diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index 4a6b8a6375311b3e13177b76e0924b6d5a635f68..0000000000000000000000000000000000000000
--- a/.editorconfig
+++ /dev/null
@@ -1,26 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_size = 2
-indent_style = space
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[vcbuild.bat]
-end_of_line = crlf
-
-[Makefile]
-indent_size = 8
-indent_style = tab
-
-[{deps}/**]
-charset = unset
-end_of_line = unset
-indent_size = unset
-indent_style = unset
-trim_trailing_whitespace = unset
-
-[{test/fixtures,deps,tools/node_modules,tools/gyp,tools/icu,tools/msvs}/**]
-insert_final_newline = false
diff --git a/.eslintignore b/.eslintignore
deleted file mode 100644
index bdfdfaeab2388d2650d1b32ab44cc8abecfabc8a..0000000000000000000000000000000000000000
--- a/.eslintignore
+++ /dev/null
@@ -1,12 +0,0 @@
-node_modules
-lib/internal/v8_prof_polyfill.js
-lib/punycode.js
-test/addons/??_*
-test/fixtures
-test/message/esm_display_syntax_error.mjs
-tools/icu
-tools/lint-md.js
-tools/node-lint-md-cli-rollup/dist
-benchmark/tmp
-doc/**/*.js
-!.eslintrc.js
diff --git a/.eslintrc.js b/.eslintrc.js
deleted file mode 100644
index 2ad6cc199cedf7c74bd8f61aef18eb8d8e6b435e..0000000000000000000000000000000000000000
--- a/.eslintrc.js
+++ /dev/null
@@ -1,294 +0,0 @@
-'use strict';
-
-/* eslint-env node */
-
-const Module = require('module');
-const path = require('path');
-
-const NodePlugin = require('./tools/node_modules/eslint-plugin-node-core');
-NodePlugin.RULES_DIR = path.resolve(__dirname, 'tools', 'eslint-rules');
-
-// The Module._findPath() monkeypatching is to make it so that ESLint will work
-// if invoked by a globally-installed ESLint or ESLint installed elsewhere
-// rather than the one we ship. This makes it possible for IDEs to lint files
-// with our rules while people edit them.
-const ModuleFindPath = Module._findPath;
-const hacks = [
-  'eslint-plugin-node-core',
-  'eslint-plugin-markdown',
-  'babel-eslint',
-];
-Module._findPath = (request, paths, isMain) => {
-  const r = ModuleFindPath(request, paths, isMain);
-  if (!r && hacks.includes(request)) {
-    try {
-      return require.resolve(`./tools/node_modules/${request}`);
-    // Keep the variable in place to ensure that ESLint started by older Node.js
-    // versions work as expected.
-    // eslint-disable-next-line no-unused-vars
-    } catch (e) {
-      return require.resolve(
-        `./tools/node_modules/eslint/node_modules/${request}`);
-    }
-  }
-  return r;
-};
-
-module.exports = {
-  root: true,
-  plugins: ['markdown', 'node-core'],
-  parser: 'babel-eslint',
-  parserOptions: { sourceType: 'script' },
-  overrides: [
-    {
-      files: [
-        'doc/api/esm.md',
-        'doc/api/module.md',
-        'doc/api/modules.md',
-        'doc/api/packages.md',
-        'test/es-module/test-esm-type-flag.js',
-        'test/es-module/test-esm-type-flag-alias.js',
-        '*.mjs',
-        'test/es-module/test-esm-example-loader.js',
-      ],
-      parserOptions: { sourceType: 'module' },
-    },
-    {
-      files: ['**/*.md'],
-      parserOptions: { ecmaFeatures: { impliedStrict: true } },
-      rules: { strict: 'off' },
-    },
-  ],
-  rules: {
-    // ESLint built-in rules
-    // https://eslint.org/docs/rules/
-    'accessor-pairs': 'error',
-    'array-callback-return': 'error',
-    'arrow-parens': ['error', 'always'],
-    'arrow-spacing': ['error', { before: true, after: true }],
-    'block-scoped-var': 'error',
-    'block-spacing': 'error',
-    'brace-style': ['error', '1tbs', { allowSingleLine: true }],
-    'capitalized-comments': ['error', 'always', {
-      line: {
-        // Ignore all lines that have less characters than 20 and all lines that
-        // start with something that looks like a variable name or code.
-        // eslint-disable-next-line max-len
-        ignorePattern: '.{0,20}$|[a-z]+ ?[0-9A-Z_.(/=:[#-]|std|http|ssh|ftp|(let|var|const) [a-z_A-Z0-9]+ =|[b-z] |[a-z]*[0-9].* ',
-        ignoreInlineComments: true,
-        ignoreConsecutiveComments: true,
-      },
-      block: {
-        ignorePattern: '.*',
-      },
-    }],
-    'comma-dangle': ['error', 'only-multiline'],
-    'comma-spacing': 'error',
-    'comma-style': 'error',
-    'computed-property-spacing': 'error',
-    'constructor-super': 'error',
-    'default-case-last': 'error',
-    'dot-location': ['error', 'property'],
-    'dot-notation': 'error',
-    'eol-last': 'error',
-    'eqeqeq': ['error', 'smart'],
-    'for-direction': 'error',
-    'func-call-spacing': 'error',
-    'func-name-matching': 'error',
-    'func-style': ['error', 'declaration', { allowArrowFunctions: true }],
-    'getter-return': 'error',
-    'indent': ['error', 2, {
-      ArrayExpression: 'first',
-      CallExpression: { arguments: 'first' },
-      FunctionDeclaration: { parameters: 'first' },
-      FunctionExpression: { parameters: 'first' },
-      MemberExpression: 'off',
-      ObjectExpression: 'first',
-      SwitchCase: 1,
-    }],
-    'key-spacing': ['error', { mode: 'strict' }],
-    'keyword-spacing': 'error',
-    'linebreak-style': ['error', 'unix'],
-    'max-len': ['error', {
-      code: 80,
-      ignorePattern: '^// Flags:',
-      ignoreRegExpLiterals: true,
-      ignoreUrls: true,
-      tabWidth: 2,
-    }],
-    'new-parens': 'error',
-    'no-async-promise-executor': 'error',
-    'no-class-assign': 'error',
-    'no-confusing-arrow': 'error',
-    'no-const-assign': 'error',
-    'no-constructor-return': 'error',
-    'no-control-regex': 'error',
-    'no-debugger': 'error',
-    'no-delete-var': 'error',
-    'no-dupe-args': 'error',
-    'no-dupe-class-members': 'error',
-    'no-dupe-keys': 'error',
-    'no-dupe-else-if': 'error',
-    'no-duplicate-case': 'error',
-    'no-duplicate-imports': 'error',
-    'no-else-return': ['error', { allowElseIf: true }],
-    'no-empty-character-class': 'error',
-    'no-ex-assign': 'error',
-    'no-extra-boolean-cast': 'error',
-    'no-extra-parens': ['error', 'functions'],
-    'no-extra-semi': 'error',
-    'no-fallthrough': 'error',
-    'no-func-assign': 'error',
-    'no-global-assign': 'error',
-    'no-invalid-regexp': 'error',
-    'no-irregular-whitespace': 'error',
-    'no-lonely-if': 'error',
-    'no-misleading-character-class': 'error',
-    'no-mixed-requires': 'error',
-    'no-mixed-spaces-and-tabs': 'error',
-    'no-multi-spaces': ['error', { ignoreEOLComments: true }],
-    'no-multiple-empty-lines': ['error', { max: 2, maxEOF: 0, maxBOF: 0 }],
-    'no-new-require': 'error',
-    'no-new-symbol': 'error',
-    'no-obj-calls': 'error',
-    'no-octal': 'error',
-    'no-path-concat': 'error',
-    'no-proto': 'error',
-    'no-redeclare': ['error', { 'builtinGlobals': false }],
-    'no-restricted-modules': ['error', 'sys'],
-    /* eslint-disable max-len */
-    'no-restricted-properties': [
-      'error',
-      {
-        object: 'assert',
-        property: 'deepEqual',
-        message: 'Use `assert.deepStrictEqual()`.',
-      },
-      {
-        object: 'assert',
-        property: 'notDeepEqual',
-        message: 'Use `assert.notDeepStrictEqual()`.',
-      },
-      {
-        object: 'assert',
-        property: 'equal',
-        message: 'Use `assert.strictEqual()` rather than `assert.equal()`.',
-      },
-      {
-        object: 'assert',
-        property: 'notEqual',
-        message: 'Use `assert.notStrictEqual()` rather than `assert.notEqual()`.',
-      },
-      {
-        property: '__defineGetter__',
-        message: '__defineGetter__ is deprecated.',
-      },
-      {
-        property: '__defineSetter__',
-        message: '__defineSetter__ is deprecated.',
-      },
-    ],
-    // If this list is modified, please copy changes that should apply to ./lib
-    // as well to lib/.eslintrc.yaml.
-    'no-restricted-syntax': [
-      'error',
-      {
-        selector: "CallExpression[callee.name='setTimeout'][arguments.length<2]",
-        message: '`setTimeout()` must be invoked with at least two arguments.',
-      },
-      {
-        selector: "CallExpression[callee.name='setInterval'][arguments.length<2]",
-        message: '`setInterval()` must be invoked with at least two arguments.',
-      },
-      {
-        selector: 'ThrowStatement > CallExpression[callee.name=/Error$/]',
-        message: 'Use `new` keyword when throwing an `Error`.',
-      },
-      {
-        selector: "CallExpression[callee.name='isNaN']",
-        message: 'Use Number.isNaN() instead of the global isNaN() function.',
-      },
-    ],
-    /* eslint-enable max-len */
-    'no-return-await': 'error',
-    'no-self-assign': 'error',
-    'no-self-compare': 'error',
-    'no-setter-return': 'error',
-    'no-shadow-restricted-names': 'error',
-    'no-tabs': 'error',
-    'no-template-curly-in-string': 'error',
-    'no-this-before-super': 'error',
-    'no-throw-literal': 'error',
-    'no-trailing-spaces': 'error',
-    'no-undef': ['error', { typeof: true }],
-    'no-undef-init': 'error',
-    'no-unexpected-multiline': 'error',
-    'no-unreachable': 'error',
-    'no-unsafe-finally': 'error',
-    'no-unsafe-negation': 'error',
-    'no-unused-labels': 'error',
-    'no-unused-vars': ['error', { args: 'none', caughtErrors: 'all' }],
-    'no-use-before-define': ['error', {
-      classes: true,
-      functions: false,
-      variables: false,
-    }],
-    'no-useless-backreference': 'error',
-    'no-useless-call': 'error',
-    'no-useless-catch': 'error',
-    'no-useless-concat': 'error',
-    'no-useless-constructor': 'error',
-    'no-useless-escape': 'error',
-    'no-useless-return': 'error',
-    'no-void': 'error',
-    'no-whitespace-before-property': 'error',
-    'no-with': 'error',
-    'object-curly-spacing': ['error', 'always'],
-    'one-var': ['error', { initialized: 'never' }],
-    'one-var-declaration-per-line': 'error',
-    'operator-linebreak': ['error', 'after'],
-    'padding-line-between-statements': [
-      'error',
-      { blankLine: 'always', prev: 'function', next: 'function' },
-    ],
-    'prefer-const': ['error', { ignoreReadBeforeAssign: true }],
-    'quotes': ['error', 'single', { avoidEscape: true }],
-    'quote-props': ['error', 'consistent'],
-    'rest-spread-spacing': 'error',
-    'semi': 'error',
-    'semi-spacing': 'error',
-    'space-before-blocks': ['error', 'always'],
-    'space-before-function-paren': ['error', {
-      anonymous: 'never',
-      named: 'never',
-      asyncArrow: 'always',
-    }],
-    'space-in-parens': ['error', 'never'],
-    'space-infix-ops': 'error',
-    'space-unary-ops': 'error',
-    'spaced-comment': ['error', 'always', {
-      'block': { 'balanced': true },
-      'exceptions': ['-'],
-    }],
-    'strict': ['error', 'global'],
-    'symbol-description': 'error',
-    'template-curly-spacing': 'error',
-    'unicode-bom': 'error',
-    'use-isnan': 'error',
-    'valid-typeof': 'error',
-
-    // Custom rules from eslint-plugin-node-core
-    'node-core/no-unescaped-regexp-dot': 'error',
-    'node-core/no-duplicate-requires': 'error',
-  },
-  globals: {
-    Atomics: 'readable',
-    BigInt: 'readable',
-    BigInt64Array: 'readable',
-    BigUint64Array: 'readable',
-    TextEncoder: 'readable',
-    TextDecoder: 'readable',
-    queueMicrotask: 'readable',
-    globalThis: 'readable',
-  },
-};
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
deleted file mode 100644
index e5da96e405628a61f98923ebbc0fe4dd29f25413..0000000000000000000000000000000000000000
--- a/.github/CODEOWNERS
+++ /dev/null
@@ -1,101 +0,0 @@
-# Node.js Project Codeowners
-
-# 1. Codeowners must always be teams, never individuals
-# 2. Each codeowner team should contain at least one TSC member
-# 3. PRs touching any code with a codeowner must be signed off by at least one
-#    person on the code owner team.
-
-# tsc & commcomm
-
-/.github/CODEOWNERS @nodejs/tsc
-/GOVERNANCE.md @nodejs/tsc
-/onboarding.md @nodejs/tsc
-/CODE_OF_CONDUCT.md @nodejs/tsc @nodejs/community-committee
-/CONTRIBUTING.md @nodejs/tsc @nodejs/community-committee
-/LICENSE @nodejs/tsc @nodejs/community-committee
-/doc/guides/contributing/code-of-conduct.md @nodejs/tsc @nodejs/community-committee
-# TODO(mmarchini): the bot doens't have a notion of precedence, that might
-# change when move the codeowners code to an Action, at which point we can
-# uncomment the line below
-# /doc/guides/contributing/*.md @nodejs/tsc
-/doc/guides/contributing/issues.md @nodejs/tsc
-/doc/guides/contributing/pull-requests.md @nodejs/tsc
-/doc/guides/collaborator-guide.md @nodejs/tsc
-/doc/guides/offboarding.md @nodejs/tsc
-/doc/guides/onboarding-extras.md @nodejs/tsc
-
-# net
-
-/deps/cares @nodejs/net
-/doc/api/dns.md @nodejs/net
-/doc/api/dgram.md @nodejs/net
-/doc/api/net.md @nodejs/net
-/lib/dgram.js @nodejs/net
-/lib/dns.js @nodejs/net
-/lib/net.js @nodejs/net @nodejs/quic
-/lib/internal/dgram.js @nodejs/net
-/lib/internal/dns/* @nodejs/net
-/lib/internal/net.js @nodejs/net
-/lib/internal/socket_list.js @nodejs/net
-/lib/internal/js_stream_socket.js @nodejs/net
-/src/cares_wrap.h @nodejs/net
-/src/connect_wrap.* @nodejs/net
-/src/connection_wrap.* @nodejs/net
-/src/node_sockaddr* @nodejs/net
-/src/tcp_wrap.* @nodejs/net
-/src/udp_wrap.* @nodejs/net
-
-# tls/crypto
-
-/lib/internal/crypto/* @nodejs/crypto
-/lib/internal/tls.js @nodejs/crypto @nodejs/net
-/lib/crypto.js @nodejs/crypto
-/lib/tls.js @nodejs/crypto @nodejs/net
-/src/node_crypto* @nodejs/crypto
-/src/node_crypto_common* @nodejs/crypto @nodejs/quic
-
-# http
-
-/deps/llhttp/* @nodejs/http @nodejs/net
-/doc/api/http.md @nodejs/http @nodejs/net
-/doc/api/http2.md @nodejs/http @nodejs/net
-/lib/_http_* @nodejs/http @nodejs/net
-/lib/http.js @nodejs/http @nodejs/net
-/lib/https.js @nodejs/crypto @nodejs/net @nodejs/http
-/src/node_http_common* @nodejs/http @nodejs/http2 @nodejs/quic @nodejs/net
-/src/node_http_parser.cc @nodejs/http @nodejs/net
-
-# http2
-
-/deps/nghttp2/* @nodejs/http2 @nodejs/net
-/doc/api/http2.md @nodejs/http2 @nodejs/net
-/lib/http2.js @nodejs/http2 @nodejs/net
-/lib/internal/http2/* @nodejs/http2 @nodejs/net
-/src/node_http2* @nodejs/http2 @nodejs/net
-/src/node_mem* @nodejs/http2
-
-# modules
-
-/doc/api/modules.md @nodejs/modules
-/doc/api/esm.md @nodejs/modules
-/doc/api/module.md @nodejs/modules
-/doc/api/packages.md @nodejs/modules
-/lib/module.js @nodejs/modules
-/lib/internal/modules/* @nodejs/modules
-/lib/internal/bootstrap/loaders.js @nodejs/modules
-/src/module_wrap* @nodejs/modules @nodejs/vm
-
-# N-API
-
-/src/node_api* @nodejs/n-api
-/src/js_native_api* @nodejs/n-api
-/doc/guides/adding-new-napi-api.md @nodejs/n-api
-/doc/api/n-api.md @nodejs/n-api
-
-# WASI
-/deps/uvwasi/ @nodejs/wasi
-/doc/api/wasi.md @nodejs/wasi
-/lib/wasi.js @nodejs/wasi
-/src/node_wasi* @nodejs/wasi
-/test/wasi/ @nodejs/wasi
-/test/fixtures/wasi/ @nodejs/wasi
diff --git a/.github/ISSUE_TEMPLATE/1-bug-report.md b/.github/ISSUE_TEMPLATE/1-bug-report.md
deleted file mode 100644
index 2a2e94d411fe2a26488cf7d932cbb91301fa6764..0000000000000000000000000000000000000000
--- a/.github/ISSUE_TEMPLATE/1-bug-report.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-name: "\U0001F41B Bug report"
-about: Create a report to help us improve
-
----
-
-<!--
-Thank you for reporting an issue.
-
-This issue tracker is for bugs and issues found within Node.js core.
-If you require more general support please file an issue on our help
-repo. https://github.com/nodejs/help
-
-
-Please fill in as much of the template below as you're able.
-
-Version: output of `node -v`
-Platform: output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows)
-Subsystem: if known, please specify affected core module name
--->
-
-* **Version**:
-* **Platform**:
-* **Subsystem**:
-
-### What steps will reproduce the bug?
-
-<!--
-Enter details about your bug, preferably a simple code snippet that can be
-run using `node` directly without installing third-party dependencies.
--->
-
-### How often does it reproduce? Is there a required condition?
-
-### What is the expected behavior?
-
-<!--
-If possible please provide textual output instead of screenshots.
--->
-
-### What do you see instead?
-
-<!--
-If possible please provide textual output instead of screenshots.
--->
-
-### Additional information
-
-<!--
-Tell us anything else you think we should know.
--->
diff --git a/.github/ISSUE_TEMPLATE/2-feature-request.md b/.github/ISSUE_TEMPLATE/2-feature-request.md
deleted file mode 100644
index 0d40bfdd110b931bc1a60de72a8aaee2bb895a2c..0000000000000000000000000000000000000000
--- a/.github/ISSUE_TEMPLATE/2-feature-request.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-name: "\U0001F680 Feature request"
-about: Suggest an idea for this project
-
----
-
-<!--
-Thank you for suggesting an idea to make Node.js better.
-
-Please fill in as much of the template below as you're able.
--->
-
-**Is your feature request related to a problem? Please describe.**
-Please describe the problem you are trying to solve.
-
-**Describe the solution you'd like**
-Please describe the desired behavior.
-
-**Describe alternatives you've considered**
-Please describe alternative solutions or features you have considered.
diff --git a/.github/ISSUE_TEMPLATE/3-api-ref-docs-problem.md b/.github/ISSUE_TEMPLATE/3-api-ref-docs-problem.md
deleted file mode 100644
index f63d540abaf4e2f62323fded5c70df48f59ac48f..0000000000000000000000000000000000000000
--- a/.github/ISSUE_TEMPLATE/3-api-ref-docs-problem.md
+++ /dev/null
@@ -1,77 +0,0 @@
----
-name: "\U0001F4D7 Open an issue regarding the Node.js API reference docs"
-about: Let us know about any problematic API reference documents
-title: "doc: "
-labels: doc
----
-
-# 📗 API Reference Docs Problem
-
-<!--
-
-Thank you for wanting to make nodejs.org better!
-
-This template is for issues with the Node.js API
-reference documentation.
-
-For problems with nodejs.org beyond the API
-reference documentation, please open an issue
-using the issue tracker for our site repository.
-
-  https://github.com/nodejs/nodejs.org
-
-For more general support, please open an issue
-using the issue tracker for our help repository.
-
-  https://github.com/nodejs/help
-
----
-
-For the issue title, please enter a one-line
-summary after “doc: ” (preferably 50 characters
-or less and no more than 72).
-
-The “✍️” are placeholders signifying requests for
-input. Replace them with your responses.
-
-If you are unsure of something, do your best.
-
--->
-
-<!-- The output of “node --version”. -->
-
-- **Version**: ✍️
-
-<!-- The output of “uname -a” (UNIX) or version
-and 32-bit or 64-bit (Windows). -->
-
-- **Platform**: ✍️
-
-<!-- The name of affected core module. -->
-
-- **Subsystem**: ✍️
-
-## Location
-
-_Section of the site where the content exists_
-
-Affected URL(s):
-
-- https://nodejs.org/api/✍️
-
-## Description
-
-_Concise explanation of the problem_
-
-<!-- If applicable, include any screenshots that
-may help solve the problem. -->
-
-✍️
-
----
-
-<!-- Use “[x]” to check the box below if you are
-interested in contributing. -->
-
-- [ ] I would like to work on this issue and
-      submit a pull request.
diff --git a/.github/ISSUE_TEMPLATE/4-report-a-flaky-test.md b/.github/ISSUE_TEMPLATE/4-report-a-flaky-test.md
deleted file mode 100644
index 544c9d5f47b0f5965c7fb97161717c1bcd69dec6..0000000000000000000000000000000000000000
--- a/.github/ISSUE_TEMPLATE/4-report-a-flaky-test.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-name: Report a flaky test
-about: Report a flaky test in our CI
-labels: "CI / flaky test"
-
----
-
-<!--
-Thank you for reporting a flaky test.
-
-Flaky tests are tests that fail occasionally in the Node.js CI, but not
-consistently enough to block PRs from landing, or that are failing in CI jobs or
-test modes that are not run for every PR.
-
-Please fill in as much of the template below as you're able.
-
-Test: The test that is flaky - e.g. `test-fs-stat-bigint`
-Platform: The platform the test is flaky on - e.g. `macos` or `linux`
-Console Output: A pasted console output from a failed CI job showing the whole
-failure of the test
-Build Links: Links to builds affected by the flaky test
-
-If any investigation has been done, please include any information found, such
-as how consistently the test fails, whether the failure could be reproduced
-locally, when the test started failing, or anything else you think is relevant.
--->
-
-* **Test**:
-* **Platform**:
-* **Console Output:**
-```
-REPLACE ME
-```
-* **Build Links**:
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
deleted file mode 100644
index 428bbf678a34c3eaead4a60264bfba9814aa6903..0000000000000000000000000000000000000000
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: ⁉️ Need help with Node.js?
-    url: https://github.com/nodejs/help
-    about: Please file an issue in our help repo.
-  - name: 🌐 Found a problem with nodejs.org beyond the API reference docs?
-    url: https://github.com/nodejs/nodejs.org/issues/new/choose
-    about: Please file an issue in the Node.js website repo.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
deleted file mode 100644
index 66efca5cd000e71f00e0ad3421fd16fe7364bc03..0000000000000000000000000000000000000000
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ /dev/null
@@ -1,44 +0,0 @@
-<!--
-Thank you for your pull request. Please provide a description above and review
-the requirements below.
-
-Bug fixes and new features should include tests and possibly benchmarks.
-
-Contributors guide: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
--->
-
-##### Checklist
-<!-- Remove items that do not apply. For completed items, change [ ] to [x]. -->
-
-- [ ] `make -j4 test` (UNIX), or `vcbuild test` (Windows) passes
-- [ ] tests and/or benchmarks are included
-- [ ] documentation is changed or added
-- [ ] commit message follows [commit guidelines](https://github.com/nodejs/node/blob/master/doc/guides/contributing/pull-requests.md#commit-message-guidelines)
-
-<!--
-Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-(a) The contribution was created in whole or in part by me and I
-    have the right to submit it under the open source license
-    indicated in the file; or
-
-(b) The contribution is based upon previous work that, to the best
-    of my knowledge, is covered under an appropriate open source
-    license and I have the right under that license to submit that
-    work with modifications, whether created in whole or in part
-    by me, under the same open source license (unless I am
-    permitted to submit under a different license), as indicated
-    in the file; or
-
-(c) The contribution was provided directly to me by some other
-    person who certified (a), (b) or (c) and I have not modified
-    it.
-
-(d) I understand and agree that this project and the contribution
-    are public and that a record of the contribution (including all
-    personal information I submit with it, including my sign-off) is
-    maintained indefinitely and may be redistributed consistent with
-    this project or the open source license(s) involved.
--->
diff --git a/.github/SUPPORT.md b/.github/SUPPORT.md
deleted file mode 100644
index d3af8e681917a0daadd08ebc8354e67f0e203aee..0000000000000000000000000000000000000000
--- a/.github/SUPPORT.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Support
-
-Node.js contributors have limited availability to address general support
-questions. Please make sure you are using a [currently-supported version of
-Node.js](https://github.com/nodejs/Release#release-schedule).
-
-When looking for support, please first search for your question in these venues:
-
-* [Node.js Website](https://nodejs.org/en/), especially the
-  [API docs](https://nodejs.org/api/)
-* [Node.js Help](https://github.com/nodejs/help)
-* [Open or closed issues in the Node.js GitHub organization](https://github.com/issues?utf8=%E2%9C%93&q=sort%3Aupdated-desc+org%3Anodejs+is%3Aissue)
-
-If you didn't find an answer in the resources above, try these unofficial
-resources:
-
-* [Questions tagged 'node.js' on Stack Overflow](https://stackoverflow.com/questions/tagged/node.js)
-* [#nodejs](https://openjs-foundation.slack.com/archives/CK9Q4MB53) channel on the OpenJS Foundation Slack ([join here](https://slack-invite.openjsf.org/))
-* [#node.js channel on chat.freenode.net](https://webchat.freenode.net?channels=node.js&uio=d4)
-* [Node.js Slack Community](https://node-js.slack.com/)
-  * To register: [nodeslackers.com](https://www.nodeslackers.com/)
-
-GitHub issues are for tracking enhancements and bugs, not general support.
-
-The open source license grants you the freedom to use Node.js. It does not
-guarantee commitments of other people's time. Please be respectful and manage
-your expectations.
diff --git a/.github/workflows/auto-start-ci.yml b/.github/workflows/auto-start-ci.yml
deleted file mode 100644
index cb9318ab4ade9f7bdd5c5d920c565280749093d6..0000000000000000000000000000000000000000
--- a/.github/workflows/auto-start-ci.yml
+++ /dev/null
@@ -1,63 +0,0 @@
----
-name: Auto Start CI
-
-on:
-  schedule:
-    # Runs every five minutes (fastest the scheduler can run). Five minutes is
-    # optimistic, it can take longer to run.
-    # To understand why `schedule` is used instead of other events, refer to
-    # ./doc/guides/commit-queue.md
-    - cron: "*/5 * * * *"
-
-jobs:
-  startCI:
-    if: github.repository == 'nodejs/node'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-
-      # Install dependencies
-      - name: Install jq
-        run: sudo apt-get install jq -y
-      - name: Install Node.js
-        uses: actions/setup-node@v2-beta
-        with:
-          node-version: '12'
-      - name: Install node-core-utils
-        run: npm install -g node-core-utils
-
-      - name: Set variables
-        run: |
-          echo "::set-env name=REPOSITORY::$(echo ${{ github.repository }} | cut -d/ -f2)"
-          echo "::set-env name=OWNER::${{ github.repository_owner }}"
-
-      # Get Pull Requests
-      - name: Get Pull Requests
-        uses: octokit/graphql-action@v2.x
-        id: get_prs_for_ci
-        with:
-          query: |
-            query prs($owner:String!, $repo:String!) {
-              repository(owner:$owner, name:$repo) {
-                pullRequests(labels: ["request-ci"], states: OPEN, last: 100) {
-                  nodes {
-                    number
-                  }
-                }
-              }
-            }
-          owner: ${{ env.OWNER }}
-          repo: ${{ env.REPOSITORY }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Setup node-core-utils
-        run: |
-          ncu-config set username ${{ secrets.JENKINS_USER }}
-          ncu-config set token none
-          ncu-config set jenkins_token ${{ secrets.JENKINS_TOKEN }}
-          ncu-config set owner ${{ env.OWNER }}
-          ncu-config set repo ${{ env.REPOSITORY }}
-
-      - name: Start CI
-        run: ./tools/actions/start-ci.sh ${{ secrets.GITHUB_TOKEN }} ${{ env.OWNER }} ${{ env.REPOSITORY }} $(echo '${{ steps.get_prs_for_ci.outputs.data }}' | jq '.repository.pullRequests.nodes | map(.number) | .[]')
diff --git a/.github/workflows/build-windows.yml b/.github/workflows/build-windows.yml
deleted file mode 100644
index 7d7a8167308960a87efb054f326c57350837b96b..0000000000000000000000000000000000000000
--- a/.github/workflows/build-windows.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: build-windows
-
-on: [push, pull_request]
-
-env:
-  PYTHON_VERSION: 2.7
-  FLAKY_TESTS: dontcare
-
-jobs:
-  build-windows:
-    runs-on: windows-2016
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v1
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Install deps
-        run: choco install nasm
-      - name: Environment Information
-        run: npx envinfo
-      - name: Build
-        run: ./vcbuild.bat
diff --git a/.github/workflows/close-stalled.yml b/.github/workflows/close-stalled.yml
deleted file mode 100644
index 1834d3ac2e681536750e2bf7fefcb05333860c47..0000000000000000000000000000000000000000
--- a/.github/workflows/close-stalled.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-name: Close stalled issues and PRs
-on:
-  schedule:
-  - cron: "0 0 * * *"
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/stale@v3
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        days-before-close: 30
-        stale-pr-label: stalled
-        stale-issue-label: stalled
-        close-issue-message: Closing this because it has stalled. Feel free to reopen if this issue is still relevant, or to ping the collaborator who labelled it stalled if you have any questions.
-        close-pr-message: Closing this because it has stalled. Feel free to reopen if this PR is still relevant, or to ping the collaborator who labelled it stalled if you have any questions.
-        # used to filter issues to check whether or not should be closed, avoids hitting maximum operations allowed if needing to paginate through all open issues
-        only-labels: stalled
-        # max requests it will send per run to the GitHub API before it deliberately exits to avoid hitting API rate limits
-        operations-per-run: 500
-        # deactivates automatic removal of stalled label if issue gets any activity
-        remove-stale-when-updated: false
-        # deactivates automatic stale labelling as we prefer to do that manually
-        days-before-stale: -1
diff --git a/.github/workflows/comment-stalled.yml b/.github/workflows/comment-stalled.yml
deleted file mode 100644
index 62bd26f39eb72d9497f399fc19f8db4383afad11..0000000000000000000000000000000000000000
--- a/.github/workflows/comment-stalled.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-name: Comment on issues and PRs when labelled stalled
-on:
-  issues:
-    types: [labeled]
-  pull_request_target:
-    types: [labeled]
-
-jobs:
-  staleComment:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Post comment
-        if: github.event.label.name == 'stalled'
-        env:
-            COMMENTS_URL: ${{ github.event.issue.comments_url || github.event.pull_request.comments_url }}
-        run: |
-          curl -X POST $COMMENTS_URL \
-          -H "Content-Type: application/json" \
-          -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
-          --data '{ "body": "This issue/PR was marked as stalled, it will be automatically closed in 30 days. If it should remain open, please leave a comment explaining why it should remain open." }'
diff --git a/.github/workflows/commit-queue.yml b/.github/workflows/commit-queue.yml
deleted file mode 100644
index 6f4affe656c9a179ba08c3ba20ceee1f88b175c8..0000000000000000000000000000000000000000
--- a/.github/workflows/commit-queue.yml
+++ /dev/null
@@ -1,79 +0,0 @@
----
-# This action requires the following secrets to be set on the repository:
-#   GH_USER_NAME: GitHub user whose Jenkins and GitHub token are defined below
-#   GH_USER_TOKEN: GitHub user token, to be used by ncu and to push changes
-#   JENKINS_TOKEN: Jenkins token, to be used to check CI status
-
-name: Commit Queue
-
-on:
-  # `schedule` event is used instead of `pull_request` because when a
-  # `pull_request` event is triggered on a PR from a fork, GITHUB_TOKEN will
-  # be read-only, and the Action won't have access to any other repository
-  # secrets, which it needs to access Jenkins API.
-  schedule:
-    - cron: "*/5 * * * *"
-
-jobs:
-  commitQueue:
-    if: github.repository == 'nodejs/node'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          # A personal token is required because pushing with GITHUB_TOKEN will
-          # prevent commits from running CI after they land on master. It needs
-          # to be set here because `checkout` configures GitHub authentication
-          # for push as well.
-          token: ${{ secrets.GH_USER_TOKEN }}
-
-      # Install dependencies
-      - name: Install Node.js
-        uses: actions/setup-node@v2-beta
-        with:
-          node-version: '12'
-      - name: Install dependencies
-        run: |
-          sudo apt-get install jq -y
-          npm install -g node-core-utils@latest
-
-      - name: Set variables
-        run: |
-          echo "::set-env name=REPOSITORY::$(echo ${{ github.repository }} | cut -d/ -f2)"
-          echo "::set-env name=OWNER::${{ github.repository_owner }}"
-
-      - name: Get Pull Requests
-        uses: octokit/graphql-action@v2.x
-        id: get_mergable_pull_requests
-        with:
-          query: |
-            query release($owner:String!,$repo:String!, $base_ref:String!) {
-              repository(owner:$owner, name:$repo) {
-                pullRequests(baseRefName: $base_ref, labels: ["commit-queue"], states: OPEN, last: 100) {
-                  nodes {
-                    number
-                  }
-                }
-              }
-            }
-          owner: ${{ env.OWNER }}
-          repo: ${{ env.REPOSITORY }}
-          # Commit queue is only enabled for the default branch on the repository
-          # TODO(mmarchini): get the default branch programmatically instead of
-          # assuming `master`
-          base_ref: "master"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Configure node-core-utils
-        run: |
-          ncu-config set branch master
-          ncu-config set upstream origin
-          ncu-config set username "${{ secrets.GH_USER_NAME }}"
-          ncu-config set token "${{ secrets.GH_USER_TOKEN }}"
-          ncu-config set jenkins_token "${{ secrets.JENKINS_TOKEN }}"
-          ncu-config set repo "${{ env.REPOSITORY }}"
-          ncu-config set owner "${{ env.OWNER }}"
-
-      - name: Start the commit queue
-        run: ./tools/actions/commit-queue.sh ${{ env.OWNER }} ${{ env.REPOSITORY }} ${{ secrets.GITHUB_TOKEN }} $(echo '${{ steps.get_mergable_pull_requests.outputs.data }}' | jq '.repository.pullRequests.nodes | map(.number) | .[]')
diff --git a/.github/workflows/linters.yml b/.github/workflows/linters.yml
deleted file mode 100644
index 4453db5c751c7fc257aaf1645c6690115ee71c40..0000000000000000000000000000000000000000
--- a/.github/workflows/linters.yml
+++ /dev/null
@@ -1,73 +0,0 @@
-name: linters
-
-on: [push, pull_request]
-
-env:
-  PYTHON_VERSION: 3.8
-  NODE_VERSION: 10.x
-
-jobs:
-  lint-addon-docs:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v1
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - name: Environment Information
-        run: npx envinfo
-      - name: Lint addon docs
-        run: NODE=$(which node) make lint-addon-docs
-  lint-cpp:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v1
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Environment Information
-        run: npx envinfo
-      - name: Lint C/C++ files
-        run: make lint-cpp
-  lint-md:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v1
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - name: Environment Information
-        run: npx envinfo
-      - name: Lint docs
-        run: |
-          echo "::add-matcher::.github/workflows/remark-lint-problem-matcher.json"
-          NODE=$(which node) make lint-md
-  lint-js:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v1
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - name: Environment Information
-        run: npx envinfo
-      - name: Lint JavaScript files
-        run: NODE=$(which node) make lint-js
-  lint-py:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v1
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Environment Information
-        run: npx envinfo
-      - name: Lint Python
-        run: |
-          make lint-py-build || true
-          NODE=$(which node) make lint-py
diff --git a/.github/workflows/misc.yml b/.github/workflows/misc.yml
deleted file mode 100644
index 6161326b93865a702694ba569164dd63f634804e..0000000000000000000000000000000000000000
--- a/.github/workflows/misc.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-name: misc
-
-on: [push, pull_request]
-
-env:
-  NODE_VERSION: 12.x
-
-jobs:
-  build-docs:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v1
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - name: Environment Information
-        run: npx envinfo
-      - name: Build
-        run: NODE=$(which node) make doc-only
-      - uses: actions/upload-artifact@v1
-        with:
-          name: docs
-          path: out/doc
-      - name: Check links
-        run: node tools/doc/checkLinks.js .
diff --git a/.github/workflows/pythonpackage.yml b/.github/workflows/pythonpackage.yml
deleted file mode 100644
index 9ff5e9a39d81fac26564094065a3aef7ba190ddf..0000000000000000000000000000000000000000
--- a/.github/workflows/pythonpackage.yml
+++ /dev/null
@@ -1,33 +0,0 @@
-name: Python 3 testing
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      max-parallel: 1
-      matrix:
-        python-version: [3.8]  # [2.7, 3.5, 3.6, 3.7]
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v1
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Compile Node.js
-      run: |
-        python ./configure.py
-        make -j2 V=1
-    - name: Test JS Suites
-      run: |
-        python tools/test.py -j 2 -p dots --report --mode=release --flaky-tests=dontcare default
-    - name: Test C++ Suites
-      run: |
-        make -j1 V=1 test/addons/.buildstamp test/js-native-api/.buildstamp test/node-api/.buildstamp
-        python tools/test.py -j 2 -p dots --report --mode=release --flaky-tests=dontcare addons js-native-api node-api
-    - name: Make lint
-      run: |
-        make lint-py-build || true
-        NODE=$(which node) make lint lint-py
diff --git a/.github/workflows/remark-lint-problem-matcher.json b/.github/workflows/remark-lint-problem-matcher.json
deleted file mode 100644
index cfb281310a9a0f14ebcf6e1c150cf3fbe71f80b0..0000000000000000000000000000000000000000
--- a/.github/workflows/remark-lint-problem-matcher.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-  "problemMatcher": [
-    {
-      "owner": "remark-lint",
-      "pattern": [
-        {
-          "regexp": "^(?:\\x1b\\[\\d+m)*(.+?)(?:\\x1b\\[\\d+m)*$",
-          "file": 1
-        },
-        {
-          "regexp": "^\\s+(?:\\d+:\\d+-)?(\\d+):(\\d+)\\s+\\S*(error|warning|info)\\S*\\s+(.+)\\s+(\\S+)\\s+(?:\\S+)$",
-          "line": 1,
-          "column": 2,
-          "severity": 3,
-          "message": 4,
-          "code": 5,
-          "loop": true
-        }
-      ]
-    }
-  ]
-}
diff --git a/.github/workflows/test-linux.yml b/.github/workflows/test-linux.yml
deleted file mode 100644
index bec9884f6c837c5ff9eeb96f2d1fba92abca2e97..0000000000000000000000000000000000000000
--- a/.github/workflows/test-linux.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: test-linux
-
-on: [push, pull_request]
-
-env:
-  PYTHON_VERSION: 2.7
-  FLAKY_TESTS: dontcare
-
-jobs:
-  test-linux:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v1
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Environment Information
-        run: npx envinfo
-      - name: Build
-        run: make build-ci -j2 V=1
-      - name: Test
-        run: make run-ci -j2 V=1 TEST_CI_ARGS="-p dots"
diff --git a/.github/workflows/test-macos.yml b/.github/workflows/test-macos.yml
deleted file mode 100644
index b9794bde31b45a4d13d98f4eb648a4936999f5ba..0000000000000000000000000000000000000000
--- a/.github/workflows/test-macos.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: test-macOS
-
-on: [push, pull_request]
-
-env:
-  PYTHON_VERSION: 2.7
-  FLAKY_TESTS: dontcare
-
-jobs:
-  test-macOS:
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v1
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Environment Information
-        run: npx envinfo
-      - name: Build
-        run: make build-ci -j8 V=1
-      - name: Test
-        run: make run-ci -j8 V=1 TEST_CI_ARGS="-p dots"
diff --git a/.mailmap b/.mailmap
deleted file mode 100644
index 4597ae9e47f61ddd4977b1518cddc22cbf2d7538..0000000000000000000000000000000000000000
--- a/.mailmap
+++ /dev/null
@@ -1,471 +0,0 @@
-Aaron Bieber <aaron@bolddaemon.com> <deftly@gmail.com>
-Aaron Heckmann <aaron.heckmann@gmail.com> <aaron.heckmann+github@gmail.com>
-Aayush Ahuja <aayush.a@directi.com> aayush.a <aayush.a@directi.com>
-Abe Fettig <abefettig@gmail.com> <abe@fettig.net>
-Abhimanyu Vashisht <abhimanyuvashisht.av@gmail.com>
-Akito Ito <akito0107@gmail.com> <akito_ito@r.recruit.co.jp>
-Alejandro Estrada <estrada9166@gmail.com>
-Alejandro Estrada <estrada9166@gmail.com> <estrada9166@hotmail.com>
-Alejandro Oviedo Garcia <alejandro.oviedo.g@gmail.com> Alejandro Oviedo <alejandro.oviedo.g@gmail.com>
-Alex Gilbert <alex@punkave.com> agilbert <alex@punkave.com>
-Alex Hultman <alexhultman@gmail.com> <alexhultman@localhost.localdomain>
-Alex Jordan <alex@strugee.net> AJ Jordan <alex@strugee.net>
-Alex Kocharin <rlidwka@kocharin.ru>
-Alex Kocharin <rlidwka@kocharin.ru> <alex@kocharin.ru>
-Alexander Marchenko <axvmindaweb@gmail.com> axvm <axvmindaweb@gmail.com>
-Alexey Kupershtokh <alexey.kupershtokh@gmail.com> <wicked@alawar.com>
-Alexis Campailla <alexis@janeasystems.com> <orangemocha@github.com>
-Alexis Sellier <self@cloudhead.net>
-Alexis Sellier <self@cloudhead.net> <alexis@cloudhead.io>
-Alfred Cepeda <AlfredJCepeda@gmail.com> ALJCepeda <AlfredJCepeda@gmail.com>
-Allen Yonghuang Wang <helloshuangzi@gmail.com>
-Amery <amery@xiangfa.org> 子丶言 <amery@xiangfa.org>
-Amit Bendor <ajbendor@gmail.com>
-Anatoli Papirovski <apapirovski@mac.com> <anatoli.papirovski@postmates.com>
-Andreas Offenhaeuser <offenhaeuser@gmail.com> anoff <offenhaeuser@gmail.com>
-Andrew Hughes <Andrew.Hughes1@ibm.com> <andrew.hughes.101@outlook.com>
-Andy Bettisworth <andy.bettisworth@accreu.com>
-Angel Stoyanov <atstojanov@gmail.com> atstojanov <atstojanov@gmail.com>
-Anna Henningsen <anna@addaleax.net> <sqrt@entless.org>
-Anna Henningsen <anna@addaleax.net> <github@addaleax.net>
-Anna Magdalena Kedzierska <anna.mag.kedzierska@gmail.com> AnnaMag <AnnaMag@users.noreply.github.com>
-Antoine Amara <amara.antoine@gmail.com> Antoine AMARA <amara.antoine@gmail.com>
-Aria Stewart <aredridel@dinhe.net> <aredridel@nbtsc.org>
-Arlo Breault <arlolra@gmail.com>
-Arnaud Lefebvre <a.lefebvre@outlook.fr> BlackYoup <a.lefebvre@outlook.fr>
-Artem Zaytsev <a.arepo@gmail.com>
-Artur G Vieira <vieira.artur.g@gmail.com> Artur Vieira <vieira.artur.g@gmail.com>
-Arnout Kazemier <info@3rd-Eden.com> <3rd-Eden@users.noreply.github.com>
-Asaf David <asafdav2@gmail.com> asafdav2 <asafdav2@gmail.com>
-Ash Cripps <acripps@redhat.com> <ashley.cripps@ibm.com>
-Ash Cripps <acripps@redhat.com> <email@ashleycripps.co.uk>
-Ash Cripps <acripps@redhat.com> <Ashley.Cripps@ibm.com>
-Ashley Maceli <ashley.maceli@gmail.com> ashleyraymaceli <ashley.maceli@gmail.com>
-Ashok Suthar <coderatlabs@gmail.com>
-Ashutosh Kumar Singh <singhjug1994@gmail.com>
-Atsuo Fukaya <fukayatsu@gmail.com>
-Ben Lugavere <b.lugavere@gmail.com> blugavere <b.lugavere@gmail.com>
-Ben Noordhuis <info@bnoordhuis.nl> <bnoordhuis@bender.(none)>
-Ben Noordhuis <info@bnoordhuis.nl> <ben@strongloop.com>
-Ben Taber <ben.taber@gmail.com>
-Benjamin Coe <bencoe@gmail.com> <ben@npmjs.com>
-Benjamin Coe <bencoe@gmail.com> <bencoe@google.com>
-Benjamin Fleischer <github@benjaminfleischer.com> Benjamin Fleischer <benjamin.fleischer@swipesense.com>
-Benjamin Gruenbaum <benjamingr@gmail.com> <benji@peer5.com>
-Benjamin Gruenbaum <benjamingr@gmail.com> <inglor@gmail.com>
-Benjamin Gruenbaum <benjamingr@gmail.com> <benjamingruenbaum@Benjamins-MacBook-Pro.local>
-Benjamin Waters <benjamin.waters@outlook.com> <ben25890@gmail.com>
-Bert Belder <bertbelder@gmail.com> <bert@piscisaureus2.(none)>
-Bert Belder <bertbelder@gmail.com> <info@2bs.nl>
-Bert Belder <bertbelder@gmail.com> <piscisaureus@Berts-MacBook-Pro.local>
-Beth Griggs <bgriggs@redhat.com> Beth Griggs <Bethany.Griggs@uk.ibm.com>
-Beth Griggs <bgriggs@redhat.com> Bethany Griggs <Bethany.Griggs@uk.ibm.com>
-Beth Griggs <bgriggs@redhat.com> Bethany N Griggs <Bethany.Griggs@uk.ibm.com>
-Beth Griggs <bgriggs@redhat.com> BethGriggs <Bethany.Griggs@uk.ibm.com>
-Bidisha Pyne <pyne.bidisha2017@gmail.com> <bidipyne@in.ibm.com>
-Brad Decker <bhdecker84@gmail.com> brad-decker <bhdecker84@gmail.com>
-Brad Larson <brad@waterfallmedia.net> BradLarson <brad@waterfallmedia.net>
-Bradley Meck <bradley.meck@gmail.com> Bradley Farias <bradley.meck@gmail.com>
-Brandon Benvie <brandon@bbenvie.com> <brandon@brandonbenvie.com>
-Brandon Kobel <kobelb@gmail.com> kobelb <brandon.kobel@elastic.co>
-Brendan Ashworth <brendan.ashworth@me.com> <squirrelslikeacorns@gmail.com>
-Brent Pendergraft <bpent3l@gmail.com> penDerGraft <bpent3l@gmail.com>
-Brian White <mscdex@mscdex.net>
-Brian White <mscdex@mscdex.net> <mscdex@gmail.com>
-Caleb Boyd <caleb.boyd@gmail.com>
-Calvin Metcalf <calvin.metcalf@gmail.com> <calvin.metcalf@state.ma.us>
-Calvin Metcalf <calvin.metcalf@gmail.com> <cmetcalf@appgeo.com>
-Caralyn Reisle <caralynreisle@gmail.com> creisle <caralynreisle@gmail.com>
-Charles <ineedpracticing@gmail.com> <cydjudge@users.noreply.github.com>
-Charles Rudolph <charles.rudolph@originate.com>
-Chen Gang <gangc.cxy@foxmail.com>
-Chew Choon Keat <choonkeat@gmail.com>
-Chris Andrews <cpandrews8@gmail.com> cpandrews8 <cpandrews8@gmail.com>
-Chris Johnson <chris.s.johnson4@gmail.com>
-Chris Young <chris.young@tinder.com> <chris.young@gotinder.com>
-Christian Clauss <cclauss@me.com>
-Christian Clauss <cclauss@me.com> <cclauss@bluewin.ch>
-Christophe Naud-Dulude <christophe.naud.dulude@gmail.com> Chris911 <christophe.naud.dulude@gmail.com>
-Christopher Lenz <cmlenz@gmail.com> <chris@lamech.local>
-Claudio Rodriguez <cjrodr@yahoo.com> <cr@fansworld.tv>
-Colin Ihrig <cjihrig@gmail.com>
-Corey Martin <coreymartin496@gmail.com>
-Damien Simonin Feugas <damien.feugas@gmail.com>
-Dan Kaplun <dbkaplun@gmail.com> <dan@beardtree.com>
-Dan Williams <dan@igniter.com> Dan.Williams <daniel@chat.za.net>
-Daniel Abrão <danielpaladar@gmail.com> Daniel Abrão <danielpaladar@gmail.com>
-Daniel Bevenius <daniel.bevenius@gmail.com> daniel.bevenius <daniel.bevenius@gmail.com>
-Daniel Berger <code+node@dpbis.net>
-Daniel Chcouri <333222@gmail.com>
-Daniel Gröber <darklord@darkboxed.org>
-Daniel Gröber <darklord@darkboxed.org> <dxld@darkboxed.org>
-Daniel Paulino <d_paulino@outlook.com> dpaulino <d_paulino@outlook.com>
-Daniel Pihlström <sciolist.se@gmail.com>
-Daniel Wang <wangyang0123@gmail.com> firedfox <wangyang02@baidu.com>
-Daniel Wang <wangyang0123@gmail.com> firedfox <wangyang0123@gmail.com>
-Danny Nemer <hi@dannynemer.com> <DannyNemer@users.noreply.github.com>
-Danny Nemer <hi@dannynemer.com> <hi@DannyNemer.com>
-Dave Pacheco <dap@joyent.com> <dap@cs.brown.edu>
-David Cai <davidcai1993@yahoo.com> DavidCai <davidcai1993@yahoo.com>
-David Mark Clements <david.clements@nearform.com>
-David Mark Clements <david.clements@nearform.com> <huperekchuno@googlemail.com>
-David Mark Clements <david.clements@nearform.com> <david.mark.clements@gmail.com>
-David Siegel <david@artcom.de> <david.siegel@artcom.de>
-DC <dcposch@dcpos.ch> dcposch@dcpos.ch <dcposch@dcpos.ch>
-Deepjyoti Mondal <djmdeveloper060796@gmail.com>
-Domenic Denicola <domenic@domenicdenicola.com>
-Domenic Denicola <domenic@domenicdenicola.com> <d@domenic.me>
-Doug Wade <doug@dougwade.io> doug.wade <doug.wade@redfin.com>
-Eduard Burtescu <eddy_me08@yahoo.com>
-Einar Otto Stangvik <einaros@gmail.com>
-Elliott Cable <me@ell.io>
-Eric Phetteplace <phette23@gmail.com>
-Ernesto Salazar <ernestoalbertosalazar@gmail.com>
-Erwin W. Ramadhan <erwinwahyuramadhan@gmail.com> erwinwahyura <erwinwahyuramadhan@gmail.com>
-Eugene Obrezkov <ghaiklor@gmail.com> ghaiklor <ghaiklor@gmail.com>
-EungJun Yi <semtlenori@gmail.com>
-Evan Larkin <evan.larkin.il.com> <evan.larkin.iit@gmail.com>
-Evan Lucas <evanlucas@me.com> <evan@btc.com>
-Evan Lucas <evanlucas@me.com> <evan.lucas@help.com>
-FangDun Cai <cfddream@gmail.com> Fangdun Cai (Fundon) <cfddream@gmail.com>
-Fangshi He <hefangshi@gmail.com> hefangshi <hefangshi@gmail.com>
-Farid Neshat <FaridN_SOAD@yahoo.com>
-Fatah N <nfatah41@gmail.com> fatahn <nfatah41@gmail.com>
-Fedor Indutny <fedor@indutny.com> <fedor.indutny@gmail.com>
-Felix Böhm <felixboehm55@googlemail.com> <me@feedic.com>
-Felix Geisendörfer <felix@debuggable.com>
-Felix Geisendörfer <felix@debuggable.com>
-Flandre Scarlet <panyilinlove@qq.com> Flandre <panyilinlove@qq.com>
-Florian Margaine <florian@margaine.com> Florian MARGAINE <florian@margaine.com>
-Forrest L Norvell <forrest@npmjs.com> <ogd@aoaioxxysz.net>
-Franziska Hinkelmann <franziska.hinkelmann@gmail.com> F. Hinkelmann <fhinkel@vt.edu>
-Friedemann Altrock <frodenius@gmail.com>
-Fuji Goro <gfuji@cpan.org>
-Gabriel de Perthuis <g2p.code@gmail.com>
-Gareth Ellis <gareth.ellis@uk.ibm.com> <gareth@gsellis.com>
-Garwah Lam <garwahlam@gmail.com>
-Geoffrey Bugaisky <gbugaisk@gmail.com> gbugaisky <gbugaisk@gmail.com>
-Gerhard Stoebich <deb2001-github@yahoo.de>
-Gibson Fahnestock <gibfahn@gmail.com> <gib@uk.ibm.com>
-Gil Pedersen <git@gpost.dk> <github@gpost.dk>
-Graham Fairweather <xotic750@gmail.com> Xotic750 <xotic750@gmail>
-Greg Sabia Tucker <greg@narrowlabs.com> <greg@tucke.rs>
-Gregor Martynus <gregor@martynus.net> Gregor <gregor@martynus.net>
-Guy Bedford <guybedford@gmail.com> guybedford <guybedford@gmail.com>
-Halil İbrahim Şener <hisener@yahoo.com> hisener <hisener@yahoo.com>
-Hannah Kim <h.heeeun.kim@gmail.com> heeeunkimmm <h.heeeun.kim@gmail.com>
-Hannes Magnusson <hannes.magnusson@gmail.com> <hannes.magnusson@creditkarma.com>
-Hendrik Schwalm <mail@hendrikschwalm.de> hschwalm <mail@hendrikschwalm.de>
-Hitesh Kanwathirtha <hiteshk@microsoft.com> <digitalinfinity@gmail.com>
-Henry Chin <hheennrryy@gmail.com>
-Herbert Vojčík <herby@mailbox.sk>
-Icer Liang <liangshuangde@163.com> <wizicer@users.noreply.github.com>
-Igor Savin <iselwin@gmail.com> kibertoad <iselwin@gmail.com>
-Igor Soarez <igorsoarez@gmail.com>
-Igor Zinkovsky <igorzi@microsoft.com>
-Imran Iqbal <imran@imraniqbal.org> <imrani@ca.ibm.com>
-Ionică Bizău <bizauionica@gmail.com> <bizauionica@yahoo.com>
-Isaac Z. Schlueter <i@izs.me>
-Isaac Z. Schlueter <i@izs.me> <i@foohack.com>
-Isaac Z. Schlueter <i@izs.me> isaacs <nope@not.real>
-Isuru Siriwardana <isuruanatomy@gmail.com> isurusiri <isuruanatomy@gmail.com>
-Italo A. Casas <me@italoacasas.com> <italo@italoacasas.com>
-Jackson Tian <shyvo1987@gmail.com> <puling.tyq@alibaba-inc.com>
-Jake Verbaten <raynos2@gmail.com>
-Jamen Marzonie <jamenmarz@gmail.com> Jamen Marz <jamenmarz+gh@gmail.com>
-James Beavers <jamesjbeavers@gmail.com> Druotic <jamesjbeavers@gmail.com>
-James Hartig <fastest963@gmail.com> <james.hartig@grooveshark.com>
-James M Snell <jasnell@gmail.com>
-James Nimlos <james@nimlos.com> JamesNimlos <james@nimlos.com>
-Jan Krems <jan.krems@gmail.com> <jan.krems@groupon.com>
-Jenna Vuong <jennavuong@gmail.com> <hello@jennavuong.com>
-JeongHoon Byun <outsideris@gmail.com> Outsider <outsideris@gmail.com>
-Jered Schmidt <tr@nslator.jp>
-Jeremiah Senkpiel <fishrock123@rocketmail.com>
-Jerry Chin <qinjia@outlook.com>
-Jessica Quynh Tran <jessica.quynh.tran@gmail.com> jessicaquynh <jessica.quynh.tran@gmail.com>
-Jesús Leganés-Combarro 'piranna <piranna@gmail.com> Jesús Leganés Combarro "piranna <piranna@gmail.com>
-Joe Shaw <joe@joeshaw.org> <joeshaw@litl.com>
-Johan Bergström <bugs@bergstroem.nu>
-Johan Dahlberg <jfd@distrop.com> <dahlberg.johan@gmail.com>
-Johann Hofmann <git@johann-hofmann.com>
-John Barboza <jbarboza@ca.ibm.com> jBarz <jBarz@users.noreply.github.com>
-John Barboza <jbarboza@ca.ibm.com> jBarz <jbarboza@ca.ibm.com>
-John Gardner <gardnerjohng@gmail.com> Alhadis <gardnerjohng@gmail.com>
-John McGuirk <johnmac81@gmail.com> jmcgui05 <johnmac81@gmail.com>
-John Musgrave <musgravejw@gmail.com> musgravejw <musgravejw@gmail.com>
-Johnny Ray Austin <johnny@johnnyray.me> Johnny Ray <http://johnnyray.me>
-Jon Tippens <jwtippens@gmail.com> legalcodes <jwtippens@gmail.com>
-Jonas Pfenniger <jonas@pfenniger.name> <jonas@stvs.ch>
-Jonathan Gourlay <gourlayjd@linux.com> mrgorbo <gourlayjd@linux.com>
-Jonathan Ong <jonathanrichardong@gmail.com> <jonathanong@users.noreply.github.com>
-Jonathan Persson <persson.jonathan@gmail.com> <jonathan.persson@creuna.se>
-Jonathan Rentzsch <jwr.git@redshed.net>
-Joseph Leon <joseph.leon.9@gmail.com>
-Jose Luis Vivero <josluivivgar@gmail.com> jlvivero <josluivivgar@gmail.com>
-Josh Erickson <josh@snoj.us>
-Josh Hunter <jopann@gmail.com> jopann <jopann@gmail.com>
-Joshua S. Weinstein <josher19@users.sf.net>
-Joyee Cheung <joyeec9h3@gmail.com> joyeecheung <joyeec9h3@gmail.com>
-Juan Soto <juan@juansoto.me>
-Julien Klepatch <julien@julienklepatch.com> jklepatch <julien@julienklepatch.com>
-Julien Waechter <julien.waechter@gmail.com> julien.waechter <julien.waechter@gmail.com>
-Junliang Yan <john.yan1019@gmail.com>
-Junliang Yan <jyan@ca.ibm.com> <jyan@ca.ibm.ca>
-Junshu Okamoto <o_askgulf@icloud.com> jun-oka <o_askgulf@icloud.com>
-Justin Beckwith <beckwith@google.com> <justin.beckwith@gmail.com>
-Justin Lee <justinlee0022@gmail.com> <justin.lee@ubc.ca>
-Jérémy Lal <kapouer@melix.org>
-Jérémy Lal <kapouer@melix.org> <holisme@gmail.com>
-Juan Sebastian Velez Posada <sebasvelez@gmail.com>
-Kai Sasaki Lewuathe <sasaki_kai@lewuathe.sakura.ne.jp>
-Karl Skomski <karl@skomski.com> <mail@skomski.com>
-Kat Marchán <kzm@zkat.tech> <kzm@sykosomatic.org>
-Kathy Truong <kathy.yvy.truong@gmail.com> k3kathy <kathy.yvy.truong@gmail.com>
-Kazuyuki Yamada <tasogare.pg@gmail.com>
-Keith M Wesolowski <wesolows@joyent.com> <wesolows@foobazco.org>
-Kelsey Breseman <ifoundthemeaningoflife@gmail.com>
-Ke Ding <dingkework@hotmail.com>
-Khaidi Chu <admin@xcoder.in> XadillaX <admin@xcoder.in>
-Khaidi Chu <admin@xcoder.in> <i@2333.moe>
-Kimberly Wilber <gcr@sneakygcr.net>
-Kimberly Wilber <gcr@sneakygcr.net> <gcr@users.noreply.github.com>
-Kiyoshi Nomo <tokyoincidents.g@gmail.com> kysnm <tokyoincidents.g@gmail.com>
-Koichi Kobayashi <koichik@improvement.jp>
-Kostiantyn Wandalen <wandalen.me@gmail.com>
-Kris Kowal <kris.kowal@cixar.com>
-Kyle Robinson Young <kyle@dontkry.com>
-Lakshmi Swetha Gopireddy <lakshmiswethagopireddy@gmail.com> LAKSHMI SWETHA GOPIREDDY <lgopired@in.ibm.com>
-Leeseean Chiu <leeseean@qq.com>
-Luke Bayes <lbayes@patternpark.com>
-Lydia Kats <llkats@gmail.com> Lydia Katsamberis <llkats@gmail.com>
-Maciej Małecki <maciej.malecki@notimplemented.org> <me@mmalecki.com>
-MaleDong <maledong_github@outlook.com> <maledong_private@qq.com>
-Malte-Thorben Bruns <skenqbx@gmail.com> <skenqbx@googlemail.com>
-Malte-Thorben Bruns <skenqbx@gmail.com> skenqbx <skenqbx@gmail.com>
-Mandeep Singh <mandeep25894@gmail.com> <mandeep.singh@zomato.com>
-Manil Chowdhurian <manil.chowdhury@gmail.com> Chowdhurian <manil.chowdhury@gmail.com>
-Marcelo Gobelli <marcelo.gobelli@gmail.com> decareano <marcelo.gobelli@gmail.com>
-Marcin Cieślak <saper@marcincieslak.com>
-Marcin Cieślak <saper@marcincieslak.com> <saper@saper.info>
-Marcin Zielinski <marzelin@gmail.com> marzelin <marzelin@gmail.com>
-Marti Martz <thalamew@q.com>
-Martial James Jefferson <martial.jefferson@gmail.com>
-Martijn Schrage <martijn@oblomov.com> Oblosys <martijn@oblomov.com>
-Masato Ohba <over.rye@gmail.com>
-Mary Marchini <oss@mmarchini.me> <matheusdot@gmail.com>
-Mary Marchini <oss@mmarchini.me> <matheus@sthima.com.br>
-Mary Marchini <oss@mmarchini.me> <matheus@sthima.com>
-Mary Marchini <oss@mmarchini.me> <mmarchini@netflix.com>
-Mary Marchini <oss@mmarchini.me> <mat@mmarchini.me>
-Matt Lang <matt@mediasuite.co.nz> matt-in-a-hat <matt@mediasuite.co.nz>
-Matt Reed <matthewreed26@gmail.com> matthewreed26 <matthewreed26@gmail.com>
-Matteo Collina <matteo.collina@gmail.com> <hello@matteocollina.com>
-Matthias Bastian <dev@matthias-bastian.de> piepmatz <piepmatz@users.noreply.github.com>
-Mathias Buus <mathiasbuus@gmail.com> <m@ge.tt>
-Mathias Pettersson <mape@mape.me>
-Matthew Lye <muddletoes@hotmail.com>
-Matthew Turner <matty_t47@hotmail.com> <ramesius@users.noreply.github.com>
-Maurice Hayward <mauricehayward1@gmail.com> maurice_hayward <mauricehayward1@gmail.com>
-Michael Bernstein <michaelrbernstein@gmail.com>
-Michael Dawson <michael_dawson@ca.ibm.com> <mdawson@devrus.com>
-Michaël Zasso <targos@protonmail.com> <mic.besace@gmail.com>
-Michael-Rainabba Richardson <rainabba@gmail.com> rainabba <rainabba@gmail.com>
-Michał Gołębiowski-Owczarek <m.goleb@gmail.com>
-Micheil Smith <micheil@brandedcode.com> <micheil@yettobebranded.net>
-Micleusanu Nicu <micnic90@gmail.com>
-Miguel Angel Asencio Hurtado <maasencioh@gmail.com> maasencioh <maasencioh@gmail.com>
-Mikael Bourges-Sevenier <mikeseven@gmail.com> <msevenier@motorola.com>
-Mike Kaufman <mike.kaufman@microsoft.com> <mkaufman@microsoft.com>
-Minqi Pan <pmq2001@gmail.com> P.S.V.R <pmq2001@gmail.com>
-Minuk Park <parkm86@gmail.com>
-Minwoo Jung <nodecorelab@gmail.com> JungMinu <jmwsoft@gmail.com>
-Minwoo Jung <nodecorelab@gmail.com> <jmwsoft@gmail.com>
-Minwoo Jung <nodecorelab@gmail.com> <minwoo@nodesource.com>
-Miroslav Bajtoš <miroslav@strongloop.com> <miro.bajtos@gmail.com>
-Mitar Milutinovic <mitar.git@tnode.com>
-Myles Borins <mylesborins@github.com> <mborins@us.ibm.com>
-Myles Borins <mylesborins@github.com> <mylesborins@google.com>
-Myles Borins <mylesborins@github.com> <myles.borins@gmail.com>
-Nam Nguyen <nam.nguyen@de.ibm.com>
-Nebu Pookins <nebu@nebupookins.net>
-Netto Farah <nettofarah@gmail.com> nettofarah <nettofarah@gmail.com>
-Nicholas Kinsey <pyrotechnick@feistystudios.com>
-Nick Soggin <nicksoggin@gmail.com> <iSkore@users.noreply.github.com>
-Nikolai Vavilov <vvnicholas@gmail.com>
-Nils Kuhnhenn <lain@volafile.io>
-Noah Rose Ledesma <noahroseledesma@seattleacademy.org> Noah Rose <noahroseledesma@seattleacademy.org>
-Noah Rose Ledesma <noahroseledesma@seattleacademy.org> <NoahRoseLedesma@seattleacademy.org>
-Oluwaseun Omoyajowo <omoyajowo2015@gmail.com>
-Onne Gorter <onne@onnlucky.com>
-Paul Querna <pquerna@apache.org> <paul@querna.org>
-Pedro Lima <pvsousalima@gmail.com> Pedro Victor <pvsousalima@gmail.com>
-Pedro Lima <pvsousalima@gmail.com> Pedro lima <pvsousalima@gmail.com>
-Peng Lyu <penn.lv@gmail.com> rebornix <penn.lv@gmail.com>
-Peter Flannery <pflannery@users.noreply.github.com>
-Peter Marton <email@martonpeter.com> <peter@risingstack.com>
-Peter Paugh <ppaugh@chariotsolutions.com> Peter <ppaugh@chariotsolutions.com>
-Phillip Johnsen <johphi@gmail.com> <phillip.johnsen@finn.no>
-Prateek Singh <prateeksingh1@hotmail.com> <prateek1@ucla.edu>
-Rachel White <loveless@gmail.com> rachelnicole <loveless@gmail.com>
-Ratikesh Misra <ratikesh92@gmail.com>
-Ravindra Barthwal <ravindrabarthwal@users.noreply.github.com> Ravindra barthwal <ravindrabarthwal@users.noreply.github.com>
-Ray Morgan <rmorgan@zappos.com>
-Ray Solomon <raybsolomon@gmail.com>
-Raymond Feng <enjoyjava@gmail.com> <raymond@strongloop.com>
-Rebecca Turner <me@re-becca.org> <rebecca@npmjs.com>
-Refael Ackermann <refack@gmail.com> <refael@empeeric.com>
-Reza Akhavan <reza@akhavan.me> jedireza <reza@akhavan.me>
-Ricardo Sánchez Gregorio <me@richnologies.io> richnologies <me@richnologies.io>
-Richard Lau <rlau@redhat.com> <riclau@uk.ibm.com>
-Rick Olson <technoweenie@gmail.com>
-Rob Adelmann <adelmann@adobe.com> <robadelmann@gmail.com>
-Rob Adelmann <adelmann@adobe.com> adelmann <adelmann@adobe.com>
-Robert Nagy <ronagy@icloud.com> Robert Nagy <robertnagy@Roberts-MacBook-Pro.local>
-Rod Machen <rod.machen@help.com> <mail@rodmachen.com>
-Roman Klauke <romaaan.git@gmail.com> <romankl@users.noreply.github.com>
-Roman Reiss <me@silverwind.io>
-Ron Korving <ron@ronkorving.nl> <rkorving@wizcorp.jp>
-Ron Korving <ron@ronkorving.nl> ronkorving <ron@ronkorving.nl>
-Ruben Bridgewater <ruben@bridgewater.de> <ruben.bridgewater@fintura.de>
-Ruben Bridgewater <ruben@bridgewater.de> <ruben.bridgewater@maibornwolff.de>
-Russell Dempsey <sgtpooki@gmail.com> <SgtPooki@gmail.com>
-Ryan Dahl <ry@tinyclouds.org>
-Ryan Emery <seebees@gmail.com>
-Ryan Mahan <ryanmahan97@gmail.com>
-Ryan Scheel <ryan.havvy@gmail.com> Ryan Scheel <Ryan.havvy@gmail.com>
-Ryan Scheel <ryan.havvy@gmail.com> Ryan Scheel (Havvy) <ryan.havvy@gmail.com>
-Saad Quadri <saad@saadq.com> saadq <saad@saadquadri.com>
-Sagir Khan <sagir.khan@gmail.com>
-Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
-Sam Mikes <smikes@cubane.com>
-Sam P Gallagher-Bishop <samgallagherb@gmail.com> <SPGB@users.noreply.github.com>
-Sam Shull <brickysam26@gmail.com> <brickysam26@samuel-shulls-computer.local>
-Sam Shull <brickysam26@gmail.com> <sshull@squaremouth.com>
-Sam Roberts <vieuxtech@gmail.com> <sam@strongloop.com>
-Samantha Sample <ssample812@gmail.com> = <=>
-Sambasiva Suda <sambasivarao@gmail.com>
-San-Tai Hsu <v@fatpipi.com>
-Santiago Gimeno <santiago.gimeno@gmail.com> <santiago.gimeno@ionide.es>
-Sarah Meyer <sarahsaltrick@gmail.com> sarahmeyer <sarahsaltrick@gmail.com>
-Sartrey Lee <sartrey@163.com> sartrey <sartrey@163.com>
-Saúl Ibarra Corretgé <s@saghul.net> <saghul@gmail.com>
-Shobhit Chittora <chittorashobhit@gmail.com> <schittora@paypal.com>
-Scott Blomquist <github@scott.blomqui.st> <sblom@microsoft.com>
-Segu Riluvan <rilwan22@hotmail.com> <riluvan@gmail.com>
-Sergey Kryzhanovsky <skryzhanovsky@gmail.com> <another@dhcp199-223-red.yandex.net>
-Shannen Saez <shannenlaptop@gmail.com>
-Shaopeng Zhang <szhang351@bloomberg.net> szhang351 <szhang351@bloomberg.net>
-Shigeki Ohtsu <ohtsu@ohtsu.org> <ohtsu@iij.ad.jp>
-Shigeki Ohtsu <ohtsu@ohtsu.org> <ohtsu@d.jp>
-Shivang Saxena <shivangs44@gmail.com>
-Shiya Luo <luo.shiya@gmail.com> shiya <luo.shiya@gmail.com>
-Siddharth Mahendraker <siddharth_mahen@hotmail.com> <siddharth_mahen@me.com>
-Simon Willison <simon@simonwillison.net>
-Siobhan O'Donovan <siobhan@justshiv.com> justshiv <siobhan@justshiv.com>
-Siyuan Gao <siyuangao@gmail.com> r1cebank <siyuangao@gmail.com>
-solebox <solekiller@gmail.com> solebox <5013box@gmail.com>
-Sreepurna Jasti <sreepurna.jasti@gmail.com> <jsreepur@in.ibm.com>
-Sreepurna Jasti <sreepurna.jasti@gmail.com> sreepurnajasti <jsreepur@in.ibm.com>
-Sreepurna Jasti <sreepurna.jasti@gmail.com> sreepurnajasti <sreepurna.jasti@gmail.com>
-Stanislav Opichal <opichals@gmail.com>
-Stefan Budeanu <stefan@budeanu.com> <stefanbu@ca.ibm.com>
-Stefan Bühler <stbuehler@web.de>
-Stephen Belanger <admin@stephenbelanger.com> <stephen.belanger@elastic.co>
-Steve Mao <maochenyan@gmail.com> <maochenyan@msn.com>
-Steven R. Loomis <srloomis@us.ibm.com> <srl@icu-project.org>
-Stewart X Addison <sxa@redhat.com> Stewart Addison <sxa@uk.ibm.com>
-Stewart X Addison <sxa@redhat.com> sxa555 <sxa@uk.ibm.com>
-Stewart X Addison <sxa@redhat.com> Stewart X Addison <sxa@uk.ibm.com>
-Suraiya Hameed <hameedsuraiya@gmail.com> suraiyah <hameedsuraiya@gmail.com>
-Suramya shah <shah.suramya@gmail.com> ss22ever <ss22ever@users.noreply.github.com>
-Surya Panikkal <surya.com@gmail.com> surya panikkal <surya.com@gmail.com>
-Surya Panikkal <surya.com@gmail.com> suryagh <surya.com@gmail.com>
-Taehee Kang <hugnosis@gmail.com> hugnosis <hugnosis@gmail.com>
-Tanuja-Sawant <f2013658@goa.bits-pilani.ac.in> <thinkbigtanu@gmail.com>
-Taylor Woll <taylor.woll@microsoft.com> taylor.woll <tawoll@ntdev.microsoft.com>
-Thomas Watson Steen <w@tson.dk> Thomas Watson <w@tson.dk>
-Timothy O. Peters <timotewpeters@gmail.com>
-Timur Shemsedinov <timur.shemsedinov@gmail.com> tshemsedinov <timur.shemsedinov@gmail.com>
-Ting Shao <ting.shao@intel.com>
-Toby Farley <tobyfarley@gmail.com> tobyfarley <tobyfarley@gmail.com>
-Toby Stableford <tobytronics@gmail.com> toboid <toboid@users.noreply.github.com>
-Todd Kennedy <todd@selfassembled.org> <toddself@users.noreply.github.com>
-TJ Holowaychuk <tj@vision-media.ca>
-TJ Holowaychuk <tj@vision-media.ca> <tjholowayhuk@gmail.com>
-Tadashi SAWADA <cesare@mayverse.jp>
-Takahiro ANDO <takahiro.ando@gmail.com>
-Tarun Batra <tarun.batra00@gmail.com> Tarun <tarun.batra00@gmail.com>
-Ted Young <ted@radicaldesigns.org>
-Teppei Sato <teppeis@gmail.com>
-Theotime Poisseau <theotime.poisseau@gmail.com>
-Thomas Hunter II <me@thomashunter.name> <tom@intrinsic.com>
-Thomas Lee <thomas.lee@shinetech.com> <tom@tom-debian.sensis.com.au>
-Thomas Reggi <thomas@reggi.com>
-Tierney Cyren <hello@bnb.im> &! (bitandbang) <tieliaco@gmail.com>
-Tierney Cyren <hello@bnb.im> bitandbang <hello@bnb.im>
-Tim Caswell <tim@creationix.com> <tim@0-26-8-e9-4c-e1.dyn.utdallas.edu>
-Tim Price <timprice@mangoraft.com>
-Tim Smart <timehandgod@gmail.com> <tim@fostle.com>
-Tim Smart <timehandgod@gmail.com> <timehandgod@gmail.com>
-Timothy Leverett <zzzzBov@gmail.com> Timothy <zzzzBov@gmail.com>
-Tobias Nießen <tniessen@tnie.de> <tniessen@users.noreply.github.com>
-Tom Atkinson <atkinson.tommy@nsoft.com> <atkinson.tommy@nhome.ba>
-Tom Atkinson <atkinson.tommy@nsoft.com> <atkinson.tommy@nsoft.ba>
-Tom Hughes <tom.hughes@palm.com> <tomtheengineer@gmail.com>
-Tom Hughes-Croucher <tom_croucher@yahoo.com>
-Tom Purcell <tpurcell@chariotsolutions.com> tpurcell <tpurcell@chariotsolutions.com>
-Tom White <tomtinkerer@gmail.com>
-Tomoki Okahana <umatomakun@gmail.com> umatoma <umatomakun@gmail.com>
-Tracy Hinds <tracyhinds@gmail.com> Tracy <tracyhinds@gmail.com>
-Travis Meisenheimer <travis@indexoutofbounds.com> <tmeisenh@gmail.com>
-Trevor Burnham <trevor@databraid.com> <trevorburnham@gmail.com>
-Trivikram Kamat <trivikr.dev@gmail.com> <16024985+trivikr@users.noreply.github.com>
-Tyler Larson <talltyler@gmail.com>
-Ujjwal Sharma <usharma1998@gmail.com> <ryzokuken@disroot.org>
-Viktor Karpov <viktor.s.karpov@gmail.com> vitkarpov <viktor.s.karpov@gmail.com>
-Vincent Voyer <v@fasterize.com>
-Vladimir de Turckheim <vlad2t@hotmail.com>
-vsemozhetbyt <vsemozhetbyt@gmail.com> Vse Mozhet Byt <vsemozhetbyt@gmail.com>
-Wang Xinyong <wang.xy.chn@gmail.com> <wangxy.chn@gmail.com>
-Weijia Wang <381152119@qq.com>
-Weijia Wang <381152119@qq.com> <starkwang@126.com>
-Weijia Wang <381152119@qq.com> <starkewang@tencent.com>
-Wei-Wei Wu <wuxx1045@umn.edu>
-Willi Eggeling <email@wje-online.de>
-Will Hayslett <william.hayslettjr@gmail.com>
-Wilson Lin <wla80@sfu.ca>
-Wyatt Preul <wpreul@gmail.com> geek <wpreul@gmail.com>
-Xavier J Ortiz <xavier.ortiz.ch@gmail.com>
-xiaoyu <306766053@qq.com> Poker <306766053@qq.com>
-Yael Hermon <yaelherm@gmail.com> <yaelhe@wix.com>
-Yazhong Liu <yorkiefixer@gmail.com> Yazhong Liu <l900422@vip.qq.com>
-Yazhong Liu <yorkiefixer@gmail.com> Yorkie <l900422@vip.qq.com>
-Yazhong Liu <yorkiefixer@gmail.com> Yorkie <yorkiefixer@gmail.com>
-Yazhong Liu <yorkiefixer@gmail.com> Yorkie Liu <yorkiefixer@gmail.com>
-Yingchen Xue <yingchenxue@qq.com>
-Yongsheng Zhang <zyszys98@gmail.com>
-Yongsheng Zhang <zyszys98@gmail.com> <17367077526@163.com>
-Yongsheng Zhang <zyszys98@gmail.com> <zhangyongsheng@youzan.com>
-Yoshihiro KIKUCHI <yknetg@gmail.com>
-Yosuke Furukawa <yosuke.furukawa@gmail.com> <furukawa.yosuke@dena.jp>
-Yuichiro MASUI <masui@masuidrive.jp>
-Yuta Hiroto <git@about-hiroppy.com> abouthiroppy <git@about-hiroppy.com>
-Zach Bjornson <bjornson@stanford.edu> <zbbjornson@gmail.com>
-Zachary Scott <zachary@zacharyscott.net> <zachary.s.scott@gmail.com>
-Zachary Vacura <admin@hackzzila.com>
-Zoran Tomicic <ztomicic@gmail.com>
-Сковорода Никита Андреевич <chalkerx@gmail.com> ChALkeR <chalkerx@gmail.com>
-隋鑫磊 <joshuasui@163.com>
-
-# These people didn't contribute patches to node directly,
-# but we've landed their v8 patches in the node repository:
-Daniel Clifford <danno@chromium.org>
-Erik Corry <erik.corry@gmail.com>
-Jakob Kummerow <jkummerow@chromium.org>
-Kevin Millikin <kmillikin@chromium.org>
-Lasse R.H. Nielsen <lrn@chromium.org>
-Michael Starzinger <mstarzinger@chromium.org>
-Toon Verwaest <verwaest@chromium.org>
-Vyacheslav Egorov <vegorov@chromium.org>
-Yang Guo <yangguo@chromium.org>
diff --git a/AUTHORS b/AUTHORS
index a61c4010be5d3c3904bb058067fdc10732a21932..213c03ba9f32a8120b581885ab55187ea4a79445 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -504,7 +504,7 @@ David Chan <david@sheetmusic.org.uk>
 Alexis Campailla <alexis@janeasystems.com>
 Nikolai Vavilov <vvnicholas@gmail.com>
 Michael Ridgway <mcridgway@gmail.com>
-Yazhong Liu <yorkiefixer@gmail.com>
+Yorkie Liu <yorkiefixer@gmail.com>
 Gabriel Falkenberg <gabriel.falkenberg@gmail.com>
 Kai Groner <kai@gronr.com>
 Lalit Kapoor <lalitkapoor@gmail.com>
@@ -587,7 +587,7 @@ Ed Umansky <edumansky@gmail.com>
 Maurice Butler <maurice.butler@gmail.com>
 John Albietz <inthecloud247@gmail.com>
 Andrew Oppenlander <andrew.oppenlander@zipscene.com>
-Julien Gilli <julien.gilli@joyent.com>
+Julien Gilli <jgilli@netflix.com>
 Gabriel Wicke <wicke@wikidev.net>
 Jakob Gillich <jakob@gillich.me>
 Lucio M. Tato <luciotato@gmail.com>
@@ -652,7 +652,7 @@ Ben Burns <benjamin.c.burns@gmail.com>
 Julian Duque <julianduquej@gmail.com>
 Teppei Sato <teppeis@gmail.com>
 Rudi Cilibrasi <cilibrar@morefuntechnologies.com>
-Tim Ruffles <oi@truffles.me.uk>
+Tim Ruffles <timruffles@googlemail.com>
 CGavrila <cristi_gavrila1@yahoo.com>
 Aleksey Smolenchuk <aleksey@uber.com>
 Caitlin Potter <caitpotter88@gmail.com>
@@ -784,7 +784,7 @@ Sven Slootweg <jamsoftgamedev@gmail.com>
 Dmitry Vasilyev <vaseker@gmail.com>
 Malcolm Ahoy <malcolmahoy@gmail.com>
 Imran Iqbal <imran@imraniqbal.org>
-Stewart X Addison <sxa@uk.ibm.com>
+Stewart X Addison <sxa@redhat.com>
 Matt Harrison <hi@matt-harrison.com>
 Christopher J. Brody <brodybits@litehelpers.net>
 Salman Aljammaz <s@0x65.net>
@@ -808,7 +808,7 @@ David Boivin <dave.a.boivin@gmail.com>
 Liang-Chi Hsieh <viirya@appier.com>
 Timothy Gu <timothygu99@gmail.com>
 Fábio Santos <fabiosantosart@gmail.com>
-Myles Borins <mylesborins@github.com>
+Myles Borins <myles.borins@gmail.com>
 Jonas Dohse <jonas@dohse.ch>
 Коренберг Марк <mark@ideco.ru>
 Caleb Boyd <caleb.boyd@gmail.com>
@@ -995,6 +995,7 @@ Doug Wade <doug@dougwade.io>
 Mohsen <mohsenekhtiari@yahoo.com>
 Marian <sorca_marian@yahoo.com>
 Justin Sprigg <IPWNDYOU@gmail.com>
+Eugene Ostroukhov <eostroukhov@google.com>
 Bryan Hughes <brhugh@microsoft.com>
 Ehsan Akhgari <ehsan@mozilla.com>
 Ingvar Stepanyan <me@rreverser.com>
@@ -1168,7 +1169,7 @@ Yoshiya Hinosawa <stibium121@gmail.com>
 Syuhei Kobayashi <nanocloudx@gmail.com>
 YutamaKotaro <california.dreamin.never.die@gmail.com>
 MURAKAMI Masahiko <fossamagna2@gmail.com>
-Thomas Watson Steen <w@tson.dk>
+Thomas Watson <w@tson.dk>
 Daijiro Yamada <yamad@daiji.ro>
 Kelvin Jin <kelvinjin@google.com>
 Mitsuo Utano <utano320@gmail.com>
@@ -1204,7 +1205,7 @@ Daniel Pittman <daniel@pittmo.net>
 Ian White <ian.white.developer@gmail.com>
 Chris Bystrek <chris.bystrek@gmail.com>
 Christine Hong <christine@dogvacay.com>
-Oscar Martinez <oscar.martinez@hautelook.com>
+Oscar Martinez <oscar@mtnz-web.com>
 Aileen <avillanueva>
 David Bradford <dbradf@gmail.com>
 stokingerl <liamstokinger@gmail.com>
@@ -1254,7 +1255,7 @@ J Scott Chapman <scott8675309@gmail.com>
 Erez Weiss <ruggertech@gmail.com>
 Scott Smereka <scott.smereka@gmail.com>
 Fabrice Tatieze <fabrice.tatieze@nike.com>
-Uttam Pawar <uttam.c.pawar@intel.com>
+Uttam Pawar <upawar@gmail.com>
 Ben Lugavere <b.lugavere@gmail.com>
 Punit Buch <punit.buch@gmail.com>
 mark hughes <mrhughes@xogrp.com>
@@ -1270,12 +1271,11 @@ amrios <amrios@us.ibm.com>
 Chris Henney <CHenney@walmartlabs.com>
 Yojan Shrestha <sickgrin@gmail.com>
 Rodrigo Palma <rpalma@mx1.ibm.com>
-Sam Shull <sam+github@samshull.com>
 Michael-Bryant Choa <mbchoa@gmail.com>
 CodeVana <codevaana@gmail.com>
 Daniel Sims <danielsims@quickenloans.com>
 Diego Paez <paez.di@gmail.com>
-Paul Graham <paul@bytefair.com>
+Paul Graham <homosaur@gmail.com>
 Jared Young <jared.young@panasonic.aero>
 vazina robertson <vazina.robertson@gmail.com>
 Bruce Lai <bruceplai@gmail.com>
@@ -1324,7 +1324,6 @@ malen <malenesok007@yahoo.com>
 Kailean Courtney <kailean@gmail.com>
 Fumiya KARASAWA <krswfmy@gmail.com>
 John Barboza <jbarboza@ca.ibm.com>
-Paul Graham <homosaur@gmail.com>
 Nate <nfoxley@stedwards.edu>
 Chris Story <storytimesolutions@gmail.com>
 Matthew Garrett <mjg59@coreos.com>
@@ -1481,7 +1480,6 @@ Tony Rice <tony@bestellensoftware.com>
 Olivier Martin <olivier4.martin@orange.com>
 jeyanthinath <jeyanthinath10@gmail.com>
 Aditya Anand <aditya.anandmc@gmail.com>
-Oscar Martinez <oscar@mtnz-web.com>
 cool88 <bhansur6@gmail.com>
 Steven Lehn <sjlehn@gmail.com>
 Łukasz Szewczak <lukaszewczak@gmail.com>
@@ -1489,12 +1487,12 @@ Madara Uchiha <me@madara.ninja>
 Gil Tayar <gil@tayar.org>
 Glenn Schlereth <Glenn.Schlereth@gmail.com>
 Artur G Vieira <vieira.artur.g@gmail.com>
-Gerhard Stoebich <deb2001-github@yahoo.de>
+Gerhard Stöbich <deb2001-github@yahoo.de>
 Sreepurna Jasti <sreepurna.jasti@gmail.com>
 Rafael Fragoso <rafaelfragosom@gmail.com>
 Andrei Cioromila <andrei.cioromila@gmail.com>
 Frank Lanitz <frank@frank.uvena.de>
-Khaidi Chu <admin@xcoder.in>
+Khaidi Chu <i@2333.moe>
 Akshay Iyer <c.m.akshay.iyer@gmail.com>
 Rick Bullotta <RickBullotta@users.noreply.github.com>
 Rajaram Gaunker <zimbabao@gmail.com>
@@ -1543,7 +1541,7 @@ lena <kaplanlena@gmail.com>
 Azard <330815461@qq.com>
 Ezequiel Garcia <ezequiel@vanguardiasur.com.ar>
 Kyle Farnung <kfarnung@microsoft.com>
-Weijia Wang <381152119@qq.com>
+Weijia Wang <starkwang@126.com>
 Nataly Shrits <nataly@soluto.com>
 Jaime Bernardo <jaime@janeasystems.com>
 Natanael Log <natte.log@gmail.com>
@@ -1620,7 +1618,6 @@ Mandeep Singh <mandeep25894@gmail.com>
 Prakash Palaniappan <prakaash.kpk@gmail.com>
 Keita Akutsu <kakts.git@gmail.com>
 Michael Albert <michaalbert.42@gmail.com>
-Eugene Ostroukhov <eostroukhov@google.com>
 Vishal Bisht <vishalbisht7201@gmail.com>
 Griffith Tchenpan <griffith.tchenpan@myworkpapers.com>
 Oky Antoro <kiantrue@gmail.com>
@@ -1664,7 +1661,7 @@ Miguel Martins <mmartins@uphold.com>
 Yury Popov <github@phoenix.dj>
 George Bezerra <georgelione@gmail.com>
 Benjamin Coe <bencoe@gmail.com>
-Tim Costa <tjsail33@gmail.com>
+Tim Costa <tim@timcosta.io>
 Rahul Mishra <mishra.rahul1712@gmail.com>
 Damien O'Reilly <damienreilly@gmail.com>
 Tuan Anh Tran <me@tuananh.org>
@@ -2116,7 +2113,7 @@ dustinnewman98 <dustinnewman98@gmail.com>
 Oluwaseun Omoyajowo <omoyajowo2015@gmail.com>
 Wilson Lin <wla80@sfu.ca>
 Eric Bickle <wolf.code@outlook.com>
-Ujjwal Sharma <usharma1998@gmail.com>
+Ujjwal Sharma <ryzokuken@disroot.org>
 Wei-Wei Wu <wuxx1045@umn.edu>
 Prateek Singh <prateeksingh1@hotmail.com>
 Ken Lin <ken23421@gmail.com>
@@ -2270,7 +2267,6 @@ prayag21 <10997858+prayag21@users.noreply.github.com>
 Bruno Pinho <bpinhosilva@gmail.com>
 Anto Aravinth <anto.aravinth.cse@gmail.com>
 Helio Frota <00hf11@gmail.com>
-Tim Ruffles <timruffles@googlemail.com>
 Jacob Page <jpage@godaddy.com>
 sagulati <sagulati@adobe.com>
 conectado <gabrielalejandro7@gmail.com>
@@ -2335,7 +2331,6 @@ Sintendo <bram.speeckaert@gmail.com>
 Nitish Sakhawalkar <nitsakh@icloud.com>
 André Cruz <andre@cabine.org>
 Josh Broomfield <josh.m.broomfield@gmail.com>
-Julien Gilli <jgilli@netflix.com>
 Umang Raghuvanshi <u@umangis.me>
 Duarte David <deltaduartedavid@gmail.com>
 Aleksey Chemakin <Dzenly@users.noreply.github.com>
@@ -2499,14 +2494,14 @@ Jerome Covington <jeromecovington@gmail.com>
 Rob Reynolds <ferventcoder@gmail.com>
 warnerp18 <warnerp18@gmail.com>
 chux0519 <chuxdesign@hotmail.com>
-Tadhg Creedon <tadhg.creedon@rangle.io>
+Tadhg Creedon <tadhgcreedon@gmail.com>
 Petar Dodev <petar.dodev@gmail.com>
 mzucker <michaeljzucker@gmail.com>
 Morgan Roderick <morgan@roderick.dk>
 Remy Parzinski <rs.parzinski@gmail.com>
 Roland Broekema <roland.broekema@qnh.nl>
 Florin-Daniel BÎLBÎE <fbilbie@bitdefender.com>
-Robin Drexler <robin.drexler@xing.com>
+Robin Drexler <drexler.robin@gmail.com>
 ZauberNerd <zaubernerd@zaubernerd.de>
 G. Carcaci <giuseppecarcaci@gmail.com>
 Jackson Chui <14085209+haiXchuus@users.noreply.github.com>
@@ -2583,7 +2578,6 @@ rahulshuklab4u <rahulshuklab4u@gmail.com>
 gengjiawen <technicalcute@gmail.com>
 Maya Anilson <manilson@yahoo.in>
 Mrityunjoy Saha <msaha@vmware.com>
-Robin Drexler <drexler.robin@gmail.com>
 Prabu Subra <prabus69@gmail.com>
 Abhishek Dixit <abhishek.dixit@genisys-group.com>
 Sarath Govind K K <sarathgovind27@gmail.com>
@@ -2621,7 +2615,6 @@ grimrose <grimrose@users.noreply.github.com>
 timothy searcy <timmyzsearcy@gmail.com>
 nakashima <nakashima1711@gmail.com>
 /Jesse <jesse.katsumata@gmail.com>
-Tadhg Creedon <tadhgcreedon@gmail.com>
 exoego <mogami@exoego.net>
 sigwyg <sigwyg>
 pastak <pasta0915@gmail.com>
@@ -2673,7 +2666,6 @@ Amit Zur <sendwithchibo@gmail.com>
 Thang Tran <trankimthang279@gmail.com>
 Kai <Schweinepriester@users.noreply.github.com>
 Abhishek Agarwal <abhishek.agr31@gmail.com>
-Uttam Pawar <upawar@gmail.com>
 Jon Kunkee <jkunkee@microsoft.com>
 Mukul Khanna <mukul18khanna@gmail.com>
 Jarrod Connolly <jarrod@nestedquotes.ca>
@@ -2682,7 +2674,7 @@ Alexander Sattelmaier <alexander.sattelmaier@gmail.com>
 Avi ד <avi.the.coder@gmail.com>
 Thomas <hakerh403@gmail.com>
 Aymen Naghmouchi <aymen.aymen@live.it>
-himself65 <himself6565@gmail.com>
+himself65 <himself65@outlook.com>
 Geir Hauge <geir.hauge@gmail.com>
 Patrick Gansterer <paroga@paroga.com>
 Nicolas Moteau <nicolas.moteau@orange.com>
@@ -2732,7 +2724,6 @@ imhype <543717080@qq.com>
 ptaylor <paul.e.taylor@me.com>
 Boxuan Li <liboxuan@connect.hku.hk>
 Aditya Pratap Singh <adisinghrajput@gmail.com>
-Eugene Ostroukhov <eostroukhov@netflix.com>
 Preveen Padmanabhan <dxb1230@gmail.com>
 Benjamin Ki <me@benjaminki.com>
 Daniel Nalborczyk <dnalborczyk@gmail.com>
@@ -2740,7 +2731,6 @@ Alba Mendez <me@alba.sh>
 zero1five <zerodengyin@gmail.com>
 Gaelan <gbs@canishe.com>
 Jacob <jacobq@gmail.com>
-himself65 <himself65@outlook.com>
 Dan Beglin <dbeglinuk@gmail.com>
 Anish Asrani <anishasrani@gmail.com>
 teams2ua <teams2ua@gmail.com>
@@ -2792,13 +2782,11 @@ Juan Roa <jdroa92@gmail.com>
 Ivan Villa <trezeguet55@gmail.com>
 Caleb ツ Everett <calebev@amazon.com>
 Miken <omarlozano053@gmail.com>
-Eugene Ostroukhov <eostroukhov@gmail.com>
 Gabriela Niño <gabynr@gmail.com>
 Mike MacCana <mike.maccana@gmail.com>
 Tim Baverstock <tim.baverstock@corp.badoo.com>
 Walle Cyril <cyril.walle@protonmail.com>
-Xu Meng <mengxumx@cn.ibm.com>
-Samuel Attard <sattard@slack-corp.com>
+Xu Meng <dmabupt@gmail.com>
 Ben L. Titzer <titzer@google.com>
 Ojasvi Monga <ojasvi@Ojasvis-MacBook-Air.local>
 Shajan Jacob <shajanjp@gmail.com>
@@ -2848,7 +2836,7 @@ Javier Ledezma <juls0593@gmail.com>
 Marian Rusnak <4215517+marian-r@users.noreply.github.com>
 Jenia <jeniabrook@gmail.com>
 Anton Gerasimov <agerasimov@twilio.com>
-rickyes <mail@zhoumq.cn>
+rickyes <0x19951125@gmail.com>
 Simon A. Eugster <simon.eu@gmail.com>
 TATSUNO Yasuhiro <ytatsuno.jp@gmail.com>
 Robert Jensen <rjensen@butterflynetwork.com>
@@ -2894,7 +2882,6 @@ Albert Wang <git@albertyw.com>
 Kenza Houmani <khoumani@bloomberg.net>
 mkdorff <mkdorff@outlook.com>
 xefimx <xefimix@gmail.com>
-garygsc <GaryGSC@users.noreply.github.com>
 Susana Ferreira <ssncferreira@gmail.com>
 Xavier Redondo <xavier.redondo@axa.com>
 Duncan Healy <duncan.healy@gmail.com>
@@ -2964,7 +2951,6 @@ Rosen Penev <rosenp@gmail.com>
 Jeremy Albright <myrlin1@gmail.com>
 Giovanni Campagna <gcampagn@cs.stanford.edu>
 Donggeon Lim <ooqwe486@gmail.com>
-Tim Costa <tim@timcosta.io>
 rene.herrmann <rene.herrmann@share-now.com>
 Derek Lewis <DerekNonGeneric@inf.is>
 Kirill Ponomarev <shacaron@gmail.com>
@@ -3003,7 +2989,7 @@ Conor ONeill <cwjoneill@gmail.com>
 tsabolov <k.tsabolov@gmail.com>
 Swagat Konchada <swagatata@gmail.com>
 Yuhanun Citgez <y.citgez@student.utwente.nl>
-Danielle Adams <danielle.adams@heroku.com>
+Danielle Adams <adamzdanielle@gmail.com>
 Andrey Pechkurov <apechkurov@gmail.com>
 Jeff <jeff.tian@outlook.com>
 simon <simon.tretter@hokify.com>
@@ -3017,13 +3003,11 @@ Andrew Neitsch <andrew@neitsch.ca>
 RamanandPatil <ramanand.patil@gmail.com>
 forfun414 <forfun414@gmail.com>
 David Gilbertson <gilbertson.david@gmail.com>
-Sergey Zelenov <sergey.zelenov@getyourguide.com>
 Eric Bickle <ebickle@users.noreply.github.com>
 Joe Pea <joe@trusktr.io>
 ExE Boss <3889017+ExE-Boss@users.noreply.github.com>
 Mateusz Krawczuk <krawczukmat@gmail.com>
 Jonathan MERCIER <jmercier@cng.fr>
-Ujjwal Sharma <ryzokuken@igalia.com>
 Jichan <development@jc-lab.net>
 Hassaan Pasha <hassaan.pasha@teamo.io>
 Eric Dobbertin <eric@dairystatedesigns.com>
@@ -3036,7 +3020,6 @@ Sk Sajidul Kadir <sheikh.sajid522@gmail.com>
 Bartlomiej Brzozowski <bart.brzozowski@janeasystems.com>
 Saajan <saajan.sn@gmail.com>
 Yash Ladha <yashladhapankajladha123@gmail.com>
-Xu Meng <dmabupt@gmail.com>
 Alex R <alexei.rudenko@gmail.com>
 Hachimi Aa (Sfeir) <hachimi.aa@sfeir.com>
 Daniel Estiven Rico Posada <danielrico.posada@gmail.com>
@@ -3085,7 +3068,6 @@ Ben Bucksch <ben.bucksch@beonex.com>
 Eli Schwartz <eschwartz@archlinux.org>
 Maciej Kacper Jagiełło <maciej@jagiello.it>
 Tom Nagle <tomanagle@gmail.com>
-rickyes <ives199511@gmail.com>
 sapics <gv.nishino@gmail.com>
 Sagar Jadhav <sagarj.jadhav23@gmail.com>
 Dennis Ameling <dennis@dennisameling.com>
@@ -3139,5 +3121,196 @@ Shigma <33423008+Shigma@users.noreply.github.com>
 atian25@qq.com <atian25@qq.com>
 Amila Welihinda <amilajack@gmail.com>
 schamberg97 <50446906+schamberg97@users.noreply.github.com>
+DrunkenPoney <mrquebec13@gmail.com>
+Christoph Tavan <dev@tavan.de>
+Clark Kozak <clarkkozak@protonmail.com>
+Michael Auderer <mike@silverstone.io>
+Linn Dahlgren <admin@opposite.biz>
+Ikko Ashimine <eltociear@gmail.com>
+Anatoly Korniltsev <korniltsev.anatoly@gmail.com>
+Victor Antonio Barzana Crespo <viticoinf@gmail.com>
+Matthieu Larcher <gitlab@ringabell.org>
+anlex N <1293006794@qq.com>
+ThakurKarthik <iamkarthik08@gmail.com>
+Aastha Gupta <aastha.gupta4104@gmail.com>
+Yohanan Baruchel <yohanan@yad2.co.il>
+Dmitry Gozman <dgozman@gmail.com>
+Daniil Demidovich <ddemidovich@staply.ru>
+Hussaina Begum Nandyala <hexxdump@gmail.com>
+Danny Sonnenschein <my.card.god@web.de>
+Sourav Shaw <shawsourav91@gmail.com>
+H Adinarayana <adharida@in.ibm.com>
+lucasg <lucas.georges@outlook.com>
+Brian 'bdougie' Douglas <ilikerobot@gmail.com>
+Lee, Bonggi <iyabong@gmail.com>
+Momtchil Momtchev <momtchil@momtchev.com>
+Josh Dague <jd@josh3736.net>
+Vincent Boivin <vboivin04@gmail.com>
+ax1 <16510021+ax1@users.noreply.github.com>
+Shubham Parihar <51517103+iShibi@users.noreply.github.com>
+Darshan Sen <raisinten@gmail.com>
+Matthew Francis Brunetti <zenflow87@gmail.com>
+Chris Opperwall <copperwall@gmail.com>
+Takuya Noguchi <takninnovationresearch@gmail.com>
+tyankatsu <frips.ryilsufupe+dev@gmail.com>
+Ben Turner <7623873+ben-turner@users.noreply.github.com>
+Bryan Field <bfield@700software.com>
+krank2me <alejok6@gmail.com>
+masx200 <34191203+masx200@users.noreply.github.com>
+Baruch Odem (Rothkoff) <baruchiro@gmail.com>
+Mattias Runge-Broberg <mattias@runge.se>
+Dmitry Semigradsky <semigradskyd@gmail.com>
+Ole André Vadla Ravnås <oleavr@gmail.com>
+Aleksandr Krutko <Oleksandr.Krutko@ibm.com>
+Brian Ingenito <28159742+bingenito@users.noreply.github.com>
+FeelyChau <feely@outlook.com>
+Darcy Clarke <darcy@darcyclarke.me>
+mayank agarwal <mayankagarwal44442@gmail.com>
+woodfairy <d.schmit@m3connect.de>
+Nikola Glavina <glavina.nikola5@gmail.com>
+Rishabh Mehan <darkrishabh@gmail.com>
+Anna Henningsen <anna.henningsen@mongodb.com>
+Andrew Casey <andrew.casey@microsoft.com>
+Anders Kaseorg <andersk@mit.edu>
+Hollow Man <hollowman@hollowman.ml>
+nlf <quitlahok@gmail.com>
+naortedgi <naor.tedgi@gmail.com>
+Narasimha Prasanna HN <yogaimpression@gmail.com>
+Zijian Liu <Lxxyxzj@gmail.com>
+inokawa <48897392+inokawa@users.noreply.github.com>
+Michael Bashurov <accounts@saitonakamura.me>
+Moshe vilner <shootermv@gmail.com>
+Nicolai Stange <nicstange@gmail.com>
+kai zhu <kaizhu256@gmail.com>
+FrankQiu <iam.frankqiu@gmail.com>
+Rock <arockplaysmc@gmail.com>
+Chinmoy Chakraborty <chinmoy12c@gmail.com>
+Maksym Baranovskyi <mkbaranovskyi@gmail.com>
+Michael Chen <4326639+mcgitty@users.noreply.github.com>
+François-Denis Gonthier <francois-denis.gonthier@opersys.com>
+Dr <dr@dr.run>
+Nitzan Uziely <linkgoron@gmail.com>
+Adrien Maret <adrien@maret.email>
+Thiago Padilha <thiago@padilha.cc>
+Joseph Hackman <josephhackman@gmail.com>
+Pranshu Jethmalani <pmj642@gmail.com>
+Rohan Chougule <rohan183chougule@gmail.com>
+Mohamed Kamagate <kamagatos@gmail.com>
+Ajay Poshak <poshakajay@gmail.com>
+Isaac Levy <isaac.r.levy@gmail.com>
+ugultopu <ugultopu@users.noreply.github.com>
+Nicholas Schamberg <schamberg.nicholas@gmail.com>
+Dimitris Halatsis <dimitris_ha@hotmail.com>
+Mattia Pontonio <44380480+mattiapontonio@users.noreply.github.com>
+Milad Fa <mfarazma@redhat.com>
+Emil Sivervik <emil@sivervik.com>
+alexbs <alexbs@users.noreply.github.com>
+Ian Storm Taylor <ian@ianstormtaylor.com>
+Carlos Fuentes <carlos.fuentes.rios.95@gmail.com>
+Tyler Ang-Wanek <tylerw@axosoft.com>
+Matthew Mario Di Pasquale <liveloveprosper@gmail.com>
+ttzztztz <ttzztztz@outlook.com>
+Romuald Brillout <github@brillout.com>
+Dave Cardwell <hello@davecardwell.com>
+Akash Negi <55234838+NegiAkash890@users.noreply.github.com>
+James Addison <jay@jp-hosting.net>
+Fabian Cook <hello@fabiancook.dev>
+Kalvin Vasconcellos <kalvin.vasconcellos@gmail.com>
+marsonya <akhil.marsonya27@gmail.com>
+Qingyu Deng <i@ayase-lab.com>
+Matin Zadehdolatabad <zadehdolatabad@gmail.com>
+Daniel Clark <daniec@microsoft.com>
+Sajal Khandelwal <skhandelwa22@bloomberg.net>
+Cheng Liu <liucheng.tech@outlook.com>
+Utku Gultopu <ugultopu@gmail.com>
+Jay Tailor <60511316+JayvaScript@users.noreply.github.com>
+Greg Ziskind <gregory.ziskind@synergistcomputing.com>
+Dan Čermák <dcermak@suse.com>
+Vít Ondruch <vondruch@redhat.com>
+humanwebpl <58517331+humanwebpl@users.noreply.github.com>
+Dawid Rusnak <dawid@drcode.pl>
+obi-el <elobiobinna@gmail.com>
+Merlin Luntke <22600241+Luntke@users.noreply.github.com>
+Marko Kaznovac <kaznovac@users.noreply.github.com>
+Gabriel Schulhof <gabrielschulhof@gmail.com>
+Ian Kerins <ianskerins@gmail.com>
+dbachko <dbachko@gmail.com>
+Mattias Buelens <mattias@buelens.com>
+Dylan Elliott <dylanelliott27@hotmail.com>
+Wassim Chegham <github@wassim.dev>
+simov <simeonvelichkov@gmail.com>
+wwwzbwcom <zbwhome@outlook.com>
+David Glasser <glasser@davidglasser.net>
+pezhmanparsaee <p.parsaee@gmail.com>
+Hassaan Pasha <pasha.hassaan@gmail.com>
+Darkripper214 <phakorn214@gmail.com>
+Anu Pasumarthy <anupama.pasumarthy@gmail.com>
+HiroyukiYagihashi <hey@hiroy.uk>
+Arkerone <shaita.axel@gmail.com>
+Voltrex <mohammadkeyvanzade94@gmail.com>
+ycjcl868 <45808948@qq.com>
+Serkan Özel <serkanozel380@gmail.com>
+Ferdi <iguessitsokaythen@gmail.com>
+eladkeyshawn <elad.keyshawn@gmail.com>
+luyahan <yahan@iscas.ac.cn>
+Simon Knott <info@simonknott.de>
+Siddharth <siddharth.muscat@gmail.com>
+Cactysman <git@cactys.dev>
+David Brownman <beamneocube@gmail.com>
+Michael Rommel <rommel@layer-7.net>
+Chengzhong Wu <chengzhong.wcz@alibaba-inc.com>
+Andres <and.atencio@gmail.com>
+Jayden Seric <me@jaydenseric.com>
+divlo <contact@divlo.fr>
+Rohit Gohri <work@rohit.page>
+Giora Guttsait <giora111@gmail.com>
+takayama <takayama@foxmail.com>
+Rafael Gonzaga <rafael.nunu@hotmail.com>
+Arnold Zokas <arnold.zokas@coderoom.net>
+Nils Dralle <nils.91@googlemail.com>
+Jesse Chan <jc@linux.com>
+helloyou2012 <helloyou2012@yeah.net>
+MrJithil <jithil@outlook.com>
+Rodolfo Carvalho <rhcarvalho@gmail.com>
+Jordan Baczuk <JBaczuk@users.noreply.github.com>
+moander <moander@outlook.com>
+Hitesh Sharma <hitesh9sharma@gmail.com>
+Andreas Schwab <schwab@suse.de>
+Moritz Kneilmann <hi@kneilmann.tech>
+fisker Cheung <lionkay@gmail.com>
+Issam E. Maghni <issam.e.maghni@mailbox.org>
+TodorTotev <51530311+TodorTotev@users.noreply.github.com>
+Wael Almattar <waelsy123@gmail.com>
+yotamselementor <83912471+yotamselementor@users.noreply.github.com>
+pengjie <37610029@qq.com>
+Philip <phershbe@gmail.com>
+julianjany <54538266+julianjany@users.noreply.github.com>
+bl-ue <bl-ue@users.noreply.github.com>
+npm-robot <ops+robot@npmjs.com>
+Shaun Keys <mariobuddy@gmail.com>
+Simone Busoli <simone.busoli@nearform.com>
+Derevianchenko Maksym <32910350+maks-white@users.noreply.github.com>
+RA80533 <32469082+RA80533@users.noreply.github.com>
+Mao Wtm <m@maowtm.org>
+Houssem Chebab <houssemchebeb@gmail.com>
+Davidson Francis <davidsondfgl@gmail.com>
+Rohan Sharma <rhnsharma5113@gmail.com>
+AkshayK <iit.akshay@gmail.com>
+FrankEntriken <42781627+FrankEntriken@users.noreply.github.com>
+Cyrille Bourgois <cyrille.bourgois@gmail.com>
+Jacob <3012099+JakobJingleheimer@users.noreply.github.com>
+ejose19 <8742215+ejose19@users.noreply.github.com>
+Tobias Koppers <tobias.koppers@googlemail.com>
+Makoto Kato <m_kato@ga2.so-net.ne.jp>
+foxxyz <foxxyz@gmail.com>
+LitoMore <litomore@gmail.com>
+nerdthatnoonelikes <kenrag24@gmail.com>
+Nikita Rykov <40735471+angrymouse@users.noreply.github.com>
+Benjamin Mayr <b.mayr@cognigy.com>
+Lew Gordon <lew.gordon@genesys.com>
+Mestery <mestery@pm.me>
+Himadri Ganguly <himadri.tech@gmail.com>
+Howie Zhao <howiezhaohr@hotmail.com>
+Luan Devecchi <luan@engineer.com>
 
 # Generated by tools/update-authors.js
diff --git a/BSDmakefile b/BSDmakefile
index b2f36fa28720f182692f6670bb24fbcc7ebf7a0d..3994ab9efd9a4d2f8c3544ab84c93fedafe75258 100644
--- a/BSDmakefile
+++ b/BSDmakefile
@@ -3,7 +3,7 @@ FLAGS=${.MAKEFLAGS:C/\-J ([0-9]+,?)+//W}
 
 all: .DEFAULT
 .DEFAULT:
-	@which gmake > /dev/null 2>&1 ||\
+	@command -v gmake > /dev/null 2>&1 ||\
 		(echo "GMake is required for node.js to build.\
 			Install and try again" && exit 1)
 	@gmake ${.FLAGS} ${.TARGETS}
diff --git a/BUILDING.md b/BUILDING.md
index 85d8d1ffa159ecb2df93d3b45246ec911ae6fe8c..5d2459eb76548fb4b7ea481ef913d652bcfb13fa 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -8,7 +8,7 @@ If you can reproduce a test failure, search for it in the
 [Node.js issue tracker](https://github.com/nodejs/node/issues) or
 file a new issue.
 
-## Table of Contents
+## Table of contents
 
 * [Supported platforms](#supported-platforms)
   * [Input](#input)
@@ -24,11 +24,13 @@ file a new issue.
     * [Unix prerequisites](#unix-prerequisites)
     * [macOS prerequisites](#macos-prerequisites)
     * [Building Node.js](#building-nodejs-1)
+    * [Installing Node.js](#installing-nodejs)
     * [Running Tests](#running-tests)
     * [Running Coverage](#running-coverage)
     * [Building the documentation](#building-the-documentation)
     * [Building a debug build](#building-a-debug-build)
     * [Building an ASAN build](#building-an-asan-build)
+    * [Speeding up frequent rebuilds when developing](#speeding-up-frequent-rebuilds-when-developing)
     * [Troubleshooting Unix and macOS builds](#troubleshooting-unix-and-macos-builds)
   * [Windows](#windows)
     * [Prerequisites](#prerequisites)
@@ -37,21 +39,23 @@ file a new issue.
     * [Building Node.js](#building-nodejs-2)
   * [Android/Android-based devices (e.g. Firefox OS)](#androidandroid-based-devices-eg-firefox-os)
 * [`Intl` (ECMA-402) support](#intl-ecma-402-support)
-  * [Default: `small-icu` (English only) support](#default-small-icu-english-only-support)
   * [Build with full ICU support (all locales supported by ICU)](#build-with-full-icu-support-all-locales-supported-by-icu)
     * [Unix/macOS](#unixmacos)
     * [Windows](#windows-1)
-  * [Building without Intl support](#building-without-intl-support)
+  * [Trimmed: `small-icu` (English only) support](#trimmed-small-icu-english-only-support)
     * [Unix/macOS](#unixmacos-1)
     * [Windows](#windows-2)
-  * [Use existing installed ICU (Unix/macOS only)](#use-existing-installed-icu-unixmacos-only)
-  * [Build with a specific ICU](#build-with-a-specific-icu)
+  * [Building without Intl support](#building-without-intl-support)
     * [Unix/macOS](#unixmacos-2)
     * [Windows](#windows-3)
+  * [Use existing installed ICU (Unix/macOS only)](#use-existing-installed-icu-unixmacos-only)
+  * [Build with a specific ICU](#build-with-a-specific-icu)
+    * [Unix/macOS](#unixmacos-3)
+    * [Windows](#windows-4)
 * [Building Node.js with FIPS-compliant OpenSSL](#building-nodejs-with-fips-compliant-openssl)
 * [Building Node.js with external core modules](#building-nodejs-with-external-core-modules)
-  * [Unix/macOS](#unixmacos-3)
-  * [Windows](#windows-4)
+  * [Unix/macOS](#unixmacos-4)
+  * [Windows](#windows-5)
 * [Note for downstream distributors of Node.js](#note-for-downstream-distributors-of-nodejs)
 
 ## Supported platforms
@@ -105,10 +109,12 @@ platforms. This is true regardless of entries in the table below.
 | GNU/Linux        | armv6            | kernel >= 4.14, glibc >= 2.24   | Experimental | Downgraded as of Node.js 12       |
 | GNU/Linux        | ppc64le >=power8 | kernel >= 3.10.0, glibc >= 2.17 | Tier 2       | e.g. Ubuntu 16.04 <sup>[1](#fn1)</sup>, EL 7  <sup>[2](#fn2)</sup> |
 | GNU/Linux        | s390x            | kernel >= 3.10.0, glibc >= 2.17 | Tier 2       | e.g. EL 7 <sup>[2](#fn2)</sup>    |
-| Windows          | x64, x86 (WoW64) | >= Windows 7/2008 R2/2012 R2    | Tier 1       | <sup>[4](#fn4),[5](#fn5)</sup>    |
-| Windows          | x86 (native)     | >= Windows 7/2008 R2/2012 R2    | Tier 1 (running) / Experimental (compiling) <sup>[6](#fn6)</sup> | |
-| Windows          | arm64            | >= Windows 10                   | Experimental |                                   |
+| Windows          | x64, x86 (WoW64) | >= Windows 8.1/2012 R2          | Tier 1       | <sup>[4](#fn4),[5](#fn5)</sup>    |
+| Windows          | x86 (native)     | >= Windows 8.1/2012 R2          | Tier 1 (running) / Experimental (compiling) <sup>[6](#fn6)</sup> | |
+| Windows          | x64, x86         | Windows Server 2012 (not R2)    | Experimental |                                   |
+| Windows          | arm64            | >= Windows 10                   | Tier 2 (compiling) / Experimental (running) |    |
 | macOS            | x64              | >= 10.11                        | Tier 1       |                                   |
+| macOS            | arm64            | >= 11                           | Experimental |                                   |
 | SmartOS          | x64              | >= 18                           | Tier 2       |                                   |
 | AIX              | ppc64be >=power7 | >= 7.2 TL02                     | Tier 2       |                                   |
 | FreeBSD          | x64              | >= 11                           | Experimental | Downgraded as of Node.js 12  <sup>[7](#fn7)</sup>     |
@@ -157,26 +163,25 @@ Depending on the host platform, the selection of toolchains may vary.
 | ---------------- | -------------------------------------------------------------- |
 | Linux            | GCC >= 6.3                                                     |
 | Windows          | Visual Studio >= 2017 with the Windows 10 SDK on a 64-bit host |
-| macOS            | Xcode >= 8 (Apple LLVM >= 8)                                   |
+| macOS            | Xcode >= 10 (Apple LLVM >= 10)                                 |
 
 ### Official binary platforms and toolchains
 
 Binaries at <https://nodejs.org/download/release/> are produced on:
 
-| Binary package        | Platform and Toolchain                                                   |
-| --------------------- | ------------------------------------------------------------------------ |
-| aix-ppc64             | AIX 7.1 TL05 on PPC64BE with GCC 6                                       |
-| darwin-x64 (and .pkg) | macOS 10.15, Xcode Command Line Tools 11 with -mmacosx-version-min=10.10 |
-| linux-arm64           | CentOS 7 with devtoolset-6 / GCC 6                                       |
-| linux-armv7l          | Cross-compiled on Ubuntu 16.04 x64 with [custom GCC toolchain](https://github.com/rvagg/rpi-newer-crosstools)   |
-| linux-ppc64le         | CentOS 7 with devtoolset-6 / GCC 6 <sup>[7](#fn7)</sup>                  |
-| linux-s390x           | RHEL 7 with devtoolset-6 / GCC 6 <sup>[7](#fn7)</sup>                    |
-| linux-x64             | CentOS 7 with devtoolset-6 / GCC 6 <sup>[7](#fn7)</sup>                  |
-| sunos-x64             | SmartOS 18 with GCC 7                                                    |
-| win-x64 and win-x86   | Windows 2012 R2 (x64) with Visual Studio 2017                            |
-
-<em id="fn7">7</em>: The Enterprise Linux devtoolset-6 allows us to compile
-binaries with GCC 6 but linked to the glibc and libstdc++ versions of the host
+| Binary package        | Platform and Toolchain                                                                                        |
+| --------------------- | ------------------------------------------------------------------------------------------------------------- |
+| aix-ppc64             | AIX 7.1 TL05 on PPC64BE with GCC 6                                                                            |
+| darwin-x64 (and .pkg) | macOS 10.15, Xcode Command Line Tools 11 with -mmacosx-version-min=10.13                                      |
+| linux-arm64           | CentOS 7 with devtoolset-8 / GCC 8 <sup>[8](#fn8)</sup>                                                       |
+| linux-armv7l          | Cross-compiled on Ubuntu 18.04 x64 with [custom GCC toolchain](https://github.com/rvagg/rpi-newer-crosstools) |
+| linux-ppc64le         | CentOS 7 with devtoolset-8 / GCC 8 <sup>[8](#fn8)</sup>                                                       |
+| linux-s390x           | RHEL 7 with devtoolset-8 / GCC 8 <sup>[8](#fn8)</sup>                                                         |
+| linux-x64             | CentOS 7 with devtoolset-8 / GCC 8 <sup>[8](#fn8)</sup>                                                       |
+| win-x64 and win-x86   | Windows 2012 R2 (x64) with Visual Studio 2019                                                                 |
+
+<em id="fn8">8</em>: The Enterprise Linux devtoolset-8 allows us to compile
+binaries with GCC 8 but linked to the glibc and libstdc++ versions of the host
 platforms (CentOS 7 / RHEL 7). Therefore, binaries produced on these systems
 are compatible with glibc >= 2.17 and libstdc++ >= 6.0.20 (`GLIBCXX_3.4.20`).
 These are available on distributions natively supporting GCC 4.9, such as
@@ -213,27 +218,18 @@ Supported platforms and toolchains change with each major version of Node.js.
 This document is only valid for the current major version of Node.js.
 Consult previous versions of this document for older versions of Node.js:
 
-* [Node.js 13](https://github.com/nodejs/node/blob/v13.x/BUILDING.md)
+* [Node.js 14](https://github.com/nodejs/node/blob/v14.x/BUILDING.md)
 * [Node.js 12](https://github.com/nodejs/node/blob/v12.x/BUILDING.md)
 * [Node.js 10](https://github.com/nodejs/node/blob/v10.x/BUILDING.md)
-* [Node.js 8](https://github.com/nodejs/node/blob/v8.x/BUILDING.md)
 
 ## Building Node.js on supported platforms
 
 ### Note about Python 2 and Python 3
 
-The Node.js project uses Python as part of its build process and has
-historically only been Python 2 compatible.
-
-Python 2 will reach its _End-of-Life_ at the end of 2019 at which point the
-interpreter will cease receiving updates. See <https://python3statement.org/>
-for more information.
-
-The Node.js project is in the process of transitioning its Python code to
-Python 3 compatibility. Installing both versions of Python while building
-and testing Node.js allows developers and end users to test, benchmark,
-and debug Node.js running on both versions to ensure a smooth and complete
-transition before the year-end deadline.
+The Node.js project supports both Python 3 and Python 2 for building.
+If both are installed Python 3 will be used. If only Python 2 is available
+it will be used instead. When possible we recommend that you build and
+test with Python 3.
 
 ### Unix and macOS
 
@@ -243,7 +239,7 @@ transition before the year-end deadline.
 * GNU Make 3.81 or newer
 * Python (see note above)
   * Python 2.7
-  * Python 3.5, 3.6, and 3.7 are experimental.
+  * Python 3.5, 3.6, 3.7, 3.8, 3.9 or 3.10 (see note above)
 
 Installation via Linux package manager can be achieved with:
 
@@ -255,14 +251,12 @@ Installation via Linux package manager can be achieved with:
 
 FreeBSD and OpenBSD users may also need to install `libexecinfo`.
 
-Python 3 users may also need to install `python3-distutils`.
-
 #### macOS prerequisites
 
-* Xcode Command Line Tools >= 8 for macOS
+* Xcode Command Line Tools >= 10 for macOS
 * Python (see note above)
   * Python 2.7
-  * Python 3.5, 3.6, and 3.7 are experimental.
+  * Python 3.6, 3.7, 3.8, 3.9, or 3.10 (see note above)
 
 macOS users can install the `Xcode Command Line Tools` by running
 `xcode-select --install`. Alternatively, if you already have the full Xcode
@@ -282,11 +276,6 @@ $ ./configure
 $ make -j4
 ```
 
-If you run into a `No module named 'distutils.spawn'` error when executing
-`./configure`, please try `python3 -m pip install --upgrade setuptools` or
-`sudo apt install python3-distutils -y`.
-For more information, see <https://github.com/nodejs/node/issues/30189>.
-
 The `-j4` option will cause `make` to run 4 simultaneous compilation jobs which
 may reduce build time. For more information, see the
 [GNU Make Documentation](https://www.gnu.org/software/make/manual/html_node/Parallel.html).
@@ -305,7 +294,15 @@ project's root directory.
 $ sudo ./tools/macos-firewall.sh
 ```
 
-#### Running Tests
+#### Installing Node.js
+
+To install this version of Node.js into a system directory:
+
+```bash
+[sudo] make install
+```
+
+#### Running tests
 
 To verify the build:
 
@@ -315,7 +312,7 @@ $ make test-only
 
 At this point, you are ready to make code changes and re-run the tests.
 
-If you are running tests before submitting a Pull Request, the recommended
+If you are running tests before submitting a pull request, the recommended
 command is:
 
 ```console
@@ -375,7 +372,7 @@ You can use
 [node-code-ide-configs](https://github.com/nodejs/node-code-ide-configs)
 to run/debug tests, if your IDE configs are present.
 
-#### Running Coverage
+#### Running coverage
 
 It's good practice to ensure any code you add or change is covered by tests.
 You can do so by running the test suite with coverage enabled:
@@ -386,28 +383,32 @@ $ make coverage
 ```
 
 A detailed coverage report will be written to `coverage/index.html` for
-JavaScript coverage and to `coverage/cxxcoverage.html` for C++ coverage
-(if you only want to run the JavaScript tests then you do not need to run
-the first command `./configure --coverage`).
-
-_Generating a test coverage report can take several minutes._
+JavaScript coverage and to `coverage/cxxcoverage.html` for C++ coverage.
 
-To collect coverage for a subset of tests you can set the `CI_JS_SUITES` and
-`CI_NATIVE_SUITES` variables (to run specific suites, e.g., `child-process`, in
-isolation, unset the opposing `_SUITES` variable):
+If you only want to run the JavaScript tests then you do not need to run
+the first command (`./configure --coverage`). Run `make coverage-run-js`,
+to execute JavaScript tests independently of the C++ test suite:
 
 ```text
-$ CI_JS_SUITES=child-process CI_NATIVE_SUITES= make coverage
+$ make coverage-run-js
 ```
 
-The above command executes tests for the `child-process` subsystem and
-outputs the resulting coverage report.
+If you are updating tests and want to collect coverage for a single test file
+(e.g. `test/parallel/test-stream2-transform.js`):
 
-Alternatively, you can run `make coverage-run-js`, to execute JavaScript tests
-independently of the C++ test suite:
+```text
+$ make coverage-clean
+$ NODE_V8_COVERAGE=coverage/tmp python tools/test.py test/parallel/test-stream2-transform.js
+$ make coverage-report-js
+```
+
+You can collect coverage for the entire suite of tests for a given subsystem
+by providing the name of a subsystem:
 
 ```text
-$ CI_JS_SUITES=fs CI_NATIVE_SUITES= make coverage-run-js
+$ make coverage-clean
+$ NODE_V8_COVERAGE=coverage/tmp python tools/test.py -J --mode=release child-process
+$ make coverage-report-js
 ```
 
 The `make coverage` command downloads some tools to the project root directory.
@@ -464,12 +465,6 @@ To test if Node.js was built correctly:
 ./node -e "console.log('Hello from Node.js ' + process.version)"
 ```
 
-To install this version of Node.js into a system directory:
-
-```bash
-[sudo] make install
-```
-
 #### Building a debug build
 
 If you run into an issue where the information provided by the JS stack trace
@@ -525,6 +520,29 @@ $  ./configure --debug --enable-asan && make -j4
 $ make test-only
 ```
 
+#### Speeding up frequent rebuilds when developing
+
+If you plan to frequently rebuild Node.js, especially if using several branches,
+installing `ccache` can help to greatly reduce build times. Set up with:
+```console
+$ sudo apt install ccache   # for Debian/Ubuntu, included in most Linux distros
+$ ccache -o cache_dir=<tmp_dir>
+$ ccache -o max_size=5.0G
+$ export CC="ccache gcc"    # add to your .profile
+$ export CXX="ccache g++"   # add to your .profile
+```
+This will allow for near-instantaneous rebuilds even when switching branches.
+
+When modifying only the JS layer in `lib`, it is possible to externally load it
+without modifying the executable:
+```console
+$ ./configure --node-builtin-modules-path $(pwd)
+```
+The resulting binary won't include any JS files and will try to load them from
+the specified directory. The JS debugger of Visual Studio Code supports this
+configuration since the November 2020 version and allows for setting
+breakpoints.
+
 #### Troubleshooting Unix and macOS builds
 
 Stale builds can sometimes result in `file not found` errors while building.
@@ -542,12 +560,12 @@ to run it again before invoking `make -j4`.
 
 ##### Option 1: Manual install
 
-* [Python 2.7](https://www.python.org/downloads/)
+* [Python 3.8](https://www.python.org/downloads/)
 * The "Desktop development with C++" workload from
-  [Visual Studio 2017](https://www.visualstudio.com/downloads/) or the
-  "Visual C++ build tools" workload from the
-  [Build Tools](https://www.visualstudio.com/downloads/#build-tools-for-visual-studio-2017),
-  with the default optional components.
+  [Visual Studio 2017 or 2019](https://visualstudio.microsoft.com/downloads/) or
+  the "Visual C++ build tools" workload from the
+  [Build Tools](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019),
+  with the default optional components
 * Basic Unix tools required for some tests,
   [Git for Windows](https://git-scm.com/download/win) includes Git Bash
   and tools which can be included in the global `PATH`.
@@ -559,13 +577,13 @@ to run it again before invoking `make -j4`.
 Optional requirements to build the MSI installer package:
 
 * The [WiX Toolset v3.11](https://wixtoolset.org/releases/) and the
-  [Wix Toolset Visual Studio 2017 Extension](https://marketplace.visualstudio.com/items?itemName=RobMensching.WixToolsetVisualStudio2017Extension).
+  [Wix Toolset Visual Studio 2017 Extension](https://marketplace.visualstudio.com/items?itemName=RobMensching.WixToolsetVisualStudio2017Extension)
+  or the [Wix Toolset Visual Studio 2019 Extension](https://marketplace.visualstudio.com/items?itemName=WixToolset.WixToolsetVisualStudio2019Extension).
+* The [WiX Toolset v3.14](https://wixtoolset.org/releases/) if
+  building for Windows 10 on ARM (ARM64)
 
 Optional requirements for compiling for Windows 10 on ARM (ARM64):
 
-* ARM64 Windows build machine
-  * Due to a GYP limitation, this is required to run compiled code
-    generation tools (like V8's builtins and mksnapshot tools)
 * Visual Studio 15.9.0 or newer
 * Visual Studio optional components
   * Visual C++ compilers and libraries for ARM64
@@ -580,7 +598,7 @@ This script will install the following [Chocolatey](https://chocolatey.org/)
 packages:
 
 * [Git for Windows](https://chocolatey.org/packages/git) with the `git` and
-  Unix tools added to the `PATH`.
+  Unix tools added to the `PATH`
 * [Python 3.x](https://chocolatey.org/packages/python) and
   [legacy Python](https://chocolatey.org/packages/python2)
 * [Visual Studio 2019 Build Tools](https://chocolatey.org/packages/visualstudio2019buildtools)
@@ -589,7 +607,7 @@ packages:
 
 To install Node.js prerequisites using
 [Boxstarter WebLauncher](https://boxstarter.org/WebLauncher), open
-<https://boxstarter.org/package/nr/url?https://raw.githubusercontent.com/nodejs/node/master/tools/bootstrap/windows_boxstarter>
+<https://boxstarter.org/package/nr/url?https://raw.githubusercontent.com/nodejs/node/HEAD/tools/bootstrap/windows_boxstarter>
 with Internet Explorer or Edge browser on the target machine.
 
 Alternatively, you can use PowerShell. Run those commands from an elevated
@@ -599,7 +617,7 @@ PowerShell terminal:
 Set-ExecutionPolicy Unrestricted -Force
 iex ((New-Object System.Net.WebClient).DownloadString('https://boxstarter.org/bootstrapper.ps1'))
 get-boxstarter -Force
-Install-BoxstarterPackage https://raw.githubusercontent.com/nodejs/node/master/tools/bootstrap/windows_boxstarter -DisableReboots
+Install-BoxstarterPackage https://raw.githubusercontent.com/nodejs/node/HEAD/tools/bootstrap/windows_boxstarter -DisableReboots
 ```
 
 The entire installation using Boxstarter will take up approximately 10 GB of
@@ -644,32 +662,41 @@ $ make
 
 ## `Intl` (ECMA-402) support
 
-[Intl](https://github.com/nodejs/node/blob/master/doc/api/intl.md) support is
-enabled by default, with English data only.
+[Intl](https://github.com/nodejs/node/blob/HEAD/doc/api/intl.md) support is
+enabled by default.
 
-### Default: `small-icu` (English only) support
+### Build with full ICU support (all locales supported by ICU)
 
-By default, only English data is included, but
-the full `Intl` (ECMA-402) APIs.  It does not need to download
-any dependencies to function. You can add full
-data at runtime.
+This is the default option.
 
-### Build with full ICU support (all locales supported by ICU)
+#### Unix/macOS
+
+```console
+$ ./configure --with-intl=full-icu
+```
+
+#### Windows
 
-With the `--download=all`, this may download ICU if you don't have an
-ICU in `deps/icu`. (The embedded `small-icu` included in the default
-Node.js source does not include all locales.)
+```console
+> .\vcbuild full-icu
+```
+
+### Trimmed: `small-icu` (English only) support
+
+ In this configuration, only English data is included, but
+the full `Intl` (ECMA-402) APIs.  It does not need to download
+any dependencies to function. You can add full data at runtime.
 
 #### Unix/macOS
 
 ```console
-$ ./configure --with-intl=full-icu --download=all
+$ ./configure --with-intl=small-icu
 ```
 
 #### Windows
 
 ```console
-> .\vcbuild full-icu download-all
+> .\vcbuild small-icu
 ```
 
 ### Building without Intl support
@@ -779,4 +806,4 @@ When Node.js is built (with an intention to distribute) with an ABI
 incompatible with the official Node.js builds (e.g. using a ABI incompatible
 version of a dependency), please reserve and use a custom `NODE_MODULE_VERSION`
 by opening a pull request against the registry available at
-<https://github.com/nodejs/node/blob/master/doc/abi_version_registry.json>.
+<https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json>.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7cb8c234c20cc85b23020a6bacc5a435044fbeba..946430073dfa2d98f22b51c42c37891a4c8d05c1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,9 +2,11 @@
 
 Select a Node.js version below to view the changelog history:
 
-* [Node.js 12](doc/changelogs/CHANGELOG_V12.md) **Long Term Support**
+* [Node.js 14](doc/changelogs/CHANGELOG_V14.md) **Long Term Support**
+* [Node.js 13](doc/changelogs/CHANGELOG_V13.md) End-of-Life
+* [Node.js 12](doc/changelogs/CHANGELOG_V12.md) Long Term Support
 * [Node.js 11](doc/changelogs/CHANGELOG_V11.md) End-of-Life
-* [Node.js 10](doc/changelogs/CHANGELOG_V10.md) Long Term Support
+* [Node.js 10](doc/changelogs/CHANGELOG_V10.md) End-of-Life
 * [Node.js 9](doc/changelogs/CHANGELOG_V9.md) End-of-Life
 * [Node.js 8](doc/changelogs/CHANGELOG_V8.md) End-of-Life
 * [Node.js 7](doc/changelogs/CHANGELOG_V7.md) End-of-Life
@@ -22,34 +24,50 @@ release.
 <!--lint disable maximum-line-length-->
 <table>
 <tr>
+  <th title="LTS Until 2023-04"><a href="doc/changelogs/CHANGELOG_V14.md">14</a><sup>LTS</sup></th>
   <th title="LTS Until 2022-04"><a href="doc/changelogs/CHANGELOG_V12.md">12</a><sup>LTS</sup></th>
-  <th title="LTS Until 2021-04"><a href="doc/changelogs/CHANGELOG_V10.md">10</a><sup>LTS</sup></th>
-  <th title="LTS Until 2019-12"><a href="doc/changelogs/CHANGELOG_V8.md">8</a><sup>LTS</sup></th>
 </tr>
 <tr>
     <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V12.md#12.22.7">12.22.7</a></b><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.22.6">12.22.6</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.22.5">12.22.5</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.22.4">12.22.4</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.22.3">12.22.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.22.2">12.22.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.22.1">12.22.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.22.0">12.22.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.21.0">12.21.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.20.2">12.20.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.20.1">12.20.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.20.0">12.20.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.19.1">12.19.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.19.0">12.19.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.18.4">12.18.4</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.18.3">12.18.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.18.2">12.18.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.18.1">12.18.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.18.0">12.18.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.17.0">12.17.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.16.3">12.16.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V12.md#12.16.2">12.16.2</a><br/>
+<b><a href="doc/changelogs/CHANGELOG_V14.md#14.18.3">14.18.3</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.18.2">14.18.2</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.18.1">14.18.1</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.18.0">14.18.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.17.6">14.17.6</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.17.5">14.17.5</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.17.4">14.17.4</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.17.3">14.17.3</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.17.2">14.17.2</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.17.1">14.17.1</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.17.0">14.17.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.16.1">14.16.1</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.16.0">14.16.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.15.5">14.15.5</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.15.4">14.15.4</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.15.3">14.15.3</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.15.2">14.15.2</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.15.1">14.15.1</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.15.0">14.15.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.14.0">14.14.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.13.1">14.13.1</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.13.0">14.13.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.12.0">14.12.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.11.0">14.11.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.10.1">14.10.1</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.10.0">14.10.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.9.0">14.9.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.8.0">14.8.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.7.0">14.7.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.6.0">14.6.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.5.0">14.5.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.4.0">14.4.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.3.0">14.3.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.2.0">14.2.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.1.0">14.1.0</a><br/>
+<a href="doc/changelogs/CHANGELOG_V14.md#14.0.0">14.0.0</a><br/>
+    </td>
+    <td valign="top">
+<b><a href="doc/changelogs/CHANGELOG_V12.md#12.16.2">12.16.2</a></b><br/>
 <a href="doc/changelogs/CHANGELOG_V12.md#12.16.1">12.16.1</a><br/>
 <a href="doc/changelogs/CHANGELOG_V12.md#12.16.0">12.16.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V12.md#12.15.0">12.15.0</a><br/>
@@ -75,66 +93,6 @@ release.
 <a href="doc/changelogs/CHANGELOG_V12.md#12.1.0">12.1.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V12.md#12.0.0">12.0.0</a><br/>
     </td>
-    <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V10.md#10.15.3">10.15.3</a></b><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.15.2">10.15.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.15.1">10.15.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.15.0">10.15.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.14.2">10.14.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.14.1">10.14.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.14.0">10.14.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.13.0">10.13.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.12.0">10.12.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.11.0">10.11.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.10.0">10.10.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.9.0">10.9.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.8.0">10.8.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.7.0">10.7.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.6.0">10.6.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.5.0">10.5.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.4.1">10.4.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.4.0">10.4.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.3.0">10.3.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.2.1">10.2.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.2.0">10.2.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.1.0">10.1.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V10.md#10.0.0">10.0.0</a><br/>
-    </td>
-    <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V8.md#8.16.0">8.16.0</a></b><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.15.1">8.15.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.15.0">8.15.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.14.1">8.14.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.14.0">8.14.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.13.0">8.13.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.12.0">8.12.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.11.4">8.11.4</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.11.3">8.11.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.11.2">8.11.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.11.1">8.11.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.11.0">8.11.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.10.0">8.10.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.9.4">8.9.4</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.9.3">8.9.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.9.2">8.9.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.9.1">8.9.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.9.0">8.9.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.8.1">8.8.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.8.0">8.8.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.7.0">8.7.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.6.0">8.6.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.5.0">8.5.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.4.0">8.4.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.3.0">8.3.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.2.1">8.2.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.2.0">8.2.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.1.4">8.1.4</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.1.3">8.1.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.1.2">8.1.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.1.1">8.1.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.1.0">8.1.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V8.md#8.0.0">8.0.0</a><br/>
-    </td>
 </tr>
 </table>
 
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 4c211405596cb42eac87cbf2c90c2764766fbb18..d724027fd9aadb9987b8213c66e78de32c31e042 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,4 +1,4 @@
 # Code of Conduct
 
-* [Node.js Code of Conduct](https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md)
-* [Node.js Moderation Policy](https://github.com/nodejs/admin/blob/master/Moderation-Policy.md)
+* [Node.js Code of Conduct](https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md)
+* [Node.js Moderation Policy](https://github.com/nodejs/admin/blob/HEAD/Moderation-Policy.md)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 29700978fb78bff41183f67d80d596279f1167b3..30db8cf9b12524a4340167b352fb7f69493a94c2 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -8,19 +8,17 @@
 ## [Code of Conduct](./doc/guides/contributing/code-of-conduct.md)
 
 The Node.js project has a
-[Code of Conduct](https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md)
+[Code of Conduct](https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md)
 to which all contributors must adhere.
 
 See [details on our policy on Code of Conduct](./doc/guides/contributing/code-of-conduct.md).
 
 ## [Issues](./doc/guides/contributing/issues.md)
 
-* [How to Contribute in Issues](./doc/guides/contributing/issues.md#how-to-contribute-in-issues)
 * [Asking for General Help](./doc/guides/contributing/issues.md#asking-for-general-help)
 * [Discussing non-technical topics](./doc/guides/contributing/issues.md#discussing-non-technical-topics)
 * [Submitting a Bug Report](./doc/guides/contributing/issues.md#submitting-a-bug-report)
 * [Triaging a Bug Report](./doc/guides/contributing/issues.md#triaging-a-bug-report)
-* [Resolving a Bug Report](./doc/guides/contributing/issues.md#resolving-a-bug-report)
 
 ## [Pull Requests](./doc/guides/contributing/pull-requests.md)
 
@@ -35,24 +33,24 @@ See [details on our policy on Code of Conduct](./doc/guides/contributing/code-of
 
 By making a contribution to this project, I certify that:
 
-* (a) The contribution was created in whole or in part by me and I
-  have the right to submit it under the open source license
-  indicated in the file; or
-
-* (b) The contribution is based upon previous work that, to the best
-  of my knowledge, is covered under an appropriate open source
-  license and I have the right under that license to submit that
-  work with modifications, whether created in whole or in part
-  by me, under the same open source license (unless I am
-  permitted to submit under a different license), as indicated
-  in the file; or
-
-* (c) The contribution was provided directly to me by some other
-  person who certified (a), (b) or (c) and I have not modified
-  it.
-
-* (d) I understand and agree that this project and the contribution
-  are public and that a record of the contribution (including all
-  personal information I submit with it, including my sign-off) is
-  maintained indefinitely and may be redistributed consistent with
-  this project or the open source license(s) involved.
+ (a) The contribution was created in whole or in part by me and I
+     have the right to submit it under the open source license
+     indicated in the file; or
+
+ (b) The contribution is based upon previous work that, to the best
+     of my knowledge, is covered under an appropriate open source
+     license and I have the right under that license to submit that
+     work with modifications, whether created in whole or in part
+     by me, under the same open source license (unless I am
+     permitted to submit under a different license), as indicated
+     in the file; or
+
+ (c) The contribution was provided directly to me by some other
+     person who certified (a), (b) or (c) and I have not modified
+     it.
+
+ (d) I understand and agree that this project and the contribution
+     are public and that a record of the contribution (including all
+     personal information I submit with it, including my sign-off) is
+     maintained indefinitely and may be redistributed consistent with
+     this project or the open source license(s) involved.
diff --git a/GOVERNANCE.md b/GOVERNANCE.md
index aeb1d9c65e1f110589b4ce16a0c88e7cd07e5de4..aa73e4b3ee7519d3f4334887e85315aaba5b02d7 100644
--- a/GOVERNANCE.md
+++ b/GOVERNANCE.md
@@ -15,45 +15,46 @@
 
 ## Triagers
 
-Triagers assess newly-opened issues in the nodejs/node and nodejs/help
-repositories. There is no GitHub team for triagers at the moment.
+Triagers assess newly-opened issues in the [nodejs/node][] and [nodejs/help][]
+repositories. The GitHub team for Node.js triagers is @nodejs/issue-triage.
+Triagers are given the "Triage" GitHub role and have:
 
-Triagers have:
-* ability to label issues
-* ability to comment, close, and reopen issues
+* Ability to label issues and pull requests
+* Ability to comment, close, and reopen issues and pull requests
 
 See:
 
+* [List of triagers](./README.md#triagers)
 * [A guide for triagers](./doc/guides/contributing/issues.md#triaging-a-bug-report)
 
 ## Collaborators
 
-Node.js Core Collaborators maintain the [nodejs/node][] GitHub repository.
-The GitHub team for Node.js Core Collaborators is @nodejs/collaborators.
+Node.js core collaborators maintain the [nodejs/node][] GitHub repository.
+The GitHub team for Node.js core collaborators is @nodejs/collaborators.
 Collaborators have:
 
 * Commit access to the [nodejs/node][] repository
 * Access to the Node.js continuous integration (CI) jobs
 
-Both Collaborators and non-Collaborators may propose changes to the Node.js
+Both collaborators and non-collaborators may propose changes to the Node.js
 source code. The mechanism to propose such a change is a GitHub pull request.
 Collaborators review and merge (_land_) pull requests.
 
-Two Collaborators must approve a pull request before the pull request can land.
-(One Collaborator approval is enough if the pull request has been open for more
-than 7 days.) Approving a pull request indicates that the Collaborator accepts
-responsibility for the change. Approval must be from Collaborators who are not
+Two collaborators must approve a pull request before the pull request can land.
+(One collaborator approval is enough if the pull request has been open for more
+than 7 days.) Approving a pull request indicates that the collaborator accepts
+responsibility for the change. Approval must be from collaborators who are not
 authors of the change.
 
-If a Collaborator opposes a proposed change, then the change cannot land. The
+If a collaborator opposes a proposed change, then the change cannot land. The
 exception is if the TSC votes to approve the change despite the opposition.
 Usually, involving the TSC is unnecessary. Often, discussions or further changes
-result in Collaborators removing their opposition.
+result in collaborators removing their opposition.
 
 See:
 
-* [List of Collaborators](./README.md#current-project-team-members)
-* [A guide for Collaborators](./doc/guides/collaborator-guide.md)
+* [List of collaborators](./README.md#current-project-team-members)
+* [A guide for collaborators](./doc/guides/collaborator-guide.md)
 
 ### Collaborator activities
 
@@ -63,12 +64,12 @@ See:
 * Participation in working groups
 * Merging pull requests
 
-The TSC can remove inactive Collaborators or provide them with _Emeritus_
+The TSC can remove inactive collaborators or provide them with _Emeritus_
 status. Emeriti may request that the TSC restore them to active status.
 
 ## Technical Steering Committee
 
-A subset of the Collaborators forms the Technical Steering Committee (TSC).
+A subset of the collaborators forms the Technical Steering Committee (TSC).
 The TSC has final authority over this project, including:
 
 * Technical direction
@@ -76,13 +77,13 @@ The TSC has final authority over this project, including:
 * Contribution policy
 * GitHub repository hosting
 * Conduct guidelines
-* Maintaining the list of Collaborators
+* Maintaining the list of collaborators
 
 The current list of TSC members is in
 [the project README](./README.md#current-project-team-members).
 
 The [TSC Charter][] governs the operations of the TSC. All changes to the
-Charter need approval by the OpenJS Foundation Board of Directors.
+Charter need approval by the OpenJS Foundation Cross-Project Council (CPC).
 
 ### TSC meetings
 
@@ -95,7 +96,7 @@ agenda is not to review or approve all patches. Collaborators review and approve
 patches on GitHub.
 
 Any community member can create a GitHub issue asking that the TSC review
-something. If consensus-seeking fails for an issue, a Collaborator may apply the
+something. If consensus-seeking fails for an issue, a collaborator may apply the
 `tsc-agenda` label. That will add it to the TSC meeting agenda.
 
 Before each TSC meeting, the meeting chair will share the agenda with members of
@@ -120,11 +121,11 @@ the issue tracker is:
 
 ## Collaborator nominations
 
-Existing Collaborators can nominate someone to become a Collaborator. Nominees
+Existing collaborators can nominate someone to become a collaborator. Nominees
 should have significant and valuable contributions across the Node.js
 organization.
 
-To nominate a new Collaborator, open an issue in the [nodejs/node][] repository.
+To nominate a new collaborator, open an issue in the [nodejs/node][] repository.
 Provide a summary of the nominee's contributions. For example:
 
 * Commits in the [nodejs/node][] repository.
@@ -144,24 +145,25 @@ Provide a summary of the nominee's contributions. For example:
   organization
 * Other participation in the wider Node.js community
 
-Mention @nodejs/collaborators in the issue to notify other Collaborators about
+Mention @nodejs/collaborators in the issue to notify other collaborators about
 the nomination.
 
-The nomination passes if no Collaborators oppose it after one week. Otherwise,
+The nomination passes if no collaborators oppose it after one week. Otherwise,
 the nomination fails.
 
 There are steps a nominator can take in advance to make a nomination as
-frictionless as possible. Use the [Collaborators discussion page][] to request
-feedback from other Collaborators in private. A nominator may also work with the
+frictionless as possible. To request feedback from other collaborators in
+ private, use the [collaborators discussion page][]
+ (which only collaborators may view). A nominator may also work with the
 nominee to improve their contribution profile.
 
 Collaborators might overlook someone with valuable contributions. In that case,
-the contributor may open an issue or contact a Collaborator to request a
+the contributor may open an issue or contact a collaborator to request a
 nomination.
 
 ### Onboarding
 
-After the nomination passes, a TSC member onboards the new Collaborator. See
+After the nomination passes, a TSC member onboards the new collaborator. See
 [the onboarding guide](./onboarding.md) for details of the onboarding
 process.
 
@@ -170,7 +172,8 @@ process.
 The TSC follows a [Consensus Seeking][] decision-making model per the
 [TSC Charter][].
 
-[Collaborators discussion page]: https://github.com/orgs/nodejs/teams/collaborators/discussions
 [Consensus Seeking]: https://en.wikipedia.org/wiki/Consensus-seeking_decision-making
-[TSC Charter]: https://github.com/nodejs/TSC/blob/master/TSC-Charter.md
+[TSC Charter]: https://github.com/nodejs/TSC/blob/HEAD/TSC-Charter.md
+[collaborators discussion page]: https://github.com/orgs/nodejs/teams/collaborators/discussions
+[nodejs/help]: https://github.com/nodejs/help
 [nodejs/node]: https://github.com/nodejs/node
diff --git a/LICENSE b/LICENSE
index 298631ee09e2dde64cab9514fb683528203f1774..1cc18f12bf8b0b0704b152ba99f477b09ee8b58a 100644
--- a/LICENSE
+++ b/LICENSE
@@ -53,30 +53,9 @@ The externally maintained libraries used by Node.js are:
 
 - Acorn, located at deps/acorn, is licensed as follows:
   """
-    Copyright (C) 2012-2018 by various contributors (see AUTHORS)
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-    THE SOFTWARE.
-  """
+    MIT License
 
-- Acorn plugins, located at deps/acorn-plugins, is licensed as follows:
-  """
-    Copyright (C) 2017-2018 by Adrian Heine
+    Copyright (C) 2012-2020 by various contributors (see AUTHORS)
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"), to deal
@@ -114,29 +93,6 @@ The externally maintained libraries used by Node.js are:
     purpose.  It is provided "as is" without express or implied warranty.
   """
 
-- HTTP Parser, located at deps/http_parser, is licensed as follows:
-  """
-    Copyright Joyent, Inc. and other Node contributors.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to
-    deal in the Software without restriction, including without limitation the
-    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-    sell copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-    IN THE SOFTWARE.
-  """
-
 - cjs-module-lexer, located at deps/cjs-module-lexer, is licensed as follows:
   """
     MIT License
@@ -439,9 +395,9 @@ The externally maintained libraries used by Node.js are:
      #  Copyright (c) 2013 International Business Machines Corporation
      #  and others. All Rights Reserved.
      #
-     # Project: http://code.google.com/p/lao-dictionary/
-     # Dictionary: http://lao-dictionary.googlecode.com/git/Lao-Dictionary.txt
-     # License: http://lao-dictionary.googlecode.com/git/Lao-Dictionary-LICENSE.txt
+     # Project: https://github.com/veer66/lao-dictionary
+     # Dictionary: https://github.com/veer66/lao-dictionary/blob/master/Lao-Dictionary.txt
+     # License: https://github.com/veer66/lao-dictionary/blob/master/Lao-Dictionary-LICENSE.txt
      #              (copied below)
      #
      #  This file is derived from the above dictionary, with slight
@@ -1082,6 +1038,7 @@ The externally maintained libraries used by Node.js are:
 
 - GYP, located at tools/gyp, is licensed as follows:
   """
+    Copyright (c) 2020 Node.js contributors. All rights reserved.
     Copyright (c) 2009 Google Inc. All rights reserved.
 
     Redistribution and use in source and binary forms, with or without
@@ -1268,12 +1225,12 @@ The externally maintained libraries used by Node.js are:
     THE SOFTWARE.
   """
 
-- babel-eslint, located at tools/node_modules/babel-eslint, is licensed as follows:
+- Babel, located at tools/node_modules/@babel, is licensed as follows:
   """
-    Copyright (c) 2014-2016 Sebastian McKenzie <sebmck@gmail.com>
-
     MIT License
 
+    Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
     Permission is hereby granted, free of charge, to any person obtaining
     a copy of this software and associated documentation files (the
     "Software"), to deal in the Software without restriction, including
@@ -1294,7 +1251,7 @@ The externally maintained libraries used by Node.js are:
     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   """
 
-- gtest, located at test/cctest/gtest, is licensed as follows:
+- gtest, located at deps/googletest, is licensed as follows:
   """
     Copyright 2008, Google Inc.
     All rights reserved.
@@ -1353,29 +1310,6 @@ The externally maintained libraries used by Node.js are:
     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   """
 
-- node-inspect, located at deps/node-inspect, is licensed as follows:
-  """
-    Copyright Node.js contributors. All rights reserved.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to
-    deal in the Software without restriction, including without limitation the
-    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-    sell copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-    IN THE SOFTWARE.
-  """
-
 - large_pages, located at src/large_pages, is licensed as follows:
   """
      Copyright (C) 2018 Intel Corporation
diff --git a/Makefile b/Makefile
index b8986e9a3c1a978bc3dfd11442a103a25a0201b8..c25a97750faccf228c4f6b4e8905d5471699e2d7 100644
--- a/Makefile
+++ b/Makefile
@@ -9,7 +9,7 @@ FLAKY_TESTS ?= run
 TEST_CI_ARGS ?=
 STAGINGSERVER ?= node-www
 LOGLEVEL ?= silent
-OSTYPE := $(shell uname -s | tr '[A-Z]' '[a-z]')
+OSTYPE := $(shell uname -s | tr '[:upper:]' '[:lower:]')
 COVTESTS ?= test-cov
 COV_SKIP_TESTS ?= core_line_numbers.js,testFinalizer.js,test_function/test.js
 GTEST_FILTER ?= "*"
@@ -35,12 +35,17 @@ V8_TEST_OPTIONS = $(V8_EXTRA_TEST_OPTIONS)
 ifdef DISABLE_V8_I18N
 	V8_BUILD_OPTIONS += i18nsupport=off
 endif
+# V8 build and test toolchains are not currently compatible with Python 3.
+# config.mk may have prepended a symlink for `python` to PATH which we need
+# to undo before calling V8's tools.
+OVERRIDE_BIN_DIR=$(dir $(abspath $(lastword $(MAKEFILE_LIST))))out/tools/bin
+NO_BIN_OVERRIDE_PATH=$(subst $() $(),:,$(filter-out $(OVERRIDE_BIN_DIR),$(subst :, ,$(PATH))))
 
 ifeq ($(OSTYPE), darwin)
 	GCOV = xcrun llvm-cov gcov
 endif
 
-BUILDTYPE_LOWER := $(shell echo $(BUILDTYPE) | tr '[A-Z]' '[a-z]')
+BUILDTYPE_LOWER := $(shell echo $(BUILDTYPE) | tr '[:upper:]' '[:lower:]')
 
 # Determine EXEEXT
 EXEEXT := $(shell $(PYTHON) -c \
@@ -53,7 +58,7 @@ NPM ?= ./deps/npm/bin/npm-cli.js
 
 # Flags for packaging.
 BUILD_DOWNLOAD_FLAGS ?= --download=all
-BUILD_INTL_FLAGS ?= --with-intl=small-icu
+BUILD_INTL_FLAGS ?= --with-intl=full-icu
 BUILD_RELEASE_FLAGS ?= $(BUILD_DOWNLOAD_FLAGS) $(BUILD_INTL_FLAGS)
 
 # Default to quiet/pretty builds.
@@ -65,8 +70,8 @@ V ?= 0
 available-node = \
 	if [ -x $(PWD)/$(NODE) ] && [ -e $(PWD)/$(NODE) ]; then \
 		$(PWD)/$(NODE) $(1); \
-	elif [ -x `which node` ] && [ -e `which node` ] && [ `which node` ]; then \
-		`which node` $(1); \
+	elif [ -x `command -v node` ] && [ -e `command -v node` ] && [ `command -v node` ]; then \
+		`command -v node` $(1); \
 	else \
 		echo "No available node, cannot run \"node $(1)\""; \
 		exit 1; \
@@ -85,7 +90,7 @@ endif
 # To add a target to the help, add a double comment (##) on the target line.
 help: ## Print help for targets with comments.
 	@printf "For more targets and info see the comments in the Makefile.\n\n"
-	@grep -E '^[a-zA-Z0-9._-]+:.*?## .*$$' Makefile | sort | \
+	@grep -E '^[[:alnum:]._-]+:.*?## .*$$' Makefile | sort | \
 		awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-15s\033[0m %s\n", $$1, $$2}'
 
 # The .PHONY is needed to ensure that we recursively use the out/Makefile
@@ -102,7 +107,7 @@ $(NODE_EXE): build_type:=Release
 $(NODE_G_EXE): build_type:=Debug
 $(NODE_EXE) $(NODE_G_EXE): config.gypi out/Makefile
 	$(MAKE) -C out BUILDTYPE=${build_type} V=$(V)
-	if [ ! -r $@ -o ! -L $@ ]; then \
+	if [ ! -r $@ ] || [ ! -L $@ ]; then \
 	  ln -fs out/${build_type}/$(NODE_EXE) $@; fi
 else
 ifeq ($(BUILD_WITH), ninja)
@@ -116,14 +121,14 @@ else
 endif
 $(NODE_EXE): config.gypi out/Release/build.ninja
 	ninja -C out/Release $(NINJA_ARGS)
-	if [ ! -r $@ -o ! -L $@ ]; then ln -fs out/Release/$(NODE_EXE) $@; fi
+	if [ ! -r $@ ] || [ ! -L $@ ]; then ln -fs out/Release/$(NODE_EXE) $@; fi
 
 $(NODE_G_EXE): config.gypi out/Debug/build.ninja
 	ninja -C out/Debug $(NINJA_ARGS)
-	if [ ! -r $@ -o ! -L $@ ]; then ln -fs out/Debug/$(NODE_EXE) $@; fi
+	if [ ! -r $@ ] || [ ! -L $@ ]; then ln -fs out/Debug/$(NODE_EXE) $@; fi
 else
 $(NODE_EXE) $(NODE_G_EXE):
-	echo This Makefile currently only supports building with 'make' or 'ninja'
+	$(warning This Makefile currently only supports building with 'make' or 'ninja')
 endif
 endif
 
@@ -133,15 +138,12 @@ CONFIG_FLAGS += --debug
 endif
 
 .PHONY: with-code-cache
-with-code-cache:
-	echo "'with-code-cache' target is a noop"
-
 .PHONY: test-code-cache
-test-code-cache: with-code-cache
-	echo "'test-code-cache' target is a noop"
+with-code-cache test-code-cache:
+	$(warning '$@' target is a noop)
 
 out/Makefile: config.gypi common.gypi node.gyp \
-	deps/uv/uv.gyp deps/http_parser/http_parser.gyp deps/zlib/zlib.gyp \
+	deps/uv/uv.gyp deps/llhttp/llhttp.gyp deps/zlib/zlib.gyp \
 	tools/v8_gypfiles/toolchain.gypi tools/v8_gypfiles/features.gypi \
 	tools/v8_gypfiles/inspector.gypi tools/v8_gypfiles/v8.gyp
 	$(PYTHON) tools/gyp_node.py -f make
@@ -150,7 +152,7 @@ out/Makefile: config.gypi common.gypi node.gyp \
 # and included in config.gypi
 config.gypi: configure configure.py src/node_version.h
 	@if [ -x config.status ]; then \
-		./config.status; \
+		export PATH="$(NO_BIN_OVERRIDE_PATH)" && ./config.status; \
 	else \
 		echo Missing or stale $@, please run ./$<; \
 		exit 1; \
@@ -200,39 +202,23 @@ check: test
 # Remove files generated by running coverage, put the non-instrumented lib back
 # in place
 coverage-clean:
-	if [ -d lib_ ]; then $(RM) -r lib; mv lib_ lib; fi
 	$(RM) -r node_modules
-	$(RM) -r gcovr build
-	$(RM) -r out/$(BUILDTYPE)/.coverage
-	$(RM) out/$(BUILDTYPE)/obj.target/node/gen/*.gcda
-	$(RM) out/$(BUILDTYPE)/obj.target/node/src/*.gcda
-	$(RM) out/$(BUILDTYPE)/obj.target/node/src/tracing/*.gcda
-	$(RM) out/$(BUILDTYPE)/obj.target/node/gen/*.gcno
-	$(RM) out/$(BUILDTYPE)/obj.target/node/src/*.gcno
-	$(RM) out/$(BUILDTYPE)/obj.target/node/src/tracing/*.gcno
-	$(RM) out/$(BUILDTYPE)/obj.target/cctest/src/*.gcno
-	$(RM) out/$(BUILDTYPE)/obj.target/cctest/test/cctest/*.gcno
-	$(RM) out/$(BUILDTYPE)/obj.target/embedtest/src/*.gcno
-	$(RM) out/$(BUILDTYPE)/obj.target/embedtest/test/embedding/*.gcno
+	$(RM) -r gcovr
+	$(RM) -r coverage/tmp
+	$(FIND) out/$(BUILDTYPE)/obj.target \( -name "*.gcda" -o -name "*.gcno" \) \
+		-type f -exec $(RM) {} \;
 
 .PHONY: coverage
-# Build and test with code coverage reporting.  Leave the lib directory
-# instrumented for any additional runs the user may want to make.
-# For C++ coverage reporting, this needs to be run in conjunction with configure
-#  --coverage.  html coverage reports will be created under coverage/
-# Related CI job: node-test-commit-linux-coverage
+# Build and test with code coverage reporting. HTML coverage reports will be
+# created under coverage/. For C++ coverage reporting, this needs to be run
+# in conjunction with configure --coverage.
+# Related CI job: node-test-commit-linux-coverage-daily
 coverage: coverage-test ## Run the tests and generate a coverage report.
 
 .PHONY: coverage-build
 coverage-build: all
 	-$(MAKE) coverage-build-js
-	if [ ! -d gcovr ]; then git clone -b 3.4 --depth=1 \
-		--single-branch https://github.com/gcovr/gcovr.git; fi
-	if [ ! -d build ]; then git clone --depth=1 \
-		--single-branch https://github.com/nodejs/build.git; fi
-	if [ ! -f gcovr/scripts/gcovr.orig ]; then \
-		(cd gcovr && patch -N -p1 < \
-		"$(CURDIR)/build/jenkins/scripts/coverage/gcovr-patches-3.4.diff"); fi
+	if [ ! -d gcovr ]; then $(PYTHON) -m pip install -t gcovr gcovr==4.2; fi
 	$(MAKE)
 
 .PHONY: coverage-build-js
@@ -244,35 +230,26 @@ coverage-build-js:
 
 .PHONY: coverage-test
 coverage-test: coverage-build
-	$(RM) out/$(BUILDTYPE)/obj.target/node/src/*.gcda
-	$(RM) out/$(BUILDTYPE)/obj.target/node/src/*/*.gcda
-	$(RM) out/$(BUILDTYPE)/obj.target/node_lib/src/*.gcda
-	$(RM) out/$(BUILDTYPE)/obj.target/node_lib/src/*/*.gcda
-	-NODE_V8_COVERAGE=out/$(BUILDTYPE)/.coverage \
-								TEST_CI_ARGS="$(TEST_CI_ARGS) --type=coverage" $(MAKE) $(COVTESTS)
+	$(FIND) out/$(BUILDTYPE)/obj.target -name "*.gcda" -type f -exec $(RM) {} \;
+	-NODE_V8_COVERAGE=coverage/tmp \
+		TEST_CI_ARGS="$(TEST_CI_ARGS) --type=coverage" $(MAKE) $(COVTESTS)
 	$(MAKE) coverage-report-js
-	-(cd out && "../gcovr/scripts/gcovr" \
+	-(cd out && PYTHONPATH=../gcovr $(PYTHON) -m gcovr \
 		--gcov-exclude='.*\b(deps|usr|out|cctest|embedding)\b' -v \
-		-r Release/obj.target --html --html-detail -o ../coverage/cxxcoverage.html \
+		-r ../src/ --object-directory Release/obj.target \
+		--html --html-details -o ../coverage/cxxcoverage.html \
 		--gcov-executable="$(GCOV)")
-	@echo -n "Javascript coverage %: "
+	@printf "Javascript coverage %%: "
 	@grep -B1 Lines coverage/index.html | head -n1 \
 		| sed 's/<[^>]*>//g'| sed 's/ //g'
-	@echo -n "C++ coverage %: "
+	@printf "C++ coverage %%: "
 	@grep -A3 Lines coverage/cxxcoverage.html | grep style  \
 		| sed 's/<[^>]*>//g'| sed 's/ //g'
 
-COV_REPORT_OPTIONS = --reporter=html \
-	--temp-directory=out/$(BUILDTYPE)/.coverage --omit-relative=false \
-	--resolve=./lib --exclude="benchmark/" --exclude="deps/" --exclude="test/" --exclude="tools/" \
-	--wrapper-length=0
-ifdef COV_ENFORCE_THRESHOLD
-	COV_REPORT_OPTIONS += --check-coverage --lines=$(COV_ENFORCE_THRESHOLD)
-endif
-
 .PHONY: coverage-report-js
 coverage-report-js:
-	$(NODE) ./node_modules/.bin/c8 report $(COV_REPORT_OPTIONS)
+	-$(MAKE) coverage-build-js
+	$(NODE) ./node_modules/.bin/c8 report
 
 .PHONY: cctest
 # Runs the C++ tests using the built `cctest` executable.
@@ -292,7 +269,8 @@ endif
 # Rebuilds deps/v8 as a git tree, pulls its third-party dependencies, and
 # builds it.
 v8:
-	tools/make-v8.sh $(V8_ARCH).$(BUILDTYPE_LOWER) $(V8_BUILD_OPTIONS)
+	export PATH="$(NO_BIN_OVERRIDE_PATH)" && \
+		tools/make-v8.sh $(V8_ARCH).$(BUILDTYPE_LOWER) $(V8_BUILD_OPTIONS)
 
 .PHONY: jstest
 jstest: build-addons build-js-native-api-tests build-node-api-tests ## Runs addon tests and JS tests
@@ -307,9 +285,8 @@ tooltest:
 
 .PHONY: coverage-run-js
 coverage-run-js:
-	$(RM) -r out/$(BUILDTYPE)/.coverage
-	$(MAKE) coverage-build-js
-	-NODE_V8_COVERAGE=out/$(BUILDTYPE)/.coverage CI_SKIP_TESTS=$(COV_SKIP_TESTS) \
+	$(RM) -r coverage/tmp
+	-NODE_V8_COVERAGE=coverage/tmp CI_SKIP_TESTS=$(COV_SKIP_TESTS) \
 					TEST_CI_ARGS="$(TEST_CI_ARGS) --type=coverage" $(MAKE) jstest
 	$(MAKE) coverage-report-js
 
@@ -350,7 +327,7 @@ test-valgrind: all
 test-check-deopts: all
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) --mode=$(BUILDTYPE_LOWER) --check-deopts parallel sequential
 
-DOCBUILDSTAMP_PREREQS = tools/doc/addon-verify.js doc/api/addons.md
+DOCBUILDSTAMP_PREREQS = tools/doc/addon-verify.mjs doc/api/addons.md
 
 ifeq ($(OSTYPE),aix)
 DOCBUILDSTAMP_PREREQS := $(DOCBUILDSTAMP_PREREQS) out/$(BUILDTYPE)/node.exp
@@ -364,7 +341,7 @@ test/addons/.docbuildstamp: $(DOCBUILDSTAMP_PREREQS) tools/doc/node_modules
 	else \
 		$(RM) -r test/addons/??_*/; \
 		[ -x $(NODE) ] && $(NODE) $< || node $< ; \
-		touch $@; \
+		[ $$? -eq 0 ] && touch $@; \
 	fi
 
 ADDONS_BINDING_GYPS := \
@@ -468,7 +445,7 @@ benchmark/napi/.buildstamp: $(ADDONS_PREREQS) \
 
 .PHONY: clear-stalled
 clear-stalled:
-	@echo "Clean up any leftover processes but don't error if found."
+	$(info Clean up any leftover processes but don't error if found.)
 	ps awwx | grep Release/node | grep -v grep | cat
 	@PS_OUT=`ps awwx | grep Release/node | grep -v grep | awk '{print $$1}'`; \
 	if [ "$${PS_OUT}" ]; then \
@@ -519,7 +496,7 @@ test-ci-js: | clear-stalled
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) -p tap --logfile test.tap \
 		--mode=$(BUILDTYPE_LOWER) --flaky-tests=$(FLAKY_TESTS) \
 		$(TEST_CI_ARGS) $(CI_JS_SUITES)
-	@echo "Clean up any leftover processes, error if found."
+	$(info Clean up any leftover processes, error if found.)
 	ps awwx | grep Release/node | grep -v grep | cat
 	@PS_OUT=`ps awwx | grep Release/node | grep -v grep | awk '{print $$1}'`; \
 	if [ "$${PS_OUT}" ]; then \
@@ -535,7 +512,7 @@ test-ci: | clear-stalled bench-addons-build build-addons build-js-native-api-tes
 		--mode=$(BUILDTYPE_LOWER) --flaky-tests=$(FLAKY_TESTS) \
 		$(TEST_CI_ARGS) $(CI_JS_SUITES) $(CI_NATIVE_SUITES) $(CI_DOC)
 	out/Release/embedtest 'require("./test/embedding/test-embedding.js")'
-	@echo "Clean up any leftover processes, error if found."
+	$(info Clean up any leftover processes, error if found.)
 	ps awwx | grep Release/node | grep -v grep | cat
 	@PS_OUT=`ps awwx | grep Release/node | grep -v grep | awk '{print $$1}'`; \
 	if [ "$${PS_OUT}" ]; then \
@@ -583,10 +560,6 @@ test-pummel: all
 test-internet: all
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) internet
 
-test-node-inspect: $(NODE_EXE)
-	USE_EMBEDDED_NODE_INSPECT=1 $(NODE) tools/test-npm-package \
-		--install deps/node-inspect test
-
 test-benchmark: | bench-addons-build
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) benchmark
 
@@ -599,20 +572,23 @@ test-hash-seed: all
 	$(NODE) test/pummel/test-hash-seed.js
 
 .PHONY: test-doc
-test-doc: doc-only lint ## Builds, lints, and verifies the docs.
+test-doc: doc-only lint-md ## Builds, lints, and verifies the docs.
 	@if [ "$(shell $(node_use_openssl))" != "true" ]; then \
 		echo "Skipping test-doc (no crypto)"; \
 	else \
 		$(PYTHON) tools/test.py $(PARALLEL_ARGS) doctool; \
 	fi
-	$(NODE) tools/doc/checkLinks.js .
+
+.PHONY: test-doc-ci
+test-doc-ci: doc-only
+	$(PYTHON) tools/test.py --shell $(NODE) $(TEST_CI_ARGS) $(PARALLEL_ARGS) doctool
 
 test-known-issues: all
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) known_issues
 
 # Related CI job: node-test-npm
 test-npm: $(NODE_EXE) ## Run the npm test suite on deps/npm.
-	$(NODE) tools/test-npm-package --install --logfile=test-npm.tap deps/npm test-node
+	$(NODE) tools/test-npm-package --install --logfile=test-npm.tap deps/npm test
 
 test-npm-publish: $(NODE_EXE)
 	npm_package_config_publishtest=true $(NODE) deps/npm/test/run.js
@@ -668,20 +644,22 @@ test-with-async-hooks:
 ifneq ("","$(wildcard deps/v8/tools/run-tests.py)")
 # Related CI job: node-test-commit-v8-linux
 test-v8: v8  ## Runs the V8 test suite on deps/v8.
-	deps/v8/tools/run-tests.py --gn --arch=$(V8_ARCH) \
-				--mode=$(BUILDTYPE_LOWER) $(V8_TEST_OPTIONS) \
+	export PATH="$(NO_BIN_OVERRIDE_PATH)" && \
+		deps/v8/tools/run-tests.py --gn --arch=$(V8_ARCH) $(V8_TEST_OPTIONS) \
 				mjsunit cctest debugger inspector message preparser \
 				$(TAP_V8)
-	@echo Testing hash seed
+	$(info Testing hash seed)
 	$(MAKE) test-hash-seed
 
 test-v8-intl: v8
-	deps/v8/tools/run-tests.py --gn --arch=$(V8_ARCH) \
-				--mode=$(BUILDTYPE_LOWER) intl \
+	export PATH="$(NO_BIN_OVERRIDE_PATH)" && \
+		deps/v8/tools/run-tests.py --gn --arch=$(V8_ARCH) \
+				intl \
 				$(TAP_V8_INTL)
 
 test-v8-benchmarks: v8
-	deps/v8/tools/run-tests.py --gn --arch=$(V8_ARCH) --mode=$(BUILDTYPE_LOWER) \
+	export PATH="$(NO_BIN_OVERRIDE_PATH)" && \
+		deps/v8/tools/run-tests.py --gn --arch=$(V8_ARCH) \
 				benchmarks \
 				$(TAP_V8_BENCHMARKS)
 
@@ -692,9 +670,8 @@ test-v8-all: test-v8 test-v8-intl test-v8-benchmarks test-v8-updates
 # runs all v8 tests
 else
 test-v8 test-v8-intl test-v8-benchmarks test-v8-all:
-	@echo "Testing v8 is not available through the source tarball."
-	@echo "Use the git repo instead:" \
-		"$ git clone https://github.com/nodejs/node.git"
+	$(warning Testing V8 is not available through the source tarball.)
+	$(warning Use the git repo instead: $$ git clone https://github.com/nodejs/node.git)
 endif
 
 apidoc_dirs = out/doc out/doc/api out/doc/api/assets
@@ -717,7 +694,7 @@ doc-only: tools/doc/node_modules \
 	@if [ "$(shell $(node_use_openssl))" != "true" ]; then \
 		echo "Skipping doc-only (no crypto)"; \
 	else \
-		$(MAKE) out/doc/api/all.html out/doc/api/all.json; \
+		$(MAKE) out/doc/api/all.html out/doc/api/all.json out/doc/api/stability; \
 	fi
 
 .PHONY: doc
@@ -746,29 +723,33 @@ run-npm-ci = $(PWD)/$(NPM) ci
 
 LINK_DATA = out/doc/apilinks.json
 VERSIONS_DATA = out/previous-doc-versions.json
-gen-api = tools/doc/generate.js --node-version=$(FULLVERSION) \
+gen-api = tools/doc/generate.mjs --node-version=$(FULLVERSION) \
 		--apilinks=$(LINK_DATA) $< --output-directory=out/doc/api \
 		--versions-file=$(VERSIONS_DATA)
-gen-apilink = tools/doc/apilinks.js $(LINK_DATA) $(wildcard lib/*.js)
+gen-apilink = tools/doc/apilinks.mjs $(LINK_DATA) $(wildcard lib/*.js)
 
-$(LINK_DATA): $(wildcard lib/*.js) tools/doc/apilinks.js | out/doc
+$(LINK_DATA): $(wildcard lib/*.js) tools/doc/apilinks.mjs | out/doc
 	$(call available-node, $(gen-apilink))
 
 # Regenerate previous versions data if the current version changes
-$(VERSIONS_DATA): CHANGELOG.md src/node_version.h tools/doc/versions.js
-	$(call available-node, tools/doc/versions.js $@)
+$(VERSIONS_DATA): CHANGELOG.md src/node_version.h tools/doc/versions.mjs
+	$(call available-node, tools/doc/versions.mjs $@)
 
-out/doc/api/%.json out/doc/api/%.html: doc/api/%.md tools/doc/generate.js \
-	tools/doc/markdown.js tools/doc/html.js tools/doc/json.js \
-	tools/doc/apilinks.js $(VERSIONS_DATA) | $(LINK_DATA) out/doc/api
+out/doc/api/%.json out/doc/api/%.html: doc/api/%.md tools/doc/generate.mjs \
+	tools/doc/markdown.mjs tools/doc/html.mjs tools/doc/json.mjs \
+	tools/doc/apilinks.mjs $(VERSIONS_DATA) | $(LINK_DATA) out/doc/api
 	$(call available-node, $(gen-api))
 
-out/doc/api/all.html: $(apidocs_html) tools/doc/allhtml.js \
-	tools/doc/apilinks.js | out/doc/api
-	$(call available-node, tools/doc/allhtml.js)
+out/doc/api/all.html: $(apidocs_html) tools/doc/allhtml.mjs \
+	tools/doc/apilinks.mjs | out/doc/api
+	$(call available-node, tools/doc/allhtml.mjs)
+
+out/doc/api/all.json: $(apidocs_json) tools/doc/alljson.mjs | out/doc/api
+	$(call available-node, tools/doc/alljson.mjs)
 
-out/doc/api/all.json: $(apidocs_json) tools/doc/alljson.js | out/doc/api
-	$(call available-node, tools/doc/alljson.js)
+.PHONY: out/doc/api/stability
+out/doc/api/stability: out/doc/api/all.json tools/doc/stability.mjs | out/doc/api
+	$(call available-node, tools/doc/stability.mjs)
 
 .PHONY: docopen
 docopen: out/doc/api/all.html
@@ -785,6 +766,7 @@ docclean:
 
 RAWVER=$(shell $(PYTHON) tools/getnodeversion.py)
 VERSION=v$(RAWVER)
+CHANGELOG=doc/changelogs/CHANGELOG_V$(firstword $(subst ., ,$(RAWVER))).md
 
 # For nightly builds, you must set DISTTYPE to "nightly", "next-nightly" or
 # "custom". For the nightly and next-nightly case, you need to set DATESTRING
@@ -919,24 +901,23 @@ BINARYNAME=$(TARNAME)-$(PLATFORM)-$(ARCH)
 endif
 BINARYTAR=$(BINARYNAME).tar
 # OSX doesn't have xz installed by default, http://macpkg.sourceforge.net/
-HAS_XZ ?= $(shell which xz > /dev/null 2>&1; [ $$? -eq 0 ] && echo 1 || echo 0)
+HAS_XZ ?= $(shell command -v xz > /dev/null 2>&1; [ $$? -eq 0 ] && echo 1 || echo 0)
 # Supply SKIP_XZ=1 to explicitly skip .tar.xz creation
 SKIP_XZ ?= 0
-XZ = $(shell [ $(HAS_XZ) -eq 1 -a $(SKIP_XZ) -eq 0 ] && echo 1 || echo 0)
+XZ = $(shell [ $(HAS_XZ) -eq 1 ] && [ $(SKIP_XZ) -eq 0 ] && echo 1 || echo 0)
 XZ_COMPRESSION ?= 9e
 PKG=$(TARNAME).pkg
 MACOSOUTDIR=out/macos
 
 ifeq ($(SKIP_XZ), 1)
 check-xz:
-	@echo "SKIP_XZ=1 supplied, skipping .tar.xz creation"
+	$(info SKIP_XZ=1 supplied, skipping .tar.xz creation)
 else
 ifeq ($(HAS_XZ), 1)
 check-xz:
 else
 check-xz:
-	@echo "No xz command, cannot continue"
-	@exit 1
+	$(error No xz command, cannot continue)
 endif
 endif
 
@@ -964,7 +945,7 @@ release-only: check-xz
 		echo "" >&2 ; \
 		exit 1 ; \
 	fi
-	@if [ "$(DISTTYPE)" != "release" -o "$(RELEASE)" = "1" ]; then \
+	@if [ "$(DISTTYPE)" != "release" ] || [ "$(RELEASE)" = "1" ]; then \
 		exit 0; \
 	else \
 		echo "" >&2 ; \
@@ -973,6 +954,15 @@ release-only: check-xz
 		echo "" >&2 ; \
 		exit 1 ; \
 	fi
+	@if [ "$(RELEASE)" = "0" ] || [ -f "$(CHANGELOG)" ]; then \
+		exit 0; \
+	else \
+		echo "" >&2 ; \
+		echo "#NODE_VERSION_IS_RELEASE is set to $(RELEASE) but " >&2 ; \
+		echo "$(CHANGELOG) does not exist." >&2 ; \
+		echo "" >&2 ; \
+		exit 1 ; \
+	fi
 
 $(PKG): release-only
 	$(RM) -r $(MACOSOUTDIR)
@@ -1001,7 +991,7 @@ $(PKG): release-only
 		--release-urlbase=$(RELEASE_URLBASE) \
 		$(CONFIG_FLAGS) $(BUILD_RELEASE_FLAGS)
 	$(MAKE) install V=$(V) DESTDIR=$(MACOSOUTDIR)/dist/node
-	SIGN="$(CODESIGN_CERT)" PKGDIR="$(MACOSOUTDIR)/dist/node/usr/local" bash \
+	SIGN="$(CODESIGN_CERT)" PKGDIR="$(MACOSOUTDIR)/dist/node/usr/local" sh \
 		tools/osx-codesign.sh
 	mkdir -p $(MACOSOUTDIR)/dist/npm/usr/local/lib/node_modules
 	mkdir -p $(MACOSOUTDIR)/pkgs
@@ -1023,8 +1013,8 @@ $(PKG): release-only
 	productbuild --distribution $(MACOSOUTDIR)/installer/productbuild/distribution.xml \
 		--resources $(MACOSOUTDIR)/installer/productbuild/Resources \
 		--package-path $(MACOSOUTDIR)/pkgs ./$(PKG)
-	SIGN="$(PRODUCTSIGN_CERT)" PKG="$(PKG)" bash tools/osx-productsign.sh
-	bash tools/osx-notarize.sh $(FULLVERSION)
+	SIGN="$(PRODUCTSIGN_CERT)" PKG="$(PKG)" sh tools/osx-productsign.sh
+	sh tools/osx-notarize.sh $(FULLVERSION)
 
 .PHONY: pkg
 # Builds the macOS installer for releases.
@@ -1037,7 +1027,7 @@ pkg-upload: pkg
 	scp -p $(TARNAME).pkg $(STAGINGSERVER):nodejs/$(DISTTYPEDIR)/$(FULLVERSION)/$(TARNAME).pkg
 	ssh $(STAGINGSERVER) "touch nodejs/$(DISTTYPEDIR)/$(FULLVERSION)/$(TARNAME).pkg.done"
 
-$(TARBALL): release-only $(NODE_EXE) doc
+$(TARBALL): release-only doc-only
 	git checkout-index -a -f --prefix=$(TARNAME)/
 	mkdir -p $(TARNAME)/doc/api
 	cp doc/node.1 $(TARNAME)/doc/node.1
@@ -1066,7 +1056,7 @@ $(TARBALL): release-only $(NODE_EXE) doc
 	find $(TARNAME)/deps/v8/test -type f ! -regex '.*/test/torque/.*' | xargs $(RM)
 	find $(TARNAME)/deps/zlib/contrib/* -type d ! -regex '.*/contrib/optimizations$$' | xargs $(RM) -r
 	find $(TARNAME)/ -name ".eslint*" -maxdepth 2 | xargs $(RM)
-	find $(TARNAME)/ -type l | xargs $(RM) # annoying on windows
+	find $(TARNAME)/ -type l | xargs $(RM)
 	tar -cf $(TARNAME).tar $(TARNAME)
 	$(RM) -r $(TARNAME)
 	gzip -c -f -9 $(TARNAME).tar > $(TARNAME).tar.gz
@@ -1140,9 +1130,13 @@ $(BINARYTAR): release-only
 	$(MAKE) install DESTDIR=$(BINARYNAME) V=$(V) PORTABLE=1
 	cp README.md $(BINARYNAME)
 	cp LICENSE $(BINARYNAME)
+ifeq ("$(wildcard $(CHANGELOG))","")
 	cp CHANGELOG.md $(BINARYNAME)
+else
+	cp $(CHANGELOG) $(BINARYNAME)/CHANGELOG.md
+endif
 ifeq ($(OSTYPE),darwin)
-	SIGN="$(CODESIGN_CERT)" PKGDIR="$(BINARYNAME)" bash tools/osx-codesign.sh
+	SIGN="$(CODESIGN_CERT)" PKGDIR="$(BINARYNAME)" sh tools/osx-codesign.sh
 endif
 	tar -cf $(BINARYNAME).tar $(BINARYNAME)
 	$(RM) -r $(BINARYNAME)
@@ -1169,12 +1163,9 @@ ifeq ($(XZ), 1)
 endif
 
 .PHONY: bench-all
-bench-all: bench-addons-build
-	@echo "Please use benchmark/run.js or benchmark/compare.js to run the benchmarks."
-
 .PHONY: bench
-bench: bench-addons-build
-	@echo "Please use benchmark/run.js or benchmark/compare.js to run the benchmarks."
+bench bench-all: bench-addons-build
+	$(warning Please use benchmark/run.js or benchmark/compare.js to run the benchmarks.)
 
 # Build required addons for benchmark before running it.
 .PHONY: bench-addons-build
@@ -1198,7 +1189,7 @@ lint-md-clean:
 
 .PHONY: lint-md-build
 lint-md-build:
-	$(warning "Deprecated no-op target 'lint-md-build'")
+	$(warning Deprecated no-op target 'lint-md-build')
 
 ifeq ("$(wildcard tools/.mdlintstamp)","")
 LINT_MD_NEWER =
@@ -1210,22 +1201,22 @@ LINT_MD_TARGETS = doc src lib benchmark test tools/doc tools/icu $(wildcard *.md
 LINT_MD_FILES = $(shell $(FIND) $(LINT_MD_TARGETS) -type f \
 	! -path '*node_modules*' ! -path 'test/fixtures/*' -name '*.md' \
 	$(LINT_MD_NEWER))
-run-lint-md = tools/lint-md.js -q -f --no-stdout $(LINT_MD_FILES)
+run-lint-md = tools/lint-md.mjs -q -f --no-stdout $(LINT_MD_FILES)
 # Lint all changed markdown files maintained by us
 tools/.mdlintstamp: $(LINT_MD_FILES)
-	@echo "Running Markdown linter..."
+	$(info Running Markdown linter...)
 	@$(call available-node,$(run-lint-md))
 	@touch $@
 
 .PHONY: lint-md
 # Lints the markdown documents maintained by us in the codebase.
-lint-md: | tools/.mdlintstamp
+lint-md: lint-js-doc | tools/.mdlintstamp
 
 
 LINT_JS_TARGETS = .eslintrc.js benchmark doc lib test tools
 
 run-lint-js = tools/node_modules/eslint/bin/eslint.js --cache \
-	--report-unused-disable-directives --ext=.js,.mjs,.md $(LINT_JS_TARGETS)
+	--report-unused-disable-directives $(LINT_JS_TARGETS)
 run-lint-js-fix = $(run-lint-js) --fix
 
 .PHONY: lint-js-fix
@@ -1233,9 +1224,11 @@ lint-js-fix:
 	@$(call available-node,$(run-lint-js-fix))
 
 .PHONY: lint-js
+.PHONY: lint-js-doc
 # Note that on the CI `lint-js-ci` is run instead.
 # Lints the JavaScript code with eslint.
-lint-js:
+lint-js-doc: LINT_JS_TARGETS=doc
+lint-js lint-js-doc:
 	@if [ "$(shell $(node_use_openssl))" != "true" ]; then \
 		echo "Skipping $@ (no crypto)"; \
 	else \
@@ -1244,20 +1237,20 @@ lint-js:
 	fi
 
 jslint: lint-js
-	@echo "Please use lint-js instead of jslint"
+	$(warning Please use lint-js instead of jslint)
 
 run-lint-js-ci = tools/node_modules/eslint/bin/eslint.js \
-  --report-unused-disable-directives --ext=.js,.mjs,.md -f tap \
+  --report-unused-disable-directives -f tap \
 	-o test-eslint.tap $(LINT_JS_TARGETS)
 
 .PHONY: lint-js-ci
 # On the CI the output is emitted in the TAP format.
 lint-js-ci:
-	@echo "Running JS linter..."
+	$(info Running JS linter...)
 	@$(call available-node,$(run-lint-js-ci))
 
 jslint-ci: lint-js-ci
-	@echo "Please use lint-js-ci instead of jslint-ci"
+	$(warning Please use lint-js-ci instead of jslint-ci)
 
 LINT_CPP_ADDON_DOC_FILES_GLOB = test/addons/??_*/*.cc test/addons/??_*/*.h
 LINT_CPP_ADDON_DOC_FILES = $(wildcard $(LINT_CPP_ADDON_DOC_FILES_GLOB))
@@ -1269,7 +1262,7 @@ LINT_CPP_EXCLUDE += $(wildcard test/js-native-api/??_*/*.cc test/js-native-api/?
 LINT_CPP_EXCLUDE += src/tracing/trace_event.h src/tracing/trace_event_common.h
 
 LINT_CPP_FILES = $(filter-out $(LINT_CPP_EXCLUDE), $(wildcard \
-	benchmark/napi/function_call/binding.cc \
+	benchmark/napi/*/*.cc \
 	src/*.c \
 	src/*.cc \
 	src/*.h \
@@ -1314,15 +1307,15 @@ CLANG_FORMAT_START ?= HEAD
 #  $ CLANG_FORMAT_START=master make format-cpp
 format-cpp: ## Format C++ diff from $CLANG_FORMAT_START to current changes
 ifneq ("","$(wildcard tools/clang-format/node_modules/)")
-	@echo "Formatting C++ diff from $(CLANG_FORMAT_START).."
+	$(info Formatting C++ diff from $(CLANG_FORMAT_START)..)
 	@$(PYTHON) tools/clang-format/node_modules/.bin/git-clang-format \
 		--binary=tools/clang-format/node_modules/.bin/clang-format \
 		--style=file \
 		$(CLANG_FORMAT_START) -- \
 		$(LINT_CPP_FILES)
 else
-	@echo "clang-format is not installed."
-	@echo "To install (requires internet access) run: $ make format-cpp-build"
+	$(info clang-format is not installed.)
+	$(info To install (requires internet access) run: $$ make format-cpp-build)
 endif
 
 ifeq ($(V),1)
@@ -1335,7 +1328,7 @@ endif
 lint-cpp: tools/.cpplintstamp
 
 tools/.cpplintstamp: $(LINT_CPP_FILES)
-	@echo "Running C++ linter..."
+	$(info Running C++ linter...)
 	@$(PYTHON) tools/cpplint.py $(CPPLINT_QUIET) $?
 	@$(PYTHON) tools/checkimports.py $?
 	@touch $@
@@ -1344,19 +1337,19 @@ tools/.cpplintstamp: $(LINT_CPP_FILES)
 lint-addon-docs: tools/.doclintstamp
 
 tools/.doclintstamp: test/addons/.docbuildstamp
-	@echo "Running C++ linter on addon docs..."
+	$(info Running C++ linter on addon docs...)
 	@$(PYTHON) tools/cpplint.py $(CPPLINT_QUIET) --filter=$(ADDON_DOC_LINT_FLAGS) \
 		$(LINT_CPP_ADDON_DOC_FILES_GLOB)
 	@touch $@
 
 cpplint: lint-cpp
-	@echo "Please use lint-cpp instead of cpplint"
+	$(warning Please use lint-cpp instead of cpplint)
 
 .PHONY: lint-py-build
 # python -m pip install flake8
 # Try with '--system' is to overcome systems that blindly set '--user'
 lint-py-build:
-	@echo "Pip installing flake8 linter on $(shell $(PYTHON) --version)..."
+	$(info Pip installing flake8 linter on $(shell $(PYTHON) --version)...)
 	$(PYTHON) -m pip install --upgrade -t tools/pip/site-packages flake8 || \
 		$(PYTHON) -m pip install --upgrade --system -t tools/pip/site-packages flake8
 
@@ -1368,8 +1361,8 @@ lint-py:
 	PYTHONPATH=tools/pip $(PYTHON) -m flake8 --count --show-source --statistics .
 else
 lint-py:
-	@echo "Python linting with flake8 is not avalible"
-	@echo "Run 'make lint-py-build'"
+	$(warning Python linting with flake8 is not available)
+	$(warning Run 'make lint-py-build')
 endif
 
 .PHONY: lint
@@ -1382,7 +1375,7 @@ lint: ## Run JS, C++, MD and doc linters.
 	$(MAKE) lint-addon-docs || EXIT_STATUS=$$? ; \
 	$(MAKE) lint-md || EXIT_STATUS=$$? ; \
 	exit $$EXIT_STATUS
-CONFLICT_RE=^>>>>>>> [0-9A-Fa-f]+|^<<<<<<< [A-Za-z]+
+CONFLICT_RE=^>>>>>>> [[:xdigit:]]+|^<<<<<<< [[:alpha:]]+
 
 # Related CI job: node-test-linter
 lint-ci: lint-js-ci lint-cpp lint-py lint-md lint-addon-docs
@@ -1395,12 +1388,9 @@ lint-ci: lint-js-ci lint-cpp lint-py lint-md lint-addon-docs
 		exit 1 ; \
 	fi
 else
-lint:
-	@echo "Linting is not available through the source tarball."
-	@echo "Use the git repo instead:" \
-		"$ git clone https://github.com/nodejs/node.git"
-
-lint-ci: lint
+lint lint-ci:
+	$(info Linting is not available through the source tarball.)
+	$(info Use the git repo instead: $$ git clone https://github.com/nodejs/node.git)
 endif
 
 .PHONY: lint-clean
@@ -1408,7 +1398,7 @@ lint-clean:
 	$(RM) tools/.*lintstamp
 	$(RM) .eslintcache
 
-HAS_DOCKER ?= $(shell which docker > /dev/null 2>&1; [ $$? -eq 0 ] && echo 1 || echo 0)
+HAS_DOCKER ?= $(shell command -v docker > /dev/null 2>&1; [ $$? -eq 0 ] && echo 1 || echo 0)
 
 ifeq ($(HAS_DOCKER), 1)
 DOCKER_COMMAND ?= docker run -it -v $(PWD):/node
@@ -1420,6 +1410,5 @@ gen-openssl: ## Generate platform dependent openssl files (requires docker)
 	$(DOCKER_COMMAND) node-openssl-builder make -C deps/openssl/config
 else
 gen-openssl:
-	@echo "No docker command, cannot continue"
-	@exit 1
+	$(error No docker command, cannot continue)
 endif
diff --git a/OAT.xml b/OAT.xml
index 5fc56ae96d13eec912546b329ff4739fcf3e6967..f07abd715fd5188dee3b623f15d84d576c747b1a 100644
--- a/OAT.xml
+++ b/OAT.xml
@@ -149,6 +149,14 @@ Note:If the text contains special characters, please escape them according to th
             <policyitem type="compatibility" name="BSD License" path="test/fixtures/wpt/resources/.*" desc="BSD License，不影响兼容性"/>
             </policy>
         </policylist>
+		<filefilterlist>
+            <filefilter name="binaryFileTypePolicyFilter" desc="doc和test中的图片" >
+			    <filteritem type="filepath" name="doc/.*.jpg" desc="doc和test中的图片"/>
+				<filteritem type="filepath" name="doc/.*.png" desc="doc和test中的图片"/>
+				<filteritem type="filepath" name="test/.*.jpg" desc="doc和test中的图片"/>
+				<filteritem type="filepath" name="test/.*.png" desc="doc和test中的图片"/>
+            </filefilter>
+        </filefilterlist>
         <filefilterlist>
             <filefilter name="defaultPolicyFilter" desc="compatibility，license文件头校验策略的过滤条件" >
                 <filteritem type="filepath" name="deps/zlib/contrib/minizip/unzip.c" desc="zlib LICENSE，文件未使用，不参与编译,不影响兼容性"/>
@@ -188,7 +196,15 @@ Note:If the text contains special characters, please escape them according to th
                 <filteritem type="filepath" name="deps/npm/node_modules/uri-js/LICENSE" desc="此为LICENSE文件"/>
                 <filteritem type="filepath" name="deps/npm/node_modules/qs/LICENSE" desc="此为LICENSE文件"/>
                 <filteritem type="filepath" name="lib/internal/cluster/.*" desc="文件没有添加license头，跟随node整体的license"/>
+                <filteritem type="filepath" name="lib/internal/util/iterable_weak_map.js" desc="不参与编译，不影响兼容性"/>
                 <filteritem type="filepath" name="deps/npm/node_modules/validate-npm-package-license/index.js" desc="文件没有添加license头，外层LICENSE位Apache"/>
+				<filteritem type="filepath" name="deps/cares/Makefile.am" desc="不参与编译，不影响兼容性"/>
+				<filteritem type="filepath" name="deps/cares/m4/zz40-xc-ovr.m4" desc="不参与编译，不影响兼容性"/>
+				<filteritem type="filepath" name="deps/cares/m4/xc-val-flgs.m4" desc="不参与编译，不影响兼容性"/>
+				<filteritem type="filepath" name="deps/cares/m4/xc-am-iface.m4" desc="不参与编译，不影响兼容性"/>
+				<filteritem type="filepath" name="deps/cares/m4/xc-cc-check.m4" desc="不参与编译，不影响兼容性"/>
+				<filteritem type="filepath" name="deps/cares/m4/xc-lt-iface.m4" desc="不参与编译，不影响兼容性"/>
+				<filteritem type="filepath" name="deps/cares/m4/xc-translit.m4" desc="不参与编译，不影响兼容性"/>
                 <filteritem type="filepath" name="deps/cares/README.cares" desc="不参与编译，不影响兼容性"/>
                 <filteritem type="filepath" name="deps/cares/RELEASE-NOTES" desc="不参与编译，不影响兼容性"/>
                 <filteritem type="filepath" name="deps/npm/man/man1/npm-dist-tag.1" desc="不参与编译，不影响兼容性"/>
diff --git a/README.OpenSource b/README.OpenSource
index 996e2e689dc1d0d6c2dc8fbd64191c7121dd3209..a6fe01b7c25cb699092ce4a77ff76fe918bb9d24 100644
--- a/README.OpenSource
+++ b/README.OpenSource
@@ -3,7 +3,7 @@
     "Name": "node",
     "License": "ISC License,Public Domain,MIT License,Free Software Foundation - MIT License,Apache License V2.0,ICU License,zlib/libpng License,BSD 2-Clause License,BSD 3-Clause License",
     "License File": "LICENSE",
-    "Version Number": "12.22.7",
+    "Version Number": "14.18.3",
     "Owner": "sunbingxin@huawei.com",
     "Upstream URL": "http://www.nodejs.org/",
     "Description": "Node.js is an open-source, cross-platform, JavaScript runtime environment. It executes JavaScript code outside of a browser."
diff --git a/README.md b/README.md
index a5066a675f0a8e8c72091eb0a85d199089738b3a..74a31d75d60f02d157b3074de4b293c630d56798 100644
--- a/README.md
+++ b/README.md
@@ -18,29 +18,30 @@ The Node.js project uses an [open governance model](./GOVERNANCE.md). The
 
 **This project is bound by a [Code of Conduct][].**
 
-# Table of Contents
+# Table of contents
 
 * [Support](#support)
-* [Release Types](#release-types)
+* [Release types](#release-types)
   * [Download](#download)
-    * [Current and LTS Releases](#current-and-lts-releases)
-    * [Nightly Releases](#nightly-releases)
-    * [API Documentation](#api-documentation)
-  * [Verifying Binaries](#verifying-binaries)
+    * [Current and LTS releases](#current-and-lts-releases)
+    * [Nightly releases](#nightly-releases)
+    * [API documentation](#api-documentation)
+  * [Verifying binaries](#verifying-binaries)
 * [Building Node.js](#building-nodejs)
 * [Security](#security)
 * [Contributing to Node.js](#contributing-to-nodejs)
-* [Current Project Team Members](#current-project-team-members)
+* [Current project team members](#current-project-team-members)
   * [TSC (Technical Steering Committee)](#tsc-technical-steering-committee)
   * [Collaborators](#collaborators)
-  * [Release Keys](#release-keys)
+  * [Release keys](#release-keys)
+* [License](#license)
 
 ## Support
 
 Looking for help? Check out the
 [instructions for getting support](.github/SUPPORT.md).
 
-## Release Types
+## Release types
 
 * **Current**: Under active development. Code for the Current release is in the
   branch for its major version number (for example,
@@ -49,10 +50,10 @@ Looking for help? Check out the
   April and October every year. Releases appearing each October have a support
   life of 8 months. Releases appearing each April convert to LTS (see below)
   each October.
-* **LTS**: Releases that receive Long-term Support, with a focus on stability
+* **LTS**: Releases that receive Long Term Support, with a focus on stability
   and security. Every even-numbered major version will become an LTS release.
   LTS releases receive 12 months of _Active LTS_ support and a further 18 months
-  of _Maintenance_. LTS release lines have alphabetically-ordered codenames,
+  of _Maintenance_. LTS release lines have alphabetically-ordered code names,
   beginning with v4 Argon. There are no breaking changes or feature additions,
   except in some special circumstances.
 * **Nightly**: Code from the Current branch built every 24-hours when there are
@@ -68,7 +69,7 @@ For more information, see the
 Binaries, installers, and source tarballs are available at
 <https://nodejs.org/en/download/>.
 
-#### Current and LTS Releases
+#### Current and LTS releases
 <https://nodejs.org/download/release/>
 
 The [latest](https://nodejs.org/download/release/latest/) directory is an
@@ -77,20 +78,20 @@ alias for the latest release from an LTS line. For example, the
 [latest-carbon](https://nodejs.org/download/release/latest-carbon/) directory
 contains the latest Carbon (Node.js 8) release.
 
-#### Nightly Releases
+#### Nightly releases
 <https://nodejs.org/download/nightly/>
 
 Each directory name and filename contains a date (in UTC) and the commit
 SHA at the HEAD of the release.
 
-#### API Documentation
+#### API documentation
 
 Documentation for the latest Current release is at <https://nodejs.org/api/>.
 Version-specific documentation is available in each release directory in the
 _docs_ subdirectory. Version-specific documentation is also at
 <https://nodejs.org/download/docs/>.
 
-### Verifying Binaries
+### Verifying binaries
 
 Download directories contain a `SHASUMS256.txt` file with SHA checksums for the
 files.
@@ -110,7 +111,7 @@ $ grep node-vx.y.z.tar.gz SHASUMS256.txt | sha256sum -c -
 
 For Current and LTS, the GPG detached signature of `SHASUMS256.txt` is in
 `SHASUMS256.txt.sig`. You can use it with `gpg` to verify the integrity of
-`SHASUM256.txt`. You will first need to import
+`SHASUMS256.txt`. You will first need to import
 [the GPG keys of individuals authorized to create releases](#release-keys). To
 import the keys:
 
@@ -143,17 +144,21 @@ For information on reporting security vulnerabilities in Node.js, see
 
 * [Contributing to the project][]
 * [Working Groups][]
-* [Strategic Initiatives][]
+* [Strategic initiatives][]
 * [Technical values and prioritization][]
 
-## Current Project Team Members
+## Current project team members
 
 For information about the governance of the Node.js project, see
 [GOVERNANCE.md](./GOVERNANCE.md).
 
+<!-- node-core-utils depends on the format of the TSC list. If the
+     format changes, those utilities need to be tested and updated. -->
 ### TSC (Technical Steering Committee)
 
 <!--lint disable prohibited-strings-->
+* [aduh95](https://github.com/aduh95) -
+**Antoine du Hamel** &lt;duhamelantoine1995@gmail.com&gt; (he/him)
 * [apapirovski](https://github.com/apapirovski) -
 **Anatoli Papirovski** &lt;apapirovski@mac.com&gt; (he/him)
 * [BethGriggs](https://github.com/BethGriggs) -
@@ -165,13 +170,15 @@ For information about the governance of the Node.js project, see
 * [cjihrig](https://github.com/cjihrig) -
 **Colin Ihrig** &lt;cjihrig@gmail.com&gt; (he/him)
 * [codebytere](https://github.com/codebytere) -
-**Shelley Vohr** &lt;codebytere@gmail.com&gt; (she/her)
+**Shelley Vohr** &lt;shelley.vohr@gmail.com&gt; (she/her)
 * [danbev](https://github.com/danbev) -
 **Daniel Bevenius** &lt;daniel.bevenius@gmail.com&gt; (he/him)
+* [danielleadams](https://github.com/danielleadams) -
+**Danielle Adams** &lt;adamzdanielle@gmail.com&gt; (she/her)
 * [fhinkel](https://github.com/fhinkel) -
 **Franziska Hinkelmann** &lt;franziska.hinkelmann@gmail.com&gt; (she/her)
 * [gabrielschulhof](https://github.com/gabrielschulhof) -
-**Gabriel Schulhof** &lt;gabriel.schulhof@intel.com&gt;
+**Gabriel Schulhof** &lt;gabrielschulhof@gmail.com&gt;
 * [gireeshpunathil](https://github.com/gireeshpunathil) -
 **Gireesh Punathil** &lt;gpunathi@in.ibm.com&gt; (he/him)
 * [jasnell](https://github.com/jasnell) -
@@ -186,6 +193,8 @@ For information about the governance of the Node.js project, see
 **Mary Marchini** &lt;oss@mmarchini.me&gt; (she/her)
 * [MylesBorins](https://github.com/MylesBorins) -
 **Myles Borins** &lt;myles.borins@gmail.com&gt; (he/him)
+* [ronag](https://github.com/ronag) -
+**Robert Nagy** &lt;ronagy@icloud.com&gt;
 * [targos](https://github.com/targos) -
 **Michaël Zasso** &lt;targos@protonmail.com&gt; (he/him)
 * [tniessen](https://github.com/tniessen) -
@@ -193,7 +202,11 @@ For information about the governance of the Node.js project, see
 * [Trott](https://github.com/Trott) -
 **Rich Trott** &lt;rtrott@gmail.com&gt; (he/him)
 
-### TSC Emeriti
+<details>
+
+<summary>Emeriti</summary>
+
+### TSC emeriti
 
 * [addaleax](https://github.com/addaleax) -
 **Anna Henningsen** &lt;anna@addaleax.net&gt; (she/her)
@@ -208,7 +221,7 @@ For information about the governance of the Node.js project, see
 * [gibfahn](https://github.com/gibfahn) -
 **Gibson Fahnestock** &lt;gibfahn@gmail.com&gt; (he/him)
 * [indutny](https://github.com/indutny) -
-**Fedor Indutny** &lt;fedor.indutny@gmail.com&gt;
+**Fedor Indutny** &lt;fedor@indutny.com&gt;
 * [isaacs](https://github.com/isaacs) -
 **Isaac Z. Schlueter** &lt;i@izs.me&gt;
 * [joshgav](https://github.com/joshgav) -
@@ -236,6 +249,11 @@ For information about the governance of the Node.js project, see
 * [trevnorris](https://github.com/trevnorris) -
 **Trevor Norris** &lt;trev.norris@gmail.com&gt;
 
+</details>
+
+<!-- node-core-utils and find-inactive-collaborators.mjs depend on the format
+     of the collaborator list. If the format changes, those utilities need to be
+     tested and updated. -->
 ### Collaborators
 
 * [addaleax](https://github.com/addaleax) -
@@ -244,8 +262,6 @@ For information about the governance of the Node.js project, see
 **Antoine du Hamel** &lt;duhamelantoine1995@gmail.com&gt; (he/him)
 * [ak239](https://github.com/ak239) -
 **Aleksei Koziatinskii** &lt;ak239spb@gmail.com&gt;
-* [AndreasMadsen](https://github.com/AndreasMadsen) -
-**Andreas Madsen** &lt;amwebdk@gmail.com&gt; (he/him)
 * [antsmartian](https://github.com/antsmartian) -
 **Anto Aravinth** &lt;anto.aravinth.cse@gmail.com&gt; (he/him)
 * [apapirovski](https://github.com/apapirovski) -
@@ -264,8 +280,6 @@ For information about the governance of the Node.js project, see
 **Bradley Farias** &lt;bradley.meck@gmail.com&gt;
 * [bmeurer](https://github.com/bmeurer) -
 **Benedikt Meurer** &lt;benedikt.meurer@gmail.com&gt;
-* [bnoordhuis](https://github.com/bnoordhuis) -
-**Ben Noordhuis** &lt;info@bnoordhuis.nl&gt;
 * [boneskull](https://github.com/boneskull) -
 **Christopher Hiller** &lt;boneskull@boneskull.com&gt; (he/him)
 * [BridgeAR](https://github.com/BridgeAR) -
@@ -279,7 +293,7 @@ For information about the governance of the Node.js project, see
 * [cjihrig](https://github.com/cjihrig) -
 **Colin Ihrig** &lt;cjihrig@gmail.com&gt; (he/him)
 * [codebytere](https://github.com/codebytere) -
-**Shelley Vohr** &lt;codebytere@gmail.com&gt; (she/her)
+**Shelley Vohr** &lt;shelley.vohr@gmail.com&gt; (she/her)
 * [danbev](https://github.com/danbev) -
 **Daniel Bevenius** &lt;daniel.bevenius@gmail.com&gt; (he/him)
 * [danielleadams](https://github.com/danielleadams) -
@@ -292,6 +306,10 @@ For information about the governance of the Node.js project, see
 **David Carlier** &lt;devnexen@gmail.com&gt;
 * [devsnek](https://github.com/devsnek) -
 **Gus Caplan** &lt;me@gus.host&gt; (they/them)
+* [dmabupt](https://github.com/dmabupt) -
+**Xu Meng** &lt;dmabupt@gmail.com&gt; (he/him)
+* [dnlup](https://github.com/dnlup)
+**Daniele Belardi** &lt;dwon.dnl@gmail.com&gt; (he/him)
 * [edsadr](https://github.com/edsadr) -
 **Adrian Estrada** &lt;edsadr@gmail.com&gt; (he/him)
 * [eugeneo](https://github.com/eugeneo) -
@@ -305,9 +323,7 @@ For information about the governance of the Node.js project, see
 * [Flarna](https://github.com/Flarna) -
 **Gerhard Stöbich** &lt;deb2001-github@yahoo.de&gt;  (he/they)
 * [gabrielschulhof](https://github.com/gabrielschulhof) -
-**Gabriel Schulhof** &lt;gabriel.schulhof@intel.com&gt;
-* [gdams](https://github.com/gdams) -
-**George Adams** &lt;george.adams@uk.ibm.com&gt; (he/him)
+**Gabriel Schulhof** &lt;gabrielschulhof@gmail.com&gt;
 * [geek](https://github.com/geek) -
 **Wyatt Preul** &lt;wpreul@gmail.com&gt;
 * [gengjiawen](https://github.com/gengjiawen) -
@@ -326,14 +342,14 @@ For information about the governance of the Node.js project, see
 **Zeyu Yang** &lt;himself65@outlook.com&gt; (he/him)
 * [hiroppy](https://github.com/hiroppy) -
 **Yuta Hiroto** &lt;hello@hiroppy.me&gt; (he/him)
+* [iansu](https://github.com/iansu) -
+**Ian Sutherland** &lt;ian@iansutherland.ca&gt;
 * [indutny](https://github.com/indutny) -
-**Fedor Indutny** &lt;fedor.indutny@gmail.com&gt;
+**Fedor Indutny** &lt;fedor@indutny.com&gt;
 * [JacksonTian](https://github.com/JacksonTian) -
 **Jackson Tian** &lt;shyvo1987@gmail.com&gt;
 * [jasnell](https://github.com/jasnell) -
 **James M Snell** &lt;jasnell@gmail.com&gt; (he/him)
-* [jdalton](https://github.com/jdalton) -
-**John-David Dalton** &lt;john.david.dalton@gmail.com&gt;
 * [jkrems](https://github.com/jkrems) -
 **Jan Krems** &lt;jan.krems@gmail.com&gt; (he/him)
 * [joaocgreis](https://github.com/joaocgreis) -
@@ -344,42 +360,48 @@ For information about the governance of the Node.js project, see
 **Juan José Arboleda** &lt;soyjuanarbol@gmail.com&gt; (he/him)
 * [JungMinu](https://github.com/JungMinu) -
 **Minwoo Jung** &lt;nodecorelab@gmail.com&gt; (he/him)
-* [lance](https://github.com/lance) -
-**Lance Ball** &lt;lball@redhat.com&gt; (he/him)
 * [legendecas](https://github.com/legendecas) -
 **Chengzhong Wu** &lt;legendecas@gmail.com&gt; (he/him)
 * [Leko](https://github.com/Leko) -
 **Shingo Inoue** &lt;leko.noor@gmail.com&gt; (he/him)
+* [linkgoron](https://github.com/linkgoron) -
+**Nitzan Uziely** &lt;linkgoron@gmail.com&gt;
 * [lpinca](https://github.com/lpinca) -
 **Luigi Pinca** &lt;luigipinca@gmail.com&gt; (he/him)
 * [lundibundi](https://github.com/lundibundi) -
 **Denys Otrishko** &lt;shishugi@gmail.com&gt; (he/him)
+* [Lxxyx](https://github.com/Lxxyx) -
+**Zijian Liu** &lt;lxxyxzj@gmail.com&gt; (he/him)
 * [mafintosh](https://github.com/mafintosh) -
 **Mathias Buus** &lt;mathiasbuus@gmail.com&gt; (he/him)
 * [mcollina](https://github.com/mcollina) -
 **Matteo Collina** &lt;matteo.collina@gmail.com&gt; (he/him)
 * [mhdawson](https://github.com/mhdawson) -
 **Michael Dawson** &lt;midawson@redhat.com&gt; (he/him)
+* [miladfarca](https://github.com/miladfarca) -
+**Milad Fa** &lt;mfarazma@redhat.com&gt; (he/him)
 * [mildsunrise](https://github.com/mildsunrise) -
 **Alba Mendez** &lt;me@alba.sh&gt; (she/her)
 * [misterdjules](https://github.com/misterdjules) -
-**Julien Gilli** &lt;jgilli@nodejs.org&gt;
+**Julien Gilli** &lt;jgilli@netflix.com&gt;
 * [mmarchini](https://github.com/mmarchini) -
 **Mary Marchini** &lt;oss@mmarchini.me&gt; (she/her)
 * [mscdex](https://github.com/mscdex) -
 **Brian White** &lt;mscdex@mscdex.net&gt;
 * [MylesBorins](https://github.com/MylesBorins) -
 **Myles Borins** &lt;myles.borins@gmail.com&gt; (he/him)
-* [ofrobots](https://github.com/ofrobots) -
-**Ali Ijaz Sheikh** &lt;ofrobots@google.com&gt; (he/him)
 * [oyyd](https://github.com/oyyd) -
 **Ouyang Yadong** &lt;oyydoibh@gmail.com&gt; (he/him)
-* [psmarshall](https://github.com/psmarshall) -
-**Peter Marshall** &lt;petermarshall@chromium.org&gt; (he/him)
+* [panva](https://github.com/panva) -
+**Filip Skokan** &lt;panva.ip@gmail.com&gt;
+* [PoojaDurgad](https://github.com/PoojaDurgad) -
+**Pooja D P** &lt;Pooja.D.P@ibm.com&gt; (she/her)
 * [puzpuzpuz](https://github.com/puzpuzpuz) -
 **Andrey Pechkurov** &lt;apechkurov@gmail.com&gt; (he/him)
 * [Qard](https://github.com/Qard) -
 **Stephen Belanger** &lt;admin@stephenbelanger.com&gt; (he/him)
+* [RaisinTen](https://github.com/RaisinTen) -
+**Darshan Sen** &lt;raisinten@gmail.com&gt; (he/him)
 * [refack](https://github.com/refack) -
 **Refael Ackermann (רפאל פלחי)** &lt;refack@gmail.com&gt; (he/him/הוא/אתה)
 * [rexagod](https://github.com/rexagod) -
@@ -390,10 +412,6 @@ For information about the governance of the Node.js project, see
 **Ricky Zhou** &lt;0x19951125@gmail.com&gt; (he/him)
 * [ronag](https://github.com/ronag) -
 **Robert Nagy** &lt;ronagy@icloud.com&gt;
-* [ronkorving](https://github.com/ronkorving) -
-**Ron Korving** &lt;ron@ronkorving.nl&gt;
-* [rubys](https://github.com/rubys) -
-**Sam Ruby** &lt;rubys@intertwingly.net&gt;
 * [ruyadorno](https://github.com/ruyadorno) -
 **Ruy Adorno** &lt;ruyadorno@github.com&gt; (he/him)
 * [rvagg](https://github.com/rvagg) -
@@ -401,13 +419,11 @@ For information about the governance of the Node.js project, see
 * [ryzokuken](https://github.com/ryzokuken) -
 **Ujjwal Sharma** &lt;ryzokuken@disroot.org&gt; (he/him)
 * [saghul](https://github.com/saghul) -
-**Saúl Ibarra Corretgé** &lt;saghul@gmail.com&gt;
+**Saúl Ibarra Corretgé** &lt;s@saghul.net&gt;
 * [santigimeno](https://github.com/santigimeno) -
 **Santiago Gimeno** &lt;santiago.gimeno@gmail.com&gt;
 * [seishun](https://github.com/seishun) -
 **Nikolai Vavilov** &lt;vvnicholas@gmail.com&gt;
-* [shigeki](https://github.com/shigeki) -
-**Shigeki Ohtsu** &lt;ohtsu@ohtsu.org&gt; (he/him)
 * [shisama](https://github.com/shisama) -
 **Masashi Hirano** &lt;shisama07@gmail.com&gt; (he/him)
 * [silverwind](https://github.com/silverwind) -
@@ -436,6 +452,8 @@ For information about the governance of the Node.js project, see
 **Thomas Watson** &lt;w@tson.dk&gt;
 * [XadillaX](https://github.com/XadillaX) -
 **Khaidi Chu** &lt;i@2333.moe&gt; (he/him)
+* [yashLadha](https://github.com/yashLadha) -
+**Yash Ladha** &lt;yash@yashladha.in&gt; (he/him)
 * [yhwang](https://github.com/yhwang) -
 **Yihong Wang** &lt;yh.wang@ibm.com&gt;
 * [yorkie](https://github.com/yorkie) -
@@ -445,14 +463,24 @@ For information about the governance of the Node.js project, see
 * [ZYSzys](https://github.com/ZYSzys) -
 **Yongsheng Zhang** &lt;zyszys98@gmail.com&gt; (he/him)
 
-### Collaborator Emeriti
+<details>
+
+<summary>Emeriti</summary>
+
+<!-- find-inactive-collaborators.mjs depends on the format of the emeriti list.
+     If the format changes, those utilities need to be tested and updated. -->
+### Collaborator emeriti
 
 * [andrasq](https://github.com/andrasq) -
 **Andras** &lt;andras@kinvey.com&gt;
 * [AnnaMag](https://github.com/AnnaMag) -
 **Anna M. Kedzierska** &lt;anna.m.kedzierska@gmail.com&gt;
+* [AndreasMadsen](https://github.com/AndreasMadsen) -
+**Andreas Madsen** &lt;amwebdk@gmail.com&gt; (he/him)
 * [aqrln](https://github.com/aqrln) -
 **Alexey Orlenko** &lt;eaglexrlnk@gmail.com&gt; (he/him)
+* [bnoordhuis](https://github.com/bnoordhuis) -
+**Ben Noordhuis** &lt;info@bnoordhuis.nl&gt;
 * [brendanashworth](https://github.com/brendanashworth) -
 **Brendan Ashworth** &lt;brendan.ashworth@me.com&gt;
 * [calvinmetcalf](https://github.com/calvinmetcalf) -
@@ -471,6 +499,8 @@ For information about the governance of the Node.js project, see
 **Alexander Makarenko** &lt;estliberitas@gmail.com&gt;
 * [firedfox](https://github.com/firedfox) -
 **Daniel Wang** &lt;wangyang0123@gmail.com&gt;
+* [gdams](https://github.com/gdams) -
+**George Adams** &lt;george.adams@microsoft.com&gt; (he/him)
 * [gibfahn](https://github.com/gibfahn) -
 **Gibson Fahnestock** &lt;gibfahn@gmail.com&gt; (he/him)
 * [glentiki](https://github.com/glentiki) -
@@ -489,6 +519,8 @@ For information about the governance of the Node.js project, see
 **Jason Ginchereau** &lt;jasongin@microsoft.com&gt;
 * [jbergstroem](https://github.com/jbergstroem) -
 **Johan Bergström** &lt;bugs@bergstroem.nu&gt;
+* [jdalton](https://github.com/jdalton) -
+**John-David Dalton** &lt;john.david.dalton@gmail.com&gt;
 * [jhamhader](https://github.com/jhamhader) -
 **Yuval Brik** &lt;yuval@brik.org.il&gt;
 * [joshgav](https://github.com/joshgav) -
@@ -499,6 +531,8 @@ For information about the governance of the Node.js project, see
 **Kyle Farnung** &lt;kfarnung@microsoft.com&gt; (he/him)
 * [kunalspathak](https://github.com/kunalspathak) -
 **Kunal Pathak** &lt;kunal.pathak@microsoft.com&gt;
+* [lance](https://github.com/lance) -
+**Lance Ball** &lt;lball@redhat.com&gt; (he/him)
 * [lucamaraschi](https://github.com/lucamaraschi) -
 **Luca Maraschi** &lt;luca.maraschi@gmail.com&gt; (he/him)
 * [lxe](https://github.com/lxe) -
@@ -517,6 +551,8 @@ For information about the governance of the Node.js project, see
 **Chen Gang** &lt;gangc.cxy@foxmail.com&gt;
 * [not-an-aardvark](https://github.com/not-an-aardvark) -
 **Teddy Katz** &lt;teddy.katz@gmail.com&gt; (he/him)
+* [ofrobots](https://github.com/ofrobots) -
+**Ali Ijaz Sheikh** &lt;ofrobots@google.com&gt; (he/him)
 * [Olegas](https://github.com/Olegas) -
 **Oleg Elifantiev** &lt;oleg@elifantiev.ru&gt;
 * [orangemocha](https://github.com/orangemocha) -
@@ -533,6 +569,8 @@ For information about the governance of the Node.js project, see
 **Minqi Pan** &lt;pmq2001@gmail.com&gt;
 * [princejwesley](https://github.com/princejwesley) -
 **Prince John Wesley** &lt;princejohnwesley@gmail.com&gt;
+* [psmarshall](https://github.com/psmarshall) -
+**Peter Marshall** &lt;petermarshall@chromium.org&gt; (he/him)
 * [rlidwka](https://github.com/rlidwka) -
 **Alex Kocharin** &lt;alex@kocharin.ru&gt;
 * [rmg](https://github.com/rmg) -
@@ -541,12 +579,18 @@ For information about the governance of the Node.js project, see
 **Robert Kowalski** &lt;rok@kowalski.gd&gt;
 * [romankl](https://github.com/romankl) -
 **Roman Klauke** &lt;romaaan.git@gmail.com&gt;
+* [ronkorving](https://github.com/ronkorving) -
+**Ron Korving** &lt;ron@ronkorving.nl&gt;
 * [RReverser](https://github.com/RReverser) -
 **Ingvar Stepanyan** &lt;me@rreverser.com&gt;
+* [rubys](https://github.com/rubys) -
+**Sam Ruby** &lt;rubys@intertwingly.net&gt;
 * [sam-github](https://github.com/sam-github) -
 **Sam Roberts** &lt;vieuxtech@gmail.com&gt;
 * [sebdeckers](https://github.com/sebdeckers) -
 **Sebastiaan Deckers** &lt;sebdeckers83@gmail.com&gt;
+* [shigeki](https://github.com/shigeki) -
+**Shigeki Ohtsu** &lt;ohtsu@ohtsu.org&gt; (he/him)
 * [stefanmb](https://github.com/stefanmb) -
 **Stefan Budeanu** &lt;stefan@budeanu.com&gt;
 * [tellnes](https://github.com/tellnes) -
@@ -565,6 +609,8 @@ For information about the governance of the Node.js project, see
 **Vse Mozhet Byt** &lt;vsemozhetbyt@gmail.com&gt; (he/him)
 * [whitlockjc](https://github.com/whitlockjc) -
 **Jeremy Whitlock** &lt;jwhitlock@apache.org&gt;
+
+</details>
 <!--lint enable prohibited-strings-->
 
 Collaborators follow the [Collaborator Guide](./doc/guides/collaborator-guide.md) in
@@ -572,10 +618,18 @@ maintaining the Node.js project.
 
 ### Triagers
 
+* [Ayase-252](https://github.com/Ayase-252) -
+**Qingyu Deng** &lt;i@ayase-lab.com&gt;
+* [himadriganguly](https://github.com/himadriganguly) -
+**Himadri Ganguly** &lt;himadri.tech@gmail.com&gt; (he/him)
+* [marsonya](https://github.com/marsonya) -
+**Akhil Marsonya** &lt;akhil.marsonya27@gmail.com&gt; (he/him)
 * [PoojaDurgad](https://github.com/PoojaDurgad) -
 **Pooja Durgad** &lt;Pooja.D.P@ibm.com&gt;
+* [RaisinTen](https://github.com/RaisinTen) -
+**Darshan Sen** &lt;raisinten@gmail.com&gt;
 
-### Release Keys
+### Release keys
 
 Primary GPG keys for Node.js Releasers (some Releasers sign with subkeys):
 
@@ -583,6 +637,8 @@ Primary GPG keys for Node.js Releasers (some Releasers sign with subkeys):
 `4ED778F539E3634C779C87C6D7062848A1AB005C`
 * **Colin Ihrig** &lt;cjihrig@gmail.com&gt;
 `94AE36675C464D64BAFA68DD7434390BDBE9B9C5`
+* **Danielle Adams** &lt;adamzdanielle@gmail.com&gt;
+`74F12602B6F1C4E913FAA37AD3A89613643B6201`
 * **James M Snell** &lt;jasnell@keybase.io&gt;
 `71DCFD284A79C3B38668286BC97EC7A07EDE3FC1`
 * **Michaël Zasso** &lt;targos@protonmail.com&gt;
@@ -600,11 +656,13 @@ Primary GPG keys for Node.js Releasers (some Releasers sign with subkeys):
 * **Shelley Vohr** &lt;shelley.vohr@gmail.com&gt;
 `B9E2F5981AA6E0CD28160D9FF13993A75599653C`
 
-To import the full set of trusted release keys:
+To import the full set of trusted release keys (including subkeys possibly used
+to sign releases):
 
 ```bash
 gpg --keyserver pool.sks-keyservers.net --recv-keys 4ED778F539E3634C779C87C6D7062848A1AB005C
 gpg --keyserver pool.sks-keyservers.net --recv-keys 94AE36675C464D64BAFA68DD7434390BDBE9B9C5
+gpg --keyserver pool.sks-keyservers.net --recv-keys 74F12602B6F1C4E913FAA37AD3A89613643B6201
 gpg --keyserver pool.sks-keyservers.net --recv-keys 71DCFD284A79C3B38668286BC97EC7A07EDE3FC1
 gpg --keyserver pool.sks-keyservers.net --recv-keys 8FCCA13FEF1D0C2E91008E09770F7A9A5AE15600
 gpg --keyserver pool.sks-keyservers.net --recv-keys C4F0DFFF4E8C1A8236409D08E73BC641CC11F4C8
@@ -618,10 +676,14 @@ gpg --keyserver pool.sks-keyservers.net --recv-keys B9E2F5981AA6E0CD28160D9FF139
 See the section above on [Verifying Binaries](#verifying-binaries) for how to
 use these keys to verify a downloaded file.
 
-Other keys used to sign some previous releases:
+<details>
+
+<summary>Other keys used to sign some previous releases</summary>
 
 * **Chris Dickinson** &lt;christopher.s.dickinson@gmail.com&gt;
 `9554F04D7259F04124DE6B476D5A82AC7E37093B`
+* **Danielle Adams** &lt;adamzdanielle@gmail.com&gt;
+`1C050899334244A8AF75E53792EF661D867B9DFA`
 * **Evan Lucas** &lt;evanlucas@me.com&gt;
 `B9AE9905FFD7803F25714661B63B535A4C206CA9`
 * **Gibson Fahnestock** &lt;gibfahn@gmail.com&gt;
@@ -637,10 +699,20 @@ Other keys used to sign some previous releases:
 * **Timothy J Fontaine** &lt;tjfontaine@gmail.com&gt;
 `7937DFD2AB06298B2293C3187D33FF9D0246406D`
 
-[Code of Conduct]: https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md
+</details>
+
+## License
+
+Node.js is available under the
+[MIT license](https://opensource.org/licenses/MIT). Node.js also includes
+external libraries that are available under a variety of licenses.  See
+[LICENSE](https://github.com/nodejs/node/blob/HEAD/LICENSE) for the full
+license text.
+
+[Code of Conduct]: https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md
 [Contributing to the project]: CONTRIBUTING.md
 [Node.js Website]: https://nodejs.org/
 [OpenJS Foundation]: https://openjsf.org/
-[Strategic Initiatives]: https://github.com/nodejs/TSC/blob/master/Strategic-Initiatives.md
+[Strategic initiatives]: doc/guides/strategic-initiatives.md
 [Technical values and prioritization]: doc/guides/technical-values.md
-[Working Groups]: https://github.com/nodejs/TSC/blob/master/WORKING_GROUPS.md
+[Working Groups]: https://github.com/nodejs/TSC/blob/HEAD/WORKING_GROUPS.md
diff --git a/SECURITY.md b/SECURITY.md
index e121072ffe43812e70e6c836f1cfda9cc756fcd0..859b88e8a175a976db4d1cb326bae33b780be43e 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -26,7 +26,7 @@ maintainers and should also be coordinated through the Node.js Ecosystem
 Security Team via [HackerOne](https://hackerone.com/nodejs-ecosystem).
 
 Details regarding this process can be found in the
-[Security Working Group repository](https://github.com/nodejs/security-wg/blob/master/processes/third_party_vuln_process.md).
+[Security Working Group repository](https://github.com/nodejs/security-wg/blob/HEAD/processes/third_party_vuln_process.md).
 
 Thank you for improving the security of Node.js and its ecosystem. Your efforts
 and responsible disclosure are greatly appreciated and will be acknowledged.
diff --git a/android-configure b/android-configure
index a7cb2b9c8b4a7833a195d133d370f36fa483b8d9..43341d1abea765bbd08c80b384511874395bf09a 100644
--- a/android-configure
+++ b/android-configure
@@ -10,7 +10,7 @@
 
 if [ $# -ne 3 ]; then
   echo "$0 should have 3 parameters: ndk_path, target_arch and sdk_version"
-  exit 1
+  return 1
 fi
 
 NDK_PATH=$1
@@ -44,21 +44,21 @@ case $ARCH in
         ;;
     *)
         echo "Unsupported architecture provided: $ARCH"
-        exit 1
+        return 1
         ;;
 esac
 
 HOST_OS="linux"
 HOST_ARCH="x86_64"
-export CC_host=$(which gcc)
-export CXX_host=$(which g++)
+export CC_host=$(command -v gcc)
+export CXX_host=$(command -v g++)
 
 host_gcc_version=$($CC_host --version | grep gcc | awk '{print $NF}')
 major=$(echo $host_gcc_version | awk -F . '{print $1}')
 minor=$(echo $host_gcc_version | awk -F . '{print $2}')
-if [ -z $major ] || [ -z $minor ] || [ $major -lt 6 ] || [ $major -eq 6 -a $minor -lt 3 ]; then
+if [ -z $major ] || [ -z $minor ] || [ $major -lt 6 ] || ( [ $major -eq 6 ] && [ $minor -lt 3 ] ); then
   echo "host gcc $host_gcc_version is too old, need gcc 6.3.0"
-  exit 1
+  return 1
 fi
 
 SUFFIX="$TOOLCHAIN_NAME$ANDROID_SDK_VERSION"
diff --git a/benchmark/_benchmark_progress.js b/benchmark/_benchmark_progress.js
index 1b7ac738f6de0d9e74de96f38de6d0f1e538a963..6c925f34e682025d707ac4bd295cf45796041b81 100644
--- a/benchmark/_benchmark_progress.js
+++ b/benchmark/_benchmark_progress.js
@@ -39,7 +39,6 @@ class BenchmarkProgress {
     this.completedConfig = 0;
     // Total number of configurations for the current file
     this.scheduledConfig = 0;
-    this.interval;  // Updates the elapsed time.
   }
 
   startQueue(index) {
diff --git a/benchmark/_http-benchmarkers.js b/benchmark/_http-benchmarkers.js
index d0f192e75948b68e8b442b2230704d9ed1e22828..615579cba52416619859b0420f0436cd10acec98 100644
--- a/benchmark/_http-benchmarkers.js
+++ b/benchmark/_http-benchmarkers.js
@@ -5,7 +5,7 @@ const path = require('path');
 const fs = require('fs');
 
 const requirementsURL =
-  'https://github.com/nodejs/node/blob/master/benchmark/writing-and-running-benchmarks.md#http-benchmark-requirements';
+  'https://github.com/nodejs/node/blob/HEAD/benchmark/writing-and-running-benchmarks.md#http-benchmark-requirements';
 
 // The port used by servers and wrk
 exports.PORT = Number(process.env.PORT) || 12346;
@@ -29,7 +29,8 @@ class AutocannonBenchmarker {
     for (const field in options.headers) {
       args.push('-H', `${field}=${options.headers[field]}`);
     }
-    args.push(`http://127.0.0.1:${options.port}${options.path}`);
+    const scheme = options.scheme || 'http';
+    args.push(`${scheme}://127.0.0.1:${options.port}${options.path}`);
     const child = child_process.spawn(this.executable, args);
     return child;
   }
@@ -60,11 +61,12 @@ class WrkBenchmarker {
     const duration = typeof options.duration === 'number' ?
       Math.max(options.duration, 1) :
       options.duration;
+    const scheme = options.scheme || 'http';
     const args = [
       '-d', duration,
       '-c', options.connections,
       '-t', Math.min(options.connections, require('os').cpus().length || 8),
-      `http://127.0.0.1:${options.port}${options.path}`,
+      `${scheme}://127.0.0.1:${options.port}${options.path}`,
     ];
     for (const field in options.headers) {
       args.push('-H', `${field}: ${options.headers[field]}`);
@@ -90,8 +92,8 @@ class WrkBenchmarker {
  */
 class TestDoubleBenchmarker {
   constructor(type) {
-    // `type` is the type of benchmarker. Possible values are 'http' and
-    // 'http2'.
+    // `type` is the type of benchmarker. Possible values are 'http', 'https',
+    // and 'http2'.
     this.name = `test-double-${type}`;
     this.executable = path.resolve(__dirname, '_test-double-benchmarker.js');
     this.present = fs.existsSync(this.executable);
@@ -101,8 +103,9 @@ class TestDoubleBenchmarker {
   create(options) {
     process.env.duration = process.env.duration || options.duration || 5;
 
+    const scheme = options.scheme || 'http';
     const env = {
-      test_url: `http://127.0.0.1:${options.port}${options.path}`,
+      test_url: `${scheme}://127.0.0.1:${options.port}${options.path}`,
       ...process.env
     };
 
@@ -179,6 +182,7 @@ const http_benchmarkers = [
   new WrkBenchmarker(),
   new AutocannonBenchmarker(),
   new TestDoubleBenchmarker('http'),
+  new TestDoubleBenchmarker('https'),
   new TestDoubleBenchmarker('http2'),
   new H2LoadBenchmarker(),
 ];
@@ -218,7 +222,7 @@ exports.run = function(options, callback) {
     return;
   }
 
-  const benchmarker_start = process.hrtime();
+  const benchmarker_start = process.hrtime.bigint();
 
   const child = benchmarker.create(options);
 
@@ -229,7 +233,7 @@ exports.run = function(options, callback) {
   child.stdout.on('data', (chunk) => stdout += chunk);
 
   child.once('close', (code) => {
-    const elapsed = process.hrtime(benchmarker_start);
+    const benchmark_end = process.hrtime.bigint();
     if (code) {
       let error_message = `${options.benchmarker} failed with ${code}.`;
       if (stdout !== '') {
@@ -246,6 +250,7 @@ exports.run = function(options, callback) {
       return;
     }
 
+    const elapsed = benchmark_end - benchmarker_start;
     callback(null, code, options.benchmarker, result, elapsed);
   });
 
diff --git a/benchmark/_test-double-benchmarker.js b/benchmark/_test-double-benchmarker.js
index 60264dfd46a60696d1d4e18f9c65c3debbac7d79..2d05f9fd92be2bfd9dd5f953e7357ecb8cdc3aa7 100644
--- a/benchmark/_test-double-benchmarker.js
+++ b/benchmark/_test-double-benchmarker.js
@@ -1,10 +1,15 @@
 'use strict';
 
 const myModule = process.argv[2];
-if (!['http', 'http2'].includes(myModule)) {
+if (!['http', 'https', 'http2'].includes(myModule)) {
   throw new Error(`Invalid module for benchmark test double: ${myModule}`);
 }
 
+let options;
+if (myModule === 'https') {
+  options = { rejectUnauthorized: false };
+}
+
 const http = require(myModule);
 
 const duration = +process.env.duration;
@@ -33,11 +38,15 @@ function request(res, client) {
 }
 
 function run() {
-  if (http.get) { // HTTP
-    http.get(url, request);
+  if (http.get) { // HTTP or HTTPS
+    if (options) {
+      http.get(url, options, request);
+    } else {
+      http.get(url, request);
+    }
   } else { // HTTP/2
     const client = http.connect(url);
-    client.on('error', (e) => { throw e; });
+    client.on('error', () => {});
     request(client.request(), client);
   }
 }
diff --git a/benchmark/async_hooks/async-local-storage-run.js b/benchmark/async_hooks/async-local-storage-run.js
new file mode 100644
index 0000000000000000000000000000000000000000..d65abb7047b2e4a8add11872d179501a22604057
--- /dev/null
+++ b/benchmark/async_hooks/async-local-storage-run.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common.js');
+const { AsyncLocalStorage } = require('async_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7]
+});
+
+async function run(store, n) {
+  for (let i = 0; i < n; i++) {
+    await new Promise((resolve) => store.run(i, resolve));
+  }
+}
+
+function main({ n }) {
+  const store = new AsyncLocalStorage();
+  bench.start();
+  run(store, n).then(() => {
+    bench.end(n);
+  });
+}
diff --git a/benchmark/async_hooks/promises.js b/benchmark/async_hooks/promises.js
index e74e3d37af11fc1762477caf25231bf53922f51f..d60ae70192c8cb101cfad92895839f30586e70c3 100644
--- a/benchmark/async_hooks/promises.js
+++ b/benchmark/async_hooks/promises.js
@@ -2,10 +2,37 @@
 const common = require('../common.js');
 const { createHook } = require('async_hooks');
 
+let hook;
+const tests = {
+  disabled() {
+    hook = createHook({
+      promiseResolve() {}
+    });
+  },
+  enabled() {
+    hook = createHook({
+      promiseResolve() {}
+    }).enable();
+  },
+  enabledWithDestroy() {
+    hook = createHook({
+      promiseResolve() {},
+      destroy() {}
+    }).enable();
+  },
+  enabledWithInitOnly() {
+    hook = createHook({
+      init() {}
+    }).enable();
+  }
+};
+
 const bench = common.createBenchmark(main, {
   n: [1e6],
   asyncHooks: [
     'enabled',
+    'enabledWithDestroy',
+    'enabledWithInitOnly',
     'disabled',
   ]
 });
@@ -20,10 +47,8 @@ async function run(n) {
 }
 
 function main({ n, asyncHooks }) {
-  const hook = createHook({ promiseResolve() {} });
-  if (asyncHooks !== 'disabled') {
-    hook.enable();
-  }
+  if (hook) hook.disable();
+  tests[asyncHooks]();
   bench.start();
   run(n).then(() => {
     bench.end(n);
diff --git a/benchmark/child_process/child-process-params.js b/benchmark/child_process/child-process-params.js
index df930395b2a0159721434508ee5a227e6247a86d..8db8d3ace20c538506de3e873c4dccd36e37aeca 100644
--- a/benchmark/child_process/child-process-params.js
+++ b/benchmark/child_process/child-process-params.js
@@ -82,6 +82,7 @@ function main({ n, methodName, params }) {
       }
       break;
     case 'execFileSync':
+    case 'spawnSync':
       switch (params) {
         case 1:
           bench.start();
@@ -119,24 +120,5 @@ function main({ n, methodName, params }) {
           break;
       }
       break;
-    case 'spawnSync':
-      switch (params) {
-        case 1:
-          bench.start();
-          for (let i = 0; i < n; i++) method(command);
-          bench.end(n);
-          break;
-        case 2:
-          bench.start();
-          for (let i = 0; i < n; i++) method(command, args);
-          bench.end(n);
-          break;
-        case 3:
-          bench.start();
-          for (let i = 0; i < n; i++) method(command, args, options);
-          bench.end(n);
-          break;
-      }
-      break;
   }
 }
diff --git a/benchmark/child_process/child-process-read-ipc.js b/benchmark/child_process/child-process-read-ipc.js
index 827f75b1e54bd1512b63b9de95de75f0a384bf48..280505026cd02ecb6b869041357280cbcbf370b6 100644
--- a/benchmark/child_process/child-process-read-ipc.js
+++ b/benchmark/child_process/child-process-read-ipc.js
@@ -13,7 +13,7 @@ if (process.argv[2] === 'child') {
   const bench = common.createBenchmark(main, {
     len: [
       64, 256, 1024, 4096, 16384, 65536,
-      65536 << 4, 65536 << 8,
+      65536 << 4, 65536 << 6 - 1,
     ],
     dur: [5]
   });
diff --git a/benchmark/common.js b/benchmark/common.js
index 701a8d6c34f07f74acde23af0957ea18ca3927d5..28a317b9a1d7a4bd23c4ccb627b87f657015ca0d 100644
--- a/benchmark/common.js
+++ b/benchmark/common.js
@@ -4,24 +4,24 @@ const child_process = require('child_process');
 const http_benchmarkers = require('./_http-benchmarkers.js');
 
 class Benchmark {
-  // Used to make sure a benchmark only start a timer once
-  #started = false;
+  constructor(fn, configs, options = {}) {
+    // Used to make sure a benchmark only start a timer once
+    this._started = false;
 
-  // Indicate that the benchmark ended
-  #ended = false;
+    // Indicate that the benchmark ended
+    this._ended = false;
 
-  // Holds process.hrtime value
-  #time = [0, 0];
+    // Holds process.hrtime value
+    this._time = 0n;
 
-  // Use the file name as the name of the benchmark
-  name = require.main.filename.slice(__dirname.length + 1);
+    // Use the file name as the name of the benchmark
+    this.name = require.main.filename.slice(__dirname.length + 1);
 
-  // Execution arguments i.e. flags used to run the jobs
-  flags = process.env.NODE_BENCHMARK_FLAGS ?
-    process.env.NODE_BENCHMARK_FLAGS.split(/\s+/) :
-    [];
+    // Execution arguments i.e. flags used to run the jobs
+    this.flags = process.env.NODE_BENCHMARK_FLAGS ?
+      process.env.NODE_BENCHMARK_FLAGS.split(/\s+/) :
+      [];
 
-  constructor(fn, configs, options = {}) {
     // Parse job-specific configuration from the command line arguments
     const argv = process.argv.slice(2);
     const parsed_args = this._parseArgs(argv, configs, options);
@@ -214,21 +214,21 @@ class Benchmark {
   }
 
   start() {
-    if (this.#started) {
+    if (this._started) {
       throw new Error('Called start more than once in a single benchmark');
     }
-    this.#started = true;
-    this.#time = process.hrtime();
+    this._started = true;
+    this._time = process.hrtime.bigint();
   }
 
   end(operations) {
     // Get elapsed time now and do error checking later for accuracy.
-    const elapsed = process.hrtime(this.#time);
+    const time = process.hrtime.bigint();
 
-    if (!this.#started) {
+    if (!this._started) {
       throw new Error('called end without start');
     }
-    if (this.#ended) {
+    if (this._ended) {
       throw new Error('called end multiple times');
     }
     if (typeof operations !== 'number') {
@@ -237,16 +237,19 @@ class Benchmark {
     if (!process.env.NODEJS_BENCHMARK_ZERO_ALLOWED && operations <= 0) {
       throw new Error('called end() with operation count <= 0');
     }
-    if (elapsed[0] === 0 && elapsed[1] === 0) {
+
+    this._ended = true;
+
+    if (time === this._time) {
       if (!process.env.NODEJS_BENCHMARK_ZERO_ALLOWED)
         throw new Error('insufficient clock precision for short benchmark');
       // Avoid dividing by zero
-      elapsed[1] = 1;
+      this.report(operations && Number.MAX_VALUE, 0n);
+      return;
     }
 
-    this.#ended = true;
-    const time = elapsed[0] + elapsed[1] / 1e9;
-    const rate = operations / time;
+    const elapsed = time - this._time;
+    const rate = operations / (Number(elapsed) / 1e9);
     this.report(rate, elapsed);
   }
 
@@ -255,12 +258,21 @@ class Benchmark {
       name: this.name,
       conf: this.config,
       rate,
-      time: elapsed[0] + elapsed[1] / 1e9,
+      time: nanoSecondsToString(elapsed),
       type: 'report',
     });
   }
 }
 
+function nanoSecondsToString(bigint) {
+  const str = bigint.toString();
+  const decimalPointIndex = str.length - 9;
+  if (decimalPointIndex <= 0) {
+    return `0.${'0'.repeat(-decimalPointIndex)}${str}`;
+  }
+  return `${str.slice(0, decimalPointIndex)}.${str.slice(decimalPointIndex)}`;
+}
+
 function formatResult(data) {
   // Construct configuration string, " A=a, B=b, ..."
   let conf = '';
@@ -271,7 +283,7 @@ function formatResult(data) {
   let rate = data.rate.toString().split('.');
   rate[0] = rate[0].replace(/(\d)(?=(?:\d\d\d)+(?!\d))/g, '$1,');
   rate = (rate[1] ? rate.join('.') : rate[0]);
-  return `${data.name}${conf}: ${rate}`;
+  return `${data.name}${conf}: ${rate}\n`;
 }
 
 function sendResult(data) {
@@ -280,7 +292,7 @@ function sendResult(data) {
     process.send(data);
   } else {
     // Otherwise report by stdout
-    console.log(formatResult(data));
+    process.stdout.write(formatResult(data));
   }
 }
 
diff --git a/benchmark/compare.R b/benchmark/compare.R
index 7a0c89af3de4c5e46c1fbf1d923c8a335ce3e93a..21e35b7e8f1b9fb0753e4230c9085afda15e378c 100644
--- a/benchmark/compare.R
+++ b/benchmark/compare.R
@@ -23,7 +23,7 @@ dat = read.csv(
 dat = data.frame(dat);
 
 dat$nameTwoLines = paste0(dat$filename, '\n', dat$configuration);
-dat$name = paste0(dat$filename, dat$configuration);
+dat$name = paste0(dat$filename, ' ', dat$configuration);
 
 # Create a box plot
 if (!is.null(plot.filename)) {
@@ -35,14 +35,14 @@ if (!is.null(plot.filename)) {
   ggsave(plot.filename, p);
 }
 
-# computes the shared standard error, as used in the welch t-test
+# Computes the shared standard error, as used in Welch's t-test.
 welch.sd = function (old.rate, new.rate) {
   old.se.squared = var(old.rate) / length(old.rate)
   new.se.squared = var(new.rate) / length(new.rate)
   return(sqrt(old.se.squared + new.se.squared))
 }
 
-# calculate the improvement confidence interval. The improvement is calculated
+# Calculate the improvement confidence interval. The improvement is calculated
 # by dividing by old.mu and not new.mu, because old.mu is what the mean
 # improvement is calculated relative to.
 confidence.interval = function (shared.se, old.mu, w, risk) {
@@ -50,7 +50,7 @@ confidence.interval = function (shared.se, old.mu, w, risk) {
   return(sprintf("±%.2f%%", (interval / old.mu) * 100))
 }
 
-# Print a table with results
+# Calculate the statistics table.
 statistics = ddply(dat, "name", function(subdat) {
   old.rate = subset(subdat, binary == "old")$rate;
   new.rate = subset(subdat, binary == "new")$rate;
@@ -68,14 +68,14 @@ statistics = ddply(dat, "name", function(subdat) {
     "(***)" = "NA"
   );
 
-  # Check if there is enough data to calculate the calculate the p-value
+  # Check if there is enough data to calculate the p-value.
   if (length(old.rate) > 1 && length(new.rate) > 1) {
-    # Perform a statistics test to see of there actually is a difference in
+    # Perform a statistical test to see if there actually is a difference in
     # performance.
     w = t.test(rate ~ binary, data=subdat);
     shared.se = welch.sd(old.rate, new.rate)
 
-    # Add user friendly stars to the table. There should be at least one star
+    # Add user-friendly stars to the table. There should be at least one star
     # before you can say that there is an improvement.
     confidence = '';
     if (w$p.value < 0.001) {
@@ -99,7 +99,7 @@ statistics = ddply(dat, "name", function(subdat) {
 });
 
 
-# Set the benchmark names as the row.names to left align them in the print
+# Set the benchmark names as the row.names to left align them in the print.
 row.names(statistics) = statistics$name;
 statistics$name = NULL;
 
@@ -108,7 +108,7 @@ print(statistics);
 cat("\n")
 cat(sprintf(
 "Be aware that when doing many comparisons the risk of a false-positive
-result increases. In this case there are %d comparisons, you can thus
+result increases. In this case, there are %d comparisons, you can thus
 expect the following amount of false-positive results:
   %.2f false positives, when considering a   5%% risk acceptance (*, **, ***),
   %.2f false positives, when considering a   1%% risk acceptance (**, ***),
diff --git a/benchmark/compare.js b/benchmark/compare.js
index 5c9cd03be3fdee5e8437c6ebd8fcd7176acd9e04..169948e006d660651a40a4c4b4a3e1fc4c7fd270 100644
--- a/benchmark/compare.js
+++ b/benchmark/compare.js
@@ -56,7 +56,7 @@ for (const filename of benchmarks) {
 // queue.length = binary.length * runs * benchmarks.length
 
 // Print csv header
-console.log('"binary", "filename", "configuration", "rate", "time"');
+console.log('"binary","filename","configuration","rate","time"');
 
 const kStartOfQueue = 0;
 
@@ -85,8 +85,8 @@ if (showProgress) {
       // Escape quotes (") for correct csv formatting
       conf = conf.replace(/"/g, '""');
 
-      console.log(`"${job.binary}", "${job.filename}", "${conf}", ` +
-                  `${data.rate}, ${data.time}`);
+      console.log(`"${job.binary}","${job.filename}","${conf}",` +
+                  `${data.rate},${data.time}`);
       if (showProgress) {
         // One item in the subqueue has been completed.
         progress.completeConfig(data);
diff --git a/benchmark/crypto/randomUUID.js b/benchmark/crypto/randomUUID.js
new file mode 100644
index 0000000000000000000000000000000000000000..cca05242874738e577893725d5393c06dfca4d04
--- /dev/null
+++ b/benchmark/crypto/randomUUID.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common.js');
+const { randomUUID } = require('crypto');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7],
+  disableEntropyCache: [0, 1],
+});
+
+function main({ n, disableEntropyCache }) {
+  disableEntropyCache = !!disableEntropyCache;
+  bench.start();
+  for (let i = 0; i < n; ++i)
+    randomUUID({ disableEntropyCache });
+  bench.end(n);
+}
diff --git a/benchmark/diagnostics_channel/http.js b/benchmark/diagnostics_channel/http.js
new file mode 100644
index 0000000000000000000000000000000000000000..55fac8a706df15a12f6b3d8568b2be1f87fdba63
--- /dev/null
+++ b/benchmark/diagnostics_channel/http.js
@@ -0,0 +1,96 @@
+'use strict';
+const common = require('../common.js');
+const dc = require('diagnostics_channel');
+const { AsyncLocalStorage } = require('async_hooks');
+const http = require('http');
+
+const bench = common.createBenchmark(main, {
+  apm: ['none', 'diagnostics_channel', 'patch'],
+  type: 'buffer',
+  len: 1024,
+  chunks: 4,
+  connections: [50, 500],
+  chunkedEnc: 1,
+  duration: 5
+});
+
+function main({ apm, connections, duration, type, len, chunks, chunkedEnc }) {
+  const done = { none, patch, diagnostics_channel }[apm]();
+
+  const server = require('../fixtures/simple-http-server.js')
+    .listen(common.PORT)
+    .on('listening', () => {
+      const path = `/${type}/${len}/${chunks}/normal/${chunkedEnc}`;
+      bench.http({
+        path,
+        connections,
+        duration
+      }, () => {
+        server.close();
+        if (done) done();
+      });
+    });
+}
+
+function none() {}
+
+function patch() {
+  const als = new AsyncLocalStorage();
+  const times = [];
+
+  const { emit } = http.Server.prototype;
+  function wrappedEmit(...args) {
+    const [name, req, res] = args;
+    if (name === 'request') {
+      als.enterWith({
+        url: req.url,
+        start: process.hrtime.bigint()
+      });
+
+      res.on('finish', () => {
+        times.push({
+          ...als.getStore(),
+          statusCode: res.statusCode,
+          end: process.hrtime.bigint()
+        });
+      });
+    }
+    return emit.apply(this, args);
+  }
+  http.Server.prototype.emit = wrappedEmit;
+
+  return () => {
+    http.Server.prototype.emit = emit;
+  };
+}
+
+function diagnostics_channel() {
+  const als = new AsyncLocalStorage();
+  const times = [];
+
+  const start = dc.channel('http.server.request.start');
+  const finish = dc.channel('http.server.response.finish');
+
+  function onStart(req) {
+    als.enterWith({
+      url: req.url,
+      start: process.hrtime.bigint()
+    });
+  }
+
+  function onFinish(res) {
+    times.push({
+      ...als.getStore(),
+      statusCode: res.statusCode,
+      end: process.hrtime.bigint()
+    });
+  }
+
+  start.subscribe(onStart);
+  finish.subscribe(onFinish);
+
+  return () => {
+    start.unsubscribe(onStart);
+    finish.unsubscribe(onFinish);
+  };
+}
diff --git a/benchmark/diagnostics_channel/publish.js b/benchmark/diagnostics_channel/publish.js
new file mode 100644
index 0000000000000000000000000000000000000000..31a770c862791955337ca3d0e1866f1afd6b90b5
--- /dev/null
+++ b/benchmark/diagnostics_channel/publish.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common.js');
+const dc = require('diagnostics_channel');
+
+const bench = common.createBenchmark(main, {
+  n: [1e8],
+  subscribers: [0, 1, 10],
+});
+
+function noop() {}
+
+function main({ n, subscribers }) {
+  const channel = dc.channel('test');
+  for (let i = 0; i < subscribers; i++) {
+    channel.subscribe(noop);
+  }
+
+  const data = {
+    foo: 'bar'
+  };
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    if (channel.hasSubscribers) {
+      channel.publish(data);
+    }
+  }
+  bench.end(n);
+}
diff --git a/benchmark/diagnostics_channel/subscribe.js b/benchmark/diagnostics_channel/subscribe.js
new file mode 100644
index 0000000000000000000000000000000000000000..1415054588c4b1141f1571eed7dd00bc67ecafec
--- /dev/null
+++ b/benchmark/diagnostics_channel/subscribe.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common.js');
+const dc = require('diagnostics_channel');
+
+const bench = common.createBenchmark(main, {
+  n: [1e8],
+});
+
+function noop() {}
+
+function main({ n }) {
+  const channel = dc.channel('channel.0');
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    channel.subscribe(noop);
+  }
+  bench.end(n);
+}
diff --git a/benchmark/es/destructuring-bench.js b/benchmark/es/destructuring-bench.js
index c07c0383da91acb205cb627f9e74df3a0b5147d4..d412b82757f0836b8da1f5a47e7ce2b75cb364ec 100644
--- a/benchmark/es/destructuring-bench.js
+++ b/benchmark/es/destructuring-bench.js
@@ -12,7 +12,8 @@ function runSwapManual(n) {
   let x, y, r;
   bench.start();
   for (let i = 0; i < n; i++) {
-    x = 1, y = 2;
+    x = 1;
+    y = 2;
     r = x;
     x = y;
     y = r;
@@ -26,7 +27,8 @@ function runSwapDestructured(n) {
   let x, y;
   bench.start();
   for (let i = 0; i < n; i++) {
-    x = 1, y = 2;
+    x = 1;
+    y = 2;
     [x, y] = [y, x];
     assert.strictEqual(x, 2);
     assert.strictEqual(y, 1);
diff --git a/benchmark/events/eventtarget.js b/benchmark/events/eventtarget.js
new file mode 100644
index 0000000000000000000000000000000000000000..d2c3ad034ff9b4471962149e0cd1ef905256c09c
--- /dev/null
+++ b/benchmark/events/eventtarget.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  listeners: [1, 5, 10]
+}, { flags: ['--expose-internals'] });
+
+function main({ n, listeners }) {
+  const { EventTarget, Event } = require('internal/event_target');
+  const target = new EventTarget();
+
+  for (let n = 0; n < listeners; n++)
+    target.addEventListener('foo', () => {});
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    target.dispatchEvent(new Event('foo'));
+  }
+  bench.end(n);
+
+}
diff --git a/benchmark/fixtures/coverage-many-branches.js b/benchmark/fixtures/coverage-many-branches.js
new file mode 100644
index 0000000000000000000000000000000000000000..9cb6360336e019a7d1a09cb82161c4f66b3aab60
--- /dev/null
+++ b/benchmark/fixtures/coverage-many-branches.js
@@ -0,0 +1,115 @@
+'use strict';
+
+// Exercise coverage of a class. Note, this logic is silly and exists solely
+// to generate branch coverage code paths:
+class CoveredClass {
+  constructor(x, y, opts) {
+    this.x = x;
+    this.y = y;
+    // Exercise coverage of nullish coalescing:
+    this.opts = opts ?? (Math.random() > 0.5 ? {} : undefined);
+  }
+  add() {
+    return this.x + this.y;
+  }
+  addSpecial() {
+    // Exercise coverage of optional chains:
+    if (this.opts?.special && this.opts?.special?.x && this.opts?.special?.y) {
+      return this.opts.special.x + this.opts.special.y;
+    }
+    return add();
+  }
+  mult() {
+    return this.x * this.y;
+  }
+  multSpecial() {
+    if (this.opts?.special && this.opts?.special?.x && this.opts?.special?.y) {
+      return this.opts.special.x * this.opts.special.y;
+    }
+    return mult();
+  }
+}
+
+// Excercise coverage of functions:
+function add(x, y) {
+  const mt = new CoveredClass(x, y);
+  return mt.add();
+}
+
+function addSpecial(x, y) {
+  let mt;
+  if (Math.random() > 0.5) {
+    mt = new CoveredClass(x, y);
+  } else {
+    mt = new CoveredClass(x, y, {
+      special: {
+        x: Math.random() * x,
+        y: Math.random() * y
+      }
+    });
+  }
+  return mt.addSpecial();
+}
+
+function mult(x, y) {
+  const mt = new CoveredClass(x, y);
+  return mt.mult();
+}
+
+function multSpecial(x, y) {
+  let mt;
+  if (Math.random() > 0.5) {
+    mt = new CoveredClass(x, y);
+  } else {
+    mt = new CoveredClass(x, y, {
+      special: {
+        x: Math.random() * x,
+        y: Math.random() * y
+      }
+    });
+  }
+  return mt.multSpecial();
+}
+
+for (let i = 0; i < parseInt(process.env.N); i++) {
+  const operations = ['add', 'addSpecial', 'mult', 'multSpecial'];
+  for (const operation of operations) {
+    // Exercise coverage of switch statements:
+    switch (operation) {
+      case 'add':
+        if (add(Math.random() * 10, Math.random() * 10) > 10) {
+          // Exercise coverage of ternary operations:
+          let r = addSpecial(Math.random() * 10, Math.random() * 10) > 10 ?
+            mult(Math.random() * 10, Math.random() * 10) :
+            add(Math.random() * 10, Math.random() * 10);
+          // Exercise && and ||
+          if (r && Math.random() > 0.5 || Math.random() < 0.5) r++;
+        }
+        break;
+      case 'addSpecial':
+        if (addSpecial(Math.random() * 10, Math.random() * 10) > 10 &&
+            add(Math.random() * 10, Math.random() * 10) > 10) {
+          let r = mult(Math.random() * 10, Math.random() * 10) > 10 ?
+            add(Math.random() * 10, Math.random() * 10) > 10 :
+            mult(Math.random() * 10, Math.random() * 10);
+          if (r && Math.random() > 0.5 || Math.random() < 0.5) r++;
+        }
+        break;
+      case 'mult':
+        if (mult(Math.random() * 10, Math.random() * 10) > 10) {
+          let r = multSpecial(Math.random() * 10, Math.random() * 10) > 10 ?
+            add(Math.random() * 10, Math.random() * 10) :
+            mult(Math.random() * 10, Math.random() * 10);
+          if (r && Math.random() > 0.5 || Math.random() < 0.5) r++;
+        }
+        break;
+      case 'multSpecial':
+        while (multSpecial(Math.random() * 10, Math.random() * 10) < 10) {
+          mult(Math.random() * 10, Math.random() * 10);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}
diff --git a/benchmark/fixtures/require-builtins.js b/benchmark/fixtures/require-builtins.js
new file mode 100644
index 0000000000000000000000000000000000000000..685eef1875b301a96e40e9be8cb9bb57efada158
--- /dev/null
+++ b/benchmark/fixtures/require-builtins.js
@@ -0,0 +1,44 @@
+'use strict';
+
+const list = [
+  'async_hooks',
+  'assert',
+  'buffer',
+  'child_process',
+  'console',
+  'constants',
+  'crypto',
+  'cluster',
+  'dgram',
+  'dns',
+  'domain',
+  'events',
+  'fs',
+  'http',
+  'http2',
+  'https',
+  'module',
+  'net',
+  'os',
+  'path',
+  'perf_hooks',
+  'process',
+  'punycode',
+  'querystring',
+  'readline',
+  'repl',
+  'stream',
+  'string_decoder',
+  'timers',
+  'tls',
+  'tty',
+  'url',
+  'util',
+  'vm',
+  'zlib',
+];
+
+for (let i = 0; i < list.length; ++i) {
+  const item = list[i];
+  require(item);
+}
diff --git a/benchmark/fixtures/simple-https-server.js b/benchmark/fixtures/simple-https-server.js
new file mode 100644
index 0000000000000000000000000000000000000000..d3b07a110113d715961897642c2631119c2fd9a6
--- /dev/null
+++ b/benchmark/fixtures/simple-https-server.js
@@ -0,0 +1,72 @@
+'use strict';
+
+const fixtures = require('../../test/common/fixtures');
+const https = require('https');
+
+const options = {
+  key: fixtures.readKey('rsa_private.pem'),
+  cert: fixtures.readKey('rsa_cert.crt')
+};
+
+const storedBytes = Object.create(null);
+const storedBuffer = Object.create(null);
+
+module.exports = https.createServer(options, (req, res) => {
+  // URL format: /<type>/<length>/<chunks>/chunkedEnc
+  const params = req.url.split('/');
+  const command = params[1];
+  let body = '';
+  const arg = params[2];
+  const n_chunks = parseInt(params[3], 10);
+  const chunkedEnc = params.length >= 5 && params[4] === '0' ? false : true;
+  let status = 200;
+
+  let n, i;
+  if (command === 'bytes') {
+    n = ~~arg;
+    if (n <= 0)
+      throw new Error('bytes called with n <= 0');
+    if (storedBytes[n] === undefined) {
+      storedBytes[n] = 'C'.repeat(n);
+    }
+    body = storedBytes[n];
+  } else if (command === 'buffer') {
+    n = ~~arg;
+    if (n <= 0)
+      throw new Error('buffer called with n <= 0');
+    if (storedBuffer[n] === undefined) {
+      storedBuffer[n] = Buffer.allocUnsafe(n);
+      for (i = 0; i < n; i++) {
+        storedBuffer[n][i] = 'C'.charCodeAt(0);
+      }
+    }
+    body = storedBuffer[n];
+  } else {
+    status = 404;
+    body = 'not found\n';
+  }
+
+  // example: https://localhost:port/bytes/512/4
+  // sends a 512 byte body in 4 chunks of 128 bytes
+  const len = body.length;
+  if (chunkedEnc) {
+    res.writeHead(status, {
+      'Content-Type': 'text/plain',
+      'Transfer-Encoding': 'chunked'
+    });
+  } else {
+    res.writeHead(status, {
+      'Content-Type': 'text/plain',
+      'Content-Length': len.toString()
+    });
+  }
+  // send body in chunks
+  if (n_chunks > 1) {
+    const step = Math.floor(len / n_chunks) || 1;
+    for (i = 0, n = (n_chunks - 1); i < n; ++i)
+      res.write(body.slice(i * step, i * step + step));
+    res.end(body.slice((n_chunks - 1) * step));
+  } else {
+    res.end(body);
+  }
+});
diff --git a/benchmark/fs/bench-statSync-failure.js b/benchmark/fs/bench-statSync-failure.js
new file mode 100644
index 0000000000000000000000000000000000000000..82cb24c09f4af224a414fba9e638e99636c96139
--- /dev/null
+++ b/benchmark/fs/bench-statSync-failure.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const path = require('path');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  statSyncType: ['throw', 'noThrow']
+});
+
+
+function main({ n, statSyncType }) {
+  const arg = path.join(__dirname, 'non.existent');
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    if (statSyncType === 'noThrow') {
+      fs.statSync(arg, { throwIfNoEntry: false });
+    } else {
+      try {
+        fs.statSync(arg);
+      } catch {
+      }
+    }
+  }
+  bench.end(n);
+}
diff --git a/benchmark/fs/bench-statSync.js b/benchmark/fs/bench-statSync.js
index 0c9366a402cb71763e3fa96843de056084b7ed7f..e75d6603fcfc644ad4f9db861a084e8b2476b4ae 100644
--- a/benchmark/fs/bench-statSync.js
+++ b/benchmark/fs/bench-statSync.js
@@ -21,6 +21,6 @@ function main({ n, statSyncType }) {
   }
   bench.end(n);
 
-  if (statSyncType === 'fstat')
+  if (statSyncType === 'fstatSync')
     fs.closeSync(arg);
 }
diff --git a/benchmark/fs/read-stream-throughput.js b/benchmark/fs/read-stream-throughput.js
index c6b4ecb166ac65af20fe272f8854c2d5d86d1d57..5984317ff91743496d0693c2f89d71bb72da3178 100644
--- a/benchmark/fs/read-stream-throughput.js
+++ b/benchmark/fs/read-stream-throughput.js
@@ -3,11 +3,14 @@
 
 const path = require('path');
 const common = require('../common.js');
-const filename = path.resolve(process.env.NODE_TMPDIR || __dirname,
-                              `.removeme-benchmark-garbage-${process.pid}`);
 const fs = require('fs');
 const assert = require('assert');
 
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+const filename = path.resolve(tmpdir.path,
+                              `.removeme-benchmark-garbage-${process.pid}`);
+
 const bench = common.createBenchmark(main, {
   encodingType: ['buf', 'asc', 'utf'],
   filesize: [1000 * 1024],
diff --git a/benchmark/fs/readfile-promises.js b/benchmark/fs/readfile-promises.js
new file mode 100644
index 0000000000000000000000000000000000000000..28633c3f06427be3aaa0478da00d4fb69ab55343
--- /dev/null
+++ b/benchmark/fs/readfile-promises.js
@@ -0,0 +1,63 @@
+// Call fs.promises.readFile over and over again really fast.
+// Then see how many times it got called.
+// Yes, this is a silly benchmark.  Most benchmarks are silly.
+'use strict';
+
+const path = require('path');
+const common = require('../common.js');
+const fs = require('fs');
+const assert = require('assert');
+
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+const filename = path.resolve(tmpdir.path,
+                              `.removeme-benchmark-garbage-${process.pid}`);
+
+const bench = common.createBenchmark(main, {
+  duration: [5],
+  len: [1024, 16 * 1024 * 1024],
+  concurrent: [1, 10]
+});
+
+function main({ len, duration, concurrent }) {
+  try { fs.unlinkSync(filename); } catch { }
+  let data = Buffer.alloc(len, 'x');
+  fs.writeFileSync(filename, data);
+  data = null;
+
+  let writes = 0;
+  let benchEnded = false;
+  bench.start();
+  setTimeout(() => {
+    benchEnded = true;
+    bench.end(writes);
+    try { fs.unlinkSync(filename); } catch { }
+    process.exit(0);
+  }, duration * 1000);
+
+  function read() {
+    fs.promises.readFile(filename)
+      .then((res) => afterRead(undefined, res))
+      .catch((err) => afterRead(err));
+  }
+
+  function afterRead(er, data) {
+    if (er) {
+      if (er.code === 'ENOENT') {
+        // Only OK if unlinked by the timer from main.
+        assert.ok(benchEnded);
+        return;
+      }
+      throw er;
+    }
+
+    if (data.length !== len)
+      throw new Error('wrong number of bytes returned');
+
+    writes++;
+    if (!benchEnded)
+      read();
+  }
+
+  while (concurrent--) read();
+}
diff --git a/benchmark/fs/readfile.js b/benchmark/fs/readfile.js
index 25d87622bcba029ae0a3502a70333ce62075af83..3f996e02ede876574cd48db923cdcd80e9639d83 100644
--- a/benchmark/fs/readfile.js
+++ b/benchmark/fs/readfile.js
@@ -5,11 +5,14 @@
 
 const path = require('path');
 const common = require('../common.js');
-const filename = path.resolve(process.env.NODE_TMPDIR || __dirname,
-                              `.removeme-benchmark-garbage-${process.pid}`);
 const fs = require('fs');
 const assert = require('assert');
 
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+const filename = path.resolve(tmpdir.path,
+                              `.removeme-benchmark-garbage-${process.pid}`);
+
 const bench = common.createBenchmark(main, {
   duration: [5],
   len: [1024, 16 * 1024 * 1024],
diff --git a/benchmark/fs/write-stream-throughput.js b/benchmark/fs/write-stream-throughput.js
index f715dfb96d8679cdf101d0b355377afe9d4c5213..44a3bb23b041d1a61f18a2373d1e19ccd552c3f6 100644
--- a/benchmark/fs/write-stream-throughput.js
+++ b/benchmark/fs/write-stream-throughput.js
@@ -3,10 +3,13 @@
 
 const path = require('path');
 const common = require('../common.js');
-const filename = path.resolve(process.env.NODE_TMPDIR || __dirname,
-                              `.removeme-benchmark-garbage-${process.pid}`);
 const fs = require('fs');
 
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+const filename = path.resolve(tmpdir.path,
+                              `.removeme-benchmark-garbage-${process.pid}`);
+
 const bench = common.createBenchmark(main, {
   dur: [5],
   encodingType: ['buf', 'asc', 'utf'],
diff --git a/benchmark/fs/writefile-promises.js b/benchmark/fs/writefile-promises.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ba25184ff3132abac3ffd9ebd69725729f2349c
--- /dev/null
+++ b/benchmark/fs/writefile-promises.js
@@ -0,0 +1,76 @@
+// Call fs.promises.writeFile over and over again really fast.
+// Then see how many times it got called.
+// Yes, this is a silly benchmark.  Most benchmarks are silly.
+'use strict';
+
+const path = require('path');
+const common = require('../common.js');
+const fs = require('fs');
+const assert = require('assert');
+const tmpdir = require('../../test/common/tmpdir');
+
+tmpdir.refresh();
+const filename = path.resolve(tmpdir.path,
+                              `.removeme-benchmark-garbage-${process.pid}`);
+let filesWritten = 0;
+const bench = common.createBenchmark(main, {
+  duration: [5],
+  encodingType: ['buf', 'asc', 'utf'],
+  size: [2, 1024, 65535, 1024 * 1024],
+  concurrent: [1, 10]
+});
+
+function main({ encodingType, duration, concurrent, size }) {
+  let encoding;
+  let chunk;
+  switch (encodingType) {
+    case 'buf':
+      chunk = Buffer.alloc(size, 'b');
+      break;
+    case 'asc':
+      chunk = 'a'.repeat(size);
+      encoding = 'ascii';
+      break;
+    case 'utf':
+      chunk = 'ü'.repeat(Math.ceil(size / 2));
+      encoding = 'utf8';
+      break;
+    default:
+      throw new Error(`invalid encodingType: ${encodingType}`);
+  }
+
+  let writes = 0;
+  let benchEnded = false;
+  bench.start();
+  setTimeout(() => {
+    benchEnded = true;
+    bench.end(writes);
+    for (let i = 0; i < filesWritten; i++) {
+      try { fs.unlinkSync(`${filename}-${i}`); } catch { }
+    }
+    process.exit(0);
+  }, duration * 1000);
+
+  function write() {
+    fs.promises.writeFile(`${filename}-${filesWritten++}`, chunk, encoding)
+      .then(() => afterWrite())
+      .catch((err) => afterWrite(err));
+  }
+
+  function afterWrite(er) {
+    if (er) {
+      if (er.code === 'ENOENT') {
+        // Only OK if unlinked by the timer from main.
+        assert.ok(benchEnded);
+        return;
+      }
+      throw er;
+    }
+
+    writes++;
+    if (!benchEnded)
+      write();
+  }
+
+  while (concurrent--) write();
+}
diff --git a/benchmark/http/headers.js b/benchmark/http/headers.js
index b83ac17e742a2ef2fbce501c3750740839b7d5b2..a3d2b7810be67625869b237ab8dca0ec83709056 100644
--- a/benchmark/http/headers.js
+++ b/benchmark/http/headers.js
@@ -4,7 +4,7 @@ const common = require('../common.js');
 const http = require('http');
 
 const bench = common.createBenchmark(main, {
-  n: [10, 1000],
+  n: [10, 600],
   len: [1, 100],
   duration: 5
 });
diff --git a/benchmark/http2/compat.js b/benchmark/http2/compat.js
index 2c7e732b07f0a5ad84d3d801e0b3bb0139716153..9ca7ab1ba08ef78ba912fde2c3f5421f1bd8768a 100644
--- a/benchmark/http2/compat.js
+++ b/benchmark/http2/compat.js
@@ -24,9 +24,10 @@ function main({ requests, streams, clients, duration }) {
       res.destroy();
     });
   });
-  server.listen(common.PORT, () => {
+  server.listen(0, () => {
     bench.http({
       path: '/',
+      port: server.address().port,
       requests,
       maxConcurrentStreams: streams,
       clients,
diff --git a/benchmark/http2/headers.js b/benchmark/http2/headers.js
index 56799da1987e5343c7f8406db9b50ba24a159df7..886f64be1c8b7ba35e2d9af092e58b497d2874e4 100644
--- a/benchmark/http2/headers.js
+++ b/benchmark/http2/headers.js
@@ -1,7 +1,6 @@
 'use strict';
 
 const common = require('../common.js');
-const PORT = common.PORT;
 
 const bench = common.createBenchmark(main, {
   n: [1e3],
@@ -32,8 +31,8 @@ function main({ n, nheaders }) {
     stream.respond();
     stream.end('Hi!');
   });
-  server.listen(PORT, () => {
-    const client = http2.connect(`http://localhost:${PORT}/`, {
+  server.listen(0, () => {
+    const client = http2.connect(`http://localhost:${server.address().port}/`, {
       maxHeaderListPairs: 20000
     });
 
diff --git a/benchmark/http2/respond-with-fd.js b/benchmark/http2/respond-with-fd.js
index 5bf5988d16a64c43d2d74be1da3b83cca320e11c..547b6900b61f48251ec5a460d44c4d896bc4b8db 100644
--- a/benchmark/http2/respond-with-fd.js
+++ b/benchmark/http2/respond-with-fd.js
@@ -25,10 +25,11 @@ function main({ requests, streams, clients, duration }) {
       stream.respondWithFD(fd);
       stream.on('error', (err) => {});
     });
-    server.listen(common.PORT, () => {
+    server.listen(0, () => {
       bench.http({
         path: '/',
         requests,
+        port: server.address().port,
         maxConcurrentStreams: streams,
         clients,
         duration,
diff --git a/benchmark/http2/simple.js b/benchmark/http2/simple.js
index 929c4c655e12955ad3eb391cb837aefb10124386..d9ac513d3c3e68b266d1195a25a06c47e53a66e3 100644
--- a/benchmark/http2/simple.js
+++ b/benchmark/http2/simple.js
@@ -22,9 +22,10 @@ function main({ requests, streams, clients, duration }) {
     out.pipe(stream);
     stream.on('error', (err) => {});
   });
-  server.listen(common.PORT, () => {
+  server.listen(0, () => {
     bench.http({
       path: '/',
+      port: server.address().port,
       requests,
       maxConcurrentStreams: streams,
       clients,
diff --git a/benchmark/http2/write.js b/benchmark/http2/write.js
index 7ea8b2c02da65022515cae1dc2cac20cc5bb595c..caf93e2f2b62d55c9bbbcc0896e9b584fa424242 100644
--- a/benchmark/http2/write.js
+++ b/benchmark/http2/write.js
@@ -26,9 +26,10 @@ function main({ streams, length, size, duration }) {
     }
     write();
   });
-  server.listen(common.PORT, () => {
+  server.listen(0, () => {
     bench.http({
       path: '/',
+      port: server.address().port,
       requests: 10000,
       duration,
       maxConcurrentStreams: streams,
diff --git a/benchmark/https/simple.js b/benchmark/https/simple.js
new file mode 100644
index 0000000000000000000000000000000000000000..243546c346f484ebd48971c383d725abfdc13d62
--- /dev/null
+++ b/benchmark/https/simple.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  type: ['bytes', 'buffer'],
+  len: [4, 1024, 102400],
+  chunks: [1, 4],
+  c: [50, 500],
+  chunkedEnc: [1, 0],
+  benchmarker: ['test-double-https'],
+  duration: 5
+});
+
+function main({ type, len, chunks, c, chunkedEnc, duration }) {
+  const server = require('../fixtures/simple-https-server.js')
+  .listen(common.PORT)
+  .on('listening', () => {
+    const path = `/${type}/${len}/${chunks}/${chunkedEnc}`;
+
+    bench.http({
+      path,
+      connections: c,
+      scheme: 'https',
+      duration
+    }, () => {
+      server.close();
+    });
+  });
+}
diff --git a/benchmark/misc/hidestackframes.js b/benchmark/misc/hidestackframes.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b14f2d95b22e2caf76b5a5f9fdc2c872d80b257
--- /dev/null
+++ b/benchmark/misc/hidestackframes.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  type: ['hide-stackframes-throw', 'direct-call-throw',
+         'hide-stackframes-noerr', 'direct-call-noerr'],
+  n: [10e4]
+}, {
+  flags: ['--expose-internals']
+});
+
+function main({ n, type }) {
+  const {
+    hideStackFrames,
+    codes: {
+      ERR_INVALID_ARG_TYPE,
+    },
+  } = require('internal/errors');
+
+  const testfn = (value) => {
+    if (typeof value !== 'number') {
+      throw new ERR_INVALID_ARG_TYPE('Benchmark', 'number', value);
+    }
+  };
+
+  let fn = testfn;
+  if (type.startsWith('hide-stackframe'))
+    fn = hideStackFrames(testfn);
+  let value = 42;
+  if (type.endsWith('-throw'))
+    value = 'err';
+
+  bench.start();
+
+  for (let i = 0; i < n; i++) {
+    try {
+      fn(value);
+    } catch {
+      // No-op
+    }
+  }
+
+  bench.end(n);
+}
diff --git a/benchmark/misc/startup.js b/benchmark/misc/startup.js
index da24ee65199077999d1cd3dd97a348f987822323..dea5a31753f8fe927d785e9dd9e24da59e31b3ca 100644
--- a/benchmark/misc/startup.js
+++ b/benchmark/misc/startup.js
@@ -7,7 +7,11 @@ let Worker;  // Lazy loaded in main
 
 const bench = common.createBenchmark(main, {
   dur: [1],
-  script: ['benchmark/fixtures/require-cachable', 'test/fixtures/semicolon'],
+  script: [
+    'benchmark/fixtures/require-builtins',
+    'benchmark/fixtures/require-cachable',
+    'test/fixtures/semicolon',
+  ],
   mode: ['process', 'worker']
 }, {
   flags: ['--expose-internals']
diff --git a/benchmark/module/module-loader-circular.js b/benchmark/module/module-loader-circular.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d392e0e1908db1900ad095ada5ff7d3c773f69a
--- /dev/null
+++ b/benchmark/module/module-loader-circular.js
@@ -0,0 +1,34 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const common = require('../common.js');
+
+const tmpdir = require('../../test/common/tmpdir');
+const benchmarkDirectory =
+  path.resolve(tmpdir.path, 'benchmark-module-circular');
+
+const bench = common.createBenchmark(main, {
+  n: [1e4]
+});
+
+function main({ n }) {
+  tmpdir.refresh();
+
+  const aDotJS = path.join(benchmarkDirectory, 'a.js');
+  const bDotJS = path.join(benchmarkDirectory, 'b.js');
+
+  fs.mkdirSync(benchmarkDirectory);
+  fs.writeFileSync(aDotJS, 'require("./b.js");');
+  fs.writeFileSync(bDotJS, 'require("./a.js");');
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    require(aDotJS);
+    require(bDotJS);
+    delete require.cache[aDotJS];
+    delete require.cache[bDotJS];
+  }
+  bench.end(n);
+
+  tmpdir.refresh();
+}
diff --git a/benchmark/napi/function_args/binding.cc b/benchmark/napi/function_args/binding.cc
index 9f250aaa83db50b745b210bced34bbb8b88c04e3..078fe0ee3ea767616e7b938fe4a2fb8d6a2b8d6e 100644
--- a/benchmark/napi/function_args/binding.cc
+++ b/benchmark/napi/function_args/binding.cc
@@ -2,18 +2,20 @@
 #include <node.h>
 #include <assert.h>
 
-using v8::Isolate;
+using v8::Array;
+using v8::ArrayBuffer;
+using v8::ArrayBufferView;
+using v8::BackingStore;
 using v8::Context;
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
-using v8::Value;
 using v8::Number;
-using v8::String;
 using v8::Object;
-using v8::Array;
-using v8::ArrayBufferView;
-using v8::ArrayBuffer;
-using v8::FunctionCallbackInfo;
+using v8::String;
+using v8::Uint32;
+using v8::Value;
 
 void CallWithString(const FunctionCallbackInfo<Value>& args) {
   assert(args.Length() == 1 && args[0]->IsString());
@@ -22,7 +24,7 @@ void CallWithString(const FunctionCallbackInfo<Value>& args) {
     const int32_t length = str->Utf8Length(args.GetIsolate()) + 1;
     char* buf = new char[length];
     str->WriteUtf8(args.GetIsolate(), buf, length);
-    delete [] buf;
+    delete[] buf;
   }
 }
 
@@ -31,7 +33,7 @@ void CallWithArray(const FunctionCallbackInfo<Value>& args) {
   if (args.Length() == 1 && args[0]->IsArray()) {
     const Local<Array> array = args[0].As<Array>();
     uint32_t length = array->Length();
-    for (uint32_t i = 0; i < length; ++ i) {
+    for (uint32_t i = 0; i < length; i++) {
       Local<Value> v;
       v = array->Get(args.GetIsolate()->GetCurrentContext(),
                      i).ToLocalChecked();
@@ -101,12 +103,10 @@ void CallWithTypedarray(const FunctionCallbackInfo<Value>& args) {
     const size_t byte_length = view->ByteLength();
     assert(byte_length > 0);
     assert(view->HasBuffer());
-    Local<ArrayBuffer> buffer;
-    buffer = view->Buffer();
-    ArrayBuffer::Contents contents;
-    contents = buffer->GetContents();
+    Local<ArrayBuffer> buffer = view->Buffer();
+    std::shared_ptr<BackingStore> bs = buffer->GetBackingStore();
     const uint32_t* data = reinterpret_cast<uint32_t*>(
-        static_cast<uint8_t*>(contents.Data()) + byte_offset);
+        static_cast<uint8_t*>(bs->Data()) + byte_offset);
     assert(data);
   }
 }
@@ -114,16 +114,18 @@ void CallWithTypedarray(const FunctionCallbackInfo<Value>& args) {
 void CallWithArguments(const FunctionCallbackInfo<Value>& args) {
   assert(args.Length() > 1 && args[0]->IsNumber());
   if (args.Length() > 1 && args[0]->IsNumber()) {
-    int32_t loop = args[0].As<v8::Uint32>()->Value();
+    int32_t loop = args[0].As<Uint32>()->Value();
     for (int32_t i = 1; i < loop; ++i) {
       assert(i < args.Length());
       assert(args[i]->IsUint32());
-      args[i].As<v8::Uint32>()->Value();
+      args[i].As<Uint32>()->Value();
     }
   }
 }
 
-void Initialize(Local<Object> target) {
+void Initialize(Local<Object> target,
+                Local<Value> module,
+                void* data) {
   NODE_SET_METHOD(target, "callWithString", CallWithString);
   NODE_SET_METHOD(target, "callWithLongString", CallWithString);
 
diff --git a/benchmark/napi/function_call/binding.cc b/benchmark/napi/function_call/binding.cc
index 289a94ac3ecc88b2070a94fcba4b61e6263c55a3..570f96f41ec458c59396be0ddb9152b92db4c97d 100644
--- a/benchmark/napi/function_call/binding.cc
+++ b/benchmark/napi/function_call/binding.cc
@@ -7,7 +7,9 @@ void Hello(const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(c++);
 }
 
-void Initialize(v8::Local<v8::Object> target) {
+void Initialize(v8::Local<v8::Object> target,
+                v8::Local<v8::Value> module,
+                void* data) {
   NODE_SET_METHOD(target, "hello", Hello);
 }
 
diff --git a/benchmark/perf_hooks/bench-eventlooputil.js b/benchmark/perf_hooks/bench-eventlooputil.js
index 984b2b66aecbcf04beaef849eb09f4d61da1f69f..1fd452afa91300212d07998bd95cf9fe446ffdc2 100644
--- a/benchmark/perf_hooks/bench-eventlooputil.js
+++ b/benchmark/perf_hooks/bench-eventlooputil.js
@@ -33,7 +33,7 @@ function main({ method, n }) {
 function benchIdleTime(n) {
   bench.start();
   for (let i = 0; i < n; i++)
-    nodeTiming.idleTime;
+    nodeTiming.idleTime; // eslint-disable-line no-unused-expressions
   bench.end(n);
 }
 
diff --git a/benchmark/process/bench-env.js b/benchmark/process/bench-env.js
index 5df521cc9583898b51a895cea2476e732a0f5fa0..e96c1d025072144b509c51b5d64fd00a4d558250 100644
--- a/benchmark/process/bench-env.js
+++ b/benchmark/process/bench-env.js
@@ -13,7 +13,7 @@ function main({ n, operation }) {
     case 'get':
       bench.start();
       for (let i = 0; i < n; i++) {
-        process.env.PATH;
+        process.env.PATH; // eslint-disable-line no-unused-expressions
       }
       bench.end(n);
       break;
@@ -42,7 +42,7 @@ function main({ n, operation }) {
     case 'query':
       bench.start();
       for (let i = 0; i < n; i++) {
-        'PATH' in process.env;
+        'PATH' in process.env; // eslint-disable-line no-unused-expressions
       }
       bench.end(n);
       break;
diff --git a/benchmark/process/coverage.js b/benchmark/process/coverage.js
new file mode 100644
index 0000000000000000000000000000000000000000..3dc0cbe52b4c0d507733ca3dae3fa37079f4ac5a
--- /dev/null
+++ b/benchmark/process/coverage.js
@@ -0,0 +1,32 @@
+// This benchmark is meant to exercise a grab bag of code paths that would
+// be expected to run slower under coverage.
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e5]
+});
+const path = require('path');
+const { rmSync } = require('fs');
+const { spawnSync } = require('child_process');
+const tmpdir = require('../../test/common/tmpdir');
+
+const coverageDir = path.join(tmpdir.path, `./cov-${Date.now()}`);
+
+function main({ n }) {
+  bench.start();
+  const result = spawnSync(process.execPath, [
+    require.resolve('../fixtures/coverage-many-branches'),
+  ], {
+    env: {
+      NODE_V8_COVERAGE: coverageDir,
+      N: n,
+      ...process.env
+    }
+  });
+  bench.end(n);
+  rmSync(coverageDir, { recursive: true, force: true });
+  if (result.status !== 0) {
+    throw new Error(result.stderr.toString('utf8'));
+  }
+}
diff --git a/benchmark/streams/writable-manywrites.js b/benchmark/streams/writable-manywrites.js
index e4ae9ab91e5f4a35c6f83fa1667c7530a9a8c8f5..025a5017ee64462da61c30f949ca74da479b892e 100644
--- a/benchmark/streams/writable-manywrites.js
+++ b/benchmark/streams/writable-manywrites.js
@@ -7,11 +7,12 @@ const bench = common.createBenchmark(main, {
   n: [2e6],
   sync: ['yes', 'no'],
   writev: ['yes', 'no'],
-  callback: ['yes', 'no']
+  callback: ['yes', 'no'],
+  len: [1024, 32 * 1024]
 });
 
-function main({ n, sync, writev, callback }) {
-  const b = Buffer.allocUnsafe(1024);
+function main({ n, sync, writev, callback, len }) {
+  const b = Buffer.allocUnsafe(len);
   const s = new Writable();
   sync = sync === 'yes';
 
diff --git a/benchmark/string_decoder/string-decoder-create.js b/benchmark/string_decoder/string-decoder-create.js
index f7fa5e0246b8601dde379e8bdc41ed753390b60f..641e562fdeab3d920df98daca1326c24f73305f3 100644
--- a/benchmark/string_decoder/string-decoder-create.js
+++ b/benchmark/string_decoder/string-decoder-create.js
@@ -12,8 +12,7 @@ const bench = common.createBenchmark(main, {
 function main({ encoding, n }) {
   bench.start();
   for (let i = 0; i < n; ++i) {
-    const sd = new StringDecoder(encoding);
-    !!sd.encoding;
+    new StringDecoder(encoding);
   }
   bench.end(n);
 }
diff --git a/benchmark/tls/throughput.js b/benchmark/tls/throughput-c2s.js
similarity index 100%
rename from benchmark/tls/throughput.js
rename to benchmark/tls/throughput-c2s.js
diff --git a/benchmark/tls/throughput-s2c.js b/benchmark/tls/throughput-s2c.js
new file mode 100644
index 0000000000000000000000000000000000000000..a505a719d3088455bf0747586a3f2da1ab8f022a
--- /dev/null
+++ b/benchmark/tls/throughput-s2c.js
@@ -0,0 +1,104 @@
+'use strict';
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  dur: [5],
+  type: ['buf', 'asc', 'utf'],
+  sendchunklen: [256, 32 * 1024, 128 * 1024, 16 * 1024 * 1024],
+  recvbuflen: [0, 64 * 1024, 1024 * 1024],
+  recvbufgenfn: ['true', 'false']
+});
+
+const fixtures = require('../../test/common/fixtures');
+let options;
+let recvbuf;
+let received = 0;
+const tls = require('tls');
+
+function main({ dur, type, sendchunklen, recvbuflen, recvbufgenfn }) {
+  if (isFinite(recvbuflen) && recvbuflen > 0)
+    recvbuf = Buffer.alloc(recvbuflen);
+
+  let encoding;
+  let chunk;
+  switch (type) {
+    case 'buf':
+      chunk = Buffer.alloc(sendchunklen, 'b');
+      break;
+    case 'asc':
+      chunk = 'a'.repeat(sendchunklen);
+      encoding = 'ascii';
+      break;
+    case 'utf':
+      chunk = 'ü'.repeat(sendchunklen / 2);
+      encoding = 'utf8';
+      break;
+    default:
+      throw new Error('invalid type');
+  }
+
+  options = {
+    key: fixtures.readKey('rsa_private.pem'),
+    cert: fixtures.readKey('rsa_cert.crt'),
+    ca: fixtures.readKey('rsa_ca.crt'),
+    ciphers: 'AES256-GCM-SHA384'
+  };
+
+  let socketOpts;
+  if (recvbuf === undefined) {
+    socketOpts = { port: common.PORT, rejectUnauthorized: false };
+  } else {
+    let buffer = recvbuf;
+    if (recvbufgenfn === 'true') {
+      let bufidx = -1;
+      const bufpool = [
+        recvbuf,
+        Buffer.from(recvbuf),
+        Buffer.from(recvbuf),
+      ];
+      buffer = () => {
+        bufidx = (bufidx + 1) % bufpool.length;
+        return bufpool[bufidx];
+      };
+    }
+    socketOpts = {
+      port: common.PORT,
+      rejectUnauthorized: false,
+      onread: {
+        buffer,
+        callback: function(nread, buf) {
+          received += nread;
+        }
+      }
+    };
+  }
+
+  const server = tls.createServer(options, (socket) => {
+    socket.on('data', (buf) => {
+      socket.on('drain', write);
+      write();
+    });
+
+    function write() {
+      while (false !== socket.write(chunk, encoding));
+    }
+  });
+
+  let conn;
+  server.listen(common.PORT, () => {
+    conn = tls.connect(socketOpts, () => {
+      setTimeout(done, dur * 1000);
+      bench.start();
+      conn.write('hello');
+    });
+
+    conn.on('data', (chunk) => {
+      received += chunk.length;
+    });
+  });
+
+  function done() {
+    const mbits = (received * 8) / (1024 * 1024);
+    bench.end(mbits);
+    process.exit(0);
+  }
+}
diff --git a/benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js b/benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js
index f6037d332d069211cc36a2d163cda7242cbf8579..fc21ea7c85d14b0c743746da6490bf07a3c2c892 100644
--- a/benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js
+++ b/benchmark/url/legacy-vs-whatwg-url-searchparams-parse.js
@@ -1,6 +1,5 @@
 'use strict';
 const common = require('../common.js');
-const { URLSearchParams } = require('url');
 const querystring = require('querystring');
 const searchParams = common.searchParams;
 
diff --git a/benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js b/benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js
index cb2301e94036daad17d6e581655a3ad027396146..b9c2861719bc0f4338b01f40007c25a7845728b0 100644
--- a/benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js
+++ b/benchmark/url/legacy-vs-whatwg-url-searchparams-serialize.js
@@ -1,6 +1,5 @@
 'use strict';
 const common = require('../common.js');
-const { URLSearchParams } = require('url');
 const querystring = require('querystring');
 const searchParams = common.searchParams;
 
diff --git a/benchmark/url/url-searchparams-iteration.js b/benchmark/url/url-searchparams-iteration.js
index b628908d62c708412cac8220509c93c9ef842693..ce530c5227fab34d473d474c9e3c27fac72c98f2 100644
--- a/benchmark/url/url-searchparams-iteration.js
+++ b/benchmark/url/url-searchparams-iteration.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common.js');
 const assert = require('assert');
-const { URLSearchParams } = require('url');
 
 const bench = common.createBenchmark(main, {
   loopMethod: ['forEach', 'iterator'],
diff --git a/benchmark/url/url-searchparams-read.js b/benchmark/url/url-searchparams-read.js
index cdaaa7ad11a8c3feec205bec156a9dd931a9a10e..e1cb39fbe71cd8cc5a6927f7b055d437f1e866cf 100644
--- a/benchmark/url/url-searchparams-read.js
+++ b/benchmark/url/url-searchparams-read.js
@@ -1,6 +1,5 @@
 'use strict';
 const common = require('../common.js');
-const { URLSearchParams } = require('url');
 
 const bench = common.createBenchmark(main, {
   accessMethod: ['get', 'getAll', 'has'],
diff --git a/benchmark/url/url-searchparams-sort.js b/benchmark/url/url-searchparams-sort.js
index 5beb98cf2d2e254fa1802ef364d6fff1aad8abdf..a1873fd612f873da506bdfd0df1f41b997119256 100644
--- a/benchmark/url/url-searchparams-sort.js
+++ b/benchmark/url/url-searchparams-sort.js
@@ -1,6 +1,5 @@
 'use strict';
 const common = require('../common.js');
-const URLSearchParams = require('url').URLSearchParams;
 
 const inputs = {
   wpt: 'wpt',  // To work around tests
diff --git a/benchmark/worker/atomics-wait.js b/benchmark/worker/atomics-wait.js
new file mode 100644
index 0000000000000000000000000000000000000000..a771b1813731edf4f0dd60f3505799e389f1d876
--- /dev/null
+++ b/benchmark/worker/atomics-wait.js
@@ -0,0 +1,15 @@
+'use strict';
+/* global SharedArrayBuffer */
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e7]
+});
+
+function main({ n }) {
+  const i32arr = new Int32Array(new SharedArrayBuffer(4));
+  bench.start();
+  for (let i = 0; i < n; i++)
+    Atomics.wait(i32arr, 0, 1);  // Will return immediately.
+  bench.end(n);
+}
diff --git a/benchmark/worker/messageport.js b/benchmark/worker/messageport.js
index 8e2ddae73ff3abe0d1a905db2e39a1fe2b9d0f86..2f0d6f0621e8c8532d3001646efb748e322c0a3d 100644
--- a/benchmark/worker/messageport.js
+++ b/benchmark/worker/messageport.js
@@ -4,6 +4,7 @@ const common = require('../common.js');
 const { MessageChannel } = require('worker_threads');
 const bench = common.createBenchmark(main, {
   payload: ['string', 'object'],
+  style: ['eventtarget', 'eventemitter'],
   n: [1e6]
 });
 
@@ -25,14 +26,26 @@ function main(conf) {
   const { port1, port2 } = new MessageChannel();
 
   let messages = 0;
-  port2.onmessage = () => {
+  function listener() {
     if (messages++ === n) {
       bench.end(n);
       port1.close();
     } else {
       write();
     }
-  };
+  }
+
+  switch (conf.style) {
+    case 'eventtarget':
+      port2.onmessage = listener;
+      break;
+    case 'eventemitter':
+      port2.on('message', listener);
+      break;
+    default:
+      throw new Error('Unsupported listener type');
+  }
+
   bench.start();
   write();
 
diff --git a/common.gypi b/common.gypi
index 102f09077455072fb5f73fa990808a0d21729463..f3a4aad62abef659e6b5aecbb01c382c75339349 100644
--- a/common.gypi
+++ b/common.gypi
@@ -26,21 +26,20 @@
     'uv_library%': 'static_library',
 
     'clang%': 0,
+    'error_on_warn%': 'false',
 
     'openssl_fips%': '',
+    'openssl_no_asm%': 0,
 
     # Don't use ICU data file (icudtl.dat) from V8, we use our own.
     'icu_use_data_file_flag%': 0,
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.45',
+    'v8_embedder_string': '-node.85',
 
     ##### V8 defaults for Node.js #####
 
-    # Old time default, now explicitly stated.
-    'v8_use_snapshot': 1,
-
     # Turn on SipHash for hash seed generation, addresses HashWick
     'v8_use_siphash': 'true',
 
@@ -61,6 +60,12 @@
     # https://github.com/nodejs/node/pull/22920/files#r222779926
     'v8_enable_handle_zapping': 0,
 
+    # Disable pointer compression. Can be enabled at build time via configure
+    # options but default values are required here as this file is also used by
+    # node-gyp to build addons.
+    'v8_enable_pointer_compression%': 0,
+    'v8_enable_31bit_smis_on_64bit_arch%': 0,
+
     # Disable V8 untrusted code mitigations.
     # See https://github.com/v8/v8/wiki/Untrusted-code-mitigations
     'v8_untrusted_code_mitigations': 0,
@@ -77,55 +82,21 @@
     ##### end V8 defaults #####
 
     'conditions': [
-      ['target_arch=="arm64"', {
-        # Disabled pending https://github.com/nodejs/node/issues/23913.
-        'openssl_no_asm%': 1,
-      }, {
-        'openssl_no_asm%': 0,
-      }],
       ['OS == "win"', {
         'os_posix': 0,
         'v8_postmortem_support%': 0,
+        'obj_dir': '<(PRODUCT_DIR)/obj',
+        'v8_base': '<(PRODUCT_DIR)/lib/libv8_snapshot.a',
       }, {
         'os_posix': 1,
         'v8_postmortem_support%': 1,
       }],
-      ['v8_use_snapshot==1', {
-        'conditions': [
-          ['GENERATOR == "ninja"', {
-            'obj_dir': '<(PRODUCT_DIR)/obj',
-            'v8_base': '<(PRODUCT_DIR)/obj/tools/v8_gypfiles/libv8_snapshot.a',
-           }, {
-            'obj_dir%': '<(PRODUCT_DIR)/obj.target',
-            'v8_base': '<(PRODUCT_DIR)/obj.target/tools/v8_gypfiles/libv8_snapshot.a',
-          }],
-          ['OS == "win"', {
-            'obj_dir': '<(PRODUCT_DIR)/obj',
-            'v8_base': '<(PRODUCT_DIR)/lib/libv8_snapshot.a',
-          }],
-          ['OS == "mac"', {
-            'obj_dir%': '<(PRODUCT_DIR)/obj.target',
-            'v8_base': '<(PRODUCT_DIR)/libv8_snapshot.a',
-          }],
-        ],
+      ['GENERATOR == "ninja"', {
+        'obj_dir': '<(PRODUCT_DIR)/obj',
+        'v8_base': '<(PRODUCT_DIR)/obj/tools/v8_gypfiles/libv8_snapshot.a',
       }, {
-        'conditions': [
-          ['GENERATOR == "ninja"', {
-            'obj_dir': '<(PRODUCT_DIR)/obj',
-            'v8_base': '<(PRODUCT_DIR)/obj/tools/v8_gypfiles/libv8_nosnapshot.a',
-           }, {
-            'obj_dir%': '<(PRODUCT_DIR)/obj.target',
-            'v8_base': '<(PRODUCT_DIR)/obj.target/tools/v8_gypfiles/libv8_nosnapshot.a',
-          }],
-          ['OS == "win"', {
-            'obj_dir': '<(PRODUCT_DIR)/obj',
-            'v8_base': '<(PRODUCT_DIR)/lib/libv8_nosnapshot.a',
-          }],
-          ['OS == "mac"', {
-            'obj_dir%': '<(PRODUCT_DIR)/obj.target',
-            'v8_base': '<(PRODUCT_DIR)/libv8_nosnapshot.a',
-          }],
-        ],
+        'obj_dir%': '<(PRODUCT_DIR)/obj.target',
+        'v8_base': '<(PRODUCT_DIR)/obj.target/tools/v8_gypfiles/libv8_snapshot.a',
       }],
       ['openssl_fips != ""', {
         'openssl_product': '<(STATIC_LIB_PREFIX)crypto<(STATIC_LIB_SUFFIX)',
@@ -134,10 +105,15 @@
       }],
       ['OS=="mac"', {
         'clang%': 1,
+        'obj_dir%': '<(PRODUCT_DIR)/obj.target',
+        'v8_base': '<(PRODUCT_DIR)/libv8_snapshot.a',
       }],
       ['target_arch in "ppc64 s390x"', {
         'v8_enable_backtrace': 1,
       }],
+      ['OS=="linux"', {
+        'node_section_ordering_info%': ''
+      }]
     ],
   },
 
@@ -188,17 +164,42 @@
           'v8_enable_handle_zapping': 0,
           'pgo_generate': ' -fprofile-generate ',
           'pgo_use': ' -fprofile-use -fprofile-correction ',
-          'lto': ' -flto=4 -fuse-linker-plugin -ffat-lto-objects ',
           'conditions': [
             ['node_shared != "true"', {
               'MSVC_runtimeType': 0    # MultiThreaded (/MT)
             }, {
               'MSVC_runtimeType': 2   # MultiThreadedDLL (/MD)
             }],
+            ['llvm_version=="0.0"', {
+              'lto': ' -flto=4 -fuse-linker-plugin -ffat-lto-objects ', # GCC
+            }, {
+              'lto': ' -flto ', # Clang
+            }],
           ],
         },
         'cflags': [ '-O3' ],
         'conditions': [
+          ['enable_lto=="true"', {
+            'cflags': ['<(lto)'],
+            'ldflags': ['<(lto)'],
+            'xcode_settings': {
+              'LLVM_LTO': 'YES',
+            },
+          }],
+          ['OS=="linux"', {
+            'conditions': [
+              ['node_section_ordering_info!=""', {
+                'cflags': [
+                  '-fuse-ld=gold',
+                  '-ffunction-sections',
+                ],
+                'ldflags': [
+                  '-fuse-ld=gold',
+                  '-Wl,--section-ordering-file=<(node_section_ordering_info)',
+                ],
+              }],
+            ],
+          }],
           ['OS=="solaris"', {
             # pull in V8's postmortem metadata
             'ldflags': [ '-Wl,-z,allextract' ]
@@ -216,10 +217,6 @@
                 'cflags': ['<(pgo_use)'],
                 'ldflags': ['<(pgo_use)'],
               },],
-              ['enable_lto=="true"', {
-                'cflags': ['<(lto)'],
-                'ldflags': ['<(lto)'],
-              },],
             ],
           },],
           ['OS == "android"', {
@@ -229,6 +226,11 @@
         ],
         'msvs_settings': {
           'VCCLCompilerTool': {
+            'conditions': [
+              ['target_arch=="arm64"', {
+                'FloatingPointModel': 1 # /fp:strict
+              }]
+            ],
             'EnableFunctionLevelLinking': 'true',
             'EnableIntrinsicFunctions': 'true',
             'FavorSizeOrSpeed': 1,          # /Ot, favor speed over size
@@ -255,7 +257,14 @@
     # Forcibly disable -Werror.  We support a wide range of compilers, it's
     # simply not feasible to squelch all warnings, never mind that the
     # libraries in deps/ are not under our control.
-    'cflags!': ['-Werror'],
+    'conditions': [
+      [ 'error_on_warn=="false"', {
+        'cflags!': ['-Werror'],
+      }, '(_target_name!="<(node_lib_target_name)" or '
+          '_target_name!="<(node_core_target_name)")', {
+        'cflags!': ['-Werror'],
+      }],
+    ],
     'msvs_settings': {
       'VCCLCompilerTool': {
         'BufferSecurityCheck': 'true',
@@ -345,6 +354,12 @@
           }],
         ],
       }],
+      ['v8_enable_pointer_compression == 1', {
+        'defines': ['V8_COMPRESS_POINTERS'],
+      }],
+      ['v8_enable_pointer_compression == 1 or v8_enable_31bit_smis_on_64bit_arch == 1', {
+        'defines': ['V8_31BIT_SMIS_ON_64BIT_ARCH'],
+      }],
       ['OS == "win"', {
         'defines': [
           'WIN32',
@@ -471,7 +486,7 @@
           'GCC_ENABLE_CPP_RTTI': 'NO',              # -fno-rtti
           'GCC_ENABLE_PASCAL_STRINGS': 'NO',        # No -mpascal-strings
           'PREBINDING': 'NO',                       # No -Wl,-prebind
-          'MACOSX_DEPLOYMENT_TARGET': '10.10',      # -mmacosx-version-min=10.10
+          'MACOSX_DEPLOYMENT_TARGET': '10.13',      # -mmacosx-version-min=10.13
           'USE_HEADERMAP': 'NO',
           'OTHER_CFLAGS': [
             '-fno-strict-aliasing',
diff --git a/configure b/configure
index 9156e13f7aed0dad68fc3f89a94f12a33d4525c8..debd3cc3d452d0f1c66ad8502c5e493d29228cfa 100644
--- a/configure
+++ b/configure
@@ -1,28 +1,39 @@
 #!/bin/sh
 
-# Locate python2 interpreter and re-execute the script.  Note that the
-# mix of single and double quotes is intentional, as is the fact that
-# the ] goes on a new line.
+# Locate an acceptable python interpreter and then re-execute the script.
+# Note that the mix of single and double quotes is intentional,
+# as is the fact that the ] goes on a new line.
 _=[ 'exec' '/bin/sh' '-c' '''
-which python2.7 >/dev/null && exec python2.7 "$0" "$@"
-which python2 >/dev/null && exec python2 "$0" "$@"
+test ${FORCE_PYTHON2} && exec python2 "$0" "$@"  # workaround for gclient
+command -v python3.10 >/dev/null && exec python3.10 "$0" "$@"
+command -v python3.9 >/dev/null && exec python3.9 "$0" "$@"
+command -v python3.8 >/dev/null && exec python3.8 "$0" "$@"
+command -v python3.7 >/dev/null && exec python3.7 "$0" "$@"
+command -v python3.6 >/dev/null && exec python3.6 "$0" "$@"
+command -v python3.5 >/dev/null && exec python3.5 "$0" "$@"
+command -v python3 >/dev/null && exec python3 "$0" "$@"
+command -v python2.7 >/dev/null && exec python2.7 "$0" "$@"
 exec python "$0" "$@"
 ''' "$0" "$@"
 ]
 del _
 
 import sys
-from distutils.spawn import find_executable as which
-if sys.version_info[:2] != (2, 7):
-  sys.stderr.write('Please use Python 2.7')
+try:
+  from shutil import which
+except ImportError:
+  from distutils.spawn import find_executable as which
 
-  python2 = which('python2') or which('python2.7')
-
-  if python2:
-    sys.stderr.write(':\n\n')
-    sys.stderr.write('  ' + python2 + ' ' + ' '.join(sys.argv))
-
-  sys.stderr.write('\n')
+print('Node.js configure: Found Python {0}.{1}.{2}...'.format(*sys.version_info))
+acceptable_pythons = ((3,10), (3, 9), (3, 8), (3, 7), (3, 6), (3, 5), (2, 7))
+if sys.version_info[:2] in acceptable_pythons:
+  import configure
+else:
+  python_cmds = ['python{0}.{1}'.format(*vers) for vers in acceptable_pythons]
+  sys.stderr.write('Please use {0}.\n'.format(' or '.join(python_cmds)))
+  for python_cmd in python_cmds:
+      python_cmd_path = which(python_cmd)
+      if python_cmd_path and 'pyenv/shims' not in python_cmd_path:
+        sys.stderr.write('\t{0} {1}\n'.format(python_cmd_path,
+                                              ' '.join(sys.argv[:1])))
   sys.exit(1)
-
-import configure
diff --git a/configure.py b/configure.py
index e6485a7b38372a14a480fd7d0fa365044a87e256..30cf6726ae891604da65e990409c22209d632b22 100644
--- a/configure.py
+++ b/configure.py
@@ -11,9 +11,15 @@ import re
 import shlex
 import subprocess
 import shutil
+import bz2
 import io
 
-from distutils.spawn import find_executable as which
+# Fallback to find_executable from distutils.spawn is a stopgap for
+# supporting V8 builds, which do not yet support Python 3.
+try:
+  from shutil import which
+except ImportError:
+  from distutils.spawn import find_executable as which
 from distutils.version import StrictVersion
 
 # If not run from node/, cd to node/.
@@ -38,6 +44,7 @@ sys.path.insert(0, 'tools')
 import getmoduleversion
 import getnapibuildversion
 from gyp_node import run_gyp
+from utils import SearchFiles
 
 # imports in deps/v8/tools/node
 sys.path.insert(0, os.path.join('deps', 'v8', 'tools', 'node'))
@@ -116,6 +123,11 @@ parser.add_option('--dest-os',
     choices=valid_os,
     help='operating system to build for ({0})'.format(', '.join(valid_os)))
 
+parser.add_option('--error-on-warn',
+    action='store_true',
+    dest='error_on_warn',
+    help='Turn compiler warnings into errors for node core sources.')
+
 parser.add_option('--gdb',
     action='store_true',
     dest='gdb',
@@ -154,7 +166,7 @@ parser.add_option("--enable-lto",
     action="store_true",
     dest="enable_lto",
     help="Enable compiling with lto of a binary. This feature is only available "
-         "on linux with gcc and g++ 5.4.1 or newer.")
+         "with gcc 5.4.1+ or clang 3.9.1+.")
 
 parser.add_option("--link-module",
     action="append",
@@ -376,6 +388,11 @@ parser.add_option('--enable-trace-maps',
     dest='trace_maps',
     help='Enable the --trace-maps flag in V8 (use at your own risk)')
 
+parser.add_option('--experimental-enable-pointer-compression',
+    action='store_true',
+    dest='enable_pointer_compression',
+    help='[Experimental] Enable V8 pointer compression (limits max heap to 4GB and breaks ABI compatibility)')
+
 parser.add_option('--v8-options',
     action='store',
     dest='v8_options',
@@ -444,10 +461,18 @@ parser.add_option('--use-largepages-script-lld',
     dest='node_use_large_pages_script_lld',
     help='This option has no effect. --use-largepages is now a runtime option.')
 
+parser.add_option('--use-section-ordering-file',
+    action='store',
+    dest='node_section_ordering_info',
+    default='',
+    help='Pass a section ordering file to the linker. This requires that ' +
+         'Node.js be linked using the gold linker. The gold linker must have ' +
+         'version 1.2 or greater.')
+
 intl_optgroup.add_option('--with-intl',
     action='store',
     dest='with_intl',
-    default='small-icu',
+    default='full-icu',
     choices=valid_intl_modes,
     help='Intl mode (valid choices: {0}) [default: %default]'.format(
         ', '.join(valid_intl_modes)))
@@ -555,7 +580,7 @@ parser.add_option('--with-snapshot',
 
 parser.add_option('--without-snapshot',
     action='store_true',
-    dest='without_snapshot',
+    dest='unused_without_snapshot',
     help=optparse.SUPPRESS_HELP)
 
 parser.add_option('--without-siphash',
@@ -838,10 +863,11 @@ def get_gas_version(cc):
 
 # Note: Apple clang self-reports as clang 4.2.0 and gcc 4.2.1.  It passes
 # the version check more by accident than anything else but a more rigorous
-# check involves checking the build number against a whitelist.  I'm not
+# check involves checking the build number against an allowlist.  I'm not
 # quite prepared to go that far yet.
 def check_compiler(o):
   if sys.platform == 'win32':
+    o['variables']['llvm_version'] = '0.0'
     if not options.openssl_no_asm and options.dest_cpu in ('x86', 'x64'):
       nasm_version = get_nasm_version('nasm')
       o['variables']['nasm_version'] = nasm_version
@@ -938,12 +964,7 @@ def is_arm_hard_float_abi():
 def host_arch_cc():
   """Host architecture check using the CC command."""
 
-  if sys.platform.startswith('aix'):
-    # we only support gcc at this point and the default on AIX
-    # would be xlc so hard code gcc
-    k = cc_macros('gcc')
-  else:
-    k = cc_macros(os.environ.get('CC_host'))
+  k = cc_macros(os.environ.get('CC_host'))
 
   matchup = {
     '__aarch64__' : 'arm64',
@@ -1021,15 +1042,24 @@ def configure_mips(o, target_arch):
   host_byteorder = 'little' if target_arch in ('mipsel', 'mips64el') else 'big'
   o['variables']['v8_host_byteorder'] = host_byteorder
 
+def clang_version_ge(version_checked):
+  for compiler in [(CC, 'c'), (CXX, 'c++')]:
+    ok, is_clang, clang_version, gcc_version = \
+      try_check_compiler(compiler[0], compiler[1])
+    if is_clang and clang_version >= version_checked:
+      return True
+  return False
 
 def gcc_version_ge(version_checked):
   for compiler in [(CC, 'c'), (CXX, 'c++')]:
-    ok, is_clang, clang_version, compiler_version = \
+    ok, is_clang, clang_version, gcc_version = \
       try_check_compiler(compiler[0], compiler[1])
-    if is_clang or compiler_version < version_checked:
+    if is_clang or gcc_version < version_checked:
       return False
   return True
 
+def configure_node_lib_files(o):
+  o['variables']['node_library_files'] = SearchFiles('lib', 'js')
 
 def configure_node(o):
   if options.dest_os == 'android':
@@ -1038,6 +1068,7 @@ def configure_node(o):
   o['variables']['node_install_npm'] = b(not options.without_npm)
   o['variables']['debug_node'] = b(options.debug_node)
   o['default_configuration'] = 'Debug' if options.debug else 'Release'
+  o['variables']['error_on_warn'] = b(options.error_on_warn)
 
   host_arch = host_arch_win() if os.name == 'nt' else host_arch_cc()
   target_arch = options.dest_cpu or host_arch
@@ -1055,15 +1086,18 @@ def configure_node(o):
   cross_compiling = (options.cross_compiling
                      if options.cross_compiling is not None
                      else target_arch != host_arch)
-  want_snapshots = not options.without_snapshot
-  o['variables']['want_separate_host_toolset'] = int(
-      cross_compiling and want_snapshots)
+  if cross_compiling:
+    os.environ['GYP_CROSSCOMPILE'] = "1"
+  if options.unused_without_snapshot:
+    warn('building --without-snapshot is no longer possible')
+
+  o['variables']['want_separate_host_toolset'] = int(cross_compiling)
 
   if options.without_node_snapshot or options.node_builtin_modules_path:
     o['variables']['node_use_node_snapshot'] = 'false'
   else:
     o['variables']['node_use_node_snapshot'] = b(
-      not cross_compiling and want_snapshots and not options.shared)
+      not cross_compiling and not options.shared)
 
   if options.without_node_code_cache or options.node_builtin_modules_path:
     o['variables']['node_use_node_code_cache'] = 'false'
@@ -1103,18 +1137,19 @@ def configure_node(o):
   o['variables']['enable_pgo_generate'] = b(options.enable_pgo_generate)
   o['variables']['enable_pgo_use']      = b(options.enable_pgo_use)
 
-  if flavor != 'linux' and (options.enable_lto):
+  if flavor == 'win' and (options.enable_lto):
     raise Exception(
-      'The lto option is supported only on linux.')
-
-  if flavor == 'linux':
-    if options.enable_lto:
-      version_checked = (5, 4, 1)
-      if not gcc_version_ge(version_checked):
-        version_checked_str = ".".join(map(str, version_checked))
-        raise Exception(
-          'The option --enable-lto is supported for gcc and gxx %s'
-          ' or newer only.' % (version_checked_str))
+      'Use Link Time Code Generation instead.')
+
+  if options.enable_lto:
+    gcc_version_checked = (5, 4, 1)
+    clang_version_checked = (3, 9, 1)
+    if not gcc_version_ge(gcc_version_checked) and not clang_version_ge(clang_version_checked):
+      gcc_version_checked_str = ".".join(map(str, gcc_version_checked))
+      clang_version_checked_str = ".".join(map(str, clang_version_checked))
+      raise Exception(
+        'The option --enable-lto is supported for gcc %s+'
+        'or clang %s+ only.' % (gcc_version_checked_str, clang_version_checked_str))
 
   o['variables']['enable_lto'] = b(options.enable_lto)
 
@@ -1225,8 +1260,7 @@ def configure_library(lib, output, pkgname=None):
   output['variables']['node_' + shared_lib] = b(getattr(options, shared_lib))
 
   if getattr(options, shared_lib):
-    (pkg_libs, pkg_cflags, pkg_libpath, pkg_modversion) = (
-        pkg_config(pkgname or lib))
+    (pkg_libs, pkg_cflags, pkg_libpath, _) = pkg_config(pkgname or lib)
 
     if options.__dict__[shared_lib + '_includes']:
       output['include_dirs'] += [options.__dict__[shared_lib + '_includes']]
@@ -1266,7 +1300,8 @@ def configure_v8(o):
   o['variables']['v8_random_seed'] = 0  # Use a random seed for hash tables.
   o['variables']['v8_promise_internal_field_count'] = 1 # Add internal field to promises for async hooks.
   o['variables']['v8_use_siphash'] = 0 if options.without_siphash else 1
-  o['variables']['v8_use_snapshot'] = 0 if options.without_snapshot else 1
+  o['variables']['v8_enable_pointer_compression'] = 1 if options.enable_pointer_compression else 0
+  o['variables']['v8_enable_31bit_smis_on_64bit_arch'] = 1 if options.enable_pointer_compression else 0
   o['variables']['v8_trace_maps'] = 1 if options.trace_maps else 0
   o['variables']['node_use_v8_platform'] = b(not options.without_v8_platform)
   o['variables']['node_use_bundled_v8'] = b(not options.without_bundled_v8)
@@ -1430,8 +1465,6 @@ def configure_intl(o):
     'variables': {}
   }
   icu_config_name = 'icu_config.gypi'
-  def write_config(data, name):
-    return
 
   # write an empty file to start with
   write(icu_config_name, do_not_edit +
@@ -1497,7 +1530,8 @@ def configure_intl(o):
   icu_parent_path = 'deps'
 
   # The full path to the ICU source directory. Should not include './'.
-  icu_full_path = 'deps/icu'
+  icu_deps_path = 'deps/icu'
+  icu_full_path = icu_deps_path
 
   # icu-tmp is used to download and unpack the ICU tarball.
   icu_tmp_path = os.path.join(icu_parent_path, 'icu-tmp')
@@ -1505,30 +1539,26 @@ def configure_intl(o):
   # canned ICU. see tools/icu/README.md to update.
   canned_icu_dir = 'deps/icu-small'
 
+  # use the README to verify what the canned ICU is
+  canned_is_full = os.path.isfile(os.path.join(canned_icu_dir, 'README-FULL-ICU.txt'))
+  canned_is_small = os.path.isfile(os.path.join(canned_icu_dir, 'README-SMALL-ICU.txt'))
+  if canned_is_small:
+    warn('Ignoring %s - in-repo small icu is no longer supported.' % canned_icu_dir)
+
   # We can use 'deps/icu-small' - pre-canned ICU *iff*
-  # - with_intl == small-icu (the default!)
-  # - with_icu_locales == 'root,en' (the default!)
-  # - deps/icu-small exists!
+  # - canned_is_full AND
   # - with_icu_source is unset (i.e. no other ICU was specified)
-  # (Note that this is the *DEFAULT CASE*.)
   #
   # This is *roughly* equivalent to
-  # $ configure --with-intl=small-icu --with-icu-source=deps/icu-small
+  # $ configure --with-intl=full-icu --with-icu-source=deps/icu-small
   # .. Except that we avoid copying icu-small over to deps/icu.
   # In this default case, deps/icu is ignored, although make clean will
   # still harmlessly remove deps/icu.
 
-  # are we using default locales?
-  using_default_locales = ( options.with_icu_locales == icu_default_locales )
-
-  # make sure the canned ICU really exists
-  canned_icu_available = os.path.isdir(canned_icu_dir)
-
-  if (o['variables']['icu_small'] == b(True)) and using_default_locales and (not with_icu_source) and canned_icu_available:
+  if (not with_icu_source) and canned_is_full:
     # OK- we can use the canned ICU.
-    icu_config['variables']['icu_small_canned'] = 1
     icu_full_path = canned_icu_dir
-
+    icu_config['variables']['icu_full_canned'] = 1
   # --with-icu-source processing
   # now, check that they didn't pass --with-icu-source=deps/icu
   elif with_icu_source and os.path.abspath(icu_full_path) == os.path.abspath(with_icu_source):
@@ -1607,29 +1637,43 @@ def configure_intl(o):
   icu_endianness = sys.byteorder[0]
   o['variables']['icu_ver_major'] = icu_ver_major
   o['variables']['icu_endianness'] = icu_endianness
-  icu_data_file_l = 'icudt%s%s.dat' % (icu_ver_major, 'l')
+  icu_data_file_l = 'icudt%s%s.dat' % (icu_ver_major, 'l') # LE filename
   icu_data_file = 'icudt%s%s.dat' % (icu_ver_major, icu_endianness)
   # relative to configure
   icu_data_path = os.path.join(icu_full_path,
                                'source/data/in',
-                               icu_data_file_l)
+                               icu_data_file_l) # LE
+  compressed_data = '%s.bz2' % (icu_data_path)
+  if not os.path.isfile(icu_data_path) and os.path.isfile(compressed_data):
+    # unpack. deps/icu is a temporary path
+    if os.path.isdir(icu_tmp_path):
+      shutil.rmtree(icu_tmp_path)
+    os.mkdir(icu_tmp_path)
+    icu_data_path = os.path.join(icu_tmp_path, icu_data_file_l)
+    with open(icu_data_path, 'wb') as outf:
+        inf = bz2.BZ2File(compressed_data, 'rb')
+        try:
+          shutil.copyfileobj(inf, outf)
+        finally:
+          inf.close()
+    # Now, proceed..
+
   # relative to dep..
-  icu_data_in = os.path.join('..','..', icu_full_path, 'source/data/in', icu_data_file_l)
+  icu_data_in = os.path.join('..','..', icu_data_path)
   if not os.path.isfile(icu_data_path) and icu_endianness != 'l':
     # use host endianness
     icu_data_path = os.path.join(icu_full_path,
                                  'source/data/in',
-                                 icu_data_file)
-    # relative to dep..
-    icu_data_in = os.path.join('..', icu_full_path, 'source/data/in',
-                               icu_data_file)
-  # this is the input '.dat' file to use .. icudt*.dat
-  # may be little-endian if from a icu-project.org tarball
-  o['variables']['icu_data_in'] = icu_data_in
+                                 icu_data_file) # will be generated
   if not os.path.isfile(icu_data_path):
     # .. and we're not about to build it from .gyp!
     error('''ICU prebuilt data file %s does not exist.
        See the README.md.''' % icu_data_path)
+
+  # this is the input '.dat' file to use .. icudt*.dat
+  # may be little-endian if from a icu-project.org tarball
+  o['variables']['icu_data_in'] = icu_data_in
+
   # map from variable name to subdirs
   icu_src = {
     'stubdata': 'stubdata',
@@ -1646,6 +1690,31 @@ def configure_intl(o):
     var  = 'icu_src_%s' % i
     path = '../../%s/source/%s' % (icu_full_path, icu_src[i])
     icu_config['variables'][var] = glob_to_var('tools/icu', path, 'patches/%s/source/%s' % (icu_ver_major, icu_src[i]) )
+  # calculate platform-specific genccode args
+  # print("platform %s, flavor %s" % (sys.platform, flavor))
+  # if sys.platform == 'darwin':
+  #   shlib_suffix = '%s.dylib'
+  # elif sys.platform.startswith('aix'):
+  #   shlib_suffix = '%s.a'
+  # else:
+  #   shlib_suffix = 'so.%s'
+  if flavor == 'win':
+    icu_config['variables']['icu_asm_ext'] = 'obj'
+    icu_config['variables']['icu_asm_opts'] = [ '-o ' ]
+  elif with_intl == 'small-icu' or options.cross_compiling:
+    icu_config['variables']['icu_asm_ext'] = 'c'
+    icu_config['variables']['icu_asm_opts'] = []
+  elif flavor == 'mac':
+    icu_config['variables']['icu_asm_ext'] = 'S'
+    icu_config['variables']['icu_asm_opts'] = [ '-a', 'gcc-darwin' ]
+  elif sys.platform.startswith('aix'):
+    icu_config['variables']['icu_asm_ext'] = 'S'
+    icu_config['variables']['icu_asm_opts'] = [ '-a', 'xlc' ]
+  else:
+    # assume GCC-compatible asm is OK
+    icu_config['variables']['icu_asm_ext'] = 'S'
+    icu_config['variables']['icu_asm_opts'] = [ '-a', 'gcc' ]
+
   # write updated icu_config.gypi with a bunch of paths
   write(icu_config_name, do_not_edit +
         pprint.pformat(icu_config, indent=2) + '\n')
@@ -1657,6 +1726,30 @@ def configure_inspector(o):
                        options.without_ssl)
   o['variables']['v8_enable_inspector'] = 0 if disable_inspector else 1
 
+def configure_section_file(o):
+  try:
+    proc = subprocess.Popen(['ld.gold'] + ['-v'], stdin = subprocess.PIPE,
+                            stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+  except OSError:
+    if options.node_section_ordering_info != "":
+      warn('''No acceptable ld.gold linker found!''')
+    return 0
+
+  match = re.match(r"^GNU gold.*([0-9]+)\.([0-9]+)$",
+                   proc.communicate()[0].decode("utf-8"))
+
+  if match:
+    gold_major_version = match.group(1)
+    gold_minor_version = match.group(2)
+    if int(gold_major_version) == 1 and int(gold_minor_version) <= 1:
+      error('''GNU gold version must be greater than 1.2 in order to use section
+            reordering''')
+
+  if options.node_section_ordering_info != "":
+    o['variables']['node_section_ordering_info'] = os.path.realpath(
+      str(options.node_section_ordering_info))
+  else:
+    o['variables']['node_section_ordering_info'] = ""
 
 def make_bin_override():
   if sys.platform == 'win32':
@@ -1710,6 +1803,7 @@ if (options.dest_os):
 flavor = GetFlavor(flavor_params)
 
 configure_node(output)
+configure_node_lib_files(output)
 configure_napi(output)
 configure_library('zlib', output)
 configure_library('http_parser', output)
@@ -1722,6 +1816,7 @@ configure_openssl(output)
 configure_intl(output)
 configure_static(output)
 configure_inspector(output)
+configure_section_file(output)
 
 # Forward OSS-Fuzz settings
 output['variables']['ossfuzz'] = b(options.ossfuzz)
@@ -1810,6 +1905,10 @@ else:
 if options.compile_commands_json:
   gyp_args += ['-f', 'compile_commands_json']
 
+# override the variable `python` defined in common.gypi
+if bin_override is not None:
+  gyp_args += ['-Dpython=' + sys.executable]
+
 # pass the leftover positional arguments to GYP
 gyp_args += args
 
diff --git a/deps/acorn-plugins/acorn-class-fields/CHANGELOG.md b/deps/acorn-plugins/acorn-class-fields/CHANGELOG.md
deleted file mode 100644
index de2c66b0c3bc65c00f88f57d8cc4a1d0ca4af32f..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-class-fields/CHANGELOG.md
+++ /dev/null
@@ -1,28 +0,0 @@
-## 0.3.1 (2019-02-09)
-
-* Restore compatibility with acorn-private-methods
-
-## 0.3.0 (2019-02-09)
-
-* Require acorn >= 6.1.0
-
-## 0.2.1 (2018-11-06)
-
-* Adapt to changes in acorn 6.0.3
-
-## 0.2.0 (2018-09-14)
-
-* Update to new acorn 6 interface
-* Change license to MIT
-
-## 0.1.2 (2018-01-26)
-
-* Don't accept whitespace between hash and private name
-
-## 0.1.1 (2018-01-17)
-
-* Correctly parse all fields named `async`
-
-## 0.1.0 (2018-01-13)
-
-Initial release
diff --git a/deps/acorn-plugins/acorn-class-fields/LICENSE b/deps/acorn-plugins/acorn-class-fields/LICENSE
deleted file mode 100644
index 7c2b27a19c033cbdfa39082bf03715fa874a646e..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-class-fields/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (C) 2017-2018 by Adrian Heine
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/deps/acorn-plugins/acorn-class-fields/README.md b/deps/acorn-plugins/acorn-class-fields/README.md
deleted file mode 100644
index 60f3463e94d315c260bff7f99366574f6e71c2a7..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-class-fields/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Class fields support for Acorn
-
-[![NPM version](https://img.shields.io/npm/v/acorn-class-fields.svg)](https://www.npmjs.org/package/acorn-class-fields)
-
-This is a plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
-
-It implements support for class fields as defined in the stage 3 proposal [Class field declarations for JavaScript](https://github.com/tc39/proposal-class-fields). The emitted AST follows [an ESTree proposal](https://github.com/estree/estree/pull/180).
-
-## Usage
-
-This module provides a plugin that can be used to extend the Acorn `Parser` class:
-
-```javascript
-const {Parser} = require('acorn');
-const classFields = require('acorn-class-fields');
-Parser.extend(classFields).parse('class X { x = 0 }');
-```
-
-## License
-
-This plugin is released under an [MIT License](./LICENSE).
diff --git a/deps/acorn-plugins/acorn-class-fields/index.js b/deps/acorn-plugins/acorn-class-fields/index.js
deleted file mode 100644
index 20348c80c6bcbf24db63081cfcbd50e130ae3470..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-class-fields/index.js
+++ /dev/null
@@ -1,59 +0,0 @@
-"use strict"
-
-const acorn = require('internal/deps/acorn/acorn/dist/acorn')
-const tt = acorn.tokTypes
-const privateClassElements = require('internal/deps/acorn-plugins/acorn-private-class-elements/index')
-
-function maybeParseFieldValue(field) {
-  if (this.eat(tt.eq)) {
-    const oldInFieldValue = this._inFieldValue
-    this._inFieldValue = true
-    field.value = this.parseExpression()
-    this._inFieldValue = oldInFieldValue
-  } else field.value = null
-}
-
-module.exports = function(Parser) {
-  Parser = privateClassElements(Parser)
-  return class extends Parser {
-    // Parse fields
-    parseClassElement(_constructorAllowsSuper) {
-      if (this.options.ecmaVersion >= 8 && (this.type == tt.name || this.type == this.privateNameToken || this.type == tt.bracketL || this.type == tt.string)) {
-        const branch = this._branch()
-        if (branch.type == tt.bracketL) {
-          let count = 0
-          do {
-            if (branch.eat(tt.bracketL)) ++count
-            else if (branch.eat(tt.bracketR)) --count
-            else branch.next()
-          } while (count > 0)
-        } else branch.next()
-        if (branch.type == tt.eq || branch.canInsertSemicolon() || branch.type == tt.semi) {
-          const node = this.startNode()
-          if (this.type == this.privateNameToken) {
-            this.parsePrivateClassElementName(node)
-          } else {
-            this.parsePropertyName(node)
-          }
-          if ((node.key.type === "Identifier" && node.key.name === "constructor") ||
-              (node.key.type === "Literal" && node.key.value === "constructor")) {
-            this.raise(node.key.start, "Classes may not have a field called constructor")
-          }
-          maybeParseFieldValue.call(this, node)
-          this.finishNode(node, "FieldDefinition")
-          this.semicolon()
-          return node
-        }
-      }
-
-      return super.parseClassElement.apply(this, arguments)
-    }
-
-    // Prohibit arguments in class field initializers
-    parseIdent(liberal, isBinding) {
-      const ident = super.parseIdent(liberal, isBinding)
-      if (this._inFieldValue && ident.name == "arguments") this.raise(ident.start, "A class field initializer may not contain arguments")
-      return ident
-    }
-  }
-}
diff --git a/deps/acorn-plugins/acorn-class-fields/package.json b/deps/acorn-plugins/acorn-class-fields/package.json
deleted file mode 100644
index 550511399f248da8bb9076133f3dbeade104251b..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-class-fields/package.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
-  "name": "acorn-class-fields",
-  "description": "Support for class fields in acorn",
-  "homepage": "https://github.com/acornjs/acorn-class-fields",
-  "contributors": [
-    "Adrian Heine <mail@adrianheine.de>"
-  ],
-  "engines": {
-    "node": ">=4.8.2"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/acornjs/acorn-class-fields"
-  },
-  "license": "MIT",
-  "scripts": {
-    "test": "mocha",
-    "test:test262": "node run_test262.js",
-    "lint": "eslint -c .eslintrc.json ."
-  },
-  "peerDependencies": {
-    "acorn": "^6.0.0"
-  },
-  "version": "0.3.1",
-  "devDependencies": {
-    "acorn": "^6.1.0",
-    "eslint": "^5.13.0",
-    "eslint-plugin-node": "^8.0.1",
-    "mocha": "^5.2.0",
-    "test262": "git+https://github.com/tc39/test262.git#33a306d1026b72227eb50a918db19ada16f12b3d",
-    "test262-parser-runner": "^0.5.0"
-  },
-  "dependencies": {
-    "acorn-private-class-elements": "^0.1.1"
-  }
-}
\ No newline at end of file
diff --git a/deps/acorn-plugins/acorn-numeric-separator/CHANGELOG.md b/deps/acorn-plugins/acorn-numeric-separator/CHANGELOG.md
deleted file mode 100644
index dfe8e3ea9dedb8b68d67f21e3c2a45b0b055e576..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-numeric-separator/CHANGELOG.md
+++ /dev/null
@@ -1,16 +0,0 @@
-## 0.3.0 (2019-04-04)
-
-* Make compatible with acorn-bigint
-
-## 0.2.0 (2018-09-14)
-
-* Update to new acorn 6 interface
-* Change license to MIT
-
-## 0.1.1 (2018-01-16)
-
-* Don't bail on empty integers as in `1.`
-
-## 0.1.0 (2017-12-19)
-
-Initial release
diff --git a/deps/acorn-plugins/acorn-numeric-separator/LICENSE b/deps/acorn-plugins/acorn-numeric-separator/LICENSE
deleted file mode 100644
index 7c2b27a19c033cbdfa39082bf03715fa874a646e..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-numeric-separator/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (C) 2017-2018 by Adrian Heine
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/deps/acorn-plugins/acorn-numeric-separator/README.md b/deps/acorn-plugins/acorn-numeric-separator/README.md
deleted file mode 100644
index 27188572d1bf4048b2053a6aaf770a8b3459e854..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-numeric-separator/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Numeric separator support for Acorn
-
-[![NPM version](https://img.shields.io/npm/v/acorn-numeric-separator.svg)](https://www.npmjs.org/package/acorn-numeric-separator)
-
-This is a plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
-
-It implements support for numeric separators as defined in the stage 3 proposal [Numeric Separators](https://github.com/tc39/proposal-numeric-separator).
-
-## Usage
-
-This module provides a plugin that can be used to extend the Acorn `Parser` class to parse numeric separators:
-
-```javascript
-var acorn = require('acorn');
-var numericSeparator = require('acorn-numeric-separator');
-acorn.Parser.extend(numericSeparator).parse('100_000');
-```
-
-## License
-
-This plugin is released under an [MIT License](./LICENSE).
diff --git a/deps/acorn-plugins/acorn-numeric-separator/index.js b/deps/acorn-plugins/acorn-numeric-separator/index.js
deleted file mode 100644
index 52f207cfd8d454d30e6e43f3da2b51ed14644004..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-numeric-separator/index.js
+++ /dev/null
@@ -1,49 +0,0 @@
-"use strict"
-
-module.exports = function(Parser) {
-  return class extends Parser {
-    readInt(radix, len) {
-      // Hack: len is only != null for unicode escape sequences,
-      // where numeric separators are not allowed
-      if (len != null) return super.readInt(radix, len)
-
-      let start = this.pos, total = 0, acceptUnderscore = false
-      for (;;) {
-        let code = this.input.charCodeAt(this.pos), val
-        if (code >= 97) val = code - 97 + 10 // a
-        else if (code == 95) {
-          if (!acceptUnderscore) this.raise(this.pos, "Invalid numeric separator")
-          ++this.pos
-          acceptUnderscore = false
-          continue
-        } else if (code >= 65) val = code - 65 + 10 // A
-        else if (code >= 48 && code <= 57) val = code - 48 // 0-9
-        else val = Infinity
-        if (val >= radix) break
-        ++this.pos
-        total = total * radix + val
-        acceptUnderscore = true
-      }
-      if (this.pos === start) return null
-      if (!acceptUnderscore) this.raise(this.pos - 1, "Invalid numeric separator")
-
-      return total
-    }
-
-    readNumber(startsWithDot) {
-      const token = super.readNumber(startsWithDot)
-      let octal = this.end - this.start >= 2 && this.input.charCodeAt(this.start) === 48
-      const stripped = this.getNumberInput(this.start, this.end)
-      if (stripped.length < this.end - this.start) {
-        if (octal) this.raise(this.start, "Invalid number")
-        this.value = parseFloat(stripped)
-      }
-      return token
-    }
-
-    // This is used by acorn-bigint
-    getNumberInput(start, end) {
-      return this.input.slice(start, end).replace(/_/g, "")
-    }
-  }
-}
diff --git a/deps/acorn-plugins/acorn-numeric-separator/package.json b/deps/acorn-plugins/acorn-numeric-separator/package.json
deleted file mode 100644
index cc0c52a65d2dfe3be80c39b880d84807a39466a2..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-numeric-separator/package.json
+++ /dev/null
@@ -1,33 +0,0 @@
-{
-  "name": "acorn-numeric-separator",
-  "description": "Support for numeric separators in acorn",
-  "homepage": "https://github.com/acornjs/acorn-numeric-separator",
-  "contributors": [
-    "Adrian Heine <mail@adrianheine.de>"
-  ],
-  "engines": {
-    "node": ">=4.8.2"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/acornjs/acorn-numeric-separator"
-  },
-  "license": "MIT",
-  "scripts": {
-    "test": "mocha",
-    "test:test262": "node run_test262.js",
-    "lint": "eslint -c .eslintrc.json ."
-  },
-  "peerDependencies": {
-    "acorn": "^6.0.0"
-  },
-  "version": "0.3.0",
-  "devDependencies": {
-    "acorn": "^6.0.0",
-    "eslint": "^5.5.0",
-    "eslint-plugin-node": "^8.0.1",
-    "mocha": "^6.0.2",
-    "test262": "git+https://github.com/tc39/test262.git#de567d3aa5de4eaa11e00131d26b9fe77997dfb0",
-    "test262-parser-runner": "^0.5.0"
-  }
-}
\ No newline at end of file
diff --git a/deps/acorn-plugins/acorn-private-class-elements/CHANGELOG.md b/deps/acorn-plugins/acorn-private-class-elements/CHANGELOG.md
deleted file mode 100644
index 6d4854429aacfa8129c39bafe98199e935f5e8e9..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-class-elements/CHANGELOG.md
+++ /dev/null
@@ -1,11 +0,0 @@
-## 0.2.0 (2020-03-07)
-
-* Mark as compatible with acorn v7
-
-## 0.1.1 (2019-02-09)
-
-* Add \_branch() method
-
-## 0.1.0 (2019-02-09)
-
-Initial release
diff --git a/deps/acorn-plugins/acorn-private-class-elements/LICENSE b/deps/acorn-plugins/acorn-private-class-elements/LICENSE
deleted file mode 100644
index 7c2b27a19c033cbdfa39082bf03715fa874a646e..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-class-elements/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (C) 2017-2018 by Adrian Heine
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/deps/acorn-plugins/acorn-private-class-elements/README.md b/deps/acorn-plugins/acorn-private-class-elements/README.md
deleted file mode 100644
index 0d228820cd1d0146dff282c6b405dd3a7797574c..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-class-elements/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# Helpers for supporting private class methods and fields for Acorn
-
-[![NPM version](https://img.shields.io/npm/v/acorn-private-class-elements.svg)](https://www.npmjs.org/package/acorn-private-class-elements)
-
-This is a plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
-
-It provides helpers for implementing support for private class elements. The emitted AST follows [an ESTree proposal](https://github.com/estree/estree/pull/180).
-
-## License
-
-This plugin is released under an [MIT License](./LICENSE).
diff --git a/deps/acorn-plugins/acorn-private-class-elements/index.js b/deps/acorn-plugins/acorn-private-class-elements/index.js
deleted file mode 100644
index 1f40bda9baa2eb30e335f0a1d38f2cc2b4f89099..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-class-elements/index.js
+++ /dev/null
@@ -1,123 +0,0 @@
-"use strict"
-
-const acorn = require('internal/deps/acorn/acorn/dist/acorn')
-if (acorn.version.indexOf("6.") != 0 && acorn.version.indexOf("6.0.") == 0 && acorn.version.indexOf("7.") != 0) {
-  throw new Error(`acorn-private-class-elements requires acorn@^6.1.0 or acorn@7.0.0, not ${acorn.version}`)
-}
-const tt = acorn.tokTypes
-const TokenType = acorn.TokenType
-
-module.exports = function(Parser) {
-  // Only load this plugin once.
-  if (Parser.prototype.parsePrivateName) {
-    return Parser
-  }
-
-  // Make sure `Parser` comes from the same acorn as our `tt`,
-  // otherwise the comparisons fail.
-  let cur = Parser
-  while (cur && cur !== acorn.Parser) {
-    cur = cur.__proto__
-  }
-  if (cur !== acorn.Parser) {
-    throw new Error("acorn-private-class-elements does not support mixing different acorn copies")
-  }
-
-  Parser = class extends Parser {
-    _branch() {
-      this.__branch = this.__branch || new Parser({ecmaVersion: this.options.ecmaVersion}, this.input)
-      this.__branch.end = this.end
-      this.__branch.pos = this.pos
-      this.__branch.type = this.type
-      this.__branch.value = this.value
-      this.__branch.containsEsc = this.containsEsc
-      return this.__branch
-    }
-
-    parsePrivateClassElementName(element) {
-      element.computed = false
-      element.key = this.parsePrivateName()
-      if (element.key.name == "constructor") this.raise(element.key.start, "Classes may not have a private element named constructor")
-      const accept = {get: "set", set: "get"}[element.kind]
-      const privateBoundNames = this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1]
-      if (Object.prototype.hasOwnProperty.call(privateBoundNames, element.key.name) && privateBoundNames[element.key.name] !== accept) {
-        this.raise(element.start, "Duplicate private element")
-      }
-      privateBoundNames[element.key.name] = element.kind || true
-      delete this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1][element.key.name]
-      return element.key
-    }
-
-    parsePrivateName() {
-      const node = this.startNode()
-      node.name = this.value
-      this.next()
-      this.finishNode(node, "PrivateName")
-      if (this.options.allowReserved == "never") this.checkUnreserved(node)
-      return node
-    }
-
-    // Parse # token
-    getTokenFromCode(code) {
-      if (code === 35) {
-        ++this.pos
-        const word = this.readWord1()
-        return this.finishToken(this.privateNameToken, word)
-      }
-      return super.getTokenFromCode(code)
-    }
-
-    // Manage stacks and check for undeclared private names
-    parseClass(node, isStatement) {
-      this._privateBoundNamesStack = this._privateBoundNamesStack || []
-      const privateBoundNames = Object.create(this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1] || null)
-      this._privateBoundNamesStack.push(privateBoundNames)
-      this._unresolvedPrivateNamesStack = this._unresolvedPrivateNamesStack || []
-      const unresolvedPrivateNames = Object.create(null)
-      this._unresolvedPrivateNamesStack.push(unresolvedPrivateNames)
-      const _return = super.parseClass(node, isStatement)
-      this._privateBoundNamesStack.pop()
-      this._unresolvedPrivateNamesStack.pop()
-      if (!this._unresolvedPrivateNamesStack.length) {
-        const names = Object.keys(unresolvedPrivateNames)
-        if (names.length) {
-          names.sort((n1, n2) => unresolvedPrivateNames[n1] - unresolvedPrivateNames[n2])
-          this.raise(unresolvedPrivateNames[names[0]], "Usage of undeclared private name")
-        }
-      } else Object.assign(this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1], unresolvedPrivateNames)
-      return _return
-    }
-
-    // Parse private element access
-    parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow) {
-      if (!this.eat(tt.dot)) {
-        return super.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow)
-      }
-      let node = this.startNodeAt(startPos, startLoc)
-      node.object = base
-      node.computed = false
-      if (this.type == this.privateNameToken) {
-        node.property = this.parsePrivateName()
-        if (!this._privateBoundNamesStack.length || !this._privateBoundNamesStack[this._privateBoundNamesStack.length - 1][node.property.name]) {
-          this._unresolvedPrivateNamesStack[this._unresolvedPrivateNamesStack.length - 1][node.property.name] = node.property.start
-        }
-      } else {
-        node.property = this.parseIdent(true)
-      }
-      return this.finishNode(node, "MemberExpression")
-    }
-
-    // Prohibit delete of private class elements
-    parseMaybeUnary(refDestructuringErrors, sawUnary) {
-      const _return = super.parseMaybeUnary(refDestructuringErrors, sawUnary)
-      if (_return.operator == "delete") {
-        if (_return.argument.type == "MemberExpression" && _return.argument.property.type == "PrivateName") {
-          this.raise(_return.start, "Private elements may not be deleted")
-        }
-      }
-      return _return
-    }
-  }
-  Parser.prototype.privateNameToken = new TokenType("privateName")
-  return Parser
-}
diff --git a/deps/acorn-plugins/acorn-private-class-elements/package.json b/deps/acorn-plugins/acorn-private-class-elements/package.json
deleted file mode 100644
index b8b652a1e9e2f3c72b11bac54ebe4522f87370b0..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-class-elements/package.json
+++ /dev/null
@@ -1,30 +0,0 @@
-{
-  "name": "acorn-private-class-elements",
-  "description": "Helpers for supporting private class methods and fields in acorn",
-  "homepage": "https://github.com/acornjs/acorn-private-class-elements",
-  "contributors": [
-    "Adrian Heine <mail@adrianheine.de>"
-  ],
-  "engines": {
-    "node": ">=4.8.2"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/acornjs/acorn-private-class-elements"
-  },
-  "license": "MIT",
-  "scripts": {
-    "test": "mocha",
-    "lint": "eslint -c .eslintrc.json ."
-  },
-  "peerDependencies": {
-    "acorn": "^6.1.0 || ^7.0.0"
-  },
-  "version": "0.2.0",
-  "devDependencies": {
-    "acorn": "^7.0.0",
-    "eslint": "^6.8.0",
-    "eslint-plugin-node": "^11.0.0",
-    "mocha": "^7.1.0"
-  }
-}
\ No newline at end of file
diff --git a/deps/acorn-plugins/acorn-private-methods/CHANGELOG.md b/deps/acorn-plugins/acorn-private-methods/CHANGELOG.md
deleted file mode 100644
index 5de4b97b8111b03187e5c7c87a74b705ec1461d5..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-methods/CHANGELOG.md
+++ /dev/null
@@ -1,29 +0,0 @@
-## 0.3.0 (2019-02-09)
-
-* Require acorn >= 6.1.0
-
-## 0.2.3 (2019-02-09)
-
-* Forbid binding await in async arrow function's parameter list
-
-## 0.2.2 (2019-01-30)
-
-* Fix parsing of chained subscripts
-
-## 0.2.1 (2018-11-06)
-
-* Adapt to changes in acorn 6.0.3
-
-## 0.2.0 (2018-09-14)
-
-* Update to new acorn 6 interface
-* Change license to MIT
-* Don't allow direct super() calls in private methods
-
-## 0.1.1 (2018-02-09)
-
-* Don't accept whitespace between hash and private name
-
-## 0.1.0 (2018-01-13)
-
-Initial release
diff --git a/deps/acorn-plugins/acorn-private-methods/LICENSE b/deps/acorn-plugins/acorn-private-methods/LICENSE
deleted file mode 100644
index 7c2b27a19c033cbdfa39082bf03715fa874a646e..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-methods/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (C) 2017-2018 by Adrian Heine
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/deps/acorn-plugins/acorn-private-methods/README.md b/deps/acorn-plugins/acorn-private-methods/README.md
deleted file mode 100644
index 6929e84ba620a80d010e7f93e9cf58a83d9d1c46..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-methods/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Private methods and getter/setters support for Acorn
-
-[![NPM version](https://img.shields.io/npm/v/acorn-private-methods.svg)](https://www.npmjs.org/package/acorn-private-methods)
-
-This is a plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
-
-It implements support for private methods, getters and setters as defined in the stage 3 proposal [Private methods and getter/setters for JavaScript classes](https://github.com/tc39/proposal-private-methods). The emitted AST follows [an ESTree proposal](https://github.com/estree/estree/pull/180).
-
-## Usage
-
-This module provides a plugin that can be used to extend the Acorn `Parser` class:
-
-```javascript
-const {Parser} = require('acorn');
-const privateMethods = require('acorn-private-methods');
-Parser.extend(privateMethods).parse('class X { #a() {} }');
-```
-
-## License
-
-This plugin is released under an [MIT License](./LICENSE).
diff --git a/deps/acorn-plugins/acorn-private-methods/index.js b/deps/acorn-plugins/acorn-private-methods/index.js
deleted file mode 100644
index a2964251680565b09a332c415c18e6ba22baebd5..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-methods/index.js
+++ /dev/null
@@ -1,25 +0,0 @@
-"use strict"
-
-const privateClassElements = require('internal/deps/acorn-plugins/acorn-private-class-elements/index')
-
-module.exports = function(Parser) {
-  const ExtendedParser = privateClassElements(Parser)
-
-  return class extends ExtendedParser {
-    // Parse private methods
-    parseClassElement(_constructorAllowsSuper) {
-      const oldInClassMemberName = this._inClassMemberName
-      this._inClassMemberName = true
-      const result = super.parseClassElement.apply(this, arguments)
-      this._inClassMemberName = oldInClassMemberName
-      return result
-    }
-
-    parsePropertyName(prop) {
-      const isPrivate = this.options.ecmaVersion >= 8 && this._inClassMemberName && this.type == this.privateNameToken
-      this._inClassMemberName = false
-      if (!isPrivate) return super.parsePropertyName(prop)
-      return this.parsePrivateClassElementName(prop)
-    }
-  }
-}
diff --git a/deps/acorn-plugins/acorn-private-methods/package.json b/deps/acorn-plugins/acorn-private-methods/package.json
deleted file mode 100644
index e7b91592aaa9b90ff7a612ec8e64e4024c7a6086..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-private-methods/package.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
-  "name": "acorn-private-methods",
-  "description": "Support for private methods in acorn",
-  "homepage": "https://github.com/acornjs/acorn-private-methods",
-  "contributors": [
-    "Adrian Heine <mail@adrianheine.de>"
-  ],
-  "engines": {
-    "node": ">=4.8.2"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/acornjs/acorn-private-methods"
-  },
-  "license": "MIT",
-  "scripts": {
-    "test": "mocha",
-    "test:test262": "node run_test262.js",
-    "lint": "eslint -c .eslintrc.json ."
-  },
-  "peerDependencies": {
-    "acorn": "^6.1.0"
-  },
-  "dependencies": {
-    "acorn-private-class-elements": "^0.1.0"
-  },
-  "version": "0.3.0",
-  "devDependencies": {
-    "acorn": "^6.1.0",
-    "eslint": "^5.13.0",
-    "eslint-plugin-node": "^8.0.1",
-    "mocha": "^5.2.0",
-    "test262": "git+https://github.com/tc39/test262.git#33a306d1026b72227eb50a918db19ada16f12b3d",
-    "test262-parser-runner": "^0.5.0"
-  }
-}
\ No newline at end of file
diff --git a/deps/acorn-plugins/acorn-static-class-features/CHANGELOG.md b/deps/acorn-plugins/acorn-static-class-features/CHANGELOG.md
deleted file mode 100644
index b9896a4bc5a45e647d37744e7c3ebf18cb1f8662..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-static-class-features/CHANGELOG.md
+++ /dev/null
@@ -1,11 +0,0 @@
-## 0.2.0 (2019-02-09)
-
-* Require acorn >= 6.1.0
-
-## 0.1.1 (2018-11-06)
-
-* Adapt to changes in acorn 6.0.3
-
-## 0.1.0 (2018-09-14)
-
-Initial release
diff --git a/deps/acorn-plugins/acorn-static-class-features/LICENSE b/deps/acorn-plugins/acorn-static-class-features/LICENSE
deleted file mode 100644
index 7c2b27a19c033cbdfa39082bf03715fa874a646e..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-static-class-features/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (C) 2017-2018 by Adrian Heine
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/deps/acorn-plugins/acorn-static-class-features/README.md b/deps/acorn-plugins/acorn-static-class-features/README.md
deleted file mode 100644
index bb214fce164a1a0c3d9eb8d38998b82a5b6ec81d..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-static-class-features/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Static class features support for Acorn
-
-[![NPM version](https://img.shields.io/npm/v/acorn-class-fields.svg)](https://www.npmjs.org/package/acorn-static-class-features)
-
-This is a plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
-
-It implements support for static class features as defined in the stage 3 proposal [Static class features](https://github.com/tc39/proposal-static-class-features). The emitted AST follows [an ESTree proposal](https://github.com/estree/estree/pull/180).
-
-## Usage
-
-This module provides a plugin that can be used to extend the Acorn `Parser` class:
-
-```javascript
-const {Parser} = require('acorn');
-const staticClassFeatures = require('acorn-static-class-features');
-Parser.extend(staticClassFeatures).parse('class X { static x = 0 }');
-```
-
-## License
-
-This plugin is released under an [MIT License](./LICENSE).
diff --git a/deps/acorn-plugins/acorn-static-class-features/index.js b/deps/acorn-plugins/acorn-static-class-features/index.js
deleted file mode 100644
index d8954bf3275e0e4ffc03bd483f5a00138c17c2c0..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-static-class-features/index.js
+++ /dev/null
@@ -1,126 +0,0 @@
-"use strict"
-
-const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g
-
-const acorn = require('internal/deps/acorn/acorn/dist/acorn')
-const tt = acorn.tokTypes
-
-function maybeParseFieldValue(field) {
-  if (this.eat(tt.eq)) {
-    const oldInFieldValue = this._inStaticFieldValue
-    this._inStaticFieldValue = true
-    field.value = this.parseExpression()
-    this._inStaticFieldValue = oldInFieldValue
-  } else field.value = null
-}
-
-const privateClassElements = require("internal/deps/acorn-plugins/acorn-private-class-elements/index")
-
-module.exports = function(Parser) {
-  const ExtendedParser = privateClassElements(Parser)
-
-  return class extends ExtendedParser {
-    // Parse private fields
-    parseClassElement(_constructorAllowsSuper) {
-      if (this.eat(tt.semi)) return null
-
-      const node = this.startNode()
-
-      const tryContextual = (k, noLineBreak) => {
-        if (typeof noLineBreak == "undefined") noLineBreak = false
-        const start = this.start, startLoc = this.startLoc
-        if (!this.eatContextual(k)) return false
-        if (this.type !== tt.parenL && (!noLineBreak || !this.canInsertSemicolon())) return true
-        if (node.key) this.unexpected()
-        node.computed = false
-        node.key = this.startNodeAt(start, startLoc)
-        node.key.name = k
-        this.finishNode(node.key, "Identifier")
-        return false
-      }
-
-      node.static = tryContextual("static")
-      if (!node.static) return super.parseClassElement.apply(this, arguments)
-
-      let isGenerator = this.eat(tt.star)
-      let isAsync = false
-      if (!isGenerator) {
-        // Special-case for `async`, since `parseClassMember` currently looks
-        // for `(` to determine whether `async` is a method name
-        if (this.options.ecmaVersion >= 8 && this.isContextual("async")) {
-          skipWhiteSpace.lastIndex = this.pos
-          let skip = skipWhiteSpace.exec(this.input)
-          let next = this.input.charAt(this.pos + skip[0].length)
-          if (next === ";" || next === "=") {
-            node.key = this.parseIdent(true)
-            node.computed = false
-            maybeParseFieldValue.call(this, node)
-            this.finishNode(node, "FieldDefinition")
-            this.semicolon()
-            return node
-          } else if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
-            isAsync = true
-            isGenerator = this.options.ecmaVersion >= 9 && this.eat(tt.star)
-          }
-        } else if (tryContextual("get")) {
-          node.kind = "get"
-        } else if (tryContextual("set")) {
-          node.kind = "set"
-        }
-      }
-      if (this.type === this.privateNameToken) {
-        this.parsePrivateClassElementName(node)
-        if (this.type !== tt.parenL) {
-          if (node.key.name === "prototype") {
-            this.raise(node.key.start, "Classes may not have a private static property named prototype")
-          }
-          maybeParseFieldValue.call(this, node)
-          this.finishNode(node, "FieldDefinition")
-          this.semicolon()
-          return node
-        }
-      } else if (!node.key) {
-        this.parsePropertyName(node)
-        if ((node.key.name || node.key.value) === "prototype" && !node.computed) {
-          this.raise(node.key.start, "Classes may not have a static property named prototype")
-        }
-      }
-      if (!node.kind) node.kind = "method"
-      this.parseClassMethod(node, isGenerator, isAsync)
-      if (!node.kind && (node.key.name || node.key.value) === "constructor" && !node.computed) {
-        this.raise(node.key.start, "Classes may not have a static field named constructor")
-      }
-      if (node.kind === "get" && node.value.params.length !== 0) {
-        this.raiseRecoverable(node.value.start, "getter should have no params")
-      }
-      if (node.kind === "set" && node.value.params.length !== 1) {
-        this.raiseRecoverable(node.value.start, "setter should have exactly one param")
-      }
-      if (node.kind === "set" && node.value.params[0].type === "RestElement") {
-        this.raiseRecoverable(node.value.params[0].start, "Setter cannot use rest params")
-      }
-
-      return node
-
-    }
-
-    // Parse public static fields
-    parseClassMethod(method, isGenerator, isAsync, _allowsDirectSuper) {
-      if (isGenerator || isAsync || method.kind != "method" || !method.static || this.options.ecmaVersion < 8 || this.type == tt.parenL) {
-        return super.parseClassMethod.apply(this, arguments)
-      }
-      maybeParseFieldValue.call(this, method)
-      delete method.kind
-      method = this.finishNode(method, "FieldDefinition")
-      this.semicolon()
-      return method
-    }
-
-    // Prohibit arguments in class field initializers
-    parseIdent(liberal, isBinding) {
-      const ident = super.parseIdent(liberal, isBinding)
-      if (this._inStaticFieldValue && ident.name == "arguments") this.raise(ident.start, "A static class field initializer may not contain arguments")
-      return ident
-    }
-  }
-}
diff --git a/deps/acorn-plugins/acorn-static-class-features/package.json b/deps/acorn-plugins/acorn-static-class-features/package.json
deleted file mode 100644
index 066223d9965df563649f6b55ec3e0623d1d45e82..0000000000000000000000000000000000000000
--- a/deps/acorn-plugins/acorn-static-class-features/package.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
-  "name": "acorn-static-class-features",
-  "description": "Support for static class features in acorn",
-  "homepage": "https://github.com/acornjs/acorn-static-class-features",
-  "contributors": [
-    "Adrian Heine <mail@adrianheine.de>"
-  ],
-  "engines": {
-    "node": ">=4.8.2"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/acornjs/acorn-static-class-features"
-  },
-  "license": "MIT",
-  "scripts": {
-    "test": "mocha",
-    "test:test262": "node run_test262.js",
-    "lint": "eslint -c .eslintrc.json ."
-  },
-  "peerDependencies": {
-    "acorn": "^6.1.0"
-  },
-  "version": "0.2.0",
-  "devDependencies": {
-    "acorn": "^6.1.0",
-    "eslint": "^5.13.0",
-    "eslint-plugin-node": "^8.0.1",
-    "mocha": "^5.2.0",
-    "test262": "git+https://github.com/tc39/test262.git#33a306d1026b72227eb50a918db19ada16f12b3d",
-    "test262-parser-runner": "^0.5.0"
-  },
-  "dependencies": {
-    "acorn-private-class-elements": "^0.1.1"
-  }
-}
\ No newline at end of file
diff --git a/deps/acorn/acorn-walk/CHANGELOG.md b/deps/acorn/acorn-walk/CHANGELOG.md
index 89114970bbeae47f7ec3c6e7e0380ad9afb2b1b5..a9382d0db9abefa141b9fbc534ea3d817a6df797 100644
--- a/deps/acorn/acorn-walk/CHANGELOG.md
+++ b/deps/acorn/acorn-walk/CHANGELOG.md
@@ -1,3 +1,37 @@
+## 8.1.0 (2021-04-24)
+
+### New features
+
+Support node types for class fields and private methods.
+
+## 8.0.2 (2021-01-25)
+
+### Bug fixes
+
+Adjust package.json to work with Node 12.16.0 and 13.0-13.6.
+
+## 8.0.0 (2021-01-05)
+
+### Bug fixes
+
+Fix a bug where `full` and `fullAncestor` would skip nodes with overridden types.
+
+## 8.0.0 (2020-08-12)
+
+### New features
+
+The package can now be loaded directly as an ECMAScript module in node 13+.
+
+## 7.2.0 (2020-06-17)
+
+### New features
+
+Support optional chaining and nullish coalescing.
+
+Support `import.meta`.
+
+Add support for `export * as ns from "source"`.
+
 ## 7.1.1 (2020-02-13)
 
 ### Bug fixes
diff --git a/deps/acorn/acorn-walk/LICENSE b/deps/acorn/acorn-walk/LICENSE
index 2c0632b6a7c63bd701c60f1daa8b8fa9bea56a81..d6be6db2cfff576dd96f97180707581bfb6b726c 100644
--- a/deps/acorn/acorn-walk/LICENSE
+++ b/deps/acorn/acorn-walk/LICENSE
@@ -1,4 +1,6 @@
-Copyright (C) 2012-2018 by various contributors (see AUTHORS)
+MIT License
+
+Copyright (C) 2012-2020 by various contributors (see AUTHORS)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/deps/acorn/acorn-walk/dist/walk.d.ts b/deps/acorn/acorn-walk/dist/walk.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..00cc005f1245c5d445a518a50838445652e550a1
--- /dev/null
+++ b/deps/acorn/acorn-walk/dist/walk.d.ts
@@ -0,0 +1,112 @@
+import {Node} from 'acorn';
+
+declare module "acorn-walk" {
+  type FullWalkerCallback<TState> = (
+    node: Node,
+    state: TState,
+    type: string
+  ) => void;
+
+  type FullAncestorWalkerCallback<TState> = (
+    node: Node,
+    state: TState | Node[],
+    ancestors: Node[],
+    type: string
+  ) => void;
+  type WalkerCallback<TState> = (node: Node, state: TState) => void;
+
+  type SimpleWalkerFn<TState> = (
+    node: Node,
+    state: TState
+  ) => void;
+  
+  type AncestorWalkerFn<TState> = (
+    node: Node,
+    state: TState| Node[],
+    ancestors: Node[]
+  ) => void;
+
+  type RecursiveWalkerFn<TState> = (
+    node: Node,
+    state: TState,
+    callback: WalkerCallback<TState>
+  ) => void;
+  
+  type SimpleVisitors<TState> = {
+    [type: string]: SimpleWalkerFn<TState>
+  };
+
+  type AncestorVisitors<TState> = {
+    [type: string]: AncestorWalkerFn<TState>
+  };
+  
+  type RecursiveVisitors<TState> = {
+    [type: string]: RecursiveWalkerFn<TState>
+  };
+
+  type FindPredicate = (type: string, node: Node) => boolean;
+
+  interface Found<TState> {
+    node: Node,
+    state: TState
+  }
+
+  export function simple<TState>(
+    node: Node,
+    visitors: SimpleVisitors<TState>,
+    base?: RecursiveVisitors<TState>,
+    state?: TState
+  ): void;
+
+  export function ancestor<TState>(
+    node: Node,
+    visitors: AncestorVisitors<TState>,
+    base?: RecursiveVisitors<TState>,
+    state?: TState
+  ): void;
+
+  export function recursive<TState>(
+    node: Node,
+    state: TState,
+    functions: RecursiveVisitors<TState>,
+    base?: RecursiveVisitors<TState>
+  ): void;
+
+  export function full<TState>(
+    node: Node,
+    callback: FullWalkerCallback<TState>,
+    base?: RecursiveVisitors<TState>,
+    state?: TState
+  ): void;
+
+  export function fullAncestor<TState>(
+    node: Node,
+    callback: FullAncestorWalkerCallback<TState>,
+    base?: RecursiveVisitors<TState>,
+    state?: TState
+  ): void;
+
+  export function make<TState>(
+    functions: RecursiveVisitors<TState>,
+    base?: RecursiveVisitors<TState>
+  ): RecursiveVisitors<TState>;
+
+  export function findNodeAt<TState>(
+    node: Node,
+    start: number | undefined,
+    end?: number | undefined,
+    type?: FindPredicate | string,
+    base?: RecursiveVisitors<TState>,
+    state?: TState
+  ): Found<TState> | undefined;
+
+  export function findNodeAround<TState>(
+    node: Node,
+    start: number | undefined,
+    type?: FindPredicate | string,
+    base?: RecursiveVisitors<TState>,
+    state?: TState
+  ): Found<TState> | undefined;
+
+  export const findNodeAfter: typeof findNodeAround;
+}
diff --git a/deps/acorn/acorn-walk/dist/walk.js b/deps/acorn/acorn-walk/dist/walk.js
index 7aaab9ce824f60dd7ac8edc1021b6ace6fd597be..5582c907595e11039c58a1d956592eb6138beba1 100644
--- a/deps/acorn/acorn-walk/dist/walk.js
+++ b/deps/acorn/acorn-walk/dist/walk.js
@@ -2,7 +2,7 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = global || self, factory((global.acorn = global.acorn || {}, global.acorn.walk = {})));
-}(this, function (exports) { 'use strict';
+}(this, (function (exports) { 'use strict';
 
   // AST walker module for Mozilla Parser API compatible trees
 
@@ -72,11 +72,15 @@
 
   // A full walk triggers the callback on each node
   function full(node, callback, baseVisitor, state, override) {
-    if (!baseVisitor) { baseVisitor = base
-    ; }(function c(node, st, override) {
+    if (!baseVisitor) { baseVisitor = base; }
+    var last
+    ;(function c(node, st, override) {
       var type = override || node.type;
       baseVisitor[type](node, st, c);
-      if (!override) { callback(node, st, type); }
+      if (last !== node) {
+        callback(node, st, type);
+        last = node;
+      }
     })(node, state, override);
   }
 
@@ -84,13 +88,16 @@
   // the callback on each node
   function fullAncestor(node, callback, baseVisitor, state) {
     if (!baseVisitor) { baseVisitor = base; }
-    var ancestors = []
+    var ancestors = [], last
     ;(function c(node, st, override) {
       var type = override || node.type;
       var isNew = node !== ancestors[ancestors.length - 1];
       if (isNew) { ancestors.push(node); }
       baseVisitor[type](node, st, c);
-      if (!override) { callback(node, st || ancestors, ancestors, type); }
+      if (last !== node) {
+        callback(node, st || ancestors, ancestors, type);
+        last = node;
+      }
       if (isNew) { ancestors.pop(); }
     })(node, state);
   }
@@ -168,17 +175,10 @@
     return max
   }
 
-  // Fallback to an Object.create polyfill for older environments.
-  var create = Object.create || function(proto) {
-    function Ctor() {}
-    Ctor.prototype = proto;
-    return new Ctor
-  };
-
   // Used to create a custom walker. Will fill in all missing node
   // type properties with the defaults.
   function make(funcs, baseVisitor) {
-    var visitor = create(baseVisitor || base);
+    var visitor = Object.create(baseVisitor || base);
     for (var type in funcs) { visitor[type] = funcs[type]; }
     return visitor
   }
@@ -200,7 +200,7 @@
   };
   base.Statement = skipThrough;
   base.EmptyStatement = ignore;
-  base.ExpressionStatement = base.ParenthesizedExpression =
+  base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression =
     function (node, st, c) { return c(node.expression, st, "Expression"); };
   base.IfStatement = function (node, st, c) {
     c(node.test, st, "Expression");
@@ -405,6 +405,8 @@
     if (node.source) { c(node.source, st, "Expression"); }
   };
   base.ExportAllDeclaration = function (node, st, c) {
+    if (node.exported)
+      { c(node.exported, st); }
     c(node.source, st, "Expression");
   };
   base.ImportDeclaration = function (node, st, c) {
@@ -419,7 +421,7 @@
   base.ImportExpression = function (node, st, c) {
     c(node.source, st, "Expression");
   };
-  base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore;
+  base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore;
 
   base.TaggedTemplateExpression = function (node, st, c) {
     c(node.tag, st, "Expression");
@@ -439,9 +441,9 @@
       c(elt, st);
     }
   };
-  base.MethodDefinition = base.Property = function (node, st, c) {
+  base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) {
     if (node.computed) { c(node.key, st, "Expression"); }
-    c(node.value, st, "Expression");
+    if (node.value) { c(node.value, st, "Expression"); }
   };
 
   exports.ancestor = ancestor;
@@ -458,4 +460,4 @@
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-}));
+})));
diff --git a/deps/acorn/acorn-walk/dist/walk.mjs b/deps/acorn/acorn-walk/dist/walk.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..ea5d4b0bc2041ff30c6857af088ec247ebdcd58d
--- /dev/null
+++ b/deps/acorn/acorn-walk/dist/walk.mjs
@@ -0,0 +1,443 @@
+// AST walker module for Mozilla Parser API compatible trees
+
+// A simple walk is one where you simply specify callbacks to be
+// called on specific nodes. The last two arguments are optional. A
+// simple use would be
+//
+//     walk.simple(myTree, {
+//         Expression: function(node) { ... }
+//     });
+//
+// to do something with all expressions. All Parser API node types
+// can be used to identify node types, as well as Expression and
+// Statement, which denote categories of nodes.
+//
+// The base argument can be used to pass a custom (recursive)
+// walker, and state can be used to give this walked an initial
+// state.
+
+function simple(node, visitors, baseVisitor, state, override) {
+  if (!baseVisitor) { baseVisitor = base
+  ; }(function c(node, st, override) {
+    var type = override || node.type, found = visitors[type];
+    baseVisitor[type](node, st, c);
+    if (found) { found(node, st); }
+  })(node, state, override);
+}
+
+// An ancestor walk keeps an array of ancestor nodes (including the
+// current node) and passes them to the callback as third parameter
+// (and also as state parameter when no other state is present).
+function ancestor(node, visitors, baseVisitor, state, override) {
+  var ancestors = [];
+  if (!baseVisitor) { baseVisitor = base
+  ; }(function c(node, st, override) {
+    var type = override || node.type, found = visitors[type];
+    var isNew = node !== ancestors[ancestors.length - 1];
+    if (isNew) { ancestors.push(node); }
+    baseVisitor[type](node, st, c);
+    if (found) { found(node, st || ancestors, ancestors); }
+    if (isNew) { ancestors.pop(); }
+  })(node, state, override);
+}
+
+// A recursive walk is one where your functions override the default
+// walkers. They can modify and replace the state parameter that's
+// threaded through the walk, and can opt how and whether to walk
+// their child nodes (by calling their third argument on these
+// nodes).
+function recursive(node, state, funcs, baseVisitor, override) {
+  var visitor = funcs ? make(funcs, baseVisitor || undefined) : baseVisitor
+  ;(function c(node, st, override) {
+    visitor[override || node.type](node, st, c);
+  })(node, state, override);
+}
+
+function makeTest(test) {
+  if (typeof test === "string")
+    { return function (type) { return type === test; } }
+  else if (!test)
+    { return function () { return true; } }
+  else
+    { return test }
+}
+
+var Found = function Found(node, state) { this.node = node; this.state = state; };
+
+// A full walk triggers the callback on each node
+function full(node, callback, baseVisitor, state, override) {
+  if (!baseVisitor) { baseVisitor = base; }
+  var last
+  ;(function c(node, st, override) {
+    var type = override || node.type;
+    baseVisitor[type](node, st, c);
+    if (last !== node) {
+      callback(node, st, type);
+      last = node;
+    }
+  })(node, state, override);
+}
+
+// An fullAncestor walk is like an ancestor walk, but triggers
+// the callback on each node
+function fullAncestor(node, callback, baseVisitor, state) {
+  if (!baseVisitor) { baseVisitor = base; }
+  var ancestors = [], last
+  ;(function c(node, st, override) {
+    var type = override || node.type;
+    var isNew = node !== ancestors[ancestors.length - 1];
+    if (isNew) { ancestors.push(node); }
+    baseVisitor[type](node, st, c);
+    if (last !== node) {
+      callback(node, st || ancestors, ancestors, type);
+      last = node;
+    }
+    if (isNew) { ancestors.pop(); }
+  })(node, state);
+}
+
+// Find a node with a given start, end, and type (all are optional,
+// null can be used as wildcard). Returns a {node, state} object, or
+// undefined when it doesn't find a matching node.
+function findNodeAt(node, start, end, test, baseVisitor, state) {
+  if (!baseVisitor) { baseVisitor = base; }
+  test = makeTest(test);
+  try {
+    (function c(node, st, override) {
+      var type = override || node.type;
+      if ((start == null || node.start <= start) &&
+          (end == null || node.end >= end))
+        { baseVisitor[type](node, st, c); }
+      if ((start == null || node.start === start) &&
+          (end == null || node.end === end) &&
+          test(type, node))
+        { throw new Found(node, st) }
+    })(node, state);
+  } catch (e) {
+    if (e instanceof Found) { return e }
+    throw e
+  }
+}
+
+// Find the innermost node of a given type that contains the given
+// position. Interface similar to findNodeAt.
+function findNodeAround(node, pos, test, baseVisitor, state) {
+  test = makeTest(test);
+  if (!baseVisitor) { baseVisitor = base; }
+  try {
+    (function c(node, st, override) {
+      var type = override || node.type;
+      if (node.start > pos || node.end < pos) { return }
+      baseVisitor[type](node, st, c);
+      if (test(type, node)) { throw new Found(node, st) }
+    })(node, state);
+  } catch (e) {
+    if (e instanceof Found) { return e }
+    throw e
+  }
+}
+
+// Find the outermost matching node after a given position.
+function findNodeAfter(node, pos, test, baseVisitor, state) {
+  test = makeTest(test);
+  if (!baseVisitor) { baseVisitor = base; }
+  try {
+    (function c(node, st, override) {
+      if (node.end < pos) { return }
+      var type = override || node.type;
+      if (node.start >= pos && test(type, node)) { throw new Found(node, st) }
+      baseVisitor[type](node, st, c);
+    })(node, state);
+  } catch (e) {
+    if (e instanceof Found) { return e }
+    throw e
+  }
+}
+
+// Find the outermost matching node before a given position.
+function findNodeBefore(node, pos, test, baseVisitor, state) {
+  test = makeTest(test);
+  if (!baseVisitor) { baseVisitor = base; }
+  var max
+  ;(function c(node, st, override) {
+    if (node.start > pos) { return }
+    var type = override || node.type;
+    if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))
+      { max = new Found(node, st); }
+    baseVisitor[type](node, st, c);
+  })(node, state);
+  return max
+}
+
+// Used to create a custom walker. Will fill in all missing node
+// type properties with the defaults.
+function make(funcs, baseVisitor) {
+  var visitor = Object.create(baseVisitor || base);
+  for (var type in funcs) { visitor[type] = funcs[type]; }
+  return visitor
+}
+
+function skipThrough(node, st, c) { c(node, st); }
+function ignore(_node, _st, _c) {}
+
+// Node walkers.
+
+var base = {};
+
+base.Program = base.BlockStatement = function (node, st, c) {
+  for (var i = 0, list = node.body; i < list.length; i += 1)
+    {
+    var stmt = list[i];
+
+    c(stmt, st, "Statement");
+  }
+};
+base.Statement = skipThrough;
+base.EmptyStatement = ignore;
+base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression =
+  function (node, st, c) { return c(node.expression, st, "Expression"); };
+base.IfStatement = function (node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.consequent, st, "Statement");
+  if (node.alternate) { c(node.alternate, st, "Statement"); }
+};
+base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); };
+base.BreakStatement = base.ContinueStatement = ignore;
+base.WithStatement = function (node, st, c) {
+  c(node.object, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.SwitchStatement = function (node, st, c) {
+  c(node.discriminant, st, "Expression");
+  for (var i$1 = 0, list$1 = node.cases; i$1 < list$1.length; i$1 += 1) {
+    var cs = list$1[i$1];
+
+    if (cs.test) { c(cs.test, st, "Expression"); }
+    for (var i = 0, list = cs.consequent; i < list.length; i += 1)
+      {
+      var cons = list[i];
+
+      c(cons, st, "Statement");
+    }
+  }
+};
+base.SwitchCase = function (node, st, c) {
+  if (node.test) { c(node.test, st, "Expression"); }
+  for (var i = 0, list = node.consequent; i < list.length; i += 1)
+    {
+    var cons = list[i];
+
+    c(cons, st, "Statement");
+  }
+};
+base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {
+  if (node.argument) { c(node.argument, st, "Expression"); }
+};
+base.ThrowStatement = base.SpreadElement =
+  function (node, st, c) { return c(node.argument, st, "Expression"); };
+base.TryStatement = function (node, st, c) {
+  c(node.block, st, "Statement");
+  if (node.handler) { c(node.handler, st); }
+  if (node.finalizer) { c(node.finalizer, st, "Statement"); }
+};
+base.CatchClause = function (node, st, c) {
+  if (node.param) { c(node.param, st, "Pattern"); }
+  c(node.body, st, "Statement");
+};
+base.WhileStatement = base.DoWhileStatement = function (node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.ForStatement = function (node, st, c) {
+  if (node.init) { c(node.init, st, "ForInit"); }
+  if (node.test) { c(node.test, st, "Expression"); }
+  if (node.update) { c(node.update, st, "Expression"); }
+  c(node.body, st, "Statement");
+};
+base.ForInStatement = base.ForOfStatement = function (node, st, c) {
+  c(node.left, st, "ForInit");
+  c(node.right, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.ForInit = function (node, st, c) {
+  if (node.type === "VariableDeclaration") { c(node, st); }
+  else { c(node, st, "Expression"); }
+};
+base.DebuggerStatement = ignore;
+
+base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); };
+base.VariableDeclaration = function (node, st, c) {
+  for (var i = 0, list = node.declarations; i < list.length; i += 1)
+    {
+    var decl = list[i];
+
+    c(decl, st);
+  }
+};
+base.VariableDeclarator = function (node, st, c) {
+  c(node.id, st, "Pattern");
+  if (node.init) { c(node.init, st, "Expression"); }
+};
+
+base.Function = function (node, st, c) {
+  if (node.id) { c(node.id, st, "Pattern"); }
+  for (var i = 0, list = node.params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    c(param, st, "Pattern");
+  }
+  c(node.body, st, node.expression ? "Expression" : "Statement");
+};
+
+base.Pattern = function (node, st, c) {
+  if (node.type === "Identifier")
+    { c(node, st, "VariablePattern"); }
+  else if (node.type === "MemberExpression")
+    { c(node, st, "MemberPattern"); }
+  else
+    { c(node, st); }
+};
+base.VariablePattern = ignore;
+base.MemberPattern = skipThrough;
+base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); };
+base.ArrayPattern = function (node, st, c) {
+  for (var i = 0, list = node.elements; i < list.length; i += 1) {
+    var elt = list[i];
+
+    if (elt) { c(elt, st, "Pattern"); }
+  }
+};
+base.ObjectPattern = function (node, st, c) {
+  for (var i = 0, list = node.properties; i < list.length; i += 1) {
+    var prop = list[i];
+
+    if (prop.type === "Property") {
+      if (prop.computed) { c(prop.key, st, "Expression"); }
+      c(prop.value, st, "Pattern");
+    } else if (prop.type === "RestElement") {
+      c(prop.argument, st, "Pattern");
+    }
+  }
+};
+
+base.Expression = skipThrough;
+base.ThisExpression = base.Super = base.MetaProperty = ignore;
+base.ArrayExpression = function (node, st, c) {
+  for (var i = 0, list = node.elements; i < list.length; i += 1) {
+    var elt = list[i];
+
+    if (elt) { c(elt, st, "Expression"); }
+  }
+};
+base.ObjectExpression = function (node, st, c) {
+  for (var i = 0, list = node.properties; i < list.length; i += 1)
+    {
+    var prop = list[i];
+
+    c(prop, st);
+  }
+};
+base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;
+base.SequenceExpression = function (node, st, c) {
+  for (var i = 0, list = node.expressions; i < list.length; i += 1)
+    {
+    var expr = list[i];
+
+    c(expr, st, "Expression");
+  }
+};
+base.TemplateLiteral = function (node, st, c) {
+  for (var i = 0, list = node.quasis; i < list.length; i += 1)
+    {
+    var quasi = list[i];
+
+    c(quasi, st);
+  }
+
+  for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1)
+    {
+    var expr = list$1[i$1];
+
+    c(expr, st, "Expression");
+  }
+};
+base.TemplateElement = ignore;
+base.UnaryExpression = base.UpdateExpression = function (node, st, c) {
+  c(node.argument, st, "Expression");
+};
+base.BinaryExpression = base.LogicalExpression = function (node, st, c) {
+  c(node.left, st, "Expression");
+  c(node.right, st, "Expression");
+};
+base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {
+  c(node.left, st, "Pattern");
+  c(node.right, st, "Expression");
+};
+base.ConditionalExpression = function (node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.consequent, st, "Expression");
+  c(node.alternate, st, "Expression");
+};
+base.NewExpression = base.CallExpression = function (node, st, c) {
+  c(node.callee, st, "Expression");
+  if (node.arguments)
+    { for (var i = 0, list = node.arguments; i < list.length; i += 1)
+      {
+        var arg = list[i];
+
+        c(arg, st, "Expression");
+      } }
+};
+base.MemberExpression = function (node, st, c) {
+  c(node.object, st, "Expression");
+  if (node.computed) { c(node.property, st, "Expression"); }
+};
+base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {
+  if (node.declaration)
+    { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); }
+  if (node.source) { c(node.source, st, "Expression"); }
+};
+base.ExportAllDeclaration = function (node, st, c) {
+  if (node.exported)
+    { c(node.exported, st); }
+  c(node.source, st, "Expression");
+};
+base.ImportDeclaration = function (node, st, c) {
+  for (var i = 0, list = node.specifiers; i < list.length; i += 1)
+    {
+    var spec = list[i];
+
+    c(spec, st);
+  }
+  c(node.source, st, "Expression");
+};
+base.ImportExpression = function (node, st, c) {
+  c(node.source, st, "Expression");
+};
+base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore;
+
+base.TaggedTemplateExpression = function (node, st, c) {
+  c(node.tag, st, "Expression");
+  c(node.quasi, st, "Expression");
+};
+base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); };
+base.Class = function (node, st, c) {
+  if (node.id) { c(node.id, st, "Pattern"); }
+  if (node.superClass) { c(node.superClass, st, "Expression"); }
+  c(node.body, st);
+};
+base.ClassBody = function (node, st, c) {
+  for (var i = 0, list = node.body; i < list.length; i += 1)
+    {
+    var elt = list[i];
+
+    c(elt, st);
+  }
+};
+base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) {
+  if (node.computed) { c(node.key, st, "Expression"); }
+  if (node.value) { c(node.value, st, "Expression"); }
+};
+
+export { ancestor, base, findNodeAfter, findNodeAround, findNodeAt, findNodeBefore, full, fullAncestor, make, recursive, simple };
diff --git a/deps/acorn/acorn-walk/package.json b/deps/acorn/acorn-walk/package.json
index a66ca892ced57738a724b93d3d2f96978925dc8b..118bb0be2c72f51dbdf6fe8e3374eb80b83b64a6 100644
--- a/deps/acorn/acorn-walk/package.json
+++ b/deps/acorn/acorn-walk/package.json
@@ -5,7 +5,18 @@
   "main": "dist/walk.js",
   "types": "dist/walk.d.ts",
   "module": "dist/walk.mjs",
-  "version": "7.1.1",
+  "exports": {
+    ".": [
+      {
+        "import": "./dist/walk.mjs",
+        "require": "./dist/walk.js",
+        "default": "./dist/walk.js"
+      },
+      "./dist/walk.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "version": "8.1.0",
   "engines": {"node": ">=0.4.0"},
   "maintainers": [
     {
diff --git a/deps/acorn/acorn/CHANGELOG.md b/deps/acorn/acorn/CHANGELOG.md
index 32f5ce8f3bb4bf66d564c04847377edc14b3705a..d69ad88125311826f7f62ead731debfd51ebe610 100644
--- a/deps/acorn/acorn/CHANGELOG.md
+++ b/deps/acorn/acorn/CHANGELOG.md
@@ -1,3 +1,173 @@
+## 8.4.1 (2021-06-24)
+
+### Bug fixes
+
+Fix a bug where `allowAwaitOutsideFunction` would allow `await` in class field initializers, and setting `ecmaVersion` to 13 or higher would allow top-level await in non-module sources.
+
+## 8.4.0 (2021-06-11)
+
+### New features
+
+A new option, `allowSuperOutsideMethod`, can be used to suppress the error when `super` is used in the wrong context.
+
+## 8.3.0 (2021-05-31)
+
+### New features
+
+Default `allowAwaitOutsideFunction` to true for ECMAScript 2022 an higher.
+
+Add support for the `p` ([indices](https://github.com/tc39/proposal-regexp-match-indices)) regexp flag.
+
+## 8.2.4 (2021-05-04)
+
+### Bug fixes
+
+Fix spec conformity in corner case 'for await (async of ...)'.
+
+## 8.2.3 (2021-05-04)
+
+### Bug fixes
+
+Fix an issue where the library couldn't parse 'for (async of ...)'.
+
+Fix a bug in UTF-16 decoding that would read characters incorrectly in some circumstances.
+
+## 8.2.2 (2021-04-29)
+
+### Bug fixes
+
+Fix a bug where a class field initialized to an async arrow function wouldn't allow await inside it. Same issue existed for generator arrow functions with yield.
+
+## 8.2.1 (2021-04-24)
+
+### Bug fixes
+
+Fix a regression introduced in 8.2.0 where static or async class methods with keyword names fail to parse.
+
+## 8.2.0 (2021-04-24)
+
+### New features
+
+Add support for ES2022 class fields and private methods.
+
+## 8.1.1 (2021-04-12)
+
+### Various
+
+Stop shipping source maps in the NPM package.
+
+## 8.1.0 (2021-03-09)
+
+### Bug fixes
+
+Fix a spurious error in nested destructuring arrays.
+
+### New features
+
+Expose `allowAwaitOutsideFunction` in CLI interface.
+
+Make `allowImportExportAnywhere` also apply to `import.meta`.
+
+## 8.0.5 (2021-01-25)
+
+### Bug fixes
+
+Adjust package.json to work with Node 12.16.0 and 13.0-13.6.
+
+## 8.0.4 (2020-10-05)
+
+### Bug fixes
+
+Make `await x ** y` an error, following the spec.
+
+Fix potentially exponential regular expression.
+
+## 8.0.3 (2020-10-02)
+
+### Bug fixes
+
+Fix a wasteful loop during `Parser` creation when setting `ecmaVersion` to `"latest"`.
+
+## 8.0.2 (2020-09-30)
+
+### Bug fixes
+
+Make the TypeScript types reflect the current allowed values for `ecmaVersion`.
+
+Fix another regexp/division tokenizer issue.
+
+## 8.0.1 (2020-08-12)
+
+### Bug fixes
+
+Provide the correct value in the `version` export.
+
+## 8.0.0 (2020-08-12)
+
+### Bug fixes
+
+Disallow expressions like `(a = b) = c`.
+
+Make non-octal escape sequences a syntax error in strict mode.
+
+### New features
+
+The package can now be loaded directly as an ECMAScript module in node 13+.
+
+Update to the set of Unicode properties from ES2021.
+
+### Breaking changes
+
+The `ecmaVersion` option is now required. For the moment, omitting it will still work with a warning, but that will change in a future release.
+
+Some changes to method signatures that may be used by plugins.
+
+## 7.4.0 (2020-08-03)
+
+### New features
+
+Add support for logical assignment operators.
+
+Add support for numeric separators.
+
+## 7.3.1 (2020-06-11)
+
+### Bug fixes
+
+Make the string in the `version` export match the actual library version.
+
+## 7.3.0 (2020-06-11)
+
+### Bug fixes
+
+Fix a bug that caused parsing of object patterns with a property named `set` that had a default value to fail.
+
+### New features
+
+Add support for optional chaining (`?.`).
+
+## 7.2.0 (2020-05-09)
+
+### Bug fixes
+
+Fix precedence issue in parsing of async arrow functions.
+
+### New features
+
+Add support for nullish coalescing.
+
+Add support for `import.meta`.
+
+Support `export * as ...` syntax.
+
+Upgrade to Unicode 13.
+
+## 6.4.1 (2020-03-09)
+
+### Bug fixes
+
+More carefully check for valid UTF16 surrogate pairs in regexp validator.
+
 ## 7.1.1 (2020-03-01)
 
 ### Bug fixes
diff --git a/deps/acorn/acorn/LICENSE b/deps/acorn/acorn/LICENSE
index 2c0632b6a7c63bd701c60f1daa8b8fa9bea56a81..d6be6db2cfff576dd96f97180707581bfb6b726c 100644
--- a/deps/acorn/acorn/LICENSE
+++ b/deps/acorn/acorn/LICENSE
@@ -1,4 +1,6 @@
-Copyright (C) 2012-2018 by various contributors (see AUTHORS)
+MIT License
+
+Copyright (C) 2012-2020 by various contributors (see AUTHORS)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/deps/acorn/acorn/README.md b/deps/acorn/acorn/README.md
index 585f2736fc05b5e36766149c089b922c449d9998..f27a99444b6f3f02a6b83ec98af012be68242d38 100644
--- a/deps/acorn/acorn/README.md
+++ b/deps/acorn/acorn/README.md
@@ -32,14 +32,14 @@ npm install
 ## Interface
 
 **parse**`(input, options)` is the main interface to the library. The
-`input` parameter is a string, `options` can be undefined or an object
-setting some of the options listed below. The return value will be an
-abstract syntax tree object as specified by the [ESTree
+`input` parameter is a string, `options` must be an object setting
+some of the options listed below. The return value will be an abstract
+syntax tree object as specified by the [ESTree
 spec](https://github.com/estree/estree).
 
 ```javascript
 let acorn = require("acorn");
-console.log(acorn.parse("1 + 1"));
+console.log(acorn.parse("1 + 1", {ecmaVersion: 2020}));
 ```
 
 When encountering a syntax error, the parser will raise a
@@ -48,18 +48,20 @@ have a `pos` property that indicates the string offset at which the
 error occurred, and a `loc` object that contains a `{line, column}`
 object referring to that same position.
 
-Options can be provided by passing a second argument, which should be
-an object containing any of these fields:
+Options are provided by in a second argument, which should be an
+object containing any of these fields (only `ecmaVersion` is
+required):
 
 - **ecmaVersion**: Indicates the ECMAScript version to parse. Must be
-  either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), 10 (2019) or 11
-  (2020, partial support). This influences support for strict mode,
-  the set of reserved words, and support for new syntax features.
-  Default is 10.
+  either 3, 5, 6 (or 2015), 7 (2016), 8 (2017), 9 (2018), 10 (2019),
+  11 (2020), 12 (2021, partial support), 13 (2022, partial support)
+  or `"latest"` (the latest the library supports). This influences
+  support for strict mode, the set of reserved words, and support
+  for new syntax features.
 
   **NOTE**: Only 'stage 4' (finalized) ECMAScript features are being
-  implemented by Acorn. Other proposed new features can be implemented
-  through plugins.
+  implemented by Acorn. Other proposed new features must be
+  implemented through plugins.
 
 - **sourceType**: Indicate the mode the code should be parsed in. Can be
   either `"script"` or `"module"`. This influences global strict mode
@@ -89,13 +91,19 @@ an object containing any of these fields:
 
 - **allowImportExportEverywhere**: By default, `import` and `export`
   declarations can only appear at a program's top level. Setting this
-  option to `true` allows them anywhere where a statement is allowed.
-  
-- **allowAwaitOutsideFunction**: By default, `await` expressions can
-  only appear inside `async` functions. Setting this option to
+  option to `true` allows them anywhere where a statement is allowed,
+  and also allows `import.meta` expressions to appear in scripts
+  (when `sourceType` is not `"module"`).
+
+- **allowAwaitOutsideFunction**: If `false`, `await` expressions can
+  only appear inside `async` functions. Defaults to `true` for
+  `ecmaVersion` 2022 and later, `false` for lower versions. Setting this option to
   `true` allows to have top-level `await` expressions. They are
   still not allowed in non-`async` functions, though.
 
+- **allowSuperOutsideMethod**: By default, `super` outside a method
+  raises an error. Set this to `true` to accept such code.
+
 - **allowHashBang**: When this is enabled (off by default), if the
   code starts with the characters `#!` (as in a shellscript), the
   first line will be treated as a comment.
@@ -224,7 +232,7 @@ you can use its static `extend` method.
 var acorn = require("acorn");
 var jsx = require("acorn-jsx");
 var JSXParser = acorn.Parser.extend(jsx());
-JSXParser.parse("foo(<bar/>)");
+JSXParser.parse("foo(<bar/>)", {ecmaVersion: 2020});
 ```
 
 The `extend` method takes any number of plugin values, and returns a
@@ -249,6 +257,9 @@ options:
 - `--allow-hash-bang`: If the code starts with the characters #! (as
   in a shellscript), the first line will be treated as a comment.
 
+- `--allow-await-outside-function`: Allows top-level `await` expressions.
+  See the `allowAwaitOutsideFunction` option for more information.
+
 - `--compact`: No whitespace is used in the AST output.
 
 - `--silent`: Do not output the AST, just return the exit status.
@@ -266,5 +277,4 @@ Plugins for ECMAScript proposals:
  - [`acorn-stage3`](https://github.com/acornjs/acorn-stage3): Parse most stage 3 proposals, bundling:
    - [`acorn-class-fields`](https://github.com/acornjs/acorn-class-fields): Parse [class fields proposal](https://github.com/tc39/proposal-class-fields)
    - [`acorn-import-meta`](https://github.com/acornjs/acorn-import-meta): Parse [import.meta proposal](https://github.com/tc39/proposal-import-meta)
-   - [`acorn-numeric-separator`](https://github.com/acornjs/acorn-numeric-separator): Parse [numeric separator proposal](https://github.com/tc39/proposal-numeric-separator)
    - [`acorn-private-methods`](https://github.com/acornjs/acorn-private-methods): parse [private methods, getters and setters proposal](https://github.com/tc39/proposal-private-methods)n
diff --git a/deps/node-inspect/cli.js b/deps/acorn/acorn/bin/acorn
similarity index 32%
rename from deps/node-inspect/cli.js
rename to deps/acorn/acorn/bin/acorn
index 4856fd706c45c2fbdae2d02e7dd5fd1b3dc5a2df..cf7df46890fdd48bbaa57fb0478c142bc4409f21 100755
--- a/deps/node-inspect/cli.js
+++ b/deps/acorn/acorn/bin/acorn
@@ -1,2 +1,4 @@
 #!/usr/bin/env node
-require('./lib/cli.js');
+'use strict';
+
+require('../dist/bin.js');
diff --git a/deps/acorn/acorn/dist/acorn.d.ts b/deps/acorn/acorn/dist/acorn.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8e8fbbcb426c3cc4db15802f44a231732ccc05be
--- /dev/null
+++ b/deps/acorn/acorn/dist/acorn.d.ts
@@ -0,0 +1,211 @@
+export as namespace acorn
+export = acorn
+
+declare namespace acorn {
+  function parse(input: string, options: Options): Node
+
+  function parseExpressionAt(input: string, pos: number, options: Options): Node
+
+  function tokenizer(input: string, options: Options): {
+    getToken(): Token
+    [Symbol.iterator](): Iterator<Token>
+  }
+
+  interface Options {
+    ecmaVersion: 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 'latest'
+    sourceType?: 'script' | 'module'
+    onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: Position) => void
+    onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: Position) => void
+    allowReserved?: boolean | 'never'
+    allowReturnOutsideFunction?: boolean
+    allowImportExportEverywhere?: boolean
+    allowAwaitOutsideFunction?: boolean
+    allowSuperOutsideMethod?: boolean
+    allowHashBang?: boolean
+    locations?: boolean
+    onToken?: ((token: Token) => any) | Token[]
+    onComment?: ((
+      isBlock: boolean, text: string, start: number, end: number, startLoc?: Position,
+      endLoc?: Position
+    ) => void) | Comment[]
+    ranges?: boolean
+    program?: Node
+    sourceFile?: string
+    directSourceFile?: string
+    preserveParens?: boolean
+  }
+
+  class Parser {
+    constructor(options: Options, input: string, startPos?: number)
+    parse(this: Parser): Node
+    static parse(this: typeof Parser, input: string, options: Options): Node
+    static parseExpressionAt(this: typeof Parser, input: string, pos: number, options: Options): Node
+    static tokenizer(this: typeof Parser, input: string, options: Options): {
+      getToken(): Token
+      [Symbol.iterator](): Iterator<Token>
+    }
+    static extend(this: typeof Parser, ...plugins: ((BaseParser: typeof Parser) => typeof Parser)[]): typeof Parser
+  }
+
+  interface Position { line: number; column: number; offset: number }
+
+  const defaultOptions: Options
+
+  function getLineInfo(input: string, offset: number): Position
+
+  class SourceLocation {
+    start: Position
+    end: Position
+    source?: string | null
+    constructor(p: Parser, start: Position, end: Position)
+  }
+
+  class Node {
+    type: string
+    start: number
+    end: number
+    loc?: SourceLocation
+    sourceFile?: string
+    range?: [number, number]
+    constructor(parser: Parser, pos: number, loc?: SourceLocation)
+  }
+
+  class TokenType {
+    label: string
+    keyword: string
+    beforeExpr: boolean
+    startsExpr: boolean
+    isLoop: boolean
+    isAssign: boolean
+    prefix: boolean
+    postfix: boolean
+    binop: number
+    updateContext?: (prevType: TokenType) => void
+    constructor(label: string, conf?: any)
+  }
+
+  const tokTypes: {
+    num: TokenType
+    regexp: TokenType
+    string: TokenType
+    name: TokenType
+    privateId: TokenType
+    eof: TokenType
+    bracketL: TokenType
+    bracketR: TokenType
+    braceL: TokenType
+    braceR: TokenType
+    parenL: TokenType
+    parenR: TokenType
+    comma: TokenType
+    semi: TokenType
+    colon: TokenType
+    dot: TokenType
+    question: TokenType
+    arrow: TokenType
+    template: TokenType
+    ellipsis: TokenType
+    backQuote: TokenType
+    dollarBraceL: TokenType
+    eq: TokenType
+    assign: TokenType
+    incDec: TokenType
+    prefix: TokenType
+    logicalOR: TokenType
+    logicalAND: TokenType
+    bitwiseOR: TokenType
+    bitwiseXOR: TokenType
+    bitwiseAND: TokenType
+    equality: TokenType
+    relational: TokenType
+    bitShift: TokenType
+    plusMin: TokenType
+    modulo: TokenType
+    star: TokenType
+    slash: TokenType
+    starstar: TokenType
+    _break: TokenType
+    _case: TokenType
+    _catch: TokenType
+    _continue: TokenType
+    _debugger: TokenType
+    _default: TokenType
+    _do: TokenType
+    _else: TokenType
+    _finally: TokenType
+    _for: TokenType
+    _function: TokenType
+    _if: TokenType
+    _return: TokenType
+    _switch: TokenType
+    _throw: TokenType
+    _try: TokenType
+    _var: TokenType
+    _const: TokenType
+    _while: TokenType
+    _with: TokenType
+    _new: TokenType
+    _this: TokenType
+    _super: TokenType
+    _class: TokenType
+    _extends: TokenType
+    _export: TokenType
+    _import: TokenType
+    _null: TokenType
+    _true: TokenType
+    _false: TokenType
+    _in: TokenType
+    _instanceof: TokenType
+    _typeof: TokenType
+    _void: TokenType
+    _delete: TokenType
+  }
+
+  class TokContext {
+    constructor(token: string, isExpr: boolean, preserveSpace: boolean, override?: (p: Parser) => void)
+  }
+
+  const tokContexts: {
+    b_stat: TokContext
+    b_expr: TokContext
+    b_tmpl: TokContext
+    p_stat: TokContext
+    p_expr: TokContext
+    q_tmpl: TokContext
+    f_expr: TokContext
+  }
+
+  function isIdentifierStart(code: number, astral?: boolean): boolean
+
+  function isIdentifierChar(code: number, astral?: boolean): boolean
+
+  interface AbstractToken {
+  }
+
+  interface Comment extends AbstractToken {
+    type: string
+    value: string
+    start: number
+    end: number
+    loc?: SourceLocation
+    range?: [number, number]
+  }
+
+  class Token {
+    type: TokenType
+    value: any
+    start: number
+    end: number
+    loc?: SourceLocation
+    range?: [number, number]
+    constructor(p: Parser)
+  }
+
+  function isNewLine(code: number): boolean
+
+  const lineBreak: RegExp
+
+  const lineBreakG: RegExp
+
+  const version: string
+}
diff --git a/deps/acorn/acorn/dist/acorn.js b/deps/acorn/acorn/dist/acorn.js
index e2b33179c789c729fc27059ff73884e962953114..af24e36cf16d2edc85aa57a07f15ce5dd89d33f3 100644
--- a/deps/acorn/acorn/dist/acorn.js
+++ b/deps/acorn/acorn/dist/acorn.js
@@ -2,7 +2,7 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = global || self, factory(global.acorn = {}));
-}(this, function (exports) { 'use strict';
+}(this, (function (exports) { 'use strict';
 
   // Reserved word lists for various dialects of the language
 
@@ -33,8 +33,8 @@
   // are only applied when a character is found to actually have a
   // code point above 128.
   // Generated by `bin/generate-identifier-regex.js`.
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08c7\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\u9ffc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7ca\ua7f5-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf\u1ac0\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
 
   var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
   var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
@@ -48,10 +48,10 @@
   // generated by bin/generate-identifier-regex.js
 
   // eslint-disable-next-line comma-spacing
-  var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,155,22,13,52,76,44,33,24,27,35,30,0,12,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,0,33,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,230,43,117,63,32,0,161,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,754,9486,286,50,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,2357,44,11,6,17,0,370,43,1301,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,15,7472,3104,541];
+  var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,349,41,7,1,79,28,11,0,9,21,107,20,28,22,13,52,76,44,33,24,27,35,30,0,3,0,9,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,2,31,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,230,43,117,63,32,7,3,0,3,7,2,1,2,23,16,0,2,0,95,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,190,0,80,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,1237,43,8,8952,286,50,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,2357,44,11,6,17,0,370,43,1301,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42717,35,4148,12,221,3,5761,15,7472,3104,541,1507,4938];
 
   // eslint-disable-next-line comma-spacing
-  var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,232,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1014,0,2,54,8,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,419,13,1495,6,110,6,6,9,792487,239];
+  var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,370,1,154,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,2,11,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,71,5,2,1,3,3,2,0,2,1,13,9,120,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1014,0,2,54,8,3,82,0,12,1,19628,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,419,13,1495,6,110,6,6,9,4759,9,787719,239];
 
   // This has a complexity linear to the value of the code. The
   // assumption is that looking up astral identifier characters is
@@ -152,6 +152,7 @@
     regexp: new TokenType("regexp", startsExpr),
     string: new TokenType("string", startsExpr),
     name: new TokenType("name", startsExpr),
+    privateId: new TokenType("privateId", startsExpr),
     eof: new TokenType("eof"),
 
     // Punctuation token types.
@@ -166,6 +167,7 @@
     colon: new TokenType(":", beforeExpr),
     dot: new TokenType("."),
     question: new TokenType("?", beforeExpr),
+    questionDot: new TokenType("?."),
     arrow: new TokenType("=>", beforeExpr),
     template: new TokenType("template"),
     invalidTemplate: new TokenType("invalidTemplate"),
@@ -204,6 +206,7 @@
     star: binop("*", 10),
     slash: binop("/", 10),
     starstar: new TokenType("**", {beforeExpr: true}),
+    coalesce: binop("??", 1),
 
     // Keyword token types.
     _break: kw("break"),
@@ -312,16 +315,17 @@
     }
   }
 
-  // A second optional argument can be given to further configure
-  // the parser process. These options are recognized:
+  // A second argument must be given to configure the parser process.
+  // These options are recognized (only `ecmaVersion` is required):
 
   var defaultOptions = {
     // `ecmaVersion` indicates the ECMAScript version to parse. Must be
-    // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10
-    // (2019). This influences support for strict mode, the set of
-    // reserved words, and support for new syntax features. The default
-    // is 10.
-    ecmaVersion: 10,
+    // either 3, 5, 6 (or 2015), 7 (2016), 8 (2017), 9 (2018), 10
+    // (2019), 11 (2020), 12 (2021), 13 (2022), or `"latest"` (the
+    // latest version the library supports). This influences support
+    // for strict mode, the set of reserved words, and support for
+    // new syntax features.
+    ecmaVersion: null,
     // `sourceType` indicates the mode the code should be parsed in.
     // Can be either `"script"` or `"module"`. This influences global
     // strict mode and parsing of `import` and `export` declarations.
@@ -344,11 +348,16 @@
     // error.
     allowReturnOutsideFunction: false,
     // When enabled, import/export statements are not constrained to
-    // appearing at the top of the program.
+    // appearing at the top of the program, and an import.meta expression
+    // in a script isn't considered an error.
     allowImportExportEverywhere: false,
+    // By default, await identifiers are allowed to appear at the top-level scope only if ecmaVersion >= 2022.
     // When enabled, await identifiers are allowed to appear at the top-level scope,
     // but they are still not allowed in non-async functions.
-    allowAwaitOutsideFunction: false,
+    allowAwaitOutsideFunction: null,
+    // When enabled, super identifiers are not constrained to
+    // appearing in methods and do not raise an error when they appear elsewhere.
+    allowSuperOutsideMethod: null,
     // When enabled, hashbang directive in the beginning of file
     // is allowed and treated as a line comment.
     allowHashBang: false,
@@ -402,14 +411,25 @@
 
   // Interpret and default an options object
 
+  var warnedAboutEcmaVersion = false;
+
   function getOptions(opts) {
     var options = {};
 
     for (var opt in defaultOptions)
       { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }
 
-    if (options.ecmaVersion >= 2015)
-      { options.ecmaVersion -= 2009; }
+    if (options.ecmaVersion === "latest") {
+      options.ecmaVersion = 1e8;
+    } else if (options.ecmaVersion == null) {
+      if (!warnedAboutEcmaVersion && typeof console === "object" && console.warn) {
+        warnedAboutEcmaVersion = true;
+        console.warn("Since Acorn 8.0.0, options.ecmaVersion is required.\nDefaulting to 2020, but this will stop working in the future.");
+      }
+      options.ecmaVersion = 11;
+    } else if (options.ecmaVersion >= 2015) {
+      options.ecmaVersion -= 2009;
+    }
 
     if (options.allowReserved == null)
       { options.allowReserved = options.ecmaVersion < 5; }
@@ -456,7 +476,7 @@
     return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)
   }
 
-  // Used in checkLVal and declareName to determine the type of a binding
+  // Used in checkLVal* and declareName to determine the type of a binding
   var
       BIND_NONE = 0, // Not a binding
       BIND_VAR = 1, // Var-style binding
@@ -471,8 +491,7 @@
     this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
     var reserved = "";
     if (options.allowReserved !== true) {
-      for (var v = options.ecmaVersion;; v--)
-        { if (reserved = reservedWords[v]) { break } }
+      reserved = reservedWords[options.ecmaVersion >= 6 ? 6 : options.ecmaVersion === 5 ? 5 : 3];
       if (options.sourceType === "module") { reserved += " await"; }
     }
     this.reservedWords = wordsRegexp(reserved);
@@ -525,13 +544,14 @@
 
     // Used to signify the start of a potential arrow function
     this.potentialArrowAt = -1;
+    this.potentialArrowInForAwait = false;
 
     // Positions to delayed-check that yield/await does not exist in default parameters.
     this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;
     // Labels in scope.
     this.labels = [];
     // Thus-far undefined exports.
-    this.undefinedExports = {};
+    this.undefinedExports = Object.create(null);
 
     // If enabled, skip leading hashbang line.
     if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
@@ -543,9 +563,14 @@
 
     // For RegExp validation
     this.regexpState = null;
+
+    // The stack of private names.
+    // Each element has two properties: 'declared' and 'used'.
+    // When it exited from the outermost class definition, all used private names must be declared.
+    this.privateNameStack = [];
   };
 
-  var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true } };
+  var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },canAwait: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true },inNonArrowFunction: { configurable: true } };
 
   Parser.prototype.parse = function parse () {
     var node = this.options.program || this.startNode();
@@ -554,14 +579,30 @@
   };
 
   prototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };
-  prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 };
-  prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 };
-  prototypeAccessors.allowSuper.get = function () { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 };
+  prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 && !this.currentVarScope().inClassFieldInit };
+  prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 && !this.currentVarScope().inClassFieldInit };
+  prototypeAccessors.canAwait.get = function () {
+    for (var i = this.scopeStack.length - 1; i >= 0; i--) {
+      var scope = this.scopeStack[i];
+      if (scope.inClassFieldInit) { return false }
+      if (scope.flags & SCOPE_FUNCTION) { return (scope.flags & SCOPE_ASYNC) > 0 }
+    }
+    return (this.inModule && this.options.ecmaVersion >= 13) || this.options.allowAwaitOutsideFunction
+  };
+  prototypeAccessors.allowSuper.get = function () {
+    var ref = this.currentThisScope();
+      var flags = ref.flags;
+      var inClassFieldInit = ref.inClassFieldInit;
+    return (flags & SCOPE_SUPER) > 0 || inClassFieldInit || this.options.allowSuperOutsideMethod
+  };
   prototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };
   prototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };
-
-  // Switch to a getter for 7.0.0.
-  Parser.prototype.inNonArrowFunction = function inNonArrowFunction () { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 };
+  prototypeAccessors.inNonArrowFunction.get = function () {
+    var ref = this.currentThisScope();
+      var flags = ref.flags;
+      var inClassFieldInit = ref.inClassFieldInit;
+    return (flags & SCOPE_FUNCTION) > 0 || inClassFieldInit
+  };
 
   Parser.extend = function extend () {
       var plugins = [], len = arguments.length;
@@ -592,7 +633,7 @@
 
   // ## Parser utilities
 
-  var literal = /^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)")/;
+  var literal = /^(?:'((?:\\.|[^'\\])*?)'|"((?:\\.|[^"\\])*?)")/;
   pp.strictDirective = function(start) {
     for (;;) {
       // Try to find string literal.
@@ -600,7 +641,14 @@
       start += skipWhiteSpace.exec(this.input)[0].length;
       var match = literal.exec(this.input.slice(start));
       if (!match) { return false }
-      if ((match[1] || match[2]) === "use strict") { return true }
+      if ((match[1] || match[2]) === "use strict") {
+        skipWhiteSpace.lastIndex = start + match[0].length;
+        var spaceAfter = skipWhiteSpace.exec(this.input), end = spaceAfter.index + spaceAfter[0].length;
+        var next = this.input.charAt(end);
+        return next === ";" || next === "}" ||
+          (lineBreak.test(spaceAfter[0]) &&
+           !(/[(`.[+\-/*%<>=,?^&]/.test(next) || next === "!" && this.input.charAt(end + 1) === "="))
+      }
       start += match[0].length;
 
       // Skip semicolon, if any.
@@ -740,7 +788,7 @@
   // to its body instead of creating a new node.
 
   pp$1.parseTopLevel = function(node) {
-    var exports = {};
+    var exports = Object.create(null);
     if (!node.body) { node.body = []; }
     while (this.type !== types.eof) {
       var stmt = this.parseStatement(null, true, exports);
@@ -770,13 +818,14 @@
     // Statement) is allowed here. If context is not empty then only a Statement
     // is allowed. However, `let [` is an explicit negative lookahead for
     // ExpressionStatement, so special-case it first.
-    if (nextCh === 91) { return true } // '['
+    if (nextCh === 91 || nextCh === 92 || nextCh > 0xd7ff && nextCh < 0xdc00) { return true } // '[', '/', astral
     if (context) { return false }
 
     if (nextCh === 123) { return true } // '{'
     if (isIdentifierStart(nextCh, true)) {
       var pos = next + 1;
-      while (isIdentifierChar(this.input.charCodeAt(pos), true)) { ++pos; }
+      while (isIdentifierChar(nextCh = this.input.charCodeAt(pos), true)) { ++pos; }
+      if (nextCh === 92 || nextCh > 0xd7ff && nextCh < 0xdc00) { return true }
       var ident = this.input.slice(next, pos);
       if (!keywordRelationalOperator.test(ident)) { return true }
     }
@@ -792,10 +841,11 @@
 
     skipWhiteSpace.lastIndex = this.pos;
     var skip = skipWhiteSpace.exec(this.input);
-    var next = this.pos + skip[0].length;
+    var next = this.pos + skip[0].length, after;
     return !lineBreak.test(this.input.slice(this.pos, next)) &&
       this.input.slice(next, next + 8) === "function" &&
-      (next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))
+      (next + 8 === this.input.length ||
+       !(isIdentifierChar(after = this.input.charCodeAt(next + 8)) || after > 0xd7ff && after < 0xdc00))
   };
 
   // Parse a single statement.
@@ -850,7 +900,7 @@
         skipWhiteSpace.lastIndex = this.pos;
         var skip = skipWhiteSpace.exec(this.input);
         var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
-        if (nextCh === 40) // '('
+        if (nextCh === 40 || nextCh === 46) // '(' or '.'
           { return this.parseExpressionStatement(node, this.parseExpression()) }
       }
 
@@ -935,7 +985,7 @@
 
   pp$1.parseForStatement = function(node) {
     this.next();
-    var awaitAt = (this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual("await")) ? this.lastTokStart : -1;
+    var awaitAt = (this.options.ecmaVersion >= 9 && this.canAwait && this.eatContextual("await")) ? this.lastTokStart : -1;
     this.labels.push(loopLabel);
     this.enterScope(0);
     this.expect(types.parenL);
@@ -961,7 +1011,7 @@
       return this.parseFor(node, init$1)
     }
     var refDestructuringErrors = new DestructuringErrors;
-    var init = this.parseExpression(true, refDestructuringErrors);
+    var init = this.parseExpression(awaitAt > -1 ? "await" : true, refDestructuringErrors);
     if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
       if (this.options.ecmaVersion >= 9) {
         if (this.type === types._in) {
@@ -969,7 +1019,7 @@
         } else { node.await = awaitAt > -1; }
       }
       this.toAssignable(init, false, refDestructuringErrors);
-      this.checkLVal(init);
+      this.checkLValPattern(init);
       return this.parseForIn(node, init)
     } else {
       this.checkExpressionErrors(refDestructuringErrors, true);
@@ -1070,7 +1120,7 @@
         clause.param = this.parseBindingAtom();
         var simple = clause.param.type === "Identifier";
         this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);
-        this.checkLVal(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
+        this.checkLValPattern(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
         this.expect(types.parenR);
       } else {
         if (this.options.ecmaVersion < 10) { this.unexpected(); }
@@ -1150,17 +1200,19 @@
   // strict"` declarations when `allowStrict` is true (used for
   // function bodies).
 
-  pp$1.parseBlock = function(createNewLexicalScope, node) {
+  pp$1.parseBlock = function(createNewLexicalScope, node, exitStrict) {
     if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
     if ( node === void 0 ) node = this.startNode();
 
     node.body = [];
     this.expect(types.braceL);
     if (createNewLexicalScope) { this.enterScope(0); }
-    while (!this.eat(types.braceR)) {
+    while (this.type !== types.braceR) {
       var stmt = this.parseStatement(null);
       node.body.push(stmt);
     }
+    if (exitStrict) { this.strict = false; }
+    this.next();
     if (createNewLexicalScope) { this.exitScope(); }
     return this.finishNode(node, "BlockStatement")
   };
@@ -1204,8 +1256,6 @@
         init.start,
         ((isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer")
       );
-    } else if (init.type === "AssignmentPattern") {
-      this.raise(init.start, "Invalid left-hand side in for-loop");
     }
     node.left = init;
     node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
@@ -1241,7 +1291,7 @@
 
   pp$1.parseVarId = function(decl, kind) {
     decl.id = this.parseBindingAtom();
-    this.checkLVal(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
+    this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
   };
 
   var FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;
@@ -1267,7 +1317,7 @@
         // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding
         // mode depends on properties of the current scope (see
         // treatFunctionsAsVar).
-        { this.checkLVal(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); }
+        { this.checkLValSimple(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); }
     }
 
     var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
@@ -1307,92 +1357,171 @@
 
     this.parseClassId(node, isStatement);
     this.parseClassSuper(node);
+    var privateNameMap = this.enterClassBody();
     var classBody = this.startNode();
     var hadConstructor = false;
     classBody.body = [];
     this.expect(types.braceL);
-    while (!this.eat(types.braceR)) {
+    while (this.type !== types.braceR) {
       var element = this.parseClassElement(node.superClass !== null);
       if (element) {
         classBody.body.push(element);
         if (element.type === "MethodDefinition" && element.kind === "constructor") {
           if (hadConstructor) { this.raise(element.start, "Duplicate constructor in the same class"); }
           hadConstructor = true;
+        } else if (element.key.type === "PrivateIdentifier" && isPrivateNameConflicted(privateNameMap, element)) {
+          this.raiseRecoverable(element.key.start, ("Identifier '#" + (element.key.name) + "' has already been declared"));
         }
       }
     }
-    node.body = this.finishNode(classBody, "ClassBody");
     this.strict = oldStrict;
+    this.next();
+    node.body = this.finishNode(classBody, "ClassBody");
+    this.exitClassBody();
     return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
   };
 
   pp$1.parseClassElement = function(constructorAllowsSuper) {
-    var this$1 = this;
-
     if (this.eat(types.semi)) { return null }
 
-    var method = this.startNode();
-    var tryContextual = function (k, noLineBreak) {
-      if ( noLineBreak === void 0 ) noLineBreak = false;
-
-      var start = this$1.start, startLoc = this$1.startLoc;
-      if (!this$1.eatContextual(k)) { return false }
-      if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
-      if (method.key) { this$1.unexpected(); }
-      method.computed = false;
-      method.key = this$1.startNodeAt(start, startLoc);
-      method.key.name = k;
-      this$1.finishNode(method.key, "Identifier");
-      return false
-    };
-
-    method.kind = "method";
-    method.static = tryContextual("static");
-    var isGenerator = this.eat(types.star);
+    var ecmaVersion = this.options.ecmaVersion;
+    var node = this.startNode();
+    var keyName = "";
+    var isGenerator = false;
     var isAsync = false;
-    if (!isGenerator) {
-      if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
+    var kind = "method";
+
+    // Parse modifiers
+    node.static = false;
+    if (this.eatContextual("static")) {
+      if (this.isClassElementNameStart() || this.type === types.star) {
+        node.static = true;
+      } else {
+        keyName = "static";
+      }
+    }
+    if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) {
+      if ((this.isClassElementNameStart() || this.type === types.star) && !this.canInsertSemicolon()) {
         isAsync = true;
-        isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
-      } else if (tryContextual("get")) {
-        method.kind = "get";
-      } else if (tryContextual("set")) {
-        method.kind = "set";
+      } else {
+        keyName = "async";
       }
     }
-    if (!method.key) { this.parsePropertyName(method); }
+    if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types.star)) {
+      isGenerator = true;
+    }
+    if (!keyName && !isAsync && !isGenerator) {
+      var lastValue = this.value;
+      if (this.eatContextual("get") || this.eatContextual("set")) {
+        if (this.isClassElementNameStart()) {
+          kind = lastValue;
+        } else {
+          keyName = lastValue;
+        }
+      }
+    }
+
+    // Parse element name
+    if (keyName) {
+      // 'async', 'get', 'set', or 'static' were not a keyword contextually.
+      // The last token is any of those. Make it the element name.
+      node.computed = false;
+      node.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc);
+      node.key.name = keyName;
+      this.finishNode(node.key, "Identifier");
+    } else {
+      this.parseClassElementName(node);
+    }
+
+    // Parse element value
+    if (ecmaVersion < 13 || this.type === types.parenL || kind !== "method" || isGenerator || isAsync) {
+      var isConstructor = !node.static && checkKeyName(node, "constructor");
+      var allowsDirectSuper = isConstructor && constructorAllowsSuper;
+      // Couldn't move this check into the 'parseClassMethod' method for backward compatibility.
+      if (isConstructor && kind !== "method") { this.raise(node.key.start, "Constructor can't have get/set modifier"); }
+      node.kind = isConstructor ? "constructor" : kind;
+      this.parseClassMethod(node, isGenerator, isAsync, allowsDirectSuper);
+    } else {
+      this.parseClassField(node);
+    }
+
+    return node
+  };
+
+  pp$1.isClassElementNameStart = function() {
+    return (
+      this.type === types.name ||
+      this.type === types.privateId ||
+      this.type === types.num ||
+      this.type === types.string ||
+      this.type === types.bracketL ||
+      this.type.keyword
+    )
+  };
+
+  pp$1.parseClassElementName = function(element) {
+    if (this.type === types.privateId) {
+      if (this.value === "constructor") {
+        this.raise(this.start, "Classes can't have an element named '#constructor'");
+      }
+      element.computed = false;
+      element.key = this.parsePrivateIdent();
+    } else {
+      this.parsePropertyName(element);
+    }
+  };
+
+  pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
+    // Check key and flags
     var key = method.key;
-    var allowsDirectSuper = false;
-    if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
-        key.type === "Literal" && key.value === "constructor")) {
-      if (method.kind !== "method") { this.raise(key.start, "Constructor can't have get/set modifier"); }
+    if (method.kind === "constructor") {
       if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
       if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
-      method.kind = "constructor";
-      allowsDirectSuper = constructorAllowsSuper;
-    } else if (method.static && key.type === "Identifier" && key.name === "prototype") {
+    } else if (method.static && checkKeyName(method, "prototype")) {
       this.raise(key.start, "Classes may not have a static property named prototype");
     }
-    this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper);
-    if (method.kind === "get" && method.value.params.length !== 0)
-      { this.raiseRecoverable(method.value.start, "getter should have no params"); }
-    if (method.kind === "set" && method.value.params.length !== 1)
-      { this.raiseRecoverable(method.value.start, "setter should have exactly one param"); }
-    if (method.kind === "set" && method.value.params[0].type === "RestElement")
-      { this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params"); }
-    return method
-  };
 
-  pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
-    method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+    // Parse value
+    var value = method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+
+    // Check value
+    if (method.kind === "get" && value.params.length !== 0)
+      { this.raiseRecoverable(value.start, "getter should have no params"); }
+    if (method.kind === "set" && value.params.length !== 1)
+      { this.raiseRecoverable(value.start, "setter should have exactly one param"); }
+    if (method.kind === "set" && value.params[0].type === "RestElement")
+      { this.raiseRecoverable(value.params[0].start, "Setter cannot use rest params"); }
+
     return this.finishNode(method, "MethodDefinition")
   };
 
+  pp$1.parseClassField = function(field) {
+    if (checkKeyName(field, "constructor")) {
+      this.raise(field.key.start, "Classes can't have a field named 'constructor'");
+    } else if (field.static && checkKeyName(field, "prototype")) {
+      this.raise(field.key.start, "Classes can't have a static field named 'prototype'");
+    }
+
+    if (this.eat(types.eq)) {
+      // To raise SyntaxError if 'arguments' exists in the initializer.
+      var scope = this.currentThisScope();
+      var inClassFieldInit = scope.inClassFieldInit;
+      scope.inClassFieldInit = true;
+      field.value = this.parseMaybeAssign();
+      scope.inClassFieldInit = inClassFieldInit;
+    } else {
+      field.value = null;
+    }
+    this.semicolon();
+
+    return this.finishNode(field, "PropertyDefinition")
+  };
+
   pp$1.parseClassId = function(node, isStatement) {
     if (this.type === types.name) {
       node.id = this.parseIdent();
       if (isStatement)
-        { this.checkLVal(node.id, BIND_LEXICAL, false); }
+        { this.checkLValSimple(node.id, BIND_LEXICAL, false); }
     } else {
       if (isStatement === true)
         { this.unexpected(); }
@@ -1404,12 +1533,79 @@
     node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
   };
 
+  pp$1.enterClassBody = function() {
+    var element = {declared: Object.create(null), used: []};
+    this.privateNameStack.push(element);
+    return element.declared
+  };
+
+  pp$1.exitClassBody = function() {
+    var ref = this.privateNameStack.pop();
+    var declared = ref.declared;
+    var used = ref.used;
+    var len = this.privateNameStack.length;
+    var parent = len === 0 ? null : this.privateNameStack[len - 1];
+    for (var i = 0; i < used.length; ++i) {
+      var id = used[i];
+      if (!has(declared, id.name)) {
+        if (parent) {
+          parent.used.push(id);
+        } else {
+          this.raiseRecoverable(id.start, ("Private field '#" + (id.name) + "' must be declared in an enclosing class"));
+        }
+      }
+    }
+  };
+
+  function isPrivateNameConflicted(privateNameMap, element) {
+    var name = element.key.name;
+    var curr = privateNameMap[name];
+
+    var next = "true";
+    if (element.type === "MethodDefinition" && (element.kind === "get" || element.kind === "set")) {
+      next = (element.static ? "s" : "i") + element.kind;
+    }
+
+    // `class { get #a(){}; static set #a(_){} }` is also conflict.
+    if (
+      curr === "iget" && next === "iset" ||
+      curr === "iset" && next === "iget" ||
+      curr === "sget" && next === "sset" ||
+      curr === "sset" && next === "sget"
+    ) {
+      privateNameMap[name] = "true";
+      return false
+    } else if (!curr) {
+      privateNameMap[name] = next;
+      return false
+    } else {
+      return true
+    }
+  }
+
+  function checkKeyName(node, name) {
+    var computed = node.computed;
+    var key = node.key;
+    return !computed && (
+      key.type === "Identifier" && key.name === name ||
+      key.type === "Literal" && key.value === name
+    )
+  }
+
   // Parses module export declaration.
 
   pp$1.parseExport = function(node, exports) {
     this.next();
     // export * from '...'
     if (this.eat(types.star)) {
+      if (this.options.ecmaVersion >= 11) {
+        if (this.eatContextual("as")) {
+          node.exported = this.parseIdent(true);
+          this.checkExport(exports, node.exported.name, this.lastTokStart);
+        } else {
+          node.exported = null;
+        }
+      }
       this.expectContextual("from");
       if (this.type !== types.string) { this.unexpected(); }
       node.source = this.parseExprAtom();
@@ -1564,7 +1760,7 @@
       // import defaultObj, { x, y as z } from '...'
       var node = this.startNode();
       node.local = this.parseIdent();
-      this.checkLVal(node.local, BIND_LEXICAL);
+      this.checkLValSimple(node.local, BIND_LEXICAL);
       nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
       if (!this.eat(types.comma)) { return nodes }
     }
@@ -1573,7 +1769,7 @@
       this.next();
       this.expectContextual("as");
       node$1.local = this.parseIdent();
-      this.checkLVal(node$1.local, BIND_LEXICAL);
+      this.checkLValSimple(node$1.local, BIND_LEXICAL);
       nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
       return nodes
     }
@@ -1592,7 +1788,7 @@
         this.checkUnreserved(node$2.imported);
         node$2.local = node$2.imported;
       }
-      this.checkLVal(node$2.local, BIND_LEXICAL);
+      this.checkLValSimple(node$2.local, BIND_LEXICAL);
       nodes.push(this.finishNode(node$2, "ImportSpecifier"));
     }
     return nodes
@@ -1629,6 +1825,7 @@
 
       case "ObjectPattern":
       case "ArrayPattern":
+      case "AssignmentPattern":
       case "RestElement":
         break
 
@@ -1677,15 +1874,16 @@
         node.type = "AssignmentPattern";
         delete node.operator;
         this.toAssignable(node.left, isBinding);
-        // falls through to AssignmentPattern
-
-      case "AssignmentPattern":
         break
 
       case "ParenthesizedExpression":
         this.toAssignable(node.expression, isBinding, refDestructuringErrors);
         break
 
+      case "ChainExpression":
+        this.raiseRecoverable(node.start, "Optional chaining cannot appear in left-hand side");
+        break
+
       case "MemberExpression":
         if (!isBinding) { break }
 
@@ -1792,70 +1990,152 @@
     return this.finishNode(node, "AssignmentPattern")
   };
 
-  // Verify that a node is an lval — something that can be assigned
-  // to.
-  // bindingType can be either:
-  // 'var' indicating that the lval creates a 'var' binding
-  // 'let' indicating that the lval creates a lexical ('let' or 'const') binding
-  // 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references
+  // The following three functions all verify that a node is an lvalue —
+  // something that can be bound, or assigned to. In order to do so, they perform
+  // a variety of checks:
+  //
+  // - Check that none of the bound/assigned-to identifiers are reserved words.
+  // - Record name declarations for bindings in the appropriate scope.
+  // - Check duplicate argument names, if checkClashes is set.
+  //
+  // If a complex binding pattern is encountered (e.g., object and array
+  // destructuring), the entire pattern is recursively checked.
+  //
+  // There are three versions of checkLVal*() appropriate for different
+  // circumstances:
+  //
+  // - checkLValSimple() shall be used if the syntactic construct supports
+  //   nothing other than identifiers and member expressions. Parenthesized
+  //   expressions are also correctly handled. This is generally appropriate for
+  //   constructs for which the spec says
+  //
+  //   > It is a Syntax Error if AssignmentTargetType of [the production] is not
+  //   > simple.
+  //
+  //   It is also appropriate for checking if an identifier is valid and not
+  //   defined elsewhere, like import declarations or function/class identifiers.
+  //
+  //   Examples where this is used include:
+  //     a += …;
+  //     import a from '…';
+  //   where a is the node to be checked.
+  //
+  // - checkLValPattern() shall be used if the syntactic construct supports
+  //   anything checkLValSimple() supports, as well as object and array
+  //   destructuring patterns. This is generally appropriate for constructs for
+  //   which the spec says
+  //
+  //   > It is a Syntax Error if [the production] is neither an ObjectLiteral nor
+  //   > an ArrayLiteral and AssignmentTargetType of [the production] is not
+  //   > simple.
+  //
+  //   Examples where this is used include:
+  //     (a = …);
+  //     const a = …;
+  //     try { … } catch (a) { … }
+  //   where a is the node to be checked.
+  //
+  // - checkLValInnerPattern() shall be used if the syntactic construct supports
+  //   anything checkLValPattern() supports, as well as default assignment
+  //   patterns, rest elements, and other constructs that may appear within an
+  //   object or array destructuring pattern.
+  //
+  //   As a special case, function parameters also use checkLValInnerPattern(),
+  //   as they also support defaults and rest constructs.
+  //
+  // These functions deliberately support both assignment and binding constructs,
+  // as the logic for both is exceedingly similar. If the node is the target of
+  // an assignment, then bindingType should be set to BIND_NONE. Otherwise, it
+  // should be set to the appropriate BIND_* constant, like BIND_VAR or
+  // BIND_LEXICAL.
+  //
+  // If the function is called with a non-BIND_NONE bindingType, then
+  // additionally a checkClashes object may be specified to allow checking for
+  // duplicate argument names. checkClashes is ignored if the provided construct
+  // is an assignment (i.e., bindingType is BIND_NONE).
 
-  pp$2.checkLVal = function(expr, bindingType, checkClashes) {
+  pp$2.checkLValSimple = function(expr, bindingType, checkClashes) {
     if ( bindingType === void 0 ) bindingType = BIND_NONE;
 
+    var isBind = bindingType !== BIND_NONE;
+
     switch (expr.type) {
     case "Identifier":
-      if (bindingType === BIND_LEXICAL && expr.name === "let")
-        { this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name"); }
       if (this.strict && this.reservedWordsStrictBind.test(expr.name))
-        { this.raiseRecoverable(expr.start, (bindingType ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
-      if (checkClashes) {
-        if (has(checkClashes, expr.name))
-          { this.raiseRecoverable(expr.start, "Argument name clash"); }
-        checkClashes[expr.name] = true;
+        { this.raiseRecoverable(expr.start, (isBind ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
+      if (isBind) {
+        if (bindingType === BIND_LEXICAL && expr.name === "let")
+          { this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name"); }
+        if (checkClashes) {
+          if (has(checkClashes, expr.name))
+            { this.raiseRecoverable(expr.start, "Argument name clash"); }
+          checkClashes[expr.name] = true;
+        }
+        if (bindingType !== BIND_OUTSIDE) { this.declareName(expr.name, bindingType, expr.start); }
       }
-      if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) { this.declareName(expr.name, bindingType, expr.start); }
+      break
+
+    case "ChainExpression":
+      this.raiseRecoverable(expr.start, "Optional chaining cannot appear in left-hand side");
       break
 
     case "MemberExpression":
-      if (bindingType) { this.raiseRecoverable(expr.start, "Binding member expression"); }
+      if (isBind) { this.raiseRecoverable(expr.start, "Binding member expression"); }
       break
 
-    case "ObjectPattern":
-      for (var i = 0, list = expr.properties; i < list.length; i += 1)
-        {
-      var prop = list[i];
+    case "ParenthesizedExpression":
+      if (isBind) { this.raiseRecoverable(expr.start, "Binding parenthesized expression"); }
+      return this.checkLValSimple(expr.expression, bindingType, checkClashes)
 
-      this.checkLVal(prop, bindingType, checkClashes);
+    default:
+      this.raise(expr.start, (isBind ? "Binding" : "Assigning to") + " rvalue");
     }
-      break
+  };
 
-    case "Property":
-      // AssignmentProperty has type === "Property"
-      this.checkLVal(expr.value, bindingType, checkClashes);
+  pp$2.checkLValPattern = function(expr, bindingType, checkClashes) {
+    if ( bindingType === void 0 ) bindingType = BIND_NONE;
+
+    switch (expr.type) {
+    case "ObjectPattern":
+      for (var i = 0, list = expr.properties; i < list.length; i += 1) {
+        var prop = list[i];
+
+      this.checkLValInnerPattern(prop, bindingType, checkClashes);
+      }
       break
 
     case "ArrayPattern":
       for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
         var elem = list$1[i$1];
 
-      if (elem) { this.checkLVal(elem, bindingType, checkClashes); }
+      if (elem) { this.checkLValInnerPattern(elem, bindingType, checkClashes); }
       }
       break
 
-    case "AssignmentPattern":
-      this.checkLVal(expr.left, bindingType, checkClashes);
+    default:
+      this.checkLValSimple(expr, bindingType, checkClashes);
+    }
+  };
+
+  pp$2.checkLValInnerPattern = function(expr, bindingType, checkClashes) {
+    if ( bindingType === void 0 ) bindingType = BIND_NONE;
+
+    switch (expr.type) {
+    case "Property":
+      // AssignmentProperty has type === "Property"
+      this.checkLValInnerPattern(expr.value, bindingType, checkClashes);
       break
 
-    case "RestElement":
-      this.checkLVal(expr.argument, bindingType, checkClashes);
+    case "AssignmentPattern":
+      this.checkLValPattern(expr.left, bindingType, checkClashes);
       break
 
-    case "ParenthesizedExpression":
-      this.checkLVal(expr.expression, bindingType, checkClashes);
+    case "RestElement":
+      this.checkLValPattern(expr.argument, bindingType, checkClashes);
       break
 
     default:
-      this.raise(expr.start, (bindingType ? "Binding" : "Assigning to") + " rvalue");
+      this.checkLValPattern(expr, bindingType, checkClashes);
     }
   };
 
@@ -1930,13 +2210,13 @@
   // and object pattern might appear (so it's possible to raise
   // delayed syntax error at correct position).
 
-  pp$3.parseExpression = function(noIn, refDestructuringErrors) {
+  pp$3.parseExpression = function(forInit, refDestructuringErrors) {
     var startPos = this.start, startLoc = this.startLoc;
-    var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
+    var expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
     if (this.type === types.comma) {
       var node = this.startNodeAt(startPos, startLoc);
       node.expressions = [expr];
-      while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors)); }
+      while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors)); }
       return this.finishNode(node, "SequenceExpression")
     }
     return expr
@@ -1945,9 +2225,9 @@
   // Parse an assignment expression. This includes applications of
   // operators like `+=`.
 
-  pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
+  pp$3.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse) {
     if (this.isContextual("yield")) {
-      if (this.inGenerator) { return this.parseYield(noIn) }
+      if (this.inGenerator) { return this.parseYield(forInit) }
       // The tokenizer will assume an expression is allowed after
       // `yield`, but this isn't that kind of yield
       else { this.exprAllowed = false; }
@@ -1964,22 +2244,29 @@
     }
 
     var startPos = this.start, startLoc = this.startLoc;
-    if (this.type === types.parenL || this.type === types.name)
-      { this.potentialArrowAt = this.start; }
-    var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
+    if (this.type === types.parenL || this.type === types.name) {
+      this.potentialArrowAt = this.start;
+      this.potentialArrowInForAwait = forInit === "await";
+    }
+    var left = this.parseMaybeConditional(forInit, refDestructuringErrors);
     if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
     if (this.type.isAssign) {
       var node = this.startNodeAt(startPos, startLoc);
       node.operator = this.value;
-      node.left = this.type === types.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;
+      if (this.type === types.eq)
+        { left = this.toAssignable(left, false, refDestructuringErrors); }
       if (!ownDestructuringErrors) {
         refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1;
       }
-      if (refDestructuringErrors.shorthandAssign >= node.left.start)
+      if (refDestructuringErrors.shorthandAssign >= left.start)
         { refDestructuringErrors.shorthandAssign = -1; } // reset because shorthand default was used correctly
-      this.checkLVal(left);
+      if (this.type === types.eq)
+        { this.checkLValPattern(left); }
+      else
+        { this.checkLValSimple(left); }
+      node.left = left;
       this.next();
-      node.right = this.parseMaybeAssign(noIn);
+      node.right = this.parseMaybeAssign(forInit);
       return this.finishNode(node, "AssignmentExpression")
     } else {
       if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
@@ -1991,16 +2278,16 @@
 
   // Parse a ternary conditional (`?:`) operator.
 
-  pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
+  pp$3.parseMaybeConditional = function(forInit, refDestructuringErrors) {
     var startPos = this.start, startLoc = this.startLoc;
-    var expr = this.parseExprOps(noIn, refDestructuringErrors);
+    var expr = this.parseExprOps(forInit, refDestructuringErrors);
     if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
     if (this.eat(types.question)) {
       var node = this.startNodeAt(startPos, startLoc);
       node.test = expr;
       node.consequent = this.parseMaybeAssign();
       this.expect(types.colon);
-      node.alternate = this.parseMaybeAssign(noIn);
+      node.alternate = this.parseMaybeAssign(forInit);
       return this.finishNode(node, "ConditionalExpression")
     }
     return expr
@@ -2008,11 +2295,11 @@
 
   // Start the precedence parser.
 
-  pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
+  pp$3.parseExprOps = function(forInit, refDestructuringErrors) {
     var startPos = this.start, startLoc = this.startLoc;
     var expr = this.parseMaybeUnary(refDestructuringErrors, false);
     if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
-    return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)
+    return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, forInit)
   };
 
   // Parse binary operators with the operator precedence parsing
@@ -2021,17 +2308,26 @@
   // defer further parser to one of its callers when it encounters an
   // operator that has a lower precedence than the set it is parsing.
 
-  pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
+  pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit) {
     var prec = this.type.binop;
-    if (prec != null && (!noIn || this.type !== types._in)) {
+    if (prec != null && (!forInit || this.type !== types._in)) {
       if (prec > minPrec) {
         var logical = this.type === types.logicalOR || this.type === types.logicalAND;
+        var coalesce = this.type === types.coalesce;
+        if (coalesce) {
+          // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions.
+          // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error.
+          prec = types.logicalAND.binop;
+        }
         var op = this.value;
         this.next();
         var startPos = this.start, startLoc = this.startLoc;
-        var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
-        var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical);
-        return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
+        var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, forInit);
+        var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);
+        if ((logical && this.type === types.coalesce) || (coalesce && (this.type === types.logicalOR || this.type === types.logicalAND))) {
+          this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses");
+        }
+        return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, forInit)
       }
     }
     return left
@@ -2047,9 +2343,9 @@
 
   // Parse unary operators, both prefix and postfix.
 
-  pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
+  pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec) {
     var startPos = this.start, startLoc = this.startLoc, expr;
-    if (this.isContextual("await") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
+    if (this.isContextual("await") && this.canAwait) {
       expr = this.parseAwait();
       sawUnary = true;
     } else if (this.type.prefix) {
@@ -2057,12 +2353,14 @@
       node.operator = this.value;
       node.prefix = true;
       this.next();
-      node.argument = this.parseMaybeUnary(null, true);
+      node.argument = this.parseMaybeUnary(null, true, update);
       this.checkExpressionErrors(refDestructuringErrors, true);
-      if (update) { this.checkLVal(node.argument); }
+      if (update) { this.checkLValSimple(node.argument); }
       else if (this.strict && node.operator === "delete" &&
                node.argument.type === "Identifier")
         { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
+      else if (node.operator === "delete" && isPrivateFieldAccess(node.argument))
+        { this.raiseRecoverable(node.start, "Private fields can not be deleted"); }
       else { sawUnary = true; }
       expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
     } else {
@@ -2073,18 +2371,29 @@
         node$1.operator = this.value;
         node$1.prefix = false;
         node$1.argument = expr;
-        this.checkLVal(expr);
+        this.checkLValSimple(expr);
         this.next();
         expr = this.finishNode(node$1, "UpdateExpression");
       }
     }
 
-    if (!sawUnary && this.eat(types.starstar))
-      { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
-    else
-      { return expr }
+    if (!incDec && this.eat(types.starstar)) {
+      if (sawUnary)
+        { this.unexpected(this.lastTokStart); }
+      else
+        { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
+    } else {
+      return expr
+    }
   };
 
+  function isPrivateFieldAccess(node) {
+    return (
+      node.type === "MemberExpression" && node.property.type === "PrivateIdentifier" ||
+      node.type === "ChainExpression" && isPrivateFieldAccess(node.expression)
+    )
+  }
+
   // Parse call, dot, and `[]`-subscript expressions.
 
   pp$3.parseExprSubscripts = function(refDestructuringErrors) {
@@ -2096,28 +2405,55 @@
     if (refDestructuringErrors && result.type === "MemberExpression") {
       if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
       if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
+      if (refDestructuringErrors.trailingComma >= result.start) { refDestructuringErrors.trailingComma = -1; }
     }
     return result
   };
 
   pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
     var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
-        this.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === "async";
+        this.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 &&
+        this.potentialArrowAt === base.start;
+    var optionalChained = false;
+
     while (true) {
-      var element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow);
-      if (element === base || element.type === "ArrowFunctionExpression") { return element }
+      var element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained);
+
+      if (element.optional) { optionalChained = true; }
+      if (element === base || element.type === "ArrowFunctionExpression") {
+        if (optionalChained) {
+          var chainNode = this.startNodeAt(startPos, startLoc);
+          chainNode.expression = element;
+          element = this.finishNode(chainNode, "ChainExpression");
+        }
+        return element
+      }
+
       base = element;
     }
   };
 
-  pp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow) {
+  pp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained) {
+    var optionalSupported = this.options.ecmaVersion >= 11;
+    var optional = optionalSupported && this.eat(types.questionDot);
+    if (noCalls && optional) { this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions"); }
+
     var computed = this.eat(types.bracketL);
-    if (computed || this.eat(types.dot)) {
+    if (computed || (optional && this.type !== types.parenL && this.type !== types.backQuote) || this.eat(types.dot)) {
       var node = this.startNodeAt(startPos, startLoc);
       node.object = base;
-      node.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== "never");
+      if (computed) {
+        node.property = this.parseExpression();
+        this.expect(types.bracketR);
+      } else if (this.type === types.privateId && base.type !== "Super") {
+        node.property = this.parsePrivateIdent();
+      } else {
+        node.property = this.parseIdent(this.options.allowReserved !== "never");
+      }
       node.computed = !!computed;
-      if (computed) { this.expect(types.bracketR); }
+      if (optionalSupported) {
+        node.optional = optional;
+      }
       base = this.finishNode(node, "MemberExpression");
     } else if (!noCalls && this.eat(types.parenL)) {
       var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
@@ -2125,7 +2461,7 @@
       this.awaitPos = 0;
       this.awaitIdentPos = 0;
       var exprList = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors);
-      if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+      if (maybeAsyncArrow && !optional && !this.canInsertSemicolon() && this.eat(types.arrow)) {
         this.checkPatternErrors(refDestructuringErrors, false);
         this.checkYieldAwaitInDefaultParams();
         if (this.awaitIdentPos > 0)
@@ -2142,8 +2478,14 @@
       var node$1 = this.startNodeAt(startPos, startLoc);
       node$1.callee = base;
       node$1.arguments = exprList;
+      if (optionalSupported) {
+        node$1.optional = optional;
+      }
       base = this.finishNode(node$1, "CallExpression");
     } else if (this.type === types.backQuote) {
+      if (optional || optionalChained) {
+        this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions");
+      }
       var node$2 = this.startNodeAt(startPos, startLoc);
       node$2.tag = base;
       node$2.quasi = this.parseTemplate({isTagged: true});
@@ -2194,7 +2536,8 @@
       if (canBeArrow && !this.canInsertSemicolon()) {
         if (this.eat(types.arrow))
           { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
-        if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
+        if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc &&
+            (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) {
           id = this.parseIdent(false);
           if (this.canInsertSemicolon() || !this.eat(types.arrow))
             { this.unexpected(); }
@@ -2266,10 +2609,18 @@
 
   pp$3.parseExprImport = function() {
     var node = this.startNode();
-    this.next(); // skip `import`
+
+    // Consume `import` as an identifier for `import.meta`.
+    // Because `this.parseIdent(true)` doesn't check escape sequences, it needs the check of `this.containsEsc`.
+    if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword import"); }
+    var meta = this.parseIdent(true);
+
     switch (this.type) {
     case types.parenL:
       return this.parseDynamicImport(node)
+    case types.dot:
+      node.meta = meta;
+      return this.parseImportMeta(node)
     default:
       this.unexpected();
     }
@@ -2294,11 +2645,27 @@
     return this.finishNode(node, "ImportExpression")
   };
 
+  pp$3.parseImportMeta = function(node) {
+    this.next(); // skip `.`
+
+    var containsEsc = this.containsEsc;
+    node.property = this.parseIdent(true);
+
+    if (node.property.name !== "meta")
+      { this.raiseRecoverable(node.property.start, "The only valid meta property for import is 'import.meta'"); }
+    if (containsEsc)
+      { this.raiseRecoverable(node.start, "'import.meta' must not contain escaped characters"); }
+    if (this.options.sourceType !== "module" && !this.options.allowImportExportEverywhere)
+      { this.raiseRecoverable(node.start, "Cannot use 'import.meta' outside a module"); }
+
+    return this.finishNode(node, "MetaProperty")
+  };
+
   pp$3.parseLiteral = function(value) {
     var node = this.startNode();
     node.value = value;
     node.raw = this.input.slice(this.start, this.end);
-    if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint = node.raw.slice(0, -1); }
+    if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint = node.raw.slice(0, -1).replace(/_/g, ""); }
     this.next();
     return this.finishNode(node, "Literal")
   };
@@ -2396,10 +2763,12 @@
       node.meta = meta;
       var containsEsc = this.containsEsc;
       node.property = this.parseIdent(true);
-      if (node.property.name !== "target" || containsEsc)
-        { this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target"); }
-      if (!this.inNonArrowFunction())
-        { this.raiseRecoverable(node.start, "new.target can only be used in functions"); }
+      if (node.property.name !== "target")
+        { this.raiseRecoverable(node.property.start, "The only valid meta property for new is 'new.target'"); }
+      if (containsEsc)
+        { this.raiseRecoverable(node.start, "'new.target' must not contain escaped characters"); }
+      if (!this.inNonArrowFunction)
+        { this.raiseRecoverable(node.start, "'new.target' can only be used in functions"); }
       return this.finishNode(node, "MetaProperty")
     }
     var startPos = this.start, startLoc = this.startLoc, isImport = this.type === types._import;
@@ -2548,7 +2917,7 @@
     } else if (!isPattern && !containsEsc &&
                this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
                (prop.key.name === "get" || prop.key.name === "set") &&
-               (this.type !== types.comma && this.type !== types.braceR)) {
+               (this.type !== types.comma && this.type !== types.braceR && this.type !== types.eq)) {
       if (isGenerator || isAsync) { this.unexpected(); }
       prop.kind = prop.key.name;
       this.parsePropertyName(prop);
@@ -2571,13 +2940,13 @@
         { this.awaitIdentPos = startPos; }
       prop.kind = "init";
       if (isPattern) {
-        prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
+        prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key));
       } else if (this.type === types.eq && refDestructuringErrors) {
         if (refDestructuringErrors.shorthandAssign < 0)
           { refDestructuringErrors.shorthandAssign = this.start; }
-        prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
+        prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key));
       } else {
-        prop.value = prop.key;
+        prop.value = this.copyNode(prop.key);
       }
       prop.shorthand = true;
     } else { this.unexpected(); }
@@ -2683,16 +3052,14 @@
       // Add the params to varDeclaredNames to ensure that an error is thrown
       // if a let/const declaration in the function clashes with one of the params.
       this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params));
-      node.body = this.parseBlock(false);
+      // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'
+      if (this.strict && node.id) { this.checkLValSimple(node.id, BIND_OUTSIDE); }
+      node.body = this.parseBlock(false, undefined, useStrict && !oldStrict);
       node.expression = false;
       this.adaptDirectivePrologue(node.body.body);
       this.labels = oldLabels;
     }
     this.exitScope();
-
-    // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'
-    if (this.strict && node.id) { this.checkLVal(node.id, BIND_OUTSIDE); }
-    this.strict = oldStrict;
   };
 
   pp$3.isSimpleParamList = function(params) {
@@ -2709,12 +3076,12 @@
   // or "arguments" and duplicate parameters.
 
   pp$3.checkParams = function(node, allowDuplicates) {
-    var nameHash = {};
+    var nameHash = Object.create(null);
     for (var i = 0, list = node.params; i < list.length; i += 1)
       {
       var param = list[i];
 
-      this.checkLVal(param, BIND_VAR, allowDuplicates ? null : nameHash);
+      this.checkLValInnerPattern(param, BIND_VAR, allowDuplicates ? null : nameHash);
     }
   };
 
@@ -2756,6 +3123,8 @@
       { this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator"); }
     if (this.inAsync && name === "await")
       { this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function"); }
+    if (this.currentThisScope().inClassFieldInit && name === "arguments")
+      { this.raiseRecoverable(start, "Cannot use 'arguments' in class field initializer"); }
     if (this.keywords.test(name))
       { this.raise(start, ("Unexpected keyword '" + name + "'")); }
     if (this.options.ecmaVersion < 6 &&
@@ -2800,9 +3169,29 @@
     return node
   };
 
+  pp$3.parsePrivateIdent = function() {
+    var node = this.startNode();
+    if (this.type === types.privateId) {
+      node.name = this.value;
+    } else {
+      this.unexpected();
+    }
+    this.next();
+    this.finishNode(node, "PrivateIdentifier");
+
+    // For validating existence
+    if (this.privateNameStack.length === 0) {
+      this.raise(node.start, ("Private field '#" + (node.name) + "' must be declared in an enclosing class"));
+    } else {
+      this.privateNameStack[this.privateNameStack.length - 1].used.push(node);
+    }
+
+    return node
+  };
+
   // Parses yield expression inside generator.
 
-  pp$3.parseYield = function(noIn) {
+  pp$3.parseYield = function(forInit) {
     if (!this.yieldPos) { this.yieldPos = this.start; }
 
     var node = this.startNode();
@@ -2812,7 +3201,7 @@
       node.argument = null;
     } else {
       node.delegate = this.eat(types.star);
-      node.argument = this.parseMaybeAssign(noIn);
+      node.argument = this.parseMaybeAssign(forInit);
     }
     return this.finishNode(node, "YieldExpression")
   };
@@ -2822,7 +3211,7 @@
 
     var node = this.startNode();
     this.next();
-    node.argument = this.parseMaybeUnary(null, false);
+    node.argument = this.parseMaybeUnary(null, true);
     return this.finishNode(node, "AwaitExpression")
   };
 
@@ -2860,6 +3249,8 @@
     this.lexical = [];
     // A list of lexically-declared FunctionDeclaration names in the current lexical scope
     this.functions = [];
+    // A switch to disallow the identifier reference 'arguments'
+    this.inClassFieldInit = false;
   };
 
   // The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
@@ -2987,6 +3378,12 @@
     return finishNodeAt.call(this, node, type, pos, loc)
   };
 
+  pp$6.copyNode = function(node) {
+    var newNode = new Node(this, node.start, this.startLoc);
+    for (var prop in node) { newNode[prop] = node[prop]; }
+    return newNode
+  };
+
   // The algorithm used to determine whether a regexp can appear at a
 
   var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
@@ -3091,7 +3488,8 @@
   };
 
   types._function.updateContext = types._class.updateContext = function(prevType) {
-    if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&
+    if (prevType.beforeExpr && prevType !== types._else &&
+        !(prevType === types.semi && this.curContext() !== types$1.p_stat) &&
         !(prevType === types._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&
         !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
       { this.context.push(types$1.f_expr); }
@@ -3137,10 +3535,12 @@
   var ecma9BinaryProperties = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS";
   var ecma10BinaryProperties = ecma9BinaryProperties + " Extended_Pictographic";
   var ecma11BinaryProperties = ecma10BinaryProperties;
+  var ecma12BinaryProperties = ecma11BinaryProperties + " EBase EComp EMod EPres ExtPict";
   var unicodeBinaryProperties = {
     9: ecma9BinaryProperties,
     10: ecma10BinaryProperties,
-    11: ecma11BinaryProperties
+    11: ecma11BinaryProperties,
+    12: ecma12BinaryProperties
   };
 
   // #table-unicode-general-category-values
@@ -3150,10 +3550,12 @@
   var ecma9ScriptValues = "Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb";
   var ecma10ScriptValues = ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd";
   var ecma11ScriptValues = ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho";
+  var ecma12ScriptValues = ecma11ScriptValues + " Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi";
   var unicodeScriptValues = {
     9: ecma9ScriptValues,
     10: ecma10ScriptValues,
-    11: ecma11ScriptValues
+    11: ecma11ScriptValues,
+    12: ecma12ScriptValues
   };
 
   var data = {};
@@ -3174,13 +3576,14 @@
   buildUnicodeData(9);
   buildUnicodeData(10);
   buildUnicodeData(11);
+  buildUnicodeData(12);
 
   var pp$8 = Parser.prototype;
 
   var RegExpValidationState = function RegExpValidationState(parser) {
     this.parser = parser;
-    this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "");
-    this.unicodeProperties = data[parser.options.ecmaVersion >= 11 ? 11 : parser.options.ecmaVersion];
+    this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "") + (parser.options.ecmaVersion >= 13 ? "d" : "");
+    this.unicodeProperties = data[parser.options.ecmaVersion >= 12 ? 12 : parser.options.ecmaVersion];
     this.source = "";
     this.flags = "";
     this.start = 0;
@@ -3211,49 +3614,61 @@
 
   // If u flag is given, this returns the code point at the index (it combines a surrogate pair).
   // Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).
-  RegExpValidationState.prototype.at = function at (i) {
+  RegExpValidationState.prototype.at = function at (i, forceU) {
+      if ( forceU === void 0 ) forceU = false;
+
     var s = this.source;
     var l = s.length;
     if (i >= l) {
       return -1
     }
     var c = s.charCodeAt(i);
-    if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
+    if (!(forceU || this.switchU) || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
       return c
     }
     var next = s.charCodeAt(i + 1);
     return next >= 0xDC00 && next <= 0xDFFF ? (c << 10) + next - 0x35FDC00 : c
   };
 
-  RegExpValidationState.prototype.nextIndex = function nextIndex (i) {
+  RegExpValidationState.prototype.nextIndex = function nextIndex (i, forceU) {
+      if ( forceU === void 0 ) forceU = false;
+
     var s = this.source;
     var l = s.length;
     if (i >= l) {
       return l
     }
     var c = s.charCodeAt(i), next;
-    if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l ||
+    if (!(forceU || this.switchU) || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l ||
         (next = s.charCodeAt(i + 1)) < 0xDC00 || next > 0xDFFF) {
       return i + 1
     }
     return i + 2
   };
 
-  RegExpValidationState.prototype.current = function current () {
-    return this.at(this.pos)
+  RegExpValidationState.prototype.current = function current (forceU) {
+      if ( forceU === void 0 ) forceU = false;
+
+    return this.at(this.pos, forceU)
   };
 
-  RegExpValidationState.prototype.lookahead = function lookahead () {
-    return this.at(this.nextIndex(this.pos))
+  RegExpValidationState.prototype.lookahead = function lookahead (forceU) {
+      if ( forceU === void 0 ) forceU = false;
+
+    return this.at(this.nextIndex(this.pos, forceU), forceU)
   };
 
-  RegExpValidationState.prototype.advance = function advance () {
-    this.pos = this.nextIndex(this.pos);
+  RegExpValidationState.prototype.advance = function advance (forceU) {
+      if ( forceU === void 0 ) forceU = false;
+
+    this.pos = this.nextIndex(this.pos, forceU);
   };
 
-  RegExpValidationState.prototype.eat = function eat (ch) {
-    if (this.current() === ch) {
-      this.advance();
+  RegExpValidationState.prototype.eat = function eat (ch, forceU) {
+      if ( forceU === void 0 ) forceU = false;
+
+    if (this.current(forceU) === ch) {
+      this.advance(forceU);
       return true
     }
     return false
@@ -3592,9 +4007,9 @@
     return false
   };
 
-  // GroupSpecifier[U] ::
+  // GroupSpecifier ::
   //   [empty]
-  //   `?` GroupName[?U]
+  //   `?` GroupName
   pp$8.regexp_groupSpecifier = function(state) {
     if (state.eat(0x3F /* ? */)) {
       if (this.regexp_eatGroupName(state)) {
@@ -3608,8 +4023,8 @@
     }
   };
 
-  // GroupName[U] ::
-  //   `<` RegExpIdentifierName[?U] `>`
+  // GroupName ::
+  //   `<` RegExpIdentifierName `>`
   // Note: this updates `state.lastStringValue` property with the eaten name.
   pp$8.regexp_eatGroupName = function(state) {
     state.lastStringValue = "";
@@ -3622,9 +4037,9 @@
     return false
   };
 
-  // RegExpIdentifierName[U] ::
-  //   RegExpIdentifierStart[?U]
-  //   RegExpIdentifierName[?U] RegExpIdentifierPart[?U]
+  // RegExpIdentifierName ::
+  //   RegExpIdentifierStart
+  //   RegExpIdentifierName RegExpIdentifierPart
   // Note: this updates `state.lastStringValue` property with the eaten name.
   pp$8.regexp_eatRegExpIdentifierName = function(state) {
     state.lastStringValue = "";
@@ -3638,17 +4053,18 @@
     return false
   };
 
-  // RegExpIdentifierStart[U] ::
+  // RegExpIdentifierStart ::
   //   UnicodeIDStart
   //   `$`
   //   `_`
-  //   `\` RegExpUnicodeEscapeSequence[?U]
+  //   `\` RegExpUnicodeEscapeSequence[+U]
   pp$8.regexp_eatRegExpIdentifierStart = function(state) {
     var start = state.pos;
-    var ch = state.current();
-    state.advance();
+    var forceU = this.options.ecmaVersion >= 11;
+    var ch = state.current(forceU);
+    state.advance(forceU);
 
-    if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
+    if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {
       ch = state.lastIntValue;
     }
     if (isRegExpIdentifierStart(ch)) {
@@ -3663,19 +4079,20 @@
     return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */
   }
 
-  // RegExpIdentifierPart[U] ::
+  // RegExpIdentifierPart ::
   //   UnicodeIDContinue
   //   `$`
   //   `_`
-  //   `\` RegExpUnicodeEscapeSequence[?U]
+  //   `\` RegExpUnicodeEscapeSequence[+U]
   //   <ZWNJ>
   //   <ZWJ>
   pp$8.regexp_eatRegExpIdentifierPart = function(state) {
     var start = state.pos;
-    var ch = state.current();
-    state.advance();
+    var forceU = this.options.ecmaVersion >= 11;
+    var ch = state.current(forceU);
+    state.advance(forceU);
 
-    if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
+    if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {
       ch = state.lastIntValue;
     }
     if (isRegExpIdentifierPart(ch)) {
@@ -3745,7 +4162,7 @@
       this.regexp_eatCControlLetter(state) ||
       this.regexp_eatZero(state) ||
       this.regexp_eatHexEscapeSequence(state) ||
-      this.regexp_eatRegExpUnicodeEscapeSequence(state) ||
+      this.regexp_eatRegExpUnicodeEscapeSequence(state, false) ||
       (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||
       this.regexp_eatIdentityEscape(state)
     )
@@ -3818,13 +4235,16 @@
   }
 
   // https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence
-  pp$8.regexp_eatRegExpUnicodeEscapeSequence = function(state) {
+  pp$8.regexp_eatRegExpUnicodeEscapeSequence = function(state, forceU) {
+    if ( forceU === void 0 ) forceU = false;
+
     var start = state.pos;
+    var switchU = forceU || state.switchU;
 
     if (state.eat(0x75 /* u */)) {
       if (this.regexp_eatFixedHexDigits(state, 4)) {
         var lead = state.lastIntValue;
-        if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {
+        if (switchU && lead >= 0xD800 && lead <= 0xDBFF) {
           var leadSurrogateEnd = state.pos;
           if (state.eat(0x5C /* \ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) {
             var trail = state.lastIntValue;
@@ -3839,7 +4259,7 @@
         return true
       }
       if (
-        state.switchU &&
+        switchU &&
         state.eat(0x7B /* { */) &&
         this.regexp_eatHexDigits(state) &&
         state.eat(0x7D /* } */) &&
@@ -3847,7 +4267,7 @@
       ) {
         return true
       }
-      if (state.switchU) {
+      if (switchU) {
         state.raise("Invalid unicode escape");
       }
       state.pos = start;
@@ -4307,9 +4727,9 @@
 
   pp$9.fullCharCodeAtPos = function() {
     var code = this.input.charCodeAt(this.pos);
-    if (code <= 0xd7ff || code >= 0xe000) { return code }
+    if (code <= 0xd7ff || code >= 0xdc00) { return code }
     var next = this.input.charCodeAt(this.pos + 1);
-    return (code << 10) + next - 0x35fdc00
+    return next <= 0xdbff || next >= 0xe000 ? code : (code << 10) + next - 0x35fdc00
   };
 
   pp$9.skipBlockComment = function() {
@@ -4447,7 +4867,13 @@
 
   pp$9.readToken_pipe_amp = function(code) { // '|&'
     var next = this.input.charCodeAt(this.pos + 1);
-    if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2) }
+    if (next === code) {
+      if (this.options.ecmaVersion >= 12) {
+        var next2 = this.input.charCodeAt(this.pos + 2);
+        if (next2 === 61) { return this.finishOp(types.assign, 3) }
+      }
+      return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2)
+    }
     if (next === 61) { return this.finishOp(types.assign, 2) }
     return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
   };
@@ -4503,6 +4929,39 @@
     return this.finishOp(code === 61 ? types.eq : types.prefix, 1)
   };
 
+  pp$9.readToken_question = function() { // '?'
+    var ecmaVersion = this.options.ecmaVersion;
+    if (ecmaVersion >= 11) {
+      var next = this.input.charCodeAt(this.pos + 1);
+      if (next === 46) {
+        var next2 = this.input.charCodeAt(this.pos + 2);
+        if (next2 < 48 || next2 > 57) { return this.finishOp(types.questionDot, 2) }
+      }
+      if (next === 63) {
+        if (ecmaVersion >= 12) {
+          var next2$1 = this.input.charCodeAt(this.pos + 2);
+          if (next2$1 === 61) { return this.finishOp(types.assign, 3) }
+        }
+        return this.finishOp(types.coalesce, 2)
+      }
+    }
+    return this.finishOp(types.question, 1)
+  };
+
+  pp$9.readToken_numberSign = function() { // '#'
+    var ecmaVersion = this.options.ecmaVersion;
+    var code = 35; // '#'
+    if (ecmaVersion >= 13) {
+      ++this.pos;
+      code = this.fullCharCodeAtPos();
+      if (isIdentifierStart(code, true) || code === 92 /* '\' */) {
+        return this.finishToken(types.privateId, this.readWord1())
+      }
+    }
+
+    this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+  };
+
   pp$9.getTokenFromCode = function(code) {
     switch (code) {
     // The interpretation of a dot depends on whether it is followed
@@ -4520,7 +4979,6 @@
     case 123: ++this.pos; return this.finishToken(types.braceL)
     case 125: ++this.pos; return this.finishToken(types.braceR)
     case 58: ++this.pos; return this.finishToken(types.colon)
-    case 63: ++this.pos; return this.finishToken(types.question)
 
     case 96: // '`'
       if (this.options.ecmaVersion < 6) { break }
@@ -4570,8 +5028,14 @@
     case 61: case 33: // '=!'
       return this.readToken_eq_excl(code)
 
+    case 63: // '?'
+      return this.readToken_question()
+
     case 126: // '~'
       return this.finishOp(types.prefix, 1)
+
+    case 35: // '#'
+      return this.readToken_numberSign()
     }
 
     this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
@@ -4625,30 +5089,67 @@
   // were read, the integer value otherwise. When `len` is given, this
   // will return `null` unless the integer has exactly `len` digits.
 
-  pp$9.readInt = function(radix, len) {
-    var start = this.pos, total = 0;
-    for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+  pp$9.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
+    // `len` is used for character escape sequences. In that case, disallow separators.
+    var allowSeparators = this.options.ecmaVersion >= 12 && len === undefined;
+
+    // `maybeLegacyOctalNumericLiteral` is true if it doesn't have prefix (0x,0o,0b)
+    // and isn't fraction part nor exponent part. In that case, if the first digit
+    // is zero then disallow separators.
+    var isLegacyOctalNumericLiteral = maybeLegacyOctalNumericLiteral && this.input.charCodeAt(this.pos) === 48;
+
+    var start = this.pos, total = 0, lastCode = 0;
+    for (var i = 0, e = len == null ? Infinity : len; i < e; ++i, ++this.pos) {
       var code = this.input.charCodeAt(this.pos), val = (void 0);
+
+      if (allowSeparators && code === 95) {
+        if (isLegacyOctalNumericLiteral) { this.raiseRecoverable(this.pos, "Numeric separator is not allowed in legacy octal numeric literals"); }
+        if (lastCode === 95) { this.raiseRecoverable(this.pos, "Numeric separator must be exactly one underscore"); }
+        if (i === 0) { this.raiseRecoverable(this.pos, "Numeric separator is not allowed at the first of digits"); }
+        lastCode = code;
+        continue
+      }
+
       if (code >= 97) { val = code - 97 + 10; } // a
       else if (code >= 65) { val = code - 65 + 10; } // A
       else if (code >= 48 && code <= 57) { val = code - 48; } // 0-9
       else { val = Infinity; }
       if (val >= radix) { break }
-      ++this.pos;
+      lastCode = code;
       total = total * radix + val;
     }
+
+    if (allowSeparators && lastCode === 95) { this.raiseRecoverable(this.pos - 1, "Numeric separator is not allowed at the last of digits"); }
     if (this.pos === start || len != null && this.pos - start !== len) { return null }
 
     return total
   };
 
+  function stringToNumber(str, isLegacyOctalNumericLiteral) {
+    if (isLegacyOctalNumericLiteral) {
+      return parseInt(str, 8)
+    }
+
+    // `parseFloat(value)` stops parsing at the first numeric separator then returns a wrong value.
+    return parseFloat(str.replace(/_/g, ""))
+  }
+
+  function stringToBigInt(str) {
+    if (typeof BigInt !== "function") {
+      return null
+    }
+
+    // `BigInt(value)` throws syntax error if the string contains numeric separators.
+    return BigInt(str.replace(/_/g, ""))
+  }
+
   pp$9.readRadixNumber = function(radix) {
     var start = this.pos;
     this.pos += 2; // 0x
     var val = this.readInt(radix);
     if (val == null) { this.raise(this.start + 2, "Expected number in radix " + radix); }
     if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {
-      val = typeof BigInt !== "undefined" ? BigInt(this.input.slice(start, this.pos)) : null;
+      val = stringToBigInt(this.input.slice(start, this.pos));
       ++this.pos;
     } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
     return this.finishToken(types.num, val)
@@ -4658,13 +5159,12 @@
 
   pp$9.readNumber = function(startsWithDot) {
     var start = this.pos;
-    if (!startsWithDot && this.readInt(10) === null) { this.raise(start, "Invalid number"); }
+    if (!startsWithDot && this.readInt(10, undefined, true) === null) { this.raise(start, "Invalid number"); }
     var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
     if (octal && this.strict) { this.raise(start, "Invalid number"); }
     var next = this.input.charCodeAt(this.pos);
     if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {
-      var str$1 = this.input.slice(start, this.pos);
-      var val$1 = typeof BigInt !== "undefined" ? BigInt(str$1) : null;
+      var val$1 = stringToBigInt(this.input.slice(start, this.pos));
       ++this.pos;
       if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
       return this.finishToken(types.num, val$1)
@@ -4682,8 +5182,7 @@
     }
     if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
 
-    var str = this.input.slice(start, this.pos);
-    var val = octal ? parseInt(str, 8) : parseFloat(str);
+    var val = stringToNumber(this.input.slice(start, this.pos), octal);
     return this.finishToken(types.num, val)
   };
 
@@ -4846,6 +5345,12 @@
       return ""
     case 56:
     case 57:
+      if (this.strict) {
+        this.invalidStringToken(
+          this.pos - 1,
+          "Invalid escape sequence"
+        );
+      }
       if (inTemplate) {
         var codePos = this.pos - 1;
 
@@ -4942,7 +5447,7 @@
 
   // Acorn is a tiny, fast JavaScript parser written in JavaScript.
 
-  var version = "7.1.0";
+  var version = "8.4.1";
 
   Parser.acorn = {
     Parser: Parser,
@@ -5017,4 +5522,4 @@
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-}));
+})));
diff --git a/deps/acorn/acorn/dist/acorn.mjs b/deps/acorn/acorn/dist/acorn.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..30833d4fdf9f75e238f2e037439163faaffaa459
--- /dev/null
+++ b/deps/acorn/acorn/dist/acorn.mjs
@@ -0,0 +1,5494 @@
+// Reserved word lists for various dialects of the language
+
+var reservedWords = {
+  3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
+  5: "class enum extends super const export import",
+  6: "enum",
+  strict: "implements interface let package private protected public static yield",
+  strictBind: "eval arguments"
+};
+
+// And the keywords
+
+var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
+
+var keywords = {
+  5: ecma5AndLessKeywords,
+  "5module": ecma5AndLessKeywords + " export import",
+  6: ecma5AndLessKeywords + " const class extends export import super"
+};
+
+var keywordRelationalOperator = /^in(stanceof)?$/;
+
+// ## Character categories
+
+// Big ugly regular expressions that match characters in the
+// whitespace, identifier, and identifier-start categories. These
+// are only applied when a character is found to actually have a
+// code point above 128.
+// Generated by `bin/generate-identifier-regex.js`.
+var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08c7\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\u9ffc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7ca\ua7f5-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf\u1ac0\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+
+var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+
+// These are a run-length and offset encoded representation of the
+// >0xffff code points that are a valid part of identifiers. The
+// offset starts at 0x10000, and each pair of numbers represents an
+// offset to the next range, and then a size of the range. They were
+// generated by bin/generate-identifier-regex.js
+
+// eslint-disable-next-line comma-spacing
+var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,349,41,7,1,79,28,11,0,9,21,107,20,28,22,13,52,76,44,33,24,27,35,30,0,3,0,9,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,2,31,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,230,43,117,63,32,7,3,0,3,7,2,1,2,23,16,0,2,0,95,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,190,0,80,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,1237,43,8,8952,286,50,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,2357,44,11,6,17,0,370,43,1301,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42717,35,4148,12,221,3,5761,15,7472,3104,541,1507,4938];
+
+// eslint-disable-next-line comma-spacing
+var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,370,1,154,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,2,11,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,71,5,2,1,3,3,2,0,2,1,13,9,120,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1014,0,2,54,8,3,82,0,12,1,19628,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,419,13,1495,6,110,6,6,9,4759,9,787719,239];
+
+// This has a complexity linear to the value of the code. The
+// assumption is that looking up astral identifier characters is
+// rare.
+function isInAstralSet(code, set) {
+  var pos = 0x10000;
+  for (var i = 0; i < set.length; i += 2) {
+    pos += set[i];
+    if (pos > code) { return false }
+    pos += set[i + 1];
+    if (pos >= code) { return true }
+  }
+}
+
+// Test whether a given character code starts an identifier.
+
+function isIdentifierStart(code, astral) {
+  if (code < 65) { return code === 36 }
+  if (code < 91) { return true }
+  if (code < 97) { return code === 95 }
+  if (code < 123) { return true }
+  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }
+  if (astral === false) { return false }
+  return isInAstralSet(code, astralIdentifierStartCodes)
+}
+
+// Test whether a given character is part of an identifier.
+
+function isIdentifierChar(code, astral) {
+  if (code < 48) { return code === 36 }
+  if (code < 58) { return true }
+  if (code < 65) { return false }
+  if (code < 91) { return true }
+  if (code < 97) { return code === 95 }
+  if (code < 123) { return true }
+  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }
+  if (astral === false) { return false }
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)
+}
+
+// ## Token types
+
+// The assignment of fine-grained, information-carrying type objects
+// allows the tokenizer to store the information it has about a
+// token in a way that is very cheap for the parser to look up.
+
+// All token type variables start with an underscore, to make them
+// easy to recognize.
+
+// The `beforeExpr` property is used to disambiguate between regular
+// expressions and divisions. It is set on all token types that can
+// be followed by an expression (thus, a slash after them would be a
+// regular expression).
+//
+// The `startsExpr` property is used to check if the token ends a
+// `yield` expression. It is set on all token types that either can
+// directly start an expression (like a quotation mark) or can
+// continue an expression (like the body of a string).
+//
+// `isLoop` marks a keyword as starting a loop, which is important
+// to know when parsing a label, in order to allow or disallow
+// continue jumps to that label.
+
+var TokenType = function TokenType(label, conf) {
+  if ( conf === void 0 ) conf = {};
+
+  this.label = label;
+  this.keyword = conf.keyword;
+  this.beforeExpr = !!conf.beforeExpr;
+  this.startsExpr = !!conf.startsExpr;
+  this.isLoop = !!conf.isLoop;
+  this.isAssign = !!conf.isAssign;
+  this.prefix = !!conf.prefix;
+  this.postfix = !!conf.postfix;
+  this.binop = conf.binop || null;
+  this.updateContext = null;
+};
+
+function binop(name, prec) {
+  return new TokenType(name, {beforeExpr: true, binop: prec})
+}
+var beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true};
+
+// Map keyword names to token types.
+
+var keywords$1 = {};
+
+// Succinct definitions of keyword token types
+function kw(name, options) {
+  if ( options === void 0 ) options = {};
+
+  options.keyword = name;
+  return keywords$1[name] = new TokenType(name, options)
+}
+
+var types = {
+  num: new TokenType("num", startsExpr),
+  regexp: new TokenType("regexp", startsExpr),
+  string: new TokenType("string", startsExpr),
+  name: new TokenType("name", startsExpr),
+  privateId: new TokenType("privateId", startsExpr),
+  eof: new TokenType("eof"),
+
+  // Punctuation token types.
+  bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
+  bracketR: new TokenType("]"),
+  braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
+  braceR: new TokenType("}"),
+  parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
+  parenR: new TokenType(")"),
+  comma: new TokenType(",", beforeExpr),
+  semi: new TokenType(";", beforeExpr),
+  colon: new TokenType(":", beforeExpr),
+  dot: new TokenType("."),
+  question: new TokenType("?", beforeExpr),
+  questionDot: new TokenType("?."),
+  arrow: new TokenType("=>", beforeExpr),
+  template: new TokenType("template"),
+  invalidTemplate: new TokenType("invalidTemplate"),
+  ellipsis: new TokenType("...", beforeExpr),
+  backQuote: new TokenType("`", startsExpr),
+  dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),
+
+  // Operators. These carry several kinds of properties to help the
+  // parser use them properly (the presence of these properties is
+  // what categorizes them as operators).
+  //
+  // `binop`, when present, specifies that this operator is a binary
+  // operator, and will refer to its precedence.
+  //
+  // `prefix` and `postfix` mark the operator as a prefix or postfix
+  // unary operator.
+  //
+  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
+  // binary operators with a very low precedence, that should result
+  // in AssignmentExpression nodes.
+
+  eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
+  assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
+  incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
+  prefix: new TokenType("!/~", {beforeExpr: true, prefix: true, startsExpr: true}),
+  logicalOR: binop("||", 1),
+  logicalAND: binop("&&", 2),
+  bitwiseOR: binop("|", 3),
+  bitwiseXOR: binop("^", 4),
+  bitwiseAND: binop("&", 5),
+  equality: binop("==/!=/===/!==", 6),
+  relational: binop("</>/<=/>=", 7),
+  bitShift: binop("<</>>/>>>", 8),
+  plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
+  modulo: binop("%", 10),
+  star: binop("*", 10),
+  slash: binop("/", 10),
+  starstar: new TokenType("**", {beforeExpr: true}),
+  coalesce: binop("??", 1),
+
+  // Keyword token types.
+  _break: kw("break"),
+  _case: kw("case", beforeExpr),
+  _catch: kw("catch"),
+  _continue: kw("continue"),
+  _debugger: kw("debugger"),
+  _default: kw("default", beforeExpr),
+  _do: kw("do", {isLoop: true, beforeExpr: true}),
+  _else: kw("else", beforeExpr),
+  _finally: kw("finally"),
+  _for: kw("for", {isLoop: true}),
+  _function: kw("function", startsExpr),
+  _if: kw("if"),
+  _return: kw("return", beforeExpr),
+  _switch: kw("switch"),
+  _throw: kw("throw", beforeExpr),
+  _try: kw("try"),
+  _var: kw("var"),
+  _const: kw("const"),
+  _while: kw("while", {isLoop: true}),
+  _with: kw("with"),
+  _new: kw("new", {beforeExpr: true, startsExpr: true}),
+  _this: kw("this", startsExpr),
+  _super: kw("super", startsExpr),
+  _class: kw("class", startsExpr),
+  _extends: kw("extends", beforeExpr),
+  _export: kw("export"),
+  _import: kw("import", startsExpr),
+  _null: kw("null", startsExpr),
+  _true: kw("true", startsExpr),
+  _false: kw("false", startsExpr),
+  _in: kw("in", {beforeExpr: true, binop: 7}),
+  _instanceof: kw("instanceof", {beforeExpr: true, binop: 7}),
+  _typeof: kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true}),
+  _void: kw("void", {beforeExpr: true, prefix: true, startsExpr: true}),
+  _delete: kw("delete", {beforeExpr: true, prefix: true, startsExpr: true})
+};
+
+// Matches a whole line break (where CRLF is considered a single
+// line break). Used to count lines.
+
+var lineBreak = /\r\n?|\n|\u2028|\u2029/;
+var lineBreakG = new RegExp(lineBreak.source, "g");
+
+function isNewLine(code, ecma2019String) {
+  return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))
+}
+
+var nonASCIIwhitespace = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+
+var ref = Object.prototype;
+var hasOwnProperty = ref.hasOwnProperty;
+var toString = ref.toString;
+
+// Checks if an object has a property.
+
+function has(obj, propName) {
+  return hasOwnProperty.call(obj, propName)
+}
+
+var isArray = Array.isArray || (function (obj) { return (
+  toString.call(obj) === "[object Array]"
+); });
+
+function wordsRegexp(words) {
+  return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$")
+}
+
+// These are used when `options.locations` is on, for the
+// `startLoc` and `endLoc` properties.
+
+var Position = function Position(line, col) {
+  this.line = line;
+  this.column = col;
+};
+
+Position.prototype.offset = function offset (n) {
+  return new Position(this.line, this.column + n)
+};
+
+var SourceLocation = function SourceLocation(p, start, end) {
+  this.start = start;
+  this.end = end;
+  if (p.sourceFile !== null) { this.source = p.sourceFile; }
+};
+
+// The `getLineInfo` function is mostly useful when the
+// `locations` option is off (for performance reasons) and you
+// want to find the line/column position for a given character
+// offset. `input` should be the code string that the offset refers
+// into.
+
+function getLineInfo(input, offset) {
+  for (var line = 1, cur = 0;;) {
+    lineBreakG.lastIndex = cur;
+    var match = lineBreakG.exec(input);
+    if (match && match.index < offset) {
+      ++line;
+      cur = match.index + match[0].length;
+    } else {
+      return new Position(line, offset - cur)
+    }
+  }
+}
+
+// A second argument must be given to configure the parser process.
+// These options are recognized (only `ecmaVersion` is required):
+
+var defaultOptions = {
+  // `ecmaVersion` indicates the ECMAScript version to parse. Must be
+  // either 3, 5, 6 (or 2015), 7 (2016), 8 (2017), 9 (2018), 10
+  // (2019), 11 (2020), 12 (2021), 13 (2022), or `"latest"` (the
+  // latest version the library supports). This influences support
+  // for strict mode, the set of reserved words, and support for
+  // new syntax features.
+  ecmaVersion: null,
+  // `sourceType` indicates the mode the code should be parsed in.
+  // Can be either `"script"` or `"module"`. This influences global
+  // strict mode and parsing of `import` and `export` declarations.
+  sourceType: "script",
+  // `onInsertedSemicolon` can be a callback that will be called
+  // when a semicolon is automatically inserted. It will be passed
+  // the position of the comma as an offset, and if `locations` is
+  // enabled, it is given the location as a `{line, column}` object
+  // as second argument.
+  onInsertedSemicolon: null,
+  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
+  // trailing commas.
+  onTrailingComma: null,
+  // By default, reserved words are only enforced if ecmaVersion >= 5.
+  // Set `allowReserved` to a boolean value to explicitly turn this on
+  // an off. When this option has the value "never", reserved words
+  // and keywords can also not be used as property names.
+  allowReserved: null,
+  // When enabled, a return at the top level is not considered an
+  // error.
+  allowReturnOutsideFunction: false,
+  // When enabled, import/export statements are not constrained to
+  // appearing at the top of the program, and an import.meta expression
+  // in a script isn't considered an error.
+  allowImportExportEverywhere: false,
+  // By default, await identifiers are allowed to appear at the top-level scope only if ecmaVersion >= 2022.
+  // When enabled, await identifiers are allowed to appear at the top-level scope,
+  // but they are still not allowed in non-async functions.
+  allowAwaitOutsideFunction: null,
+  // When enabled, super identifiers are not constrained to
+  // appearing in methods and do not raise an error when they appear elsewhere.
+  allowSuperOutsideMethod: null,
+  // When enabled, hashbang directive in the beginning of file
+  // is allowed and treated as a line comment.
+  allowHashBang: false,
+  // When `locations` is on, `loc` properties holding objects with
+  // `start` and `end` properties in `{line, column}` form (with
+  // line being 1-based and column 0-based) will be attached to the
+  // nodes.
+  locations: false,
+  // A function can be passed as `onToken` option, which will
+  // cause Acorn to call that function with object in the same
+  // format as tokens returned from `tokenizer().getToken()`. Note
+  // that you are not allowed to call the parser from the
+  // callback—that will corrupt its internal state.
+  onToken: null,
+  // A function can be passed as `onComment` option, which will
+  // cause Acorn to call that function with `(block, text, start,
+  // end)` parameters whenever a comment is skipped. `block` is a
+  // boolean indicating whether this is a block (`/* */`) comment,
+  // `text` is the content of the comment, and `start` and `end` are
+  // character offsets that denote the start and end of the comment.
+  // When the `locations` option is on, two more parameters are
+  // passed, the full `{line, column}` locations of the start and
+  // end of the comments. Note that you are not allowed to call the
+  // parser from the callback—that will corrupt its internal state.
+  onComment: null,
+  // Nodes have their start and end characters offsets recorded in
+  // `start` and `end` properties (directly on the node, rather than
+  // the `loc` object, which holds line/column data. To also add a
+  // [semi-standardized][range] `range` property holding a `[start,
+  // end]` array with the same numbers, set the `ranges` option to
+  // `true`.
+  //
+  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+  ranges: false,
+  // It is possible to parse multiple files into a single AST by
+  // passing the tree produced by parsing the first file as
+  // `program` option in subsequent parses. This will add the
+  // toplevel forms of the parsed file to the `Program` (top) node
+  // of an existing parse tree.
+  program: null,
+  // When `locations` is on, you can pass this to record the source
+  // file in every node's `loc` object.
+  sourceFile: null,
+  // This value, if given, is stored in every node, whether
+  // `locations` is on or off.
+  directSourceFile: null,
+  // When enabled, parenthesized expressions are represented by
+  // (non-standard) ParenthesizedExpression nodes
+  preserveParens: false
+};
+
+// Interpret and default an options object
+
+var warnedAboutEcmaVersion = false;
+
+function getOptions(opts) {
+  var options = {};
+
+  for (var opt in defaultOptions)
+    { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }
+
+  if (options.ecmaVersion === "latest") {
+    options.ecmaVersion = 1e8;
+  } else if (options.ecmaVersion == null) {
+    if (!warnedAboutEcmaVersion && typeof console === "object" && console.warn) {
+      warnedAboutEcmaVersion = true;
+      console.warn("Since Acorn 8.0.0, options.ecmaVersion is required.\nDefaulting to 2020, but this will stop working in the future.");
+    }
+    options.ecmaVersion = 11;
+  } else if (options.ecmaVersion >= 2015) {
+    options.ecmaVersion -= 2009;
+  }
+
+  if (options.allowReserved == null)
+    { options.allowReserved = options.ecmaVersion < 5; }
+
+  if (isArray(options.onToken)) {
+    var tokens = options.onToken;
+    options.onToken = function (token) { return tokens.push(token); };
+  }
+  if (isArray(options.onComment))
+    { options.onComment = pushComment(options, options.onComment); }
+
+  return options
+}
+
+function pushComment(options, array) {
+  return function(block, text, start, end, startLoc, endLoc) {
+    var comment = {
+      type: block ? "Block" : "Line",
+      value: text,
+      start: start,
+      end: end
+    };
+    if (options.locations)
+      { comment.loc = new SourceLocation(this, startLoc, endLoc); }
+    if (options.ranges)
+      { comment.range = [start, end]; }
+    array.push(comment);
+  }
+}
+
+// Each scope gets a bitset that may contain these flags
+var
+    SCOPE_TOP = 1,
+    SCOPE_FUNCTION = 2,
+    SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION,
+    SCOPE_ASYNC = 4,
+    SCOPE_GENERATOR = 8,
+    SCOPE_ARROW = 16,
+    SCOPE_SIMPLE_CATCH = 32,
+    SCOPE_SUPER = 64,
+    SCOPE_DIRECT_SUPER = 128;
+
+function functionFlags(async, generator) {
+  return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)
+}
+
+// Used in checkLVal* and declareName to determine the type of a binding
+var
+    BIND_NONE = 0, // Not a binding
+    BIND_VAR = 1, // Var-style binding
+    BIND_LEXICAL = 2, // Let- or const-style binding
+    BIND_FUNCTION = 3, // Function declaration
+    BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding
+    BIND_OUTSIDE = 5; // Special case for function names as bound inside the function
+
+var Parser = function Parser(options, input, startPos) {
+  this.options = options = getOptions(options);
+  this.sourceFile = options.sourceFile;
+  this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
+  var reserved = "";
+  if (options.allowReserved !== true) {
+    reserved = reservedWords[options.ecmaVersion >= 6 ? 6 : options.ecmaVersion === 5 ? 5 : 3];
+    if (options.sourceType === "module") { reserved += " await"; }
+  }
+  this.reservedWords = wordsRegexp(reserved);
+  var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict;
+  this.reservedWordsStrict = wordsRegexp(reservedStrict);
+  this.reservedWordsStrictBind = wordsRegexp(reservedStrict + " " + reservedWords.strictBind);
+  this.input = String(input);
+
+  // Used to signal to callers of `readWord1` whether the word
+  // contained any escape sequences. This is needed because words with
+  // escape sequences must not be interpreted as keywords.
+  this.containsEsc = false;
+
+  // Set up token state
+
+  // The current position of the tokenizer in the input.
+  if (startPos) {
+    this.pos = startPos;
+    this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
+    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
+  } else {
+    this.pos = this.lineStart = 0;
+    this.curLine = 1;
+  }
+
+  // Properties of the current token:
+  // Its type
+  this.type = types.eof;
+  // For tokens that include more information than their type, the value
+  this.value = null;
+  // Its start and end offset
+  this.start = this.end = this.pos;
+  // And, if locations are used, the {line, column} object
+  // corresponding to those offsets
+  this.startLoc = this.endLoc = this.curPosition();
+
+  // Position information for the previous token
+  this.lastTokEndLoc = this.lastTokStartLoc = null;
+  this.lastTokStart = this.lastTokEnd = this.pos;
+
+  // The context stack is used to superficially track syntactic
+  // context to predict whether a regular expression is allowed in a
+  // given position.
+  this.context = this.initialContext();
+  this.exprAllowed = true;
+
+  // Figure out if it's a module code.
+  this.inModule = options.sourceType === "module";
+  this.strict = this.inModule || this.strictDirective(this.pos);
+
+  // Used to signify the start of a potential arrow function
+  this.potentialArrowAt = -1;
+  this.potentialArrowInForAwait = false;
+
+  // Positions to delayed-check that yield/await does not exist in default parameters.
+  this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;
+  // Labels in scope.
+  this.labels = [];
+  // Thus-far undefined exports.
+  this.undefinedExports = Object.create(null);
+
+  // If enabled, skip leading hashbang line.
+  if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
+    { this.skipLineComment(2); }
+
+  // Scope tracking for duplicate variable names (see scope.js)
+  this.scopeStack = [];
+  this.enterScope(SCOPE_TOP);
+
+  // For RegExp validation
+  this.regexpState = null;
+
+  // The stack of private names.
+  // Each element has two properties: 'declared' and 'used'.
+  // When it exited from the outermost class definition, all used private names must be declared.
+  this.privateNameStack = [];
+};
+
+var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },canAwait: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true },inNonArrowFunction: { configurable: true } };
+
+Parser.prototype.parse = function parse () {
+  var node = this.options.program || this.startNode();
+  this.nextToken();
+  return this.parseTopLevel(node)
+};
+
+prototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };
+prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 && !this.currentVarScope().inClassFieldInit };
+prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 && !this.currentVarScope().inClassFieldInit };
+prototypeAccessors.canAwait.get = function () {
+  for (var i = this.scopeStack.length - 1; i >= 0; i--) {
+    var scope = this.scopeStack[i];
+    if (scope.inClassFieldInit) { return false }
+    if (scope.flags & SCOPE_FUNCTION) { return (scope.flags & SCOPE_ASYNC) > 0 }
+  }
+  return (this.inModule && this.options.ecmaVersion >= 13) || this.options.allowAwaitOutsideFunction
+};
+prototypeAccessors.allowSuper.get = function () {
+  var ref = this.currentThisScope();
+    var flags = ref.flags;
+    var inClassFieldInit = ref.inClassFieldInit;
+  return (flags & SCOPE_SUPER) > 0 || inClassFieldInit || this.options.allowSuperOutsideMethod
+};
+prototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };
+prototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };
+prototypeAccessors.inNonArrowFunction.get = function () {
+  var ref = this.currentThisScope();
+    var flags = ref.flags;
+    var inClassFieldInit = ref.inClassFieldInit;
+  return (flags & SCOPE_FUNCTION) > 0 || inClassFieldInit
+};
+
+Parser.extend = function extend () {
+    var plugins = [], len = arguments.length;
+    while ( len-- ) plugins[ len ] = arguments[ len ];
+
+  var cls = this;
+  for (var i = 0; i < plugins.length; i++) { cls = plugins[i](cls); }
+  return cls
+};
+
+Parser.parse = function parse (input, options) {
+  return new this(options, input).parse()
+};
+
+Parser.parseExpressionAt = function parseExpressionAt (input, pos, options) {
+  var parser = new this(options, input, pos);
+  parser.nextToken();
+  return parser.parseExpression()
+};
+
+Parser.tokenizer = function tokenizer (input, options) {
+  return new this(options, input)
+};
+
+Object.defineProperties( Parser.prototype, prototypeAccessors );
+
+var pp = Parser.prototype;
+
+// ## Parser utilities
+
+var literal = /^(?:'((?:\\.|[^'\\])*?)'|"((?:\\.|[^"\\])*?)")/;
+pp.strictDirective = function(start) {
+  for (;;) {
+    // Try to find string literal.
+    skipWhiteSpace.lastIndex = start;
+    start += skipWhiteSpace.exec(this.input)[0].length;
+    var match = literal.exec(this.input.slice(start));
+    if (!match) { return false }
+    if ((match[1] || match[2]) === "use strict") {
+      skipWhiteSpace.lastIndex = start + match[0].length;
+      var spaceAfter = skipWhiteSpace.exec(this.input), end = spaceAfter.index + spaceAfter[0].length;
+      var next = this.input.charAt(end);
+      return next === ";" || next === "}" ||
+        (lineBreak.test(spaceAfter[0]) &&
+         !(/[(`.[+\-/*%<>=,?^&]/.test(next) || next === "!" && this.input.charAt(end + 1) === "="))
+    }
+    start += match[0].length;
+
+    // Skip semicolon, if any.
+    skipWhiteSpace.lastIndex = start;
+    start += skipWhiteSpace.exec(this.input)[0].length;
+    if (this.input[start] === ";")
+      { start++; }
+  }
+};
+
+// Predicate that tests whether the next token is of the given
+// type, and if yes, consumes it as a side effect.
+
+pp.eat = function(type) {
+  if (this.type === type) {
+    this.next();
+    return true
+  } else {
+    return false
+  }
+};
+
+// Tests whether parsed token is a contextual keyword.
+
+pp.isContextual = function(name) {
+  return this.type === types.name && this.value === name && !this.containsEsc
+};
+
+// Consumes contextual keyword if possible.
+
+pp.eatContextual = function(name) {
+  if (!this.isContextual(name)) { return false }
+  this.next();
+  return true
+};
+
+// Asserts that following token is given contextual keyword.
+
+pp.expectContextual = function(name) {
+  if (!this.eatContextual(name)) { this.unexpected(); }
+};
+
+// Test whether a semicolon can be inserted at the current position.
+
+pp.canInsertSemicolon = function() {
+  return this.type === types.eof ||
+    this.type === types.braceR ||
+    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+};
+
+pp.insertSemicolon = function() {
+  if (this.canInsertSemicolon()) {
+    if (this.options.onInsertedSemicolon)
+      { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }
+    return true
+  }
+};
+
+// Consume a semicolon, or, failing that, see if we are allowed to
+// pretend that there is a semicolon at this position.
+
+pp.semicolon = function() {
+  if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
+};
+
+pp.afterTrailingComma = function(tokType, notNext) {
+  if (this.type === tokType) {
+    if (this.options.onTrailingComma)
+      { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }
+    if (!notNext)
+      { this.next(); }
+    return true
+  }
+};
+
+// Expect a token of a given type. If found, consume it, otherwise,
+// raise an unexpected token error.
+
+pp.expect = function(type) {
+  this.eat(type) || this.unexpected();
+};
+
+// Raise an unexpected token error.
+
+pp.unexpected = function(pos) {
+  this.raise(pos != null ? pos : this.start, "Unexpected token");
+};
+
+function DestructuringErrors() {
+  this.shorthandAssign =
+  this.trailingComma =
+  this.parenthesizedAssign =
+  this.parenthesizedBind =
+  this.doubleProto =
+    -1;
+}
+
+pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
+  if (!refDestructuringErrors) { return }
+  if (refDestructuringErrors.trailingComma > -1)
+    { this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); }
+  var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
+  if (parens > -1) { this.raiseRecoverable(parens, "Parenthesized pattern"); }
+};
+
+pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
+  if (!refDestructuringErrors) { return false }
+  var shorthandAssign = refDestructuringErrors.shorthandAssign;
+  var doubleProto = refDestructuringErrors.doubleProto;
+  if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }
+  if (shorthandAssign >= 0)
+    { this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns"); }
+  if (doubleProto >= 0)
+    { this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property"); }
+};
+
+pp.checkYieldAwaitInDefaultParams = function() {
+  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
+    { this.raise(this.yieldPos, "Yield expression cannot be a default value"); }
+  if (this.awaitPos)
+    { this.raise(this.awaitPos, "Await expression cannot be a default value"); }
+};
+
+pp.isSimpleAssignTarget = function(expr) {
+  if (expr.type === "ParenthesizedExpression")
+    { return this.isSimpleAssignTarget(expr.expression) }
+  return expr.type === "Identifier" || expr.type === "MemberExpression"
+};
+
+var pp$1 = Parser.prototype;
+
+// ### Statement parsing
+
+// Parse a program. Initializes the parser, reads any number of
+// statements, and wraps them in a Program node.  Optionally takes a
+// `program` argument.  If present, the statements will be appended
+// to its body instead of creating a new node.
+
+pp$1.parseTopLevel = function(node) {
+  var exports = Object.create(null);
+  if (!node.body) { node.body = []; }
+  while (this.type !== types.eof) {
+    var stmt = this.parseStatement(null, true, exports);
+    node.body.push(stmt);
+  }
+  if (this.inModule)
+    { for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1)
+      {
+        var name = list[i];
+
+        this.raiseRecoverable(this.undefinedExports[name].start, ("Export '" + name + "' is not defined"));
+      } }
+  this.adaptDirectivePrologue(node.body);
+  this.next();
+  node.sourceType = this.options.sourceType;
+  return this.finishNode(node, "Program")
+};
+
+var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+pp$1.isLet = function(context) {
+  if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false }
+  skipWhiteSpace.lastIndex = this.pos;
+  var skip = skipWhiteSpace.exec(this.input);
+  var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
+  // For ambiguous cases, determine if a LexicalDeclaration (or only a
+  // Statement) is allowed here. If context is not empty then only a Statement
+  // is allowed. However, `let [` is an explicit negative lookahead for
+  // ExpressionStatement, so special-case it first.
+  if (nextCh === 91 || nextCh === 92 || nextCh > 0xd7ff && nextCh < 0xdc00) { return true } // '[', '/', astral
+  if (context) { return false }
+
+  if (nextCh === 123) { return true } // '{'
+  if (isIdentifierStart(nextCh, true)) {
+    var pos = next + 1;
+    while (isIdentifierChar(nextCh = this.input.charCodeAt(pos), true)) { ++pos; }
+    if (nextCh === 92 || nextCh > 0xd7ff && nextCh < 0xdc00) { return true }
+    var ident = this.input.slice(next, pos);
+    if (!keywordRelationalOperator.test(ident)) { return true }
+  }
+  return false
+};
+
+// check 'async [no LineTerminator here] function'
+// - 'async /*foo*/ function' is OK.
+// - 'async /*\n*/ function' is invalid.
+pp$1.isAsyncFunction = function() {
+  if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
+    { return false }
+
+  skipWhiteSpace.lastIndex = this.pos;
+  var skip = skipWhiteSpace.exec(this.input);
+  var next = this.pos + skip[0].length, after;
+  return !lineBreak.test(this.input.slice(this.pos, next)) &&
+    this.input.slice(next, next + 8) === "function" &&
+    (next + 8 === this.input.length ||
+     !(isIdentifierChar(after = this.input.charCodeAt(next + 8)) || after > 0xd7ff && after < 0xdc00))
+};
+
+// Parse a single statement.
+//
+// If expecting a statement and finding a slash operator, parse a
+// regular expression literal. This is to handle cases like
+// `if (foo) /blah/.exec(foo)`, where looking at the previous token
+// does not help.
+
+pp$1.parseStatement = function(context, topLevel, exports) {
+  var starttype = this.type, node = this.startNode(), kind;
+
+  if (this.isLet(context)) {
+    starttype = types._var;
+    kind = "let";
+  }
+
+  // Most types of statements are recognized by the keyword they
+  // start with. Many are trivial to parse, some require a bit of
+  // complexity.
+
+  switch (starttype) {
+  case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
+  case types._debugger: return this.parseDebuggerStatement(node)
+  case types._do: return this.parseDoStatement(node)
+  case types._for: return this.parseForStatement(node)
+  case types._function:
+    // Function as sole body of either an if statement or a labeled statement
+    // works, but not when it is part of a labeled statement that is the sole
+    // body of an if statement.
+    if ((context && (this.strict || context !== "if" && context !== "label")) && this.options.ecmaVersion >= 6) { this.unexpected(); }
+    return this.parseFunctionStatement(node, false, !context)
+  case types._class:
+    if (context) { this.unexpected(); }
+    return this.parseClass(node, true)
+  case types._if: return this.parseIfStatement(node)
+  case types._return: return this.parseReturnStatement(node)
+  case types._switch: return this.parseSwitchStatement(node)
+  case types._throw: return this.parseThrowStatement(node)
+  case types._try: return this.parseTryStatement(node)
+  case types._const: case types._var:
+    kind = kind || this.value;
+    if (context && kind !== "var") { this.unexpected(); }
+    return this.parseVarStatement(node, kind)
+  case types._while: return this.parseWhileStatement(node)
+  case types._with: return this.parseWithStatement(node)
+  case types.braceL: return this.parseBlock(true, node)
+  case types.semi: return this.parseEmptyStatement(node)
+  case types._export:
+  case types._import:
+    if (this.options.ecmaVersion > 10 && starttype === types._import) {
+      skipWhiteSpace.lastIndex = this.pos;
+      var skip = skipWhiteSpace.exec(this.input);
+      var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
+      if (nextCh === 40 || nextCh === 46) // '(' or '.'
+        { return this.parseExpressionStatement(node, this.parseExpression()) }
+    }
+
+    if (!this.options.allowImportExportEverywhere) {
+      if (!topLevel)
+        { this.raise(this.start, "'import' and 'export' may only appear at the top level"); }
+      if (!this.inModule)
+        { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
+    }
+    return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)
+
+    // If the statement does not start with a statement keyword or a
+    // brace, it's an ExpressionStatement or LabeledStatement. We
+    // simply start parsing an expression, and afterwards, if the
+    // next token is a colon and the expression was a simple
+    // Identifier node, we switch to interpreting it as a label.
+  default:
+    if (this.isAsyncFunction()) {
+      if (context) { this.unexpected(); }
+      this.next();
+      return this.parseFunctionStatement(node, true, !context)
+    }
+
+    var maybeName = this.value, expr = this.parseExpression();
+    if (starttype === types.name && expr.type === "Identifier" && this.eat(types.colon))
+      { return this.parseLabeledStatement(node, maybeName, expr, context) }
+    else { return this.parseExpressionStatement(node, expr) }
+  }
+};
+
+pp$1.parseBreakContinueStatement = function(node, keyword) {
+  var isBreak = keyword === "break";
+  this.next();
+  if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }
+  else if (this.type !== types.name) { this.unexpected(); }
+  else {
+    node.label = this.parseIdent();
+    this.semicolon();
+  }
+
+  // Verify that there is an actual destination to break or
+  // continue to.
+  var i = 0;
+  for (; i < this.labels.length; ++i) {
+    var lab = this.labels[i];
+    if (node.label == null || lab.name === node.label.name) {
+      if (lab.kind != null && (isBreak || lab.kind === "loop")) { break }
+      if (node.label && isBreak) { break }
+    }
+  }
+  if (i === this.labels.length) { this.raise(node.start, "Unsyntactic " + keyword); }
+  return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
+};
+
+pp$1.parseDebuggerStatement = function(node) {
+  this.next();
+  this.semicolon();
+  return this.finishNode(node, "DebuggerStatement")
+};
+
+pp$1.parseDoStatement = function(node) {
+  this.next();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement("do");
+  this.labels.pop();
+  this.expect(types._while);
+  node.test = this.parseParenExpression();
+  if (this.options.ecmaVersion >= 6)
+    { this.eat(types.semi); }
+  else
+    { this.semicolon(); }
+  return this.finishNode(node, "DoWhileStatement")
+};
+
+// Disambiguating between a `for` and a `for`/`in` or `for`/`of`
+// loop is non-trivial. Basically, we have to parse the init `var`
+// statement or expression, disallowing the `in` operator (see
+// the second parameter to `parseExpression`), and then check
+// whether the next token is `in` or `of`. When there is no init
+// part (semicolon immediately after the opening parenthesis), it
+// is a regular `for` loop.
+
+pp$1.parseForStatement = function(node) {
+  this.next();
+  var awaitAt = (this.options.ecmaVersion >= 9 && this.canAwait && this.eatContextual("await")) ? this.lastTokStart : -1;
+  this.labels.push(loopLabel);
+  this.enterScope(0);
+  this.expect(types.parenL);
+  if (this.type === types.semi) {
+    if (awaitAt > -1) { this.unexpected(awaitAt); }
+    return this.parseFor(node, null)
+  }
+  var isLet = this.isLet();
+  if (this.type === types._var || this.type === types._const || isLet) {
+    var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
+    this.next();
+    this.parseVar(init$1, true, kind);
+    this.finishNode(init$1, "VariableDeclaration");
+    if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1) {
+      if (this.options.ecmaVersion >= 9) {
+        if (this.type === types._in) {
+          if (awaitAt > -1) { this.unexpected(awaitAt); }
+        } else { node.await = awaitAt > -1; }
+      }
+      return this.parseForIn(node, init$1)
+    }
+    if (awaitAt > -1) { this.unexpected(awaitAt); }
+    return this.parseFor(node, init$1)
+  }
+  var refDestructuringErrors = new DestructuringErrors;
+  var init = this.parseExpression(awaitAt > -1 ? "await" : true, refDestructuringErrors);
+  if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+    if (this.options.ecmaVersion >= 9) {
+      if (this.type === types._in) {
+        if (awaitAt > -1) { this.unexpected(awaitAt); }
+      } else { node.await = awaitAt > -1; }
+    }
+    this.toAssignable(init, false, refDestructuringErrors);
+    this.checkLValPattern(init);
+    return this.parseForIn(node, init)
+  } else {
+    this.checkExpressionErrors(refDestructuringErrors, true);
+  }
+  if (awaitAt > -1) { this.unexpected(awaitAt); }
+  return this.parseFor(node, init)
+};
+
+pp$1.parseFunctionStatement = function(node, isAsync, declarationPosition) {
+  this.next();
+  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
+};
+
+pp$1.parseIfStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  // allow function declarations in branches, but only in non-strict mode
+  node.consequent = this.parseStatement("if");
+  node.alternate = this.eat(types._else) ? this.parseStatement("if") : null;
+  return this.finishNode(node, "IfStatement")
+};
+
+pp$1.parseReturnStatement = function(node) {
+  if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+    { this.raise(this.start, "'return' outside of function"); }
+  this.next();
+
+  // In `return` (and `break`/`continue`), the keywords with
+  // optional arguments, we eagerly look for a semicolon or the
+  // possibility to insert one.
+
+  if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }
+  else { node.argument = this.parseExpression(); this.semicolon(); }
+  return this.finishNode(node, "ReturnStatement")
+};
+
+pp$1.parseSwitchStatement = function(node) {
+  this.next();
+  node.discriminant = this.parseParenExpression();
+  node.cases = [];
+  this.expect(types.braceL);
+  this.labels.push(switchLabel);
+  this.enterScope(0);
+
+  // Statements under must be grouped (by label) in SwitchCase
+  // nodes. `cur` is used to keep the node that we are currently
+  // adding statements to.
+
+  var cur;
+  for (var sawDefault = false; this.type !== types.braceR;) {
+    if (this.type === types._case || this.type === types._default) {
+      var isCase = this.type === types._case;
+      if (cur) { this.finishNode(cur, "SwitchCase"); }
+      node.cases.push(cur = this.startNode());
+      cur.consequent = [];
+      this.next();
+      if (isCase) {
+        cur.test = this.parseExpression();
+      } else {
+        if (sawDefault) { this.raiseRecoverable(this.lastTokStart, "Multiple default clauses"); }
+        sawDefault = true;
+        cur.test = null;
+      }
+      this.expect(types.colon);
+    } else {
+      if (!cur) { this.unexpected(); }
+      cur.consequent.push(this.parseStatement(null));
+    }
+  }
+  this.exitScope();
+  if (cur) { this.finishNode(cur, "SwitchCase"); }
+  this.next(); // Closing brace
+  this.labels.pop();
+  return this.finishNode(node, "SwitchStatement")
+};
+
+pp$1.parseThrowStatement = function(node) {
+  this.next();
+  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
+    { this.raise(this.lastTokEnd, "Illegal newline after throw"); }
+  node.argument = this.parseExpression();
+  this.semicolon();
+  return this.finishNode(node, "ThrowStatement")
+};
+
+// Reused empty array added for node fields that are always empty.
+
+var empty = [];
+
+pp$1.parseTryStatement = function(node) {
+  this.next();
+  node.block = this.parseBlock();
+  node.handler = null;
+  if (this.type === types._catch) {
+    var clause = this.startNode();
+    this.next();
+    if (this.eat(types.parenL)) {
+      clause.param = this.parseBindingAtom();
+      var simple = clause.param.type === "Identifier";
+      this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);
+      this.checkLValPattern(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
+      this.expect(types.parenR);
+    } else {
+      if (this.options.ecmaVersion < 10) { this.unexpected(); }
+      clause.param = null;
+      this.enterScope(0);
+    }
+    clause.body = this.parseBlock(false);
+    this.exitScope();
+    node.handler = this.finishNode(clause, "CatchClause");
+  }
+  node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;
+  if (!node.handler && !node.finalizer)
+    { this.raise(node.start, "Missing catch or finally clause"); }
+  return this.finishNode(node, "TryStatement")
+};
+
+pp$1.parseVarStatement = function(node, kind) {
+  this.next();
+  this.parseVar(node, false, kind);
+  this.semicolon();
+  return this.finishNode(node, "VariableDeclaration")
+};
+
+pp$1.parseWhileStatement = function(node) {
+  this.next();
+  node.test = this.parseParenExpression();
+  this.labels.push(loopLabel);
+  node.body = this.parseStatement("while");
+  this.labels.pop();
+  return this.finishNode(node, "WhileStatement")
+};
+
+pp$1.parseWithStatement = function(node) {
+  if (this.strict) { this.raise(this.start, "'with' in strict mode"); }
+  this.next();
+  node.object = this.parseParenExpression();
+  node.body = this.parseStatement("with");
+  return this.finishNode(node, "WithStatement")
+};
+
+pp$1.parseEmptyStatement = function(node) {
+  this.next();
+  return this.finishNode(node, "EmptyStatement")
+};
+
+pp$1.parseLabeledStatement = function(node, maybeName, expr, context) {
+  for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1)
+    {
+    var label = list[i$1];
+
+    if (label.name === maybeName)
+      { this.raise(expr.start, "Label '" + maybeName + "' is already declared");
+  } }
+  var kind = this.type.isLoop ? "loop" : this.type === types._switch ? "switch" : null;
+  for (var i = this.labels.length - 1; i >= 0; i--) {
+    var label$1 = this.labels[i];
+    if (label$1.statementStart === node.start) {
+      // Update information about previous labels on this node
+      label$1.statementStart = this.start;
+      label$1.kind = kind;
+    } else { break }
+  }
+  this.labels.push({name: maybeName, kind: kind, statementStart: this.start});
+  node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
+  this.labels.pop();
+  node.label = expr;
+  return this.finishNode(node, "LabeledStatement")
+};
+
+pp$1.parseExpressionStatement = function(node, expr) {
+  node.expression = expr;
+  this.semicolon();
+  return this.finishNode(node, "ExpressionStatement")
+};
+
+// Parse a semicolon-enclosed block of statements, handling `"use
+// strict"` declarations when `allowStrict` is true (used for
+// function bodies).
+
+pp$1.parseBlock = function(createNewLexicalScope, node, exitStrict) {
+  if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
+  if ( node === void 0 ) node = this.startNode();
+
+  node.body = [];
+  this.expect(types.braceL);
+  if (createNewLexicalScope) { this.enterScope(0); }
+  while (this.type !== types.braceR) {
+    var stmt = this.parseStatement(null);
+    node.body.push(stmt);
+  }
+  if (exitStrict) { this.strict = false; }
+  this.next();
+  if (createNewLexicalScope) { this.exitScope(); }
+  return this.finishNode(node, "BlockStatement")
+};
+
+// Parse a regular `for` loop. The disambiguation code in
+// `parseStatement` will already have parsed the init statement or
+// expression.
+
+pp$1.parseFor = function(node, init) {
+  node.init = init;
+  this.expect(types.semi);
+  node.test = this.type === types.semi ? null : this.parseExpression();
+  this.expect(types.semi);
+  node.update = this.type === types.parenR ? null : this.parseExpression();
+  this.expect(types.parenR);
+  node.body = this.parseStatement("for");
+  this.exitScope();
+  this.labels.pop();
+  return this.finishNode(node, "ForStatement")
+};
+
+// Parse a `for`/`in` and `for`/`of` loop, which are almost
+// same from parser's perspective.
+
+pp$1.parseForIn = function(node, init) {
+  var isForIn = this.type === types._in;
+  this.next();
+
+  if (
+    init.type === "VariableDeclaration" &&
+    init.declarations[0].init != null &&
+    (
+      !isForIn ||
+      this.options.ecmaVersion < 8 ||
+      this.strict ||
+      init.kind !== "var" ||
+      init.declarations[0].id.type !== "Identifier"
+    )
+  ) {
+    this.raise(
+      init.start,
+      ((isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer")
+    );
+  }
+  node.left = init;
+  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();
+  this.expect(types.parenR);
+  node.body = this.parseStatement("for");
+  this.exitScope();
+  this.labels.pop();
+  return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement")
+};
+
+// Parse a list of variable declarations.
+
+pp$1.parseVar = function(node, isFor, kind) {
+  node.declarations = [];
+  node.kind = kind;
+  for (;;) {
+    var decl = this.startNode();
+    this.parseVarId(decl, kind);
+    if (this.eat(types.eq)) {
+      decl.init = this.parseMaybeAssign(isFor);
+    } else if (kind === "const" && !(this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
+      this.unexpected();
+    } else if (decl.id.type !== "Identifier" && !(isFor && (this.type === types._in || this.isContextual("of")))) {
+      this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
+    } else {
+      decl.init = null;
+    }
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+    if (!this.eat(types.comma)) { break }
+  }
+  return node
+};
+
+pp$1.parseVarId = function(decl, kind) {
+  decl.id = this.parseBindingAtom();
+  this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
+};
+
+var FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;
+
+// Parse a function declaration or literal (depending on the
+// `statement & FUNC_STATEMENT`).
+
+// Remove `allowExpressionBody` for 7.0.0, as it is only called with false
+pp$1.parseFunction = function(node, statement, allowExpressionBody, isAsync) {
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {
+    if (this.type === types.star && (statement & FUNC_HANGING_STATEMENT))
+      { this.unexpected(); }
+    node.generator = this.eat(types.star);
+  }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+
+  if (statement & FUNC_STATEMENT) {
+    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types.name ? null : this.parseIdent();
+    if (node.id && !(statement & FUNC_HANGING_STATEMENT))
+      // If it is a regular function declaration in sloppy mode, then it is
+      // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding
+      // mode depends on properties of the current scope (see
+      // treatFunctionsAsVar).
+      { this.checkLValSimple(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); }
+  }
+
+  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.awaitIdentPos = 0;
+  this.enterScope(functionFlags(node.async, node.generator));
+
+  if (!(statement & FUNC_STATEMENT))
+    { node.id = this.type === types.name ? this.parseIdent() : null; }
+
+  this.parseFunctionParams(node);
+  this.parseFunctionBody(node, allowExpressionBody, false);
+
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.awaitIdentPos = oldAwaitIdentPos;
+  return this.finishNode(node, (statement & FUNC_STATEMENT) ? "FunctionDeclaration" : "FunctionExpression")
+};
+
+pp$1.parseFunctionParams = function(node) {
+  this.expect(types.parenL);
+  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.checkYieldAwaitInDefaultParams();
+};
+
+// Parse a class declaration or literal (depending on the
+// `isStatement` parameter).
+
+pp$1.parseClass = function(node, isStatement) {
+  this.next();
+
+  // ecma-262 14.6 Class Definitions
+  // A class definition is always strict mode code.
+  var oldStrict = this.strict;
+  this.strict = true;
+
+  this.parseClassId(node, isStatement);
+  this.parseClassSuper(node);
+  var privateNameMap = this.enterClassBody();
+  var classBody = this.startNode();
+  var hadConstructor = false;
+  classBody.body = [];
+  this.expect(types.braceL);
+  while (this.type !== types.braceR) {
+    var element = this.parseClassElement(node.superClass !== null);
+    if (element) {
+      classBody.body.push(element);
+      if (element.type === "MethodDefinition" && element.kind === "constructor") {
+        if (hadConstructor) { this.raise(element.start, "Duplicate constructor in the same class"); }
+        hadConstructor = true;
+      } else if (element.key.type === "PrivateIdentifier" && isPrivateNameConflicted(privateNameMap, element)) {
+        this.raiseRecoverable(element.key.start, ("Identifier '#" + (element.key.name) + "' has already been declared"));
+      }
+    }
+  }
+  this.strict = oldStrict;
+  this.next();
+  node.body = this.finishNode(classBody, "ClassBody");
+  this.exitClassBody();
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
+};
+
+pp$1.parseClassElement = function(constructorAllowsSuper) {
+  if (this.eat(types.semi)) { return null }
+
+  var ecmaVersion = this.options.ecmaVersion;
+  var node = this.startNode();
+  var keyName = "";
+  var isGenerator = false;
+  var isAsync = false;
+  var kind = "method";
+
+  // Parse modifiers
+  node.static = false;
+  if (this.eatContextual("static")) {
+    if (this.isClassElementNameStart() || this.type === types.star) {
+      node.static = true;
+    } else {
+      keyName = "static";
+    }
+  }
+  if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) {
+    if ((this.isClassElementNameStart() || this.type === types.star) && !this.canInsertSemicolon()) {
+      isAsync = true;
+    } else {
+      keyName = "async";
+    }
+  }
+  if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types.star)) {
+    isGenerator = true;
+  }
+  if (!keyName && !isAsync && !isGenerator) {
+    var lastValue = this.value;
+    if (this.eatContextual("get") || this.eatContextual("set")) {
+      if (this.isClassElementNameStart()) {
+        kind = lastValue;
+      } else {
+        keyName = lastValue;
+      }
+    }
+  }
+
+  // Parse element name
+  if (keyName) {
+    // 'async', 'get', 'set', or 'static' were not a keyword contextually.
+    // The last token is any of those. Make it the element name.
+    node.computed = false;
+    node.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc);
+    node.key.name = keyName;
+    this.finishNode(node.key, "Identifier");
+  } else {
+    this.parseClassElementName(node);
+  }
+
+  // Parse element value
+  if (ecmaVersion < 13 || this.type === types.parenL || kind !== "method" || isGenerator || isAsync) {
+    var isConstructor = !node.static && checkKeyName(node, "constructor");
+    var allowsDirectSuper = isConstructor && constructorAllowsSuper;
+    // Couldn't move this check into the 'parseClassMethod' method for backward compatibility.
+    if (isConstructor && kind !== "method") { this.raise(node.key.start, "Constructor can't have get/set modifier"); }
+    node.kind = isConstructor ? "constructor" : kind;
+    this.parseClassMethod(node, isGenerator, isAsync, allowsDirectSuper);
+  } else {
+    this.parseClassField(node);
+  }
+
+  return node
+};
+
+pp$1.isClassElementNameStart = function() {
+  return (
+    this.type === types.name ||
+    this.type === types.privateId ||
+    this.type === types.num ||
+    this.type === types.string ||
+    this.type === types.bracketL ||
+    this.type.keyword
+  )
+};
+
+pp$1.parseClassElementName = function(element) {
+  if (this.type === types.privateId) {
+    if (this.value === "constructor") {
+      this.raise(this.start, "Classes can't have an element named '#constructor'");
+    }
+    element.computed = false;
+    element.key = this.parsePrivateIdent();
+  } else {
+    this.parsePropertyName(element);
+  }
+};
+
+pp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {
+  // Check key and flags
+  var key = method.key;
+  if (method.kind === "constructor") {
+    if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
+    if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
+  } else if (method.static && checkKeyName(method, "prototype")) {
+    this.raise(key.start, "Classes may not have a static property named prototype");
+  }
+
+  // Parse value
+  var value = method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);
+
+  // Check value
+  if (method.kind === "get" && value.params.length !== 0)
+    { this.raiseRecoverable(value.start, "getter should have no params"); }
+  if (method.kind === "set" && value.params.length !== 1)
+    { this.raiseRecoverable(value.start, "setter should have exactly one param"); }
+  if (method.kind === "set" && value.params[0].type === "RestElement")
+    { this.raiseRecoverable(value.params[0].start, "Setter cannot use rest params"); }
+
+  return this.finishNode(method, "MethodDefinition")
+};
+
+pp$1.parseClassField = function(field) {
+  if (checkKeyName(field, "constructor")) {
+    this.raise(field.key.start, "Classes can't have a field named 'constructor'");
+  } else if (field.static && checkKeyName(field, "prototype")) {
+    this.raise(field.key.start, "Classes can't have a static field named 'prototype'");
+  }
+
+  if (this.eat(types.eq)) {
+    // To raise SyntaxError if 'arguments' exists in the initializer.
+    var scope = this.currentThisScope();
+    var inClassFieldInit = scope.inClassFieldInit;
+    scope.inClassFieldInit = true;
+    field.value = this.parseMaybeAssign();
+    scope.inClassFieldInit = inClassFieldInit;
+  } else {
+    field.value = null;
+  }
+  this.semicolon();
+
+  return this.finishNode(field, "PropertyDefinition")
+};
+
+pp$1.parseClassId = function(node, isStatement) {
+  if (this.type === types.name) {
+    node.id = this.parseIdent();
+    if (isStatement)
+      { this.checkLValSimple(node.id, BIND_LEXICAL, false); }
+  } else {
+    if (isStatement === true)
+      { this.unexpected(); }
+    node.id = null;
+  }
+};
+
+pp$1.parseClassSuper = function(node) {
+  node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
+};
+
+pp$1.enterClassBody = function() {
+  var element = {declared: Object.create(null), used: []};
+  this.privateNameStack.push(element);
+  return element.declared
+};
+
+pp$1.exitClassBody = function() {
+  var ref = this.privateNameStack.pop();
+  var declared = ref.declared;
+  var used = ref.used;
+  var len = this.privateNameStack.length;
+  var parent = len === 0 ? null : this.privateNameStack[len - 1];
+  for (var i = 0; i < used.length; ++i) {
+    var id = used[i];
+    if (!has(declared, id.name)) {
+      if (parent) {
+        parent.used.push(id);
+      } else {
+        this.raiseRecoverable(id.start, ("Private field '#" + (id.name) + "' must be declared in an enclosing class"));
+      }
+    }
+  }
+};
+
+function isPrivateNameConflicted(privateNameMap, element) {
+  var name = element.key.name;
+  var curr = privateNameMap[name];
+
+  var next = "true";
+  if (element.type === "MethodDefinition" && (element.kind === "get" || element.kind === "set")) {
+    next = (element.static ? "s" : "i") + element.kind;
+  }
+
+  // `class { get #a(){}; static set #a(_){} }` is also conflict.
+  if (
+    curr === "iget" && next === "iset" ||
+    curr === "iset" && next === "iget" ||
+    curr === "sget" && next === "sset" ||
+    curr === "sset" && next === "sget"
+  ) {
+    privateNameMap[name] = "true";
+    return false
+  } else if (!curr) {
+    privateNameMap[name] = next;
+    return false
+  } else {
+    return true
+  }
+}
+
+function checkKeyName(node, name) {
+  var computed = node.computed;
+  var key = node.key;
+  return !computed && (
+    key.type === "Identifier" && key.name === name ||
+    key.type === "Literal" && key.value === name
+  )
+}
+
+// Parses module export declaration.
+
+pp$1.parseExport = function(node, exports) {
+  this.next();
+  // export * from '...'
+  if (this.eat(types.star)) {
+    if (this.options.ecmaVersion >= 11) {
+      if (this.eatContextual("as")) {
+        node.exported = this.parseIdent(true);
+        this.checkExport(exports, node.exported.name, this.lastTokStart);
+      } else {
+        node.exported = null;
+      }
+    }
+    this.expectContextual("from");
+    if (this.type !== types.string) { this.unexpected(); }
+    node.source = this.parseExprAtom();
+    this.semicolon();
+    return this.finishNode(node, "ExportAllDeclaration")
+  }
+  if (this.eat(types._default)) { // export default ...
+    this.checkExport(exports, "default", this.lastTokStart);
+    var isAsync;
+    if (this.type === types._function || (isAsync = this.isAsyncFunction())) {
+      var fNode = this.startNode();
+      this.next();
+      if (isAsync) { this.next(); }
+      node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
+    } else if (this.type === types._class) {
+      var cNode = this.startNode();
+      node.declaration = this.parseClass(cNode, "nullableID");
+    } else {
+      node.declaration = this.parseMaybeAssign();
+      this.semicolon();
+    }
+    return this.finishNode(node, "ExportDefaultDeclaration")
+  }
+  // export var|const|let|function|class ...
+  if (this.shouldParseExportStatement()) {
+    node.declaration = this.parseStatement(null);
+    if (node.declaration.type === "VariableDeclaration")
+      { this.checkVariableExport(exports, node.declaration.declarations); }
+    else
+      { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
+    node.specifiers = [];
+    node.source = null;
+  } else { // export { x, y as z } [from '...']
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifiers(exports);
+    if (this.eatContextual("from")) {
+      if (this.type !== types.string) { this.unexpected(); }
+      node.source = this.parseExprAtom();
+    } else {
+      for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+        // check for keywords used as local names
+        var spec = list[i];
+
+        this.checkUnreserved(spec.local);
+        // check if export is defined
+        this.checkLocalExport(spec.local);
+      }
+
+      node.source = null;
+    }
+    this.semicolon();
+  }
+  return this.finishNode(node, "ExportNamedDeclaration")
+};
+
+pp$1.checkExport = function(exports, name, pos) {
+  if (!exports) { return }
+  if (has(exports, name))
+    { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
+  exports[name] = true;
+};
+
+pp$1.checkPatternExport = function(exports, pat) {
+  var type = pat.type;
+  if (type === "Identifier")
+    { this.checkExport(exports, pat.name, pat.start); }
+  else if (type === "ObjectPattern")
+    { for (var i = 0, list = pat.properties; i < list.length; i += 1)
+      {
+        var prop = list[i];
+
+        this.checkPatternExport(exports, prop);
+      } }
+  else if (type === "ArrayPattern")
+    { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
+      var elt = list$1[i$1];
+
+        if (elt) { this.checkPatternExport(exports, elt); }
+    } }
+  else if (type === "Property")
+    { this.checkPatternExport(exports, pat.value); }
+  else if (type === "AssignmentPattern")
+    { this.checkPatternExport(exports, pat.left); }
+  else if (type === "RestElement")
+    { this.checkPatternExport(exports, pat.argument); }
+  else if (type === "ParenthesizedExpression")
+    { this.checkPatternExport(exports, pat.expression); }
+};
+
+pp$1.checkVariableExport = function(exports, decls) {
+  if (!exports) { return }
+  for (var i = 0, list = decls; i < list.length; i += 1)
+    {
+    var decl = list[i];
+
+    this.checkPatternExport(exports, decl.id);
+  }
+};
+
+pp$1.shouldParseExportStatement = function() {
+  return this.type.keyword === "var" ||
+    this.type.keyword === "const" ||
+    this.type.keyword === "class" ||
+    this.type.keyword === "function" ||
+    this.isLet() ||
+    this.isAsyncFunction()
+};
+
+// Parses a comma-separated list of module exports.
+
+pp$1.parseExportSpecifiers = function(exports) {
+  var nodes = [], first = true;
+  // export { x, y as z } [from '...']
+  this.expect(types.braceL);
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this.expect(types.comma);
+      if (this.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
+
+    var node = this.startNode();
+    node.local = this.parseIdent(true);
+    node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
+    this.checkExport(exports, node.exported.name, node.exported.start);
+    nodes.push(this.finishNode(node, "ExportSpecifier"));
+  }
+  return nodes
+};
+
+// Parses import declaration.
+
+pp$1.parseImport = function(node) {
+  this.next();
+  // import '...'
+  if (this.type === types.string) {
+    node.specifiers = empty;
+    node.source = this.parseExprAtom();
+  } else {
+    node.specifiers = this.parseImportSpecifiers();
+    this.expectContextual("from");
+    node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();
+  }
+  this.semicolon();
+  return this.finishNode(node, "ImportDeclaration")
+};
+
+// Parses a comma-separated list of module imports.
+
+pp$1.parseImportSpecifiers = function() {
+  var nodes = [], first = true;
+  if (this.type === types.name) {
+    // import defaultObj, { x, y as z } from '...'
+    var node = this.startNode();
+    node.local = this.parseIdent();
+    this.checkLValSimple(node.local, BIND_LEXICAL);
+    nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
+    if (!this.eat(types.comma)) { return nodes }
+  }
+  if (this.type === types.star) {
+    var node$1 = this.startNode();
+    this.next();
+    this.expectContextual("as");
+    node$1.local = this.parseIdent();
+    this.checkLValSimple(node$1.local, BIND_LEXICAL);
+    nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
+    return nodes
+  }
+  this.expect(types.braceL);
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this.expect(types.comma);
+      if (this.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
+
+    var node$2 = this.startNode();
+    node$2.imported = this.parseIdent(true);
+    if (this.eatContextual("as")) {
+      node$2.local = this.parseIdent();
+    } else {
+      this.checkUnreserved(node$2.imported);
+      node$2.local = node$2.imported;
+    }
+    this.checkLValSimple(node$2.local, BIND_LEXICAL);
+    nodes.push(this.finishNode(node$2, "ImportSpecifier"));
+  }
+  return nodes
+};
+
+// Set `ExpressionStatement#directive` property for directive prologues.
+pp$1.adaptDirectivePrologue = function(statements) {
+  for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
+    statements[i].directive = statements[i].expression.raw.slice(1, -1);
+  }
+};
+pp$1.isDirectiveCandidate = function(statement) {
+  return (
+    statement.type === "ExpressionStatement" &&
+    statement.expression.type === "Literal" &&
+    typeof statement.expression.value === "string" &&
+    // Reject parenthesized strings.
+    (this.input[statement.start] === "\"" || this.input[statement.start] === "'")
+  )
+};
+
+var pp$2 = Parser.prototype;
+
+// Convert existing expression atom to assignable pattern
+// if possible.
+
+pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
+  if (this.options.ecmaVersion >= 6 && node) {
+    switch (node.type) {
+    case "Identifier":
+      if (this.inAsync && node.name === "await")
+        { this.raise(node.start, "Cannot use 'await' as identifier inside an async function"); }
+      break
+
+    case "ObjectPattern":
+    case "ArrayPattern":
+    case "AssignmentPattern":
+    case "RestElement":
+      break
+
+    case "ObjectExpression":
+      node.type = "ObjectPattern";
+      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+      for (var i = 0, list = node.properties; i < list.length; i += 1) {
+        var prop = list[i];
+
+      this.toAssignable(prop, isBinding);
+        // Early error:
+        //   AssignmentRestProperty[Yield, Await] :
+        //     `...` DestructuringAssignmentTarget[Yield, Await]
+        //
+        //   It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|.
+        if (
+          prop.type === "RestElement" &&
+          (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")
+        ) {
+          this.raise(prop.argument.start, "Unexpected token");
+        }
+      }
+      break
+
+    case "Property":
+      // AssignmentProperty has type === "Property"
+      if (node.kind !== "init") { this.raise(node.key.start, "Object pattern can't contain getter or setter"); }
+      this.toAssignable(node.value, isBinding);
+      break
+
+    case "ArrayExpression":
+      node.type = "ArrayPattern";
+      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+      this.toAssignableList(node.elements, isBinding);
+      break
+
+    case "SpreadElement":
+      node.type = "RestElement";
+      this.toAssignable(node.argument, isBinding);
+      if (node.argument.type === "AssignmentPattern")
+        { this.raise(node.argument.start, "Rest elements cannot have a default value"); }
+      break
+
+    case "AssignmentExpression":
+      if (node.operator !== "=") { this.raise(node.left.end, "Only '=' operator can be used for specifying default value."); }
+      node.type = "AssignmentPattern";
+      delete node.operator;
+      this.toAssignable(node.left, isBinding);
+      break
+
+    case "ParenthesizedExpression":
+      this.toAssignable(node.expression, isBinding, refDestructuringErrors);
+      break
+
+    case "ChainExpression":
+      this.raiseRecoverable(node.start, "Optional chaining cannot appear in left-hand side");
+      break
+
+    case "MemberExpression":
+      if (!isBinding) { break }
+
+    default:
+      this.raise(node.start, "Assigning to rvalue");
+    }
+  } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
+  return node
+};
+
+// Convert list of expression atoms to binding list.
+
+pp$2.toAssignableList = function(exprList, isBinding) {
+  var end = exprList.length;
+  for (var i = 0; i < end; i++) {
+    var elt = exprList[i];
+    if (elt) { this.toAssignable(elt, isBinding); }
+  }
+  if (end) {
+    var last = exprList[end - 1];
+    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
+      { this.unexpected(last.argument.start); }
+  }
+  return exprList
+};
+
+// Parses spread element.
+
+pp$2.parseSpread = function(refDestructuringErrors) {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+  return this.finishNode(node, "SpreadElement")
+};
+
+pp$2.parseRestBinding = function() {
+  var node = this.startNode();
+  this.next();
+
+  // RestElement inside of a function parameter must be an identifier
+  if (this.options.ecmaVersion === 6 && this.type !== types.name)
+    { this.unexpected(); }
+
+  node.argument = this.parseBindingAtom();
+
+  return this.finishNode(node, "RestElement")
+};
+
+// Parses lvalue (assignable) atom.
+
+pp$2.parseBindingAtom = function() {
+  if (this.options.ecmaVersion >= 6) {
+    switch (this.type) {
+    case types.bracketL:
+      var node = this.startNode();
+      this.next();
+      node.elements = this.parseBindingList(types.bracketR, true, true);
+      return this.finishNode(node, "ArrayPattern")
+
+    case types.braceL:
+      return this.parseObj(true)
+    }
+  }
+  return this.parseIdent()
+};
+
+pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (first) { first = false; }
+    else { this.expect(types.comma); }
+    if (allowEmpty && this.type === types.comma) {
+      elts.push(null);
+    } else if (allowTrailingComma && this.afterTrailingComma(close)) {
+      break
+    } else if (this.type === types.ellipsis) {
+      var rest = this.parseRestBinding();
+      this.parseBindingListItem(rest);
+      elts.push(rest);
+      if (this.type === types.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
+      this.expect(close);
+      break
+    } else {
+      var elem = this.parseMaybeDefault(this.start, this.startLoc);
+      this.parseBindingListItem(elem);
+      elts.push(elem);
+    }
+  }
+  return elts
+};
+
+pp$2.parseBindingListItem = function(param) {
+  return param
+};
+
+// Parses assignment pattern around given atom if possible.
+
+pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
+  left = left || this.parseBindingAtom();
+  if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }
+  var node = this.startNodeAt(startPos, startLoc);
+  node.left = left;
+  node.right = this.parseMaybeAssign();
+  return this.finishNode(node, "AssignmentPattern")
+};
+
+// The following three functions all verify that a node is an lvalue —
+// something that can be bound, or assigned to. In order to do so, they perform
+// a variety of checks:
+//
+// - Check that none of the bound/assigned-to identifiers are reserved words.
+// - Record name declarations for bindings in the appropriate scope.
+// - Check duplicate argument names, if checkClashes is set.
+//
+// If a complex binding pattern is encountered (e.g., object and array
+// destructuring), the entire pattern is recursively checked.
+//
+// There are three versions of checkLVal*() appropriate for different
+// circumstances:
+//
+// - checkLValSimple() shall be used if the syntactic construct supports
+//   nothing other than identifiers and member expressions. Parenthesized
+//   expressions are also correctly handled. This is generally appropriate for
+//   constructs for which the spec says
+//
+//   > It is a Syntax Error if AssignmentTargetType of [the production] is not
+//   > simple.
+//
+//   It is also appropriate for checking if an identifier is valid and not
+//   defined elsewhere, like import declarations or function/class identifiers.
+//
+//   Examples where this is used include:
+//     a += …;
+//     import a from '…';
+//   where a is the node to be checked.
+//
+// - checkLValPattern() shall be used if the syntactic construct supports
+//   anything checkLValSimple() supports, as well as object and array
+//   destructuring patterns. This is generally appropriate for constructs for
+//   which the spec says
+//
+//   > It is a Syntax Error if [the production] is neither an ObjectLiteral nor
+//   > an ArrayLiteral and AssignmentTargetType of [the production] is not
+//   > simple.
+//
+//   Examples where this is used include:
+//     (a = …);
+//     const a = …;
+//     try { … } catch (a) { … }
+//   where a is the node to be checked.
+//
+// - checkLValInnerPattern() shall be used if the syntactic construct supports
+//   anything checkLValPattern() supports, as well as default assignment
+//   patterns, rest elements, and other constructs that may appear within an
+//   object or array destructuring pattern.
+//
+//   As a special case, function parameters also use checkLValInnerPattern(),
+//   as they also support defaults and rest constructs.
+//
+// These functions deliberately support both assignment and binding constructs,
+// as the logic for both is exceedingly similar. If the node is the target of
+// an assignment, then bindingType should be set to BIND_NONE. Otherwise, it
+// should be set to the appropriate BIND_* constant, like BIND_VAR or
+// BIND_LEXICAL.
+//
+// If the function is called with a non-BIND_NONE bindingType, then
+// additionally a checkClashes object may be specified to allow checking for
+// duplicate argument names. checkClashes is ignored if the provided construct
+// is an assignment (i.e., bindingType is BIND_NONE).
+
+pp$2.checkLValSimple = function(expr, bindingType, checkClashes) {
+  if ( bindingType === void 0 ) bindingType = BIND_NONE;
+
+  var isBind = bindingType !== BIND_NONE;
+
+  switch (expr.type) {
+  case "Identifier":
+    if (this.strict && this.reservedWordsStrictBind.test(expr.name))
+      { this.raiseRecoverable(expr.start, (isBind ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
+    if (isBind) {
+      if (bindingType === BIND_LEXICAL && expr.name === "let")
+        { this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name"); }
+      if (checkClashes) {
+        if (has(checkClashes, expr.name))
+          { this.raiseRecoverable(expr.start, "Argument name clash"); }
+        checkClashes[expr.name] = true;
+      }
+      if (bindingType !== BIND_OUTSIDE) { this.declareName(expr.name, bindingType, expr.start); }
+    }
+    break
+
+  case "ChainExpression":
+    this.raiseRecoverable(expr.start, "Optional chaining cannot appear in left-hand side");
+    break
+
+  case "MemberExpression":
+    if (isBind) { this.raiseRecoverable(expr.start, "Binding member expression"); }
+    break
+
+  case "ParenthesizedExpression":
+    if (isBind) { this.raiseRecoverable(expr.start, "Binding parenthesized expression"); }
+    return this.checkLValSimple(expr.expression, bindingType, checkClashes)
+
+  default:
+    this.raise(expr.start, (isBind ? "Binding" : "Assigning to") + " rvalue");
+  }
+};
+
+pp$2.checkLValPattern = function(expr, bindingType, checkClashes) {
+  if ( bindingType === void 0 ) bindingType = BIND_NONE;
+
+  switch (expr.type) {
+  case "ObjectPattern":
+    for (var i = 0, list = expr.properties; i < list.length; i += 1) {
+      var prop = list[i];
+
+    this.checkLValInnerPattern(prop, bindingType, checkClashes);
+    }
+    break
+
+  case "ArrayPattern":
+    for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
+      var elem = list$1[i$1];
+
+    if (elem) { this.checkLValInnerPattern(elem, bindingType, checkClashes); }
+    }
+    break
+
+  default:
+    this.checkLValSimple(expr, bindingType, checkClashes);
+  }
+};
+
+pp$2.checkLValInnerPattern = function(expr, bindingType, checkClashes) {
+  if ( bindingType === void 0 ) bindingType = BIND_NONE;
+
+  switch (expr.type) {
+  case "Property":
+    // AssignmentProperty has type === "Property"
+    this.checkLValInnerPattern(expr.value, bindingType, checkClashes);
+    break
+
+  case "AssignmentPattern":
+    this.checkLValPattern(expr.left, bindingType, checkClashes);
+    break
+
+  case "RestElement":
+    this.checkLValPattern(expr.argument, bindingType, checkClashes);
+    break
+
+  default:
+    this.checkLValPattern(expr, bindingType, checkClashes);
+  }
+};
+
+// A recursive descent parser operates by defining functions for all
+
+var pp$3 = Parser.prototype;
+
+// Check if property name clashes with already added.
+// Object/class getters and setters are not allowed to clash —
+// either with each other or with an init property — and in
+// strict mode, init properties are also not allowed to be repeated.
+
+pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
+  if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement")
+    { return }
+  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
+    { return }
+  var key = prop.key;
+  var name;
+  switch (key.type) {
+  case "Identifier": name = key.name; break
+  case "Literal": name = String(key.value); break
+  default: return
+  }
+  var kind = prop.kind;
+  if (this.options.ecmaVersion >= 6) {
+    if (name === "__proto__" && kind === "init") {
+      if (propHash.proto) {
+        if (refDestructuringErrors) {
+          if (refDestructuringErrors.doubleProto < 0)
+            { refDestructuringErrors.doubleProto = key.start; }
+          // Backwards-compat kludge. Can be removed in version 6.0
+        } else { this.raiseRecoverable(key.start, "Redefinition of __proto__ property"); }
+      }
+      propHash.proto = true;
+    }
+    return
+  }
+  name = "$" + name;
+  var other = propHash[name];
+  if (other) {
+    var redefinition;
+    if (kind === "init") {
+      redefinition = this.strict && other.init || other.get || other.set;
+    } else {
+      redefinition = other.init || other[kind];
+    }
+    if (redefinition)
+      { this.raiseRecoverable(key.start, "Redefinition of property"); }
+  } else {
+    other = propHash[name] = {
+      init: false,
+      get: false,
+      set: false
+    };
+  }
+  other[kind] = true;
+};
+
+// ### Expression parsing
+
+// These nest, from the most general expression type at the top to
+// 'atomic', nondivisible expression types at the bottom. Most of
+// the functions will simply let the function(s) below them parse,
+// and, *if* the syntactic construct they handle is present, wrap
+// the AST node that the inner parser gave them in another node.
+
+// Parse a full expression. The optional arguments are used to
+// forbid the `in` operator (in for loops initalization expressions)
+// and provide reference for storing '=' operator inside shorthand
+// property assignment in contexts where both object expression
+// and object pattern might appear (so it's possible to raise
+// delayed syntax error at correct position).
+
+pp$3.parseExpression = function(forInit, refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
+  if (this.type === types.comma) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.expressions = [expr];
+    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors)); }
+    return this.finishNode(node, "SequenceExpression")
+  }
+  return expr
+};
+
+// Parse an assignment expression. This includes applications of
+// operators like `+=`.
+
+pp$3.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse) {
+  if (this.isContextual("yield")) {
+    if (this.inGenerator) { return this.parseYield(forInit) }
+    // The tokenizer will assume an expression is allowed after
+    // `yield`, but this isn't that kind of yield
+    else { this.exprAllowed = false; }
+  }
+
+  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1;
+  if (refDestructuringErrors) {
+    oldParenAssign = refDestructuringErrors.parenthesizedAssign;
+    oldTrailingComma = refDestructuringErrors.trailingComma;
+    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
+  } else {
+    refDestructuringErrors = new DestructuringErrors;
+    ownDestructuringErrors = true;
+  }
+
+  var startPos = this.start, startLoc = this.startLoc;
+  if (this.type === types.parenL || this.type === types.name) {
+    this.potentialArrowAt = this.start;
+    this.potentialArrowInForAwait = forInit === "await";
+  }
+  var left = this.parseMaybeConditional(forInit, refDestructuringErrors);
+  if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
+  if (this.type.isAssign) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.operator = this.value;
+    if (this.type === types.eq)
+      { left = this.toAssignable(left, false, refDestructuringErrors); }
+    if (!ownDestructuringErrors) {
+      refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1;
+    }
+    if (refDestructuringErrors.shorthandAssign >= left.start)
+      { refDestructuringErrors.shorthandAssign = -1; } // reset because shorthand default was used correctly
+    if (this.type === types.eq)
+      { this.checkLValPattern(left); }
+    else
+      { this.checkLValSimple(left); }
+    node.left = left;
+    this.next();
+    node.right = this.parseMaybeAssign(forInit);
+    return this.finishNode(node, "AssignmentExpression")
+  } else {
+    if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
+  }
+  if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; }
+  if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; }
+  return left
+};
+
+// Parse a ternary conditional (`?:`) operator.
+
+pp$3.parseMaybeConditional = function(forInit, refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseExprOps(forInit, refDestructuringErrors);
+  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+  if (this.eat(types.question)) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.test = expr;
+    node.consequent = this.parseMaybeAssign();
+    this.expect(types.colon);
+    node.alternate = this.parseMaybeAssign(forInit);
+    return this.finishNode(node, "ConditionalExpression")
+  }
+  return expr
+};
+
+// Start the precedence parser.
+
+pp$3.parseExprOps = function(forInit, refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseMaybeUnary(refDestructuringErrors, false);
+  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+  return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, forInit)
+};
+
+// Parse binary operators with the operator precedence parsing
+// algorithm. `left` is the left-hand side of the operator.
+// `minPrec` provides context that allows the function to stop and
+// defer further parser to one of its callers when it encounters an
+// operator that has a lower precedence than the set it is parsing.
+
+pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit) {
+  var prec = this.type.binop;
+  if (prec != null && (!forInit || this.type !== types._in)) {
+    if (prec > minPrec) {
+      var logical = this.type === types.logicalOR || this.type === types.logicalAND;
+      var coalesce = this.type === types.coalesce;
+      if (coalesce) {
+        // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions.
+        // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error.
+        prec = types.logicalAND.binop;
+      }
+      var op = this.value;
+      this.next();
+      var startPos = this.start, startLoc = this.startLoc;
+      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, forInit);
+      var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);
+      if ((logical && this.type === types.coalesce) || (coalesce && (this.type === types.logicalOR || this.type === types.logicalAND))) {
+        this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses");
+      }
+      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, forInit)
+    }
+  }
+  return left
+};
+
+pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
+  var node = this.startNodeAt(startPos, startLoc);
+  node.left = left;
+  node.operator = op;
+  node.right = right;
+  return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression")
+};
+
+// Parse unary operators, both prefix and postfix.
+
+pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec) {
+  var startPos = this.start, startLoc = this.startLoc, expr;
+  if (this.isContextual("await") && this.canAwait) {
+    expr = this.parseAwait();
+    sawUnary = true;
+  } else if (this.type.prefix) {
+    var node = this.startNode(), update = this.type === types.incDec;
+    node.operator = this.value;
+    node.prefix = true;
+    this.next();
+    node.argument = this.parseMaybeUnary(null, true, update);
+    this.checkExpressionErrors(refDestructuringErrors, true);
+    if (update) { this.checkLValSimple(node.argument); }
+    else if (this.strict && node.operator === "delete" &&
+             node.argument.type === "Identifier")
+      { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
+    else if (node.operator === "delete" && isPrivateFieldAccess(node.argument))
+      { this.raiseRecoverable(node.start, "Private fields can not be deleted"); }
+    else { sawUnary = true; }
+    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  } else {
+    expr = this.parseExprSubscripts(refDestructuringErrors);
+    if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
+    while (this.type.postfix && !this.canInsertSemicolon()) {
+      var node$1 = this.startNodeAt(startPos, startLoc);
+      node$1.operator = this.value;
+      node$1.prefix = false;
+      node$1.argument = expr;
+      this.checkLValSimple(expr);
+      this.next();
+      expr = this.finishNode(node$1, "UpdateExpression");
+    }
+  }
+
+  if (!incDec && this.eat(types.starstar)) {
+    if (sawUnary)
+      { this.unexpected(this.lastTokStart); }
+    else
+      { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
+  } else {
+    return expr
+  }
+};
+
+function isPrivateFieldAccess(node) {
+  return (
+    node.type === "MemberExpression" && node.property.type === "PrivateIdentifier" ||
+    node.type === "ChainExpression" && isPrivateFieldAccess(node.expression)
+  )
+}
+
+// Parse call, dot, and `[]`-subscript expressions.
+
+pp$3.parseExprSubscripts = function(refDestructuringErrors) {
+  var startPos = this.start, startLoc = this.startLoc;
+  var expr = this.parseExprAtom(refDestructuringErrors);
+  if (expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")")
+    { return expr }
+  var result = this.parseSubscripts(expr, startPos, startLoc);
+  if (refDestructuringErrors && result.type === "MemberExpression") {
+    if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
+    if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
+    if (refDestructuringErrors.trailingComma >= result.start) { refDestructuringErrors.trailingComma = -1; }
+  }
+  return result
+};
+
+pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
+  var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
+      this.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 &&
+      this.potentialArrowAt === base.start;
+  var optionalChained = false;
+
+  while (true) {
+    var element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained);
+
+    if (element.optional) { optionalChained = true; }
+    if (element === base || element.type === "ArrowFunctionExpression") {
+      if (optionalChained) {
+        var chainNode = this.startNodeAt(startPos, startLoc);
+        chainNode.expression = element;
+        element = this.finishNode(chainNode, "ChainExpression");
+      }
+      return element
+    }
+
+    base = element;
+  }
+};
+
+pp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained) {
+  var optionalSupported = this.options.ecmaVersion >= 11;
+  var optional = optionalSupported && this.eat(types.questionDot);
+  if (noCalls && optional) { this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions"); }
+
+  var computed = this.eat(types.bracketL);
+  if (computed || (optional && this.type !== types.parenL && this.type !== types.backQuote) || this.eat(types.dot)) {
+    var node = this.startNodeAt(startPos, startLoc);
+    node.object = base;
+    if (computed) {
+      node.property = this.parseExpression();
+      this.expect(types.bracketR);
+    } else if (this.type === types.privateId && base.type !== "Super") {
+      node.property = this.parsePrivateIdent();
+    } else {
+      node.property = this.parseIdent(this.options.allowReserved !== "never");
+    }
+    node.computed = !!computed;
+    if (optionalSupported) {
+      node.optional = optional;
+    }
+    base = this.finishNode(node, "MemberExpression");
+  } else if (!noCalls && this.eat(types.parenL)) {
+    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+    this.yieldPos = 0;
+    this.awaitPos = 0;
+    this.awaitIdentPos = 0;
+    var exprList = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors);
+    if (maybeAsyncArrow && !optional && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+      this.checkPatternErrors(refDestructuringErrors, false);
+      this.checkYieldAwaitInDefaultParams();
+      if (this.awaitIdentPos > 0)
+        { this.raise(this.awaitIdentPos, "Cannot use 'await' as identifier inside an async function"); }
+      this.yieldPos = oldYieldPos;
+      this.awaitPos = oldAwaitPos;
+      this.awaitIdentPos = oldAwaitIdentPos;
+      return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true)
+    }
+    this.checkExpressionErrors(refDestructuringErrors, true);
+    this.yieldPos = oldYieldPos || this.yieldPos;
+    this.awaitPos = oldAwaitPos || this.awaitPos;
+    this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos;
+    var node$1 = this.startNodeAt(startPos, startLoc);
+    node$1.callee = base;
+    node$1.arguments = exprList;
+    if (optionalSupported) {
+      node$1.optional = optional;
+    }
+    base = this.finishNode(node$1, "CallExpression");
+  } else if (this.type === types.backQuote) {
+    if (optional || optionalChained) {
+      this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions");
+    }
+    var node$2 = this.startNodeAt(startPos, startLoc);
+    node$2.tag = base;
+    node$2.quasi = this.parseTemplate({isTagged: true});
+    base = this.finishNode(node$2, "TaggedTemplateExpression");
+  }
+  return base
+};
+
+// Parse an atomic expression — either a single token that is an
+// expression, an expression started by a keyword like `function` or
+// `new`, or an expression wrapped in punctuation like `()`, `[]`,
+// or `{}`.
+
+pp$3.parseExprAtom = function(refDestructuringErrors) {
+  // If a division operator appears in an expression position, the
+  // tokenizer got confused, and we force it to read a regexp instead.
+  if (this.type === types.slash) { this.readRegexp(); }
+
+  var node, canBeArrow = this.potentialArrowAt === this.start;
+  switch (this.type) {
+  case types._super:
+    if (!this.allowSuper)
+      { this.raise(this.start, "'super' keyword outside a method"); }
+    node = this.startNode();
+    this.next();
+    if (this.type === types.parenL && !this.allowDirectSuper)
+      { this.raise(node.start, "super() call outside constructor of a subclass"); }
+    // The `super` keyword can appear at below:
+    // SuperProperty:
+    //     super [ Expression ]
+    //     super . IdentifierName
+    // SuperCall:
+    //     super ( Arguments )
+    if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
+      { this.unexpected(); }
+    return this.finishNode(node, "Super")
+
+  case types._this:
+    node = this.startNode();
+    this.next();
+    return this.finishNode(node, "ThisExpression")
+
+  case types.name:
+    var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
+    var id = this.parseIdent(false);
+    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types._function))
+      { return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true) }
+    if (canBeArrow && !this.canInsertSemicolon()) {
+      if (this.eat(types.arrow))
+        { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
+      if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc &&
+          (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) {
+        id = this.parseIdent(false);
+        if (this.canInsertSemicolon() || !this.eat(types.arrow))
+          { this.unexpected(); }
+        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)
+      }
+    }
+    return id
+
+  case types.regexp:
+    var value = this.value;
+    node = this.parseLiteral(value.value);
+    node.regex = {pattern: value.pattern, flags: value.flags};
+    return node
+
+  case types.num: case types.string:
+    return this.parseLiteral(this.value)
+
+  case types._null: case types._true: case types._false:
+    node = this.startNode();
+    node.value = this.type === types._null ? null : this.type === types._true;
+    node.raw = this.type.keyword;
+    this.next();
+    return this.finishNode(node, "Literal")
+
+  case types.parenL:
+    var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);
+    if (refDestructuringErrors) {
+      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
+        { refDestructuringErrors.parenthesizedAssign = start; }
+      if (refDestructuringErrors.parenthesizedBind < 0)
+        { refDestructuringErrors.parenthesizedBind = start; }
+    }
+    return expr
+
+  case types.bracketL:
+    node = this.startNode();
+    this.next();
+    node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);
+    return this.finishNode(node, "ArrayExpression")
+
+  case types.braceL:
+    return this.parseObj(false, refDestructuringErrors)
+
+  case types._function:
+    node = this.startNode();
+    this.next();
+    return this.parseFunction(node, 0)
+
+  case types._class:
+    return this.parseClass(this.startNode(), false)
+
+  case types._new:
+    return this.parseNew()
+
+  case types.backQuote:
+    return this.parseTemplate()
+
+  case types._import:
+    if (this.options.ecmaVersion >= 11) {
+      return this.parseExprImport()
+    } else {
+      return this.unexpected()
+    }
+
+  default:
+    this.unexpected();
+  }
+};
+
+pp$3.parseExprImport = function() {
+  var node = this.startNode();
+
+  // Consume `import` as an identifier for `import.meta`.
+  // Because `this.parseIdent(true)` doesn't check escape sequences, it needs the check of `this.containsEsc`.
+  if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword import"); }
+  var meta = this.parseIdent(true);
+
+  switch (this.type) {
+  case types.parenL:
+    return this.parseDynamicImport(node)
+  case types.dot:
+    node.meta = meta;
+    return this.parseImportMeta(node)
+  default:
+    this.unexpected();
+  }
+};
+
+pp$3.parseDynamicImport = function(node) {
+  this.next(); // skip `(`
+
+  // Parse node.source.
+  node.source = this.parseMaybeAssign();
+
+  // Verify ending.
+  if (!this.eat(types.parenR)) {
+    var errorPos = this.start;
+    if (this.eat(types.comma) && this.eat(types.parenR)) {
+      this.raiseRecoverable(errorPos, "Trailing comma is not allowed in import()");
+    } else {
+      this.unexpected(errorPos);
+    }
+  }
+
+  return this.finishNode(node, "ImportExpression")
+};
+
+pp$3.parseImportMeta = function(node) {
+  this.next(); // skip `.`
+
+  var containsEsc = this.containsEsc;
+  node.property = this.parseIdent(true);
+
+  if (node.property.name !== "meta")
+    { this.raiseRecoverable(node.property.start, "The only valid meta property for import is 'import.meta'"); }
+  if (containsEsc)
+    { this.raiseRecoverable(node.start, "'import.meta' must not contain escaped characters"); }
+  if (this.options.sourceType !== "module" && !this.options.allowImportExportEverywhere)
+    { this.raiseRecoverable(node.start, "Cannot use 'import.meta' outside a module"); }
+
+  return this.finishNode(node, "MetaProperty")
+};
+
+pp$3.parseLiteral = function(value) {
+  var node = this.startNode();
+  node.value = value;
+  node.raw = this.input.slice(this.start, this.end);
+  if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint = node.raw.slice(0, -1).replace(/_/g, ""); }
+  this.next();
+  return this.finishNode(node, "Literal")
+};
+
+pp$3.parseParenExpression = function() {
+  this.expect(types.parenL);
+  var val = this.parseExpression();
+  this.expect(types.parenR);
+  return val
+};
+
+pp$3.parseParenAndDistinguishExpression = function(canBeArrow) {
+  var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
+  if (this.options.ecmaVersion >= 6) {
+    this.next();
+
+    var innerStartPos = this.start, innerStartLoc = this.startLoc;
+    var exprList = [], first = true, lastIsComma = false;
+    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;
+    this.yieldPos = 0;
+    this.awaitPos = 0;
+    // Do not save awaitIdentPos to allow checking awaits nested in parameters
+    while (this.type !== types.parenR) {
+      first ? first = false : this.expect(types.comma);
+      if (allowTrailingComma && this.afterTrailingComma(types.parenR, true)) {
+        lastIsComma = true;
+        break
+      } else if (this.type === types.ellipsis) {
+        spreadStart = this.start;
+        exprList.push(this.parseParenItem(this.parseRestBinding()));
+        if (this.type === types.comma) { this.raise(this.start, "Comma is not permitted after the rest element"); }
+        break
+      } else {
+        exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));
+      }
+    }
+    var innerEndPos = this.start, innerEndLoc = this.startLoc;
+    this.expect(types.parenR);
+
+    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
+      this.checkPatternErrors(refDestructuringErrors, false);
+      this.checkYieldAwaitInDefaultParams();
+      this.yieldPos = oldYieldPos;
+      this.awaitPos = oldAwaitPos;
+      return this.parseParenArrowList(startPos, startLoc, exprList)
+    }
+
+    if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }
+    if (spreadStart) { this.unexpected(spreadStart); }
+    this.checkExpressionErrors(refDestructuringErrors, true);
+    this.yieldPos = oldYieldPos || this.yieldPos;
+    this.awaitPos = oldAwaitPos || this.awaitPos;
+
+    if (exprList.length > 1) {
+      val = this.startNodeAt(innerStartPos, innerStartLoc);
+      val.expressions = exprList;
+      this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
+    } else {
+      val = exprList[0];
+    }
+  } else {
+    val = this.parseParenExpression();
+  }
+
+  if (this.options.preserveParens) {
+    var par = this.startNodeAt(startPos, startLoc);
+    par.expression = val;
+    return this.finishNode(par, "ParenthesizedExpression")
+  } else {
+    return val
+  }
+};
+
+pp$3.parseParenItem = function(item) {
+  return item
+};
+
+pp$3.parseParenArrowList = function(startPos, startLoc, exprList) {
+  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
+};
+
+// New's precedence is slightly tricky. It must allow its argument to
+// be a `[]` or dot subscript expression, but not a call — at least,
+// not without wrapping it in parentheses. Thus, it uses the noCalls
+// argument to parseSubscripts to prevent it from consuming the
+// argument list.
+
+var empty$1 = [];
+
+pp$3.parseNew = function() {
+  if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword new"); }
+  var node = this.startNode();
+  var meta = this.parseIdent(true);
+  if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {
+    node.meta = meta;
+    var containsEsc = this.containsEsc;
+    node.property = this.parseIdent(true);
+    if (node.property.name !== "target")
+      { this.raiseRecoverable(node.property.start, "The only valid meta property for new is 'new.target'"); }
+    if (containsEsc)
+      { this.raiseRecoverable(node.start, "'new.target' must not contain escaped characters"); }
+    if (!this.inNonArrowFunction)
+      { this.raiseRecoverable(node.start, "'new.target' can only be used in functions"); }
+    return this.finishNode(node, "MetaProperty")
+  }
+  var startPos = this.start, startLoc = this.startLoc, isImport = this.type === types._import;
+  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
+  if (isImport && node.callee.type === "ImportExpression") {
+    this.raise(startPos, "Cannot use new with import()");
+  }
+  if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false); }
+  else { node.arguments = empty$1; }
+  return this.finishNode(node, "NewExpression")
+};
+
+// Parse template expression.
+
+pp$3.parseTemplateElement = function(ref) {
+  var isTagged = ref.isTagged;
+
+  var elem = this.startNode();
+  if (this.type === types.invalidTemplate) {
+    if (!isTagged) {
+      this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
+    }
+    elem.value = {
+      raw: this.value,
+      cooked: null
+    };
+  } else {
+    elem.value = {
+      raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
+      cooked: this.value
+    };
+  }
+  this.next();
+  elem.tail = this.type === types.backQuote;
+  return this.finishNode(elem, "TemplateElement")
+};
+
+pp$3.parseTemplate = function(ref) {
+  if ( ref === void 0 ) ref = {};
+  var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;
+
+  var node = this.startNode();
+  this.next();
+  node.expressions = [];
+  var curElt = this.parseTemplateElement({isTagged: isTagged});
+  node.quasis = [curElt];
+  while (!curElt.tail) {
+    if (this.type === types.eof) { this.raise(this.pos, "Unterminated template literal"); }
+    this.expect(types.dollarBraceL);
+    node.expressions.push(this.parseExpression());
+    this.expect(types.braceR);
+    node.quasis.push(curElt = this.parseTemplateElement({isTagged: isTagged}));
+  }
+  this.next();
+  return this.finishNode(node, "TemplateLiteral")
+};
+
+pp$3.isAsyncProp = function(prop) {
+  return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
+    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&
+    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+};
+
+// Parse an object literal or binding pattern.
+
+pp$3.parseObj = function(isPattern, refDestructuringErrors) {
+  var node = this.startNode(), first = true, propHash = {};
+  node.properties = [];
+  this.next();
+  while (!this.eat(types.braceR)) {
+    if (!first) {
+      this.expect(types.comma);
+      if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types.braceR)) { break }
+    } else { first = false; }
+
+    var prop = this.parseProperty(isPattern, refDestructuringErrors);
+    if (!isPattern) { this.checkPropClash(prop, propHash, refDestructuringErrors); }
+    node.properties.push(prop);
+  }
+  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
+};
+
+pp$3.parseProperty = function(isPattern, refDestructuringErrors) {
+  var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
+  if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {
+    if (isPattern) {
+      prop.argument = this.parseIdent(false);
+      if (this.type === types.comma) {
+        this.raise(this.start, "Comma is not permitted after the rest element");
+      }
+      return this.finishNode(prop, "RestElement")
+    }
+    // To disallow parenthesized identifier via `this.toAssignable()`.
+    if (this.type === types.parenL && refDestructuringErrors) {
+      if (refDestructuringErrors.parenthesizedAssign < 0) {
+        refDestructuringErrors.parenthesizedAssign = this.start;
+      }
+      if (refDestructuringErrors.parenthesizedBind < 0) {
+        refDestructuringErrors.parenthesizedBind = this.start;
+      }
+    }
+    // Parse argument.
+    prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
+    // To disallow trailing comma via `this.toAssignable()`.
+    if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
+      refDestructuringErrors.trailingComma = this.start;
+    }
+    // Finish
+    return this.finishNode(prop, "SpreadElement")
+  }
+  if (this.options.ecmaVersion >= 6) {
+    prop.method = false;
+    prop.shorthand = false;
+    if (isPattern || refDestructuringErrors) {
+      startPos = this.start;
+      startLoc = this.startLoc;
+    }
+    if (!isPattern)
+      { isGenerator = this.eat(types.star); }
+  }
+  var containsEsc = this.containsEsc;
+  this.parsePropertyName(prop);
+  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
+    isAsync = true;
+    isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
+    this.parsePropertyName(prop, refDestructuringErrors);
+  } else {
+    isAsync = false;
+  }
+  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
+  return this.finishNode(prop, "Property")
+};
+
+pp$3.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
+  if ((isGenerator || isAsync) && this.type === types.colon)
+    { this.unexpected(); }
+
+  if (this.eat(types.colon)) {
+    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
+    prop.kind = "init";
+  } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {
+    if (isPattern) { this.unexpected(); }
+    prop.kind = "init";
+    prop.method = true;
+    prop.value = this.parseMethod(isGenerator, isAsync);
+  } else if (!isPattern && !containsEsc &&
+             this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+             (prop.key.name === "get" || prop.key.name === "set") &&
+             (this.type !== types.comma && this.type !== types.braceR && this.type !== types.eq)) {
+    if (isGenerator || isAsync) { this.unexpected(); }
+    prop.kind = prop.key.name;
+    this.parsePropertyName(prop);
+    prop.value = this.parseMethod(false);
+    var paramCount = prop.kind === "get" ? 0 : 1;
+    if (prop.value.params.length !== paramCount) {
+      var start = prop.value.start;
+      if (prop.kind === "get")
+        { this.raiseRecoverable(start, "getter should have no params"); }
+      else
+        { this.raiseRecoverable(start, "setter should have exactly one param"); }
+    } else {
+      if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
+        { this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params"); }
+    }
+  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+    if (isGenerator || isAsync) { this.unexpected(); }
+    this.checkUnreserved(prop.key);
+    if (prop.key.name === "await" && !this.awaitIdentPos)
+      { this.awaitIdentPos = startPos; }
+    prop.kind = "init";
+    if (isPattern) {
+      prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key));
+    } else if (this.type === types.eq && refDestructuringErrors) {
+      if (refDestructuringErrors.shorthandAssign < 0)
+        { refDestructuringErrors.shorthandAssign = this.start; }
+      prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key));
+    } else {
+      prop.value = this.copyNode(prop.key);
+    }
+    prop.shorthand = true;
+  } else { this.unexpected(); }
+};
+
+pp$3.parsePropertyName = function(prop) {
+  if (this.options.ecmaVersion >= 6) {
+    if (this.eat(types.bracketL)) {
+      prop.computed = true;
+      prop.key = this.parseMaybeAssign();
+      this.expect(types.bracketR);
+      return prop.key
+    } else {
+      prop.computed = false;
+    }
+  }
+  return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never")
+};
+
+// Initialize empty function node.
+
+pp$3.initFunction = function(node) {
+  node.id = null;
+  if (this.options.ecmaVersion >= 6) { node.generator = node.expression = false; }
+  if (this.options.ecmaVersion >= 8) { node.async = false; }
+};
+
+// Parse object or class method.
+
+pp$3.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {
+  var node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6)
+    { node.generator = isGenerator; }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.awaitIdentPos = 0;
+  this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
+
+  this.expect(types.parenL);
+  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
+  this.checkYieldAwaitInDefaultParams();
+  this.parseFunctionBody(node, false, true);
+
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.awaitIdentPos = oldAwaitIdentPos;
+  return this.finishNode(node, "FunctionExpression")
+};
+
+// Parse arrow function expression with given parameters.
+
+pp$3.parseArrowExpression = function(node, params, isAsync) {
+  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;
+
+  this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW);
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 8) { node.async = !!isAsync; }
+
+  this.yieldPos = 0;
+  this.awaitPos = 0;
+  this.awaitIdentPos = 0;
+
+  node.params = this.toAssignableList(params, true);
+  this.parseFunctionBody(node, true, false);
+
+  this.yieldPos = oldYieldPos;
+  this.awaitPos = oldAwaitPos;
+  this.awaitIdentPos = oldAwaitIdentPos;
+  return this.finishNode(node, "ArrowFunctionExpression")
+};
+
+// Parse function body and check parameters.
+
+pp$3.parseFunctionBody = function(node, isArrowFunction, isMethod) {
+  var isExpression = isArrowFunction && this.type !== types.braceL;
+  var oldStrict = this.strict, useStrict = false;
+
+  if (isExpression) {
+    node.body = this.parseMaybeAssign();
+    node.expression = true;
+    this.checkParams(node, false);
+  } else {
+    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);
+    if (!oldStrict || nonSimple) {
+      useStrict = this.strictDirective(this.end);
+      // If this is a strict mode function, verify that argument names
+      // are not repeated, and it does not try to bind the words `eval`
+      // or `arguments`.
+      if (useStrict && nonSimple)
+        { this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list"); }
+    }
+    // Start a new scope with regard to labels and the `inFunction`
+    // flag (restore them to their old value afterwards).
+    var oldLabels = this.labels;
+    this.labels = [];
+    if (useStrict) { this.strict = true; }
+
+    // Add the params to varDeclaredNames to ensure that an error is thrown
+    // if a let/const declaration in the function clashes with one of the params.
+    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params));
+    // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'
+    if (this.strict && node.id) { this.checkLValSimple(node.id, BIND_OUTSIDE); }
+    node.body = this.parseBlock(false, undefined, useStrict && !oldStrict);
+    node.expression = false;
+    this.adaptDirectivePrologue(node.body.body);
+    this.labels = oldLabels;
+  }
+  this.exitScope();
+};
+
+pp$3.isSimpleParamList = function(params) {
+  for (var i = 0, list = params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    if (param.type !== "Identifier") { return false
+  } }
+  return true
+};
+
+// Checks function params for various disallowed patterns such as using "eval"
+// or "arguments" and duplicate parameters.
+
+pp$3.checkParams = function(node, allowDuplicates) {
+  var nameHash = Object.create(null);
+  for (var i = 0, list = node.params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    this.checkLValInnerPattern(param, BIND_VAR, allowDuplicates ? null : nameHash);
+  }
+};
+
+// Parses a comma-separated list of expressions, and returns them as
+// an array. `close` is the token type that ends the list, and
+// `allowEmpty` can be turned on to allow subsequent commas with
+// nothing in between them to be parsed as `null` (which is needed
+// for array literals).
+
+pp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
+  var elts = [], first = true;
+  while (!this.eat(close)) {
+    if (!first) {
+      this.expect(types.comma);
+      if (allowTrailingComma && this.afterTrailingComma(close)) { break }
+    } else { first = false; }
+
+    var elt = (void 0);
+    if (allowEmpty && this.type === types.comma)
+      { elt = null; }
+    else if (this.type === types.ellipsis) {
+      elt = this.parseSpread(refDestructuringErrors);
+      if (refDestructuringErrors && this.type === types.comma && refDestructuringErrors.trailingComma < 0)
+        { refDestructuringErrors.trailingComma = this.start; }
+    } else {
+      elt = this.parseMaybeAssign(false, refDestructuringErrors);
+    }
+    elts.push(elt);
+  }
+  return elts
+};
+
+pp$3.checkUnreserved = function(ref) {
+  var start = ref.start;
+  var end = ref.end;
+  var name = ref.name;
+
+  if (this.inGenerator && name === "yield")
+    { this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator"); }
+  if (this.inAsync && name === "await")
+    { this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function"); }
+  if (this.currentThisScope().inClassFieldInit && name === "arguments")
+    { this.raiseRecoverable(start, "Cannot use 'arguments' in class field initializer"); }
+  if (this.keywords.test(name))
+    { this.raise(start, ("Unexpected keyword '" + name + "'")); }
+  if (this.options.ecmaVersion < 6 &&
+    this.input.slice(start, end).indexOf("\\") !== -1) { return }
+  var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
+  if (re.test(name)) {
+    if (!this.inAsync && name === "await")
+      { this.raiseRecoverable(start, "Cannot use keyword 'await' outside an async function"); }
+    this.raiseRecoverable(start, ("The keyword '" + name + "' is reserved"));
+  }
+};
+
+// Parse the next token as an identifier. If `liberal` is true (used
+// when parsing properties), it will also convert keywords into
+// identifiers.
+
+pp$3.parseIdent = function(liberal, isBinding) {
+  var node = this.startNode();
+  if (this.type === types.name) {
+    node.name = this.value;
+  } else if (this.type.keyword) {
+    node.name = this.type.keyword;
+
+    // To fix https://github.com/acornjs/acorn/issues/575
+    // `class` and `function` keywords push new context into this.context.
+    // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.
+    // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword
+    if ((node.name === "class" || node.name === "function") &&
+        (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
+      this.context.pop();
+    }
+  } else {
+    this.unexpected();
+  }
+  this.next(!!liberal);
+  this.finishNode(node, "Identifier");
+  if (!liberal) {
+    this.checkUnreserved(node);
+    if (node.name === "await" && !this.awaitIdentPos)
+      { this.awaitIdentPos = node.start; }
+  }
+  return node
+};
+
+pp$3.parsePrivateIdent = function() {
+  var node = this.startNode();
+  if (this.type === types.privateId) {
+    node.name = this.value;
+  } else {
+    this.unexpected();
+  }
+  this.next();
+  this.finishNode(node, "PrivateIdentifier");
+
+  // For validating existence
+  if (this.privateNameStack.length === 0) {
+    this.raise(node.start, ("Private field '#" + (node.name) + "' must be declared in an enclosing class"));
+  } else {
+    this.privateNameStack[this.privateNameStack.length - 1].used.push(node);
+  }
+
+  return node
+};
+
+// Parses yield expression inside generator.
+
+pp$3.parseYield = function(forInit) {
+  if (!this.yieldPos) { this.yieldPos = this.start; }
+
+  var node = this.startNode();
+  this.next();
+  if (this.type === types.semi || this.canInsertSemicolon() || (this.type !== types.star && !this.type.startsExpr)) {
+    node.delegate = false;
+    node.argument = null;
+  } else {
+    node.delegate = this.eat(types.star);
+    node.argument = this.parseMaybeAssign(forInit);
+  }
+  return this.finishNode(node, "YieldExpression")
+};
+
+pp$3.parseAwait = function() {
+  if (!this.awaitPos) { this.awaitPos = this.start; }
+
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeUnary(null, true);
+  return this.finishNode(node, "AwaitExpression")
+};
+
+var pp$4 = Parser.prototype;
+
+// This function is used to raise exceptions on parse errors. It
+// takes an offset integer (into the current `input`) to indicate
+// the location of the error, attaches the position to the end
+// of the error message, and then raises a `SyntaxError` with that
+// message.
+
+pp$4.raise = function(pos, message) {
+  var loc = getLineInfo(this.input, pos);
+  message += " (" + loc.line + ":" + loc.column + ")";
+  var err = new SyntaxError(message);
+  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
+  throw err
+};
+
+pp$4.raiseRecoverable = pp$4.raise;
+
+pp$4.curPosition = function() {
+  if (this.options.locations) {
+    return new Position(this.curLine, this.pos - this.lineStart)
+  }
+};
+
+var pp$5 = Parser.prototype;
+
+var Scope = function Scope(flags) {
+  this.flags = flags;
+  // A list of var-declared names in the current lexical scope
+  this.var = [];
+  // A list of lexically-declared names in the current lexical scope
+  this.lexical = [];
+  // A list of lexically-declared FunctionDeclaration names in the current lexical scope
+  this.functions = [];
+  // A switch to disallow the identifier reference 'arguments'
+  this.inClassFieldInit = false;
+};
+
+// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.
+
+pp$5.enterScope = function(flags) {
+  this.scopeStack.push(new Scope(flags));
+};
+
+pp$5.exitScope = function() {
+  this.scopeStack.pop();
+};
+
+// The spec says:
+// > At the top level of a function, or script, function declarations are
+// > treated like var declarations rather than like lexical declarations.
+pp$5.treatFunctionsAsVarInScope = function(scope) {
+  return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)
+};
+
+pp$5.declareName = function(name, bindingType, pos) {
+  var redeclared = false;
+  if (bindingType === BIND_LEXICAL) {
+    var scope = this.currentScope();
+    redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;
+    scope.lexical.push(name);
+    if (this.inModule && (scope.flags & SCOPE_TOP))
+      { delete this.undefinedExports[name]; }
+  } else if (bindingType === BIND_SIMPLE_CATCH) {
+    var scope$1 = this.currentScope();
+    scope$1.lexical.push(name);
+  } else if (bindingType === BIND_FUNCTION) {
+    var scope$2 = this.currentScope();
+    if (this.treatFunctionsAsVar)
+      { redeclared = scope$2.lexical.indexOf(name) > -1; }
+    else
+      { redeclared = scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1; }
+    scope$2.functions.push(name);
+  } else {
+    for (var i = this.scopeStack.length - 1; i >= 0; --i) {
+      var scope$3 = this.scopeStack[i];
+      if (scope$3.lexical.indexOf(name) > -1 && !((scope$3.flags & SCOPE_SIMPLE_CATCH) && scope$3.lexical[0] === name) ||
+          !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) {
+        redeclared = true;
+        break
+      }
+      scope$3.var.push(name);
+      if (this.inModule && (scope$3.flags & SCOPE_TOP))
+        { delete this.undefinedExports[name]; }
+      if (scope$3.flags & SCOPE_VAR) { break }
+    }
+  }
+  if (redeclared) { this.raiseRecoverable(pos, ("Identifier '" + name + "' has already been declared")); }
+};
+
+pp$5.checkLocalExport = function(id) {
+  // scope.functions must be empty as Module code is always strict.
+  if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&
+      this.scopeStack[0].var.indexOf(id.name) === -1) {
+    this.undefinedExports[id.name] = id;
+  }
+};
+
+pp$5.currentScope = function() {
+  return this.scopeStack[this.scopeStack.length - 1]
+};
+
+pp$5.currentVarScope = function() {
+  for (var i = this.scopeStack.length - 1;; i--) {
+    var scope = this.scopeStack[i];
+    if (scope.flags & SCOPE_VAR) { return scope }
+  }
+};
+
+// Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`.
+pp$5.currentThisScope = function() {
+  for (var i = this.scopeStack.length - 1;; i--) {
+    var scope = this.scopeStack[i];
+    if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) { return scope }
+  }
+};
+
+var Node = function Node(parser, pos, loc) {
+  this.type = "";
+  this.start = pos;
+  this.end = 0;
+  if (parser.options.locations)
+    { this.loc = new SourceLocation(parser, loc); }
+  if (parser.options.directSourceFile)
+    { this.sourceFile = parser.options.directSourceFile; }
+  if (parser.options.ranges)
+    { this.range = [pos, 0]; }
+};
+
+// Start an AST node, attaching a start offset.
+
+var pp$6 = Parser.prototype;
+
+pp$6.startNode = function() {
+  return new Node(this, this.start, this.startLoc)
+};
+
+pp$6.startNodeAt = function(pos, loc) {
+  return new Node(this, pos, loc)
+};
+
+// Finish an AST node, adding `type` and `end` properties.
+
+function finishNodeAt(node, type, pos, loc) {
+  node.type = type;
+  node.end = pos;
+  if (this.options.locations)
+    { node.loc.end = loc; }
+  if (this.options.ranges)
+    { node.range[1] = pos; }
+  return node
+}
+
+pp$6.finishNode = function(node, type) {
+  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
+};
+
+// Finish node at given position
+
+pp$6.finishNodeAt = function(node, type, pos, loc) {
+  return finishNodeAt.call(this, node, type, pos, loc)
+};
+
+pp$6.copyNode = function(node) {
+  var newNode = new Node(this, node.start, this.startLoc);
+  for (var prop in node) { newNode[prop] = node[prop]; }
+  return newNode
+};
+
+// The algorithm used to determine whether a regexp can appear at a
+
+var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
+  this.token = token;
+  this.isExpr = !!isExpr;
+  this.preserveSpace = !!preserveSpace;
+  this.override = override;
+  this.generator = !!generator;
+};
+
+var types$1 = {
+  b_stat: new TokContext("{", false),
+  b_expr: new TokContext("{", true),
+  b_tmpl: new TokContext("${", false),
+  p_stat: new TokContext("(", false),
+  p_expr: new TokContext("(", true),
+  q_tmpl: new TokContext("`", true, true, function (p) { return p.tryReadTemplateToken(); }),
+  f_stat: new TokContext("function", false),
+  f_expr: new TokContext("function", true),
+  f_expr_gen: new TokContext("function", true, false, null, true),
+  f_gen: new TokContext("function", false, false, null, true)
+};
+
+var pp$7 = Parser.prototype;
+
+pp$7.initialContext = function() {
+  return [types$1.b_stat]
+};
+
+pp$7.braceIsBlock = function(prevType) {
+  var parent = this.curContext();
+  if (parent === types$1.f_expr || parent === types$1.f_stat)
+    { return true }
+  if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))
+    { return !parent.isExpr }
+
+  // The check for `tt.name && exprAllowed` detects whether we are
+  // after a `yield` or `of` construct. See the `updateContext` for
+  // `tt.name`.
+  if (prevType === types._return || prevType === types.name && this.exprAllowed)
+    { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }
+  if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow)
+    { return true }
+  if (prevType === types.braceL)
+    { return parent === types$1.b_stat }
+  if (prevType === types._var || prevType === types._const || prevType === types.name)
+    { return false }
+  return !this.exprAllowed
+};
+
+pp$7.inGeneratorContext = function() {
+  for (var i = this.context.length - 1; i >= 1; i--) {
+    var context = this.context[i];
+    if (context.token === "function")
+      { return context.generator }
+  }
+  return false
+};
+
+pp$7.updateContext = function(prevType) {
+  var update, type = this.type;
+  if (type.keyword && prevType === types.dot)
+    { this.exprAllowed = false; }
+  else if (update = type.updateContext)
+    { update.call(this, prevType); }
+  else
+    { this.exprAllowed = type.beforeExpr; }
+};
+
+// Token-specific context update code
+
+types.parenR.updateContext = types.braceR.updateContext = function() {
+  if (this.context.length === 1) {
+    this.exprAllowed = true;
+    return
+  }
+  var out = this.context.pop();
+  if (out === types$1.b_stat && this.curContext().token === "function") {
+    out = this.context.pop();
+  }
+  this.exprAllowed = !out.isExpr;
+};
+
+types.braceL.updateContext = function(prevType) {
+  this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);
+  this.exprAllowed = true;
+};
+
+types.dollarBraceL.updateContext = function() {
+  this.context.push(types$1.b_tmpl);
+  this.exprAllowed = true;
+};
+
+types.parenL.updateContext = function(prevType) {
+  var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;
+  this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);
+  this.exprAllowed = true;
+};
+
+types.incDec.updateContext = function() {
+  // tokExprAllowed stays unchanged
+};
+
+types._function.updateContext = types._class.updateContext = function(prevType) {
+  if (prevType.beforeExpr && prevType !== types._else &&
+      !(prevType === types.semi && this.curContext() !== types$1.p_stat) &&
+      !(prevType === types._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&
+      !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
+    { this.context.push(types$1.f_expr); }
+  else
+    { this.context.push(types$1.f_stat); }
+  this.exprAllowed = false;
+};
+
+types.backQuote.updateContext = function() {
+  if (this.curContext() === types$1.q_tmpl)
+    { this.context.pop(); }
+  else
+    { this.context.push(types$1.q_tmpl); }
+  this.exprAllowed = false;
+};
+
+types.star.updateContext = function(prevType) {
+  if (prevType === types._function) {
+    var index = this.context.length - 1;
+    if (this.context[index] === types$1.f_expr)
+      { this.context[index] = types$1.f_expr_gen; }
+    else
+      { this.context[index] = types$1.f_gen; }
+  }
+  this.exprAllowed = true;
+};
+
+types.name.updateContext = function(prevType) {
+  var allowed = false;
+  if (this.options.ecmaVersion >= 6 && prevType !== types.dot) {
+    if (this.value === "of" && !this.exprAllowed ||
+        this.value === "yield" && this.inGeneratorContext())
+      { allowed = true; }
+  }
+  this.exprAllowed = allowed;
+};
+
+// This file contains Unicode properties extracted from the ECMAScript
+// specification. The lists are extracted like so:
+// $$('#table-binary-unicode-properties > figure > table > tbody > tr > td:nth-child(1) code').map(el => el.innerText)
+
+// #table-binary-unicode-properties
+var ecma9BinaryProperties = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS";
+var ecma10BinaryProperties = ecma9BinaryProperties + " Extended_Pictographic";
+var ecma11BinaryProperties = ecma10BinaryProperties;
+var ecma12BinaryProperties = ecma11BinaryProperties + " EBase EComp EMod EPres ExtPict";
+var unicodeBinaryProperties = {
+  9: ecma9BinaryProperties,
+  10: ecma10BinaryProperties,
+  11: ecma11BinaryProperties,
+  12: ecma12BinaryProperties
+};
+
+// #table-unicode-general-category-values
+var unicodeGeneralCategoryValues = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu";
+
+// #table-unicode-script-values
+var ecma9ScriptValues = "Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb";
+var ecma10ScriptValues = ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd";
+var ecma11ScriptValues = ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho";
+var ecma12ScriptValues = ecma11ScriptValues + " Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi";
+var unicodeScriptValues = {
+  9: ecma9ScriptValues,
+  10: ecma10ScriptValues,
+  11: ecma11ScriptValues,
+  12: ecma12ScriptValues
+};
+
+var data = {};
+function buildUnicodeData(ecmaVersion) {
+  var d = data[ecmaVersion] = {
+    binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + " " + unicodeGeneralCategoryValues),
+    nonBinary: {
+      General_Category: wordsRegexp(unicodeGeneralCategoryValues),
+      Script: wordsRegexp(unicodeScriptValues[ecmaVersion])
+    }
+  };
+  d.nonBinary.Script_Extensions = d.nonBinary.Script;
+
+  d.nonBinary.gc = d.nonBinary.General_Category;
+  d.nonBinary.sc = d.nonBinary.Script;
+  d.nonBinary.scx = d.nonBinary.Script_Extensions;
+}
+buildUnicodeData(9);
+buildUnicodeData(10);
+buildUnicodeData(11);
+buildUnicodeData(12);
+
+var pp$8 = Parser.prototype;
+
+var RegExpValidationState = function RegExpValidationState(parser) {
+  this.parser = parser;
+  this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "") + (parser.options.ecmaVersion >= 13 ? "d" : "");
+  this.unicodeProperties = data[parser.options.ecmaVersion >= 12 ? 12 : parser.options.ecmaVersion];
+  this.source = "";
+  this.flags = "";
+  this.start = 0;
+  this.switchU = false;
+  this.switchN = false;
+  this.pos = 0;
+  this.lastIntValue = 0;
+  this.lastStringValue = "";
+  this.lastAssertionIsQuantifiable = false;
+  this.numCapturingParens = 0;
+  this.maxBackReference = 0;
+  this.groupNames = [];
+  this.backReferenceNames = [];
+};
+
+RegExpValidationState.prototype.reset = function reset (start, pattern, flags) {
+  var unicode = flags.indexOf("u") !== -1;
+  this.start = start | 0;
+  this.source = pattern + "";
+  this.flags = flags;
+  this.switchU = unicode && this.parser.options.ecmaVersion >= 6;
+  this.switchN = unicode && this.parser.options.ecmaVersion >= 9;
+};
+
+RegExpValidationState.prototype.raise = function raise (message) {
+  this.parser.raiseRecoverable(this.start, ("Invalid regular expression: /" + (this.source) + "/: " + message));
+};
+
+// If u flag is given, this returns the code point at the index (it combines a surrogate pair).
+// Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).
+RegExpValidationState.prototype.at = function at (i, forceU) {
+    if ( forceU === void 0 ) forceU = false;
+
+  var s = this.source;
+  var l = s.length;
+  if (i >= l) {
+    return -1
+  }
+  var c = s.charCodeAt(i);
+  if (!(forceU || this.switchU) || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
+    return c
+  }
+  var next = s.charCodeAt(i + 1);
+  return next >= 0xDC00 && next <= 0xDFFF ? (c << 10) + next - 0x35FDC00 : c
+};
+
+RegExpValidationState.prototype.nextIndex = function nextIndex (i, forceU) {
+    if ( forceU === void 0 ) forceU = false;
+
+  var s = this.source;
+  var l = s.length;
+  if (i >= l) {
+    return l
+  }
+  var c = s.charCodeAt(i), next;
+  if (!(forceU || this.switchU) || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l ||
+      (next = s.charCodeAt(i + 1)) < 0xDC00 || next > 0xDFFF) {
+    return i + 1
+  }
+  return i + 2
+};
+
+RegExpValidationState.prototype.current = function current (forceU) {
+    if ( forceU === void 0 ) forceU = false;
+
+  return this.at(this.pos, forceU)
+};
+
+RegExpValidationState.prototype.lookahead = function lookahead (forceU) {
+    if ( forceU === void 0 ) forceU = false;
+
+  return this.at(this.nextIndex(this.pos, forceU), forceU)
+};
+
+RegExpValidationState.prototype.advance = function advance (forceU) {
+    if ( forceU === void 0 ) forceU = false;
+
+  this.pos = this.nextIndex(this.pos, forceU);
+};
+
+RegExpValidationState.prototype.eat = function eat (ch, forceU) {
+    if ( forceU === void 0 ) forceU = false;
+
+  if (this.current(forceU) === ch) {
+    this.advance(forceU);
+    return true
+  }
+  return false
+};
+
+function codePointToString(ch) {
+  if (ch <= 0xFFFF) { return String.fromCharCode(ch) }
+  ch -= 0x10000;
+  return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)
+}
+
+/**
+ * Validate the flags part of a given RegExpLiteral.
+ *
+ * @param {RegExpValidationState} state The state to validate RegExp.
+ * @returns {void}
+ */
+pp$8.validateRegExpFlags = function(state) {
+  var validFlags = state.validFlags;
+  var flags = state.flags;
+
+  for (var i = 0; i < flags.length; i++) {
+    var flag = flags.charAt(i);
+    if (validFlags.indexOf(flag) === -1) {
+      this.raise(state.start, "Invalid regular expression flag");
+    }
+    if (flags.indexOf(flag, i + 1) > -1) {
+      this.raise(state.start, "Duplicate regular expression flag");
+    }
+  }
+};
+
+/**
+ * Validate the pattern part of a given RegExpLiteral.
+ *
+ * @param {RegExpValidationState} state The state to validate RegExp.
+ * @returns {void}
+ */
+pp$8.validateRegExpPattern = function(state) {
+  this.regexp_pattern(state);
+
+  // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of
+  // parsing contains a |GroupName|, reparse with the goal symbol
+  // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*
+  // exception if _P_ did not conform to the grammar, if any elements of _P_
+  // were not matched by the parse, or if any Early Error conditions exist.
+  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
+    state.switchN = true;
+    this.regexp_pattern(state);
+  }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern
+pp$8.regexp_pattern = function(state) {
+  state.pos = 0;
+  state.lastIntValue = 0;
+  state.lastStringValue = "";
+  state.lastAssertionIsQuantifiable = false;
+  state.numCapturingParens = 0;
+  state.maxBackReference = 0;
+  state.groupNames.length = 0;
+  state.backReferenceNames.length = 0;
+
+  this.regexp_disjunction(state);
+
+  if (state.pos !== state.source.length) {
+    // Make the same messages as V8.
+    if (state.eat(0x29 /* ) */)) {
+      state.raise("Unmatched ')'");
+    }
+    if (state.eat(0x5D /* ] */) || state.eat(0x7D /* } */)) {
+      state.raise("Lone quantifier brackets");
+    }
+  }
+  if (state.maxBackReference > state.numCapturingParens) {
+    state.raise("Invalid escape");
+  }
+  for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {
+    var name = list[i];
+
+    if (state.groupNames.indexOf(name) === -1) {
+      state.raise("Invalid named capture referenced");
+    }
+  }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction
+pp$8.regexp_disjunction = function(state) {
+  this.regexp_alternative(state);
+  while (state.eat(0x7C /* | */)) {
+    this.regexp_alternative(state);
+  }
+
+  // Make the same message as V8.
+  if (this.regexp_eatQuantifier(state, true)) {
+    state.raise("Nothing to repeat");
+  }
+  if (state.eat(0x7B /* { */)) {
+    state.raise("Lone quantifier brackets");
+  }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative
+pp$8.regexp_alternative = function(state) {
+  while (state.pos < state.source.length && this.regexp_eatTerm(state))
+    { }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term
+pp$8.regexp_eatTerm = function(state) {
+  if (this.regexp_eatAssertion(state)) {
+    // Handle `QuantifiableAssertion Quantifier` alternative.
+    // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion
+    // is a QuantifiableAssertion.
+    if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {
+      // Make the same message as V8.
+      if (state.switchU) {
+        state.raise("Invalid quantifier");
+      }
+    }
+    return true
+  }
+
+  if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {
+    this.regexp_eatQuantifier(state);
+    return true
+  }
+
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion
+pp$8.regexp_eatAssertion = function(state) {
+  var start = state.pos;
+  state.lastAssertionIsQuantifiable = false;
+
+  // ^, $
+  if (state.eat(0x5E /* ^ */) || state.eat(0x24 /* $ */)) {
+    return true
+  }
+
+  // \b \B
+  if (state.eat(0x5C /* \ */)) {
+    if (state.eat(0x42 /* B */) || state.eat(0x62 /* b */)) {
+      return true
+    }
+    state.pos = start;
+  }
+
+  // Lookahead / Lookbehind
+  if (state.eat(0x28 /* ( */) && state.eat(0x3F /* ? */)) {
+    var lookbehind = false;
+    if (this.options.ecmaVersion >= 9) {
+      lookbehind = state.eat(0x3C /* < */);
+    }
+    if (state.eat(0x3D /* = */) || state.eat(0x21 /* ! */)) {
+      this.regexp_disjunction(state);
+      if (!state.eat(0x29 /* ) */)) {
+        state.raise("Unterminated group");
+      }
+      state.lastAssertionIsQuantifiable = !lookbehind;
+      return true
+    }
+  }
+
+  state.pos = start;
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier
+pp$8.regexp_eatQuantifier = function(state, noError) {
+  if ( noError === void 0 ) noError = false;
+
+  if (this.regexp_eatQuantifierPrefix(state, noError)) {
+    state.eat(0x3F /* ? */);
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix
+pp$8.regexp_eatQuantifierPrefix = function(state, noError) {
+  return (
+    state.eat(0x2A /* * */) ||
+    state.eat(0x2B /* + */) ||
+    state.eat(0x3F /* ? */) ||
+    this.regexp_eatBracedQuantifier(state, noError)
+  )
+};
+pp$8.regexp_eatBracedQuantifier = function(state, noError) {
+  var start = state.pos;
+  if (state.eat(0x7B /* { */)) {
+    var min = 0, max = -1;
+    if (this.regexp_eatDecimalDigits(state)) {
+      min = state.lastIntValue;
+      if (state.eat(0x2C /* , */) && this.regexp_eatDecimalDigits(state)) {
+        max = state.lastIntValue;
+      }
+      if (state.eat(0x7D /* } */)) {
+        // SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term
+        if (max !== -1 && max < min && !noError) {
+          state.raise("numbers out of order in {} quantifier");
+        }
+        return true
+      }
+    }
+    if (state.switchU && !noError) {
+      state.raise("Incomplete quantifier");
+    }
+    state.pos = start;
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Atom
+pp$8.regexp_eatAtom = function(state) {
+  return (
+    this.regexp_eatPatternCharacters(state) ||
+    state.eat(0x2E /* . */) ||
+    this.regexp_eatReverseSolidusAtomEscape(state) ||
+    this.regexp_eatCharacterClass(state) ||
+    this.regexp_eatUncapturingGroup(state) ||
+    this.regexp_eatCapturingGroup(state)
+  )
+};
+pp$8.regexp_eatReverseSolidusAtomEscape = function(state) {
+  var start = state.pos;
+  if (state.eat(0x5C /* \ */)) {
+    if (this.regexp_eatAtomEscape(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$8.regexp_eatUncapturingGroup = function(state) {
+  var start = state.pos;
+  if (state.eat(0x28 /* ( */)) {
+    if (state.eat(0x3F /* ? */) && state.eat(0x3A /* : */)) {
+      this.regexp_disjunction(state);
+      if (state.eat(0x29 /* ) */)) {
+        return true
+      }
+      state.raise("Unterminated group");
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$8.regexp_eatCapturingGroup = function(state) {
+  if (state.eat(0x28 /* ( */)) {
+    if (this.options.ecmaVersion >= 9) {
+      this.regexp_groupSpecifier(state);
+    } else if (state.current() === 0x3F /* ? */) {
+      state.raise("Invalid group");
+    }
+    this.regexp_disjunction(state);
+    if (state.eat(0x29 /* ) */)) {
+      state.numCapturingParens += 1;
+      return true
+    }
+    state.raise("Unterminated group");
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom
+pp$8.regexp_eatExtendedAtom = function(state) {
+  return (
+    state.eat(0x2E /* . */) ||
+    this.regexp_eatReverseSolidusAtomEscape(state) ||
+    this.regexp_eatCharacterClass(state) ||
+    this.regexp_eatUncapturingGroup(state) ||
+    this.regexp_eatCapturingGroup(state) ||
+    this.regexp_eatInvalidBracedQuantifier(state) ||
+    this.regexp_eatExtendedPatternCharacter(state)
+  )
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier
+pp$8.regexp_eatInvalidBracedQuantifier = function(state) {
+  if (this.regexp_eatBracedQuantifier(state, true)) {
+    state.raise("Nothing to repeat");
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter
+pp$8.regexp_eatSyntaxCharacter = function(state) {
+  var ch = state.current();
+  if (isSyntaxCharacter(ch)) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+  return false
+};
+function isSyntaxCharacter(ch) {
+  return (
+    ch === 0x24 /* $ */ ||
+    ch >= 0x28 /* ( */ && ch <= 0x2B /* + */ ||
+    ch === 0x2E /* . */ ||
+    ch === 0x3F /* ? */ ||
+    ch >= 0x5B /* [ */ && ch <= 0x5E /* ^ */ ||
+    ch >= 0x7B /* { */ && ch <= 0x7D /* } */
+  )
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter
+// But eat eager.
+pp$8.regexp_eatPatternCharacters = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {
+    state.advance();
+  }
+  return state.pos !== start
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter
+pp$8.regexp_eatExtendedPatternCharacter = function(state) {
+  var ch = state.current();
+  if (
+    ch !== -1 &&
+    ch !== 0x24 /* $ */ &&
+    !(ch >= 0x28 /* ( */ && ch <= 0x2B /* + */) &&
+    ch !== 0x2E /* . */ &&
+    ch !== 0x3F /* ? */ &&
+    ch !== 0x5B /* [ */ &&
+    ch !== 0x5E /* ^ */ &&
+    ch !== 0x7C /* | */
+  ) {
+    state.advance();
+    return true
+  }
+  return false
+};
+
+// GroupSpecifier ::
+//   [empty]
+//   `?` GroupName
+pp$8.regexp_groupSpecifier = function(state) {
+  if (state.eat(0x3F /* ? */)) {
+    if (this.regexp_eatGroupName(state)) {
+      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
+        state.raise("Duplicate capture group name");
+      }
+      state.groupNames.push(state.lastStringValue);
+      return
+    }
+    state.raise("Invalid group");
+  }
+};
+
+// GroupName ::
+//   `<` RegExpIdentifierName `>`
+// Note: this updates `state.lastStringValue` property with the eaten name.
+pp$8.regexp_eatGroupName = function(state) {
+  state.lastStringValue = "";
+  if (state.eat(0x3C /* < */)) {
+    if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) {
+      return true
+    }
+    state.raise("Invalid capture group name");
+  }
+  return false
+};
+
+// RegExpIdentifierName ::
+//   RegExpIdentifierStart
+//   RegExpIdentifierName RegExpIdentifierPart
+// Note: this updates `state.lastStringValue` property with the eaten name.
+pp$8.regexp_eatRegExpIdentifierName = function(state) {
+  state.lastStringValue = "";
+  if (this.regexp_eatRegExpIdentifierStart(state)) {
+    state.lastStringValue += codePointToString(state.lastIntValue);
+    while (this.regexp_eatRegExpIdentifierPart(state)) {
+      state.lastStringValue += codePointToString(state.lastIntValue);
+    }
+    return true
+  }
+  return false
+};
+
+// RegExpIdentifierStart ::
+//   UnicodeIDStart
+//   `$`
+//   `_`
+//   `\` RegExpUnicodeEscapeSequence[+U]
+pp$8.regexp_eatRegExpIdentifierStart = function(state) {
+  var start = state.pos;
+  var forceU = this.options.ecmaVersion >= 11;
+  var ch = state.current(forceU);
+  state.advance(forceU);
+
+  if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {
+    ch = state.lastIntValue;
+  }
+  if (isRegExpIdentifierStart(ch)) {
+    state.lastIntValue = ch;
+    return true
+  }
+
+  state.pos = start;
+  return false
+};
+function isRegExpIdentifierStart(ch) {
+  return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */
+}
+
+// RegExpIdentifierPart ::
+//   UnicodeIDContinue
+//   `$`
+//   `_`
+//   `\` RegExpUnicodeEscapeSequence[+U]
+//   <ZWNJ>
+//   <ZWJ>
+pp$8.regexp_eatRegExpIdentifierPart = function(state) {
+  var start = state.pos;
+  var forceU = this.options.ecmaVersion >= 11;
+  var ch = state.current(forceU);
+  state.advance(forceU);
+
+  if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {
+    ch = state.lastIntValue;
+  }
+  if (isRegExpIdentifierPart(ch)) {
+    state.lastIntValue = ch;
+    return true
+  }
+
+  state.pos = start;
+  return false
+};
+function isRegExpIdentifierPart(ch) {
+  return isIdentifierChar(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ || ch === 0x200C /* <ZWNJ> */ || ch === 0x200D /* <ZWJ> */
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape
+pp$8.regexp_eatAtomEscape = function(state) {
+  if (
+    this.regexp_eatBackReference(state) ||
+    this.regexp_eatCharacterClassEscape(state) ||
+    this.regexp_eatCharacterEscape(state) ||
+    (state.switchN && this.regexp_eatKGroupName(state))
+  ) {
+    return true
+  }
+  if (state.switchU) {
+    // Make the same message as V8.
+    if (state.current() === 0x63 /* c */) {
+      state.raise("Invalid unicode escape");
+    }
+    state.raise("Invalid escape");
+  }
+  return false
+};
+pp$8.regexp_eatBackReference = function(state) {
+  var start = state.pos;
+  if (this.regexp_eatDecimalEscape(state)) {
+    var n = state.lastIntValue;
+    if (state.switchU) {
+      // For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape
+      if (n > state.maxBackReference) {
+        state.maxBackReference = n;
+      }
+      return true
+    }
+    if (n <= state.numCapturingParens) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$8.regexp_eatKGroupName = function(state) {
+  if (state.eat(0x6B /* k */)) {
+    if (this.regexp_eatGroupName(state)) {
+      state.backReferenceNames.push(state.lastStringValue);
+      return true
+    }
+    state.raise("Invalid named reference");
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape
+pp$8.regexp_eatCharacterEscape = function(state) {
+  return (
+    this.regexp_eatControlEscape(state) ||
+    this.regexp_eatCControlLetter(state) ||
+    this.regexp_eatZero(state) ||
+    this.regexp_eatHexEscapeSequence(state) ||
+    this.regexp_eatRegExpUnicodeEscapeSequence(state, false) ||
+    (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||
+    this.regexp_eatIdentityEscape(state)
+  )
+};
+pp$8.regexp_eatCControlLetter = function(state) {
+  var start = state.pos;
+  if (state.eat(0x63 /* c */)) {
+    if (this.regexp_eatControlLetter(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+  return false
+};
+pp$8.regexp_eatZero = function(state) {
+  if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) {
+    state.lastIntValue = 0;
+    state.advance();
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape
+pp$8.regexp_eatControlEscape = function(state) {
+  var ch = state.current();
+  if (ch === 0x74 /* t */) {
+    state.lastIntValue = 0x09; /* \t */
+    state.advance();
+    return true
+  }
+  if (ch === 0x6E /* n */) {
+    state.lastIntValue = 0x0A; /* \n */
+    state.advance();
+    return true
+  }
+  if (ch === 0x76 /* v */) {
+    state.lastIntValue = 0x0B; /* \v */
+    state.advance();
+    return true
+  }
+  if (ch === 0x66 /* f */) {
+    state.lastIntValue = 0x0C; /* \f */
+    state.advance();
+    return true
+  }
+  if (ch === 0x72 /* r */) {
+    state.lastIntValue = 0x0D; /* \r */
+    state.advance();
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter
+pp$8.regexp_eatControlLetter = function(state) {
+  var ch = state.current();
+  if (isControlLetter(ch)) {
+    state.lastIntValue = ch % 0x20;
+    state.advance();
+    return true
+  }
+  return false
+};
+function isControlLetter(ch) {
+  return (
+    (ch >= 0x41 /* A */ && ch <= 0x5A /* Z */) ||
+    (ch >= 0x61 /* a */ && ch <= 0x7A /* z */)
+  )
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence
+pp$8.regexp_eatRegExpUnicodeEscapeSequence = function(state, forceU) {
+  if ( forceU === void 0 ) forceU = false;
+
+  var start = state.pos;
+  var switchU = forceU || state.switchU;
+
+  if (state.eat(0x75 /* u */)) {
+    if (this.regexp_eatFixedHexDigits(state, 4)) {
+      var lead = state.lastIntValue;
+      if (switchU && lead >= 0xD800 && lead <= 0xDBFF) {
+        var leadSurrogateEnd = state.pos;
+        if (state.eat(0x5C /* \ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) {
+          var trail = state.lastIntValue;
+          if (trail >= 0xDC00 && trail <= 0xDFFF) {
+            state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+            return true
+          }
+        }
+        state.pos = leadSurrogateEnd;
+        state.lastIntValue = lead;
+      }
+      return true
+    }
+    if (
+      switchU &&
+      state.eat(0x7B /* { */) &&
+      this.regexp_eatHexDigits(state) &&
+      state.eat(0x7D /* } */) &&
+      isValidUnicode(state.lastIntValue)
+    ) {
+      return true
+    }
+    if (switchU) {
+      state.raise("Invalid unicode escape");
+    }
+    state.pos = start;
+  }
+
+  return false
+};
+function isValidUnicode(ch) {
+  return ch >= 0 && ch <= 0x10FFFF
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape
+pp$8.regexp_eatIdentityEscape = function(state) {
+  if (state.switchU) {
+    if (this.regexp_eatSyntaxCharacter(state)) {
+      return true
+    }
+    if (state.eat(0x2F /* / */)) {
+      state.lastIntValue = 0x2F; /* / */
+      return true
+    }
+    return false
+  }
+
+  var ch = state.current();
+  if (ch !== 0x63 /* c */ && (!state.switchN || ch !== 0x6B /* k */)) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape
+pp$8.regexp_eatDecimalEscape = function(state) {
+  state.lastIntValue = 0;
+  var ch = state.current();
+  if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) {
+    do {
+      state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);
+      state.advance();
+    } while ((ch = state.current()) >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */)
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape
+pp$8.regexp_eatCharacterClassEscape = function(state) {
+  var ch = state.current();
+
+  if (isCharacterClassEscape(ch)) {
+    state.lastIntValue = -1;
+    state.advance();
+    return true
+  }
+
+  if (
+    state.switchU &&
+    this.options.ecmaVersion >= 9 &&
+    (ch === 0x50 /* P */ || ch === 0x70 /* p */)
+  ) {
+    state.lastIntValue = -1;
+    state.advance();
+    if (
+      state.eat(0x7B /* { */) &&
+      this.regexp_eatUnicodePropertyValueExpression(state) &&
+      state.eat(0x7D /* } */)
+    ) {
+      return true
+    }
+    state.raise("Invalid property name");
+  }
+
+  return false
+};
+function isCharacterClassEscape(ch) {
+  return (
+    ch === 0x64 /* d */ ||
+    ch === 0x44 /* D */ ||
+    ch === 0x73 /* s */ ||
+    ch === 0x53 /* S */ ||
+    ch === 0x77 /* w */ ||
+    ch === 0x57 /* W */
+  )
+}
+
+// UnicodePropertyValueExpression ::
+//   UnicodePropertyName `=` UnicodePropertyValue
+//   LoneUnicodePropertyNameOrValue
+pp$8.regexp_eatUnicodePropertyValueExpression = function(state) {
+  var start = state.pos;
+
+  // UnicodePropertyName `=` UnicodePropertyValue
+  if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D /* = */)) {
+    var name = state.lastStringValue;
+    if (this.regexp_eatUnicodePropertyValue(state)) {
+      var value = state.lastStringValue;
+      this.regexp_validateUnicodePropertyNameAndValue(state, name, value);
+      return true
+    }
+  }
+  state.pos = start;
+
+  // LoneUnicodePropertyNameOrValue
+  if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {
+    var nameOrValue = state.lastStringValue;
+    this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);
+    return true
+  }
+  return false
+};
+pp$8.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
+  if (!has(state.unicodeProperties.nonBinary, name))
+    { state.raise("Invalid property name"); }
+  if (!state.unicodeProperties.nonBinary[name].test(value))
+    { state.raise("Invalid property value"); }
+};
+pp$8.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
+  if (!state.unicodeProperties.binary.test(nameOrValue))
+    { state.raise("Invalid property name"); }
+};
+
+// UnicodePropertyName ::
+//   UnicodePropertyNameCharacters
+pp$8.regexp_eatUnicodePropertyName = function(state) {
+  var ch = 0;
+  state.lastStringValue = "";
+  while (isUnicodePropertyNameCharacter(ch = state.current())) {
+    state.lastStringValue += codePointToString(ch);
+    state.advance();
+  }
+  return state.lastStringValue !== ""
+};
+function isUnicodePropertyNameCharacter(ch) {
+  return isControlLetter(ch) || ch === 0x5F /* _ */
+}
+
+// UnicodePropertyValue ::
+//   UnicodePropertyValueCharacters
+pp$8.regexp_eatUnicodePropertyValue = function(state) {
+  var ch = 0;
+  state.lastStringValue = "";
+  while (isUnicodePropertyValueCharacter(ch = state.current())) {
+    state.lastStringValue += codePointToString(ch);
+    state.advance();
+  }
+  return state.lastStringValue !== ""
+};
+function isUnicodePropertyValueCharacter(ch) {
+  return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)
+}
+
+// LoneUnicodePropertyNameOrValue ::
+//   UnicodePropertyValueCharacters
+pp$8.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
+  return this.regexp_eatUnicodePropertyValue(state)
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass
+pp$8.regexp_eatCharacterClass = function(state) {
+  if (state.eat(0x5B /* [ */)) {
+    state.eat(0x5E /* ^ */);
+    this.regexp_classRanges(state);
+    if (state.eat(0x5D /* ] */)) {
+      return true
+    }
+    // Unreachable since it threw "unterminated regular expression" error before.
+    state.raise("Unterminated character class");
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges
+// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges
+// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash
+pp$8.regexp_classRanges = function(state) {
+  while (this.regexp_eatClassAtom(state)) {
+    var left = state.lastIntValue;
+    if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) {
+      var right = state.lastIntValue;
+      if (state.switchU && (left === -1 || right === -1)) {
+        state.raise("Invalid character class");
+      }
+      if (left !== -1 && right !== -1 && left > right) {
+        state.raise("Range out of order in character class");
+      }
+    }
+  }
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom
+// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash
+pp$8.regexp_eatClassAtom = function(state) {
+  var start = state.pos;
+
+  if (state.eat(0x5C /* \ */)) {
+    if (this.regexp_eatClassEscape(state)) {
+      return true
+    }
+    if (state.switchU) {
+      // Make the same message as V8.
+      var ch$1 = state.current();
+      if (ch$1 === 0x63 /* c */ || isOctalDigit(ch$1)) {
+        state.raise("Invalid class escape");
+      }
+      state.raise("Invalid escape");
+    }
+    state.pos = start;
+  }
+
+  var ch = state.current();
+  if (ch !== 0x5D /* ] */) {
+    state.lastIntValue = ch;
+    state.advance();
+    return true
+  }
+
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape
+pp$8.regexp_eatClassEscape = function(state) {
+  var start = state.pos;
+
+  if (state.eat(0x62 /* b */)) {
+    state.lastIntValue = 0x08; /* <BS> */
+    return true
+  }
+
+  if (state.switchU && state.eat(0x2D /* - */)) {
+    state.lastIntValue = 0x2D; /* - */
+    return true
+  }
+
+  if (!state.switchU && state.eat(0x63 /* c */)) {
+    if (this.regexp_eatClassControlLetter(state)) {
+      return true
+    }
+    state.pos = start;
+  }
+
+  return (
+    this.regexp_eatCharacterClassEscape(state) ||
+    this.regexp_eatCharacterEscape(state)
+  )
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter
+pp$8.regexp_eatClassControlLetter = function(state) {
+  var ch = state.current();
+  if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {
+    state.lastIntValue = ch % 0x20;
+    state.advance();
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
+pp$8.regexp_eatHexEscapeSequence = function(state) {
+  var start = state.pos;
+  if (state.eat(0x78 /* x */)) {
+    if (this.regexp_eatFixedHexDigits(state, 2)) {
+      return true
+    }
+    if (state.switchU) {
+      state.raise("Invalid escape");
+    }
+    state.pos = start;
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits
+pp$8.regexp_eatDecimalDigits = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  state.lastIntValue = 0;
+  while (isDecimalDigit(ch = state.current())) {
+    state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);
+    state.advance();
+  }
+  return state.pos !== start
+};
+function isDecimalDigit(ch) {
+  return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits
+pp$8.regexp_eatHexDigits = function(state) {
+  var start = state.pos;
+  var ch = 0;
+  state.lastIntValue = 0;
+  while (isHexDigit(ch = state.current())) {
+    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+    state.advance();
+  }
+  return state.pos !== start
+};
+function isHexDigit(ch) {
+  return (
+    (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) ||
+    (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) ||
+    (ch >= 0x61 /* a */ && ch <= 0x66 /* f */)
+  )
+}
+function hexToInt(ch) {
+  if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) {
+    return 10 + (ch - 0x41 /* A */)
+  }
+  if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) {
+    return 10 + (ch - 0x61 /* a */)
+  }
+  return ch - 0x30 /* 0 */
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence
+// Allows only 0-377(octal) i.e. 0-255(decimal).
+pp$8.regexp_eatLegacyOctalEscapeSequence = function(state) {
+  if (this.regexp_eatOctalDigit(state)) {
+    var n1 = state.lastIntValue;
+    if (this.regexp_eatOctalDigit(state)) {
+      var n2 = state.lastIntValue;
+      if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
+        state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;
+      } else {
+        state.lastIntValue = n1 * 8 + n2;
+      }
+    } else {
+      state.lastIntValue = n1;
+    }
+    return true
+  }
+  return false
+};
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit
+pp$8.regexp_eatOctalDigit = function(state) {
+  var ch = state.current();
+  if (isOctalDigit(ch)) {
+    state.lastIntValue = ch - 0x30; /* 0 */
+    state.advance();
+    return true
+  }
+  state.lastIntValue = 0;
+  return false
+};
+function isOctalDigit(ch) {
+  return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */
+}
+
+// https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits
+// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit
+// And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
+pp$8.regexp_eatFixedHexDigits = function(state, length) {
+  var start = state.pos;
+  state.lastIntValue = 0;
+  for (var i = 0; i < length; ++i) {
+    var ch = state.current();
+    if (!isHexDigit(ch)) {
+      state.pos = start;
+      return false
+    }
+    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+    state.advance();
+  }
+  return true
+};
+
+// Object type used to represent tokens. Note that normally, tokens
+// simply exist as properties on the parser object. This is only
+// used for the onToken callback and the external tokenizer.
+
+var Token = function Token(p) {
+  this.type = p.type;
+  this.value = p.value;
+  this.start = p.start;
+  this.end = p.end;
+  if (p.options.locations)
+    { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }
+  if (p.options.ranges)
+    { this.range = [p.start, p.end]; }
+};
+
+// ## Tokenizer
+
+var pp$9 = Parser.prototype;
+
+// Move to the next token
+
+pp$9.next = function(ignoreEscapeSequenceInKeyword) {
+  if (!ignoreEscapeSequenceInKeyword && this.type.keyword && this.containsEsc)
+    { this.raiseRecoverable(this.start, "Escape sequence in keyword " + this.type.keyword); }
+  if (this.options.onToken)
+    { this.options.onToken(new Token(this)); }
+
+  this.lastTokEnd = this.end;
+  this.lastTokStart = this.start;
+  this.lastTokEndLoc = this.endLoc;
+  this.lastTokStartLoc = this.startLoc;
+  this.nextToken();
+};
+
+pp$9.getToken = function() {
+  this.next();
+  return new Token(this)
+};
+
+// If we're in an ES6 environment, make parsers iterable
+if (typeof Symbol !== "undefined")
+  { pp$9[Symbol.iterator] = function() {
+    var this$1 = this;
+
+    return {
+      next: function () {
+        var token = this$1.getToken();
+        return {
+          done: token.type === types.eof,
+          value: token
+        }
+      }
+    }
+  }; }
+
+// Toggle strict mode. Re-reads the next number or string to please
+// pedantic tests (`"use strict"; 010;` should fail).
+
+pp$9.curContext = function() {
+  return this.context[this.context.length - 1]
+};
+
+// Read a single token, updating the parser object's token-related
+// properties.
+
+pp$9.nextToken = function() {
+  var curContext = this.curContext();
+  if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
+
+  this.start = this.pos;
+  if (this.options.locations) { this.startLoc = this.curPosition(); }
+  if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
+
+  if (curContext.override) { return curContext.override(this) }
+  else { this.readToken(this.fullCharCodeAtPos()); }
+};
+
+pp$9.readToken = function(code) {
+  // Identifier or keyword. '\uXXXX' sequences are allowed in
+  // identifiers, so '\' also dispatches to that.
+  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+    { return this.readWord() }
+
+  return this.getTokenFromCode(code)
+};
+
+pp$9.fullCharCodeAtPos = function() {
+  var code = this.input.charCodeAt(this.pos);
+  if (code <= 0xd7ff || code >= 0xdc00) { return code }
+  var next = this.input.charCodeAt(this.pos + 1);
+  return next <= 0xdbff || next >= 0xe000 ? code : (code << 10) + next - 0x35fdc00
+};
+
+pp$9.skipBlockComment = function() {
+  var startLoc = this.options.onComment && this.curPosition();
+  var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
+  if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); }
+  this.pos = end + 2;
+  if (this.options.locations) {
+    lineBreakG.lastIndex = start;
+    var match;
+    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
+      ++this.curLine;
+      this.lineStart = match.index + match[0].length;
+    }
+  }
+  if (this.options.onComment)
+    { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+                           startLoc, this.curPosition()); }
+};
+
+pp$9.skipLineComment = function(startSkip) {
+  var start = this.pos;
+  var startLoc = this.options.onComment && this.curPosition();
+  var ch = this.input.charCodeAt(this.pos += startSkip);
+  while (this.pos < this.input.length && !isNewLine(ch)) {
+    ch = this.input.charCodeAt(++this.pos);
+  }
+  if (this.options.onComment)
+    { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+                           startLoc, this.curPosition()); }
+};
+
+// Called at the start of the parse and after every token. Skips
+// whitespace and comments, and.
+
+pp$9.skipSpace = function() {
+  loop: while (this.pos < this.input.length) {
+    var ch = this.input.charCodeAt(this.pos);
+    switch (ch) {
+    case 32: case 160: // ' '
+      ++this.pos;
+      break
+    case 13:
+      if (this.input.charCodeAt(this.pos + 1) === 10) {
+        ++this.pos;
+      }
+    case 10: case 8232: case 8233:
+      ++this.pos;
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+      break
+    case 47: // '/'
+      switch (this.input.charCodeAt(this.pos + 1)) {
+      case 42: // '*'
+        this.skipBlockComment();
+        break
+      case 47:
+        this.skipLineComment(2);
+        break
+      default:
+        break loop
+      }
+      break
+    default:
+      if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+        ++this.pos;
+      } else {
+        break loop
+      }
+    }
+  }
+};
+
+// Called at the end of every token. Sets `end`, `val`, and
+// maintains `context` and `exprAllowed`, and skips the space after
+// the token, so that the next one's `start` will point at the
+// right position.
+
+pp$9.finishToken = function(type, val) {
+  this.end = this.pos;
+  if (this.options.locations) { this.endLoc = this.curPosition(); }
+  var prevType = this.type;
+  this.type = type;
+  this.value = val;
+
+  this.updateContext(prevType);
+};
+
+// ### Token reading
+
+// This is the function that is called to fetch the next token. It
+// is somewhat obscure, because it works in character codes rather
+// than characters, and because operator parsing has been inlined
+// into it.
+//
+// All in the name of speed.
+//
+pp$9.readToken_dot = function() {
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next >= 48 && next <= 57) { return this.readNumber(true) }
+  var next2 = this.input.charCodeAt(this.pos + 2);
+  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+    this.pos += 3;
+    return this.finishToken(types.ellipsis)
+  } else {
+    ++this.pos;
+    return this.finishToken(types.dot)
+  }
+};
+
+pp$9.readToken_slash = function() { // '/'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.slash, 1)
+};
+
+pp$9.readToken_mult_modulo_exp = function(code) { // '%*'
+  var next = this.input.charCodeAt(this.pos + 1);
+  var size = 1;
+  var tokentype = code === 42 ? types.star : types.modulo;
+
+  // exponentiation operator ** and **=
+  if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {
+    ++size;
+    tokentype = types.starstar;
+    next = this.input.charCodeAt(this.pos + 2);
+  }
+
+  if (next === 61) { return this.finishOp(types.assign, size + 1) }
+  return this.finishOp(tokentype, size)
+};
+
+pp$9.readToken_pipe_amp = function(code) { // '|&'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) {
+    if (this.options.ecmaVersion >= 12) {
+      var next2 = this.input.charCodeAt(this.pos + 2);
+      if (next2 === 61) { return this.finishOp(types.assign, 3) }
+    }
+    return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2)
+  }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
+};
+
+pp$9.readToken_caret = function() { // '^'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.bitwiseXOR, 1)
+};
+
+pp$9.readToken_plus_min = function(code) { // '+-'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === code) {
+    if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&
+        (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
+      // A `-->` line comment
+      this.skipLineComment(3);
+      this.skipSpace();
+      return this.nextToken()
+    }
+    return this.finishOp(types.incDec, 2)
+  }
+  if (next === 61) { return this.finishOp(types.assign, 2) }
+  return this.finishOp(types.plusMin, 1)
+};
+
+pp$9.readToken_lt_gt = function(code) { // '<>'
+  var next = this.input.charCodeAt(this.pos + 1);
+  var size = 1;
+  if (next === code) {
+    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+    if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
+    return this.finishOp(types.bitShift, size)
+  }
+  if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&
+      this.input.charCodeAt(this.pos + 3) === 45) {
+    // `<!--`, an XML-style comment that should be interpreted as a line comment
+    this.skipLineComment(4);
+    this.skipSpace();
+    return this.nextToken()
+  }
+  if (next === 61) { size = 2; }
+  return this.finishOp(types.relational, size)
+};
+
+pp$9.readToken_eq_excl = function(code) { // '=!'
+  var next = this.input.charCodeAt(this.pos + 1);
+  if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
+  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
+    this.pos += 2;
+    return this.finishToken(types.arrow)
+  }
+  return this.finishOp(code === 61 ? types.eq : types.prefix, 1)
+};
+
+pp$9.readToken_question = function() { // '?'
+  var ecmaVersion = this.options.ecmaVersion;
+  if (ecmaVersion >= 11) {
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 46) {
+      var next2 = this.input.charCodeAt(this.pos + 2);
+      if (next2 < 48 || next2 > 57) { return this.finishOp(types.questionDot, 2) }
+    }
+    if (next === 63) {
+      if (ecmaVersion >= 12) {
+        var next2$1 = this.input.charCodeAt(this.pos + 2);
+        if (next2$1 === 61) { return this.finishOp(types.assign, 3) }
+      }
+      return this.finishOp(types.coalesce, 2)
+    }
+  }
+  return this.finishOp(types.question, 1)
+};
+
+pp$9.readToken_numberSign = function() { // '#'
+  var ecmaVersion = this.options.ecmaVersion;
+  var code = 35; // '#'
+  if (ecmaVersion >= 13) {
+    ++this.pos;
+    code = this.fullCharCodeAtPos();
+    if (isIdentifierStart(code, true) || code === 92 /* '\' */) {
+      return this.finishToken(types.privateId, this.readWord1())
+    }
+  }
+
+  this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+};
+
+pp$9.getTokenFromCode = function(code) {
+  switch (code) {
+  // The interpretation of a dot depends on whether it is followed
+  // by a digit or another two dots.
+  case 46: // '.'
+    return this.readToken_dot()
+
+  // Punctuation tokens.
+  case 40: ++this.pos; return this.finishToken(types.parenL)
+  case 41: ++this.pos; return this.finishToken(types.parenR)
+  case 59: ++this.pos; return this.finishToken(types.semi)
+  case 44: ++this.pos; return this.finishToken(types.comma)
+  case 91: ++this.pos; return this.finishToken(types.bracketL)
+  case 93: ++this.pos; return this.finishToken(types.bracketR)
+  case 123: ++this.pos; return this.finishToken(types.braceL)
+  case 125: ++this.pos; return this.finishToken(types.braceR)
+  case 58: ++this.pos; return this.finishToken(types.colon)
+
+  case 96: // '`'
+    if (this.options.ecmaVersion < 6) { break }
+    ++this.pos;
+    return this.finishToken(types.backQuote)
+
+  case 48: // '0'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 120 || next === 88) { return this.readRadixNumber(16) } // '0x', '0X' - hex number
+    if (this.options.ecmaVersion >= 6) {
+      if (next === 111 || next === 79) { return this.readRadixNumber(8) } // '0o', '0O' - octal number
+      if (next === 98 || next === 66) { return this.readRadixNumber(2) } // '0b', '0B' - binary number
+    }
+
+  // Anything else beginning with a digit is an integer, octal
+  // number, or float.
+  case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
+    return this.readNumber(false)
+
+  // Quotes produce strings.
+  case 34: case 39: // '"', "'"
+    return this.readString(code)
+
+  // Operators are parsed inline in tiny state machines. '=' (61) is
+  // often referred to. `finishOp` simply skips the amount of
+  // characters it is given as second argument, and returns a token
+  // of the type given by its first argument.
+
+  case 47: // '/'
+    return this.readToken_slash()
+
+  case 37: case 42: // '%*'
+    return this.readToken_mult_modulo_exp(code)
+
+  case 124: case 38: // '|&'
+    return this.readToken_pipe_amp(code)
+
+  case 94: // '^'
+    return this.readToken_caret()
+
+  case 43: case 45: // '+-'
+    return this.readToken_plus_min(code)
+
+  case 60: case 62: // '<>'
+    return this.readToken_lt_gt(code)
+
+  case 61: case 33: // '=!'
+    return this.readToken_eq_excl(code)
+
+  case 63: // '?'
+    return this.readToken_question()
+
+  case 126: // '~'
+    return this.finishOp(types.prefix, 1)
+
+  case 35: // '#'
+    return this.readToken_numberSign()
+  }
+
+  this.raise(this.pos, "Unexpected character '" + codePointToString$1(code) + "'");
+};
+
+pp$9.finishOp = function(type, size) {
+  var str = this.input.slice(this.pos, this.pos + size);
+  this.pos += size;
+  return this.finishToken(type, str)
+};
+
+pp$9.readRegexp = function() {
+  var escaped, inClass, start = this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) { this.raise(start, "Unterminated regular expression"); }
+    var ch = this.input.charAt(this.pos);
+    if (lineBreak.test(ch)) { this.raise(start, "Unterminated regular expression"); }
+    if (!escaped) {
+      if (ch === "[") { inClass = true; }
+      else if (ch === "]" && inClass) { inClass = false; }
+      else if (ch === "/" && !inClass) { break }
+      escaped = ch === "\\";
+    } else { escaped = false; }
+    ++this.pos;
+  }
+  var pattern = this.input.slice(start, this.pos);
+  ++this.pos;
+  var flagsStart = this.pos;
+  var flags = this.readWord1();
+  if (this.containsEsc) { this.unexpected(flagsStart); }
+
+  // Validate pattern
+  var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));
+  state.reset(start, pattern, flags);
+  this.validateRegExpFlags(state);
+  this.validateRegExpPattern(state);
+
+  // Create Literal#value property value.
+  var value = null;
+  try {
+    value = new RegExp(pattern, flags);
+  } catch (e) {
+    // ESTree requires null if it failed to instantiate RegExp object.
+    // https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral
+  }
+
+  return this.finishToken(types.regexp, {pattern: pattern, flags: flags, value: value})
+};
+
+// Read an integer in the given radix. Return null if zero digits
+// were read, the integer value otherwise. When `len` is given, this
+// will return `null` unless the integer has exactly `len` digits.
+
+pp$9.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
+  // `len` is used for character escape sequences. In that case, disallow separators.
+  var allowSeparators = this.options.ecmaVersion >= 12 && len === undefined;
+
+  // `maybeLegacyOctalNumericLiteral` is true if it doesn't have prefix (0x,0o,0b)
+  // and isn't fraction part nor exponent part. In that case, if the first digit
+  // is zero then disallow separators.
+  var isLegacyOctalNumericLiteral = maybeLegacyOctalNumericLiteral && this.input.charCodeAt(this.pos) === 48;
+
+  var start = this.pos, total = 0, lastCode = 0;
+  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i, ++this.pos) {
+    var code = this.input.charCodeAt(this.pos), val = (void 0);
+
+    if (allowSeparators && code === 95) {
+      if (isLegacyOctalNumericLiteral) { this.raiseRecoverable(this.pos, "Numeric separator is not allowed in legacy octal numeric literals"); }
+      if (lastCode === 95) { this.raiseRecoverable(this.pos, "Numeric separator must be exactly one underscore"); }
+      if (i === 0) { this.raiseRecoverable(this.pos, "Numeric separator is not allowed at the first of digits"); }
+      lastCode = code;
+      continue
+    }
+
+    if (code >= 97) { val = code - 97 + 10; } // a
+    else if (code >= 65) { val = code - 65 + 10; } // A
+    else if (code >= 48 && code <= 57) { val = code - 48; } // 0-9
+    else { val = Infinity; }
+    if (val >= radix) { break }
+    lastCode = code;
+    total = total * radix + val;
+  }
+
+  if (allowSeparators && lastCode === 95) { this.raiseRecoverable(this.pos - 1, "Numeric separator is not allowed at the last of digits"); }
+  if (this.pos === start || len != null && this.pos - start !== len) { return null }
+
+  return total
+};
+
+function stringToNumber(str, isLegacyOctalNumericLiteral) {
+  if (isLegacyOctalNumericLiteral) {
+    return parseInt(str, 8)
+  }
+
+  // `parseFloat(value)` stops parsing at the first numeric separator then returns a wrong value.
+  return parseFloat(str.replace(/_/g, ""))
+}
+
+function stringToBigInt(str) {
+  if (typeof BigInt !== "function") {
+    return null
+  }
+
+  // `BigInt(value)` throws syntax error if the string contains numeric separators.
+  return BigInt(str.replace(/_/g, ""))
+}
+
+pp$9.readRadixNumber = function(radix) {
+  var start = this.pos;
+  this.pos += 2; // 0x
+  var val = this.readInt(radix);
+  if (val == null) { this.raise(this.start + 2, "Expected number in radix " + radix); }
+  if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {
+    val = stringToBigInt(this.input.slice(start, this.pos));
+    ++this.pos;
+  } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+  return this.finishToken(types.num, val)
+};
+
+// Read an integer, octal integer, or floating-point number.
+
+pp$9.readNumber = function(startsWithDot) {
+  var start = this.pos;
+  if (!startsWithDot && this.readInt(10, undefined, true) === null) { this.raise(start, "Invalid number"); }
+  var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
+  if (octal && this.strict) { this.raise(start, "Invalid number"); }
+  var next = this.input.charCodeAt(this.pos);
+  if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {
+    var val$1 = stringToBigInt(this.input.slice(start, this.pos));
+    ++this.pos;
+    if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+    return this.finishToken(types.num, val$1)
+  }
+  if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }
+  if (next === 46 && !octal) { // '.'
+    ++this.pos;
+    this.readInt(10);
+    next = this.input.charCodeAt(this.pos);
+  }
+  if ((next === 69 || next === 101) && !octal) { // 'eE'
+    next = this.input.charCodeAt(++this.pos);
+    if (next === 43 || next === 45) { ++this.pos; } // '+-'
+    if (this.readInt(10) === null) { this.raise(start, "Invalid number"); }
+  }
+  if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
+
+  var val = stringToNumber(this.input.slice(start, this.pos), octal);
+  return this.finishToken(types.num, val)
+};
+
+// Read a string value, interpreting backslash-escapes.
+
+pp$9.readCodePoint = function() {
+  var ch = this.input.charCodeAt(this.pos), code;
+
+  if (ch === 123) { // '{'
+    if (this.options.ecmaVersion < 6) { this.unexpected(); }
+    var codePos = ++this.pos;
+    code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
+    ++this.pos;
+    if (code > 0x10FFFF) { this.invalidStringToken(codePos, "Code point out of bounds"); }
+  } else {
+    code = this.readHexChar(4);
+  }
+  return code
+};
+
+function codePointToString$1(code) {
+  // UTF-16 Decoding
+  if (code <= 0xFFFF) { return String.fromCharCode(code) }
+  code -= 0x10000;
+  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)
+}
+
+pp$9.readString = function(quote) {
+  var out = "", chunkStart = ++this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) { this.raise(this.start, "Unterminated string constant"); }
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === quote) { break }
+    if (ch === 92) { // '\'
+      out += this.input.slice(chunkStart, this.pos);
+      out += this.readEscapedChar(false);
+      chunkStart = this.pos;
+    } else {
+      if (isNewLine(ch, this.options.ecmaVersion >= 10)) { this.raise(this.start, "Unterminated string constant"); }
+      ++this.pos;
+    }
+  }
+  out += this.input.slice(chunkStart, this.pos++);
+  return this.finishToken(types.string, out)
+};
+
+// Reads template string tokens.
+
+var INVALID_TEMPLATE_ESCAPE_ERROR = {};
+
+pp$9.tryReadTemplateToken = function() {
+  this.inTemplateElement = true;
+  try {
+    this.readTmplToken();
+  } catch (err) {
+    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
+      this.readInvalidTemplateToken();
+    } else {
+      throw err
+    }
+  }
+
+  this.inTemplateElement = false;
+};
+
+pp$9.invalidStringToken = function(position, message) {
+  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
+    throw INVALID_TEMPLATE_ESCAPE_ERROR
+  } else {
+    this.raise(position, message);
+  }
+};
+
+pp$9.readTmplToken = function() {
+  var out = "", chunkStart = this.pos;
+  for (;;) {
+    if (this.pos >= this.input.length) { this.raise(this.start, "Unterminated template"); }
+    var ch = this.input.charCodeAt(this.pos);
+    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
+      if (this.pos === this.start && (this.type === types.template || this.type === types.invalidTemplate)) {
+        if (ch === 36) {
+          this.pos += 2;
+          return this.finishToken(types.dollarBraceL)
+        } else {
+          ++this.pos;
+          return this.finishToken(types.backQuote)
+        }
+      }
+      out += this.input.slice(chunkStart, this.pos);
+      return this.finishToken(types.template, out)
+    }
+    if (ch === 92) { // '\'
+      out += this.input.slice(chunkStart, this.pos);
+      out += this.readEscapedChar(true);
+      chunkStart = this.pos;
+    } else if (isNewLine(ch)) {
+      out += this.input.slice(chunkStart, this.pos);
+      ++this.pos;
+      switch (ch) {
+      case 13:
+        if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; }
+      case 10:
+        out += "\n";
+        break
+      default:
+        out += String.fromCharCode(ch);
+        break
+      }
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+      chunkStart = this.pos;
+    } else {
+      ++this.pos;
+    }
+  }
+};
+
+// Reads a template token to search for the end, without validating any escape sequences
+pp$9.readInvalidTemplateToken = function() {
+  for (; this.pos < this.input.length; this.pos++) {
+    switch (this.input[this.pos]) {
+    case "\\":
+      ++this.pos;
+      break
+
+    case "$":
+      if (this.input[this.pos + 1] !== "{") {
+        break
+      }
+    // falls through
+
+    case "`":
+      return this.finishToken(types.invalidTemplate, this.input.slice(this.start, this.pos))
+
+    // no default
+    }
+  }
+  this.raise(this.start, "Unterminated template");
+};
+
+// Used to read escaped characters
+
+pp$9.readEscapedChar = function(inTemplate) {
+  var ch = this.input.charCodeAt(++this.pos);
+  ++this.pos;
+  switch (ch) {
+  case 110: return "\n" // 'n' -> '\n'
+  case 114: return "\r" // 'r' -> '\r'
+  case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'
+  case 117: return codePointToString$1(this.readCodePoint()) // 'u'
+  case 116: return "\t" // 't' -> '\t'
+  case 98: return "\b" // 'b' -> '\b'
+  case 118: return "\u000b" // 'v' -> '\u000b'
+  case 102: return "\f" // 'f' -> '\f'
+  case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; } // '\r\n'
+  case 10: // ' \n'
+    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
+    return ""
+  case 56:
+  case 57:
+    if (this.strict) {
+      this.invalidStringToken(
+        this.pos - 1,
+        "Invalid escape sequence"
+      );
+    }
+    if (inTemplate) {
+      var codePos = this.pos - 1;
+
+      this.invalidStringToken(
+        codePos,
+        "Invalid escape sequence in template string"
+      );
+
+      return null
+    }
+  default:
+    if (ch >= 48 && ch <= 55) {
+      var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];
+      var octal = parseInt(octalStr, 8);
+      if (octal > 255) {
+        octalStr = octalStr.slice(0, -1);
+        octal = parseInt(octalStr, 8);
+      }
+      this.pos += octalStr.length - 1;
+      ch = this.input.charCodeAt(this.pos);
+      if ((octalStr !== "0" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {
+        this.invalidStringToken(
+          this.pos - 1 - octalStr.length,
+          inTemplate
+            ? "Octal literal in template string"
+            : "Octal literal in strict mode"
+        );
+      }
+      return String.fromCharCode(octal)
+    }
+    if (isNewLine(ch)) {
+      // Unicode new line characters after \ get removed from output in both
+      // template literals and strings
+      return ""
+    }
+    return String.fromCharCode(ch)
+  }
+};
+
+// Used to read character escape sequences ('\x', '\u', '\U').
+
+pp$9.readHexChar = function(len) {
+  var codePos = this.pos;
+  var n = this.readInt(16, len);
+  if (n === null) { this.invalidStringToken(codePos, "Bad character escape sequence"); }
+  return n
+};
+
+// Read an identifier, and return it as a string. Sets `this.containsEsc`
+// to whether the word contained a '\u' escape.
+//
+// Incrementally adds only escaped chars, adding other chunks as-is
+// as a micro-optimization.
+
+pp$9.readWord1 = function() {
+  this.containsEsc = false;
+  var word = "", first = true, chunkStart = this.pos;
+  var astral = this.options.ecmaVersion >= 6;
+  while (this.pos < this.input.length) {
+    var ch = this.fullCharCodeAtPos();
+    if (isIdentifierChar(ch, astral)) {
+      this.pos += ch <= 0xffff ? 1 : 2;
+    } else if (ch === 92) { // "\"
+      this.containsEsc = true;
+      word += this.input.slice(chunkStart, this.pos);
+      var escStart = this.pos;
+      if (this.input.charCodeAt(++this.pos) !== 117) // "u"
+        { this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX"); }
+      ++this.pos;
+      var esc = this.readCodePoint();
+      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
+        { this.invalidStringToken(escStart, "Invalid Unicode escape"); }
+      word += codePointToString$1(esc);
+      chunkStart = this.pos;
+    } else {
+      break
+    }
+    first = false;
+  }
+  return word + this.input.slice(chunkStart, this.pos)
+};
+
+// Read an identifier or keyword token. Will check for reserved
+// words when necessary.
+
+pp$9.readWord = function() {
+  var word = this.readWord1();
+  var type = types.name;
+  if (this.keywords.test(word)) {
+    type = keywords$1[word];
+  }
+  return this.finishToken(type, word)
+};
+
+// Acorn is a tiny, fast JavaScript parser written in JavaScript.
+
+var version = "8.4.1";
+
+Parser.acorn = {
+  Parser: Parser,
+  version: version,
+  defaultOptions: defaultOptions,
+  Position: Position,
+  SourceLocation: SourceLocation,
+  getLineInfo: getLineInfo,
+  Node: Node,
+  TokenType: TokenType,
+  tokTypes: types,
+  keywordTypes: keywords$1,
+  TokContext: TokContext,
+  tokContexts: types$1,
+  isIdentifierChar: isIdentifierChar,
+  isIdentifierStart: isIdentifierStart,
+  Token: Token,
+  isNewLine: isNewLine,
+  lineBreak: lineBreak,
+  lineBreakG: lineBreakG,
+  nonASCIIwhitespace: nonASCIIwhitespace
+};
+
+// The main exported interface (under `self.acorn` when in the
+// browser) is a `parse` function that takes a code string and
+// returns an abstract syntax tree as specified by [Mozilla parser
+// API][api].
+//
+// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+
+function parse(input, options) {
+  return Parser.parse(input, options)
+}
+
+// This function tries to parse a single expression at a given
+// offset in a string. Useful for parsing mixed-language formats
+// that embed JavaScript expressions.
+
+function parseExpressionAt(input, pos, options) {
+  return Parser.parseExpressionAt(input, pos, options)
+}
+
+// Acorn is organized as a tokenizer and a recursive-descent parser.
+// The `tokenizer` export provides an interface to the tokenizer.
+
+function tokenizer(input, options) {
+  return Parser.tokenizer(input, options)
+}
+
+export { Node, Parser, Position, SourceLocation, TokContext, Token, TokenType, defaultOptions, getLineInfo, isIdentifierChar, isIdentifierStart, isNewLine, keywords$1 as keywordTypes, lineBreak, lineBreakG, nonASCIIwhitespace, parse, parseExpressionAt, types$1 as tokContexts, types as tokTypes, tokenizer, version };
diff --git a/deps/acorn/acorn/dist/acorn.mjs.d.ts b/deps/acorn/acorn/dist/acorn.mjs.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5f633595e5f9a44c72558d763895d3770d0f9e6d
--- /dev/null
+++ b/deps/acorn/acorn/dist/acorn.mjs.d.ts
@@ -0,0 +1,2 @@
+import * as acorn from "./acorn";
+export = acorn;
\ No newline at end of file
diff --git a/deps/acorn/acorn/dist/bin.js b/deps/acorn/acorn/dist/bin.js
new file mode 100644
index 0000000000000000000000000000000000000000..3c3ce22e520edc2d62cef92caf4a22e7f674b5f7
--- /dev/null
+++ b/deps/acorn/acorn/dist/bin.js
@@ -0,0 +1,65 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var acorn = require('./acorn.js');
+
+var infile, forceFile, silent = false, compact = false, tokenize = false;
+var options = {};
+
+function help(status) {
+  var print = (status === 0) ? console.log : console.error;
+  print("usage: " + path.basename(process.argv[1]) + " [--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|...|--ecma2015|--ecma2016|--ecma2017|--ecma2018|...]");
+  print("        [--tokenize] [--locations] [---allow-hash-bang] [--allow-await-outside-function] [--compact] [--silent] [--module] [--help] [--] [infile]");
+  process.exit(status);
+}
+
+for (var i = 2; i < process.argv.length; ++i) {
+  var arg = process.argv[i];
+  if ((arg === "-" || arg[0] !== "-") && !infile) { infile = arg; }
+  else if (arg === "--" && !infile && i + 2 === process.argv.length) { forceFile = infile = process.argv[++i]; }
+  else if (arg === "--locations") { options.locations = true; }
+  else if (arg === "--allow-hash-bang") { options.allowHashBang = true; }
+  else if (arg === "--allow-await-outside-function") { options.allowAwaitOutsideFunction = true; }
+  else if (arg === "--silent") { silent = true; }
+  else if (arg === "--compact") { compact = true; }
+  else if (arg === "--help") { help(0); }
+  else if (arg === "--tokenize") { tokenize = true; }
+  else if (arg === "--module") { options.sourceType = "module"; }
+  else {
+    var match = arg.match(/^--ecma(\d+)$/);
+    if (match)
+      { options.ecmaVersion = +match[1]; }
+    else
+      { help(1); }
+  }
+}
+
+function run(code) {
+  var result;
+  try {
+    if (!tokenize) {
+      result = acorn.parse(code, options);
+    } else {
+      result = [];
+      var tokenizer = acorn.tokenizer(code, options), token;
+      do {
+        token = tokenizer.getToken();
+        result.push(token);
+      } while (token.type !== acorn.tokTypes.eof)
+    }
+  } catch (e) {
+    console.error(infile && infile !== "-" ? e.message.replace(/\(\d+:\d+\)$/, function (m) { return m.slice(0, 1) + infile + " " + m.slice(1); }) : e.message);
+    process.exit(1);
+  }
+  if (!silent) { console.log(JSON.stringify(result, null, compact ? null : 2)); }
+}
+
+if (forceFile || infile && infile !== "-") {
+  run(fs.readFileSync(infile, "utf8"));
+} else {
+  var code = "";
+  process.stdin.resume();
+  process.stdin.on("data", function (chunk) { return code += chunk; });
+  process.stdin.on("end", function () { return run(code); });
+}
diff --git a/deps/acorn/acorn/package.json b/deps/acorn/acorn/package.json
index 6a8f036073a2abfa5f7fa7db6068fb66a04b81a8..c691734ec30e5c542f934dfbf1a86ac487f62110 100644
--- a/deps/acorn/acorn/package.json
+++ b/deps/acorn/acorn/package.json
@@ -5,7 +5,18 @@
   "main": "dist/acorn.js",
   "types": "dist/acorn.d.ts",
   "module": "dist/acorn.mjs",
-  "version": "7.1.1",
+  "exports": {
+    ".": [
+      {
+        "import": "./dist/acorn.mjs",
+        "require": "./dist/acorn.js",
+        "default": "./dist/acorn.js"
+      },
+      "./dist/acorn.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "version": "8.4.1",
   "engines": {"node": ">=0.4.0"},
   "maintainers": [
     {
diff --git a/deps/brotli/c/common/dictionary.bin.br b/deps/brotli/c/common/dictionary.bin.br
deleted file mode 100644
index 6a55d420a8186fd40b050a2226ef870a73783a55..0000000000000000000000000000000000000000
Binary files a/deps/brotli/c/common/dictionary.bin.br and /dev/null differ
diff --git a/deps/cares/CHANGES b/deps/cares/CHANGES
new file mode 100644
index 0000000000000000000000000000000000000000..fcdc0437ae46001e48d6a8619f202e15965ae015
--- /dev/null
+++ b/deps/cares/CHANGES
@@ -0,0 +1,5121 @@
+   Changelog for the c-ares project. Generated with git2changes.pl
+
+Version 1.18.1 (26 Oct 2021)
+
+bradh352 (26 Oct 2021)
+- missed version
+
+- 1.18.1 release prep
+
+- ares_getaddrinfo() was returning the wrong size for ai_addrlen
+  
+  ai_addrlen was erroneously returning 16 bytes instead of the
+  sizeof(struct sockaddr_in6).  This is a regression introduced
+  in 1.18.0.
+  
+  Reported by: James Brown <jbrown@easypost.com>
+  Fix By: Brad House (@bradh352)
+
+- Windows: autotools force linking to iphlpapi
+
+GitHub (26 Oct 2021)
+- [Gregor Jasny brought this change]
+
+  Fix typo detected by lintian (#434)
+  
+  typo in docs for ares_parse_uri_reply
+  
+  Fix By: Gregor Jasny (@gjasny)
+
+Version 1.18.0 (25 Oct 2021)
+
+bradh352 (25 Oct 2021)
+- replace Travis badge with Cirrus-CI badge
+
+- c-ares 1.18.0 release prep
+
+GitHub (21 Oct 2021)
+- [Jérôme Duval brought this change]
+
+  Haiku: port (#431)
+  
+  Port for Haiku.  Slight CMake changes, header changes, and resolv.conf/hosts paths specific to Haiku.
+  
+  Port By: Jérôme Duval (@korli)
+
+bradh352 (19 Oct 2021)
+- valgrind: fix reported invalid read
+
+- make sure distcheck runs
+
+- detect oddities and skip test if necessary
+
+- fix null ptr deref in strlen
+
+- bend over backwards for testing file access, something is weird on debian
+
+- chmod(fn, 0) is failing on debian
+
+- maybe process needs to be called
+
+- split test output
+
+- clean up a couple of compiler warnings
+
+- use helper function for addrinfo to simplify code
+
+- INSTANTIATE_TEST_CASE_P -> INSTANTIATE_TEST_SUITE_P as new convention in googletest
+
+- gmock: update from 1.8.0 to 1.11.0
+
+- Cirrus-CI: fix debian arm build
+
+- Cirrus-CI: more updates for proper testing
+
+- install proper packages for asan and analyze
+
+- fix  crash in tests
+
+- try to disable container tests
+
+- need g++ for tests on debian
+
+- try cirrus-ci again
+
+- whitespace
+
+- start bringing up cirrus-ci
+
+- prep for adding new ci
+
+- fix cut and paste error
+
+GitHub (18 Oct 2021)
+- [Brad House brought this change]
+
+  RFC6761: special case "localhost" (#430)
+  
+  As per RFC6761 Section 6.3, "localhost" lookups need to be special cased to return loopback addresses, and not forward queries to recursive dns servers.
+  
+  We first look up via files (/etc/hosts or equivalent), and if that fails, we then attempt a system-specific address enumeration for loopback addresses (currently Windows-only), and finally fallback to ::1 and 127.0.0.1.
+  
+  Fix By: Brad House (@bradh352)
+  Fixes Bug: #399
+
+- [Brad House brought this change]
+
+  Reimplement ares_gethostbyname() by wrapping ares_getaddrinfo() (#428)
+  
+  ares_gethostbyname() and ares_getaddrinfo() do a lot of similar things, however ares_getaddrinfo() has some desirable behaviors that should be imported into ares_gethostbyname(). For one, it sorts the address lists for the most likely to succeed based on the current system routes. Next, when AF_UNSPEC is specified, it properly handles search lists instead of first searching all of AF_INET6 then AF_INET, since ares_gethostbyname() searches in parallel. Therefore, this PR should also resolve the issues attempted in #94.
+  
+  A few things this PR does:
+  
+  1. ares_parse_a_reply() and ares_parse_aaaa_reply() had very similar code to translate struct ares_addrinfo into a struct hostent as well as into struct ares_addrttl/ares_addr6ttl this has been split out into helper functions of ares__addrinfo2hostent() and ares__addrinfo2addrttl() to prevent this duplicative code.
+  
+  2. ares_getaddrinfo() was apparently never honoring HOSTALIASES, and this was discovered once ares_gethostbyname() was turned into a wrapper, the affected test cases started failing.
+  
+  3. A slight API modification to save the query hostname into struct ares_addrinfo as the last element of name. Since this is the last element, and all user-level instances of struct ares_addrinfo are allocated internally by c-ares, this is not an ABI-breaking change nor would it impact any API compatibility. This was needed since struct hostent has an h_name element.
+  
+  4. Test Framework: MockServer tests via TCP would fail if more than 1 request was received at a time which is common when ares_getaddrinfo() queries for both A and AAAA records simultaneously. Infact, this was a long standing issue in which the ares_getaddrinfo() test were bypassing TCP alltogether. This has been corrected, the message is now processed in a loop.
+  
+  5. Some tests had to be updated for overall correctness as they were invalid but somehow passing prior to this change.
+  
+  Change By: Brad House (@bradh352)
+
+bradh352 (9 Oct 2021)
+- ares_getaddrinfo() missing sanity check to fix #426
+
+- ares_getaddrinfo(): continue to next domain in search if query returns ARES_ENODATA
+  
+  Some DNS servers may behave badly and return a valid response with no data, in this
+  case, continue on to the next search domain, but cache the result.
+  
+  Fixes Bug: #426
+  Fix By: Brad House (@bradh352)
+
+- Allow '/' as a valid character for a returned name
+  
+  As of c-ares 1.17.2, a CNAME an in-addr.arpa delegation broke due
+  to not allowing '/'.  This needs to be allowed to not break valid
+  functionality.
+  
+  Fixes Bug: #427
+  Reported By: Adrian (@leftshift)
+  Fix By: Brad House (@bradh352)
+
+Daniel Stenberg (5 Oct 2021)
+- libcares.pc.in: update the URL
+
+bradh352 (8 Sep 2021)
+- ares_expand_name should allow underscores (_) as SRV records legitimately use them
+  
+  c-ares 1.17.2 introduced response validation to prevent a security issue, however
+  it did not have (_) listed as a valid character for domain name responses which
+  caused issues when a CNAME referenced a SRV record which contained underscores.
+  
+  While RFC2181 section 11 does explicitly state not to do validation, that applies
+  to servers not clients.
+  
+  Fixes: #424
+  Fix By: Brad House (@bradh352)
+
+Daniel Stenberg (7 Sep 2021)
+- domain: update to use c-ares.org
+  
+  Closes #423
+
+- mailing list: moved to lists.haxx.se
+
+GitHub (3 Sep 2021)
+- [Biswapriyo Nath brought this change]
+
+  CMake: Fix build in cygwin (#422)
+  
+  As cygwin environment has both socket.h and winsock2.h headers check WIN32 not to include the later one here
+  
+  Fix By: Biswapriyo Nath (@Biswa96)
+
+bradh352 (23 Aug 2021)
+- make building more verbose
+
+- add appveyor cmake/mingw static-only build
+
+GitHub (17 Aug 2021)
+- [Sinan Kaya brought this change]
+
+  CMake: lower case advapi32 for cross-building with mingw (#420)
+  
+  When cross compiling with yocto's meta-mingw layer, getting a dependency
+  error.
+  
+  This is caused by the fact that advapi32 is lower case in mingw builds.
+  
+  Fix By: Sinan Kaya <sinan.kaya@microsoft.com>
+
+bradh352 (17 Aug 2021)
+- autotools: add ax_check_gnu_make.m4
+
+- autotools: add ax_require_defined.m4
+
+- autotools: dont use newer AC_CHECK_INCLUDES_DEFAULT, don't quote AC_ERROR_MSG
+
+- import more files needed by newer ax_code_coverage.m4
+
+- import more files needed by newer ax_code_coverage.m4
+
+- work around autoreconf -fiv first call returning 'error: too many loops'
+
+- restore zz40-xc-ovr.m4
+
+- autotools: processed configure.ac through autoupdate
+
+- autotools. update ax_code_coverage.m4 to latest. don't use deprecated AC_HELP_STRING
+
+- pull out some old autotools cruft
+
+GitHub (17 Aug 2021)
+- [Felix Yan brought this change]
+
+  Provide ares_nameser.h as a public interface (#417)
+  
+  NodeJS needs ares_nameser.h as a pubic header.
+  
+  Fixes: #415
+  Fix By: Felix Yan (@felixonmars)
+
+- [Felix Yan brought this change]
+
+  Fix building when latest ax_code_coverage.m4 is imported (#418)
+  
+  ax_code_coverage.m4 dropped the @CODE_COVERAGE_RULES@ macro, so we need to switch to the latest recommendation from the m4 file.  This requires updates to Makefile.am.
+  
+  Fix By: Felix Yan (@felixonmars)
+
+bradh352 (12 Aug 2021)
+- bump version to match current release
+
+GitHub (12 Aug 2021)
+- [dhrumilrana brought this change]
+
+  z/OS minor update, add missing semicolon in ares_init.c (#414)
+  
+  Build fix for z/OS
+  
+  Fix by: Dhrumil Rana (@dhrumilrana)
+
+- [Daniel Bevenius brought this change]
+
+  add build to .gitignore (#410)
+  
+  This commit adds the build directory to be ignored by git.
+  
+  The motivation for adding this to .gitignore as opposed to
+  .git/info/exclude is that the CMake example in INSTALL.md uses build
+  as the name of the directory to be used by CMake. This will cause
+  git to report build as an untracked file.
+  
+  Fix By: Daniel Bevenius (@danbev)
+
+- [Martin Holeš brought this change]
+
+  Add support for URI(Uniform Resource Identifier) records. (#411)
+  
+  Add ares_parse_uri_reply() for parsing URI DNS replies.
+  
+  Fix By: Martin Holeš (@martin-256)
+
+Daniel Stenberg (10 Aug 2021)
+- ares_getaddrinfo.3: available since 1.16.0
+
+- README.md: use https:// links
+
+Version 1.17.2 (24 Jul 2021)
+
+bradh352 (24 Jul 2021)
+- fix typo
+
+- prep for 1.17.2 release
+
+GitHub (30 Jun 2021)
+- [jeanpierrecartal brought this change]
+
+  Replace strdup() with ares_strdup() (#408)
+  
+  strdup() is used in src/lib/ares_parse_a_reply.c and src/lib/ares_parse_aaaa_reply.c whereas allocated memory is freed using ares_free().
+  
+  Bug: 407
+  Fix By: Jean-pierre Cartal (@jeanpierrecartal)
+
+- [Brad House brought this change]
+
+  Validate hostnames in DNS responses and discard from malicious servers (#406)
+  
+  To prevent possible users having XSS issues due to intentionally malformed DNS replies, validate hostnames returned in responses and return EBADRESP if they are not valid.
+  
+  It is not clear what legitimate issues this may cause at this point.
+  
+  Bug Reported By: philipp.jeitner@sit.fraunhofer.de
+  Fix By: Brad House (@bradh352)
+
+bradh352 (11 Jun 2021)
+- ares_expand_name(): fix formatting and handling of root name response
+  
+  Fixes issue introduced in prior commit with formatting and handling
+  of parsing a root name response which should not be escaped.
+  
+  Fix By: Brad House
+
+- ares_expand_name() should escape more characters
+  
+  RFC1035 5.1 specifies some reserved characters and escaping sequences
+  that are allowed to be specified.  Expand the list of reserved characters
+  and also escape non-printable characters using the \DDD format as
+  specified in the RFC.
+  
+  Bug Reported By: philipp.jeitner@sit.fraunhofer.de
+  Fix By: Brad House (@bradh352)
+
+GitHub (15 Apr 2021)
+- [HALX99 brought this change]
+
+  Fix can't get dns server on macos and ios (#401)
+  
+  If DNS configuration didn't include search domains on MacOS (or iOS) it would throw an error instead of ignoring.
+  
+  Fix By: @halx99
+
+- [catalinh-bd brought this change]
+
+  Bugfix/crash in ares  sortaddrinfo (#400)
+  
+  The bug was generated because there was no check for the number
+  of items in the list and invalid memory was accesed when the list
+  was empty. There is a check for null after calling malloc but on
+  some systems it always returns a valid address for size equals 0.
+  Relates To: #392, 0903dcecabca283d0fa771632892dc7592b7a66d
+  
+  Fix By: @catalinh-bd
+
+bradh352 (2 Mar 2021)
+- Null deref if ares_getaddrinfo() is terminated with ares_destroy()
+  
+  ares_freeaddrinfo() was not checking for a Null ptr during cleanup of
+  an aborted query.
+  
+  Once that was resolved it uncovered another possible issue with
+  multiple simultaneous underlying queries being outstanding and
+  possibly prematurely cleaning up the handle.
+  
+  Reported By: Michael Kourlas
+  Fix By: Brad House (@bradh352)
+
+GitHub (18 Feb 2021)
+- [Brad House brought this change]
+
+  CMake: RANDOM_FILE not defined #397
+  
+  RANDOM_FILE was never defined by cmake, causing RC4 key generation to use the less secure rand() method.
+  
+  Also, due to clashes with chain-building from other projects (e.g. curl) that may define RANDOM_FILE, this was renamed to CARES_RANDOM_FILE.
+  
+  This is the proposed change for #396
+  
+  Fix By: Brad House (@bradh352)
+
+- [Anton Danielsson brought this change]
+
+  CMake: fix Make install for iOS/MacOS (#395)
+  
+  INSTALL TARGETS were missing the BUNDLE DESTINATION
+  
+  Fix By: Anton Danielsson (@anton-danielsson)
+
+- [František Dvořák brought this change]
+
+  Fix build with autotools out of source tree (#394)
+  
+  Add missing include directory, which fixes the build with autotools in separated build directory.
+  
+  Fix By: František Dvořák (@valtri)
+
+bradh352 (15 Jan 2021)
+- fuzzing: HAVE_CONFIG_H may not be defined so cannot include ares_setup.h.  Its not needed even though we include ares_nameser.h
+
+- remove redundant header checks
+
+- properly detect netinet/tcp.h on openbsd
+
+- more portability updates
+
+- renamed nameser.h to ares_nameser.h requires Makefile.inc update for distributed files
+
+- more portability updates
+
+- remove bad files
+
+- portability updates for test cases
+
+- Portability Updates for arpa/nameser.h (#388)
+  
+  There is too much inconsistency between platforms for arpa/nameser.h and arpa/nameser_compat.h for the way the current files are structured.  Still load the respective system files but make our private nameser.h more forgiving.
+  
+  Fixes: #388
+  Fix By: Brad House (@bradh352)
+
+- ares_parse_ptr_reply() handle NULL for addr/addr_len. Fixes #392
+  
+  NodeJS passes NULL for addr and 0 for addrlen parameters to ares_parse_ptr_reply().  On systems where malloc(0) returned NULL, this would cause the function to return ARES_ENOMEM, but the cleanup wasn't handled properly and would crash.
+  
+  This patche fixes that bug, and also hardens ares_free_hostent() to not leak memory during cleanup.
+  
+  Fixes: #392
+  Fix By: Brad House (@bradh352)
+
+- Define behavior of malloc(0)
+  
+  Some systems may return either NULL or a valid pointer on malloc(0).  c-ares should never call malloc(0) so lets return NULL so we're more likely to find an issue if it were to occur.
+
+GitHub (24 Dec 2020)
+- [dhrumilrana brought this change]
+
+  z/OS: port (#390)
+  
+  Port c-ares to z/OS.
+  
+  Fix By: Dhrumil Rana (@dhrumilrana)
+
+- [vburdo brought this change]
+
+  Use unbuffered stdio for /dev/urandom to read only requested data (#391)
+  
+  Buffered fread() reads 4096 bytes which is completely unnecessary and potentially may cause problems.
+  I discovered this on private linux configuration where custom /dev/urandom implementation has poor performance.
+  
+  Fix By: @vburdo
+
+- [Jay Freeman (saurik) brought this change]
+
+  This relative header #include needs to use quotes. (#386)
+  
+  Fix By: Jay Freeman (@saurik)
+
+bradh352 (23 Nov 2020)
+- Win32: Fix tools build with autotools static library
+  When c-ares is being built as static on Win32, CARES_STATICLIB must
+  be defined, but it wasn't being pulled in for the tools.
+  
+  Fixes: #384
+  Fix By: Brad House (@bradh352)
+
+- Loosen requirements for static c-ares library when building tests
+  
+  It appears that when building tests, it would hardcode enabling building
+  of the c-ares static library.  This was probably due to Windows limitations
+  in symbol visibility.
+  
+  This change will use the static library if it exists for tests, always.
+  Otherwise, it will only forcibly enable static libraries for tests on
+  Windows.
+  
+  Fixes: #380
+  Fix By: Brad House (@bradh352)
+
+- Remove legacy comment about ahost/acountry/adig targets
+
+- Distribute fuzzinput/fuzznames for fuzz tests
+  
+  The fuzz test files were not being distributed.  This doesn't appear to be
+  a regression, it looks like they have never been distributed.
+  
+  Fixes: #379
+  Fix By: Brad House (@bradh352)
+
+Version 1.17.1 (19 Nov 2020)
+
+GitHub (19 Nov 2020)
+- [Brad House brought this change]
+
+  Travis: add iOS target built with CMake (#378)
+  
+  Issue #377 suggested that CMake builds for iOS with c-ares were broken. This PR adds an automatic Travis build for iOS CMake.
+  
+  Fix By: Brad House (@bradh352)
+
+bradh352 (18 Nov 2020)
+- fix build
+
+GitHub (18 Nov 2020)
+- [Fabrice Fontaine brought this change]
+
+  External projects were using non-public header ares_dns.h, make public again (#376)
+  
+  It appears some outside projects were relying on macros in ares_dns.h, even though it doesn't appear that header was ever meant to be public.  That said, we don't want to break external integrators so we should distribute this header again.
+  
+  Fix By: Fabrice Fontaine (@ffontaine)
+
+bradh352 (17 Nov 2020)
+- note that so versioning has moved to configure.ac
+
+- note about 1.17.1
+
+- fix sed gone wrong
+
+GitHub (17 Nov 2020)
+- [Daniel Stenberg brought this change]
+
+  autotools cleanup (#372)
+  
+  * remove: install-sh mkinstalldirs
+  
+  They're generated when needed, no need to store in it.
+  
+  * buildconf: remove custom logic with autoreconf
+  
+  Fix By: Daniel Stenberg (@bagder)
+
+bradh352 (17 Nov 2020)
+- attempt to fix 1.17.0 release distribution issues
+
+Version 1.17.0 (16 Nov 2020)
+
+bradh352 (16 Nov 2020)
+- 1.17.0 release prep
+
+- ares_getaddrinfo(): duplicate hints ai_socktype and ai_protocol into output
+  
+  ai_socktype and ai_protocol were ignored from the hints input.  They are now
+  duplicated into the output as expected.  Currently no sanity checks on
+  proper values are taking place.
+  
+  Fixes: #317
+  Fix By: Brad House (@bradh352)
+
+- ares_parse_{a,aaaa}_reply could return larger *naddrttls than passed in
+  
+  If there are more ttls returned than the maximum provided by the requestor, then
+  the *naddrttls response would be larger than the actual number of elements in
+  the addrttls array.
+  
+  This bug could lead to invalid memory accesses in applications using c-ares.
+  
+  This behavior appeared to break with PR #257
+  
+  Fixes: #371
+  Reported By: Momtchil Momtchev (@mmomtchev)
+  Fix By: Brad House (@bradh352)
+
+GitHub (5 Nov 2020)
+- [Dustin Lundquist brought this change]
+
+  docs: ares_set_local_ip4() uses host byte order (#368)
+  
+  Properly document brain-dead behavior of ares_set_local_ip4() using host byte order instead of expected network byte order.
+  
+  Fix By: Dustin Lundquist <d.lundquist@tempered.io>
+
+- [Łukasz Marszał brought this change]
+
+  empty hquery->name could lead to invalid memory access (#367)
+  
+  If hquery->name is empty (=="\0"), &hquery->name[strlen(hquery->name)-1] would point to "random" place in memory. This is causing some of my address sanitizer tests to fail.
+  
+  Fix By: Łukasz Marszał (@lmarszal)
+
+bradh352 (28 Sep 2020)
+- Fix OSSFuzz reported issue in CAA reply parsing
+  
+  OSS-Fuzz is reporting a use-of-uninitialized-value:
+  https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=26012
+  
+  Reported By: David Drysdale (@daviddrysdale)
+
+GitHub (26 Sep 2020)
+- [David Hotham brought this change]
+
+  fuzz CAA parsing (#363)
+  
+  Add fuzz support for CAA parsing
+  
+  Fix By: David Hotham (@dimbleby)
+
+- [Daniela Sonnenschein brought this change]
+
+  Allow parsing of CAA Resource Record (#360)
+  
+  CAA (Certification Authority Authorization) was introduced in RFC 6844.
+  This has been obsoleted by RFC 8659. This commit added the possibility
+  to query CAA resource records with adig and adds a parser for CAA
+  records, that can be used in conjunction with ares_query(3).
+  
+  Closes Bug: #292
+  Fix By: Daniela Sonnenschein (@lxdicted)
+
+Daniel Stenberg (17 Sep 2020)
+- docs: remove the html and pdf make targets
+  
+  They're rarely used in our daily work flow and mostly just add friction,
+  
+  Closes #362
+
+bradh352 (14 Sep 2020)
+- ares_process needs to always include nameser.h as it has compat
+
+- Define T_OPT if system doesn't provide it
+
+GitHub (12 Sep 2020)
+- [Gisle Vanem brought this change]
+
+  Change the mailman links (#358)
+  
+  Links when wrapping become misleading.  Insert newline to prevent wrapping.
+  
+  Fix By: Gisle Vanem (@gvanem)
+
+- [Gisle Vanem brought this change]
+
+  [adig] Update man-page for the '-x' option (#357)
+  
+  Fix By: Gisle Vanem (@gvanem)
+
+- [Gisle Vanem brought this change]
+
+  [adig] add '-x' option. (#356)
+  
+  Added a 'dig-style' '-x' option. Also support '-xx' for a
+  IPv6 bit-string PTR query.
+  
+  Fix By: Gisle Vanem (@gvanem)
+
+bradh352 (12 Sep 2020)
+- fix indentation
+
+- ns_t_opt -> T_OPT
+
+GitHub (12 Sep 2020)
+- [Gisle Vanem brought this change]
+
+  Fixes for Watt-32 on djgpp + Windows (#355)
+  
+  No longer any relation to libcurl since '<libcurl-root>/packages/DOS/common.dj' is dropped.
+  This Makefile.dj has been tested on Win-10 only (using the Windows hosted djgpp cross compiler).
+  
+  Fix By: Gisle Vanem (@gvanem)
+
+- [Gisle Vanem brought this change]
+
+  Fixes for Watt-32 on Windows and MSDOS (#354)
+  
+  Move the prototype to 'ares_private.h'.
+  
+  Fix By: Gisle Vanem (@gvanem)
+
+bradh352 (11 Sep 2020)
+- update path for include
+
+- remove stale information
+
+- remove stale information
+
+Brad House (9 Sep 2020)
+- silence compiler warnings
+
+- Remove stale msvc files from makefile
+
+GitHub (9 Sep 2020)
+- [Brad House brought this change]
+
+  Reorganize source tree (#349)
+  
+  Originally started by Daniel Stenberg (@bagder) with #123, this patch reorganizes the c-ares source tree to have a more modern layout.  It also fixes out of tree builds for autotools, and automatically builds the tests if tests are enabled.  All tests are passing which tests each of the supported build systems (autotools, cmake, nmake, mingw gmake).  There may be some edge cases that will have to be caught later on for things I'm not aware of.
+  
+  Fix By: Brad House (@bradh352)
+
+Brad House (1 Sep 2020)
+- remove CURLDEBUG as per #82
+
+GitHub (1 Sep 2020)
+- [Erik Lax brought this change]
+
+  Detect remote DNS server does not support EDNS as per RFC 6891 (#244)
+  
+  EDNS retry should be based on FORMERR returned without an OPT RR record as per https://tools.ietf.org/html/rfc6891#section-7 rather than just treating any unexpected error condition as a reason to disable EDNS on the channel.
+  
+  Fix By: Erik Lax (@eriklax)
+
+Brad House (27 Aug 2020)
+- Fix for #345, don't use 'true' use 1
+
+GitHub (27 Aug 2020)
+- [Seraphime Kirkovski brought this change]
+
+  ares_gethostbyname: Fix AF_UNSPEC support when using an ip address (#204)
+  
+  fake_hostent() was not supporting AF_UNSPEC, so when an ip address was specified when using AF_UNSPEC it would attempt to do a DNS lookup rather than returning a fake hostent using the ip address.
+  
+  Fix By: Seraphime Kirkovski (@Seraphime)
+
+- [apenn-msft brought this change]
+
+  Tests should use dynamic system-assigned ports rather than static port (#346)
+  
+  The c-ares test suite was hardcoded to use port 5300 (and possibly 5301, 5302) for the test suite.  Especially in containers, there may be no guarantee these ports are available and cause tests to fail when they could otherwise succeed.  Instead, request the system to assign a port to use dynamically.  This is now the default.  To override, the test suite still takes the "-p <port>" option as it always has and will honor that.
+  
+  Fix By: Anthony Penniston (@apenn-msft)
+
+Brad House (25 Aug 2020)
+- Unset members of the addr struct contain garbage values (#343)
+  
+  When generating the ares_sockaddr data by getaddrinfo() it was only filling
+  in certain members while leaving others uninitialized.  This left garbage
+  data if a user tried to use the unset values.  memset() the ares_sockaddr
+  to 0 prior to filling in the values to prevent this.
+  
+  Reported By: @SmorkalovG
+  Fix By: Brad House (@bradh352)
+
+GitHub (24 Aug 2020)
+- [Jonathan Maye-Hobbs brought this change]
+
+  FQDN with trailing period should be queried first with larger ndot value (#345)
+  
+  If a query is performed for dynamodb.us-east-1.amazonaws.com. with ndots=5, it was attempting to search the search domains rather than just attempting the FQDN that was passed it.  This patch now at least attempts the FQDN first.
+  
+  We may need to determine if we should abort any further searching, however as is probably intended.
+  
+  Fix by: Jonathan Maye-Hobbs (@wheelpharoah)
+
+- [Gisle Vanem brought this change]
+
+  Update acountry.c country code list (#341)
+  
+  Updated country_list[]:
+   * 2-letter ISO-3166 country-codes.
+   * Add, rename some names + codes in accordance with latest table at https://en.wikipedia.org/wiki/ISO_3166-1.
+  
+  Fix By: Gisle Vanem (@gvanem)
+
+- [Bulat Gaifullin brought this change]
+
+  Test case should honor flag HAVE_WRITEV rather than WIN32 (#344)
+  
+  Test cases where not honoring the HAVE_WRITEV flag but instead using WIN32 to determine if WRITEV was available or not.  This patch fixes that.
+  
+  Fix By: Bulat Gaifullin (@bgaifullin)
+
+Brad House (18 Jul 2020)
+- Ensure c89 support
+  
+  A couple of for loops in Mac-specific code were using integer declarations
+  inside a for loop.  Move the declaration to the top of the preceding
+  code block to retain c89 compliance.
+  
+  Reported By: Jeffrey Walton
+
+GitHub (2 Jul 2020)
+- [Fionn Fitzmaurice brought this change]
+
+  Avoid buffer overflow in RC4 loop comparison (#336)
+  
+  The rc4 function iterates over a buffer of size buffer_len who's maximum
+  value is INT_MAX with a counter of type short that is not guaranteed to
+  have maximum size INT_MAX.
+  
+  In circumstances where short is narrower than int and where buffer_len
+  is larger than the maximum value of a short, it may be possible to loop
+  infinitely as counter will overflow and never be greater than or equal
+  to buffer_len.
+  
+  The solution is to make the comparison be between types of equal width.
+  This commit defines counter as an int.
+  
+  Fix By: Fionn Fitzmaurice (@fionn)
+
+- [anonymoushelpishere brought this change]
+
+  Updated help information for adig, acountry, and ahost. (#334)
+  
+  Provide more descriptive help information for various utilities.
+  
+  Fix By: @anonymoushelpishere
+
+- [lutianxiong brought this change]
+
+  avoid read-heap-buffer-overflow (#332)
+  
+  Fix invalid read in ares_parse_soa_reply.c found during fuzzing
+  
+  Fixes Bug: #333
+  Fix By: lutianxiong (@ltx2018)
+
+- [Ivan Baidakou brought this change]
+
+  Fix: sizeof(sizeof(addr.saX)) -> sizeof(addr.saX) in readaddrinfo (#331)
+  
+  Looks like a sed-gone-wrong, a sizeof inside of a sizeof.
+  
+  Fix By: Ivan Baidakou (@basiliscos)
+
+Version 1.16.1 (11 May 2020)
+
+Brad House (11 May 2020)
+- c-ares 1.16.1 release prep
+
+- update travis to use xcode11.4
+
+- Prevent possible double-free in ares_getaddrinfo() if ares_destroy() is called
+  
+  In the event that ares_destroy() is called prior to ares_getaddrinfo() completing,
+  it would result in an invalid read and double-free due to calling end_hquery() twice.
+  
+  Reported By: Jann Horn @ Google Project Zero
+
+GitHub (30 Apr 2020)
+- [shelley vohr brought this change]
+
+  fix: windows UNICODE incompatibilities with ares_getaddrinfo (#328)
+  
+  Fixes the following compatibility issues:
+  * Use RegQueryValueExA instead of RegQueryValueEx
+  * Use ExpandEnvironmentStringsA instead of ExpandEnvironmentStrings
+  * Use RegOpenKeyExA instead of RegOpenKeyExA
+  * Use GetWindowsDirectoryA instead of GetWindowsDirectoryA
+  
+  Fix By: Shelley Vohr (@codebytere)
+  Closes: #327
+
+Brad House (13 Apr 2020)
+- travis: CloudFlare does not allow T_ANY requests, so live tests that use it fail.  Disable.
+
+- travis: bump macos image to the latest
+
+- cast-align warnings are false for struct sockaddr, silence
+  
+  Create a macro to silence false cast-align warnings when casting
+  struct sockaddr * to struct sockaddr_in * and struct sockaddr_in6 *.
+  
+  Fix By: Brad House (@bradh352)
+
+- MacOS: Enable libresolv support for retrieving DNS servers like iOS does.
+
+GitHub (10 Apr 2020)
+- [Dmitry Igrishin brought this change]
+
+  CMake: Populate the INCLUDE_DIRECTORIES property of installed targets (#323)
+  
+  Populate the INCLUDE_DIRECTORIES property of installed targets
+  
+  Fix By: Dmitry Igrishin (@dmitigr)
+
+Brad House (10 Apr 2020)
+- travis: make valgrind use cmake for tests
+
+- dont try to use libtool to run valgrind
+
+- valgrind requires libtool installed to wrap tests
+
+- scan build 7
+
+- fix travis live test
+
+- add debug for travis
+
+- try without sudo
+
+- attempt to modernize travis build environment
+
+GitHub (6 Apr 2020)
+- [Teemu R brought this change]
+
+  Allow TXT records on CHAOS qclass (#321)
+  
+  Some DNS servers intentionally "misuse" the obsoleted CHAOS (CH) qclass to provide things like `version.bind`, `version.server`, `authors.bind`, `hostname.bind` and `id.server`.
+  
+  C-ares was not allowing such use cases.
+  
+  Fix By: Teemu R. (@rytilahti)
+
+Brad House (5 Apr 2020)
+- Remove warnings from ares_getaddrinfo.3 man page
+  
+  As reported in #319, non-standard macros of .IN were used.
+  Replace with .RS/.RE.
+  
+  Fixes: #319
+  Fix By: Brad House (@bradh352)
+
+- ares_getaddrinfo man page render better for man2html
+
+- update man pages to render better for man2html
+
+Version 1.16.0 (12 Mar 2020)
+
+Brad House (12 Mar 2020)
+- 1.16.0 release notes draft
+
+- attempt to fix double-free introduced in e0517f9
+
+GitHub (12 Mar 2020)
+- [David Drysdale brought this change]
+
+  test: fuzzer input triggering double free (#315)
+  
+  OSS-Fuzz has reported a double-free with the fuzzer input file
+  included here; run with:
+    ./test/aresfuzz test/fuzzinput/clusterfuzz-5637790584012800
+  
+  Bisecting the failure points to commit e0517f97d988 ("Parse SOA records
+  from ns_t_any response (#103)")
+
+- [Brad House brought this change]
+
+  CMake: Install Manpages (#314)
+  
+  CMake wasn't installing manpages.
+  
+  Fixes #297
+  Fix By: Brad House (@bradh352)
+
+- [Brad House brought this change]
+
+  Enable cmake tests for AppVeyor (#313)
+  
+  Tests require linking against the static library on Windows otherwise the symbols are not exported for internals being tested.
+  
+  Fix By: Brad House (@bradh352)
+
+Brad House (11 Mar 2020)
+- Add AppVeyor badge
+
+- bump c-ares version to 1.16.0. test AppVeyor integration.
+
+GitHub (11 Mar 2020)
+- [Brad House brought this change]
+
+  replace all usages of inet_addr() with ares_inet_pton() which is more proper (#312)
+  
+  Replace usage of inet_addr() with ares_inet_pton() which is more appropriate and fixes issues with legitimate addresses like 255.255.255.0. IPv6 already used this.
+  
+  Fixes #309
+  Fix By: Brad House (@bradh352)
+
+- [Brad House brought this change]
+
+  CMake: Generate WinPDB files during build (#311)
+  
+  Build and Install PDB (Windows Debug Symbol) files if supported by underlying system.
+  
+  Also update AppVeyor to test cmake builds.
+  
+  Fixes #245
+  Fix By: Piotr Pietraszkiewicz (@ppietrasa) and Brad House (@bradh352)
+
+- [Brad House brought this change]
+
+  CMake: Rework library function checking (#310)
+  
+  CHECK_LIBRARY_EXISTS(), while it takes a function name, does not actually verify the function exists in the library being evaluated. Instead, if the function is found in any dependent library, and the referenced library also exists, it returns true. This is not desirable.
+  
+  Wrap with a Macro to change the behavior.
+  
+  Fixes: #307
+  Fix By: Brad House (@bradh352)
+
+- [Dron Rathore brought this change]
+
+  Parse SOA records from ns_t_any response (#103)
+  
+  Added the capability of parsing SOA record from a response buffer of ns_t_any type query, this implementation doesn't interfere with existing T_SOA query's response as that too is treated as a list of records. The function returns ARES_EBADRESP if no SOA record is found(as per RFC).
+  
+  The basic idea of sticking to RFC that a ns_t_any too should return an SOA record is something open for discussion but I have kept the functionality intact as it was previously i.e the function returns ARES_EBADRESP if it doesn't find a SOA record regardless of which response it is parsing i.e. T_SOA or T_ANY.
+  
+  Note that asking for T_ANY is generally a bad idea:
+  - https://blog.cloudflare.com/what-happened-next-the-deprecation-of-any/
+  - https://tools.ietf.org/html/draft-ietf-dnsop-refuse-any
+  
+  Bug: #102
+  Fix By: Dron Rathore (@DronRathore)
+
+- [Stephen Bryant brought this change]
+
+  Added CPack functionality for generating RPM or DEB packages (#283)
+  
+  Added CPack functionality for generating RPM or DEB packages
+  
+  ie: run `cpack -G RPM` (or "DEB") after building with CMake.
+  
+  The current configuration creates 3 separate packages for the shared library,
+  the development files and the tools.
+  
+  Fix By: Stephen Bryant (@bf-bryants)
+
+- [tjwalton brought this change]
+
+  ares_gethostbyname: Return ENODATA if no valid A or AAAA record found (#304)
+  
+  ares_gethostbyname() was returning ESUCCESS when no A or AAAA record was found but a CNAME pointing nowhere was present.  ENODATA should be returned instead, however the hosts pointer will still be present to provide the alias list.
+  
+  * Return ENODATA if no valid A or AAAA record found
+  * Fix and update test ParseAReplyNoData.
+  * Add test for new ENODATA behaviour in ares_gethostbyname.
+  
+  Fixes Bug #303
+  Fix By: @tjwalton
+
+- [Michal Rostecki brought this change]
+
+  test: Separate live tests from SetServers* tests (#299)
+  
+  Before this change, SetServers, SetServersPorts and SetServersCSV
+  contained test cases trying to make DNS queries with the google.com
+  hostname, which requires Internet connectivity. Tests with that
+  requirement should be defined in the ares-test-live.cc file and contain
+  "Live" prefix to filter them out with `--gtest_filter=-*.Live*` on
+  machines without Internet connectivity.
+  
+  Fix By: Michal Rostecki (@mrostecki)
+
+- [Adam Majer brought this change]
+
+  Only count valid addresses when response parsing (#302)
+  
+  When ares_parse_a_reply or ares_parse_aaaa_reply is called in case
+  where another AAAA and A responses exist, the resulting ares_addrttl
+  count is invalid and the structure points to gibberish.
+  
+  This is a regression since 1.15.
+  
+  Issue: https://github.com/c-ares/c-ares/issues/300
+  Fix By: Adam Majer (@AdamMajer)
+
+Brad House (24 Dec 2019)
+- [Kyle Edwards brought this change]
+
+  CMake: Provide c-ares version in package export file (#296)
+  
+  The CMake package export file should provide version information.
+  
+  Fix By: Kyle Edwards (@KyleFromKitware)
+
+- [Ben Noordhuis brought this change]
+
+  Accept invalid /etc/resolv.conf lookup values, ability to build container tests (#274)
+  
+  * Add CARES_BUILD_CONTAINER_TESTS CMake option to add ability to build the Linux-only containerized tests.
+  * Accept invalid /etc/resolv.conf lookup values
+  
+  Before this commit invalid `lookup` values resulted in c-ares not using
+  any lookups without any clear indication why. After this commit it uses
+  the default "fb".
+  
+  Fix By: Ben Noordhuis (@bnoordhuis)
+
+- [Christian Ammer brought this change]
+
+  Parallel A and AAAA lookups in `ares_getaddrinfo` (#290)
+  
+  A and AAAA lookups for ares_getaddrinfo() are now performed in parallel.
+  
+  For this change `ares_search` was removed from `ares_getaddrinfo`.
+  Instead `ares_query` in combination with `next_dns_lookup` are
+  doing the suffix search.
+  
+  Adding support for `.onion` addresses which are tested by
+  `TEST_F(DefaultChannelTest, GetAddrinfoOnionDomain)`
+  
+  Fix By: Christian Ammer (@ChristianAmmer)
+
+- [Vy Nguyen brought this change]
+
+  Move variables into the block where it is used to avoid unused-vars (#281)
+  
+  Warning uncovered with [-Werror, -Wunused-variables]
+  
+  Fix By: Vy Nguyen (@oontvoo)
+
+- [Vy Nguyen brought this change]
+
+  Rename local macros to avoid conflicting with system ones and remove unsed variables. (Otherwise code will break once compiled with [-Werror,-Wmacro-redefined,-Wunused-variable] ) (#280)
+  
+  Fix new getaddrinfo code to not redefine macros on some systems.
+  
+  Fix By: Vy Nguyen (@oontvoo)
+
+- [Egor Pugin brought this change]
+
+  [ares_getenv] Return NULL in all cases. (#279)
+  
+  if ares_getenv is defined, it must return a value on all platforms.
+  
+  Fix By: Egor Pugin (@egorpugin)
+
+- [Abhishek Arya brought this change]
+
+  Add OSS-Fuzz fuzzing badge (#278)
+  
+  Adds based on instructions at
+  https://google.github.io/oss-fuzz/getting-started/new-project-guide/#status-badge
+  
+  Patch By: Abhishek Arya (@inferno-chromium)
+
+- [Peter Eisentraut brought this change]
+
+  ares_init_options.3: Fix layout (#275)
+  
+  7e6af8e inserted the documentation of resolvconf_path in the middle of
+  the item for ednspsz, leading to broken layout.  Fix that.
+  
+  Fix By: Peter Eisentraut (@petere)
+
+- [Gregor Jasny brought this change]
+
+  manpages: Fix typos detected by lintian (#269)
+  
+  
+  Fix By: Gregor Jasny (@gjasny)
+
+- [lifenjoiner brought this change]
+
+  keep command line usage up to date (#256)
+  
+  adig and ahost built-in help did not match args taken.
+  
+  Fix-By: @lifenjoiner
+
+- [Dan Noé brought this change]
+
+  ares-test.cc: Handle nullptr in AddrInfo ostream. (#268)
+  
+  The const AddrInfo& argument to operator<< overload for AddrInfo can be
+  a nullptr unique_ptr. Handle this explicitly by printing {nullptr} if
+  the rest of the function cannot be safely executed.
+  
+  Fix-by: Dan Noé <dpn@google.com>
+
+- [Dan Noé brought this change]
+
+  Add missing limits.h include from ares_getaddrinfo.c (#267)
+  
+  This files references INT_MAX, but does not include limits.h. This can
+  cause a build failure on some platforms. Include limits.h if we have it.
+  
+  Fix-by: Dan Noé <dpn@google.com>
+
+- [Andrew Selivanov brought this change]
+
+  fix fuzzer docs and add missing getaddrinfo docs (#265)
+  
+  There is a fix for a bit outdated clang fuzzer docs and ares_getaddrinfo docs.
+  
+  Fix By: Andrew Selivanov (@ki11roy)
+
+- [Andrew Selivanov brought this change]
+
+  Fix leak and crash in ares_parse_a/aaaa_reply (#264)
+  
+  * fix leak if naddress of particular type found
+  * fix segfault when wanted ttls count lesser than count of result records
+  * add fuzzer input files that trigger problems (from #263)
+  
+  Reported-By: David Drysdale (@daviddrysdale)
+  Fix-By: Andrew Selivanov (@ki11roy)
+
+- [Andrew Selivanov brought this change]
+
+  fix segfault when parsing wrong type of record (#262)
+  
+  Fixes segfault when trying to ares_parse_aaaa with AF_INET and vise versa.
+  
+  Fix By: Andrew Selivanov (@ki11roy)
+
+- work around mingw compile failure
+
+- c++ requires explicit casts
+
+- support EnvValue on Windows by implementing setenv/unsetenv
+
+- [Andrew Selivanov brought this change]
+
+  getaddrinfo enhancements (#257)
+  
+  * Service support has been added to getaddrinfo.
+  * ares_parse_a/aaaa_record now share code with the addrinfo parser.
+  * Private ares_addrinfo structure with useful extensions such as ttls (including cname ttls),
+    as well as the ability to list multiple cnames in chain of lookups
+  
+  Work By: Andrew Selivanov @ki11roy
+
+- [Andrew Selivanov brought this change]
+
+  fix ares__sortaddrinfo, use wrappers for sock_funcs (#258)
+  
+  Some socket functions weren't exposed for use by other areas of the library.  Expose
+  those and make use of them in ares__sortaddrinfo().
+  
+  Fix By: Andrew Selivanov (@ki11roy)
+
+- Fix c89 compilation support broken by .onion rejection changes
+  
+  Move .onion check lower after all variables have been declared.
+  
+  Bug: #246
+
+- [kedixa brought this change]
+
+  getaddrinfo: callback must be called on bad domain (#249)
+  
+  Due to an order of incrementing the remaining queries and calling ares_query, on a bad domain
+  the registered callback wouldn't be called.
+  
+  Bug: #248
+  Fixed-By: @kedixa
+
+- [Darrin W. Cullop brought this change]
+
+  Windows ARM/ARM64 requires AdvApi32 (#252)
+  
+  Fix link issues caused by missing library that appears to only be required on ARM (though
+  docs don't list this restriction). Doesn't hurt to require it everywhere.
+  
+  Bug: #251
+  Fixed-By: Darrin Cullop (@dwcullop)
+
+- [kedixa brought this change]
+
+  getaddrinfo: avoid infinite loop in case of NXDOMAIN(#240) (#242)
+  
+  There are two possible causes for infinite loops fo NXDOMAIN, based on how many dots are in the domain name (one for < ARES_OPT_NDOTS and one for >= ARES_OPT_NDOTS), where it will repeat the same query over and over as the hquery->next_domain doesn't increment.
+  
+  Fix By: @kedixa
+
+- Portability fix for ares__sortaddrinfo()
+  
+  replace uint32_t with unsigned int and socklen_t with ares_socklen_t
+  
+  By: Brad House
+
+- [Khaidi Chu brought this change]
+
+  fix: init bufp before reject .onion to make it can be free correctly (#241)
+  
+  When querying a .onion domain, it returns directly without setting bufp to NULL. A subsequent free() that occurs can cause a segmentation fault.
+  
+  Fix By: Khaidi Chu (@XadillaX)
+
+- [Andrew Selivanov brought this change]
+
+  Add ares__sortaddrinfo() to support getaddrinfo() sorted results (#239)
+  
+  This is a port of RFC 6724 compliant sorting function from Android Bionic project:
+  https://android.googlesource.com/platform/bionic/+/e919b116d35aa7deb24ddece69c491e24c3b0d6f/libc/netbsd/net/getaddrinfo.c
+  
+  The latest version is essentially the same, except two additional parameters to test connection with (mark/uid):
+  https://android.googlesource.com/platform/bionic/+/master/libc/dns/net/getaddrinfo.c
+  
+  Please note that even that version has some restrictions. It doesn't support some rules from RFC 6724:
+  
+  Rule 3 (Avoid deprecated addresses)
+  Rule 4 (Prefer home addresses)
+  Rule 7 (Prefer native transport)
+  
+  Submitted By: Andrew Selivanov (@ki11roy)
+
+- [Christian Ammer brought this change]
+
+  Increase portability of `ares-test-mock-ai.cc` (#235)
+  
+  * using portable ares_inet_pton and updated includes in ares-test-mock-ai
+  * forgot to remove deleted ares-test-ai.cc in Makefile.inc
+  
+  Fix By: Christian Ammer (@ChristianAmmer)
+
+- [Fabrice Fontaine brought this change]
+
+  m4/xc-cc-check.m4: use XC_CHECK_BUILD_FLAGS (#236)
+  
+  Use XC_CHECK_BUILD_FLAGS instead of XC_CHECK_USER_FLAGS.
+  Otherwise it complains of CPPFLAGS in CFLAGS.
+  [Retrieved from:
+  https://git.buildroot.net/buildroot/tree/package/c-ares/0001-use_check_build_instead_of_check_user.patch]
+  
+  Signed-off-by: Gustavo Zacarias <gustavo@zacarias.com.ar>
+  Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>
+  Submitted by: Fabrice Fontaine
+
+- [Christian Ammer brought this change]
+
+  Bugfix for `ares_getaddrinfo` and additional unit tests (#234)
+  
+  This PullRequest fixes a bug in the function add_to_addrinfo which task is to add new addrinfo items to the ai_next linked list. Also additional unit tests for testing ares_getaddrinfo will be added:
+  
+  Additional mock server test classes (ares-test-mock-ai.cc):
+  MockTCPChannelTestAI
+  MockExtraOptsTestAI
+  MockNoCheckRespChannelTestAI
+  MockEDNSChannelTestAI
+  RotateMultiMockTestAI
+  NoRotateMultiMockTestAI
+  
+  Additional live tests (ares-test-live-ai.cc):
+  LiveGetHostByNameV4
+  LiveGetHostByNameV6
+  LiveGetHostByNameV4AndV6
+  
+  Fix By: Christian Ammer (@ChristianAmmer)
+
+- [Christian Ammer brought this change]
+
+  Remaining queries counter fix, additional unit tests for `ares_getaddrinfo` (#233)
+  
+  Remaining queries counter fix, added tests (ParallelLookups,
+  SearchDomains, SearchDomainsServFailOnAAAA).  Removed unnecessary
+  if and commented code in test.
+  
+  Fix By: Christian Ammer (@ChristianAmmer)
+
+- [Christian Ammer brought this change]
+
+  Add initial implementation for ares_getaddrinfo (#112)
+  
+  Initial implementation for ares_getaddrinfo().  It is NOT compliant with RFC6724, though
+  it is expected to come closer to conformance prior to the next release.
+  
+  Features not supported include sorted addresses and honoring of service and hints
+  parameters.
+  
+  Implementation by: Christian Ammer (@ChristianAmmer)
+
+- [Ben Noordhuis brought this change]
+
+  test: fix bad expectation in ipv6 localhost test (#227)
+  
+  The LiveGetLocalhostByAddrV6 test expected to see "localhost" in the
+  result when doing an address-to-name lookup for ::1 but on my system
+  that resolves to "ip6-loopback" because of this stanza in /etc/hosts:
+  
+      $ grep ^::1 /etc/hosts
+      ::1     ip6-localhost ip6-loopback
+  
+  Fix By: Ben Noordhuis (@bnoordhuis)
+  Bug: #85
+
+- [Ben Noordhuis brought this change]
+
+  ares_version.h: bump version (#230)
+  
+  Version change not committed from maketgz.sh
+  
+  Bug: #229
+
+Daniel Stenberg (24 Oct 2018)
+- ares_library_init_android.3: minor syntax edits, fixed AVAILABILITY
+
+Version 1.15.0 (23 Oct 2018)
+
+Brad House (23 Oct 2018)
+- last minute 1.15.0 addition
+
+- [Ben Noordhuis brought this change]
+
+  Report ARES_ENOTFOUND for .onion domain names as per RFC7686. (#228)
+  
+  Quoting RFC 7686:
+  
+      Name Resolution APIs and Libraries (...) MUST either respond
+      to requests for .onion names by resolving them according to
+      [tor-rendezvous] or by responding with NXDOMAIN.
+  
+      A legacy client may inadvertently attempt to resolve a .onion
+      name through the DNS. This causes a disclosure that the client
+      is attempting to use Tor to reach a specific service. Malicious
+      resolvers could be engineered to capture and record such leaks,
+      which might have very adverse consequences for the well-being
+      of the user.
+  
+  Bug: #196
+  Fix By: Ben Noordhuis @bnoordhuis
+
+- prepare for c-ares 1.15.0 release
+
+- AIX Build Fix
+  
+  AIX attempts to include both nameser_compat.h and onameser_compat.h.  It appears
+  the proper fix is to define _USE_IRS so that only nameser_compat.h is used.
+  
+  Bug: #224
+  Fix By: Brad House (@bradh352)
+
+- Fix crash in ares_dup() due to new ARES_OPT_RESOLVCONF
+  
+  ares_dup() calls ares_init_options() by making its own fake option
+  mask since the original mask isn't stored but ARES_OPT_RESOLVCONF
+  was always set, instead of conditionally set.  This caused a crash
+  because ares_strdup() isn't NULL-safe if no custom path was set.
+  
+  Made ares_dup() set ARES_OPT_RESOLVCONF conditionally.
+  
+  Fix By: Brad House (@bradh352)
+
+- [Sarat Addepalli brought this change]
+
+  Add ares_init_options() configurability for path to resolv.conf file
+  
+  Add resolvconf_path to end of struct ares_options with ARES_OPT_RESOLVCONF option
+  so on Unix-like systems a custom path can be specified.  If no path is specified,
+  /etc/resolv.conf is used like normal.
+  
+  Fix By: Sarat Addepalli @SirR4T
+  Fixes Bug: #220
+  Review By: Brad House @bradh352
+
+- remove stale variables
+
+- fix prototype name for ares_strsplit_free()
+
+- add missing prototype
+
+- simplify ares_strsplit() and create ares_strsplit_free() helper function
+
+- missing ares_strsplit.h from HHEADERS for inclusion in distribution
+
+- [Ruslan Baratov brought this change]
+
+  Add CARES_BUILD_TOOLS CMake option (#214)
+  
+  Add ability to exclude building of tools (adig, ahost, acountry) in CMake.  This should also close #200.
+  
+  Fix By: Ruslan Baratov (@ruslo)
+  Bug: #200
+
+- [flyingdutchman23 brought this change]
+
+  Style. Whitespace cleanup. (#213)
+  
+  Small whitespace cleanups.
+  
+  Fix By: @flyingdutchman23
+
+- [John Schember brought this change]
+
+  Android: Support for domain search suffix (#211)
+  
+  Fixes issue #207. Uses LinkProperties.getDomains() to get a list of search domains and adds them to the suffix list.  This also adds a new helper function to split strings into an array based on multiple delimiters replacing multiple other functions for dealing with string splitting.
+  
+  Submitter: John Schember (@user-none)
+  Fixes: #207
+  Approved-by: Brad House (@bradh352)
+
+- [afalin brought this change]
+
+  Improve DNS suffixes extracting from WinNT registry (#202)
+  
+  Join all global and connection specific suffix lists. Use 'HKLM\Software\Policies\Microsoft\Windows NT\DNSClient\SearchList', 'HKLM\System\CurrentControlSet\Services\Tcpip\Parameters\Domain' as global suffix lists.
+  
+  Fix By: @afalin
+
+- Be consistent with indention in CMakeLists.txt
+  
+  The imported TRANSFORM_MAKEFILE_INC function from curl used space indention
+  but the rest of the file used tabs.  Go ahead and make it tabs for
+  consistency as well.
+  
+  Committed By: Brad House
+
+- [flyingdutchman23 brought this change]
+
+  Fix modern gcc warning: argument to 'sizeof' in 'strncpy' call is the same expression as the source
+  
+  Silence warning about using src to determine number of bytes to copy.
+  In this case it doesn't matter whether it is `src` or `dest`. So there
+  is no functionality change.
+  
+  Bug: #210
+  Fix By: @flyingdutchman23
+
+- [Andi Schnebinger brought this change]
+
+  fix stringop-overflow warning of GCC (#201)
+  
+  When using a modern GCC to compile c-ares, there is a stringop-overflow warning.
+  This patch simply silences the false-positive warning, there is no actual code flaw.
+  
+  Bug: https://github.com/c-ares/c-ares/pull/201
+  Fixed By: Andi Schnebinger @Iniesta8
+
+GitHub (18 May 2018)
+- [David Drysdale brought this change]
+
+  travis: do coverage in "coverage" build (#195)
+  
+  Fixes #194, a mistake from commit a255081f2c3c ("travis: Only do
+  coverage/distcheck on normal build")
+
+Brad House (17 May 2018)
+- [Brad Spencer brought this change]
+
+  Apply the IPv6 server blacklist to all nameserver sources, not just Windows (#193)
+  
+  For #164, I mentioned that it seemed like the IPv6 nameserver blacklist should apply to all OSes. In a mailing list post, @bradh352 agreed and suggested that I file a PR to make it so.
+  
+  This moves the blacklist check from being Windows-specific to being a general feature of config_nameservers(), no matter the nameserver source. It also simplifies the ares_ipv6_server_blacklisted() implementation to not parse and re-parse the blacklisted IPv6 addresses from strings on every check. I think they're almost as easy to read as a sequence of hex bytes in an array initializer, and it's definitely less work on each trip through the code.
+  
+  Fix By: Brad Spencer @b-spencer
+  PR: https://github.com/c-ares/c-ares/pull/193
+
+- [Brad Spencer brought this change]
+
+  Fix warnings emitted by MSVC when using -W4 (#192)
+  
+  These changes fix a few warnings emitted by recent versions of MSVC when compiling with -W4. Half of the changes are in Windows-specific code, and the other half should be safe no matter the compiler or OS.
+  
+  The allocation function change is probably the only one that needs explanation. MSVC gives warnings about the function pointers not being stable across DLL boundaries or something to that effect, so for Windows, I've made them be called indirectly, which at least made the compiler happy. I can't say I've tested every linking combination on Windows with them before or after the change, but it seems harmless.
+  
+  Fix By: Brad Spencer @b-spencer
+  PR: https://github.com/c-ares/c-ares/pull/192
+
+- [David Hotham brought this change]
+
+  Prevent changing name servers while queries are outstanding (#191)
+  
+  Changing name servers doesn't work, per #41.  Better to return an error code than to crash.
+  
+  Fix-by: David Hotham @dimbleby
+
+David Drysdale (15 May 2018)
+- [Tobias Nießen brought this change]
+
+  Fix comment in ares_rules.h (#189)
+
+Brad House (6 May 2018)
+- [Brad Spencer brought this change]
+
+  Harden and rationalize c-ares timeout computation (#187)
+  
+  * Harden and rationalize c-ares timeout computation
+  * Remove the rand() part of the timeout calculation completely.
+  
+  When c-ares sends a DNS query, it computes the timeout for that request as follows:
+  
+  timeplus = channel->timeout << (query->try_count / channel->nservers);
+  timeplus = (timeplus * (9 + (rand () & 7))) / 16;
+  I see two issues with this code. Firstly, when either try_count or channel->timeout are large enough, this can end up as an illegal shift.
+  
+  Secondly, the algorithm for adding the random timeout (added in 2009) is surprising. The original commit that introduced this algorithm says it was done to avoid a "packet storm". But, the algorithm appears to only reduce the timeout by an amount proportional to the scaled timeout's magnitude. It isn't clear to me that, for example, cutting a 30 second timeout almost in half to roughly 17 seconds is appropriate. Even with the default timeout of 5000 ms, this algorithm computes values between 2812 ms and 5000 ms, which is enough to cause a slightly latent DNS response to get spuriously dropped.
+  
+  If preventing the timers from all expiring at the same time really is desirable, then it seems better to extend the timeout by a small factor so that the application gets at least the timeout it asked for, and maybe a little more. In my experience, this is common practice for timeouts: applications expect that a timeout will happen at or after the designated time (but not before), allowing for delay in detecting and reporting the timeout. Furthermore, it seems like the timeout shouldn't be extended by very much (we don't want a 30 second timeout changing into a 45 second timeout, either).
+  
+  Consider also the documentation of channel->timeout in ares_init_options():
+  
+  The number of milliseconds each name server is given to respond to a query on the first try. (After the first try, the timeout algorithm becomes more complicated, but scales linearly with the value of timeout.) The default is five seconds.
+  
+  In the current implementation, even the first try does not use the value that the user supplies; it will use anywhere between 56% and 100% of that value.
+  
+  The attached patch attempts to address all of these concerns without trying to make the algorithm much more sophisticated. After performing a safe shift, this patch simply adds a small random timeout to the computed value of between 0 ms and 511 ms. I could see limiting the random amount to be no greater than a proportion of the configured magnitude, but I can't see scaling the random with the overall computed timeout. As far as I understand, the goal is just to schedule retries "not at the same exact time", so a small difference seems sufficient.
+  
+  UPDATE: randomization removed.
+  
+  Closes PR #187
+  Fix by: Brad Spencer
+
+- distribute ares_android.h
+  
+  Distribute ares_android.h when a release distribution package is
+  created.
+  
+  Reported By: Andrey Khranovsky
+  Bug: https://c-ares.haxx.se/mail/c-ares-archive-2018-04/0000.shtml
+
+- ares_set_servers_csv() on failure should not leave channel in a bad state
+  
+  If bad data is passed to ares_set_servers_csv() or
+  ares_set_servers_ports_csv() it will clear the existing channel
+  configured DNS servers, then a call to ares_send() will fail due
+  to a bad malloc which may have undefined behavior.
+  
+  The fix now only clears existing servers on success.  An additional
+  sanity check was added in ares_send() to ensure nservers >= 1 or
+  will result in ARES_ESERVFAIL.
+  
+  Bug: https://c-ares.haxx.se/mail/c-ares-archive-2018-03/0000.shtml
+  Reported-by: Francisco Sedano Crippa
+
+- docs: Not all manpages are listed
+  
+  Some docs aren't installed or not showing up on
+  https://c-ares.haxx.se/docs.html
+  due to not being listed in Makefile.inc.  Add missing docs and
+  ensure docs are alphabetized.
+
+Version 1.14.0 (16 Feb 2018)
+
+Daniel Stenberg (16 Feb 2018)
+- ares_android.c: fix warning: ISO C forbids an empty translation unit
+
+- RELEASE-NOTES: some more work we did and people who helped
+
+Brad House (16 Feb 2018)
+- travis: skip Autotools style testing for cmake
+  
+  Fix cmake test build by skipping autotools portion of test script.
+
+- travis: standardize CMake test off of Autotools tests
+  
+  Instead of running 'make test', run the tests directly like autotools
+  does.  It provides more verbose output.
+
+- travis: Enable building tests for CMake
+  
+  Travis should auto-build and run tests for cmake builds now that
+  PR #168 is merged.
+
+- fix version in pkgconfig
+
+- Add version update to CMakeLists in maketgz
+
+- Release prep.  Add support for pkgconfig in cmake, set versions appropriately
+
+Gregor Jasny (15 Feb 2018)
+- CMake: Add tests
+
+Brad House (14 Feb 2018)
+- [Gregor Jasny brought this change]
+
+  Use cmake3 package provided by Ubuntu (#182)
+
+- Cmake 3.1 instead of 3.2.1 should be the minimum
+
+- Update RELEASE-NOTES and RELEASE-PROCEDURE.md to prepare for next release
+
+- get rid of c++ style comments
+
+- Use trusty for all builds, precise is EOL.  Update clang and cmake versions.
+
+- Current CMakeLists.txt doesn't support 2.8.12 anymore, we need to bump the version to 3.2.1 minimum
+
+- Re-organize sections in INSTALL.md and add CMake section
+
+- [Sergey Kolomenkin brought this change]
+
+  remove compilation warnings in MSVC (#47)
+
+- document handling of timeouts for ares_process and ares_process_fd to close PR #57
+
+- As per Issue #155, since we do not require gethostname() during init, if it fails, there's no reason for init to fail as it is only used to populate the domain
+
+GitHub (7 Feb 2018)
+- [David Drysdale brought this change]
+
+  Document WSAStartup requirement (#180)
+
+David Drysdale (6 Feb 2018)
+- [Antonio Tajuelo brought this change]
+
+  Added coderelease.io badge to readme.md for letting people subscribe to new versions (#174)
+
+- [Sheel Bedi brought this change]
+
+  Update year in LICENSE.md to 2018 (#170)
+
+GitHub (4 Feb 2018)
+- [David Drysdale brought this change]
+
+  travis: use VM not container for {L,A}SAN builds (#177)
+  
+  As per https://github.com/travis-ci/travis-ci/issues/9033, container
+  based builds do not currently allow ptrace, which is used by LSAN and
+  ASAN.
+
+Brad House (3 Feb 2018)
+- [acthompson-google-com brought this change]
+
+  Android JNI code leaks local references in some cases (#175)
+  
+  * Add Google LLC to AUTHORS.
+  
+  * android: Explicitly delete all JNI local references, and cache JNI method IDs at initialization.
+  
+  * android: Only return ARES_ENOTINITIALIZED on failures in initialization code.
+
+Gregor Jasny (2 Jan 2018)
+- Embed fused Google Test 1.8.0
+
+Brad House (21 Dec 2017)
+- [John Schember brought this change]
+
+  android: Check returns for obj and classes are not NULL. Document API levels for various Android functions and objects used. (#166)
+
+- CARES_CHECK_TYPE should reference variable so a warning is not produced for -Werror compatibility
+
+- [Brad Spencer brought this change]
+
+  Fix computation of IPv6 blacklist mask for values of netmask > 8. (#164)
+
+David Drysdale (14 Dec 2017)
+- travis: Only do coverage/distcheck on normal build
+
+- travis: only do pip install on Linux
+
+- travis: only test in IPv4 mode
+  
+  Travis' Trusty environment does not support IPv6.
+
+- test: allow restriction to one IP address family
+
+- [Roman Teterin brought this change]
+
+  Fix a typo in init_by_resolv_conf (#160)
+
+Brad House (11 Dec 2017)
+- @gvanem says MSVC -RTCc option fails, looks erroneous to me, but the additional mask is harmless
+
+- Fix some other mingw warnings
+
+- Issue #143, get rid of windows build warning due to passing 'char **' to argument expecting 'const char **'
+
+- [Gregor Jasny brought this change]
+
+  Distribute CMake files (#130)
+
+- Android variants may not have __system_property_get
+  
+  Some android systems like ARM64 may not have the __system_property_get
+  symbol in libc (but still have it in the public headers).  Detect this
+  condition at build time.  The __system_property_get method of retrieving
+  name servers is deprecated as of Oreo so should strictly be a fallback
+  mechanism anyhow.
+
+David Drysdale (9 Nov 2017)
+- [David Hotham brought this change]
+
+  Wrong function name throughout man page (#154)
+
+- ares_data.c: iterate through substructs when freeing
+  
+  Previous code recursed into substructures, which makes it more likely
+  that large/heavily-nested responses could use up lots of stack.
+
+- test: test ares_free_data on long chain of structs
+
+- [Felix Yan brought this change]
+
+  Fix a typo in inet_ntop.c (#151)
+
+Daniel Stenberg (29 Sep 2017)
+- ares_gethostbyname.3: fix callback status values
+  
+  - ARES_ENOTFOUND means the _name_ wasn't found
+  
+  - ARES_ENODATA can be returned when a resolve fails
+  
+  Reported-by: Jakub Hrozek
+  Bug: https://c-ares.haxx.se/mail/c-ares-archive-2011-06/0012.shtml
+
+Brad House (28 Sep 2017)
+- [John Schember brought this change]
+
+  Fix DNS server lookup breaking with Android O due to Android removing access to net.dns# system properties. (#148)
+  
+  As of Android 8 (Oreo) access to net.dns# has been removed (https://developer.android.com/about/versions/oreo/android-8.0-changes.html). The reasoning given is that it, "improves privacy on the platform". Currently c-ares uses this to get the list of DNS servers.
+  
+  Now the only way to access the DNS server list is by using the Connectivity Manager though Java. This adds the necessary JNI code to use the Connectivity Manager and pull the DNS server list. The old way using __system_property_get with net.dns# remains for compatibilty.
+  
+  Using the Connectivity Manager requires the ACCESS_NETWORK_STATE permission to be set on the app. Existing applications most likely are not setting this and keeping the previous method as a fallback will at the very least ensure those apps don't break on older versions of Android. They will need to add this permission for Android 8 compatibility.
+  
+  Included in the patch are two initalization functions which are required. The JVM must be registered as well as the Connectivity Manager itself. There is no way to get the Connectivity Manager except though Java. Either being passed down to C directly or by passing in an Android Context which can be used to get the Connectivity Manager. Examples are provided in the documentation.
+
+- [Konstantinos Sofokleous brought this change]
+
+  allow linking against the static msvc runtime library (#133)
+  
+  allow linking against the static msvc runtime library
+
+- [Gergely Nagy brought this change]
+
+  Force using the ANSI versions of WinAPI functions (#142)
+  
+  When compiling c-ares with a build system that defines UNICODE,
+  bad versions of WinAPI functions are used causing failures or even
+  crashes. When windows.h is included in MBCS mode (like in the default
+  build system), the ..A versions are the same as using the one without
+  any suffix.
+
+- [cmake] build fix on Solaris
+
+GitHub (11 Sep 2017)
+- [Brad House brought this change]
+
+  Win32 exclude legacy ipv6 subnets (#144)
+  
+  win32 ipv6: add infrastructure to exclude ipv6 subnets that are known to cause issues
+
+- [David Drysdale brought this change]
+
+  windows: only look for ancient compilers (#146)
+  
+  Also drop the use of a versioned output directory; just use
+  .\msvc
+
+- [David Drysdale brought this change]
+
+  ares_init_options.3: match up sock_state_cb args (#141)
+  
+  Fixes #140
+
+Daniel Stenberg (25 Aug 2017)
+- [Anna Henningsen brought this change]
+
+  gethostbyaddr: fail with `ECANCELLED` for `ares_cancel()`
+  
+  When `ares_cancel()` was invoked, `ares_gethostbyaddr()`
+  queries would fail with `ENOTFOUND` instead of `ECANCELLED`.
+  
+  It seems appropriate to treat `ares_cancel()` like `ares_destroy()`,
+  but I would appreciate review of the correctness of this change.
+  
+  Ref: https://github.com/nodejs/node/issues/14814
+  
+  Closes #138
+
+David Drysdale (18 Aug 2017)
+- [David Hotham brought this change]
+
+  support most recent Visual Studio 2017
+
+Brad House (26 Jul 2017)
+- Preserve original DNS server order on Windows for equal metrics.
+  
+  qsort is not stable, in order to make it stable we need to record
+  the original index and add it as a secondary sort value when the
+  metrics are equal to prevent using DNS servers that may not work
+  at all as reported by some users.
+
+David Drysdale (15 Jul 2017)
+- [Anna Henningsen brought this change]
+
+  ares_parse_naptr_reply: make buffer length check more accurate
+  
+  9478908a490a6bf009ba58d81de8c1d06d50a117 introduced a length check
+  for records parsed by `ares_parse_naptr_reply()`. However, that
+  function is designed to parse replies which also contain non-NAPTR
+  records; for A records, the `rr_len > 7` check will fail as there
+  are only 4 bytes of payload.
+  In particular, parsing ANY replies for NAPTR records was broken
+  by that patch.
+  
+  Fix that by moving the check into the case in which it is already
+  known that the record is a NAPTR record.
+
+- appveyor: run dnsdump as a sanity check
+
+- travis: run dnsdump as a sanity check
+
+- test: use ares_free_string() throughout
+  
+  As pointed out by Gisle Vanem in #125.
+
+Daniel Stenberg (3 Jul 2017)
+- RELEASE-PROCEDURE.md: how to release
+  
+  Fixes #115
+  Closes #116
+
+David Drysdale (2 Jul 2017)
+- test: Build dnsdump on Windows too
+  
+  Thanks to Gisle Vanem for showing the way:
+  https://github.com/c-ares/c-ares/commit/b701af8a24cf9d173b1dbe5faedcea34642e92da#commitcomment-22830845
+
+Brad House (26 Jun 2017)
+- [Christian Ammer brought this change]
+
+  fix statement like #define - ares ssize_t define had a trailing semicolon (#120)
+
+David Drysdale (21 Jun 2017)
+- test: distribute the fuzzcheck.sh script
+  
+  The TESTS target runs fuzzcheck.sh so make sure it is included
+  in the distributed tarball.
+  
+  (The test itself will be pointless when run on a distribution, because
+  the fuzzing corpus directories are not shipped, but at least this
+  means that `make -C test test` should work.)
+
+- test: run the name-parsing corpus check too
+
+Daniel Stenberg (21 Jun 2017)
+- dist: don't build/ship PDF versions in release archives
+  
+  ... experience says very few read them and they can still get build by
+  those who want them.a
+
+- ares_version.h: bump version
+
+Version 1.13.0 (20 Jun 2017)
+
+Daniel Stenberg (20 Jun 2017)
+- RELEASE-NOTES: 1.13.0
+
+- ares_set_socket_functions.3: added in 1.13.0
+
+David Drysdale (18 Jun 2017)
+- ares_parse_naptr_reply: check sufficient data
+  
+  Check that there is enough data for the required elements
+  of an NAPTR record (2 int16, 3 bytes for string lengths)
+  before processing a record.
+
+- test: Feed in short NAPTR
+
+- test: Add fuzz input with short NAPTR
+
+- test: add ares_parse_naptr_reply to fuzzer
+
+- [noiz brought this change]
+
+  Update ares.h to support compiling with QNX
+
+- [Dionna Glaze brought this change]
+
+  Simple changes to appease stricter compilers.
+  
+  ares_process.c uses htonl, which needs <arpa/inet.h> included.
+  ares_getnameinfo.c uses a dynamically selected format string for
+  sprintf, which -Wformat-literal doesn't like. Usually one would use
+  inttypes.h and a format string "%" PRIu32, but C99 is too new for some
+  supported platforms.
+
+GitHub (16 Jun 2017)
+- [Gregor Jasny brought this change]
+
+  CMake: Emulate interface library on import (#108)
+  
+  Closes: #104
+  Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
+
+Brad House (6 Jun 2017)
+- [ChristianAmmer brought this change]
+
+  Added support for Windows DNS Suffix Search List (#93)
+  
+  This change solves issue #53.
+  
+  Support for suffix search lists was already built in for Linux. The search list could be set via set_search. With this change the suffix search list from Windows is read from the registry and then set into the ares configuration via set_search. There are two sources for the search list:
+  
+  The global DNS suffix search list.
+  The primary and connection specific DNS suffixes if the global is not available.
+  
+  Contributed by @ChristianAmmer
+
+Daniel Stenberg (25 May 2017)
+- [Thomas Köckerbauer brought this change]
+
+  configure: do not heck for ar if specified manually
+  
+  Closes #62
+
+David Drysdale (23 May 2017)
+- ares_expand_name: limit number of indirections
+
+- test: fuzz input file that takes a while to process
+
+- test: copy data in fuzz regression driver
+  
+  Oops.
+
+GitHub (23 May 2017)
+- [David Drysdale brought this change]
+
+  Convert char from ISO-8859-1 to UTF-8 (#99)
+  
+  Fixes #97
+
+- [Gregor Jasny brought this change]
+
+  travis: Use trusty for cmake builds (#109)
+  
+  kubuntu-backports dropped the CMake package for Precise
+
+David Drysdale (2 May 2017)
+- [David Hotham brought this change]
+
+  msvc_ver.inc support most recent Visual Studio 2017 (#101)
+
+- test: use io.h not unistd.h for Windows
+
+- test: try building fuzz binaries on Windows
+
+- test: stick to int in ares-fuzz.c
+  
+  Using int rather than ares_ssize_t means this file
+  needs no c-ares dependency - it's a general driver for
+  any libFuzzer-style entrypoint.
+
+- test: force ARES_OPT_NOROTATE for no-rotate tests
+
+- test: check expected NOROTATE value
+
+- ares_create_query: use ares_free not naked free
+  
+  Accidentally added in commit 65c71be1cbe5
+  ("ares_create_query: avoid single-byte buffer overwrite")
+
+Brad House (17 Mar 2017)
+- Need ares.h for ares_ssize_t
+
+- tests should not use ssize_t, use ares_ssize_t
+
+GitHub (16 Mar 2017)
+- [Brad House brought this change]
+
+  Portability updates for legacy systems. (#92)
+  
+  Socklen_t should not be used in code, instead ares_socklen_t should be used.
+  Convert ssize_t to ares_ssize_t for portability since the public API now exposes this.
+
+David Drysdale (14 Mar 2017)
+- [Michael Osei brought this change]
+
+  Update msvc_ver.inc (#91)
+  
+  For Visual Studio 2017 builds
+
+Daniel Stenberg (13 Mar 2017)
+- [Brad House brought this change]
+
+  Windows DNS server sorting (#81)
+  
+  Original Patch From Brad Spencer:
+  https://c-ares.haxx.se/mail/c-ares-archive-2016-04/0000.shtml
+  
+  My modifications include:
+   * Dynamically find GetBestRoute2 since it is a Windows Vista+ symbol, and will fall back to prior behavior when not available.
+   * Prefer get_DNS_AdaptersAddresses as the modifications should alleviate the concerns which caused us to prefer get_DNS_NetworkParams
+   * Update AppVeyor to use MinGW-w64 instead of the legacy MinGW
+   * Fix compile error in test suite for Windows.
+  
+  Original message from patch below:
+  
+  From: Brad Spencer <bspencer@blackberry.com>
+  Date: Fri, 29 Apr 2016 14:26:23 -0300
+  
+  On Windows, the c-ares DNS resolver tries first to get a full list of
+  DNS server addresses by enumerating the system's IPv4/v6 interfaces and
+  then getting the per-interface DNS server lists from those interfaces
+  and joining them together. The OS, at least in the way the c-ares
+  prefers to query them (which also may be the only or best way in some
+  environments), does not provide a unified list of DNS servers ordered
+  according to "current network conditions". Currently, c-ares will then
+  try to use them in whatever order the nested enumeration produces, which
+  may result in DNS requests being sent to servers on one interface
+  (hosting the current default route, for example) that are only intended
+  to be used via another interface (intended to be used when the first
+  interface is not available, for example). This, in turn, can lead to
+  spurious failures and timeouts simply because of the server address
+  order that resulted because of the enumeration process.
+  
+  This patch makes the (safe?) assumption that there is no other better
+  rule to chose which interface's DNS server list should be prioritized.
+  After all, a DNS lookup isn't something "per network"; applications
+  don't look up "these DNS names on this interface and those DNS names on
+  that interface". There is a single resource pool of DNS servers and the
+  application should presume that any server will give it the "right"
+  answer. However, even if all DNS servers are assumed to give equally
+  useful responses, it is reasonable to expect that some DNS servers will
+  not accept requests on all interfaces. This patch avoids the problem by
+  sorting the DNS server addresses using the Windows IPv4/v6 routing tables.
+  
+  For example, a request to DNS server C on interface 2 that is actually
+  sent over interface 1 (which may happen to have the default route) may
+  be rejected by or not delivered to DNS server C. So, better to use DNS
+  servers A and B associated with interface 1, at least as a first try.
+  
+  By using the metric of the route to the DNS server itself as a proxy for
+  priority of the DNS server in the list, this patch is able to adapt
+  dynamically to changes in the interface list, the DNS server lists per
+  interface, which interfaces are active, the routing table, and so on,
+  while always picking a good "best" DNS server first.
+  
+  In cases where any DNS server on any interface will do, this patch still
+  seems useful because it will prioritize a lower-metric route's (and thus
+  interface's) servers.
+
+David Drysdale (22 Feb 2017)
+- [Sergii Pylypenko brought this change]
+
+  docs: fixed references to ares_set_local_ip4 and ares_set_local_ip6
+
+- [Calle Wilund brought this change]
+
+  ares test: fix win32 build errors with virtual socket function tests
+  
+  The added api requires both some typedefs not previously imported
+  into the test build + the test code did not fully deal with
+  socket differences on windows.
+
+- [Calle Wilund brought this change]
+
+  ares_process: fix return type of socket_create function (win32 warning)
+
+Daniel Stenberg (31 Jan 2017)
+- [Calle Wilund brought this change]
+
+  ares_set_socket_functions: Add man page
+  
+  Providing some rudimentary documentation for the added functionality
+  
+  Closes #72
+
+- [Calle Wilund brought this change]
+
+  ares-test: Add test helpers and cases for virtual socket IO
+  
+  * Added test case macro to automatically run tests twice, once "normal",
+    once with virtual IO.
+  * Changed most "live" query tests to run in dual mode to verify
+    at least simple socket IO via virtual functions
+  * Added test case for settings/duping socket functions & callback data
+
+- [elcallio brought this change]
+
+  Implement using virtual socket IO functions when set
+  
+  Uses virtual socket IO functions when set on a channel.
+  Note that no socket options are set, nor is any binding
+  done by the library in this case, since the client defining
+  these is probably more suited to deal with this.
+
+- [elcallio brought this change]
+
+  Add virtual function set for socket IO
+  
+  Defines a structure of basic create, close, read/write
+  functions as virtual function calls, settable for individual
+  c-ares channels.
+
+David Drysdale (30 Jan 2017)
+- test: ignore aresfuzzname binary
+
+Gregor Jasny (14 Jan 2017)
+- [Stephen Sorley brought this change]
+
+  Always use check_symbol_exists instead of check_function_exists.
+
+- Also add includes to TARGETS_INST_DEST
+
+- [Stephen Sorley brought this change]
+
+  Windows build fixes
+
+- CMake: Export targets
+
+- CMake: Use GNUInstallDirs for install location defaults
+
+David Drysdale (11 Jan 2017)
+- Update Makefile.am for renamed INSTALL.md
+
+GitHub (11 Jan 2017)
+- [David Drysdale brought this change]
+
+  docs: convert INSTALL to MarkDown & tweak (#83)
+
+- [Gregor Jasny brought this change]
+
+  Merge pull request #77 from stephen-sorley/cmake_modernize
+  
+  Updated CMake minimum version to 2.8.12.
+
+Stephen Sorley (4 Jan 2017)
+- Changed executables to depend directly on internal libcares target, instead of against
+  the external-facing alias targets.
+
+- Updated Travis to pull CMake 2.8.12 from kubuntu-backports ppa.
+
+- Updated CMake minimum version to 2.8.12.
+  
+  Changed the way usage requirements (include dirs, compile defs, dependent libraries) are specified, to match the recommended standard practice for modern CMake. This involves using target-specific functions (target_include_directories, target_compile_definitions, etc.), along with the PUBLIC, PRIVATE or INTERFACE modifiers.
+  
+  Updated chain-building support to imitate new-style Find modules (import libs), instead of old-style Find modules (cache variables).
+
+David Drysdale (26 Dec 2016)
+- [Chris Araman brought this change]
+
+  configure: clock_gettime workaround (#75)
+  
+  Commits 7518c26, c41726b, and bc14ee7 brought this workaround to the CMake build system. This expands it to the autoconf build system.
+  
+  Fixes #71
+
+- test: add fuzz entrypoint for ares_create_query()
+
+- test: Add gTest/gMock files to SOURCES
+  
+  Built tarballs are not including all of the files needed
+  to build the test suite because they are missing from the
+  <target>_SOURCES variable in Makefile.am.
+
+- travis: Move build scripts under travis/
+  
+  Travis doesn't always propagate errors in inline multi-line
+  scripts, so move them all to be explicit shell scripts, each
+  with set -e.
+
+- travis: check distributed tarball builds
+
+Daniel Stenberg (25 Oct 2016)
+- dist: ship msvc_ver.inc too
+  
+  Reported-by: Bruce Stephens
+  
+  Fixes #69
+
+- [Aaron Bieber brought this change]
+
+  fix build on OpenBSD
+
+- ares_version.h: bump, working on 1.12.1 now
+
+GitHub (18 Oct 2016)
+- [Gregor Jasny brought this change]
+
+  Merge pull request #64 from bradh352/master
+  
+  Add CMake build system support to C-Ares.
+
+Brad House (5 Oct 2016)
+- suggested PROJECT_NAME change broke chain building as it needs the magic PROJECT_NAME set in the ADD_LIBRARY for matching. Fix to make both goals work
+
+- update MacOSX 10.12 detection
+
+- Expand XCode clock_gettime fix to include MacOS 10.12, not just iOS10
+
+David Drysdale (4 Oct 2016)
+- Revert "travis: work around bug in PyCParser"
+  
+  This reverts commit a24a10a348fc00b8cfd684d91894a1df14880ea9.
+
+- travis: work around bug in PyCParser
+  
+  See https://github.com/pyca/cryptography/issues/3187
+
+Brad House (3 Oct 2016)
+- PROJECT_SOURCE_DIR instead of CMAKE_CURRENT_SOURCE_DIR as per @gjasny
+
+- use a project name of c-ares as per @gjasny
+
+- Import curl conversion of Makefile.inc to cmake form dynamically as per bdoetsch@ameritech.net to make maintaining multiple build systems easier
+
+Daniel Stenberg (30 Sep 2016)
+- dist: add ares_library_initialized.* to the tarball
+
+David Drysdale (30 Sep 2016)
+- test: check ares_create_query with too-long name
+
+Daniel Stenberg (30 Sep 2016)
+- man pages: minor formatting edits
+
+Brad House (29 Sep 2016)
+- merge fc7917e from @daviddrysdale ... travis build updates for cmake
+
+- cleanups as per @gjasny ... Use naked IF statements and use NOT DEFINED
+
+Version 1.12.0 (29 Sep 2016)
+
+Daniel Stenberg (29 Sep 2016)
+- RELEASE-NOTES: 1.12.0
+
+- [David Drysdale brought this change]
+
+  ares-test-misc: test ares_create_query with escaped trailing dot
+
+- ares_create_query: avoid single-byte buffer overwrite
+  
+  ... when the name ends with an escaped dot.
+  
+  CVE-2016-5180
+  
+  Bug: https://c-ares.haxx.se/adv_20160929.html
+
+Brad House (29 Sep 2016)
+- CMake: Unify library versioning with the libtool methodology to make keeping library versions in sync easier with the autotools build system
+
+Daniel Stenberg (29 Sep 2016)
+- ares_library_initialized.3: added
+
+- make: bump CARES_VERSION_INFO for release
+
+David Drysdale (29 Sep 2016)
+- man: update ares_init_options.3
+
+Daniel Stenberg (29 Sep 2016)
+- ares_library_init.3: corrected the ares_library_init_mem proto
+
+Brad House (28 Sep 2016)
+- XCode v8 introduced clock_gettime() for iOS v10.  However, it is a weak symbol, which means when earlier iOS versions try to use clock_gettime() it results in a crash due to the missing symbol.  Detect this condition and do not set HAVE_CLOCK_GETTIME_MONOTONIC.
+
+- Adds cmake build system support to C-Ares.
+  
+  The patch does not modify any source files, it only adds 3 new files
+  (CMakelists.txt, ares_build.h.cmake, ares_config.h.cmake) which form the
+  build system.  I've tried to go through as much of the autotools tests and
+  extracted what I thought was appropriate, though many of the tests aren't
+  as in-depth in CMake as they are for autotools ... it is unclear why some
+  of them exist at all, I'm guessing for legacy systems that CMake probably
+  doesn't support anyhow.
+  
+  Building the library, and examples (adig, ahost, acountry) plus installation
+  should work across a large number of tested platforms.  The tests have not
+  yet been integrated.
+
+Daniel Stenberg (27 Sep 2016)
+- README.md: remove space from link
+
+- README: link to the correct c-ares badge!
+  
+  Reported-by: David Hotham
+  
+  Fixes #63
+
+- docs: minor formatting edits
+
+- ares_destroy.3: formatting polish
+
+- ares_init.3: split the init docs into two separate man pages
+
+- SECURITY: point to the vulnerabilities page now
+
+- RELEASE-NOTES: synced with daa7235b1a5
+
+- ares_create_query.3: edit language
+  
+  Tried to make the man page more readable.
+
+David Drysdale (26 Sep 2016)
+- test: fix gMock to work with gcc >= 6.x
+  
+  Taken from:
+  https://github.com/google/googletest/issues/705#issuecomment-235067917
+
+Daniel Stenberg (26 Sep 2016)
+- [Brad House brought this change]
+
+  headers: remove checks for and defines of variable sizes
+  
+  ... they're not really used and by avoiding them in the ares_build.h
+  output we make the public header less dependent on data sizes.
+
+David Drysdale (24 Sep 2016)
+- api: add ARES_OPT_NOROTATE optmask value
+  
+  Fix up a couple of problems with configuring whether c-ares rotates
+  between different name servers between requests.
+  
+  Firstly, ares_save_options() returns (in *optmask) the value of
+  (channel->optmask & ARES_OPT_ROTATE), which doesn't necessarily
+  indicate whether the channel is or is not actually doing rotation.
+  This can be confusing/incorrect if:
+   - the channel was originally configured without ARES_OPT_ROTATE
+     (so it appears that the channel is not rotating)
+   - the /etc/resolv.conf file includes the 'rotate' option
+     (so the channel is actually performing rotation).
+  
+  Secondly, it is not possible to reliably configure a channel
+  to not-rotate; leaving off ARES_OPT_ROTATE is not enough, since
+  a 'rotate' option in /etc/resolv.conf will turn it on again.
+  
+  Therefore:
+   - add an ARES_OPT_NOROTATE optmask value to allow explicit
+     configuration of no-rotate behaviour
+   - in ares_save_options(), report the value of channel->rotate
+     as exactly one of (optmask & ARES_OPT_ROTATE) or
+     (optmask & ARES_OPT_NOROTATE).
+  
+  In terms of back-compatibility:
+   - existing apps that set ARES_OPT_ROTATE will continue to rotate,
+     and to have ARES_OPT_ROTATE reported back from ares_save_options()
+   - existing apps that don't set ARES_OPT_ROTATE will continue to
+     use local config/defaults to decide whether to rotate, and will
+     now get ARES_OPT_ROTATE or ARES_OPT_NOROTATE reported back from
+     ares_save_options() rather than 0.
+
+- ares_init_options: only propagate init failures from options
+  
+  Commit 46bb820be3a8 ("ares_init_options: don't lose init failure")
+  changed init behaviour so that earlier errors in initialization
+  weren't lost.  In particular, if the user passes in specific
+  options but they are not applied (e.g. because of an allocation
+  failure), that failure needs to be reported back to the user; this
+  also applies when duplicating a channel with ares_dup().
+  
+  However, other initialization failures can be ignored and
+  overridden -- in particular, if init_by_resolv_conf() or
+  init_by_environment() fail, then falling back to default values
+  is OK.
+  
+  So only preserve failures from the init_by_options() stage, not
+  from all initialization stages.
+  
+  Fixes issue 60.
+
+- test: Force reinstall of libtool on OSX
+  
+  Travis build environment appears to have changed.
+
+- test: Add valgrind build variant
+
+- test: Add null pointer to gtest args
+  
+  GoogleTest assumes that there is a null pointer in argv[argc],
+  so make it look like that. Without this change, tests run with
+  command-line arguments get memory errors under valgrind/ASAN.
+
+Daniel Stenberg (21 Aug 2016)
+- AUTHOR: maybe gitgub isn't really an author =)
+
+- AUTHORS: added contributors from the git log
+
+- LICENSE.md: add a stand-alone license file
+  
+  Just the MIT license used in the top the source files moved out to a
+  stand-alone file for easier reference and discovery.
+
+- README: added "CII best practices" badge
+
+- SECURITY.md: suggested "security process" for the project
+
+David Drysdale (17 Aug 2016)
+- test: Add Clang static analysis build to Travis
+  
+  Run scan-build over the library source code, but skip the
+  tests.  Needs a later Clang install in Travis
+
+- test: more info on how to run fuzz testing
+
+- test: make fuzzer driver code C not C++
+
+- test: fuzzer mode for AFL's persistent mode
+  
+  When fuzzing with AFL, if the LLVM-based instrumentation is
+  used (via the afl-clang-fast wrapper), then it is possible to
+  have a single execution of the fuzzer program iterate multiple
+  times over the fuzzing entrypoint (similar to libFuzzer's normal
+  mode of execution) with different data.  This is much (e.g. 10x)
+  faster.
+  
+  Add code to support this, by checking whether __AFL_LOOP is
+  defined at compile-time.
+  
+  Also, shift the code to effectively be C rather than C++.
+
+- test: simplify deps for fuzzer entrypoint
+  
+  No need to depend on the rest of the test code (ares-test.h) for
+  the fuzzer entrypoint; this makes the entrypoint slightly simpler
+  to build with LLVM's libFuzzer.
+  
+  Also shift the code to effectively be C rather than C++
+
+- test: disable MinGW tests
+  
+  The test binary built in the MinGW build is failing for some
+  reason.  It works for me when I build locally, so I'm guessing
+  it's down to some sort of AppVeyor environment issue.
+  
+  Disable for now.
+
+Daniel Stenberg (16 Aug 2016)
+- read_tcp_data: remove superfluous NULL check
+  
+  CID 56884 by Coverity. The pointer is already derefenced before this
+  point so it can't be NULL here anyway.
+
+- web: http => https
+
+GitHub (20 Jul 2016)
+- [David Drysdale brought this change]
+
+  Merge pull request #59 from fuze/master
+  
+  Update msvc_ver.inc for VS2015 Update 3
+
+- [Chris Araman brought this change]
+
+  Update msvc_ver.inc
+  
+  support Visual Studio 2015 Update 3
+
+David Drysdale (2 May 2016)
+- Fix trailing comment for #endif
+
+Daniel Stenberg (30 Apr 2016)
+- email: use Gisle's "new" address
+
+David Drysdale (18 Apr 2016)
+- test: drop superfluous fuzz inputs
+  
+  Where there are multiple fuzz input files that only differ in
+  the first two bytes (the query ID), just keep the first such
+  file.
+
+svante karlsson (15 Apr 2016)
+- Update msvc_ver.inc
+  
+  support Visual Studio 2015 Update 2
+
+David Drysdale (31 Mar 2016)
+- test: Run fuzzcheck.sh in Travis build
+
+- test: add fuzzing check script to tests
+  
+  Add a test script that runs the fuzzing command over the
+  corpus of DNS packets.  This doesn't actually do any fuzzing
+  (it just runs them as inputs without generating any variations)
+  but it does ensure that the fuzzing entrypoint is still working.
+
+- test: allow multiple files in aresfuzz command line
+  
+  If no arguments are specified, use stdin as input.
+  Otherwise treat each argument as a filename and feed
+  its contents to the fuzz entrypoint.
+
+- test: Add corpus of DNS packets
+  
+  For fuzz testing it is useful to start from a corpus of valid
+  packets, so fill out the test/fuzzinput/ directory with a bunch
+  of inputs.
+  
+  These packets were generated by temporarily modifying the c-ares
+  process_answer() function to save off any incoming response messages.
+
+- test: Add utility to show DNS packet from file
+
+- [nordsturm brought this change]
+
+  Fix nsort initialization
+  
+  Author: Alexander Drachevskiy
+  http://c-ares.haxx.se/mail/c-ares-archive-2014-07/0004.shtml
+  http://c-ares.haxx.se/mail/c-ares-archive-2014-07/0014.shtml
+
+- test: Check setting nsort=0 option is respected
+
+- test: Update fuzzing function prototype
+  
+  libFuzzer changed expected return type from void to int
+  in LLVM 3.8.
+
+- Explicitly clear struct servent before use
+  
+  On a build where MSAN has been manually set up (which involves
+  using an MSAN-instrumented version of the standard C++ library, see
+  https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo)
+  there's a warning about use of uninitialized memory here.  It
+  might be a false positive, but the fix is trivial so include it.
+
+- test: for AF_UNSPEC, return CNAME only for AAAA, but valid A record
+  
+  Also shuffle expected responses rsp6/rsp4 into the order they will occur.
+
+- [Chris Araman brought this change]
+
+  msvc_ver.inc: support Visual Studio 2015 Update 1
+
+- build: commonize MSVC version detection
+  
+  Remove the need to copy/paste version number mapping between
+  Makefile.msvc and test/Makefile.msvc.
+
+- test: Use different name in live test
+
+- test: Only pass unused args to GoogleTest
+
+- ahost.c: add cast to fix C++ compile
+  
+  If ahost.c is force-compiled as C++ the missing cast from
+  (void *) to (char **) is problematic.
+
+- ares_library_cleanup: reset ares_realloc too
+  
+  Otherwise a subsequent use of the library might use a previous
+  incarnation's realloc() implementation.
+
+Daniel Stenberg (9 Mar 2016)
+- [Brad House brought this change]
+
+  configure: check if tests can get built before enabled
+  
+  The current approach for disabling tests is not a good solution because
+  it forces you to pass --disable-tests, rather than auto-detect if your
+  system can support the tests in the first place.  Many (most?) systems
+  do not have C++11.  This also causes issues when chain-building c-ares,
+  the hosting system needs to be updated to support passing this
+  additional flag if necessary, it doesn't seem reasonable to add this
+  requirement which breaks compatibility.
+  
+  This change auto-detects if the system can build the tests and
+  automatically disable them if it cannot.  If you pass --enable-tests to
+  configure and the system cannot build them either due to lack of system
+  support, or because cross-compilation is being used, it will throw an
+  appropriate error since the user indicated they really did want the
+  tests.
+
+David Drysdale (3 Mar 2016)
+- [Viktor Szakats brought this change]
+
+  Makefile.m32: add support for CROSSPREFIX
+
+- [Viktor Szakats brought this change]
+
+  Makefile.m32: add support for extra flags
+  
+  Allow specification of CARES_{LD,C}FLAG_EXTRAS envvars
+  for mingw
+
+- test: Build with MinGW on AppVeyor
+
+- test: avoid in6addr_* constants
+  
+  These aren't available on MinGW, so use explicit addresses instead.
+
+- test: add missing #includes for dns-proto.cc
+
+- [Gregor Jasny brought this change]
+
+  Fix man page typos detected by Lintian
+
+Daniel Stenberg (19 Feb 2016)
+- configure: acknowledge --disable-tests
+  
+  Fixes #44
+
+- AUTHORS: added contributors from the 1.11.0 release
+
+- bump: start working on the next version
+
+Version 1.11.0 (19 Feb 2016)
+
+Daniel Stenberg (19 Feb 2016)
+- RELEASE-NOTES: final edits for 1.11.0
+
+David Drysdale (15 Feb 2016)
+- ares_dup.3: remove mention of nonexistent function
+  
+  ares_dup_options() doesn't exist, so don't document it.
+
+- test: skip repeated build steps
+  
+  Top-level buildconf/configure now triggers for the
+  test/ subdir too, so don't need to do explicitly.
+
+- test: namespaces unavailable when cross-compiling
+
+Daniel Stenberg (13 Feb 2016)
+- configure: only run configure in test when NOT cross-compiling
+  
+  ... as the tests won't run cross-compiled anyway
+
+David Drysdale (13 Feb 2016)
+- test: prefer ON_CALL to EXPECT_CALL to reduce flakes
+  
+  For UDP tests, there's a chance of a retry.  EXPECT_CALL only
+  expects a single request to arrive at the server; ON_CALL allows
+  for a UDP retry and repeats the same answer.
+  
+  Note that ON_CALL and EXPECT_CALL can't be mixed in the same
+  test, and that tests that have a varied sequence of responses
+  for the same repeated request still have to use EXPECT_CALL.
+
+Daniel Stenberg (13 Feb 2016)
+- configure: run configure in 'test' too
+  
+  Having the test dir completely stand-alone causes too many issues for
+  users and devs. It still needs to be built specifically.
+
+- configure: build silently by default
+
+- buildconf: run test/buildconf too if present
+
+- test/configure: build silently by default
+
+- [Gregor Jasny brought this change]
+
+  dist: Distribute README.md
+  
+  Closes #42
+
+Version 1.11.0 (11 Feb 2016)
+
+Daniel Stenberg (11 Feb 2016)
+- Makefile.am: distribute the test dir too
+
+- RELEASE-NOTES: synced with 385582bd14b68a
+
+- [Nicolas \"Pixel\" Noble brought this change]
+
+  ares_win32_init: make LoadLibrary work when using UNICODE too
+  
+  Closes #17
+
+David Drysdale (11 Feb 2016)
+- Use "resolve" as synonym of "dns" in nsswitch.conf
+  
+  Modern Linux systems may have libnss_resolve from systemd as the
+  resolver, which is then configured in /etc/nsswitch.conf with
+  the "resolve" keyword rather than "dns".
+  
+  Fixes #33
+
+- ares_set_socket_callback: make manpage match code
+  
+  The code in ares_process.c that invokes the socket creation/connection
+  callback only checks for rc < 0, not for standard ares error codes.
+
+- Merge pull request #36 from AGWA-forks/master
+  
+  Add ares_set_socket_configure_callback()
+
+- test: Update init tests to match behaviour
+  
+  Unreadable config files are now treated the same way
+  as absent config files.
+
+- [Fedor Indutny brought this change]
+
+  Ignore `fopen` errors to use default values
+  
+  After 46bb820be3a83520e70e6c5f0c5133253fcd69cd `init_by_resolv_conf`
+  errors are no longer swallowed in `ares_init_options`. This has exposed
+  a previously unknown bug in `lookups` initialization code.
+  
+  If there is no lookup configuration in `resolv.conf`,
+  `init_by_resolv_conf` will attempt to read it from other files available
+  on the system. However, some of these files may have restricted
+  permissions (like `600`), which will lead to `EACCESS` errno, which in
+  turn is handled like a fatal error by `init_by_resolv_conf`.
+  
+  However, it sounds illogical that this error should be handled as a
+  fatal. There is a `init_by_defaults` call that overrides `lookups` with
+  default value, and certainly possible absence of lookup information is
+  the reason why this function exists in a first place!
+  
+  I suggest handling any `fopen` errors as non-fatal ones, allowing to
+  pick up the `lookups` value from different config files, or to pick up
+  default value.
+
+Andrew Ayer (9 Feb 2016)
+- Document callback type in man page for ares_set_socket_callback
+
+- Add ares_set_socket_configure_callback()
+  
+  This function sets a callback that is invoked after the socket is
+  created, but before the connection is established.  This is an ideal
+  time to customize various socket options.
+
+David Drysdale (9 Feb 2016)
+- test: ares_set_socket_callback failure behaviour
+
+- test: Check ares_parse_txt_reply_ext() entrypoint
+
+- [Fedor Indutny brought this change]
+
+  txt: introduce `ares_parse_txt_reply_ext`
+  
+  Introduce `ares_txt_ext` structure with an extra `record_start`
+  field, which indicates a start of a new TXT record, thus allowing to
+  differentiate the chunks in the same record, from a chunks in a
+  different record.
+  
+  Introduce a new API method: `ares_parse_txt_reply_ext` that works with
+  this kind of struct.
+
+- doc: Update missed repo references
+
+- doc: Update docs on contributing
+
+- test: Run command line tools in Travis
+  
+  Do a quick execution of each of the command line tools
+  in the continuous integration build, so that any (say)
+  sanitizer failures show up.
+
+- acountry: drop inert test
+  
+  If ver_1 is true, then z0 and z1 must both be 'z', and so
+  (z0 != 'z' && z1 != 'z') can never be true.
+  
+  CID 56879, pointed out by Coverity.
+
+- doc: update badge locations to master repo
+
+- test: Enable maintainer mode + debug in Travis
+
+- test: Add an iOS build target
+
+- test: Ignore SIGPIPE in tests
+
+- test: More initialization tests
+
+- test: Improve containerized test mechanism
+  
+  Aim is to ensure that code coverage information can escape the
+  container.  To do this:
+   - Enter a new mount namespace too, so that we can...
+   - Bind mount the expected source directory into the container
+   - Share memory with the sub-process so coverage information is
+     shared too.
+
+- test: Make contained tests easier to write
+
+- test: Add framework for containerized testing
+  
+  On Linux we can potentially use user and UTS namespaces to run  a test
+  in a pseudo-container with:
+   - arbitrary filesystem (e.g. /etc/resolv.conf, /etc/nsswitch.conf, /etc/hosts)
+   - arbitrary hostname/domainname.
+  
+  Include a first pass at the framework code to allow this, along with a
+  first test case that uses the container.
+
+- test: Use a longer timeout for less flakiness
+  
+  Having occasional test failures from timeout before multiple
+  queries can complete, so up the default timeout for the test
+  from 100ms to 1500ms.
+
+- test: Make failure tests more robust
+  
+  Different platforms will do different numbers of allocations
+  in the processing of a given API call; just check that the
+  return code is either success or ENOMEM, and free off any
+  returned state in the former case.
+  
+  Also cope with ECONNREFUSED as well as ENOTFOUND.
+
+- test: Get test code building under Windows
+  
+   - Initial nmake file based off library nmake file
+   - Cast socket call arguments to (char *)
+   - Use wrapper sclose() that maps to closesocket() or close()
+   - Build a config.h indicating presence of headers
+   - Conditionally include netdb.h
+   - Remove unnecessary include of sys/socket.h
+   - Force longer bitmask for allocation failure tracking
+   - Call WSAStartup() / WSACleanup() in main()
+   - Set TCP_NODELAY for mock server
+   - Turn on tests in AppVeyor build
+
+- test: Disable tests that manipulate env on Windows
+
+- test: Move file lists into Makefile.inc
+  
+  In preparation for a Win32 build of the test suite.
+
+- test: Add a simple multi-server test
+  
+  Check rotate option does something
+
+- test: Allow for multiple mock servers
+  
+   - Update the MockServer to allow separate specification of
+     UDP and TCP ports
+   - Have an array of mock servers listening on consecutive
+     sets of ports.
+   - Rename Process(fd) to ProcessFD(fd) to avoid confusion.
+   - Initialize channel by using the new ares_set_servers_ports()
+     entrypoint, so multiple ports on the same loopback address
+     can be used.
+
+- test: Update test for set/get_servers variants
+  
+  Ports are significant in the _ports_ variant functions, so update test to cope.
+
+- test: Make GetNameServers() utility function port-aware
+  
+  Also make it generally available.
+
+- test: more testing, including of internal static functions
+
+- test: more tests, especially fallback processing
+  
+   - Make mock server listen on UDP + TCP in parallel.
+   - Test UDP->TCP fallback on truncation
+   - Test EDNS->no-EDNS fallback
+   - Test some environment init options
+   - Test nonsense reply
+  
+  test: short response
+
+- test: more tests, particularly of initialization
+
+- test: Run mock tests over both TCP and UDP
+  
+  With the exception of a few tests that make use of the timed
+  retry aspect of UDP.
+
+- test: Run mock tests over both IPv4 and IPv6
+
+- test: Add more tests for edge cases
+
+- test: more nooks and crannies of pton functions
+
+- test: More tests for PTR parsing
+
+- test: Use of HOSTALIAS environment variable
+
+- test: Add RAII utility classes for testing
+  
+   - TempFile holds specific contents
+   - EnvValue sets an environment variable
+
+- test: More search domain scenarios
+
+- test: Remove duplicate flags from Makefile.am
+
+- test: Make test code leak-free
+
+- test: More tests
+  
+   - test use of sortlist
+   - test gethostbyname(AF_UNSPEC)
+
+- test: Test ares_gethostbyname_file()
+
+- test: Add more tests of ares_getnameinfo()
+
+- test: Tweak tests, add alloc failure test
+
+- test: Test init with options
+
+- test: More tests
+  
+   - ares_inet_net_pton() variants
+   - ares_getsock() variants
+
+- test: Expose ProcessWork() function
+
+- test: More parsing tests
+  
+  Including:
+   - Split each parse function test set out into separate files.
+   - Add an allocation failure test for each parsing function.
+   - Add error check test for each parsing function.
+
+- test: Add various additional tests
+
+- test: More tests
+  
+  Include tests of internal functions, based on the value of the
+  CARES_SYMBOL_HIDING macro; need to configure the library with
+  --disable-symbol-hiding to enable these tests.
+
+- test: Allow command line override of mock server port
+
+- test: Add README.md documentation
+
+- test: Temporarily avoid latest Python requests package
+  
+  Currently get error from Travis on this install step, and downgrading one
+  version appears to fix the problem.
+  
+  "Could not find any downloads that satisfy the requirement pyOpenSSL>=0.13
+  (from requests[security])"
+
+- test: Add AppVeyor config file for Windows build
+
+- test: Add configuration for a Travis build
+  
+  Cover Linux & OSX on the container infrastructure, but install
+  a later G++ to satisfy the tests' need for C++11.
+  
+  Use a build matrix to include a variety of build variants:
+   - ASAN
+   - UBSAN
+   - LSAN
+   - Coverage via coveralls.io
+  
+  test: invoke ASAN and coverage in Travis build
+  
+  Also shift to use explicit build matrix
+  
+  test: Use coveralls.io for coverage tracking
+  
+  test: Add a build with UBSAN
+  
+  Also expand and re-order the setting of environment variables
+  for easier modification.
+  
+  test: Add LSAN build to Travis config
+
+- test: Add initial unit tests for c-ares library
+  
+  The tests are written in C++11, using the GoogleTest and GoogleMock
+  frameworks.  They have their own independent autoconf setup, so that
+  users of the library need not have a C++ compiler just to get c-ares
+  working (however, the test/configure.ac file does assume the use of
+  a shared top-level m4/ directory).  However, this autoconf setup has
+  only been tested on Linux and OSX so far.
+  
+  Run with "./arestest", or "./arestest -v" to see extra debug info.
+  The GoogleTest options for running specific tests are also
+  available (e.g. "./arestest --gtest_filter=*Live*").
+  
+  The tests are nowhere near complete yet (currently hitting around
+  60% coverage as reported by gcov), but they do include examples
+  of a few different styles of testing:
+  
+   - There are live tests (ares-test-live.cc), which assume that the
+     current machine has a valid DNS setup and connection to the
+     internet; these tests issue queries for real domains but don't
+     particularly check what gets returned.  The tests will fail on
+     an offline machine.
+  
+   - There a few mock tests (ares-test-mock.cc) that set up a fake DNS
+     server and inject its port into the c-ares library configuration.
+     These tests allow specific response messages to be crafted and
+     injected, and so are likely to be used for many more tests in
+     future.
+  
+      - To make this generation/injection easier, the dns-proto.h file
+        includes C++ helper classes for building DNS packets.
+  
+   - Other library entrypoints that don't require network activity
+     (e.g. ares_parse_*_reply) are tested directly.
+  
+   - There are few tests of library-internal functions that are not
+     normally visible to API users (in ares-test-internal.cc).
+  
+   - A couple of the tests use a helper method of the test fixture to
+     inject memory allocation failures, using the earlier change to the
+     library to allow override of malloc/realloc/free.
+  
+   - There is also an entrypoint to allow Clang's libfuzzer to drive
+     the packet parsing code in ares_parse_*_reply, together with a
+     standalone wrapper for it (./aresfuzz) to allow use of afl-fuzz
+     for further fuzz testing.
+
+- test: Add local copy of GoogleMock/GoogleTest 1.7.0
+  
+  Don't check in gtest/m4 files, as they are unused and interfere
+  with the top-level configure process.
+
+- doc: Show build badges in README.md
+  
+  Note that these URLs will need to be updated if/when the test branch
+  gets pulled into the master repo/branch.
+
+- doc: Convert README to README.md
+  
+  Gives better display on GitHub
+
+- doc: Update in preparation for next release
+  
+  Assume 1.11.0 is next (as there are various API additions).
+  Also add myself to AUTHORS.
+
+- build: Allow header compilation by Windows C++ compiler
+
+- build: Expose whether symbol hiding is on
+  
+  Adding the CARES_SYMBOL_HIDING definition allows the test suite to
+  detect whether internal symbols are available or not.
+
+- build: Add autoconf macros for C++11 code using pthreads
+  
+  Pull in testing macros from the GNU autoconf archive to allow
+  configure scripts to test for and setup use of a C++11 compiler
+  (AX_CXX_COMPILE_STDCXX_11) and the pthreads library (AX_PTHREAD).
+  
+  Note that these macros are not used by the main library autoconf,
+  just by the tests (which share the same m4/ directory).
+
+- build: Add a code coverage option
+  
+  Configure with:
+    ./configure --enable-code-coverage
+  Show coverage output with:
+    make code-coverage-capture
+  
+  Built on m4/ax_code_coverage.m4 from the GNU autoconf archive
+  to provide the macros to check for presence of gcov + lcov;
+  upstream macro modified to:
+   - Remove use of $(AM_DEFAULT_VERBOSITY) , as earlier versions of
+     autoconf (such as the one used by default on Travis) do not have this.
+   - Rather than automatically defining CODE_COVERAGE_RULES to be a set
+     of makefile rules that use ifeq/endif (which is GNU make-specific),
+     instead only define CODE_COVERAGE_RULES if coverages is turned on,
+     and in that case don't use conditionals in the makefile.
+
+- api: Add entrypoints to allow use of per-server ports
+  
+  Add user-visible entrypoints ares_{get,set}_servers_ports(3), which
+  take struct ares_addr_port_node rather than struct ares_addr_node.
+  This structure includes a UDP and TCP port number; if this is set
+  to zero, the channel-wide port values are used as before.
+  
+  Similarly, add a new ares_set_servers_ports_csv(3) entrypoint, which
+  is analogous to ares_set_servers(3) except it doesn't ignore any
+  specified port information; instead, any per-server specified port
+  is used as both the UDP and TCP port for that server.
+  
+  The internal struct ares_addr is extended to hold the UDP/TCP ports,
+  stored in network order, with the convention that a value of zero
+  indicates that the channel-wide UDP/TCP port should be used.
+  
+  For the internal implementation of ares_dup(3), shift to use the
+  _ports() version of the get/set functions, so port information is
+  transferred correctly to the new channel.
+  
+  Update manpages, and add missing ares_set_servers_csv to the lists
+  while we're at it
+
+- api: Add ares_set_sortlist(3) entrypoint
+  
+  Allow explicit configuration of the channel's sortlist, by
+  specifying a string in the same format as the equivalent
+  /etc/resolv.conf option.
+  
+  This allows library users to perform the same configuration
+  that is available via /etc/resolv.conf, but without needing
+  to change that file.
+
+- api: Allow injection of user-specified malloc/free functions
+  
+  Add a new ares_library_init_mem() initialization function for the
+  library which allows the library user to specify their own malloc,
+  realloc & free equivalents for use library-wide.
+  
+  Store these function pointers in library-wide global variables,
+  defaulting to libc's malloc(), realloc() and free().
+  
+  Change all calls to malloc, realloc and free to use the function pointer
+  instead.  Also ensure that ares_strdup() is always available
+  (even if the local environment includes strdup(3)), and change the
+  library code to always use it.
+  
+  Convert calls to calloc() to use ares_malloc() + memset
+
+- api: Add option to expose some internal functions
+  
+  Purely for testing, add --enable-expose-statics option to configure
+  which converts some static internal functions to be externally visible.
+
+- api: Expose the ares_library_initialized() function
+
+- ahost: Allow repeated -s <domain> options
+  
+  This also removes a potential leak where later -s options would
+  replace earlier ones without freeing the relevant string.
+
+- Mark unhittable lines
+  
+  Add comments for the benefit of the lcov tool, marking
+  lines that cannot be hit.  Typically these are fall-back
+  protection arms that are already covered by earlier checks,
+  and so it's not worth taking out the unhittable code (in case
+  someone changes the code between the two places in future).
+
+- ares_set_servers_csv.3: make return type match code
+
+- bitncmp: update comment to match code behaviour
+
+- ares_striendstr: fix so non-NULL return can happen
+  
+  This looks to have been broken since it was first introduced in 2005 in
+  commit aba0b775ea30 ("Added ares_getnameinfo which mimics the
+  getnameinfo API")
+
+- config_sortlist: free any existing sortlist on (re)alloc failure
+  
+  If we get an allocation failure on 2nd or later entry in the sortlist, the
+  code would return ENOMEM but still leave the initial entries allocated.
+  Ensure that *sortlist is set to NULL whenever ENOMEM is returned.
+
+- ares_dup: clear new channel on failure
+  
+  If the attempt to transfer IPv6 servers from the old to the new channel
+  fails, the previous code would still return a channel to the user even though
+  an error return code was generated.  This makes it likely that users would
+  leak the channel, so explicitly clear the channel in this case.
+
+- ares_init_options: don't lose init failure
+  
+  If (say) init_by_options() fails, the subsequent call to
+  init_by_defaults() was overwriting the return code with
+  success.  Still call init_by_defaults() regardless, but track
+  its return value separately
+
+- ares_gethostbyname: don't leak valid-but-empty hostent
+  
+  If an AF_UNSPEC query gets a valid response to its AAAA query,
+  but which has no IPv6 addresses in it, then the code chains on to
+  a A record query.  However, the hostent from the AAAA response
+  was being leaked along the way (because it gets replaced before
+  the follow-on end_hquery() invocation).
+
+- ares_parse_txt_reply: propagate errors from per-substring loop
+  
+  If we get an allocation failure when processing a particular substring in a
+  TXT record, that failure is silently lost; fix that by propagating errors from
+  the inner loop to the outer loop.
+
+- process_answer: fix things up correctly when removing EDNS option
+  
+  When a server rejects an EDNS-equipped request, we retry without
+  the EDNS option.  However, in TCP mode, the 2-byte length prefix was
+  being calculated wrong -- it was built from the answer length rather than
+  the length of the original request.
+  
+  Also, it is theoretically possible that the call to realloc() might change
+  the data pointed to; to allow for this, qbuf also needs updating.
+  
+  (Both these fixes were actually included in a patchset sent on the mailing
+  list in Oct 2012, but were included with other functional changes that
+  didn't get merged:
+  http://c-ares.haxx.se/mail/c-ares-archive-2012-10/0004.shtml)
+
+- ares__read_line: clear buf pointer on realloc failure
+
+- ares_expand_name: check for valid bits in label length
+  
+  The top two bits of the label length indicate whether this is a
+  label length (00) or an index to a name elsewhere in the message
+  (11).  RFC1035 4.1.4 says that the other possible values for the
+  top two bits (01, 10) are reserved for future use.
+
+Daniel Stenberg (23 Jan 2016)
+- [Gregor Jasny brought this change]
+
+  Fix typos detected by lintian
+  
+  Closes #32
+
+- [Gregor Jasny brought this change]
+
+  Distribute all man pages
+
+- README.cares: s/I/Daniel
+  
+  ... and add a pointer to an existing version of the original area 1.1.1
+  package.a
+
+- read_tcp_data: don't try to use NULL pointer after malloc failure
+  
+  CID 56884, pointed out by Coverity. We really should make this function
+  return an error code so that a malloc() failure can return back a major
+  failure.
+
+- configure_socket: explicitly ignore return code
+  
+  CID 56889 in Coverity pointed out the return code from setsocknonblock()
+  is ignored, and this added typecast to (void) makes it explicit.
+
+- ahost: check the select() return code
+  
+  Fixes CID 137189, pointed out by Coverity
+
+David Drysdale (18 Jan 2016)
+- Fix buildconf on platforms using glibtoolize
+  
+  Commit c49a87eea538 changed buildconf to only check for
+  libtoolize, but missed a line
+
+- Don't exit loop early leaving uninitialized entries
+  
+  Update for commit affc63cba875d.
+  
+  The original patch from Gregor Jasny did not have the break
+  statement; I incorrectly added it to prevent continuing the loop.
+  However, the later entries in the array would then be left
+  uninitialized, causing problems for later cleanup.
+  
+  So fix to match Gregor's original patch, with apologies.
+
+Daniel Stenberg (18 Jan 2016)
+- buildconf: remove check for libtool, it only requires libtoolize
+
+David Drysdale (17 Jan 2016)
+- [Gregor Jasny brought this change]
+
+  Use libresolv to initialize cares on iPhone targets
+  
+  On iPhone targets like iOS, watchOS or tvOS the file
+  /etc/resolv.conf cannot be used to configure cares.
+  
+  Instead the resolver library is queried for configuration
+  values.
+  
+  CC: Yury Kirpichev <ykirpichev@yandex-team.ru>
+
+Daniel Stenberg (17 Jan 2016)
+- README: updated to new repo URL
+
+David Drysdale (14 Jan 2016)
+- [Lei Shi brought this change]
+
+  Fixing slow DNS lookup issue
+  
+  This patch is fixing the dns lookup issue due to dummy dns information
+  of a disconnected adapter(in my case is a bluetooth adapter). I changed
+  the dns lookup policy to try GetNetworkParams first because the
+  GetNetworkParams provides the most reliable dns information (lots of
+  checks were done by system). I also filter out inoperable adapter in
+  DNS_AdaptersAddresses in case GetNetworkParams fail.
+
+- Merge pull request #30 from p-push/vs-2015
+  
+  Support Visual Studio 2015
+
+Oleg Pudeyev (3 Jan 2016)
+- [Gisle Vanem brought this change]
+
+  Support Visual Studio 2015
+
+David Drysdale (11 Nov 2015)
+- [Andrew Andkjar brought this change]
+
+  added another version case to Makefile.msvc
+  
+  nmake version 11.00.61030.0 resolves to CC_VERS_NUM = 110
+
+- Merge pull request #26 from bitbouncer/vs-2013
+  
+  added define for visual studio 2013
+
+svante karlsson (25 Jun 2015)
+- added define for visual studio 2013
+
+Jakub Hrozek (6 Nov 2014)
+- ares__read_line: free buf on realloc failure
+
+- Destroy options if ares_save_options fails
+  
+  It's possible that, if ares_save_options failed, the opts structure
+  would contain some allocated memory. Calling ares_destroy_options in
+  this case is safe, because ares_save_options zeroes out the memory
+  initially.
+
+- [David Drysdale brought this change]
+
+  Continue loop if space for hostname not large enough
+  
+  When attempting to build a search domain from the local hostname
+  (used as a fallback when no other methods have given a search
+  domain), the code doubles the buffer size on each loop iteration.
+  
+  However, the loop previously had a WHILE_FALSE terminator so the continue
+  statement exited the loop rather than going round again.
+
+Daniel Stenberg (30 Oct 2014)
+- ares_getnameinfo.3: there is no ares_getaddrinfo
+
+David Drysdale (30 Sep 2014)
+- [Gregor Jasny brought this change]
+
+  Prevent tmpbuf from overrunning
+  
+  Fix Coverity error CID 56886.
+  
+  Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
+
+- [Gregor Jasny brought this change]
+
+  Re-start loop if select fails
+  
+  Fix Coverity error CID 56882
+  
+  Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
+
+- [Gregor Jasny brought this change]
+
+  Free temporary variable in error path
+  
+  Fix Coverity CID 56890
+  
+  Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
+
+- [Gregor Jasny brought this change]
+
+  Fix integer shift overflow if both tcp_socket and udp_socket are set
+  
+  The problem occurs if at the start of the loop the sockindex is at the
+  last valid ARES_GETSOCK_MAXNUM position. If then both udp_socket and
+  tcp_socket are valid, sockindex gets incremented for UDP first and
+  points one entry behind the array for the tcp block.
+  So the fix is to check after every increment of sockindex if it is still
+  valid.
+  
+  Fix Coverity error CID 56878
+  
+  Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
+
+- [Gregor Jasny brought this change]
+
+  Null check before dereference
+  
+  Fix Coverity error CID 56880
+  
+  Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
+
+Jakub Hrozek (28 Jul 2014)
+- [Gisle Vanem brought this change]
+
+  Comment in ares_ipv6.h
+
+David Drysdale (25 Jul 2014)
+- CONTRIBUTING: add file to indicate mailing list is preferred
+
+- Add -t u option to ahost
+  
+  Add an option to allow specification of the AF_UNSPEC
+  address family.
+
+Jakub Hrozek (24 Jul 2014)
+- host_callback: Fall back to AF_INET on searching with AF_UNSPEC
+  
+  Previously, when an ares_gethostbyname() searched with AF_UNSPEC and the
+  first AF_INET6 call only returned CNAMEs, the host_callback never
+  retried AF_INET.
+  
+  This patch makes sure than on ARES_SUCCESS, the result of AF_INET6 is
+  taken as authoritative only if the result contains some addresses.
+
+- [David Drysdale brought this change]
+
+  Move memset call below platform-specific declarations
+  
+  A GitHub commenter [1] says that my recent change to ahost.c has
+  problems compiling on Windows + C89 platforms.
+  
+  [1]  https://github.com/bagder/c-ares/commit/ee22246507c9#commitcomment-6587616
+
+- [David Drysdale brought this change]
+
+  Update ahost man page to describe -s option.
+  
+  Commit ee22246507c9 added the -s <domain> option to the
+  ahost command, but neglected to update the man page to
+  describe it.
+  
+  Also fix typo in description of -t option.
+
+- ares_parse_soa_reply: Do not leak rr_name on allocation failure
+  
+  If ares_malloc_data failed, already allocated rr_name would go out of
+  scope.
+
+- [David Drysdale brought this change]
+
+  Don't override explicitly specified search domains
+  
+  Only set search domains from /etc/resolv.conf if there isn't a value
+  already present in the channel.
+
+- [David Drysdale brought this change]
+
+  Allow specification of search domain in ahost
+  
+  Add the "-s domain" command line option to override the search
+  domains.
+
+Daniel Stenberg (12 May 2014)
+- Revert "ares_parse_aaaa_reply: fix leak when reply contains 1 alias and no address"
+  
+  This reverts commit 440110b303fdbfadb3ad53d30eeb98cc45d70451.
+
+- [Frederic Germain brought this change]
+
+  ares_parse_aaaa_reply: fix leak when reply contains 1 alias and no address
+
+- [Doug Kwan brought this change]
+
+  ares_build.h: fix building on 64-bit powerpc
+  
+  There are two issues.
+  
+  1. gcc actually does not use __ppc__ and __ppc64__ but __PPC__ and
+  __PPC64__.  The tests of __ILP32__ and __LP64__ are sufficient for gcc.
+  
+  2. clang defines __GNU__ and defines both __ppc64__ and __ppc__ when
+  targeting ppc64.  This makes CARES_SIZEOF_LONG to be 4 on a ppc64 system
+  when building with clang.
+  
+  My patch is two change the order of the checks so that we check the
+  64-bit case first.
+
+- refresh: updated now with automake 1.14
+
+- [David Drysdale brought this change]
+
+  single_domain: Invalid memory access for empty string input
+  
+  We noticed a small buglet in ares_search() when it gets an empty string
+  as input -- the single_domain() utility function in ares_search.c
+  accesses invalid memory (before the start of the string).
+
+Guenter Knauf (31 Aug 2013)
+- Fixed warning 'type specifier missing'.
+
+Daniel Stenberg (30 Aug 2013)
+- [Tor Arntsen brought this change]
+
+  ares_rules.h: CARES_SIZEOF_LONG doesn't exist anymore, don't test for it
+  
+  It was removed in f19387dd72432
+
+- nowarn: use <limits.h> instead of configure for size of long
+  
+  This makes the header file much more multi-arch friendly and can be used
+  as-is with both 32 bit and 64 bit builds.
+
+- timeoffset: made static and private
+  
+  ares__timeoffset() was only used once within this single source file
+
+- timeadd: make static
+  
+  ares__timeadd() was only ever used from within the same source
+
+Yang Tse (18 Jul 2013)
+- xc-am-iface.m4: comments refinement
+
+- configure: fix 'subdir-objects' distclean related issue
+  
+  See XC_AMEND_DISTCLEAN comments for details.
+
+- configure: automake 1.14 compatibility tweak (use XC_AUTOMAKE)
+
+- xc-am-iface.m4: provide XC_AUTOMAKE macro
+
+Daniel Stenberg (12 May 2013)
+- gitignore: ignore all ares_*pdf but also CHANGES.dist
+
+- bump: start working towards 1.10.1
+
+Version 1.10.0 (12 May 2013)
+
+Daniel Stenberg (12 May 2013)
+- RELEASE-NOTES: two more bug fixes
+
+- [Keith Shaw brought this change]
+
+  ares_set_servers_csv: fixed IPv6 address parsing
+  
+  Fixed bug that caused the last part of an IPv6 address to be parsed as
+  the port number when the last part is all numeric.
+
+- nroff: fix two syntax mistakes
+  
+  ares_parse_a_reply and ares_parse_aaaa_reply both had two \fB instead of
+  \fP
+  
+  Reported-by: Alexander Klauer
+  Bug: http://c-ares.haxx.se/mail/c-ares-archive-2013-03/0010.shtml
+
+- [Alex Loukissas brought this change]
+
+  build: fix build on msvc11
+
+- Makefile.am: increment -version-info for 1.10.0 release
+
+- README: remove unnecessary comment
+
+- ares_version.h: copyright end range year is now 2013
+
+- RELEASE-NOTES: synced with fb0737f3a0a1c37
+
+- [Paul Saab brought this change]
+
+  ares_parse_aaaa_reply: Plug memory leak
+  
+  This change is similar to ares_parse_a_reply.c in commit
+  bffd67f16a8f42fe6dbf79ab2e39d92eea05c8a6
+
+- [Patrick Valsecchi brought this change]
+
+  ares_parse_txt_reply: return a ares_txt_reply node for each sub-string
+  
+  Previously, the function would wrongly return all substrings merged into
+  one.
+
+- [Alexander Klauer brought this change]
+
+  library init: documentation update
+  
+  This commit updates the documentation of ares_library_init() and
+  ares_library_cleanup() with regard to the newly introduced reference
+  counting of initializations and deinitializations.
+
+- [Alexander Klauer brought this change]
+
+  library init: be recursive
+  
+  Previously, a single call to ares_library_cleanup() would deinitialise
+  the c-ares library, regardless of how many times ares_library_init() was
+  called. This behaviour may cause problems in programs linking two or
+  more libraries which, in turn, use c-ares. The present commit fixes this
+  problem, deinitializing the library only after a number of calls to
+  ares_library_cleanup() matching the number of calls to
+  ares_library_init().
+
+- [Patrick Valsecchi brought this change]
+
+  protocol parsing: check input data stricter
+  
+  ... so that bad length fields aren't blindly accepted
+  
+  Bug: http://c-ares.haxx.se/mail/c-ares-archive-2013-04/0016.shtml
+
+Guenter Knauf (11 Apr 2013)
+- Create ares_build.h when buidling from Git.
+
+- Added -DCARES_STATICLIB to CFLAGS.
+  
+  Currently this static makefile does only support building the
+  static library libcares.a.
+
+Daniel Stenberg (8 Apr 2013)
+- [Alexander Klauer brought this change]
+
+  .gitignore: ignore patch files
+  
+  This commit adds a line to .gitignore to the effect that patch files
+  generated by 'git format-patch' are excluded from the repository.
+
+- [Alexander Klauer brought this change]
+
+  ares_destroy() documentation: no new requests
+  
+  Clarify that no new requests may be added to a resolver channel that is
+  currently being destroyed.
+
+- [Alexander Klauer brought this change]
+
+  Documentation: properly document ARES_ECANCELLED
+  
+  This commit clarifies the behaviour of ares_cancel() with respect to
+  callbacks and adds missing documentation of ARES_ECANCELLED to the man
+  pages of the affected functions.
+
+- [Alexander Klauer brought this change]
+
+  ares_cancel(): cancel requests safely
+  
+  An invocation of ares_cancel() walks through the request list, calling
+  the callbacks of all pending requests on a channel. Previously, if such
+  a callback added a new request to the channel, the request list might
+  not end up empty, causing an abort by assertion failure. The present
+  commit ensures that precisely all requests present upon entry of
+  ares_cancel() are cancelled, and that adding new requests through
+  callbacks is safe.
+
+Yang Tse (10 Mar 2013)
+- ares.h: stricter CARES_EXTERN linkage decorations logic
+  
+  No API change involved.
+
+- ares_build.h.dist: enhance non-configure GCC ABI detection logic
+  
+  GCC specific adjustments:
+  
+  - check __ILP32__ before 32 and 64bit processor architectures in
+    order to detect ILP32 programming model on 64 bit processors
+    which, of course, also support LP64 programming model, when using
+    gcc 4.7 or newer.
+  
+  - keep 32bit processor architecture checks in order to support gcc
+    versions older than 4.7 which don't define __ILP32__
+  
+  - check __LP64__ for gcc 3.3 and newer, while keeping 64bit processor
+    architecture checks for older versions which don't define __LP64__
+
+Daniel Stenberg (9 Mar 2013)
+- ares.h: there is no ares_free_soa function
+
+Yang Tse (9 Mar 2013)
+- Makefile.am: empty AM_LDFLAGS definition for automake 1.7 compatibility
+
+- ares_inet_ntop.3: s/socklen_t/ares_socklen_t
+
+- configure: use XC_LIBTOOL for portability across libtool versions
+
+- xc-lt-iface.m4: provide XC_LIBTOOL macro
+
+- Makefile.am: use AM_CPPFLAGS instead of INCLUDES
+
+- inet_ntop.c: s/socklen_t/ares_socklen_t
+
+- inet_ntop.c: s/socklen_t/ares_socklen_t for portability
+
+Daniel Stenberg (19 Feb 2013)
+- ares.h: s/socklen_t/ares_socklen_t for portability
+
+- ares_inet_ntop.3: 4th argument is socklen_t!
+
+- spell inet correctly!
+
+- ares_inet_pton/ntop: cleanup
+  
+  Make sure that the symbols are always exported and present in c-ares.
+  
+  Make the headers prefixed with 'ares'.
+  
+  Removed the inet_ntop.h version as it no longer features any content.
+
+- ares_inet_ntop/ares_inet_pton: added man pages
+
+Yang Tse (15 Feb 2013)
+- [Gisle Vanem brought this change]
+
+  curl_setup_once.h: definition of HAVE_CLOSE_S defines sclose() to close_s()
+
+- [Gisle Vanem brought this change]
+
+  config-dos.h: define HAVE_CLOSE_S for MSDOS/Watt-32
+
+- [Gisle Vanem brought this change]
+
+  config-dos.h: define strerror() to strerror_s_() for High-C
+
+Daniel Stenberg (13 Feb 2013)
+- ares_get_datatype: removed unused function
+  
+  it was also wrongly named as internal functions require two underscores
+
+- ares__bitncmp: use two underscores for private functions
+  
+  It used a single one previously making it look like a public one
+
+- ares__generate_new_id: moved to ares_query.c
+  
+  ... and ares__rc4 is turned into a local static function.
+
+- ares__swap_lists: make private and static
+  
+  ... since there's only one user, make it static within ares_process.c
+
+Yang Tse (13 Feb 2013)
+- Makefile.msvc: add four VS version strings
+
+Daniel Stenberg (13 Feb 2013)
+- ares_expand_name.3: clarify how to free the data
+
+Yang Tse (30 Jan 2013)
+- zz40-xc-ovr.m4: fix 'wc' detection - follow-up 2
+  
+  - Fix a pair of single quotes to double quotes.
+  
+  URL: http://curl.haxx.se/mail/lib-2013-01/0355.html
+  Reported by: Tor Arntsen
+
+- zz40-xc-ovr.m4: fix 'wc' detection - follow-up
+  
+  - Take into account that 'wc' may return leading spaces and/or tabs.
+  
+  - Set initial IFS to space, tab and newline.
+
+- zz40-xc-ovr.m4: fix 'wc' detection
+  
+  - Take into account that 'wc' may return leading spaces.
+  
+  - Set internationalization behavior variables.
+  
+  Tor Arntsen analyzed and reported the issue.
+  
+  URL: http://curl.haxx.se/mail/lib-2013-01/0351.html
+
+- zz40-xc-ovr.m4: check another three basic utilities
+
+- zz40-xc-ovr.m4: 1.0 interface stabilization
+  
+  - Stabilization results in 4 public interface m4 macros:
+    XC_CONFIGURE_PREAMBLE
+    XC_CONFIGURE_PREAMBLE_VER_MAJOR
+    XC_CONFIGURE_PREAMBLE_VER_MINOR
+    XC_CHECK_PATH_SEPARATOR
+  - Avoid one level of internal indirection
+  - Update comments
+  - Drop XC_OVR_ZZ40 macro
+
+- zz40-xc-ovr.m4: emit witness message in configure BODY
+  
+  This avoids witness message in output when running configure --help,
+  while sending the message to config.log for other configure runs.
+
+- zz40-xc-ovr.m4: truly do version conditional overriding
+  
+  - version conditional overriding
+  - catch unexpanded XC macros
+  - fix double words in comments
+
+- zz40-xc-ovr.m4: fix variable assignment of subshell output bashism
+  
+  Tor Arntsen analyzed and reported the issue.
+  
+  URL: http://curl.haxx.se/mail/lib-2013-01/0306.html
+
+- zz40-xc-ovr.m4: reinstate strict AC_REQUIRE macro dependencies
+
+- zz40-xc-ovr.m4: avoid double single-quote usage
+
+- zz40-xc-ovr.m4: parentheses balancing of 'case' statements
+  
+  m4 quadrigraph shell comment technique allows proper autoconf
+  parentheses balancing in shell 'case' statements. The presence
+  of unbalanced parentheses may otherwise trigger expansion bugs.
+
+- zz40-xc-ovr.m4: internals overhauling
+  
+  - Update comments
+  - Execute commands in subshells
+  - Faster path separator check
+  - Fix missing 'test' command
+  - Rename private macros
+  - Minimize AC_REQUIRE usage
+
+- zz40-xc-ovr.m4: redirect errors and warnings to stderr
+
+- configure: use XC_CONFIGURE_PREAMBLE early checks
+  
+  Some basic checks we make were placed early enough in generated
+  configure script when using autoconf 2.5X versions. Newer autoconf
+  versions expand these checks much further into the configure script,
+  rendering them useless. Using XC_CONFIGURE_PREAMBLE fixes placement
+  of early intended checks across all our autoconf supported versions.
+
+- zz40-xc-ovr.m4: provide XC_CONFIGURE_PREAMBLE macro
+
+- configure: autotools compatibility fixes - step I
+  
+  Fix proper macro expansion order across autotools versions for
+  C compiler and preprocessor program checks.
+
+- configure: fix automake 1.13 compatibility
+  
+  Tested with:
+  
+  buildconf: autoconf version 2.69
+  buildconf: autom4te version 2.69
+  buildconf: autoheader version 2.69
+  buildconf: automake version 1.13.1
+  buildconf: aclocal version 1.13.1
+  buildconf: libtool version 2.4
+  buildconf: GNU m4 version 1.4.16
+
+- ares_private.h: use again memdebug.h instead of curl_memdebug.h
+
+- configure.ac: replace AM_CONFIG_HEADER with AC_CONFIG_HEADERS
+  
+  automake 1.13 errors if AM_CONFIG_HEADER is used in configure script.
+
+- cares-override.m4: provide AC_CONFIG_MACRO_DIR definition conditionally
+  
+  Provide a 'traceable' AC_CONFIG_MACRO_DIR definition only when using
+  an autoconf version that does not provide it, instead of what we were
+  doing up to now of providing and overriding AC_CONFIG_MACRO_DIR for
+  all autoconf versions.
+
+- ares_private.h: use curl_memdebug.h instead of memdebug.h
+
+- vc6cares.dsp: add ares_create_query.c and ares_parse_soa_reply.c
+
+- cares-functions.m4: improve gethostname arg 2 data type check
+
+- setup_once.h: HP-UX specific 'bool', 'false' and 'true' definitions.
+  
+  Also reverts commit bceb40095a
+
+- configure: check if compiler halts on function prototype mismatch
+
+- cares-functions.m4: add gethostname arg 2 data type check and definition
+
+- cares-functions.m4: update thread-safeness detection of getaddrinfo()
+  
+  Take in account that POSIX standard Issue 7 drops h_errno support. Now, we also
+  consider getaddrinfo() to be thread-safe when (_POSIX_C_SOURCE >= 200809L) or
+  (_XOPEN_SOURCE >= 700) independently of whether h_errno exists or not.
+  
+  Take in account that h_errno might be a modifiable lvalue not defined as
+  a C preprocessor macro.
+
+- setup_once.h: HP-UX <sys/socket.h> issue workaround
+  
+  Issue: When building a 32bit target with large file support HP-UX
+  <sys/socket.h> header file may simultaneously provide two different
+  sets of declarations for sendfile and sendpath functions, one with
+  static and another with external linkage. Given that we do not use
+  mentioned functions we really don't care which linkage is the
+  appropriate one, but on the other hand, the double declaration emmits
+  warnings when using the HP-UX compiler and errors when using modern
+  gcc versions resulting in fatal compilation errors.
+  
+  Mentioned issue is now fixed as long as we don't use sendfile nor
+  sendpath functions.
+
+- setup_once.h: refactor inclusion of <unistd.h> and <sys/socket.h>
+  
+  Inclusion of these two header files now done in setup_once.h
+
+- Header inclusion clean-up
+  
+  Remove header inclusions already done in setup_once.h
+
+- setup_once.h: HP-UX specific TRUE and FALSE definitions
+  
+  Some HP-UX system headers require TRUE defined to 1 and FALSE to 0.
+
+- ares_timeout.c: fix compiler warning
+
+- ares_create_query.c: IRIX compilation fix
+
+- c-ares/nameser.h: add some T_* defines for ns_t_* values
+
+Daniel Stenberg (7 Nov 2012)
+- Revert "ares_parse_aaaa_reply: fix memory leak"
+  
+  This reverts commit 50f25d8a4b2d16f4c5e0ef620238688b7a315c7a.
+
+- ares_parse_aaaa_reply: fix memory leak
+  
+  an allocated buffer was not freed in the successful case.
+
+- [Gisle Vanem brought this change]
+
+  adig: perror() doesn't work for socket errors on windows
+  
+  ... so print the SOCKERRNO instead
+
+- get_DNS_AdaptersAddresses: fix IPv6 parsing
+  
+  Use of the wrong define made the function not parse IPv6 addresses
+  properly.
+  
+  Bug: http://c-ares.haxx.se/mail/c-ares-archive-2012-06/0028.shtml
+  Reported by: Saúl Ibarra Corretgé
+
+- version: bumped to 1.10.0
+  
+  Due to the newly added function: ares_create_query()
+
+- AUTHORS: synced with 83093ac450
+  
+  Added 21 authors since this document was last updated
+
+- ares_create_query.3: mention when this is added
+
+- [hpopescu@ixiacom.com brought this change]
+
+  Added new feature (rfc2671)
+
+- code police: fix indents, < 80 columns, reflowed comments
+
+Guenter Knauf (11 Jul 2012)
+- Cleaned up version awk script.
+
+Daniel Stenberg (30 Jun 2012)
+- [Gisle Vanem brought this change]
+
+  read_udp_packets: bail out loop on bad sockets
+  
+  I can see that recvfrom() in ares_process.c many times is called with
+  'udp_socket' == ARES_SOCKET_BAD. The code takes care not to call
+  recv/recvfrom with ARES_SOCKET_BAD in the outer-loop. So should the
+  inner-loop.
+
+Yang Tse (29 Jun 2012)
+- cares-compilers.m4: remove -Wstrict-aliasing=3 from clang
+  
+  Currently it is unknown if there is any version of clang that
+  actually supports -Wstrict-aliasing. What is known is that there
+  are several that don't support it.
+
+- cares-compilers.m4: -Wstrict-aliasing=3 for warning enabled gcc and clang builds
+
+Daniel Stenberg (18 Jun 2012)
+- version: work towards 1.9.2 (at least)
+
+Version 1.9.1 (18 Jun 2012)
+
+Daniel Stenberg (18 Jun 2012)
+- RELEASE-NOTES: 1.9.1 coming up
+
+Version 1.9.0 (16 Jun 2012)
+
+Daniel Stenberg (16 Jun 2012)
+- ares_version.h: next version is 1.9.0
+
+- [Marko Kreen brought this change]
+
+  ares_data.h: ARES_DATATYPE_SOA_REPLY is added in 1.9.0
+
+- RELEASE-NOTES: synced with 979bf951d
+  
+  Next release deemed to become 1.9.0 due to the new function
+
+- [Marko Kreen brought this change]
+
+  SOA parser added
+  
+  I need to do SOA queries, so here is a parser for them.
+  
+  - ares_soa_reply: new struct
+  - ares_malloc_data/ares_free_soa: ARES_DATATYPE_SOA_REPLY
+  - ares_parse_soa_reply: actual function
+
+Yang Tse (14 Jun 2012)
+- Kill compiler warning
+
+- Fix libcares.pc generation for static MingW* cross builds
+
+Daniel Stenberg (21 May 2012)
+- [Nick Alcock brought this change]
+
+  Fix UDP and TCP port byte order in saved options.
+  
+  The UDP and TCP port are stored in network byte order in the
+  ares_channeldata, but are passed in to ares_init_options() in host byte
+  order.  Thus we must return them from ares_save_options() in host byte
+  order too, or a duplicated channel will convert them again, leading to a
+  nonfunctional channel and a mysterious connection refused error from
+  ares_gethostbyname().  This breaks ares_dup(), thus the curl easy API
+  when c-ares is used by curl, and thus all the curl easy API's users.
+
+Yang Tse (28 Apr 2012)
+- version: start working on 1.8.1-DEV
+
+Version 1.8.0 (27 Apr 2012)
+
+Daniel Stenberg (27 Apr 2012)
+- RELEASE-NOTES: call next 1.8 instead
+  
+  Since we added a function, let's use a stricter bumping scheme
+
+Yang Tse (25 Apr 2012)
+- INSTALL: some adjustments
+
+Daniel Stenberg (25 Apr 2012)
+- GIT-INFO: mention buildconf
+
+Yang Tse (25 Apr 2012)
+- INSTALL: remove more sections that don't apply to c-ares
+
+- ares_timeout.c: fix compiler warning
+
+Daniel Stenberg (25 Apr 2012)
+- [Ben Noordhuis brought this change]
+
+  Makefile.m32: fix mingw32 build
+  
+  * add . to include path so ares_build.h is picked up
+  * make ar configurable to ease cross-compiling
+
+- RELEASE-NOTES: added what's happened since 1.7.5
+
+Guenter Knauf (22 Apr 2012)
+- Updated copyright year.
+
+Yang Tse (21 Apr 2012)
+- ares_init.c: Further refactoring of Windows system's DNS fetching code
+
+Guenter Knauf (20 Apr 2012)
+- Android: small changes to dns property part.
+  
+  Prefix prop vars; kill var; use DNS_PROP_NAME_PREFIX macro.
+
+- Handle CNAME-only in ares_parse_aaaa_reply().
+  
+  posted to the c-ares list by Peter Griess <pg@std.in>.
+
+- Add support for multiple DNS servers on Android.
+  
+  Before, c-ares always used the first DNS server on Android, causing
+  network problems if this DNS server was not available.
+  
+  Signed-off-by: Geert Uytterhoeven <Geert.Uytterhoeven@sonycom.com>
+
+- Added INSTALL so it gets into tarballs.
+
+- Added some more ifdefs to silent compiler warnings.
+
+Yang Tse (17 Apr 2012)
+- INSTALL: remove a non c-ares section
+
+- cares-compilers.m4: -Wno-pedantic-ms-format for Windows gcc 4.5 builds
+  
+  When building a Windows target with gcc 4.5 or newer and strict compiler
+  warnings enabled use -Wno-pedantic-ms-format in addition to other flags.
+
+- setup_once.h: tighten requirements for stdbool.h header inclusion
+  
+  Include stdbool.h only when it is available and configure is capable of
+  detecting a proper 'bool' data type when the header is included.
+
+- configure: NATIVE_WINDOWS no longer defined in config file
+
+- cares-compilers.m4: double underscore decoration for visibility attribute
+
+- build adjustments: CARES_SYMBOL_HIDING no longer defined in config files
+  
+  configure script now provides conditional definitions for Makefile.am
+  that result in CARES_SYMBOL_HIDING being defined by resulting makefiles
+  when appropriate.
+
+- configure: Windows cross-compilation fixes
+  
+  CARES_BUILDING_LIBRARY and CARES_STATICLIB no longer defined in ares_config.h,
+  configure will generate appropriate conditionals so that mentioned symbols
+  get defined and used in Makefile derived from Makefile.am at compilation time.
+
+Guenter Knauf (17 Apr 2012)
+- Added INSTALL file adapted from libcurl.
+  
+  Not yet ready, and needs further edits.
+
+Yang Tse (16 Apr 2012)
+- ares_init.c: get_iphlpapi_dns_info() refactoring
+
+Guenter Knauf (16 Apr 2012)
+- Kill some more compiler warnings.
+
+- Kill compiler warning about unused var.
+
+- Fixed my last commit: wrong preprocessor directive.
+
+- Check for __ANDROID__ in addition to ANDROID macro.
+
+- Check for __ANDROID__ in addition to ANDROID macro.
+  
+  Posted to c-ares list by Wayne.
+
+- Fix for Android to disable useless arpa/nameser.h.
+
+- Fix for Android to include sys/select.h for fd_set.
+
+Yang Tse (17 Mar 2012)
+- ares_data.c: some NAPTR related fixes
+
+Daniel Stenberg (16 Mar 2012)
+- port numbers: convert them to network order!
+  
+  When the config options ARES_OPT_UDP_PORT or ARES_OPT_TCP_PORT are used,
+  make sure to convert them to network byte order!
+  
+  Bug: http://c-ares.haxx.se/mail/c-ares-archive-2012-02/0004.shtml
+
+- white space cleanup
+  
+  - Keep code within 80 columns
+  
+  - Removed funny spaces after open paren and before closing paren
+
+- [Poul Thomas Lomholt brought this change]
+
+  get_iphlpapi_dns_info: fix buffer overrun
+  
+  I experienced a buffer overrun exception in c-ares on Windows and
+  tracked it down to be an error in the calculation of the 'left' variable
+  in get_iphlpapi_dns_info().
+  
+  I changed the variable type of 'left' to a _signed_ type because of the
+  subtraction arithmetic; not sure if a long is the best choice
+
+- Merge pull request #7 from saghul/naptr
+  
+  Added support for parsing NAPTR records
+
+saghul (23 Feb 2012)
+- Added support for parsing NAPTR records
+
+Yang Tse (19 Jan 2012)
+- ares_init.c: fix compiler warning on winsock builds
+
+- configure: libtool 1.5 tweaks
+
+Daniel Stenberg (19 Dec 2011)
+- ares_timeout.3: fix the NAME section
+  
+  It was clearly a copy n' paste error
+
+Yang Tse (27 Sep 2011)
+- [Albert Chin brought this change]
+
+  configure - m4: make CURL_CHECK_DEF ignore leading whitespace on symbol def
+  
+  When using Sun C compiler the preprocessor somehow inserts an extra space
+  in front of replaced symbol, breaking CURL_CHECK_DEF macro. To workaround
+  this, macro CURL_CHECK_DEF now ignores all leading whitespace in front of
+  symbol substitution result.
+
+- ares_init.c: fix segfault triggered in ares_init_options() upon previous
+               failure of init_by_defaults() and incomplete cleanup there.
+
+- ares_process.c: fix compiler warning
+
+- fix MSVC compiler warning 'conditional expression is constant'
+
+- setup_once.h cleanup and sync
+
+- [Denis Bilenko brought this change]
+
+  ares_getnameinfo: fix random results with c-ares 1.7.5
+  
+  In ares_getnameinfo memcpy did not copy enough bytes, causing
+  it to return arbitrary memory contents as a result.
+
+- warnings: fix another 'conversion may lose significant bits' compiler warning
+
+- ares_dns.h: adjust DNS__16BIT and DNS__32BIT macro definitions
+  
+  Fixing compiler warnings existing definitions triggered on these.
+
+- ares_destroy.c: fix segfault in ares_destroy_options()
+
+Daniel Stenberg (21 Aug 2011)
+- ares_parse_srv_reply: silence compiler warnings
+  
+  ... by adding ugly typecasts.
+
+- CHANGES: generate from script
+  
+  The CHANGES file is now generated automatically with 'git2changes.pl',
+  invoked by the maketgz script which is used to build release archives.
+  
+  The former human edited CHANGES file was renamed to CHANGES.0 in git.
+
+Yang Tse (21 Aug 2011)
+- Makefile.netware: SIZEOF_SHORT definition
+
+- warnings: fix some 'conversion may lose significant bits' compiler warnings
+
+- configure: fix symbol hiding usability check
+  
+  A more thorough test is done now in order to determine visibility attribute
+  usability, given that some compilers don't support visibility attribute on
+  all configurations.
+
+Daniel Stenberg (16 Aug 2011)
+- 1.7.6: start working...
+
+Version 1.7.5 (16 Aug 2011)
+
+Daniel Stenberg (16 Aug 2011)
+- CHANGES: synced for 1.7.5 release
+
+- RELEASE-NOTES: synced with bb4096effef7f000
+
+Jakub Hrozek (15 Aug 2011)
+- Only fall back to AF_INET searches when looking for AF_UNSPEC addresses
+
+Yang Tse (10 Aug 2011)
+- [Gisle Vanem brought this change]
+
+  ares_iphlpapi.h: Watcom C fix
+  
+    Added "!defined(_WS2DEF_)" since Watcom doesn't have
+    a per type guard for the typedefs 'CSADDR_INFO' (that MingW has) or
+    'SOCKET_ADDRESS' (that MSVC has). But we can use the header-guard for
+    <ws2def.h> instead.
+
+- [Gisle Vanem brought this change]
+
+  Makefile.Watcom:
+    * The 'NTDDI_VERSION' needs to be raised to 0x05010000
+      in order for SOCKADDR_STORAGE etc. to be typedefed.
+    * Replaced '-dUSE_WATT32' with '-dWATT32'.
+    * Added $(DEMOS) to the 'all' target and removed the 'demos'
+      target to be consistent with e.g. Makefile.msvc etc.
+    * 'ENABLE_IPV6' is no longer used. Hence removed the '%use_ipv6' construct.
+    * object-file order seems to be important (Watcom v.19). Hence
+      'ares_getopt.obj' must be put after the .obj that references getopt().
+
+- cares-compilers.m4: CARES_CONVERT_INCLUDE_TO_ISYSTEM adjustments
+  
+  Add CARES_CHECK_COMPILER as a requirement.
+  
+  Ensure macro does nothing unless GNU_C or CLANG compiler is used.
+  
+  This should allow usage of this macro in unforeseen placements.
+
+- config-win32.h: comments adjustments - followup
+
+- config-win32.h: comments adjustments
+
+Daniel Stenberg (5 Aug 2011)
+- [Tom Hughes brought this change]
+
+  ares_parse_a_reply: fix memleak
+
+Yang Tse (29 Jul 2011)
+- cares-functions.m4 serial # bump
+
+- Revert "configure: additional flag checks for fcntl() and socket()"
+  
+  This reverts commit 5f2a3b0e48f26d24cb1fefea0dccb92d417dcbf7.
+
+- configure: additional flag checks for fcntl() and socket()
+
+- xc-translit.m4 fix quoting
+
+- configure: avoid direct usage of AS_TR_* macros
+
+- xc-translit.m4 provides transliteration macros with well defined behavior.
+
+Jakub Hrozek (15 Jun 2011)
+- Revert "Only fall back to AF_INET searches when looking for AF_UNSPEC addresses"
+  
+  This reverts commit b5823d65706af687c0e5110af8f0cfdcd068997d.
+  
+  This patch was not reviewed properly before pushing
+
+- Revert "Do not use sized constants in public headers"
+  
+  This reverts commit 22c01e96f7b2ae9923e1baa50bfe3c0d22297a7d.
+  
+  This is a Red Hat specific patch that does not belong into upstream
+
+- Use correct sizeof in ares_getnameinfo()
+
+- Do not leak rr_name on failures inside ares_parse_ptr_reply
+
+- Do not leak rr_name on failures inside ares_parse_a_reply
+
+- Do not leak rr_name on failures inside ares_parse_aaaa_reply
+
+- Do not leak rr_name on failures inside ares_parse_ns_reply
+
+- Fix incorrect sizeof() in ares_save_options
+
+- Fix incorrect allocation in ares_parse_ptr_reply()
+
+- Only fall back to AF_INET searches when looking for AF_UNSPEC addresses
+
+- Do not use sized constants in public headers
+
+Daniel Stenberg (13 Jun 2011)
+- [Jakub Hrozek brought this change]
+
+  ares_free_hostent(NULL) should be a noop
+
+Yang Tse (8 Jun 2011)
+- configure: fix recvfrom 5th arg type qualifier detection (followup)
+
+- configure: fix recvfrom 5th arg type qualifier detection
+  
+  Additionally remove whitespace from EOL
+
+Daniel Stenberg (4 Jun 2011)
+- strlen: use size_t to receive the return
+
+Yang Tse (4 Jun 2011)
+- xlc: avoid preprocessor definition usage when linking
+
+- ares_nowarn: icc 9.1 workaround
+
+- ares_nowarn: header inclusion fix
+
+- ares_init: make ares_private.h last included header again
+
+- compiler warning: fix
+  
+  Fix compiler warning: conversion may lose significant bits
+
+- compiler warning: fix
+  
+  Fix compiler warning: variable was set but never used
+  
+  Fix compiler warning: clobber ignored
+
+- ares_iphlpapi: fix compiler warnings
+
+- winsock: compilation fixes
+  
+  Provide winsock iphlpapi alternative definitions to prevent compilation
+  failures when using a variety of winsock header implementations.
+
+Daniel Stenberg (17 May 2011)
+- [David Stuart brought this change]
+
+  IPv6-on-windows: find DNS servers correctly
+
+- man pages: docs for the c-ares utility programs
+
+- ares_parse_ns_reply.c: remove CVSism
+
+Yang Tse (27 Mar 2011)
+- build: fix header inclusion
+
+- getservbyport replacement for Win CE
+
+- renamed getplatform() to ares__getplatform() to avoid namespace pollution
+
+- configure: fix libtool warning
+  
+  Recent versions of libtool are now tracing usage of AC_CONFIG_MACRO_DIR
+  macro and warn heavily when not used in configure script along with
+  ACLOCAL_AMFLAGS in Makefile.am.  So in order to make libtool happy
+  while keeping backwards compatibility this is added.
+
+- adig: RFC4034 resource record type detection
+  
+  Can be tested with: adig -s 8.8.8.8 -t ANY example.com
+
+- nameser.h: RFC4034 resource record type definitions
+
+- build: move platform stuff to ares_platform.c and ares_platform.h
+
+- build: find out windows platform using GetVersionEx()
+
+- build: use getenv() replacement function for systems which lack it
+
+- setup_once: system error codes for Windows CE
+
+- ares_search: use ERRNO macro for portability sake
+
+- System's errno.h inclusion cleanup follow-up.
+  
+  System's errno.h is conditionally included from setup_once.h
+
+- Windows CE specific adjustment
+  
+  All versions of Windows CE support Winsock 1.1
+
+- System's errno.h inclusion cleanup.
+  
+  System's errno.h is conditionally included from setup_once.h
+
+- ares_init: fix gethostname error detection on winsock platforms
+
+- configure: r-enable temporarily disabled detection of system's inet_ntop()
+  
+  Detection was temporarily disabled in commit 674e044ccb21f2f63537da53565fce868f
+
+Daniel Stenberg (15 Mar 2011)
+- configure: stop using the deprecated AM_INIT_AUTOMAKE syntax
+
+- [Gisle Vanem brought this change]
+
+  Watt-32: use errno
+  
+  Make sure Watt-32 programs use 'errno' even on Win32 targets
+
+Guenter Knauf (18 Feb 2011)
+- Removed commented CLFAGS no longer needed.
+
+- Fixed CFLAGS for NetWare.
+  
+  Added -m32 to enable compilation with x86_64 compilers;
+  added conditional to set -fpcc-struct-return only for gcc compiler.
+
+Daniel Stenberg (18 Feb 2011)
+- [Gisle Vanem brought this change]
+
+  Watt32: fix server init
+  
+  Somewhere in the process, programs using the Watt-32 tcp/ip stack
+  stopped working.
+
+- [Dima Tisnek brought this change]
+
+  config_sortlist: (win32) missing else
+  
+  Without an else there, contents of "pat" that could have been
+  successfully set just above, may be clobbered by successive unsuccessful
+  calls to "xxx_pton" or "ip_addr".
+
+Yang Tse (17 Jan 2011)
+- Makefile.msvc: add a couple of VS version strings
+
+- Makefile.msvc: add a couple of VS version strings
+
+- build: add install target to Makefile.msvc
+
+Daniel Stenberg (27 Dec 2010)
+- ares_set_servers_csv: remove unused variables
+
+- init_by_resolv_conf: fix compiler warnings
+  
+  The code received the return codes in the 'status' variable without
+  using it. Instead we just ignore those particular errors.
+
+- getv4: Value stored to 'dst' is never read
+
+- advance_tcp_send_queue: avoid NULL ptr dereference
+  
+  If given a too large 'num_bytes' value, it would cause a NULL ptr
+  dereference. Instead the code will now break out of the loop at the end
+  of the list.
+
+- [Peter Pentchev brought this change]
+
+  configure: fix a bashism
+
+- cleanup: avoid unsafe typecasts
+  
+  Avoid the risk of reading 16bit data from an unaligned address by using
+  a macro that is adapted for this.
+
+- [Stefan Bühler brought this change]
+
+  ares_expand_name: Fix encoded length for indirect root
+
+Yang Tse (18 Dec 2010)
+- build: add some explicit file references to VS project files
+
+- config-win32: provide HAVE_ASSERT_H definition
+
+- build: include ares_nowarn in sample program VS project files
+
+- build: include ares_nowarn among SAMPLESOURCES and SAMPLEHEADERS
+
+- configure: temporarily disable detection of system's inet_ntop()
+  
+  This is done to allow compilation of ares_inet_ntop() by some daily
+  builds picky compilers that otherwise do not need this function.
+
+- changes: mention last fix
+
+- ares_inet_ntop: remove definition and usage of macro SPRINTF
+  
+  Existing definition of SPRINTF always resulted in sprintf() being used,
+  and sprintf() returning 'int' is already used throughout the library.
+
+- ares_inet_ntop: reapply changes from previous c-ares version (III)
+  
+  - Replace 'u_char' with 'unsigned char'.
+  - Replace 'u_int' with 'unsigned int'.
+  - use macros ERRNO and SET_ERRNO() for errno handling.
+
+- ares_inet_ntop: reapply changes from previous c-ares version (II)
+  
+  - Remove rcsid.
+  - Adjust header file inclusions.
+  - ares_inet_ntop used only on systems without a proper inet_ntop function.
+
+- ares_inet_ntop: reapply changes from previous c-ares version (I)
+  
+  - Replace tabs with spaces.
+  - Use ANSI C style for function declarations and definitions.
+  - Use sizeof with parentheses.
+
+- ares_inet_ntop: fix off by one error triggering out of bounds write
+  
+  ares_inet_ntop would trigger an out of bounds write when the representation
+  of the address required 15 characters, due to not taking in account null
+  termination character.
+  
+  Full import of inet_ntop.c from bind-9.5.3rc1 to pull additional fixes.
+
+- ares_nowarn: add conditional inclusion of assert.h header
+
+- fix compiler warning: conversion may lose significant bits
+
+- ares_inet_net_pton: fix non-rejection of some malformed literals
+  
+  ares_inet_net_pton would return wrong values when excessively large,
+  and invalid, netmasks are used. Fixes are from bind-9.5.3rc1,
+  issue also described in the WLB-2008080064 advisory.
+
+- setup_once: provide ISASCII macro
+
+- configure: inet_net_pton function check adjustments
+  
+  Define HAVE_INET_NET_PTON only when system's inet_net_pton function is IPv6
+  capable and is not affected by the WLB-2008080064 advisory.
+  
+  HAVE_INET_NET_PTON_IPV6 is no longer defined nor used.
+
+- ares_init: fix detection of semicolon comments in resolv.conf
+  
+  File resolv.conf may either use a hash '#' or a semicolon ';' character as an
+  indication that the rest of the line is a comment.  This fixes not recognizing
+  the semicolon as a valid comment indicator in resolv.conf.
+
+- version: start working on 1.7.5
+
+Version 1.7.4 (8 Dec 2010)
+
+Daniel Stenberg (8 Dec 2010)
+- release-preps: CHANGES and RELEASE-NOTES synced
+
+- ares_set_local_*: added in 1.7.4, not before
+
+Yang Tse (3 Dec 2010)
+- build: provide SIZEOF_SIZE_T definition for non-configure builds
+
+- build: config.dos renamed to config-dos.h
+
+- build: provide SIZEOF_SIZE_T netware definition
+
+- ares_gethostbyaddr: fix compiler warning: conversion may lose significant bits
+
+- configure: undo using autobuilds to temporarily verify strict aliasing warnings.
+
+- fix compiler warning: rounding, sign extension, or loss of accuracy may result
+
+Daniel Stenberg (2 Dec 2010)
+- [Ben Noordhuis brought this change]
+
+  ares_parse_a_reply: fix CNAME response parsing
+  
+  Reply to a CNAME query doesn't contain addresses, causing
+  ares_parse_a_reply() to bail out with ARES_ENODATA
+  
+  Bug: http://groups.google.com/group/nodejs/browse_thread/thread/a1268c9ea5e9ad9b
+
+Yang Tse (1 Dec 2010)
+- fix compiler warning: conversion may lose significant bits
+
+- atoi: remove atoi usage
+
+- ares_init: fix compiler warning: conversion may lose significant bits
+
+- configure: fix autoconf warning
+
+- inet_pton: fix compiler warning
+
+- configure: use autobuilds to temporarily verify strict aliasing warnings.
+  
+  Temporarily, When cross-compiling with gcc 3.0 or later, enable strict aliasing
+  rules and warnings. Given that cross-compiled targets autobuilds do not run the
+  test-suite, there is no risk of running code that violates strict aliasing rules
+
+- ares_getnameinfo: Partially revert commit 85520d66e0ac7ac73411bc25e98769a88b2f
+  
+  Upon socket address family and length validation failure return ARES_ENOTIMP
+  in callback again, this is the error code documented in man page and used
+  mostly all over the library.
+
+- ares_getnameinfo: Validate socket address family and length.
+  
+  Validate socket address family and that the socket address length is appropriate
+  for the specified family. Failure is reported with ARES_EBADFAMILY in callback.
+
+- ares_getnameinfo: fix two compiler warnings
+
+- Added another VS10 version string
+
+- Fix GCC 4 compiler warning 'dereferencing type-punned pointer might break strict-aliasing rules'.
+
+- Revert commit 494274e653936335c255a47599970de3df21e7c4
+
+- configure: fix autoconf 2.68 warning: no AC_LANG_SOURCE call detected in body
+
+- Fix compiler warning: array subscript has type 'char'
+
+- Fix GCC 4 compiler warning 'dereferencing type-punned pointer might break strict-aliasing rules'.
+
+- Revert following commits:
+    07bc7ea79509bcc9ef6e09151e81766ed00d3392
+    3392a50ea3f8573ea4b7a9d82b9833dab60cb0e9
+    9912637d32c9987719a1ea12db591aee2941891c
+  
+  The purpose of the whole patch was to silence a compiler warning triggered
+  with GCC 4 on file ares_process.c  The specific compiler warning was
+  'dereferencing type-punned pointer might break strict-aliasing rules'.
+  
+  A simpler patch will follow to equally silence the warning.
+
+- ares_options: reorder header inclusions to make inclusion of
+  ares_private.h the last included one again.
+
+Daniel Stenberg (12 Nov 2010)
+- [Patrik Thunstrom brought this change]
+
+  adig: fix NAPTR parsing
+  
+  I ran across a small "issue" in your adig example.
+  
+  It is simply the last part of the NAPTR record, the replacement element,
+  which is not a string, as currently handled in adig, but a domain name.
+
+- ares_save_options: assignments instead of memcpy
+
+- init_by_options: don't copy an empty sortlist
+  
+  If there aren't any sort items to copy, don't bother. Without this
+  little precaution it would do a malloc(0) which causes undefined
+  behaviors and is frowned upon by curl's memdebug-system.
+
+Guenter Knauf (3 Oct 2010)
+- Minor Watcom makefile tweaks.
+
+Daniel Stenberg (30 Sep 2010)
+- [Mike Crowe brought this change]
+
+  Fix lookup with HOSTALIASES set.
+  
+  ares__read_line returns ARES_EOF when it reaches the end of the
+  file. This will happen every time when reading to the end of the
+  HOSTALIASES file. Unfortunately single_domain treats this error as
+  being fatal.
+  
+  Signed-off-by: Mike Crowe <mac@mcrowe.com>
+
+Ben Greear (24 Aug 2010)
+- Add missing break that caused get_ares_servers to fail.
+  
+  Reported-by: Ning Dong <flintning@163.com>
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+Yang Tse (11 Aug 2010)
+- configure: werror related adjustments
+
+Guenter Knauf (8 Aug 2010)
+- Added copyright string to ares_version.h and make use of it in other files.
+
+- Block created ares_build.h for NetWare to avoid usage from other platforms.
+
+- Fix to overwrite default libname.
+
+- Some more Watcom makefile massage ...
+
+- Some more Watcom makefile massage ...
+
+Ben Greear (4 Aug 2010)
+- sock-addr-storage:  Detect and deal with lack of .ss_family member.
+  
+  AIX, at least, does not have sockaddr_storage.ss_family member.
+  Detect this in the configure logic and use proper #ifdefs in the
+  ares_process logic.
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+  Tested-by: Tor Arntsen <tor@spacetec.no>
+
+Guenter Knauf (3 Aug 2010)
+- Added Watcom makefile based on libcurl's Makefile.Watcom.
+
+Ben Greear (31 Jul 2010)
+- typo:  Fix compile bug for platforms that don't have sockaddr_storage.
+  
+  Bug was introduced by me in previous commit.
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+- Fix aliasing warning in gcc 4.4.4 (at least).
+  
+  Should be no functional change, though the code gets a bit
+  ugglier.
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+Daniel Stenberg (31 Jul 2010)
+- ares_set_servers_csv: use ISDIGIT
+  
+  The IS*() set of macros are preferred to the regular is*() functions as
+  they help us avoid the most common pitfalls.
+
+Ben Greear (30 Jul 2010)
+- cast arg to isdigit to int
+  
+  Looks like it might silence a warning on Netware build.
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+- remove all uses of uint32_t
+  
+  Previous fix forgot a few.
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+- fix signed v/s unsigned casts warning in ares_gethostbyaddr.c
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+- local-bind-fixup:  Fix inet_pton warning.
+  
+  Conditionally include <arpa/inet.h> for inet_pton
+  headers.
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+- build:  Enable compiling with -Werror.
+  
+  This helps find compile warnings because they simply break
+  the build.
+  
+  To use:
+  ./configure --enable-warnings --enable-werror
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+- ipv6: Fix some build issues related to the local-bind feature.
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+Guenter Knauf (29 Jul 2010)
+- Replaced uint32_t with unsigned int to fix broken builds on a couple of platforms.
+
+Daniel Stenberg (18 Jul 2010)
+- [Ben Greear brought this change]
+
+  local-bind:  Support binding to local interface/IPs
+  
+  Add 3 new functions to set the local binding for the out-going
+  socket connection, and add ares_set_servers_csv() to set a
+  list of servers at once as a comma-separated string.
+  
+  Signed-off-by: Ben Greear <greearb@candelatech.com>
+
+- version: now start on 1.7.4
+
+- [Andrew C. Morrow brought this change]
+
+  fix memory leak in ares_getnameinfo
+
+Version 1.7.3 (11 Jun 2010)
+
+Daniel Stenberg (11 Jun 2010)
+- changelogs: updated for 1.7.3
+
+- [BogDan Vatra brought this change]
+
+  init: allow c-ares to work on Android OS
+
+- changelog: fill in the 1.7.2 changes
+
+- added another pdf to ignore
+
+Yang Tse (11 Jun 2010)
+- add ares_parse_mx_reply.c to VS dsp file
+
+Daniel Stenberg (10 Jun 2010)
+- tarball: add $(CSOURCES) $(HHEADERS) to EXTRA_DIST
+  
+  It's not clear to me why we need this, but we apparently may
+  otherwise not get all files bundled in the dist tarball.
+
+- version: start working on 1.7.3
+
+Version 1.7.2 (10 Jun 2010)
+
+Daniel Stenberg (10 Jun 2010)
+- RELEASE-NOTES: 1.7.2 details added
+
+- [Jakub Hrozek brought this change]
+
+  ares_init: Last, not first instance of domain or search should win
+
+- style: make code less than 80 columns wide
+
+Yang Tse (31 May 2010)
+- [Tor Arntsen brought this change]
+
+  improve alternative definition of bool to use enum instead of unsigned char
+
+- fix VS2010 compiler warnings
+
+Daniel Stenberg (18 Apr 2010)
+- [Jérémy Lal brought this change]
+
+  added ares_parse_mx_reply
+
+- repair the file mode
+
+- remove all $Id$ lines
+
+- remove all .cvsignore files
+
+- spell fix
+  
+  reported by Gregor Jasny on the mailing list
+
+- [Peter Pentchev brought this change]
+
+  Fix a couple of typos and grammar nits.
+
+- ignore the GPG signature files too
+
+- start the journey towards 1.7.2
+
+- no longer CVS tagging
+
+- ignore generated PDFs
+
+Version 1.7.1 (23 Mar 2010)
+
+Daniel Stenberg (23 Mar 2010)
+- 1.7.1
+
+- made README the primary readme file
+  
+  ... and did README.cares to contain a historic reason etc.
+
+- s/CVS/git
+
+- git now, not CVS
+
+- ignore lots of generated files
+
+- [Daniel Johnson brought this change]
+
+  Fix warnings for clang
+
+Yang Tse (17 Mar 2010)
+- replaced intel compiler option -no-ansi-alias with -fno-strict-aliasing
+
+- update outdated serial number
+
+- fix compiler warning
+
+- watt32 compilation fix
+
+- Added another VS10 version string
+
+- fix line break
+
+- removed usage of 's6_addr', fixing compilation issue triggered with no
+  longer using 'in6_addr' but only our 'ares_in6_addr' struct
+
+Daniel Stenberg (5 Mar 2010)
+- Daniel Johnson provided fixes for building with the clang compiler
+
+Yang Tse (5 Mar 2010)
+- Added IPv6 name servers support
+
+Gisle Vanem (5 Mar 2010)
+- Ops!. Readded ares_nowarn.h.
+
+- Added ares_nowarn.c.
+
+Yang Tse (28 Feb 2010)
+- Added SIZEOF_INT and SIZEOF_SHORT definitions for non-configure systems
+
+- Added ares_nowarn.* to VC6 project file
+
+- Added SIZEOF_INT definition
+
+- fix compiler warning
+
+- fix compiler warning
+
+- fix compiler warning
+
+Daniel Stenberg (17 Feb 2010)
+- ares_reinit()
+  
+  - To allow an app to force a re-read of /etc/resolv.conf etc, pretty much
+    like the res_init() resolver function offers
+
+- - Tommie Gannert pointed out a silly bug in ares_process_fd() since it didn't
+    check for broken connections like ares_process() did. Based on that, I
+    merged the two functions into a single generic one with two front-ends.
+
+Yang Tse (30 Dec 2009)
+- VMS specific preprocessor symbol checking adjustments
+
+- Mention last changes
+
+- - Fix configure_socket() to use ares_socket_t instead of int data type.
+
+- - Where run-time error checks enabling compiler option /GZ was used it is now
+    replaced with equivalent /RTCsu for Visual Studio 2003 and newer versions.
+  
+  - Compiler option /GX is now replaced with equivalent /EHsc for all versions.
+
+- - Ingmar Runge noticed that Windows config-win32.h configuration file
+    did not include a definition for HAVE_CLOSESOCKET which resulted in
+    function close() being inappropriately used to close sockets.
+
+Daniel Stenberg (30 Nov 2009)
+- start working on 1.7.1
+
+Version 1.7.0 (27 Nov 2009)
+
+Yang Tse (27 Nov 2009)
+- Preserve empty line following last target
+
+- - Larry Lansing fixed ares_parse_srv_reply to properly parse replies
+    which might contain non-SRV answers, skipping over potential non-SRV
+    ones such as CNAMEs.
+
+- When using icc, compile with -fpic and link with intel dynamic libraries.
+
+- Added 'currently' in italics to insist on transient situation.
+
+- Fix language
+
+- Daniel wants upcoming release to be 1.7.0
+
+- Mention last changes
+
+- - Removed from external interface preprocessor symbol definition for
+    CARES_HAVE_ARES_FREE_DATA. Current functionality of ares_free_data()
+    makes it unnecessary.
+
+- Added README.msvc
+
+- Changed c-ares naming conventions when using MSVC as described in README.msvc
+
+- - Mention other recent changes
+
+- - Jakub Hrozek renamed addrttl and addr6ttl structs to ares_addrttl and
+    ares_addr6ttl in order to prevent name space pollution, along with
+    necessary changes to code base and man pages.This change does not break
+    ABI, there is no need to recompile existing applications. But existing
+    applications using these structs with the old name will need source code
+    adjustments when recompiled using c-ares 1.6.1.
+
+- - Jakub Hrozek fixed more function prototypes in man pages to sync them
+    with the ones declared in ares.h
+
+- Make configure remove the ares_build.h file included in distribution tarballs.
+
+- Fix macro redefinition.
+
+- Fix name space pollution.
+
+- Allow using different extra import libraries for debug and release builds.
+
+- Add manifest stuff to msvc makefile
+
+- Sync man page with reality
+
+- Add missing external API decoration for ares_set_socket_callback()
+
+- Add ares_free_data() man page.
+
+- - Provide in external interface preprocessor symbol definitions for
+    CARES_HAVE_ARES_FREE_DATA as an indication of function availability.
+
+- Remove typecast
+
+- Fix comment
+
+- Add ares_data.c and ares_data.h
+
+- Jakub Hrozek modified ares_parse_srv_reply() and ares_parse_txt_reply() API
+  to return a linked lists of results. These were also modified to internally
+  use the ares_data memory struct and as such its result must be free'ed with
+  ares_free_data().
+
+- Initial support for the generic ares_free_data() function that will allow
+  applications to free memory allocated and returned by some c-ares funtions.
+
+- Make usage of calloc()'s arguments consistent with rest of code base
+
+- workaround icc 9.1 optimizer issue
+
+- Add icc fvisibility bug test
+
+- Fix icc 9.0 compiler warning: external definition with no prior declaration
+
+- Fix three var names
+
+- Add check for assert.h header file
+
+- getaddrinfo is fully thread safe on solaris versions which
+  implement the function even when h_errno is not a macro.
+  
+  The h_errno macro test now only done on systems for which there
+  is no hard coded knowledge about getaddrinfo's thread safeness.
+
+- Remove files generated on previous buildconf/configure run
+
+- Remove enable-thread / disable-thread configure option. These were only placebo
+  options. The library is always built as thread safe as possible on every system.
+
+- Refactor how preprocessor symbol _THREAD_SAFE definition is done.
+
+- Assume that getaddrinfo is thread safe, unless hard coded
+  knowledge says the contrary or h_errno is not defined.
+
+- Related with the threadsafe capability of getaddrinfo:
+  
+  - Constantine Sapuntzakis reported that Darwin 6.0 a.k.a. MAC OS X 10.2
+    and newer have a threadsafe getaddrinfo.
+  
+  - Fix Dragonfly BSD triplet detection.
+  
+  - In case the hard-coded knowledge says that getaddrinfo is threadsafe,
+    an additional check is done to verify that h_errno is also defined.
+    If h_errno isn't defined, we finally assume that it isn't threadsafe.
+    Jamie Lokier provided the inspiration for this extra check.
+
+- AIX 5.2 and newer have threadsafe getaddrinfo.
+  
+  Add some comments to better understand what the regex's pretend to achieve.
+
+- HP-UX 11.11 and later have threadsafe getaddrinfo
+
+- Check if getaddrinfo is threadsafe when function check allows it to be used
+
+- Renamed fpGetNetworkParams and fpSystemFunction036 to avoid namespace pollution with static library
+
+- Add kernel32.lib
+
+- Mention last changes
+
+- Reinstate copyright symbol lost in previous commit
+
+- Make some strings different in resource file for debug or release builds
+
+- Ignore more subdirs
+
+- Fix compiler warning: conditional expression is constant
+
+- Sync linker and resource compiler options with Makefile.msvc
+
+- Follow Makefile.msvc subdirectory naming scheme, and sync compiler options
+
+- Updated MSVC makefile that allows building dynamic and static
+  c-ares libraries in debug and release flavours.
+  
+  Additionally each of the three sample programs is built against
+  each of the four possible c-ares libraries, generating all this
+  a total number of 12 executables and 4 libraries.
+
+- Test for USE_WINSOCK since it is more restrictive than WIN32
+
+- Make header inclusion depend on HAVE_*_H definition
+
+- Remove unneeded preprocessor directives
+
+- Adjust c-ares include paths for memory tracking enabled (--enable-curldebug) builds
+
+- source files used by sample programs
+
+- Renamed c-ares setup.h to ares_setup.h
+
+- Adjust include paths to take in account that currently:
+  
+  c-ares with --enable-curldebug uses memdebug.h from libcurl's lib subdirectory.
+  
+  memdebug.h needs access to libcurl's setup.h from libcurl's lib subdirectory
+  and also needs access to libcurl's generated curl_config.h
diff --git a/deps/cares/CMakeLists.txt b/deps/cares/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cc4b590718df832633d19a639363019a6f52f2d4
--- /dev/null
+++ b/deps/cares/CMakeLists.txt
@@ -0,0 +1,766 @@
+CMAKE_MINIMUM_REQUIRED (VERSION 3.1.0)
+
+INCLUDE (CheckIncludeFiles)
+INCLUDE (CheckTypeSize)
+INCLUDE (CheckFunctionExists)
+INCLUDE (CheckSymbolExists)
+INCLUDE (CheckCSourceCompiles)
+INCLUDE (CheckStructHasMember)
+INCLUDE (CheckLibraryExists)
+
+PROJECT (c-ares LANGUAGES C VERSION "1.18.0" )
+
+# Set this version before release
+SET (CARES_VERSION "1.18.1")
+
+INCLUDE (GNUInstallDirs) # include this *AFTER* PROJECT(), otherwise paths are wrong.
+
+# This is for libtool compatibility, and specified in a form that is easily
+# translatable from libtool (even if the actual form doesn't make sense).
+# For instance, in an autotools project, in Makefile.am there is a line that
+# contains something like:
+#     -version-info 4:0:2
+# This breaks down into sections of current:revision:age
+# This then generates a version of  "(current-age).age.revision"  with an
+# interface version of "(current-age)"
+# For example, a version of 4:0:2 would generate output such as:
+#    libname.so   -> libname.so.2
+#    libname.so.2 -> libname.so.2.2.0
+SET (CARES_LIB_VERSIONINFO "7:1:5")
+
+
+OPTION (CARES_STATIC     "Build as a static library"                                             OFF)
+OPTION (CARES_SHARED     "Build as a shared library"                                             ON)
+OPTION (CARES_INSTALL    "Create installation targets (chain builders may want to disable this)" ON)
+OPTION (CARES_STATIC_PIC "Build the static library as PIC (position independent)"                OFF)
+OPTION (CARES_BUILD_TESTS "Build and run tests"                                                  OFF)
+OPTION (CARES_BUILD_CONTAINER_TESTS "Build and run container tests (implies CARES_BUILD_TESTS, Linux only)" OFF)
+OPTION (CARES_BUILD_TOOLS "Build tools"                                                          ON)
+
+# Tests require static to be enabled on Windows to be able to access otherwise hidden symbols
+IF (CARES_BUILD_TESTS AND (NOT CARES_STATIC) AND WIN32)
+	SET (CARES_STATIC ON)
+	SET (CARES_STATIC_PIC ON)
+	MESSAGE (WARNING "Static building was requested be disabled, but reenabled to support tests")
+ENDIF ()
+
+# allow linking against the static runtime library in msvc
+IF (MSVC)
+	OPTION (CARES_MSVC_STATIC_RUNTIME "Link against the static runtime library" OFF)
+	IF (CARES_MSVC_STATIC_RUNTIME)
+		# CMAKE_CONFIGURATION_TYPES is empty on non-IDE generators (Ninja, NMake)
+		# and that's why we also use CMAKE_BUILD_TYPE to cover for those generators.
+		# For IDE generators, CMAKE_BUILD_TYPE is usually empty
+		FOREACH (config_type ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE})
+			STRING (TOUPPER ${config_type} upper_config_type)
+			SET (flag_var "CMAKE_C_FLAGS_${upper_config_type}")
+			IF (${flag_var} MATCHES "/MD")
+				STRING (REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+			ENDIF ()
+		ENDFOREACH ()
+
+		# clean up
+		SET (upper_config_type)
+		SET (config_type)
+		SET (flag_var)
+	ENDIF ()
+ENDIF ()
+
+# Keep build organized.
+SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}")
+SET (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+SET (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+SET (PACKAGE_DIRECTORY ${PROJECT_BINARY_DIR}/package)
+
+# Destinations for installing different kinds of targets (pass to install command).
+SET (TARGETS_INST_DEST
+	RUNTIME DESTINATION  ${CMAKE_INSTALL_BINDIR}
+	BUNDLE DESTINATION   ${CMAKE_INSTALL_BINDIR}
+	LIBRARY DESTINATION  ${CMAKE_INSTALL_LIBDIR}
+	ARCHIVE DESTINATION  ${CMAKE_INSTALL_LIBDIR}
+)
+
+# Function in Library
+# CHECK_LIBRARY_EXISTS can't be used as it will return true if the function
+# is found in a different dependent library.
+MACRO (CARES_FUNCTION_IN_LIBRARY func lib var)
+	CHECK_FUNCTION_EXISTS ("${func}" "_CARES_FUNC_IN_LIB_GLOBAL_${func}")
+	IF ("${_CARES_FUNC_IN_LIB_GLOBAL_${func}}")
+		SET (${var} FALSE)
+	ELSE ()
+		CHECK_LIBRARY_EXISTS ("${lib}" "${func}" "" ${var})
+	ENDIF ()
+ENDMACRO ()
+
+# Look for dependent/required libraries
+CARES_FUNCTION_IN_LIBRARY (res_servicename resolv HAVE_RES_SERVICENAME_IN_LIBRESOLV)
+IF (HAVE_RES_SERVICENAME_IN_LIBRESOLV)
+	SET (HAVE_LIBRESOLV 1)
+ENDIF ()
+
+IF (APPLE)
+	CHECK_C_SOURCE_COMPILES ("
+	#include <stdio.h>
+	#include <TargetConditionals.h>
+	int main() {
+#if TARGET_OS_IPHONE == 0
+#error Not an iPhone target
+#endif
+return 0;
+	}
+	"
+	IOS)
+
+	CHECK_C_SOURCE_COMPILES ("
+#include <stdio.h>
+#include <TargetConditionals.h>
+	int main() {
+#if TARGET_OS_IPHONE == 0 || __IPHONE_OS_VERSION_MIN_REQUIRED < 100000
+#  error Not iOS v10
+#endif
+return 0;
+	}
+	"
+	IOS_V10)
+
+	CHECK_C_SOURCE_COMPILES ("
+#include <stdio.h>
+#include <AvailabilityMacros.h>
+#ifndef MAC_OS_X_VERSION_10_12
+#  define MAC_OS_X_VERSION_10_12 101200
+#endif
+	int main() {
+#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
+#  error Not MacOSX 10.12 or higher
+#endif
+return 0;
+	}
+	"
+	MACOS_V1012)
+ENDIF ()
+
+IF ((IOS OR APPLE OR ZOS) AND HAVE_LIBRESOLV)
+	SET (CARES_USE_LIBRESOLV 1)
+ENDIF()
+
+
+CARES_FUNCTION_IN_LIBRARY (gethostbyname nsl HAVE_LIBNSL)
+CARES_FUNCTION_IN_LIBRARY (gethostbyname socket HAVE_GHBN_LIBSOCKET)
+CARES_FUNCTION_IN_LIBRARY (gethostbyname network HAVE_LIBNETWORK)
+CARES_FUNCTION_IN_LIBRARY (socket socket HAVE_SOCKET_LIBSOCKET)
+IF (HAVE_GHBN_LIBSOCKET OR HAVE_SOCKET_LIBSOCKET)
+	SET(HAVE_LIBSOCKET TRUE)
+ENDIF ()
+CARES_FUNCTION_IN_LIBRARY (socket network HAVE_LIBNETWORK)
+CARES_FUNCTION_IN_LIBRARY (clock_gettime rt HAVE_LIBRT)
+
+
+# Look for necessary includes
+CHECK_INCLUDE_FILES (sys/types.h           HAVE_SYS_TYPES_H)
+CHECK_INCLUDE_FILES (sys/socket.h          HAVE_SYS_SOCKET_H)
+CHECK_INCLUDE_FILES (sys/sockio.h          HAVE_SYS_SOCKIO_H)
+CHECK_INCLUDE_FILES (arpa/inet.h           HAVE_ARPA_INET_H)
+CHECK_INCLUDE_FILES (arpa/nameser_compat.h HAVE_ARPA_NAMESER_COMPAT_H)
+CHECK_INCLUDE_FILES (arpa/nameser.h        HAVE_ARPA_NAMESER_H)
+CHECK_INCLUDE_FILES (assert.h              HAVE_ASSERT_H)
+CHECK_INCLUDE_FILES (errno.h               HAVE_ERRNO_H)
+CHECK_INCLUDE_FILES (fcntl.h               HAVE_FCNTL_H)
+CHECK_INCLUDE_FILES (inttypes.h            HAVE_INTTYPES_H)
+CHECK_INCLUDE_FILES (limits.h              HAVE_LIMITS_H)
+CHECK_INCLUDE_FILES (malloc.h              HAVE_MALLOC_H)
+CHECK_INCLUDE_FILES (memory.h              HAVE_MEMORY_H)
+CHECK_INCLUDE_FILES (netdb.h               HAVE_NETDB_H)
+CHECK_INCLUDE_FILES (netinet/in.h          HAVE_NETINET_IN_H)
+CHECK_INCLUDE_FILES (net/if.h              HAVE_NET_IF_H)
+CHECK_INCLUDE_FILES (signal.h              HAVE_SIGNAL_H)
+CHECK_INCLUDE_FILES (socket.h              HAVE_SOCKET_H)
+CHECK_INCLUDE_FILES (stdbool.h             HAVE_STDBOOL_H)
+CHECK_INCLUDE_FILES (stdint.h              HAVE_STDINT_H)
+CHECK_INCLUDE_FILES (stdlib.h              HAVE_STDLIB_H)
+CHECK_INCLUDE_FILES (strings.h             HAVE_STRINGS_H)
+CHECK_INCLUDE_FILES (string.h              HAVE_STRING_H)
+CHECK_INCLUDE_FILES (stropts.h             HAVE_STROPTS_H)
+CHECK_INCLUDE_FILES (sys/ioctl.h           HAVE_SYS_IOCTL_H)
+CHECK_INCLUDE_FILES (sys/param.h           HAVE_SYS_PARAM_H)
+CHECK_INCLUDE_FILES (sys/select.h          HAVE_SYS_SELECT_H)
+CHECK_INCLUDE_FILES (sys/stat.h            HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILES (sys/time.h            HAVE_SYS_TIME_H)
+CHECK_INCLUDE_FILES (sys/uio.h             HAVE_SYS_UIO_H)
+CHECK_INCLUDE_FILES (time.h                HAVE_TIME_H)
+CHECK_INCLUDE_FILES (dlfcn.h               HAVE_DLFCN_H)
+CHECK_INCLUDE_FILES (unistd.h              HAVE_UNISTD_H)
+
+# On OpenBSD, you must include sys/types.h before netinet/tcp.h
+IF (HAVE_SYS_TYPES_H)
+  CHECK_INCLUDE_FILES ("sys/types.h;netinet/tcp.h"         HAVE_NETINET_TCP_H)
+ELSE ()
+  CHECK_INCLUDE_FILES (netinet/tcp.h                       HAVE_NETINET_TCP_H)
+ENDIF ()
+
+# Include order matters for these windows files.
+# As cygwin environment has both socket.h and winsock2.h
+# headers check WIN32 not to include the later one here
+IF (WIN32)
+CHECK_INCLUDE_FILES ("winsock2.h;windows.h"            HAVE_WINSOCK2_H)
+CHECK_INCLUDE_FILES ("winsock2.h;ws2tcpip.h;windows.h" HAVE_WS2TCPIP_H)
+CHECK_INCLUDE_FILES ("winsock.h;windows.h"             HAVE_WINSOCK_H)
+CHECK_INCLUDE_FILES (windows.h                         HAVE_WINDOWS_H)
+ENDIF ()
+
+# Set system-specific compiler flags
+IF (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+	LIST (APPEND SYSFLAGS -D_DARWIN_C_SOURCE)
+ELSEIF (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+	LIST (APPEND SYSFLAGS -D_GNU_SOURCE -D_POSIX_C_SOURCE=199309L -D_XOPEN_SOURCE=600)
+ELSEIF (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+	LIST (APPEND SYSFLAGS -D__EXTENSIONS__ -D_REENTRANT -D_XOPEN_SOURCE=600)
+ELSEIF (CMAKE_SYSTEM_NAME STREQUAL "AIX")
+	LIST (APPEND SYSFLAGS -D_ALL_SOURCE -D_XOPEN_SOURCE=600 -D_USE_IRS)
+ELSEIF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
+	# Don't define _XOPEN_SOURCE on FreeBSD, it actually reduces visibility instead of increasing it
+ELSEIF (WIN32)
+	LIST (APPEND SYSFLAGS -DWIN32_LEAN_AND_MEAN -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -D_WIN32_WINNT=0x0600)
+ENDIF ()
+ADD_DEFINITIONS(${SYSFLAGS})
+
+
+
+# Tell C-Ares about libraries to depend on
+IF (HAVE_LIBRESOLV)
+	LIST (APPEND CARES_DEPENDENT_LIBS resolv)
+ENDIF ()
+IF (HAVE_LIBNSL)
+	LIST (APPEND CARES_DEPENDENT_LIBS nsl)
+ENDIF ()
+IF (HAVE_LIBSOCKET)
+	LIST (APPEND CARES_DEPENDENT_LIBS socket)
+ENDIF ()
+IF (HAVE_LIBNETWORK)
+	LIST (APPEND CARES_DEPENDENT_LIBS network)
+ENDIF ()
+IF (HAVE_LIBRT)
+	LIST (APPEND CARES_DEPENDENT_LIBS rt)
+ENDIF ()
+IF (WIN32)
+	LIST (APPEND CARES_DEPENDENT_LIBS ws2_32 advapi32 iphlpapi)
+ENDIF ()
+
+
+# When checking for symbols, we need to make sure we set the proper
+# headers, libraries, and definitions for the detection to work properly
+# CMAKE_REQUIRED_DEFINITIONS, CMAKE_REQUIRED_LIBRARIES, and
+# CMAKE_EXTRA_INCLUDE_FILES.  When we're done with the detection, we'll
+# unset them.
+
+SET (CMAKE_REQUIRED_DEFINITIONS ${SYSFLAGS})
+LIST (APPEND CMAKE_REQUIRED_LIBRARIES ${CARES_DEPENDENT_LIBS})
+
+MACRO (CARES_EXTRAINCLUDE_IFSET var include)
+	IF (${var})
+		LIST (APPEND CMAKE_EXTRA_INCLUDE_FILES ${include})
+	ENDIF ()
+ENDMACRO ()
+
+CARES_EXTRAINCLUDE_IFSET (HAVE_STDBOOL_H      stdbool.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_SYS_TYPES_H    sys/types.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_ARPA_INET_H    arpa/inet.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_ARPA_NAMESER_H arpa/nameser.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_NETDB_H        netdb.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_NET_IF_H       net/if.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_NETINET_IN_H   netinet/in.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_NETINET_TCP_H  netinet/tcp.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_SIGNAL_H       signal.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_STDLIB_H       stdlib.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_STRING_H       string.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_STRINGS_H      strings.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_SYS_IOCTL_H    sys/ioctl.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_SYS_SELECT_H   sys/select.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_SYS_SOCKET_H   sys/socket.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_SYS_SOCKIO_H	sys/sockio.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_SYS_TIME_H     sys/time.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_SYS_UIO_H      sys/uio.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_TIME_H         time.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_FCNTL_H        fcntl.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_UNISTD_H       unistd.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_WINSOCK2_H     winsock2.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_WS2TCPIP_H     ws2tcpip.h)
+CARES_EXTRAINCLUDE_IFSET (HAVE_WINDOWS_H      windows.h)
+
+# Check Types
+# CHECK_TYPE_SIZE can't be used to see if a type exists because on Apple when
+# building multi-arch, it will throw an error.  So we need to wrap
+# CHECK_C_SOURCE_COMPILES for our tests.
+MACRO (CARES_TYPE_EXISTS type var)
+	SET(_CARES_C_SOURCE "
+		#include <stdio.h>
+		#include <stdlib.h>
+	")
+	FOREACH(_C_HEADER ${CMAKE_EXTRA_INCLUDE_FILES})
+		SET(_CARES_C_SOURCE "${_CARES_C_SOURCE}
+		#include <${_C_HEADER}>")
+	ENDFOREACH(_C_HEADER)
+
+	SET(_CARES_C_SOURCE "${_CARES_C_SOURCE}
+		int main() {
+			${type} var_exists;
+			(void)var_exists;
+			return 0;
+		}
+	")
+	CHECK_C_SOURCE_COMPILES ("${_CARES_C_SOURCE}" ${var})
+ENDMACRO ()
+
+CARES_TYPE_EXISTS (socklen_t                 HAVE_SOCKLEN_T)
+CARES_TYPE_EXISTS (SOCKET                    HAVE_TYPE_SOCKET)
+CARES_TYPE_EXISTS (bool                      HAVE_BOOL_T)
+CARES_TYPE_EXISTS (ssize_t                   HAVE_SSIZE_T)
+CARES_TYPE_EXISTS ("long long"               HAVE_LONGLONG)
+CARES_TYPE_EXISTS (sig_atomic_t              HAVE_SIG_ATOMIC_T)
+CARES_TYPE_EXISTS ("struct addrinfo"         HAVE_STRUCT_ADDRINFO)
+CARES_TYPE_EXISTS ("struct in6_addr"         HAVE_STRUCT_IN6_ADDR)
+CARES_TYPE_EXISTS ("struct sockaddr_in6"     HAVE_STRUCT_SOCKADDR_IN6)
+CARES_TYPE_EXISTS ("struct sockaddr_storage" HAVE_STRUCT_SOCKADDR_STORAGE)
+CARES_TYPE_EXISTS ("struct timeval"          HAVE_STRUCT_TIMEVAL)
+
+
+# Check for preprocessor defines
+CHECK_SYMBOL_EXISTS (AF_INET6        "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_AF_INET6)
+CHECK_SYMBOL_EXISTS (O_NONBLOCK      "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_O_NONBLOCK)
+CHECK_SYMBOL_EXISTS (FIONBIO         "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_FIONBIO)
+CHECK_SYMBOL_EXISTS (SIOCGIFADDR     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_IOCTL_SIOCGIFADDR)
+CHECK_SYMBOL_EXISTS (MSG_NOSIGNAL    "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_MSG_NOSIGNAL)
+CHECK_SYMBOL_EXISTS (PF_INET6        "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_PF_INET6)
+CHECK_SYMBOL_EXISTS (SO_NONBLOCK     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_SO_NONBLOCK)
+
+# XCode v8 bug: iOS when targeting less than v10, or MacOS when targeting less than v10.12 will
+# say clock_gettime exists, it is a weak symbol that only exists in iOS10/MacOS10.12 and will
+# cause a crash at runtime when running on older versions.  Skip finding CLOCK_MONOTONIC on older
+# OS's.
+IF ((NOT APPLE) OR IOS_V10 OR MACOS_V1012)
+	CHECK_SYMBOL_EXISTS (CLOCK_MONOTONIC "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_CLOCK_GETTIME_MONOTONIC)
+ENDIF ()
+
+CHECK_STRUCT_HAS_MEMBER("struct sockaddr_in6" sin6_scope_id "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID LANGUAGE C)
+
+# Check for "LL" numeric suffix support
+CHECK_C_SOURCE_COMPILES ("int main() { int n=1234LL; return 0; }" HAVE_LL)
+
+
+CHECK_SYMBOL_EXISTS (bitncmp         "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_BITNCMP)
+CHECK_SYMBOL_EXISTS (closesocket     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_CLOSESOCKET)
+CHECK_SYMBOL_EXISTS (CloseSocket     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_CLOSESOCKET_CAMEL)
+CHECK_SYMBOL_EXISTS (connect         "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_CONNECT)
+CHECK_SYMBOL_EXISTS (fcntl           "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_FCNTL)
+CHECK_SYMBOL_EXISTS (freeaddrinfo    "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_FREEADDRINFO)
+CHECK_SYMBOL_EXISTS (getaddrinfo     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETADDRINFO)
+CHECK_SYMBOL_EXISTS (getenv          "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETENV)
+CHECK_SYMBOL_EXISTS (gethostbyaddr   "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETHOSTBYADDR)
+CHECK_SYMBOL_EXISTS (gethostbyname   "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETHOSTBYNAME)
+CHECK_SYMBOL_EXISTS (gethostname     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETHOSTNAME)
+CHECK_SYMBOL_EXISTS (getnameinfo     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETNAMEINFO)
+CHECK_SYMBOL_EXISTS (getservbyport_r "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETSERVBYPORT_R)
+CHECK_SYMBOL_EXISTS (getservbyname_r "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETSERVBYNAME_R)
+CHECK_SYMBOL_EXISTS (gettimeofday    "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_GETTIMEOFDAY)
+CHECK_SYMBOL_EXISTS (if_indextoname  "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_IF_INDEXTONAME)
+CHECK_SYMBOL_EXISTS (inet_net_pton   "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_INET_NET_PTON)
+IF (NOT WIN32)
+	# Disabled on Windows, because these functions are only really supported on Windows
+	# Vista or newer (_WIN32_WINNT >= 0x0600). Older versions of Windows may provide
+	# them as experimental non-working features, so we have to disable them manually.
+	CHECK_SYMBOL_EXISTS (inet_ntop       "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_INET_NTOP)
+	CHECK_SYMBOL_EXISTS (inet_pton       "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_INET_PTON)
+ENDIF ()
+CHECK_SYMBOL_EXISTS (ioctl           "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_IOCTL)
+CHECK_SYMBOL_EXISTS (ioctlsocket     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_IOCTLSOCKET)
+CHECK_SYMBOL_EXISTS (IoctlSocket     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_IOCTLSOCKET_CAMEL)
+CHECK_SYMBOL_EXISTS (recv            "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_RECV)
+CHECK_SYMBOL_EXISTS (recvfrom        "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_RECVFROM)
+CHECK_SYMBOL_EXISTS (send            "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_SEND)
+CHECK_SYMBOL_EXISTS (setsockopt      "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_SETSOCKOPT)
+CHECK_SYMBOL_EXISTS (socket          "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_SOCKET)
+CHECK_SYMBOL_EXISTS (strcasecmp      "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_STRCASECMP)
+CHECK_SYMBOL_EXISTS (strcmpi         "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_STRCMPI)
+CHECK_SYMBOL_EXISTS (strdup          "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_STRDUP)
+CHECK_SYMBOL_EXISTS (stricmp         "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_STRICMP)
+CHECK_SYMBOL_EXISTS (strncasecmp     "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_STRNCASECMP)
+CHECK_SYMBOL_EXISTS (strncmpi        "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_STRNCMPI)
+CHECK_SYMBOL_EXISTS (strnicmp        "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_STRNICMP)
+CHECK_SYMBOL_EXISTS (writev          "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_WRITEV)
+
+# On Android, the system headers may define __system_property_get(), but excluded
+# from libc.  We need to perform a link test instead of a header/symbol test.
+CHECK_FUNCTION_EXISTS (__system_property_get HAVE___SYSTEM_PROPERTY_GET)
+
+# Unset temporary data
+SET (CMAKE_EXTRA_INCLUDE_FILES)
+SET (CMAKE_REQUIRED_DEFINITIONS)
+SET (CMAKE_REQUIRED_LIBRARIES)
+
+
+find_file(CARES_RANDOM_FILE urandom /dev)
+mark_as_advanced(CARES_RANDOM_FILE)
+
+
+################################################################################
+# recv, recvfrom, send, getnameinfo, gethostname
+# ARGUMENTS AND RETURN VALUES
+#
+# The AutoTools build tries to be really thorough here.  So much so that it
+# takes forever.  We really don't want to do that.  Lets make some educated
+# guesses based on datatypes we have available, and for others, use some 'sane'
+# defaults.  This should be much quicker and nearly as accurate ... and even
+# if not, it probably won't matter in the least.
+
+IF (HAVE_SSIZE_T AND HAVE_SOCKLEN_T)
+	# If we have ssize_t and socklen_t, the API is usually sane and uses ssize_t and size_t for lengths
+	SET (RECVFROM_TYPE_RETV ssize_t)
+	SET (RECVFROM_TYPE_ARG3 size_t)
+ELSE ()
+	SET (RECVFROM_TYPE_RETV int)
+	SET (RECVFROM_TYPE_ARG3 int)
+ENDIF ()
+
+IF (HAVE_TYPE_SOCKET)
+	# If the SOCKET type is defined, it uses socket ... should be windows only
+	SET (RECVFROM_TYPE_ARG1 SOCKET)
+ELSE ()
+	SET (RECVFROM_TYPE_ARG1 int)
+ENDIF()
+
+IF (HAVE_SOCKLEN_T)
+	# If we have socklen_t the APIs pretty much always actually use it
+	SET (RECVFROM_TYPE_ARG6 "socklen_t *")
+	SET (GETNAMEINFO_TYPE_ARG2 socklen_t)
+	SET (GETNAMEINFO_TYPE_ARG46 socklen_t)
+ELSE ()
+	SET (RECVFROM_TYPE_ARG6 "int *")
+	SET (GETNAMEINFO_TYPE_ARG2 int)
+	SET (GETNAMEINFO_TYPE_ARG46 int)
+ENDIF ()
+
+IF (WIN32)
+	SET (RECV_TYPE_ARG2 "char *")
+ELSE ()
+	SET (RECV_TYPE_ARG2 "void *")
+ENDIF ()
+
+# Functions are typically consistent so the equivalent fields map ... equivalently
+SET (RECV_TYPE_RETV ${RECVFROM_TYPE_RETV})
+SET (SEND_TYPE_RETV ${RECVFROM_TYPE_RETV})
+SET (RECV_TYPE_ARG1 ${RECVFROM_TYPE_ARG1})
+SET (RECVFROM_TYPE_ARG2 ${RECV_TYPE_ARG2})
+SET (SEND_TYPE_ARG1 ${RECVFROM_TYPE_ARG1})
+SET (RECV_TYPE_ARG3 ${RECVFROM_TYPE_ARG3})
+SET (SEND_TYPE_ARG3 ${RECVFROM_TYPE_ARG3})
+SET (GETHOSTNAME_TYPE_ARG2 ${RECVFROM_TYPE_ARG3})
+
+# These should always be "sane" values to use always
+SET (RECVFROM_QUAL_ARG5 )
+SET (RECVFROM_TYPE_ARG4 int)
+SET (RECVFROM_TYPE_ARG5 "struct sockaddr *")
+SET (RECV_TYPE_ARG4 int)
+SET (GETNAMEINFO_TYPE_ARG1 "struct sockaddr *")
+SET (GETNAMEINFO_TYPE_ARG7 int)
+SET (SEND_TYPE_ARG2 "void *")
+SET (SEND_TYPE_ARG4 int)
+################################################################################
+
+
+# HAVE_CXX11  ??
+# HAVE_SIG_ATOMIC_T_VOLATILE  ??
+
+
+# Set a few variables by hand that C-Ares wants, logically, based on detection
+# data.
+
+IF (HAVE_SOCKLEN_T)
+	Set (CARES_TYPEOF_ARES_SOCKLEN_T "socklen_t")
+ELSE ()
+	Set (CARES_TYPEOF_ARES_SOCKLEN_T "int")
+ENDIF ()
+
+IF (HAVE_SSIZE_T)
+	Set (CARES_TYPEOF_ARES_SSIZE_T "ssize_t")
+ELSE ()
+	IF (WIN32)
+		IF ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+			Set (CARES_TYPEOF_ARES_SSIZE_T "__int64")
+		ELSE ()
+			Set (CARES_TYPEOF_ARES_SSIZE_T "int")
+		ENDIF ()
+	ELSE ()
+		Set (CARES_TYPEOF_ARES_SSIZE_T "long")
+	ENDIF ()
+ENDIF ()
+
+IF (HAVE_FCNTL AND HAVE_O_NONBLOCK)
+	SET (HAVE_FCNTL_O_NONBLOCK 1)
+ENDIF ()
+
+IF (HAVE_IOCTL AND HAVE_FIONBIO)
+	SET (HAVE_IOCTL_FIONBIO 1)
+ENDIF ()
+
+IF (HAVE_IOCTLSOCKET AND HAVE_FIONBIO)
+	SET (HAVE_IOCTLSOCKET_FIONBIO 1)
+ENDIF ()
+
+IF (HAVE_IOCTLSOCKET_CAMEL AND HAVE_FIONBIO)
+	SET (HAVE_IOCTLSOCKET_CAMEL_FIONBIO 1)
+ENDIF ()
+
+IF (HAVE_GETADDRINFO)
+	IF (CMAKE_SYSTEM_NAME STREQUAL "Darwin" OR
+		CMAKE_SYSTEM_NAME STREQUAL "HPUX" OR
+		CMAKE_SYSTEM_NAME STREQUAL "NetBSD" OR
+		CMAKE_SYSTEM_NAME STREQUAL "SunOS" OR
+		CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR
+		CMAKE_SYSTEM_NAME STREQUAL "AIX" OR
+		WIN32)
+			SET (HAVE_GETADDRINFO_THREADSAFE 1)
+	ENDIF ()
+ENDIF ()
+
+IF (HAVE_TIME_H AND HAVE_SYS_TIME_H)
+	SET (TIME_WITH_SYS_TIME 1)
+ENDIF ()
+
+IF (HAVE_GETSERVBYPORT_R)
+	# TODO : Should probably autodetect
+	IF (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+		SET (GETSERVBYPORT_R_ARGS 5)
+	ELSEIF (CMAKE_SYSTEM_NAME STREQUAL "AIX" OR
+		CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" OR
+		HAIKU)
+		SET (GETSERVBYPORT_R_ARGS 4)
+	ELSE ()
+		# Probably linux
+		SET (GETSERVBYPORT_R_ARGS 6)
+	ENDIF ()
+ENDIF ()
+
+IF (HAVE_GETSERVBYNAME_R)
+	# TODO : Should probably autodetect
+	IF (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+		SET (GETSERVBYNAME_R_ARGS 5)
+	ELSEIF (CMAKE_SYSTEM_NAME STREQUAL "AIX" OR
+		CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" OR
+		HAIKU)
+		SET (GETSERVBYNAME_R_ARGS 4)
+	ELSE ()
+		# Probably linux
+		SET (GETSERVBYNAME_R_ARGS 6)
+	ENDIF ()
+ENDIF ()
+
+# Set some aliases used for ares_build.h
+IF (HAVE_SYS_TYPES_H)
+	SET (CARES_HAVE_SYS_TYPES_H 1)
+ENDIF ()
+IF (HAVE_SYS_SOCKET_H)
+	SET (CARES_HAVE_SYS_SOCKET_H 1)
+ENDIF()
+IF (HAVE_WS2TCPIP_H)
+	SET (CARES_HAVE_WS2TCPIP_H 1)
+ENDIF()
+IF (HAVE_WINSOCK2_H)
+	SET (CARES_HAVE_WINSOCK2_H 1)
+ENDIF()
+IF (HAVE_WINDOWS_H)
+	SET (CARES_HAVE_WINDOWS_H 1)
+ENDIF()
+IF (HAVE_ARPA_NAMESER_H)
+	SET (CARES_HAVE_ARPA_NAMESER_H 1)
+ENDIF()
+IF (HAVE_ARPA_NAMESER_COMPAT_H)
+	SET (CARES_HAVE_ARPA_NAMESER_COMPAT_H 1)
+ENDIF()
+
+# Record toplevel CMakeLists.txt path
+set(CARES_TOPLEVEL_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+
+
+# TRANSFORM_MAKEFILE_INC
+#
+# This function consumes the "Makefile.inc" autotools file, and converts it into
+#  "Makefile.inc.cmake", a cmake include file; transforming this:
+#
+# CSOURCES = ares__close_sockets.c	\
+#   ares__get_hostent.c			\
+#   ares__read_line.c			\
+#   ...
+#
+#   into this:
+#
+# SET (CSOURCES
+# 	ares__close_sockets.c
+# 	ares__get_hostent.c
+# 	ares__read_line.c
+#	...
+function(TRANSFORM_MAKEFILE_INC INPUT_FILE OUTPUT_FILE)
+	file(READ ${INPUT_FILE} MAKEFILE_INC_TEXT)
+	string(REPLACE "$(top_srcdir)"   "\${PROJECT_SOURCE_DIR}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+	string(REPLACE "$(top_builddir)" "\${PROJECT_BINARY_DIR}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+
+	string(REGEX REPLACE "\\\\\n" "ß!ß" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+	string(REGEX REPLACE "([a-zA-Z_][a-zA-Z0-9_]*)[\t ]*=[\t ]*([^\n]*)" "SET(\\1 \\2)" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+	string(REPLACE "ß!ß" "\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+
+	string(REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace $() with ${}
+	string(REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace @@ with ${}, even if that may not be read by CMake scripts.
+	file(WRITE ${OUTPUT_FILE} ${MAKEFILE_INC_TEXT})
+endfunction()
+
+# Directory for includes
+ADD_SUBDIRECTORY (include)
+
+# Directory for lib and tools
+ADD_SUBDIRECTORY (src)
+
+# Docs
+ADD_SUBDIRECTORY (docs)
+
+# Tests
+IF (CARES_BUILD_TESTS OR CARES_BUILD_CONTAINER_TESTS)
+	ENABLE_TESTING ()
+	ADD_SUBDIRECTORY (test)
+ENDIF ()
+
+
+# Export targets
+IF (CARES_INSTALL)
+	SET (CMAKECONFIG_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
+	INCLUDE (CMakePackageConfigHelpers)
+	CONFIGURE_PACKAGE_CONFIG_FILE (${PROJECT_NAME}-config.cmake.in ${PROJECT_NAME}-config.cmake
+		INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR}
+		PATH_VARS CMAKE_INSTALL_INCLUDEDIR
+		NO_CHECK_REQUIRED_COMPONENTS_MACRO
+	)
+
+	WRITE_BASIC_PACKAGE_VERSION_FILE(${PROJECT_NAME}-config-version.cmake VERSION "${CARES_VERSION}" COMPATIBILITY SameMajorVersion)
+	INSTALL (EXPORT ${PROJECT_NAME}-targets COMPONENT Devel DESTINATION ${CMAKECONFIG_INSTALL_DIR} NAMESPACE ${PROJECT_NAME}::)
+	INSTALL (FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake" COMPONENT Devel DESTINATION ${CMAKECONFIG_INSTALL_DIR})
+
+	# pkgconfig support
+	IF (NOT CARES_SHARED)
+		SET (CPPFLAG_CARES_STATICLIB "-DCARES_STATICLIB")
+		FOREACH (LIB ${CARES_DEPENDENT_LIBS})
+			SET (CARES_PRIVATE_LIBS "${CARES_PRIVATE_LIBS} -l${LIB}")
+		ENDFOREACH ()
+	ENDIF ()
+	CONFIGURE_FILE("libcares.pc.cmake" "libcares.pc" @ONLY)
+	INSTALL (FILES "${CMAKE_CURRENT_BINARY_DIR}/libcares.pc" COMPONENT Devel DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+ENDIF ()
+
+
+# Legacy chain-building variables (provided for compatibility with old code).
+# Don't use these, external code should be updated to refer to the aliases directly (e.g., Cares::cares).
+SET (CARES_FOUND 1 CACHE INTERNAL "CARES LIBRARY FOUND")
+SET (CARES_LIBRARIES ${PROJECT_NAME}::cares CACHE INTERNAL "CARES LIBRARIES")
+
+
+IF (CARES_INSTALL)
+    # Package creation
+    set( CPACK_PACKAGE_NAME ${PROJECT_NAME} )
+    set( CPACK_PACKAGE_VENDOR "Daniel Stenberg" ) # Github project owner
+    set( CPACK_PACKAGE_DESCRIPTION_SUMMARY "A C library for asynchronous DNS requests" )
+    set( CPACK_PACKAGE_HOMEPAGE_URL "https://c-ares.org/" )
+    set( CPACK_PACKAGE_CONTACT      "https://c-ares.org/" )
+    set( CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR} )
+    set( CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR} )
+    set( CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH} )
+    set( CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH} )
+    set( CPACK_PACKAGE_INSTALL_DIRECTORY ${PROJECT_NAME} )
+    set( CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md" )
+    set( CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md" )
+
+    set( CPACK_COMPONENT_Library_DISPLAY_NAME "c-ares Library" )
+    set( CPACK_COMPONENT_Library_DESCRIPTION "The c-ares binary library." )
+    set( CPACK_COMPONENT_Library_REQUIRED 1 )
+    set( CPACK_COMPONENT_Devel_DISPLAY_NAME "c-ares Development Files" )
+    set( CPACK_COMPONENT_Devel_DESCRIPTION "Development files for compiling against c-ares." )
+    set( CPACK_COMPONENT_Devel_REQUIRED 0 )
+    IF (CARES_BUILD_TOOLS)
+        set( CPACK_COMPONENT_Tools_DISPLAY_NAME "c-ares Tools" )
+        set( CPACK_COMPONENT_Tools_DESCRIPTION "Tools for using c-ares." )
+        set( CPACK_COMPONENT_Tools_REQUIRED 0 )
+    ENDIF ()
+
+    if( ${CMAKE_SYSTEM_NAME} STREQUAL "Linux" )
+
+        if ( "${CPACK_PACKAGE_ARCHITECTURE}" STREQUAL "" )
+            # Note: the architecture should default to the local architecture, but it
+            # in fact comes up empty.  We call `uname -m` to ask the kernel instead.
+            EXECUTE_PROCESS( COMMAND uname -m COMMAND tr -d '\n' OUTPUT_VARIABLE CPACK_PACKAGE_ARCHITECTURE )
+        endif()
+
+        set( CPACK_INCLUDE_TOPLEVEL_DIRECTORY 1 )
+        set( CPACK_PACKAGE_RELEASE 1 )
+
+
+        # RPM - https://cmake.org/cmake/help/latest/cpack_gen/rpm.html
+        set( CPACK_RPM_PACKAGE_RELEASE ${CPACK_PACKAGE_RELEASE} )
+        set( CPACK_RPM_PACKAGE_ARCHITECTURE ${CPACK_PACKAGE_ARCHITECTURE} )
+        set( CPACK_RPM_PACKAGE_DESCRIPTION ${CPACK_PACKAGE_DESCRIPTION_SUMMARY} )
+        set( CPACK_RPM_PACKAGE_URL ${CPACK_PACKAGE_HOMEPAGE_URL} )
+        set( CPACK_RPM_PACKAGE_LICENSE "MIT" )
+        set( CPACK_RPM_COMPONENT_INSTALL 1 )
+        set( CPACK_RPM_COMPRESSION_TYPE "xz" )
+        set( CPACK_RPM_PACKAGE_AUTOPROV 1 )
+
+        set( CPACK_RPM_Library_PACKAGE_SUMMARY ${CPACK_COMPONENT_Library_DESCRIPTION} )
+        set( CPACK_RPM_Library_PACKAGE_ARCHITECTURE ${CPACK_RPM_PACKAGE_ARCHITECTURE} )
+        set( CPACK_RPM_Library_PACKAGE_NAME "libcares${CARES_LIB_VERSION_MAJOR}" )
+        set( CPACK_RPM_Library_FILE_NAME "RPM-DEFAULT" )
+
+        set( CPACK_RPM_Devel_PACKAGE_REQUIRES "cmake >= ${CMAKE_MINIMUM_REQUIRED_VERSION}, ${CPACK_RPM_Library_PACKAGE_NAME} >= ${CPACK_PACKAGE_VERSION}" )
+        set( CPACK_RPM_Devel_PACKAGE_SUMMARY ${CPACK_COMPONENT_Devel_DESCRIPTION} )
+        set( CPACK_RPM_Devel_PACKAGE_ARCHITECTURE ${CPACK_RPM_PACKAGE_ARCHITECTURE} )
+        set( CPACK_RPM_Devel_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-devel" )
+        set( CPACK_RPM_Devel_FILE_NAME "RPM-DEFAULT" )
+
+        IF (CARES_BUILD_TOOLS)
+            set( CPACK_RPM_Tools_PACKAGE_REQUIRES "${CPACK_RPM_Library_PACKAGE_NAME} >= ${CPACK_PACKAGE_VERSION}" )
+            set( CPACK_RPM_Tools_PACKAGE_SUMMARY ${CPACK_COMPONENT_Tools_DESCRIPTION} )
+            set( CPACK_RPM_Tools_PACKAGE_ARCHITECTURE ${CPACK_RPM_PACKAGE_ARCHITECTURE} )
+            set( CPACK_RPM_Tools_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-tools" )
+            set( CPACK_RPM_Tools_FILE_NAME "RPM-DEFAULT" )
+        ENDIF ()
+
+
+        # DEB - https://cmake.org/cmake/help/latest/cpack_gen/deb.html
+        set( CPACK_DEBIAN_PACKAGE_RELEASE ${CPACK_PACKAGE_RELEASE} )
+        set( CPACK_DEBIAN_PACKAGE_HOMEPAGE ${CPACK_PACKAGE_HOMEPAGE_URL} )
+        set( CPACK_DEB_COMPONENT_INSTALL 1 )
+        set( CPACK_DEBIAN_COMPRESSION_TYPE "xz")
+        set( CPACK_DEBIAN_PACKAGE_SHLIBDEPS 1 )
+
+        if ( ${CPACK_PACKAGE_ARCHITECTURE} STREQUAL "x86_64" )
+            set( CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64" )  # DEB doesn't always use the kernel's arch name
+        else()
+            set( CPACK_DEBIAN_PACKAGE_ARCHITECTURE ${CPACK_PACKAGE_ARCHITECTURE} )
+        endif()
+
+        set( CPACK_DEBIAN_FILE_NAME "DEB-DEFAULT" ) # Use default naming scheme
+
+        set( CPACK_DEBIAN_LIBRARY_PACKAGE_NAME ${CPACK_RPM_Library_PACKAGE_NAME} )
+
+        set( CPACK_DEBIAN_DEVEL_PACKAGE_DEPENDS "cmake (>= ${CMAKE_MINIMUM_REQUIRED_VERSION}), ${CPACK_DEBIAN_LIBRARY_PACKAGE_NAME} (>= ${CPACK_PACKAGE_VERSION})" )
+        set( CPACK_DEBIAN_DEVEL_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-dev" )
+
+        IF (CARES_BUILD_TOOLS)
+            set( CPACK_DEBIAN_TOOLS_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-tools" )
+            set( CPACK_DEBIAN_TOOLS_PACKAGE_SHLIBDEPS OFF ) # dpkg-shlibdeps can't find the libs we built
+            set( CPACK_DEBIAN_TOOLS_PACKAGE_DEPENDS "${CPACK_DEBIAN_LIBRARY_PACKAGE_NAME} (>= ${CPACK_PACKAGE_VERSION})" )
+        ENDIF ()
+
+    elseif( ${CMAKE_HOST_WIN32} )
+        set( CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL ON )
+        set( CPACK_NSIS_DISPLAY_NAME ${PROJECT_NAME} )
+        set( CPACK_NSIS_PACKAGE_NAME ${PROJECT_NAME} )
+        set( CPACK_NSIS_URL_INFO_ABOUT ${CPACK_PACKAGE_HOMEPAGE_URL} )
+    endif()
+
+    # This must always be last!
+    include( CPack )
+ENDIF ()
diff --git a/deps/cares/CONTRIBUTING.md b/deps/cares/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..a3b5194c78ad5f38b2d53998dba1028a18eed215
--- /dev/null
+++ b/deps/cares/CONTRIBUTING.md
@@ -0,0 +1,15 @@
+Contributing to c-ares
+======================
+
+To contribute patches to c-ares, please generate a GitHub pull request
+and follow these guidelines:
+
+ - Check that the Travis builds are green for your pull request.
+ - Please update the test suite to add a test case for any new functionality.
+ - Build the library with `./configure --enable-debug --enable-maintainer-mode` and
+   ensure there are no new warnings.
+
+To improve the chances of the c-ares maintainers responding to your request:
+
+ - Also send an email to the mailing list at `c-ares@lists.haxx.se` describing your change.
+ - To follow any associated discussion, please subscribe to the [mailing list](http://lists.haxx.se/listinfo/c-ares).
diff --git a/deps/cares/INSTALL.md b/deps/cares/INSTALL.md
new file mode 100644
index 0000000000000000000000000000000000000000..1e33ad7fd0eb029bfd91252cb1d5d6c34d4deda4
--- /dev/null
+++ b/deps/cares/INSTALL.md
@@ -0,0 +1,409 @@
+** This file is adapted from libcurl and not yet fully rewritten for c-ares! **
+
+```
+                          ___       __ _ _ __ ___  ___
+                         / __| ___ / _` | '__/ _ \/ __|
+                        | (_  |___| (_| | | |  __/\__ \
+                         \___|     \__,_|_|  \___||___/
+
+                                How To Compile
+```
+
+Installing Binary Packages
+==========================
+
+Lots of people download binary distributions of c-ares. This document
+does not describe how to install c-ares using such a binary package.
+This document describes how to compile, build and install c-ares from
+source code.
+
+Building from Git
+=================
+
+If you get your code off a Git repository rather than an official
+release tarball, see the [GIT-INFO](GIT-INFO) file in the root directory
+for specific instructions on how to proceed.
+
+In particular, if not using CMake you will need to run `./buildconf` (Unix) or
+`buildconf.bat` (Windows) to generate build files, and for the former
+you will need a local installation of Autotools.  If using CMake the steps are
+the same for both Git and official release tarballs.
+
+AutoTools Build
+===============
+
+### General Information, works on most Unix Platforms (Linux, FreeBSD, etc)
+
+A normal Unix installation is made in three or four steps (after you've
+unpacked the source archive):
+
+    ./configure
+    make
+    make install
+
+You probably need to be root when doing the last command.
+
+If you have checked out the sources from the git repository, read the
+[GIT-INFO](GIT_INFO) on how to proceed.
+
+Get a full listing of all available configure options by invoking it like:
+
+    ./configure --help
+
+If you want to install c-ares in a different file hierarchy than /usr/local,
+you need to specify that already when running configure:
+
+    ./configure --prefix=/path/to/c-ares/tree
+
+If you happen to have write permission in that directory, you can do `make
+install` without being root. An example of this would be to make a local
+install in your own home directory:
+
+    ./configure --prefix=$HOME
+    make
+    make install
+
+### More Options
+
+To force configure to use the standard cc compiler if both cc and gcc are
+present, run configure like
+
+    CC=cc ./configure
+    # or
+    env CC=cc ./configure
+
+To force a static library compile, disable the shared library creation
+by running configure like:
+
+    ./configure --disable-shared
+
+If you're a c-ares developer and use gcc, you might want to enable more
+debug options with the `--enable-debug` option.
+
+### Special Cases
+
+Some versions of uClibc require configuring with `CPPFLAGS=-D_GNU_SOURCE=1`
+to get correct large file support.
+
+The Open Watcom C compiler on Linux requires configuring with the variables:
+
+    ./configure CC=owcc AR="$WATCOM/binl/wlib" AR_FLAGS=-q \
+        RANLIB=/bin/true STRIP="$WATCOM/binl/wstrip" CFLAGS=-Wextra
+
+
+### CROSS COMPILE
+
+(This section was graciously brought to us by Jim Duey, with additions by
+Dan Fandrich)
+
+Download and unpack the c-ares package.
+
+`cd` to the new directory. (e.g. `cd c-ares-1.7.6`)
+
+Set environment variables to point to the cross-compile toolchain and call
+configure with any options you need.  Be sure and specify the `--host` and
+`--build` parameters at configuration time.  The following script is an
+example of cross-compiling for the IBM 405GP PowerPC processor using the
+toolchain from MonteVista for Hardhat Linux.
+
+```sh
+#! /bin/sh
+
+export PATH=$PATH:/opt/hardhat/devkit/ppc/405/bin
+export CPPFLAGS="-I/opt/hardhat/devkit/ppc/405/target/usr/include"
+export AR=ppc_405-ar
+export AS=ppc_405-as
+export LD=ppc_405-ld
+export RANLIB=ppc_405-ranlib
+export CC=ppc_405-gcc
+export NM=ppc_405-nm
+
+./configure --target=powerpc-hardhat-linux \
+     --host=powerpc-hardhat-linux \
+     --build=i586-pc-linux-gnu \
+     --prefix=/opt/hardhat/devkit/ppc/405/target/usr/local \
+     --exec-prefix=/usr/local
+```
+
+You may also need to provide a parameter like `--with-random=/dev/urandom`
+to configure as it cannot detect the presence of a random number
+generating device for a target system.  The `--prefix` parameter
+specifies where c-ares will be installed.  If `configure` completes
+successfully, do `make` and `make install` as usual.
+
+In some cases, you may be able to simplify the above commands to as
+little as:
+
+    ./configure --host=ARCH-OS
+
+
+### Cygwin (Windows)
+
+Almost identical to the unix installation. Run the configure script in the
+c-ares root with `sh configure`. Make sure you have the sh executable in
+`/bin/` or you'll see the configure fail toward the end.
+
+Run `make`
+
+
+### QNX
+
+(This section was graciously brought to us by David Bentham)
+
+As QNX is targeted for resource constrained environments, the QNX headers
+set conservative limits. This includes the `FD_SETSIZE` macro, set by default
+to 32. Socket descriptors returned within the c-ares library may exceed this,
+resulting in memory faults/SIGSEGV crashes when passed into `select(..)`
+calls using `fd_set` macros.
+
+A good all-round solution to this is to override the default when building
+c-ares, by overriding `CFLAGS` during configure, example:
+
+    # configure CFLAGS='-DFD_SETSIZE=64 -g -O2'
+
+
+### RISC OS
+
+The library can be cross-compiled using gccsdk as follows:
+
+    CC=riscos-gcc AR=riscos-ar RANLIB='riscos-ar -s' ./configure \
+         --host=arm-riscos-aof --without-random --disable-shared
+    make
+
+where `riscos-gcc` and `riscos-ar` are links to the gccsdk tools.
+You can then link your program with `c-ares/lib/.libs/libcares.a`.
+
+
+### Android
+
+Method using a configure cross-compile (tested with Android NDK r7b):
+
+  - prepare the toolchain of the Android NDK for standalone use; this can
+    be done by invoking the script:
+
+        ./tools/make-standalone-toolchain.sh
+
+    which creates a usual cross-compile toolchain. Lets assume that you put
+    this toolchain below `/opt` then invoke configure with something
+    like:
+
+    ```
+        export PATH=/opt/arm-linux-androideabi-4.4.3/bin:$PATH
+       ./configure --host=arm-linux-androideabi [more configure options]
+        make
+    ```
+  - if you want to compile directly from our GIT repo you might run into
+    this issue with older automake stuff:
+
+    ```
+        checking host system type...
+        Invalid configuration `arm-linux-androideabi':
+        system `androideabi' not recognized
+        configure: error: /bin/sh ./config.sub arm-linux-androideabi failed
+    ```
+    this issue can be fixed with using more recent versions of `config.sub`
+    and `config.guess` which can be obtained here:
+    http://git.savannah.gnu.org/gitweb/?p=config.git;a=tree
+    you need to replace your system-own versions which usually can be
+    found in your automake folder:
+    `find /usr -name config.sub`
+
+
+CMake builds
+============
+
+Current releases of c-ares introduce a CMake v3+ build system that has been
+tested on most platforms including Windows, Linux, FreeBSD, MacOS, AIX and
+Solaris.
+
+In the most basic form, building with CMake might look like:
+
+```sh
+cd /path/to/cmake/source
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local/cares ..
+make
+sudo make install
+```
+
+Options
+-------
+
+Options to CMake are passed on the command line using "-D${OPTION}=${VALUE}".
+The values defined are all boolean and take values like On, Off, True, False.
+
+* CARES_STATIC - Build the static library (off by default)
+* CARES_SHARED - Build the shared library (on by default)
+* CARES_INSTALL - Hook in installation, useful to disable if chain building
+* CARES_STATIC_PIC - Build the static library as position-independent (off by
+   default)
+
+
+Ninja
+-----
+
+Ninja is the next-generation build system meant for generators like CMake that
+heavily parallize builds.  Its use is very similar to the normal build:
+
+```sh
+cd /path/to/cmake/source
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local/cares -G "Ninja" ..
+ninja
+sudo ninja install
+```
+
+Windows MSVC Command Line
+-------------------------
+
+```
+cd \path\to\cmake\source
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=C:\cares -G "NMake Makefiles" ..
+nmake
+nmake install
+```
+
+Windows MinGW-w64 Command Line via MSYS
+---------------------------------------
+```
+cd \path\to\cmake\source
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=C:\cares -G "MSYS Makefiles" ..
+make
+make install
+```
+
+
+Platform-specific build systems
+===============================
+
+Win32
+-----
+
+### Building Windows DLLs and C run-time (CRT) linkage issues
+
+As a general rule, building a DLL with static CRT linkage is highly
+discouraged, and intermixing CRTs in the same app is something to
+avoid at any cost.
+
+Reading and comprehension of Microsoft Knowledge Base articles
+KB94248 and KB140584 is a must for any Windows developer. Especially
+important is full understanding if you are not going to follow the
+advice given above.
+
+ - [KB94248](http://support.microsoft.com/kb/94248/en-us) - How To Use the C Run-Time
+
+ - [KB140584](http://support.microsoft.com/kb/140584/en-us) - How to link with the correct C Run-Time (CRT) library
+
+ - [KB190799](http://msdn.microsoft.com/en-us/library/ms235460) - Potential Errors Passing CRT Objects Across DLL Boundaries
+
+If your app is misbehaving in some strange way, or it is suffering
+from memory corruption, before asking for further help, please try
+first to rebuild every single library your app uses as well as your
+app using the debug multithreaded dynamic C runtime.
+
+
+### MingW32
+
+Make sure that MinGW32's bin dir is in the search path, for example:
+
+    set PATH=c:\mingw32\bin;%PATH%
+
+then run 'make -f Makefile.m32' in the root dir.
+
+
+### MSVC 6 caveats
+
+If you use MSVC 6 it is required that you use the February 2003 edition PSDK:
+http://www.microsoft.com/msdownload/platformsdk/sdkupdate/psdk-full.htm
+
+
+### MSVC from command line
+
+Run the `vcvars32.bat` file to get a proper environment. The
+`vcvars32.bat` file is part of the Microsoft development environment and
+you may find it in `C:\Program Files\Microsoft Visual Studio\vc98\bin`
+provided that you installed Visual C/C++ 6 in the default directory.
+
+Further details in [README.msvc](README.msvc)
+
+
+### Important static c-ares usage note
+
+When building an application that uses the static c-ares library, you must
+add `-DCARES_STATICLIB` to your `CFLAGS`.  Otherwise the linker will look for
+dynamic import symbols.
+
+
+IBM OS/2
+--------
+
+Building under OS/2 is not much different from building under unix.
+You need:
+
+  - emx 0.9d
+  - GNU make
+  - GNU patch
+  - ksh
+  - GNU bison
+  - GNU file utilities
+  - GNU sed
+  - autoconf 2.13
+
+If during the linking you get an error about `_errno` being an undefined
+symbol referenced from the text segment, you need to add `-D__ST_MT_ERRNO__`
+in your definitions.
+
+If you're getting huge binaries, probably your makefiles have the `-g` in
+`CFLAGS`.
+
+
+NetWare
+-------
+
+To compile `libcares.a` / `libcares.lib` you need:
+
+ - either any gcc / nlmconv, or CodeWarrior 7 PDK 4 or later.
+ - gnu make and awk running on the platform you compile on;
+   native Win32 versions can be downloaded from:
+   http://www.gknw.net/development/prgtools/
+ - recent Novell LibC SDK available from:
+   http://developer.novell.com/ndk/libc.htm
+ - or recent Novell CLib SDK available from:
+   http://developer.novell.com/ndk/clib.htm
+
+Set a search path to your compiler, linker and tools; on Linux make
+sure that the var `OSTYPE` contains the string 'linux'; set the var
+`NDKBASE` to point to the base of your Novell NDK; and then type
+`make -f Makefile.netware` from the top source directory;
+
+
+PORTS
+=====
+
+This is a probably incomplete list of known hardware and operating systems
+that c-ares has been compiled for. If you know a system c-ares compiles and
+runs on, that isn't listed, please let us know!
+
+     - Alpha Tru64 v5.0 5.1
+     - ARM Android 1.5, 2.1, 2.3
+     - MIPS IRIX 6.2, 6.5
+     - Power AIX 3.2.5, 4.2, 4.3.1, 4.3.2, 5.1, 5.2
+     - i386 Linux 1.3, 2.0, 2.2, 2.3, 2.4, 2.6
+     - i386 Novell NetWare
+     - i386 Windows 95, 98, ME, NT, 2000, XP, 2003
+     - x86_64 Linux
+
+
+Useful URLs
+===========
+
+ - c-ares: https://c-ares.org/
+ - MingW: http://www.mingw.org/
+ - MinGW-w64: http://mingw-w64.sourceforge.net/
+ - OpenWatcom: http://www.openwatcom.org/
diff --git a/deps/cares/Makefile.Watcom b/deps/cares/Makefile.Watcom
new file mode 100644
index 0000000000000000000000000000000000000000..fa529a56edc8e1bb746a65b69f2712f5a7128c3b
--- /dev/null
+++ b/deps/cares/Makefile.Watcom
@@ -0,0 +1,164 @@
+#
+#  Watcom / OpenWatcom / Win32 makefile for cares.
+#  Quick hack by Guenter; comments to: /dev/nul
+#
+
+!ifndef %watcom
+!error WATCOM environment variable not set!
+!else
+SYS_INCL = -I$(%watcom)\h\nt -I$(%watcom)\h
+SYS_LIBS = $(%watcom)\lib386\nt;$(%watcom)\lib386
+!endif
+
+!ifdef %libname
+LIBNAME = $(%libname)
+!else
+LIBNAME	= cares
+!endif
+TARGETS = $(LIBNAME).dll $(LIBNAME)_imp.lib $(LIBNAME).lib
+DEMOS   = adig.exe ahost.exe acountry.exe
+
+CC = wcc386
+LD = wlink
+AR = wlib
+RC = wrc
+
+!ifdef __LOADDLL__
+!  loaddll wcc386  wccd386
+!  loaddll wpp386  wppd386
+!  loaddll wlib    wlibd
+!endif
+
+!if $(__VERSION__) < 1250
+RM = del /q /f 2>NUL
+!else
+RM = rm -f
+!endif
+MD = mkdir
+RD = rmdir /q /s 2>NUL
+CP = copy
+
+CFLAGS = -3r -mf -hc -zff -zgf -zq -zm -zc -s -fr=con -w2 -fpi -oilrtfm &
+         -wcd=201 -bt=nt -d+ -dWIN32 -dCARES_BUILDING_LIBRARY           &
+         -dNTDDI_VERSION=0x05010000 -I. $(SYS_INCL)
+
+LFLAGS = option quiet, map, caseexact, eliminate
+
+!ifdef %debug
+DEBUG  = -dDEBUG=1 -dDEBUGBUILD
+CFLAGS += -d3 $(DEBUG)
+LFLAGS += debug all
+!else
+CFLAGS += -d0
+!endif
+
+CFLAGS += -d_WIN32_WINNT=0x0600
+
+#
+# Change to suite.
+#
+!ifdef %use_watt32
+CFLAGS += -dWATT32 -I$(%watt_root)\inc
+!endif
+
+OBJ_BASE = WC_Win32.obj
+LINK_ARG = $(OBJ_BASE)\dyn\wlink.arg
+LIB_ARG  = $(OBJ_BASE)\stat\wlib.arg
+
+# In order to process Makefile.inc wmake must be called with -u switch!
+!ifneq __MAKEOPTS__ -u
+!error You MUST call wmake with the -u switch!
+!else
+!include Makefile.inc
+!endif
+
+OBJS = $(CSOURCES:.c=.obj)
+OBJS = $OBJ_DIR\$(OBJS: = $OBJ_DIR\)
+
+#
+# Use $(OBJS) as a template to generate $(OBJS_STAT) and $(OBJS_DYN).
+#
+OBJ_DIR    = $(OBJ_BASE)\stat
+OBJS_STAT  = $+ $(OBJS) $-
+
+OBJ_DIR    = $(OBJ_BASE)\dyn
+OBJS_DYN   = $+ $(OBJS) $-
+
+ARESBUILDH = ares_build.h
+RESOURCE   = $(OBJ_BASE)\dyn\cares.res
+
+all: $(ARESBUILDH) $(OBJ_BASE) $(TARGETS) $(DEMOS) .SYMBOLIC
+	@echo Welcome to cares
+
+$(OBJ_BASE):
+	-$(MD) $^@
+	-$(MD) $^@\stat
+	-$(MD) $^@\dyn
+	-$(MD) $^@\demos
+
+$(ARESBUILDH): .EXISTSONLY
+	$(CP) $^@.dist $^@
+
+$(LIBNAME).dll: $(OBJS_DYN) $(RESOURCE) $(LINK_ARG)
+	$(LD) name $^@ @$]@
+
+$(LIBNAME).lib: $(OBJS_STAT) $(LIB_ARG)
+	$(AR) -q -b -c $^@ @$]@
+
+adig.exe: $(OBJ_BASE)\demos\adig.obj $(OBJ_BASE)\demos\ares_getopt.obj $(LIBNAME).lib
+	$(LD) name $^@ system nt $(LFLAGS) file { $(OBJ_BASE)\demos\ares_getopt.obj $[@ } library $]@, ws2_32.lib
+
+ahost.exe: $(OBJ_BASE)\demos\ahost.obj $(OBJ_BASE)\demos\ares_getopt.obj $(LIBNAME).lib
+	$(LD) name $^@ system nt $(LFLAGS) file { $(OBJ_BASE)\demos\ares_getopt.obj $[@ } library $]@, ws2_32.lib
+
+acountry.exe: $(OBJ_BASE)\demos\acountry.obj $(OBJ_BASE)\demos\ares_getopt.obj $(LIBNAME).lib
+	$(LD) name $^@ system nt $(LFLAGS) file { $(OBJ_BASE)\demos\ares_getopt.obj $[@ } library $]@, ws2_32.lib
+
+clean: .SYMBOLIC
+	-$(RM) $(OBJS_STAT)
+	-$(RM) $(OBJS_DYN)
+	-$(RM) $(RESOURCE) $(LINK_ARG) $(LIB_ARG)
+
+vclean realclean: clean .SYMBOLIC
+	-$(RM) $(TARGETS) $(LIBNAME).map
+	-$(RM) $(DEMOS) $(DEMOS:.exe=.map)
+	-$(RD) $(OBJ_BASE)\stat
+	-$(RD) $(OBJ_BASE)\dyn
+	-$(RD) $(OBJ_BASE)\demos
+	-$(RD) $(OBJ_BASE)
+
+.ERASE
+$(RESOURCE): cares.rc .AUTODEPEND
+	$(RC) $(DEBUG) -q -r -zm -I..\include $(SYS_INCL) $[@ -fo=$^@
+
+.ERASE
+.c{$(OBJ_BASE)\dyn}.obj:
+	$(CC) $(CFLAGS) -bd $[@ -fo=$^@
+
+.ERASE
+.c{$(OBJ_BASE)\stat}.obj:
+	$(CC) $(CFLAGS) -DCARES_STATICLIB $[@ -fo=$^@
+
+.ERASE
+.c{$(OBJ_BASE)\demos}.obj:
+	$(CC) $(CFLAGS) -DCARES_STATICLIB $[@ -fo=$^@
+
+$(LINK_ARG): $(__MAKEFILES__)
+	%create $^@
+	@%append $^@ system nt dll
+	@%append $^@ file { $(OBJS_DYN) }
+	@%append $^@ option res=$(RESOURCE), implib=$(LIBNAME)_imp.lib 
+	@%append $^@ $(LFLAGS)
+	@%append $^@ libpath $(SYS_LIBS)
+#	@%append $^@ library clib3r.lib
+!ifdef %use_watt32
+	@%append $^@ library $(%watt_root)\lib\wattcpw_imp.lib
+!else
+	@%append $^@ library ws2_32.lib
+!endif
+
+$(LIB_ARG): $(__MAKEFILES__)
+	%create $^@
+	@for %f in ($(OBJS_STAT)) do @%append $^@ +- %f
+
+
diff --git a/deps/cares/Makefile.am b/deps/cares/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..eef3d3d160e455c16aa5e2e5ba50128aafbc6eea
--- /dev/null
+++ b/deps/cares/Makefile.am
@@ -0,0 +1,37 @@
+AUTOMAKE_OPTIONS = foreign nostdinc 1.9.6
+ACLOCAL_AMFLAGS = -I m4 --install
+
+MSVCFILES = msvc_ver.inc buildconf.bat
+
+# adig and ahost are just sample programs and thus not mentioned with the
+# regular sources and headers
+EXTRA_DIST = AUTHORS CHANGES README.cares $(man_MANS) RELEASE-NOTES	\
+ c-ares-config.cmake.in libcares.pc.cmake libcares.pc.in buildconf get_ver.awk \
+ maketgz TODO README.msvc $(MSVCFILES) INSTALL.md README.md LICENSE.md \
+ CMakeLists.txt Makefile.dj Makefile.m32 Makefile.netware Makefile.msvc \
+ Makefile.Watcom AUTHORS CONTRIBUTING.md SECURITY.md TODO
+
+
+CLEANFILES = $(PDFPAGES) $(HTMLPAGES)
+
+DISTCLEANFILES = include/ares_build.h
+
+DIST_SUBDIRS = include src test docs
+
+SUBDIRS = @BUILD_SUBDIRS@
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libcares.pc
+
+# where to install the c-ares headers
+libcares_ladir = $(includedir)
+
+
+# Make files named *.dist replace the file without .dist extension
+dist-hook:
+	find $(distdir) -name "*.dist" -exec rm {} \;
+	(distit=`find $(srcdir) -name "*.dist"`; \
+	for file in $$distit; do \
+	  strip=`echo $$file | sed -e s/^$(srcdir)// -e s/\.dist//`; \
+	  cp $$file $(distdir)$$strip; \
+	done)
diff --git a/deps/cares/Makefile.dj b/deps/cares/Makefile.dj
new file mode 100644
index 0000000000000000000000000000000000000000..a88aae219da93348f5ead6cdfcbcb2100984db74
--- /dev/null
+++ b/deps/cares/Makefile.dj
@@ -0,0 +1,102 @@
+#
+# c-ares Makefile for djgpp/gcc/Watt-32.
+#   By Gisle Vanem <gvanem@yahoo.no> 2004 - 2020.
+#
+include src/lib/Makefile.inc
+
+CSOURCES := $(addprefix src/lib/, $(CSOURCES))
+CSOURCES := $(filter-out src/lib/windows_port.c, $(CSOURCES))
+
+VPATH = src/lib src/tools
+
+#
+# Root directory for Waterloo tcp/ip.
+# WATT_ROOT should be set during Watt-32 install.
+#
+WATT32_ROOT = $(realpath $(WATT_ROOT))
+WATT32_LIB  = $(WATT32_ROOT)/lib/libwatt.a
+
+OBJ_DIR = djgpp
+
+CFLAGS = -g -O2 -I./include -I./src/lib \
+         -I$(WATT32_ROOT)/inc -Wall \
+         -DWATT32 -DHAVE_CONFIG_H   \
+         -Dselect=select_s
+
+LDFLAGS = -s
+
+ifeq ($(OS),Windows_NT)
+  #
+  # Windows hosted djgpp cross compiler. Get it from:
+  #   https://github.com/andrewwutw/build-djgpp/releases
+  #
+  DJ_PREFIX ?= c:/some-path/djgpp/bin/i586-pc-msdosdjgpp-
+  CC = $(DJ_PREFIX)gcc
+
+else
+  #
+  # The normal djgpp 'gcc' for MSDOS.
+  #
+  CC = gcc
+endif
+
+OBJECTS = $(addprefix $(OBJ_DIR)/, \
+            $(notdir $(CSOURCES:.c=.o)))
+
+GENERATED = src/lib/ares_config.h \
+            include/ares_build.h
+
+TARGETS = libcares.a acountry.exe adig.exe ahost.exe
+
+.SECONDARY: $(OBJ_DIR)/ares_getopt.o
+
+all: $(OBJ_DIR) $(GENERATED) $(TARGETS)
+	@echo Welcome to c-ares.
+
+libcares.a: $(OBJECTS)
+	ar rs $@ $(OBJECTS)
+
+src/lib/ares_config.h: src/lib/config-dos.h
+	cp --update $< $@
+
+include/ares_build.h: include/ares_build.h.dist
+	cp --update $< $@
+
+%.exe: src/tools/%.c $(OBJ_DIR)/ares_getopt.o libcares.a
+	$(call compile_and_link, $@, $^ $(WATT32_LIB))
+
+# Clean generated files and objects.
+#
+clean:
+	- rm -f depend.dj $(GENERATED) $(OBJ_DIR)/*.o
+	- rmdir $(OBJ_DIR)
+
+# Clean everything
+#
+realclean vclean: clean
+	- rm -f $(TARGETS) $(TARGETS:.exe=.map)
+
+$(OBJ_DIR):
+	- mkdir $@
+
+$(OBJ_DIR)/%.o: %.c
+	$(CC) $(CFLAGS) -o $@ -c $<
+	@echo
+
+define compile_and_link
+  $(CC) -o $(1) $(CFLAGS) $(LDFLAGS) -Wl,--print-map,--sort-common $(2) > $(1:.exe=.map)
+  @echo
+endef
+
+DEP_REPLACE = sed -e 's@\(.*\)\.o: @\n$$(OBJ_DIR)\/\1.o: @' \
+                  -e 's@$(WATT32_ROOT)@$$(WATT32_ROOT)@g'
+
+#
+# One may have to do 'make -f Makefile.dj clean' first in case
+# a foreign 'curl_config.h' is making trouble.
+#
+depend: $(GENERATED) Makefile.dj
+	$(CC) -MM $(CFLAGS) $(CSOURCES) | $(DEP_REPLACE) > depend.dj
+
+-include depend.dj
+
diff --git a/deps/cares/Makefile.in b/deps/cares/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..7d7b59eaa2dc37f9de920e67a6ddd47c030bd055
--- /dev/null
+++ b/deps/cares/Makefile.in
@@ -0,0 +1,938 @@
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2021 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = .
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_ac_append_to_file.m4 \
+	$(top_srcdir)/m4/ax_ac_print_to_file.m4 \
+	$(top_srcdir)/m4/ax_add_am_macro_static.m4 \
+	$(top_srcdir)/m4/ax_am_macros_static.m4 \
+	$(top_srcdir)/m4/ax_check_gnu_make.m4 \
+	$(top_srcdir)/m4/ax_code_coverage.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx_11.m4 \
+	$(top_srcdir)/m4/ax_file_escapes.m4 \
+	$(top_srcdir)/m4/ax_require_defined.m4 \
+	$(top_srcdir)/m4/cares-compilers.m4 \
+	$(top_srcdir)/m4/cares-confopts.m4 \
+	$(top_srcdir)/m4/cares-functions.m4 \
+	$(top_srcdir)/m4/cares-reentrant.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/xc-am-iface.m4 \
+	$(top_srcdir)/m4/xc-cc-check.m4 \
+	$(top_srcdir)/m4/xc-lt-iface.m4 \
+	$(top_srcdir)/m4/xc-translit.m4 \
+	$(top_srcdir)/m4/xc-val-flgs.m4 \
+	$(top_srcdir)/m4/zz40-xc-ovr.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
+	$(am__configure_deps) $(am__DIST_COMMON)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno config.status.lineno
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/src/lib/ares_config.h \
+	$(top_builddir)/include/ares_build.h
+CONFIG_CLEAN_FILES = libcares.pc
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+SOURCES =
+DIST_SOURCES =
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+	ctags-recursive dvi-recursive html-recursive info-recursive \
+	install-data-recursive install-dvi-recursive \
+	install-exec-recursive install-html-recursive \
+	install-info-recursive install-pdf-recursive \
+	install-ps-recursive install-recursive installcheck-recursive \
+	installdirs-recursive pdf-recursive ps-recursive \
+	tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(pkgconfigdir)"
+DATA = $(pkgconfig_DATA)
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
+  distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+  $(RECURSIVE_TARGETS) \
+  $(RECURSIVE_CLEAN_TARGETS) \
+  $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+	cscope distdir distdir-am dist dist-all distcheck
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/libcares.pc.in \
+	AUTHORS INSTALL.md NEWS README.md TODO compile config.guess \
+	config.sub depcomp install-sh ltmain.sh missing
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+distdir = $(PACKAGE)-$(VERSION)
+top_distdir = $(distdir)
+am__remove_distdir = \
+  if test -d "$(distdir)"; then \
+    find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
+      && rm -rf "$(distdir)" \
+      || { sleep 5 && rm -rf "$(distdir)"; }; \
+  else :; fi
+am__post_remove_distdir = $(am__remove_distdir)
+am__relativize = \
+  dir0=`pwd`; \
+  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+  sed_rest='s,^[^/]*/*,,'; \
+  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+  sed_butlast='s,/*[^/]*$$,,'; \
+  while test -n "$$dir1"; do \
+    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+    if test "$$first" != "."; then \
+      if test "$$first" = ".."; then \
+        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+      else \
+        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+        if test "$$first2" = "$$first"; then \
+          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+        else \
+          dir2="../$$dir2"; \
+        fi; \
+        dir0="$$dir0"/"$$first"; \
+      fi; \
+    fi; \
+    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+  done; \
+  reldir="$$dir2"
+DIST_ARCHIVES = $(distdir).tar.gz
+GZIP_ENV = --best
+DIST_TARGETS = dist-gzip
+# Exists only to be overridden by the user if desired.
+AM_DISTCHECK_DVI_TARGET = dvi
+distuninstallcheck_listfiles = find . -type f -print
+am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
+  | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
+distcleancheck_listfiles = find . -type f -print
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BUILD_SUBDIRS = @BUILD_SUBDIRS@
+CARES_CFLAG_EXTRAS = @CARES_CFLAG_EXTRAS@
+CARES_PRIVATE_LIBS = @CARES_PRIVATE_LIBS@
+CARES_RANDOM_FILE = @CARES_RANDOM_FILE@
+CARES_VERSION_INFO = @CARES_VERSION_INFO@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CFLAG_CARES_SYMBOL_HIDING = @CFLAG_CARES_SYMBOL_HIDING@
+CODE_COVERAGE_CFLAGS = @CODE_COVERAGE_CFLAGS@
+CODE_COVERAGE_CPPFLAGS = @CODE_COVERAGE_CPPFLAGS@
+CODE_COVERAGE_CXXFLAGS = @CODE_COVERAGE_CXXFLAGS@
+CODE_COVERAGE_ENABLED = @CODE_COVERAGE_ENABLED@
+CODE_COVERAGE_LIBS = @CODE_COVERAGE_LIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPPFLAG_CARES_STATICLIB = @CPPFLAG_CARES_STATICLIB@
+CSCOPE = @CSCOPE@
+CTAGS = @CTAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ETAGS = @ETAGS@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GCOV = @GCOV@
+GENHTML = @GENHTML@
+GREP = @GREP@
+HAVE_CXX11 = @HAVE_CXX11@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LCOV = @LCOV@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+ifGNUmake = @ifGNUmake@
+ifnGNUmake = @ifnGNUmake@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AUTOMAKE_OPTIONS = foreign nostdinc 1.9.6
+ACLOCAL_AMFLAGS = -I m4 --install
+MSVCFILES = msvc_ver.inc buildconf.bat
+
+# adig and ahost are just sample programs and thus not mentioned with the
+# regular sources and headers
+EXTRA_DIST = AUTHORS CHANGES README.cares $(man_MANS) RELEASE-NOTES	\
+ c-ares-config.cmake.in libcares.pc.cmake libcares.pc.in buildconf get_ver.awk \
+ maketgz TODO README.msvc $(MSVCFILES) INSTALL.md README.md LICENSE.md \
+ CMakeLists.txt Makefile.dj Makefile.m32 Makefile.netware Makefile.msvc \
+ Makefile.Watcom AUTHORS CONTRIBUTING.md SECURITY.md TODO
+
+CLEANFILES = $(PDFPAGES) $(HTMLPAGES)
+DISTCLEANFILES = include/ares_build.h
+DIST_SUBDIRS = include src test docs
+SUBDIRS = @BUILD_SUBDIRS@
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libcares.pc
+
+# where to install the c-ares headers
+libcares_ladir = $(includedir)
+all: all-recursive
+
+.SUFFIXES:
+am--refresh: Makefile
+	@:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
+	      $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    echo ' $(SHELL) ./config.status'; \
+	    $(SHELL) ./config.status;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	$(SHELL) ./config.status --recheck
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	$(am__cd) $(srcdir) && $(AUTOCONF)
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
+$(am__aclocal_m4_deps):
+libcares.pc: $(top_builddir)/config.status $(srcdir)/libcares.pc.in
+	cd $(top_builddir) && $(SHELL) ./config.status $@
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool config.lt
+install-pkgconfigDATA: $(pkgconfig_DATA)
+	@$(NORMAL_INSTALL)
+	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
+	  $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
+	done
+
+uninstall-pkgconfigDATA:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+#     (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+	@fail=; \
+	if $(am__make_keepgoing); then \
+	  failcom='fail=yes'; \
+	else \
+	  failcom='exit 1'; \
+	fi; \
+	dot_seen=no; \
+	target=`echo $@ | sed s/-recursive//`; \
+	case "$@" in \
+	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+	  *) list='$(SUBDIRS)' ;; \
+	esac; \
+	for subdir in $$list; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    dot_seen=yes; \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done; \
+	if test "$$dot_seen" = "no"; then \
+	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+	fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+	  include_option=--etags-include; \
+	  empty_fix=.; \
+	else \
+	  include_option=--include; \
+	  empty_fix=; \
+	fi; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test ! -f $$subdir/TAGS || \
+	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+	  fi; \
+	done; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscope: cscope.files
+	test ! -s cscope.files \
+	  || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
+clean-cscope:
+	-rm -f cscope.files
+cscope.files: clean-cscope cscopelist
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+	-rm -f cscope.out cscope.in.out cscope.po.out cscope.files
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	$(am__remove_distdir)
+	test -d "$(distdir)" || mkdir "$(distdir)"
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    $(am__make_dryrun) \
+	      || test -d "$(distdir)/$$subdir" \
+	      || $(MKDIR_P) "$(distdir)/$$subdir" \
+	      || exit 1; \
+	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+	    $(am__relativize); \
+	    new_distdir=$$reldir; \
+	    dir1=$$subdir; dir2="$(top_distdir)"; \
+	    $(am__relativize); \
+	    new_top_distdir=$$reldir; \
+	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+	    ($(am__cd) $$subdir && \
+	      $(MAKE) $(AM_MAKEFLAGS) \
+	        top_distdir="$$new_top_distdir" \
+	        distdir="$$new_distdir" \
+		am__remove_distdir=: \
+		am__skip_length_check=: \
+		am__skip_mode_fix=: \
+	        distdir) \
+	      || exit 1; \
+	  fi; \
+	done
+	$(MAKE) $(AM_MAKEFLAGS) \
+	  top_distdir="$(top_distdir)" distdir="$(distdir)" \
+	  dist-hook
+	-test -n "$(am__skip_mode_fix)" \
+	|| find "$(distdir)" -type d ! -perm -755 \
+		-exec chmod u+rwx,go+rx {} \; -o \
+	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
+	|| chmod -R a+r "$(distdir)"
+dist-gzip: distdir
+	tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz
+	$(am__post_remove_distdir)
+
+dist-bzip2: distdir
+	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
+	$(am__post_remove_distdir)
+
+dist-lzip: distdir
+	tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
+	$(am__post_remove_distdir)
+
+dist-xz: distdir
+	tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
+	$(am__post_remove_distdir)
+
+dist-zstd: distdir
+	tardir=$(distdir) && $(am__tar) | zstd -c $${ZSTD_CLEVEL-$${ZSTD_OPT--19}} >$(distdir).tar.zst
+	$(am__post_remove_distdir)
+
+dist-tarZ: distdir
+	@echo WARNING: "Support for distribution archives compressed with" \
+		       "legacy program 'compress' is deprecated." >&2
+	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
+	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+	$(am__post_remove_distdir)
+
+dist-shar: distdir
+	@echo WARNING: "Support for shar distribution archives is" \
+	               "deprecated." >&2
+	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
+	shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz
+	$(am__post_remove_distdir)
+
+dist-zip: distdir
+	-rm -f $(distdir).zip
+	zip -rq $(distdir).zip $(distdir)
+	$(am__post_remove_distdir)
+
+dist dist-all:
+	$(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
+	$(am__post_remove_distdir)
+
+# This target untars the dist file and tries a VPATH configuration.  Then
+# it guarantees that the distribution is self-contained by making another
+# tarfile.
+distcheck: dist
+	case '$(DIST_ARCHIVES)' in \
+	*.tar.gz*) \
+	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\
+	*.tar.bz2*) \
+	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
+	*.tar.lz*) \
+	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
+	*.tar.xz*) \
+	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
+	*.tar.Z*) \
+	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
+	*.shar.gz*) \
+	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\
+	*.zip*) \
+	  unzip $(distdir).zip ;;\
+	*.tar.zst*) \
+	  zstd -dc $(distdir).tar.zst | $(am__untar) ;;\
+	esac
+	chmod -R a-w $(distdir)
+	chmod u+w $(distdir)
+	mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
+	chmod a-w $(distdir)
+	test -d $(distdir)/_build || exit 0; \
+	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
+	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
+	  && am__cwd=`pwd` \
+	  && $(am__cd) $(distdir)/_build/sub \
+	  && ../../configure \
+	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
+	    $(DISTCHECK_CONFIGURE_FLAGS) \
+	    --srcdir=../.. --prefix="$$dc_install_base" \
+	  && $(MAKE) $(AM_MAKEFLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) $(AM_DISTCHECK_DVI_TARGET) \
+	  && $(MAKE) $(AM_MAKEFLAGS) check \
+	  && $(MAKE) $(AM_MAKEFLAGS) install \
+	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
+	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
+	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
+	        distuninstallcheck \
+	  && chmod -R a-w "$$dc_install_base" \
+	  && ({ \
+	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
+	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
+	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
+	  && rm -rf "$$dc_destdir" \
+	  && $(MAKE) $(AM_MAKEFLAGS) dist \
+	  && rm -rf $(DIST_ARCHIVES) \
+	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
+	  && cd "$$am__cwd" \
+	  || exit 1
+	$(am__post_remove_distdir)
+	@(echo "$(distdir) archives ready for distribution: "; \
+	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
+	  sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
+distuninstallcheck:
+	@test -n '$(distuninstallcheck_dir)' || { \
+	  echo 'ERROR: trying to run $@ with an empty' \
+	       '$$(distuninstallcheck_dir)' >&2; \
+	  exit 1; \
+	}; \
+	$(am__cd) '$(distuninstallcheck_dir)' || { \
+	  echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
+	  exit 1; \
+	}; \
+	test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
+	   || { echo "ERROR: files left after uninstall:" ; \
+	        if test -n "$(DESTDIR)"; then \
+	          echo "  (check DESTDIR support)"; \
+	        fi ; \
+	        $(distuninstallcheck_listfiles) ; \
+	        exit 1; } >&2
+distcleancheck: distclean
+	@if test '$(srcdir)' = . ; then \
+	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
+	  exit 1 ; \
+	fi
+	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
+	  || { echo "ERROR: files left in build directory after distclean:" ; \
+	       $(distcleancheck_listfiles) ; \
+	       exit 1; } >&2
+check-am: all-am
+check: check-recursive
+all-am: Makefile $(DATA)
+installdirs: installdirs-recursive
+installdirs-am:
+	for dir in "$(DESTDIR)$(pkgconfigdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+	-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-recursive
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-libtool \
+	distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am: install-pkgconfigDATA
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf $(top_srcdir)/autom4te.cache
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am: uninstall-pkgconfigDATA
+
+.MAKE: $(am__recursive_targets) install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
+	am--refresh check check-am clean clean-cscope clean-generic \
+	clean-libtool cscope cscopelist-am ctags ctags-am dist \
+	dist-all dist-bzip2 dist-gzip dist-hook dist-lzip dist-shar \
+	dist-tarZ dist-xz dist-zip dist-zstd distcheck distclean \
+	distclean-generic distclean-libtool distclean-tags \
+	distcleancheck distdir distuninstallcheck dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-man install-pdf install-pdf-am \
+	install-pkgconfigDATA install-ps install-ps-am install-strip \
+	installcheck installcheck-am installdirs installdirs-am \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags tags-am uninstall uninstall-am uninstall-pkgconfigDATA
+
+.PRECIOUS: Makefile
+
+
+# Make files named *.dist replace the file without .dist extension
+dist-hook:
+	find $(distdir) -name "*.dist" -exec rm {} \;
+	(distit=`find $(srcdir) -name "*.dist"`; \
+	for file in $$distit; do \
+	  strip=`echo $$file | sed -e s/^$(srcdir)// -e s/\.dist//`; \
+	  cp $$file $(distdir)$$strip; \
+	done)
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/deps/cares/Makefile.m32 b/deps/cares/Makefile.m32
new file mode 100644
index 0000000000000000000000000000000000000000..66d28b1c146761b4efda5ca89ad1f2d1b81c1113
--- /dev/null
+++ b/deps/cares/Makefile.m32
@@ -0,0 +1,77 @@
+#############################################################
+#
+## Makefile for building libcares.a with MingW32 (GCC-3.2)
+## Use: make -f Makefile.m32 [demos]
+##
+## Quick hack by Guenter; comments to: /dev/nul
+#
+########################################################
+## Nothing more to do below this line!
+
+LIB	= src/lib/libcares.a
+
+AR	= $(CROSSPREFIX)ar
+CC	= $(CROSSPREFIX)gcc
+LD	= $(CROSSPREFIX)gcc
+RANLIB	= $(CROSSPREFIX)ranlib
+#RM	= rm -f
+CP	= cp -afv
+
+CFLAGS	= $(CARES_CFLAG_EXTRAS) -O2 -Wall -I./include -I./src/lib -D_WIN32_WINNT=0x0600
+CFLAGS	+= -DCARES_STATICLIB
+LDFLAGS	= $(CARES_LDFLAG_EXTRAS) -s
+LIBS	= -lws2_32 -liphlpapi
+
+# Makefile.inc provides the CSOURCES and HHEADERS defines
+include src/lib/Makefile.inc
+
+OBJLIB	:= $(patsubst %.c,src/lib/%.o,$(strip $(CSOURCES)))
+
+
+$(LIB): $(OBJLIB)
+	$(AR) cru $@ $^
+	$(RANLIB) $@
+
+all: $(LIB) demos
+
+demos: src/tools/adig.exe src/tools/ahost.exe src/tools/acountry.exe
+
+tags:
+	etags *.[ch]
+
+%.exe: %.o src/tools/ares_getopt.o $(LIB)
+	$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
+
+$(OBJLIB): include/ares.h include/ares_dns.h include/ares_build.h
+
+.c.o:
+	$(CC) $(CFLAGS) -o $@ -c $<
+
+include/ares_build.h:
+	$(CP) include/ares_build.h.dist include/ares_build.h
+
+check:
+
+install:
+	${top_srcdir}/mkinstalldirs ${DESTDIR}${libdir}
+	${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}
+	${top_srcdir}/mkinstalldirs ${DESTDIR}${mandir}/man3
+	${INSTALL} -m 644 $(LIB) ${DESTDIR}${libdir}
+	${RANLIB} ${DESTDIR}${libdir}/$(LIB)
+	chmod u-w ${DESTDIR}${libdir}/$(LIB)
+	${INSTALL} -m 444 ${srcdir}/include/ares.h ${DESTDIR}${includedir}
+	${INSTALL} -m 444 ${srcdir}/include/ares_build.h ${DESTDIR}${includedir}
+	${INSTALL} -m 444 ${srcdir}/include/ares_rules.h ${DESTDIR}${includedir}
+	${INSTALL} -m 444 ${srcdir}/include/ares_version.h ${DESTDIR}${includedir}
+	(for man in $(MANPAGES); do \
+	   ${INSTALL} -m 444 ${srcdir}/$${man} ${DESTDIR}${mandir}/man3; \
+	done)
+
+clean:
+	$(RM) src/tools/ares_getopt.o $(OBJLIB) $(LIB) src/tools/adig.exe src/tools/ahost.exe src/tools/acountry.exe
+
+distclean: clean
+	$(RM) config.cache config.log config.status Makefile
+ifeq "$(wildcard include/ares_build.h.dist)" "include/ares_build.h.dist"
+	$(RM) include/ares_build.h
+endif
diff --git a/deps/cares/Makefile.msvc b/deps/cares/Makefile.msvc
new file mode 100644
index 0000000000000000000000000000000000000000..62cc48fb3b545f63a8c8b6d7b0efe06075983749
--- /dev/null
+++ b/deps/cares/Makefile.msvc
@@ -0,0 +1,491 @@
+
+# Copyright (C) 2009-2013 by Daniel Stenberg
+#
+# Permission to use, copy, modify, and distribute this
+# software and its documentation for any purpose and without
+# fee is hereby granted, provided that the above copyright
+# notice appear in all copies and that both that copyright
+# notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in
+# advertising or publicity pertaining to distribution of the
+# software without specific, written prior permission.
+# M.I.T. makes no representations about the suitability of
+# this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+
+# ------------------------------------------------------------------------------
+#
+# Makefile for building c-ares libraries and sample programs with MSVC.
+#
+# Usage: nmake /f makefile.msvc CFG=<config> <target>
+#
+# <config> must be one of: [ lib-release | lib-debug | dll-release | dll-debug }
+# <target> must be one of: [ ALL | c-ares | acountry | adig | ahost | clean }
+#
+# If a <target> other than ALL or clean is given, <config> becomes mandatory.
+#
+# If neither <config> nor <target> are specified this results in
+# all targets being built for all <config> c-ares library types.
+#
+# This makefile must be processed from the subdir where it is located.
+#
+# All results are generated below a subdirectory named msvcXXX.
+#
+# ------------------------------------------------------------------------------
+
+NAME = cares
+
+# ------------------------------------------------
+# c-ares static and dynamic libraries common base
+# file names for release and debug configurations
+# ------------------------------------------------
+
+STA_LIB_REL = lib$(NAME)
+DYN_LIB_REL = $(NAME)
+STA_LIB_DBG = $(STA_LIB_REL)d
+DYN_LIB_DBG = $(DYN_LIB_REL)d
+
+# -------------------------------------------
+# Base names for c-ares DLL import libraries
+# -------------------------------------------
+
+IMP_LIB_REL = $(DYN_LIB_REL)
+IMP_LIB_DBG = $(DYN_LIB_DBG)
+
+# --------------------------
+# Runtime library selection
+# --------------------------
+
+RTLIB  = /MD
+RTLIBD = /MDd
+
+!IF "$(RTLIBCFG)" == "static"
+RTLIB  = /MT
+RTLIBD = /MTd
+!ENDIF
+
+# --------------------------------------------------------
+# Define USE_WATT32 to 1 to use the Watt-32 tcp/ip stack,
+# otherwise Winsock tcp/ip stack will be used as default.
+# --------------------------------------------------------
+
+USE_WATT32 = 0
+
+# --------------------------------------------------------
+# Detect compiler version.
+# --------------------------------------------------------
+!INCLUDE .\msvc_ver.inc
+
+# ----------------------------------------------------
+# Verify that current subdir is the c-ares source one
+# ----------------------------------------------------
+
+!IF ! EXIST(.\src\lib\ares_init.c)
+!  MESSAGE Can not process Makefile.msvc from outside of c-ares source subdirectory.
+!  MESSAGE Change to the subdirectory where Makefile.msvc is found, and try again.
+!  ERROR   See previous message.
+!ENDIF
+
+# ------------------------------------------------------------------
+# Base subdir is the common root from which other subdirs will hang.
+# ------------------------------------------------------------------
+
+BASE_DIR = .\msvc
+
+# ----------------------------------------
+# Subdir holding sources for all projects
+# ----------------------------------------
+
+SRCDIR = .
+
+# -----------------------------
+# Default installation subdirs
+# -----------------------------
+
+!IFNDEF INSTALL_DIR
+INSTALL_DIR = .
+!ENDIF
+
+!IFNDEF INSTALL_DIR_LIB
+INSTALL_DIR_LIB = $(INSTALL_DIR)\lib
+!ENDIF
+
+!IFNDEF INSTALL_DIR_INC
+INSTALL_DIR_INC = $(INSTALL_DIR)\include
+!ENDIF
+
+# -------------------------
+# Configuration validation
+# -------------------------
+
+VALID_CFGSET = FALSE
+!IF "$(CFG)" == "lib-release" || "$(CFG)" == "lib-debug" || \
+    "$(CFG)" == "dll-release" || "$(CFG)" == "dll-debug"
+VALID_CFGSET = TRUE
+!ENDIF
+
+!IF "$(VALID_CFGSET)" == "FALSE" && "$(CFG)" != ""
+!  MESSAGE MSVC c-ares makefile
+!  MESSAGE
+!  MESSAGE Usage: nmake /f makefile.msvc CFG=<config> <target>
+!  MESSAGE
+!  MESSAGE <config> must be one of: [ lib-release | lib-debug | dll-release | dll-debug }
+!  MESSAGE <target> must be one of: [ ALL | c-ares | acountry | adig | ahost | clean }
+!  MESSAGE
+!  MESSAGE If a <target> other than ALL or clean is given, <config> becomes mandatory.
+!  MESSAGE
+!  MESSAGE If neither <config> nor <target> are specified this results in
+!  MESSAGE all targets being built for all <config> c-ares library types.
+!  MESSAGE
+!  ERROR Choose a valid configuration.
+!ENDIF
+
+# --------------------------------------------------------
+# Project subdirs independent of configuration being used
+# --------------------------------------------------------
+
+CARES_DIR = $(BASE_DIR)\cares
+PROG1_DIR = $(BASE_DIR)\acountry
+PROG2_DIR = $(BASE_DIR)\adig
+PROG3_DIR = $(BASE_DIR)\ahost
+
+# ---------------------------------------------------
+# Subdirs which are configuration dependent are only
+# defined when a valid configuration has been given.
+# ---------------------------------------------------
+
+!IF "$(VALID_CFGSET)" == "TRUE"
+CARES_OUTDIR = $(CARES_DIR)\$(CFG)
+PROG1_OUTDIR = $(PROG1_DIR)\$(CFG)
+PROG2_OUTDIR = $(PROG2_DIR)\$(CFG)
+PROG3_OUTDIR = $(PROG3_DIR)\$(CFG)
+CARES_OBJDIR = $(CARES_OUTDIR)\obj
+PROG1_OBJDIR = $(PROG1_OUTDIR)\obj
+PROG2_OBJDIR = $(PROG2_OUTDIR)\obj
+PROG3_OBJDIR = $(PROG3_OUTDIR)\obj
+!ELSE
+!UNDEF CARES_OUTDIR
+!UNDEF PROG1_OUTDIR
+!UNDEF PROG2_OUTDIR
+!UNDEF PROG3_OUTDIR
+!UNDEF CARES_OBJDIR
+!UNDEF PROG1_OBJDIR
+!UNDEF PROG2_OBJDIR
+!UNDEF PROG3_OBJDIR
+!ENDIF
+
+# -------------------------------------
+# Settings that depend on tcp/ip stack
+# -------------------------------------
+
+!IF "$(USE_WATT32)" == "1"
+CFLAGS  = /UWIN32 /DWATT32 /I$(WATT_ROOT)\inc
+EX_LIBS_REL = $(WATT_ROOT)\lib\wattcpvc_imp.lib
+EX_LIBS_DBG = $(WATT_ROOT)\lib\wattcpvc_imp_d.lib
+!ELSE
+CFLAGS  = /DWIN32 /D_WIN32_WINNT=0x0600
+EX_LIBS_REL = ws2_32.lib advapi32.lib kernel32.lib iphlpapi.lib
+EX_LIBS_DBG = ws2_32.lib advapi32.lib kernel32.lib iphlpapi.lib
+!ENDIF
+
+# -------------------------------------------------
+# Switches that depend on ancient compiler versions
+# -------------------------------------------------
+
+!IF $(CC_VERS_NUM) == 60
+PDB_NONE            = /pdb:none
+PDBTYPE_CONSOLIDATE = /pdbtype:consolidate
+!ELSE
+!UNDEF PDB_NONE
+!UNDEF PDBTYPE_CONSOLIDATE
+!ENDIF
+
+!IF $(CC_VERS_NUM) <= 70
+RT_ERROR_CHECKING = /GZ
+!ELSE
+RT_ERROR_CHECKING = /RTCsu
+!ENDIF
+
+# ----------------------------
+# Assorted commands and flags
+# ----------------------------
+
+CC_CMD_REL = cl.exe /nologo $(RTLIB) /DNDEBUG /O2
+CC_CMD_DBG = cl.exe /nologo $(RTLIBD) /D_DEBUG /Od /Zi $(RT_ERROR_CHECKING)
+CC_CFLAGS  = $(CFLAGS) /I.\src\lib /I.\include /W3 /EHsc /FD
+
+RC_CMD_REL = rc.exe /l 0x409 /d "NDEBUG"
+RC_CMD_DBG = rc.exe /l 0x409 /d "_DEBUG"
+
+LINK_CMD_LIB = link.exe /lib /nologo
+LINK_CMD_DLL = link.exe /dll /nologo /incremental:no /fixed:no
+LINK_CMD_EXE = link.exe /nologo /incremental:no /fixed:no /subsystem:console
+
+LINK_CMD_EXE_REL = $(LINK_CMD_EXE) /release $(PDB_NONE)
+LINK_CMD_EXE_DBG = $(LINK_CMD_EXE) /debug $(PDBTYPE_CONSOLIDATE)
+
+# ---------------------------------
+# Configuration dependent settings
+# ---------------------------------
+
+!IF "$(CFG)" == "lib-release"
+CARES_TARGET = $(STA_LIB_REL).lib
+CARES_CFLAGS = /DCARES_BUILDING_LIBRARY /DCARES_STATICLIB
+CARES_LFLAGS =
+SPROG_CFLAGS = /DCARES_STATICLIB
+SPROG_LFLAGS = /libpath:$(CARES_OUTDIR) $(EX_LIBS_REL) $(STA_LIB_REL).lib
+CARES_LINK   = $(LINK_CMD_LIB)
+SPROG_LINK   = $(LINK_CMD_EXE_REL)
+CC_CMD       = $(CC_CMD_REL)
+!ENDIF
+
+!IF "$(CFG)" == "lib-debug"
+CARES_TARGET = $(STA_LIB_DBG).lib
+CARES_CFLAGS = /DCARES_BUILDING_LIBRARY /DCARES_STATICLIB /DDEBUGBUILD
+CARES_LFLAGS =
+SPROG_CFLAGS = /DCARES_STATICLIB
+SPROG_LFLAGS = /libpath:$(CARES_OUTDIR) $(EX_LIBS_DBG) $(STA_LIB_DBG).lib
+CARES_LINK   = $(LINK_CMD_LIB)
+SPROG_LINK   = $(LINK_CMD_EXE_DBG)
+CC_CMD       = $(CC_CMD_DBG)
+!ENDIF
+
+!IF "$(CFG)" == "dll-release"
+CARES_TARGET = $(DYN_LIB_REL).dll
+CARES_CFLAGS = /DCARES_BUILDING_LIBRARY
+CARES_LFLAGS = /release $(EX_LIBS_REL) /implib:$(CARES_OUTDIR)\$(IMP_LIB_REL).lib $(PDB_NONE)
+SPROG_CFLAGS =
+SPROG_LFLAGS = /libpath:$(CARES_OUTDIR) $(EX_LIBS_REL) $(IMP_LIB_REL).lib
+CARES_LINK   = $(LINK_CMD_DLL)
+SPROG_LINK   = $(LINK_CMD_EXE_REL)
+CC_CMD       = $(CC_CMD_REL)
+USE_RES_FILE = TRUE
+RC_CMD       = $(RC_CMD_REL)
+!ENDIF
+
+!IF "$(CFG)" == "dll-debug"
+CARES_TARGET = $(DYN_LIB_DBG).dll
+CARES_CFLAGS = /DCARES_BUILDING_LIBRARY /DDEBUGBUILD
+CARES_LFLAGS = /debug $(EX_LIBS_DBG) /implib:$(CARES_OUTDIR)\$(IMP_LIB_DBG).lib /pdb:$(CARES_OUTDIR)\$(DYN_LIB_DBG).pdb $(PDBTYPE_CONSOLIDATE)
+SPROG_CFLAGS =
+SPROG_LFLAGS = /libpath:$(CARES_OUTDIR) $(EX_LIBS_DBG) $(IMP_LIB_DBG).lib
+CARES_LINK   = $(LINK_CMD_DLL)
+SPROG_LINK   = $(LINK_CMD_EXE_DBG)
+CC_CMD       = $(CC_CMD_DBG)
+USE_RES_FILE = TRUE
+RC_CMD       = $(RC_CMD_DBG)
+!ENDIF
+
+# --------------------------------------------
+# Makefile.inc provides lists of source files
+# --------------------------------------------
+
+!INCLUDE .\src\lib\Makefile.inc
+!INCLUDE .\src\tools\Makefile.inc
+
+# ----------------------------
+# Build lists of object files
+# ----------------------------
+
+!IF "$(VALID_CFGSET)" == "TRUE"
+
+!IF [ECHO CARES_OBJS=^$(CARES_OBJDIR)\$(CSOURCES: = $(CARES_OBJDIR^)\) > .\cares_objs.inc] == 0
+!INCLUDE .\cares_objs.inc
+!IF [DEL .\cares_objs.inc]
+!ENDIF
+!ELSE
+!ERROR Problem generating CARES_OBJS list.
+!ENDIF
+CARES_OBJS = $(CARES_OBJS:.c=.obj)
+!IF "$(USE_RES_FILE)" == "TRUE"
+CARES_OBJS = $(CARES_OBJS) $(CARES_OBJDIR)\cares.res
+!ENDIF
+
+!IF [ECHO PROG1_OBJS=^$(PROG1_OBJDIR)\$(SAMPLESOURCES: = $(PROG1_OBJDIR^)\) > .\prog1_objs.inc] == 0
+!INCLUDE .\prog1_objs.inc
+!IF [DEL .\prog1_objs.inc]
+!ENDIF
+!ELSE
+!ERROR Problem generating PROG1_OBJS list.
+!ENDIF
+PROG1_OBJS = $(PROG1_OBJS:.c=.obj)
+PROG1_OBJS = $(PROG1_OBJS:/=\)
+PROG1_OBJS = $(PROG1_OBJS) $(PROG1_OBJDIR)\acountry.obj
+
+!IF [ECHO PROG2_OBJS=^$(PROG2_OBJDIR)\$(SAMPLESOURCES: = $(PROG2_OBJDIR^)\) > .\prog2_objs.inc] == 0
+!INCLUDE .\prog2_objs.inc
+!IF [DEL .\prog2_objs.inc]
+!ENDIF
+!ELSE
+!ERROR Problem generating PROG2_OBJS list.
+!ENDIF
+PROG2_OBJS = $(PROG2_OBJS:.c=.obj)
+PROG2_OBJS = $(PROG2_OBJS:/=\)
+PROG2_OBJS = $(PROG2_OBJS) $(PROG2_OBJDIR)\adig.obj
+
+!IF [ECHO PROG3_OBJS=^$(PROG3_OBJDIR)\$(SAMPLESOURCES: = $(PROG3_OBJDIR^)\) > .\prog3_objs.inc] == 0
+!INCLUDE .\prog3_objs.inc
+!IF [DEL .\prog3_objs.inc]
+!ENDIF
+!ELSE
+!ERROR Problem generating PROG3_OBJS list.
+!ENDIF
+PROG3_OBJS = $(PROG3_OBJS:.c=.obj)
+PROG3_OBJS = $(PROG3_OBJS:/=\)
+PROG3_OBJS = $(PROG3_OBJS) $(PROG3_OBJDIR)\ahost.obj
+
+!ENDIF
+
+
+# --------------------------------
+# Only our custom inference rules
+# --------------------------------
+
+.SUFFIXES:
+.SUFFIXES: .c .rc
+
+{$(SRCDIR)\src\lib}.rc{$(CARES_OBJDIR)}.res:
+    $(RC_CMD) /Fo $@ $<
+
+{$(SRCDIR)\src\lib}.c{$(CARES_OBJDIR)}.obj:
+    $(CC_CMD) $(CC_CFLAGS) $(CARES_CFLAGS) /Fo$@ /Fd$(@D)\ /c $<
+
+{$(SRCDIR)\src\tools}.c{$(PROG1_OBJDIR)}.obj:
+    $(CC_CMD) $(CC_CFLAGS) $(SPROG_CFLAGS) /Fo$@ /Fd$(@D)\ /c $<
+
+{$(SRCDIR)\src\tools}.c{$(PROG2_OBJDIR)}.obj:
+    $(CC_CMD) $(CC_CFLAGS) $(SPROG_CFLAGS) /Fo$@ /Fd$(@D)\ /c $<
+
+{$(SRCDIR)\src\tools}.c{$(PROG3_OBJDIR)}.obj:
+    $(CC_CMD) $(CC_CFLAGS) $(SPROG_CFLAGS) /Fo$@ /Fd$(@D)\ /c $<
+
+# Hack Alert! we reference ../lib/ files in the Makefile.inc for tools as they
+# share some files with the library itself.  We need to hack around that here.
+
+{$(SRCDIR)\src\lib}.c{$(PROG1_OBJDIR)\..\lib}.obj:
+    $(CC_CMD) $(CC_CFLAGS) $(SPROG_CFLAGS) /Fo$(PROG1_OBJDIR)\$(@F) /Fd$(PROG1_OBJDIR)\ /c $<
+
+{$(SRCDIR)\src\lib}.c{$(PROG2_OBJDIR)\..\lib}.obj:
+    $(CC_CMD) $(CC_CFLAGS) $(SPROG_CFLAGS) /Fo$(PROG2_OBJDIR)\$(@F) /Fd$(PROG2_OBJDIR)\ /c $<
+
+{$(SRCDIR)\src\lib}.c{$(PROG3_OBJDIR)\..\lib}.obj:
+    $(CC_CMD) $(CC_CFLAGS) $(SPROG_CFLAGS) /Fo$(PROG3_OBJDIR)\$(@F) /Fd$(PROG3_OBJDIR)\ /c $<
+
+# ------------------------------------------------------------- #
+# ------------------------------------------------------------- #
+# Default target when no CFG library type has been specified,   #
+# results in building target ALL for all c-ares library types.  #
+# ------------------------------------------------------------- #
+# ------------------------------------------------------------- #
+
+!IF "$(VALID_CFGSET)" == "FALSE"
+
+ALL:
+    $(MAKE) /NOLOGO /f .\Makefile.msvc  CFG=lib-release  ALL
+    $(MAKE) /NOLOGO /f .\Makefile.msvc  CFG=lib-debug    ALL
+    $(MAKE) /NOLOGO /f .\Makefile.msvc  CFG=dll-release  ALL
+    $(MAKE) /NOLOGO /f .\Makefile.msvc  CFG=dll-debug    ALL
+
+clean:
+    @-RMDIR /S /Q $(BASE_DIR) >NUL 2>&1
+
+install:
+    @$(MAKE) /nologo /f .\Makefile.msvc  CFG=lib-release  install
+    @$(MAKE) /nologo /f .\Makefile.msvc  CFG=lib-debug    install
+    @$(MAKE) /nologo /f .\Makefile.msvc  CFG=dll-release  install
+    @$(MAKE) /nologo /f .\Makefile.msvc  CFG=dll-debug    install
+
+!ENDIF
+
+# ---------------------------------------------------------------------
+# Targets only available when a proper CFG library type has been given
+# ---------------------------------------------------------------------
+
+!IF "$(VALID_CFGSET)" == "TRUE"
+
+ALL: c-ares acountry adig ahost
+    @
+
+# $(HHEADERS) $(CSOURCES)
+c-ares: $(CARES_OBJDIR) $(CARES_OBJS) $(CARES_OUTDIR)
+    $(CARES_LINK) $(CARES_LFLAGS) /out:$(CARES_OUTDIR)\$(CARES_TARGET) $(CARES_OBJS)
+!   IF "$(USE_RES_FILE)" == "TRUE"
+    @if exist $(CARES_OUTDIR)\$(CARES_TARGET).manifest mt -nologo -manifest $(CARES_OUTDIR)\$(CARES_TARGET).manifest -outputresource:$(CARES_OUTDIR)\$(CARES_TARGET);2
+!   ENDIF
+
+# acountry.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+acountry: c-ares $(PROG1_OBJDIR) $(PROG1_OBJS) $(PROG1_OUTDIR)
+    $(SPROG_LINK) $(SPROG_LFLAGS) /out:$(PROG1_OUTDIR)\acountry.exe $(PROG1_OBJS:..\lib=)
+    @if exist $(PROG1_OUTDIR)\acountry.exe.manifest mt -nologo -manifest $(PROG1_OUTDIR)\acountry.exe.manifest -outputresource:$(PROG1_OUTDIR)\acountry.exe;1
+
+# adig.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+adig: c-ares  $(PROG2_OBJDIR) $(PROG2_OBJS) $(PROG2_OUTDIR)
+    $(SPROG_LINK) $(SPROG_LFLAGS) /out:$(PROG2_OUTDIR)\adig.exe $(PROG2_OBJS:..\lib=)
+    @if exist $(PROG2_OUTDIR)\adig.exe.manifest mt -nologo -manifest $(PROG2_OUTDIR)\adig.exe.manifest -outputresource:$(PROG2_OUTDIR)\adig.exe;1
+
+# ahost.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+ahost: c-ares $(PROG3_OBJDIR) $(PROG3_OBJS) $(PROG3_OUTDIR)
+    $(SPROG_LINK) $(SPROG_LFLAGS) /out:$(PROG3_OUTDIR)\ahost.exe $(PROG3_OBJS:..\lib=)
+    @if exist $(PROG3_OUTDIR)\ahost.exe.manifest mt -nologo -manifest $(PROG3_OUTDIR)\ahost.exe.manifest -outputresource:$(PROG3_OUTDIR)\ahost.exe;1
+
+$(CARES_OUTDIR): $(CARES_DIR)
+    @if not exist $(CARES_OUTDIR) mkdir $(CARES_OUTDIR)
+
+$(PROG1_OUTDIR): $(PROG1_DIR)
+    @if not exist $(PROG1_OUTDIR) mkdir $(PROG1_OUTDIR)
+
+$(PROG2_OUTDIR): $(PROG2_DIR)
+    @if not exist $(PROG2_OUTDIR) mkdir $(PROG2_OUTDIR)
+
+$(PROG3_OUTDIR): $(PROG3_DIR)
+    @if not exist $(PROG3_OUTDIR) mkdir $(PROG3_OUTDIR)
+
+$(CARES_OBJDIR): $(CARES_OUTDIR)
+    @if not exist $(CARES_OBJDIR) mkdir $(CARES_OBJDIR)
+
+$(PROG1_OBJDIR): $(PROG1_OUTDIR)
+    @if not exist $(PROG1_OBJDIR) mkdir $(PROG1_OBJDIR)
+
+$(PROG2_OBJDIR): $(PROG2_OUTDIR)
+    @if not exist $(PROG2_OBJDIR) mkdir $(PROG2_OBJDIR)
+
+$(PROG3_OBJDIR): $(PROG3_OUTDIR)
+    @if not exist $(PROG3_OBJDIR) mkdir $(PROG3_OBJDIR)
+
+clean:
+    @-RMDIR /S /Q $(CARES_OUTDIR) >NUL 2>&1
+    @-RMDIR /S /Q $(PROG1_OUTDIR) >NUL 2>&1
+    @-RMDIR /S /Q $(PROG2_OUTDIR) >NUL 2>&1
+    @-RMDIR /S /Q $(PROG3_OUTDIR) >NUL 2>&1
+
+install:
+    @if not exist $(CARES_OUTDIR)\$(CARES_TARGET) \
+        $(MAKE) /f .\Makefile.msvc CFG=$(CFG) c-ares
+    @if not exist "$(INSTALL_DIR)"     mkdir "$(INSTALL_DIR)"
+    @if not exist "$(INSTALL_DIR_LIB)" mkdir "$(INSTALL_DIR_LIB)"
+    @if not exist "$(INSTALL_DIR_INC)" mkdir "$(INSTALL_DIR_INC)"
+    @copy /y $(CARES_OUTDIR)\*.*              "$(INSTALL_DIR_LIB)" >NUL
+    @copy /y $(SRCDIR)\include\ares.h         "$(INSTALL_DIR_INC)" >NUL
+    @copy /y $(SRCDIR)\include\ares_build.h   "$(INSTALL_DIR_INC)" >NUL
+    @copy /y $(SRCDIR)\include\ares_rules.h   "$(INSTALL_DIR_INC)" >NUL
+    @copy /y $(SRCDIR)\include\ares_version.h "$(INSTALL_DIR_INC)" >NUL
+    @echo Installed c-ares $(CFG)
+
+!ENDIF
+
+$(BASE_DIR):
+    @if not exist $(BASE_DIR) mkdir $(BASE_DIR)
+
+$(CARES_DIR): $(BASE_DIR)
+    @if not exist $(CARES_DIR) mkdir $(CARES_DIR)
+
+$(PROG1_DIR): $(BASE_DIR)
+    @if not exist $(PROG1_DIR) mkdir $(PROG1_DIR)
+
+$(PROG2_DIR): $(BASE_DIR)
+    @if not exist $(PROG2_DIR) mkdir $(PROG2_DIR)
+
+$(PROG3_DIR): $(BASE_DIR)
+    @if not exist $(PROG3_DIR) mkdir $(PROG3_DIR)
+
+# End of Makefile.msvc
diff --git a/deps/cares/Makefile.netware b/deps/cares/Makefile.netware
new file mode 100644
index 0000000000000000000000000000000000000000..e1a8a5523ca07bdabb345699e254b7b648d7f494
--- /dev/null
+++ b/deps/cares/Makefile.netware
@@ -0,0 +1,430 @@
+#################################################################
+#
+## Makefile for building libcares (NetWare version - gnu make)
+## Use: make -f Makefile.netware
+##
+## Comments to: Guenter Knauf http://www.gknw.de/phpbb
+#
+#################################################################
+
+# Edit the path below to point to the base of your Novell NDK.
+ifndef NDKBASE
+NDKBASE	= c:/novell
+endif
+
+ifndef INSTDIR
+INSTDIR	= ../ares-$(LIBCARES_VERSION_STR)-bin-nw
+endif
+
+# Edit the vars below to change NLM target settings.
+TARGETS = adig.nlm ahost.nlm acountry.nlm
+LTARGET = libcares.$(LIBEXT)
+VERSION	= $(LIBCARES_VERSION)
+COPYR	= $(LIBCARES_COPYRIGHT_STR)
+DESCR	= cURL $(subst .def,,$(notdir $@)) $(LIBCARES_VERSION_STR) - http://curl.haxx.se
+MTSAFE	= YES
+STACK	= 64000
+SCREEN	= none
+#EXPORTS	=
+# Comment the line below if you dont want to load protected automatically.
+#LDRING	= 3
+
+# Edit the var below to point to your lib architecture.
+ifndef LIBARCH
+LIBARCH = LIBC
+endif
+
+# must be equal to NDEBUG or DEBUG
+ifndef DB
+DB	= NDEBUG
+endif
+# Optimization: -O<n> or debugging: -g
+ifeq ($(DB),NDEBUG)
+	OPT	= -O2
+	OBJDIR	= release
+else
+	OPT	= -g
+	OBJDIR	= debug
+endif
+
+# Include the version info retrieved from curlver.h
+-include $(OBJDIR)/version.inc
+
+# The following lines defines your compiler.
+ifdef CWFolder
+	METROWERKS = $(CWFolder)
+endif
+ifdef METROWERKS
+	# MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support
+	MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support/Metrowerks Support
+	CC = mwccnlm
+else
+	CC = gcc
+endif
+# a native win32 awk can be downloaded from here:
+# http://www.gknw.net/development/prgtools/awk-20070501.zip
+AWK	= awk
+YACC	= bison -y
+CP	= cp -afv
+MKDIR	= mkdir
+# RM	= rm -f
+# if you want to mark the target as MTSAFE you will need a tool for
+# generating the xdc data for the linker; here's a minimal tool:
+# http://www.gknw.net/development/prgtools/mkxdc.zip
+MPKXDC	= mkxdc
+
+# Global flags for all compilers
+CFLAGS	+= $(OPT) -D$(DB) -DNETWARE -DHAVE_CONFIG_H -nostdinc
+
+ifeq ($(CC),mwccnlm)
+LD	= mwldnlm
+LDFLAGS	= -nostdlib $(PRELUDE) $(OBJEXE) $(<:.def=.o) -o $@ -commandfile
+AR	= mwldnlm
+ARFLAGS	= -nostdlib -type library -o
+LIBEXT	= lib
+#RANLIB	=
+CFLAGS	+= -msgstyle gcc -gccinc -inline off -opt nointrinsics -proc 586
+CFLAGS	+= -relax_pointers
+#CFLAGS	+= -w on
+ifeq ($(LIBARCH),LIBC)
+	PRELUDE = $(SDK_LIBC)/imports/libcpre.o
+	CFLAGS += -align 4
+else
+	# PRELUDE = $(SDK_CLIB)/imports/clibpre.o
+	# to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
+	PRELUDE = "$(MWCW_PATH)/libraries/runtime/prelude.obj"
+	# CFLAGS += -include "$(MWCW_PATH)/headers/nlm_clib_prefix.h"
+	CFLAGS += -align 1
+endif
+else
+LD	= nlmconv
+LDFLAGS	= -T
+AR	= ar
+ARFLAGS	= -cq
+LIBEXT	= a
+RANLIB	= ranlib
+CFLAGS  += -m32
+CFLAGS  += -fno-builtin -fno-strict-aliasing
+ifeq ($(findstring gcc,$(CC)),gcc)
+CFLAGS  += -fpcc-struct-return
+endif
+CFLAGS  += -Wall # -pedantic
+ifeq ($(LIBARCH),LIBC)
+	PRELUDE = $(SDK_LIBC)/imports/libcpre.gcc.o
+else
+	# PRELUDE = $(SDK_CLIB)/imports/clibpre.gcc.o
+	# to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
+	# http://www.gknw.net/development/mk_nlm/gcc_pre.zip
+	PRELUDE = $(NDK_ROOT)/pre/prelude.o
+	CFLAGS += -include $(NDKBASE)/nlmconv/genlm.h
+endif
+endif
+
+NDK_ROOT = $(NDKBASE)/ndk
+SDK_CLIB = $(NDK_ROOT)/nwsdk
+SDK_LIBC = $(NDK_ROOT)/libc
+
+ifeq ($(LIBARCH),LIBC)
+	INCLUDES += -I$(SDK_LIBC)/include
+	# INCLUDES += -I$(SDK_LIBC)/include/nks
+	# INCLUDES += -I$(SDK_LIBC)/include/winsock
+	CFLAGS += -D_POSIX_SOURCE
+else
+	INCLUDES += -I$(SDK_CLIB)/include/nlm
+	# INCLUDES += -I$(SDK_CLIB)/include/nlm/obsolete
+	# INCLUDES += -I$(SDK_CLIB)/include
+endif
+
+CFLAGS	+= -I. $(INCLUDES)
+
+ifeq ($(MTSAFE),YES)
+	XDCOPT = -n
+endif
+ifeq ($(MTSAFE),NO)
+	XDCOPT = -u
+endif
+
+ifeq ($(findstring /sh,$(SHELL)),/sh)
+DL	= '
+#-include $(NDKBASE)/nlmconv/ncpfs.inc
+endif
+
+# Makefile.inc provides the CSOURCES and HHEADERS defines
+include Makefile.inc
+
+OBJLIB	:= $(patsubst %.c,$(OBJDIR)/%.o,$(strip $(CSOURCES)))
+OBJEXE	= $(OBJLIB) $(OBJDIR)/ares_getopt.o
+
+.PHONY: lib nlm prebuild dist install clean
+
+lib: prebuild $(LTARGET)
+
+nlm: prebuild $(TARGETS)
+
+prebuild: $(OBJDIR) ares_build.h $(OBJDIR)/version.inc ares_config.h
+
+install: $(INSTDIR) all
+	@$(CP) *.nlm $(INSTDIR)
+	@$(CP) ../CHANGES $(INSTDIR)
+	@$(CP) ../COPYING $(INSTDIR)
+	@$(CP) ../README $(INSTDIR)
+	@$(CP) ../RELEASE-NOTES $(INSTDIR)
+
+clean:
+	-$(RM) $(LTARGET) $(TARGETS) ares_config.h
+	-$(RM) -r $(OBJDIR)
+	-$(RM) -r arpa
+
+%.$(LIBEXT): $(OBJLIB)
+	@echo Creating $@
+	@-$(RM) $@
+	@$(AR) $(ARFLAGS) $@ $^
+ifdef RANLIB
+	@$(RANLIB) $@
+endif
+
+%.nlm: $(OBJDIR)/%.def $(OBJDIR)/%.o $(OBJDIR)/%.xdc $(OBJEXE)
+	@echo Linking $@
+	@-$(RM) $@
+	@$(LD) $(LDFLAGS) $<
+
+$(OBJDIR) $(INSTDIR):
+	@$(MKDIR) $@
+
+$(OBJDIR)/%.o: %.c
+#	@echo Compiling $<
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(OBJDIR)/version.inc: ares_version.h $(OBJDIR)
+	@echo Creating $@
+	@$(AWK) -f get_ver.awk $< > $@
+
+$(OBJDIR)/%.xdc: Makefile.netware
+	@echo Creating $@
+	@$(MPKXDC) $(XDCOPT) $@
+
+$(OBJDIR)/%.def: Makefile.netware
+	@echo Creating $@
+	@echo $(DL)# DEF file for linking with $(LD)$(DL) > $@
+	@echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@
+	@echo $(DL)# All your changes will be lost!!$(DL) >> $@
+	@echo $(DL)#$(DL) >> $@
+	@echo $(DL)copyright "$(COPYR)"$(DL) >> $@
+	@echo $(DL)description "$(DESCR)"$(DL) >> $@
+	@echo $(DL)version $(VERSION)$(DL) >> $@
+ifdef NLMTYPE
+	@echo $(DL)type $(NLMTYPE)$(DL) >> $@
+endif
+ifdef STACK
+	@echo $(DL)stack $(STACK)$(DL) >> $@
+endif
+ifdef SCREEN
+	@echo $(DL)screenname "$(SCREEN)"$(DL) >> $@
+else
+	@echo $(DL)screenname "DEFAULT"$(DL) >> $@
+endif
+ifeq ($(DB),DEBUG)
+	@echo $(DL)debug$(DL) >> $@
+endif
+	@echo $(DL)threadname "$^"$(DL) >> $@
+ifdef XDCOPT
+	@echo $(DL)xdcdata $(@:.def=.xdc)$(DL) >> $@
+endif
+ifeq ($(LDRING),0)
+	@echo $(DL)flag_on 16$(DL) >> $@
+endif
+ifeq ($(LDRING),3)
+	@echo $(DL)flag_on 512$(DL) >> $@
+endif
+ifeq ($(LIBARCH),CLIB)
+	@echo $(DL)start _Prelude$(DL) >> $@
+	@echo $(DL)exit _Stop$(DL) >> $@
+	@echo $(DL)import @$(SDK_CLIB)/imports/clib.imp$(DL) >> $@
+	@echo $(DL)import @$(SDK_CLIB)/imports/threads.imp$(DL) >> $@
+	@echo $(DL)import @$(SDK_CLIB)/imports/nlmlib.imp$(DL) >> $@
+	@echo $(DL)import @$(SDK_CLIB)/imports/socklib.imp$(DL) >> $@
+	@echo $(DL)module clib$(DL) >> $@
+else
+	@echo $(DL)flag_on 64$(DL) >> $@
+	@echo $(DL)pseudopreemption$(DL) >> $@
+	@echo $(DL)start _LibCPrelude$(DL) >> $@
+	@echo $(DL)exit _LibCPostlude$(DL) >> $@
+	@echo $(DL)check _LibCCheckUnload$(DL) >> $@
+	@echo $(DL)import @$(SDK_LIBC)/imports/libc.imp$(DL) >> $@
+	@echo $(DL)import @$(SDK_LIBC)/imports/netware.imp$(DL) >> $@
+	@echo $(DL)module libc$(DL) >> $@
+endif
+ifdef MODULES
+	@echo $(DL)module $(MODULES)$(DL) >> $@
+endif
+ifdef EXPORTS
+	@echo $(DL)export $(EXPORTS)$(DL) >> $@
+endif
+ifdef IMPORTS
+	@echo $(DL)import $(IMPORTS)$(DL) >> $@
+endif
+ifeq ($(LD),nlmconv)
+	@echo $(DL)input $(PRELUDE)$(DL) >> $@
+	@echo $(DL)input $(OBJEXE)$(DL) >> $@
+	@echo $(DL)input $(@:.def=.o)$(DL) >> $@
+	@echo $(DL)output $(notdir $(@:.def=.nlm))$(DL) >> $@
+endif
+
+ares_config.h: Makefile.netware
+	@echo Creating $@
+	@echo $(DL)/* $@ for NetWare target.$(DL) > $@
+	@echo $(DL)** Do not edit this file - it is created by make!$(DL) >> $@
+	@echo $(DL)** All your changes will be lost!!$(DL) >> $@
+	@echo $(DL)*/$(DL) >> $@
+	@echo $(DL)#ifndef NETWARE$(DL) >> $@
+	@echo $(DL)#error This $(notdir $@) is created for NetWare platform!$(DL) >> $@
+	@echo $(DL)#endif$(DL) >> $@
+	@echo $(DL)#define VERSION "$(LIBCARES_VERSION_STR)"$(DL) >> $@
+	@echo $(DL)#define PACKAGE_BUGREPORT "a suitable curl mailing list => http://curl.haxx.se/mail/"$(DL) >> $@
+ifeq ($(LIBARCH),CLIB)
+	@echo $(DL)#define OS "i586-pc-clib-NetWare"$(DL) >> $@
+	@echo $(DL)#define HAVE_STRICMP 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRNICMP 1$(DL) >> $@
+	@echo $(DL)#define NETDB_USE_INTERNET 1$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_ARG1 int$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_ARG2 char *$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_ARG3 int$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_ARG4 int$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_RETV int$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG1 int$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG2 char$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG3 int$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG4 int$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG5 struct sockaddr$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG6 int$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_RETV int$(DL) >> $@
+	@echo $(DL)#define SEND_QUAL_ARG2$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_ARG1 int$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_ARG2 char *$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_ARG3 int$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_ARG4 int$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_RETV int$(DL) >> $@
+else
+	@echo $(DL)#define OS "i586-pc-libc-NetWare"$(DL) >> $@
+	@echo $(DL)#define HAVE_DLFCN_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_DLOPEN 1$(DL) >> $@
+	@echo $(DL)#define HAVE_FTRUNCATE 1$(DL) >> $@
+	@echo $(DL)#define HAVE_GETTIMEOFDAY 1$(DL) >> $@
+	@echo $(DL)#define HAVE_INTTYPES_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_LONGLONG 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STDINT_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRCASECMP 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRLCAT 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRLCPY 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRTOLL 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SYS_PARAM_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SYS_SELECT_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_TERMIOS_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_AF_INET6 1$(DL) >> $@
+	@echo $(DL)#define HAVE_PF_INET6 1$(DL) >> $@
+	@echo $(DL)#define HAVE_FREEADDRINFO 1$(DL) >> $@
+	@echo $(DL)#define HAVE_GETADDRINFO 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRUCT_IN6_ADDR 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRUCT_SOCKADDR_IN6 1$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_ARG1 int$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_ARG2 void *$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_ARG3 size_t$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_ARG4 int$(DL) >> $@
+	@echo $(DL)#define RECV_TYPE_RETV ssize_t$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG1 int$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG2 void$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG3 size_t$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG4 int$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG5 struct sockaddr$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG6 size_t$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_RETV ssize_t$(DL) >> $@
+	@echo $(DL)#define RECVFROM_TYPE_ARG2_IS_VOID 1$(DL) >> $@
+	@echo $(DL)#define SEND_QUAL_ARG2$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_ARG1 int$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_ARG2 void *$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_ARG3 size_t$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_ARG4 int$(DL) >> $@
+	@echo $(DL)#define SEND_TYPE_RETV ssize_t$(DL) >> $@
+endif
+	@echo $(DL)#define HAVE_ARPA_INET_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_ASSERT_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_ERRNO_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_ERR_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_FCNTL_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_GETENV 1$(DL) >> $@
+	@echo $(DL)#define HAVE_GETHOSTBYADDR 1$(DL) >> $@
+	@echo $(DL)#define HAVE_GETHOSTBYNAME 1$(DL) >> $@
+	@echo $(DL)#define HAVE_GETHOSTNAME 1$(DL) >> $@
+	@echo $(DL)#define HAVE_GETPROTOBYNAME 1$(DL) >> $@
+	@echo $(DL)#define HAVE_GMTIME_R 1$(DL) >> $@
+	@echo $(DL)#define HAVE_INET_ADDR 1$(DL) >> $@
+	@echo $(DL)#define HAVE_IOCTL 1$(DL) >> $@
+	@echo $(DL)#define HAVE_IOCTL_FIONBIO 1$(DL) >> $@
+	@echo $(DL)#define HAVE_LIMITS_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_LL 1$(DL) >> $@
+	@echo $(DL)#define HAVE_LOCALTIME_R 1$(DL) >> $@
+	@echo $(DL)#define HAVE_MALLOC_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_NETINET_IN_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_RECV 1$(DL) >> $@
+	@echo $(DL)#define HAVE_RECVFROM 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SELECT 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SEND 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SETJMP_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SIGNAL 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SIGNAL_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SIG_ATOMIC_T 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SOCKET 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STDLIB_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRDUP 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRFTIME 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRING_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRSTR 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRUCT_ADDRINFO 1$(DL) >> $@
+	@echo $(DL)#define HAVE_STRUCT_TIMEVAL 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SYS_IOCTL_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SYS_STAT_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SYS_TIME_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_TIME_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_UNAME 1$(DL) >> $@
+	@echo $(DL)#define HAVE_UNISTD_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_UTIME 1$(DL) >> $@
+	@echo $(DL)#define HAVE_UTIME_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_WRITEV 1$(DL) >> $@
+	@echo $(DL)#define RETSIGTYPE void$(DL) >> $@
+	@echo $(DL)#define STDC_HEADERS 1$(DL) >> $@
+	@echo $(DL)#define TIME_WITH_SYS_TIME 1$(DL) >> $@
+ifdef NW_WINSOCK
+	@echo $(DL)#define HAVE_CLOSESOCKET 1$(DL) >> $@
+else
+	@echo $(DL)#define HAVE_SYS_TYPES_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SYS_SOCKET_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_SYS_SOCKIO_H 1$(DL) >> $@
+	@echo $(DL)#define HAVE_NETDB_H 1$(DL) >> $@
+endif
+	@echo $(DL)#ifdef __GNUC__$(DL) >> $@
+	@echo $(DL)#define HAVE_VARIADIC_MACROS_GCC 1$(DL) >> $@
+	@echo $(DL)#else$(DL) >> $@
+	@echo $(DL)#define HAVE_VARIADIC_MACROS_C99 1$(DL) >> $@
+	@echo $(DL)#endif$(DL) >> $@
+
+FORCE: ;
+
+ares_build.h: Makefile.netware FORCE
+	@echo Creating $@
+	@echo $(DL)/* $@ intended for NetWare target.$(DL) > $@
+	@echo $(DL)** Do not edit this file - it is created by make!$(DL) >> $@
+	@echo $(DL)** All your changes will be lost!!$(DL) >> $@
+	@echo $(DL)*/$(DL) >> $@
+	@echo $(DL)#ifndef NETWARE$(DL) >> $@
+	@echo $(DL)#error This $(notdir $@) is created for NetWare platform!$(DL) >> $@
+	@echo $(DL)#endif$(DL) >> $@
+	@echo $(DL)#ifndef __CARES_BUILD_H$(DL) >> $@
+	@echo $(DL)#define __CARES_BUILD_H$(DL) >> $@
+ifeq ($(LIBARCH),CLIB)
+	@echo $(DL)#define CARES_TYPEOF_ARES_SOCKLEN_T int$(DL) >> $@
+else
+	@echo $(DL)#define CARES_TYPEOF_ARES_SOCKLEN_T unsigned int$(DL) >> $@
+endif
+	@echo $(DL)typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;$(DL) >> $@
+	@echo $(DL)#endif /* __CARES_BUILD_H */$(DL) >> $@
diff --git a/deps/cares/README.cares b/deps/cares/README.cares
index 4dee46eabf8f4bf757c6e42f2e2f4db8acbdef0c..ec809ab948367c94208b354eebef2e569d096eb9 100644
--- a/deps/cares/README.cares
+++ b/deps/cares/README.cares
@@ -12,4 +12,4 @@ compatible with ares: a new name makes that more obvious to the public.
 The original libares was distributed at
 ftp://athena-dist.mit.edu:pub/ATHENA/ares (which seems to not be alive
 anymore).  A local copy of the original ares package is kept here:
-https://c-ares.haxx.se/download/ares-1.1.1.tar.gz
+https://c-ares.org/download/ares-1.1.1.tar.gz
diff --git a/deps/cares/README.md b/deps/cares/README.md
index 148338f9e18081df772ffa4a1e203a20a4a800c7..24a96c453dd0ff53af856ef0d0a753df94f3b83c 100644
--- a/deps/cares/README.md
+++ b/deps/cares/README.md
@@ -1,7 +1,7 @@
 c-ares
 ======
 
-[![Build Status](https://travis-ci.org/c-ares/c-ares.svg?branch=master)](https://travis-ci.org/c-ares/c-ares)
+[![Build Status](https://api.cirrus-ci.com/github/c-ares/c-ares.svg)](https://cirrus-ci.com/github/c-ares/c-ares)
 [![Windows Build Status](https://ci.appveyor.com/api/projects/status/aevgc5914tm72pvs/branch/master?svg=true)](https://ci.appveyor.com/project/c-ares/c-ares/branch/master)
 [![Coverage Status](https://coveralls.io/repos/c-ares/c-ares/badge.svg?branch=master&service=github)](https://coveralls.io/github/c-ares/c-ares?branch=master)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/291/badge)](https://bestpractices.coreinfrastructure.org/projects/291)
@@ -14,19 +14,19 @@ perform multiple DNS queries in parallel.  The primary examples of such
 applications are servers which communicate with multiple clients and programs
 with graphical user interfaces.
 
-The full source code is available in the ['c-ares' release archives](https://c-ares.haxx.se/download/),
-and in a git repository: http://github.com/c-ares/c-ares.  See the
+The full source code is available in the ['c-ares' release archives](https://c-ares.org/download/),
+and in a git repository: https://github.com/c-ares/c-ares.  See the
 [INSTALL.md](INSTALL.md) file for build information.
 
 If you find bugs, correct flaws, have questions or have comments in general in
 regard to c-ares (or by all means the original ares too), get in touch with us
-on the c-ares mailing list: http://cool.haxx.se/mailman/listinfo/c-ares
+on the c-ares mailing list: https://lists.haxx.se/listinfo/c-ares
 
 c-ares is of course distributed under the same MIT-style license as the
 original ares.
 
 You'll find all c-ares details and news here:
-        https://c-ares.haxx.se/
+        https://c-ares.org/
 
 
 Notes for c-ares hackers
diff --git a/deps/cares/RELEASE-NOTES b/deps/cares/RELEASE-NOTES
index a006ed4c964e71d54d1ea3e0b5b1c6d15688ed06..d095749deab951cf2ccf5bfda7119547ea40ebe7 100644
--- a/deps/cares/RELEASE-NOTES
+++ b/deps/cares/RELEASE-NOTES
@@ -1,79 +1,85 @@
-c-ares version 1.17.2
+c-ares version 1.18.1
+
+This is an urgent bugfix release for a regression made in 1.18.0.
+
+Bug fixes:
+ o ares_getaddrinfo() would return ai_addrlen of 16 for ipv6
+   adddresses rather than the sizeof(struct sockaddr_in6)
 
-This is a security and bugfix release.  It addresses a few security related
-issues along with various bugfixes mostly related to portability.
 
-Security:
- o NodeJS passes NULL for addr and 0 for addrlen to ares_parse_ptr_reply() on
-   systems where malloc(0) returns NULL.  This would cause a crash. [8]
- o When building c-ares with CMake, the RANDOM_FILE would not be set and
-   therefore downgrade to the less secure random number generator [12]
- o If ares_getaddrinfo() was terminated by an ares_destroy(), it would cause
-   a crash [13]
- o Crash in sortaddrinfo() if the list size equals 0 due to an unexpected
-   DNS response [14]
- o Expand number of escaped characters in DNS replies as per RFC1035 5.1 to
-   prevent spoofing [16], [17]
- o Perform validation on hostnames to prevent possible XSS due to applications
-   not performing valiation themselves [18]
+
+c-ares version 1.18.0
+
+This is a feature and bugfix release.  It addresses a couple of new feature
+requests as well as a couple of bug fixes.
 
 Changes:
- o Use non-blocking /dev/urandom for random data to prevent early startup
-   performance issues [5]
- o z/OS port [6]
- o ares_malloc(0) is now defined behavior (returns NULL) rather than
-   system-specific to catch edge cases [7]
+ o Add support for URI(Uniform Resource Identifier) records via
+   ares_parse_uri_reply() [1]
+ o Provide ares_nameser.h as a public interface as needed by NodeJS [5]
+ o Update URLs from c-ares.haxx.se to c-ares.org [9]
+ o During a domain search, treat ARES_ENODATA as ARES_NXDOMAIN so that the
+   search process will continue to the next domain in the search.  [11]
+ o Turn ares_gethostbyname() into a wrapper for ares_getaddrinfo() as they
+   followed very similar code paths and ares_gethostbyaddr() has some more
+   desirable features such as priority sorting and parallel queries for
+   AF_UNSPEC. [12]
+ o ares_getaddrinfo() now contains a name element in the address info
+   structure as the last element.  This is not an API or ABI break due to
+   the structure always being internally allocated and it being the last
+   element. [12]
+ o ares_parse_a_reply() and ares_parse_aaaa_reply() were nearly identical, those
+   now use the same helper functions for parsing rather than having their own
+   code. [12]
+ o RFC6761 Section 6.3 says "localhost" lookups need to be special cased to
+   return loopback addresses, and not forward queries to recursive dns servers.
+   On Windows this now returns all loopback addresses, on other systems it
+   returns 127.0.0.1 or ::1 always, and will never forward a request for
+   "localhost" to outside DNS servers. [13]
+ o Haiki: port [14]
 
 Bug fixes:
- o Fuzz testing files were not distributed with official archives [1]
- o Building tests should not force building of static libraries except on
-   Windows [2]
- o Windows builds of the tools would fail if built as static due to a missing
-   CARES_STATICLIB definition [3]
- o Relative headers must use double quotes to prevent pulling in a system
-   library [4]
- o Fix OpenBSD building by implementing portability updates for including
-   arpa/nameser.h [9]
- o Fix building out-of-tree for autotools [10]
- o Make install on MacOS/iOS with CMake was missing the bundle destination so
-   libraries weren't actually installed [11]
- o Fix retrieving DNS server configuration on MacOS and iOS if the configuration
-   did not include search domains [15]
- o ares_parse_a_reply and ares_parse_aaa_reply were erroneously using strdup()
-   instead of ares_strdup() [19]
-
+ o add build to .gitignore [2]
+ o z/OS minor update, add missing semicolon in ares_init.c [3]
+ o Fix building when latest ax_code_coverage.m4 is imported [4]
+ o Work around autotools 'error: too many loops' and other newer autotools
+   import related bugs.
+ o MinGW cross builds need advapi32 link as lower case [6]
+ o Cygwin build fix due to containing both socket.h and winsock2.h [7]
+ o ares_expand_name should allow underscores (_) as SRV records legitimately use
+   them [8]
+ o Allow '/' as a valid character for a returned name for CNAME in-addr.arpa
+   delegation [10]
+ o ares_getaddrinfo() was not honoring HOSTALIASES [12]
+ o ares_getaddrinfo() had some test cases disabled due to a bug in the test
+   framework itself which has now been resolved [12]
+ o Due to Travis-CI becoming unfriendly to open-source, Cirrus-CI has now been
+   brought online for automated unit testing.
 
 Thanks go to these friendly people for their efforts and contributions:
-  Anton Danielsson (@anton-danielsson)
+  Biswapriyo Nath (@Biswa96)
   Brad House (@bradh352)
+  Daniel Bevenius (@danbev)
   Daniel Stenberg (@bagder)
   Dhrumil Rana (@dhrumilrana)
-  František Dvořák (@valtri)
-  @halx99
-  Jay Freeman (@saurik)
-  Jean-pierre Cartal (@jeanpierrecartal)
-  Michael Kourlas
-  Philipp Jeitner
-  @vburdo
-(11 contributors)
+  Felix Yan (@felixonmars)
+  Jérôme Duval (@korli)
+  Martin Holeš (@martin-256)
+  Sinan Kaya
+(9 contributors)
 
 References to bug reports and discussions on issues:
- [1] = https://github.com/c-ares/c-ares/issues/379
- [2] = https://github.com/c-ares/c-ares/issues/380
- [3] = https://github.com/c-ares/c-ares/issues/384
- [4] = https://github.com/c-ares/c-ares/pull/386
- [5] = https://github.com/c-ares/c-ares/pull/391
- [6] = https://github.com/c-ares/c-ares/pull/390
- [7] = https://github.com/c-ares/c-ares/commit/485fb66
- [8] = https://github.com/c-ares/c-ares/issues/392
- [9] = https://github.com/c-ares/c-ares/issues/388
- [10] = https://github.com/c-ares/c-ares/pull/394
- [11] = https://github.com/c-ares/c-ares/pull/395
- [12] = https://github.com/c-ares/c-ares/pull/397
- [13] = https://github.com/c-ares/c-ares/commit/df94703
- [14] = https://github.com/c-ares/c-ares/pull/400
- [15] = https://github.com/c-ares/c-ares/pull/401
- [16] = https://github.com/c-ares/c-ares/commit/362f91d
- [17] = https://github.com/c-ares/c-ares/commit/44c009b
- [18] = https://github.com/c-ares/c-ares/commit/c9b6c60
- [19] = https://github.com/c-ares/c-ares/pull/408
+ [1] = https://github.com/c-ares/c-ares/pull/411
+ [2] = https://github.com/c-ares/c-ares/pull/410
+ [3] = https://github.com/c-ares/c-ares/pull/414
+ [4] = https://github.com/c-ares/c-ares/pull/418
+ [5] = https://github.com/c-ares/c-ares/pull/417
+ [6] = https://github.com/c-ares/c-ares/pull/420
+ [7] = https://github.com/c-ares/c-ares/pull/422
+ [8] = https://github.com/c-ares/c-ares/issues/424
+ [9] = https://github.com/c-ares/c-ares/issues/423
+ [10] = https://github.com/c-ares/c-ares/issues/427
+ [11] = https://github.com/c-ares/c-ares/issues/426
+ [12] = https://github.com/c-ares/c-ares/pull/428
+ [13] = https://github.com/c-ares/c-ares/pull/430
+ [14] = https://github.com/c-ares/c-ares/pull/431
diff --git a/deps/cares/SECURITY.md b/deps/cares/SECURITY.md
new file mode 100644
index 0000000000000000000000000000000000000000..2a04a8dbcc355724091d880bb3feaba51b0243e8
--- /dev/null
+++ b/deps/cares/SECURITY.md
@@ -0,0 +1,100 @@
+c-ares security
+===============
+
+This document is intended to provide guidance on how security vulnerabilities
+should be handled in the c-ares project.
+
+Publishing Information
+----------------------
+
+All known and public c-ares vulnerabilities will be listed on [the c-ares web
+site](https://c-ares.org/vulns.html).
+
+Security vulnerabilities should not be entered in the project's public bug
+tracker unless the necessary configuration is in place to limit access to the
+issue to only the reporter and the project's security team.
+
+Vulnerability Handling
+----------------------
+
+The typical process for handling a new security vulnerability is as follows.
+
+No information should be made public about a vulnerability until it is
+formally announced at the end of this process. That means, for example that a
+bug tracker entry must NOT be created to track the issue since that will make
+the issue public and it should not be discussed on the project's public
+mailing list. Also messages associated with any commits should not make any
+reference to the security nature of the commit if done prior to the public
+announcement.
+
+- The person discovering the issue, the reporter, reports the vulnerability
+  privately to `c-ares-security@haxx.se`. That's an email alias that reaches a
+  handful of selected and trusted people.
+
+- Messages that do not relate to the reporting or managing of an undisclosed
+  security vulnerability in c-ares are ignored and no further action is
+  required.
+
+- A person in the security team sends an e-mail to the original reporter to
+  acknowledge the report.
+
+- The security team investigates the report and either rejects it or accepts
+  it.
+
+- If the report is rejected, the team writes to the reporter to explain why.
+
+- If the report is accepted, the team writes to the reporter to let him/her
+  know it is accepted and that they are working on a fix.
+
+- The security team discusses the problem, works out a fix, considers the
+  impact of the problem and suggests a release schedule. This discussion
+  should involve the reporter as much as possible.
+
+- The release of the information should be "as soon as possible" and is most
+  often synced with an upcoming release that contains the fix. If the
+  reporter, or anyone else, thinks the next planned release is too far away
+  then a separate earlier release for security reasons should be considered.
+
+- Write a security advisory draft about the problem that explains what the
+  problem is, its impact, which versions it affects, solutions or
+  workarounds, when the release is out and make sure to credit all
+  contributors properly.
+
+- Request a CVE number from
+  [distros@openwall](http://oss-security.openwall.org/wiki/mailing-lists/distros)
+  when also informing and preparing them for the upcoming public security
+  vulnerability announcement - attach the advisory draft for information. Note
+  that 'distros' won't accept an embargo longer than 19 days.
+
+- Update the "security advisory" with the CVE number.
+
+- The security team commits the fix in a private branch. The commit message
+  should ideally contain the CVE number. This fix is usually also distributed
+  to the 'distros' mailing list to allow them to use the fix prior to the
+  public announcement.
+
+- At the day of the next release, the private branch is merged into the master
+  branch and pushed. Once pushed, the information is accessible to the public
+  and the actual release should follow suit immediately afterwards.
+
+- The project team creates a release that includes the fix.
+
+- The project team announces the release and the vulnerability to the world in
+  the same manner we always announce releases. It gets sent to the c-ares
+  mailing list and the oss-security mailing list.
+
+- The security web page on the web site should get the new vulnerability
+  mentioned.
+
+C-ARES-SECURITY (at haxx dot se)
+--------------------------------
+
+Who is on this list? There are a couple of criteria you must meet, and then we
+might ask you to join the list or you can ask to join it. It really isn't very
+formal. We basically only require that you have a long-term presence in the
+c-ares project and you have shown an understanding for the project and its way
+of working. You must've been around for a good while and you should have no
+plans in vanishing in the near future.
+
+We do not make the list of partipants public mostly because it tends to vary
+somewhat over time and a list somewhere will only risk getting outdated.
diff --git a/deps/cares/acinclude.m4 b/deps/cares/acinclude.m4
new file mode 100644
index 0000000000000000000000000000000000000000..c255198e5f452c039099d80c72f12f66a80e6190
--- /dev/null
+++ b/deps/cares/acinclude.m4
@@ -0,0 +1,1915 @@
+
+
+dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])
+dnl -------------------------------------------------
+dnl Use the C preprocessor to find out if the given object-style symbol
+dnl is defined and get its expansion. This macro will not use default
+dnl includes even if no INCLUDES argument is given. This macro will run
+dnl silently when invoked with three arguments. If the expansion would
+dnl result in a set of double-quoted strings the returned expansion will
+dnl actually be a single double-quoted string concatenating all them.
+
+AC_DEFUN([CURL_CHECK_DEF], [
+  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
+  AS_VAR_PUSHDEF([ac_Def], [curl_cv_def_$1])dnl
+  if test -z "$SED"; then
+    AC_MSG_ERROR([SED not set. Cannot continue without SED being set.])
+  fi
+  if test -z "$GREP"; then
+    AC_MSG_ERROR([GREP not set. Cannot continue without GREP being set.])
+  fi
+  ifelse($3,,[AC_MSG_CHECKING([for preprocessor definition of $1])])
+  tmp_exp=""
+  AC_PREPROC_IFELSE([
+    AC_LANG_SOURCE(
+ifelse($2,,,[$2])[[
+#ifdef $1
+CURL_DEF_TOKEN $1
+#endif
+    ]])
+  ],[
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[[ ]][[ ]]*//' 2>/dev/null | \
+      "$SED" 's/[["]][[ ]]*[["]]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "$1"; then
+      tmp_exp=""
+    fi
+  ])
+  if test -z "$tmp_exp"; then
+    AS_VAR_SET(ac_HaveDef, no)
+    ifelse($3,,[AC_MSG_RESULT([no])])
+  else
+    AS_VAR_SET(ac_HaveDef, yes)
+    AS_VAR_SET(ac_Def, $tmp_exp)
+    ifelse($3,,[AC_MSG_RESULT([$tmp_exp])])
+  fi
+  AS_VAR_POPDEF([ac_Def])dnl
+  AS_VAR_POPDEF([ac_HaveDef])dnl
+])
+
+
+dnl CURL_CHECK_DEF_CC (SYMBOL, [INCLUDES], [SILENT])
+dnl -------------------------------------------------
+dnl Use the C compiler to find out only if the given symbol is defined
+dnl or not, this can not find out its expansion. This macro will not use
+dnl default includes even if no INCLUDES argument is given. This macro
+dnl will run silently when invoked with three arguments.
+
+AC_DEFUN([CURL_CHECK_DEF_CC], [
+  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
+  ifelse($3,,[AC_MSG_CHECKING([for compiler definition of $1])])
+  AC_COMPILE_IFELSE([
+    AC_LANG_SOURCE(
+ifelse($2,,,[$2])[[
+int main (void)
+{
+#ifdef $1
+  return 0;
+#else
+  force compilation error
+#endif
+}
+    ]])
+  ],[
+    tst_symbol_defined="yes"
+  ],[
+    tst_symbol_defined="no"
+  ])
+  if test "$tst_symbol_defined" = "yes"; then
+    AS_VAR_SET(ac_HaveDef, yes)
+    ifelse($3,,[AC_MSG_RESULT([yes])])
+  else
+    AS_VAR_SET(ac_HaveDef, no)
+    ifelse($3,,[AC_MSG_RESULT([no])])
+  fi
+  AS_VAR_POPDEF([ac_HaveDef])dnl
+])
+
+
+dnl CARES_CHECK_LIB_XNET
+dnl -------------------------------------------------
+dnl Verify if X/Open network library is required.
+
+AC_DEFUN([CARES_CHECK_LIB_XNET], [
+  AC_MSG_CHECKING([if X/Open network library is required])
+  tst_lib_xnet_required="no"
+  AC_COMPILE_IFELSE([
+    AC_LANG_SOURCE([[
+int main (void)
+{
+#if defined(__hpux) && defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)
+  return 0;
+#elif defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)
+  return 0;
+#else
+  force compilation error
+#endif
+}
+    ]])
+  ],[
+    tst_lib_xnet_required="yes"
+    LIBS="$LIBS -lxnet"
+  ])
+  AC_MSG_RESULT([$tst_lib_xnet_required])
+])
+
+
+dnl CARES_CHECK_AIX_ALL_SOURCE
+dnl -------------------------------------------------
+dnl Provides a replacement of traditional AC_AIX with
+dnl an uniform behaviour across all autoconf versions,
+dnl and with our own placement rules.
+
+AC_DEFUN([CARES_CHECK_AIX_ALL_SOURCE], [
+  AH_VERBATIM([_ALL_SOURCE],
+    [/* Define to 1 if OS is AIX. */
+#ifndef _ALL_SOURCE
+#  undef _ALL_SOURCE
+#endif])
+  AC_BEFORE([$0], [AC_SYS_LARGEFILE])dnl
+  AC_BEFORE([$0], [CARES_CONFIGURE_REENTRANT])dnl
+  AC_MSG_CHECKING([if OS is AIX (to define _ALL_SOURCE)])
+  AC_EGREP_CPP([yes_this_is_aix],[
+#ifdef _AIX
+   yes_this_is_aix
+#endif
+  ],[
+    AC_MSG_RESULT([yes])
+    AC_DEFINE(_ALL_SOURCE)
+  ],[
+    AC_MSG_RESULT([no])
+  ])
+])
+
+
+dnl CURL_CHECK_HEADER_WINDOWS
+dnl -------------------------------------------------
+dnl Check for compilable and valid windows.h header
+
+AC_DEFUN([CURL_CHECK_HEADER_WINDOWS], [
+  AC_CACHE_CHECK([for windows.h], [ac_cv_header_windows_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+      ]],[[
+#if defined(__CYGWIN__) || defined(__CEGCC__)
+        HAVE_WINDOWS_H shall not be defined.
+#else
+        int dummy=2*WINVER;
+#endif
+      ]])
+    ],[
+      ac_cv_header_windows_h="yes"
+    ],[
+      ac_cv_header_windows_h="no"
+    ])
+  ])
+  case "$ac_cv_header_windows_h" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_WINDOWS_H, 1,
+        [Define to 1 if you have the windows.h header file.])
+      AC_DEFINE_UNQUOTED(WIN32_LEAN_AND_MEAN, 1,
+        [Define to avoid automatic inclusion of winsock.h])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_NATIVE_WINDOWS
+dnl -------------------------------------------------
+dnl Check if building a native Windows target
+
+AC_DEFUN([CURL_CHECK_NATIVE_WINDOWS], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
+  AC_CACHE_CHECK([whether build target is a native Windows one], [ac_cv_native_windows], [
+    if test "$ac_cv_header_windows_h" = "no"; then
+      ac_cv_native_windows="no"
+    else
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+        ]],[[
+#if defined(__MINGW32__) || defined(__MINGW32CE__) || \
+   (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64)))
+          int dummy=1;
+#else
+          Not a native Windows build target.
+#endif
+        ]])
+      ],[
+        ac_cv_native_windows="yes"
+      ],[
+        ac_cv_native_windows="no"
+      ])
+    fi
+  ])
+  AM_CONDITIONAL(DOING_NATIVE_WINDOWS, test "x$ac_cv_native_windows" = xyes)
+])
+
+
+dnl CURL_CHECK_HEADER_WINSOCK
+dnl -------------------------------------------------
+dnl Check for compilable and valid winsock.h header
+
+AC_DEFUN([CURL_CHECK_HEADER_WINSOCK], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
+  AC_CACHE_CHECK([for winsock.h], [ac_cv_header_winsock_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock.h>
+      ]],[[
+#if defined(__CYGWIN__) || defined(__CEGCC__)
+        HAVE_WINSOCK_H shall not be defined.
+#else
+        int dummy=WSACleanup();
+#endif
+      ]])
+    ],[
+      ac_cv_header_winsock_h="yes"
+    ],[
+      ac_cv_header_winsock_h="no"
+    ])
+  ])
+  case "$ac_cv_header_winsock_h" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_WINSOCK_H, 1,
+        [Define to 1 if you have the winsock.h header file.])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_HEADER_WINSOCK2
+dnl -------------------------------------------------
+dnl Check for compilable and valid winsock2.h header
+
+AC_DEFUN([CURL_CHECK_HEADER_WINSOCK2], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
+  AC_CACHE_CHECK([for winsock2.h], [ac_cv_header_winsock2_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock2.h>
+      ]],[[
+#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
+        HAVE_WINSOCK2_H shall not be defined.
+#else
+        int dummy=2*IPPROTO_ESP;
+#endif
+      ]])
+    ],[
+      ac_cv_header_winsock2_h="yes"
+    ],[
+      ac_cv_header_winsock2_h="no"
+    ])
+  ])
+  case "$ac_cv_header_winsock2_h" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_WINSOCK2_H, 1,
+        [Define to 1 if you have the winsock2.h header file.])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_HEADER_WS2TCPIP
+dnl -------------------------------------------------
+dnl Check for compilable and valid ws2tcpip.h header
+
+AC_DEFUN([CURL_CHECK_HEADER_WS2TCPIP], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
+  AC_CACHE_CHECK([for ws2tcpip.h], [ac_cv_header_ws2tcpip_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+      ]],[[
+#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
+        HAVE_WS2TCPIP_H shall not be defined.
+#else
+        int dummy=2*IP_PKTINFO;
+#endif
+      ]])
+    ],[
+      ac_cv_header_ws2tcpip_h="yes"
+    ],[
+      ac_cv_header_ws2tcpip_h="no"
+    ])
+  ])
+  case "$ac_cv_header_ws2tcpip_h" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_WS2TCPIP_H, 1,
+        [Define to 1 if you have the ws2tcpip.h header file.])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_HEADER_MALLOC
+dnl -------------------------------------------------
+dnl Check for compilable and valid malloc.h header,
+dnl and check if it is needed even with stdlib.h
+
+AC_DEFUN([CURL_CHECK_HEADER_MALLOC], [
+  AC_CACHE_CHECK([for malloc.h], [ac_cv_header_malloc_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <malloc.h>
+      ]],[[
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+      ]])
+    ],[
+      ac_cv_header_malloc_h="yes"
+    ],[
+      ac_cv_header_malloc_h="no"
+    ])
+  ])
+  if test "$ac_cv_header_malloc_h" = "yes"; then
+    AC_DEFINE_UNQUOTED(HAVE_MALLOC_H, 1,
+      [Define to 1 if you have the malloc.h header file.])
+    #
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <stdlib.h>
+      ]],[[
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+      ]])
+    ],[
+      curl_cv_need_header_malloc_h="no"
+    ],[
+      curl_cv_need_header_malloc_h="yes"
+    ])
+    #
+    case "$curl_cv_need_header_malloc_h" in
+      yes)
+        AC_DEFINE_UNQUOTED(NEED_MALLOC_H, 1,
+          [Define to 1 if you need the malloc.h header file even with stdlib.h])
+        ;;
+    esac
+  fi
+])
+
+
+dnl CURL_CHECK_HEADER_MEMORY
+dnl -------------------------------------------------
+dnl Check for compilable and valid memory.h header,
+dnl and check if it is needed even with stdlib.h for
+dnl memory related functions.
+
+AC_DEFUN([CURL_CHECK_HEADER_MEMORY], [
+  AC_CACHE_CHECK([for memory.h], [ac_cv_header_memory_h], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <memory.h>
+      ]],[[
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+      ]])
+    ],[
+      ac_cv_header_memory_h="yes"
+    ],[
+      ac_cv_header_memory_h="no"
+    ])
+  ])
+  if test "$ac_cv_header_memory_h" = "yes"; then
+    AC_DEFINE_UNQUOTED(HAVE_MEMORY_H, 1,
+      [Define to 1 if you have the memory.h header file.])
+    #
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <stdlib.h>
+      ]],[[
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+      ]])
+    ],[
+      curl_cv_need_header_memory_h="no"
+    ],[
+      curl_cv_need_header_memory_h="yes"
+    ])
+    #
+    case "$curl_cv_need_header_memory_h" in
+      yes)
+        AC_DEFINE_UNQUOTED(NEED_MEMORY_H, 1,
+          [Define to 1 if you need the memory.h header file even with stdlib.h])
+        ;;
+    esac
+  fi
+])
+
+
+dnl CURL_CHECK_FUNC_GETNAMEINFO
+dnl -------------------------------------------------
+dnl Test if the getnameinfo function is available,
+dnl and check the types of five of its arguments.
+dnl If the function succeeds HAVE_GETNAMEINFO will be
+dnl defined, defining the types of the arguments in
+dnl GETNAMEINFO_TYPE_ARG1, GETNAMEINFO_TYPE_ARG2,
+dnl GETNAMEINFO_TYPE_ARG46 and GETNAMEINFO_TYPE_ARG7,
+dnl and also defining the type qualifier of first
+dnl argument in GETNAMEINFO_QUAL_ARG1.
+
+AC_DEFUN([CURL_CHECK_FUNC_GETNAMEINFO], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/socket.h netdb.h)
+  #
+  AC_MSG_CHECKING([for getnameinfo])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getnameinfo])
+  ],[
+    AC_MSG_RESULT([yes])
+    curl_cv_getnameinfo="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    curl_cv_getnameinfo="no"
+  ])
+  #
+  if test "$curl_cv_getnameinfo" != "yes"; then
+    AC_MSG_CHECKING([deeper for getnameinfo])
+    AC_LINK_IFELSE([
+      AC_LANG_PROGRAM([[
+      ]],[[
+        getnameinfo();
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      curl_cv_getnameinfo="yes"
+    ],[
+      AC_MSG_RESULT([but still no])
+      curl_cv_getnameinfo="no"
+    ])
+  fi
+  #
+  if test "$curl_cv_getnameinfo" != "yes"; then
+    AC_MSG_CHECKING([deeper and deeper for getnameinfo])
+    AC_LINK_IFELSE([
+      AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#endif
+      ]],[[
+        getnameinfo(0, 0, 0, 0, 0, 0, 0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      curl_cv_getnameinfo="yes"
+    ],[
+      AC_MSG_RESULT([but still no])
+      curl_cv_getnameinfo="no"
+    ])
+  fi
+  #
+  if test "$curl_cv_getnameinfo" = "yes"; then
+    AC_CACHE_CHECK([types of arguments for getnameinfo],
+      [curl_cv_func_getnameinfo_args], [
+      curl_cv_func_getnameinfo_args="unknown"
+      for gni_arg1 in 'struct sockaddr *' 'const struct sockaddr *' 'void *'; do
+        for gni_arg2 in 'socklen_t' 'size_t' 'int'; do
+          for gni_arg46 in 'size_t' 'int' 'socklen_t' 'unsigned int' 'DWORD'; do
+            for gni_arg7 in 'int' 'unsigned int'; do
+              if test "$curl_cv_func_getnameinfo_args" = "unknown"; then
+                AC_COMPILE_IFELSE([
+                  AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#if (!defined(_WIN32_WINNT)) || (_WIN32_WINNT < 0x0501)
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0501
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#define GNICALLCONV WSAAPI
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#define GNICALLCONV
+#endif
+                    extern int GNICALLCONV getnameinfo($gni_arg1, $gni_arg2,
+                                           char *, $gni_arg46,
+                                           char *, $gni_arg46,
+                                           $gni_arg7);
+                  ]],[[
+                    $gni_arg2 salen=0;
+                    $gni_arg46 hostlen=0;
+                    $gni_arg46 servlen=0;
+                    $gni_arg7 flags=0;
+                    int res = getnameinfo(0, salen, 0, hostlen, 0, servlen, flags);
+                  ]])
+                ],[
+                  curl_cv_func_getnameinfo_args="$gni_arg1,$gni_arg2,$gni_arg46,$gni_arg7"
+                ])
+              fi
+            done
+          done
+        done
+      done
+    ]) # AC-CACHE-CHECK
+    if test "$curl_cv_func_getnameinfo_args" = "unknown"; then
+      AC_MSG_WARN([Cannot find proper types to use for getnameinfo args])
+      AC_MSG_WARN([HAVE_GETNAMEINFO will not be defined])
+    else
+      gni_prev_IFS=$IFS; IFS=','
+      set dummy `echo "$curl_cv_func_getnameinfo_args" | sed 's/\*/\*/g'`
+      IFS=$gni_prev_IFS
+      shift
+      #
+      gni_qual_type_arg1=$[1]
+      #
+      AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG2, $[2],
+        [Define to the type of arg 2 for getnameinfo.])
+      AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG46, $[3],
+        [Define to the type of args 4 and 6 for getnameinfo.])
+      AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG7, $[4],
+        [Define to the type of arg 7 for getnameinfo.])
+      #
+      prev_sh_opts=$-
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set -f
+          ;;
+      esac
+      #
+      case "$gni_qual_type_arg1" in
+        const*)
+          gni_qual_arg1=const
+          gni_type_arg1=`echo $gni_qual_type_arg1 | sed 's/^const //'`
+        ;;
+        *)
+          gni_qual_arg1=
+          gni_type_arg1=$gni_qual_type_arg1
+        ;;
+      esac
+      #
+      AC_DEFINE_UNQUOTED(GETNAMEINFO_QUAL_ARG1, $gni_qual_arg1,
+        [Define to the type qualifier of arg 1 for getnameinfo.])
+      AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG1, $gni_type_arg1,
+        [Define to the type of arg 1 for getnameinfo.])
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set +f
+          ;;
+      esac
+      #
+      AC_DEFINE_UNQUOTED(HAVE_GETNAMEINFO, 1,
+        [Define to 1 if you have the getnameinfo function.])
+      ac_cv_func_getnameinfo="yes"
+    fi
+  fi
+])
+
+
+dnl TYPE_SOCKADDR_STORAGE
+dnl -------------------------------------------------
+dnl Check for struct sockaddr_storage. Most IPv6-enabled
+dnl hosts have it, but AIX 4.3 is one known exception.
+
+AC_DEFUN([TYPE_SOCKADDR_STORAGE],
+[
+   AC_CHECK_TYPE([struct sockaddr_storage],
+        AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE, 1,
+                  [if struct sockaddr_storage is defined]), ,
+   [
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#endif
+   ])
+])
+
+
+dnl CURL_CHECK_NI_WITHSCOPEID
+dnl -------------------------------------------------
+dnl Check for working NI_WITHSCOPEID in getnameinfo()
+
+AC_DEFUN([CURL_CHECK_NI_WITHSCOPEID], [
+  AC_REQUIRE([CURL_CHECK_FUNC_GETNAMEINFO])dnl
+  AC_REQUIRE([TYPE_SOCKADDR_STORAGE])dnl
+  AC_CHECK_HEADERS(stdio.h sys/types.h sys/socket.h \
+                   netdb.h netinet/in.h arpa/inet.h)
+  #
+  AC_CACHE_CHECK([for working NI_WITHSCOPEID],
+    [ac_cv_working_ni_withscopeid], [
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_STDIO_H
+#include <stdio.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+      ]],[[
+#if defined(NI_WITHSCOPEID) && defined(HAVE_GETNAMEINFO)
+#ifdef HAVE_STRUCT_SOCKADDR_STORAGE
+        struct sockaddr_storage sa;
+#else
+        unsigned char sa[256];
+#endif
+        char hostbuf[NI_MAXHOST];
+        int rc;
+        GETNAMEINFO_TYPE_ARG2 salen = (GETNAMEINFO_TYPE_ARG2)sizeof(sa);
+        GETNAMEINFO_TYPE_ARG46 hostlen = (GETNAMEINFO_TYPE_ARG46)sizeof(hostbuf);
+        GETNAMEINFO_TYPE_ARG7 flags = NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;
+        int fd = socket(AF_INET6, SOCK_STREAM, 0);
+        if(fd < 0) {
+          perror("socket()");
+          return 1; /* Error creating socket */
+        }
+        rc = getsockname(fd, (GETNAMEINFO_TYPE_ARG1)&sa, &salen);
+        if(rc) {
+          perror("getsockname()");
+          return 2; /* Error retrieving socket name */
+        }
+        rc = getnameinfo((GETNAMEINFO_TYPE_ARG1)&sa, salen, hostbuf, hostlen, NULL, 0, flags);
+        if(rc) {
+          printf("rc = %s\n", gai_strerror(rc));
+          return 3; /* Error translating socket address */
+        }
+        return 0; /* Ok, NI_WITHSCOPEID works */
+#else
+        return 4; /* Error, NI_WITHSCOPEID not defined or no getnameinfo() */
+#endif
+      ]]) # AC-LANG-PROGRAM
+    ],[
+      # Exit code == 0. Program worked.
+      ac_cv_working_ni_withscopeid="yes"
+    ],[
+      # Exit code != 0. Program failed.
+      ac_cv_working_ni_withscopeid="no"
+    ],[
+      # Program is not run when cross-compiling. So we assume
+      # NI_WITHSCOPEID will work if we are able to compile it.
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+        ]],[[
+          unsigned int dummy= NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;
+        ]])
+      ],[
+        ac_cv_working_ni_withscopeid="yes"
+      ],[
+        ac_cv_working_ni_withscopeid="no"
+      ]) # AC-COMPILE-IFELSE
+    ]) # AC-RUN-IFELSE
+  ]) # AC-CACHE-CHECK
+  case "$ac_cv_working_ni_withscopeid" in
+    yes)
+      AC_DEFINE(HAVE_NI_WITHSCOPEID, 1,
+        [Define to 1 if NI_WITHSCOPEID exists and works.])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_FUNC_RECV
+dnl -------------------------------------------------
+dnl Test if the socket recv() function is available,
+dnl and check its return type and the types of its
+dnl arguments. If the function succeeds HAVE_RECV
+dnl will be defined, defining the types of the arguments
+dnl in RECV_TYPE_ARG1, RECV_TYPE_ARG2, RECV_TYPE_ARG3
+dnl and RECV_TYPE_ARG4, defining the type of the function
+dnl return value in RECV_TYPE_RETV.
+
+AC_DEFUN([CURL_CHECK_FUNC_RECV], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/socket.h)
+  #
+  AC_MSG_CHECKING([for recv])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+    ]],[[
+      recv(0, 0, 0, 0);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    curl_cv_recv="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    curl_cv_recv="no"
+  ])
+  #
+  if test "$curl_cv_recv" = "yes"; then
+    AC_CACHE_CHECK([types of args and return type for recv],
+      [curl_cv_func_recv_args], [
+      curl_cv_func_recv_args="unknown"
+      for recv_retv in 'int' 'ssize_t'; do
+        for recv_arg1 in 'int' 'ssize_t' 'SOCKET'; do
+          for recv_arg2 in 'char *' 'void *'; do
+            for recv_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
+              for recv_arg4 in 'int' 'unsigned int'; do
+                if test "$curl_cv_func_recv_args" = "unknown"; then
+                  AC_COMPILE_IFELSE([
+                    AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#define RECVCALLCONV PASCAL
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#define RECVCALLCONV
+#endif
+                      extern $recv_retv RECVCALLCONV
+                      recv($recv_arg1, $recv_arg2, $recv_arg3, $recv_arg4);
+                    ]],[[
+                      $recv_arg1 s=0;
+                      $recv_arg2 buf=0;
+                      $recv_arg3 len=0;
+                      $recv_arg4 flags=0;
+                      $recv_retv res = recv(s, buf, len, flags);
+                    ]])
+                  ],[
+                    curl_cv_func_recv_args="$recv_arg1,$recv_arg2,$recv_arg3,$recv_arg4,$recv_retv"
+                  ])
+                fi
+              done
+            done
+          done
+        done
+      done
+    ]) # AC-CACHE-CHECK
+    if test "$curl_cv_func_recv_args" = "unknown"; then
+      AC_MSG_ERROR([Cannot find proper types to use for recv args])
+    else
+      recv_prev_IFS=$IFS; IFS=','
+      set dummy `echo "$curl_cv_func_recv_args" | sed 's/\*/\*/g'`
+      IFS=$recv_prev_IFS
+      shift
+      #
+      AC_DEFINE_UNQUOTED(RECV_TYPE_ARG1, $[1],
+        [Define to the type of arg 1 for recv.])
+      AC_DEFINE_UNQUOTED(RECV_TYPE_ARG2, $[2],
+        [Define to the type of arg 2 for recv.])
+      AC_DEFINE_UNQUOTED(RECV_TYPE_ARG3, $[3],
+        [Define to the type of arg 3 for recv.])
+      AC_DEFINE_UNQUOTED(RECV_TYPE_ARG4, $[4],
+        [Define to the type of arg 4 for recv.])
+      AC_DEFINE_UNQUOTED(RECV_TYPE_RETV, $[5],
+        [Define to the function return type for recv.])
+      #
+      AC_DEFINE_UNQUOTED(HAVE_RECV, 1,
+        [Define to 1 if you have the recv function.])
+      ac_cv_func_recv="yes"
+    fi
+  else
+    AC_MSG_ERROR([Unable to link function recv])
+  fi
+])
+
+
+dnl CURL_CHECK_FUNC_SEND
+dnl -------------------------------------------------
+dnl Test if the socket send() function is available,
+dnl and check its return type and the types of its
+dnl arguments. If the function succeeds HAVE_SEND
+dnl will be defined, defining the types of the arguments
+dnl in SEND_TYPE_ARG1, SEND_TYPE_ARG2, SEND_TYPE_ARG3
+dnl and SEND_TYPE_ARG4, defining the type of the function
+dnl return value in SEND_TYPE_RETV, and also defining the
+dnl type qualifier of second argument in SEND_QUAL_ARG2.
+
+AC_DEFUN([CURL_CHECK_FUNC_SEND], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/socket.h)
+  #
+  AC_MSG_CHECKING([for send])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+    ]],[[
+      send(0, 0, 0, 0);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    curl_cv_send="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    curl_cv_send="no"
+  ])
+  #
+  if test "$curl_cv_send" = "yes"; then
+    AC_CACHE_CHECK([types of args and return type for send],
+      [curl_cv_func_send_args], [
+      curl_cv_func_send_args="unknown"
+      for send_retv in 'int' 'ssize_t'; do
+        for send_arg1 in 'int' 'ssize_t' 'SOCKET'; do
+          for send_arg2 in 'char *' 'void *' 'const char *' 'const void *'; do
+            for send_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
+              for send_arg4 in 'int' 'unsigned int'; do
+                if test "$curl_cv_func_send_args" = "unknown"; then
+                  AC_COMPILE_IFELSE([
+                    AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#define SENDCALLCONV PASCAL
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#define SENDCALLCONV
+#endif
+                      extern $send_retv SENDCALLCONV
+                      send($send_arg1, $send_arg2, $send_arg3, $send_arg4);
+                    ]],[[
+                      $send_arg1 s=0;
+                      $send_arg3 len=0;
+                      $send_arg4 flags=0;
+                      $send_retv res = send(s, 0, len, flags);
+                    ]])
+                  ],[
+                    curl_cv_func_send_args="$send_arg1,$send_arg2,$send_arg3,$send_arg4,$send_retv"
+                  ])
+                fi
+              done
+            done
+          done
+        done
+      done
+    ]) # AC-CACHE-CHECK
+    if test "$curl_cv_func_send_args" = "unknown"; then
+      AC_MSG_ERROR([Cannot find proper types to use for send args])
+    else
+      send_prev_IFS=$IFS; IFS=','
+      set dummy `echo "$curl_cv_func_send_args" | sed 's/\*/\*/g'`
+      IFS=$send_prev_IFS
+      shift
+      #
+      send_qual_type_arg2=$[2]
+      #
+      AC_DEFINE_UNQUOTED(SEND_TYPE_ARG1, $[1],
+        [Define to the type of arg 1 for send.])
+      AC_DEFINE_UNQUOTED(SEND_TYPE_ARG3, $[3],
+        [Define to the type of arg 3 for send.])
+      AC_DEFINE_UNQUOTED(SEND_TYPE_ARG4, $[4],
+        [Define to the type of arg 4 for send.])
+      AC_DEFINE_UNQUOTED(SEND_TYPE_RETV, $[5],
+        [Define to the function return type for send.])
+      #
+      prev_sh_opts=$-
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set -f
+          ;;
+      esac
+      #
+      case "$send_qual_type_arg2" in
+        const*)
+          send_qual_arg2=const
+          send_type_arg2=`echo $send_qual_type_arg2 | sed 's/^const //'`
+        ;;
+        *)
+          send_qual_arg2=
+          send_type_arg2=$send_qual_type_arg2
+        ;;
+      esac
+      #
+      AC_DEFINE_UNQUOTED(SEND_QUAL_ARG2, $send_qual_arg2,
+        [Define to the type qualifier of arg 2 for send.])
+      AC_DEFINE_UNQUOTED(SEND_TYPE_ARG2, $send_type_arg2,
+        [Define to the type of arg 2 for send.])
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set +f
+          ;;
+      esac
+      #
+      AC_DEFINE_UNQUOTED(HAVE_SEND, 1,
+        [Define to 1 if you have the send function.])
+      ac_cv_func_send="yes"
+    fi
+  else
+    AC_MSG_ERROR([Unable to link function send])
+  fi
+])
+
+
+dnl CURL_CHECK_FUNC_RECVFROM
+dnl -------------------------------------------------
+dnl Test if the socket recvfrom() function is available,
+dnl and check its return type and the types of its
+dnl arguments. If the function succeeds HAVE_RECVFROM
+dnl will be defined, defining the types of the arguments
+dnl in RECVFROM_TYPE_ARG1, RECVFROM_TYPE_ARG2, and so on
+dnl to RECVFROM_TYPE_ARG6, defining also the type of the
+dnl function return value in RECVFROM_TYPE_RETV.
+dnl Notice that the types returned for pointer arguments
+dnl will actually be the type pointed by the pointer.
+
+AC_DEFUN([CURL_CHECK_FUNC_RECVFROM], [
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/socket.h)
+  #
+  AC_MSG_CHECKING([for recvfrom])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+    ]],[[
+      recvfrom(0, 0, 0, 0, 0, 0);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    curl_cv_recvfrom="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    curl_cv_recvfrom="no"
+  ])
+  #
+  if test "$curl_cv_recvfrom" = "yes"; then
+    AC_CACHE_CHECK([types of args and return type for recvfrom],
+      [curl_cv_func_recvfrom_args], [
+      curl_cv_func_recvfrom_args="unknown"
+      for recvfrom_retv in 'int' 'ssize_t'; do
+        for recvfrom_arg1 in 'int' 'ssize_t' 'SOCKET'; do
+          for recvfrom_arg2 in 'char *' 'void *'; do
+            for recvfrom_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
+              for recvfrom_arg4 in 'int' 'unsigned int'; do
+                for recvfrom_arg5 in 'struct sockaddr *' 'void *' 'const struct sockaddr *'; do
+                  for recvfrom_arg6 in 'socklen_t *' 'int *' 'unsigned int *' 'size_t *' 'void *'; do
+                    if test "$curl_cv_func_recvfrom_args" = "unknown"; then
+                      AC_COMPILE_IFELSE([
+                        AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#define RECVFROMCALLCONV PASCAL
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#define RECVFROMCALLCONV
+#endif
+                          extern $recvfrom_retv RECVFROMCALLCONV
+                          recvfrom($recvfrom_arg1, $recvfrom_arg2,
+                                   $recvfrom_arg3, $recvfrom_arg4,
+                                   $recvfrom_arg5, $recvfrom_arg6);
+                        ]],[[
+                          $recvfrom_arg1 s=0;
+                          $recvfrom_arg2 buf=0;
+                          $recvfrom_arg3 len=0;
+                          $recvfrom_arg4 flags=0;
+                          $recvfrom_arg5 addr=0;
+                          $recvfrom_arg6 addrlen=0;
+                          $recvfrom_retv res=0;
+                          res = recvfrom(s, buf, len, flags, addr, addrlen);
+                        ]])
+                      ],[
+                        curl_cv_func_recvfrom_args="$recvfrom_arg1,$recvfrom_arg2,$recvfrom_arg3,$recvfrom_arg4,$recvfrom_arg5,$recvfrom_arg6,$recvfrom_retv"
+                      ])
+                    fi
+                  done
+                done
+              done
+            done
+          done
+        done
+      done
+    ]) # AC-CACHE-CHECK
+    # Nearly last minute change for this release starts here
+    AC_DEFINE_UNQUOTED(HAVE_RECVFROM, 1,
+      [Define to 1 if you have the recvfrom function.])
+    ac_cv_func_recvfrom="yes"
+    # Nearly last minute change for this release ends here
+    if test "$curl_cv_func_recvfrom_args" = "unknown"; then
+      AC_MSG_WARN([Cannot find proper types to use for recvfrom args])
+    else
+      recvfrom_prev_IFS=$IFS; IFS=','
+      set dummy `echo "$curl_cv_func_recvfrom_args" | sed 's/\*/\*/g'`
+      IFS=$recvfrom_prev_IFS
+      shift
+      #
+      recvfrom_ptrt_arg2=$[2]
+      recvfrom_qual_ptrt_arg5=$[5]
+      recvfrom_ptrt_arg6=$[6]
+      #
+      AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG1, $[1],
+        [Define to the type of arg 1 for recvfrom.])
+      AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG3, $[3],
+        [Define to the type of arg 3 for recvfrom.])
+      AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG4, $[4],
+        [Define to the type of arg 4 for recvfrom.])
+      AC_DEFINE_UNQUOTED(RECVFROM_TYPE_RETV, $[7],
+        [Define to the function return type for recvfrom.])
+      #
+      prev_sh_opts=$-
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set -f
+          ;;
+      esac
+      #
+      case "$recvfrom_qual_ptrt_arg5" in
+        const*)
+          recvfrom_qual_arg5=const
+          recvfrom_ptrt_arg5=`echo $recvfrom_qual_ptrt_arg5 | sed 's/^const //'`
+        ;;
+        *)
+          recvfrom_qual_arg5=
+          recvfrom_ptrt_arg5=$recvfrom_qual_ptrt_arg5
+        ;;
+      esac
+      #
+      recvfrom_type_arg2=`echo $recvfrom_ptrt_arg2 | sed 's/ \*//'`
+      recvfrom_type_arg5=`echo $recvfrom_ptrt_arg5 | sed 's/ \*//'`
+      recvfrom_type_arg6=`echo $recvfrom_ptrt_arg6 | sed 's/ \*//'`
+      #
+      AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG2, $recvfrom_type_arg2,
+        [Define to the type pointed by arg 2 for recvfrom.])
+      AC_DEFINE_UNQUOTED(RECVFROM_QUAL_ARG5, $recvfrom_qual_arg5,
+        [Define to the type qualifier pointed by arg 5 for recvfrom.])
+      AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG5, $recvfrom_type_arg5,
+        [Define to the type pointed by arg 5 for recvfrom.])
+      AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG6, $recvfrom_type_arg6,
+        [Define to the type pointed by arg 6 for recvfrom.])
+      #
+      if test "$recvfrom_type_arg2" = "void"; then
+        AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG2_IS_VOID, 1,
+          [Define to 1 if the type pointed by arg 2 for recvfrom is void.])
+      fi
+      if test "$recvfrom_type_arg5" = "void"; then
+        AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG5_IS_VOID, 1,
+          [Define to 1 if the type pointed by arg 5 for recvfrom is void.])
+      fi
+      if test "$recvfrom_type_arg6" = "void"; then
+        AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG6_IS_VOID, 1,
+          [Define to 1 if the type pointed by arg 6 for recvfrom is void.])
+      fi
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set +f
+          ;;
+      esac
+      #
+      AC_DEFINE_UNQUOTED(HAVE_RECVFROM, 1,
+        [Define to 1 if you have the recvfrom function.])
+      ac_cv_func_recvfrom="yes"
+    fi
+  else
+    AC_MSG_WARN([Unable to link function recvfrom])
+    AC_MSG_WARN([Your system will be vulnerable to some forms of DNS cache poisoning])
+  fi
+])
+
+
+dnl CURL_CHECK_MSG_NOSIGNAL
+dnl -------------------------------------------------
+dnl Check for MSG_NOSIGNAL
+
+AC_DEFUN([CURL_CHECK_MSG_NOSIGNAL], [
+  AC_CHECK_HEADERS(sys/types.h sys/socket.h)
+  AC_CACHE_CHECK([for MSG_NOSIGNAL], [ac_cv_msg_nosignal], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+      ]],[[
+        int flag=MSG_NOSIGNAL;
+      ]])
+    ],[
+      ac_cv_msg_nosignal="yes"
+    ],[
+      ac_cv_msg_nosignal="no"
+    ])
+  ])
+  case "$ac_cv_msg_nosignal" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_MSG_NOSIGNAL, 1,
+        [Define to 1 if you have the MSG_NOSIGNAL flag.])
+      ;;
+  esac
+])
+
+
+dnl CURL_CHECK_STRUCT_TIMEVAL
+dnl -------------------------------------------------
+dnl Check for timeval struct
+
+AC_DEFUN([CURL_CHECK_STRUCT_TIMEVAL], [
+  AC_REQUIRE([AC_HEADER_TIME])dnl
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
+  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/time.h time.h sys/socket.h)
+  AC_CACHE_CHECK([for struct timeval], [ac_cv_struct_timeval], [
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+#include <time.h>
+#endif
+#else
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+      ]],[[
+        struct timeval ts;
+        ts.tv_sec  = 0;
+        ts.tv_usec = 0;
+      ]])
+    ],[
+      ac_cv_struct_timeval="yes"
+    ],[
+      ac_cv_struct_timeval="no"
+    ])
+  ])
+  case "$ac_cv_struct_timeval" in
+    yes)
+      AC_DEFINE_UNQUOTED(HAVE_STRUCT_TIMEVAL, 1,
+        [Define to 1 if you have the timeval struct.])
+      ;;
+  esac
+])
+
+
+dnl TYPE_SIG_ATOMIC_T
+dnl -------------------------------------------------
+dnl Check if the sig_atomic_t type is available, and
+dnl verify if it is already defined as volatile.
+
+AC_DEFUN([TYPE_SIG_ATOMIC_T], [
+  AC_CHECK_HEADERS(signal.h)
+  AC_CHECK_TYPE([sig_atomic_t],[
+    AC_DEFINE(HAVE_SIG_ATOMIC_T, 1,
+      [Define to 1 if sig_atomic_t is an available typedef.])
+  ], ,[
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+  ])
+  case "$ac_cv_type_sig_atomic_t" in
+    yes)
+      #
+      AC_MSG_CHECKING([if sig_atomic_t is already defined as volatile])
+      AC_LINK_IFELSE([
+        AC_LANG_PROGRAM([[
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+        ]],[[
+          static volatile sig_atomic_t dummy = 0;
+        ]])
+      ],[
+        AC_MSG_RESULT([no])
+        ac_cv_sig_atomic_t_volatile="no"
+      ],[
+        AC_MSG_RESULT([yes])
+        ac_cv_sig_atomic_t_volatile="yes"
+      ])
+      #
+      if test "$ac_cv_sig_atomic_t_volatile" = "yes"; then
+        AC_DEFINE(HAVE_SIG_ATOMIC_T_VOLATILE, 1,
+          [Define to 1 if sig_atomic_t is already defined as volatile.])
+      fi
+      ;;
+  esac
+])
+
+
+dnl TYPE_IN_ADDR_T
+dnl -------------------------------------------------
+dnl Check for in_addr_t: it is used to receive the return code of inet_addr()
+dnl and a few other things.
+
+AC_DEFUN([TYPE_IN_ADDR_T], [
+  AC_CHECK_TYPE([in_addr_t], ,[
+    dnl in_addr_t not available
+    AC_CACHE_CHECK([for in_addr_t equivalent],
+      [curl_cv_in_addr_t_equiv], [
+      curl_cv_in_addr_t_equiv="unknown"
+      for t in "unsigned long" int size_t unsigned long; do
+        if test "$curl_cv_in_addr_t_equiv" = "unknown"; then
+          AC_LINK_IFELSE([
+            AC_LANG_PROGRAM([[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#endif
+            ]],[[
+              $t data = inet_addr ("1.2.3.4");
+            ]])
+          ],[
+            curl_cv_in_addr_t_equiv="$t"
+          ])
+        fi
+      done
+    ])
+    case "$curl_cv_in_addr_t_equiv" in
+      unknown)
+        AC_MSG_ERROR([Cannot find a type to use in place of in_addr_t])
+        ;;
+      *)
+        AC_DEFINE_UNQUOTED(in_addr_t, $curl_cv_in_addr_t_equiv,
+          [Type to use in place of in_addr_t when system does not provide it.])
+        ;;
+    esac
+  ],[
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#endif
+  ])
+])
+
+
+dnl CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC
+dnl -------------------------------------------------
+dnl Check if monotonic clock_gettime is available.
+
+AC_DEFUN([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC], [
+  AC_REQUIRE([AC_HEADER_TIME])dnl
+  AC_CHECK_HEADERS(sys/types.h sys/time.h time.h)
+  AC_MSG_CHECKING([for monotonic clock_gettime])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+#include <time.h>
+#endif
+#else
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
+    ]],[[
+      struct timespec ts;
+      (void)clock_gettime(CLOCK_MONOTONIC, &ts);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    ac_cv_func_clock_gettime="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    ac_cv_func_clock_gettime="no"
+  ])
+  dnl Definition of HAVE_CLOCK_GETTIME_MONOTONIC is intentionally postponed
+  dnl until library linking and run-time checks for clock_gettime succeed.
+])
+
+
+dnl CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC
+dnl -------------------------------------------------
+dnl If monotonic clock_gettime is available then,
+dnl check and prepended to LIBS any needed libraries.
+
+AC_DEFUN([CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC], [
+  AC_REQUIRE([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC])dnl
+  #
+  if test "$ac_cv_func_clock_gettime" = "yes"; then
+    #
+    AC_MSG_CHECKING([for clock_gettime in libraries])
+    #
+    curl_cv_save_LIBS="$LIBS"
+    curl_cv_gclk_LIBS="unknown"
+    #
+    for x_xlibs in '' '-lrt' '-lposix4' ; do
+      if test "$curl_cv_gclk_LIBS" = "unknown"; then
+        if test -z "$x_xlibs"; then
+          LIBS="$curl_cv_save_LIBS"
+        else
+          LIBS="$x_xlibs $curl_cv_save_LIBS"
+        fi
+        AC_LINK_IFELSE([
+          AC_LANG_PROGRAM([[
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+#include <time.h>
+#endif
+#else
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
+          ]],[[
+            struct timespec ts;
+            (void)clock_gettime(CLOCK_MONOTONIC, &ts);
+          ]])
+        ],[
+          curl_cv_gclk_LIBS="$x_xlibs"
+        ])
+      fi
+    done
+    #
+    LIBS="$curl_cv_save_LIBS"
+    #
+    case X-"$curl_cv_gclk_LIBS" in
+      X-unknown)
+        AC_MSG_RESULT([cannot find clock_gettime])
+        AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
+        ac_cv_func_clock_gettime="no"
+        ;;
+      X-)
+        AC_MSG_RESULT([no additional lib required])
+        ac_cv_func_clock_gettime="yes"
+        ;;
+      *)
+        if test -z "$curl_cv_save_LIBS"; then
+          LIBS="$curl_cv_gclk_LIBS"
+        else
+          LIBS="$curl_cv_gclk_LIBS $curl_cv_save_LIBS"
+        fi
+        AC_MSG_RESULT([$curl_cv_gclk_LIBS])
+        ac_cv_func_clock_gettime="yes"
+        ;;
+    esac
+    #
+    dnl only do runtime verification when not cross-compiling
+    if test "x$cross_compiling" != "xyes" &&
+      test "$ac_cv_func_clock_gettime" = "yes"; then
+      AC_MSG_CHECKING([if monotonic clock_gettime works])
+      AC_RUN_IFELSE([
+        AC_LANG_PROGRAM([[
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+#include <time.h>
+#endif
+#else
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
+        ]],[[
+          struct timespec ts;
+          if (0 == clock_gettime(CLOCK_MONOTONIC, &ts))
+            exit(0);
+          else
+            exit(1);
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+      ],[
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
+        ac_cv_func_clock_gettime="no"
+        LIBS="$curl_cv_save_LIBS"
+      ])
+    fi
+    #
+    case "$ac_cv_func_clock_gettime" in
+      yes)
+        AC_DEFINE_UNQUOTED(HAVE_CLOCK_GETTIME_MONOTONIC, 1,
+          [Define to 1 if you have the clock_gettime function and monotonic timer.])
+        ;;
+    esac
+    #
+  fi
+  #
+])
+
+
+dnl CARES_CHECK_LIBS_CONNECT
+dnl -------------------------------------------------
+dnl Verify if network connect function is already available
+dnl using current libraries or if another one is required.
+
+AC_DEFUN([CARES_CHECK_LIBS_CONNECT], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_MSG_CHECKING([for connect in libraries])
+  tst_connect_save_LIBS="$LIBS"
+  tst_connect_need_LIBS="unknown"
+  for tst_lib in '' '-lsocket' ; do
+    if test "$tst_connect_need_LIBS" = "unknown"; then
+      LIBS="$tst_lib $tst_connect_save_LIBS"
+      AC_LINK_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_winsock2
+          #ifndef HAVE_WINDOWS_H
+            int connect(int, void*, int);
+          #endif
+        ]],[[
+          if(0 != connect(0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        tst_connect_need_LIBS="$tst_lib"
+      ])
+    fi
+  done
+  LIBS="$tst_connect_save_LIBS"
+  #
+  case X-"$tst_connect_need_LIBS" in
+    X-unknown)
+      AC_MSG_RESULT([cannot find connect])
+      AC_MSG_ERROR([cannot find connect function in libraries.])
+      ;;
+    X-)
+      AC_MSG_RESULT([yes])
+      ;;
+    *)
+      AC_MSG_RESULT([$tst_connect_need_LIBS])
+      LIBS="$tst_connect_need_LIBS $tst_connect_save_LIBS"
+      ;;
+  esac
+])
+
+
+dnl CARES_DEFINE_UNQUOTED (VARIABLE, [VALUE])
+dnl -------------------------------------------------
+dnl Like AC_DEFINE_UNQUOTED this macro will define a C preprocessor
+dnl symbol that can be further used in custom template configuration
+dnl files. This macro, unlike AC_DEFINE_UNQUOTED, does not use a third
+dnl argument for the description. Symbol definitions done with this
+dnl macro are intended to be exclusively used in handcrafted *.h.in
+dnl template files. Contrary to what AC_DEFINE_UNQUOTED does, this one
+dnl prevents autoheader generation and insertion of symbol template
+dnl stub and definition into the first configuration header file. Do
+dnl not use this macro as a replacement for AC_DEFINE_UNQUOTED, each
+dnl one serves different functional needs.
+
+AC_DEFUN([CARES_DEFINE_UNQUOTED], [
+cat >>confdefs.h <<_EOF
+[@%:@define] $1 ifelse($#, 2, [$2], 1)
+_EOF
+])
+
+dnl CARES_CONFIGURE_ARES_SOCKLEN_T
+dnl -------------------------------------------------
+dnl Find out suitable ares_socklen_t data type definition and size, making
+dnl appropriate definitions for template file ares_build.h.in
+dnl to properly configure and use the library.
+dnl
+dnl The need for the ares_socklen_t definition arises mainly to properly
+dnl interface HP-UX systems which on one hand have a typedef'ed socklen_t
+dnl data type which is 32 or 64-Bit wide depending on the data model being
+dnl used, and that on the other hand is only actually used when interfacing
+dnl the X/Open sockets provided in the xnet library.
+
+AC_DEFUN([CARES_CONFIGURE_ARES_SOCKLEN_T], [
+  AC_REQUIRE([CARES_INCLUDES_WS2TCPIP])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_PREPROCESS_CALLCONV])dnl
+  #
+  AC_MSG_CHECKING([for ares_socklen_t data type])
+  cares_typeof_ares_socklen_t="unknown"
+  for arg1 in int SOCKET; do
+    for arg2 in 'struct sockaddr' void; do
+      for t in socklen_t int size_t 'unsigned int' long 'unsigned long' void; do
+        if test "$cares_typeof_ares_socklen_t" = "unknown"; then
+          AC_COMPILE_IFELSE([
+            AC_LANG_PROGRAM([[
+              $cares_includes_ws2tcpip
+              $cares_includes_sys_socket
+              $cares_preprocess_callconv
+              extern int FUNCALLCONV getpeername($arg1, $arg2 *, $t *);
+            ]],[[
+              $t *lenptr = 0;
+              if(0 != getpeername(0, 0, lenptr))
+                return 1;
+            ]])
+          ],[
+            cares_typeof_ares_socklen_t="$t"
+          ])
+        fi
+      done
+    done
+  done
+  for t in socklen_t int; do
+    if test "$cares_typeof_ares_socklen_t" = "void"; then
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_sys_socket
+          typedef $t ares_socklen_t;
+        ]],[[
+          ares_socklen_t dummy;
+        ]])
+      ],[
+        cares_typeof_ares_socklen_t="$t"
+      ])
+    fi
+  done
+  AC_MSG_RESULT([$cares_typeof_ares_socklen_t])
+  if test "$cares_typeof_ares_socklen_t" = "void" ||
+    test "$cares_typeof_ares_socklen_t" = "unknown"; then
+    AC_MSG_ERROR([cannot find data type for ares_socklen_t.])
+  fi
+  #
+  AC_MSG_CHECKING([size of ares_socklen_t])
+  cares_sizeof_ares_socklen_t="unknown"
+  cares_pull_headers_socklen_t="unknown"
+  if test "$ac_cv_header_ws2tcpip_h" = "yes"; then
+    tst_pull_header_checks='none ws2tcpip'
+    tst_size_checks='4'
+  else
+    tst_pull_header_checks='none systypes syssocket'
+    tst_size_checks='4 8 2'
+  fi
+  for tst_size in $tst_size_checks; do
+    for tst_pull_headers in $tst_pull_header_checks; do
+      if test "$cares_sizeof_ares_socklen_t" = "unknown"; then
+        case $tst_pull_headers in
+          ws2tcpip)
+            tmp_includes="$cares_includes_ws2tcpip"
+            ;;
+          systypes)
+            tmp_includes="$cares_includes_sys_types"
+            ;;
+          syssocket)
+            tmp_includes="$cares_includes_sys_socket"
+            ;;
+          *)
+            tmp_includes=""
+            ;;
+        esac
+        AC_COMPILE_IFELSE([
+          AC_LANG_PROGRAM([[
+            $tmp_includes
+            typedef $cares_typeof_ares_socklen_t ares_socklen_t;
+            typedef char dummy_arr[sizeof(ares_socklen_t) == $tst_size ? 1 : -1];
+          ]],[[
+            ares_socklen_t dummy;
+          ]])
+        ],[
+          cares_sizeof_ares_socklen_t="$tst_size"
+          cares_pull_headers_socklen_t="$tst_pull_headers"
+        ])
+      fi
+    done
+  done
+  AC_MSG_RESULT([$cares_sizeof_ares_socklen_t])
+  if test "$cares_sizeof_ares_socklen_t" = "unknown"; then
+    AC_MSG_ERROR([cannot find out size of ares_socklen_t.])
+  fi
+  #
+  case $cares_pull_headers_socklen_t in
+    ws2tcpip)
+      CARES_DEFINE_UNQUOTED([CARES_PULL_WS2TCPIP_H])
+      ;;
+    systypes)
+      CARES_DEFINE_UNQUOTED([CARES_PULL_SYS_TYPES_H])
+      ;;
+    syssocket)
+      CARES_DEFINE_UNQUOTED([CARES_PULL_SYS_TYPES_H])
+      CARES_DEFINE_UNQUOTED([CARES_PULL_SYS_SOCKET_H])
+      ;;
+  esac
+  CARES_DEFINE_UNQUOTED([CARES_TYPEOF_ARES_SOCKLEN_T], [$cares_typeof_ares_socklen_t])
+  CARES_DEFINE_UNQUOTED([CARES_SIZEOF_ARES_SOCKLEN_T], [$cares_sizeof_ares_socklen_t])
+])
+
+
+dnl This macro determines if the specified struct exists in the specified file
+dnl Syntax:
+dnl CARES_CHECK_STRUCT(headers, struct name, if found, [if not found])
+
+AC_DEFUN([CARES_CHECK_STRUCT], [
+  AC_MSG_CHECKING([for struct $2])
+  AC_TRY_COMPILE([$1],
+    [
+      struct $2 struct_instance;
+    ], ac_struct="yes", ac_found="no")
+  if test "$ac_struct" = "yes" ; then
+    AC_MSG_RESULT(yes)
+    $3
+  else
+    AC_MSG_RESULT(no)
+    $4
+  fi
+])
+
+dnl This macro determines if the specified constant exists in the specified file
+dnl Syntax:
+dnl CARES_CHECK_CONSTANT(headers, constant name, if found, [if not found])
+
+AC_DEFUN([CARES_CHECK_CONSTANT], [
+  AC_MSG_CHECKING([for $2])
+  AC_EGREP_CPP(VARIABLEWASDEFINED,
+   [
+      $1
+
+      #ifdef $2
+        VARIABLEWASDEFINED
+      #else
+        NJET
+      #endif
+    ], ac_constant="yes", ac_constant="no"
+  )
+  if test "$ac_constant" = "yes" ; then
+    AC_MSG_RESULT(yes)
+    $3
+  else
+    AC_MSG_RESULT(no)
+    $4
+  fi
+])
+
diff --git a/deps/cares/aclocal.m4 b/deps/cares/aclocal.m4
new file mode 100644
index 0000000000000000000000000000000000000000..e7ced790b9190bf10cab6540e4209508b583a528
--- /dev/null
+++ b/deps/cares/aclocal.m4
@@ -0,0 +1,1211 @@
+# generated automatically by aclocal 1.16.5 -*- Autoconf -*-
+
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
+
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
+m4_ifndef([AC_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.71],,
+[m4_warning([this file was generated for autoconf 2.71.
+You have another version of autoconf.  It may work, but is not guaranteed to.
+If you have problems, you may need to regenerate the build system entirely.
+To do so, use the procedure documented by the package, typically 'autoreconf'.])])
+
+# Copyright (C) 2002-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_AUTOMAKE_VERSION(VERSION)
+# ----------------------------
+# Automake X.Y traces this macro to ensure aclocal.m4 has been
+# generated from the m4 files accompanying Automake X.Y.
+# (This private macro should not be called outside this file.)
+AC_DEFUN([AM_AUTOMAKE_VERSION],
+[am__api_version='1.16'
+dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
+dnl require some minimum version.  Point them to the right macro.
+m4_if([$1], [1.16.5], [],
+      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
+])
+
+# _AM_AUTOCONF_VERSION(VERSION)
+# -----------------------------
+# aclocal traces this macro to find the Autoconf version.
+# This is a private macro too.  Using m4_define simplifies
+# the logic in aclocal, which can simply ignore this definition.
+m4_define([_AM_AUTOCONF_VERSION], [])
+
+# AM_SET_CURRENT_AUTOMAKE_VERSION
+# -------------------------------
+# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
+# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
+AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
+[AM_AUTOMAKE_VERSION([1.16.5])dnl
+m4_ifndef([AC_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
+
+# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
+# $ac_aux_dir to '$srcdir/foo'.  In other projects, it is set to
+# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
+#
+# Of course, Automake must honor this variable whenever it calls a
+# tool from the auxiliary directory.  The problem is that $srcdir (and
+# therefore $ac_aux_dir as well) can be either absolute or relative,
+# depending on how configure is run.  This is pretty annoying, since
+# it makes $ac_aux_dir quite unusable in subdirectories: in the top
+# source directory, any form will work fine, but in subdirectories a
+# relative path needs to be adjusted first.
+#
+# $ac_aux_dir/missing
+#    fails when called from a subdirectory if $ac_aux_dir is relative
+# $top_srcdir/$ac_aux_dir/missing
+#    fails if $ac_aux_dir is absolute,
+#    fails when called from a subdirectory in a VPATH build with
+#          a relative $ac_aux_dir
+#
+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
+# are both prefixed by $srcdir.  In an in-source build this is usually
+# harmless because $srcdir is '.', but things will broke when you
+# start a VPATH build or use an absolute $srcdir.
+#
+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
+# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
+#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
+# and then we would define $MISSING as
+#   MISSING="\${SHELL} $am_aux_dir/missing"
+# This will work as long as MISSING is not called from configure, because
+# unfortunately $(top_srcdir) has no meaning in configure.
+# However there are other variables, like CC, which are often used in
+# configure, and could therefore not use this "fixed" $ac_aux_dir.
+#
+# Another solution, used here, is to always expand $ac_aux_dir to an
+# absolute PATH.  The drawback is that using absolute paths prevent a
+# configured tree to be moved without reconfiguration.
+
+AC_DEFUN([AM_AUX_DIR_EXPAND],
+[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
+])
+
+# AM_CONDITIONAL                                            -*- Autoconf -*-
+
+# Copyright (C) 1997-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_CONDITIONAL(NAME, SHELL-CONDITION)
+# -------------------------------------
+# Define a conditional.
+AC_DEFUN([AM_CONDITIONAL],
+[AC_PREREQ([2.52])dnl
+ m4_if([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
+       [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
+AC_SUBST([$1_TRUE])dnl
+AC_SUBST([$1_FALSE])dnl
+_AM_SUBST_NOTMAKE([$1_TRUE])dnl
+_AM_SUBST_NOTMAKE([$1_FALSE])dnl
+m4_define([_AM_COND_VALUE_$1], [$2])dnl
+if $2; then
+  $1_TRUE=
+  $1_FALSE='#'
+else
+  $1_TRUE='#'
+  $1_FALSE=
+fi
+AC_CONFIG_COMMANDS_PRE(
+[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
+  AC_MSG_ERROR([[conditional "$1" was never defined.
+Usually this means the macro was only invoked conditionally.]])
+fi])])
+
+# Copyright (C) 1999-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
+# written in clear, in which case automake, when reading aclocal.m4,
+# will think it sees a *use*, and therefore will trigger all it's
+# C support machinery.  Also note that it means that autoscan, seeing
+# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
+
+
+# _AM_DEPENDENCIES(NAME)
+# ----------------------
+# See how the compiler implements dependency checking.
+# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
+# We try a few techniques and use that to set a single cache variable.
+#
+# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
+# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
+# dependency, and given that the user is not expected to run this macro,
+# just rely on AC_PROG_CC.
+AC_DEFUN([_AM_DEPENDENCIES],
+[AC_REQUIRE([AM_SET_DEPDIR])dnl
+AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
+AC_REQUIRE([AM_MAKE_INCLUDE])dnl
+AC_REQUIRE([AM_DEP_TRACK])dnl
+
+m4_if([$1], [CC],   [depcc="$CC"   am_compiler_list=],
+      [$1], [CXX],  [depcc="$CXX"  am_compiler_list=],
+      [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
+      [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
+      [$1], [UPC],  [depcc="$UPC"  am_compiler_list=],
+      [$1], [GCJ],  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
+                    [depcc="$$1"   am_compiler_list=])
+
+AC_CACHE_CHECK([dependency style of $depcc],
+               [am_cv_$1_dependencies_compiler_type],
+[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_$1_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
+  fi
+  am__universal=false
+  m4_case([$1], [CC],
+    [case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac],
+    [CXX],
+    [case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac])
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_$1_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_$1_dependencies_compiler_type=none
+fi
+])
+AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
+AM_CONDITIONAL([am__fastdep$1], [
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
+])
+
+
+# AM_SET_DEPDIR
+# -------------
+# Choose a directory name for dependency files.
+# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
+AC_DEFUN([AM_SET_DEPDIR],
+[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
+])
+
+
+# AM_DEP_TRACK
+# ------------
+AC_DEFUN([AM_DEP_TRACK],
+[AC_ARG_ENABLE([dependency-tracking], [dnl
+AS_HELP_STRING(
+  [--enable-dependency-tracking],
+  [do not reject slow dependency extractors])
+AS_HELP_STRING(
+  [--disable-dependency-tracking],
+  [speeds up one-time build])])
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
+AC_SUBST([AMDEPBACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
+AC_SUBST([am__nodep])dnl
+_AM_SUBST_NOTMAKE([am__nodep])dnl
+])
+
+# Generate code to set up dependency tracking.              -*- Autoconf -*-
+
+# Copyright (C) 1999-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_OUTPUT_DEPENDENCY_COMMANDS
+# ------------------------------
+AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
+[{
+  # Older Autoconf quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  AS_CASE([$CONFIG_FILES],
+          [*\'*], [eval set x "$CONFIG_FILES"],
+          [*], [set x $CONFIG_FILES])
+  shift
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
+  do
+    # Strip MF so we end up with the name of the file.
+    am_mf=`AS_ECHO(["$am_mf"]) | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`AS_DIRNAME(["$am_mf"])`
+    am_filepart=`AS_BASENAME(["$am_mf"])`
+    AM_RUN_LOG([cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles]) || am_rc=$?
+  done
+  if test $am_rc -ne 0; then
+    AC_MSG_FAILURE([Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  If GNU make was not used, consider
+    re-running the configure script with MAKE="gmake" (or whatever is
+    necessary).  You can also try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).])
+  fi
+  AS_UNSET([am_dirpart])
+  AS_UNSET([am_filepart])
+  AS_UNSET([am_mf])
+  AS_UNSET([am_rc])
+  rm -f conftest-deps.mk
+}
+])# _AM_OUTPUT_DEPENDENCY_COMMANDS
+
+
+# AM_OUTPUT_DEPENDENCY_COMMANDS
+# -----------------------------
+# This macro should only be invoked once -- use via AC_REQUIRE.
+#
+# This code is only required when automatic dependency tracking is enabled.
+# This creates each '.Po' and '.Plo' makefile fragment that we'll need in
+# order to bootstrap the dependency handling code.
+AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
+[AC_CONFIG_COMMANDS([depfiles],
+     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
+     [AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"])])
+
+# Do all the work for Automake.                             -*- Autoconf -*-
+
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This macro actually does too much.  Some checks are only needed if
+# your package does certain things.  But this isn't really a big deal.
+
+dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
+m4_define([AC_PROG_CC],
+m4_defn([AC_PROG_CC])
+[_AM_PROG_CC_C_O
+])
+
+# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
+# AM_INIT_AUTOMAKE([OPTIONS])
+# -----------------------------------------------
+# The call with PACKAGE and VERSION arguments is the old style
+# call (pre autoconf-2.50), which is being phased out.  PACKAGE
+# and VERSION should now be passed to AC_INIT and removed from
+# the call to AM_INIT_AUTOMAKE.
+# We support both call styles for the transition.  After
+# the next Automake release, Autoconf can make the AC_INIT
+# arguments mandatory, and then we can depend on a new Autoconf
+# release and drop the old call support.
+AC_DEFUN([AM_INIT_AUTOMAKE],
+[AC_PREREQ([2.65])dnl
+m4_ifdef([_$0_ALREADY_INIT],
+  [m4_fatal([$0 expanded multiple times
+]m4_defn([_$0_ALREADY_INIT]))],
+  [m4_define([_$0_ALREADY_INIT], m4_expansion_stack)])dnl
+dnl Autoconf wants to disallow AM_ names.  We explicitly allow
+dnl the ones we care about.
+m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
+AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
+AC_REQUIRE([AC_PROG_INSTALL])dnl
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+AC_SUBST([CYGPATH_W])
+
+# Define the identity of the package.
+dnl Distinguish between old-style and new-style calls.
+m4_ifval([$2],
+[AC_DIAGNOSE([obsolete],
+             [$0: two- and three-arguments forms are deprecated.])
+m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
+ AC_SUBST([PACKAGE], [$1])dnl
+ AC_SUBST([VERSION], [$2])],
+[_AM_SET_OPTIONS([$1])dnl
+dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
+m4_if(
+  m4_ifset([AC_PACKAGE_NAME], [ok]):m4_ifset([AC_PACKAGE_VERSION], [ok]),
+  [ok:ok],,
+  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
+ AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
+ AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
+
+_AM_IF_OPTION([no-define],,
+[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
+ AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
+
+# Some tools Automake needs.
+AC_REQUIRE([AM_SANITY_CHECK])dnl
+AC_REQUIRE([AC_ARG_PROGRAM])dnl
+AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
+AM_MISSING_PROG([AUTOCONF], [autoconf])
+AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
+AM_MISSING_PROG([AUTOHEADER], [autoheader])
+AM_MISSING_PROG([MAKEINFO], [makeinfo])
+AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
+AC_REQUIRE([AC_PROG_MKDIR_P])dnl
+# For better backward compatibility.  To be removed once Automake 1.9.x
+# dies out for good.  For more background, see:
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
+AC_REQUIRE([AC_PROG_AWK])dnl
+AC_REQUIRE([AC_PROG_MAKE_SET])dnl
+AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
+	      [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
+			     [_AM_PROG_TAR([v7])])])
+_AM_IF_OPTION([no-dependencies],,
+[AC_PROVIDE_IFELSE([AC_PROG_CC],
+		  [_AM_DEPENDENCIES([CC])],
+		  [m4_define([AC_PROG_CC],
+			     m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_CXX],
+		  [_AM_DEPENDENCIES([CXX])],
+		  [m4_define([AC_PROG_CXX],
+			     m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJC],
+		  [_AM_DEPENDENCIES([OBJC])],
+		  [m4_define([AC_PROG_OBJC],
+			     m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
+		  [_AM_DEPENDENCIES([OBJCXX])],
+		  [m4_define([AC_PROG_OBJCXX],
+			     m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
+])
+# Variables for tags utilities; see am/tags.am
+if test -z "$CTAGS"; then
+  CTAGS=ctags
+fi
+AC_SUBST([CTAGS])
+if test -z "$ETAGS"; then
+  ETAGS=etags
+fi
+AC_SUBST([ETAGS])
+if test -z "$CSCOPE"; then
+  CSCOPE=cscope
+fi
+AC_SUBST([CSCOPE])
+
+AC_REQUIRE([AM_SILENT_RULES])dnl
+dnl The testsuite driver may need to know about EXEEXT, so add the
+dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
+dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
+AC_CONFIG_COMMANDS_PRE(dnl
+[m4_provide_if([_AM_COMPILER_EXEEXT],
+  [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
+  fi
+fi
+dnl The trailing newline in this macro's definition is deliberate, for
+dnl backward compatibility and to allow trailing 'dnl'-style comments
+dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
+])
+
+dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
+dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
+dnl mangled by Autoconf and run in a shell conditional statement.
+m4_define([_AC_COMPILER_EXEEXT],
+m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
+
+# When config.status generates a header, we must update the stamp-h file.
+# This file resides in the same directory as the config header
+# that is generated.  The stamp files are numbered to have different names.
+
+# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
+# loop where config.status creates the headers, so we can generate
+# our stamp files there.
+AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
+[# Compute $1's index in $config_headers.
+_am_arg=$1
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
+
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_SH
+# ------------------
+# Define $install_sh.
+AC_DEFUN([AM_PROG_INSTALL_SH],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+if test x"${install_sh+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+AC_SUBST([install_sh])])
+
+# Copyright (C) 2003-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# Check whether the underlying file-system supports filenames
+# with a leading dot.  For instance MS-DOS doesn't.
+AC_DEFUN([AM_SET_LEADING_DOT],
+[rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+AC_SUBST([am__leading_dot])])
+
+# Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
+# From Jim Meyering
+
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MAINTAINER_MODE([DEFAULT-MODE])
+# ----------------------------------
+# Control maintainer-specific portions of Makefiles.
+# Default is to disable them, unless 'enable' is passed literally.
+# For symmetry, 'disable' may be passed as well.  Anyway, the user
+# can override the default with the --enable/--disable switch.
+AC_DEFUN([AM_MAINTAINER_MODE],
+[m4_case(m4_default([$1], [disable]),
+       [enable], [m4_define([am_maintainer_other], [disable])],
+       [disable], [m4_define([am_maintainer_other], [enable])],
+       [m4_define([am_maintainer_other], [enable])
+        m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])])
+AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
+  dnl maintainer-mode's default is 'disable' unless 'enable' is passed
+  AC_ARG_ENABLE([maintainer-mode],
+    [AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode],
+      am_maintainer_other[ make rules and dependencies not useful
+      (and sometimes confusing) to the casual installer])],
+    [USE_MAINTAINER_MODE=$enableval],
+    [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
+  AC_MSG_RESULT([$USE_MAINTAINER_MODE])
+  AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes])
+  MAINT=$MAINTAINER_MODE_TRUE
+  AC_SUBST([MAINT])dnl
+]
+)
+
+# Check to see how 'make' treats includes.	            -*- Autoconf -*-
+
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MAKE_INCLUDE()
+# -----------------
+# Check whether make has an 'include' directive that can support all
+# the idioms we need for our automatic dependency tracking code.
+AC_DEFUN([AM_MAKE_INCLUDE],
+[AC_MSG_CHECKING([whether ${MAKE-make} supports the include directive])
+cat > confinc.mk << 'END'
+am__doit:
+	@echo this is the am__doit target >confinc.out
+.PHONY: am__doit
+END
+am__include="#"
+am__quote=
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  AM_RUN_LOG([${MAKE-make} -f confmf.$s && cat confinc.out])
+  AS_CASE([$?:`cat confinc.out 2>/dev/null`],
+      ['0:this is the am__doit target'],
+      [AS_CASE([$s],
+          [BSD], [am__include='.include' am__quote='"'],
+          [am__include='include' am__quote=''])])
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+AC_MSG_RESULT([${_am_result}])
+AC_SUBST([am__include])])
+AC_SUBST([am__quote])])
+
+# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
+
+# Copyright (C) 1997-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MISSING_PROG(NAME, PROGRAM)
+# ------------------------------
+AC_DEFUN([AM_MISSING_PROG],
+[AC_REQUIRE([AM_MISSING_HAS_RUN])
+$1=${$1-"${am_missing_run}$2"}
+AC_SUBST($1)])
+
+# AM_MISSING_HAS_RUN
+# ------------------
+# Define MISSING if not defined so far and test if it is modern enough.
+# If it is, set am_missing_run to use it, otherwise, to nothing.
+AC_DEFUN([AM_MISSING_HAS_RUN],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([missing])dnl
+if test x"${MISSING+set}" != xset; then
+  MISSING="\${SHELL} '$am_aux_dir/missing'"
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+  am_missing_run="$MISSING "
+else
+  am_missing_run=
+  AC_MSG_WARN(['missing' script is too old or missing])
+fi
+])
+
+# Helper functions for option handling.                     -*- Autoconf -*-
+
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_MANGLE_OPTION(NAME)
+# -----------------------
+AC_DEFUN([_AM_MANGLE_OPTION],
+[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
+
+# _AM_SET_OPTION(NAME)
+# --------------------
+# Set option NAME.  Presently that only means defining a flag for this option.
+AC_DEFUN([_AM_SET_OPTION],
+[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
+
+# _AM_SET_OPTIONS(OPTIONS)
+# ------------------------
+# OPTIONS is a space-separated list of Automake options.
+AC_DEFUN([_AM_SET_OPTIONS],
+[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
+
+# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
+# -------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+AC_DEFUN([_AM_IF_OPTION],
+[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
+
+# Copyright (C) 1999-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_CC_C_O
+# ---------------
+# Like AC_PROG_CC_C_O, but changed for automake.  We rewrite AC_PROG_CC
+# to automatically call this.
+AC_DEFUN([_AM_PROG_CC_C_O],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([compile])dnl
+AC_LANG_PUSH([C])dnl
+AC_CACHE_CHECK(
+  [whether $CC understands -c and -o together],
+  [am_cv_prog_cc_c_o],
+  [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i])
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+AC_LANG_POP([C])])
+
+# For backward compatibility.
+AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
+
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_RUN_LOG(COMMAND)
+# -------------------
+# Run COMMAND, save the exit status in ac_status, and log it.
+# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
+AC_DEFUN([AM_RUN_LOG],
+[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
+   ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   (exit $ac_status); }])
+
+# Check to make sure that the build environment is sane.    -*- Autoconf -*-
+
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SANITY_CHECK
+# ---------------
+AC_DEFUN([AM_SANITY_CHECK],
+[AC_MSG_CHECKING([whether build environment is sane])
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *[[\\\"\#\$\&\'\`$am_lf]]*)
+    AC_MSG_ERROR([unsafe absolute working directory name]);;
+esac
+case $srcdir in
+  *[[\\\"\#\$\&\'\`$am_lf\ \	]]*)
+    AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   am_has_slept=no
+   for am_try in 1 2; do
+     echo "timestamp, slept: $am_has_slept" > conftest.file
+     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+     if test "$[*]" = "X"; then
+	# -L didn't work.
+	set X `ls -t "$srcdir/configure" conftest.file`
+     fi
+     if test "$[*]" != "X $srcdir/configure conftest.file" \
+	&& test "$[*]" != "X conftest.file $srcdir/configure"; then
+
+	# If neither matched, then we have a broken ls.  This can happen
+	# if, for instance, CONFIG_SHELL is bash and it inherits a
+	# broken ls alias from the environment.  This has actually
+	# happened.  Such a system could not be considered "sane".
+	AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
+  alias in your environment])
+     fi
+     if test "$[2]" = conftest.file || test $am_try -eq 2; then
+       break
+     fi
+     # Just in case.
+     sleep 1
+     am_has_slept=yes
+   done
+   test "$[2]" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   AC_MSG_ERROR([newly created file is older than distributed files!
+Check your system clock])
+fi
+AC_MSG_RESULT([yes])
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+  ( sleep 1 ) &
+  am_sleep_pid=$!
+fi
+AC_CONFIG_COMMANDS_PRE(
+  [AC_MSG_CHECKING([that generated files are newer than configure])
+   if test -n "$am_sleep_pid"; then
+     # Hide warnings about reused PIDs.
+     wait $am_sleep_pid 2>/dev/null
+   fi
+   AC_MSG_RESULT([done])])
+rm -f conftest.file
+])
+
+# Copyright (C) 2009-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SILENT_RULES([DEFAULT])
+# --------------------------
+# Enable less verbose build rules; with the default set to DEFAULT
+# ("yes" being less verbose, "no" or empty being verbose).
+AC_DEFUN([AM_SILENT_RULES],
+[AC_ARG_ENABLE([silent-rules], [dnl
+AS_HELP_STRING(
+  [--enable-silent-rules],
+  [less verbose build output (undo: "make V=1")])
+AS_HELP_STRING(
+  [--disable-silent-rules],
+  [verbose build output (undo: "make V=0")])dnl
+])
+case $enable_silent_rules in @%:@ (((
+  yes) AM_DEFAULT_VERBOSITY=0;;
+   no) AM_DEFAULT_VERBOSITY=1;;
+    *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
+esac
+dnl
+dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
+dnl do not support nested variable expansions.
+dnl See automake bug#9928 and bug#10237.
+am_make=${MAKE-make}
+AC_CACHE_CHECK([whether $am_make supports nested variables],
+   [am_cv_make_support_nested_variables],
+   [if AS_ECHO([['TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi])
+if test $am_cv_make_support_nested_variables = yes; then
+  dnl Using '$V' instead of '$(V)' breaks IRIX make.
+  AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AC_SUBST([AM_V])dnl
+AM_SUBST_NOTMAKE([AM_V])dnl
+AC_SUBST([AM_DEFAULT_V])dnl
+AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
+AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
+AM_BACKSLASH='\'
+AC_SUBST([AM_BACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
+])
+
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_STRIP
+# ---------------------
+# One issue with vendor 'install' (even GNU) is that you can't
+# specify the program used to strip binaries.  This is especially
+# annoying in cross-compiling environments, where the build's strip
+# is unlikely to handle the host's binaries.
+# Fortunately install-sh will honor a STRIPPROG variable, so we
+# always use install-sh in "make install-strip", and initialize
+# STRIPPROG with the value of the STRIP variable (set by the user).
+AC_DEFUN([AM_PROG_INSTALL_STRIP],
+[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip".  However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
+if test "$cross_compiling" != no; then
+  AC_CHECK_TOOL([STRIP], [strip], :)
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+AC_SUBST([INSTALL_STRIP_PROGRAM])])
+
+# Copyright (C) 2006-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_SUBST_NOTMAKE(VARIABLE)
+# ---------------------------
+# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
+# This macro is traced by Automake.
+AC_DEFUN([_AM_SUBST_NOTMAKE])
+
+# AM_SUBST_NOTMAKE(VARIABLE)
+# --------------------------
+# Public sister of _AM_SUBST_NOTMAKE.
+AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
+
+# Check how to create a tarball.                            -*- Autoconf -*-
+
+# Copyright (C) 2004-2021 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_TAR(FORMAT)
+# --------------------
+# Check how to create a tarball in format FORMAT.
+# FORMAT should be one of 'v7', 'ustar', or 'pax'.
+#
+# Substitute a variable $(am__tar) that is a command
+# writing to stdout a FORMAT-tarball containing the directory
+# $tardir.
+#     tardir=directory && $(am__tar) > result.tar
+#
+# Substitute a variable $(am__untar) that extract such
+# a tarball read from stdin.
+#     $(am__untar) < result.tar
+#
+AC_DEFUN([_AM_PROG_TAR],
+[# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AC_SUBST([AMTAR], ['$${TAR-tar}'])
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
+
+m4_if([$1], [v7],
+  [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
+
+  [m4_case([$1],
+    [ustar],
+     [# The POSIX 1988 'ustar' format is defined with fixed-size fields.
+      # There is notably a 21 bits limit for the UID and the GID.  In fact,
+      # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
+      # and bug#13588).
+      am_max_uid=2097151 # 2^21 - 1
+      am_max_gid=$am_max_uid
+      # The $UID and $GID variables are not portable, so we need to resort
+      # to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
+      # below are definitely unexpected, so allow the users to see them
+      # (that is, avoid stderr redirection).
+      am_uid=`id -u || echo unknown`
+      am_gid=`id -g || echo unknown`
+      AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
+      if test $am_uid -le $am_max_uid; then
+         AC_MSG_RESULT([yes])
+      else
+         AC_MSG_RESULT([no])
+         _am_tools=none
+      fi
+      AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
+      if test $am_gid -le $am_max_gid; then
+         AC_MSG_RESULT([yes])
+      else
+        AC_MSG_RESULT([no])
+        _am_tools=none
+      fi],
+
+  [pax],
+    [],
+
+  [m4_fatal([Unknown tar format])])
+
+  AC_MSG_CHECKING([how to create a $1 tar archive])
+
+  # Go ahead even if we have the value already cached.  We do so because we
+  # need to set the values for the 'am__tar' and 'am__untar' variables.
+  _am_tools=${am_cv_prog_tar_$1-$_am_tools}
+
+  for _am_tool in $_am_tools; do
+    case $_am_tool in
+    gnutar)
+      for _am_tar in tar gnutar gtar; do
+        AM_RUN_LOG([$_am_tar --version]) && break
+      done
+      am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
+      am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
+      am__untar="$_am_tar -xf -"
+      ;;
+    plaintar)
+      # Must skip GNU tar: if it does not support --format= it doesn't create
+      # ustar tarball either.
+      (tar --version) >/dev/null 2>&1 && continue
+      am__tar='tar chf - "$$tardir"'
+      am__tar_='tar chf - "$tardir"'
+      am__untar='tar xf -'
+      ;;
+    pax)
+      am__tar='pax -L -x $1 -w "$$tardir"'
+      am__tar_='pax -L -x $1 -w "$tardir"'
+      am__untar='pax -r'
+      ;;
+    cpio)
+      am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
+      am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
+      am__untar='cpio -i -H $1 -d'
+      ;;
+    none)
+      am__tar=false
+      am__tar_=false
+      am__untar=false
+      ;;
+    esac
+
+    # If the value was cached, stop now.  We just wanted to have am__tar
+    # and am__untar set.
+    test -n "${am_cv_prog_tar_$1}" && break
+
+    # tar/untar a dummy directory, and stop if the command works.
+    rm -rf conftest.dir
+    mkdir conftest.dir
+    echo GrepMe > conftest.dir/file
+    AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
+    rm -rf conftest.dir
+    if test -s conftest.tar; then
+      AM_RUN_LOG([$am__untar <conftest.tar])
+      AM_RUN_LOG([cat conftest.dir/file])
+      grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
+    fi
+  done
+  rm -rf conftest.dir
+
+  AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
+  AC_MSG_RESULT([$am_cv_prog_tar_$1])])
+
+AC_SUBST([am__tar])
+AC_SUBST([am__untar])
+]) # _AM_PROG_TAR
+
+m4_include([m4/ax_ac_append_to_file.m4])
+m4_include([m4/ax_ac_print_to_file.m4])
+m4_include([m4/ax_add_am_macro_static.m4])
+m4_include([m4/ax_am_macros_static.m4])
+m4_include([m4/ax_check_gnu_make.m4])
+m4_include([m4/ax_code_coverage.m4])
+m4_include([m4/ax_cxx_compile_stdcxx_11.m4])
+m4_include([m4/ax_file_escapes.m4])
+m4_include([m4/ax_require_defined.m4])
+m4_include([m4/cares-compilers.m4])
+m4_include([m4/cares-confopts.m4])
+m4_include([m4/cares-functions.m4])
+m4_include([m4/cares-reentrant.m4])
+m4_include([m4/libtool.m4])
+m4_include([m4/ltoptions.m4])
+m4_include([m4/ltsugar.m4])
+m4_include([m4/ltversion.m4])
+m4_include([m4/lt~obsolete.m4])
+m4_include([m4/xc-am-iface.m4])
+m4_include([m4/xc-cc-check.m4])
+m4_include([m4/xc-lt-iface.m4])
+m4_include([m4/xc-translit.m4])
+m4_include([m4/xc-val-flgs.m4])
+m4_include([m4/zz40-xc-ovr.m4])
+m4_include([acinclude.m4])
diff --git a/deps/cares/aminclude_static.am b/deps/cares/aminclude_static.am
new file mode 100644
index 0000000000000000000000000000000000000000..c90aef60a4bcf46bfa0c70a1f95dd1ece7d172c5
--- /dev/null
+++ b/deps/cares/aminclude_static.am
@@ -0,0 +1,126 @@
+
+# aminclude_static.am generated automatically by Autoconf
+# from AX_AM_MACROS_STATIC on Wed Oct 27 08:06:13 CEST 2021
+
+
+# Code coverage
+#
+# Optional:
+#  - CODE_COVERAGE_DIRECTORY: Top-level directory for code coverage reporting.
+#    Multiple directories may be specified, separated by whitespace.
+#    (Default: $(top_builddir))
+#  - CODE_COVERAGE_OUTPUT_FILE: Filename and path for the .info file generated
+#    by lcov for code coverage. (Default:
+#    $(PACKAGE_NAME)-$(PACKAGE_VERSION)-coverage.info)
+#  - CODE_COVERAGE_OUTPUT_DIRECTORY: Directory for generated code coverage
+#    reports to be created. (Default:
+#    $(PACKAGE_NAME)-$(PACKAGE_VERSION)-coverage)
+#  - CODE_COVERAGE_BRANCH_COVERAGE: Set to 1 to enforce branch coverage,
+#    set to 0 to disable it and leave empty to stay with the default.
+#    (Default: empty)
+#  - CODE_COVERAGE_LCOV_SHOPTS_DEFAULT: Extra options shared between both lcov
+#    instances. (Default: based on )
+#  - CODE_COVERAGE_LCOV_SHOPTS: Extra options to shared between both lcov
+#    instances. (Default: )
+#  - CODE_COVERAGE_LCOV_OPTIONS_GCOVPATH: --gcov-tool pathtogcov
+#  - CODE_COVERAGE_LCOV_OPTIONS_DEFAULT: Extra options to pass to the
+#    collecting lcov instance. (Default: )
+#  - CODE_COVERAGE_LCOV_OPTIONS: Extra options to pass to the collecting lcov
+#    instance. (Default: )
+#  - CODE_COVERAGE_LCOV_RMOPTS_DEFAULT: Extra options to pass to the filtering
+#    lcov instance. (Default: empty)
+#  - CODE_COVERAGE_LCOV_RMOPTS: Extra options to pass to the filtering lcov
+#    instance. (Default: )
+#  - CODE_COVERAGE_GENHTML_OPTIONS_DEFAULT: Extra options to pass to the
+#    genhtml instance. (Default: based on )
+#  - CODE_COVERAGE_GENHTML_OPTIONS: Extra options to pass to the genhtml
+#    instance. (Default: )
+#  - CODE_COVERAGE_IGNORE_PATTERN: Extra glob pattern of files to ignore
+#
+# The generated report will be titled using the $(PACKAGE_NAME) and
+# $(PACKAGE_VERSION). In order to add the current git hash to the title,
+# use the git-version-gen script, available online.
+# Optional variables
+# run only on top dir
+if CODE_COVERAGE_ENABLED
+ ifeq ($(abs_builddir), $(abs_top_builddir))
+CODE_COVERAGE_DIRECTORY ?= $(top_builddir)
+CODE_COVERAGE_OUTPUT_FILE ?= $(PACKAGE_NAME)-$(PACKAGE_VERSION)-coverage.info
+CODE_COVERAGE_OUTPUT_DIRECTORY ?= $(PACKAGE_NAME)-$(PACKAGE_VERSION)-coverage
+
+CODE_COVERAGE_BRANCH_COVERAGE ?=
+CODE_COVERAGE_LCOV_SHOPTS_DEFAULT ?= $(if $(CODE_COVERAGE_BRANCH_COVERAGE),--rc lcov_branch_coverage=$(CODE_COVERAGE_BRANCH_COVERAGE))
+CODE_COVERAGE_LCOV_SHOPTS ?= $(CODE_COVERAGE_LCOV_SHOPTS_DEFAULT)
+CODE_COVERAGE_LCOV_OPTIONS_GCOVPATH ?= --gcov-tool "$(GCOV)"
+CODE_COVERAGE_LCOV_OPTIONS_DEFAULT ?= $(CODE_COVERAGE_LCOV_OPTIONS_GCOVPATH)
+CODE_COVERAGE_LCOV_OPTIONS ?= $(CODE_COVERAGE_LCOV_OPTIONS_DEFAULT)
+CODE_COVERAGE_LCOV_RMOPTS_DEFAULT ?=
+CODE_COVERAGE_LCOV_RMOPTS ?= $(CODE_COVERAGE_LCOV_RMOPTS_DEFAULT)
+CODE_COVERAGE_GENHTML_OPTIONS_DEFAULT ?=$(if $(CODE_COVERAGE_BRANCH_COVERAGE),--rc genhtml_branch_coverage=$(CODE_COVERAGE_BRANCH_COVERAGE))
+CODE_COVERAGE_GENHTML_OPTIONS ?= $(CODE_COVERAGE_GENHTML_OPTIONS_DEFAULT)
+CODE_COVERAGE_IGNORE_PATTERN ?=
+
+GITIGNOREFILES := $(GITIGNOREFILES) $(CODE_COVERAGE_OUTPUT_FILE) $(CODE_COVERAGE_OUTPUT_DIRECTORY)
+code_coverage_v_lcov_cap = $(code_coverage_v_lcov_cap_$(V))
+code_coverage_v_lcov_cap_ = $(code_coverage_v_lcov_cap_$(AM_DEFAULT_VERBOSITY))
+code_coverage_v_lcov_cap_0 = @echo "  LCOV   --capture" $(CODE_COVERAGE_OUTPUT_FILE);
+code_coverage_v_lcov_ign = $(code_coverage_v_lcov_ign_$(V))
+code_coverage_v_lcov_ign_ = $(code_coverage_v_lcov_ign_$(AM_DEFAULT_VERBOSITY))
+code_coverage_v_lcov_ign_0 = @echo "  LCOV   --remove /tmp/*" $(CODE_COVERAGE_IGNORE_PATTERN);
+code_coverage_v_genhtml = $(code_coverage_v_genhtml_$(V))
+code_coverage_v_genhtml_ = $(code_coverage_v_genhtml_$(AM_DEFAULT_VERBOSITY))
+code_coverage_v_genhtml_0 = @echo "  GEN   " "$(CODE_COVERAGE_OUTPUT_DIRECTORY)";
+code_coverage_quiet = $(code_coverage_quiet_$(V))
+code_coverage_quiet_ = $(code_coverage_quiet_$(AM_DEFAULT_VERBOSITY))
+code_coverage_quiet_0 = --quiet
+
+# sanitizes the test-name: replaces with underscores: dashes and dots
+code_coverage_sanitize = $(subst -,_,$(subst .,_,$(1)))
+
+# Use recursive makes in order to ignore errors during check
+check-code-coverage:
+	-$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -k check
+	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) code-coverage-capture
+
+# Capture code coverage data
+code-coverage-capture: code-coverage-capture-hook
+	$(code_coverage_v_lcov_cap)$(LCOV) $(code_coverage_quiet) $(addprefix --directory ,$(CODE_COVERAGE_DIRECTORY)) --capture --output-file "$(CODE_COVERAGE_OUTPUT_FILE).tmp" --test-name "$(call code_coverage_sanitize,$(PACKAGE_NAME)-$(PACKAGE_VERSION))" --no-checksum --compat-libtool $(CODE_COVERAGE_LCOV_SHOPTS) $(CODE_COVERAGE_LCOV_OPTIONS)
+	$(code_coverage_v_lcov_ign)$(LCOV) $(code_coverage_quiet) $(addprefix --directory ,$(CODE_COVERAGE_DIRECTORY)) --remove "$(CODE_COVERAGE_OUTPUT_FILE).tmp" "/tmp/*" $(CODE_COVERAGE_IGNORE_PATTERN) --output-file "$(CODE_COVERAGE_OUTPUT_FILE)" $(CODE_COVERAGE_LCOV_SHOPTS) $(CODE_COVERAGE_LCOV_RMOPTS)
+	-@rm -f "$(CODE_COVERAGE_OUTPUT_FILE).tmp"
+	$(code_coverage_v_genhtml)LANG=C $(GENHTML) $(code_coverage_quiet) $(addprefix --prefix ,$(CODE_COVERAGE_DIRECTORY)) --output-directory "$(CODE_COVERAGE_OUTPUT_DIRECTORY)" --title "$(PACKAGE_NAME)-$(PACKAGE_VERSION) Code Coverage" --legend --show-details "$(CODE_COVERAGE_OUTPUT_FILE)" $(CODE_COVERAGE_GENHTML_OPTIONS)
+	@echo "file://$(abs_builddir)/$(CODE_COVERAGE_OUTPUT_DIRECTORY)/index.html"
+
+code-coverage-clean:
+	-$(LCOV) --directory $(top_builddir) -z
+	-rm -rf "$(CODE_COVERAGE_OUTPUT_FILE)" "$(CODE_COVERAGE_OUTPUT_FILE).tmp" "$(CODE_COVERAGE_OUTPUT_DIRECTORY)"
+	-find . \( -name "*.gcda" -o -name "*.gcno" -o -name "*.gcov" \) -delete
+
+code-coverage-dist-clean:
+
+AM_DISTCHECK_CONFIGURE_FLAGS := $(AM_DISTCHECK_CONFIGURE_FLAGS) --disable-code-coverage
+ else # ifneq ($(abs_builddir), $(abs_top_builddir))
+check-code-coverage:
+
+code-coverage-capture: code-coverage-capture-hook
+
+code-coverage-clean:
+
+code-coverage-dist-clean:
+ endif # ifeq ($(abs_builddir), $(abs_top_builddir))
+else #! CODE_COVERAGE_ENABLED
+# Use recursive makes in order to ignore errors during check
+check-code-coverage:
+	@echo "Need to reconfigure with --enable-code-coverage"
+# Capture code coverage data
+code-coverage-capture: code-coverage-capture-hook
+	@echo "Need to reconfigure with --enable-code-coverage"
+
+code-coverage-clean:
+
+code-coverage-dist-clean:
+
+endif #CODE_COVERAGE_ENABLED
+# Hook rule executed before code-coverage-capture, overridable by the user
+code-coverage-capture-hook:
+
+.PHONY: check-code-coverage code-coverage-capture code-coverage-dist-clean code-coverage-clean code-coverage-capture-hook
diff --git a/deps/cares/buildconf b/deps/cares/buildconf
new file mode 100755
index 0000000000000000000000000000000000000000..4e4c17e99919804a34846ed212e25445355afd06
--- /dev/null
+++ b/deps/cares/buildconf
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+echo "*** Do not use buildconf. Instead, just use: autoreconf -fi" >&2
+exec ${AUTORECONF:-autoreconf} -fi "${@}"
diff --git a/deps/cares/buildconf.bat b/deps/cares/buildconf.bat
new file mode 100644
index 0000000000000000000000000000000000000000..dcee45239b8b5829945e3263cb2fc7150cf61b66
--- /dev/null
+++ b/deps/cares/buildconf.bat
@@ -0,0 +1,20 @@
+@echo off
+REM
+REM
+REM This batch file must be used to set up a git tree to build on
+REM systems where there is no autotools support (i.e. Microsoft).
+REM
+REM This file is not included nor needed for c-ares' release
+REM archives, neither for c-ares' daily snapshot archives.
+
+if exist GIT-INFO goto start_doing
+ECHO ERROR: This file shall only be used with a c-ares git checkout.
+goto end_all
+:start_doing
+
+if not exist include\ares_build.h.dist goto end_ares_build_h
+copy /Y include\ares_build.h.dist include\ares_build.h
+:end_ares_build_h
+
+:end_all
+
diff --git a/deps/cares/c-ares-config.cmake.in b/deps/cares/c-ares-config.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..464837b3750e4a92b8530430abec1ca5bfe558d5
--- /dev/null
+++ b/deps/cares/c-ares-config.cmake.in
@@ -0,0 +1,21 @@
+@PACKAGE_INIT@
+
+set_and_check(c-ares_INCLUDE_DIR "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@")
+
+include("${CMAKE_CURRENT_LIST_DIR}/c-ares-config-version.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/c-ares-targets.cmake")
+
+set(c-ares_LIBRARY c-ares::cares)
+
+if(@CARES_SHARED@)
+	add_library(c-ares::cares_shared INTERFACE IMPORTED)
+	set_target_properties(c-ares::cares_shared PROPERTIES INTERFACE_LINK_LIBRARIES "c-ares::cares")
+	set(c-ares_SHARED_LIBRARY c-ares::cares_shared)
+elseif(@CARES_STATIC@)
+	add_library(c-ares::cares_static INTERFACE IMPORTED)
+	set_target_properties(c-ares::cares_static PROPERTIES INTERFACE_LINK_LIBRARIES "c-ares::cares")
+endif()
+
+if(@CARES_STATIC@)
+	set(c-ares_STATIC_LIBRARY c-ares::cares_static)
+endif()
diff --git a/deps/cares/cares.gyp b/deps/cares/cares.gyp
index 6c12fc5948d5abc3de284a90af786a8f748380a4..88933e00745d305cd9874f6ca0f27ae132678bf4 100644
--- a/deps/cares/cares.gyp
+++ b/deps/cares/cares.gyp
@@ -30,15 +30,18 @@
     {
       'target_name': 'cares',
       'type': '<(library)',
-      'include_dirs': [ 'include', 'src/lib' ],
+      'include_dirs': [ 'include' ],
       'direct_dependent_settings': {
-        'include_dirs': [ 'include', 'src/lib' ]
+        'include_dirs': [ 'include' ]
       },
       'sources': [
         'include/ares.h',
         'include/ares_dns.h',
+        'include/ares_nameser.h',
         'include/ares_rules.h',
         'include/ares_version.h',
+        'src/lib/ares__addrinfo2hostent.c',
+        'src/lib/ares__addrinfo_localhost.c',
         'src/lib/ares_android.c',
         'src/lib/ares_cancel.c',
         'src/lib/ares__close_sockets.c',
@@ -66,7 +69,6 @@
         'src/lib/ares_llist.c',
         'src/lib/ares_llist.h',
         'src/lib/ares_mkquery.c',
-        'src/lib/ares_nameser.h',
         'src/lib/ares_nowarn.c',
         'src/lib/ares_nowarn.h',
         'src/lib/ares_options.c',
@@ -81,6 +83,7 @@
         'src/lib/ares_parse_soa_reply.c',
         'src/lib/ares_parse_srv_reply.c',
         'src/lib/ares_parse_txt_reply.c',
+        'src/lib/ares_parse_uri_reply.c',
         'src/lib/ares_platform.h',
         'src/lib/ares_private.h',
         'src/lib/ares_process.c',
diff --git a/deps/cares/configure b/deps/cares/configure
new file mode 100755
index 0000000000000000000000000000000000000000..737f0a0ddd93e6629f91196cd051be423500dff2
--- /dev/null
+++ b/deps/cares/configure
@@ -0,0 +1,36935 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.71 for c-ares 1.18.1.
+#
+# Report bugs to <c-ares mailing list: http://lists.haxx.se/listinfo/c-ares>.
+#
+#
+# Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation,
+# Inc.
+#
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+
+## -------------------------------- ##
+##  XC_CONFIGURE_PREAMBLE ver: 1.0  ##
+## -------------------------------- ##
+
+xc_configure_preamble_ver_major='1'
+xc_configure_preamble_ver_minor='0'
+
+#
+# Set IFS to space, tab and newline.
+#
+
+xc_space=' '
+xc_tab='	'
+xc_newline='
+'
+IFS="$xc_space$xc_tab$xc_newline"
+
+#
+# Set internationalization behavior variables.
+#
+
+LANG='C'
+LC_ALL='C'
+LANGUAGE='C'
+export LANG
+export LC_ALL
+export LANGUAGE
+
+#
+# Some useful variables.
+#
+
+xc_msg_warn='configure: WARNING:'
+xc_msg_abrt='Can not continue.'
+xc_msg_err='configure: error:'
+
+#
+# Verify that 'echo' command is available, otherwise abort.
+#
+
+xc_tst_str='unknown'
+(`echo "$xc_tst_str" >/dev/null 2>&1`) && xc_tst_str='success'
+case "x$xc_tst_str" in # ((
+  xsuccess)
+    :
+    ;;
+  *)
+    # Try built-in echo, and fail.
+    echo "$xc_msg_err 'echo' command not found. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Verify that 'test' command is available, otherwise abort.
+#
+
+xc_tst_str='unknown'
+(`test -n "$xc_tst_str" >/dev/null 2>&1`) && xc_tst_str='success'
+case "x$xc_tst_str" in # ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'test' command not found. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Verify that 'PATH' variable is set, otherwise abort.
+#
+
+xc_tst_str='unknown'
+(`test -n "$PATH" >/dev/null 2>&1`) && xc_tst_str='success'
+case "x$xc_tst_str" in # ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'PATH' variable not set. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Verify that 'expr' command is available, otherwise abort.
+#
+
+xc_tst_str='unknown'
+xc_tst_str=`expr "$xc_tst_str" : '.*' 2>/dev/null`
+case "x$xc_tst_str" in # ((
+  x7)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'expr' command not found. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Verify that 'sed' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str='unknown'
+xc_tst_str=`echo "$xc_tst_str" 2>/dev/null \
+  | sed -e 's:unknown:success:' 2>/dev/null`
+case "x$xc_tst_str" in # ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'sed' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Verify that 'grep' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str='unknown'
+(`echo "$xc_tst_str" 2>/dev/null \
+  | grep 'unknown' >/dev/null 2>&1`) && xc_tst_str='success'
+case "x$xc_tst_str" in # ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'grep' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Verify that 'tr' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str="${xc_tab}98s7u6c5c4e3s2s10"
+xc_tst_str=`echo "$xc_tst_str" 2>/dev/null \
+  | tr -d "0123456789$xc_tab" 2>/dev/null`
+case "x$xc_tst_str" in # ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'tr' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Verify that 'wc' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str='unknown unknown unknown unknown'
+xc_tst_str=`echo "$xc_tst_str" 2>/dev/null \
+  | wc -w 2>/dev/null | tr -d "$xc_space$xc_tab" 2>/dev/null`
+case "x$xc_tst_str" in # ((
+  x4)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'wc' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Verify that 'cat' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str='unknown'
+xc_tst_str=`cat <<_EOT 2>/dev/null \
+  | wc -l 2>/dev/null | tr -d "$xc_space$xc_tab" 2>/dev/null
+unknown
+unknown
+unknown
+_EOT`
+case "x$xc_tst_str" in # ((
+  x3)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'cat' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+
+#
+# Auto-detect and set 'PATH_SEPARATOR', unless it is already non-empty set.
+#
+
+# Directory count in 'PATH' when using a colon separator.
+xc_tst_dirs_col='x'
+xc_tst_prev_IFS=$IFS; IFS=':'
+for xc_tst_dir in $PATH; do
+  IFS=$xc_tst_prev_IFS
+  xc_tst_dirs_col="x$xc_tst_dirs_col"
+done
+IFS=$xc_tst_prev_IFS
+xc_tst_dirs_col=`expr "$xc_tst_dirs_col" : '.*'`
+
+# Directory count in 'PATH' when using a semicolon separator.
+xc_tst_dirs_sem='x'
+xc_tst_prev_IFS=$IFS; IFS=';'
+for xc_tst_dir in $PATH; do
+  IFS=$xc_tst_prev_IFS
+  xc_tst_dirs_sem="x$xc_tst_dirs_sem"
+done
+IFS=$xc_tst_prev_IFS
+xc_tst_dirs_sem=`expr "$xc_tst_dirs_sem" : '.*'`
+
+if test $xc_tst_dirs_sem -eq $xc_tst_dirs_col; then
+  # When both counting methods give the same result we do not want to
+  # chose one over the other, and consider auto-detection not possible.
+  if test -z "$PATH_SEPARATOR"; then
+    # Stop dead until user provides 'PATH_SEPARATOR' definition.
+    echo "$xc_msg_err 'PATH_SEPARATOR' variable not set. $xc_msg_abrt" >&2
+    exit 1
+  fi
+else
+  # Separator with the greater directory count is the auto-detected one.
+  if test $xc_tst_dirs_sem -gt $xc_tst_dirs_col; then
+    xc_tst_auto_separator=';'
+  else
+    xc_tst_auto_separator=':'
+  fi
+  if test -z "$PATH_SEPARATOR"; then
+    # Simply use the auto-detected one when not already set.
+    PATH_SEPARATOR=$xc_tst_auto_separator
+  elif test "x$PATH_SEPARATOR" != "x$xc_tst_auto_separator"; then
+    echo "$xc_msg_warn 'PATH_SEPARATOR' does not match auto-detected one." >&2
+  fi
+fi
+xc_PATH_SEPARATOR=$PATH_SEPARATOR
+
+xc_configure_preamble_result='yes'
+
+
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+as_nop=:
+if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
+then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else $as_nop
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+
+# Reset variables that may have inherited troublesome values from
+# the environment.
+
+# IFS needs to be set, to space, tab, and newline, in precisely that order.
+# (If _AS_PATH_WALK were called with IFS unset, it would have the
+# side effect of setting IFS to empty, thus disabling word splitting.)
+# Quoting is to prevent editors from complaining about space-tab.
+as_nl='
+'
+export as_nl
+IFS=" ""	$as_nl"
+
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# Ensure predictable behavior from utilities with locale-dependent output.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# We cannot yet rely on "unset" to work, but we need these variables
+# to be unset--not just set to an empty or harmless value--now, to
+# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh).  This construct
+# also avoids known problems related to "unset" and subshell syntax
+# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
+for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
+do eval test \${$as_var+y} \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+
+# Ensure that fds 0, 1, and 2 are open.
+if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi
+if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
+if (exec 3>&2)            ; then :; else exec 2>/dev/null; fi
+
+
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    test -r "$as_dir$0" && as_myself=$as_dir$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="as_nop=:
+if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
+then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else \$as_nop
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" )
+then :
+
+else \$as_nop
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+blah=\$(echo \$(echo blah))
+test x\"\$blah\" = xblah || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1
+
+  test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || (
+    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
+    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
+    PATH=/empty FPATH=/empty; export PATH FPATH
+    test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\
+      || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1"
+  if (eval "$as_required") 2>/dev/null
+then :
+  as_have_required=yes
+else $as_nop
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null
+then :
+
+else $as_nop
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null
+then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null
+then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+IFS=$as_save_IFS
+if $as_found
+then :
+
+else $as_nop
+  if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null
+then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi
+fi
+
+
+      if test "x$CONFIG_SHELL" != x
+then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno
+then :
+  printf "%s\n" "$0: This script requires a shell more modern than all"
+  printf "%s\n" "$0: the shells that I found on your system."
+  if test ${ZSH_VERSION+y} ; then
+    printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and c-ares mailing
+$0: list: http://lists.haxx.se/listinfo/c-ares about your
+$0: system, including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+# as_fn_nop
+# ---------
+# Do nothing but, unlike ":", preserve the value of $?.
+as_fn_nop ()
+{
+  return $?
+}
+as_nop=as_fn_nop
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
+then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else $as_nop
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
+then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else $as_nop
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+# as_fn_nop
+# ---------
+# Do nothing but, unlike ":", preserve the value of $?.
+as_fn_nop ()
+{
+  return $?
+}
+as_nop=as_fn_nop
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  printf "%s\n" "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+
+# Determine whether it's possible to make 'echo' print without a newline.
+# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
+# for compatibility with existing Makefiles.
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+# For backward compatibility with old third-party macros, we provide
+# the shell variables $as_echo and $as_echo_n.  New code should use
+# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
+as_echo='printf %s\n'
+as_echo_n='printf %s'
+
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME='c-ares'
+PACKAGE_TARNAME='c-ares'
+PACKAGE_VERSION='1.18.1'
+PACKAGE_STRING='c-ares 1.18.1'
+PACKAGE_BUGREPORT='c-ares mailing list: http://lists.haxx.se/listinfo/c-ares'
+PACKAGE_URL=''
+
+ac_unique_file="src/lib/ares_ipv6.h"
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stddef.h>
+#ifdef HAVE_STDIO_H
+# include <stdio.h>
+#endif
+#ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_header_c_list=
+enable_option_checking=no
+ac_subst_vars='am__EXEEXT_FALSE
+am__EXEEXT_TRUE
+LTLIBOBJS
+LIBOBJS
+BUILD_SUBDIRS
+subdirs
+CARES_CFLAG_EXTRAS
+CARES_PRIVATE_LIBS
+CFLAG_CARES_SYMBOL_HIDING
+DOING_CARES_SYMBOL_HIDING_FALSE
+DOING_CARES_SYMBOL_HIDING_TRUE
+CARES_RANDOM_FILE
+DOING_NATIVE_WINDOWS_FALSE
+DOING_NATIVE_WINDOWS_TRUE
+CPPFLAG_CARES_STATICLIB
+USE_CPPFLAG_CARES_STATICLIB_FALSE
+USE_CPPFLAG_CARES_STATICLIB_TRUE
+CARES_LT_SHLIB_USE_MIMPURE_TEXT_FALSE
+CARES_LT_SHLIB_USE_MIMPURE_TEXT_TRUE
+CARES_LT_SHLIB_USE_NO_UNDEFINED_FALSE
+CARES_LT_SHLIB_USE_NO_UNDEFINED_TRUE
+CARES_LT_SHLIB_USE_VERSION_INFO_FALSE
+CARES_LT_SHLIB_USE_VERSION_INFO_TRUE
+CXXCPP
+LT_SYS_LIBRARY_PATH
+OTOOL64
+OTOOL
+LIPO
+NMEDIT
+DSYMUTIL
+MANIFEST_TOOL
+RANLIB
+ac_ct_AR
+LN_S
+NM
+ac_ct_DUMPBIN
+DUMPBIN
+LD
+FGREP
+LIBTOOL
+OBJDUMP
+DLLTOOL
+AS
+CSCOPE
+ETAGS
+CTAGS
+am__fastdepCXX_FALSE
+am__fastdepCXX_TRUE
+CXXDEPMODE
+am__fastdepCC_FALSE
+am__fastdepCC_TRUE
+CCDEPMODE
+am__nodep
+AMDEPBACKSLASH
+AMDEP_FALSE
+AMDEP_TRUE
+am__include
+DEPDIR
+am__untar
+am__tar
+AMTAR
+am__leading_dot
+SET_MAKE
+mkdir_p
+MKDIR_P
+INSTALL_STRIP_PROGRAM
+STRIP
+install_sh
+MAKEINFO
+AUTOHEADER
+AUTOMAKE
+AUTOCONF
+ACLOCAL
+VERSION
+PACKAGE
+CYGPATH_W
+am__isrc
+HAVE_CXX11
+ac_ct_CXX
+CXXFLAGS
+CXX
+CPP
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+INSTALL_DATA
+INSTALL_SCRIPT
+INSTALL_PROGRAM
+host_os
+host_vendor
+host_cpu
+host
+build_os
+build_vendor
+build_cpu
+build
+CODE_COVERAGE_LIBS
+CODE_COVERAGE_CXXFLAGS
+CODE_COVERAGE_CFLAGS
+CODE_COVERAGE_CPPFLAGS
+GENHTML
+LCOV
+GCOV
+ifnGNUmake
+ifGNUmake
+AWK
+CODE_COVERAGE_ENABLED
+CODE_COVERAGE_ENABLED_FALSE
+CODE_COVERAGE_ENABLED_TRUE
+AR
+EGREP
+GREP
+SED
+AM_BACKSLASH
+AM_DEFAULT_VERBOSITY
+AM_DEFAULT_V
+AM_V
+MAINT
+MAINTAINER_MODE_FALSE
+MAINTAINER_MODE_TRUE
+CARES_VERSION_INFO
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+runstatedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+SHELL
+PATH_SEPARATOR
+am__quote'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_maintainer_mode
+enable_silent_rules
+enable_debug
+enable_optimize
+enable_warnings
+enable_werror
+enable_symbol_hiding
+enable_expose_statics
+with_gcov
+enable_code_coverage
+enable_dependency_tracking
+enable_largefile
+enable_shared
+enable_static
+with_pic
+enable_fast_install
+with_aix_soname
+with_gnu_ld
+with_sysroot
+enable_libtool_lock
+enable_libgcc
+with_random
+enable_nonblocking
+enable_tests
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CPP
+CXX
+CXXFLAGS
+CCC
+LT_SYS_LIBRARY_PATH
+CXXCPP'
+ac_subdirs_all='test'
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+runstatedir='${localstatedir}/run'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: \`$ac_useropt'"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: \`$ac_useropt'"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -runstatedir | --runstatedir | --runstatedi | --runstated \
+  | --runstate | --runstat | --runsta | --runst | --runs \
+  | --run | --ru | --r)
+    ac_prev=runstatedir ;;
+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+  | --run=* | --ru=* | --r=*)
+    runstatedir=$ac_optarg ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: \`$ac_useropt'"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: \`$ac_useropt'"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir runstatedir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures c-ares 1.18.1 to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking ...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/c-ares]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+
+Program names:
+  --program-prefix=PREFIX            prepend PREFIX to installed program names
+  --program-suffix=SUFFIX            append SUFFIX to installed program names
+  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
+
+System types:
+  --build=BUILD     configure for building on BUILD [guessed]
+  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+  case $ac_init_help in
+     short | recursive ) echo "Configuration of c-ares 1.18.1:";;
+   esac
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-maintainer-mode
+                          enable make rules and dependencies not useful (and
+                          sometimes confusing) to the casual installer
+  --enable-silent-rules   less verbose build output (undo: "make V=1")
+  --disable-silent-rules  verbose build output (undo: "make V=0")
+  --enable-debug          Enable debug build options
+  --disable-debug         Disable debug build options
+  --enable-optimize(=OPT) Enable compiler optimizations (default=-O2)
+  --disable-optimize      Disable compiler optimizations
+  --enable-warnings       Enable strict compiler warnings
+  --disable-warnings      Disable strict compiler warnings
+  --enable-werror         Enable compiler warnings as errors
+  --disable-werror        Disable compiler warnings as errors
+  --enable-symbol-hiding  Enable hiding of library internal symbols
+  --disable-symbol-hiding Disable hiding of library internal symbols
+  --enable-expose-statics Enable exposure of internal static functions for
+                          testing
+  --disable-expose-statics
+                          Disable exposure of internal static functions for
+                          testing
+  --enable-code-coverage  Whether to enable code coverage support
+  --enable-dependency-tracking
+                          do not reject slow dependency extractors
+  --disable-dependency-tracking
+                          speeds up one-time build
+  --disable-largefile     omit support for large files
+  --enable-shared[=PKGS]  build shared libraries [default=yes]
+  --enable-static[=PKGS]  build static libraries [default=yes]
+  --enable-fast-install[=PKGS]
+                          optimize for fast installation [default=yes]
+  --disable-libtool-lock  avoid locking (might break parallel builds)
+  --enable-libgcc         use libgcc when linking
+  --enable-nonblocking    Enable non-blocking communications
+  --disable-nonblocking   Disable non-blocking communications
+  --enable-tests          build test suite
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-gcov=GCOV        use given GCOV for coverage (GCOV=gcov).
+  --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
+                          both]
+  --with-aix-soname=aix|svr4|both
+                          shared library versioning (aka "SONAME") variant to
+                          provide on AIX, [default=aix].
+  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
+  --with-sysroot[=DIR]    Search for dependent libraries within DIR (or the
+                          compiler's sysroot if not specified).
+  --with-random=FILE      read randomness from FILE (default=/dev/urandom)
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+  CXX         C++ compiler command
+  CXXFLAGS    C++ compiler flags
+  LT_SYS_LIBRARY_PATH
+              User-defined run-time library search path.
+  CXXCPP      C++ preprocessor
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to <c-ares mailing list: http://lists.haxx.se/listinfo/c-ares>.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for configure.gnu first; this name is used for a wrapper for
+    # Metaconfig's "Configure" on case-insensitive file systems.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+c-ares configure 1.18.1
+generated by GNU Autoconf 2.71
+
+Copyright (C) 2021 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest.beam
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext
+then :
+  ac_retval=0
+else $as_nop
+  printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }
+then :
+  ac_retval=0
+else $as_nop
+  printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+
+# ac_fn_cxx_try_compile LINENO
+# ----------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest.beam
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext
+then :
+  ac_retval=0
+else $as_nop
+  printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_compile
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }
+then :
+  ac_retval=0
+else $as_nop
+  printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+printf %s "checking for $2... " >&6; }
+if eval test \${$3+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  eval "$3=yes"
+else $as_nop
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_check_func LINENO FUNC VAR
+# ----------------------------------
+# Tests whether FUNC exists, setting the cache variable VAR accordingly
+ac_fn_c_check_func ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+printf %s "checking for $2... " >&6; }
+if eval test \${$3+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char $2 (); below.  */
+
+#include <limits.h>
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main (void)
+{
+return $2 ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  eval "$3=yes"
+else $as_nop
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_func
+
+# ac_fn_cxx_try_cpp LINENO
+# ------------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       }
+then :
+  ac_retval=0
+else $as_nop
+  printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_cpp
+
+# ac_fn_cxx_try_link LINENO
+# -------------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }
+then :
+  ac_retval=0
+else $as_nop
+  printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_link
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that
+# executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }
+then :
+  ac_retval=0
+else $as_nop
+  printf "%s\n" "$as_me: program exited with status $ac_status" >&5
+       printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR
+# ------------------------------------------------------------------
+# Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR
+# accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR.
+ac_fn_check_decl ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  as_decl_name=`echo $2|sed 's/ *(.*//'`
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5
+printf %s "checking whether $as_decl_name is declared... " >&6; }
+if eval test \${$3+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'`
+  eval ac_save_FLAGS=\$$6
+  as_fn_append $6 " $5"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main (void)
+{
+#ifndef $as_decl_name
+#ifdef __cplusplus
+  (void) $as_decl_use;
+#else
+  (void) $as_decl_name;
+#endif
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  eval "$3=yes"
+else $as_nop
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  eval $6=\$ac_save_FLAGS
+
+fi
+eval ac_res=\$$3
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_check_decl
+
+# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
+# -------------------------------------------
+# Tests whether TYPE exists after having included INCLUDES, setting cache
+# variable VAR accordingly.
+ac_fn_c_check_type ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+printf %s "checking for $2... " >&6; }
+if eval test \${$3+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main (void)
+{
+if (sizeof ($2))
+	 return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main (void)
+{
+if (sizeof (($2)))
+	    return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+else $as_nop
+  eval "$3=yes"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_type
+
+# ac_fn_c_check_member LINENO AGGR MEMBER VAR INCLUDES
+# ----------------------------------------------------
+# Tries to find if the field MEMBER exists in type AGGR, after including
+# INCLUDES, setting cache variable VAR accordingly.
+ac_fn_c_check_member ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5
+printf %s "checking for $2.$3... " >&6; }
+if eval test \${$4+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$5
+int
+main (void)
+{
+static $2 ac_aggr;
+if (ac_aggr.$3)
+return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  eval "$4=yes"
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$5
+int
+main (void)
+{
+static $2 ac_aggr;
+if (sizeof ac_aggr.$3)
+return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  eval "$4=yes"
+else $as_nop
+  eval "$4=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+eval ac_res=\$$4
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_member
+ac_configure_args_raw=
+for ac_arg
+do
+  case $ac_arg in
+  *\'*)
+    ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+  esac
+  as_fn_append ac_configure_args_raw " '$ac_arg'"
+done
+
+case $ac_configure_args_raw in
+  *$as_nl*)
+    ac_safe_unquote= ;;
+  *)
+    ac_unsafe_z='|&;<>()$`\\"*?[ ''	' # This string ends in space, tab.
+    ac_unsafe_a="$ac_unsafe_z#~"
+    ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g"
+    ac_configure_args_raw=`      printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;;
+esac
+
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by c-ares $as_me 1.18.1, which was
+generated by GNU Autoconf 2.71.  Invocation command line was
+
+  $ $0$ac_configure_args_raw
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    printf "%s\n" "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Sanitize IFS.
+  IFS=" ""	$as_nl"
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    printf "%s\n" "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    printf "%s\n" "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      printf "%s\n" "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      printf "%s\n" "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	printf "%s\n" "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      printf "%s\n" "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      printf "%s\n" "$as_me: caught signal $ac_signal"
+    printf "%s\n" "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+printf "%s\n" "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h
+
+printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h
+
+printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h
+
+printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h
+
+printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h
+
+printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+if test -n "$CONFIG_SITE"; then
+  ac_site_files="$CONFIG_SITE"
+elif test "x$prefix" != xNONE; then
+  ac_site_files="$prefix/share/config.site $prefix/etc/config.site"
+else
+  ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+fi
+
+for ac_site_file in $ac_site_files
+do
+  case $ac_site_file in #(
+  */*) :
+     ;; #(
+  *) :
+    ac_site_file=./$ac_site_file ;;
+esac
+  if test -f "$ac_site_file" && test -r "$ac_site_file"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file" \
+      || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+printf "%s\n" "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+printf "%s\n" "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Test code for whether the C compiler supports C89 (global declarations)
+ac_c_conftest_c89_globals='
+/* Does the compiler advertise C89 conformance?
+   Do not test the value of __STDC__, because some compilers set it to 0
+   while being otherwise adequately conformant. */
+#if !defined __STDC__
+# error "Compiler does not advertise C89 conformance"
+#endif
+
+#include <stddef.h>
+#include <stdarg.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7 src/conf.sh.  */
+struct buf { int x; };
+struct buf * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not \xHH hex character constants.
+   These do not provoke an error unfortunately, instead are silently treated
+   as an "x".  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously \x00 != x always comes out true, for an
+   array size at least.  It is necessary to write \x00 == 0 to get something
+   that is true only with -std.  */
+int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) '\''x'\''
+int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int),
+               int, int);'
+
+# Test code for whether the C compiler supports C89 (body of main).
+ac_c_conftest_c89_main='
+ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]);
+'
+
+# Test code for whether the C compiler supports C99 (global declarations)
+ac_c_conftest_c99_globals='
+// Does the compiler advertise C99 conformance?
+#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+# error "Compiler does not advertise C99 conformance"
+#endif
+
+#include <stdbool.h>
+extern int puts (const char *);
+extern int printf (const char *, ...);
+extern int dprintf (int, const char *, ...);
+extern void *malloc (size_t);
+
+// Check varargs macros.  These examples are taken from C99 6.10.3.5.
+// dprintf is used instead of fprintf to avoid needing to declare
+// FILE and stderr.
+#define debug(...) dprintf (2, __VA_ARGS__)
+#define showlist(...) puts (#__VA_ARGS__)
+#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
+static void
+test_varargs_macros (void)
+{
+  int x = 1234;
+  int y = 5678;
+  debug ("Flag");
+  debug ("X = %d\n", x);
+  showlist (The first, second, and third items.);
+  report (x>y, "x is %d but y is %d", x, y);
+}
+
+// Check long long types.
+#define BIG64 18446744073709551615ull
+#define BIG32 4294967295ul
+#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
+#if !BIG_OK
+  #error "your preprocessor is broken"
+#endif
+#if BIG_OK
+#else
+  #error "your preprocessor is broken"
+#endif
+static long long int bignum = -9223372036854775807LL;
+static unsigned long long int ubignum = BIG64;
+
+struct incomplete_array
+{
+  int datasize;
+  double data[];
+};
+
+struct named_init {
+  int number;
+  const wchar_t *name;
+  double average;
+};
+
+typedef const char *ccp;
+
+static inline int
+test_restrict (ccp restrict text)
+{
+  // See if C++-style comments work.
+  // Iterate through items via the restricted pointer.
+  // Also check for declarations in for loops.
+  for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i)
+    continue;
+  return 0;
+}
+
+// Check varargs and va_copy.
+static bool
+test_varargs (const char *format, ...)
+{
+  va_list args;
+  va_start (args, format);
+  va_list args_copy;
+  va_copy (args_copy, args);
+
+  const char *str = "";
+  int number = 0;
+  float fnumber = 0;
+
+  while (*format)
+    {
+      switch (*format++)
+	{
+	case '\''s'\'': // string
+	  str = va_arg (args_copy, const char *);
+	  break;
+	case '\''d'\'': // int
+	  number = va_arg (args_copy, int);
+	  break;
+	case '\''f'\'': // float
+	  fnumber = va_arg (args_copy, double);
+	  break;
+	default:
+	  break;
+	}
+    }
+  va_end (args_copy);
+  va_end (args);
+
+  return *str && number && fnumber;
+}
+'
+
+# Test code for whether the C compiler supports C99 (body of main).
+ac_c_conftest_c99_main='
+  // Check bool.
+  _Bool success = false;
+  success |= (argc != 0);
+
+  // Check restrict.
+  if (test_restrict ("String literal") == 0)
+    success = true;
+  char *restrict newvar = "Another string";
+
+  // Check varargs.
+  success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234);
+  test_varargs_macros ();
+
+  // Check flexible array members.
+  struct incomplete_array *ia =
+    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
+  ia->datasize = 10;
+  for (int i = 0; i < ia->datasize; ++i)
+    ia->data[i] = i * 1.234;
+
+  // Check named initializers.
+  struct named_init ni = {
+    .number = 34,
+    .name = L"Test wide string",
+    .average = 543.34343,
+  };
+
+  ni.number = 58;
+
+  int dynamic_array[ni.number];
+  dynamic_array[0] = argv[0][0];
+  dynamic_array[ni.number - 1] = 543;
+
+  // work around unused variable warnings
+  ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\''
+	 || dynamic_array[ni.number - 1] != 543);
+'
+
+# Test code for whether the C compiler supports C11 (global declarations)
+ac_c_conftest_c11_globals='
+// Does the compiler advertise C11 conformance?
+#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L
+# error "Compiler does not advertise C11 conformance"
+#endif
+
+// Check _Alignas.
+char _Alignas (double) aligned_as_double;
+char _Alignas (0) no_special_alignment;
+extern char aligned_as_int;
+char _Alignas (0) _Alignas (int) aligned_as_int;
+
+// Check _Alignof.
+enum
+{
+  int_alignment = _Alignof (int),
+  int_array_alignment = _Alignof (int[100]),
+  char_alignment = _Alignof (char)
+};
+_Static_assert (0 < -_Alignof (int), "_Alignof is signed");
+
+// Check _Noreturn.
+int _Noreturn does_not_return (void) { for (;;) continue; }
+
+// Check _Static_assert.
+struct test_static_assert
+{
+  int x;
+  _Static_assert (sizeof (int) <= sizeof (long int),
+                  "_Static_assert does not work in struct");
+  long int y;
+};
+
+// Check UTF-8 literals.
+#define u8 syntax error!
+char const utf8_literal[] = u8"happens to be ASCII" "another string";
+
+// Check duplicate typedefs.
+typedef long *long_ptr;
+typedef long int *long_ptr;
+typedef long_ptr long_ptr;
+
+// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
+struct anonymous
+{
+  union {
+    struct { int i; int j; };
+    struct { int k; long int l; } w;
+  };
+  int m;
+} v1;
+'
+
+# Test code for whether the C compiler supports C11 (body of main).
+ac_c_conftest_c11_main='
+  _Static_assert ((offsetof (struct anonymous, i)
+		   == offsetof (struct anonymous, w.k)),
+		  "Anonymous union alignment botch");
+  v1.i = 2;
+  v1.w.k = 5;
+  ok |= v1.i != 5;
+'
+
+# Test code for whether the C compiler supports C11 (complete).
+ac_c_conftest_c11_program="${ac_c_conftest_c89_globals}
+${ac_c_conftest_c99_globals}
+${ac_c_conftest_c11_globals}
+
+int
+main (int argc, char **argv)
+{
+  int ok = 0;
+  ${ac_c_conftest_c89_main}
+  ${ac_c_conftest_c99_main}
+  ${ac_c_conftest_c11_main}
+  return ok;
+}
+"
+
+# Test code for whether the C compiler supports C99 (complete).
+ac_c_conftest_c99_program="${ac_c_conftest_c89_globals}
+${ac_c_conftest_c99_globals}
+
+int
+main (int argc, char **argv)
+{
+  int ok = 0;
+  ${ac_c_conftest_c89_main}
+  ${ac_c_conftest_c99_main}
+  return ok;
+}
+"
+
+# Test code for whether the C compiler supports C89 (complete).
+ac_c_conftest_c89_program="${ac_c_conftest_c89_globals}
+
+int
+main (int argc, char **argv)
+{
+  int ok = 0;
+  ${ac_c_conftest_c89_main}
+  return ok;
+}
+"
+
+# Test code for whether the C++ compiler supports C++98 (global declarations)
+ac_cxx_conftest_cxx98_globals='
+// Does the compiler advertise C++98 conformance?
+#if !defined __cplusplus || __cplusplus < 199711L
+# error "Compiler does not advertise C++98 conformance"
+#endif
+
+// These inclusions are to reject old compilers that
+// lack the unsuffixed header files.
+#include <cstdlib>
+#include <exception>
+
+// <cassert> and <cstring> are *not* freestanding headers in C++98.
+extern void assert (int);
+namespace std {
+  extern int strcmp (const char *, const char *);
+}
+
+// Namespaces, exceptions, and templates were all added after "C++ 2.0".
+using std::exception;
+using std::strcmp;
+
+namespace {
+
+void test_exception_syntax()
+{
+  try {
+    throw "test";
+  } catch (const char *s) {
+    // Extra parentheses suppress a warning when building autoconf itself,
+    // due to lint rules shared with more typical C programs.
+    assert (!(strcmp) (s, "test"));
+  }
+}
+
+template <typename T> struct test_template
+{
+  T const val;
+  explicit test_template(T t) : val(t) {}
+  template <typename U> T add(U u) { return static_cast<T>(u) + val; }
+};
+
+} // anonymous namespace
+'
+
+# Test code for whether the C++ compiler supports C++98 (body of main)
+ac_cxx_conftest_cxx98_main='
+  assert (argc);
+  assert (! argv[0]);
+{
+  test_exception_syntax ();
+  test_template<double> tt (2.0);
+  assert (tt.add (4) == 6.0);
+  assert (true && !false);
+}
+'
+
+# Test code for whether the C++ compiler supports C++11 (global declarations)
+ac_cxx_conftest_cxx11_globals='
+// Does the compiler advertise C++ 2011 conformance?
+#if !defined __cplusplus || __cplusplus < 201103L
+# error "Compiler does not advertise C++11 conformance"
+#endif
+
+namespace cxx11test
+{
+  constexpr int get_val() { return 20; }
+
+  struct testinit
+  {
+    int i;
+    double d;
+  };
+
+  class delegate
+  {
+  public:
+    delegate(int n) : n(n) {}
+    delegate(): delegate(2354) {}
+
+    virtual int getval() { return this->n; };
+  protected:
+    int n;
+  };
+
+  class overridden : public delegate
+  {
+  public:
+    overridden(int n): delegate(n) {}
+    virtual int getval() override final { return this->n * 2; }
+  };
+
+  class nocopy
+  {
+  public:
+    nocopy(int i): i(i) {}
+    nocopy() = default;
+    nocopy(const nocopy&) = delete;
+    nocopy & operator=(const nocopy&) = delete;
+  private:
+    int i;
+  };
+
+  // for testing lambda expressions
+  template <typename Ret, typename Fn> Ret eval(Fn f, Ret v)
+  {
+    return f(v);
+  }
+
+  // for testing variadic templates and trailing return types
+  template <typename V> auto sum(V first) -> V
+  {
+    return first;
+  }
+  template <typename V, typename... Args> auto sum(V first, Args... rest) -> V
+  {
+    return first + sum(rest...);
+  }
+}
+'
+
+# Test code for whether the C++ compiler supports C++11 (body of main)
+ac_cxx_conftest_cxx11_main='
+{
+  // Test auto and decltype
+  auto a1 = 6538;
+  auto a2 = 48573953.4;
+  auto a3 = "String literal";
+
+  int total = 0;
+  for (auto i = a3; *i; ++i) { total += *i; }
+
+  decltype(a2) a4 = 34895.034;
+}
+{
+  // Test constexpr
+  short sa[cxx11test::get_val()] = { 0 };
+}
+{
+  // Test initializer lists
+  cxx11test::testinit il = { 4323, 435234.23544 };
+}
+{
+  // Test range-based for
+  int array[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3,
+                 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
+  for (auto &x : array) { x += 23; }
+}
+{
+  // Test lambda expressions
+  using cxx11test::eval;
+  assert (eval ([](int x) { return x*2; }, 21) == 42);
+  double d = 2.0;
+  assert (eval ([&](double x) { return d += x; }, 3.0) == 5.0);
+  assert (d == 5.0);
+  assert (eval ([=](double x) mutable { return d += x; }, 4.0) == 9.0);
+  assert (d == 5.0);
+}
+{
+  // Test use of variadic templates
+  using cxx11test::sum;
+  auto a = sum(1);
+  auto b = sum(1, 2);
+  auto c = sum(1.0, 2.0, 3.0);
+}
+{
+  // Test constructor delegation
+  cxx11test::delegate d1;
+  cxx11test::delegate d2();
+  cxx11test::delegate d3(45);
+}
+{
+  // Test override and final
+  cxx11test::overridden o1(55464);
+}
+{
+  // Test nullptr
+  char *c = nullptr;
+}
+{
+  // Test template brackets
+  test_template<::test_template<int>> v(test_template<int>(12));
+}
+{
+  // Unicode literals
+  char const *utf8 = u8"UTF-8 string \u2500";
+  char16_t const *utf16 = u"UTF-8 string \u2500";
+  char32_t const *utf32 = U"UTF-32 string \u2500";
+}
+'
+
+# Test code for whether the C compiler supports C++11 (complete).
+ac_cxx_conftest_cxx11_program="${ac_cxx_conftest_cxx98_globals}
+${ac_cxx_conftest_cxx11_globals}
+
+int
+main (int argc, char **argv)
+{
+  int ok = 0;
+  ${ac_cxx_conftest_cxx98_main}
+  ${ac_cxx_conftest_cxx11_main}
+  return ok;
+}
+"
+
+# Test code for whether the C compiler supports C++98 (complete).
+ac_cxx_conftest_cxx98_program="${ac_cxx_conftest_cxx98_globals}
+int
+main (int argc, char **argv)
+{
+  int ok = 0;
+  ${ac_cxx_conftest_cxx98_main}
+  return ok;
+}
+"
+
+as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H"
+as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H"
+as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H"
+as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H"
+as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H"
+as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H"
+as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H"
+as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H"
+as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H"
+as_fn_append ac_header_c_list " sys/time.h sys_time_h HAVE_SYS_TIME_H"
+
+# Auxiliary files required by this configure script.
+ac_aux_files="ltmain.sh missing compile install-sh config.guess config.sub"
+
+# Locations in which to look for auxiliary files.
+ac_aux_dir_candidates="${srcdir}${PATH_SEPARATOR}${srcdir}/..${PATH_SEPARATOR}${srcdir}/../.."
+
+# Search for a directory containing all of the required auxiliary files,
+# $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates.
+# If we don't find one directory that contains all the files we need,
+# we report the set of missing files from the *first* directory in
+# $ac_aux_dir_candidates and give up.
+ac_missing_aux_files=""
+ac_first_candidate=:
+printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in $ac_aux_dir_candidates
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+  as_found=:
+
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}:  trying $as_dir" >&5
+  ac_aux_dir_found=yes
+  ac_install_sh=
+  for ac_aux in $ac_aux_files
+  do
+    # As a special case, if "install-sh" is required, that requirement
+    # can be satisfied by any of "install-sh", "install.sh", or "shtool",
+    # and $ac_install_sh is set appropriately for whichever one is found.
+    if test x"$ac_aux" = x"install-sh"
+    then
+      if test -f "${as_dir}install-sh"; then
+        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}install-sh found" >&5
+        ac_install_sh="${as_dir}install-sh -c"
+      elif test -f "${as_dir}install.sh"; then
+        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}install.sh found" >&5
+        ac_install_sh="${as_dir}install.sh -c"
+      elif test -f "${as_dir}shtool"; then
+        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}shtool found" >&5
+        ac_install_sh="${as_dir}shtool install -c"
+      else
+        ac_aux_dir_found=no
+        if $ac_first_candidate; then
+          ac_missing_aux_files="${ac_missing_aux_files} install-sh"
+        else
+          break
+        fi
+      fi
+    else
+      if test -f "${as_dir}${ac_aux}"; then
+        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}${ac_aux} found" >&5
+      else
+        ac_aux_dir_found=no
+        if $ac_first_candidate; then
+          ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}"
+        else
+          break
+        fi
+      fi
+    fi
+  done
+  if test "$ac_aux_dir_found" = yes; then
+    ac_aux_dir="$as_dir"
+    break
+  fi
+  ac_first_candidate=false
+
+  as_found=false
+done
+IFS=$as_save_IFS
+if $as_found
+then :
+
+else $as_nop
+  as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5
+fi
+
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+if test -f "${ac_aux_dir}config.guess"; then
+  ac_config_guess="$SHELL ${ac_aux_dir}config.guess"
+fi
+if test -f "${ac_aux_dir}config.sub"; then
+  ac_config_sub="$SHELL ${ac_aux_dir}config.sub"
+fi
+if test -f "$ac_aux_dir/configure"; then
+  ac_configure="$SHELL ${ac_aux_dir}configure"
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+printf "%s\n" "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+printf "%s\n" "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+printf "%s\n" "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+printf "%s\n" "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+printf "%s\n" "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file'
+	    and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+CARES_VERSION_INFO="7:1:5"
+
+
+
+ac_config_headers="$ac_config_headers src/lib/ares_config.h include/ares_build.h"
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
+printf %s "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
+    # Check whether --enable-maintainer-mode was given.
+if test ${enable_maintainer_mode+y}
+then :
+  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
+else $as_nop
+  USE_MAINTAINER_MODE=no
+fi
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
+printf "%s\n" "$USE_MAINTAINER_MODE" >&6; }
+   if test $USE_MAINTAINER_MODE = yes; then
+  MAINTAINER_MODE_TRUE=
+  MAINTAINER_MODE_FALSE='#'
+else
+  MAINTAINER_MODE_TRUE='#'
+  MAINTAINER_MODE_FALSE=
+fi
+
+  MAINT=$MAINTAINER_MODE_TRUE
+
+
+# Check whether --enable-silent-rules was given.
+if test ${enable_silent_rules+y}
+then :
+  enableval=$enable_silent_rules;
+fi
+
+case $enable_silent_rules in # (((
+  yes) AM_DEFAULT_VERBOSITY=0;;
+   no) AM_DEFAULT_VERBOSITY=1;;
+    *) AM_DEFAULT_VERBOSITY=0;;
+esac
+am_make=${MAKE-make}
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
+printf %s "checking whether $am_make supports nested variables... " >&6; }
+if test ${am_cv_make_support_nested_variables+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if printf "%s\n" 'TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
+printf "%s\n" "$am_cv_make_support_nested_variables" >&6; }
+if test $am_cv_make_support_nested_variables = yes; then
+    AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AM_BACKSLASH='\'
+
+
+
+
+
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable debug build options" >&5
+printf %s "checking whether to enable debug build options... " >&6; }
+  OPT_DEBUG_BUILD="default"
+  # Check whether --enable-debug was given.
+if test ${enable_debug+y}
+then :
+  enableval=$enable_debug; OPT_DEBUG_BUILD=$enableval
+fi
+
+  case "$OPT_DEBUG_BUILD" in
+    no)
+            want_debug="no"
+      ;;
+    default)
+            want_debug="no"
+      ;;
+    *)
+            want_debug="yes"
+      ;;
+  esac
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $want_debug" >&5
+printf "%s\n" "$want_debug" >&6; }
+
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable compiler optimizer" >&5
+printf %s "checking whether to enable compiler optimizer... " >&6; }
+  OPT_COMPILER_OPTIMIZE="default"
+  # Check whether --enable-optimize was given.
+if test ${enable_optimize+y}
+then :
+  enableval=$enable_optimize; OPT_COMPILER_OPTIMIZE=$enableval
+fi
+
+  case "$OPT_COMPILER_OPTIMIZE" in
+    no)
+                              want_optimize="no"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      ;;
+    default)
+                                                                        if test "$want_debug" = "yes"; then
+        want_optimize="assume_no"
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not specified (assuming no)" >&5
+printf "%s\n" "not specified (assuming no)" >&6; }
+      else
+        want_optimize="assume_yes"
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not specified (assuming yes)" >&5
+printf "%s\n" "not specified (assuming yes)" >&6; }
+      fi
+      ;;
+    *)
+                              want_optimize="yes"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      ;;
+  esac
+
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable strict compiler warnings" >&5
+printf %s "checking whether to enable strict compiler warnings... " >&6; }
+  OPT_COMPILER_WARNINGS="default"
+  # Check whether --enable-warnings was given.
+if test ${enable_warnings+y}
+then :
+  enableval=$enable_warnings; OPT_COMPILER_WARNINGS=$enableval
+fi
+
+  case "$OPT_COMPILER_WARNINGS" in
+    no)
+            want_warnings="no"
+      ;;
+    default)
+                  want_warnings="$want_debug"
+      ;;
+    *)
+            want_warnings="yes"
+      ;;
+  esac
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $want_warnings" >&5
+printf "%s\n" "$want_warnings" >&6; }
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable compiler warnings as errors" >&5
+printf %s "checking whether to enable compiler warnings as errors... " >&6; }
+  OPT_COMPILER_WERROR="default"
+  # Check whether --enable-werror was given.
+if test ${enable_werror+y}
+then :
+  enableval=$enable_werror; OPT_COMPILER_WERROR=$enableval
+fi
+
+  case "$OPT_COMPILER_WERROR" in
+    no)
+            want_werror="no"
+      ;;
+    default)
+            want_werror="no"
+      ;;
+    *)
+            want_werror="yes"
+      ;;
+  esac
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $want_werror" >&5
+printf "%s\n" "$want_werror" >&6; }
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable hiding of library internal symbols" >&5
+printf %s "checking whether to enable hiding of library internal symbols... " >&6; }
+  OPT_SYMBOL_HIDING="default"
+  # Check whether --enable-symbol-hiding was given.
+if test ${enable_symbol_hiding+y}
+then :
+  enableval=$enable_symbol_hiding; OPT_SYMBOL_HIDING=$enableval
+fi
+
+  case "$OPT_SYMBOL_HIDING" in
+    no)
+                              want_symbol_hiding="no"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      ;;
+    default)
+                  want_symbol_hiding="yes"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      ;;
+    *)
+                        want_symbol_hiding="yes"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      ;;
+  esac
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to expose internal static functions for testing" >&5
+printf %s "checking whether to expose internal static functions for testing... " >&6; }
+  OPT_EXPOSE_STATICS="default"
+  # Check whether --enable-expose-statics was given.
+if test ${enable_expose_statics+y}
+then :
+  enableval=$enable_expose_statics; OPT_EXPOSE_STATICS=$enableval
+fi
+
+  case "$OPT_EXPOSE_STATICS" in
+    no)
+            want_expose_statics="no"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      ;;
+    default)
+                  want_expose_statics="no"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      ;;
+    *)
+            want_expose_statics="yes"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      ;;
+  esac
+  if test "$want_expose_statics" = "yes"; then
+
+printf "%s\n" "#define CARES_EXPOSE_STATICS 1" >>confdefs.h
+
+  fi
+
+
+#
+# Check that 'XC_CONFIGURE_PREAMBLE' has already run.
+#
+
+if test -z "$xc_configure_preamble_result"; then
+  as_fn_error $? "xc_configure_preamble_result not set (internal problem)" "$LINENO" 5
+fi
+
+#
+# Check that 'PATH_SEPARATOR' has already been set.
+#
+
+if test -z "$xc_PATH_SEPARATOR"; then
+  as_fn_error $? "xc_PATH_SEPARATOR not set (internal problem)" "$LINENO" 5
+fi
+if test -z "$PATH_SEPARATOR"; then
+  as_fn_error $? "PATH_SEPARATOR not set (internal or config.site problem)" "$LINENO" 5
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for path separator" >&5
+printf %s "checking for path separator... " >&6; }
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PATH_SEPARATOR" >&5
+printf "%s\n" "$PATH_SEPARATOR" >&6; }
+if test "x$PATH_SEPARATOR" != "x$xc_PATH_SEPARATOR"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for initial path separator" >&5
+printf %s "checking for initial path separator... " >&6; }
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xc_PATH_SEPARATOR" >&5
+printf "%s\n" "$xc_PATH_SEPARATOR" >&6; }
+  as_fn_error $? "path separator mismatch (internal or config.site problem)" "$LINENO" 5
+fi
+
+
+# Extract the first word of "sed", so it can be a program name with args.
+set dummy sed; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_path_SED+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  case $SED in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_SED="$SED" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_dummy="$PATH:/usr/bin:/usr/local/bin"
+for as_dir in $as_dummy
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_path_SED="$as_dir$ac_word$ac_exec_ext"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  test -z "$ac_cv_path_SED" && ac_cv_path_SED="not_found"
+  ;;
+esac
+fi
+SED=$ac_cv_path_SED
+if test -n "$SED"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
+printf "%s\n" "$SED" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+if test -z "$SED" || test "$SED" = "not_found"; then
+  as_fn_error $? "sed not found in PATH. Cannot continue without sed." "$LINENO" 5
+fi
+
+
+# Extract the first word of "grep", so it can be a program name with args.
+set dummy grep; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_path_GREP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  case $GREP in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_dummy="$PATH:/usr/bin:/usr/local/bin"
+for as_dir in $as_dummy
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_path_GREP="$as_dir$ac_word$ac_exec_ext"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  test -z "$ac_cv_path_GREP" && ac_cv_path_GREP="not_found"
+  ;;
+esac
+fi
+GREP=$ac_cv_path_GREP
+if test -n "$GREP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
+printf "%s\n" "$GREP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+if test -z "$GREP" || test "$GREP" = "not_found"; then
+  as_fn_error $? "grep not found in PATH. Cannot continue without grep." "$LINENO" 5
+fi
+
+
+if echo a | ($GREP -E '(a|b)') >/dev/null 2>&1; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+printf %s "checking for egrep... " >&6; }
+  EGREP="$GREP -E"
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
+printf "%s\n" "$EGREP" >&6; }
+else
+  # Extract the first word of "egrep", so it can be a program name with args.
+set dummy egrep; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_path_EGREP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  case $EGREP in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_dummy="$PATH:/usr/bin:/usr/local/bin"
+for as_dir in $as_dummy
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_path_EGREP="$as_dir$ac_word$ac_exec_ext"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  test -z "$ac_cv_path_EGREP" && ac_cv_path_EGREP="not_found"
+  ;;
+esac
+fi
+EGREP=$ac_cv_path_EGREP
+if test -n "$EGREP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
+printf "%s\n" "$EGREP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$EGREP" || test "$EGREP" = "not_found"; then
+  as_fn_error $? "egrep not found in PATH. Cannot continue without egrep." "$LINENO" 5
+fi
+
+
+if test -z "$AR"; then
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ar; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_path_AR+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  case $AR in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_AR="$AR" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_dummy="$PATH:/usr/bin:/usr/local/bin"
+for as_dir in $as_dummy
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_path_AR="$as_dir$ac_word$ac_exec_ext"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+AR=$ac_cv_path_AR
+if test -n "$AR"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+printf "%s\n" "$AR" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_path_AR"; then
+  ac_pt_AR=$AR
+  # Extract the first word of "ar", so it can be a program name with args.
+set dummy ar; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_path_ac_pt_AR+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  case $ac_pt_AR in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_ac_pt_AR="$ac_pt_AR" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_dummy="$PATH:/usr/bin:/usr/local/bin"
+for as_dir in $as_dummy
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_path_ac_pt_AR="$as_dir$ac_word$ac_exec_ext"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+ac_pt_AR=$ac_cv_path_ac_pt_AR
+if test -n "$ac_pt_AR"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_pt_AR" >&5
+printf "%s\n" "$ac_pt_AR" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_pt_AR" = x; then
+    AR="not_found"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AR=$ac_pt_AR
+  fi
+else
+  AR="$ac_cv_path_AR"
+fi
+
+  if test -z "$AR" || test "$AR" = "not_found"; then
+    as_fn_error $? "ar not found in PATH. Cannot continue without ar." "$LINENO" 5
+  fi
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+	# allow to override gcov location
+
+# Check whether --with-gcov was given.
+if test ${with_gcov+y}
+then :
+  withval=$with_gcov; _AX_CODE_COVERAGE_GCOV_PROG_WITH=$with_gcov
+else $as_nop
+  _AX_CODE_COVERAGE_GCOV_PROG_WITH=gcov
+fi
+
+
+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build with code coverage support" >&5
+printf %s "checking whether to build with code coverage support... " >&6; }
+	# Check whether --enable-code-coverage was given.
+if test ${enable_code_coverage+y}
+then :
+  enableval=$enable_code_coverage;
+else $as_nop
+  enable_code_coverage=no
+fi
+
+
+	 if test "x$enable_code_coverage" = xyes; then
+  CODE_COVERAGE_ENABLED_TRUE=
+  CODE_COVERAGE_ENABLED_FALSE='#'
+else
+  CODE_COVERAGE_ENABLED_TRUE='#'
+  CODE_COVERAGE_ENABLED_FALSE=
+fi
+
+	CODE_COVERAGE_ENABLED=$enable_code_coverage
+
+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_code_coverage" >&5
+printf "%s\n" "$enable_code_coverage" >&6; }
+
+	if  test "x$enable_code_coverage" = xyes
+then :
+
+
+	  for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_AWK+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+printf "%s\n" "$AWK" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+  test -n "$AWK" && break
+done
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU make" >&5
+printf %s "checking for GNU make... " >&6; }
+if test ${_cv_gnu_make_command+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+      _cv_gnu_make_command="" ;
+    for a in "$MAKE" make gmake gnumake ; do
+      if test -z "$a" ; then continue ; fi ;
+      if "$a" --version 2> /dev/null | grep GNU 2>&1 > /dev/null ; then
+        _cv_gnu_make_command=$a ;
+        AX_CHECK_GNU_MAKE_HEADLINE=$("$a" --version 2> /dev/null | grep "GNU Make")
+        ax_check_gnu_make_version=$(echo ${AX_CHECK_GNU_MAKE_HEADLINE} | ${AWK} -F " " '{ print $(NF); }')
+        break ;
+      fi
+    done ;
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $_cv_gnu_make_command" >&5
+printf "%s\n" "$_cv_gnu_make_command" >&6; }
+  if test "x$_cv_gnu_make_command" = x""
+then :
+  ifGNUmake="#"
+else $as_nop
+  ifGNUmake=""
+fi
+  if test "x$_cv_gnu_make_command" = x""
+then :
+  ifnGNUmake=""
+else $as_nop
+  ifnGNUmake="#"
+fi
+  if test "x$_cv_gnu_make_command" = x""
+then :
+  { ax_cv_gnu_make_command=; unset ax_cv_gnu_make_command;}
+else $as_nop
+  ax_cv_gnu_make_command=${_cv_gnu_make_command}
+fi
+  if test "x$_cv_gnu_make_command" = x""
+then :
+  as_fn_error $? "not using GNU make that is needed for coverage" "$LINENO" 5
+fi
+
+
+
+
+	# check for gcov
+	if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}$_AX_CODE_COVERAGE_GCOV_PROG_WITH", so it can be a program name with args.
+set dummy ${ac_tool_prefix}$_AX_CODE_COVERAGE_GCOV_PROG_WITH; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_GCOV+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$GCOV"; then
+  ac_cv_prog_GCOV="$GCOV" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_GCOV="${ac_tool_prefix}$_AX_CODE_COVERAGE_GCOV_PROG_WITH"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+GCOV=$ac_cv_prog_GCOV
+if test -n "$GCOV"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GCOV" >&5
+printf "%s\n" "$GCOV" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_GCOV"; then
+  ac_ct_GCOV=$GCOV
+  # Extract the first word of "$_AX_CODE_COVERAGE_GCOV_PROG_WITH", so it can be a program name with args.
+set dummy $_AX_CODE_COVERAGE_GCOV_PROG_WITH; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_GCOV+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_GCOV"; then
+  ac_cv_prog_ac_ct_GCOV="$ac_ct_GCOV" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_GCOV="$_AX_CODE_COVERAGE_GCOV_PROG_WITH"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_GCOV=$ac_cv_prog_ac_ct_GCOV
+if test -n "$ac_ct_GCOV"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_GCOV" >&5
+printf "%s\n" "$ac_ct_GCOV" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_GCOV" = x; then
+    GCOV=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    GCOV=$ac_ct_GCOV
+  fi
+else
+  GCOV="$ac_cv_prog_GCOV"
+fi
+
+	if test "X$GCOV" = "X:"
+then :
+  as_fn_error $? "gcov is needed to do coverage" "$LINENO" 5
+fi
+
+
+		if  test "$GCC" = "no"
+then :
+
+		as_fn_error $? "not compiling with gcc, which is required for gcov code coverage" "$LINENO" 5
+
+fi
+
+	# Extract the first word of "lcov", so it can be a program name with args.
+set dummy lcov; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_LCOV+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$LCOV"; then
+  ac_cv_prog_LCOV="$LCOV" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_LCOV="lcov"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+LCOV=$ac_cv_prog_LCOV
+if test -n "$LCOV"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LCOV" >&5
+printf "%s\n" "$LCOV" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+	# Extract the first word of "genhtml", so it can be a program name with args.
+set dummy genhtml; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_GENHTML+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$GENHTML"; then
+  ac_cv_prog_GENHTML="$GENHTML" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_GENHTML="genhtml"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+GENHTML=$ac_cv_prog_GENHTML
+if test -n "$GENHTML"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GENHTML" >&5
+printf "%s\n" "$GENHTML" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+
+	if  test x"$LCOV" = x
+then :
+
+		as_fn_error $? "To enable code coverage reporting you must have lcov installed" "$LINENO" 5
+
+fi
+
+	if  test x"$GENHTML" = x
+then :
+
+		as_fn_error $? "Could not find genhtml from the lcov package" "$LINENO" 5
+
+fi
+
+			CODE_COVERAGE_CPPFLAGS="-DNDEBUG"
+	CODE_COVERAGE_CFLAGS="-O0 -g -fprofile-arcs -ftest-coverage"
+	CODE_COVERAGE_CXXFLAGS="-O0 -g -fprofile-arcs -ftest-coverage"
+	CODE_COVERAGE_LIBS="-lgcov"
+
+
+
+
+
+
+
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  # Make sure we can run config.sub.
+$SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 ||
+  as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+printf %s "checking build system type... " >&6; }
+if test ${ac_cv_build+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_build_alias=$build_alias
+test "x$ac_build_alias" = x &&
+  ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"`
+test "x$ac_build_alias" = x &&
+  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
+ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` ||
+  as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+printf "%s\n" "$ac_cv_build" >&6; }
+case $ac_cv_build in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
+esac
+build=$ac_cv_build
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_build
+shift
+build_cpu=$1
+build_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+build_os=$*
+IFS=$ac_save_IFS
+case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+printf %s "checking host system type... " >&6; }
+if test ${ac_cv_host+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test "x$host_alias" = x; then
+  ac_cv_host=$ac_cv_build
+else
+  ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` ||
+    as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5
+fi
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+printf "%s\n" "$ac_cv_host" >&6; }
+case $ac_cv_host in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
+esac
+host=$ac_cv_host
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_host
+shift
+host_cpu=$1
+host_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+host_os=$*
+IFS=$ac_save_IFS
+case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+
+
+
+printf "%s\n" "#define OS \"${host}\"" >>confdefs.h
+
+
+
+  xc_prog_cc_prev_IFS=$IFS
+  xc_prog_cc_prev_LIBS=$LIBS
+  xc_prog_cc_prev_CFLAGS=$CFLAGS
+  xc_prog_cc_prev_LDFLAGS=$LDFLAGS
+  xc_prog_cc_prev_CPPFLAGS=$CPPFLAGS
+
+
+
+  xc_bad_var_libs=no
+  for xc_word in $LIBS; do
+    case "$xc_word" in
+      -l* | --library=*)
+        :
+        ;;
+      *)
+        xc_bad_var_libs=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_libs = yes; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: using LIBS: $LIBS" >&5
+printf "%s\n" "$as_me: using LIBS: $LIBS" >&6;}
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: LIBS error: LIBS may only be used to specify libraries (-lname)." >&5
+printf "%s\n" "$as_me: LIBS error: LIBS may only be used to specify libraries (-lname)." >&6;}
+  fi
+
+
+  xc_bad_var_ldflags=no
+  for xc_word in $LDFLAGS; do
+    case "$xc_word" in
+      -D*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -U*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -I*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_ldflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_ldflags = yes; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: using LDFLAGS: $LDFLAGS" >&5
+printf "%s\n" "$as_me: using LDFLAGS: $LDFLAGS" >&6;}
+    xc_bad_var_msg="LDFLAGS error: LDFLAGS may only be used to specify linker flags, not"
+    for xc_word in $LDFLAGS; do
+      case "$xc_word" in
+        -D*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -U*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -I*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -l* | --library=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&6;}
+          ;;
+      esac
+    done
+  fi
+
+
+  xc_bad_var_cppflags=no
+  for xc_word in $CPPFLAGS; do
+    case "$xc_word" in
+      -rpath*)
+        xc_bad_var_cppflags=yes
+        ;;
+      -L* | --library-path=*)
+        xc_bad_var_cppflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_cppflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_cppflags = yes; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: using CPPFLAGS: $CPPFLAGS" >&5
+printf "%s\n" "$as_me: using CPPFLAGS: $CPPFLAGS" >&6;}
+    xc_bad_var_msg="CPPFLAGS error: CPPFLAGS may only be used to specify C preprocessor flags, not"
+    for xc_word in $CPPFLAGS; do
+      case "$xc_word" in
+        -rpath*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word" >&6;}
+          ;;
+        -L* | --library-path=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word" >&6;}
+          ;;
+        -l* | --library=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&6;}
+          ;;
+      esac
+    done
+  fi
+
+
+  xc_bad_var_cflags=no
+  for xc_word in $CFLAGS; do
+    case "$xc_word" in
+      -D*)
+        xc_bad_var_cflags=yes
+        ;;
+      -U*)
+        xc_bad_var_cflags=yes
+        ;;
+      -I*)
+        xc_bad_var_cflags=yes
+        ;;
+      -rpath*)
+        xc_bad_var_cflags=yes
+        ;;
+      -L* | --library-path=*)
+        xc_bad_var_cflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_cflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_cflags = yes; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: using CFLAGS: $CFLAGS" >&5
+printf "%s\n" "$as_me: using CFLAGS: $CFLAGS" >&6;}
+    xc_bad_var_msg="CFLAGS error: CFLAGS may only be used to specify C compiler flags, not"
+    for xc_word in $CFLAGS; do
+      case "$xc_word" in
+        -D*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -U*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -I*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -rpath*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word" >&6;}
+          ;;
+        -L* | --library-path=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word" >&6;}
+          ;;
+        -l* | --library=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&6;}
+          ;;
+      esac
+    done
+  fi
+
+  if test $xc_bad_var_libs = yes ||
+     test $xc_bad_var_cflags = yes ||
+     test $xc_bad_var_ldflags = yes ||
+     test $xc_bad_var_cppflags = yes; then
+     { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Continuing even with errors mentioned immediately above this line." >&5
+printf "%s\n" "$as_me: WARNING: Continuing even with errors mentioned immediately above this line." >&2;}
+  fi
+
+
+  # Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+# Reject install programs that cannot install multiple files.
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+printf %s "checking for a BSD-compatible install... " >&6; }
+if test -z "$INSTALL"; then
+if test ${ac_cv_path_install+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    # Account for fact that we put trailing slashes in our PATH walk.
+case $as_dir in #((
+  ./ | /[cC]/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext"; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    rm -rf conftest.one conftest.two conftest.dir
+	    echo one > conftest.one
+	    echo two > conftest.two
+	    mkdir conftest.dir
+	    if "$as_dir$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir/" &&
+	      test -s conftest.one && test -s conftest.two &&
+	      test -s conftest.dir/conftest.one &&
+	      test -s conftest.dir/conftest.two
+	    then
+	      ac_cv_path_install="$as_dir$ac_prog$ac_exec_ext -c"
+	      break 3
+	    fi
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+
+  done
+IFS=$as_save_IFS
+
+rm -rf conftest.one conftest.two conftest.dir
+
+fi
+  if test ${ac_cv_path_install+y}; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    INSTALL=$ac_install_sh
+  fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+printf "%s\n" "$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+
+
+
+
+
+
+
+
+
+
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf "%s\n" "$CC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+printf "%s\n" "$ac_ct_CC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf "%s\n" "$CC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    if test "$as_dir$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf "%s\n" "$CC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf "%s\n" "$CC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+printf "%s\n" "$ac_ct_CC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args.
+set dummy ${ac_tool_prefix}clang; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}clang"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf "%s\n" "$CC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "clang", so it can be a program name with args.
+set dummy clang; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="clang"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+printf "%s\n" "$ac_ct_CC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+fi
+
+
+test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion -version; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+printf %s "checking whether the C compiler works... " >&6; }
+ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else $as_nop
+  ac_file=''
+fi
+if test -z "$ac_file"
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+printf %s "checking for C compiler default output file name... " >&6; }
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+printf "%s\n" "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+printf %s "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else $as_nop
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+printf "%s\n" "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main (void)
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+printf %s "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+printf "%s\n" "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+printf %s "checking for suffix of object files... " >&6; }
+if test ${ac_cv_objext+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else $as_nop
+  printf "%s\n" "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+printf "%s\n" "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5
+printf %s "checking whether the compiler supports GNU C... " >&6; }
+if test ${ac_cv_c_compiler_gnu+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_compiler_gnu=yes
+else $as_nop
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+y}
+ac_save_CFLAGS=$CFLAGS
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+printf %s "checking whether $CC accepts -g... " >&6; }
+if test ${ac_cv_prog_cc_g+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_prog_cc_g=yes
+else $as_nop
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+else $as_nop
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
+if test $ac_test_CFLAGS; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+ac_prog_cc_stdc=no
+if test x$ac_prog_cc_stdc = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
+printf %s "checking for $CC option to enable C11 features... " >&6; }
+if test ${ac_cv_prog_cc_c11+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_cv_prog_cc_c11=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_c_conftest_c11_program
+_ACEOF
+for ac_arg in '' -std=gnu11
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_prog_cc_c11=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+  test "x$ac_cv_prog_cc_c11" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+fi
+
+if test "x$ac_cv_prog_cc_c11" = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf "%s\n" "unsupported" >&6; }
+else $as_nop
+  if test "x$ac_cv_prog_cc_c11" = x
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf "%s\n" "none needed" >&6; }
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
+printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
+     CC="$CC $ac_cv_prog_cc_c11"
+fi
+  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
+  ac_prog_cc_stdc=c11
+fi
+fi
+if test x$ac_prog_cc_stdc = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
+printf %s "checking for $CC option to enable C99 features... " >&6; }
+if test ${ac_cv_prog_cc_c99+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_cv_prog_cc_c99=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_c_conftest_c99_program
+_ACEOF
+for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99=
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_prog_cc_c99=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+  test "x$ac_cv_prog_cc_c99" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+fi
+
+if test "x$ac_cv_prog_cc_c99" = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf "%s\n" "unsupported" >&6; }
+else $as_nop
+  if test "x$ac_cv_prog_cc_c99" = x
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf "%s\n" "none needed" >&6; }
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
+printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
+     CC="$CC $ac_cv_prog_cc_c99"
+fi
+  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
+  ac_prog_cc_stdc=c99
+fi
+fi
+if test x$ac_prog_cc_stdc = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
+printf %s "checking for $CC option to enable C89 features... " >&6; }
+if test ${ac_cv_prog_cc_c89+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_c_conftest_c89_program
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+fi
+
+if test "x$ac_cv_prog_cc_c89" = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf "%s\n" "unsupported" >&6; }
+else $as_nop
+  if test "x$ac_cv_prog_cc_c89" = x
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf "%s\n" "none needed" >&6; }
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
+     CC="$CC $ac_cv_prog_cc_c89"
+fi
+  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
+  ac_prog_cc_stdc=c89
+fi
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
+printf %s "checking whether $CC understands -c and -o together... " >&6; }
+if test ${am_cv_prog_cc_c_o+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
+   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
+printf "%s\n" "$am_cv_prog_cc_c_o" >&6; }
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+printf %s "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if test ${ac_cv_prog_CPP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+      # Double quotes because $CC needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+else $as_nop
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+  # Broken: success on invalid input.
+continue
+else $as_nop
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok
+then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+printf "%s\n" "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+else $as_nop
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+  # Broken: success on invalid input.
+continue
+else $as_nop
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok
+then :
+
+else $as_nop
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+  IFS=$xc_prog_cc_prev_IFS
+  LIBS=$xc_prog_cc_prev_LIBS
+  CFLAGS=$xc_prog_cc_prev_CFLAGS
+  LDFLAGS=$xc_prog_cc_prev_LDFLAGS
+  CPPFLAGS=$xc_prog_cc_prev_CPPFLAGS
+
+
+
+
+
+
+
+
+
+
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+if test -z "$CXX"; then
+  if test -n "$CCC"; then
+    CXX=$CCC
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$CXX"; then
+  ac_cv_prog_CXX="$CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CXX=$ac_cv_prog_CXX
+if test -n "$CXX"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
+printf "%s\n" "$CXX" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+    test -n "$CXX" && break
+  done
+fi
+if test -z "$CXX"; then
+  ac_ct_CXX=$CXX
+  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_CXX"; then
+  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CXX="$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
+if test -n "$ac_ct_CXX"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
+printf "%s\n" "$ac_ct_CXX" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CXX" && break
+done
+
+  if test "x$ac_ct_CXX" = x; then
+    CXX="g++"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CXX=$ac_ct_CXX
+  fi
+fi
+
+  fi
+fi
+# Provide some information about the compiler.
+printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+printf "%s\n" "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5
+printf %s "checking whether the compiler supports GNU C++... " >&6; }
+if test ${ac_cv_cxx_compiler_gnu+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"
+then :
+  ac_compiler_gnu=yes
+else $as_nop
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
+printf "%s\n" "$ac_cv_cxx_compiler_gnu" >&6; }
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+if test $ac_compiler_gnu = yes; then
+  GXX=yes
+else
+  GXX=
+fi
+ac_test_CXXFLAGS=${CXXFLAGS+y}
+ac_save_CXXFLAGS=$CXXFLAGS
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
+printf %s "checking whether $CXX accepts -g... " >&6; }
+if test ${ac_cv_prog_cxx_g+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
+   ac_cxx_werror_flag=yes
+   ac_cv_prog_cxx_g=no
+   CXXFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"
+then :
+  ac_cv_prog_cxx_g=yes
+else $as_nop
+  CXXFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"
+then :
+
+else $as_nop
+  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+	 CXXFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"
+then :
+  ac_cv_prog_cxx_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
+printf "%s\n" "$ac_cv_prog_cxx_g" >&6; }
+if test $ac_test_CXXFLAGS; then
+  CXXFLAGS=$ac_save_CXXFLAGS
+elif test $ac_cv_prog_cxx_g = yes; then
+  if test "$GXX" = yes; then
+    CXXFLAGS="-g -O2"
+  else
+    CXXFLAGS="-g"
+  fi
+else
+  if test "$GXX" = yes; then
+    CXXFLAGS="-O2"
+  else
+    CXXFLAGS=
+  fi
+fi
+ac_prog_cxx_stdcxx=no
+if test x$ac_prog_cxx_stdcxx = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features" >&5
+printf %s "checking for $CXX option to enable C++11 features... " >&6; }
+if test ${ac_cv_prog_cxx_11+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_cv_prog_cxx_11=no
+ac_save_CXX=$CXX
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_cxx_conftest_cxx11_program
+_ACEOF
+for ac_arg in '' -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x -qlanglvl=extended0x -AA
+do
+  CXX="$ac_save_CXX $ac_arg"
+  if ac_fn_cxx_try_compile "$LINENO"
+then :
+  ac_cv_prog_cxx_cxx11=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+  test "x$ac_cv_prog_cxx_cxx11" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CXX=$ac_save_CXX
+fi
+
+if test "x$ac_cv_prog_cxx_cxx11" = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf "%s\n" "unsupported" >&6; }
+else $as_nop
+  if test "x$ac_cv_prog_cxx_cxx11" = x
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf "%s\n" "none needed" >&6; }
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5
+printf "%s\n" "$ac_cv_prog_cxx_cxx11" >&6; }
+     CXX="$CXX $ac_cv_prog_cxx_cxx11"
+fi
+  ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11
+  ac_prog_cxx_stdcxx=cxx11
+fi
+fi
+if test x$ac_prog_cxx_stdcxx = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features" >&5
+printf %s "checking for $CXX option to enable C++98 features... " >&6; }
+if test ${ac_cv_prog_cxx_98+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_cv_prog_cxx_98=no
+ac_save_CXX=$CXX
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_cxx_conftest_cxx98_program
+_ACEOF
+for ac_arg in '' -std=gnu++98 -std=c++98 -qlanglvl=extended -AA
+do
+  CXX="$ac_save_CXX $ac_arg"
+  if ac_fn_cxx_try_compile "$LINENO"
+then :
+  ac_cv_prog_cxx_cxx98=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+  test "x$ac_cv_prog_cxx_cxx98" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CXX=$ac_save_CXX
+fi
+
+if test "x$ac_cv_prog_cxx_cxx98" = xno
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf "%s\n" "unsupported" >&6; }
+else $as_nop
+  if test "x$ac_cv_prog_cxx_cxx98" = x
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf "%s\n" "none needed" >&6; }
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5
+printf "%s\n" "$ac_cv_prog_cxx_cxx98" >&6; }
+     CXX="$CXX $ac_cv_prog_cxx_cxx98"
+fi
+  ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98
+  ac_prog_cxx_stdcxx=cxx98
+fi
+fi
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+
+    ax_cxx_compile_cxx11_required=false
+  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+  ac_success=no
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features by default" >&5
+printf %s "checking whether $CXX supports C++11 features by default... " >&6; }
+if test ${ax_cv_cxx_compile_cxx11+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+  template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+    struct Base {
+    virtual void f() {}
+    };
+    struct Child : public Base {
+    virtual void f() override {}
+    };
+
+    typedef check<check<bool>> right_angle_brackets;
+
+    int a;
+    decltype(a) b;
+
+    typedef check<int> check_type;
+    check_type c;
+    check_type&& cr = static_cast<check_type&&>(c);
+
+    auto d = a;
+    auto l = [](){};
+
+    // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+    // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function because of this
+    namespace test_template_alias_sfinae {
+        struct foo {};
+
+        template<typename T>
+        using member = typename T::member_type;
+
+        template<typename T>
+        void func(...) {}
+
+        template<typename T>
+        void func(member<T>*) {}
+
+        void test();
+
+        void test() {
+            func<foo>(0);
+        }
+    }
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"
+then :
+  ax_cv_cxx_compile_cxx11=yes
+else $as_nop
+  ax_cv_cxx_compile_cxx11=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx11" >&5
+printf "%s\n" "$ax_cv_cxx_compile_cxx11" >&6; }
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+
+
+
+    if test x$ac_success = xno; then
+    for switch in -std=c++11 -std=c++0x; do
+      cachevar=`printf "%s\n" "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh`
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5
+printf %s "checking whether $CXX supports C++11 features with $switch... " >&6; }
+if eval test \${$cachevar+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+  template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+    struct Base {
+    virtual void f() {}
+    };
+    struct Child : public Base {
+    virtual void f() override {}
+    };
+
+    typedef check<check<bool>> right_angle_brackets;
+
+    int a;
+    decltype(a) b;
+
+    typedef check<int> check_type;
+    check_type c;
+    check_type&& cr = static_cast<check_type&&>(c);
+
+    auto d = a;
+    auto l = [](){};
+
+    // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+    // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function because of this
+    namespace test_template_alias_sfinae {
+        struct foo {};
+
+        template<typename T>
+        using member = typename T::member_type;
+
+        template<typename T>
+        void func(...) {}
+
+        template<typename T>
+        void func(member<T>*) {}
+
+        void test();
+
+        void test() {
+            func<foo>(0);
+        }
+    }
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"
+then :
+  eval $cachevar=yes
+else $as_nop
+  eval $cachevar=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+         CXXFLAGS="$ac_save_CXXFLAGS"
+fi
+eval ac_res=\$$cachevar
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+  if test x$ax_cxx_compile_cxx11_required = xtrue; then
+    if test x$ac_success = xno; then
+      as_fn_error $? "*** A compiler with support for C++11 language features is required." "$LINENO" 5
+    fi
+  else
+    if test x$ac_success = xno; then
+      HAVE_CXX11=0
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: No compiler with C++11 support was found" >&5
+printf "%s\n" "$as_me: No compiler with C++11 support was found" >&6;}
+    else
+      HAVE_CXX11=1
+
+printf "%s\n" "#define HAVE_CXX11 1" >>confdefs.h
+
+    fi
+
+
+  fi
+
+
+am__api_version='1.16'
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
+printf %s "checking whether build environment is sane... " >&6; }
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *[\\\"\#\$\&\'\`$am_lf]*)
+    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
+esac
+case $srcdir in
+  *[\\\"\#\$\&\'\`$am_lf\ \	]*)
+    as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   am_has_slept=no
+   for am_try in 1 2; do
+     echo "timestamp, slept: $am_has_slept" > conftest.file
+     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+     if test "$*" = "X"; then
+	# -L didn't work.
+	set X `ls -t "$srcdir/configure" conftest.file`
+     fi
+     if test "$*" != "X $srcdir/configure conftest.file" \
+	&& test "$*" != "X conftest.file $srcdir/configure"; then
+
+	# If neither matched, then we have a broken ls.  This can happen
+	# if, for instance, CONFIG_SHELL is bash and it inherits a
+	# broken ls alias from the environment.  This has actually
+	# happened.  Such a system could not be considered "sane".
+	as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
+  alias in your environment" "$LINENO" 5
+     fi
+     if test "$2" = conftest.file || test $am_try -eq 2; then
+       break
+     fi
+     # Just in case.
+     sleep 1
+     am_has_slept=yes
+   done
+   test "$2" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   as_fn_error $? "newly created file is older than distributed files!
+Check your system clock" "$LINENO" 5
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+  ( sleep 1 ) &
+  am_sleep_pid=$!
+fi
+
+rm -f conftest.file
+
+test "$program_prefix" != NONE &&
+  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+# Use a double $ so make ignores it.
+test "$program_suffix" != NONE &&
+  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+# Double any \ or $.
+# By default was `s,x,x', remove it if useless.
+ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
+program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"`
+
+
+  if test x"${MISSING+set}" != xset; then
+  MISSING="\${SHELL} '$am_aux_dir/missing'"
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+  am_missing_run="$MISSING "
+else
+  am_missing_run=
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
+printf "%s\n" "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
+fi
+
+if test x"${install_sh+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip".  However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+if test "$cross_compiling" != no; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_STRIP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+printf "%s\n" "$STRIP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_STRIP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+printf "%s\n" "$ac_ct_STRIP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5
+printf %s "checking for a race-free mkdir -p... " >&6; }
+if test -z "$MKDIR_P"; then
+  if test ${ac_cv_path_mkdir+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in mkdir gmkdir; do
+	 for ac_exec_ext in '' $ac_executable_extensions; do
+	   as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext" || continue
+	   case `"$as_dir$ac_prog$ac_exec_ext" --version 2>&1` in #(
+	     'mkdir ('*'coreutils) '* | \
+	     'BusyBox '* | \
+	     'mkdir (fileutils) '4.1*)
+	       ac_cv_path_mkdir=$as_dir$ac_prog$ac_exec_ext
+	       break 3;;
+	   esac
+	 done
+       done
+  done
+IFS=$as_save_IFS
+
+fi
+
+  test -d ./--version && rmdir ./--version
+  if test ${ac_cv_path_mkdir+y}; then
+    MKDIR_P="$ac_cv_path_mkdir -p"
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for MKDIR_P within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    MKDIR_P="$ac_install_sh -d"
+  fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
+printf "%s\n" "$MKDIR_P" >&6; }
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+printf %s "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+if eval test \${ac_cv_prog_make_${ac_make}_set+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+	@echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+  *@@@%%%=?*=@@@%%%*)
+    eval ac_cv_prog_make_${ac_make}_set=yes;;
+  *)
+    eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+  SET_MAKE=
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+
+DEPDIR="${am__leading_dot}deps"
+
+ac_config_commands="$ac_config_commands depfiles"
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
+printf %s "checking whether ${MAKE-make} supports the include directive... " >&6; }
+cat > confinc.mk << 'END'
+am__doit:
+	@echo this is the am__doit target >confinc.out
+.PHONY: am__doit
+END
+am__include="#"
+am__quote=
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
+   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+  case $?:`cat confinc.out 2>/dev/null` in #(
+  '0:this is the am__doit target') :
+    case $s in #(
+  BSD) :
+    am__include='.include' am__quote='"' ;; #(
+  *) :
+    am__include='include' am__quote='' ;;
+esac ;; #(
+  *) :
+     ;;
+esac
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
+printf "%s\n" "${_am_result}" >&6; }
+
+# Check whether --enable-dependency-tracking was given.
+if test ${enable_dependency_tracking+y}
+then :
+  enableval=$enable_dependency_tracking;
+fi
+
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+ if test "x$enable_dependency_tracking" != xno; then
+  AMDEP_TRUE=
+  AMDEP_FALSE='#'
+else
+  AMDEP_TRUE='#'
+  AMDEP_FALSE=
+fi
+
+
+## --------------------------------------- ##
+##  Start of automake initialization code  ##
+## --------------------------------------- ##
+
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  am__isrc=' -I$(srcdir)'
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+
+
+# Define the identity of the package.
+ PACKAGE='c-ares'
+ VERSION='1.18.1'
+
+
+printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h
+
+
+printf "%s\n" "#define VERSION \"$VERSION\"" >>confdefs.h
+
+# Some tools Automake needs.
+
+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
+
+
+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
+
+
+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
+
+
+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
+
+
+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
+
+# For better backward compatibility.  To be removed once Automake 1.9.x
+# dies out for good.  For more background, see:
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+mkdir_p='$(MKDIR_P)'
+
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
+# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AMTAR='$${TAR-tar}'
+
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar  pax cpio none'
+
+am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+
+
+
+
+
+depcc="$CC"   am_compiler_list=
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+printf %s "checking dependency style of $depcc... " >&6; }
+if test ${am_cv_CC_dependencies_compiler_type+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CC_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
+printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_TRUE=
+  am__fastdepCC_FALSE='#'
+else
+  am__fastdepCC_TRUE='#'
+  am__fastdepCC_FALSE=
+fi
+
+
+depcc="$CXX"  am_compiler_list=
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+printf %s "checking dependency style of $depcc... " >&6; }
+if test ${am_cv_CXX_dependencies_compiler_type+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CXX_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CXX_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CXX_dependencies_compiler_type=none
+fi
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
+printf "%s\n" "$am_cv_CXX_dependencies_compiler_type" >&6; }
+CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
+  am__fastdepCXX_TRUE=
+  am__fastdepCXX_FALSE='#'
+else
+  am__fastdepCXX_TRUE='#'
+  am__fastdepCXX_FALSE=
+fi
+
+
+# Variables for tags utilities; see am/tags.am
+if test -z "$CTAGS"; then
+  CTAGS=ctags
+fi
+
+if test -z "$ETAGS"; then
+  ETAGS=etags
+fi
+
+if test -z "$CSCOPE"; then
+  CSCOPE=cscope
+fi
+
+
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
+  fi
+fi
+
+## ------------------------------------- ##
+##  End of automake initialization code  ##
+## ------------------------------------- ##
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+printf %s "checking for grep that handles long lines and -e... " >&6; }
+if test ${ac_cv_path_GREP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in grep ggrep
+   do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+printf "%s\n" "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+printf %s "checking for egrep... " >&6; }
+if test ${ac_cv_path_EGREP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in egrep
+   do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+printf "%s\n" "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if OS is AIX (to define _ALL_SOURCE)" >&5
+printf %s "checking if OS is AIX (to define _ALL_SOURCE)... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#ifdef _AIX
+   yes_this_is_aix
+#endif
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "yes_this_is_aix" >/dev/null 2>&1
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    printf "%s\n" "#define _ALL_SOURCE 1" >>confdefs.h
+
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+fi
+rm -rf conftest*
+
+
+
+
+    #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _THREAD_SAFE is already defined" >&5
+printf %s "checking if _THREAD_SAFE is already defined... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+#ifdef _THREAD_SAFE
+      int dummy=1;
+#else
+      force compilation error
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tmp_thread_safe_initially_defined="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tmp_thread_safe_initially_defined="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  #
+  if test "$tmp_thread_safe_initially_defined" = "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _THREAD_SAFE is actually needed" >&5
+printf %s "checking if _THREAD_SAFE is actually needed... " >&6; }
+
+  case $host_os in
+    aix[123].* | aix4.[012].*)
+            tmp_need_thread_safe="no"
+      ;;
+    aix*)
+            tmp_need_thread_safe="yes"
+      ;;
+    *)
+      tmp_need_thread_safe="no"
+      ;;
+  esac
+
+    if test "$tmp_need_thread_safe" = "yes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _THREAD_SAFE is onwards defined" >&5
+printf %s "checking if _THREAD_SAFE is onwards defined... " >&6; }
+  if test "$tmp_thread_safe_initially_defined" = "yes" ||
+    test "$tmp_need_thread_safe" = "yes"; then
+
+
+printf "%s\n" "#define NEED_THREAD_SAFE 1" >>confdefs.h
+
+cat >>confdefs.h <<_EOF
+#ifndef _THREAD_SAFE
+#  define _THREAD_SAFE
+#endif
+_EOF
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+  #
+
+
+    #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _REENTRANT is already defined" >&5
+printf %s "checking if _REENTRANT is already defined... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+#ifdef _REENTRANT
+      int dummy=1;
+#else
+      force compilation error
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tmp_reentrant_initially_defined="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tmp_reentrant_initially_defined="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  #
+  if test "$tmp_reentrant_initially_defined" = "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _REENTRANT is actually needed" >&5
+printf %s "checking if _REENTRANT is actually needed... " >&6; }
+
+  case $host_os in
+    solaris*)
+      tmp_need_reentrant="yes"
+      ;;
+    *)
+      tmp_need_reentrant="no"
+      ;;
+  esac
+
+    if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <errno.h>
+
+int
+main (void)
+{
+
+      if(0 != errno)
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    tmp_errno="yes"
+
+else $as_nop
+
+    tmp_errno="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  if test "$tmp_errno" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <errno.h>
+
+int
+main (void)
+{
+
+#ifdef errno
+        int dummy=1;
+#else
+        force compilation error
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      tmp_errno="errno_macro_defined"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#define _REENTRANT
+#include <errno.h>
+
+int
+main (void)
+{
+
+#ifdef errno
+          int dummy=1;
+#else
+          force compilation error
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+        tmp_errno="errno_macro_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+
+    fi
+    if test "$tmp_need_reentrant" = "no"; then
+
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define gmtime_r to an innocuous variant, in case <limits.h> declares gmtime_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define gmtime_r innocuous_gmtime_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char gmtime_r (); below.  */
+
+#include <limits.h>
+#undef gmtime_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char gmtime_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_gmtime_r || defined __stub___gmtime_r
+choke me
+#endif
+
+int
+main (void)
+{
+return gmtime_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_gmtime_r="yes"
+
+else $as_nop
+
+    tmp_gmtime_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_gmtime_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <time.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gmtime_r" >/dev/null 2>&1
+then :
+
+      tmp_gmtime_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <time.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gmtime_r" >/dev/null 2>&1
+then :
+
+        tmp_gmtime_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define localtime_r to an innocuous variant, in case <limits.h> declares localtime_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define localtime_r innocuous_localtime_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char localtime_r (); below.  */
+
+#include <limits.h>
+#undef localtime_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char localtime_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_localtime_r || defined __stub___localtime_r
+choke me
+#endif
+
+int
+main (void)
+{
+return localtime_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_localtime_r="yes"
+
+else $as_nop
+
+    tmp_localtime_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_localtime_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <time.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "localtime_r" >/dev/null 2>&1
+then :
+
+      tmp_localtime_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <time.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "localtime_r" >/dev/null 2>&1
+then :
+
+        tmp_localtime_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define strerror_r to an innocuous variant, in case <limits.h> declares strerror_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define strerror_r innocuous_strerror_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char strerror_r (); below.  */
+
+#include <limits.h>
+#undef strerror_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strerror_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_strerror_r || defined __stub___strerror_r
+choke me
+#endif
+
+int
+main (void)
+{
+return strerror_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_strerror_r="yes"
+
+else $as_nop
+
+    tmp_strerror_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_strerror_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strerror_r" >/dev/null 2>&1
+then :
+
+      tmp_strerror_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strerror_r" >/dev/null 2>&1
+then :
+
+        tmp_strerror_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define strtok_r to an innocuous variant, in case <limits.h> declares strtok_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define strtok_r innocuous_strtok_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char strtok_r (); below.  */
+
+#include <limits.h>
+#undef strtok_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strtok_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_strtok_r || defined __stub___strtok_r
+choke me
+#endif
+
+int
+main (void)
+{
+return strtok_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_strtok_r="yes"
+
+else $as_nop
+
+    tmp_strtok_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_strtok_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strtok_r" >/dev/null 2>&1
+then :
+
+      tmp_strtok_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strtok_r" >/dev/null 2>&1
+then :
+
+        tmp_strtok_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define inet_ntoa_r to an innocuous variant, in case <limits.h> declares inet_ntoa_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define inet_ntoa_r innocuous_inet_ntoa_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char inet_ntoa_r (); below.  */
+
+#include <limits.h>
+#undef inet_ntoa_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char inet_ntoa_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_inet_ntoa_r || defined __stub___inet_ntoa_r
+choke me
+#endif
+
+int
+main (void)
+{
+return inet_ntoa_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_inet_ntoa_r="yes"
+
+else $as_nop
+
+    tmp_inet_ntoa_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_inet_ntoa_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "inet_ntoa_r" >/dev/null 2>&1
+then :
+
+      tmp_inet_ntoa_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "inet_ntoa_r" >/dev/null 2>&1
+then :
+
+        tmp_inet_ntoa_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define gethostbyaddr_r to an innocuous variant, in case <limits.h> declares gethostbyaddr_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define gethostbyaddr_r innocuous_gethostbyaddr_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char gethostbyaddr_r (); below.  */
+
+#include <limits.h>
+#undef gethostbyaddr_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char gethostbyaddr_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_gethostbyaddr_r || defined __stub___gethostbyaddr_r
+choke me
+#endif
+
+int
+main (void)
+{
+return gethostbyaddr_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_gethostbyaddr_r="yes"
+
+else $as_nop
+
+    tmp_gethostbyaddr_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_gethostbyaddr_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <netdb.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gethostbyaddr_r" >/dev/null 2>&1
+then :
+
+      tmp_gethostbyaddr_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gethostbyaddr_r" >/dev/null 2>&1
+then :
+
+        tmp_gethostbyaddr_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define gethostbyname_r to an innocuous variant, in case <limits.h> declares gethostbyname_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define gethostbyname_r innocuous_gethostbyname_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char gethostbyname_r (); below.  */
+
+#include <limits.h>
+#undef gethostbyname_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char gethostbyname_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_gethostbyname_r || defined __stub___gethostbyname_r
+choke me
+#endif
+
+int
+main (void)
+{
+return gethostbyname_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_gethostbyname_r="yes"
+
+else $as_nop
+
+    tmp_gethostbyname_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_gethostbyname_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <netdb.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gethostbyname_r" >/dev/null 2>&1
+then :
+
+      tmp_gethostbyname_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gethostbyname_r" >/dev/null 2>&1
+then :
+
+        tmp_gethostbyname_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define getprotobyname_r to an innocuous variant, in case <limits.h> declares getprotobyname_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define getprotobyname_r innocuous_getprotobyname_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char getprotobyname_r (); below.  */
+
+#include <limits.h>
+#undef getprotobyname_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char getprotobyname_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_getprotobyname_r || defined __stub___getprotobyname_r
+choke me
+#endif
+
+int
+main (void)
+{
+return getprotobyname_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_getprotobyname_r="yes"
+
+else $as_nop
+
+    tmp_getprotobyname_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_getprotobyname_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <netdb.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getprotobyname_r" >/dev/null 2>&1
+then :
+
+      tmp_getprotobyname_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getprotobyname_r" >/dev/null 2>&1
+then :
+
+        tmp_getprotobyname_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define getservbyport_r to an innocuous variant, in case <limits.h> declares getservbyport_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define getservbyport_r innocuous_getservbyport_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char getservbyport_r (); below.  */
+
+#include <limits.h>
+#undef getservbyport_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char getservbyport_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_getservbyport_r || defined __stub___getservbyport_r
+choke me
+#endif
+
+int
+main (void)
+{
+return getservbyport_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    tmp_getservbyport_r="yes"
+
+else $as_nop
+
+    tmp_getservbyport_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test "$tmp_getservbyport_r" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#include <sys/types.h>
+#include <netdb.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getservbyport_r" >/dev/null 2>&1
+then :
+
+      tmp_getservbyport_r="proto_declared"
+
+else $as_nop
+
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getservbyport_r" >/dev/null 2>&1
+then :
+
+        tmp_getservbyport_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+
+fi
+rm -rf conftest*
+
+
+fi
+rm -rf conftest*
+
+  fi
+
+  fi
+
+    fi
+    if test "$tmp_need_reentrant" = "yes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _REENTRANT is onwards defined" >&5
+printf %s "checking if _REENTRANT is onwards defined... " >&6; }
+  if test "$tmp_reentrant_initially_defined" = "yes" ||
+    test "$tmp_need_reentrant" = "yes"; then
+
+
+printf "%s\n" "#define NEED_REENTRANT 1" >>confdefs.h
+
+cat >>confdefs.h <<_EOF
+#ifndef _REENTRANT
+#  define _REENTRANT
+#endif
+_EOF
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+  #
+
+
+# Check whether --enable-largefile was given.
+if test ${enable_largefile+y}
+then :
+  enableval=$enable_largefile;
+fi
+
+if test "$enable_largefile" != no; then
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for special C compiler options needed for large files" >&5
+printf %s "checking for special C compiler options needed for large files... " >&6; }
+if test ${ac_cv_sys_largefile_CC+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_cv_sys_largefile_CC=no
+     if test "$GCC" != yes; then
+       ac_save_CC=$CC
+       while :; do
+	 # IRIX 6.2 and later do not support large files by default,
+	 # so use the C compiler's -n32 option if that helps.
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+	 if ac_fn_c_try_compile "$LINENO"
+then :
+  break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+	 CC="$CC -n32"
+	 if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_sys_largefile_CC=' -n32'; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+	 break
+       done
+       CC=$ac_save_CC
+       rm -f conftest.$ac_ext
+    fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_CC" >&5
+printf "%s\n" "$ac_cv_sys_largefile_CC" >&6; }
+  if test "$ac_cv_sys_largefile_CC" != no; then
+    CC=$CC$ac_cv_sys_largefile_CC
+  fi
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _FILE_OFFSET_BITS value needed for large files" >&5
+printf %s "checking for _FILE_OFFSET_BITS value needed for large files... " >&6; }
+if test ${ac_cv_sys_file_offset_bits+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  while :; do
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_sys_file_offset_bits=no; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#define _FILE_OFFSET_BITS 64
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_sys_file_offset_bits=64; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  ac_cv_sys_file_offset_bits=unknown
+  break
+done
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_file_offset_bits" >&5
+printf "%s\n" "$ac_cv_sys_file_offset_bits" >&6; }
+case $ac_cv_sys_file_offset_bits in #(
+  no | unknown) ;;
+  *)
+printf "%s\n" "#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits" >>confdefs.h
+;;
+esac
+rm -rf conftest*
+  if test $ac_cv_sys_file_offset_bits = unknown; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _LARGE_FILES value needed for large files" >&5
+printf %s "checking for _LARGE_FILES value needed for large files... " >&6; }
+if test ${ac_cv_sys_large_files+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  while :; do
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_sys_large_files=no; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#define _LARGE_FILES 1
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_sys_large_files=1; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  ac_cv_sys_large_files=unknown
+  break
+done
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_large_files" >&5
+printf "%s\n" "$ac_cv_sys_large_files" >&6; }
+case $ac_cv_sys_large_files in #(
+  no | unknown) ;;
+  *)
+printf "%s\n" "#define _LARGE_FILES $ac_cv_sys_large_files" >>confdefs.h
+;;
+esac
+rm -rf conftest*
+  fi
+fi
+
+
+case $host_os in
+  solaris*)
+
+printf "%s\n" "#define ETC_INET 1" >>confdefs.h
+
+    ;;
+esac
+
+case `pwd` in
+  *\ * | *\	*)
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
+printf "%s\n" "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
+esac
+
+
+
+macro_version='2.4.6'
+macro_revision='2.4.6'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ltmain=$ac_aux_dir/ltmain.sh
+
+# Backslashify metacharacters that are still active within
+# double-quoted strings.
+sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
+printf %s "checking how to print strings... " >&6; }
+# Test print first, because it will be a builtin if present.
+if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
+   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='print -r --'
+elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='printf %s\n'
+else
+  # Use this function as a fallback that always works.
+  func_fallback_echo ()
+  {
+    eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+  }
+  ECHO='func_fallback_echo'
+fi
+
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO ""
+}
+
+case $ECHO in
+  printf*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: printf" >&5
+printf "%s\n" "printf" >&6; } ;;
+  print*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
+printf "%s\n" "print -r" >&6; } ;;
+  *) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cat" >&5
+printf "%s\n" "cat" >&6; } ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+printf %s "checking for a sed that does not truncate output... " >&6; }
+if test ${ac_cv_path_SED+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in sed gsed
+   do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
+else
+  ac_cv_path_SED=$SED
+fi
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+printf "%s\n" "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
+
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
+
+
+
+
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+printf %s "checking for fgrep... " >&6; }
+if test ${ac_cv_path_FGREP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+   then ac_cv_path_FGREP="$GREP -F"
+   else
+     if test -z "$FGREP"; then
+  ac_path_FGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in fgrep
+   do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_FGREP="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_FGREP" || continue
+# Check for GNU ac_path_FGREP and select it if it is found.
+  # Check for GNU $ac_path_FGREP
+case `"$ac_path_FGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'FGREP' >> "conftest.nl"
+    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_FGREP="$ac_path_FGREP"
+      ac_path_FGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_FGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_FGREP"; then
+    as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_FGREP=$FGREP
+fi
+
+   fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+printf "%s\n" "$ac_cv_path_FGREP" >&6; }
+ FGREP="$ac_cv_path_FGREP"
+
+
+test -z "$GREP" && GREP=grep
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-gnu-ld was given.
+if test ${with_gnu_ld+y}
+then :
+  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
+else $as_nop
+  with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test yes = "$GCC"; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+printf %s "checking for ld used by $CC... " >&6; }
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return, which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [\\/]* | ?:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD=$ac_prog
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test yes = "$with_gnu_ld"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+printf %s "checking for GNU ld... " >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+printf %s "checking for non-GNU ld... " >&6; }
+fi
+if test ${lt_cv_path_LD+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -z "$LD"; then
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD=$ac_dir/$ac_prog
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test no != "$with_gnu_ld" && break
+	;;
+      *)
+	test yes != "$with_gnu_ld" && break
+	;;
+      esac
+    fi
+  done
+  IFS=$lt_save_ifs
+else
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
+fi
+fi
+
+LD=$lt_cv_path_LD
+if test -n "$LD"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+printf "%s\n" "$LD" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
+if test ${lt_cv_prog_gnu_ld+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
+printf %s "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
+if test ${lt_cv_path_NM+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM=$NM
+else
+  lt_nm_to_check=${ac_tool_prefix}nm
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS=$lt_save_ifs
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm=$ac_dir/$lt_tmp_nm
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	# Tru64's nm complains that /dev/null is an invalid object file
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
+	  lt_cv_path_NM="$tmp_nm -B"
+	  break 2
+	  ;;
+	*)
+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	  */dev/null*)
+	    lt_cv_path_NM="$tmp_nm -p"
+	    break 2
+	    ;;
+	  *)
+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	    continue # so that we can try to find one that supports BSD flags
+	    ;;
+	  esac
+	  ;;
+	esac
+      fi
+    done
+    IFS=$lt_save_ifs
+  done
+  : ${lt_cv_path_NM=no}
+fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
+printf "%s\n" "$lt_cv_path_NM" >&6; }
+if test no != "$lt_cv_path_NM"; then
+  NM=$lt_cv_path_NM
+else
+  # Didn't find any BSD compatible name lister, look for dumpbin.
+  if test -n "$DUMPBIN"; then :
+    # Let the user override the test.
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in dumpbin "link -dump"
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_DUMPBIN+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$DUMPBIN"; then
+  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DUMPBIN=$ac_cv_prog_DUMPBIN
+if test -n "$DUMPBIN"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
+printf "%s\n" "$DUMPBIN" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+    test -n "$DUMPBIN" && break
+  done
+fi
+if test -z "$DUMPBIN"; then
+  ac_ct_DUMPBIN=$DUMPBIN
+  for ac_prog in dumpbin "link -dump"
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_DUMPBIN+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_DUMPBIN"; then
+  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
+if test -n "$ac_ct_DUMPBIN"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
+printf "%s\n" "$ac_ct_DUMPBIN" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_DUMPBIN" && break
+done
+
+  if test "x$ac_ct_DUMPBIN" = x; then
+    DUMPBIN=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DUMPBIN=$ac_ct_DUMPBIN
+  fi
+fi
+
+    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
+    *COFF*)
+      DUMPBIN="$DUMPBIN -symbols -headers"
+      ;;
+    *)
+      DUMPBIN=:
+      ;;
+    esac
+  fi
+
+  if test : != "$DUMPBIN"; then
+    NM=$DUMPBIN
+  fi
+fi
+test -z "$NM" && NM=nm
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
+printf %s "checking the name lister ($NM) interface... " >&6; }
+if test ${lt_cv_nm_interface+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_nm_interface="BSD nm"
+  echo "int some_variable = 0;" > conftest.$ac_ext
+  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
+  (eval "$ac_compile" 2>conftest.err)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
+  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: output\"" >&5)
+  cat conftest.out >&5
+  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+    lt_cv_nm_interface="MS dumpbin"
+  fi
+  rm -f conftest*
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
+printf "%s\n" "$lt_cv_nm_interface" >&6; }
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
+printf %s "checking whether ln -s works... " >&6; }
+LN_S=$as_ln_s
+if test "$LN_S" = "ln -s"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
+printf "%s\n" "no, using $LN_S" >&6; }
+fi
+
+# find the maximum length of command line arguments
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
+printf %s "checking the maximum length of command line arguments... " >&6; }
+if test ${lt_cv_sys_max_cmd_len+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+    i=0
+  teststring=ABCD
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw* | cegcc*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  mint*)
+    # On MiNT this can take a long time and run out of memory.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  os2*)
+    # The test takes a long time on OS/2.
+    lt_cv_sys_max_cmd_len=8192
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[	 ]//'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+    if test -n "$lt_cv_sys_max_cmd_len" && \
+       test undefined != "$lt_cv_sys_max_cmd_len"; then
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    else
+      # Make teststring a little bigger before we do anything with it.
+      # a 1K string should be a reasonable start.
+      for i in 1 2 3 4 5 6 7 8; do
+        teststring=$teststring$teststring
+      done
+      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+      # If test is not a shell built-in, we'll probably end up computing a
+      # maximum length that is only half of the actual maximum length, but
+      # we can't tell.
+      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
+	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
+	      test 17 != "$i" # 1/2 MB should be enough
+      do
+        i=`expr $i + 1`
+        teststring=$teststring$teststring
+      done
+      # Only check the string length outside the loop.
+      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+      teststring=
+      # Add a significant safety factor because C++ compilers can tack on
+      # massive amounts of additional arguments before passing them to the
+      # linker.  It appears as though 1/2 is a usable value.
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    fi
+    ;;
+  esac
+
+fi
+
+if test -n "$lt_cv_sys_max_cmd_len"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
+printf "%s\n" "$lt_cv_sys_max_cmd_len" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none" >&5
+printf "%s\n" "none" >&6; }
+fi
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+
+
+
+
+
+: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  lt_unset=unset
+else
+  lt_unset=false
+fi
+
+
+
+
+
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  lt_SP2NL='tr \040 \012'
+  lt_NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  lt_SP2NL='tr \100 \n'
+  lt_NL2SP='tr \r\n \100\100'
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
+printf %s "checking how to convert $build file names to $host format... " >&6; }
+if test ${lt_cv_to_host_file_cmd+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
+        ;;
+    esac
+    ;;
+  *-*-cygwin* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_noop
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
+        ;;
+    esac
+    ;;
+  * ) # unhandled hosts (and "normal" native builds)
+    lt_cv_to_host_file_cmd=func_convert_file_noop
+    ;;
+esac
+
+fi
+
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
+printf "%s\n" "$lt_cv_to_host_file_cmd" >&6; }
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
+printf %s "checking how to convert $build file names to toolchain format... " >&6; }
+if test ${lt_cv_to_tool_file_cmd+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  #assume ordinary cross tools, or native build.
+lt_cv_to_tool_file_cmd=func_convert_file_noop
+case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
+        ;;
+    esac
+    ;;
+esac
+
+fi
+
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
+printf "%s\n" "$lt_cv_to_tool_file_cmd" >&6; }
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
+printf %s "checking for $LD option to reload object files... " >&6; }
+if test ${lt_cv_ld_reload_flag+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_ld_reload_flag='-r'
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
+printf "%s\n" "$lt_cv_ld_reload_flag" >&6; }
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    if test yes != "$GCC"; then
+      reload_cmds=false
+    fi
+    ;;
+  darwin*)
+    if test yes = "$GCC"; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_OBJDUMP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+printf "%s\n" "$OBJDUMP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+  ac_ct_OBJDUMP=$OBJDUMP
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_OBJDUMP"; then
+  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OBJDUMP="objdump"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_OBJDUMP" = x; then
+    OBJDUMP="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OBJDUMP=$ac_ct_OBJDUMP
+  fi
+else
+  OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
+printf %s "checking how to recognize dependent libraries... " >&6; }
+if test ${lt_cv_deplibs_check_method+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# 'unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# that responds to the $file_magic_cmd with a given extended regex.
+# If you have 'file' or equivalent on your system and you're not sure
+# whether 'pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix[4-9]*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi[45]*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+mingw* | pw32*)
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump',
+  # unless we find 'file', for example because we are cross-compiling.
+  if ( file / ) >/dev/null 2>&1; then
+    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+    lt_cv_file_magic_cmd='func_win32_libid'
+  else
+    # Keep this pattern in sync with the one in func_win32_libid.
+    lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
+    lt_cv_file_magic_cmd='$OBJDUMP -f'
+  fi
+  ;;
+
+cegcc*)
+  # use the weaker test based on 'objdump'. See mingw*.
+  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | dragonfly*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+haiku*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case $host_cpu in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+interix[3-9]*)
+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd* | netbsdelf*-gnu)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+*nto* | *qnx*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+openbsd* | bitrig*)
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+rdos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.3*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  pc)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+tpf*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+os2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
+printf "%s\n" "$lt_cv_deplibs_check_method" >&6; }
+
+file_magic_glob=
+want_nocaseglob=no
+if test "$build" = "$host"; then
+  case $host_os in
+  mingw* | pw32*)
+    if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
+      want_nocaseglob=yes
+    else
+      file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"`
+    fi
+    ;;
+  esac
+fi
+
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dlltool; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_DLLTOOL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$DLLTOOL"; then
+  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DLLTOOL=$ac_cv_prog_DLLTOOL
+if test -n "$DLLTOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+printf "%s\n" "$DLLTOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DLLTOOL"; then
+  ac_ct_DLLTOOL=$DLLTOOL
+  # Extract the first word of "dlltool", so it can be a program name with args.
+set dummy dlltool; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_DLLTOOL"; then
+  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
+if test -n "$ac_ct_DLLTOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_DLLTOOL" = x; then
+    DLLTOOL="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DLLTOOL=$ac_ct_DLLTOOL
+  fi
+else
+  DLLTOOL="$ac_cv_prog_DLLTOOL"
+fi
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
+printf %s "checking how to associate runtime and link libraries... " >&6; }
+if test ${lt_cv_sharedlib_from_linklib_cmd+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_sharedlib_from_linklib_cmd='unknown'
+
+case $host_os in
+cygwin* | mingw* | pw32* | cegcc*)
+  # two different shell functions defined in ltmain.sh;
+  # decide which one to use based on capabilities of $DLLTOOL
+  case `$DLLTOOL --help 2>&1` in
+  *--identify-strict*)
+    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
+    ;;
+  *)
+    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
+    ;;
+  esac
+  ;;
+*)
+  # fallback: assume linklib IS sharedlib
+  lt_cv_sharedlib_from_linklib_cmd=$ECHO
+  ;;
+esac
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
+printf "%s\n" "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
+sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
+test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  for ac_prog in ar
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_AR+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$AR"; then
+  ac_cv_prog_AR="$AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AR=$ac_cv_prog_AR
+if test -n "$AR"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+printf "%s\n" "$AR" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+    test -n "$AR" && break
+  done
+fi
+if test -z "$AR"; then
+  ac_ct_AR=$AR
+  for ac_prog in ar
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_AR+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_AR"; then
+  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_AR="$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_AR=$ac_cv_prog_ac_ct_AR
+if test -n "$ac_ct_AR"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+printf "%s\n" "$ac_ct_AR" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_AR" && break
+done
+
+  if test "x$ac_ct_AR" = x; then
+    AR="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AR=$ac_ct_AR
+  fi
+fi
+
+: ${AR=ar}
+: ${AR_FLAGS=cr}
+
+
+
+
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
+printf %s "checking for archiver @FILE support... " >&6; }
+if test ${lt_cv_ar_at_file+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_ar_at_file=no
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  echo conftest.$ac_objext > conftest.lst
+      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5'
+      { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
+  (eval $lt_ar_try) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+      if test 0 -eq "$ac_status"; then
+	# Ensure the archiver fails upon bogus file names.
+	rm -f conftest.$ac_objext libconftest.a
+	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
+  (eval $lt_ar_try) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	if test 0 -ne "$ac_status"; then
+          lt_cv_ar_at_file=@
+        fi
+      fi
+      rm -f conftest.* libconftest.a
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
+printf "%s\n" "$lt_cv_ar_at_file" >&6; }
+
+if test no = "$lt_cv_ar_at_file"; then
+  archiver_list_spec=
+else
+  archiver_list_spec=$lt_cv_ar_at_file
+fi
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_STRIP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+printf "%s\n" "$STRIP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_STRIP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+printf "%s\n" "$ac_ct_STRIP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+test -z "$STRIP" && STRIP=:
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_RANLIB+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
+printf "%s\n" "$RANLIB" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_RANLIB+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
+printf "%s\n" "$ac_ct_RANLIB" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_RANLIB" = x; then
+    RANLIB=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    RANLIB=$ac_ct_RANLIB
+  fi
+else
+  RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+test -z "$RANLIB" && RANLIB=:
+
+
+
+
+
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  bitrig* | openbsd*)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
+    ;;
+  *)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
+fi
+
+case $host_os in
+  darwin*)
+    lock_old_archive_extraction=yes ;;
+  *)
+    lock_old_archive_extraction=no ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
+printf %s "checking command to parse $NM output from $compiler object... " >&6; }
+if test ${lt_cv_sys_global_symbol_pipe+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[BCDEGRST]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='[BCDT]'
+  ;;
+cygwin* | mingw* | pw32* | cegcc*)
+  symcode='[ABCDGISTW]'
+  ;;
+hpux*)
+  if test ia64 = "$host_cpu"; then
+    symcode='[ABCDEGRST]'
+  fi
+  ;;
+irix* | nonstopux*)
+  symcode='[BCDEGRST]'
+  ;;
+osf*)
+  symcode='[BCDEGQRST]'
+  ;;
+solaris*)
+  symcode='[BDRT]'
+  ;;
+sco3.2v5*)
+  symcode='[DT]'
+  ;;
+sysv4.2uw2*)
+  symcode='[DT]'
+  ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+  symcode='[ABDT]'
+  ;;
+sysv4)
+  symcode='[DFNSTU]'
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='[ABCDGIRSTW]' ;;
+esac
+
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  # Gets list of data symbols to import.
+  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
+  # Adjust the below global symbol transforms to fixup imported variables.
+  lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
+  lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
+  lt_c_name_lib_hook="\
+  -e 's/^I .* \(lib.*\)$/  {\"\1\", (void *) 0},/p'\
+  -e 's/^I .* \(.*\)$/  {\"lib\1\", (void *) 0},/p'"
+else
+  # Disable hooks by default.
+  lt_cv_sys_global_symbol_to_import=
+  lt_cdecl_hook=
+  lt_c_name_hook=
+  lt_c_name_lib_hook=
+fi
+
+# Transform an extracted symbol line into a proper C declaration.
+# Some systems (esp. on ia64) link data and code symbols differently,
+# so use this general approach.
+lt_cv_sys_global_symbol_to_cdecl="sed -n"\
+$lt_cdecl_hook\
+" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
+$lt_c_name_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
+
+# Transform an extracted symbol line into symbol name with lib prefix and
+# symbol address.
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
+$lt_c_name_lib_hook\
+" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
+" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"lib\1\", (void *) \&\1},/p'"
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# Try without a prefix underscore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+  symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+  # Write the raw and C identifiers.
+  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+    # Fake it for dumpbin and say T for any non-static function,
+    # D for any global variable and I for any imported variable.
+    # Also find C++ and __fastcall symbols from MSVC++,
+    # which start with @ or ?.
+    lt_cv_sys_global_symbol_pipe="$AWK '"\
+"     {last_section=section; section=\$ 3};"\
+"     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
+"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+"     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
+"     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
+"     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
+"     \$ 0!~/External *\|/{next};"\
+"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
+"     {if(hide[section]) next};"\
+"     {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\
+"     {split(\$ 0,a,/\||\r/); split(a[2],s)};"\
+"     s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
+"     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
+"     ' prfx=^$ac_symprfx"
+  else
+    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[	 ]\($symcode$symcode*\)[	 ][	 ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+  fi
+  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(void);
+void nm_test_func(void){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&5
+    if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&5 && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<_LT_EOF > conftest.$ac_ext
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
+   relocations are performed -- see ld's documentation on pseudo-relocs.  */
+# define LT_DLSYM_CONST
+#elif defined __osf__
+/* This system does not cope well with relocations in const data.  */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+	  # Now generate the symbol file.
+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+	  cat <<_LT_EOF >> conftest.$ac_ext
+
+/* The mapping between symbol names and symbols.  */
+LT_DLSYM_CONST struct {
+  const char *name;
+  void       *address;
+}
+lt__PROGRAM__LTX_preloaded_symbols[] =
+{
+  { "@PROGRAM@", (void *) 0 },
+_LT_EOF
+	  $SED "s/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+	  cat <<\_LT_EOF >> conftest.$ac_ext
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt__PROGRAM__LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+	  # Now try linking the two files.
+	  mv conftest.$ac_objext conftstm.$ac_objext
+	  lt_globsym_save_LIBS=$LIBS
+	  lt_globsym_save_CFLAGS=$CFLAGS
+	  LIBS=conftstm.$ac_objext
+	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s conftest$ac_exeext; then
+	    pipe_works=yes
+	  fi
+	  LIBS=$lt_globsym_save_LIBS
+	  CFLAGS=$lt_globsym_save_CFLAGS
+	else
+	  echo "cannot find nm_test_func in $nlist" >&5
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&5
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
+    fi
+  else
+    echo "$progname: failed program was:" >&5
+    cat conftest.$ac_ext >&5
+  fi
+  rm -rf conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test yes = "$pipe_works"; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+
+fi
+
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: failed" >&5
+printf "%s\n" "failed" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+printf "%s\n" "ok" >&6; }
+fi
+
+# Response file support.
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  nm_file_list_spec='@'
+elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then
+  nm_file_list_spec='@'
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
+printf %s "checking for sysroot... " >&6; }
+
+# Check whether --with-sysroot was given.
+if test ${with_sysroot+y}
+then :
+  withval=$with_sysroot;
+else $as_nop
+  with_sysroot=no
+fi
+
+
+lt_sysroot=
+case $with_sysroot in #(
+ yes)
+   if test yes = "$GCC"; then
+     lt_sysroot=`$CC --print-sysroot 2>/dev/null`
+   fi
+   ;; #(
+ /*)
+   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
+   ;; #(
+ no|'')
+   ;; #(
+ *)
+   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
+printf "%s\n" "$with_sysroot" >&6; }
+   as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
+   ;;
+esac
+
+ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
+printf "%s\n" "${lt_sysroot:-no}" >&6; }
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
+printf %s "checking for a working dd... " >&6; }
+if test ${ac_cv_path_lt_DD+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+: ${lt_DD:=$DD}
+if test -z "$lt_DD"; then
+  ac_path_lt_DD_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in dd
+   do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_lt_DD="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_lt_DD" || continue
+if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
+fi
+      $ac_path_lt_DD_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_lt_DD"; then
+    :
+  fi
+else
+  ac_cv_path_lt_DD=$lt_DD
+fi
+
+rm -f conftest.i conftest2.i conftest.out
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
+printf "%s\n" "$ac_cv_path_lt_DD" >&6; }
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
+printf %s "checking how to truncate binary pipes... " >&6; }
+if test ${lt_cv_truncate_bin+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+lt_cv_truncate_bin=
+if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
+fi
+rm -f conftest.i conftest2.i conftest.out
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
+printf "%s\n" "$lt_cv_truncate_bin" >&6; }
+
+
+
+
+
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
+# Check whether --enable-libtool-lock was given.
+if test ${enable_libtool_lock+y}
+then :
+  enableval=$enable_libtool_lock;
+fi
+
+test no = "$enable_libtool_lock" || enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out what ABI is being produced by ac_compile, and set mode
+  # options accordingly.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.$ac_objext` in
+      *ELF-32*)
+	HPUX_IA64_MODE=32
+	;;
+      *ELF-64*)
+	HPUX_IA64_MODE=64
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    if test yes = "$lt_cv_prog_gnu_ld"; then
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -melf32bsmip"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -melf32bmipn32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -melf64bmip"
+	;;
+      esac
+    else
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -32"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -n32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -64"
+	  ;;
+      esac
+    fi
+  fi
+  rm -rf conftest*
+  ;;
+
+mips64*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    emul=elf
+    case `/usr/bin/file conftest.$ac_objext` in
+      *32-bit*)
+	emul="${emul}32"
+	;;
+      *64-bit*)
+	emul="${emul}64"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *MSB*)
+	emul="${emul}btsmip"
+	;;
+      *LSB*)
+	emul="${emul}ltsmip"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *N32*)
+	emul="${emul}n32"
+	;;
+    esac
+    LD="${LD-ld} -m $emul"
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
+s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.  Note that the listed cases only cover the
+  # situations where additional linker options are needed (such as when
+  # doing 32-bit compilation for a host where ld defaults to 64-bit, or
+  # vice versa); the common cases where no linker options are needed do
+  # not appear in the list.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.o` in
+      *32-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_i386_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    case `/usr/bin/file conftest.o` in
+	      *x86-64*)
+		LD="${LD-ld} -m elf32_x86_64"
+		;;
+	      *)
+		LD="${LD-ld} -m elf_i386"
+		;;
+	    esac
+	    ;;
+	  powerpc64le-*linux*)
+	    LD="${LD-ld} -m elf32lppclinux"
+	    ;;
+	  powerpc64-*linux*)
+	    LD="${LD-ld} -m elf32ppclinux"
+	    ;;
+	  s390x-*linux*)
+	    LD="${LD-ld} -m elf_s390"
+	    ;;
+	  sparc64-*linux*)
+	    LD="${LD-ld} -m elf32_sparc"
+	    ;;
+	esac
+	;;
+      *64-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_x86_64_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    LD="${LD-ld} -m elf_x86_64"
+	    ;;
+	  powerpcle-*linux*)
+	    LD="${LD-ld} -m elf64lppc"
+	    ;;
+	  powerpc-*linux*)
+	    LD="${LD-ld} -m elf64ppc"
+	    ;;
+	  s390*-*linux*|s390*-*tpf*)
+	    LD="${LD-ld} -m elf64_s390"
+	    ;;
+	  sparc*-*linux*)
+	    LD="${LD-ld} -m elf64_sparc"
+	    ;;
+	esac
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS=$CFLAGS
+  CFLAGS="$CFLAGS -belf"
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
+printf %s "checking whether the C compiler needs -belf... " >&6; }
+if test ${lt_cv_cc_needs_belf+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  lt_cv_cc_needs_belf=yes
+else $as_nop
+  lt_cv_cc_needs_belf=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+     ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
+printf "%s\n" "$lt_cv_cc_needs_belf" >&6; }
+  if test yes != "$lt_cv_cc_needs_belf"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS=$SAVE_CFLAGS
+  fi
+  ;;
+*-*solaris*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.o` in
+    *64-bit*)
+      case $lt_cv_prog_gnu_ld in
+      yes*)
+        case $host in
+        i?86-*-solaris*|x86_64-*-solaris*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        sparc*-*-solaris*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+        esac
+        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
+        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
+          LD=${LD-ld}_sol2
+        fi
+        ;;
+      *)
+	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
+	  LD="${LD-ld} -64"
+	fi
+	;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+esac
+
+need_locks=$enable_libtool_lock
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
+set dummy ${ac_tool_prefix}mt; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_MANIFEST_TOOL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$MANIFEST_TOOL"; then
+  ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
+if test -n "$MANIFEST_TOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
+printf "%s\n" "$MANIFEST_TOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_MANIFEST_TOOL"; then
+  ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL
+  # Extract the first word of "mt", so it can be a program name with args.
+set dummy mt; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_MANIFEST_TOOL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_MANIFEST_TOOL"; then
+  ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_MANIFEST_TOOL="mt"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
+if test -n "$ac_ct_MANIFEST_TOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
+printf "%s\n" "$ac_ct_MANIFEST_TOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_MANIFEST_TOOL" = x; then
+    MANIFEST_TOOL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL
+  fi
+else
+  MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL"
+fi
+
+test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
+printf %s "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
+if test ${lt_cv_path_mainfest_tool+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_path_mainfest_tool=no
+  echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5
+  $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
+  cat conftest.err >&5
+  if $GREP 'Manifest Tool' conftest.out > /dev/null; then
+    lt_cv_path_mainfest_tool=yes
+  fi
+  rm -f conftest*
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
+printf "%s\n" "$lt_cv_path_mainfest_tool" >&6; }
+if test yes != "$lt_cv_path_mainfest_tool"; then
+  MANIFEST_TOOL=:
+fi
+
+
+
+
+
+
+  case $host_os in
+    rhapsody* | darwin*)
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_DSYMUTIL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$DSYMUTIL"; then
+  ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DSYMUTIL=$ac_cv_prog_DSYMUTIL
+if test -n "$DSYMUTIL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+printf "%s\n" "$DSYMUTIL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DSYMUTIL"; then
+  ac_ct_DSYMUTIL=$DSYMUTIL
+  # Extract the first word of "dsymutil", so it can be a program name with args.
+set dummy dsymutil; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_DSYMUTIL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_DSYMUTIL"; then
+  ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
+if test -n "$ac_ct_DSYMUTIL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
+printf "%s\n" "$ac_ct_DSYMUTIL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_DSYMUTIL" = x; then
+    DSYMUTIL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DSYMUTIL=$ac_ct_DSYMUTIL
+  fi
+else
+  DSYMUTIL="$ac_cv_prog_DSYMUTIL"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
+set dummy ${ac_tool_prefix}nmedit; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_NMEDIT+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$NMEDIT"; then
+  ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+NMEDIT=$ac_cv_prog_NMEDIT
+if test -n "$NMEDIT"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
+printf "%s\n" "$NMEDIT" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_NMEDIT"; then
+  ac_ct_NMEDIT=$NMEDIT
+  # Extract the first word of "nmedit", so it can be a program name with args.
+set dummy nmedit; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_NMEDIT+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_NMEDIT"; then
+  ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_NMEDIT="nmedit"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
+if test -n "$ac_ct_NMEDIT"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
+printf "%s\n" "$ac_ct_NMEDIT" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_NMEDIT" = x; then
+    NMEDIT=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    NMEDIT=$ac_ct_NMEDIT
+  fi
+else
+  NMEDIT="$ac_cv_prog_NMEDIT"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
+set dummy ${ac_tool_prefix}lipo; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_LIPO+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$LIPO"; then
+  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+LIPO=$ac_cv_prog_LIPO
+if test -n "$LIPO"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+printf "%s\n" "$LIPO" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_LIPO"; then
+  ac_ct_LIPO=$LIPO
+  # Extract the first word of "lipo", so it can be a program name with args.
+set dummy lipo; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_LIPO+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_LIPO"; then
+  ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_LIPO="lipo"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
+if test -n "$ac_ct_LIPO"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
+printf "%s\n" "$ac_ct_LIPO" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_LIPO" = x; then
+    LIPO=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    LIPO=$ac_ct_LIPO
+  fi
+else
+  LIPO="$ac_cv_prog_LIPO"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_OTOOL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$OTOOL"; then
+  ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL=$ac_cv_prog_OTOOL
+if test -n "$OTOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
+printf "%s\n" "$OTOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL"; then
+  ac_ct_OTOOL=$OTOOL
+  # Extract the first word of "otool", so it can be a program name with args.
+set dummy otool; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_OTOOL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_OTOOL"; then
+  ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OTOOL="otool"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
+if test -n "$ac_ct_OTOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
+printf "%s\n" "$ac_ct_OTOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_OTOOL" = x; then
+    OTOOL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OTOOL=$ac_ct_OTOOL
+  fi
+else
+  OTOOL="$ac_cv_prog_OTOOL"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool64; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_OTOOL64+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$OTOOL64"; then
+  ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL64=$ac_cv_prog_OTOOL64
+if test -n "$OTOOL64"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
+printf "%s\n" "$OTOOL64" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL64"; then
+  ac_ct_OTOOL64=$OTOOL64
+  # Extract the first word of "otool64", so it can be a program name with args.
+set dummy otool64; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_OTOOL64+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_OTOOL64"; then
+  ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OTOOL64="otool64"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
+if test -n "$ac_ct_OTOOL64"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
+printf "%s\n" "$ac_ct_OTOOL64" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_OTOOL64" = x; then
+    OTOOL64=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OTOOL64=$ac_ct_OTOOL64
+  fi
+else
+  OTOOL64="$ac_cv_prog_OTOOL64"
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
+printf %s "checking for -single_module linker flag... " >&6; }
+if test ${lt_cv_apple_cc_single_mod+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_apple_cc_single_mod=no
+      if test -z "$LT_MULTI_MODULE"; then
+	# By default we will add the -single_module flag. You can override
+	# by either setting the environment variable LT_MULTI_MODULE
+	# non-empty at configure time, or by adding -multi_module to the
+	# link flags.
+	rm -rf libconftest.dylib*
+	echo "int foo(void){return 1;}" > conftest.c
+	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+-dynamiclib -Wl,-single_module conftest.c" >&5
+	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
+        _lt_result=$?
+	# If there is a non-empty error log, and "single_module"
+	# appears in it, assume the flag caused a linker warning
+        if test -s conftest.err && $GREP single_module conftest.err; then
+	  cat conftest.err >&5
+	# Otherwise, if the output was created with a 0 exit code from
+	# the compiler, it worked.
+	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
+	  lt_cv_apple_cc_single_mod=yes
+	else
+	  cat conftest.err >&5
+	fi
+	rm -rf libconftest.dylib*
+	rm -f conftest.*
+      fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
+printf "%s\n" "$lt_cv_apple_cc_single_mod" >&6; }
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
+printf %s "checking for -exported_symbols_list linker flag... " >&6; }
+if test ${lt_cv_ld_exported_symbols_list+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_ld_exported_symbols_list=no
+      save_LDFLAGS=$LDFLAGS
+      echo "_main" > conftest.sym
+      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  lt_cv_ld_exported_symbols_list=yes
+else $as_nop
+  lt_cv_ld_exported_symbols_list=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+	LDFLAGS=$save_LDFLAGS
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
+printf "%s\n" "$lt_cv_ld_exported_symbols_list" >&6; }
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
+printf %s "checking for -force_load linker flag... " >&6; }
+if test ${lt_cv_ld_force_load+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_ld_force_load=no
+      cat > conftest.c << _LT_EOF
+int forced_loaded() { return 2;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
+      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
+      echo "$AR cr libconftest.a conftest.o" >&5
+      $AR cr libconftest.a conftest.o 2>&5
+      echo "$RANLIB libconftest.a" >&5
+      $RANLIB libconftest.a 2>&5
+      cat > conftest.c << _LT_EOF
+int main() { return 0;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5
+      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
+      _lt_result=$?
+      if test -s conftest.err && $GREP force_load conftest.err; then
+	cat conftest.err >&5
+      elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
+	lt_cv_ld_force_load=yes
+      else
+	cat conftest.err >&5
+      fi
+        rm -f conftest.err libconftest.a conftest conftest.c
+        rm -rf conftest.dSYM
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
+printf "%s\n" "$lt_cv_ld_force_load" >&6; }
+    case $host_os in
+    rhapsody* | darwin1.[012])
+      _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
+    darwin1.*)
+      _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+    darwin*) # darwin 5.x on
+      # if running on 10.5 or later, the deployment target defaults
+      # to the OS version, if on x86, and 10.4, the deployment
+      # target defaults to 10.4. Don't you love it?
+      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
+	10.0,*86*-darwin8*|10.0,*-darwin[912]*)
+	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+	10.[012][,.]*)
+	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+	10.*|11.*)
+	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+      esac
+    ;;
+  esac
+    if test yes = "$lt_cv_apple_cc_single_mod"; then
+      _lt_dar_single_mod='$single_module'
+    fi
+    if test yes = "$lt_cv_ld_exported_symbols_list"; then
+      _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
+    else
+      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
+    fi
+    if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
+      _lt_dsymutil='~$DSYMUTIL $lib || :'
+    else
+      _lt_dsymutil=
+    fi
+    ;;
+  esac
+
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR[:DIR]:"
+#       string "DIR[ DIR]" will be prepended to VARIABLE
+# ":DIR[:DIR]"
+#       string "DIR[ DIR]" will be appended to VARIABLE
+# "DIRP[:DIRP]::[DIRA:]DIRA"
+#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
+#       "DIRA[ DIRA]" will be appended to VARIABLE
+# "DIR[:DIR]"
+#       VARIABLE will be replaced by "DIR[ DIR]"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
+ac_header= ac_cache=
+for ac_item in $ac_header_c_list
+do
+  if test $ac_cache; then
+    ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default"
+    if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then
+      printf "%s\n" "#define $ac_item 1" >> confdefs.h
+    fi
+    ac_header= ac_cache=
+  elif test $ac_header; then
+    ac_cache=$ac_item
+  else
+    ac_header=$ac_item
+  fi
+done
+
+
+
+
+
+
+
+
+if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes
+then :
+
+printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
+"
+if test "x$ac_cv_header_dlfcn_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_DLFCN_H 1" >>confdefs.h
+
+fi
+
+
+
+func_stripname_cnf ()
+{
+  case $2 in
+  .*) func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%\\\\$2\$%%"`;;
+  *)  func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%$2\$%%"`;;
+  esac
+} # func_stripname_cnf
+
+# ------------------------------------ #
+#  Determine libtool default behavior  #
+# ------------------------------------ #
+
+#
+# Default behavior is to enable shared and static libraries on systems
+# where libtool knows how to build both library versions, and does not
+# require separate configuration and build runs for each flavor.
+#
+
+xc_lt_want_enable_shared='yes'
+xc_lt_want_enable_static='yes'
+
+#
+# User may have disabled shared or static libraries.
+#
+case "x$enable_shared" in # (
+  xno)
+    xc_lt_want_enable_shared='no'
+    ;;
+esac
+case "x$enable_static" in # (
+  xno)
+    xc_lt_want_enable_static='no'
+    ;;
+esac
+if test "x$xc_lt_want_enable_shared" = 'xno' &&
+  test "x$xc_lt_want_enable_static" = 'xno'; then
+  as_fn_error $? "can not disable shared and static libraries simultaneously" "$LINENO" 5
+fi
+
+#
+# Default behavior on systems that require independent configuration
+# and build runs for shared and static is to enable shared libraries
+# and disable static ones. On these systems option '--disable-shared'
+# must be used in order to build a proper static library.
+#
+
+if test "x$xc_lt_want_enable_shared" = 'xyes' &&
+  test "x$xc_lt_want_enable_static" = 'xyes'; then
+  case $host_os in # (
+    mingw* | pw32* | cegcc* | os2* | aix*)
+      xc_lt_want_enable_static='no'
+      ;;
+  esac
+fi
+
+#
+# Make libtool aware of current shared and static library preferences
+# taking in account that, depending on host characteristics, libtool
+# may modify these option preferences later in this configure script.
+#
+
+enable_shared=$xc_lt_want_enable_shared
+enable_static=$xc_lt_want_enable_static
+
+#
+# Default behavior is to build PIC objects for shared libraries and
+# non-PIC objects for static libraries.
+#
+
+xc_lt_want_with_pic='default'
+
+#
+# User may have specified PIC preference.
+#
+
+case "x$with_pic" in # ((
+  xno)
+    xc_lt_want_with_pic='no'
+    ;;
+  xyes)
+    xc_lt_want_with_pic='yes'
+    ;;
+esac
+
+#
+# Default behavior on some systems where building a shared library out
+# of non-PIC compiled objects will fail with following linker error
+# "relocation R_X86_64_32 can not be used when making a shared object"
+# is to build PIC objects even for static libraries. This behavior may
+# be overriden using 'configure --disable-shared --without-pic'.
+#
+
+if test "x$xc_lt_want_with_pic" = 'xdefault'; then
+  case $host_cpu in # (
+    x86_64 | amd64 | ia64)
+      case $host_os in # (
+        linux* | freebsd*)
+          xc_lt_want_with_pic='yes'
+          ;;
+      esac
+      ;;
+  esac
+fi
+
+#
+# Make libtool aware of current PIC preference taking in account that,
+# depending on host characteristics, libtool may modify PIC default
+# behavior to fit host system idiosyncrasies later in this script.
+#
+
+with_pic=$xc_lt_want_with_pic
+
+## ----------------------- ##
+##  Start of libtool code  ##
+## ----------------------- ##
+
+
+
+
+# Set options
+enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
+set dummy ${ac_tool_prefix}as; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_AS+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$AS"; then
+  ac_cv_prog_AS="$AS" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AS="${ac_tool_prefix}as"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AS=$ac_cv_prog_AS
+if test -n "$AS"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
+printf "%s\n" "$AS" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_AS"; then
+  ac_ct_AS=$AS
+  # Extract the first word of "as", so it can be a program name with args.
+set dummy as; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_AS+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_AS"; then
+  ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_AS="as"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_AS=$ac_cv_prog_ac_ct_AS
+if test -n "$ac_ct_AS"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
+printf "%s\n" "$ac_ct_AS" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_AS" = x; then
+    AS="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AS=$ac_ct_AS
+  fi
+else
+  AS="$ac_cv_prog_AS"
+fi
+
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dlltool; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_DLLTOOL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$DLLTOOL"; then
+  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DLLTOOL=$ac_cv_prog_DLLTOOL
+if test -n "$DLLTOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+printf "%s\n" "$DLLTOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DLLTOOL"; then
+  ac_ct_DLLTOOL=$DLLTOOL
+  # Extract the first word of "dlltool", so it can be a program name with args.
+set dummy dlltool; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_DLLTOOL"; then
+  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
+if test -n "$ac_ct_DLLTOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_DLLTOOL" = x; then
+    DLLTOOL="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DLLTOOL=$ac_ct_DLLTOOL
+  fi
+else
+  DLLTOOL="$ac_cv_prog_DLLTOOL"
+fi
+
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_OBJDUMP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+printf "%s\n" "$OBJDUMP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+  ac_ct_OBJDUMP=$OBJDUMP
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -n "$ac_ct_OBJDUMP"; then
+  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OBJDUMP="objdump"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_OBJDUMP" = x; then
+    OBJDUMP="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OBJDUMP=$ac_ct_OBJDUMP
+  fi
+else
+  OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+  ;;
+esac
+
+test -z "$AS" && AS=as
+
+
+
+
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+
+
+
+
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+
+
+
+
+
+
+        enable_dlopen=no
+
+
+
+            # Check whether --enable-shared was given.
+if test ${enable_shared+y}
+then :
+  enableval=$enable_shared; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else $as_nop
+  enable_shared=yes
+fi
+
+
+
+
+
+
+
+
+
+  # Check whether --enable-static was given.
+if test ${enable_static+y}
+then :
+  enableval=$enable_static; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else $as_nop
+  enable_static=yes
+fi
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-pic was given.
+if test ${with_pic+y}
+then :
+  withval=$with_pic; lt_p=${PACKAGE-default}
+    case $withval in
+    yes|no) pic_mode=$withval ;;
+    *)
+      pic_mode=default
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for lt_pkg in $withval; do
+	IFS=$lt_save_ifs
+	if test "X$lt_pkg" = "X$lt_p"; then
+	  pic_mode=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else $as_nop
+  pic_mode=default
+fi
+
+
+
+
+
+
+
+
+  # Check whether --enable-fast-install was given.
+if test ${enable_fast_install+y}
+then :
+  enableval=$enable_fast_install; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else $as_nop
+  enable_fast_install=yes
+fi
+
+
+
+
+
+
+
+
+  shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix[5-9]*,yes)
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
+printf %s "checking which variant of shared library versioning to provide... " >&6; }
+
+# Check whether --with-aix-soname was given.
+if test ${with_aix_soname+y}
+then :
+  withval=$with_aix_soname; case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname
+else $as_nop
+  if test ${lt_cv_with_aix_soname+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_with_aix_soname=aix
+fi
+
+    with_aix_soname=$lt_cv_with_aix_soname
+fi
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
+printf "%s\n" "$with_aix_soname" >&6; }
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS=$ltmain
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+test -z "$LN_S" && LN_S="ln -s"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "${ZSH_VERSION+set}"; then
+   setopt NO_GLOB_SUBST
+fi
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
+printf %s "checking for objdir... " >&6; }
+if test ${lt_cv_objdir+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
+printf "%s\n" "$lt_cv_objdir" >&6; }
+objdir=$lt_cv_objdir
+
+
+
+
+
+printf "%s\n" "#define LT_OBJDIR \"$lt_cv_objdir/\"" >>confdefs.h
+
+
+
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test set != "${COLLECT_NAMES+set}"; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Global variables:
+ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a '.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+old_CC=$CC
+old_CFLAGS=$CFLAGS
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
+
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
+printf %s "checking for ${ac_tool_prefix}file... " >&6; }
+if test ${lt_cv_path_MAGIC_CMD+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  case $MAGIC_CMD in
+[\\/*] |  ?:[\\/]*)
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/${ac_tool_prefix}file"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"${ac_tool_prefix}file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
+  ;;
+esac
+fi
+
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+if test -n "$MAGIC_CMD"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+printf "%s\n" "$MAGIC_CMD" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+
+
+
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for file" >&5
+printf %s "checking for file... " >&6; }
+if test ${lt_cv_path_MAGIC_CMD+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  case $MAGIC_CMD in
+[\\/*] |  ?:[\\/]*)
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/file"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
+  ;;
+esac
+fi
+
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+if test -n "$MAGIC_CMD"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+printf "%s\n" "$MAGIC_CMD" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+  else
+    MAGIC_CMD=:
+  fi
+fi
+
+  fi
+  ;;
+esac
+
+# Use C for the default configuration in the libtool script
+
+lt_save_CC=$CC
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+objext=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}'
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
+compiler_DEFAULT=$CC
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+
+lt_prog_compiler_no_builtin_flag=
+
+if test yes = "$GCC"; then
+  case $cc_basename in
+  nvcc*)
+    lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
+  *)
+    lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
+  esac
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+printf %s "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
+if test ${lt_cv_prog_compiler_rtti_exceptions+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_rtti_exceptions=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="-fno-rtti -fno-exceptions"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_rtti_exceptions=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
+printf "%s\n" "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then
+    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
+else
+    :
+fi
+
+fi
+
+
+
+
+
+
+  lt_prog_compiler_wl=
+lt_prog_compiler_pic=
+lt_prog_compiler_static=
+
+
+  if test yes = "$GCC"; then
+    lt_prog_compiler_wl='-Wl,'
+    lt_prog_compiler_static='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            lt_prog_compiler_pic='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
+            lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      ;;
+
+    haiku*)
+      # PIC is the default for Haiku.
+      # The "-static" flag exists, but is broken.
+      lt_prog_compiler_static=
+      ;;
+
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='-fPIC'
+	;;
+      esac
+      ;;
+
+    interix[3-9]*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      lt_prog_compiler_can_build_shared=no
+      enable_shared=no
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic='-fPIC -shared'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic=-Kconform_pic
+      fi
+      ;;
+
+    *)
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+    esac
+
+    case $cc_basename in
+    nvcc*) # Cuda Compiler Driver 2.2
+      lt_prog_compiler_wl='-Xlinker '
+      if test -n "$lt_prog_compiler_pic"; then
+        lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic"
+      fi
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      lt_prog_compiler_wl='-Wl,'
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      else
+	lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      case $cc_basename in
+      nagfor*)
+        # NAG Fortran compiler
+        lt_prog_compiler_wl='-Wl,-Wl,,'
+        lt_prog_compiler_pic='-PIC'
+        lt_prog_compiler_static='-Bstatic'
+        ;;
+      esac
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      lt_prog_compiler_static='$wl-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC (with -KPIC) is the default.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+      case $cc_basename in
+      # old Intel for x86_64, which still supported -KPIC.
+      ecc*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-KPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # flang / f18. f95 an alias for gfortran or flang on Debian
+      flang* | f18* | f95*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # icc used to be incompatible with GCC.
+      # ICC 10 doesn't accept -KPIC any more.
+      icc* | ifort*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # Lahey Fortran 8.1.
+      lf95*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='--shared'
+	lt_prog_compiler_static='--static'
+	;;
+      nagfor*)
+	# NAG Fortran compiler
+	lt_prog_compiler_wl='-Wl,-Wl,,'
+	lt_prog_compiler_pic='-PIC'
+	lt_prog_compiler_static='-Bstatic'
+	;;
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+	;;
+      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fpic'
+	lt_prog_compiler_static='-Bstatic'
+        ;;
+      ccc*)
+        lt_prog_compiler_wl='-Wl,'
+        # All Alpha code is PIC.
+        lt_prog_compiler_static='-non_shared'
+        ;;
+      xl* | bgxl* | bgf* | mpixl*)
+	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-qpic'
+	lt_prog_compiler_static='-qstaticlink'
+	;;
+      *)
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*)
+	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl=''
+	  ;;
+	*Sun\ F* | *Sun*Fortran*)
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl='-Qoption ld '
+	  ;;
+	*Sun\ C*)
+	  # Sun C 5.9
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl='-Wl,'
+	  ;;
+        *Intel*\ [CF]*Compiler*)
+	  lt_prog_compiler_wl='-Wl,'
+	  lt_prog_compiler_pic='-fPIC'
+	  lt_prog_compiler_static='-static'
+	  ;;
+	*Portland\ Group*)
+	  lt_prog_compiler_wl='-Wl,'
+	  lt_prog_compiler_pic='-fpic'
+	  lt_prog_compiler_static='-Bstatic'
+	  ;;
+	esac
+	;;
+      esac
+      ;;
+
+    newsos6)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic='-fPIC -shared'
+      ;;
+
+    osf3* | osf4* | osf5*)
+      lt_prog_compiler_wl='-Wl,'
+      # All OSF/1 code is PIC.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    rdos*)
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    solaris*)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
+	lt_prog_compiler_wl='-Qoption ld ';;
+      *)
+	lt_prog_compiler_wl='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      lt_prog_compiler_wl='-Qoption ld '
+      lt_prog_compiler_pic='-PIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic='-Kconform_pic'
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    unicos*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_can_build_shared=no
+      ;;
+
+    uts4*)
+      lt_prog_compiler_pic='-pic'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *)
+      lt_prog_compiler_can_build_shared=no
+      ;;
+    esac
+  fi
+
+case $host_os in
+  # For platforms that do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic=
+    ;;
+  *)
+    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
+    ;;
+esac
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+printf %s "checking for $compiler option to produce PIC... " >&6; }
+if test ${lt_cv_prog_compiler_pic+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_pic=$lt_prog_compiler_pic
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
+printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; }
+lt_prog_compiler_pic=$lt_cv_prog_compiler_pic
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
+printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
+if test ${lt_cv_prog_compiler_pic_works+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_pic_works=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_pic_works=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
+printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_pic_works"; then
+    case $lt_prog_compiler_pic in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
+     esac
+else
+    lt_prog_compiler_pic=
+     lt_prog_compiler_can_build_shared=no
+fi
+
+fi
+
+
+
+
+
+
+
+
+
+
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
+if test ${lt_cv_prog_compiler_static_works+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_static_works=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler_static_works=yes
+       fi
+     else
+       lt_cv_prog_compiler_static_works=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
+printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_static_works"; then
+    :
+else
+    lt_prog_compiler_static=
+fi
+
+
+
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if test ${lt_cv_prog_compiler_c_o+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_c_o=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if test ${lt_cv_prog_compiler_c_o+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_c_o=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+hard_links=nottested
+if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then
+  # do not overwrite the value of need_locks provided by the user
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+printf %s "checking if we can lock with hard links... " >&6; }
+  hard_links=yes
+  $RM conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+printf "%s\n" "$hard_links" >&6; }
+  if test no = "$hard_links"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
+printf "%s\n" "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+
+  runpath_var=
+  allow_undefined_flag=
+  always_export_symbols=no
+  archive_cmds=
+  archive_expsym_cmds=
+  compiler_needs_object=no
+  enable_shared_with_static_runtimes=no
+  export_dynamic_flag_spec=
+  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  hardcode_automatic=no
+  hardcode_direct=no
+  hardcode_direct_absolute=no
+  hardcode_libdir_flag_spec=
+  hardcode_libdir_separator=
+  hardcode_minus_L=no
+  hardcode_shlibpath_var=unsupported
+  inherit_rpath=no
+  link_all_deplibs=unknown
+  module_cmds=
+  module_expsym_cmds=
+  old_archive_from_new_cmds=
+  old_archive_from_expsyms_cmds=
+  thread_safe_flag_spec=
+  whole_archive_flag_spec=
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  include_expsyms=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ' (' and ')$', so one must not match beginning or
+  # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
+  # as well as any symbol that contains 'd'.
+  exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  # Exclude shared library initialization/finalization symbols.
+  extract_expsyms_cmds=
+
+  case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test yes != "$GCC"; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd* | bitrig*)
+    with_gnu_ld=no
+    ;;
+  linux* | k*bsd*-gnu | gnu*)
+    link_all_deplibs=no
+    ;;
+  esac
+
+  ld_shlibs=yes
+
+  # On some targets, GNU ld is compatible enough with the native linker
+  # that we're better off using the native interface for both.
+  lt_use_gnu_ld_interface=no
+  if test yes = "$with_gnu_ld"; then
+    case $host_os in
+      aix*)
+	# The AIX port of GNU ld has always aspired to compatibility
+	# with the native linker.  However, as the warning in the GNU ld
+	# block says, versions before 2.19.5* couldn't really create working
+	# shared libraries, regardless of the interface used.
+	case `$LD -v 2>&1` in
+	  *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
+	  *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;;
+	  *\ \(GNU\ Binutils\)\ [3-9]*) ;;
+	  *)
+	    lt_use_gnu_ld_interface=yes
+	    ;;
+	esac
+	;;
+      *)
+	lt_use_gnu_ld_interface=yes
+	;;
+    esac
+  fi
+
+  if test yes = "$lt_use_gnu_ld_interface"; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='$wl'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+    export_dynamic_flag_spec='$wl--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+      whole_archive_flag_spec=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+    else
+      whole_archive_flag_spec=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v | $SED -e 's/(^)\+)\s\+//' 2>&1` in
+      *GNU\ gold*) supports_anon_versioning=yes ;;
+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix[3-9]*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test ia64 != "$host_cpu"; then
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.19, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to install binutils
+*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
+*** You will then need to restart the configuration process.
+
+_LT_EOF
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+            archive_expsym_cmds=''
+        ;;
+      m68k)
+            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_minus_L=yes
+        ;;
+      esac
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	allow_undefined_flag=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
+      # as there is no search path for DLLs.
+      hardcode_libdir_flag_spec='-L$libdir'
+      export_dynamic_flag_spec='$wl--export-all-symbols'
+      allow_undefined_flag=unsupported
+      always_export_symbols=no
+      enable_shared_with_static_runtimes=yes
+      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
+      exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
+
+      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file, use it as
+	# is; otherwise, prepend EXPORTS...
+	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+          cp $export_symbols $output_objdir/$soname.def;
+        else
+          echo EXPORTS > $output_objdir/$soname.def;
+          cat $export_symbols >> $output_objdir/$soname.def;
+        fi~
+        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    haiku*)
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+      link_all_deplibs=yes
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
+    interix[3-9]*)
+      hardcode_direct=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+      export_dynamic_flag_spec='$wl-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+      tmp_diet=no
+      if test linux-dietlibc = "$host_os"; then
+	case $cc_basename in
+	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
+	esac
+      fi
+      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
+	 && test no = "$tmp_diet"
+      then
+	tmp_addflag=' $pic_flag'
+	tmp_sharedflag='-shared'
+	case $cc_basename,$host_cpu in
+        pgcc*)				# Portland Group C compiler
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95* | pgfortran*)
+					# Portland Group f77 and f90 compilers
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	lf95*)				# Lahey Fortran 8.1
+	  whole_archive_flag_spec=
+	  tmp_sharedflag='--shared' ;;
+        nagfor*)                        # NAGFOR 5.3
+          tmp_sharedflag='-Wl,-shared' ;;
+	xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
+	  tmp_sharedflag='-qmkshrobj'
+	  tmp_addflag= ;;
+	nvcc*)	# Cuda Compiler Driver 2.2
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  compiler_needs_object=yes
+	  ;;
+	esac
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ C*)			# Sun C 5.9
+	  whole_archive_flag_spec='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  compiler_needs_object=yes
+	  tmp_sharedflag='-G' ;;
+	*Sun\ F*)			# Sun Fortran 8.3
+	  tmp_sharedflag='-G' ;;
+	esac
+	archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+
+        if test yes = "$supports_anon_versioning"; then
+          archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+            echo "local: *; };" >> $output_objdir/$libname.ver~
+            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
+        fi
+
+	case $cc_basename in
+	tcc*)
+	  export_dynamic_flag_spec='-rdynamic'
+	  ;;
+	xlf* | bgf* | bgxlf* | mpixlf*)
+	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
+	  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
+	  hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+	  archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
+	  if test yes = "$supports_anon_versioning"; then
+	    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+              echo "local: *; };" >> $output_objdir/$libname.ver~
+              $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+	  fi
+	  ;;
+	esac
+      else
+        ld_shlibs=no
+      fi
+      ;;
+
+    netbsd* | netbsdelf*-gnu)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  # For security reasons, it is highly recommended that you always
+	  # use absolute paths for naming shared libraries, and exclude the
+	  # DT_RUNPATH tag from executables and libraries.  But doing so
+	  # requires that you compile everything twice, which is a pain.
+	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	  else
+	    ld_shlibs=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+    esac
+
+    if test no = "$ld_shlibs"; then
+      runpath_var=
+      hardcode_libdir_flag_spec=
+      export_dynamic_flag_spec=
+      whole_archive_flag_spec=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      allow_undefined_flag=unsupported
+      always_export_symbols=yes
+      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L=yes
+      if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	hardcode_direct=unsupported
+      fi
+      ;;
+
+    aix[4-9]*)
+      if test ia64 = "$host_cpu"; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
+	# Without the "-l" option, or with the "-B" option, AIX nm treats
+	# weak defined symbols like other global defined symbols, whereas
+	# GNU nm marks them as "W".
+	# While the 'weak' keyword is ignored in the Export File, we need
+	# it in the Import File for the 'aix-soname' feature, so we have
+	# to replace the "-B" option with "-P" for AIX nm.
+	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
+	else
+	  export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# have runtime linking enabled, and use it for executables.
+	# For shared libraries, we enable/disable runtime linking
+	# depending on the kind of the shared library created -
+	# when "with_aix_soname,aix_use_runtimelinking" is:
+	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "aix,yes"  lib.so          shared, rtl:yes, for executables
+	#            lib.a           static archive
+	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
+	#            lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a(lib.so.V) shared, rtl:no
+	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a           static archive
+	case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
+	  for ld_flag in $LDFLAGS; do
+	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
+	    aix_use_runtimelinking=yes
+	    break
+	  fi
+	  done
+	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	    # so we don't have lib.a shared libs to link our executables.
+	    # We have to force runtime linking in this case.
+	    aix_use_runtimelinking=yes
+	    LDFLAGS="$LDFLAGS -Wl,-brtl"
+	  fi
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      archive_cmds=''
+      hardcode_direct=yes
+      hardcode_direct_absolute=yes
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      file_list_spec='$wl-f,'
+      case $with_aix_soname,$aix_use_runtimelinking in
+      aix,*) ;; # traditional, no import file
+      svr4,* | *,yes) # use import file
+	# The Import File defines what to hardcode.
+	hardcode_direct=no
+	hardcode_direct_absolute=no
+	;;
+      esac
+
+      if test yes = "$GCC"; then
+	case $host_os in aix4.[012]|aix4.[012].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`$CC -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+	  # We have reworked collect2
+	  :
+	  else
+	  # We have old collect2
+	  hardcode_direct=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  hardcode_minus_L=yes
+	  hardcode_libdir_flag_spec='-L$libdir'
+	  hardcode_libdir_separator=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test yes = "$aix_use_runtimelinking"; then
+	  shared_flag="$shared_flag "'$wl-G'
+	fi
+	# Need to ensure runtime linking is disabled for the traditional
+	# shared library, or the linker may eventually find shared libraries
+	# /with/ Import File - we do not want to mix them.
+	shared_flag_aix='-shared'
+	shared_flag_svr4='-shared $wl-G'
+      else
+	# not using gcc
+	if test ia64 = "$host_cpu"; then
+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag='$wl-G'
+	  else
+	    shared_flag='$wl-bM:SRE'
+	  fi
+	  shared_flag_aix='$wl-bM:SRE'
+	  shared_flag_svr4='$wl-G'
+	fi
+      fi
+
+      export_dynamic_flag_spec='$wl-bexpall'
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      always_export_symbols=yes
+      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag='-berok'
+        # Determine the default libpath from the value encoded in an
+        # empty executable.
+        if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if test ${lt_cv_aix_libpath_+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *\([^ ]*\) *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath_
+fi
+
+        hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
+        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
+      else
+	if test ia64 = "$host_cpu"; then
+	  hardcode_libdir_flag_spec='$wl-R $libdir:/usr/lib:/lib'
+	  allow_undefined_flag="-z nodefs"
+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an
+	 # empty executable.
+	 if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if test ${lt_cv_aix_libpath_+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *\([^ ]*\) *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath_
+fi
+
+	 hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  no_undefined_flag=' $wl-bernotok'
+	  allow_undefined_flag=' $wl-berok'
+	  if test yes = "$with_gnu_ld"; then
+	    # We only use this code for GNU lds that support --whole-archive.
+	    whole_archive_flag_spec='$wl--whole-archive$convenience $wl--no-whole-archive'
+	  else
+	    # Exported symbols can be pulled into shared objects from archives
+	    whole_archive_flag_spec='$convenience'
+	  fi
+	  archive_cmds_need_lc=yes
+	  archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	  # -brtl affects multiple linker settings, -berok does not and is overridden later
+	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`'
+	  if test svr4 != "$with_aix_soname"; then
+	    # This is similar to how AIX traditionally builds its shared libraries.
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	  fi
+	  if test aix != "$with_aix_soname"; then
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	  else
+	    # used by -dlpreopen to get the symbols
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	  fi
+	  archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+            archive_expsym_cmds=''
+        ;;
+      m68k)
+            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_minus_L=yes
+        ;;
+      esac
+      ;;
+
+    bsdi[45]*)
+      export_dynamic_flag_spec=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      case $cc_basename in
+      cl*)
+	# Native MSVC
+	hardcode_libdir_flag_spec=' '
+	allow_undefined_flag=unsupported
+	always_export_symbols=yes
+	file_list_spec='@'
+	# Tell ltmain to make .lib files, not .a files.
+	libext=lib
+	# Tell ltmain to make .dll files, not .so files.
+	shrext_cmds=.dll
+	# FIXME: Setting linknames here is a bad hack.
+	archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+            cp "$export_symbols" "$output_objdir/$soname.def";
+            echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+          else
+            $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+          fi~
+          $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+          linknames='
+	# The linker will not automatically build a static lib if we build a DLL.
+	# _LT_TAGVAR(old_archive_from_new_cmds, )='true'
+	enable_shared_with_static_runtimes=yes
+	exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+	export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
+	# Don't use ranlib
+	old_postinstall_cmds='chmod 644 $oldlib'
+	postlink_cmds='lt_outputfile="@OUTPUT@"~
+          lt_tool_outputfile="@TOOL_OUTPUT@"~
+          case $lt_outputfile in
+            *.exe|*.EXE) ;;
+            *)
+              lt_outputfile=$lt_outputfile.exe
+              lt_tool_outputfile=$lt_tool_outputfile.exe
+              ;;
+          esac~
+          if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+            $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+            $RM "$lt_outputfile.manifest";
+          fi'
+	;;
+      *)
+	# Assume MSVC wrapper
+	hardcode_libdir_flag_spec=' '
+	allow_undefined_flag=unsupported
+	# Tell ltmain to make .lib files, not .a files.
+	libext=lib
+	# Tell ltmain to make .dll files, not .so files.
+	shrext_cmds=.dll
+	# FIXME: Setting linknames here is a bad hack.
+	archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+	# The linker will automatically build a .lib file if we build a DLL.
+	old_archive_from_new_cmds='true'
+	# FIXME: Should let the user specify the lib program.
+	old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
+	enable_shared_with_static_runtimes=yes
+	;;
+      esac
+      ;;
+
+    darwin* | rhapsody*)
+
+
+  archive_cmds_need_lc=no
+  hardcode_direct=no
+  hardcode_automatic=yes
+  hardcode_shlibpath_var=unsupported
+  if test yes = "$lt_cv_ld_force_load"; then
+    whole_archive_flag_spec='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+
+  else
+    whole_archive_flag_spec=''
+  fi
+  link_all_deplibs=yes
+  allow_undefined_flag=$_lt_dar_allow_undefined
+  case $cc_basename in
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
+     *) _lt_dar_can_shared=$GCC ;;
+  esac
+  if test yes = "$_lt_dar_can_shared"; then
+    output_verbose_link_cmd=func_echo_all
+    archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    archive_expsym_cmds="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+
+  else
+  ld_shlibs=no
+  fi
+
+      ;;
+
+    dgux*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2.*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | dragonfly*)
+      archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    hpux9*)
+      if test yes = "$GCC"; then
+	archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+      else
+	archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+      fi
+      hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+      hardcode_libdir_separator=:
+      hardcode_direct=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L=yes
+      export_dynamic_flag_spec='$wl-E'
+      ;;
+
+    hpux10*)
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test no = "$with_gnu_ld"; then
+	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+	hardcode_libdir_separator=:
+	hardcode_direct=yes
+	hardcode_direct_absolute=yes
+	export_dynamic_flag_spec='$wl-E'
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	hardcode_minus_L=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+
+	  # Older versions of the 11.00 compiler do not understand -b yet
+	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
+	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
+printf %s "checking if $CC understands -b... " >&6; }
+if test ${lt_cv_prog_compiler__b+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler__b=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS -b"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler__b=yes
+       fi
+     else
+       lt_cv_prog_compiler__b=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
+printf "%s\n" "$lt_cv_prog_compiler__b" >&6; }
+
+if test yes = "$lt_cv_prog_compiler__b"; then
+    archive_cmds='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+else
+    archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+fi
+
+	  ;;
+	esac
+      fi
+      if test no = "$with_gnu_ld"; then
+	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+	hardcode_libdir_separator=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  hardcode_direct=no
+	  hardcode_shlibpath_var=no
+	  ;;
+	*)
+	  hardcode_direct=yes
+	  hardcode_direct_absolute=yes
+	  export_dynamic_flag_spec='$wl-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  hardcode_minus_L=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	# Try to use the -exported_symbol ld option, if it does not
+	# work, assume that -exports_file does not work either and
+	# implicitly export all symbols.
+	# This should be the same for all languages, so no per-tag cache variable.
+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5
+printf %s "checking whether the $host_os linker accepts -exported_symbol... " >&6; }
+if test ${lt_cv_irix_exported_symbol+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  save_LDFLAGS=$LDFLAGS
+	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
+	   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+int foo (void) { return 0; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  lt_cv_irix_exported_symbol=yes
+else $as_nop
+  lt_cv_irix_exported_symbol=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+           LDFLAGS=$save_LDFLAGS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
+printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; }
+	if test yes = "$lt_cv_irix_exported_symbol"; then
+          archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
+	fi
+	link_all_deplibs=no
+      else
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      inherit_rpath=yes
+      link_all_deplibs=yes
+      ;;
+
+    linux*)
+      case $cc_basename in
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	ld_shlibs=yes
+	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      esac
+      ;;
+
+    netbsd* | netbsdelf*-gnu)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    newsos6)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      hardcode_shlibpath_var=no
+      ;;
+
+    *nto* | *qnx*)
+      ;;
+
+    openbsd* | bitrig*)
+      if test -f /usr/libexec/ld.so; then
+	hardcode_direct=yes
+	hardcode_shlibpath_var=no
+	hardcode_direct_absolute=yes
+	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols'
+	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+	  export_dynamic_flag_spec='$wl-E'
+	else
+	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+	fi
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
+    osf3*)
+      if test yes = "$GCC"; then
+	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test yes = "$GCC"; then
+	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
+	archive_cmds='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
+          $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	hardcode_libdir_flag_spec='-rpath $libdir'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_separator=:
+      ;;
+
+    solaris*)
+      no_undefined_flag=' -z defs'
+      if test yes = "$GCC"; then
+	wlarc='$wl'
+	archive_cmds='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+          $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+      else
+	case `$CC -V 2>&1` in
+	*"Compilers 5.0"*)
+	  wlarc=''
+	  archive_cmds='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+            $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+	  ;;
+	*)
+	  wlarc='$wl'
+	  archive_cmds='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+            $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+	  ;;
+	esac
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_shlibpath_var=no
+      case $host_os in
+      solaris2.[0-5] | solaris2.[0-5].*) ;;
+      *)
+	# The compiler driver will combine and reorder linker options,
+	# but understands '-z linker_flag'.  GCC discards it without '$wl',
+	# but is careful enough not to reorder.
+	# Supported since Solaris 2.6 (maybe 2.5.1?)
+	if test yes = "$GCC"; then
+	  whole_archive_flag_spec='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
+	else
+	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
+	fi
+	;;
+      esac
+      link_all_deplibs=yes
+      ;;
+
+    sunos4*)
+      if test sequent = "$host_vendor"; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	archive_cmds='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  reload_cmds='$CC -r -o $output$reload_objs'
+	  hardcode_direct=no
+        ;;
+	motorola)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4.3*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_shlibpath_var=no
+      export_dynamic_flag_spec='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_shlibpath_var=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	ld_shlibs=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+      no_undefined_flag='$wl-z,text'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      runpath_var='LD_RUN_PATH'
+
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We CANNOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      no_undefined_flag='$wl-z,text'
+      allow_undefined_flag='$wl-z,nodefs'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='$wl-R,$libdir'
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      export_dynamic_flag_spec='$wl-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      ld_shlibs=no
+      ;;
+    esac
+
+    if test sni = "$host_vendor"; then
+      case $host in
+      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+	export_dynamic_flag_spec='$wl-Blargedynsym'
+	;;
+      esac
+    fi
+  fi
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
+printf "%s\n" "$ld_shlibs" >&6; }
+test no = "$ld_shlibs" && can_build_shared=no
+
+with_gnu_ld=$with_gnu_ld
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc=yes
+
+  if test yes,yes = "$GCC,$enable_shared"; then
+    case $archive_cmds in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+printf %s "checking whether -lc should be explicitly linked in... " >&6; }
+if test ${lt_cv_archive_cmds_need_lc+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  $RM conftest*
+	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } 2>conftest.err; then
+	  soname=conftest
+	  lib=conftest
+	  libobjs=conftest.$ac_objext
+	  deplibs=
+	  wl=$lt_prog_compiler_wl
+	  pic_flag=$lt_prog_compiler_pic
+	  compiler_flags=-v
+	  linker_flags=-v
+	  verstring=
+	  output_objdir=.
+	  libname=conftest
+	  lt_save_allow_undefined_flag=$allow_undefined_flag
+	  allow_undefined_flag=
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
+  (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	  then
+	    lt_cv_archive_cmds_need_lc=no
+	  else
+	    lt_cv_archive_cmds_need_lc=yes
+	  fi
+	  allow_undefined_flag=$lt_save_allow_undefined_flag
+	else
+	  cat conftest.err 1>&5
+	fi
+	$RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
+printf "%s\n" "$lt_cv_archive_cmds_need_lc" >&6; }
+      archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+printf %s "checking dynamic linker characteristics... " >&6; }
+
+if test yes = "$GCC"; then
+  case $host_os in
+    darwin*) lt_awk_arg='/^libraries:/,/LR/' ;;
+    *) lt_awk_arg='/^libraries:/' ;;
+  esac
+  case $host_os in
+    mingw* | cegcc*) lt_sed_strip_eq='s|=\([A-Za-z]:\)|\1|g' ;;
+    *) lt_sed_strip_eq='s|=/|/|g' ;;
+  esac
+  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
+  case $lt_search_path_spec in
+  *\;*)
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
+    ;;
+  *)
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
+    ;;
+  esac
+  # Ok, now we have the path, separated by spaces, we can step through it
+  # and add multilib dir if necessary...
+  lt_tmp_lt_search_path_spec=
+  lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
+  # ...but if some path component already ends with the multilib dir we assume
+  # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer).
+  case "$lt_multi_os_dir; $lt_search_path_spec " in
+  "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*)
+    lt_multi_os_dir=
+    ;;
+  esac
+  for lt_sys_path in $lt_search_path_spec; do
+    if test -d "$lt_sys_path$lt_multi_os_dir"; then
+      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir"
+    elif test -n "$lt_multi_os_dir"; then
+      test -d "$lt_sys_path" && \
+	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
+    fi
+  done
+  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
+BEGIN {RS = " "; FS = "/|\n";} {
+  lt_foo = "";
+  lt_count = 0;
+  for (lt_i = NF; lt_i > 0; lt_i--) {
+    if ($lt_i != "" && $lt_i != ".") {
+      if ($lt_i == "..") {
+        lt_count++;
+      } else {
+        if (lt_count == 0) {
+          lt_foo = "/" $lt_i lt_foo;
+        } else {
+          lt_count--;
+        }
+      }
+    }
+  }
+  if (lt_foo != "") { lt_freq[lt_foo]++; }
+  if (lt_freq[lt_foo] == 1) { print lt_foo; }
+}'`
+  # AWK program above erroneously prepends '/' to C:/dos/paths
+  # for these hosts.
+  case $host_os in
+    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
+      $SED 's|/\([A-Za-z]:\)|\1|g'` ;;
+  esac
+  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=.so
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+
+
+case $host_os in
+aix3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='$libname$release$shared_ext$major'
+  ;;
+
+aix[4-9]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test ia64 = "$host_cpu"; then
+    # AIX 5 supports IA64
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[01] | aix4.[01].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  case $host_cpu in
+  powerpc)
+    # Since July 2007 AmigaOS4 officially supports .so libraries.
+    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    ;;
+  m68k)
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    ;;
+  esac
+  ;;
+
+beos*)
+  library_names_spec='$libname$shared_ext'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[45]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$cc_basename in
+  yes,*)
+    # gcc
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname~
+      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+      fi'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+
+      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
+      ;;
+    mingw* | cegcc*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      ;;
+    esac
+    dynamic_linker='Win32 ld.exe'
+    ;;
+
+  *,cl*)
+    # Native MSVC
+    libname_spec='$name'
+    soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
+
+    case $build_os in
+    mingw*)
+      sys_lib_search_path_spec=
+      lt_save_ifs=$IFS
+      IFS=';'
+      for lt_path in $LIB
+      do
+        IFS=$lt_save_ifs
+        # Let DOS variable expansion print the short 8.3 style file name.
+        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+      done
+      IFS=$lt_save_ifs
+      # Convert to MSYS style.
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
+      ;;
+    cygwin*)
+      # Convert to unix form, then to dos form, then back to unix form
+      # but this time dos style (no spaces!) so that the unix form looks
+      # like /cygdrive/c/PROGRA~1:/cygdr...
+      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      ;;
+    *)
+      sys_lib_search_path_spec=$LIB
+      if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
+        # It is most probably a Windows format PATH.
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      # FIXME: find the short name or the path components, as spaces are
+      # common. (e.g. "Program Files" -> "PROGRA~1")
+      ;;
+    esac
+
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+    dynamic_linker='Win32 link.exe'
+    ;;
+
+  *)
+    # Assume MSVC wrapper
+    library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
+    dynamic_linker='Win32 ld.exe'
+    ;;
+  esac
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+
+  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[23].*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2.*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  *) # from 4.6 on, and DragonFly
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+haiku*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  dynamic_linker="$host_os runtime_loader"
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
+    fi
+    ;;
+  hppa*64*)
+    shrext_cmds='.sl'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+  postinstall_cmds='chmod 555 $lib'
+  # or fails outright, so override atomically:
+  install_override_mode=555
+  ;;
+
+interix[3-9]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test yes = "$lt_cv_prog_gnu_ld"; then
+		version_type=linux # correct to gnu/linux during the next big refactor
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  hardcode_libdir_flag_spec='-L$libdir'
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+
+  # Some binutils ld are patched to set DT_RUNPATH
+  if test ${lt_cv_shlibpath_overrides_runpath+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_shlibpath_overrides_runpath=no
+    save_LDFLAGS=$LDFLAGS
+    save_libdir=$libdir
+    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
+	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null
+then :
+  lt_cv_shlibpath_overrides_runpath=yes
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+    LDFLAGS=$save_LDFLAGS
+    libdir=$save_libdir
+
+fi
+
+  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+netbsdelf*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='NetBSD ld.elf_so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+*nto* | *qnx*)
+  version_type=qnx
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='ldqnx.so'
+  ;;
+
+openbsd* | bitrig*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec=/usr/lib
+  need_lib_prefix=no
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+os2*)
+  libname_spec='$name'
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  ;;
+
+rdos*)
+  dynamic_linker=no
+  ;;
+
+solaris*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test yes = "$with_gnu_ld"; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec; then
+    version_type=linux # correct to gnu/linux during the next big refactor
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=sco
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  if test yes = "$with_gnu_ld"; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+tpf*)
+  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+uts4*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+printf "%s\n" "$dynamic_linker" >&6; }
+test no = "$dynamic_linker" && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test yes = "$GCC"; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
+fi
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
+fi
+
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+printf %s "checking how to hardcode library paths into programs... " >&6; }
+hardcode_action=
+if test -n "$hardcode_libdir_flag_spec" ||
+   test -n "$runpath_var" ||
+   test yes = "$hardcode_automatic"; then
+
+  # We can hardcode non-existent directories.
+  if test no != "$hardcode_direct" &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" &&
+     test no != "$hardcode_minus_L"; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action=unsupported
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
+printf "%s\n" "$hardcode_action" >&6; }
+
+if test relink = "$hardcode_action" ||
+   test yes = "$inherit_rpath"; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+
+
+
+
+  if test yes != "$enable_dlopen"; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen=load_add_on
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32* | cegcc*)
+    lt_cv_dlopen=LoadLibrary
+    lt_cv_dlopen_libs=
+    ;;
+
+  cygwin*)
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    ;;
+
+  darwin*)
+    # if libdl is installed we need to link against it
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+printf %s "checking for dlopen in -ldl... " >&6; }
+if test ${ac_cv_lib_dl_dlopen+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char dlopen ();
+int
+main (void)
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_dl_dlopen=yes
+else $as_nop
+  ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes
+then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
+else $as_nop
+
+    lt_cv_dlopen=dyld
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+
+fi
+
+    ;;
+
+  tpf*)
+    # Don't try to run any link tests for TPF.  We know it's impossible
+    # because TPF is a cross-compiler, and we know how we open DSOs.
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=no
+    ;;
+
+  *)
+    ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
+if test "x$ac_cv_func_shl_load" = xyes
+then :
+  lt_cv_dlopen=shl_load
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+printf %s "checking for shl_load in -ldld... " >&6; }
+if test ${ac_cv_lib_dld_shl_load+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char shl_load ();
+int
+main (void)
+{
+return shl_load ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_dld_shl_load=yes
+else $as_nop
+  ac_cv_lib_dld_shl_load=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
+printf "%s\n" "$ac_cv_lib_dld_shl_load" >&6; }
+if test "x$ac_cv_lib_dld_shl_load" = xyes
+then :
+  lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld
+else $as_nop
+  ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
+if test "x$ac_cv_func_dlopen" = xyes
+then :
+  lt_cv_dlopen=dlopen
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+printf %s "checking for dlopen in -ldl... " >&6; }
+if test ${ac_cv_lib_dl_dlopen+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char dlopen ();
+int
+main (void)
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_dl_dlopen=yes
+else $as_nop
+  ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes
+then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
+printf %s "checking for dlopen in -lsvld... " >&6; }
+if test ${ac_cv_lib_svld_dlopen+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsvld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char dlopen ();
+int
+main (void)
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_svld_dlopen=yes
+else $as_nop
+  ac_cv_lib_svld_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
+printf "%s\n" "$ac_cv_lib_svld_dlopen" >&6; }
+if test "x$ac_cv_lib_svld_dlopen" = xyes
+then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
+printf %s "checking for dld_link in -ldld... " >&6; }
+if test ${ac_cv_lib_dld_dld_link+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char dld_link ();
+int
+main (void)
+{
+return dld_link ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_dld_dld_link=yes
+else $as_nop
+  ac_cv_lib_dld_dld_link=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
+printf "%s\n" "$ac_cv_lib_dld_dld_link" >&6; }
+if test "x$ac_cv_lib_dld_dld_link" = xyes
+then :
+  lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+    ;;
+  esac
+
+  if test no = "$lt_cv_dlopen"; then
+    enable_dlopen=no
+  else
+    enable_dlopen=yes
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS=$CPPFLAGS
+    test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS=$LDFLAGS
+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS=$LIBS
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
+printf %s "checking whether a program can dlopen itself... " >&6; }
+if test ${lt_cv_dlopen_self+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  	  if test yes = "$cross_compiling"; then :
+  lt_cv_dlopen_self=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisibility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}
+_LT_EOF
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
+printf "%s\n" "$lt_cv_dlopen_self" >&6; }
+
+    if test yes = "$lt_cv_dlopen_self"; then
+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
+printf %s "checking whether a statically linked program can dlopen itself... " >&6; }
+if test ${lt_cv_dlopen_self_static+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  	  if test yes = "$cross_compiling"; then :
+  lt_cv_dlopen_self_static=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisibility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}
+_LT_EOF
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self_static=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
+printf "%s\n" "$lt_cv_dlopen_self_static" >&6; }
+    fi
+
+    CPPFLAGS=$save_CPPFLAGS
+    LDFLAGS=$save_LDFLAGS
+    LIBS=$save_LIBS
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+striplib=
+old_striplib=
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
+printf %s "checking whether stripping libraries is possible... " >&6; }
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+  darwin*)
+    if test -n "$STRIP"; then
+      striplib="$STRIP -x"
+      old_striplib="$STRIP -S"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    fi
+    ;;
+  *)
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ;;
+  esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+  # Report what library types will actually be built
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
+printf %s "checking if libtool supports shared libraries... " >&6; }
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
+printf "%s\n" "$can_build_shared" >&6; }
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
+printf %s "checking whether to build shared libraries... " >&6; }
+  test no = "$can_build_shared" && enable_shared=no
+
+  # On AIX, shared libraries and static libraries use the same namespace, and
+  # are all built from PIC.
+  case $host_os in
+  aix3*)
+    test yes = "$enable_shared" && enable_static=no
+    if test -n "$RANLIB"; then
+      archive_cmds="$archive_cmds~\$RANLIB \$lib"
+      postinstall_cmds='$RANLIB $lib'
+    fi
+    ;;
+
+  aix[4-9]*)
+    if test ia64 != "$host_cpu"; then
+      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+      yes,aix,yes) ;;			# shared object as lib.so file only
+      yes,svr4,*) ;;			# shared object as lib.so archive member only
+      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+      esac
+    fi
+    ;;
+  esac
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
+printf "%s\n" "$enable_shared" >&6; }
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
+printf %s "checking whether to build static libraries... " >&6; }
+  # Make sure either enable_shared or enable_static is yes.
+  test yes = "$enable_shared" || enable_static=yes
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
+printf "%s\n" "$enable_static" >&6; }
+
+
+
+
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC=$lt_save_CC
+
+      if test -n "$CXX" && ( test no != "$CXX" &&
+    ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) ||
+    (test g++ != "$CXX"))); then
+  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
+printf %s "checking how to run the C++ preprocessor... " >&6; }
+if test -z "$CXXCPP"; then
+  if test ${ac_cv_prog_CXXCPP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+      # Double quotes because $CXX needs to be expanded
+    for CXXCPP in "$CXX -E" cpp /lib/cpp
+    do
+      ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
+		     Syntax error
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"
+then :
+
+else $as_nop
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"
+then :
+  # Broken: success on invalid input.
+continue
+else $as_nop
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok
+then :
+  break
+fi
+
+    done
+    ac_cv_prog_CXXCPP=$CXXCPP
+
+fi
+  CXXCPP=$ac_cv_prog_CXXCPP
+else
+  ac_cv_prog_CXXCPP=$CXXCPP
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
+printf "%s\n" "$CXXCPP" >&6; }
+ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
+		     Syntax error
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"
+then :
+
+else $as_nop
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"
+then :
+  # Broken: success on invalid input.
+continue
+else $as_nop
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok
+then :
+
+else $as_nop
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+else
+  _lt_caught_CXX_error=yes
+fi
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+archive_cmds_need_lc_CXX=no
+allow_undefined_flag_CXX=
+always_export_symbols_CXX=no
+archive_expsym_cmds_CXX=
+compiler_needs_object_CXX=no
+export_dynamic_flag_spec_CXX=
+hardcode_direct_CXX=no
+hardcode_direct_absolute_CXX=no
+hardcode_libdir_flag_spec_CXX=
+hardcode_libdir_separator_CXX=
+hardcode_minus_L_CXX=no
+hardcode_shlibpath_var_CXX=unsupported
+hardcode_automatic_CXX=no
+inherit_rpath_CXX=no
+module_cmds_CXX=
+module_expsym_cmds_CXX=
+link_all_deplibs_CXX=unknown
+old_archive_cmds_CXX=$old_archive_cmds
+reload_flag_CXX=$reload_flag
+reload_cmds_CXX=$reload_cmds
+no_undefined_flag_CXX=
+whole_archive_flag_spec_CXX=
+enable_shared_with_static_runtimes_CXX=no
+
+# Source file extension for C++ test sources.
+ac_ext=cpp
+
+# Object file extension for compiled C++ test sources.
+objext=o
+objext_CXX=$objext
+
+# No sense in running all these tests if we already determined that
+# the CXX compiler isn't working.  Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test yes != "$_lt_caught_CXX_error"; then
+  # Code to be used in simple compile tests
+  lt_simple_compile_test_code="int some_variable = 0;"
+
+  # Code to be used in simple link tests
+  lt_simple_link_test_code='int main(int, char *[]) { return(0); }'
+
+  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+  # save warnings/boilerplate of simple test code
+  ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+  ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+  # Allow CC to be a program name with arguments.
+  lt_save_CC=$CC
+  lt_save_CFLAGS=$CFLAGS
+  lt_save_LD=$LD
+  lt_save_GCC=$GCC
+  GCC=$GXX
+  lt_save_with_gnu_ld=$with_gnu_ld
+  lt_save_path_LD=$lt_cv_path_LD
+  if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+    lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+  else
+    $as_unset lt_cv_prog_gnu_ld
+  fi
+  if test -n "${lt_cv_path_LDCXX+set}"; then
+    lt_cv_path_LD=$lt_cv_path_LDCXX
+  else
+    $as_unset lt_cv_path_LD
+  fi
+  test -z "${LDCXX+set}" || LD=$LDCXX
+  CC=${CXX-"c++"}
+  CFLAGS=$CXXFLAGS
+  compiler=$CC
+  compiler_CXX=$CC
+  func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
+
+
+  if test -n "$compiler"; then
+    # We don't want -fno-exception when compiling C++ code, so set the
+    # no_builtin_flag separately
+    if test yes = "$GXX"; then
+      lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin'
+    else
+      lt_prog_compiler_no_builtin_flag_CXX=
+    fi
+
+    if test yes = "$GXX"; then
+      # Set up default GNU C++ configuration
+
+
+
+# Check whether --with-gnu-ld was given.
+if test ${with_gnu_ld+y}
+then :
+  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
+else $as_nop
+  with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test yes = "$GCC"; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+printf %s "checking for ld used by $CC... " >&6; }
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return, which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [\\/]* | ?:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD=$ac_prog
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test yes = "$with_gnu_ld"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+printf %s "checking for GNU ld... " >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+printf %s "checking for non-GNU ld... " >&6; }
+fi
+if test ${lt_cv_path_LD+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if test -z "$LD"; then
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD=$ac_dir/$ac_prog
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test no != "$with_gnu_ld" && break
+	;;
+      *)
+	test yes != "$with_gnu_ld" && break
+	;;
+      esac
+    fi
+  done
+  IFS=$lt_save_ifs
+else
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
+fi
+fi
+
+LD=$lt_cv_path_LD
+if test -n "$LD"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+printf "%s\n" "$LD" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
+if test ${lt_cv_prog_gnu_ld+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+
+
+
+
+      # Check if GNU C++ uses GNU ld as the underlying linker, since the
+      # archiving commands below assume that GNU ld is being used.
+      if test yes = "$with_gnu_ld"; then
+        archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+        archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+
+        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+        export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+
+        # If archive_cmds runs LD, not CC, wlarc should be empty
+        # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+        #     investigate it a little bit more. (MM)
+        wlarc='$wl'
+
+        # ancient GNU ld didn't support --whole-archive et. al.
+        if eval "`$CC -print-prog-name=ld` --help 2>&1" |
+	  $GREP 'no-whole-archive' > /dev/null; then
+          whole_archive_flag_spec_CXX=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+        else
+          whole_archive_flag_spec_CXX=
+        fi
+      else
+        with_gnu_ld=no
+        wlarc=
+
+        # A generic and very simple default shared library creation
+        # command for GNU C++ for the case where it uses the native
+        # linker, instead of GNU ld.  If possible, this setting should
+        # overridden to take advantage of the native linker features on
+        # the platform it is being used on.
+        archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+      fi
+
+      # Commands to make compiler produce verbose output that lists
+      # what "hidden" libraries, object files and flags are used when
+      # linking a shared library.
+      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
+
+    else
+      GXX=no
+      with_gnu_ld=no
+      wlarc=
+    fi
+
+    # PORTME: fill in a description of your system's C++ link characteristics
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+    ld_shlibs_CXX=yes
+    case $host_os in
+      aix3*)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+        ;;
+      aix[4-9]*)
+        if test ia64 = "$host_cpu"; then
+          # On IA64, the linker does run time linking by default, so we don't
+          # have to do anything special.
+          aix_use_runtimelinking=no
+          exp_sym_flag='-Bexport'
+          no_entry_flag=
+        else
+          aix_use_runtimelinking=no
+
+          # Test if we are trying to use run time linking or normal
+          # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+          # have runtime linking enabled, and use it for executables.
+          # For shared libraries, we enable/disable runtime linking
+          # depending on the kind of the shared library created -
+          # when "with_aix_soname,aix_use_runtimelinking" is:
+          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "aix,yes"  lib.so          shared, rtl:yes, for executables
+          #            lib.a           static archive
+          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
+          #            lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a(lib.so.V) shared, rtl:no
+          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a           static archive
+          case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
+	    for ld_flag in $LDFLAGS; do
+	      case $ld_flag in
+	      *-brtl*)
+	        aix_use_runtimelinking=yes
+	        break
+	        ;;
+	      esac
+	    done
+	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	      # so we don't have lib.a shared libs to link our executables.
+	      # We have to force runtime linking in this case.
+	      aix_use_runtimelinking=yes
+	      LDFLAGS="$LDFLAGS -Wl,-brtl"
+	    fi
+	    ;;
+          esac
+
+          exp_sym_flag='-bexport'
+          no_entry_flag='-bnoentry'
+        fi
+
+        # When large executables or shared objects are built, AIX ld can
+        # have problems creating the table of contents.  If linking a library
+        # or program results in "error TOC overflow" add -mminimal-toc to
+        # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+        # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+        archive_cmds_CXX=''
+        hardcode_direct_CXX=yes
+        hardcode_direct_absolute_CXX=yes
+        hardcode_libdir_separator_CXX=':'
+        link_all_deplibs_CXX=yes
+        file_list_spec_CXX='$wl-f,'
+        case $with_aix_soname,$aix_use_runtimelinking in
+        aix,*) ;;	# no import file
+        svr4,* | *,yes) # use import file
+          # The Import File defines what to hardcode.
+          hardcode_direct_CXX=no
+          hardcode_direct_absolute_CXX=no
+          ;;
+        esac
+
+        if test yes = "$GXX"; then
+          case $host_os in aix4.[012]|aix4.[012].*)
+          # We only want to do this on AIX 4.2 and lower, the check
+          # below for broken collect2 doesn't work under 4.3+
+	  collect2name=`$CC -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+	    # We have reworked collect2
+	    :
+	  else
+	    # We have old collect2
+	    hardcode_direct_CXX=unsupported
+	    # It fails to find uninstalled libraries when the uninstalled
+	    # path is not listed in the libpath.  Setting hardcode_minus_L
+	    # to unsupported forces relinking
+	    hardcode_minus_L_CXX=yes
+	    hardcode_libdir_flag_spec_CXX='-L$libdir'
+	    hardcode_libdir_separator_CXX=
+	  fi
+          esac
+          shared_flag='-shared'
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag=$shared_flag' $wl-G'
+	  fi
+	  # Need to ensure runtime linking is disabled for the traditional
+	  # shared library, or the linker may eventually find shared libraries
+	  # /with/ Import File - we do not want to mix them.
+	  shared_flag_aix='-shared'
+	  shared_flag_svr4='-shared $wl-G'
+        else
+          # not using gcc
+          if test ia64 = "$host_cpu"; then
+	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	  # chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+          else
+	    if test yes = "$aix_use_runtimelinking"; then
+	      shared_flag='$wl-G'
+	    else
+	      shared_flag='$wl-bM:SRE'
+	    fi
+	    shared_flag_aix='$wl-bM:SRE'
+	    shared_flag_svr4='$wl-G'
+          fi
+        fi
+
+        export_dynamic_flag_spec_CXX='$wl-bexpall'
+        # It seems that -bexpall does not export symbols beginning with
+        # underscore (_), so it is better to generate a list of symbols to
+	# export.
+        always_export_symbols_CXX=yes
+	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
+          # Warning - without using the other runtime loading flags (-brtl),
+          # -berok will link without error, but may produce a broken library.
+          # The "-G" linker flag allows undefined symbols.
+          no_undefined_flag_CXX='-bernotok'
+          # Determine the default libpath from the value encoded in an empty
+          # executable.
+          if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if test ${lt_cv_aix_libpath__CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"
+then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *\([^ ]*\) *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath__CXX"; then
+    lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath__CXX"; then
+    lt_cv_aix_libpath__CXX=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath__CXX
+fi
+
+          hardcode_libdir_flag_spec_CXX='$wl-blibpath:$libdir:'"$aix_libpath"
+
+          archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
+        else
+          if test ia64 = "$host_cpu"; then
+	    hardcode_libdir_flag_spec_CXX='$wl-R $libdir:/usr/lib:/lib'
+	    allow_undefined_flag_CXX="-z nodefs"
+	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
+          else
+	    # Determine the default libpath from the value encoded in an
+	    # empty executable.
+	    if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if test ${lt_cv_aix_libpath__CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"
+then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *\([^ ]*\) *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath__CXX"; then
+    lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath__CXX"; then
+    lt_cv_aix_libpath__CXX=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath__CXX
+fi
+
+	    hardcode_libdir_flag_spec_CXX='$wl-blibpath:$libdir:'"$aix_libpath"
+	    # Warning - without using the other run time loading flags,
+	    # -berok will link without error, but may produce a broken library.
+	    no_undefined_flag_CXX=' $wl-bernotok'
+	    allow_undefined_flag_CXX=' $wl-berok'
+	    if test yes = "$with_gnu_ld"; then
+	      # We only use this code for GNU lds that support --whole-archive.
+	      whole_archive_flag_spec_CXX='$wl--whole-archive$convenience $wl--no-whole-archive'
+	    else
+	      # Exported symbols can be pulled into shared objects from archives
+	      whole_archive_flag_spec_CXX='$convenience'
+	    fi
+	    archive_cmds_need_lc_CXX=yes
+	    archive_expsym_cmds_CXX='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	    # -brtl affects multiple linker settings, -berok does not and is overridden later
+	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`'
+	    if test svr4 != "$with_aix_soname"; then
+	      # This is similar to how AIX traditionally builds its shared
+	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	    fi
+	    if test aix != "$with_aix_soname"; then
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	    else
+	      # used by -dlpreopen to get the symbols
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	    fi
+	    archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$RM -r $output_objdir/$realname.d'
+          fi
+        fi
+        ;;
+
+      beos*)
+	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	  allow_undefined_flag_CXX=unsupported
+	  # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	  # support --undefined.  This deserves some investigation.  FIXME
+	  archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	else
+	  ld_shlibs_CXX=no
+	fi
+	;;
+
+      chorus*)
+        case $cc_basename in
+          *)
+	  # FIXME: insert proper C++ library support
+	  ld_shlibs_CXX=no
+	  ;;
+        esac
+        ;;
+
+      cygwin* | mingw* | pw32* | cegcc*)
+	case $GXX,$cc_basename in
+	,cl* | no,cl*)
+	  # Native MSVC
+	  # hardcode_libdir_flag_spec is actually meaningless, as there is
+	  # no search path for DLLs.
+	  hardcode_libdir_flag_spec_CXX=' '
+	  allow_undefined_flag_CXX=unsupported
+	  always_export_symbols_CXX=yes
+	  file_list_spec_CXX='@'
+	  # Tell ltmain to make .lib files, not .a files.
+	  libext=lib
+	  # Tell ltmain to make .dll files, not .so files.
+	  shrext_cmds=.dll
+	  # FIXME: Setting linknames here is a bad hack.
+	  archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	  archive_expsym_cmds_CXX='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+              cp "$export_symbols" "$output_objdir/$soname.def";
+              echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+            else
+              $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+            fi~
+            $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+            linknames='
+	  # The linker will not automatically build a static lib if we build a DLL.
+	  # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true'
+	  enable_shared_with_static_runtimes_CXX=yes
+	  # Don't use ranlib
+	  old_postinstall_cmds_CXX='chmod 644 $oldlib'
+	  postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~
+            lt_tool_outputfile="@TOOL_OUTPUT@"~
+            case $lt_outputfile in
+              *.exe|*.EXE) ;;
+              *)
+                lt_outputfile=$lt_outputfile.exe
+                lt_tool_outputfile=$lt_tool_outputfile.exe
+                ;;
+            esac~
+            func_to_tool_file "$lt_outputfile"~
+            if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+              $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+              $RM "$lt_outputfile.manifest";
+            fi'
+	  ;;
+	*)
+	  # g++
+	  # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless,
+	  # as there is no search path for DLLs.
+	  hardcode_libdir_flag_spec_CXX='-L$libdir'
+	  export_dynamic_flag_spec_CXX='$wl--export-all-symbols'
+	  allow_undefined_flag_CXX=unsupported
+	  always_export_symbols_CXX=no
+	  enable_shared_with_static_runtimes_CXX=yes
+
+	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	    # If the export-symbols file already is a .def file, use it as
+	    # is; otherwise, prepend EXPORTS...
+	    archive_expsym_cmds_CXX='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
+              cp $export_symbols $output_objdir/$soname.def;
+            else
+              echo EXPORTS > $output_objdir/$soname.def;
+              cat $export_symbols >> $output_objdir/$soname.def;
+            fi~
+            $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	  else
+	    ld_shlibs_CXX=no
+	  fi
+	  ;;
+	esac
+	;;
+      darwin* | rhapsody*)
+
+
+  archive_cmds_need_lc_CXX=no
+  hardcode_direct_CXX=no
+  hardcode_automatic_CXX=yes
+  hardcode_shlibpath_var_CXX=unsupported
+  if test yes = "$lt_cv_ld_force_load"; then
+    whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+
+  else
+    whole_archive_flag_spec_CXX=''
+  fi
+  link_all_deplibs_CXX=yes
+  allow_undefined_flag_CXX=$_lt_dar_allow_undefined
+  case $cc_basename in
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
+     *) _lt_dar_can_shared=$GCC ;;
+  esac
+  if test yes = "$_lt_dar_can_shared"; then
+    output_verbose_link_cmd=func_echo_all
+    archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds_CXX="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+       if test yes != "$lt_cv_apple_cc_single_mod"; then
+      archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
+      archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
+    fi
+
+  else
+  ld_shlibs_CXX=no
+  fi
+
+	;;
+
+      os2*)
+	hardcode_libdir_flag_spec_CXX='-L$libdir'
+	hardcode_minus_L_CXX=yes
+	allow_undefined_flag_CXX=unsupported
+	shrext_cmds=.dll
+	archive_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	archive_expsym_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  prefix_cmds="$SED"~
+	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	    prefix_cmds="$prefix_cmds -e 1d";
+	  fi~
+	  prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
+	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	old_archive_From_new_cmds_CXX='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+	enable_shared_with_static_runtimes_CXX=yes
+	;;
+
+      dgux*)
+        case $cc_basename in
+          ec++*)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          ghcx*)
+	    # Green Hills C++ Compiler
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+        esac
+        ;;
+
+      freebsd2.*)
+        # C++ shared libraries reported to be fairly broken before
+	# switch to ELF
+        ld_shlibs_CXX=no
+        ;;
+
+      freebsd-elf*)
+        archive_cmds_need_lc_CXX=no
+        ;;
+
+      freebsd* | dragonfly*)
+        # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+        # conventions
+        ld_shlibs_CXX=yes
+        ;;
+
+      haiku*)
+        archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+        link_all_deplibs_CXX=yes
+        ;;
+
+      hpux9*)
+        hardcode_libdir_flag_spec_CXX='$wl+b $wl$libdir'
+        hardcode_libdir_separator_CXX=:
+        export_dynamic_flag_spec_CXX='$wl-E'
+        hardcode_direct_CXX=yes
+        hardcode_minus_L_CXX=yes # Not in the search PATH,
+				             # but as the default
+				             # location of the library.
+
+        case $cc_basename in
+          CC*)
+            # FIXME: insert proper C++ library support
+            ld_shlibs_CXX=no
+            ;;
+          aCC*)
+            archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+            # Commands to make compiler produce verbose output that lists
+            # what "hidden" libraries, object files and flags are used when
+            # linking a shared library.
+            #
+            # There doesn't appear to be a way to prevent this compiler from
+            # explicitly linking system object files so we need to strip them
+            # from the output so that they don't get included in the library
+            # dependencies.
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+            ;;
+          *)
+            if test yes = "$GXX"; then
+              archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+            else
+              # FIXME: insert proper C++ library support
+              ld_shlibs_CXX=no
+            fi
+            ;;
+        esac
+        ;;
+
+      hpux10*|hpux11*)
+        if test no = "$with_gnu_ld"; then
+	  hardcode_libdir_flag_spec_CXX='$wl+b $wl$libdir'
+	  hardcode_libdir_separator_CXX=:
+
+          case $host_cpu in
+            hppa*64*|ia64*)
+              ;;
+            *)
+	      export_dynamic_flag_spec_CXX='$wl-E'
+              ;;
+          esac
+        fi
+        case $host_cpu in
+          hppa*64*|ia64*)
+            hardcode_direct_CXX=no
+            hardcode_shlibpath_var_CXX=no
+            ;;
+          *)
+            hardcode_direct_CXX=yes
+            hardcode_direct_absolute_CXX=yes
+            hardcode_minus_L_CXX=yes # Not in the search PATH,
+					         # but as the default
+					         # location of the library.
+            ;;
+        esac
+
+        case $cc_basename in
+          CC*)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          aCC*)
+	    case $host_cpu in
+	      hppa*64*)
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	      ia64*)
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	      *)
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	    esac
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    ;;
+          *)
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
+	        case $host_cpu in
+	          hppa*64*)
+	            archive_cmds_CXX='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	          ia64*)
+	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	          *)
+	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	        esac
+	      fi
+	    else
+	      # FIXME: insert proper C++ library support
+	      ld_shlibs_CXX=no
+	    fi
+	    ;;
+        esac
+        ;;
+
+      interix[3-9]*)
+	hardcode_direct_CXX=no
+	hardcode_shlibpath_var_CXX=no
+	hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	export_dynamic_flag_spec_CXX='$wl-E'
+	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+	# Instead, shared libraries are loaded at an image base (0x10000000 by
+	# default) and relocated if they conflict, which is a slow very memory
+	# consuming and fragmenting process.  To avoid this, we pick a random,
+	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+	archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	archive_expsym_cmds_CXX='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	;;
+      irix5* | irix6*)
+        case $cc_basename in
+          CC*)
+	    # SGI C++
+	    archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
+	    # necessary to make sure instantiated templates are included
+	    # in the archive.
+	    old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs'
+	    ;;
+          *)
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	      else
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
+	      fi
+	    fi
+	    link_all_deplibs_CXX=yes
+	    ;;
+        esac
+        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+        hardcode_libdir_separator_CXX=:
+        inherit_rpath_CXX=yes
+        ;;
+
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+        case $cc_basename in
+          KCC*)
+	    # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	    # KCC will only create a shared library if the output file
+	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
+	    # to its proper name (with version) after linking.
+	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	    archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib'
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
+	    old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'
+	    ;;
+	  icpc* | ecpc* )
+	    # Intel C++
+	    with_gnu_ld=yes
+	    # version 8.0 and above of icpc choke on multiply defined symbols
+	    # if we add $predep_objects and $postdep_objects, however 7.1 and
+	    # earlier do not add the objects themselves.
+	    case `$CC -V 2>&1` in
+	      *"Version 7."*)
+	        archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+		archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+		;;
+	      *)  # Version 8.0 or newer
+	        tmp_idyn=
+	        case $host_cpu in
+		  ia64*) tmp_idyn=' -i_dynamic';;
+		esac
+	        archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+		archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+		;;
+	    esac
+	    archive_cmds_need_lc_CXX=no
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    whole_archive_flag_spec_CXX='$wl--whole-archive$convenience $wl--no-whole-archive'
+	    ;;
+          pgCC* | pgcpp*)
+            # Portland Group C++ compiler
+	    case `$CC -V` in
+	    *pgCC\ [1-5].* | *pgcpp\ [1-5].*)
+	      prelink_cmds_CXX='tpldir=Template.dir~
+               rm -rf $tpldir~
+               $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+               compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+	      old_archive_cmds_CXX='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+                $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+                $RANLIB $oldlib'
+	      archive_cmds_CXX='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	      ;;
+	    *) # Version 6 and above use weak symbols
+	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	      archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	      ;;
+	    esac
+
+	    hardcode_libdir_flag_spec_CXX='$wl--rpath $wl$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    whole_archive_flag_spec_CXX='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+            ;;
+	  cxx*)
+	    # Compaq C++
+	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	    archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname  -o $lib $wl-retain-symbols-file $wl$export_symbols'
+
+	    runpath_var=LD_RUN_PATH
+	    hardcode_libdir_flag_spec_CXX='-rpath $libdir'
+	    hardcode_libdir_separator_CXX=:
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
+	    ;;
+	  xl* | mpixl* | bgxl*)
+	    # IBM XL 8.0 on PPC, with GNU ld
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    if test yes = "$supports_anon_versioning"; then
+	      archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~
+                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+                echo "local: *; };" >> $output_objdir/$libname.ver~
+                $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
+	    fi
+	    ;;
+	  *)
+	    case `$CC -V 2>&1 | sed 5q` in
+	    *Sun\ C*)
+	      # Sun C++ 5.9
+	      no_undefined_flag_CXX=' -zdefs'
+	      archive_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      archive_expsym_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols'
+	      hardcode_libdir_flag_spec_CXX='-R$libdir'
+	      whole_archive_flag_spec_CXX='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	      compiler_needs_object_CXX=yes
+
+	      # Not sure whether something based on
+	      # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
+	      # would be better.
+	      output_verbose_link_cmd='func_echo_all'
+
+	      # Archives containing C++ object files must be created using
+	      # "CC -xar", where "CC" is the Sun C++ compiler.  This is
+	      # necessary to make sure instantiated templates are included
+	      # in the archive.
+	      old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
+	      ;;
+	    esac
+	    ;;
+	esac
+	;;
+
+      lynxos*)
+        # FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+
+      m88k*)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+	;;
+
+      mvs*)
+        case $cc_basename in
+          cxx*)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+	  *)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+	esac
+	;;
+
+      netbsd*)
+        if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	  archive_cmds_CXX='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+	  wlarc=
+	  hardcode_libdir_flag_spec_CXX='-R$libdir'
+	  hardcode_direct_CXX=yes
+	  hardcode_shlibpath_var_CXX=no
+	fi
+	# Workaround some broken pre-1.5 toolchains
+	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+	;;
+
+      *nto* | *qnx*)
+        ld_shlibs_CXX=yes
+	;;
+
+      openbsd* | bitrig*)
+	if test -f /usr/libexec/ld.so; then
+	  hardcode_direct_CXX=yes
+	  hardcode_shlibpath_var_CXX=no
+	  hardcode_direct_absolute_CXX=yes
+	  archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+	  hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then
+	    archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib'
+	    export_dynamic_flag_spec_CXX='$wl-E'
+	    whole_archive_flag_spec_CXX=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+	  fi
+	  output_verbose_link_cmd=func_echo_all
+	else
+	  ld_shlibs_CXX=no
+	fi
+	;;
+
+      osf3* | osf4* | osf5*)
+        case $cc_basename in
+          KCC*)
+	    # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	    # KCC will only create a shared library if the output file
+	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
+	    # to its proper name (with version) after linking.
+	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	    hardcode_libdir_separator_CXX=:
+
+	    # Archives containing C++ object files must be created using
+	    # the KAI C++ compiler.
+	    case $host in
+	      osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;;
+	      *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;;
+	    esac
+	    ;;
+          RCC*)
+	    # Rational C++ 2.4.1
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          cxx*)
+	    case $host in
+	      osf3*)
+	        allow_undefined_flag_CXX=' $wl-expect_unresolved $wl\*'
+	        archive_cmds_CXX='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+		;;
+	      *)
+	        allow_undefined_flag_CXX=' -expect_unresolved \*'
+	        archive_cmds_CXX='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	        archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+                  echo "-hidden">> $lib.exp~
+                  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
+                  $RM $lib.exp'
+	        hardcode_libdir_flag_spec_CXX='-rpath $libdir'
+		;;
+	    esac
+
+	    hardcode_libdir_separator_CXX=:
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    ;;
+	  *)
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      allow_undefined_flag_CXX=' $wl-expect_unresolved $wl\*'
+	      case $host in
+	        osf3*)
+	          archive_cmds_CXX='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+		  ;;
+	        *)
+	          archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+		  ;;
+	      esac
+
+	      hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+	      hardcode_libdir_separator_CXX=:
+
+	      # Commands to make compiler produce verbose output that lists
+	      # what "hidden" libraries, object files and flags are used when
+	      # linking a shared library.
+	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
+
+	    else
+	      # FIXME: insert proper C++ library support
+	      ld_shlibs_CXX=no
+	    fi
+	    ;;
+        esac
+        ;;
+
+      psos*)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+        ;;
+
+      sunos4*)
+        case $cc_basename in
+          CC*)
+	    # Sun C++ 4.x
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          lcc*)
+	    # Lucid
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+        esac
+        ;;
+
+      solaris*)
+        case $cc_basename in
+          CC* | sunCC*)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+            archive_cmds_need_lc_CXX=yes
+	    no_undefined_flag_CXX=' -zdefs'
+	    archive_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	    archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+              $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	    hardcode_libdir_flag_spec_CXX='-R$libdir'
+	    hardcode_shlibpath_var_CXX=no
+	    case $host_os in
+	      solaris2.[0-5] | solaris2.[0-5].*) ;;
+	      *)
+		# The compiler driver will combine and reorder linker options,
+		# but understands '-z linker_flag'.
+	        # Supported since Solaris 2.6 (maybe 2.5.1?)
+		whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract'
+	        ;;
+	    esac
+	    link_all_deplibs_CXX=yes
+
+	    output_verbose_link_cmd='func_echo_all'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -xar", where "CC" is the Sun C++ compiler.  This is
+	    # necessary to make sure instantiated templates are included
+	    # in the archive.
+	    old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
+	    ;;
+          gcx*)
+	    # Green Hills C++ Compiler
+	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+
+	    # The C++ compiler must be used to create the archive.
+	    old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+	    ;;
+          *)
+	    # GNU C++ compiler with Solaris linker
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      no_undefined_flag_CXX=' $wl-z ${wl}defs'
+	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+                  $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	        # Commands to make compiler produce verbose output that lists
+	        # what "hidden" libraries, object files and flags are used when
+	        # linking a shared library.
+	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
+	      else
+	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
+	        # platform.
+	        archive_cmds_CXX='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+                  $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	        # Commands to make compiler produce verbose output that lists
+	        # what "hidden" libraries, object files and flags are used when
+	        # linking a shared library.
+	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
+	      fi
+
+	      hardcode_libdir_flag_spec_CXX='$wl-R $wl$libdir'
+	      case $host_os in
+		solaris2.[0-5] | solaris2.[0-5].*) ;;
+		*)
+		  whole_archive_flag_spec_CXX='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
+		  ;;
+	      esac
+	    fi
+	    ;;
+        esac
+        ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+      no_undefined_flag_CXX='$wl-z,text'
+      archive_cmds_need_lc_CXX=no
+      hardcode_shlibpath_var_CXX=no
+      runpath_var='LD_RUN_PATH'
+
+      case $cc_basename in
+        CC*)
+	  archive_cmds_CXX='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds_CXX='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds_CXX='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds_CXX='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+      esac
+      ;;
+
+      sysv5* | sco3.2v5* | sco5v6*)
+	# Note: We CANNOT use -z defs as we might desire, because we do not
+	# link with -lc, and that would cause any symbols used from libc to
+	# always be unresolved, which means just about no library would
+	# ever link correctly.  If we're not using GNU ld we use -z text
+	# though, which does catch some bad symbols but isn't as heavy-handed
+	# as -z defs.
+	no_undefined_flag_CXX='$wl-z,text'
+	allow_undefined_flag_CXX='$wl-z,nodefs'
+	archive_cmds_need_lc_CXX=no
+	hardcode_shlibpath_var_CXX=no
+	hardcode_libdir_flag_spec_CXX='$wl-R,$libdir'
+	hardcode_libdir_separator_CXX=':'
+	link_all_deplibs_CXX=yes
+	export_dynamic_flag_spec_CXX='$wl-Bexport'
+	runpath_var='LD_RUN_PATH'
+
+	case $cc_basename in
+          CC*)
+	    archive_cmds_CXX='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    archive_expsym_cmds_CXX='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~
+              '"$old_archive_cmds_CXX"
+	    reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~
+              '"$reload_cmds_CXX"
+	    ;;
+	  *)
+	    archive_cmds_CXX='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    archive_expsym_cmds_CXX='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    ;;
+	esac
+      ;;
+
+      tandem*)
+        case $cc_basename in
+          NCC*)
+	    # NonStop-UX NCC 3.20
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+        esac
+        ;;
+
+      vxworks*)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+        ;;
+
+      *)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+        ;;
+    esac
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
+printf "%s\n" "$ld_shlibs_CXX" >&6; }
+    test no = "$ld_shlibs_CXX" && can_build_shared=no
+
+    GCC_CXX=$GXX
+    LD_CXX=$LD
+
+    ## CAVEAT EMPTOR:
+    ## There is no encapsulation within the following macros, do not change
+    ## the running order or otherwise move them around unless you know exactly
+    ## what you are doing...
+    # Dependencies to place before and after the object being linked:
+predep_objects_CXX=
+postdep_objects_CXX=
+predeps_CXX=
+postdeps_CXX=
+compiler_lib_search_path_CXX=
+
+cat > conftest.$ac_ext <<_LT_EOF
+class Foo
+{
+public:
+  Foo (void) { a = 0; }
+private:
+  int a;
+};
+_LT_EOF
+
+
+_lt_libdeps_save_CFLAGS=$CFLAGS
+case "$CC $CFLAGS " in #(
+*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
+*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
+*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
+esac
+
+if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  # Parse the compiler output and extract the necessary
+  # objects, libraries and library flags.
+
+  # Sentinel used to keep track of whether or not we are before
+  # the conftest object file.
+  pre_test_object_deps_done=no
+
+  for p in `eval "$output_verbose_link_cmd"`; do
+    case $prev$p in
+
+    -L* | -R* | -l*)
+       # Some compilers place space between "-{L,R}" and the path.
+       # Remove the space.
+       if test x-L = "$p" ||
+          test x-R = "$p"; then
+	 prev=$p
+	 continue
+       fi
+
+       # Expand the sysroot to ease extracting the directories later.
+       if test -z "$prev"; then
+         case $p in
+         -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
+         -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
+         -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
+         esac
+       fi
+       case $p in
+       =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
+       esac
+       if test no = "$pre_test_object_deps_done"; then
+	 case $prev in
+	 -L | -R)
+	   # Internal compiler library paths should come after those
+	   # provided the user.  The postdeps already come after the
+	   # user supplied libs so there is no need to process them.
+	   if test -z "$compiler_lib_search_path_CXX"; then
+	     compiler_lib_search_path_CXX=$prev$p
+	   else
+	     compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} $prev$p"
+	   fi
+	   ;;
+	 # The "-l" case would never come before the object being
+	 # linked, so don't bother handling this case.
+	 esac
+       else
+	 if test -z "$postdeps_CXX"; then
+	   postdeps_CXX=$prev$p
+	 else
+	   postdeps_CXX="${postdeps_CXX} $prev$p"
+	 fi
+       fi
+       prev=
+       ;;
+
+    *.lto.$objext) ;; # Ignore GCC LTO objects
+    *.$objext)
+       # This assumes that the test object file only shows up
+       # once in the compiler output.
+       if test "$p" = "conftest.$objext"; then
+	 pre_test_object_deps_done=yes
+	 continue
+       fi
+
+       if test no = "$pre_test_object_deps_done"; then
+	 if test -z "$predep_objects_CXX"; then
+	   predep_objects_CXX=$p
+	 else
+	   predep_objects_CXX="$predep_objects_CXX $p"
+	 fi
+       else
+	 if test -z "$postdep_objects_CXX"; then
+	   postdep_objects_CXX=$p
+	 else
+	   postdep_objects_CXX="$postdep_objects_CXX $p"
+	 fi
+       fi
+       ;;
+
+    *) ;; # Ignore the rest.
+
+    esac
+  done
+
+  # Clean up.
+  rm -f a.out a.exe
+else
+  echo "libtool.m4: error: problem compiling CXX test program"
+fi
+
+$RM -f confest.$objext
+CFLAGS=$_lt_libdeps_save_CFLAGS
+
+# PORTME: override above test on systems where it is broken
+case $host_os in
+interix[3-9]*)
+  # Interix 3.5 installs completely hosed .la files for C++, so rather than
+  # hack all around it, let's just trust "g++" to DTRT.
+  predep_objects_CXX=
+  postdep_objects_CXX=
+  postdeps_CXX=
+  ;;
+esac
+
+
+case " $postdeps_CXX " in
+*" -lc "*) archive_cmds_need_lc_CXX=no ;;
+esac
+ compiler_lib_search_dirs_CXX=
+if test -n "${compiler_lib_search_path_CXX}"; then
+ compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | $SED -e 's! -L! !g' -e 's!^ !!'`
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    lt_prog_compiler_wl_CXX=
+lt_prog_compiler_pic_CXX=
+lt_prog_compiler_static_CXX=
+
+
+  # C++ specific cases for pic, static, wl, etc.
+  if test yes = "$GXX"; then
+    lt_prog_compiler_wl_CXX='-Wl,'
+    lt_prog_compiler_static_CXX='-static'
+
+    case $host_os in
+    aix*)
+      # All AIX code is PIC.
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static_CXX='-Bstatic'
+      fi
+      lt_prog_compiler_pic_CXX='-fPIC'
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            lt_prog_compiler_pic_CXX='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
+            lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+    mingw* | cygwin* | os2* | pw32* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static_CXX='$wl-static'
+	;;
+      esac
+      ;;
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic_CXX='-fno-common'
+      ;;
+    *djgpp*)
+      # DJGPP does not support shared libraries at all
+      lt_prog_compiler_pic_CXX=
+      ;;
+    haiku*)
+      # PIC is the default for Haiku.
+      # The "-static" flag exists, but is broken.
+      lt_prog_compiler_static_CXX=
+      ;;
+    interix[3-9]*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic_CXX=-Kconform_pic
+      fi
+      ;;
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+	;;
+      *)
+	lt_prog_compiler_pic_CXX='-fPIC'
+	;;
+      esac
+      ;;
+    *qnx* | *nto*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic_CXX='-fPIC -shared'
+      ;;
+    *)
+      lt_prog_compiler_pic_CXX='-fPIC'
+      ;;
+    esac
+  else
+    case $host_os in
+      aix[4-9]*)
+	# All AIX code is PIC.
+	if test ia64 = "$host_cpu"; then
+	  # AIX 5 now supports IA64 processor
+	  lt_prog_compiler_static_CXX='-Bstatic'
+	else
+	  lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp'
+	fi
+	;;
+      chorus*)
+	case $cc_basename in
+	cxch68*)
+	  # Green Hills C++ Compiler
+	  # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+	  ;;
+	esac
+	;;
+      mingw* | cygwin* | os2* | pw32* | cegcc*)
+	# This hack is so that the source file can tell whether it is being
+	# built for inclusion in a dll (and should export symbols for example).
+	lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+	;;
+      dgux*)
+	case $cc_basename in
+	  ec++*)
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    ;;
+	  ghcx*)
+	    # Green Hills C++ Compiler
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      freebsd* | dragonfly*)
+	# FreeBSD uses GNU C++
+	;;
+      hpux9* | hpux10* | hpux11*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='$wl-a ${wl}archive'
+	    if test ia64 != "$host_cpu"; then
+	      lt_prog_compiler_pic_CXX='+Z'
+	    fi
+	    ;;
+	  aCC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='$wl-a ${wl}archive'
+	    case $host_cpu in
+	    hppa*64*|ia64*)
+	      # +Z the default
+	      ;;
+	    *)
+	      lt_prog_compiler_pic_CXX='+Z'
+	      ;;
+	    esac
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      interix*)
+	# This is c89, which is MS Visual C++ (no shared libs)
+	# Anyone wants to do a port?
+	;;
+      irix5* | irix6* | nonstopux*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    # CC pic flag -KPIC is the default.
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+	case $cc_basename in
+	  KCC*)
+	    # KAI C++ Compiler
+	    lt_prog_compiler_wl_CXX='--backend -Wl,'
+	    lt_prog_compiler_pic_CXX='-fPIC'
+	    ;;
+	  ecpc* )
+	    # old Intel C++ for x86_64, which still supported -KPIC.
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-static'
+	    ;;
+	  icpc* )
+	    # Intel C++, used to be incompatible with GCC.
+	    # ICC 10 doesn't accept -KPIC any more.
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-fPIC'
+	    lt_prog_compiler_static_CXX='-static'
+	    ;;
+	  pgCC* | pgcpp*)
+	    # Portland Group C++ compiler
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-fpic'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	  cxx*)
+	    # Compaq C++
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    lt_prog_compiler_pic_CXX=
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    ;;
+	  xlc* | xlC* | bgxl[cC]* | mpixl[cC]*)
+	    # IBM XL 8.0, 9.0 on PPC and BlueGene
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-qpic'
+	    lt_prog_compiler_static_CXX='-qstaticlink'
+	    ;;
+	  *)
+	    case `$CC -V 2>&1 | sed 5q` in
+	    *Sun\ C*)
+	      # Sun C++ 5.9
+	      lt_prog_compiler_pic_CXX='-KPIC'
+	      lt_prog_compiler_static_CXX='-Bstatic'
+	      lt_prog_compiler_wl_CXX='-Qoption ld '
+	      ;;
+	    esac
+	    ;;
+	esac
+	;;
+      lynxos*)
+	;;
+      m88k*)
+	;;
+      mvs*)
+	case $cc_basename in
+	  cxx*)
+	    lt_prog_compiler_pic_CXX='-W c,exportall'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      netbsd* | netbsdelf*-gnu)
+	;;
+      *qnx* | *nto*)
+        # QNX uses GNU C++, but need to define -shared option too, otherwise
+        # it will coredump.
+        lt_prog_compiler_pic_CXX='-fPIC -shared'
+        ;;
+      osf3* | osf4* | osf5*)
+	case $cc_basename in
+	  KCC*)
+	    lt_prog_compiler_wl_CXX='--backend -Wl,'
+	    ;;
+	  RCC*)
+	    # Rational C++ 2.4.1
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  cxx*)
+	    # Digital/Compaq C++
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    lt_prog_compiler_pic_CXX=
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      psos*)
+	;;
+      solaris*)
+	case $cc_basename in
+	  CC* | sunCC*)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    lt_prog_compiler_wl_CXX='-Qoption ld '
+	    ;;
+	  gcx*)
+	    # Green Hills C++ Compiler
+	    lt_prog_compiler_pic_CXX='-PIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sunos4*)
+	case $cc_basename in
+	  CC*)
+	    # Sun C++ 4.x
+	    lt_prog_compiler_pic_CXX='-pic'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	  lcc*)
+	    # Lucid
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	esac
+	;;
+      tandem*)
+	case $cc_basename in
+	  NCC*)
+	    # NonStop-UX NCC 3.20
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      vxworks*)
+	;;
+      *)
+	lt_prog_compiler_can_build_shared_CXX=no
+	;;
+    esac
+  fi
+
+case $host_os in
+  # For platforms that do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic_CXX=
+    ;;
+  *)
+    lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC"
+    ;;
+esac
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+printf %s "checking for $compiler option to produce PIC... " >&6; }
+if test ${lt_cv_prog_compiler_pic_CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5
+printf "%s\n" "$lt_cv_prog_compiler_pic_CXX" >&6; }
+lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic_CXX"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5
+printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; }
+if test ${lt_cv_prog_compiler_pic_works_CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_pic_works_CXX=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_pic_works_CXX=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5
+printf "%s\n" "$lt_cv_prog_compiler_pic_works_CXX" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_pic_works_CXX"; then
+    case $lt_prog_compiler_pic_CXX in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;;
+     esac
+else
+    lt_prog_compiler_pic_CXX=
+     lt_prog_compiler_can_build_shared_CXX=no
+fi
+
+fi
+
+
+
+
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\"
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
+if test ${lt_cv_prog_compiler_static_works_CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_static_works_CXX=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler_static_works_CXX=yes
+       fi
+     else
+       lt_cv_prog_compiler_static_works_CXX=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5
+printf "%s\n" "$lt_cv_prog_compiler_static_works_CXX" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_static_works_CXX"; then
+    :
+else
+    lt_prog_compiler_static_CXX=
+fi
+
+
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if test ${lt_cv_prog_compiler_c_o_CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_c_o_CXX=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o_CXX=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
+printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; }
+
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if test ${lt_cv_prog_compiler_c_o_CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_prog_compiler_c_o_CXX=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o_CXX=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
+printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; }
+
+
+
+
+hard_links=nottested
+if test no = "$lt_cv_prog_compiler_c_o_CXX" && test no != "$need_locks"; then
+  # do not overwrite the value of need_locks provided by the user
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+printf %s "checking if we can lock with hard links... " >&6; }
+  hard_links=yes
+  $RM conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+printf "%s\n" "$hard_links" >&6; }
+  if test no = "$hard_links"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
+printf "%s\n" "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+
+  export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
+  case $host_os in
+  aix[4-9]*)
+    # If we're using GNU nm, then we don't want the "-C" option.
+    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
+    # Without the "-l" option, or with the "-B" option, AIX nm treats
+    # weak defined symbols like other global defined symbols, whereas
+    # GNU nm marks them as "W".
+    # While the 'weak' keyword is ignored in the Export File, we need
+    # it in the Import File for the 'aix-soname' feature, so we have
+    # to replace the "-B" option with "-P" for AIX nm.
+    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
+    else
+      export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+    fi
+    ;;
+  pw32*)
+    export_symbols_cmds_CXX=$ltdll_cmds
+    ;;
+  cygwin* | mingw* | cegcc*)
+    case $cc_basename in
+    cl*)
+      exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+      ;;
+    *)
+      export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
+      exclude_expsyms_CXX='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
+      ;;
+    esac
+    ;;
+  linux* | k*bsd*-gnu | gnu*)
+    link_all_deplibs_CXX=no
+    ;;
+  *)
+    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+    ;;
+  esac
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
+printf "%s\n" "$ld_shlibs_CXX" >&6; }
+test no = "$ld_shlibs_CXX" && can_build_shared=no
+
+with_gnu_ld_CXX=$with_gnu_ld
+
+
+
+
+
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc_CXX" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc_CXX=yes
+
+  if test yes,yes = "$GCC,$enable_shared"; then
+    case $archive_cmds_CXX in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+printf %s "checking whether -lc should be explicitly linked in... " >&6; }
+if test ${lt_cv_archive_cmds_need_lc_CXX+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  $RM conftest*
+	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } 2>conftest.err; then
+	  soname=conftest
+	  lib=conftest
+	  libobjs=conftest.$ac_objext
+	  deplibs=
+	  wl=$lt_prog_compiler_wl_CXX
+	  pic_flag=$lt_prog_compiler_pic_CXX
+	  compiler_flags=-v
+	  linker_flags=-v
+	  verstring=
+	  output_objdir=.
+	  libname=conftest
+	  lt_save_allow_undefined_flag=$allow_undefined_flag_CXX
+	  allow_undefined_flag_CXX=
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
+  (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	  then
+	    lt_cv_archive_cmds_need_lc_CXX=no
+	  else
+	    lt_cv_archive_cmds_need_lc_CXX=yes
+	  fi
+	  allow_undefined_flag_CXX=$lt_save_allow_undefined_flag
+	else
+	  cat conftest.err 1>&5
+	fi
+	$RM conftest*
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5
+printf "%s\n" "$lt_cv_archive_cmds_need_lc_CXX" >&6; }
+      archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+printf %s "checking dynamic linker characteristics... " >&6; }
+
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=.so
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+
+
+case $host_os in
+aix3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='$libname$release$shared_ext$major'
+  ;;
+
+aix[4-9]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test ia64 = "$host_cpu"; then
+    # AIX 5 supports IA64
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[01] | aix4.[01].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  case $host_cpu in
+  powerpc)
+    # Since July 2007 AmigaOS4 officially supports .so libraries.
+    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    ;;
+  m68k)
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    ;;
+  esac
+  ;;
+
+beos*)
+  library_names_spec='$libname$shared_ext'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[45]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$cc_basename in
+  yes,*)
+    # gcc
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname~
+      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+      fi'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+
+      ;;
+    mingw* | cegcc*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      ;;
+    esac
+    dynamic_linker='Win32 ld.exe'
+    ;;
+
+  *,cl*)
+    # Native MSVC
+    libname_spec='$name'
+    soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
+
+    case $build_os in
+    mingw*)
+      sys_lib_search_path_spec=
+      lt_save_ifs=$IFS
+      IFS=';'
+      for lt_path in $LIB
+      do
+        IFS=$lt_save_ifs
+        # Let DOS variable expansion print the short 8.3 style file name.
+        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+      done
+      IFS=$lt_save_ifs
+      # Convert to MSYS style.
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
+      ;;
+    cygwin*)
+      # Convert to unix form, then to dos form, then back to unix form
+      # but this time dos style (no spaces!) so that the unix form looks
+      # like /cygdrive/c/PROGRA~1:/cygdr...
+      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      ;;
+    *)
+      sys_lib_search_path_spec=$LIB
+      if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
+        # It is most probably a Windows format PATH.
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      # FIXME: find the short name or the path components, as spaces are
+      # common. (e.g. "Program Files" -> "PROGRA~1")
+      ;;
+    esac
+
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+    dynamic_linker='Win32 link.exe'
+    ;;
+
+  *)
+    # Assume MSVC wrapper
+    library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
+    dynamic_linker='Win32 ld.exe'
+    ;;
+  esac
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[23].*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2.*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  *) # from 4.6 on, and DragonFly
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+haiku*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  dynamic_linker="$host_os runtime_loader"
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
+    fi
+    ;;
+  hppa*64*)
+    shrext_cmds='.sl'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+  postinstall_cmds='chmod 555 $lib'
+  # or fails outright, so override atomically:
+  install_override_mode=555
+  ;;
+
+interix[3-9]*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test yes = "$lt_cv_prog_gnu_ld"; then
+		version_type=linux # correct to gnu/linux during the next big refactor
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  hardcode_libdir_flag_spec_CXX='-L$libdir'
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+
+  # Some binutils ld are patched to set DT_RUNPATH
+  if test ${lt_cv_shlibpath_overrides_runpath+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  lt_cv_shlibpath_overrides_runpath=no
+    save_LDFLAGS=$LDFLAGS
+    save_libdir=$libdir
+    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \
+	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\""
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"
+then :
+  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null
+then :
+  lt_cv_shlibpath_overrides_runpath=yes
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+    LDFLAGS=$save_LDFLAGS
+    libdir=$save_libdir
+
+fi
+
+  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+netbsdelf*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='NetBSD ld.elf_so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+*nto* | *qnx*)
+  version_type=qnx
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='ldqnx.so'
+  ;;
+
+openbsd* | bitrig*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec=/usr/lib
+  need_lib_prefix=no
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+os2*)
+  libname_spec='$name'
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  ;;
+
+rdos*)
+  dynamic_linker=no
+  ;;
+
+solaris*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test yes = "$with_gnu_ld"; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec; then
+    version_type=linux # correct to gnu/linux during the next big refactor
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=sco
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  if test yes = "$with_gnu_ld"; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+tpf*)
+  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+uts4*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+printf "%s\n" "$dynamic_linker" >&6; }
+test no = "$dynamic_linker" && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test yes = "$GCC"; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
+fi
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
+fi
+
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+printf %s "checking how to hardcode library paths into programs... " >&6; }
+hardcode_action_CXX=
+if test -n "$hardcode_libdir_flag_spec_CXX" ||
+   test -n "$runpath_var_CXX" ||
+   test yes = "$hardcode_automatic_CXX"; then
+
+  # We can hardcode non-existent directories.
+  if test no != "$hardcode_direct_CXX" &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" &&
+     test no != "$hardcode_minus_L_CXX"; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action_CXX=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action_CXX=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action_CXX=unsupported
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5
+printf "%s\n" "$hardcode_action_CXX" >&6; }
+
+if test relink = "$hardcode_action_CXX" ||
+   test yes = "$inherit_rpath_CXX"; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+
+
+
+
+
+  fi # test -n "$compiler"
+
+  CC=$lt_save_CC
+  CFLAGS=$lt_save_CFLAGS
+  LDCXX=$LD
+  LD=$lt_save_LD
+  GCC=$lt_save_GCC
+  with_gnu_ld=$lt_save_with_gnu_ld
+  lt_cv_path_LDCXX=$lt_cv_path_LD
+  lt_cv_path_LD=$lt_save_path_LD
+  lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+  lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+fi # test yes != "$_lt_caught_CXX_error"
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        ac_config_commands="$ac_config_commands libtool"
+
+
+
+
+# Only expand once:
+
+
+## --------------------- ##
+##  End of libtool code  ##
+## --------------------- ##
+
+#
+# Verify if finally libtool shared libraries will be built
+#
+
+case "x$enable_shared" in # ((
+  xyes | xno)
+    xc_lt_build_shared=$enable_shared
+    ;;
+  *)
+    as_fn_error $? "unexpected libtool enable_shared value: $enable_shared" "$LINENO" 5
+    ;;
+esac
+
+#
+# Verify if finally libtool static libraries will be built
+#
+
+case "x$enable_static" in # ((
+  xyes | xno)
+    xc_lt_build_static=$enable_static
+    ;;
+  *)
+    as_fn_error $? "unexpected libtool enable_static value: $enable_static" "$LINENO" 5
+    ;;
+esac
+
+#
+# Verify if libtool shared libraries should be linked using flag -version-info
+#
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries with -version-info" >&5
+printf %s "checking whether to build shared libraries with -version-info... " >&6; }
+xc_lt_shlib_use_version_info='yes'
+if test "x$version_type" = 'xnone'; then
+  xc_lt_shlib_use_version_info='no'
+fi
+case $host_os in # (
+  amigaos*)
+    xc_lt_shlib_use_version_info='yes'
+    ;;
+esac
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xc_lt_shlib_use_version_info" >&5
+printf "%s\n" "$xc_lt_shlib_use_version_info" >&6; }
+
+#
+# Verify if libtool shared libraries should be linked using flag -no-undefined
+#
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries with -no-undefined" >&5
+printf %s "checking whether to build shared libraries with -no-undefined... " >&6; }
+xc_lt_shlib_use_no_undefined='no'
+if test "x$allow_undefined" = 'xno'; then
+  xc_lt_shlib_use_no_undefined='yes'
+elif test "x$allow_undefined_flag" = 'xunsupported'; then
+  xc_lt_shlib_use_no_undefined='yes'
+fi
+case $host_os in # (
+  cygwin* | mingw* | pw32* | cegcc* | os2* | aix*)
+    xc_lt_shlib_use_no_undefined='yes'
+    ;;
+esac
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xc_lt_shlib_use_no_undefined" >&5
+printf "%s\n" "$xc_lt_shlib_use_no_undefined" >&6; }
+
+#
+# Verify if libtool shared libraries should be linked using flag -mimpure-text
+#
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries with -mimpure-text" >&5
+printf %s "checking whether to build shared libraries with -mimpure-text... " >&6; }
+xc_lt_shlib_use_mimpure_text='no'
+case $host_os in # (
+  solaris2*)
+    if test "x$GCC" = 'xyes'; then
+      xc_lt_shlib_use_mimpure_text='yes'
+    fi
+    ;;
+esac
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xc_lt_shlib_use_mimpure_text" >&5
+printf "%s\n" "$xc_lt_shlib_use_mimpure_text" >&6; }
+
+#
+# Find out wether libtool libraries would be built wit PIC
+#
+
+case "x$pic_mode" in # ((((
+  xdefault)
+    xc_lt_build_shared_with_pic='yes'
+    xc_lt_build_static_with_pic='no'
+    ;;
+  xyes)
+    xc_lt_build_shared_with_pic='yes'
+    xc_lt_build_static_with_pic='yes'
+    ;;
+  xno)
+    xc_lt_build_shared_with_pic='no'
+    xc_lt_build_static_with_pic='no'
+    ;;
+  *)
+    xc_lt_build_shared_with_pic='unknown'
+    xc_lt_build_static_with_pic='unknown'
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unexpected libtool pic_mode value: $pic_mode" >&5
+printf "%s\n" "$as_me: WARNING: unexpected libtool pic_mode value: $pic_mode" >&2;}
+    ;;
+esac
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries with PIC" >&5
+printf %s "checking whether to build shared libraries with PIC... " >&6; }
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xc_lt_build_shared_with_pic" >&5
+printf "%s\n" "$xc_lt_build_shared_with_pic" >&6; }
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries with PIC" >&5
+printf %s "checking whether to build static libraries with PIC... " >&6; }
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xc_lt_build_static_with_pic" >&5
+printf "%s\n" "$xc_lt_build_static_with_pic" >&6; }
+
+#
+# Verify if libtool shared libraries will be built while static not built
+#
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries only" >&5
+printf %s "checking whether to build shared libraries only... " >&6; }
+if test "$xc_lt_build_shared" = 'yes' &&
+  test "$xc_lt_build_static" = 'no'; then
+  xc_lt_build_shared_only='yes'
+else
+  xc_lt_build_shared_only='no'
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xc_lt_build_shared_only" >&5
+printf "%s\n" "$xc_lt_build_shared_only" >&6; }
+
+#
+# Verify if libtool static libraries will be built while shared not built
+#
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries only" >&5
+printf %s "checking whether to build static libraries only... " >&6; }
+if test "$xc_lt_build_static" = 'yes' &&
+  test "$xc_lt_build_shared" = 'no'; then
+  xc_lt_build_static_only='yes'
+else
+  xc_lt_build_static_only='no'
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $xc_lt_build_static_only" >&5
+printf "%s\n" "$xc_lt_build_static_only" >&6; }
+
+
+
+
+
+#
+# Automake conditionals based on libtool related checks
+#
+
+ if test "x$xc_lt_shlib_use_version_info" = 'xyes'; then
+  CARES_LT_SHLIB_USE_VERSION_INFO_TRUE=
+  CARES_LT_SHLIB_USE_VERSION_INFO_FALSE='#'
+else
+  CARES_LT_SHLIB_USE_VERSION_INFO_TRUE='#'
+  CARES_LT_SHLIB_USE_VERSION_INFO_FALSE=
+fi
+
+ if test "x$xc_lt_shlib_use_no_undefined" = 'xyes'; then
+  CARES_LT_SHLIB_USE_NO_UNDEFINED_TRUE=
+  CARES_LT_SHLIB_USE_NO_UNDEFINED_FALSE='#'
+else
+  CARES_LT_SHLIB_USE_NO_UNDEFINED_TRUE='#'
+  CARES_LT_SHLIB_USE_NO_UNDEFINED_FALSE=
+fi
+
+ if test "x$xc_lt_shlib_use_mimpure_text" = 'xyes'; then
+  CARES_LT_SHLIB_USE_MIMPURE_TEXT_TRUE=
+  CARES_LT_SHLIB_USE_MIMPURE_TEXT_FALSE='#'
+else
+  CARES_LT_SHLIB_USE_MIMPURE_TEXT_TRUE='#'
+  CARES_LT_SHLIB_USE_MIMPURE_TEXT_FALSE=
+fi
+
+
+#
+# Due to libtool and automake machinery limitations of not allowing
+# specifying separate CPPFLAGS or CFLAGS when compiling objects for
+# inclusion of these in shared or static libraries, we are forced to
+# build using separate configure runs for shared and static libraries
+# on systems where different CPPFLAGS or CFLAGS are mandatory in order
+# to compile objects for each kind of library. Notice that relying on
+# the '-DPIC' CFLAG that libtool provides is not valid given that the
+# user might for example choose to build static libraries with PIC.
+#
+
+#
+# Make our Makefile.am files use the staticlib CPPFLAG only when strictly
+# targeting a static library and not building its shared counterpart.
+#
+
+ if test "x$xc_lt_build_static_only" = 'xyes'; then
+  USE_CPPFLAG_CARES_STATICLIB_TRUE=
+  USE_CPPFLAG_CARES_STATICLIB_FALSE='#'
+else
+  USE_CPPFLAG_CARES_STATICLIB_TRUE='#'
+  USE_CPPFLAG_CARES_STATICLIB_FALSE=
+fi
+
+
+#
+# Make staticlib CPPFLAG variable and its definition visible in output
+# files unconditionally, providing an empty definition unless strictly
+# targeting a static library and not building its shared counterpart.
+#
+
+CPPFLAG_CARES_STATICLIB=
+if test "x$xc_lt_build_static_only" = 'xyes'; then
+  CPPFLAG_CARES_STATICLIB='-DCARES_STATICLIB'
+fi
+
+
+
+
+  #
+  compiler_id="unknown"
+  compiler_num="0"
+  #
+  flags_dbg_all="unknown"
+  flags_dbg_yes="unknown"
+  flags_dbg_off="unknown"
+  flags_opt_all="unknown"
+  flags_opt_yes="unknown"
+  flags_opt_off="unknown"
+  #
+  flags_prefer_cppflags="no"
+  #
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is DEC/Compaq/HP C" >&5
+printf %s "checking if compiler is DEC/Compaq/HP C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __DECC
+CURL_DEF_TOKEN __DECC
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__DECC"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___DECC=no
+
+  else
+    curl_cv_have_def___DECC=yes
+    curl_cv_def___DECC=$tmp_exp
+
+  fi
+
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __DECC_VER
+CURL_DEF_TOKEN __DECC_VER
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__DECC_VER"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___DECC_VER=no
+
+  else
+    curl_cv_have_def___DECC_VER=yes
+    curl_cv_def___DECC_VER=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___DECC" = "yes" &&
+    test "$curl_cv_have_def___DECC_VER" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="DEC_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g2"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -O4"
+    flags_opt_yes="-O1"
+    flags_opt_off="-O0"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is HP-UX C" >&5
+printf %s "checking if compiler is HP-UX C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __HP_cc
+CURL_DEF_TOKEN __HP_cc
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__HP_cc"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___HP_cc=no
+
+  else
+    curl_cv_have_def___HP_cc=yes
+    curl_cv_def___HP_cc=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___HP_cc" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="HP_UX_C"
+    flags_dbg_all="-g -s"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-s"
+    flags_opt_all="-O +O0 +O1 +O2 +O3 +O4"
+    flags_opt_yes="+O2"
+    flags_opt_off="+O0"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is IBM C" >&5
+printf %s "checking if compiler is IBM C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __IBMC__
+CURL_DEF_TOKEN __IBMC__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__IBMC__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___IBMC__=no
+
+  else
+    curl_cv_have_def___IBMC__=yes
+    curl_cv_def___IBMC__=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___IBMC__" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="IBM_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -O4 -O5"
+    flags_opt_all="$flags_opt_all -qnooptimize"
+    flags_opt_all="$flags_opt_all -qoptimize=0"
+    flags_opt_all="$flags_opt_all -qoptimize=1"
+    flags_opt_all="$flags_opt_all -qoptimize=2"
+    flags_opt_all="$flags_opt_all -qoptimize=3"
+    flags_opt_all="$flags_opt_all -qoptimize=4"
+    flags_opt_all="$flags_opt_all -qoptimize=5"
+    flags_opt_yes="-O2"
+    flags_opt_off="-qnooptimize"
+    flags_prefer_cppflags="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is Intel C" >&5
+printf %s "checking if compiler is Intel C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __INTEL_COMPILER
+CURL_DEF_TOKEN __INTEL_COMPILER
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__INTEL_COMPILER"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___INTEL_COMPILER=no
+
+  else
+    curl_cv_have_def___INTEL_COMPILER=yes
+    curl_cv_def___INTEL_COMPILER=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___INTEL_COMPILER" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_num="$curl_cv_def___INTEL_COMPILER"
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __unix__
+CURL_DEF_TOKEN __unix__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = ""; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___unix__=no
+
+  else
+    curl_cv_have_def___unix__=yes
+    curl_cv_def___unix__=$tmp_exp
+
+  fi
+
+    if test "$curl_cv_have_def___unix__" = "yes"; then
+      compiler_id="INTEL_UNIX_C"
+      flags_dbg_all="-g -g0"
+      flags_dbg_yes="-g"
+      flags_dbg_off="-g0"
+      flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
+      flags_opt_yes="-O2"
+      flags_opt_off="-O0"
+    else
+      compiler_id="INTEL_WINDOWS_C"
+      flags_dbg_all="/ZI /Zi /zI /zi /ZD /Zd /zD /zd /Z7 /z7 /Oy /Oy-"
+      flags_dbg_all="$flags_dbg_all /debug"
+      flags_dbg_all="$flags_dbg_all /debug:none"
+      flags_dbg_all="$flags_dbg_all /debug:minimal"
+      flags_dbg_all="$flags_dbg_all /debug:partial"
+      flags_dbg_all="$flags_dbg_all /debug:full"
+      flags_dbg_all="$flags_dbg_all /debug:semantic_stepping"
+      flags_dbg_all="$flags_dbg_all /debug:extended"
+      flags_dbg_yes="/Zi /Oy-"
+      flags_dbg_off="/debug:none /Oy-"
+      flags_opt_all="/O /O0 /O1 /O2 /O3 /Od /Og /Og- /Oi /Oi-"
+      flags_opt_yes="/O2"
+      flags_opt_off="/Od"
+    fi
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is clang" >&5
+printf %s "checking if compiler is clang... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __clang__
+CURL_DEF_TOKEN __clang__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__clang__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___clang__=no
+
+  else
+    curl_cv_have_def___clang__=yes
+    curl_cv_def___clang__=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___clang__" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="CLANG"
+    clangver=`$CC -dumpversion`
+    clangvhi=`echo $clangver | cut -d . -f1`
+    clangvlo=`echo $clangver | cut -d . -f2`
+    compiler_num=`(expr $clangvhi "*" 100 + $clangvlo) 2>/dev/null`
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_all="$flags_dbg_all -ggdb"
+    flags_dbg_all="$flags_dbg_all -gstabs"
+    flags_dbg_all="$flags_dbg_all -gstabs+"
+    flags_dbg_all="$flags_dbg_all -gcoff"
+    flags_dbg_all="$flags_dbg_all -gxcoff"
+    flags_dbg_all="$flags_dbg_all -gdwarf-2"
+    flags_dbg_all="$flags_dbg_all -gvms"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -Os -O3 -O4"
+    flags_opt_yes="-Os"
+    flags_opt_off="-O0"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is GNU C" >&5
+printf %s "checking if compiler is GNU C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __GNUC__
+CURL_DEF_TOKEN __GNUC__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__GNUC__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___GNUC__=no
+
+  else
+    curl_cv_have_def___GNUC__=yes
+    curl_cv_def___GNUC__=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___GNUC__" = "yes" &&
+    test "$compiler_id" = "unknown"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="GNU_C"
+    gccver=`$CC -dumpversion`
+    gccvhi=`echo $gccver | cut -d . -f1`
+    gccvlo=`echo $gccver | cut -d . -f2`
+    compiler_num=`(expr $gccvhi "*" 100 + $gccvlo) 2>/dev/null`
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_all="$flags_dbg_all -ggdb"
+    flags_dbg_all="$flags_dbg_all -gstabs"
+    flags_dbg_all="$flags_dbg_all -gstabs+"
+    flags_dbg_all="$flags_dbg_all -gcoff"
+    flags_dbg_all="$flags_dbg_all -gxcoff"
+    flags_dbg_all="$flags_dbg_all -gdwarf-2"
+    flags_dbg_all="$flags_dbg_all -gvms"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef _WIN32
+CURL_DEF_TOKEN _WIN32
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "_WIN32"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def__WIN32=no
+
+  else
+    curl_cv_have_def__WIN32=yes
+    curl_cv_def__WIN32=$tmp_exp
+
+  fi
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is LCC" >&5
+printf %s "checking if compiler is LCC... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __LCC__
+CURL_DEF_TOKEN __LCC__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__LCC__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___LCC__=no
+
+  else
+    curl_cv_have_def___LCC__=yes
+    curl_cv_def___LCC__=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___LCC__" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="LCC"
+    flags_dbg_all="-g"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all=""
+    flags_opt_yes=""
+    flags_opt_off=""
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is SGI MIPSpro C" >&5
+printf %s "checking if compiler is SGI MIPSpro C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __GNUC__
+CURL_DEF_TOKEN __GNUC__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__GNUC__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___GNUC__=no
+
+  else
+    curl_cv_have_def___GNUC__=yes
+    curl_cv_def___GNUC__=$tmp_exp
+
+  fi
+
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef _COMPILER_VERSION
+CURL_DEF_TOKEN _COMPILER_VERSION
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "_COMPILER_VERSION"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def__COMPILER_VERSION=no
+
+  else
+    curl_cv_have_def__COMPILER_VERSION=yes
+    curl_cv_def__COMPILER_VERSION=$tmp_exp
+
+  fi
+
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef _SGI_COMPILER_VERSION
+CURL_DEF_TOKEN _SGI_COMPILER_VERSION
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "_SGI_COMPILER_VERSION"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def__SGI_COMPILER_VERSION=no
+
+  else
+    curl_cv_have_def__SGI_COMPILER_VERSION=yes
+    curl_cv_def__SGI_COMPILER_VERSION=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___GNUC__" = "no" &&
+    (test "$curl_cv_have_def__SGI_COMPILER_VERSION" = "yes" ||
+     test "$curl_cv_have_def__COMPILER_VERSION" = "yes"); then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="SGI_MIPSPRO_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is SGI MIPS C" >&5
+printf %s "checking if compiler is SGI MIPS C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __GNUC__
+CURL_DEF_TOKEN __GNUC__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__GNUC__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___GNUC__=no
+
+  else
+    curl_cv_have_def___GNUC__=yes
+    curl_cv_def___GNUC__=$tmp_exp
+
+  fi
+
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __sgi
+CURL_DEF_TOKEN __sgi
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__sgi"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___sgi=no
+
+  else
+    curl_cv_have_def___sgi=yes
+    curl_cv_def___sgi=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___GNUC__" = "no" &&
+    test "$curl_cv_have_def___sgi" = "yes" &&
+    test "$compiler_id" = "unknown"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="SGI_MIPS_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is SunPro C" >&5
+printf %s "checking if compiler is SunPro C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __SUNPRO_C
+CURL_DEF_TOKEN __SUNPRO_C
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__SUNPRO_C"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___SUNPRO_C=no
+
+  else
+    curl_cv_have_def___SUNPRO_C=yes
+    curl_cv_def___SUNPRO_C=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___SUNPRO_C" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="SUNPRO_C"
+    flags_dbg_all="-g -s"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-s"
+    flags_opt_all="-O -xO -xO1 -xO2 -xO3 -xO4 -xO5"
+    flags_opt_yes="-xO2"
+    flags_opt_off=""
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is Tiny C" >&5
+printf %s "checking if compiler is Tiny C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __TINYC__
+CURL_DEF_TOKEN __TINYC__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__TINYC__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___TINYC__=no
+
+  else
+    curl_cv_have_def___TINYC__=yes
+    curl_cv_def___TINYC__=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___TINYC__" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    compiler_id="TINY_C"
+    flags_dbg_all="-g -b"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all=""
+    flags_opt_yes=""
+    flags_opt_off=""
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is Watcom C" >&5
+printf %s "checking if compiler is Watcom C... " >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __WATCOMC__
+CURL_DEF_TOKEN __WATCOMC__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__WATCOMC__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___WATCOMC__=no
+
+  else
+    curl_cv_have_def___WATCOMC__=yes
+    curl_cv_def___WATCOMC__=$tmp_exp
+
+  fi
+
+  if test "$curl_cv_have_def___WATCOMC__" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __UNIX__
+CURL_DEF_TOKEN __UNIX__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__UNIX__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___UNIX__=no
+
+  else
+    curl_cv_have_def___UNIX__=yes
+    curl_cv_def___UNIX__=$tmp_exp
+
+  fi
+
+    if test "$curl_cv_have_def___UNIX__" = "yes"; then
+      compiler_id="WATCOM_UNIX_C"
+      flags_dbg_all="-g1 -g1+ -g2 -g3"
+      flags_dbg_yes="-g2"
+      flags_dbg_off=""
+      flags_opt_all="-O0 -O1 -O2 -O3"
+      flags_opt_yes="-O2"
+      flags_opt_off="-O0"
+    else
+      compiler_id="WATCOM_WINDOWS_C"
+      flags_dbg_all=""
+      flags_dbg_yes=""
+      flags_dbg_off=""
+      flags_opt_all=""
+      flags_opt_yes=""
+      flags_opt_off=""
+    fi
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+  #
+  if test "$compiler_id" = "unknown"; then
+  cat <<_EOF 1>&2
+***
+*** Warning: This configure script does not have information about the
+*** compiler you are using, relative to the flags required to enable or
+*** disable generation of debug info, optimization options or warnings.
+***
+*** Whatever settings are present in CFLAGS will be used for this run.
+***
+*** If you wish to help the c-ares project to better support your compiler
+*** you can report this and the required info on the c-ares development
+*** mailing list: http://lists.haxx.se/listinfo/c-ares/
+***
+_EOF
+  fi
+
+
+squeeze() {
+  _sqz_result=""
+  eval _sqz_input=\$$1
+  for _sqz_token in $_sqz_input; do
+    if test -z "$_sqz_result"; then
+      _sqz_result="$_sqz_token"
+    else
+      _sqz_result="$_sqz_result $_sqz_token"
+    fi
+  done
+  eval $1=\$_sqz_result
+  return 0
+}
+
+
+      #
+  if test "$compiler_id" != "unknown"; then
+    #
+    if test "$compiler_id" = "GNU_C" ||
+      test "$compiler_id" = "CLANG"; then
+
+      if test "$compiler_id" = "GNU_C" ||
+    test "$compiler_id" = "CLANG"; then
+    tmp_has_include="no"
+    tmp_chg_FLAGS="$CFLAGS"
+    for word1 in $tmp_chg_FLAGS; do
+      case "$word1" in
+        -I*)
+          tmp_has_include="yes"
+          ;;
+      esac
+    done
+    if test "$tmp_has_include" = "yes"; then
+      tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
+      tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
+      CFLAGS="$tmp_chg_FLAGS"
+      squeeze CFLAGS
+    fi
+    tmp_has_include="no"
+    tmp_chg_FLAGS="$CPPFLAGS"
+    for word1 in $tmp_chg_FLAGS; do
+      case "$word1" in
+        -I*)
+          tmp_has_include="yes"
+          ;;
+      esac
+    done
+    if test "$tmp_has_include" = "yes"; then
+      tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
+      tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
+      CPPFLAGS="$tmp_chg_FLAGS"
+      squeeze CPPFLAGS
+    fi
+  fi
+
+    fi
+    #
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS=""
+    tmp_CFLAGS=""
+    #
+    case "$compiler_id" in
+        #
+      CLANG)
+        #
+                                tmp_CFLAGS="$tmp_CFLAGS -Qunused-arguments"
+        ;;
+        #
+      DEC_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS -std1"
+                tmp_CFLAGS="$tmp_CFLAGS -noansi_alias"
+                tmp_CFLAGS="$tmp_CFLAGS -warnprotos"
+                tmp_CFLAGS="$tmp_CFLAGS -msg_fatal toofewargs,toomanyargs"
+        ;;
+        #
+      GNU_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      HP_UX_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS -z"
+                                tmp_CFLAGS="$tmp_CFLAGS +W 4227,4255"
+        ;;
+        #
+      IBM_C)
+        #
+                tmp_CPPFLAGS="$tmp_CPPFLAGS -qthreaded"
+                                        tmp_CPPFLAGS="$tmp_CPPFLAGS -qnoansialias"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -qhalt=e"
+        ;;
+        #
+      INTEL_UNIX_C)
+        #
+                        tmp_CFLAGS="$tmp_CFLAGS -std=gnu89"
+                                                tmp_CPPFLAGS="$tmp_CPPFLAGS -we 140,147,165,266"
+                                        tmp_CPPFLAGS="$tmp_CPPFLAGS -wd 279,981,1469"
+        ;;
+        #
+      INTEL_WINDOWS_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      LCC)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS -n"
+        ;;
+        #
+      SGI_MIPS_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      SGI_MIPSPRO_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      SUNPRO_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      TINY_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      WATCOM_UNIX_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      WATCOM_WINDOWS_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+    esac
+    #
+    squeeze tmp_CPPFLAGS
+    squeeze tmp_CFLAGS
+    #
+    if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler accepts some basic options" >&5
+printf %s "checking if compiler accepts some basic options... " >&6; }
+      CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+
+    tmp_compiler_works="unknown"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+      int i = 1;
+      return i;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    tmp_compiler_works="yes"
+
+else $as_nop
+
+    tmp_compiler_works="no"
+    echo " " >&6
+    sed 's/^/cc-fail: /' conftest.err >&6
+    echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    if test "$tmp_compiler_works" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+        int i = 1;
+        return i;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+      tmp_compiler_works="yes"
+
+else $as_nop
+
+      tmp_compiler_works="no"
+      echo " " >&6
+      sed 's/^/link-fail: /' conftest.err >&6
+      echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  fi
+    if test "x$cross_compiling" != "xyes" &&
+    test "$tmp_compiler_works" = "yes"; then
+    if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#       ifdef __STDC__
+#         include <stdlib.h>
+#       endif
+
+int
+main (void)
+{
+
+        int i = 0;
+        exit(i);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+      tmp_compiler_works="yes"
+
+else $as_nop
+
+      tmp_compiler_works="no"
+      echo " " >&6
+      echo "run-fail: test program exited with status $ac_status" >&6
+      echo " " >&6
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+  fi
+    if test "$tmp_compiler_works" = "yes"; then
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS" >&5
+printf "%s\n" "$as_me: compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS" >&6;}
+
+  else
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS" >&5
+printf "%s\n" "$as_me: WARNING: compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS" >&2;}
+                CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+
+  fi
+
+    fi
+    #
+  fi
+
+
+        #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    #
+    tmp_options=""
+    tmp_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS="$CPPFLAGS"
+
+    ac_var_stripped=""
+  for word1 in $tmp_CFLAGS; do
+    ac_var_strip_word="no"
+    for word2 in $flags_dbg_all; do
+      if test "$word1" = "$word2"; then
+        ac_var_strip_word="yes"
+      fi
+    done
+    if test "$ac_var_strip_word" = "no"; then
+      ac_var_stripped="$ac_var_stripped $word1"
+    fi
+  done
+    tmp_CFLAGS="$ac_var_stripped"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_stripped=""
+  for word1 in $tmp_CPPFLAGS; do
+    ac_var_strip_word="no"
+    for word2 in $flags_dbg_all; do
+      if test "$word1" = "$word2"; then
+        ac_var_strip_word="yes"
+      fi
+    done
+    if test "$ac_var_strip_word" = "no"; then
+      ac_var_stripped="$ac_var_stripped $word1"
+    fi
+  done
+    tmp_CPPFLAGS="$ac_var_stripped"
+  squeeze tmp_CPPFLAGS
+
+    #
+    if test "$want_debug" = "yes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler accepts debug enabling options" >&5
+printf %s "checking if compiler accepts debug enabling options... " >&6; }
+      tmp_options="$flags_dbg_yes"
+    fi
+    if test "$want_debug" = "no"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler accepts debug disabling options" >&5
+printf %s "checking if compiler accepts debug disabling options... " >&6; }
+      tmp_options="$flags_dbg_off"
+    fi
+    #
+    if test "$flags_prefer_cppflags" = "yes"; then
+      CPPFLAGS="$tmp_CPPFLAGS $tmp_options"
+      CFLAGS="$tmp_CFLAGS"
+    else
+      CPPFLAGS="$tmp_CPPFLAGS"
+      CFLAGS="$tmp_CFLAGS $tmp_options"
+    fi
+    squeeze CPPFLAGS
+    squeeze CFLAGS
+
+    tmp_compiler_works="unknown"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+      int i = 1;
+      return i;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    tmp_compiler_works="yes"
+
+else $as_nop
+
+    tmp_compiler_works="no"
+    echo " " >&6
+    sed 's/^/cc-fail: /' conftest.err >&6
+    echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    if test "$tmp_compiler_works" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+        int i = 1;
+        return i;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+      tmp_compiler_works="yes"
+
+else $as_nop
+
+      tmp_compiler_works="no"
+      echo " " >&6
+      sed 's/^/link-fail: /' conftest.err >&6
+      echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  fi
+    if test "x$cross_compiling" != "xyes" &&
+    test "$tmp_compiler_works" = "yes"; then
+    if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#       ifdef __STDC__
+#         include <stdlib.h>
+#       endif
+
+int
+main (void)
+{
+
+        int i = 0;
+        exit(i);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+      tmp_compiler_works="yes"
+
+else $as_nop
+
+      tmp_compiler_works="no"
+      echo " " >&6
+      echo "run-fail: test program exited with status $ac_status" >&6
+      echo " " >&6
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+  fi
+    if test "$tmp_compiler_works" = "yes"; then
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: compiler options added: $tmp_options" >&5
+printf "%s\n" "$as_me: compiler options added: $tmp_options" >&6;}
+
+  else
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: compiler options rejected: $tmp_options" >&5
+printf "%s\n" "$as_me: WARNING: compiler options rejected: $tmp_options" >&2;}
+            CPPFLAGS="$tmp_save_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS"
+
+  fi
+
+    #
+  fi
+
+
+        #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    #
+    tmp_options=""
+    tmp_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS="$CPPFLAGS"
+    honor_optimize_option="yes"
+    #
+                        #
+    if test "$want_optimize" = "assume_no" ||
+       test "$want_optimize" = "assume_yes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler optimizer assumed setting might be used" >&5
+printf %s "checking if compiler optimizer assumed setting might be used... " >&6; }
+
+
+  ac_var_match_word="no"
+  for word1 in $tmp_CFLAGS; do
+    for word2 in $flags_opt_all; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+  if test "$ac_var_match_word" = "yes"; then
+
+        honor_optimize_option="no"
+
+
+  fi
+
+
+
+  ac_var_match_word="no"
+  for word1 in $tmp_CPPFLAGS; do
+    for word2 in $flags_opt_all; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+  if test "$ac_var_match_word" = "yes"; then
+
+        honor_optimize_option="no"
+
+
+  fi
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $honor_optimize_option" >&5
+printf "%s\n" "$honor_optimize_option" >&6; }
+      if test "$honor_optimize_option" = "yes"; then
+        if test "$want_optimize" = "assume_yes"; then
+          want_optimize="yes"
+        fi
+        if test "$want_optimize" = "assume_no"; then
+          want_optimize="no"
+        fi
+      fi
+    fi
+    #
+    if test "$honor_optimize_option" = "yes"; then
+
+    ac_var_stripped=""
+  for word1 in $tmp_CFLAGS; do
+    ac_var_strip_word="no"
+    for word2 in $flags_opt_all; do
+      if test "$word1" = "$word2"; then
+        ac_var_strip_word="yes"
+      fi
+    done
+    if test "$ac_var_strip_word" = "no"; then
+      ac_var_stripped="$ac_var_stripped $word1"
+    fi
+  done
+    tmp_CFLAGS="$ac_var_stripped"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_stripped=""
+  for word1 in $tmp_CPPFLAGS; do
+    ac_var_strip_word="no"
+    for word2 in $flags_opt_all; do
+      if test "$word1" = "$word2"; then
+        ac_var_strip_word="yes"
+      fi
+    done
+    if test "$ac_var_strip_word" = "no"; then
+      ac_var_stripped="$ac_var_stripped $word1"
+    fi
+  done
+    tmp_CPPFLAGS="$ac_var_stripped"
+  squeeze tmp_CPPFLAGS
+
+      if test "$want_optimize" = "yes"; then
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler accepts optimizer enabling options" >&5
+printf %s "checking if compiler accepts optimizer enabling options... " >&6; }
+        tmp_options="$flags_opt_yes"
+      fi
+      if test "$want_optimize" = "no"; then
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler accepts optimizer disabling options" >&5
+printf %s "checking if compiler accepts optimizer disabling options... " >&6; }
+        tmp_options="$flags_opt_off"
+      fi
+      if test "$flags_prefer_cppflags" = "yes"; then
+        CPPFLAGS="$tmp_CPPFLAGS $tmp_options"
+        CFLAGS="$tmp_CFLAGS"
+      else
+        CPPFLAGS="$tmp_CPPFLAGS"
+        CFLAGS="$tmp_CFLAGS $tmp_options"
+      fi
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+
+    tmp_compiler_works="unknown"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+      int i = 1;
+      return i;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    tmp_compiler_works="yes"
+
+else $as_nop
+
+    tmp_compiler_works="no"
+    echo " " >&6
+    sed 's/^/cc-fail: /' conftest.err >&6
+    echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    if test "$tmp_compiler_works" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+        int i = 1;
+        return i;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+      tmp_compiler_works="yes"
+
+else $as_nop
+
+      tmp_compiler_works="no"
+      echo " " >&6
+      sed 's/^/link-fail: /' conftest.err >&6
+      echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  fi
+    if test "x$cross_compiling" != "xyes" &&
+    test "$tmp_compiler_works" = "yes"; then
+    if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#       ifdef __STDC__
+#         include <stdlib.h>
+#       endif
+
+int
+main (void)
+{
+
+        int i = 0;
+        exit(i);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+      tmp_compiler_works="yes"
+
+else $as_nop
+
+      tmp_compiler_works="no"
+      echo " " >&6
+      echo "run-fail: test program exited with status $ac_status" >&6
+      echo " " >&6
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+  fi
+    if test "$tmp_compiler_works" = "yes"; then
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: compiler options added: $tmp_options" >&5
+printf "%s\n" "$as_me: compiler options added: $tmp_options" >&6;}
+
+  else
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: compiler options rejected: $tmp_options" >&5
+printf "%s\n" "$as_me: WARNING: compiler options rejected: $tmp_options" >&2;}
+                CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+
+  fi
+
+    fi
+    #
+  fi
+
+
+        #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS=""
+    tmp_CFLAGS=""
+    #
+    case "$compiler_id" in
+        #
+      CLANG)
+        #
+        if test "$want_warnings" = "yes"; then
+          tmp_CFLAGS="$tmp_CFLAGS -pedantic"
+          tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
+          tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
+          tmp_CFLAGS="$tmp_CFLAGS -Wshadow"
+          tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
+          tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
+          tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+          tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
+          tmp_CFLAGS="$tmp_CFLAGS -Wundef"
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+          tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
+          tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
+          tmp_CFLAGS="$tmp_CFLAGS -Wcast-align"
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+          tmp_CFLAGS="$tmp_CFLAGS -Wshorten-64-to-32"
+          #
+                    if test "$compiler_num" -ge "101"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wunused"
+          fi
+        fi
+        ;;
+        #
+      DEC_C)
+        #
+        if test "$want_warnings" = "yes"; then
+                    tmp_CFLAGS="$tmp_CFLAGS -msg_enable level3"
+        fi
+        ;;
+        #
+      GNU_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          #
+                              if test "x$cross_compiling" != "xyes" ||
+            test "$compiler_num" -ge "300"; then
+            tmp_CFLAGS="$tmp_CFLAGS -pedantic"
+          fi
+          #
+                    tmp_CFLAGS="$tmp_CFLAGS -Wall -W"
+          #
+                    if test "$compiler_num" -ge "104"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
+                        if test "x$cross_compiling" != "xyes" ||
+              test "$compiler_num" -ge "300"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wunused -Wshadow"
+            fi
+          fi
+          #
+                    if test "$compiler_num" -ge "207"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
+                        if test "x$cross_compiling" != "xyes" ||
+              test "$compiler_num" -ge "300"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
+              tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
+            fi
+          fi
+          #
+                    if test "$compiler_num" -ge "295"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+          fi
+          #
+                    if test "$compiler_num" -ge "296"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
+                                                tmp_CFLAGS="$tmp_CFLAGS -Wundef"
+          fi
+          #
+                    if test "$compiler_num" -ge "297"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+          fi
+          #
+                    if test "$compiler_num" -ge "300"; then
+                                                            tmp_CFLAGS="$tmp_CFLAGS"
+          fi
+          #
+                    if test "$compiler_num" -ge "303"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
+          fi
+          #
+                    if test "$compiler_num" -ge "304"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
+          fi
+          #
+                    if test "$compiler_num" -ge "400"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wstrict-aliasing=3"
+          fi
+          #
+                    if test "$compiler_num" -ge "402"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wcast-align"
+          fi
+          #
+                    if test "$compiler_num" -ge "403"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wtype-limits -Wold-style-declaration"
+            tmp_CFLAGS="$tmp_CFLAGS -Wmissing-parameter-type -Wempty-body"
+            tmp_CFLAGS="$tmp_CFLAGS -Wclobbered -Wignored-qualifiers"
+            tmp_CFLAGS="$tmp_CFLAGS -Wconversion -Wno-sign-conversion -Wvla"
+          fi
+          #
+                    if test "$compiler_num" -ge "405"; then
+                        if test "$curl_cv_have_def__WIN32" = "yes"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-pedantic-ms-format"
+            fi
+          fi
+          #
+        fi
+        #
+                if test "$compiler_num" -ge "300"; then
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+        else
+                              if test "x$cross_compiling" = "xyes"; then
+            if test "$compiler_num" -ge "104"; then
+                            tmp_CFLAGS="$tmp_CFLAGS -Wno-unused -Wno-shadow"
+            fi
+            if test "$compiler_num" -ge "207"; then
+                            tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-declarations"
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-prototypes"
+            fi
+          fi
+        fi
+        ;;
+        #
+      HP_UX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+                    tmp_CFLAGS="$tmp_CFLAGS +w1"
+        fi
+        ;;
+        #
+      IBM_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      INTEL_UNIX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          if test "$compiler_num" -gt "600"; then
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wall -w2"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcheck"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcomment"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wdeprecated"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wmissing-prototypes"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wp64"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wpointer-arith"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wreturn-type"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wshadow"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wuninitialized"
+                        tmp_CPPFLAGS="$tmp_CPPFLAGS -Wunused-function"
+          fi
+        fi
+                tmp_CFLAGS="$tmp_CFLAGS -fno-omit-frame-pointer"
+                tmp_CFLAGS="$tmp_CFLAGS -fno-strict-aliasing"
+                tmp_CFLAGS="$tmp_CFLAGS -fp-model precise"
+                if test "$compiler_num" -ge "1000"; then
+                    tmp_CFLAGS="$tmp_CFLAGS -vec-report0"
+        fi
+        ;;
+        #
+      INTEL_WINDOWS_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      LCC)
+        #
+        if test "$want_warnings" = "yes"; then
+                                                  tmp_CFLAGS="$tmp_CFLAGS"
+        fi
+        ;;
+        #
+      SGI_MIPS_C)
+        #
+        if test "$want_warnings" = "yes"; then
+                    tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
+        fi
+        ;;
+        #
+      SGI_MIPSPRO_C)
+        #
+        if test "$want_warnings" = "yes"; then
+                    tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
+                              tmp_CFLAGS="$tmp_CFLAGS -woff 1209"
+        fi
+        ;;
+        #
+      SUNPRO_C)
+        #
+        if test "$want_warnings" = "yes"; then
+                    tmp_CFLAGS="$tmp_CFLAGS -v"
+        fi
+        ;;
+        #
+      TINY_C)
+        #
+        if test "$want_warnings" = "yes"; then
+                    tmp_CFLAGS="$tmp_CFLAGS -Wall"
+                    tmp_CFLAGS="$tmp_CFLAGS -Wwrite-strings"
+                    tmp_CFLAGS="$tmp_CFLAGS -Wunsupported"
+        fi
+        ;;
+        #
+      WATCOM_UNIX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+                    tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
+        fi
+        ;;
+        #
+      WATCOM_WINDOWS_C)
+        #
+                tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+    esac
+    #
+    squeeze tmp_CPPFLAGS
+    squeeze tmp_CFLAGS
+    #
+    if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler accepts strict warning options" >&5
+printf %s "checking if compiler accepts strict warning options... " >&6; }
+      CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+
+    tmp_compiler_works="unknown"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+      int i = 1;
+      return i;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    tmp_compiler_works="yes"
+
+else $as_nop
+
+    tmp_compiler_works="no"
+    echo " " >&6
+    sed 's/^/cc-fail: /' conftest.err >&6
+    echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    if test "$tmp_compiler_works" = "yes"; then
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+        int i = 1;
+        return i;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+      tmp_compiler_works="yes"
+
+else $as_nop
+
+      tmp_compiler_works="no"
+      echo " " >&6
+      sed 's/^/link-fail: /' conftest.err >&6
+      echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  fi
+    if test "x$cross_compiling" != "xyes" &&
+    test "$tmp_compiler_works" = "yes"; then
+    if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#       ifdef __STDC__
+#         include <stdlib.h>
+#       endif
+
+int
+main (void)
+{
+
+        int i = 0;
+        exit(i);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+      tmp_compiler_works="yes"
+
+else $as_nop
+
+      tmp_compiler_works="no"
+      echo " " >&6
+      echo "run-fail: test program exited with status $ac_status" >&6
+      echo " " >&6
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+  fi
+    if test "$tmp_compiler_works" = "yes"; then
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS" >&5
+printf "%s\n" "$as_me: compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS" >&6;}
+
+  else
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS" >&5
+printf "%s\n" "$as_me: WARNING: compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS" >&2;}
+                CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+
+  fi
+
+    fi
+    #
+  fi
+
+
+if test "$compiler_id" = "INTEL_UNIX_C"; then
+  #
+  if test "$compiler_num" -ge "1000"; then
+        CFLAGS="$CFLAGS -shared-intel"
+  elif test "$compiler_num" -ge "900"; then
+        CFLAGS="$CFLAGS -i-dynamic"
+  fi
+  #
+fi
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler halts on compilation errors" >&5
+printf %s "checking if compiler halts on compilation errors... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+      force compilation error
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    as_fn_error $? "compiler does not halt on compilation errors." "$LINENO" 5
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler halts on negative sized arrays" >&5
+printf %s "checking if compiler halts on negative sized arrays... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
+
+int
+main (void)
+{
+
+      bad_t dummy;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    as_fn_error $? "compiler does not halt on negative sized arrays." "$LINENO" 5
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler halts on function prototype mismatch" >&5
+printf %s "checking if compiler halts on function prototype mismatch... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#     include <stdlib.h>
+      int rand(int n);
+      int rand(int n)
+      {
+        if(n)
+          return ++n;
+        else
+          return n;
+      }
+
+int
+main (void)
+{
+
+      int i[2];
+      int j = rand(i[0]);
+      if(j)
+        return j;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    as_fn_error $? "compiler does not halt on function prototype mismatch." "$LINENO" 5
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler supports hiding library internal symbols" >&5
+printf %s "checking if compiler supports hiding library internal symbols... " >&6; }
+  supports_symbol_hiding="no"
+  symbol_hiding_CFLAGS=""
+  symbol_hiding_EXTERN=""
+  tmp_CFLAGS=""
+  tmp_EXTERN=""
+  case "$compiler_id" in
+    CLANG)
+            tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
+      tmp_CFLAGS="-fvisibility=hidden"
+      supports_symbol_hiding="yes"
+      ;;
+    GNU_C)
+            if test "$compiler_num" -ge "304"; then
+        if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
+          tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
+          tmp_CFLAGS="-fvisibility=hidden"
+          supports_symbol_hiding="yes"
+        fi
+      fi
+      ;;
+    INTEL_UNIX_C)
+            if test "$compiler_num" -ge "900"; then
+        if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
+          tmp_save_CFLAGS="$CFLAGS"
+          CFLAGS="$CFLAGS -fvisibility=hidden"
+          cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#             include <stdio.h>
+
+int
+main (void)
+{
+
+              printf("icc fvisibility bug test");
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+            tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
+            tmp_CFLAGS="-fvisibility=hidden"
+            supports_symbol_hiding="yes"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+          CFLAGS="$tmp_save_CFLAGS"
+        fi
+      fi
+      ;;
+    SUNPRO_C)
+      if $CC 2>&1 | grep flags >/dev/null && $CC -flags | grep xldscope= >/dev/null ; then
+        tmp_EXTERN="__global"
+        tmp_CFLAGS="-xldscope=hidden"
+        supports_symbol_hiding="yes"
+      fi
+      ;;
+  esac
+  if test "$supports_symbol_hiding" = "yes"; then
+    tmp_save_CFLAGS="$CFLAGS"
+    CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+    squeeze CFLAGS
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $tmp_EXTERN char *dummy(char *buff);
+        char *dummy(char *buff)
+        {
+         if(buff)
+           return ++buff;
+         else
+           return buff;
+        }
+
+int
+main (void)
+{
+
+        char b[16];
+        char *r = dummy(&b[0]);
+        if(r)
+          return (int)*r;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      supports_symbol_hiding="yes"
+      if test -f conftest.err; then
+        grep 'visibility' conftest.err >/dev/null
+        if test "$?" -eq "0"; then
+          supports_symbol_hiding="no"
+        fi
+      fi
+
+else $as_nop
+
+      supports_symbol_hiding="no"
+      echo " " >&6
+      sed 's/^/cc-src: /' conftest.$ac_ext >&6
+      sed 's/^/cc-err: /' conftest.err >&6
+      echo " " >&6
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    CFLAGS="$tmp_save_CFLAGS"
+  fi
+  if test "$supports_symbol_hiding" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    symbol_hiding_CFLAGS="$tmp_CFLAGS"
+    symbol_hiding_EXTERN="$tmp_EXTERN"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for windows.h" >&5
+printf %s "checking for windows.h... " >&6; }
+if test ${ac_cv_header_windows_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__)
+        HAVE_WINDOWS_H shall not be defined.
+#else
+        int dummy=2*WINVER;
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_windows_h="yes"
+
+else $as_nop
+
+      ac_cv_header_windows_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_windows_h" >&5
+printf "%s\n" "$ac_cv_header_windows_h" >&6; }
+  case "$ac_cv_header_windows_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WINDOWS_H 1" >>confdefs.h
+
+
+printf "%s\n" "#define WIN32_LEAN_AND_MEAN 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether build target is a native Windows one" >&5
+printf %s "checking whether build target is a native Windows one... " >&6; }
+if test ${ac_cv_native_windows+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    if test "$ac_cv_header_windows_h" = "no"; then
+      ac_cv_native_windows="no"
+    else
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+#if defined(__MINGW32__) || defined(__MINGW32CE__) || \
+   (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64)))
+          int dummy=1;
+#else
+          Not a native Windows build target.
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+        ac_cv_native_windows="yes"
+
+else $as_nop
+
+        ac_cv_native_windows="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    fi
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_native_windows" >&5
+printf "%s\n" "$ac_cv_native_windows" >&6; }
+   if test "x$ac_cv_native_windows" = xyes; then
+  DOING_NATIVE_WINDOWS_TRUE=
+  DOING_NATIVE_WINDOWS_FALSE='#'
+else
+  DOING_NATIVE_WINDOWS_TRUE='#'
+  DOING_NATIVE_WINDOWS_FALSE=
+fi
+
+
+case X-"$ac_cv_native_windows" in
+  X-yes)
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for winsock.h" >&5
+printf %s "checking for winsock.h... " >&6; }
+if test ${ac_cv_header_winsock_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__)
+        HAVE_WINSOCK_H shall not be defined.
+#else
+        int dummy=WSACleanup();
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_winsock_h="yes"
+
+else $as_nop
+
+      ac_cv_header_winsock_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_winsock_h" >&5
+printf "%s\n" "$ac_cv_header_winsock_h" >&6; }
+  case "$ac_cv_header_winsock_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WINSOCK_H 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for winsock2.h" >&5
+printf %s "checking for winsock2.h... " >&6; }
+if test ${ac_cv_header_winsock2_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock2.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
+        HAVE_WINSOCK2_H shall not be defined.
+#else
+        int dummy=2*IPPROTO_ESP;
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_winsock2_h="yes"
+
+else $as_nop
+
+      ac_cv_header_winsock2_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_winsock2_h" >&5
+printf "%s\n" "$ac_cv_header_winsock2_h" >&6; }
+  case "$ac_cv_header_winsock2_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WINSOCK2_H 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ws2tcpip.h" >&5
+printf %s "checking for ws2tcpip.h... " >&6; }
+if test ${ac_cv_header_ws2tcpip_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
+        HAVE_WS2TCPIP_H shall not be defined.
+#else
+        int dummy=2*IP_PKTINFO;
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_ws2tcpip_h="yes"
+
+else $as_nop
+
+      ac_cv_header_ws2tcpip_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_ws2tcpip_h" >&5
+printf "%s\n" "$ac_cv_header_ws2tcpip_h" >&6; }
+  case "$ac_cv_header_ws2tcpip_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WS2TCPIP_H 1" >>confdefs.h
+
+      ;;
+  esac
+
+    CPPFLAGS="$CPPFLAGS -D_WIN32_WINNT=0x0600"
+    ;;
+  *)
+    ac_cv_header_winsock_h="no"
+    ac_cv_header_winsock2_h="no"
+    ac_cv_header_ws2tcpip_h="no"
+    ;;
+esac
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if X/Open network library is required" >&5
+printf %s "checking if X/Open network library is required... " >&6; }
+  tst_lib_xnet_required="no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+int main (void)
+{
+#if defined(__hpux) && defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)
+  return 0;
+#elif defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)
+  return 0;
+#else
+  force compilation error
+#endif
+}
+
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    tst_lib_xnet_required="yes"
+    LIBS="$LIBS -lxnet"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tst_lib_xnet_required" >&5
+printf "%s\n" "$tst_lib_xnet_required" >&6; }
+
+
+ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
+if test "x$ac_cv_func_gethostbyname" = xyes
+then :
+  HAVE_GETHOSTBYNAME="1"
+
+else $as_nop
+   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
+printf %s "checking for gethostbyname in -lnsl... " >&6; }
+if test ${ac_cv_lib_nsl_gethostbyname+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lnsl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char gethostbyname ();
+int
+main (void)
+{
+return gethostbyname ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_nsl_gethostbyname=yes
+else $as_nop
+  ac_cv_lib_nsl_gethostbyname=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
+printf "%s\n" "$ac_cv_lib_nsl_gethostbyname" >&6; }
+if test "x$ac_cv_lib_nsl_gethostbyname" = xyes
+then :
+  HAVE_GETHOSTBYNAME="1"
+                             LIBS="$LIBS -lnsl"
+
+fi
+
+
+fi
+
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lsocket" >&5
+printf %s "checking for gethostbyname in -lsocket... " >&6; }
+if test ${ac_cv_lib_socket_gethostbyname+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsocket  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char gethostbyname ();
+int
+main (void)
+{
+return gethostbyname ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_socket_gethostbyname=yes
+else $as_nop
+  ac_cv_lib_socket_gethostbyname=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_gethostbyname" >&5
+printf "%s\n" "$ac_cv_lib_socket_gethostbyname" >&6; }
+if test "x$ac_cv_lib_socket_gethostbyname" = xyes
+then :
+  HAVE_GETHOSTBYNAME="1"
+               LIBS="$LIBS -lsocket"
+
+fi
+
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname with both nsl and socket libs" >&5
+printf %s "checking for gethostbyname with both nsl and socket libs... " >&6; }
+  my_ac_save_LIBS=$LIBS
+  LIBS="-lnsl -lsocket $LIBS"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+      gethostbyname();
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    HAVE_GETHOSTBYNAME="1"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    LIBS=$my_ac_save_LIBS
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+    if test "$ac_cv_header_windows_h" = "yes"; then
+    if test "$ac_cv_header_winsock_h" = "yes"; then
+      case $host in
+        *-*-mingw32ce*)
+          winsock_LIB="-lwinsock"
+          ;;
+        *)
+          winsock_LIB="-lwsock32"
+          ;;
+      esac
+    fi
+    if test "$ac_cv_header_winsock2_h" = "yes"; then
+      winsock_LIB="-lws2_32"
+    fi
+    if test ! -z "$winsock_LIB"; then
+      my_ac_save_LIBS=$LIBS
+      LIBS="$winsock_LIB $LIBS"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in $winsock_LIB" >&5
+printf %s "checking for gethostbyname in $winsock_LIB... " >&6; }
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#endif
+
+int
+main (void)
+{
+
+          gethostbyname("www.dummysite.com");
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+        HAVE_GETHOSTBYNAME="1"
+
+else $as_nop
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        winsock_LIB=""
+        LIBS=$my_ac_save_LIBS
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+    fi
+  fi
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname for Minix 3" >&5
+printf %s "checking for gethostbyname for Minix 3... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+/* Older Minix versions may need <net/gen/netdb.h> here instead */
+#include <netdb.h>
+
+int
+main (void)
+{
+
+      gethostbyname("www.dummysite.com");
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    HAVE_GETHOSTBYNAME="1"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname for eCos" >&5
+printf %s "checking for gethostbyname for eCos... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <stdio.h>
+#include <netdb.h>
+
+int
+main (void)
+{
+
+      gethostbyname("www.dummysite.com");
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    HAVE_GETHOSTBYNAME="1"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnet" >&5
+printf %s "checking for gethostbyname in -lnet... " >&6; }
+if test ${ac_cv_lib_net_gethostbyname+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lnet  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char gethostbyname ();
+int
+main (void)
+{
+return gethostbyname ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_net_gethostbyname=yes
+else $as_nop
+  ac_cv_lib_net_gethostbyname=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_net_gethostbyname" >&5
+printf "%s\n" "$ac_cv_lib_net_gethostbyname" >&6; }
+if test "x$ac_cv_lib_net_gethostbyname" = xyes
+then :
+  HAVE_GETHOSTBYNAME="1"
+               LIBS="$LIBS -lnet"
+
+fi
+
+fi
+
+
+if test "$HAVE_GETHOSTBYNAME" != "1"; then
+  as_fn_error $? "couldn't find libraries for gethostbyname()" "$LINENO" 5
+fi
+
+if test "x$host_vendor" = "xapple"
+then :
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing res_servicename" >&5
+printf %s "checking for library containing res_servicename... " >&6; }
+if test ${ac_cv_search_res_servicename+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_func_search_save_LIBS=$LIBS
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char res_servicename ();
+int
+main (void)
+{
+return res_servicename ();
+  ;
+  return 0;
+}
+_ACEOF
+for ac_lib in '' resolv
+do
+  if test -z "$ac_lib"; then
+    ac_res="none required"
+  else
+    ac_res=-l$ac_lib
+    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+  fi
+  if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_search_res_servicename=$ac_res
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext
+  if test ${ac_cv_search_res_servicename+y}
+then :
+  break
+fi
+done
+if test ${ac_cv_search_res_servicename+y}
+then :
+
+else $as_nop
+  ac_cv_search_res_servicename=no
+fi
+rm conftest.$ac_ext
+LIBS=$ac_func_search_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_res_servicename" >&5
+printf "%s\n" "$ac_cv_search_res_servicename" >&6; }
+ac_res=$ac_cv_search_res_servicename
+if test "$ac_res" != no
+then :
+  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+
+
+printf "%s\n" "#define CARES_USE_LIBRESOLV 1" >>confdefs.h
+
+
+else $as_nop
+
+    as_fn_error $? "Unable to find libresolv which is required for iPhone targets" "$LINENO" 5
+
+fi
+
+
+fi
+
+if test "x$host_vendor" = "xibm" -a "x$host_os" = "xopenedition"
+then :
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing res_init" >&5
+printf %s "checking for library containing res_init... " >&6; }
+if test ${ac_cv_search_res_init+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_func_search_save_LIBS=$LIBS
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char res_init ();
+int
+main (void)
+{
+return res_init ();
+  ;
+  return 0;
+}
+_ACEOF
+for ac_lib in '' resolv
+do
+  if test -z "$ac_lib"; then
+    ac_res="none required"
+  else
+    ac_res=-l$ac_lib
+    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+  fi
+  if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_search_res_init=$ac_res
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext
+  if test ${ac_cv_search_res_init+y}
+then :
+  break
+fi
+done
+if test ${ac_cv_search_res_init+y}
+then :
+
+else $as_nop
+  ac_cv_search_res_init=no
+fi
+rm conftest.$ac_ext
+LIBS=$ac_func_search_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_res_init" >&5
+printf "%s\n" "$ac_cv_search_res_init" >&6; }
+ac_res=$ac_cv_search_res_init
+if test "$ac_res" != no
+then :
+  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+
+
+printf "%s\n" "#define CARES_USE_LIBRESOLV 1" >>confdefs.h
+
+
+else $as_nop
+
+    as_fn_error $? "Unable to find libresolv which is required for z/OS" "$LINENO" 5
+
+fi
+
+
+fi
+
+ac_fn_c_check_func "$LINENO" "strcasecmp" "ac_cv_func_strcasecmp"
+if test "x$ac_cv_func_strcasecmp" = xyes
+then :
+
+else $as_nop
+   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for strcasecmp in -lresolve" >&5
+printf %s "checking for strcasecmp in -lresolve... " >&6; }
+if test ${ac_cv_lib_resolve_strcasecmp+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lresolve  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char strcasecmp ();
+int
+main (void)
+{
+return strcasecmp ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_resolve_strcasecmp=yes
+else $as_nop
+  ac_cv_lib_resolve_strcasecmp=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_resolve_strcasecmp" >&5
+printf "%s\n" "$ac_cv_lib_resolve_strcasecmp" >&6; }
+if test "x$ac_cv_lib_resolve_strcasecmp" = xyes
+then :
+  printf "%s\n" "#define HAVE_LIBRESOLVE 1" >>confdefs.h
+
+  LIBS="-lresolve $LIBS"
+
+fi
+
+fi
+
+
+if test "$ac_cv_lib_resolve_strcasecmp" = "$ac_cv_func_strcasecmp"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for strcasecmp in -lresolve" >&5
+printf %s "checking for strcasecmp in -lresolve... " >&6; }
+if test ${ac_cv_lib_resolve_strcasecmp+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lresolve -lnsl $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+char strcasecmp ();
+int
+main (void)
+{
+return strcasecmp ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_lib_resolve_strcasecmp=yes
+else $as_nop
+  ac_cv_lib_resolve_strcasecmp=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_resolve_strcasecmp" >&5
+printf "%s\n" "$ac_cv_lib_resolve_strcasecmp" >&6; }
+if test "x$ac_cv_lib_resolve_strcasecmp" = xyes
+then :
+  LIBS="-lresolve $LIBS"
+fi
+
+fi
+ac_cv_func_strcasecmp="no"
+
+if test "$ac_cv_header_winsock2_h" = "yes"; then
+  LIBS="$LIBS -liphlpapi"
+fi
+
+
+cares_includes_winsock2="\
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#  else
+#    ifdef HAVE_WINSOCK_H
+#      include <winsock.h>
+#    endif
+#  endif
+#endif
+/* includes end */"
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for windows.h" >&5
+printf %s "checking for windows.h... " >&6; }
+if test ${ac_cv_header_windows_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__)
+        HAVE_WINDOWS_H shall not be defined.
+#else
+        int dummy=2*WINVER;
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_windows_h="yes"
+
+else $as_nop
+
+      ac_cv_header_windows_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_windows_h" >&5
+printf "%s\n" "$ac_cv_header_windows_h" >&6; }
+  case "$ac_cv_header_windows_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WINDOWS_H 1" >>confdefs.h
+
+
+printf "%s\n" "#define WIN32_LEAN_AND_MEAN 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for winsock.h" >&5
+printf %s "checking for winsock.h... " >&6; }
+if test ${ac_cv_header_winsock_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__)
+        HAVE_WINSOCK_H shall not be defined.
+#else
+        int dummy=WSACleanup();
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_winsock_h="yes"
+
+else $as_nop
+
+      ac_cv_header_winsock_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_winsock_h" >&5
+printf "%s\n" "$ac_cv_header_winsock_h" >&6; }
+  case "$ac_cv_header_winsock_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WINSOCK_H 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for winsock2.h" >&5
+printf %s "checking for winsock2.h... " >&6; }
+if test ${ac_cv_header_winsock2_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock2.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
+        HAVE_WINSOCK2_H shall not be defined.
+#else
+        int dummy=2*IPPROTO_ESP;
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_winsock2_h="yes"
+
+else $as_nop
+
+      ac_cv_header_winsock2_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_winsock2_h" >&5
+printf "%s\n" "$ac_cv_header_winsock2_h" >&6; }
+  case "$ac_cv_header_winsock2_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WINSOCK2_H 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for connect in libraries" >&5
+printf %s "checking for connect in libraries... " >&6; }
+  tst_connect_save_LIBS="$LIBS"
+  tst_connect_need_LIBS="unknown"
+  for tst_lib in '' '-lsocket' ; do
+    if test "$tst_connect_need_LIBS" = "unknown"; then
+      LIBS="$tst_lib $tst_connect_save_LIBS"
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+          $cares_includes_winsock2
+          #ifndef HAVE_WINDOWS_H
+            int connect(int, void*, int);
+          #endif
+
+int
+main (void)
+{
+
+          if(0 != connect(0, 0, 0))
+            return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+        tst_connect_need_LIBS="$tst_lib"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+    fi
+  done
+  LIBS="$tst_connect_save_LIBS"
+  #
+  case X-"$tst_connect_need_LIBS" in
+    X-unknown)
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cannot find connect" >&5
+printf "%s\n" "cannot find connect" >&6; }
+      as_fn_error $? "cannot find connect function in libraries." "$LINENO" 5
+      ;;
+    X-)
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      ;;
+    *)
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tst_connect_need_LIBS" >&5
+printf "%s\n" "$tst_connect_need_LIBS" >&6; }
+      LIBS="$tst_connect_need_LIBS $tst_connect_save_LIBS"
+      ;;
+  esac
+
+
+if test "x$host_vendor" = "xapple"
+then :
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for iOS minimum version 10 or later" >&5
+printf %s "checking for iOS minimum version 10 or later... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <stdio.h>
+#include <TargetConditionals.h>
+
+int
+main (void)
+{
+
+#if TARGET_OS_IPHONE == 0 || __IPHONE_OS_VERSION_MIN_REQUIRED < 100000
+#error Not iOS 10 or later
+#endif
+return 0;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    ac_cv_ios_10="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+
+if test "x$host_vendor" = "xapple"
+then :
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for macOS minimum version 10.12 or later" >&5
+printf %s "checking for macOS minimum version 10.12 or later... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <stdio.h>
+#include <TargetConditionals.h>
+
+int
+main (void)
+{
+
+#ifndef MAC_OS_X_VERSION_10_12
+#  define MAC_OS_X_VERSION_10_12 101200
+#endif
+#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
+#error Not macOS 10.12 or later
+#endif
+return 0;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    ac_cv_macos_10_12="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+
+if test "x$host_vendor" != "xapple" || test "x$ac_cv_ios_10" = "xyes" || test "x$ac_cv_macos_10_12" = "xyes"; then
+
+
+# Obsolete code to be removed.
+if test $ac_cv_header_sys_time_h = yes; then
+
+printf "%s\n" "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
+
+fi
+# End of obsolete code.
+
+
+    ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/time.h" "ac_cv_header_sys_time_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_time_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TIME_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "time.h" "ac_cv_header_time_h" "$ac_includes_default"
+if test "x$ac_cv_header_time_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_TIME_H 1" >>confdefs.h
+
+fi
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for monotonic clock_gettime" >&5
+printf %s "checking for monotonic clock_gettime... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+#include <time.h>
+#endif
+#else
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+      struct timespec ts;
+      (void)clock_gettime(CLOCK_MONOTONIC, &ts);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    ac_cv_func_clock_gettime="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_clock_gettime="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+
+    #
+  if test "$ac_cv_func_clock_gettime" = "yes"; then
+    #
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for clock_gettime in libraries" >&5
+printf %s "checking for clock_gettime in libraries... " >&6; }
+    #
+    curl_cv_save_LIBS="$LIBS"
+    curl_cv_gclk_LIBS="unknown"
+    #
+    for x_xlibs in '' '-lrt' '-lposix4' ; do
+      if test "$curl_cv_gclk_LIBS" = "unknown"; then
+        if test -z "$x_xlibs"; then
+          LIBS="$curl_cv_save_LIBS"
+        else
+          LIBS="$x_xlibs $curl_cv_save_LIBS"
+        fi
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+#include <time.h>
+#endif
+#else
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+            struct timespec ts;
+            (void)clock_gettime(CLOCK_MONOTONIC, &ts);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+          curl_cv_gclk_LIBS="$x_xlibs"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+      fi
+    done
+    #
+    LIBS="$curl_cv_save_LIBS"
+    #
+    case X-"$curl_cv_gclk_LIBS" in
+      X-unknown)
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cannot find clock_gettime" >&5
+printf "%s\n" "cannot find clock_gettime" >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: HAVE_CLOCK_GETTIME_MONOTONIC will not be defined" >&5
+printf "%s\n" "$as_me: WARNING: HAVE_CLOCK_GETTIME_MONOTONIC will not be defined" >&2;}
+        ac_cv_func_clock_gettime="no"
+        ;;
+      X-)
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no additional lib required" >&5
+printf "%s\n" "no additional lib required" >&6; }
+        ac_cv_func_clock_gettime="yes"
+        ;;
+      *)
+        if test -z "$curl_cv_save_LIBS"; then
+          LIBS="$curl_cv_gclk_LIBS"
+        else
+          LIBS="$curl_cv_gclk_LIBS $curl_cv_save_LIBS"
+        fi
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $curl_cv_gclk_LIBS" >&5
+printf "%s\n" "$curl_cv_gclk_LIBS" >&6; }
+        ac_cv_func_clock_gettime="yes"
+        ;;
+    esac
+    #
+        if test "x$cross_compiling" != "xyes" &&
+      test "$ac_cv_func_clock_gettime" = "yes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if monotonic clock_gettime works" >&5
+printf %s "checking if monotonic clock_gettime works... " >&6; }
+      if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+#include <time.h>
+#endif
+#else
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+          struct timespec ts;
+          if (0 == clock_gettime(CLOCK_MONOTONIC, &ts))
+            exit(0);
+          else
+            exit(1);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+else $as_nop
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: HAVE_CLOCK_GETTIME_MONOTONIC will not be defined" >&5
+printf "%s\n" "$as_me: WARNING: HAVE_CLOCK_GETTIME_MONOTONIC will not be defined" >&2;}
+        ac_cv_func_clock_gettime="no"
+        LIBS="$curl_cv_save_LIBS"
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+    fi
+    #
+    case "$ac_cv_func_clock_gettime" in
+      yes)
+
+printf "%s\n" "#define HAVE_CLOCK_GETTIME_MONOTONIC 1" >>confdefs.h
+
+        ;;
+    esac
+    #
+  fi
+  #
+
+fi
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use libgcc" >&5
+printf %s "checking whether to use libgcc... " >&6; }
+# Check whether --enable-libgcc was given.
+if test ${enable_libgcc+y}
+then :
+  enableval=$enable_libgcc;  case "$enableval" in
+  yes)
+        LIBS="$LIBS -lgcc"
+       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+       ;;
+  *)   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+       ;;
+  esac
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+fi
+
+
+
+
+
+
+STDC_HEADERS
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+printf %s "checking for egrep... " >&6; }
+if test ${ac_cv_path_EGREP+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in egrep
+   do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+printf "%s\n" "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for malloc.h" >&5
+printf %s "checking for malloc.h... " >&6; }
+if test ${ac_cv_header_malloc_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <malloc.h>
+
+int
+main (void)
+{
+
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_malloc_h="yes"
+
+else $as_nop
+
+      ac_cv_header_malloc_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_malloc_h" >&5
+printf "%s\n" "$ac_cv_header_malloc_h" >&6; }
+  if test "$ac_cv_header_malloc_h" = "yes"; then
+
+printf "%s\n" "#define HAVE_MALLOC_H 1" >>confdefs.h
+
+    #
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <stdlib.h>
+
+int
+main (void)
+{
+
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      curl_cv_need_header_malloc_h="no"
+
+else $as_nop
+
+      curl_cv_need_header_malloc_h="yes"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    #
+    case "$curl_cv_need_header_malloc_h" in
+      yes)
+
+printf "%s\n" "#define NEED_MALLOC_H 1" >>confdefs.h
+
+        ;;
+    esac
+  fi
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for memory.h" >&5
+printf %s "checking for memory.h... " >&6; }
+if test ${ac_cv_header_memory_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <memory.h>
+
+int
+main (void)
+{
+
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_memory_h="yes"
+
+else $as_nop
+
+      ac_cv_header_memory_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_memory_h" >&5
+printf "%s\n" "$ac_cv_header_memory_h" >&6; }
+  if test "$ac_cv_header_memory_h" = "yes"; then
+
+printf "%s\n" "#define HAVE_MEMORY_H 1" >>confdefs.h
+
+    #
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#include <stdlib.h>
+
+int
+main (void)
+{
+
+        void *p = malloc(10);
+        void *q = calloc(10,10);
+        free(p);
+        free(q);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      curl_cv_need_header_memory_h="no"
+
+else $as_nop
+
+      curl_cv_need_header_memory_h="yes"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    #
+    case "$curl_cv_need_header_memory_h" in
+      yes)
+
+printf "%s\n" "#define NEED_MEMORY_H 1" >>confdefs.h
+
+        ;;
+    esac
+  fi
+
+
+ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/time.h" "ac_cv_header_sys_time_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_sys_time_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TIME_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/select.h" "ac_cv_header_sys_select_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_sys_select_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SELECT_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/ioctl.h" "ac_cv_header_sys_ioctl_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_sys_ioctl_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_IOCTL_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/param.h" "ac_cv_header_sys_param_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_sys_param_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_PARAM_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/uio.h" "ac_cv_header_sys_uio_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_sys_uio_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_UIO_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "assert.h" "ac_cv_header_assert_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_assert_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_ASSERT_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "netdb.h" "ac_cv_header_netdb_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_netdb_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_NETDB_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "netinet/in.h" "ac_cv_header_netinet_in_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_netinet_in_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_NETINET_IN_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "netinet/tcp.h" "ac_cv_header_netinet_tcp_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_netinet_tcp_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_NETINET_TCP_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "net/if.h" "ac_cv_header_net_if_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_net_if_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_NET_IF_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "errno.h" "ac_cv_header_errno_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_errno_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_ERRNO_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "socket.h" "ac_cv_header_socket_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SOCKET_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "strings.h" "ac_cv_header_strings_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_strings_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_STRINGS_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "stdbool.h" "ac_cv_header_stdbool_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_stdbool_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_STDBOOL_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "time.h" "ac_cv_header_time_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_time_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_TIME_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "limits.h" "ac_cv_header_limits_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_limits_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_LIMITS_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "arpa/nameser.h" "ac_cv_header_arpa_nameser_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_arpa_nameser_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_ARPA_NAMESER_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "arpa/nameser_compat.h" "ac_cv_header_arpa_nameser_compat_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_arpa_nameser_compat_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_ARPA_NAMESER_COMPAT_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "arpa/inet.h" "ac_cv_header_arpa_inet_h" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+
+"
+if test "x$ac_cv_header_arpa_inet_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_ARPA_INET_H 1" >>confdefs.h
+
+fi
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC options needed to detect all undeclared functions" >&5
+printf %s "checking for $CC options needed to detect all undeclared functions... " >&6; }
+if test ${ac_cv_c_undeclared_builtin_options+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_save_CFLAGS=$CFLAGS
+   ac_cv_c_undeclared_builtin_options='cannot detect'
+   for ac_arg in '' -fno-builtin; do
+     CFLAGS="$ac_save_CFLAGS $ac_arg"
+     # This test program should *not* compile successfully.
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+(void) strchr;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+else $as_nop
+  # This test program should compile successfully.
+        # No library function is consistently available on
+        # freestanding implementations, so test against a dummy
+        # declaration.  Include always-available headers on the
+        # off chance that they somehow elicit warnings.
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <float.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stddef.h>
+extern void ac_decl (int, char *);
+
+int
+main (void)
+{
+(void) ac_decl (0, (char *) 0);
+  (void) ac_decl;
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  if test x"$ac_arg" = x
+then :
+  ac_cv_c_undeclared_builtin_options='none needed'
+else $as_nop
+  ac_cv_c_undeclared_builtin_options=$ac_arg
+fi
+          break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    done
+    CFLAGS=$ac_save_CFLAGS
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5
+printf "%s\n" "$ac_cv_c_undeclared_builtin_options" >&6; }
+  case $ac_cv_c_undeclared_builtin_options in #(
+  'cannot detect') :
+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot make $CC report undeclared builtins
+See \`config.log' for more details" "$LINENO" 5; } ;; #(
+  'none needed') :
+    ac_c_undeclared_builtin_options='' ;; #(
+  *) :
+    ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;;
+esac
+
+ac_fn_check_decl "$LINENO" "HAVE_ARPA_NAMESER_H" "ac_cv_have_decl_HAVE_ARPA_NAMESER_H" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS"
+if test "x$ac_cv_have_decl_HAVE_ARPA_NAMESER_H" = xyes
+then :
+
+
+cat >>confdefs.h <<_EOF
+#define CARES_HAVE_ARPA_NAMESER_H 1
+_EOF
+
+
+fi
+ac_fn_check_decl "$LINENO" "HAVE_ARPA_NAMESER_COMPAT_H" "ac_cv_have_decl_HAVE_ARPA_NAMESER_COMPAT_H" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS"
+if test "x$ac_cv_have_decl_HAVE_ARPA_NAMESER_COMPAT_H" = xyes
+then :
+
+
+cat >>confdefs.h <<_EOF
+#define CARES_HAVE_ARPA_NAMESER_COMPAT_H 1
+_EOF
+
+
+fi
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
+printf %s "checking for an ANSI C-conforming const... " >&6; }
+if test ${ac_cv_c_const+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main (void)
+{
+
+#ifndef __cplusplus
+  /* Ultrix mips cc rejects this sort of thing.  */
+  typedef int charset[2];
+  const charset cs = { 0, 0 };
+  /* SunOS 4.1.1 cc rejects this.  */
+  char const *const *pcpcc;
+  char **ppc;
+  /* NEC SVR4.0.2 mips cc rejects this.  */
+  struct point {int x, y;};
+  static struct point const zero = {0,0};
+  /* IBM XL C 1.02.0.0 rejects this.
+     It does not let you subtract one const X* pointer from another in
+     an arm of an if-expression whose if-part is not a constant
+     expression */
+  const char *g = "string";
+  pcpcc = &g + (g ? g-g : 0);
+  /* HPUX 7.0 cc rejects these. */
+  ++pcpcc;
+  ppc = (char**) pcpcc;
+  pcpcc = (char const *const *) ppc;
+  { /* SCO 3.2v4 cc rejects this sort of thing.  */
+    char tx;
+    char *t = &tx;
+    char const *s = 0 ? (char *) 0 : (char const *) 0;
+
+    *t++ = 0;
+    if (s) return 0;
+  }
+  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+    int x[] = {25, 17};
+    const int *foo = &x[0];
+    ++foo;
+  }
+  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
+    typedef const int *iptr;
+    iptr p = 0;
+    ++p;
+  }
+  { /* IBM XL C 1.02.0.0 rejects this sort of thing, saying
+       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
+    struct s { int j; const int *ap[3]; } bx;
+    struct s *b = &bx; b->j = 5;
+  }
+  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+    const int foo = 10;
+    if (!foo) return 0;
+  }
+  return !cs[0] && !zero.x;
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_c_const=yes
+else $as_nop
+  ac_cv_c_const=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
+printf "%s\n" "$ac_cv_c_const" >&6; }
+if test $ac_cv_c_const = no; then
+
+printf "%s\n" "#define const /**/" >>confdefs.h
+
+fi
+
+ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
+if test "x$ac_cv_type_size_t" = xyes
+then :
+
+else $as_nop
+
+printf "%s\n" "#define size_t unsigned int" >>confdefs.h
+
+fi
+
+
+# Obsolete code to be removed.
+if test $ac_cv_header_sys_time_h = yes; then
+
+printf "%s\n" "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
+
+fi
+# End of obsolete code.
+
+
+        ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/time.h" "ac_cv_header_sys_time_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_time_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TIME_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "time.h" "ac_cv_header_time_h" "$ac_includes_default"
+if test "x$ac_cv_header_time_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_TIME_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for struct timeval" >&5
+printf %s "checking for struct timeval... " >&6; }
+if test ${ac_cv_struct_timeval+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+#include <time.h>
+#endif
+#else
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+int
+main (void)
+{
+
+        struct timeval ts;
+        ts.tv_sec  = 0;
+        ts.tv_usec = 0;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_struct_timeval="yes"
+
+else $as_nop
+
+      ac_cv_struct_timeval="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_timeval" >&5
+printf "%s\n" "$ac_cv_struct_timeval" >&6; }
+  case "$ac_cv_struct_timeval" in
+    yes)
+
+printf "%s\n" "#define HAVE_STRUCT_TIMEVAL 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+ac_fn_c_check_type "$LINENO" "long long" "ac_cv_type_long_long" "$ac_includes_default"
+if test "x$ac_cv_type_long_long" = xyes
+then :
+
+printf "%s\n" "#define HAVE_LONGLONG 1" >>confdefs.h
+
+   longlong="yes"
+
+fi
+
+
+if test "xyes" = "x$longlong"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if numberLL works" >&5
+printf %s "checking if numberLL works... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+      long long val = 1000LL;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_LL 1" >>confdefs.h
+
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+
+# check for ssize_t
+ac_fn_c_check_type "$LINENO" "ssize_t" "ac_cv_type_ssize_t" "$ac_includes_default"
+if test "x$ac_cv_type_ssize_t" = xyes
+then :
+   CARES_TYPEOF_ARES_SSIZE_T=ssize_t
+else $as_nop
+   CARES_TYPEOF_ARES_SSIZE_T=int
+fi
+
+
+
+printf "%s\n" "#define CARES_TYPEOF_ARES_SSIZE_T ${CARES_TYPEOF_ARES_SSIZE_T}" >>confdefs.h
+
+
+
+# check for bool type
+ac_fn_c_check_type "$LINENO" "bool" "ac_cv_type_bool" "
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_STDBOOL_H
+#include <stdbool.h>
+#endif
+
+"
+if test "x$ac_cv_type_bool" = xyes
+then :
+
+
+printf "%s\n" "#define HAVE_BOOL_T 1" >>confdefs.h
+
+
+fi
+
+
+
+cares_includes_ws2tcpip="\
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#    ifdef HAVE_WS2TCPIP_H
+#       include <ws2tcpip.h>
+#    endif
+#  endif
+#endif
+/* includes end */"
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for windows.h" >&5
+printf %s "checking for windows.h... " >&6; }
+if test ${ac_cv_header_windows_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__)
+        HAVE_WINDOWS_H shall not be defined.
+#else
+        int dummy=2*WINVER;
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_windows_h="yes"
+
+else $as_nop
+
+      ac_cv_header_windows_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_windows_h" >&5
+printf "%s\n" "$ac_cv_header_windows_h" >&6; }
+  case "$ac_cv_header_windows_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WINDOWS_H 1" >>confdefs.h
+
+
+printf "%s\n" "#define WIN32_LEAN_AND_MEAN 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for winsock2.h" >&5
+printf %s "checking for winsock2.h... " >&6; }
+if test ${ac_cv_header_winsock2_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock2.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
+        HAVE_WINSOCK2_H shall not be defined.
+#else
+        int dummy=2*IPPROTO_ESP;
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_winsock2_h="yes"
+
+else $as_nop
+
+      ac_cv_header_winsock2_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_winsock2_h" >&5
+printf "%s\n" "$ac_cv_header_winsock2_h" >&6; }
+  case "$ac_cv_header_winsock2_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WINSOCK2_H 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ws2tcpip.h" >&5
+printf %s "checking for ws2tcpip.h... " >&6; }
+if test ${ac_cv_header_ws2tcpip_h+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+int
+main (void)
+{
+
+#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
+        HAVE_WS2TCPIP_H shall not be defined.
+#else
+        int dummy=2*IP_PKTINFO;
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_header_ws2tcpip_h="yes"
+
+else $as_nop
+
+      ac_cv_header_ws2tcpip_h="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_ws2tcpip_h" >&5
+printf "%s\n" "$ac_cv_header_ws2tcpip_h" >&6; }
+  case "$ac_cv_header_ws2tcpip_h" in
+    yes)
+
+printf "%s\n" "#define HAVE_WS2TCPIP_H 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+
+cares_includes_sys_socket="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_sys_socket
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$cares_includes_sys_socket
+"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+
+
+
+cares_preprocess_callconv="\
+/* preprocess start */
+#ifdef HAVE_WINDOWS_H
+#  define FUNCALLCONV __stdcall
+#else
+#  define FUNCALLCONV
+#endif
+/* preprocess end */"
+
+
+        #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ares_socklen_t data type" >&5
+printf %s "checking for ares_socklen_t data type... " >&6; }
+  cares_typeof_ares_socklen_t="unknown"
+  for arg1 in int SOCKET; do
+    for arg2 in 'struct sockaddr' void; do
+      for t in socklen_t int size_t 'unsigned int' long 'unsigned long' void; do
+        if test "$cares_typeof_ares_socklen_t" = "unknown"; then
+          cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+              $cares_includes_ws2tcpip
+              $cares_includes_sys_socket
+              $cares_preprocess_callconv
+              extern int FUNCALLCONV getpeername($arg1, $arg2 *, $t *);
+
+int
+main (void)
+{
+
+              $t *lenptr = 0;
+              if(0 != getpeername(0, 0, lenptr))
+                return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+            cares_typeof_ares_socklen_t="$t"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+        fi
+      done
+    done
+  done
+  for t in socklen_t int; do
+    if test "$cares_typeof_ares_socklen_t" = "void"; then
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+          $cares_includes_sys_socket
+          typedef $t ares_socklen_t;
+
+int
+main (void)
+{
+
+          ares_socklen_t dummy;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+        cares_typeof_ares_socklen_t="$t"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    fi
+  done
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cares_typeof_ares_socklen_t" >&5
+printf "%s\n" "$cares_typeof_ares_socklen_t" >&6; }
+  if test "$cares_typeof_ares_socklen_t" = "void" ||
+    test "$cares_typeof_ares_socklen_t" = "unknown"; then
+    as_fn_error $? "cannot find data type for ares_socklen_t." "$LINENO" 5
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of ares_socklen_t" >&5
+printf %s "checking size of ares_socklen_t... " >&6; }
+  cares_sizeof_ares_socklen_t="unknown"
+  cares_pull_headers_socklen_t="unknown"
+  if test "$ac_cv_header_ws2tcpip_h" = "yes"; then
+    tst_pull_header_checks='none ws2tcpip'
+    tst_size_checks='4'
+  else
+    tst_pull_header_checks='none systypes syssocket'
+    tst_size_checks='4 8 2'
+  fi
+  for tst_size in $tst_size_checks; do
+    for tst_pull_headers in $tst_pull_header_checks; do
+      if test "$cares_sizeof_ares_socklen_t" = "unknown"; then
+        case $tst_pull_headers in
+          ws2tcpip)
+            tmp_includes="$cares_includes_ws2tcpip"
+            ;;
+          systypes)
+            tmp_includes="$cares_includes_sys_types"
+            ;;
+          syssocket)
+            tmp_includes="$cares_includes_sys_socket"
+            ;;
+          *)
+            tmp_includes=""
+            ;;
+        esac
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+            $tmp_includes
+            typedef $cares_typeof_ares_socklen_t ares_socklen_t;
+            typedef char dummy_arr[sizeof(ares_socklen_t) == $tst_size ? 1 : -1];
+
+int
+main (void)
+{
+
+            ares_socklen_t dummy;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+          cares_sizeof_ares_socklen_t="$tst_size"
+          cares_pull_headers_socklen_t="$tst_pull_headers"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+      fi
+    done
+  done
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cares_sizeof_ares_socklen_t" >&5
+printf "%s\n" "$cares_sizeof_ares_socklen_t" >&6; }
+  if test "$cares_sizeof_ares_socklen_t" = "unknown"; then
+    as_fn_error $? "cannot find out size of ares_socklen_t." "$LINENO" 5
+  fi
+  #
+  case $cares_pull_headers_socklen_t in
+    ws2tcpip)
+
+cat >>confdefs.h <<_EOF
+#define CARES_PULL_WS2TCPIP_H 1
+_EOF
+
+      ;;
+    systypes)
+
+cat >>confdefs.h <<_EOF
+#define CARES_PULL_SYS_TYPES_H 1
+_EOF
+
+      ;;
+    syssocket)
+
+cat >>confdefs.h <<_EOF
+#define CARES_PULL_SYS_TYPES_H 1
+_EOF
+
+
+cat >>confdefs.h <<_EOF
+#define CARES_PULL_SYS_SOCKET_H 1
+_EOF
+
+      ;;
+  esac
+
+cat >>confdefs.h <<_EOF
+#define CARES_TYPEOF_ARES_SOCKLEN_T $cares_typeof_ares_socklen_t
+_EOF
+
+
+cat >>confdefs.h <<_EOF
+#define CARES_SIZEOF_ARES_SOCKLEN_T $cares_sizeof_ares_socklen_t
+_EOF
+
+
+
+
+  ac_fn_c_check_type "$LINENO" "in_addr_t" "ac_cv_type_in_addr_t" "
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#endif
+
+"
+if test "x$ac_cv_type_in_addr_t" = xyes
+then :
+
+else $as_nop
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for in_addr_t equivalent" >&5
+printf %s "checking for in_addr_t equivalent... " >&6; }
+if test ${curl_cv_in_addr_t_equiv+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+      curl_cv_in_addr_t_equiv="unknown"
+      for t in "unsigned long" int size_t unsigned long; do
+        if test "$curl_cv_in_addr_t_equiv" = "unknown"; then
+          cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+              $t data = inet_addr ("1.2.3.4");
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+            curl_cv_in_addr_t_equiv="$t"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+        fi
+      done
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $curl_cv_in_addr_t_equiv" >&5
+printf "%s\n" "$curl_cv_in_addr_t_equiv" >&6; }
+    case "$curl_cv_in_addr_t_equiv" in
+      unknown)
+        as_fn_error $? "Cannot find a type to use in place of in_addr_t" "$LINENO" 5
+        ;;
+      *)
+
+printf "%s\n" "#define in_addr_t $curl_cv_in_addr_t_equiv" >>confdefs.h
+
+        ;;
+    esac
+
+fi
+
+
+
+
+   ac_fn_c_check_type "$LINENO" "struct sockaddr_storage" "ac_cv_type_struct_sockaddr_storage" "
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#endif
+
+"
+if test "x$ac_cv_type_struct_sockaddr_storage" = xyes
+then :
+
+printf "%s\n" "#define HAVE_STRUCT_SOCKADDR_STORAGE 1" >>confdefs.h
+
+fi
+
+
+
+
+  ac_fn_c_check_header_compile "$LINENO" "signal.h" "ac_cv_header_signal_h" "$ac_includes_default"
+if test "x$ac_cv_header_signal_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SIGNAL_H 1" >>confdefs.h
+
+fi
+
+  ac_fn_c_check_type "$LINENO" "sig_atomic_t" "ac_cv_type_sig_atomic_t" "
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+"
+if test "x$ac_cv_type_sig_atomic_t" = xyes
+then :
+
+
+printf "%s\n" "#define HAVE_SIG_ATOMIC_T 1" >>confdefs.h
+
+
+fi
+
+  case "$ac_cv_type_sig_atomic_t" in
+    yes)
+      #
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if sig_atomic_t is already defined as volatile" >&5
+printf %s "checking if sig_atomic_t is already defined as volatile... " >&6; }
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+int
+main (void)
+{
+
+          static volatile sig_atomic_t dummy = 0;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        ac_cv_sig_atomic_t_volatile="no"
+
+else $as_nop
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+        ac_cv_sig_atomic_t_volatile="yes"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+      #
+      if test "$ac_cv_sig_atomic_t_volatile" = "yes"; then
+
+printf "%s\n" "#define HAVE_SIG_ATOMIC_T_VOLATILE 1" >>confdefs.h
+
+      fi
+      ;;
+  esac
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking return type of signal handlers" >&5
+printf %s "checking return type of signal handlers... " >&6; }
+if test ${ac_cv_type_signal+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+#include <signal.h>
+
+int
+main (void)
+{
+return *(signal (0, 0)) (0) == 1;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_type_signal=int
+else $as_nop
+  ac_cv_type_signal=void
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_signal" >&5
+printf "%s\n" "$ac_cv_type_signal" >&6; }
+
+printf "%s\n" "#define RETSIGTYPE $ac_cv_type_signal" >>confdefs.h
+
+
+
+
+      ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for recv" >&5
+printf %s "checking for recv... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+      recv(0, 0, 0, 0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    curl_cv_recv="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    curl_cv_recv="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$curl_cv_recv" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking types of args and return type for recv" >&5
+printf %s "checking types of args and return type for recv... " >&6; }
+if test ${curl_cv_func_recv_args+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+      curl_cv_func_recv_args="unknown"
+      for recv_retv in 'int' 'ssize_t'; do
+        for recv_arg1 in 'int' 'ssize_t' 'SOCKET'; do
+          for recv_arg2 in 'char *' 'void *'; do
+            for recv_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
+              for recv_arg4 in 'int' 'unsigned int'; do
+                if test "$curl_cv_func_recv_args" = "unknown"; then
+                  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#define RECVCALLCONV PASCAL
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#define RECVCALLCONV
+#endif
+                      extern $recv_retv RECVCALLCONV
+                      recv($recv_arg1, $recv_arg2, $recv_arg3, $recv_arg4);
+
+int
+main (void)
+{
+
+                      $recv_arg1 s=0;
+                      $recv_arg2 buf=0;
+                      $recv_arg3 len=0;
+                      $recv_arg4 flags=0;
+                      $recv_retv res = recv(s, buf, len, flags);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+                    curl_cv_func_recv_args="$recv_arg1,$recv_arg2,$recv_arg3,$recv_arg4,$recv_retv"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+                fi
+              done
+            done
+          done
+        done
+      done
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $curl_cv_func_recv_args" >&5
+printf "%s\n" "$curl_cv_func_recv_args" >&6; } # AC-CACHE-CHECK
+    if test "$curl_cv_func_recv_args" = "unknown"; then
+      as_fn_error $? "Cannot find proper types to use for recv args" "$LINENO" 5
+    else
+      recv_prev_IFS=$IFS; IFS=','
+      set dummy `echo "$curl_cv_func_recv_args" | sed 's/\*/\*/g'`
+      IFS=$recv_prev_IFS
+      shift
+      #
+
+printf "%s\n" "#define RECV_TYPE_ARG1 $1" >>confdefs.h
+
+
+printf "%s\n" "#define RECV_TYPE_ARG2 $2" >>confdefs.h
+
+
+printf "%s\n" "#define RECV_TYPE_ARG3 $3" >>confdefs.h
+
+
+printf "%s\n" "#define RECV_TYPE_ARG4 $4" >>confdefs.h
+
+
+printf "%s\n" "#define RECV_TYPE_RETV $5" >>confdefs.h
+
+      #
+
+printf "%s\n" "#define HAVE_RECV 1" >>confdefs.h
+
+      ac_cv_func_recv="yes"
+    fi
+  else
+    as_fn_error $? "Unable to link function recv" "$LINENO" 5
+  fi
+
+
+      ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for recvfrom" >&5
+printf %s "checking for recvfrom... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+      recvfrom(0, 0, 0, 0, 0, 0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    curl_cv_recvfrom="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    curl_cv_recvfrom="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$curl_cv_recvfrom" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking types of args and return type for recvfrom" >&5
+printf %s "checking types of args and return type for recvfrom... " >&6; }
+if test ${curl_cv_func_recvfrom_args+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+      curl_cv_func_recvfrom_args="unknown"
+      for recvfrom_retv in 'int' 'ssize_t'; do
+        for recvfrom_arg1 in 'int' 'ssize_t' 'SOCKET'; do
+          for recvfrom_arg2 in 'char *' 'void *'; do
+            for recvfrom_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
+              for recvfrom_arg4 in 'int' 'unsigned int'; do
+                for recvfrom_arg5 in 'struct sockaddr *' 'void *' 'const struct sockaddr *'; do
+                  for recvfrom_arg6 in 'socklen_t *' 'int *' 'unsigned int *' 'size_t *' 'void *'; do
+                    if test "$curl_cv_func_recvfrom_args" = "unknown"; then
+                      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#define RECVFROMCALLCONV PASCAL
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#define RECVFROMCALLCONV
+#endif
+                          extern $recvfrom_retv RECVFROMCALLCONV
+                          recvfrom($recvfrom_arg1, $recvfrom_arg2,
+                                   $recvfrom_arg3, $recvfrom_arg4,
+                                   $recvfrom_arg5, $recvfrom_arg6);
+
+int
+main (void)
+{
+
+                          $recvfrom_arg1 s=0;
+                          $recvfrom_arg2 buf=0;
+                          $recvfrom_arg3 len=0;
+                          $recvfrom_arg4 flags=0;
+                          $recvfrom_arg5 addr=0;
+                          $recvfrom_arg6 addrlen=0;
+                          $recvfrom_retv res=0;
+                          res = recvfrom(s, buf, len, flags, addr, addrlen);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+                        curl_cv_func_recvfrom_args="$recvfrom_arg1,$recvfrom_arg2,$recvfrom_arg3,$recvfrom_arg4,$recvfrom_arg5,$recvfrom_arg6,$recvfrom_retv"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+                    fi
+                  done
+                done
+              done
+            done
+          done
+        done
+      done
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $curl_cv_func_recvfrom_args" >&5
+printf "%s\n" "$curl_cv_func_recvfrom_args" >&6; } # AC-CACHE-CHECK
+    # Nearly last minute change for this release starts here
+
+printf "%s\n" "#define HAVE_RECVFROM 1" >>confdefs.h
+
+    ac_cv_func_recvfrom="yes"
+    # Nearly last minute change for this release ends here
+    if test "$curl_cv_func_recvfrom_args" = "unknown"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Cannot find proper types to use for recvfrom args" >&5
+printf "%s\n" "$as_me: WARNING: Cannot find proper types to use for recvfrom args" >&2;}
+    else
+      recvfrom_prev_IFS=$IFS; IFS=','
+      set dummy `echo "$curl_cv_func_recvfrom_args" | sed 's/\*/\*/g'`
+      IFS=$recvfrom_prev_IFS
+      shift
+      #
+      recvfrom_ptrt_arg2=$2
+      recvfrom_qual_ptrt_arg5=$5
+      recvfrom_ptrt_arg6=$6
+      #
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG1 $1" >>confdefs.h
+
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG3 $3" >>confdefs.h
+
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG4 $4" >>confdefs.h
+
+
+printf "%s\n" "#define RECVFROM_TYPE_RETV $7" >>confdefs.h
+
+      #
+      prev_sh_opts=$-
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set -f
+          ;;
+      esac
+      #
+      case "$recvfrom_qual_ptrt_arg5" in
+        const*)
+          recvfrom_qual_arg5=const
+          recvfrom_ptrt_arg5=`echo $recvfrom_qual_ptrt_arg5 | sed 's/^const //'`
+        ;;
+        *)
+          recvfrom_qual_arg5=
+          recvfrom_ptrt_arg5=$recvfrom_qual_ptrt_arg5
+        ;;
+      esac
+      #
+      recvfrom_type_arg2=`echo $recvfrom_ptrt_arg2 | sed 's/ \*//'`
+      recvfrom_type_arg5=`echo $recvfrom_ptrt_arg5 | sed 's/ \*//'`
+      recvfrom_type_arg6=`echo $recvfrom_ptrt_arg6 | sed 's/ \*//'`
+      #
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG2 $recvfrom_type_arg2" >>confdefs.h
+
+
+printf "%s\n" "#define RECVFROM_QUAL_ARG5 $recvfrom_qual_arg5" >>confdefs.h
+
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG5 $recvfrom_type_arg5" >>confdefs.h
+
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG6 $recvfrom_type_arg6" >>confdefs.h
+
+      #
+      if test "$recvfrom_type_arg2" = "void"; then
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG2_IS_VOID 1" >>confdefs.h
+
+      fi
+      if test "$recvfrom_type_arg5" = "void"; then
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG5_IS_VOID 1" >>confdefs.h
+
+      fi
+      if test "$recvfrom_type_arg6" = "void"; then
+
+printf "%s\n" "#define RECVFROM_TYPE_ARG6_IS_VOID 1" >>confdefs.h
+
+      fi
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set +f
+          ;;
+      esac
+      #
+
+printf "%s\n" "#define HAVE_RECVFROM 1" >>confdefs.h
+
+      ac_cv_func_recvfrom="yes"
+    fi
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Unable to link function recvfrom" >&5
+printf "%s\n" "$as_me: WARNING: Unable to link function recvfrom" >&2;}
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Your system will be vulnerable to some forms of DNS cache poisoning" >&5
+printf "%s\n" "$as_me: WARNING: Your system will be vulnerable to some forms of DNS cache poisoning" >&2;}
+  fi
+
+
+      ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for send" >&5
+printf %s "checking for send... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+      send(0, 0, 0, 0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    curl_cv_send="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    curl_cv_send="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$curl_cv_send" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking types of args and return type for send" >&5
+printf %s "checking types of args and return type for send... " >&6; }
+if test ${curl_cv_func_send_args+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+      curl_cv_func_send_args="unknown"
+      for send_retv in 'int' 'ssize_t'; do
+        for send_arg1 in 'int' 'ssize_t' 'SOCKET'; do
+          for send_arg2 in 'char *' 'void *' 'const char *' 'const void *'; do
+            for send_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
+              for send_arg4 in 'int' 'unsigned int'; do
+                if test "$curl_cv_func_send_args" = "unknown"; then
+                  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#define SENDCALLCONV PASCAL
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#define SENDCALLCONV
+#endif
+                      extern $send_retv SENDCALLCONV
+                      send($send_arg1, $send_arg2, $send_arg3, $send_arg4);
+
+int
+main (void)
+{
+
+                      $send_arg1 s=0;
+                      $send_arg3 len=0;
+                      $send_arg4 flags=0;
+                      $send_retv res = send(s, 0, len, flags);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+                    curl_cv_func_send_args="$send_arg1,$send_arg2,$send_arg3,$send_arg4,$send_retv"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+                fi
+              done
+            done
+          done
+        done
+      done
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $curl_cv_func_send_args" >&5
+printf "%s\n" "$curl_cv_func_send_args" >&6; } # AC-CACHE-CHECK
+    if test "$curl_cv_func_send_args" = "unknown"; then
+      as_fn_error $? "Cannot find proper types to use for send args" "$LINENO" 5
+    else
+      send_prev_IFS=$IFS; IFS=','
+      set dummy `echo "$curl_cv_func_send_args" | sed 's/\*/\*/g'`
+      IFS=$send_prev_IFS
+      shift
+      #
+      send_qual_type_arg2=$2
+      #
+
+printf "%s\n" "#define SEND_TYPE_ARG1 $1" >>confdefs.h
+
+
+printf "%s\n" "#define SEND_TYPE_ARG3 $3" >>confdefs.h
+
+
+printf "%s\n" "#define SEND_TYPE_ARG4 $4" >>confdefs.h
+
+
+printf "%s\n" "#define SEND_TYPE_RETV $5" >>confdefs.h
+
+      #
+      prev_sh_opts=$-
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set -f
+          ;;
+      esac
+      #
+      case "$send_qual_type_arg2" in
+        const*)
+          send_qual_arg2=const
+          send_type_arg2=`echo $send_qual_type_arg2 | sed 's/^const //'`
+        ;;
+        *)
+          send_qual_arg2=
+          send_type_arg2=$send_qual_type_arg2
+        ;;
+      esac
+      #
+
+printf "%s\n" "#define SEND_QUAL_ARG2 $send_qual_arg2" >>confdefs.h
+
+
+printf "%s\n" "#define SEND_TYPE_ARG2 $send_type_arg2" >>confdefs.h
+
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set +f
+          ;;
+      esac
+      #
+
+printf "%s\n" "#define HAVE_SEND 1" >>confdefs.h
+
+      ac_cv_func_send="yes"
+    fi
+  else
+    as_fn_error $? "Unable to link function send" "$LINENO" 5
+  fi
+
+
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MSG_NOSIGNAL" >&5
+printf %s "checking for MSG_NOSIGNAL... " >&6; }
+if test ${ac_cv_msg_nosignal+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+        int flag=MSG_NOSIGNAL;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      ac_cv_msg_nosignal="yes"
+
+else $as_nop
+
+      ac_cv_msg_nosignal="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_msg_nosignal" >&5
+printf "%s\n" "$ac_cv_msg_nosignal" >&6; }
+  case "$ac_cv_msg_nosignal" in
+    yes)
+
+printf "%s\n" "#define HAVE_MSG_NOSIGNAL 1" >>confdefs.h
+
+      ;;
+  esac
+
+
+
+cares_includes_socket="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SOCKET_H
+#  include <socket.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_socket
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "socket.h" "ac_cv_header_socket_h" "$cares_includes_socket
+"
+if test "x$ac_cv_header_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SOCKET_H 1" >>confdefs.h
+
+fi
+
+
+
+      #
+  tst_links_closesocket="unknown"
+  tst_proto_closesocket="unknown"
+  tst_compi_closesocket="unknown"
+  tst_allow_closesocket="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if closesocket can be linked" >&5
+printf %s "checking if closesocket can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_winsock2
+      $cares_includes_socket
+
+int
+main (void)
+{
+
+      if(0 != closesocket(0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_closesocket="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_closesocket="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_closesocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if closesocket is prototyped" >&5
+printf %s "checking if closesocket is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_winsock2
+      $cares_includes_socket
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "closesocket" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_closesocket="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_closesocket="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_closesocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if closesocket is compilable" >&5
+printf %s "checking if closesocket is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+        $cares_includes_socket
+
+int
+main (void)
+{
+
+        if(0 != closesocket(0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_closesocket="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_closesocket="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_closesocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if closesocket usage allowed" >&5
+printf %s "checking if closesocket usage allowed... " >&6; }
+    if test "x$cares_disallow_closesocket" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_closesocket="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_closesocket="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if closesocket might be used" >&5
+printf %s "checking if closesocket might be used... " >&6; }
+  if test "$tst_links_closesocket" = "yes" &&
+     test "$tst_proto_closesocket" = "yes" &&
+     test "$tst_compi_closesocket" = "yes" &&
+     test "$tst_allow_closesocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_CLOSESOCKET 1" >>confdefs.h
+
+    ac_cv_func_closesocket="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_closesocket="no"
+  fi
+
+
+    #
+  tst_links_closesocket_camel="unknown"
+  tst_proto_closesocket_camel="unknown"
+  tst_compi_closesocket_camel="unknown"
+  tst_allow_closesocket_camel="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CloseSocket can be linked" >&5
+printf %s "checking if CloseSocket can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_sys_socket
+
+int
+main (void)
+{
+
+      if(0 != CloseSocket(0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_closesocket_camel="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_closesocket_camel="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_closesocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CloseSocket is prototyped" >&5
+printf %s "checking if CloseSocket is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_sys_socket
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "CloseSocket" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_closesocket_camel="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_closesocket_camel="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_closesocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CloseSocket is compilable" >&5
+printf %s "checking if CloseSocket is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_sys_socket
+
+int
+main (void)
+{
+
+        if(0 != CloseSocket(0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_closesocket_camel="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_closesocket_camel="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_closesocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CloseSocket usage allowed" >&5
+printf %s "checking if CloseSocket usage allowed... " >&6; }
+    if test "x$cares_disallow_closesocket_camel" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_closesocket_camel="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_closesocket_camel="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CloseSocket might be used" >&5
+printf %s "checking if CloseSocket might be used... " >&6; }
+  if test "$tst_links_closesocket_camel" = "yes" &&
+     test "$tst_proto_closesocket_camel" = "yes" &&
+     test "$tst_compi_closesocket_camel" = "yes" &&
+     test "$tst_allow_closesocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_CLOSESOCKET_CAMEL 1" >>confdefs.h
+
+    ac_cv_func_closesocket_camel="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_closesocket_camel="no"
+  fi
+
+
+        #
+  tst_links_connect="unknown"
+  tst_proto_connect="unknown"
+  tst_compi_connect="unknown"
+  tst_allow_connect="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if connect can be linked" >&5
+printf %s "checking if connect can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+
+int
+main (void)
+{
+
+      if(0 != connect(0, 0, 0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_connect="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_connect="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_connect" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if connect is prototyped" >&5
+printf %s "checking if connect is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "connect" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_connect="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_connect="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_connect" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if connect is compilable" >&5
+printf %s "checking if connect is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+        $cares_includes_socket
+
+int
+main (void)
+{
+
+        if(0 != connect(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_connect="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_connect="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_connect" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if connect usage allowed" >&5
+printf %s "checking if connect usage allowed... " >&6; }
+    if test "x$cares_disallow_connect" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_connect="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_connect="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if connect might be used" >&5
+printf %s "checking if connect might be used... " >&6; }
+  if test "$tst_links_connect" = "yes" &&
+     test "$tst_proto_connect" = "yes" &&
+     test "$tst_compi_connect" = "yes" &&
+     test "$tst_allow_connect" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_CONNECT 1" >>confdefs.h
+
+    ac_cv_func_connect="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_connect="no"
+  fi
+
+
+cares_includes_fcntl="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#  include <fcntl.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_fcntl
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "unistd.h" "ac_cv_header_unistd_h" "$cares_includes_fcntl
+"
+if test "x$ac_cv_header_unistd_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_UNISTD_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "fcntl.h" "ac_cv_header_fcntl_h" "$cares_includes_fcntl
+"
+if test "x$ac_cv_header_fcntl_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_FCNTL_H 1" >>confdefs.h
+
+fi
+
+
+
+    #
+  tst_links_fcntl="unknown"
+  tst_proto_fcntl="unknown"
+  tst_compi_fcntl="unknown"
+  tst_allow_fcntl="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fcntl can be linked" >&5
+printf %s "checking if fcntl can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define fcntl to an innocuous variant, in case <limits.h> declares fcntl.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define fcntl innocuous_fcntl
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char fcntl (); below.  */
+
+#include <limits.h>
+#undef fcntl
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char fcntl ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_fcntl || defined __stub___fcntl
+choke me
+#endif
+
+int
+main (void)
+{
+return fcntl ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_fcntl="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_fcntl="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_fcntl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fcntl is prototyped" >&5
+printf %s "checking if fcntl is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_fcntl
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "fcntl" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_fcntl="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_fcntl="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_fcntl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fcntl is compilable" >&5
+printf %s "checking if fcntl is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_fcntl
+
+int
+main (void)
+{
+
+        if(0 != fcntl(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_fcntl="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_fcntl="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_fcntl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fcntl usage allowed" >&5
+printf %s "checking if fcntl usage allowed... " >&6; }
+    if test "x$cares_disallow_fcntl" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_fcntl="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_fcntl="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fcntl might be used" >&5
+printf %s "checking if fcntl might be used... " >&6; }
+  if test "$tst_links_fcntl" = "yes" &&
+     test "$tst_proto_fcntl" = "yes" &&
+     test "$tst_compi_fcntl" = "yes" &&
+     test "$tst_allow_fcntl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_FCNTL 1" >>confdefs.h
+
+    ac_cv_func_fcntl="yes"
+
+  #
+  tst_compi_fcntl_o_nonblock="unknown"
+  tst_allow_fcntl_o_nonblock="unknown"
+  #
+  case $host_os in
+    sunos4* | aix3* | beos*)
+            cares_disallow_fcntl_o_nonblock="yes"
+      ;;
+  esac
+  #
+  if test "$ac_cv_func_fcntl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fcntl O_NONBLOCK is compilable" >&5
+printf %s "checking if fcntl O_NONBLOCK is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_fcntl
+
+int
+main (void)
+{
+
+        int flags = 0;
+        if(0 != fcntl(0, F_SETFL, flags | O_NONBLOCK))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_fcntl_o_nonblock="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_fcntl_o_nonblock="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_fcntl_o_nonblock" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fcntl O_NONBLOCK usage allowed" >&5
+printf %s "checking if fcntl O_NONBLOCK usage allowed... " >&6; }
+    if test "x$cares_disallow_fcntl_o_nonblock" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_fcntl_o_nonblock="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_fcntl_o_nonblock="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fcntl O_NONBLOCK might be used" >&5
+printf %s "checking if fcntl O_NONBLOCK might be used... " >&6; }
+  if test "$tst_compi_fcntl_o_nonblock" = "yes" &&
+     test "$tst_allow_fcntl_o_nonblock" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_FCNTL_O_NONBLOCK 1" >>confdefs.h
+
+    ac_cv_func_fcntl_o_nonblock="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_fcntl_o_nonblock="no"
+  fi
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_fcntl="no"
+  fi
+
+
+cares_includes_netdb="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_netdb
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "netdb.h" "ac_cv_header_netdb_h" "$cares_includes_netdb
+"
+if test "x$ac_cv_header_netdb_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_NETDB_H 1" >>confdefs.h
+
+fi
+
+
+
+        #
+  tst_links_freeaddrinfo="unknown"
+  tst_proto_freeaddrinfo="unknown"
+  tst_compi_freeaddrinfo="unknown"
+  tst_allow_freeaddrinfo="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if freeaddrinfo can be linked" >&5
+printf %s "checking if freeaddrinfo can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+
+int
+main (void)
+{
+
+      freeaddrinfo(0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_freeaddrinfo="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_freeaddrinfo="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_freeaddrinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if freeaddrinfo is prototyped" >&5
+printf %s "checking if freeaddrinfo is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "freeaddrinfo" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_freeaddrinfo="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_freeaddrinfo="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_freeaddrinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if freeaddrinfo is compilable" >&5
+printf %s "checking if freeaddrinfo is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_ws2tcpip
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+
+int
+main (void)
+{
+
+        freeaddrinfo(0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_freeaddrinfo="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_freeaddrinfo="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_freeaddrinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if freeaddrinfo usage allowed" >&5
+printf %s "checking if freeaddrinfo usage allowed... " >&6; }
+    if test "x$cares_disallow_freeaddrinfo" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_freeaddrinfo="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_freeaddrinfo="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if freeaddrinfo might be used" >&5
+printf %s "checking if freeaddrinfo might be used... " >&6; }
+  if test "$tst_links_freeaddrinfo" = "yes" &&
+     test "$tst_proto_freeaddrinfo" = "yes" &&
+     test "$tst_compi_freeaddrinfo" = "yes" &&
+     test "$tst_allow_freeaddrinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_FREEADDRINFO 1" >>confdefs.h
+
+    ac_cv_func_freeaddrinfo="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_freeaddrinfo="no"
+  fi
+
+
+cares_includes_stdlib="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_stdlib
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$cares_includes_stdlib
+"
+if test "x$ac_cv_header_stdlib_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_STDLIB_H 1" >>confdefs.h
+
+fi
+
+
+
+cares_includes_string="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_STRING_H
+#  include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_string
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "string.h" "ac_cv_header_string_h" "$cares_includes_string
+"
+if test "x$ac_cv_header_string_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_STRING_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "strings.h" "ac_cv_header_strings_h" "$cares_includes_string
+"
+if test "x$ac_cv_header_strings_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_STRINGS_H 1" >>confdefs.h
+
+fi
+
+
+
+              #
+  tst_links_getaddrinfo="unknown"
+  tst_proto_getaddrinfo="unknown"
+  tst_compi_getaddrinfo="unknown"
+  tst_works_getaddrinfo="unknown"
+  tst_allow_getaddrinfo="unknown"
+  tst_tsafe_getaddrinfo="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getaddrinfo can be linked" >&5
+printf %s "checking if getaddrinfo can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+
+int
+main (void)
+{
+
+      if(0 != getaddrinfo(0, 0, 0, 0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_getaddrinfo="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_getaddrinfo="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_getaddrinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getaddrinfo is prototyped" >&5
+printf %s "checking if getaddrinfo is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getaddrinfo" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_getaddrinfo="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_getaddrinfo="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_getaddrinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getaddrinfo is compilable" >&5
+printf %s "checking if getaddrinfo is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_ws2tcpip
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+
+int
+main (void)
+{
+
+        if(0 != getaddrinfo(0, 0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_getaddrinfo="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_getaddrinfo="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+    if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_getaddrinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getaddrinfo seems to work" >&5
+printf %s "checking if getaddrinfo seems to work... " >&6; }
+    if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_ws2tcpip
+        $cares_includes_stdlib
+        $cares_includes_string
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+
+int
+main (void)
+{
+
+        struct addrinfo hints;
+        struct addrinfo *ai = 0;
+        int error;
+
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_flags = AI_NUMERICHOST;
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        error = getaddrinfo("127.0.0.1", 0, &hints, &ai);
+        if(error || !ai)
+          exit(1); /* fail */
+        else
+          exit(0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_works_getaddrinfo="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_works_getaddrinfo="no"
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+  fi
+  #
+  if test "$tst_compi_getaddrinfo" = "yes" &&
+    test "$tst_works_getaddrinfo" != "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getaddrinfo usage allowed" >&5
+printf %s "checking if getaddrinfo usage allowed... " >&6; }
+    if test "x$cares_disallow_getaddrinfo" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_getaddrinfo="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_getaddrinfo="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getaddrinfo might be used" >&5
+printf %s "checking if getaddrinfo might be used... " >&6; }
+  if test "$tst_links_getaddrinfo" = "yes" &&
+     test "$tst_proto_getaddrinfo" = "yes" &&
+     test "$tst_compi_getaddrinfo" = "yes" &&
+     test "$tst_allow_getaddrinfo" = "yes" &&
+     test "$tst_works_getaddrinfo" != "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_GETADDRINFO 1" >>confdefs.h
+
+    ac_cv_func_getaddrinfo="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_getaddrinfo="no"
+    ac_cv_func_getaddrinfo_threadsafe="no"
+  fi
+  #
+  if test "$ac_cv_func_getaddrinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getaddrinfo is threadsafe" >&5
+printf %s "checking if getaddrinfo is threadsafe... " >&6; }
+    case $host_os in
+      aix[1234].* | aix5.[01].*)
+                tst_tsafe_getaddrinfo="no"
+        ;;
+      aix*)
+                tst_tsafe_getaddrinfo="yes"
+        ;;
+      darwin[12345].*)
+                tst_tsafe_getaddrinfo="no"
+        ;;
+      darwin*)
+                tst_tsafe_getaddrinfo="yes"
+        ;;
+      freebsd[1234].* | freebsd5.[1234]*)
+                tst_tsafe_getaddrinfo="no"
+        ;;
+      freebsd*)
+                tst_tsafe_getaddrinfo="yes"
+        ;;
+      hpux[123456789].* | hpux10.* | hpux11.0* | hpux11.10*)
+                tst_tsafe_getaddrinfo="no"
+        ;;
+      hpux*)
+                tst_tsafe_getaddrinfo="yes"
+        ;;
+      netbsd[123].*)
+                tst_tsafe_getaddrinfo="no"
+        ;;
+      netbsd*)
+                tst_tsafe_getaddrinfo="yes"
+        ;;
+      *bsd*)
+                tst_tsafe_getaddrinfo="no"
+        ;;
+      solaris2*)
+                tst_tsafe_getaddrinfo="yes"
+        ;;
+    esac
+    if test "$tst_tsafe_getaddrinfo" = "unknown" &&
+       test "$ac_cv_native_windows" = "yes"; then
+      tst_tsafe_getaddrinfo="yes"
+    fi
+    if test "$tst_tsafe_getaddrinfo" = "unknown"; then
+
+
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+
+int main (void)
+{
+#ifdef h_errno
+  return 0;
+#else
+  force compilation error
+#endif
+}
+
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+    tst_symbol_defined="yes"
+
+else $as_nop
+
+    tst_symbol_defined="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  if test "$tst_symbol_defined" = "yes"; then
+    curl_cv_have_def_h_errno=yes
+
+  else
+    curl_cv_have_def_h_errno=no
+
+  fi
+
+      if test "$curl_cv_have_def_h_errno" = "yes"; then
+        tst_h_errno_macro="yes"
+      else
+        tst_h_errno_macro="no"
+      fi
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+          $cares_includes_sys_socket
+          $cares_includes_netdb
+
+int
+main (void)
+{
+
+          h_errno = 2;
+          if(0 != h_errno)
+            return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+        tst_h_errno_modifiable_lvalue="yes"
+
+else $as_nop
+
+        tst_h_errno_modifiable_lvalue="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L)
+          return 0;
+#elif defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 700)
+          return 0;
+#else
+          force compilation error
+#endif
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+        tst_h_errno_sbs_issue_7="yes"
+
+else $as_nop
+
+        tst_h_errno_sbs_issue_7="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+      if test "$tst_h_errno_macro" = "no" &&
+         test "$tst_h_errno_modifiable_lvalue" = "no" &&
+         test "$tst_h_errno_sbs_issue_7" = "no"; then
+        tst_tsafe_getaddrinfo="no"
+      else
+        tst_tsafe_getaddrinfo="yes"
+      fi
+    fi
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tst_tsafe_getaddrinfo" >&5
+printf "%s\n" "$tst_tsafe_getaddrinfo" >&6; }
+    if test "$tst_tsafe_getaddrinfo" = "yes"; then
+
+printf "%s\n" "#define HAVE_GETADDRINFO_THREADSAFE 1" >>confdefs.h
+
+      ac_cv_func_getaddrinfo_threadsafe="yes"
+    else
+      ac_cv_func_getaddrinfo_threadsafe="no"
+    fi
+  fi
+
+
+    #
+  tst_links_getenv="unknown"
+  tst_proto_getenv="unknown"
+  tst_compi_getenv="unknown"
+  tst_allow_getenv="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getenv can be linked" >&5
+printf %s "checking if getenv can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define getenv to an innocuous variant, in case <limits.h> declares getenv.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define getenv innocuous_getenv
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char getenv (); below.  */
+
+#include <limits.h>
+#undef getenv
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char getenv ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_getenv || defined __stub___getenv
+choke me
+#endif
+
+int
+main (void)
+{
+return getenv ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_getenv="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_getenv="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_getenv" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getenv is prototyped" >&5
+printf %s "checking if getenv is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_stdlib
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getenv" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_getenv="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_getenv="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_getenv" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getenv is compilable" >&5
+printf %s "checking if getenv is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stdlib
+
+int
+main (void)
+{
+
+        if(0 != getenv(0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_getenv="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_getenv="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_getenv" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getenv usage allowed" >&5
+printf %s "checking if getenv usage allowed... " >&6; }
+    if test "x$cares_disallow_getenv" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_getenv="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_getenv="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getenv might be used" >&5
+printf %s "checking if getenv might be used... " >&6; }
+  if test "$tst_links_getenv" = "yes" &&
+     test "$tst_proto_getenv" = "yes" &&
+     test "$tst_compi_getenv" = "yes" &&
+     test "$tst_allow_getenv" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_GETENV 1" >>confdefs.h
+
+    ac_cv_func_getenv="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_getenv="no"
+  fi
+
+
+      #
+  tst_links_gethostbyaddr="unknown"
+  tst_proto_gethostbyaddr="unknown"
+  tst_compi_gethostbyaddr="unknown"
+  tst_allow_gethostbyaddr="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyaddr can be linked" >&5
+printf %s "checking if gethostbyaddr can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_winsock2
+      $cares_includes_netdb
+
+int
+main (void)
+{
+
+      if(0 != gethostbyaddr(0, 0, 0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_gethostbyaddr="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_gethostbyaddr="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_gethostbyaddr" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyaddr is prototyped" >&5
+printf %s "checking if gethostbyaddr is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_winsock2
+      $cares_includes_netdb
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gethostbyaddr" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_gethostbyaddr="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_gethostbyaddr="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_gethostbyaddr" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyaddr is compilable" >&5
+printf %s "checking if gethostbyaddr is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+        $cares_includes_netdb
+
+int
+main (void)
+{
+
+        if(0 != gethostbyaddr(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_gethostbyaddr="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_gethostbyaddr="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_gethostbyaddr" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyaddr usage allowed" >&5
+printf %s "checking if gethostbyaddr usage allowed... " >&6; }
+    if test "x$cares_disallow_gethostbyaddr" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_gethostbyaddr="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_gethostbyaddr="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyaddr might be used" >&5
+printf %s "checking if gethostbyaddr might be used... " >&6; }
+  if test "$tst_links_gethostbyaddr" = "yes" &&
+     test "$tst_proto_gethostbyaddr" = "yes" &&
+     test "$tst_compi_gethostbyaddr" = "yes" &&
+     test "$tst_allow_gethostbyaddr" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_GETHOSTBYADDR 1" >>confdefs.h
+
+    ac_cv_func_gethostbyaddr="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_gethostbyaddr="no"
+  fi
+
+
+      #
+  tst_links_gethostbyname="unknown"
+  tst_proto_gethostbyname="unknown"
+  tst_compi_gethostbyname="unknown"
+  tst_allow_gethostbyname="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyname can be linked" >&5
+printf %s "checking if gethostbyname can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_winsock2
+      $cares_includes_netdb
+
+int
+main (void)
+{
+
+      if(0 != gethostbyname(0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_gethostbyname="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_gethostbyname="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_gethostbyname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyname is prototyped" >&5
+printf %s "checking if gethostbyname is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_winsock2
+      $cares_includes_netdb
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gethostbyname" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_gethostbyname="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_gethostbyname="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_gethostbyname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyname is compilable" >&5
+printf %s "checking if gethostbyname is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+        $cares_includes_netdb
+
+int
+main (void)
+{
+
+        if(0 != gethostbyname(0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_gethostbyname="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_gethostbyname="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_gethostbyname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyname usage allowed" >&5
+printf %s "checking if gethostbyname usage allowed... " >&6; }
+    if test "x$cares_disallow_gethostbyname" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_gethostbyname="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_gethostbyname="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostbyname might be used" >&5
+printf %s "checking if gethostbyname might be used... " >&6; }
+  if test "$tst_links_gethostbyname" = "yes" &&
+     test "$tst_proto_gethostbyname" = "yes" &&
+     test "$tst_compi_gethostbyname" = "yes" &&
+     test "$tst_allow_gethostbyname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_GETHOSTBYNAME 1" >>confdefs.h
+
+    ac_cv_func_gethostbyname="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_gethostbyname="no"
+  fi
+
+
+cares_includes_unistd="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_unistd
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "unistd.h" "ac_cv_header_unistd_h" "$cares_includes_unistd
+"
+if test "x$ac_cv_header_unistd_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_UNISTD_H 1" >>confdefs.h
+
+fi
+
+
+
+        #
+  tst_links_gethostname="unknown"
+  tst_proto_gethostname="unknown"
+  tst_compi_gethostname="unknown"
+  tst_allow_gethostname="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostname can be linked" >&5
+printf %s "checking if gethostname can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_winsock2
+      $cares_includes_unistd
+
+int
+main (void)
+{
+
+      if(0 != gethostname(0, 0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_gethostname="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_gethostname="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_gethostname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostname is prototyped" >&5
+printf %s "checking if gethostname is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_winsock2
+      $cares_includes_unistd
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "gethostname" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_gethostname="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_gethostname="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_gethostname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostname is compilable" >&5
+printf %s "checking if gethostname is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+        $cares_includes_unistd
+
+int
+main (void)
+{
+
+        if(0 != gethostname(0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_gethostname="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_gethostname="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_gethostname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostname arg 2 data type" >&5
+printf %s "checking for gethostname arg 2 data type... " >&6; }
+    tst_gethostname_type_arg2="unknown"
+    for tst_arg1 in 'char *' 'unsigned char *' 'void *'; do
+      for tst_arg2 in 'int' 'unsigned int' 'size_t'; do
+        if test "$tst_gethostname_type_arg2" = "unknown"; then
+          cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+              $cares_includes_winsock2
+              $cares_includes_unistd
+              $cares_preprocess_callconv
+              extern int FUNCALLCONV gethostname($tst_arg1, $tst_arg2);
+
+int
+main (void)
+{
+
+              if(0 != gethostname(0, 0))
+                return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+            tst_gethostname_type_arg2="$tst_arg2"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+        fi
+      done
+    done
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tst_gethostname_type_arg2" >&5
+printf "%s\n" "$tst_gethostname_type_arg2" >&6; }
+    if test "$tst_gethostname_type_arg2" != "unknown"; then
+
+printf "%s\n" "#define GETHOSTNAME_TYPE_ARG2 $tst_gethostname_type_arg2" >>confdefs.h
+
+    fi
+  fi
+  #
+  if test "$tst_compi_gethostname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostname usage allowed" >&5
+printf %s "checking if gethostname usage allowed... " >&6; }
+    if test "x$cares_disallow_gethostname" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_gethostname="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_gethostname="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if gethostname might be used" >&5
+printf %s "checking if gethostname might be used... " >&6; }
+  if test "$tst_links_gethostname" = "yes" &&
+     test "$tst_proto_gethostname" = "yes" &&
+     test "$tst_compi_gethostname" = "yes" &&
+     test "$tst_allow_gethostname" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_GETHOSTNAME 1" >>confdefs.h
+
+    ac_cv_func_gethostname="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_gethostname="no"
+  fi
+
+
+    #
+  tst_links_getservbyport_r="unknown"
+  tst_proto_getservbyport_r="unknown"
+  tst_compi_getservbyport_r="unknown"
+  tst_allow_getservbyport_r="unknown"
+  tst_nargs_getservbyport_r="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getservbyport_r can be linked" >&5
+printf %s "checking if getservbyport_r can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define getservbyport_r to an innocuous variant, in case <limits.h> declares getservbyport_r.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define getservbyport_r innocuous_getservbyport_r
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char getservbyport_r (); below.  */
+
+#include <limits.h>
+#undef getservbyport_r
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char getservbyport_r ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_getservbyport_r || defined __stub___getservbyport_r
+choke me
+#endif
+
+int
+main (void)
+{
+return getservbyport_r ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_getservbyport_r="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_getservbyport_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_getservbyport_r" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getservbyport_r is prototyped" >&5
+printf %s "checking if getservbyport_r is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_netdb
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getservbyport_r" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_getservbyport_r="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_getservbyport_r="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_getservbyport_r" = "yes"; then
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getservbyport_r takes 4 args." >&5
+printf %s "checking if getservbyport_r takes 4 args.... " >&6; }
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+          $cares_includes_netdb
+
+int
+main (void)
+{
+
+          if(0 != getservbyport_r(0, 0, 0, 0))
+            return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="4"
+
+else $as_nop
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        tst_compi_getservbyport_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    fi
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getservbyport_r takes 5 args." >&5
+printf %s "checking if getservbyport_r takes 5 args.... " >&6; }
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+          $cares_includes_netdb
+
+int
+main (void)
+{
+
+          if(0 != getservbyport_r(0, 0, 0, 0, 0))
+            return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="5"
+
+else $as_nop
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        tst_compi_getservbyport_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    fi
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getservbyport_r takes 6 args." >&5
+printf %s "checking if getservbyport_r takes 6 args.... " >&6; }
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+          $cares_includes_netdb
+
+int
+main (void)
+{
+
+          if(0 != getservbyport_r(0, 0, 0, 0, 0, 0))
+            return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="6"
+
+else $as_nop
+
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+        tst_compi_getservbyport_r="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    fi
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getservbyport_r is compilable" >&5
+printf %s "checking if getservbyport_r is compilable... " >&6; }
+    if test "$tst_compi_getservbyport_r" = "yes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    fi
+  fi
+  #
+  if test "$tst_compi_getservbyport_r" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getservbyport_r usage allowed" >&5
+printf %s "checking if getservbyport_r usage allowed... " >&6; }
+    if test "x$cares_disallow_getservbyport_r" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_getservbyport_r="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_getservbyport_r="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if getservbyport_r might be used" >&5
+printf %s "checking if getservbyport_r might be used... " >&6; }
+  if test "$tst_links_getservbyport_r" = "yes" &&
+     test "$tst_proto_getservbyport_r" = "yes" &&
+     test "$tst_compi_getservbyport_r" = "yes" &&
+     test "$tst_allow_getservbyport_r" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_GETSERVBYPORT_R 1" >>confdefs.h
+
+
+printf "%s\n" "#define GETSERVBYPORT_R_ARGS $tst_nargs_getservbyport_r" >>confdefs.h
+
+    if test "$tst_nargs_getservbyport_r" -eq "4"; then
+
+printf "%s\n" "#define GETSERVBYPORT_R_BUFSIZE sizeof(struct servent_data)" >>confdefs.h
+
+    else
+
+printf "%s\n" "#define GETSERVBYPORT_R_BUFSIZE 4096" >>confdefs.h
+
+    fi
+    ac_cv_func_getservbyport_r="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_getservbyport_r="no"
+  fi
+
+
+cares_includes_arpa_inet="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_arpa_inet
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$cares_includes_arpa_inet
+"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "netinet/in.h" "ac_cv_header_netinet_in_h" "$cares_includes_arpa_inet
+"
+if test "x$ac_cv_header_netinet_in_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_NETINET_IN_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "arpa/inet.h" "ac_cv_header_arpa_inet_h" "$cares_includes_arpa_inet
+"
+if test "x$ac_cv_header_arpa_inet_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_ARPA_INET_H 1" >>confdefs.h
+
+fi
+
+
+
+        #
+  tst_links_inet_net_pton="unknown"
+  tst_proto_inet_net_pton="unknown"
+  tst_compi_inet_net_pton="unknown"
+  tst_works_inet_net_pton="unknown"
+  tst_allow_inet_net_pton="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_net_pton can be linked" >&5
+printf %s "checking if inet_net_pton can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define inet_net_pton to an innocuous variant, in case <limits.h> declares inet_net_pton.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define inet_net_pton innocuous_inet_net_pton
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char inet_net_pton (); below.  */
+
+#include <limits.h>
+#undef inet_net_pton
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char inet_net_pton ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_inet_net_pton || defined __stub___inet_net_pton
+choke me
+#endif
+
+int
+main (void)
+{
+return inet_net_pton ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_inet_net_pton="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_inet_net_pton="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_inet_net_pton" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_net_pton is prototyped" >&5
+printf %s "checking if inet_net_pton is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_arpa_inet
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "inet_net_pton" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_inet_net_pton="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_inet_net_pton="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_inet_net_pton" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_net_pton is compilable" >&5
+printf %s "checking if inet_net_pton is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_arpa_inet
+
+int
+main (void)
+{
+
+        if(0 != inet_net_pton(0, 0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_inet_net_pton="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_inet_net_pton="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+    if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_inet_net_pton" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_net_pton seems to work" >&5
+printf %s "checking if inet_net_pton seems to work... " >&6; }
+    if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stdlib
+        $cares_includes_arpa_inet
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        unsigned char ipv6a[16+1];
+        unsigned char ipv4a[4+1];
+        const char *ipv6net1 = "fe80::214:4fff:fe0b:76c8";
+        const char *ipv6net2 = "::fffe:7f00:1";
+        const char *ipv6net3 = "7f20:1::/64";
+        const char *ipv6net4 = "7f20:1::/2147483649";
+        const char *ipv4net1 = "192.168.100.1";
+        const char *ipv4net2 = "192.168.100/32";
+        const char *ipv4net3 = "192.168.100.1/2147483649";
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(32 != inet_net_pton(AF_INET, ipv4net1, ipv4a, 4))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv4a[0x00] != 0xc0) ||
+            (ipv4a[0x01] != 0xa8) ||
+            (ipv4a[0x02] != 0x64) ||
+            (ipv4a[0x03] != 0x01) ||
+            (ipv4a[0x04] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(32 != inet_net_pton(AF_INET, ipv4net2, ipv4a, 4))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv4a[0x00] != 0xc0) ||
+            (ipv4a[0x01] != 0xa8) ||
+            (ipv4a[0x02] != 0x64) ||
+            (ipv4a[0x03] != 0x00) ||
+            (ipv4a[0x04] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(-1 != inet_net_pton(AF_INET, ipv4net3, ipv4a, 4))
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(128 != inet_net_pton(AF_INET6, ipv6net1, ipv6a, 16))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0x00] != 0xfe) ||
+            (ipv6a[0x01] != 0x80) ||
+            (ipv6a[0x08] != 0x02) ||
+            (ipv6a[0x09] != 0x14) ||
+            (ipv6a[0x0a] != 0x4f) ||
+            (ipv6a[0x0b] != 0xff) ||
+            (ipv6a[0x0c] != 0xfe) ||
+            (ipv6a[0x0d] != 0x0b) ||
+            (ipv6a[0x0e] != 0x76) ||
+            (ipv6a[0x0f] != 0xc8) ||
+            (ipv6a[0x10] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0x02] != 0x0) ||
+            (ipv6a[0x03] != 0x0) ||
+            (ipv6a[0x04] != 0x0) ||
+            (ipv6a[0x05] != 0x0) ||
+            (ipv6a[0x06] != 0x0) ||
+            (ipv6a[0x07] != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 0, sizeof(ipv6a));
+        ipv6a[0x10] = 0x01;
+        if(128 != inet_net_pton(AF_INET6, ipv6net2, ipv6a, 16))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0x0a] != 0xff) ||
+            (ipv6a[0x0b] != 0xfe) ||
+            (ipv6a[0x0c] != 0x7f) ||
+            (ipv6a[0x0f] != 0x01) ||
+            (ipv6a[0x10] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0x00] != 0x0) ||
+            (ipv6a[0x01] != 0x0) ||
+            (ipv6a[0x02] != 0x0) ||
+            (ipv6a[0x03] != 0x0) ||
+            (ipv6a[0x04] != 0x0) ||
+            (ipv6a[0x05] != 0x0) ||
+            (ipv6a[0x06] != 0x0) ||
+            (ipv6a[0x07] != 0x0) ||
+            (ipv6a[0x08] != 0x0) ||
+            (ipv6a[0x09] != 0x0) ||
+            (ipv6a[0x0d] != 0x0) ||
+            (ipv6a[0x0e] != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(64 != inet_net_pton(AF_INET6, ipv6net3, ipv6a, 16))
+          exit(1); /* fail */
+        if( (ipv6a[0x00] != 0x7f) ||
+            (ipv6a[0x01] != 0x20) ||
+            (ipv6a[0x03] != 0x01) ||
+            (ipv6a[0x08] != 0x01) ||
+            (ipv6a[0x09] != 0x01) ||
+            (ipv6a[0x0a] != 0x01) ||
+            (ipv6a[0x0b] != 0x01) ||
+            (ipv6a[0x0c] != 0x01) ||
+            (ipv6a[0x0d] != 0x01) ||
+            (ipv6a[0x0e] != 0x01) ||
+            (ipv6a[0x0f] != 0x01) ||
+            (ipv6a[0x10] != 0x01) )
+          exit(1); /* fail */
+        if( (ipv6a[0x02] != 0x0) ||
+            (ipv6a[0x04] != 0x0) ||
+            (ipv6a[0x05] != 0x0) ||
+            (ipv6a[0x06] != 0x0) ||
+            (ipv6a[0x07] != 0x0) ||
+            (ipv6a[0x07] != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(-1 != inet_net_pton(AF_INET6, ipv6net4, ipv6a, 16))
+          exit(1); /* fail */
+        /* - */
+        exit(0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_works_inet_net_pton="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_works_inet_net_pton="no"
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+  fi
+  #
+  if test "$tst_compi_inet_net_pton" = "yes" &&
+    test "$tst_works_inet_net_pton" != "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_net_pton usage allowed" >&5
+printf %s "checking if inet_net_pton usage allowed... " >&6; }
+    if test "x$cares_disallow_inet_net_pton" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_inet_net_pton="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_inet_net_pton="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_net_pton might be used" >&5
+printf %s "checking if inet_net_pton might be used... " >&6; }
+  if test "$tst_links_inet_net_pton" = "yes" &&
+     test "$tst_proto_inet_net_pton" = "yes" &&
+     test "$tst_compi_inet_net_pton" = "yes" &&
+     test "$tst_allow_inet_net_pton" = "yes" &&
+     test "$tst_works_inet_net_pton" != "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_INET_NET_PTON 1" >>confdefs.h
+
+    ac_cv_func_inet_net_pton="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_inet_net_pton="no"
+  fi
+
+
+        #
+  tst_links_inet_ntop="unknown"
+  tst_proto_inet_ntop="unknown"
+  tst_compi_inet_ntop="unknown"
+  tst_works_inet_ntop="unknown"
+  tst_allow_inet_ntop="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_ntop can be linked" >&5
+printf %s "checking if inet_ntop can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define inet_ntop to an innocuous variant, in case <limits.h> declares inet_ntop.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define inet_ntop innocuous_inet_ntop
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char inet_ntop (); below.  */
+
+#include <limits.h>
+#undef inet_ntop
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char inet_ntop ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_inet_ntop || defined __stub___inet_ntop
+choke me
+#endif
+
+int
+main (void)
+{
+return inet_ntop ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_inet_ntop="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_inet_ntop="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_inet_ntop" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_ntop is prototyped" >&5
+printf %s "checking if inet_ntop is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_arpa_inet
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "inet_ntop" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_inet_ntop="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_inet_ntop="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_inet_ntop" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_ntop is compilable" >&5
+printf %s "checking if inet_ntop is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_arpa_inet
+
+int
+main (void)
+{
+
+        if(0 != inet_ntop(0, 0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_inet_ntop="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_inet_ntop="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+    if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_inet_ntop" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_ntop seems to work" >&5
+printf %s "checking if inet_ntop seems to work... " >&6; }
+    if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stdlib
+        $cares_includes_arpa_inet
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        char ipv6res[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
+        char ipv4res[sizeof "255.255.255.255"];
+        unsigned char ipv6a[26];
+        unsigned char ipv4a[5];
+        char *ipv6ptr = 0;
+        char *ipv4ptr = 0;
+        /* - */
+        ipv4res[0] = '\0';
+        ipv4a[0] = 0xc0;
+        ipv4a[1] = 0xa8;
+        ipv4a[2] = 0x64;
+        ipv4a[3] = 0x01;
+        ipv4a[4] = 0x01;
+        /* - */
+        ipv4ptr = inet_ntop(AF_INET, ipv4a, ipv4res, sizeof(ipv4res));
+        if(!ipv4ptr)
+          exit(1); /* fail */
+        if(ipv4ptr != ipv4res)
+          exit(1); /* fail */
+        if(!ipv4ptr[0])
+          exit(1); /* fail */
+        if(memcmp(ipv4res, "192.168.100.1", 13) != 0)
+          exit(1); /* fail */
+        /* - */
+        ipv6res[0] = '\0';
+        memset(ipv6a, 0, sizeof(ipv6a));
+        ipv6a[0] = 0xfe;
+        ipv6a[1] = 0x80;
+        ipv6a[8] = 0x02;
+        ipv6a[9] = 0x14;
+        ipv6a[10] = 0x4f;
+        ipv6a[11] = 0xff;
+        ipv6a[12] = 0xfe;
+        ipv6a[13] = 0x0b;
+        ipv6a[14] = 0x76;
+        ipv6a[15] = 0xc8;
+        ipv6a[25] = 0x01;
+        /* - */
+        ipv6ptr = inet_ntop(AF_INET6, ipv6a, ipv6res, sizeof(ipv6res));
+        if(!ipv6ptr)
+          exit(1); /* fail */
+        if(ipv6ptr != ipv6res)
+          exit(1); /* fail */
+        if(!ipv6ptr[0])
+          exit(1); /* fail */
+        if(memcmp(ipv6res, "fe80::214:4fff:fe0b:76c8", 24) != 0)
+          exit(1); /* fail */
+        /* - */
+        exit(0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_works_inet_ntop="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_works_inet_ntop="no"
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+  fi
+  #
+  if test "$tst_compi_inet_ntop" = "yes" &&
+    test "$tst_works_inet_ntop" != "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_ntop usage allowed" >&5
+printf %s "checking if inet_ntop usage allowed... " >&6; }
+    if test "x$cares_disallow_inet_ntop" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_inet_ntop="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_inet_ntop="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_ntop might be used" >&5
+printf %s "checking if inet_ntop might be used... " >&6; }
+  if test "$tst_links_inet_ntop" = "yes" &&
+     test "$tst_proto_inet_ntop" = "yes" &&
+     test "$tst_compi_inet_ntop" = "yes" &&
+     test "$tst_allow_inet_ntop" = "yes" &&
+     test "$tst_works_inet_ntop" != "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_INET_NTOP 1" >>confdefs.h
+
+    ac_cv_func_inet_ntop="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_inet_ntop="no"
+  fi
+
+
+        #
+  tst_links_inet_pton="unknown"
+  tst_proto_inet_pton="unknown"
+  tst_compi_inet_pton="unknown"
+  tst_works_inet_pton="unknown"
+  tst_allow_inet_pton="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_pton can be linked" >&5
+printf %s "checking if inet_pton can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define inet_pton to an innocuous variant, in case <limits.h> declares inet_pton.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define inet_pton innocuous_inet_pton
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char inet_pton (); below.  */
+
+#include <limits.h>
+#undef inet_pton
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char inet_pton ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_inet_pton || defined __stub___inet_pton
+choke me
+#endif
+
+int
+main (void)
+{
+return inet_pton ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_inet_pton="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_inet_pton="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_inet_pton" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_pton is prototyped" >&5
+printf %s "checking if inet_pton is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_arpa_inet
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "inet_pton" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_inet_pton="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_inet_pton="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_inet_pton" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_pton is compilable" >&5
+printf %s "checking if inet_pton is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_arpa_inet
+
+int
+main (void)
+{
+
+        if(0 != inet_pton(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_inet_pton="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_inet_pton="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+    if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_inet_pton" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_pton seems to work" >&5
+printf %s "checking if inet_pton seems to work... " >&6; }
+    if test "$cross_compiling" = yes
+then :
+  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run test program while cross compiling
+See \`config.log' for more details" "$LINENO" 5; }
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stdlib
+        $cares_includes_arpa_inet
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        unsigned char ipv6a[16+1];
+        unsigned char ipv4a[4+1];
+        const char *ipv6src = "fe80::214:4fff:fe0b:76c8";
+        const char *ipv4src = "192.168.100.1";
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(1 != inet_pton(AF_INET, ipv4src, ipv4a))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv4a[0] != 0xc0) ||
+            (ipv4a[1] != 0xa8) ||
+            (ipv4a[2] != 0x64) ||
+            (ipv4a[3] != 0x01) ||
+            (ipv4a[4] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(1 != inet_pton(AF_INET6, ipv6src, ipv6a))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0]  != 0xfe) ||
+            (ipv6a[1]  != 0x80) ||
+            (ipv6a[8]  != 0x02) ||
+            (ipv6a[9]  != 0x14) ||
+            (ipv6a[10] != 0x4f) ||
+            (ipv6a[11] != 0xff) ||
+            (ipv6a[12] != 0xfe) ||
+            (ipv6a[13] != 0x0b) ||
+            (ipv6a[14] != 0x76) ||
+            (ipv6a[15] != 0xc8) ||
+            (ipv6a[16] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[2]  != 0x0) ||
+            (ipv6a[3]  != 0x0) ||
+            (ipv6a[4]  != 0x0) ||
+            (ipv6a[5]  != 0x0) ||
+            (ipv6a[6]  != 0x0) ||
+            (ipv6a[7]  != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        exit(0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_works_inet_pton="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_works_inet_pton="no"
+
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+  fi
+  #
+  if test "$tst_compi_inet_pton" = "yes" &&
+    test "$tst_works_inet_pton" != "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_pton usage allowed" >&5
+printf %s "checking if inet_pton usage allowed... " >&6; }
+    if test "x$cares_disallow_inet_pton" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_inet_pton="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_inet_pton="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if inet_pton might be used" >&5
+printf %s "checking if inet_pton might be used... " >&6; }
+  if test "$tst_links_inet_pton" = "yes" &&
+     test "$tst_proto_inet_pton" = "yes" &&
+     test "$tst_compi_inet_pton" = "yes" &&
+     test "$tst_allow_inet_pton" = "yes" &&
+     test "$tst_works_inet_pton" != "no"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_INET_PTON 1" >>confdefs.h
+
+    ac_cv_func_inet_pton="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_inet_pton="no"
+  fi
+
+
+cares_includes_stropts="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#  include <sys/ioctl.h>
+#endif
+#ifdef HAVE_STROPTS_H
+#  include <stropts.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_stropts
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "unistd.h" "ac_cv_header_unistd_h" "$cares_includes_stropts
+"
+if test "x$ac_cv_header_unistd_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_UNISTD_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$cares_includes_stropts
+"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/ioctl.h" "ac_cv_header_sys_ioctl_h" "$cares_includes_stropts
+"
+if test "x$ac_cv_header_sys_ioctl_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_IOCTL_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "stropts.h" "ac_cv_header_stropts_h" "$cares_includes_stropts
+"
+if test "x$ac_cv_header_stropts_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_STROPTS_H 1" >>confdefs.h
+
+fi
+
+
+
+    #
+  tst_links_ioctl="unknown"
+  tst_proto_ioctl="unknown"
+  tst_compi_ioctl="unknown"
+  tst_allow_ioctl="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl can be linked" >&5
+printf %s "checking if ioctl can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define ioctl to an innocuous variant, in case <limits.h> declares ioctl.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define ioctl innocuous_ioctl
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char ioctl (); below.  */
+
+#include <limits.h>
+#undef ioctl
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char ioctl ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_ioctl || defined __stub___ioctl
+choke me
+#endif
+
+int
+main (void)
+{
+return ioctl ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_ioctl="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_ioctl="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_ioctl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl is prototyped" >&5
+printf %s "checking if ioctl is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_stropts
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "ioctl" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_ioctl="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_ioctl="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_ioctl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl is compilable" >&5
+printf %s "checking if ioctl is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stropts
+
+int
+main (void)
+{
+
+        if(0 != ioctl(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_ioctl="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_ioctl="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_ioctl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl usage allowed" >&5
+printf %s "checking if ioctl usage allowed... " >&6; }
+    if test "x$cares_disallow_ioctl" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_ioctl="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_ioctl="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl might be used" >&5
+printf %s "checking if ioctl might be used... " >&6; }
+  if test "$tst_links_ioctl" = "yes" &&
+     test "$tst_proto_ioctl" = "yes" &&
+     test "$tst_compi_ioctl" = "yes" &&
+     test "$tst_allow_ioctl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_IOCTL 1" >>confdefs.h
+
+    ac_cv_func_ioctl="yes"
+
+  #
+  tst_compi_ioctl_fionbio="unknown"
+  tst_allow_ioctl_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl FIONBIO is compilable" >&5
+printf %s "checking if ioctl FIONBIO is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stropts
+
+int
+main (void)
+{
+
+        int flags = 0;
+        if(0 != ioctl(0, FIONBIO, &flags))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_ioctl_fionbio="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_ioctl_fionbio="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_ioctl_fionbio" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl FIONBIO usage allowed" >&5
+printf %s "checking if ioctl FIONBIO usage allowed... " >&6; }
+    if test "x$cares_disallow_ioctl_fionbio" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_ioctl_fionbio="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_ioctl_fionbio="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl FIONBIO might be used" >&5
+printf %s "checking if ioctl FIONBIO might be used... " >&6; }
+  if test "$tst_compi_ioctl_fionbio" = "yes" &&
+     test "$tst_allow_ioctl_fionbio" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_IOCTL_FIONBIO 1" >>confdefs.h
+
+    ac_cv_func_ioctl_fionbio="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_ioctl_fionbio="no"
+  fi
+
+
+  #
+  tst_compi_ioctl_siocgifaddr="unknown"
+  tst_allow_ioctl_siocgifaddr="unknown"
+  #
+  if test "$ac_cv_func_ioctl" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl SIOCGIFADDR is compilable" >&5
+printf %s "checking if ioctl SIOCGIFADDR is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stropts
+        #include <net/if.h>
+
+int
+main (void)
+{
+
+        struct ifreq ifr;
+        if(0 != ioctl(0, SIOCGIFADDR, &ifr))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_ioctl_siocgifaddr="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_ioctl_siocgifaddr="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_ioctl_siocgifaddr" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl SIOCGIFADDR usage allowed" >&5
+printf %s "checking if ioctl SIOCGIFADDR usage allowed... " >&6; }
+    if test "x$cares_disallow_ioctl_siocgifaddr" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_ioctl_siocgifaddr="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_ioctl_siocgifaddr="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctl SIOCGIFADDR might be used" >&5
+printf %s "checking if ioctl SIOCGIFADDR might be used... " >&6; }
+  if test "$tst_compi_ioctl_siocgifaddr" = "yes" &&
+     test "$tst_allow_ioctl_siocgifaddr" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_IOCTL_SIOCGIFADDR 1" >>confdefs.h
+
+    ac_cv_func_ioctl_siocgifaddr="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_ioctl_siocgifaddr="no"
+  fi
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_ioctl="no"
+  fi
+
+
+    #
+  tst_links_ioctlsocket="unknown"
+  tst_proto_ioctlsocket="unknown"
+  tst_compi_ioctlsocket="unknown"
+  tst_allow_ioctlsocket="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctlsocket can be linked" >&5
+printf %s "checking if ioctlsocket can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_winsock2
+
+int
+main (void)
+{
+
+      if(0 != ioctlsocket(0, 0, 0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_ioctlsocket="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_ioctlsocket="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_ioctlsocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctlsocket is prototyped" >&5
+printf %s "checking if ioctlsocket is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_winsock2
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "ioctlsocket" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_ioctlsocket="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_ioctlsocket="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_ioctlsocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctlsocket is compilable" >&5
+printf %s "checking if ioctlsocket is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+
+int
+main (void)
+{
+
+        if(0 != ioctlsocket(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_ioctlsocket="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_ioctlsocket="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_ioctlsocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctlsocket usage allowed" >&5
+printf %s "checking if ioctlsocket usage allowed... " >&6; }
+    if test "x$cares_disallow_ioctlsocket" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_ioctlsocket="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_ioctlsocket="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctlsocket might be used" >&5
+printf %s "checking if ioctlsocket might be used... " >&6; }
+  if test "$tst_links_ioctlsocket" = "yes" &&
+     test "$tst_proto_ioctlsocket" = "yes" &&
+     test "$tst_compi_ioctlsocket" = "yes" &&
+     test "$tst_allow_ioctlsocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_IOCTLSOCKET 1" >>confdefs.h
+
+    ac_cv_func_ioctlsocket="yes"
+
+  #
+  tst_compi_ioctlsocket_fionbio="unknown"
+  tst_allow_ioctlsocket_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctlsocket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctlsocket FIONBIO is compilable" >&5
+printf %s "checking if ioctlsocket FIONBIO is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+
+int
+main (void)
+{
+
+        int flags = 0;
+        if(0 != ioctlsocket(0, FIONBIO, &flags))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_ioctlsocket_fionbio="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_ioctlsocket_fionbio="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_fionbio" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctlsocket FIONBIO usage allowed" >&5
+printf %s "checking if ioctlsocket FIONBIO usage allowed... " >&6; }
+    if test "x$cares_disallow_ioctlsocket_fionbio" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_ioctlsocket_fionbio="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_ioctlsocket_fionbio="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ioctlsocket FIONBIO might be used" >&5
+printf %s "checking if ioctlsocket FIONBIO might be used... " >&6; }
+  if test "$tst_compi_ioctlsocket_fionbio" = "yes" &&
+     test "$tst_allow_ioctlsocket_fionbio" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_IOCTLSOCKET_FIONBIO 1" >>confdefs.h
+
+    ac_cv_func_ioctlsocket_fionbio="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_ioctlsocket_fionbio="no"
+  fi
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_ioctlsocket="no"
+  fi
+
+
+    #
+  tst_links_ioctlsocket_camel="unknown"
+  tst_proto_ioctlsocket_camel="unknown"
+  tst_compi_ioctlsocket_camel="unknown"
+  tst_allow_ioctlsocket_camel="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if IoctlSocket can be linked" >&5
+printf %s "checking if IoctlSocket can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define IoctlSocket to an innocuous variant, in case <limits.h> declares IoctlSocket.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define IoctlSocket innocuous_IoctlSocket
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char IoctlSocket (); below.  */
+
+#include <limits.h>
+#undef IoctlSocket
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char IoctlSocket ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_IoctlSocket || defined __stub___IoctlSocket
+choke me
+#endif
+
+int
+main (void)
+{
+return IoctlSocket ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_ioctlsocket_camel="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_ioctlsocket_camel="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_ioctlsocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if IoctlSocket is prototyped" >&5
+printf %s "checking if IoctlSocket is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_stropts
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "IoctlSocket" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_ioctlsocket_camel="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_ioctlsocket_camel="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_ioctlsocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if IoctlSocket is compilable" >&5
+printf %s "checking if IoctlSocket is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stropts
+
+int
+main (void)
+{
+
+        if(0 != IoctlSocket(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_ioctlsocket_camel="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_ioctlsocket_camel="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if IoctlSocket usage allowed" >&5
+printf %s "checking if IoctlSocket usage allowed... " >&6; }
+    if test "x$cares_disallow_ioctlsocket_camel" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_ioctlsocket_camel="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_ioctlsocket_camel="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if IoctlSocket might be used" >&5
+printf %s "checking if IoctlSocket might be used... " >&6; }
+  if test "$tst_links_ioctlsocket_camel" = "yes" &&
+     test "$tst_proto_ioctlsocket_camel" = "yes" &&
+     test "$tst_compi_ioctlsocket_camel" = "yes" &&
+     test "$tst_allow_ioctlsocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_IOCTLSOCKET_CAMEL 1" >>confdefs.h
+
+    ac_cv_func_ioctlsocket_camel="yes"
+
+  #
+  tst_compi_ioctlsocket_camel_fionbio="unknown"
+  tst_allow_ioctlsocket_camel_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctlsocket_camel" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if IoctlSocket FIONBIO is compilable" >&5
+printf %s "checking if IoctlSocket FIONBIO is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_stropts
+
+int
+main (void)
+{
+
+        long flags = 0;
+        if(0 != ioctlsocket(0, FIONBIO, &flags))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_ioctlsocket_camel_fionbio="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_ioctlsocket_camel_fionbio="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if IoctlSocket FIONBIO usage allowed" >&5
+printf %s "checking if IoctlSocket FIONBIO usage allowed... " >&6; }
+    if test "x$cares_disallow_ioctlsocket_camel_fionbio" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_ioctlsocket_camel_fionbio="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_ioctlsocket_camel_fionbio="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if IoctlSocket FIONBIO might be used" >&5
+printf %s "checking if IoctlSocket FIONBIO might be used... " >&6; }
+  if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes" &&
+     test "$tst_allow_ioctlsocket_camel_fionbio" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_IOCTLSOCKET_CAMEL_FIONBIO 1" >>confdefs.h
+
+    ac_cv_func_ioctlsocket_camel_fionbio="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_ioctlsocket_camel_fionbio="no"
+  fi
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_ioctlsocket_camel="no"
+  fi
+
+
+      #
+  tst_links_setsockopt="unknown"
+  tst_proto_setsockopt="unknown"
+  tst_compi_setsockopt="unknown"
+  tst_allow_setsockopt="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if setsockopt can be linked" >&5
+printf %s "checking if setsockopt can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+
+int
+main (void)
+{
+
+      if(0 != setsockopt(0, 0, 0, 0, 0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_setsockopt="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_setsockopt="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_setsockopt" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if setsockopt is prototyped" >&5
+printf %s "checking if setsockopt is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "setsockopt" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_setsockopt="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_setsockopt="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_setsockopt" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if setsockopt is compilable" >&5
+printf %s "checking if setsockopt is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+
+int
+main (void)
+{
+
+        if(0 != setsockopt(0, 0, 0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_setsockopt="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_setsockopt="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_setsockopt" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if setsockopt usage allowed" >&5
+printf %s "checking if setsockopt usage allowed... " >&6; }
+    if test "x$cares_disallow_setsockopt" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_setsockopt="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_setsockopt="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if setsockopt might be used" >&5
+printf %s "checking if setsockopt might be used... " >&6; }
+  if test "$tst_links_setsockopt" = "yes" &&
+     test "$tst_proto_setsockopt" = "yes" &&
+     test "$tst_compi_setsockopt" = "yes" &&
+     test "$tst_allow_setsockopt" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_SETSOCKOPT 1" >>confdefs.h
+
+    ac_cv_func_setsockopt="yes"
+
+  #
+  tst_compi_setsockopt_so_nonblock="unknown"
+  tst_allow_setsockopt_so_nonblock="unknown"
+  #
+  if test "$ac_cv_func_setsockopt" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if setsockopt SO_NONBLOCK is compilable" >&5
+printf %s "checking if setsockopt SO_NONBLOCK is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+
+int
+main (void)
+{
+
+        if(0 != setsockopt(0, SOL_SOCKET, SO_NONBLOCK, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_setsockopt_so_nonblock="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_setsockopt_so_nonblock="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_setsockopt_so_nonblock" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if setsockopt SO_NONBLOCK usage allowed" >&5
+printf %s "checking if setsockopt SO_NONBLOCK usage allowed... " >&6; }
+    if test "x$cares_disallow_setsockopt_so_nonblock" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_setsockopt_so_nonblock="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_setsockopt_so_nonblock="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if setsockopt SO_NONBLOCK might be used" >&5
+printf %s "checking if setsockopt SO_NONBLOCK might be used... " >&6; }
+  if test "$tst_compi_setsockopt_so_nonblock" = "yes" &&
+     test "$tst_allow_setsockopt_so_nonblock" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_SETSOCKOPT_SO_NONBLOCK 1" >>confdefs.h
+
+    ac_cv_func_setsockopt_so_nonblock="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_setsockopt_so_nonblock="no"
+  fi
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_setsockopt="no"
+  fi
+
+
+        #
+  tst_links_socket="unknown"
+  tst_proto_socket="unknown"
+  tst_compi_socket="unknown"
+  tst_allow_socket="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if socket can be linked" >&5
+printf %s "checking if socket can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+
+int
+main (void)
+{
+
+      if(0 != socket(0, 0, 0))
+        return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_socket="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_socket="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_socket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if socket is prototyped" >&5
+printf %s "checking if socket is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "socket" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_socket="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_socket="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_socket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if socket is compilable" >&5
+printf %s "checking if socket is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+        $cares_includes_socket
+
+int
+main (void)
+{
+
+        if(0 != socket(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_socket="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_socket="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_socket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if socket usage allowed" >&5
+printf %s "checking if socket usage allowed... " >&6; }
+    if test "x$cares_disallow_socket" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_socket="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_socket="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if socket might be used" >&5
+printf %s "checking if socket might be used... " >&6; }
+  if test "$tst_links_socket" = "yes" &&
+     test "$tst_proto_socket" = "yes" &&
+     test "$tst_compi_socket" = "yes" &&
+     test "$tst_allow_socket" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_SOCKET 1" >>confdefs.h
+
+    ac_cv_func_socket="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_socket="no"
+  fi
+
+
+    #
+  tst_links_strcasecmp="unknown"
+  tst_proto_strcasecmp="unknown"
+  tst_compi_strcasecmp="unknown"
+  tst_allow_strcasecmp="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcasecmp can be linked" >&5
+printf %s "checking if strcasecmp can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define strcasecmp to an innocuous variant, in case <limits.h> declares strcasecmp.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define strcasecmp innocuous_strcasecmp
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char strcasecmp (); below.  */
+
+#include <limits.h>
+#undef strcasecmp
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strcasecmp ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_strcasecmp || defined __stub___strcasecmp
+choke me
+#endif
+
+int
+main (void)
+{
+return strcasecmp ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_strcasecmp="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_strcasecmp="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_strcasecmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcasecmp is prototyped" >&5
+printf %s "checking if strcasecmp is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_string
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strcasecmp" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_strcasecmp="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_strcasecmp="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_strcasecmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcasecmp is compilable" >&5
+printf %s "checking if strcasecmp is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        if(0 != strcasecmp(0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_strcasecmp="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_strcasecmp="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_strcasecmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcasecmp usage allowed" >&5
+printf %s "checking if strcasecmp usage allowed... " >&6; }
+    if test "x$cares_disallow_strcasecmp" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_strcasecmp="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_strcasecmp="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcasecmp might be used" >&5
+printf %s "checking if strcasecmp might be used... " >&6; }
+  if test "$tst_links_strcasecmp" = "yes" &&
+     test "$tst_proto_strcasecmp" = "yes" &&
+     test "$tst_compi_strcasecmp" = "yes" &&
+     test "$tst_allow_strcasecmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRCASECMP 1" >>confdefs.h
+
+    ac_cv_func_strcasecmp="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_strcasecmp="no"
+  fi
+
+
+    #
+  tst_links_strcmpi="unknown"
+  tst_proto_strcmpi="unknown"
+  tst_compi_strcmpi="unknown"
+  tst_allow_strcmpi="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcmpi can be linked" >&5
+printf %s "checking if strcmpi can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define strcmpi to an innocuous variant, in case <limits.h> declares strcmpi.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define strcmpi innocuous_strcmpi
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char strcmpi (); below.  */
+
+#include <limits.h>
+#undef strcmpi
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strcmpi ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_strcmpi || defined __stub___strcmpi
+choke me
+#endif
+
+int
+main (void)
+{
+return strcmpi ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_strcmpi="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_strcmpi="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_strcmpi" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcmpi is prototyped" >&5
+printf %s "checking if strcmpi is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_string
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strcmpi" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_strcmpi="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_strcmpi="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_strcmpi" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcmpi is compilable" >&5
+printf %s "checking if strcmpi is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        if(0 != strcmpi(0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_strcmpi="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_strcmpi="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_strcmpi" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcmpi usage allowed" >&5
+printf %s "checking if strcmpi usage allowed... " >&6; }
+    if test "x$cares_disallow_strcmpi" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_strcmpi="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_strcmpi="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strcmpi might be used" >&5
+printf %s "checking if strcmpi might be used... " >&6; }
+  if test "$tst_links_strcmpi" = "yes" &&
+     test "$tst_proto_strcmpi" = "yes" &&
+     test "$tst_compi_strcmpi" = "yes" &&
+     test "$tst_allow_strcmpi" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRCMPI 1" >>confdefs.h
+
+    ac_cv_func_strcmpi="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_strcmpi="no"
+  fi
+
+
+    #
+  tst_links_strdup="unknown"
+  tst_proto_strdup="unknown"
+  tst_compi_strdup="unknown"
+  tst_allow_strdup="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strdup can be linked" >&5
+printf %s "checking if strdup can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define strdup to an innocuous variant, in case <limits.h> declares strdup.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define strdup innocuous_strdup
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char strdup (); below.  */
+
+#include <limits.h>
+#undef strdup
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strdup ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_strdup || defined __stub___strdup
+choke me
+#endif
+
+int
+main (void)
+{
+return strdup ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_strdup="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_strdup="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_strdup" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strdup is prototyped" >&5
+printf %s "checking if strdup is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_string
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strdup" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_strdup="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_strdup="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_strdup" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strdup is compilable" >&5
+printf %s "checking if strdup is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        if(0 != strdup(0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_strdup="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_strdup="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_strdup" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strdup usage allowed" >&5
+printf %s "checking if strdup usage allowed... " >&6; }
+    if test "x$cares_disallow_strdup" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_strdup="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_strdup="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strdup might be used" >&5
+printf %s "checking if strdup might be used... " >&6; }
+  if test "$tst_links_strdup" = "yes" &&
+     test "$tst_proto_strdup" = "yes" &&
+     test "$tst_compi_strdup" = "yes" &&
+     test "$tst_allow_strdup" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRDUP 1" >>confdefs.h
+
+    ac_cv_func_strdup="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_strdup="no"
+  fi
+
+
+    #
+  tst_links_stricmp="unknown"
+  tst_proto_stricmp="unknown"
+  tst_compi_stricmp="unknown"
+  tst_allow_stricmp="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if stricmp can be linked" >&5
+printf %s "checking if stricmp can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define stricmp to an innocuous variant, in case <limits.h> declares stricmp.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define stricmp innocuous_stricmp
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char stricmp (); below.  */
+
+#include <limits.h>
+#undef stricmp
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char stricmp ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_stricmp || defined __stub___stricmp
+choke me
+#endif
+
+int
+main (void)
+{
+return stricmp ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_stricmp="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_stricmp="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_stricmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if stricmp is prototyped" >&5
+printf %s "checking if stricmp is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_string
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "stricmp" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_stricmp="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_stricmp="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_stricmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if stricmp is compilable" >&5
+printf %s "checking if stricmp is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        if(0 != stricmp(0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_stricmp="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_stricmp="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_stricmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if stricmp usage allowed" >&5
+printf %s "checking if stricmp usage allowed... " >&6; }
+    if test "x$cares_disallow_stricmp" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_stricmp="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_stricmp="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if stricmp might be used" >&5
+printf %s "checking if stricmp might be used... " >&6; }
+  if test "$tst_links_stricmp" = "yes" &&
+     test "$tst_proto_stricmp" = "yes" &&
+     test "$tst_compi_stricmp" = "yes" &&
+     test "$tst_allow_stricmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRICMP 1" >>confdefs.h
+
+    ac_cv_func_stricmp="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_stricmp="no"
+  fi
+
+
+    #
+  tst_links_strncasecmp="unknown"
+  tst_proto_strncasecmp="unknown"
+  tst_compi_strncasecmp="unknown"
+  tst_allow_strncasecmp="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncasecmp can be linked" >&5
+printf %s "checking if strncasecmp can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define strncasecmp to an innocuous variant, in case <limits.h> declares strncasecmp.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define strncasecmp innocuous_strncasecmp
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char strncasecmp (); below.  */
+
+#include <limits.h>
+#undef strncasecmp
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strncasecmp ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_strncasecmp || defined __stub___strncasecmp
+choke me
+#endif
+
+int
+main (void)
+{
+return strncasecmp ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_strncasecmp="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_strncasecmp="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_strncasecmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncasecmp is prototyped" >&5
+printf %s "checking if strncasecmp is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_string
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strncasecmp" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_strncasecmp="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_strncasecmp="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_strncasecmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncasecmp is compilable" >&5
+printf %s "checking if strncasecmp is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        if(0 != strncasecmp(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_strncasecmp="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_strncasecmp="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_strncasecmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncasecmp usage allowed" >&5
+printf %s "checking if strncasecmp usage allowed... " >&6; }
+    if test "x$cares_disallow_strncasecmp" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_strncasecmp="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_strncasecmp="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncasecmp might be used" >&5
+printf %s "checking if strncasecmp might be used... " >&6; }
+  if test "$tst_links_strncasecmp" = "yes" &&
+     test "$tst_proto_strncasecmp" = "yes" &&
+     test "$tst_compi_strncasecmp" = "yes" &&
+     test "$tst_allow_strncasecmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRNCASECMP 1" >>confdefs.h
+
+    ac_cv_func_strncasecmp="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_strncasecmp="no"
+  fi
+
+
+    #
+  tst_links_strncmpi="unknown"
+  tst_proto_strncmpi="unknown"
+  tst_compi_strncmpi="unknown"
+  tst_allow_strncmpi="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncmpi can be linked" >&5
+printf %s "checking if strncmpi can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define strncmpi to an innocuous variant, in case <limits.h> declares strncmpi.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define strncmpi innocuous_strncmpi
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char strncmpi (); below.  */
+
+#include <limits.h>
+#undef strncmpi
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strncmpi ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_strncmpi || defined __stub___strncmpi
+choke me
+#endif
+
+int
+main (void)
+{
+return strncmpi ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_strncmpi="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_strncmpi="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_strncmpi" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncmpi is prototyped" >&5
+printf %s "checking if strncmpi is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_string
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strncmpi" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_strncmpi="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_strncmpi="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_strncmpi" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncmpi is compilable" >&5
+printf %s "checking if strncmpi is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        if(0 != strncmpi(0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_strncmpi="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_strncmpi="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_strncmpi" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncmpi usage allowed" >&5
+printf %s "checking if strncmpi usage allowed... " >&6; }
+    if test "x$cares_disallow_strncmpi" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_strncmpi="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_strncmpi="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strncmpi might be used" >&5
+printf %s "checking if strncmpi might be used... " >&6; }
+  if test "$tst_links_strncmpi" = "yes" &&
+     test "$tst_proto_strncmpi" = "yes" &&
+     test "$tst_compi_strncmpi" = "yes" &&
+     test "$tst_allow_strncmpi" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRNCMPI 1" >>confdefs.h
+
+    ac_cv_func_strncmpi="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_strncmpi="no"
+  fi
+
+
+    #
+  tst_links_strnicmp="unknown"
+  tst_proto_strnicmp="unknown"
+  tst_compi_strnicmp="unknown"
+  tst_allow_strnicmp="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strnicmp can be linked" >&5
+printf %s "checking if strnicmp can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define strnicmp to an innocuous variant, in case <limits.h> declares strnicmp.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define strnicmp innocuous_strnicmp
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char strnicmp (); below.  */
+
+#include <limits.h>
+#undef strnicmp
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char strnicmp ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_strnicmp || defined __stub___strnicmp
+choke me
+#endif
+
+int
+main (void)
+{
+return strnicmp ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_strnicmp="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_strnicmp="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_strnicmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strnicmp is prototyped" >&5
+printf %s "checking if strnicmp is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_string
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "strnicmp" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_strnicmp="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_strnicmp="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_strnicmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strnicmp is compilable" >&5
+printf %s "checking if strnicmp is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_string
+
+int
+main (void)
+{
+
+        if(0 != strnicmp(0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_strnicmp="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_strnicmp="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_strnicmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strnicmp usage allowed" >&5
+printf %s "checking if strnicmp usage allowed... " >&6; }
+    if test "x$cares_disallow_strnicmp" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_strnicmp="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_strnicmp="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if strnicmp might be used" >&5
+printf %s "checking if strnicmp might be used... " >&6; }
+  if test "$tst_links_strnicmp" = "yes" &&
+     test "$tst_proto_strnicmp" = "yes" &&
+     test "$tst_compi_strnicmp" = "yes" &&
+     test "$tst_allow_strnicmp" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRNICMP 1" >>confdefs.h
+
+    ac_cv_func_strnicmp="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_strnicmp="no"
+  fi
+
+
+cares_includes_sys_uio="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_UIO_H
+#  include <sys/uio.h>
+#endif
+/* includes end */"
+  ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$cares_includes_sys_uio
+"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/uio.h" "ac_cv_header_sys_uio_h" "$cares_includes_sys_uio
+"
+if test "x$ac_cv_header_sys_uio_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_UIO_H 1" >>confdefs.h
+
+fi
+
+
+
+    #
+  tst_links_writev="unknown"
+  tst_proto_writev="unknown"
+  tst_compi_writev="unknown"
+  tst_allow_writev="unknown"
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if writev can be linked" >&5
+printf %s "checking if writev can be linked... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define writev to an innocuous variant, in case <limits.h> declares writev.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define writev innocuous_writev
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char writev (); below.  */
+
+#include <limits.h>
+#undef writev
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char writev ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_writev || defined __stub___writev
+choke me
+#endif
+
+int
+main (void)
+{
+return writev ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    tst_links_writev="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    tst_links_writev="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$tst_links_writev" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if writev is prototyped" >&5
+printf %s "checking if writev is prototyped... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+      $cares_includes_sys_uio
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "writev" >/dev/null 2>&1
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_proto_writev="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_proto_writev="no"
+
+fi
+rm -rf conftest*
+
+  fi
+  #
+  if test "$tst_proto_writev" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if writev is compilable" >&5
+printf %s "checking if writev is compilable... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+        $cares_includes_sys_uio
+
+int
+main (void)
+{
+
+        if(0 != writev(0, 0, 0))
+          return 1;
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_compi_writev="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_compi_writev="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  fi
+  #
+  if test "$tst_compi_writev" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if writev usage allowed" >&5
+printf %s "checking if writev usage allowed... " >&6; }
+    if test "x$cares_disallow_writev" != "xyes"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      tst_allow_writev="yes"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      tst_allow_writev="no"
+    fi
+  fi
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if writev might be used" >&5
+printf %s "checking if writev might be used... " >&6; }
+  if test "$tst_links_writev" = "yes" &&
+     test "$tst_proto_writev" = "yes" &&
+     test "$tst_compi_writev" = "yes" &&
+     test "$tst_allow_writev" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_WRITEV 1" >>confdefs.h
+
+    ac_cv_func_writev="yes"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    ac_cv_func_writev="no"
+  fi
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for PF_INET6" >&5
+printf %s "checking for PF_INET6... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+
+
+      #ifdef PF_INET6
+        VARIABLEWASDEFINED
+      #else
+        NJET
+      #endif
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "VARIABLEWASDEFINED" >/dev/null 2>&1
+then :
+  ac_constant="yes"
+else $as_nop
+  ac_constant="no"
+
+fi
+rm -rf conftest*
+
+  if test "$ac_constant" = "yes" ; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_PF_INET6 1" >>confdefs.h
+
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+  fi
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AF_INET6" >&5
+printf %s "checking for AF_INET6... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+
+
+      #ifdef AF_INET6
+        VARIABLEWASDEFINED
+      #else
+        NJET
+      #endif
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "VARIABLEWASDEFINED" >/dev/null 2>&1
+then :
+  ac_constant="yes"
+else $as_nop
+  ac_constant="no"
+
+fi
+rm -rf conftest*
+
+  if test "$ac_constant" = "yes" ; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_AF_INET6 1" >>confdefs.h
+
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+  fi
+
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for struct in6_addr" >&5
+printf %s "checking for struct in6_addr... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+      struct in6_addr struct_instance;
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_struct="yes"
+else $as_nop
+  ac_found="no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  if test "$ac_struct" = "yes" ; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRUCT_IN6_ADDR 1" >>confdefs.h
+
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+  fi
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for struct sockaddr_in6" >&5
+printf %s "checking for struct sockaddr_in6... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+      struct sockaddr_in6 struct_instance;
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_struct="yes"
+else $as_nop
+  ac_found="no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+  if test "$ac_struct" = "yes" ; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+printf "%s\n" "#define HAVE_STRUCT_SOCKADDR_IN6 1" >>confdefs.h
+ ac_have_sockaddr_in6=yes
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+
+  fi
+
+
+ac_fn_c_check_member "$LINENO" "struct sockaddr_in6" "sin6_scope_id" "ac_cv_member_struct_sockaddr_in6_sin6_scope_id" "
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#endif
+
+"
+if test "x$ac_cv_member_struct_sockaddr_in6_sin6_scope_id" = xyes
+then :
+
+printf "%s\n" "#define HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID 1" >>confdefs.h
+
+
+fi
+
+
+ac_fn_c_check_member "$LINENO" "struct addrinfo" "ai_flags" "ac_cv_member_struct_addrinfo_ai_flags" "
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#endif
+
+
+"
+if test "x$ac_cv_member_struct_addrinfo_ai_flags" = xyes
+then :
+
+printf "%s\n" "#define HAVE_STRUCT_ADDRINFO 1" >>confdefs.h
+
+fi
+
+
+
+
+  for ac_func in bitncmp gettimeofday if_indextoname
+do :
+  as_ac_var=`printf "%s\n" "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"
+then :
+  cat >>confdefs.h <<_ACEOF
+#define `printf "%s\n" "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+
+else $as_nop
+
+  func="$ac_func"
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking deeper for $func" >&5
+printf %s "checking deeper for $func... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+      $func ();
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    eval "ac_cv_func_$func=yes"
+
+cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$func" | sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' | sed 's/^A-Z0-9_/_/g'` 1
+_ACEOF
+
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: but still no" >&5
+printf "%s\n" "but still no" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+
+fi
+
+done
+
+ac_fn_c_check_func "$LINENO" "__system_property_get" "ac_cv_func___system_property_get"
+if test "x$ac_cv_func___system_property_get" = xyes
+then :
+
+
+printf "%s\n" "#define HAVE___SYSTEM_PROPERTY_GET 1" >>confdefs.h
+
+
+fi
+
+
+
+    ac_fn_c_check_header_compile "$LINENO" "sys/types.h" "ac_cv_header_sys_types_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_types_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_TYPES_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default"
+if test "x$ac_cv_header_sys_socket_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
+
+fi
+ac_fn_c_check_header_compile "$LINENO" "netdb.h" "ac_cv_header_netdb_h" "$ac_includes_default"
+if test "x$ac_cv_header_netdb_h" = xyes
+then :
+  printf "%s\n" "#define HAVE_NETDB_H 1" >>confdefs.h
+
+fi
+
+  #
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for getnameinfo" >&5
+printf %s "checking for getnameinfo... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    /* Define getnameinfo to an innocuous variant, in case <limits.h> declares getnameinfo.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define getnameinfo innocuous_getnameinfo
+
+/* System header to define __stub macros and hopefully few prototypes,
+   which can conflict with char getnameinfo (); below.  */
+
+#include <limits.h>
+#undef getnameinfo
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char getnameinfo ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_getnameinfo || defined __stub___getnameinfo
+choke me
+#endif
+
+int
+main (void)
+{
+return getnameinfo ();
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    curl_cv_getnameinfo="yes"
+
+else $as_nop
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+    curl_cv_getnameinfo="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  #
+  if test "$curl_cv_getnameinfo" != "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking deeper for getnameinfo" >&5
+printf %s "checking deeper for getnameinfo... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+
+int
+main (void)
+{
+
+        getnameinfo();
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      curl_cv_getnameinfo="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: but still no" >&5
+printf "%s\n" "but still no" >&6; }
+      curl_cv_getnameinfo="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  fi
+  #
+  if test "$curl_cv_getnameinfo" != "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking deeper and deeper for getnameinfo" >&5
+printf %s "checking deeper and deeper for getnameinfo... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#endif
+
+int
+main (void)
+{
+
+        getnameinfo(0, 0, 0, 0, 0, 0, 0);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      curl_cv_getnameinfo="yes"
+
+else $as_nop
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: but still no" >&5
+printf "%s\n" "but still no" >&6; }
+      curl_cv_getnameinfo="no"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+  fi
+  #
+  if test "$curl_cv_getnameinfo" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking types of arguments for getnameinfo" >&5
+printf %s "checking types of arguments for getnameinfo... " >&6; }
+if test ${curl_cv_func_getnameinfo_args+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+
+      curl_cv_func_getnameinfo_args="unknown"
+      for gni_arg1 in 'struct sockaddr *' 'const struct sockaddr *' 'void *'; do
+        for gni_arg2 in 'socklen_t' 'size_t' 'int'; do
+          for gni_arg46 in 'size_t' 'int' 'socklen_t' 'unsigned int' 'DWORD'; do
+            for gni_arg7 in 'int' 'unsigned int'; do
+              if test "$curl_cv_func_getnameinfo_args" = "unknown"; then
+                cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#if (!defined(_WIN32_WINNT)) || (_WIN32_WINNT < 0x0501)
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0501
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#define GNICALLCONV WSAAPI
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#define GNICALLCONV
+#endif
+                    extern int GNICALLCONV getnameinfo($gni_arg1, $gni_arg2,
+                                           char *, $gni_arg46,
+                                           char *, $gni_arg46,
+                                           $gni_arg7);
+
+int
+main (void)
+{
+
+                    $gni_arg2 salen=0;
+                    $gni_arg46 hostlen=0;
+                    $gni_arg46 servlen=0;
+                    $gni_arg7 flags=0;
+                    int res = getnameinfo(0, salen, 0, hostlen, 0, servlen, flags);
+
+  ;
+  return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+                  curl_cv_func_getnameinfo_args="$gni_arg1,$gni_arg2,$gni_arg46,$gni_arg7"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+              fi
+            done
+          done
+        done
+      done
+
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $curl_cv_func_getnameinfo_args" >&5
+printf "%s\n" "$curl_cv_func_getnameinfo_args" >&6; } # AC-CACHE-CHECK
+    if test "$curl_cv_func_getnameinfo_args" = "unknown"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Cannot find proper types to use for getnameinfo args" >&5
+printf "%s\n" "$as_me: WARNING: Cannot find proper types to use for getnameinfo args" >&2;}
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: HAVE_GETNAMEINFO will not be defined" >&5
+printf "%s\n" "$as_me: WARNING: HAVE_GETNAMEINFO will not be defined" >&2;}
+    else
+      gni_prev_IFS=$IFS; IFS=','
+      set dummy `echo "$curl_cv_func_getnameinfo_args" | sed 's/\*/\*/g'`
+      IFS=$gni_prev_IFS
+      shift
+      #
+      gni_qual_type_arg1=$1
+      #
+
+printf "%s\n" "#define GETNAMEINFO_TYPE_ARG2 $2" >>confdefs.h
+
+
+printf "%s\n" "#define GETNAMEINFO_TYPE_ARG46 $3" >>confdefs.h
+
+
+printf "%s\n" "#define GETNAMEINFO_TYPE_ARG7 $4" >>confdefs.h
+
+      #
+      prev_sh_opts=$-
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set -f
+          ;;
+      esac
+      #
+      case "$gni_qual_type_arg1" in
+        const*)
+          gni_qual_arg1=const
+          gni_type_arg1=`echo $gni_qual_type_arg1 | sed 's/^const //'`
+        ;;
+        *)
+          gni_qual_arg1=
+          gni_type_arg1=$gni_qual_type_arg1
+        ;;
+      esac
+      #
+
+printf "%s\n" "#define GETNAMEINFO_QUAL_ARG1 $gni_qual_arg1" >>confdefs.h
+
+
+printf "%s\n" "#define GETNAMEINFO_TYPE_ARG1 $gni_type_arg1" >>confdefs.h
+
+      #
+      case $prev_sh_opts in
+        *f*)
+          ;;
+        *)
+          set +f
+          ;;
+      esac
+      #
+
+printf "%s\n" "#define HAVE_GETNAMEINFO 1" >>confdefs.h
+
+      ac_cv_func_getnameinfo="yes"
+    fi
+  fi
+
+
+
+ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
+printf %s "checking whether byte ordering is bigendian... " >&6; }
+if test ${ac_cv_c_bigendian+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  ac_cv_c_bigendian=unknown
+    # See if we're dealing with a universal compiler.
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifndef __APPLE_CC__
+	       not a universal capable compiler
+	     #endif
+	     typedef int dummy;
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+	# Check for potential -arch flags.  It is not universal unless
+	# there are at least two -arch flags with different values.
+	ac_arch=
+	ac_prev=
+	for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
+	 if test -n "$ac_prev"; then
+	   case $ac_word in
+	     i?86 | x86_64 | ppc | ppc64)
+	       if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
+		 ac_arch=$ac_word
+	       else
+		 ac_cv_c_bigendian=universal
+		 break
+	       fi
+	       ;;
+	   esac
+	   ac_prev=
+	 elif test "x$ac_word" = "x-arch"; then
+	   ac_prev=arch
+	 fi
+       done
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    if test $ac_cv_c_bigendian = unknown; then
+      # See if sys/param.h defines the BYTE_ORDER macro.
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+	     #include <sys/param.h>
+
+int
+main (void)
+{
+#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
+		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
+		     && LITTLE_ENDIAN)
+	      bogus endian macros
+	     #endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  # It does; now see whether it defined to BIG_ENDIAN or not.
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+		#include <sys/param.h>
+
+int
+main (void)
+{
+#if BYTE_ORDER != BIG_ENDIAN
+		 not big endian
+		#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_c_bigendian=yes
+else $as_nop
+  ac_cv_c_bigendian=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    fi
+    if test $ac_cv_c_bigendian = unknown; then
+      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
+
+int
+main (void)
+{
+#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
+	      bogus endian macros
+	     #endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  # It does; now see whether it defined to _BIG_ENDIAN or not.
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
+
+int
+main (void)
+{
+#ifndef _BIG_ENDIAN
+		 not big endian
+		#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_cv_c_bigendian=yes
+else $as_nop
+  ac_cv_c_bigendian=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+    fi
+    if test $ac_cv_c_bigendian = unknown; then
+      # Compile a test program.
+      if test "$cross_compiling" = yes
+then :
+  # Try to guess by grepping values from an object file.
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+unsigned short int ascii_mm[] =
+		  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
+		unsigned short int ascii_ii[] =
+		  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
+		int use_ascii (int i) {
+		  return ascii_mm[i] + ascii_ii[i];
+		}
+		unsigned short int ebcdic_ii[] =
+		  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
+		unsigned short int ebcdic_mm[] =
+		  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
+		int use_ebcdic (int i) {
+		  return ebcdic_mm[i] + ebcdic_ii[i];
+		}
+		extern int foo;
+
+int
+main (void)
+{
+return use_ascii (foo) == use_ebcdic (foo);
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
+	      ac_cv_c_bigendian=yes
+	    fi
+	    if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
+	      if test "$ac_cv_c_bigendian" = unknown; then
+		ac_cv_c_bigendian=no
+	      else
+		# finding both strings is unlikely to happen, but who knows?
+		ac_cv_c_bigendian=unknown
+	      fi
+	    fi
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+else $as_nop
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
+int
+main (void)
+{
+
+	     /* Are we little or big endian?  From Harbison&Steele.  */
+	     union
+	     {
+	       long int l;
+	       char c[sizeof (long int)];
+	     } u;
+	     u.l = 1;
+	     return u.c[sizeof (long int) - 1] == 1;
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+  ac_cv_c_bigendian=no
+else $as_nop
+  ac_cv_c_bigendian=yes
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+    fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
+printf "%s\n" "$ac_cv_c_bigendian" >&6; }
+ case $ac_cv_c_bigendian in #(
+   yes)
+
+printf "%s\n" "#define ARES_BIG_ENDIAN 1" >>confdefs.h
+;; #(
+   no)
+      ;; #(
+   universal)
+
+printf "%s\n" "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
+
+     ;; #(
+   *)
+     { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: couldn't figure out endianess, assuming little endian!" >&5
+printf "%s\n" "$as_me: WARNING: couldn't figure out endianess, assuming little endian!" >&2;}
+ ;;
+ esac
+
+
+
+# Check whether --with-random was given.
+if test ${with_random+y}
+then :
+  withval=$with_random;  CARES_RANDOM_FILE="$withval"
+else $as_nop
+
+                                if test "$cross_compiling" = "no"; then
+          as_ac_File=`printf "%s\n" "ac_cv_file_"/dev/urandom"" | $as_tr_sh`
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for \"/dev/urandom\"" >&5
+printf %s "checking for \"/dev/urandom\"... " >&6; }
+if eval test \${$as_ac_File+y}
+then :
+  printf %s "(cached) " >&6
+else $as_nop
+  test "$cross_compiling" = yes &&
+  as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5
+if test -r ""/dev/urandom""; then
+  eval "$as_ac_File=yes"
+else
+  eval "$as_ac_File=no"
+fi
+fi
+eval ac_res=\$$as_ac_File
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+if eval test \"x\$"$as_ac_File"\" = x"yes"
+then :
+   CARES_RANDOM_FILE="/dev/urandom"
+fi
+
+        else
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cannot check for /dev/urandom while cross compiling; assuming none" >&5
+printf "%s\n" "$as_me: WARNING: cannot check for /dev/urandom while cross compiling; assuming none" >&2;}
+        fi
+
+
+
+fi
+
+if test -n "$CARES_RANDOM_FILE" && test X"$CARES_RANDOM_FILE" != Xno ; then
+
+
+printf "%s\n" "#define CARES_RANDOM_FILE \"$CARES_RANDOM_FILE\"" >>confdefs.h
+
+fi
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable non-blocking communications" >&5
+printf %s "checking whether to enable non-blocking communications... " >&6; }
+  OPT_NONBLOCKING="default"
+  # Check whether --enable-nonblocking was given.
+if test ${enable_nonblocking+y}
+then :
+  enableval=$enable_nonblocking; OPT_NONBLOCKING=$enableval
+fi
+
+  case "$OPT_NONBLOCKING" in
+    no)
+            want_nonblocking="no"
+      ;;
+    default)
+            want_nonblocking="yes"
+      ;;
+    *)
+            want_nonblocking="yes"
+      ;;
+  esac
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $want_nonblocking" >&5
+printf "%s\n" "$want_nonblocking" >&6; }
+
+
+              #
+  tst_method="unknown"
+  if test "$want_nonblocking" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to set a socket into non-blocking mode" >&5
+printf %s "checking how to set a socket into non-blocking mode... " >&6; }
+    if test "x$ac_cv_func_fcntl_o_nonblock" = "xyes"; then
+      tst_method="fcntl O_NONBLOCK"
+    elif test "x$ac_cv_func_ioctl_fionbio" = "xyes"; then
+      tst_method="ioctl FIONBIO"
+    elif test "x$ac_cv_func_ioctlsocket_fionbio" = "xyes"; then
+      tst_method="ioctlsocket FIONBIO"
+    elif test "x$ac_cv_func_ioctlsocket_camel_fionbio" = "xyes"; then
+      tst_method="IoctlSocket FIONBIO"
+    elif test "x$ac_cv_func_setsockopt_so_nonblock" = "xyes"; then
+      tst_method="setsockopt SO_NONBLOCK"
+    fi
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tst_method" >&5
+printf "%s\n" "$tst_method" >&6; }
+    if test "$tst_method" = "unknown"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cannot determine non-blocking socket method." >&5
+printf "%s\n" "$as_me: WARNING: cannot determine non-blocking socket method." >&2;}
+    fi
+  fi
+  if test "$tst_method" = "unknown"; then
+
+printf "%s\n" "#define USE_BLOCKING_SOCKETS 1" >>confdefs.h
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: non-blocking sockets disabled." >&5
+printf "%s\n" "$as_me: WARNING: non-blocking sockets disabled." >&2;}
+  fi
+
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether hiding of library internal symbols will actually happen" >&5
+printf %s "checking whether hiding of library internal symbols will actually happen... " >&6; }
+  CFLAG_CARES_SYMBOL_HIDING=""
+  doing_symbol_hiding="no"
+  if test x"$ac_cv_native_windows" != "xyes" &&
+    test "$want_symbol_hiding" = "yes" &&
+    test "$supports_symbol_hiding" = "yes"; then
+    doing_symbol_hiding="yes"
+    CFLAG_CARES_SYMBOL_HIDING="$symbol_hiding_CFLAGS"
+
+printf "%s\n" "#define CARES_SYMBOL_SCOPE_EXTERN $symbol_hiding_EXTERN" >>confdefs.h
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+   if test x$doing_symbol_hiding = xyes; then
+  DOING_CARES_SYMBOL_HIDING_TRUE=
+  DOING_CARES_SYMBOL_HIDING_FALSE='#'
+else
+  DOING_CARES_SYMBOL_HIDING_TRUE='#'
+  DOING_CARES_SYMBOL_HIDING_FALSE=
+fi
+
+
+  if test "$doing_symbol_hiding" = "yes"; then
+
+printf "%s\n" "#define CARES_SYMBOL_HIDING 1" >>confdefs.h
+
+  fi
+
+
+CARES_PRIVATE_LIBS="$LIBS"
+
+
+CARES_CFLAG_EXTRAS=""
+if test X"$want_werror" = Xyes; then
+  CARES_CFLAG_EXTRAS="-Werror"
+fi
+
+
+
+squeeze CFLAGS
+squeeze CPPFLAGS
+squeeze DEFS
+squeeze LDFLAGS
+squeeze LIBS
+
+squeeze CARES_PRIVATE_LIBS
+
+
+
+  xc_bad_var_libs=no
+  for xc_word in $LIBS; do
+    case "$xc_word" in
+      -l* | --library=*)
+        :
+        ;;
+      *)
+        xc_bad_var_libs=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_libs = yes; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: using LIBS: $LIBS" >&5
+printf "%s\n" "$as_me: using LIBS: $LIBS" >&6;}
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: LIBS error: LIBS may only be used to specify libraries (-lname)." >&5
+printf "%s\n" "$as_me: LIBS error: LIBS may only be used to specify libraries (-lname)." >&6;}
+  fi
+
+
+  xc_bad_var_ldflags=no
+  for xc_word in $LDFLAGS; do
+    case "$xc_word" in
+      -D*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -U*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -I*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_ldflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_ldflags = yes; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: using LDFLAGS: $LDFLAGS" >&5
+printf "%s\n" "$as_me: using LDFLAGS: $LDFLAGS" >&6;}
+    xc_bad_var_msg="LDFLAGS error: LDFLAGS may only be used to specify linker flags, not"
+    for xc_word in $LDFLAGS; do
+      case "$xc_word" in
+        -D*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -U*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -I*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -l* | --library=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&6;}
+          ;;
+      esac
+    done
+  fi
+
+
+  xc_bad_var_cppflags=no
+  for xc_word in $CPPFLAGS; do
+    case "$xc_word" in
+      -rpath*)
+        xc_bad_var_cppflags=yes
+        ;;
+      -L* | --library-path=*)
+        xc_bad_var_cppflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_cppflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_cppflags = yes; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: using CPPFLAGS: $CPPFLAGS" >&5
+printf "%s\n" "$as_me: using CPPFLAGS: $CPPFLAGS" >&6;}
+    xc_bad_var_msg="CPPFLAGS error: CPPFLAGS may only be used to specify C preprocessor flags, not"
+    for xc_word in $CPPFLAGS; do
+      case "$xc_word" in
+        -rpath*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word" >&6;}
+          ;;
+        -L* | --library-path=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word" >&6;}
+          ;;
+        -l* | --library=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&6;}
+          ;;
+      esac
+    done
+  fi
+
+
+  xc_bad_var_cflags=no
+  for xc_word in $CFLAGS; do
+    case "$xc_word" in
+      -D*)
+        xc_bad_var_cflags=yes
+        ;;
+      -U*)
+        xc_bad_var_cflags=yes
+        ;;
+      -I*)
+        xc_bad_var_cflags=yes
+        ;;
+      -rpath*)
+        xc_bad_var_cflags=yes
+        ;;
+      -L* | --library-path=*)
+        xc_bad_var_cflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_cflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_cflags = yes; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: using CFLAGS: $CFLAGS" >&5
+printf "%s\n" "$as_me: using CFLAGS: $CFLAGS" >&6;}
+    xc_bad_var_msg="CFLAGS error: CFLAGS may only be used to specify C compiler flags, not"
+    for xc_word in $CFLAGS; do
+      case "$xc_word" in
+        -D*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -U*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -I*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word" >&6;}
+          ;;
+        -rpath*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word" >&6;}
+          ;;
+        -L* | --library-path=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word" >&6;}
+          ;;
+        -l* | --library=*)
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&5
+printf "%s\n" "$as_me: $xc_bad_var_msg libraries. Use LIBS for: $xc_word" >&6;}
+          ;;
+      esac
+    done
+  fi
+
+  if test $xc_bad_var_libs = yes ||
+     test $xc_bad_var_cflags = yes ||
+     test $xc_bad_var_ldflags = yes ||
+     test $xc_bad_var_cppflags = yes; then
+     { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Continuing even with errors mentioned immediately above this line." >&5
+printf "%s\n" "$as_me: WARNING: Continuing even with errors mentioned immediately above this line." >&2;}
+  fi
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build tests" >&5
+printf %s "checking whether to build tests... " >&6; }
+# Check whether --enable-tests was given.
+if test ${enable_tests+y}
+then :
+  enableval=$enable_tests;  build_tests="$enableval"
+else $as_nop
+   if test "x$HAVE_CXX11" = "x1" && test "x$cross_compiling" = "xno" ; then
+	    build_tests="yes"
+	  else
+	    build_tests="no"
+	  fi
+
+
+fi
+
+
+if test "x$build_tests" = "xyes" ; then
+	if test "x$HAVE_CXX11" = "0" ; then
+		as_fn_error $? "*** Building tests requires a CXX11 compiler" "$LINENO" 5
+	fi
+	if test "x$cross_compiling" = "xyes" ; then
+		as_fn_error $? "*** Tests not supported when cross compiling" "$LINENO" 5
+	fi
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $build_tests" >&5
+printf "%s\n" "$build_tests" >&6; }
+
+
+BUILD_SUBDIRS="include src docs"
+if test "x$build_tests" = "xyes" ; then
+
+
+subdirs="$subdirs test"
+
+  BUILD_SUBDIRS="${BUILD_SUBDIRS} test"
+fi
+
+
+
+ac_config_files="$ac_config_files Makefile include/Makefile src/Makefile src/lib/Makefile src/tools/Makefile docs/Makefile libcares.pc"
+
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+printf "%s\n" "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
+  as_fn_error $? "conditional \"MAINTAINER_MODE\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${CODE_COVERAGE_ENABLED_TRUE}" && test -z "${CODE_COVERAGE_ENABLED_FALSE}"; then
+  as_fn_error $? "conditional \"CODE_COVERAGE_ENABLED\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
+printf %s "checking that generated files are newer than configure... " >&6; }
+   if test -n "$am_sleep_pid"; then
+     # Hide warnings about reused PIDs.
+     wait $am_sleep_pid 2>/dev/null
+   fi
+   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: done" >&5
+printf "%s\n" "done" >&6; }
+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
+  as_fn_error $? "conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCXX\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+ if test -n "$EXEEXT"; then
+  am__EXEEXT_TRUE=
+  am__EXEEXT_FALSE='#'
+else
+  am__EXEEXT_TRUE='#'
+  am__EXEEXT_FALSE=
+fi
+
+if test -z "${CARES_LT_SHLIB_USE_VERSION_INFO_TRUE}" && test -z "${CARES_LT_SHLIB_USE_VERSION_INFO_FALSE}"; then
+  as_fn_error $? "conditional \"CARES_LT_SHLIB_USE_VERSION_INFO\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${CARES_LT_SHLIB_USE_NO_UNDEFINED_TRUE}" && test -z "${CARES_LT_SHLIB_USE_NO_UNDEFINED_FALSE}"; then
+  as_fn_error $? "conditional \"CARES_LT_SHLIB_USE_NO_UNDEFINED\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${CARES_LT_SHLIB_USE_MIMPURE_TEXT_TRUE}" && test -z "${CARES_LT_SHLIB_USE_MIMPURE_TEXT_FALSE}"; then
+  as_fn_error $? "conditional \"CARES_LT_SHLIB_USE_MIMPURE_TEXT\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${USE_CPPFLAG_CARES_STATICLIB_TRUE}" && test -z "${USE_CPPFLAG_CARES_STATICLIB_FALSE}"; then
+  as_fn_error $? "conditional \"USE_CPPFLAG_CARES_STATICLIB\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${DOING_NATIVE_WINDOWS_TRUE}" && test -z "${DOING_NATIVE_WINDOWS_FALSE}"; then
+  as_fn_error $? "conditional \"DOING_NATIVE_WINDOWS\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+
+if test -z "${DOING_CARES_SYMBOL_HIDING_TRUE}" && test -z "${DOING_CARES_SYMBOL_HIDING_FALSE}"; then
+  as_fn_error $? "conditional \"DOING_CARES_SYMBOL_HIDING\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+as_nop=:
+if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
+then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else $as_nop
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+
+# Reset variables that may have inherited troublesome values from
+# the environment.
+
+# IFS needs to be set, to space, tab, and newline, in precisely that order.
+# (If _AS_PATH_WALK were called with IFS unset, it would have the
+# side effect of setting IFS to empty, thus disabling word splitting.)
+# Quoting is to prevent editors from complaining about space-tab.
+as_nl='
+'
+export as_nl
+IFS=" ""	$as_nl"
+
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# Ensure predictable behavior from utilities with locale-dependent output.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# We cannot yet rely on "unset" to work, but we need these variables
+# to be unset--not just set to an empty or harmless value--now, to
+# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh).  This construct
+# also avoids known problems related to "unset" and subshell syntax
+# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
+for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
+do eval test \${$as_var+y} \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+
+# Ensure that fds 0, 1, and 2 are open.
+if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi
+if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
+if (exec 3>&2)            ; then :; else exec 2>/dev/null; fi
+
+
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    test -r "$as_dir$0" && as_myself=$as_dir$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  printf "%s\n" "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
+then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else $as_nop
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
+then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else $as_nop
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+# Determine whether it's possible to make 'echo' print without a newline.
+# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
+# for compatibility with existing Makefiles.
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+# For backward compatibility with old third-party macros, we provide
+# the shell variables $as_echo and $as_echo_n.  New code should use
+# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
+as_echo='printf %s\n'
+as_echo_n='printf %s'
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by c-ares $as_me 1.18.1, which was
+generated by GNU Autoconf 2.71.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+case $ac_config_headers in *"
+"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
+esac
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
+config_commands="$ac_config_commands"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 [OPTION]... [TAG]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
+      --header=FILE[:TEMPLATE]
+                   instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Configuration commands:
+$config_commands
+
+Report bugs to <c-ares mailing list: http://lists.haxx.se/listinfo/c-ares>."
+
+_ACEOF
+ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"`
+ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"`
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config='$ac_cs_config_escaped'
+ac_cs_version="\\
+c-ares config.status 1.18.1
+configured by $0, generated by GNU Autoconf 2.71,
+  with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2021 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+INSTALL='$INSTALL'
+MKDIR_P='$MKDIR_P'
+AWK='$AWK'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=?*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    printf "%s\n" "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    printf "%s\n" "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h)
+    # Conflict between --help and --header
+    as_fn_error $? "ambiguous option: \`$1'
+Try \`$0 --help' for more information.";;
+  --help | --hel | -h )
+    printf "%s\n" "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  printf "%s\n" "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+#
+# INIT-COMMANDS
+#
+AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
+
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
+macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
+AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`'
+DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`'
+OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`'
+enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
+enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
+pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
+enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
+shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`'
+SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
+ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
+PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`'
+host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`'
+host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`'
+host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`'
+build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`'
+build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`'
+build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`'
+SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`'
+Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`'
+GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`'
+EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`'
+FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`'
+LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`'
+NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`'
+LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`'
+max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`'
+ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`'
+exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`'
+lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`'
+lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`'
+lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`'
+lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`'
+lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`'
+reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
+reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
+deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`'
+file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`'
+file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`'
+want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`'
+sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`'
+AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`'
+AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`'
+archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`'
+STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`'
+RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`'
+old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`'
+lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`'
+CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`'
+CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`'
+compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`'
+GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`'
+lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $SED "$delay_single_quote_subst"`'
+nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`'
+lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`'
+lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $SED "$delay_single_quote_subst"`'
+objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
+MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`'
+need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`'
+MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`'
+DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`'
+NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`'
+LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`'
+OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`'
+OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`'
+libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`'
+shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`'
+extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`'
+hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`'
+inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`'
+always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`'
+include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`'
+prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`'
+postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`'
+file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`'
+variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`'
+need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`'
+need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`'
+version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`'
+runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`'
+libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`'
+library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`'
+soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`'
+install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`'
+postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`'
+finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
+hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
+sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
+configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
+configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
+hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
+enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`'
+old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`'
+striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`'
+predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`'
+postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`'
+predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`'
+postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`'
+LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`'
+reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`'
+reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`'
+GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`'
+inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`'
+always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
+include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
+prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`'
+predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`'
+postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`'
+predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`'
+postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`'
+
+LTCC='$LTCC'
+LTCFLAGS='$LTCFLAGS'
+compiler='$compiler_DEFAULT'
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+
+# Quote evaled strings.
+for var in AS \
+DLLTOOL \
+OBJDUMP \
+SHELL \
+ECHO \
+PATH_SEPARATOR \
+SED \
+GREP \
+EGREP \
+FGREP \
+LD \
+NM \
+LN_S \
+lt_SP2NL \
+lt_NL2SP \
+reload_flag \
+deplibs_check_method \
+file_magic_cmd \
+file_magic_glob \
+want_nocaseglob \
+sharedlib_from_linklib_cmd \
+AR \
+AR_FLAGS \
+archiver_list_spec \
+STRIP \
+RANLIB \
+CC \
+CFLAGS \
+compiler \
+lt_cv_sys_global_symbol_pipe \
+lt_cv_sys_global_symbol_to_cdecl \
+lt_cv_sys_global_symbol_to_import \
+lt_cv_sys_global_symbol_to_c_name_address \
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
+lt_cv_nm_interface \
+nm_file_list_spec \
+lt_cv_truncate_bin \
+lt_prog_compiler_no_builtin_flag \
+lt_prog_compiler_pic \
+lt_prog_compiler_wl \
+lt_prog_compiler_static \
+lt_cv_prog_compiler_c_o \
+need_locks \
+MANIFEST_TOOL \
+DSYMUTIL \
+NMEDIT \
+LIPO \
+OTOOL \
+OTOOL64 \
+shrext_cmds \
+export_dynamic_flag_spec \
+whole_archive_flag_spec \
+compiler_needs_object \
+with_gnu_ld \
+allow_undefined_flag \
+no_undefined_flag \
+hardcode_libdir_flag_spec \
+hardcode_libdir_separator \
+exclude_expsyms \
+include_expsyms \
+file_list_spec \
+variables_saved_for_relink \
+libname_spec \
+library_names_spec \
+soname_spec \
+install_override_mode \
+finish_eval \
+old_striplib \
+striplib \
+compiler_lib_search_dirs \
+predep_objects \
+postdep_objects \
+predeps \
+postdeps \
+compiler_lib_search_path \
+LD_CXX \
+reload_flag_CXX \
+compiler_CXX \
+lt_prog_compiler_no_builtin_flag_CXX \
+lt_prog_compiler_pic_CXX \
+lt_prog_compiler_wl_CXX \
+lt_prog_compiler_static_CXX \
+lt_cv_prog_compiler_c_o_CXX \
+export_dynamic_flag_spec_CXX \
+whole_archive_flag_spec_CXX \
+compiler_needs_object_CXX \
+with_gnu_ld_CXX \
+allow_undefined_flag_CXX \
+no_undefined_flag_CXX \
+hardcode_libdir_flag_spec_CXX \
+hardcode_libdir_separator_CXX \
+exclude_expsyms_CXX \
+include_expsyms_CXX \
+file_list_spec_CXX \
+compiler_lib_search_dirs_CXX \
+predep_objects_CXX \
+postdep_objects_CXX \
+predeps_CXX \
+postdeps_CXX \
+compiler_lib_search_path_CXX; do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *[\\\\\\\`\\"\\\$]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+# Double-quote double-evaled strings.
+for var in reload_cmds \
+old_postinstall_cmds \
+old_postuninstall_cmds \
+old_archive_cmds \
+extract_expsyms_cmds \
+old_archive_from_new_cmds \
+old_archive_from_expsyms_cmds \
+archive_cmds \
+archive_expsym_cmds \
+module_cmds \
+module_expsym_cmds \
+export_symbols_cmds \
+prelink_cmds \
+postlink_cmds \
+postinstall_cmds \
+postuninstall_cmds \
+finish_cmds \
+sys_lib_search_path_spec \
+configure_time_dlsearch_path \
+configure_time_lt_sys_library_path \
+reload_cmds_CXX \
+old_archive_cmds_CXX \
+old_archive_from_new_cmds_CXX \
+old_archive_from_expsyms_cmds_CXX \
+archive_cmds_CXX \
+archive_expsym_cmds_CXX \
+module_cmds_CXX \
+module_expsym_cmds_CXX \
+export_symbols_cmds_CXX \
+prelink_cmds_CXX \
+postlink_cmds_CXX; do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *[\\\\\\\`\\"\\\$]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+ac_aux_dir='$ac_aux_dir'
+
+# See if we are running on zsh, and set the options that allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}"; then
+   setopt NO_GLOB_SUBST
+fi
+
+
+    PACKAGE='$PACKAGE'
+    VERSION='$VERSION'
+    RM='$RM'
+    ofile='$ofile'
+
+
+
+
+
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "src/lib/ares_config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/lib/ares_config.h" ;;
+    "include/ares_build.h") CONFIG_HEADERS="$CONFIG_HEADERS include/ares_build.h" ;;
+    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
+    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+    "include/Makefile") CONFIG_FILES="$CONFIG_FILES include/Makefile" ;;
+    "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
+    "src/lib/Makefile") CONFIG_FILES="$CONFIG_FILES src/lib/Makefile" ;;
+    "src/tools/Makefile") CONFIG_FILES="$CONFIG_FILES src/tools/Makefile" ;;
+    "docs/Makefile") CONFIG_FILES="$CONFIG_FILES docs/Makefile" ;;
+    "libcares.pc") CONFIG_FILES="$CONFIG_FILES libcares.pc" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files
+  test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers
+  test ${CONFIG_COMMANDS+y} || CONFIG_COMMANDS=$config_commands
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\)..*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\)..*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
+h
+s///
+s/^/:/
+s/[	 ]*$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/\(=[	 ]*\).*/\1/
+G
+s/\n//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+# Set up the scripts for CONFIG_HEADERS section.
+# No need to generate them if there are no CONFIG_HEADERS.
+# This happens for instance with `./config.status Makefile'.
+if test -n "$CONFIG_HEADERS"; then
+cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
+BEGIN {
+_ACEOF
+
+# Transform confdefs.h into an awk script `defines.awk', embedded as
+# here-document in config.status, that substitutes the proper values into
+# config.h.in to produce config.h.
+
+# Create a delimiter string that does not exist in confdefs.h, to ease
+# handling of long lines.
+ac_delim='%!_!# '
+for ac_last_try in false false :; do
+  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
+  if test -z "$ac_tt"; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+
+# For the awk script, D is an array of macro values keyed by name,
+# likewise P contains macro parameters if any.  Preserve backslash
+# newline sequences.
+
+ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
+sed -n '
+s/.\{148\}/&'"$ac_delim"'/g
+t rset
+:rset
+s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
+t def
+d
+:def
+s/\\$//
+t bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3"/p
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
+d
+:bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3\\\\\\n"\\/p
+t cont
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
+t cont
+d
+:cont
+n
+s/.\{148\}/&'"$ac_delim"'/g
+t clear
+:clear
+s/\\$//
+t bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/"/p
+d
+:bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
+b cont
+' <confdefs.h | sed '
+s/'"$ac_delim"'/"\\\
+"/g' >>$CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  for (key in D) D_is_set[key] = 1
+  FS = ""
+}
+/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
+  line = \$ 0
+  split(line, arg, " ")
+  if (arg[1] == "#") {
+    defundef = arg[2]
+    mac1 = arg[3]
+  } else {
+    defundef = substr(arg[1], 2)
+    mac1 = arg[2]
+  }
+  split(mac1, mac2, "(") #)
+  macro = mac2[1]
+  prefix = substr(line, 1, index(line, defundef) - 1)
+  if (D_is_set[macro]) {
+    # Preserve the white space surrounding the "#".
+    print prefix "define", macro P[macro] D[macro]
+    next
+  } else {
+    # Replace #undef with comments.  This is necessary, for example,
+    # in the case of _POSIX_SOURCE, which is predefined and required
+    # on some systems where configure will not decide to define it.
+    if (defundef == "undef") {
+      print "/*", prefix defundef, macro, "*/"
+      next
+    }
+  }
+}
+{ print }
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
+fi # test -n "$CONFIG_HEADERS"
+
+
+eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+printf "%s\n" "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`printf "%s\n" "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+  esac
+  ac_MKDIR_P=$MKDIR_P
+  case $MKDIR_P in
+  [\\/$]* | ?:[\\/]* ) ;;
+  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
+  esac
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+s&@INSTALL@&$ac_INSTALL&;t t
+s&@MKDIR_P@&$ac_MKDIR_P&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+  :H)
+  #
+  # CONFIG_HEADER
+  #
+  if test x"$ac_file" != x-; then
+    {
+      printf "%s\n" "/* $configure_input  */" >&1 \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
+    } >"$ac_tmp/config.h" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+printf "%s\n" "$as_me: $ac_file is unchanged" >&6;}
+    else
+      rm -f "$ac_file"
+      mv "$ac_tmp/config.h" "$ac_file" \
+	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    fi
+  else
+    printf "%s\n" "/* $configure_input  */" >&1 \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
+      || as_fn_error $? "could not create -" "$LINENO" 5
+  fi
+# Compute "$ac_file"'s index in $config_headers.
+_am_arg="$ac_file"
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
+$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$_am_arg" : 'X\(//\)[^/]' \| \
+	 X"$_am_arg" : 'X\(//\)$' \| \
+	 X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X"$_am_arg" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`/stamp-h$_am_stamp_count
+ ;;
+
+  :C)  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+printf "%s\n" "$as_me: executing $ac_file commands" >&6;}
+ ;;
+  esac
+
+
+  case $ac_file$ac_mode in
+    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
+  # Older Autoconf quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  case $CONFIG_FILES in #(
+  *\'*) :
+    eval set x "$CONFIG_FILES" ;; #(
+  *) :
+    set x $CONFIG_FILES ;; #(
+  *) :
+     ;;
+esac
+  shift
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
+  do
+    # Strip MF so we end up with the name of the file.
+    am_mf=`printf "%s\n" "$am_mf" | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`$as_dirname -- "$am_mf" ||
+$as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$am_mf" : 'X\(//\)[^/]' \| \
+	 X"$am_mf" : 'X\(//\)$' \| \
+	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X"$am_mf" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    am_filepart=`$as_basename -- "$am_mf" ||
+$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$am_mf" : 'X\(//\)$' \| \
+	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
+printf "%s\n" X/"$am_mf" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    { echo "$as_me:$LINENO: cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles" >&5
+   (cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } || am_rc=$?
+  done
+  if test $am_rc -ne 0; then
+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  If GNU make was not used, consider
+    re-running the configure script with MAKE=\"gmake\" (or whatever is
+    necessary).  You can also try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+  { am_dirpart=; unset am_dirpart;}
+  { am_filepart=; unset am_filepart;}
+  { am_mf=; unset am_mf;}
+  { am_rc=; unset am_rc;}
+  rm -f conftest-deps.mk
+}
+ ;;
+    "libtool":C)
+
+    # See if we are running on zsh, and set the options that allow our
+    # commands through without removal of \ escapes.
+    if test -n "${ZSH_VERSION+set}"; then
+      setopt NO_GLOB_SUBST
+    fi
+
+    cfgfile=${ofile}T
+    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
+    $RM "$cfgfile"
+
+    cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+# Generated automatically by $as_me ($PACKAGE) $VERSION
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit, 1996
+
+# Copyright (C) 2014 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of of the License, or
+# (at your option) any later version.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program or library that is built
+# using GNU Libtool, you may include this file under the  same
+# distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# The names of the tagged configurations supported by this script.
+available_tags='CXX '
+
+# Configured defaults for sys_lib_dlsearch_path munging.
+: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
+
+# ### BEGIN LIBTOOL CONFIG
+
+# Which release of libtool.m4 was used?
+macro_version=$macro_version
+macro_revision=$macro_revision
+
+# Assembler program.
+AS=$lt_AS
+
+# DLL creation program.
+DLLTOOL=$lt_DLLTOOL
+
+# Object dumper program.
+OBJDUMP=$lt_OBJDUMP
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# What type of objects to build.
+pic_mode=$pic_mode
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# Shared archive member basename,for filename based shared library versioning on AIX.
+shared_archive_member_spec=$shared_archive_member_spec
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# An echo program that protects backslashes.
+ECHO=$lt_ECHO
+
+# The PATH separator for the build system.
+PATH_SEPARATOR=$lt_PATH_SEPARATOR
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# A sed program that does not truncate output.
+SED=$lt_SED
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="\$SED -e 1s/^X//"
+
+# A grep program that handles long lines.
+GREP=$lt_GREP
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# A literal string matcher.
+FGREP=$lt_FGREP
+
+# A BSD- or MS-compatible name lister.
+NM=$lt_NM
+
+# Whether we need soft or hard links.
+LN_S=$lt_LN_S
+
+# What is the maximum length of a command?
+max_cmd_len=$max_cmd_len
+
+# Object file suffix (normally "o").
+objext=$ac_objext
+
+# Executable file suffix (normally "").
+exeext=$exeext
+
+# whether the shell understands "unset".
+lt_unset=$lt_unset
+
+# turn spaces into newlines.
+SP2NL=$lt_lt_SP2NL
+
+# turn newlines into spaces.
+NL2SP=$lt_lt_NL2SP
+
+# convert \$build file names to \$host format.
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+
+# convert \$build files to toolchain format.
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method = "file_magic".
+file_magic_cmd=$lt_file_magic_cmd
+
+# How to find potential files when deplibs_check_method = "file_magic".
+file_magic_glob=$lt_file_magic_glob
+
+# Find potential files using nocaseglob when deplibs_check_method = "file_magic".
+want_nocaseglob=$lt_want_nocaseglob
+
+# Command to associate shared and link libraries.
+sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd
+
+# The archiver.
+AR=$lt_AR
+
+# Flags to create an archive.
+AR_FLAGS=$lt_AR_FLAGS
+
+# How to feed a file listing to the archiver.
+archiver_list_spec=$lt_archiver_list_spec
+
+# A symbol stripping program.
+STRIP=$lt_STRIP
+
+# Commands used to install an old-style archive.
+RANLIB=$lt_RANLIB
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Whether to use a lock for old archive extraction.
+lock_old_archive_extraction=$lock_old_archive_extraction
+
+# A C compiler.
+LTCC=$lt_CC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_CFLAGS
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration.
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm into a list of symbols to manually relocate.
+global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import
+
+# Transform the output of nm in a C name address pair.
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# Transform the output of nm in a C name address pair when lib prefix is needed.
+global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix
+
+# The name lister interface.
+nm_interface=$lt_lt_cv_nm_interface
+
+# Specify filename containing input files for \$NM.
+nm_file_list_spec=$lt_nm_file_list_spec
+
+# The root where to search for dependent libraries,and where our libraries should be installed.
+lt_sysroot=$lt_sysroot
+
+# Command to truncate a binary pipe.
+lt_truncate_bin=$lt_lt_cv_truncate_bin
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# Used to examine libraries when file_magic_cmd begins with "file".
+MAGIC_CMD=$MAGIC_CMD
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Manifest tool.
+MANIFEST_TOOL=$lt_MANIFEST_TOOL
+
+# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
+DSYMUTIL=$lt_DSYMUTIL
+
+# Tool to change global to local symbols on Mac OS X.
+NMEDIT=$lt_NMEDIT
+
+# Tool to manipulate fat objects and archives on Mac OS X.
+LIPO=$lt_LIPO
+
+# ldd/readelf like tool for Mach-O binaries on Mac OS X.
+OTOOL=$lt_OTOOL
+
+# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
+OTOOL64=$lt_OTOOL64
+
+# Old archive suffix (normally "a").
+libext=$libext
+
+# Shared library suffix (normally ".so").
+shrext_cmds=$lt_shrext_cmds
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at link time.
+variables_saved_for_relink=$lt_variables_saved_for_relink
+
+# Do we need the "lib" prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Library versioning type.
+version_type=$version_type
+
+# Shared library runtime path variable.
+runpath_var=$runpath_var
+
+# Shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Permission mode override for installation of shared libraries.
+install_override_mode=$lt_install_override_mode
+
+# Command to use after installation of a shared archive.
+postinstall_cmds=$lt_postinstall_cmds
+
+# Command to use after uninstallation of a shared archive.
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# As "finish_cmds", except a single script fragment to be evaled but
+# not shown.
+finish_eval=$lt_finish_eval
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Compile-time system search path for libraries.
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Detected run-time system search path for libraries.
+sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
+
+# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
+configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+
+# The linker used to build libraries.
+LD=$lt_LD
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds
+
+# A language specific compiler.
+CC=$lt_compiler
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds
+archive_expsym_cmds=$lt_archive_expsym_cmds
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds
+module_expsym_cmds=$lt_module_expsym_cmds
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds
+
+# Commands necessary for finishing linking programs.
+postlink_cmds=$lt_postlink_cmds
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action
+
+# The directories searched by this compiler when creating a shared library.
+compiler_lib_search_dirs=$lt_compiler_lib_search_dirs
+
+# Dependencies to place before and after the objects being linked to
+# create a shared library.
+predep_objects=$lt_predep_objects
+postdep_objects=$lt_postdep_objects
+predeps=$lt_predeps
+postdeps=$lt_postdeps
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path
+
+# ### END LIBTOOL CONFIG
+
+_LT_EOF
+
+    cat <<'_LT_EOF' >> "$cfgfile"
+
+# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
+
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR[:DIR]:"
+#       string "DIR[ DIR]" will be prepended to VARIABLE
+# ":DIR[:DIR]"
+#       string "DIR[ DIR]" will be appended to VARIABLE
+# "DIRP[:DIRP]::[DIRA:]DIRA"
+#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
+#       "DIRA[ DIRA]" will be appended to VARIABLE
+# "DIR[:DIR]"
+#       VARIABLE will be replaced by "DIR[ DIR]"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
+
+# ### END FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_EOF
+
+  case $host_os in
+  aix3*)
+    cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test set != "${COLLECT_NAMES+set}"; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+_LT_EOF
+    ;;
+  esac
+
+
+
+ltmain=$ac_aux_dir/ltmain.sh
+
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '$q' "$ltmain" >> "$cfgfile" \
+     || (rm -f "$cfgfile"; exit 1)
+
+   mv -f "$cfgfile" "$ofile" ||
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+
+
+    cat <<_LT_EOF >> "$ofile"
+
+# ### BEGIN LIBTOOL TAG CONFIG: CXX
+
+# The linker used to build libraries.
+LD=$lt_LD_CXX
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag_CXX
+reload_cmds=$lt_reload_cmds_CXX
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds_CXX
+
+# A language specific compiler.
+CC=$lt_compiler_CXX
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC_CXX
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic_CXX
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl_CXX
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static_CXX
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc_CXX
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object_CXX
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds_CXX
+archive_expsym_cmds=$lt_archive_expsym_cmds_CXX
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds_CXX
+module_expsym_cmds=$lt_module_expsym_cmds_CXX
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld_CXX
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag_CXX
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag_CXX
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct_CXX
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute_CXX
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L_CXX
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic_CXX
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath_CXX
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs_CXX
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols_CXX
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds_CXX
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms_CXX
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms_CXX
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds_CXX
+
+# Commands necessary for finishing linking programs.
+postlink_cmds=$lt_postlink_cmds_CXX
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec_CXX
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action_CXX
+
+# The directories searched by this compiler when creating a shared library.
+compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX
+
+# Dependencies to place before and after the objects being linked to
+# create a shared library.
+predep_objects=$lt_predep_objects_CXX
+postdep_objects=$lt_postdep_objects_CXX
+predeps=$lt_predeps_CXX
+postdeps=$lt_postdeps_CXX
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path_CXX
+
+# ### END LIBTOOL TAG CONFIG: CXX
+_LT_EOF
+
+ ;;
+
+  esac
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit 1
+fi
+
+#
+# CONFIG_SUBDIRS section.
+#
+if test "$no_recursion" != yes; then
+
+  # Remove --cache-file, --srcdir, and --disable-option-checking arguments
+  # so they do not pile up.
+  ac_sub_configure_args=
+  ac_prev=
+  eval "set x $ac_configure_args"
+  shift
+  for ac_arg
+  do
+    if test -n "$ac_prev"; then
+      ac_prev=
+      continue
+    fi
+    case $ac_arg in
+    -cache-file | --cache-file | --cache-fil | --cache-fi \
+    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+      ac_prev=cache_file ;;
+    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
+    | --c=*)
+      ;;
+    --config-cache | -C)
+      ;;
+    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+      ac_prev=srcdir ;;
+    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+      ;;
+    -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+      ac_prev=prefix ;;
+    -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+      ;;
+    --disable-option-checking)
+      ;;
+    *)
+      case $ac_arg in
+      *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+      esac
+      as_fn_append ac_sub_configure_args " '$ac_arg'" ;;
+    esac
+  done
+
+  # Always prepend --prefix to ensure using the same prefix
+  # in subdir configurations.
+  ac_arg="--prefix=$prefix"
+  case $ac_arg in
+  *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+  esac
+  ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
+
+  # Pass --silent
+  if test "$silent" = yes; then
+    ac_sub_configure_args="--silent $ac_sub_configure_args"
+  fi
+
+  # Always prepend --disable-option-checking to silence warnings, since
+  # different subdirs can have different --enable and --with options.
+  ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args"
+
+  ac_popdir=`pwd`
+  for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
+
+    # Do not complain, so a configure script can configure whichever
+    # parts of a large source tree are present.
+    test -d "$srcdir/$ac_dir" || continue
+
+    ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5
+    printf "%s\n" "$ac_msg" >&6
+    as_dir="$ac_dir"; as_fn_mkdir_p
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+    cd "$ac_dir"
+
+    # Check for configure.gnu first; this name is used for a wrapper for
+    # Metaconfig's "Configure" on case-insensitive file systems.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      ac_sub_configure=$ac_srcdir/configure.gnu
+    elif test -f "$ac_srcdir/configure"; then
+      ac_sub_configure=$ac_srcdir/configure
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5
+printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
+      ac_sub_configure=
+    fi
+
+    # The recursion is here.
+    if test -n "$ac_sub_configure"; then
+      # Make the cache file name correct relative to the subdirectory.
+      case $cache_file in
+      [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;;
+      *) # Relative name.
+	ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
+      esac
+
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5
+printf "%s\n" "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
+      # The eval makes quoting arguments work.
+      eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
+	   --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
+	as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5
+    fi
+
+    cd "$ac_popdir"
+  done
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
+
+## ---------------------------------- ##
+##  Start of distclean amending code  ##
+## ---------------------------------- ##
+
+for xc_subdir in '.'
+do
+
+if test ! -f "$xc_subdir/Makefile"; then
+  echo "$xc_msg_err $xc_subdir/Makefile file not found. $xc_msg_abrt" >&2
+  exit 1
+fi
+
+# Fetch dependency tracking file list from Makefile include lines.
+
+xc_inc_lines=`grep '^include .*(DEPDIR)' "$xc_subdir/Makefile" 2>/dev/null`
+xc_cnt_words=`echo "$xc_inc_lines" | wc -w | tr -d "$xc_space$xc_tab"`
+
+# --disable-dependency-tracking might have been used, consequently
+# there is nothing to amend without a dependency tracking file list.
+
+if test $xc_cnt_words -gt 0; then
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: amending $xc_subdir/Makefile" >&5
+printf "%s\n" "$as_me: amending $xc_subdir/Makefile" >&6;}
+
+# Build Makefile specific patch hunk.
+
+xc_p="$xc_subdir/xc_patch.tmp"
+
+xc_rm_depfiles=`echo "$xc_inc_lines" \
+  | $SED 's%include%	-rm -f%' 2>/dev/null`
+
+xc_dep_subdirs=`echo "$xc_inc_lines" \
+  | $SED 's%include[ ][ ]*%%' 2>/dev/null \
+  | $SED 's%(DEPDIR)/.*%(DEPDIR)%' 2>/dev/null \
+  | sort | uniq`
+
+echo "$xc_rm_depfiles" >$xc_p
+
+for xc_dep_dir in $xc_dep_subdirs; do
+  echo "${xc_tab}@xm_dep_cnt=\`ls $xc_dep_dir | wc -l 2>/dev/null\`; \\"            >>$xc_p
+  echo "${xc_tab}if test \$\$xm_dep_cnt -eq 0 && test -d $xc_dep_dir; then \\"      >>$xc_p
+  echo "${xc_tab}  rm -rf $xc_dep_dir; \\"                                          >>$xc_p
+  echo "${xc_tab}fi"                                                                >>$xc_p
+done
+
+# Build Makefile patching sed scripts.
+
+xc_s1="$xc_subdir/xc_script_1.tmp"
+xc_s2="$xc_subdir/xc_script_2.tmp"
+xc_s3="$xc_subdir/xc_script_3.tmp"
+
+cat >$xc_s1 <<\_EOT
+/^distclean[ ]*:/,/^[^	][^	]*:/{
+  s/^.*(DEPDIR)/___xc_depdir_line___/
+}
+/^maintainer-clean[ ]*:/,/^[^	][^	]*:/{
+  s/^.*(DEPDIR)/___xc_depdir_line___/
+}
+_EOT
+
+cat >$xc_s2 <<\_EOT
+/___xc_depdir_line___$/{
+  N
+  /___xc_depdir_line___$/D
+}
+_EOT
+
+cat >$xc_s3 <<_EOT
+/^___xc_depdir_line___/{
+  r $xc_p
+  d
+}
+_EOT
+
+# Apply patch to Makefile and cleanup.
+
+$SED -f "$xc_s1" "$xc_subdir/Makefile"      >"$xc_subdir/Makefile.tmp1"
+$SED -f "$xc_s2" "$xc_subdir/Makefile.tmp1" >"$xc_subdir/Makefile.tmp2"
+$SED -f "$xc_s3" "$xc_subdir/Makefile.tmp2" >"$xc_subdir/Makefile.tmp3"
+
+if test -f "$xc_subdir/Makefile.tmp3"; then
+  mv -f "$xc_subdir/Makefile.tmp3" "$xc_subdir/Makefile"
+fi
+
+test -f "$xc_subdir/Makefile.tmp1" && rm -f "$xc_subdir/Makefile.tmp1"
+test -f "$xc_subdir/Makefile.tmp2" && rm -f "$xc_subdir/Makefile.tmp2"
+test -f "$xc_subdir/Makefile.tmp3" && rm -f "$xc_subdir/Makefile.tmp3"
+
+test -f "$xc_p"  && rm -f "$xc_p"
+test -f "$xc_s1" && rm -f "$xc_s1"
+test -f "$xc_s2" && rm -f "$xc_s2"
+test -f "$xc_s3" && rm -f "$xc_s3"
+
+fi
+
+done
+
+## -------------------------------- ##
+##  End of distclean amending code  ##
+## -------------------------------- ##
+
+
+
diff --git a/deps/cares/configure.ac b/deps/cares/configure.ac
new file mode 100644
index 0000000000000000000000000000000000000000..1d0fb5ce4e531fa8373acc12e179f6fd6765f95a
--- /dev/null
+++ b/deps/cares/configure.ac
@@ -0,0 +1,983 @@
+AC_PREREQ([2.60])
+
+AC_INIT([c-ares], [1.18.1],
+  [c-ares mailing list: http://lists.haxx.se/listinfo/c-ares])
+
+CARES_VERSION_INFO="7:1:5"
+dnl This flag accepts an argument of the form current[:revision[:age]]. So,
+dnl passing -version-info 3:12:1 sets current to 3, revision to 12, and age to
+dnl 1.
+dnl
+dnl If either revision or age are omitted, they default to 0. Also note that age
+dnl must be less than or equal to the current interface number.
+dnl
+dnl Here are a set of rules to help you update your library version information:
+dnl
+dnl 1.Start with version information of 0:0:0 for each libtool library.
+dnl
+dnl 2.Update the version information only immediately before a public release of
+dnl your software. More frequent updates are unnecessary, and only guarantee
+dnl that the current interface number gets larger faster.
+dnl
+dnl 3.If the library source code has changed at all since the last update, then
+dnl increment revision (c:r+1:a)
+dnl
+dnl 4.If any interfaces have been added, removed, or changed since the last
+dnl update, increment current, and set revision to 0. (c+1:r=0:a)
+dnl
+dnl 5.If any interfaces have been added since the last public release, then
+dnl increment age. (c:r:a+1)
+dnl
+dnl 6.If any interfaces have been removed since the last public release, then
+dnl set age to 0. (c:r:a=0)
+dnl
+AC_SUBST([CARES_VERSION_INFO])
+
+AC_CONFIG_SRCDIR([src/lib/ares_ipv6.h])
+AC_CONFIG_HEADERS([src/lib/ares_config.h include/ares_build.h])
+AC_CONFIG_MACRO_DIR([m4])
+AM_MAINTAINER_MODE
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
+
+AX_REQUIRE_DEFINED([AX_CXX_COMPILE_STDCXX_11])
+
+CARES_CHECK_OPTION_DEBUG
+CARES_CHECK_OPTION_OPTIMIZE
+CARES_CHECK_OPTION_WARNINGS
+CARES_CHECK_OPTION_WERROR
+CARES_CHECK_OPTION_SYMBOL_HIDING
+CARES_CHECK_OPTION_EXPOSE_STATICS
+
+XC_CHECK_PATH_SEPARATOR
+
+dnl SED is mandatory for configure process and libtool.
+dnl Set it now, allowing it to be changed later.
+AC_PATH_PROG([SED], [sed], [not_found],
+  [$PATH:/usr/bin:/usr/local/bin])
+if test -z "$SED" || test "$SED" = "not_found"; then
+  AC_MSG_ERROR([sed not found in PATH. Cannot continue without sed.])
+fi
+AC_SUBST([SED])
+
+dnl GREP is mandatory for configure process and libtool.
+dnl Set it now, allowing it to be changed later.
+AC_PATH_PROG([GREP], [grep], [not_found],
+  [$PATH:/usr/bin:/usr/local/bin])
+if test -z "$GREP" || test "$GREP" = "not_found"; then
+  AC_MSG_ERROR([grep not found in PATH. Cannot continue without grep.])
+fi
+AC_SUBST([GREP])
+
+dnl EGREP is mandatory for configure process and libtool.
+dnl Set it now, allowing it to be changed later.
+if echo a | ($GREP -E '(a|b)') >/dev/null 2>&1; then
+  AC_MSG_CHECKING([for egrep])
+  EGREP="$GREP -E"
+  AC_MSG_RESULT([$EGREP])
+else
+  AC_PATH_PROG([EGREP], [egrep], [not_found],
+    [$PATH:/usr/bin:/usr/local/bin])
+fi
+if test -z "$EGREP" || test "$EGREP" = "not_found"; then
+  AC_MSG_ERROR([egrep not found in PATH. Cannot continue without egrep.])
+fi
+AC_SUBST([EGREP])
+
+dnl AR is mandatory for configure process and libtool.
+dnl This is target dependent, so check it as a tool.
+if test -z "$AR"; then
+  dnl allow it to be overridden
+  AC_PATH_TOOL([AR], [ar], [not_found],
+    [$PATH:/usr/bin:/usr/local/bin])
+  if test -z "$AR" || test "$AR" = "not_found"; then
+    AC_MSG_ERROR([ar not found in PATH. Cannot continue without ar.])
+  fi
+fi
+AC_SUBST([AR])
+
+AX_CODE_COVERAGE
+
+
+dnl
+dnl Detect the canonical host and target build environment
+dnl
+
+AC_CANONICAL_HOST
+dnl Get system canonical name
+AC_DEFINE_UNQUOTED(OS, "${host}", [cpu-machine-OS])
+
+XC_CHECK_PROG_CC
+AX_CXX_COMPILE_STDCXX_11([noext],[optional])
+
+XC_AUTOMAKE
+
+dnl This defines _ALL_SOURCE for AIX
+CARES_CHECK_AIX_ALL_SOURCE
+
+dnl Our configure and build reentrant settings
+CARES_CONFIGURE_THREAD_SAFE
+CARES_CONFIGURE_REENTRANT
+
+dnl check for how to do large files
+AC_SYS_LARGEFILE
+
+case $host_os in
+  solaris*)
+    AC_DEFINE(ETC_INET, 1, [if a /etc/inet dir is being used])
+    ;;
+esac
+
+XC_LIBTOOL
+
+
+#
+# Automake conditionals based on libtool related checks
+#
+
+AM_CONDITIONAL([CARES_LT_SHLIB_USE_VERSION_INFO],
+  [test "x$xc_lt_shlib_use_version_info" = 'xyes'])
+AM_CONDITIONAL([CARES_LT_SHLIB_USE_NO_UNDEFINED],
+  [test "x$xc_lt_shlib_use_no_undefined" = 'xyes'])
+AM_CONDITIONAL([CARES_LT_SHLIB_USE_MIMPURE_TEXT],
+  [test "x$xc_lt_shlib_use_mimpure_text" = 'xyes'])
+
+#
+# Due to libtool and automake machinery limitations of not allowing
+# specifying separate CPPFLAGS or CFLAGS when compiling objects for
+# inclusion of these in shared or static libraries, we are forced to
+# build using separate configure runs for shared and static libraries
+# on systems where different CPPFLAGS or CFLAGS are mandatory in order
+# to compile objects for each kind of library. Notice that relying on
+# the '-DPIC' CFLAG that libtool provides is not valid given that the
+# user might for example choose to build static libraries with PIC.
+#
+
+#
+# Make our Makefile.am files use the staticlib CPPFLAG only when strictly
+# targeting a static library and not building its shared counterpart.
+#
+
+AM_CONDITIONAL([USE_CPPFLAG_CARES_STATICLIB],
+  [test "x$xc_lt_build_static_only" = 'xyes'])
+
+#
+# Make staticlib CPPFLAG variable and its definition visible in output
+# files unconditionally, providing an empty definition unless strictly
+# targeting a static library and not building its shared counterpart.
+#
+
+CPPFLAG_CARES_STATICLIB=
+if test "x$xc_lt_build_static_only" = 'xyes'; then
+  CPPFLAG_CARES_STATICLIB='-DCARES_STATICLIB'
+fi
+AC_SUBST([CPPFLAG_CARES_STATICLIB])
+
+dnl **********************************************************************
+dnl platform/compiler/architecture specific checks/flags
+dnl **********************************************************************
+
+CARES_CHECK_COMPILER
+CARES_SET_COMPILER_BASIC_OPTS
+CARES_SET_COMPILER_DEBUG_OPTS
+CARES_SET_COMPILER_OPTIMIZE_OPTS
+CARES_SET_COMPILER_WARNING_OPTS
+
+if test "$compiler_id" = "INTEL_UNIX_C"; then
+  #
+  if test "$compiler_num" -ge "1000"; then
+    dnl icc 10.X or later
+    CFLAGS="$CFLAGS -shared-intel"
+  elif test "$compiler_num" -ge "900"; then
+    dnl icc 9.X specific
+    CFLAGS="$CFLAGS -i-dynamic"
+  fi
+  #
+fi
+
+CARES_CHECK_COMPILER_HALT_ON_ERROR
+CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
+CARES_CHECK_COMPILER_PROTOTYPE_MISMATCH
+CARES_CHECK_COMPILER_SYMBOL_HIDING
+
+dnl **********************************************************************
+dnl Compilation based checks should not be done before this point.
+dnl **********************************************************************
+
+dnl **********************************************************************
+dnl Make sure that our checks for headers windows.h winsock.h winsock2.h
+dnl and ws2tcpip.h take precedence over any other further checks which
+dnl could be done later using AC_CHECK_HEADER or AC_CHECK_HEADERS for
+dnl this specific header files. And do them before its results are used.
+dnl **********************************************************************
+
+CURL_CHECK_HEADER_WINDOWS
+CURL_CHECK_NATIVE_WINDOWS
+case X-"$ac_cv_native_windows" in
+  X-yes)
+    CURL_CHECK_HEADER_WINSOCK
+    CURL_CHECK_HEADER_WINSOCK2
+    CURL_CHECK_HEADER_WS2TCPIP
+    CPPFLAGS="$CPPFLAGS -D_WIN32_WINNT=0x0600"
+    ;;
+  *)
+    ac_cv_header_winsock_h="no"
+    ac_cv_header_winsock2_h="no"
+    ac_cv_header_ws2tcpip_h="no"
+    ;;
+esac
+
+dnl **********************************************************************
+dnl Checks for libraries.
+dnl **********************************************************************
+
+CARES_CHECK_LIB_XNET
+
+dnl gethostbyname without lib or in the nsl lib?
+AC_CHECK_FUNC(gethostbyname,
+              [HAVE_GETHOSTBYNAME="1"
+              ],
+              [ AC_CHECK_LIB(nsl, gethostbyname,
+                             [HAVE_GETHOSTBYNAME="1"
+                             LIBS="$LIBS -lnsl"
+                             ])
+              ])
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+  dnl gethostbyname in the socket lib?
+  AC_CHECK_LIB(socket, gethostbyname,
+               [HAVE_GETHOSTBYNAME="1"
+               LIBS="$LIBS -lsocket"
+               ])
+fi
+
+dnl At least one system has been identified to require BOTH nsl and socket
+dnl libs at the same time to link properly.
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+  AC_MSG_CHECKING([for gethostbyname with both nsl and socket libs])
+  my_ac_save_LIBS=$LIBS
+  LIBS="-lnsl -lsocket $LIBS"
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      gethostbyname();
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    HAVE_GETHOSTBYNAME="1"
+  ],[
+    AC_MSG_RESULT([no])
+    LIBS=$my_ac_save_LIBS
+  ])
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+  dnl This is for winsock systems
+  if test "$ac_cv_header_windows_h" = "yes"; then
+    if test "$ac_cv_header_winsock_h" = "yes"; then
+      case $host in
+        *-*-mingw32ce*)
+          winsock_LIB="-lwinsock"
+          ;;
+        *)
+          winsock_LIB="-lwsock32"
+          ;;
+      esac
+    fi
+    if test "$ac_cv_header_winsock2_h" = "yes"; then
+      winsock_LIB="-lws2_32"
+    fi
+    if test ! -z "$winsock_LIB"; then
+      my_ac_save_LIBS=$LIBS
+      LIBS="$winsock_LIB $LIBS"
+      AC_MSG_CHECKING([for gethostbyname in $winsock_LIB])
+      AC_LINK_IFELSE([
+        AC_LANG_PROGRAM([[
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#else
+#ifdef HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+#endif
+#endif
+        ]],[[
+          gethostbyname("www.dummysite.com");
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        HAVE_GETHOSTBYNAME="1"
+      ],[
+        AC_MSG_RESULT([no])
+        winsock_LIB=""
+        LIBS=$my_ac_save_LIBS
+      ])
+    fi
+  fi
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+  dnl This is for Minix 3.1
+  AC_MSG_CHECKING([for gethostbyname for Minix 3])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+/* Older Minix versions may need <net/gen/netdb.h> here instead */
+#include <netdb.h>
+    ]],[[
+      gethostbyname("www.dummysite.com");
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    HAVE_GETHOSTBYNAME="1"
+  ],[
+    AC_MSG_RESULT([no])
+  ])
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+  dnl This is for eCos with a stubbed DNS implementation
+  AC_MSG_CHECKING([for gethostbyname for eCos])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+#include <stdio.h>
+#include <netdb.h>
+    ]],[[
+      gethostbyname("www.dummysite.com");
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    HAVE_GETHOSTBYNAME="1"
+  ],[
+    AC_MSG_RESULT([no])
+  ])
+fi
+
+if test "$HAVE_GETHOSTBYNAME" != "1"
+then
+  dnl gethostbyname in the net lib - for BeOS
+  AC_CHECK_LIB(net, gethostbyname,
+               [HAVE_GETHOSTBYNAME="1"
+               LIBS="$LIBS -lnet"
+               ])
+fi
+
+
+if test "$HAVE_GETHOSTBYNAME" != "1"; then
+  AC_MSG_ERROR([couldn't find libraries for gethostbyname()])
+fi
+
+dnl resolv lib for Apple (MacOS and iOS)
+AS_IF([test "x$host_vendor" = "xapple"], [
+  AC_SEARCH_LIBS([res_servicename], [resolv], [
+    AC_DEFINE([CARES_USE_LIBRESOLV], [1], [Use resolver library to configure cares])
+  ], [
+    AC_MSG_ERROR([Unable to find libresolv which is required for iPhone targets])
+  ])
+])
+
+dnl resolv lib for z/OS
+AS_IF([test "x$host_vendor" = "xibm" -a "x$host_os" = "xopenedition" ], [
+  AC_SEARCH_LIBS([res_init], [resolv], [
+    AC_DEFINE([CARES_USE_LIBRESOLV], [1], [Use resolver library to configure cares])
+  ], [
+    AC_MSG_ERROR([Unable to find libresolv which is required for z/OS])
+  ])
+])
+
+dnl resolve lib?
+AC_CHECK_FUNC(strcasecmp, , [ AC_CHECK_LIB(resolve, strcasecmp) ])
+
+if test "$ac_cv_lib_resolve_strcasecmp" = "$ac_cv_func_strcasecmp"; then
+  AC_CHECK_LIB(resolve, strcasecmp,
+              [LIBS="-lresolve $LIBS"],
+               ,
+               -lnsl)
+fi
+ac_cv_func_strcasecmp="no"
+
+dnl Windows builds require linking to iphlpapi
+if test "$ac_cv_header_winsock2_h" = "yes"; then
+  LIBS="$LIBS -liphlpapi"
+fi
+
+CARES_CHECK_LIBS_CONNECT
+
+dnl iOS 10?
+AS_IF([test "x$host_vendor" = "xapple"], [
+  AC_MSG_CHECKING([for iOS minimum version 10 or later])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+#include <stdio.h>
+#include <TargetConditionals.h>
+    ]], [[
+#if TARGET_OS_IPHONE == 0 || __IPHONE_OS_VERSION_MIN_REQUIRED < 100000
+#error Not iOS 10 or later
+#endif
+return 0;
+   ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    ac_cv_ios_10="yes"
+  ],[
+    AC_MSG_RESULT([no])
+  ])
+])
+
+dnl macOS 10.12?
+AS_IF([test "x$host_vendor" = "xapple"], [
+  AC_MSG_CHECKING([for macOS minimum version 10.12 or later])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+#include <stdio.h>
+#include <TargetConditionals.h>
+    ]], [[
+#ifndef MAC_OS_X_VERSION_10_12
+#  define MAC_OS_X_VERSION_10_12 101200
+#endif
+#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
+#error Not macOS 10.12 or later
+#endif
+return 0;
+   ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    ac_cv_macos_10_12="yes"
+  ],[
+    AC_MSG_RESULT([no])
+  ])
+])
+
+dnl **********************************************************************
+dnl In case that function clock_gettime with monotonic timer is available,
+dnl check for additional required libraries.
+dnl **********************************************************************
+dnl Xcode 8 bug: iOS when targeting less than 10, or macOS when targeting less than 10.12 will
+dnl say clock_gettime exists, it is a weak symbol that only exists in iOS 10 or macOS 10.12 and will
+dnl cause a crash at runtime when running on older versions.  Skip finding CLOCK_MONOTONIC on older
+dnl Apple OS's.
+if test "x$host_vendor" != "xapple" || test "x$ac_cv_ios_10" = "xyes" || test "x$ac_cv_macos_10_12" = "xyes"; then
+  CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC
+fi
+
+AC_MSG_CHECKING([whether to use libgcc])
+AC_ARG_ENABLE(libgcc,
+AS_HELP_STRING([--enable-libgcc],[use libgcc when linking]),
+[ case "$enableval" in
+  yes)
+        LIBS="$LIBS -lgcc"
+       AC_MSG_RESULT(yes)
+       ;;
+  *)   AC_MSG_RESULT(no)
+       ;;
+  esac ],
+       AC_MSG_RESULT(no)
+)
+
+
+dnl Let's hope this split URL remains working:
+dnl http://publibn.boulder.ibm.com/doc_link/en_US/a_doc_lib/aixprggd/ \
+dnl genprogc/thread_quick_ref.htm
+
+
+dnl **********************************************************************
+dnl Back to "normal" configuring
+dnl **********************************************************************
+
+dnl Checks for header files.
+STDC_HEADERS
+
+AC_PROG_EGREP
+
+
+CURL_CHECK_HEADER_MALLOC
+CURL_CHECK_HEADER_MEMORY
+
+dnl check for a few basic system headers we need
+AC_CHECK_HEADERS(
+       sys/types.h \
+       sys/time.h \
+       sys/select.h \
+       sys/socket.h \
+       sys/ioctl.h \
+       sys/param.h \
+       sys/uio.h \
+       assert.h \
+       netdb.h \
+       netinet/in.h \
+       netinet/tcp.h \
+       net/if.h \
+       errno.h \
+       socket.h \
+       strings.h \
+       stdbool.h \
+       time.h \
+       limits.h \
+       arpa/nameser.h \
+       arpa/nameser_compat.h \
+       arpa/inet.h,
+dnl to do if not found
+[],
+dnl to do if found
+[],
+dnl default includes
+[
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+dnl We do this default-include simply to make sure that the nameser_compat.h
+dnl header *REALLY* can be include after the new nameser.h. It seems AIX 5.1
+dnl (and others?) is not designed to allow this.
+#ifdef HAVE_ARPA_NAMESER_H
+#include <arpa/nameser.h>
+#endif
+
+dnl *Sigh* these are needed in order for net/if.h to get properly detected.
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+]
+)
+
+dnl Test and set CARES_HAVE_ARPA_NAMESER_H / CARES_HAVE_ARPA_NAMESER_COMPAT_H
+AC_CHECK_DECL([HAVE_ARPA_NAMESER_H],
+[
+CARES_DEFINE_UNQUOTED([CARES_HAVE_ARPA_NAMESER_H])
+],
+[]
+)
+AC_CHECK_DECL([HAVE_ARPA_NAMESER_COMPAT_H],
+[
+CARES_DEFINE_UNQUOTED([CARES_HAVE_ARPA_NAMESER_COMPAT_H])
+],
+[]
+)
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+AC_TYPE_SIZE_T
+m4_warn([obsolete],
+[Update your code to rely only on HAVE_SYS_TIME_H,
+then remove this warning and the obsolete code below it.
+All current systems provide time.h; it need not be checked for.
+Not all systems provide sys/time.h, but those that do, all allow
+you to include it and time.h simultaneously.])dnl
+AC_CHECK_HEADERS_ONCE([sys/time.h])
+# Obsolete code to be removed.
+if test $ac_cv_header_sys_time_h = yes; then
+  AC_DEFINE([TIME_WITH_SYS_TIME],[1],[Define to 1 if you can safely include both <sys/time.h>
+	     and <time.h>.  This macro is obsolete.])
+fi
+# End of obsolete code.
+
+CURL_CHECK_STRUCT_TIMEVAL
+
+AC_CHECK_TYPE(long long,
+   [AC_DEFINE(HAVE_LONGLONG, 1,
+     [Define to 1 if the compiler supports the 'long long' data type.])]
+   longlong="yes"
+)
+
+if test "xyes" = "x$longlong"; then
+  AC_MSG_CHECKING([if numberLL works])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      long long val = 1000LL;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    AC_DEFINE(HAVE_LL, 1, [if your compiler supports LL])
+  ],[
+    AC_MSG_RESULT([no])
+  ])
+fi
+
+
+# check for ssize_t
+AC_CHECK_TYPE(ssize_t, [ CARES_TYPEOF_ARES_SSIZE_T=ssize_t ],
+  [ CARES_TYPEOF_ARES_SSIZE_T=int ])
+
+AC_DEFINE_UNQUOTED([CARES_TYPEOF_ARES_SSIZE_T], ${CARES_TYPEOF_ARES_SSIZE_T},
+  [the signed version of size_t])
+
+
+# check for bool type
+AC_CHECK_TYPE([bool],[
+  AC_DEFINE(HAVE_BOOL_T, 1,
+    [Define to 1 if bool is an available type.])
+], ,[
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_STDBOOL_H
+#include <stdbool.h>
+#endif
+])
+
+CARES_CONFIGURE_ARES_SOCKLEN_T
+
+TYPE_IN_ADDR_T
+
+TYPE_SOCKADDR_STORAGE
+
+TYPE_SIG_ATOMIC_T
+
+m4_warn([obsolete],
+[your code may safely assume C89 semantics that RETSIGTYPE is void.
+Remove this warning and the `AC_CACHE_CHECK' when you adjust the code.])dnl
+AC_CACHE_CHECK([return type of signal handlers],[ac_cv_type_signal],[AC_COMPILE_IFELSE(
+[AC_LANG_PROGRAM([#include <sys/types.h>
+#include <signal.h>
+],
+		 [return *(signal (0, 0)) (0) == 1;])],
+		   [ac_cv_type_signal=int],
+		   [ac_cv_type_signal=void])])
+AC_DEFINE_UNQUOTED([RETSIGTYPE],[$ac_cv_type_signal],[Define as the return type of signal handlers
+		    (`int' or `void').])
+
+
+CURL_CHECK_FUNC_RECV
+CURL_CHECK_FUNC_RECVFROM
+CURL_CHECK_FUNC_SEND
+CURL_CHECK_MSG_NOSIGNAL
+
+CARES_CHECK_FUNC_CLOSESOCKET
+CARES_CHECK_FUNC_CLOSESOCKET_CAMEL
+CARES_CHECK_FUNC_CONNECT
+CARES_CHECK_FUNC_FCNTL
+CARES_CHECK_FUNC_FREEADDRINFO
+CARES_CHECK_FUNC_GETADDRINFO
+CARES_CHECK_FUNC_GETENV
+CARES_CHECK_FUNC_GETHOSTBYADDR
+CARES_CHECK_FUNC_GETHOSTBYNAME
+CARES_CHECK_FUNC_GETHOSTNAME
+CARES_CHECK_FUNC_GETSERVBYPORT_R
+CARES_CHECK_FUNC_INET_NET_PTON
+CARES_CHECK_FUNC_INET_NTOP
+CARES_CHECK_FUNC_INET_PTON
+CARES_CHECK_FUNC_IOCTL
+CARES_CHECK_FUNC_IOCTLSOCKET
+CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL
+CARES_CHECK_FUNC_SETSOCKOPT
+CARES_CHECK_FUNC_SOCKET
+CARES_CHECK_FUNC_STRCASECMP
+CARES_CHECK_FUNC_STRCMPI
+CARES_CHECK_FUNC_STRDUP
+CARES_CHECK_FUNC_STRICMP
+CARES_CHECK_FUNC_STRNCASECMP
+CARES_CHECK_FUNC_STRNCMPI
+CARES_CHECK_FUNC_STRNICMP
+CARES_CHECK_FUNC_WRITEV
+
+
+dnl check for AF_INET6
+CARES_CHECK_CONSTANT(
+  [
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+  ], [PF_INET6],
+     AC_DEFINE_UNQUOTED(HAVE_PF_INET6,1,[Define to 1 if you have PF_INET6.])
+)
+
+dnl check for PF_INET6
+CARES_CHECK_CONSTANT(
+  [
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#endif
+  ], [AF_INET6],
+     AC_DEFINE_UNQUOTED(HAVE_AF_INET6,1,[Define to 1 if you have AF_INET6.])
+)
+
+
+dnl check for the in6_addr structure
+CARES_CHECK_STRUCT(
+  [
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#endif
+  ], [in6_addr],
+     AC_DEFINE_UNQUOTED(HAVE_STRUCT_IN6_ADDR,1,[Define to 1 if you have struct in6_addr.])
+)
+
+dnl check for the sockaddr_in6 structure
+CARES_CHECK_STRUCT(
+  [
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#endif
+  ], [sockaddr_in6],
+     AC_DEFINE_UNQUOTED(HAVE_STRUCT_SOCKADDR_IN6,1,
+       [Define to 1 if you have struct sockaddr_in6.]) ac_have_sockaddr_in6=yes
+)
+
+AC_CHECK_MEMBER(struct sockaddr_in6.sin6_scope_id,
+    AC_DEFINE_UNQUOTED(HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID,1,
+      [Define to 1 if your struct sockaddr_in6 has sin6_scope_id.])
+   , ,
+  [
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#endif
+  ])
+
+dnl check for the addrinfo structure
+AC_CHECK_MEMBER(struct addrinfo.ai_flags,
+     AC_DEFINE_UNQUOTED(HAVE_STRUCT_ADDRINFO,1,
+       [Define to 1 if you have struct addrinfo.]),,
+  [
+#undef inline
+#ifdef HAVE_WINDOWS_H
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#ifdef HAVE_WINSOCK2_H
+#include <winsock2.h>
+#ifdef HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+#endif
+#else
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#endif
+  ]
+)
+
+
+AC_CHECK_FUNCS([bitncmp \
+  gettimeofday \
+  if_indextoname
+],[
+],[
+  func="$ac_func"
+  AC_MSG_CHECKING([deeper for $func])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      $func ();
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    eval "ac_cv_func_$func=yes"
+    AC_DEFINE_UNQUOTED(XC_SH_TR_CPP([HAVE_$func]), [1],
+      [Define to 1 if you have the $func function.])
+  ],[
+    AC_MSG_RESULT([but still no])
+  ])
+])
+
+dnl Android. Some variants like arm64 may no longer have __system_property_get
+dnl in libc, but they are defined in the headers.  Perform a link check.
+AC_CHECK_FUNC([__system_property_get], [
+    AC_DEFINE([HAVE___SYSTEM_PROPERTY_GET], [1], [Define if __system_property_get exists.])
+])
+
+dnl Check if the getnameinfo function is available
+dnl and get the types of five of its arguments.
+CURL_CHECK_FUNC_GETNAMEINFO
+
+
+AC_C_BIGENDIAN(
+    [AC_DEFINE(ARES_BIG_ENDIAN, 1,
+      [define this if ares is built for a big endian system])],
+    ,
+    [AC_MSG_WARN([couldn't figure out endianess, assuming little endian!])]
+)
+
+dnl Check for user-specified random device
+AC_ARG_WITH(random,
+AS_HELP_STRING([--with-random=FILE],
+               [read randomness from FILE (default=/dev/urandom)]),
+    [ CARES_RANDOM_FILE="$withval" ],
+    [
+        dnl Check for random device.  If we're cross compiling, we can't
+        dnl check, and it's better to assume it doesn't exist than it is
+        dnl to fail on AC_CHECK_FILE or later.
+        if test "$cross_compiling" = "no"; then
+          AC_CHECK_FILE("/dev/urandom", [ CARES_RANDOM_FILE="/dev/urandom"] )
+        else
+          AC_MSG_WARN([cannot check for /dev/urandom while cross compiling; assuming none])
+        fi
+
+    ]
+)
+if test -n "$CARES_RANDOM_FILE" && test X"$CARES_RANDOM_FILE" != Xno ; then
+        AC_SUBST(CARES_RANDOM_FILE)
+        AC_DEFINE_UNQUOTED(CARES_RANDOM_FILE, "$CARES_RANDOM_FILE",
+        [a suitable file/device to read random data from])
+fi
+
+CARES_CHECK_OPTION_NONBLOCKING
+CARES_CHECK_NONBLOCKING_SOCKET
+
+CARES_CONFIGURE_SYMBOL_HIDING
+
+CARES_PRIVATE_LIBS="$LIBS"
+AC_SUBST(CARES_PRIVATE_LIBS)
+
+CARES_CFLAG_EXTRAS=""
+if test X"$want_werror" = Xyes; then
+  CARES_CFLAG_EXTRAS="-Werror"
+fi
+AC_SUBST(CARES_CFLAG_EXTRAS)
+
+dnl squeeze whitespace out of some variables
+
+squeeze CFLAGS
+squeeze CPPFLAGS
+squeeze DEFS
+squeeze LDFLAGS
+squeeze LIBS
+
+squeeze CARES_PRIVATE_LIBS
+
+XC_CHECK_BUILD_FLAGS
+
+AC_MSG_CHECKING([whether to build tests])
+AC_ARG_ENABLE(tests,
+	AS_HELP_STRING([--enable-tests], [build test suite]),
+	[ build_tests="$enableval" ],
+	[ if test "x$HAVE_CXX11" = "x1" && test "x$cross_compiling" = "xno" ; then
+	    build_tests="yes"
+	  else
+	    build_tests="no"
+	  fi
+	]
+)
+
+if test "x$build_tests" = "xyes" ; then
+	if test "x$HAVE_CXX11" = "0" ; then
+		AC_MSG_ERROR([*** Building tests requires a CXX11 compiler])
+	fi
+	if test "x$cross_compiling" = "xyes" ; then
+		AC_MSG_ERROR([*** Tests not supported when cross compiling])
+	fi
+fi
+AC_MSG_RESULT([$build_tests])
+
+
+BUILD_SUBDIRS="include src docs"
+if test "x$build_tests" = "xyes" ; then
+  AC_CONFIG_SUBDIRS([test])
+  BUILD_SUBDIRS="${BUILD_SUBDIRS} test"
+fi
+
+AC_SUBST(BUILD_SUBDIRS)
+
+AC_CONFIG_FILES([Makefile           \
+                 include/Makefile   \
+                 src/Makefile       \
+                 src/lib/Makefile   \
+                 src/tools/Makefile \
+                 docs/Makefile      \
+                 libcares.pc ])
+
+AC_OUTPUT
+XC_AMEND_DISTCLEAN(['.'])
diff --git a/deps/cares/docs/CMakeLists.txt b/deps/cares/docs/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5b91d313e2fd0f2ef4186738129ddbc2331679b6
--- /dev/null
+++ b/deps/cares/docs/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Headers and Man Pages installation target
+IF (CARES_INSTALL)
+	# ManPages
+	FILE (GLOB DevelManPages "." "*.3")
+	INSTALL (FILES ${DevelManPages}
+		DESTINATION ${CMAKE_INSTALL_MANDIR}/man3
+		COMPONENT Devel
+	)
+
+	IF (CARES_BUILD_TOOLS)
+		FILE (GLOB ToolManPages "." "*.1")
+		INSTALL (FILES ${ToolManPages}
+			DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
+			COMPONENT Tools
+		)
+	ENDIF ()
+ENDIF ()
diff --git a/deps/cares/docs/Makefile.am b/deps/cares/docs/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..289445ce49b4973598653f157c0aeed1c531d0e8
--- /dev/null
+++ b/deps/cares/docs/Makefile.am
@@ -0,0 +1,11 @@
+#***************************************************************************
+
+###########################################################################
+
+AUTOMAKE_OPTIONS = foreign subdir-objects no-dependencies
+
+include Makefile.inc
+
+man_MANS = $(MANPAGES)
+
+EXTRA_DIST = $(MANPAGES) ahost.1 adig.1 acountry.1 Makefile.inc CMakeLists.txt
diff --git a/deps/cares/docs/Makefile.in b/deps/cares/docs/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..b4e656ec2e823b3889f3b136df59a881df573450
--- /dev/null
+++ b/deps/cares/docs/Makefile.in
@@ -0,0 +1,636 @@
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2021 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+#***************************************************************************
+
+###########################################################################
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = docs
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_ac_append_to_file.m4 \
+	$(top_srcdir)/m4/ax_ac_print_to_file.m4 \
+	$(top_srcdir)/m4/ax_add_am_macro_static.m4 \
+	$(top_srcdir)/m4/ax_am_macros_static.m4 \
+	$(top_srcdir)/m4/ax_check_gnu_make.m4 \
+	$(top_srcdir)/m4/ax_code_coverage.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx_11.m4 \
+	$(top_srcdir)/m4/ax_file_escapes.m4 \
+	$(top_srcdir)/m4/ax_require_defined.m4 \
+	$(top_srcdir)/m4/cares-compilers.m4 \
+	$(top_srcdir)/m4/cares-confopts.m4 \
+	$(top_srcdir)/m4/cares-functions.m4 \
+	$(top_srcdir)/m4/cares-reentrant.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/xc-am-iface.m4 \
+	$(top_srcdir)/m4/xc-cc-check.m4 \
+	$(top_srcdir)/m4/xc-lt-iface.m4 \
+	$(top_srcdir)/m4/xc-translit.m4 \
+	$(top_srcdir)/m4/xc-val-flgs.m4 \
+	$(top_srcdir)/m4/zz40-xc-ovr.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/src/lib/ares_config.h \
+	$(top_builddir)/include/ares_build.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+depcomp =
+am__maybe_remake_depfiles =
+SOURCES =
+DIST_SOURCES =
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+man3dir = $(mandir)/man3
+am__installdirs = "$(DESTDIR)$(man3dir)"
+NROFF = nroff
+MANS = $(man_MANS)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.inc
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BUILD_SUBDIRS = @BUILD_SUBDIRS@
+CARES_CFLAG_EXTRAS = @CARES_CFLAG_EXTRAS@
+CARES_PRIVATE_LIBS = @CARES_PRIVATE_LIBS@
+CARES_RANDOM_FILE = @CARES_RANDOM_FILE@
+CARES_VERSION_INFO = @CARES_VERSION_INFO@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CFLAG_CARES_SYMBOL_HIDING = @CFLAG_CARES_SYMBOL_HIDING@
+CODE_COVERAGE_CFLAGS = @CODE_COVERAGE_CFLAGS@
+CODE_COVERAGE_CPPFLAGS = @CODE_COVERAGE_CPPFLAGS@
+CODE_COVERAGE_CXXFLAGS = @CODE_COVERAGE_CXXFLAGS@
+CODE_COVERAGE_ENABLED = @CODE_COVERAGE_ENABLED@
+CODE_COVERAGE_LIBS = @CODE_COVERAGE_LIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPPFLAG_CARES_STATICLIB = @CPPFLAG_CARES_STATICLIB@
+CSCOPE = @CSCOPE@
+CTAGS = @CTAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ETAGS = @ETAGS@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GCOV = @GCOV@
+GENHTML = @GENHTML@
+GREP = @GREP@
+HAVE_CXX11 = @HAVE_CXX11@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LCOV = @LCOV@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+ifGNUmake = @ifGNUmake@
+ifnGNUmake = @ifnGNUmake@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AUTOMAKE_OPTIONS = foreign subdir-objects no-dependencies
+MANPAGES = ares_cancel.3		\
+  ares_create_query.3			\
+  ares_destroy.3			\
+  ares_destroy_options.3		\
+  ares_dup.3				\
+  ares_expand_name.3			\
+  ares_expand_string.3			\
+  ares_fds.3				\
+  ares_free_data.3			\
+  ares_free_hostent.3			\
+  ares_free_string.3			\
+  ares_freeaddrinfo.3			\
+  ares_get_servers.3			\
+  ares_get_servers_ports.3		\
+  ares_getaddrinfo.3			\
+  ares_gethostbyaddr.3			\
+  ares_gethostbyname.3			\
+  ares_gethostbyname_file.3		\
+  ares_getnameinfo.3			\
+  ares_getsock.3			\
+  ares_inet_ntop.3			\
+  ares_inet_pton.3			\
+  ares_init.3				\
+  ares_init_options.3			\
+  ares_library_cleanup.3		\
+  ares_library_init.3			\
+  ares_library_init_android.3		\
+  ares_library_initialized.3		\
+  ares_mkquery.3			\
+  ares_parse_a_reply.3			\
+  ares_parse_aaaa_reply.3		\
+  ares_parse_caa_reply.3		\
+  ares_parse_mx_reply.3			\
+  ares_parse_naptr_reply.3		\
+  ares_parse_ns_reply.3			\
+  ares_parse_ptr_reply.3		\
+  ares_parse_soa_reply.3		\
+  ares_parse_srv_reply.3		\
+  ares_parse_txt_reply.3		\
+  ares_parse_uri_reply.3		\
+  ares_process.3			\
+  ares_query.3				\
+  ares_save_options.3			\
+  ares_search.3				\
+  ares_send.3				\
+  ares_set_local_dev.3			\
+  ares_set_local_ip4.3			\
+  ares_set_local_ip6.3			\
+  ares_set_servers.3			\
+  ares_set_servers_csv.3		\
+  ares_set_servers_ports.3		\
+  ares_set_servers_ports_csv.3		\
+  ares_set_socket_callback.3		\
+  ares_set_socket_configure_callback.3	\
+  ares_set_socket_functions.3		\
+  ares_set_sortlist.3			\
+  ares_strerror.3			\
+  ares_timeout.3			\
+  ares_version.3
+
+man_MANS = $(MANPAGES)
+EXTRA_DIST = $(MANPAGES) ahost.1 adig.1 acountry.1 Makefile.inc CMakeLists.txt
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/Makefile.inc $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign docs/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign docs/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+$(srcdir)/Makefile.inc $(am__empty):
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-man3: $(man_MANS)
+	@$(NORMAL_INSTALL)
+	@list1=''; \
+	list2='$(man_MANS)'; \
+	test -n "$(man3dir)" \
+	  && test -n "`echo $$list1$$list2`" \
+	  || exit 0; \
+	echo " $(MKDIR_P) '$(DESTDIR)$(man3dir)'"; \
+	$(MKDIR_P) "$(DESTDIR)$(man3dir)" || exit 1; \
+	{ for i in $$list1; do echo "$$i"; done;  \
+	if test -n "$$list2"; then \
+	  for i in $$list2; do echo "$$i"; done \
+	    | sed -n '/\.3[a-z]*$$/p'; \
+	fi; \
+	} | while read p; do \
+	  if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; echo "$$p"; \
+	done | \
+	sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^3][0-9a-z]*$$,3,;x' \
+	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
+	sed 'N;N;s,\n, ,g' | { \
+	list=; while read file base inst; do \
+	  if test "$$base" = "$$inst"; then list="$$list $$file"; else \
+	    echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man3dir)/$$inst'"; \
+	    $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man3dir)/$$inst" || exit $$?; \
+	  fi; \
+	done; \
+	for i in $$list; do echo "$$i"; done | $(am__base_list) | \
+	while read files; do \
+	  test -z "$$files" || { \
+	    echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man3dir)'"; \
+	    $(INSTALL_DATA) $$files "$(DESTDIR)$(man3dir)" || exit $$?; }; \
+	done; }
+
+uninstall-man3:
+	@$(NORMAL_UNINSTALL)
+	@list=''; test -n "$(man3dir)" || exit 0; \
+	files=`{ for i in $$list; do echo "$$i"; done; \
+	l2='$(man_MANS)'; for i in $$l2; do echo "$$i"; done | \
+	  sed -n '/\.3[a-z]*$$/p'; \
+	} | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^3][0-9a-z]*$$,3,;x' \
+	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
+	dir='$(DESTDIR)$(man3dir)'; $(am__uninstall_files_from_dir)
+tags TAGS:
+
+ctags CTAGS:
+
+cscope cscopelist:
+
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(MANS)
+installdirs:
+	for dir in "$(DESTDIR)$(man3dir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-man
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man: install-man3
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-man
+
+uninstall-man: uninstall-man3
+
+.MAKE: install-am install-strip
+
+.PHONY: all all-am check check-am clean clean-generic clean-libtool \
+	cscopelist-am ctags-am distclean distclean-generic \
+	distclean-libtool distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-man3 install-pdf install-pdf-am install-ps \
+	install-ps-am install-strip installcheck installcheck-am \
+	installdirs maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
+	ps ps-am tags-am uninstall uninstall-am uninstall-man \
+	uninstall-man3
+
+.PRECIOUS: Makefile
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/deps/cares/docs/Makefile.inc b/deps/cares/docs/Makefile.inc
new file mode 100644
index 0000000000000000000000000000000000000000..3aa62aa43b3d58a12e323570001930cbefe68818
--- /dev/null
+++ b/deps/cares/docs/Makefile.inc
@@ -0,0 +1,59 @@
+MANPAGES = ares_cancel.3		\
+  ares_create_query.3			\
+  ares_destroy.3			\
+  ares_destroy_options.3		\
+  ares_dup.3				\
+  ares_expand_name.3			\
+  ares_expand_string.3			\
+  ares_fds.3				\
+  ares_free_data.3			\
+  ares_free_hostent.3			\
+  ares_free_string.3			\
+  ares_freeaddrinfo.3			\
+  ares_get_servers.3			\
+  ares_get_servers_ports.3		\
+  ares_getaddrinfo.3			\
+  ares_gethostbyaddr.3			\
+  ares_gethostbyname.3			\
+  ares_gethostbyname_file.3		\
+  ares_getnameinfo.3			\
+  ares_getsock.3			\
+  ares_inet_ntop.3			\
+  ares_inet_pton.3			\
+  ares_init.3				\
+  ares_init_options.3			\
+  ares_library_cleanup.3		\
+  ares_library_init.3			\
+  ares_library_init_android.3		\
+  ares_library_initialized.3		\
+  ares_mkquery.3			\
+  ares_parse_a_reply.3			\
+  ares_parse_aaaa_reply.3		\
+  ares_parse_caa_reply.3		\
+  ares_parse_mx_reply.3			\
+  ares_parse_naptr_reply.3		\
+  ares_parse_ns_reply.3			\
+  ares_parse_ptr_reply.3		\
+  ares_parse_soa_reply.3		\
+  ares_parse_srv_reply.3		\
+  ares_parse_txt_reply.3		\
+  ares_parse_uri_reply.3		\
+  ares_process.3			\
+  ares_query.3				\
+  ares_save_options.3			\
+  ares_search.3				\
+  ares_send.3				\
+  ares_set_local_dev.3			\
+  ares_set_local_ip4.3			\
+  ares_set_local_ip6.3			\
+  ares_set_servers.3			\
+  ares_set_servers_csv.3		\
+  ares_set_servers_ports.3		\
+  ares_set_servers_ports_csv.3		\
+  ares_set_socket_callback.3		\
+  ares_set_socket_configure_callback.3	\
+  ares_set_socket_functions.3		\
+  ares_set_sortlist.3			\
+  ares_strerror.3			\
+  ares_timeout.3			\
+  ares_version.3
diff --git a/deps/cares/docs/acountry.1 b/deps/cares/docs/acountry.1
new file mode 100644
index 0000000000000000000000000000000000000000..8c3aaea848d250fee0af6ce97362b4ca651abad1
--- /dev/null
+++ b/deps/cares/docs/acountry.1
@@ -0,0 +1,54 @@
+.TH ACOUNTRY "1" "April 2011" "c-ares utilities"
+.SH NAME
+acountry \- print the country where an IPv4 address or host is located
+.SH SYNOPSIS
+.B acountry
+[\fIOPTION\fR]... \fIHOST\fR...
+.SH DESCRIPTION
+.PP
+.\" Add any additional description here
+.PP
+Print the country where HOST (an IPv4 address or hostname) is located,
+using the countries.nerd.dk DNS domain to identify the country.
+.PP
+This utility comes with the \fBc\-ares\fR asynchronous resolver library.
+.SH OPTIONS
+.TP
+\fB\-d\fR
+Print some extra debugging output.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display this help and exit.
+.TP
+\fB\-v\fR
+Be more verbose. Print extra information.
+.SH "REPORTING BUGS"
+Report bugs to the c-ares mailing list:
+.br
+\fBhttps://lists.haxx.se/listinfo/c-ares\fR
+.SH "SEE ALSO"
+.PP
+adig(1), ahost(1).
+.PP
+The DNSBL countries.nerd.dk
+.br
+\fBhttp://countries.nerd.dk/\fR
+.SH COPYRIGHT
+This utility is based on code/ideas contained in sofware written by Greg Hudson (ares)
+carrying the following notice:
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of M.I.T. not be used in
+advertising or publicity pertaining to distribution of the software
+without specific, written prior permission. M.I.T. makes no
+representations about the suitability of this software for any
+purpose. It is provided "as is" without express or implied warranty.
+.br
+No further copyright claims are being made by the author(s) of this utility.
+.SH AUTHOR
+Gisle Vanem
diff --git a/deps/cares/docs/adig.1 b/deps/cares/docs/adig.1
new file mode 100644
index 0000000000000000000000000000000000000000..2056b959dbff5f7cd9e759148b49d5e126d4316c
--- /dev/null
+++ b/deps/cares/docs/adig.1
@@ -0,0 +1,85 @@
+.TH ADIG "1" "April 2011" "c-ares utilities"
+.SH NAME
+adig \- print information collected from Domain Name System (DNS) servers
+.SH SYNOPSIS
+.B adig
+[\fIOPTION\fR]... \fINAME\fR...
+.SH DESCRIPTION
+.PP
+.\" Add any additional description here
+.PP
+Send queries to DNS servers about \fINAME\fR and print received
+information, where \fINAME\fR is a valid DNS name (e.g. www.example.com,
+1.2.3.10.in-addr.arpa).
+.PP
+This utility comes with the \fBc\-ares\fR asynchronous resolver library.
+.SH OPTIONS
+.TP
+\fB\-c\fR class
+Set the query class.
+Possible values for class are
+NY, CHAOS, HS, IN (default).
+.TP
+\fB\-d\fR
+Print some extra debugging output.
+.TP
+\fB\-f\fR flag
+Add a flag.
+Possible values for flag are
+igntc, noaliases, norecurse, primary, stayopen, usevc.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display this help and exit.
+.TP
+\fB\-T\fR port
+Use specified TCP port to connect to DNS server.
+.TP
+\fB\-s\fR server
+Connect to specified DNS server, instead of the system's default one(s).
+.TP
+\fB\-t\fR type
+Query records of specified type.
+Possible values for type are
+A (default), AAAA, AFSDB, ANY, AXFR, CNAME, GPOS, HINFO, ISDN, KEY, LOC, MAILA,
+MAILB, MB, MD, MF, MG, MINFO, MR, MX, NAPTR, NS, NSAP, NSAP_PTR, NULL,
+PTR, PX, RP, RT, SIG, SOA, SRV, TXT, URI, WKS, X25,
+.TP
+\fB\-U\fR port
+Use specified UDP port to connect to DNS server.
+.TP
+\fB\-x\fR
+For an IPv4 \fB-t PTR a.b.c.d\fR lookup, query for
+.br
+\fBd.c.b.a.in-addr.arpa.\fR
+This more often gives correct names in the \fBANSWER\fR.
+.br
+For an IPv6 \fB-t PTR addr\fR lookup, query for \fBa.b.c....z.IP6.ARPA.\fR
+.TP
+\fB\-xx\fR
+As for \fB-x\fR and an IPv6 address, compact \fBa.b.c....z.IP6.ARPA.\fR into a RFC-2673 bit-string.
+This compacted \fBbit-string\fR form is not supported by many DNS-servers.
+
+.SH "REPORTING BUGS"
+Report bugs to the c-ares mailing list:
+.br
+\fBhttps://lists.haxx.se/listinfo/c-ares\fR
+.SH "SEE ALSO"
+.PP
+acountry(1), ahost(1).
+.SH COPYRIGHT
+This utility is based on code/ideas contained in sofware written by Greg Hudson (ares)
+carrying the following notice:
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of M.I.T. not be used in
+advertising or publicity pertaining to distribution of the software
+without specific, written prior permission. M.I.T. makes no
+representations about the suitability of this software for any
+purpose. It is provided "as is" without express or implied warranty.
+.br
+No further copyright claims are being made by the author(s) of this utility.
diff --git a/deps/cares/docs/ahost.1 b/deps/cares/docs/ahost.1
new file mode 100644
index 0000000000000000000000000000000000000000..430af821d49da103a30d039f291a12638c102961
--- /dev/null
+++ b/deps/cares/docs/ahost.1
@@ -0,0 +1,59 @@
+.TH AHOST "1" "April 2011" "c-ares utilities"
+.SH NAME
+ahost \- print the A or AAAA record associated with a hostname or IP address
+.SH SYNOPSIS
+.B ahost
+[\fIOPTION\fR]... \fIHOST\fR...
+.SH DESCRIPTION
+.PP
+.\" Add any additional description here
+.PP
+Look up the DNS A or AAAA record associated with HOST (a hostname or an
+IP address).
+.PP
+This utility comes with the \fBc\-ares\fR asynchronous resolver library.
+.SH OPTIONS
+.TP
+\fB\-d\fR
+Print some extra debugging output.
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Display this help and exit.
+.TP
+\fB\-t\fR type
+If type is "a", print the A record (default).
+If type is "aaaa", print the AAAA record.
+If type is "u", look for either AAAA or A record (in that order).
+.TP
+\fB\-s\fR \fIdomain\fP
+Specify the \fIdomain\fP to search instead of using the default values from
+.br
+/etc/resolv.conf. This option only has an effect on platforms that use
+.br
+/etc/resolv.conf
+for DNS configuration; it has no effect on other platforms (such as Win32
+or Android).
+.SH "REPORTING BUGS"
+Report bugs to the c-ares mailing list:
+.br
+\fBhttps://lists.haxx.se/listinfo/c-ares\fR
+.SH "SEE ALSO"
+.PP
+acountry(1), adig(1).
+.SH COPYRIGHT
+This utility is based on code/ideas contained in sofware written by Greg Hudson (ares)
+carrying the following notice:
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of M.I.T. not be used in
+advertising or publicity pertaining to distribution of the software
+without specific, written prior permission. M.I.T. makes no
+representations about the suitability of this software for any
+purpose. It is provided "as is" without express or implied warranty.
+.br
+No further copyright claims are being made by the author(s) of this utility.
diff --git a/deps/cares/docs/ares_cancel.3 b/deps/cares/docs/ares_cancel.3
new file mode 100644
index 0000000000000000000000000000000000000000..1a2d3f5846ea5fd7fd3c7921713639b625376930
--- /dev/null
+++ b/deps/cares/docs/ares_cancel.3
@@ -0,0 +1,46 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_CANCEL 3 "31 March 2004"
+.SH NAME
+ares_cancel \- Cancel a resolve
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+void ares_cancel(ares_channel \fIchannel\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_cancel(3)\fP function cancels all lookups/requests made on the the
+name service channel identified by \fIchannel\fP.  \fBares_cancel(3)\fP
+invokes the callbacks for each pending query on the channel, passing a status
+of
+.BR ARES_ECANCELLED .
+These calls give the callbacks a chance to clean up any state which might have
+been stored in their arguments. If such a callback invocation adds a new
+request to the channel, that request will \fInot\fP be cancelled by the
+current invocation of \fBares_cancel(3)\fP.
+.SH SEE ALSO
+.BR ares_init (3)
+.BR ares_destroy (3)
+.SH NOTES
+This function was added in c-ares 1.2.0
+
+c-ares 1.6.0 and earlier pass a status of
+.BR ARES_ETIMEOUT
+instead of
+.BR ARES_ECANCELLED .
+.SH AUTHOR
+Dirk Manske
diff --git a/deps/cares/docs/ares_create_query.3 b/deps/cares/docs/ares_create_query.3
new file mode 100644
index 0000000000000000000000000000000000000000..1ab0624e4134d0ab0e958b3586db65789707416b
--- /dev/null
+++ b/deps/cares/docs/ares_create_query.3
@@ -0,0 +1,83 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_CREATE_QUERY 3 "17 Aug 2012"
+.SH NAME
+ares_create_query \- Compose a single-question DNS query buffer
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+int ares_create_query(const char *\fIname\fP,
+                      int \fIdnsclass\fP,
+                      int \fItype\fP,
+                      unsigned short \fIid\fP,
+                      int \fIrd\fP,
+                      unsigned char **\fIbuf\fP,
+                      int *\fIbuflen\fP,
+                      int \fImax_udp_size\fP)
+.fi
+.SH DESCRIPTION
+The \fIares_create_query(3)\fP function composes a DNS query with a single
+question.  The parameter \fIname\fP gives the query name as a NUL-terminated C
+string of period-separated labels optionally ending with a period; periods and
+backslashes within a label must be escaped with a backlash.
+
+The parameters \fIdnsclass\fP and \fItype\fP give the class and type of the
+query using the values defined in \fB<arpa/nameser.h>\fP.
+
+The parameter \fIid\fP gives a 16-bit identifier for the query.
+
+The parameter \fIrd\fP should be nonzero if recursion is desired, zero if not.
+
+The query will be placed in an allocated buffer, a pointer to which will be
+stored in the variable pointed to by \fIbuf\fP, and the length of which will
+be stored in the variable pointed to by \fIbuflen\fP.
+
+It is the caller's responsibility to free this buffer using
+\fIares_free_string(3)\fP when it is no longer needed.  The parameter
+\fImax_udp_size\fP should be nonzero to activate EDNS. Usage of
+\fIares_create_query(3)\fP\ with \fImax_udp_size\fP set to zero is equivalent
+to using \fIares_mkquery(3)\fP.
+.SH RETURN VALUES
+.B ares_create_query
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+Construction of the DNS query succeeded.
+.TP 15
+.B ARES_ENOTFOUND
+The query name
+.I name
+refers to a
+.I .onion
+domain name. See RFC 7686.
+.TP 15
+.B ARES_EBADNAME
+The query name
+.I name
+could not be encoded as a domain name, either because it contained a
+zero-length label or because it contained a label of more than 63
+characters.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH AVAILABILITY
+Added in c-ares 1.10.0
+.SH SEE ALSO
+.BR ares_expand_name (3),
+.BR ares_free_string (3),
+.BR ares_mkquery (3)
+.SH AUTHOR
diff --git a/deps/cares/docs/ares_destroy.3 b/deps/cares/docs/ares_destroy.3
new file mode 100644
index 0000000000000000000000000000000000000000..9cdee30aac6eec60fcc457799635cfad3ef4580d
--- /dev/null
+++ b/deps/cares/docs/ares_destroy.3
@@ -0,0 +1,40 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_DESTROY 3 "7 December 2004"
+.SH NAME
+ares_destroy \- Destroy a resolver channel
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+void ares_destroy(ares_channel \fIchannel\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_destroy(3)\fP function destroys the name service channel
+identified by \fIchannel\fP, freeing all memory and closing all sockets used
+by the channel.
+
+\fBares_destroy(3)\fP invokes the callbacks for each pending query on the
+channel, passing a status of \fIARES_EDESTRUCTION\fP. These calls give the
+callbacks a chance to clean up any state which might have been stored in their
+arguments. A callback must not add new requests to a channel being destroyed.
+.SH SEE ALSO
+.BR ares_init (3),
+.BR ares_cancel (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_destroy_options.3 b/deps/cares/docs/ares_destroy_options.3
new file mode 100644
index 0000000000000000000000000000000000000000..31e346b79533ae7b7d1cae54dd088c4c89a56d59
--- /dev/null
+++ b/deps/cares/docs/ares_destroy_options.3
@@ -0,0 +1,35 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_DESTROY_OPTIONS 3 "1 June 2007"
+.SH NAME
+ares_destroy_options \- Destroy options initialized with ares_save_options
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B void ares_destroy_options(struct ares_options *\fIoptions\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_destroy_options(3)\fP function destroys the options struct
+identified by \Ioptions\fP, freeing all memory allocated by
+\fBares_save_options(3)\fP.
+.SH SEE ALSO
+.BR ares_save_options (3),
+.BR ares_init_options (3)
+.SH AUTHOR
+Brad House
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_dup.3 b/deps/cares/docs/ares_dup.3
new file mode 100644
index 0000000000000000000000000000000000000000..e64c10423d0b0f1f97c00b44178ae4516ebb7ee6
--- /dev/null
+++ b/deps/cares/docs/ares_dup.3
@@ -0,0 +1,39 @@
+.\"
+.\" Copyright (C) 2004-2009 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_DUP 3 "26 May 2009"
+.SH NAME
+ares_dup \- Duplicate a resolver channel
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_dup(ares_channel *\fIdest\fP, ares_channel \fIsource\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_dup(3)\fP function duplicates an existing communications channel
+for name service lookups.  If it returns successfully, \fBares_dup(3)\fP will
+set the variable pointed to by \fIdest\fP to a handle used to identify the
+name service channel.  The caller should invoke \fIares_destroy(3)\fP on the
+handle when the channel is no longer needed.
+.SH SEE ALSO
+.BR ares_destroy(3),
+.BR ares_init(3),
+.BR ares_library_init(3)
+.SH AVAILABILITY
+\fIares_dup(3)\fP was added in c-ares 1.6.0
+.SH AUTHOR
+Daniel Stenberg
+
diff --git a/deps/cares/docs/ares_expand_name.3 b/deps/cares/docs/ares_expand_name.3
new file mode 100644
index 0000000000000000000000000000000000000000..fc18df3ee3018b1d9937a2c5a73260cc4a71c68c
--- /dev/null
+++ b/deps/cares/docs/ares_expand_name.3
@@ -0,0 +1,65 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_EXPAND_NAME 3 "20 Nov 2009"
+.SH NAME
+ares_expand_name \- Expand a DNS-encoded domain name
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_expand_name(const unsigned char *\fIencoded\fP,
+.B      const unsigned char *\fIabuf\fP, int \fIalen\fP, char **\fIs\fP,
+.B 	long *\fIenclen\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_expand_name
+function converts a DNS-encoded domain name to a dot-separated C
+string.  The argument
+.I encoded
+gives the beginning of the encoded domain name, and the arguments
+.I abuf
+and
+.I alen
+give the containing message buffer (necessary for the processing of
+indirection pointers within the encoded domain name).  The result is
+placed in a NUL-terminated allocated buffer, a pointer to which is
+stored in the variable pointed to by
+.IR s .
+The length of the encoded name is stored in the variable pointed to by
+.I enclen
+so that the caller can advance past the encoded domain name to read
+further data in the message.
+
+Use \fIares_free_string(3)\fP to free the allocated hostname.
+.SH RETURN VALUES
+.B ares_expand_name
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+Expansion of the encoded name succeeded.
+.TP 15
+.B ARES_EBADNAME
+The encoded domain name was malformed and could not be expanded.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH SEE ALSO
+.BR ares_mkquery (3), ares_free_string (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_expand_string.3 b/deps/cares/docs/ares_expand_string.3
new file mode 100644
index 0000000000000000000000000000000000000000..33dd7bdada1f88a1c220fc894790adabfb12192e
--- /dev/null
+++ b/deps/cares/docs/ares_expand_string.3
@@ -0,0 +1,61 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_EXPAND_NAME 3 "20 Nov 2009"
+.SH NAME
+ares_expand_string \- Expand a length encoded string
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_expand_string(const unsigned char *\fIencoded\fP,
+.B      const unsigned char *\fIabuf\fP, int \fIalen\fP, unsigned char **\fIs\fP,
+.B 	long *\fIenclen\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_expand_string
+function converts a length encoded string to a NUL-terminated C
+string.  The argument
+.I encoded
+gives the beginning of the encoded string, and the arguments
+.I abuf
+and
+.I alen
+give the containing message buffer (necessary for the processing of
+indirection pointers within the encoded domain name).  The result is
+placed in a NUL-terminated allocated buffer, a pointer to which is
+stored in the variable pointed to by
+.IR s .
+The length of the encoded string is stored in the variable pointed to by
+.I enclen
+so that the caller can advance past the encoded string to read
+further data in the message.
+.SH RETURN VALUES
+.B ares_expand_string
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+Expansion of the encoded string succeeded.
+.TP 15
+.B ARES_EBADSTR
+The encoded string was malformed and could not be expanded.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH SEE ALSO
+.BR ares_free_string (3)
+.SH AUTHOR
+Dominick Meglio
diff --git a/deps/cares/docs/ares_fds.3 b/deps/cares/docs/ares_fds.3
new file mode 100644
index 0000000000000000000000000000000000000000..07063fb008ff232c4b243f0cda3e35bac83b889e
--- /dev/null
+++ b/deps/cares/docs/ares_fds.3
@@ -0,0 +1,48 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_FDS 3 "23 July 1998"
+.SH NAME
+ares_fds \- return file descriptors to select on
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+int ares_fds(ares_channel \fIchannel\fP,
+             fd_set *\fIread_fds\fP,
+	     fd_set *\fIwrite_fds\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_fds(3)\fP function retrieves the set of file descriptors which the
+calling application should select on for reading and writing for the
+processing of name service queries pending on the name service channel
+identified by \fIchannel\fP.
+
+File descriptors will be set in the file descriptor sets pointed to by
+\fIread_fds\fP and \fIwrite_fds\fP as appropriate.  File descriptors already
+set in \fIread_fds\fP and \fIwrite_fds\fP will remain set; initialization of
+the file descriptor sets (using \fBFD_ZERO\fP) is the responsibility of the
+caller.
+.SH RETURN VALUES
+\fBares_fds(3)\fP returns a value that is one greater than the number of the
+highest socket set in either \fIread_fds\fP or \fIwrite_fds\fP.  If no queries
+are active, \fBares_fds(3)\fP returns 0.
+.SH SEE ALSO
+.BR ares_timeout (3),
+.BR ares_process (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_free_data.3 b/deps/cares/docs/ares_free_data.3
new file mode 100644
index 0000000000000000000000000000000000000000..18e83ce7821d2fbf6ad2ab38ee74935d7c468176
--- /dev/null
+++ b/deps/cares/docs/ares_free_data.3
@@ -0,0 +1,82 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\" Copyright (C) 2004-2010 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_FREE_DATA 3 "5 March 2010"
+.SH NAME
+ares_free_data \- Free data allocated by several c-ares functions
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B void ares_free_data(void *\fIdataptr\fP)
+.PP
+.B cc file.c -lcares
+.fi
+.SH DESCRIPTION
+.PP
+The
+.B ares_free_data(3)
+function frees one or more data structures allocated and returned
+by several c-ares functions. Specifically the data returned by the
+following list of functions must be deallocated using this function.
+.TP 5
+.B ares_get_servers(3)
+When used to free the data returned by ares_get_servers(3) this
+will free the whole linked list of ares_addr_node structures returned
+by ares_get_servers(3).
+.TP
+.B ares_parse_srv_reply(3)
+When used to free the data returned by ares_parse_srv_reply(3) this
+will free the whole linked list of ares_srv_reply structures returned
+by ares_parse_srv_reply(3), along with any additional storage
+associated with those structures.
+.TP
+.B ares_parse_mx_reply(3)
+When used to free the data returned by ares_parse_mx_reply(3) this
+will free the whole linked list of ares_mx_reply structures returned
+by ares_parse_mx_reply(3), along with any additional storage
+associated with those structures.
+.TP
+.B ares_parse_txt_reply(3)
+When used to free the data returned by ares_parse_txt_reply(3) this
+will free the whole linked list of ares_txt_reply structures returned
+by ares_parse_txt_reply(3), along with any additional storage
+associated with those structures.
+.TP
+.B ares_parse_soa_reply(3)
+When used to free the data returned by ares_parse_soa_reply(3) this
+will free the ares_soa_reply structure, along with any additional storage
+associated with those structure.
+.B ares_parse_uri_reply(3)
+When used to free the data returned by ares_parse_uri_reply(3) this
+will free list of ares_uri_reply structures, along with any additional
+storage associated with those structure.
+.SH RETURN VALUE
+The ares_free_data() function does not return a value.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.7.0.
+.SH SEE ALSO
+.BR ares_get_servers(3),
+.BR ares_parse_srv_reply(3),
+.BR ares_parse_mx_reply(3),
+.BR ares_parse_txt_reply(3),
+.BR ares_parse_soa_reply(3)
+.SH AUTHOR
+Yang Tse
+.PP
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Copyright (C) 2004-2010 by Daniel Stenberg.
diff --git a/deps/cares/docs/ares_free_hostent.3 b/deps/cares/docs/ares_free_hostent.3
new file mode 100644
index 0000000000000000000000000000000000000000..d692801bafe88753b001915518e2b58838fe5894
--- /dev/null
+++ b/deps/cares/docs/ares_free_hostent.3
@@ -0,0 +1,45 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_FREE_HOSTENT 3 "23 July 1998"
+.SH NAME
+ares_free_hostent \- Free host structure allocated by ares functions
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B void ares_free_hostent(struct hostent *\fIhost\fP)
+.fi
+.SH DESCRIPTION
+The
+.I ares_free_hostent
+function frees a
+.B struct hostent
+allocated by one of the functions \fIares_parse_a_reply(3)\fP,
+\fIares_parse_aaaa_reply(3)\fP, or \fIares_parse_ptr_reply(3)\fP.
+.SH NOTES
+It is not necessary (and is not correct) to free the host structure passed to
+the callback functions for \fIares_gethostbyname(3)\fP or
+\fIares_gethostbyaddr(3)\fP. c-ares will automatically free such host
+structures when the callback returns.
+.SH SEE ALSO
+.BR ares_parse_a_reply (3),
+.BR ares_parse_aaaa_reply (3),
+.BR ares_parse_ptr_reply (3),
+.BR ares_parse_ns_reply (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_free_string.3 b/deps/cares/docs/ares_free_string.3
new file mode 100644
index 0000000000000000000000000000000000000000..61d88aa27fcfdb449de6a5d8d22e469bb351638a
--- /dev/null
+++ b/deps/cares/docs/ares_free_string.3
@@ -0,0 +1,34 @@
+.\"
+.\" Copyright 2000 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_FREE_STRING 3 "4 February 2004"
+.SH NAME
+ares_free_string \- Free strings allocated by ares functions
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B void ares_free_string(void *\fIstr\fP)
+.fi
+.SH DESCRIPTION
+The \fIares_free_string(3)\fP function frees a string allocated by an ares
+function.
+.SH SEE ALSO
+.BR ares_mkquery (3)
+.BR ares_expand_string (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 2000 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_freeaddrinfo.3 b/deps/cares/docs/ares_freeaddrinfo.3
new file mode 100644
index 0000000000000000000000000000000000000000..8a8ad591872824e2b4039d80c133f793fb578ba3
--- /dev/null
+++ b/deps/cares/docs/ares_freeaddrinfo.3
@@ -0,0 +1,37 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_FREEADDRINFO 3 "31 October 2018"
+.SH NAME
+ares_freeaddrinfo \- Free addrinfo structure allocated by ares functions
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+void ares_freeaddrinfo(struct ares_addrinfo *\fIai\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_freeaddrinfo
+function frees a
+.B struct ares_addrinfo
+returned in \fIresult\fP of
+.B ares_addrinfo_callback
+.SH SEE ALSO
+.BR ares_getaddrinfo (3),
+.SH AUTHOR
+Christian Ammer
+.BR
+Andrew Selivanov <andrew.selivanov@gmail.com>
diff --git a/deps/cares/docs/ares_get_servers.3 b/deps/cares/docs/ares_get_servers.3
new file mode 100644
index 0000000000000000000000000000000000000000..d6064289bb7aef7cd314fea9d16a3b759f1f630e
--- /dev/null
+++ b/deps/cares/docs/ares_get_servers.3
@@ -0,0 +1,84 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\" Copyright (C) 2008-2010 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_GET_SERVERS 3 "5 March 2010"
+.SH NAME
+ares_get_servers, ares_get_servers_ports \- Retrieve name servers from an initialized ares_channel
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_get_servers(ares_channel \fIchannel\fP, struct ares_addr_node **\fIservers\fP)
+.B int ares_get_servers_ports(ares_channel \fIchannel\fP, struct ares_addr_port_node **\fIservers\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_get_servers(3)\fP function retrieves name servers configuration
+from the
+channel data identified by
+.IR channel ,
+as a linked list of ares_addr_node structs storing a pointer to the first
+node at the address specified by
+.IR servers .
+
+The \fBares_get_servers_ports(3)\fP function also retrieves any per-server
+port information that may have been previously configured, returning a linked
+list of ares_addr_port structures.
+
+Function caller may traverse the returned name server linked list, or may use
+it directly as suitable input for the \fBares_set_servers(3)\fP /
+\fBares_set_servers_ports(3)\fP functions, but
+shall not shrink or extend the list on its own.
+
+Each node of the name server linked list is stored in memory dynamically
+allocated and managed by c-ares. It is the caller's responsibility to free
+the resulting linked list, using \fBares_free_data(3)\fP , once the caller
+does not need it any longer.
+
+This function is capable of handling IPv4 and IPv6 name server
+addresses simultaneously, rendering \fBares_save_options(3)\fP with
+optmask \fBARES_OPT_SERVERS\fP functionally obsolete except for
+IPv4-only name server usage.
+
+.SH RETURN VALUES
+This function may return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The name servers configuration was successfully retrieved
+.TP 15
+.B ARES_ENOMEM
+The memory was exhausted
+.TP 15
+.B ARES_ENODATA
+The channel data identified by
+.IR channel
+was invalid.
+.SH SEE ALSO
+.BR ares_set_servers (3),
+.BR ares_init_options (3),
+.BR ares_save_options(3)
+.SH AVAILABILITY
+\fBares_get_servers(3)\fP was added in c-ares 1.7.1;
+\fBares_get_servers_ports(3)\fP was added in c-ares 1.11.0.
+.SH AUTHOR
+Implementation of this function and associated library internals are based
+on code, comments and feedback provided in November and December of 2008 by
+Daniel Stenberg, Gregor Jasny, Phil Blundell and Yang Tse, December 2009
+by Cedric Bail, February 2010 by Jakub Hrozek. On March 2010 Yang Tse
+shuffled all the bits and this function popped out.
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Copyright (C) 2008-2010 by Daniel Stenberg
diff --git a/deps/cares/docs/ares_get_servers_ports.3 b/deps/cares/docs/ares_get_servers_ports.3
new file mode 100644
index 0000000000000000000000000000000000000000..1f5d1f708b75f15dad2c09793010f0e11aa16963
--- /dev/null
+++ b/deps/cares/docs/ares_get_servers_ports.3
@@ -0,0 +1 @@
+.so man3/ares_get_servers.3
diff --git a/deps/cares/docs/ares_getaddrinfo.3 b/deps/cares/docs/ares_getaddrinfo.3
new file mode 100644
index 0000000000000000000000000000000000000000..33c8a50dd3fa41fb54631faa2e368a8378977bf4
--- /dev/null
+++ b/deps/cares/docs/ares_getaddrinfo.3
@@ -0,0 +1,199 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_GETADDRINFO 3 "4 November 2018"
+.SH NAME
+ares_getaddrinfo \- Initiate a host query by name and service
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef void (*ares_addrinfo_callback)(void *\fIarg\fP, int \fIstatus\fP,
+.B 	int \fItimeouts\fP, struct ares_addrinfo *\fIresult\fP)
+.PP
+.B void ares_getaddrinfo(ares_channel \fIchannel\fP, const char *\fIname\fP,
+.B 	const char* \fIservice\fP, const struct ares_addrinfo_hints *\fIhints\fP,
+.B 	ares_addrinfo_callback \fIcallback\fP, void *\fIarg\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_getaddrinfo
+function initiates a host query by name on the name service channel
+identified by
+.IR channel .
+The
+.I name
+and
+.I service
+parameters give the hostname and service as NULL-terminated C strings.
+The
+.I hints
+parameter is an
+.BR ares_addrinfo_hints
+structure:
+.PP
+.RS
+.EX
+struct ares_addrinfo_hints {
+  int ai_flags;
+  int ai_family;
+  int ai_socktype;
+  int ai_protocol;
+};
+.EE
+.RE
+.TP
+.I ai_family
+Specifies desired address family. AF_UNSPEC means return both AF_INET and AF_INET6.
+.TP
+.I ai_socktype
+Specifies desired socket type, for example SOCK_STREAM or SOCK_DGRAM.
+Setting this to 0 means any type.
+.TP
+.I ai_protocol
+Setting this to 0 means any protocol.
+.TP
+.I ai_flags
+Specifies additional options, see below.
+.PP
+.TP 19
+.B ARES_AI_NUMERICSERV
+If this option is set
+.I service
+field will be treated as a numeric value.
+.TP 19
+.B ARES_AI_CANONNAME
+The ares_addrinfo structure will return a canonical names list.
+.TP 19
+.B ARES_AI_NOSORT
+Result addresses will not be sorted and no connections to resolved addresses will be attempted.
+.TP 19
+.B ARES_AI_ENVHOSTS
+Read hosts file path from the environment variable
+.I CARES_HOSTS .
+.PP
+When the query is complete or has failed, the ares library will invoke \fIcallback\fP.
+Completion or failure of the query may happen immediately, or may happen
+during a later call to \fIares_process(3)\fP, \fIares_destroy(3)\fP or
+\fIares_cancel(3)\fP.
+.PP
+The callback argument
+.I arg
+is copied from the
+.B ares_getaddrinfo
+argument
+.IR arg .
+The callback argument
+.I status
+indicates whether the query succeeded and, if not, how it failed.  It
+may have any of the following values:
+.TP 19
+.B ARES_SUCCESS
+The host lookup completed successfully.
+.TP 19
+.B ARES_ENOTIMP
+The ares library does not know how to find addresses of type
+.IR family .
+.TP 19
+.B ARES_ENOTFOUND
+The
+.I name
+was not found.
+.TP 19
+.B ARES_ENOMEM
+Memory was exhausted.
+.TP 19
+.B ARES_ECANCELLED
+The query was cancelled.
+.TP 19
+.B ARES_EDESTRUCTION
+The name service channel
+.I channel
+is being destroyed; the query will not be completed.
+.PP
+On successful completion of the query, the callback argument
+.I result
+points to a
+.B struct ares_addrinfo
+which contains two linked lists, one with resolved addresses and another with canonical names. 
+Also included is the official name of the host (analogous to gethostbyname() h_name).
+.PP
+.RS
+.EX
+struct ares_addrinfo {
+  struct ares_addrinfo_cname *cnames;
+  struct ares_addrinfo_node  *nodes;
+  char *name;
+};
+.EE
+.RE
+.PP
+.I ares_addrinfo_node
+structure is similar to RFC3493 addrinfo, but without canonname and with extra ttl field.
+.RS
+.PP
+.EX
+struct ares_addrinfo_node {
+  int                        ai_ttl;
+  int                        ai_flags;
+  int                        ai_family;
+  int                        ai_socktype;
+  int                        ai_protocol;
+  ares_socklen_t             ai_addrlen;
+  struct sockaddr           *ai_addr;
+  struct ares_addrinfo_node *ai_next;
+};
+.EE
+.RE
+.PP
+.I ares_addrinfo_cname
+structure is a linked list of CNAME records where
+.I ttl
+is a time to live
+.I alias
+is a label of the resource record and
+.I name
+is a value (canonical name) of the resource record.
+See RFC2181 10.1.1. CNAME terminology.
+.RS
+.PP
+.EX
+struct ares_addrinfo_cname {
+  int                         ttl;
+  char                       *alias;
+  char                       *name;
+  struct ares_addrinfo_cname *next;
+};
+.EE
+.RE
+.PP
+The reserved memory has to be deleted by
+.B ares_freeaddrinfo.
+
+The result is sorted according to RFC6724 except:
+ - Rule 3 (Avoid deprecated addresses)
+ - Rule 4 (Prefer home addresses)
+ - Rule 7 (Prefer native transport)
+
+Please note that the function will attempt a connection
+on each of the resolved addresses as per RFC6724.
+.SH AVAILABILITY
+This function was added in c-ares 1.16.0, released in March 2020.
+.SH SEE ALSO
+.BR ares_freeaddrinfo (3)
+.SH AUTHOR
+Christian Ammer
+.br
+Andrew Selivanov <andrew.selivanov@gmail.com>
diff --git a/deps/cares/docs/ares_gethostbyaddr.3 b/deps/cares/docs/ares_gethostbyaddr.3
new file mode 100644
index 0000000000000000000000000000000000000000..77273075566f10149fb164f85c3436d1f4efea90
--- /dev/null
+++ b/deps/cares/docs/ares_gethostbyaddr.3
@@ -0,0 +1,104 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_GETHOSTBYADDR 3 "24 July 1998"
+.SH NAME
+ares_gethostbyaddr \- Initiate a host query by address
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef void (*ares_host_callback)(void *\fIarg\fP, int \fIstatus\fP,
+.B	int \fItimeouts\fP, struct hostent *\fIhostent\fP)
+.PP
+.B void ares_gethostbyaddr(ares_channel \fIchannel\fP, const void *\fIaddr\fP,
+.B 	int \fIaddrlen\fP, int \fIfamily\fP, ares_host_callback \fIcallback\fP,
+.B 	void *\fIarg\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_gethostbyaddr
+function initiates a host query by address on the name service channel
+identified by
+.IR channel .
+The parameters
+.I addr
+and
+.I addrlen
+give the address as a series of bytes, and
+.I family
+gives the type of address.  When the query is complete or has failed, the ares
+library will invoke \fIcallback\fP.  Completion or failure of the query may
+happen immediately, or may happen during a later call to
+\fIares_process(3)\fP, \fIares_destroy(3)\fP or \fIares_cancel(3)\fP.
+.PP
+The callback argument
+.I arg
+is copied from the
+.B ares_gethostbyaddr
+argument
+.IR arg .
+The callback argument
+.I status
+indicates whether the query succeeded and, if not, how it failed.  It
+may have any of the following values:
+.TP 19
+.B ARES_SUCCESS
+The host lookup completed successfully.
+.TP 19
+.B ARES_ENOTIMP
+The ares library does not know how to look up addresses of type
+.IR family .
+.TP 19
+.B ARES_ENOTFOUND
+The address
+.I addr
+was not found.
+.TP 19
+.B ARES_ENOMEM
+Memory was exhausted.
+.TP 19
+.B ARES_ECANCELLED
+The query was cancelled.
+.TP 19
+.B ARES_EDESTRUCTION
+The name service channel
+.I channel
+is being destroyed; the query will not be completed.
+.PP
+The callback argument
+.I timeouts
+reports how many times a query timed out during the execution of the
+given request.
+.PP
+On successful completion of the query, the callback argument
+.I hostent
+points to a
+.B struct hostent
+containing the name of the host returned by the query.  The callback
+need not and should not attempt to free the memory pointed to by
+.IR hostent ;
+the ares library will free it when the callback returns.  If the query
+did not complete successfully,
+.I hostent
+will be
+.BR NULL .
+.SH SEE ALSO
+.BR ares_process (3),
+.BR ares_gethostbyname (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_gethostbyname.3 b/deps/cares/docs/ares_gethostbyname.3
new file mode 100644
index 0000000000000000000000000000000000000000..cfd6a0a12a2229ec3a8164bf4fcc509f2286c161
--- /dev/null
+++ b/deps/cares/docs/ares_gethostbyname.3
@@ -0,0 +1,111 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_GETHOSTBYNAME 3 "25 July 1998"
+.SH NAME
+ares_gethostbyname \- Initiate a host query by name
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef void (*ares_host_callback)(void *\fIarg\fP, int \fIstatus\fP,
+.B	int \fItimeouts\fP, struct hostent *\fIhostent\fP)
+.PP
+.B void ares_gethostbyname(ares_channel \fIchannel\fP, const char *\fIname\fP,
+.B 	int \fIfamily\fP, ares_host_callback \fIcallback\fP, void *\fIarg\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_gethostbyname
+function initiates a host query by name on the name service channel
+identified by
+.IR channel .
+The parameter
+.I name
+gives the hostname as a NUL-terminated C string, and
+.I family
+gives the desired type of address for the resulting host entry.  When the
+query is complete or has failed, the ares library will invoke \fIcallback\fP.
+Completion or failure of the query may happen immediately, or may happen
+during a later call to \fIares_process(3)\fP, \fIares_destroy(3)\fP or
+\fIares_cancel(3)\fP.
+.PP
+The callback argument
+.I arg
+is copied from the
+.B ares_gethostbyname
+argument
+.IR arg .
+The callback argument
+.I status
+indicates whether the query succeeded and, if not, how it failed.  It
+may have any of the following values:
+.TP 19
+.B ARES_SUCCESS
+The host lookup completed successfully.
+.TP 19
+.B ARES_ENOTIMP
+The ares library does not know how to find addresses of type
+.IR family .
+.TP 19
+.B ARES_EBADNAME
+The hostname
+.B name
+is composed entirely of numbers and periods, but is not a valid
+representation of an Internet address.
+.TP 19
+.B ARES_ENODATA
+There was no data returned to extract a result from.
+.TP 19
+.B ARES_ENOTFOUND
+The name
+.I name
+was not found.
+.TP 19
+.B ARES_ENOMEM
+Memory was exhausted.
+.TP 19
+.B ARES_ECANCELLED
+The query was cancelled.
+.TP 19
+.B ARES_EDESTRUCTION
+The name service channel
+.I channel
+is being destroyed; the query will not be completed.
+.PP
+The callback argument
+.I timeouts
+reports how many times a query timed out during the execution of the
+given request.
+.PP
+On successful completion of the query, the callback argument
+.I hostent
+points to a
+.B struct hostent
+containing the name of the host returned by the query.  The callback
+need not and should not attempt to free the memory pointed to by
+.IR hostent ;
+the ares library will free it when the callback returns.  If the query
+did not complete successfully,
+.I hostent
+will be
+.BR NULL .
+.SH SEE ALSO
+.BR ares_process (3),
+.BR ares_gethostbyaddr (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_gethostbyname_file.3 b/deps/cares/docs/ares_gethostbyname_file.3
new file mode 100644
index 0000000000000000000000000000000000000000..8f59b4157661fbe44e1e6d93a7ae2c2e533ad232
--- /dev/null
+++ b/deps/cares/docs/ares_gethostbyname_file.3
@@ -0,0 +1,83 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_GETHOSTBYNAME 3 "25 July 1998"
+.SH NAME
+ares_gethostbyname_file \- Lookup a name in the system's hosts file
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_gethostbyname_file(ares_channel \fIchannel\fP, const char *\fIname\fP,
+.B 	int \fIfamily\fP, struct hostent **host)
+.fi
+.SH DESCRIPTION
+The
+.B ares_gethostbyname_file
+function performs a host lookup by name against the system's hosts file (or equivalent local hostname database).  
+The
+.IR channel
+parameter is required, but no asynchronous queries are performed.  Instead, the
+lookup is done via the same mechanism used to perform 'f' lookups
+(see the
+.I lookups
+options field in \fIares_init_options(3)\fP).
+The parameter
+.I name
+gives the hostname as a NUL-terminated C string, and
+.I family
+gives the desired type of address for the resulting host entry.  
+.PP
+The return value indicates whether the query succeeded and, if not, how it
+failed.  It may have any of the following values:
+.TP 19
+.B ARES_SUCCESS
+The host lookup completed successfully and 
+.I host
+now points to the result (and must be freed with \fIares_free_hostent(3)\fP).
+.TP 19
+.B ARES_ENOTFOUND
+The hostname
+.I name
+was not found.
+.TP 19
+.B ARES_EFILE
+There was a file I/O error while performing the lookup.
+.TP 19
+.B ARES_ENOMEM
+Memory was exhausted.
+.PP
+On successful completion of the query, the pointer pointed to by
+.I host
+points to a
+.B struct hostent
+containing the address of the host returned by the lookup.  The user must
+free the memory pointed to by
+.IR host
+when finished with it by calling \fIares_free_hostent(3)\fP.  If the lookup did
+not complete successfully, 
+.I host
+will be
+.BR NULL .
+.SH AVAILABILITY
+Added in c-ares 1.5.4
+.SH SEE ALSO
+.BR ares_gethostbyname (3),
+.BR ares_free_hostent (3),
+.BR ares_init_options (3)
+.SH AUTHOR
+Brad Spencer
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_getnameinfo.3 b/deps/cares/docs/ares_getnameinfo.3
new file mode 100644
index 0000000000000000000000000000000000000000..1017432108ac1d0c92e1c5b3ac073b0f7481bc6a
--- /dev/null
+++ b/deps/cares/docs/ares_getnameinfo.3
@@ -0,0 +1,151 @@
+.\"
+.\" Copyright 2005 by Dominick Meglio.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_GETNAMEINFO 3 "1 May 2009"
+.SH NAME
+ares_getnameinfo \- Address-to-nodename translation in protocol-independent manner
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef void (*ares_nameinfo_callback)(void *\fIarg\fP, int \fIstatus\fP,
+.B	int \fItimeouts\fP, char *\fInode\fP, char *\fIservice\fP)
+.PP
+.B void ares_getnameinfo(ares_channel \fIchannel\fP, const struct sockaddr *\fIsa\fP,
+.B 	ares_socklen_t \fIsalen\fP, int \fIflags\fP, ares_nameinfo_callback \fIcallback\fP,
+.B 	void *\fIarg\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_getnameinfo
+function is defined for protocol-independent address translation. The function
+is a combination of \fIares_gethostbyaddr(3)\fP and \fIgetservbyport(3)\fP. The function will
+translate the address either by executing a host query on the name service channel
+identified by
+.IR channel 
+or it will attempt to resolve it locally if possible.
+The parameters
+.I sa
+and
+.I len
+give the address as a sockaddr structure, and
+.I flags
+gives the options that the function will use.  Valid flags are listed below:
+.TP 19
+.B ARES_NI_NOFQDN
+Only the nodename portion of the FQDN is returned for local hosts.
+.TP 19
+.B ARES_NI_NUMERICHOST
+The numeric form of the hostname is returned rather than the name.
+.TP 19
+.B ARES_NI_NAMEREQD
+An error is returned if the hostname cannot be found in the DNS.
+.TP 19
+.B ARES_NI_NUMERICSERV
+The numeric form of the service is returned rather than the name.
+.TP 19
+.B ARES_NI_TCP
+The service name is to be looked up for the TCP protocol.
+.TP 19
+.B ARES_NI_UDP
+The service name is to be looked up for the UDP protocol.
+.TP 19
+.B ARES_NI_SCTP
+The service name is to be looked up for the SCTP protocol.
+.TP 19
+.B ARES_NI_DCCP
+The service name is to be looked up for the DCCP protocol.
+.TP 19
+.B ARES_NI_NUMERICSCOPE
+The numeric form of the scope ID is returned rather than the name.
+.TP 19
+.B ARES_NI_LOOKUPHOST
+A hostname lookup is being requested.
+.TP 19
+.B ARES_NI_LOOKUPSERVICE
+A service name lookup is being requested.
+.PP
+When the query
+is complete or has 
+failed, the ares library will invoke \fIcallback\fP.  Completion or failure of 
+the query may happen immediately, or may happen during a later call to
+\fIares_process(3)\fP, \fIares_destroy(3)\fP or \fIares_cancel(3)\fP.
+.PP
+The callback argument
+.I arg
+is copied from the
+.B ares_getnameinfo
+argument
+.IR arg .
+The callback argument
+.I status
+indicates whether the query succeeded and, if not, how it failed.  It
+may have any of the following values:
+.TP 19
+.B ARES_SUCCESS
+The host lookup completed successfully.
+.TP 19
+.B ARES_ENOTIMP
+The ares library does not know how to look up addresses of type
+.IR family .
+.TP 19
+.B ARES_ENOTFOUND
+The address
+.I addr
+was not found.
+.TP 19
+.B ARES_ENOMEM
+Memory was exhausted.
+.TP 19
+.B ARES_ECANCELLED
+The query was cancelled.
+.TP 19
+.B ARES_EDESTRUCTION
+The name service channel
+.I channel
+is being destroyed; the query will not be completed.
+.TP 19
+.B ARES_EBADFLAGS
+The
+.I flags
+parameter contains an illegal value.
+.PP
+The callback argument
+.I timeouts
+reports how many times a query timed out during the execution of the
+given request.
+.PP
+On successful completion of the query, the callback argument
+.I node
+contains a string representing the hostname (assuming 
+.B ARES_NI_LOOKUPHOST
+was specified). Additionally, 
+.I service
+contains a string representing the service name (assuming
+.B ARES_NI_LOOKUPSERVICE
+was specified).
+If the query did not complete successfully, or one of the values
+was not requested, 
+.I node
+or
+.I service
+will be 
+.BR NULL .
+.SH SEE ALSO
+.BR ares_process (3),
+.SH AUTHOR
+Dominick Meglio
+.br
+Copyright 2005 by Dominick Meglio.
diff --git a/deps/cares/docs/ares_getsock.3 b/deps/cares/docs/ares_getsock.3
new file mode 100644
index 0000000000000000000000000000000000000000..137329115e49a9d447781d6e8f36f25d69214f55
--- /dev/null
+++ b/deps/cares/docs/ares_getsock.3
@@ -0,0 +1,57 @@
+.\"
+.\" Copyright 1998 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_GETSOCK 3 "11 March 2010"
+.SH NAME
+ares_getsock \- get socket descriptors to wait on
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_getsock(ares_channel \fIchannel\fP, ares_socket_t *\fIsocks\fP,
+.B int \fInumsocks\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_getsock
+function retrieves the set of socket descriptors which the calling
+application should wait on for reading and/or writing for the
+processing of name service queries pending on the name service channel
+identified by
+.IR channel .
+Socket descriptors will be set in the socket descriptor array pointed to by
+\fIsocks\fP.
+\fInumsocks\fP is the size of the given array in number of ints.
+
+This function can only return information about up to 16 sockets. If more are
+in use (however unlikely that is), they are simply not reported back.
+.SH RETURN VALUES
+\fBares_getsock\fP returns a bitmask for what actions to wait for on the
+different sockets. The ares.h header file provides these convenience macros to
+extract the information appropriately:
+
+.nf
+#define ARES_GETSOCK_MAXNUM 16 /* ares_getsock() can return info about
+                                  this many sockets */
+#define ARES_GETSOCK_READABLE(bits,num) (bits & (1<< (num)))
+#define ARES_GETSOCK_WRITABLE(bits,num) (bits & (1 << ((num) + \
+                                         ARES_GETSOCK_MAXNUM)))
+.fi
+.SH NOTES
+This function was added in c-ares 1.3.1
+.SH SEE ALSO
+.BR ares_timeout (3),
+.BR ares_fds (3),
+.BR ares_process (3)
diff --git a/deps/cares/docs/ares_inet_ntop.3 b/deps/cares/docs/ares_inet_ntop.3
new file mode 100644
index 0000000000000000000000000000000000000000..93ee09cf773b518556438d46656496f92dea63c0
--- /dev/null
+++ b/deps/cares/docs/ares_inet_ntop.3
@@ -0,0 +1,47 @@
+.\"
+.\" Copyright (C) 2013 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_INET_NTOP 3 "17 Feb 2013"
+.SH NAME
+ares_inet_ntop \- convert a network format address to presentation format
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B const char *
+.B ares_inet_ntop(int af, const void *src, char *dst, ares_socklen_t size);
+.fi
+.SH DESCRIPTION
+This is a portable version with the identical functionality of the commonly
+available \fIinet_ntop\fP.
+
+The ares_inet_ntop() function converts a numeric address into a text string
+suitable for presentation. The \fBaf\fP argument shall specify the family of
+the address. This can be AF_INET or AF_INET6.  The \fBsrc\fP argument points
+to a buffer holding an IPv4 address if the af argument is AF_INET, or an IPv6
+address if the af argument is AF_INET6; the address must be in network byte
+order. The \fBdst\fP argument points to a buffer where the function stores the
+resulting text string; it shall not be NULL. The \fBsize\fP argument specifies
+the size of this buffer, which shall be large enough to hold the text string
+(INET_ADDRSTRLEN (16) characters for IPv4, INET6_ADDRSTRLEN (46) characters
+for IPv6).
+.SH SEE ALSO
+.BR ares_init(3),
+.BR ares_inet_pton(3)
+.SH AVAILABILITY
+made properly publicly available in c-ares for real in version 1.10.0
+.SH AUTHOR
+Daniel Stenberg
+
diff --git a/deps/cares/docs/ares_inet_pton.3 b/deps/cares/docs/ares_inet_pton.3
new file mode 100644
index 0000000000000000000000000000000000000000..b7d86bb4e0404beec17997f8c26aa73e1263da4a
--- /dev/null
+++ b/deps/cares/docs/ares_inet_pton.3
@@ -0,0 +1,43 @@
+.\"
+.\" Copyright (C) 2013 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_INET_PTON 3 "17 Feb 2013"
+.SH NAME
+ares_inet_pton \- convert an IPv4 or IPv6 address from text to binary form
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B const char *ares_inet_pton(int af, const char *src, void *dst);
+.fi
+.SH DESCRIPTION
+This is a portable version with the identical functionality of the commonly
+available \fIinet_pton\fP.
+
+The ares_inet_pton() function converts the address in its standard text
+presentation form into its numeric binary form. The \fBaf\fP argument shall
+specify the family of the address. The AF_INET and AF_INET6 address families
+shall be supported. The \fBsrc\fP argument points to the string being passed
+in. The \fBdst\fP argument points to a buffer into which the function stores
+the numeric address; this shall be large enough to hold the numeric address
+(32 bits for AF_INET, 128 bits for AF_INET6).
+.SH SEE ALSO
+.BR ares_init(3),
+.BR ares_inet_ntop(3)
+.SH AVAILABILITY
+made properly publicly available in c-ares for real in version 1.10.0
+.SH AUTHOR
+Daniel Stenberg
+
diff --git a/deps/cares/docs/ares_init.3 b/deps/cares/docs/ares_init.3
new file mode 100644
index 0000000000000000000000000000000000000000..0baf4b76fea59f5896f3347dd9ba1f7c9ab10931
--- /dev/null
+++ b/deps/cares/docs/ares_init.3
@@ -0,0 +1,81 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\" Copyright (C) 2004-2010 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_INIT 3 "5 March 2010"
+.SH NAME
+ares_init \- Initialize a resolver channel
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+int ares_init(ares_channel *\fIchannelptr\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_init(3)\fP function initializes a communications channel for name
+service lookups.  If it returns successfully, \fBares_init(3)\fP will set the
+variable pointed to by \fIchannelptr\fP to a handle used to identify the name
+service channel.  The caller should invoke \fIares_destroy(3)\fP on the handle
+when the channel is no longer needed.
+
+The \fIares_init_options(3)\fP function is provide to offer more init
+alternatives.
+.SH RETURN VALUES
+\fIares_init(3)\fP can return any of the following values:
+.TP 14
+.B ARES_SUCCESS
+Initialization succeeded.
+.TP 14
+.B ARES_EFILE
+A configuration file could not be read.
+.TP 14
+.B ARES_ENOMEM
+The process's available memory was exhausted.
+.TP 14
+.B ARES_ENOTINITIALIZED
+c-ares library initialization not yet performed.
+.SH NOTES
+When initializing from
+.B /etc/resolv.conf,
+.BR ares_init (3)
+reads the
+.I domain
+and
+.I search
+directives to allow lookups of short names relative to the domains
+specified. The
+.I domain
+and
+.I search
+directives override one another. If more that one instance of either
+.I domain
+or
+.I search
+directives is specified, the last occurrence wins. For more information,
+please see the
+.BR resolv.conf (5)
+manual page.
+.SH SEE ALSO
+.BR ares_init_options(3),
+.BR ares_destroy(3),
+.BR ares_dup(3),
+.BR ares_library_init(3),
+.BR ares_set_servers(3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Copyright (C) 2004-2010 by Daniel Stenberg.
diff --git a/deps/cares/docs/ares_init_options.3 b/deps/cares/docs/ares_init_options.3
new file mode 100644
index 0000000000000000000000000000000000000000..b9d52a895c165a17173fa55883359be8fc225626
--- /dev/null
+++ b/deps/cares/docs/ares_init_options.3
@@ -0,0 +1,295 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\" Copyright (C) 2004-2010 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_INIT 3 "5 March 2010"
+.SH NAME
+ares_init_options \- Initialize a resolver channel
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+struct ares_options {
+  int flags;
+  int timeout; /* in seconds or milliseconds, depending on options */
+  int tries;
+  int ndots;
+  unsigned short udp_port;
+  unsigned short tcp_port;
+  int socket_send_buffer_size;
+  int socket_receive_buffer_size;
+  struct in_addr *servers;
+  int nservers;
+  char **domains;
+  int ndomains;
+  char *lookups;
+  ares_sock_state_cb sock_state_cb;
+  void *sock_state_cb_data;
+  struct apattern *sortlist;
+  int nsort;
+  int ednspsz;
+  char *resolvconf_path;
+};
+
+int ares_init_options(ares_channel *\fIchannelptr\fP,
+                      struct ares_options *\fIoptions\fP,
+                      int \fIoptmask\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_init_options(3)\fP function initializes a communications channel
+for name service lookups.  If it returns successfully,
+\fBares_init_options(3)\fP will set the variable pointed to by
+\fIchannelptr\fP to a handle used to identify the name service channel.  The
+caller should invoke \fIares_destroy(3)\fP on the handle when the channel is
+no longer needed.
+
+The \fIoptmask\fP parameter generally specifies which fields in the structure pointed to
+by \fIoptions\fP are set, as follows:
+.TP 18
+.B ARES_OPT_FLAGS
+.B int \fIflags\fP;
+.br
+Flags controlling the behavior of the resolver.  See below for a
+description of possible flag values.
+.TP 18
+.B ARES_OPT_TIMEOUT
+.B int \fItimeout\fP;
+.br
+The number of seconds each name server is given to respond to a query on the
+first try.  (After the first try, the timeout algorithm becomes more
+complicated, but scales linearly with the value of \fItimeout\fP.)  The
+default is five seconds. This option is being deprecated by
+\fIARES_OPT_TIMEOUTMS\fP starting in c-ares 1.5.2.
+.TP 18
+.B ARES_OPT_TIMEOUTMS
+.B int \fItimeout\fP;
+.br
+The number of milliseconds each name server is given to respond to a query on
+the first try.  (After the first try, the timeout algorithm becomes more
+complicated, but scales linearly with the value of \fItimeout\fP.)  The
+default is five seconds. Note that this option is specified with the same
+struct field as the former \fIARES_OPT_TIMEOUT\fP, it is but the option bits
+that tell c-ares how to interpret the number. This option was added in c-ares
+1.5.2.
+.TP 18
+.B ARES_OPT_TRIES
+.B int \fItries\fP;
+.br
+The number of tries the resolver will try contacting each name server
+before giving up.  The default is four tries.
+.TP 18
+.B ARES_OPT_NDOTS
+.B int \fIndots\fP;
+.br
+The number of dots which must be present in a domain name for it to be
+queried for "as is" prior to querying for it with the default domain
+extensions appended.  The default value is 1 unless set otherwise by
+resolv.conf or the RES_OPTIONS environment variable.
+.TP 18
+.B ARES_OPT_UDP_PORT
+.B unsigned short \fIudp_port\fP;
+.br
+The port to use for queries over UDP, in network byte order.
+The default value is 53 (in network byte order), the standard name
+service port.
+.TP 18
+.B ARES_OPT_TCP_PORT
+.B unsigned short \fItcp_port\fP;
+.br
+The port to use for queries over TCP, in network byte order.
+The default value is 53 (in network byte order), the standard name
+service port.
+.TP 18
+.B ARES_OPT_SERVERS
+.B struct in_addr *\fIservers\fP;
+.br
+.B int \fInservers\fP;
+.br
+The list of IPv4 servers to contact, instead of the servers specified in
+resolv.conf or the local named. In order to allow specification of either
+IPv4 or IPv6 name servers, the
+.BR ares_set_servers(3)
+function must be used instead.
+.TP 18
+.B ARES_OPT_DOMAINS
+.B char **\fIdomains\fP;
+.br
+.B int \fIndomains\fP;
+.br
+The domains to search, instead of the domains specified in resolv.conf
+or the domain derived from the kernel hostname variable.
+.TP 18
+.B ARES_OPT_LOOKUPS
+.B char *\fIlookups\fP;
+.br
+The lookups to perform for host queries.
+.I lookups
+should be set to a string of the characters "b" or "f", where "b"
+indicates a DNS lookup and "f" indicates a lookup in the hosts file.
+.TP 18
+.B ARES_OPT_SOCK_STATE_CB
+.B void (*\fIsock_state_cb\fP)(void *data, ares_socket_t socket_fd, int readable, int writable);
+.br
+.B void *\fIsock_state_cb_data\fP;
+.br
+A callback function to be invoked when a socket changes state.
+.I socket_fd
+will be passed the socket whose state has changed;
+.I readable
+will be set to true if the socket should listen for read events, and
+.I writable
+will be set to true if the socket should listen for write events.
+The value of
+.I sock_state_cb_data
+will be passed as the
+.I data
+argument.
+.TP 18
+.B ARES_OPT_SORTLIST
+.B struct apattern *\fIsortlist\fP;
+.br
+.B int \fInsort\fP;
+.br
+A list of IP address ranges that specifies the order of preference that
+results from \fIares_gethostbyname\fP should be returned in.  Note that
+this can only be used with a sortlist retrieved via
+\fBares_save_options(3)\fP (because
+.B struct apattern
+is opaque); to set a fresh sort list, use \fBares_set_sortlist(3)\fP.
+.TP 18
+.B ARES_OPT_SOCK_SNDBUF
+.B int \fIsocket_send_buffer_size\fP;
+.br
+The send buffer size to set for the socket.
+.TP 18
+.B ARES_OPT_SOCK_RCVBUF
+.B int \fIsocket_receive_buffer_size\fP;
+.br
+The receive buffer size to set for the socket.
+.TP 18
+.B ARES_OPT_EDNSPSZ
+.B int \fIednspsz\fP;
+.br
+The message size to be advertized in EDNS; only takes effect if the
+.B ARES_FLAG_EDNS
+flag is set.
+.TP 18
+.B ARES_OPT_RESOLVCONF
+.B char *\fIresolvconf_path\fP;
+.br
+The path to use for reading the resolv.conf file. The
+.I resolvconf_path
+should be set to a path string, and will be honoured on *nix like systems. The
+default is
+.B /etc/resolv.conf
+.br
+.PP
+The \fIoptmask\fP parameter also includes options without a corresponding
+field in the
+.B ares_options
+structure, as follows:
+.TP 23
+.B ARES_OPT_ROTATE
+Perform round-robin selection of the nameservers configured for the channel
+for each resolution.
+.TP 23
+.B ARES_OPT_NOROTATE
+Do not perform round-robin nameserver selection; always use the list of
+nameservers in the same order.
+.PP
+The
+.I flags
+field should be the bitwise or of some subset of the following values:
+.TP 23
+.B ARES_FLAG_USEVC
+Always use TCP queries (the "virtual circuit") instead of UDP
+queries.  Normally, TCP is only used if a UDP query yields a truncated
+result.
+.TP 23
+.B ARES_FLAG_PRIMARY
+Only query the first server in the list of servers to query.
+.TP 23
+.B ARES_FLAG_IGNTC
+If a truncated response to a UDP query is received, do not fall back
+to TCP; simply continue on with the truncated response.
+.TP 23
+.B ARES_FLAG_NORECURSE
+Do not set the "recursion desired" bit on outgoing queries, so that the name
+server being contacted will not try to fetch the answer from other servers if
+it doesn't know the answer locally. Be aware that ares will not do the
+recursion for you.  Recursion must be handled by the application calling ares
+if \fIARES_FLAG_NORECURSE\fP is set.
+.TP 23
+.B ARES_FLAG_STAYOPEN
+Do not close communications sockets when the number of active queries
+drops to zero.
+.TP 23
+.B ARES_FLAG_NOSEARCH
+Do not use the default search domains; only query hostnames as-is or
+as aliases.
+.TP 23
+.B ARES_FLAG_NOALIASES
+Do not honor the HOSTALIASES environment variable, which normally
+specifies a file of hostname translations.
+.TP 23
+.B ARES_FLAG_NOCHECKRESP
+Do not discard responses with the SERVFAIL, NOTIMP, or REFUSED
+response code or responses whose questions don't match the questions
+in the request.  Primarily useful for writing clients which might be
+used to test or debug name servers.
+.TP 23
+.B ARES_FLAG_EDNS
+Include an EDNS pseudo-resource record (RFC 2671) in generated requests.
+.SH RETURN VALUES
+\fBares_init_options(3)\fP can return any of the following values:
+.TP 14
+.B ARES_SUCCESS
+Initialization succeeded.
+.TP 14
+.B ARES_EFILE
+A configuration file could not be read.
+.TP 14
+.B ARES_ENOMEM
+The process's available memory was exhausted.
+.TP 14
+.B ARES_ENOTINITIALIZED
+c-ares library initialization not yet performed.
+.SH NOTES
+When initializing from
+.B /etc/resolv.conf,
+(or, alternatively when specified by the
+.I resolvconf_path
+path location)
+\fBares_init_options(3)\fP reads the \fIdomain\fP and \fIsearch\fP directives
+to allow lookups of short names relative to the domains specified. The
+\fIdomain\fP and \fIsearch\fP directives override one another. If more that
+one instance of either \fIdomain\fP or \fIsearch\fP directives is specified,
+the last occurrence wins. For more information, please see the
+.BR resolv.conf (5)
+manual page.
+.SH SEE ALSO
+.BR ares_init(3),
+.BR ares_destroy(3),
+.BR ares_dup(3),
+.BR ares_library_init(3),
+.BR ares_save_options(3),
+.BR ares_set_servers(3),
+.BR ares_set_sortlist(3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Copyright (C) 2004-2010 by Daniel Stenberg.
diff --git a/deps/cares/docs/ares_library_cleanup.3 b/deps/cares/docs/ares_library_cleanup.3
new file mode 100644
index 0000000000000000000000000000000000000000..a1ffa6a948a479c32fe3bd3e5341050c14bed025
--- /dev/null
+++ b/deps/cares/docs/ares_library_cleanup.3
@@ -0,0 +1,84 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\" Copyright (C) 2004-2009 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_LIBRARY_CLEANUP 3 "19 May 2009"
+.SH NAME
+ares_library_cleanup \- c-ares library deinitialization
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+void ares_library_cleanup(void)
+.fi
+.SH DESCRIPTION
+.PP
+The
+.B ares_library_cleanup
+function uninitializes the c-ares library, freeing all resources
+previously acquired by \fIares_library_init(3)\fP when the library
+was initialized, provided there was only one single previous call to
+\fIares_library_init(3)\fP. If there was more than one previous call to
+\fIares_library_init(3)\fP, this function uninitializes the c-ares
+library only if it is the call matching the call to
+\fIares_library_init(3)\fP which initialized the library
+(usually the very first call to \fIares_library_init(3)\fP).
+Other calls to \fIares_library_cleanup(3)\fP have no effect other than
+decrementing an internal counter.
+.PP
+This function must be called when the program using c-ares will
+no longer need any c-ares function. Once the program has called
+\fIares_library_cleanup(3)\fP sufficiently often such that the
+library is uninitialised, it shall not make any further call to any
+c-ares function.
+.PP
+This function does not cancel any pending c-ares lookups or requests
+previously done. Program  must use \fIares_cancel(3)\fP for this purpose.
+.PP
+.B This function is not thread safe.
+You have to call it once the program is about to terminate, but this call must
+be done once the program has terminated every single thread that it could have
+initiated. This is required to avoid potential race conditions in library
+deinitialization, and also due to the fact that \fIares_library_cleanup(3)\fP
+might call functions from other libraries that are thread unsafe, and could
+conflict with any other thread that is already using these other libraries.
+.PP
+Win32/64 application DLLs shall not call \fIares_library_cleanup(3)\fP from
+the DllMain function. Doing so will produce deadlocks and other problems.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.7.0 along with the
+definition of preprocessor symbol \fICARES_HAVE_ARES_LIBRARY_CLEANUP\fP as an
+indication of the availability of this function. Reference counting in
+\fIares_library_init()\fP and \fIares_library_cleanup()\fP, which requires
+calls to the former function to match calls to the latter, is present since
+c-ares version 1.10.0.
+Earlier versions would deinitialize the library on the first call
+to \fIares_library_cleanup()\fP.
+.PP
+Since the introduction of this function, it is absolutely mandatory to call it
+for any Win32/64 program using c-ares.
+.PP
+Non-Win32/64 systems can still use c-ares version 1.7.0 without calling
+\fIares_library_cleanup(3)\fP due to the fact that \fIcurrently\fP it is nearly
+a do-nothing function on non-Win32/64 platforms.
+.SH SEE ALSO
+.BR ares_library_init(3),
+.BR ares_cancel(3)
+.SH AUTHOR
+Yang Tse
+.PP
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Copyright (C) 2004-2009 by Daniel Stenberg.
diff --git a/deps/cares/docs/ares_library_init.3 b/deps/cares/docs/ares_library_init.3
new file mode 100644
index 0000000000000000000000000000000000000000..b38cf325d4ee4e76d468311caac5fe01aea2e241
--- /dev/null
+++ b/deps/cares/docs/ares_library_init.3
@@ -0,0 +1,114 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\" Copyright (C) 2004-2009 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_LIBRARY_INIT 3 "19 May 2009"
+.SH NAME
+ares_library_init \- c-ares library initialization
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+int ares_library_init(int \fIflags\fP)
+
+int ares_library_init_mem(int \fIflags\fP,
+                          void *(*\fIamalloc\fP)(size_t),
+                          void (*\fIafree\fP)(void *ptr),
+                          void (*\fIarealloc\fP)(void *ptr, size_t size))
+.fi
+.SH DESCRIPTION
+.PP
+The
+.B ares_library_init
+function performs initializations internally required by the c-ares
+library that must take place before any other function provided by
+c-ares can be used in a program.
+.PP
+This function must be called at least once within the life of a program,
+before the program actually executes any other c-ares library function.
+Initializations done by this function remain effective until a number of
+calls to \fIares_library_cleanup(3)\fP equal to the number of calls to
+this function are performed.
+.PP
+Successive calls to this function do nothing further, only the first
+call done when c-ares is in an uninitialized state is actually
+effective.
+.PP
+The
+.I flags
+parameter is a bit pattern that tells c-ares exactly which features
+should be initialized, as described below. Set the desired bits by
+ORing the values together. In normal operation you should specify
+\fIARES_LIB_INIT_ALL\fP. Don't use any other value unless you are
+familiar with it and trying to control some internal c-ares feature.
+.PP
+The
+.B ares_library_init_mem
+function allows the caller to provide memory management functions that the
+c-ares library will be use instead of \fImalloc(3)\fP, \fIfree(3)\fP and
+\fIrealloc(3)\fP.
+.PP
+.B This function is not thread safe.
+You have to call it once the program has started, but this call must be done
+before the program starts any other thread. This is required to avoid
+potential race conditions in library initialization, and also due to the fact
+that \fIares_library_init(3)\fP might call functions from other libraries that
+are thread unsafe, and could conflict with any other thread that is already
+using these other libraries.
+.PP
+On Windows platforms, the library user should ensure that \fIWSAStartup()\fP
+is called before the c-ares library is initialized and used.
+.PP
+Win32/64 application DLLs shall not call \fIares_library_init(3)\fP from the
+DllMain function. Doing so will produce deadlocks and other problems.
+.SH FLAGS
+.TP 5
+.B ARES_LIB_INIT_ALL
+Initialize everything possible. This sets all known bits.
+.TP
+.B ARES_LIB_INIT_WIN32
+Initialize Win32/64 specific libraries.
+.TP
+.B ARES_LIB_INIT_NONE
+Initialize nothing extra. This sets no bit.
+.SH RETURN VALUE
+Upon successful completion, ares_library_init() will return 0.  Otherwise, a
+non-zero error number will be returned to indicate the error. Except for
+\fIares_strerror(3)\fP, you shall not call any other c-ares function upon
+\fIares_library_init(3)\fP failure.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.7.0 along with the
+definition of preprocessor symbol \fICARES_HAVE_ARES_LIBRARY_INIT\fP as an
+indication of the availability of this function. Its recursive behavior,
+which requires a matching number of calls to \fIares_library_cleanup()\fP
+in order to deinitialize the library, is present since c-ares version
+1.10.0. Earlier versions would deinitialize the library on the first call
+to \fIares_library_cleanup()\fP.
+.PP
+Since the introduction of this function it is absolutely mandatory to
+call it for any Win32/64 program using c-ares.
+.PP
+Non-Win32/64 systems can still use c-ares version 1.7.0 without calling
+\fIares_library_init(3)\fP due to the fact that \fIcurrently\fP it is nearly
+a do-nothing function on non-Win32/64 platforms at this point.
+.SH SEE ALSO
+.BR ares_library_cleanup(3),
+.BR ares_strerror(3)
+.SH AUTHOR
+Yang Tse
+.PP
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Copyright (C) 2004-2009 by Daniel Stenberg.
diff --git a/deps/cares/docs/ares_library_init_android.3 b/deps/cares/docs/ares_library_init_android.3
new file mode 100644
index 0000000000000000000000000000000000000000..9e1ac4cd5bed30d478537c2b94ea766c81224042
--- /dev/null
+++ b/deps/cares/docs/ares_library_init_android.3
@@ -0,0 +1,142 @@
+.\"
+.\" Copyright (C) 2017 by John Schember
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_LIBRARY_INIT_ANDROID 3 "13 Sept 2017"
+.SH NAME
+ares_library_init_android \- c-ares library Android initialization
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+int ares_library_init_android(jobject \fIconnectivity_manager\fP)
+
+int ares_library_android_initialized();
+
+void ares_library_init_jvm(JavaVM *\fIjvm\fP)
+
+.fi
+.SH DESCRIPTION
+The \fIares_library_init_android(3)\fP function performs initializations
+internally required by the c-ares library when used on Android. This can take
+place anytime after \fIares_library_init(3)\fP. It must take place after
+\fIares_library_init_jvm\fP. ares_library_init_android must be called before
+DNS resolution will work on Android 8 (Oreo) or newer when targetSdkVersion is
+set to 26+.
+
+As of Android 8 (API level 26) getting DNS server information has
+becomei more restrictive and can only be accessed using the
+Connectivity Manager. It is necessary to pass the connectivity
+manager to c-ares via JNI. Also, the ACCESS_NETWORK_STATE permission
+must be present in the Android application.
+
+Android older than 8 do not need to to be initialized as they
+are less restrictive. However, this is a run time not compile time
+limitation. Proper Android initialization should take place regardless
+of the targeted Android version.
+
+Deinitialization will take place though \fIares_library_cleanup(3)\fP.
+
+The \fBares_library_init_jvm\fP function allows the caller to register the JVM
+with c-ares.  It's meant to be called during JNI_OnLoad because you're
+guaranteed to have the JVM in that function. The JVM is required in order to
+use the Connectivty Manager registered using
+\fIares_library_init_android(3)\fP. This must be call before
+\fIares_library_init_android(3)\fP.
+
+The \fBares_library_android_initialized\fP function can be used to check
+whether c-ares has been initialized for use with Android.
+.SH RETURN VALUES
+ARES_SUCCESS will be returned on success otherwise an error code will be
+returned.
+.SH THREAD SAFETY
+.B These init functions are not thread safe.
+You have to call it once the program has started, but this call must be done
+before the program starts any other thread. This is required to avoid
+potential race conditions in library initialization, and also due to the fact
+these might call functions from other libraries that
+are thread unsafe, and could conflict with any other thread that is already
+using these other libraries.
+.SH JNI
+Accessing the Connectivity Manager though Java:
+
+Register the \fIares_library_android_init\fP.
+.nf
+  static JNINativeMethod funcs[] = {
+  { "initialize_native",     "(Landroid/net/ConnectivityManager;)I",
+    (void *)&ares_library_init_android}
+  };
+
+  JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
+  {
+    JNIEnv *env = NULL;
+    jclass  cls = NULL;
+    jint    res;
+  
+    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK)
+      return -1;
+  
+    cls = (*env)->FindClass(env, JNIT_CLASS);
+    if (cls == NULL)
+      return -1;
+  
+    res = (*env)->RegisterNatives(env, cls, funcs, sizeof(funcs)/sizeof(funcs[0]));
+    if (res != 0)
+      return -1;
+  
+    ares_library_init_jvm(vm);
+    return JNI_VERSION_1_6;
+  }
+.fi
+Calling the registered function from Java:
+.nf
+  public class MyObject {
+    static {
+      System.loadLibrary("cares");
+    }
+  
+    private static native boolean initialize_native(ConnectivityManager
+      connectivity_manager);
+  
+    public static boolean initialize(Context context) {
+      initialize_native((ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE));
+    }
+  }
+.fi
+Initializing the Connectivity Manager in JNI directly using an Android
+Context. It is assumed the JVM has aleady been registered through
+\fIJNI_OnLoad\fP.
+.nf
+  void initialize(jobject android_context)
+  {
+    jclass obj_cls = jni_get_class(env, "android/content/Context");
+    jmethodID obj_mid = jni_get_method_id(env, obj_cls, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
+    jfieldID fid = (*env)->GetStaticFieldID(env, obj_cls, "CONNECTIVITY_SERVICE", "Ljava/lang/String;");
+    jstring str = (*env)->GetStaticObjectField(env, obj_cls, fid);
+    connectivity_manager = (*env)->CallObjectMethod(env, android_context, obj_mid, str);
+    if (connectivity_manager == NULL)
+      return;
+    ares_library_init_android(connectivity_manager);
+  }
+.fi
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.15.0.
+.SH SEE ALSO
+.BR ares_library_init(3),
+.BR ares_library_cleanup(3),
+.SH AUTHOR
+John Schember
+.PP
+Copyright (C) 2017 by John Schember
+
diff --git a/deps/cares/docs/ares_library_initialized.3 b/deps/cares/docs/ares_library_initialized.3
new file mode 100644
index 0000000000000000000000000000000000000000..3e2727f85748a942a22e05869b47c9b219c1e503
--- /dev/null
+++ b/deps/cares/docs/ares_library_initialized.3
@@ -0,0 +1,34 @@
+.\"
+.\" Copyright (C) 2016 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_LIBRARY_INITIALIZED 3 "29 Sep 2016"
+.SH NAME
+ares_library_initialized \- get the initialization state
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+int ares_library_initialized(void)
+.fi
+.SH DESCRIPTION
+Returns information if c-ares needs to get initialized.
+.SH RETURN VALUE
+\fIARES_ENOTINITIALIZED\fP if not initialized and \fIARES_SUCCESS\fP if no
+initialization is needed.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.11.0
+.SH SEE ALSO
+.BR ares_library_init(3),
+.BR ares_library_cleanup(3)
diff --git a/deps/cares/docs/ares_mkquery.3 b/deps/cares/docs/ares_mkquery.3
new file mode 100644
index 0000000000000000000000000000000000000000..c8afad83cbd22b3beea0ac5131fdcccdbd777441
--- /dev/null
+++ b/deps/cares/docs/ares_mkquery.3
@@ -0,0 +1,89 @@
+.\"
+.\" Copyright 1998, 2000 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_MKQUERY 3 "20 Nov 2009"
+.SH NAME
+ares_mkquery \- Compose a single-question DNS query buffer
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_mkquery(const char *\fIname\fP, int \fIdnsclass\fP, int \fItype\fP,
+.B	unsigned short \fIid\fP, int \fIrd\fP, unsigned char **\fIbuf\fP,
+.B	int *\fIbuflen\fP)
+.fi
+.SH DESCRIPTION
+Deprecated function. See \fIares_create_query(3)\fP instead!
+
+The
+.B ares_mkquery
+function composes a DNS query with a single question.
+The parameter
+.I name
+gives the query name as a NUL-terminated C string of period-separated
+labels optionally ending with a period; periods and backslashes within
+a label must be escaped with a backlash.  The parameters
+.I dnsclass
+and
+.I type
+give the class and type of the query using the values defined in
+.BR <arpa/nameser.h> .
+The parameter
+.I id
+gives a 16-bit identifier for the query.  The parameter
+.I rd
+should be nonzero if recursion is desired, zero if not.  The query
+will be placed in an allocated buffer, a pointer to which will be
+stored in the variable pointed to by
+.IR buf ,
+and the length of which will be stored in the variable pointed to by
+.IR buflen .
+It is the caller's responsibility to free this buffer using
+\fIares_free_string(3)\fP when it is no longer needed.
+
+Usage of \fIares_mkquery(3)\fP is deprecated, whereas the function is
+equivalent to \fIares_create_query(3)\fP with \fBmax_udp_size\fP set to
+0.
+
+.SH RETURN VALUES
+.B ares_mkquery
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+Construction of the DNS query succeeded.
+.TP 15
+.B ARES_ENOTFOUND
+The query name
+.I name
+refers to a
+.I .onion
+domain name. See RFC 7686.
+.TP 15
+.B ARES_EBADNAME
+The query name
+.I name
+could not be encoded as a domain name, either because it contained a
+zero-length label or because it contained a label of more than 63
+characters.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH SEE ALSO
+.BR ares_expand_name (3),
+.BR ares_free_string (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998, 2000 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_parse_a_reply.3 b/deps/cares/docs/ares_parse_a_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..8e4908a7fe78cb830722f602aa41844c5980dccc
--- /dev/null
+++ b/deps/cares/docs/ares_parse_a_reply.3
@@ -0,0 +1,80 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_A_REPLY 3 "25 July 1998"
+.SH NAME
+ares_parse_a_reply \- Parse a reply to a DNS query of type A
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_a_reply(const unsigned char *\fIabuf\fP, int \fIalen\fP,
+.B 	struct hostent **\fIhost\fP,
+.B      struct ares_addrttl *\fIaddrttls\fP, int *\fInaddrttls\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_a_reply
+function parses the response to a query of type A into a
+.BR "struct hostent"
+and/or an array of
+.BR "struct ares_addrttls" . 
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR host ,
+if host is nonnull.
+It is the caller's responsibility to free the resulting host structure
+using
+.BR ares_free_hostent (3)
+when it is no longer needed.
+.PP
+If
+.IR addrttls
+and
+.IR naddrttls
+are both nonnull,
+then up to *naddrttls
+.BR "struct ares_addrttl"
+records are stored in the array pointed to by addrttls,
+and then *naddrttls is set to the number of records so stored.
+Note that the memory for these records is supplied by the caller.
+.SH RETURN VALUES
+.B ares_parse_a_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH SEE ALSO
+.BR ares_gethostbyname (3),
+.BR ares_free_hostent (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Andrew Selivanov <andrew.selivanov@gmail.com>
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_parse_aaaa_reply.3 b/deps/cares/docs/ares_parse_aaaa_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..674acc5c468620980ce26bcaf01fd2684b0582c3
--- /dev/null
+++ b/deps/cares/docs/ares_parse_aaaa_reply.3
@@ -0,0 +1,80 @@
+.\"
+.\" Copyright 2005 by Dominick Meglio.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_AAAA_REPLY 3 "20 Nov 2009"
+.SH NAME
+ares_parse_aaaa_reply \- Parse a reply to a DNS query of type AAAA
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_aaaa_reply(const unsigned char *\fIabuf\fP, int \fIalen\fP,
+.B 	struct hostent **\fIhost\fP,         
+.B      struct ares_addr6ttl *\fIaddrttls\fP, int *\fInaddrttls\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_aaaa_reply
+function parses the response to a query of type AAAA into a
+.BR "struct hostent"
+and/or an array of
+.BR "struct ares_addr6ttl" . 
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR host ,
+if host is nonnull.
+It is the caller's responsibility to free the resulting host structure
+using
+.BR ares_free_hostent (3)
+when it is no longer needed.
+.PP
+If
+.IR addrttls
+and
+.IR naddrttls
+are both nonnull,
+then up to *naddrttls
+.BR "struct ares_addr6ttl"
+records are stored in the array pointed to by addrttls,
+and then *naddrttls is set to the number of records so stored.
+Note that the memory for these records is supplied by the caller.
+.SH RETURN VALUES
+.B ares_parse_aaaa_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH SEE ALSO
+.BR ares_gethostbyname (3),
+.BR ares_free_hostent (3)
+.SH AUTHOR
+Dominick Meglio
+.br
+Copyright 2005 by Dominick Meglio.
+.BR
+Andrew Selivanov <andrew.selivanov@gmail.com>
diff --git a/deps/cares/docs/ares_parse_caa_reply.3 b/deps/cares/docs/ares_parse_caa_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..71bd6be96013cce9f7edc5f715a6a9cf1ebecb18
--- /dev/null
+++ b/deps/cares/docs/ares_parse_caa_reply.3
@@ -0,0 +1,171 @@
+.\"
+.\" Copyright 2020 Danny Sonnenschein <my.card.god@web.de>
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_CAA_REPLY 3 "16 September 2020"
+.SH NAME
+ares_parse_caa_reply \- Parse a reply to a DNS query of type CAA
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+int ares_parse_caa_reply(const unsigned char* \fIabuf\fP, int \fIalen\fP,
+                         struct ares_caa_reply **\fIcaa_out\fP);
+.fi
+.SH DESCRIPTION
+The
+.BR "ares_parse_caa_reply" 
+function parses the response to a query of type CAA into a
+linked list (one element per sub-string) of
+.IR "struct ares_caa_reply"
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR caa_out .
+It is the caller's responsibility to free the resulting
+.IR caa_out
+structure when it is no longer needed using the function
+.B ares_free_data(3)
+.PP
+The structure 
+.I ares_caa_reply(3)
+contains the following fields:
+.sp
+.in +4n
+.nf
+struct ares_caa_reply {
+  struct ares_caa_reply *next;
+  int                    critical;
+  unsigned char         *property;
+  size_t                 plength; /* plength excludes null */
+  unsigned char         *value;
+  size_t                 length;  /* length excludes null */
+};
+.fi
+.in
+.PP
+.SH RETURN VALUES
+.BR "ares_parse_caa_reply"
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH EXAMPLE
+.nf
+#include <arpa/inet.h>
+#include <time.h>
+#include <sys/time.h>
+#include <netdb.h>
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ares.h"
+
+static void dns_callback(void *arg,
+                         int status,
+                         int timeouts,
+                         unsigned char *abuf,
+                         int alen)
+  {
+    struct ares_caa_reply *caa_out;
+    int err;
+
+    err = ares_parse_caa_reply (abuf, alen, &caa_out);
+    if (err == ARES_SUCCESS)
+      {
+        struct ares_caa_reply *caa_curr;
+        for (caa_curr=caa_out; caa_curr; caa_curr=caa_curr->next)
+          printf ("%s. CAA %i %s \\"%s\\"\\n", arg,
+                                            caa_curr->critical,
+                                            caa_curr->property,
+                                            caa_curr->value);
+      }
+    else
+      {
+        printf ("err=%i\\n", err);
+      }
+    ares_free_data (caa_out);
+  }
+
+static void main_loop(ares_channel *channel)
+  {
+    int nfds, count;
+    fd_set readers, writers;
+    struct timeval tv, *tvp;
+    while (1)
+      {
+        FD_ZERO (&readers);
+        FD_ZERO (&writers);
+        nfds = ares_fds (*channel, &readers, &writers);
+        if (nfds == 0)
+          break;
+        tvp = ares_timeout (*channel, NULL, &tv);
+        count = select (nfds, &readers, &writers, NULL, tvp);
+        ares_process (*channel, &readers, &writers);
+      }
+  }
+
+int main(int argc, char **argv)
+  {
+    const char *sversion;
+    int iversion;
+    int err;
+
+    sversion = ares_version (&iversion);
+    printf ("c-ares version %s\\n", sversion);
+
+    char *domain = "wikipedia.org";
+    if (argc > 1)
+      domain = argv[1];
+
+    ares_channel channel;
+    if ((err = ares_init (&channel)) != ARES_SUCCESS)
+      {
+        printf ("ares_init() failed (%i)\\n", err);
+        exit (EXIT_FAILURE);
+      }
+
+    ares_query (channel, domain,
+                1,   /* ns_c_in */
+                257, /* T_CAA */
+                dns_callback, domain);
+
+    main_loop (&channel);
+
+    ares_destroy (channel);
+
+    exit (EXIT_SUCCESS);
+  }
+.fi
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.17.0.
+.SH SEE ALSO
+.BR ares_query (3)
+.BR ares_free_data (3)
+.SH AUTHOR
+Written by Danny Sonnenschein <my.card.god@web.de>, on behalf of platynum, https://platynum.ch
diff --git a/deps/cares/docs/ares_parse_mx_reply.3 b/deps/cares/docs/ares_parse_mx_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..87df4592ea38558da2366f27a1970078b90d7d92
--- /dev/null
+++ b/deps/cares/docs/ares_parse_mx_reply.3
@@ -0,0 +1,79 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_MX_REPLY 3 "4 August 2009"
+.SH NAME
+ares_parse_mx_reply \- Parse a reply to a DNS query of type MX
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_mx_reply(const unsigned char* \fIabuf\fP, int \fIalen\fP,
+.B                          struct ares_mx_reply** \fImx_out\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_mx_reply
+function parses the response to a query of type MX into a
+linked list of
+.I struct ares_mx_reply 
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR mx_out .
+It is the caller's responsibility to free the resulting
+.IR mx_out
+structure when it is no longer needed using the function
+.B ares_free_data
+.PP
+The structure 
+.I ares_mx_reply
+contains the following fields:
+.sp
+.in +4n
+.nf
+struct ares_mx_reply {
+    struct ares_mx_reply *next;
+    char *host;
+    unsigned short priority;
+};
+.fi
+.in
+.PP
+.SH RETURN VALUES
+.B ares_parse_mx_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.7.2.
+.SH SEE ALSO
+.BR ares_query (3)
+.BR ares_free_data (3)
+.SH AUTHOR
+Written by Jeremy Lal <kapouer@melix.org>
diff --git a/deps/cares/docs/ares_parse_naptr_reply.3 b/deps/cares/docs/ares_parse_naptr_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..2a5f1e5bd08bed8137245a1696a2617883790ada
--- /dev/null
+++ b/deps/cares/docs/ares_parse_naptr_reply.3
@@ -0,0 +1,83 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_NAPTR_REPLY 3 "23 February 2012"
+.SH NAME
+ares_parse_naptr_reply \- Parse a reply to a DNS query of type NAPTR
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_naptr_reply(const unsigned char* \fIabuf\fP, int \fIalen\fP,
+.B                          struct ares_naptr_reply** \fInaptr_out\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_naptr_reply
+function parses the response to a query of type NAPTR into a
+linked list of
+.I struct ares_naptr_reply 
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR naptr_out .
+It is the caller's responsibility to free the resulting
+.IR naptr_out
+structure when it is no longer needed using the function
+.B ares_free_data
+.PP
+The structure 
+.I ares_naptr_reply
+contains the following fields:
+.sp
+.in +4n
+.nf
+struct ares_naptr_reply {
+    struct ares_naptr_reply *next;
+    unsigned char *flags;
+    unsigned char *service;
+    unsigned char *regexp;
+    char *replacement;
+    unsigned short order;
+    unsigned short preference;
+};
+.fi
+.in
+.PP
+.SH RETURN VALUES
+.B ares_parse_naptr_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.7.6.
+.SH SEE ALSO
+.BR ares_query (3)
+.BR ares_free_data (3)
+.SH AUTHOR
+Written by Jakub Hrozek <jhrozek@redhat.com>, on behalf of Red Hat, Inc http://www.redhat.com
diff --git a/deps/cares/docs/ares_parse_ns_reply.3 b/deps/cares/docs/ares_parse_ns_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..b6340ac84649ff7da7545903e0c288c7a6cff69d
--- /dev/null
+++ b/deps/cares/docs/ares_parse_ns_reply.3
@@ -0,0 +1,66 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_NS_REPLY 3 "10 February 2007"
+.SH NAME
+ares_parse_ns_reply \- Parse a reply to a DNS query of type NS into a hostent
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_ns_reply(const unsigned char *\fIabuf\fP, int \fIalen\fP,
+.B 	struct hostent **\fIhost\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_ns_reply
+function parses the response to a query of type NS into a
+.BR "struct hostent" .
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR host . 
+The nameservers are stored into the 
+.BR aliases 
+field of the 
+.IR host 
+structure. 
+It is the caller's responsibility to free the resulting host structure
+using
+.BR ares_free_hostent (3)
+when it is no longer needed.
+.SH RETURN VALUES
+.B ares_parse_ns_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH SEE ALSO
+.BR ares_query (3),
+.BR ares_free_hostent (3)
+.SH AUTHOR
+Written by Vlad Dinulescu <vlad.dinulescu@avira.com>, on behalf of AVIRA Gmbh http://www.avira.com
diff --git a/deps/cares/docs/ares_parse_ptr_reply.3 b/deps/cares/docs/ares_parse_ptr_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..1016a6823fddacd494f0434697232614a5452deb
--- /dev/null
+++ b/deps/cares/docs/ares_parse_ptr_reply.3
@@ -0,0 +1,74 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_PTR_REPLY 3 "25 July 1998"
+.SH NAME
+ares_parse_ptr_reply \- Parse a reply to a DNS query of type PTR into a hostent
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_ptr_reply(const unsigned char *\fIabuf\fP, int \fIalen\fP,
+.B 	const void *\fIaddr\fP, int \fIaddrlen\fP, int \fIfamily\fP,
+.B	struct hostent **\fIhost\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_ptr_reply
+function parses the response to a query of type PTR into a
+.BR "struct hostent" .
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The parameters
+.IR addr ,
+.IR addrlen ,
+and
+.I family
+specify which address was queried for; they are not used to verify the
+response, merely used to fill in the address of the
+.BR "struct hostent" .
+The resulting
+.B struct hostent
+is stored in allocated memory and a pointer to it stored into the
+variable pointed to by
+.IR host .
+It is the caller's responsibility to free the resulting host structure
+using
+.BR ares_free_hostent (3)
+when it is no longer needed.
+.SH RETURN VALUES
+.B ares_parse_ptr_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH SEE ALSO
+.BR ares_gethostbyaddr (3),
+.BR ares_free_hostent (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_parse_soa_reply.3 b/deps/cares/docs/ares_parse_soa_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..1c4456f0bbe9b09bca8fcbdd9d34d5ef34ff481d
--- /dev/null
+++ b/deps/cares/docs/ares_parse_soa_reply.3
@@ -0,0 +1,80 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_SOA_REPLY 3 "29 May 2012"
+.SH NAME
+ares_parse_soa_reply \- Parse a reply to a DNS query of type SOA
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_soa_reply(const unsigned char* \fIabuf\fP, int \fIalen\fP,
+.B				struct ares_soa_reply** \fIsoa_out\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_soa_reply
+function parses the response to a query of type SOA into a
+.IR struct\ ares_soa_reply .
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR soa_out .
+It is the caller's responsibility to free the resulting
+.IR soa_out
+structure when it is no longer needed using the function
+.B ares_free_data
+.PP
+The structure 
+.I ares_soa_reply
+contains the following fields:
+.sp
+.in +4n
+.nf
+struct ares_soa_reply {
+	char *nsname;
+	char *hostmaster;
+	unsigned int serial;
+	unsigned int refresh;
+	unsigned int retry;
+	unsigned int expire;
+	unsigned int minttl;
+};
+.fi
+.in
+.PP
+.SH RETURN VALUES
+.B ares_parse_soa_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.9.0.
+.SH SEE ALSO
+.BR ares_query (3)
+.BR ares_free_data (3)
diff --git a/deps/cares/docs/ares_parse_srv_reply.3 b/deps/cares/docs/ares_parse_srv_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..9b561ffa365cc7fd79883ae2c29bb15b018b156f
--- /dev/null
+++ b/deps/cares/docs/ares_parse_srv_reply.3
@@ -0,0 +1,81 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_SRV_REPLY 3 "4 August 2009"
+.SH NAME
+ares_parse_srv_reply \- Parse a reply to a DNS query of type SRV
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_srv_reply(const unsigned char* \fIabuf\fP, int \fIalen\fP,
+.B                          struct ares_srv_reply** \fIsrv_out\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_srv_reply
+function parses the response to a query of type SRV into a
+linked list of
+.I struct ares_srv_reply 
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR srv_out .
+It is the caller's responsibility to free the resulting
+.IR srv_out
+structure when it is no longer needed using the function
+.B ares_free_data
+.PP
+The structure 
+.I ares_srv_reply
+contains the following fields:
+.sp
+.in +4n
+.nf
+struct ares_srv_reply {
+    struct ares_srv_reply  *next;
+    unsigned short weight;
+    unsigned short priority;
+    unsigned short port;
+    char *host;
+};
+.fi
+.in
+.PP
+.SH RETURN VALUES
+.B ares_parse_srv_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.7.0.
+.SH SEE ALSO
+.BR ares_query (3)
+.BR ares_free_data (3)
+.SH AUTHOR
+Written by Jakub Hrozek <jhrozek@redhat.com>, on behalf of Red Hat, Inc http://www.redhat.com
diff --git a/deps/cares/docs/ares_parse_txt_reply.3 b/deps/cares/docs/ares_parse_txt_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..e15d0eace15ac4701e69a97f6268a53b12f9bb1d
--- /dev/null
+++ b/deps/cares/docs/ares_parse_txt_reply.3
@@ -0,0 +1,120 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_TXT_REPLY 3 "27 October 2009"
+.SH NAME
+ares_parse_txt_reply \- Parse a reply to a DNS query of type TXT
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_txt_reply(const unsigned char* \fIabuf\fP, int \fIalen\fP,
+.B                         struct ares_txt_reply **\fItxt_out\fP);
+.PP
+.B int ares_parse_txt_reply_ext(const unsigned char* \fIabuf\fP, int \fIalen\fP,
+.B                              struct ares_txt_ext **\fItxt_out\fP);
+.fi
+.SH DESCRIPTION
+The
+.BR "ares_parse_txt_reply" " (" "ares_parse_txt_reply_ext" ")"
+function parses the response to a query of type TXT into a
+linked list (one element per sub-string) of
+.IR "struct ares_txt_reply" " (" "struct ares_txt_ext" ")"
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR txt_out .
+It is the caller's responsibility to free the resulting
+.IR txt_out
+structure when it is no longer needed using the function
+.B ares_free_data
+.PP
+The structure 
+.I ares_txt_reply
+contains the following fields:
+.sp
+.in +4n
+.nf
+struct ares_txt_reply {
+  struct ares_txt_reply  *next;
+  unsigned int  length;
+  unsigned char *txt;
+};
+.fi
+.in
+.PP
+The structure
+.I ares_txt_ext
+contains the following fields:
+.sp
+.in +4n
+.nf
+struct ares_txt_ext {
+  struct ares_txt_ext  *next;
+  unsigned int  length;
+  unsigned char *txt;
+  unsigned char record_start;
+};
+.fi
+.in
+.PP
+The
+.I record_start
+field in
+.I struct ares_txt_ext
+is 1 if this structure is a start of a TXT record, and 0 if the structure is a
+continuation of a previous record. The linked list of the
+.I struct ares_txt_ext
+will have at least one item with
+.I record_start
+equal to 1, and may have some items with
+.I record_start
+equal to 0 between them.
+.PP
+These sequences of
+.I struct ares_txt_ext
+(starting from the item with
+.I record_start
+equal to 1, and ending right before the record start item) may be treated as
+either components of a single TXT record or as a multi-parted TXT record,
+depending on particular use case.
+.PP
+.SH RETURN VALUES
+.BR "ares_parse_txt_reply" " (" "ares_parse_txt_reply_ext" ")"
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH AVAILABILITY
+This function was first introduced in c-ares version 1.7.0.
+.SH SEE ALSO
+.BR ares_query (3)
+.BR ares_free_data (3)
+.SH AUTHOR
+Written by Jakub Hrozek <jhrozek@redhat.com>, on behalf of Red Hat, Inc http://www.redhat.com
+.PP
+Amended by Fedor Indutny <fedor@indutny.com>, on behalf of PayPal, Inc https://www.paypal.com
diff --git a/deps/cares/docs/ares_parse_uri_reply.3 b/deps/cares/docs/ares_parse_uri_reply.3
new file mode 100644
index 0000000000000000000000000000000000000000..09da1a94e58fb8e0444c0b2df060a789edbf102b
--- /dev/null
+++ b/deps/cares/docs/ares_parse_uri_reply.3
@@ -0,0 +1,81 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PARSE_URI_REPLY 3 "14 August 2020"
+.SH NAME
+ares_parse_uri_reply \- Parse a reply to a DNS query of type URI
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_parse_uri_reply(const unsigned char* \fIabuf\fP, int \fIalen\fP,
+.B                          struct ares_uri_reply** \fIuri_out\fP);
+.fi
+.SH DESCRIPTION
+The
+.B ares_parse_uri_reply
+function parses the response to a query of type URI into a
+linked list of
+.I struct ares_uri_reply 
+The parameters
+.I abuf
+and
+.I alen
+give the contents of the response.  The result is stored in allocated
+memory and a pointer to it stored into the variable pointed to by
+.IR uri_out .
+It is the caller's responsibility to free the resulting
+.IR uri_out
+structure when it is no longer needed using the function
+.B ares_free_data
+.PP
+The structure 
+.I ares_uri_reply
+contains the following fields:
+.sp
+.in +4n
+.nf
+struct ares_uri_reply {
+    struct ares_uri_reply       *next;
+    unsigned short              weight;
+    unsigned short              priority;
+    char                        *uri;
+    int                         ttl;
+};
+.fi
+.in
+.PP
+.SH RETURN VALUES
+.B ares_parse_uri_reply
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The response was successfully parsed.
+.TP 15
+.B ARES_EBADRESP
+The response was malformatted.
+.TP 15
+.B ARES_ENODATA
+The response did not contain an answer to the query.
+.TP 15
+.B ARES_ENOMEM
+Memory was exhausted.
+.SH AVAILABILITY
+
+.SH SEE ALSO
+.BR ares_query (3)
+.BR ares_free_data (3)
+.SH AUTHOR
+Written by Jan Petrasek <petrasek@tes.eu>
diff --git a/deps/cares/docs/ares_process.3 b/deps/cares/docs/ares_process.3
new file mode 100644
index 0000000000000000000000000000000000000000..caabbf13b94dfa08d9f50a867ab2c7553cfe7877
--- /dev/null
+++ b/deps/cares/docs/ares_process.3
@@ -0,0 +1,79 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_PROCESS 3 "25 July 1998"
+.SH NAME
+ares_process \- Process events for name resolution
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+void ares_process(ares_channel \fIchannel\fP,
+                  fd_set *\fIread_fds\fP,
+                  fd_set *\fIwrite_fds\fP)
+
+void ares_process_fd(ares_channel \fIchannel\fP,
+                     ares_socket_t \fIread_fd\fP,
+                     ares_socket_t \fIwrite_fd\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_process(3)\fP function handles input/output events and timeouts
+associated with queries pending on the name service channel identified by
+.IR channel .
+The file descriptor sets pointed to by \fIread_fds\fP and \fIwrite_fds\fP
+should have file descriptors set in them according to whether the file
+descriptors specified by \fIares_fds(3)\fP are ready for reading and writing.
+(The easiest way to determine this information is to invoke \fBselect(3)\fP
+with a timeout no greater than the timeout given by \fIares_timeout(3)\fP).
+
+The \fBares_process(3)\fP function will invoke callbacks for pending queries
+if they complete successfully or fail.
+
+\fBares_process_fd(3)\fP works the same way but acts and operates only on the
+specific file descriptors (sockets) you pass in to the function. Use
+ARES_SOCKET_BAD for "no action". This function is provided to allow users of
+c-ares to void \fIselect(3)\fP in their applications and within c-ares.
+
+To only process possible timeout conditions without a socket event occurring,
+one may pass NULL as the values for both \fIread_fds\fP and \fIwrite_fds\fP for
+\fBares_process(3)\fP, or ARES_SOCKET_BAD for both \fIread_fd\fP and
+\fIwrite_fd\fP for \fBares_process_fd(3)\fP.
+.SH EXAMPLE
+The following code fragment waits for all pending queries on a channel
+to complete:
+
+.nf
+int nfds, count;
+fd_set readers, writers;
+struct timeval tv, *tvp;
+
+while (1) {
+  FD_ZERO(&readers);
+  FD_ZERO(&writers);
+  nfds = ares_fds(channel, &readers, &writers);
+  if (nfds == 0)
+    break;
+  tvp = ares_timeout(channel, NULL, &tv);
+  count = select(nfds, &readers, &writers, NULL, tvp);
+  ares_process(channel, &readers, &writers);
+}
+.fi
+.SH SEE ALSO
+.BR ares_fds (3),
+.BR ares_timeout (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_query.3 b/deps/cares/docs/ares_query.3
new file mode 100644
index 0000000000000000000000000000000000000000..733fbc972b58faa90c6d0385b45830a21b084064
--- /dev/null
+++ b/deps/cares/docs/ares_query.3
@@ -0,0 +1,149 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_QUERY 3 "24 July 1998"
+.SH NAME
+ares_query \- Initiate a single-question DNS query
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef void (*ares_callback)(void *\fIarg\fP, int \fIstatus\fP,
+.B	int \fItimeouts\fP, unsigned char *\fIabuf\fP, int \fIalen\fP)
+.PP
+.B void ares_query(ares_channel \fIchannel\fP, const char *\fIname\fP,
+.B 	int \fIdnsclass\fP, int \fItype\fP, ares_callback \fIcallback\fP,
+.B	void *\fIarg\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_query
+function initiates a single-question DNS query on the name service
+channel identified by
+.IR channel .
+The parameter
+.I name
+gives the query name as a NUL-terminated C string of period-separated
+labels optionally ending with a period; periods and backslashes within
+a label must be escaped with a backslash.  The parameters
+.I dnsclass
+and
+.I type
+give the class and type of the query using the values defined in
+.BR <arpa/nameser.h> .
+When the query is complete or has failed, the ares library will invoke
+.IR callback .
+Completion or failure of the query may happen immediately, or may
+happen during a later call to
+.BR ares_process (3)
+or
+.BR ares_destroy (3).
+.PP
+The callback argument
+.I arg
+is copied from the
+.B ares_query
+argument
+.IR arg .
+The callback argument
+.I status
+indicates whether the query succeeded and, if not, how it failed.  It
+may have any of the following values:
+.TP 19
+.B ARES_SUCCESS
+The query completed successfully.
+.TP 19
+.B ARES_ENODATA
+The query completed but contains no answers.
+.TP 19
+.B ARES_EFORMERR
+The query completed but the server claims that the query was
+malformatted.
+.TP 19
+.B ARES_ESERVFAIL
+The query completed but the server claims to have experienced a
+failure.  (This code can only occur if the
+.B ARES_FLAG_NOCHECKRESP
+flag was specified at channel initialization time; otherwise, such
+responses are ignored at the
+.BR ares_send (3)
+level.)
+.TP 19
+.B ARES_ENOTFOUND
+The query completed but the queried-for domain name was not found.
+.TP 19
+.B ARES_ENOTIMP
+The query completed but the server does not implement the operation
+requested by the query.  (This code can only occur if the
+.B ARES_FLAG_NOCHECKRESP
+flag was specified at channel initialization time; otherwise, such
+responses are ignored at the
+.BR ares_send (3)
+level.)
+.TP 19
+.B ARES_EREFUSED
+The query completed but the server refused the query.  (This code can
+only occur if the
+.B ARES_FLAG_NOCHECKRESP
+flag was specified at channel initialization time; otherwise, such
+responses are ignored at the
+.BR ares_send (3)
+level.)
+.TP 19
+.B ARES_EBADNAME
+The query name
+.I name
+could not be encoded as a domain name, either because it contained a
+zero-length label or because it contained a label of more than 63
+characters.
+.TP 19
+.B ARES_ETIMEOUT
+No name servers responded within the timeout period.
+.TP 19
+.B ARES_ECONNREFUSED
+No name servers could be contacted.
+.TP 19
+.B ARES_ENOMEM
+Memory was exhausted.
+.TP 19
+.B ARES_ECANCELLED
+The query was cancelled.
+.TP 19
+.B ARES_EDESTRUCTION
+The name service channel
+.I channel
+is being destroyed; the query will not be completed.
+.PP
+The callback argument
+.I timeouts
+reports how many times a query timed out during the execution of the
+given request.
+.PP
+If the query completed (even if there was something wrong with it, as
+indicated by some of the above error codes), the callback argument
+.I abuf
+points to a result buffer of length
+.IR alen .
+If the query did not complete,
+.I abuf
+will be NULL and
+.I alen
+will be 0.
+.SH SEE ALSO
+.BR ares_process (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_save_options.3 b/deps/cares/docs/ares_save_options.3
new file mode 100644
index 0000000000000000000000000000000000000000..bddae049344c6f8ac46cf72ccf79fcb4a61642d8
--- /dev/null
+++ b/deps/cares/docs/ares_save_options.3
@@ -0,0 +1,74 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SAVE_OPTIONS 3 "5 March 2010"
+.SH NAME
+ares_save_options \- Save configuration values obtained from initialized ares_channel
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_save_options(ares_channel \fIchannel\fP, struct ares_options *\fIoptions\fP, int *\fIoptmask\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_save_options(3)\fP function saves the channel data identified by
+.IR channel ,
+into the options struct identified by
+.IR options ,
+and saves the mask of options which are set to the integer
+pointer (passed by reference) identified by
+.IR optmask .
+
+The resultant options and optmask are then able to be
+passed directly to ares_init_options.  When the options
+are no longer needed, ares_destroy_options should be called
+to free any associated memory.
+.SH RETURN VALUES
+.B ares_save_options(3)
+can return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The channel data was successfully stored
+.TP 15
+.B ARES_ENOMEM
+The memory was exhausted
+.TP 15
+.B ARES_ENODATA
+The channel data identified by 
+.IR channel
+were invalid.
+.SH NOTE
+Since c-ares 1.6.0 the ares_options struct has been "locked" meaning that it
+won't be extended to cover new functions. This function will remain
+functioning, but it can only return config data that can be represented in
+this config struct, which may no longer be the complete set of config
+options. \fBares_dup(3)\fP will not have that restriction.
+
+The ares_options struct can not handle potential IPv6 name servers the
+ares_channel might be configured to use. The \fBares_save_options(3)\fP function
+will only return IPv4 servers, if any. In order to retrieve all name servers
+an ares_channel might be using, the \fBares_get_servers(3)\fP function must be
+used instead.
+.SH SEE ALSO
+.BR ares_destroy_options (3),
+.BR ares_init_options (3),
+.BR ares_get_servers (3),
+.BR ares_dup (3)
+.SH AVAILABILITY
+ares_save_options(3) was added in c-ares 1.4.0
+.SH AUTHOR
+Brad House
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_search.3 b/deps/cares/docs/ares_search.3
new file mode 100644
index 0000000000000000000000000000000000000000..2c85d20f645b08cb07a2282d1798925d51fef11b
--- /dev/null
+++ b/deps/cares/docs/ares_search.3
@@ -0,0 +1,151 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SEARCH 3 "24 July 1998"
+.SH NAME
+ares_search \- Initiate a DNS query with domain search
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef void (*ares_callback)(void *\fIarg\fP, int \fIstatus\fP,
+.B	int \fItimeouts\fP, unsigned char *\fIabuf\fP, int \fIalen\fP)
+.PP
+.B void ares_search(ares_channel \fIchannel\fP, const char *\fIname\fP,
+.B 	int \fIdnsclass\fP, int \fItype\fP, ares_callback \fIcallback\fP,
+.B	void *\fIarg\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_search
+function initiates a series of single-question DNS queries on the name
+service channel identified by
+.IR channel ,
+using the channel's search domains as well as a host alias file given
+by the HOSTALIAS environment variable.  The parameter
+.I name
+gives the alias name or the base of the query name as a NUL-terminated
+C string of period-separated labels; if it ends with a period, the
+channel's search domains will not be used.  Periods and backslashes
+within a label must be escaped with a backslash.  The parameters
+.I dnsclass
+and
+.I type
+give the class and type of the query using the values defined in
+.BR <arpa/nameser.h> .
+When the query sequence is complete or has failed, the ares library
+will invoke
+.IR callback .
+Completion or failure of the query sequence may happen immediately, or
+may happen during a later call to
+.BR ares_process (3)
+or
+.BR ares_destroy (3).
+.PP
+The callback argument
+.I arg
+is copied from the
+.B ares_search
+argument
+.IR arg .
+The callback argument
+.I status
+indicates whether the query sequence ended with a successful query
+and, if not, how the query sequence failed.  It may have any of the
+following values:
+.TP 19
+.B ARES_SUCCESS
+A query completed successfully.
+.TP 19
+.B ARES_ENODATA
+No query completed successfully; when the query was tried without a
+search domain appended, a response was returned with no answers.
+.TP 19
+.B ARES_EFORMERR
+A query completed but the server claimed that the query was
+malformatted.
+.TP 19
+.B ARES_ESERVFAIL
+No query completed successfully; when the query was tried without a
+search domain appended, the server claimed to have experienced a
+failure.  (This code can only occur if the
+.B ARES_FLAG_NOCHECKRESP
+flag was specified at channel initialization time; otherwise, such
+responses are ignored at the
+.BR ares_send (3)
+level.)
+.TP 19
+.B ARES_ENOTFOUND
+No query completed successfully; when the query was tried without a
+search domain appended, the server reported that the queried-for
+domain name was not found.
+.TP 19
+.B ARES_ENOTIMP
+A query completed but the server does not implement the operation
+requested by the query.  (This code can only occur if the
+.B ARES_FLAG_NOCHECKRESP
+flag was specified at channel initialization time; otherwise, such
+responses are ignored at the
+.BR ares_send (3)
+level.)
+.TP 19
+.B ARES_EREFUSED
+A query completed but the server refused the query.  (This code can
+only occur returned if the
+.B ARES_FLAG_NOCHECKRESP
+flag was specified at channel initialization time; otherwise, such
+responses are ignored at the
+.BR ares_send (3)
+level.)
+.TP 19
+.B ARES_TIMEOUT
+No name servers responded to a query within the timeout period.
+.TP 19
+.B ARES_ECONNREFUSED
+No name servers could be contacted.
+.TP 19
+.B ARES_ENOMEM
+Memory was exhausted.
+.TP 19
+.B ARES_ECANCELLED
+The query was cancelled.
+.TP 19
+.B ARES_EDESTRUCTION
+The name service channel
+.I channel
+is being destroyed; the query will not be completed.
+.PP
+The callback argument
+.I timeouts
+reports how many times a query timed out during the execution of the
+given request.
+.PP
+If a query completed successfully, the callback argument
+.I abuf
+points to a result buffer of length
+.IR alen .
+If the query did not complete successfully,
+.I abuf
+will usually be NULL and
+.I alen
+will usually be 0, but in some cases an unsuccessful query result may
+be placed in
+.IR abuf .
+.SH SEE ALSO
+.BR ares_process (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_send.3 b/deps/cares/docs/ares_send.3
new file mode 100644
index 0000000000000000000000000000000000000000..b89abfeb85a8909f89703438224edab0d398e156
--- /dev/null
+++ b/deps/cares/docs/ares_send.3
@@ -0,0 +1,123 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SEND 3 "25 July 1998"
+.SH NAME
+ares_send \- Initiate a DNS query
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef void (*ares_callback)(void *\fIarg\fP, int \fIstatus\fP,
+.B	int \fItimeouts\fP, unsigned char *\fIabuf\fP, int \fIalen\fP)
+.PP
+.B void ares_send(ares_channel \fIchannel\fP, const unsigned char *\fIqbuf\fP,
+.B 	int \fIqlen\fP, ares_callback \fIcallback\fP, void *\fIarg\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_send
+function initiates a DNS query on the name service channel identified
+by
+.IR channel .
+The parameters
+.I qbuf
+and
+.I qlen
+give the DNS query, which should already have been formatted according
+to the DNS protocol.  When the query is complete or has failed, the
+ares library will invoke
+.IR callback .
+Completion or failure of the query may happen immediately, or may
+happen during a later call to
+.BR ares_process (3)
+or
+.BR ares_destroy (3).
+.PP
+The callback argument
+.I arg
+is copied from the
+.B ares_send
+argument
+.IR arg .
+The callback argument
+.I status
+indicates whether the query succeeded and, if not, how it failed.  It
+may have any of the following values:
+.TP 19
+.B ARES_SUCCESS
+The query completed.
+.TP 19
+.B ARES_EBADQUERY
+The query buffer was poorly formed (was not long enough for a DNS
+header or was too long for TCP transmission).
+.TP 19
+.B ARES_ETIMEOUT
+No name servers responded within the timeout period.
+.TP 19
+.B ARES_ECONNREFUSED
+No name servers could be contacted.
+.TP 19
+.B ARES_ENOMEM
+Memory was exhausted.
+.TP 19
+.B ARES_ECANCELLED
+The query was cancelled.
+.TP 19
+.B ARES_EDESTRUCTION
+The name service channel
+.I channel
+is being destroyed; the query will not be completed.
+.PP
+The callback argument
+.I timeouts
+reports how many times a query timed out during the execution of the
+given request.
+.PP
+If the query completed, the callback argument
+.I abuf
+points to a result buffer of length
+.IR alen .
+If the query did not complete,
+.I abuf
+will be NULL and
+.I alen
+will be 0.
+.PP
+Unless the flag
+.B ARES_FLAG_NOCHECKRESP
+was set at channel initialization time,
+.B ares_send
+will normally ignore responses whose questions do not match the
+questions in
+.IR qbuf ,
+as well as responses with reply codes of
+.BR SERVFAIL ,
+.BR NOTIMP ,
+and
+.BR REFUSED .
+Unlike other query functions in the ares library, however,
+.B ares_send
+does not inspect the header of the reply packet to determine the error
+status, so a callback status of
+.B ARES_SUCCESS
+does not reflect as much about the response as for other query
+functions.
+.SH SEE ALSO
+.BR ares_process (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_set_local_dev.3 b/deps/cares/docs/ares_set_local_dev.3
new file mode 100644
index 0000000000000000000000000000000000000000..7d82133ac13438ce659b2be2482107bd78792c21
--- /dev/null
+++ b/deps/cares/docs/ares_set_local_dev.3
@@ -0,0 +1,39 @@
+.\"
+.\" Copyright 2010 by Ben Greear <greearb@candelatech.com>
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SET_LOCAL_DEV 3 "30 June 2010"
+.SH NAME
+ares_set_local_dev \- Bind to a specific network device when creating sockets.
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B void ares_set_local_dev(ares_channel \fIchannel\fP, const char* \fIlocal_dev_name\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_set_local_dev\fP function causes all future sockets
+to be bound to this device with SO_BINDTODEVICE.  This forces communications
+to go over a certain interface, which can be useful on multi-homed machines.
+This option is only supported on Linux, and root privileges are required
+for the option to work.  If SO_BINDTODEVICE is not supported or the
+setsocktop call fails (probably because of permissions), the error is
+silently ignored.
+.SH SEE ALSO
+.BR ares_set_local_ip4 (3)
+.BR ares_set_local_ip6 (3)
+.SH NOTES
+This function was added in c-ares 1.7.4
+.SH AUTHOR
+Ben Greear
diff --git a/deps/cares/docs/ares_set_local_ip4.3 b/deps/cares/docs/ares_set_local_ip4.3
new file mode 100644
index 0000000000000000000000000000000000000000..e68e80e76ae194fa375bf8c118fbbb45459b8a75
--- /dev/null
+++ b/deps/cares/docs/ares_set_local_ip4.3
@@ -0,0 +1,34 @@
+.\"
+.\" Copyright 2010 by Ben Greear <greearb@candelatech.com>
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SET_LOCAL_IP4 3 "30 June 2010"
+.SH NAME
+ares_set_local_ip4 \- Set local IPv4 address outgoing requests.
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B void ares_set_local_ip4(ares_channel \fIchannel\fP, unsigned int \fIlocal_ip\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_set_local_ip4\fP function sets the IP address for outbound
+requests.  The parameter \fIlocal_ip\fP is specified in host byte order.  This
+allows users to specify outbound interfaces when used on multi-homed systems.
+.SH SEE ALSO
+.BR ares_set_local_ip6 (3)
+.SH NOTES
+This function was added in c-ares 1.7.4
+.SH AUTHOR
+Ben Greear
diff --git a/deps/cares/docs/ares_set_local_ip6.3 b/deps/cares/docs/ares_set_local_ip6.3
new file mode 100644
index 0000000000000000000000000000000000000000..e659f5c930bb69d0d3963644a5601f9b4d262748
--- /dev/null
+++ b/deps/cares/docs/ares_set_local_ip6.3
@@ -0,0 +1,35 @@
+.\"
+.\" Copyright 2010 by Ben Greear <greearb@candelatech.com>
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SET_LOCAL_IP6 3 "30 June 2010"
+.SH NAME
+ares_set_local_ip6 \- Set local IPv6 address outgoing requests.
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B void ares_set_local_ip6(ares_channel \fIchannel\fP, const unsigned char* \fIlocal_ip6\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_set_local_ip6\fP function sets the IPv6 address for outbound
+IPv6 requests.  The parameter \fIlocal_ip6\fP is specified in network byte
+order.  This allows users to specify outbound interfaces when used on
+multi-homed systems.  The local_ip6 argument must be 16 bytes in length.
+.SH SEE ALSO
+.BR ares_set_local_ip4 (3)
+.SH NOTES
+This function was added in c-ares 1.7.4
+.SH AUTHOR
+Ben Greear
diff --git a/deps/cares/docs/ares_set_servers.3 b/deps/cares/docs/ares_set_servers.3
new file mode 100644
index 0000000000000000000000000000000000000000..65ad1e16427828559f30b28bf97d31b480658fa1
--- /dev/null
+++ b/deps/cares/docs/ares_set_servers.3
@@ -0,0 +1,95 @@
+.\"
+.\" Copyright 2010 by Ben Greear <greearb@candelatech.com>
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SET_SERVERS 3 "5 March 2010"
+.SH NAME
+ares_set_servers, ares_set_servers_ports \- Initialize an ares_channel name servers configuration
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_set_servers(ares_channel \fIchannel\fP, struct ares_addr_node *\fIservers\fP)
+.B int ares_set_servers_ports(ares_channel \fIchannel\fP, struct ares_addr_port_node *\fIservers\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_set_servers(3)\fP function initializes name servers configuration
+for the channel data identified by
+.IR channel ,
+from a
+.IR servers
+pointer to a linked list of ares_addr_node structs holding name servers
+address data.
+.PP
+The name server linked list pointer argument may be the result of a previous
+call to \fBares_get_servers(3)\fP or a linked list of \fBares_addr_node\fP structs
+set up by other means.
+.PP
+The \fBares_set_servers(3)\fP function also allows the specification of UDP and
+TCP ports to be used for communication on a per-server basis.  The provided
+linked list argument may be the result of a previous call to
+\fBares_get_servers_ports(3)\fP or a linked list of \fBares_addr_port_node\fP structs
+set up by other means.
+.PP
+This function replaces any potentially previously configured name servers
+with the ones given in the linked list. So, in order to configure a channel
+with more than one name server all the desired ones must be specified in a
+single list.
+.PP
+The function does not take ownership of the linked list argument.
+The caller is responsible for freeing the linked list when no longer needed.
+.PP
+This function is capable of handling IPv4 and IPv6 name server
+addresses simultaneously, rendering \fBares_init_options(3)\fP with
+optmask \fBARES_OPT_SERVERS\fP functionally obsolete except for
+IPv4-only name server usage.
+
+.SH RETURN VALUES
+.B ares_set_servers(3)
+may return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The name servers configuration was successfully initialized.
+.TP 15
+.B ARES_ENOMEM
+The process's available memory was exhausted.
+.TP 15
+.B ARES_ENODATA
+The channel data identified by 
+.IR channel
+was invalid.
+.TP 15
+.B ARES_ENOTINITIALIZED
+c-ares library initialization not yet performed.
+.TP 15
+.B ARES_ENOTIMP
+Changing name servers configuration while queries are outstanding is not implemented.
+.SH SEE ALSO
+.BR ares_set_servers_csv (3),
+.BR ares_get_servers (3),
+.BR ares_init_options (3),
+.BR ares_dup(3)
+.SH AVAILABILITY
+\fBares_set_servers(3)\fP was added in c-ares 1.7.1;
+\fBares_set_servers_ports(3)\fP was added in c-ares 1.11.0.
+.SH AUTHOR
+Implementation of this function and associated library internals are based
+on code, comments and feedback provided in November and December of 2008 by
+Daniel Stenberg, Gregor Jasny, Phil Blundell and Yang Tse, December 2009
+by Cedric Bail, February 2010 by Jakub Hrozek. On March 2010 Yang Tse
+shuffled all the bits and this function popped out.
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
+.br
+Copyright (C) 2008-2010 by Daniel Stenberg
diff --git a/deps/cares/docs/ares_set_servers_csv.3 b/deps/cares/docs/ares_set_servers_csv.3
new file mode 100644
index 0000000000000000000000000000000000000000..638d26987eddbc322afe1fe66268be52b72029c2
--- /dev/null
+++ b/deps/cares/docs/ares_set_servers_csv.3
@@ -0,0 +1,67 @@
+.\"
+.\" Copyright 2010 by Ben Greear <greearb@candelatech.com>
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SET_SERVERS_CSV 3 "30 June 2010"
+.SH NAME
+ares_set_servers_csv, ares_set_servers_ports_csv \- Set list of DNS servers to be used.
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_set_servers_csv(ares_channel \fIchannel\fP, const char* \fIservers\fP)
+.B int ares_set_servers_ports_csv(ares_channel \fIchannel\fP, const char* \fIservers\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_set_servers_csv\fP and \fBares_set_servers_ports_csv\fPfunctions set
+the list of DNS servers that ARES will query.  The format of the servers option is:
+
+host[:port][,host[:port]]...
+
+For example:
+
+192.168.1.100,192.168.1.101,3.4.5.6
+.PP
+The \fBares_set_servers_csv\fP function will ignore any port values specified in
+the input string, whereare the \fBares_set_servers_ports_csv\fP function will
+apply any specified port values as the UDP and TCP port to be used for that
+particular nameserver.
+
+.SH RETURN VALUES
+.B ares_set_servers_csv(3)
+This function may return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The name servers configuration was successfully initialized.
+.TP 15
+.B ARES_ENOMEM
+The process's available memory was exhausted.
+.TP 15
+.B ARES_ENODATA
+The channel data identified by
+.IR channel
+was invalid.
+.TP 15
+.B ARES_ENOTINITIALIZED
+c-ares library initialization not yet performed.
+.TP 15
+.B ARES_ENOTIMP
+Changing name servers configuration while queries are outstanding is not implemented.
+.SH SEE ALSO
+.BR ares_set_servers (3)
+.SH AVAILABILITY
+\fBares_set_servers_csv\fP was added in c-ares 1.7.2;
+\fBares_set_servers_ports_csv\fP was added in c-ares 1.11.0.
+.SH AUTHOR
+Ben Greear
diff --git a/deps/cares/docs/ares_set_servers_ports.3 b/deps/cares/docs/ares_set_servers_ports.3
new file mode 100644
index 0000000000000000000000000000000000000000..a3be18938e6983ed197559842e79d34889ca9d6f
--- /dev/null
+++ b/deps/cares/docs/ares_set_servers_ports.3
@@ -0,0 +1 @@
+.so man3/ares_set_servers.3
diff --git a/deps/cares/docs/ares_set_servers_ports_csv.3 b/deps/cares/docs/ares_set_servers_ports_csv.3
new file mode 100644
index 0000000000000000000000000000000000000000..30535c69f109bc1d46e3a5b437b50520a6f31a6d
--- /dev/null
+++ b/deps/cares/docs/ares_set_servers_ports_csv.3
@@ -0,0 +1 @@
+.so man3/ares_set_servers_csv.3
diff --git a/deps/cares/docs/ares_set_socket_callback.3 b/deps/cares/docs/ares_set_socket_callback.3
new file mode 100644
index 0000000000000000000000000000000000000000..14a5ad2dcb5ea2111cc677362f930e17bf2af25f
--- /dev/null
+++ b/deps/cares/docs/ares_set_socket_callback.3
@@ -0,0 +1,32 @@
+.\"
+.TH ARES_SET_SOCKET_CALLBACK 3 "20 Nov 2009"
+.SH NAME
+ares_set_socket_callback \- Set a socket creation callback
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef int (*ares_sock_create_callback)(ares_socket_t \fIsocket_fd\fP,
+                                         int \fItype\fP,
+                                         void *\fIuserdata\fP)
+.PP
+.B void ares_set_socket_callback(ares_channel \fIchannel\fP,
+                             ares_sock_create_callback \fIcallback\fP,
+                             void *\fIuserdata\fP)
+.PP
+.B cc file.c -lcares
+.fi
+.SH DESCRIPTION
+.PP
+This function sets a \fIcallback\fP in the given ares channel handle. This
+callback function will be invoked after the socket has been created, and
+connected to the remote server. The callback must return ARES_SUCCESS if
+things are fine, or return -1 to signal an error. A returned error will
+abort the ares operation.
+.SH SEE ALSO
+.BR ares_init_options (3), ares_set_socket_configure_callback (3)
+.SH AVAILABILITY
+ares_set_socket_callback(3) was added in c-ares 1.6.0
+.SH AUTHOR
+Gregor Jasny
+
diff --git a/deps/cares/docs/ares_set_socket_configure_callback.3 b/deps/cares/docs/ares_set_socket_configure_callback.3
new file mode 100644
index 0000000000000000000000000000000000000000..d3b2f93017993685f6f89b89051f7c2ac861d8ba
--- /dev/null
+++ b/deps/cares/docs/ares_set_socket_configure_callback.3
@@ -0,0 +1,33 @@
+.\"
+.TH ARES_SET_SOCKET_CONFIGURE_CALLBACK 3 "6 Feb 2016"
+.SH NAME
+ares_set_socket_configure_callback \- Set a socket configuration callback
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B typedef int (*ares_sock_config_callback)(ares_socket_t \fIsocket_fd\fP,
+                                         int \fItype\fP,
+                                         void *\fIuserdata\fP)
+.PP
+.B void ares_set_socket_configure_callback(ares_channel \fIchannel\fP,
+                             ares_sock_config_callback \fIcallback\fP,
+                             void *\fIuserdata\fP)
+.PP
+.B cc file.c -lcares
+.fi
+.SH DESCRIPTION
+.PP
+This function sets a \fIcallback\fP in the given ares channel handle. This
+callback function will be invoked after the socket has been created, but
+before it has been connected to the remote server, which is an ideal time
+to configure various socket options.  The callback must return ARES_SUCCESS
+if things are fine, or return -1 to signal an error. A returned error will
+abort the ares operation.
+.SH SEE ALSO
+.BR ares_init_options (3), ares_set_socket_callback (3)
+.SH AVAILABILITY
+ares_set_socket_configure_callback(3) was added in c-ares 1.11.0
+.SH AUTHOR
+Andrew Ayer
+
diff --git a/deps/cares/docs/ares_set_socket_functions.3 b/deps/cares/docs/ares_set_socket_functions.3
new file mode 100644
index 0000000000000000000000000000000000000000..1cb0b8553bda74cd173dcdc800c611617f755ccc
--- /dev/null
+++ b/deps/cares/docs/ares_set_socket_functions.3
@@ -0,0 +1,99 @@
+.\"
+.TH ARES_SET_SOCKET_FUNCTIONS 3 "13 Dec 2016"
+.SH NAME
+ares_set_socket_functions \- Set socket io callbacks
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B struct ares_socket_functions {
+	ares_socket_t(*\fIasocket\fP)(int, int, int, void *);
+	int(*\fIaclose\fP)(ares_socket_t, void *);
+	int(*\fIaconnect\fP)(ares_socket_t, const struct sockaddr *, ares_socklen_t, void *);
+	ares_ssize_t(*\fIarecvfrom\fP)(ares_socket_t, void *, size_t, int, struct sockaddr *, ares_socklen_t *, void *);
+	ares_ssize_t(*\fIasendv\fP)(ares_socket_t, const struct iovec *, int, void *);
+   };
+
+.PP
+.B void ares_set_socket_functions(ares_channel \fIchannel\fP,
+				  const struct ares_socket_functions * \fIfunctions\fP,
+				  void *\fIuser_data\fP);
+
+.fi
+.SH DESCRIPTION
+.PP
+This function sets a set of callback \fIfunctions\fP in the given ares channel handle.
+These callback functions will be invoked to create/destroy socket objects and perform
+io, instead of the normal system calls. A client application can override normal network
+operation fully through this functionality, and provide its own transport layer.
+.PP
+All callback functions are expected to operate like their system equivalents, and to
+set
+.BR errno(3)
+to an appropriate error code on failure. C-ares also expects all io functions to behave
+asynchronously, i.e. as if the socket object has been set to non-blocking mode. Thus
+read/write calls (for TCP connections) are expected to often generate
+.BR EAGAIN
+or
+.BR EWOULDBLOCK.
+
+.PP
+The \fIuser_data\fP value is provided to each callback function invocation to serve as
+context.
+.PP
+The
+.B ares_socket_functions
+must provide the following callbacks:
+.TP 18
+.B \fIasocket\fP
+.B ares_socket_t(*)(int \fIdomain\fP, int \fItype\fP, int \fIprotocol\fP, void * \fIuser_data\fP)
+.br
+Creates an endpoint for communication and returns a descriptor. \fIdomain\fP, \fItype\fP, and \fIprotocol\fP
+each correspond to the parameters of
+.BR socket(2).
+Returns ahandle to the newly created socket, or -1 on error.
+.TP 18
+.B \fIaclose\fP
+.B int(*)(ares_socket_t \fIfd\fP, void * \fIuser_data\fP)
+.br
+Closes the socket endpoint indicated by \fIfd\fP. See
+.BR close(2)
+.TP 18
+.B \fIaconnect\fP
+.B int(*)(ares_socket_t \fIfd\fP, const struct sockaddr * \fIaddr\fP, ares_socklen_t \fIaddr_len\fP, void * \fIuser_data\fP)
+.br
+Initiate a connection to the address indicated by \fIaddr\fP on a socket. See
+.BR connect(2)
+
+.TP 18
+.B \fIarecvfrom\fP
+.B ares_ssize_t(*)(ares_socket_t \fIfd\fP, void * \fIbuffer\fP, size_t \fIbuf_size\fP, int \fIflags\fP, struct sockaddr * \fIaddr\fP, ares_socklen_t * \fIaddr_len\fP, void * \fIuser_data\fP)
+.br
+Receives data from remote socket endpoint, if available. If the \fIaddr\fP parameter is not NULL and the connection protocol provides the source address, the callback should fill this in. See
+.BR recvfrom(2)
+
+.TP 18
+.B \fIasendv\fP
+.B ares_ssize_t(*)(ares_socket_t \fIfd\fP, const struct iovec * \fIdata\fP, int \fIlen\fP, void * \fIuser_data\fP)
+.br
+Send data, as provided by the iovec array \fIdata\fP, to the socket endpoint. See
+.BR writev(2),
+
+.PP
+The
+.B ares_socket_functions
+struct provided is not copied but directly referenced,
+and must thus remain valid through out the channels and any created socket's lifetime.
+.SH AVAILABILITY
+Added in c-ares 1.13.0
+.SH SEE ALSO
+.BR ares_init_options (3),
+.BR socket(2),
+.BR close(2),
+.BR connect(2),
+.BR recv(2),
+.BR recvfrom(2),
+.BR send(2),
+.BR writev(2)
+.SH AUTHOR
+Carl Wilund
diff --git a/deps/cares/docs/ares_set_sortlist.3 b/deps/cares/docs/ares_set_sortlist.3
new file mode 100644
index 0000000000000000000000000000000000000000..24a97906ad9a271baf0bdaac2bf6710b02c34875
--- /dev/null
+++ b/deps/cares/docs/ares_set_sortlist.3
@@ -0,0 +1,58 @@
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_SET_SORTLIST 3 "23 November 2015"
+.SH NAME
+ares_set_sortlist \- Initialize an ares_channel sortlist configuration
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B int ares_set_sortlist(ares_channel \fIchannel\fP, const char *\fIsortstr\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_set_sortlist(3)\fP function initializes an address sortlist configuration
+for the channel data identified by
+.IR channel ,
+so that addresses returned by \fBares_gethostbyname(3)\fP are sorted according to the
+sortlist.  The provided
+.IR sortstr
+string that holds a space separated list of IP-address-netmask pairs.  The
+netmask is optional but follows the address after a slash if present.  For example,
+"130.155.160.0/255.255.240.0 130.155.0.0".
+
+This function replaces any potentially previously configured address sortlist
+with the ones given in the configuration string.
+
+.SH RETURN VALUES
+.B ares_set_sortlist(3)
+may return any of the following values:
+.TP 15
+.B ARES_SUCCESS
+The sortlist configuration was successfully initialized.
+.TP 15
+.B ARES_ENOMEM
+The process's available memory was exhausted.
+.TP 15
+.B ARES_ENODATA
+The channel data identified by
+.IR channel
+was invalid.
+.TP 15
+.B ARES_ENOTINITIALIZED
+c-ares library initialization not yet performed.
+.SH SEE ALSO
+.BR ares_init_options (3),
+.BR ares_dup(3)
+.SH AVAILABILITY
+ares_set_sortlist(3) was added in c-ares 1.11.0
diff --git a/deps/cares/docs/ares_strerror.3 b/deps/cares/docs/ares_strerror.3
new file mode 100644
index 0000000000000000000000000000000000000000..4b50d5bbb5850ff2b29187cf51beca313297352b
--- /dev/null
+++ b/deps/cares/docs/ares_strerror.3
@@ -0,0 +1,37 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_STRERROR 3 "25 July 1998"
+.SH NAME
+ares_strerror \- Get the description of an ares library error code
+.SH SYNOPSIS
+.nf
+.B #include <ares.h>
+.PP
+.B const char *ares_strerror(int \fIcode\fP)
+.fi
+.SH DESCRIPTION
+The
+.B ares_strerror
+function gets the description of the ares library error code
+.IR code ,
+returning the result as a NUL-terminated C string.
+.SH NOTES
+This function is not compatible with ares, it takes a different set of
+arguments.
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_timeout.3 b/deps/cares/docs/ares_timeout.3
new file mode 100644
index 0000000000000000000000000000000000000000..c57685dcf7c4c366218316347a9a8796dc535d39
--- /dev/null
+++ b/deps/cares/docs/ares_timeout.3
@@ -0,0 +1,46 @@
+.\"
+.\" Copyright 1998 by the Massachusetts Institute of Technology.
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_TIMEOUT 3 "25 July 1998"
+.SH NAME
+ares_timeout \- return maximum time to wait
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+struct timeval *ares_timeout(ares_channel \fIchannel\fP,
+                             struct timeval *\fImaxtv\fP,
+                             struct timeval *\fItv\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_timeout(3)\fP function determines the maximum time for which the
+caller should wait before invoking \fIares_process(3)\fP to process timeouts.
+The parameter \fImaxtv\fP specifies a existing maximum timeout, or \fBNULL\fP
+if the caller does not wish to apply a maximum timeout.  The parameter
+\fItv\fP must point to a writable buffer of type \fBstruct timeval\fP It is
+valid for \fImaxtv\fP and \fItv\fP to have the same value.
+
+If no queries have timeouts pending sooner than the given maximum timeout,
+\fBares_timeout(3)\fP returns the value of \fImaxtv\fP; otherwise
+\fBares_timeout(3)\fP stores the appropriate timeout value into the buffer
+pointed to by \fItv\fP and returns the value of \fItv\fP.
+.SH SEE ALSO
+.BR ares_fds (3),
+.BR ares_process (3),
+.BR ares_process_fd (3)
+.SH AUTHOR
+Greg Hudson, MIT Information Systems
+.br
+Copyright 1998 by the Massachusetts Institute of Technology.
diff --git a/deps/cares/docs/ares_version.3 b/deps/cares/docs/ares_version.3
new file mode 100644
index 0000000000000000000000000000000000000000..9ba7831f54db379ff59612a10532e7a1ccc75c7e
--- /dev/null
+++ b/deps/cares/docs/ares_version.3
@@ -0,0 +1,35 @@
+.\"
+.\" Copyright 2004 by Daniel Stenberg
+.\"
+.\" Permission to use, copy, modify, and distribute this
+.\" software and its documentation for any purpose and without
+.\" fee is hereby granted, provided that the above copyright
+.\" notice appear in all copies and that both that copyright
+.\" notice and this permission notice appear in supporting
+.\" documentation, and that the name of M.I.T. not be used in
+.\" advertising or publicity pertaining to distribution of the
+.\" software without specific, written prior permission.
+.\" M.I.T. makes no representations about the suitability of
+.\" this software for any purpose.  It is provided "as is"
+.\" without express or implied warranty.
+.\"
+.TH ARES_VERSION 3 "29 January 2004"
+.SH NAME
+ares_version \- Get the version number of the library
+.SH SYNOPSIS
+.nf
+#include <ares.h>
+
+const char *ares_version(int *\fIversion\fP)
+.fi
+.SH DESCRIPTION
+The \fBares_version(3)\fP function gets the library version as a string and
+optionally as an integer stored in the \fIversion\fP argument. If you pass a
+NULL, no integer is attempted to be returned.
+
+The integer is built up as 24bit number, with 8 separate bits used for major
+number, minor number and patch number. This makes a version string such as
+1.2.3 will be returned as the hexadecimal number 0x010203 (decimal 66051).
+.SH "SEE ALSO"
+.BR ares_init (3),
+.BR ares_library_init (3)
diff --git a/deps/cares/get_ver.awk b/deps/cares/get_ver.awk
new file mode 100644
index 0000000000000000000000000000000000000000..5e3db6db99a96b1f4b526b602bfec995e302d673
--- /dev/null
+++ b/deps/cares/get_ver.awk
@@ -0,0 +1,27 @@
+# ***************************************************************************
+# *  Project: c-ares
+# *
+# ***************************************************************************
+# awk script which fetches c-ares version number and string from input
+# file and writes them to STDOUT. Here you can get an awk version for Win32:
+# http://www.gknw.net/development/prgtools/awk-20100523.zip
+#
+BEGIN {
+  while ((getline < ARGV[1]) > 0) {
+    sub("\r", "") # make MSYS gawk work with CRLF header input.
+    if (match ($0, /^#define ARES_COPYRIGHT "[^"]+"$/))
+      copyright_string = substr($0, 25, length($0)-25)
+    else if (match ($0, /^#define ARES_VERSION_STR "[^"]+"$/))
+      version_string = substr($3, 2, length($3)-2)
+    else if (match ($0, /^#define ARES_VERSION_MAJOR [0-9]+$/))
+      version_major = $3
+    else if (match ($0, /^#define ARES_VERSION_MINOR [0-9]+$/))
+      version_minor = $3
+    else if (match ($0, /^#define ARES_VERSION_PATCH [0-9]+$/))
+      version_patch = $3
+  }
+  print "LIBCARES_VERSION = " version_major "," version_minor "," version_patch
+  print "LIBCARES_VERSION_STR = " version_string
+  print "LIBCARES_COPYRIGHT_STR = " copyright_string
+}
+
diff --git a/deps/cares/include/CMakeLists.txt b/deps/cares/include/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3321956dd74f58ab2d139f4a9b075c59366de0d2
--- /dev/null
+++ b/deps/cares/include/CMakeLists.txt
@@ -0,0 +1,8 @@
+# Write ares_build.h configuration file.  This is an installed file.
+CONFIGURE_FILE (ares_build.h.cmake ${PROJECT_BINARY_DIR}/ares_build.h)
+
+# Headers installation target
+IF (CARES_INSTALL)
+	SET (CARES_HEADERS ares.h ares_version.h "${PROJECT_BINARY_DIR}/ares_build.h" ares_rules.h ares_dns.h ares_nameser.h)
+	INSTALL (FILES ${CARES_HEADERS} COMPONENT Devel DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+ENDIF ()
diff --git a/deps/cares/include/Makefile.am b/deps/cares/include/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..d208bece64cd443d36f56023382c00936d8a54e4
--- /dev/null
+++ b/deps/cares/include/Makefile.am
@@ -0,0 +1,7 @@
+AUTOMAKE_OPTIONS = foreign nostdinc 1.9.6
+ACLOCAL_AMFLAGS = -I m4 --install
+
+# what headers to install on 'make install':
+include_HEADERS = ares.h ares_version.h ares_build.h ares_rules.h ares_dns.h ares_nameser.h
+
+EXTRA_DIST = ares_build.h.cmake ares_build.h.in ares_build.h.dist CMakeLists.txt
diff --git a/deps/cares/include/Makefile.in b/deps/cares/include/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..fad83f2c905901c123e976ad54a00f62656b0e26
--- /dev/null
+++ b/deps/cares/include/Makefile.in
@@ -0,0 +1,623 @@
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2021 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = include
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_ac_append_to_file.m4 \
+	$(top_srcdir)/m4/ax_ac_print_to_file.m4 \
+	$(top_srcdir)/m4/ax_add_am_macro_static.m4 \
+	$(top_srcdir)/m4/ax_am_macros_static.m4 \
+	$(top_srcdir)/m4/ax_check_gnu_make.m4 \
+	$(top_srcdir)/m4/ax_code_coverage.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx_11.m4 \
+	$(top_srcdir)/m4/ax_file_escapes.m4 \
+	$(top_srcdir)/m4/ax_require_defined.m4 \
+	$(top_srcdir)/m4/cares-compilers.m4 \
+	$(top_srcdir)/m4/cares-confopts.m4 \
+	$(top_srcdir)/m4/cares-functions.m4 \
+	$(top_srcdir)/m4/cares-reentrant.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/xc-am-iface.m4 \
+	$(top_srcdir)/m4/xc-cc-check.m4 \
+	$(top_srcdir)/m4/xc-lt-iface.m4 \
+	$(top_srcdir)/m4/xc-translit.m4 \
+	$(top_srcdir)/m4/xc-val-flgs.m4 \
+	$(top_srcdir)/m4/zz40-xc-ovr.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(include_HEADERS) \
+	$(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/src/lib/ares_config.h ares_build.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+SOURCES =
+DIST_SOURCES =
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(includedir)"
+HEADERS = $(include_HEADERS)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) \
+	ares_build.h.in
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/ares_build.h.in
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BUILD_SUBDIRS = @BUILD_SUBDIRS@
+CARES_CFLAG_EXTRAS = @CARES_CFLAG_EXTRAS@
+CARES_PRIVATE_LIBS = @CARES_PRIVATE_LIBS@
+CARES_RANDOM_FILE = @CARES_RANDOM_FILE@
+CARES_VERSION_INFO = @CARES_VERSION_INFO@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CFLAG_CARES_SYMBOL_HIDING = @CFLAG_CARES_SYMBOL_HIDING@
+CODE_COVERAGE_CFLAGS = @CODE_COVERAGE_CFLAGS@
+CODE_COVERAGE_CPPFLAGS = @CODE_COVERAGE_CPPFLAGS@
+CODE_COVERAGE_CXXFLAGS = @CODE_COVERAGE_CXXFLAGS@
+CODE_COVERAGE_ENABLED = @CODE_COVERAGE_ENABLED@
+CODE_COVERAGE_LIBS = @CODE_COVERAGE_LIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPPFLAG_CARES_STATICLIB = @CPPFLAG_CARES_STATICLIB@
+CSCOPE = @CSCOPE@
+CTAGS = @CTAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ETAGS = @ETAGS@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GCOV = @GCOV@
+GENHTML = @GENHTML@
+GREP = @GREP@
+HAVE_CXX11 = @HAVE_CXX11@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LCOV = @LCOV@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+ifGNUmake = @ifGNUmake@
+ifnGNUmake = @ifnGNUmake@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AUTOMAKE_OPTIONS = foreign nostdinc 1.9.6
+ACLOCAL_AMFLAGS = -I m4 --install
+
+# what headers to install on 'make install':
+include_HEADERS = ares.h ares_version.h ares_build.h ares_rules.h ares_dns.h ares_nameser.h
+EXTRA_DIST = ares_build.h.cmake ares_build.h.in ares_build.h.dist CMakeLists.txt
+all: ares_build.h
+	$(MAKE) $(AM_MAKEFLAGS) all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign include/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign include/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+ares_build.h: stamp-h2
+	@test -f $@ || rm -f stamp-h2
+	@test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h2
+
+stamp-h2: $(srcdir)/ares_build.h.in $(top_builddir)/config.status
+	@rm -f stamp-h2
+	cd $(top_builddir) && $(SHELL) ./config.status include/ares_build.h
+
+distclean-hdr:
+	-rm -f ares_build.h stamp-h2
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-includeHEADERS: $(include_HEADERS)
+	@$(NORMAL_INSTALL)
+	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includedir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \
+	done
+
+uninstall-includeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir)
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(HEADERS) ares_build.h
+installdirs:
+	for dir in "$(DESTDIR)$(includedir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-hdr distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-includeHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-includeHEADERS
+
+.MAKE: all install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+	clean-libtool cscopelist-am ctags ctags-am distclean \
+	distclean-generic distclean-hdr distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-includeHEADERS install-info \
+	install-info-am install-man install-pdf install-pdf-am \
+	install-ps install-ps-am install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
+	uninstall-am uninstall-includeHEADERS
+
+.PRECIOUS: Makefile
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/deps/cares/include/ares.h b/deps/cares/include/ares.h
index b341d60934d34c9c688e4988a170851ad1f237aa..cf8a8553fe099eef3b2dddf2d5682ac3faf61369 100644
--- a/deps/cares/include/ares.h
+++ b/deps/cares/include/ares.h
@@ -39,7 +39,7 @@
 #if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \
     defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \
     defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \
-    defined(__QNXNTO__) || defined(__MVS__)
+    defined(__QNXNTO__) || defined(__MVS__) || defined(__HAIKU__)
 #include <sys/select.h>
 #endif
 #if (defined(NETWARE) && !defined(__NOVELL_LIBC__))
@@ -588,6 +588,14 @@ struct ares_soa_reply {
   unsigned int minttl;
 };
 
+struct ares_uri_reply {
+  struct ares_uri_reply  *next;
+  unsigned short          priority;
+  unsigned short          weight;
+  char                   *uri;
+  int                     ttl;
+};
+
 /*
  * Similar to addrinfo, but with extra ttl and missing canonname.
  */
@@ -617,6 +625,7 @@ struct ares_addrinfo_cname {
 struct ares_addrinfo {
   struct ares_addrinfo_cname *cnames;
   struct ares_addrinfo_node  *nodes;
+  char                       *name;
 };
 
 struct ares_addrinfo_hints {
@@ -685,6 +694,10 @@ CARES_EXTERN int ares_parse_soa_reply(const unsigned char* abuf,
 				      int alen,
 				      struct ares_soa_reply** soa_out);
 
+CARES_EXTERN int ares_parse_uri_reply(const unsigned char* abuf,
+                                      int alen,
+                                      struct ares_uri_reply** uri_out);
+
 CARES_EXTERN void ares_free_string(void *str);
 
 CARES_EXTERN void ares_free_hostent(struct hostent *host);
diff --git a/deps/cares/include/ares_build.h b/deps/cares/include/ares_build.h
index 5e3ba9f0d8cb0cc0516f4f55a858203b4f0f4c2f..7f7d2e02daaba9c8e91b68a8efaf86921e4363c3 100644
--- a/deps/cares/include/ares_build.h
+++ b/deps/cares/include/ares_build.h
@@ -2,7 +2,7 @@
 #define __CARES_BUILD_H
 
 
-/* Copyright (C) 2009 - 2013 by Daniel Stenberg et al
+/* Copyright (C) 2009 - 2021 by Daniel Stenberg et al
  *
  * Permission to use, copy, modify, and distribute this software and its
  * documentation for any purpose and without fee is hereby granted, provided
@@ -42,7 +42,7 @@
  *
  * If you think that something actually needs to be changed, adjusted
  * or fixed in this file, then, report it on the c-ares development
- * mailing list: http://cool.haxx.se/mailman/listinfo/c-ares/
+ * mailing list: http://lists.haxx.se/listinfo/c-ares/
  *
  * Try to keep one section per platform, compiler and architecture,
  * otherwise, if an existing section is reused for a different one and
diff --git a/deps/cares/include/ares_build.h.cmake b/deps/cares/include/ares_build.h.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e847f17ea79ea70159d500d666222586d5c1d2ca
--- /dev/null
+++ b/deps/cares/include/ares_build.h.cmake
@@ -0,0 +1,43 @@
+#ifndef __CARES_BUILD_H
+#define __CARES_BUILD_H
+
+#define CARES_TYPEOF_ARES_SOCKLEN_T @CARES_TYPEOF_ARES_SOCKLEN_T@
+#define CARES_TYPEOF_ARES_SSIZE_T @CARES_TYPEOF_ARES_SSIZE_T@
+
+/* Prefix names with CARES_ to make sure they don't conflict with other config.h
+ * files.  We need to include some dependent headers that may be system specific
+ * for C-Ares */
+#cmakedefine CARES_HAVE_SYS_TYPES_H
+#cmakedefine CARES_HAVE_SYS_SOCKET_H
+#cmakedefine CARES_HAVE_WINDOWS_H
+#cmakedefine CARES_HAVE_WS2TCPIP_H
+#cmakedefine CARES_HAVE_WINSOCK2_H
+#cmakedefine CARES_HAVE_WINDOWS_H
+#cmakedefine CARES_HAVE_ARPA_NAMESER_H
+#cmakedefine CARES_HAVE_ARPA_NAMESER_COMPAT_H
+
+#ifdef CARES_HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+#ifdef CARES_HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+#ifdef CARES_HAVE_WINSOCK2_H
+#  include <winsock2.h>
+#endif
+
+#ifdef CARES_HAVE_WS2TCPIP_H
+#  include <ws2tcpip.h>
+#endif
+
+#ifdef CARES_HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+
+typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;
+typedef CARES_TYPEOF_ARES_SSIZE_T ares_ssize_t;
+
+#endif /* __CARES_BUILD_H */
diff --git a/deps/cares/include/ares_build.h.in b/deps/cares/include/ares_build.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..8abc874c809026b7794bcc11b8049823a22ddcd2
--- /dev/null
+++ b/deps/cares/include/ares_build.h.in
@@ -0,0 +1,103 @@
+#ifndef __CARES_BUILD_H
+#define __CARES_BUILD_H
+
+
+/* Copyright (C) 2009 - 2021 by Daniel Stenberg et al
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * c-ares library user nor by the c-ares library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the c-ares development
+ * mailing list: http://lists.haxx.se/listinfo/c-ares/
+ *
+ * This header file shall only export symbols which are 'cares' or 'CARES'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file ares_build.h.in or ares_build.h,
+ * this is due to the following reason:
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed ares_build.h file with one that is suitable
+ * and specific to the library being configured and built, which is generated
+ * from the ares_build.h.in template file.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CARES_TYPEOF_ARES_SOCKLEN_T
+#  error "CARES_TYPEOF_ARES_SOCKLEN_T shall not be defined except in ares_build.h"
+   Error Compilation_aborted_CARES_TYPEOF_ARES_SOCKLEN_T_already_defined
+#endif
+
+#undef CARES_HAVE_ARPA_NAMESER_H
+#undef CARES_HAVE_ARPA_NAMESER_COMPAT_H
+
+/* ================================================================ */
+/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
+/* ================================================================ */
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file ws2tcpip.h must be included by the external interface. */
+#undef CARES_PULL_WS2TCPIP_H
+#ifdef CARES_PULL_WS2TCPIP_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system   */
+/* header file sys/types.h must be included by the external interface. */
+#undef CARES_PULL_SYS_TYPES_H
+#ifdef CARES_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system    */
+/* header file sys/socket.h must be included by the external interface. */
+#undef CARES_PULL_SYS_SOCKET_H
+#ifdef CARES_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Integral data type used for ares_socklen_t. */
+#undef CARES_TYPEOF_ARES_SOCKLEN_T
+
+/* Data type definition of ares_socklen_t. */
+typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;
+
+/* Integral data type used for ares_ssize_t. */
+#undef CARES_TYPEOF_ARES_SSIZE_T
+
+/* Data type definition of ares_ssize_t. */
+typedef CARES_TYPEOF_ARES_SSIZE_T ares_ssize_t;
+
+#endif /* __CARES_BUILD_H */
diff --git a/deps/cares/src/lib/ares_nameser.h b/deps/cares/include/ares_nameser.h
similarity index 97%
rename from deps/cares/src/lib/ares_nameser.h
rename to deps/cares/include/ares_nameser.h
index 5270e5a3a6a079c4e40edbd169e1044574839efe..18a9e5ac0e25fa8034252e2bd7042cb531652820 100644
--- a/deps/cares/src/lib/ares_nameser.h
+++ b/deps/cares/include/ares_nameser.h
@@ -2,10 +2,12 @@
 #ifndef ARES_NAMESER_H
 #define ARES_NAMESER_H
 
-#ifdef HAVE_ARPA_NAMESER_H
+#include "ares_build.h"
+
+#ifdef CARES_HAVE_ARPA_NAMESER_H
 #  include <arpa/nameser.h>
 #endif
-#ifdef HAVE_ARPA_NAMESER_COMPAT_H
+#ifdef CARES_HAVE_ARPA_NAMESER_COMPAT_H
 #  include <arpa/nameser_compat.h>
 #endif
 
@@ -68,7 +70,7 @@
  * provide them
  * ============================================================================
  */
-#ifndef HAVE_ARPA_NAMESER_H
+#ifndef CARES_HAVE_ARPA_NAMESER_H
 
 typedef enum __ns_class {
     ns_c_invalid = 0,       /* Cookie. */
@@ -138,7 +140,7 @@ typedef enum __ns_type {
     ns_t_mailb = 253,       /* Transfer mailbox records. */
     ns_t_maila = 254,       /* Transfer mail agent records. */
     ns_t_any = 255,         /* Wildcard match. */
-    ns_t_zxfr = 256,        /* BIND-specific, nonstandard. */
+    ns_t_uri = 256,         /* Uniform Resource Identifier (RFC7553) */
     ns_t_caa = 257,         /* Certification Authority Authorization. */
     ns_t_max = 65536
 } ns_type;
@@ -173,7 +175,7 @@ typedef enum __ns_rcode {
     ns_r_badtime = 18
 } ns_rcode;
 
-#endif /* HAVE_ARPA_NAMESER_H */
+#endif /* CARES_HAVE_ARPA_NAMESER_H */
 
 
 /* ============================================================================
@@ -468,8 +470,8 @@ typedef enum __ns_rcode {
 #ifndef T_ANY
 #  define T_ANY           255 /* ns_t_any */
 #endif
-#ifndef T_ZXFR
-#  define T_ZXFR          256 /* ns_t_zxfr */
+#ifndef T_URI
+#  define T_URI          256 /* ns_t_uri */
 #endif
 #ifndef T_CAA
 #  define T_CAA           257 /* ns_t_caa */
diff --git a/deps/cares/include/ares_rules.h b/deps/cares/include/ares_rules.h
index cac23cf2e32db3430347102e8bd9cab35da53b8e..1706ab7d00444d3e6666a0d8c44da50104da8af5 100644
--- a/deps/cares/include/ares_rules.h
+++ b/deps/cares/include/ares_rules.h
@@ -2,7 +2,7 @@
 #define __CARES_RULES_H
 
 
-/* Copyright (C) 2009 by Daniel Stenberg et al
+/* Copyright (C) 2009 - 2021 by Daniel Stenberg et al
  *
  * Permission to use, copy, modify, and distribute this software and its
  * documentation for any purpose and without fee is hereby granted, provided
@@ -40,7 +40,7 @@
  * library is properly built and used.
  *
  * You can find further help on the c-ares development mailing list:
- * http://cool.haxx.se/mailman/listinfo/c-ares/
+ * http://lists.haxx.se/listinfo/c-ares/
  *
  * NOTE 2
  * ------
diff --git a/deps/cares/include/ares_version.h b/deps/cares/include/ares_version.h
index de1ac8424cca16607edc7df3fad60daf53b5051c..22c6f62fd72c627c2be98bf70f5b73b75ed8b9b3 100644
--- a/deps/cares/include/ares_version.h
+++ b/deps/cares/include/ares_version.h
@@ -3,15 +3,15 @@
 #define ARES__VERSION_H
 
 /* This is the global package copyright */
-#define ARES_COPYRIGHT "2004 - 2020 Daniel Stenberg, <daniel@haxx.se>."
+#define ARES_COPYRIGHT "2004 - 2021 Daniel Stenberg, <daniel@haxx.se>."
 
 #define ARES_VERSION_MAJOR 1
-#define ARES_VERSION_MINOR 17
-#define ARES_VERSION_PATCH 2
+#define ARES_VERSION_MINOR 18
+#define ARES_VERSION_PATCH 1
 #define ARES_VERSION ((ARES_VERSION_MAJOR<<16)|\
                        (ARES_VERSION_MINOR<<8)|\
                        (ARES_VERSION_PATCH))
-#define ARES_VERSION_STR "1.17.2"
+#define ARES_VERSION_STR "1.18.1"
 
 #if (ARES_VERSION >= 0x010700)
 #  define CARES_HAVE_ARES_LIBRARY_INIT 1
diff --git a/deps/cares/install-sh b/deps/cares/install-sh
new file mode 100755
index 0000000000000000000000000000000000000000..ec298b53740270ce82b326c4c2deaa5dcdec4596
--- /dev/null
+++ b/deps/cares/install-sh
@@ -0,0 +1,541 @@
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2020-11-14.01; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# 'make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+tab='	'
+nl='
+'
+IFS=" $tab$nl"
+
+# Set DOITPROG to "echo" to test this script.
+
+doit=${DOITPROG-}
+doit_exec=${doit:-exec}
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+# Create dirs (including intermediate dirs) using mode 755.
+# This is like GNU 'install' as of coreutils 8.32 (2020).
+mkdir_umask=22
+
+backupsuffix=
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+is_target_a_directory=possibly
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+   or: $0 [OPTION]... SRCFILES... DIRECTORY
+   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+   or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+     --help     display this help and exit.
+     --version  display version info and exit.
+
+  -c            (ignored)
+  -C            install only if different (preserve data modification time)
+  -d            create directories instead of installing files.
+  -g GROUP      $chgrpprog installed files to GROUP.
+  -m MODE       $chmodprog installed files to MODE.
+  -o USER       $chownprog installed files to USER.
+  -p            pass -p to $cpprog.
+  -s            $stripprog installed files.
+  -S SUFFIX     attempt to back up existing files, with suffix SUFFIX.
+  -t DIRECTORY  install into DIRECTORY.
+  -T            report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+  RMPROG STRIPPROG
+
+By default, rm is invoked with -f; when overridden with RMPROG,
+it's up to you to specify -f if you want it.
+
+If -S is not specified, no backups are attempted.
+
+Email bug reports to bug-automake@gnu.org.
+Automake home page: https://www.gnu.org/software/automake/
+"
+
+while test $# -ne 0; do
+  case $1 in
+    -c) ;;
+
+    -C) copy_on_change=true;;
+
+    -d) dir_arg=true;;
+
+    -g) chgrpcmd="$chgrpprog $2"
+        shift;;
+
+    --help) echo "$usage"; exit $?;;
+
+    -m) mode=$2
+        case $mode in
+          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
+            echo "$0: invalid mode: $mode" >&2
+            exit 1;;
+        esac
+        shift;;
+
+    -o) chowncmd="$chownprog $2"
+        shift;;
+
+    -p) cpprog="$cpprog -p";;
+
+    -s) stripcmd=$stripprog;;
+
+    -S) backupsuffix="$2"
+        shift;;
+
+    -t)
+        is_target_a_directory=always
+        dst_arg=$2
+        # Protect names problematic for 'test' and other utilities.
+        case $dst_arg in
+          -* | [=\(\)!]) dst_arg=./$dst_arg;;
+        esac
+        shift;;
+
+    -T) is_target_a_directory=never;;
+
+    --version) echo "$0 $scriptversion"; exit $?;;
+
+    --) shift
+        break;;
+
+    -*) echo "$0: invalid option: $1" >&2
+        exit 1;;
+
+    *)  break;;
+  esac
+  shift
+done
+
+# We allow the use of options -d and -T together, by making -d
+# take the precedence; this is for compatibility with GNU install.
+
+if test -n "$dir_arg"; then
+  if test -n "$dst_arg"; then
+    echo "$0: target directory not allowed when installing a directory." >&2
+    exit 1
+  fi
+fi
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+  # When -d is used, all remaining arguments are directories to create.
+  # When -t is used, the destination is already specified.
+  # Otherwise, the last argument is the destination.  Remove it from $@.
+  for arg
+  do
+    if test -n "$dst_arg"; then
+      # $@ is not empty: it contains at least $arg.
+      set fnord "$@" "$dst_arg"
+      shift # fnord
+    fi
+    shift # arg
+    dst_arg=$arg
+    # Protect names problematic for 'test' and other utilities.
+    case $dst_arg in
+      -* | [=\(\)!]) dst_arg=./$dst_arg;;
+    esac
+  done
+fi
+
+if test $# -eq 0; then
+  if test -z "$dir_arg"; then
+    echo "$0: no input file specified." >&2
+    exit 1
+  fi
+  # It's OK to call 'install-sh -d' without argument.
+  # This can happen when creating conditional directories.
+  exit 0
+fi
+
+if test -z "$dir_arg"; then
+  if test $# -gt 1 || test "$is_target_a_directory" = always; then
+    if test ! -d "$dst_arg"; then
+      echo "$0: $dst_arg: Is not a directory." >&2
+      exit 1
+    fi
+  fi
+fi
+
+if test -z "$dir_arg"; then
+  do_exit='(exit $ret); exit $ret'
+  trap "ret=129; $do_exit" 1
+  trap "ret=130; $do_exit" 2
+  trap "ret=141; $do_exit" 13
+  trap "ret=143; $do_exit" 15
+
+  # Set umask so as not to create temps with too-generous modes.
+  # However, 'strip' requires both read and write access to temps.
+  case $mode in
+    # Optimize common cases.
+    *644) cp_umask=133;;
+    *755) cp_umask=22;;
+
+    *[0-7])
+      if test -z "$stripcmd"; then
+        u_plus_rw=
+      else
+        u_plus_rw='% 200'
+      fi
+      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+    *)
+      if test -z "$stripcmd"; then
+        u_plus_rw=
+      else
+        u_plus_rw=,u+rw
+      fi
+      cp_umask=$mode$u_plus_rw;;
+  esac
+fi
+
+for src
+do
+  # Protect names problematic for 'test' and other utilities.
+  case $src in
+    -* | [=\(\)!]) src=./$src;;
+  esac
+
+  if test -n "$dir_arg"; then
+    dst=$src
+    dstdir=$dst
+    test -d "$dstdir"
+    dstdir_status=$?
+    # Don't chown directories that already exist.
+    if test $dstdir_status = 0; then
+      chowncmd=""
+    fi
+  else
+
+    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+    # might cause directories to be created, which would be especially bad
+    # if $src (and thus $dsttmp) contains '*'.
+    if test ! -f "$src" && test ! -d "$src"; then
+      echo "$0: $src does not exist." >&2
+      exit 1
+    fi
+
+    if test -z "$dst_arg"; then
+      echo "$0: no destination specified." >&2
+      exit 1
+    fi
+    dst=$dst_arg
+
+    # If destination is a directory, append the input filename.
+    if test -d "$dst"; then
+      if test "$is_target_a_directory" = never; then
+        echo "$0: $dst_arg: Is a directory" >&2
+        exit 1
+      fi
+      dstdir=$dst
+      dstbase=`basename "$src"`
+      case $dst in
+	*/) dst=$dst$dstbase;;
+	*)  dst=$dst/$dstbase;;
+      esac
+      dstdir_status=0
+    else
+      dstdir=`dirname "$dst"`
+      test -d "$dstdir"
+      dstdir_status=$?
+    fi
+  fi
+
+  case $dstdir in
+    */) dstdirslash=$dstdir;;
+    *)  dstdirslash=$dstdir/;;
+  esac
+
+  obsolete_mkdir_used=false
+
+  if test $dstdir_status != 0; then
+    case $posix_mkdir in
+      '')
+        # With -d, create the new directory with the user-specified mode.
+        # Otherwise, rely on $mkdir_umask.
+        if test -n "$dir_arg"; then
+          mkdir_mode=-m$mode
+        else
+          mkdir_mode=
+        fi
+
+        posix_mkdir=false
+	# The $RANDOM variable is not portable (e.g., dash).  Use it
+	# here however when possible just to lower collision chance.
+	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+
+	trap '
+	  ret=$?
+	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
+	  exit $ret
+	' 0
+
+	# Because "mkdir -p" follows existing symlinks and we likely work
+	# directly in world-writeable /tmp, make sure that the '$tmpdir'
+	# directory is successfully created first before we actually test
+	# 'mkdir -p'.
+	if (umask $mkdir_umask &&
+	    $mkdirprog $mkdir_mode "$tmpdir" &&
+	    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
+	then
+	  if test -z "$dir_arg" || {
+	       # Check for POSIX incompatibilities with -m.
+	       # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+	       # other-writable bit of parent directory when it shouldn't.
+	       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+	       test_tmpdir="$tmpdir/a"
+	       ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
+	       case $ls_ld_tmpdir in
+		 d????-?r-*) different_mode=700;;
+		 d????-?--*) different_mode=755;;
+		 *) false;;
+	       esac &&
+	       $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
+		 ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
+		 test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+	       }
+	     }
+	  then posix_mkdir=:
+	  fi
+	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
+	else
+	  # Remove any dirs left behind by ancient mkdir implementations.
+	  rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
+	fi
+	trap '' 0;;
+    esac
+
+    if
+      $posix_mkdir && (
+        umask $mkdir_umask &&
+        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+      )
+    then :
+    else
+
+      # mkdir does not conform to POSIX,
+      # or it failed possibly due to a race condition.  Create the
+      # directory the slow way, step by step, checking for races as we go.
+
+      case $dstdir in
+        /*) prefix='/';;
+        [-=\(\)!]*) prefix='./';;
+        *)  prefix='';;
+      esac
+
+      oIFS=$IFS
+      IFS=/
+      set -f
+      set fnord $dstdir
+      shift
+      set +f
+      IFS=$oIFS
+
+      prefixes=
+
+      for d
+      do
+        test X"$d" = X && continue
+
+        prefix=$prefix$d
+        if test -d "$prefix"; then
+          prefixes=
+        else
+          if $posix_mkdir; then
+            (umask $mkdir_umask &&
+             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+            # Don't fail if two instances are running concurrently.
+            test -d "$prefix" || exit 1
+          else
+            case $prefix in
+              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+              *) qprefix=$prefix;;
+            esac
+            prefixes="$prefixes '$qprefix'"
+          fi
+        fi
+        prefix=$prefix/
+      done
+
+      if test -n "$prefixes"; then
+        # Don't fail if two instances are running concurrently.
+        (umask $mkdir_umask &&
+         eval "\$doit_exec \$mkdirprog $prefixes") ||
+          test -d "$dstdir" || exit 1
+        obsolete_mkdir_used=true
+      fi
+    fi
+  fi
+
+  if test -n "$dir_arg"; then
+    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+  else
+
+    # Make a couple of temp file names in the proper directory.
+    dsttmp=${dstdirslash}_inst.$$_
+    rmtmp=${dstdirslash}_rm.$$_
+
+    # Trap to clean up those temp files at exit.
+    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+    # Copy the file name to the temp name.
+    (umask $cp_umask &&
+     { test -z "$stripcmd" || {
+	 # Create $dsttmp read-write so that cp doesn't create it read-only,
+	 # which would cause strip to fail.
+	 if test -z "$doit"; then
+	   : >"$dsttmp" # No need to fork-exec 'touch'.
+	 else
+	   $doit touch "$dsttmp"
+	 fi
+       }
+     } &&
+     $doit_exec $cpprog "$src" "$dsttmp") &&
+
+    # and set any options; do chmod last to preserve setuid bits.
+    #
+    # If any of these fail, we abort the whole thing.  If we want to
+    # ignore errors from any of these, just make sure not to ignore
+    # errors from the above "$doit $cpprog $src $dsttmp" command.
+    #
+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+    # If -C, don't bother to copy if it wouldn't change the file.
+    if $copy_on_change &&
+       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
+       set -f &&
+       set X $old && old=:$2:$4:$5:$6 &&
+       set X $new && new=:$2:$4:$5:$6 &&
+       set +f &&
+       test "$old" = "$new" &&
+       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+    then
+      rm -f "$dsttmp"
+    else
+      # If $backupsuffix is set, and the file being installed
+      # already exists, attempt a backup.  Don't worry if it fails,
+      # e.g., if mv doesn't support -f.
+      if test -n "$backupsuffix" && test -f "$dst"; then
+        $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
+      fi
+
+      # Rename the file to the real destination.
+      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+      # The rename failed, perhaps because mv can't rename something else
+      # to itself, or perhaps because mv is so ancient that it does not
+      # support -f.
+      {
+        # Now remove or move aside any old file at destination location.
+        # We try this two ways since rm can't unlink itself on some
+        # systems and the destination file might be busy for other
+        # reasons.  In this case, the final cleanup might fail but the new
+        # file should still install successfully.
+        {
+          test ! -f "$dst" ||
+          $doit $rmcmd "$dst" 2>/dev/null ||
+          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+            { $doit $rmcmd "$rmtmp" 2>/dev/null; :; }
+          } ||
+          { echo "$0: cannot unlink or rename $dst" >&2
+            (exit 1); exit 1
+          }
+        } &&
+
+        # Now rename the file to the real destination.
+        $doit $mvcmd "$dsttmp" "$dst"
+      }
+    fi || exit 1
+
+    trap '' 0
+  fi
+done
+
+# Local variables:
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/deps/cares/libcares.pc.cmake b/deps/cares/libcares.pc.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..67fd301d0a57ad8aab26c5a19fb2a53d682e55e9
--- /dev/null
+++ b/deps/cares/libcares.pc.cmake
@@ -0,0 +1,20 @@
+#***************************************************************************
+# Project        ___       __ _ _ __ ___  ___ 
+#               / __|____ / _` | '__/ _ \/ __|
+#              | (_|_____| (_| | | |  __/\__ \
+#               \___|     \__,_|_|  \___||___/
+#
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}/@CMAKE_INSTALL_BINDIR@
+libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
+includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
+
+Name: c-ares
+URL: https://c-ares.org/
+Description: asynchronous DNS lookup library
+Version: @CARES_VERSION@
+Requires: 
+Requires.private: 
+Cflags: -I${includedir} @CPPFLAG_CARES_STATICLIB@
+Libs: -L${libdir} -lcares
+Libs.private: @CARES_PRIVATE_LIBS@
diff --git a/deps/cares/libcares.pc.in b/deps/cares/libcares.pc.in
new file mode 100644
index 0000000000000000000000000000000000000000..e7ef5d250725b70706bf6374b0c96c576a517100
--- /dev/null
+++ b/deps/cares/libcares.pc.in
@@ -0,0 +1,20 @@
+#***************************************************************************
+# Project        ___       __ _ _ __ ___  ___ 
+#               / __|____ / _` | '__/ _ \/ __|
+#              | (_|_____| (_| | | |  __/\__ \
+#               \___|     \__,_|_|  \___||___/
+#
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: c-ares
+URL: http://c-ares.org/
+Description: asynchronous DNS lookup library
+Version: @VERSION@
+Requires: 
+Requires.private: 
+Cflags: -I${includedir} @CPPFLAG_CARES_STATICLIB@
+Libs: -L${libdir} -lcares
+Libs.private: @CARES_PRIVATE_LIBS@
diff --git a/deps/cares/ltmain.sh b/deps/cares/ltmain.sh
new file mode 100755
index 0000000000000000000000000000000000000000..21e5e078472631b867fce67f93a8a157e5a4379b
--- /dev/null
+++ b/deps/cares/ltmain.sh
@@ -0,0 +1,11251 @@
+#! /bin/sh
+## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
+##               by inline-source v2014-01-03.01
+
+# libtool (GNU libtool) 2.4.6
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+
+# Copyright (C) 1996-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# As a special exception to the GNU General Public License,
+# if you distribute this file as part of a program or library that
+# is built using GNU Libtool, you may include this file under the
+# same distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+PROGRAM=libtool
+PACKAGE=libtool
+VERSION="2.4.6 Debian-2.4.6-15"
+package_revision=2.4.6
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# Run './libtool --help' for help with using this script from the
+# command line.
+
+
+## ------------------------------- ##
+## User overridable command paths. ##
+## ------------------------------- ##
+
+# After configure completes, it has a better idea of some of the
+# shell tools we need than the defaults used by the functions shared
+# with bootstrap, so set those here where they can still be over-
+# ridden by the user, but otherwise take precedence.
+
+: ${AUTOCONF="autoconf"}
+: ${AUTOMAKE="automake"}
+
+
+## -------------------------- ##
+## Source external libraries. ##
+## -------------------------- ##
+
+# Much of our low-level functionality needs to be sourced from external
+# libraries, which are installed to $pkgauxdir.
+
+# Set a version string for this script.
+scriptversion=2015-01-20.17; # UTC
+
+# General shell script boiler plate, and helper functions.
+# Written by Gary V. Vaughan, 2004
+
+# Copyright (C) 2004-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+# As a special exception to the GNU General Public License, if you distribute
+# this file as part of a program or library that is built using GNU Libtool,
+# you may include this file under the same distribution terms that you use
+# for the rest of that program.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# Please report bugs or propose patches to gary@gnu.org.
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# Evaluate this file near the top of your script to gain access to
+# the functions and variables defined here:
+#
+#   . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
+#
+# If you need to override any of the default environment variable
+# settings, do that before evaluating this file.
+
+
+## -------------------- ##
+## Shell normalisation. ##
+## -------------------- ##
+
+# Some shells need a little help to be as Bourne compatible as possible.
+# Before doing anything else, make sure all that help has been provided!
+
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
+fi
+
+# NLS nuisances: We save the old values in case they are required later.
+_G_user_locale=
+_G_safe_locale=
+for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+do
+  eval "if test set = \"\${$_G_var+set}\"; then
+          save_$_G_var=\$$_G_var
+          $_G_var=C
+	  export $_G_var
+	  _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
+	  _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
+	fi"
+done
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Make sure IFS has a sensible default
+sp=' '
+nl='
+'
+IFS="$sp	$nl"
+
+# There are apparently some retarded systems that use ';' as a PATH separator!
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+
+## ------------------------- ##
+## Locate command utilities. ##
+## ------------------------- ##
+
+
+# func_executable_p FILE
+# ----------------------
+# Check that FILE is an executable regular file.
+func_executable_p ()
+{
+    test -f "$1" && test -x "$1"
+}
+
+
+# func_path_progs PROGS_LIST CHECK_FUNC [PATH]
+# --------------------------------------------
+# Search for either a program that responds to --version with output
+# containing "GNU", or else returned by CHECK_FUNC otherwise, by
+# trying all the directories in PATH with each of the elements of
+# PROGS_LIST.
+#
+# CHECK_FUNC should accept the path to a candidate program, and
+# set $func_check_prog_result if it truncates its output less than
+# $_G_path_prog_max characters.
+func_path_progs ()
+{
+    _G_progs_list=$1
+    _G_check_func=$2
+    _G_PATH=${3-"$PATH"}
+
+    _G_path_prog_max=0
+    _G_path_prog_found=false
+    _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
+    for _G_dir in $_G_PATH; do
+      IFS=$_G_save_IFS
+      test -z "$_G_dir" && _G_dir=.
+      for _G_prog_name in $_G_progs_list; do
+        for _exeext in '' .EXE; do
+          _G_path_prog=$_G_dir/$_G_prog_name$_exeext
+          func_executable_p "$_G_path_prog" || continue
+          case `"$_G_path_prog" --version 2>&1` in
+            *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
+            *)     $_G_check_func $_G_path_prog
+		   func_path_progs_result=$func_check_prog_result
+		   ;;
+          esac
+          $_G_path_prog_found && break 3
+        done
+      done
+    done
+    IFS=$_G_save_IFS
+    test -z "$func_path_progs_result" && {
+      echo "no acceptable sed could be found in \$PATH" >&2
+      exit 1
+    }
+}
+
+
+# We want to be able to use the functions in this file before configure
+# has figured out where the best binaries are kept, which means we have
+# to search for them ourselves - except when the results are already set
+# where we skip the searches.
+
+# Unless the user overrides by setting SED, search the path for either GNU
+# sed, or the sed that truncates its output the least.
+test -z "$SED" && {
+  _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+  for _G_i in 1 2 3 4 5 6 7; do
+    _G_sed_script=$_G_sed_script$nl$_G_sed_script
+  done
+  echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
+  _G_sed_script=
+
+  func_check_prog_sed ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo '' >> conftest.nl
+      "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
+  rm -f conftest.sed
+  SED=$func_path_progs_result
+}
+
+
+# Unless the user overrides by setting GREP, search the path for either GNU
+# grep, or the grep that truncates its output the least.
+test -z "$GREP" && {
+  func_check_prog_grep ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    _G_path_prog_max=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo 'GREP' >> conftest.nl
+      "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
+  GREP=$func_path_progs_result
+}
+
+
+## ------------------------------- ##
+## User overridable command paths. ##
+## ------------------------------- ##
+
+# All uppercase variable names are used for environment variables.  These
+# variables can be overridden by the user before calling a script that
+# uses them if a suitable command of that name is not already available
+# in the command search PATH.
+
+: ${CP="cp -f"}
+: ${ECHO="printf %s\n"}
+: ${EGREP="$GREP -E"}
+: ${FGREP="$GREP -F"}
+: ${LN_S="ln -s"}
+: ${MAKE="make"}
+: ${MKDIR="mkdir"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
+
+
+## -------------------- ##
+## Useful sed snippets. ##
+## -------------------- ##
+
+sed_dirname='s|/[^/]*$||'
+sed_basename='s|^.*/||'
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
+
+# Same as above, but do not quote variable references.
+sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution that turns a string into a regex matching for the
+# string literally.
+sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
+
+# Sed substitution that converts a w32 file name or path
+# that contains forward slashes, into one that contains
+# (escaped) backslashes.  A very naive implementation.
+sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+
+# Re-'\' parameter expansions in output of sed_double_quote_subst that
+# were '\'-ed in input to the same.  If an odd number of '\' preceded a
+# '$' in input to sed_double_quote_subst, that '$' was protected from
+# expansion.  Since each input '\' is now two '\'s, look for any number
+# of runs of four '\'s followed by two '\'s and then a '$'.  '\' that '$'.
+_G_bs='\\'
+_G_bs2='\\\\'
+_G_bs4='\\\\\\\\'
+_G_dollar='\$'
+sed_double_backslash="\
+  s/$_G_bs4/&\\
+/g
+  s/^$_G_bs2$_G_dollar/$_G_bs&/
+  s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
+  s/\n//g"
+
+
+## ----------------- ##
+## Global variables. ##
+## ----------------- ##
+
+# Except for the global variables explicitly listed below, the following
+# functions in the '^func_' namespace, and the '^require_' namespace
+# variables initialised in the 'Resource management' section, sourcing
+# this file will not pollute your global namespace with anything
+# else. There's no portable way to scope variables in Bourne shell
+# though, so actually running these functions will sometimes place
+# results into a variable named after the function, and often use
+# temporary variables in the '^_G_' namespace. If you are careful to
+# avoid using those namespaces casually in your sourcing script, things
+# should continue to work as you expect. And, of course, you can freely
+# overwrite any of the functions or variables defined here before
+# calling anything to customize them.
+
+EXIT_SUCCESS=0
+EXIT_FAILURE=1
+EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
+EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.
+
+# Allow overriding, eg assuming that you follow the convention of
+# putting '$debug_cmd' at the start of all your functions, you can get
+# bash to show function call trace with:
+#
+#    debug_cmd='echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
+debug_cmd=${debug_cmd-":"}
+exit_cmd=:
+
+# By convention, finish your script with:
+#
+#    exit $exit_status
+#
+# so that you can set exit_status to non-zero if you want to indicate
+# something went wrong during execution without actually bailing out at
+# the point of failure.
+exit_status=$EXIT_SUCCESS
+
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath=$0
+
+# The name of this program.
+progname=`$ECHO "$progpath" |$SED "$sed_basename"`
+
+# Make sure we have an absolute progpath for reexecution:
+case $progpath in
+  [\\/]*|[A-Za-z]:\\*) ;;
+  *[\\/]*)
+     progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
+     progdir=`cd "$progdir" && pwd`
+     progpath=$progdir/$progname
+     ;;
+  *)
+     _G_IFS=$IFS
+     IFS=${PATH_SEPARATOR-:}
+     for progdir in $PATH; do
+       IFS=$_G_IFS
+       test -x "$progdir/$progname" && break
+     done
+     IFS=$_G_IFS
+     test -n "$progdir" || progdir=`pwd`
+     progpath=$progdir/$progname
+     ;;
+esac
+
+
+## ----------------- ##
+## Standard options. ##
+## ----------------- ##
+
+# The following options affect the operation of the functions defined
+# below, and should be set appropriately depending on run-time para-
+# meters passed on the command line.
+
+opt_dry_run=false
+opt_quiet=false
+opt_verbose=false
+
+# Categories 'all' and 'none' are always available.  Append any others
+# you will pass as the first argument to func_warning from your own
+# code.
+warning_categories=
+
+# By default, display warnings according to 'opt_warning_types'.  Set
+# 'warning_func'  to ':' to elide all warnings, or func_fatal_error to
+# treat the next displayed warning as a fatal error.
+warning_func=func_warn_and_continue
+
+# Set to 'all' to display all warnings, 'none' to suppress all
+# warnings, or a space delimited list of some subset of
+# 'warning_categories' to display only the listed warnings.
+opt_warning_types=all
+
+
+## -------------------- ##
+## Resource management. ##
+## -------------------- ##
+
+# This section contains definitions for functions that each ensure a
+# particular resource (a file, or a non-empty configuration variable for
+# example) is available, and if appropriate to extract default values
+# from pertinent package files. Call them using their associated
+# 'require_*' variable to ensure that they are executed, at most, once.
+#
+# It's entirely deliberate that calling these functions can set
+# variables that don't obey the namespace limitations obeyed by the rest
+# of this file, in order that that they be as useful as possible to
+# callers.
+
+
+# require_term_colors
+# -------------------
+# Allow display of bold text on terminals that support it.
+require_term_colors=func_require_term_colors
+func_require_term_colors ()
+{
+    $debug_cmd
+
+    test -t 1 && {
+      # COLORTERM and USE_ANSI_COLORS environment variables take
+      # precedence, because most terminfo databases neglect to describe
+      # whether color sequences are supported.
+      test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
+
+      if test 1 = "$USE_ANSI_COLORS"; then
+        # Standard ANSI escape sequences
+        tc_reset=''
+        tc_bold='';   tc_standout=''
+        tc_red='';   tc_green=''
+        tc_blue='';  tc_cyan=''
+      else
+        # Otherwise trust the terminfo database after all.
+        test -n "`tput sgr0 2>/dev/null`" && {
+          tc_reset=`tput sgr0`
+          test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
+          tc_standout=$tc_bold
+          test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
+          test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
+          test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
+          test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
+          test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
+        }
+      fi
+    }
+
+    require_term_colors=:
+}
+
+
+## ----------------- ##
+## Function library. ##
+## ----------------- ##
+
+# This section contains a variety of useful functions to call in your
+# scripts. Take note of the portable wrappers for features provided by
+# some modern shells, which will fall back to slower equivalents on
+# less featureful shells.
+
+
+# func_append VAR VALUE
+# ---------------------
+# Append VALUE onto the existing contents of VAR.
+
+  # We should try to minimise forks, especially on Windows where they are
+  # unreasonably slow, so skip the feature probes when bash or zsh are
+  # being used:
+  if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
+    : ${_G_HAVE_ARITH_OP="yes"}
+    : ${_G_HAVE_XSI_OPS="yes"}
+    # The += operator was introduced in bash 3.1
+    case $BASH_VERSION in
+      [12].* | 3.0 | 3.0*) ;;
+      *)
+        : ${_G_HAVE_PLUSEQ_OP="yes"}
+        ;;
+    esac
+  fi
+
+  # _G_HAVE_PLUSEQ_OP
+  # Can be empty, in which case the shell is probed, "yes" if += is
+  # useable or anything else if it does not work.
+  test -z "$_G_HAVE_PLUSEQ_OP" \
+    && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
+    && _G_HAVE_PLUSEQ_OP=yes
+
+if test yes = "$_G_HAVE_PLUSEQ_OP"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_append ()
+  {
+    $debug_cmd
+
+    eval "$1+=\$2"
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_append ()
+  {
+    $debug_cmd
+
+    eval "$1=\$$1\$2"
+  }
+fi
+
+
+# func_append_quoted VAR VALUE
+# ----------------------------
+# Quote VALUE and append to the end of shell variable VAR, separated
+# by a space.
+if test yes = "$_G_HAVE_PLUSEQ_OP"; then
+  eval 'func_append_quoted ()
+  {
+    $debug_cmd
+
+    func_quote_for_eval "$2"
+    eval "$1+=\\ \$func_quote_for_eval_result"
+  }'
+else
+  func_append_quoted ()
+  {
+    $debug_cmd
+
+    func_quote_for_eval "$2"
+    eval "$1=\$$1\\ \$func_quote_for_eval_result"
+  }
+fi
+
+
+# func_append_uniq VAR VALUE
+# --------------------------
+# Append unique VALUE onto the existing contents of VAR, assuming
+# entries are delimited by the first character of VALUE.  For example:
+#
+#   func_append_uniq options " --another-option option-argument"
+#
+# will only append to $options if " --another-option option-argument "
+# is not already present somewhere in $options already (note spaces at
+# each end implied by leading space in second argument).
+func_append_uniq ()
+{
+    $debug_cmd
+
+    eval _G_current_value='`$ECHO $'$1'`'
+    _G_delim=`expr "$2" : '\(.\)'`
+
+    case $_G_delim$_G_current_value$_G_delim in
+      *"$2$_G_delim"*) ;;
+      *) func_append "$@" ;;
+    esac
+}
+
+
+# func_arith TERM...
+# ------------------
+# Set func_arith_result to the result of evaluating TERMs.
+  test -z "$_G_HAVE_ARITH_OP" \
+    && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
+    && _G_HAVE_ARITH_OP=yes
+
+if test yes = "$_G_HAVE_ARITH_OP"; then
+  eval 'func_arith ()
+  {
+    $debug_cmd
+
+    func_arith_result=$(( $* ))
+  }'
+else
+  func_arith ()
+  {
+    $debug_cmd
+
+    func_arith_result=`expr "$@"`
+  }
+fi
+
+
+# func_basename FILE
+# ------------------
+# Set func_basename_result to FILE with everything up to and including
+# the last / stripped.
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  # If this shell supports suffix pattern removal, then use it to avoid
+  # forking. Hide the definitions single quotes in case the shell chokes
+  # on unsupported syntax...
+  _b='func_basename_result=${1##*/}'
+  _d='case $1 in
+        */*) func_dirname_result=${1%/*}$2 ;;
+        *  ) func_dirname_result=$3        ;;
+      esac'
+
+else
+  # ...otherwise fall back to using sed.
+  _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
+  _d='func_dirname_result=`$ECHO "$1"  |$SED "$sed_dirname"`
+      if test "X$func_dirname_result" = "X$1"; then
+        func_dirname_result=$3
+      else
+        func_append func_dirname_result "$2"
+      fi'
+fi
+
+eval 'func_basename ()
+{
+    $debug_cmd
+
+    '"$_b"'
+}'
+
+
+# func_dirname FILE APPEND NONDIR_REPLACEMENT
+# -------------------------------------------
+# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+eval 'func_dirname ()
+{
+    $debug_cmd
+
+    '"$_d"'
+}'
+
+
+# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
+# --------------------------------------------------------
+# Perform func_basename and func_dirname in a single function
+# call:
+#   dirname:  Compute the dirname of FILE.  If nonempty,
+#             add APPEND to the result, otherwise set result
+#             to NONDIR_REPLACEMENT.
+#             value returned in "$func_dirname_result"
+#   basename: Compute filename of FILE.
+#             value retuned in "$func_basename_result"
+# For efficiency, we do not delegate to the functions above but instead
+# duplicate the functionality here.
+eval 'func_dirname_and_basename ()
+{
+    $debug_cmd
+
+    '"$_b"'
+    '"$_d"'
+}'
+
+
+# func_echo ARG...
+# ----------------
+# Echo program name prefixed message.
+func_echo ()
+{
+    $debug_cmd
+
+    _G_message=$*
+
+    func_echo_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_IFS
+      $ECHO "$progname: $_G_line"
+    done
+    IFS=$func_echo_IFS
+}
+
+
+# func_echo_all ARG...
+# --------------------
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO "$*"
+}
+
+
+# func_echo_infix_1 INFIX ARG...
+# ------------------------------
+# Echo program name, followed by INFIX on the first line, with any
+# additional lines not showing INFIX.
+func_echo_infix_1 ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    _G_infix=$1; shift
+    _G_indent=$_G_infix
+    _G_prefix="$progname: $_G_infix: "
+    _G_message=$*
+
+    # Strip color escape sequences before counting printable length
+    for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
+    do
+      test -n "$_G_tc" && {
+        _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
+        _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
+      }
+    done
+    _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes
+
+    func_echo_infix_1_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_infix_1_IFS
+      $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
+      _G_prefix=$_G_indent
+    done
+    IFS=$func_echo_infix_1_IFS
+}
+
+
+# func_error ARG...
+# -----------------
+# Echo program name prefixed message to standard error.
+func_error ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    func_echo_infix_1 "  $tc_standout${tc_red}error$tc_reset" "$*" >&2
+}
+
+
+# func_fatal_error ARG...
+# -----------------------
+# Echo program name prefixed message to standard error, and exit.
+func_fatal_error ()
+{
+    $debug_cmd
+
+    func_error "$*"
+    exit $EXIT_FAILURE
+}
+
+
+# func_grep EXPRESSION FILENAME
+# -----------------------------
+# Check whether EXPRESSION matches any line of FILENAME, without output.
+func_grep ()
+{
+    $debug_cmd
+
+    $GREP "$1" "$2" >/dev/null 2>&1
+}
+
+
+# func_len STRING
+# ---------------
+# Set func_len_result to the length of STRING. STRING may not
+# start with a hyphen.
+  test -z "$_G_HAVE_XSI_OPS" \
+    && (eval 'x=a/b/c;
+      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
+    && _G_HAVE_XSI_OPS=yes
+
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_len ()
+  {
+    $debug_cmd
+
+    func_len_result=${#1}
+  }'
+else
+  func_len ()
+  {
+    $debug_cmd
+
+    func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
+  }
+fi
+
+
+# func_mkdir_p DIRECTORY-PATH
+# ---------------------------
+# Make sure the entire path to DIRECTORY-PATH is available.
+func_mkdir_p ()
+{
+    $debug_cmd
+
+    _G_directory_path=$1
+    _G_dir_list=
+
+    if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
+
+      # Protect directory names starting with '-'
+      case $_G_directory_path in
+        -*) _G_directory_path=./$_G_directory_path ;;
+      esac
+
+      # While some portion of DIR does not yet exist...
+      while test ! -d "$_G_directory_path"; do
+        # ...make a list in topmost first order.  Use a colon delimited
+	# list incase some portion of path contains whitespace.
+        _G_dir_list=$_G_directory_path:$_G_dir_list
+
+        # If the last portion added has no slash in it, the list is done
+        case $_G_directory_path in */*) ;; *) break ;; esac
+
+        # ...otherwise throw away the child directory and loop
+        _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
+      done
+      _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
+
+      func_mkdir_p_IFS=$IFS; IFS=:
+      for _G_dir in $_G_dir_list; do
+	IFS=$func_mkdir_p_IFS
+        # mkdir can fail with a 'File exist' error if two processes
+        # try to create one of the directories concurrently.  Don't
+        # stop in that case!
+        $MKDIR "$_G_dir" 2>/dev/null || :
+      done
+      IFS=$func_mkdir_p_IFS
+
+      # Bail out if we (or some other process) failed to create a directory.
+      test -d "$_G_directory_path" || \
+        func_fatal_error "Failed to create '$1'"
+    fi
+}
+
+
+# func_mktempdir [BASENAME]
+# -------------------------
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible.  If
+# given, BASENAME is the basename for that directory.
+func_mktempdir ()
+{
+    $debug_cmd
+
+    _G_template=${TMPDIR-/tmp}/${1-$progname}
+
+    if test : = "$opt_dry_run"; then
+      # Return a directory name, but don't create it in dry-run mode
+      _G_tmpdir=$_G_template-$$
+    else
+
+      # If mktemp works, use that first and foremost
+      _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
+
+      if test ! -d "$_G_tmpdir"; then
+        # Failing that, at least try and use $RANDOM to avoid a race
+        _G_tmpdir=$_G_template-${RANDOM-0}$$
+
+        func_mktempdir_umask=`umask`
+        umask 0077
+        $MKDIR "$_G_tmpdir"
+        umask $func_mktempdir_umask
+      fi
+
+      # If we're not in dry-run mode, bomb out on failure
+      test -d "$_G_tmpdir" || \
+        func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
+    fi
+
+    $ECHO "$_G_tmpdir"
+}
+
+
+# func_normal_abspath PATH
+# ------------------------
+# Remove doubled-up and trailing slashes, "." path components,
+# and cancel out any ".." path components in PATH after making
+# it an absolute path.
+func_normal_abspath ()
+{
+    $debug_cmd
+
+    # These SED scripts presuppose an absolute path with a trailing slash.
+    _G_pathcar='s|^/\([^/]*\).*$|\1|'
+    _G_pathcdr='s|^/[^/]*||'
+    _G_removedotparts=':dotsl
+		s|/\./|/|g
+		t dotsl
+		s|/\.$|/|'
+    _G_collapseslashes='s|/\{1,\}|/|g'
+    _G_finalslash='s|/*$|/|'
+
+    # Start from root dir and reassemble the path.
+    func_normal_abspath_result=
+    func_normal_abspath_tpath=$1
+    func_normal_abspath_altnamespace=
+    case $func_normal_abspath_tpath in
+      "")
+        # Empty path, that just means $cwd.
+        func_stripname '' '/' "`pwd`"
+        func_normal_abspath_result=$func_stripname_result
+        return
+        ;;
+      # The next three entries are used to spot a run of precisely
+      # two leading slashes without using negated character classes;
+      # we take advantage of case's first-match behaviour.
+      ///*)
+        # Unusual form of absolute path, do nothing.
+        ;;
+      //*)
+        # Not necessarily an ordinary path; POSIX reserves leading '//'
+        # and for example Cygwin uses it to access remote file shares
+        # over CIFS/SMB, so we conserve a leading double slash if found.
+        func_normal_abspath_altnamespace=/
+        ;;
+      /*)
+        # Absolute path, do nothing.
+        ;;
+      *)
+        # Relative path, prepend $cwd.
+        func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
+        ;;
+    esac
+
+    # Cancel out all the simple stuff to save iterations.  We also want
+    # the path to end with a slash for ease of parsing, so make sure
+    # there is one (and only one) here.
+    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
+    while :; do
+      # Processed it all yet?
+      if test / = "$func_normal_abspath_tpath"; then
+        # If we ascended to the root using ".." the result may be empty now.
+        if test -z "$func_normal_abspath_result"; then
+          func_normal_abspath_result=/
+        fi
+        break
+      fi
+      func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_pathcar"`
+      func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_pathcdr"`
+      # Figure out what to do with it
+      case $func_normal_abspath_tcomponent in
+        "")
+          # Trailing empty path component, ignore it.
+          ;;
+        ..)
+          # Parent dir; strip last assembled component from result.
+          func_dirname "$func_normal_abspath_result"
+          func_normal_abspath_result=$func_dirname_result
+          ;;
+        *)
+          # Actual path component, append it.
+          func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
+          ;;
+      esac
+    done
+    # Restore leading double-slash if one was found on entry.
+    func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
+}
+
+
+# func_notquiet ARG...
+# --------------------
+# Echo program name prefixed message only when not in quiet mode.
+func_notquiet ()
+{
+    $debug_cmd
+
+    $opt_quiet || func_echo ${1+"$@"}
+
+    # A bug in bash halts the script if the last line of a function
+    # fails when set -e is in force, so we need another command to
+    # work around that:
+    :
+}
+
+
+# func_relative_path SRCDIR DSTDIR
+# --------------------------------
+# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
+func_relative_path ()
+{
+    $debug_cmd
+
+    func_relative_path_result=
+    func_normal_abspath "$1"
+    func_relative_path_tlibdir=$func_normal_abspath_result
+    func_normal_abspath "$2"
+    func_relative_path_tbindir=$func_normal_abspath_result
+
+    # Ascend the tree starting from libdir
+    while :; do
+      # check if we have found a prefix of bindir
+      case $func_relative_path_tbindir in
+        $func_relative_path_tlibdir)
+          # found an exact match
+          func_relative_path_tcancelled=
+          break
+          ;;
+        $func_relative_path_tlibdir*)
+          # found a matching prefix
+          func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
+          func_relative_path_tcancelled=$func_stripname_result
+          if test -z "$func_relative_path_result"; then
+            func_relative_path_result=.
+          fi
+          break
+          ;;
+        *)
+          func_dirname $func_relative_path_tlibdir
+          func_relative_path_tlibdir=$func_dirname_result
+          if test -z "$func_relative_path_tlibdir"; then
+            # Have to descend all the way to the root!
+            func_relative_path_result=../$func_relative_path_result
+            func_relative_path_tcancelled=$func_relative_path_tbindir
+            break
+          fi
+          func_relative_path_result=../$func_relative_path_result
+          ;;
+      esac
+    done
+
+    # Now calculate path; take care to avoid doubling-up slashes.
+    func_stripname '' '/' "$func_relative_path_result"
+    func_relative_path_result=$func_stripname_result
+    func_stripname '/' '/' "$func_relative_path_tcancelled"
+    if test -n "$func_stripname_result"; then
+      func_append func_relative_path_result "/$func_stripname_result"
+    fi
+
+    # Normalisation. If bindir is libdir, return '.' else relative path.
+    if test -n "$func_relative_path_result"; then
+      func_stripname './' '' "$func_relative_path_result"
+      func_relative_path_result=$func_stripname_result
+    fi
+
+    test -n "$func_relative_path_result" || func_relative_path_result=.
+
+    :
+}
+
+
+# func_quote_for_eval ARG...
+# --------------------------
+# Aesthetically quote ARGs to be evaled later.
+# This function returns two values:
+#   i) func_quote_for_eval_result
+#      double-quoted, suitable for a subsequent eval
+#  ii) func_quote_for_eval_unquoted_result
+#      has all characters that are still active within double
+#      quotes backslashified.
+func_quote_for_eval ()
+{
+    $debug_cmd
+
+    func_quote_for_eval_unquoted_result=
+    func_quote_for_eval_result=
+    while test 0 -lt $#; do
+      case $1 in
+        *[\\\`\"\$]*)
+	  _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
+        *)
+          _G_unquoted_arg=$1 ;;
+      esac
+      if test -n "$func_quote_for_eval_unquoted_result"; then
+	func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
+      else
+        func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
+      fi
+
+      case $_G_unquoted_arg in
+        # Double-quote args containing shell metacharacters to delay
+        # word splitting, command substitution and variable expansion
+        # for a subsequent eval.
+        # Many Bourne shells cannot handle close brackets correctly
+        # in scan sets, so we specify it separately.
+        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+          _G_quoted_arg=\"$_G_unquoted_arg\"
+          ;;
+        *)
+          _G_quoted_arg=$_G_unquoted_arg
+	  ;;
+      esac
+
+      if test -n "$func_quote_for_eval_result"; then
+	func_append func_quote_for_eval_result " $_G_quoted_arg"
+      else
+        func_append func_quote_for_eval_result "$_G_quoted_arg"
+      fi
+      shift
+    done
+}
+
+
+# func_quote_for_expand ARG
+# -------------------------
+# Aesthetically quote ARG to be evaled later; same as above,
+# but do not quote variable references.
+func_quote_for_expand ()
+{
+    $debug_cmd
+
+    case $1 in
+      *[\\\`\"]*)
+	_G_arg=`$ECHO "$1" | $SED \
+	    -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
+      *)
+        _G_arg=$1 ;;
+    esac
+
+    case $_G_arg in
+      # Double-quote args containing shell metacharacters to delay
+      # word splitting and command substitution for a subsequent eval.
+      # Many Bourne shells cannot handle close brackets correctly
+      # in scan sets, so we specify it separately.
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+        _G_arg=\"$_G_arg\"
+        ;;
+    esac
+
+    func_quote_for_expand_result=$_G_arg
+}
+
+
+# func_stripname PREFIX SUFFIX NAME
+# ---------------------------------
+# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_stripname ()
+  {
+    $debug_cmd
+
+    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
+    # positional parameters, so assign one to ordinary variable first.
+    func_stripname_result=$3
+    func_stripname_result=${func_stripname_result#"$1"}
+    func_stripname_result=${func_stripname_result%"$2"}
+  }'
+else
+  func_stripname ()
+  {
+    $debug_cmd
+
+    case $2 in
+      .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
+      *)  func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
+    esac
+  }
+fi
+
+
+# func_show_eval CMD [FAIL_EXP]
+# -----------------------------
+# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
+# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
+# is given, then evaluate it.
+func_show_eval ()
+{
+    $debug_cmd
+
+    _G_cmd=$1
+    _G_fail_exp=${2-':'}
+
+    func_quote_for_expand "$_G_cmd"
+    eval "func_notquiet $func_quote_for_expand_result"
+
+    $opt_dry_run || {
+      eval "$_G_cmd"
+      _G_status=$?
+      if test 0 -ne "$_G_status"; then
+	eval "(exit $_G_status); $_G_fail_exp"
+      fi
+    }
+}
+
+
+# func_show_eval_locale CMD [FAIL_EXP]
+# ------------------------------------
+# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
+# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
+# is given, then evaluate it.  Use the saved locale for evaluation.
+func_show_eval_locale ()
+{
+    $debug_cmd
+
+    _G_cmd=$1
+    _G_fail_exp=${2-':'}
+
+    $opt_quiet || {
+      func_quote_for_expand "$_G_cmd"
+      eval "func_echo $func_quote_for_expand_result"
+    }
+
+    $opt_dry_run || {
+      eval "$_G_user_locale
+	    $_G_cmd"
+      _G_status=$?
+      eval "$_G_safe_locale"
+      if test 0 -ne "$_G_status"; then
+	eval "(exit $_G_status); $_G_fail_exp"
+      fi
+    }
+}
+
+
+# func_tr_sh
+# ----------
+# Turn $1 into a string suitable for a shell variable name.
+# Result is stored in $func_tr_sh_result.  All characters
+# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
+# if $1 begins with a digit, a '_' is prepended as well.
+func_tr_sh ()
+{
+    $debug_cmd
+
+    case $1 in
+    [0-9]* | *[!a-zA-Z0-9_]*)
+      func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
+      ;;
+    * )
+      func_tr_sh_result=$1
+      ;;
+    esac
+}
+
+
+# func_verbose ARG...
+# -------------------
+# Echo program name prefixed message in verbose mode only.
+func_verbose ()
+{
+    $debug_cmd
+
+    $opt_verbose && func_echo "$*"
+
+    :
+}
+
+
+# func_warn_and_continue ARG...
+# -----------------------------
+# Echo program name prefixed warning message to standard error.
+func_warn_and_continue ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
+}
+
+
+# func_warning CATEGORY ARG...
+# ----------------------------
+# Echo program name prefixed warning message to standard error. Warning
+# messages can be filtered according to CATEGORY, where this function
+# elides messages where CATEGORY is not listed in the global variable
+# 'opt_warning_types'.
+func_warning ()
+{
+    $debug_cmd
+
+    # CATEGORY must be in the warning_categories list!
+    case " $warning_categories " in
+      *" $1 "*) ;;
+      *) func_internal_error "invalid warning category '$1'" ;;
+    esac
+
+    _G_category=$1
+    shift
+
+    case " $opt_warning_types " in
+      *" $_G_category "*) $warning_func ${1+"$@"} ;;
+    esac
+}
+
+
+# func_sort_ver VER1 VER2
+# -----------------------
+# 'sort -V' is not generally available.
+# Note this deviates from the version comparison in automake
+# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
+# but this should suffice as we won't be specifying old
+# version formats or redundant trailing .0 in bootstrap.conf.
+# If we did want full compatibility then we should probably
+# use m4_version_compare from autoconf.
+func_sort_ver ()
+{
+    $debug_cmd
+
+    printf '%s\n%s\n' "$1" "$2" \
+      | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
+}
+
+# func_lt_ver PREV CURR
+# ---------------------
+# Return true if PREV and CURR are in the correct order according to
+# func_sort_ver, otherwise false.  Use it like this:
+#
+#  func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
+func_lt_ver ()
+{
+    $debug_cmd
+
+    test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
+}
+
+
+# Local variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-time-zone: "UTC"
+# End:
+#! /bin/sh
+
+# Set a version string for this script.
+scriptversion=2015-10-07.11; # UTC
+
+# A portable, pluggable option parser for Bourne shell.
+# Written by Gary V. Vaughan, 2010
+
+# Copyright (C) 2010-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Please report bugs or propose patches to gary@gnu.org.
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# This file is a library for parsing options in your shell scripts along
+# with assorted other useful supporting features that you can make use
+# of too.
+#
+# For the simplest scripts you might need only:
+#
+#   #!/bin/sh
+#   . relative/path/to/funclib.sh
+#   . relative/path/to/options-parser
+#   scriptversion=1.0
+#   func_options ${1+"$@"}
+#   eval set dummy "$func_options_result"; shift
+#   ...rest of your script...
+#
+# In order for the '--version' option to work, you will need to have a
+# suitably formatted comment like the one at the top of this file
+# starting with '# Written by ' and ending with '# warranty; '.
+#
+# For '-h' and '--help' to work, you will also need a one line
+# description of your script's purpose in a comment directly above the
+# '# Written by ' line, like the one at the top of this file.
+#
+# The default options also support '--debug', which will turn on shell
+# execution tracing (see the comment above debug_cmd below for another
+# use), and '--verbose' and the func_verbose function to allow your script
+# to display verbose messages only when your user has specified
+# '--verbose'.
+#
+# After sourcing this file, you can plug processing for additional
+# options by amending the variables from the 'Configuration' section
+# below, and following the instructions in the 'Option parsing'
+# section further down.
+
+## -------------- ##
+## Configuration. ##
+## -------------- ##
+
+# You should override these variables in your script after sourcing this
+# file so that they reflect the customisations you have added to the
+# option parser.
+
+# The usage line for option parsing errors and the start of '-h' and
+# '--help' output messages. You can embed shell variables for delayed
+# expansion at the time the message is displayed, but you will need to
+# quote other shell meta-characters carefully to prevent them being
+# expanded when the contents are evaled.
+usage='$progpath [OPTION]...'
+
+# Short help message in response to '-h' and '--help'.  Add to this or
+# override it after sourcing this library to reflect the full set of
+# options your script accepts.
+usage_message="\
+       --debug        enable verbose shell tracing
+   -W, --warnings=CATEGORY
+                      report the warnings falling in CATEGORY [all]
+   -v, --verbose      verbosely report processing
+       --version      print version information and exit
+   -h, --help         print short or long help message and exit
+"
+
+# Additional text appended to 'usage_message' in response to '--help'.
+long_help_message="
+Warning categories include:
+       'all'          show all warnings
+       'none'         turn off all the warnings
+       'error'        warnings are treated as fatal errors"
+
+# Help message printed before fatal option parsing errors.
+fatal_help="Try '\$progname --help' for more information."
+
+
+
+## ------------------------- ##
+## Hook function management. ##
+## ------------------------- ##
+
+# This section contains functions for adding, removing, and running hooks
+# to the main code.  A hook is just a named list of of function, that can
+# be run in order later on.
+
+# func_hookable FUNC_NAME
+# -----------------------
+# Declare that FUNC_NAME will run hooks added with
+# 'func_add_hook FUNC_NAME ...'.
+func_hookable ()
+{
+    $debug_cmd
+
+    func_append hookable_fns " $1"
+}
+
+
+# func_add_hook FUNC_NAME HOOK_FUNC
+# ---------------------------------
+# Request that FUNC_NAME call HOOK_FUNC before it returns.  FUNC_NAME must
+# first have been declared "hookable" by a call to 'func_hookable'.
+func_add_hook ()
+{
+    $debug_cmd
+
+    case " $hookable_fns " in
+      *" $1 "*) ;;
+      *) func_fatal_error "'$1' does not accept hook functions." ;;
+    esac
+
+    eval func_append ${1}_hooks '" $2"'
+}
+
+
+# func_remove_hook FUNC_NAME HOOK_FUNC
+# ------------------------------------
+# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
+func_remove_hook ()
+{
+    $debug_cmd
+
+    eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
+}
+
+
+# func_run_hooks FUNC_NAME [ARG]...
+# ---------------------------------
+# Run all hook functions registered to FUNC_NAME.
+# It is assumed that the list of hook functions contains nothing more
+# than a whitespace-delimited list of legal shell function names, and
+# no effort is wasted trying to catch shell meta-characters or preserve
+# whitespace.
+func_run_hooks ()
+{
+    $debug_cmd
+
+    _G_rc_run_hooks=false
+
+    case " $hookable_fns " in
+      *" $1 "*) ;;
+      *) func_fatal_error "'$1' does not support hook funcions.n" ;;
+    esac
+
+    eval _G_hook_fns=\$$1_hooks; shift
+
+    for _G_hook in $_G_hook_fns; do
+      if eval $_G_hook '"$@"'; then
+        # store returned options list back into positional
+        # parameters for next 'cmd' execution.
+        eval _G_hook_result=\$${_G_hook}_result
+        eval set dummy "$_G_hook_result"; shift
+        _G_rc_run_hooks=:
+      fi
+    done
+
+    $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result
+}
+
+
+
+## --------------- ##
+## Option parsing. ##
+## --------------- ##
+
+# In order to add your own option parsing hooks, you must accept the
+# full positional parameter list in your hook function, you may remove/edit
+# any options that you action, and then pass back the remaining unprocessed
+# options in '<hooked_function_name>_result', escaped suitably for
+# 'eval'.  In this case you also must return $EXIT_SUCCESS to let the
+# hook's caller know that it should pay attention to
+# '<hooked_function_name>_result'.  Returning $EXIT_FAILURE signalizes that
+# arguments are left untouched by the hook and therefore caller will ignore the
+# result variable.
+#
+# Like this:
+#
+#    my_options_prep ()
+#    {
+#        $debug_cmd
+#
+#        # Extend the existing usage message.
+#        usage_message=$usage_message'
+#      -s, --silent       don'\''t print informational messages
+#    '
+#        # No change in '$@' (ignored completely by this hook).  There is
+#        # no need to do the equivalent (but slower) action:
+#        # func_quote_for_eval ${1+"$@"}
+#        # my_options_prep_result=$func_quote_for_eval_result
+#        false
+#    }
+#    func_add_hook func_options_prep my_options_prep
+#
+#
+#    my_silent_option ()
+#    {
+#        $debug_cmd
+#
+#        args_changed=false
+#
+#        # Note that for efficiency, we parse as many options as we can
+#        # recognise in a loop before passing the remainder back to the
+#        # caller on the first unrecognised argument we encounter.
+#        while test $# -gt 0; do
+#          opt=$1; shift
+#          case $opt in
+#            --silent|-s) opt_silent=:
+#                         args_changed=:
+#                         ;;
+#            # Separate non-argument short options:
+#            -s*)         func_split_short_opt "$_G_opt"
+#                         set dummy "$func_split_short_opt_name" \
+#                             "-$func_split_short_opt_arg" ${1+"$@"}
+#                         shift
+#                         args_changed=:
+#                         ;;
+#            *)           # Make sure the first unrecognised option "$_G_opt"
+#                         # is added back to "$@", we could need that later
+#                         # if $args_changed is true.
+#                         set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
+#          esac
+#        done
+#
+#        if $args_changed; then
+#          func_quote_for_eval ${1+"$@"}
+#          my_silent_option_result=$func_quote_for_eval_result
+#        fi
+#
+#        $args_changed
+#    }
+#    func_add_hook func_parse_options my_silent_option
+#
+#
+#    my_option_validation ()
+#    {
+#        $debug_cmd
+#
+#        $opt_silent && $opt_verbose && func_fatal_help "\
+#    '--silent' and '--verbose' options are mutually exclusive."
+#
+#        false
+#    }
+#    func_add_hook func_validate_options my_option_validation
+#
+# You'll also need to manually amend $usage_message to reflect the extra
+# options you parse.  It's preferable to append if you can, so that
+# multiple option parsing hooks can be added safely.
+
+
+# func_options_finish [ARG]...
+# ----------------------------
+# Finishing the option parse loop (call 'func_options' hooks ATM).
+func_options_finish ()
+{
+    $debug_cmd
+
+    _G_func_options_finish_exit=false
+    if func_run_hooks func_options ${1+"$@"}; then
+      func_options_finish_result=$func_run_hooks_result
+      _G_func_options_finish_exit=:
+    fi
+
+    $_G_func_options_finish_exit
+}
+
+
+# func_options [ARG]...
+# ---------------------
+# All the functions called inside func_options are hookable. See the
+# individual implementations for details.
+func_hookable func_options
+func_options ()
+{
+    $debug_cmd
+
+    _G_rc_options=false
+
+    for my_func in options_prep parse_options validate_options options_finish
+    do
+      if eval func_$my_func '${1+"$@"}'; then
+        eval _G_res_var='$'"func_${my_func}_result"
+        eval set dummy "$_G_res_var" ; shift
+        _G_rc_options=:
+      fi
+    done
+
+    # Save modified positional parameters for caller.  As a top-level
+    # options-parser function we always need to set the 'func_options_result'
+    # variable (regardless the $_G_rc_options value).
+    if $_G_rc_options; then
+      func_options_result=$_G_res_var
+    else
+      func_quote_for_eval ${1+"$@"}
+      func_options_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_options
+}
+
+
+# func_options_prep [ARG]...
+# --------------------------
+# All initialisations required before starting the option parse loop.
+# Note that when calling hook functions, we pass through the list of
+# positional parameters.  If a hook function modifies that list, and
+# needs to propagate that back to rest of this script, then the complete
+# modified list must be put in 'func_run_hooks_result' before
+# returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned).
+func_hookable func_options_prep
+func_options_prep ()
+{
+    $debug_cmd
+
+    # Option defaults:
+    opt_verbose=false
+    opt_warning_types=
+
+    _G_rc_options_prep=false
+    if func_run_hooks func_options_prep ${1+"$@"}; then
+      _G_rc_options_prep=:
+      # save modified positional parameters for caller
+      func_options_prep_result=$func_run_hooks_result
+    fi
+
+    $_G_rc_options_prep
+}
+
+
+# func_parse_options [ARG]...
+# ---------------------------
+# The main option parsing loop.
+func_hookable func_parse_options
+func_parse_options ()
+{
+    $debug_cmd
+
+    func_parse_options_result=
+
+    _G_rc_parse_options=false
+    # this just eases exit handling
+    while test $# -gt 0; do
+      # Defer to hook functions for initial option parsing, so they
+      # get priority in the event of reusing an option name.
+      if func_run_hooks func_parse_options ${1+"$@"}; then
+        eval set dummy "$func_run_hooks_result"; shift
+        _G_rc_parse_options=:
+      fi
+
+      # Break out of the loop if we already parsed every option.
+      test $# -gt 0 || break
+
+      _G_match_parse_options=:
+      _G_opt=$1
+      shift
+      case $_G_opt in
+        --debug|-x)   debug_cmd='set -x'
+                      func_echo "enabling shell trace mode"
+                      $debug_cmd
+                      ;;
+
+        --no-warnings|--no-warning|--no-warn)
+                      set dummy --warnings none ${1+"$@"}
+                      shift
+		      ;;
+
+        --warnings|--warning|-W)
+                      if test $# = 0 && func_missing_arg $_G_opt; then
+                        _G_rc_parse_options=:
+                        break
+                      fi
+                      case " $warning_categories $1" in
+                        *" $1 "*)
+                          # trailing space prevents matching last $1 above
+                          func_append_uniq opt_warning_types " $1"
+                          ;;
+                        *all)
+                          opt_warning_types=$warning_categories
+                          ;;
+                        *none)
+                          opt_warning_types=none
+                          warning_func=:
+                          ;;
+                        *error)
+                          opt_warning_types=$warning_categories
+                          warning_func=func_fatal_error
+                          ;;
+                        *)
+                          func_fatal_error \
+                             "unsupported warning category: '$1'"
+                          ;;
+                      esac
+                      shift
+                      ;;
+
+        --verbose|-v) opt_verbose=: ;;
+        --version)    func_version ;;
+        -\?|-h)       func_usage ;;
+        --help)       func_help ;;
+
+	# Separate optargs to long options (plugins may need this):
+	--*=*)        func_split_equals "$_G_opt"
+	              set dummy "$func_split_equals_lhs" \
+                          "$func_split_equals_rhs" ${1+"$@"}
+                      shift
+                      ;;
+
+       # Separate optargs to short options:
+        -W*)
+                      func_split_short_opt "$_G_opt"
+                      set dummy "$func_split_short_opt_name" \
+                          "$func_split_short_opt_arg" ${1+"$@"}
+                      shift
+                      ;;
+
+        # Separate non-argument short options:
+        -\?*|-h*|-v*|-x*)
+                      func_split_short_opt "$_G_opt"
+                      set dummy "$func_split_short_opt_name" \
+                          "-$func_split_short_opt_arg" ${1+"$@"}
+                      shift
+                      ;;
+
+        --)           _G_rc_parse_options=: ; break ;;
+        -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
+        *)            set dummy "$_G_opt" ${1+"$@"}; shift
+                      _G_match_parse_options=false
+                      break
+                      ;;
+      esac
+
+      $_G_match_parse_options && _G_rc_parse_options=:
+    done
+
+
+    if $_G_rc_parse_options; then
+      # save modified positional parameters for caller
+      func_quote_for_eval ${1+"$@"}
+      func_parse_options_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_parse_options
+}
+
+
+# func_validate_options [ARG]...
+# ------------------------------
+# Perform any sanity checks on option settings and/or unconsumed
+# arguments.
+func_hookable func_validate_options
+func_validate_options ()
+{
+    $debug_cmd
+
+    _G_rc_validate_options=false
+
+    # Display all warnings if -W was not given.
+    test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
+
+    if func_run_hooks func_validate_options ${1+"$@"}; then
+      # save modified positional parameters for caller
+      func_validate_options_result=$func_run_hooks_result
+      _G_rc_validate_options=:
+    fi
+
+    # Bail if the options were screwed!
+    $exit_cmd $EXIT_FAILURE
+
+    $_G_rc_validate_options
+}
+
+
+
+## ----------------- ##
+## Helper functions. ##
+## ----------------- ##
+
+# This section contains the helper functions used by the rest of the
+# hookable option parser framework in ascii-betical order.
+
+
+# func_fatal_help ARG...
+# ----------------------
+# Echo program name prefixed message to standard error, followed by
+# a help hint, and exit.
+func_fatal_help ()
+{
+    $debug_cmd
+
+    eval \$ECHO \""Usage: $usage"\"
+    eval \$ECHO \""$fatal_help"\"
+    func_error ${1+"$@"}
+    exit $EXIT_FAILURE
+}
+
+
+# func_help
+# ---------
+# Echo long help message to standard output and exit.
+func_help ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "$long_help_message"
+    exit 0
+}
+
+
+# func_missing_arg ARGNAME
+# ------------------------
+# Echo program name prefixed message to standard error and set global
+# exit_cmd.
+func_missing_arg ()
+{
+    $debug_cmd
+
+    func_error "Missing argument for '$1'."
+    exit_cmd=exit
+}
+
+
+# func_split_equals STRING
+# ------------------------
+# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
+# splitting STRING at the '=' sign.
+test -z "$_G_HAVE_XSI_OPS" \
+    && (eval 'x=a/b/c;
+      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
+    && _G_HAVE_XSI_OPS=yes
+
+if test yes = "$_G_HAVE_XSI_OPS"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_split_equals ()
+  {
+      $debug_cmd
+
+      func_split_equals_lhs=${1%%=*}
+      func_split_equals_rhs=${1#*=}
+      test "x$func_split_equals_lhs" = "x$1" \
+        && func_split_equals_rhs=
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_split_equals ()
+  {
+      $debug_cmd
+
+      func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
+      func_split_equals_rhs=
+      test "x$func_split_equals_lhs" = "x$1" \
+        || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
+  }
+fi #func_split_equals
+
+
+# func_split_short_opt SHORTOPT
+# -----------------------------
+# Set func_split_short_opt_name and func_split_short_opt_arg shell
+# variables after splitting SHORTOPT after the 2nd character.
+if test yes = "$_G_HAVE_XSI_OPS"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_split_short_opt ()
+  {
+      $debug_cmd
+
+      func_split_short_opt_arg=${1#??}
+      func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_split_short_opt ()
+  {
+      $debug_cmd
+
+      func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
+      func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
+  }
+fi #func_split_short_opt
+
+
+# func_usage
+# ----------
+# Echo short help message to standard output and exit.
+func_usage ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
+    exit 0
+}
+
+
+# func_usage_message
+# ------------------
+# Echo short help message to standard output.
+func_usage_message ()
+{
+    $debug_cmd
+
+    eval \$ECHO \""Usage: $usage"\"
+    echo
+    $SED -n 's|^# ||
+        /^Written by/{
+          x;p;x
+        }
+	h
+	/^Written by/q' < "$progpath"
+    echo
+    eval \$ECHO \""$usage_message"\"
+}
+
+
+# func_version
+# ------------
+# Echo version message to standard output and exit.
+func_version ()
+{
+    $debug_cmd
+
+    printf '%s\n' "$progname $scriptversion"
+    $SED -n '
+        /(C)/!b go
+        :more
+        /\./!{
+          N
+          s|\n# | |
+          b more
+        }
+        :go
+        /^# Written by /,/# warranty; / {
+          s|^# ||
+          s|^# *$||
+          s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
+          p
+        }
+        /^# Written by / {
+          s|^# ||
+          p
+        }
+        /^warranty; /q' < "$progpath"
+
+    exit $?
+}
+
+
+# Local variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-time-zone: "UTC"
+# End:
+
+# Set a version string.
+scriptversion='(GNU libtool) 2.4.6'
+
+
+# func_echo ARG...
+# ----------------
+# Libtool also displays the current mode in messages, so override
+# funclib.sh func_echo with this custom definition.
+func_echo ()
+{
+    $debug_cmd
+
+    _G_message=$*
+
+    func_echo_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_IFS
+      $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
+    done
+    IFS=$func_echo_IFS
+}
+
+
+# func_warning ARG...
+# -------------------
+# Libtool warnings are not categorized, so override funclib.sh
+# func_warning with this simpler definition.
+func_warning ()
+{
+    $debug_cmd
+
+    $warning_func ${1+"$@"}
+}
+
+
+## ---------------- ##
+## Options parsing. ##
+## ---------------- ##
+
+# Hook in the functions to make sure our own options are parsed during
+# the option parsing loop.
+
+usage='$progpath [OPTION]... [MODE-ARG]...'
+
+# Short help message in response to '-h'.
+usage_message="Options:
+       --config             show all configuration variables
+       --debug              enable verbose shell tracing
+   -n, --dry-run            display commands without modifying any files
+       --features           display basic configuration information and exit
+       --mode=MODE          use operation mode MODE
+       --no-warnings        equivalent to '-Wnone'
+       --preserve-dup-deps  don't remove duplicate dependency libraries
+       --quiet, --silent    don't print informational messages
+       --tag=TAG            use configuration variables from tag TAG
+   -v, --verbose            print more informational messages than default
+       --version            print version information
+   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY [all]
+   -h, --help, --help-all   print short, long, or detailed help message
+"
+
+# Additional text appended to 'usage_message' in response to '--help'.
+func_help ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "$long_help_message
+
+MODE must be one of the following:
+
+       clean           remove files from the build directory
+       compile         compile a source file into a libtool object
+       execute         automatically set library path, then run a program
+       finish          complete the installation of libtool libraries
+       install         install libraries or executables
+       link            create a library or an executable
+       uninstall       remove libraries from an installed directory
+
+MODE-ARGS vary depending on the MODE.  When passed as first option,
+'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
+Try '$progname --help --mode=MODE' for a more detailed description of MODE.
+
+When reporting a bug, please describe a test case to reproduce it and
+include the following information:
+
+       host-triplet:   $host
+       shell:          $SHELL
+       compiler:       $LTCC
+       compiler flags: $LTCFLAGS
+       linker:         $LD (gnu? $with_gnu_ld)
+       version:        $progname $scriptversion Debian-2.4.6-15
+       automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
+       autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
+
+Report bugs to <bug-libtool@gnu.org>.
+GNU libtool home page: <http://www.gnu.org/s/libtool/>.
+General help using GNU software: <http://www.gnu.org/gethelp/>."
+    exit 0
+}
+
+
+# func_lo2o OBJECT-NAME
+# ---------------------
+# Transform OBJECT-NAME from a '.lo' suffix to the platform specific
+# object suffix.
+
+lo2o=s/\\.lo\$/.$objext/
+o2lo=s/\\.$objext\$/.lo/
+
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_lo2o ()
+  {
+    case $1 in
+      *.lo) func_lo2o_result=${1%.lo}.$objext ;;
+      *   ) func_lo2o_result=$1               ;;
+    esac
+  }'
+
+  # func_xform LIBOBJ-OR-SOURCE
+  # ---------------------------
+  # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
+  # suffix to a '.lo' libtool-object suffix.
+  eval 'func_xform ()
+  {
+    func_xform_result=${1%.*}.lo
+  }'
+else
+  # ...otherwise fall back to using sed.
+  func_lo2o ()
+  {
+    func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
+  }
+
+  func_xform ()
+  {
+    func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
+  }
+fi
+
+
+# func_fatal_configuration ARG...
+# -------------------------------
+# Echo program name prefixed message to standard error, followed by
+# a configuration failure hint, and exit.
+func_fatal_configuration ()
+{
+    func__fatal_error ${1+"$@"} \
+      "See the $PACKAGE documentation for more information." \
+      "Fatal configuration error."
+}
+
+
+# func_config
+# -----------
+# Display the configuration for all the tags in this script.
+func_config ()
+{
+    re_begincf='^# ### BEGIN LIBTOOL'
+    re_endcf='^# ### END LIBTOOL'
+
+    # Default configuration.
+    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
+
+    # Now print the configurations for the tags.
+    for tagname in $taglist; do
+      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
+    done
+
+    exit $?
+}
+
+
+# func_features
+# -------------
+# Display the features supported by this script.
+func_features ()
+{
+    echo "host: $host"
+    if test yes = "$build_libtool_libs"; then
+      echo "enable shared libraries"
+    else
+      echo "disable shared libraries"
+    fi
+    if test yes = "$build_old_libs"; then
+      echo "enable static libraries"
+    else
+      echo "disable static libraries"
+    fi
+
+    exit $?
+}
+
+
+# func_enable_tag TAGNAME
+# -----------------------
+# Verify that TAGNAME is valid, and either flag an error and exit, or
+# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
+# variable here.
+func_enable_tag ()
+{
+    # Global variable:
+    tagname=$1
+
+    re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
+    re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
+    sed_extractcf=/$re_begincf/,/$re_endcf/p
+
+    # Validate tagname.
+    case $tagname in
+      *[!-_A-Za-z0-9,/]*)
+        func_fatal_error "invalid tag name: $tagname"
+        ;;
+    esac
+
+    # Don't test for the "default" C tag, as we know it's
+    # there but not specially marked.
+    case $tagname in
+        CC) ;;
+    *)
+        if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
+	  taglist="$taglist $tagname"
+
+	  # Evaluate the configuration.  Be careful to quote the path
+	  # and the sed script, to avoid splitting on whitespace, but
+	  # also don't use non-portable quotes within backquotes within
+	  # quotes we have to do it in 2 steps:
+	  extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
+	  eval "$extractedcf"
+        else
+	  func_error "ignoring unknown tag $tagname"
+        fi
+        ;;
+    esac
+}
+
+
+# func_check_version_match
+# ------------------------
+# Ensure that we are using m4 macros, and libtool script from the same
+# release of libtool.
+func_check_version_match ()
+{
+    if test "$package_revision" != "$macro_revision"; then
+      if test "$VERSION" != "$macro_version"; then
+        if test -z "$macro_version"; then
+          cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
+$progname: definition of this LT_INIT comes from an older release.
+$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+$progname: and run autoconf again.
+_LT_EOF
+        else
+          cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
+$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
+$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+$progname: and run autoconf again.
+_LT_EOF
+        fi
+      else
+        cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
+$progname: but the definition of this LT_INIT comes from revision $macro_revision.
+$progname: You should recreate aclocal.m4 with macros from revision $package_revision
+$progname: of $PACKAGE $VERSION and run autoconf again.
+_LT_EOF
+      fi
+
+      exit $EXIT_MISMATCH
+    fi
+}
+
+
+# libtool_options_prep [ARG]...
+# -----------------------------
+# Preparation for options parsed by libtool.
+libtool_options_prep ()
+{
+    $debug_mode
+
+    # Option defaults:
+    opt_config=false
+    opt_dlopen=
+    opt_dry_run=false
+    opt_help=false
+    opt_mode=
+    opt_preserve_dup_deps=false
+    opt_quiet=false
+
+    nonopt=
+    preserve_args=
+
+    _G_rc_lt_options_prep=:
+
+    # Shorthand for --mode=foo, only valid as the first argument
+    case $1 in
+    clean|clea|cle|cl)
+      shift; set dummy --mode clean ${1+"$@"}; shift
+      ;;
+    compile|compil|compi|comp|com|co|c)
+      shift; set dummy --mode compile ${1+"$@"}; shift
+      ;;
+    execute|execut|execu|exec|exe|ex|e)
+      shift; set dummy --mode execute ${1+"$@"}; shift
+      ;;
+    finish|finis|fini|fin|fi|f)
+      shift; set dummy --mode finish ${1+"$@"}; shift
+      ;;
+    install|instal|insta|inst|ins|in|i)
+      shift; set dummy --mode install ${1+"$@"}; shift
+      ;;
+    link|lin|li|l)
+      shift; set dummy --mode link ${1+"$@"}; shift
+      ;;
+    uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
+      shift; set dummy --mode uninstall ${1+"$@"}; shift
+      ;;
+    *)
+      _G_rc_lt_options_prep=false
+      ;;
+    esac
+
+    if $_G_rc_lt_options_prep; then
+      # Pass back the list of options.
+      func_quote_for_eval ${1+"$@"}
+      libtool_options_prep_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_lt_options_prep
+}
+func_add_hook func_options_prep libtool_options_prep
+
+
+# libtool_parse_options [ARG]...
+# ---------------------------------
+# Provide handling for libtool specific options.
+libtool_parse_options ()
+{
+    $debug_cmd
+
+    _G_rc_lt_parse_options=false
+
+    # Perform our own loop to consume as many options as possible in
+    # each iteration.
+    while test $# -gt 0; do
+      _G_match_lt_parse_options=:
+      _G_opt=$1
+      shift
+      case $_G_opt in
+        --dry-run|--dryrun|-n)
+                        opt_dry_run=:
+                        ;;
+
+        --config)       func_config ;;
+
+        --dlopen|-dlopen)
+                        opt_dlopen="${opt_dlopen+$opt_dlopen
+}$1"
+                        shift
+                        ;;
+
+        --preserve-dup-deps)
+                        opt_preserve_dup_deps=: ;;
+
+        --features)     func_features ;;
+
+        --finish)       set dummy --mode finish ${1+"$@"}; shift ;;
+
+        --help)         opt_help=: ;;
+
+        --help-all)     opt_help=': help-all' ;;
+
+        --mode)         test $# = 0 && func_missing_arg $_G_opt && break
+                        opt_mode=$1
+                        case $1 in
+                          # Valid mode arguments:
+                          clean|compile|execute|finish|install|link|relink|uninstall) ;;
+
+                          # Catch anything else as an error
+                          *) func_error "invalid argument for $_G_opt"
+                             exit_cmd=exit
+                             break
+                             ;;
+                        esac
+                        shift
+                        ;;
+
+        --no-silent|--no-quiet)
+                        opt_quiet=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --no-warnings|--no-warning|--no-warn)
+                        opt_warning=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --no-verbose)
+                        opt_verbose=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --silent|--quiet)
+                        opt_quiet=:
+                        opt_verbose=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --tag)          test $# = 0 && func_missing_arg $_G_opt && break
+                        opt_tag=$1
+                        func_append preserve_args " $_G_opt $1"
+                        func_enable_tag "$1"
+                        shift
+                        ;;
+
+        --verbose|-v)   opt_quiet=false
+                        opt_verbose=:
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        # An option not handled by this hook function:
+        *)              set dummy "$_G_opt" ${1+"$@"} ; shift
+                        _G_match_lt_parse_options=false
+                        break
+                        ;;
+      esac
+      $_G_match_lt_parse_options && _G_rc_lt_parse_options=:
+    done
+
+    if $_G_rc_lt_parse_options; then
+      # save modified positional parameters for caller
+      func_quote_for_eval ${1+"$@"}
+      libtool_parse_options_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_lt_parse_options
+}
+func_add_hook func_parse_options libtool_parse_options
+
+
+
+# libtool_validate_options [ARG]...
+# ---------------------------------
+# Perform any sanity checks on option settings and/or unconsumed
+# arguments.
+libtool_validate_options ()
+{
+    # save first non-option argument
+    if test 0 -lt $#; then
+      nonopt=$1
+      shift
+    fi
+
+    # preserve --debug
+    test : = "$debug_cmd" || func_append preserve_args " --debug"
+
+    case $host in
+      # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
+      # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
+      *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
+        # don't eliminate duplications in $postdeps and $predeps
+        opt_duplicate_compiler_generated_deps=:
+        ;;
+      *)
+        opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
+        ;;
+    esac
+
+    $opt_help || {
+      # Sanity checks first:
+      func_check_version_match
+
+      test yes != "$build_libtool_libs" \
+        && test yes != "$build_old_libs" \
+        && func_fatal_configuration "not configured to build any kind of library"
+
+      # Darwin sucks
+      eval std_shrext=\"$shrext_cmds\"
+
+      # Only execute mode is allowed to have -dlopen flags.
+      if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
+        func_error "unrecognized option '-dlopen'"
+        $ECHO "$help" 1>&2
+        exit $EXIT_FAILURE
+      fi
+
+      # Change the help message to a mode-specific one.
+      generic_help=$help
+      help="Try '$progname --help --mode=$opt_mode' for more information."
+    }
+
+    # Pass back the unparsed argument list
+    func_quote_for_eval ${1+"$@"}
+    libtool_validate_options_result=$func_quote_for_eval_result
+}
+func_add_hook func_validate_options libtool_validate_options
+
+
+# Process options as early as possible so that --help and --version
+# can return quickly.
+func_options ${1+"$@"}
+eval set dummy "$func_options_result"; shift
+
+
+
+## ----------- ##
+##    Main.    ##
+## ----------- ##
+
+magic='%%%MAGIC variable%%%'
+magic_exe='%%%MAGIC EXE variable%%%'
+
+# Global variables.
+extracted_archives=
+extracted_serial=0
+
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end.  This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+}
+
+# func_generated_by_libtool
+# True iff stdin has been generated by Libtool. This function is only
+# a basic sanity check; it will hardly flush out determined imposters.
+func_generated_by_libtool_p ()
+{
+  $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+}
+
+# func_lalib_p file
+# True iff FILE is a libtool '.la' library or '.lo' object file.
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_lalib_p ()
+{
+    test -f "$1" &&
+      $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
+}
+
+# func_lalib_unsafe_p file
+# True iff FILE is a libtool '.la' library or '.lo' object file.
+# This function implements the same check as func_lalib_p without
+# resorting to external programs.  To this end, it redirects stdin and
+# closes it afterwards, without saving the original file descriptor.
+# As a safety measure, use it only where a negative result would be
+# fatal anyway.  Works if 'file' does not exist.
+func_lalib_unsafe_p ()
+{
+    lalib_p=no
+    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
+	for lalib_p_l in 1 2 3 4
+	do
+	    read lalib_p_line
+	    case $lalib_p_line in
+		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
+	    esac
+	done
+	exec 0<&5 5<&-
+    fi
+    test yes = "$lalib_p"
+}
+
+# func_ltwrapper_script_p file
+# True iff FILE is a libtool wrapper script
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_script_p ()
+{
+    test -f "$1" &&
+      $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
+}
+
+# func_ltwrapper_executable_p file
+# True iff FILE is a libtool wrapper executable
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_executable_p ()
+{
+    func_ltwrapper_exec_suffix=
+    case $1 in
+    *.exe) ;;
+    *) func_ltwrapper_exec_suffix=.exe ;;
+    esac
+    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
+}
+
+# func_ltwrapper_scriptname file
+# Assumes file is an ltwrapper_executable
+# uses $file to determine the appropriate filename for a
+# temporary ltwrapper_script.
+func_ltwrapper_scriptname ()
+{
+    func_dirname_and_basename "$1" "" "."
+    func_stripname '' '.exe' "$func_basename_result"
+    func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
+}
+
+# func_ltwrapper_p file
+# True iff FILE is a libtool wrapper script or wrapper executable
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_p ()
+{
+    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
+}
+
+
+# func_execute_cmds commands fail_cmd
+# Execute tilde-delimited COMMANDS.
+# If FAIL_CMD is given, eval that upon failure.
+# FAIL_CMD may read-access the current command in variable CMD!
+func_execute_cmds ()
+{
+    $debug_cmd
+
+    save_ifs=$IFS; IFS='~'
+    for cmd in $1; do
+      IFS=$sp$nl
+      eval cmd=\"$cmd\"
+      IFS=$save_ifs
+      func_show_eval "$cmd" "${2-:}"
+    done
+    IFS=$save_ifs
+}
+
+
+# func_source file
+# Source FILE, adding directory component if necessary.
+# Note that it is not necessary on cygwin/mingw to append a dot to
+# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
+# behavior happens only for exec(3), not for open(2)!  Also, sourcing
+# 'FILE.' does not work on cygwin managed mounts.
+func_source ()
+{
+    $debug_cmd
+
+    case $1 in
+    */* | *\\*)	. "$1" ;;
+    *)		. "./$1" ;;
+    esac
+}
+
+
+# func_resolve_sysroot PATH
+# Replace a leading = in PATH with a sysroot.  Store the result into
+# func_resolve_sysroot_result
+func_resolve_sysroot ()
+{
+  func_resolve_sysroot_result=$1
+  case $func_resolve_sysroot_result in
+  =*)
+    func_stripname '=' '' "$func_resolve_sysroot_result"
+    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
+    ;;
+  esac
+}
+
+# func_replace_sysroot PATH
+# If PATH begins with the sysroot, replace it with = and
+# store the result into func_replace_sysroot_result.
+func_replace_sysroot ()
+{
+  case $lt_sysroot:$1 in
+  ?*:"$lt_sysroot"*)
+    func_stripname "$lt_sysroot" '' "$1"
+    func_replace_sysroot_result='='$func_stripname_result
+    ;;
+  *)
+    # Including no sysroot.
+    func_replace_sysroot_result=$1
+    ;;
+  esac
+}
+
+# func_infer_tag arg
+# Infer tagged configuration to use if any are available and
+# if one wasn't chosen via the "--tag" command line option.
+# Only attempt this if the compiler in the base compile
+# command doesn't match the default compiler.
+# arg is usually of the form 'gcc ...'
+func_infer_tag ()
+{
+    $debug_cmd
+
+    if test -n "$available_tags" && test -z "$tagname"; then
+      CC_quoted=
+      for arg in $CC; do
+	func_append_quoted CC_quoted "$arg"
+      done
+      CC_expanded=`func_echo_all $CC`
+      CC_quoted_expanded=`func_echo_all $CC_quoted`
+      case $@ in
+      # Blanks in the command may have been stripped by the calling shell,
+      # but not from the CC environment variable when configure was run.
+      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
+      # Blanks at the start of $base_compile will cause this to fail
+      # if we don't check for them as well.
+      *)
+	for z in $available_tags; do
+	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
+	    # Evaluate the configuration.
+	    eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+	    CC_quoted=
+	    for arg in $CC; do
+	      # Double-quote args containing other shell metacharacters.
+	      func_append_quoted CC_quoted "$arg"
+	    done
+	    CC_expanded=`func_echo_all $CC`
+	    CC_quoted_expanded=`func_echo_all $CC_quoted`
+	    case "$@ " in
+	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
+	      # The compiler in the base compile command matches
+	      # the one in the tagged configuration.
+	      # Assume this is the tagged configuration we want.
+	      tagname=$z
+	      break
+	      ;;
+	    esac
+	  fi
+	done
+	# If $tagname still isn't set, then no tagged configuration
+	# was found and let the user know that the "--tag" command
+	# line option must be used.
+	if test -z "$tagname"; then
+	  func_echo "unable to infer tagged configuration"
+	  func_fatal_error "specify a tag with '--tag'"
+#	else
+#	  func_verbose "using $tagname tagged configuration"
+	fi
+	;;
+      esac
+    fi
+}
+
+
+
+# func_write_libtool_object output_name pic_name nonpic_name
+# Create a libtool object file (analogous to a ".la" file),
+# but don't create it if we're doing a dry run.
+func_write_libtool_object ()
+{
+    write_libobj=$1
+    if test yes = "$build_libtool_libs"; then
+      write_lobj=\'$2\'
+    else
+      write_lobj=none
+    fi
+
+    if test yes = "$build_old_libs"; then
+      write_oldobj=\'$3\'
+    else
+      write_oldobj=none
+    fi
+
+    $opt_dry_run || {
+      cat >${write_libobj}T <<EOF
+# $write_libobj - a libtool object file
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object=$write_lobj
+
+# Name of the non-PIC object
+non_pic_object=$write_oldobj
+
+EOF
+      $MV "${write_libobj}T" "$write_libobj"
+    }
+}
+
+
+##################################################
+# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
+##################################################
+
+# func_convert_core_file_wine_to_w32 ARG
+# Helper function used by file name conversion functions when $build is *nix,
+# and $host is mingw, cygwin, or some other w32 environment. Relies on a
+# correctly configured wine environment available, with the winepath program
+# in $build's $PATH.
+#
+# ARG is the $build file name to be converted to w32 format.
+# Result is available in $func_convert_core_file_wine_to_w32_result, and will
+# be empty on error (or when ARG is empty)
+func_convert_core_file_wine_to_w32 ()
+{
+  $debug_cmd
+
+  func_convert_core_file_wine_to_w32_result=$1
+  if test -n "$1"; then
+    # Unfortunately, winepath does not exit with a non-zero error code, so we
+    # are forced to check the contents of stdout. On the other hand, if the
+    # command is not found, the shell will set an exit code of 127 and print
+    # *an error message* to stdout. So we must check for both error code of
+    # zero AND non-empty stdout, which explains the odd construction:
+    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
+    if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
+      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
+        $SED -e "$sed_naive_backslashify"`
+    else
+      func_convert_core_file_wine_to_w32_result=
+    fi
+  fi
+}
+# end: func_convert_core_file_wine_to_w32
+
+
+# func_convert_core_path_wine_to_w32 ARG
+# Helper function used by path conversion functions when $build is *nix, and
+# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
+# configured wine environment available, with the winepath program in $build's
+# $PATH. Assumes ARG has no leading or trailing path separator characters.
+#
+# ARG is path to be converted from $build format to win32.
+# Result is available in $func_convert_core_path_wine_to_w32_result.
+# Unconvertible file (directory) names in ARG are skipped; if no directory names
+# are convertible, then the result may be empty.
+func_convert_core_path_wine_to_w32 ()
+{
+  $debug_cmd
+
+  # unfortunately, winepath doesn't convert paths, only file names
+  func_convert_core_path_wine_to_w32_result=
+  if test -n "$1"; then
+    oldIFS=$IFS
+    IFS=:
+    for func_convert_core_path_wine_to_w32_f in $1; do
+      IFS=$oldIFS
+      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
+      if test -n "$func_convert_core_file_wine_to_w32_result"; then
+        if test -z "$func_convert_core_path_wine_to_w32_result"; then
+          func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
+        else
+          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
+        fi
+      fi
+    done
+    IFS=$oldIFS
+  fi
+}
+# end: func_convert_core_path_wine_to_w32
+
+
+# func_cygpath ARGS...
+# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
+# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
+# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
+# (2), returns the Cygwin file name or path in func_cygpath_result (input
+# file name or path is assumed to be in w32 format, as previously converted
+# from $build's *nix or MSYS format). In case (3), returns the w32 file name
+# or path in func_cygpath_result (input file name or path is assumed to be in
+# Cygwin format). Returns an empty string on error.
+#
+# ARGS are passed to cygpath, with the last one being the file name or path to
+# be converted.
+#
+# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
+# environment variable; do not put it in $PATH.
+func_cygpath ()
+{
+  $debug_cmd
+
+  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
+    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
+    if test "$?" -ne 0; then
+      # on failure, ensure result is empty
+      func_cygpath_result=
+    fi
+  else
+    func_cygpath_result=
+    func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
+  fi
+}
+#end: func_cygpath
+
+
+# func_convert_core_msys_to_w32 ARG
+# Convert file name or path ARG from MSYS format to w32 format.  Return
+# result in func_convert_core_msys_to_w32_result.
+func_convert_core_msys_to_w32 ()
+{
+  $debug_cmd
+
+  # awkward: cmd appends spaces to result
+  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
+    $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
+}
+#end: func_convert_core_msys_to_w32
+
+
+# func_convert_file_check ARG1 ARG2
+# Verify that ARG1 (a file name in $build format) was converted to $host
+# format in ARG2. Otherwise, emit an error message, but continue (resetting
+# func_to_host_file_result to ARG1).
+func_convert_file_check ()
+{
+  $debug_cmd
+
+  if test -z "$2" && test -n "$1"; then
+    func_error "Could not determine host file name corresponding to"
+    func_error "  '$1'"
+    func_error "Continuing, but uninstalled executables may not work."
+    # Fallback:
+    func_to_host_file_result=$1
+  fi
+}
+# end func_convert_file_check
+
+
+# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
+# Verify that FROM_PATH (a path in $build format) was converted to $host
+# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
+# func_to_host_file_result to a simplistic fallback value (see below).
+func_convert_path_check ()
+{
+  $debug_cmd
+
+  if test -z "$4" && test -n "$3"; then
+    func_error "Could not determine the host path corresponding to"
+    func_error "  '$3'"
+    func_error "Continuing, but uninstalled executables may not work."
+    # Fallback.  This is a deliberately simplistic "conversion" and
+    # should not be "improved".  See libtool.info.
+    if test "x$1" != "x$2"; then
+      lt_replace_pathsep_chars="s|$1|$2|g"
+      func_to_host_path_result=`echo "$3" |
+        $SED -e "$lt_replace_pathsep_chars"`
+    else
+      func_to_host_path_result=$3
+    fi
+  fi
+}
+# end func_convert_path_check
+
+
+# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
+# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
+# and appending REPL if ORIG matches BACKPAT.
+func_convert_path_front_back_pathsep ()
+{
+  $debug_cmd
+
+  case $4 in
+  $1 ) func_to_host_path_result=$3$func_to_host_path_result
+    ;;
+  esac
+  case $4 in
+  $2 ) func_append func_to_host_path_result "$3"
+    ;;
+  esac
+}
+# end func_convert_path_front_back_pathsep
+
+
+##################################################
+# $build to $host FILE NAME CONVERSION FUNCTIONS #
+##################################################
+# invoked via '$to_host_file_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# Result will be available in $func_to_host_file_result.
+
+
+# func_to_host_file ARG
+# Converts the file name ARG from $build format to $host format. Return result
+# in func_to_host_file_result.
+func_to_host_file ()
+{
+  $debug_cmd
+
+  $to_host_file_cmd "$1"
+}
+# end func_to_host_file
+
+
+# func_to_tool_file ARG LAZY
+# converts the file name ARG from $build format to toolchain format. Return
+# result in func_to_tool_file_result.  If the conversion in use is listed
+# in (the comma separated) LAZY, no conversion takes place.
+func_to_tool_file ()
+{
+  $debug_cmd
+
+  case ,$2, in
+    *,"$to_tool_file_cmd",*)
+      func_to_tool_file_result=$1
+      ;;
+    *)
+      $to_tool_file_cmd "$1"
+      func_to_tool_file_result=$func_to_host_file_result
+      ;;
+  esac
+}
+# end func_to_tool_file
+
+
+# func_convert_file_noop ARG
+# Copy ARG to func_to_host_file_result.
+func_convert_file_noop ()
+{
+  func_to_host_file_result=$1
+}
+# end func_convert_file_noop
+
+
+# func_convert_file_msys_to_w32 ARG
+# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper.  Returns result in
+# func_to_host_file_result.
+func_convert_file_msys_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_msys_to_w32 "$1"
+    func_to_host_file_result=$func_convert_core_msys_to_w32_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_w32
+
+
+# func_convert_file_cygwin_to_w32 ARG
+# Convert file name ARG from Cygwin to w32 format.  Returns result in
+# func_to_host_file_result.
+func_convert_file_cygwin_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
+    # LT_CYGPATH in this case.
+    func_to_host_file_result=`cygpath -m "$1"`
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_cygwin_to_w32
+
+
+# func_convert_file_nix_to_w32 ARG
+# Convert file name ARG from *nix to w32 format.  Requires a wine environment
+# and a working winepath. Returns result in func_to_host_file_result.
+func_convert_file_nix_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_file_wine_to_w32 "$1"
+    func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_w32
+
+
+# func_convert_file_msys_to_cygwin ARG
+# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_file_msys_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_msys_to_w32 "$1"
+    func_cygpath -u "$func_convert_core_msys_to_w32_result"
+    func_to_host_file_result=$func_cygpath_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_cygwin
+
+
+# func_convert_file_nix_to_cygwin ARG
+# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
+# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
+# in func_to_host_file_result.
+func_convert_file_nix_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
+    func_convert_core_file_wine_to_w32 "$1"
+    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
+    func_to_host_file_result=$func_cygpath_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_cygwin
+
+
+#############################################
+# $build to $host PATH CONVERSION FUNCTIONS #
+#############################################
+# invoked via '$to_host_path_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# The result will be available in $func_to_host_path_result.
+#
+# Path separators are also converted from $build format to $host format.  If
+# ARG begins or ends with a path separator character, it is preserved (but
+# converted to $host format) on output.
+#
+# All path conversion functions are named using the following convention:
+#   file name conversion function    : func_convert_file_X_to_Y ()
+#   path conversion function         : func_convert_path_X_to_Y ()
+# where, for any given $build/$host combination the 'X_to_Y' value is the
+# same.  If conversion functions are added for new $build/$host combinations,
+# the two new functions must follow this pattern, or func_init_to_host_path_cmd
+# will break.
+
+
+# func_init_to_host_path_cmd
+# Ensures that function "pointer" variable $to_host_path_cmd is set to the
+# appropriate value, based on the value of $to_host_file_cmd.
+to_host_path_cmd=
+func_init_to_host_path_cmd ()
+{
+  $debug_cmd
+
+  if test -z "$to_host_path_cmd"; then
+    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
+    to_host_path_cmd=func_convert_path_$func_stripname_result
+  fi
+}
+
+
+# func_to_host_path ARG
+# Converts the path ARG from $build format to $host format. Return result
+# in func_to_host_path_result.
+func_to_host_path ()
+{
+  $debug_cmd
+
+  func_init_to_host_path_cmd
+  $to_host_path_cmd "$1"
+}
+# end func_to_host_path
+
+
+# func_convert_path_noop ARG
+# Copy ARG to func_to_host_path_result.
+func_convert_path_noop ()
+{
+  func_to_host_path_result=$1
+}
+# end func_convert_path_noop
+
+
+# func_convert_path_msys_to_w32 ARG
+# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper.  Returns result in
+# func_to_host_path_result.
+func_convert_path_msys_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # Remove leading and trailing path separator characters from ARG.  MSYS
+    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
+    # and winepath ignores them completely.
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+    func_to_host_path_result=$func_convert_core_msys_to_w32_result
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_msys_to_w32
+
+
+# func_convert_path_cygwin_to_w32 ARG
+# Convert path ARG from Cygwin to w32 format.  Returns result in
+# func_to_host_file_result.
+func_convert_path_cygwin_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_cygwin_to_w32
+
+
+# func_convert_path_nix_to_w32 ARG
+# Convert path ARG from *nix to w32 format.  Requires a wine environment and
+# a working winepath.  Returns result in func_to_host_file_result.
+func_convert_path_nix_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+    func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_nix_to_w32
+
+
+# func_convert_path_msys_to_cygwin ARG
+# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_path_msys_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
+    func_to_host_path_result=$func_cygpath_result
+    func_convert_path_check : : \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+  fi
+}
+# end func_convert_path_msys_to_cygwin
+
+
+# func_convert_path_nix_to_cygwin ARG
+# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
+# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
+# func_to_host_file_result.
+func_convert_path_nix_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # Remove leading and trailing path separator characters from
+    # ARG. msys behavior is inconsistent here, cygpath turns them
+    # into '.;' and ';.', and winepath ignores them completely.
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
+    func_to_host_path_result=$func_cygpath_result
+    func_convert_path_check : : \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+  fi
+}
+# end func_convert_path_nix_to_cygwin
+
+
+# func_dll_def_p FILE
+# True iff FILE is a Windows DLL '.def' file.
+# Keep in sync with _LT_DLL_DEF_P in libtool.m4
+func_dll_def_p ()
+{
+  $debug_cmd
+
+  func_dll_def_p_tmp=`$SED -n \
+    -e 's/^[	 ]*//' \
+    -e '/^\(;.*\)*$/d' \
+    -e 's/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p' \
+    -e q \
+    "$1"`
+  test DEF = "$func_dll_def_p_tmp"
+}
+
+
+# func_mode_compile arg...
+func_mode_compile ()
+{
+    $debug_cmd
+
+    # Get the compilation command and the source file.
+    base_compile=
+    srcfile=$nonopt  #  always keep a non-empty value in "srcfile"
+    suppress_opt=yes
+    suppress_output=
+    arg_mode=normal
+    libobj=
+    later=
+    pie_flag=
+
+    for arg
+    do
+      case $arg_mode in
+      arg  )
+	# do not "continue".  Instead, add this to base_compile
+	lastarg=$arg
+	arg_mode=normal
+	;;
+
+      target )
+	libobj=$arg
+	arg_mode=normal
+	continue
+	;;
+
+      normal )
+	# Accept any command-line options.
+	case $arg in
+	-o)
+	  test -n "$libobj" && \
+	    func_fatal_error "you cannot specify '-o' more than once"
+	  arg_mode=target
+	  continue
+	  ;;
+
+	-pie | -fpie | -fPIE)
+          func_append pie_flag " $arg"
+	  continue
+	  ;;
+
+	-shared | -static | -prefer-pic | -prefer-non-pic)
+	  func_append later " $arg"
+	  continue
+	  ;;
+
+	-no-suppress)
+	  suppress_opt=no
+	  continue
+	  ;;
+
+	-Xcompiler)
+	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
+	  continue      #  The current "srcfile" will either be retained or
+	  ;;            #  replaced later.  I would guess that would be a bug.
+
+	-Wc,*)
+	  func_stripname '-Wc,' '' "$arg"
+	  args=$func_stripname_result
+	  lastarg=
+	  save_ifs=$IFS; IFS=,
+	  for arg in $args; do
+	    IFS=$save_ifs
+	    func_append_quoted lastarg "$arg"
+	  done
+	  IFS=$save_ifs
+	  func_stripname ' ' '' "$lastarg"
+	  lastarg=$func_stripname_result
+
+	  # Add the arguments to base_compile.
+	  func_append base_compile " $lastarg"
+	  continue
+	  ;;
+
+	*)
+	  # Accept the current argument as the source file.
+	  # The previous "srcfile" becomes the current argument.
+	  #
+	  lastarg=$srcfile
+	  srcfile=$arg
+	  ;;
+	esac  #  case $arg
+	;;
+      esac    #  case $arg_mode
+
+      # Aesthetically quote the previous argument.
+      func_append_quoted base_compile "$lastarg"
+    done # for arg
+
+    case $arg_mode in
+    arg)
+      func_fatal_error "you must specify an argument for -Xcompile"
+      ;;
+    target)
+      func_fatal_error "you must specify a target with '-o'"
+      ;;
+    *)
+      # Get the name of the library object.
+      test -z "$libobj" && {
+	func_basename "$srcfile"
+	libobj=$func_basename_result
+      }
+      ;;
+    esac
+
+    # Recognize several different file suffixes.
+    # If the user specifies -o file.o, it is replaced with file.lo
+    case $libobj in
+    *.[cCFSifmso] | \
+    *.ada | *.adb | *.ads | *.asm | \
+    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
+    *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
+      func_xform "$libobj"
+      libobj=$func_xform_result
+      ;;
+    esac
+
+    case $libobj in
+    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
+    *)
+      func_fatal_error "cannot determine name of library object from '$libobj'"
+      ;;
+    esac
+
+    func_infer_tag $base_compile
+
+    for arg in $later; do
+      case $arg in
+      -shared)
+	test yes = "$build_libtool_libs" \
+	  || func_fatal_configuration "cannot build a shared library"
+	build_old_libs=no
+	continue
+	;;
+
+      -static)
+	build_libtool_libs=no
+	build_old_libs=yes
+	continue
+	;;
+
+      -prefer-pic)
+	pic_mode=yes
+	continue
+	;;
+
+      -prefer-non-pic)
+	pic_mode=no
+	continue
+	;;
+      esac
+    done
+
+    func_quote_for_eval "$libobj"
+    test "X$libobj" != "X$func_quote_for_eval_result" \
+      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'	 &()|`$[]' \
+      && func_warning "libobj name '$libobj' may not contain shell special characters."
+    func_dirname_and_basename "$obj" "/" ""
+    objname=$func_basename_result
+    xdir=$func_dirname_result
+    lobj=$xdir$objdir/$objname
+
+    test -z "$base_compile" && \
+      func_fatal_help "you must specify a compilation command"
+
+    # Delete any leftover library objects.
+    if test yes = "$build_old_libs"; then
+      removelist="$obj $lobj $libobj ${libobj}T"
+    else
+      removelist="$lobj $libobj ${libobj}T"
+    fi
+
+    # On Cygwin there's no "real" PIC flag so we must build both object types
+    case $host_os in
+    cygwin* | mingw* | pw32* | os2* | cegcc*)
+      pic_mode=default
+      ;;
+    esac
+    if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
+      # non-PIC code in shared libraries is not supported
+      pic_mode=default
+    fi
+
+    # Calculate the filename of the output object if compiler does
+    # not support -o with -c
+    if test no = "$compiler_c_o"; then
+      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
+      lockfile=$output_obj.lock
+    else
+      output_obj=
+      need_locks=no
+      lockfile=
+    fi
+
+    # Lock this critical section if it is needed
+    # We use this script file to make the link, it avoids creating a new file
+    if test yes = "$need_locks"; then
+      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+	func_echo "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    elif test warn = "$need_locks"; then
+      if test -f "$lockfile"; then
+	$ECHO "\
+*** ERROR, $lockfile exists and contains:
+`cat $lockfile 2>/dev/null`
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+      func_append removelist " $output_obj"
+      $ECHO "$srcfile" > "$lockfile"
+    fi
+
+    $opt_dry_run || $RM $removelist
+    func_append removelist " $lockfile"
+    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
+
+    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
+    srcfile=$func_to_tool_file_result
+    func_quote_for_eval "$srcfile"
+    qsrcfile=$func_quote_for_eval_result
+
+    # Only build a PIC object if we are building libtool libraries.
+    if test yes = "$build_libtool_libs"; then
+      # Without this assignment, base_compile gets emptied.
+      fbsd_hideous_sh_bug=$base_compile
+
+      if test no != "$pic_mode"; then
+	command="$base_compile $qsrcfile $pic_flag"
+      else
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      fi
+
+      func_mkdir_p "$xdir$objdir"
+
+      if test -z "$output_obj"; then
+	# Place PIC objects in $objdir
+	func_append command " -o $lobj"
+      fi
+
+      func_show_eval_locale "$command"	\
+          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
+
+      if test warn = "$need_locks" &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$ECHO "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed, then go on to compile the next one
+      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
+	func_show_eval '$MV "$output_obj" "$lobj"' \
+	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+      fi
+
+      # Allow error messages only from the first compilation.
+      if test yes = "$suppress_opt"; then
+	suppress_output=' >/dev/null 2>&1'
+      fi
+    fi
+
+    # Only build a position-dependent object if we build old libraries.
+    if test yes = "$build_old_libs"; then
+      if test yes != "$pic_mode"; then
+	# Don't build PIC code
+	command="$base_compile $qsrcfile$pie_flag"
+      else
+	command="$base_compile $qsrcfile $pic_flag"
+      fi
+      if test yes = "$compiler_c_o"; then
+	func_append command " -o $obj"
+      fi
+
+      # Suppress compiler output if we already did a PIC compilation.
+      func_append command "$suppress_output"
+      func_show_eval_locale "$command" \
+        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
+
+      if test warn = "$need_locks" &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$ECHO "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed
+      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
+	func_show_eval '$MV "$output_obj" "$obj"' \
+	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+      fi
+    fi
+
+    $opt_dry_run || {
+      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
+
+      # Unlock the critical section if it was locked
+      if test no != "$need_locks"; then
+	removelist=$lockfile
+        $RM "$lockfile"
+      fi
+    }
+
+    exit $EXIT_SUCCESS
+}
+
+$opt_help || {
+  test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
+}
+
+func_mode_help ()
+{
+    # We need to display help for each of the modes.
+    case $opt_mode in
+      "")
+        # Generic help is extracted from the usage comments
+        # at the start of this file.
+        func_help
+        ;;
+
+      clean)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
+
+Remove files from the build directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
+to RM.
+
+If FILE is a libtool library, object or program, all the files associated
+with it are deleted. Otherwise, only FILE itself is deleted using RM."
+        ;;
+
+      compile)
+      $ECHO \
+"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
+
+Compile a source file into a libtool library object.
+
+This mode accepts the following additional options:
+
+  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
+  -no-suppress      do not suppress compiler output for multiple passes
+  -prefer-pic       try to build PIC objects only
+  -prefer-non-pic   try to build non-PIC objects only
+  -shared           do not build a '.o' file suitable for static linking
+  -static           only build a '.o' file suitable for static linking
+  -Wc,FLAG          pass FLAG directly to the compiler
+
+COMPILE-COMMAND is a command to be used in creating a 'standard' object file
+from the given SOURCEFILE.
+
+The output file name is determined by removing the directory component from
+SOURCEFILE, then substituting the C source code suffix '.c' with the
+library object suffix, '.lo'."
+        ;;
+
+      execute)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
+
+Automatically set library path, then run a program.
+
+This mode accepts the following additional options:
+
+  -dlopen FILE      add the directory containing FILE to the library path
+
+This mode sets the library path environment variable according to '-dlopen'
+flags.
+
+If any of the ARGS are libtool executable wrappers, then they are translated
+into their corresponding uninstalled binary, and any of their required library
+directories are added to the library path.
+
+Then, COMMAND is executed, with ARGS as arguments."
+        ;;
+
+      finish)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
+
+Complete the installation of libtool libraries.
+
+Each LIBDIR is a directory that contains libtool libraries.
+
+The commands that this mode executes may require superuser privileges.  Use
+the '--dry-run' option if you just want to see what would be executed."
+        ;;
+
+      install)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
+
+Install executables or libraries.
+
+INSTALL-COMMAND is the installation command.  The first component should be
+either the 'install' or 'cp' program.
+
+The following components of INSTALL-COMMAND are treated specially:
+
+  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
+
+The rest of the components are interpreted as arguments to that command (only
+BSD-compatible install options are recognized)."
+        ;;
+
+      link)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
+
+Link object files or libraries together to form another library, or to
+create an executable program.
+
+LINK-COMMAND is a command using the C compiler that you would use to create
+a program from several object files.
+
+The following components of LINK-COMMAND are treated specially:
+
+  -all-static       do not do any dynamic linking at all
+  -avoid-version    do not add a version suffix if possible
+  -bindir BINDIR    specify path to binaries directory (for systems where
+                    libraries must be found in the PATH setting at runtime)
+  -dlopen FILE      '-dlpreopen' FILE if it cannot be dlopened at runtime
+  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
+  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
+  -export-symbols SYMFILE
+                    try to export only the symbols listed in SYMFILE
+  -export-symbols-regex REGEX
+                    try to export only the symbols matching REGEX
+  -LLIBDIR          search LIBDIR for required installed libraries
+  -lNAME            OUTPUT-FILE requires the installed library libNAME
+  -module           build a library that can dlopened
+  -no-fast-install  disable the fast-install mode
+  -no-install       link a not-installable executable
+  -no-undefined     declare that a library does not refer to external symbols
+  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
+  -objectlist FILE  use a list of object files found in FILE to specify objects
+  -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)
+  -precious-files-regex REGEX
+                    don't remove output files matching REGEX
+  -release RELEASE  specify package release information
+  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
+  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
+  -shared           only do dynamic linking of libtool libraries
+  -shrext SUFFIX    override the standard shared library file extension
+  -static           do not do any dynamic linking of uninstalled libtool libraries
+  -static-libtool-libs
+                    do not do any dynamic linking of libtool libraries
+  -version-info CURRENT[:REVISION[:AGE]]
+                    specify library version info [each variable defaults to 0]
+  -weak LIBNAME     declare that the target provides the LIBNAME interface
+  -Wc,FLAG
+  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
+  -Wl,FLAG
+  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
+  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
+
+All other options (arguments beginning with '-') are ignored.
+
+Every other argument is treated as a filename.  Files ending in '.la' are
+treated as uninstalled libtool libraries, other files are standard or library
+object files.
+
+If the OUTPUT-FILE ends in '.la', then a libtool library is created,
+only library objects ('.lo' files) may be specified, and '-rpath' is
+required, except when creating a convenience library.
+
+If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
+using 'ar' and 'ranlib', or on Windows using 'lib'.
+
+If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
+is created, otherwise an executable program is created."
+        ;;
+
+      uninstall)
+        $ECHO \
+"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
+
+Remove libraries from an installation directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
+to RM.
+
+If FILE is a libtool library, all the files associated with it are deleted.
+Otherwise, only FILE itself is deleted using RM."
+        ;;
+
+      *)
+        func_fatal_help "invalid operation mode '$opt_mode'"
+        ;;
+    esac
+
+    echo
+    $ECHO "Try '$progname --help' for more information about other modes."
+}
+
+# Now that we've collected a possible --mode arg, show help if necessary
+if $opt_help; then
+  if test : = "$opt_help"; then
+    func_mode_help
+  else
+    {
+      func_help noexit
+      for opt_mode in compile link execute install finish uninstall clean; do
+	func_mode_help
+      done
+    } | $SED -n '1p; 2,$s/^Usage:/  or: /p'
+    {
+      func_help noexit
+      for opt_mode in compile link execute install finish uninstall clean; do
+	echo
+	func_mode_help
+      done
+    } |
+    $SED '1d
+      /^When reporting/,/^Report/{
+	H
+	d
+      }
+      $x
+      /information about other modes/d
+      /more detailed .*MODE/d
+      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
+  fi
+  exit $?
+fi
+
+
+# func_mode_execute arg...
+func_mode_execute ()
+{
+    $debug_cmd
+
+    # The first argument is the command name.
+    cmd=$nonopt
+    test -z "$cmd" && \
+      func_fatal_help "you must specify a COMMAND"
+
+    # Handle -dlopen flags immediately.
+    for file in $opt_dlopen; do
+      test -f "$file" \
+	|| func_fatal_help "'$file' is not a file"
+
+      dir=
+      case $file in
+      *.la)
+	func_resolve_sysroot "$file"
+	file=$func_resolve_sysroot_result
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$file" \
+	  || func_fatal_help "'$lib' is not a valid libtool archive"
+
+	# Read the libtool library.
+	dlname=
+	library_names=
+	func_source "$file"
+
+	# Skip this library if it cannot be dlopened.
+	if test -z "$dlname"; then
+	  # Warn if it was a shared library.
+	  test -n "$library_names" && \
+	    func_warning "'$file' was not linked with '-export-dynamic'"
+	  continue
+	fi
+
+	func_dirname "$file" "" "."
+	dir=$func_dirname_result
+
+	if test -f "$dir/$objdir/$dlname"; then
+	  func_append dir "/$objdir"
+	else
+	  if test ! -f "$dir/$dlname"; then
+	    func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
+	  fi
+	fi
+	;;
+
+      *.lo)
+	# Just add the directory containing the .lo file.
+	func_dirname "$file" "" "."
+	dir=$func_dirname_result
+	;;
+
+      *)
+	func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
+	continue
+	;;
+      esac
+
+      # Get the absolute pathname.
+      absdir=`cd "$dir" && pwd`
+      test -n "$absdir" && dir=$absdir
+
+      # Now add the directory to shlibpath_var.
+      if eval "test -z \"\$$shlibpath_var\""; then
+	eval "$shlibpath_var=\"\$dir\""
+      else
+	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+      fi
+    done
+
+    # This variable tells wrapper scripts just to set shlibpath_var
+    # rather than running their programs.
+    libtool_execute_magic=$magic
+
+    # Check if any of the arguments is a wrapper script.
+    args=
+    for file
+    do
+      case $file in
+      -* | *.la | *.lo ) ;;
+      *)
+	# Do a test to see if this is really a libtool program.
+	if func_ltwrapper_script_p "$file"; then
+	  func_source "$file"
+	  # Transform arg to wrapped name.
+	  file=$progdir/$program
+	elif func_ltwrapper_executable_p "$file"; then
+	  func_ltwrapper_scriptname "$file"
+	  func_source "$func_ltwrapper_scriptname_result"
+	  # Transform arg to wrapped name.
+	  file=$progdir/$program
+	fi
+	;;
+      esac
+      # Quote arguments (to preserve shell metacharacters).
+      func_append_quoted args "$file"
+    done
+
+    if $opt_dry_run; then
+      # Display what would be done.
+      if test -n "$shlibpath_var"; then
+	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
+	echo "export $shlibpath_var"
+      fi
+      $ECHO "$cmd$args"
+      exit $EXIT_SUCCESS
+    else
+      if test -n "$shlibpath_var"; then
+	# Export the shlibpath_var.
+	eval "export $shlibpath_var"
+      fi
+
+      # Restore saved environment variables
+      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+      do
+	eval "if test \"\${save_$lt_var+set}\" = set; then
+                $lt_var=\$save_$lt_var; export $lt_var
+	      else
+		$lt_unset $lt_var
+	      fi"
+      done
+
+      # Now prepare to actually exec the command.
+      exec_cmd=\$cmd$args
+    fi
+}
+
+test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
+
+
+# func_mode_finish arg...
+func_mode_finish ()
+{
+    $debug_cmd
+
+    libs=
+    libdirs=
+    admincmds=
+
+    for opt in "$nonopt" ${1+"$@"}
+    do
+      if test -d "$opt"; then
+	func_append libdirs " $opt"
+
+      elif test -f "$opt"; then
+	if func_lalib_unsafe_p "$opt"; then
+	  func_append libs " $opt"
+	else
+	  func_warning "'$opt' is not a valid libtool archive"
+	fi
+
+      else
+	func_fatal_error "invalid argument '$opt'"
+      fi
+    done
+
+    if test -n "$libs"; then
+      if test -n "$lt_sysroot"; then
+        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
+        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
+      else
+        sysroot_cmd=
+      fi
+
+      # Remove sysroot references
+      if $opt_dry_run; then
+        for lib in $libs; do
+          echo "removing references to $lt_sysroot and '=' prefixes from $lib"
+        done
+      else
+        tmpdir=`func_mktempdir`
+        for lib in $libs; do
+	  $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
+	    > $tmpdir/tmp-la
+	  mv -f $tmpdir/tmp-la $lib
+	done
+        ${RM}r "$tmpdir"
+      fi
+    fi
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      for libdir in $libdirs; do
+	if test -n "$finish_cmds"; then
+	  # Do each command in the finish commands.
+	  func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
+'"$cmd"'"'
+	fi
+	if test -n "$finish_eval"; then
+	  # Do the single finish_eval.
+	  eval cmds=\"$finish_eval\"
+	  $opt_dry_run || eval "$cmds" || func_append admincmds "
+       $cmds"
+	fi
+      done
+    fi
+
+    # Exit here if they wanted silent mode.
+    $opt_quiet && exit $EXIT_SUCCESS
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      echo "----------------------------------------------------------------------"
+      echo "Libraries have been installed in:"
+      for libdir in $libdirs; do
+	$ECHO "   $libdir"
+      done
+      echo
+      echo "If you ever happen to want to link against installed libraries"
+      echo "in a given directory, LIBDIR, you must either use libtool, and"
+      echo "specify the full pathname of the library, or use the '-LLIBDIR'"
+      echo "flag during linking and do at least one of the following:"
+      if test -n "$shlibpath_var"; then
+	echo "   - add LIBDIR to the '$shlibpath_var' environment variable"
+	echo "     during execution"
+      fi
+      if test -n "$runpath_var"; then
+	echo "   - add LIBDIR to the '$runpath_var' environment variable"
+	echo "     during linking"
+      fi
+      if test -n "$hardcode_libdir_flag_spec"; then
+	libdir=LIBDIR
+	eval flag=\"$hardcode_libdir_flag_spec\"
+
+	$ECHO "   - use the '$flag' linker flag"
+      fi
+      if test -n "$admincmds"; then
+	$ECHO "   - have your system administrator run these commands:$admincmds"
+      fi
+      if test -f /etc/ld.so.conf; then
+	echo "   - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
+      fi
+      echo
+
+      echo "See any operating system documentation about shared libraries for"
+      case $host in
+	solaris2.[6789]|solaris2.1[0-9])
+	  echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
+	  echo "pages."
+	  ;;
+	*)
+	  echo "more information, such as the ld(1) and ld.so(8) manual pages."
+	  ;;
+      esac
+      echo "----------------------------------------------------------------------"
+    fi
+    exit $EXIT_SUCCESS
+}
+
+test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
+
+
+# func_mode_install arg...
+func_mode_install ()
+{
+    $debug_cmd
+
+    # There may be an optional sh(1) argument at the beginning of
+    # install_prog (especially on Windows NT).
+    if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
+       # Allow the use of GNU shtool's install command.
+       case $nonopt in *shtool*) :;; *) false;; esac
+    then
+      # Aesthetically quote it.
+      func_quote_for_eval "$nonopt"
+      install_prog="$func_quote_for_eval_result "
+      arg=$1
+      shift
+    else
+      install_prog=
+      arg=$nonopt
+    fi
+
+    # The real first argument should be the name of the installation program.
+    # Aesthetically quote it.
+    func_quote_for_eval "$arg"
+    func_append install_prog "$func_quote_for_eval_result"
+    install_shared_prog=$install_prog
+    case " $install_prog " in
+      *[\\\ /]cp\ *) install_cp=: ;;
+      *) install_cp=false ;;
+    esac
+
+    # We need to accept at least all the BSD install flags.
+    dest=
+    files=
+    opts=
+    prev=
+    install_type=
+    isdir=false
+    stripme=
+    no_mode=:
+    for arg
+    do
+      arg2=
+      if test -n "$dest"; then
+	func_append files " $dest"
+	dest=$arg
+	continue
+      fi
+
+      case $arg in
+      -d) isdir=: ;;
+      -f)
+	if $install_cp; then :; else
+	  prev=$arg
+	fi
+	;;
+      -g | -m | -o)
+	prev=$arg
+	;;
+      -s)
+	stripme=" -s"
+	continue
+	;;
+      -*)
+	;;
+      *)
+	# If the previous option needed an argument, then skip it.
+	if test -n "$prev"; then
+	  if test X-m = "X$prev" && test -n "$install_override_mode"; then
+	    arg2=$install_override_mode
+	    no_mode=false
+	  fi
+	  prev=
+	else
+	  dest=$arg
+	  continue
+	fi
+	;;
+      esac
+
+      # Aesthetically quote the argument.
+      func_quote_for_eval "$arg"
+      func_append install_prog " $func_quote_for_eval_result"
+      if test -n "$arg2"; then
+	func_quote_for_eval "$arg2"
+      fi
+      func_append install_shared_prog " $func_quote_for_eval_result"
+    done
+
+    test -z "$install_prog" && \
+      func_fatal_help "you must specify an install program"
+
+    test -n "$prev" && \
+      func_fatal_help "the '$prev' option requires an argument"
+
+    if test -n "$install_override_mode" && $no_mode; then
+      if $install_cp; then :; else
+	func_quote_for_eval "$install_override_mode"
+	func_append install_shared_prog " -m $func_quote_for_eval_result"
+      fi
+    fi
+
+    if test -z "$files"; then
+      if test -z "$dest"; then
+	func_fatal_help "no file or destination specified"
+      else
+	func_fatal_help "you must specify a destination"
+      fi
+    fi
+
+    # Strip any trailing slash from the destination.
+    func_stripname '' '/' "$dest"
+    dest=$func_stripname_result
+
+    # Check to see that the destination is a directory.
+    test -d "$dest" && isdir=:
+    if $isdir; then
+      destdir=$dest
+      destname=
+    else
+      func_dirname_and_basename "$dest" "" "."
+      destdir=$func_dirname_result
+      destname=$func_basename_result
+
+      # Not a directory, so check to see that there is only one file specified.
+      set dummy $files; shift
+      test "$#" -gt 1 && \
+	func_fatal_help "'$dest' is not a directory"
+    fi
+    case $destdir in
+    [\\/]* | [A-Za-z]:[\\/]*) ;;
+    *)
+      for file in $files; do
+	case $file in
+	*.lo) ;;
+	*)
+	  func_fatal_help "'$destdir' must be an absolute directory name"
+	  ;;
+	esac
+      done
+      ;;
+    esac
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic=$magic
+
+    staticlibs=
+    future_libdirs=
+    current_libdirs=
+    for file in $files; do
+
+      # Do each installation.
+      case $file in
+      *.$libext)
+	# Do the static libraries later.
+	func_append staticlibs " $file"
+	;;
+
+      *.la)
+	func_resolve_sysroot "$file"
+	file=$func_resolve_sysroot_result
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$file" \
+	  || func_fatal_help "'$file' is not a valid libtool archive"
+
+	library_names=
+	old_library=
+	relink_command=
+	func_source "$file"
+
+	# Add the libdir to current_libdirs if it is the destination.
+	if test "X$destdir" = "X$libdir"; then
+	  case "$current_libdirs " in
+	  *" $libdir "*) ;;
+	  *) func_append current_libdirs " $libdir" ;;
+	  esac
+	else
+	  # Note the libdir as a future libdir.
+	  case "$future_libdirs " in
+	  *" $libdir "*) ;;
+	  *) func_append future_libdirs " $libdir" ;;
+	  esac
+	fi
+
+	func_dirname "$file" "/" ""
+	dir=$func_dirname_result
+	func_append dir "$objdir"
+
+	if test -n "$relink_command"; then
+	  # Determine the prefix the user has applied to our future dir.
+	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
+
+	  # Don't allow the user to place us outside of our expected
+	  # location b/c this prevents finding dependent libraries that
+	  # are installed to the same prefix.
+	  # At present, this check doesn't affect windows .dll's that
+	  # are installed into $libdir/../bin (currently, that works fine)
+	  # but it's something to keep an eye on.
+	  test "$inst_prefix_dir" = "$destdir" && \
+	    func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
+
+	  if test -n "$inst_prefix_dir"; then
+	    # Stick the inst_prefix_dir data into the link command.
+	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+	  else
+	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
+	  fi
+
+	  func_warning "relinking '$file'"
+	  func_show_eval "$relink_command" \
+	    'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
+	fi
+
+	# See the names of the shared library.
+	set dummy $library_names; shift
+	if test -n "$1"; then
+	  realname=$1
+	  shift
+
+	  srcname=$realname
+	  test -n "$relink_command" && srcname=${realname}T
+
+	  # Install the shared library and build the symlinks.
+	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
+	      'exit $?'
+	  tstripme=$stripme
+	  case $host_os in
+	  cygwin* | mingw* | pw32* | cegcc*)
+	    case $realname in
+	    *.dll.a)
+	      tstripme=
+	      ;;
+	    esac
+	    ;;
+	  os2*)
+	    case $realname in
+	    *_dll.a)
+	      tstripme=
+	      ;;
+	    esac
+	    ;;
+	  esac
+	  if test -n "$tstripme" && test -n "$striplib"; then
+	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
+	  fi
+
+	  if test "$#" -gt 0; then
+	    # Delete the old symlinks, and create new ones.
+	    # Try 'ln -sf' first, because the 'ln' binary might depend on
+	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
+	    # so we also need to try rm && ln -s.
+	    for linkname
+	    do
+	      test "$linkname" != "$realname" \
+		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
+	    done
+	  fi
+
+	  # Do each command in the postinstall commands.
+	  lib=$destdir/$realname
+	  func_execute_cmds "$postinstall_cmds" 'exit $?'
+	fi
+
+	# Install the pseudo-library for information purposes.
+	func_basename "$file"
+	name=$func_basename_result
+	instname=$dir/${name}i
+	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
+
+	# Maybe install the static library, too.
+	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
+	;;
+
+      *.lo)
+	# Install (i.e. copy) a libtool object.
+
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile=$destdir/$destname
+	else
+	  func_basename "$file"
+	  destfile=$func_basename_result
+	  destfile=$destdir/$destfile
+	fi
+
+	# Deduce the name of the destination old-style object file.
+	case $destfile in
+	*.lo)
+	  func_lo2o "$destfile"
+	  staticdest=$func_lo2o_result
+	  ;;
+	*.$objext)
+	  staticdest=$destfile
+	  destfile=
+	  ;;
+	*)
+	  func_fatal_help "cannot copy a libtool object to '$destfile'"
+	  ;;
+	esac
+
+	# Install the libtool object if requested.
+	test -n "$destfile" && \
+	  func_show_eval "$install_prog $file $destfile" 'exit $?'
+
+	# Install the old object if enabled.
+	if test yes = "$build_old_libs"; then
+	  # Deduce the name of the old-style object file.
+	  func_lo2o "$file"
+	  staticobj=$func_lo2o_result
+	  func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
+	fi
+	exit $EXIT_SUCCESS
+	;;
+
+      *)
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile=$destdir/$destname
+	else
+	  func_basename "$file"
+	  destfile=$func_basename_result
+	  destfile=$destdir/$destfile
+	fi
+
+	# If the file is missing, and there is a .exe on the end, strip it
+	# because it is most likely a libtool script we actually want to
+	# install
+	stripped_ext=
+	case $file in
+	  *.exe)
+	    if test ! -f "$file"; then
+	      func_stripname '' '.exe' "$file"
+	      file=$func_stripname_result
+	      stripped_ext=.exe
+	    fi
+	    ;;
+	esac
+
+	# Do a test to see if this is really a libtool program.
+	case $host in
+	*cygwin* | *mingw*)
+	    if func_ltwrapper_executable_p "$file"; then
+	      func_ltwrapper_scriptname "$file"
+	      wrapper=$func_ltwrapper_scriptname_result
+	    else
+	      func_stripname '' '.exe' "$file"
+	      wrapper=$func_stripname_result
+	    fi
+	    ;;
+	*)
+	    wrapper=$file
+	    ;;
+	esac
+	if func_ltwrapper_script_p "$wrapper"; then
+	  notinst_deplibs=
+	  relink_command=
+
+	  func_source "$wrapper"
+
+	  # Check the variables that should have been set.
+	  test -z "$generated_by_libtool_version" && \
+	    func_fatal_error "invalid libtool wrapper script '$wrapper'"
+
+	  finalize=:
+	  for lib in $notinst_deplibs; do
+	    # Check to see that each library is installed.
+	    libdir=
+	    if test -f "$lib"; then
+	      func_source "$lib"
+	    fi
+	    libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
+	    if test -n "$libdir" && test ! -f "$libfile"; then
+	      func_warning "'$lib' has not been installed in '$libdir'"
+	      finalize=false
+	    fi
+	  done
+
+	  relink_command=
+	  func_source "$wrapper"
+
+	  outputname=
+	  if test no = "$fast_install" && test -n "$relink_command"; then
+	    $opt_dry_run || {
+	      if $finalize; then
+	        tmpdir=`func_mktempdir`
+		func_basename "$file$stripped_ext"
+		file=$func_basename_result
+	        outputname=$tmpdir/$file
+	        # Replace the output file specification.
+	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
+
+	        $opt_quiet || {
+	          func_quote_for_expand "$relink_command"
+		  eval "func_echo $func_quote_for_expand_result"
+	        }
+	        if eval "$relink_command"; then :
+	          else
+		  func_error "error: relink '$file' with the above command before installing it"
+		  $opt_dry_run || ${RM}r "$tmpdir"
+		  continue
+	        fi
+	        file=$outputname
+	      else
+	        func_warning "cannot relink '$file'"
+	      fi
+	    }
+	  else
+	    # Install the binary that we compiled earlier.
+	    file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
+	  fi
+	fi
+
+	# remove .exe since cygwin /usr/bin/install will append another
+	# one anyway
+	case $install_prog,$host in
+	*/usr/bin/install*,*cygwin*)
+	  case $file:$destfile in
+	  *.exe:*.exe)
+	    # this is ok
+	    ;;
+	  *.exe:*)
+	    destfile=$destfile.exe
+	    ;;
+	  *:*.exe)
+	    func_stripname '' '.exe' "$destfile"
+	    destfile=$func_stripname_result
+	    ;;
+	  esac
+	  ;;
+	esac
+	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
+	$opt_dry_run || if test -n "$outputname"; then
+	  ${RM}r "$tmpdir"
+	fi
+	;;
+      esac
+    done
+
+    for file in $staticlibs; do
+      func_basename "$file"
+      name=$func_basename_result
+
+      # Set up the ranlib parameters.
+      oldlib=$destdir/$name
+      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+      tool_oldlib=$func_to_tool_file_result
+
+      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
+
+      if test -n "$stripme" && test -n "$old_striplib"; then
+	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
+      fi
+
+      # Do each command in the postinstall commands.
+      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
+    done
+
+    test -n "$future_libdirs" && \
+      func_warning "remember to run '$progname --finish$future_libdirs'"
+
+    if test -n "$current_libdirs"; then
+      # Maybe just do a dry run.
+      $opt_dry_run && current_libdirs=" -n$current_libdirs"
+      exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
+    else
+      exit $EXIT_SUCCESS
+    fi
+}
+
+test install = "$opt_mode" && func_mode_install ${1+"$@"}
+
+
+# func_generate_dlsyms outputname originator pic_p
+# Extract symbols from dlprefiles and create ${outputname}S.o with
+# a dlpreopen symbol table.
+func_generate_dlsyms ()
+{
+    $debug_cmd
+
+    my_outputname=$1
+    my_originator=$2
+    my_pic_p=${3-false}
+    my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
+    my_dlsyms=
+
+    if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+      if test -n "$NM" && test -n "$global_symbol_pipe"; then
+	my_dlsyms=${my_outputname}S.c
+      else
+	func_error "not configured to extract global symbols from dlpreopened files"
+      fi
+    fi
+
+    if test -n "$my_dlsyms"; then
+      case $my_dlsyms in
+      "") ;;
+      *.c)
+	# Discover the nlist of each of the dlfiles.
+	nlist=$output_objdir/$my_outputname.nm
+
+	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
+
+	# Parse the name list into a source file.
+	func_verbose "creating $output_objdir/$my_dlsyms"
+
+	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
+/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
+/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
+#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
+#endif
+
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
+   relocations are performed -- see ld's documentation on pseudo-relocs.  */
+# define LT_DLSYM_CONST
+#elif defined __osf__
+/* This system does not cope well with relocations in const data.  */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
+
+#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
+
+/* External symbol declarations for the compiler. */\
+"
+
+	if test yes = "$dlself"; then
+	  func_verbose "generating symbol list for '$output'"
+
+	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
+
+	  # Add our own program objects to the symbol list.
+	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	  for progfile in $progfiles; do
+	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
+	    func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
+	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
+	  done
+
+	  if test -n "$exclude_expsyms"; then
+	    $opt_dry_run || {
+	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	    }
+	  fi
+
+	  if test -n "$export_symbols_regex"; then
+	    $opt_dry_run || {
+	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	    }
+	  fi
+
+	  # Prepare the list of exported symbols
+	  if test -z "$export_symbols"; then
+	    export_symbols=$output_objdir/$outputname.exp
+	    $opt_dry_run || {
+	      $RM $export_symbols
+	      eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+	      case $host in
+	      *cygwin* | *mingw* | *cegcc* )
+                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+	        ;;
+	      esac
+	    }
+	  else
+	    $opt_dry_run || {
+	      eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	      case $host in
+	        *cygwin* | *mingw* | *cegcc* )
+	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+	          ;;
+	      esac
+	    }
+	  fi
+	fi
+
+	for dlprefile in $dlprefiles; do
+	  func_verbose "extracting global C symbols from '$dlprefile'"
+	  func_basename "$dlprefile"
+	  name=$func_basename_result
+          case $host in
+	    *cygwin* | *mingw* | *cegcc* )
+	      # if an import library, we need to obtain dlname
+	      if func_win32_import_lib_p "$dlprefile"; then
+	        func_tr_sh "$dlprefile"
+	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
+	        dlprefile_dlbasename=
+	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
+	          # Use subshell, to avoid clobbering current variable values
+	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
+	          if test -n "$dlprefile_dlname"; then
+	            func_basename "$dlprefile_dlname"
+	            dlprefile_dlbasename=$func_basename_result
+	          else
+	            # no lafile. user explicitly requested -dlpreopen <import library>.
+	            $sharedlib_from_linklib_cmd "$dlprefile"
+	            dlprefile_dlbasename=$sharedlib_from_linklib_result
+	          fi
+	        fi
+	        $opt_dry_run || {
+	          if test -n "$dlprefile_dlbasename"; then
+	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
+	          else
+	            func_warning "Could not compute DLL name from $name"
+	            eval '$ECHO ": $name " >> "$nlist"'
+	          fi
+	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
+	            $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
+	        }
+	      else # not an import lib
+	        $opt_dry_run || {
+	          eval '$ECHO ": $name " >> "$nlist"'
+	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+	        }
+	      fi
+	    ;;
+	    *)
+	      $opt_dry_run || {
+	        eval '$ECHO ": $name " >> "$nlist"'
+	        func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	        eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+	      }
+	    ;;
+          esac
+	done
+
+	$opt_dry_run || {
+	  # Make sure we have at least an empty file.
+	  test -f "$nlist" || : > "$nlist"
+
+	  if test -n "$exclude_expsyms"; then
+	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
+	    $MV "$nlist"T "$nlist"
+	  fi
+
+	  # Try sorting and uniquifying the output.
+	  if $GREP -v "^: " < "$nlist" |
+	      if sort -k 3 </dev/null >/dev/null 2>&1; then
+		sort -k 3
+	      else
+		sort +2
+	      fi |
+	      uniq > "$nlist"S; then
+	    :
+	  else
+	    $GREP -v "^: " < "$nlist" > "$nlist"S
+	  fi
+
+	  if test -f "$nlist"S; then
+	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
+	  else
+	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
+	  fi
+
+	  func_show_eval '$RM "${nlist}I"'
+	  if test -n "$global_symbol_to_import"; then
+	    eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
+	  fi
+
+	  echo >> "$output_objdir/$my_dlsyms" "\
+
+/* The mapping between symbol names and symbols.  */
+typedef struct {
+  const char *name;
+  void *address;
+} lt_dlsymlist;
+extern LT_DLSYM_CONST lt_dlsymlist
+lt_${my_prefix}_LTX_preloaded_symbols[];\
+"
+
+	  if test -s "$nlist"I; then
+	    echo >> "$output_objdir/$my_dlsyms" "\
+static void lt_syminit(void)
+{
+  LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
+  for (; symbol->name; ++symbol)
+    {"
+	    $SED 's/.*/      if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
+	    echo >> "$output_objdir/$my_dlsyms" "\
+    }
+}"
+	  fi
+	  echo >> "$output_objdir/$my_dlsyms" "\
+LT_DLSYM_CONST lt_dlsymlist
+lt_${my_prefix}_LTX_preloaded_symbols[] =
+{ {\"$my_originator\", (void *) 0},"
+
+	  if test -s "$nlist"I; then
+	    echo >> "$output_objdir/$my_dlsyms" "\
+  {\"@INIT@\", (void *) &lt_syminit},"
+	  fi
+
+	  case $need_lib_prefix in
+	  no)
+	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
+	    ;;
+	  *)
+	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
+	    ;;
+	  esac
+	  echo >> "$output_objdir/$my_dlsyms" "\
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt_${my_prefix}_LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif\
+"
+	} # !$opt_dry_run
+
+	pic_flag_for_symtable=
+	case "$compile_command " in
+	*" -static "*) ;;
+	*)
+	  case $host in
+	  # compiling the symbol table file with pic_flag works around
+	  # a FreeBSD bug that causes programs to crash when -lm is
+	  # linked before any other PIC object.  But we must not use
+	  # pic_flag when linking with -static.  The problem exists in
+	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
+	  *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
+	  *-*-hpux*)
+	    pic_flag_for_symtable=" $pic_flag"  ;;
+	  *)
+	    $my_pic_p && pic_flag_for_symtable=" $pic_flag"
+	    ;;
+	  esac
+	  ;;
+	esac
+	symtab_cflags=
+	for arg in $LTCFLAGS; do
+	  case $arg in
+	  -pie | -fpie | -fPIE) ;;
+	  *) func_append symtab_cflags " $arg" ;;
+	  esac
+	done
+
+	# Now compile the dynamic symbol file.
+	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
+
+	# Clean up the generated files.
+	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
+
+	# Transform the symbol file into the correct name.
+	symfileobj=$output_objdir/${my_outputname}S.$objext
+	case $host in
+	*cygwin* | *mingw* | *cegcc* )
+	  if test -f "$output_objdir/$my_outputname.def"; then
+	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+	  else
+	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  fi
+	  ;;
+	*)
+	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  ;;
+	esac
+	;;
+      *)
+	func_fatal_error "unknown suffix for '$my_dlsyms'"
+	;;
+      esac
+    else
+      # We keep going just in case the user didn't refer to
+      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
+      # really was required.
+
+      # Nullify the symbol file.
+      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
+      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
+    fi
+}
+
+# func_cygming_gnu_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is a GNU/binutils-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_gnu_implib_p ()
+{
+  $debug_cmd
+
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
+  test -n "$func_cygming_gnu_implib_tmp"
+}
+
+# func_cygming_ms_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is an MS-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_ms_implib_p ()
+{
+  $debug_cmd
+
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
+  test -n "$func_cygming_ms_implib_tmp"
+}
+
+# func_win32_libid arg
+# return the library type of file 'arg'
+#
+# Need a lot of goo to handle *both* DLLs and import libs
+# Has to be a shell function in order to 'eat' the argument
+# that is supplied when $file_magic_command is called.
+# Despite the name, also deal with 64 bit binaries.
+func_win32_libid ()
+{
+  $debug_cmd
+
+  win32_libid_type=unknown
+  win32_fileres=`file -L $1 2>/dev/null`
+  case $win32_fileres in
+  *ar\ archive\ import\ library*) # definitely import
+    win32_libid_type="x86 archive import"
+    ;;
+  *ar\ archive*) # could be an import, or static
+    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
+    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
+       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
+      case $nm_interface in
+      "MS dumpbin")
+	if func_cygming_ms_implib_p "$1" ||
+	   func_cygming_gnu_implib_p "$1"
+	then
+	  win32_nmres=import
+	else
+	  win32_nmres=
+	fi
+	;;
+      *)
+	func_to_tool_file "$1" func_convert_file_msys_to_w32
+	win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
+	  $SED -n -e '
+	    1,100{
+		/ I /{
+		    s|.*|import|
+		    p
+		    q
+		}
+	    }'`
+	;;
+      esac
+      case $win32_nmres in
+      import*)  win32_libid_type="x86 archive import";;
+      *)        win32_libid_type="x86 archive static";;
+      esac
+    fi
+    ;;
+  *DLL*)
+    win32_libid_type="x86 DLL"
+    ;;
+  *executable*) # but shell scripts are "executable" too...
+    case $win32_fileres in
+    *MS\ Windows\ PE\ Intel*)
+      win32_libid_type="x86 DLL"
+      ;;
+    esac
+    ;;
+  esac
+  $ECHO "$win32_libid_type"
+}
+
+# func_cygming_dll_for_implib ARG
+#
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+# Invoked by eval'ing the libtool variable
+#    $sharedlib_from_linklib_cmd
+# Result is available in the variable
+#    $sharedlib_from_linklib_result
+func_cygming_dll_for_implib ()
+{
+  $debug_cmd
+
+  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
+}
+
+# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
+#
+# The is the core of a fallback implementation of a
+# platform-specific function to extract the name of the
+# DLL associated with the specified import library LIBNAME.
+#
+# SECTION_NAME is either .idata$6 or .idata$7, depending
+# on the platform and compiler that created the implib.
+#
+# Echos the name of the DLL associated with the
+# specified import library.
+func_cygming_dll_for_implib_fallback_core ()
+{
+  $debug_cmd
+
+  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
+  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
+    $SED '/^Contents of section '"$match_literal"':/{
+      # Place marker at beginning of archive member dllname section
+      s/.*/====MARK====/
+      p
+      d
+    }
+    # These lines can sometimes be longer than 43 characters, but
+    # are always uninteresting
+    /:[	 ]*file format pe[i]\{,1\}-/d
+    /^In archive [^:]*:/d
+    # Ensure marker is printed
+    /^====MARK====/p
+    # Remove all lines with less than 43 characters
+    /^.\{43\}/!d
+    # From remaining lines, remove first 43 characters
+    s/^.\{43\}//' |
+    $SED -n '
+      # Join marker and all lines until next marker into a single line
+      /^====MARK====/ b para
+      H
+      $ b para
+      b
+      :para
+      x
+      s/\n//g
+      # Remove the marker
+      s/^====MARK====//
+      # Remove trailing dots and whitespace
+      s/[\. \t]*$//
+      # Print
+      /./p' |
+    # we now have a list, one entry per line, of the stringified
+    # contents of the appropriate section of all members of the
+    # archive that possess that section. Heuristic: eliminate
+    # all those that have a first or second character that is
+    # a '.' (that is, objdump's representation of an unprintable
+    # character.) This should work for all archives with less than
+    # 0x302f exports -- but will fail for DLLs whose name actually
+    # begins with a literal '.' or a single character followed by
+    # a '.'.
+    #
+    # Of those that remain, print the first one.
+    $SED -e '/^\./d;/^.\./d;q'
+}
+
+# func_cygming_dll_for_implib_fallback ARG
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+#
+# This fallback implementation is for use when $DLLTOOL
+# does not support the --identify-strict option.
+# Invoked by eval'ing the libtool variable
+#    $sharedlib_from_linklib_cmd
+# Result is available in the variable
+#    $sharedlib_from_linklib_result
+func_cygming_dll_for_implib_fallback ()
+{
+  $debug_cmd
+
+  if func_cygming_gnu_implib_p "$1"; then
+    # binutils import library
+    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
+  elif func_cygming_ms_implib_p "$1"; then
+    # ms-generated import library
+    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
+  else
+    # unknown
+    sharedlib_from_linklib_result=
+  fi
+}
+
+
+# func_extract_an_archive dir oldlib
+func_extract_an_archive ()
+{
+    $debug_cmd
+
+    f_ex_an_ar_dir=$1; shift
+    f_ex_an_ar_oldlib=$1
+    if test yes = "$lock_old_archive_extraction"; then
+      lockfile=$f_ex_an_ar_oldlib.lock
+      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+	func_echo "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    fi
+    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
+		   'stat=$?; rm -f "$lockfile"; exit $stat'
+    if test yes = "$lock_old_archive_extraction"; then
+      $opt_dry_run || rm -f "$lockfile"
+    fi
+    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+     :
+    else
+      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
+    fi
+}
+
+
+# func_extract_archives gentop oldlib ...
+func_extract_archives ()
+{
+    $debug_cmd
+
+    my_gentop=$1; shift
+    my_oldlibs=${1+"$@"}
+    my_oldobjs=
+    my_xlib=
+    my_xabs=
+    my_xdir=
+
+    for my_xlib in $my_oldlibs; do
+      # Extract the objects.
+      case $my_xlib in
+	[\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
+	*) my_xabs=`pwd`"/$my_xlib" ;;
+      esac
+      func_basename "$my_xlib"
+      my_xlib=$func_basename_result
+      my_xlib_u=$my_xlib
+      while :; do
+        case " $extracted_archives " in
+	*" $my_xlib_u "*)
+	  func_arith $extracted_serial + 1
+	  extracted_serial=$func_arith_result
+	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
+	*) break ;;
+	esac
+      done
+      extracted_archives="$extracted_archives $my_xlib_u"
+      my_xdir=$my_gentop/$my_xlib_u
+
+      func_mkdir_p "$my_xdir"
+
+      case $host in
+      *-darwin*)
+	func_verbose "Extracting $my_xabs"
+	# Do not bother doing anything if just a dry run
+	$opt_dry_run || {
+	  darwin_orig_dir=`pwd`
+	  cd $my_xdir || exit $?
+	  darwin_archive=$my_xabs
+	  darwin_curdir=`pwd`
+	  func_basename "$darwin_archive"
+	  darwin_base_archive=$func_basename_result
+	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
+	  if test -n "$darwin_arches"; then
+	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
+	    darwin_arch=
+	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
+	    for darwin_arch in  $darwin_arches; do
+	      func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
+	      $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
+	      cd "unfat-$$/$darwin_base_archive-$darwin_arch"
+	      func_extract_an_archive "`pwd`" "$darwin_base_archive"
+	      cd "$darwin_curdir"
+	      $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
+	    done # $darwin_arches
+            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
+	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
+	    darwin_file=
+	    darwin_files=
+	    for darwin_file in $darwin_filelist; do
+	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
+	      $LIPO -create -output "$darwin_file" $darwin_files
+	    done # $darwin_filelist
+	    $RM -rf unfat-$$
+	    cd "$darwin_orig_dir"
+	  else
+	    cd $darwin_orig_dir
+	    func_extract_an_archive "$my_xdir" "$my_xabs"
+	  fi # $darwin_arches
+	} # !$opt_dry_run
+	;;
+      *)
+        func_extract_an_archive "$my_xdir" "$my_xabs"
+	;;
+      esac
+      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
+    done
+
+    func_extract_archives_result=$my_oldobjs
+}
+
+
+# func_emit_wrapper [arg=no]
+#
+# Emit a libtool wrapper script on stdout.
+# Don't directly open a file because we may want to
+# incorporate the script contents within a cygwin/mingw
+# wrapper executable.  Must ONLY be called from within
+# func_mode_link because it depends on a number of variables
+# set therein.
+#
+# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
+# variable will take.  If 'yes', then the emitted script
+# will assume that the directory where it is stored is
+# the $objdir directory.  This is a cygwin/mingw-specific
+# behavior.
+func_emit_wrapper ()
+{
+	func_emit_wrapper_arg1=${1-no}
+
+	$ECHO "\
+#! $SHELL
+
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='$sed_quote_subst'
+
+# Be Bourne compatible
+if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
+fi
+BIN_SH=xpg4; export BIN_SH # for Tru64
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+relink_command=\"$relink_command\"
+
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+  # install mode needs the following variables:
+  generated_by_libtool_version='$macro_version'
+  notinst_deplibs='$notinst_deplibs'
+else
+  # When we are sourced in execute mode, \$file and \$ECHO are already set.
+  if test \"\$libtool_execute_magic\" != \"$magic\"; then
+    file=\"\$0\""
+
+    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
+    $ECHO "\
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+    ECHO=\"$qECHO\"
+  fi
+
+# Very basic option parsing. These options are (a) specific to
+# the libtool wrapper, (b) are identical between the wrapper
+# /script/ and the wrapper /executable/ that is used only on
+# windows platforms, and (c) all begin with the string "--lt-"
+# (application programs are unlikely to have options that match
+# this pattern).
+#
+# There are only two supported options: --lt-debug and
+# --lt-dump-script. There is, deliberately, no --lt-help.
+#
+# The first argument to this parsing function should be the
+# script's $0 value, followed by "$@".
+lt_option_debug=
+func_parse_lt_options ()
+{
+  lt_script_arg0=\$0
+  shift
+  for lt_opt
+  do
+    case \"\$lt_opt\" in
+    --lt-debug) lt_option_debug=1 ;;
+    --lt-dump-script)
+        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
+        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
+        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
+        cat \"\$lt_dump_D/\$lt_dump_F\"
+        exit 0
+      ;;
+    --lt-*)
+        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
+        exit 1
+      ;;
+    esac
+  done
+
+  # Print the debug banner immediately:
+  if test -n \"\$lt_option_debug\"; then
+    echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
+  fi
+}
+
+# Used when --lt-debug. Prints its arguments to stdout
+# (redirection is the responsibility of the caller)
+func_lt_dump_args ()
+{
+  lt_dump_args_N=1;
+  for lt_arg
+  do
+    \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
+    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
+  done
+}
+
+# Core function for launching the target application
+func_exec_program_core ()
+{
+"
+  case $host in
+  # Backslashes separate directories on plain windows
+  *-*-mingw | *-*-os2* | *-cegcc*)
+    $ECHO "\
+      if test -n \"\$lt_option_debug\"; then
+        \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
+        func_lt_dump_args \${1+\"\$@\"} 1>&2
+      fi
+      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+    ;;
+
+  *)
+    $ECHO "\
+      if test -n \"\$lt_option_debug\"; then
+        \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
+        func_lt_dump_args \${1+\"\$@\"} 1>&2
+      fi
+      exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+    ;;
+  esac
+  $ECHO "\
+      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
+      exit 1
+}
+
+# A function to encapsulate launching the target application
+# Strips options in the --lt-* namespace from \$@ and
+# launches target application with the remaining arguments.
+func_exec_program ()
+{
+  case \" \$* \" in
+  *\\ --lt-*)
+    for lt_wr_arg
+    do
+      case \$lt_wr_arg in
+      --lt-*) ;;
+      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
+      esac
+      shift
+    done ;;
+  esac
+  func_exec_program_core \${1+\"\$@\"}
+}
+
+  # Parse options
+  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
+
+  # Find the directory that this script lives in.
+  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
+  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+
+  # Follow symbolic links until we get to the real thisdir.
+  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
+  while test -n \"\$file\"; do
+    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
+
+    # If there was a directory component, then change thisdir.
+    if test \"x\$destdir\" != \"x\$file\"; then
+      case \"\$destdir\" in
+      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
+      *) thisdir=\"\$thisdir/\$destdir\" ;;
+      esac
+    fi
+
+    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
+    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
+  done
+
+  # Usually 'no', except on cygwin/mingw when embedded into
+  # the cwrapper.
+  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
+  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
+    # special case for '.'
+    if test \"\$thisdir\" = \".\"; then
+      thisdir=\`pwd\`
+    fi
+    # remove .libs from thisdir
+    case \"\$thisdir\" in
+    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
+    $objdir )   thisdir=. ;;
+    esac
+  fi
+
+  # Try to get the absolute directory name.
+  absdir=\`cd \"\$thisdir\" && pwd\`
+  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+
+	if test yes = "$fast_install"; then
+	  $ECHO "\
+  program=lt-'$outputname'$exeext
+  progdir=\"\$thisdir/$objdir\"
+
+  if test ! -f \"\$progdir/\$program\" ||
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
+       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+
+    file=\"\$\$-\$program\"
+
+    if test ! -d \"\$progdir\"; then
+      $MKDIR \"\$progdir\"
+    else
+      $RM \"\$progdir/\$file\"
+    fi"
+
+	  $ECHO "\
+
+    # relink executable if necessary
+    if test -n \"\$relink_command\"; then
+      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
+      else
+	\$ECHO \"\$relink_command_output\" >&2
+	$RM \"\$progdir/\$file\"
+	exit 1
+      fi
+    fi
+
+    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+    { $RM \"\$progdir/\$program\";
+      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+    $RM \"\$progdir/\$file\"
+  fi"
+	else
+	  $ECHO "\
+  program='$outputname'
+  progdir=\"\$thisdir/$objdir\"
+"
+	fi
+
+	$ECHO "\
+
+  if test -f \"\$progdir/\$program\"; then"
+
+	# fixup the dll searchpath if we need to.
+	#
+	# Fix the DLL searchpath if we need to.  Do this before prepending
+	# to shlibpath, because on Windows, both are PATH and uninstalled
+	# libraries must come first.
+	if test -n "$dllsearchpath"; then
+	  $ECHO "\
+    # Add the dll search path components to the executable PATH
+    PATH=$dllsearchpath:\$PATH
+"
+	fi
+
+	# Export our shlibpath_var if we have one.
+	if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	  $ECHO "\
+    # Add our own library path to $shlibpath_var
+    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+
+    # Some systems cannot cope with colon-terminated $shlibpath_var
+    # The second colon is a workaround for a bug in BeOS R4 sed
+    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
+
+    export $shlibpath_var
+"
+	fi
+
+	$ECHO "\
+    if test \"\$libtool_execute_magic\" != \"$magic\"; then
+      # Run the actual program with our arguments.
+      func_exec_program \${1+\"\$@\"}
+    fi
+  else
+    # The program doesn't exist.
+    \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
+    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
+    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
+    exit 1
+  fi
+fi\
+"
+}
+
+
+# func_emit_cwrapperexe_src
+# emit the source code for a wrapper executable on stdout
+# Must ONLY be called from within func_mode_link because
+# it depends on a number of variable set therein.
+func_emit_cwrapperexe_src ()
+{
+	cat <<EOF
+
+/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
+   Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+
+   The $output program cannot be directly executed until all the libtool
+   libraries that it depends on are installed.
+
+   This wrapper executable should never be moved out of the build directory.
+   If it is, it will not operate correctly.
+*/
+EOF
+	    cat <<"EOF"
+#ifdef _MSC_VER
+# define _CRT_SECURE_NO_DEPRECATE 1
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _MSC_VER
+# include <direct.h>
+# include <process.h>
+# include <io.h>
+#else
+# include <unistd.h>
+# include <stdint.h>
+# ifdef __CYGWIN__
+#  include <io.h>
+# endif
+#endif
+#include <malloc.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
+
+/* declarations of non-ANSI functions */
+#if defined __MINGW32__
+# ifdef __STRICT_ANSI__
+int _putenv (const char *);
+# endif
+#elif defined __CYGWIN__
+# ifdef __STRICT_ANSI__
+char *realpath (const char *, char *);
+int putenv (char *);
+int setenv (const char *, const char *, int);
+# endif
+/* #elif defined other_platform || defined ... */
+#endif
+
+/* portability defines, excluding path handling macros */
+#if defined _MSC_VER
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+# define S_IXUSR _S_IEXEC
+#elif defined __MINGW32__
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+#elif defined __CYGWIN__
+# define HAVE_SETENV
+# define FOPEN_WB "wb"
+/* #elif defined other platforms ... */
+#endif
+
+#if defined PATH_MAX
+# define LT_PATHMAX PATH_MAX
+#elif defined MAXPATHLEN
+# define LT_PATHMAX MAXPATHLEN
+#else
+# define LT_PATHMAX 1024
+#endif
+
+#ifndef S_IXOTH
+# define S_IXOTH 0
+#endif
+#ifndef S_IXGRP
+# define S_IXGRP 0
+#endif
+
+/* path handling portability macros */
+#ifndef DIR_SEPARATOR
+# define DIR_SEPARATOR '/'
+# define PATH_SEPARATOR ':'
+#endif
+
+#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
+  defined __OS2__
+# define HAVE_DOS_BASED_FILE_SYSTEM
+# define FOPEN_WB "wb"
+# ifndef DIR_SEPARATOR_2
+#  define DIR_SEPARATOR_2 '\\'
+# endif
+# ifndef PATH_SEPARATOR_2
+#  define PATH_SEPARATOR_2 ';'
+# endif
+#endif
+
+#ifndef DIR_SEPARATOR_2
+# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
+#else /* DIR_SEPARATOR_2 */
+# define IS_DIR_SEPARATOR(ch) \
+	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
+#endif /* DIR_SEPARATOR_2 */
+
+#ifndef PATH_SEPARATOR_2
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
+#else /* PATH_SEPARATOR_2 */
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
+#endif /* PATH_SEPARATOR_2 */
+
+#ifndef FOPEN_WB
+# define FOPEN_WB "w"
+#endif
+#ifndef _O_BINARY
+# define _O_BINARY 0
+#endif
+
+#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
+#define XFREE(stale) do { \
+  if (stale) { free (stale); stale = 0; } \
+} while (0)
+
+#if defined LT_DEBUGWRAPPER
+static int lt_debug = 1;
+#else
+static int lt_debug = 0;
+#endif
+
+const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
+
+void *xmalloc (size_t num);
+char *xstrdup (const char *string);
+const char *base_name (const char *name);
+char *find_executable (const char *wrapper);
+char *chase_symlinks (const char *pathspec);
+int make_executable (const char *path);
+int check_executable (const char *path);
+char *strendzap (char *str, const char *pat);
+void lt_debugprintf (const char *file, int line, const char *fmt, ...);
+void lt_fatal (const char *file, int line, const char *message, ...);
+static const char *nonnull (const char *s);
+static const char *nonempty (const char *s);
+void lt_setenv (const char *name, const char *value);
+char *lt_extend_str (const char *orig_value, const char *add, int to_end);
+void lt_update_exe_path (const char *name, const char *value);
+void lt_update_lib_path (const char *name, const char *value);
+char **prepare_spawn (char **argv);
+void lt_dump_script (FILE *f);
+EOF
+
+	    cat <<EOF
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+# define externally_visible volatile
+#else
+# define externally_visible __attribute__((externally_visible)) volatile
+#endif
+externally_visible const char * MAGIC_EXE = "$magic_exe";
+const char * LIB_PATH_VARNAME = "$shlibpath_var";
+EOF
+
+	    if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+              func_to_host_path "$temp_rpath"
+	      cat <<EOF
+const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
+EOF
+	    else
+	      cat <<"EOF"
+const char * LIB_PATH_VALUE   = "";
+EOF
+	    fi
+
+	    if test -n "$dllsearchpath"; then
+              func_to_host_path "$dllsearchpath:"
+	      cat <<EOF
+const char * EXE_PATH_VARNAME = "PATH";
+const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
+EOF
+	    else
+	      cat <<"EOF"
+const char * EXE_PATH_VARNAME = "";
+const char * EXE_PATH_VALUE   = "";
+EOF
+	    fi
+
+	    if test yes = "$fast_install"; then
+	      cat <<EOF
+const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
+EOF
+	    else
+	      cat <<EOF
+const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
+EOF
+	    fi
+
+
+	    cat <<"EOF"
+
+#define LTWRAPPER_OPTION_PREFIX         "--lt-"
+
+static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
+static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
+static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
+
+int
+main (int argc, char *argv[])
+{
+  char **newargz;
+  int  newargc;
+  char *tmp_pathspec;
+  char *actual_cwrapper_path;
+  char *actual_cwrapper_name;
+  char *target_name;
+  char *lt_argv_zero;
+  int rval = 127;
+
+  int i;
+
+  program_name = (char *) xstrdup (base_name (argv[0]));
+  newargz = XMALLOC (char *, (size_t) argc + 1);
+
+  /* very simple arg parsing; don't want to rely on getopt
+   * also, copy all non cwrapper options to newargz, except
+   * argz[0], which is handled differently
+   */
+  newargc=0;
+  for (i = 1; i < argc; i++)
+    {
+      if (STREQ (argv[i], dumpscript_opt))
+	{
+EOF
+	    case $host in
+	      *mingw* | *cygwin* )
+		# make stdout use "unix" line endings
+		echo "          setmode(1,_O_BINARY);"
+		;;
+	      esac
+
+	    cat <<"EOF"
+	  lt_dump_script (stdout);
+	  return 0;
+	}
+      if (STREQ (argv[i], debug_opt))
+	{
+          lt_debug = 1;
+          continue;
+	}
+      if (STREQ (argv[i], ltwrapper_option_prefix))
+        {
+          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
+             namespace, but it is not one of the ones we know about and
+             have already dealt with, above (inluding dump-script), then
+             report an error. Otherwise, targets might begin to believe
+             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
+             namespace. The first time any user complains about this, we'll
+             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
+             or a configure.ac-settable value.
+           */
+          lt_fatal (__FILE__, __LINE__,
+		    "unrecognized %s option: '%s'",
+                    ltwrapper_option_prefix, argv[i]);
+        }
+      /* otherwise ... */
+      newargz[++newargc] = xstrdup (argv[i]);
+    }
+  newargz[++newargc] = NULL;
+
+EOF
+	    cat <<EOF
+  /* The GNU banner must be the first non-error debug message */
+  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
+EOF
+	    cat <<"EOF"
+  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
+  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
+
+  tmp_pathspec = find_executable (argv[0]);
+  if (tmp_pathspec == NULL)
+    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) found exe (before symlink chase) at: %s\n",
+		  tmp_pathspec);
+
+  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) found exe (after symlink chase) at: %s\n",
+		  actual_cwrapper_path);
+  XFREE (tmp_pathspec);
+
+  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
+  strendzap (actual_cwrapper_path, actual_cwrapper_name);
+
+  /* wrapper name transforms */
+  strendzap (actual_cwrapper_name, ".exe");
+  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
+  XFREE (actual_cwrapper_name);
+  actual_cwrapper_name = tmp_pathspec;
+  tmp_pathspec = 0;
+
+  /* target_name transforms -- use actual target program name; might have lt- prefix */
+  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
+  strendzap (target_name, ".exe");
+  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
+  XFREE (target_name);
+  target_name = tmp_pathspec;
+  tmp_pathspec = 0;
+
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(main) libtool target name: %s\n",
+		  target_name);
+EOF
+
+	    cat <<EOF
+  newargz[0] =
+    XMALLOC (char, (strlen (actual_cwrapper_path) +
+		    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
+  strcpy (newargz[0], actual_cwrapper_path);
+  strcat (newargz[0], "$objdir");
+  strcat (newargz[0], "/");
+EOF
+
+	    cat <<"EOF"
+  /* stop here, and copy so we don't have to do this twice */
+  tmp_pathspec = xstrdup (newargz[0]);
+
+  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
+  strcat (newargz[0], actual_cwrapper_name);
+
+  /* DO want the lt- prefix here if it exists, so use target_name */
+  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
+  XFREE (tmp_pathspec);
+  tmp_pathspec = NULL;
+EOF
+
+	    case $host_os in
+	      mingw*)
+	    cat <<"EOF"
+  {
+    char* p;
+    while ((p = strchr (newargz[0], '\\')) != NULL)
+      {
+	*p = '/';
+      }
+    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
+      {
+	*p = '/';
+      }
+  }
+EOF
+	    ;;
+	    esac
+
+	    cat <<"EOF"
+  XFREE (target_name);
+  XFREE (actual_cwrapper_path);
+  XFREE (actual_cwrapper_name);
+
+  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
+  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
+  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
+     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
+     because on Windows, both *_VARNAMEs are PATH but uninstalled
+     libraries must come first. */
+  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
+  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
+
+  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
+		  nonnull (lt_argv_zero));
+  for (i = 0; i < newargc; i++)
+    {
+      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
+		      i, nonnull (newargz[i]));
+    }
+
+EOF
+
+	    case $host_os in
+	      mingw*)
+		cat <<"EOF"
+  /* execv doesn't actually work on mingw as expected on unix */
+  newargz = prepare_spawn (newargz);
+  rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
+  if (rval == -1)
+    {
+      /* failed to start process */
+      lt_debugprintf (__FILE__, __LINE__,
+		      "(main) failed to launch target \"%s\": %s\n",
+		      lt_argv_zero, nonnull (strerror (errno)));
+      return 127;
+    }
+  return rval;
+EOF
+		;;
+	      *)
+		cat <<"EOF"
+  execv (lt_argv_zero, newargz);
+  return rval; /* =127, but avoids unused variable warning */
+EOF
+		;;
+	    esac
+
+	    cat <<"EOF"
+}
+
+void *
+xmalloc (size_t num)
+{
+  void *p = (void *) malloc (num);
+  if (!p)
+    lt_fatal (__FILE__, __LINE__, "memory exhausted");
+
+  return p;
+}
+
+char *
+xstrdup (const char *string)
+{
+  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
+			  string) : NULL;
+}
+
+const char *
+base_name (const char *name)
+{
+  const char *base;
+
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+  /* Skip over the disk name in MSDOS pathnames. */
+  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
+    name += 2;
+#endif
+
+  for (base = name; *name; name++)
+    if (IS_DIR_SEPARATOR (*name))
+      base = name + 1;
+  return base;
+}
+
+int
+check_executable (const char *path)
+{
+  struct stat st;
+
+  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
+                  nonempty (path));
+  if ((!path) || (!*path))
+    return 0;
+
+  if ((stat (path, &st) >= 0)
+      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
+    return 1;
+  else
+    return 0;
+}
+
+int
+make_executable (const char *path)
+{
+  int rval = 0;
+  struct stat st;
+
+  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
+                  nonempty (path));
+  if ((!path) || (!*path))
+    return 0;
+
+  if (stat (path, &st) >= 0)
+    {
+      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
+    }
+  return rval;
+}
+
+/* Searches for the full path of the wrapper.  Returns
+   newly allocated full path name if found, NULL otherwise
+   Does not chase symlinks, even on platforms that support them.
+*/
+char *
+find_executable (const char *wrapper)
+{
+  int has_slash = 0;
+  const char *p;
+  const char *p_next;
+  /* static buffer for getcwd */
+  char tmp[LT_PATHMAX + 1];
+  size_t tmp_len;
+  char *concat_name;
+
+  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
+                  nonempty (wrapper));
+
+  if ((wrapper == NULL) || (*wrapper == '\0'))
+    return NULL;
+
+  /* Absolute path? */
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
+    {
+      concat_name = xstrdup (wrapper);
+      if (check_executable (concat_name))
+	return concat_name;
+      XFREE (concat_name);
+    }
+  else
+    {
+#endif
+      if (IS_DIR_SEPARATOR (wrapper[0]))
+	{
+	  concat_name = xstrdup (wrapper);
+	  if (check_executable (concat_name))
+	    return concat_name;
+	  XFREE (concat_name);
+	}
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+    }
+#endif
+
+  for (p = wrapper; *p; p++)
+    if (*p == '/')
+      {
+	has_slash = 1;
+	break;
+      }
+  if (!has_slash)
+    {
+      /* no slashes; search PATH */
+      const char *path = getenv ("PATH");
+      if (path != NULL)
+	{
+	  for (p = path; *p; p = p_next)
+	    {
+	      const char *q;
+	      size_t p_len;
+	      for (q = p; *q; q++)
+		if (IS_PATH_SEPARATOR (*q))
+		  break;
+	      p_len = (size_t) (q - p);
+	      p_next = (*q == '\0' ? q : q + 1);
+	      if (p_len == 0)
+		{
+		  /* empty path: current directory */
+		  if (getcwd (tmp, LT_PATHMAX) == NULL)
+		    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+                              nonnull (strerror (errno)));
+		  tmp_len = strlen (tmp);
+		  concat_name =
+		    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
+		  memcpy (concat_name, tmp, tmp_len);
+		  concat_name[tmp_len] = '/';
+		  strcpy (concat_name + tmp_len + 1, wrapper);
+		}
+	      else
+		{
+		  concat_name =
+		    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
+		  memcpy (concat_name, p, p_len);
+		  concat_name[p_len] = '/';
+		  strcpy (concat_name + p_len + 1, wrapper);
+		}
+	      if (check_executable (concat_name))
+		return concat_name;
+	      XFREE (concat_name);
+	    }
+	}
+      /* not found in PATH; assume curdir */
+    }
+  /* Relative path | not found in path: prepend cwd */
+  if (getcwd (tmp, LT_PATHMAX) == NULL)
+    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+              nonnull (strerror (errno)));
+  tmp_len = strlen (tmp);
+  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
+  memcpy (concat_name, tmp, tmp_len);
+  concat_name[tmp_len] = '/';
+  strcpy (concat_name + tmp_len + 1, wrapper);
+
+  if (check_executable (concat_name))
+    return concat_name;
+  XFREE (concat_name);
+  return NULL;
+}
+
+char *
+chase_symlinks (const char *pathspec)
+{
+#ifndef S_ISLNK
+  return xstrdup (pathspec);
+#else
+  char buf[LT_PATHMAX];
+  struct stat s;
+  char *tmp_pathspec = xstrdup (pathspec);
+  char *p;
+  int has_symlinks = 0;
+  while (strlen (tmp_pathspec) && !has_symlinks)
+    {
+      lt_debugprintf (__FILE__, __LINE__,
+		      "checking path component for symlinks: %s\n",
+		      tmp_pathspec);
+      if (lstat (tmp_pathspec, &s) == 0)
+	{
+	  if (S_ISLNK (s.st_mode) != 0)
+	    {
+	      has_symlinks = 1;
+	      break;
+	    }
+
+	  /* search backwards for last DIR_SEPARATOR */
+	  p = tmp_pathspec + strlen (tmp_pathspec) - 1;
+	  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
+	    p--;
+	  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
+	    {
+	      /* no more DIR_SEPARATORS left */
+	      break;
+	    }
+	  *p = '\0';
+	}
+      else
+	{
+	  lt_fatal (__FILE__, __LINE__,
+		    "error accessing file \"%s\": %s",
+		    tmp_pathspec, nonnull (strerror (errno)));
+	}
+    }
+  XFREE (tmp_pathspec);
+
+  if (!has_symlinks)
+    {
+      return xstrdup (pathspec);
+    }
+
+  tmp_pathspec = realpath (pathspec, buf);
+  if (tmp_pathspec == 0)
+    {
+      lt_fatal (__FILE__, __LINE__,
+		"could not follow symlinks for %s", pathspec);
+    }
+  return xstrdup (tmp_pathspec);
+#endif
+}
+
+char *
+strendzap (char *str, const char *pat)
+{
+  size_t len, patlen;
+
+  assert (str != NULL);
+  assert (pat != NULL);
+
+  len = strlen (str);
+  patlen = strlen (pat);
+
+  if (patlen <= len)
+    {
+      str += len - patlen;
+      if (STREQ (str, pat))
+	*str = '\0';
+    }
+  return str;
+}
+
+void
+lt_debugprintf (const char *file, int line, const char *fmt, ...)
+{
+  va_list args;
+  if (lt_debug)
+    {
+      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
+      va_start (args, fmt);
+      (void) vfprintf (stderr, fmt, args);
+      va_end (args);
+    }
+}
+
+static void
+lt_error_core (int exit_status, const char *file,
+	       int line, const char *mode,
+	       const char *message, va_list ap)
+{
+  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
+  vfprintf (stderr, message, ap);
+  fprintf (stderr, ".\n");
+
+  if (exit_status >= 0)
+    exit (exit_status);
+}
+
+void
+lt_fatal (const char *file, int line, const char *message, ...)
+{
+  va_list ap;
+  va_start (ap, message);
+  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
+  va_end (ap);
+}
+
+static const char *
+nonnull (const char *s)
+{
+  return s ? s : "(null)";
+}
+
+static const char *
+nonempty (const char *s)
+{
+  return (s && !*s) ? "(empty)" : nonnull (s);
+}
+
+void
+lt_setenv (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_setenv) setting '%s' to '%s'\n",
+                  nonnull (name), nonnull (value));
+  {
+#ifdef HAVE_SETENV
+    /* always make a copy, for consistency with !HAVE_SETENV */
+    char *str = xstrdup (value);
+    setenv (name, str, 1);
+#else
+    size_t len = strlen (name) + 1 + strlen (value) + 1;
+    char *str = XMALLOC (char, len);
+    sprintf (str, "%s=%s", name, value);
+    if (putenv (str) != EXIT_SUCCESS)
+      {
+        XFREE (str);
+      }
+#endif
+  }
+}
+
+char *
+lt_extend_str (const char *orig_value, const char *add, int to_end)
+{
+  char *new_value;
+  if (orig_value && *orig_value)
+    {
+      size_t orig_value_len = strlen (orig_value);
+      size_t add_len = strlen (add);
+      new_value = XMALLOC (char, add_len + orig_value_len + 1);
+      if (to_end)
+        {
+          strcpy (new_value, orig_value);
+          strcpy (new_value + orig_value_len, add);
+        }
+      else
+        {
+          strcpy (new_value, add);
+          strcpy (new_value + add_len, orig_value);
+        }
+    }
+  else
+    {
+      new_value = xstrdup (add);
+    }
+  return new_value;
+}
+
+void
+lt_update_exe_path (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
+                  nonnull (name), nonnull (value));
+
+  if (name && *name && value && *value)
+    {
+      char *new_value = lt_extend_str (getenv (name), value, 0);
+      /* some systems can't cope with a ':'-terminated path #' */
+      size_t len = strlen (new_value);
+      while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
+        {
+          new_value[--len] = '\0';
+        }
+      lt_setenv (name, new_value);
+      XFREE (new_value);
+    }
+}
+
+void
+lt_update_lib_path (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
+                  nonnull (name), nonnull (value));
+
+  if (name && *name && value && *value)
+    {
+      char *new_value = lt_extend_str (getenv (name), value, 0);
+      lt_setenv (name, new_value);
+      XFREE (new_value);
+    }
+}
+
+EOF
+	    case $host_os in
+	      mingw*)
+		cat <<"EOF"
+
+/* Prepares an argument vector before calling spawn().
+   Note that spawn() does not by itself call the command interpreter
+     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
+      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+         GetVersionEx(&v);
+         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
+      }) ? "cmd.exe" : "command.com").
+   Instead it simply concatenates the arguments, separated by ' ', and calls
+   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
+   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
+   special way:
+   - Space and tab are interpreted as delimiters. They are not treated as
+     delimiters if they are surrounded by double quotes: "...".
+   - Unescaped double quotes are removed from the input. Their only effect is
+     that within double quotes, space and tab are treated like normal
+     characters.
+   - Backslashes not followed by double quotes are not special.
+   - But 2*n+1 backslashes followed by a double quote become
+     n backslashes followed by a double quote (n >= 0):
+       \" -> "
+       \\\" -> \"
+       \\\\\" -> \\"
+ */
+#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+char **
+prepare_spawn (char **argv)
+{
+  size_t argc;
+  char **new_argv;
+  size_t i;
+
+  /* Count number of arguments.  */
+  for (argc = 0; argv[argc] != NULL; argc++)
+    ;
+
+  /* Allocate new argument vector.  */
+  new_argv = XMALLOC (char *, argc + 1);
+
+  /* Put quoted arguments into the new argument vector.  */
+  for (i = 0; i < argc; i++)
+    {
+      const char *string = argv[i];
+
+      if (string[0] == '\0')
+	new_argv[i] = xstrdup ("\"\"");
+      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
+	{
+	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
+	  size_t length;
+	  unsigned int backslashes;
+	  const char *s;
+	  char *quoted_string;
+	  char *p;
+
+	  length = 0;
+	  backslashes = 0;
+	  if (quote_around)
+	    length++;
+	  for (s = string; *s != '\0'; s++)
+	    {
+	      char c = *s;
+	      if (c == '"')
+		length += backslashes + 1;
+	      length++;
+	      if (c == '\\')
+		backslashes++;
+	      else
+		backslashes = 0;
+	    }
+	  if (quote_around)
+	    length += backslashes + 1;
+
+	  quoted_string = XMALLOC (char, length + 1);
+
+	  p = quoted_string;
+	  backslashes = 0;
+	  if (quote_around)
+	    *p++ = '"';
+	  for (s = string; *s != '\0'; s++)
+	    {
+	      char c = *s;
+	      if (c == '"')
+		{
+		  unsigned int j;
+		  for (j = backslashes + 1; j > 0; j--)
+		    *p++ = '\\';
+		}
+	      *p++ = c;
+	      if (c == '\\')
+		backslashes++;
+	      else
+		backslashes = 0;
+	    }
+	  if (quote_around)
+	    {
+	      unsigned int j;
+	      for (j = backslashes; j > 0; j--)
+		*p++ = '\\';
+	      *p++ = '"';
+	    }
+	  *p = '\0';
+
+	  new_argv[i] = quoted_string;
+	}
+      else
+	new_argv[i] = (char *) string;
+    }
+  new_argv[argc] = NULL;
+
+  return new_argv;
+}
+EOF
+		;;
+	    esac
+
+            cat <<"EOF"
+void lt_dump_script (FILE* f)
+{
+EOF
+	    func_emit_wrapper yes |
+	      $SED -n -e '
+s/^\(.\{79\}\)\(..*\)/\1\
+\2/
+h
+s/\([\\"]\)/\\\1/g
+s/$/\\n/
+s/\([^\n]*\).*/  fputs ("\1", f);/p
+g
+D'
+            cat <<"EOF"
+}
+EOF
+}
+# end: func_emit_cwrapperexe_src
+
+# func_win32_import_lib_p ARG
+# True if ARG is an import lib, as indicated by $file_magic_cmd
+func_win32_import_lib_p ()
+{
+    $debug_cmd
+
+    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
+    *import*) : ;;
+    *) false ;;
+    esac
+}
+
+# func_suncc_cstd_abi
+# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
+# Several compiler flags select an ABI that is incompatible with the
+# Cstd library. Avoid specifying it if any are in CXXFLAGS.
+func_suncc_cstd_abi ()
+{
+    $debug_cmd
+
+    case " $compile_command " in
+    *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
+      suncc_use_cstd_abi=no
+      ;;
+    *)
+      suncc_use_cstd_abi=yes
+      ;;
+    esac
+}
+
+# func_mode_link arg...
+func_mode_link ()
+{
+    $debug_cmd
+
+    case $host in
+    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+      # It is impossible to link a dll without this setting, and
+      # we shouldn't force the makefile maintainer to figure out
+      # what system we are compiling for in order to pass an extra
+      # flag for every libtool invocation.
+      # allow_undefined=no
+
+      # FIXME: Unfortunately, there are problems with the above when trying
+      # to make a dll that has undefined symbols, in which case not
+      # even a static library is built.  For now, we need to specify
+      # -no-undefined on the libtool link line when we can be certain
+      # that all symbols are satisfied, otherwise we get a static library.
+      allow_undefined=yes
+      ;;
+    *)
+      allow_undefined=yes
+      ;;
+    esac
+    libtool_args=$nonopt
+    base_compile="$nonopt $@"
+    compile_command=$nonopt
+    finalize_command=$nonopt
+
+    compile_rpath=
+    finalize_rpath=
+    compile_shlibpath=
+    finalize_shlibpath=
+    convenience=
+    old_convenience=
+    deplibs=
+    old_deplibs=
+    compiler_flags=
+    linker_flags=
+    dllsearchpath=
+    lib_search_path=`pwd`
+    inst_prefix_dir=
+    new_inherited_linker_flags=
+
+    avoid_version=no
+    bindir=
+    dlfiles=
+    dlprefiles=
+    dlself=no
+    export_dynamic=no
+    export_symbols=
+    export_symbols_regex=
+    generated=
+    libobjs=
+    ltlibs=
+    module=no
+    no_install=no
+    objs=
+    os2dllname=
+    non_pic_objects=
+    precious_files_regex=
+    prefer_static_libs=no
+    preload=false
+    prev=
+    prevarg=
+    release=
+    rpath=
+    xrpath=
+    perm_rpath=
+    temp_rpath=
+    thread_safe=no
+    vinfo=
+    vinfo_number=no
+    weak_libs=
+    single_module=$wl-single_module
+    func_infer_tag $base_compile
+
+    # We need to know -static, to get the right output filenames.
+    for arg
+    do
+      case $arg in
+      -shared)
+	test yes != "$build_libtool_libs" \
+	  && func_fatal_configuration "cannot build a shared library"
+	build_old_libs=no
+	break
+	;;
+      -all-static | -static | -static-libtool-libs)
+	case $arg in
+	-all-static)
+	  if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
+	    func_warning "complete static linking is impossible in this configuration"
+	  fi
+	  if test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	  ;;
+	-static)
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=built
+	  ;;
+	-static-libtool-libs)
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	  ;;
+	esac
+	build_libtool_libs=no
+	build_old_libs=yes
+	break
+	;;
+      esac
+    done
+
+    # See if our shared archives depend on static archives.
+    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
+
+    # Go through the arguments, transforming them on the way.
+    while test "$#" -gt 0; do
+      arg=$1
+      shift
+      func_quote_for_eval "$arg"
+      qarg=$func_quote_for_eval_unquoted_result
+      func_append libtool_args " $func_quote_for_eval_result"
+
+      # If the previous option needs an argument, assign it.
+      if test -n "$prev"; then
+	case $prev in
+	output)
+	  func_append compile_command " @OUTPUT@"
+	  func_append finalize_command " @OUTPUT@"
+	  ;;
+	esac
+
+	case $prev in
+	bindir)
+	  bindir=$arg
+	  prev=
+	  continue
+	  ;;
+	dlfiles|dlprefiles)
+	  $preload || {
+	    # Add the symbol object into the linking commands.
+	    func_append compile_command " @SYMFILE@"
+	    func_append finalize_command " @SYMFILE@"
+	    preload=:
+	  }
+	  case $arg in
+	  *.la | *.lo) ;;  # We handle these cases below.
+	  force)
+	    if test no = "$dlself"; then
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  self)
+	    if test dlprefiles = "$prev"; then
+	      dlself=yes
+	    elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
+	      dlself=yes
+	    else
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  *)
+	    if test dlfiles = "$prev"; then
+	      func_append dlfiles " $arg"
+	    else
+	      func_append dlprefiles " $arg"
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  esac
+	  ;;
+	expsyms)
+	  export_symbols=$arg
+	  test -f "$arg" \
+	    || func_fatal_error "symbol file '$arg' does not exist"
+	  prev=
+	  continue
+	  ;;
+	expsyms_regex)
+	  export_symbols_regex=$arg
+	  prev=
+	  continue
+	  ;;
+	framework)
+	  case $host in
+	    *-*-darwin*)
+	      case "$deplibs " in
+		*" $qarg.ltframework "*) ;;
+		*) func_append deplibs " $qarg.ltframework" # this is fixed later
+		   ;;
+	      esac
+	      ;;
+	  esac
+	  prev=
+	  continue
+	  ;;
+	inst_prefix)
+	  inst_prefix_dir=$arg
+	  prev=
+	  continue
+	  ;;
+	mllvm)
+	  # Clang does not use LLVM to link, so we can simply discard any
+	  # '-mllvm $arg' options when doing the link step.
+	  prev=
+	  continue
+	  ;;
+	objectlist)
+	  if test -f "$arg"; then
+	    save_arg=$arg
+	    moreargs=
+	    for fil in `cat "$save_arg"`
+	    do
+#	      func_append moreargs " $fil"
+	      arg=$fil
+	      # A libtool-controlled object.
+
+	      # Check to see that this really is a libtool object.
+	      if func_lalib_unsafe_p "$arg"; then
+		pic_object=
+		non_pic_object=
+
+		# Read the .lo file
+		func_source "$arg"
+
+		if test -z "$pic_object" ||
+		   test -z "$non_pic_object" ||
+		   test none = "$pic_object" &&
+		   test none = "$non_pic_object"; then
+		  func_fatal_error "cannot find name of object for '$arg'"
+		fi
+
+		# Extract subdirectory from the argument.
+		func_dirname "$arg" "/" ""
+		xdir=$func_dirname_result
+
+		if test none != "$pic_object"; then
+		  # Prepend the subdirectory the object is found in.
+		  pic_object=$xdir$pic_object
+
+		  if test dlfiles = "$prev"; then
+		    if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
+		      func_append dlfiles " $pic_object"
+		      prev=
+		      continue
+		    else
+		      # If libtool objects are unsupported, then we need to preload.
+		      prev=dlprefiles
+		    fi
+		  fi
+
+		  # CHECK ME:  I think I busted this.  -Ossama
+		  if test dlprefiles = "$prev"; then
+		    # Preload the old-style object.
+		    func_append dlprefiles " $pic_object"
+		    prev=
+		  fi
+
+		  # A PIC object.
+		  func_append libobjs " $pic_object"
+		  arg=$pic_object
+		fi
+
+		# Non-PIC object.
+		if test none != "$non_pic_object"; then
+		  # Prepend the subdirectory the object is found in.
+		  non_pic_object=$xdir$non_pic_object
+
+		  # A standard non-PIC object
+		  func_append non_pic_objects " $non_pic_object"
+		  if test -z "$pic_object" || test none = "$pic_object"; then
+		    arg=$non_pic_object
+		  fi
+		else
+		  # If the PIC object exists, use it instead.
+		  # $xdir was prepended to $pic_object above.
+		  non_pic_object=$pic_object
+		  func_append non_pic_objects " $non_pic_object"
+		fi
+	      else
+		# Only an error if not doing a dry-run.
+		if $opt_dry_run; then
+		  # Extract subdirectory from the argument.
+		  func_dirname "$arg" "/" ""
+		  xdir=$func_dirname_result
+
+		  func_lo2o "$arg"
+		  pic_object=$xdir$objdir/$func_lo2o_result
+		  non_pic_object=$xdir$func_lo2o_result
+		  func_append libobjs " $pic_object"
+		  func_append non_pic_objects " $non_pic_object"
+	        else
+		  func_fatal_error "'$arg' is not a valid libtool object"
+		fi
+	      fi
+	    done
+	  else
+	    func_fatal_error "link input file '$arg' does not exist"
+	  fi
+	  arg=$save_arg
+	  prev=
+	  continue
+	  ;;
+	os2dllname)
+	  os2dllname=$arg
+	  prev=
+	  continue
+	  ;;
+	precious_regex)
+	  precious_files_regex=$arg
+	  prev=
+	  continue
+	  ;;
+	release)
+	  release=-$arg
+	  prev=
+	  continue
+	  ;;
+	rpath | xrpath)
+	  # We need an absolute path.
+	  case $arg in
+	  [\\/]* | [A-Za-z]:[\\/]*) ;;
+	  *)
+	    func_fatal_error "only absolute run-paths are allowed"
+	    ;;
+	  esac
+	  if test rpath = "$prev"; then
+	    case "$rpath " in
+	    *" $arg "*) ;;
+	    *) func_append rpath " $arg" ;;
+	    esac
+	  else
+	    case "$xrpath " in
+	    *" $arg "*) ;;
+	    *) func_append xrpath " $arg" ;;
+	    esac
+	  fi
+	  prev=
+	  continue
+	  ;;
+	shrext)
+	  shrext_cmds=$arg
+	  prev=
+	  continue
+	  ;;
+	weak)
+	  func_append weak_libs " $arg"
+	  prev=
+	  continue
+	  ;;
+	xcclinker)
+	  func_append linker_flags " $qarg"
+	  func_append compiler_flags " $qarg"
+	  prev=
+	  func_append compile_command " $qarg"
+	  func_append finalize_command " $qarg"
+	  continue
+	  ;;
+	xcompiler)
+	  func_append compiler_flags " $qarg"
+	  prev=
+	  func_append compile_command " $qarg"
+	  func_append finalize_command " $qarg"
+	  continue
+	  ;;
+	xlinker)
+	  func_append linker_flags " $qarg"
+	  func_append compiler_flags " $wl$qarg"
+	  prev=
+	  func_append compile_command " $wl$qarg"
+	  func_append finalize_command " $wl$qarg"
+	  continue
+	  ;;
+	*)
+	  eval "$prev=\"\$arg\""
+	  prev=
+	  continue
+	  ;;
+	esac
+      fi # test -n "$prev"
+
+      prevarg=$arg
+
+      case $arg in
+      -all-static)
+	if test -n "$link_static_flag"; then
+	  # See comment for -static flag below, for more details.
+	  func_append compile_command " $link_static_flag"
+	  func_append finalize_command " $link_static_flag"
+	fi
+	continue
+	;;
+
+      -allow-undefined)
+	# FIXME: remove this flag sometime in the future.
+	func_fatal_error "'-allow-undefined' must not be used because it is the default"
+	;;
+
+      -avoid-version)
+	avoid_version=yes
+	continue
+	;;
+
+      -bindir)
+	prev=bindir
+	continue
+	;;
+
+      -dlopen)
+	prev=dlfiles
+	continue
+	;;
+
+      -dlpreopen)
+	prev=dlprefiles
+	continue
+	;;
+
+      -export-dynamic)
+	export_dynamic=yes
+	continue
+	;;
+
+      -export-symbols | -export-symbols-regex)
+	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	  func_fatal_error "more than one -exported-symbols argument is not allowed"
+	fi
+	if test X-export-symbols = "X$arg"; then
+	  prev=expsyms
+	else
+	  prev=expsyms_regex
+	fi
+	continue
+	;;
+
+      -framework)
+	prev=framework
+	continue
+	;;
+
+      -inst-prefix-dir)
+	prev=inst_prefix
+	continue
+	;;
+
+      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
+      # so, if we see these flags be careful not to treat them like -L
+      -L[A-Z][A-Z]*:*)
+	case $with_gcc/$host in
+	no/*-*-irix* | /*-*-irix*)
+	  func_append compile_command " $arg"
+	  func_append finalize_command " $arg"
+	  ;;
+	esac
+	continue
+	;;
+
+      -L*)
+	func_stripname "-L" '' "$arg"
+	if test -z "$func_stripname_result"; then
+	  if test "$#" -gt 0; then
+	    func_fatal_error "require no space between '-L' and '$1'"
+	  else
+	    func_fatal_error "need path for '-L' option"
+	  fi
+	fi
+	func_resolve_sysroot "$func_stripname_result"
+	dir=$func_resolve_sysroot_result
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  absdir=`cd "$dir" && pwd`
+	  test -z "$absdir" && \
+	    func_fatal_error "cannot determine absolute directory name of '$dir'"
+	  dir=$absdir
+	  ;;
+	esac
+	case "$deplibs " in
+	*" -L$dir "* | *" $arg "*)
+	  # Will only happen for absolute or sysroot arguments
+	  ;;
+	*)
+	  # Preserve sysroot, but never include relative directories
+	  case $dir in
+	    [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
+	    *) func_append deplibs " -L$dir" ;;
+	  esac
+	  func_append lib_search_path " $dir"
+	  ;;
+	esac
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$dir:"*) ;;
+	  ::) dllsearchpath=$dir;;
+	  *) func_append dllsearchpath ":$dir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  ::) dllsearchpath=$testbindir;;
+	  *) func_append dllsearchpath ":$testbindir";;
+	  esac
+	  ;;
+	esac
+	continue
+	;;
+
+      -l*)
+	if test X-lc = "X$arg" || test X-lm = "X$arg"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
+	    # These systems don't actually have a C or math library (as such)
+	    continue
+	    ;;
+	  *-*-os2*)
+	    # These systems don't actually have a C library (as such)
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
+	    # Do not include libc due to us having libc/libc_r.
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C and math libraries are in the System framework
+	    func_append deplibs " System.ltframework"
+	    continue
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  esac
+	elif test X-lc_r = "X$arg"; then
+	 case $host in
+	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
+	   # Do not include libc_r directly, use -pthread flag.
+	   continue
+	   ;;
+	 esac
+	fi
+	func_append deplibs " $arg"
+	continue
+	;;
+
+      -mllvm)
+	prev=mllvm
+	continue
+	;;
+
+      -module)
+	module=yes
+	continue
+	;;
+
+      # Tru64 UNIX uses -model [arg] to determine the layout of C++
+      # classes, name mangling, and exception handling.
+      # Darwin uses the -arch flag to determine output architecture.
+      -model|-arch|-isysroot|--sysroot)
+	func_append compiler_flags " $arg"
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+	prev=xcompiler
+	continue
+	;;
+
+      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+	func_append compiler_flags " $arg"
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+	case "$new_inherited_linker_flags " in
+	    *" $arg "*) ;;
+	    * ) func_append new_inherited_linker_flags " $arg" ;;
+	esac
+	continue
+	;;
+
+      -multi_module)
+	single_module=$wl-multi_module
+	continue
+	;;
+
+      -no-fast-install)
+	fast_install=no
+	continue
+	;;
+
+      -no-install)
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
+	  # The PATH hackery in wrapper scripts is required on Windows
+	  # and Darwin in order for the loader to find any dlls it needs.
+	  func_warning "'-no-install' is ignored for $host"
+	  func_warning "assuming '-no-fast-install' instead"
+	  fast_install=no
+	  ;;
+	*) no_install=yes ;;
+	esac
+	continue
+	;;
+
+      -no-undefined)
+	allow_undefined=no
+	continue
+	;;
+
+      -objectlist)
+	prev=objectlist
+	continue
+	;;
+
+      -os2dllname)
+	prev=os2dllname
+	continue
+	;;
+
+      -o) prev=output ;;
+
+      -precious-files-regex)
+	prev=precious_regex
+	continue
+	;;
+
+      -release)
+	prev=release
+	continue
+	;;
+
+      -rpath)
+	prev=rpath
+	continue
+	;;
+
+      -R)
+	prev=xrpath
+	continue
+	;;
+
+      -R*)
+	func_stripname '-R' '' "$arg"
+	dir=$func_stripname_result
+	# We need an absolute path.
+	case $dir in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	=*)
+	  func_stripname '=' '' "$dir"
+	  dir=$lt_sysroot$func_stripname_result
+	  ;;
+	*)
+	  func_fatal_error "only absolute run-paths are allowed"
+	  ;;
+	esac
+	case "$xrpath " in
+	*" $dir "*) ;;
+	*) func_append xrpath " $dir" ;;
+	esac
+	continue
+	;;
+
+      -shared)
+	# The effects of -shared are defined in a previous loop.
+	continue
+	;;
+
+      -shrext)
+	prev=shrext
+	continue
+	;;
+
+      -static | -static-libtool-libs)
+	# The effects of -static are defined in a previous loop.
+	# We used to do the same as -all-static on platforms that
+	# didn't have a PIC flag, but the assumption that the effects
+	# would be equivalent was wrong.  It would break on at least
+	# Digital Unix and AIX.
+	continue
+	;;
+
+      -thread-safe)
+	thread_safe=yes
+	continue
+	;;
+
+      -version-info)
+	prev=vinfo
+	continue
+	;;
+
+      -version-number)
+	prev=vinfo
+	vinfo_number=yes
+	continue
+	;;
+
+      -weak)
+        prev=weak
+	continue
+	;;
+
+      -Wc,*)
+	func_stripname '-Wc,' '' "$arg"
+	args=$func_stripname_result
+	arg=
+	save_ifs=$IFS; IFS=,
+	for flag in $args; do
+	  IFS=$save_ifs
+          func_quote_for_eval "$flag"
+	  func_append arg " $func_quote_for_eval_result"
+	  func_append compiler_flags " $func_quote_for_eval_result"
+	done
+	IFS=$save_ifs
+	func_stripname ' ' '' "$arg"
+	arg=$func_stripname_result
+	;;
+
+      -Wl,*)
+	func_stripname '-Wl,' '' "$arg"
+	args=$func_stripname_result
+	arg=
+	save_ifs=$IFS; IFS=,
+	for flag in $args; do
+	  IFS=$save_ifs
+          func_quote_for_eval "$flag"
+	  func_append arg " $wl$func_quote_for_eval_result"
+	  func_append compiler_flags " $wl$func_quote_for_eval_result"
+	  func_append linker_flags " $func_quote_for_eval_result"
+	done
+	IFS=$save_ifs
+	func_stripname ' ' '' "$arg"
+	arg=$func_stripname_result
+	;;
+
+      -Xcompiler)
+	prev=xcompiler
+	continue
+	;;
+
+      -Xlinker)
+	prev=xlinker
+	continue
+	;;
+
+      -XCClinker)
+	prev=xcclinker
+	continue
+	;;
+
+      # -msg_* for osf cc
+      -msg_*)
+	func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+
+      # Flags to be passed through unchanged, with rationale:
+      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
+      # -r[0-9][0-9]*        specify processor for the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
+      # +DA*, +DD*           enable 64-bit mode for the HP compiler
+      # -q*                  compiler args for the IBM compiler
+      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
+      # -F/path              path to uninstalled frameworks, gcc on darwin
+      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
+      # -fstack-protector*   stack protector flags for GCC
+      # @file                GCC response files
+      # -tp=*                Portland pgcc target processor selection
+      # --sysroot=*          for sysroot support
+      # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
+      # -specs=*             GCC specs files
+      # -stdlib=*            select c++ std lib with clang
+      # -fsanitize=*         Clang/GCC memory and address sanitizer
+      # -fuse-ld=*           Linker select flags for GCC
+      # -static-*            direct GCC to link specific libraries statically
+      # -fcilkplus           Cilk Plus language extension features for C/C++
+      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
+      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
+      -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
+      -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus)
+        func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+        func_append compile_command " $arg"
+        func_append finalize_command " $arg"
+        func_append compiler_flags " $arg"
+        continue
+        ;;
+
+      -Z*)
+        if test os2 = "`expr $host : '.*\(os2\)'`"; then
+          # OS/2 uses -Zxxx to specify OS/2-specific options
+	  compiler_flags="$compiler_flags $arg"
+	  func_append compile_command " $arg"
+	  func_append finalize_command " $arg"
+	  case $arg in
+	  -Zlinker | -Zstack)
+	    prev=xcompiler
+	    ;;
+	  esac
+	  continue
+        else
+	  # Otherwise treat like 'Some other compiler flag' below
+	  func_quote_for_eval "$arg"
+	  arg=$func_quote_for_eval_result
+        fi
+	;;
+
+      # Some other compiler flag.
+      -* | +*)
+        func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+
+      *.$objext)
+	# A standard object.
+	func_append objs " $arg"
+	;;
+
+      *.lo)
+	# A libtool-controlled object.
+
+	# Check to see that this really is a libtool object.
+	if func_lalib_unsafe_p "$arg"; then
+	  pic_object=
+	  non_pic_object=
+
+	  # Read the .lo file
+	  func_source "$arg"
+
+	  if test -z "$pic_object" ||
+	     test -z "$non_pic_object" ||
+	     test none = "$pic_object" &&
+	     test none = "$non_pic_object"; then
+	    func_fatal_error "cannot find name of object for '$arg'"
+	  fi
+
+	  # Extract subdirectory from the argument.
+	  func_dirname "$arg" "/" ""
+	  xdir=$func_dirname_result
+
+	  test none = "$pic_object" || {
+	    # Prepend the subdirectory the object is found in.
+	    pic_object=$xdir$pic_object
+
+	    if test dlfiles = "$prev"; then
+	      if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
+		func_append dlfiles " $pic_object"
+		prev=
+		continue
+	      else
+		# If libtool objects are unsupported, then we need to preload.
+		prev=dlprefiles
+	      fi
+	    fi
+
+	    # CHECK ME:  I think I busted this.  -Ossama
+	    if test dlprefiles = "$prev"; then
+	      # Preload the old-style object.
+	      func_append dlprefiles " $pic_object"
+	      prev=
+	    fi
+
+	    # A PIC object.
+	    func_append libobjs " $pic_object"
+	    arg=$pic_object
+	  }
+
+	  # Non-PIC object.
+	  if test none != "$non_pic_object"; then
+	    # Prepend the subdirectory the object is found in.
+	    non_pic_object=$xdir$non_pic_object
+
+	    # A standard non-PIC object
+	    func_append non_pic_objects " $non_pic_object"
+	    if test -z "$pic_object" || test none = "$pic_object"; then
+	      arg=$non_pic_object
+	    fi
+	  else
+	    # If the PIC object exists, use it instead.
+	    # $xdir was prepended to $pic_object above.
+	    non_pic_object=$pic_object
+	    func_append non_pic_objects " $non_pic_object"
+	  fi
+	else
+	  # Only an error if not doing a dry-run.
+	  if $opt_dry_run; then
+	    # Extract subdirectory from the argument.
+	    func_dirname "$arg" "/" ""
+	    xdir=$func_dirname_result
+
+	    func_lo2o "$arg"
+	    pic_object=$xdir$objdir/$func_lo2o_result
+	    non_pic_object=$xdir$func_lo2o_result
+	    func_append libobjs " $pic_object"
+	    func_append non_pic_objects " $non_pic_object"
+	  else
+	    func_fatal_error "'$arg' is not a valid libtool object"
+	  fi
+	fi
+	;;
+
+      *.$libext)
+	# An archive.
+	func_append deplibs " $arg"
+	func_append old_deplibs " $arg"
+	continue
+	;;
+
+      *.la)
+	# A libtool-controlled library.
+
+	func_resolve_sysroot "$arg"
+	if test dlfiles = "$prev"; then
+	  # This library was specified with -dlopen.
+	  func_append dlfiles " $func_resolve_sysroot_result"
+	  prev=
+	elif test dlprefiles = "$prev"; then
+	  # The library was specified with -dlpreopen.
+	  func_append dlprefiles " $func_resolve_sysroot_result"
+	  prev=
+	else
+	  func_append deplibs " $func_resolve_sysroot_result"
+	fi
+	continue
+	;;
+
+      # Some other compiler argument.
+      *)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+      esac # arg
+
+      # Now actually substitute the argument into the commands.
+      if test -n "$arg"; then
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+      fi
+    done # argument parsing loop
+
+    test -n "$prev" && \
+      func_fatal_help "the '$prevarg' option requires an argument"
+
+    if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
+      eval arg=\"$export_dynamic_flag_spec\"
+      func_append compile_command " $arg"
+      func_append finalize_command " $arg"
+    fi
+
+    oldlibs=
+    # calculate the name of the file, without its directory
+    func_basename "$output"
+    outputname=$func_basename_result
+    libobjs_save=$libobjs
+
+    if test -n "$shlibpath_var"; then
+      # get the directories listed in $shlibpath_var
+      eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
+    else
+      shlib_search_path=
+    fi
+    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
+    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+
+    # Definition is injected by LT_CONFIG during libtool generation.
+    func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
+
+    func_dirname "$output" "/" ""
+    output_objdir=$func_dirname_result$objdir
+    func_to_tool_file "$output_objdir/"
+    tool_output_objdir=$func_to_tool_file_result
+    # Create the object directory.
+    func_mkdir_p "$output_objdir"
+
+    # Determine the type of output
+    case $output in
+    "")
+      func_fatal_help "you must specify an output file"
+      ;;
+    *.$libext) linkmode=oldlib ;;
+    *.lo | *.$objext) linkmode=obj ;;
+    *.la) linkmode=lib ;;
+    *) linkmode=prog ;; # Anything else should be a program.
+    esac
+
+    specialdeplibs=
+
+    libs=
+    # Find all interdependent deplibs by searching for libraries
+    # that are linked more than once (e.g. -la -lb -la)
+    for deplib in $deplibs; do
+      if $opt_preserve_dup_deps; then
+	case "$libs " in
+	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
+	esac
+      fi
+      func_append libs " $deplib"
+    done
+
+    if test lib = "$linkmode"; then
+      libs="$predeps $libs $compiler_lib_search_path $postdeps"
+
+      # Compute libraries that are listed more than once in $predeps
+      # $postdeps and mark them as special (i.e., whose duplicates are
+      # not to be eliminated).
+      pre_post_deps=
+      if $opt_duplicate_compiler_generated_deps; then
+	for pre_post_dep in $predeps $postdeps; do
+	  case "$pre_post_deps " in
+	  *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
+	  esac
+	  func_append pre_post_deps " $pre_post_dep"
+	done
+      fi
+      pre_post_deps=
+    fi
+
+    deplibs=
+    newdependency_libs=
+    newlib_search_path=
+    need_relink=no # whether we're linking any uninstalled libtool libraries
+    notinst_deplibs= # not-installed libtool libraries
+    notinst_path= # paths that contain not-installed libtool libraries
+
+    case $linkmode in
+    lib)
+	passes="conv dlpreopen link"
+	for file in $dlfiles $dlprefiles; do
+	  case $file in
+	  *.la) ;;
+	  *)
+	    func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
+	    ;;
+	  esac
+	done
+	;;
+    prog)
+	compile_deplibs=
+	finalize_deplibs=
+	alldeplibs=false
+	newdlfiles=
+	newdlprefiles=
+	passes="conv scan dlopen dlpreopen link"
+	;;
+    *)  passes="conv"
+	;;
+    esac
+
+    for pass in $passes; do
+      # The preopen pass in lib mode reverses $deplibs; put it back here
+      # so that -L comes before libs that need it for instance...
+      if test lib,link = "$linkmode,$pass"; then
+	## FIXME: Find the place where the list is rebuilt in the wrong
+	##        order, and fix it there properly
+        tmp_deplibs=
+	for deplib in $deplibs; do
+	  tmp_deplibs="$deplib $tmp_deplibs"
+	done
+	deplibs=$tmp_deplibs
+      fi
+
+      if test lib,link = "$linkmode,$pass" ||
+	 test prog,scan = "$linkmode,$pass"; then
+	libs=$deplibs
+	deplibs=
+      fi
+      if test prog = "$linkmode"; then
+	case $pass in
+	dlopen) libs=$dlfiles ;;
+	dlpreopen) libs=$dlprefiles ;;
+	link)
+	  libs="$deplibs %DEPLIBS%"
+	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
+	  ;;
+	esac
+      fi
+      if test lib,dlpreopen = "$linkmode,$pass"; then
+	# Collect and forward deplibs of preopened libtool libs
+	for lib in $dlprefiles; do
+	  # Ignore non-libtool-libs
+	  dependency_libs=
+	  func_resolve_sysroot "$lib"
+	  case $lib in
+	  *.la)	func_source "$func_resolve_sysroot_result" ;;
+	  esac
+
+	  # Collect preopened libtool deplibs, except any this library
+	  # has declared as weak libs
+	  for deplib in $dependency_libs; do
+	    func_basename "$deplib"
+            deplib_base=$func_basename_result
+	    case " $weak_libs " in
+	    *" $deplib_base "*) ;;
+	    *) func_append deplibs " $deplib" ;;
+	    esac
+	  done
+	done
+	libs=$dlprefiles
+      fi
+      if test dlopen = "$pass"; then
+	# Collect dlpreopened libraries
+	save_deplibs=$deplibs
+	deplibs=
+      fi
+
+      for deplib in $libs; do
+	lib=
+	found=false
+	case $deplib in
+	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+	  if test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    func_append compiler_flags " $deplib"
+	    if test lib = "$linkmode"; then
+		case "$new_inherited_linker_flags " in
+		    *" $deplib "*) ;;
+		    * ) func_append new_inherited_linker_flags " $deplib" ;;
+		esac
+	    fi
+	  fi
+	  continue
+	  ;;
+	-l*)
+	  if test lib != "$linkmode" && test prog != "$linkmode"; then
+	    func_warning "'-l' is ignored for archives/objects"
+	    continue
+	  fi
+	  func_stripname '-l' '' "$deplib"
+	  name=$func_stripname_result
+	  if test lib = "$linkmode"; then
+	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
+	  else
+	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
+	  fi
+	  for searchdir in $searchdirs; do
+	    for search_ext in .la $std_shrext .so .a; do
+	      # Search the libtool library
+	      lib=$searchdir/lib$name$search_ext
+	      if test -f "$lib"; then
+		if test .la = "$search_ext"; then
+		  found=:
+		else
+		  found=false
+		fi
+		break 2
+	      fi
+	    done
+	  done
+	  if $found; then
+	    # deplib is a libtool library
+	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
+	    # We need to do some special things here, and not later.
+	    if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+	      case " $predeps $postdeps " in
+	      *" $deplib "*)
+		if func_lalib_p "$lib"; then
+		  library_names=
+		  old_library=
+		  func_source "$lib"
+		  for l in $old_library $library_names; do
+		    ll=$l
+		  done
+		  if test "X$ll" = "X$old_library"; then # only static version available
+		    found=false
+		    func_dirname "$lib" "" "."
+		    ladir=$func_dirname_result
+		    lib=$ladir/$old_library
+		    if test prog,link = "$linkmode,$pass"; then
+		      compile_deplibs="$deplib $compile_deplibs"
+		      finalize_deplibs="$deplib $finalize_deplibs"
+		    else
+		      deplibs="$deplib $deplibs"
+		      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
+		    fi
+		    continue
+		  fi
+		fi
+		;;
+	      *) ;;
+	      esac
+	    fi
+	  else
+	    # deplib doesn't seem to be a libtool library
+	    if test prog,link = "$linkmode,$pass"; then
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      deplibs="$deplib $deplibs"
+	      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    continue
+	  fi
+	  ;; # -l
+	*.ltframework)
+	  if test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    deplibs="$deplib $deplibs"
+	    if test lib = "$linkmode"; then
+		case "$new_inherited_linker_flags " in
+		    *" $deplib "*) ;;
+		    * ) func_append new_inherited_linker_flags " $deplib" ;;
+		esac
+	    fi
+	  fi
+	  continue
+	  ;;
+	-L*)
+	  case $linkmode in
+	  lib)
+	    deplibs="$deplib $deplibs"
+	    test conv = "$pass" && continue
+	    newdependency_libs="$deplib $newdependency_libs"
+	    func_stripname '-L' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    func_append newlib_search_path " $func_resolve_sysroot_result"
+	    ;;
+	  prog)
+	    if test conv = "$pass"; then
+	      deplibs="$deplib $deplibs"
+	      continue
+	    fi
+	    if test scan = "$pass"; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    func_stripname '-L' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    func_append newlib_search_path " $func_resolve_sysroot_result"
+	    ;;
+	  *)
+	    func_warning "'-L' is ignored for archives/objects"
+	    ;;
+	  esac # linkmode
+	  continue
+	  ;; # -L
+	-R*)
+	  if test link = "$pass"; then
+	    func_stripname '-R' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    dir=$func_resolve_sysroot_result
+	    # Make sure the xrpath contains only unique directories.
+	    case "$xrpath " in
+	    *" $dir "*) ;;
+	    *) func_append xrpath " $dir" ;;
+	    esac
+	  fi
+	  deplibs="$deplib $deplibs"
+	  continue
+	  ;;
+	*.la)
+	  func_resolve_sysroot "$deplib"
+	  lib=$func_resolve_sysroot_result
+	  ;;
+	*.$libext)
+	  if test conv = "$pass"; then
+	    deplibs="$deplib $deplibs"
+	    continue
+	  fi
+	  case $linkmode in
+	  lib)
+	    # Linking convenience modules into shared libraries is allowed,
+	    # but linking other static libraries is non-portable.
+	    case " $dlpreconveniencelibs " in
+	    *" $deplib "*) ;;
+	    *)
+	      valid_a_lib=false
+	      case $deplibs_check_method in
+		match_pattern*)
+		  set dummy $deplibs_check_method; shift
+		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
+		    | $EGREP "$match_pattern_regex" > /dev/null; then
+		    valid_a_lib=:
+		  fi
+		;;
+		pass_all)
+		  valid_a_lib=:
+		;;
+	      esac
+	      if $valid_a_lib; then
+		echo
+		$ECHO "*** Warning: Linking the shared library $output against the"
+		$ECHO "*** static library $deplib is not portable!"
+		deplibs="$deplib $deplibs"
+	      else
+		echo
+		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because the file extensions .$libext of this argument makes me believe"
+		echo "*** that it is just a static archive that I should not use here."
+	      fi
+	      ;;
+	    esac
+	    continue
+	    ;;
+	  prog)
+	    if test link != "$pass"; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    continue
+	    ;;
+	  esac # linkmode
+	  ;; # *.$libext
+	*.lo | *.$objext)
+	  if test conv = "$pass"; then
+	    deplibs="$deplib $deplibs"
+	  elif test prog = "$linkmode"; then
+	    if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
+	      # If there is no dlopen support or we're linking statically,
+	      # we need to preload.
+	      func_append newdlprefiles " $deplib"
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      func_append newdlfiles " $deplib"
+	    fi
+	  fi
+	  continue
+	  ;;
+	%DEPLIBS%)
+	  alldeplibs=:
+	  continue
+	  ;;
+	esac # case $deplib
+
+	$found || test -f "$lib" \
+	  || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$lib" \
+	  || func_fatal_error "'$lib' is not a valid libtool archive"
+
+	func_dirname "$lib" "" "."
+	ladir=$func_dirname_result
+
+	dlname=
+	dlopen=
+	dlpreopen=
+	libdir=
+	library_names=
+	old_library=
+	inherited_linker_flags=
+	# If the library was installed with an old release of libtool,
+	# it will not redefine variables installed, or shouldnotlink
+	installed=yes
+	shouldnotlink=no
+	avoidtemprpath=
+
+
+	# Read the .la file
+	func_source "$lib"
+
+	# Convert "-framework foo" to "foo.ltframework"
+	if test -n "$inherited_linker_flags"; then
+	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
+	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
+	    case " $new_inherited_linker_flags " in
+	      *" $tmp_inherited_linker_flag "*) ;;
+	      *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
+	    esac
+	  done
+	fi
+	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	if test lib,link = "$linkmode,$pass" ||
+	   test prog,scan = "$linkmode,$pass" ||
+	   { test prog != "$linkmode" && test lib != "$linkmode"; }; then
+	  test -n "$dlopen" && func_append dlfiles " $dlopen"
+	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
+	fi
+
+	if test conv = "$pass"; then
+	  # Only check for convenience libraries
+	  deplibs="$lib $deplibs"
+	  if test -z "$libdir"; then
+	    if test -z "$old_library"; then
+	      func_fatal_error "cannot find name of link library for '$lib'"
+	    fi
+	    # It is a libtool convenience library, so add in its objects.
+	    func_append convenience " $ladir/$objdir/$old_library"
+	    func_append old_convenience " $ladir/$objdir/$old_library"
+	    tmp_libs=
+	    for deplib in $dependency_libs; do
+	      deplibs="$deplib $deplibs"
+	      if $opt_preserve_dup_deps; then
+		case "$tmp_libs " in
+		*" $deplib "*) func_append specialdeplibs " $deplib" ;;
+		esac
+	      fi
+	      func_append tmp_libs " $deplib"
+	    done
+	  elif test prog != "$linkmode" && test lib != "$linkmode"; then
+	    func_fatal_error "'$lib' is not a convenience library"
+	  fi
+	  continue
+	fi # $pass = conv
+
+
+	# Get the name of the library we link against.
+	linklib=
+	if test -n "$old_library" &&
+	   { test yes = "$prefer_static_libs" ||
+	     test built,no = "$prefer_static_libs,$installed"; }; then
+	  linklib=$old_library
+	else
+	  for l in $old_library $library_names; do
+	    linklib=$l
+	  done
+	fi
+	if test -z "$linklib"; then
+	  func_fatal_error "cannot find name of link library for '$lib'"
+	fi
+
+	# This library was specified with -dlopen.
+	if test dlopen = "$pass"; then
+	  test -z "$libdir" \
+	    && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
+	  if test -z "$dlname" ||
+	     test yes != "$dlopen_support" ||
+	     test no = "$build_libtool_libs"
+	  then
+	    # If there is no dlname, no dlopen support or we're linking
+	    # statically, we need to preload.  We also need to preload any
+	    # dependent libraries so libltdl's deplib preloader doesn't
+	    # bomb out in the load deplibs phase.
+	    func_append dlprefiles " $lib $dependency_libs"
+	  else
+	    func_append newdlfiles " $lib"
+	  fi
+	  continue
+	fi # $pass = dlopen
+
+	# We need an absolute path.
+	case $ladir in
+	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
+	*)
+	  abs_ladir=`cd "$ladir" && pwd`
+	  if test -z "$abs_ladir"; then
+	    func_warning "cannot determine absolute directory name of '$ladir'"
+	    func_warning "passing it literally to the linker, although it might fail"
+	    abs_ladir=$ladir
+	  fi
+	  ;;
+	esac
+	func_basename "$lib"
+	laname=$func_basename_result
+
+	# Find the relevant object directory and library name.
+	if test yes = "$installed"; then
+	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    func_warning "library '$lib' was moved."
+	    dir=$ladir
+	    absdir=$abs_ladir
+	    libdir=$abs_ladir
+	  else
+	    dir=$lt_sysroot$libdir
+	    absdir=$lt_sysroot$libdir
+	  fi
+	  test yes = "$hardcode_automatic" && avoidtemprpath=yes
+	else
+	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    dir=$ladir
+	    absdir=$abs_ladir
+	    # Remove this search path later
+	    func_append notinst_path " $abs_ladir"
+	  else
+	    dir=$ladir/$objdir
+	    absdir=$abs_ladir/$objdir
+	    # Remove this search path later
+	    func_append notinst_path " $abs_ladir"
+	  fi
+	fi # $installed = yes
+	func_stripname 'lib' '.la' "$laname"
+	name=$func_stripname_result
+
+	# This library was specified with -dlpreopen.
+	if test dlpreopen = "$pass"; then
+	  if test -z "$libdir" && test prog = "$linkmode"; then
+	    func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
+	  fi
+	  case $host in
+	    # special handling for platforms with PE-DLLs.
+	    *cygwin* | *mingw* | *cegcc* )
+	      # Linker will automatically link against shared library if both
+	      # static and shared are present.  Therefore, ensure we extract
+	      # symbols from the import library if a shared library is present
+	      # (otherwise, the dlopen module name will be incorrect).  We do
+	      # this by putting the import library name into $newdlprefiles.
+	      # We recover the dlopen module name by 'saving' the la file
+	      # name in a special purpose variable, and (later) extracting the
+	      # dlname from the la file.
+	      if test -n "$dlname"; then
+	        func_tr_sh "$dir/$linklib"
+	        eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
+	        func_append newdlprefiles " $dir/$linklib"
+	      else
+	        func_append newdlprefiles " $dir/$old_library"
+	        # Keep a list of preopened convenience libraries to check
+	        # that they are being used correctly in the link pass.
+	        test -z "$libdir" && \
+	          func_append dlpreconveniencelibs " $dir/$old_library"
+	      fi
+	    ;;
+	    * )
+	      # Prefer using a static library (so that no silly _DYNAMIC symbols
+	      # are required to link).
+	      if test -n "$old_library"; then
+	        func_append newdlprefiles " $dir/$old_library"
+	        # Keep a list of preopened convenience libraries to check
+	        # that they are being used correctly in the link pass.
+	        test -z "$libdir" && \
+	          func_append dlpreconveniencelibs " $dir/$old_library"
+	      # Otherwise, use the dlname, so that lt_dlopen finds it.
+	      elif test -n "$dlname"; then
+	        func_append newdlprefiles " $dir/$dlname"
+	      else
+	        func_append newdlprefiles " $dir/$linklib"
+	      fi
+	    ;;
+	  esac
+	fi # $pass = dlpreopen
+
+	if test -z "$libdir"; then
+	  # Link the convenience library
+	  if test lib = "$linkmode"; then
+	    deplibs="$dir/$old_library $deplibs"
+	  elif test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$dir/$old_library $compile_deplibs"
+	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
+	  else
+	    deplibs="$lib $deplibs" # used for prog,scan pass
+	  fi
+	  continue
+	fi
+
+
+	if test prog = "$linkmode" && test link != "$pass"; then
+	  func_append newlib_search_path " $ladir"
+	  deplibs="$lib $deplibs"
+
+	  linkalldeplibs=false
+	  if test no != "$link_all_deplibs" || test -z "$library_names" ||
+	     test no = "$build_libtool_libs"; then
+	    linkalldeplibs=:
+	  fi
+
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    case $deplib in
+	    -L*) func_stripname '-L' '' "$deplib"
+	         func_resolve_sysroot "$func_stripname_result"
+	         func_append newlib_search_path " $func_resolve_sysroot_result"
+		 ;;
+	    esac
+	    # Need to link against all dependency_libs?
+	    if $linkalldeplibs; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      # Need to hardcode shared library paths
+	      # or/and link against static libraries
+	      newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    if $opt_preserve_dup_deps; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
+	      esac
+	    fi
+	    func_append tmp_libs " $deplib"
+	  done # for deplib
+	  continue
+	fi # $linkmode = prog...
+
+	if test prog,link = "$linkmode,$pass"; then
+	  if test -n "$library_names" &&
+	     { { test no = "$prefer_static_libs" ||
+	         test built,yes = "$prefer_static_libs,$installed"; } ||
+	       test -z "$old_library"; }; then
+	    # We need to hardcode the library path
+	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
+	      # Make sure the rpath contains only unique directories.
+	      case $temp_rpath: in
+	      *"$absdir:"*) ;;
+	      *) func_append temp_rpath "$absdir:" ;;
+	      esac
+	    fi
+
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) func_append compile_rpath " $absdir" ;;
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append finalize_rpath " $libdir" ;;
+	      esac
+	      ;;
+	    esac
+	  fi # $linkmode,$pass = prog,link...
+
+	  if $alldeplibs &&
+	     { test pass_all = "$deplibs_check_method" ||
+	       { test yes = "$build_libtool_libs" &&
+		 test -n "$library_names"; }; }; then
+	    # We only need to search for static libraries
+	    continue
+	  fi
+	fi
+
+	link_static=no # Whether the deplib will be linked statically
+	use_static_libs=$prefer_static_libs
+	if test built = "$use_static_libs" && test yes = "$installed"; then
+	  use_static_libs=no
+	fi
+	if test -n "$library_names" &&
+	   { test no = "$use_static_libs" || test -z "$old_library"; }; then
+	  case $host in
+	  *cygwin* | *mingw* | *cegcc* | *os2*)
+	      # No point in relinking DLLs because paths are not encoded
+	      func_append notinst_deplibs " $lib"
+	      need_relink=no
+	    ;;
+	  *)
+	    if test no = "$installed"; then
+	      func_append notinst_deplibs " $lib"
+	      need_relink=yes
+	    fi
+	    ;;
+	  esac
+	  # This is a shared library
+
+	  # Warn about portability, can't link against -module's on some
+	  # systems (darwin).  Don't bleat about dlopened modules though!
+	  dlopenmodule=
+	  for dlpremoduletest in $dlprefiles; do
+	    if test "X$dlpremoduletest" = "X$lib"; then
+	      dlopenmodule=$dlpremoduletest
+	      break
+	    fi
+	  done
+	  if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
+	    echo
+	    if test prog = "$linkmode"; then
+	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
+	    else
+	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
+	    fi
+	    $ECHO "*** $linklib is not portable!"
+	  fi
+	  if test lib = "$linkmode" &&
+	     test yes = "$hardcode_into_libs"; then
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) func_append compile_rpath " $absdir" ;;
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append finalize_rpath " $libdir" ;;
+	      esac
+	      ;;
+	    esac
+	  fi
+
+	  if test -n "$old_archive_from_expsyms_cmds"; then
+	    # figure out the soname
+	    set dummy $library_names
+	    shift
+	    realname=$1
+	    shift
+	    libname=`eval "\\$ECHO \"$libname_spec\""`
+	    # use dlname if we got it. it's perfectly good, no?
+	    if test -n "$dlname"; then
+	      soname=$dlname
+	    elif test -n "$soname_spec"; then
+	      # bleh windows
+	      case $host in
+	      *cygwin* | mingw* | *cegcc* | *os2*)
+	        func_arith $current - $age
+		major=$func_arith_result
+		versuffix=-$major
+		;;
+	      esac
+	      eval soname=\"$soname_spec\"
+	    else
+	      soname=$realname
+	    fi
+
+	    # Make a new name for the extract_expsyms_cmds to use
+	    soroot=$soname
+	    func_basename "$soroot"
+	    soname=$func_basename_result
+	    func_stripname 'lib' '.dll' "$soname"
+	    newlib=libimp-$func_stripname_result.a
+
+	    # If the library has no export list, then create one now
+	    if test -f "$output_objdir/$soname-def"; then :
+	    else
+	      func_verbose "extracting exported symbol list from '$soname'"
+	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
+	    fi
+
+	    # Create $newlib
+	    if test -f "$output_objdir/$newlib"; then :; else
+	      func_verbose "generating import library for '$soname'"
+	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
+	    fi
+	    # make sure the library variables are pointing to the new library
+	    dir=$output_objdir
+	    linklib=$newlib
+	  fi # test -n "$old_archive_from_expsyms_cmds"
+
+	  if test prog = "$linkmode" || test relink != "$opt_mode"; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    lib_linked=yes
+	    case $hardcode_action in
+	    immediate | unsupported)
+	      if test no = "$hardcode_direct"; then
+		add=$dir/$linklib
+		case $host in
+		  *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;
+		  *-*-sysv4*uw2*) add_dir=-L$dir ;;
+		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
+		    *-*-unixware7*) add_dir=-L$dir ;;
+		  *-*-darwin* )
+		    # if the lib is a (non-dlopened) module then we cannot
+		    # link against it, someone is ignoring the earlier warnings
+		    if /usr/bin/file -L $add 2> /dev/null |
+			 $GREP ": [^:]* bundle" >/dev/null; then
+		      if test "X$dlopenmodule" != "X$lib"; then
+			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
+			if test -z "$old_library"; then
+			  echo
+			  echo "*** And there doesn't seem to be a static archive available"
+			  echo "*** The link will probably fail, sorry"
+			else
+			  add=$dir/$old_library
+			fi
+		      elif test -n "$old_library"; then
+			add=$dir/$old_library
+		      fi
+		    fi
+		esac
+	      elif test no = "$hardcode_minus_L"; then
+		case $host in
+		*-*-sunos*) add_shlibpath=$dir ;;
+		esac
+		add_dir=-L$dir
+		add=-l$name
+	      elif test no = "$hardcode_shlibpath_var"; then
+		add_shlibpath=$dir
+		add=-l$name
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    relink)
+	      if test yes = "$hardcode_direct" &&
+	         test no = "$hardcode_direct_absolute"; then
+		add=$dir/$linklib
+	      elif test yes = "$hardcode_minus_L"; then
+		add_dir=-L$absdir
+		# Try looking first in the location we're being installed to.
+		if test -n "$inst_prefix_dir"; then
+		  case $libdir in
+		    [\\/]*)
+		      func_append add_dir " -L$inst_prefix_dir$libdir"
+		      ;;
+		  esac
+		fi
+		add=-l$name
+	      elif test yes = "$hardcode_shlibpath_var"; then
+		add_shlibpath=$dir
+		add=-l$name
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    *) lib_linked=no ;;
+	    esac
+
+	    if test yes != "$lib_linked"; then
+	      func_fatal_configuration "unsupported hardcode properties"
+	    fi
+
+	    if test -n "$add_shlibpath"; then
+	      case :$compile_shlibpath: in
+	      *":$add_shlibpath:"*) ;;
+	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
+	      esac
+	    fi
+	    if test prog = "$linkmode"; then
+	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
+	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	      if test yes != "$hardcode_direct" &&
+		 test yes != "$hardcode_minus_L" &&
+		 test yes = "$hardcode_shlibpath_var"; then
+		case :$finalize_shlibpath: in
+		*":$libdir:"*) ;;
+		*) func_append finalize_shlibpath "$libdir:" ;;
+		esac
+	      fi
+	    fi
+	  fi
+
+	  if test prog = "$linkmode" || test relink = "$opt_mode"; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    # Finalize command for both is simple: just hardcode it.
+	    if test yes = "$hardcode_direct" &&
+	       test no = "$hardcode_direct_absolute"; then
+	      add=$libdir/$linklib
+	    elif test yes = "$hardcode_minus_L"; then
+	      add_dir=-L$libdir
+	      add=-l$name
+	    elif test yes = "$hardcode_shlibpath_var"; then
+	      case :$finalize_shlibpath: in
+	      *":$libdir:"*) ;;
+	      *) func_append finalize_shlibpath "$libdir:" ;;
+	      esac
+	      add=-l$name
+	    elif test yes = "$hardcode_automatic"; then
+	      if test -n "$inst_prefix_dir" &&
+		 test -f "$inst_prefix_dir$libdir/$linklib"; then
+		add=$inst_prefix_dir$libdir/$linklib
+	      else
+		add=$libdir/$linklib
+	      fi
+	    else
+	      # We cannot seem to hardcode it, guess we'll fake it.
+	      add_dir=-L$libdir
+	      # Try looking first in the location we're being installed to.
+	      if test -n "$inst_prefix_dir"; then
+		case $libdir in
+		  [\\/]*)
+		    func_append add_dir " -L$inst_prefix_dir$libdir"
+		    ;;
+		esac
+	      fi
+	      add=-l$name
+	    fi
+
+	    if test prog = "$linkmode"; then
+	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
+	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	    fi
+	  fi
+	elif test prog = "$linkmode"; then
+	  # Here we assume that one of hardcode_direct or hardcode_minus_L
+	  # is not unsupported.  This is valid on all known static and
+	  # shared platforms.
+	  if test unsupported != "$hardcode_direct"; then
+	    test -n "$old_library" && linklib=$old_library
+	    compile_deplibs="$dir/$linklib $compile_deplibs"
+	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
+	  else
+	    compile_deplibs="-l$name -L$dir $compile_deplibs"
+	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
+	  fi
+	elif test yes = "$build_libtool_libs"; then
+	  # Not a shared library
+	  if test pass_all != "$deplibs_check_method"; then
+	    # We're trying link a shared library against a static one
+	    # but the system doesn't support it.
+
+	    # Just print a warning and add the library to dependency_libs so
+	    # that the program can be linked against the static library.
+	    echo
+	    $ECHO "*** Warning: This system cannot link to static lib archive $lib."
+	    echo "*** I have the capability to make that library automatically link in when"
+	    echo "*** you link to this library.  But I can only do this if you have a"
+	    echo "*** shared version of the library, which you do not appear to have."
+	    if test yes = "$module"; then
+	      echo "*** But as you try to build a module library, libtool will still create "
+	      echo "*** a static module, that should work as long as the dlopening application"
+	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
+	      if test -z "$global_symbol_pipe"; then
+		echo
+		echo "*** However, this would only work if libtool was able to extract symbol"
+		echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
+		echo "*** not find such a program.  So, this module is probably useless."
+		echo "*** 'nm' from GNU binutils and a full rebuild may help."
+	      fi
+	      if test no = "$build_old_libs"; then
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  else
+	    deplibs="$dir/$old_library $deplibs"
+	    link_static=yes
+	  fi
+	fi # link shared/static library?
+
+	if test lib = "$linkmode"; then
+	  if test -n "$dependency_libs" &&
+	     { test yes != "$hardcode_into_libs" ||
+	       test yes = "$build_old_libs" ||
+	       test yes = "$link_static"; }; then
+	    # Extract -R from dependency_libs
+	    temp_deplibs=
+	    for libdir in $dependency_libs; do
+	      case $libdir in
+	      -R*) func_stripname '-R' '' "$libdir"
+	           temp_xrpath=$func_stripname_result
+		   case " $xrpath " in
+		   *" $temp_xrpath "*) ;;
+		   *) func_append xrpath " $temp_xrpath";;
+		   esac;;
+	      *) func_append temp_deplibs " $libdir";;
+	      esac
+	    done
+	    dependency_libs=$temp_deplibs
+	  fi
+
+	  func_append newlib_search_path " $absdir"
+	  # Link against this library
+	  test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
+	  # ... and its dependency_libs
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    newdependency_libs="$deplib $newdependency_libs"
+	    case $deplib in
+              -L*) func_stripname '-L' '' "$deplib"
+                   func_resolve_sysroot "$func_stripname_result";;
+              *) func_resolve_sysroot "$deplib" ;;
+            esac
+	    if $opt_preserve_dup_deps; then
+	      case "$tmp_libs " in
+	      *" $func_resolve_sysroot_result "*)
+                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
+	      esac
+	    fi
+	    func_append tmp_libs " $func_resolve_sysroot_result"
+	  done
+
+	  if test no != "$link_all_deplibs"; then
+	    # Add the search paths of all dependency libraries
+	    for deplib in $dependency_libs; do
+	      path=
+	      case $deplib in
+	      -L*) path=$deplib ;;
+	      *.la)
+	        func_resolve_sysroot "$deplib"
+	        deplib=$func_resolve_sysroot_result
+	        func_dirname "$deplib" "" "."
+		dir=$func_dirname_result
+		# We need an absolute path.
+		case $dir in
+		[\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;
+		*)
+		  absdir=`cd "$dir" && pwd`
+		  if test -z "$absdir"; then
+		    func_warning "cannot determine absolute directory name of '$dir'"
+		    absdir=$dir
+		  fi
+		  ;;
+		esac
+		if $GREP "^installed=no" $deplib > /dev/null; then
+		case $host in
+		*-*-darwin*)
+		  depdepl=
+		  eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+		  if test -n "$deplibrary_names"; then
+		    for tmp in $deplibrary_names; do
+		      depdepl=$tmp
+		    done
+		    if test -f "$absdir/$objdir/$depdepl"; then
+		      depdepl=$absdir/$objdir/$depdepl
+		      darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
+                      if test -z "$darwin_install_name"; then
+                          darwin_install_name=`$OTOOL64 -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
+                      fi
+		      func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
+		      func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
+		      path=
+		    fi
+		  fi
+		  ;;
+		*)
+		  path=-L$absdir/$objdir
+		  ;;
+		esac
+		else
+		  eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+		  test -z "$libdir" && \
+		    func_fatal_error "'$deplib' is not a valid libtool archive"
+		  test "$absdir" != "$libdir" && \
+		    func_warning "'$deplib' seems to be moved"
+
+		  path=-L$absdir
+		fi
+		;;
+	      esac
+	      case " $deplibs " in
+	      *" $path "*) ;;
+	      *) deplibs="$path $deplibs" ;;
+	      esac
+	    done
+	  fi # link_all_deplibs != no
+	fi # linkmode = lib
+      done # for deplib in $libs
+      if test link = "$pass"; then
+	if test prog = "$linkmode"; then
+	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
+	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
+	else
+	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	fi
+      fi
+      dependency_libs=$newdependency_libs
+      if test dlpreopen = "$pass"; then
+	# Link the dlpreopened libraries before other libraries
+	for deplib in $save_deplibs; do
+	  deplibs="$deplib $deplibs"
+	done
+      fi
+      if test dlopen != "$pass"; then
+	test conv = "$pass" || {
+	  # Make sure lib_search_path contains only unique directories.
+	  lib_search_path=
+	  for dir in $newlib_search_path; do
+	    case "$lib_search_path " in
+	    *" $dir "*) ;;
+	    *) func_append lib_search_path " $dir" ;;
+	    esac
+	  done
+	  newlib_search_path=
+	}
+
+	if test prog,link = "$linkmode,$pass"; then
+	  vars="compile_deplibs finalize_deplibs"
+	else
+	  vars=deplibs
+	fi
+	for var in $vars dependency_libs; do
+	  # Add libraries to $var in reverse order
+	  eval tmp_libs=\"\$$var\"
+	  new_libs=
+	  for deplib in $tmp_libs; do
+	    # FIXME: Pedantically, this is the right thing to do, so
+	    #        that some nasty dependency loop isn't accidentally
+	    #        broken:
+	    #new_libs="$deplib $new_libs"
+	    # Pragmatically, this seems to cause very few problems in
+	    # practice:
+	    case $deplib in
+	    -L*) new_libs="$deplib $new_libs" ;;
+	    -R*) ;;
+	    *)
+	      # And here is the reason: when a library appears more
+	      # than once as an explicit dependence of a library, or
+	      # is implicitly linked in more than once by the
+	      # compiler, it is considered special, and multiple
+	      # occurrences thereof are not removed.  Compare this
+	      # with having the same library being listed as a
+	      # dependency of multiple other libraries: in this case,
+	      # we know (pedantically, we assume) the library does not
+	      # need to be listed more than once, so we keep only the
+	      # last copy.  This is not always right, but it is rare
+	      # enough that we require users that really mean to play
+	      # such unportable linking tricks to link the library
+	      # using -Wl,-lname, so that libtool does not consider it
+	      # for duplicate removal.
+	      case " $specialdeplibs " in
+	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
+	      *)
+		case " $new_libs " in
+		*" $deplib "*) ;;
+		*) new_libs="$deplib $new_libs" ;;
+		esac
+		;;
+	      esac
+	      ;;
+	    esac
+	  done
+	  tmp_libs=
+	  for deplib in $new_libs; do
+	    case $deplib in
+	    -L*)
+	      case " $tmp_libs " in
+	      *" $deplib "*) ;;
+	      *) func_append tmp_libs " $deplib" ;;
+	      esac
+	      ;;
+	    *) func_append tmp_libs " $deplib" ;;
+	    esac
+	  done
+	  eval $var=\"$tmp_libs\"
+	done # for var
+      fi
+
+      # Add Sun CC postdeps if required:
+      test CXX = "$tagname" && {
+        case $host_os in
+        linux*)
+          case `$CC -V 2>&1 | sed 5q` in
+          *Sun\ C*) # Sun C++ 5.9
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+
+        solaris*)
+          func_cc_basename "$CC"
+          case $func_cc_basename_result in
+          CC* | sunCC*)
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+        esac
+      }
+
+      # Last step: remove runtime libs from dependency_libs
+      # (they stay in deplibs)
+      tmp_libs=
+      for i in $dependency_libs; do
+	case " $predeps $postdeps $compiler_lib_search_path " in
+	*" $i "*)
+	  i=
+	  ;;
+	esac
+	if test -n "$i"; then
+	  func_append tmp_libs " $i"
+	fi
+      done
+      dependency_libs=$tmp_libs
+    done # for pass
+    if test prog = "$linkmode"; then
+      dlfiles=$newdlfiles
+    fi
+    if test prog = "$linkmode" || test lib = "$linkmode"; then
+      dlprefiles=$newdlprefiles
+    fi
+
+    case $linkmode in
+    oldlib)
+      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+	func_warning "'-dlopen' is ignored for archives"
+      fi
+
+      case " $deplibs" in
+      *\ -l* | *\ -L*)
+	func_warning "'-l' and '-L' are ignored for archives" ;;
+      esac
+
+      test -n "$rpath" && \
+	func_warning "'-rpath' is ignored for archives"
+
+      test -n "$xrpath" && \
+	func_warning "'-R' is ignored for archives"
+
+      test -n "$vinfo" && \
+	func_warning "'-version-info/-version-number' is ignored for archives"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for archives"
+
+      test -n "$export_symbols$export_symbols_regex" && \
+	func_warning "'-export-symbols' is ignored for archives"
+
+      # Now set the variables for building old libraries.
+      build_libtool_libs=no
+      oldlibs=$output
+      func_append objs "$old_deplibs"
+      ;;
+
+    lib)
+      # Make sure we only generate libraries of the form 'libNAME.la'.
+      case $outputname in
+      lib*)
+	func_stripname 'lib' '.la' "$outputname"
+	name=$func_stripname_result
+	eval shared_ext=\"$shrext_cmds\"
+	eval libname=\"$libname_spec\"
+	;;
+      *)
+	test no = "$module" \
+	  && func_fatal_help "libtool library '$output' must begin with 'lib'"
+
+	if test no != "$need_lib_prefix"; then
+	  # Add the "lib" prefix for modules if required
+	  func_stripname '' '.la' "$outputname"
+	  name=$func_stripname_result
+	  eval shared_ext=\"$shrext_cmds\"
+	  eval libname=\"$libname_spec\"
+	else
+	  func_stripname '' '.la' "$outputname"
+	  libname=$func_stripname_result
+	fi
+	;;
+      esac
+
+      if test -n "$objs"; then
+	if test pass_all != "$deplibs_check_method"; then
+	  func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
+	else
+	  echo
+	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
+	  $ECHO "*** objects $objs is not portable!"
+	  func_append libobjs " $objs"
+	fi
+      fi
+
+      test no = "$dlself" \
+	|| func_warning "'-dlopen self' is ignored for libtool libraries"
+
+      set dummy $rpath
+      shift
+      test 1 -lt "$#" \
+	&& func_warning "ignoring multiple '-rpath's for a libtool library"
+
+      install_libdir=$1
+
+      oldlibs=
+      if test -z "$rpath"; then
+	if test yes = "$build_libtool_libs"; then
+	  # Building a libtool convenience library.
+	  # Some compilers have problems with a '.al' extension so
+	  # convenience libraries should have the same extension an
+	  # archive normally would.
+	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
+	  build_libtool_libs=convenience
+	  build_old_libs=yes
+	fi
+
+	test -n "$vinfo" && \
+	  func_warning "'-version-info/-version-number' is ignored for convenience libraries"
+
+	test -n "$release" && \
+	  func_warning "'-release' is ignored for convenience libraries"
+      else
+
+	# Parse the version information argument.
+	save_ifs=$IFS; IFS=:
+	set dummy $vinfo 0 0 0
+	shift
+	IFS=$save_ifs
+
+	test -n "$7" && \
+	  func_fatal_help "too many parameters to '-version-info'"
+
+	# convert absolute version numbers to libtool ages
+	# this retains compatibility with .la files and attempts
+	# to make the code below a bit more comprehensible
+
+	case $vinfo_number in
+	yes)
+	  number_major=$1
+	  number_minor=$2
+	  number_revision=$3
+	  #
+	  # There are really only two kinds -- those that
+	  # use the current revision as the major version
+	  # and those that subtract age and use age as
+	  # a minor version.  But, then there is irix
+	  # that has an extra 1 added just for fun
+	  #
+	  case $version_type in
+	  # correct linux to gnu/linux during the next big refactor
+	  darwin|freebsd-elf|linux|osf|windows|none)
+	    func_arith $number_major + $number_minor
+	    current=$func_arith_result
+	    age=$number_minor
+	    revision=$number_revision
+	    ;;
+	  freebsd-aout|qnx|sunos)
+	    current=$number_major
+	    revision=$number_minor
+	    age=0
+	    ;;
+	  irix|nonstopux)
+	    func_arith $number_major + $number_minor
+	    current=$func_arith_result
+	    age=$number_minor
+	    revision=$number_minor
+	    lt_irix_increment=no
+	    ;;
+	  *)
+	    func_fatal_configuration "$modename: unknown library version type '$version_type'"
+	    ;;
+	  esac
+	  ;;
+	no)
+	  current=$1
+	  revision=$2
+	  age=$3
+	  ;;
+	esac
+
+	# Check that each of the things are valid numbers.
+	case $current in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  func_error "CURRENT '$current' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	case $revision in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  func_error "REVISION '$revision' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	case $age in
+	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+	*)
+	  func_error "AGE '$age' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	if test "$age" -gt "$current"; then
+	  func_error "AGE '$age' is greater than the current interface number '$current'"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	fi
+
+	# Calculate the version variables.
+	major=
+	versuffix=
+	verstring=
+	case $version_type in
+	none) ;;
+
+	darwin)
+	  # Like Linux, but with the current version available in
+	  # verstring for coding it into the library header
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  # Darwin ld doesn't like 0 for these options...
+	  func_arith $current + 1
+	  minor_current=$func_arith_result
+	  xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
+	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+          # On Darwin other compilers
+          case $CC in
+              nagfor*)
+                  verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
+                  ;;
+              *)
+                  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+                  ;;
+          esac
+	  ;;
+
+	freebsd-aout)
+	  major=.$current
+	  versuffix=.$current.$revision
+	  ;;
+
+	freebsd-elf)
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  ;;
+
+	irix | nonstopux)
+	  if test no = "$lt_irix_increment"; then
+	    func_arith $current - $age
+	  else
+	    func_arith $current - $age + 1
+	  fi
+	  major=$func_arith_result
+
+	  case $version_type in
+	    nonstopux) verstring_prefix=nonstopux ;;
+	    *)         verstring_prefix=sgi ;;
+	  esac
+	  verstring=$verstring_prefix$major.$revision
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$revision
+	  while test 0 -ne "$loop"; do
+	    func_arith $revision - $loop
+	    iface=$func_arith_result
+	    func_arith $loop - 1
+	    loop=$func_arith_result
+	    verstring=$verstring_prefix$major.$iface:$verstring
+	  done
+
+	  # Before this point, $major must not contain '.'.
+	  major=.$major
+	  versuffix=$major.$revision
+	  ;;
+
+	linux) # correct to gnu/linux during the next big refactor
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  ;;
+
+	osf)
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=.$current.$age.$revision
+	  verstring=$current.$age.$revision
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$age
+	  while test 0 -ne "$loop"; do
+	    func_arith $current - $loop
+	    iface=$func_arith_result
+	    func_arith $loop - 1
+	    loop=$func_arith_result
+	    verstring=$verstring:$iface.0
+	  done
+
+	  # Make executables depend on our current version.
+	  func_append verstring ":$current.0"
+	  ;;
+
+	qnx)
+	  major=.$current
+	  versuffix=.$current
+	  ;;
+
+	sco)
+	  major=.$current
+	  versuffix=.$current
+	  ;;
+
+	sunos)
+	  major=.$current
+	  versuffix=.$current.$revision
+	  ;;
+
+	windows)
+	  # Use '-' rather than '.', since we only want one
+	  # extension on DOS 8.3 file systems.
+	  func_arith $current - $age
+	  major=$func_arith_result
+	  versuffix=-$major
+	  ;;
+
+	*)
+	  func_fatal_configuration "unknown library version type '$version_type'"
+	  ;;
+	esac
+
+	# Clear the version info if we defaulted, and they specified a release.
+	if test -z "$vinfo" && test -n "$release"; then
+	  major=
+	  case $version_type in
+	  darwin)
+	    # we can't check for "0.0" in archive_cmds due to quoting
+	    # problems, so we reset it completely
+	    verstring=
+	    ;;
+	  *)
+	    verstring=0.0
+	    ;;
+	  esac
+	  if test no = "$need_version"; then
+	    versuffix=
+	  else
+	    versuffix=.0.0
+	  fi
+	fi
+
+	# Remove version info from name if versioning should be avoided
+	if test yes,no = "$avoid_version,$need_version"; then
+	  major=
+	  versuffix=
+	  verstring=
+	fi
+
+	# Check to see if the archive will have undefined symbols.
+	if test yes = "$allow_undefined"; then
+	  if test unsupported = "$allow_undefined_flag"; then
+	    if test yes = "$build_old_libs"; then
+	      func_warning "undefined symbols not allowed in $host shared libraries; building static only"
+	      build_libtool_libs=no
+	    else
+	      func_fatal_error "can't build $host shared library unless -no-undefined is specified"
+	    fi
+	  fi
+	else
+	  # Don't allow undefined symbols.
+	  allow_undefined_flag=$no_undefined_flag
+	fi
+
+      fi
+
+      func_generate_dlsyms "$libname" "$libname" :
+      func_append libobjs " $symfileobj"
+      test " " = "$libobjs" && libobjs=
+
+      if test relink != "$opt_mode"; then
+	# Remove our outputs, but don't remove object files since they
+	# may have been created when compiling PIC objects.
+	removelist=
+	tempremovelist=`$ECHO "$output_objdir/*"`
+	for p in $tempremovelist; do
+	  case $p in
+	    *.$objext | *.gcno)
+	       ;;
+	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
+	       if test -n "$precious_files_regex"; then
+		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
+		 then
+		   continue
+		 fi
+	       fi
+	       func_append removelist " $p"
+	       ;;
+	    *) ;;
+	  esac
+	done
+	test -n "$removelist" && \
+	  func_show_eval "${RM}r \$removelist"
+      fi
+
+      # Now set the variables for building old libraries.
+      if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
+	func_append oldlibs " $output_objdir/$libname.$libext"
+
+	# Transform .lo files to .o files.
+	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
+      fi
+
+      # Eliminate all temporary directories.
+      #for path in $notinst_path; do
+      #	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
+      #	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
+      #	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
+      #done
+
+      if test -n "$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	temp_xrpath=
+	for libdir in $xrpath; do
+	  func_replace_sysroot "$libdir"
+	  func_append temp_xrpath " -R$func_replace_sysroot_result"
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_rpath " $libdir" ;;
+	  esac
+	done
+	if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
+	  dependency_libs="$temp_xrpath $dependency_libs"
+	fi
+      fi
+
+      # Make sure dlfiles contains only unique files that won't be dlpreopened
+      old_dlfiles=$dlfiles
+      dlfiles=
+      for lib in $old_dlfiles; do
+	case " $dlprefiles $dlfiles " in
+	*" $lib "*) ;;
+	*) func_append dlfiles " $lib" ;;
+	esac
+      done
+
+      # Make sure dlprefiles contains only unique files
+      old_dlprefiles=$dlprefiles
+      dlprefiles=
+      for lib in $old_dlprefiles; do
+	case "$dlprefiles " in
+	*" $lib "*) ;;
+	*) func_append dlprefiles " $lib" ;;
+	esac
+      done
+
+      if test yes = "$build_libtool_libs"; then
+	if test -n "$rpath"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
+	    # these systems don't actually have a c library (as such)!
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.[012])
+	    # Rhapsody C library is in the System framework
+	    func_append deplibs " System.ltframework"
+	    ;;
+	  *-*-netbsd*)
+	    # Don't link with libc until the a.out ld.so is fixed.
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    ;;
+	  *)
+	    # Add libc to deplibs on all other systems if necessary.
+	    if test yes = "$build_libtool_need_lc"; then
+	      func_append deplibs " -lc"
+	    fi
+	    ;;
+	  esac
+	fi
+
+	# Transform deplibs into only deplibs that can be linked in shared.
+	name_save=$name
+	libname_save=$libname
+	release_save=$release
+	versuffix_save=$versuffix
+	major_save=$major
+	# I'm not sure if I'm treating the release correctly.  I think
+	# release should show up in the -l (ie -lgmp5) so we don't want to
+	# add it in twice.  Is that correct?
+	release=
+	versuffix=
+	major=
+	newdeplibs=
+	droppeddeps=no
+	case $deplibs_check_method in
+	pass_all)
+	  # Don't check for shared/static.  Everything works.
+	  # This might be a little naive.  We might want to check
+	  # whether the library exists or not.  But this is on
+	  # osf3 & osf4 and I'm not really sure... Just
+	  # implementing what was already the behavior.
+	  newdeplibs=$deplibs
+	  ;;
+	test_compile)
+	  # This code stresses the "libraries are programs" paradigm to its
+	  # limits. Maybe even breaks it.  We compile a program, linking it
+	  # against the deplibs as a proxy for the library.  Then we can check
+	  # whether they linked in statically or dynamically with ldd.
+	  $opt_dry_run || $RM conftest.c
+	  cat > conftest.c <<EOF
+	  int main() { return 0; }
+EOF
+	  $opt_dry_run || $RM conftest
+	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
+	    ldd_output=`ldd conftest`
+	    for i in $deplibs; do
+	      case $i in
+	      -l*)
+		func_stripname -l '' "$i"
+		name=$func_stripname_result
+		if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		  case " $predeps $postdeps " in
+		  *" $i "*)
+		    func_append newdeplibs " $i"
+		    i=
+		    ;;
+		  esac
+		fi
+		if test -n "$i"; then
+		  libname=`eval "\\$ECHO \"$libname_spec\""`
+		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+		  set dummy $deplib_matches; shift
+		  deplib_match=$1
+		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
+		    func_append newdeplibs " $i"
+		  else
+		    droppeddeps=yes
+		    echo
+		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
+		    echo "*** I have the capability to make that library automatically link in when"
+		    echo "*** you link to this library.  But I can only do this if you have a"
+		    echo "*** shared version of the library, which I believe you do not have"
+		    echo "*** because a test_compile did reveal that the linker did not use it for"
+		    echo "*** its dynamic dependency list that programs get resolved with at runtime."
+		  fi
+		fi
+		;;
+	      *)
+		func_append newdeplibs " $i"
+		;;
+	      esac
+	    done
+	  else
+	    # Error occurred in the first compile.  Let's try to salvage
+	    # the situation: Compile a separate program for each library.
+	    for i in $deplibs; do
+	      case $i in
+	      -l*)
+		func_stripname -l '' "$i"
+		name=$func_stripname_result
+		$opt_dry_run || $RM conftest
+		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
+		  ldd_output=`ldd conftest`
+		  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		    case " $predeps $postdeps " in
+		    *" $i "*)
+		      func_append newdeplibs " $i"
+		      i=
+		      ;;
+		    esac
+		  fi
+		  if test -n "$i"; then
+		    libname=`eval "\\$ECHO \"$libname_spec\""`
+		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+		    set dummy $deplib_matches; shift
+		    deplib_match=$1
+		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
+		      func_append newdeplibs " $i"
+		    else
+		      droppeddeps=yes
+		      echo
+		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
+		      echo "*** I have the capability to make that library automatically link in when"
+		      echo "*** you link to this library.  But I can only do this if you have a"
+		      echo "*** shared version of the library, which you do not appear to have"
+		      echo "*** because a test_compile did reveal that the linker did not use this one"
+		      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
+		    fi
+		  fi
+		else
+		  droppeddeps=yes
+		  echo
+		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
+		  echo "*** make it link in!  You will probably need to install it or some"
+		  echo "*** library that it depends on before this library will be fully"
+		  echo "*** functional.  Installing it before continuing would be even better."
+		fi
+		;;
+	      *)
+		func_append newdeplibs " $i"
+		;;
+	      esac
+	    done
+	  fi
+	  ;;
+	file_magic*)
+	  set dummy $deplibs_check_method; shift
+	  file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    case $a_deplib in
+	    -l*)
+	      func_stripname -l '' "$a_deplib"
+	      name=$func_stripname_result
+	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  func_append newdeplibs " $a_deplib"
+		  a_deplib=
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib"; then
+		libname=`eval "\\$ECHO \"$libname_spec\""`
+		if test -n "$file_magic_glob"; then
+		  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
+		else
+		  libnameglob=$libname
+		fi
+		test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  if test yes = "$want_nocaseglob"; then
+		    shopt -s nocaseglob
+		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
+		    $nocaseglob
+		  else
+		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
+		  fi
+		  for potent_lib in $potential_libs; do
+		      # Follow soft links.
+		      if ls -lLd "$potent_lib" 2>/dev/null |
+			 $GREP " -> " >/dev/null; then
+			continue
+		      fi
+		      # The statement above tries to avoid entering an
+		      # endless loop below, in case of cyclic links.
+		      # We might still enter an endless loop, since a link
+		      # loop can be closed while we follow links,
+		      # but so what?
+		      potlib=$potent_lib
+		      while test -h "$potlib" 2>/dev/null; do
+			potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
+			case $potliblink in
+			[\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;
+			*) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;
+			esac
+		      done
+		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
+			 $SED -e 10q |
+			 $EGREP "$file_magic_regex" > /dev/null; then
+			func_append newdeplibs " $a_deplib"
+			a_deplib=
+			break 2
+		      fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib"; then
+		droppeddeps=yes
+		echo
+		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib"; then
+		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
+		else
+		  $ECHO "*** with $libname and none of the candidates passed a file format test"
+		  $ECHO "*** using a file magic. Last file checked: $potlib"
+		fi
+	      fi
+	      ;;
+	    *)
+	      # Add a -L argument.
+	      func_append newdeplibs " $a_deplib"
+	      ;;
+	    esac
+	  done # Gone through all deplibs.
+	  ;;
+	match_pattern*)
+	  set dummy $deplibs_check_method; shift
+	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+	  for a_deplib in $deplibs; do
+	    case $a_deplib in
+	    -l*)
+	      func_stripname -l '' "$a_deplib"
+	      name=$func_stripname_result
+	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  func_append newdeplibs " $a_deplib"
+		  a_deplib=
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib"; then
+		libname=`eval "\\$ECHO \"$libname_spec\""`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		    potlib=$potent_lib # see symlink-check above in file_magic test
+		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
+		       $EGREP "$match_pattern_regex" > /dev/null; then
+		      func_append newdeplibs " $a_deplib"
+		      a_deplib=
+		      break 2
+		    fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib"; then
+		droppeddeps=yes
+		echo
+		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib"; then
+		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
+		else
+		  $ECHO "*** with $libname and none of the candidates passed a file format test"
+		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
+		fi
+	      fi
+	      ;;
+	    *)
+	      # Add a -L argument.
+	      func_append newdeplibs " $a_deplib"
+	      ;;
+	    esac
+	  done # Gone through all deplibs.
+	  ;;
+	none | unknown | *)
+	  newdeplibs=
+	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
+	  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+	    for i in $predeps $postdeps; do
+	      # can't use Xsed below, because $i might contain '/'
+	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
+	    done
+	  fi
+	  case $tmp_deplibs in
+	  *[!\	\ ]*)
+	    echo
+	    if test none = "$deplibs_check_method"; then
+	      echo "*** Warning: inter-library dependencies are not supported in this platform."
+	    else
+	      echo "*** Warning: inter-library dependencies are not known to be supported."
+	    fi
+	    echo "*** All declared inter-library dependencies are being dropped."
+	    droppeddeps=yes
+	    ;;
+	  esac
+	  ;;
+	esac
+	versuffix=$versuffix_save
+	major=$major_save
+	release=$release_save
+	libname=$libname_save
+	name=$name_save
+
+	case $host in
+	*-*-rhapsody* | *-*-darwin1.[012])
+	  # On Rhapsody replace the C library with the System framework
+	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
+	  ;;
+	esac
+
+	if test yes = "$droppeddeps"; then
+	  if test yes = "$module"; then
+	    echo
+	    echo "*** Warning: libtool could not satisfy all declared inter-library"
+	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
+	    echo "*** a static module, that should work as long as the dlopening"
+	    echo "*** application is linked with the -dlopen flag."
+	    if test -z "$global_symbol_pipe"; then
+	      echo
+	      echo "*** However, this would only work if libtool was able to extract symbol"
+	      echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
+	      echo "*** not find such a program.  So, this module is probably useless."
+	      echo "*** 'nm' from GNU binutils and a full rebuild may help."
+	    fi
+	    if test no = "$build_old_libs"; then
+	      oldlibs=$output_objdir/$libname.$libext
+	      build_libtool_libs=module
+	      build_old_libs=yes
+	    else
+	      build_libtool_libs=no
+	    fi
+	  else
+	    echo "*** The inter-library dependencies that have been dropped here will be"
+	    echo "*** automatically added whenever a program is linked with this library"
+	    echo "*** or is declared to -dlopen it."
+
+	    if test no = "$allow_undefined"; then
+	      echo
+	      echo "*** Since this library must not contain undefined symbols,"
+	      echo "*** because either the platform does not support them or"
+	      echo "*** it was explicitly requested with -no-undefined,"
+	      echo "*** libtool will only create a static version of it."
+	      if test no = "$build_old_libs"; then
+		oldlibs=$output_objdir/$libname.$libext
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  fi
+	fi
+	# Done checking deplibs!
+	deplibs=$newdeplibs
+      fi
+      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
+      case $host in
+	*-*-darwin*)
+	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	  ;;
+      esac
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $deplibs " in
+	  *" -L$path/$objdir "*)
+	    func_append new_libs " -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) func_append new_libs " $deplib" ;;
+	  esac
+	  ;;
+	*) func_append new_libs " $deplib" ;;
+	esac
+      done
+      deplibs=$new_libs
+
+      # All the library-specific variables (install_libdir is set above).
+      library_names=
+      old_library=
+      dlname=
+
+      # Test again, we may have decided not to build it any more
+      if test yes = "$build_libtool_libs"; then
+	# Remove $wl instances when linking with ld.
+	# FIXME: should test the right _cmds variable.
+	case $archive_cmds in
+	  *\$LD\ *) wl= ;;
+        esac
+	if test yes = "$hardcode_into_libs"; then
+	  # Hardcode the library paths
+	  hardcode_libdirs=
+	  dep_rpath=
+	  rpath=$finalize_rpath
+	  test relink = "$opt_mode" || rpath=$compile_rpath$rpath
+	  for libdir in $rpath; do
+	    if test -n "$hardcode_libdir_flag_spec"; then
+	      if test -n "$hardcode_libdir_separator"; then
+		func_replace_sysroot "$libdir"
+		libdir=$func_replace_sysroot_result
+		if test -z "$hardcode_libdirs"; then
+		  hardcode_libdirs=$libdir
+		else
+		  # Just accumulate the unique libdirs.
+		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		    ;;
+		  *)
+		    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		    ;;
+		  esac
+		fi
+	      else
+		eval flag=\"$hardcode_libdir_flag_spec\"
+		func_append dep_rpath " $flag"
+	      fi
+	    elif test -n "$runpath_var"; then
+	      case "$perm_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append perm_rpath " $libdir" ;;
+	      esac
+	    fi
+	  done
+	  # Substitute the hardcoded libdirs into the rpath.
+	  if test -n "$hardcode_libdir_separator" &&
+	     test -n "$hardcode_libdirs"; then
+	    libdir=$hardcode_libdirs
+	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
+	  fi
+	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
+	    # We should set the runpath_var.
+	    rpath=
+	    for dir in $perm_rpath; do
+	      func_append rpath "$dir:"
+	    done
+	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
+	  fi
+	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
+	fi
+
+	shlibpath=$finalize_shlibpath
+	test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
+	if test -n "$shlibpath"; then
+	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
+	fi
+
+	# Get the real and link names of the library.
+	eval shared_ext=\"$shrext_cmds\"
+	eval library_names=\"$library_names_spec\"
+	set dummy $library_names
+	shift
+	realname=$1
+	shift
+
+	if test -n "$soname_spec"; then
+	  eval soname=\"$soname_spec\"
+	else
+	  soname=$realname
+	fi
+	if test -z "$dlname"; then
+	  dlname=$soname
+	fi
+
+	lib=$output_objdir/$realname
+	linknames=
+	for link
+	do
+	  func_append linknames " $link"
+	done
+
+	# Use standard objects if they are pic
+	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	test "X$libobjs" = "X " && libobjs=
+
+	delfiles=
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
+	  export_symbols=$output_objdir/$libname.uexp
+	  func_append delfiles " $export_symbols"
+	fi
+
+	orig_export_symbols=
+	case $host_os in
+	cygwin* | mingw* | cegcc*)
+	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
+	    # exporting using user supplied symfile
+	    func_dll_def_p "$export_symbols" || {
+	      # and it's NOT already a .def file. Must figure out
+	      # which of the given symbols are data symbols and tag
+	      # them as such. So, trigger use of export_symbols_cmds.
+	      # export_symbols gets reassigned inside the "prepare
+	      # the list of exported symbols" if statement, so the
+	      # include_expsyms logic still works.
+	      orig_export_symbols=$export_symbols
+	      export_symbols=
+	      always_export_symbols=yes
+	    }
+	  fi
+	  ;;
+	esac
+
+	# Prepare the list of exported symbols
+	if test -z "$export_symbols"; then
+	  if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
+	    func_verbose "generating symbol list for '$libname.la'"
+	    export_symbols=$output_objdir/$libname.exp
+	    $opt_dry_run || $RM $export_symbols
+	    cmds=$export_symbols_cmds
+	    save_ifs=$IFS; IFS='~'
+	    for cmd1 in $cmds; do
+	      IFS=$save_ifs
+	      # Take the normal branch if the nm_file_list_spec branch
+	      # doesn't work or if tool conversion is not needed.
+	      case $nm_file_list_spec~$to_tool_file_cmd in
+		*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
+		  try_normal_branch=yes
+		  eval cmd=\"$cmd1\"
+		  func_len " $cmd"
+		  len=$func_len_result
+		  ;;
+		*)
+		  try_normal_branch=no
+		  ;;
+	      esac
+	      if test yes = "$try_normal_branch" \
+		 && { test "$len" -lt "$max_cmd_len" \
+		      || test "$max_cmd_len" -le -1; }
+	      then
+		func_show_eval "$cmd" 'exit $?'
+		skipped_export=false
+	      elif test -n "$nm_file_list_spec"; then
+		func_basename "$output"
+		output_la=$func_basename_result
+		save_libobjs=$libobjs
+		save_output=$output
+		output=$output_objdir/$output_la.nm
+		func_to_tool_file "$output"
+		libobjs=$nm_file_list_spec$func_to_tool_file_result
+		func_append delfiles " $output"
+		func_verbose "creating $NM input file list: $output"
+		for obj in $save_libobjs; do
+		  func_to_tool_file "$obj"
+		  $ECHO "$func_to_tool_file_result"
+		done > "$output"
+		eval cmd=\"$cmd1\"
+		func_show_eval "$cmd" 'exit $?'
+		output=$save_output
+		libobjs=$save_libobjs
+		skipped_export=false
+	      else
+		# The command line is too long to execute in one step.
+		func_verbose "using reloadable object file for export list..."
+		skipped_export=:
+		# Break out early, otherwise skipped_export may be
+		# set to false by a later but shorter cmd.
+		break
+	      fi
+	    done
+	    IFS=$save_ifs
+	    if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
+	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+	fi
+
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  tmp_export_symbols=$export_symbols
+	  test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
+	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
+	fi
+
+	if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
+	  # The given exports_symbols file has to be filtered, so filter it.
+	  func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
+	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
+	  # 's' commands, which not all seds can handle. GNU sed should be fine
+	  # though. Also, the filter scales superlinearly with the number of
+	  # global variables. join(1) would be nice here, but unfortunately
+	  # isn't a blessed tool.
+	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
+	  func_append delfiles " $export_symbols $output_objdir/$libname.filter"
+	  export_symbols=$output_objdir/$libname.def
+	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
+	fi
+
+	tmp_deplibs=
+	for test_deplib in $deplibs; do
+	  case " $convenience " in
+	  *" $test_deplib "*) ;;
+	  *)
+	    func_append tmp_deplibs " $test_deplib"
+	    ;;
+	  esac
+	done
+	deplibs=$tmp_deplibs
+
+	if test -n "$convenience"; then
+	  if test -n "$whole_archive_flag_spec" &&
+	    test yes = "$compiler_needs_object" &&
+	    test -z "$libobjs"; then
+	    # extract the archives, so we have objects to list.
+	    # TODO: could optimize this to just extract one archive.
+	    whole_archive_flag_spec=
+	  fi
+	  if test -n "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	    test "X$libobjs" = "X " && libobjs=
+	  else
+	    gentop=$output_objdir/${outputname}x
+	    func_append generated " $gentop"
+
+	    func_extract_archives $gentop $convenience
+	    func_append libobjs " $func_extract_archives_result"
+	    test "X$libobjs" = "X " && libobjs=
+	  fi
+	fi
+
+	if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
+	  eval flag=\"$thread_safe_flag_spec\"
+	  func_append linker_flags " $flag"
+	fi
+
+	# Make a backup of the uninstalled library when relinking
+	if test relink = "$opt_mode"; then
+	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
+	fi
+
+	# Do each of the archive commands.
+	if test yes = "$module" && test -n "$module_cmds"; then
+	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	    eval test_cmds=\"$module_expsym_cmds\"
+	    cmds=$module_expsym_cmds
+	  else
+	    eval test_cmds=\"$module_cmds\"
+	    cmds=$module_cmds
+	  fi
+	else
+	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	    eval test_cmds=\"$archive_expsym_cmds\"
+	    cmds=$archive_expsym_cmds
+	  else
+	    eval test_cmds=\"$archive_cmds\"
+	    cmds=$archive_cmds
+	  fi
+	fi
+
+	if test : != "$skipped_export" &&
+	   func_len " $test_cmds" &&
+	   len=$func_len_result &&
+	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  :
+	else
+	  # The command line is too long to link in one step, link piecewise
+	  # or, if using GNU ld and skipped_export is not :, use a linker
+	  # script.
+
+	  # Save the value of $output and $libobjs because we want to
+	  # use them later.  If we have whole_archive_flag_spec, we
+	  # want to use save_libobjs as it was before
+	  # whole_archive_flag_spec was expanded, because we can't
+	  # assume the linker understands whole_archive_flag_spec.
+	  # This may have to be revisited, in case too many
+	  # convenience libraries get linked in and end up exceeding
+	  # the spec.
+	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	  fi
+	  save_output=$output
+	  func_basename "$output"
+	  output_la=$func_basename_result
+
+	  # Clear the reloadable object creation command queue and
+	  # initialize k to one.
+	  test_cmds=
+	  concat_cmds=
+	  objlist=
+	  last_robj=
+	  k=1
+
+	  if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
+	    output=$output_objdir/$output_la.lnkscript
+	    func_verbose "creating GNU ld script: $output"
+	    echo 'INPUT (' > $output
+	    for obj in $save_libobjs
+	    do
+	      func_to_tool_file "$obj"
+	      $ECHO "$func_to_tool_file_result" >> $output
+	    done
+	    echo ')' >> $output
+	    func_append delfiles " $output"
+	    func_to_tool_file "$output"
+	    output=$func_to_tool_file_result
+	  elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
+	    output=$output_objdir/$output_la.lnk
+	    func_verbose "creating linker input file list: $output"
+	    : > $output
+	    set x $save_libobjs
+	    shift
+	    firstobj=
+	    if test yes = "$compiler_needs_object"; then
+	      firstobj="$1 "
+	      shift
+	    fi
+	    for obj
+	    do
+	      func_to_tool_file "$obj"
+	      $ECHO "$func_to_tool_file_result" >> $output
+	    done
+	    func_append delfiles " $output"
+	    func_to_tool_file "$output"
+	    output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
+	  else
+	    if test -n "$save_libobjs"; then
+	      func_verbose "creating reloadable object files..."
+	      output=$output_objdir/$output_la-$k.$objext
+	      eval test_cmds=\"$reload_cmds\"
+	      func_len " $test_cmds"
+	      len0=$func_len_result
+	      len=$len0
+
+	      # Loop over the list of objects to be linked.
+	      for obj in $save_libobjs
+	      do
+		func_len " $obj"
+		func_arith $len + $func_len_result
+		len=$func_arith_result
+		if test -z "$objlist" ||
+		   test "$len" -lt "$max_cmd_len"; then
+		  func_append objlist " $obj"
+		else
+		  # The command $test_cmds is almost too long, add a
+		  # command to the queue.
+		  if test 1 -eq "$k"; then
+		    # The first file doesn't have a previous command to add.
+		    reload_objs=$objlist
+		    eval concat_cmds=\"$reload_cmds\"
+		  else
+		    # All subsequent reloadable object files will link in
+		    # the last one created.
+		    reload_objs="$objlist $last_robj"
+		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
+		  fi
+		  last_robj=$output_objdir/$output_la-$k.$objext
+		  func_arith $k + 1
+		  k=$func_arith_result
+		  output=$output_objdir/$output_la-$k.$objext
+		  objlist=" $obj"
+		  func_len " $last_robj"
+		  func_arith $len0 + $func_len_result
+		  len=$func_arith_result
+		fi
+	      done
+	      # Handle the remaining objects by creating one last
+	      # reloadable object file.  All subsequent reloadable object
+	      # files will link in the last one created.
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      reload_objs="$objlist $last_robj"
+	      eval concat_cmds=\"\$concat_cmds$reload_cmds\"
+	      if test -n "$last_robj"; then
+	        eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
+	      fi
+	      func_append delfiles " $output"
+
+	    else
+	      output=
+	    fi
+
+	    ${skipped_export-false} && {
+	      func_verbose "generating symbol list for '$libname.la'"
+	      export_symbols=$output_objdir/$libname.exp
+	      $opt_dry_run || $RM $export_symbols
+	      libobjs=$output
+	      # Append the command to create the export file.
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
+	      if test -n "$last_robj"; then
+		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
+	      fi
+	    }
+
+	    test -n "$save_libobjs" &&
+	      func_verbose "creating a temporary reloadable object file: $output"
+
+	    # Loop through the commands generated above and execute them.
+	    save_ifs=$IFS; IFS='~'
+	    for cmd in $concat_cmds; do
+	      IFS=$save_ifs
+	      $opt_quiet || {
+		  func_quote_for_expand "$cmd"
+		  eval "func_echo $func_quote_for_expand_result"
+	      }
+	      $opt_dry_run || eval "$cmd" || {
+		lt_exit=$?
+
+		# Restore the uninstalled library and exit
+		if test relink = "$opt_mode"; then
+		  ( cd "$output_objdir" && \
+		    $RM "${realname}T" && \
+		    $MV "${realname}U" "$realname" )
+		fi
+
+		exit $lt_exit
+	      }
+	    done
+	    IFS=$save_ifs
+
+	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
+	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+
+          ${skipped_export-false} && {
+	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	      tmp_export_symbols=$export_symbols
+	      test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
+	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
+	    fi
+
+	    if test -n "$orig_export_symbols"; then
+	      # The given exports_symbols file has to be filtered, so filter it.
+	      func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
+	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
+	      # 's' commands, which not all seds can handle. GNU sed should be fine
+	      # though. Also, the filter scales superlinearly with the number of
+	      # global variables. join(1) would be nice here, but unfortunately
+	      # isn't a blessed tool.
+	      $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
+	      func_append delfiles " $export_symbols $output_objdir/$libname.filter"
+	      export_symbols=$output_objdir/$libname.def
+	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
+	    fi
+	  }
+
+	  libobjs=$output
+	  # Restore the value of output.
+	  output=$save_output
+
+	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	    test "X$libobjs" = "X " && libobjs=
+	  fi
+	  # Expand the library linking commands again to reset the
+	  # value of $libobjs for piecewise linking.
+
+	  # Do each of the archive commands.
+	  if test yes = "$module" && test -n "$module_cmds"; then
+	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	      cmds=$module_expsym_cmds
+	    else
+	      cmds=$module_cmds
+	    fi
+	  else
+	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	      cmds=$archive_expsym_cmds
+	    else
+	      cmds=$archive_cmds
+	    fi
+	  fi
+	fi
+
+	if test -n "$delfiles"; then
+	  # Append the command to remove temporary files to $cmds.
+	  eval cmds=\"\$cmds~\$RM $delfiles\"
+	fi
+
+	# Add any objects from preloaded convenience libraries
+	if test -n "$dlprefiles"; then
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $dlprefiles
+	  func_append libobjs " $func_extract_archives_result"
+	  test "X$libobjs" = "X " && libobjs=
+	fi
+
+	save_ifs=$IFS; IFS='~'
+	for cmd in $cmds; do
+	  IFS=$sp$nl
+	  eval cmd=\"$cmd\"
+	  IFS=$save_ifs
+	  $opt_quiet || {
+	    func_quote_for_expand "$cmd"
+	    eval "func_echo $func_quote_for_expand_result"
+	  }
+	  $opt_dry_run || eval "$cmd" || {
+	    lt_exit=$?
+
+	    # Restore the uninstalled library and exit
+	    if test relink = "$opt_mode"; then
+	      ( cd "$output_objdir" && \
+	        $RM "${realname}T" && \
+		$MV "${realname}U" "$realname" )
+	    fi
+
+	    exit $lt_exit
+	  }
+	done
+	IFS=$save_ifs
+
+	# Restore the uninstalled library and exit
+	if test relink = "$opt_mode"; then
+	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
+
+	  if test -n "$convenience"; then
+	    if test -z "$whole_archive_flag_spec"; then
+	      func_show_eval '${RM}r "$gentop"'
+	    fi
+	  fi
+
+	  exit $EXIT_SUCCESS
+	fi
+
+	# Create links to the real library.
+	for linkname in $linknames; do
+	  if test "$realname" != "$linkname"; then
+	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
+	  fi
+	done
+
+	# If -module or -export-dynamic was specified, set the dlname.
+	if test yes = "$module" || test yes = "$export_dynamic"; then
+	  # On all known operating systems, these are identical.
+	  dlname=$soname
+	fi
+      fi
+      ;;
+
+    obj)
+      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+	func_warning "'-dlopen' is ignored for objects"
+      fi
+
+      case " $deplibs" in
+      *\ -l* | *\ -L*)
+	func_warning "'-l' and '-L' are ignored for objects" ;;
+      esac
+
+      test -n "$rpath" && \
+	func_warning "'-rpath' is ignored for objects"
+
+      test -n "$xrpath" && \
+	func_warning "'-R' is ignored for objects"
+
+      test -n "$vinfo" && \
+	func_warning "'-version-info' is ignored for objects"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for objects"
+
+      case $output in
+      *.lo)
+	test -n "$objs$old_deplibs" && \
+	  func_fatal_error "cannot build library object '$output' from non-libtool objects"
+
+	libobj=$output
+	func_lo2o "$libobj"
+	obj=$func_lo2o_result
+	;;
+      *)
+	libobj=
+	obj=$output
+	;;
+      esac
+
+      # Delete the old objects.
+      $opt_dry_run || $RM $obj $libobj
+
+      # Objects from convenience libraries.  This assumes
+      # single-version convenience libraries.  Whenever we create
+      # different ones for PIC/non-PIC, this we'll have to duplicate
+      # the extraction.
+      reload_conv_objs=
+      gentop=
+      # if reload_cmds runs $LD directly, get rid of -Wl from
+      # whole_archive_flag_spec and hope we can get by with turning comma
+      # into space.
+      case $reload_cmds in
+        *\$LD[\ \$]*) wl= ;;
+      esac
+      if test -n "$convenience"; then
+	if test -n "$whole_archive_flag_spec"; then
+	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
+	  test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
+	  reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
+	else
+	  gentop=$output_objdir/${obj}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $convenience
+	  reload_conv_objs="$reload_objs $func_extract_archives_result"
+	fi
+      fi
+
+      # If we're not building shared, we need to use non_pic_objs
+      test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
+
+      # Create the old-style object.
+      reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
+
+      output=$obj
+      func_execute_cmds "$reload_cmds" 'exit $?'
+
+      # Exit if we aren't doing a library object file.
+      if test -z "$libobj"; then
+	if test -n "$gentop"; then
+	  func_show_eval '${RM}r "$gentop"'
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      test yes = "$build_libtool_libs" || {
+	if test -n "$gentop"; then
+	  func_show_eval '${RM}r "$gentop"'
+	fi
+
+	# Create an invalid libtool object if no PIC, so that we don't
+	# accidentally link it into a program.
+	# $show "echo timestamp > $libobj"
+	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
+	exit $EXIT_SUCCESS
+      }
+
+      if test -n "$pic_flag" || test default != "$pic_mode"; then
+	# Only do commands if we really have different PIC objects.
+	reload_objs="$libobjs $reload_conv_objs"
+	output=$libobj
+	func_execute_cmds "$reload_cmds" 'exit $?'
+      fi
+
+      if test -n "$gentop"; then
+	func_show_eval '${RM}r "$gentop"'
+      fi
+
+      exit $EXIT_SUCCESS
+      ;;
+
+    prog)
+      case $host in
+	*cygwin*) func_stripname '' '.exe' "$output"
+	          output=$func_stripname_result.exe;;
+      esac
+      test -n "$vinfo" && \
+	func_warning "'-version-info' is ignored for programs"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for programs"
+
+      $preload \
+	&& test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
+	&& func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
+
+      case $host in
+      *-*-rhapsody* | *-*-darwin1.[012])
+	# On Rhapsody replace the C library is the System framework
+	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
+	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
+	;;
+      esac
+
+      case $host in
+      *-*-darwin*)
+	# Don't allow lazy linking, it breaks C++ global constructors
+	# But is supposedly fixed on 10.4 or later (yay!).
+	if test CXX = "$tagname"; then
+	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
+	    10.[0123])
+	      func_append compile_command " $wl-bind_at_load"
+	      func_append finalize_command " $wl-bind_at_load"
+	    ;;
+	  esac
+	fi
+	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
+	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+	;;
+      esac
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $compile_deplibs " in
+	  *" -L$path/$objdir "*)
+	    func_append new_libs " -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $compile_deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) func_append new_libs " $deplib" ;;
+	  esac
+	  ;;
+	*) func_append new_libs " $deplib" ;;
+	esac
+      done
+      compile_deplibs=$new_libs
+
+
+      func_append compile_command " $compile_deplibs"
+      func_append finalize_command " $finalize_deplibs"
+
+      if test -n "$rpath$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	for libdir in $rpath $xrpath; do
+	  # This is the magic to use -rpath.
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_rpath " $libdir" ;;
+	  esac
+	done
+      fi
+
+      # Now hardcode the library paths
+      rpath=
+      hardcode_libdirs=
+      for libdir in $compile_rpath $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs=$libdir
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    func_append rpath " $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append perm_rpath " $libdir" ;;
+	  esac
+	fi
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+	  testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$libdir:"*) ;;
+	  ::) dllsearchpath=$libdir;;
+	  *) func_append dllsearchpath ":$libdir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  ::) dllsearchpath=$testbindir;;
+	  *) func_append dllsearchpath ":$testbindir";;
+	  esac
+	  ;;
+	esac
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir=$hardcode_libdirs
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      compile_rpath=$rpath
+
+      rpath=
+      hardcode_libdirs=
+      for libdir in $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs=$libdir
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    func_append rpath " $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$finalize_perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_perm_rpath " $libdir" ;;
+	  esac
+	fi
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir=$hardcode_libdirs
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      finalize_rpath=$rpath
+
+      if test -n "$libobjs" && test yes = "$build_old_libs"; then
+	# Transform all the library objects into standard objects.
+	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+      fi
+
+      func_generate_dlsyms "$outputname" "@PROGRAM@" false
+
+      # template prelinking step
+      if test -n "$prelink_cmds"; then
+	func_execute_cmds "$prelink_cmds" 'exit $?'
+      fi
+
+      wrappers_required=:
+      case $host in
+      *cegcc* | *mingw32ce*)
+        # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
+        wrappers_required=false
+        ;;
+      *cygwin* | *mingw* )
+        test yes = "$build_libtool_libs" || wrappers_required=false
+        ;;
+      *)
+        if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
+          wrappers_required=false
+        fi
+        ;;
+      esac
+      $wrappers_required || {
+	# Replace the output file specification.
+	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
+	link_command=$compile_command$compile_rpath
+
+	# We have no uninstalled library dependencies, so finalize right now.
+	exit_status=0
+	func_show_eval "$link_command" 'exit_status=$?'
+
+	if test -n "$postlink_cmds"; then
+	  func_to_tool_file "$output"
+	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	  func_execute_cmds "$postlink_cmds" 'exit $?'
+	fi
+
+	# Delete the generated files.
+	if test -f "$output_objdir/${outputname}S.$objext"; then
+	  func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
+	fi
+
+	exit $exit_status
+      }
+
+      if test -n "$compile_shlibpath$finalize_shlibpath"; then
+	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
+      fi
+      if test -n "$finalize_shlibpath"; then
+	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
+      fi
+
+      compile_var=
+      finalize_var=
+      if test -n "$runpath_var"; then
+	if test -n "$perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $perm_rpath; do
+	    func_append rpath "$dir:"
+	  done
+	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+	if test -n "$finalize_perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $finalize_perm_rpath; do
+	    func_append rpath "$dir:"
+	  done
+	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+      fi
+
+      if test yes = "$no_install"; then
+	# We don't need to create a wrapper script.
+	link_command=$compile_var$compile_command$compile_rpath
+	# Replace the output file specification.
+	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
+	# Delete the old output file.
+	$opt_dry_run || $RM $output
+	# Link the executable and exit
+	func_show_eval "$link_command" 'exit $?'
+
+	if test -n "$postlink_cmds"; then
+	  func_to_tool_file "$output"
+	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	  func_execute_cmds "$postlink_cmds" 'exit $?'
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      case $hardcode_action,$fast_install in
+        relink,*)
+	  # Fast installation is not supported
+	  link_command=$compile_var$compile_command$compile_rpath
+	  relink_command=$finalize_var$finalize_command$finalize_rpath
+
+	  func_warning "this platform does not like uninstalled shared libraries"
+	  func_warning "'$output' will be relinked during installation"
+	  ;;
+        *,yes)
+	  link_command=$finalize_var$compile_command$finalize_rpath
+	  relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
+          ;;
+	*,no)
+	  link_command=$compile_var$compile_command$compile_rpath
+	  relink_command=$finalize_var$finalize_command$finalize_rpath
+          ;;
+	*,needless)
+	  link_command=$finalize_var$compile_command$finalize_rpath
+	  relink_command=
+          ;;
+      esac
+
+      # Replace the output file specification.
+      link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+
+      # Delete the old output files.
+      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
+
+      func_show_eval "$link_command" 'exit $?'
+
+      if test -n "$postlink_cmds"; then
+	func_to_tool_file "$output_objdir/$outputname"
+	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	func_execute_cmds "$postlink_cmds" 'exit $?'
+      fi
+
+      # Now create the wrapper script.
+      func_verbose "creating $output"
+
+      # Quote the relink command for shipping.
+      if test -n "$relink_command"; then
+	# Preserve any variables that may affect compiler behavior
+	for var in $variables_saved_for_relink; do
+	  if eval test -z \"\${$var+set}\"; then
+	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
+	  elif eval var_value=\$$var; test -z "$var_value"; then
+	    relink_command="$var=; export $var; $relink_command"
+	  else
+	    func_quote_for_eval "$var_value"
+	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+	  fi
+	done
+	relink_command="(cd `pwd`; $relink_command)"
+	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+      fi
+
+      # Only actually do things if not in dry run mode.
+      $opt_dry_run || {
+	# win32 will think the script is a binary if it has
+	# a .exe suffix, so we strip it off here.
+	case $output in
+	  *.exe) func_stripname '' '.exe' "$output"
+	         output=$func_stripname_result ;;
+	esac
+	# test for cygwin because mv fails w/o .exe extensions
+	case $host in
+	  *cygwin*)
+	    exeext=.exe
+	    func_stripname '' '.exe' "$outputname"
+	    outputname=$func_stripname_result ;;
+	  *) exeext= ;;
+	esac
+	case $host in
+	  *cygwin* | *mingw* )
+	    func_dirname_and_basename "$output" "" "."
+	    output_name=$func_basename_result
+	    output_path=$func_dirname_result
+	    cwrappersource=$output_path/$objdir/lt-$output_name.c
+	    cwrapper=$output_path/$output_name.exe
+	    $RM $cwrappersource $cwrapper
+	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
+
+	    func_emit_cwrapperexe_src > $cwrappersource
+
+	    # The wrapper executable is built using the $host compiler,
+	    # because it contains $host paths and files. If cross-
+	    # compiling, it, like the target executable, must be
+	    # executed on the $host or under an emulation environment.
+	    $opt_dry_run || {
+	      $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
+	      $STRIP $cwrapper
+	    }
+
+	    # Now, create the wrapper script for func_source use:
+	    func_ltwrapper_scriptname $cwrapper
+	    $RM $func_ltwrapper_scriptname_result
+	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
+	    $opt_dry_run || {
+	      # note: this script will not be executed, so do not chmod.
+	      if test "x$build" = "x$host"; then
+		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
+	      else
+		func_emit_wrapper no > $func_ltwrapper_scriptname_result
+	      fi
+	    }
+	  ;;
+	  * )
+	    $RM $output
+	    trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
+
+	    func_emit_wrapper no > $output
+	    chmod +x $output
+	  ;;
+	esac
+      }
+      exit $EXIT_SUCCESS
+      ;;
+    esac
+
+    # See if we need to build an old-fashioned archive.
+    for oldlib in $oldlibs; do
+
+      case $build_libtool_libs in
+        convenience)
+	  oldobjs="$libobjs_save $symfileobj"
+	  addlibs=$convenience
+	  build_libtool_libs=no
+	  ;;
+	module)
+	  oldobjs=$libobjs_save
+	  addlibs=$old_convenience
+	  build_libtool_libs=no
+          ;;
+	*)
+	  oldobjs="$old_deplibs $non_pic_objects"
+	  $preload && test -f "$symfileobj" \
+	    && func_append oldobjs " $symfileobj"
+	  addlibs=$old_convenience
+	  ;;
+      esac
+
+      if test -n "$addlibs"; then
+	gentop=$output_objdir/${outputname}x
+	func_append generated " $gentop"
+
+	func_extract_archives $gentop $addlibs
+	func_append oldobjs " $func_extract_archives_result"
+      fi
+
+      # Do each command in the archive commands.
+      if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
+	cmds=$old_archive_from_new_cmds
+      else
+
+	# Add any objects from preloaded convenience libraries
+	if test -n "$dlprefiles"; then
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $dlprefiles
+	  func_append oldobjs " $func_extract_archives_result"
+	fi
+
+	# POSIX demands no paths to be encoded in archives.  We have
+	# to avoid creating archives with duplicate basenames if we
+	# might have to extract them afterwards, e.g., when creating a
+	# static archive out of a convenience library, or when linking
+	# the entirety of a libtool archive into another (currently
+	# not supported by libtool).
+	if (for obj in $oldobjs
+	    do
+	      func_basename "$obj"
+	      $ECHO "$func_basename_result"
+	    done | sort | sort -uc >/dev/null 2>&1); then
+	  :
+	else
+	  echo "copying selected object files to avoid basename conflicts..."
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+	  func_mkdir_p "$gentop"
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  counter=1
+	  for obj in $save_oldobjs
+	  do
+	    func_basename "$obj"
+	    objbase=$func_basename_result
+	    case " $oldobjs " in
+	    " ") oldobjs=$obj ;;
+	    *[\ /]"$objbase "*)
+	      while :; do
+		# Make sure we don't pick an alternate name that also
+		# overlaps.
+		newobj=lt$counter-$objbase
+		func_arith $counter + 1
+		counter=$func_arith_result
+		case " $oldobjs " in
+		*[\ /]"$newobj "*) ;;
+		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
+		esac
+	      done
+	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
+	      func_append oldobjs " $gentop/$newobj"
+	      ;;
+	    *) func_append oldobjs " $obj" ;;
+	    esac
+	  done
+	fi
+	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+	tool_oldlib=$func_to_tool_file_result
+	eval cmds=\"$old_archive_cmds\"
+
+	func_len " $cmds"
+	len=$func_len_result
+	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  cmds=$old_archive_cmds
+	elif test -n "$archiver_list_spec"; then
+	  func_verbose "using command file archive linking..."
+	  for obj in $oldobjs
+	  do
+	    func_to_tool_file "$obj"
+	    $ECHO "$func_to_tool_file_result"
+	  done > $output_objdir/$libname.libcmd
+	  func_to_tool_file "$output_objdir/$libname.libcmd"
+	  oldobjs=" $archiver_list_spec$func_to_tool_file_result"
+	  cmds=$old_archive_cmds
+	else
+	  # the command line is too long to link in one step, link in parts
+	  func_verbose "using piecewise archive linking..."
+	  save_RANLIB=$RANLIB
+	  RANLIB=:
+	  objlist=
+	  concat_cmds=
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  # Is there a better way of finding the last object in the list?
+	  for obj in $save_oldobjs
+	  do
+	    last_oldobj=$obj
+	  done
+	  eval test_cmds=\"$old_archive_cmds\"
+	  func_len " $test_cmds"
+	  len0=$func_len_result
+	  len=$len0
+	  for obj in $save_oldobjs
+	  do
+	    func_len " $obj"
+	    func_arith $len + $func_len_result
+	    len=$func_arith_result
+	    func_append objlist " $obj"
+	    if test "$len" -lt "$max_cmd_len"; then
+	      :
+	    else
+	      # the above command should be used before it gets too long
+	      oldobjs=$objlist
+	      if test "$obj" = "$last_oldobj"; then
+		RANLIB=$save_RANLIB
+	      fi
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
+	      objlist=
+	      len=$len0
+	    fi
+	  done
+	  RANLIB=$save_RANLIB
+	  oldobjs=$objlist
+	  if test -z "$oldobjs"; then
+	    eval cmds=\"\$concat_cmds\"
+	  else
+	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
+	  fi
+	fi
+      fi
+      func_execute_cmds "$cmds" 'exit $?'
+    done
+
+    test -n "$generated" && \
+      func_show_eval "${RM}r$generated"
+
+    # Now create the libtool archive.
+    case $output in
+    *.la)
+      old_library=
+      test yes = "$build_old_libs" && old_library=$libname.$libext
+      func_verbose "creating $output"
+
+      # Preserve any variables that may affect compiler behavior
+      for var in $variables_saved_for_relink; do
+	if eval test -z \"\${$var+set}\"; then
+	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
+	elif eval var_value=\$$var; test -z "$var_value"; then
+	  relink_command="$var=; export $var; $relink_command"
+	else
+	  func_quote_for_eval "$var_value"
+	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+	fi
+      done
+      # Quote the link command for shipping.
+      relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+      if test yes = "$hardcode_automatic"; then
+	relink_command=
+      fi
+
+      # Only create the output if not a dry run.
+      $opt_dry_run || {
+	for installed in no yes; do
+	  if test yes = "$installed"; then
+	    if test -z "$install_libdir"; then
+	      break
+	    fi
+	    output=$output_objdir/${outputname}i
+	    # Replace all uninstalled libtool libraries with the installed ones
+	    newdependency_libs=
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      *.la)
+		func_basename "$deplib"
+		name=$func_basename_result
+		func_resolve_sysroot "$deplib"
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
+		test -z "$libdir" && \
+		  func_fatal_error "'$deplib' is not a valid libtool archive"
+		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      -L*)
+		func_stripname -L '' "$deplib"
+		func_replace_sysroot "$func_stripname_result"
+		func_append newdependency_libs " -L$func_replace_sysroot_result"
+		;;
+	      -R*)
+		func_stripname -R '' "$deplib"
+		func_replace_sysroot "$func_stripname_result"
+		func_append newdependency_libs " -R$func_replace_sysroot_result"
+		;;
+	      *) func_append newdependency_libs " $deplib" ;;
+	      esac
+	    done
+	    dependency_libs=$newdependency_libs
+	    newdlfiles=
+
+	    for lib in $dlfiles; do
+	      case $lib in
+	      *.la)
+	        func_basename "$lib"
+		name=$func_basename_result
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+		test -z "$libdir" && \
+		  func_fatal_error "'$lib' is not a valid libtool archive"
+		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      *) func_append newdlfiles " $lib" ;;
+	      esac
+	    done
+	    dlfiles=$newdlfiles
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+	      *.la)
+		# Only pass preopened files to the pseudo-archive (for
+		# eventual linking with the app. that links it) if we
+		# didn't already link the preopened objects directly into
+		# the library:
+		func_basename "$lib"
+		name=$func_basename_result
+		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+		test -z "$libdir" && \
+		  func_fatal_error "'$lib' is not a valid libtool archive"
+		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      esac
+	    done
+	    dlprefiles=$newdlprefiles
+	  else
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      func_append newdlfiles " $abs"
+	    done
+	    dlfiles=$newdlfiles
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      func_append newdlprefiles " $abs"
+	    done
+	    dlprefiles=$newdlprefiles
+	  fi
+	  $RM $output
+	  # place dlname in correct position for cygwin
+	  # In fact, it would be nice if we could use this code for all target
+	  # systems that can't hard-code library paths into their executables
+	  # and that have no shared library path variable independent of PATH,
+	  # but it turns out we can't easily determine that from inspecting
+	  # libtool variables, so we have to hard-code the OSs to which it
+	  # applies here; at the moment, that means platforms that use the PE
+	  # object format with DLL files.  See the long comment at the top of
+	  # tests/bindir.at for full details.
+	  tdlname=$dlname
+	  case $host,$output,$installed,$module,$dlname in
+	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
+	      # If a -bindir argument was supplied, place the dll there.
+	      if test -n "$bindir"; then
+		func_relative_path "$install_libdir" "$bindir"
+		tdlname=$func_relative_path_result/$dlname
+	      else
+		# Otherwise fall back on heuristic.
+		tdlname=../bin/$dlname
+	      fi
+	      ;;
+	  esac
+	  $ECHO > $output "\
+# $outputname - a libtool library file
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='$tdlname'
+
+# Names of this library.
+library_names='$library_names'
+
+# The name of the static archive.
+old_library='$old_library'
+
+# Linker flags that cannot go in dependency_libs.
+inherited_linker_flags='$new_inherited_linker_flags'
+
+# Libraries that this one depends upon.
+dependency_libs='$dependency_libs'
+
+# Names of additional weak libraries provided by this library
+weak_library_names='$weak_libs'
+
+# Version information for $libname.
+current=$current
+age=$age
+revision=$revision
+
+# Is this an already installed library?
+installed=$installed
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=$module
+
+# Files to dlopen/dlpreopen
+dlopen='$dlfiles'
+dlpreopen='$dlprefiles'
+
+# Directory that this library needs to be installed in:
+libdir='$install_libdir'"
+	  if test no,yes = "$installed,$need_relink"; then
+	    $ECHO >> $output "\
+relink_command=\"$relink_command\""
+	  fi
+	done
+      }
+
+      # Do a symbolic link so that the libtool archive can be found in
+      # LD_LIBRARY_PATH before the program is installed.
+      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
+      ;;
+    esac
+    exit $EXIT_SUCCESS
+}
+
+if test link = "$opt_mode" || test relink = "$opt_mode"; then
+  func_mode_link ${1+"$@"}
+fi
+
+
+# func_mode_uninstall arg...
+func_mode_uninstall ()
+{
+    $debug_cmd
+
+    RM=$nonopt
+    files=
+    rmforce=false
+    exit_status=0
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic=$magic
+
+    for arg
+    do
+      case $arg in
+      -f) func_append RM " $arg"; rmforce=: ;;
+      -*) func_append RM " $arg" ;;
+      *) func_append files " $arg" ;;
+      esac
+    done
+
+    test -z "$RM" && \
+      func_fatal_help "you must specify an RM program"
+
+    rmdirs=
+
+    for file in $files; do
+      func_dirname "$file" "" "."
+      dir=$func_dirname_result
+      if test . = "$dir"; then
+	odir=$objdir
+      else
+	odir=$dir/$objdir
+      fi
+      func_basename "$file"
+      name=$func_basename_result
+      test uninstall = "$opt_mode" && odir=$dir
+
+      # Remember odir for removal later, being careful to avoid duplicates
+      if test clean = "$opt_mode"; then
+	case " $rmdirs " in
+	  *" $odir "*) ;;
+	  *) func_append rmdirs " $odir" ;;
+	esac
+      fi
+
+      # Don't error if the file doesn't exist and rm -f was used.
+      if { test -L "$file"; } >/dev/null 2>&1 ||
+	 { test -h "$file"; } >/dev/null 2>&1 ||
+	 test -f "$file"; then
+	:
+      elif test -d "$file"; then
+	exit_status=1
+	continue
+      elif $rmforce; then
+	continue
+      fi
+
+      rmfiles=$file
+
+      case $name in
+      *.la)
+	# Possibly a libtool archive, so verify it.
+	if func_lalib_p "$file"; then
+	  func_source $dir/$name
+
+	  # Delete the libtool libraries and symlinks.
+	  for n in $library_names; do
+	    func_append rmfiles " $odir/$n"
+	  done
+	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"
+
+	  case $opt_mode in
+	  clean)
+	    case " $library_names " in
+	    *" $dlname "*) ;;
+	    *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
+	    esac
+	    test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
+	    ;;
+	  uninstall)
+	    if test -n "$library_names"; then
+	      # Do each command in the postuninstall commands.
+	      func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
+	    fi
+
+	    if test -n "$old_library"; then
+	      # Do each command in the old_postuninstall commands.
+	      func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
+	    fi
+	    # FIXME: should reinstall the best remaining shared library.
+	    ;;
+	  esac
+	fi
+	;;
+
+      *.lo)
+	# Possibly a libtool object, so verify it.
+	if func_lalib_p "$file"; then
+
+	  # Read the .lo file
+	  func_source $dir/$name
+
+	  # Add PIC object to the list of files to remove.
+	  if test -n "$pic_object" && test none != "$pic_object"; then
+	    func_append rmfiles " $dir/$pic_object"
+	  fi
+
+	  # Add non-PIC object to the list of files to remove.
+	  if test -n "$non_pic_object" && test none != "$non_pic_object"; then
+	    func_append rmfiles " $dir/$non_pic_object"
+	  fi
+	fi
+	;;
+
+      *)
+	if test clean = "$opt_mode"; then
+	  noexename=$name
+	  case $file in
+	  *.exe)
+	    func_stripname '' '.exe' "$file"
+	    file=$func_stripname_result
+	    func_stripname '' '.exe' "$name"
+	    noexename=$func_stripname_result
+	    # $file with .exe has already been added to rmfiles,
+	    # add $file without .exe
+	    func_append rmfiles " $file"
+	    ;;
+	  esac
+	  # Do a test to see if this is a libtool program.
+	  if func_ltwrapper_p "$file"; then
+	    if func_ltwrapper_executable_p "$file"; then
+	      func_ltwrapper_scriptname "$file"
+	      relink_command=
+	      func_source $func_ltwrapper_scriptname_result
+	      func_append rmfiles " $func_ltwrapper_scriptname_result"
+	    else
+	      relink_command=
+	      func_source $dir/$noexename
+	    fi
+
+	    # note $name still contains .exe if it was in $file originally
+	    # as does the version of $file that was added into $rmfiles
+	    func_append rmfiles " $odir/$name $odir/${name}S.$objext"
+	    if test yes = "$fast_install" && test -n "$relink_command"; then
+	      func_append rmfiles " $odir/lt-$name"
+	    fi
+	    if test "X$noexename" != "X$name"; then
+	      func_append rmfiles " $odir/lt-$noexename.c"
+	    fi
+	  fi
+	fi
+	;;
+      esac
+      func_show_eval "$RM $rmfiles" 'exit_status=1'
+    done
+
+    # Try to remove the $objdir's in the directories where we deleted files
+    for dir in $rmdirs; do
+      if test -d "$dir"; then
+	func_show_eval "rmdir $dir >/dev/null 2>&1"
+      fi
+    done
+
+    exit $exit_status
+}
+
+if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
+  func_mode_uninstall ${1+"$@"}
+fi
+
+test -z "$opt_mode" && {
+  help=$generic_help
+  func_fatal_help "you must specify a MODE"
+}
+
+test -z "$exec_cmd" && \
+  func_fatal_help "invalid operation mode '$opt_mode'"
+
+if test -n "$exec_cmd"; then
+  eval exec "$exec_cmd"
+  exit $EXIT_FAILURE
+fi
+
+exit $exit_status
+
+
+# The TAGs below are defined such that we never get into a situation
+# where we disable both kinds of libraries.  Given conflicting
+# choices, we go for a static library, that is the most portable,
+# since we can't tell whether shared libraries were disabled because
+# the user asked for that or because the platform doesn't support
+# them.  This is particularly important on AIX, because we don't
+# support having both static and shared libraries enabled at the same
+# time on that platform, so we default to a shared-only configuration.
+# If a disable-shared tag is given, we'll fallback to a static-only
+# configuration.  But we'll never go from static-only to shared-only.
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
+build_libtool_libs=no
+build_old_libs=yes
+# ### END LIBTOOL TAG CONFIG: disable-shared
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-static
+build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
+# ### END LIBTOOL TAG CONFIG: disable-static
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:
diff --git a/deps/cares/m4/ax_ac_append_to_file.m4 b/deps/cares/m4/ax_ac_append_to_file.m4
new file mode 100644
index 0000000000000000000000000000000000000000..242b3d520069523c856ca58ed2ce4ca85e6122a2
--- /dev/null
+++ b/deps/cares/m4/ax_ac_append_to_file.m4
@@ -0,0 +1,32 @@
+# ===========================================================================
+#   https://www.gnu.org/software/autoconf-archive/ax_ac_append_to_file.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_AC_APPEND_TO_FILE([FILE],[DATA])
+#
+# DESCRIPTION
+#
+#   Appends the specified data to the specified Autoconf is run. If you want
+#   to append to a file when configure is run use AX_APPEND_TO_FILE instead.
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Allan Caffee <allan.caffee@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 10
+
+AC_DEFUN([AX_AC_APPEND_TO_FILE],[
+AC_REQUIRE([AX_FILE_ESCAPES])
+m4_esyscmd(
+AX_FILE_ESCAPES
+[
+printf "%s" "$2" >> "$1"
+])
+])
diff --git a/deps/cares/m4/ax_ac_print_to_file.m4 b/deps/cares/m4/ax_ac_print_to_file.m4
new file mode 100644
index 0000000000000000000000000000000000000000..642dfc15113751d7378441960c0bb6447d327e43
--- /dev/null
+++ b/deps/cares/m4/ax_ac_print_to_file.m4
@@ -0,0 +1,32 @@
+# ===========================================================================
+#   https://www.gnu.org/software/autoconf-archive/ax_ac_print_to_file.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_AC_PRINT_TO_FILE([FILE],[DATA])
+#
+# DESCRIPTION
+#
+#   Writes the specified data to the specified file when Autoconf is run. If
+#   you want to print to a file when configure is run use AX_PRINT_TO_FILE
+#   instead.
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Allan Caffee <allan.caffee@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 10
+
+AC_DEFUN([AX_AC_PRINT_TO_FILE],[
+m4_esyscmd(
+AC_REQUIRE([AX_FILE_ESCAPES])
+[
+printf "%s" "$2" > "$1"
+])
+])
diff --git a/deps/cares/m4/ax_add_am_macro_static.m4 b/deps/cares/m4/ax_add_am_macro_static.m4
new file mode 100644
index 0000000000000000000000000000000000000000..6442d24b7c54a73f1771293f791f4c9ecc7aa420
--- /dev/null
+++ b/deps/cares/m4/ax_add_am_macro_static.m4
@@ -0,0 +1,28 @@
+# ===========================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_add_am_macro_static.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_ADD_AM_MACRO_STATIC([RULE])
+#
+# DESCRIPTION
+#
+#   Adds the specified rule to $AMINCLUDE.
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Tom Howard <tomhoward@users.sf.net>
+#   Copyright (c) 2009 Allan Caffee <allan.caffee@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 8
+
+AC_DEFUN([AX_ADD_AM_MACRO_STATIC],[
+  AC_REQUIRE([AX_AM_MACROS_STATIC])
+  AX_AC_APPEND_TO_FILE(AMINCLUDE_STATIC,[$1])
+])
diff --git a/deps/cares/m4/ax_am_macros_static.m4 b/deps/cares/m4/ax_am_macros_static.m4
new file mode 100644
index 0000000000000000000000000000000000000000..f4cee8c8908541131b1b7a33a092e9a1485bcbd0
--- /dev/null
+++ b/deps/cares/m4/ax_am_macros_static.m4
@@ -0,0 +1,38 @@
+# ===========================================================================
+#   https://www.gnu.org/software/autoconf-archive/ax_am_macros_static.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_AM_MACROS_STATIC
+#
+# DESCRIPTION
+#
+#   Adds support for macros that create Automake rules. You must manually
+#   add the following line
+#
+#     include $(top_srcdir)/aminclude_static.am
+#
+#   to your Makefile.am files.
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Tom Howard <tomhoward@users.sf.net>
+#   Copyright (c) 2009 Allan Caffee <allan.caffee@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 11
+
+AC_DEFUN([AMINCLUDE_STATIC],[aminclude_static.am])
+
+AC_DEFUN([AX_AM_MACROS_STATIC],
+[
+AX_AC_PRINT_TO_FILE(AMINCLUDE_STATIC,[
+# ]AMINCLUDE_STATIC[ generated automatically by Autoconf
+# from AX_AM_MACROS_STATIC on ]m4_esyscmd([LC_ALL=C date])[
+])
+])
diff --git a/deps/cares/m4/ax_check_gnu_make.m4 b/deps/cares/m4/ax_check_gnu_make.m4
new file mode 100644
index 0000000000000000000000000000000000000000..785dc96daf151c72af1492ac364196146e8b1a42
--- /dev/null
+++ b/deps/cares/m4/ax_check_gnu_make.m4
@@ -0,0 +1,95 @@
+# ===========================================================================
+#    https://www.gnu.org/software/autoconf-archive/ax_check_gnu_make.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CHECK_GNU_MAKE([run-if-true],[run-if-false])
+#
+# DESCRIPTION
+#
+#   This macro searches for a GNU version of make. If a match is found:
+#
+#     * The makefile variable `ifGNUmake' is set to the empty string, otherwise
+#       it is set to "#". This is useful for including a special features in a
+#       Makefile, which cannot be handled by other versions of make.
+#     * The makefile variable `ifnGNUmake' is set to #, otherwise
+#       it is set to the empty string. This is useful for including a special
+#       features in a Makefile, which can be handled
+#       by other versions of make or to specify else like clause.
+#     * The variable `_cv_gnu_make_command` is set to the command to invoke
+#       GNU make if it exists, the empty string otherwise.
+#     * The variable `ax_cv_gnu_make_command` is set to the command to invoke
+#       GNU make by copying `_cv_gnu_make_command`, otherwise it is unset.
+#     * If GNU Make is found, its version is extracted from the output of
+#       `make --version` as the last field of a record of space-separated
+#       columns and saved into the variable `ax_check_gnu_make_version`.
+#     * Additionally if GNU Make is found, run shell code run-if-true
+#       else run shell code run-if-false.
+#
+#   Here is an example of its use:
+#
+#   Makefile.in might contain:
+#
+#     # A failsafe way of putting a dependency rule into a makefile
+#     $(DEPEND):
+#             $(CC) -MM $(srcdir)/*.c > $(DEPEND)
+#
+#     @ifGNUmake@ ifeq ($(DEPEND),$(wildcard $(DEPEND)))
+#     @ifGNUmake@ include $(DEPEND)
+#     @ifGNUmake@ else
+#     fallback code
+#     @ifGNUmake@ endif
+#
+#   Then configure.in would normally contain:
+#
+#     AX_CHECK_GNU_MAKE()
+#     AC_OUTPUT(Makefile)
+#
+#   Then perhaps to cause gnu make to override any other make, we could do
+#   something like this (note that GNU make always looks for GNUmakefile
+#   first):
+#
+#     if  ! test x$_cv_gnu_make_command = x ; then
+#             mv Makefile GNUmakefile
+#             echo .DEFAULT: > Makefile ;
+#             echo \  $_cv_gnu_make_command \$@ >> Makefile;
+#     fi
+#
+#   Then, if any (well almost any) other make is called, and GNU make also
+#   exists, then the other make wraps the GNU make.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 John Darrington <j.darrington@elvis.murdoch.edu.au>
+#   Copyright (c) 2015 Enrico M. Crisostomo <enrico.m.crisostomo@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 12
+
+AC_DEFUN([AX_CHECK_GNU_MAKE],dnl
+  [AC_PROG_AWK
+  AC_CACHE_CHECK([for GNU make],[_cv_gnu_make_command],[dnl
+    _cv_gnu_make_command="" ;
+dnl Search all the common names for GNU make
+    for a in "$MAKE" make gmake gnumake ; do
+      if test -z "$a" ; then continue ; fi ;
+      if "$a" --version 2> /dev/null | grep GNU 2>&1 > /dev/null ; then
+        _cv_gnu_make_command=$a ;
+        AX_CHECK_GNU_MAKE_HEADLINE=$("$a" --version 2> /dev/null | grep "GNU Make")
+        ax_check_gnu_make_version=$(echo ${AX_CHECK_GNU_MAKE_HEADLINE} | ${AWK} -F " " '{ print $(NF); }')
+        break ;
+      fi
+    done ;])
+dnl If there was a GNU version, then set @ifGNUmake@ to the empty string, '#' otherwise
+  AS_VAR_IF([_cv_gnu_make_command], [""], [AS_VAR_SET([ifGNUmake], ["#"])],   [AS_VAR_SET([ifGNUmake], [""])])
+  AS_VAR_IF([_cv_gnu_make_command], [""], [AS_VAR_SET([ifnGNUmake], [""])],   [AS_VAR_SET([ifnGNUmake], ["#"])])
+  AS_VAR_IF([_cv_gnu_make_command], [""], [AS_UNSET(ax_cv_gnu_make_command)], [AS_VAR_SET([ax_cv_gnu_make_command], [${_cv_gnu_make_command}])])
+  AS_VAR_IF([_cv_gnu_make_command], [""],[$2],[$1])
+  AC_SUBST([ifGNUmake])
+  AC_SUBST([ifnGNUmake])
+])
diff --git a/deps/cares/m4/ax_check_user_namespace.m4 b/deps/cares/m4/ax_check_user_namespace.m4
new file mode 100644
index 0000000000000000000000000000000000000000..27ba69821cb7e38378ee6fd833312aae962be25d
--- /dev/null
+++ b/deps/cares/m4/ax_check_user_namespace.m4
@@ -0,0 +1,54 @@
+# -*- Autoconf -*-
+
+# SYNOPSIS
+#
+#   AX_CHECK_USER_NAMESPACE
+#
+# DESCRIPTION
+#
+#   This macro checks whether the local system supports Linux user namespaces.
+#   If so, it calls AC_DEFINE(HAVE_USER_NAMESPACE).
+
+AC_DEFUN([AX_CHECK_USER_NAMESPACE],[dnl
+ AC_CACHE_CHECK([whether user namespaces are supported],
+  ax_cv_user_namespace,[
+  AC_LANG_PUSH([C])
+  AC_RUN_IFELSE([AC_LANG_SOURCE([[
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+int userfn(void *d) {
+  usleep(100000);  /* synchronize by sleep */
+  return (getuid() != 0);
+}
+char userst[1024*1024];
+int main() {
+  char buffer[1024];
+  int rc, status, fd;
+  pid_t child = clone(userfn, userst + 1024*1024, CLONE_NEWUSER|SIGCHLD, 0);
+  if (child < 0) return 1;
+
+  sprintf(buffer, "/proc/%d/uid_map", child);
+  fd = open(buffer, O_CREAT|O_WRONLY|O_TRUNC, 0755);
+  sprintf(buffer, "0 %d 1\n", getuid());
+  write(fd, buffer, strlen(buffer));
+  close(fd);
+
+  rc = waitpid(child, &status, 0);
+  if (rc <= 0) return 1;
+  if (!WIFEXITED(status)) return 1;
+  return WEXITSTATUS(status);
+}
+  ]])],[ax_cv_user_namespace=yes],[ax_cv_user_namespace=no],[ax_cv_user_namespace=no])
+ AC_LANG_POP([C])
+ ])
+ if test "$ax_cv_user_namespace" = yes; then
+   AC_DEFINE([HAVE_USER_NAMESPACE],[1],[Whether user namespaces are available])
+ fi
+]) # AX_CHECK_USER_NAMESPACE
diff --git a/deps/cares/m4/ax_check_uts_namespace.m4 b/deps/cares/m4/ax_check_uts_namespace.m4
new file mode 100644
index 0000000000000000000000000000000000000000..cf7b145c30e471894fcddac22f42fa05088b6244
--- /dev/null
+++ b/deps/cares/m4/ax_check_uts_namespace.m4
@@ -0,0 +1,76 @@
+# -*- Autoconf -*-
+
+# SYNOPSIS
+#
+#   AX_CHECK_UTS_NAMESPACE
+#
+# DESCRIPTION
+#
+#   This macro checks whether the local system supports Linux UTS namespaces.
+#   Also requires user namespaces to be available, so that non-root users
+#   can enter the namespace.
+#   If so, it calls AC_DEFINE(HAVE_UTS_NAMESPACE).
+
+AC_DEFUN([AX_CHECK_UTS_NAMESPACE],[dnl
+ AC_CACHE_CHECK([whether UTS namespaces are supported],
+  ax_cv_uts_namespace,[
+  AC_LANG_PUSH([C])
+  AC_RUN_IFELSE([AC_LANG_SOURCE([[
+#define _GNU_SOURCE
+#include <sched.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+int utsfn(void *d) {
+  char buffer[1024];
+  const char *name = "autoconftest";
+  int rc = sethostname(name, strlen(name));
+  if (rc != 0) return 1;
+  gethostname(buffer, 1024);
+  return (strcmp(buffer, name) != 0);
+}
+
+char st2[1024*1024];
+int fn(void *d) {
+  pid_t child;
+  int rc, status;
+  usleep(100000);  /* synchronize by sleep */
+  if (getuid() != 0) return 1;
+  child = clone(utsfn, st2 + 1024*1024, CLONE_NEWUTS|SIGCHLD, 0);
+  if (child < 0) return 1;
+  rc = waitpid(child, &status, 0);
+  if (rc <= 0) return 1;
+  if (!WIFEXITED(status)) return 1;
+  return WEXITSTATUS(status);
+}
+char st[1024*1024];
+int main() {
+  char buffer[1024];
+  int rc, status, fd;
+  pid_t child = clone(fn, st + 1024*1024, CLONE_NEWUSER|SIGCHLD, 0);
+  if (child < 0) return 1;
+
+  sprintf(buffer, "/proc/%d/uid_map", child);
+  fd = open(buffer, O_CREAT|O_WRONLY|O_TRUNC, 0755);
+  sprintf(buffer, "0 %d 1\n", getuid());
+  write(fd, buffer, strlen(buffer));
+  close(fd);
+
+  rc = waitpid(child, &status, 0);
+  if (rc <= 0) return 1;
+  if (!WIFEXITED(status)) return 1;
+  return WEXITSTATUS(status);
+}
+]])
+  ],[ax_cv_uts_namespace=yes],[ax_cv_uts_namespace=no],[ax_cv_uts_namespace=no])
+ AC_LANG_POP([C])
+ ])
+ if test "$ax_cv_uts_namespace" = yes; then
+   AC_DEFINE([HAVE_UTS_NAMESPACE],[1],[Whether UTS namespaces are available])
+ fi
+]) # AX_CHECK_UTS_NAMESPACE
diff --git a/deps/cares/m4/ax_cxx_compile_stdcxx_11.m4 b/deps/cares/m4/ax_cxx_compile_stdcxx_11.m4
new file mode 100644
index 0000000000000000000000000000000000000000..229de309169c8aa677ccd6d919ca54a8d717ee9d
--- /dev/null
+++ b/deps/cares/m4/ax_cxx_compile_stdcxx_11.m4
@@ -0,0 +1,163 @@
+# ============================================================================
+#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# ============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++11
+#   standard; if necessary, add switches to CXXFLAGS to enable support.
+#
+#   The first argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for an extended mode.
+#
+#   The second argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline C++11 support is required and that the macro
+#   should error out if no mode with that support is found.  If specified
+#   'optional', then configuration proceeds regardless, after defining
+#   HAVE_CXX11 if and only if a supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 9
+
+m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [[
+  template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+    struct Base {
+    virtual void f() {}
+    };
+    struct Child : public Base {
+    virtual void f() override {}
+    };
+
+    typedef check<check<bool>> right_angle_brackets;
+
+    int a;
+    decltype(a) b;
+
+    typedef check<int> check_type;
+    check_type c;
+    check_type&& cr = static_cast<check_type&&>(c);
+
+    auto d = a;
+    auto l = [](){};
+
+    // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+    // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function because of this
+    namespace test_template_alias_sfinae {
+        struct foo {};
+
+        template<typename T>
+        using member = typename T::member_type;
+
+        template<typename T>
+        void func(...) {}
+
+        template<typename T>
+        void func(member<T>*) {}
+
+        void test();
+
+        void test() {
+            func<foo>(0);
+        }
+    }
+]])
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl
+  m4_if([$1], [], [],
+        [$1], [ext], [],
+        [$1], [noext], [],
+        [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl
+  m4_if([$2], [], [ax_cxx_compile_cxx11_required=true],
+        [$2], [mandatory], [ax_cxx_compile_cxx11_required=true],
+        [$2], [optional], [ax_cxx_compile_cxx11_required=false],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX_11])])
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+  AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
+  ax_cv_cxx_compile_cxx11,
+  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+    [ax_cv_cxx_compile_cxx11=yes],
+    [ax_cv_cxx_compile_cxx11=no])])
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+
+  m4_if([$1], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=gnu++11 -std=gnu++0x; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+                     $cachevar,
+        [ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXXFLAGS="$ac_save_CXXFLAGS"])
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$1], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=c++11 -std=c++0x; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+                     $cachevar,
+        [ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXXFLAGS="$ac_save_CXXFLAGS"])
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx11_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.])
+    fi
+  else
+    if test x$ac_success = xno; then
+      HAVE_CXX11=0
+      AC_MSG_NOTICE([No compiler with C++11 support was found])
+    else
+      HAVE_CXX11=1
+      AC_DEFINE(HAVE_CXX11,1,
+                [define if the compiler supports basic C++11 syntax])
+    fi
+
+    AC_SUBST(HAVE_CXX11)
+  fi
+])
diff --git a/deps/cares/m4/ax_file_escapes.m4 b/deps/cares/m4/ax_file_escapes.m4
new file mode 100644
index 0000000000000000000000000000000000000000..a86fdc326ba01c5a558fb516240431bc80ef8132
--- /dev/null
+++ b/deps/cares/m4/ax_file_escapes.m4
@@ -0,0 +1,30 @@
+# ===========================================================================
+#     https://www.gnu.org/software/autoconf-archive/ax_file_escapes.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_FILE_ESCAPES
+#
+# DESCRIPTION
+#
+#   Writes the specified data to the specified file.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Tom Howard <tomhoward@users.sf.net>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 8
+
+AC_DEFUN([AX_FILE_ESCAPES],[
+AX_DOLLAR="\$"
+AX_SRB="\\135"
+AX_SLB="\\133"
+AX_BS="\\\\"
+AX_DQ="\""
+])
diff --git a/deps/cares/m4/ax_require_defined.m4 b/deps/cares/m4/ax_require_defined.m4
new file mode 100644
index 0000000000000000000000000000000000000000..17c3eab7dafde6c1358c7c189bbe44a6e14995a7
--- /dev/null
+++ b/deps/cares/m4/ax_require_defined.m4
@@ -0,0 +1,37 @@
+# ===========================================================================
+#    https://www.gnu.org/software/autoconf-archive/ax_require_defined.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_REQUIRE_DEFINED(MACRO)
+#
+# DESCRIPTION
+#
+#   AX_REQUIRE_DEFINED is a simple helper for making sure other macros have
+#   been defined and thus are available for use.  This avoids random issues
+#   where a macro isn't expanded.  Instead the configure script emits a
+#   non-fatal:
+#
+#     ./configure: line 1673: AX_CFLAGS_WARN_ALL: command not found
+#
+#   It's like AC_REQUIRE except it doesn't expand the required macro.
+#
+#   Here's an example:
+#
+#     AX_REQUIRE_DEFINED([AX_CHECK_LINK_FLAG])
+#
+# LICENSE
+#
+#   Copyright (c) 2014 Mike Frysinger <vapier@gentoo.org>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 2
+
+AC_DEFUN([AX_REQUIRE_DEFINED], [dnl
+  m4_ifndef([$1], [m4_fatal([macro ]$1[ is not defined; is a m4 file missing?])])
+])dnl AX_REQUIRE_DEFINED
diff --git a/deps/cares/m4/cares-compilers.m4 b/deps/cares/m4/cares-compilers.m4
new file mode 100644
index 0000000000000000000000000000000000000000..5ae6b90b3280550f64e540dadbbc30420376fa91
--- /dev/null
+++ b/deps/cares/m4/cares-compilers.m4
@@ -0,0 +1,1496 @@
+#***************************************************************************
+#
+# Copyright (C) 2009 - 2021 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 75
+
+
+dnl CARES_CHECK_COMPILER
+dnl -------------------------------------------------
+dnl Verify if the C compiler being used is known.
+
+AC_DEFUN([CARES_CHECK_COMPILER], [
+  #
+  compiler_id="unknown"
+  compiler_num="0"
+  #
+  flags_dbg_all="unknown"
+  flags_dbg_yes="unknown"
+  flags_dbg_off="unknown"
+  flags_opt_all="unknown"
+  flags_opt_yes="unknown"
+  flags_opt_off="unknown"
+  #
+  flags_prefer_cppflags="no"
+  #
+  CARES_CHECK_COMPILER_DEC_C
+  CARES_CHECK_COMPILER_HPUX_C
+  CARES_CHECK_COMPILER_IBM_C
+  CARES_CHECK_COMPILER_INTEL_C
+  CARES_CHECK_COMPILER_CLANG
+  CARES_CHECK_COMPILER_GNU_C
+  CARES_CHECK_COMPILER_LCC
+  CARES_CHECK_COMPILER_SGI_MIPSPRO_C
+  CARES_CHECK_COMPILER_SGI_MIPS_C
+  CARES_CHECK_COMPILER_SUNPRO_C
+  CARES_CHECK_COMPILER_TINY_C
+  CARES_CHECK_COMPILER_WATCOM_C
+  #
+  if test "$compiler_id" = "unknown"; then
+  cat <<_EOF 1>&2
+***
+*** Warning: This configure script does not have information about the
+*** compiler you are using, relative to the flags required to enable or
+*** disable generation of debug info, optimization options or warnings.
+***
+*** Whatever settings are present in CFLAGS will be used for this run.
+***
+*** If you wish to help the c-ares project to better support your compiler
+*** you can report this and the required info on the c-ares development
+*** mailing list: http://lists.haxx.se/listinfo/c-ares/
+***
+_EOF
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_CLANG
+dnl -------------------------------------------------
+dnl Verify if compiler being used is clang.
+
+AC_DEFUN([CARES_CHECK_COMPILER_CLANG], [
+  AC_BEFORE([$0],[CARES_CHECK_COMPILER_GNU_C])dnl
+  AC_MSG_CHECKING([if compiler is clang])
+  CURL_CHECK_DEF([__clang__], [], [silent])
+  if test "$curl_cv_have_def___clang__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="CLANG"
+    clangver=`$CC -dumpversion`
+    clangvhi=`echo $clangver | cut -d . -f1`
+    clangvlo=`echo $clangver | cut -d . -f2`
+    compiler_num=`(expr $clangvhi "*" 100 + $clangvlo) 2>/dev/null`
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_all="$flags_dbg_all -ggdb"
+    flags_dbg_all="$flags_dbg_all -gstabs"
+    flags_dbg_all="$flags_dbg_all -gstabs+"
+    flags_dbg_all="$flags_dbg_all -gcoff"
+    flags_dbg_all="$flags_dbg_all -gxcoff"
+    flags_dbg_all="$flags_dbg_all -gdwarf-2"
+    flags_dbg_all="$flags_dbg_all -gvms"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -Os -O3 -O4"
+    flags_opt_yes="-Os"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_DEC_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is DEC C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_DEC_C], [
+  AC_MSG_CHECKING([if compiler is DEC/Compaq/HP C])
+  CURL_CHECK_DEF([__DECC], [], [silent])
+  CURL_CHECK_DEF([__DECC_VER], [], [silent])
+  if test "$curl_cv_have_def___DECC" = "yes" &&
+    test "$curl_cv_have_def___DECC_VER" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="DEC_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g2"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -O4"
+    flags_opt_yes="-O1"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_GNU_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is GNU C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_GNU_C], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_INTEL_C])dnl
+  AC_REQUIRE([CARES_CHECK_COMPILER_CLANG])dnl
+  AC_MSG_CHECKING([if compiler is GNU C])
+  CURL_CHECK_DEF([__GNUC__], [], [silent])
+  if test "$curl_cv_have_def___GNUC__" = "yes" &&
+    test "$compiler_id" = "unknown"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="GNU_C"
+    gccver=`$CC -dumpversion`
+    gccvhi=`echo $gccver | cut -d . -f1`
+    gccvlo=`echo $gccver | cut -d . -f2`
+    compiler_num=`(expr $gccvhi "*" 100 + $gccvlo) 2>/dev/null`
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_all="$flags_dbg_all -ggdb"
+    flags_dbg_all="$flags_dbg_all -gstabs"
+    flags_dbg_all="$flags_dbg_all -gstabs+"
+    flags_dbg_all="$flags_dbg_all -gcoff"
+    flags_dbg_all="$flags_dbg_all -gxcoff"
+    flags_dbg_all="$flags_dbg_all -gdwarf-2"
+    flags_dbg_all="$flags_dbg_all -gvms"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+    CURL_CHECK_DEF([_WIN32], [], [silent])
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_HPUX_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is HP-UX C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_HPUX_C], [
+  AC_MSG_CHECKING([if compiler is HP-UX C])
+  CURL_CHECK_DEF([__HP_cc], [], [silent])
+  if test "$curl_cv_have_def___HP_cc" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="HP_UX_C"
+    flags_dbg_all="-g -s"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-s"
+    flags_opt_all="-O +O0 +O1 +O2 +O3 +O4"
+    flags_opt_yes="+O2"
+    flags_opt_off="+O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_IBM_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is IBM C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_IBM_C], [
+  AC_MSG_CHECKING([if compiler is IBM C])
+  CURL_CHECK_DEF([__IBMC__], [], [silent])
+  if test "$curl_cv_have_def___IBMC__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="IBM_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -O4 -O5"
+    flags_opt_all="$flags_opt_all -qnooptimize"
+    flags_opt_all="$flags_opt_all -qoptimize=0"
+    flags_opt_all="$flags_opt_all -qoptimize=1"
+    flags_opt_all="$flags_opt_all -qoptimize=2"
+    flags_opt_all="$flags_opt_all -qoptimize=3"
+    flags_opt_all="$flags_opt_all -qoptimize=4"
+    flags_opt_all="$flags_opt_all -qoptimize=5"
+    flags_opt_yes="-O2"
+    flags_opt_off="-qnooptimize"
+    flags_prefer_cppflags="yes"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_INTEL_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is Intel C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_INTEL_C], [
+  AC_BEFORE([$0],[CARES_CHECK_COMPILER_GNU_C])dnl
+  AC_MSG_CHECKING([if compiler is Intel C])
+  CURL_CHECK_DEF([__INTEL_COMPILER], [], [silent])
+  if test "$curl_cv_have_def___INTEL_COMPILER" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_num="$curl_cv_def___INTEL_COMPILER"
+    CURL_CHECK_DEF([__unix__], [], [silent])
+    if test "$curl_cv_have_def___unix__" = "yes"; then
+      compiler_id="INTEL_UNIX_C"
+      flags_dbg_all="-g -g0"
+      flags_dbg_yes="-g"
+      flags_dbg_off="-g0"
+      flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
+      flags_opt_yes="-O2"
+      flags_opt_off="-O0"
+    else
+      compiler_id="INTEL_WINDOWS_C"
+      flags_dbg_all="/ZI /Zi /zI /zi /ZD /Zd /zD /zd /Z7 /z7 /Oy /Oy-"
+      flags_dbg_all="$flags_dbg_all /debug"
+      flags_dbg_all="$flags_dbg_all /debug:none"
+      flags_dbg_all="$flags_dbg_all /debug:minimal"
+      flags_dbg_all="$flags_dbg_all /debug:partial"
+      flags_dbg_all="$flags_dbg_all /debug:full"
+      flags_dbg_all="$flags_dbg_all /debug:semantic_stepping"
+      flags_dbg_all="$flags_dbg_all /debug:extended"
+      flags_dbg_yes="/Zi /Oy-"
+      flags_dbg_off="/debug:none /Oy-"
+      flags_opt_all="/O /O0 /O1 /O2 /O3 /Od /Og /Og- /Oi /Oi-"
+      flags_opt_yes="/O2"
+      flags_opt_off="/Od"
+    fi
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_LCC
+dnl -------------------------------------------------
+dnl Verify if compiler being used is LCC.
+
+AC_DEFUN([CARES_CHECK_COMPILER_LCC], [
+  AC_MSG_CHECKING([if compiler is LCC])
+  CURL_CHECK_DEF([__LCC__], [], [silent])
+  if test "$curl_cv_have_def___LCC__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="LCC"
+    flags_dbg_all="-g"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all=""
+    flags_opt_yes=""
+    flags_opt_off=""
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_SGI_MIPS_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is SGI MIPS C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_SGI_MIPS_C], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_SGI_MIPSPRO_C])dnl
+  AC_MSG_CHECKING([if compiler is SGI MIPS C])
+  CURL_CHECK_DEF([__GNUC__], [], [silent])
+  CURL_CHECK_DEF([__sgi], [], [silent])
+  if test "$curl_cv_have_def___GNUC__" = "no" &&
+    test "$curl_cv_have_def___sgi" = "yes" &&
+    test "$compiler_id" = "unknown"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="SGI_MIPS_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_SGI_MIPSPRO_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is SGI MIPSpro C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_SGI_MIPSPRO_C], [
+  AC_BEFORE([$0],[CARES_CHECK_COMPILER_SGI_MIPS_C])dnl
+  AC_MSG_CHECKING([if compiler is SGI MIPSpro C])
+  CURL_CHECK_DEF([__GNUC__], [], [silent])
+  CURL_CHECK_DEF([_COMPILER_VERSION], [], [silent])
+  CURL_CHECK_DEF([_SGI_COMPILER_VERSION], [], [silent])
+  if test "$curl_cv_have_def___GNUC__" = "no" &&
+    (test "$curl_cv_have_def__SGI_COMPILER_VERSION" = "yes" ||
+     test "$curl_cv_have_def__COMPILER_VERSION" = "yes"); then
+    AC_MSG_RESULT([yes])
+    compiler_id="SGI_MIPSPRO_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_SUNPRO_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is SunPro C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_SUNPRO_C], [
+  AC_MSG_CHECKING([if compiler is SunPro C])
+  CURL_CHECK_DEF([__SUNPRO_C], [], [silent])
+  if test "$curl_cv_have_def___SUNPRO_C" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="SUNPRO_C"
+    flags_dbg_all="-g -s"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-s"
+    flags_opt_all="-O -xO -xO1 -xO2 -xO3 -xO4 -xO5"
+    flags_opt_yes="-xO2"
+    flags_opt_off=""
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_TINY_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is Tiny C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_TINY_C], [
+  AC_MSG_CHECKING([if compiler is Tiny C])
+  CURL_CHECK_DEF([__TINYC__], [], [silent])
+  if test "$curl_cv_have_def___TINYC__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="TINY_C"
+    flags_dbg_all="-g -b"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all=""
+    flags_opt_yes=""
+    flags_opt_off=""
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_WATCOM_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is Watcom C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_WATCOM_C], [
+  AC_MSG_CHECKING([if compiler is Watcom C])
+  CURL_CHECK_DEF([__WATCOMC__], [], [silent])
+  if test "$curl_cv_have_def___WATCOMC__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    CURL_CHECK_DEF([__UNIX__], [], [silent])
+    if test "$curl_cv_have_def___UNIX__" = "yes"; then
+      compiler_id="WATCOM_UNIX_C"
+      flags_dbg_all="-g1 -g1+ -g2 -g3"
+      flags_dbg_yes="-g2"
+      flags_dbg_off=""
+      flags_opt_all="-O0 -O1 -O2 -O3"
+      flags_opt_yes="-O2"
+      flags_opt_off="-O0"
+    else
+      compiler_id="WATCOM_WINDOWS_C"
+      flags_dbg_all=""
+      flags_dbg_yes=""
+      flags_dbg_off=""
+      flags_opt_all=""
+      flags_opt_yes=""
+      flags_opt_off=""
+    fi
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CONVERT_INCLUDE_TO_ISYSTEM
+dnl -------------------------------------------------
+dnl Changes standard include paths present in CFLAGS
+dnl and CPPFLAGS into isystem include paths. This is
+dnl done to prevent GNUC from generating warnings on
+dnl headers from these locations, although on ancient
+dnl GNUC versions these warnings are not silenced.
+
+AC_DEFUN([CARES_CONVERT_INCLUDE_TO_ISYSTEM], [
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  if test "$compiler_id" = "GNU_C" ||
+    test "$compiler_id" = "CLANG"; then
+    tmp_has_include="no"
+    tmp_chg_FLAGS="$CFLAGS"
+    for word1 in $tmp_chg_FLAGS; do
+      case "$word1" in
+        -I*)
+          tmp_has_include="yes"
+          ;;
+      esac
+    done
+    if test "$tmp_has_include" = "yes"; then
+      tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
+      tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
+      CFLAGS="$tmp_chg_FLAGS"
+      squeeze CFLAGS
+    fi
+    tmp_has_include="no"
+    tmp_chg_FLAGS="$CPPFLAGS"
+    for word1 in $tmp_chg_FLAGS; do
+      case "$word1" in
+        -I*)
+          tmp_has_include="yes"
+          ;;
+      esac
+    done
+    if test "$tmp_has_include" = "yes"; then
+      tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
+      tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
+      CPPFLAGS="$tmp_chg_FLAGS"
+      squeeze CPPFLAGS
+    fi
+  fi
+])
+
+
+dnl CARES_COMPILER_WORKS_IFELSE ([ACTION-IF-WORKS], [ACTION-IF-NOT-WORKS])
+dnl -------------------------------------------------
+dnl Verify if the C compiler seems to work with the
+dnl settings that are 'active' at the time the test
+dnl is performed.
+
+AC_DEFUN([CARES_COMPILER_WORKS_IFELSE], [
+  dnl compilation capability verification
+  tmp_compiler_works="unknown"
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      int i = 1;
+      return i;
+    ]])
+  ],[
+    tmp_compiler_works="yes"
+  ],[
+    tmp_compiler_works="no"
+    echo " " >&6
+    sed 's/^/cc-fail: /' conftest.err >&6
+    echo " " >&6
+  ])
+  dnl linking capability verification
+  if test "$tmp_compiler_works" = "yes"; then
+    AC_LINK_IFELSE([
+      AC_LANG_PROGRAM([[
+      ]],[[
+        int i = 1;
+        return i;
+      ]])
+    ],[
+      tmp_compiler_works="yes"
+    ],[
+      tmp_compiler_works="no"
+      echo " " >&6
+      sed 's/^/link-fail: /' conftest.err >&6
+      echo " " >&6
+    ])
+  fi
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tmp_compiler_works" = "yes"; then
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+#       ifdef __STDC__
+#         include <stdlib.h>
+#       endif
+      ]],[[
+        int i = 0;
+        exit(i);
+      ]])
+    ],[
+      tmp_compiler_works="yes"
+    ],[
+      tmp_compiler_works="no"
+      echo " " >&6
+      echo "run-fail: test program exited with status $ac_status" >&6
+      echo " " >&6
+    ])
+  fi
+  dnl branch upon test result
+  if test "$tmp_compiler_works" = "yes"; then
+  ifelse($1,,:,[$1])
+  ifelse($2,,,[else
+    $2])
+  fi
+])
+
+
+dnl CARES_SET_COMPILER_BASIC_OPTS
+dnl -------------------------------------------------
+dnl Sets compiler specific options/flags which do not
+dnl depend on configure's debug, optimize or warnings
+dnl options.
+
+AC_DEFUN([CARES_SET_COMPILER_BASIC_OPTS], [
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  #
+  if test "$compiler_id" != "unknown"; then
+    #
+    if test "$compiler_id" = "GNU_C" ||
+      test "$compiler_id" = "CLANG"; then
+      CARES_CONVERT_INCLUDE_TO_ISYSTEM
+    fi
+    #
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS=""
+    tmp_CFLAGS=""
+    #
+    case "$compiler_id" in
+        #
+      CLANG)
+        #
+        dnl Disable warnings for unused arguments, otherwise clang will
+        dnl warn about compile-time arguments used during link-time, like
+        dnl -O and -g and -pedantic.
+        tmp_CFLAGS="$tmp_CFLAGS -Qunused-arguments"
+        ;;
+        #
+      DEC_C)
+        #
+        dnl Select strict ANSI C compiler mode
+        tmp_CFLAGS="$tmp_CFLAGS -std1"
+        dnl Turn off optimizer ANSI C aliasing rules
+        tmp_CFLAGS="$tmp_CFLAGS -noansi_alias"
+        dnl Generate warnings for missing function prototypes
+        tmp_CFLAGS="$tmp_CFLAGS -warnprotos"
+        dnl Change some warnings into fatal errors
+        tmp_CFLAGS="$tmp_CFLAGS -msg_fatal toofewargs,toomanyargs"
+        ;;
+        #
+      GNU_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      HP_UX_C)
+        #
+        dnl Disallow run-time dereferencing of null pointers
+        tmp_CFLAGS="$tmp_CFLAGS -z"
+        dnl Disable some remarks
+        dnl #4227: padding struct with n bytes to align member
+        dnl #4255: padding size of struct with n bytes to alignment boundary
+        tmp_CFLAGS="$tmp_CFLAGS +W 4227,4255"
+        ;;
+        #
+      IBM_C)
+        #
+        dnl Ensure that compiler optimizations are always thread-safe.
+        tmp_CPPFLAGS="$tmp_CPPFLAGS -qthreaded"
+        dnl Disable type based strict aliasing optimizations, using worst
+        dnl case aliasing assumptions when compiling. Type based aliasing
+        dnl would restrict the lvalues that could be safely used to access
+        dnl a data object.
+        tmp_CPPFLAGS="$tmp_CPPFLAGS -qnoansialias"
+        dnl Force compiler to stop after the compilation phase, without
+        dnl generating an object code file when compilation has errors.
+        tmp_CPPFLAGS="$tmp_CPPFLAGS -qhalt=e"
+        ;;
+        #
+      INTEL_UNIX_C)
+        #
+        dnl On unix this compiler uses gcc's header files, so
+        dnl we select ANSI C89 dialect plus GNU extensions.
+        tmp_CFLAGS="$tmp_CFLAGS -std=gnu89"
+        dnl Change some warnings into errors
+        dnl #140: too many arguments in function call
+        dnl #147: declaration is incompatible with 'previous one'
+        dnl #165: too few arguments in function call
+        dnl #266: function declared implicitly
+        tmp_CPPFLAGS="$tmp_CPPFLAGS -we 140,147,165,266"
+        dnl Disable some remarks
+        dnl #279: controlling expression is constant
+        dnl #981: operands are evaluated in unspecified order
+        dnl #1469: "cc" clobber ignored
+        tmp_CPPFLAGS="$tmp_CPPFLAGS -wd 279,981,1469"
+        ;;
+        #
+      INTEL_WINDOWS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      LCC)
+        #
+        dnl Disallow run-time dereferencing of null pointers
+        tmp_CFLAGS="$tmp_CFLAGS -n"
+        ;;
+        #
+      SGI_MIPS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      SGI_MIPSPRO_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      SUNPRO_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      TINY_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      WATCOM_UNIX_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      WATCOM_WINDOWS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+    esac
+    #
+    squeeze tmp_CPPFLAGS
+    squeeze tmp_CFLAGS
+    #
+    if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
+      AC_MSG_CHECKING([if compiler accepts some basic options])
+      CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+      CARES_COMPILER_WORKS_IFELSE([
+        AC_MSG_RESULT([yes])
+        AC_MSG_NOTICE([compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS])
+      ],[
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN([compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS])
+        dnl restore initial settings
+        CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+      ])
+    fi
+    #
+  fi
+])
+
+
+dnl CARES_SET_COMPILER_DEBUG_OPTS
+dnl -------------------------------------------------
+dnl Sets compiler specific options/flags which depend
+dnl on configure's debug option.
+
+AC_DEFUN([CARES_SET_COMPILER_DEBUG_OPTS], [
+  AC_REQUIRE([CARES_CHECK_OPTION_DEBUG])dnl
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    #
+    tmp_options=""
+    tmp_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS="$CPPFLAGS"
+    CARES_VAR_STRIP([tmp_CFLAGS],[$flags_dbg_all])
+    CARES_VAR_STRIP([tmp_CPPFLAGS],[$flags_dbg_all])
+    #
+    if test "$want_debug" = "yes"; then
+      AC_MSG_CHECKING([if compiler accepts debug enabling options])
+      tmp_options="$flags_dbg_yes"
+    fi
+    if test "$want_debug" = "no"; then
+      AC_MSG_CHECKING([if compiler accepts debug disabling options])
+      tmp_options="$flags_dbg_off"
+    fi
+    #
+    if test "$flags_prefer_cppflags" = "yes"; then
+      CPPFLAGS="$tmp_CPPFLAGS $tmp_options"
+      CFLAGS="$tmp_CFLAGS"
+    else
+      CPPFLAGS="$tmp_CPPFLAGS"
+      CFLAGS="$tmp_CFLAGS $tmp_options"
+    fi
+    squeeze CPPFLAGS
+    squeeze CFLAGS
+    CARES_COMPILER_WORKS_IFELSE([
+      AC_MSG_RESULT([yes])
+      AC_MSG_NOTICE([compiler options added: $tmp_options])
+    ],[
+      AC_MSG_RESULT([no])
+      AC_MSG_WARN([compiler options rejected: $tmp_options])
+      dnl restore initial settings
+      CPPFLAGS="$tmp_save_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS"
+    ])
+    #
+  fi
+])
+
+
+dnl CARES_SET_COMPILER_OPTIMIZE_OPTS
+dnl -------------------------------------------------
+dnl Sets compiler specific options/flags which depend
+dnl on configure's optimize option.
+
+AC_DEFUN([CARES_SET_COMPILER_OPTIMIZE_OPTS], [
+  AC_REQUIRE([CARES_CHECK_OPTION_OPTIMIZE])dnl
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    #
+    tmp_options=""
+    tmp_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS="$CPPFLAGS"
+    honor_optimize_option="yes"
+    #
+    dnl If optimization request setting has not been explicitly specified,
+    dnl it has been derived from the debug setting and initially assumed.
+    dnl This initially assumed optimizer setting will finally be ignored
+    dnl if CFLAGS or CPPFLAGS already hold optimizer flags. This implies
+    dnl that an initially assumed optimizer setting might not be honored.
+    #
+    if test "$want_optimize" = "assume_no" ||
+       test "$want_optimize" = "assume_yes"; then
+      AC_MSG_CHECKING([if compiler optimizer assumed setting might be used])
+      CARES_VAR_MATCH_IFELSE([tmp_CFLAGS],[$flags_opt_all],[
+        honor_optimize_option="no"
+      ])
+      CARES_VAR_MATCH_IFELSE([tmp_CPPFLAGS],[$flags_opt_all],[
+        honor_optimize_option="no"
+      ])
+      AC_MSG_RESULT([$honor_optimize_option])
+      if test "$honor_optimize_option" = "yes"; then
+        if test "$want_optimize" = "assume_yes"; then
+          want_optimize="yes"
+        fi
+        if test "$want_optimize" = "assume_no"; then
+          want_optimize="no"
+        fi
+      fi
+    fi
+    #
+    if test "$honor_optimize_option" = "yes"; then
+      CARES_VAR_STRIP([tmp_CFLAGS],[$flags_opt_all])
+      CARES_VAR_STRIP([tmp_CPPFLAGS],[$flags_opt_all])
+      if test "$want_optimize" = "yes"; then
+        AC_MSG_CHECKING([if compiler accepts optimizer enabling options])
+        tmp_options="$flags_opt_yes"
+      fi
+      if test "$want_optimize" = "no"; then
+        AC_MSG_CHECKING([if compiler accepts optimizer disabling options])
+        tmp_options="$flags_opt_off"
+      fi
+      if test "$flags_prefer_cppflags" = "yes"; then
+        CPPFLAGS="$tmp_CPPFLAGS $tmp_options"
+        CFLAGS="$tmp_CFLAGS"
+      else
+        CPPFLAGS="$tmp_CPPFLAGS"
+        CFLAGS="$tmp_CFLAGS $tmp_options"
+      fi
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+      CARES_COMPILER_WORKS_IFELSE([
+        AC_MSG_RESULT([yes])
+        AC_MSG_NOTICE([compiler options added: $tmp_options])
+      ],[
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN([compiler options rejected: $tmp_options])
+        dnl restore initial settings
+        CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+      ])
+    fi
+    #
+  fi
+])
+
+
+dnl CARES_SET_COMPILER_WARNING_OPTS
+dnl -------------------------------------------------
+dnl Sets compiler options/flags which depend on
+dnl configure's warnings given option.
+
+AC_DEFUN([CARES_SET_COMPILER_WARNING_OPTS], [
+  AC_REQUIRE([CARES_CHECK_OPTION_WARNINGS])dnl
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS=""
+    tmp_CFLAGS=""
+    #
+    case "$compiler_id" in
+        #
+      CLANG)
+        #
+        if test "$want_warnings" = "yes"; then
+          tmp_CFLAGS="$tmp_CFLAGS -pedantic"
+          tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
+          tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
+          tmp_CFLAGS="$tmp_CFLAGS -Wshadow"
+          tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
+          tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
+          tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+          tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
+          tmp_CFLAGS="$tmp_CFLAGS -Wundef"
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+          tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
+          tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
+          tmp_CFLAGS="$tmp_CFLAGS -Wcast-align"
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+          tmp_CFLAGS="$tmp_CFLAGS -Wshorten-64-to-32"
+          #
+          dnl Only clang 1.1 or later
+          if test "$compiler_num" -ge "101"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wunused"
+          fi
+        fi
+        ;;
+        #
+      DEC_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Select a higher warning level than default level2
+          tmp_CFLAGS="$tmp_CFLAGS -msg_enable level3"
+        fi
+        ;;
+        #
+      GNU_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          #
+          dnl Do not enable -pedantic when cross-compiling with a gcc older
+          dnl than 3.0, to avoid warnings from third party system headers.
+          if test "x$cross_compiling" != "xyes" ||
+            test "$compiler_num" -ge "300"; then
+            tmp_CFLAGS="$tmp_CFLAGS -pedantic"
+          fi
+          #
+          dnl Set of options we believe *ALL* gcc versions support:
+          tmp_CFLAGS="$tmp_CFLAGS -Wall -W"
+          #
+          dnl Only gcc 1.4 or later
+          if test "$compiler_num" -ge "104"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
+            dnl If not cross-compiling with a gcc older than 3.0
+            if test "x$cross_compiling" != "xyes" ||
+              test "$compiler_num" -ge "300"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wunused -Wshadow"
+            fi
+          fi
+          #
+          dnl Only gcc 2.7 or later
+          if test "$compiler_num" -ge "207"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
+            dnl If not cross-compiling with a gcc older than 3.0
+            if test "x$cross_compiling" != "xyes" ||
+              test "$compiler_num" -ge "300"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
+              tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
+            fi
+          fi
+          #
+          dnl Only gcc 2.95 or later
+          if test "$compiler_num" -ge "295"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+          fi
+          #
+          dnl Only gcc 2.96 or later
+          if test "$compiler_num" -ge "296"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
+            dnl -Wundef used only if gcc is 2.96 or later since we get
+            dnl lots of "`_POSIX_C_SOURCE' is not defined" in system
+            dnl headers with gcc 2.95.4 on FreeBSD 4.9
+            tmp_CFLAGS="$tmp_CFLAGS -Wundef"
+          fi
+          #
+          dnl Only gcc 2.97 or later
+          if test "$compiler_num" -ge "297"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+          fi
+          #
+          dnl Only gcc 3.0 or later
+          if test "$compiler_num" -ge "300"; then
+            dnl -Wunreachable-code seems totally unreliable on my gcc 3.3.2 on
+            dnl on i686-Linux as it gives us heaps with false positives.
+            dnl Also, on gcc 4.0.X it is totally unbearable and complains all
+            dnl over making it unusable for generic purposes. Let's not use it.
+            tmp_CFLAGS="$tmp_CFLAGS"
+          fi
+          #
+          dnl Only gcc 3.3 or later
+          if test "$compiler_num" -ge "303"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
+          fi
+          #
+          dnl Only gcc 3.4 or later
+          if test "$compiler_num" -ge "304"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
+          fi
+          #
+          dnl Only gcc 4.0 or later
+          if test "$compiler_num" -ge "400"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wstrict-aliasing=3"
+          fi
+          #
+          dnl Only gcc 4.2 or later
+          if test "$compiler_num" -ge "402"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wcast-align"
+          fi
+          #
+          dnl Only gcc 4.3 or later
+          if test "$compiler_num" -ge "403"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wtype-limits -Wold-style-declaration"
+            tmp_CFLAGS="$tmp_CFLAGS -Wmissing-parameter-type -Wempty-body"
+            tmp_CFLAGS="$tmp_CFLAGS -Wclobbered -Wignored-qualifiers"
+            tmp_CFLAGS="$tmp_CFLAGS -Wconversion -Wno-sign-conversion -Wvla"
+          fi
+          #
+          dnl Only gcc 4.5 or later
+          if test "$compiler_num" -ge "405"; then
+            dnl Only windows targets
+            if test "$curl_cv_have_def__WIN32" = "yes"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-pedantic-ms-format"
+            fi
+          fi
+          #
+        fi
+        #
+        dnl Do not issue warnings for code in system include paths.
+        if test "$compiler_num" -ge "300"; then
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+        else
+          dnl When cross-compiling with a gcc older than 3.0, disable
+          dnl some warnings triggered on third party system headers.
+          if test "x$cross_compiling" = "xyes"; then
+            if test "$compiler_num" -ge "104"; then
+              dnl gcc 1.4 or later
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-unused -Wno-shadow"
+            fi
+            if test "$compiler_num" -ge "207"; then
+              dnl gcc 2.7 or later
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-declarations"
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-prototypes"
+            fi
+          fi
+        fi
+        ;;
+        #
+      HP_UX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Issue all warnings
+          tmp_CFLAGS="$tmp_CFLAGS +w1"
+        fi
+        ;;
+        #
+      IBM_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      INTEL_UNIX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          if test "$compiler_num" -gt "600"; then
+            dnl Show errors, warnings, and remarks
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wall -w2"
+            dnl Perform extra compile-time code checking
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcheck"
+            dnl Warn on nested comments
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcomment"
+            dnl Show warnings relative to deprecated features
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wdeprecated"
+            dnl Enable warnings for missing prototypes
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wmissing-prototypes"
+            dnl Enable warnings for 64-bit portability issues
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wp64"
+            dnl Enable warnings for questionable pointer arithmetic
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wpointer-arith"
+            dnl Check for function return typw issues
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wreturn-type"
+            dnl Warn on variable declarations hiding a previous one
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wshadow"
+            dnl Warn when a variable is used before initialized
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wuninitialized"
+            dnl Warn if a declared function is not used
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wunused-function"
+          fi
+        fi
+        dnl Disable using EBP register in optimizations
+        tmp_CFLAGS="$tmp_CFLAGS -fno-omit-frame-pointer"
+        dnl Disable use of ANSI C aliasing rules in optimizations
+        tmp_CFLAGS="$tmp_CFLAGS -fno-strict-aliasing"
+        dnl Value-safe optimizations on floating-point data
+        tmp_CFLAGS="$tmp_CFLAGS -fp-model precise"
+        dnl Only icc 10.0 or later
+        if test "$compiler_num" -ge "1000"; then
+          dnl Disable vectorizer diagnostic information
+          tmp_CFLAGS="$tmp_CFLAGS -vec-report0"
+        fi
+        ;;
+        #
+      INTEL_WINDOWS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      LCC)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Highest warning level is double -A, next is single -A.
+          dnl Due to the big number of warnings these trigger on third
+          dnl party header files it is impractical for us to use any of
+          dnl them here. If you want them simply define it in CPPFLAGS.
+          tmp_CFLAGS="$tmp_CFLAGS"
+        fi
+        ;;
+        #
+      SGI_MIPS_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Perform stricter semantic and lint-like checks
+          tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
+        fi
+        ;;
+        #
+      SGI_MIPSPRO_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Perform stricter semantic and lint-like checks
+          tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
+          dnl Disable some remarks
+          dnl #1209: controlling expression is constant
+          tmp_CFLAGS="$tmp_CFLAGS -woff 1209"
+        fi
+        ;;
+        #
+      SUNPRO_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Perform stricter semantic and lint-like checks
+          tmp_CFLAGS="$tmp_CFLAGS -v"
+        fi
+        ;;
+        #
+      TINY_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Activate all warnings
+          tmp_CFLAGS="$tmp_CFLAGS -Wall"
+          dnl Make string constants be of type const char *
+          tmp_CFLAGS="$tmp_CFLAGS -Wwrite-strings"
+          dnl Warn use of unsupported GCC features ignored by TCC
+          tmp_CFLAGS="$tmp_CFLAGS -Wunsupported"
+        fi
+        ;;
+        #
+      WATCOM_UNIX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Issue all warnings
+          tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
+        fi
+        ;;
+        #
+      WATCOM_WINDOWS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+    esac
+    #
+    squeeze tmp_CPPFLAGS
+    squeeze tmp_CFLAGS
+    #
+    if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
+      AC_MSG_CHECKING([if compiler accepts strict warning options])
+      CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+      CARES_COMPILER_WORKS_IFELSE([
+        AC_MSG_RESULT([yes])
+        AC_MSG_NOTICE([compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS])
+      ],[
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN([compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS])
+        dnl restore initial settings
+        CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+      ])
+    fi
+    #
+  fi
+])
+
+
+dnl CARES_SHFUNC_SQUEEZE
+dnl -------------------------------------------------
+dnl Declares a shell function squeeze() which removes
+dnl redundant whitespace out of a shell variable.
+
+AC_DEFUN([CARES_SHFUNC_SQUEEZE], [
+squeeze() {
+  _sqz_result=""
+  eval _sqz_input=\[$][$]1
+  for _sqz_token in $_sqz_input; do
+    if test -z "$_sqz_result"; then
+      _sqz_result="$_sqz_token"
+    else
+      _sqz_result="$_sqz_result $_sqz_token"
+    fi
+  done
+  eval [$]1=\$_sqz_result
+  return 0
+}
+])
+
+
+dnl CARES_CHECK_COMPILER_HALT_ON_ERROR
+dnl -------------------------------------------------
+dnl Verifies if the compiler actually halts after the
+dnl compilation phase without generating any object
+dnl code file, when the source compiles with errors.
+
+AC_DEFUN([CARES_CHECK_COMPILER_HALT_ON_ERROR], [
+  AC_MSG_CHECKING([if compiler halts on compilation errors])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      force compilation error
+    ]])
+  ],[
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler does not halt on compilation errors.])
+  ],[
+    AC_MSG_RESULT([yes])
+  ])
+])
+
+
+dnl CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
+dnl -------------------------------------------------
+dnl Verifies if the compiler actually halts after the
+dnl compilation phase without generating any object
+dnl code file, when the source code tries to define a
+dnl type for a constant array with negative dimension.
+
+AC_DEFUN([CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_HALT_ON_ERROR])dnl
+  AC_MSG_CHECKING([if compiler halts on negative sized arrays])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
+    ]],[[
+      bad_t dummy;
+    ]])
+  ],[
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
+  ],[
+    AC_MSG_RESULT([yes])
+  ])
+])
+
+
+dnl CARES_CHECK_COMPILER_STRUCT_MEMBER_SIZE
+dnl -------------------------------------------------
+dnl Verifies if the compiler is capable of handling the
+dnl size of a struct member, struct which is a function
+dnl result, as a compilation-time condition inside the
+dnl type definition of a constant array.
+
+AC_DEFUN([CARES_CHECK_COMPILER_STRUCT_MEMBER_SIZE], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE])dnl
+  AC_MSG_CHECKING([if compiler struct member size checking works])
+  tst_compiler_check_one_works="unknown"
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      struct mystruct {
+        int  mi;
+        char mc;
+        struct mystruct *next;
+      };
+      struct mystruct myfunc();
+      typedef char good_t1[sizeof(myfunc().mi) == sizeof(int)  ? 1 : -1 ];
+      typedef char good_t2[sizeof(myfunc().mc) == sizeof(char) ? 1 : -1 ];
+    ]],[[
+      good_t1 dummy1;
+      good_t2 dummy2;
+    ]])
+  ],[
+    tst_compiler_check_one_works="yes"
+  ],[
+    tst_compiler_check_one_works="no"
+    sed 's/^/cc-src: /' conftest.$ac_ext >&6
+    sed 's/^/cc-err: /' conftest.err >&6
+  ])
+  tst_compiler_check_two_works="unknown"
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      struct mystruct {
+        int  mi;
+        char mc;
+        struct mystruct *next;
+      };
+      struct mystruct myfunc();
+      typedef char bad_t1[sizeof(myfunc().mi) != sizeof(int)  ? 1 : -1 ];
+      typedef char bad_t2[sizeof(myfunc().mc) != sizeof(char) ? 1 : -1 ];
+    ]],[[
+      bad_t1 dummy1;
+      bad_t2 dummy2;
+    ]])
+  ],[
+    tst_compiler_check_two_works="no"
+  ],[
+    tst_compiler_check_two_works="yes"
+  ])
+  if test "$tst_compiler_check_one_works" = "yes" &&
+    test "$tst_compiler_check_two_works" = "yes"; then
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler fails struct member size checking.])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_SYMBOL_HIDING
+dnl -------------------------------------------------
+dnl Verify if compiler supports hiding library internal symbols, setting
+dnl shell variable supports_symbol_hiding value as appropriate, as well as
+dnl variables symbol_hiding_CFLAGS and symbol_hiding_EXTERN when supported.
+
+AC_DEFUN([CARES_CHECK_COMPILER_SYMBOL_HIDING], [
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_BEFORE([$0],[CARES_CONFIGURE_SYMBOL_HIDING])dnl
+  AC_MSG_CHECKING([if compiler supports hiding library internal symbols])
+  supports_symbol_hiding="no"
+  symbol_hiding_CFLAGS=""
+  symbol_hiding_EXTERN=""
+  tmp_CFLAGS=""
+  tmp_EXTERN=""
+  case "$compiler_id" in
+    CLANG)
+      dnl All versions of clang support -fvisibility=
+      tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
+      tmp_CFLAGS="-fvisibility=hidden"
+      supports_symbol_hiding="yes"
+      ;;
+    GNU_C)
+      dnl Only gcc 3.4 or later
+      if test "$compiler_num" -ge "304"; then
+        if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
+          tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
+          tmp_CFLAGS="-fvisibility=hidden"
+          supports_symbol_hiding="yes"
+        fi
+      fi
+      ;;
+    INTEL_UNIX_C)
+      dnl Only icc 9.0 or later
+      if test "$compiler_num" -ge "900"; then
+        if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
+          tmp_save_CFLAGS="$CFLAGS"
+          CFLAGS="$CFLAGS -fvisibility=hidden"
+          AC_LINK_IFELSE([
+            AC_LANG_PROGRAM([[
+#             include <stdio.h>
+            ]],[[
+              printf("icc fvisibility bug test");
+            ]])
+          ],[
+            tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
+            tmp_CFLAGS="-fvisibility=hidden"
+            supports_symbol_hiding="yes"
+          ])
+          CFLAGS="$tmp_save_CFLAGS"
+        fi
+      fi
+      ;;
+    SUNPRO_C)
+      if $CC 2>&1 | grep flags >/dev/null && $CC -flags | grep xldscope= >/dev/null ; then
+        tmp_EXTERN="__global"
+        tmp_CFLAGS="-xldscope=hidden"
+        supports_symbol_hiding="yes"
+      fi
+      ;;
+  esac
+  if test "$supports_symbol_hiding" = "yes"; then
+    tmp_save_CFLAGS="$CFLAGS"
+    CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+    squeeze CFLAGS
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $tmp_EXTERN char *dummy(char *buff);
+        char *dummy(char *buff)
+        {
+         if(buff)
+           return ++buff;
+         else
+           return buff;
+        }
+      ]],[[
+        char b[16];
+        char *r = dummy(&b[0]);
+        if(r)
+          return (int)*r;
+      ]])
+    ],[
+      supports_symbol_hiding="yes"
+      if test -f conftest.err; then
+        grep 'visibility' conftest.err >/dev/null
+        if test "$?" -eq "0"; then
+          supports_symbol_hiding="no"
+        fi
+      fi
+    ],[
+      supports_symbol_hiding="no"
+      echo " " >&6
+      sed 's/^/cc-src: /' conftest.$ac_ext >&6
+      sed 's/^/cc-err: /' conftest.err >&6
+      echo " " >&6
+    ])
+    CFLAGS="$tmp_save_CFLAGS"
+  fi
+  if test "$supports_symbol_hiding" = "yes"; then
+    AC_MSG_RESULT([yes])
+    symbol_hiding_CFLAGS="$tmp_CFLAGS"
+    symbol_hiding_EXTERN="$tmp_EXTERN"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_PROTOTYPE_MISMATCH
+dnl -------------------------------------------------
+dnl Verifies if the compiler actually halts after the
+dnl compilation phase without generating any object
+dnl code file, when the source code tries to redefine
+dnl a prototype which does not match previous one.
+
+AC_DEFUN([CARES_CHECK_COMPILER_PROTOTYPE_MISMATCH], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_HALT_ON_ERROR])dnl
+  AC_MSG_CHECKING([if compiler halts on function prototype mismatch])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+#     include <stdlib.h>
+      int rand(int n);
+      int rand(int n)
+      {
+        if(n)
+          return ++n;
+        else
+          return n;
+      }
+    ]],[[
+      int i[2];
+      int j = rand(i[0]);
+      if(j)
+        return j;
+    ]])
+  ],[
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler does not halt on function prototype mismatch.])
+  ],[
+    AC_MSG_RESULT([yes])
+  ])
+])
+
+
+dnl CARES_VAR_MATCH (VARNAME, VALUE)
+dnl -------------------------------------------------
+dnl Verifies if shell variable VARNAME contains VALUE.
+dnl Contents of variable VARNAME and VALUE are handled
+dnl as whitespace separated lists of words. If at least
+dnl one word of VALUE is present in VARNAME the match
+dnl is considered positive, otherwise false.
+
+AC_DEFUN([CARES_VAR_MATCH], [
+  ac_var_match_word="no"
+  for word1 in $[$1]; do
+    for word2 in [$2]; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+])
+
+
+dnl CARES_VAR_MATCH_IFELSE (VARNAME, VALUE,
+dnl                        [ACTION-IF-MATCH], [ACTION-IF-NOT-MATCH])
+dnl -------------------------------------------------
+dnl This performs a CURL_VAR_MATCH check and executes
+dnl first branch if the match is positive, otherwise
+dnl the second branch is executed.
+
+AC_DEFUN([CARES_VAR_MATCH_IFELSE], [
+  CARES_VAR_MATCH([$1],[$2])
+  if test "$ac_var_match_word" = "yes"; then
+  ifelse($3,,:,[$3])
+  ifelse($4,,,[else
+    $4])
+  fi
+])
+
+
+dnl CARES_VAR_STRIP (VARNAME, VALUE)
+dnl -------------------------------------------------
+dnl Contents of variable VARNAME and VALUE are handled
+dnl as whitespace separated lists of words. Each word
+dnl from VALUE is removed from VARNAME when present.
+
+AC_DEFUN([CARES_VAR_STRIP], [
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  ac_var_stripped=""
+  for word1 in $[$1]; do
+    ac_var_strip_word="no"
+    for word2 in [$2]; do
+      if test "$word1" = "$word2"; then
+        ac_var_strip_word="yes"
+      fi
+    done
+    if test "$ac_var_strip_word" = "no"; then
+      ac_var_stripped="$ac_var_stripped $word1"
+    fi
+  done
+  dnl squeeze whitespace out of result
+  [$1]="$ac_var_stripped"
+  squeeze [$1]
+])
+
diff --git a/deps/cares/m4/cares-confopts.m4 b/deps/cares/m4/cares-confopts.m4
new file mode 100644
index 0000000000000000000000000000000000000000..78af64bffe1b991f68075dd1c82052fb9a7a856b
--- /dev/null
+++ b/deps/cares/m4/cares-confopts.m4
@@ -0,0 +1,356 @@
+#***************************************************************************
+#
+# Copyright (C) 2008 - 2013 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 11
+
+
+dnl CARES_CHECK_OPTION_DEBUG
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-debug or --disable-debug, and set shell
+dnl variable want_debug value as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_DEBUG], [
+  AC_BEFORE([$0],[CARES_CHECK_OPTION_WARNINGS])dnl
+  AC_BEFORE([$0],[XC_CHECK_PROG_CC])dnl
+  AC_MSG_CHECKING([whether to enable debug build options])
+  OPT_DEBUG_BUILD="default"
+  AC_ARG_ENABLE(debug,
+AS_HELP_STRING([--enable-debug],[Enable debug build options])
+AS_HELP_STRING([--disable-debug],[Disable debug build options]),
+  OPT_DEBUG_BUILD=$enableval)
+  case "$OPT_DEBUG_BUILD" in
+    no)
+      dnl --disable-debug option used
+      want_debug="no"
+      ;;
+    default)
+      dnl configure option not specified
+      want_debug="no"
+      ;;
+    *)
+      dnl --enable-debug option used
+      want_debug="yes"
+      ;;
+  esac
+  AC_MSG_RESULT([$want_debug])
+])
+
+
+dnl CARES_CHECK_OPTION_NONBLOCKING
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-nonblocking or --disable-nonblocking, and
+dnl set shell variable want_nonblocking as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_NONBLOCKING], [
+  AC_BEFORE([$0],[CARES_CHECK_NONBLOCKING_SOCKET])dnl
+  AC_MSG_CHECKING([whether to enable non-blocking communications])
+  OPT_NONBLOCKING="default"
+  AC_ARG_ENABLE(nonblocking,
+AS_HELP_STRING([--enable-nonblocking],[Enable non-blocking communications])
+AS_HELP_STRING([--disable-nonblocking],[Disable non-blocking communications]),
+  OPT_NONBLOCKING=$enableval)
+  case "$OPT_NONBLOCKING" in
+    no)
+      dnl --disable-nonblocking option used
+      want_nonblocking="no"
+      ;;
+    default)
+      dnl configure option not specified
+      want_nonblocking="yes"
+      ;;
+    *)
+      dnl --enable-nonblocking option used
+      want_nonblocking="yes"
+      ;;
+  esac
+  AC_MSG_RESULT([$want_nonblocking])
+])
+
+
+dnl CARES_CHECK_OPTION_OPTIMIZE
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-optimize or --disable-optimize, and set
+dnl shell variable want_optimize value as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_OPTIMIZE], [
+  AC_REQUIRE([CARES_CHECK_OPTION_DEBUG])dnl
+  AC_BEFORE([$0],[XC_CHECK_PROG_CC])dnl
+  AC_MSG_CHECKING([whether to enable compiler optimizer])
+  OPT_COMPILER_OPTIMIZE="default"
+  AC_ARG_ENABLE(optimize,
+AS_HELP_STRING([--enable-optimize(=OPT)],[Enable compiler optimizations (default=-O2)])
+AS_HELP_STRING([--disable-optimize],[Disable compiler optimizations]),
+  OPT_COMPILER_OPTIMIZE=$enableval)
+  case "$OPT_COMPILER_OPTIMIZE" in
+    no)
+      dnl --disable-optimize option used. We will handle this as
+      dnl a request to disable compiler optimizations if possible.
+      dnl If the compiler is known CFLAGS and CPPFLAGS will be
+      dnl overridden, otherwise this can not be honored.
+      want_optimize="no"
+      AC_MSG_RESULT([no])
+      ;;
+    default)
+      dnl configure's optimize option not specified. Initially we will
+      dnl handle this as a a request contrary to configure's setting
+      dnl for --enable-debug. IOW, initially, for debug-enabled builds
+      dnl this will be handled as a request to disable optimizations if
+      dnl possible, and for debug-disabled builds this will be handled
+      dnl initially as a request to enable optimizations if possible.
+      dnl Finally, if the compiler is known and CFLAGS and CPPFLAGS do
+      dnl not have any optimizer flag the request will be honored, in
+      dnl any other case the request can not be honored.
+      dnl IOW, existing optimizer flags defined in CFLAGS or CPPFLAGS
+      dnl will always take precedence over any initial assumption.
+      if test "$want_debug" = "yes"; then
+        want_optimize="assume_no"
+        AC_MSG_RESULT([not specified (assuming no)])
+      else
+        want_optimize="assume_yes"
+        AC_MSG_RESULT([not specified (assuming yes)])
+      fi
+      ;;
+    *)
+      dnl --enable-optimize option used. We will handle this as
+      dnl a request to enable compiler optimizations if possible.
+      dnl If the compiler is known CFLAGS and CPPFLAGS will be
+      dnl overridden, otherwise this can not be honored.
+      want_optimize="yes"
+      AC_MSG_RESULT([yes])
+      ;;
+  esac
+])
+
+
+dnl CARES_CHECK_OPTION_SYMBOL_HIDING
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-symbol-hiding or --disable-symbol-hiding,
+dnl setting shell variable want_symbol_hiding value.
+
+AC_DEFUN([CARES_CHECK_OPTION_SYMBOL_HIDING], [
+  AC_BEFORE([$0],[CARES_CHECK_COMPILER_SYMBOL_HIDING])dnl
+  AC_MSG_CHECKING([whether to enable hiding of library internal symbols])
+  OPT_SYMBOL_HIDING="default"
+  AC_ARG_ENABLE(symbol-hiding,
+AS_HELP_STRING([--enable-symbol-hiding],[Enable hiding of library internal symbols])
+AS_HELP_STRING([--disable-symbol-hiding],[Disable hiding of library internal symbols]),
+  OPT_SYMBOL_HIDING=$enableval)
+  case "$OPT_SYMBOL_HIDING" in
+    no)
+      dnl --disable-symbol-hiding option used.
+      dnl This is an indication to not attempt hiding of library internal
+      dnl symbols. Default symbol visibility will be used, which normally
+      dnl exposes all library internal symbols.
+      want_symbol_hiding="no"
+      AC_MSG_RESULT([no])
+      ;;
+    default)
+      dnl configure's symbol-hiding option not specified.
+      dnl Handle this as if --enable-symbol-hiding option was given.
+      want_symbol_hiding="yes"
+      AC_MSG_RESULT([yes])
+      ;;
+    *)
+      dnl --enable-symbol-hiding option used.
+      dnl This is an indication to attempt hiding of library internal
+      dnl symbols. This is only supported on some compilers/linkers.
+      want_symbol_hiding="yes"
+      AC_MSG_RESULT([yes])
+      ;;
+  esac
+])
+
+
+dnl CARES_CHECK_OPTION_EXPOSE_STATICS
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-expose-statics or --disable-expose-statics,
+dnl setting shell variable want_expose_statics value.
+
+AC_DEFUN([CARES_CHECK_OPTION_EXPOSE_STATICS], [
+  AC_MSG_CHECKING([whether to expose internal static functions for testing])
+  OPT_EXPOSE_STATICS="default"
+  AC_ARG_ENABLE(expose-statics,
+AS_HELP_STRING([--enable-expose-statics],[Enable exposure of internal static functions for testing])
+AS_HELP_STRING([--disable-expose-statics],[Disable exposure of internal static functions for testing]),
+  OPT_EXPOSE_STATICS=$enableval)
+  case "$OPT_EXPOSE_STATICS" in
+    no)
+      dnl --disable-expose-statics option used.
+      want_expose_statics="no"
+      AC_MSG_RESULT([no])
+      ;;
+    default)
+      dnl configure's expose-statics option not specified.
+      dnl Handle this as if --disable-expose-statics option was given.
+      want_expose_statics="no"
+      AC_MSG_RESULT([no])
+      ;;
+    *)
+      dnl --enable-expose-statics option used.
+      want_expose_statics="yes"
+      AC_MSG_RESULT([yes])
+      ;;
+  esac
+  if test "$want_expose_statics" = "yes"; then
+    AC_DEFINE_UNQUOTED(CARES_EXPOSE_STATICS, 1,
+      [Defined for build that exposes internal static functions for testing.])
+  fi
+])
+
+
+dnl CARES_CHECK_OPTION_WARNINGS
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-warnings or --disable-warnings, and set
+dnl shell variable want_warnings as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_WARNINGS], [
+  AC_REQUIRE([CARES_CHECK_OPTION_DEBUG])dnl
+  AC_BEFORE([$0],[CARES_CHECK_OPTION_WERROR])dnl
+  AC_BEFORE([$0],[XC_CHECK_PROG_CC])dnl
+  AC_MSG_CHECKING([whether to enable strict compiler warnings])
+  OPT_COMPILER_WARNINGS="default"
+  AC_ARG_ENABLE(warnings,
+AS_HELP_STRING([--enable-warnings],[Enable strict compiler warnings])
+AS_HELP_STRING([--disable-warnings],[Disable strict compiler warnings]),
+  OPT_COMPILER_WARNINGS=$enableval)
+  case "$OPT_COMPILER_WARNINGS" in
+    no)
+      dnl --disable-warnings option used
+      want_warnings="no"
+      ;;
+    default)
+      dnl configure option not specified, so
+      dnl use same setting as --enable-debug
+      want_warnings="$want_debug"
+      ;;
+    *)
+      dnl --enable-warnings option used
+      want_warnings="yes"
+      ;;
+  esac
+  AC_MSG_RESULT([$want_warnings])
+])
+
+dnl CARES_CHECK_OPTION_WERROR
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-werror or --disable-werror, and set
+dnl shell variable want_werror as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_WERROR], [
+  AC_BEFORE([$0],[CARES_CHECK_COMPILER])dnl
+  AC_MSG_CHECKING([whether to enable compiler warnings as errors])
+  OPT_COMPILER_WERROR="default"
+  AC_ARG_ENABLE(werror,
+AS_HELP_STRING([--enable-werror],[Enable compiler warnings as errors])
+AS_HELP_STRING([--disable-werror],[Disable compiler warnings as errors]),
+  OPT_COMPILER_WERROR=$enableval)
+  case "$OPT_COMPILER_WERROR" in
+    no)
+      dnl --disable-werror option used
+      want_werror="no"
+      ;;
+    default)
+      dnl configure option not specified
+      want_werror="no"
+      ;;
+    *)
+      dnl --enable-werror option used
+      want_werror="yes"
+      ;;
+  esac
+  AC_MSG_RESULT([$want_werror])
+])
+
+
+dnl CARES_CHECK_NONBLOCKING_SOCKET
+dnl -------------------------------------------------
+dnl Check for how to set a socket into non-blocking state.
+
+AC_DEFUN([CARES_CHECK_NONBLOCKING_SOCKET], [
+  AC_REQUIRE([CARES_CHECK_OPTION_NONBLOCKING])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_FCNTL])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_IOCTL])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_IOCTLSOCKET])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_SETSOCKOPT])dnl
+  #
+  tst_method="unknown"
+  if test "$want_nonblocking" = "yes"; then
+    AC_MSG_CHECKING([how to set a socket into non-blocking mode])
+    if test "x$ac_cv_func_fcntl_o_nonblock" = "xyes"; then
+      tst_method="fcntl O_NONBLOCK"
+    elif test "x$ac_cv_func_ioctl_fionbio" = "xyes"; then
+      tst_method="ioctl FIONBIO"
+    elif test "x$ac_cv_func_ioctlsocket_fionbio" = "xyes"; then
+      tst_method="ioctlsocket FIONBIO"
+    elif test "x$ac_cv_func_ioctlsocket_camel_fionbio" = "xyes"; then
+      tst_method="IoctlSocket FIONBIO"
+    elif test "x$ac_cv_func_setsockopt_so_nonblock" = "xyes"; then
+      tst_method="setsockopt SO_NONBLOCK"
+    fi
+    AC_MSG_RESULT([$tst_method])
+    if test "$tst_method" = "unknown"; then
+      AC_MSG_WARN([cannot determine non-blocking socket method.])
+    fi
+  fi
+  if test "$tst_method" = "unknown"; then
+    AC_DEFINE_UNQUOTED(USE_BLOCKING_SOCKETS, 1,
+      [Define to disable non-blocking sockets.])
+    AC_MSG_WARN([non-blocking sockets disabled.])
+  fi
+])
+
+
+dnl CARES_CONFIGURE_SYMBOL_HIDING
+dnl -------------------------------------------------
+dnl Depending on --enable-symbol-hiding or --disable-symbol-hiding
+dnl configure option, and compiler capability to actually honor such
+dnl option, this will modify compiler flags as appropriate and also
+dnl provide needed definitions for configuration and Makefile.am files.
+dnl This macro should not be used until all compilation tests have
+dnl been done to prevent interferences on other tests.
+
+AC_DEFUN([CARES_CONFIGURE_SYMBOL_HIDING], [
+  AC_MSG_CHECKING([whether hiding of library internal symbols will actually happen])
+  CFLAG_CARES_SYMBOL_HIDING=""
+  doing_symbol_hiding="no"
+  if test x"$ac_cv_native_windows" != "xyes" &&
+    test "$want_symbol_hiding" = "yes" &&
+    test "$supports_symbol_hiding" = "yes"; then
+    doing_symbol_hiding="yes"
+    CFLAG_CARES_SYMBOL_HIDING="$symbol_hiding_CFLAGS"
+    AC_DEFINE_UNQUOTED(CARES_SYMBOL_SCOPE_EXTERN, $symbol_hiding_EXTERN,
+      [Definition to make a library symbol externally visible.])
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+  fi
+  AM_CONDITIONAL(DOING_CARES_SYMBOL_HIDING, test x$doing_symbol_hiding = xyes)
+  AC_SUBST(CFLAG_CARES_SYMBOL_HIDING)
+  if test "$doing_symbol_hiding" = "yes"; then
+    AC_DEFINE_UNQUOTED(CARES_SYMBOL_HIDING, 1,
+      [Defined for build with symbol hiding.])
+  fi
+])
+
diff --git a/deps/cares/m4/cares-functions.m4 b/deps/cares/m4/cares-functions.m4
new file mode 100644
index 0000000000000000000000000000000000000000..0f3992c7f08054a3eb583c91f1ee9695d87d3c16
--- /dev/null
+++ b/deps/cares/m4/cares-functions.m4
@@ -0,0 +1,3755 @@
+#***************************************************************************
+#
+# Copyright (C) 2008 - 2012 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 46
+
+
+dnl CARES_INCLUDES_ARPA_INET
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when arpa/inet.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_ARPA_INET], [
+cares_includes_arpa_inet="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h sys/socket.h netinet/in.h arpa/inet.h,
+    [], [], [$cares_includes_arpa_inet])
+])
+
+
+dnl CARES_INCLUDES_FCNTL
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when fcntl.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_FCNTL], [
+cares_includes_fcntl="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#  include <fcntl.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h unistd.h fcntl.h,
+    [], [], [$cares_includes_fcntl])
+])
+
+
+dnl CARES_INCLUDES_NETDB
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when netdb.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_NETDB], [
+cares_includes_netdb="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h netdb.h,
+    [], [], [$cares_includes_netdb])
+])
+
+
+dnl CARES_INCLUDES_SOCKET
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when socket.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SOCKET], [
+cares_includes_socket="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SOCKET_H
+#  include <socket.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h socket.h,
+    [], [], [$cares_includes_socket])
+])
+
+
+dnl CARES_INCLUDES_STDLIB
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when stdlib.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_STDLIB], [
+cares_includes_stdlib="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h stdlib.h,
+    [], [], [$cares_includes_stdlib])
+])
+
+
+dnl CARES_INCLUDES_STRING
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when string(s).h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_STRING], [
+cares_includes_string="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_STRING_H
+#  include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h string.h strings.h,
+    [], [], [$cares_includes_string])
+])
+
+
+dnl CARES_INCLUDES_STROPTS
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when stropts.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_STROPTS], [
+cares_includes_stropts="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#  include <sys/ioctl.h>
+#endif
+#ifdef HAVE_STROPTS_H
+#  include <stropts.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h unistd.h sys/socket.h sys/ioctl.h stropts.h,
+    [], [], [$cares_includes_stropts])
+])
+
+
+dnl CARES_INCLUDES_SYS_SOCKET
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when sys/socket.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SYS_SOCKET], [
+cares_includes_sys_socket="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h sys/socket.h,
+    [], [], [$cares_includes_sys_socket])
+])
+
+
+dnl CARES_INCLUDES_SYS_TYPES
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when sys/types.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SYS_TYPES], [
+cares_includes_sys_types="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h,
+    [], [], [$cares_includes_sys_types])
+])
+
+
+dnl CARES_INCLUDES_SYS_UIO
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when sys/uio.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SYS_UIO], [
+cares_includes_sys_uio="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_UIO_H
+#  include <sys/uio.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h sys/uio.h,
+    [], [], [$cares_includes_sys_uio])
+])
+
+
+dnl CARES_INCLUDES_UNISTD
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when unistd.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_UNISTD], [
+cares_includes_unistd="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h unistd.h,
+    [], [], [$cares_includes_unistd])
+])
+
+
+dnl CARES_INCLUDES_WINSOCK2
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when winsock(2).h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_WINSOCK2], [
+cares_includes_winsock2="\
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#  else
+#    ifdef HAVE_WINSOCK_H
+#      include <winsock.h>
+#    endif
+#  endif
+#endif
+/* includes end */"
+  CURL_CHECK_HEADER_WINDOWS
+  CURL_CHECK_HEADER_WINSOCK
+  CURL_CHECK_HEADER_WINSOCK2
+])
+
+
+dnl CARES_INCLUDES_WS2TCPIP
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when ws2tcpip.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_WS2TCPIP], [
+cares_includes_ws2tcpip="\
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#    ifdef HAVE_WS2TCPIP_H
+#       include <ws2tcpip.h>
+#    endif
+#  endif
+#endif
+/* includes end */"
+  CURL_CHECK_HEADER_WINDOWS
+  CURL_CHECK_HEADER_WINSOCK2
+  CURL_CHECK_HEADER_WS2TCPIP
+])
+
+
+dnl CARES_PREPROCESS_CALLCONV
+dnl -------------------------------------------------
+dnl Set up variable with a preprocessor block which
+dnl defines function calling convention.
+
+AC_DEFUN([CARES_PREPROCESS_CALLCONV], [
+cares_preprocess_callconv="\
+/* preprocess start */
+#ifdef HAVE_WINDOWS_H
+#  define FUNCALLCONV __stdcall
+#else
+#  define FUNCALLCONV
+#endif
+/* preprocess end */"
+])
+
+
+dnl CARES_CHECK_FUNC_CLOSESOCKET
+dnl -------------------------------------------------
+dnl Verify if closesocket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_closesocket, then
+dnl HAVE_CLOSESOCKET will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_CLOSESOCKET], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_SOCKET])dnl
+  #
+  tst_links_closesocket="unknown"
+  tst_proto_closesocket="unknown"
+  tst_compi_closesocket="unknown"
+  tst_allow_closesocket="unknown"
+  #
+  AC_MSG_CHECKING([if closesocket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_socket
+    ]],[[
+      if(0 != closesocket(0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_closesocket="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_closesocket="no"
+  ])
+  #
+  if test "$tst_links_closesocket" = "yes"; then
+    AC_MSG_CHECKING([if closesocket is prototyped])
+    AC_EGREP_CPP([closesocket],[
+      $cares_includes_winsock2
+      $cares_includes_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_closesocket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_closesocket="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_closesocket" = "yes"; then
+    AC_MSG_CHECKING([if closesocket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_socket
+      ]],[[
+        if(0 != closesocket(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_closesocket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_closesocket="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_closesocket" = "yes"; then
+    AC_MSG_CHECKING([if closesocket usage allowed])
+    if test "x$cares_disallow_closesocket" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_closesocket="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_closesocket="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if closesocket might be used])
+  if test "$tst_links_closesocket" = "yes" &&
+     test "$tst_proto_closesocket" = "yes" &&
+     test "$tst_compi_closesocket" = "yes" &&
+     test "$tst_allow_closesocket" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET, 1,
+      [Define to 1 if you have the closesocket function.])
+    ac_cv_func_closesocket="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_closesocket="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_CLOSESOCKET_CAMEL
+dnl -------------------------------------------------
+dnl Verify if CloseSocket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_closesocket_camel,
+dnl then HAVE_CLOSESOCKET_CAMEL will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_CLOSESOCKET_CAMEL], [
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  #
+  tst_links_closesocket_camel="unknown"
+  tst_proto_closesocket_camel="unknown"
+  tst_compi_closesocket_camel="unknown"
+  tst_allow_closesocket_camel="unknown"
+  #
+  AC_MSG_CHECKING([if CloseSocket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_sys_socket
+    ]],[[
+      if(0 != CloseSocket(0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_closesocket_camel="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_closesocket_camel="no"
+  ])
+  #
+  if test "$tst_links_closesocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if CloseSocket is prototyped])
+    AC_EGREP_CPP([CloseSocket],[
+      $cares_includes_sys_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_closesocket_camel="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_closesocket_camel="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_closesocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if CloseSocket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_sys_socket
+      ]],[[
+        if(0 != CloseSocket(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_closesocket_camel="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_closesocket_camel="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_closesocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if CloseSocket usage allowed])
+    if test "x$cares_disallow_closesocket_camel" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_closesocket_camel="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_closesocket_camel="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if CloseSocket might be used])
+  if test "$tst_links_closesocket_camel" = "yes" &&
+     test "$tst_proto_closesocket_camel" = "yes" &&
+     test "$tst_compi_closesocket_camel" = "yes" &&
+     test "$tst_allow_closesocket_camel" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET_CAMEL, 1,
+      [Define to 1 if you have the CloseSocket camel case function.])
+    ac_cv_func_closesocket_camel="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_closesocket_camel="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_CONNECT
+dnl -------------------------------------------------
+dnl Verify if connect is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_connect, then
+dnl HAVE_CONNECT will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_CONNECT], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_INCLUDES_SOCKET])dnl
+  #
+  tst_links_connect="unknown"
+  tst_proto_connect="unknown"
+  tst_compi_connect="unknown"
+  tst_allow_connect="unknown"
+  #
+  AC_MSG_CHECKING([if connect can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+    ]],[[
+      if(0 != connect(0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_connect="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_connect="no"
+  ])
+  #
+  if test "$tst_links_connect" = "yes"; then
+    AC_MSG_CHECKING([if connect is prototyped])
+    AC_EGREP_CPP([connect],[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_connect="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_connect="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_connect" = "yes"; then
+    AC_MSG_CHECKING([if connect is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+        $cares_includes_socket
+      ]],[[
+        if(0 != connect(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_connect="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_connect="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_connect" = "yes"; then
+    AC_MSG_CHECKING([if connect usage allowed])
+    if test "x$cares_disallow_connect" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_connect="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_connect="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if connect might be used])
+  if test "$tst_links_connect" = "yes" &&
+     test "$tst_proto_connect" = "yes" &&
+     test "$tst_compi_connect" = "yes" &&
+     test "$tst_allow_connect" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_CONNECT, 1,
+      [Define to 1 if you have the connect function.])
+    ac_cv_func_connect="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_connect="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_FCNTL
+dnl -------------------------------------------------
+dnl Verify if fcntl is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_fcntl, then
+dnl HAVE_FCNTL will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_FCNTL], [
+  AC_REQUIRE([CARES_INCLUDES_FCNTL])dnl
+  #
+  tst_links_fcntl="unknown"
+  tst_proto_fcntl="unknown"
+  tst_compi_fcntl="unknown"
+  tst_allow_fcntl="unknown"
+  #
+  AC_MSG_CHECKING([if fcntl can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([fcntl])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_fcntl="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_fcntl="no"
+  ])
+  #
+  if test "$tst_links_fcntl" = "yes"; then
+    AC_MSG_CHECKING([if fcntl is prototyped])
+    AC_EGREP_CPP([fcntl],[
+      $cares_includes_fcntl
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_fcntl="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_fcntl="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_fcntl" = "yes"; then
+    AC_MSG_CHECKING([if fcntl is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_fcntl
+      ]],[[
+        if(0 != fcntl(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_fcntl="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_fcntl="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_fcntl" = "yes"; then
+    AC_MSG_CHECKING([if fcntl usage allowed])
+    if test "x$cares_disallow_fcntl" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_fcntl="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_fcntl="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if fcntl might be used])
+  if test "$tst_links_fcntl" = "yes" &&
+     test "$tst_proto_fcntl" = "yes" &&
+     test "$tst_compi_fcntl" = "yes" &&
+     test "$tst_allow_fcntl" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_FCNTL, 1,
+      [Define to 1 if you have the fcntl function.])
+    ac_cv_func_fcntl="yes"
+    CARES_CHECK_FUNC_FCNTL_O_NONBLOCK
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_fcntl="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_FCNTL_O_NONBLOCK
+dnl -------------------------------------------------
+dnl Verify if fcntl with status flag O_NONBLOCK is
+dnl available, can be compiled, and seems to work. If
+dnl all of these are true, then HAVE_FCNTL_O_NONBLOCK
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_FCNTL_O_NONBLOCK], [
+  #
+  tst_compi_fcntl_o_nonblock="unknown"
+  tst_allow_fcntl_o_nonblock="unknown"
+  #
+  case $host_os in
+    sunos4* | aix3* | beos*)
+      dnl O_NONBLOCK does not work on these platforms
+      cares_disallow_fcntl_o_nonblock="yes"
+      ;;
+  esac
+  #
+  if test "$ac_cv_func_fcntl" = "yes"; then
+    AC_MSG_CHECKING([if fcntl O_NONBLOCK is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_fcntl
+      ]],[[
+        int flags = 0;
+        if(0 != fcntl(0, F_SETFL, flags | O_NONBLOCK))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_fcntl_o_nonblock="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_fcntl_o_nonblock="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_fcntl_o_nonblock" = "yes"; then
+    AC_MSG_CHECKING([if fcntl O_NONBLOCK usage allowed])
+    if test "x$cares_disallow_fcntl_o_nonblock" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_fcntl_o_nonblock="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_fcntl_o_nonblock="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if fcntl O_NONBLOCK might be used])
+  if test "$tst_compi_fcntl_o_nonblock" = "yes" &&
+     test "$tst_allow_fcntl_o_nonblock" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_FCNTL_O_NONBLOCK, 1,
+      [Define to 1 if you have a working fcntl O_NONBLOCK function.])
+    ac_cv_func_fcntl_o_nonblock="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_fcntl_o_nonblock="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_FREEADDRINFO
+dnl -------------------------------------------------
+dnl Verify if freeaddrinfo is available, prototyped,
+dnl and can be compiled. If all of these are true,
+dnl and usage has not been previously disallowed with
+dnl shell variable cares_disallow_freeaddrinfo, then
+dnl HAVE_FREEADDRINFO will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_FREEADDRINFO], [
+  AC_REQUIRE([CARES_INCLUDES_WS2TCPIP])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_freeaddrinfo="unknown"
+  tst_proto_freeaddrinfo="unknown"
+  tst_compi_freeaddrinfo="unknown"
+  tst_allow_freeaddrinfo="unknown"
+  #
+  AC_MSG_CHECKING([if freeaddrinfo can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+    ]],[[
+      freeaddrinfo(0);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_freeaddrinfo="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_freeaddrinfo="no"
+  ])
+  #
+  if test "$tst_links_freeaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if freeaddrinfo is prototyped])
+    AC_EGREP_CPP([freeaddrinfo],[
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_freeaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_freeaddrinfo="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_freeaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if freeaddrinfo is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_ws2tcpip
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+      ]],[[
+        freeaddrinfo(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_freeaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_freeaddrinfo="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_freeaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if freeaddrinfo usage allowed])
+    if test "x$cares_disallow_freeaddrinfo" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_freeaddrinfo="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_freeaddrinfo="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if freeaddrinfo might be used])
+  if test "$tst_links_freeaddrinfo" = "yes" &&
+     test "$tst_proto_freeaddrinfo" = "yes" &&
+     test "$tst_compi_freeaddrinfo" = "yes" &&
+     test "$tst_allow_freeaddrinfo" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_FREEADDRINFO, 1,
+      [Define to 1 if you have the freeaddrinfo function.])
+    ac_cv_func_freeaddrinfo="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_freeaddrinfo="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETADDRINFO
+dnl -------------------------------------------------
+dnl Verify if getaddrinfo is available, prototyped, can
+dnl be compiled and seems to work. If all of these are
+dnl true, and usage has not been previously disallowed
+dnl with shell variable cares_disallow_getaddrinfo, then
+dnl HAVE_GETADDRINFO will be defined. Additionally when
+dnl HAVE_GETADDRINFO gets defined this will also attempt
+dnl to find out if getaddrinfo happens to be threadsafe,
+dnl defining HAVE_GETADDRINFO_THREADSAFE when true.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETADDRINFO], [
+  AC_REQUIRE([CARES_INCLUDES_WS2TCPIP])dnl
+  AC_REQUIRE([CARES_INCLUDES_STDLIB])dnl
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])dnl
+  #
+  tst_links_getaddrinfo="unknown"
+  tst_proto_getaddrinfo="unknown"
+  tst_compi_getaddrinfo="unknown"
+  tst_works_getaddrinfo="unknown"
+  tst_allow_getaddrinfo="unknown"
+  tst_tsafe_getaddrinfo="unknown"
+  #
+  AC_MSG_CHECKING([if getaddrinfo can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+    ]],[[
+      if(0 != getaddrinfo(0, 0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_getaddrinfo="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_getaddrinfo="no"
+  ])
+  #
+  if test "$tst_links_getaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if getaddrinfo is prototyped])
+    AC_EGREP_CPP([getaddrinfo],[
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_getaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_getaddrinfo="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_getaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if getaddrinfo is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_ws2tcpip
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+      ]],[[
+        if(0 != getaddrinfo(0, 0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_getaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_getaddrinfo="no"
+    ])
+  fi
+  #
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_getaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if getaddrinfo seems to work])
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_ws2tcpip
+        $cares_includes_stdlib
+        $cares_includes_string
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+      ]],[[
+        struct addrinfo hints;
+        struct addrinfo *ai = 0;
+        int error;
+
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_flags = AI_NUMERICHOST;
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        error = getaddrinfo("127.0.0.1", 0, &hints, &ai);
+        if(error || !ai)
+          exit(1); /* fail */
+        else
+          exit(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_works_getaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_works_getaddrinfo="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_getaddrinfo" = "yes" &&
+    test "$tst_works_getaddrinfo" != "no"; then
+    AC_MSG_CHECKING([if getaddrinfo usage allowed])
+    if test "x$cares_disallow_getaddrinfo" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_getaddrinfo="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_getaddrinfo="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if getaddrinfo might be used])
+  if test "$tst_links_getaddrinfo" = "yes" &&
+     test "$tst_proto_getaddrinfo" = "yes" &&
+     test "$tst_compi_getaddrinfo" = "yes" &&
+     test "$tst_allow_getaddrinfo" = "yes" &&
+     test "$tst_works_getaddrinfo" != "no"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO, 1,
+      [Define to 1 if you have a working getaddrinfo function.])
+    ac_cv_func_getaddrinfo="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_getaddrinfo="no"
+    ac_cv_func_getaddrinfo_threadsafe="no"
+  fi
+  #
+  if test "$ac_cv_func_getaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if getaddrinfo is threadsafe])
+    case $host_os in
+      aix[[1234]].* | aix5.[[01]].*)
+        dnl aix 5.1 and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      aix*)
+        dnl aix 5.2 and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      darwin[[12345]].*)
+        dnl darwin 5.0 and mac os x 10.1.X and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      darwin*)
+        dnl darwin 6.0 and mac os x 10.2.X and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      freebsd[[1234]].* | freebsd5.[[1234]]*)
+        dnl freebsd 5.4 and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      freebsd*)
+        dnl freebsd 5.5 and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      hpux[[123456789]].* | hpux10.* | hpux11.0* | hpux11.10*)
+        dnl hpux 11.10 and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      hpux*)
+        dnl hpux 11.11 and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      netbsd[[123]].*)
+        dnl netbsd 3.X and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      netbsd*)
+        dnl netbsd 4.X and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      *bsd*)
+        dnl All other bsd's
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      solaris2*)
+        dnl solaris which have it
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+    esac
+    if test "$tst_tsafe_getaddrinfo" = "unknown" &&
+       test "$ac_cv_native_windows" = "yes"; then
+      tst_tsafe_getaddrinfo="yes"
+    fi
+    if test "$tst_tsafe_getaddrinfo" = "unknown"; then
+      CURL_CHECK_DEF_CC([h_errno], [
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+        ], [silent])
+      if test "$curl_cv_have_def_h_errno" = "yes"; then
+        tst_h_errno_macro="yes"
+      else
+        tst_h_errno_macro="no"
+      fi
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_sys_socket
+          $cares_includes_netdb
+        ]],[[
+          h_errno = 2;
+          if(0 != h_errno)
+            return 1;
+        ]])
+      ],[
+        tst_h_errno_modifiable_lvalue="yes"
+      ],[
+        tst_h_errno_modifiable_lvalue="no"
+      ])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+        ]],[[
+#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L)
+          return 0;
+#elif defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 700)
+          return 0;
+#else
+          force compilation error
+#endif
+        ]])
+      ],[
+        tst_h_errno_sbs_issue_7="yes"
+      ],[
+        tst_h_errno_sbs_issue_7="no"
+      ])
+      if test "$tst_h_errno_macro" = "no" &&
+         test "$tst_h_errno_modifiable_lvalue" = "no" &&
+         test "$tst_h_errno_sbs_issue_7" = "no"; then
+        tst_tsafe_getaddrinfo="no"
+      else
+        tst_tsafe_getaddrinfo="yes"
+      fi
+    fi
+    AC_MSG_RESULT([$tst_tsafe_getaddrinfo])
+    if test "$tst_tsafe_getaddrinfo" = "yes"; then
+      AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO_THREADSAFE, 1,
+        [Define to 1 if the getaddrinfo function is threadsafe.])
+      ac_cv_func_getaddrinfo_threadsafe="yes"
+    else
+      ac_cv_func_getaddrinfo_threadsafe="no"
+    fi
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETENV
+dnl -------------------------------------------------
+dnl Verify if getenv is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_getenv, then
+dnl HAVE_GETENV will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETENV], [
+  AC_REQUIRE([CARES_INCLUDES_STDLIB])dnl
+  #
+  tst_links_getenv="unknown"
+  tst_proto_getenv="unknown"
+  tst_compi_getenv="unknown"
+  tst_allow_getenv="unknown"
+  #
+  AC_MSG_CHECKING([if getenv can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getenv])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_getenv="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_getenv="no"
+  ])
+  #
+  if test "$tst_links_getenv" = "yes"; then
+    AC_MSG_CHECKING([if getenv is prototyped])
+    AC_EGREP_CPP([getenv],[
+      $cares_includes_stdlib
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_getenv="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_getenv="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_getenv" = "yes"; then
+    AC_MSG_CHECKING([if getenv is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stdlib
+      ]],[[
+        if(0 != getenv(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_getenv="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_getenv="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_getenv" = "yes"; then
+    AC_MSG_CHECKING([if getenv usage allowed])
+    if test "x$cares_disallow_getenv" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_getenv="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_getenv="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if getenv might be used])
+  if test "$tst_links_getenv" = "yes" &&
+     test "$tst_proto_getenv" = "yes" &&
+     test "$tst_compi_getenv" = "yes" &&
+     test "$tst_allow_getenv" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETENV, 1,
+      [Define to 1 if you have the getenv function.])
+    ac_cv_func_getenv="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_getenv="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETHOSTBYADDR
+dnl -------------------------------------------------
+dnl Verify if gethostbyaddr is available, prototyped,
+dnl and can be compiled. If all of these are true,
+dnl and usage has not been previously disallowed with
+dnl shell variable cares_disallow_gethostbyaddr, then
+dnl HAVE_GETHOSTBYADDR will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETHOSTBYADDR], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_gethostbyaddr="unknown"
+  tst_proto_gethostbyaddr="unknown"
+  tst_compi_gethostbyaddr="unknown"
+  tst_allow_gethostbyaddr="unknown"
+  #
+  AC_MSG_CHECKING([if gethostbyaddr can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_netdb
+    ]],[[
+      if(0 != gethostbyaddr(0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_gethostbyaddr="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_gethostbyaddr="no"
+  ])
+  #
+  if test "$tst_links_gethostbyaddr" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyaddr is prototyped])
+    AC_EGREP_CPP([gethostbyaddr],[
+      $cares_includes_winsock2
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_gethostbyaddr="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_gethostbyaddr="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_gethostbyaddr" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyaddr is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_netdb
+      ]],[[
+        if(0 != gethostbyaddr(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_gethostbyaddr="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_gethostbyaddr="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_gethostbyaddr" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyaddr usage allowed])
+    if test "x$cares_disallow_gethostbyaddr" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_gethostbyaddr="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_gethostbyaddr="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if gethostbyaddr might be used])
+  if test "$tst_links_gethostbyaddr" = "yes" &&
+     test "$tst_proto_gethostbyaddr" = "yes" &&
+     test "$tst_compi_gethostbyaddr" = "yes" &&
+     test "$tst_allow_gethostbyaddr" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYADDR, 1,
+      [Define to 1 if you have the gethostbyaddr function.])
+    ac_cv_func_gethostbyaddr="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_gethostbyaddr="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETHOSTBYNAME
+dnl -------------------------------------------------
+dnl Verify if gethostbyname is available, prototyped,
+dnl and can be compiled. If all of these are true,
+dnl and usage has not been previously disallowed with
+dnl shell variable cares_disallow_gethostbyname, then
+dnl HAVE_GETHOSTBYNAME will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETHOSTBYNAME], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_gethostbyname="unknown"
+  tst_proto_gethostbyname="unknown"
+  tst_compi_gethostbyname="unknown"
+  tst_allow_gethostbyname="unknown"
+  #
+  AC_MSG_CHECKING([if gethostbyname can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_netdb
+    ]],[[
+      if(0 != gethostbyname(0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_gethostbyname="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_gethostbyname="no"
+  ])
+  #
+  if test "$tst_links_gethostbyname" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyname is prototyped])
+    AC_EGREP_CPP([gethostbyname],[
+      $cares_includes_winsock2
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_gethostbyname="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_gethostbyname="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_gethostbyname" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyname is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_netdb
+      ]],[[
+        if(0 != gethostbyname(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_gethostbyname="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_gethostbyname="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_gethostbyname" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyname usage allowed])
+    if test "x$cares_disallow_gethostbyname" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_gethostbyname="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_gethostbyname="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if gethostbyname might be used])
+  if test "$tst_links_gethostbyname" = "yes" &&
+     test "$tst_proto_gethostbyname" = "yes" &&
+     test "$tst_compi_gethostbyname" = "yes" &&
+     test "$tst_allow_gethostbyname" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME, 1,
+      [Define to 1 if you have the gethostbyname function.])
+    ac_cv_func_gethostbyname="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_gethostbyname="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETHOSTNAME
+dnl -------------------------------------------------
+dnl Verify if gethostname is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_gethostname, then
+dnl HAVE_GETHOSTNAME will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETHOSTNAME], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_UNISTD])dnl
+  AC_REQUIRE([CARES_PREPROCESS_CALLCONV])dnl
+  #
+  tst_links_gethostname="unknown"
+  tst_proto_gethostname="unknown"
+  tst_compi_gethostname="unknown"
+  tst_allow_gethostname="unknown"
+  #
+  AC_MSG_CHECKING([if gethostname can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_unistd
+    ]],[[
+      if(0 != gethostname(0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_gethostname="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_gethostname="no"
+  ])
+  #
+  if test "$tst_links_gethostname" = "yes"; then
+    AC_MSG_CHECKING([if gethostname is prototyped])
+    AC_EGREP_CPP([gethostname],[
+      $cares_includes_winsock2
+      $cares_includes_unistd
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_gethostname="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_gethostname="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_gethostname" = "yes"; then
+    AC_MSG_CHECKING([if gethostname is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_unistd
+      ]],[[
+        if(0 != gethostname(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_gethostname="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_gethostname="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_gethostname" = "yes"; then
+    AC_MSG_CHECKING([for gethostname arg 2 data type])
+    tst_gethostname_type_arg2="unknown"
+    for tst_arg1 in 'char *' 'unsigned char *' 'void *'; do
+      for tst_arg2 in 'int' 'unsigned int' 'size_t'; do
+        if test "$tst_gethostname_type_arg2" = "unknown"; then
+          AC_COMPILE_IFELSE([
+            AC_LANG_PROGRAM([[
+              $cares_includes_winsock2
+              $cares_includes_unistd
+              $cares_preprocess_callconv
+              extern int FUNCALLCONV gethostname($tst_arg1, $tst_arg2);
+            ]],[[
+              if(0 != gethostname(0, 0))
+                return 1;
+            ]])
+          ],[
+            tst_gethostname_type_arg2="$tst_arg2"
+          ])
+        fi
+      done
+    done
+    AC_MSG_RESULT([$tst_gethostname_type_arg2])
+    if test "$tst_gethostname_type_arg2" != "unknown"; then
+      AC_DEFINE_UNQUOTED(GETHOSTNAME_TYPE_ARG2, $tst_gethostname_type_arg2,
+        [Define to the type of arg 2 for gethostname.])
+    fi
+  fi
+  #
+  if test "$tst_compi_gethostname" = "yes"; then
+    AC_MSG_CHECKING([if gethostname usage allowed])
+    if test "x$cares_disallow_gethostname" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_gethostname="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_gethostname="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if gethostname might be used])
+  if test "$tst_links_gethostname" = "yes" &&
+     test "$tst_proto_gethostname" = "yes" &&
+     test "$tst_compi_gethostname" = "yes" &&
+     test "$tst_allow_gethostname" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETHOSTNAME, 1,
+      [Define to 1 if you have the gethostname function.])
+    ac_cv_func_gethostname="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_gethostname="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETSERVBYPORT_R
+dnl -------------------------------------------------
+dnl Verify if getservbyport_r is available, prototyped,
+dnl and can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_getservbyport_r, then
+dnl HAVE_GETSERVBYPORT_R will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETSERVBYPORT_R], [
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_getservbyport_r="unknown"
+  tst_proto_getservbyport_r="unknown"
+  tst_compi_getservbyport_r="unknown"
+  tst_allow_getservbyport_r="unknown"
+  tst_nargs_getservbyport_r="unknown"
+  #
+  AC_MSG_CHECKING([if getservbyport_r can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getservbyport_r])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_getservbyport_r="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_getservbyport_r="no"
+  ])
+  #
+  if test "$tst_links_getservbyport_r" = "yes"; then
+    AC_MSG_CHECKING([if getservbyport_r is prototyped])
+    AC_EGREP_CPP([getservbyport_r],[
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_getservbyport_r="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_getservbyport_r="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_getservbyport_r" = "yes"; then
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyport_r takes 4 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyport_r(0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="4"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyport_r="no"
+      ])
+    fi
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyport_r takes 5 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyport_r(0, 0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="5"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyport_r="no"
+      ])
+    fi
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyport_r takes 6 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyport_r(0, 0, 0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="6"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyport_r="no"
+      ])
+    fi
+    AC_MSG_CHECKING([if getservbyport_r is compilable])
+    if test "$tst_compi_getservbyport_r" = "yes"; then
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  #
+  if test "$tst_compi_getservbyport_r" = "yes"; then
+    AC_MSG_CHECKING([if getservbyport_r usage allowed])
+    if test "x$cares_disallow_getservbyport_r" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_getservbyport_r="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_getservbyport_r="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if getservbyport_r might be used])
+  if test "$tst_links_getservbyport_r" = "yes" &&
+     test "$tst_proto_getservbyport_r" = "yes" &&
+     test "$tst_compi_getservbyport_r" = "yes" &&
+     test "$tst_allow_getservbyport_r" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETSERVBYPORT_R, 1,
+      [Define to 1 if you have the getservbyport_r function.])
+    AC_DEFINE_UNQUOTED(GETSERVBYPORT_R_ARGS, $tst_nargs_getservbyport_r,
+      [Specifies the number of arguments to getservbyport_r])
+    if test "$tst_nargs_getservbyport_r" -eq "4"; then
+      AC_DEFINE(GETSERVBYPORT_R_BUFSIZE, sizeof(struct servent_data),
+        [Specifies the size of the buffer to pass to getservbyport_r])
+    else
+      AC_DEFINE(GETSERVBYPORT_R_BUFSIZE, 4096,
+        [Specifies the size of the buffer to pass to getservbyport_r])
+    fi
+    ac_cv_func_getservbyport_r="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_getservbyport_r="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETSERVBYNAME_R
+dnl -------------------------------------------------
+dnl Verify if getservbyname_r is available, prototyped,
+dnl and can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_getservbyname_r, then
+dnl HAVE_GETSERVBYNAME_R will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETSERVBYNAME_R], [
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_getservbyname_r="unknown"
+  tst_proto_getservbyname_r="unknown"
+  tst_compi_getservbyname_r="unknown"
+  tst_allow_getservbyname_r="unknown"
+  tst_nargs_getservbyname_r="unknown"
+  #
+  AC_MSG_CHECKING([if getservbyname_r can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getservbyname_r])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_getservbyname_r="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_getservbyname_r="no"
+  ])
+  #
+  if test "$tst_links_getservbyname_r" = "yes"; then
+    AC_MSG_CHECKING([if getservbyname_r is prototyped])
+    AC_EGREP_CPP([getservbyname_r],[
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_getservbyname_r="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_getservbyname_r="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_getservbyname_r" = "yes"; then
+    if test "$tst_nargs_getservbyname_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyname_r takes 4 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyname_r(0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyname_r="yes"
+        tst_nargs_getservbyname_r="4"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyname_r="no"
+      ])
+    fi
+    if test "$tst_nargs_getservbyname_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyname_r takes 5 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyname_r(0, 0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyname_r="yes"
+        tst_nargs_getservbyname_r="5"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyname_r="no"
+      ])
+    fi
+    if test "$tst_nargs_getservbyname_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyname_r takes 6 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyname_r(0, 0, 0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyname_r="yes"
+        tst_nargs_getservbyname_r="6"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyname_r="no"
+      ])
+    fi
+    AC_MSG_CHECKING([if getservbyname_r is compilable])
+    if test "$tst_compi_getservbyname_r" = "yes"; then
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  #
+  if test "$tst_compi_getservbyname_r" = "yes"; then
+    AC_MSG_CHECKING([if getservbyname_r usage allowed])
+    if test "x$cares_disallow_getservbyname_r" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_getservbyname_r="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_getservbyname_r="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if getservbyname_r might be used])
+  if test "$tst_links_getservbyname_r" = "yes" &&
+     test "$tst_proto_getservbyname_r" = "yes" &&
+     test "$tst_compi_getservbyname_r" = "yes" &&
+     test "$tst_allow_getservbyname_r" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETSERVBYNAME_R, 1,
+      [Define to 1 if you have the getservbyname_r function.])
+    AC_DEFINE_UNQUOTED(GETSERVBYNAME_R_ARGS, $tst_nargs_getservbyname_r,
+      [Specifies the number of arguments to getservbyname_r])
+    if test "$tst_nargs_getservbyname_r" -eq "4"; then
+      AC_DEFINE(GETSERVBYNAME_R_BUFSIZE, sizeof(struct servent_data),
+        [Specifies the size of the buffer to pass to getservbyname_r])
+    else
+      AC_DEFINE(GETSERVBYNAME_R_BUFSIZE, 4096,
+        [Specifies the size of the buffer to pass to getservbyname_r])
+    fi
+    ac_cv_func_getservbyname_r="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_getservbyname_r="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_INET_NET_PTON
+dnl -------------------------------------------------
+dnl Verify if inet_net_pton is available, prototyped, can
+dnl be compiled and seems to work. If all of these are
+dnl true, and usage has not been previously disallowed
+dnl with shell variable cares_disallow_inet_net_pton, then
+dnl HAVE_INET_NET_PTON will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_INET_NET_PTON], [
+  AC_REQUIRE([CARES_INCLUDES_STDLIB])dnl
+  AC_REQUIRE([CARES_INCLUDES_ARPA_INET])dnl
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_inet_net_pton="unknown"
+  tst_proto_inet_net_pton="unknown"
+  tst_compi_inet_net_pton="unknown"
+  tst_works_inet_net_pton="unknown"
+  tst_allow_inet_net_pton="unknown"
+  #
+  AC_MSG_CHECKING([if inet_net_pton can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([inet_net_pton])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_inet_net_pton="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_inet_net_pton="no"
+  ])
+  #
+  if test "$tst_links_inet_net_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_net_pton is prototyped])
+    AC_EGREP_CPP([inet_net_pton],[
+      $cares_includes_arpa_inet
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_inet_net_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_inet_net_pton="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_inet_net_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_net_pton is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_arpa_inet
+      ]],[[
+        if(0 != inet_net_pton(0, 0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_inet_net_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_inet_net_pton="no"
+    ])
+  fi
+  #
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_inet_net_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_net_pton seems to work])
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stdlib
+        $cares_includes_arpa_inet
+        $cares_includes_string
+      ]],[[
+        unsigned char ipv6a[16+1];
+        unsigned char ipv4a[4+1];
+        const char *ipv6net1 = "fe80::214:4fff:fe0b:76c8";
+        const char *ipv6net2 = "::fffe:7f00:1";
+        const char *ipv6net3 = "7f20:1::/64";
+        const char *ipv6net4 = "7f20:1::/2147483649";
+        const char *ipv4net1 = "192.168.100.1";
+        const char *ipv4net2 = "192.168.100/32";
+        const char *ipv4net3 = "192.168.100.1/2147483649";
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(32 != inet_net_pton(AF_INET, ipv4net1, ipv4a, 4))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv4a[0x00] != 0xc0) ||
+            (ipv4a[0x01] != 0xa8) ||
+            (ipv4a[0x02] != 0x64) ||
+            (ipv4a[0x03] != 0x01) ||
+            (ipv4a[0x04] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(32 != inet_net_pton(AF_INET, ipv4net2, ipv4a, 4))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv4a[0x00] != 0xc0) ||
+            (ipv4a[0x01] != 0xa8) ||
+            (ipv4a[0x02] != 0x64) ||
+            (ipv4a[0x03] != 0x00) ||
+            (ipv4a[0x04] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(-1 != inet_net_pton(AF_INET, ipv4net3, ipv4a, 4))
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(128 != inet_net_pton(AF_INET6, ipv6net1, ipv6a, 16))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0x00] != 0xfe) ||
+            (ipv6a[0x01] != 0x80) ||
+            (ipv6a[0x08] != 0x02) ||
+            (ipv6a[0x09] != 0x14) ||
+            (ipv6a[0x0a] != 0x4f) ||
+            (ipv6a[0x0b] != 0xff) ||
+            (ipv6a[0x0c] != 0xfe) ||
+            (ipv6a[0x0d] != 0x0b) ||
+            (ipv6a[0x0e] != 0x76) ||
+            (ipv6a[0x0f] != 0xc8) ||
+            (ipv6a[0x10] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0x02] != 0x0) ||
+            (ipv6a[0x03] != 0x0) ||
+            (ipv6a[0x04] != 0x0) ||
+            (ipv6a[0x05] != 0x0) ||
+            (ipv6a[0x06] != 0x0) ||
+            (ipv6a[0x07] != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 0, sizeof(ipv6a));
+        ipv6a[0x10] = 0x01;
+        if(128 != inet_net_pton(AF_INET6, ipv6net2, ipv6a, 16))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0x0a] != 0xff) ||
+            (ipv6a[0x0b] != 0xfe) ||
+            (ipv6a[0x0c] != 0x7f) ||
+            (ipv6a[0x0f] != 0x01) ||
+            (ipv6a[0x10] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0x00] != 0x0) ||
+            (ipv6a[0x01] != 0x0) ||
+            (ipv6a[0x02] != 0x0) ||
+            (ipv6a[0x03] != 0x0) ||
+            (ipv6a[0x04] != 0x0) ||
+            (ipv6a[0x05] != 0x0) ||
+            (ipv6a[0x06] != 0x0) ||
+            (ipv6a[0x07] != 0x0) ||
+            (ipv6a[0x08] != 0x0) ||
+            (ipv6a[0x09] != 0x0) ||
+            (ipv6a[0x0d] != 0x0) ||
+            (ipv6a[0x0e] != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(64 != inet_net_pton(AF_INET6, ipv6net3, ipv6a, 16))
+          exit(1); /* fail */
+        if( (ipv6a[0x00] != 0x7f) ||
+            (ipv6a[0x01] != 0x20) ||
+            (ipv6a[0x03] != 0x01) ||
+            (ipv6a[0x08] != 0x01) ||
+            (ipv6a[0x09] != 0x01) ||
+            (ipv6a[0x0a] != 0x01) ||
+            (ipv6a[0x0b] != 0x01) ||
+            (ipv6a[0x0c] != 0x01) ||
+            (ipv6a[0x0d] != 0x01) ||
+            (ipv6a[0x0e] != 0x01) ||
+            (ipv6a[0x0f] != 0x01) ||
+            (ipv6a[0x10] != 0x01) )
+          exit(1); /* fail */
+        if( (ipv6a[0x02] != 0x0) ||
+            (ipv6a[0x04] != 0x0) ||
+            (ipv6a[0x05] != 0x0) ||
+            (ipv6a[0x06] != 0x0) ||
+            (ipv6a[0x07] != 0x0) ||
+            (ipv6a[0x07] != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(-1 != inet_net_pton(AF_INET6, ipv6net4, ipv6a, 16))
+          exit(1); /* fail */
+        /* - */
+        exit(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_works_inet_net_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_works_inet_net_pton="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_inet_net_pton" = "yes" &&
+    test "$tst_works_inet_net_pton" != "no"; then
+    AC_MSG_CHECKING([if inet_net_pton usage allowed])
+    if test "x$cares_disallow_inet_net_pton" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_inet_net_pton="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_inet_net_pton="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if inet_net_pton might be used])
+  if test "$tst_links_inet_net_pton" = "yes" &&
+     test "$tst_proto_inet_net_pton" = "yes" &&
+     test "$tst_compi_inet_net_pton" = "yes" &&
+     test "$tst_allow_inet_net_pton" = "yes" &&
+     test "$tst_works_inet_net_pton" != "no"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_INET_NET_PTON, 1,
+      [Define to 1 if you have a IPv6 capable working inet_net_pton function.])
+    ac_cv_func_inet_net_pton="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_inet_net_pton="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_INET_NTOP
+dnl -------------------------------------------------
+dnl Verify if inet_ntop is available, prototyped, can
+dnl be compiled and seems to work. If all of these are
+dnl true, and usage has not been previously disallowed
+dnl with shell variable cares_disallow_inet_ntop, then
+dnl HAVE_INET_NTOP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_INET_NTOP], [
+  AC_REQUIRE([CARES_INCLUDES_STDLIB])dnl
+  AC_REQUIRE([CARES_INCLUDES_ARPA_INET])dnl
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_inet_ntop="unknown"
+  tst_proto_inet_ntop="unknown"
+  tst_compi_inet_ntop="unknown"
+  tst_works_inet_ntop="unknown"
+  tst_allow_inet_ntop="unknown"
+  #
+  AC_MSG_CHECKING([if inet_ntop can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([inet_ntop])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_inet_ntop="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_inet_ntop="no"
+  ])
+  #
+  if test "$tst_links_inet_ntop" = "yes"; then
+    AC_MSG_CHECKING([if inet_ntop is prototyped])
+    AC_EGREP_CPP([inet_ntop],[
+      $cares_includes_arpa_inet
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_inet_ntop="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_inet_ntop="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_inet_ntop" = "yes"; then
+    AC_MSG_CHECKING([if inet_ntop is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_arpa_inet
+      ]],[[
+        if(0 != inet_ntop(0, 0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_inet_ntop="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_inet_ntop="no"
+    ])
+  fi
+  #
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_inet_ntop" = "yes"; then
+    AC_MSG_CHECKING([if inet_ntop seems to work])
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stdlib
+        $cares_includes_arpa_inet
+        $cares_includes_string
+      ]],[[
+        char ipv6res[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
+        char ipv4res[sizeof "255.255.255.255"];
+        unsigned char ipv6a[26];
+        unsigned char ipv4a[5];
+        char *ipv6ptr = 0;
+        char *ipv4ptr = 0;
+        /* - */
+        ipv4res[0] = '\0';
+        ipv4a[0] = 0xc0;
+        ipv4a[1] = 0xa8;
+        ipv4a[2] = 0x64;
+        ipv4a[3] = 0x01;
+        ipv4a[4] = 0x01;
+        /* - */
+        ipv4ptr = inet_ntop(AF_INET, ipv4a, ipv4res, sizeof(ipv4res));
+        if(!ipv4ptr)
+          exit(1); /* fail */
+        if(ipv4ptr != ipv4res)
+          exit(1); /* fail */
+        if(!ipv4ptr[0])
+          exit(1); /* fail */
+        if(memcmp(ipv4res, "192.168.100.1", 13) != 0)
+          exit(1); /* fail */
+        /* - */
+        ipv6res[0] = '\0';
+        memset(ipv6a, 0, sizeof(ipv6a));
+        ipv6a[0] = 0xfe;
+        ipv6a[1] = 0x80;
+        ipv6a[8] = 0x02;
+        ipv6a[9] = 0x14;
+        ipv6a[10] = 0x4f;
+        ipv6a[11] = 0xff;
+        ipv6a[12] = 0xfe;
+        ipv6a[13] = 0x0b;
+        ipv6a[14] = 0x76;
+        ipv6a[15] = 0xc8;
+        ipv6a[25] = 0x01;
+        /* - */
+        ipv6ptr = inet_ntop(AF_INET6, ipv6a, ipv6res, sizeof(ipv6res));
+        if(!ipv6ptr)
+          exit(1); /* fail */
+        if(ipv6ptr != ipv6res)
+          exit(1); /* fail */
+        if(!ipv6ptr[0])
+          exit(1); /* fail */
+        if(memcmp(ipv6res, "fe80::214:4fff:fe0b:76c8", 24) != 0)
+          exit(1); /* fail */
+        /* - */
+        exit(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_works_inet_ntop="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_works_inet_ntop="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_inet_ntop" = "yes" &&
+    test "$tst_works_inet_ntop" != "no"; then
+    AC_MSG_CHECKING([if inet_ntop usage allowed])
+    if test "x$cares_disallow_inet_ntop" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_inet_ntop="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_inet_ntop="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if inet_ntop might be used])
+  if test "$tst_links_inet_ntop" = "yes" &&
+     test "$tst_proto_inet_ntop" = "yes" &&
+     test "$tst_compi_inet_ntop" = "yes" &&
+     test "$tst_allow_inet_ntop" = "yes" &&
+     test "$tst_works_inet_ntop" != "no"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_INET_NTOP, 1,
+      [Define to 1 if you have a IPv6 capable working inet_ntop function.])
+    ac_cv_func_inet_ntop="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_inet_ntop="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_INET_PTON
+dnl -------------------------------------------------
+dnl Verify if inet_pton is available, prototyped, can
+dnl be compiled and seems to work. If all of these are
+dnl true, and usage has not been previously disallowed
+dnl with shell variable cares_disallow_inet_pton, then
+dnl HAVE_INET_PTON will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_INET_PTON], [
+  AC_REQUIRE([CARES_INCLUDES_STDLIB])dnl
+  AC_REQUIRE([CARES_INCLUDES_ARPA_INET])dnl
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_inet_pton="unknown"
+  tst_proto_inet_pton="unknown"
+  tst_compi_inet_pton="unknown"
+  tst_works_inet_pton="unknown"
+  tst_allow_inet_pton="unknown"
+  #
+  AC_MSG_CHECKING([if inet_pton can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([inet_pton])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_inet_pton="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_inet_pton="no"
+  ])
+  #
+  if test "$tst_links_inet_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_pton is prototyped])
+    AC_EGREP_CPP([inet_pton],[
+      $cares_includes_arpa_inet
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_inet_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_inet_pton="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_inet_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_pton is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_arpa_inet
+      ]],[[
+        if(0 != inet_pton(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_inet_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_inet_pton="no"
+    ])
+  fi
+  #
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_inet_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_pton seems to work])
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stdlib
+        $cares_includes_arpa_inet
+        $cares_includes_string
+      ]],[[
+        unsigned char ipv6a[16+1];
+        unsigned char ipv4a[4+1];
+        const char *ipv6src = "fe80::214:4fff:fe0b:76c8";
+        const char *ipv4src = "192.168.100.1";
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(1 != inet_pton(AF_INET, ipv4src, ipv4a))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv4a[0] != 0xc0) ||
+            (ipv4a[1] != 0xa8) ||
+            (ipv4a[2] != 0x64) ||
+            (ipv4a[3] != 0x01) ||
+            (ipv4a[4] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(1 != inet_pton(AF_INET6, ipv6src, ipv6a))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0]  != 0xfe) ||
+            (ipv6a[1]  != 0x80) ||
+            (ipv6a[8]  != 0x02) ||
+            (ipv6a[9]  != 0x14) ||
+            (ipv6a[10] != 0x4f) ||
+            (ipv6a[11] != 0xff) ||
+            (ipv6a[12] != 0xfe) ||
+            (ipv6a[13] != 0x0b) ||
+            (ipv6a[14] != 0x76) ||
+            (ipv6a[15] != 0xc8) ||
+            (ipv6a[16] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[2]  != 0x0) ||
+            (ipv6a[3]  != 0x0) ||
+            (ipv6a[4]  != 0x0) ||
+            (ipv6a[5]  != 0x0) ||
+            (ipv6a[6]  != 0x0) ||
+            (ipv6a[7]  != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        exit(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_works_inet_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_works_inet_pton="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_inet_pton" = "yes" &&
+    test "$tst_works_inet_pton" != "no"; then
+    AC_MSG_CHECKING([if inet_pton usage allowed])
+    if test "x$cares_disallow_inet_pton" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_inet_pton="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_inet_pton="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if inet_pton might be used])
+  if test "$tst_links_inet_pton" = "yes" &&
+     test "$tst_proto_inet_pton" = "yes" &&
+     test "$tst_compi_inet_pton" = "yes" &&
+     test "$tst_allow_inet_pton" = "yes" &&
+     test "$tst_works_inet_pton" != "no"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_INET_PTON, 1,
+      [Define to 1 if you have a IPv6 capable working inet_pton function.])
+    ac_cv_func_inet_pton="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_inet_pton="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTL
+dnl -------------------------------------------------
+dnl Verify if ioctl is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_ioctl, then
+dnl HAVE_IOCTL will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTL], [
+  AC_REQUIRE([CARES_INCLUDES_STROPTS])dnl
+  #
+  tst_links_ioctl="unknown"
+  tst_proto_ioctl="unknown"
+  tst_compi_ioctl="unknown"
+  tst_allow_ioctl="unknown"
+  #
+  AC_MSG_CHECKING([if ioctl can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([ioctl])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_ioctl="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_ioctl="no"
+  ])
+  #
+  if test "$tst_links_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl is prototyped])
+    AC_EGREP_CPP([ioctl],[
+      $cares_includes_stropts
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_ioctl="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_ioctl="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+      ]],[[
+        if(0 != ioctl(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctl="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctl="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl usage allowed])
+    if test "x$cares_disallow_ioctl" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctl="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctl="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctl might be used])
+  if test "$tst_links_ioctl" = "yes" &&
+     test "$tst_proto_ioctl" = "yes" &&
+     test "$tst_compi_ioctl" = "yes" &&
+     test "$tst_allow_ioctl" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTL, 1,
+      [Define to 1 if you have the ioctl function.])
+    ac_cv_func_ioctl="yes"
+    CARES_CHECK_FUNC_IOCTL_FIONBIO
+    CARES_CHECK_FUNC_IOCTL_SIOCGIFADDR
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctl="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTL_FIONBIO
+dnl -------------------------------------------------
+dnl Verify if ioctl with the FIONBIO command is
+dnl available, can be compiled, and seems to work. If
+dnl all of these are true, then HAVE_IOCTL_FIONBIO
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTL_FIONBIO], [
+  #
+  tst_compi_ioctl_fionbio="unknown"
+  tst_allow_ioctl_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl FIONBIO is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+      ]],[[
+        int flags = 0;
+        if(0 != ioctl(0, FIONBIO, &flags))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctl_fionbio="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctl_fionbio="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctl_fionbio" = "yes"; then
+    AC_MSG_CHECKING([if ioctl FIONBIO usage allowed])
+    if test "x$cares_disallow_ioctl_fionbio" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctl_fionbio="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctl_fionbio="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctl FIONBIO might be used])
+  if test "$tst_compi_ioctl_fionbio" = "yes" &&
+     test "$tst_allow_ioctl_fionbio" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTL_FIONBIO, 1,
+      [Define to 1 if you have a working ioctl FIONBIO function.])
+    ac_cv_func_ioctl_fionbio="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctl_fionbio="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTL_SIOCGIFADDR
+dnl -------------------------------------------------
+dnl Verify if ioctl with the SIOCGIFADDR command is available,
+dnl struct ifreq is defined, they can be compiled, and seem to
+dnl work. If all of these are true, then HAVE_IOCTL_SIOCGIFADDR
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTL_SIOCGIFADDR], [
+  #
+  tst_compi_ioctl_siocgifaddr="unknown"
+  tst_allow_ioctl_siocgifaddr="unknown"
+  #
+  if test "$ac_cv_func_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl SIOCGIFADDR is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+        #include <net/if.h>
+      ]],[[
+        struct ifreq ifr;
+        if(0 != ioctl(0, SIOCGIFADDR, &ifr))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctl_siocgifaddr="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctl_siocgifaddr="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctl_siocgifaddr" = "yes"; then
+    AC_MSG_CHECKING([if ioctl SIOCGIFADDR usage allowed])
+    if test "x$cares_disallow_ioctl_siocgifaddr" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctl_siocgifaddr="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctl_siocgifaddr="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctl SIOCGIFADDR might be used])
+  if test "$tst_compi_ioctl_siocgifaddr" = "yes" &&
+     test "$tst_allow_ioctl_siocgifaddr" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTL_SIOCGIFADDR, 1,
+      [Define to 1 if you have a working ioctl SIOCGIFADDR function.])
+    ac_cv_func_ioctl_siocgifaddr="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctl_siocgifaddr="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTLSOCKET
+dnl -------------------------------------------------
+dnl Verify if ioctlsocket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_ioctlsocket, then
+dnl HAVE_IOCTLSOCKET will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTLSOCKET], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  #
+  tst_links_ioctlsocket="unknown"
+  tst_proto_ioctlsocket="unknown"
+  tst_compi_ioctlsocket="unknown"
+  tst_allow_ioctlsocket="unknown"
+  #
+  AC_MSG_CHECKING([if ioctlsocket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+    ]],[[
+      if(0 != ioctlsocket(0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_ioctlsocket="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_ioctlsocket="no"
+  ])
+  #
+  if test "$tst_links_ioctlsocket" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket is prototyped])
+    AC_EGREP_CPP([ioctlsocket],[
+      $cares_includes_winsock2
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_ioctlsocket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_ioctlsocket="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_ioctlsocket" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+      ]],[[
+        if(0 != ioctlsocket(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctlsocket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctlsocket="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctlsocket" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket usage allowed])
+    if test "x$cares_disallow_ioctlsocket" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctlsocket="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctlsocket="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctlsocket might be used])
+  if test "$tst_links_ioctlsocket" = "yes" &&
+     test "$tst_proto_ioctlsocket" = "yes" &&
+     test "$tst_compi_ioctlsocket" = "yes" &&
+     test "$tst_allow_ioctlsocket" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET, 1,
+      [Define to 1 if you have the ioctlsocket function.])
+    ac_cv_func_ioctlsocket="yes"
+    CARES_CHECK_FUNC_IOCTLSOCKET_FIONBIO
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctlsocket="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTLSOCKET_FIONBIO
+dnl -------------------------------------------------
+dnl Verify if ioctlsocket with the FIONBIO command is
+dnl available, can be compiled, and seems to work. If
+dnl all of these are true, then HAVE_IOCTLSOCKET_FIONBIO
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTLSOCKET_FIONBIO], [
+  #
+  tst_compi_ioctlsocket_fionbio="unknown"
+  tst_allow_ioctlsocket_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctlsocket" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket FIONBIO is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+      ]],[[
+        int flags = 0;
+        if(0 != ioctlsocket(0, FIONBIO, &flags))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctlsocket_fionbio="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctlsocket_fionbio="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_fionbio" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket FIONBIO usage allowed])
+    if test "x$cares_disallow_ioctlsocket_fionbio" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctlsocket_fionbio="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctlsocket_fionbio="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctlsocket FIONBIO might be used])
+  if test "$tst_compi_ioctlsocket_fionbio" = "yes" &&
+     test "$tst_allow_ioctlsocket_fionbio" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_FIONBIO, 1,
+      [Define to 1 if you have a working ioctlsocket FIONBIO function.])
+    ac_cv_func_ioctlsocket_fionbio="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctlsocket_fionbio="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL
+dnl -------------------------------------------------
+dnl Verify if IoctlSocket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_ioctlsocket_camel,
+dnl then HAVE_IOCTLSOCKET_CAMEL will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL], [
+  AC_REQUIRE([CARES_INCLUDES_STROPTS])dnl
+  #
+  tst_links_ioctlsocket_camel="unknown"
+  tst_proto_ioctlsocket_camel="unknown"
+  tst_compi_ioctlsocket_camel="unknown"
+  tst_allow_ioctlsocket_camel="unknown"
+  #
+  AC_MSG_CHECKING([if IoctlSocket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([IoctlSocket])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_ioctlsocket_camel="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_ioctlsocket_camel="no"
+  ])
+  #
+  if test "$tst_links_ioctlsocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket is prototyped])
+    AC_EGREP_CPP([IoctlSocket],[
+      $cares_includes_stropts
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_ioctlsocket_camel="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_ioctlsocket_camel="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_ioctlsocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+      ]],[[
+        if(0 != IoctlSocket(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctlsocket_camel="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctlsocket_camel="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket usage allowed])
+    if test "x$cares_disallow_ioctlsocket_camel" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctlsocket_camel="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctlsocket_camel="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if IoctlSocket might be used])
+  if test "$tst_links_ioctlsocket_camel" = "yes" &&
+     test "$tst_proto_ioctlsocket_camel" = "yes" &&
+     test "$tst_compi_ioctlsocket_camel" = "yes" &&
+     test "$tst_allow_ioctlsocket_camel" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL, 1,
+      [Define to 1 if you have the IoctlSocket camel case function.])
+    ac_cv_func_ioctlsocket_camel="yes"
+    CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctlsocket_camel="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
+dnl -------------------------------------------------
+dnl Verify if IoctlSocket with FIONBIO command is available,
+dnl can be compiled, and seems to work. If all of these are
+dnl true, then HAVE_IOCTLSOCKET_CAMEL_FIONBIO will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO], [
+  #
+  tst_compi_ioctlsocket_camel_fionbio="unknown"
+  tst_allow_ioctlsocket_camel_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctlsocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket FIONBIO is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+      ]],[[
+        long flags = 0;
+        if(0 != ioctlsocket(0, FIONBIO, &flags))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctlsocket_camel_fionbio="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctlsocket_camel_fionbio="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket FIONBIO usage allowed])
+    if test "x$cares_disallow_ioctlsocket_camel_fionbio" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctlsocket_camel_fionbio="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctlsocket_camel_fionbio="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if IoctlSocket FIONBIO might be used])
+  if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes" &&
+     test "$tst_allow_ioctlsocket_camel_fionbio" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL_FIONBIO, 1,
+      [Define to 1 if you have a working IoctlSocket camel case FIONBIO function.])
+    ac_cv_func_ioctlsocket_camel_fionbio="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctlsocket_camel_fionbio="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_SETSOCKOPT
+dnl -------------------------------------------------
+dnl Verify if setsockopt is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_setsockopt, then
+dnl HAVE_SETSOCKOPT will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_SETSOCKOPT], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  #
+  tst_links_setsockopt="unknown"
+  tst_proto_setsockopt="unknown"
+  tst_compi_setsockopt="unknown"
+  tst_allow_setsockopt="unknown"
+  #
+  AC_MSG_CHECKING([if setsockopt can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+    ]],[[
+      if(0 != setsockopt(0, 0, 0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_setsockopt="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_setsockopt="no"
+  ])
+  #
+  if test "$tst_links_setsockopt" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt is prototyped])
+    AC_EGREP_CPP([setsockopt],[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_setsockopt="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_setsockopt="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_setsockopt" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+      ]],[[
+        if(0 != setsockopt(0, 0, 0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_setsockopt="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_setsockopt="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_setsockopt" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt usage allowed])
+    if test "x$cares_disallow_setsockopt" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_setsockopt="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_setsockopt="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if setsockopt might be used])
+  if test "$tst_links_setsockopt" = "yes" &&
+     test "$tst_proto_setsockopt" = "yes" &&
+     test "$tst_compi_setsockopt" = "yes" &&
+     test "$tst_allow_setsockopt" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_SETSOCKOPT, 1,
+      [Define to 1 if you have the setsockopt function.])
+    ac_cv_func_setsockopt="yes"
+    CARES_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_setsockopt="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK
+dnl -------------------------------------------------
+dnl Verify if setsockopt with the SO_NONBLOCK command is
+dnl available, can be compiled, and seems to work. If
+dnl all of these are true, then HAVE_SETSOCKOPT_SO_NONBLOCK
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK], [
+  #
+  tst_compi_setsockopt_so_nonblock="unknown"
+  tst_allow_setsockopt_so_nonblock="unknown"
+  #
+  if test "$ac_cv_func_setsockopt" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt SO_NONBLOCK is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+      ]],[[
+        if(0 != setsockopt(0, SOL_SOCKET, SO_NONBLOCK, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_setsockopt_so_nonblock="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_setsockopt_so_nonblock="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_setsockopt_so_nonblock" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt SO_NONBLOCK usage allowed])
+    if test "x$cares_disallow_setsockopt_so_nonblock" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_setsockopt_so_nonblock="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_setsockopt_so_nonblock="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if setsockopt SO_NONBLOCK might be used])
+  if test "$tst_compi_setsockopt_so_nonblock" = "yes" &&
+     test "$tst_allow_setsockopt_so_nonblock" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_SETSOCKOPT_SO_NONBLOCK, 1,
+      [Define to 1 if you have a working setsockopt SO_NONBLOCK function.])
+    ac_cv_func_setsockopt_so_nonblock="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_setsockopt_so_nonblock="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_SOCKET
+dnl -------------------------------------------------
+dnl Verify if socket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_socket, then
+dnl HAVE_SOCKET will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_SOCKET], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_INCLUDES_SOCKET])dnl
+  #
+  tst_links_socket="unknown"
+  tst_proto_socket="unknown"
+  tst_compi_socket="unknown"
+  tst_allow_socket="unknown"
+  #
+  AC_MSG_CHECKING([if socket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+    ]],[[
+      if(0 != socket(0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_socket="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_socket="no"
+  ])
+  #
+  if test "$tst_links_socket" = "yes"; then
+    AC_MSG_CHECKING([if socket is prototyped])
+    AC_EGREP_CPP([socket],[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_socket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_socket="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_socket" = "yes"; then
+    AC_MSG_CHECKING([if socket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+        $cares_includes_socket
+      ]],[[
+        if(0 != socket(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_socket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_socket="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_socket" = "yes"; then
+    AC_MSG_CHECKING([if socket usage allowed])
+    if test "x$cares_disallow_socket" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_socket="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_socket="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if socket might be used])
+  if test "$tst_links_socket" = "yes" &&
+     test "$tst_proto_socket" = "yes" &&
+     test "$tst_compi_socket" = "yes" &&
+     test "$tst_allow_socket" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_SOCKET, 1,
+      [Define to 1 if you have the socket function.])
+    ac_cv_func_socket="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_socket="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRCASECMP
+dnl -------------------------------------------------
+dnl Verify if strcasecmp is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strcasecmp, then
+dnl HAVE_STRCASECMP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRCASECMP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strcasecmp="unknown"
+  tst_proto_strcasecmp="unknown"
+  tst_compi_strcasecmp="unknown"
+  tst_allow_strcasecmp="unknown"
+  #
+  AC_MSG_CHECKING([if strcasecmp can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strcasecmp])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strcasecmp="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strcasecmp="no"
+  ])
+  #
+  if test "$tst_links_strcasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strcasecmp is prototyped])
+    AC_EGREP_CPP([strcasecmp],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strcasecmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strcasecmp="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strcasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strcasecmp is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strcasecmp(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strcasecmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strcasecmp="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strcasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strcasecmp usage allowed])
+    if test "x$cares_disallow_strcasecmp" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strcasecmp="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strcasecmp="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strcasecmp might be used])
+  if test "$tst_links_strcasecmp" = "yes" &&
+     test "$tst_proto_strcasecmp" = "yes" &&
+     test "$tst_compi_strcasecmp" = "yes" &&
+     test "$tst_allow_strcasecmp" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRCASECMP, 1,
+      [Define to 1 if you have the strcasecmp function.])
+    ac_cv_func_strcasecmp="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strcasecmp="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRCMPI
+dnl -------------------------------------------------
+dnl Verify if strcmpi is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strcmpi, then
+dnl HAVE_STRCMPI will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRCMPI], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strcmpi="unknown"
+  tst_proto_strcmpi="unknown"
+  tst_compi_strcmpi="unknown"
+  tst_allow_strcmpi="unknown"
+  #
+  AC_MSG_CHECKING([if strcmpi can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strcmpi])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strcmpi="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strcmpi="no"
+  ])
+  #
+  if test "$tst_links_strcmpi" = "yes"; then
+    AC_MSG_CHECKING([if strcmpi is prototyped])
+    AC_EGREP_CPP([strcmpi],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strcmpi="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strcmpi="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strcmpi" = "yes"; then
+    AC_MSG_CHECKING([if strcmpi is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strcmpi(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strcmpi="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strcmpi="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strcmpi" = "yes"; then
+    AC_MSG_CHECKING([if strcmpi usage allowed])
+    if test "x$cares_disallow_strcmpi" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strcmpi="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strcmpi="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strcmpi might be used])
+  if test "$tst_links_strcmpi" = "yes" &&
+     test "$tst_proto_strcmpi" = "yes" &&
+     test "$tst_compi_strcmpi" = "yes" &&
+     test "$tst_allow_strcmpi" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRCMPI, 1,
+      [Define to 1 if you have the strcmpi function.])
+    ac_cv_func_strcmpi="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strcmpi="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRDUP
+dnl -------------------------------------------------
+dnl Verify if strdup is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strdup, then
+dnl HAVE_STRDUP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRDUP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strdup="unknown"
+  tst_proto_strdup="unknown"
+  tst_compi_strdup="unknown"
+  tst_allow_strdup="unknown"
+  #
+  AC_MSG_CHECKING([if strdup can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strdup])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strdup="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strdup="no"
+  ])
+  #
+  if test "$tst_links_strdup" = "yes"; then
+    AC_MSG_CHECKING([if strdup is prototyped])
+    AC_EGREP_CPP([strdup],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strdup="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strdup="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strdup" = "yes"; then
+    AC_MSG_CHECKING([if strdup is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strdup(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strdup="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strdup="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strdup" = "yes"; then
+    AC_MSG_CHECKING([if strdup usage allowed])
+    if test "x$cares_disallow_strdup" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strdup="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strdup="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strdup might be used])
+  if test "$tst_links_strdup" = "yes" &&
+     test "$tst_proto_strdup" = "yes" &&
+     test "$tst_compi_strdup" = "yes" &&
+     test "$tst_allow_strdup" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRDUP, 1,
+      [Define to 1 if you have the strdup function.])
+    ac_cv_func_strdup="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strdup="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRICMP
+dnl -------------------------------------------------
+dnl Verify if stricmp is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_stricmp, then
+dnl HAVE_STRICMP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRICMP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_stricmp="unknown"
+  tst_proto_stricmp="unknown"
+  tst_compi_stricmp="unknown"
+  tst_allow_stricmp="unknown"
+  #
+  AC_MSG_CHECKING([if stricmp can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([stricmp])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_stricmp="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_stricmp="no"
+  ])
+  #
+  if test "$tst_links_stricmp" = "yes"; then
+    AC_MSG_CHECKING([if stricmp is prototyped])
+    AC_EGREP_CPP([stricmp],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_stricmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_stricmp="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_stricmp" = "yes"; then
+    AC_MSG_CHECKING([if stricmp is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != stricmp(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_stricmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_stricmp="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_stricmp" = "yes"; then
+    AC_MSG_CHECKING([if stricmp usage allowed])
+    if test "x$cares_disallow_stricmp" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_stricmp="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_stricmp="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if stricmp might be used])
+  if test "$tst_links_stricmp" = "yes" &&
+     test "$tst_proto_stricmp" = "yes" &&
+     test "$tst_compi_stricmp" = "yes" &&
+     test "$tst_allow_stricmp" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRICMP, 1,
+      [Define to 1 if you have the stricmp function.])
+    ac_cv_func_stricmp="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_stricmp="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRNCASECMP
+dnl -------------------------------------------------
+dnl Verify if strncasecmp is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strncasecmp, then
+dnl HAVE_STRNCASECMP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRNCASECMP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strncasecmp="unknown"
+  tst_proto_strncasecmp="unknown"
+  tst_compi_strncasecmp="unknown"
+  tst_allow_strncasecmp="unknown"
+  #
+  AC_MSG_CHECKING([if strncasecmp can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strncasecmp])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strncasecmp="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strncasecmp="no"
+  ])
+  #
+  if test "$tst_links_strncasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strncasecmp is prototyped])
+    AC_EGREP_CPP([strncasecmp],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strncasecmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strncasecmp="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strncasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strncasecmp is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strncasecmp(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strncasecmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strncasecmp="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strncasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strncasecmp usage allowed])
+    if test "x$cares_disallow_strncasecmp" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strncasecmp="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strncasecmp="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strncasecmp might be used])
+  if test "$tst_links_strncasecmp" = "yes" &&
+     test "$tst_proto_strncasecmp" = "yes" &&
+     test "$tst_compi_strncasecmp" = "yes" &&
+     test "$tst_allow_strncasecmp" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRNCASECMP, 1,
+      [Define to 1 if you have the strncasecmp function.])
+    ac_cv_func_strncasecmp="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strncasecmp="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRNCMPI
+dnl -------------------------------------------------
+dnl Verify if strncmpi is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strncmpi, then
+dnl HAVE_STRNCMPI will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRNCMPI], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strncmpi="unknown"
+  tst_proto_strncmpi="unknown"
+  tst_compi_strncmpi="unknown"
+  tst_allow_strncmpi="unknown"
+  #
+  AC_MSG_CHECKING([if strncmpi can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strncmpi])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strncmpi="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strncmpi="no"
+  ])
+  #
+  if test "$tst_links_strncmpi" = "yes"; then
+    AC_MSG_CHECKING([if strncmpi is prototyped])
+    AC_EGREP_CPP([strncmpi],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strncmpi="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strncmpi="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strncmpi" = "yes"; then
+    AC_MSG_CHECKING([if strncmpi is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strncmpi(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strncmpi="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strncmpi="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strncmpi" = "yes"; then
+    AC_MSG_CHECKING([if strncmpi usage allowed])
+    if test "x$cares_disallow_strncmpi" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strncmpi="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strncmpi="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strncmpi might be used])
+  if test "$tst_links_strncmpi" = "yes" &&
+     test "$tst_proto_strncmpi" = "yes" &&
+     test "$tst_compi_strncmpi" = "yes" &&
+     test "$tst_allow_strncmpi" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRNCMPI, 1,
+      [Define to 1 if you have the strncmpi function.])
+    ac_cv_func_strncmpi="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strncmpi="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRNICMP
+dnl -------------------------------------------------
+dnl Verify if strnicmp is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strnicmp, then
+dnl HAVE_STRNICMP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRNICMP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strnicmp="unknown"
+  tst_proto_strnicmp="unknown"
+  tst_compi_strnicmp="unknown"
+  tst_allow_strnicmp="unknown"
+  #
+  AC_MSG_CHECKING([if strnicmp can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strnicmp])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strnicmp="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strnicmp="no"
+  ])
+  #
+  if test "$tst_links_strnicmp" = "yes"; then
+    AC_MSG_CHECKING([if strnicmp is prototyped])
+    AC_EGREP_CPP([strnicmp],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strnicmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strnicmp="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strnicmp" = "yes"; then
+    AC_MSG_CHECKING([if strnicmp is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strnicmp(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strnicmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strnicmp="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strnicmp" = "yes"; then
+    AC_MSG_CHECKING([if strnicmp usage allowed])
+    if test "x$cares_disallow_strnicmp" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strnicmp="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strnicmp="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strnicmp might be used])
+  if test "$tst_links_strnicmp" = "yes" &&
+     test "$tst_proto_strnicmp" = "yes" &&
+     test "$tst_compi_strnicmp" = "yes" &&
+     test "$tst_allow_strnicmp" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRNICMP, 1,
+      [Define to 1 if you have the strnicmp function.])
+    ac_cv_func_strnicmp="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strnicmp="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_WRITEV
+dnl -------------------------------------------------
+dnl Verify if writev is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_writev, then
+dnl HAVE_WRITEV will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_WRITEV], [
+  AC_REQUIRE([CARES_INCLUDES_SYS_UIO])dnl
+  #
+  tst_links_writev="unknown"
+  tst_proto_writev="unknown"
+  tst_compi_writev="unknown"
+  tst_allow_writev="unknown"
+  #
+  AC_MSG_CHECKING([if writev can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([writev])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_writev="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_writev="no"
+  ])
+  #
+  if test "$tst_links_writev" = "yes"; then
+    AC_MSG_CHECKING([if writev is prototyped])
+    AC_EGREP_CPP([writev],[
+      $cares_includes_sys_uio
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_writev="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_writev="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_writev" = "yes"; then
+    AC_MSG_CHECKING([if writev is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_sys_uio
+      ]],[[
+        if(0 != writev(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_writev="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_writev="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_writev" = "yes"; then
+    AC_MSG_CHECKING([if writev usage allowed])
+    if test "x$cares_disallow_writev" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_writev="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_writev="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if writev might be used])
+  if test "$tst_links_writev" = "yes" &&
+     test "$tst_proto_writev" = "yes" &&
+     test "$tst_compi_writev" = "yes" &&
+     test "$tst_allow_writev" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_WRITEV, 1,
+      [Define to 1 if you have the writev function.])
+    ac_cv_func_writev="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_writev="no"
+  fi
+])
diff --git a/deps/cares/m4/cares-reentrant.m4 b/deps/cares/m4/cares-reentrant.m4
new file mode 100644
index 0000000000000000000000000000000000000000..052326b3c0e425af1a266f70279dcbaafa8fa28f
--- /dev/null
+++ b/deps/cares/m4/cares-reentrant.m4
@@ -0,0 +1,611 @@
+#***************************************************************************
+# $Id$
+#
+# Copyright (C) 2008 - 2009 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 6
+
+dnl Note 1
+dnl ------
+dnl None of the CARES_CHECK_NEED_REENTRANT_* macros shall use HAVE_FOO_H to
+dnl conditionally include header files. These macros are used early in the
+dnl configure process much before header file availability is known.
+
+
+dnl CARES_CHECK_NEED_REENTRANT_ERRNO
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes errno available as a preprocessor macro.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_ERRNO], [
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+#include <errno.h>
+    ]],[[
+      if(0 != errno)
+        return 1;
+    ]])
+  ],[
+    tmp_errno="yes"
+  ],[
+    tmp_errno="no"
+  ])
+  if test "$tmp_errno" = "yes"; then
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <errno.h>
+      ]],[[
+#ifdef errno
+        int dummy=1;
+#else
+        force compilation error
+#endif
+      ]])
+    ],[
+      tmp_errno="errno_macro_defined"
+    ],[
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+#define _REENTRANT
+#include <errno.h>
+        ]],[[
+#ifdef errno
+          int dummy=1;
+#else
+          force compilation error
+#endif
+        ]])
+      ],[
+        tmp_errno="errno_macro_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GMTIME_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function gmtime_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GMTIME_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([gmtime_r])
+  ],[
+    tmp_gmtime_r="yes"
+  ],[
+    tmp_gmtime_r="no"
+  ])
+  if test "$tmp_gmtime_r" = "yes"; then
+    AC_EGREP_CPP([gmtime_r],[
+#include <sys/types.h>
+#include <time.h>
+    ],[
+      tmp_gmtime_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([gmtime_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <time.h>
+      ],[
+        tmp_gmtime_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_LOCALTIME_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function localtime_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_LOCALTIME_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([localtime_r])
+  ],[
+    tmp_localtime_r="yes"
+  ],[
+    tmp_localtime_r="no"
+  ])
+  if test "$tmp_localtime_r" = "yes"; then
+    AC_EGREP_CPP([localtime_r],[
+#include <sys/types.h>
+#include <time.h>
+    ],[
+      tmp_localtime_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([localtime_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <time.h>
+      ],[
+        tmp_localtime_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_STRERROR_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function strerror_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_STRERROR_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strerror_r])
+  ],[
+    tmp_strerror_r="yes"
+  ],[
+    tmp_strerror_r="no"
+  ])
+  if test "$tmp_strerror_r" = "yes"; then
+    AC_EGREP_CPP([strerror_r],[
+#include <sys/types.h>
+#include <string.h>
+    ],[
+      tmp_strerror_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([strerror_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <string.h>
+      ],[
+        tmp_strerror_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_STRTOK_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function strtok_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_STRTOK_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strtok_r])
+  ],[
+    tmp_strtok_r="yes"
+  ],[
+    tmp_strtok_r="no"
+  ])
+  if test "$tmp_strtok_r" = "yes"; then
+    AC_EGREP_CPP([strtok_r],[
+#include <sys/types.h>
+#include <string.h>
+    ],[
+      tmp_strtok_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([strtok_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <string.h>
+      ],[
+        tmp_strtok_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_INET_NTOA_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function inet_ntoa_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_INET_NTOA_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([inet_ntoa_r])
+  ],[
+    tmp_inet_ntoa_r="yes"
+  ],[
+    tmp_inet_ntoa_r="no"
+  ])
+  if test "$tmp_inet_ntoa_r" = "yes"; then
+    AC_EGREP_CPP([inet_ntoa_r],[
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+    ],[
+      tmp_inet_ntoa_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([inet_ntoa_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+      ],[
+        tmp_inet_ntoa_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function gethostbyaddr_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([gethostbyaddr_r])
+  ],[
+    tmp_gethostbyaddr_r="yes"
+  ],[
+    tmp_gethostbyaddr_r="no"
+  ])
+  if test "$tmp_gethostbyaddr_r" = "yes"; then
+    AC_EGREP_CPP([gethostbyaddr_r],[
+#include <sys/types.h>
+#include <netdb.h>
+    ],[
+      tmp_gethostbyaddr_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([gethostbyaddr_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+      ],[
+        tmp_gethostbyaddr_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function gethostbyname_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([gethostbyname_r])
+  ],[
+    tmp_gethostbyname_r="yes"
+  ],[
+    tmp_gethostbyname_r="no"
+  ])
+  if test "$tmp_gethostbyname_r" = "yes"; then
+    AC_EGREP_CPP([gethostbyname_r],[
+#include <sys/types.h>
+#include <netdb.h>
+    ],[
+      tmp_gethostbyname_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([gethostbyname_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+      ],[
+        tmp_gethostbyname_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function getprotobyname_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getprotobyname_r])
+  ],[
+    tmp_getprotobyname_r="yes"
+  ],[
+    tmp_getprotobyname_r="no"
+  ])
+  if test "$tmp_getprotobyname_r" = "yes"; then
+    AC_EGREP_CPP([getprotobyname_r],[
+#include <sys/types.h>
+#include <netdb.h>
+    ],[
+      tmp_getprotobyname_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([getprotobyname_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+      ],[
+        tmp_getprotobyname_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GETSERVBYPORT_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function getservbyport_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GETSERVBYPORT_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getservbyport_r])
+  ],[
+    tmp_getservbyport_r="yes"
+  ],[
+    tmp_getservbyport_r="no"
+  ])
+  if test "$tmp_getservbyport_r" = "yes"; then
+    AC_EGREP_CPP([getservbyport_r],[
+#include <sys/types.h>
+#include <netdb.h>
+    ],[
+      tmp_getservbyport_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([getservbyport_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+      ],[
+        tmp_getservbyport_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_FUNCTIONS_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes several _r functions compiler visible.
+dnl Internal macro for CARES_CONFIGURE_REENTRANT.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_FUNCTIONS_R], [
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GMTIME_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_LOCALTIME_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_STRERROR_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_STRTOK_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_INET_NTOA_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GETSERVBYPORT_R
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_SYSTEM
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl must be unconditionally done for this platform.
+dnl Internal macro for CARES_CONFIGURE_REENTRANT.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_SYSTEM], [
+  case $host_os in
+    solaris*)
+      tmp_need_reentrant="yes"
+      ;;
+    *)
+      tmp_need_reentrant="no"
+      ;;
+  esac
+])
+
+
+dnl CARES_CHECK_NEED_THREAD_SAFE_SYSTEM
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _THREAD_SAFE definition
+dnl must be unconditionally done for this platform.
+dnl Internal macro for CARES_CONFIGURE_THREAD_SAFE.
+
+AC_DEFUN([CARES_CHECK_NEED_THREAD_SAFE_SYSTEM], [
+  case $host_os in
+    aix[[123]].* | aix4.[[012]].*)
+      dnl aix 4.2 and older
+      tmp_need_thread_safe="no"
+      ;;
+    aix*)
+      dnl AIX 4.3 and newer
+      tmp_need_thread_safe="yes"
+      ;;
+    *)
+      tmp_need_thread_safe="no"
+      ;;
+  esac
+])
+
+
+dnl CARES_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT
+dnl -------------------------------------------------
+dnl This macro ensures that configuration tests done
+dnl after this will execute with preprocessor symbol
+dnl _REENTRANT defined. This macro also ensures that
+dnl the generated config file defines NEED_REENTRANT
+dnl and that in turn setup.h will define _REENTRANT.
+dnl Internal macro for CARES_CONFIGURE_REENTRANT.
+
+AC_DEFUN([CARES_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT], [
+AC_DEFINE(NEED_REENTRANT, 1,
+  [Define to 1 if _REENTRANT preprocessor symbol must be defined.])
+cat >>confdefs.h <<_EOF
+#ifndef _REENTRANT
+#  define _REENTRANT
+#endif
+_EOF
+])
+
+
+dnl CARES_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE
+dnl -------------------------------------------------
+dnl This macro ensures that configuration tests done
+dnl after this will execute with preprocessor symbol
+dnl _THREAD_SAFE defined. This macro also ensures that
+dnl the generated config file defines NEED_THREAD_SAFE
+dnl and that in turn setup.h will define _THREAD_SAFE.
+dnl Internal macro for CARES_CONFIGURE_THREAD_SAFE.
+
+AC_DEFUN([CARES_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE], [
+AC_DEFINE(NEED_THREAD_SAFE, 1,
+  [Define to 1 if _THREAD_SAFE preprocessor symbol must be defined.])
+cat >>confdefs.h <<_EOF
+#ifndef _THREAD_SAFE
+#  define _THREAD_SAFE
+#endif
+_EOF
+])
+
+
+dnl CARES_CONFIGURE_REENTRANT
+dnl -------------------------------------------------
+dnl This first checks if the preprocessor _REENTRANT
+dnl symbol is already defined. If it isn't currently
+dnl defined a set of checks are performed to verify
+dnl if its definition is required to make visible to
+dnl the compiler a set of *_r functions. Finally, if
+dnl _REENTRANT is already defined or needed it takes
+dnl care of making adjustments necessary to ensure
+dnl that it is defined equally for further configure
+dnl tests and generated config file.
+
+AC_DEFUN([CARES_CONFIGURE_REENTRANT], [
+  AC_PREREQ([2.50])dnl
+  #
+  AC_MSG_CHECKING([if _REENTRANT is already defined])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+#ifdef _REENTRANT
+      int dummy=1;
+#else
+      force compilation error
+#endif
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tmp_reentrant_initially_defined="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tmp_reentrant_initially_defined="no"
+  ])
+  #
+  if test "$tmp_reentrant_initially_defined" = "no"; then
+    AC_MSG_CHECKING([if _REENTRANT is actually needed])
+    CARES_CHECK_NEED_REENTRANT_SYSTEM
+    if test "$tmp_need_reentrant" = "no"; then
+      CARES_CHECK_NEED_REENTRANT_ERRNO
+    fi
+    if test "$tmp_need_reentrant" = "no"; then
+      CARES_CHECK_NEED_REENTRANT_FUNCTIONS_R
+    fi
+    if test "$tmp_need_reentrant" = "yes"; then
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if _REENTRANT is onwards defined])
+  if test "$tmp_reentrant_initially_defined" = "yes" ||
+    test "$tmp_need_reentrant" = "yes"; then
+    CARES_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+  fi
+  #
+])
+
+
+dnl CARES_CONFIGURE_THREAD_SAFE
+dnl -------------------------------------------------
+dnl This first checks if the preprocessor _THREAD_SAFE
+dnl symbol is already defined. If it isn't currently
+dnl defined a set of checks are performed to verify
+dnl if its definition is required. Finally, if
+dnl _THREAD_SAFE is already defined or needed it takes
+dnl care of making adjustments necessary to ensure
+dnl that it is defined equally for further configure
+dnl tests and generated config file.
+
+AC_DEFUN([CARES_CONFIGURE_THREAD_SAFE], [
+  AC_PREREQ([2.50])dnl
+  #
+  AC_MSG_CHECKING([if _THREAD_SAFE is already defined])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+#ifdef _THREAD_SAFE
+      int dummy=1;
+#else
+      force compilation error
+#endif
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tmp_thread_safe_initially_defined="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tmp_thread_safe_initially_defined="no"
+  ])
+  #
+  if test "$tmp_thread_safe_initially_defined" = "no"; then
+    AC_MSG_CHECKING([if _THREAD_SAFE is actually needed])
+    CARES_CHECK_NEED_THREAD_SAFE_SYSTEM
+    if test "$tmp_need_thread_safe" = "yes"; then
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if _THREAD_SAFE is onwards defined])
+  if test "$tmp_thread_safe_initially_defined" = "yes" ||
+    test "$tmp_need_thread_safe" = "yes"; then
+    CARES_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+  fi
+  #
+])
diff --git a/deps/cares/m4/ltoptions.m4 b/deps/cares/m4/ltoptions.m4
new file mode 100644
index 0000000000000000000000000000000000000000..94b082976667c0c9edf2e9ff7a668c1fd7d997bf
--- /dev/null
+++ b/deps/cares/m4/ltoptions.m4
@@ -0,0 +1,437 @@
+# Helper functions for option handling.                    -*- Autoconf -*-
+#
+#   Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software
+#   Foundation, Inc.
+#   Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 8 ltoptions.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
+
+
+# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
+# ------------------------------------------
+m4_define([_LT_MANGLE_OPTION],
+[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
+
+
+# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
+# ---------------------------------------
+# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
+# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
+# saved as a flag.
+m4_define([_LT_SET_OPTION],
+[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
+m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
+        _LT_MANGLE_DEFUN([$1], [$2]),
+    [m4_warning([Unknown $1 option '$2'])])[]dnl
+])
+
+
+# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
+# ------------------------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+m4_define([_LT_IF_OPTION],
+[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
+
+
+# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
+# -------------------------------------------------------
+# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
+# are set.
+m4_define([_LT_UNLESS_OPTIONS],
+[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+	    [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
+		      [m4_define([$0_found])])])[]dnl
+m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
+])[]dnl
+])
+
+
+# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
+# ----------------------------------------
+# OPTION-LIST is a space-separated list of Libtool options associated
+# with MACRO-NAME.  If any OPTION has a matching handler declared with
+# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
+# the unknown option and exit.
+m4_defun([_LT_SET_OPTIONS],
+[# Set options
+m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+    [_LT_SET_OPTION([$1], _LT_Option)])
+
+m4_if([$1],[LT_INIT],[
+  dnl
+  dnl Simply set some default values (i.e off) if boolean options were not
+  dnl specified:
+  _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
+  ])
+  _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
+  ])
+  dnl
+  dnl If no reference was made to various pairs of opposing options, then
+  dnl we run the default mode handler for the pair.  For example, if neither
+  dnl 'shared' nor 'disable-shared' was passed, we enable building of shared
+  dnl archives by default:
+  _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
+  _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
+		   [_LT_ENABLE_FAST_INSTALL])
+  _LT_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4],
+		   [_LT_WITH_AIX_SONAME([aix])])
+  ])
+])# _LT_SET_OPTIONS
+
+
+## --------------------------------- ##
+## Macros to handle LT_INIT options. ##
+## --------------------------------- ##
+
+# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
+# -----------------------------------------
+m4_define([_LT_MANGLE_DEFUN],
+[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
+
+
+# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
+# -----------------------------------------------
+m4_define([LT_OPTION_DEFINE],
+[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
+])# LT_OPTION_DEFINE
+
+
+# dlopen
+# ------
+LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
+])
+
+AU_DEFUN([AC_LIBTOOL_DLOPEN],
+[_LT_SET_OPTION([LT_INIT], [dlopen])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the 'dlopen' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
+
+
+# win32-dll
+# ---------
+# Declare package support for building win32 dll's.
+LT_OPTION_DEFINE([LT_INIT], [win32-dll],
+[enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
+  AC_CHECK_TOOL(AS, as, false)
+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+  AC_CHECK_TOOL(OBJDUMP, objdump, false)
+  ;;
+esac
+
+test -z "$AS" && AS=as
+_LT_DECL([], [AS],      [1], [Assembler program])dnl
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl
+])# win32-dll
+
+AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+_LT_SET_OPTION([LT_INIT], [win32-dll])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the 'win32-dll' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
+
+
+# _LT_ENABLE_SHARED([DEFAULT])
+# ----------------------------
+# implement the --enable-shared flag, and supports the 'shared' and
+# 'disable-shared' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
+m4_define([_LT_ENABLE_SHARED],
+[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([shared],
+    [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+	[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac],
+    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
+
+    _LT_DECL([build_libtool_libs], [enable_shared], [0],
+	[Whether or not to build shared libraries])
+])# _LT_ENABLE_SHARED
+
+LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
+])
+
+AC_DEFUN([AC_DISABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], [disable-shared])
+])
+
+AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
+AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_SHARED], [])
+dnl AC_DEFUN([AM_DISABLE_SHARED], [])
+
+
+
+# _LT_ENABLE_STATIC([DEFAULT])
+# ----------------------------
+# implement the --enable-static flag, and support the 'static' and
+# 'disable-static' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
+m4_define([_LT_ENABLE_STATIC],
+[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([static],
+    [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+	[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac],
+    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
+
+    _LT_DECL([build_old_libs], [enable_static], [0],
+	[Whether or not to build static libraries])
+])# _LT_ENABLE_STATIC
+
+LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
+])
+
+AC_DEFUN([AC_DISABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], [disable-static])
+])
+
+AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
+AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_STATIC], [])
+dnl AC_DEFUN([AM_DISABLE_STATIC], [])
+
+
+
+# _LT_ENABLE_FAST_INSTALL([DEFAULT])
+# ----------------------------------
+# implement the --enable-fast-install flag, and support the 'fast-install'
+# and 'disable-fast-install' LT_INIT options.
+# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
+m4_define([_LT_ENABLE_FAST_INSTALL],
+[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([fast-install],
+    [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac],
+    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
+
+_LT_DECL([fast_install], [enable_fast_install], [0],
+	 [Whether or not to optimize for fast installation])dnl
+])# _LT_ENABLE_FAST_INSTALL
+
+LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the 'fast-install' option into LT_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the 'disable-fast-install' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
+dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
+
+
+# _LT_WITH_AIX_SONAME([DEFAULT])
+# ----------------------------------
+# implement the --with-aix-soname flag, and support the `aix-soname=aix'
+# and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT
+# is either `aix', `both' or `svr4'.  If omitted, it defaults to `aix'.
+m4_define([_LT_WITH_AIX_SONAME],
+[m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl
+shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix[[5-9]]*,yes)
+  AC_MSG_CHECKING([which variant of shared library versioning to provide])
+  AC_ARG_WITH([aix-soname],
+    [AS_HELP_STRING([--with-aix-soname=aix|svr4|both],
+      [shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])],
+    [case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      AC_MSG_ERROR([Unknown argument to --with-aix-soname])
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname],
+    [AC_CACHE_VAL([lt_cv_with_aix_soname],
+      [lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT)
+    with_aix_soname=$lt_cv_with_aix_soname])
+  AC_MSG_RESULT([$with_aix_soname])
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+_LT_DECL([], [shared_archive_member_spec], [0],
+    [Shared archive member basename, for filename based shared library versioning on AIX])dnl
+])# _LT_WITH_AIX_SONAME
+
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])])
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])])
+LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])])
+
+
+# _LT_WITH_PIC([MODE])
+# --------------------
+# implement the --with-pic flag, and support the 'pic-only' and 'no-pic'
+# LT_INIT options.
+# MODE is either 'yes' or 'no'.  If omitted, it defaults to 'both'.
+m4_define([_LT_WITH_PIC],
+[AC_ARG_WITH([pic],
+    [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
+	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+    [lt_p=${PACKAGE-default}
+    case $withval in
+    yes|no) pic_mode=$withval ;;
+    *)
+      pic_mode=default
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for lt_pkg in $withval; do
+	IFS=$lt_save_ifs
+	if test "X$lt_pkg" = "X$lt_p"; then
+	  pic_mode=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac],
+    [pic_mode=m4_default([$1], [default])])
+
+_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
+])# _LT_WITH_PIC
+
+LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
+
+# Old name:
+AU_DEFUN([AC_LIBTOOL_PICMODE],
+[_LT_SET_OPTION([LT_INIT], [pic-only])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the 'pic-only' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
+
+## ----------------- ##
+## LTDL_INIT Options ##
+## ----------------- ##
+
+m4_define([_LTDL_MODE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
+		 [m4_define([_LTDL_MODE], [nonrecursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [recursive],
+		 [m4_define([_LTDL_MODE], [recursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [subproject],
+		 [m4_define([_LTDL_MODE], [subproject])])
+
+m4_define([_LTDL_TYPE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [installable],
+		 [m4_define([_LTDL_TYPE], [installable])])
+LT_OPTION_DEFINE([LTDL_INIT], [convenience],
+		 [m4_define([_LTDL_TYPE], [convenience])])
diff --git a/deps/cares/m4/ltsugar.m4 b/deps/cares/m4/ltsugar.m4
new file mode 100644
index 0000000000000000000000000000000000000000..48bc9344a4d661e116be1483d5520753875b2bd1
--- /dev/null
+++ b/deps/cares/m4/ltsugar.m4
@@ -0,0 +1,124 @@
+# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
+#
+# Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software
+# Foundation, Inc.
+# Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltsugar.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
+
+
+# lt_join(SEP, ARG1, [ARG2...])
+# -----------------------------
+# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
+# associated separator.
+# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
+# versions in m4sugar had bugs.
+m4_define([lt_join],
+[m4_if([$#], [1], [],
+       [$#], [2], [[$2]],
+       [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
+m4_define([_lt_join],
+[m4_if([$#$2], [2], [],
+       [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
+
+
+# lt_car(LIST)
+# lt_cdr(LIST)
+# ------------
+# Manipulate m4 lists.
+# These macros are necessary as long as will still need to support
+# Autoconf-2.59, which quotes differently.
+m4_define([lt_car], [[$1]])
+m4_define([lt_cdr],
+[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
+       [$#], 1, [],
+       [m4_dquote(m4_shift($@))])])
+m4_define([lt_unquote], $1)
+
+
+# lt_append(MACRO-NAME, STRING, [SEPARATOR])
+# ------------------------------------------
+# Redefine MACRO-NAME to hold its former content plus 'SEPARATOR''STRING'.
+# Note that neither SEPARATOR nor STRING are expanded; they are appended
+# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
+# No SEPARATOR is output if MACRO-NAME was previously undefined (different
+# than defined and empty).
+#
+# This macro is needed until we can rely on Autoconf 2.62, since earlier
+# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
+m4_define([lt_append],
+[m4_define([$1],
+	   m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
+
+
+
+# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
+# ----------------------------------------------------------
+# Produce a SEP delimited list of all paired combinations of elements of
+# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
+# has the form PREFIXmINFIXSUFFIXn.
+# Needed until we can rely on m4_combine added in Autoconf 2.62.
+m4_define([lt_combine],
+[m4_if(m4_eval([$# > 3]), [1],
+       [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
+[[m4_foreach([_Lt_prefix], [$2],
+	     [m4_foreach([_Lt_suffix],
+		]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
+	[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
+
+
+# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
+# -----------------------------------------------------------------------
+# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
+# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
+m4_define([lt_if_append_uniq],
+[m4_ifdef([$1],
+	  [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
+		 [lt_append([$1], [$2], [$3])$4],
+		 [$5])],
+	  [lt_append([$1], [$2], [$3])$4])])
+
+
+# lt_dict_add(DICT, KEY, VALUE)
+# -----------------------------
+m4_define([lt_dict_add],
+[m4_define([$1($2)], [$3])])
+
+
+# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
+# --------------------------------------------
+m4_define([lt_dict_add_subkey],
+[m4_define([$1($2:$3)], [$4])])
+
+
+# lt_dict_fetch(DICT, KEY, [SUBKEY])
+# ----------------------------------
+m4_define([lt_dict_fetch],
+[m4_ifval([$3],
+	m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
+    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
+
+
+# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
+# -----------------------------------------------------------------
+m4_define([lt_if_dict_fetch],
+[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
+	[$5],
+    [$6])])
+
+
+# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
+# --------------------------------------------------------------
+m4_define([lt_dict_filter],
+[m4_if([$5], [], [],
+  [lt_join(m4_quote(m4_default([$4], [[, ]])),
+           lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
+		      [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
+])
diff --git a/deps/cares/m4/ltversion.m4 b/deps/cares/m4/ltversion.m4
new file mode 100644
index 0000000000000000000000000000000000000000..fa04b52a3bf868bd57e7ba796d64385a51e7ec5a
--- /dev/null
+++ b/deps/cares/m4/ltversion.m4
@@ -0,0 +1,23 @@
+# ltversion.m4 -- version numbers			-*- Autoconf -*-
+#
+#   Copyright (C) 2004, 2011-2015 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# @configure_input@
+
+# serial 4179 ltversion.m4
+# This file is part of GNU Libtool
+
+m4_define([LT_PACKAGE_VERSION], [2.4.6])
+m4_define([LT_PACKAGE_REVISION], [2.4.6])
+
+AC_DEFUN([LTVERSION_VERSION],
+[macro_version='2.4.6'
+macro_revision='2.4.6'
+_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
+_LT_DECL(, macro_revision, 0)
+])
diff --git a/deps/cares/m4/lt~obsolete.m4 b/deps/cares/m4/lt~obsolete.m4
new file mode 100644
index 0000000000000000000000000000000000000000..c6b26f88f6c3c1a052afa6314ba2adf832d785ee
--- /dev/null
+++ b/deps/cares/m4/lt~obsolete.m4
@@ -0,0 +1,99 @@
+# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
+#
+#   Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software
+#   Foundation, Inc.
+#   Written by Scott James Remnant, 2004.
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 5 lt~obsolete.m4
+
+# These exist entirely to fool aclocal when bootstrapping libtool.
+#
+# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN),
+# which have later been changed to m4_define as they aren't part of the
+# exported API, or moved to Autoconf or Automake where they belong.
+#
+# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
+# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
+# using a macro with the same name in our local m4/libtool.m4 it'll
+# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
+# and doesn't know about Autoconf macros at all.)
+#
+# So we provide this file, which has a silly filename so it's always
+# included after everything else.  This provides aclocal with the
+# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
+# because those macros already exist, or will be overwritten later.
+# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6.
+#
+# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
+# Yes, that means every name once taken will need to remain here until
+# we give up compatibility with versions before 1.7, at which point
+# we need to keep only those names which we still refer to.
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
+
+m4_ifndef([AC_LIBTOOL_LINKER_OPTION],	[AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
+m4_ifndef([AC_PROG_EGREP],		[AC_DEFUN([AC_PROG_EGREP])])
+m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_AC_SHELL_INIT],		[AC_DEFUN([_LT_AC_SHELL_INIT])])
+m4_ifndef([_LT_AC_SYS_LIBPATH_AIX],	[AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
+m4_ifndef([_LT_PROG_LTMAIN],		[AC_DEFUN([_LT_PROG_LTMAIN])])
+m4_ifndef([_LT_AC_TAGVAR],		[AC_DEFUN([_LT_AC_TAGVAR])])
+m4_ifndef([AC_LTDL_ENABLE_INSTALL],	[AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
+m4_ifndef([AC_LTDL_PREOPEN],		[AC_DEFUN([AC_LTDL_PREOPEN])])
+m4_ifndef([_LT_AC_SYS_COMPILER],	[AC_DEFUN([_LT_AC_SYS_COMPILER])])
+m4_ifndef([_LT_AC_LOCK],		[AC_DEFUN([_LT_AC_LOCK])])
+m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE],	[AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
+m4_ifndef([_LT_AC_TRY_DLOPEN_SELF],	[AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
+m4_ifndef([AC_LIBTOOL_PROG_CC_C_O],	[AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
+m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
+m4_ifndef([AC_LIBTOOL_OBJDIR],		[AC_DEFUN([AC_LIBTOOL_OBJDIR])])
+m4_ifndef([AC_LTDL_OBJDIR],		[AC_DEFUN([AC_LTDL_OBJDIR])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
+m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP],	[AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
+m4_ifndef([AC_PATH_MAGIC],		[AC_DEFUN([AC_PATH_MAGIC])])
+m4_ifndef([AC_PROG_LD_GNU],		[AC_DEFUN([AC_PROG_LD_GNU])])
+m4_ifndef([AC_PROG_LD_RELOAD_FLAG],	[AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
+m4_ifndef([AC_DEPLIBS_CHECK_METHOD],	[AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
+m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],	[AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
+m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],	[AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
+m4_ifndef([LT_AC_PROG_EGREP],		[AC_DEFUN([LT_AC_PROG_EGREP])])
+m4_ifndef([LT_AC_PROG_SED],		[AC_DEFUN([LT_AC_PROG_SED])])
+m4_ifndef([_LT_CC_BASENAME],		[AC_DEFUN([_LT_CC_BASENAME])])
+m4_ifndef([_LT_COMPILER_BOILERPLATE],	[AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
+m4_ifndef([_LT_LINKER_BOILERPLATE],	[AC_DEFUN([_LT_LINKER_BOILERPLATE])])
+m4_ifndef([_AC_PROG_LIBTOOL],		[AC_DEFUN([_AC_PROG_LIBTOOL])])
+m4_ifndef([AC_LIBTOOL_SETUP],		[AC_DEFUN([AC_LIBTOOL_SETUP])])
+m4_ifndef([_LT_AC_CHECK_DLFCN],		[AC_DEFUN([_LT_AC_CHECK_DLFCN])])
+m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],	[AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
+m4_ifndef([_LT_AC_TAGCONFIG],		[AC_DEFUN([_LT_AC_TAGCONFIG])])
+m4_ifndef([AC_DISABLE_FAST_INSTALL],	[AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
+m4_ifndef([_LT_AC_LANG_CXX],		[AC_DEFUN([_LT_AC_LANG_CXX])])
+m4_ifndef([_LT_AC_LANG_F77],		[AC_DEFUN([_LT_AC_LANG_F77])])
+m4_ifndef([_LT_AC_LANG_GCJ],		[AC_DEFUN([_LT_AC_LANG_GCJ])])
+m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
+m4_ifndef([_LT_AC_LANG_C_CONFIG],	[AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
+m4_ifndef([_LT_AC_LANG_CXX_CONFIG],	[AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
+m4_ifndef([_LT_AC_LANG_F77_CONFIG],	[AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
+m4_ifndef([_LT_AC_LANG_GCJ_CONFIG],	[AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
+m4_ifndef([_LT_AC_LANG_RC_CONFIG],	[AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
+m4_ifndef([AC_LIBTOOL_CONFIG],		[AC_DEFUN([AC_LIBTOOL_CONFIG])])
+m4_ifndef([_LT_AC_FILE_LTDLL_C],	[AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
+m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS],	[AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])])
+m4_ifndef([_LT_AC_PROG_CXXCPP],		[AC_DEFUN([_LT_AC_PROG_CXXCPP])])
+m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS],	[AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])])
+m4_ifndef([_LT_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_PROG_F77],		[AC_DEFUN([_LT_PROG_F77])])
+m4_ifndef([_LT_PROG_FC],		[AC_DEFUN([_LT_PROG_FC])])
+m4_ifndef([_LT_PROG_CXX],		[AC_DEFUN([_LT_PROG_CXX])])
diff --git a/deps/cares/m4/xc-am-iface.m4 b/deps/cares/m4/xc-am-iface.m4
new file mode 100644
index 0000000000000000000000000000000000000000..1571c211fb4e543f657b5ed393f3d43d1915813c
--- /dev/null
+++ b/deps/cares/m4/xc-am-iface.m4
@@ -0,0 +1,253 @@
+#---------------------------------------------------------------------------
+#
+# xc-am-iface.m4
+#
+# Copyright (c) 2013 Daniel Stenberg <daniel@haxx.se>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+#---------------------------------------------------------------------------
+
+# serial 1
+
+
+dnl _XC_AUTOMAKE_BODY
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl This macro performs embedding of automake initialization
+dnl code into configure script. When automake version 1.14 or
+dnl newer is used at configure script generation time, this
+dnl results in 'subdir-objects' automake option being used.
+dnl When using automake versions older than 1.14 this option
+dnl is not used when generating configure script.
+dnl
+dnl Existence of automake _AM_PROG_CC_C_O m4 private macro
+dnl is used to differentiate automake version 1.14 from older
+dnl ones which lack this macro.
+
+m4_define([_XC_AUTOMAKE_BODY],
+[dnl
+## --------------------------------------- ##
+##  Start of automake initialization code  ##
+## --------------------------------------- ##
+m4_ifdef([_AM_PROG_CC_C_O],
+[
+AM_INIT_AUTOMAKE([subdir-objects])
+],[
+AM_INIT_AUTOMAKE
+])dnl
+## ------------------------------------- ##
+##  End of automake initialization code  ##
+## ------------------------------------- ##
+dnl
+m4_define([$0], [])[]dnl
+])
+
+
+dnl XC_AUTOMAKE
+dnl -------------------------------------------------
+dnl Public macro.
+dnl
+dnl This macro embeds automake machinery into configure
+dnl script regardless of automake version used in order
+dnl to generate configure script.
+dnl
+dnl When using automake version 1.14 or newer, automake
+dnl initialization option 'subdir-objects' is used to
+dnl generate the configure script, otherwise this option
+dnl is not used.
+
+AC_DEFUN([XC_AUTOMAKE],
+[dnl
+AC_PREREQ([2.50])dnl
+dnl
+AC_BEFORE([$0],[AM_INIT_AUTOMAKE])dnl
+dnl
+_XC_AUTOMAKE_BODY
+dnl
+m4_ifdef([AM_INIT_AUTOMAKE],
+  [m4_undefine([AM_INIT_AUTOMAKE])])dnl
+dnl
+m4_define([$0], [])[]dnl
+])
+
+
+dnl _XC_AMEND_DISTCLEAN_BODY ([LIST-OF-SUBDIRS])
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl This macro performs shell code embedding into
+dnl configure script in order to modify distclean
+dnl and maintainer-clean targets of makefiles which
+dnl are located in given list of subdirs.
+dnl
+dnl See XC_AMEND_DISTCLEAN comments for details.
+
+m4_define([_XC_AMEND_DISTCLEAN_BODY],
+[dnl
+## ---------------------------------- ##
+##  Start of distclean amending code  ##
+## ---------------------------------- ##
+
+for xc_subdir in [$1]
+do
+
+if test ! -f "$xc_subdir/Makefile"; then
+  echo "$xc_msg_err $xc_subdir/Makefile file not found. $xc_msg_abrt" >&2
+  exit 1
+fi
+
+# Fetch dependency tracking file list from Makefile include lines.
+
+xc_inc_lines=`grep '^include .*(DEPDIR)' "$xc_subdir/Makefile" 2>/dev/null`
+xc_cnt_words=`echo "$xc_inc_lines" | wc -w | tr -d "$xc_space$xc_tab"`
+
+# --disable-dependency-tracking might have been used, consequently
+# there is nothing to amend without a dependency tracking file list.
+
+if test $xc_cnt_words -gt 0; then
+
+AC_MSG_NOTICE([amending $xc_subdir/Makefile])
+
+# Build Makefile specific patch hunk.
+
+xc_p="$xc_subdir/xc_patch.tmp"
+
+xc_rm_depfiles=`echo "$xc_inc_lines" \
+  | $SED 's%include%	-rm -f%' 2>/dev/null`
+
+xc_dep_subdirs=`echo "$xc_inc_lines" \
+  | $SED 's%include[[ ]][[ ]]*%%' 2>/dev/null \
+  | $SED 's%(DEPDIR)/.*%(DEPDIR)%' 2>/dev/null \
+  | sort | uniq`
+
+echo "$xc_rm_depfiles" >$xc_p
+
+for xc_dep_dir in $xc_dep_subdirs; do
+  echo "${xc_tab}@xm_dep_cnt=\`ls $xc_dep_dir | wc -l 2>/dev/null\`; \\"            >>$xc_p
+  echo "${xc_tab}if test \$\$xm_dep_cnt -eq 0 && test -d $xc_dep_dir; then \\"      >>$xc_p
+  echo "${xc_tab}  rm -rf $xc_dep_dir; \\"                                          >>$xc_p
+  echo "${xc_tab}fi"                                                                >>$xc_p
+done
+
+# Build Makefile patching sed scripts.
+
+xc_s1="$xc_subdir/xc_script_1.tmp"
+xc_s2="$xc_subdir/xc_script_2.tmp"
+xc_s3="$xc_subdir/xc_script_3.tmp"
+
+cat >$xc_s1 <<\_EOT
+/^distclean[[ ]]*:/,/^[[^	]][[^	]]*:/{
+  s/^.*(DEPDIR)/___xc_depdir_line___/
+}
+/^maintainer-clean[[ ]]*:/,/^[[^	]][[^	]]*:/{
+  s/^.*(DEPDIR)/___xc_depdir_line___/
+}
+_EOT
+
+cat >$xc_s2 <<\_EOT
+/___xc_depdir_line___$/{
+  N
+  /___xc_depdir_line___$/D
+}
+_EOT
+
+cat >$xc_s3 <<_EOT
+/^___xc_depdir_line___/{
+  r $xc_p
+  d
+}
+_EOT
+
+# Apply patch to Makefile and cleanup.
+
+$SED -f "$xc_s1" "$xc_subdir/Makefile"      >"$xc_subdir/Makefile.tmp1"
+$SED -f "$xc_s2" "$xc_subdir/Makefile.tmp1" >"$xc_subdir/Makefile.tmp2"
+$SED -f "$xc_s3" "$xc_subdir/Makefile.tmp2" >"$xc_subdir/Makefile.tmp3"
+
+if test -f "$xc_subdir/Makefile.tmp3"; then
+  mv -f "$xc_subdir/Makefile.tmp3" "$xc_subdir/Makefile"
+fi
+
+test -f "$xc_subdir/Makefile.tmp1" && rm -f "$xc_subdir/Makefile.tmp1"
+test -f "$xc_subdir/Makefile.tmp2" && rm -f "$xc_subdir/Makefile.tmp2"
+test -f "$xc_subdir/Makefile.tmp3" && rm -f "$xc_subdir/Makefile.tmp3"
+
+test -f "$xc_p"  && rm -f "$xc_p"
+test -f "$xc_s1" && rm -f "$xc_s1"
+test -f "$xc_s2" && rm -f "$xc_s2"
+test -f "$xc_s3" && rm -f "$xc_s3"
+
+fi
+
+done
+
+## -------------------------------- ##
+##  End of distclean amending code  ##
+## -------------------------------- ##
+dnl
+m4_define([$0], [])[]dnl
+])
+
+
+dnl XC_AMEND_DISTCLEAN ([LIST-OF-SUBDIRS])
+dnl -------------------------------------------------
+dnl Public macro.
+dnl
+dnl This macro embeds shell code into configure script
+dnl that amends, at configure runtime, the distclean
+dnl and maintainer-clean targets of Makefiles located
+dnl in all subdirs given in the mandatory white-space
+dnl separated list argument.
+dnl
+dnl Embedding only takes place when using automake 1.14
+dnl or newer, otherwise amending code is not included
+dnl in generated configure script.
+dnl
+dnl distclean and maintainer-clean targets are modified
+dnl to avoid unconditional removal of dependency subdirs
+dnl which triggers distclean and maintainer-clean errors
+dnl when using automake 'subdir-objects' option along
+dnl with per-target objects and source files existing in
+dnl multiple subdirs used for different build targets.
+dnl
+dnl New behavior first removes each dependency tracking
+dnl file independently, and only removes each dependency
+dnl subdir when it finds out that it no longer holds any
+dnl dependency tracking file.
+dnl
+dnl When configure option --disable-dependency-tracking
+dnl is used no amending takes place given that there are
+dnl no dependency tracking files.
+
+AC_DEFUN([XC_AMEND_DISTCLEAN],
+[dnl
+AC_PREREQ([2.50])dnl
+dnl
+m4_ifdef([_AC_OUTPUT_MAIN_LOOP],
+  [m4_provide_if([_AC_OUTPUT_MAIN_LOOP], [],
+    [m4_fatal([call to AC_OUTPUT needed before $0])])])dnl
+dnl
+m4_if([$#], [1], [], [m4_fatal([$0: wrong number of arguments])])dnl
+m4_if([$1], [], [m4_fatal([$0: missing argument])])dnl
+dnl
+AC_REQUIRE([XC_CONFIGURE_PREAMBLE])dnl
+dnl
+m4_ifdef([_AM_PROG_CC_C_O],
+[
+_XC_AMEND_DISTCLEAN_BODY([$1])
+])dnl
+m4_define([$0], [])[]dnl
+])
+
diff --git a/deps/cares/m4/xc-cc-check.m4 b/deps/cares/m4/xc-cc-check.m4
new file mode 100644
index 0000000000000000000000000000000000000000..777decf2983d1188231836d79ff584729b9189d9
--- /dev/null
+++ b/deps/cares/m4/xc-cc-check.m4
@@ -0,0 +1,96 @@
+#---------------------------------------------------------------------------
+#
+# xc-cc-check.m4
+#
+# Copyright (c) 2013 Daniel Stenberg <daniel@haxx.se>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+#---------------------------------------------------------------------------
+
+# serial 1
+
+
+dnl _XC_PROG_CC_PREAMBLE
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_PROG_CC_PREAMBLE], [
+  xc_prog_cc_prev_IFS=$IFS
+  xc_prog_cc_prev_LIBS=$LIBS
+  xc_prog_cc_prev_CFLAGS=$CFLAGS
+  xc_prog_cc_prev_LDFLAGS=$LDFLAGS
+  xc_prog_cc_prev_CPPFLAGS=$CPPFLAGS
+])
+
+
+dnl _XC_PROG_CC_POSTLUDE
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_PROG_CC_POSTLUDE], [
+  IFS=$xc_prog_cc_prev_IFS
+  LIBS=$xc_prog_cc_prev_LIBS
+  CFLAGS=$xc_prog_cc_prev_CFLAGS
+  LDFLAGS=$xc_prog_cc_prev_LDFLAGS
+  CPPFLAGS=$xc_prog_cc_prev_CPPFLAGS
+  AC_SUBST([CC])dnl
+  AC_SUBST([CPP])dnl
+  AC_SUBST([LIBS])dnl
+  AC_SUBST([CFLAGS])dnl
+  AC_SUBST([LDFLAGS])dnl
+  AC_SUBST([CPPFLAGS])dnl
+])
+
+
+dnl _XC_PROG_CC
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_PROG_CC], [
+  AC_REQUIRE([_XC_PROG_CC_PREAMBLE])dnl
+  AC_REQUIRE([XC_CHECK_BUILD_FLAGS])dnl
+  AC_REQUIRE([AC_PROG_INSTALL])dnl
+  AC_REQUIRE([AC_PROG_CC])dnl
+  AC_REQUIRE([AM_PROG_CC_C_O])dnl
+  AC_REQUIRE([AC_PROG_CPP])dnl
+  AC_REQUIRE([_XC_PROG_CC_POSTLUDE])dnl
+])
+
+
+dnl XC_CHECK_PROG_CC
+dnl -------------------------------------------------
+dnl Public macro.
+dnl
+dnl Checks for C compiler and C preprocessor programs,
+dnl while doing some previous sanity validation on user
+dnl provided LIBS, LDFLAGS, CPPFLAGS and CFLAGS values
+dnl that must succeed in order to continue execution.
+dnl
+dnl This sets variables CC and CPP, while preventing
+dnl LIBS, LDFLAGS, CFLAGS, CPPFLAGS and IFS from being
+dnl unexpectedly changed by underlying macros.
+
+AC_DEFUN([XC_CHECK_PROG_CC], [
+  AC_PREREQ([2.50])dnl
+  AC_BEFORE([$0],[_XC_PROG_CC_PREAMBLE])dnl
+  AC_BEFORE([$0],[AC_PROG_INSTALL])dnl
+  AC_BEFORE([$0],[AC_PROG_CC])dnl
+  AC_BEFORE([$0],[AM_PROG_CC_C_O])dnl
+  AC_BEFORE([$0],[AC_PROG_CPP])dnl
+  AC_BEFORE([$0],[AC_PROG_LIBTOOL])dnl
+  AC_BEFORE([$0],[AM_INIT_AUTOMAKE])dnl
+  AC_BEFORE([$0],[_XC_PROG_CC_POSTLUDE])dnl
+  AC_REQUIRE([_XC_PROG_CC])dnl
+])
+
diff --git a/deps/cares/m4/xc-lt-iface.m4 b/deps/cares/m4/xc-lt-iface.m4
new file mode 100644
index 0000000000000000000000000000000000000000..0b90d5f25f02521085356e95ed0157f98c1da7d2
--- /dev/null
+++ b/deps/cares/m4/xc-lt-iface.m4
@@ -0,0 +1,465 @@
+#---------------------------------------------------------------------------
+#
+# xc-lt-iface.m4
+#
+# Copyright (c) 2013 Daniel Stenberg <daniel@haxx.se>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+#---------------------------------------------------------------------------
+
+# serial 1
+
+
+dnl _XC_LIBTOOL_PREAMBLE
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Checks some configure script options related with
+dnl libtool and customizes its default behavior before
+dnl libtool code is actually used in script.
+
+m4_define([_XC_LIBTOOL_PREAMBLE],
+[dnl
+# ------------------------------------ #
+#  Determine libtool default behavior  #
+# ------------------------------------ #
+
+#
+# Default behavior is to enable shared and static libraries on systems
+# where libtool knows how to build both library versions, and does not
+# require separate configuration and build runs for each flavor.
+#
+
+xc_lt_want_enable_shared='yes'
+xc_lt_want_enable_static='yes'
+
+#
+# User may have disabled shared or static libraries.
+#
+case "x$enable_shared" in @%:@ (
+  xno)
+    xc_lt_want_enable_shared='no'
+    ;;
+esac
+case "x$enable_static" in @%:@ (
+  xno)
+    xc_lt_want_enable_static='no'
+    ;;
+esac
+if test "x$xc_lt_want_enable_shared" = 'xno' &&
+  test "x$xc_lt_want_enable_static" = 'xno'; then
+  AC_MSG_ERROR([can not disable shared and static libraries simultaneously])
+fi
+
+#
+# Default behavior on systems that require independent configuration
+# and build runs for shared and static is to enable shared libraries
+# and disable static ones. On these systems option '--disable-shared'
+# must be used in order to build a proper static library.
+#
+
+if test "x$xc_lt_want_enable_shared" = 'xyes' &&
+  test "x$xc_lt_want_enable_static" = 'xyes'; then
+  case $host_os in @%:@ (
+    mingw* | pw32* | cegcc* | os2* | aix*)
+      xc_lt_want_enable_static='no'
+      ;;
+  esac
+fi
+
+#
+# Make libtool aware of current shared and static library preferences
+# taking in account that, depending on host characteristics, libtool
+# may modify these option preferences later in this configure script.
+#
+
+enable_shared=$xc_lt_want_enable_shared
+enable_static=$xc_lt_want_enable_static
+
+#
+# Default behavior is to build PIC objects for shared libraries and
+# non-PIC objects for static libraries.
+#
+
+xc_lt_want_with_pic='default'
+
+#
+# User may have specified PIC preference.
+#
+
+case "x$with_pic" in @%:@ ((
+  xno)
+    xc_lt_want_with_pic='no'
+    ;;
+  xyes)
+    xc_lt_want_with_pic='yes'
+    ;;
+esac
+
+#
+# Default behavior on some systems where building a shared library out
+# of non-PIC compiled objects will fail with following linker error
+# "relocation R_X86_64_32 can not be used when making a shared object"
+# is to build PIC objects even for static libraries. This behavior may
+# be overriden using 'configure --disable-shared --without-pic'.
+#
+
+if test "x$xc_lt_want_with_pic" = 'xdefault'; then
+  case $host_cpu in @%:@ (
+    x86_64 | amd64 | ia64)
+      case $host_os in @%:@ (
+        linux* | freebsd*)
+          xc_lt_want_with_pic='yes'
+          ;;
+      esac
+      ;;
+  esac
+fi
+
+#
+# Make libtool aware of current PIC preference taking in account that,
+# depending on host characteristics, libtool may modify PIC default
+# behavior to fit host system idiosyncrasies later in this script.
+#
+
+with_pic=$xc_lt_want_with_pic
+dnl
+m4_define([$0],[])dnl
+])
+
+
+dnl _XC_LIBTOOL_BODY
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl This macro performs embedding of libtool code into
+dnl configure script, regardless of libtool version in
+dnl use when generating configure script.
+
+m4_define([_XC_LIBTOOL_BODY],
+[dnl
+## ----------------------- ##
+##  Start of libtool code  ##
+## ----------------------- ##
+m4_ifdef([LT_INIT],
+[dnl
+LT_INIT([win32-dll])
+],[dnl
+AC_LIBTOOL_WIN32_DLL
+AC_PROG_LIBTOOL
+])dnl
+## --------------------- ##
+##  End of libtool code  ##
+## --------------------- ##
+dnl
+m4_define([$0], [])[]dnl
+])
+
+
+dnl _XC_CHECK_LT_BUILD_LIBRARIES
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Checks wether libtool shared and static libraries
+dnl are finally built depending on user input, default
+dnl behavior and knowledge that libtool has about host
+dnl characteristics.
+dnl Results stored in following shell variables:
+dnl   xc_lt_build_shared
+dnl   xc_lt_build_static
+
+m4_define([_XC_CHECK_LT_BUILD_LIBRARIES],
+[dnl
+#
+# Verify if finally libtool shared libraries will be built
+#
+
+case "x$enable_shared" in @%:@ ((
+  xyes | xno)
+    xc_lt_build_shared=$enable_shared
+    ;;
+  *)
+    AC_MSG_ERROR([unexpected libtool enable_shared value: $enable_shared])
+    ;;
+esac
+
+#
+# Verify if finally libtool static libraries will be built
+#
+
+case "x$enable_static" in @%:@ ((
+  xyes | xno)
+    xc_lt_build_static=$enable_static
+    ;;
+  *)
+    AC_MSG_ERROR([unexpected libtool enable_static value: $enable_static])
+    ;;
+esac
+dnl
+m4_define([$0],[])dnl
+])
+
+
+dnl _XC_CHECK_LT_SHLIB_USE_VERSION_INFO
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Checks if the -version-info linker flag must be
+dnl provided when building libtool shared libraries.
+dnl Result stored in xc_lt_shlib_use_version_info.
+
+m4_define([_XC_CHECK_LT_SHLIB_USE_VERSION_INFO],
+[dnl
+#
+# Verify if libtool shared libraries should be linked using flag -version-info
+#
+
+AC_MSG_CHECKING([whether to build shared libraries with -version-info])
+xc_lt_shlib_use_version_info='yes'
+if test "x$version_type" = 'xnone'; then
+  xc_lt_shlib_use_version_info='no'
+fi
+case $host_os in @%:@ (
+  amigaos*)
+    xc_lt_shlib_use_version_info='yes'
+    ;;
+esac
+AC_MSG_RESULT([$xc_lt_shlib_use_version_info])
+dnl
+m4_define([$0], [])[]dnl
+])
+
+
+dnl _XC_CHECK_LT_SHLIB_USE_NO_UNDEFINED
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Checks if the -no-undefined linker flag must be
+dnl provided when building libtool shared libraries.
+dnl Result stored in xc_lt_shlib_use_no_undefined.
+
+m4_define([_XC_CHECK_LT_SHLIB_USE_NO_UNDEFINED],
+[dnl
+#
+# Verify if libtool shared libraries should be linked using flag -no-undefined
+#
+
+AC_MSG_CHECKING([whether to build shared libraries with -no-undefined])
+xc_lt_shlib_use_no_undefined='no'
+if test "x$allow_undefined" = 'xno'; then
+  xc_lt_shlib_use_no_undefined='yes'
+elif test "x$allow_undefined_flag" = 'xunsupported'; then
+  xc_lt_shlib_use_no_undefined='yes'
+fi
+case $host_os in @%:@ (
+  cygwin* | mingw* | pw32* | cegcc* | os2* | aix*)
+    xc_lt_shlib_use_no_undefined='yes'
+    ;;
+esac
+AC_MSG_RESULT([$xc_lt_shlib_use_no_undefined])
+dnl
+m4_define([$0], [])[]dnl
+])
+
+
+dnl _XC_CHECK_LT_SHLIB_USE_MIMPURE_TEXT
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Checks if the -mimpure-text linker flag must be
+dnl provided when building libtool shared libraries.
+dnl Result stored in xc_lt_shlib_use_mimpure_text.
+
+m4_define([_XC_CHECK_LT_SHLIB_USE_MIMPURE_TEXT],
+[dnl
+#
+# Verify if libtool shared libraries should be linked using flag -mimpure-text
+#
+
+AC_MSG_CHECKING([whether to build shared libraries with -mimpure-text])
+xc_lt_shlib_use_mimpure_text='no'
+case $host_os in @%:@ (
+  solaris2*)
+    if test "x$GCC" = 'xyes'; then
+      xc_lt_shlib_use_mimpure_text='yes'
+    fi
+    ;;
+esac
+AC_MSG_RESULT([$xc_lt_shlib_use_mimpure_text])
+dnl
+m4_define([$0], [])[]dnl
+])
+
+
+dnl _XC_CHECK_LT_BUILD_WITH_PIC
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Checks wether libtool shared and static libraries
+dnl would be built with PIC depending on user input,
+dnl default behavior and knowledge that libtool has
+dnl about host characteristics.
+dnl Results stored in following shell variables:
+dnl   xc_lt_build_shared_with_pic
+dnl   xc_lt_build_static_with_pic
+
+m4_define([_XC_CHECK_LT_BUILD_WITH_PIC],
+[dnl
+#
+# Find out wether libtool libraries would be built wit PIC
+#
+
+case "x$pic_mode" in @%:@ ((((
+  xdefault)
+    xc_lt_build_shared_with_pic='yes'
+    xc_lt_build_static_with_pic='no'
+    ;;
+  xyes)
+    xc_lt_build_shared_with_pic='yes'
+    xc_lt_build_static_with_pic='yes'
+    ;;
+  xno)
+    xc_lt_build_shared_with_pic='no'
+    xc_lt_build_static_with_pic='no'
+    ;;
+  *)
+    xc_lt_build_shared_with_pic='unknown'
+    xc_lt_build_static_with_pic='unknown'
+    AC_MSG_WARN([unexpected libtool pic_mode value: $pic_mode])
+    ;;
+esac
+AC_MSG_CHECKING([whether to build shared libraries with PIC])
+AC_MSG_RESULT([$xc_lt_build_shared_with_pic])
+AC_MSG_CHECKING([whether to build static libraries with PIC])
+AC_MSG_RESULT([$xc_lt_build_static_with_pic])
+dnl
+m4_define([$0],[])dnl
+])
+
+
+dnl _XC_CHECK_LT_BUILD_SINGLE_VERSION
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Checks wether a libtool shared or static library
+dnl is finally built exclusively without the other.
+dnl Results stored in following shell variables:
+dnl   xc_lt_build_shared_only
+dnl   xc_lt_build_static_only
+
+m4_define([_XC_CHECK_LT_BUILD_SINGLE_VERSION],
+[dnl
+#
+# Verify if libtool shared libraries will be built while static not built
+#
+
+AC_MSG_CHECKING([whether to build shared libraries only])
+if test "$xc_lt_build_shared" = 'yes' &&
+  test "$xc_lt_build_static" = 'no'; then
+  xc_lt_build_shared_only='yes'
+else
+  xc_lt_build_shared_only='no'
+fi
+AC_MSG_RESULT([$xc_lt_build_shared_only])
+
+#
+# Verify if libtool static libraries will be built while shared not built
+#
+
+AC_MSG_CHECKING([whether to build static libraries only])
+if test "$xc_lt_build_static" = 'yes' &&
+  test "$xc_lt_build_shared" = 'no'; then
+  xc_lt_build_static_only='yes'
+else
+  xc_lt_build_static_only='no'
+fi
+AC_MSG_RESULT([$xc_lt_build_static_only])
+dnl
+m4_define([$0],[])dnl
+])
+
+
+dnl _XC_LIBTOOL_POSTLUDE
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Performs several checks related with libtool that
+dnl can not be done unless libtool code has already
+dnl been executed. See individual check descriptions
+dnl for further info.
+
+m4_define([_XC_LIBTOOL_POSTLUDE],
+[dnl
+_XC_CHECK_LT_BUILD_LIBRARIES
+_XC_CHECK_LT_SHLIB_USE_VERSION_INFO
+_XC_CHECK_LT_SHLIB_USE_NO_UNDEFINED
+_XC_CHECK_LT_SHLIB_USE_MIMPURE_TEXT
+_XC_CHECK_LT_BUILD_WITH_PIC
+_XC_CHECK_LT_BUILD_SINGLE_VERSION
+dnl
+m4_define([$0],[])dnl
+])
+
+
+dnl XC_LIBTOOL
+dnl -------------------------------------------------
+dnl Public macro.
+dnl
+dnl This macro embeds libtool machinery into configure
+dnl script, regardless of libtool version, and performs
+dnl several additional checks whose results can be used
+dnl later on.
+dnl
+dnl Usage of this macro ensures that generated configure
+dnl script uses equivalent logic irrespective of autoconf
+dnl or libtool version being used to generate configure
+dnl script.
+dnl
+dnl Results stored in following shell variables:
+dnl   xc_lt_build_shared
+dnl   xc_lt_build_static
+dnl   xc_lt_shlib_use_version_info
+dnl   xc_lt_shlib_use_no_undefined
+dnl   xc_lt_shlib_use_mimpure_text
+dnl   xc_lt_build_shared_with_pic
+dnl   xc_lt_build_static_with_pic
+dnl   xc_lt_build_shared_only
+dnl   xc_lt_build_static_only
+
+AC_DEFUN([XC_LIBTOOL],
+[dnl
+AC_PREREQ([2.50])dnl
+dnl
+AC_BEFORE([$0],[LT_INIT])dnl
+AC_BEFORE([$0],[AC_PROG_LIBTOOL])dnl
+AC_BEFORE([$0],[AC_LIBTOOL_WIN32_DLL])dnl
+dnl
+AC_REQUIRE([XC_CHECK_PATH_SEPARATOR])dnl
+AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+dnl
+_XC_LIBTOOL_PREAMBLE
+_XC_LIBTOOL_BODY
+_XC_LIBTOOL_POSTLUDE
+dnl
+m4_ifdef([AC_LIBTOOL_WIN32_DLL],
+  [m4_undefine([AC_LIBTOOL_WIN32_DLL])])dnl
+m4_ifdef([AC_PROG_LIBTOOL],
+  [m4_undefine([AC_PROG_LIBTOOL])])dnl
+m4_ifdef([LT_INIT],
+  [m4_undefine([LT_INIT])])dnl
+dnl
+m4_define([$0],[])dnl
+])
+
diff --git a/deps/cares/m4/xc-translit.m4 b/deps/cares/m4/xc-translit.m4
new file mode 100644
index 0000000000000000000000000000000000000000..1918f1684084ebcacc0ecc009ed808ce05ff4cef
--- /dev/null
+++ b/deps/cares/m4/xc-translit.m4
@@ -0,0 +1,164 @@
+#---------------------------------------------------------------------------
+#
+# xc-translit.m4
+#
+# Copyright (c) 2011 Daniel Stenberg <daniel@haxx.se>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+#---------------------------------------------------------------------------
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 2
+
+
+dnl XC_SH_TR_SH (expression)
+dnl -------------------------------------------------
+dnl Shell execution time transliteration of 'expression'
+dnl argument, where all non-alfanumeric characters are
+dnl converted to the underscore '_' character.
+dnl Normal shell expansion and substitution takes place
+dnl for given 'expression' at shell execution time before
+dnl transliteration is applied to it.
+
+AC_DEFUN([XC_SH_TR_SH],
+[`echo "$1" | sed 's/[[^a-zA-Z0-9_]]/_/g'`])
+
+
+dnl XC_SH_TR_SH_EX (expression, [extra])
+dnl -------------------------------------------------
+dnl Like XC_SH_TR_SH but transliterating characters
+dnl given in 'extra' argument to lowercase 'p'. For
+dnl example [*+], [*], and [+] are valid 'extra' args.
+
+AC_DEFUN([XC_SH_TR_SH_EX],
+[ifelse([$2], [],
+  [XC_SH_TR_SH([$1])],
+  [`echo "$1" | sed 's/[[$2]]/p/g' | sed 's/[[^a-zA-Z0-9_]]/_/g'`])])
+
+
+dnl XC_M4_TR_SH (expression)
+dnl -------------------------------------------------
+dnl m4 execution time transliteration of 'expression'
+dnl argument, where all non-alfanumeric characters are
+dnl converted to the underscore '_' character.
+
+AC_DEFUN([XC_M4_TR_SH],
+[patsubst(XC_QPATSUBST(XC_QUOTE($1),
+                       [[^a-zA-Z0-9_]], [_]),
+          [\(_\(.*\)_\)], [\2])])
+
+
+dnl XC_M4_TR_SH_EX (expression, [extra])
+dnl -------------------------------------------------
+dnl Like XC_M4_TR_SH but transliterating characters
+dnl given in 'extra' argument to lowercase 'p'. For
+dnl example [*+], [*], and [+] are valid 'extra' args.
+
+AC_DEFUN([XC_M4_TR_SH_EX],
+[ifelse([$2], [],
+  [XC_M4_TR_SH([$1])],
+  [patsubst(XC_QPATSUBST(XC_QPATSUBST(XC_QUOTE($1),
+                                      [[$2]],
+                                      [p]),
+                         [[^a-zA-Z0-9_]], [_]),
+            [\(_\(.*\)_\)], [\2])])])
+
+
+dnl XC_SH_TR_CPP (expression)
+dnl -------------------------------------------------
+dnl Shell execution time transliteration of 'expression'
+dnl argument, where all non-alfanumeric characters are
+dnl converted to the underscore '_' character and alnum
+dnl characters are converted to uppercase.
+dnl Normal shell expansion and substitution takes place
+dnl for given 'expression' at shell execution time before
+dnl transliteration is applied to it.
+
+AC_DEFUN([XC_SH_TR_CPP],
+[`echo "$1" | dnl
+sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' | dnl
+sed 's/[[^A-Z0-9_]]/_/g'`])
+
+
+dnl XC_SH_TR_CPP_EX (expression, [extra])
+dnl -------------------------------------------------
+dnl Like XC_SH_TR_CPP but transliterating characters
+dnl given in 'extra' argument to uppercase 'P'. For
+dnl example [*+], [*], and [+] are valid 'extra' args.
+
+AC_DEFUN([XC_SH_TR_CPP_EX],
+[ifelse([$2], [],
+  [XC_SH_TR_CPP([$1])],
+  [`echo "$1" | dnl
+sed 's/[[$2]]/P/g' | dnl
+sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' | dnl
+sed 's/[[^A-Z0-9_]]/_/g'`])])
+
+
+dnl XC_M4_TR_CPP (expression)
+dnl -------------------------------------------------
+dnl m4 execution time transliteration of 'expression'
+dnl argument, where all non-alfanumeric characters are
+dnl converted to the underscore '_' character and alnum
+dnl characters are converted to uppercase.
+
+AC_DEFUN([XC_M4_TR_CPP],
+[patsubst(XC_QPATSUBST(XC_QTRANSLIT(XC_QUOTE($1),
+                                    [abcdefghijklmnopqrstuvwxyz],
+                                    [ABCDEFGHIJKLMNOPQRSTUVWXYZ]),
+                       [[^A-Z0-9_]], [_]),
+          [\(_\(.*\)_\)], [\2])])
+
+
+dnl XC_M4_TR_CPP_EX (expression, [extra])
+dnl -------------------------------------------------
+dnl Like XC_M4_TR_CPP but transliterating characters
+dnl given in 'extra' argument to uppercase 'P'. For
+dnl example [*+], [*], and [+] are valid 'extra' args.
+
+AC_DEFUN([XC_M4_TR_CPP_EX],
+[ifelse([$2], [],
+  [XC_M4_TR_CPP([$1])],
+  [patsubst(XC_QPATSUBST(XC_QTRANSLIT(XC_QPATSUBST(XC_QUOTE($1),
+                                                   [[$2]],
+                                                   [P]),
+                                      [abcdefghijklmnopqrstuvwxyz],
+                                      [ABCDEFGHIJKLMNOPQRSTUVWXYZ]),
+                         [[^A-Z0-9_]], [_]),
+            [\(_\(.*\)_\)], [\2])])])
+
+
+dnl XC_QUOTE (expression)
+dnl -------------------------------------------------
+dnl Expands to quoted result of 'expression' expansion.
+
+AC_DEFUN([XC_QUOTE],
+[[$@]])
+
+
+dnl XC_QPATSUBST (string, regexp[, repl])
+dnl -------------------------------------------------
+dnl Expands to quoted result of 'patsubst' expansion.
+
+AC_DEFUN([XC_QPATSUBST],
+[XC_QUOTE(patsubst([$1], [$2], [$3]))])
+
+
+dnl XC_QTRANSLIT (string, chars, repl)
+dnl -------------------------------------------------
+dnl Expands to quoted result of 'translit' expansion.
+
+AC_DEFUN([XC_QTRANSLIT],
+[XC_QUOTE(translit([$1], [$2], [$3]))])
+
diff --git a/deps/cares/m4/xc-val-flgs.m4 b/deps/cares/m4/xc-val-flgs.m4
new file mode 100644
index 0000000000000000000000000000000000000000..81d1eac9e3bee421aeb370c5ad3c4c2212518caa
--- /dev/null
+++ b/deps/cares/m4/xc-val-flgs.m4
@@ -0,0 +1,243 @@
+#---------------------------------------------------------------------------
+#
+# xc-val-flgs.m4
+#
+# Copyright (c) 2013 Daniel Stenberg <daniel@haxx.se>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+#---------------------------------------------------------------------------
+
+# serial 1
+
+
+dnl _XC_CHECK_VAR_LIBS
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_CHECK_VAR_LIBS], [
+  xc_bad_var_libs=no
+  for xc_word in $LIBS; do
+    case "$xc_word" in
+      -l* | --library=*)
+        :
+        ;;
+      *)
+        xc_bad_var_libs=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_libs = yes; then
+    AC_MSG_NOTICE([using LIBS: $LIBS])
+    AC_MSG_NOTICE([LIBS error: LIBS may only be used to specify libraries (-lname).])
+  fi
+])
+
+
+dnl _XC_CHECK_VAR_LDFLAGS
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_CHECK_VAR_LDFLAGS], [
+  xc_bad_var_ldflags=no
+  for xc_word in $LDFLAGS; do
+    case "$xc_word" in
+      -D*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -U*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -I*)
+        xc_bad_var_ldflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_ldflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_ldflags = yes; then
+    AC_MSG_NOTICE([using LDFLAGS: $LDFLAGS])
+    xc_bad_var_msg="LDFLAGS error: LDFLAGS may only be used to specify linker flags, not"
+    for xc_word in $LDFLAGS; do
+      case "$xc_word" in
+        -D*)
+          AC_MSG_NOTICE([$xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word])
+          ;;
+        -U*)
+          AC_MSG_NOTICE([$xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word])
+          ;;
+        -I*)
+          AC_MSG_NOTICE([$xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word])
+          ;;
+        -l* | --library=*)
+          AC_MSG_NOTICE([$xc_bad_var_msg libraries. Use LIBS for: $xc_word])
+          ;;
+      esac
+    done
+  fi
+])
+
+
+dnl _XC_CHECK_VAR_CPPFLAGS
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_CHECK_VAR_CPPFLAGS], [
+  xc_bad_var_cppflags=no
+  for xc_word in $CPPFLAGS; do
+    case "$xc_word" in
+      -rpath*)
+        xc_bad_var_cppflags=yes
+        ;;
+      -L* | --library-path=*)
+        xc_bad_var_cppflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_cppflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_cppflags = yes; then
+    AC_MSG_NOTICE([using CPPFLAGS: $CPPFLAGS])
+    xc_bad_var_msg="CPPFLAGS error: CPPFLAGS may only be used to specify C preprocessor flags, not"
+    for xc_word in $CPPFLAGS; do
+      case "$xc_word" in
+        -rpath*)
+          AC_MSG_NOTICE([$xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word])
+          ;;
+        -L* | --library-path=*)
+          AC_MSG_NOTICE([$xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word])
+          ;;
+        -l* | --library=*)
+          AC_MSG_NOTICE([$xc_bad_var_msg libraries. Use LIBS for: $xc_word])
+          ;;
+      esac
+    done
+  fi
+])
+
+
+dnl _XC_CHECK_VAR_CFLAGS
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_CHECK_VAR_CFLAGS], [
+  xc_bad_var_cflags=no
+  for xc_word in $CFLAGS; do
+    case "$xc_word" in
+      -D*)
+        xc_bad_var_cflags=yes
+        ;;
+      -U*)
+        xc_bad_var_cflags=yes
+        ;;
+      -I*)
+        xc_bad_var_cflags=yes
+        ;;
+      -rpath*)
+        xc_bad_var_cflags=yes
+        ;;
+      -L* | --library-path=*)
+        xc_bad_var_cflags=yes
+        ;;
+      -l* | --library=*)
+        xc_bad_var_cflags=yes
+        ;;
+    esac
+  done
+  if test $xc_bad_var_cflags = yes; then
+    AC_MSG_NOTICE([using CFLAGS: $CFLAGS])
+    xc_bad_var_msg="CFLAGS error: CFLAGS may only be used to specify C compiler flags, not"
+    for xc_word in $CFLAGS; do
+      case "$xc_word" in
+        -D*)
+          AC_MSG_NOTICE([$xc_bad_var_msg macro definitions. Use CPPFLAGS for: $xc_word])
+          ;;
+        -U*)
+          AC_MSG_NOTICE([$xc_bad_var_msg macro suppressions. Use CPPFLAGS for: $xc_word])
+          ;;
+        -I*)
+          AC_MSG_NOTICE([$xc_bad_var_msg include directories. Use CPPFLAGS for: $xc_word])
+          ;;
+        -rpath*)
+          AC_MSG_NOTICE([$xc_bad_var_msg library runtime directories. Use LDFLAGS for: $xc_word])
+          ;;
+        -L* | --library-path=*)
+          AC_MSG_NOTICE([$xc_bad_var_msg library directories. Use LDFLAGS for: $xc_word])
+          ;;
+        -l* | --library=*)
+          AC_MSG_NOTICE([$xc_bad_var_msg libraries. Use LIBS for: $xc_word])
+          ;;
+      esac
+    done
+  fi
+])
+
+
+dnl XC_CHECK_USER_FLAGS
+dnl -------------------------------------------------
+dnl Public macro.
+dnl
+dnl Performs some sanity checks for LIBS, LDFLAGS,
+dnl CPPFLAGS and CFLAGS values that the user might
+dnl have set. When checks fails, user is noticed
+dnl about errors detected in all of them and script
+dnl execution is halted.
+dnl
+dnl Intended to be used early in configure script.
+
+AC_DEFUN([XC_CHECK_USER_FLAGS], [
+  AC_PREREQ([2.50])dnl
+  AC_BEFORE([$0],[XC_CHECK_PROG_CC])dnl
+  dnl check order below matters
+  _XC_CHECK_VAR_LIBS
+  _XC_CHECK_VAR_LDFLAGS
+  _XC_CHECK_VAR_CPPFLAGS
+  _XC_CHECK_VAR_CFLAGS
+  if test $xc_bad_var_libs = yes ||
+     test $xc_bad_var_cflags = yes ||
+     test $xc_bad_var_ldflags = yes ||
+     test $xc_bad_var_cppflags = yes; then
+     AC_MSG_ERROR([Can not continue. Fix errors mentioned immediately above this line.])
+  fi
+])
+
+
+dnl XC_CHECK_BUILD_FLAGS
+dnl -------------------------------------------------
+dnl Public macro.
+dnl
+dnl Performs some sanity checks for LIBS, LDFLAGS,
+dnl CPPFLAGS and CFLAGS values that the configure
+dnl script might have set. When checks fails, user
+dnl is noticed about errors detected in all of them
+dnl but script continues execution.
+dnl
+dnl Intended to be used very late in configure script.
+
+AC_DEFUN([XC_CHECK_BUILD_FLAGS], [
+  AC_PREREQ([2.50])dnl
+  dnl check order below matters
+  _XC_CHECK_VAR_LIBS
+  _XC_CHECK_VAR_LDFLAGS
+  _XC_CHECK_VAR_CPPFLAGS
+  _XC_CHECK_VAR_CFLAGS
+  if test $xc_bad_var_libs = yes ||
+     test $xc_bad_var_cflags = yes ||
+     test $xc_bad_var_ldflags = yes ||
+     test $xc_bad_var_cppflags = yes; then
+     AC_MSG_WARN([Continuing even with errors mentioned immediately above this line.])
+  fi
+])
+
diff --git a/deps/cares/m4/zz40-xc-ovr.m4 b/deps/cares/m4/zz40-xc-ovr.m4
new file mode 100644
index 0000000000000000000000000000000000000000..0e3b1cba61e1cf339f5e441dbc4d9e3d9979253b
--- /dev/null
+++ b/deps/cares/m4/zz40-xc-ovr.m4
@@ -0,0 +1,668 @@
+#---------------------------------------------------------------------------
+#
+# zz40-xc-ovr.m4
+#
+# Copyright (c) 2013 Daniel Stenberg <daniel@haxx.se>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+#---------------------------------------------------------------------------
+
+# serial 1
+
+
+dnl The funny name of this file is intentional in order to make it
+dnl sort alphabetically after any libtool, autoconf or automake
+dnl provided .m4 macro file that might get copied into this same
+dnl subdirectory. This allows that macro (re)definitions from this
+dnl file may override those provided in other files.
+
+
+dnl Version macros
+dnl -------------------------------------------------
+dnl Public macros.
+
+m4_define([XC_CONFIGURE_PREAMBLE_VER_MAJOR],[1])dnl
+m4_define([XC_CONFIGURE_PREAMBLE_VER_MINOR],[0])dnl
+
+
+dnl _XC_CFG_PRE_PREAMBLE
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_CFG_PRE_PREAMBLE],
+[
+## -------------------------------- ##
+@%:@@%:@  [XC_CONFIGURE_PREAMBLE] ver: []dnl
+XC_CONFIGURE_PREAMBLE_VER_MAJOR.[]dnl
+XC_CONFIGURE_PREAMBLE_VER_MINOR  ##
+## -------------------------------- ##
+
+xc_configure_preamble_ver_major='XC_CONFIGURE_PREAMBLE_VER_MAJOR'
+xc_configure_preamble_ver_minor='XC_CONFIGURE_PREAMBLE_VER_MINOR'
+
+#
+# Set IFS to space, tab and newline.
+#
+
+xc_space=' '
+xc_tab='	'
+xc_newline='
+'
+IFS="$xc_space$xc_tab$xc_newline"
+
+#
+# Set internationalization behavior variables.
+#
+
+LANG='C'
+LC_ALL='C'
+LANGUAGE='C'
+export LANG
+export LC_ALL
+export LANGUAGE
+
+#
+# Some useful variables.
+#
+
+xc_msg_warn='configure: WARNING:'
+xc_msg_abrt='Can not continue.'
+xc_msg_err='configure: error:'
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_CMD_ECHO
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'echo' command
+dnl is available, otherwise aborts execution.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_CMD_ECHO],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_PREAMBLE])dnl
+#
+# Verify that 'echo' command is available, otherwise abort.
+#
+
+xc_tst_str='unknown'
+(`echo "$xc_tst_str" >/dev/null 2>&1`) && xc_tst_str='success'
+case "x$xc_tst_str" in @%:@ ((
+  xsuccess)
+    :
+    ;;
+  *)
+    # Try built-in echo, and fail.
+    echo "$xc_msg_err 'echo' command not found. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_CMD_TEST
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'test' command
+dnl is available, otherwise aborts execution.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_CMD_TEST],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_ECHO])dnl
+#
+# Verify that 'test' command is available, otherwise abort.
+#
+
+xc_tst_str='unknown'
+(`test -n "$xc_tst_str" >/dev/null 2>&1`) && xc_tst_str='success'
+case "x$xc_tst_str" in @%:@ ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'test' command not found. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_VAR_PATH
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'PATH' variable
+dnl is set, otherwise aborts execution.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_VAR_PATH],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_TEST])dnl
+#
+# Verify that 'PATH' variable is set, otherwise abort.
+#
+
+xc_tst_str='unknown'
+(`test -n "$PATH" >/dev/null 2>&1`) && xc_tst_str='success'
+case "x$xc_tst_str" in @%:@ ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'PATH' variable not set. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_CMD_EXPR
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'expr' command
+dnl is available, otherwise aborts execution.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_CMD_EXPR],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_VAR_PATH])dnl
+#
+# Verify that 'expr' command is available, otherwise abort.
+#
+
+xc_tst_str='unknown'
+xc_tst_str=`expr "$xc_tst_str" : '.*' 2>/dev/null`
+case "x$xc_tst_str" in @%:@ ((
+  x7)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'expr' command not found. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_UTIL_SED
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'sed' utility
+dnl is found within 'PATH', otherwise aborts execution.
+dnl
+dnl This 'sed' is required in order to allow configure
+dnl script bootstrapping itself. No fancy testing for a
+dnl proper 'sed' this early, that should be done later.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_UTIL_SED],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_VAR_PATH])dnl
+#
+# Verify that 'sed' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str='unknown'
+xc_tst_str=`echo "$xc_tst_str" 2>/dev/null \
+  | sed -e 's:unknown:success:' 2>/dev/null`
+case "x$xc_tst_str" in @%:@ ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'sed' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_UTIL_GREP
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'grep' utility
+dnl is found within 'PATH', otherwise aborts execution.
+dnl
+dnl This 'grep' is required in order to allow configure
+dnl script bootstrapping itself. No fancy testing for a
+dnl proper 'grep' this early, that should be done later.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_UTIL_GREP],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_VAR_PATH])dnl
+#
+# Verify that 'grep' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str='unknown'
+(`echo "$xc_tst_str" 2>/dev/null \
+  | grep 'unknown' >/dev/null 2>&1`) && xc_tst_str='success'
+case "x$xc_tst_str" in @%:@ ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'grep' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_UTIL_TR
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'tr' utility
+dnl is found within 'PATH', otherwise aborts execution.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_UTIL_TR],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_VAR_PATH])dnl
+#
+# Verify that 'tr' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str="${xc_tab}98s7u6c5c4e3s2s10"
+xc_tst_str=`echo "$xc_tst_str" 2>/dev/null \
+  | tr -d "0123456789$xc_tab" 2>/dev/null`
+case "x$xc_tst_str" in @%:@ ((
+  xsuccess)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'tr' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_UTIL_WC
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'wc' utility
+dnl is found within 'PATH', otherwise aborts execution.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_UTIL_WC],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_TR])dnl
+#
+# Verify that 'wc' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str='unknown unknown unknown unknown'
+xc_tst_str=`echo "$xc_tst_str" 2>/dev/null \
+  | wc -w 2>/dev/null | tr -d "$xc_space$xc_tab" 2>/dev/null`
+case "x$xc_tst_str" in @%:@ ((
+  x4)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'wc' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_BASIC_CHK_UTIL_CAT
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that verifies that 'cat' utility
+dnl is found within 'PATH', otherwise aborts execution.
+
+AC_DEFUN([_XC_CFG_PRE_BASIC_CHK_UTIL_CAT],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_WC])dnl
+#
+# Verify that 'cat' utility is found within 'PATH', otherwise abort.
+#
+
+xc_tst_str='unknown'
+xc_tst_str=`cat <<_EOT 2>/dev/null \
+  | wc -l 2>/dev/null | tr -d "$xc_space$xc_tab" 2>/dev/null
+unknown
+unknown
+unknown
+_EOT`
+case "x$xc_tst_str" in @%:@ ((
+  x3)
+    :
+    ;;
+  *)
+    echo "$xc_msg_err 'cat' utility not found in 'PATH'. $xc_msg_abrt" >&2
+    exit 1
+    ;;
+esac
+])
+
+
+dnl _XC_CFG_PRE_CHECK_PATH_SEPARATOR
+dnl -------------------------------------------------
+dnl Private macro.
+dnl
+dnl Emits shell code that computes the path separator
+dnl and stores the result in 'PATH_SEPARATOR', unless
+dnl the user has already set it with a non-empty value.
+dnl
+dnl This path separator is the symbol used to separate
+dnl or diferentiate paths inside the 'PATH' environment
+dnl variable.
+dnl
+dnl Non-empty user provided 'PATH_SEPARATOR' always
+dnl overrides the auto-detected one.
+
+AC_DEFUN([_XC_CFG_PRE_CHECK_PATH_SEPARATOR],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_EXPR])dnl
+#
+# Auto-detect and set 'PATH_SEPARATOR', unless it is already non-empty set.
+#
+
+# Directory count in 'PATH' when using a colon separator.
+xc_tst_dirs_col='x'
+xc_tst_prev_IFS=$IFS; IFS=':'
+for xc_tst_dir in $PATH; do
+  IFS=$xc_tst_prev_IFS
+  xc_tst_dirs_col="x$xc_tst_dirs_col"
+done
+IFS=$xc_tst_prev_IFS
+xc_tst_dirs_col=`expr "$xc_tst_dirs_col" : '.*'`
+
+# Directory count in 'PATH' when using a semicolon separator.
+xc_tst_dirs_sem='x'
+xc_tst_prev_IFS=$IFS; IFS=';'
+for xc_tst_dir in $PATH; do
+  IFS=$xc_tst_prev_IFS
+  xc_tst_dirs_sem="x$xc_tst_dirs_sem"
+done
+IFS=$xc_tst_prev_IFS
+xc_tst_dirs_sem=`expr "$xc_tst_dirs_sem" : '.*'`
+
+if test $xc_tst_dirs_sem -eq $xc_tst_dirs_col; then
+  # When both counting methods give the same result we do not want to
+  # chose one over the other, and consider auto-detection not possible.
+  if test -z "$PATH_SEPARATOR"; then
+    # Stop dead until user provides 'PATH_SEPARATOR' definition.
+    echo "$xc_msg_err 'PATH_SEPARATOR' variable not set. $xc_msg_abrt" >&2
+    exit 1
+  fi
+else
+  # Separator with the greater directory count is the auto-detected one.
+  if test $xc_tst_dirs_sem -gt $xc_tst_dirs_col; then
+    xc_tst_auto_separator=';'
+  else
+    xc_tst_auto_separator=':'
+  fi
+  if test -z "$PATH_SEPARATOR"; then
+    # Simply use the auto-detected one when not already set.
+    PATH_SEPARATOR=$xc_tst_auto_separator
+  elif test "x$PATH_SEPARATOR" != "x$xc_tst_auto_separator"; then
+    echo "$xc_msg_warn 'PATH_SEPARATOR' does not match auto-detected one." >&2
+  fi
+fi
+xc_PATH_SEPARATOR=$PATH_SEPARATOR
+AC_SUBST([PATH_SEPARATOR])dnl
+])
+
+
+dnl _XC_CFG_PRE_POSTLUDE
+dnl -------------------------------------------------
+dnl Private macro.
+
+AC_DEFUN([_XC_CFG_PRE_POSTLUDE],
+[dnl
+AC_REQUIRE([_XC_CFG_PRE_PREAMBLE])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_ECHO])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_TEST])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_VAR_PATH])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_EXPR])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_SED])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_GREP])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_TR])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_WC])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_CAT])dnl
+AC_REQUIRE([_XC_CFG_PRE_CHECK_PATH_SEPARATOR])dnl
+dnl
+xc_configure_preamble_result='yes'
+])
+
+
+dnl XC_CONFIGURE_PREAMBLE
+dnl -------------------------------------------------
+dnl Public macro.
+dnl
+dnl This macro emits shell code which does some
+dnl very basic checks related with the availability
+dnl of some commands and utilities needed to allow
+dnl configure script bootstrapping itself when using
+dnl these to figure out other settings. Also emits
+dnl code that performs PATH_SEPARATOR auto-detection
+dnl and sets its value unless it is already set with
+dnl a non-empty value.
+dnl
+dnl These basic checks are intended to be placed and
+dnl executed as early as possible in the resulting
+dnl configure script, and as such these must be pure
+dnl and portable shell code.
+dnl
+dnl This macro may be used directly, or indirectly
+dnl when using other macros that AC_REQUIRE it such
+dnl as XC_CHECK_PATH_SEPARATOR.
+dnl
+dnl Currently the mechanism used to ensure that this
+dnl macro expands early enough in generated configure
+dnl script is making it override autoconf and libtool
+dnl PATH_SEPARATOR check.
+
+AC_DEFUN([XC_CONFIGURE_PREAMBLE],
+[dnl
+AC_PREREQ([2.50])dnl
+dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_PREAMBLE])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_CMD_ECHO])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_CMD_TEST])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_VAR_PATH])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_CMD_EXPR])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_UTIL_SED])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_UTIL_GREP])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_UTIL_TR])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_UTIL_WC])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_BASIC_CHK_UTIL_CAT])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_CHECK_PATH_SEPARATOR])dnl
+AC_BEFORE([$0],[_XC_CFG_PRE_POSTLUDE])dnl
+dnl
+AC_BEFORE([$0],[AC_CHECK_TOOL])dnl
+AC_BEFORE([$0],[AC_CHECK_PROG])dnl
+AC_BEFORE([$0],[AC_CHECK_TOOLS])dnl
+AC_BEFORE([$0],[AC_CHECK_PROGS])dnl
+dnl
+AC_BEFORE([$0],[AC_PATH_TOOL])dnl
+AC_BEFORE([$0],[AC_PATH_PROG])dnl
+AC_BEFORE([$0],[AC_PATH_PROGS])dnl
+dnl
+AC_BEFORE([$0],[AC_PROG_SED])dnl
+AC_BEFORE([$0],[AC_PROG_GREP])dnl
+AC_BEFORE([$0],[AC_PROG_LN_S])dnl
+AC_BEFORE([$0],[AC_PROG_MKDIR_P])dnl
+AC_BEFORE([$0],[AC_PROG_INSTALL])dnl
+AC_BEFORE([$0],[AC_PROG_MAKE_SET])dnl
+AC_BEFORE([$0],[AC_PROG_LIBTOOL])dnl
+dnl
+AC_BEFORE([$0],[LT_INIT])dnl
+AC_BEFORE([$0],[AM_INIT_AUTOMAKE])dnl
+AC_BEFORE([$0],[AC_LIBTOOL_WIN32_DLL])dnl
+dnl
+AC_REQUIRE([_XC_CFG_PRE_PREAMBLE])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_ECHO])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_TEST])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_VAR_PATH])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_CMD_EXPR])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_SED])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_GREP])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_TR])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_WC])dnl
+AC_REQUIRE([_XC_CFG_PRE_BASIC_CHK_UTIL_CAT])dnl
+AC_REQUIRE([_XC_CFG_PRE_CHECK_PATH_SEPARATOR])dnl
+AC_REQUIRE([_XC_CFG_PRE_POSTLUDE])dnl
+dnl
+m4_pattern_forbid([^_*XC])dnl
+m4_define([$0],[])dnl
+])
+
+
+dnl Override autoconf and libtool PATH_SEPARATOR check
+dnl -------------------------------------------------
+dnl Macros overriding.
+dnl
+dnl This is done to ensure that the same check is
+dnl used across different autoconf versions and to
+dnl allow expansion of XC_CONFIGURE_PREAMBLE macro
+dnl early enough in the generated configure script.
+
+dnl
+dnl Override when using autoconf 2.53 and newer.
+dnl
+
+m4_ifdef([_AS_PATH_SEPARATOR_PREPARE],
+[dnl
+m4_undefine([_AS_PATH_SEPARATOR_PREPARE])dnl
+m4_defun([_AS_PATH_SEPARATOR_PREPARE],
+[dnl
+AC_REQUIRE([XC_CONFIGURE_PREAMBLE])dnl
+m4_define([$0],[])dnl
+])dnl
+])
+
+dnl
+dnl Override when using autoconf 2.50 to 2.52
+dnl
+
+m4_ifdef([_AC_INIT_PREPARE_FS_SEPARATORS],
+[dnl
+m4_undefine([_AC_INIT_PREPARE_FS_SEPARATORS])dnl
+m4_defun([_AC_INIT_PREPARE_FS_SEPARATORS],
+[dnl
+AC_REQUIRE([XC_CONFIGURE_PREAMBLE])dnl
+ac_path_separator=$PATH_SEPARATOR
+m4_define([$0],[])dnl
+])dnl
+])
+
+dnl
+dnl Override when using libtool 1.4.2
+dnl
+
+m4_ifdef([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR],
+[dnl
+m4_undefine([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR])dnl
+m4_defun([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR],
+[dnl
+AC_REQUIRE([XC_CONFIGURE_PREAMBLE])dnl
+lt_cv_sys_path_separator=$PATH_SEPARATOR
+m4_define([$0],[])dnl
+])dnl
+])
+
+
+dnl XC_CHECK_PATH_SEPARATOR
+dnl -------------------------------------------------
+dnl Public macro.
+dnl
+dnl Usage of this macro ensures that generated configure
+dnl script uses the same PATH_SEPARATOR check irrespective
+dnl of autoconf or libtool version being used to generate
+dnl configure script.
+dnl
+dnl Emits shell code that computes the path separator
+dnl and stores the result in 'PATH_SEPARATOR', unless
+dnl the user has already set it with a non-empty value.
+dnl
+dnl This path separator is the symbol used to separate
+dnl or diferentiate paths inside the 'PATH' environment
+dnl variable.
+dnl
+dnl Non-empty user provided 'PATH_SEPARATOR' always
+dnl overrides the auto-detected one.
+dnl
+dnl Strictly speaking the check is done in two steps. The
+dnl first, which does the actual check, takes place in
+dnl XC_CONFIGURE_PREAMBLE macro and happens very early in
+dnl generated configure script. The second one shows and
+dnl logs the result of the check into config.log at a later
+dnl configure stage. Placement of this second stage in
+dnl generated configure script will be done where first
+dnl direct or indirect usage of this macro happens.
+
+AC_DEFUN([XC_CHECK_PATH_SEPARATOR],
+[dnl
+AC_PREREQ([2.50])dnl
+dnl
+AC_BEFORE([$0],[AC_CHECK_TOOL])dnl
+AC_BEFORE([$0],[AC_CHECK_PROG])dnl
+AC_BEFORE([$0],[AC_CHECK_TOOLS])dnl
+AC_BEFORE([$0],[AC_CHECK_PROGS])dnl
+dnl
+AC_BEFORE([$0],[AC_PATH_TOOL])dnl
+AC_BEFORE([$0],[AC_PATH_PROG])dnl
+AC_BEFORE([$0],[AC_PATH_PROGS])dnl
+dnl
+AC_BEFORE([$0],[AC_PROG_SED])dnl
+AC_BEFORE([$0],[AC_PROG_GREP])dnl
+AC_BEFORE([$0],[AC_PROG_LN_S])dnl
+AC_BEFORE([$0],[AC_PROG_MKDIR_P])dnl
+AC_BEFORE([$0],[AC_PROG_INSTALL])dnl
+AC_BEFORE([$0],[AC_PROG_MAKE_SET])dnl
+AC_BEFORE([$0],[AC_PROG_LIBTOOL])dnl
+dnl
+AC_BEFORE([$0],[LT_INIT])dnl
+AC_BEFORE([$0],[AM_INIT_AUTOMAKE])dnl
+AC_BEFORE([$0],[AC_LIBTOOL_WIN32_DLL])dnl
+dnl
+AC_REQUIRE([XC_CONFIGURE_PREAMBLE])dnl
+dnl
+#
+# Check that 'XC_CONFIGURE_PREAMBLE' has already run.
+#
+
+if test -z "$xc_configure_preamble_result"; then
+  AC_MSG_ERROR([xc_configure_preamble_result not set (internal problem)])
+fi
+
+#
+# Check that 'PATH_SEPARATOR' has already been set.
+#
+
+if test -z "$xc_PATH_SEPARATOR"; then
+  AC_MSG_ERROR([xc_PATH_SEPARATOR not set (internal problem)])
+fi
+if test -z "$PATH_SEPARATOR"; then
+  AC_MSG_ERROR([PATH_SEPARATOR not set (internal or config.site problem)])
+fi
+AC_MSG_CHECKING([for path separator])
+AC_MSG_RESULT([$PATH_SEPARATOR])
+if test "x$PATH_SEPARATOR" != "x$xc_PATH_SEPARATOR"; then
+  AC_MSG_CHECKING([for initial path separator])
+  AC_MSG_RESULT([$xc_PATH_SEPARATOR])
+  AC_MSG_ERROR([path separator mismatch (internal or config.site problem)])
+fi
+dnl
+m4_pattern_forbid([^_*XC])dnl
+m4_define([$0],[])dnl
+])
+
diff --git a/deps/cares/maketgz b/deps/cares/maketgz
new file mode 100755
index 0000000000000000000000000000000000000000..ec1ecea540afb81dba169a9b136d96e5880a351b
--- /dev/null
+++ b/deps/cares/maketgz
@@ -0,0 +1,69 @@
+#!/usr/bin/env perl
+
+$version = $ARGV[0];
+
+if($version eq "") {
+    print "Enter version number!\n";
+    exit;
+}
+
+if(!-f "include/ares.h") {
+    print "run this script in the ares source root dir\n";
+    exit;
+}
+
+my ($major, $minor, $patch)=split(/\./, $version);
+
+$major += 0;
+$minor += 0;
+$patch += 0;
+
+open(VER, "<include/ares_version.h") ||
+    die "can't open include/ares_version.h";
+open(NEWV, ">include/ares_version.h.dist");
+while(<VER>) {
+    $_ =~ s/^\#define ARES_VERSION_MAJOR .*/\#define ARES_VERSION_MAJOR $major/;
+    $_ =~ s/^\#define ARES_VERSION_MINOR .*/\#define ARES_VERSION_MINOR $minor/;
+    $_ =~ s/^\#define ARES_VERSION_PATCH .*/\#define ARES_VERSION_PATCH $patch/;
+    $_ =~ s/^\#define ARES_VERSION_STR .*/\#define ARES_VERSION_STR \"$version\"/;
+
+    print NEWV $_;
+}
+close(VER);
+close(NEWV);
+print "include/ares_version.h.dist created\n";
+
+if(!-f "configure") {
+    print "running buildconf\n";
+    `./buildconf`;
+}
+print "adding $version in the configure.ac file\n";
+`sed -e 's/AC_INIT.*/AC_INIT([c-ares], [$version],/' < configure.ac > configure.ac.dist`;
+
+print "adding $version in the CMakeLists.txt file\n";
+`sed -e 's/SET.*CARES_VERSION.*/SET (CARES_VERSION "$version")/' < CMakeLists.txt > CMakeLists.txt.dist && rm -f CMakeLists.txt && mv CMakeLists.txt.dist CMakeLists.txt`;
+
+# now make a new configure script with this
+print "makes a new configure script\n";
+`autoconf configure.ac.dist >configure`;
+
+# now run this new configure to get a fine makefile
+print "running configure\n";
+`./configure`;
+
+print "produce CHANGES\n";
+`git log --pretty=fuller --no-color --date=short --decorate=full -1000 | ./git2changes.pl > CHANGES.dist`;
+
+# now make the actual tarball
+print "running make dist\n";
+`make dist VERSION=$version`;
+
+# remove temporay sourced man pages
+`make -s clean-sourced-manpages`;
+
+print "removing temporary configure.ac file\n";
+`rm configure.ac.dist`;
+print "removing temporary ares_version.h file\n";
+`rm include/ares_version.h.dist`;
+
+print "NOTE: now tag this release!\n";
diff --git a/deps/cares/msvc_ver.inc b/deps/cares/msvc_ver.inc
new file mode 100644
index 0000000000000000000000000000000000000000..595cbdf1dea7471c0b5be6fd4c017708cb36edf3
--- /dev/null
+++ b/deps/cares/msvc_ver.inc
@@ -0,0 +1,24 @@
+# -----------------------------------------------
+# Detect NMAKE version deducing old MSVC versions
+# -----------------------------------------------
+
+!IFNDEF _NMAKE_VER
+!  MESSAGE Macro _NMAKE_VER not defined.
+!  MESSAGE Use MSVC's NMAKE to process this makefile.
+!  ERROR   See previous message.
+!ENDIF
+
+!IF     "$(_NMAKE_VER)" == "6.00.8168.0"
+CC_VERS_NUM = 60
+!ELSEIF "$(_NMAKE_VER)" == "6.00.9782.0"
+CC_VERS_NUM = 60
+!ELSEIF "$(_NMAKE_VER)" == "7.00.8882"
+CC_VERS_NUM = 70
+!ELSEIF "$(_NMAKE_VER)" == "7.00.9466"
+CC_VERS_NUM = 70
+!ELSEIF "$(_NMAKE_VER)" == "7.00.9955"
+CC_VERS_NUM = 70
+!ELSE
+# Pick an arbitrary bigger number for all later versions
+CC_VERS_NUM = 199
+!ENDIF
diff --git a/deps/cares/src/CMakeLists.txt b/deps/cares/src/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6750c1780f62319d1c82b605d4ccb1986bb21527
--- /dev/null
+++ b/deps/cares/src/CMakeLists.txt
@@ -0,0 +1,2 @@
+ADD_SUBDIRECTORY (lib)
+ADD_SUBDIRECTORY (tools)
diff --git a/deps/cares/src/Makefile.am b/deps/cares/src/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..2e97e422f73adfae38d063773c63232acac12133
--- /dev/null
+++ b/deps/cares/src/Makefile.am
@@ -0,0 +1,2 @@
+EXTRA_DIST=CMakeLists.txt
+SUBDIRS=lib tools
diff --git a/deps/cares/src/Makefile.in b/deps/cares/src/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..999e965d9ea055597cb2f51dede1b60de7ce9fae
--- /dev/null
+++ b/deps/cares/src/Makefile.in
@@ -0,0 +1,666 @@
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2021 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_ac_append_to_file.m4 \
+	$(top_srcdir)/m4/ax_ac_print_to_file.m4 \
+	$(top_srcdir)/m4/ax_add_am_macro_static.m4 \
+	$(top_srcdir)/m4/ax_am_macros_static.m4 \
+	$(top_srcdir)/m4/ax_check_gnu_make.m4 \
+	$(top_srcdir)/m4/ax_code_coverage.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx_11.m4 \
+	$(top_srcdir)/m4/ax_file_escapes.m4 \
+	$(top_srcdir)/m4/ax_require_defined.m4 \
+	$(top_srcdir)/m4/cares-compilers.m4 \
+	$(top_srcdir)/m4/cares-confopts.m4 \
+	$(top_srcdir)/m4/cares-functions.m4 \
+	$(top_srcdir)/m4/cares-reentrant.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/xc-am-iface.m4 \
+	$(top_srcdir)/m4/xc-cc-check.m4 \
+	$(top_srcdir)/m4/xc-lt-iface.m4 \
+	$(top_srcdir)/m4/xc-translit.m4 \
+	$(top_srcdir)/m4/xc-val-flgs.m4 \
+	$(top_srcdir)/m4/zz40-xc-ovr.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/src/lib/ares_config.h \
+	$(top_builddir)/include/ares_build.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+SOURCES =
+DIST_SOURCES =
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+	ctags-recursive dvi-recursive html-recursive info-recursive \
+	install-data-recursive install-dvi-recursive \
+	install-exec-recursive install-html-recursive \
+	install-info-recursive install-pdf-recursive \
+	install-ps-recursive install-recursive installcheck-recursive \
+	installdirs-recursive pdf-recursive ps-recursive \
+	tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
+  distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+  $(RECURSIVE_TARGETS) \
+  $(RECURSIVE_CLEAN_TARGETS) \
+  $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+	distdir distdir-am
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+DIST_SUBDIRS = $(SUBDIRS)
+am__DIST_COMMON = $(srcdir)/Makefile.in
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+am__relativize = \
+  dir0=`pwd`; \
+  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+  sed_rest='s,^[^/]*/*,,'; \
+  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+  sed_butlast='s,/*[^/]*$$,,'; \
+  while test -n "$$dir1"; do \
+    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+    if test "$$first" != "."; then \
+      if test "$$first" = ".."; then \
+        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+      else \
+        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+        if test "$$first2" = "$$first"; then \
+          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+        else \
+          dir2="../$$dir2"; \
+        fi; \
+        dir0="$$dir0"/"$$first"; \
+      fi; \
+    fi; \
+    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+  done; \
+  reldir="$$dir2"
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BUILD_SUBDIRS = @BUILD_SUBDIRS@
+CARES_CFLAG_EXTRAS = @CARES_CFLAG_EXTRAS@
+CARES_PRIVATE_LIBS = @CARES_PRIVATE_LIBS@
+CARES_RANDOM_FILE = @CARES_RANDOM_FILE@
+CARES_VERSION_INFO = @CARES_VERSION_INFO@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CFLAG_CARES_SYMBOL_HIDING = @CFLAG_CARES_SYMBOL_HIDING@
+CODE_COVERAGE_CFLAGS = @CODE_COVERAGE_CFLAGS@
+CODE_COVERAGE_CPPFLAGS = @CODE_COVERAGE_CPPFLAGS@
+CODE_COVERAGE_CXXFLAGS = @CODE_COVERAGE_CXXFLAGS@
+CODE_COVERAGE_ENABLED = @CODE_COVERAGE_ENABLED@
+CODE_COVERAGE_LIBS = @CODE_COVERAGE_LIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPPFLAG_CARES_STATICLIB = @CPPFLAG_CARES_STATICLIB@
+CSCOPE = @CSCOPE@
+CTAGS = @CTAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ETAGS = @ETAGS@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GCOV = @GCOV@
+GENHTML = @GENHTML@
+GREP = @GREP@
+HAVE_CXX11 = @HAVE_CXX11@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LCOV = @LCOV@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+ifGNUmake = @ifGNUmake@
+ifnGNUmake = @ifnGNUmake@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+EXTRA_DIST = CMakeLists.txt
+SUBDIRS = lib tools
+all: all-recursive
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign src/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+#     (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+	@fail=; \
+	if $(am__make_keepgoing); then \
+	  failcom='fail=yes'; \
+	else \
+	  failcom='exit 1'; \
+	fi; \
+	dot_seen=no; \
+	target=`echo $@ | sed s/-recursive//`; \
+	case "$@" in \
+	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+	  *) list='$(SUBDIRS)' ;; \
+	esac; \
+	for subdir in $$list; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    dot_seen=yes; \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done; \
+	if test "$$dot_seen" = "no"; then \
+	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+	fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+	  include_option=--etags-include; \
+	  empty_fix=.; \
+	else \
+	  include_option=--include; \
+	  empty_fix=; \
+	fi; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test ! -f $$subdir/TAGS || \
+	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+	  fi; \
+	done; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    $(am__make_dryrun) \
+	      || test -d "$(distdir)/$$subdir" \
+	      || $(MKDIR_P) "$(distdir)/$$subdir" \
+	      || exit 1; \
+	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+	    $(am__relativize); \
+	    new_distdir=$$reldir; \
+	    dir1=$$subdir; dir2="$(top_distdir)"; \
+	    $(am__relativize); \
+	    new_top_distdir=$$reldir; \
+	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+	    ($(am__cd) $$subdir && \
+	      $(MAKE) $(AM_MAKEFLAGS) \
+	        top_distdir="$$new_top_distdir" \
+	        distdir="$$new_distdir" \
+		am__remove_distdir=: \
+		am__skip_length_check=: \
+		am__skip_mode_fix=: \
+	        distdir) \
+	      || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-recursive
+all-am: Makefile
+installdirs: installdirs-recursive
+installdirs-am:
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-recursive
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: $(am__recursive_targets) install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \
+	check-am clean clean-generic clean-libtool cscopelist-am ctags \
+	ctags-am distclean distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-pdf install-pdf-am install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	installdirs-am maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
+	ps ps-am tags tags-am uninstall uninstall-am
+
+.PRECIOUS: Makefile
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/deps/cares/src/lib/CMakeLists.txt b/deps/cares/src/lib/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d37be21ace7979268bc7a71bb03460ac6dc5c39
--- /dev/null
+++ b/deps/cares/src/lib/CMakeLists.txt
@@ -0,0 +1,115 @@
+
+# Transform Makefile.inc
+transform_makefile_inc("Makefile.inc" "${PROJECT_BINARY_DIR}/src/lib/Makefile.inc.cmake")
+include(${PROJECT_BINARY_DIR}/src/lib/Makefile.inc.cmake)
+
+# Write ares_config.h configuration file.  This is used only for the build.
+CONFIGURE_FILE (ares_config.h.cmake ${PROJECT_BINARY_DIR}/ares_config.h)
+
+# Build the dynamic/shared library
+IF (CARES_SHARED)
+	ADD_LIBRARY (${PROJECT_NAME} SHARED ${CSOURCES})
+
+	# Convert CARES_LIB_VERSIONINFO libtool version format into VERSION and SOVERSION
+	# Convert from ":" separated into CMake list format using ";"
+	STRING (REPLACE ":" ";" CARES_LIB_VERSIONINFO ${CARES_LIB_VERSIONINFO})
+	LIST (GET CARES_LIB_VERSIONINFO 0 CARES_LIB_VERSION_CURRENT)
+	LIST (GET CARES_LIB_VERSIONINFO 1 CARES_LIB_VERSION_REVISION)
+	LIST (GET CARES_LIB_VERSIONINFO 2 CARES_LIB_VERSION_AGE)
+	MATH (EXPR CARES_LIB_VERSION_MAJOR "${CARES_LIB_VERSION_CURRENT} - ${CARES_LIB_VERSION_AGE}")
+	SET  (CARES_LIB_VERSION_MINOR "${CARES_LIB_VERSION_AGE}")
+	SET  (CARES_LIB_VERSION_RELEASE "${CARES_LIB_VERSION_REVISION}")
+
+	SET_TARGET_PROPERTIES (${PROJECT_NAME} PROPERTIES
+		EXPORT_NAME                  cares
+		OUTPUT_NAME                  cares
+		COMPILE_PDB_NAME             cares
+		COMPILE_PDB_OUTPUT_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+		SOVERSION                    ${CARES_LIB_VERSION_MAJOR}
+		VERSION                      "${CARES_LIB_VERSION_MAJOR}.${CARES_LIB_VERSION_MINOR}.${CARES_LIB_VERSION_RELEASE}"
+	)
+
+	TARGET_INCLUDE_DIRECTORIES (${PROJECT_NAME}
+		PUBLIC "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>"
+		       "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
+		       "$<BUILD_INTERFACE:${CARES_TOPLEVEL_DIR}/include>"
+		       "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+		PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}"
+	)
+
+	TARGET_COMPILE_DEFINITIONS (${PROJECT_NAME} PRIVATE HAVE_CONFIG_H=1 CARES_BUILDING_LIBRARY)
+
+	TARGET_LINK_LIBRARIES (${PROJECT_NAME} PUBLIC ${CARES_DEPENDENT_LIBS})
+
+	IF (CARES_INSTALL)
+		INSTALL (TARGETS ${PROJECT_NAME}
+			EXPORT ${PROJECT_NAME}-targets
+			COMPONENT Library
+			${TARGETS_INST_DEST}
+		)
+		INSTALL(FILES ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/cares.pdb
+			DESTINATION ${CMAKE_INSTALL_BINDIR}
+			COMPONENT Library
+			OPTIONAL
+		)
+	ENDIF ()
+	SET (STATIC_SUFFIX "_static")
+
+	# For chain building: add alias targets that look like import libs that would be returned by find_package(c-ares).
+	ADD_LIBRARY (${PROJECT_NAME}::cares_shared ALIAS ${PROJECT_NAME})
+	ADD_LIBRARY (${PROJECT_NAME}::cares        ALIAS ${PROJECT_NAME})
+ENDIF ()
+
+# Build the static library
+IF (CARES_STATIC)
+	SET (LIBNAME ${PROJECT_NAME}${STATIC_SUFFIX})
+
+	ADD_LIBRARY (${LIBNAME} STATIC ${CSOURCES})
+
+	SET_TARGET_PROPERTIES (${LIBNAME} PROPERTIES
+		EXPORT_NAME                  cares${STATIC_SUFFIX}
+		OUTPUT_NAME                  cares${STATIC_SUFFIX}
+		COMPILE_PDB_NAME             cares${STATIC_SUFFIX}
+		COMPILE_PDB_OUTPUT_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+	)
+
+	IF (CARES_STATIC_PIC)
+		SET_TARGET_PROPERTIES (${LIBNAME} PROPERTIES POSITION_INDEPENDENT_CODE True)
+	ENDIF ()
+
+	TARGET_INCLUDE_DIRECTORIES (${LIBNAME}
+		PUBLIC "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>"
+		       "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
+		       "$<BUILD_INTERFACE:${CARES_TOPLEVEL_DIR}/include>"
+		       "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+		PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}"
+	)
+
+	TARGET_COMPILE_DEFINITIONS (${LIBNAME}
+		PUBLIC  CARES_STATICLIB
+		PRIVATE HAVE_CONFIG_H=1
+	)
+
+	TARGET_LINK_LIBRARIES (${LIBNAME} PUBLIC ${CARES_DEPENDENT_LIBS})
+	IF (CARES_INSTALL)
+		INSTALL (TARGETS ${LIBNAME} EXPORT ${PROJECT_NAME}-targets COMPONENT Devel
+			${TARGETS_INST_DEST}
+		)
+		INSTALL(FILES ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/cares${STATIC_SUFFIX}.pdb
+			DESTINATION ${CMAKE_INSTALL_BINDIR}
+			COMPONENT Library
+			OPTIONAL
+		)
+	ENDIF ()
+
+	# For chain building: add alias targets that look like import libs that would be returned by find_package(c-ares).
+	ADD_LIBRARY (${PROJECT_NAME}::cares_static ALIAS ${LIBNAME})
+	IF (NOT TARGET ${PROJECT_NAME}::cares)
+		# Only use static for the generic alias if shared lib wasn't built.
+		ADD_LIBRARY (${PROJECT_NAME}::cares ALIAS ${LIBNAME})
+	ENDIF ()
+ENDIF ()
+
+
+
+
diff --git a/deps/cares/src/lib/Makefile.am b/deps/cares/src/lib/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..4813621ce239927cfc58eeaa0edf6196edff043c
--- /dev/null
+++ b/deps/cares/src/lib/Makefile.am
@@ -0,0 +1,74 @@
+AUTOMAKE_OPTIONS = foreign subdir-objects nostdinc 1.9.6
+ACLOCAL_AMFLAGS = -I m4 --install
+
+# Specify our include paths here, and do it relative to $(top_srcdir) and
+# $(top_builddir), to ensure that these paths which belong to the library
+# being currently built and tested are searched before the library which
+# might possibly already be installed in the system.
+
+AM_CPPFLAGS = -I$(top_builddir)/include \
+              -I$(top_builddir)/src/lib \
+              -I$(top_srcdir)/include \
+              -I$(top_srcdir)/src/lib
+
+lib_LTLIBRARIES = libcares.la
+
+man_MANS = $(MANPAGES)
+
+# adig and ahost are just sample programs and thus not mentioned with the
+# regular sources and headers
+EXTRA_DIST = Makefile.inc config-win32.h CMakeLists.txt \
+  ares_config.h.in ares_config.h.cmake cares.rc \
+  $(CSOURCES) $(HHEADERS) config-dos.h
+
+DISTCLEANFILES = ares_config.h
+
+DIST_SUBDIRS =
+
+AM_LDFLAGS =
+
+libcares_la_LDFLAGS_EXTRA =
+
+if CARES_LT_SHLIB_USE_VERSION_INFO
+libcares_la_LDFLAGS_EXTRA += -version-info @CARES_VERSION_INFO@
+endif
+
+if CARES_LT_SHLIB_USE_NO_UNDEFINED
+libcares_la_LDFLAGS_EXTRA += -no-undefined
+endif
+
+if CARES_LT_SHLIB_USE_MIMPURE_TEXT
+libcares_la_LDFLAGS_EXTRA += -mimpure-text
+endif
+
+libcares_la_LDFLAGS = $(AM_LDFLAGS) $(libcares_la_LDFLAGS_EXTRA)
+
+# Add -Werror if defined
+CFLAGS += @CARES_CFLAG_EXTRAS@
+
+if USE_CPPFLAG_CARES_STATICLIB
+AM_CPPFLAGS += $(CPPFLAG_CARES_STATICLIB)
+endif
+
+libcares_la_CFLAGS_EXTRA =
+
+libcares_la_CPPFLAGS_EXTRA = -DCARES_BUILDING_LIBRARY
+
+if DOING_CARES_SYMBOL_HIDING
+libcares_la_CFLAGS_EXTRA += $(CFLAG_CARES_SYMBOL_HIDING)
+libcares_la_CPPFLAGS_EXTRA += -DCARES_SYMBOL_HIDING
+endif
+
+include $(top_srcdir)/aminclude_static.am
+libcares_la_LIBS = $(CODE_COVERAGE_LIBS)
+libcares_la_CFLAGS_EXTRA += $(CODE_COVERAGE_CFLAGS)
+libcares_la_CPPFLAGS_EXTRA += $(CODE_COVERAGE_CPPFLAGS)
+
+libcares_la_CFLAGS = $(AM_CFLAGS) $(libcares_la_CFLAGS_EXTRA)
+
+libcares_la_CPPFLAGS = $(AM_CPPFLAGS) $(libcares_la_CPPFLAGS_EXTRA)
+
+# Makefile.inc provides the CSOURCES and HHEADERS defines
+include Makefile.inc
+
+libcares_la_SOURCES = $(CSOURCES) $(HHEADERS)
diff --git a/deps/cares/src/lib/Makefile.in b/deps/cares/src/lib/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..6b42bb85bfc4224465befa868f9606e20923104d
--- /dev/null
+++ b/deps/cares/src/lib/Makefile.in
@@ -0,0 +1,1764 @@
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2021 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+# aminclude_static.am generated automatically by Autoconf
+# from AX_AM_MACROS_STATIC on Wed Oct 27 08:01:08 CEST 2021
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@CARES_LT_SHLIB_USE_VERSION_INFO_TRUE@am__append_1 = -version-info @CARES_VERSION_INFO@
+@CARES_LT_SHLIB_USE_NO_UNDEFINED_TRUE@am__append_2 = -no-undefined
+@CARES_LT_SHLIB_USE_MIMPURE_TEXT_TRUE@am__append_3 = -mimpure-text
+@USE_CPPFLAG_CARES_STATICLIB_TRUE@am__append_4 = $(CPPFLAG_CARES_STATICLIB)
+@DOING_CARES_SYMBOL_HIDING_TRUE@am__append_5 = $(CFLAG_CARES_SYMBOL_HIDING)
+@DOING_CARES_SYMBOL_HIDING_TRUE@am__append_6 = -DCARES_SYMBOL_HIDING
+subdir = src/lib
+SUBDIRS =
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_ac_append_to_file.m4 \
+	$(top_srcdir)/m4/ax_ac_print_to_file.m4 \
+	$(top_srcdir)/m4/ax_add_am_macro_static.m4 \
+	$(top_srcdir)/m4/ax_am_macros_static.m4 \
+	$(top_srcdir)/m4/ax_check_gnu_make.m4 \
+	$(top_srcdir)/m4/ax_code_coverage.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx_11.m4 \
+	$(top_srcdir)/m4/ax_file_escapes.m4 \
+	$(top_srcdir)/m4/ax_require_defined.m4 \
+	$(top_srcdir)/m4/cares-compilers.m4 \
+	$(top_srcdir)/m4/cares-confopts.m4 \
+	$(top_srcdir)/m4/cares-functions.m4 \
+	$(top_srcdir)/m4/cares-reentrant.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/xc-am-iface.m4 \
+	$(top_srcdir)/m4/xc-cc-check.m4 \
+	$(top_srcdir)/m4/xc-lt-iface.m4 \
+	$(top_srcdir)/m4/xc-translit.m4 \
+	$(top_srcdir)/m4/xc-val-flgs.m4 \
+	$(top_srcdir)/m4/zz40-xc-ovr.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = ares_config.h $(top_builddir)/include/ares_build.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(libdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+libcares_la_LIBADD =
+am__objects_1 = libcares_la-ares__addrinfo2hostent.lo \
+	libcares_la-ares__addrinfo_localhost.lo \
+	libcares_la-ares__close_sockets.lo \
+	libcares_la-ares__get_hostent.lo \
+	libcares_la-ares__parse_into_addrinfo.lo \
+	libcares_la-ares__readaddrinfo.lo \
+	libcares_la-ares__sortaddrinfo.lo \
+	libcares_la-ares__read_line.lo libcares_la-ares__timeval.lo \
+	libcares_la-ares_android.lo libcares_la-ares_cancel.lo \
+	libcares_la-ares_data.lo libcares_la-ares_destroy.lo \
+	libcares_la-ares_expand_name.lo \
+	libcares_la-ares_expand_string.lo libcares_la-ares_fds.lo \
+	libcares_la-ares_free_hostent.lo \
+	libcares_la-ares_free_string.lo \
+	libcares_la-ares_freeaddrinfo.lo \
+	libcares_la-ares_getaddrinfo.lo libcares_la-ares_getenv.lo \
+	libcares_la-ares_gethostbyaddr.lo \
+	libcares_la-ares_gethostbyname.lo \
+	libcares_la-ares_getnameinfo.lo libcares_la-ares_getsock.lo \
+	libcares_la-ares_init.lo libcares_la-ares_library_init.lo \
+	libcares_la-ares_llist.lo libcares_la-ares_mkquery.lo \
+	libcares_la-ares_create_query.lo libcares_la-ares_nowarn.lo \
+	libcares_la-ares_options.lo libcares_la-ares_parse_a_reply.lo \
+	libcares_la-ares_parse_aaaa_reply.lo \
+	libcares_la-ares_parse_caa_reply.lo \
+	libcares_la-ares_parse_mx_reply.lo \
+	libcares_la-ares_parse_naptr_reply.lo \
+	libcares_la-ares_parse_ns_reply.lo \
+	libcares_la-ares_parse_ptr_reply.lo \
+	libcares_la-ares_parse_soa_reply.lo \
+	libcares_la-ares_parse_srv_reply.lo \
+	libcares_la-ares_parse_txt_reply.lo \
+	libcares_la-ares_parse_uri_reply.lo \
+	libcares_la-ares_platform.lo libcares_la-ares_process.lo \
+	libcares_la-ares_query.lo libcares_la-ares_search.lo \
+	libcares_la-ares_send.lo libcares_la-ares_strcasecmp.lo \
+	libcares_la-ares_strdup.lo libcares_la-ares_strerror.lo \
+	libcares_la-ares_strsplit.lo libcares_la-ares_timeout.lo \
+	libcares_la-ares_version.lo libcares_la-ares_writev.lo \
+	libcares_la-bitncmp.lo libcares_la-inet_net_pton.lo \
+	libcares_la-inet_ntop.lo libcares_la-windows_port.lo
+am__objects_2 =
+am_libcares_la_OBJECTS = $(am__objects_1) $(am__objects_2)
+libcares_la_OBJECTS = $(am_libcares_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+libcares_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(libcares_la_CFLAGS) \
+	$(CFLAGS) $(libcares_la_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = 
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade =  \
+	./$(DEPDIR)/libcares_la-ares__addrinfo2hostent.Plo \
+	./$(DEPDIR)/libcares_la-ares__addrinfo_localhost.Plo \
+	./$(DEPDIR)/libcares_la-ares__close_sockets.Plo \
+	./$(DEPDIR)/libcares_la-ares__get_hostent.Plo \
+	./$(DEPDIR)/libcares_la-ares__parse_into_addrinfo.Plo \
+	./$(DEPDIR)/libcares_la-ares__read_line.Plo \
+	./$(DEPDIR)/libcares_la-ares__readaddrinfo.Plo \
+	./$(DEPDIR)/libcares_la-ares__sortaddrinfo.Plo \
+	./$(DEPDIR)/libcares_la-ares__timeval.Plo \
+	./$(DEPDIR)/libcares_la-ares_android.Plo \
+	./$(DEPDIR)/libcares_la-ares_cancel.Plo \
+	./$(DEPDIR)/libcares_la-ares_create_query.Plo \
+	./$(DEPDIR)/libcares_la-ares_data.Plo \
+	./$(DEPDIR)/libcares_la-ares_destroy.Plo \
+	./$(DEPDIR)/libcares_la-ares_expand_name.Plo \
+	./$(DEPDIR)/libcares_la-ares_expand_string.Plo \
+	./$(DEPDIR)/libcares_la-ares_fds.Plo \
+	./$(DEPDIR)/libcares_la-ares_free_hostent.Plo \
+	./$(DEPDIR)/libcares_la-ares_free_string.Plo \
+	./$(DEPDIR)/libcares_la-ares_freeaddrinfo.Plo \
+	./$(DEPDIR)/libcares_la-ares_getaddrinfo.Plo \
+	./$(DEPDIR)/libcares_la-ares_getenv.Plo \
+	./$(DEPDIR)/libcares_la-ares_gethostbyaddr.Plo \
+	./$(DEPDIR)/libcares_la-ares_gethostbyname.Plo \
+	./$(DEPDIR)/libcares_la-ares_getnameinfo.Plo \
+	./$(DEPDIR)/libcares_la-ares_getsock.Plo \
+	./$(DEPDIR)/libcares_la-ares_init.Plo \
+	./$(DEPDIR)/libcares_la-ares_library_init.Plo \
+	./$(DEPDIR)/libcares_la-ares_llist.Plo \
+	./$(DEPDIR)/libcares_la-ares_mkquery.Plo \
+	./$(DEPDIR)/libcares_la-ares_nowarn.Plo \
+	./$(DEPDIR)/libcares_la-ares_options.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_a_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_aaaa_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_caa_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_mx_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_naptr_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_ns_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_ptr_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_soa_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_srv_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_txt_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_parse_uri_reply.Plo \
+	./$(DEPDIR)/libcares_la-ares_platform.Plo \
+	./$(DEPDIR)/libcares_la-ares_process.Plo \
+	./$(DEPDIR)/libcares_la-ares_query.Plo \
+	./$(DEPDIR)/libcares_la-ares_search.Plo \
+	./$(DEPDIR)/libcares_la-ares_send.Plo \
+	./$(DEPDIR)/libcares_la-ares_strcasecmp.Plo \
+	./$(DEPDIR)/libcares_la-ares_strdup.Plo \
+	./$(DEPDIR)/libcares_la-ares_strerror.Plo \
+	./$(DEPDIR)/libcares_la-ares_strsplit.Plo \
+	./$(DEPDIR)/libcares_la-ares_timeout.Plo \
+	./$(DEPDIR)/libcares_la-ares_version.Plo \
+	./$(DEPDIR)/libcares_la-ares_writev.Plo \
+	./$(DEPDIR)/libcares_la-bitncmp.Plo \
+	./$(DEPDIR)/libcares_la-inet_net_pton.Plo \
+	./$(DEPDIR)/libcares_la-inet_ntop.Plo \
+	./$(DEPDIR)/libcares_la-windows_port.Plo
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 = 
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 = 
+SOURCES = $(libcares_la_SOURCES)
+DIST_SOURCES = $(libcares_la_SOURCES)
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+	ctags-recursive dvi-recursive html-recursive info-recursive \
+	install-data-recursive install-dvi-recursive \
+	install-exec-recursive install-html-recursive \
+	install-info-recursive install-pdf-recursive \
+	install-ps-recursive install-recursive installcheck-recursive \
+	installdirs-recursive pdf-recursive ps-recursive \
+	tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
+  distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+  $(RECURSIVE_TARGETS) \
+  $(RECURSIVE_CLEAN_TARGETS) \
+  $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+	distdir distdir-am
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) \
+	ares_config.h.in
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.inc \
+	$(srcdir)/ares_config.h.in $(top_srcdir)/aminclude_static.am \
+	$(top_srcdir)/depcomp
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+am__relativize = \
+  dir0=`pwd`; \
+  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+  sed_rest='s,^[^/]*/*,,'; \
+  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+  sed_butlast='s,/*[^/]*$$,,'; \
+  while test -n "$$dir1"; do \
+    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+    if test "$$first" != "."; then \
+      if test "$$first" = ".."; then \
+        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+      else \
+        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+        if test "$$first2" = "$$first"; then \
+          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+        else \
+          dir2="../$$dir2"; \
+        fi; \
+        dir0="$$dir0"/"$$first"; \
+      fi; \
+    fi; \
+    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+  done; \
+  reldir="$$dir2"
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BUILD_SUBDIRS = @BUILD_SUBDIRS@
+CARES_CFLAG_EXTRAS = @CARES_CFLAG_EXTRAS@
+CARES_PRIVATE_LIBS = @CARES_PRIVATE_LIBS@
+CARES_RANDOM_FILE = @CARES_RANDOM_FILE@
+CARES_VERSION_INFO = @CARES_VERSION_INFO@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+
+# Add -Werror if defined
+CFLAGS = @CFLAGS@ @CARES_CFLAG_EXTRAS@
+CFLAG_CARES_SYMBOL_HIDING = @CFLAG_CARES_SYMBOL_HIDING@
+CODE_COVERAGE_CFLAGS = @CODE_COVERAGE_CFLAGS@
+CODE_COVERAGE_CPPFLAGS = @CODE_COVERAGE_CPPFLAGS@
+CODE_COVERAGE_CXXFLAGS = @CODE_COVERAGE_CXXFLAGS@
+CODE_COVERAGE_ENABLED = @CODE_COVERAGE_ENABLED@
+CODE_COVERAGE_LIBS = @CODE_COVERAGE_LIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPPFLAG_CARES_STATICLIB = @CPPFLAG_CARES_STATICLIB@
+CSCOPE = @CSCOPE@
+CTAGS = @CTAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ETAGS = @ETAGS@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GCOV = @GCOV@
+GENHTML = @GENHTML@
+GREP = @GREP@
+HAVE_CXX11 = @HAVE_CXX11@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LCOV = @LCOV@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+ifGNUmake = @ifGNUmake@
+ifnGNUmake = @ifnGNUmake@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AUTOMAKE_OPTIONS = foreign subdir-objects nostdinc 1.9.6
+ACLOCAL_AMFLAGS = -I m4 --install
+
+# Specify our include paths here, and do it relative to $(top_srcdir) and
+# $(top_builddir), to ensure that these paths which belong to the library
+# being currently built and tested are searched before the library which
+# might possibly already be installed in the system.
+AM_CPPFLAGS = -I$(top_builddir)/include -I$(top_builddir)/src/lib \
+	-I$(top_srcdir)/include -I$(top_srcdir)/src/lib \
+	$(am__append_4)
+lib_LTLIBRARIES = libcares.la
+man_MANS = $(MANPAGES)
+
+# adig and ahost are just sample programs and thus not mentioned with the
+# regular sources and headers
+EXTRA_DIST = Makefile.inc config-win32.h CMakeLists.txt \
+  ares_config.h.in ares_config.h.cmake cares.rc \
+  $(CSOURCES) $(HHEADERS) config-dos.h
+
+DISTCLEANFILES = ares_config.h
+DIST_SUBDIRS = 
+AM_LDFLAGS = 
+libcares_la_LDFLAGS_EXTRA = $(am__append_1) $(am__append_2) \
+	$(am__append_3)
+libcares_la_LDFLAGS = $(AM_LDFLAGS) $(libcares_la_LDFLAGS_EXTRA)
+libcares_la_CFLAGS_EXTRA = $(am__append_5) $(CODE_COVERAGE_CFLAGS)
+libcares_la_CPPFLAGS_EXTRA = -DCARES_BUILDING_LIBRARY $(am__append_6) \
+	$(CODE_COVERAGE_CPPFLAGS)
+@CODE_COVERAGE_ENABLED_TRUE@GITIGNOREFILES := $(GITIGNOREFILES) $(CODE_COVERAGE_OUTPUT_FILE) $(CODE_COVERAGE_OUTPUT_DIRECTORY)
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_lcov_cap = $(code_coverage_v_lcov_cap_$(V))
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_lcov_cap_ = $(code_coverage_v_lcov_cap_$(AM_DEFAULT_VERBOSITY))
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_lcov_cap_0 = @echo "  LCOV   --capture" $(CODE_COVERAGE_OUTPUT_FILE);
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_lcov_ign = $(code_coverage_v_lcov_ign_$(V))
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_lcov_ign_ = $(code_coverage_v_lcov_ign_$(AM_DEFAULT_VERBOSITY))
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_lcov_ign_0 = @echo "  LCOV   --remove /tmp/*" $(CODE_COVERAGE_IGNORE_PATTERN);
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_genhtml = $(code_coverage_v_genhtml_$(V))
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_genhtml_ = $(code_coverage_v_genhtml_$(AM_DEFAULT_VERBOSITY))
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_v_genhtml_0 = @echo "  GEN   " "$(CODE_COVERAGE_OUTPUT_DIRECTORY)";
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_quiet = $(code_coverage_quiet_$(V))
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_quiet_ = $(code_coverage_quiet_$(AM_DEFAULT_VERBOSITY))
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_quiet_0 = --quiet
+
+# sanitizes the test-name: replaces with underscores: dashes and dots
+@CODE_COVERAGE_ENABLED_TRUE@code_coverage_sanitize = $(subst -,_,$(subst .,_,$(1)))
+@CODE_COVERAGE_ENABLED_TRUE@AM_DISTCHECK_CONFIGURE_FLAGS := $(AM_DISTCHECK_CONFIGURE_FLAGS) --disable-code-coverage
+libcares_la_LIBS = $(CODE_COVERAGE_LIBS)
+libcares_la_CFLAGS = $(AM_CFLAGS) $(libcares_la_CFLAGS_EXTRA)
+libcares_la_CPPFLAGS = $(AM_CPPFLAGS) $(libcares_la_CPPFLAGS_EXTRA)
+CSOURCES = ares__addrinfo2hostent.c	\
+  ares__addrinfo_localhost.c	\
+  ares__close_sockets.c	\
+  ares__get_hostent.c			\
+  ares__parse_into_addrinfo.c		\
+  ares__readaddrinfo.c			\
+  ares__sortaddrinfo.c			\
+  ares__read_line.c			\
+  ares__timeval.c			\
+  ares_android.c			\
+  ares_cancel.c				\
+  ares_data.c				\
+  ares_destroy.c			\
+  ares_expand_name.c			\
+  ares_expand_string.c			\
+  ares_fds.c				\
+  ares_free_hostent.c			\
+  ares_free_string.c			\
+  ares_freeaddrinfo.c			\
+  ares_getaddrinfo.c			\
+  ares_getenv.c				\
+  ares_gethostbyaddr.c			\
+  ares_gethostbyname.c			\
+  ares_getnameinfo.c			\
+  ares_getsock.c			\
+  ares_init.c				\
+  ares_library_init.c			\
+  ares_llist.c				\
+  ares_mkquery.c			\
+  ares_create_query.c			\
+  ares_nowarn.c				\
+  ares_options.c			\
+  ares_parse_a_reply.c			\
+  ares_parse_aaaa_reply.c		\
+  ares_parse_caa_reply.c		\
+  ares_parse_mx_reply.c			\
+  ares_parse_naptr_reply.c		\
+  ares_parse_ns_reply.c			\
+  ares_parse_ptr_reply.c		\
+  ares_parse_soa_reply.c		\
+  ares_parse_srv_reply.c		\
+  ares_parse_txt_reply.c		\
+  ares_parse_uri_reply.c		\
+  ares_platform.c			\
+  ares_process.c			\
+  ares_query.c				\
+  ares_search.c				\
+  ares_send.c				\
+  ares_strcasecmp.c			\
+  ares_strdup.c				\
+  ares_strerror.c			\
+  ares_strsplit.c			\
+  ares_timeout.c			\
+  ares_version.c			\
+  ares_writev.c				\
+  bitncmp.c				\
+  inet_net_pton.c			\
+  inet_ntop.c				\
+  windows_port.c
+
+HHEADERS = ares_android.h                        \
+  ares_data.h				\
+  ares_getenv.h				\
+  ares_inet_net_pton.h			\
+  ares_iphlpapi.h			\
+  ares_ipv6.h				\
+  ares_library_init.h			\
+  ares_llist.h				\
+  ares_nowarn.h				\
+  ares_platform.h			\
+  ares_private.h			\
+  ares_strcasecmp.h			\
+  ares_strdup.h				\
+  ares_strsplit.h			\
+  ares_writev.h				\
+  bitncmp.h				\
+  ares_setup.h				\
+  setup_once.h
+
+
+# Makefile.inc provides the CSOURCES and HHEADERS defines
+libcares_la_SOURCES = $(CSOURCES) $(HHEADERS)
+all: ares_config.h
+	$(MAKE) $(AM_MAKEFLAGS) all-recursive
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(top_srcdir)/aminclude_static.am $(srcdir)/Makefile.inc $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/lib/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign src/lib/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+$(top_srcdir)/aminclude_static.am $(srcdir)/Makefile.inc $(am__empty):
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+ares_config.h: stamp-h1
+	@test -f $@ || rm -f stamp-h1
+	@test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1
+
+stamp-h1: $(srcdir)/ares_config.h.in $(top_builddir)/config.status
+	@rm -f stamp-h1
+	cd $(top_builddir) && $(SHELL) ./config.status src/lib/ares_config.h
+$(srcdir)/ares_config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) 
+	($(am__cd) $(top_srcdir) && $(AUTOHEADER))
+	rm -f stamp-h1
+	touch $@
+
+distclean-hdr:
+	-rm -f ares_config.h stamp-h1
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+	}
+
+uninstall-libLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	for p in $$list; do \
+	  $(am__strip_dir) \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+	done
+
+clean-libLTLIBRARIES:
+	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+	@list='$(lib_LTLIBRARIES)'; \
+	locs=`for p in $$list; do echo $$p; done | \
+	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+	      sort -u`; \
+	test -z "$$locs" || { \
+	  echo rm -f $${locs}; \
+	  rm -f $${locs}; \
+	}
+
+libcares.la: $(libcares_la_OBJECTS) $(libcares_la_DEPENDENCIES) $(EXTRA_libcares_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(libcares_la_LINK) -rpath $(libdir) $(libcares_la_OBJECTS) $(libcares_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__addrinfo2hostent.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__addrinfo_localhost.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__close_sockets.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__get_hostent.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__parse_into_addrinfo.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__read_line.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__readaddrinfo.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__sortaddrinfo.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares__timeval.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_android.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_cancel.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_create_query.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_data.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_destroy.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_expand_name.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_expand_string.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_fds.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_free_hostent.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_free_string.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_freeaddrinfo.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_getaddrinfo.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_getenv.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_gethostbyaddr.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_gethostbyname.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_getnameinfo.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_getsock.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_init.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_library_init.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_llist.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_mkquery.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_nowarn.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_options.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_a_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_aaaa_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_caa_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_mx_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_naptr_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_ns_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_ptr_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_soa_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_srv_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_txt_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_parse_uri_reply.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_platform.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_process.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_query.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_search.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_send.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_strcasecmp.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_strdup.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_strerror.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_strsplit.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_timeout.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_version.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-ares_writev.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-bitncmp.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-inet_net_pton.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-inet_ntop.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcares_la-windows_port.Plo@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
+
+.c.o:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
+
+libcares_la-ares__addrinfo2hostent.lo: ares__addrinfo2hostent.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__addrinfo2hostent.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__addrinfo2hostent.Tpo -c -o libcares_la-ares__addrinfo2hostent.lo `test -f 'ares__addrinfo2hostent.c' || echo '$(srcdir)/'`ares__addrinfo2hostent.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__addrinfo2hostent.Tpo $(DEPDIR)/libcares_la-ares__addrinfo2hostent.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__addrinfo2hostent.c' object='libcares_la-ares__addrinfo2hostent.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__addrinfo2hostent.lo `test -f 'ares__addrinfo2hostent.c' || echo '$(srcdir)/'`ares__addrinfo2hostent.c
+
+libcares_la-ares__addrinfo_localhost.lo: ares__addrinfo_localhost.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__addrinfo_localhost.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__addrinfo_localhost.Tpo -c -o libcares_la-ares__addrinfo_localhost.lo `test -f 'ares__addrinfo_localhost.c' || echo '$(srcdir)/'`ares__addrinfo_localhost.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__addrinfo_localhost.Tpo $(DEPDIR)/libcares_la-ares__addrinfo_localhost.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__addrinfo_localhost.c' object='libcares_la-ares__addrinfo_localhost.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__addrinfo_localhost.lo `test -f 'ares__addrinfo_localhost.c' || echo '$(srcdir)/'`ares__addrinfo_localhost.c
+
+libcares_la-ares__close_sockets.lo: ares__close_sockets.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__close_sockets.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__close_sockets.Tpo -c -o libcares_la-ares__close_sockets.lo `test -f 'ares__close_sockets.c' || echo '$(srcdir)/'`ares__close_sockets.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__close_sockets.Tpo $(DEPDIR)/libcares_la-ares__close_sockets.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__close_sockets.c' object='libcares_la-ares__close_sockets.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__close_sockets.lo `test -f 'ares__close_sockets.c' || echo '$(srcdir)/'`ares__close_sockets.c
+
+libcares_la-ares__get_hostent.lo: ares__get_hostent.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__get_hostent.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__get_hostent.Tpo -c -o libcares_la-ares__get_hostent.lo `test -f 'ares__get_hostent.c' || echo '$(srcdir)/'`ares__get_hostent.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__get_hostent.Tpo $(DEPDIR)/libcares_la-ares__get_hostent.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__get_hostent.c' object='libcares_la-ares__get_hostent.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__get_hostent.lo `test -f 'ares__get_hostent.c' || echo '$(srcdir)/'`ares__get_hostent.c
+
+libcares_la-ares__parse_into_addrinfo.lo: ares__parse_into_addrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__parse_into_addrinfo.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__parse_into_addrinfo.Tpo -c -o libcares_la-ares__parse_into_addrinfo.lo `test -f 'ares__parse_into_addrinfo.c' || echo '$(srcdir)/'`ares__parse_into_addrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__parse_into_addrinfo.Tpo $(DEPDIR)/libcares_la-ares__parse_into_addrinfo.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__parse_into_addrinfo.c' object='libcares_la-ares__parse_into_addrinfo.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__parse_into_addrinfo.lo `test -f 'ares__parse_into_addrinfo.c' || echo '$(srcdir)/'`ares__parse_into_addrinfo.c
+
+libcares_la-ares__readaddrinfo.lo: ares__readaddrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__readaddrinfo.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__readaddrinfo.Tpo -c -o libcares_la-ares__readaddrinfo.lo `test -f 'ares__readaddrinfo.c' || echo '$(srcdir)/'`ares__readaddrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__readaddrinfo.Tpo $(DEPDIR)/libcares_la-ares__readaddrinfo.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__readaddrinfo.c' object='libcares_la-ares__readaddrinfo.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__readaddrinfo.lo `test -f 'ares__readaddrinfo.c' || echo '$(srcdir)/'`ares__readaddrinfo.c
+
+libcares_la-ares__sortaddrinfo.lo: ares__sortaddrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__sortaddrinfo.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__sortaddrinfo.Tpo -c -o libcares_la-ares__sortaddrinfo.lo `test -f 'ares__sortaddrinfo.c' || echo '$(srcdir)/'`ares__sortaddrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__sortaddrinfo.Tpo $(DEPDIR)/libcares_la-ares__sortaddrinfo.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__sortaddrinfo.c' object='libcares_la-ares__sortaddrinfo.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__sortaddrinfo.lo `test -f 'ares__sortaddrinfo.c' || echo '$(srcdir)/'`ares__sortaddrinfo.c
+
+libcares_la-ares__read_line.lo: ares__read_line.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__read_line.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__read_line.Tpo -c -o libcares_la-ares__read_line.lo `test -f 'ares__read_line.c' || echo '$(srcdir)/'`ares__read_line.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__read_line.Tpo $(DEPDIR)/libcares_la-ares__read_line.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__read_line.c' object='libcares_la-ares__read_line.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__read_line.lo `test -f 'ares__read_line.c' || echo '$(srcdir)/'`ares__read_line.c
+
+libcares_la-ares__timeval.lo: ares__timeval.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares__timeval.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares__timeval.Tpo -c -o libcares_la-ares__timeval.lo `test -f 'ares__timeval.c' || echo '$(srcdir)/'`ares__timeval.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares__timeval.Tpo $(DEPDIR)/libcares_la-ares__timeval.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares__timeval.c' object='libcares_la-ares__timeval.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares__timeval.lo `test -f 'ares__timeval.c' || echo '$(srcdir)/'`ares__timeval.c
+
+libcares_la-ares_android.lo: ares_android.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_android.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_android.Tpo -c -o libcares_la-ares_android.lo `test -f 'ares_android.c' || echo '$(srcdir)/'`ares_android.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_android.Tpo $(DEPDIR)/libcares_la-ares_android.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_android.c' object='libcares_la-ares_android.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_android.lo `test -f 'ares_android.c' || echo '$(srcdir)/'`ares_android.c
+
+libcares_la-ares_cancel.lo: ares_cancel.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_cancel.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_cancel.Tpo -c -o libcares_la-ares_cancel.lo `test -f 'ares_cancel.c' || echo '$(srcdir)/'`ares_cancel.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_cancel.Tpo $(DEPDIR)/libcares_la-ares_cancel.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_cancel.c' object='libcares_la-ares_cancel.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_cancel.lo `test -f 'ares_cancel.c' || echo '$(srcdir)/'`ares_cancel.c
+
+libcares_la-ares_data.lo: ares_data.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_data.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_data.Tpo -c -o libcares_la-ares_data.lo `test -f 'ares_data.c' || echo '$(srcdir)/'`ares_data.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_data.Tpo $(DEPDIR)/libcares_la-ares_data.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_data.c' object='libcares_la-ares_data.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_data.lo `test -f 'ares_data.c' || echo '$(srcdir)/'`ares_data.c
+
+libcares_la-ares_destroy.lo: ares_destroy.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_destroy.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_destroy.Tpo -c -o libcares_la-ares_destroy.lo `test -f 'ares_destroy.c' || echo '$(srcdir)/'`ares_destroy.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_destroy.Tpo $(DEPDIR)/libcares_la-ares_destroy.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_destroy.c' object='libcares_la-ares_destroy.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_destroy.lo `test -f 'ares_destroy.c' || echo '$(srcdir)/'`ares_destroy.c
+
+libcares_la-ares_expand_name.lo: ares_expand_name.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_expand_name.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_expand_name.Tpo -c -o libcares_la-ares_expand_name.lo `test -f 'ares_expand_name.c' || echo '$(srcdir)/'`ares_expand_name.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_expand_name.Tpo $(DEPDIR)/libcares_la-ares_expand_name.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_expand_name.c' object='libcares_la-ares_expand_name.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_expand_name.lo `test -f 'ares_expand_name.c' || echo '$(srcdir)/'`ares_expand_name.c
+
+libcares_la-ares_expand_string.lo: ares_expand_string.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_expand_string.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_expand_string.Tpo -c -o libcares_la-ares_expand_string.lo `test -f 'ares_expand_string.c' || echo '$(srcdir)/'`ares_expand_string.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_expand_string.Tpo $(DEPDIR)/libcares_la-ares_expand_string.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_expand_string.c' object='libcares_la-ares_expand_string.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_expand_string.lo `test -f 'ares_expand_string.c' || echo '$(srcdir)/'`ares_expand_string.c
+
+libcares_la-ares_fds.lo: ares_fds.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_fds.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_fds.Tpo -c -o libcares_la-ares_fds.lo `test -f 'ares_fds.c' || echo '$(srcdir)/'`ares_fds.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_fds.Tpo $(DEPDIR)/libcares_la-ares_fds.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_fds.c' object='libcares_la-ares_fds.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_fds.lo `test -f 'ares_fds.c' || echo '$(srcdir)/'`ares_fds.c
+
+libcares_la-ares_free_hostent.lo: ares_free_hostent.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_free_hostent.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_free_hostent.Tpo -c -o libcares_la-ares_free_hostent.lo `test -f 'ares_free_hostent.c' || echo '$(srcdir)/'`ares_free_hostent.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_free_hostent.Tpo $(DEPDIR)/libcares_la-ares_free_hostent.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_free_hostent.c' object='libcares_la-ares_free_hostent.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_free_hostent.lo `test -f 'ares_free_hostent.c' || echo '$(srcdir)/'`ares_free_hostent.c
+
+libcares_la-ares_free_string.lo: ares_free_string.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_free_string.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_free_string.Tpo -c -o libcares_la-ares_free_string.lo `test -f 'ares_free_string.c' || echo '$(srcdir)/'`ares_free_string.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_free_string.Tpo $(DEPDIR)/libcares_la-ares_free_string.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_free_string.c' object='libcares_la-ares_free_string.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_free_string.lo `test -f 'ares_free_string.c' || echo '$(srcdir)/'`ares_free_string.c
+
+libcares_la-ares_freeaddrinfo.lo: ares_freeaddrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_freeaddrinfo.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_freeaddrinfo.Tpo -c -o libcares_la-ares_freeaddrinfo.lo `test -f 'ares_freeaddrinfo.c' || echo '$(srcdir)/'`ares_freeaddrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_freeaddrinfo.Tpo $(DEPDIR)/libcares_la-ares_freeaddrinfo.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_freeaddrinfo.c' object='libcares_la-ares_freeaddrinfo.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_freeaddrinfo.lo `test -f 'ares_freeaddrinfo.c' || echo '$(srcdir)/'`ares_freeaddrinfo.c
+
+libcares_la-ares_getaddrinfo.lo: ares_getaddrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_getaddrinfo.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_getaddrinfo.Tpo -c -o libcares_la-ares_getaddrinfo.lo `test -f 'ares_getaddrinfo.c' || echo '$(srcdir)/'`ares_getaddrinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_getaddrinfo.Tpo $(DEPDIR)/libcares_la-ares_getaddrinfo.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getaddrinfo.c' object='libcares_la-ares_getaddrinfo.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_getaddrinfo.lo `test -f 'ares_getaddrinfo.c' || echo '$(srcdir)/'`ares_getaddrinfo.c
+
+libcares_la-ares_getenv.lo: ares_getenv.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_getenv.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_getenv.Tpo -c -o libcares_la-ares_getenv.lo `test -f 'ares_getenv.c' || echo '$(srcdir)/'`ares_getenv.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_getenv.Tpo $(DEPDIR)/libcares_la-ares_getenv.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getenv.c' object='libcares_la-ares_getenv.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_getenv.lo `test -f 'ares_getenv.c' || echo '$(srcdir)/'`ares_getenv.c
+
+libcares_la-ares_gethostbyaddr.lo: ares_gethostbyaddr.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_gethostbyaddr.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_gethostbyaddr.Tpo -c -o libcares_la-ares_gethostbyaddr.lo `test -f 'ares_gethostbyaddr.c' || echo '$(srcdir)/'`ares_gethostbyaddr.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_gethostbyaddr.Tpo $(DEPDIR)/libcares_la-ares_gethostbyaddr.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_gethostbyaddr.c' object='libcares_la-ares_gethostbyaddr.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_gethostbyaddr.lo `test -f 'ares_gethostbyaddr.c' || echo '$(srcdir)/'`ares_gethostbyaddr.c
+
+libcares_la-ares_gethostbyname.lo: ares_gethostbyname.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_gethostbyname.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_gethostbyname.Tpo -c -o libcares_la-ares_gethostbyname.lo `test -f 'ares_gethostbyname.c' || echo '$(srcdir)/'`ares_gethostbyname.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_gethostbyname.Tpo $(DEPDIR)/libcares_la-ares_gethostbyname.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_gethostbyname.c' object='libcares_la-ares_gethostbyname.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_gethostbyname.lo `test -f 'ares_gethostbyname.c' || echo '$(srcdir)/'`ares_gethostbyname.c
+
+libcares_la-ares_getnameinfo.lo: ares_getnameinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_getnameinfo.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_getnameinfo.Tpo -c -o libcares_la-ares_getnameinfo.lo `test -f 'ares_getnameinfo.c' || echo '$(srcdir)/'`ares_getnameinfo.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_getnameinfo.Tpo $(DEPDIR)/libcares_la-ares_getnameinfo.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getnameinfo.c' object='libcares_la-ares_getnameinfo.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_getnameinfo.lo `test -f 'ares_getnameinfo.c' || echo '$(srcdir)/'`ares_getnameinfo.c
+
+libcares_la-ares_getsock.lo: ares_getsock.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_getsock.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_getsock.Tpo -c -o libcares_la-ares_getsock.lo `test -f 'ares_getsock.c' || echo '$(srcdir)/'`ares_getsock.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_getsock.Tpo $(DEPDIR)/libcares_la-ares_getsock.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getsock.c' object='libcares_la-ares_getsock.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_getsock.lo `test -f 'ares_getsock.c' || echo '$(srcdir)/'`ares_getsock.c
+
+libcares_la-ares_init.lo: ares_init.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_init.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_init.Tpo -c -o libcares_la-ares_init.lo `test -f 'ares_init.c' || echo '$(srcdir)/'`ares_init.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_init.Tpo $(DEPDIR)/libcares_la-ares_init.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_init.c' object='libcares_la-ares_init.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_init.lo `test -f 'ares_init.c' || echo '$(srcdir)/'`ares_init.c
+
+libcares_la-ares_library_init.lo: ares_library_init.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_library_init.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_library_init.Tpo -c -o libcares_la-ares_library_init.lo `test -f 'ares_library_init.c' || echo '$(srcdir)/'`ares_library_init.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_library_init.Tpo $(DEPDIR)/libcares_la-ares_library_init.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_library_init.c' object='libcares_la-ares_library_init.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_library_init.lo `test -f 'ares_library_init.c' || echo '$(srcdir)/'`ares_library_init.c
+
+libcares_la-ares_llist.lo: ares_llist.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_llist.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_llist.Tpo -c -o libcares_la-ares_llist.lo `test -f 'ares_llist.c' || echo '$(srcdir)/'`ares_llist.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_llist.Tpo $(DEPDIR)/libcares_la-ares_llist.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_llist.c' object='libcares_la-ares_llist.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_llist.lo `test -f 'ares_llist.c' || echo '$(srcdir)/'`ares_llist.c
+
+libcares_la-ares_mkquery.lo: ares_mkquery.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_mkquery.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_mkquery.Tpo -c -o libcares_la-ares_mkquery.lo `test -f 'ares_mkquery.c' || echo '$(srcdir)/'`ares_mkquery.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_mkquery.Tpo $(DEPDIR)/libcares_la-ares_mkquery.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_mkquery.c' object='libcares_la-ares_mkquery.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_mkquery.lo `test -f 'ares_mkquery.c' || echo '$(srcdir)/'`ares_mkquery.c
+
+libcares_la-ares_create_query.lo: ares_create_query.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_create_query.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_create_query.Tpo -c -o libcares_la-ares_create_query.lo `test -f 'ares_create_query.c' || echo '$(srcdir)/'`ares_create_query.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_create_query.Tpo $(DEPDIR)/libcares_la-ares_create_query.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_create_query.c' object='libcares_la-ares_create_query.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_create_query.lo `test -f 'ares_create_query.c' || echo '$(srcdir)/'`ares_create_query.c
+
+libcares_la-ares_nowarn.lo: ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_nowarn.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_nowarn.Tpo -c -o libcares_la-ares_nowarn.lo `test -f 'ares_nowarn.c' || echo '$(srcdir)/'`ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_nowarn.Tpo $(DEPDIR)/libcares_la-ares_nowarn.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_nowarn.c' object='libcares_la-ares_nowarn.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_nowarn.lo `test -f 'ares_nowarn.c' || echo '$(srcdir)/'`ares_nowarn.c
+
+libcares_la-ares_options.lo: ares_options.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_options.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_options.Tpo -c -o libcares_la-ares_options.lo `test -f 'ares_options.c' || echo '$(srcdir)/'`ares_options.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_options.Tpo $(DEPDIR)/libcares_la-ares_options.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_options.c' object='libcares_la-ares_options.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_options.lo `test -f 'ares_options.c' || echo '$(srcdir)/'`ares_options.c
+
+libcares_la-ares_parse_a_reply.lo: ares_parse_a_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_a_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_a_reply.Tpo -c -o libcares_la-ares_parse_a_reply.lo `test -f 'ares_parse_a_reply.c' || echo '$(srcdir)/'`ares_parse_a_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_a_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_a_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_a_reply.c' object='libcares_la-ares_parse_a_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_a_reply.lo `test -f 'ares_parse_a_reply.c' || echo '$(srcdir)/'`ares_parse_a_reply.c
+
+libcares_la-ares_parse_aaaa_reply.lo: ares_parse_aaaa_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_aaaa_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_aaaa_reply.Tpo -c -o libcares_la-ares_parse_aaaa_reply.lo `test -f 'ares_parse_aaaa_reply.c' || echo '$(srcdir)/'`ares_parse_aaaa_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_aaaa_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_aaaa_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_aaaa_reply.c' object='libcares_la-ares_parse_aaaa_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_aaaa_reply.lo `test -f 'ares_parse_aaaa_reply.c' || echo '$(srcdir)/'`ares_parse_aaaa_reply.c
+
+libcares_la-ares_parse_caa_reply.lo: ares_parse_caa_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_caa_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_caa_reply.Tpo -c -o libcares_la-ares_parse_caa_reply.lo `test -f 'ares_parse_caa_reply.c' || echo '$(srcdir)/'`ares_parse_caa_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_caa_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_caa_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_caa_reply.c' object='libcares_la-ares_parse_caa_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_caa_reply.lo `test -f 'ares_parse_caa_reply.c' || echo '$(srcdir)/'`ares_parse_caa_reply.c
+
+libcares_la-ares_parse_mx_reply.lo: ares_parse_mx_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_mx_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_mx_reply.Tpo -c -o libcares_la-ares_parse_mx_reply.lo `test -f 'ares_parse_mx_reply.c' || echo '$(srcdir)/'`ares_parse_mx_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_mx_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_mx_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_mx_reply.c' object='libcares_la-ares_parse_mx_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_mx_reply.lo `test -f 'ares_parse_mx_reply.c' || echo '$(srcdir)/'`ares_parse_mx_reply.c
+
+libcares_la-ares_parse_naptr_reply.lo: ares_parse_naptr_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_naptr_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_naptr_reply.Tpo -c -o libcares_la-ares_parse_naptr_reply.lo `test -f 'ares_parse_naptr_reply.c' || echo '$(srcdir)/'`ares_parse_naptr_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_naptr_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_naptr_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_naptr_reply.c' object='libcares_la-ares_parse_naptr_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_naptr_reply.lo `test -f 'ares_parse_naptr_reply.c' || echo '$(srcdir)/'`ares_parse_naptr_reply.c
+
+libcares_la-ares_parse_ns_reply.lo: ares_parse_ns_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_ns_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_ns_reply.Tpo -c -o libcares_la-ares_parse_ns_reply.lo `test -f 'ares_parse_ns_reply.c' || echo '$(srcdir)/'`ares_parse_ns_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_ns_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_ns_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_ns_reply.c' object='libcares_la-ares_parse_ns_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_ns_reply.lo `test -f 'ares_parse_ns_reply.c' || echo '$(srcdir)/'`ares_parse_ns_reply.c
+
+libcares_la-ares_parse_ptr_reply.lo: ares_parse_ptr_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_ptr_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_ptr_reply.Tpo -c -o libcares_la-ares_parse_ptr_reply.lo `test -f 'ares_parse_ptr_reply.c' || echo '$(srcdir)/'`ares_parse_ptr_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_ptr_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_ptr_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_ptr_reply.c' object='libcares_la-ares_parse_ptr_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_ptr_reply.lo `test -f 'ares_parse_ptr_reply.c' || echo '$(srcdir)/'`ares_parse_ptr_reply.c
+
+libcares_la-ares_parse_soa_reply.lo: ares_parse_soa_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_soa_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_soa_reply.Tpo -c -o libcares_la-ares_parse_soa_reply.lo `test -f 'ares_parse_soa_reply.c' || echo '$(srcdir)/'`ares_parse_soa_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_soa_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_soa_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_soa_reply.c' object='libcares_la-ares_parse_soa_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_soa_reply.lo `test -f 'ares_parse_soa_reply.c' || echo '$(srcdir)/'`ares_parse_soa_reply.c
+
+libcares_la-ares_parse_srv_reply.lo: ares_parse_srv_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_srv_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_srv_reply.Tpo -c -o libcares_la-ares_parse_srv_reply.lo `test -f 'ares_parse_srv_reply.c' || echo '$(srcdir)/'`ares_parse_srv_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_srv_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_srv_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_srv_reply.c' object='libcares_la-ares_parse_srv_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_srv_reply.lo `test -f 'ares_parse_srv_reply.c' || echo '$(srcdir)/'`ares_parse_srv_reply.c
+
+libcares_la-ares_parse_txt_reply.lo: ares_parse_txt_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_txt_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_txt_reply.Tpo -c -o libcares_la-ares_parse_txt_reply.lo `test -f 'ares_parse_txt_reply.c' || echo '$(srcdir)/'`ares_parse_txt_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_txt_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_txt_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_txt_reply.c' object='libcares_la-ares_parse_txt_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_txt_reply.lo `test -f 'ares_parse_txt_reply.c' || echo '$(srcdir)/'`ares_parse_txt_reply.c
+
+libcares_la-ares_parse_uri_reply.lo: ares_parse_uri_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_parse_uri_reply.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_parse_uri_reply.Tpo -c -o libcares_la-ares_parse_uri_reply.lo `test -f 'ares_parse_uri_reply.c' || echo '$(srcdir)/'`ares_parse_uri_reply.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_parse_uri_reply.Tpo $(DEPDIR)/libcares_la-ares_parse_uri_reply.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_parse_uri_reply.c' object='libcares_la-ares_parse_uri_reply.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_parse_uri_reply.lo `test -f 'ares_parse_uri_reply.c' || echo '$(srcdir)/'`ares_parse_uri_reply.c
+
+libcares_la-ares_platform.lo: ares_platform.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_platform.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_platform.Tpo -c -o libcares_la-ares_platform.lo `test -f 'ares_platform.c' || echo '$(srcdir)/'`ares_platform.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_platform.Tpo $(DEPDIR)/libcares_la-ares_platform.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_platform.c' object='libcares_la-ares_platform.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_platform.lo `test -f 'ares_platform.c' || echo '$(srcdir)/'`ares_platform.c
+
+libcares_la-ares_process.lo: ares_process.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_process.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_process.Tpo -c -o libcares_la-ares_process.lo `test -f 'ares_process.c' || echo '$(srcdir)/'`ares_process.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_process.Tpo $(DEPDIR)/libcares_la-ares_process.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_process.c' object='libcares_la-ares_process.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_process.lo `test -f 'ares_process.c' || echo '$(srcdir)/'`ares_process.c
+
+libcares_la-ares_query.lo: ares_query.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_query.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_query.Tpo -c -o libcares_la-ares_query.lo `test -f 'ares_query.c' || echo '$(srcdir)/'`ares_query.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_query.Tpo $(DEPDIR)/libcares_la-ares_query.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_query.c' object='libcares_la-ares_query.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_query.lo `test -f 'ares_query.c' || echo '$(srcdir)/'`ares_query.c
+
+libcares_la-ares_search.lo: ares_search.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_search.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_search.Tpo -c -o libcares_la-ares_search.lo `test -f 'ares_search.c' || echo '$(srcdir)/'`ares_search.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_search.Tpo $(DEPDIR)/libcares_la-ares_search.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_search.c' object='libcares_la-ares_search.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_search.lo `test -f 'ares_search.c' || echo '$(srcdir)/'`ares_search.c
+
+libcares_la-ares_send.lo: ares_send.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_send.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_send.Tpo -c -o libcares_la-ares_send.lo `test -f 'ares_send.c' || echo '$(srcdir)/'`ares_send.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_send.Tpo $(DEPDIR)/libcares_la-ares_send.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_send.c' object='libcares_la-ares_send.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_send.lo `test -f 'ares_send.c' || echo '$(srcdir)/'`ares_send.c
+
+libcares_la-ares_strcasecmp.lo: ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_strcasecmp.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_strcasecmp.Tpo -c -o libcares_la-ares_strcasecmp.lo `test -f 'ares_strcasecmp.c' || echo '$(srcdir)/'`ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_strcasecmp.Tpo $(DEPDIR)/libcares_la-ares_strcasecmp.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_strcasecmp.c' object='libcares_la-ares_strcasecmp.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_strcasecmp.lo `test -f 'ares_strcasecmp.c' || echo '$(srcdir)/'`ares_strcasecmp.c
+
+libcares_la-ares_strdup.lo: ares_strdup.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_strdup.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_strdup.Tpo -c -o libcares_la-ares_strdup.lo `test -f 'ares_strdup.c' || echo '$(srcdir)/'`ares_strdup.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_strdup.Tpo $(DEPDIR)/libcares_la-ares_strdup.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_strdup.c' object='libcares_la-ares_strdup.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_strdup.lo `test -f 'ares_strdup.c' || echo '$(srcdir)/'`ares_strdup.c
+
+libcares_la-ares_strerror.lo: ares_strerror.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_strerror.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_strerror.Tpo -c -o libcares_la-ares_strerror.lo `test -f 'ares_strerror.c' || echo '$(srcdir)/'`ares_strerror.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_strerror.Tpo $(DEPDIR)/libcares_la-ares_strerror.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_strerror.c' object='libcares_la-ares_strerror.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_strerror.lo `test -f 'ares_strerror.c' || echo '$(srcdir)/'`ares_strerror.c
+
+libcares_la-ares_strsplit.lo: ares_strsplit.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_strsplit.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_strsplit.Tpo -c -o libcares_la-ares_strsplit.lo `test -f 'ares_strsplit.c' || echo '$(srcdir)/'`ares_strsplit.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_strsplit.Tpo $(DEPDIR)/libcares_la-ares_strsplit.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_strsplit.c' object='libcares_la-ares_strsplit.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_strsplit.lo `test -f 'ares_strsplit.c' || echo '$(srcdir)/'`ares_strsplit.c
+
+libcares_la-ares_timeout.lo: ares_timeout.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_timeout.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_timeout.Tpo -c -o libcares_la-ares_timeout.lo `test -f 'ares_timeout.c' || echo '$(srcdir)/'`ares_timeout.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_timeout.Tpo $(DEPDIR)/libcares_la-ares_timeout.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_timeout.c' object='libcares_la-ares_timeout.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_timeout.lo `test -f 'ares_timeout.c' || echo '$(srcdir)/'`ares_timeout.c
+
+libcares_la-ares_version.lo: ares_version.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_version.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_version.Tpo -c -o libcares_la-ares_version.lo `test -f 'ares_version.c' || echo '$(srcdir)/'`ares_version.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_version.Tpo $(DEPDIR)/libcares_la-ares_version.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_version.c' object='libcares_la-ares_version.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_version.lo `test -f 'ares_version.c' || echo '$(srcdir)/'`ares_version.c
+
+libcares_la-ares_writev.lo: ares_writev.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-ares_writev.lo -MD -MP -MF $(DEPDIR)/libcares_la-ares_writev.Tpo -c -o libcares_la-ares_writev.lo `test -f 'ares_writev.c' || echo '$(srcdir)/'`ares_writev.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-ares_writev.Tpo $(DEPDIR)/libcares_la-ares_writev.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_writev.c' object='libcares_la-ares_writev.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-ares_writev.lo `test -f 'ares_writev.c' || echo '$(srcdir)/'`ares_writev.c
+
+libcares_la-bitncmp.lo: bitncmp.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-bitncmp.lo -MD -MP -MF $(DEPDIR)/libcares_la-bitncmp.Tpo -c -o libcares_la-bitncmp.lo `test -f 'bitncmp.c' || echo '$(srcdir)/'`bitncmp.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-bitncmp.Tpo $(DEPDIR)/libcares_la-bitncmp.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='bitncmp.c' object='libcares_la-bitncmp.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-bitncmp.lo `test -f 'bitncmp.c' || echo '$(srcdir)/'`bitncmp.c
+
+libcares_la-inet_net_pton.lo: inet_net_pton.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-inet_net_pton.lo -MD -MP -MF $(DEPDIR)/libcares_la-inet_net_pton.Tpo -c -o libcares_la-inet_net_pton.lo `test -f 'inet_net_pton.c' || echo '$(srcdir)/'`inet_net_pton.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-inet_net_pton.Tpo $(DEPDIR)/libcares_la-inet_net_pton.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='inet_net_pton.c' object='libcares_la-inet_net_pton.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-inet_net_pton.lo `test -f 'inet_net_pton.c' || echo '$(srcdir)/'`inet_net_pton.c
+
+libcares_la-inet_ntop.lo: inet_ntop.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-inet_ntop.lo -MD -MP -MF $(DEPDIR)/libcares_la-inet_ntop.Tpo -c -o libcares_la-inet_ntop.lo `test -f 'inet_ntop.c' || echo '$(srcdir)/'`inet_ntop.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-inet_ntop.Tpo $(DEPDIR)/libcares_la-inet_ntop.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='inet_ntop.c' object='libcares_la-inet_ntop.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-inet_ntop.lo `test -f 'inet_ntop.c' || echo '$(srcdir)/'`inet_ntop.c
+
+libcares_la-windows_port.lo: windows_port.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -MT libcares_la-windows_port.lo -MD -MP -MF $(DEPDIR)/libcares_la-windows_port.Tpo -c -o libcares_la-windows_port.lo `test -f 'windows_port.c' || echo '$(srcdir)/'`windows_port.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcares_la-windows_port.Tpo $(DEPDIR)/libcares_la-windows_port.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='windows_port.c' object='libcares_la-windows_port.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libcares_la_CPPFLAGS) $(CPPFLAGS) $(libcares_la_CFLAGS) $(CFLAGS) -c -o libcares_la-windows_port.lo `test -f 'windows_port.c' || echo '$(srcdir)/'`windows_port.c
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+#     (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+	@fail=; \
+	if $(am__make_keepgoing); then \
+	  failcom='fail=yes'; \
+	else \
+	  failcom='exit 1'; \
+	fi; \
+	dot_seen=no; \
+	target=`echo $@ | sed s/-recursive//`; \
+	case "$@" in \
+	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+	  *) list='$(SUBDIRS)' ;; \
+	esac; \
+	for subdir in $$list; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    dot_seen=yes; \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done; \
+	if test "$$dot_seen" = "no"; then \
+	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+	fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+	  include_option=--etags-include; \
+	  empty_fix=.; \
+	else \
+	  include_option=--include; \
+	  empty_fix=; \
+	fi; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test ! -f $$subdir/TAGS || \
+	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+	  fi; \
+	done; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    $(am__make_dryrun) \
+	      || test -d "$(distdir)/$$subdir" \
+	      || $(MKDIR_P) "$(distdir)/$$subdir" \
+	      || exit 1; \
+	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+	    $(am__relativize); \
+	    new_distdir=$$reldir; \
+	    dir1=$$subdir; dir2="$(top_distdir)"; \
+	    $(am__relativize); \
+	    new_top_distdir=$$reldir; \
+	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+	    ($(am__cd) $$subdir && \
+	      $(MAKE) $(AM_MAKEFLAGS) \
+	        top_distdir="$$new_top_distdir" \
+	        distdir="$$new_distdir" \
+		am__remove_distdir=: \
+		am__skip_length_check=: \
+		am__skip_mode_fix=: \
+	        distdir) \
+	      || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-recursive
+all-am: Makefile $(LTLIBRARIES) ares_config.h
+installdirs: installdirs-recursive
+installdirs-am:
+	for dir in "$(DESTDIR)$(libdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+	-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
+	mostlyclean-am
+
+distclean: distclean-recursive
+		-rm -f ./$(DEPDIR)/libcares_la-ares__addrinfo2hostent.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__addrinfo_localhost.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__close_sockets.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__get_hostent.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__parse_into_addrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__read_line.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__readaddrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__sortaddrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__timeval.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_android.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_cancel.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_create_query.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_data.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_destroy.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_expand_name.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_expand_string.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_fds.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_free_hostent.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_free_string.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_freeaddrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_getaddrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_getenv.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_gethostbyaddr.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_gethostbyname.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_getnameinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_getsock.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_init.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_library_init.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_llist.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_mkquery.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_nowarn.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_options.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_a_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_aaaa_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_caa_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_mx_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_naptr_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_ns_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_ptr_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_soa_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_srv_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_txt_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_uri_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_platform.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_process.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_query.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_search.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_send.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_strcasecmp.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_strdup.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_strerror.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_strsplit.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_timeout.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_version.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_writev.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-bitncmp.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-inet_net_pton.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-inet_ntop.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-windows_port.Plo
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-hdr distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+		-rm -f ./$(DEPDIR)/libcares_la-ares__addrinfo2hostent.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__addrinfo_localhost.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__close_sockets.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__get_hostent.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__parse_into_addrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__read_line.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__readaddrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__sortaddrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares__timeval.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_android.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_cancel.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_create_query.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_data.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_destroy.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_expand_name.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_expand_string.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_fds.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_free_hostent.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_free_string.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_freeaddrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_getaddrinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_getenv.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_gethostbyaddr.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_gethostbyname.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_getnameinfo.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_getsock.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_init.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_library_init.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_llist.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_mkquery.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_nowarn.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_options.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_a_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_aaaa_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_caa_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_mx_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_naptr_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_ns_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_ptr_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_soa_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_srv_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_txt_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_parse_uri_reply.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_platform.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_process.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_query.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_search.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_send.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_strcasecmp.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_strdup.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_strerror.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_strsplit.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_timeout.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_version.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-ares_writev.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-bitncmp.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-inet_net_pton.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-inet_ntop.Plo
+	-rm -f ./$(DEPDIR)/libcares_la-windows_port.Plo
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES
+
+.MAKE: $(am__recursive_targets) all install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
+	am--depfiles check check-am clean clean-generic \
+	clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \
+	ctags-am distclean distclean-compile distclean-generic \
+	distclean-hdr distclean-libtool distclean-tags distdir dvi \
+	dvi-am html html-am info info-am install install-am \
+	install-data install-data-am install-dvi install-dvi-am \
+	install-exec install-exec-am install-html install-html-am \
+	install-info install-info-am install-libLTLIBRARIES \
+	install-man install-pdf install-pdf-am install-ps \
+	install-ps-am install-strip installcheck installcheck-am \
+	installdirs installdirs-am maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES
+
+.PRECIOUS: Makefile
+
+
+# Code coverage
+#
+# Optional:
+#  - CODE_COVERAGE_DIRECTORY: Top-level directory for code coverage reporting.
+#    Multiple directories may be specified, separated by whitespace.
+#    (Default: $(top_builddir))
+#  - CODE_COVERAGE_OUTPUT_FILE: Filename and path for the .info file generated
+#    by lcov for code coverage. (Default:
+#    $(PACKAGE_NAME)-$(PACKAGE_VERSION)-coverage.info)
+#  - CODE_COVERAGE_OUTPUT_DIRECTORY: Directory for generated code coverage
+#    reports to be created. (Default:
+#    $(PACKAGE_NAME)-$(PACKAGE_VERSION)-coverage)
+#  - CODE_COVERAGE_BRANCH_COVERAGE: Set to 1 to enforce branch coverage,
+#    set to 0 to disable it and leave empty to stay with the default.
+#    (Default: empty)
+#  - CODE_COVERAGE_LCOV_SHOPTS_DEFAULT: Extra options shared between both lcov
+#    instances. (Default: based on )
+#  - CODE_COVERAGE_LCOV_SHOPTS: Extra options to shared between both lcov
+#    instances. (Default: )
+#  - CODE_COVERAGE_LCOV_OPTIONS_GCOVPATH: --gcov-tool pathtogcov
+#  - CODE_COVERAGE_LCOV_OPTIONS_DEFAULT: Extra options to pass to the
+#    collecting lcov instance. (Default: )
+#  - CODE_COVERAGE_LCOV_OPTIONS: Extra options to pass to the collecting lcov
+#    instance. (Default: )
+#  - CODE_COVERAGE_LCOV_RMOPTS_DEFAULT: Extra options to pass to the filtering
+#    lcov instance. (Default: empty)
+#  - CODE_COVERAGE_LCOV_RMOPTS: Extra options to pass to the filtering lcov
+#    instance. (Default: )
+#  - CODE_COVERAGE_GENHTML_OPTIONS_DEFAULT: Extra options to pass to the
+#    genhtml instance. (Default: based on )
+#  - CODE_COVERAGE_GENHTML_OPTIONS: Extra options to pass to the genhtml
+#    instance. (Default: )
+#  - CODE_COVERAGE_IGNORE_PATTERN: Extra glob pattern of files to ignore
+#
+# The generated report will be titled using the $(PACKAGE_NAME) and
+# $(PACKAGE_VERSION). In order to add the current git hash to the title,
+# use the git-version-gen script, available online.
+# Optional variables
+# run only on top dir
+@CODE_COVERAGE_ENABLED_TRUE@ ifeq ($(abs_builddir), $(abs_top_builddir))
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_DIRECTORY ?= $(top_builddir)
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_OUTPUT_FILE ?= $(PACKAGE_NAME)-$(PACKAGE_VERSION)-coverage.info
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_OUTPUT_DIRECTORY ?= $(PACKAGE_NAME)-$(PACKAGE_VERSION)-coverage
+
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_BRANCH_COVERAGE ?=
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_LCOV_SHOPTS_DEFAULT ?= $(if $(CODE_COVERAGE_BRANCH_COVERAGE),--rc lcov_branch_coverage=$(CODE_COVERAGE_BRANCH_COVERAGE))
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_LCOV_SHOPTS ?= $(CODE_COVERAGE_LCOV_SHOPTS_DEFAULT)
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_LCOV_OPTIONS_GCOVPATH ?= --gcov-tool "$(GCOV)"
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_LCOV_OPTIONS_DEFAULT ?= $(CODE_COVERAGE_LCOV_OPTIONS_GCOVPATH)
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_LCOV_OPTIONS ?= $(CODE_COVERAGE_LCOV_OPTIONS_DEFAULT)
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_LCOV_RMOPTS_DEFAULT ?=
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_LCOV_RMOPTS ?= $(CODE_COVERAGE_LCOV_RMOPTS_DEFAULT)
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_GENHTML_OPTIONS_DEFAULT ?=$(if $(CODE_COVERAGE_BRANCH_COVERAGE),--rc genhtml_branch_coverage=$(CODE_COVERAGE_BRANCH_COVERAGE))
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_GENHTML_OPTIONS ?= $(CODE_COVERAGE_GENHTML_OPTIONS_DEFAULT)
+@CODE_COVERAGE_ENABLED_TRUE@CODE_COVERAGE_IGNORE_PATTERN ?=
+
+# Use recursive makes in order to ignore errors during check
+@CODE_COVERAGE_ENABLED_TRUE@check-code-coverage:
+@CODE_COVERAGE_ENABLED_TRUE@	-$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -k check
+@CODE_COVERAGE_ENABLED_TRUE@	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) code-coverage-capture
+
+# Capture code coverage data
+@CODE_COVERAGE_ENABLED_TRUE@code-coverage-capture: code-coverage-capture-hook
+@CODE_COVERAGE_ENABLED_TRUE@	$(code_coverage_v_lcov_cap)$(LCOV) $(code_coverage_quiet) $(addprefix --directory ,$(CODE_COVERAGE_DIRECTORY)) --capture --output-file "$(CODE_COVERAGE_OUTPUT_FILE).tmp" --test-name "$(call code_coverage_sanitize,$(PACKAGE_NAME)-$(PACKAGE_VERSION))" --no-checksum --compat-libtool $(CODE_COVERAGE_LCOV_SHOPTS) $(CODE_COVERAGE_LCOV_OPTIONS)
+@CODE_COVERAGE_ENABLED_TRUE@	$(code_coverage_v_lcov_ign)$(LCOV) $(code_coverage_quiet) $(addprefix --directory ,$(CODE_COVERAGE_DIRECTORY)) --remove "$(CODE_COVERAGE_OUTPUT_FILE).tmp" "/tmp/*" $(CODE_COVERAGE_IGNORE_PATTERN) --output-file "$(CODE_COVERAGE_OUTPUT_FILE)" $(CODE_COVERAGE_LCOV_SHOPTS) $(CODE_COVERAGE_LCOV_RMOPTS)
+@CODE_COVERAGE_ENABLED_TRUE@	-@rm -f "$(CODE_COVERAGE_OUTPUT_FILE).tmp"
+@CODE_COVERAGE_ENABLED_TRUE@	$(code_coverage_v_genhtml)LANG=C $(GENHTML) $(code_coverage_quiet) $(addprefix --prefix ,$(CODE_COVERAGE_DIRECTORY)) --output-directory "$(CODE_COVERAGE_OUTPUT_DIRECTORY)" --title "$(PACKAGE_NAME)-$(PACKAGE_VERSION) Code Coverage" --legend --show-details "$(CODE_COVERAGE_OUTPUT_FILE)" $(CODE_COVERAGE_GENHTML_OPTIONS)
+@CODE_COVERAGE_ENABLED_TRUE@	@echo "file://$(abs_builddir)/$(CODE_COVERAGE_OUTPUT_DIRECTORY)/index.html"
+
+@CODE_COVERAGE_ENABLED_TRUE@code-coverage-clean:
+@CODE_COVERAGE_ENABLED_TRUE@	-$(LCOV) --directory $(top_builddir) -z
+@CODE_COVERAGE_ENABLED_TRUE@	-rm -rf "$(CODE_COVERAGE_OUTPUT_FILE)" "$(CODE_COVERAGE_OUTPUT_FILE).tmp" "$(CODE_COVERAGE_OUTPUT_DIRECTORY)"
+@CODE_COVERAGE_ENABLED_TRUE@	-find . \( -name "*.gcda" -o -name "*.gcno" -o -name "*.gcov" \) -delete
+
+@CODE_COVERAGE_ENABLED_TRUE@code-coverage-dist-clean:
+@CODE_COVERAGE_ENABLED_TRUE@ else # ifneq ($(abs_builddir), $(abs_top_builddir))
+@CODE_COVERAGE_ENABLED_TRUE@check-code-coverage:
+
+@CODE_COVERAGE_ENABLED_TRUE@code-coverage-capture: code-coverage-capture-hook
+
+@CODE_COVERAGE_ENABLED_TRUE@code-coverage-clean:
+
+@CODE_COVERAGE_ENABLED_TRUE@code-coverage-dist-clean:
+@CODE_COVERAGE_ENABLED_TRUE@ endif # ifeq ($(abs_builddir), $(abs_top_builddir))
+# Use recursive makes in order to ignore errors during check
+@CODE_COVERAGE_ENABLED_FALSE@check-code-coverage:
+@CODE_COVERAGE_ENABLED_FALSE@	@echo "Need to reconfigure with --enable-code-coverage"
+# Capture code coverage data
+@CODE_COVERAGE_ENABLED_FALSE@code-coverage-capture: code-coverage-capture-hook
+@CODE_COVERAGE_ENABLED_FALSE@	@echo "Need to reconfigure with --enable-code-coverage"
+
+@CODE_COVERAGE_ENABLED_FALSE@code-coverage-clean:
+
+@CODE_COVERAGE_ENABLED_FALSE@code-coverage-dist-clean:
+
+# Hook rule executed before code-coverage-capture, overridable by the user
+code-coverage-capture-hook:
+
+.PHONY: check-code-coverage code-coverage-capture code-coverage-dist-clean code-coverage-clean code-coverage-capture-hook
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/deps/cares/src/lib/Makefile.inc b/deps/cares/src/lib/Makefile.inc
new file mode 100644
index 0000000000000000000000000000000000000000..a3b060c289ce7c7b860ddecba2fc0698ecebc7a6
--- /dev/null
+++ b/deps/cares/src/lib/Makefile.inc
@@ -0,0 +1,81 @@
+
+CSOURCES = ares__addrinfo2hostent.c	\
+  ares__addrinfo_localhost.c	\
+  ares__close_sockets.c	\
+  ares__get_hostent.c			\
+  ares__parse_into_addrinfo.c		\
+  ares__readaddrinfo.c			\
+  ares__sortaddrinfo.c			\
+  ares__read_line.c			\
+  ares__timeval.c			\
+  ares_android.c			\
+  ares_cancel.c				\
+  ares_data.c				\
+  ares_destroy.c			\
+  ares_expand_name.c			\
+  ares_expand_string.c			\
+  ares_fds.c				\
+  ares_free_hostent.c			\
+  ares_free_string.c			\
+  ares_freeaddrinfo.c			\
+  ares_getaddrinfo.c			\
+  ares_getenv.c				\
+  ares_gethostbyaddr.c			\
+  ares_gethostbyname.c			\
+  ares_getnameinfo.c			\
+  ares_getsock.c			\
+  ares_init.c				\
+  ares_library_init.c			\
+  ares_llist.c				\
+  ares_mkquery.c			\
+  ares_create_query.c			\
+  ares_nowarn.c				\
+  ares_options.c			\
+  ares_parse_a_reply.c			\
+  ares_parse_aaaa_reply.c		\
+  ares_parse_caa_reply.c		\
+  ares_parse_mx_reply.c			\
+  ares_parse_naptr_reply.c		\
+  ares_parse_ns_reply.c			\
+  ares_parse_ptr_reply.c		\
+  ares_parse_soa_reply.c		\
+  ares_parse_srv_reply.c		\
+  ares_parse_txt_reply.c		\
+  ares_parse_uri_reply.c		\
+  ares_platform.c			\
+  ares_process.c			\
+  ares_query.c				\
+  ares_search.c				\
+  ares_send.c				\
+  ares_strcasecmp.c			\
+  ares_strdup.c				\
+  ares_strerror.c			\
+  ares_strsplit.c			\
+  ares_timeout.c			\
+  ares_version.c			\
+  ares_writev.c				\
+  bitncmp.c				\
+  inet_net_pton.c			\
+  inet_ntop.c				\
+  windows_port.c
+
+HHEADERS = ares_android.h                        \
+  ares_data.h				\
+  ares_getenv.h				\
+  ares_inet_net_pton.h			\
+  ares_iphlpapi.h			\
+  ares_ipv6.h				\
+  ares_library_init.h			\
+  ares_llist.h				\
+  ares_nowarn.h				\
+  ares_platform.h			\
+  ares_private.h			\
+  ares_strcasecmp.h			\
+  ares_strdup.h				\
+  ares_strsplit.h			\
+  ares_writev.h				\
+  bitncmp.h				\
+  ares_setup.h				\
+  setup_once.h
+
+
diff --git a/deps/cares/src/lib/ares__addrinfo2hostent.c b/deps/cares/src/lib/ares__addrinfo2hostent.c
new file mode 100644
index 0000000000000000000000000000000000000000..efb145cd11bcafb5f5269155c06f65f3166f20e1
--- /dev/null
+++ b/deps/cares/src/lib/ares__addrinfo2hostent.c
@@ -0,0 +1,266 @@
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ * Copyright 2005 Dominick Meglio
+ * Copyright (C) 2019 by Andrew Selivanov
+ * Copyright (C) 2021 by Brad House
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#include "ares_setup.h"
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#include "ares_nameser.h"
+
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+
+#ifdef HAVE_LIMITS_H
+#  include <limits.h>
+#endif
+
+#include "ares.h"
+#include "ares_dns.h"
+#include "ares_inet_net_pton.h"
+#include "ares_private.h"
+
+int ares__addrinfo2hostent(const struct ares_addrinfo *ai, int family,
+                           struct hostent **host)
+{
+  struct ares_addrinfo_node *next;
+  struct ares_addrinfo_cname *next_cname;
+  char **aliases = NULL;
+  char *addrs = NULL;
+  int naliases = 0, naddrs = 0, alias = 0, i;
+
+  if (ai == NULL || host == NULL)
+    return ARES_EBADQUERY;
+
+  *host = ares_malloc(sizeof(**host));
+  if (!(*host))
+    {
+      goto enomem;
+    }
+  memset(*host, 0, sizeof(**host));
+
+  /* Use the first node of the response as the family, since hostent can only
+   * represent one family.  We assume getaddrinfo() returned a sorted list if
+   * the user requested AF_UNSPEC. */
+  if (family == AF_UNSPEC && ai->nodes)
+    family = ai->nodes->ai_family;
+
+  next = ai->nodes;
+  while (next)
+    {
+      if(next->ai_family == family)
+        {
+          ++naddrs;
+        }
+      next = next->ai_next;
+    }
+
+  next_cname = ai->cnames;
+  while (next_cname)
+    {
+      if(next_cname->alias)
+        ++naliases;
+      next_cname = next_cname->next;
+    }
+
+  aliases = ares_malloc((naliases + 1) * sizeof(char *));
+  if (!aliases)
+    {
+      goto enomem;
+    }
+  (*host)->h_aliases = aliases;
+  memset(aliases, 0, (naliases + 1) * sizeof(char *));
+
+  if (naliases)
+    {
+      next_cname = ai->cnames;
+      while (next_cname)
+        {
+          if(next_cname->alias) {
+            aliases[alias] = ares_strdup(next_cname->alias);
+            if (!aliases[alias]) {
+              goto enomem;
+            }
+            alias++;
+          }
+          next_cname = next_cname->next;
+        }
+    }
+
+
+  (*host)->h_addr_list = ares_malloc((naddrs + 1) * sizeof(char *));
+  if (!(*host)->h_addr_list)
+    {
+      goto enomem;
+    }
+
+  memset((*host)->h_addr_list, 0, (naddrs + 1) * sizeof(char *));
+
+  if (ai->cnames)
+    {
+      (*host)->h_name = ares_strdup(ai->cnames->name);
+      if ((*host)->h_name == NULL && ai->cnames->name)
+        {
+          goto enomem;
+        }
+    }
+  else
+    {
+      (*host)->h_name = ares_strdup(ai->name);
+      if ((*host)->h_name == NULL && ai->name)
+        {
+          goto enomem;
+        }
+    }
+
+  (*host)->h_addrtype = family;
+  (*host)->h_length = (family == AF_INET)?
+     sizeof(struct in_addr):sizeof(struct ares_in6_addr);
+
+  if (naddrs)
+    {
+      addrs = ares_malloc(naddrs * (*host)->h_length);
+      if (!addrs)
+        {
+          goto enomem;
+        }
+
+      i = 0;
+      next = ai->nodes;
+      while (next)
+        {
+          if(next->ai_family == family)
+            {
+              (*host)->h_addr_list[i] = addrs + (i * (*host)->h_length);
+              if (family == AF_INET6)
+                {
+                  memcpy((*host)->h_addr_list[i],
+                     &(CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr)->sin6_addr),
+                     (*host)->h_length);
+                }
+              else
+                {
+                  memcpy((*host)->h_addr_list[i],
+                     &(CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr)->sin_addr),
+                     (*host)->h_length);
+                }
+              ++i;
+            }
+          next = next->ai_next;
+        }
+
+      if (i == 0)
+        {
+          ares_free(addrs);
+        }
+    }
+
+  if (naddrs == 0 && naliases == 0)
+    {
+      ares_free_hostent(*host);
+      *host = NULL;
+      return ARES_ENODATA;
+    }
+
+  return ARES_SUCCESS;
+
+enomem:
+  ares_free_hostent(*host);
+  *host = NULL;
+  return ARES_ENOMEM;
+}
+
+
+int ares__addrinfo2addrttl(const struct ares_addrinfo *ai, int family,
+                           int req_naddrttls, struct ares_addrttl *addrttls,
+                           struct ares_addr6ttl *addr6ttls, int *naddrttls)
+{
+  struct ares_addrinfo_node *next;
+  struct ares_addrinfo_cname *next_cname;
+  int cname_ttl = INT_MAX;
+
+  if (family != AF_INET && family != AF_INET6)
+    return ARES_EBADQUERY;
+
+  if (ai == NULL || naddrttls == NULL)
+    return ARES_EBADQUERY;
+
+  if (family == AF_INET && addrttls == NULL)
+    return ARES_EBADQUERY;
+
+  if (family == AF_INET6 && addr6ttls == NULL)
+    return ARES_EBADQUERY;
+
+  if (req_naddrttls == 0)
+    return ARES_EBADQUERY;
+
+  *naddrttls = 0;
+
+  next_cname = ai->cnames;
+  while (next_cname)
+    {
+      if(next_cname->ttl < cname_ttl)
+        cname_ttl = next_cname->ttl;
+      next_cname = next_cname->next;
+    }
+
+  next = ai->nodes;
+  while (next)
+    {
+      if(next->ai_family == family)
+        {
+          if (*naddrttls < req_naddrttls)
+            {
+                if (family == AF_INET6)
+                  {
+                    if(next->ai_ttl > cname_ttl)
+                      addr6ttls[*naddrttls].ttl = cname_ttl;
+                    else
+                      addr6ttls[*naddrttls].ttl = next->ai_ttl;
+
+                    memcpy(&addr6ttls[*naddrttls].ip6addr,
+                           &(CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr)->sin6_addr),
+                           sizeof(struct ares_in6_addr));
+                  }
+                else
+                  {
+                    if(next->ai_ttl > cname_ttl)
+                      addrttls[*naddrttls].ttl = cname_ttl;
+                    else
+                      addrttls[*naddrttls].ttl = next->ai_ttl;
+                    memcpy(&addrttls[*naddrttls].ipaddr,
+                           &(CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr)->sin_addr),
+                           sizeof(struct in_addr));
+                  }
+                (*naddrttls)++;
+             }
+        }
+      next = next->ai_next;
+    }
+
+  return ARES_SUCCESS;
+}
+
diff --git a/deps/cares/src/lib/ares__addrinfo_localhost.c b/deps/cares/src/lib/ares__addrinfo_localhost.c
new file mode 100644
index 0000000000000000000000000000000000000000..7940ecdae7df3dd4e85b91dae070aca3757ee46e
--- /dev/null
+++ b/deps/cares/src/lib/ares__addrinfo_localhost.c
@@ -0,0 +1,240 @@
+/* Copyright (C) 2021
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#include "ares_setup.h"
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#if defined(_WIN32) && defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0600
+#include <ws2ipdef.h>
+#include <iphlpapi.h>
+#endif
+
+#include "ares.h"
+#include "ares_inet_net_pton.h"
+#include "ares_nowarn.h"
+#include "ares_private.h"
+
+int ares_append_ai_node(int aftype,
+                        unsigned short port,
+                        int ttl,
+                        const void *adata,
+                        struct ares_addrinfo_node **nodes)
+{
+  struct ares_addrinfo_node *node;
+
+  node = ares__append_addrinfo_node(nodes);
+  if (!node)
+    {
+      return ARES_ENOMEM;
+    }
+
+  memset(node, 0, sizeof(*node));
+
+  if (aftype == AF_INET)
+    {
+      struct sockaddr_in *sin = ares_malloc(sizeof(*sin));
+      if (!sin)
+        {
+          return ARES_ENOMEM;
+        }
+
+      memset(sin, 0, sizeof(*sin));
+      memcpy(&sin->sin_addr.s_addr, adata, sizeof(sin->sin_addr.s_addr));
+      sin->sin_family = AF_INET;
+      sin->sin_port = htons(port);
+
+      node->ai_addr = (struct sockaddr *)sin;
+      node->ai_family = AF_INET;
+      node->ai_addrlen = sizeof(*sin);
+      node->ai_addr = (struct sockaddr *)sin;
+      node->ai_ttl = ttl;
+    }
+
+  if (aftype == AF_INET6)
+    {
+      struct sockaddr_in6 *sin6 = ares_malloc(sizeof(*sin6));
+      if (!sin6)
+        {
+          return ARES_ENOMEM;
+        }
+
+      memset(sin6, 0, sizeof(*sin6));
+      memcpy(&sin6->sin6_addr.s6_addr, adata, sizeof(sin6->sin6_addr.s6_addr));
+      sin6->sin6_family = AF_INET6;
+      sin6->sin6_port = htons(port);
+
+      node->ai_addr = (struct sockaddr *)sin6;
+      node->ai_family = AF_INET6;
+      node->ai_addrlen = sizeof(*sin6);
+      node->ai_addr = (struct sockaddr *)sin6;
+      node->ai_ttl = ttl;
+    }
+
+  return ARES_SUCCESS;
+}
+
+
+static int ares__default_loopback_addrs(int aftype,
+                                        unsigned short port,
+                                        struct ares_addrinfo_node **nodes)
+{
+  int status = ARES_SUCCESS;
+
+  if (aftype == AF_UNSPEC || aftype == AF_INET6)
+    {
+      struct ares_in6_addr addr6;
+      ares_inet_pton(AF_INET6, "::1", &addr6);
+      status = ares_append_ai_node(AF_INET6, port, 0, &addr6, nodes);
+      if (status != ARES_SUCCESS)
+        {
+          return status;
+       }
+    }
+
+  if (aftype == AF_UNSPEC || aftype == AF_INET)
+    {
+      struct in_addr addr4;
+      ares_inet_pton(AF_INET, "127.0.0.1", &addr4);
+      status = ares_append_ai_node(AF_INET, port, 0, &addr4, nodes);
+      if (status != ARES_SUCCESS)
+        {
+          return status;
+       }
+    }
+
+  return status;
+}
+
+
+static int ares__system_loopback_addrs(int aftype,
+                                       unsigned short port,
+                                       struct ares_addrinfo_node **nodes)
+{
+#if defined(_WIN32) && defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0600
+  PMIB_UNICASTIPADDRESS_TABLE table;
+  unsigned int i;
+  int status;
+
+  *nodes = NULL;
+
+  if (GetUnicastIpAddressTable(aftype, &table) != NO_ERROR)
+    return ARES_ENOTFOUND;
+
+  for (i=0; i<table->NumEntries; i++)
+    {
+      if (table->Table[i].InterfaceLuid.Info.IfType !=
+          IF_TYPE_SOFTWARE_LOOPBACK)
+        {
+          continue;
+        }
+
+      if (table->Table[i].Address.si_family == AF_INET)
+        {
+          status = ares_append_ai_node(table->Table[i].Address.si_family, port, 0,
+                                       &table->Table[i].Address.Ipv4.sin_addr,
+                                       nodes);
+        }
+      else if (table->Table[i].Address.si_family == AF_INET6)
+        {
+          status = ares_append_ai_node(table->Table[i].Address.si_family, port, 0,
+                                       &table->Table[i].Address.Ipv6.sin6_addr,
+                                       nodes);
+        }
+      else
+        {
+          /* Ignore any others */
+          continue;
+        }
+
+      if (status != ARES_SUCCESS)
+        {
+          goto fail;
+        }
+    }
+
+    if (*nodes == NULL)
+      status = ARES_ENOTFOUND;
+
+fail:
+  FreeMibTable(table);
+
+  if (status != ARES_SUCCESS)
+    {
+      ares__freeaddrinfo_nodes(*nodes);
+      *nodes = NULL;
+    }
+
+  return status;
+
+#else
+  (void)aftype;
+  (void)port;
+  (void)nodes;
+  /* Not supported on any other OS at this time */
+  return ARES_ENOTFOUND;
+#endif
+}
+
+
+int ares__addrinfo_localhost(const char *name,
+                             unsigned short port,
+                             const struct ares_addrinfo_hints *hints,
+                             struct ares_addrinfo *ai)
+{
+  struct ares_addrinfo_node *nodes = NULL;
+  int result;
+
+  /* Validate family */
+  switch (hints->ai_family) {
+    case AF_INET:
+    case AF_INET6:
+    case AF_UNSPEC:
+      break;
+    default:
+      return ARES_EBADFAMILY;
+  }
+
+  ai->name = ares_strdup(name);
+  if(!ai->name)
+    {
+      goto enomem;
+    }
+
+  result = ares__system_loopback_addrs(hints->ai_family, port, &nodes);
+
+  if (result == ARES_ENOTFOUND)
+    {
+      result = ares__default_loopback_addrs(hints->ai_family, port, &nodes);
+    }
+
+  ares__addrinfo_cat_nodes(&ai->nodes, nodes);
+
+  return result;
+
+enomem:
+  ares__freeaddrinfo_nodes(nodes);
+  ares_free(ai->name);
+  ai->name = NULL;
+  return ARES_ENOMEM;
+}
diff --git a/deps/cares/src/lib/ares__parse_into_addrinfo.c b/deps/cares/src/lib/ares__parse_into_addrinfo.c
index 7550abab4a40a8aa52f74feee8ff254a87f43b76..4393f04b961270384f72713b9cd709da44749a56 100644
--- a/deps/cares/src/lib/ares__parse_into_addrinfo.c
+++ b/deps/cares/src/lib/ares__parse_into_addrinfo.c
@@ -39,23 +39,20 @@
 #include "ares_dns.h"
 #include "ares_private.h"
 
-int ares__parse_into_addrinfo2(const unsigned char *abuf,
-                               int alen,
-                               char **question_hostname,
-                               struct ares_addrinfo *ai)
+int ares__parse_into_addrinfo(const unsigned char *abuf,
+                              int alen, int cname_only_is_enodata,
+                              unsigned short port,
+                              struct ares_addrinfo *ai)
 {
   unsigned int qdcount, ancount;
   int status, i, rr_type, rr_class, rr_len, rr_ttl;
   int got_a = 0, got_aaaa = 0, got_cname = 0;
   long len;
   const unsigned char *aptr;
+  char *question_hostname = NULL;
   char *hostname, *rr_name = NULL, *rr_data;
   struct ares_addrinfo_cname *cname, *cnames = NULL;
-  struct ares_addrinfo_node *node, *nodes = NULL;
-  struct sockaddr_in *sin;
-  struct sockaddr_in6 *sin6;
-
-  *question_hostname = NULL;
+  struct ares_addrinfo_node *nodes = NULL;
 
   /* Give up if abuf doesn't have room for a header. */
   if (alen < HFIXEDSZ)
@@ -70,15 +67,16 @@ int ares__parse_into_addrinfo2(const unsigned char *abuf,
 
   /* Expand the name from the question, and skip past the question. */
   aptr = abuf + HFIXEDSZ;
-  status = ares__expand_name_for_response(aptr, abuf, alen, question_hostname, &len, 0);
+  status = ares__expand_name_for_response(aptr, abuf, alen, &question_hostname, &len, 0);
   if (status != ARES_SUCCESS)
     return status;
   if (aptr + len + QFIXEDSZ > abuf + alen)
     {
-      return ARES_EBADRESP;
+      status = ARES_EBADRESP;
+      goto failed_stat;
     }
 
-  hostname = *question_hostname;
+  hostname = question_hostname;
 
   aptr += len + QFIXEDSZ;
 
@@ -121,30 +119,9 @@ int ares__parse_into_addrinfo2(const unsigned char *abuf,
             goto failed_stat;
           }  /* LCOV_EXCL_STOP */
 
-          node = ares__append_addrinfo_node(&nodes);
-          if (!node)
-            {
-              status = ARES_ENOMEM;
-              goto failed_stat;
-            }
-
-          sin = ares_malloc(sizeof(struct sockaddr_in));
-          if (!sin)
-            {
-              status = ARES_ENOMEM;
-              goto failed_stat;
-            }
-          memset(sin, 0, sizeof(struct sockaddr_in));
-          memcpy(&sin->sin_addr.s_addr, aptr, sizeof(struct in_addr));
-          sin->sin_family = AF_INET;
-
-          node->ai_addr = (struct sockaddr *)sin;
-          node->ai_family = AF_INET;
-          node->ai_addrlen = sizeof(struct sockaddr_in);
-
-          node->ai_ttl = rr_ttl;
-
-          status = ARES_SUCCESS;
+          status = ares_append_ai_node(AF_INET, port, rr_ttl, aptr, &nodes);
+          if (status != ARES_SUCCESS)
+            goto failed_stat;
         }
       else if (rr_class == C_IN && rr_type == T_AAAA
           && rr_len == sizeof(struct ares_in6_addr)
@@ -157,31 +134,9 @@ int ares__parse_into_addrinfo2(const unsigned char *abuf,
             goto failed_stat;
           }  /* LCOV_EXCL_STOP */
 
-          node = ares__append_addrinfo_node(&nodes);
-          if (!node)
-            {
-              status = ARES_ENOMEM;
-              goto failed_stat;
-            }
-
-          sin6 = ares_malloc(sizeof(struct sockaddr_in6));
-          if (!sin6)
-            {
-              status = ARES_ENOMEM;
-              goto failed_stat;
-            }
-
-          memset(sin6, 0, sizeof(struct sockaddr_in6));
-          memcpy(&sin6->sin6_addr.s6_addr, aptr, sizeof(struct ares_in6_addr));
-          sin6->sin6_family = AF_INET6;
-
-          node->ai_addr = (struct sockaddr *)sin6;
-          node->ai_family = AF_INET6;
-          node->ai_addrlen = sizeof(struct sockaddr_in6);
-
-          node->ai_ttl = rr_ttl;
-
-          status = ARES_SUCCESS;
+          status = ares_append_ai_node(AF_INET6, port, rr_ttl, aptr, &nodes);
+          if (status != ARES_SUCCESS)
+            goto failed_stat;
         }
 
       if (rr_class == C_IN && rr_type == T_CNAME)
@@ -208,10 +163,13 @@ int ares__parse_into_addrinfo2(const unsigned char *abuf,
           cname->ttl = rr_ttl;
           cname->alias = rr_name;
           cname->name = rr_data;
+          rr_name = NULL;
         }
       else
         {
+          /* rr_name is only saved for cname */
           ares_free(rr_name);
+          rr_name = NULL;
         }
 
 
@@ -225,36 +183,47 @@ int ares__parse_into_addrinfo2(const unsigned char *abuf,
 
   if (status == ARES_SUCCESS)
     {
-      ares__addrinfo_cat_nodes(&ai->nodes, nodes);
-      if (got_cname)
+      if (!got_a && !got_aaaa)
         {
-          ares__addrinfo_cat_cnames(&ai->cnames, cnames);
-          return status;
+          if (!got_cname || (got_cname && cname_only_is_enodata))
+            {
+              status = ARES_ENODATA;
+              goto failed_stat;
+            }
+        }
+
+      /* save the question hostname as ai->name */
+      if (ai->name == NULL || strcasecmp(ai->name, question_hostname) != 0)
+        {
+          ares_free(ai->name);
+          ai->name = ares_strdup(question_hostname);
+          if (!ai->name)
+            {
+              status = ARES_ENOMEM;
+              goto failed_stat;
+            }
         }
-      else if (got_a == 0 && got_aaaa == 0)
+
+      if (got_a || got_aaaa)
+        {
+          ares__addrinfo_cat_nodes(&ai->nodes, nodes);
+          nodes = NULL;
+        }
+
+      if (got_cname)
         {
-          /* the check for naliases to be zero is to make sure CNAME responses
-             don't get caught here */
-          status = ARES_ENODATA;
+          ares__addrinfo_cat_cnames(&ai->cnames, cnames);
+          cnames = NULL;
         }
     }
 
+  ares_free(question_hostname);
   return status;
 
 failed_stat:
+  ares_free(question_hostname);
   ares_free(rr_name);
   ares__freeaddrinfo_cnames(cnames);
   ares__freeaddrinfo_nodes(nodes);
   return status;
 }
-
-int ares__parse_into_addrinfo(const unsigned char *abuf,
-                              int alen,
-                              struct ares_addrinfo *ai)
-{
-  int status;
-  char *question_hostname;
-  status = ares__parse_into_addrinfo2(abuf, alen, &question_hostname, ai);
-  ares_free(question_hostname);
-  return status;
-}
diff --git a/deps/cares/src/lib/ares__readaddrinfo.c b/deps/cares/src/lib/ares__readaddrinfo.c
index 2b5bb40c3dd017d54a173f34e115d78c1317af0e..673de87722b37db216481c31fc254ce3b19efafd 100644
--- a/deps/cares/src/lib/ares__readaddrinfo.c
+++ b/deps/cares/src/lib/ares__readaddrinfo.c
@@ -42,11 +42,10 @@ int ares__readaddrinfo(FILE *fp,
   char *txtaddr, *txthost, *txtalias;
   char *aliases[MAX_ALIASES];
   unsigned int i, alias_count;
-  int status;
+  int status = ARES_SUCCESS;
   size_t linesize;
-  ares_sockaddr addr;
   struct ares_addrinfo_cname *cname = NULL, *cnames = NULL;
-  struct ares_addrinfo_node *node = NULL, *nodes = NULL;
+  struct ares_addrinfo_node *nodes = NULL;
   int match_with_alias, match_with_canonical;
   int want_cname = hints->ai_flags & ARES_AI_CANONNAME;
 
@@ -60,6 +59,12 @@ int ares__readaddrinfo(FILE *fp,
       return ARES_EBADFAMILY;
   }
 
+  ai->name = ares_strdup(name);
+  if(!ai->name)
+    {
+      status = ARES_ENOMEM;
+      goto fail;
+    }
 
   while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS)
     {
@@ -163,57 +168,36 @@ int ares__readaddrinfo(FILE *fp,
           continue;
         }
 
-      /* Zero-out 'addr' struct, as there are members that we may not set, especially
-       * for ipv6.  We don't want garbage data */
-      memset(&addr, 0, sizeof(addr));
-
       /*
        * Convert address string to network address for the requested families.
        * Actual address family possible values are AF_INET and AF_INET6 only.
        */
       if ((hints->ai_family == AF_INET) || (hints->ai_family == AF_UNSPEC))
         {
-          addr.sa4.sin_port = htons(port);
-          if (ares_inet_pton(AF_INET, txtaddr, &addr.sa4.sin_addr) > 0)
+          struct in_addr addr4;
+          if (ares_inet_pton(AF_INET, txtaddr, &addr4) == 1)
             {
-              node = ares__append_addrinfo_node(&nodes);
-              if(!node)
-                {
-                  goto enomem;
-                }
-
-              node->ai_family = addr.sa.sa_family = AF_INET;
-              node->ai_addrlen = sizeof(addr.sa4);
-              node->ai_addr = ares_malloc(sizeof(addr.sa4));
-              if (!node->ai_addr)
+              status = ares_append_ai_node(AF_INET, port, 0, &addr4, &nodes);
+              if (status != ARES_SUCCESS)
                 {
-                  goto enomem;
+                  goto fail;
                 }
-              memcpy(node->ai_addr, &addr.sa4, sizeof(addr.sa4));
             }
         }
       if ((hints->ai_family == AF_INET6) || (hints->ai_family == AF_UNSPEC))
         {
-          addr.sa6.sin6_port = htons(port);
-          if (ares_inet_pton(AF_INET6, txtaddr, &addr.sa6.sin6_addr) > 0)
+          struct ares_in6_addr addr6;
+          if (ares_inet_pton(AF_INET6, txtaddr, &addr6) == 1)
             {
-              node = ares__append_addrinfo_node(&nodes);
-              if (!node)
+              status = ares_append_ai_node(AF_INET6, port, 0, &addr6, &nodes);
+              if (status != ARES_SUCCESS)
                 {
-                  goto enomem;
+                  goto fail;
                 }
-
-              node->ai_family = addr.sa.sa_family = AF_INET6;
-              node->ai_addrlen = sizeof(addr.sa6);
-              node->ai_addr = ares_malloc(sizeof(addr.sa6));
-              if (!node->ai_addr)
-                {
-                  goto enomem;
-                }
-              memcpy(node->ai_addr, &addr.sa6, sizeof(addr.sa6));
             }
         }
-      if (!node)
+
+      if (status != ARES_SUCCESS)
         /* Ignore line if invalid address string for the requested family. */
         continue;
 
@@ -224,7 +208,8 @@ int ares__readaddrinfo(FILE *fp,
               cname = ares__append_addrinfo_cname(&cnames);
               if (!cname)
                 {
-                  goto enomem;
+                  status = ARES_ENOMEM;
+                  goto fail;
                 }
               cname->alias = ares_strdup(aliases[i]);
               cname->name = ares_strdup(txthost);
@@ -235,7 +220,8 @@ int ares__readaddrinfo(FILE *fp,
               cname = ares__append_addrinfo_cname(&cnames);
               if (!cname)
                 {
-                  goto enomem;
+                  status = ARES_ENOMEM;
+                  goto fail;
                 }
               cname->name = ares_strdup(txthost);
             }
@@ -245,20 +231,21 @@ int ares__readaddrinfo(FILE *fp,
   /* Last read failed. */
   if (status == ARES_ENOMEM)
     {
-      goto enomem;
+      goto fail;
     }
 
   /* Free line buffer. */
   ares_free(line);
-
   ares__addrinfo_cat_cnames(&ai->cnames, cnames);
   ares__addrinfo_cat_nodes(&ai->nodes, nodes);
 
-  return node ? ARES_SUCCESS : ARES_ENOTFOUND;
+  return nodes ? ARES_SUCCESS : ARES_ENOTFOUND;
 
-enomem:
+fail:
   ares_free(line);
   ares__freeaddrinfo_cnames(cnames);
   ares__freeaddrinfo_nodes(nodes);
-  return ARES_ENOMEM;
+  ares_free(ai->name);
+  ai->name = NULL;
+  return status;
 }
diff --git a/deps/cares/src/lib/ares__sortaddrinfo.c b/deps/cares/src/lib/ares__sortaddrinfo.c
index 6e56cc902304ca2a6ab9e8e6bbf92e8c4f4259bd..3f050cad00fbddee6d5017ca47f829034e083979 100644
--- a/deps/cares/src/lib/ares__sortaddrinfo.c
+++ b/deps/cares/src/lib/ares__sortaddrinfo.c
@@ -301,11 +301,15 @@ static int rfc6724_compare(const void *ptr1, const void *ptr2)
     }
 
   /* Rule 2: Prefer matching scope. */
-  scope_src1 = get_scope(&a1->src_addr.sa);
+  scope_src1 = ARES_IPV6_ADDR_SCOPE_NODELOCAL;
+  if (a1->has_src_addr)
+    scope_src1 = get_scope(&a1->src_addr.sa);
   scope_dst1 = get_scope(a1->ai->ai_addr);
   scope_match1 = (scope_src1 == scope_dst1);
 
-  scope_src2 = get_scope(&a2->src_addr.sa);
+  scope_src2 = ARES_IPV6_ADDR_SCOPE_NODELOCAL;
+  if (a2->has_src_addr)
+    scope_src2 = get_scope(&a2->src_addr.sa);
   scope_dst2 = get_scope(a2->ai->ai_addr);
   scope_match2 = (scope_src2 == scope_dst2);
 
@@ -319,11 +323,15 @@ static int rfc6724_compare(const void *ptr1, const void *ptr2)
   /* Rule 4: Prefer home addresses.  */
 
   /* Rule 5: Prefer matching label. */
-  label_src1 = get_label(&a1->src_addr.sa);
+  label_src1 = 1;
+  if (a1->has_src_addr)
+    label_src1 = get_label(&a1->src_addr.sa);
   label_dst1 = get_label(a1->ai->ai_addr);
   label_match1 = (label_src1 == label_dst1);
 
-  label_src2 = get_label(&a2->src_addr.sa);
+  label_src2 = 1;
+  if (a2->has_src_addr)
+    label_src2 = get_label(&a2->src_addr.sa);
   label_dst2 = get_label(a2->ai->ai_addr);
   label_match2 = (label_src2 == label_dst2);
 
diff --git a/deps/cares/src/lib/ares_config.h.cmake b/deps/cares/src/lib/ares_config.h.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..fddb7853514bbe85b54ba78230dee5426075ae31
--- /dev/null
+++ b/deps/cares/src/lib/ares_config.h.cmake
@@ -0,0 +1,432 @@
+/* Generated from ares_config.h.cmake */
+
+/* Define if building universal (internal helper macro) */
+#undef AC_APPLE_UNIVERSAL_BUILD
+
+/* define this if ares is built for a big endian system */
+#undef ARES_BIG_ENDIAN
+
+/* when building as static part of libcurl */
+#undef BUILDING_LIBCURL
+
+/* Defined for build that exposes internal static functions for testing. */
+#undef CARES_EXPOSE_STATICS
+
+/* Defined for build with symbol hiding. */
+#undef CARES_SYMBOL_HIDING
+
+/* Definition to make a library symbol externally visible. */
+#undef CARES_SYMBOL_SCOPE_EXTERN
+
+/* Use resolver library to configure cares */
+#cmakedefine CARES_USE_LIBRESOLV
+
+/* if a /etc/inet dir is being used */
+#undef ETC_INET
+
+/* Define to the type of arg 2 for gethostname. */
+#define GETHOSTNAME_TYPE_ARG2 @GETHOSTNAME_TYPE_ARG2@
+
+/* Define to the type qualifier of arg 1 for getnameinfo. */
+#define GETNAMEINFO_QUAL_ARG1 @GETNAMEINFO_QUAL_ARG1@
+
+/* Define to the type of arg 1 for getnameinfo. */
+#define GETNAMEINFO_TYPE_ARG1 @GETNAMEINFO_TYPE_ARG1@
+
+/* Define to the type of arg 2 for getnameinfo. */
+#define GETNAMEINFO_TYPE_ARG2 @GETNAMEINFO_TYPE_ARG2@
+
+/* Define to the type of args 4 and 6 for getnameinfo. */
+#define GETNAMEINFO_TYPE_ARG46 @GETNAMEINFO_TYPE_ARG46@
+
+/* Define to the type of arg 7 for getnameinfo. */
+#define GETNAMEINFO_TYPE_ARG7 @GETNAMEINFO_TYPE_ARG7@
+
+/* Specifies the number of arguments to getservbyport_r */
+#define GETSERVBYPORT_R_ARGS @GETSERVBYPORT_R_ARGS@
+
+/* Specifies the number of arguments to getservbyname_r */
+#define GETSERVBYNAME_R_ARGS @GETSERVBYNAME_R_ARGS@
+
+/* Define to 1 if you have AF_INET6. */
+#cmakedefine HAVE_AF_INET6
+
+/* Define to 1 if you have the <arpa/inet.h> header file. */
+#cmakedefine HAVE_ARPA_INET_H
+
+/* Define to 1 if you have the <arpa/nameser_compat.h> header file. */
+#cmakedefine HAVE_ARPA_NAMESER_COMPAT_H
+
+/* Define to 1 if you have the <arpa/nameser.h> header file. */
+#cmakedefine HAVE_ARPA_NAMESER_H
+
+/* Define to 1 if you have the <assert.h> header file. */
+#cmakedefine HAVE_ASSERT_H
+
+/* Define to 1 if you have the `bitncmp' function. */
+#cmakedefine HAVE_BITNCMP
+
+/* Define to 1 if bool is an available type. */
+#cmakedefine HAVE_BOOL_T
+
+/* Define to 1 if you have the clock_gettime function and monotonic timer. */
+#cmakedefine HAVE_CLOCK_GETTIME_MONOTONIC
+
+/* Define to 1 if you have the closesocket function. */
+#cmakedefine HAVE_CLOSESOCKET
+
+/* Define to 1 if you have the CloseSocket camel case function. */
+#cmakedefine HAVE_CLOSESOCKET_CAMEL
+
+/* Define to 1 if you have the connect function. */
+#cmakedefine HAVE_CONNECT
+
+/* define if the compiler supports basic C++11 syntax */
+#cmakedefine HAVE_CXX11
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#cmakedefine HAVE_DLFCN_H
+
+/* Define to 1 if you have the <errno.h> header file. */
+#cmakedefine HAVE_ERRNO_H
+
+/* Define to 1 if you have the fcntl function. */
+#cmakedefine HAVE_FCNTL
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#cmakedefine HAVE_FCNTL_H
+
+/* Define to 1 if you have a working fcntl O_NONBLOCK function. */
+#cmakedefine HAVE_FCNTL_O_NONBLOCK
+
+/* Define to 1 if you have the freeaddrinfo function. */
+#cmakedefine HAVE_FREEADDRINFO
+
+/* Define to 1 if you have a working getaddrinfo function. */
+#cmakedefine HAVE_GETADDRINFO
+
+/* Define to 1 if the getaddrinfo function is threadsafe. */
+#cmakedefine HAVE_GETADDRINFO_THREADSAFE
+
+/* Define to 1 if you have the getenv function. */
+#cmakedefine HAVE_GETENV
+
+/* Define to 1 if you have the gethostbyaddr function. */
+#cmakedefine HAVE_GETHOSTBYADDR
+
+/* Define to 1 if you have the gethostbyname function. */
+#cmakedefine HAVE_GETHOSTBYNAME
+
+/* Define to 1 if you have the gethostname function. */
+#cmakedefine HAVE_GETHOSTNAME
+
+/* Define to 1 if you have the getnameinfo function. */
+#cmakedefine HAVE_GETNAMEINFO
+
+/* Define to 1 if you have the getservbyport_r function. */
+#cmakedefine HAVE_GETSERVBYPORT_R
+
+/* Define to 1 if you have the getservbyname_r function. */
+#cmakedefine HAVE_GETSERVBYNAME_R
+
+/* Define to 1 if you have the `gettimeofday' function. */
+#cmakedefine HAVE_GETTIMEOFDAY
+
+/* Define to 1 if you have the `if_indextoname' function. */
+#cmakedefine HAVE_IF_INDEXTONAME
+
+/* Define to 1 if you have a IPv6 capable working inet_net_pton function. */
+#cmakedefine HAVE_INET_NET_PTON
+
+/* Define to 1 if you have a IPv6 capable working inet_ntop function. */
+#cmakedefine HAVE_INET_NTOP
+
+/* Define to 1 if you have a IPv6 capable working inet_pton function. */
+#cmakedefine HAVE_INET_PTON
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#cmakedefine HAVE_INTTYPES_H
+
+/* Define to 1 if you have the ioctl function. */
+#cmakedefine HAVE_IOCTL
+
+/* Define to 1 if you have the ioctlsocket function. */
+#cmakedefine HAVE_IOCTLSOCKET
+
+/* Define to 1 if you have the IoctlSocket camel case function. */
+#cmakedefine HAVE_IOCTLSOCKET_CAMEL
+
+/* Define to 1 if you have a working IoctlSocket camel case FIONBIO function.
+   */
+#cmakedefine HAVE_IOCTLSOCKET_CAMEL_FIONBIO
+
+/* Define to 1 if you have a working ioctlsocket FIONBIO function. */
+#cmakedefine HAVE_IOCTLSOCKET_FIONBIO
+
+/* Define to 1 if you have a working ioctl FIONBIO function. */
+#cmakedefine HAVE_IOCTL_FIONBIO
+
+/* Define to 1 if you have a working ioctl SIOCGIFADDR function. */
+#cmakedefine HAVE_IOCTL_SIOCGIFADDR
+
+/* Define to 1 if you have the `resolve' library (-lresolve). */
+#cmakedefine HAVE_LIBRESOLV
+
+/* Define to 1 if you have the <limits.h> header file. */
+#cmakedefine HAVE_LIMITS_H
+
+/* if your compiler supports LL */
+#cmakedefine HAVE_LL
+
+/* Define to 1 if the compiler supports the 'long long' data type. */
+#cmakedefine HAVE_LONGLONG
+
+/* Define to 1 if you have the malloc.h header file. */
+#cmakedefine HAVE_MALLOC_H
+
+/* Define to 1 if you have the memory.h header file. */
+#cmakedefine HAVE_MEMORY_H
+
+/* Define to 1 if you have the MSG_NOSIGNAL flag. */
+#cmakedefine HAVE_MSG_NOSIGNAL
+
+/* Define to 1 if you have the <netdb.h> header file. */
+#cmakedefine HAVE_NETDB_H
+
+/* Define to 1 if you have the <netinet/in.h> header file. */
+#cmakedefine HAVE_NETINET_IN_H
+
+/* Define to 1 if you have the <netinet/tcp.h> header file. */
+#cmakedefine HAVE_NETINET_TCP_H
+
+/* Define to 1 if you have the <net/if.h> header file. */
+#cmakedefine HAVE_NET_IF_H
+
+/* Define to 1 if you have PF_INET6. */
+#cmakedefine HAVE_PF_INET6
+
+/* Define to 1 if you have the recv function. */
+#cmakedefine HAVE_RECV
+
+/* Define to 1 if you have the recvfrom function. */
+#cmakedefine HAVE_RECVFROM
+
+/* Define to 1 if you have the send function. */
+#cmakedefine HAVE_SEND
+
+/* Define to 1 if you have the setsockopt function. */
+#cmakedefine HAVE_SETSOCKOPT
+
+/* Define to 1 if you have a working setsockopt SO_NONBLOCK function. */
+#cmakedefine HAVE_SETSOCKOPT_SO_NONBLOCK
+
+/* Define to 1 if you have the <signal.h> header file. */
+#cmakedefine HAVE_SIGNAL_H
+
+/* Define to 1 if sig_atomic_t is an available typedef. */
+#cmakedefine HAVE_SIG_ATOMIC_T
+
+/* Define to 1 if sig_atomic_t is already defined as volatile. */
+#cmakedefine HAVE_SIG_ATOMIC_T_VOLATILE
+
+/* Define to 1 if your struct sockaddr_in6 has sin6_scope_id. */
+#cmakedefine HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
+
+/* Define to 1 if you have the socket function. */
+#cmakedefine HAVE_SOCKET
+
+/* Define to 1 if you have the <socket.h> header file. */
+#cmakedefine HAVE_SOCKET_H
+
+/* Define to 1 if you have the <stdbool.h> header file. */
+#cmakedefine HAVE_STDBOOL_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#cmakedefine HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#cmakedefine HAVE_STDLIB_H
+
+/* Define to 1 if you have the strcasecmp function. */
+#cmakedefine HAVE_STRCASECMP
+
+/* Define to 1 if you have the strcmpi function. */
+#cmakedefine HAVE_STRCMPI
+
+/* Define to 1 if you have the strdup function. */
+#cmakedefine HAVE_STRDUP
+
+/* Define to 1 if you have the stricmp function. */
+#cmakedefine HAVE_STRICMP
+
+/* Define to 1 if you have the <strings.h> header file. */
+#cmakedefine HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#cmakedefine HAVE_STRING_H
+
+/* Define to 1 if you have the strncasecmp function. */
+#cmakedefine HAVE_STRNCASECMP
+
+/* Define to 1 if you have the strncmpi function. */
+#cmakedefine HAVE_STRNCMPI
+
+/* Define to 1 if you have the strnicmp function. */
+#cmakedefine HAVE_STRNICMP
+
+/* Define to 1 if you have the <stropts.h> header file. */
+#cmakedefine HAVE_STROPTS_H
+
+/* Define to 1 if you have struct addrinfo. */
+#cmakedefine HAVE_STRUCT_ADDRINFO
+
+/* Define to 1 if you have struct in6_addr. */
+#cmakedefine HAVE_STRUCT_IN6_ADDR
+
+/* Define to 1 if you have struct sockaddr_in6. */
+#cmakedefine HAVE_STRUCT_SOCKADDR_IN6
+
+/* if struct sockaddr_storage is defined */
+#cmakedefine HAVE_STRUCT_SOCKADDR_STORAGE
+
+/* Define to 1 if you have the timeval struct. */
+#cmakedefine HAVE_STRUCT_TIMEVAL
+
+/* Define to 1 if you have the <sys/ioctl.h> header file. */
+#cmakedefine HAVE_SYS_IOCTL_H
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#cmakedefine HAVE_SYS_PARAM_H
+
+/* Define to 1 if you have the <sys/select.h> header file. */
+#cmakedefine HAVE_SYS_SELECT_H
+
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#cmakedefine HAVE_SYS_SOCKET_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#cmakedefine HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#cmakedefine HAVE_SYS_TIME_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#cmakedefine HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <sys/uio.h> header file. */
+#cmakedefine HAVE_SYS_UIO_H
+
+/* Define to 1 if you have the <time.h> header file. */
+#cmakedefine HAVE_TIME_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#cmakedefine HAVE_UNISTD_H
+
+/* Define to 1 if you have the windows.h header file. */
+#cmakedefine HAVE_WINDOWS_H
+
+/* Define to 1 if you have the winsock2.h header file. */
+#cmakedefine HAVE_WINSOCK2_H
+
+/* Define to 1 if you have the winsock.h header file. */
+#cmakedefine HAVE_WINSOCK_H
+
+/* Define to 1 if you have the writev function. */
+#cmakedefine HAVE_WRITEV
+
+/* Define to 1 if you have the ws2tcpip.h header file. */
+#cmakedefine HAVE_WS2TCPIP_H
+
+/* Define to 1 if you have the __system_property_get function */
+#cmakedefine HAVE___SYSTEM_PROPERTY_GET
+
+/* Define to 1 if you need the malloc.h header file even with stdlib.h */
+#cmakedefine NEED_MALLOC_H
+
+/* Define to 1 if you need the memory.h header file even with stdlib.h */
+#cmakedefine NEED_MEMORY_H
+
+/* a suitable file/device to read random data from */
+#cmakedefine CARES_RANDOM_FILE "@CARES_RANDOM_FILE@"
+
+/* Define to the type qualifier pointed by arg 5 for recvfrom. */
+#define RECVFROM_QUAL_ARG5 @RECVFROM_QUAL_ARG5@
+
+/* Define to the type of arg 1 for recvfrom. */
+#define RECVFROM_TYPE_ARG1 @RECVFROM_TYPE_ARG1@
+
+/* Define to the type pointed by arg 2 for recvfrom. */
+#define RECVFROM_TYPE_ARG2 @RECVFROM_TYPE_ARG2@
+
+/* Define to 1 if the type pointed by arg 2 for recvfrom is void. */
+#cmakedefine01 RECVFROM_TYPE_ARG2_IS_VOID
+
+/* Define to the type of arg 3 for recvfrom. */
+#define RECVFROM_TYPE_ARG3 @RECVFROM_TYPE_ARG3@
+
+/* Define to the type of arg 4 for recvfrom. */
+#define RECVFROM_TYPE_ARG4 @RECVFROM_TYPE_ARG4@
+
+/* Define to the type pointed by arg 5 for recvfrom. */
+#define RECVFROM_TYPE_ARG5 @RECVFROM_TYPE_ARG5@
+
+/* Define to 1 if the type pointed by arg 5 for recvfrom is void. */
+#cmakedefine01 RECVFROM_TYPE_ARG5_IS_VOID
+
+/* Define to the type pointed by arg 6 for recvfrom. */
+#define RECVFROM_TYPE_ARG6 @RECVFROM_TYPE_ARG6@
+
+/* Define to 1 if the type pointed by arg 6 for recvfrom is void. */
+#cmakedefine01 RECVFROM_TYPE_ARG6_IS_VOID
+
+/* Define to the function return type for recvfrom. */
+#define RECVFROM_TYPE_RETV @RECVFROM_TYPE_RETV@
+
+/* Define to the type of arg 1 for recv. */
+#define RECV_TYPE_ARG1 @RECV_TYPE_ARG1@
+
+/* Define to the type of arg 2 for recv. */
+#define RECV_TYPE_ARG2 @RECV_TYPE_ARG2@
+
+/* Define to the type of arg 3 for recv. */
+#define RECV_TYPE_ARG3 @RECV_TYPE_ARG3@
+
+/* Define to the type of arg 4 for recv. */
+#define RECV_TYPE_ARG4 @RECV_TYPE_ARG4@
+
+/* Define to the function return type for recv. */
+#define RECV_TYPE_RETV @RECV_TYPE_RETV@
+
+/* Define as the return type of signal handlers (`int' or `void'). */
+#define RETSIGTYPE @RETSIGTYPE@
+
+/* Define to the type qualifier of arg 2 for send. */
+#define SEND_QUAL_ARG2 @SEND_QUAL_ARG2@
+
+/* Define to the type of arg 1 for send. */
+#define SEND_TYPE_ARG1 @SEND_TYPE_ARG1@
+
+/* Define to the type of arg 2 for send. */
+#define SEND_TYPE_ARG2 @SEND_TYPE_ARG2@
+
+/* Define to the type of arg 3 for send. */
+#define SEND_TYPE_ARG3 @SEND_TYPE_ARG3@
+
+/* Define to the type of arg 4 for send. */
+#define SEND_TYPE_ARG4 @SEND_TYPE_ARG4@
+
+/* Define to the function return type for send. */
+#define SEND_TYPE_RETV @SEND_TYPE_RETV@
+
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
+#cmakedefine TIME_WITH_SYS_TIME
+
+/* Define to disable non-blocking sockets. */
+#undef USE_BLOCKING_SOCKETS
+
+/* Define to avoid automatic inclusion of winsock.h */
+#undef WIN32_LEAN_AND_MEAN
+
+/* Type to use in place of in_addr_t when system does not provide it. */
+#undef in_addr_t
+
diff --git a/deps/cares/src/lib/ares_config.h.in b/deps/cares/src/lib/ares_config.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..b260c08fe62bd7724cfca52330d95dfe44e62e0b
--- /dev/null
+++ b/deps/cares/src/lib/ares_config.h.in
@@ -0,0 +1,502 @@
+/* src/lib/ares_config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define if building universal (internal helper macro) */
+#undef AC_APPLE_UNIVERSAL_BUILD
+
+/* define this if ares is built for a big endian system */
+#undef ARES_BIG_ENDIAN
+
+/* Defined for build that exposes internal static functions for testing. */
+#undef CARES_EXPOSE_STATICS
+
+/* a suitable file/device to read random data from */
+#undef CARES_RANDOM_FILE
+
+/* Defined for build with symbol hiding. */
+#undef CARES_SYMBOL_HIDING
+
+/* Definition to make a library symbol externally visible. */
+#undef CARES_SYMBOL_SCOPE_EXTERN
+
+/* the signed version of size_t */
+#undef CARES_TYPEOF_ARES_SSIZE_T
+
+/* Use resolver library to configure cares */
+#undef CARES_USE_LIBRESOLV
+
+/* if a /etc/inet dir is being used */
+#undef ETC_INET
+
+/* Define to the type of arg 2 for gethostname. */
+#undef GETHOSTNAME_TYPE_ARG2
+
+/* Define to the type qualifier of arg 1 for getnameinfo. */
+#undef GETNAMEINFO_QUAL_ARG1
+
+/* Define to the type of arg 1 for getnameinfo. */
+#undef GETNAMEINFO_TYPE_ARG1
+
+/* Define to the type of arg 2 for getnameinfo. */
+#undef GETNAMEINFO_TYPE_ARG2
+
+/* Define to the type of args 4 and 6 for getnameinfo. */
+#undef GETNAMEINFO_TYPE_ARG46
+
+/* Define to the type of arg 7 for getnameinfo. */
+#undef GETNAMEINFO_TYPE_ARG7
+
+/* Specifies the number of arguments to getservbyport_r */
+#undef GETSERVBYPORT_R_ARGS
+
+/* Specifies the size of the buffer to pass to getservbyport_r */
+#undef GETSERVBYPORT_R_BUFSIZE
+
+/* Define to 1 if you have AF_INET6. */
+#undef HAVE_AF_INET6
+
+/* Define to 1 if you have the <arpa/inet.h> header file. */
+#undef HAVE_ARPA_INET_H
+
+/* Define to 1 if you have the <arpa/nameser_compat.h> header file. */
+#undef HAVE_ARPA_NAMESER_COMPAT_H
+
+/* Define to 1 if you have the <arpa/nameser.h> header file. */
+#undef HAVE_ARPA_NAMESER_H
+
+/* Define to 1 if you have the <assert.h> header file. */
+#undef HAVE_ASSERT_H
+
+/* Define to 1 if you have the `bitncmp' function. */
+#undef HAVE_BITNCMP
+
+/* Define to 1 if bool is an available type. */
+#undef HAVE_BOOL_T
+
+/* Define to 1 if you have the clock_gettime function and monotonic timer. */
+#undef HAVE_CLOCK_GETTIME_MONOTONIC
+
+/* Define to 1 if you have the closesocket function. */
+#undef HAVE_CLOSESOCKET
+
+/* Define to 1 if you have the CloseSocket camel case function. */
+#undef HAVE_CLOSESOCKET_CAMEL
+
+/* Define to 1 if you have the connect function. */
+#undef HAVE_CONNECT
+
+/* define if the compiler supports basic C++11 syntax */
+#undef HAVE_CXX11
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <errno.h> header file. */
+#undef HAVE_ERRNO_H
+
+/* Define to 1 if you have the fcntl function. */
+#undef HAVE_FCNTL
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#undef HAVE_FCNTL_H
+
+/* Define to 1 if you have a working fcntl O_NONBLOCK function. */
+#undef HAVE_FCNTL_O_NONBLOCK
+
+/* Define to 1 if you have the freeaddrinfo function. */
+#undef HAVE_FREEADDRINFO
+
+/* Define to 1 if you have a working getaddrinfo function. */
+#undef HAVE_GETADDRINFO
+
+/* Define to 1 if the getaddrinfo function is threadsafe. */
+#undef HAVE_GETADDRINFO_THREADSAFE
+
+/* Define to 1 if you have the getenv function. */
+#undef HAVE_GETENV
+
+/* Define to 1 if you have the gethostbyaddr function. */
+#undef HAVE_GETHOSTBYADDR
+
+/* Define to 1 if you have the gethostbyname function. */
+#undef HAVE_GETHOSTBYNAME
+
+/* Define to 1 if you have the gethostname function. */
+#undef HAVE_GETHOSTNAME
+
+/* Define to 1 if you have the getnameinfo function. */
+#undef HAVE_GETNAMEINFO
+
+/* Define to 1 if you have the getservbyport_r function. */
+#undef HAVE_GETSERVBYPORT_R
+
+/* Define to 1 if you have the `gettimeofday' function. */
+#undef HAVE_GETTIMEOFDAY
+
+/* Define to 1 if you have the `if_indextoname' function. */
+#undef HAVE_IF_INDEXTONAME
+
+/* Define to 1 if you have a IPv6 capable working inet_net_pton function. */
+#undef HAVE_INET_NET_PTON
+
+/* Define to 1 if you have a IPv6 capable working inet_ntop function. */
+#undef HAVE_INET_NTOP
+
+/* Define to 1 if you have a IPv6 capable working inet_pton function. */
+#undef HAVE_INET_PTON
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the ioctl function. */
+#undef HAVE_IOCTL
+
+/* Define to 1 if you have the ioctlsocket function. */
+#undef HAVE_IOCTLSOCKET
+
+/* Define to 1 if you have the IoctlSocket camel case function. */
+#undef HAVE_IOCTLSOCKET_CAMEL
+
+/* Define to 1 if you have a working IoctlSocket camel case FIONBIO function.
+   */
+#undef HAVE_IOCTLSOCKET_CAMEL_FIONBIO
+
+/* Define to 1 if you have a working ioctlsocket FIONBIO function. */
+#undef HAVE_IOCTLSOCKET_FIONBIO
+
+/* Define to 1 if you have a working ioctl FIONBIO function. */
+#undef HAVE_IOCTL_FIONBIO
+
+/* Define to 1 if you have a working ioctl SIOCGIFADDR function. */
+#undef HAVE_IOCTL_SIOCGIFADDR
+
+/* Define to 1 if you have the `resolve' library (-lresolve). */
+#undef HAVE_LIBRESOLVE
+
+/* Define to 1 if you have the <limits.h> header file. */
+#undef HAVE_LIMITS_H
+
+/* if your compiler supports LL */
+#undef HAVE_LL
+
+/* Define to 1 if the compiler supports the 'long long' data type. */
+#undef HAVE_LONGLONG
+
+/* Define to 1 if you have the malloc.h header file. */
+#undef HAVE_MALLOC_H
+
+/* Define to 1 if you have the memory.h header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the MSG_NOSIGNAL flag. */
+#undef HAVE_MSG_NOSIGNAL
+
+/* Define to 1 if you have the <netdb.h> header file. */
+#undef HAVE_NETDB_H
+
+/* Define to 1 if you have the <netinet/in.h> header file. */
+#undef HAVE_NETINET_IN_H
+
+/* Define to 1 if you have the <netinet/tcp.h> header file. */
+#undef HAVE_NETINET_TCP_H
+
+/* Define to 1 if you have the <net/if.h> header file. */
+#undef HAVE_NET_IF_H
+
+/* Define to 1 if you have PF_INET6. */
+#undef HAVE_PF_INET6
+
+/* Define to 1 if you have the recv function. */
+#undef HAVE_RECV
+
+/* Define to 1 if you have the recvfrom function. */
+#undef HAVE_RECVFROM
+
+/* Define to 1 if you have the send function. */
+#undef HAVE_SEND
+
+/* Define to 1 if you have the setsockopt function. */
+#undef HAVE_SETSOCKOPT
+
+/* Define to 1 if you have a working setsockopt SO_NONBLOCK function. */
+#undef HAVE_SETSOCKOPT_SO_NONBLOCK
+
+/* Define to 1 if you have the <signal.h> header file. */
+#undef HAVE_SIGNAL_H
+
+/* Define to 1 if sig_atomic_t is an available typedef. */
+#undef HAVE_SIG_ATOMIC_T
+
+/* Define to 1 if sig_atomic_t is already defined as volatile. */
+#undef HAVE_SIG_ATOMIC_T_VOLATILE
+
+/* Define to 1 if your struct sockaddr_in6 has sin6_scope_id. */
+#undef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
+
+/* Define to 1 if you have the socket function. */
+#undef HAVE_SOCKET
+
+/* Define to 1 if you have the <socket.h> header file. */
+#undef HAVE_SOCKET_H
+
+/* Define to 1 if you have the <stdbool.h> header file. */
+#undef HAVE_STDBOOL_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdio.h> header file. */
+#undef HAVE_STDIO_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the strcasecmp function. */
+#undef HAVE_STRCASECMP
+
+/* Define to 1 if you have the strcmpi function. */
+#undef HAVE_STRCMPI
+
+/* Define to 1 if you have the strdup function. */
+#undef HAVE_STRDUP
+
+/* Define to 1 if you have the stricmp function. */
+#undef HAVE_STRICMP
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the strncasecmp function. */
+#undef HAVE_STRNCASECMP
+
+/* Define to 1 if you have the strncmpi function. */
+#undef HAVE_STRNCMPI
+
+/* Define to 1 if you have the strnicmp function. */
+#undef HAVE_STRNICMP
+
+/* Define to 1 if you have the <stropts.h> header file. */
+#undef HAVE_STROPTS_H
+
+/* Define to 1 if you have struct addrinfo. */
+#undef HAVE_STRUCT_ADDRINFO
+
+/* Define to 1 if you have struct in6_addr. */
+#undef HAVE_STRUCT_IN6_ADDR
+
+/* Define to 1 if you have struct sockaddr_in6. */
+#undef HAVE_STRUCT_SOCKADDR_IN6
+
+/* if struct sockaddr_storage is defined */
+#undef HAVE_STRUCT_SOCKADDR_STORAGE
+
+/* Define to 1 if you have the timeval struct. */
+#undef HAVE_STRUCT_TIMEVAL
+
+/* Define to 1 if you have the <sys/ioctl.h> header file. */
+#undef HAVE_SYS_IOCTL_H
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#undef HAVE_SYS_PARAM_H
+
+/* Define to 1 if you have the <sys/select.h> header file. */
+#undef HAVE_SYS_SELECT_H
+
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#undef HAVE_SYS_SOCKET_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#undef HAVE_SYS_TIME_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <sys/uio.h> header file. */
+#undef HAVE_SYS_UIO_H
+
+/* Define to 1 if you have the <time.h> header file. */
+#undef HAVE_TIME_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if you have the windows.h header file. */
+#undef HAVE_WINDOWS_H
+
+/* Define to 1 if you have the winsock2.h header file. */
+#undef HAVE_WINSOCK2_H
+
+/* Define to 1 if you have the winsock.h header file. */
+#undef HAVE_WINSOCK_H
+
+/* Define to 1 if you have the writev function. */
+#undef HAVE_WRITEV
+
+/* Define to 1 if you have the ws2tcpip.h header file. */
+#undef HAVE_WS2TCPIP_H
+
+/* Define if __system_property_get exists. */
+#undef HAVE___SYSTEM_PROPERTY_GET
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#undef LT_OBJDIR
+
+/* Define to 1 if you need the malloc.h header file even with stdlib.h */
+#undef NEED_MALLOC_H
+
+/* Define to 1 if you need the memory.h header file even with stdlib.h */
+#undef NEED_MEMORY_H
+
+/* Define to 1 if _REENTRANT preprocessor symbol must be defined. */
+#undef NEED_REENTRANT
+
+/* Define to 1 if _THREAD_SAFE preprocessor symbol must be defined. */
+#undef NEED_THREAD_SAFE
+
+/* cpu-machine-OS */
+#undef OS
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to the type qualifier pointed by arg 5 for recvfrom. */
+#undef RECVFROM_QUAL_ARG5
+
+/* Define to the type of arg 1 for recvfrom. */
+#undef RECVFROM_TYPE_ARG1
+
+/* Define to the type pointed by arg 2 for recvfrom. */
+#undef RECVFROM_TYPE_ARG2
+
+/* Define to 1 if the type pointed by arg 2 for recvfrom is void. */
+#undef RECVFROM_TYPE_ARG2_IS_VOID
+
+/* Define to the type of arg 3 for recvfrom. */
+#undef RECVFROM_TYPE_ARG3
+
+/* Define to the type of arg 4 for recvfrom. */
+#undef RECVFROM_TYPE_ARG4
+
+/* Define to the type pointed by arg 5 for recvfrom. */
+#undef RECVFROM_TYPE_ARG5
+
+/* Define to 1 if the type pointed by arg 5 for recvfrom is void. */
+#undef RECVFROM_TYPE_ARG5_IS_VOID
+
+/* Define to the type pointed by arg 6 for recvfrom. */
+#undef RECVFROM_TYPE_ARG6
+
+/* Define to 1 if the type pointed by arg 6 for recvfrom is void. */
+#undef RECVFROM_TYPE_ARG6_IS_VOID
+
+/* Define to the function return type for recvfrom. */
+#undef RECVFROM_TYPE_RETV
+
+/* Define to the type of arg 1 for recv. */
+#undef RECV_TYPE_ARG1
+
+/* Define to the type of arg 2 for recv. */
+#undef RECV_TYPE_ARG2
+
+/* Define to the type of arg 3 for recv. */
+#undef RECV_TYPE_ARG3
+
+/* Define to the type of arg 4 for recv. */
+#undef RECV_TYPE_ARG4
+
+/* Define to the function return type for recv. */
+#undef RECV_TYPE_RETV
+
+/* Define as the return type of signal handlers (`int' or `void'). */
+#undef RETSIGTYPE
+
+/* Define to the type qualifier of arg 2 for send. */
+#undef SEND_QUAL_ARG2
+
+/* Define to the type of arg 1 for send. */
+#undef SEND_TYPE_ARG1
+
+/* Define to the type of arg 2 for send. */
+#undef SEND_TYPE_ARG2
+
+/* Define to the type of arg 3 for send. */
+#undef SEND_TYPE_ARG3
+
+/* Define to the type of arg 4 for send. */
+#undef SEND_TYPE_ARG4
+
+/* Define to the function return type for send. */
+#undef SEND_TYPE_RETV
+
+/* Define to 1 if all of the C90 standard headers exist (not just the ones
+   required in a freestanding environment). This macro is provided for
+   backward compatibility; new code need not use it. */
+#undef STDC_HEADERS
+
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. This
+   macro is obsolete. */
+#undef TIME_WITH_SYS_TIME
+
+/* Define to disable non-blocking sockets. */
+#undef USE_BLOCKING_SOCKETS
+
+/* Version number of package */
+#undef VERSION
+
+/* Define to avoid automatic inclusion of winsock.h */
+#undef WIN32_LEAN_AND_MEAN
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+#  undef WORDS_BIGENDIAN
+# endif
+#endif
+
+/* Define to 1 if OS is AIX. */
+#ifndef _ALL_SOURCE
+#  undef _ALL_SOURCE
+#endif
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+#undef _FILE_OFFSET_BITS
+
+/* Define for large files, on AIX-style hosts. */
+#undef _LARGE_FILES
+
+/* Define to empty if `const' does not conform to ANSI C. */
+#undef const
+
+/* Type to use in place of in_addr_t when system does not provide it. */
+#undef in_addr_t
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t
diff --git a/deps/cares/src/lib/ares_data.c b/deps/cares/src/lib/ares_data.c
index aa925b8b511b2e8970e90e690aa06c78b833857f..69dff06689ae240f20e649db77afa0eb133d9ba2 100644
--- a/deps/cares/src/lib/ares_data.c
+++ b/deps/cares/src/lib/ares_data.c
@@ -77,6 +77,14 @@ void ares_free_data(void *dataptr)
             ares_free(ptr->data.srv_reply.host);
           break;
 
+        case ARES_DATATYPE_URI_REPLY:
+
+          if (ptr->data.uri_reply.next)
+            next_data = ptr->data.uri_reply.next;
+          if (ptr->data.uri_reply.uri)
+            ares_free(ptr->data.uri_reply.uri);
+          break;
+
         case ARES_DATATYPE_TXT_REPLY:
         case ARES_DATATYPE_TXT_EXT:
 
@@ -174,6 +182,14 @@ void *ares_malloc_data(ares_datatype type)
         ptr->data.srv_reply.port = 0;
         break;
 
+      case ARES_DATATYPE_URI_REPLY:
+        ptr->data.uri_reply.next = NULL;
+        ptr->data.uri_reply.priority = 0;
+        ptr->data.uri_reply.weight = 0;
+        ptr->data.uri_reply.uri = NULL;
+        ptr->data.uri_reply.ttl = 0;
+        break;
+
       case ARES_DATATYPE_TXT_EXT:
         ptr->data.txt_ext.record_start = 0;
         /* FALLTHROUGH */
diff --git a/deps/cares/src/lib/ares_data.h b/deps/cares/src/lib/ares_data.h
index b0182fd6907499e2b01ddf544a7fdeb74419d083..6b9dd9f8f74359547a7dd9230bd77d2958975e6b 100644
--- a/deps/cares/src/lib/ares_data.h
+++ b/deps/cares/src/lib/ares_data.h
@@ -23,6 +23,7 @@ typedef enum {
   ARES_DATATYPE_MX_REPLY,    /* struct ares_mx_reply   - introduced in 1.7.2 */
   ARES_DATATYPE_NAPTR_REPLY,/* struct ares_naptr_reply - introduced in 1.7.6 */
   ARES_DATATYPE_SOA_REPLY,    /* struct ares_soa_reply - introduced in 1.9.0 */
+  ARES_DATATYPE_URI_REPLY, 	/* struct ares_uri_reply */
 #if 0
   ARES_DATATYPE_ADDR6TTL,     /* struct ares_addrttl   */
   ARES_DATATYPE_ADDRTTL,      /* struct ares_addr6ttl  */
@@ -67,6 +68,7 @@ struct ares_data {
     struct ares_naptr_reply  naptr_reply;
     struct ares_soa_reply    soa_reply;
     struct ares_caa_reply    caa_reply;
+    struct ares_uri_reply    uri_reply;
   } data;
 };
 
diff --git a/deps/cares/src/lib/ares_expand_name.c b/deps/cares/src/lib/ares_expand_name.c
index a62c982e045255c1c57cee66da175edd20146c5a..fcd88a2a42eb4212c3751cb549a64d432e1c418c 100644
--- a/deps/cares/src/lib/ares_expand_name.c
+++ b/deps/cares/src/lib/ares_expand_name.c
@@ -59,10 +59,19 @@ static int ares__isprint(int ch)
   return 0;
 }
 
-/* Character set allowed by hostnames */
+/* Character set allowed by hostnames.  This is to include the normal
+ * domain name character set plus:
+ *  - underscores which are used in SRV records.
+ *  - Forward slashes such as are used for classless in-addr.arpa 
+ *    delegation (CNAMEs)
+ * While RFC 2181 section 11 does state not to do validation,
+ * that applies to servers, not clients.  Vulnerabilities have been
+ * reported when this validation is not performed.  Security is more
+ * important than edge-case compatibility (which is probably invalid
+ * anyhow). */
 static int is_hostnamech(int ch)
 {
-  /* [A-Za-z0-9-.]
+  /* [A-Za-z0-9-._/]
    * Don't use isalnum() as it is locale-specific
    */
   if (ch >= 'A' && ch <= 'Z')
@@ -71,7 +80,7 @@ static int is_hostnamech(int ch)
     return 1;
   if (ch >= '0' && ch <= '9')
     return 1;
-  if (ch == '-' || ch == '.')
+  if (ch == '-' || ch == '.' || ch == '_' || ch == '/')
     return 1;
 
   return 0;
diff --git a/deps/cares/src/lib/ares_freeaddrinfo.c b/deps/cares/src/lib/ares_freeaddrinfo.c
index d8891bbf8a5cd066d9dbec59271ed324e388622c..ab871363d510b07ab172787d993b3f4a240e863f 100644
--- a/deps/cares/src/lib/ares_freeaddrinfo.c
+++ b/deps/cares/src/lib/ares_freeaddrinfo.c
@@ -55,5 +55,6 @@ void ares_freeaddrinfo(struct ares_addrinfo *ai)
     return;
   ares__freeaddrinfo_cnames(ai->cnames);
   ares__freeaddrinfo_nodes(ai->nodes);
+  ares_free(ai->name);
   ares_free(ai);
 }
diff --git a/deps/cares/src/lib/ares_getaddrinfo.c b/deps/cares/src/lib/ares_getaddrinfo.c
index db17a6708680c8896bedc93449a1539ba3770fc4..0a0225a59ec442e9b7a4593beb8d3de1840651d3 100644
--- a/deps/cares/src/lib/ares_getaddrinfo.c
+++ b/deps/cares/src/lib/ares_getaddrinfo.c
@@ -72,6 +72,7 @@ struct host_query
   struct ares_addrinfo *ai;      /* store results between lookups */
   int remaining;   /* number of DNS answers waiting for */
   int next_domain; /* next search domain to try */
+  int nodata_cnt; /* Track nodata responses to possibly override final result */
 };
 
 static const struct ares_addrinfo_hints default_hints = {
@@ -101,13 +102,15 @@ static const struct ares_addrinfo_node empty_addrinfo_node = {
 
 static const struct ares_addrinfo empty_addrinfo = {
   NULL, /* cnames */
-  NULL  /* nodes */
+  NULL, /* nodes */
+  NULL  /* name */
 };
 
 /* forward declarations */
 static void host_callback(void *arg, int status, int timeouts,
                           unsigned char *abuf, int alen);
 static int as_is_first(const struct host_query *hquery);
+static int as_is_only(const struct host_query* hquery);
 static int next_dns_lookup(struct host_query *hquery);
 
 struct ares_addrinfo_cname *ares__malloc_addrinfo_cname()
@@ -281,9 +284,7 @@ static int fake_addrinfo(const char *name,
                          void *arg)
 {
   struct ares_addrinfo_cname *cname;
-  struct ares_addrinfo_node *node;
-  ares_sockaddr addr;
-  size_t addrlen;
+  int status = ARES_SUCCESS;
   int result = 0;
   int family = hints->ai_family;
   if (family == AF_INET || family == AF_INET6 || family == AF_UNSPEC)
@@ -304,62 +305,45 @@ static int fake_addrinfo(const char *name,
             }
         }
 
-      memset(&addr, 0, sizeof(addr));
-
       /* if we don't have 3 dots, it is illegal
        * (although inet_pton doesn't think so).
        */
       if (numdots != 3 || !valid)
         result = 0;
       else
-        result =
-            (ares_inet_pton(AF_INET, name, &addr.sa4.sin_addr) < 1 ? 0 : 1);
-
-      if (result)
         {
-          family = addr.sa.sa_family = AF_INET;
-          addr.sa4.sin_port = htons(port);
-          addrlen = sizeof(addr.sa4);
+          struct in_addr addr4;
+          result = ares_inet_pton(AF_INET, name, &addr4) < 1 ? 0 : 1;
+          if (result)
+            {
+              status = ares_append_ai_node(AF_INET, port, 0, &addr4, &ai->nodes);
+              if (status != ARES_SUCCESS)
+                {
+                  callback(arg, status, 0, NULL);
+                  return 1;
+                }
+            }
         }
     }
 
   if (family == AF_INET6 || family == AF_UNSPEC)
     {
-      result =
-          (ares_inet_pton(AF_INET6, name, &addr.sa6.sin6_addr) < 1 ? 0 : 1);
-      addr.sa6.sin6_family = AF_INET6;
-      addr.sa6.sin6_port = htons(port);
-      addrlen = sizeof(addr.sa6);
+      struct ares_in6_addr addr6;
+      result = ares_inet_pton(AF_INET6, name, &addr6) < 1 ? 0 : 1;
+      if (result)
+        {
+          status = ares_append_ai_node(AF_INET6, port, 0, &addr6, &ai->nodes);
+          if (status != ARES_SUCCESS)
+            {
+              callback(arg, status, 0, NULL);
+              return 1;
+            }
+        }
     }
 
   if (!result)
     return 0;
 
-  node = ares__malloc_addrinfo_node();
-  if (!node)
-    {
-      ares_freeaddrinfo(ai);
-      callback(arg, ARES_ENOMEM, 0, NULL);
-      return 1;
-    }
-
-  ai->nodes = node;
-
-  node->ai_addr = ares_malloc(addrlen);
-  if (!node->ai_addr)
-    {
-      ares_freeaddrinfo(ai);
-      callback(arg, ARES_ENOMEM, 0, NULL);
-      return 1;
-    }
-
-  node->ai_addrlen = (unsigned int)addrlen;
-  node->ai_family = addr.sa.sa_family;
-  if (addr.sa.sa_family == AF_INET)
-    memcpy(node->ai_addr, &addr.sa4, sizeof(addr.sa4));
-  else
-    memcpy(node->ai_addr, &addr.sa6, sizeof(addr.sa6));
-
   if (hints->ai_flags & ARES_AI_CANONNAME)
     {
       cname = ares__append_addrinfo_cname(&ai->cnames);
@@ -380,8 +364,8 @@ static int fake_addrinfo(const char *name,
         }
     }
 
-  node->ai_socktype = hints->ai_socktype;
-  node->ai_protocol = hints->ai_protocol;
+  ai->nodes->ai_socktype = hints->ai_socktype;
+  ai->nodes->ai_protocol = hints->ai_protocol;
 
   callback(arg, ARES_SUCCESS, 0, ai);
   return 1;
@@ -400,19 +384,11 @@ static void end_hquery(struct host_query *hquery, int status)
           hquery->ai->nodes = sentinel.ai_next;
         }
       next = hquery->ai->nodes;
-      /* Set port into each address (resolved separately). */
+
       while (next)
         {
           next->ai_socktype = hquery->hints.ai_socktype;
           next->ai_protocol = hquery->hints.ai_protocol;
-          if (next->ai_family == AF_INET)
-            {
-              (CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr))->sin_port = htons(hquery->port);
-            }
-          else
-            {
-              (CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr))->sin6_port = htons(hquery->port);
-            }
           next = next->ai_next;
         }
     }
@@ -500,6 +476,16 @@ static int file_lookup(struct host_query *hquery)
     }
   status = ares__readaddrinfo(fp, hquery->name, hquery->port, &hquery->hints, hquery->ai);
   fclose(fp);
+
+  /* RFC6761 section 6.3 #3 states that "Name resolution APIs and libraries
+   * SHOULD recognize localhost names as special and SHOULD always return the
+   * IP loopback address for address queries" */
+  if (status == ARES_ENOTFOUND && strcmp(hquery->name, "localhost") == 0)
+    {
+      return ares__addrinfo_localhost(hquery->name, hquery->port,
+                                      &hquery->hints, hquery->ai);
+    }
+
   return status;
 }
 
@@ -508,9 +494,16 @@ static void next_lookup(struct host_query *hquery, int status)
   switch (*hquery->remaining_lookups)
     {
       case 'b':
-          /* DNS lookup */
-          if (next_dns_lookup(hquery))
-            break;
+          /* RFC6761 section 6.3 #3 says "Name resolution APIs SHOULD NOT send
+           * queries for localhost names to their configured caching DNS
+           * server(s)." */
+          if (strcmp(hquery->name, "localhost") != 0)
+            {
+              /* DNS lookup */
+              if (next_dns_lookup(hquery))
+                break;
+            }
+
           hquery->remaining_lookups++;
           next_lookup(hquery, status);
           break;
@@ -542,12 +535,12 @@ static void host_callback(void *arg, int status, int timeouts,
 
   if (status == ARES_SUCCESS)
     {
-      addinfostatus = ares__parse_into_addrinfo(abuf, alen, hquery->ai);
+      addinfostatus = ares__parse_into_addrinfo(abuf, alen, 1, hquery->port, hquery->ai);
     }
 
   if (!hquery->remaining)
     {
-      if (addinfostatus != ARES_SUCCESS)
+      if (addinfostatus != ARES_SUCCESS && addinfostatus != ARES_ENODATA)
         {
           /* error in parsing result e.g. no memory */
           end_hquery(hquery, addinfostatus);
@@ -557,9 +550,12 @@ static void host_callback(void *arg, int status, int timeouts,
           /* at least one query ended with ARES_SUCCESS */
           end_hquery(hquery, ARES_SUCCESS);
         }
-      else if (status == ARES_ENOTFOUND)
+      else if (status == ARES_ENOTFOUND || status == ARES_ENODATA ||
+               addinfostatus == ARES_ENODATA)
         {
-          next_lookup(hquery, status);
+          if (status == ARES_ENODATA || addinfostatus == ARES_ENODATA)
+            hquery->nodata_cnt++;
+          next_lookup(hquery, hquery->nodata_cnt?ARES_ENODATA:status);
         }
       else if (status == ARES_EDESTRUCTION)
         {
@@ -586,6 +582,8 @@ void ares_getaddrinfo(ares_channel channel,
   unsigned short port = 0;
   int family;
   struct ares_addrinfo *ai;
+  char *alias_name = NULL;
+  int status;
 
   if (!hints)
     {
@@ -610,6 +608,17 @@ void ares_getaddrinfo(ares_channel channel,
       return;
     }
 
+  /* perform HOSTALIAS resolution (technically this function does some other
+   * things we are going to ignore) */
+  status = ares__single_domain(channel, name, &alias_name);
+  if (status != ARES_SUCCESS) {
+    callback(arg, status, 0, NULL);
+    return;
+  }
+
+  if (alias_name)
+    name = alias_name;
+
   if (service)
     {
       if (hints->ai_flags & ARES_AI_NUMERICSERV)
@@ -617,6 +626,7 @@ void ares_getaddrinfo(ares_channel channel,
           port = (unsigned short)strtoul(service, NULL, 0);
           if (!port)
             {
+              ares_free(alias_name);
               callback(arg, ARES_ESERVICE, 0, NULL);
               return;
             }
@@ -629,6 +639,7 @@ void ares_getaddrinfo(ares_channel channel,
               port = (unsigned short)strtoul(service, NULL, 0);
               if (!port)
                 {
+                  ares_free(alias_name);
                   callback(arg, ARES_ESERVICE, 0, NULL);
                   return;
                 }
@@ -639,12 +650,14 @@ void ares_getaddrinfo(ares_channel channel,
   ai = ares__malloc_addrinfo();
   if (!ai)
     {
+      ares_free(alias_name);
       callback(arg, ARES_ENOMEM, 0, NULL);
       return;
     }
 
   if (fake_addrinfo(name, port, hints, ai, callback, arg))
     {
+      ares_free(alias_name);
       return;
     }
 
@@ -652,12 +665,14 @@ void ares_getaddrinfo(ares_channel channel,
   hquery = ares_malloc(sizeof(struct host_query));
   if (!hquery)
     {
+      ares_free(alias_name);
       ares_freeaddrinfo(ai);
       callback(arg, ARES_ENOMEM, 0, NULL);
       return;
     }
 
   hquery->name = ares_strdup(name);
+  ares_free(alias_name);
   if (!hquery->name)
     {
       ares_free(hquery);
@@ -677,6 +692,7 @@ void ares_getaddrinfo(ares_channel channel,
   hquery->ai = ai;
   hquery->next_domain = -1;
   hquery->remaining = 0;
+  hquery->nodata_cnt = 0;
 
   /* Start performing lookups according to channel->lookups. */
   next_lookup(hquery, ARES_ECONNREFUSED /* initial error code */);
@@ -707,7 +723,7 @@ static int next_dns_lookup(struct host_query *hquery)
     hquery->next_domain++;
   }
 
-  if (!s && hquery->next_domain < hquery->channel->ndomains)
+  if (!s && hquery->next_domain < hquery->channel->ndomains && !as_is_only(hquery))
     {
       status = ares__cat_domain(
           hquery->name,
@@ -755,7 +771,7 @@ static int as_is_first(const struct host_query* hquery)
 {
   char* p;
   int ndots = 0;
-  size_t nname = strlen(hquery->name);
+  size_t nname = hquery->name?strlen(hquery->name):0;
   for (p = hquery->name; *p; p++)
     {
       if (*p == '.')
@@ -770,3 +786,12 @@ static int as_is_first(const struct host_query* hquery)
     }
   return ndots >= hquery->channel->ndots;
 }
+
+static int as_is_only(const struct host_query* hquery)
+{
+  size_t nname = hquery->name?strlen(hquery->name):0;
+  if (nname && hquery->name[nname-1] == '.')
+    return 1;
+  return 0;
+}
+
diff --git a/deps/cares/src/lib/ares_gethostbyname.c b/deps/cares/src/lib/ares_gethostbyname.c
index e09363632ee5eeeaeb8ffeb2064aa450aca5035e..8c71cc67f3c75a839e427c63cb792b8f2a31c8a8 100644
--- a/deps/cares/src/lib/ares_gethostbyname.c
+++ b/deps/cares/src/lib/ares_gethostbyname.c
@@ -1,4 +1,3 @@
-
 /* Copyright 1998, 2011, 2013 by the Massachusetts Institute of Technology.
  *
  * Permission to use, copy, modify, and distribute this
@@ -39,30 +38,6 @@
 #include "ares_nowarn.h"
 #include "ares_private.h"
 
-#ifdef WATT32
-#undef WIN32
-#endif
-
-struct host_query {
-  /* Arguments passed to ares_gethostbyname() */
-  ares_channel channel;
-  char *name;
-  ares_host_callback callback;
-  void *arg;
-  int sent_family; /* this family is what was is being used */
-  int want_family; /* this family is what is asked for in the API */
-  const char *remaining_lookups;
-  int timeouts;
-};
-
-static void next_lookup(struct host_query *hquery, int status_code);
-static void host_callback(void *arg, int status, int timeouts,
-                          unsigned char *abuf, int alen);
-static void end_hquery(struct host_query *hquery, int status,
-                       struct hostent *host);
-static int fake_hostent(const char *name, int family,
-                        ares_host_callback callback, void *arg);
-static int file_lookup(const char *name, int family, struct hostent **host);
 static void sort_addresses(struct hostent *host,
                            const struct apattern *sortlist, int nsort);
 static void sort6_addresses(struct hostent *host,
@@ -72,252 +47,182 @@ static int get_address_index(const struct in_addr *addr,
 static int get6_address_index(const struct ares_in6_addr *addr,
                               const struct apattern *sortlist, int nsort);
 
-void ares_gethostbyname(ares_channel channel, const char *name, int family,
-                        ares_host_callback callback, void *arg)
+struct host_query {
+  ares_host_callback callback;
+  void *arg;
+  ares_channel channel;
+};
+
+static void ares_gethostbyname_callback(void *arg, int status, int timeouts,
+                                        struct ares_addrinfo *result)
 {
-  struct host_query *hquery;
-
-  /* Right now we only know how to look up Internet addresses - and unspec
-     means try both basically. */
-  switch (family) {
-  case AF_INET:
-  case AF_INET6:
-  case AF_UNSPEC:
-    break;
-  default:
-    callback(arg, ARES_ENOTIMP, 0, NULL);
-    return;
-  }
+  struct hostent *hostent = NULL;
+  struct host_query *ghbn_arg = arg;
 
-  /* Per RFC 7686, reject queries for ".onion" domain names with NXDOMAIN. */
-  if (ares__is_onion_domain(name))
+  if (status == ARES_SUCCESS)
     {
-      callback(arg, ARES_ENOTFOUND, 0, NULL);
-      return;
+      status = ares__addrinfo2hostent(result, AF_UNSPEC, &hostent);
+    }
+
+  /* addrinfo2hostent will only return ENODATA if there are no addresses _and_
+   * no cname/aliases.  However, gethostbyname will return ENODATA even if there
+   * is cname/alias data */
+  if (status == ARES_SUCCESS && hostent &&
+      (!hostent->h_addr_list || !hostent->h_addr_list[0]))
+    {
+      status = ARES_ENODATA;
+    }
+
+  if (status == ARES_SUCCESS && ghbn_arg->channel->nsort && hostent)
+    {
+      if (hostent->h_addrtype == AF_INET6)
+        sort6_addresses(hostent, ghbn_arg->channel->sortlist,
+                        ghbn_arg->channel->nsort);
+      if (hostent->h_addrtype == AF_INET)
+        sort_addresses(hostent, ghbn_arg->channel->sortlist,
+                       ghbn_arg->channel->nsort);
     }
 
-  if (fake_hostent(name, family, callback, arg))
+  ghbn_arg->callback(ghbn_arg->arg, status, timeouts, hostent);
+
+  ares_freeaddrinfo(result);
+  ares_free(ghbn_arg);
+  ares_free_hostent(hostent);
+}
+
+void ares_gethostbyname(ares_channel channel, const char *name, int family,
+                        ares_host_callback callback, void *arg)
+{
+  const struct ares_addrinfo_hints hints = { ARES_AI_CANONNAME, family, 0, 0 };
+  struct host_query *ghbn_arg;
+
+  if (!callback)
     return;
 
-  /* Allocate and fill in the host query structure. */
-  hquery = ares_malloc(sizeof(struct host_query));
-  if (!hquery)
+  ghbn_arg = ares_malloc(sizeof(*ghbn_arg));
+  if (!ghbn_arg)
     {
       callback(arg, ARES_ENOMEM, 0, NULL);
       return;
     }
-  hquery->channel = channel;
-  hquery->name = ares_strdup(name);
-  hquery->want_family = family;
-  hquery->sent_family = -1; /* nothing is sent yet */
-  if (!hquery->name) {
-    ares_free(hquery);
-    callback(arg, ARES_ENOMEM, 0, NULL);
-    return;
-  }
-  hquery->callback = callback;
-  hquery->arg = arg;
-  hquery->remaining_lookups = channel->lookups;
-  hquery->timeouts = 0;
 
-  /* Start performing lookups according to channel->lookups. */
-  next_lookup(hquery, ARES_ECONNREFUSED /* initial error code */);
+  ghbn_arg->callback=callback;
+  ghbn_arg->arg=arg;
+  ghbn_arg->channel=channel;
+
+  ares_getaddrinfo(channel, name, NULL, &hints, ares_gethostbyname_callback,
+                   ghbn_arg);
 }
 
-static void next_lookup(struct host_query *hquery, int status_code)
+
+static void sort_addresses(struct hostent *host,
+                           const struct apattern *sortlist, int nsort)
 {
-  const char *p;
-  struct hostent *host;
-  int status = status_code;
+  struct in_addr a1, a2;
+  int i1, i2, ind1, ind2;
 
-  for (p = hquery->remaining_lookups; *p; p++)
+  /* This is a simple insertion sort, not optimized at all.  i1 walks
+   * through the address list, with the loop invariant that everything
+   * to the left of i1 is sorted.  In the loop body, the value at i1 is moved
+   * back through the list (via i2) until it is in sorted order.
+   */
+  for (i1 = 0; host->h_addr_list[i1]; i1++)
     {
-      switch (*p)
+      memcpy(&a1, host->h_addr_list[i1], sizeof(struct in_addr));
+      ind1 = get_address_index(&a1, sortlist, nsort);
+      for (i2 = i1 - 1; i2 >= 0; i2--)
         {
-        case 'b':
-          /* DNS lookup */
-          hquery->remaining_lookups = p + 1;
-          if ((hquery->want_family == AF_INET6) ||
-              (hquery->want_family == AF_UNSPEC)) {
-            /* if inet6 or unspec, start out with AAAA */
-            hquery->sent_family = AF_INET6;
-            ares_search(hquery->channel, hquery->name, C_IN, T_AAAA,
-                        host_callback, hquery);
-          }
-          else {
-            hquery->sent_family = AF_INET;
-            ares_search(hquery->channel, hquery->name, C_IN, T_A,
-                        host_callback, hquery);
-          }
-          return;
-
-        case 'f':
-          /* Host file lookup */
-          status = file_lookup(hquery->name, hquery->want_family, &host);
-
-          /* this status check below previously checked for !ARES_ENOTFOUND,
-             but we should not assume that this single error code is the one
-             that can occur, as that is in fact no longer the case */
-          if (status == ARES_SUCCESS)
-            {
-              end_hquery(hquery, status, host);
-              return;
-            }
-          status = status_code;   /* Use original status code */
-          break;
+          memcpy(&a2, host->h_addr_list[i2], sizeof(struct in_addr));
+          ind2 = get_address_index(&a2, sortlist, nsort);
+          if (ind2 <= ind1)
+            break;
+          memcpy(host->h_addr_list[i2 + 1], &a2, sizeof(struct in_addr));
         }
+      memcpy(host->h_addr_list[i2 + 1], &a1, sizeof(struct in_addr));
     }
-  end_hquery(hquery, status, NULL);
 }
 
-static void host_callback(void *arg, int status, int timeouts,
-                          unsigned char *abuf, int alen)
+/* Find the first entry in sortlist which matches addr.  Return nsort
+ * if none of them match.
+ */
+static int get_address_index(const struct in_addr *addr,
+                             const struct apattern *sortlist,
+                             int nsort)
 {
-  struct host_query *hquery = (struct host_query *) arg;
-  ares_channel channel = hquery->channel;
-  struct hostent *host = NULL;
+  int i;
 
-  hquery->timeouts += timeouts;
-  if (status == ARES_SUCCESS)
+  for (i = 0; i < nsort; i++)
     {
-      if (hquery->sent_family == AF_INET)
+      if (sortlist[i].family != AF_INET)
+        continue;
+      if (sortlist[i].type == PATTERN_MASK)
         {
-          status = ares_parse_a_reply(abuf, alen, &host, NULL, NULL);
-          if (host && channel->nsort)
-            sort_addresses(host, channel->sortlist, channel->nsort);
+          if ((addr->s_addr & sortlist[i].mask.addr4.s_addr)
+              == sortlist[i].addrV4.s_addr)
+            break;
         }
-      else if (hquery->sent_family == AF_INET6)
+      else
         {
-          status = ares_parse_aaaa_reply(abuf, alen, &host, NULL, NULL);
-          if ((status == ARES_ENODATA || status == ARES_EBADRESP ||
-               (status == ARES_SUCCESS && host && host->h_addr_list[0] == NULL)) &&
-                hquery->want_family == AF_UNSPEC) {
-            /* The query returned something but either there were no AAAA
-               records (e.g. just CNAME) or the response was malformed.  Try
-               looking up A instead. */
-            if (host)
-              ares_free_hostent(host);
-            hquery->sent_family = AF_INET;
-            ares_search(hquery->channel, hquery->name, C_IN, T_A,
-                        host_callback, hquery);
-            return;
-          }
-          if (host && channel->nsort)
-            sort6_addresses(host, channel->sortlist, channel->nsort);
+          if (!ares__bitncmp(&addr->s_addr, &sortlist[i].addrV4.s_addr,
+                             sortlist[i].mask.bits))
+            break;
         }
-      if (status == ARES_SUCCESS && host && host->h_addr_list[0] == NULL)
-      {
-        /* The query returned something but had no A/AAAA record
-           (even after potentially retrying AAAA with A)
-           so we should treat this as an error */
-        status = ARES_ENODATA;
-      }
-      end_hquery(hquery, status, host);
-    }
-  else if ((status == ARES_ENODATA || status == ARES_EBADRESP ||
-            status == ARES_ETIMEOUT) && (hquery->sent_family == AF_INET6 &&
-            hquery->want_family == AF_UNSPEC))
-    {
-      /* The AAAA query yielded no useful result.  Now look up an A instead. */
-      hquery->sent_family = AF_INET;
-      ares_search(hquery->channel, hquery->name, C_IN, T_A, host_callback,
-                  hquery);
     }
-  else if (status == ARES_EDESTRUCTION)
-    end_hquery(hquery, status, NULL);
-  else
-    next_lookup(hquery, status);
+  return i;
 }
 
-static void end_hquery(struct host_query *hquery, int status,
-                       struct hostent *host)
+static void sort6_addresses(struct hostent *host,
+                            const struct apattern *sortlist, int nsort)
 {
-  hquery->callback(hquery->arg, status, hquery->timeouts, host);
-  if (host)
-    ares_free_hostent(host);
-  ares_free(hquery->name);
-  ares_free(hquery);
-}
+  struct ares_in6_addr a1, a2;
+  int i1, i2, ind1, ind2;
 
-/* If the name looks like an IP address, fake up a host entry, end the
- * query immediately, and return true.  Otherwise return false.
- */
-static int fake_hostent(const char *name, int family,
-                        ares_host_callback callback, void *arg)
-{
-  struct hostent hostent;
-  char *aliases[1] = { NULL };
-  char *addrs[2];
-  int result = 0;
-  struct in_addr in;
-  struct ares_in6_addr in6;
-
-  if (family == AF_INET || family == AF_UNSPEC)
+  /* This is a simple insertion sort, not optimized at all.  i1 walks
+   * through the address list, with the loop invariant that everything
+   * to the left of i1 is sorted.  In the loop body, the value at i1 is moved
+   * back through the list (via i2) until it is in sorted order.
+   */
+  for (i1 = 0; host->h_addr_list[i1]; i1++)
     {
-      /* It only looks like an IP address if it's all numbers and dots. */
-      int numdots = 0, valid = 1;
-      const char *p;
-      for (p = name; *p; p++)
+      memcpy(&a1, host->h_addr_list[i1], sizeof(struct ares_in6_addr));
+      ind1 = get6_address_index(&a1, sortlist, nsort);
+      for (i2 = i1 - 1; i2 >= 0; i2--)
         {
-          if (!ISDIGIT(*p) && *p != '.') {
-            valid = 0;
+          memcpy(&a2, host->h_addr_list[i2], sizeof(struct ares_in6_addr));
+          ind2 = get6_address_index(&a2, sortlist, nsort);
+          if (ind2 <= ind1)
             break;
-          } else if (*p == '.') {
-            numdots++;
-          }
+          memcpy(host->h_addr_list[i2 + 1], &a2, sizeof(struct ares_in6_addr));
         }
-
-      /* if we don't have 3 dots, it is illegal
-       * (although inet_pton doesn't think so).
-       */
-      if (numdots != 3 || !valid) {
-        result = 0;
-      } else {
-        result = (ares_inet_pton(AF_INET, name, &in) < 1 ? 0 : 1);
-      }
-
-      /*
-       * Set address family in case of failure,
-       * as we will try to convert it later afterwards
-       */
-      family = result ? AF_INET : AF_INET6;
+      memcpy(host->h_addr_list[i2 + 1], &a1, sizeof(struct ares_in6_addr));
     }
-  if (family == AF_INET6)
-    result = (ares_inet_pton(AF_INET6, name, &in6) < 1 ? 0 : 1);
+}
 
-  if (!result)
-    return 0;
+/* Find the first entry in sortlist which matches addr.  Return nsort
+ * if none of them match.
+ */
+static int get6_address_index(const struct ares_in6_addr *addr,
+                              const struct apattern *sortlist,
+                              int nsort)
+{
+  int i;
 
-  if (family == AF_INET)
-    {
-      hostent.h_length = (int)sizeof(struct in_addr);
-      addrs[0] = (char *)&in;
-    }
-  else if (family == AF_INET6)
-    {
-      hostent.h_length = (int)sizeof(struct ares_in6_addr);
-      addrs[0] = (char *)&in6;
-    }
-  /* Duplicate the name, to avoid a constness violation. */
-  hostent.h_name = ares_strdup(name);
-  if (!hostent.h_name)
+  for (i = 0; i < nsort; i++)
     {
-      callback(arg, ARES_ENOMEM, 0, NULL);
-      return 1;
+      if (sortlist[i].family != AF_INET6)
+        continue;
+      if (!ares__bitncmp(addr, &sortlist[i].addrV6, sortlist[i].mask.bits))
+        break;
     }
+  return i;
+}
 
-  /* Fill in the rest of the host structure and terminate the query. */
-  addrs[1] = NULL;
-  hostent.h_aliases = aliases;
-  hostent.h_addrtype = aresx_sitoss(family);
-  hostent.h_addr_list = addrs;
-  callback(arg, ARES_SUCCESS, 0, &hostent);
 
-  ares_free((char *)(hostent.h_name));
-  return 1;
-}
 
-/* This is an API method */
+static int file_lookup(const char *name, int family, struct hostent **host);
+
+/* I really have no idea why this is exposed as a public function, but since
+ * it is, we can't kill this legacy function. */
 int ares_gethostbyname_file(ares_channel channel, const char *name,
                             int family, struct hostent **host)
 {
@@ -431,104 +336,3 @@ static int file_lookup(const char *name, int family, struct hostent **host)
   return status;
 }
 
-static void sort_addresses(struct hostent *host,
-                           const struct apattern *sortlist, int nsort)
-{
-  struct in_addr a1, a2;
-  int i1, i2, ind1, ind2;
-
-  /* This is a simple insertion sort, not optimized at all.  i1 walks
-   * through the address list, with the loop invariant that everything
-   * to the left of i1 is sorted.  In the loop body, the value at i1 is moved
-   * back through the list (via i2) until it is in sorted order.
-   */
-  for (i1 = 0; host->h_addr_list[i1]; i1++)
-    {
-      memcpy(&a1, host->h_addr_list[i1], sizeof(struct in_addr));
-      ind1 = get_address_index(&a1, sortlist, nsort);
-      for (i2 = i1 - 1; i2 >= 0; i2--)
-        {
-          memcpy(&a2, host->h_addr_list[i2], sizeof(struct in_addr));
-          ind2 = get_address_index(&a2, sortlist, nsort);
-          if (ind2 <= ind1)
-            break;
-          memcpy(host->h_addr_list[i2 + 1], &a2, sizeof(struct in_addr));
-        }
-      memcpy(host->h_addr_list[i2 + 1], &a1, sizeof(struct in_addr));
-    }
-}
-
-/* Find the first entry in sortlist which matches addr.  Return nsort
- * if none of them match.
- */
-static int get_address_index(const struct in_addr *addr,
-                             const struct apattern *sortlist,
-                             int nsort)
-{
-  int i;
-
-  for (i = 0; i < nsort; i++)
-    {
-      if (sortlist[i].family != AF_INET)
-        continue;
-      if (sortlist[i].type == PATTERN_MASK)
-        {
-          if ((addr->s_addr & sortlist[i].mask.addr4.s_addr)
-              == sortlist[i].addrV4.s_addr)
-            break;
-        }
-      else
-        {
-          if (!ares__bitncmp(&addr->s_addr, &sortlist[i].addrV4.s_addr,
-                             sortlist[i].mask.bits))
-            break;
-        }
-    }
-  return i;
-}
-
-static void sort6_addresses(struct hostent *host,
-                            const struct apattern *sortlist, int nsort)
-{
-  struct ares_in6_addr a1, a2;
-  int i1, i2, ind1, ind2;
-
-  /* This is a simple insertion sort, not optimized at all.  i1 walks
-   * through the address list, with the loop invariant that everything
-   * to the left of i1 is sorted.  In the loop body, the value at i1 is moved
-   * back through the list (via i2) until it is in sorted order.
-   */
-  for (i1 = 0; host->h_addr_list[i1]; i1++)
-    {
-      memcpy(&a1, host->h_addr_list[i1], sizeof(struct ares_in6_addr));
-      ind1 = get6_address_index(&a1, sortlist, nsort);
-      for (i2 = i1 - 1; i2 >= 0; i2--)
-        {
-          memcpy(&a2, host->h_addr_list[i2], sizeof(struct ares_in6_addr));
-          ind2 = get6_address_index(&a2, sortlist, nsort);
-          if (ind2 <= ind1)
-            break;
-          memcpy(host->h_addr_list[i2 + 1], &a2, sizeof(struct ares_in6_addr));
-        }
-      memcpy(host->h_addr_list[i2 + 1], &a1, sizeof(struct ares_in6_addr));
-    }
-}
-
-/* Find the first entry in sortlist which matches addr.  Return nsort
- * if none of them match.
- */
-static int get6_address_index(const struct ares_in6_addr *addr,
-                              const struct apattern *sortlist,
-                              int nsort)
-{
-  int i;
-
-  for (i = 0; i < nsort; i++)
-    {
-      if (sortlist[i].family != AF_INET6)
-        continue;
-      if (!ares__bitncmp(addr, &sortlist[i].addrV6, sortlist[i].mask.bits))
-        break;
-    }
-  return i;
-}
diff --git a/deps/cares/src/lib/ares_init.c b/deps/cares/src/lib/ares_init.c
index 0917dce2fe3f8b693457c493c033f23503b293e5..de5d86c9aee8437eea94aa29a3cfd0a8db54f953 100644
--- a/deps/cares/src/lib/ares_init.c
+++ b/deps/cares/src/lib/ares_init.c
@@ -1470,7 +1470,7 @@ static int init_by_resolv_conf(ares_channel channel)
   struct __res_state *res = 0;
   int count4, count6;
   __STATEEXTIPV6 *v6;
-  struct server_state *pserver
+  struct server_state *pserver;
   if (0 == res) {
     int rc = res_init();
     while (rc == -1 && h_errno == TRY_AGAIN) {
diff --git a/deps/cares/src/lib/ares_parse_a_reply.c b/deps/cares/src/lib/ares_parse_a_reply.c
index b08ac8760ff9e014c2c7e5d86f91fb2def4f5281..ee903c7510e12269106a52d028cf1dcb3e3ae6cf 100644
--- a/deps/cares/src/lib/ares_parse_a_reply.c
+++ b/deps/cares/src/lib/ares_parse_a_reply.c
@@ -42,168 +42,49 @@
 #include "ares_private.h"
 
 int ares_parse_a_reply(const unsigned char *abuf, int alen,
-                       struct hostent **host,
-                       struct ares_addrttl *addrttls, int *naddrttls)
+                       struct hostent **host, struct ares_addrttl *addrttls,
+                       int *naddrttls)
 {
   struct ares_addrinfo ai;
-  struct ares_addrinfo_node *next;
-  struct ares_addrinfo_cname *next_cname;
-  char **aliases = NULL;
   char *question_hostname = NULL;
-  struct hostent *hostent = NULL;
-  struct in_addr *addrs = NULL;
-  int naliases = 0, naddrs = 0, alias = 0, i;
-  int cname_ttl = INT_MAX;
   int status;
+  int req_naddrttls = 0;
 
-  memset(&ai, 0, sizeof(ai));
-
-  status = ares__parse_into_addrinfo2(abuf, alen, &question_hostname, &ai);
-  if (status != ARES_SUCCESS)
-    {
-      ares_free(question_hostname);
-
-      if (naddrttls)
-        {
-          *naddrttls = 0;
-        }
-
-      return status;
-    }
-
-  hostent = ares_malloc(sizeof(struct hostent));
-  if (!hostent)
-    {
-      goto enomem;
-    }
-
-  next = ai.nodes;
-  while (next)
-    {
-      if (next->ai_family == AF_INET)
-        {
-          ++naddrs;
-        }
-      next = next->ai_next;
-    }
-
-  next_cname = ai.cnames;
-  while (next_cname)
-    {
-      if(next_cname->alias)
-        ++naliases;
-      next_cname = next_cname->next;
-    }
-
-  aliases = ares_malloc((naliases + 1) * sizeof(char *));
-  if (!aliases)
-    {
-      goto enomem;
-    }
-
-  if (naliases)
-    {
-      next_cname = ai.cnames;
-      while (next_cname)
-        {
-          if(next_cname->alias)
-            aliases[alias++] = ares_strdup(next_cname->alias);
-          if(next_cname->ttl < cname_ttl)
-            cname_ttl = next_cname->ttl;
-          next_cname = next_cname->next;
-        }
-    }
-
-  aliases[alias] = NULL;
-
-  hostent->h_addr_list = ares_malloc((naddrs + 1) * sizeof(char *));
-  if (!hostent->h_addr_list)
+  if (naddrttls)
     {
-      goto enomem;
+      req_naddrttls = *naddrttls;
+      *naddrttls = 0;
     }
 
-  for (i = 0; i < naddrs + 1; ++i)
-    {
-      hostent->h_addr_list[i] = NULL;
-    }
+  memset(&ai, 0, sizeof(ai));
 
-  if (ai.cnames)
+  status = ares__parse_into_addrinfo(abuf, alen, 0, 0, &ai);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
     {
-      hostent->h_name = ares_strdup(ai.cnames->name);
-      ares_free(question_hostname);
+      goto fail;
     }
-  else
-    {
-      hostent->h_name = question_hostname;
-    }
-
-  hostent->h_aliases = aliases;
-  hostent->h_addrtype = AF_INET;
-  hostent->h_length = sizeof(struct in_addr);
 
-  if (naddrs)
+  if (host != NULL)
     {
-      addrs = ares_malloc(naddrs * sizeof(struct in_addr));
-      if (!addrs)
-        {
-          goto enomem;
-        }
-
-      i = 0;
-      next = ai.nodes;
-      while (next)
+      status = ares__addrinfo2hostent(&ai, AF_INET, host);
+      if (status != ARES_SUCCESS && status != ARES_ENODATA)
         {
-          if (next->ai_family == AF_INET)
-            {
-              hostent->h_addr_list[i] = (char *)&addrs[i];
-              memcpy(hostent->h_addr_list[i],
-                     &(CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr)->sin_addr),
-                     sizeof(struct in_addr));
-              if (naddrttls && i < *naddrttls)
-                {
-                  if (next->ai_ttl > cname_ttl)
-                    addrttls[i].ttl = cname_ttl;
-                  else
-                    addrttls[i].ttl = next->ai_ttl;
-
-                  memcpy(&addrttls[i].ipaddr,
-                         &(CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr)->sin_addr),
-                         sizeof(struct in_addr));
-                }
-              ++i;
-            }
-          next = next->ai_next;
-        }
-      if (i == 0)
-        {
-          ares_free(addrs);
+          goto fail;
         }
     }
 
-  if (host)
-    {
-      *host = hostent;
-    }
-  else
-    {
-      ares_free_hostent(hostent);
-    }
+  if (addrttls != NULL && req_naddrttls)
+   {
+     ares__addrinfo2addrttl(&ai, AF_INET, req_naddrttls, addrttls,
+                            NULL, naddrttls);
+   }
 
-  if (naddrttls)
-    {
-      /* Truncated to at most *naddrttls entries */
-      *naddrttls = (naddrs > *naddrttls)?*naddrttls:naddrs;
-    }
-
-  ares__freeaddrinfo_cnames(ai.cnames);
-  ares__freeaddrinfo_nodes(ai.nodes);
-  return ARES_SUCCESS;
 
-enomem:
-  ares_free(aliases);
-  ares_free(hostent);
+fail:
   ares__freeaddrinfo_cnames(ai.cnames);
   ares__freeaddrinfo_nodes(ai.nodes);
+  ares_free(ai.name);
   ares_free(question_hostname);
-  return ARES_ENOMEM;
+
+  return status;
 }
diff --git a/deps/cares/src/lib/ares_parse_aaaa_reply.c b/deps/cares/src/lib/ares_parse_aaaa_reply.c
index 6f4744a8dc494a795284f7f6343a67f8fbd3214c..091065d31761a4c5842295ae3c874974b550f46a 100644
--- a/deps/cares/src/lib/ares_parse_aaaa_reply.c
+++ b/deps/cares/src/lib/ares_parse_aaaa_reply.c
@@ -48,165 +48,45 @@ int ares_parse_aaaa_reply(const unsigned char *abuf, int alen,
                           int *naddrttls)
 {
   struct ares_addrinfo ai;
-  struct ares_addrinfo_node *next;
-  struct ares_addrinfo_cname *next_cname;
-  char **aliases = NULL;
   char *question_hostname = NULL;
-  struct hostent *hostent = NULL;
-  struct ares_in6_addr *addrs = NULL;
-  int naliases = 0, naddrs = 0, alias = 0, i;
-  int cname_ttl = INT_MAX;
   int status;
+  int req_naddrttls = 0;
 
-  memset(&ai, 0, sizeof(ai));
-
-  status = ares__parse_into_addrinfo2(abuf, alen, &question_hostname, &ai);
-  if (status != ARES_SUCCESS)
-    {
-      ares_free(question_hostname);
-
-      if (naddrttls)
-        {
-          *naddrttls = 0;
-        }
-
-      return status;
-    }
-
-  hostent = ares_malloc(sizeof(struct hostent));
-  if (!hostent)
-    {
-      goto enomem;
-    }
-
-  next = ai.nodes;
-  while (next)
-    {
-      if(next->ai_family == AF_INET6)
-        {
-          ++naddrs;
-        }
-      next = next->ai_next;
-    }
-
-  next_cname = ai.cnames;
-  while (next_cname)
-    {
-      if(next_cname->alias)
-        ++naliases;
-      next_cname = next_cname->next;
-    }
-
-  aliases = ares_malloc((naliases + 1) * sizeof(char *));
-  if (!aliases)
-    {
-      goto enomem;
-    }
-
-  if (naliases)
-    {
-      next_cname = ai.cnames;
-      while (next_cname)
-        {
-          if(next_cname->alias)
-            aliases[alias++] = ares_strdup(next_cname->alias);
-          if(next_cname->ttl < cname_ttl)
-            cname_ttl = next_cname->ttl;
-          next_cname = next_cname->next;
-        }
-    }
-
-  aliases[alias] = NULL;
-
-  hostent->h_addr_list = ares_malloc((naddrs + 1) * sizeof(char *));
-  if (!hostent->h_addr_list)
+  if (naddrttls)
     {
-      goto enomem;
+      req_naddrttls = *naddrttls;
+      *naddrttls = 0;
     }
 
-  for (i = 0; i < naddrs + 1; ++i)
-    {
-      hostent->h_addr_list[i] = NULL;
-    }
+  memset(&ai, 0, sizeof(ai));
 
-  if (ai.cnames)
-    {
-      hostent->h_name = ares_strdup(ai.cnames->name);
-      ares_free(question_hostname);
-    }
-  else
+  status = ares__parse_into_addrinfo(abuf, alen, 0, 0, &ai);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
     {
-      hostent->h_name = question_hostname;
+      goto fail;
     }
 
-  hostent->h_aliases = aliases;
-  hostent->h_addrtype = AF_INET6;
-  hostent->h_length = sizeof(struct ares_in6_addr);
-
-  if (naddrs)
+  if (host != NULL)
     {
-      addrs = ares_malloc(naddrs * sizeof(struct ares_in6_addr));
-      if (!addrs)
-        {
-          goto enomem;
-        }
-
-      i = 0;
-      next = ai.nodes;
-      while (next)
-        {
-          if(next->ai_family == AF_INET6)
-            {
-              hostent->h_addr_list[i] = (char*)&addrs[i];
-              memcpy(hostent->h_addr_list[i],
-                     &(CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr)->sin6_addr),
-                     sizeof(struct ares_in6_addr));
-              if (naddrttls && i < *naddrttls)
-                {
-                    if(next->ai_ttl > cname_ttl)
-                      addrttls[i].ttl = cname_ttl;
-                    else
-                      addrttls[i].ttl = next->ai_ttl;
-
-                    memcpy(&addrttls[i].ip6addr,
-                           &(CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr)->sin6_addr),
-                           sizeof(struct ares_in6_addr));
-                }
-              ++i;
-            }
-          next = next->ai_next;
-        }
-
-      if (i == 0)
+      status = ares__addrinfo2hostent(&ai, AF_INET6, host);
+      if (status != ARES_SUCCESS && status != ARES_ENODATA)
         {
-          ares_free(addrs);
+          goto fail;
         }
     }
 
-  if (host)
-    {
-      *host = hostent;
-    }
-  else
-    {
-      ares_free_hostent(hostent);
-    }
+  if (addrttls != NULL && req_naddrttls)
+   {
+     ares__addrinfo2addrttl(&ai, AF_INET6, req_naddrttls, NULL,
+                            addrttls, naddrttls);
+   }
 
-  if (naddrttls)
-    {
-      /* Truncated to at most *naddrttls entries */
-      *naddrttls = (naddrs > *naddrttls)?*naddrttls:naddrs;
-    }
-
-  ares__freeaddrinfo_cnames(ai.cnames);
-  ares__freeaddrinfo_nodes(ai.nodes);
-  return ARES_SUCCESS;
-
-enomem:
-  ares_free(aliases);
-  ares_free(hostent);
+fail:
   ares__freeaddrinfo_cnames(ai.cnames);
   ares__freeaddrinfo_nodes(ai.nodes);
   ares_free(question_hostname);
-  return ARES_ENOMEM;
+  ares_free(ai.name);
+
+  return status;
 }
+
diff --git a/deps/cares/src/lib/ares_parse_uri_reply.c b/deps/cares/src/lib/ares_parse_uri_reply.c
new file mode 100644
index 0000000000000000000000000000000000000000..d79b5c4d85ce5bf35ffcf9af8b84ce44c9191d11
--- /dev/null
+++ b/deps/cares/src/lib/ares_parse_uri_reply.c
@@ -0,0 +1,184 @@
+
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ * Copyright (C) 2009 by Jakub Hrozek <jhrozek@redhat.com>
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#include "ares_setup.h"
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#include "ares_nameser.h"
+
+#include "ares.h"
+#include "ares_dns.h"
+#include "ares_data.h"
+#include "ares_private.h"
+
+/* AIX portability check */
+#ifndef T_URI
+#  define T_URI 256 /* uri selection */
+#endif
+
+int
+ares_parse_uri_reply (const unsigned char *abuf, int alen,
+                      struct ares_uri_reply **uri_out)
+{
+  unsigned int qdcount, ancount, i;
+  const unsigned char *aptr, *vptr;
+  int status, rr_type, rr_class, rr_len, rr_ttl;
+  long len;
+  char *uri_str = NULL, *rr_name = NULL;
+  struct ares_uri_reply *uri_head = NULL;
+  struct ares_uri_reply *uri_last = NULL;
+  struct ares_uri_reply *uri_curr;
+
+  /* Set *uri_out to NULL for all failure cases. */
+  *uri_out = NULL;
+
+  /* Give up if abuf doesn't have room for a header. */
+  if (alen < HFIXEDSZ){
+	  return ARES_EBADRESP;
+  }
+
+  /* Fetch the question and answer count from the header. */
+  qdcount = DNS_HEADER_QDCOUNT (abuf);
+  ancount = DNS_HEADER_ANCOUNT (abuf);
+  if (qdcount != 1) {
+      return ARES_EBADRESP;
+  }
+  if (ancount == 0) {
+	  return ARES_ENODATA;
+  }
+  /* Expand the name from the question, and skip past the question. */
+  aptr = abuf + HFIXEDSZ;
+
+  status = ares_expand_name (aptr, abuf, alen, &uri_str, &len);
+  if (status != ARES_SUCCESS){
+	  return status;
+  }
+  if (aptr + len + QFIXEDSZ > abuf + alen)
+    {
+      ares_free (uri_str);
+      return ARES_EBADRESP;
+    }
+  aptr += len + QFIXEDSZ;
+
+  /* Examine each answer resource record (RR) in turn. */
+  for (i = 0; i < ancount; i++)
+    {
+      /* Decode the RR up to the data field. */
+      status = ares_expand_name (aptr, abuf, alen, &rr_name, &len);
+      if (status != ARES_SUCCESS)
+        {
+          break;
+        }
+      aptr += len;
+      if (aptr + RRFIXEDSZ > abuf + alen)
+        {
+          status = ARES_EBADRESP;
+          break;
+        }
+
+      rr_type 	= DNS_RR_TYPE (aptr);
+      rr_class 	= DNS_RR_CLASS (aptr);
+      rr_ttl 	= DNS_RR_TTL(aptr);
+      rr_len 	= DNS_RR_LEN (aptr);
+      aptr += RRFIXEDSZ;
+
+      if (aptr + rr_len > abuf + alen)
+        {
+          status = ARES_EBADRESP;
+          break;
+        }
+
+      /* Check if we are really looking at a URI record */
+      if (rr_class == C_IN && rr_type == T_URI)
+        {
+          /* parse the URI record itself */
+          if (rr_len < 5)
+            {
+              status = ARES_EBADRESP;
+              break;
+            }
+          /* Allocate storage for this URI answer appending it to the list */
+          uri_curr = ares_malloc_data(ARES_DATATYPE_URI_REPLY);
+          if (!uri_curr)
+            {
+              status = ARES_ENOMEM;
+              break;
+            }
+          if (uri_last)
+            {
+              uri_last->next = uri_curr;
+            }
+          else
+            {
+              uri_head = uri_curr;
+            }
+          uri_last = uri_curr;
+
+          vptr = aptr;
+          uri_curr->priority = DNS__16BIT(vptr);
+          vptr += sizeof(unsigned short);
+          uri_curr->weight = DNS__16BIT(vptr);
+          vptr += sizeof(unsigned short);
+          uri_curr->uri = (char *)ares_malloc(rr_len-3);
+	  	  if (!uri_curr->uri)
+	      	{
+	      	  status = ARES_ENOMEM;
+			  break;
+		    }
+          uri_curr->uri = strncpy(uri_curr->uri, (const char *)vptr, rr_len-4);
+          uri_curr->uri[rr_len-4]='\0';
+          uri_curr->ttl = rr_ttl;
+
+          if (status != ARES_SUCCESS)
+            break;
+        }
+
+      /* Don't lose memory in the next iteration */
+      ares_free (rr_name);
+      rr_name = NULL;
+
+      /* Move on to the next record */
+      aptr += rr_len;
+    }
+
+  if (uri_str)
+    ares_free (uri_str);
+  if (rr_name)
+    ares_free (rr_name);
+
+  /* clean up on error */
+  if (status != ARES_SUCCESS)
+    {
+      if (uri_head)
+        ares_free_data (uri_head);
+      return status;
+    }
+
+  /* everything looks fine, return the data */
+  *uri_out = uri_head;
+
+  return ARES_SUCCESS;
+}
diff --git a/deps/cares/src/lib/ares_private.h b/deps/cares/src/lib/ares_private.h
index 09f65062f0228a3de2b162ee15e4473ca879a6d5..60d69e08b79d5c2982d21a0a261da6b9ced910e3 100644
--- a/deps/cares/src/lib/ares_private.h
+++ b/deps/cares/src/lib/ares_private.h
@@ -85,6 +85,11 @@ W32_FUNC const char *_w32_GetHostsFile (void);
 
 #define PATH_HOSTS             "InetDBase:Hosts"
 
+#elif defined(__HAIKU__)
+
+#define PATH_RESOLV_CONF "/system/settings/network/resolv.conf"
+#define PATH_HOSTS              "/system/settings/network/hosts"
+
 #else
 
 #define PATH_RESOLV_CONF        "/etc/resolv.conf"
@@ -387,17 +392,26 @@ void ares__freeaddrinfo_cnames(struct ares_addrinfo_cname *ai_cname);
 
 struct ares_addrinfo_cname *ares__append_addrinfo_cname(struct ares_addrinfo_cname **ai_cname);
 
+int ares_append_ai_node(int aftype, unsigned short port, int ttl,
+                        const void *adata,
+                        struct ares_addrinfo_node **nodes);
+
 void ares__addrinfo_cat_cnames(struct ares_addrinfo_cname **head,
                                struct ares_addrinfo_cname *tail);
 
 int ares__parse_into_addrinfo(const unsigned char *abuf,
-                              int alen,
+                              int alen, int cname_only_is_enodata,
+                              unsigned short port,
                               struct ares_addrinfo *ai);
 
-int ares__parse_into_addrinfo2(const unsigned char *abuf,
-                               int alen,
-                               char **question_hostname,
-                               struct ares_addrinfo *ai);
+int ares__addrinfo2hostent(const struct ares_addrinfo *ai, int family,
+                           struct hostent **host);
+int ares__addrinfo2addrttl(const struct ares_addrinfo *ai, int family,
+                           int req_naddrttls, struct ares_addrttl *addrttls,
+                           struct ares_addr6ttl *addr6ttls, int *naddrttls);
+int ares__addrinfo_localhost(const char *name, unsigned short port,
+                             const struct ares_addrinfo_hints *hints,
+                             struct ares_addrinfo *ai);
 
 #if 0 /* Not used */
 long ares__tvdiff(struct timeval t1, struct timeval t2);
diff --git a/deps/cares/src/lib/ares_strdup.c b/deps/cares/src/lib/ares_strdup.c
index 0c3dcffc30d6e6381ad811abd61c79084cfcd33d..39fc8692e75ea01ae958668ff8564584c9a1588b 100644
--- a/deps/cares/src/lib/ares_strdup.c
+++ b/deps/cares/src/lib/ares_strdup.c
@@ -22,28 +22,21 @@
 
 char *ares_strdup(const char *s1)
 {
-#ifdef HAVE_STRDUP
-  if (ares_malloc == malloc)
-    return strdup(s1);
-  else
-#endif
-  {
-    size_t sz;
-    char * s2;
+  size_t sz;
+  char * s2;
 
-    if(s1) {
-      sz = strlen(s1);
-      if(sz < (size_t)-1) {
-        sz++;
-        if(sz < ((size_t)-1) / sizeof(char)) {
-          s2 = ares_malloc(sz * sizeof(char));
-          if(s2) {
-            memcpy(s2, s1, sz * sizeof(char));
-            return s2;
-          }
+  if(s1) {
+    sz = strlen(s1);
+    if(sz < (size_t)-1) {
+      sz++;
+      if(sz < ((size_t)-1)) {
+        s2 = ares_malloc(sz);
+        if(s2) {
+          memcpy(s2, s1, sz);
+          return s2;
         }
       }
     }
-    return (char *)NULL;
   }
+  return (char *)NULL;
 }
diff --git a/deps/cares/src/lib/cares.rc b/deps/cares/src/lib/cares.rc
new file mode 100644
index 0000000000000000000000000000000000000000..6360834deafd86f274e3742146ba33329680dc42
--- /dev/null
+++ b/deps/cares/src/lib/cares.rc
@@ -0,0 +1,65 @@
+
+/* Copyright (C) 2009-2021 by Daniel Stenberg
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#include <winver.h>
+#include "../../include/ares_version.h"
+
+LANGUAGE  0x09,0x01
+
+#define RC_VERSION  ARES_VERSION_MAJOR, ARES_VERSION_MINOR, ARES_VERSION_PATCH, 0
+
+VS_VERSION_INFO VERSIONINFO
+  FILEVERSION     RC_VERSION
+  PRODUCTVERSION  RC_VERSION
+  FILEFLAGSMASK   0x3fL
+#if defined(DEBUGBUILD) || defined(_DEBUG)
+  FILEFLAGS 1
+#else
+  FILEFLAGS 0
+#endif
+  FILEOS      VOS__WINDOWS32
+  FILETYPE    VFT_DLL
+  FILESUBTYPE 0x0L
+
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904b0"
+    BEGIN
+      VALUE "CompanyName",      "The c-ares library, https://c-ares.org/\0"
+#if defined(DEBUGBUILD) || defined(_DEBUG)
+      VALUE "FileDescription",  "c-ares Debug Shared Library\0"
+      VALUE "FileVersion",      ARES_VERSION_STR "\0"
+      VALUE "InternalName",     "c-ares\0"
+      VALUE "OriginalFilename", "caresd.dll\0"
+#else
+      VALUE "FileDescription",  "c-ares Shared Library\0"
+      VALUE "FileVersion",      ARES_VERSION_STR "\0"
+      VALUE "InternalName",     "c-ares\0"
+      VALUE "OriginalFilename", "cares.dll\0"
+#endif
+      VALUE "ProductName",      "The c-ares library\0"
+      VALUE "ProductVersion",   ARES_VERSION_STR "\0"
+      VALUE "LegalCopyright",   "� " ARES_COPYRIGHT "\0"
+      VALUE "License",          "https://c-ares.org/license.html\0"
+    END
+  END
+
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x409, 1200
+  END
+END
diff --git a/deps/cares/src/lib/config-dos.h b/deps/cares/src/lib/config-dos.h
new file mode 100644
index 0000000000000000000000000000000000000000..b241d69a5c6660bf27083ecab1ceed094908f3c1
--- /dev/null
+++ b/deps/cares/src/lib/config-dos.h
@@ -0,0 +1,115 @@
+#ifndef HEADER_CONFIG_DOS_H
+#define HEADER_CONFIG_DOS_H
+
+
+/* ================================================================ */
+/*       ares/config-dos.h - Hand crafted config file for DOS       */
+/* ================================================================ */
+
+#define PACKAGE  "c-ares"
+
+#define HAVE_ERRNO_H           1
+#define HAVE_GETENV            1
+#define HAVE_GETTIMEOFDAY      1
+#define HAVE_IOCTLSOCKET       1
+#define HAVE_IOCTLSOCKET_FIONBIO   1
+#define HAVE_LIMITS_H          1
+#define HAVE_NET_IF_H          1
+#define HAVE_RECV              1
+#define HAVE_RECVFROM          1
+#define HAVE_SEND              1
+#define HAVE_STRDUP            1
+#define HAVE_STRICMP           1
+#define HAVE_STRUCT_IN6_ADDR   1
+#define HAVE_STRUCT_TIMEVAL    1
+#define HAVE_SYS_IOCTL_H       1
+#define HAVE_SYS_SOCKET_H      1
+#define HAVE_SYS_STAT_H        1
+#define HAVE_SYS_TYPES_H       1
+#define HAVE_TIME_H            1
+#define HAVE_UNISTD_H          1
+#define HAVE_WRITEV            1
+
+#define NEED_MALLOC_H          1
+
+#define RETSIGTYPE             void
+#define TIME_WITH_SYS_TIME     1
+
+/* Qualifiers for send(), recv(), recvfrom() and getnameinfo(). */
+
+#define SEND_TYPE_ARG1         int
+#define SEND_QUAL_ARG2         const
+#define SEND_TYPE_ARG2         void *
+#define SEND_TYPE_ARG3         int
+#define SEND_TYPE_ARG4         int
+#define SEND_TYPE_RETV         int
+
+#define RECV_TYPE_ARG1         int
+#define RECV_TYPE_ARG2         void *
+#define RECV_TYPE_ARG3         int
+#define RECV_TYPE_ARG4         int
+#define RECV_TYPE_RETV         int
+
+#define RECVFROM_TYPE_ARG1     int
+#define RECVFROM_TYPE_ARG2     void
+#define RECVFROM_TYPE_ARG3     int
+#define RECVFROM_TYPE_ARG4     int
+#define RECVFROM_TYPE_ARG5     struct sockaddr
+#define RECVFROM_TYPE_ARG6     int
+#define RECVFROM_TYPE_RETV     int
+#define RECVFROM_TYPE_ARG2_IS_VOID 1
+
+#define BSD
+
+/* Target HAVE_x section */
+
+#if defined(DJGPP)
+  #undef _SSIZE_T
+  #include <sys/types.h>               /* For 'ssize_t' */
+
+  #define HAVE_STRCASECMP           1
+  #define HAVE_STRNCASECMP          1
+  #define HAVE_SYS_TIME_H           1
+  #define HAVE_VARIADIC_MACROS_GCC  1
+
+  /* Because djgpp <= 2.03 doesn't have snprintf() etc. */
+  #if (DJGPP_MINOR < 4)
+    #define _MPRINTF_REPLACE
+  #endif
+
+#elif defined(__WATCOMC__)
+  #define HAVE_STRCASECMP 1
+
+#elif defined(__HIGHC__)
+  #define HAVE_SYS_TIME_H 1
+  #define strerror(e) strerror_s_((e))
+#endif
+
+#ifdef WATT32
+  #define HAVE_AF_INET6                    1
+  #define HAVE_ARPA_INET_H                 1
+  #define HAVE_ARPA_NAMESER_H              1
+  #define HAVE_CLOSE_S                     1
+  #define HAVE_GETHOSTNAME                 1
+  #define HAVE_NETDB_H                     1
+  #define HAVE_NETINET_IN_H                1
+  #define HAVE_NETINET_TCP_H               1
+  #define HAVE_PF_INET6                    1
+  #define HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID  1
+  #define HAVE_STRUCT_ADDRINFO             1
+  #define HAVE_STRUCT_IN6_ADDR             1
+  #define HAVE_STRUCT_SOCKADDR_IN6         1
+  #define HAVE_SYS_SOCKET_H                1
+  #define HAVE_SYS_UIO_H                   1
+  #define NS_INADDRSZ                      4
+  #define HAVE_STRUCT_SOCKADDR_IN6         1
+
+  #define HAVE_GETSERVBYPORT_R             1
+  #define GETSERVBYPORT_R_ARGS             5
+#endif
+
+#undef word
+#undef byte
+
+#endif /* HEADER_CONFIG_DOS_H */
+
diff --git a/deps/cares/src/tools/CMakeLists.txt b/deps/cares/src/tools/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0c44216fcc4efba16e57e0c843441152fbf1f322
--- /dev/null
+++ b/deps/cares/src/tools/CMakeLists.txt
@@ -0,0 +1,55 @@
+IF (CARES_BUILD_TOOLS)
+	# Transform Makefile.inc
+	transform_makefile_inc("Makefile.inc" "${PROJECT_BINARY_DIR}/src/tools/Makefile.inc.cmake")
+	include(${PROJECT_BINARY_DIR}/src/tools/Makefile.inc.cmake)
+
+	# Build ahost
+	ADD_EXECUTABLE (ahost ahost.c ${SAMPLESOURCES})
+	TARGET_INCLUDE_DIRECTORIES (ahost
+		PUBLIC "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>"
+		       "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
+		       "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/lib>"
+		       "$<BUILD_INTERFACE:${CARES_TOPLEVEL_DIR}/include>"
+		       "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+		PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}"
+	)
+	TARGET_COMPILE_DEFINITIONS (ahost PRIVATE HAVE_CONFIG_H=1)
+	TARGET_LINK_LIBRARIES (ahost PRIVATE ${PROJECT_NAME})
+	IF (CARES_INSTALL)
+		INSTALL (TARGETS ahost COMPONENT Tools ${TARGETS_INST_DEST})
+	ENDIF ()
+
+
+	# Build adig
+	ADD_EXECUTABLE (adig adig.c ${SAMPLESOURCES})
+	TARGET_INCLUDE_DIRECTORIES (adig
+		PUBLIC "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>"
+		       "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
+		       "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/lib>"
+		       "$<BUILD_INTERFACE:${CARES_TOPLEVEL_DIR}/include>"
+		       "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+		PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}"
+	)
+	TARGET_COMPILE_DEFINITIONS (adig PRIVATE HAVE_CONFIG_H=1)
+	TARGET_LINK_LIBRARIES (adig PRIVATE ${PROJECT_NAME})
+	IF (CARES_INSTALL)
+		INSTALL (TARGETS adig COMPONENT Tools ${TARGETS_INST_DEST})
+	ENDIF ()
+
+
+	# Build acountry
+	ADD_EXECUTABLE (acountry acountry.c ${SAMPLESOURCES})
+	TARGET_INCLUDE_DIRECTORIES (acountry
+		PUBLIC "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>"
+		       "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
+		       "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/lib>"
+		       "$<BUILD_INTERFACE:${CARES_TOPLEVEL_DIR}/include>"
+		       "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+		PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}"
+	)
+	TARGET_COMPILE_DEFINITIONS (acountry PRIVATE HAVE_CONFIG_H=1)
+	TARGET_LINK_LIBRARIES (acountry PRIVATE ${PROJECT_NAME})
+	IF (CARES_INSTALL)
+		INSTALL (TARGETS acountry COMPONENT Tools ${TARGETS_INST_DEST})
+	ENDIF ()
+ENDIF ()
diff --git a/deps/cares/src/tools/Makefile.am b/deps/cares/src/tools/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..c503723cad3cdfc56e2eeb67e8eff3bc1dffb7af
--- /dev/null
+++ b/deps/cares/src/tools/Makefile.am
@@ -0,0 +1,36 @@
+AUTOMAKE_OPTIONS = foreign subdir-objects nostdinc 1.9.6
+PROGS = ahost adig acountry
+
+EXTRA_DIST = CMakeLists.txt Makefile.inc
+
+noinst_PROGRAMS =$(PROGS)
+
+# Specify our include paths here, and do it relative to $(top_srcdir) and
+# $(top_builddir), to ensure that these paths which belong to the library
+# being currently built and tested are searched before the library which
+# might possibly already be installed in the system.
+
+AM_CPPFLAGS = -I$(top_builddir)/include \
+              -I$(top_builddir)/src/lib \
+              -I$(top_srcdir)/include \
+              -I$(top_srcdir)/src/lib
+
+if USE_CPPFLAG_CARES_STATICLIB
+AM_CPPFLAGS += $(CPPFLAG_CARES_STATICLIB)
+endif
+
+include Makefile.inc
+
+LDADD = $(top_builddir)/src/lib/libcares.la
+
+ahost_SOURCES = ahost.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+ahost_CFLAGS = $(AM_CFLAGS)
+ahost_CPPFLAGS = $(AM_CPPFLAGS)
+
+adig_SOURCES = adig.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+adig_CFLAGS = $(AM_CFLAGS)
+adig_CPPFLAGS = $(AM_CPPFLAGS)
+
+acountry_SOURCES = acountry.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+acountry_CFLAGS = $(AM_CFLAGS)
+acountry_CPPFLAGS = $(AM_CPPFLAGS)
diff --git a/deps/cares/src/tools/Makefile.in b/deps/cares/src/tools/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..e665ac984b4c54ffcf55023ffc314085d82652e8
--- /dev/null
+++ b/deps/cares/src/tools/Makefile.in
@@ -0,0 +1,944 @@
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2021 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+noinst_PROGRAMS = $(am__EXEEXT_1)
+@USE_CPPFLAG_CARES_STATICLIB_TRUE@am__append_1 = $(CPPFLAG_CARES_STATICLIB)
+subdir = src/tools
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_ac_append_to_file.m4 \
+	$(top_srcdir)/m4/ax_ac_print_to_file.m4 \
+	$(top_srcdir)/m4/ax_add_am_macro_static.m4 \
+	$(top_srcdir)/m4/ax_am_macros_static.m4 \
+	$(top_srcdir)/m4/ax_check_gnu_make.m4 \
+	$(top_srcdir)/m4/ax_code_coverage.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx_11.m4 \
+	$(top_srcdir)/m4/ax_file_escapes.m4 \
+	$(top_srcdir)/m4/ax_require_defined.m4 \
+	$(top_srcdir)/m4/cares-compilers.m4 \
+	$(top_srcdir)/m4/cares-confopts.m4 \
+	$(top_srcdir)/m4/cares-functions.m4 \
+	$(top_srcdir)/m4/cares-reentrant.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/xc-am-iface.m4 \
+	$(top_srcdir)/m4/xc-cc-check.m4 \
+	$(top_srcdir)/m4/xc-lt-iface.m4 \
+	$(top_srcdir)/m4/xc-translit.m4 \
+	$(top_srcdir)/m4/xc-val-flgs.m4 \
+	$(top_srcdir)/m4/zz40-xc-ovr.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/src/lib/ares_config.h \
+	$(top_builddir)/include/ares_build.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__EXEEXT_1 = ahost$(EXEEXT) adig$(EXEEXT) acountry$(EXEEXT)
+PROGRAMS = $(noinst_PROGRAMS)
+am__dirstamp = $(am__leading_dot)dirstamp
+am__objects_1 = acountry-ares_getopt.$(OBJEXT) \
+	../lib/acountry-ares_nowarn.$(OBJEXT) \
+	../lib/acountry-ares_strcasecmp.$(OBJEXT)
+am__objects_2 =
+am_acountry_OBJECTS = acountry-acountry.$(OBJEXT) $(am__objects_1) \
+	$(am__objects_2)
+acountry_OBJECTS = $(am_acountry_OBJECTS)
+acountry_LDADD = $(LDADD)
+acountry_DEPENDENCIES = $(top_builddir)/src/lib/libcares.la
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+acountry_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(acountry_CFLAGS) \
+	$(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+am__objects_3 = adig-ares_getopt.$(OBJEXT) \
+	../lib/adig-ares_nowarn.$(OBJEXT) \
+	../lib/adig-ares_strcasecmp.$(OBJEXT)
+am_adig_OBJECTS = adig-adig.$(OBJEXT) $(am__objects_3) \
+	$(am__objects_2)
+adig_OBJECTS = $(am_adig_OBJECTS)
+adig_LDADD = $(LDADD)
+adig_DEPENDENCIES = $(top_builddir)/src/lib/libcares.la
+adig_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(adig_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+am__objects_4 = ahost-ares_getopt.$(OBJEXT) \
+	../lib/ahost-ares_nowarn.$(OBJEXT) \
+	../lib/ahost-ares_strcasecmp.$(OBJEXT)
+am_ahost_OBJECTS = ahost-ahost.$(OBJEXT) $(am__objects_4) \
+	$(am__objects_2)
+ahost_OBJECTS = $(am_ahost_OBJECTS)
+ahost_LDADD = $(LDADD)
+ahost_DEPENDENCIES = $(top_builddir)/src/lib/libcares.la
+ahost_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(ahost_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = 
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ../lib/$(DEPDIR)/acountry-ares_nowarn.Po \
+	../lib/$(DEPDIR)/acountry-ares_strcasecmp.Po \
+	../lib/$(DEPDIR)/adig-ares_nowarn.Po \
+	../lib/$(DEPDIR)/adig-ares_strcasecmp.Po \
+	../lib/$(DEPDIR)/ahost-ares_nowarn.Po \
+	../lib/$(DEPDIR)/ahost-ares_strcasecmp.Po \
+	./$(DEPDIR)/acountry-acountry.Po \
+	./$(DEPDIR)/acountry-ares_getopt.Po ./$(DEPDIR)/adig-adig.Po \
+	./$(DEPDIR)/adig-ares_getopt.Po ./$(DEPDIR)/ahost-ahost.Po \
+	./$(DEPDIR)/ahost-ares_getopt.Po
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 = 
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 = 
+SOURCES = $(acountry_SOURCES) $(adig_SOURCES) $(ahost_SOURCES)
+DIST_SOURCES = $(acountry_SOURCES) $(adig_SOURCES) $(ahost_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.inc \
+	$(top_srcdir)/depcomp
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BUILD_SUBDIRS = @BUILD_SUBDIRS@
+CARES_CFLAG_EXTRAS = @CARES_CFLAG_EXTRAS@
+CARES_PRIVATE_LIBS = @CARES_PRIVATE_LIBS@
+CARES_RANDOM_FILE = @CARES_RANDOM_FILE@
+CARES_VERSION_INFO = @CARES_VERSION_INFO@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CFLAG_CARES_SYMBOL_HIDING = @CFLAG_CARES_SYMBOL_HIDING@
+CODE_COVERAGE_CFLAGS = @CODE_COVERAGE_CFLAGS@
+CODE_COVERAGE_CPPFLAGS = @CODE_COVERAGE_CPPFLAGS@
+CODE_COVERAGE_CXXFLAGS = @CODE_COVERAGE_CXXFLAGS@
+CODE_COVERAGE_ENABLED = @CODE_COVERAGE_ENABLED@
+CODE_COVERAGE_LIBS = @CODE_COVERAGE_LIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPPFLAG_CARES_STATICLIB = @CPPFLAG_CARES_STATICLIB@
+CSCOPE = @CSCOPE@
+CTAGS = @CTAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ETAGS = @ETAGS@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GCOV = @GCOV@
+GENHTML = @GENHTML@
+GREP = @GREP@
+HAVE_CXX11 = @HAVE_CXX11@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LCOV = @LCOV@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+ifGNUmake = @ifGNUmake@
+ifnGNUmake = @ifnGNUmake@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AUTOMAKE_OPTIONS = foreign subdir-objects nostdinc 1.9.6
+PROGS = ahost adig acountry
+EXTRA_DIST = CMakeLists.txt Makefile.inc
+
+# Specify our include paths here, and do it relative to $(top_srcdir) and
+# $(top_builddir), to ensure that these paths which belong to the library
+# being currently built and tested are searched before the library which
+# might possibly already be installed in the system.
+AM_CPPFLAGS = -I$(top_builddir)/include -I$(top_builddir)/src/lib \
+	-I$(top_srcdir)/include -I$(top_srcdir)/src/lib \
+	$(am__append_1)
+SAMPLESOURCES = ares_getopt.c		\
+  ../lib/ares_nowarn.c				\
+  ../lib/ares_strcasecmp.c
+
+SAMPLEHEADERS = ares_getopt.h		\
+  ../lib/ares_nowarn.h				\
+  ../lib/ares_strcasecmp.h
+
+LDADD = $(top_builddir)/src/lib/libcares.la
+ahost_SOURCES = ahost.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+ahost_CFLAGS = $(AM_CFLAGS)
+ahost_CPPFLAGS = $(AM_CPPFLAGS)
+adig_SOURCES = adig.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+adig_CFLAGS = $(AM_CFLAGS)
+adig_CPPFLAGS = $(AM_CPPFLAGS)
+acountry_SOURCES = acountry.c $(SAMPLESOURCES) $(SAMPLEHEADERS)
+acountry_CFLAGS = $(AM_CFLAGS)
+acountry_CPPFLAGS = $(AM_CPPFLAGS)
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/Makefile.inc $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/tools/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign src/tools/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+$(srcdir)/Makefile.inc $(am__empty):
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+clean-noinstPROGRAMS:
+	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
+	echo " rm -f" $$list; \
+	rm -f $$list || exit $$?; \
+	test -n "$(EXEEXT)" || exit 0; \
+	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+	echo " rm -f" $$list; \
+	rm -f $$list
+../lib/$(am__dirstamp):
+	@$(MKDIR_P) ../lib
+	@: > ../lib/$(am__dirstamp)
+../lib/$(DEPDIR)/$(am__dirstamp):
+	@$(MKDIR_P) ../lib/$(DEPDIR)
+	@: > ../lib/$(DEPDIR)/$(am__dirstamp)
+../lib/acountry-ares_nowarn.$(OBJEXT): ../lib/$(am__dirstamp) \
+	../lib/$(DEPDIR)/$(am__dirstamp)
+../lib/acountry-ares_strcasecmp.$(OBJEXT): ../lib/$(am__dirstamp) \
+	../lib/$(DEPDIR)/$(am__dirstamp)
+
+acountry$(EXEEXT): $(acountry_OBJECTS) $(acountry_DEPENDENCIES) $(EXTRA_acountry_DEPENDENCIES) 
+	@rm -f acountry$(EXEEXT)
+	$(AM_V_CCLD)$(acountry_LINK) $(acountry_OBJECTS) $(acountry_LDADD) $(LIBS)
+../lib/adig-ares_nowarn.$(OBJEXT): ../lib/$(am__dirstamp) \
+	../lib/$(DEPDIR)/$(am__dirstamp)
+../lib/adig-ares_strcasecmp.$(OBJEXT): ../lib/$(am__dirstamp) \
+	../lib/$(DEPDIR)/$(am__dirstamp)
+
+adig$(EXEEXT): $(adig_OBJECTS) $(adig_DEPENDENCIES) $(EXTRA_adig_DEPENDENCIES) 
+	@rm -f adig$(EXEEXT)
+	$(AM_V_CCLD)$(adig_LINK) $(adig_OBJECTS) $(adig_LDADD) $(LIBS)
+../lib/ahost-ares_nowarn.$(OBJEXT): ../lib/$(am__dirstamp) \
+	../lib/$(DEPDIR)/$(am__dirstamp)
+../lib/ahost-ares_strcasecmp.$(OBJEXT): ../lib/$(am__dirstamp) \
+	../lib/$(DEPDIR)/$(am__dirstamp)
+
+ahost$(EXEEXT): $(ahost_OBJECTS) $(ahost_DEPENDENCIES) $(EXTRA_ahost_DEPENDENCIES) 
+	@rm -f ahost$(EXEEXT)
+	$(AM_V_CCLD)$(ahost_LINK) $(ahost_OBJECTS) $(ahost_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+	-rm -f ../lib/*.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@../lib/$(DEPDIR)/acountry-ares_nowarn.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@../lib/$(DEPDIR)/acountry-ares_strcasecmp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@../lib/$(DEPDIR)/adig-ares_nowarn.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@../lib/$(DEPDIR)/adig-ares_strcasecmp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@../lib/$(DEPDIR)/ahost-ares_nowarn.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@../lib/$(DEPDIR)/ahost-ares_strcasecmp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/acountry-acountry.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/acountry-ares_getopt.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/adig-adig.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/adig-ares_getopt.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ahost-ahost.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ahost-ares_getopt.Po@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
+
+.c.o:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
+
+acountry-acountry.o: acountry.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -MT acountry-acountry.o -MD -MP -MF $(DEPDIR)/acountry-acountry.Tpo -c -o acountry-acountry.o `test -f 'acountry.c' || echo '$(srcdir)/'`acountry.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/acountry-acountry.Tpo $(DEPDIR)/acountry-acountry.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='acountry.c' object='acountry-acountry.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -c -o acountry-acountry.o `test -f 'acountry.c' || echo '$(srcdir)/'`acountry.c
+
+acountry-acountry.obj: acountry.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -MT acountry-acountry.obj -MD -MP -MF $(DEPDIR)/acountry-acountry.Tpo -c -o acountry-acountry.obj `if test -f 'acountry.c'; then $(CYGPATH_W) 'acountry.c'; else $(CYGPATH_W) '$(srcdir)/acountry.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/acountry-acountry.Tpo $(DEPDIR)/acountry-acountry.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='acountry.c' object='acountry-acountry.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -c -o acountry-acountry.obj `if test -f 'acountry.c'; then $(CYGPATH_W) 'acountry.c'; else $(CYGPATH_W) '$(srcdir)/acountry.c'; fi`
+
+acountry-ares_getopt.o: ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -MT acountry-ares_getopt.o -MD -MP -MF $(DEPDIR)/acountry-ares_getopt.Tpo -c -o acountry-ares_getopt.o `test -f 'ares_getopt.c' || echo '$(srcdir)/'`ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/acountry-ares_getopt.Tpo $(DEPDIR)/acountry-ares_getopt.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getopt.c' object='acountry-ares_getopt.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -c -o acountry-ares_getopt.o `test -f 'ares_getopt.c' || echo '$(srcdir)/'`ares_getopt.c
+
+acountry-ares_getopt.obj: ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -MT acountry-ares_getopt.obj -MD -MP -MF $(DEPDIR)/acountry-ares_getopt.Tpo -c -o acountry-ares_getopt.obj `if test -f 'ares_getopt.c'; then $(CYGPATH_W) 'ares_getopt.c'; else $(CYGPATH_W) '$(srcdir)/ares_getopt.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/acountry-ares_getopt.Tpo $(DEPDIR)/acountry-ares_getopt.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getopt.c' object='acountry-ares_getopt.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -c -o acountry-ares_getopt.obj `if test -f 'ares_getopt.c'; then $(CYGPATH_W) 'ares_getopt.c'; else $(CYGPATH_W) '$(srcdir)/ares_getopt.c'; fi`
+
+../lib/acountry-ares_nowarn.o: ../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -MT ../lib/acountry-ares_nowarn.o -MD -MP -MF ../lib/$(DEPDIR)/acountry-ares_nowarn.Tpo -c -o ../lib/acountry-ares_nowarn.o `test -f '../lib/ares_nowarn.c' || echo '$(srcdir)/'`../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/acountry-ares_nowarn.Tpo ../lib/$(DEPDIR)/acountry-ares_nowarn.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_nowarn.c' object='../lib/acountry-ares_nowarn.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -c -o ../lib/acountry-ares_nowarn.o `test -f '../lib/ares_nowarn.c' || echo '$(srcdir)/'`../lib/ares_nowarn.c
+
+../lib/acountry-ares_nowarn.obj: ../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -MT ../lib/acountry-ares_nowarn.obj -MD -MP -MF ../lib/$(DEPDIR)/acountry-ares_nowarn.Tpo -c -o ../lib/acountry-ares_nowarn.obj `if test -f '../lib/ares_nowarn.c'; then $(CYGPATH_W) '../lib/ares_nowarn.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_nowarn.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/acountry-ares_nowarn.Tpo ../lib/$(DEPDIR)/acountry-ares_nowarn.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_nowarn.c' object='../lib/acountry-ares_nowarn.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -c -o ../lib/acountry-ares_nowarn.obj `if test -f '../lib/ares_nowarn.c'; then $(CYGPATH_W) '../lib/ares_nowarn.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_nowarn.c'; fi`
+
+../lib/acountry-ares_strcasecmp.o: ../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -MT ../lib/acountry-ares_strcasecmp.o -MD -MP -MF ../lib/$(DEPDIR)/acountry-ares_strcasecmp.Tpo -c -o ../lib/acountry-ares_strcasecmp.o `test -f '../lib/ares_strcasecmp.c' || echo '$(srcdir)/'`../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/acountry-ares_strcasecmp.Tpo ../lib/$(DEPDIR)/acountry-ares_strcasecmp.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_strcasecmp.c' object='../lib/acountry-ares_strcasecmp.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -c -o ../lib/acountry-ares_strcasecmp.o `test -f '../lib/ares_strcasecmp.c' || echo '$(srcdir)/'`../lib/ares_strcasecmp.c
+
+../lib/acountry-ares_strcasecmp.obj: ../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -MT ../lib/acountry-ares_strcasecmp.obj -MD -MP -MF ../lib/$(DEPDIR)/acountry-ares_strcasecmp.Tpo -c -o ../lib/acountry-ares_strcasecmp.obj `if test -f '../lib/ares_strcasecmp.c'; then $(CYGPATH_W) '../lib/ares_strcasecmp.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_strcasecmp.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/acountry-ares_strcasecmp.Tpo ../lib/$(DEPDIR)/acountry-ares_strcasecmp.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_strcasecmp.c' object='../lib/acountry-ares_strcasecmp.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(acountry_CPPFLAGS) $(CPPFLAGS) $(acountry_CFLAGS) $(CFLAGS) -c -o ../lib/acountry-ares_strcasecmp.obj `if test -f '../lib/ares_strcasecmp.c'; then $(CYGPATH_W) '../lib/ares_strcasecmp.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_strcasecmp.c'; fi`
+
+adig-adig.o: adig.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -MT adig-adig.o -MD -MP -MF $(DEPDIR)/adig-adig.Tpo -c -o adig-adig.o `test -f 'adig.c' || echo '$(srcdir)/'`adig.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/adig-adig.Tpo $(DEPDIR)/adig-adig.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='adig.c' object='adig-adig.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -c -o adig-adig.o `test -f 'adig.c' || echo '$(srcdir)/'`adig.c
+
+adig-adig.obj: adig.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -MT adig-adig.obj -MD -MP -MF $(DEPDIR)/adig-adig.Tpo -c -o adig-adig.obj `if test -f 'adig.c'; then $(CYGPATH_W) 'adig.c'; else $(CYGPATH_W) '$(srcdir)/adig.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/adig-adig.Tpo $(DEPDIR)/adig-adig.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='adig.c' object='adig-adig.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -c -o adig-adig.obj `if test -f 'adig.c'; then $(CYGPATH_W) 'adig.c'; else $(CYGPATH_W) '$(srcdir)/adig.c'; fi`
+
+adig-ares_getopt.o: ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -MT adig-ares_getopt.o -MD -MP -MF $(DEPDIR)/adig-ares_getopt.Tpo -c -o adig-ares_getopt.o `test -f 'ares_getopt.c' || echo '$(srcdir)/'`ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/adig-ares_getopt.Tpo $(DEPDIR)/adig-ares_getopt.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getopt.c' object='adig-ares_getopt.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -c -o adig-ares_getopt.o `test -f 'ares_getopt.c' || echo '$(srcdir)/'`ares_getopt.c
+
+adig-ares_getopt.obj: ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -MT adig-ares_getopt.obj -MD -MP -MF $(DEPDIR)/adig-ares_getopt.Tpo -c -o adig-ares_getopt.obj `if test -f 'ares_getopt.c'; then $(CYGPATH_W) 'ares_getopt.c'; else $(CYGPATH_W) '$(srcdir)/ares_getopt.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/adig-ares_getopt.Tpo $(DEPDIR)/adig-ares_getopt.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getopt.c' object='adig-ares_getopt.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -c -o adig-ares_getopt.obj `if test -f 'ares_getopt.c'; then $(CYGPATH_W) 'ares_getopt.c'; else $(CYGPATH_W) '$(srcdir)/ares_getopt.c'; fi`
+
+../lib/adig-ares_nowarn.o: ../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -MT ../lib/adig-ares_nowarn.o -MD -MP -MF ../lib/$(DEPDIR)/adig-ares_nowarn.Tpo -c -o ../lib/adig-ares_nowarn.o `test -f '../lib/ares_nowarn.c' || echo '$(srcdir)/'`../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/adig-ares_nowarn.Tpo ../lib/$(DEPDIR)/adig-ares_nowarn.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_nowarn.c' object='../lib/adig-ares_nowarn.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -c -o ../lib/adig-ares_nowarn.o `test -f '../lib/ares_nowarn.c' || echo '$(srcdir)/'`../lib/ares_nowarn.c
+
+../lib/adig-ares_nowarn.obj: ../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -MT ../lib/adig-ares_nowarn.obj -MD -MP -MF ../lib/$(DEPDIR)/adig-ares_nowarn.Tpo -c -o ../lib/adig-ares_nowarn.obj `if test -f '../lib/ares_nowarn.c'; then $(CYGPATH_W) '../lib/ares_nowarn.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_nowarn.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/adig-ares_nowarn.Tpo ../lib/$(DEPDIR)/adig-ares_nowarn.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_nowarn.c' object='../lib/adig-ares_nowarn.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -c -o ../lib/adig-ares_nowarn.obj `if test -f '../lib/ares_nowarn.c'; then $(CYGPATH_W) '../lib/ares_nowarn.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_nowarn.c'; fi`
+
+../lib/adig-ares_strcasecmp.o: ../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -MT ../lib/adig-ares_strcasecmp.o -MD -MP -MF ../lib/$(DEPDIR)/adig-ares_strcasecmp.Tpo -c -o ../lib/adig-ares_strcasecmp.o `test -f '../lib/ares_strcasecmp.c' || echo '$(srcdir)/'`../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/adig-ares_strcasecmp.Tpo ../lib/$(DEPDIR)/adig-ares_strcasecmp.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_strcasecmp.c' object='../lib/adig-ares_strcasecmp.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -c -o ../lib/adig-ares_strcasecmp.o `test -f '../lib/ares_strcasecmp.c' || echo '$(srcdir)/'`../lib/ares_strcasecmp.c
+
+../lib/adig-ares_strcasecmp.obj: ../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -MT ../lib/adig-ares_strcasecmp.obj -MD -MP -MF ../lib/$(DEPDIR)/adig-ares_strcasecmp.Tpo -c -o ../lib/adig-ares_strcasecmp.obj `if test -f '../lib/ares_strcasecmp.c'; then $(CYGPATH_W) '../lib/ares_strcasecmp.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_strcasecmp.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/adig-ares_strcasecmp.Tpo ../lib/$(DEPDIR)/adig-ares_strcasecmp.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_strcasecmp.c' object='../lib/adig-ares_strcasecmp.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(adig_CPPFLAGS) $(CPPFLAGS) $(adig_CFLAGS) $(CFLAGS) -c -o ../lib/adig-ares_strcasecmp.obj `if test -f '../lib/ares_strcasecmp.c'; then $(CYGPATH_W) '../lib/ares_strcasecmp.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_strcasecmp.c'; fi`
+
+ahost-ahost.o: ahost.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -MT ahost-ahost.o -MD -MP -MF $(DEPDIR)/ahost-ahost.Tpo -c -o ahost-ahost.o `test -f 'ahost.c' || echo '$(srcdir)/'`ahost.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/ahost-ahost.Tpo $(DEPDIR)/ahost-ahost.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ahost.c' object='ahost-ahost.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -c -o ahost-ahost.o `test -f 'ahost.c' || echo '$(srcdir)/'`ahost.c
+
+ahost-ahost.obj: ahost.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -MT ahost-ahost.obj -MD -MP -MF $(DEPDIR)/ahost-ahost.Tpo -c -o ahost-ahost.obj `if test -f 'ahost.c'; then $(CYGPATH_W) 'ahost.c'; else $(CYGPATH_W) '$(srcdir)/ahost.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/ahost-ahost.Tpo $(DEPDIR)/ahost-ahost.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ahost.c' object='ahost-ahost.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -c -o ahost-ahost.obj `if test -f 'ahost.c'; then $(CYGPATH_W) 'ahost.c'; else $(CYGPATH_W) '$(srcdir)/ahost.c'; fi`
+
+ahost-ares_getopt.o: ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -MT ahost-ares_getopt.o -MD -MP -MF $(DEPDIR)/ahost-ares_getopt.Tpo -c -o ahost-ares_getopt.o `test -f 'ares_getopt.c' || echo '$(srcdir)/'`ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/ahost-ares_getopt.Tpo $(DEPDIR)/ahost-ares_getopt.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getopt.c' object='ahost-ares_getopt.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -c -o ahost-ares_getopt.o `test -f 'ares_getopt.c' || echo '$(srcdir)/'`ares_getopt.c
+
+ahost-ares_getopt.obj: ares_getopt.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -MT ahost-ares_getopt.obj -MD -MP -MF $(DEPDIR)/ahost-ares_getopt.Tpo -c -o ahost-ares_getopt.obj `if test -f 'ares_getopt.c'; then $(CYGPATH_W) 'ares_getopt.c'; else $(CYGPATH_W) '$(srcdir)/ares_getopt.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/ahost-ares_getopt.Tpo $(DEPDIR)/ahost-ares_getopt.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='ares_getopt.c' object='ahost-ares_getopt.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -c -o ahost-ares_getopt.obj `if test -f 'ares_getopt.c'; then $(CYGPATH_W) 'ares_getopt.c'; else $(CYGPATH_W) '$(srcdir)/ares_getopt.c'; fi`
+
+../lib/ahost-ares_nowarn.o: ../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -MT ../lib/ahost-ares_nowarn.o -MD -MP -MF ../lib/$(DEPDIR)/ahost-ares_nowarn.Tpo -c -o ../lib/ahost-ares_nowarn.o `test -f '../lib/ares_nowarn.c' || echo '$(srcdir)/'`../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/ahost-ares_nowarn.Tpo ../lib/$(DEPDIR)/ahost-ares_nowarn.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_nowarn.c' object='../lib/ahost-ares_nowarn.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -c -o ../lib/ahost-ares_nowarn.o `test -f '../lib/ares_nowarn.c' || echo '$(srcdir)/'`../lib/ares_nowarn.c
+
+../lib/ahost-ares_nowarn.obj: ../lib/ares_nowarn.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -MT ../lib/ahost-ares_nowarn.obj -MD -MP -MF ../lib/$(DEPDIR)/ahost-ares_nowarn.Tpo -c -o ../lib/ahost-ares_nowarn.obj `if test -f '../lib/ares_nowarn.c'; then $(CYGPATH_W) '../lib/ares_nowarn.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_nowarn.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/ahost-ares_nowarn.Tpo ../lib/$(DEPDIR)/ahost-ares_nowarn.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_nowarn.c' object='../lib/ahost-ares_nowarn.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -c -o ../lib/ahost-ares_nowarn.obj `if test -f '../lib/ares_nowarn.c'; then $(CYGPATH_W) '../lib/ares_nowarn.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_nowarn.c'; fi`
+
+../lib/ahost-ares_strcasecmp.o: ../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -MT ../lib/ahost-ares_strcasecmp.o -MD -MP -MF ../lib/$(DEPDIR)/ahost-ares_strcasecmp.Tpo -c -o ../lib/ahost-ares_strcasecmp.o `test -f '../lib/ares_strcasecmp.c' || echo '$(srcdir)/'`../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/ahost-ares_strcasecmp.Tpo ../lib/$(DEPDIR)/ahost-ares_strcasecmp.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_strcasecmp.c' object='../lib/ahost-ares_strcasecmp.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -c -o ../lib/ahost-ares_strcasecmp.o `test -f '../lib/ares_strcasecmp.c' || echo '$(srcdir)/'`../lib/ares_strcasecmp.c
+
+../lib/ahost-ares_strcasecmp.obj: ../lib/ares_strcasecmp.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -MT ../lib/ahost-ares_strcasecmp.obj -MD -MP -MF ../lib/$(DEPDIR)/ahost-ares_strcasecmp.Tpo -c -o ../lib/ahost-ares_strcasecmp.obj `if test -f '../lib/ares_strcasecmp.c'; then $(CYGPATH_W) '../lib/ares_strcasecmp.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_strcasecmp.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) ../lib/$(DEPDIR)/ahost-ares_strcasecmp.Tpo ../lib/$(DEPDIR)/ahost-ares_strcasecmp.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='../lib/ares_strcasecmp.c' object='../lib/ahost-ares_strcasecmp.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(ahost_CPPFLAGS) $(CPPFLAGS) $(ahost_CFLAGS) $(CFLAGS) -c -o ../lib/ahost-ares_strcasecmp.obj `if test -f '../lib/ares_strcasecmp.c'; then $(CYGPATH_W) '../lib/ares_strcasecmp.c'; else $(CYGPATH_W) '$(srcdir)/../lib/ares_strcasecmp.c'; fi`
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(PROGRAMS)
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+	-rm -f ../lib/$(DEPDIR)/$(am__dirstamp)
+	-rm -f ../lib/$(am__dirstamp)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstPROGRAMS \
+	mostlyclean-am
+
+distclean: distclean-am
+		-rm -f ../lib/$(DEPDIR)/acountry-ares_nowarn.Po
+	-rm -f ../lib/$(DEPDIR)/acountry-ares_strcasecmp.Po
+	-rm -f ../lib/$(DEPDIR)/adig-ares_nowarn.Po
+	-rm -f ../lib/$(DEPDIR)/adig-ares_strcasecmp.Po
+	-rm -f ../lib/$(DEPDIR)/ahost-ares_nowarn.Po
+	-rm -f ../lib/$(DEPDIR)/ahost-ares_strcasecmp.Po
+	-rm -f ./$(DEPDIR)/acountry-acountry.Po
+	-rm -f ./$(DEPDIR)/acountry-ares_getopt.Po
+	-rm -f ./$(DEPDIR)/adig-adig.Po
+	-rm -f ./$(DEPDIR)/adig-ares_getopt.Po
+	-rm -f ./$(DEPDIR)/ahost-ahost.Po
+	-rm -f ./$(DEPDIR)/ahost-ares_getopt.Po
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+		-rm -f ../lib/$(DEPDIR)/acountry-ares_nowarn.Po
+	-rm -f ../lib/$(DEPDIR)/acountry-ares_strcasecmp.Po
+	-rm -f ../lib/$(DEPDIR)/adig-ares_nowarn.Po
+	-rm -f ../lib/$(DEPDIR)/adig-ares_strcasecmp.Po
+	-rm -f ../lib/$(DEPDIR)/ahost-ares_nowarn.Po
+	-rm -f ../lib/$(DEPDIR)/ahost-ares_strcasecmp.Po
+	-rm -f ./$(DEPDIR)/acountry-acountry.Po
+	-rm -f ./$(DEPDIR)/acountry-ares_getopt.Po
+	-rm -f ./$(DEPDIR)/adig-adig.Po
+	-rm -f ./$(DEPDIR)/adig-ares_getopt.Po
+	-rm -f ./$(DEPDIR)/ahost-ahost.Po
+	-rm -f ./$(DEPDIR)/ahost-ares_getopt.Po
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
+	clean-generic clean-libtool clean-noinstPROGRAMS cscopelist-am \
+	ctags ctags-am distclean distclean-compile distclean-generic \
+	distclean-libtool distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-man install-pdf install-pdf-am \
+	install-ps install-ps-am install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags tags-am uninstall uninstall-am
+
+.PRECIOUS: Makefile
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/deps/cares/src/tools/Makefile.inc b/deps/cares/src/tools/Makefile.inc
new file mode 100644
index 0000000000000000000000000000000000000000..7aea8e5f259eeae6a41253797931a8b4d5c737dc
--- /dev/null
+++ b/deps/cares/src/tools/Makefile.inc
@@ -0,0 +1,7 @@
+SAMPLESOURCES = ares_getopt.c		\
+  ../lib/ares_nowarn.c				\
+  ../lib/ares_strcasecmp.c
+
+SAMPLEHEADERS = ares_getopt.h		\
+  ../lib/ares_nowarn.h				\
+  ../lib/ares_strcasecmp.h
diff --git a/deps/cares/src/tools/acountry.c b/deps/cares/src/tools/acountry.c
new file mode 100644
index 0000000000000000000000000000000000000000..a86d7cb0a39a56ec99e96ec36c9176012163b1d9
--- /dev/null
+++ b/deps/cares/src/tools/acountry.c
@@ -0,0 +1,652 @@
+/*
+ *
+ * IP-address/hostname to country converter.
+ *
+ * Problem; you want to know where IP a.b.c.d is located.
+ *
+ * Use ares_gethostbyname ("d.c.b.a.zz.countries.nerd.dk")
+ * and get the CNAME (host->h_name). Result will be:
+ *   CNAME = zz<CC>.countries.nerd.dk with address 127.0.x.y (ver 1) or
+ *   CNAME = <a.b.c.d>.zz.countries.nerd.dk with address 127.0.x.y (ver 2)
+ *
+ * The 2 letter country code is in <CC> and the ISO-3166 country
+ * number is in x.y (number = x*256 + y). Version 2 of the protocol is missing
+ * the <CC> number.
+ *
+ * Ref: http://countries.nerd.dk/more.html
+ *
+ * Written by G. Vanem <gvanem@yahoo.no> 2006, 2007
+ *
+ * NB! This program may not be big-endian aware.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#include "ares_setup.h"
+
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+
+#if defined(WIN32) && !defined(WATT32)
+  #include <winsock.h>
+#else
+  #include <arpa/inet.h>
+  #include <netinet/in.h>
+  #include <netdb.h>
+#endif
+
+#include "ares.h"
+#include "ares_getopt.h"
+#include "ares_nowarn.h"
+
+#ifndef HAVE_STRDUP
+#  include "ares_strdup.h"
+#  define strdup(ptr) ares_strdup(ptr)
+#endif
+
+#ifndef HAVE_STRCASECMP
+#  include "ares_strcasecmp.h"
+#  define strcasecmp(p1,p2) ares_strcasecmp(p1,p2)
+#endif
+
+#ifndef HAVE_STRNCASECMP
+#  include "ares_strcasecmp.h"
+#  define strncasecmp(p1,p2,n) ares_strncasecmp(p1,p2,n)
+#endif
+
+#ifndef INADDR_NONE
+#define INADDR_NONE 0xffffffff
+#endif
+
+/* By using a double cast, we can get rid of the bogus warning of
+ * warning: cast from 'const struct sockaddr *' to 'const struct sockaddr_in6 *' increases required alignment from 1 to 4 [-Wcast-align]
+ */
+#define CARES_INADDR_CAST(type, var) ((type)((void *)var))
+
+static const char *usage      = "acountry [-?hdv] {host|addr} ...\n";
+static const char  nerd_fmt[] = "%u.%u.%u.%u.zz.countries.nerd.dk";
+static const char *nerd_ver1  = nerd_fmt + 14;  /* .countries.nerd.dk */
+static const char *nerd_ver2  = nerd_fmt + 11;  /* .zz.countries.nerd.dk */
+static int         verbose    = 0;
+
+#define TRACE(fmt) do {               \
+                     if (verbose > 0) \
+                       printf fmt ;   \
+                   } WHILE_FALSE
+
+static void wait_ares(ares_channel channel);
+static void callback(void *arg, int status, int timeouts, struct hostent *host);
+static void callback2(void *arg, int status, int timeouts, struct hostent *host);
+static void find_country_from_cname(const char *cname, struct in_addr addr);
+static void print_help_info_acountry(void);
+
+static void Abort(const char *fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+  exit(1);
+}
+
+int main(int argc, char **argv)
+{
+  ares_channel channel;
+  int    ch, status;
+
+#if defined(WIN32) && !defined(WATT32)
+  WORD wVersionRequested = MAKEWORD(USE_WINSOCK,USE_WINSOCK);
+  WSADATA wsaData;
+  WSAStartup(wVersionRequested, &wsaData);
+#endif
+
+  status = ares_library_init(ARES_LIB_INIT_ALL);
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
+      return 1;
+    }
+
+  while ((ch = ares_getopt(argc, argv, "dvh?")) != -1)
+    switch (ch)
+      {
+      case 'd':
+#ifdef WATT32
+        dbug_init();
+#endif
+        break;
+      case 'v':
+        verbose++;
+        break;
+      case 'h':
+        print_help_info_acountry();
+        break;
+      case '?':
+        print_help_info_acountry();
+        break;
+      default:
+        Abort(usage);
+      }
+
+  argc -= optind;
+  argv += optind;
+  if (argc < 1)
+     Abort(usage);
+
+  status = ares_init(&channel);
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_init: %s\n", ares_strerror(status));
+      return 1;
+    }
+
+  /* Initiate the queries, one per command-line argument. */
+  for ( ; *argv; argv++)
+    {
+      struct in_addr addr;
+      char buf[100];
+
+      /* If this fails, assume '*argv' is a host-name that
+       * must be resolved first
+       */
+      if (ares_inet_pton(AF_INET, *argv, &addr) != 1)
+        {
+          ares_gethostbyname(channel, *argv, AF_INET, callback2, &addr);
+          wait_ares(channel);
+          if (addr.s_addr == INADDR_NONE)
+            {
+              printf("Failed to lookup %s\n", *argv);
+              continue;
+            }
+        }
+
+      sprintf(buf, nerd_fmt,
+              (unsigned int)(addr.s_addr >> 24),
+              (unsigned int)((addr.s_addr >> 16) & 255),
+              (unsigned int)((addr.s_addr >> 8) & 255),
+              (unsigned int)(addr.s_addr & 255));
+      TRACE(("Looking up %s...", buf));
+      fflush(stdout);
+      ares_gethostbyname(channel, buf, AF_INET, callback, buf);
+    }
+
+  wait_ares(channel);
+  ares_destroy(channel);
+
+  ares_library_cleanup();
+
+#if defined(WIN32) && !defined(WATT32)
+  WSACleanup();
+#endif
+
+  return 0;
+}
+
+/*
+ * Wait for the queries to complete.
+ */
+static void wait_ares(ares_channel channel)
+{
+  for (;;)
+    {
+      struct timeval *tvp, tv;
+      fd_set read_fds, write_fds;
+      int nfds;
+
+      FD_ZERO(&read_fds);
+      FD_ZERO(&write_fds);
+      nfds = ares_fds(channel, &read_fds, &write_fds);
+      if (nfds == 0)
+        break;
+      tvp = ares_timeout(channel, NULL, &tv);
+      nfds = select(nfds, &read_fds, &write_fds, NULL, tvp);
+      if (nfds < 0)
+        continue;
+      ares_process(channel, &read_fds, &write_fds);
+    }
+}
+
+/*
+ * This is the callback used when we have the IP-address of interest.
+ * Extract the CNAME and figure out the country-code from it.
+ */
+static void callback(void *arg, int status, int timeouts, struct hostent *host)
+{
+  const char *name = (const char*)arg;
+  const char *cname;
+  char buf[20];
+
+  (void)timeouts;
+
+  if (!host || status != ARES_SUCCESS)
+    {
+      printf("Failed to lookup %s: %s\n", name, ares_strerror(status));
+      return;
+    }
+
+  TRACE(("\nFound address %s, name %s\n",
+         ares_inet_ntop(AF_INET,(const char*)host->h_addr,buf,sizeof(buf)),
+         host->h_name));
+
+  cname = host->h_name;  /* CNAME gets put here */
+  if (!cname)
+    printf("Failed to get CNAME for %s\n", name);
+  else
+    find_country_from_cname(cname, *(CARES_INADDR_CAST(struct in_addr *, host->h_addr)));
+}
+
+/*
+ * This is the callback used to obtain the IP-address of the host of interest.
+ */
+static void callback2(void *arg, int status, int timeouts, struct hostent *host)
+{
+  struct in_addr *addr = (struct in_addr*) arg;
+
+  (void)timeouts;
+  if (!host || status != ARES_SUCCESS)
+    memset(addr, INADDR_NONE, sizeof(*addr));
+  else
+    memcpy(addr, host->h_addr, sizeof(*addr));
+}
+
+struct search_list {
+       int         country_number; /* ISO-3166 country number */
+       char        short_name[3];  /* A2 short country code */
+       const char *long_name;      /* normal country name */
+     };
+
+static const struct search_list *list_lookup(int number, const struct search_list *list, int num)
+{
+  while (num > 0 && list->long_name)
+    {
+      if (list->country_number == number)
+        return (list);
+      num--;
+      list++;
+    }
+  return (NULL);
+}
+
+/*
+ * Ref: https://en.wikipedia.org/wiki/ISO_3166-1
+ */
+static const struct search_list country_list[] = {
+       {   4, "af", "Afghanistan"                          },
+       { 248, "ax", "Åland Island"                         },
+       {   8, "al", "Albania"                              },
+       {  12, "dz", "Algeria"                              },
+       {  16, "as", "American Samoa"                       },
+       {  20, "ad", "Andorra"                              },
+       {  24, "ao", "Angola"                               },
+       { 660, "ai", "Anguilla"                             },
+       {  10, "aq", "Antarctica"                           },
+       {  28, "ag", "Antigua & Barbuda"                    },
+       {  32, "ar", "Argentina"                            },
+       {  51, "am", "Armenia"                              },
+       { 533, "aw", "Aruba"                                },
+       {  36, "au", "Australia"                            },
+       {  40, "at", "Austria"                              },
+       {  31, "az", "Azerbaijan"                           },
+       {  44, "bs", "Bahamas"                              },
+       {  48, "bh", "Bahrain"                              },
+       {  50, "bd", "Bangladesh"                           },
+       {  52, "bb", "Barbados"                             },
+       { 112, "by", "Belarus"                              },
+       {  56, "be", "Belgium"                              },
+       {  84, "bz", "Belize"                               },
+       { 204, "bj", "Benin"                                },
+       {  60, "bm", "Bermuda"                              },
+       {  64, "bt", "Bhutan"                               },
+       {  68, "bo", "Bolivia"                              },
+       { 535, "bq", "Bonaire, Sint Eustatius and Saba"     }, /* Formerly 'Bonaire' / 'Netherlands Antilles' */
+       {  70, "ba", "Bosnia & Herzegovina"                 },
+       {  72, "bw", "Botswana"                             },
+       {  74, "bv", "Bouvet Island"                        },
+       {  76, "br", "Brazil"                               },
+       {  86, "io", "British Indian Ocean Territory"       },
+       {  96, "bn", "Brunei Darussalam"                    },
+       { 100, "bg", "Bulgaria"                             },
+       { 854, "bf", "Burkina Faso"                         },
+       { 108, "bi", "Burundi"                              },
+       { 116, "kh", "Cambodia"                             },
+       { 120, "cm", "Cameroon"                             },
+       { 124, "ca", "Canada"                               },
+       { 132, "cv", "Cape Verde"                           },
+       { 136, "ky", "Cayman Islands"                       },
+       { 140, "cf", "Central African Republic"             },
+       { 148, "td", "Chad"                                 },
+       { 152, "cl", "Chile"                                },
+       { 156, "cn", "China"                                },
+       { 162, "cx", "Christmas Island"                     },
+       { 166, "cc", "Cocos Islands"                        },
+       { 170, "co", "Colombia"                             },
+       { 174, "km", "Comoros"                              },
+       { 178, "cg", "Congo"                                },
+       { 180, "cd", "Congo"                                },
+       { 184, "ck", "Cook Islands"                         },
+       { 188, "cr", "Costa Rica"                           },
+       { 384, "ci", "Cote d'Ivoire"                        },
+       { 191, "hr", "Croatia"                              },
+       { 192, "cu", "Cuba"                                 },
+       { 531, "cw", "Curaçao"                              },
+       { 196, "cy", "Cyprus"                               },
+       { 203, "cz", "Czech Republic"                       },
+       { 208, "dk", "Denmark"                              },
+       { 262, "dj", "Djibouti"                             },
+       { 212, "dm", "Dominica"                             },
+       { 214, "do", "Dominican Republic"                   },
+       { 218, "ec", "Ecuador"                              },
+       { 818, "eg", "Egypt"                                },
+       { 222, "sv", "El Salvador"                          },
+       { 226, "gq", "Equatorial Guinea"                    },
+       { 232, "er", "Eritrea"                              },
+       { 233, "ee", "Estonia"                              },
+       { 748, "sz", "Eswatini"                             }, /* Formerly Swaziland */
+       { 231, "et", "Ethiopia"                             },
+     { 65281, "eu", "European Union"                       }, /* 127.0.255.1 */
+       { 238, "fk", "Falkland Islands"                     },
+       { 234, "fo", "Faroe Islands"                        },
+       { 242, "fj", "Fiji"                                 },
+       { 246, "fi", "Finland"                              },
+       { 250, "fr", "France"                               },
+       { 249, "fx", "France, Metropolitan"                 },
+       { 254, "gf", "French Guiana"                        },
+       { 258, "pf", "French Polynesia"                     },
+       { 260, "tf", "French Southern Territories"          },
+       { 266, "ga", "Gabon"                                },
+       { 270, "gm", "Gambia"                               },
+       { 268, "ge", "Georgia"                              },
+       { 276, "de", "Germany"                              },
+       { 288, "gh", "Ghana"                                },
+       { 292, "gi", "Gibraltar"                            },
+       { 300, "gr", "Greece"                               },
+       { 304, "gl", "Greenland"                            },
+       { 308, "gd", "Grenada"                              },
+       { 312, "gp", "Guadeloupe"                           },
+       { 316, "gu", "Guam"                                 },
+       { 320, "gt", "Guatemala"                            },
+       { 831, "gg", "Guernsey"                             },
+       { 324, "gn", "Guinea"                               },
+       { 624, "gw", "Guinea-Bissau"                        },
+       { 328, "gy", "Guyana"                               },
+       { 332, "ht", "Haiti"                                },
+       { 334, "hm", "Heard & Mc Donald Islands"            },
+       { 336, "va", "Holy See"                             }, /* Vatican City */
+       { 340, "hn", "Honduras"                             },
+       { 344, "hk", "Hong kong"                            },
+       { 348, "hu", "Hungary"                              },
+       { 352, "is", "Iceland"                              },
+       { 356, "in", "India"                                },
+       { 360, "id", "Indonesia"                            },
+       { 364, "ir", "Iran"                                 },
+       { 368, "iq", "Iraq"                                 },
+       { 372, "ie", "Ireland"                              },
+       { 833, "im", "Isle of Man"                          },
+       { 376, "il", "Israel"                               },
+       { 380, "it", "Italy"                                },
+       { 388, "jm", "Jamaica"                              },
+       { 392, "jp", "Japan"                                },
+       { 832, "je", "Jersey"                               },
+       { 400, "jo", "Jordan"                               },
+       { 398, "kz", "Kazakhstan"                           },
+       { 404, "ke", "Kenya"                                },
+       { 296, "ki", "Kiribati"                             },
+       { 408, "kp", "Korea (north)"                        },
+       { 410, "kr", "Korea (south)"                        },
+       {   0, "xk", "Kosovo"                               }, /* https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2 */
+       { 414, "kw", "Kuwait"                               },
+       { 417, "kg", "Kyrgyzstan"                           },
+       { 418, "la", "Laos"                                 },
+       { 428, "lv", "Latvia"                               },
+       { 422, "lb", "Lebanon"                              },
+       { 426, "ls", "Lesotho"                              },
+       { 430, "lr", "Liberia"                              },
+       { 434, "ly", "Libya"                                },
+       { 438, "li", "Liechtenstein"                        },
+       { 440, "lt", "Lithuania"                            },
+       { 442, "lu", "Luxembourg"                           },
+       { 446, "mo", "Macao"                                },
+       { 450, "mg", "Madagascar"                           },
+       { 454, "mw", "Malawi"                               },
+       { 458, "my", "Malaysia"                             },
+       { 462, "mv", "Maldives"                             },
+       { 466, "ml", "Mali"                                 },
+       { 470, "mt", "Malta"                                },
+       { 584, "mh", "Marshall Islands"                     },
+       { 474, "mq", "Martinique"                           },
+       { 478, "mr", "Mauritania"                           },
+       { 480, "mu", "Mauritius"                            },
+       { 175, "yt", "Mayotte"                              },
+       { 484, "mx", "Mexico"                               },
+       { 583, "fm", "Micronesia"                           },
+       { 498, "md", "Moldova"                              },
+       { 492, "mc", "Monaco"                               },
+       { 496, "mn", "Mongolia"                             },
+       { 499, "me", "Montenegro"                           },  
+       { 500, "ms", "Montserrat"                           },
+       { 504, "ma", "Morocco"                              },
+       { 508, "mz", "Mozambique"                           },
+       { 104, "mm", "Myanmar"                              },
+       { 516, "na", "Namibia"                              },
+       { 520, "nr", "Nauru"                                },
+       { 524, "np", "Nepal"                                },
+       { 528, "nl", "Netherlands"                          },
+       { 540, "nc", "New Caledonia"                        },
+       { 554, "nz", "New Zealand"                          },
+       { 558, "ni", "Nicaragua"                            },
+       { 562, "ne", "Niger"                                },
+       { 566, "ng", "Nigeria"                              },
+       { 570, "nu", "Niue"                                 },
+       { 574, "nf", "Norfolk Island"                       },
+       { 807, "mk", "North Macedonia"                      }, /* 'Macedonia' until February 2019 */
+       { 580, "mp", "Northern Mariana Islands"             },
+       { 578, "no", "Norway"                               },
+       { 512, "om", "Oman"                                 },
+       { 586, "pk", "Pakistan"                             },
+       { 585, "pw", "Palau"                                },
+       { 275, "ps", "Palestinian Territory"                },
+       { 591, "pa", "Panama"                               },
+       { 598, "pg", "Papua New Guinea"                     },
+       { 600, "py", "Paraguay"                             },
+       { 604, "pe", "Peru"                                 },
+       { 608, "ph", "Philippines"                          },
+       { 612, "pn", "Pitcairn"                             },
+       { 616, "pl", "Poland"                               },
+       { 620, "pt", "Portugal"                             },
+       { 630, "pr", "Puerto Rico"                          },
+       { 634, "qa", "Qatar"                                },
+       { 638, "re", "Reunion"                              },
+       { 642, "ro", "Romania"                              },
+       { 643, "ru", "Russian Federation"                   },
+       { 646, "rw", "Rwanda"                               },
+       { 0,   "bl", "Saint Barthélemy"                     }, /* https://en.wikipedia.org/wiki/ISO_3166-2:BL */
+       { 659, "kn", "Saint Kitts & Nevis"                  },
+       { 662, "lc", "Saint Lucia"                          },
+       { 663, "mf", "Saint Martin"                         },
+       { 670, "vc", "Saint Vincent"                        },
+       { 882, "ws", "Samoa"                                },
+       { 674, "sm", "San Marino"                           },
+       { 678, "st", "Sao Tome & Principe"                  },
+       { 682, "sa", "Saudi Arabia"                         },
+       { 686, "sn", "Senegal"                              },
+       { 688, "rs", "Serbia"                               },
+       { 690, "sc", "Seychelles"                           },
+       { 694, "sl", "Sierra Leone"                         },
+       { 702, "sg", "Singapore"                            },
+       { 534, "sx", "Sint Maarten"                         },
+       { 703, "sk", "Slovakia"                             },
+       { 705, "si", "Slovenia"                             },
+       {  90, "sb", "Solomon Islands"                      },
+       { 706, "so", "Somalia"                              },
+       { 710, "za", "South Africa"                         },
+       { 239, "gs", "South Georgia & South Sandwich Is."   },
+       { 728, "ss", "South Sudan"                          },
+       { 724, "es", "Spain"                                },
+       { 144, "lk", "Sri Lanka"                            },
+       { 654, "sh", "St. Helena"                           },
+       { 666, "pm", "St. Pierre & Miquelon"                },
+       { 736, "sd", "Sudan"                                },
+       { 740, "sr", "Suriname"                             },
+       { 744, "sj", "Svalbard & Jan Mayen Islands"         },
+       { 752, "se", "Sweden"                               },
+       { 756, "ch", "Switzerland"                          },
+       { 760, "sy", "Syrian Arab Republic"                 },
+       { 158, "tw", "Taiwan"                               },
+       { 762, "tj", "Tajikistan"                           },
+       { 834, "tz", "Tanzania"                             },
+       { 764, "th", "Thailand"                             },
+       { 626, "tl", "Timor-Leste"                          },
+       { 768, "tg", "Togo"                                 },
+       { 772, "tk", "Tokelau"                              },
+       { 776, "to", "Tonga"                                },
+       { 780, "tt", "Trinidad & Tobago"                    },
+       { 788, "tn", "Tunisia"                              },
+       { 792, "tr", "Turkey"                               },
+       { 795, "tm", "Turkmenistan"                         },
+       { 796, "tc", "Turks & Caicos Islands"               },
+       { 798, "tv", "Tuvalu"                               },
+       { 800, "ug", "Uganda"                               },
+       { 804, "ua", "Ukraine"                              },
+       { 784, "ae", "United Arab Emirates"                 },
+       { 826, "gb", "United Kingdom"                       },
+       { 840, "us", "United States"                        },
+       { 581, "um", "United States Minor Outlying Islands" },
+       { 858, "uy", "Uruguay"                              },
+       { 860, "uz", "Uzbekistan"                           },
+       { 548, "vu", "Vanuatu"                              },
+       { 862, "ve", "Venezuela"                            },
+       { 704, "vn", "Vietnam"                              },
+       {  92, "vg", "Virgin Islands (British)"             },
+       { 850, "vi", "Virgin Islands (US)"                  },
+       { 876, "wf", "Wallis & Futuna Islands"              },
+       { 732, "eh", "Western Sahara"                       },
+       { 887, "ye", "Yemen"                                },
+       { 894, "zm", "Zambia"                               },
+       { 716, "zw", "Zimbabwe"                             }
+     };
+
+/*
+ * Check if start of 'str' is simply an IPv4 address.
+ */
+#define BYTE_OK(x) ((x) >= 0 && (x) <= 255)
+
+static int is_addr(char *str, char **end)
+{
+  int a0, a1, a2, a3, num, rc = 0, length = 0;
+
+  num = sscanf(str,"%3d.%3d.%3d.%3d%n",&a0,&a1,&a2,&a3,&length);
+  if( (num == 4) &&
+      BYTE_OK(a0) && BYTE_OK(a1) && BYTE_OK(a2) && BYTE_OK(a3) &&
+      length >= (3+4))
+    {
+      rc = 1;
+      *end = str + length;
+    }
+  return rc;
+}
+
+/*
+ * Find the country-code and name from the CNAME. E.g.:
+ *   version 1: CNAME = zzno.countries.nerd.dk with address 127.0.2.66
+ *              yields ccode_A" = "no" and cnumber 578 (2.66).
+ *   version 2: CNAME = <a.b.c.d>.zz.countries.nerd.dk with address 127.0.2.66
+ *              yields cnumber 578 (2.66). ccode_A is "";
+ */
+static void find_country_from_cname(const char *cname, struct in_addr addr)
+{
+  const struct search_list *country;
+  char  ccode_A2[3], *ccopy, *dot_4;
+  int   cnumber, z0, z1, ver_1, ver_2;
+  unsigned long ip;
+
+  ip = ntohl(addr.s_addr);
+  z0 = TOLOWER(cname[0]);
+  z1 = TOLOWER(cname[1]);
+  ccopy = strdup(cname);
+  dot_4 = NULL;
+
+  ver_1 = (z0 == 'z' && z1 == 'z' && !strcasecmp(cname+4,nerd_ver1));
+  ver_2 = (is_addr(ccopy,&dot_4) && !strcasecmp(dot_4,nerd_ver2));
+
+  if (ver_1)
+    {
+      const char *dot = strchr(cname, '.');
+      if (dot != cname+4)
+        {
+          printf("Unexpected CNAME %s (ver_1)\n", cname);
+          free(ccopy);
+          return;
+        }
+    }
+  else if (ver_2)
+    {
+      z0 = TOLOWER(dot_4[1]);
+      z1 = TOLOWER(dot_4[2]);
+      if (z0 != 'z' && z1 != 'z')
+        {
+          printf("Unexpected CNAME %s (ver_2)\n", cname);
+          free(ccopy);
+          return;
+        }
+    }
+  else
+    {
+      printf("Unexpected CNAME %s (ver?)\n", cname);
+      free(ccopy);
+      return;
+    }
+
+  if (ver_1)
+    {
+      ccode_A2[0] = (char)TOLOWER(cname[2]);
+      ccode_A2[1] = (char)TOLOWER(cname[3]);
+      ccode_A2[2] = '\0';
+    }
+  else
+    ccode_A2[0] = '\0';
+
+  cnumber = ip & 0xFFFF;
+
+  TRACE(("Found country-code `%s', number %d\n",
+         ver_1 ? ccode_A2 : "<n/a>", cnumber));
+
+  country = list_lookup(cnumber, country_list,
+                        sizeof(country_list) / sizeof(country_list[0]));
+  if (!country)
+    printf("Name for country-number %d not found.\n", cnumber);
+  else
+    {
+      if (ver_1)
+        {
+          if ((country->short_name[0] != ccode_A2[0]) ||
+              (country->short_name[1] != ccode_A2[1]) ||
+              (country->short_name[2] != ccode_A2[2]))
+            printf("short-name mismatch; %s vs %s\n",
+                   country->short_name, ccode_A2);
+        }
+      printf("%s (%s), number %d.\n",
+             country->long_name, country->short_name, cnumber);
+    }
+  free(ccopy);
+}
+
+/* Information from the man page. Formatting taken from man -h */
+static void print_help_info_acountry(void) {
+    printf("acountry, version %s \n\n", ARES_VERSION_STR);
+    printf("usage: acountry [-hdv] {host|addr} ...\n\n"
+    "  d : Print some extra debugging output.\n"
+    "  h : Display this help and exit.\n"
+    "  v : Be more verbose. Print extra information.\n\n");
+    exit(0);
+}
diff --git a/deps/cares/src/tools/adig.c b/deps/cares/src/tools/adig.c
new file mode 100644
index 0000000000000000000000000000000000000000..412ad467b5525bf84262dc792dd23f46a6b3333b
--- /dev/null
+++ b/deps/cares/src/tools/adig.c
@@ -0,0 +1,983 @@
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ *
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#include "ares_setup.h"
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+
+#include "ares_nameser.h"
+
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+
+#include "ares.h"
+#include "ares_dns.h"
+#include "ares_getopt.h"
+#include "ares_nowarn.h"
+
+#ifndef HAVE_STRDUP
+#  include "ares_strdup.h"
+#  define strdup(ptr) ares_strdup(ptr)
+#endif
+
+#ifndef HAVE_STRCASECMP
+#  include "ares_strcasecmp.h"
+#  define strcasecmp(p1,p2) ares_strcasecmp(p1,p2)
+#endif
+
+#ifndef HAVE_STRNCASECMP
+#  include "ares_strcasecmp.h"
+#  define strncasecmp(p1,p2,n) ares_strncasecmp(p1,p2,n)
+#endif
+
+#ifdef WATT32
+#undef WIN32  /* Redefined in MingW headers */
+#endif
+
+
+struct nv {
+  const char *name;
+  int value;
+};
+
+static const struct nv flags[] = {
+  { "usevc",            ARES_FLAG_USEVC },
+  { "primary",          ARES_FLAG_PRIMARY },
+  { "igntc",            ARES_FLAG_IGNTC },
+  { "norecurse",        ARES_FLAG_NORECURSE },
+  { "stayopen",         ARES_FLAG_STAYOPEN },
+  { "noaliases",        ARES_FLAG_NOALIASES }
+};
+static const int nflags = sizeof(flags) / sizeof(flags[0]);
+
+static const struct nv classes[] = {
+  { "IN",       C_IN },
+  { "CHAOS",    C_CHAOS },
+  { "HS",       C_HS },
+  { "ANY",      C_ANY }
+};
+static const int nclasses = sizeof(classes) / sizeof(classes[0]);
+
+static const struct nv types[] = {
+  { "A",        T_A },
+  { "NS",       T_NS },
+  { "MD",       T_MD },
+  { "MF",       T_MF },
+  { "CNAME",    T_CNAME },
+  { "SOA",      T_SOA },
+  { "MB",       T_MB },
+  { "MG",       T_MG },
+  { "MR",       T_MR },
+  { "NULL",     T_NULL },
+  { "WKS",      T_WKS },
+  { "PTR",      T_PTR },
+  { "HINFO",    T_HINFO },
+  { "MINFO",    T_MINFO },
+  { "MX",       T_MX },
+  { "TXT",      T_TXT },
+  { "RP",       T_RP },
+  { "AFSDB",    T_AFSDB },
+  { "X25",      T_X25 },
+  { "ISDN",     T_ISDN },
+  { "RT",       T_RT },
+  { "NSAP",     T_NSAP },
+  { "NSAP_PTR", T_NSAP_PTR },
+  { "SIG",      T_SIG },
+  { "KEY",      T_KEY },
+  { "PX",       T_PX },
+  { "GPOS",     T_GPOS },
+  { "AAAA",     T_AAAA },
+  { "LOC",      T_LOC },
+  { "SRV",      T_SRV },
+  { "AXFR",     T_AXFR },
+  { "MAILB",    T_MAILB },
+  { "MAILA",    T_MAILA },
+  { "NAPTR",    T_NAPTR },
+  { "DS",       T_DS },
+  { "SSHFP",    T_SSHFP },
+  { "RRSIG",    T_RRSIG },
+  { "NSEC",     T_NSEC },
+  { "DNSKEY",   T_DNSKEY },
+  { "CAA",      T_CAA },
+  { "URI",      T_URI },
+  { "ANY",      T_ANY }
+};
+static const int ntypes = sizeof(types) / sizeof(types[0]);
+
+static const char *opcodes[] = {
+  "QUERY", "IQUERY", "STATUS", "(reserved)", "NOTIFY",
+  "(unknown)", "(unknown)", "(unknown)", "(unknown)",
+  "UPDATEA", "UPDATED", "UPDATEDA", "UPDATEM", "UPDATEMA",
+  "ZONEINIT", "ZONEREF"
+};
+
+static const char *rcodes[] = {
+  "NOERROR", "FORMERR", "SERVFAIL", "NXDOMAIN", "NOTIMP", "REFUSED",
+  "(unknown)", "(unknown)", "(unknown)", "(unknown)", "(unknown)",
+  "(unknown)", "(unknown)", "(unknown)", "(unknown)", "NOCHANGE"
+};
+
+static void callback(void *arg, int status, int timeouts,
+                     unsigned char *abuf, int alen);
+static const unsigned char *display_question(const unsigned char *aptr,
+                                             const unsigned char *abuf,
+                                             int alen);
+static const unsigned char *display_rr(const unsigned char *aptr,
+                                       const unsigned char *abuf, int alen);
+static int convert_query (char **name, int use_bitstring);
+static const char *type_name(int type);
+static const char *class_name(int dnsclass);
+static void usage(void);
+static void destroy_addr_list(struct ares_addr_node *head);
+static void append_addr_list(struct ares_addr_node **head,
+                             struct ares_addr_node *node);
+static void print_help_info_adig(void);
+
+int main(int argc, char **argv)
+{
+  ares_channel channel;
+  int c, i, optmask = ARES_OPT_FLAGS, dnsclass = C_IN, type = T_A;
+  int status, nfds, count;
+  int use_ptr_helper = 0;
+  struct ares_options options;
+  struct hostent *hostent;
+  fd_set read_fds, write_fds;
+  struct timeval *tvp, tv;
+  struct ares_addr_node *srvr, *servers = NULL;
+
+#ifdef USE_WINSOCK
+  WORD wVersionRequested = MAKEWORD(USE_WINSOCK,USE_WINSOCK);
+  WSADATA wsaData;
+  WSAStartup(wVersionRequested, &wsaData);
+#endif
+
+  status = ares_library_init(ARES_LIB_INIT_ALL);
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
+      return 1;
+    }
+
+  options.flags = ARES_FLAG_NOCHECKRESP;
+  options.servers = NULL;
+  options.nservers = 0;
+  while ((c = ares_getopt(argc, argv, "dh?f:s:c:t:T:U:x")) != -1)
+    {
+      switch (c)
+        {
+        case 'd':
+#ifdef WATT32
+          dbug_init();
+#endif
+          break;
+        case 'h':
+          print_help_info_adig();
+          break;
+        case '?':
+          print_help_info_adig();
+          break;
+        case 'f':
+          /* Add a flag. */
+          for (i = 0; i < nflags; i++)
+            {
+              if (strcmp(flags[i].name, optarg) == 0)
+                break;
+            }
+          if (i < nflags)
+            options.flags |= flags[i].value;
+          else
+            usage();
+          break;
+
+        case 's':
+          /* User-specified name servers override default ones. */
+          srvr = malloc(sizeof(struct ares_addr_node));
+          if (!srvr)
+            {
+              fprintf(stderr, "Out of memory!\n");
+              destroy_addr_list(servers);
+              return 1;
+            }
+          append_addr_list(&servers, srvr);
+          if (ares_inet_pton(AF_INET, optarg, &srvr->addr.addr4) > 0)
+            srvr->family = AF_INET;
+          else if (ares_inet_pton(AF_INET6, optarg, &srvr->addr.addr6) > 0)
+            srvr->family = AF_INET6;
+          else
+            {
+              hostent = gethostbyname(optarg);
+              if (!hostent)
+                {
+                  fprintf(stderr, "adig: server %s not found.\n", optarg);
+                  destroy_addr_list(servers);
+                  return 1;
+                }
+              switch (hostent->h_addrtype)
+                {
+                  case AF_INET:
+                    srvr->family = AF_INET;
+                    memcpy(&srvr->addr.addr4, hostent->h_addr,
+                           sizeof(srvr->addr.addr4));
+                    break;
+                  case AF_INET6:
+                    srvr->family = AF_INET6;
+                    memcpy(&srvr->addr.addr6, hostent->h_addr,
+                           sizeof(srvr->addr.addr6));
+                    break;
+                  default:
+                    fprintf(stderr,
+                      "adig: server %s unsupported address family.\n", optarg);
+                    destroy_addr_list(servers);
+                    return 1;
+                }
+            }
+          /* Notice that calling ares_init_options() without servers in the
+           * options struct and with ARES_OPT_SERVERS set simultaneously in
+           * the options mask, results in an initialization with no servers.
+           * When alternative name servers have been specified these are set
+           * later calling ares_set_servers() overriding any existing server
+           * configuration. To prevent initial configuration with default
+           * servers that will be discarded later, ARES_OPT_SERVERS is set.
+           * If this flag is not set here the result shall be the same but
+           * ares_init_options() will do needless work. */
+          optmask |= ARES_OPT_SERVERS;
+          break;
+
+        case 'c':
+          /* Set the query class. */
+          for (i = 0; i < nclasses; i++)
+            {
+              if (strcasecmp(classes[i].name, optarg) == 0)
+                break;
+            }
+          if (i < nclasses)
+            dnsclass = classes[i].value;
+          else
+            usage();
+          break;
+
+        case 't':
+          /* Set the query type. */
+          for (i = 0; i < ntypes; i++)
+            {
+              if (strcasecmp(types[i].name, optarg) == 0)
+                break;
+            }
+          if (i < ntypes)
+            type = types[i].value;
+          else
+            usage();
+          break;
+
+        case 'T':
+          /* Set the TCP port number. */
+          if (!ISDIGIT(*optarg))
+            usage();
+          options.tcp_port = (unsigned short)strtol(optarg, NULL, 0);
+          optmask |= ARES_OPT_TCP_PORT;
+          break;
+
+        case 'U':
+          /* Set the UDP port number. */
+          if (!ISDIGIT(*optarg))
+            usage();
+          options.udp_port = (unsigned short)strtol(optarg, NULL, 0);
+          optmask |= ARES_OPT_UDP_PORT;
+          break;
+
+        case 'x':
+          use_ptr_helper++;
+          break;
+        }
+    }
+  argc -= optind;
+  argv += optind;
+  if (argc == 0)
+    usage();
+
+  status = ares_init_options(&channel, &options, optmask);
+
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_init_options: %s\n",
+              ares_strerror(status));
+      return 1;
+    }
+
+  if(servers)
+    {
+      status = ares_set_servers(channel, servers);
+      destroy_addr_list(servers);
+      if (status != ARES_SUCCESS)
+        {
+          fprintf(stderr, "ares_init_options: %s\n",
+                  ares_strerror(status));
+          return 1;
+        }
+    }
+
+  /* Initiate the queries, one per command-line argument.  If there is
+   * only one query to do, supply NULL as the callback argument;
+   * otherwise, supply the query name as an argument so we can
+   * distinguish responses for the user when printing them out.
+   */
+  for (i = 1; *argv; i++, argv++)
+    {
+      char *query = *argv;
+
+      if (type == T_PTR && dnsclass == C_IN && use_ptr_helper)
+         if (!convert_query (&query, use_ptr_helper >= 2))
+            continue;
+
+      ares_query(channel, query, dnsclass, type, callback, i < argc-1 ? (void*)query : NULL);
+    }
+
+  /* Wait for all queries to complete. */
+  for (;;)
+    {
+      FD_ZERO(&read_fds);
+      FD_ZERO(&write_fds);
+      nfds = ares_fds(channel, &read_fds, &write_fds);
+      if (nfds == 0)
+        break;
+      tvp = ares_timeout(channel, NULL, &tv);
+      count = select(nfds, &read_fds, &write_fds, NULL, tvp);
+      if (count < 0 && (status = SOCKERRNO) != EINVAL)
+        {
+          printf("select fail: %d", status);
+          return 1;
+        }
+      ares_process(channel, &read_fds, &write_fds);
+    }
+
+  ares_destroy(channel);
+
+  ares_library_cleanup();
+
+#ifdef USE_WINSOCK
+  WSACleanup();
+#endif
+
+  return 0;
+}
+
+static void callback(void *arg, int status, int timeouts,
+                     unsigned char *abuf, int alen)
+{
+  char *name = (char *) arg;
+  int id, qr, opcode, aa, tc, rd, ra, rcode;
+  unsigned int qdcount, ancount, nscount, arcount, i;
+  const unsigned char *aptr;
+
+  (void) timeouts;
+
+  /* Display the query name if given. */
+  if (name)
+    printf("Answer for query %s:\n", name);
+
+  /* Display an error message if there was an error, but only stop if
+   * we actually didn't get an answer buffer.
+   */
+  if (status != ARES_SUCCESS)
+    {
+      printf("%s\n", ares_strerror(status));
+      if (!abuf)
+        return;
+    }
+
+  /* Won't happen, but check anyway, for safety. */
+  if (alen < HFIXEDSZ)
+    return;
+
+  /* Parse the answer header. */
+  id = DNS_HEADER_QID(abuf);
+  qr = DNS_HEADER_QR(abuf);
+  opcode = DNS_HEADER_OPCODE(abuf);
+  aa = DNS_HEADER_AA(abuf);
+  tc = DNS_HEADER_TC(abuf);
+  rd = DNS_HEADER_RD(abuf);
+  ra = DNS_HEADER_RA(abuf);
+  rcode = DNS_HEADER_RCODE(abuf);
+  qdcount = DNS_HEADER_QDCOUNT(abuf);
+  ancount = DNS_HEADER_ANCOUNT(abuf);
+  nscount = DNS_HEADER_NSCOUNT(abuf);
+  arcount = DNS_HEADER_ARCOUNT(abuf);
+
+  /* Display the answer header. */
+  printf("id: %d\n", id);
+  printf("flags: %s%s%s%s%s\n",
+         qr ? "qr " : "",
+         aa ? "aa " : "",
+         tc ? "tc " : "",
+         rd ? "rd " : "",
+         ra ? "ra " : "");
+  printf("opcode: %s\n", opcodes[opcode]);
+  printf("rcode: %s\n", rcodes[rcode]);
+
+  /* Display the questions. */
+  printf("Questions:\n");
+  aptr = abuf + HFIXEDSZ;
+  for (i = 0; i < qdcount; i++)
+    {
+      aptr = display_question(aptr, abuf, alen);
+      if (aptr == NULL)
+        return;
+    }
+
+  /* Display the answers. */
+  printf("Answers:\n");
+  for (i = 0; i < ancount; i++)
+    {
+      aptr = display_rr(aptr, abuf, alen);
+      if (aptr == NULL)
+        return;
+    }
+
+  /* Display the NS records. */
+  printf("NS records:\n");
+  for (i = 0; i < nscount; i++)
+    {
+      aptr = display_rr(aptr, abuf, alen);
+      if (aptr == NULL)
+        return;
+    }
+
+  /* Display the additional records. */
+  printf("Additional records:\n");
+  for (i = 0; i < arcount; i++)
+    {
+      aptr = display_rr(aptr, abuf, alen);
+      if (aptr == NULL)
+        return;
+    }
+}
+
+static const unsigned char *display_question(const unsigned char *aptr,
+                                             const unsigned char *abuf,
+                                             int alen)
+{
+  char *name;
+  int type, dnsclass, status;
+  long len;
+
+  /* Parse the question name. */
+  status = ares_expand_name(aptr, abuf, alen, &name, &len);
+  if (status != ARES_SUCCESS)
+    return NULL;
+  aptr += len;
+
+  /* Make sure there's enough data after the name for the fixed part
+   * of the question.
+   */
+  if (aptr + QFIXEDSZ > abuf + alen)
+    {
+      ares_free_string(name);
+      return NULL;
+    }
+
+  /* Parse the question type and class. */
+  type = DNS_QUESTION_TYPE(aptr);
+  dnsclass = DNS_QUESTION_CLASS(aptr);
+  aptr += QFIXEDSZ;
+
+  /* Display the question, in a format sort of similar to how we will
+   * display RRs.
+   */
+  printf("\t%-15s.\t", name);
+  if (dnsclass != C_IN)
+    printf("\t%s", class_name(dnsclass));
+  printf("\t%s\n", type_name(type));
+  ares_free_string(name);
+  return aptr;
+}
+
+static const unsigned char *display_rr(const unsigned char *aptr,
+                                       const unsigned char *abuf, int alen)
+{
+  const unsigned char *p;
+  int type, dnsclass, ttl, dlen, status, i;
+  long len;
+  int vlen;
+  char addr[46];
+  union {
+    unsigned char * as_uchar;
+             char * as_char;
+  } name;
+
+  /* Parse the RR name. */
+  status = ares_expand_name(aptr, abuf, alen, &name.as_char, &len);
+  if (status != ARES_SUCCESS)
+    return NULL;
+  aptr += len;
+
+  /* Make sure there is enough data after the RR name for the fixed
+   * part of the RR.
+   */
+  if (aptr + RRFIXEDSZ > abuf + alen)
+    {
+      ares_free_string(name.as_char);
+      return NULL;
+    }
+
+  /* Parse the fixed part of the RR, and advance to the RR data
+   * field. */
+  type = DNS_RR_TYPE(aptr);
+  dnsclass = DNS_RR_CLASS(aptr);
+  ttl = DNS_RR_TTL(aptr);
+  dlen = DNS_RR_LEN(aptr);
+  aptr += RRFIXEDSZ;
+  if (aptr + dlen > abuf + alen)
+    {
+      ares_free_string(name.as_char);
+      return NULL;
+    }
+
+  /* Display the RR name, class, and type. */
+  printf("\t%-15s.\t%d", name.as_char, ttl);
+  if (dnsclass != C_IN)
+    printf("\t%s", class_name(dnsclass));
+  printf("\t%s", type_name(type));
+  ares_free_string(name.as_char);
+
+  /* Display the RR data.  Don't touch aptr. */
+  switch (type)
+    {
+    case T_CNAME:
+    case T_MB:
+    case T_MD:
+    case T_MF:
+    case T_MG:
+    case T_MR:
+    case T_NS:
+    case T_PTR:
+      /* For these types, the RR data is just a domain name. */
+      status = ares_expand_name(aptr, abuf, alen, &name.as_char, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t%s.", name.as_char);
+      ares_free_string(name.as_char);
+      break;
+
+    case T_HINFO:
+      /* The RR data is two length-counted character strings. */
+      p = aptr;
+      len = *p;
+      if (p + len + 1 > aptr + dlen)
+        return NULL;
+      status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t%s", name.as_char);
+      ares_free_string(name.as_char);
+      p += len;
+      len = *p;
+      if (p + len + 1 > aptr + dlen)
+        return NULL;
+      status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t%s", name.as_char);
+      ares_free_string(name.as_char);
+      break;
+
+    case T_MINFO:
+      /* The RR data is two domain names. */
+      p = aptr;
+      status = ares_expand_name(p, abuf, alen, &name.as_char, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t%s.", name.as_char);
+      ares_free_string(name.as_char);
+      p += len;
+      status = ares_expand_name(p, abuf, alen, &name.as_char, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t%s.", name.as_char);
+      ares_free_string(name.as_char);
+      break;
+
+    case T_MX:
+      /* The RR data is two bytes giving a preference ordering, and
+       * then a domain name.
+       */
+      if (dlen < 2)
+        return NULL;
+      printf("\t%d", (int)DNS__16BIT(aptr));
+      status = ares_expand_name(aptr + 2, abuf, alen, &name.as_char, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t%s.", name.as_char);
+      ares_free_string(name.as_char);
+      break;
+
+    case T_SOA:
+      /* The RR data is two domain names and then five four-byte
+       * numbers giving the serial number and some timeouts.
+       */
+      p = aptr;
+      status = ares_expand_name(p, abuf, alen, &name.as_char, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t%s.\n", name.as_char);
+      ares_free_string(name.as_char);
+      p += len;
+      status = ares_expand_name(p, abuf, alen, &name.as_char, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t\t\t\t\t\t%s.\n", name.as_char);
+      ares_free_string(name.as_char);
+      p += len;
+      if (p + 20 > aptr + dlen)
+        return NULL;
+      printf("\t\t\t\t\t\t( %u %u %u %u %u )",
+             DNS__32BIT(p), DNS__32BIT(p+4),
+             DNS__32BIT(p+8), DNS__32BIT(p+12),
+             DNS__32BIT(p+16));
+      break;
+
+    case T_TXT:
+      /* The RR data is one or more length-counted character
+       * strings. */
+      p = aptr;
+      while (p < aptr + dlen)
+        {
+          len = *p;
+          if (p + len + 1 > aptr + dlen)
+            return NULL;
+          status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len);
+          if (status != ARES_SUCCESS)
+            return NULL;
+          printf("\t%s", name.as_char);
+          ares_free_string(name.as_char);
+          p += len;
+        }
+      break;
+
+    case T_CAA:
+
+      p = aptr;
+
+      /* Flags */
+      printf(" %u", (int)*p);
+      p += 1;
+
+      /* Remainder of record */
+      vlen = (int)dlen - ((char)*p) - 2;
+
+      /* The Property identifier, one of:
+          - "issue",
+          - "iodef", or
+          - "issuewild" */
+      status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf(" %s", name.as_char);
+      ares_free_string(name.as_char);
+      p += len;
+
+      if (p + vlen > abuf + alen)
+        return NULL;
+
+      /* A sequence of octets representing the Property Value */
+      printf(" %.*s", vlen, p);
+      break;
+
+    case T_A:
+      /* The RR data is a four-byte Internet address. */
+      if (dlen != 4)
+        return NULL;
+      printf("\t%s", ares_inet_ntop(AF_INET,aptr,addr,sizeof(addr)));
+      break;
+
+    case T_AAAA:
+      /* The RR data is a 16-byte IPv6 address. */
+      if (dlen != 16)
+        return NULL;
+      printf("\t%s", ares_inet_ntop(AF_INET6,aptr,addr,sizeof(addr)));
+      break;
+
+    case T_WKS:
+      /* Not implemented yet */
+      break;
+
+    case T_SRV:
+      /* The RR data is three two-byte numbers representing the
+       * priority, weight, and port, followed by a domain name.
+       */
+
+      printf("\t%d", (int)DNS__16BIT(aptr));
+      printf(" %d", (int)DNS__16BIT(aptr + 2));
+      printf(" %d", (int)DNS__16BIT(aptr + 4));
+
+      status = ares_expand_name(aptr + 6, abuf, alen, &name.as_char, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t%s.", name.as_char);
+      ares_free_string(name.as_char);
+      break;
+
+    case T_URI:
+      /* The RR data is two two-byte numbers representing the
+       * priority and weight, followed by a target.
+       */
+
+      printf("\t%d ", (int)DNS__16BIT(aptr));
+      printf("%d \t\t", (int)DNS__16BIT(aptr+2));
+      p = aptr +4;
+      for (i=0; i <dlen-4; ++i)
+        printf("%c",p[i]);
+      break;
+
+    case T_NAPTR:
+
+      printf("\t%d", (int)DNS__16BIT(aptr)); /* order */
+      printf(" %d\n", (int)DNS__16BIT(aptr + 2)); /* preference */
+
+      p = aptr + 4;
+      status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t\t\t\t\t\t%s\n", name.as_char);
+      ares_free_string(name.as_char);
+      p += len;
+
+      status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t\t\t\t\t\t%s\n", name.as_char);
+      ares_free_string(name.as_char);
+      p += len;
+
+      status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t\t\t\t\t\t%s\n", name.as_char);
+      ares_free_string(name.as_char);
+      p += len;
+
+      status = ares_expand_name(p, abuf, alen, &name.as_char, &len);
+      if (status != ARES_SUCCESS)
+        return NULL;
+      printf("\t\t\t\t\t\t%s", name.as_char);
+      ares_free_string(name.as_char);
+      break;
+
+    case T_DS:
+    case T_SSHFP:
+    case T_RRSIG:
+    case T_NSEC:
+    case T_DNSKEY:
+      printf("\t[RR type parsing unavailable]");
+      break;
+
+    default:
+      printf("\t[Unknown RR; cannot parse]");
+      break;
+    }
+  printf("\n");
+
+  return aptr + dlen;
+}
+
+/*
+ * With the '-x' (or '-xx') and '-t PTR' options, convert a query for an
+ * address into a more useful 'T_PTR' type question.
+ * Like with an input 'query':
+ *  "a.b.c.d"  ->  "d.c.b.a".in-addr.arpa"          for an IPv4 address.
+ *  "a.b.c....x.y.z" -> "z.y.x....c.d.e.IP6.ARPA"   for an IPv6 address.
+ *
+ * An example from 'dig -x PTR 2001:470:1:1b9::31':
+ *
+ * QUESTION SECTION:
+ * 1.3.0.0.0.0.0.0.0.0.0.0.0.0.0.0.9.b.1.0.1.0.0.0.0.7.4.0.1.0.0.2.IP6.ARPA. IN PTR
+ *
+ * ANSWER SECTION:
+ * 1.3.0.0.0.0.0.0.0.0.0.0.0.0.0.0.9.b.1.0.1.0.0.0.0.7.4.0.1.0.0.2.IP6.ARPA. 254148 IN PTR ipv6.cybernode.com.
+ *
+ * If 'use_bitstring == 1', try to use the more compact RFC-2673 bitstring format.
+ * Thus the above 'dig' query should become:
+ *   [x13000000000000009b10100007401002].IP6.ARPA. IN PTR
+ */
+static int convert_query (char **name_p, int use_bitstring)
+{
+#ifndef MAX_IP6_RR
+#define MAX_IP6_RR  (16*sizeof(".x.x") + sizeof(".IP6.ARPA") + 1)
+#endif
+
+#ifdef HAVE_INET_PTON
+ #define ACCEPTED_RETVAL4 1
+ #define ACCEPTED_RETVAL6 1
+#else
+ #define ACCEPTED_RETVAL4 32
+ #define ACCEPTED_RETVAL6 128
+#endif
+
+  static char new_name [MAX_IP6_RR];
+  static const char hex_chars[] = "0123456789ABCDEF";
+
+  union {
+    struct in_addr       addr4;
+    struct ares_in6_addr addr6;
+  } addr;
+
+  if (ares_inet_pton (AF_INET, *name_p, &addr.addr4) == 1)
+    {
+       unsigned long laddr = ntohl(addr.addr4.s_addr);
+       unsigned long a1 = (laddr >> 24UL) & 0xFFUL;
+       unsigned long a2 = (laddr >> 16UL) & 0xFFUL;
+       unsigned long a3 = (laddr >>  8UL) & 0xFFUL;
+       unsigned long a4 = laddr & 0xFFUL;
+
+       snprintf(new_name, sizeof(new_name), "%lu.%lu.%lu.%lu.in-addr.arpa", a4, a3, a2, a1);
+       *name_p = new_name;
+       return (1);
+    }
+
+  if (ares_inet_pton(AF_INET6, *name_p, &addr.addr6) == 1)
+    {
+       char *c = new_name;
+       const unsigned char *ip = (const unsigned char*) &addr.addr6;
+       int   max_i = (int)sizeof(addr.addr6) - 1;
+       int   i, hi, lo;
+
+       /* Use the more compact RFC-2673 notation?
+        * Currently doesn't work or unsupported by the DNS-servers I've tested against.
+        */
+       if (use_bitstring)
+       {
+         *c++ = '\\';
+         *c++ = '[';
+         *c++ = 'x';
+         for (i = max_i; i >= 0; i--)
+         {
+           hi = ip[i] >> 4;
+           lo = ip[i] & 15;
+           *c++ = hex_chars [lo];
+           *c++ = hex_chars [hi];
+         }
+         strcpy (c, "].IP6.ARPA");
+       }
+       else
+       {
+         for (i = max_i; i >= 0; i--)
+         {
+           hi = ip[i] >> 4;
+           lo = ip[i] & 15;
+           *c++ = hex_chars [lo];
+           *c++ = '.';
+           *c++ = hex_chars [hi];
+           *c++ = '.';
+         }
+         strcpy (c, "IP6.ARPA");
+       }
+       *name_p = new_name;
+       return (1);
+    }
+  printf("Address %s was not legal for this query.\n", *name_p);
+  return (0);
+}
+
+static const char *type_name(int type)
+{
+  int i;
+
+  for (i = 0; i < ntypes; i++)
+    {
+      if (types[i].value == type)
+        return types[i].name;
+    }
+  return "(unknown)";
+}
+
+static const char *class_name(int dnsclass)
+{
+  int i;
+
+  for (i = 0; i < nclasses; i++)
+    {
+      if (classes[i].value == dnsclass)
+        return classes[i].name;
+    }
+  return "(unknown)";
+}
+
+static void usage(void)
+{
+  fprintf(stderr, "usage: adig [-h] [-d] [-f flag] [-s server] [-c class] "
+          "[-t type] [-T|U port] [-x|-xx] name ...\n");
+  exit(1);
+}
+
+static void destroy_addr_list(struct ares_addr_node *head)
+{
+  while(head)
+    {
+      struct ares_addr_node *detached = head;
+      head = head->next;
+      free(detached);
+    }
+}
+
+static void append_addr_list(struct ares_addr_node **head,
+                             struct ares_addr_node *node)
+{
+  struct ares_addr_node *last;
+  node->next = NULL;
+  if(*head)
+    {
+      last = *head;
+      while(last->next)
+        last = last->next;
+      last->next = node;
+    }
+  else
+    *head = node;
+}
+
+
+/* Information from the man page. Formatting taken from man -h */
+static void print_help_info_adig(void) {
+    printf("adig, version %s \n\n", ARES_VERSION_STR);
+    printf("usage: adig [-h] [-d] [-f flag] [-s server] [-c class] [-t type] [-T|U port] [-x | -xx] name ...\n\n"
+    "  d : Print some extra debugging output.\n"
+    "  f : Add a flag. Possible values for flag are igntc, noaliases, norecurse, primary, stayopen, usevc.\n"
+    "  h : Display this help and exit.\n\n"
+    "  T port   : Use specified TCP port to connect to DNS server.\n"
+    "  U port   : Use specified UDP port to connect to DNS server.\n"
+    "  c class  : Set the query class. Possible values for class are NY, CHAOS, HS, IN  (default).\n"
+    "  s server : Connect to specified DNS server, instead of the system's default one(s).\n"
+    "  t type   : Query records of specified type.  \n"
+    "              Possible values for type are A  \n"
+    "              (default), AAAA, AFSDB,  ANY,\n"
+    "              AXFR, CNAME, GPOS, HINFO, ISDN,\n"
+    "              KEY, LOC, MAILA, MAILB, MB, MD,\n"
+    "              MF, MG, MINFO, MR, MX, NAPTR, NS,\n"
+    "              NSAP, NSAP_PTR, NULL, PTR, PX, RP,\n"
+    "              RT,  SIG,  SOA, SRV, TXT, URI, WKS, X25\n\n"
+    " -x  : For a '-t PTR a.b.c.d' lookup, query for 'd.c.b.a.in-addr.arpa.'\n"
+    " -xx : As above, but for IPv6, compact the format into a bitstring like\n"
+    "       '[xabcdef00000000000000000000000000].IP6.ARPA.'\n");
+    exit(0);
+}
diff --git a/deps/cares/src/tools/ahost.c b/deps/cares/src/tools/ahost.c
new file mode 100644
index 0000000000000000000000000000000000000000..77ca7cd091ef43b67884e9fdd3f1447bfda65e62
--- /dev/null
+++ b/deps/cares/src/tools/ahost.c
@@ -0,0 +1,231 @@
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ *
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#include "ares_setup.h"
+
+#if !defined(WIN32) || defined(WATT32)
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#endif
+
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+
+#include "ares.h"
+#include "ares_dns.h"
+#include "ares_getopt.h"
+#include "ares_ipv6.h"
+#include "ares_nowarn.h"
+
+#ifndef HAVE_STRDUP
+#  include "ares_strdup.h"
+#  define strdup(ptr) ares_strdup(ptr)
+#endif
+
+#ifndef HAVE_STRCASECMP
+#  include "ares_strcasecmp.h"
+#  define strcasecmp(p1,p2) ares_strcasecmp(p1,p2)
+#endif
+
+#ifndef HAVE_STRNCASECMP
+#  include "ares_strcasecmp.h"
+#  define strncasecmp(p1,p2,n) ares_strncasecmp(p1,p2,n)
+#endif
+
+static void callback(void *arg, int status, int timeouts, struct hostent *host);
+static void usage(void);
+static void print_help_info_ahost(void);
+
+int main(int argc, char **argv)
+{
+  struct ares_options options;
+  int optmask = 0;
+  ares_channel channel;
+  int status, nfds, c, addr_family = AF_INET;
+  fd_set read_fds, write_fds;
+  struct timeval *tvp, tv;
+  struct in_addr addr4;
+  struct ares_in6_addr addr6;
+
+#ifdef USE_WINSOCK
+  WORD wVersionRequested = MAKEWORD(USE_WINSOCK,USE_WINSOCK);
+  WSADATA wsaData;
+  WSAStartup(wVersionRequested, &wsaData);
+#endif
+
+  memset(&options, 0, sizeof(options));
+
+  status = ares_library_init(ARES_LIB_INIT_ALL);
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
+      return 1;
+    }
+
+  while ((c = ares_getopt(argc,argv,"dt:h?s:")) != -1)
+    {
+      switch (c)
+        {
+        case 'd':
+#ifdef WATT32
+          dbug_init();
+#endif
+          break;
+        case 's':
+          optmask |= ARES_OPT_DOMAINS;
+          options.ndomains++;
+          options.domains = (char **)realloc(options.domains,
+                                             options.ndomains * sizeof(char *));
+          options.domains[options.ndomains - 1] = strdup(optarg);
+          break;
+        case 't':
+          if (!strcasecmp(optarg,"a"))
+            addr_family = AF_INET;
+          else if (!strcasecmp(optarg,"aaaa"))
+            addr_family = AF_INET6;
+          else if (!strcasecmp(optarg,"u"))
+            addr_family = AF_UNSPEC;
+          else
+            usage();
+          break;
+        case 'h':
+          print_help_info_ahost();
+          break;
+        case '?':
+          print_help_info_ahost();
+          break;
+        default:
+          usage();
+          break;
+        }
+    }
+
+  argc -= optind;
+  argv += optind;
+  if (argc < 1)
+    usage();
+
+  status = ares_init_options(&channel, &options, optmask);
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "ares_init: %s\n", ares_strerror(status));
+      return 1;
+    }
+
+  /* Initiate the queries, one per command-line argument. */
+  for ( ; *argv; argv++)
+    {
+      if (ares_inet_pton(AF_INET, *argv, &addr4) == 1)
+        {
+          ares_gethostbyaddr(channel, &addr4, sizeof(addr4), AF_INET, callback,
+                             *argv);
+        }
+      else if (ares_inet_pton(AF_INET6, *argv, &addr6) == 1)
+        {
+          ares_gethostbyaddr(channel, &addr6, sizeof(addr6), AF_INET6, callback,
+                             *argv);
+        }
+      else
+        {
+          ares_gethostbyname(channel, *argv, addr_family, callback, *argv);
+        }
+    }
+
+  /* Wait for all queries to complete. */
+  for (;;)
+    {
+      int res;
+      FD_ZERO(&read_fds);
+      FD_ZERO(&write_fds);
+      nfds = ares_fds(channel, &read_fds, &write_fds);
+      if (nfds == 0)
+        break;
+      tvp = ares_timeout(channel, NULL, &tv);
+      res = select(nfds, &read_fds, &write_fds, NULL, tvp);
+      if (-1 == res)
+        break;
+      ares_process(channel, &read_fds, &write_fds);
+    }
+
+  ares_destroy(channel);
+
+  ares_library_cleanup();
+
+#ifdef USE_WINSOCK
+  WSACleanup();
+#endif
+
+  return 0;
+}
+
+static void callback(void *arg, int status, int timeouts, struct hostent *host)
+{
+  char **p;
+
+  (void)timeouts;
+
+  if (status != ARES_SUCCESS)
+    {
+      fprintf(stderr, "%s: %s\n", (char *) arg, ares_strerror(status));
+      return;
+    }
+
+  for (p = host->h_addr_list; *p; p++)
+    {
+      char addr_buf[46] = "??";
+
+      ares_inet_ntop(host->h_addrtype, *p, addr_buf, sizeof(addr_buf));
+      printf("%-32s\t%s", host->h_name, addr_buf);
+#if 0
+      if (host->h_aliases[0])
+        {
+           int i;
+
+           printf (", Aliases: ");
+           for (i = 0; host->h_aliases[i]; i++)
+               printf("%s ", host->h_aliases[i]);
+        }
+#endif
+      puts("");
+    }
+}
+
+static void usage(void)
+{
+  fprintf(stderr, "usage: ahost [-h] [-d] [-s {domain}] [-t {a|aaaa|u}] {host|addr} ...\n");
+  exit(1);
+}
+
+/* Information from the man page. Formatting taken from man -h */
+static void print_help_info_ahost(void) {
+    printf("ahost, version %s \n\n", ARES_VERSION_STR);
+    printf("usage: ahost [-h] [-d] [-s {domain}] [-t {a|aaaa|u}] {host|addr} ...\n\n"
+    "  d : Print some extra debugging output.\n"
+    "  h : Display this help and exit.\n\n"
+    "  s domain : Specify the domain to search instead of \n"
+    "               using the default values from \n"
+    "               /etc/resolv.conf. This option only has an \n"
+    "               effect on platforms that use /etc/resolv.conf\n"
+    "               for DNS configuration; it has no effect on other\n"
+    "               platforms (such as Win32 or Android).\n"
+    "  t type   : If type is \"a\", print the A record (default).\n"
+    "               If type is \"aaaa\", print the AAAA record.  If\n"
+    "               type is \"u\", look for either AAAA or A record\n"
+    "               (in that order).\n\n");
+    exit(0);
+} 
diff --git a/deps/cjs-module-lexer/CHANGELOG.md b/deps/cjs-module-lexer/CHANGELOG.md
index d49499aaa2efcc1a7413e115bd1eec6fc6d50871..e7d12a70f1a329ae322743fd16827b213ac17f22 100644
--- a/deps/cjs-module-lexer/CHANGELOG.md
+++ b/deps/cjs-module-lexer/CHANGELOG.md
@@ -1,3 +1,6 @@
+1.2.2
+- Fix RollupJS reexports bug (https://github.com/guybedford/cjs-module-lexer/pull/59)
+
 1.2.1
 - Support Unicode escapes in strings (https://github.com/guybedford/cjs-module-lexer/pull/55)
 - Filter export strings to valid surrogate pairs (https://github.com/guybedford/cjs-module-lexer/pull/56)
diff --git a/deps/cjs-module-lexer/README.md b/deps/cjs-module-lexer/README.md
index 3893221beb79c7e0fd5ef703924d97c1de8ecf16..a761c0c7dfd714ddf17214eefc0f5e32129c2451 100755
--- a/deps/cjs-module-lexer/README.md
+++ b/deps/cjs-module-lexer/README.md
@@ -113,7 +113,7 @@ EXPORT_STAR_LIB: `Object.keys(` IDENTIFIER$1 `).forEach(function (` IDENTIFIER$2
         (`if (` IDENTIFIER$2 `in` EXPORTS_IDENTIFIER `&&` EXPORTS_IDENTIFIER `[` IDENTIFIER$2 `] ===` IDENTIFIER$1 `[` IDENTIFIER$2 `]) return` `;`)?
       )?
     ) |
-    `if (` IDENTIFIER$2 `!==` ( `'default'` | `"default"` ) (`&& !` (`Object` `.prototype`? `.hasOwnProperty.call(`  IDENTIFIER$1 `, ` IDENTIFIER$2 `)` | IDENTIFIER$1 `.hasOwnProperty(` IDENTIFIER$2 `)`))? `)`
+    `if (` IDENTIFIER$2 `!==` ( `'default'` | `"default"` ) (`&& !` (`Object` `.prototype`? `.hasOwnProperty.call(`  IDENTIFIER `, ` IDENTIFIER$2 `)` | IDENTIFIER `.hasOwnProperty(` IDENTIFIER$2 `)`))? `)`
   )
   (
     EXPORTS_IDENTIFIER `[` IDENTIFIER$2 `] =` IDENTIFIER$1 `[` IDENTIFIER$2 `]` `;`? |
diff --git a/deps/cjs-module-lexer/dist/lexer.js b/deps/cjs-module-lexer/dist/lexer.js
index 4ac468b84952a4b1436b248c080838a50f8def03..391bc5624ee49596fbc2bea83cab1d5bd1545bb4 100644
--- a/deps/cjs-module-lexer/dist/lexer.js
+++ b/deps/cjs-module-lexer/dist/lexer.js
@@ -1 +1 @@
-"use strict";exports.parse=parse;exports.init=init;let A;const Q=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(g,I="@"){if(!A)throw new Error("Not initialized");const D=g.length+1,N=(A.__heap_base.value||A.__heap_base)+4*D-A.memory.buffer.byteLength;N>0&&A.memory.grow(Math.ceil(N/65536));const k=A.sa(D);if((Q?C:E)(g,new Uint16Array(A.memory.buffer,k,D)),!A.parseCJS(k,g.length,0,0,0))throw Object.assign(new Error(`Parse error ${I}${A.e()}:${g.slice(0,A.e()).split("\n").length}:${A.e()-g.lastIndexOf("\n",A.e()-1)}`),{idx:A.e()});let w=new Set,J=new Set,K=new Set;for(;A.rre();){const Q=B(g.slice(A.res(),A.ree()));Q&&J.add(Q)}for(;A.ru();)K.add(B(g.slice(A.us(),A.ue())));for(;A.re();){let Q=B(g.slice(A.es(),A.ee()));void 0===Q||K.has(Q)||w.add(Q)}return{exports:[...w],reexports:[...J]}}function B(A){if('"'!==A[0]&&"'"!==A[0])return A;try{const Q=(0,eval)(A);for(let A=0;A<Q.length;A++){const B=64512&Q.charCodeAt(A);if(!(B<55296)){if(55296!==B)return;if(56320!=(64512&Q.charCodeAt(++A)))return}}return Q}catch{}}function E(A,Q){const B=A.length;let E=0;for(;E<B;){const B=A.charCodeAt(E);Q[E++]=(255&B)<<8|B>>>8}}function C(A,Q){const B=A.length;let E=0;for(;E<B;)Q[E]=A.charCodeAt(E++)}let g;function init(){return g||(g=(async()=>{const Q=await WebAssembly.compile((B="AGFzbQEAAAABrAERYAJ/fwBgAABgAX8Bf2AAAX9gBn9/f39/fwF/YAF/AGAXf39/f39/f39/f39/f39/f39/f39/f38Bf2AIf39/f39/f38Bf2AHf39/f39/fwF/YAN/f38Bf2AFf39/f38Bf2AOf39/f39/f39/f39/f38Bf2AKf39/f39/f39/fwF/YAt/f39/f39/f39/fwF/YAJ/fwF/YAR/f39/AX9gCX9/f39/f39/fwF/A0NCAgMDAwMDAwMDAwMAAAABBAICBQQFAQECAgICAQUBAQUBAQYHAQIIAwICAgkKAgELAgwNDgQPCA4HAgICAhACAgMJBAUBcAEFBQUDAQABBg8CfwFB0JgCC38AQdCYAgsHXA4GbWVtb3J5AgACc2EAAAFlAAECZXMAAgJlZQADA3JlcwAEA3JlZQAFAnVzAAYCdWUABwJyZQAIA3JyZQAJAnJ1AAoIcGFyc2VDSlMADwtfX2hlYXBfYmFzZQMBCQoBAEEBCwQLDA0OCsWhAUJ4AQF/QQAoApgfIgEgAEEBdGoiAEEAOwEAQQAgAEECaiIANgLkH0EAIAA2AugfQQBBADYCwB9BAEEANgLIH0EAQQA2AsQfQQBBADYCzB9BAEEANgLUH0EAQQA2AtAfQQBBADYC2B9BAEEANgLgH0EAQQA2AtwfIAELCABBACgC7B8LFQBBACgCxB8oAgBBACgCmB9rQQF1CxUAQQAoAsQfKAIEQQAoApgfa0EBdQsVAEEAKALQHygCAEEAKAKYH2tBAXULFQBBACgC0B8oAgRBACgCmB9rQQF1CxUAQQAoAtwfKAIAQQAoApgfa0EBdQsVAEEAKALcHygCBEEAKAKYH2tBAXULJQEBf0EAQQAoAsQfIgBBCGpBwB8gABsoAgAiADYCxB8gAEEARwslAQF/QQBBACgC0B8iAEEIakHMHyAAGygCACIANgLQHyAAQQBHCyUBAX9BAEEAKALcHyIAQQhqQdgfIAAbKAIAIgA2AtwfIABBAEcLSAEBf0EAKALIHyICQQhqQcAfIAIbQQAoAugfIgI2AgBBACACNgLIH0EAIAJBDGo2AugfIAJBADYCCCACIAE2AgQgAiAANgIAC0gBAX9BACgC1B8iAkEIakHMHyACG0EAKALoHyICNgIAQQAgAjYC1B9BACACQQxqNgLoHyACQQA2AgggAiABNgIEIAIgADYCAAtIAQF/QQAoAuAfIgJBCGpB2B8gAhtBACgC6B8iAjYCAEEAIAI2AuAfQQAgAkEMajYC6B8gAkEANgIIIAIgATYCBCACIAA2AgALEgBBAEEANgLMH0EAQQA2AtQfC6MPAEEAIAE2AoBAQQAgADYCmB8CQCACRQ0AQQAgAjYCnB8LAkAgA0UNAEEAIAM2AqAfCwJAIARFDQBBACAENgKkHwtBAEH//wM7AYhAQQBBoMAANgKgYEEAQbDgADYCsKABQQBBgCA2ArSgAUEAQQAoAqwfNgKMQEEAIABBfmoiAjYCvKABQQAgAiABQQF0aiIDNgLAoAFBAEEAOwGGQEEAQQA7AYRAQQBBADoAkEBBAEEANgLsH0EAQQA6APAfQQBBADoAuKABAkACQCAALwEAQSNHDQAgAC8BAkEhRw0AQQEhAiABQQJGDQFBACAAQQJqNgK8oAEgAEEEaiEAAkADQCAAIgJBfmogA08NASACQQJqIQAgAi8BAEF2aiIBQQNLDQAgAQ4EAQAAAQELC0EAIAI2ArygAQsDQEEAIAJBAmoiADYCvKABAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACIANPDQACQCAALwEAIgFBd2oiA0EXSw0AQQEgA3RBn4CABHENFwsCQAJAQQAvAYZAIgMNACABQaF/aiIEQQ5NDQMgAUFZaiIEQQhNDQQgAUGFf2oiBEECTQ0FIAFBIkYNCyABQc8ARg0BIAFB8gBHDRUCQEEAEBBFDQAgABARRQ0AIAIQEgtBAEEAKAK8oAE2AoxADBgLIAFBWWoiBEEITQ0FIAFBoH9qIgRBBU0NBiABQYV/aiIEQQJNDQcgAUEiRg0KIAFBzwBGDQAgAUHtAEcNFAwTCyACQQRqQeIAQeoAQeUAQeMAQfQAEBNFDRMgABARRQ0TIANFEBQMEwtBAC8BiEBB//8DRkEALwGGQEVxQQAtAPAfRXEPCyAEDg8SBRERDhEPERERExERERASCyAEDgkGDAgQEBAQEAUGCyAEDgMJDwcJCyAEDgkECgkODg4ODgMECyAEDgYBDQ0KDQsBCyAEDgMGDAMGC0EALwGIQEH+/wNGDQMMBAsCQAJAIAIvAQQiAkEqRg0AIAJBL0cNARAVDA8LEBYMDgsCQAJAAkACQEEAKAKMQCIALwEAIgIQF0UNACACQVVqIgNBA0sNAgJAAkACQCADDgQBBQIAAQsgAEF+ai8BAEFQakH//wNxQQpJDQMMBAsgAEF+ai8BAEErRg0CDAMLIABBfmovAQBBLUYNAQwCCwJAAkAgAkH9AEYNACACQS9GDQEgAkEpRw0CQQAoArCgASADQQJ0aigCABAYRQ0CDAMLQQAoArCgASADQQJ0aigCABAZDQIgA0HQoAFqLQAARQ0BDAILQQAtAJBADQELIAAQGiEDIAJFDQBBASECIANFDQELEBtBACECC0EAIAI6AJBADAoLIAEQHAwJC0EAIANBf2oiADsBhkACQCADQQAvAYhAIgJHDQBBAEEALwGEQEF/aiICOwGEQEEAQQAoAqBgIAJB//8DcUEBdGovAQA7AYhADAILIAJB//8DRg0IIABB//8DcSACTw0ICxAdQQAhAgwMCxAeDAYLIANB0KABakEALQC4oAE6AABBACADQQFqOwGGQEEAKAKwoAEgA0ECdGpBACgCjEA2AgBBAEEAOgC4oAEMBQtBACADQX9qOwGGQAwEC0EAIANBAWo7AYZAQQAoArCgASADQQJ0akEAKAKMQDYCAAwDCyAAEBFFDQIgAi8BBEHsAEcNAiACLwEGQeEARw0CIAIvAQhB8wBHDQIgAi8BCkHzAEcNAgJAAkAgAi8BDCIDQXdqIgJBF0sNAEEBIAJ0QZ+AgARxDQELIANBoAFHDQMLQQBBAToAuKABDAILIAJBBGpB+ABB8ABB7wBB8gBB9AAQE0UNASAAEBFFDQECQCACLwEOQfMARw0AQQAQHwwCCyADDQEQIAwBCyACQQRqQe8AQeQAQfUAQewAQeUAEBNFDQAgABARRQ0AECELQQBBACgCvKABNgKMQAwCCwJAAkAgAkEEaiIDQekAQe4AQfQAQeUAQfIAQe8AQfAAQdIAQeUAQfEAQfUAQekAQfIAQeUAQdcAQekAQewAQeQAQeMAQeEAQfIAQeQAECJFDQACQCAAEBENACACLwEAQS5HDQELQQAgAkEwajYCvKABIAIvATBBKEcNAUEAIAJBMmo2ArygAUEAQQE7AYZAQQAoArCgAUEAKAKMQDYCAEEAEBBFDQEgABARRQ0BIAIQEgwBCyADQd8AQeUAQfgAQfAAQe8AQfIAQfQAECNFDQACQCAAEBENACACLwEAQS5HDQELQQAgAkESajYCvKABAkAgAi8BEiIDQdMARw0AIAIvARRB9ABHDQEgAi8BFkHhAEcNASACLwEYQfIARw0BQQAgAkEaajYCvKABIAIvARohAwsgA0H//wNxQShHDQBBACgCsKABQQAoAoxANgIAQQBBATsBhkBBAEEAKAK8oAEiAkECajYCvKABIAIvAQJB8gBHDQBBAhAQGgtBAEEAKAK8oAE2AoxADAELAkAgAkEEakHtAEHwAEHvAEHyAEH0ABATRQ0AIAAQEUUNABAkQQAoArygASEAC0EAIAA2AoxAC0EAKALAoAEhA0EAKAK8oAEhAgwACwsgAgv3AQEEf0EAIQECQEEAKAK8oAEiAkECakHlAEHxAEH1AEHpAEHyAEHlABAmRQ0AQQAhAUEAIAJBDmo2ArygAQJAECdBKEcNAEEAQQAoArygAUECajYCvKABECchA0EAKAK8oAEhBAJAIANBJ0YNACADQSJHDQELIAMQHEEAQQAoArygAUECaiIDNgK8oAEQJ0EpRw0AAkAgAEF/aiIBQQFLDQACQAJAIAEOAgEAAQsgBCADQQAoAqAfEQAAQQEPCyAEIANBACgCoB8RAABBAQ8LQQAoArSgASAENgIAQQAoArSgASADNgIEQQEPC0EAIAI2ArygAQsgAQsdAAJAQQAoApgfIABHDQBBAQ8LIABBfmovAQAQJQv+AgEEf0EAKAKYHyEBAkADQCAAQX5qIQIgAC8BACIDQSBHDQEgACABSyEEIAIhACAEDQALCwJAIANBPUcNAAJAA0AgAkF+aiEAIAIvAQBBIEcNASACIAFLIQQgACECIAQNAAsLIABBAmohAiAAQQRqIQNBACEEAkADQCACECghACACIAFNDQEgAEUNASAAQdwARg0CIAAQKUUNASACQX5BfCAAQYCABEkbaiECIAAQKiEEDAALCyAEQQFxRQ0AIAIvAQBBIEcNAEEAKAK0oAEiBEEAKAKwH0YNACAEIAM2AgwgBCACQQJqNgIIIAJBfmohAEEgIQICQANAIABBAmogAU0NASACQf//A3FBIEcNASAALwEAIQIgAEF+aiEADAALCyACQf//A3FBjn9qIgJBAksNAAJAAkACQCACDgMAAwEACyAAQfYAQeEAECsNAQwCCyAAQewAQeUAECsNACAAQeMAQe8AQe4AQfMAECxFDQELQQAgBEEQajYCtKABCws/AQF/QQAhBgJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVGIQYLIAYLliYBCH9BAEEAKAK8oAEiAUEMajYCvKABIAFBCmohAQJAECdBLkcNAEEAQQAoArygAUECajYCvKABAkACQBAnIgJB5ABHDQBBACgCvKABIgBBAmpB5QBB5gBB6QBB7gBB5QBB0ABB8gBB7wBB8ABB5QBB8gBB9ABB+QAQL0UNAkEAIABBHGo2ArygASAAQRpqIQEQJ0EoRw0CQQBBACgCvKABQQJqNgK8oAEQJxAwRQ0CECdBLEcNAkEAQQAoArygAUECajYCvKABAkAQJyIAQSdGDQAgAEEiRw0DC0EAKAK8oAEhAiAAEBxBAEEAKAK8oAFBAmoiADYCvKABECdBLEcNAUEAQQAoArygAUECajYCvKABECdB+wBHDQFBAEEAKAK8oAFBAmo2ArygAQJAECciA0HlAEcNAEEAKAK8oAEiA0ECakHuAEH1AEHtAEHlAEHyAEHhAEHiAEHsAEHlABAxRQ0CQQAgA0EUajYCvKABECdBOkcNAkEAQQAoArygAUECajYCvKABECdB9ABHDQJBACgCvKABIgMvAQJB8gBHDQIgAy8BBEH1AEcNAiADLwEGQeUARw0CQQAgA0EIajYCvKABECdBLEcNAkEAQQAoArygAUECajYCvKABECchAwsCQCADQecARg0AIANB9gBHDQJBACgCvKABIgMvAQJB4QBHDQIgAy8BBEHsAEcNAiADLwEGQfUARw0CIAMvAQhB5QBHDQJBACADQQpqNgK8oAEQJ0E6Rw0CIAIgAEEAKAKcHxEAAEEAIAE2ArygAQ8LQQAoArygASIDLwECQeUARw0BIAMvAQRB9ABHDQFBACADQQZqNgK8oAECQBAnIgNBOkcNAEEAQQAoArygAUECajYCvKABECdB5gBHDQJBACgCvKABIgNBAmpB9QBB7gBB4wBB9ABB6QBB7wBB7gAQI0UNAkEAIANBEGoiAzYCvKABAkAQJyIEQShGDQAgA0EAKAK8oAFGDQMgBBAtRQ0DCxAnIQMLIANBKEcNAUEAQQAoArygAUECajYCvKABECdBKUcNAUEAQQAoArygAUECajYCvKABECdB+wBHDQFBAEEAKAK8oAFBAmo2ArygARAnQfIARw0BQQAoArygASIDQQJqQeUAQfQAQfUAQfIAQe4AEBNFDQFBACADQQxqNgK8oAEQJxAtRQ0BAkACQAJAECciA0HbAEYNACADQS5HDQJBAEEAKAK8oAFBAmo2ArygARAnEC0NAQwEC0EAQQAoArygAUECajYCvKABAkAQJyIDQSdGDQAgA0EiRw0ECyADEBxBAEEAKAK8oAFBAmo2ArygARAnQd0ARw0DQQBBACgCvKABQQJqNgK8oAELECchAwsCQCADQTtHDQBBAEEAKAK8oAFBAmo2ArygARAnIQMLIANB/QBHDQFBAEEAKAK8oAFBAmo2ArygAQJAECciA0EsRw0AQQBBACgCvKABQQJqNgK8oAEQJyEDCyADQf0ARw0BQQBBACgCvKABQQJqNgK8oAEQJ0EpRw0BIAIgAEEAKAKcHxEAAA8LIAJB6wBHDQEgAEUNAUEAKAK8oAEiAC8BAkHlAEcNASAALwEEQfkARw0BIAAvAQZB8wBHDQEgAEEGaiEBQQAgAEEIajYCvKABECdBKEcNAUEAQQAoArygAUECajYCvKABECchAEEAKAK8oAEhAiAAEC1FDQFBACgCvKABIQAQJ0EpRw0BQQBBACgCvKABIgFBAmo2ArygARAnQS5HDQFBAEEAKAK8oAFBAmo2ArygARAnQeYARw0BQQAoArygASIDQQJqQe8AQfIAQcUAQeEAQeMAQegAECZFDQFBACADQQ5qNgK8oAEQJyEDQQAoArygASIEQX5qIQEgA0EoRw0BQQAgBEECajYCvKABECdB5gBHDQFBACgCvKABIgNBAmpB9QBB7gBB4wBB9ABB6QBB7wBB7gAQI0UNAUEAIANBEGo2ArygARAnQShHDQFBAEEAKAK8oAFBAmo2ArygARAnIQNBACgCvKABIQQgAxAtRQ0BQQAoArygASEDECdBKUcNAUEAQQAoArygAUECajYCvKABECdB+wBHDQFBAEEAKAK8oAFBAmo2ArygARAnQekARw0BQQAoArygASIFLwECQeYARw0BQQAgBUEEajYCvKABECdBKEcNAUEAQQAoArygAUECajYCvKABECcaQQAoArygASIFIAQgAyAEayIDEEENASAAIAJrIgZBAXUhB0EAIAUgA0EBdSIIQQF0ajYCvKABAkACQAJAECciAEEhRg0AIABBPUcNBEEAKAK8oAEiAC8BAkE9Rw0EIAAvAQRBPUcNBEEAIABBBmo2ArygAQJAECciAEEnRg0AIABBIkcNBQtBACgCvKABIgVBAmpB5ABB5QBB5gBB4QBB9QBB7ABB9AAQI0UNBEEAIAVBEGo2ArygARAnIABHDQRBAEEAKAK8oAFBAmo2ArygARAnQfwARw0EQQAoArygASIALwECQfwARw0EQQAgAEEEajYCvKABECcaQQAoArygASIAIAQgAxBBDQRBACAAIAhBAXRqNgK8oAEQJ0E9Rw0EQQAoArygASIALwECQT1HDQQgAC8BBEE9Rw0EQQAgAEEGajYCvKABAkAQJyIAQSdGDQAgAEEiRw0FC0EAKAK8oAEiBUECakHfAEHfAEHlAEHzAEHNAEHvAEHkAEH1AEHsAEHlABAyRQ0EQQAgBUEWajYCvKABECcgAEcNBEEAQQAoArygAUECajYCvKABECdBKUcNBEEAQQAoArygAUECajYCvKABECdB8gBHDQRBACgCvKABIgBBAmpB5QBB9ABB9QBB8gBB7gAQE0UNBEEAIABBDGo2ArygAQJAECdBO0cNAEEAQQAoArygAUECajYCvKABCxAnIgBB6QBHDQJB6QAhAEEAKAK8oAEiBS8BAkHmAEcNAkEAIAVBBGo2ArygARAnQShHDQRBAEEAKAK8oAFBAmoiADYCvKABAkAgBCAIEDNFDQAQJ0EpRw0FQQBBACgCvKABQQJqNgK8oAEQJ0HyAEcNBUEAKAK8oAEiAEECakHlAEH0AEH1AEHyAEHuABATRQ0FQQAgAEEMajYCvKABAkAQJ0E7Rw0AQQBBACgCvKABQQJqNgK8oAELECciAEHpAEcNA0HpACEAQQAoArygASIFLwECQeYARw0DQQAgBUEEajYCvKABECdBKEcNBUEAKAK8oAFBAmohAAtBACAANgK8oAEgACAEIAMQQQ0EQQAgACAIQQF0ajYCvKABECdB6QBHDQRBACgCvKABIgAvAQJB7gBHDQQgAC8BBEEgRw0EQQAgAEEGajYCvKABECcQMEUNBBAnQSZHDQRBACgCvKABIgAvAQJBJkcNBEEAIABBBGo2ArygARAnEDBFDQQQJ0HbAEcNBEEAQQAoArygAUECajYCvKABECcaQQAoArygASIAIAQgAxBBDQRBACAAIAhBAXRqNgK8oAEQJ0HdAEcNBEEAQQAoArygAUECajYCvKABECdBPUcNBEEAKAK8oAEiAC8BAkE9Rw0EIAAvAQRBPUcNBEEAIABBBmo2ArygARAnGkEAKAK8oAEiACACIAYQQQ0EQQAgACAHQQF0ajYCvKABECdB2wBHDQRBAEEAKAK8oAFBAmo2ArygARAnGkEAKAK8oAEiACAEIAMQQQ0EQQAgACAIQQF0ajYCvKABECdB3QBHDQRBAEEAKAK8oAFBAmo2ArygARAnQSlHDQRBAEEAKAK8oAFBAmo2ArygARAnQfIARw0EQQAoArygASIAQQJqQeUAQfQAQfUAQfIAQe4AEBNFDQRBACAAQQxqNgK8oAEQJ0E7Rw0BQQBBACgCvKABQQJqNgK8oAEMAQtBACgCvKABIgAvAQJBPUcNAyAALwEEQT1HDQNBACAAQQZqNgK8oAECQBAnIgBBJ0YNACAAQSJHDQQLQQAoArygASIFQQJqQeQAQeUAQeYAQeEAQfUAQewAQfQAECNFDQNBACAFQRBqNgK8oAEQJyAARw0DQQBBACgCvKABQQJqNgK8oAECQBAnIgBBJkcNAEEAKAK8oAEiAC8BAkEmRw0EQQAgAEEEajYCvKABECdBIUcNBEEAQQAoArygAUECajYCvKABECcaAkACQEEAKAK8oAEiACACIAYQQQ0AQQAgACAHQQF0ajYCvKABECdBLkcNBkEAQQAoArygAUECajYCvKABECdB6ABHDQZBACgCvKABIgBBAmpB4QBB8wBBzwBB9wBB7gBB0ABB8gBB7wBB8ABB5QBB8gBB9ABB+QAQL0UNBkEAIABBHGo2ArygARAnQShHDQZBAEEAKAK8oAFBAmo2ArygARAnGkEAKAK8oAEiACAEIAMQQQ0GQQAgACAIQQF0ajYCvKABECdBKUcNBkEAQQAoArygAUECajYCvKABDAELIAQgCBAzRQ0FCxAnIQALIABBKUcNA0EAQQAoArygAUECajYCvKABCxAnIQALAkACQAJAIAAQMEUNABAnQdsARw0EQQBBACgCvKABQQJqNgK8oAEQJxpBACgCvKABIgAgBCADEEENBEEAIAAgCEEBdGo2ArygARAnQd0ARw0EQQBBACgCvKABQQJqNgK8oAEQJ0E9Rw0EQQBBACgCvKABQQJqNgK8oAEQJxpBACgCvKABIgAgAiAGEEENBEEAIAAgB0EBdGo2ArygARAnQdsARw0EQQBBACgCvKABQQJqNgK8oAEQJxpBACgCvKABIgAgBCADEEENBEEAIAAgCEEBdGo2ArygARAnQd0ARw0EQQBBACgCvKABQQJqNgK8oAEQJyIAQTtHDQJBAEEAKAK8oAFBAmo2ArygAQwBCyAAQc8ARw0DQQAoArygASIAQQJqQeIAQeoAQeUAQeMAQfQAEBNFDQNBACAAQQxqNgK8oAEQJ0EuRw0DQQBBACgCvKABQQJqNgK8oAEQJ0HkAEcNA0EAKAK8oAEiAEECakHlAEHmAEHpAEHuAEHlAEHQAEHyAEHvAEHwAEHlAEHyAEH0AEH5ABAvRQ0DQQAgAEEcajYCvKABECdBKEcNA0EAQQAoArygAUECajYCvKABECcQMEUNAxAnQSxHDQNBAEEAKAK8oAFBAmo2ArygARAnGkEAKAK8oAEiACAEIAMQQQ0DQQAgACAIQQF0ajYCvKABECdBLEcNA0EAQQAoArygAUECajYCvKABECdB+wBHDQNBAEEAKAK8oAFBAmo2ArygARAnQeUARw0DQQAoArygASIAQQJqQe4AQfUAQe0AQeUAQfIAQeEAQeIAQewAQeUAEDFFDQNBACAAQRRqNgK8oAEQJ0E6Rw0DQQBBACgCvKABQQJqNgK8oAEQJyEFQQAoArygASEAAkAgBUH0AEYNACAALwECQfIARw0EIAAvAQRB9QBHDQQgAC8BBkHlAEcNBAtBACAAQQhqNgK8oAEQJ0EsRw0DQQBBACgCvKABQQJqNgK8oAEQJ0HnAEcNA0EAKAK8oAEiAC8BAkHlAEcNAyAALwEEQfQARw0DQQAgAEEGajYCvKABAkAQJyIAQTpHDQBBAEEAKAK8oAFBAmo2ArygARAnQeYARw0EQQAoArygASIAQQJqQfUAQe4AQeMAQfQAQekAQe8AQe4AECNFDQRBACAAQRBqIgA2ArygAQJAECciBUEoRg0AIABBACgCvKABRg0FIAUQLUUNBQsQJyEACyAAQShHDQNBAEEAKAK8oAFBAmo2ArygARAnQSlHDQNBAEEAKAK8oAFBAmo2ArygARAnQfsARw0DQQBBACgCvKABQQJqNgK8oAEQJ0HyAEcNA0EAKAK8oAEiAEECakHlAEH0AEH1AEHyAEHuABATRQ0DQQAgAEEMajYCvKABECcaQQAoArygASIAIAIgBhBBDQNBACAAIAdBAXRqNgK8oAEQJ0HbAEcNA0EAQQAoArygAUECajYCvKABECcaQQAoArygASIAIAQgAxBBDQNBACAAIAhBAXRqNgK8oAEQJ0HdAEcNA0EAQQAoArygAUECajYCvKABAkAQJyIAQTtHDQBBAEEAKAK8oAFBAmo2ArygARAnIQALIABB/QBHDQNBAEEAKAK8oAFBAmo2ArygAQJAECciAEEsRw0AQQBBACgCvKABQQJqNgK8oAEQJyEACyAAQf0ARw0DQQBBACgCvKABQQJqNgK8oAEQJ0EpRw0DQQBBACgCvKABQQJqNgK8oAEQJyIAQTtHDQFBAEEAKAK8oAFBAmo2ArygAQsQJyEACyAAQf0ARw0BQQBBACgCvKABQQJqNgK8oAEQJ0EpRw0BQQAoArSgASEEQYAgIQADQAJAAkAgBCAARg0AIAcgAEEMaigCACAAQQhqKAIAIgNrQQF1Rw0BIAIgAyAGEEENASAAKAIAIABBBGooAgBBACgCoB8RAABBACABNgK8oAELDwsgAEEQaiEADAALCyACIABBACgCpB8RAAALQQAgATYCvKABC1MBBH9BACgCvKABQQJqIQBBACgCwKABIQECQANAIAAiAkF+aiABTw0BIAJBAmohACACLwEAQXZqIgNBA0sNACADDgQBAAABAQsLQQAgAjYCvKABC3wBAn9BAEEAKAK8oAEiAEECajYCvKABIABBBmohAEEAKALAoAEhAQNAAkACQAJAIABBfGogAU8NACAAQX5qLwEAQSpHDQIgAC8BAEEvRw0CQQAgAEF+ajYCvKABDAELIABBfmohAAtBACAANgK8oAEPCyAAQQJqIQAMAAsLdQEBfwJAAkAgAEFfaiIBQQVLDQBBASABdEExcQ0BCyAAQUZqQf//A3FBBkkNACAAQVhqQf//A3FBB0kgAEEpR3ENAAJAIABBpX9qIgFBA0sNACABDgQBAAABAQsgAEH9AEcgAEGFf2pB//8DcUEESXEPC0EBCz0BAX9BASEBAkAgAEH3AEHoAEHpAEHsAEHlABA0DQAgAEHmAEHvAEHyABA1DQAgAEHpAEHmABArIQELIAELrQEBA39BASEBAkACQAJAAkACQAJAAkAgAC8BACICQUVqIgNBA00NACACQZt/aiIDQQNNDQEgAkEpRg0DIAJB+QBHDQIgAEF+akHmAEHpAEHuAEHhAEHsAEHsABA2DwsgAw4EAgEBBQILIAMOBAIAAAMCC0EAIQELIAEPCyAAQX5qQeUAQewAQfMAEDUPCyAAQX5qQeMAQeEAQfQAQeMAECwPCyAAQX5qLwEAQT1GC+0DAQJ/QQAhAQJAIAAvAQBBnH9qIgJBE0sNAAJAAkACQAJAAkACQAJAAkAgAg4UAAECCAgICAgICAMECAgFCAYICAcACyAAQX5qLwEAQZd/aiICQQNLDQcCQAJAIAIOBAAJCQEACyAAQXxqQfYAQe8AECsPCyAAQXxqQfkAQekAQeUAEDUPCyAAQX5qLwEAQY1/aiICQQFLDQYCQAJAIAIOAgABAAsCQCAAQXxqLwEAIgJB4QBGDQAgAkHsAEcNCCAAQXpqQeUAEDcPCyAAQXpqQeMAEDcPCyAAQXxqQeQAQeUAQewAQeUAECwPCyAAQX5qLwEAQe8ARw0FIABBfGovAQBB5QBHDQUCQCAAQXpqLwEAIgJB8ABGDQAgAkHjAEcNBiAAQXhqQekAQe4AQfMAQfQAQeEAQe4AEDYPCyAAQXhqQfQAQfkAECsPC0EBIQEgAEF+aiIAQekAEDcNBCAAQfIAQeUAQfQAQfUAQfIAEDQPCyAAQX5qQeQAEDcPCyAAQX5qQeQAQeUAQeIAQfUAQecAQecAQeUAEDgPCyAAQX5qQeEAQfcAQeEAQekAECwPCwJAIABBfmovAQAiAkHvAEYNACACQeUARw0BIABBfGpB7gAQNw8LIABBfGpB9ABB6ABB8gAQNSEBCyABC4cBAQN/A0BBAEEAKAK8oAEiAEECaiIBNgK8oAECQAJAAkAgAEEAKALAoAFPDQAgAS8BACIBQaV/aiICQQFNDQICQCABQXZqIgBBA00NACABQS9HDQQMAgsgAA4EAAMDAAALEB0LDwsCQAJAIAIOAgEAAQtBACAAQQRqNgK8oAEMAQsQQBoMAAsLlQEBBH9BACgCvKABIQFBACgCwKABIQICQAJAA0AgASIDQQJqIQEgAyACTw0BIAEvAQAiBCAARg0CAkAgBEHcAEYNACAEQXZqIgNBA0sNASADDgQCAQECAgsgA0EEaiEBIAMvAQRBDUcNACADQQZqIAEgAy8BBkEKRhshAQwACwtBACABNgK8oAEQHQ8LQQAgATYCvKABCzgBAX9BAEEBOgDwH0EAKAK8oAEhAEEAQQAoAsCgAUECajYCvKABQQAgAEEAKAKYH2tBAXU2AuwfC84BAQV/QQAoArygASEAQQAoAsCgASEBA0AgACICQQJqIQACQAJAIAIgAU8NACAALwEAIgNBpH9qIgRBBE0NASADQSRHDQIgAi8BBEH7AEcNAkEAQQAvAYRAIgBBAWo7AYRAQQAoAqBgIABBAXRqQQAvAYhAOwEAQQAgAkEEajYCvKABQQBBAC8BhkBBAWoiADsBiEBBACAAOwGGQA8LQQAgADYCvKABEB0PCwJAAkAgBA4FAQICAgABC0EAIAA2ArygAQ8LIAJBBGohAAwACwu2AgECf0EAQQAoArygASIBQQ5qNgK8oAECQAJAAkAQJyICQdsARg0AIAJBPUYNASACQS5HDQJBAEEAKAK8oAFBAmo2ArygARAnIQJBACgCvKABIQAgAhAtRQ0CQQAoArygASECECdBPUcNAiAAIAJBACgCnB8RAAAPC0EAQQAoArygAUECajYCvKABAkAQJyICQSdGDQAgAkEiRw0CC0EAKAK8oAEhACACEBxBAEEAKAK8oAFBAmoiAjYCvKABECdB3QBHDQFBAEEAKAK8oAFBAmo2ArygARAnQT1HDQEgACACQQAoApwfEQAADAELIABFDQBBACgCqB8RAQBBAEEAKAK8oAFBAmo2ArygAQJAECciAkHyAEYNACACQfsARw0BEC4PC0EBEBAaC0EAIAFBDGo2ArygAQs2AQJ/QQBBACgCvKABQQxqIgA2ArygARAnIQECQAJAQQAoArygASAARw0AIAEQP0UNAQsQHQsLbAEBf0EAQQAoArygASIAQQxqNgK8oAECQBAnQS5HDQBBAEEAKAK8oAFBAmo2ArygARAnQeUARw0AQQAoArygAUECakH4AEHwAEHvAEHyAEH0AEHzABAmRQ0AQQEQHw8LQQAgAEEKajYCvKABC+kBAQF/QQAhFwJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVHDQAgAC8BCiAGRw0AIAAvAQwgB0cNACAALwEOIAhHDQAgAC8BECAJRw0AIAAvARIgCkcNACAALwEUIAtHDQAgAC8BFiAMRw0AIAAvARggDUcNACAALwEaIA5HDQAgAC8BHCAPRw0AIAAvAR4gEEcNACAALwEgIBFHDQAgAC8BIiASRw0AIAAvASQgE0cNACAALwEmIBRHDQAgAC8BKCAVRw0AIAAvASogFkYhFwsgFwtTAQF/QQAhCAJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVHDQAgAC8BCiAGRw0AIAAvAQwgB0YhCAsgCAukAQEEf0EAQQAoArygASIAQQxqIgE2ArygAQJAAkACQAJAAkAQJyICQVlqIgNBB00NACACQSJGDQIgAkH7AEYNAgwBCwJAIAMOCAIAAQIBAQEDAgtBAEEALwGGQCIDQQFqOwGGQEEAKAKwoAEgA0ECdGogADYCAA8LQQAoArygASABRg0CC0EALwGGQEUNAEEAQQAoArygAUF+ajYCvKABDwsQHQsLNAEBf0EBIQECQCAAQXdqQf//A3FBBUkNACAAQYABckGgAUYNACAAQS5HIAAQP3EhAQsgAQtJAQF/QQAhBwJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVHDQAgAC8BCiAGRiEHCyAHC3oBA39BACgCvKABIQACQANAAkAgAC8BACIBQXdqQQVJDQAgAUEgRg0AIAFBoAFGDQAgAUEvRw0CAkAgAC8BAiIAQSpGDQAgAEEvRw0DEBUMAQsQFgtBAEEAKAK8oAEiAkECaiIANgK8oAEgAkEAKALAoAFJDQALCyABCzkBAX8CQCAALwEAIgFBgPgDcUGAuANHDQAgAEF+ai8BAEH/B3FBCnQgAUH/B3FyQYCABGohAQsgAQt9AQF/AkAgAEEvSw0AIABBJEYPCwJAIABBOkkNAEEAIQECQCAAQcEASQ0AIABB2wBJDQECQCAAQeAASw0AIABB3wBGDwsgAEH7AEkNAQJAIABB//8DSw0AIABBqgFJDQEgABA5DwtBASEBIAAQOg0AIAAQOyEBCyABDwtBAQtjAQF/AkAgAEHAAEsNACAAQSRGDwtBASEBAkAgAEHbAEkNAAJAIABB4ABLDQAgAEHfAEYPCyAAQfsASQ0AAkAgAEH//wNLDQBBACEBIABBqgFJDQEgABA8DwsgABA6IQELIAELTAEDf0EAIQMCQCAAQX5qIgRBACgCmB8iBUkNACAELwEAIAFHDQAgAC8BACACRw0AAkAgBCAFRw0AQQEPCyAAQXxqLwEAECUhAwsgAwtmAQN/QQAhBQJAIABBemoiBkEAKAKYHyIHSQ0AIAYvAQAgAUcNACAAQXxqLwEAIAJHDQAgAEF+ai8BACADRw0AIAAvAQAgBEcNAAJAIAYgB0cNAEEBDwsgAEF4ai8BABAlIQULIAULhQEBAn8gABA+IgAQKiEBAkACQCAAQdwARg0AQQAhAiABRQ0BC0EAKAK8oAFBAkEEIABBgIAESRtqIQACQANAQQAgADYCvKABIAAvAQAQPiIBRQ0BAkAgARApRQ0AIABBAkEEIAFBgIAESRtqIQAMAQsLQQAhAiABQdwARg0BC0EBIQILIAIL2gMBBH9BACgCvKABIgBBfmohAQNAQQAgAEECajYCvKABAkACQAJAIABBACgCwKABTw0AECchAEEAKAK8oAEhAgJAAkAgABAtRQ0AQQAoArygASEDAkACQBAnIgBBOkcNAEEAQQAoArygAUECajYCvKABECcQLUUNAUEAKAK8oAEvAQAhAAsgAiADQQAoApwfEQAADAILQQAgATYCvKABDwsCQAJAIABBIkYNACAAQS5GDQEgAEEnRw0EC0EAKAK8oAEhAiAAEBxBAEEAKAK8oAFBAmoiAzYCvKABECciAEE6Rw0BQQBBACgCvKABQQJqNgK8oAECQBAnEC1FDQBBACgCvKABLwEAIQAgAiADQQAoApwfEQAADAILQQAgATYCvKABDwtBACgCvKABIgAvAQJBLkcNAiAALwEEQS5HDQJBACAAQQZqNgK8oAECQAJAAkAgAC8BBiIAQfIARw0AQQEQECEAQQAoArygASECIAANASACLwEAIQALIABB//8DcRAtDQFBACABNgK8oAEPC0EAIAJBAmo2ArygAQsQJyEACyAAQf//A3EiAEEsRg0CIABB/QBGDQBBACABNgK8oAELDwtBACABNgK8oAEPC0EAKAK8oAEhAAwACwuPAQEBf0EAIQ4CQCAALwEAIAFHDQAgAC8BAiACRw0AIAAvAQQgA0cNACAALwEGIARHDQAgAC8BCCAFRw0AIAAvAQogBkcNACAALwEMIAdHDQAgAC8BDiAIRw0AIAAvARAgCUcNACAALwESIApHDQAgAC8BFCALRw0AIAAvARYgDEcNACAALwEYIA1GIQ4LIA4LqAEBAn9BACEBQQAoArygASECAkACQCAAQe0ARw0AIAJBAmpB7wBB5ABB9QBB7ABB5QAQE0UNAUEAIAJBDGo2ArygAQJAECdBLkYNAEEAIQEMAgtBAEEAKAK8oAFBAmo2ArygARAnIQALIABB5QBHDQBBACgCvKABIgBBDmogAiAAQQJqQfgAQfAAQe8AQfIAQfQAQfMAECYiARshAgtBACACNgK8oAEgAQtnAQF/QQAhCgJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVHDQAgAC8BCiAGRw0AIAAvAQwgB0cNACAALwEOIAhHDQAgAC8BECAJRiEKCyAKC3EBAX9BACELAkAgAC8BACABRw0AIAAvAQIgAkcNACAALwEEIANHDQAgAC8BBiAERw0AIAAvAQggBUcNACAALwEKIAZHDQAgAC8BDCAHRw0AIAAvAQ4gCEcNACAALwEQIAlHDQAgAC8BEiAKRiELCyALC4MEAQJ/QQAhAgJAECdBzwBHDQBBACECQQAoArygASIDQQJqQeIAQeoAQeUAQeMAQfQAEBNFDQBBACECQQAgA0EMajYCvKABECdBLkcNAEEAQQAoArygAUECajYCvKABAkAQJyIDQfAARw0AQQAhAkEAKAK8oAEiA0ECakHyAEHvAEH0AEHvAEH0AEH5AEHwAEHlABA9RQ0BQQAhAkEAIANBEmo2ArygARAnQS5HDQFBAEEAKAK8oAFBAmo2ArygARAnIQMLQQAhAiADQegARw0AQQAhAkEAKAK8oAEiA0ECakHhAEHzAEHPAEH3AEHuAEHQAEHyAEHvAEHwAEHlAEHyAEH0AEH5ABAvRQ0AQQAhAkEAIANBHGo2ArygARAnQS5HDQBBACECQQBBACgCvKABQQJqNgK8oAEQJ0HjAEcNAEEAIQJBACgCvKABIgMvAQJB4QBHDQAgAy8BBEHsAEcNACADLwEGQewARw0AQQAhAkEAIANBCGo2ArygARAnQShHDQBBACECQQBBACgCvKABQQJqNgK8oAEQJxAtRQ0AECdBLEcNAEEAIQJBAEEAKAK8oAFBAmo2ArygARAnGkEAKAK8oAEiAyAAIAFBAXQiARBBDQBBACECQQAgAyABajYCvKABECdBKUcNAEEAQQAoArygAUECajYCvKABQQEhAgsgAgtJAQN/QQAhBgJAIABBeGoiB0EAKAKYHyIISQ0AIAcgASACIAMgBCAFEBNFDQACQCAHIAhHDQBBAQ8LIABBdmovAQAQJSEGCyAGC1kBA39BACEEAkAgAEF8aiIFQQAoApgfIgZJDQAgBS8BACABRw0AIABBfmovAQAgAkcNACAALwEAIANHDQACQCAFIAZHDQBBAQ8LIABBemovAQAQJSEECyAEC0sBA39BACEHAkAgAEF2aiIIQQAoApgfIglJDQAgCCABIAIgAyAEIAUgBhAmRQ0AAkAgCCAJRw0AQQEPCyAAQXRqLwEAECUhBwsgBws9AQJ/QQAhAgJAQQAoApgfIgMgAEsNACAALwEAIAFHDQACQCADIABHDQBBAQ8LIABBfmovAQAQJSECCyACC00BA39BACEIAkAgAEF0aiIJQQAoApgfIgpJDQAgCSABIAIgAyAEIAUgBiAHECNFDQACQCAJIApHDQBBAQ8LIABBcmovAQAQJSEICyAIC/kSAQN/AkAgABA8DQAgAEH0v39qQQJJDQAgAEG3AUYNACAAQYB6akHwAEkNACAAQf12akEFSQ0AIABBhwdGDQAgAEHvdGpBLUkNAAJAIABBwXRqIgFBCEsNAEEBIAF0Qe0CcQ0BCyAAQfBzakELSQ0AIABBtXNqQR9JDQACQCAAQapyaiIBQRJLDQBBASABdEH//BlxDQELIABB8AxGDQAgAEGWcmpBBEkNACAAQcBwakEKSQ0AIABB2nBqQQtJDQAgAEHQcWpBG0kNACAAQZEORg0AIABBkHJqQQpJDQAgAEHCbWpBEkkNACAAQcZtakEDSQ0AIABBnW5qQSFJDQAgAEGtbmpBD0kNACAAQadvakEDSQ0AIABB129qQQVJDQAgAEHbb2pBA0kNACAAQeVvakEJSQ0AIABB6m9qQQRJDQAgAEH9D0YNACAAQZVwakEJSQ0AAkAgAEGvbWoiAUESSw0AQQEgAXRB/4AYcQ0BCyAAQZptakEKSQ0AAkACQCAAQcRsaiIBQSdNDQAgAEH/bGpBA0kNAgwBCyABDigBAAEBAQEBAQEAAAEBAAABAQEAAAAAAAAAAAABAAAAAAAAAAAAAAEBAQsgAEH+E0YNACAAQZpsakEKSQ0AAkAgAEHEa2oiAUEVSw0AQQEgAXRB/bCOAXENAQsgAEH/a2pBA0kNACAAQfUURg0AIABBmmtqQQxJDQACQAJAIABBxGpqIgFBJ00NACAAQf9qakEDSQ0CDAELIAEOKAEAAQEBAQEBAQEAAQEBAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBCyAAQZpqakEKSQ0AIABBhmpqQQZJDQACQAJAIABBxGlqIgFBJ00NACAAQf9pakEDSQ0CDAELIAEOKAEAAQEBAQEBAQAAAQEAAAEBAQAAAAAAAAAAAQEAAAAAAAAAAAAAAQEBCyAAQZppakEKSQ0AAkAgAEHCaGoiAUEZSw0AQQEgAXRBn+6DEHENAQsgAEGCF0YNACAAQZpoakEKSQ0AAkACQCAAQcJnaiIBQSVNDQAgAEGAaGpBBUkNAgwBCyABDiYBAQEBAQEBAAEBAQABAQEBAAAAAAAAAAEBAAAAAAAAAAAAAAABAQELIABBmmdqQQpJDQACQAJAIABBxGZqIgFBJ00NACAAQf9makEDSQ0CDAELIAEOKAEAAQEBAQEBAQABAQEAAQEBAQAAAAAAAAABAQAAAAAAAAAAAAAAAQEBCyAAQZpmakEKSQ0AIABBfHEiAkGAGkYNAAJAIABBxWVqIgFBKEsNACABDikBAQABAQEBAQEBAAEBAQABAQEBAAAAAAAAAAAAAQAAAAAAAAAAAAABAQELIABBmmVqQQpJDQACQCAAQbZkaiIBQQxLDQBBASABdEHhL3ENAQsgAEH+ZGpBAkkNACAAQXhxQdgbRg0AIABBmmRqQQpJDQACQCAAQc9jaiIBQR1LDQBBASABdEH5h4D+A3ENAQsgAEGOZGpBAkkNACAAQbEdRg0AIABBsGNqQQpJDQACQCAAQcxiaiIBQQhLDQAgAUEGRw0BCyAAQbhiakEGSQ0AIABB4GFqQQpJDQAgAEEBciIBQZkeRg0AIABBsGJqQQpJDQACQCAAQcthaiIDQQpLDQBBASADdEGVDHENAQsgAEHzYGpBC0kNACABQYcfRg0AIABBj2FqQRRJDQAgAEHuUWpBA0kNACAAQZdZakEJSQ0AIABBo1lqQQNJDQAgAEHxXmpBD0kNACAAQf5eakEMSQ0AIABBj19qQQRJDQAgAEGZX2pBB0kNACAAQZ5fakEDSQ0AIABBol9qQQNJDQAgAEGqX2pBBEkNACAAQcBfakEKSQ0AIABB1V9qQRRJDQAgAEHGH0YNACAAQedgakEkSQ0AIABBzlFqQQNJDQAgAEGuUWpBAkkNACAAQY5RakECSQ0AIABB9U9qQQNJDQAgAEGgUGpBCkkNACAAQd0vRg0AIABBzFBqQSBJDQAgAEGwRmpBA0kNACAAQbBHakEKSQ0AIABBwEdqQQpJDQAgAEHcR2pBFEkNACAAQZpIakEOSQ0AIABB0EhqQQpJDQAgAEHfSGpBDUkNACAAQYBJakEDSQ0AIABBlUlqQQlJDQAgAEGwSWpBCkkNACAAQcxJakERSQ0AIABBgEpqQQVJDQAgAEHQSmpBDkkNACAAQfBKakEKSQ0AIABBgUtqQQtJDQAgAEGgS2pBHUkNACAAQatLakEKSQ0AIABB6UtqQQVJDQAgAEGwTGpBC0kNACAAQbpNakEKSQ0AIABB0E1qQQxJDQAgAEHgTWpBDEkNACAAQakxRg0AIABB8E9qQQpJDQAgAEHARGpBOkkNACAAQYlGakEDSQ0AIABBjkZqQQNJDQAgAEHtOUYNACAAQaxGakEVSQ0AIABBhURqQQVJDQACQCAAQcG/f2oiAUEVSw0AQQEgAXRBg4CAAXENAQsgAEGbvn9qQQxJDQAgAEHhwQBGDQAgAEGwvn9qQQ1JDQAgAEGRpn9qQQNJDQAgAEH/2gBGDQAgAEFgcUHg2wBGDQAgAEHWn39qQQZJDQAgAEHnnn9qQQJJDQAgAEGMs31qQQpJDQAgAEHvzAJGDQAgAEHgs31qQQpJDQACQCAAQfWvfWoiAUEcSw0AQQEgAXRBgYCA+AFxDQELIABB4rJ9akECSQ0AIABBkLJ9akECSQ0AAkACQCAAQf6vfWoiAUEETQ0AIABBgK99akECSQ0CDAELIAEOBQEAAAABAQsgAEHNrH1qQQ5JDQAgAkGA0wJGDQAgAEG5rX1qQQ1JDQAgAEHarX1qQQhJDQAgAEGBrn1qQQtJDQAgAEGgrn1qQRJJDQAgAEHMrn1qQRJJDQAgAEGwrn1qQQpJDQAgAEHXq31qQQ5JDQAgAEHl0wJGDQAgAEFfcUGwrH1qQQpJDQACQCAAQb2rfWoiAUEKSw0AQQEgAXRBgQxxDQELIABBsKt9akEKSQ0AAkAgAEGdqH1qIgFBCksNACABQQhHDQELAkAgAEHQqn1qIgFBEUsNAEEBIAF0QZ2DC3ENAQsCQCAAQZWqfWoiAUELSw0AQQEgAXRBnxhxDQELIABBhat9akEDSQ0AIABBcHEiAUGA/ANGDQAgAEGe9gNGDQAgAEGQqH1qQQpJDQAgAEG//gNGIABB8IF8akEKSSAAQbODfGpBA0kgAEHNg3xqQQJJIAFBoPwDRnJycnIPC0EBC1wBBH9BgIAEIQFBkAghAkF+IQMCQANAQQAhBCADQQJqIgNB5wNLDQEgAigCACABaiIBIABLDQEgAkEEaiEEIAJBCGohAiAEKAIAIAFqIgEgAEkNAAtBASEECyAEC1wBBH9BgIAEIQFBsBchAkF+IQMCQANAQQAhBCADQQJqIgNB+QFLDQEgAigCACABaiIBIABLDQEgAkEEaiEEIAJBCGohAiAEKAIAIAFqIgEgAEkNAAtBASEECyAEC+0fAQZ/QQEhAQJAAkACQCAAQdZ+aiICQRBLDQBBASACdEGBkARxDQELIABBunpqQQxJDQAgAEGIfmpBygNJDQAgAEHAfmpBF0kNACAAQah+akEfSQ0AAkAgAEGQeWoiAkEcSw0AQQEgAnRB3/mCugFxDQELAkAgAEGgemoiAkEOSw0AQQEgAnRBn6ABcQ0BCyAAQfZ2akGmAUkNACAAQYl4akGLAUkNACAAQfJ4akEUSQ0AIABB3XhqQdMASQ0AIABBkXRqQQRJDQAgAEGwdGpBG0kNACAAQaB1akEpSQ0AIABB2QpGDQAgAEHPdWpBJkkNAAJAAkACQCAAQY9zakHjAEkNACAAQQFyIgJB7wxGDQAgAEHgc2pBK0kNAAJAIABBq3JqIgFBPE8NAEKBgIywgJyBgAggAa2IQgGDUEUNAQsgAEHucWpBHkkNACAAQbZwakEhSQ0AIABBsQ9GDQAgAEGzcWpB2QBJDQACQCAAQYxwaiIBQQZLDQBBASABdEHDAHENAQsgAEGAcGpBFkkNAAJAAkAgAEHcb2oiA0EETQ0AIABBmhBGDQIMAQtBASEBIAMOBQQAAAAEBAsgAEH8bWpBNkkNACAAQcpuakEISQ0AIABB4G5qQRVJDQAgAEHAb2pBGUkNACAAQaBvakELSQ0AIABBvRJGDQAgAEHQEkYNACAAQahtakEKSQ0AIABBj21qQRBJDQACQCAAQftsaiIDQQxPDQBBASEBQf8ZIANB//8DcXZBAXENBAsgAEHtbGpBFkkNAAJAIABBhGxqIgFBFEsNAEEBIAF0QYH84QBxDQELIABB1mxqQQdJDQACQCAAQc5saiIBQRxLDQBBASABdEHxkYCAAXENAQsCQCAAQaRsaiIBQRVLDQBBASABdEG7gMABcQ0BCyAAQe1rakEWSQ0AAkAgAEHWa2oiAUE1Tw0AQv+2g4CAgOALIAGtiEIBg1BFDQELIABB7WpqQRZJDQAgAEHxampBA0kNACAAQY5rakEDSQ0AIABB+2pqQQlJDQACQAJAAkAgAEHWamoiA0EmTQ0AIABBh2pqIgFBF0sNAUEBIAF0QYHgvwZxRQ0BDAMLQQEhASADDicFBQUFBQUFAQUFAQUFBQUFAQEBBQEBAQEBAQEBAQEBAQEBAQEBAQUFCyAAQaBqakECSQ0BCyAAQe1pakEWSQ0AAkACQAJAIABBj2lqIgNBM00NACAAQdZpaiIBQRNLDQFBASABdEH/9iNxRQ0BDAMLQQEhASADDjQFAQEBAQEBAQEBAQEBAQEBAQEFAQUFBQUFBQEBAQUFBQEFBQUFAQEBBQUBBQEFBQEBAQUFBQsgAEGkaWoiAUEFSw0AIAFBAkcNAQsgAEHYaGpBA0kNACAAQe5nakEXSQ0AIABB8mdqQQNJDQAgAEH7Z2pBCEkNACAAQdAXRg0AIABB0mhqQQxJDQAgAEG9GEYNACAAQdZnakEQSQ0AAkAgAEGoZ2oiAUEpTw0AQoeGgICAICABrYhCAYNQRQ0BCyAAQdZmakEKSQ0AIABB7mZqQRdJDQAgAEH7ZmpBCEkNACAAQfJmakEDSQ0AAkAgAEH7ZWoiAUELSw0AIAFBCEcNAQsCQCAAQctmaiIBQQhLDQBBASABdEGfAnENAQsCQCAAQaJmaiIBQRRLDQBBASABdEGNgOAAcQ0BCyAAQe5lakEpSQ0AIABBvRpGDQAgAEHOGkYNACAAQc1kakEJSQ0AIABB5mRqQRhJDQAgAEH7ZGpBEkkNACAAQYZlakEGSQ0AIABBrGVqQQNJDQAgAEGhZWpBA0kNAAJAIABBw2RqIgNBCk8NAEEBIQFB+QcgA0H//wNxdkEBcQ0ECyACQbMcRg0AIABB/2NqQTBJDQAgAEHAY2pBB0kNAAJAIABB/2JqIgFBDEsNAEEBIAF0QcslcQ0BCyAAQXxxIgNBlB1GDQAgAEHnYmpBB0kNAAJAIABB32JqIgFBJk8NAELX7JuA+QUgAa2IQgGDUEUNAQsgAEGAYGpBK0kNACAAQfhgakEFSQ0AIABBt2FqQSRJDQAgAEF4cSIEQcAeRg0AIABBgB5GDQAgA0HcHUYNAAJAIABBwV9qIgFBKE8NAEKBgPjDxxggAa2IQgGDUEUNAQsgAEGSX2pBA0kNACAAQeBeakEmSQ0AIABBjiFGDQAgAEGLX2pBDUkNACAAQcchRg0AIABBzSFGDQAgAEG2W2pBBEkNACAAQbBeakErSQ0AIABBhF5qQc0CSQ0AAkAgAEGwW2oiBUEJTw0AQQEhAUH/AiAFQf//A3F2QQFxDQQLIABBzlpqQQRJDQAgAEHwWmpBIUkNACAAQfZaakEESQ0AIABBpltqQQRJDQAgAEGgW2pBKUkNAAJAIABByFpqIgVBCU8NAEEBIQFB/wIgBUH//wNxdkEBcQ0ECyAAQYBRakE0SQ0AIABBklFqQQNJDQAgAEGgUWpBDUkNACAAQcBRakESSQ0AIABB4FFqQRJJDQAgAEHyUWpBBEkNACAAQYBSakENSQ0AIABBklJqQQtJDQAgAEHgUmpBywBJDQAgAEH/UmpBGkkNACAAQZFTakERSQ0AIABB/1dqQewESQ0AIABBiFhqQQZJDQAgAEHgWGpB1gBJDQAgAEFwcSIFQYAnRg0AIABB6FlqQcMASQ0AIABB7llqQQRJDQAgAEGoWmpBOUkNACAAQb5aakEESQ0AIABBuFpqQQ9JDQAgAEHXL0YNACAAQdwvRg0AIABB4E9qQdkASQ0AIABBgExqQRdJDQAgAEHQTGpBGkkNACAAQYBNakEsSQ0AIABBkE1qQQVJDQAgAEGwTWpBHkkNACAAQYBOakEfSQ0AIABB0E5qQcYASQ0AIABBqjFGDQQgAEGAT2pBKUkNBCAAQbtJakEHSQ0EIABB+0lqQS9JDQQgAEGnNUYNBCAAQeBLakE1SQ0EIABBl0ZqQQRJDQQgAEHDRmpBA0kNBCAAQfBGakErSQ0EIABBgEdqQQlJDQQgAEGmR2pBJEkNBCAAQbNHakEDSQ0EIABBgEhqQSRJDQQgAEHGSGpBLEkNBCACQa83Rg0EIABB/UhqQR5JDQQgAEGSRmoiBkEJSQ0BDAILQQEhAQwCC0EBIQFBjwMgBkH//wNxdkEBcQ0BCyAEQdA+Rg0BIABBuEFqQQZJDQEgAEHgQWpBJkkNASAAQehBakEGSQ0BIABBgEZqQcABSQ0BIABBgERqQZYCSQ0BAkAgAEGnQWoiAUEESw0AQQEgAXRBFXENAgsgAEGhQWpBH0kNASAAQYBBakE1SQ0BAkAgAEHKQGoiBEEJTw0AQQEhAUH/AiAEQf//A3F2QQFxDQELIABBjkBqQQNJDQEgAEGgQGpBDUkNASAAQapAakEGSQ0BIANB0D9GDQEgAEG+QGpBA0kNASAAQbpAakEHSQ0BIABBikBqQQdJDQEgAEHxwABGDQEgAEH/wABGDQEgAEHwvn9qQQ1JDQEgAEGCwgBGDQEgAEGHwgBGDQEgAEGVwgBGDQEgAEH2vX9qQQpJDQECQCAAQei9f2oiBEERTw0AQQEhAUG/oAUgBHZBAXENAQsgAEHWvX9qQRBJDQEgA0G8wgBGDQECQCAAQbu9f2oiBEEKTw0AQQEhAUGfBCAEQf//A3F2QQFxDQELIABBoKd/akGFAUkNASAAQdCnf2pBL0kNASAAQaC9f2pBKUkNASAAQYCof2pBL0kNAQJAIABBlaZ/aiIEQQlPDQBBASEBQY8DIARB//8DcXZBAXENAQsgAEGApn9qQSZJDQEgAEGn2gBGDQEgAEGt2gBGDQEgAEGAtn1qQY0CSQ0BIABBsLZ9akEuSQ0BIABBgMB9akGNCUkNASAAQYDkfmpB8KMBSQ0BIABBgJh/akG2M0kNASAFQfDjAEYNASAAQeCcf2pBG0kNASAAQc+df2pB3gBJDQEgAEH7nX9qQStJDQEgA0H84QBGDQEgAEHfnn9qQdoASQ0BIABB5Z5/akEFSQ0BIABBv59/akHWAEkNASAAQciff2pBBUkNASAAQc+ff2pBBUkNASAAQd+ff2pBCUkNASAAQfuff2pBA0kNASAAQaikf2pBB0kNASAAQbCkf2pBB0kNASAAQbikf2pBB0kNASAAQcCkf2pBB0kNASAAQcikf2pBB0kNASAAQdCkf2pBB0kNASAAQdikf2pBB0kNASAAQeCkf2pBB0kNASAAQYClf2pBF0kNASAAQe/aAEYNASAAQdClf2pBOEkNASAAQf6ufWpBMkkNASAAQcCvfWpBNEkNASAAQfSvfWpBF0kNASAAQfmvfWpBBEkNASAAQf2vfWpBA0kNASAAQYmwfWpBC0kNASAAQfWwfWpBL0kNASAAQd6xfWpB5wBJDQEgAEHpsX1qQQlJDQEgAEHgsn1qQdAASQ0BIABBgbN9akEfSQ0BIABBwLN9akEvSQ0BIAJBq8wCRg0BIAVBkMwCRg0BAkAgAEGOrn1qIgJBDU8NAEEBIQFBvzQgAkH//wNxdkEBcQ0BCyAAQaCtfWpBHUkNASAAQfatfWpBHEkNASAAQdCtfWpBF0kNASAAQbyrfWpBCEkNASAAQcCrfWpBA0kNASAAQYCsfWpBKUkNASAAQYasfWpBBUkNASAAQZqsfWpBCkkNASAAQaCsfWpBBUkNASAAQc/TAkYNASAAQfysfWpBL0kNASAAQYKrfWpBMkkNASAAQfrUAkYNASAAQaCrfWpBF0kNAQJAIABBz6p9aiICQRJPDQBBASEBQbG+CiACdkEBcQ0BCyAAQYCKfGpBB0kNASAAQZCLfGpB6gBJDQEgAEGAjnxqQe4CSQ0BIABBtdB8akExSQ0BIABB0NB8akEXSQ0BIABBgKh9akGk1wBJDQEgAEGQqX1qQfMASQ0BIABBpKl9akEKSQ0BIABB0Kl9akErSQ0BIABB2Kl9akEHSQ0BIABB4Kl9akEHSQ0BIABB76l9akEGSQ0BIABBd3FB/6l9akEGSQ0BIABBjqp9akEDSQ0BIABBpap9akEDSQ0BIABBoKp9akELSQ0BAkAgAEHtiXxqIgJBC08NAEEBIQFBnwggAkH//wNxdkEBcQ0BCyAAQeGJfGpBCkkNASAAQdaJfGpBDUkNAQJAIABByIl8aiICQQ1PDQBBASEBQd82IAJB//8DcXZBAXENAQsgAEGugHxqQQZJDQEgAEG2gHxqQQZJDQEgAEG+gHxqQQZJDQEgAEGagXxqQdkASQ0BIABBv4F8akEaSQ0BIABB34F8akEaSQ0BIABBioN8akGHAUkNASAAQZCDfGpBBUkNASAAQZCEfGpBDEkNASAAQe6EfGpBNkkNASAAQbCFfGpBwABJDQEgAEG6iXxqQewASQ0BQQEhASAAQa2IfGpB6wJJDQAgAEGmgHxqQQNJDwsgAQ8LQQELXQEBf0EAIQkCQCAALwEAIAFHDQAgAC8BAiACRw0AIAAvAQQgA0cNACAALwEGIARHDQAgAC8BCCAFRw0AIAAvAQogBkcNACAALwEMIAdHDQAgAC8BDiAIRiEJCyAJCzUAAkAgAEGA+ANxQYCwA0cNACAAQQp0QYD4P3FBACgCvKABLwECQf8HcXJBgIAEaiEACyAAC2gBAn9BASEBAkACQCAAQV9qIgJBBUsNAEEBIAJ0QTFxDQELIABB+P8DcUEoRg0AIABBRmpB//8DcUEGSQ0AAkAgAEGlf2oiAkEDSw0AIAJBAUcNAQsgAEGFf2pB//8DcUEESSEBCyABC40BAQV/QQAoArygASEAQQAoAsCgASEBA38gAEECaiECAkACQCAAIAFPDQAgAi8BACIDQaR/aiIEQQFNDQEgAiEAIANBdmoiA0EDSw0CIAIhACADDgQAAgIAAAtBACACNgK8oAEQHUEADwsCQAJAIAQOAgEAAQtBACACNgK8oAFB3QAPCyAAQQRqIQAMAAsLSQEDf0EAIQMCQCACRQ0AAkADQCAALQAAIgQgAS0AACIFRw0BIAFBAWohASAAQQFqIQAgAkF/aiICDQAMAgsLIAQgBWshAwsgAwsLwhcCAEGACAuYFwAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAIAAAAZAAAAAgAAABIAAAACAAAAAQAAAAIAAAAOAAAAAwAAAA0AAAAjAAAAegAAAEYAAAA0AAAADAEAABwAAAAEAAAAMAAAADAAAAAfAAAADgAAAB0AAAAGAAAAJQAAAAsAAAAdAAAAAwAAACMAAAAFAAAABwAAAAIAAAAEAAAAKwAAAJ0AAAATAAAAIwAAAAUAAAAjAAAABQAAACcAAAAJAAAAMwAAAJ0AAAA2AQAACgAAABUAAAALAAAABwAAAJkAAAAFAAAAAwAAAAAAAAACAAAAKwAAAAIAAAABAAAABAAAAAAAAAADAAAAFgAAAAsAAAAWAAAACgAAAB4AAABCAAAAEgAAAAIAAAABAAAACwAAABUAAAALAAAAGQAAAEcAAAA3AAAABwAAAAEAAABBAAAAAAAAABAAAAADAAAAAgAAAAIAAAACAAAAHAAAACsAAAAcAAAABAAAABwAAAAkAAAABwAAAAIAAAAbAAAAHAAAADUAAAALAAAAFQAAAAsAAAASAAAADgAAABEAAABvAAAASAAAADgAAAAyAAAADgAAADIAAAAOAAAAIwAAAF0BAAApAAAABwAAAAEAAABPAAAAHAAAAAsAAAAAAAAACQAAABUAAABrAAAAFAAAABwAAAAWAAAADQAAADQAAABMAAAALAAAACEAAAAYAAAAGwAAACMAAAAeAAAAAAAAAAMAAAAAAAAACQAAACIAAAAEAAAAAAAAAA0AAAAvAAAADwAAAAMAAAAWAAAAAAAAAAIAAAAAAAAAJAAAABEAAAACAAAAGAAAAFUAAAAGAAAAAgAAAAAAAAACAAAAAwAAAAIAAAAOAAAAAgAAAAkAAAAIAAAALgAAACcAAAAHAAAAAwAAAAEAAAADAAAAFQAAAAIAAAAGAAAAAgAAAAEAAAACAAAABAAAAAQAAAAAAAAAEwAAAAAAAAANAAAABAAAAJ8AAAA0AAAAEwAAAAMAAAAVAAAAAgAAAB8AAAAvAAAAFQAAAAEAAAACAAAAAAAAALkAAAAuAAAAKgAAAAMAAAAlAAAALwAAABUAAAAAAAAAPAAAACoAAAAOAAAAAAAAAEgAAAAaAAAA5gAAACsAAAB1AAAAPwAAACAAAAAHAAAAAwAAAAAAAAADAAAABwAAAAIAAAABAAAAAgAAABcAAAAQAAAAAAAAAAIAAAAAAAAAXwAAAAcAAAADAAAAJgAAABEAAAAAAAAAAgAAAAAAAAAdAAAAAAAAAAsAAAAnAAAACAAAAAAAAAAWAAAAAAAAAAwAAAAtAAAAFAAAAAAAAAAjAAAAOAAAAAgBAAAIAAAAAgAAACQAAAASAAAAAAAAADIAAAAdAAAAcQAAAAYAAAACAAAAAQAAAAIAAAAlAAAAFgAAAAAAAAAaAAAABQAAAAIAAAABAAAAAgAAAB8AAAAPAAAAAAAAAEgBAAASAAAAvgAAAAAAAABQAAAAmQMAAGcAAABuAAAAEgAAAMMAAAC9CgAALgQAANIPAABGAgAAuiEAADgCAAAIAAAAHgAAAHIAAAAdAAAAEwAAAC8AAAARAAAAAwAAACAAAAAUAAAABgAAABIAAACxAgAAPwAAAIEAAABKAAAABgAAAAAAAABDAAAADAAAAEEAAAABAAAAAgAAAAAAAAAdAAAA9xcAAAkAAADVBAAAKwAAAAgAAAD4IgAAHgEAADIAAAACAAAAEgAAAAMAAAAJAAAAiwEAAAUJAABqAAAABgAAAAwAAAAEAAAACAAAAAgAAAAJAAAAZxcAAFQAAAACAAAARgAAAAIAAAABAAAAAwAAAAAAAAADAAAAAQAAAAMAAAADAAAAAgAAAAsAAAACAAAAAAAAAAIAAAAGAAAAAgAAAEAAAAACAAAAAwAAAAMAAAAHAAAAAgAAAAYAAAACAAAAGwAAAAIAAAADAAAAAgAAAAQAAAACAAAAAAAAAAQAAAAGAAAAAgAAAFMBAAADAAAAGAAAAAIAAAAYAAAAAgAAAB4AAAACAAAAGAAAAAIAAAAeAAAAAgAAABgAAAACAAAAHgAAAAIAAAAYAAAAAgAAAB4AAAACAAAAGAAAAAIAAAAHAAAANQkAACwAAAALAAAABgAAABEAAAAAAAAAcgEAACsAAAAVBQAAxAAAADwAAABDAAAACAAAAAAAAAC1BAAAAwAAAAIAAAAaAAAAAgAAAAEAAAACAAAAAAAAAAMAAAAAAAAAAgAAAAkAAAACAAAAAwAAAAIAAAAAAAAAAgAAAAAAAAAHAAAAAAAAAAUAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAIAAAACAAAAAgAAAAEAAAACAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAQAAAAIAAAAAAAAAAwAAAAMAAAACAAAABgAAAAIAAAADAAAAAgAAAAMAAAACAAAAAAAAAAIAAAAJAAAAAgAAABAAAAAGAAAAAgAAAAIAAAAEAAAAAgAAABAAAABFEQAA3aYAACMAAAA0EAAADAAAAN0AAAADAAAAgRYAAA8AAAAwHQAAIAwAAB0CAADjBQAAShMAAP0BAAAAAAAA4wAAAAAAAACWAAAABAAAACYBAAAJAAAAWAUAAAIAAAACAAAAAQAAAAYAAAADAAAAKQAAAAIAAAAFAAAAAAAAAKYAAAABAAAAPgIAAAMAAAAJAAAACQAAAHIBAAABAAAAmgAAAAoAAACwAAAAAgAAADYAAAAOAAAAIAAAAAkAAAAQAAAAAwAAAC4AAAAKAAAANgAAAAkAAAAHAAAAAgAAACUAAAANAAAAAgAAAAkAAAAGAAAAAQAAAC0AAAAAAAAADQAAAAIAAAAxAAAADQAAAAkAAAADAAAAAgAAAAsAAABTAAAACwAAAAcAAAAAAAAAoQAAAAsAAAAGAAAACQAAAAcAAAADAAAAOAAAAAEAAAACAAAABgAAAAMAAAABAAAAAwAAAAIAAAAKAAAAAAAAAAsAAAABAAAAAwAAAAYAAAAEAAAABAAAAMEAAAARAAAACgAAAAkAAAAFAAAAAAAAAFIAAAATAAAADQAAAAkAAADWAAAABgAAAAMAAAAIAAAAHAAAAAEAAABTAAAAEAAAABAAAAAJAAAAUgAAAAwAAAAJAAAACQAAAFQAAAAOAAAABQAAAAkAAADzAAAADgAAAKYAAAAJAAAARwAAAAUAAAACAAAAAQAAAAMAAAADAAAAAgAAAAAAAAACAAAAAQAAAA0AAAAJAAAAeAAAAAYAAAADAAAABgAAAAQAAAAAAAAAHQAAAAkAAAApAAAABgAAAAIAAAADAAAACQAAAAAAAAAKAAAACgAAAC8AAAAPAAAAlgEAAAcAAAACAAAABwAAABEAAAAJAAAAOQAAABUAAAACAAAADQAAAHsAAAAFAAAABAAAAAAAAAACAAAAAQAAAAIAAAAGAAAAAgAAAAAAAAAJAAAACQAAADEAAAAEAAAAAgAAAAEAAAACAAAABAAAAAkAAAAJAAAASgEAAAMAAABqSwAACQAAAIcAAAAEAAAAPAAAAAYAAAAaAAAACQAAAPYDAAAAAAAAAgAAADYAAAAIAAAAAwAAAFIAAAAAAAAADAAAAAEAAACsTAAAAQAAAMcUAAAEAAAABAAAAAUAAAAJAAAABwAAAAMAAAAGAAAAHwAAAAMAAACVAAAAAgAAAIoFAAAxAAAAAQIAADYAAAAFAAAAMQAAAAkAAAAAAAAADwAAAAAAAAAXAAAABAAAAAIAAAAOAAAAUQUAAAYAAAACAAAAEAAAAAMAAAAGAAAAAgAAAAEAAAACAAAABAAAAAYBAAAGAAAACgAAAAkAAACjAQAADQAAANcFAAAGAAAAbgAAAAYAAAAGAAAACQAAAJcSAAAJAAAABwUMAO8AAAAAQZgfCxxQjAAAAQAAAAIAAAADAAAABAAAAAAEAADwHwAA","undefined"!=typeof window&&"function"==typeof atob?Uint8Array.from(atob(B),A=>A.charCodeAt(0)):Buffer.from(B,"base64")));var B;const{exports:E}=await WebAssembly.instantiate(Q);A=E})())}
\ No newline at end of file
+"use strict";exports.parse=parse;exports.init=init;let A;const Q=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(g,I="@"){if(!A)throw new Error("Not initialized");const D=g.length+1,N=(A.__heap_base.value||A.__heap_base)+4*D-A.memory.buffer.byteLength;N>0&&A.memory.grow(Math.ceil(N/65536));const k=A.sa(D);if((Q?C:E)(g,new Uint16Array(A.memory.buffer,k,D)),!A.parseCJS(k,g.length,0,0,0))throw Object.assign(new Error(`Parse error ${I}${A.e()}:${g.slice(0,A.e()).split("\n").length}:${A.e()-g.lastIndexOf("\n",A.e()-1)}`),{idx:A.e()});let w=new Set,o=new Set,J=new Set;for(;A.rre();){const Q=B(g.slice(A.res(),A.ree()));Q&&o.add(Q)}for(;A.ru();)J.add(B(g.slice(A.us(),A.ue())));for(;A.re();){let Q=B(g.slice(A.es(),A.ee()));void 0===Q||J.has(Q)||w.add(Q)}return{exports:[...w],reexports:[...o]}}function B(A){if('"'!==A[0]&&"'"!==A[0])return A;try{const Q=(0,eval)(A);for(let A=0;A<Q.length;A++){const B=64512&Q.charCodeAt(A);if(!(B<55296)){if(55296!==B)return;if(56320!=(64512&Q.charCodeAt(++A)))return}}return Q}catch{}}function E(A,Q){const B=A.length;let E=0;for(;E<B;){const B=A.charCodeAt(E);Q[E++]=(255&B)<<8|B>>>8}}function C(A,Q){const B=A.length;let E=0;for(;E<B;)Q[E]=A.charCodeAt(E++)}let g;function init(){return g||(g=(async()=>{const Q=await WebAssembly.compile((B="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","undefined"!=typeof window&&"function"==typeof atob?Uint8Array.from(atob(B),A=>A.charCodeAt(0)):Buffer.from(B,"base64")));var B;const{exports:E}=await WebAssembly.instantiate(Q);A=E})())}
\ No newline at end of file
diff --git a/deps/cjs-module-lexer/dist/lexer.mjs b/deps/cjs-module-lexer/dist/lexer.mjs
index acb87e58e2cb71de792041472a50b03ced996c9b..5dc4052af6965e356589fdc9483793c439beb419 100644
--- a/deps/cjs-module-lexer/dist/lexer.mjs
+++ b/deps/cjs-module-lexer/dist/lexer.mjs
@@ -1,2 +1,2 @@
-/* cjs-module-lexer 1.2.1 */
-let A;const Q=1===new Uint8Array(new Uint16Array([1]).buffer)[0];export function parse(g,I="@"){if(!A)throw new Error("Not initialized");const D=g.length+1,N=(A.__heap_base.value||A.__heap_base)+4*D-A.memory.buffer.byteLength;N>0&&A.memory.grow(Math.ceil(N/65536));const k=A.sa(D);if((Q?C:E)(g,new Uint16Array(A.memory.buffer,k,D)),!A.parseCJS(k,g.length,0,0,0))throw Object.assign(new Error(`Parse error ${I}${A.e()}:${g.slice(0,A.e()).split("\n").length}:${A.e()-g.lastIndexOf("\n",A.e()-1)}`),{idx:A.e()});let w=new Set,J=new Set,K=new Set;for(;A.rre();){const Q=B(g.slice(A.res(),A.ree()));Q&&J.add(Q)}for(;A.ru();)K.add(B(g.slice(A.us(),A.ue())));for(;A.re();){let Q=B(g.slice(A.es(),A.ee()));void 0===Q||K.has(Q)||w.add(Q)}return{exports:[...w],reexports:[...J]}}function B(A){if('"'!==A[0]&&"'"!==A[0])return A;try{const Q=(0,eval)(A);for(let A=0;A<Q.length;A++){const B=64512&Q.charCodeAt(A);if(!(B<55296)){if(55296!==B)return;if(56320!=(64512&Q.charCodeAt(++A)))return}}return Q}catch{}}function E(A,Q){const B=A.length;let E=0;for(;E<B;){const B=A.charCodeAt(E);Q[E++]=(255&B)<<8|B>>>8}}function C(A,Q){const B=A.length;let E=0;for(;E<B;)Q[E]=A.charCodeAt(E++)}let g;export function init(){return g||(g=(async()=>{const Q=await WebAssembly.compile((B="AGFzbQEAAAABrAERYAJ/fwBgAABgAX8Bf2AAAX9gBn9/f39/fwF/YAF/AGAXf39/f39/f39/f39/f39/f39/f39/f38Bf2AIf39/f39/f38Bf2AHf39/f39/fwF/YAN/f38Bf2AFf39/f38Bf2AOf39/f39/f39/f39/f38Bf2AKf39/f39/f39/fwF/YAt/f39/f39/f39/fwF/YAJ/fwF/YAR/f39/AX9gCX9/f39/f39/fwF/A0NCAgMDAwMDAwMDAwMAAAABBAICBQQFAQECAgICAQUBAQUBAQYHAQIIAwICAgkKAgELAgwNDgQPCA4HAgICAhACAgMJBAUBcAEFBQUDAQABBg8CfwFB0JgCC38AQdCYAgsHXA4GbWVtb3J5AgACc2EAAAFlAAECZXMAAgJlZQADA3JlcwAEA3JlZQAFAnVzAAYCdWUABwJyZQAIA3JyZQAJAnJ1AAoIcGFyc2VDSlMADwtfX2hlYXBfYmFzZQMBCQoBAEEBCwQLDA0OCsWhAUJ4AQF/QQAoApgfIgEgAEEBdGoiAEEAOwEAQQAgAEECaiIANgLkH0EAIAA2AugfQQBBADYCwB9BAEEANgLIH0EAQQA2AsQfQQBBADYCzB9BAEEANgLUH0EAQQA2AtAfQQBBADYC2B9BAEEANgLgH0EAQQA2AtwfIAELCABBACgC7B8LFQBBACgCxB8oAgBBACgCmB9rQQF1CxUAQQAoAsQfKAIEQQAoApgfa0EBdQsVAEEAKALQHygCAEEAKAKYH2tBAXULFQBBACgC0B8oAgRBACgCmB9rQQF1CxUAQQAoAtwfKAIAQQAoApgfa0EBdQsVAEEAKALcHygCBEEAKAKYH2tBAXULJQEBf0EAQQAoAsQfIgBBCGpBwB8gABsoAgAiADYCxB8gAEEARwslAQF/QQBBACgC0B8iAEEIakHMHyAAGygCACIANgLQHyAAQQBHCyUBAX9BAEEAKALcHyIAQQhqQdgfIAAbKAIAIgA2AtwfIABBAEcLSAEBf0EAKALIHyICQQhqQcAfIAIbQQAoAugfIgI2AgBBACACNgLIH0EAIAJBDGo2AugfIAJBADYCCCACIAE2AgQgAiAANgIAC0gBAX9BACgC1B8iAkEIakHMHyACG0EAKALoHyICNgIAQQAgAjYC1B9BACACQQxqNgLoHyACQQA2AgggAiABNgIEIAIgADYCAAtIAQF/QQAoAuAfIgJBCGpB2B8gAhtBACgC6B8iAjYCAEEAIAI2AuAfQQAgAkEMajYC6B8gAkEANgIIIAIgATYCBCACIAA2AgALEgBBAEEANgLMH0EAQQA2AtQfC6MPAEEAIAE2AoBAQQAgADYCmB8CQCACRQ0AQQAgAjYCnB8LAkAgA0UNAEEAIAM2AqAfCwJAIARFDQBBACAENgKkHwtBAEH//wM7AYhAQQBBoMAANgKgYEEAQbDgADYCsKABQQBBgCA2ArSgAUEAQQAoAqwfNgKMQEEAIABBfmoiAjYCvKABQQAgAiABQQF0aiIDNgLAoAFBAEEAOwGGQEEAQQA7AYRAQQBBADoAkEBBAEEANgLsH0EAQQA6APAfQQBBADoAuKABAkACQCAALwEAQSNHDQAgAC8BAkEhRw0AQQEhAiABQQJGDQFBACAAQQJqNgK8oAEgAEEEaiEAAkADQCAAIgJBfmogA08NASACQQJqIQAgAi8BAEF2aiIBQQNLDQAgAQ4EAQAAAQELC0EAIAI2ArygAQsDQEEAIAJBAmoiADYCvKABAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCACIANPDQACQCAALwEAIgFBd2oiA0EXSw0AQQEgA3RBn4CABHENFwsCQAJAQQAvAYZAIgMNACABQaF/aiIEQQ5NDQMgAUFZaiIEQQhNDQQgAUGFf2oiBEECTQ0FIAFBIkYNCyABQc8ARg0BIAFB8gBHDRUCQEEAEBBFDQAgABARRQ0AIAIQEgtBAEEAKAK8oAE2AoxADBgLIAFBWWoiBEEITQ0FIAFBoH9qIgRBBU0NBiABQYV/aiIEQQJNDQcgAUEiRg0KIAFBzwBGDQAgAUHtAEcNFAwTCyACQQRqQeIAQeoAQeUAQeMAQfQAEBNFDRMgABARRQ0TIANFEBQMEwtBAC8BiEBB//8DRkEALwGGQEVxQQAtAPAfRXEPCyAEDg8SBRERDhEPERERExERERASCyAEDgkGDAgQEBAQEAUGCyAEDgMJDwcJCyAEDgkECgkODg4ODgMECyAEDgYBDQ0KDQsBCyAEDgMGDAMGC0EALwGIQEH+/wNGDQMMBAsCQAJAIAIvAQQiAkEqRg0AIAJBL0cNARAVDA8LEBYMDgsCQAJAAkACQEEAKAKMQCIALwEAIgIQF0UNACACQVVqIgNBA0sNAgJAAkACQCADDgQBBQIAAQsgAEF+ai8BAEFQakH//wNxQQpJDQMMBAsgAEF+ai8BAEErRg0CDAMLIABBfmovAQBBLUYNAQwCCwJAAkAgAkH9AEYNACACQS9GDQEgAkEpRw0CQQAoArCgASADQQJ0aigCABAYRQ0CDAMLQQAoArCgASADQQJ0aigCABAZDQIgA0HQoAFqLQAARQ0BDAILQQAtAJBADQELIAAQGiEDIAJFDQBBASECIANFDQELEBtBACECC0EAIAI6AJBADAoLIAEQHAwJC0EAIANBf2oiADsBhkACQCADQQAvAYhAIgJHDQBBAEEALwGEQEF/aiICOwGEQEEAQQAoAqBgIAJB//8DcUEBdGovAQA7AYhADAILIAJB//8DRg0IIABB//8DcSACTw0ICxAdQQAhAgwMCxAeDAYLIANB0KABakEALQC4oAE6AABBACADQQFqOwGGQEEAKAKwoAEgA0ECdGpBACgCjEA2AgBBAEEAOgC4oAEMBQtBACADQX9qOwGGQAwEC0EAIANBAWo7AYZAQQAoArCgASADQQJ0akEAKAKMQDYCAAwDCyAAEBFFDQIgAi8BBEHsAEcNAiACLwEGQeEARw0CIAIvAQhB8wBHDQIgAi8BCkHzAEcNAgJAAkAgAi8BDCIDQXdqIgJBF0sNAEEBIAJ0QZ+AgARxDQELIANBoAFHDQMLQQBBAToAuKABDAILIAJBBGpB+ABB8ABB7wBB8gBB9AAQE0UNASAAEBFFDQECQCACLwEOQfMARw0AQQAQHwwCCyADDQEQIAwBCyACQQRqQe8AQeQAQfUAQewAQeUAEBNFDQAgABARRQ0AECELQQBBACgCvKABNgKMQAwCCwJAAkAgAkEEaiIDQekAQe4AQfQAQeUAQfIAQe8AQfAAQdIAQeUAQfEAQfUAQekAQfIAQeUAQdcAQekAQewAQeQAQeMAQeEAQfIAQeQAECJFDQACQCAAEBENACACLwEAQS5HDQELQQAgAkEwajYCvKABIAIvATBBKEcNAUEAIAJBMmo2ArygAUEAQQE7AYZAQQAoArCgAUEAKAKMQDYCAEEAEBBFDQEgABARRQ0BIAIQEgwBCyADQd8AQeUAQfgAQfAAQe8AQfIAQfQAECNFDQACQCAAEBENACACLwEAQS5HDQELQQAgAkESajYCvKABAkAgAi8BEiIDQdMARw0AIAIvARRB9ABHDQEgAi8BFkHhAEcNASACLwEYQfIARw0BQQAgAkEaajYCvKABIAIvARohAwsgA0H//wNxQShHDQBBACgCsKABQQAoAoxANgIAQQBBATsBhkBBAEEAKAK8oAEiAkECajYCvKABIAIvAQJB8gBHDQBBAhAQGgtBAEEAKAK8oAE2AoxADAELAkAgAkEEakHtAEHwAEHvAEHyAEH0ABATRQ0AIAAQEUUNABAkQQAoArygASEAC0EAIAA2AoxAC0EAKALAoAEhA0EAKAK8oAEhAgwACwsgAgv3AQEEf0EAIQECQEEAKAK8oAEiAkECakHlAEHxAEH1AEHpAEHyAEHlABAmRQ0AQQAhAUEAIAJBDmo2ArygAQJAECdBKEcNAEEAQQAoArygAUECajYCvKABECchA0EAKAK8oAEhBAJAIANBJ0YNACADQSJHDQELIAMQHEEAQQAoArygAUECaiIDNgK8oAEQJ0EpRw0AAkAgAEF/aiIBQQFLDQACQAJAIAEOAgEAAQsgBCADQQAoAqAfEQAAQQEPCyAEIANBACgCoB8RAABBAQ8LQQAoArSgASAENgIAQQAoArSgASADNgIEQQEPC0EAIAI2ArygAQsgAQsdAAJAQQAoApgfIABHDQBBAQ8LIABBfmovAQAQJQv+AgEEf0EAKAKYHyEBAkADQCAAQX5qIQIgAC8BACIDQSBHDQEgACABSyEEIAIhACAEDQALCwJAIANBPUcNAAJAA0AgAkF+aiEAIAIvAQBBIEcNASACIAFLIQQgACECIAQNAAsLIABBAmohAiAAQQRqIQNBACEEAkADQCACECghACACIAFNDQEgAEUNASAAQdwARg0CIAAQKUUNASACQX5BfCAAQYCABEkbaiECIAAQKiEEDAALCyAEQQFxRQ0AIAIvAQBBIEcNAEEAKAK0oAEiBEEAKAKwH0YNACAEIAM2AgwgBCACQQJqNgIIIAJBfmohAEEgIQICQANAIABBAmogAU0NASACQf//A3FBIEcNASAALwEAIQIgAEF+aiEADAALCyACQf//A3FBjn9qIgJBAksNAAJAAkACQCACDgMAAwEACyAAQfYAQeEAECsNAQwCCyAAQewAQeUAECsNACAAQeMAQe8AQe4AQfMAECxFDQELQQAgBEEQajYCtKABCws/AQF/QQAhBgJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVGIQYLIAYLliYBCH9BAEEAKAK8oAEiAUEMajYCvKABIAFBCmohAQJAECdBLkcNAEEAQQAoArygAUECajYCvKABAkACQBAnIgJB5ABHDQBBACgCvKABIgBBAmpB5QBB5gBB6QBB7gBB5QBB0ABB8gBB7wBB8ABB5QBB8gBB9ABB+QAQL0UNAkEAIABBHGo2ArygASAAQRpqIQEQJ0EoRw0CQQBBACgCvKABQQJqNgK8oAEQJxAwRQ0CECdBLEcNAkEAQQAoArygAUECajYCvKABAkAQJyIAQSdGDQAgAEEiRw0DC0EAKAK8oAEhAiAAEBxBAEEAKAK8oAFBAmoiADYCvKABECdBLEcNAUEAQQAoArygAUECajYCvKABECdB+wBHDQFBAEEAKAK8oAFBAmo2ArygAQJAECciA0HlAEcNAEEAKAK8oAEiA0ECakHuAEH1AEHtAEHlAEHyAEHhAEHiAEHsAEHlABAxRQ0CQQAgA0EUajYCvKABECdBOkcNAkEAQQAoArygAUECajYCvKABECdB9ABHDQJBACgCvKABIgMvAQJB8gBHDQIgAy8BBEH1AEcNAiADLwEGQeUARw0CQQAgA0EIajYCvKABECdBLEcNAkEAQQAoArygAUECajYCvKABECchAwsCQCADQecARg0AIANB9gBHDQJBACgCvKABIgMvAQJB4QBHDQIgAy8BBEHsAEcNAiADLwEGQfUARw0CIAMvAQhB5QBHDQJBACADQQpqNgK8oAEQJ0E6Rw0CIAIgAEEAKAKcHxEAAEEAIAE2ArygAQ8LQQAoArygASIDLwECQeUARw0BIAMvAQRB9ABHDQFBACADQQZqNgK8oAECQBAnIgNBOkcNAEEAQQAoArygAUECajYCvKABECdB5gBHDQJBACgCvKABIgNBAmpB9QBB7gBB4wBB9ABB6QBB7wBB7gAQI0UNAkEAIANBEGoiAzYCvKABAkAQJyIEQShGDQAgA0EAKAK8oAFGDQMgBBAtRQ0DCxAnIQMLIANBKEcNAUEAQQAoArygAUECajYCvKABECdBKUcNAUEAQQAoArygAUECajYCvKABECdB+wBHDQFBAEEAKAK8oAFBAmo2ArygARAnQfIARw0BQQAoArygASIDQQJqQeUAQfQAQfUAQfIAQe4AEBNFDQFBACADQQxqNgK8oAEQJxAtRQ0BAkACQAJAECciA0HbAEYNACADQS5HDQJBAEEAKAK8oAFBAmo2ArygARAnEC0NAQwEC0EAQQAoArygAUECajYCvKABAkAQJyIDQSdGDQAgA0EiRw0ECyADEBxBAEEAKAK8oAFBAmo2ArygARAnQd0ARw0DQQBBACgCvKABQQJqNgK8oAELECchAwsCQCADQTtHDQBBAEEAKAK8oAFBAmo2ArygARAnIQMLIANB/QBHDQFBAEEAKAK8oAFBAmo2ArygAQJAECciA0EsRw0AQQBBACgCvKABQQJqNgK8oAEQJyEDCyADQf0ARw0BQQBBACgCvKABQQJqNgK8oAEQJ0EpRw0BIAIgAEEAKAKcHxEAAA8LIAJB6wBHDQEgAEUNAUEAKAK8oAEiAC8BAkHlAEcNASAALwEEQfkARw0BIAAvAQZB8wBHDQEgAEEGaiEBQQAgAEEIajYCvKABECdBKEcNAUEAQQAoArygAUECajYCvKABECchAEEAKAK8oAEhAiAAEC1FDQFBACgCvKABIQAQJ0EpRw0BQQBBACgCvKABIgFBAmo2ArygARAnQS5HDQFBAEEAKAK8oAFBAmo2ArygARAnQeYARw0BQQAoArygASIDQQJqQe8AQfIAQcUAQeEAQeMAQegAECZFDQFBACADQQ5qNgK8oAEQJyEDQQAoArygASIEQX5qIQEgA0EoRw0BQQAgBEECajYCvKABECdB5gBHDQFBACgCvKABIgNBAmpB9QBB7gBB4wBB9ABB6QBB7wBB7gAQI0UNAUEAIANBEGo2ArygARAnQShHDQFBAEEAKAK8oAFBAmo2ArygARAnIQNBACgCvKABIQQgAxAtRQ0BQQAoArygASEDECdBKUcNAUEAQQAoArygAUECajYCvKABECdB+wBHDQFBAEEAKAK8oAFBAmo2ArygARAnQekARw0BQQAoArygASIFLwECQeYARw0BQQAgBUEEajYCvKABECdBKEcNAUEAQQAoArygAUECajYCvKABECcaQQAoArygASIFIAQgAyAEayIDEEENASAAIAJrIgZBAXUhB0EAIAUgA0EBdSIIQQF0ajYCvKABAkACQAJAECciAEEhRg0AIABBPUcNBEEAKAK8oAEiAC8BAkE9Rw0EIAAvAQRBPUcNBEEAIABBBmo2ArygAQJAECciAEEnRg0AIABBIkcNBQtBACgCvKABIgVBAmpB5ABB5QBB5gBB4QBB9QBB7ABB9AAQI0UNBEEAIAVBEGo2ArygARAnIABHDQRBAEEAKAK8oAFBAmo2ArygARAnQfwARw0EQQAoArygASIALwECQfwARw0EQQAgAEEEajYCvKABECcaQQAoArygASIAIAQgAxBBDQRBACAAIAhBAXRqNgK8oAEQJ0E9Rw0EQQAoArygASIALwECQT1HDQQgAC8BBEE9Rw0EQQAgAEEGajYCvKABAkAQJyIAQSdGDQAgAEEiRw0FC0EAKAK8oAEiBUECakHfAEHfAEHlAEHzAEHNAEHvAEHkAEH1AEHsAEHlABAyRQ0EQQAgBUEWajYCvKABECcgAEcNBEEAQQAoArygAUECajYCvKABECdBKUcNBEEAQQAoArygAUECajYCvKABECdB8gBHDQRBACgCvKABIgBBAmpB5QBB9ABB9QBB8gBB7gAQE0UNBEEAIABBDGo2ArygAQJAECdBO0cNAEEAQQAoArygAUECajYCvKABCxAnIgBB6QBHDQJB6QAhAEEAKAK8oAEiBS8BAkHmAEcNAkEAIAVBBGo2ArygARAnQShHDQRBAEEAKAK8oAFBAmoiADYCvKABAkAgBCAIEDNFDQAQJ0EpRw0FQQBBACgCvKABQQJqNgK8oAEQJ0HyAEcNBUEAKAK8oAEiAEECakHlAEH0AEH1AEHyAEHuABATRQ0FQQAgAEEMajYCvKABAkAQJ0E7Rw0AQQBBACgCvKABQQJqNgK8oAELECciAEHpAEcNA0HpACEAQQAoArygASIFLwECQeYARw0DQQAgBUEEajYCvKABECdBKEcNBUEAKAK8oAFBAmohAAtBACAANgK8oAEgACAEIAMQQQ0EQQAgACAIQQF0ajYCvKABECdB6QBHDQRBACgCvKABIgAvAQJB7gBHDQQgAC8BBEEgRw0EQQAgAEEGajYCvKABECcQMEUNBBAnQSZHDQRBACgCvKABIgAvAQJBJkcNBEEAIABBBGo2ArygARAnEDBFDQQQJ0HbAEcNBEEAQQAoArygAUECajYCvKABECcaQQAoArygASIAIAQgAxBBDQRBACAAIAhBAXRqNgK8oAEQJ0HdAEcNBEEAQQAoArygAUECajYCvKABECdBPUcNBEEAKAK8oAEiAC8BAkE9Rw0EIAAvAQRBPUcNBEEAIABBBmo2ArygARAnGkEAKAK8oAEiACACIAYQQQ0EQQAgACAHQQF0ajYCvKABECdB2wBHDQRBAEEAKAK8oAFBAmo2ArygARAnGkEAKAK8oAEiACAEIAMQQQ0EQQAgACAIQQF0ajYCvKABECdB3QBHDQRBAEEAKAK8oAFBAmo2ArygARAnQSlHDQRBAEEAKAK8oAFBAmo2ArygARAnQfIARw0EQQAoArygASIAQQJqQeUAQfQAQfUAQfIAQe4AEBNFDQRBACAAQQxqNgK8oAEQJ0E7Rw0BQQBBACgCvKABQQJqNgK8oAEMAQtBACgCvKABIgAvAQJBPUcNAyAALwEEQT1HDQNBACAAQQZqNgK8oAECQBAnIgBBJ0YNACAAQSJHDQQLQQAoArygASIFQQJqQeQAQeUAQeYAQeEAQfUAQewAQfQAECNFDQNBACAFQRBqNgK8oAEQJyAARw0DQQBBACgCvKABQQJqNgK8oAECQBAnIgBBJkcNAEEAKAK8oAEiAC8BAkEmRw0EQQAgAEEEajYCvKABECdBIUcNBEEAQQAoArygAUECajYCvKABECcaAkACQEEAKAK8oAEiACACIAYQQQ0AQQAgACAHQQF0ajYCvKABECdBLkcNBkEAQQAoArygAUECajYCvKABECdB6ABHDQZBACgCvKABIgBBAmpB4QBB8wBBzwBB9wBB7gBB0ABB8gBB7wBB8ABB5QBB8gBB9ABB+QAQL0UNBkEAIABBHGo2ArygARAnQShHDQZBAEEAKAK8oAFBAmo2ArygARAnGkEAKAK8oAEiACAEIAMQQQ0GQQAgACAIQQF0ajYCvKABECdBKUcNBkEAQQAoArygAUECajYCvKABDAELIAQgCBAzRQ0FCxAnIQALIABBKUcNA0EAQQAoArygAUECajYCvKABCxAnIQALAkACQAJAIAAQMEUNABAnQdsARw0EQQBBACgCvKABQQJqNgK8oAEQJxpBACgCvKABIgAgBCADEEENBEEAIAAgCEEBdGo2ArygARAnQd0ARw0EQQBBACgCvKABQQJqNgK8oAEQJ0E9Rw0EQQBBACgCvKABQQJqNgK8oAEQJxpBACgCvKABIgAgAiAGEEENBEEAIAAgB0EBdGo2ArygARAnQdsARw0EQQBBACgCvKABQQJqNgK8oAEQJxpBACgCvKABIgAgBCADEEENBEEAIAAgCEEBdGo2ArygARAnQd0ARw0EQQBBACgCvKABQQJqNgK8oAEQJyIAQTtHDQJBAEEAKAK8oAFBAmo2ArygAQwBCyAAQc8ARw0DQQAoArygASIAQQJqQeIAQeoAQeUAQeMAQfQAEBNFDQNBACAAQQxqNgK8oAEQJ0EuRw0DQQBBACgCvKABQQJqNgK8oAEQJ0HkAEcNA0EAKAK8oAEiAEECakHlAEHmAEHpAEHuAEHlAEHQAEHyAEHvAEHwAEHlAEHyAEH0AEH5ABAvRQ0DQQAgAEEcajYCvKABECdBKEcNA0EAQQAoArygAUECajYCvKABECcQMEUNAxAnQSxHDQNBAEEAKAK8oAFBAmo2ArygARAnGkEAKAK8oAEiACAEIAMQQQ0DQQAgACAIQQF0ajYCvKABECdBLEcNA0EAQQAoArygAUECajYCvKABECdB+wBHDQNBAEEAKAK8oAFBAmo2ArygARAnQeUARw0DQQAoArygASIAQQJqQe4AQfUAQe0AQeUAQfIAQeEAQeIAQewAQeUAEDFFDQNBACAAQRRqNgK8oAEQJ0E6Rw0DQQBBACgCvKABQQJqNgK8oAEQJyEFQQAoArygASEAAkAgBUH0AEYNACAALwECQfIARw0EIAAvAQRB9QBHDQQgAC8BBkHlAEcNBAtBACAAQQhqNgK8oAEQJ0EsRw0DQQBBACgCvKABQQJqNgK8oAEQJ0HnAEcNA0EAKAK8oAEiAC8BAkHlAEcNAyAALwEEQfQARw0DQQAgAEEGajYCvKABAkAQJyIAQTpHDQBBAEEAKAK8oAFBAmo2ArygARAnQeYARw0EQQAoArygASIAQQJqQfUAQe4AQeMAQfQAQekAQe8AQe4AECNFDQRBACAAQRBqIgA2ArygAQJAECciBUEoRg0AIABBACgCvKABRg0FIAUQLUUNBQsQJyEACyAAQShHDQNBAEEAKAK8oAFBAmo2ArygARAnQSlHDQNBAEEAKAK8oAFBAmo2ArygARAnQfsARw0DQQBBACgCvKABQQJqNgK8oAEQJ0HyAEcNA0EAKAK8oAEiAEECakHlAEH0AEH1AEHyAEHuABATRQ0DQQAgAEEMajYCvKABECcaQQAoArygASIAIAIgBhBBDQNBACAAIAdBAXRqNgK8oAEQJ0HbAEcNA0EAQQAoArygAUECajYCvKABECcaQQAoArygASIAIAQgAxBBDQNBACAAIAhBAXRqNgK8oAEQJ0HdAEcNA0EAQQAoArygAUECajYCvKABAkAQJyIAQTtHDQBBAEEAKAK8oAFBAmo2ArygARAnIQALIABB/QBHDQNBAEEAKAK8oAFBAmo2ArygAQJAECciAEEsRw0AQQBBACgCvKABQQJqNgK8oAEQJyEACyAAQf0ARw0DQQBBACgCvKABQQJqNgK8oAEQJ0EpRw0DQQBBACgCvKABQQJqNgK8oAEQJyIAQTtHDQFBAEEAKAK8oAFBAmo2ArygAQsQJyEACyAAQf0ARw0BQQBBACgCvKABQQJqNgK8oAEQJ0EpRw0BQQAoArSgASEEQYAgIQADQAJAAkAgBCAARg0AIAcgAEEMaigCACAAQQhqKAIAIgNrQQF1Rw0BIAIgAyAGEEENASAAKAIAIABBBGooAgBBACgCoB8RAABBACABNgK8oAELDwsgAEEQaiEADAALCyACIABBACgCpB8RAAALQQAgATYCvKABC1MBBH9BACgCvKABQQJqIQBBACgCwKABIQECQANAIAAiAkF+aiABTw0BIAJBAmohACACLwEAQXZqIgNBA0sNACADDgQBAAABAQsLQQAgAjYCvKABC3wBAn9BAEEAKAK8oAEiAEECajYCvKABIABBBmohAEEAKALAoAEhAQNAAkACQAJAIABBfGogAU8NACAAQX5qLwEAQSpHDQIgAC8BAEEvRw0CQQAgAEF+ajYCvKABDAELIABBfmohAAtBACAANgK8oAEPCyAAQQJqIQAMAAsLdQEBfwJAAkAgAEFfaiIBQQVLDQBBASABdEExcQ0BCyAAQUZqQf//A3FBBkkNACAAQVhqQf//A3FBB0kgAEEpR3ENAAJAIABBpX9qIgFBA0sNACABDgQBAAABAQsgAEH9AEcgAEGFf2pB//8DcUEESXEPC0EBCz0BAX9BASEBAkAgAEH3AEHoAEHpAEHsAEHlABA0DQAgAEHmAEHvAEHyABA1DQAgAEHpAEHmABArIQELIAELrQEBA39BASEBAkACQAJAAkACQAJAAkAgAC8BACICQUVqIgNBA00NACACQZt/aiIDQQNNDQEgAkEpRg0DIAJB+QBHDQIgAEF+akHmAEHpAEHuAEHhAEHsAEHsABA2DwsgAw4EAgEBBQILIAMOBAIAAAMCC0EAIQELIAEPCyAAQX5qQeUAQewAQfMAEDUPCyAAQX5qQeMAQeEAQfQAQeMAECwPCyAAQX5qLwEAQT1GC+0DAQJ/QQAhAQJAIAAvAQBBnH9qIgJBE0sNAAJAAkACQAJAAkACQAJAAkAgAg4UAAECCAgICAgICAMECAgFCAYICAcACyAAQX5qLwEAQZd/aiICQQNLDQcCQAJAIAIOBAAJCQEACyAAQXxqQfYAQe8AECsPCyAAQXxqQfkAQekAQeUAEDUPCyAAQX5qLwEAQY1/aiICQQFLDQYCQAJAIAIOAgABAAsCQCAAQXxqLwEAIgJB4QBGDQAgAkHsAEcNCCAAQXpqQeUAEDcPCyAAQXpqQeMAEDcPCyAAQXxqQeQAQeUAQewAQeUAECwPCyAAQX5qLwEAQe8ARw0FIABBfGovAQBB5QBHDQUCQCAAQXpqLwEAIgJB8ABGDQAgAkHjAEcNBiAAQXhqQekAQe4AQfMAQfQAQeEAQe4AEDYPCyAAQXhqQfQAQfkAECsPC0EBIQEgAEF+aiIAQekAEDcNBCAAQfIAQeUAQfQAQfUAQfIAEDQPCyAAQX5qQeQAEDcPCyAAQX5qQeQAQeUAQeIAQfUAQecAQecAQeUAEDgPCyAAQX5qQeEAQfcAQeEAQekAECwPCwJAIABBfmovAQAiAkHvAEYNACACQeUARw0BIABBfGpB7gAQNw8LIABBfGpB9ABB6ABB8gAQNSEBCyABC4cBAQN/A0BBAEEAKAK8oAEiAEECaiIBNgK8oAECQAJAAkAgAEEAKALAoAFPDQAgAS8BACIBQaV/aiICQQFNDQICQCABQXZqIgBBA00NACABQS9HDQQMAgsgAA4EAAMDAAALEB0LDwsCQAJAIAIOAgEAAQtBACAAQQRqNgK8oAEMAQsQQBoMAAsLlQEBBH9BACgCvKABIQFBACgCwKABIQICQAJAA0AgASIDQQJqIQEgAyACTw0BIAEvAQAiBCAARg0CAkAgBEHcAEYNACAEQXZqIgNBA0sNASADDgQCAQECAgsgA0EEaiEBIAMvAQRBDUcNACADQQZqIAEgAy8BBkEKRhshAQwACwtBACABNgK8oAEQHQ8LQQAgATYCvKABCzgBAX9BAEEBOgDwH0EAKAK8oAEhAEEAQQAoAsCgAUECajYCvKABQQAgAEEAKAKYH2tBAXU2AuwfC84BAQV/QQAoArygASEAQQAoAsCgASEBA0AgACICQQJqIQACQAJAIAIgAU8NACAALwEAIgNBpH9qIgRBBE0NASADQSRHDQIgAi8BBEH7AEcNAkEAQQAvAYRAIgBBAWo7AYRAQQAoAqBgIABBAXRqQQAvAYhAOwEAQQAgAkEEajYCvKABQQBBAC8BhkBBAWoiADsBiEBBACAAOwGGQA8LQQAgADYCvKABEB0PCwJAAkAgBA4FAQICAgABC0EAIAA2ArygAQ8LIAJBBGohAAwACwu2AgECf0EAQQAoArygASIBQQ5qNgK8oAECQAJAAkAQJyICQdsARg0AIAJBPUYNASACQS5HDQJBAEEAKAK8oAFBAmo2ArygARAnIQJBACgCvKABIQAgAhAtRQ0CQQAoArygASECECdBPUcNAiAAIAJBACgCnB8RAAAPC0EAQQAoArygAUECajYCvKABAkAQJyICQSdGDQAgAkEiRw0CC0EAKAK8oAEhACACEBxBAEEAKAK8oAFBAmoiAjYCvKABECdB3QBHDQFBAEEAKAK8oAFBAmo2ArygARAnQT1HDQEgACACQQAoApwfEQAADAELIABFDQBBACgCqB8RAQBBAEEAKAK8oAFBAmo2ArygAQJAECciAkHyAEYNACACQfsARw0BEC4PC0EBEBAaC0EAIAFBDGo2ArygAQs2AQJ/QQBBACgCvKABQQxqIgA2ArygARAnIQECQAJAQQAoArygASAARw0AIAEQP0UNAQsQHQsLbAEBf0EAQQAoArygASIAQQxqNgK8oAECQBAnQS5HDQBBAEEAKAK8oAFBAmo2ArygARAnQeUARw0AQQAoArygAUECakH4AEHwAEHvAEHyAEH0AEHzABAmRQ0AQQEQHw8LQQAgAEEKajYCvKABC+kBAQF/QQAhFwJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVHDQAgAC8BCiAGRw0AIAAvAQwgB0cNACAALwEOIAhHDQAgAC8BECAJRw0AIAAvARIgCkcNACAALwEUIAtHDQAgAC8BFiAMRw0AIAAvARggDUcNACAALwEaIA5HDQAgAC8BHCAPRw0AIAAvAR4gEEcNACAALwEgIBFHDQAgAC8BIiASRw0AIAAvASQgE0cNACAALwEmIBRHDQAgAC8BKCAVRw0AIAAvASogFkYhFwsgFwtTAQF/QQAhCAJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVHDQAgAC8BCiAGRw0AIAAvAQwgB0YhCAsgCAukAQEEf0EAQQAoArygASIAQQxqIgE2ArygAQJAAkACQAJAAkAQJyICQVlqIgNBB00NACACQSJGDQIgAkH7AEYNAgwBCwJAIAMOCAIAAQIBAQEDAgtBAEEALwGGQCIDQQFqOwGGQEEAKAKwoAEgA0ECdGogADYCAA8LQQAoArygASABRg0CC0EALwGGQEUNAEEAQQAoArygAUF+ajYCvKABDwsQHQsLNAEBf0EBIQECQCAAQXdqQf//A3FBBUkNACAAQYABckGgAUYNACAAQS5HIAAQP3EhAQsgAQtJAQF/QQAhBwJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVHDQAgAC8BCiAGRiEHCyAHC3oBA39BACgCvKABIQACQANAAkAgAC8BACIBQXdqQQVJDQAgAUEgRg0AIAFBoAFGDQAgAUEvRw0CAkAgAC8BAiIAQSpGDQAgAEEvRw0DEBUMAQsQFgtBAEEAKAK8oAEiAkECaiIANgK8oAEgAkEAKALAoAFJDQALCyABCzkBAX8CQCAALwEAIgFBgPgDcUGAuANHDQAgAEF+ai8BAEH/B3FBCnQgAUH/B3FyQYCABGohAQsgAQt9AQF/AkAgAEEvSw0AIABBJEYPCwJAIABBOkkNAEEAIQECQCAAQcEASQ0AIABB2wBJDQECQCAAQeAASw0AIABB3wBGDwsgAEH7AEkNAQJAIABB//8DSw0AIABBqgFJDQEgABA5DwtBASEBIAAQOg0AIAAQOyEBCyABDwtBAQtjAQF/AkAgAEHAAEsNACAAQSRGDwtBASEBAkAgAEHbAEkNAAJAIABB4ABLDQAgAEHfAEYPCyAAQfsASQ0AAkAgAEH//wNLDQBBACEBIABBqgFJDQEgABA8DwsgABA6IQELIAELTAEDf0EAIQMCQCAAQX5qIgRBACgCmB8iBUkNACAELwEAIAFHDQAgAC8BACACRw0AAkAgBCAFRw0AQQEPCyAAQXxqLwEAECUhAwsgAwtmAQN/QQAhBQJAIABBemoiBkEAKAKYHyIHSQ0AIAYvAQAgAUcNACAAQXxqLwEAIAJHDQAgAEF+ai8BACADRw0AIAAvAQAgBEcNAAJAIAYgB0cNAEEBDwsgAEF4ai8BABAlIQULIAULhQEBAn8gABA+IgAQKiEBAkACQCAAQdwARg0AQQAhAiABRQ0BC0EAKAK8oAFBAkEEIABBgIAESRtqIQACQANAQQAgADYCvKABIAAvAQAQPiIBRQ0BAkAgARApRQ0AIABBAkEEIAFBgIAESRtqIQAMAQsLQQAhAiABQdwARg0BC0EBIQILIAIL2gMBBH9BACgCvKABIgBBfmohAQNAQQAgAEECajYCvKABAkACQAJAIABBACgCwKABTw0AECchAEEAKAK8oAEhAgJAAkAgABAtRQ0AQQAoArygASEDAkACQBAnIgBBOkcNAEEAQQAoArygAUECajYCvKABECcQLUUNAUEAKAK8oAEvAQAhAAsgAiADQQAoApwfEQAADAILQQAgATYCvKABDwsCQAJAIABBIkYNACAAQS5GDQEgAEEnRw0EC0EAKAK8oAEhAiAAEBxBAEEAKAK8oAFBAmoiAzYCvKABECciAEE6Rw0BQQBBACgCvKABQQJqNgK8oAECQBAnEC1FDQBBACgCvKABLwEAIQAgAiADQQAoApwfEQAADAILQQAgATYCvKABDwtBACgCvKABIgAvAQJBLkcNAiAALwEEQS5HDQJBACAAQQZqNgK8oAECQAJAAkAgAC8BBiIAQfIARw0AQQEQECEAQQAoArygASECIAANASACLwEAIQALIABB//8DcRAtDQFBACABNgK8oAEPC0EAIAJBAmo2ArygAQsQJyEACyAAQf//A3EiAEEsRg0CIABB/QBGDQBBACABNgK8oAELDwtBACABNgK8oAEPC0EAKAK8oAEhAAwACwuPAQEBf0EAIQ4CQCAALwEAIAFHDQAgAC8BAiACRw0AIAAvAQQgA0cNACAALwEGIARHDQAgAC8BCCAFRw0AIAAvAQogBkcNACAALwEMIAdHDQAgAC8BDiAIRw0AIAAvARAgCUcNACAALwESIApHDQAgAC8BFCALRw0AIAAvARYgDEcNACAALwEYIA1GIQ4LIA4LqAEBAn9BACEBQQAoArygASECAkACQCAAQe0ARw0AIAJBAmpB7wBB5ABB9QBB7ABB5QAQE0UNAUEAIAJBDGo2ArygAQJAECdBLkYNAEEAIQEMAgtBAEEAKAK8oAFBAmo2ArygARAnIQALIABB5QBHDQBBACgCvKABIgBBDmogAiAAQQJqQfgAQfAAQe8AQfIAQfQAQfMAECYiARshAgtBACACNgK8oAEgAQtnAQF/QQAhCgJAIAAvAQAgAUcNACAALwECIAJHDQAgAC8BBCADRw0AIAAvAQYgBEcNACAALwEIIAVHDQAgAC8BCiAGRw0AIAAvAQwgB0cNACAALwEOIAhHDQAgAC8BECAJRiEKCyAKC3EBAX9BACELAkAgAC8BACABRw0AIAAvAQIgAkcNACAALwEEIANHDQAgAC8BBiAERw0AIAAvAQggBUcNACAALwEKIAZHDQAgAC8BDCAHRw0AIAAvAQ4gCEcNACAALwEQIAlHDQAgAC8BEiAKRiELCyALC4MEAQJ/QQAhAgJAECdBzwBHDQBBACECQQAoArygASIDQQJqQeIAQeoAQeUAQeMAQfQAEBNFDQBBACECQQAgA0EMajYCvKABECdBLkcNAEEAQQAoArygAUECajYCvKABAkAQJyIDQfAARw0AQQAhAkEAKAK8oAEiA0ECakHyAEHvAEH0AEHvAEH0AEH5AEHwAEHlABA9RQ0BQQAhAkEAIANBEmo2ArygARAnQS5HDQFBAEEAKAK8oAFBAmo2ArygARAnIQMLQQAhAiADQegARw0AQQAhAkEAKAK8oAEiA0ECakHhAEHzAEHPAEH3AEHuAEHQAEHyAEHvAEHwAEHlAEHyAEH0AEH5ABAvRQ0AQQAhAkEAIANBHGo2ArygARAnQS5HDQBBACECQQBBACgCvKABQQJqNgK8oAEQJ0HjAEcNAEEAIQJBACgCvKABIgMvAQJB4QBHDQAgAy8BBEHsAEcNACADLwEGQewARw0AQQAhAkEAIANBCGo2ArygARAnQShHDQBBACECQQBBACgCvKABQQJqNgK8oAEQJxAtRQ0AECdBLEcNAEEAIQJBAEEAKAK8oAFBAmo2ArygARAnGkEAKAK8oAEiAyAAIAFBAXQiARBBDQBBACECQQAgAyABajYCvKABECdBKUcNAEEAQQAoArygAUECajYCvKABQQEhAgsgAgtJAQN/QQAhBgJAIABBeGoiB0EAKAKYHyIISQ0AIAcgASACIAMgBCAFEBNFDQACQCAHIAhHDQBBAQ8LIABBdmovAQAQJSEGCyAGC1kBA39BACEEAkAgAEF8aiIFQQAoApgfIgZJDQAgBS8BACABRw0AIABBfmovAQAgAkcNACAALwEAIANHDQACQCAFIAZHDQBBAQ8LIABBemovAQAQJSEECyAEC0sBA39BACEHAkAgAEF2aiIIQQAoApgfIglJDQAgCCABIAIgAyAEIAUgBhAmRQ0AAkAgCCAJRw0AQQEPCyAAQXRqLwEAECUhBwsgBws9AQJ/QQAhAgJAQQAoApgfIgMgAEsNACAALwEAIAFHDQACQCADIABHDQBBAQ8LIABBfmovAQAQJSECCyACC00BA39BACEIAkAgAEF0aiIJQQAoApgfIgpJDQAgCSABIAIgAyAEIAUgBiAHECNFDQACQCAJIApHDQBBAQ8LIABBcmovAQAQJSEICyAIC/kSAQN/AkAgABA8DQAgAEH0v39qQQJJDQAgAEG3AUYNACAAQYB6akHwAEkNACAAQf12akEFSQ0AIABBhwdGDQAgAEHvdGpBLUkNAAJAIABBwXRqIgFBCEsNAEEBIAF0Qe0CcQ0BCyAAQfBzakELSQ0AIABBtXNqQR9JDQACQCAAQapyaiIBQRJLDQBBASABdEH//BlxDQELIABB8AxGDQAgAEGWcmpBBEkNACAAQcBwakEKSQ0AIABB2nBqQQtJDQAgAEHQcWpBG0kNACAAQZEORg0AIABBkHJqQQpJDQAgAEHCbWpBEkkNACAAQcZtakEDSQ0AIABBnW5qQSFJDQAgAEGtbmpBD0kNACAAQadvakEDSQ0AIABB129qQQVJDQAgAEHbb2pBA0kNACAAQeVvakEJSQ0AIABB6m9qQQRJDQAgAEH9D0YNACAAQZVwakEJSQ0AAkAgAEGvbWoiAUESSw0AQQEgAXRB/4AYcQ0BCyAAQZptakEKSQ0AAkACQCAAQcRsaiIBQSdNDQAgAEH/bGpBA0kNAgwBCyABDigBAAEBAQEBAQEAAAEBAAABAQEAAAAAAAAAAAABAAAAAAAAAAAAAAEBAQsgAEH+E0YNACAAQZpsakEKSQ0AAkAgAEHEa2oiAUEVSw0AQQEgAXRB/bCOAXENAQsgAEH/a2pBA0kNACAAQfUURg0AIABBmmtqQQxJDQACQAJAIABBxGpqIgFBJ00NACAAQf9qakEDSQ0CDAELIAEOKAEAAQEBAQEBAQEAAQEBAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBCyAAQZpqakEKSQ0AIABBhmpqQQZJDQACQAJAIABBxGlqIgFBJ00NACAAQf9pakEDSQ0CDAELIAEOKAEAAQEBAQEBAQAAAQEAAAEBAQAAAAAAAAAAAQEAAAAAAAAAAAAAAQEBCyAAQZppakEKSQ0AAkAgAEHCaGoiAUEZSw0AQQEgAXRBn+6DEHENAQsgAEGCF0YNACAAQZpoakEKSQ0AAkACQCAAQcJnaiIBQSVNDQAgAEGAaGpBBUkNAgwBCyABDiYBAQEBAQEBAAEBAQABAQEBAAAAAAAAAAEBAAAAAAAAAAAAAAABAQELIABBmmdqQQpJDQACQAJAIABBxGZqIgFBJ00NACAAQf9makEDSQ0CDAELIAEOKAEAAQEBAQEBAQABAQEAAQEBAQAAAAAAAAABAQAAAAAAAAAAAAAAAQEBCyAAQZpmakEKSQ0AIABBfHEiAkGAGkYNAAJAIABBxWVqIgFBKEsNACABDikBAQABAQEBAQEBAAEBAQABAQEBAAAAAAAAAAAAAQAAAAAAAAAAAAABAQELIABBmmVqQQpJDQACQCAAQbZkaiIBQQxLDQBBASABdEHhL3ENAQsgAEH+ZGpBAkkNACAAQXhxQdgbRg0AIABBmmRqQQpJDQACQCAAQc9jaiIBQR1LDQBBASABdEH5h4D+A3ENAQsgAEGOZGpBAkkNACAAQbEdRg0AIABBsGNqQQpJDQACQCAAQcxiaiIBQQhLDQAgAUEGRw0BCyAAQbhiakEGSQ0AIABB4GFqQQpJDQAgAEEBciIBQZkeRg0AIABBsGJqQQpJDQACQCAAQcthaiIDQQpLDQBBASADdEGVDHENAQsgAEHzYGpBC0kNACABQYcfRg0AIABBj2FqQRRJDQAgAEHuUWpBA0kNACAAQZdZakEJSQ0AIABBo1lqQQNJDQAgAEHxXmpBD0kNACAAQf5eakEMSQ0AIABBj19qQQRJDQAgAEGZX2pBB0kNACAAQZ5fakEDSQ0AIABBol9qQQNJDQAgAEGqX2pBBEkNACAAQcBfakEKSQ0AIABB1V9qQRRJDQAgAEHGH0YNACAAQedgakEkSQ0AIABBzlFqQQNJDQAgAEGuUWpBAkkNACAAQY5RakECSQ0AIABB9U9qQQNJDQAgAEGgUGpBCkkNACAAQd0vRg0AIABBzFBqQSBJDQAgAEGwRmpBA0kNACAAQbBHakEKSQ0AIABBwEdqQQpJDQAgAEHcR2pBFEkNACAAQZpIakEOSQ0AIABB0EhqQQpJDQAgAEHfSGpBDUkNACAAQYBJakEDSQ0AIABBlUlqQQlJDQAgAEGwSWpBCkkNACAAQcxJakERSQ0AIABBgEpqQQVJDQAgAEHQSmpBDkkNACAAQfBKakEKSQ0AIABBgUtqQQtJDQAgAEGgS2pBHUkNACAAQatLakEKSQ0AIABB6UtqQQVJDQAgAEGwTGpBC0kNACAAQbpNakEKSQ0AIABB0E1qQQxJDQAgAEHgTWpBDEkNACAAQakxRg0AIABB8E9qQQpJDQAgAEHARGpBOkkNACAAQYlGakEDSQ0AIABBjkZqQQNJDQAgAEHtOUYNACAAQaxGakEVSQ0AIABBhURqQQVJDQACQCAAQcG/f2oiAUEVSw0AQQEgAXRBg4CAAXENAQsgAEGbvn9qQQxJDQAgAEHhwQBGDQAgAEGwvn9qQQ1JDQAgAEGRpn9qQQNJDQAgAEH/2gBGDQAgAEFgcUHg2wBGDQAgAEHWn39qQQZJDQAgAEHnnn9qQQJJDQAgAEGMs31qQQpJDQAgAEHvzAJGDQAgAEHgs31qQQpJDQACQCAAQfWvfWoiAUEcSw0AQQEgAXRBgYCA+AFxDQELIABB4rJ9akECSQ0AIABBkLJ9akECSQ0AAkACQCAAQf6vfWoiAUEETQ0AIABBgK99akECSQ0CDAELIAEOBQEAAAABAQsgAEHNrH1qQQ5JDQAgAkGA0wJGDQAgAEG5rX1qQQ1JDQAgAEHarX1qQQhJDQAgAEGBrn1qQQtJDQAgAEGgrn1qQRJJDQAgAEHMrn1qQRJJDQAgAEGwrn1qQQpJDQAgAEHXq31qQQ5JDQAgAEHl0wJGDQAgAEFfcUGwrH1qQQpJDQACQCAAQb2rfWoiAUEKSw0AQQEgAXRBgQxxDQELIABBsKt9akEKSQ0AAkAgAEGdqH1qIgFBCksNACABQQhHDQELAkAgAEHQqn1qIgFBEUsNAEEBIAF0QZ2DC3ENAQsCQCAAQZWqfWoiAUELSw0AQQEgAXRBnxhxDQELIABBhat9akEDSQ0AIABBcHEiAUGA/ANGDQAgAEGe9gNGDQAgAEGQqH1qQQpJDQAgAEG//gNGIABB8IF8akEKSSAAQbODfGpBA0kgAEHNg3xqQQJJIAFBoPwDRnJycnIPC0EBC1wBBH9BgIAEIQFBkAghAkF+IQMCQANAQQAhBCADQQJqIgNB5wNLDQEgAigCACABaiIBIABLDQEgAkEEaiEEIAJBCGohAiAEKAIAIAFqIgEgAEkNAAtBASEECyAEC1wBBH9BgIAEIQFBsBchAkF+IQMCQANAQQAhBCADQQJqIgNB+QFLDQEgAigCACABaiIBIABLDQEgAkEEaiEEIAJBCGohAiAEKAIAIAFqIgEgAEkNAAtBASEECyAEC+0fAQZ/QQEhAQJAAkACQCAAQdZ+aiICQRBLDQBBASACdEGBkARxDQELIABBunpqQQxJDQAgAEGIfmpBygNJDQAgAEHAfmpBF0kNACAAQah+akEfSQ0AAkAgAEGQeWoiAkEcSw0AQQEgAnRB3/mCugFxDQELAkAgAEGgemoiAkEOSw0AQQEgAnRBn6ABcQ0BCyAAQfZ2akGmAUkNACAAQYl4akGLAUkNACAAQfJ4akEUSQ0AIABB3XhqQdMASQ0AIABBkXRqQQRJDQAgAEGwdGpBG0kNACAAQaB1akEpSQ0AIABB2QpGDQAgAEHPdWpBJkkNAAJAAkACQCAAQY9zakHjAEkNACAAQQFyIgJB7wxGDQAgAEHgc2pBK0kNAAJAIABBq3JqIgFBPE8NAEKBgIywgJyBgAggAa2IQgGDUEUNAQsgAEHucWpBHkkNACAAQbZwakEhSQ0AIABBsQ9GDQAgAEGzcWpB2QBJDQACQCAAQYxwaiIBQQZLDQBBASABdEHDAHENAQsgAEGAcGpBFkkNAAJAAkAgAEHcb2oiA0EETQ0AIABBmhBGDQIMAQtBASEBIAMOBQQAAAAEBAsgAEH8bWpBNkkNACAAQcpuakEISQ0AIABB4G5qQRVJDQAgAEHAb2pBGUkNACAAQaBvakELSQ0AIABBvRJGDQAgAEHQEkYNACAAQahtakEKSQ0AIABBj21qQRBJDQACQCAAQftsaiIDQQxPDQBBASEBQf8ZIANB//8DcXZBAXENBAsgAEHtbGpBFkkNAAJAIABBhGxqIgFBFEsNAEEBIAF0QYH84QBxDQELIABB1mxqQQdJDQACQCAAQc5saiIBQRxLDQBBASABdEHxkYCAAXENAQsCQCAAQaRsaiIBQRVLDQBBASABdEG7gMABcQ0BCyAAQe1rakEWSQ0AAkAgAEHWa2oiAUE1Tw0AQv+2g4CAgOALIAGtiEIBg1BFDQELIABB7WpqQRZJDQAgAEHxampBA0kNACAAQY5rakEDSQ0AIABB+2pqQQlJDQACQAJAAkAgAEHWamoiA0EmTQ0AIABBh2pqIgFBF0sNAUEBIAF0QYHgvwZxRQ0BDAMLQQEhASADDicFBQUFBQUFAQUFAQUFBQUFAQEBBQEBAQEBAQEBAQEBAQEBAQEBAQUFCyAAQaBqakECSQ0BCyAAQe1pakEWSQ0AAkACQAJAIABBj2lqIgNBM00NACAAQdZpaiIBQRNLDQFBASABdEH/9iNxRQ0BDAMLQQEhASADDjQFAQEBAQEBAQEBAQEBAQEBAQEFAQUFBQUFBQEBAQUFBQEFBQUFAQEBBQUBBQEFBQEBAQUFBQsgAEGkaWoiAUEFSw0AIAFBAkcNAQsgAEHYaGpBA0kNACAAQe5nakEXSQ0AIABB8mdqQQNJDQAgAEH7Z2pBCEkNACAAQdAXRg0AIABB0mhqQQxJDQAgAEG9GEYNACAAQdZnakEQSQ0AAkAgAEGoZ2oiAUEpTw0AQoeGgICAICABrYhCAYNQRQ0BCyAAQdZmakEKSQ0AIABB7mZqQRdJDQAgAEH7ZmpBCEkNACAAQfJmakEDSQ0AAkAgAEH7ZWoiAUELSw0AIAFBCEcNAQsCQCAAQctmaiIBQQhLDQBBASABdEGfAnENAQsCQCAAQaJmaiIBQRRLDQBBASABdEGNgOAAcQ0BCyAAQe5lakEpSQ0AIABBvRpGDQAgAEHOGkYNACAAQc1kakEJSQ0AIABB5mRqQRhJDQAgAEH7ZGpBEkkNACAAQYZlakEGSQ0AIABBrGVqQQNJDQAgAEGhZWpBA0kNAAJAIABBw2RqIgNBCk8NAEEBIQFB+QcgA0H//wNxdkEBcQ0ECyACQbMcRg0AIABB/2NqQTBJDQAgAEHAY2pBB0kNAAJAIABB/2JqIgFBDEsNAEEBIAF0QcslcQ0BCyAAQXxxIgNBlB1GDQAgAEHnYmpBB0kNAAJAIABB32JqIgFBJk8NAELX7JuA+QUgAa2IQgGDUEUNAQsgAEGAYGpBK0kNACAAQfhgakEFSQ0AIABBt2FqQSRJDQAgAEF4cSIEQcAeRg0AIABBgB5GDQAgA0HcHUYNAAJAIABBwV9qIgFBKE8NAEKBgPjDxxggAa2IQgGDUEUNAQsgAEGSX2pBA0kNACAAQeBeakEmSQ0AIABBjiFGDQAgAEGLX2pBDUkNACAAQcchRg0AIABBzSFGDQAgAEG2W2pBBEkNACAAQbBeakErSQ0AIABBhF5qQc0CSQ0AAkAgAEGwW2oiBUEJTw0AQQEhAUH/AiAFQf//A3F2QQFxDQQLIABBzlpqQQRJDQAgAEHwWmpBIUkNACAAQfZaakEESQ0AIABBpltqQQRJDQAgAEGgW2pBKUkNAAJAIABByFpqIgVBCU8NAEEBIQFB/wIgBUH//wNxdkEBcQ0ECyAAQYBRakE0SQ0AIABBklFqQQNJDQAgAEGgUWpBDUkNACAAQcBRakESSQ0AIABB4FFqQRJJDQAgAEHyUWpBBEkNACAAQYBSakENSQ0AIABBklJqQQtJDQAgAEHgUmpBywBJDQAgAEH/UmpBGkkNACAAQZFTakERSQ0AIABB/1dqQewESQ0AIABBiFhqQQZJDQAgAEHgWGpB1gBJDQAgAEFwcSIFQYAnRg0AIABB6FlqQcMASQ0AIABB7llqQQRJDQAgAEGoWmpBOUkNACAAQb5aakEESQ0AIABBuFpqQQ9JDQAgAEHXL0YNACAAQdwvRg0AIABB4E9qQdkASQ0AIABBgExqQRdJDQAgAEHQTGpBGkkNACAAQYBNakEsSQ0AIABBkE1qQQVJDQAgAEGwTWpBHkkNACAAQYBOakEfSQ0AIABB0E5qQcYASQ0AIABBqjFGDQQgAEGAT2pBKUkNBCAAQbtJakEHSQ0EIABB+0lqQS9JDQQgAEGnNUYNBCAAQeBLakE1SQ0EIABBl0ZqQQRJDQQgAEHDRmpBA0kNBCAAQfBGakErSQ0EIABBgEdqQQlJDQQgAEGmR2pBJEkNBCAAQbNHakEDSQ0EIABBgEhqQSRJDQQgAEHGSGpBLEkNBCACQa83Rg0EIABB/UhqQR5JDQQgAEGSRmoiBkEJSQ0BDAILQQEhAQwCC0EBIQFBjwMgBkH//wNxdkEBcQ0BCyAEQdA+Rg0BIABBuEFqQQZJDQEgAEHgQWpBJkkNASAAQehBakEGSQ0BIABBgEZqQcABSQ0BIABBgERqQZYCSQ0BAkAgAEGnQWoiAUEESw0AQQEgAXRBFXENAgsgAEGhQWpBH0kNASAAQYBBakE1SQ0BAkAgAEHKQGoiBEEJTw0AQQEhAUH/AiAEQf//A3F2QQFxDQELIABBjkBqQQNJDQEgAEGgQGpBDUkNASAAQapAakEGSQ0BIANB0D9GDQEgAEG+QGpBA0kNASAAQbpAakEHSQ0BIABBikBqQQdJDQEgAEHxwABGDQEgAEH/wABGDQEgAEHwvn9qQQ1JDQEgAEGCwgBGDQEgAEGHwgBGDQEgAEGVwgBGDQEgAEH2vX9qQQpJDQECQCAAQei9f2oiBEERTw0AQQEhAUG/oAUgBHZBAXENAQsgAEHWvX9qQRBJDQEgA0G8wgBGDQECQCAAQbu9f2oiBEEKTw0AQQEhAUGfBCAEQf//A3F2QQFxDQELIABBoKd/akGFAUkNASAAQdCnf2pBL0kNASAAQaC9f2pBKUkNASAAQYCof2pBL0kNAQJAIABBlaZ/aiIEQQlPDQBBASEBQY8DIARB//8DcXZBAXENAQsgAEGApn9qQSZJDQEgAEGn2gBGDQEgAEGt2gBGDQEgAEGAtn1qQY0CSQ0BIABBsLZ9akEuSQ0BIABBgMB9akGNCUkNASAAQYDkfmpB8KMBSQ0BIABBgJh/akG2M0kNASAFQfDjAEYNASAAQeCcf2pBG0kNASAAQc+df2pB3gBJDQEgAEH7nX9qQStJDQEgA0H84QBGDQEgAEHfnn9qQdoASQ0BIABB5Z5/akEFSQ0BIABBv59/akHWAEkNASAAQciff2pBBUkNASAAQc+ff2pBBUkNASAAQd+ff2pBCUkNASAAQfuff2pBA0kNASAAQaikf2pBB0kNASAAQbCkf2pBB0kNASAAQbikf2pBB0kNASAAQcCkf2pBB0kNASAAQcikf2pBB0kNASAAQdCkf2pBB0kNASAAQdikf2pBB0kNASAAQeCkf2pBB0kNASAAQYClf2pBF0kNASAAQe/aAEYNASAAQdClf2pBOEkNASAAQf6ufWpBMkkNASAAQcCvfWpBNEkNASAAQfSvfWpBF0kNASAAQfmvfWpBBEkNASAAQf2vfWpBA0kNASAAQYmwfWpBC0kNASAAQfWwfWpBL0kNASAAQd6xfWpB5wBJDQEgAEHpsX1qQQlJDQEgAEHgsn1qQdAASQ0BIABBgbN9akEfSQ0BIABBwLN9akEvSQ0BIAJBq8wCRg0BIAVBkMwCRg0BAkAgAEGOrn1qIgJBDU8NAEEBIQFBvzQgAkH//wNxdkEBcQ0BCyAAQaCtfWpBHUkNASAAQfatfWpBHEkNASAAQdCtfWpBF0kNASAAQbyrfWpBCEkNASAAQcCrfWpBA0kNASAAQYCsfWpBKUkNASAAQYasfWpBBUkNASAAQZqsfWpBCkkNASAAQaCsfWpBBUkNASAAQc/TAkYNASAAQfysfWpBL0kNASAAQYKrfWpBMkkNASAAQfrUAkYNASAAQaCrfWpBF0kNAQJAIABBz6p9aiICQRJPDQBBASEBQbG+CiACdkEBcQ0BCyAAQYCKfGpBB0kNASAAQZCLfGpB6gBJDQEgAEGAjnxqQe4CSQ0BIABBtdB8akExSQ0BIABB0NB8akEXSQ0BIABBgKh9akGk1wBJDQEgAEGQqX1qQfMASQ0BIABBpKl9akEKSQ0BIABB0Kl9akErSQ0BIABB2Kl9akEHSQ0BIABB4Kl9akEHSQ0BIABB76l9akEGSQ0BIABBd3FB/6l9akEGSQ0BIABBjqp9akEDSQ0BIABBpap9akEDSQ0BIABBoKp9akELSQ0BAkAgAEHtiXxqIgJBC08NAEEBIQFBnwggAkH//wNxdkEBcQ0BCyAAQeGJfGpBCkkNASAAQdaJfGpBDUkNAQJAIABByIl8aiICQQ1PDQBBASEBQd82IAJB//8DcXZBAXENAQsgAEGugHxqQQZJDQEgAEG2gHxqQQZJDQEgAEG+gHxqQQZJDQEgAEGagXxqQdkASQ0BIABBv4F8akEaSQ0BIABB34F8akEaSQ0BIABBioN8akGHAUkNASAAQZCDfGpBBUkNASAAQZCEfGpBDEkNASAAQe6EfGpBNkkNASAAQbCFfGpBwABJDQEgAEG6iXxqQewASQ0BQQEhASAAQa2IfGpB6wJJDQAgAEGmgHxqQQNJDwsgAQ8LQQELXQEBf0EAIQkCQCAALwEAIAFHDQAgAC8BAiACRw0AIAAvAQQgA0cNACAALwEGIARHDQAgAC8BCCAFRw0AIAAvAQogBkcNACAALwEMIAdHDQAgAC8BDiAIRiEJCyAJCzUAAkAgAEGA+ANxQYCwA0cNACAAQQp0QYD4P3FBACgCvKABLwECQf8HcXJBgIAEaiEACyAAC2gBAn9BASEBAkACQCAAQV9qIgJBBUsNAEEBIAJ0QTFxDQELIABB+P8DcUEoRg0AIABBRmpB//8DcUEGSQ0AAkAgAEGlf2oiAkEDSw0AIAJBAUcNAQsgAEGFf2pB//8DcUEESSEBCyABC40BAQV/QQAoArygASEAQQAoAsCgASEBA38gAEECaiECAkACQCAAIAFPDQAgAi8BACIDQaR/aiIEQQFNDQEgAiEAIANBdmoiA0EDSw0CIAIhACADDgQAAgIAAAtBACACNgK8oAEQHUEADwsCQAJAIAQOAgEAAQtBACACNgK8oAFB3QAPCyAAQQRqIQAMAAsLSQEDf0EAIQMCQCACRQ0AAkADQCAALQAAIgQgAS0AACIFRw0BIAFBAWohASAAQQFqIQAgAkF/aiICDQAMAgsLIAQgBWshAwsgAwsLwhcCAEGACAuYFwAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAIAAAAZAAAAAgAAABIAAAACAAAAAQAAAAIAAAAOAAAAAwAAAA0AAAAjAAAAegAAAEYAAAA0AAAADAEAABwAAAAEAAAAMAAAADAAAAAfAAAADgAAAB0AAAAGAAAAJQAAAAsAAAAdAAAAAwAAACMAAAAFAAAABwAAAAIAAAAEAAAAKwAAAJ0AAAATAAAAIwAAAAUAAAAjAAAABQAAACcAAAAJAAAAMwAAAJ0AAAA2AQAACgAAABUAAAALAAAABwAAAJkAAAAFAAAAAwAAAAAAAAACAAAAKwAAAAIAAAABAAAABAAAAAAAAAADAAAAFgAAAAsAAAAWAAAACgAAAB4AAABCAAAAEgAAAAIAAAABAAAACwAAABUAAAALAAAAGQAAAEcAAAA3AAAABwAAAAEAAABBAAAAAAAAABAAAAADAAAAAgAAAAIAAAACAAAAHAAAACsAAAAcAAAABAAAABwAAAAkAAAABwAAAAIAAAAbAAAAHAAAADUAAAALAAAAFQAAAAsAAAASAAAADgAAABEAAABvAAAASAAAADgAAAAyAAAADgAAADIAAAAOAAAAIwAAAF0BAAApAAAABwAAAAEAAABPAAAAHAAAAAsAAAAAAAAACQAAABUAAABrAAAAFAAAABwAAAAWAAAADQAAADQAAABMAAAALAAAACEAAAAYAAAAGwAAACMAAAAeAAAAAAAAAAMAAAAAAAAACQAAACIAAAAEAAAAAAAAAA0AAAAvAAAADwAAAAMAAAAWAAAAAAAAAAIAAAAAAAAAJAAAABEAAAACAAAAGAAAAFUAAAAGAAAAAgAAAAAAAAACAAAAAwAAAAIAAAAOAAAAAgAAAAkAAAAIAAAALgAAACcAAAAHAAAAAwAAAAEAAAADAAAAFQAAAAIAAAAGAAAAAgAAAAEAAAACAAAABAAAAAQAAAAAAAAAEwAAAAAAAAANAAAABAAAAJ8AAAA0AAAAEwAAAAMAAAAVAAAAAgAAAB8AAAAvAAAAFQAAAAEAAAACAAAAAAAAALkAAAAuAAAAKgAAAAMAAAAlAAAALwAAABUAAAAAAAAAPAAAACoAAAAOAAAAAAAAAEgAAAAaAAAA5gAAACsAAAB1AAAAPwAAACAAAAAHAAAAAwAAAAAAAAADAAAABwAAAAIAAAABAAAAAgAAABcAAAAQAAAAAAAAAAIAAAAAAAAAXwAAAAcAAAADAAAAJgAAABEAAAAAAAAAAgAAAAAAAAAdAAAAAAAAAAsAAAAnAAAACAAAAAAAAAAWAAAAAAAAAAwAAAAtAAAAFAAAAAAAAAAjAAAAOAAAAAgBAAAIAAAAAgAAACQAAAASAAAAAAAAADIAAAAdAAAAcQAAAAYAAAACAAAAAQAAAAIAAAAlAAAAFgAAAAAAAAAaAAAABQAAAAIAAAABAAAAAgAAAB8AAAAPAAAAAAAAAEgBAAASAAAAvgAAAAAAAABQAAAAmQMAAGcAAABuAAAAEgAAAMMAAAC9CgAALgQAANIPAABGAgAAuiEAADgCAAAIAAAAHgAAAHIAAAAdAAAAEwAAAC8AAAARAAAAAwAAACAAAAAUAAAABgAAABIAAACxAgAAPwAAAIEAAABKAAAABgAAAAAAAABDAAAADAAAAEEAAAABAAAAAgAAAAAAAAAdAAAA9xcAAAkAAADVBAAAKwAAAAgAAAD4IgAAHgEAADIAAAACAAAAEgAAAAMAAAAJAAAAiwEAAAUJAABqAAAABgAAAAwAAAAEAAAACAAAAAgAAAAJAAAAZxcAAFQAAAACAAAARgAAAAIAAAABAAAAAwAAAAAAAAADAAAAAQAAAAMAAAADAAAAAgAAAAsAAAACAAAAAAAAAAIAAAAGAAAAAgAAAEAAAAACAAAAAwAAAAMAAAAHAAAAAgAAAAYAAAACAAAAGwAAAAIAAAADAAAAAgAAAAQAAAACAAAAAAAAAAQAAAAGAAAAAgAAAFMBAAADAAAAGAAAAAIAAAAYAAAAAgAAAB4AAAACAAAAGAAAAAIAAAAeAAAAAgAAABgAAAACAAAAHgAAAAIAAAAYAAAAAgAAAB4AAAACAAAAGAAAAAIAAAAHAAAANQkAACwAAAALAAAABgAAABEAAAAAAAAAcgEAACsAAAAVBQAAxAAAADwAAABDAAAACAAAAAAAAAC1BAAAAwAAAAIAAAAaAAAAAgAAAAEAAAACAAAAAAAAAAMAAAAAAAAAAgAAAAkAAAACAAAAAwAAAAIAAAAAAAAAAgAAAAAAAAAHAAAAAAAAAAUAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAIAAAACAAAAAgAAAAEAAAACAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAQAAAAIAAAAAAAAAAwAAAAMAAAACAAAABgAAAAIAAAADAAAAAgAAAAMAAAACAAAAAAAAAAIAAAAJAAAAAgAAABAAAAAGAAAAAgAAAAIAAAAEAAAAAgAAABAAAABFEQAA3aYAACMAAAA0EAAADAAAAN0AAAADAAAAgRYAAA8AAAAwHQAAIAwAAB0CAADjBQAAShMAAP0BAAAAAAAA4wAAAAAAAACWAAAABAAAACYBAAAJAAAAWAUAAAIAAAACAAAAAQAAAAYAAAADAAAAKQAAAAIAAAAFAAAAAAAAAKYAAAABAAAAPgIAAAMAAAAJAAAACQAAAHIBAAABAAAAmgAAAAoAAACwAAAAAgAAADYAAAAOAAAAIAAAAAkAAAAQAAAAAwAAAC4AAAAKAAAANgAAAAkAAAAHAAAAAgAAACUAAAANAAAAAgAAAAkAAAAGAAAAAQAAAC0AAAAAAAAADQAAAAIAAAAxAAAADQAAAAkAAAADAAAAAgAAAAsAAABTAAAACwAAAAcAAAAAAAAAoQAAAAsAAAAGAAAACQAAAAcAAAADAAAAOAAAAAEAAAACAAAABgAAAAMAAAABAAAAAwAAAAIAAAAKAAAAAAAAAAsAAAABAAAAAwAAAAYAAAAEAAAABAAAAMEAAAARAAAACgAAAAkAAAAFAAAAAAAAAFIAAAATAAAADQAAAAkAAADWAAAABgAAAAMAAAAIAAAAHAAAAAEAAABTAAAAEAAAABAAAAAJAAAAUgAAAAwAAAAJAAAACQAAAFQAAAAOAAAABQAAAAkAAADzAAAADgAAAKYAAAAJAAAARwAAAAUAAAACAAAAAQAAAAMAAAADAAAAAgAAAAAAAAACAAAAAQAAAA0AAAAJAAAAeAAAAAYAAAADAAAABgAAAAQAAAAAAAAAHQAAAAkAAAApAAAABgAAAAIAAAADAAAACQAAAAAAAAAKAAAACgAAAC8AAAAPAAAAlgEAAAcAAAACAAAABwAAABEAAAAJAAAAOQAAABUAAAACAAAADQAAAHsAAAAFAAAABAAAAAAAAAACAAAAAQAAAAIAAAAGAAAAAgAAAAAAAAAJAAAACQAAADEAAAAEAAAAAgAAAAEAAAACAAAABAAAAAkAAAAJAAAASgEAAAMAAABqSwAACQAAAIcAAAAEAAAAPAAAAAYAAAAaAAAACQAAAPYDAAAAAAAAAgAAADYAAAAIAAAAAwAAAFIAAAAAAAAADAAAAAEAAACsTAAAAQAAAMcUAAAEAAAABAAAAAUAAAAJAAAABwAAAAMAAAAGAAAAHwAAAAMAAACVAAAAAgAAAIoFAAAxAAAAAQIAADYAAAAFAAAAMQAAAAkAAAAAAAAADwAAAAAAAAAXAAAABAAAAAIAAAAOAAAAUQUAAAYAAAACAAAAEAAAAAMAAAAGAAAAAgAAAAEAAAACAAAABAAAAAYBAAAGAAAACgAAAAkAAACjAQAADQAAANcFAAAGAAAAbgAAAAYAAAAGAAAACQAAAJcSAAAJAAAABwUMAO8AAAAAQZgfCxxQjAAAAQAAAAIAAAADAAAABAAAAAAEAADwHwAA","undefined"!=typeof window&&"function"==typeof atob?Uint8Array.from(atob(B),A=>A.charCodeAt(0)):Buffer.from(B,"base64")));var B;const{exports:E}=await WebAssembly.instantiate(Q);A=E})())}
\ No newline at end of file
+/* cjs-module-lexer 1.2.2 */
+let A;const Q=1===new Uint8Array(new Uint16Array([1]).buffer)[0];export function parse(g,I="@"){if(!A)throw new Error("Not initialized");const D=g.length+1,N=(A.__heap_base.value||A.__heap_base)+4*D-A.memory.buffer.byteLength;N>0&&A.memory.grow(Math.ceil(N/65536));const k=A.sa(D);if((Q?C:E)(g,new Uint16Array(A.memory.buffer,k,D)),!A.parseCJS(k,g.length,0,0,0))throw Object.assign(new Error(`Parse error ${I}${A.e()}:${g.slice(0,A.e()).split("\n").length}:${A.e()-g.lastIndexOf("\n",A.e()-1)}`),{idx:A.e()});let w=new Set,o=new Set,J=new Set;for(;A.rre();){const Q=B(g.slice(A.res(),A.ree()));Q&&o.add(Q)}for(;A.ru();)J.add(B(g.slice(A.us(),A.ue())));for(;A.re();){let Q=B(g.slice(A.es(),A.ee()));void 0===Q||J.has(Q)||w.add(Q)}return{exports:[...w],reexports:[...o]}}function B(A){if('"'!==A[0]&&"'"!==A[0])return A;try{const Q=(0,eval)(A);for(let A=0;A<Q.length;A++){const B=64512&Q.charCodeAt(A);if(!(B<55296)){if(55296!==B)return;if(56320!=(64512&Q.charCodeAt(++A)))return}}return Q}catch{}}function E(A,Q){const B=A.length;let E=0;for(;E<B;){const B=A.charCodeAt(E);Q[E++]=(255&B)<<8|B>>>8}}function C(A,Q){const B=A.length;let E=0;for(;E<B;)Q[E]=A.charCodeAt(E++)}let g;export function init(){return g||(g=(async()=>{const Q=await WebAssembly.compile((B="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","undefined"!=typeof window&&"function"==typeof atob?Uint8Array.from(atob(B),A=>A.charCodeAt(0)):Buffer.from(B,"base64")));var B;const{exports:E}=await WebAssembly.instantiate(Q);A=E})())}
\ No newline at end of file
diff --git a/deps/cjs-module-lexer/lexer.js b/deps/cjs-module-lexer/lexer.js
index b66e37204b41d63be625972e0abc625fdfa37e20..1bf3123c172c3981380c763eb4610fa1d43d8a13 100755
--- a/deps/cjs-module-lexer/lexer.js
+++ b/deps/cjs-module-lexer/lexer.js
@@ -651,8 +651,10 @@ function tryParseObjectDefineOrKeys (keys) {
             if (ch !== 33/*!*/) break;
             pos += 1;
             ch = commentWhitespace();
-            if (source.startsWith(id, pos)) {
-              pos += id.length;
+            if (ch === 79/*O*/ && source.startsWith('bject', pos + 1) && source[pos + 6] === '.') {
+              if (!tryParseObjectHasOwnProperty(it_id)) break;
+            }
+            else if (identifier()) {
               ch = commentWhitespace();
               if (ch !== 46/*.*/) break;
               pos++;
@@ -669,7 +671,7 @@ function tryParseObjectDefineOrKeys (keys) {
               if (ch !== 41/*)*/) break;
               pos += 1;
             }
-            else if (!tryParseObjectHasOwnProperty(it_id)) break;
+            else break;
             ch = commentWhitespace();
           }
           if (ch !== 41/*)*/) break;
diff --git a/deps/cjs-module-lexer/package.json b/deps/cjs-module-lexer/package.json
index e550ac682ee9bbba6744381bc3df3ea2082538a1..13d13ca93c8d7d648b94e32dc607c0cdb1cacea1 100755
--- a/deps/cjs-module-lexer/package.json
+++ b/deps/cjs-module-lexer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cjs-module-lexer",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Lexes CommonJS modules, returning their named exports metadata",
   "main": "lexer.js",
   "exports": {
diff --git a/deps/histogram/src/hdr_atomic.h b/deps/histogram/src/hdr_atomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae1056a83612af5e370ce12fea82f334fce0c62c
--- /dev/null
+++ b/deps/histogram/src/hdr_atomic.h
@@ -0,0 +1,146 @@
+/**
+ * hdr_atomic.h
+ * Written by Philip Orwig and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+#ifndef HDR_ATOMIC_H__
+#define HDR_ATOMIC_H__
+
+
+#if defined(_MSC_VER)
+
+#include <stdint.h>
+#include <intrin.h>
+#include <stdbool.h>
+
+static void __inline * hdr_atomic_load_pointer(void** pointer)
+{
+	_ReadBarrier();
+	return *pointer;
+}
+
+static void hdr_atomic_store_pointer(void** pointer, void* value)
+{
+	_WriteBarrier();
+	*pointer = value;
+}
+
+static int64_t __inline hdr_atomic_load_64(int64_t* field)
+{ 
+	_ReadBarrier();
+	return *field;
+}
+
+static void __inline hdr_atomic_store_64(int64_t* field, int64_t value)
+{
+	_WriteBarrier();
+	*field = value;
+}
+
+static int64_t __inline hdr_atomic_exchange_64(volatile int64_t* field, int64_t value)
+{
+#if defined(_WIN64)
+    return _InterlockedExchange64(field, value);
+#else
+    int64_t comparand;
+    int64_t initial_value = *field;
+    do
+    {
+        comparand = initial_value;
+        initial_value = _InterlockedCompareExchange64(field, value, comparand);
+    }
+    while (comparand != initial_value);
+
+    return initial_value;
+#endif
+}
+
+static int64_t __inline hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t value)
+{
+#if defined(_WIN64)
+	return _InterlockedExchangeAdd64(field, value) + value;
+#else
+    int64_t comparand;
+    int64_t initial_value = *field;
+    do
+    {
+        comparand = initial_value;
+        initial_value = _InterlockedCompareExchange64(field, comparand + value, comparand);
+    }
+    while (comparand != initial_value);
+
+    return initial_value + value;
+#endif
+}
+
+static bool __inline hdr_atomic_compare_exchange_64(volatile int64_t* field, int64_t* expected, int64_t desired)
+{
+    return *expected == _InterlockedCompareExchange64(field, desired, *expected);
+}
+
+#elif defined(__ATOMIC_SEQ_CST)
+
+#define hdr_atomic_load_pointer(x) __atomic_load_n(x, __ATOMIC_SEQ_CST)
+#define hdr_atomic_store_pointer(f,v) __atomic_store_n(f,v, __ATOMIC_SEQ_CST)
+#define hdr_atomic_load_64(x) __atomic_load_n(x, __ATOMIC_SEQ_CST)
+#define hdr_atomic_store_64(f,v) __atomic_store_n(f,v, __ATOMIC_SEQ_CST)
+#define hdr_atomic_exchange_64(f,i) __atomic_exchange_n(f,i, __ATOMIC_SEQ_CST)
+#define hdr_atomic_add_fetch_64(field, value) __atomic_add_fetch(field, value, __ATOMIC_SEQ_CST)
+#define hdr_atomic_compare_exchange_64(field, expected, desired) __atomic_compare_exchange_n(field, expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
+
+#elif defined(__x86_64__)
+
+#include <stdint.h>
+#include <stdbool.h>
+
+static inline void* hdr_atomic_load_pointer(void** pointer)
+{
+   void* p =  *pointer;
+	asm volatile ("" ::: "memory");
+	return p;
+}
+
+static inline void hdr_atomic_store_pointer(void** pointer, void* value)
+{
+    asm volatile ("lock; xchgq %0, %1" : "+q" (value), "+m" (*pointer));
+}
+
+static inline int64_t hdr_atomic_load_64(int64_t* field)
+{
+    int64_t i = *field;
+	asm volatile ("" ::: "memory");
+	return i;
+}
+
+static inline void hdr_atomic_store_64(int64_t* field, int64_t value)
+{
+    asm volatile ("lock; xchgq %0, %1" : "+q" (value), "+m" (*field));
+}
+
+static inline int64_t hdr_atomic_exchange_64(volatile int64_t* field, int64_t value)
+{
+    int64_t result = 0;
+    asm volatile ("lock; xchgq %1, %2" : "=r" (result), "+q" (value), "+m" (*field));
+    return result;
+}
+
+static inline int64_t hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t value)
+{
+    return __sync_add_and_fetch(field, value);
+}
+
+static inline bool hdr_atomic_compare_exchange_64(volatile int64_t* field, int64_t* expected, int64_t desired)
+{
+    int64_t original;
+    asm volatile( "lock; cmpxchgq %2, %1" : "=a"(original), "+m"(*field) : "q"(desired), "0"(*expected));
+    return original == *expected;
+}
+
+#else
+
+#error "Unable to determine atomic operations for your platform"
+
+#endif
+
+#endif /* HDR_ATOMIC_H__ */
diff --git a/deps/histogram/src/hdr_histogram.c b/deps/histogram/src/hdr_histogram.c
index d9565b802e35642ecc77f5a656c5239f7cc59756..4bcfbeb049bf59ef6e9cec1ce9580dd3cb8a6610 100644
--- a/deps/histogram/src/hdr_histogram.c
+++ b/deps/histogram/src/hdr_histogram.c
@@ -7,7 +7,6 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include <math.h>
-#include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
@@ -16,6 +15,7 @@
 
 #include "hdr_histogram.h"
 #include "hdr_tests.h"
+#include "hdr_atomic.h"
 
 /*  ######   #######  ##     ## ##    ## ########  ######  */
 /* ##    ## ##     ## ##     ## ###   ##    ##    ##    ## */
@@ -66,12 +66,49 @@ static void counts_inc_normalised(
     h->total_count += value;
 }
 
+static void counts_inc_normalised_atomic(
+    struct hdr_histogram* h, int32_t index, int64_t value)
+{
+    int32_t normalised_index = normalize_index(h, index);
+
+    hdr_atomic_add_fetch_64(&h->counts[normalised_index], value);
+    hdr_atomic_add_fetch_64(&h->total_count, value);
+}
+
 static void update_min_max(struct hdr_histogram* h, int64_t value)
 {
     h->min_value = (value < h->min_value && value != 0) ? value : h->min_value;
     h->max_value = (value > h->max_value) ? value : h->max_value;
 }
 
+static void update_min_max_atomic(struct hdr_histogram* h, int64_t value)
+{
+    int64_t current_min_value;
+    int64_t current_max_value;
+    do
+    {
+        current_min_value = hdr_atomic_load_64(&h->min_value);
+
+        if (0 == value || current_min_value <= value)
+        {
+            break;
+        }
+    }
+    while (!hdr_atomic_compare_exchange_64(&h->min_value, &current_min_value, value));
+
+    do
+    {
+        current_max_value = hdr_atomic_load_64(&h->max_value);
+
+        if (value <= current_max_value)
+        {
+            break;
+        }
+    }
+    while (!hdr_atomic_compare_exchange_64(&h->max_value, &current_max_value, value));
+}
+
+
 /* ##     ## ######## #### ##       #### ######## ##    ## */
 /* ##     ##    ##     ##  ##        ##     ##     ##  ##  */
 /* ##     ##    ##     ##  ##        ##     ##      ####   */
@@ -91,33 +128,40 @@ static int64_t power(int64_t base, int64_t exp)
 }
 
 #if defined(_MSC_VER)
-#  if defined(_WIN64)
-#    pragma intrinsic(_BitScanReverse64)
-#  else
-#    pragma intrinsic(_BitScanReverse)
-#  endif
+#   if defined(_WIN64)
+#       pragma intrinsic(_BitScanReverse64)
+#   else
+#       pragma intrinsic(_BitScanReverse)
+#   endif
 #endif
 
-static int32_t get_bucket_index(const struct hdr_histogram* h, int64_t value)
+static int32_t count_leading_zeros_64(int64_t value)
 {
 #if defined(_MSC_VER)
     uint32_t leading_zero = 0;
-    int64_t masked_value = value | h->sub_bucket_mask;
-#  if defined(_WIN64)
-    _BitScanReverse64(&leading_zero, masked_value);
-#  else
-    uint32_t high = masked_value >> 32;
-    if  (_BitScanReverse(&leading_zero, high)) {
-      leading_zero += 32;
-    } else {
-      uint32_t low = masked_value & 0x00000000FFFFFFFF;
-      _BitScanReverse(&leading_zero, low);
+#if defined(_WIN64)
+    _BitScanReverse64(&leading_zero, value);
+#else
+    uint32_t high = value >> 32;
+    if  (_BitScanReverse(&leading_zero, high))
+    {
+        leading_zero += 32;
+    }
+    else
+    {
+        uint32_t low = value & 0x00000000FFFFFFFF;
+        _BitScanReverse(&leading_zero, low);
     }
-#  endif
-    int32_t pow2ceiling = 64 - (63 - leading_zero); /* smallest power of 2 containing value */
+#endif
+    return 63 - leading_zero; /* smallest power of 2 containing value */
 #else
-    int32_t pow2ceiling = 64 - __builtin_clzll(value | h->sub_bucket_mask); /* smallest power of 2 containing value */
+    return __builtin_clzll(value); /* smallest power of 2 containing value */
 #endif
+}
+
+static int32_t get_bucket_index(const struct hdr_histogram* h, int64_t value)
+{
+    int32_t pow2ceiling = 64 - count_leading_zeros_64(value | h->sub_bucket_mask); /* smallest power of 2 containing value */
     return pow2ceiling - h->unit_magnitude - (h->sub_bucket_half_count_magnitude + 1);
 }
 
@@ -283,11 +327,8 @@ int hdr_calculate_bucket_config(
     int64_t largest_value_with_single_unit_resolution;
 
     if (lowest_trackable_value < 1 ||
-            significant_figures < 1 || 5 < significant_figures)
-    {
-        return EINVAL;
-    }
-    else if (lowest_trackable_value * 2 > highest_trackable_value)
+            significant_figures < 1 || 5 < significant_figures ||
+            lowest_trackable_value * 2 > highest_trackable_value)
     {
         return EINVAL;
     }
@@ -300,8 +341,13 @@ int hdr_calculate_bucket_config(
     sub_bucket_count_magnitude = (int32_t) ceil(log((double)largest_value_with_single_unit_resolution) / log(2));
     cfg->sub_bucket_half_count_magnitude = ((sub_bucket_count_magnitude > 1) ? sub_bucket_count_magnitude : 1) - 1;
 
-    cfg->unit_magnitude = (int32_t) floor(log((double)lowest_trackable_value) / log(2));
+    double unit_magnitude = log((double)lowest_trackable_value) / log(2);
+    if (INT32_MAX < unit_magnitude)
+    {
+        return EINVAL;
+    }
 
+    cfg->unit_magnitude = (int32_t) unit_magnitude;
     cfg->sub_bucket_count      = (int32_t) pow(2, (cfg->sub_bucket_half_count_magnitude + 1));
     cfg->sub_bucket_half_count = cfg->sub_bucket_count / 2;
     cfg->sub_bucket_mask       = ((int64_t) cfg->sub_bucket_count - 1) << cfg->unit_magnitude;
@@ -352,11 +398,16 @@ int hdr_init(
         return r;
     }
 
-    counts = calloc((size_t) cfg.counts_len, sizeof(int64_t));
-    histogram = calloc(1, sizeof(struct hdr_histogram));
+    counts = (int64_t*) calloc((size_t) cfg.counts_len, sizeof(int64_t));
+    if (!counts)
+    {
+        return ENOMEM;
+    }
 
-    if (!counts || !histogram)
+    histogram = (struct hdr_histogram*) calloc(1, sizeof(struct hdr_histogram));
+    if (!histogram)
     {
+        free(counts);
         return ENOMEM;
     }
 
@@ -370,8 +421,10 @@ int hdr_init(
 
 void hdr_close(struct hdr_histogram* h)
 {
-    free(h->counts);
-    free(h);
+    if (h) {
+	free(h->counts);
+	free(h);
+    }
 }
 
 int hdr_alloc(int64_t highest_trackable_value, int significant_figures, struct hdr_histogram** result)
@@ -407,6 +460,11 @@ bool hdr_record_value(struct hdr_histogram* h, int64_t value)
     return hdr_record_values(h, value, 1);
 }
 
+bool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value)
+{
+    return hdr_record_values_atomic(h, value, 1);
+}
+
 bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count)
 {
     int32_t counts_index;
@@ -429,11 +487,37 @@ bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count)
     return true;
 }
 
+bool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count)
+{
+    int32_t counts_index;
+
+    if (value < 0)
+    {
+        return false;
+    }
+
+    counts_index = counts_index_for(h, value);
+
+    if (counts_index < 0 || h->counts_len <= counts_index)
+    {
+        return false;
+    }
+
+    counts_inc_normalised_atomic(h, counts_index, count);
+    update_min_max_atomic(h, value);
+
+    return true;
+}
+
 bool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, int64_t expected_interval)
 {
     return hdr_record_corrected_values(h, value, 1, expected_interval);
 }
 
+bool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t value, int64_t expected_interval)
+{
+    return hdr_record_corrected_values_atomic(h, value, 1, expected_interval);
+}
 
 bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval)
 {
@@ -461,6 +545,32 @@ bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t
     return true;
 }
 
+bool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval)
+{
+    int64_t missing_value;
+
+    if (!hdr_record_values_atomic(h, value, count))
+    {
+        return false;
+    }
+
+    if (expected_interval <= 0 || value <= expected_interval)
+    {
+        return true;
+    }
+
+    missing_value = value - expected_interval;
+    for (; missing_value >= expected_interval; missing_value -= expected_interval)
+    {
+        if (!hdr_record_values_atomic(h, missing_value, count))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 int64_t hdr_add(struct hdr_histogram* h, const struct hdr_histogram* from)
 {
     struct hdr_iter iter;
@@ -672,7 +782,7 @@ static bool next_value_greater_than_reporting_level_upper_bound(
     return peek_next_value_from_index(iter) > reporting_level_upper_bound;
 }
 
-static bool _basic_iter_next(struct hdr_iter *iter)
+static bool basic_iter_next(struct hdr_iter *iter)
 {
     if (!has_next(iter) || iter->counts_index >= iter->h->counts_len)
     {
@@ -684,19 +794,19 @@ static bool _basic_iter_next(struct hdr_iter *iter)
     return true;
 }
 
-static void _update_iterated_values(struct hdr_iter* iter, int64_t new_value_iterated_to)
+static void update_iterated_values(struct hdr_iter* iter, int64_t new_value_iterated_to)
 {
     iter->value_iterated_from = iter->value_iterated_to;
     iter->value_iterated_to = new_value_iterated_to;
 }
 
-static bool _all_values_iter_next(struct hdr_iter* iter)
+static bool all_values_iter_next(struct hdr_iter* iter)
 {
     bool result = move_next(iter);
 
     if (result)
     {
-        _update_iterated_values(iter, iter->value);
+        update_iterated_values(iter, iter->value);
     }
 
     return result;
@@ -715,7 +825,7 @@ void hdr_iter_init(struct hdr_iter* iter, const struct hdr_histogram* h)
     iter->value_iterated_from = 0;
     iter->value_iterated_to = 0;
 
-    iter->_next_fp = _all_values_iter_next;
+    iter->_next_fp = all_values_iter_next;
 }
 
 bool hdr_iter_next(struct hdr_iter* iter)
@@ -731,7 +841,7 @@ bool hdr_iter_next(struct hdr_iter* iter)
 /* ##        ##       ##    ##  ##    ## ##       ##   ###    ##     ##  ##       ##       ##    ## */
 /* ##        ######## ##     ##  ######  ######## ##    ##    ##    #### ######## ########  ######  */
 
-static bool _percentile_iter_next(struct hdr_iter* iter)
+static bool percentile_iter_next(struct hdr_iter* iter)
 {
     int64_t temp, half_distance, percentile_reporting_ticks;
 
@@ -750,7 +860,7 @@ static bool _percentile_iter_next(struct hdr_iter* iter)
         return true;
     }
 
-    if (iter->counts_index == -1 && !_basic_iter_next(iter))
+    if (iter->counts_index == -1 && !basic_iter_next(iter))
     {
         return false;
     }
@@ -761,7 +871,7 @@ static bool _percentile_iter_next(struct hdr_iter* iter)
         if (iter->count != 0 &&
                 percentiles->percentile_to_iterate_to <= current_percentile)
         {
-            _update_iterated_values(iter, highest_equivalent_value(iter->h, iter->value));
+            update_iterated_values(iter, highest_equivalent_value(iter->h, iter->value));
 
             percentiles->percentile = percentiles->percentile_to_iterate_to;
             temp = (int64_t)(log(100 / (100.0 - (percentiles->percentile_to_iterate_to))) / log(2)) + 1;
@@ -772,7 +882,7 @@ static bool _percentile_iter_next(struct hdr_iter* iter)
             return true;
         }
     }
-    while (_basic_iter_next(iter));
+    while (basic_iter_next(iter));
 
     return true;
 }
@@ -788,7 +898,7 @@ void hdr_iter_percentile_init(struct hdr_iter* iter, const struct hdr_histogram*
     iter->specifics.percentiles.percentile_to_iterate_to = 0.0;
     iter->specifics.percentiles.percentile               = 0.0;
 
-    iter->_next_fp = _percentile_iter_next;
+    iter->_next_fp = percentile_iter_next;
 }
 
 static void format_line_string(char* str, size_t len, int significant_figures, format_type format)
@@ -827,13 +937,13 @@ static void format_line_string(char* str, size_t len, int significant_figures, f
 /* ##     ## ########  ######   #######  ##     ## ########  ######## ########   */
 
 
-static bool _recorded_iter_next(struct hdr_iter* iter)
+static bool recorded_iter_next(struct hdr_iter* iter)
 {
-    while (_basic_iter_next(iter))
+    while (basic_iter_next(iter))
     {
         if (iter->count != 0)
         {
-            _update_iterated_values(iter, iter->value);
+            update_iterated_values(iter, iter->value);
 
             iter->specifics.recorded.count_added_in_this_iteration_step = iter->count;
             return true;
@@ -849,7 +959,7 @@ void hdr_iter_recorded_init(struct hdr_iter* iter, const struct hdr_histogram* h
 
     iter->specifics.recorded.count_added_in_this_iteration_step = 0;
 
-    iter->_next_fp = _recorded_iter_next;
+    iter->_next_fp = recorded_iter_next;
 }
 
 /* ##       #### ##    ## ########    ###    ########  */
@@ -861,7 +971,7 @@ void hdr_iter_recorded_init(struct hdr_iter* iter, const struct hdr_histogram* h
 /* ######## #### ##    ## ######## ##     ## ##     ## */
 
 
-static bool _iter_linear_next(struct hdr_iter* iter)
+static bool iter_linear_next(struct hdr_iter* iter)
 {
     struct hdr_iter_linear* linear = &iter->specifics.linear;
 
@@ -875,7 +985,7 @@ static bool _iter_linear_next(struct hdr_iter* iter)
         {
             if (iter->value >= linear->next_value_reporting_level_lowest_equivalent)
             {
-                _update_iterated_values(iter, linear->next_value_reporting_level);
+                update_iterated_values(iter, linear->next_value_reporting_level);
 
                 linear->next_value_reporting_level += linear->value_units_per_bucket;
                 linear->next_value_reporting_level_lowest_equivalent =
@@ -907,7 +1017,7 @@ void hdr_iter_linear_init(struct hdr_iter* iter, const struct hdr_histogram* h,
     iter->specifics.linear.next_value_reporting_level = value_units_per_bucket;
     iter->specifics.linear.next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(h, value_units_per_bucket);
 
-    iter->_next_fp = _iter_linear_next;
+    iter->_next_fp = iter_linear_next;
 }
 
 /* ##        #######   ######      ###    ########  #### ######## ##     ## ##     ## ####  ######  */
@@ -918,7 +1028,7 @@ void hdr_iter_linear_init(struct hdr_iter* iter, const struct hdr_histogram* h,
 /* ##       ##     ## ##    ##  ##     ## ##    ##   ##     ##    ##     ## ##     ##  ##  ##    ## */
 /* ########  #######   ######   ##     ## ##     ## ####    ##    ##     ## ##     ## ####  ######  */
 
-static bool _log_iter_next(struct hdr_iter *iter)
+static bool log_iter_next(struct hdr_iter *iter)
 {
     struct hdr_iter_log* logarithmic = &iter->specifics.log;
 
@@ -932,7 +1042,7 @@ static bool _log_iter_next(struct hdr_iter *iter)
         {
             if (iter->value >= logarithmic->next_value_reporting_level_lowest_equivalent)
             {
-                _update_iterated_values(iter, logarithmic->next_value_reporting_level);
+                update_iterated_values(iter, logarithmic->next_value_reporting_level);
 
                 logarithmic->next_value_reporting_level *= (int64_t)logarithmic->log_base;
                 logarithmic->next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(iter->h, logarithmic->next_value_reporting_level);
@@ -965,7 +1075,7 @@ void hdr_iter_log_init(
     iter->specifics.log.next_value_reporting_level = value_units_first_bucket;
     iter->specifics.log.next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(h, value_units_first_bucket);
 
-    iter->_next_fp = _log_iter_next;
+    iter->_next_fp = log_iter_next;
 }
 
 /* Printing. */
@@ -977,7 +1087,6 @@ static const char* format_head_string(format_type format)
         case CSV:
             return "%s,%s,%s,%s\n";
         case CLASSIC:
-            return "%12s %12s %12s %12s\n\n";
         default:
             return "%12s %12s %12s %12s\n\n";
     }
diff --git a/deps/histogram/src/hdr_histogram.h b/deps/histogram/src/hdr_histogram.h
index 4a0f4606b5717292a31e46fcf155ae640202b0d5..aff51f1c11526ace0a8959e7e43b90065e236abc 100644
--- a/deps/histogram/src/hdr_histogram.h
+++ b/deps/histogram/src/hdr_histogram.h
@@ -110,6 +110,21 @@ size_t hdr_get_memory_size(struct hdr_histogram* h);
  */
 bool hdr_record_value(struct hdr_histogram* h, int64_t value);
 
+/**
+ * Records a value in the histogram, will round this value of to a precision at or better
+ * than the significant_figure specified at construction time.
+ *
+ * Will record this value atomically, however the whole structure may appear inconsistent
+ * when read concurrently with this update.  Do NOT mix calls to this method with calls
+ * to non-atomic updates.
+ *
+ * @param h "This" pointer
+ * @param value Value to add to the histogram
+ * @return false if the value is larger than the highest_trackable_value and can't be recorded,
+ * true otherwise.
+ */
+bool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value);
+
 /**
  * Records count values in the histogram, will round this value of to a
  * precision at or better than the significant_figure specified at construction
@@ -123,6 +138,22 @@ bool hdr_record_value(struct hdr_histogram* h, int64_t value);
  */
 bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count);
 
+/**
+ * Records count values in the histogram, will round this value of to a
+ * precision at or better than the significant_figure specified at construction
+ * time.
+ *
+ * Will record this value atomically, however the whole structure may appear inconsistent
+ * when read concurrently with this update.  Do NOT mix calls to this method with calls
+ * to non-atomic updates.
+ *
+ * @param h "This" pointer
+ * @param value Value to add to the histogram
+ * @param count Number of 'value's to add to the histogram
+ * @return false if any value is larger than the highest_trackable_value and can't be recorded,
+ * true otherwise.
+ */
+bool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count);
 
 /**
  * Record a value in the histogram and backfill based on an expected interval.
@@ -140,6 +171,28 @@ bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count);
  * true otherwise.
  */
 bool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, int64_t expexcted_interval);
+
+/**
+ * Record a value in the histogram and backfill based on an expected interval.
+ *
+ * Records a value in the histogram, will round this value of to a precision at or better
+ * than the significant_figure specified at contruction time.  This is specifically used
+ * for recording latency.  If the value is larger than the expected_interval then the
+ * latency recording system has experienced co-ordinated omission.  This method fills in the
+ * values that would have occured had the client providing the load not been blocked.
+ *
+ * Will record this value atomically, however the whole structure may appear inconsistent
+ * when read concurrently with this update.  Do NOT mix calls to this method with calls
+ * to non-atomic updates.
+ *
+ * @param h "This" pointer
+ * @param value Value to add to the histogram
+ * @param expected_interval The delay between recording values.
+ * @return false if the value is larger than the highest_trackable_value and can't be recorded,
+ * true otherwise.
+ */
+bool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t value, int64_t expexcted_interval);
+
 /**
  * Record a value in the histogram 'count' times.  Applies the same correcting logic
  * as 'hdr_record_corrected_value'.
@@ -153,6 +206,23 @@ bool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, int64_t
  */
 bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval);
 
+/**
+ * Record a value in the histogram 'count' times.  Applies the same correcting logic
+ * as 'hdr_record_corrected_value'.
+ *
+ * Will record this value atomically, however the whole structure may appear inconsistent
+ * when read concurrently with this update.  Do NOT mix calls to this method with calls
+ * to non-atomic updates.
+ *
+ * @param h "This" pointer
+ * @param value Value to add to the histogram
+ * @param count Number of 'value's to add to the histogram
+ * @param expected_interval The delay between recording values.
+ * @return false if the value is larger than the highest_trackable_value and can't be recorded,
+ * true otherwise.
+ */
+bool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval);
+
 /**
  * Adds all of the values from 'from' to 'this' histogram.  Will return the
  * number of values that are dropped when copying.  Values will be dropped
@@ -299,7 +369,7 @@ struct hdr_iter
     /** raw index into the counts array */
     int32_t counts_index;
     /** snapshot of the length at the time the iterator is created */
-    int32_t total_count;
+    int64_t total_count;
     /** value directly from array for the current counts_index */
     int64_t count;
     /** sum of all of the counts up to and including the count at this index */
@@ -431,4 +501,4 @@ void hdr_reset_internal_counters(struct hdr_histogram* h);
 }
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff --git a/deps/http_parser/.gitignore b/deps/http_parser/.gitignore
deleted file mode 100644
index c122e76fb9126b8c1b4c0132e4b531caedba021c..0000000000000000000000000000000000000000
--- a/deps/http_parser/.gitignore
+++ /dev/null
@@ -1,30 +0,0 @@
-/out/
-core
-tags
-*.o
-test
-test_g
-test_fast
-bench
-url_parser
-parsertrace
-parsertrace_g
-*.mk
-*.Makefile
-*.so.*
-*.exe.*
-*.exe
-*.a
-
-
-# Visual Studio uglies
-*.suo
-*.sln
-*.vcxproj
-*.vcxproj.filters
-*.vcxproj.user
-*.opensdf
-*.ncrunchsolution*
-*.sdf
-*.vsp
-*.psess
diff --git a/deps/http_parser/.mailmap b/deps/http_parser/.mailmap
deleted file mode 100644
index 278d1412637240f9d13a00512588a264ab9ad91f..0000000000000000000000000000000000000000
--- a/deps/http_parser/.mailmap
+++ /dev/null
@@ -1,8 +0,0 @@
-# update AUTHORS with:
-#   git log --all --reverse --format='%aN <%aE>' | perl -ne 'BEGIN{print "# Authors ordered by first contribution.\n"} print unless $h{$_}; $h{$_} = 1' > AUTHORS
-Ryan Dahl <ry@tinyclouds.org>
-Salman Haq <salman.haq@asti-usa.com>
-Simon Zimmermann <simonz05@gmail.com>
-Thomas LE ROUX <thomas@november-eleven.fr> LE ROUX Thomas <thomas@procheo.fr>
-Thomas LE ROUX <thomas@november-eleven.fr> Thomas LE ROUX <thomas@procheo.fr>
-Fedor Indutny <fedor@indutny.com>
diff --git a/deps/http_parser/.travis.yml b/deps/http_parser/.travis.yml
deleted file mode 100644
index 4b038e6e62d638dce7cdaeb73c80d9b931b7f565..0000000000000000000000000000000000000000
--- a/deps/http_parser/.travis.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-language: c
-
-compiler:
-  - clang
-  - gcc
-
-script:
-  - "make"
-
-notifications:
-  email: false
-  irc:
-    - "irc.freenode.net#node-ci"
diff --git a/deps/http_parser/AUTHORS b/deps/http_parser/AUTHORS
deleted file mode 100644
index 5323b685caefb91ef74b5fcf5f630fd09c97b33f..0000000000000000000000000000000000000000
--- a/deps/http_parser/AUTHORS
+++ /dev/null
@@ -1,68 +0,0 @@
-# Authors ordered by first contribution.
-Ryan Dahl <ry@tinyclouds.org>
-Jeremy Hinegardner <jeremy@hinegardner.org>
-Sergey Shepelev <temotor@gmail.com>
-Joe Damato <ice799@gmail.com>
-tomika <tomika_nospam@freemail.hu>
-Phoenix Sol <phoenix@burninglabs.com>
-Cliff Frey <cliff@meraki.com>
-Ewen Cheslack-Postava <ewencp@cs.stanford.edu>
-Santiago Gala <sgala@apache.org>
-Tim Becker <tim.becker@syngenio.de>
-Jeff Terrace <jterrace@gmail.com>
-Ben Noordhuis <info@bnoordhuis.nl>
-Nathan Rajlich <nathan@tootallnate.net>
-Mark Nottingham <mnot@mnot.net>
-Aman Gupta <aman@tmm1.net>
-Tim Becker <tim.becker@kuriositaet.de>
-Sean Cunningham <sean.cunningham@mandiant.com>
-Peter Griess <pg@std.in>
-Salman Haq <salman.haq@asti-usa.com>
-Cliff Frey <clifffrey@gmail.com>
-Jon Kolb <jon@b0g.us>
-Fouad Mardini <f.mardini@gmail.com>
-Paul Querna <pquerna@apache.org>
-Felix Geisendörfer <felix@debuggable.com>
-koichik <koichik@improvement.jp>
-Andre Caron <andre.l.caron@gmail.com>
-Ivo Raisr <ivosh@ivosh.net>
-James McLaughlin <jamie@lacewing-project.org>
-David Gwynne <loki@animata.net>
-Thomas LE ROUX <thomas@november-eleven.fr>
-Randy Rizun <rrizun@ortivawireless.com>
-Andre Louis Caron <andre.louis.caron@usherbrooke.ca>
-Simon Zimmermann <simonz05@gmail.com>
-Erik Dubbelboer <erik@dubbelboer.com>
-Martell Malone <martellmalone@gmail.com>
-Bertrand Paquet <bpaquet@octo.com>
-BogDan Vatra <bogdan@kde.org>
-Peter Faiman <peter@thepicard.org>
-Corey Richardson <corey@octayn.net>
-Tóth Tamás <tomika_nospam@freemail.hu>
-Cam Swords <cam.swords@gmail.com>
-Chris Dickinson <christopher.s.dickinson@gmail.com>
-Uli Köhler <ukoehler@btronik.de>
-Charlie Somerville <charlie@charliesomerville.com>
-Patrik Stutz <patrik.stutz@gmail.com>
-Fedor Indutny <fedor.indutny@gmail.com>
-runner <runner.mei@gmail.com>
-Alexis Campailla <alexis@janeasystems.com>
-David Wragg <david@wragg.org>
-Vinnie Falco <vinnie.falco@gmail.com>
-Alex Butum <alexbutum@linux.com>
-Rex Feng <rexfeng@gmail.com>
-Alex Kocharin <alex@kocharin.ru>
-Mark Koopman <markmontymark@yahoo.com>
-Helge Heß <me@helgehess.eu>
-Alexis La Goutte <alexis.lagoutte@gmail.com>
-George Miroshnykov <george.miroshnykov@gmail.com>
-Maciej Małecki <me@mmalecki.com>
-Marc O'Morain <github.com@marcomorain.com>
-Jeff Pinner <jpinner@twitter.com>
-Timothy J Fontaine <tjfontaine@gmail.com>
-Akagi201 <akagi201@gmail.com>
-Romain Giraud <giraud.romain@gmail.com>
-Jay Satiro <raysatiro@yahoo.com>
-Arne Steen <Arne.Steen@gmx.de>
-Kjell Schubert <kjell.schubert@gmail.com>
-Olivier Mengué <dolmen@cpan.org>
diff --git a/deps/http_parser/LICENSE-MIT b/deps/http_parser/LICENSE-MIT
deleted file mode 100644
index 1ec0ab4e1746be2b5a7a817eb9c92cf8e3ff7e6d..0000000000000000000000000000000000000000
--- a/deps/http_parser/LICENSE-MIT
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright Joyent, Inc. and other Node contributors.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-IN THE SOFTWARE. 
diff --git a/deps/http_parser/Makefile b/deps/http_parser/Makefile
deleted file mode 100644
index 5d212215041cbcda94a445d2ed741a72b07e5220..0000000000000000000000000000000000000000
--- a/deps/http_parser/Makefile
+++ /dev/null
@@ -1,160 +0,0 @@
-# Copyright Joyent, Inc. and other Node contributors. All rights reserved.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-
-PLATFORM ?= $(shell sh -c 'uname -s | tr "[A-Z]" "[a-z]"')
-HELPER ?=
-BINEXT ?=
-SOLIBNAME = libhttp_parser
-SOMAJOR = 2
-SOMINOR = 9
-SOREV   = 4
-ifeq (darwin,$(PLATFORM))
-SOEXT ?= dylib
-SONAME ?= $(SOLIBNAME).$(SOMAJOR).$(SOMINOR).$(SOEXT)
-LIBNAME ?= $(SOLIBNAME).$(SOMAJOR).$(SOMINOR).$(SOREV).$(SOEXT)
-else ifeq (wine,$(PLATFORM))
-CC = winegcc
-BINEXT = .exe.so
-HELPER = wine
-else
-SOEXT ?= so
-SONAME ?= $(SOLIBNAME).$(SOEXT).$(SOMAJOR).$(SOMINOR)
-LIBNAME ?= $(SOLIBNAME).$(SOEXT).$(SOMAJOR).$(SOMINOR).$(SOREV)
-endif
-
-CC?=gcc
-AR?=ar
-
-CPPFLAGS ?=
-LDFLAGS ?=
-
-CPPFLAGS += -I.
-CPPFLAGS_DEBUG = $(CPPFLAGS) -DHTTP_PARSER_STRICT=1
-CPPFLAGS_DEBUG += $(CPPFLAGS_DEBUG_EXTRA)
-CPPFLAGS_FAST = $(CPPFLAGS) -DHTTP_PARSER_STRICT=0
-CPPFLAGS_FAST += $(CPPFLAGS_FAST_EXTRA)
-CPPFLAGS_BENCH = $(CPPFLAGS_FAST)
-
-CFLAGS += -Wall -Wextra -Werror
-CFLAGS_DEBUG = $(CFLAGS) -O0 -g $(CFLAGS_DEBUG_EXTRA)
-CFLAGS_FAST = $(CFLAGS) -O3 $(CFLAGS_FAST_EXTRA)
-CFLAGS_BENCH = $(CFLAGS_FAST) -Wno-unused-parameter
-CFLAGS_LIB = $(CFLAGS_FAST) -fPIC
-
-LDFLAGS_LIB = $(LDFLAGS) -shared
-
-INSTALL ?= install
-PREFIX ?= /usr/local
-LIBDIR = $(PREFIX)/lib
-INCLUDEDIR = $(PREFIX)/include
-
-ifeq (darwin,$(PLATFORM))
-LDFLAGS_LIB += -Wl,-install_name,$(LIBDIR)/$(SONAME)
-else
-# TODO(bnoordhuis) The native SunOS linker expects -h rather than -soname...
-LDFLAGS_LIB += -Wl,-soname=$(SONAME)
-endif
-
-test: test_g test_fast
-	$(HELPER) ./test_g$(BINEXT)
-	$(HELPER) ./test_fast$(BINEXT)
-
-test_g: http_parser_g.o test_g.o
-	$(CC) $(CFLAGS_DEBUG) $(LDFLAGS) http_parser_g.o test_g.o -o $@
-
-test_g.o: test.c http_parser.h Makefile
-	$(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) -c test.c -o $@
-
-http_parser_g.o: http_parser.c http_parser.h Makefile
-	$(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) -c http_parser.c -o $@
-
-test_fast: http_parser.o test.o http_parser.h
-	$(CC) $(CFLAGS_FAST) $(LDFLAGS) http_parser.o test.o -o $@
-
-test.o: test.c http_parser.h Makefile
-	$(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) -c test.c -o $@
-
-bench: http_parser.o bench.o
-	$(CC) $(CFLAGS_BENCH) $(LDFLAGS) http_parser.o bench.o -o $@
-
-bench.o: bench.c http_parser.h Makefile
-	$(CC) $(CPPFLAGS_BENCH) $(CFLAGS_BENCH) -c bench.c -o $@
-
-http_parser.o: http_parser.c http_parser.h Makefile
-	$(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) -c http_parser.c
-
-test-run-timed: test_fast
-	while(true) do time $(HELPER) ./test_fast$(BINEXT) > /dev/null; done
-
-test-valgrind: test_g
-	valgrind ./test_g
-
-libhttp_parser.o: http_parser.c http_parser.h Makefile
-	$(CC) $(CPPFLAGS_FAST) $(CFLAGS_LIB) -c http_parser.c -o libhttp_parser.o
-
-library: libhttp_parser.o
-	$(CC) $(LDFLAGS_LIB) -o $(LIBNAME) $<
-
-package: http_parser.o
-	$(AR) rcs libhttp_parser.a http_parser.o
-
-url_parser: http_parser.o contrib/url_parser.c
-	$(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) $^ -o $@
-
-url_parser_g: http_parser_g.o contrib/url_parser.c
-	$(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) $^ -o $@
-
-parsertrace: http_parser.o contrib/parsertrace.c
-	$(CC) $(CPPFLAGS_FAST) $(CFLAGS_FAST) $^ -o parsertrace$(BINEXT)
-
-parsertrace_g: http_parser_g.o contrib/parsertrace.c
-	$(CC) $(CPPFLAGS_DEBUG) $(CFLAGS_DEBUG) $^ -o parsertrace_g$(BINEXT)
-
-tags: http_parser.c http_parser.h test.c
-	ctags $^
-
-install: library
-	$(INSTALL) -D  http_parser.h $(DESTDIR)$(INCLUDEDIR)/http_parser.h
-	$(INSTALL) -D $(LIBNAME) $(DESTDIR)$(LIBDIR)/$(LIBNAME)
-	ln -sf $(LIBNAME) $(DESTDIR)$(LIBDIR)/$(SONAME)
-	ln -sf $(LIBNAME) $(DESTDIR)$(LIBDIR)/$(SOLIBNAME).$(SOEXT)
-
-install-strip: library
-	$(INSTALL) -D  http_parser.h $(DESTDIR)$(INCLUDEDIR)/http_parser.h
-	$(INSTALL) -D -s $(LIBNAME) $(DESTDIR)$(LIBDIR)/$(LIBNAME)
-	ln -sf $(LIBNAME) $(DESTDIR)$(LIBDIR)/$(SONAME)
-	ln -sf $(LIBNAME) $(DESTDIR)$(LIBDIR)/$(SOLIBNAME).$(SOEXT)
-
-uninstall:
-	rm $(DESTDIR)$(INCLUDEDIR)/http_parser.h
-	rm $(DESTDIR)$(LIBDIR)/$(SOLIBNAME).$(SOEXT)
-	rm $(DESTDIR)$(LIBDIR)/$(SONAME)
-	rm $(DESTDIR)$(LIBDIR)/$(LIBNAME)
-
-clean:
-	rm -f *.o *.a tags test test_fast test_g \
-		http_parser.tar libhttp_parser.so.* \
-		url_parser url_parser_g parsertrace parsertrace_g \
-		*.exe *.exe.so
-
-contrib/url_parser.c:	http_parser.h
-contrib/parsertrace.c:	http_parser.h
-
-.PHONY: clean package test-run test-run-timed test-valgrind install install-strip uninstall
diff --git a/deps/http_parser/README.md b/deps/http_parser/README.md
deleted file mode 100644
index e38d3a57881a6a38f733e19efcd1e3fbf16dc2b6..0000000000000000000000000000000000000000
--- a/deps/http_parser/README.md
+++ /dev/null
@@ -1,249 +0,0 @@
-HTTP Parser
-===========
-
-http-parser is [**not** actively maintained](https://github.com/nodejs/http-parser/issues/522).
-New projects and projects looking to migrate should consider [llhttp](https://github.com/nodejs/llhttp).
-
-[![Build Status](https://api.travis-ci.org/nodejs/http-parser.svg?branch=master)](https://travis-ci.org/nodejs/http-parser)
-
-This is a parser for HTTP messages written in C. It parses both requests and
-responses. The parser is designed to be used in performance HTTP
-applications. It does not make any syscalls nor allocations, it does not
-buffer data, it can be interrupted at anytime. Depending on your
-architecture, it only requires about 40 bytes of data per message
-stream (in a web server that is per connection).
-
-Features:
-
-  * No dependencies
-  * Handles persistent streams (keep-alive).
-  * Decodes chunked encoding.
-  * Upgrade support
-  * Defends against buffer overflow attacks.
-
-The parser extracts the following information from HTTP messages:
-
-  * Header fields and values
-  * Content-Length
-  * Request method
-  * Response status code
-  * Transfer-Encoding
-  * HTTP version
-  * Request URL
-  * Message body
-
-
-Usage
------
-
-One `http_parser` object is used per TCP connection. Initialize the struct
-using `http_parser_init()` and set the callbacks. That might look something
-like this for a request parser:
-```c
-http_parser_settings settings;
-settings.on_url = my_url_callback;
-settings.on_header_field = my_header_field_callback;
-/* ... */
-
-http_parser *parser = malloc(sizeof(http_parser));
-http_parser_init(parser, HTTP_REQUEST);
-parser->data = my_socket;
-```
-
-When data is received on the socket execute the parser and check for errors.
-
-```c
-size_t len = 80*1024, nparsed;
-char buf[len];
-ssize_t recved;
-
-recved = recv(fd, buf, len, 0);
-
-if (recved < 0) {
-  /* Handle error. */
-}
-
-/* Start up / continue the parser.
- * Note we pass recved==0 to signal that EOF has been received.
- */
-nparsed = http_parser_execute(parser, &settings, buf, recved);
-
-if (parser->upgrade) {
-  /* handle new protocol */
-} else if (nparsed != recved) {
-  /* Handle error. Usually just close the connection. */
-}
-```
-
-`http_parser` needs to know where the end of the stream is. For example, sometimes
-servers send responses without Content-Length and expect the client to
-consume input (for the body) until EOF. To tell `http_parser` about EOF, give
-`0` as the fourth parameter to `http_parser_execute()`. Callbacks and errors
-can still be encountered during an EOF, so one must still be prepared
-to receive them.
-
-Scalar valued message information such as `status_code`, `method`, and the
-HTTP version are stored in the parser structure. This data is only
-temporally stored in `http_parser` and gets reset on each new message. If
-this information is needed later, copy it out of the structure during the
-`headers_complete` callback.
-
-The parser decodes the transfer-encoding for both requests and responses
-transparently. That is, a chunked encoding is decoded before being sent to
-the on_body callback.
-
-
-The Special Problem of Upgrade
-------------------------------
-
-`http_parser` supports upgrading the connection to a different protocol. An
-increasingly common example of this is the WebSocket protocol which sends
-a request like
-
-        GET /demo HTTP/1.1
-        Upgrade: WebSocket
-        Connection: Upgrade
-        Host: example.com
-        Origin: http://example.com
-        WebSocket-Protocol: sample
-
-followed by non-HTTP data.
-
-(See [RFC6455](https://tools.ietf.org/html/rfc6455) for more information the
-WebSocket protocol.)
-
-To support this, the parser will treat this as a normal HTTP message without a
-body, issuing both on_headers_complete and on_message_complete callbacks. However
-http_parser_execute() will stop parsing at the end of the headers and return.
-
-The user is expected to check if `parser->upgrade` has been set to 1 after
-`http_parser_execute()` returns. Non-HTTP data begins at the buffer supplied
-offset by the return value of `http_parser_execute()`.
-
-
-Callbacks
----------
-
-During the `http_parser_execute()` call, the callbacks set in
-`http_parser_settings` will be executed. The parser maintains state and
-never looks behind, so buffering the data is not necessary. If you need to
-save certain data for later usage, you can do that from the callbacks.
-
-There are two types of callbacks:
-
-* notification `typedef int (*http_cb) (http_parser*);`
-    Callbacks: on_message_begin, on_headers_complete, on_message_complete.
-* data `typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);`
-    Callbacks: (requests only) on_url,
-               (common) on_header_field, on_header_value, on_body;
-
-Callbacks must return 0 on success. Returning a non-zero value indicates
-error to the parser, making it exit immediately.
-
-For cases where it is necessary to pass local information to/from a callback,
-the `http_parser` object's `data` field can be used.
-An example of such a case is when using threads to handle a socket connection,
-parse a request, and then give a response over that socket. By instantiation
-of a thread-local struct containing relevant data (e.g. accepted socket,
-allocated memory for callbacks to write into, etc), a parser's callbacks are
-able to communicate data between the scope of the thread and the scope of the
-callback in a threadsafe manner. This allows `http_parser` to be used in
-multi-threaded contexts.
-
-Example:
-```c
- typedef struct {
-  socket_t sock;
-  void* buffer;
-  int buf_len;
- } custom_data_t;
-
-
-int my_url_callback(http_parser* parser, const char *at, size_t length) {
-  /* access to thread local custom_data_t struct.
-  Use this access save parsed data for later use into thread local
-  buffer, or communicate over socket
-  */
-  parser->data;
-  ...
-  return 0;
-}
-
-...
-
-void http_parser_thread(socket_t sock) {
- int nparsed = 0;
- /* allocate memory for user data */
- custom_data_t *my_data = malloc(sizeof(custom_data_t));
-
- /* some information for use by callbacks.
- * achieves thread -> callback information flow */
- my_data->sock = sock;
-
- /* instantiate a thread-local parser */
- http_parser *parser = malloc(sizeof(http_parser));
- http_parser_init(parser, HTTP_REQUEST); /* initialise parser */
- /* this custom data reference is accessible through the reference to the
- parser supplied to callback functions */
- parser->data = my_data;
-
- http_parser_settings settings; /* set up callbacks */
- settings.on_url = my_url_callback;
-
- /* execute parser */
- nparsed = http_parser_execute(parser, &settings, buf, recved);
-
- ...
- /* parsed information copied from callback.
- can now perform action on data copied into thread-local memory from callbacks.
- achieves callback -> thread information flow */
- my_data->buffer;
- ...
-}
-
-```
-
-In case you parse HTTP message in chunks (i.e. `read()` request line
-from socket, parse, read half headers, parse, etc) your data callbacks
-may be called more than once. `http_parser` guarantees that data pointer is only
-valid for the lifetime of callback. You can also `read()` into a heap allocated
-buffer to avoid copying memory around if this fits your application.
-
-Reading headers may be a tricky task if you read/parse headers partially.
-Basically, you need to remember whether last header callback was field or value
-and apply the following logic:
-
-    (on_header_field and on_header_value shortened to on_h_*)
-     ------------------------ ------------ --------------------------------------------
-    | State (prev. callback) | Callback   | Description/action                         |
-     ------------------------ ------------ --------------------------------------------
-    | nothing (first call)   | on_h_field | Allocate new buffer and copy callback data |
-    |                        |            | into it                                    |
-     ------------------------ ------------ --------------------------------------------
-    | value                  | on_h_field | New header started.                        |
-    |                        |            | Copy current name,value buffers to headers |
-    |                        |            | list and allocate new buffer for new name  |
-     ------------------------ ------------ --------------------------------------------
-    | field                  | on_h_field | Previous name continues. Reallocate name   |
-    |                        |            | buffer and append callback data to it      |
-     ------------------------ ------------ --------------------------------------------
-    | field                  | on_h_value | Value for current header started. Allocate |
-    |                        |            | new buffer and copy callback data to it    |
-     ------------------------ ------------ --------------------------------------------
-    | value                  | on_h_value | Value continues. Reallocate value buffer   |
-    |                        |            | and append callback data to it             |
-     ------------------------ ------------ --------------------------------------------
-
-
-Parsing URLs
-------------
-
-A simplistic zero-copy URL parser is provided as `http_parser_parse_url()`.
-Users of this library may wish to use it to parse URLs constructed from
-consecutive `on_url` callbacks.
-
-See examples of reading in headers:
-
-* [partial example](http://gist.github.com/155877) in C
-* [from http-parser tests](http://github.com/joyent/http-parser/blob/37a0ff8/test.c#L403) in C
-* [from Node library](http://github.com/joyent/node/blob/842eaf4/src/http.js#L284) in Javascript
diff --git a/deps/http_parser/bench.c b/deps/http_parser/bench.c
deleted file mode 100644
index 678f5556c59880d1f134e3bbe202b006d22793f7..0000000000000000000000000000000000000000
--- a/deps/http_parser/bench.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/* Copyright Fedor Indutny. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#include "http_parser.h"
-#include <assert.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/time.h>
-
-/* 8 gb */
-static const int64_t kBytes = 8LL << 30;
-
-static const char data[] =
-    "POST /joyent/http-parser HTTP/1.1\r\n"
-    "Host: github.com\r\n"
-    "DNT: 1\r\n"
-    "Accept-Encoding: gzip, deflate, sdch\r\n"
-    "Accept-Language: ru-RU,ru;q=0.8,en-US;q=0.6,en;q=0.4\r\n"
-    "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) "
-        "AppleWebKit/537.36 (KHTML, like Gecko) "
-        "Chrome/39.0.2171.65 Safari/537.36\r\n"
-    "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,"
-        "image/webp,*/*;q=0.8\r\n"
-    "Referer: https://github.com/joyent/http-parser\r\n"
-    "Connection: keep-alive\r\n"
-    "Transfer-Encoding: chunked\r\n"
-    "Cache-Control: max-age=0\r\n\r\nb\r\nhello world\r\n0\r\n";
-static const size_t data_len = sizeof(data) - 1;
-
-static int on_info(http_parser* p) {
-  return 0;
-}
-
-
-static int on_data(http_parser* p, const char *at, size_t length) {
-  return 0;
-}
-
-static http_parser_settings settings = {
-  .on_message_begin = on_info,
-  .on_headers_complete = on_info,
-  .on_message_complete = on_info,
-  .on_header_field = on_data,
-  .on_header_value = on_data,
-  .on_url = on_data,
-  .on_status = on_data,
-  .on_body = on_data
-};
-
-int bench(int iter_count, int silent) {
-  struct http_parser parser;
-  int i;
-  int err;
-  struct timeval start;
-  struct timeval end;
-
-  if (!silent) {
-    err = gettimeofday(&start, NULL);
-    assert(err == 0);
-  }
-
-  fprintf(stderr, "req_len=%d\n", (int) data_len);
-  for (i = 0; i < iter_count; i++) {
-    size_t parsed;
-    http_parser_init(&parser, HTTP_REQUEST);
-
-    parsed = http_parser_execute(&parser, &settings, data, data_len);
-    assert(parsed == data_len);
-  }
-
-  if (!silent) {
-    double elapsed;
-    double bw;
-    double total;
-
-    err = gettimeofday(&end, NULL);
-    assert(err == 0);
-
-    fprintf(stdout, "Benchmark result:\n");
-
-    elapsed = (double) (end.tv_sec - start.tv_sec) +
-              (end.tv_usec - start.tv_usec) * 1e-6f;
-
-    total = (double) iter_count * data_len;
-    bw = (double) total / elapsed;
-
-    fprintf(stdout, "%.2f mb | %.2f mb/s | %.2f req/sec | %.2f s\n",
-        (double) total / (1024 * 1024),
-        bw / (1024 * 1024),
-        (double) iter_count / elapsed,
-        elapsed);
-
-    fflush(stdout);
-  }
-
-  return 0;
-}
-
-int main(int argc, char** argv) {
-  int64_t iterations;
-
-  iterations = kBytes / (int64_t) data_len;
-  if (argc == 2 && strcmp(argv[1], "infinite") == 0) {
-    for (;;)
-      bench(iterations, 1);
-    return 0;
-  } else {
-    return bench(iterations, 0);
-  }
-}
diff --git a/deps/http_parser/contrib/parsertrace.c b/deps/http_parser/contrib/parsertrace.c
deleted file mode 100644
index 3daa7f46a19370fa54b883e1e04b6806003d3d14..0000000000000000000000000000000000000000
--- a/deps/http_parser/contrib/parsertrace.c
+++ /dev/null
@@ -1,157 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-/* Dump what the parser finds to stdout as it happen */
-
-#include "http_parser.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-int on_message_begin(http_parser* _) {
-  (void)_;
-  printf("\n***MESSAGE BEGIN***\n\n");
-  return 0;
-}
-
-int on_headers_complete(http_parser* _) {
-  (void)_;
-  printf("\n***HEADERS COMPLETE***\n\n");
-  return 0;
-}
-
-int on_message_complete(http_parser* _) {
-  (void)_;
-  printf("\n***MESSAGE COMPLETE***\n\n");
-  return 0;
-}
-
-int on_url(http_parser* _, const char* at, size_t length) {
-  (void)_;
-  printf("Url: %.*s\n", (int)length, at);
-  return 0;
-}
-
-int on_header_field(http_parser* _, const char* at, size_t length) {
-  (void)_;
-  printf("Header field: %.*s\n", (int)length, at);
-  return 0;
-}
-
-int on_header_value(http_parser* _, const char* at, size_t length) {
-  (void)_;
-  printf("Header value: %.*s\n", (int)length, at);
-  return 0;
-}
-
-int on_body(http_parser* _, const char* at, size_t length) {
-  (void)_;
-  printf("Body: %.*s\n", (int)length, at);
-  return 0;
-}
-
-void usage(const char* name) {
-  fprintf(stderr,
-          "Usage: %s $type $filename\n"
-          "  type: -x, where x is one of {r,b,q}\n"
-          "  parses file as a Response, reQuest, or Both\n",
-          name);
-  exit(EXIT_FAILURE);
-}
-
-int main(int argc, char* argv[]) {
-  enum http_parser_type file_type;
-
-  if (argc != 3) {
-    usage(argv[0]);
-  }
-
-  char* type = argv[1];
-  if (type[0] != '-') {
-    usage(argv[0]);
-  }
-
-  switch (type[1]) {
-    /* in the case of "-", type[1] will be NUL */
-    case 'r':
-      file_type = HTTP_RESPONSE;
-      break;
-    case 'q':
-      file_type = HTTP_REQUEST;
-      break;
-    case 'b':
-      file_type = HTTP_BOTH;
-      break;
-    default:
-      usage(argv[0]);
-  }
-
-  char* filename = argv[2];
-  FILE* file = fopen(filename, "r");
-  if (file == NULL) {
-    perror("fopen");
-    goto fail;
-  }
-
-  fseek(file, 0, SEEK_END);
-  long file_length = ftell(file);
-  if (file_length == -1) {
-    perror("ftell");
-    goto fail;
-  }
-  fseek(file, 0, SEEK_SET);
-
-  char* data = malloc(file_length);
-  if (fread(data, 1, file_length, file) != (size_t)file_length) {
-    fprintf(stderr, "couldn't read entire file\n");
-    free(data);
-    goto fail;
-  }
-
-  http_parser_settings settings;
-  memset(&settings, 0, sizeof(settings));
-  settings.on_message_begin = on_message_begin;
-  settings.on_url = on_url;
-  settings.on_header_field = on_header_field;
-  settings.on_header_value = on_header_value;
-  settings.on_headers_complete = on_headers_complete;
-  settings.on_body = on_body;
-  settings.on_message_complete = on_message_complete;
-
-  http_parser parser;
-  http_parser_init(&parser, file_type);
-  size_t nparsed = http_parser_execute(&parser, &settings, data, file_length);
-  free(data);
-
-  if (nparsed != (size_t)file_length) {
-    fprintf(stderr,
-            "Error: %s (%s)\n",
-            http_errno_description(HTTP_PARSER_ERRNO(&parser)),
-            http_errno_name(HTTP_PARSER_ERRNO(&parser)));
-    goto fail;
-  }
-
-  return EXIT_SUCCESS;
-
-fail:
-  fclose(file);
-  return EXIT_FAILURE;
-}
diff --git a/deps/http_parser/contrib/url_parser.c b/deps/http_parser/contrib/url_parser.c
deleted file mode 100644
index f235bed9e483dc7b4c0398c12cfd3494b9b72074..0000000000000000000000000000000000000000
--- a/deps/http_parser/contrib/url_parser.c
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "http_parser.h"
-#include <stdio.h>
-#include <string.h>
-
-void
-dump_url (const char *url, const struct http_parser_url *u)
-{
-  unsigned int i;
-
-  printf("\tfield_set: 0x%x, port: %u\n", u->field_set, u->port);
-  for (i = 0; i < UF_MAX; i++) {
-    if ((u->field_set & (1 << i)) == 0) {
-      printf("\tfield_data[%u]: unset\n", i);
-      continue;
-    }
-
-    printf("\tfield_data[%u]: off: %u, len: %u, part: %.*s\n",
-           i,
-           u->field_data[i].off,
-           u->field_data[i].len,
-           u->field_data[i].len,
-           url + u->field_data[i].off);
-  }
-}
-
-int main(int argc, char ** argv) {
-  struct http_parser_url u;
-  int len, connect, result;
-
-  if (argc != 3) {
-    printf("Syntax : %s connect|get url\n", argv[0]);
-    return 1;
-  }
-  len = strlen(argv[2]);
-  connect = strcmp("connect", argv[1]) == 0 ? 1 : 0;
-  printf("Parsing %s, connect %d\n", argv[2], connect);
-
-  http_parser_url_init(&u);
-  result = http_parser_parse_url(argv[2], len, connect, &u);
-  if (result != 0) {
-    printf("Parse error : %d\n", result);
-    return result;
-  }
-  printf("Parse ok, result : \n");
-  dump_url(argv[2], &u);
-  return 0;
-}
diff --git a/deps/http_parser/fuzzers/fuzz_parser.c b/deps/http_parser/fuzzers/fuzz_parser.c
deleted file mode 100644
index 1a8442c9b637a65ff9f52b66c62add26c74436af..0000000000000000000000000000000000000000
--- a/deps/http_parser/fuzzers/fuzz_parser.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include "http_parser.h"
-
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
-{
-  static const http_parser_settings settings_null = {
-    .on_message_begin = 0
-    , .on_header_field = 0
-    ,.on_header_value = 0
-    ,.on_url = 0
-    ,.on_status = 0
-    ,.on_body = 0
-    ,.on_headers_complete = 0
-    ,.on_message_complete = 0
-    ,.on_chunk_header = 0
-    ,.on_chunk_complete = 0
-  };
-
-  http_parser parser;
-  http_parser_init(&parser, HTTP_BOTH);
-  http_parser_execute(&parser, &settings_null, (char*)data, size);
-
-  return 0;
-}
diff --git a/deps/http_parser/fuzzers/fuzz_url.c b/deps/http_parser/fuzzers/fuzz_url.c
deleted file mode 100644
index eca11a2edce55260a9a4a0931887e7b18dcc22a6..0000000000000000000000000000000000000000
--- a/deps/http_parser/fuzzers/fuzz_url.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include "http_parser.h"
-
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
-{
-  struct http_parser_url u;
-  http_parser_url_init(&u);
-  http_parser_parse_url((char*)data, size, 0, &u);
-  http_parser_parse_url((char*)data, size, 1, &u);
-
-  return 0;
-}
diff --git a/deps/http_parser/http_parser.c b/deps/http_parser/http_parser.c
deleted file mode 100644
index e9b2b9e83b9a57e504a9a2a5c0d7d36df4a39fac..0000000000000000000000000000000000000000
--- a/deps/http_parser/http_parser.c
+++ /dev/null
@@ -1,2582 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#include "http_parser.h"
-#include <assert.h>
-#include <stddef.h>
-#include <ctype.h>
-#include <string.h>
-#include <limits.h>
-
-static uint32_t max_header_size = HTTP_MAX_HEADER_SIZE;
-
-#ifndef ULLONG_MAX
-# define ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */
-#endif
-
-#ifndef MIN
-# define MIN(a,b) ((a) < (b) ? (a) : (b))
-#endif
-
-#ifndef ARRAY_SIZE
-# define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-#endif
-
-#ifndef BIT_AT
-# define BIT_AT(a, i)                                                \
-  (!!((unsigned int) (a)[(unsigned int) (i) >> 3] &                  \
-   (1 << ((unsigned int) (i) & 7))))
-#endif
-
-#ifndef ELEM_AT
-# define ELEM_AT(a, i, v) ((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v))
-#endif
-
-#define SET_ERRNO(e)                                                 \
-do {                                                                 \
-  parser->nread = nread;                                             \
-  parser->http_errno = (e);                                          \
-} while(0)
-
-#define CURRENT_STATE() p_state
-#define UPDATE_STATE(V) p_state = (enum state) (V);
-#define RETURN(V)                                                    \
-do {                                                                 \
-  parser->nread = nread;                                             \
-  parser->state = CURRENT_STATE();                                   \
-  return (V);                                                        \
-} while (0);
-#define REEXECUTE()                                                  \
-  goto reexecute;                                                    \
-
-
-#ifdef __GNUC__
-# define LIKELY(X) __builtin_expect(!!(X), 1)
-# define UNLIKELY(X) __builtin_expect(!!(X), 0)
-#else
-# define LIKELY(X) (X)
-# define UNLIKELY(X) (X)
-#endif
-
-
-/* Run the notify callback FOR, returning ER if it fails */
-#define CALLBACK_NOTIFY_(FOR, ER)                                    \
-do {                                                                 \
-  assert(HTTP_PARSER_ERRNO(parser) == HPE_OK);                       \
-                                                                     \
-  if (LIKELY(settings->on_##FOR)) {                                  \
-    parser->state = CURRENT_STATE();                                 \
-    if (UNLIKELY(0 != settings->on_##FOR(parser))) {                 \
-      SET_ERRNO(HPE_CB_##FOR);                                       \
-    }                                                                \
-    UPDATE_STATE(parser->state);                                     \
-                                                                     \
-    /* We either errored above or got paused; get out */             \
-    if (UNLIKELY(HTTP_PARSER_ERRNO(parser) != HPE_OK)) {             \
-      return (ER);                                                   \
-    }                                                                \
-  }                                                                  \
-} while (0)
-
-/* Run the notify callback FOR and consume the current byte */
-#define CALLBACK_NOTIFY(FOR)            CALLBACK_NOTIFY_(FOR, p - data + 1)
-
-/* Run the notify callback FOR and don't consume the current byte */
-#define CALLBACK_NOTIFY_NOADVANCE(FOR)  CALLBACK_NOTIFY_(FOR, p - data)
-
-/* Run data callback FOR with LEN bytes, returning ER if it fails */
-#define CALLBACK_DATA_(FOR, LEN, ER)                                 \
-do {                                                                 \
-  assert(HTTP_PARSER_ERRNO(parser) == HPE_OK);                       \
-                                                                     \
-  if (FOR##_mark) {                                                  \
-    if (LIKELY(settings->on_##FOR)) {                                \
-      parser->state = CURRENT_STATE();                               \
-      if (UNLIKELY(0 !=                                              \
-                   settings->on_##FOR(parser, FOR##_mark, (LEN)))) { \
-        SET_ERRNO(HPE_CB_##FOR);                                     \
-      }                                                              \
-      UPDATE_STATE(parser->state);                                   \
-                                                                     \
-      /* We either errored above or got paused; get out */           \
-      if (UNLIKELY(HTTP_PARSER_ERRNO(parser) != HPE_OK)) {           \
-        return (ER);                                                 \
-      }                                                              \
-    }                                                                \
-    FOR##_mark = NULL;                                               \
-  }                                                                  \
-} while (0)
-
-/* Run the data callback FOR and consume the current byte */
-#define CALLBACK_DATA(FOR)                                           \
-    CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1)
-
-/* Run the data callback FOR and don't consume the current byte */
-#define CALLBACK_DATA_NOADVANCE(FOR)                                 \
-    CALLBACK_DATA_(FOR, p - FOR##_mark, p - data)
-
-/* Set the mark FOR; non-destructive if mark is already set */
-#define MARK(FOR)                                                    \
-do {                                                                 \
-  if (!FOR##_mark) {                                                 \
-    FOR##_mark = p;                                                  \
-  }                                                                  \
-} while (0)
-
-/* Don't allow the total size of the HTTP headers (including the status
- * line) to exceed max_header_size.  This check is here to protect
- * embedders against denial-of-service attacks where the attacker feeds
- * us a never-ending header that the embedder keeps buffering.
- *
- * This check is arguably the responsibility of embedders but we're doing
- * it on the embedder's behalf because most won't bother and this way we
- * make the web a little safer.  max_header_size is still far bigger
- * than any reasonable request or response so this should never affect
- * day-to-day operation.
- */
-#define COUNT_HEADER_SIZE(V)                                         \
-do {                                                                 \
-  nread += (uint32_t)(V);                                            \
-  if (UNLIKELY(nread > max_header_size)) {                           \
-    SET_ERRNO(HPE_HEADER_OVERFLOW);                                  \
-    goto error;                                                      \
-  }                                                                  \
-} while (0)
-
-
-#define PROXY_CONNECTION "proxy-connection"
-#define CONNECTION "connection"
-#define CONTENT_LENGTH "content-length"
-#define TRANSFER_ENCODING "transfer-encoding"
-#define UPGRADE "upgrade"
-#define CHUNKED "chunked"
-#define KEEP_ALIVE "keep-alive"
-#define CLOSE "close"
-
-
-static const char *method_strings[] =
-  {
-#define XX(num, name, string) #string,
-  HTTP_METHOD_MAP(XX)
-#undef XX
-  };
-
-
-/* Tokens as defined by rfc 2616. Also lowercases them.
- *        token       = 1*<any CHAR except CTLs or separators>
- *     separators     = "(" | ")" | "<" | ">" | "@"
- *                    | "," | ";" | ":" | "\" | <">
- *                    | "/" | "[" | "]" | "?" | "="
- *                    | "{" | "}" | SP | HT
- */
-static const char tokens[256] = {
-/*   0 nul    1 soh    2 stx    3 etx    4 eot    5 enq    6 ack    7 bel  */
-        0,       0,       0,       0,       0,       0,       0,       0,
-/*   8 bs     9 ht    10 nl    11 vt    12 np    13 cr    14 so    15 si   */
-        0,       0,       0,       0,       0,       0,       0,       0,
-/*  16 dle   17 dc1   18 dc2   19 dc3   20 dc4   21 nak   22 syn   23 etb */
-        0,       0,       0,       0,       0,       0,       0,       0,
-/*  24 can   25 em    26 sub   27 esc   28 fs    29 gs    30 rs    31 us  */
-        0,       0,       0,       0,       0,       0,       0,       0,
-/*  32 sp    33  !    34  "    35  #    36  $    37  %    38  &    39  '  */
-       ' ',     '!',      0,      '#',     '$',     '%',     '&',    '\'',
-/*  40  (    41  )    42  *    43  +    44  ,    45  -    46  .    47  /  */
-        0,       0,      '*',     '+',      0,      '-',     '.',      0,
-/*  48  0    49  1    50  2    51  3    52  4    53  5    54  6    55  7  */
-       '0',     '1',     '2',     '3',     '4',     '5',     '6',     '7',
-/*  56  8    57  9    58  :    59  ;    60  <    61  =    62  >    63  ?  */
-       '8',     '9',      0,       0,       0,       0,       0,       0,
-/*  64  @    65  A    66  B    67  C    68  D    69  E    70  F    71  G  */
-        0,      'a',     'b',     'c',     'd',     'e',     'f',     'g',
-/*  72  H    73  I    74  J    75  K    76  L    77  M    78  N    79  O  */
-       'h',     'i',     'j',     'k',     'l',     'm',     'n',     'o',
-/*  80  P    81  Q    82  R    83  S    84  T    85  U    86  V    87  W  */
-       'p',     'q',     'r',     's',     't',     'u',     'v',     'w',
-/*  88  X    89  Y    90  Z    91  [    92  \    93  ]    94  ^    95  _  */
-       'x',     'y',     'z',      0,       0,       0,      '^',     '_',
-/*  96  `    97  a    98  b    99  c   100  d   101  e   102  f   103  g  */
-       '`',     'a',     'b',     'c',     'd',     'e',     'f',     'g',
-/* 104  h   105  i   106  j   107  k   108  l   109  m   110  n   111  o  */
-       'h',     'i',     'j',     'k',     'l',     'm',     'n',     'o',
-/* 112  p   113  q   114  r   115  s   116  t   117  u   118  v   119  w  */
-       'p',     'q',     'r',     's',     't',     'u',     'v',     'w',
-/* 120  x   121  y   122  z   123  {   124  |   125  }   126  ~   127 del */
-       'x',     'y',     'z',      0,      '|',      0,      '~',       0 };
-
-
-static const int8_t unhex[256] =
-  {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
-  ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  };
-
-
-#if HTTP_PARSER_STRICT
-# define T(v) 0
-#else
-# define T(v) v
-#endif
-
-
-static const uint8_t normal_url_char[32] = {
-/*   0 nul    1 soh    2 stx    3 etx    4 eot    5 enq    6 ack    7 bel  */
-        0    |   0    |   0    |   0    |   0    |   0    |   0    |   0,
-/*   8 bs     9 ht    10 nl    11 vt    12 np    13 cr    14 so    15 si   */
-        0    | T(2)   |   0    |   0    | T(16)  |   0    |   0    |   0,
-/*  16 dle   17 dc1   18 dc2   19 dc3   20 dc4   21 nak   22 syn   23 etb */
-        0    |   0    |   0    |   0    |   0    |   0    |   0    |   0,
-/*  24 can   25 em    26 sub   27 esc   28 fs    29 gs    30 rs    31 us  */
-        0    |   0    |   0    |   0    |   0    |   0    |   0    |   0,
-/*  32 sp    33  !    34  "    35  #    36  $    37  %    38  &    39  '  */
-        0    |   2    |   4    |   0    |   16   |   32   |   64   |  128,
-/*  40  (    41  )    42  *    43  +    44  ,    45  -    46  .    47  /  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  48  0    49  1    50  2    51  3    52  4    53  5    54  6    55  7  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  56  8    57  9    58  :    59  ;    60  <    61  =    62  >    63  ?  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |   0,
-/*  64  @    65  A    66  B    67  C    68  D    69  E    70  F    71  G  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  72  H    73  I    74  J    75  K    76  L    77  M    78  N    79  O  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  80  P    81  Q    82  R    83  S    84  T    85  U    86  V    87  W  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  88  X    89  Y    90  Z    91  [    92  \    93  ]    94  ^    95  _  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  96  `    97  a    98  b    99  c   100  d   101  e   102  f   103  g  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/* 104  h   105  i   106  j   107  k   108  l   109  m   110  n   111  o  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/* 112  p   113  q   114  r   115  s   116  t   117  u   118  v   119  w  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/* 120  x   121  y   122  z   123  {   124  |   125  }   126  ~   127 del */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |   0, };
-
-#undef T
-
-enum state
-  { s_dead = 1 /* important that this is > 0 */
-
-  , s_start_req_or_res
-  , s_res_or_resp_H
-  , s_start_res
-  , s_res_H
-  , s_res_HT
-  , s_res_HTT
-  , s_res_HTTP
-  , s_res_http_major
-  , s_res_http_dot
-  , s_res_http_minor
-  , s_res_http_end
-  , s_res_first_status_code
-  , s_res_status_code
-  , s_res_status_start
-  , s_res_status
-  , s_res_line_almost_done
-
-  , s_start_req
-
-  , s_req_method
-  , s_req_spaces_before_url
-  , s_req_schema
-  , s_req_schema_slash
-  , s_req_schema_slash_slash
-  , s_req_server_start
-  , s_req_server
-  , s_req_server_with_at
-  , s_req_path
-  , s_req_query_string_start
-  , s_req_query_string
-  , s_req_fragment_start
-  , s_req_fragment
-  , s_req_http_start
-  , s_req_http_H
-  , s_req_http_HT
-  , s_req_http_HTT
-  , s_req_http_HTTP
-  , s_req_http_I
-  , s_req_http_IC
-  , s_req_http_major
-  , s_req_http_dot
-  , s_req_http_minor
-  , s_req_http_end
-  , s_req_line_almost_done
-
-  , s_header_field_start
-  , s_header_field
-  , s_header_value_discard_ws
-  , s_header_value_discard_ws_almost_done
-  , s_header_value_discard_lws
-  , s_header_value_start
-  , s_header_value
-  , s_header_value_lws
-
-  , s_header_almost_done
-
-  , s_chunk_size_start
-  , s_chunk_size
-  , s_chunk_parameters
-  , s_chunk_size_almost_done
-
-  , s_headers_almost_done
-  , s_headers_done
-
-  /* Important: 's_headers_done' must be the last 'header' state. All
-   * states beyond this must be 'body' states. It is used for overflow
-   * checking. See the PARSING_HEADER() macro.
-   */
-
-  , s_chunk_data
-  , s_chunk_data_almost_done
-  , s_chunk_data_done
-
-  , s_body_identity
-  , s_body_identity_eof
-
-  , s_message_done
-  };
-
-
-#define PARSING_HEADER(state) (state <= s_headers_done)
-
-
-enum header_states
-  { h_general = 0
-  , h_C
-  , h_CO
-  , h_CON
-
-  , h_matching_connection
-  , h_matching_proxy_connection
-  , h_matching_content_length
-  , h_matching_transfer_encoding
-  , h_matching_upgrade
-
-  , h_connection
-  , h_content_length
-  , h_content_length_num
-  , h_content_length_ws
-  , h_transfer_encoding
-  , h_upgrade
-
-  , h_matching_transfer_encoding_token_start
-  , h_matching_transfer_encoding_chunked
-  , h_matching_transfer_encoding_token
-
-  , h_matching_connection_token_start
-  , h_matching_connection_keep_alive
-  , h_matching_connection_close
-  , h_matching_connection_upgrade
-  , h_matching_connection_token
-
-  , h_transfer_encoding_chunked
-  , h_connection_keep_alive
-  , h_connection_close
-  , h_connection_upgrade
-  };
-
-enum http_host_state
-  {
-    s_http_host_dead = 1
-  , s_http_userinfo_start
-  , s_http_userinfo
-  , s_http_host_start
-  , s_http_host_v6_start
-  , s_http_host
-  , s_http_host_v6
-  , s_http_host_v6_end
-  , s_http_host_v6_zone_start
-  , s_http_host_v6_zone
-  , s_http_host_port_start
-  , s_http_host_port
-};
-
-/* Macros for character classes; depends on strict-mode  */
-#define CR                  '\r'
-#define LF                  '\n'
-#define LOWER(c)            (unsigned char)(c | 0x20)
-#define IS_ALPHA(c)         (LOWER(c) >= 'a' && LOWER(c) <= 'z')
-#define IS_NUM(c)           ((c) >= '0' && (c) <= '9')
-#define IS_ALPHANUM(c)      (IS_ALPHA(c) || IS_NUM(c))
-#define IS_HEX(c)           (IS_NUM(c) || (LOWER(c) >= 'a' && LOWER(c) <= 'f'))
-#define IS_MARK(c)          ((c) == '-' || (c) == '_' || (c) == '.' || \
-  (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \
-  (c) == ')')
-#define IS_USERINFO_CHAR(c) (IS_ALPHANUM(c) || IS_MARK(c) || (c) == '%' || \
-  (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \
-  (c) == '$' || (c) == ',')
-
-#define STRICT_TOKEN(c)     ((c == ' ') ? 0 : tokens[(unsigned char)c])
-
-#if HTTP_PARSER_STRICT
-#define TOKEN(c)            STRICT_TOKEN(c)
-#define IS_URL_CHAR(c)      (BIT_AT(normal_url_char, (unsigned char)c))
-#define IS_HOST_CHAR(c)     (IS_ALPHANUM(c) || (c) == '.' || (c) == '-')
-#else
-#define TOKEN(c)            tokens[(unsigned char)c]
-#define IS_URL_CHAR(c)                                                         \
-  (BIT_AT(normal_url_char, (unsigned char)c) || ((c) & 0x80))
-#define IS_HOST_CHAR(c)                                                        \
-  (IS_ALPHANUM(c) || (c) == '.' || (c) == '-' || (c) == '_')
-#endif
-
-/**
- * Verify that a char is a valid visible (printable) US-ASCII
- * character or %x80-FF
- **/
-#define IS_HEADER_CHAR(ch)                                                     \
-  (ch == CR || ch == LF || ch == 9 || ((unsigned char)ch > 31 && ch != 127))
-
-#define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res)
-
-
-#if HTTP_PARSER_STRICT
-# define STRICT_CHECK(cond)                                          \
-do {                                                                 \
-  if (cond) {                                                        \
-    SET_ERRNO(HPE_STRICT);                                           \
-    goto error;                                                      \
-  }                                                                  \
-} while (0)
-# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead)
-#else
-# define STRICT_CHECK(cond)
-# define NEW_MESSAGE() start_state
-#endif
-
-
-/* Map errno values to strings for human-readable output */
-#define HTTP_STRERROR_GEN(n, s) { "HPE_" #n, s },
-static struct {
-  const char *name;
-  const char *description;
-} http_strerror_tab[] = {
-  HTTP_ERRNO_MAP(HTTP_STRERROR_GEN)
-};
-#undef HTTP_STRERROR_GEN
-
-int http_message_needs_eof(const http_parser *parser);
-
-/* Our URL parser.
- *
- * This is designed to be shared by http_parser_execute() for URL validation,
- * hence it has a state transition + byte-for-byte interface. In addition, it
- * is meant to be embedded in http_parser_parse_url(), which does the dirty
- * work of turning state transitions URL components for its API.
- *
- * This function should only be invoked with non-space characters. It is
- * assumed that the caller cares about (and can detect) the transition between
- * URL and non-URL states by looking for these.
- */
-static enum state
-parse_url_char(enum state s, const char ch)
-{
-  if (ch == ' ' || ch == '\r' || ch == '\n') {
-    return s_dead;
-  }
-
-#if HTTP_PARSER_STRICT
-  if (ch == '\t' || ch == '\f') {
-    return s_dead;
-  }
-#endif
-
-  switch (s) {
-    case s_req_spaces_before_url:
-      /* Proxied requests are followed by scheme of an absolute URI (alpha).
-       * All methods except CONNECT are followed by '/' or '*'.
-       */
-
-      if (ch == '/' || ch == '*') {
-        return s_req_path;
-      }
-
-      if (IS_ALPHA(ch)) {
-        return s_req_schema;
-      }
-
-      break;
-
-    case s_req_schema:
-      if (IS_ALPHA(ch)) {
-        return s;
-      }
-
-      if (ch == ':') {
-        return s_req_schema_slash;
-      }
-
-      break;
-
-    case s_req_schema_slash:
-      if (ch == '/') {
-        return s_req_schema_slash_slash;
-      }
-
-      break;
-
-    case s_req_schema_slash_slash:
-      if (ch == '/') {
-        return s_req_server_start;
-      }
-
-      break;
-
-    case s_req_server_with_at:
-      if (ch == '@') {
-        return s_dead;
-      }
-
-    /* fall through */
-    case s_req_server_start:
-    case s_req_server:
-      if (ch == '/') {
-        return s_req_path;
-      }
-
-      if (ch == '?') {
-        return s_req_query_string_start;
-      }
-
-      if (ch == '@') {
-        return s_req_server_with_at;
-      }
-
-      if (IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') {
-        return s_req_server;
-      }
-
-      break;
-
-    case s_req_path:
-      if (IS_URL_CHAR(ch)) {
-        return s;
-      }
-
-      switch (ch) {
-        case '?':
-          return s_req_query_string_start;
-
-        case '#':
-          return s_req_fragment_start;
-      }
-
-      break;
-
-    case s_req_query_string_start:
-    case s_req_query_string:
-      if (IS_URL_CHAR(ch)) {
-        return s_req_query_string;
-      }
-
-      switch (ch) {
-        case '?':
-          /* allow extra '?' in query string */
-          return s_req_query_string;
-
-        case '#':
-          return s_req_fragment_start;
-      }
-
-      break;
-
-    case s_req_fragment_start:
-      if (IS_URL_CHAR(ch)) {
-        return s_req_fragment;
-      }
-
-      switch (ch) {
-        case '?':
-          return s_req_fragment;
-
-        case '#':
-          return s;
-      }
-
-      break;
-
-    case s_req_fragment:
-      if (IS_URL_CHAR(ch)) {
-        return s;
-      }
-
-      switch (ch) {
-        case '?':
-        case '#':
-          return s;
-      }
-
-      break;
-
-    default:
-      break;
-  }
-
-  /* We should never fall out of the switch above unless there's an error */
-  return s_dead;
-}
-
-size_t http_parser_execute (http_parser *parser,
-                            const http_parser_settings *settings,
-                            const char *data,
-                            size_t len)
-{
-  char c, ch;
-  int8_t unhex_val;
-  const char *p = data;
-  const char *header_field_mark = 0;
-  const char *header_value_mark = 0;
-  const char *url_mark = 0;
-  const char *body_mark = 0;
-  const char *status_mark = 0;
-  enum state p_state = (enum state) parser->state;
-  const unsigned int lenient = parser->lenient_http_headers;
-  const unsigned int allow_chunked_length = parser->allow_chunked_length;
-
-  uint32_t nread = parser->nread;
-
-  /* We're in an error state. Don't bother doing anything. */
-  if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
-    return 0;
-  }
-
-  if (len == 0) {
-    switch (CURRENT_STATE()) {
-      case s_body_identity_eof:
-        /* Use of CALLBACK_NOTIFY() here would erroneously return 1 byte read if
-         * we got paused.
-         */
-        CALLBACK_NOTIFY_NOADVANCE(message_complete);
-        return 0;
-
-      case s_dead:
-      case s_start_req_or_res:
-      case s_start_res:
-      case s_start_req:
-        return 0;
-
-      default:
-        SET_ERRNO(HPE_INVALID_EOF_STATE);
-        return 1;
-    }
-  }
-
-
-  if (CURRENT_STATE() == s_header_field)
-    header_field_mark = data;
-  if (CURRENT_STATE() == s_header_value)
-    header_value_mark = data;
-  switch (CURRENT_STATE()) {
-  case s_req_path:
-  case s_req_schema:
-  case s_req_schema_slash:
-  case s_req_schema_slash_slash:
-  case s_req_server_start:
-  case s_req_server:
-  case s_req_server_with_at:
-  case s_req_query_string_start:
-  case s_req_query_string:
-  case s_req_fragment_start:
-  case s_req_fragment:
-    url_mark = data;
-    break;
-  case s_res_status:
-    status_mark = data;
-    break;
-  default:
-    break;
-  }
-
-  for (p=data; p != data + len; p++) {
-    ch = *p;
-
-    if (PARSING_HEADER(CURRENT_STATE()))
-      COUNT_HEADER_SIZE(1);
-
-reexecute:
-    switch (CURRENT_STATE()) {
-
-      case s_dead:
-        /* this state is used after a 'Connection: close' message
-         * the parser will error out if it reads another message
-         */
-        if (LIKELY(ch == CR || ch == LF))
-          break;
-
-        SET_ERRNO(HPE_CLOSED_CONNECTION);
-        goto error;
-
-      case s_start_req_or_res:
-      {
-        if (ch == CR || ch == LF)
-          break;
-        parser->flags = 0;
-        parser->uses_transfer_encoding = 0;
-        parser->content_length = ULLONG_MAX;
-
-        if (ch == 'H') {
-          UPDATE_STATE(s_res_or_resp_H);
-
-          CALLBACK_NOTIFY(message_begin);
-        } else {
-          parser->type = HTTP_REQUEST;
-          UPDATE_STATE(s_start_req);
-          REEXECUTE();
-        }
-
-        break;
-      }
-
-      case s_res_or_resp_H:
-        if (ch == 'T') {
-          parser->type = HTTP_RESPONSE;
-          UPDATE_STATE(s_res_HT);
-        } else {
-          if (UNLIKELY(ch != 'E')) {
-            SET_ERRNO(HPE_INVALID_CONSTANT);
-            goto error;
-          }
-
-          parser->type = HTTP_REQUEST;
-          parser->method = HTTP_HEAD;
-          parser->index = 2;
-          UPDATE_STATE(s_req_method);
-        }
-        break;
-
-      case s_start_res:
-      {
-        if (ch == CR || ch == LF)
-          break;
-        parser->flags = 0;
-        parser->uses_transfer_encoding = 0;
-        parser->content_length = ULLONG_MAX;
-
-        if (ch == 'H') {
-          UPDATE_STATE(s_res_H);
-        } else {
-          SET_ERRNO(HPE_INVALID_CONSTANT);
-          goto error;
-        }
-
-        CALLBACK_NOTIFY(message_begin);
-        break;
-      }
-
-      case s_res_H:
-        STRICT_CHECK(ch != 'T');
-        UPDATE_STATE(s_res_HT);
-        break;
-
-      case s_res_HT:
-        STRICT_CHECK(ch != 'T');
-        UPDATE_STATE(s_res_HTT);
-        break;
-
-      case s_res_HTT:
-        STRICT_CHECK(ch != 'P');
-        UPDATE_STATE(s_res_HTTP);
-        break;
-
-      case s_res_HTTP:
-        STRICT_CHECK(ch != '/');
-        UPDATE_STATE(s_res_http_major);
-        break;
-
-      case s_res_http_major:
-        if (UNLIKELY(!IS_NUM(ch))) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        parser->http_major = ch - '0';
-        UPDATE_STATE(s_res_http_dot);
-        break;
-
-      case s_res_http_dot:
-      {
-        if (UNLIKELY(ch != '.')) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        UPDATE_STATE(s_res_http_minor);
-        break;
-      }
-
-      case s_res_http_minor:
-        if (UNLIKELY(!IS_NUM(ch))) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        parser->http_minor = ch - '0';
-        UPDATE_STATE(s_res_http_end);
-        break;
-
-      case s_res_http_end:
-      {
-        if (UNLIKELY(ch != ' ')) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        UPDATE_STATE(s_res_first_status_code);
-        break;
-      }
-
-      case s_res_first_status_code:
-      {
-        if (!IS_NUM(ch)) {
-          if (ch == ' ') {
-            break;
-          }
-
-          SET_ERRNO(HPE_INVALID_STATUS);
-          goto error;
-        }
-        parser->status_code = ch - '0';
-        UPDATE_STATE(s_res_status_code);
-        break;
-      }
-
-      case s_res_status_code:
-      {
-        if (!IS_NUM(ch)) {
-          switch (ch) {
-            case ' ':
-              UPDATE_STATE(s_res_status_start);
-              break;
-            case CR:
-            case LF:
-              UPDATE_STATE(s_res_status_start);
-              REEXECUTE();
-              break;
-            default:
-              SET_ERRNO(HPE_INVALID_STATUS);
-              goto error;
-          }
-          break;
-        }
-
-        parser->status_code *= 10;
-        parser->status_code += ch - '0';
-
-        if (UNLIKELY(parser->status_code > 999)) {
-          SET_ERRNO(HPE_INVALID_STATUS);
-          goto error;
-        }
-
-        break;
-      }
-
-      case s_res_status_start:
-      {
-        MARK(status);
-        UPDATE_STATE(s_res_status);
-        parser->index = 0;
-
-        if (ch == CR || ch == LF)
-          REEXECUTE();
-
-        break;
-      }
-
-      case s_res_status:
-        if (ch == CR) {
-          UPDATE_STATE(s_res_line_almost_done);
-          CALLBACK_DATA(status);
-          break;
-        }
-
-        if (ch == LF) {
-          UPDATE_STATE(s_header_field_start);
-          CALLBACK_DATA(status);
-          break;
-        }
-
-        break;
-
-      case s_res_line_almost_done:
-        STRICT_CHECK(ch != LF);
-        UPDATE_STATE(s_header_field_start);
-        break;
-
-      case s_start_req:
-      {
-        if (ch == CR || ch == LF)
-          break;
-        parser->flags = 0;
-        parser->uses_transfer_encoding = 0;
-        parser->content_length = ULLONG_MAX;
-
-        if (UNLIKELY(!IS_ALPHA(ch))) {
-          SET_ERRNO(HPE_INVALID_METHOD);
-          goto error;
-        }
-
-        parser->method = (enum http_method) 0;
-        parser->index = 1;
-        switch (ch) {
-          case 'A': parser->method = HTTP_ACL; break;
-          case 'B': parser->method = HTTP_BIND; break;
-          case 'C': parser->method = HTTP_CONNECT; /* or COPY, CHECKOUT */ break;
-          case 'D': parser->method = HTTP_DELETE; break;
-          case 'G': parser->method = HTTP_GET; break;
-          case 'H': parser->method = HTTP_HEAD; break;
-          case 'L': parser->method = HTTP_LOCK; /* or LINK */ break;
-          case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH, MKCALENDAR */ break;
-          case 'N': parser->method = HTTP_NOTIFY; break;
-          case 'O': parser->method = HTTP_OPTIONS; break;
-          case 'P': parser->method = HTTP_POST;
-            /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */
-            break;
-          case 'R': parser->method = HTTP_REPORT; /* or REBIND */ break;
-          case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH, SOURCE */ break;
-          case 'T': parser->method = HTTP_TRACE; break;
-          case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE, UNBIND, UNLINK */ break;
-          default:
-            SET_ERRNO(HPE_INVALID_METHOD);
-            goto error;
-        }
-        UPDATE_STATE(s_req_method);
-
-        CALLBACK_NOTIFY(message_begin);
-
-        break;
-      }
-
-      case s_req_method:
-      {
-        const char *matcher;
-        if (UNLIKELY(ch == '\0')) {
-          SET_ERRNO(HPE_INVALID_METHOD);
-          goto error;
-        }
-
-        matcher = method_strings[parser->method];
-        if (ch == ' ' && matcher[parser->index] == '\0') {
-          UPDATE_STATE(s_req_spaces_before_url);
-        } else if (ch == matcher[parser->index]) {
-          ; /* nada */
-        } else if ((ch >= 'A' && ch <= 'Z') || ch == '-') {
-
-          switch (parser->method << 16 | parser->index << 8 | ch) {
-#define XX(meth, pos, ch, new_meth) \
-            case (HTTP_##meth << 16 | pos << 8 | ch): \
-              parser->method = HTTP_##new_meth; break;
-
-            XX(POST,      1, 'U', PUT)
-            XX(POST,      1, 'A', PATCH)
-            XX(POST,      1, 'R', PROPFIND)
-            XX(PUT,       2, 'R', PURGE)
-            XX(CONNECT,   1, 'H', CHECKOUT)
-            XX(CONNECT,   2, 'P', COPY)
-            XX(MKCOL,     1, 'O', MOVE)
-            XX(MKCOL,     1, 'E', MERGE)
-            XX(MKCOL,     1, '-', MSEARCH)
-            XX(MKCOL,     2, 'A', MKACTIVITY)
-            XX(MKCOL,     3, 'A', MKCALENDAR)
-            XX(SUBSCRIBE, 1, 'E', SEARCH)
-            XX(SUBSCRIBE, 1, 'O', SOURCE)
-            XX(REPORT,    2, 'B', REBIND)
-            XX(PROPFIND,  4, 'P', PROPPATCH)
-            XX(LOCK,      1, 'I', LINK)
-            XX(UNLOCK,    2, 'S', UNSUBSCRIBE)
-            XX(UNLOCK,    2, 'B', UNBIND)
-            XX(UNLOCK,    3, 'I', UNLINK)
-#undef XX
-            default:
-              SET_ERRNO(HPE_INVALID_METHOD);
-              goto error;
-          }
-        } else {
-          SET_ERRNO(HPE_INVALID_METHOD);
-          goto error;
-        }
-
-        ++parser->index;
-        break;
-      }
-
-      case s_req_spaces_before_url:
-      {
-        if (ch == ' ') break;
-
-        MARK(url);
-        if (parser->method == HTTP_CONNECT) {
-          UPDATE_STATE(s_req_server_start);
-        }
-
-        UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch));
-        if (UNLIKELY(CURRENT_STATE() == s_dead)) {
-          SET_ERRNO(HPE_INVALID_URL);
-          goto error;
-        }
-
-        break;
-      }
-
-      case s_req_schema:
-      case s_req_schema_slash:
-      case s_req_schema_slash_slash:
-      case s_req_server_start:
-      {
-        switch (ch) {
-          /* No whitespace allowed here */
-          case ' ':
-          case CR:
-          case LF:
-            SET_ERRNO(HPE_INVALID_URL);
-            goto error;
-          default:
-            UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch));
-            if (UNLIKELY(CURRENT_STATE() == s_dead)) {
-              SET_ERRNO(HPE_INVALID_URL);
-              goto error;
-            }
-        }
-
-        break;
-      }
-
-      case s_req_server:
-      case s_req_server_with_at:
-      case s_req_path:
-      case s_req_query_string_start:
-      case s_req_query_string:
-      case s_req_fragment_start:
-      case s_req_fragment:
-      {
-        switch (ch) {
-          case ' ':
-            UPDATE_STATE(s_req_http_start);
-            CALLBACK_DATA(url);
-            break;
-          case CR:
-          case LF:
-            parser->http_major = 0;
-            parser->http_minor = 9;
-            UPDATE_STATE((ch == CR) ?
-              s_req_line_almost_done :
-              s_header_field_start);
-            CALLBACK_DATA(url);
-            break;
-          default:
-            UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch));
-            if (UNLIKELY(CURRENT_STATE() == s_dead)) {
-              SET_ERRNO(HPE_INVALID_URL);
-              goto error;
-            }
-        }
-        break;
-      }
-
-      case s_req_http_start:
-        switch (ch) {
-          case ' ':
-            break;
-          case 'H':
-            UPDATE_STATE(s_req_http_H);
-            break;
-          case 'I':
-            if (parser->method == HTTP_SOURCE) {
-              UPDATE_STATE(s_req_http_I);
-              break;
-            }
-            /* fall through */
-          default:
-            SET_ERRNO(HPE_INVALID_CONSTANT);
-            goto error;
-        }
-        break;
-
-      case s_req_http_H:
-        STRICT_CHECK(ch != 'T');
-        UPDATE_STATE(s_req_http_HT);
-        break;
-
-      case s_req_http_HT:
-        STRICT_CHECK(ch != 'T');
-        UPDATE_STATE(s_req_http_HTT);
-        break;
-
-      case s_req_http_HTT:
-        STRICT_CHECK(ch != 'P');
-        UPDATE_STATE(s_req_http_HTTP);
-        break;
-
-      case s_req_http_I:
-        STRICT_CHECK(ch != 'C');
-        UPDATE_STATE(s_req_http_IC);
-        break;
-
-      case s_req_http_IC:
-        STRICT_CHECK(ch != 'E');
-        UPDATE_STATE(s_req_http_HTTP);  /* Treat "ICE" as "HTTP". */
-        break;
-
-      case s_req_http_HTTP:
-        STRICT_CHECK(ch != '/');
-        UPDATE_STATE(s_req_http_major);
-        break;
-
-      case s_req_http_major:
-        if (UNLIKELY(!IS_NUM(ch))) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        parser->http_major = ch - '0';
-        UPDATE_STATE(s_req_http_dot);
-        break;
-
-      case s_req_http_dot:
-      {
-        if (UNLIKELY(ch != '.')) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        UPDATE_STATE(s_req_http_minor);
-        break;
-      }
-
-      case s_req_http_minor:
-        if (UNLIKELY(!IS_NUM(ch))) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        parser->http_minor = ch - '0';
-        UPDATE_STATE(s_req_http_end);
-        break;
-
-      case s_req_http_end:
-      {
-        if (ch == CR) {
-          UPDATE_STATE(s_req_line_almost_done);
-          break;
-        }
-
-        if (ch == LF) {
-          UPDATE_STATE(s_header_field_start);
-          break;
-        }
-
-        SET_ERRNO(HPE_INVALID_VERSION);
-        goto error;
-        break;
-      }
-
-      /* end of request line */
-      case s_req_line_almost_done:
-      {
-        if (UNLIKELY(ch != LF)) {
-          SET_ERRNO(HPE_LF_EXPECTED);
-          goto error;
-        }
-
-        UPDATE_STATE(s_header_field_start);
-        break;
-      }
-
-      case s_header_field_start:
-      {
-        if (ch == CR) {
-          UPDATE_STATE(s_headers_almost_done);
-          break;
-        }
-
-        if (ch == LF) {
-          /* they might be just sending \n instead of \r\n so this would be
-           * the second \n to denote the end of headers*/
-          UPDATE_STATE(s_headers_almost_done);
-          REEXECUTE();
-        }
-
-        c = TOKEN(ch);
-
-        if (UNLIKELY(!c)) {
-          SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
-          goto error;
-        }
-
-        MARK(header_field);
-
-        parser->index = 0;
-        UPDATE_STATE(s_header_field);
-
-        switch (c) {
-          case 'c':
-            parser->header_state = h_C;
-            break;
-
-          case 'p':
-            parser->header_state = h_matching_proxy_connection;
-            break;
-
-          case 't':
-            parser->header_state = h_matching_transfer_encoding;
-            break;
-
-          case 'u':
-            parser->header_state = h_matching_upgrade;
-            break;
-
-          default:
-            parser->header_state = h_general;
-            break;
-        }
-        break;
-      }
-
-      case s_header_field:
-      {
-        const char* start = p;
-        for (; p != data + len; p++) {
-          ch = *p;
-          c = TOKEN(ch);
-
-          if (!c)
-            break;
-
-          switch (parser->header_state) {
-            case h_general: {
-              size_t left = data + len - p;
-              const char* pe = p + MIN(left, max_header_size);
-              while (p+1 < pe && TOKEN(p[1])) {
-                p++;
-              }
-              break;
-            }
-
-            case h_C:
-              parser->index++;
-              parser->header_state = (c == 'o' ? h_CO : h_general);
-              break;
-
-            case h_CO:
-              parser->index++;
-              parser->header_state = (c == 'n' ? h_CON : h_general);
-              break;
-
-            case h_CON:
-              parser->index++;
-              switch (c) {
-                case 'n':
-                  parser->header_state = h_matching_connection;
-                  break;
-                case 't':
-                  parser->header_state = h_matching_content_length;
-                  break;
-                default:
-                  parser->header_state = h_general;
-                  break;
-              }
-              break;
-
-            /* connection */
-
-            case h_matching_connection:
-              parser->index++;
-              if (parser->index > sizeof(CONNECTION)-1
-                  || c != CONNECTION[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(CONNECTION)-2) {
-                parser->header_state = h_connection;
-              }
-              break;
-
-            /* proxy-connection */
-
-            case h_matching_proxy_connection:
-              parser->index++;
-              if (parser->index > sizeof(PROXY_CONNECTION)-1
-                  || c != PROXY_CONNECTION[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(PROXY_CONNECTION)-2) {
-                parser->header_state = h_connection;
-              }
-              break;
-
-            /* content-length */
-
-            case h_matching_content_length:
-              parser->index++;
-              if (parser->index > sizeof(CONTENT_LENGTH)-1
-                  || c != CONTENT_LENGTH[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(CONTENT_LENGTH)-2) {
-                parser->header_state = h_content_length;
-              }
-              break;
-
-            /* transfer-encoding */
-
-            case h_matching_transfer_encoding:
-              parser->index++;
-              if (parser->index > sizeof(TRANSFER_ENCODING)-1
-                  || c != TRANSFER_ENCODING[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(TRANSFER_ENCODING)-2) {
-                parser->header_state = h_transfer_encoding;
-                parser->uses_transfer_encoding = 1;
-
-                /* Multiple `Transfer-Encoding` headers should be treated as
-                 * one, but with values separate by a comma.
-                 *
-                 * See: https://tools.ietf.org/html/rfc7230#section-3.2.2
-                 */
-                parser->flags &= ~F_CHUNKED;
-              }
-              break;
-
-            /* upgrade */
-
-            case h_matching_upgrade:
-              parser->index++;
-              if (parser->index > sizeof(UPGRADE)-1
-                  || c != UPGRADE[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(UPGRADE)-2) {
-                parser->header_state = h_upgrade;
-              }
-              break;
-
-            case h_connection:
-            case h_content_length:
-            case h_transfer_encoding:
-            case h_upgrade:
-              if (ch != ' ') parser->header_state = h_general;
-              break;
-
-            default:
-              assert(0 && "Unknown header_state");
-              break;
-          }
-        }
-
-        if (p == data + len) {
-          --p;
-          COUNT_HEADER_SIZE(p - start);
-          break;
-        }
-
-        COUNT_HEADER_SIZE(p - start);
-
-        if (ch == ':') {
-          UPDATE_STATE(s_header_value_discard_ws);
-          CALLBACK_DATA(header_field);
-          break;
-        }
-
-        SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
-        goto error;
-      }
-
-      case s_header_value_discard_ws:
-        if (ch == ' ' || ch == '\t') break;
-
-        if (ch == CR) {
-          UPDATE_STATE(s_header_value_discard_ws_almost_done);
-          break;
-        }
-
-        if (ch == LF) {
-          UPDATE_STATE(s_header_value_discard_lws);
-          break;
-        }
-
-        /* fall through */
-
-      case s_header_value_start:
-      {
-        MARK(header_value);
-
-        UPDATE_STATE(s_header_value);
-        parser->index = 0;
-
-        c = LOWER(ch);
-
-        switch (parser->header_state) {
-          case h_upgrade:
-            parser->flags |= F_UPGRADE;
-            parser->header_state = h_general;
-            break;
-
-          case h_transfer_encoding:
-            /* looking for 'Transfer-Encoding: chunked' */
-            if ('c' == c) {
-              parser->header_state = h_matching_transfer_encoding_chunked;
-            } else {
-              parser->header_state = h_matching_transfer_encoding_token;
-            }
-            break;
-
-          /* Multi-value `Transfer-Encoding` header */
-          case h_matching_transfer_encoding_token_start:
-            break;
-
-          case h_content_length:
-            if (UNLIKELY(!IS_NUM(ch))) {
-              SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-              goto error;
-            }
-
-            if (parser->flags & F_CONTENTLENGTH) {
-              SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH);
-              goto error;
-            }
-
-            parser->flags |= F_CONTENTLENGTH;
-            parser->content_length = ch - '0';
-            parser->header_state = h_content_length_num;
-            break;
-
-          /* when obsolete line folding is encountered for content length
-           * continue to the s_header_value state */
-          case h_content_length_ws:
-            break;
-
-          case h_connection:
-            /* looking for 'Connection: keep-alive' */
-            if (c == 'k') {
-              parser->header_state = h_matching_connection_keep_alive;
-            /* looking for 'Connection: close' */
-            } else if (c == 'c') {
-              parser->header_state = h_matching_connection_close;
-            } else if (c == 'u') {
-              parser->header_state = h_matching_connection_upgrade;
-            } else {
-              parser->header_state = h_matching_connection_token;
-            }
-            break;
-
-          /* Multi-value `Connection` header */
-          case h_matching_connection_token_start:
-            break;
-
-          default:
-            parser->header_state = h_general;
-            break;
-        }
-        break;
-      }
-
-      case s_header_value:
-      {
-        const char* start = p;
-        enum header_states h_state = (enum header_states) parser->header_state;
-        for (; p != data + len; p++) {
-          ch = *p;
-          if (ch == CR) {
-            UPDATE_STATE(s_header_almost_done);
-            parser->header_state = h_state;
-            CALLBACK_DATA(header_value);
-            break;
-          }
-
-          if (ch == LF) {
-            UPDATE_STATE(s_header_almost_done);
-            COUNT_HEADER_SIZE(p - start);
-            parser->header_state = h_state;
-            CALLBACK_DATA_NOADVANCE(header_value);
-            REEXECUTE();
-          }
-
-          if (!lenient && !IS_HEADER_CHAR(ch)) {
-            SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
-            goto error;
-          }
-
-          c = LOWER(ch);
-
-          switch (h_state) {
-            case h_general:
-              {
-                size_t left = data + len - p;
-                const char* pe = p + MIN(left, max_header_size);
-
-                for (; p != pe; p++) {
-                  ch = *p;
-                  if (ch == CR || ch == LF) {
-                    --p;
-                    break;
-                  }
-                  if (!lenient && !IS_HEADER_CHAR(ch)) {
-                    SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
-                    goto error;
-                  }
-                }
-                if (p == data + len)
-                  --p;
-                break;
-              }
-
-            case h_connection:
-            case h_transfer_encoding:
-              assert(0 && "Shouldn't get here.");
-              break;
-
-            case h_content_length:
-              if (ch == ' ') break;
-              h_state = h_content_length_num;
-              /* fall through */
-
-            case h_content_length_num:
-            {
-              uint64_t t;
-
-              if (ch == ' ') {
-                h_state = h_content_length_ws;
-                break;
-              }
-
-              if (UNLIKELY(!IS_NUM(ch))) {
-                SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-                parser->header_state = h_state;
-                goto error;
-              }
-
-              t = parser->content_length;
-              t *= 10;
-              t += ch - '0';
-
-              /* Overflow? Test against a conservative limit for simplicity. */
-              if (UNLIKELY((ULLONG_MAX - 10) / 10 < parser->content_length)) {
-                SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-                parser->header_state = h_state;
-                goto error;
-              }
-
-              parser->content_length = t;
-              break;
-            }
-
-            case h_content_length_ws:
-              if (ch == ' ') break;
-              SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-              parser->header_state = h_state;
-              goto error;
-
-            /* Transfer-Encoding: chunked */
-            case h_matching_transfer_encoding_token_start:
-              /* looking for 'Transfer-Encoding: chunked' */
-              if ('c' == c) {
-                h_state = h_matching_transfer_encoding_chunked;
-              } else if (STRICT_TOKEN(c)) {
-                /* TODO(indutny): similar code below does this, but why?
-                 * At the very least it seems to be inconsistent given that
-                 * h_matching_transfer_encoding_token does not check for
-                 * `STRICT_TOKEN`
-                 */
-                h_state = h_matching_transfer_encoding_token;
-              } else if (c == ' ' || c == '\t') {
-                /* Skip lws */
-              } else {
-                h_state = h_general;
-              }
-              break;
-
-            case h_matching_transfer_encoding_chunked:
-              parser->index++;
-              if (parser->index > sizeof(CHUNKED)-1
-                  || c != CHUNKED[parser->index]) {
-                h_state = h_matching_transfer_encoding_token;
-              } else if (parser->index == sizeof(CHUNKED)-2) {
-                h_state = h_transfer_encoding_chunked;
-              }
-              break;
-
-            case h_matching_transfer_encoding_token:
-              if (ch == ',') {
-                h_state = h_matching_transfer_encoding_token_start;
-                parser->index = 0;
-              }
-              break;
-
-            case h_matching_connection_token_start:
-              /* looking for 'Connection: keep-alive' */
-              if (c == 'k') {
-                h_state = h_matching_connection_keep_alive;
-              /* looking for 'Connection: close' */
-              } else if (c == 'c') {
-                h_state = h_matching_connection_close;
-              } else if (c == 'u') {
-                h_state = h_matching_connection_upgrade;
-              } else if (STRICT_TOKEN(c)) {
-                h_state = h_matching_connection_token;
-              } else if (c == ' ' || c == '\t') {
-                /* Skip lws */
-              } else {
-                h_state = h_general;
-              }
-              break;
-
-            /* looking for 'Connection: keep-alive' */
-            case h_matching_connection_keep_alive:
-              parser->index++;
-              if (parser->index > sizeof(KEEP_ALIVE)-1
-                  || c != KEEP_ALIVE[parser->index]) {
-                h_state = h_matching_connection_token;
-              } else if (parser->index == sizeof(KEEP_ALIVE)-2) {
-                h_state = h_connection_keep_alive;
-              }
-              break;
-
-            /* looking for 'Connection: close' */
-            case h_matching_connection_close:
-              parser->index++;
-              if (parser->index > sizeof(CLOSE)-1 || c != CLOSE[parser->index]) {
-                h_state = h_matching_connection_token;
-              } else if (parser->index == sizeof(CLOSE)-2) {
-                h_state = h_connection_close;
-              }
-              break;
-
-            /* looking for 'Connection: upgrade' */
-            case h_matching_connection_upgrade:
-              parser->index++;
-              if (parser->index > sizeof(UPGRADE) - 1 ||
-                  c != UPGRADE[parser->index]) {
-                h_state = h_matching_connection_token;
-              } else if (parser->index == sizeof(UPGRADE)-2) {
-                h_state = h_connection_upgrade;
-              }
-              break;
-
-            case h_matching_connection_token:
-              if (ch == ',') {
-                h_state = h_matching_connection_token_start;
-                parser->index = 0;
-              }
-              break;
-
-            case h_transfer_encoding_chunked:
-              if (ch != ' ') h_state = h_matching_transfer_encoding_token;
-              break;
-
-            case h_connection_keep_alive:
-            case h_connection_close:
-            case h_connection_upgrade:
-              if (ch == ',') {
-                if (h_state == h_connection_keep_alive) {
-                  parser->flags |= F_CONNECTION_KEEP_ALIVE;
-                } else if (h_state == h_connection_close) {
-                  parser->flags |= F_CONNECTION_CLOSE;
-                } else if (h_state == h_connection_upgrade) {
-                  parser->flags |= F_CONNECTION_UPGRADE;
-                }
-                h_state = h_matching_connection_token_start;
-                parser->index = 0;
-              } else if (ch != ' ') {
-                h_state = h_matching_connection_token;
-              }
-              break;
-
-            default:
-              UPDATE_STATE(s_header_value);
-              h_state = h_general;
-              break;
-          }
-        }
-        parser->header_state = h_state;
-
-        if (p == data + len)
-          --p;
-
-        COUNT_HEADER_SIZE(p - start);
-        break;
-      }
-
-      case s_header_almost_done:
-      {
-        if (UNLIKELY(ch != LF)) {
-          SET_ERRNO(HPE_LF_EXPECTED);
-          goto error;
-        }
-
-        UPDATE_STATE(s_header_value_lws);
-        break;
-      }
-
-      case s_header_value_lws:
-      {
-        if (ch == ' ' || ch == '\t') {
-          if (parser->header_state == h_content_length_num) {
-              /* treat obsolete line folding as space */
-              parser->header_state = h_content_length_ws;
-          }
-          UPDATE_STATE(s_header_value_start);
-          REEXECUTE();
-        }
-
-        /* finished the header */
-        switch (parser->header_state) {
-          case h_connection_keep_alive:
-            parser->flags |= F_CONNECTION_KEEP_ALIVE;
-            break;
-          case h_connection_close:
-            parser->flags |= F_CONNECTION_CLOSE;
-            break;
-          case h_transfer_encoding_chunked:
-            parser->flags |= F_CHUNKED;
-            break;
-          case h_connection_upgrade:
-            parser->flags |= F_CONNECTION_UPGRADE;
-            break;
-          default:
-            break;
-        }
-
-        UPDATE_STATE(s_header_field_start);
-        REEXECUTE();
-      }
-
-      case s_header_value_discard_ws_almost_done:
-      {
-        STRICT_CHECK(ch != LF);
-        UPDATE_STATE(s_header_value_discard_lws);
-        break;
-      }
-
-      case s_header_value_discard_lws:
-      {
-        if (ch == ' ' || ch == '\t') {
-          UPDATE_STATE(s_header_value_discard_ws);
-          break;
-        } else {
-          switch (parser->header_state) {
-            case h_connection_keep_alive:
-              parser->flags |= F_CONNECTION_KEEP_ALIVE;
-              break;
-            case h_connection_close:
-              parser->flags |= F_CONNECTION_CLOSE;
-              break;
-            case h_connection_upgrade:
-              parser->flags |= F_CONNECTION_UPGRADE;
-              break;
-            case h_transfer_encoding_chunked:
-              parser->flags |= F_CHUNKED;
-              break;
-            case h_content_length:
-              /* do not allow empty content length */
-              SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-              goto error;
-              break;
-            default:
-              break;
-          }
-
-          /* header value was empty */
-          MARK(header_value);
-          UPDATE_STATE(s_header_field_start);
-          CALLBACK_DATA_NOADVANCE(header_value);
-          REEXECUTE();
-        }
-      }
-
-      case s_headers_almost_done:
-      {
-        STRICT_CHECK(ch != LF);
-
-        if (parser->flags & F_TRAILING) {
-          /* End of a chunked request */
-          UPDATE_STATE(s_message_done);
-          CALLBACK_NOTIFY_NOADVANCE(chunk_complete);
-          REEXECUTE();
-        }
-
-        /* Cannot use transfer-encoding and a content-length header together
-           per the HTTP specification. (RFC 7230 Section 3.3.3) */
-        if ((parser->uses_transfer_encoding == 1) &&
-            (parser->flags & F_CONTENTLENGTH)) {
-          /* Allow it for lenient parsing as long as `Transfer-Encoding` is
-           * not `chunked` or allow_length_with_encoding is set
-           */
-          if (parser->flags & F_CHUNKED) {
-            if (!allow_chunked_length) {
-              SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH);
-              goto error;
-            }
-          } else if (!lenient) {
-            SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH);
-            goto error;
-          }
-        }
-
-        UPDATE_STATE(s_headers_done);
-
-        /* Set this here so that on_headers_complete() callbacks can see it */
-        if ((parser->flags & F_UPGRADE) &&
-            (parser->flags & F_CONNECTION_UPGRADE)) {
-          /* For responses, "Upgrade: foo" and "Connection: upgrade" are
-           * mandatory only when it is a 101 Switching Protocols response,
-           * otherwise it is purely informational, to announce support.
-           */
-          parser->upgrade =
-              (parser->type == HTTP_REQUEST || parser->status_code == 101);
-        } else {
-          parser->upgrade = (parser->method == HTTP_CONNECT);
-        }
-
-        /* Here we call the headers_complete callback. This is somewhat
-         * different than other callbacks because if the user returns 1, we
-         * will interpret that as saying that this message has no body. This
-         * is needed for the annoying case of recieving a response to a HEAD
-         * request.
-         *
-         * We'd like to use CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so
-         * we have to simulate it by handling a change in errno below.
-         */
-        if (settings->on_headers_complete) {
-          switch (settings->on_headers_complete(parser)) {
-            case 0:
-              break;
-
-            case 2:
-              parser->upgrade = 1;
-
-              /* fall through */
-            case 1:
-              parser->flags |= F_SKIPBODY;
-              break;
-
-            default:
-              SET_ERRNO(HPE_CB_headers_complete);
-              RETURN(p - data); /* Error */
-          }
-        }
-
-        if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
-          RETURN(p - data);
-        }
-
-        REEXECUTE();
-      }
-
-      case s_headers_done:
-      {
-        int hasBody;
-        STRICT_CHECK(ch != LF);
-
-        parser->nread = 0;
-        nread = 0;
-
-        hasBody = parser->flags & F_CHUNKED ||
-          (parser->content_length > 0 && parser->content_length != ULLONG_MAX);
-        if (parser->upgrade && (parser->method == HTTP_CONNECT ||
-                                (parser->flags & F_SKIPBODY) || !hasBody)) {
-          /* Exit, the rest of the message is in a different protocol. */
-          UPDATE_STATE(NEW_MESSAGE());
-          CALLBACK_NOTIFY(message_complete);
-          RETURN((p - data) + 1);
-        }
-
-        if (parser->flags & F_SKIPBODY) {
-          UPDATE_STATE(NEW_MESSAGE());
-          CALLBACK_NOTIFY(message_complete);
-        } else if (parser->flags & F_CHUNKED) {
-          /* chunked encoding - ignore Content-Length header,
-           * prepare for a chunk */
-          UPDATE_STATE(s_chunk_size_start);
-        } else if (parser->uses_transfer_encoding == 1) {
-          if (parser->type == HTTP_REQUEST && !lenient) {
-            /* RFC 7230 3.3.3 */
-
-            /* If a Transfer-Encoding header field
-             * is present in a request and the chunked transfer coding is not
-             * the final encoding, the message body length cannot be determined
-             * reliably; the server MUST respond with the 400 (Bad Request)
-             * status code and then close the connection.
-             */
-            SET_ERRNO(HPE_INVALID_TRANSFER_ENCODING);
-            RETURN(p - data); /* Error */
-          } else {
-            /* RFC 7230 3.3.3 */
-
-            /* If a Transfer-Encoding header field is present in a response and
-             * the chunked transfer coding is not the final encoding, the
-             * message body length is determined by reading the connection until
-             * it is closed by the server.
-             */
-            UPDATE_STATE(s_body_identity_eof);
-          }
-        } else {
-          if (parser->content_length == 0) {
-            /* Content-Length header given but zero: Content-Length: 0\r\n */
-            UPDATE_STATE(NEW_MESSAGE());
-            CALLBACK_NOTIFY(message_complete);
-          } else if (parser->content_length != ULLONG_MAX) {
-            /* Content-Length header given and non-zero */
-            UPDATE_STATE(s_body_identity);
-          } else {
-            if (!http_message_needs_eof(parser)) {
-              /* Assume content-length 0 - read the next */
-              UPDATE_STATE(NEW_MESSAGE());
-              CALLBACK_NOTIFY(message_complete);
-            } else {
-              /* Read body until EOF */
-              UPDATE_STATE(s_body_identity_eof);
-            }
-          }
-        }
-
-        break;
-      }
-
-      case s_body_identity:
-      {
-        uint64_t to_read = MIN(parser->content_length,
-                               (uint64_t) ((data + len) - p));
-
-        assert(parser->content_length != 0
-            && parser->content_length != ULLONG_MAX);
-
-        /* The difference between advancing content_length and p is because
-         * the latter will automaticaly advance on the next loop iteration.
-         * Further, if content_length ends up at 0, we want to see the last
-         * byte again for our message complete callback.
-         */
-        MARK(body);
-        parser->content_length -= to_read;
-        p += to_read - 1;
-
-        if (parser->content_length == 0) {
-          UPDATE_STATE(s_message_done);
-
-          /* Mimic CALLBACK_DATA_NOADVANCE() but with one extra byte.
-           *
-           * The alternative to doing this is to wait for the next byte to
-           * trigger the data callback, just as in every other case. The
-           * problem with this is that this makes it difficult for the test
-           * harness to distinguish between complete-on-EOF and
-           * complete-on-length. It's not clear that this distinction is
-           * important for applications, but let's keep it for now.
-           */
-          CALLBACK_DATA_(body, p - body_mark + 1, p - data);
-          REEXECUTE();
-        }
-
-        break;
-      }
-
-      /* read until EOF */
-      case s_body_identity_eof:
-        MARK(body);
-        p = data + len - 1;
-
-        break;
-
-      case s_message_done:
-        UPDATE_STATE(NEW_MESSAGE());
-        CALLBACK_NOTIFY(message_complete);
-        if (parser->upgrade) {
-          /* Exit, the rest of the message is in a different protocol. */
-          RETURN((p - data) + 1);
-        }
-        break;
-
-      case s_chunk_size_start:
-      {
-        assert(nread == 1);
-        assert(parser->flags & F_CHUNKED);
-
-        unhex_val = unhex[(unsigned char)ch];
-        if (UNLIKELY(unhex_val == -1)) {
-          SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
-          goto error;
-        }
-
-        parser->content_length = unhex_val;
-        UPDATE_STATE(s_chunk_size);
-        break;
-      }
-
-      case s_chunk_size:
-      {
-        uint64_t t;
-
-        assert(parser->flags & F_CHUNKED);
-
-        if (ch == CR) {
-          UPDATE_STATE(s_chunk_size_almost_done);
-          break;
-        }
-
-        unhex_val = unhex[(unsigned char)ch];
-
-        if (unhex_val == -1) {
-          if (ch == ';' || ch == ' ') {
-            UPDATE_STATE(s_chunk_parameters);
-            break;
-          }
-
-          SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
-          goto error;
-        }
-
-        t = parser->content_length;
-        t *= 16;
-        t += unhex_val;
-
-        /* Overflow? Test against a conservative limit for simplicity. */
-        if (UNLIKELY((ULLONG_MAX - 16) / 16 < parser->content_length)) {
-          SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-          goto error;
-        }
-
-        parser->content_length = t;
-        break;
-      }
-
-      case s_chunk_parameters:
-      {
-        assert(parser->flags & F_CHUNKED);
-        /* just ignore this shit. TODO check for overflow */
-        if (ch == CR) {
-          UPDATE_STATE(s_chunk_size_almost_done);
-          break;
-        }
-        break;
-      }
-
-      case s_chunk_size_almost_done:
-      {
-        assert(parser->flags & F_CHUNKED);
-        STRICT_CHECK(ch != LF);
-
-        parser->nread = 0;
-        nread = 0;
-
-        if (parser->content_length == 0) {
-          parser->flags |= F_TRAILING;
-          UPDATE_STATE(s_header_field_start);
-        } else {
-          UPDATE_STATE(s_chunk_data);
-        }
-        CALLBACK_NOTIFY(chunk_header);
-        break;
-      }
-
-      case s_chunk_data:
-      {
-        uint64_t to_read = MIN(parser->content_length,
-                               (uint64_t) ((data + len) - p));
-
-        assert(parser->flags & F_CHUNKED);
-        assert(parser->content_length != 0
-            && parser->content_length != ULLONG_MAX);
-
-        /* See the explanation in s_body_identity for why the content
-         * length and data pointers are managed this way.
-         */
-        MARK(body);
-        parser->content_length -= to_read;
-        p += to_read - 1;
-
-        if (parser->content_length == 0) {
-          UPDATE_STATE(s_chunk_data_almost_done);
-        }
-
-        break;
-      }
-
-      case s_chunk_data_almost_done:
-        assert(parser->flags & F_CHUNKED);
-        assert(parser->content_length == 0);
-        STRICT_CHECK(ch != CR);
-        UPDATE_STATE(s_chunk_data_done);
-        CALLBACK_DATA(body);
-        break;
-
-      case s_chunk_data_done:
-        assert(parser->flags & F_CHUNKED);
-        STRICT_CHECK(ch != LF);
-        parser->nread = 0;
-        nread = 0;
-        UPDATE_STATE(s_chunk_size_start);
-        CALLBACK_NOTIFY(chunk_complete);
-        break;
-
-      default:
-        assert(0 && "unhandled state");
-        SET_ERRNO(HPE_INVALID_INTERNAL_STATE);
-        goto error;
-    }
-  }
-
-  /* Run callbacks for any marks that we have leftover after we ran out of
-   * bytes. There should be at most one of these set, so it's OK to invoke
-   * them in series (unset marks will not result in callbacks).
-   *
-   * We use the NOADVANCE() variety of callbacks here because 'p' has already
-   * overflowed 'data' and this allows us to correct for the off-by-one that
-   * we'd otherwise have (since CALLBACK_DATA() is meant to be run with a 'p'
-   * value that's in-bounds).
-   */
-
-  assert(((header_field_mark ? 1 : 0) +
-          (header_value_mark ? 1 : 0) +
-          (url_mark ? 1 : 0)  +
-          (body_mark ? 1 : 0) +
-          (status_mark ? 1 : 0)) <= 1);
-
-  CALLBACK_DATA_NOADVANCE(header_field);
-  CALLBACK_DATA_NOADVANCE(header_value);
-  CALLBACK_DATA_NOADVANCE(url);
-  CALLBACK_DATA_NOADVANCE(body);
-  CALLBACK_DATA_NOADVANCE(status);
-
-  RETURN(len);
-
-error:
-  if (HTTP_PARSER_ERRNO(parser) == HPE_OK) {
-    SET_ERRNO(HPE_UNKNOWN);
-  }
-
-  RETURN(p - data);
-}
-
-
-/* Does the parser need to see an EOF to find the end of the message? */
-int
-http_message_needs_eof (const http_parser *parser)
-{
-  if (parser->type == HTTP_REQUEST) {
-    return 0;
-  }
-
-  /* See RFC 2616 section 4.4 */
-  if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */
-      parser->status_code == 204 ||     /* No Content */
-      parser->status_code == 304 ||     /* Not Modified */
-      parser->flags & F_SKIPBODY) {     /* response to a HEAD request */
-    return 0;
-  }
-
-  /* RFC 7230 3.3.3, see `s_headers_almost_done` */
-  if ((parser->uses_transfer_encoding == 1) &&
-      (parser->flags & F_CHUNKED) == 0) {
-    return 1;
-  }
-
-  if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) {
-    return 0;
-  }
-
-  return 1;
-}
-
-
-int
-http_should_keep_alive (const http_parser *parser)
-{
-  if (parser->http_major > 0 && parser->http_minor > 0) {
-    /* HTTP/1.1 */
-    if (parser->flags & F_CONNECTION_CLOSE) {
-      return 0;
-    }
-  } else {
-    /* HTTP/1.0 or earlier */
-    if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) {
-      return 0;
-    }
-  }
-
-  return !http_message_needs_eof(parser);
-}
-
-
-const char *
-http_method_str (enum http_method m)
-{
-  return ELEM_AT(method_strings, m, "<unknown>");
-}
-
-const char *
-http_status_str (enum http_status s)
-{
-  switch (s) {
-#define XX(num, name, string) case HTTP_STATUS_##name: return #string;
-    HTTP_STATUS_MAP(XX)
-#undef XX
-    default: return "<unknown>";
-  }
-}
-
-void
-http_parser_init (http_parser *parser, enum http_parser_type t)
-{
-  void *data = parser->data; /* preserve application data */
-  memset(parser, 0, sizeof(*parser));
-  parser->data = data;
-  parser->type = t;
-  parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res));
-  parser->http_errno = HPE_OK;
-}
-
-void
-http_parser_settings_init(http_parser_settings *settings)
-{
-  memset(settings, 0, sizeof(*settings));
-}
-
-const char *
-http_errno_name(enum http_errno err) {
-  assert(((size_t) err) < ARRAY_SIZE(http_strerror_tab));
-  return http_strerror_tab[err].name;
-}
-
-const char *
-http_errno_description(enum http_errno err) {
-  assert(((size_t) err) < ARRAY_SIZE(http_strerror_tab));
-  return http_strerror_tab[err].description;
-}
-
-static enum http_host_state
-http_parse_host_char(enum http_host_state s, const char ch) {
-  switch(s) {
-    case s_http_userinfo:
-    case s_http_userinfo_start:
-      if (ch == '@') {
-        return s_http_host_start;
-      }
-
-      if (IS_USERINFO_CHAR(ch)) {
-        return s_http_userinfo;
-      }
-      break;
-
-    case s_http_host_start:
-      if (ch == '[') {
-        return s_http_host_v6_start;
-      }
-
-      if (IS_HOST_CHAR(ch)) {
-        return s_http_host;
-      }
-
-      break;
-
-    case s_http_host:
-      if (IS_HOST_CHAR(ch)) {
-        return s_http_host;
-      }
-
-    /* fall through */
-    case s_http_host_v6_end:
-      if (ch == ':') {
-        return s_http_host_port_start;
-      }
-
-      break;
-
-    case s_http_host_v6:
-      if (ch == ']') {
-        return s_http_host_v6_end;
-      }
-
-    /* fall through */
-    case s_http_host_v6_start:
-      if (IS_HEX(ch) || ch == ':' || ch == '.') {
-        return s_http_host_v6;
-      }
-
-      if (s == s_http_host_v6 && ch == '%') {
-        return s_http_host_v6_zone_start;
-      }
-      break;
-
-    case s_http_host_v6_zone:
-      if (ch == ']') {
-        return s_http_host_v6_end;
-      }
-
-    /* fall through */
-    case s_http_host_v6_zone_start:
-      /* RFC 6874 Zone ID consists of 1*( unreserved / pct-encoded) */
-      if (IS_ALPHANUM(ch) || ch == '%' || ch == '.' || ch == '-' || ch == '_' ||
-          ch == '~') {
-        return s_http_host_v6_zone;
-      }
-      break;
-
-    case s_http_host_port:
-    case s_http_host_port_start:
-      if (IS_NUM(ch)) {
-        return s_http_host_port;
-      }
-
-      break;
-
-    default:
-      break;
-  }
-  return s_http_host_dead;
-}
-
-static int
-http_parse_host(const char * buf, struct http_parser_url *u, int found_at) {
-  enum http_host_state s;
-
-  const char *p;
-  size_t buflen = u->field_data[UF_HOST].off + u->field_data[UF_HOST].len;
-
-  assert(u->field_set & (1 << UF_HOST));
-
-  u->field_data[UF_HOST].len = 0;
-
-  s = found_at ? s_http_userinfo_start : s_http_host_start;
-
-  for (p = buf + u->field_data[UF_HOST].off; p < buf + buflen; p++) {
-    enum http_host_state new_s = http_parse_host_char(s, *p);
-
-    if (new_s == s_http_host_dead) {
-      return 1;
-    }
-
-    switch(new_s) {
-      case s_http_host:
-        if (s != s_http_host) {
-          u->field_data[UF_HOST].off = (uint16_t)(p - buf);
-        }
-        u->field_data[UF_HOST].len++;
-        break;
-
-      case s_http_host_v6:
-        if (s != s_http_host_v6) {
-          u->field_data[UF_HOST].off = (uint16_t)(p - buf);
-        }
-        u->field_data[UF_HOST].len++;
-        break;
-
-      case s_http_host_v6_zone_start:
-      case s_http_host_v6_zone:
-        u->field_data[UF_HOST].len++;
-        break;
-
-      case s_http_host_port:
-        if (s != s_http_host_port) {
-          u->field_data[UF_PORT].off = (uint16_t)(p - buf);
-          u->field_data[UF_PORT].len = 0;
-          u->field_set |= (1 << UF_PORT);
-        }
-        u->field_data[UF_PORT].len++;
-        break;
-
-      case s_http_userinfo:
-        if (s != s_http_userinfo) {
-          u->field_data[UF_USERINFO].off = (uint16_t)(p - buf);
-          u->field_data[UF_USERINFO].len = 0;
-          u->field_set |= (1 << UF_USERINFO);
-        }
-        u->field_data[UF_USERINFO].len++;
-        break;
-
-      default:
-        break;
-    }
-    s = new_s;
-  }
-
-  /* Make sure we don't end somewhere unexpected */
-  switch (s) {
-    case s_http_host_start:
-    case s_http_host_v6_start:
-    case s_http_host_v6:
-    case s_http_host_v6_zone_start:
-    case s_http_host_v6_zone:
-    case s_http_host_port_start:
-    case s_http_userinfo:
-    case s_http_userinfo_start:
-      return 1;
-    default:
-      break;
-  }
-
-  return 0;
-}
-
-void
-http_parser_url_init(struct http_parser_url *u) {
-  memset(u, 0, sizeof(*u));
-}
-
-int
-http_parser_parse_url(const char *buf, size_t buflen, int is_connect,
-                      struct http_parser_url *u)
-{
-  enum state s;
-  const char *p;
-  enum http_parser_url_fields uf, old_uf;
-  int found_at = 0;
-
-  if (buflen == 0) {
-    return 1;
-  }
-
-  u->port = u->field_set = 0;
-  s = is_connect ? s_req_server_start : s_req_spaces_before_url;
-  old_uf = UF_MAX;
-
-  for (p = buf; p < buf + buflen; p++) {
-    s = parse_url_char(s, *p);
-
-    /* Figure out the next field that we're operating on */
-    switch (s) {
-      case s_dead:
-        return 1;
-
-      /* Skip delimeters */
-      case s_req_schema_slash:
-      case s_req_schema_slash_slash:
-      case s_req_server_start:
-      case s_req_query_string_start:
-      case s_req_fragment_start:
-        continue;
-
-      case s_req_schema:
-        uf = UF_SCHEMA;
-        break;
-
-      case s_req_server_with_at:
-        found_at = 1;
-
-      /* fall through */
-      case s_req_server:
-        uf = UF_HOST;
-        break;
-
-      case s_req_path:
-        uf = UF_PATH;
-        break;
-
-      case s_req_query_string:
-        uf = UF_QUERY;
-        break;
-
-      case s_req_fragment:
-        uf = UF_FRAGMENT;
-        break;
-
-      default:
-        assert(!"Unexpected state");
-        return 1;
-    }
-
-    /* Nothing's changed; soldier on */
-    if (uf == old_uf) {
-      u->field_data[uf].len++;
-      continue;
-    }
-
-    u->field_data[uf].off = (uint16_t)(p - buf);
-    u->field_data[uf].len = 1;
-
-    u->field_set |= (1 << uf);
-    old_uf = uf;
-  }
-
-  /* host must be present if there is a schema */
-  /* parsing http:///toto will fail */
-  if ((u->field_set & (1 << UF_SCHEMA)) &&
-      (u->field_set & (1 << UF_HOST)) == 0) {
-    return 1;
-  }
-
-  if (u->field_set & (1 << UF_HOST)) {
-    if (http_parse_host(buf, u, found_at) != 0) {
-      return 1;
-    }
-  }
-
-  /* CONNECT requests can only contain "hostname:port" */
-  if (is_connect && u->field_set != ((1 << UF_HOST)|(1 << UF_PORT))) {
-    return 1;
-  }
-
-  if (u->field_set & (1 << UF_PORT)) {
-    uint16_t off;
-    uint16_t len;
-    const char* p;
-    const char* end;
-    unsigned long v;
-
-    off = u->field_data[UF_PORT].off;
-    len = u->field_data[UF_PORT].len;
-    end = buf + off + len;
-
-    /* NOTE: The characters are already validated and are in the [0-9] range */
-    assert((size_t) (off + len) <= buflen && "Port number overflow");
-    v = 0;
-    for (p = buf + off; p < end; p++) {
-      v *= 10;
-      v += *p - '0';
-
-      /* Ports have a max value of 2^16 */
-      if (v > 0xffff) {
-        return 1;
-      }
-    }
-
-    u->port = (uint16_t) v;
-  }
-
-  return 0;
-}
-
-void
-http_parser_pause(http_parser *parser, int paused) {
-  /* Users should only be pausing/unpausing a parser that is not in an error
-   * state. In non-debug builds, there's not much that we can do about this
-   * other than ignore it.
-   */
-  if (HTTP_PARSER_ERRNO(parser) == HPE_OK ||
-      HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) {
-    uint32_t nread = parser->nread; /* used by the SET_ERRNO macro */
-    SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK);
-  } else {
-    assert(0 && "Attempting to pause parser in error state");
-  }
-}
-
-int
-http_body_is_final(const struct http_parser *parser) {
-    return parser->state == s_message_done;
-}
-
-unsigned long
-http_parser_version(void) {
-  return HTTP_PARSER_VERSION_MAJOR * 0x10000 |
-         HTTP_PARSER_VERSION_MINOR * 0x00100 |
-         HTTP_PARSER_VERSION_PATCH * 0x00001;
-}
-
-void
-http_parser_set_max_header_size(uint32_t size) {
-  max_header_size = size;
-}
diff --git a/deps/http_parser/http_parser.gyp b/deps/http_parser/http_parser.gyp
deleted file mode 100644
index 4364f73d1f4548298ea4092371e6586f0c18744b..0000000000000000000000000000000000000000
--- a/deps/http_parser/http_parser.gyp
+++ /dev/null
@@ -1,111 +0,0 @@
-# This file is used with the GYP meta build system.
-# http://code.google.com/p/gyp/
-# To build try this:
-#   svn co http://gyp.googlecode.com/svn/trunk gyp
-#   ./gyp/gyp -f make --depth=`pwd` http_parser.gyp 
-#   ./out/Debug/test 
-{
-  'target_defaults': {
-    'default_configuration': 'Debug',
-    'configurations': {
-      # TODO: hoist these out and put them somewhere common, because
-      #       RuntimeLibrary MUST MATCH across the entire project
-      'Debug': {
-        'defines': [ 'DEBUG', '_DEBUG' ],
-        'cflags': [ '-Wall', '-Wextra', '-O0', '-g', '-ftrapv' ],
-        'msvs_settings': {
-          'VCCLCompilerTool': {
-            'RuntimeLibrary': 1, # static debug
-          },
-        },
-      },
-      'Release': {
-        'defines': [ 'NDEBUG' ],
-        'cflags': [ '-Wall', '-Wextra', '-O3' ],
-        'msvs_settings': {
-          'VCCLCompilerTool': {
-            'RuntimeLibrary': 0, # static release
-          },
-        },
-      }
-    },
-    'msvs_settings': {
-      'VCCLCompilerTool': {
-      },
-      'VCLibrarianTool': {
-      },
-      'VCLinkerTool': {
-        'GenerateDebugInformation': 'true',
-      },
-    },
-    'conditions': [
-      ['OS == "win"', {
-        'defines': [
-          'WIN32'
-        ],
-      }]
-    ],
-  },
-
-  'targets': [
-    {
-      'target_name': 'http_parser',
-      'type': 'static_library',
-      'include_dirs': [ '.' ],
-      'direct_dependent_settings': {
-        'defines': [ 'HTTP_PARSER_STRICT=0' ],
-        'include_dirs': [ '.' ],
-      },
-      'defines': [ 'HTTP_MAX_HEADER_SIZE=8192', 'HTTP_PARSER_STRICT=0' ],
-      'sources': [ './http_parser.c', ],
-      'conditions': [
-        ['OS=="win"', {
-          'msvs_settings': {
-            'VCCLCompilerTool': {
-              # Compile as C++. http_parser.c is actually C99, but C++ is
-              # close enough in this case.
-              'CompileAs': 2,
-            },
-          },
-        }]
-      ],
-    },
-
-    {
-      'target_name': 'http_parser_strict',
-      'type': 'static_library',
-      'include_dirs': [ '.' ],
-      'direct_dependent_settings': {
-        'defines': [ 'HTTP_PARSER_STRICT=1' ],
-        'include_dirs': [ '.' ],
-      },
-      'defines': [ 'HTTP_MAX_HEADER_SIZE=8192', 'HTTP_PARSER_STRICT=1' ],
-      'sources': [ './http_parser.c', ],
-      'conditions': [
-        ['OS=="win"', {
-          'msvs_settings': {
-            'VCCLCompilerTool': {
-              # Compile as C++. http_parser.c is actually C99, but C++ is
-              # close enough in this case.
-              'CompileAs': 2,
-            },
-          },
-        }]
-      ],
-    },
-
-    {
-      'target_name': 'test-nonstrict',
-      'type': 'executable',
-      'dependencies': [ 'http_parser' ],
-      'sources': [ 'test.c' ]
-    },
-
-    {
-      'target_name': 'test-strict',
-      'type': 'executable',
-      'dependencies': [ 'http_parser_strict' ],
-      'sources': [ 'test.c' ]
-    }
-  ]
-}
diff --git a/deps/http_parser/http_parser.h b/deps/http_parser/http_parser.h
deleted file mode 100644
index 3772b3994fe4ae3544ba75a511c057ba220f2283..0000000000000000000000000000000000000000
--- a/deps/http_parser/http_parser.h
+++ /dev/null
@@ -1,449 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#ifndef http_parser_h
-#define http_parser_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Also update SONAME in the Makefile whenever you change these. */
-#define HTTP_PARSER_VERSION_MAJOR 2
-#define HTTP_PARSER_VERSION_MINOR 9
-#define HTTP_PARSER_VERSION_PATCH 4
-
-#include <stddef.h>
-#if defined(_WIN32) && !defined(__MINGW32__) && \
-  (!defined(_MSC_VER) || _MSC_VER<1600) && !defined(__WINE__)
-#include <BaseTsd.h>
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#elif (defined(__sun) || defined(__sun__)) && defined(__SunOS_5_9)
-#include <sys/inttypes.h>
-#else
-#include <stdint.h>
-#endif
-
-/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
- * faster
- */
-#ifndef HTTP_PARSER_STRICT
-# define HTTP_PARSER_STRICT 1
-#endif
-
-/* Maximium header size allowed. If the macro is not defined
- * before including this header then the default is used. To
- * change the maximum header size, define the macro in the build
- * environment (e.g. -DHTTP_MAX_HEADER_SIZE=<value>). To remove
- * the effective limit on the size of the header, define the macro
- * to a very large number (e.g. -DHTTP_MAX_HEADER_SIZE=0x7fffffff)
- */
-#ifndef HTTP_MAX_HEADER_SIZE
-# define HTTP_MAX_HEADER_SIZE (80*1024)
-#endif
-
-typedef struct http_parser http_parser;
-typedef struct http_parser_settings http_parser_settings;
-
-
-/* Callbacks should return non-zero to indicate an error. The parser will
- * then halt execution.
- *
- * The one exception is on_headers_complete. In a HTTP_RESPONSE parser
- * returning '1' from on_headers_complete will tell the parser that it
- * should not expect a body. This is used when receiving a response to a
- * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
- * chunked' headers that indicate the presence of a body.
- *
- * Returning `2` from on_headers_complete will tell parser that it should not
- * expect neither a body nor any futher responses on this connection. This is
- * useful for handling responses to a CONNECT request which may not contain
- * `Upgrade` or `Connection: upgrade` headers.
- *
- * http_data_cb does not return data chunks. It will be called arbitrarily
- * many times for each string. E.G. you might get 10 callbacks for "on_url"
- * each providing just a few characters more data.
- */
-typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
-typedef int (*http_cb) (http_parser*);
-
-
-/* Status Codes */
-#define HTTP_STATUS_MAP(XX)                                                 \
-  XX(100, CONTINUE,                        Continue)                        \
-  XX(101, SWITCHING_PROTOCOLS,             Switching Protocols)             \
-  XX(102, PROCESSING,                      Processing)                      \
-  XX(200, OK,                              OK)                              \
-  XX(201, CREATED,                         Created)                         \
-  XX(202, ACCEPTED,                        Accepted)                        \
-  XX(203, NON_AUTHORITATIVE_INFORMATION,   Non-Authoritative Information)   \
-  XX(204, NO_CONTENT,                      No Content)                      \
-  XX(205, RESET_CONTENT,                   Reset Content)                   \
-  XX(206, PARTIAL_CONTENT,                 Partial Content)                 \
-  XX(207, MULTI_STATUS,                    Multi-Status)                    \
-  XX(208, ALREADY_REPORTED,                Already Reported)                \
-  XX(226, IM_USED,                         IM Used)                         \
-  XX(300, MULTIPLE_CHOICES,                Multiple Choices)                \
-  XX(301, MOVED_PERMANENTLY,               Moved Permanently)               \
-  XX(302, FOUND,                           Found)                           \
-  XX(303, SEE_OTHER,                       See Other)                       \
-  XX(304, NOT_MODIFIED,                    Not Modified)                    \
-  XX(305, USE_PROXY,                       Use Proxy)                       \
-  XX(307, TEMPORARY_REDIRECT,              Temporary Redirect)              \
-  XX(308, PERMANENT_REDIRECT,              Permanent Redirect)              \
-  XX(400, BAD_REQUEST,                     Bad Request)                     \
-  XX(401, UNAUTHORIZED,                    Unauthorized)                    \
-  XX(402, PAYMENT_REQUIRED,                Payment Required)                \
-  XX(403, FORBIDDEN,                       Forbidden)                       \
-  XX(404, NOT_FOUND,                       Not Found)                       \
-  XX(405, METHOD_NOT_ALLOWED,              Method Not Allowed)              \
-  XX(406, NOT_ACCEPTABLE,                  Not Acceptable)                  \
-  XX(407, PROXY_AUTHENTICATION_REQUIRED,   Proxy Authentication Required)   \
-  XX(408, REQUEST_TIMEOUT,                 Request Timeout)                 \
-  XX(409, CONFLICT,                        Conflict)                        \
-  XX(410, GONE,                            Gone)                            \
-  XX(411, LENGTH_REQUIRED,                 Length Required)                 \
-  XX(412, PRECONDITION_FAILED,             Precondition Failed)             \
-  XX(413, PAYLOAD_TOO_LARGE,               Payload Too Large)               \
-  XX(414, URI_TOO_LONG,                    URI Too Long)                    \
-  XX(415, UNSUPPORTED_MEDIA_TYPE,          Unsupported Media Type)          \
-  XX(416, RANGE_NOT_SATISFIABLE,           Range Not Satisfiable)           \
-  XX(417, EXPECTATION_FAILED,              Expectation Failed)              \
-  XX(421, MISDIRECTED_REQUEST,             Misdirected Request)             \
-  XX(422, UNPROCESSABLE_ENTITY,            Unprocessable Entity)            \
-  XX(423, LOCKED,                          Locked)                          \
-  XX(424, FAILED_DEPENDENCY,               Failed Dependency)               \
-  XX(426, UPGRADE_REQUIRED,                Upgrade Required)                \
-  XX(428, PRECONDITION_REQUIRED,           Precondition Required)           \
-  XX(429, TOO_MANY_REQUESTS,               Too Many Requests)               \
-  XX(431, REQUEST_HEADER_FIELDS_TOO_LARGE, Request Header Fields Too Large) \
-  XX(451, UNAVAILABLE_FOR_LEGAL_REASONS,   Unavailable For Legal Reasons)   \
-  XX(500, INTERNAL_SERVER_ERROR,           Internal Server Error)           \
-  XX(501, NOT_IMPLEMENTED,                 Not Implemented)                 \
-  XX(502, BAD_GATEWAY,                     Bad Gateway)                     \
-  XX(503, SERVICE_UNAVAILABLE,             Service Unavailable)             \
-  XX(504, GATEWAY_TIMEOUT,                 Gateway Timeout)                 \
-  XX(505, HTTP_VERSION_NOT_SUPPORTED,      HTTP Version Not Supported)      \
-  XX(506, VARIANT_ALSO_NEGOTIATES,         Variant Also Negotiates)         \
-  XX(507, INSUFFICIENT_STORAGE,            Insufficient Storage)            \
-  XX(508, LOOP_DETECTED,                   Loop Detected)                   \
-  XX(510, NOT_EXTENDED,                    Not Extended)                    \
-  XX(511, NETWORK_AUTHENTICATION_REQUIRED, Network Authentication Required) \
-
-enum http_status
-  {
-#define XX(num, name, string) HTTP_STATUS_##name = num,
-  HTTP_STATUS_MAP(XX)
-#undef XX
-  };
-
-
-/* Request Methods */
-#define HTTP_METHOD_MAP(XX)         \
-  XX(0,  DELETE,      DELETE)       \
-  XX(1,  GET,         GET)          \
-  XX(2,  HEAD,        HEAD)         \
-  XX(3,  POST,        POST)         \
-  XX(4,  PUT,         PUT)          \
-  /* pathological */                \
-  XX(5,  CONNECT,     CONNECT)      \
-  XX(6,  OPTIONS,     OPTIONS)      \
-  XX(7,  TRACE,       TRACE)        \
-  /* WebDAV */                      \
-  XX(8,  COPY,        COPY)         \
-  XX(9,  LOCK,        LOCK)         \
-  XX(10, MKCOL,       MKCOL)        \
-  XX(11, MOVE,        MOVE)         \
-  XX(12, PROPFIND,    PROPFIND)     \
-  XX(13, PROPPATCH,   PROPPATCH)    \
-  XX(14, SEARCH,      SEARCH)       \
-  XX(15, UNLOCK,      UNLOCK)       \
-  XX(16, BIND,        BIND)         \
-  XX(17, REBIND,      REBIND)       \
-  XX(18, UNBIND,      UNBIND)       \
-  XX(19, ACL,         ACL)          \
-  /* subversion */                  \
-  XX(20, REPORT,      REPORT)       \
-  XX(21, MKACTIVITY,  MKACTIVITY)   \
-  XX(22, CHECKOUT,    CHECKOUT)     \
-  XX(23, MERGE,       MERGE)        \
-  /* upnp */                        \
-  XX(24, MSEARCH,     M-SEARCH)     \
-  XX(25, NOTIFY,      NOTIFY)       \
-  XX(26, SUBSCRIBE,   SUBSCRIBE)    \
-  XX(27, UNSUBSCRIBE, UNSUBSCRIBE)  \
-  /* RFC-5789 */                    \
-  XX(28, PATCH,       PATCH)        \
-  XX(29, PURGE,       PURGE)        \
-  /* CalDAV */                      \
-  XX(30, MKCALENDAR,  MKCALENDAR)   \
-  /* RFC-2068, section 19.6.1.2 */  \
-  XX(31, LINK,        LINK)         \
-  XX(32, UNLINK,      UNLINK)       \
-  /* icecast */                     \
-  XX(33, SOURCE,      SOURCE)       \
-
-enum http_method
-  {
-#define XX(num, name, string) HTTP_##name = num,
-  HTTP_METHOD_MAP(XX)
-#undef XX
-  };
-
-
-enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
-
-
-/* Flag values for http_parser.flags field */
-enum flags
-  { F_CHUNKED               = 1 << 0
-  , F_CONNECTION_KEEP_ALIVE = 1 << 1
-  , F_CONNECTION_CLOSE      = 1 << 2
-  , F_CONNECTION_UPGRADE    = 1 << 3
-  , F_TRAILING              = 1 << 4
-  , F_UPGRADE               = 1 << 5
-  , F_SKIPBODY              = 1 << 6
-  , F_CONTENTLENGTH         = 1 << 7
-  };
-
-
-/* Map for errno-related constants
- *
- * The provided argument should be a macro that takes 2 arguments.
- */
-#define HTTP_ERRNO_MAP(XX)                                           \
-  /* No error */                                                     \
-  XX(OK, "success")                                                  \
-                                                                     \
-  /* Callback-related errors */                                      \
-  XX(CB_message_begin, "the on_message_begin callback failed")       \
-  XX(CB_url, "the on_url callback failed")                           \
-  XX(CB_header_field, "the on_header_field callback failed")         \
-  XX(CB_header_value, "the on_header_value callback failed")         \
-  XX(CB_headers_complete, "the on_headers_complete callback failed") \
-  XX(CB_body, "the on_body callback failed")                         \
-  XX(CB_message_complete, "the on_message_complete callback failed") \
-  XX(CB_status, "the on_status callback failed")                     \
-  XX(CB_chunk_header, "the on_chunk_header callback failed")         \
-  XX(CB_chunk_complete, "the on_chunk_complete callback failed")     \
-                                                                     \
-  /* Parsing-related errors */                                       \
-  XX(INVALID_EOF_STATE, "stream ended at an unexpected time")        \
-  XX(HEADER_OVERFLOW,                                                \
-     "too many header bytes seen; overflow detected")                \
-  XX(CLOSED_CONNECTION,                                              \
-     "data received after completed connection: close message")      \
-  XX(INVALID_VERSION, "invalid HTTP version")                        \
-  XX(INVALID_STATUS, "invalid HTTP status code")                     \
-  XX(INVALID_METHOD, "invalid HTTP method")                          \
-  XX(INVALID_URL, "invalid URL")                                     \
-  XX(INVALID_HOST, "invalid host")                                   \
-  XX(INVALID_PORT, "invalid port")                                   \
-  XX(INVALID_PATH, "invalid path")                                   \
-  XX(INVALID_QUERY_STRING, "invalid query string")                   \
-  XX(INVALID_FRAGMENT, "invalid fragment")                           \
-  XX(LF_EXPECTED, "LF character expected")                           \
-  XX(INVALID_HEADER_TOKEN, "invalid character in header")            \
-  XX(INVALID_CONTENT_LENGTH,                                         \
-     "invalid character in content-length header")                   \
-  XX(UNEXPECTED_CONTENT_LENGTH,                                      \
-     "unexpected content-length header")                             \
-  XX(INVALID_CHUNK_SIZE,                                             \
-     "invalid character in chunk size header")                       \
-  XX(INVALID_CONSTANT, "invalid constant string")                    \
-  XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
-  XX(STRICT, "strict mode assertion failed")                         \
-  XX(PAUSED, "parser is paused")                                     \
-  XX(UNKNOWN, "an unknown error occurred")                           \
-  XX(INVALID_TRANSFER_ENCODING,                                      \
-     "request has invalid transfer-encoding")                        \
-
-
-/* Define HPE_* values for each errno value above */
-#define HTTP_ERRNO_GEN(n, s) HPE_##n,
-enum http_errno {
-  HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
-};
-#undef HTTP_ERRNO_GEN
-
-
-/* Get an http_errno value from an http_parser */
-#define HTTP_PARSER_ERRNO(p)            ((enum http_errno) (p)->http_errno)
-
-
-struct http_parser {
-  /** PRIVATE **/
-  unsigned int type : 2;         /* enum http_parser_type */
-  unsigned int flags : 8;       /* F_* values from 'flags' enum; semi-public */
-  unsigned int state : 7;        /* enum state from http_parser.c */
-  unsigned int header_state : 7; /* enum header_state from http_parser.c */
-  unsigned int index : 5;        /* index into current matcher */
-  unsigned int uses_transfer_encoding : 1; /* Transfer-Encoding header is present */
-  unsigned int allow_chunked_length : 1; /* Allow headers with both
-                                          * `Content-Length` and
-                                          * `Transfer-Encoding: chunked` set */
-  unsigned int lenient_http_headers : 1;
-
-  uint32_t nread;          /* # bytes read in various scenarios */
-  uint64_t content_length; /* # bytes in body. `(uint64_t) -1` (all bits one)
-                            * if no Content-Length header.
-                            */
-
-  /** READ-ONLY **/
-  unsigned short http_major;
-  unsigned short http_minor;
-  unsigned int status_code : 16; /* responses only */
-  unsigned int method : 8;       /* requests only */
-  unsigned int http_errno : 7;
-
-  /* 1 = Upgrade header was present and the parser has exited because of that.
-   * 0 = No upgrade header present.
-   * Should be checked when http_parser_execute() returns in addition to
-   * error checking.
-   */
-  unsigned int upgrade : 1;
-
-  /** PUBLIC **/
-  void *data; /* A pointer to get hook to the "connection" or "socket" object */
-};
-
-
-struct http_parser_settings {
-  http_cb      on_message_begin;
-  http_data_cb on_url;
-  http_data_cb on_status;
-  http_data_cb on_header_field;
-  http_data_cb on_header_value;
-  http_cb      on_headers_complete;
-  http_data_cb on_body;
-  http_cb      on_message_complete;
-  /* When on_chunk_header is called, the current chunk length is stored
-   * in parser->content_length.
-   */
-  http_cb      on_chunk_header;
-  http_cb      on_chunk_complete;
-};
-
-
-enum http_parser_url_fields
-  { UF_SCHEMA           = 0
-  , UF_HOST             = 1
-  , UF_PORT             = 2
-  , UF_PATH             = 3
-  , UF_QUERY            = 4
-  , UF_FRAGMENT         = 5
-  , UF_USERINFO         = 6
-  , UF_MAX              = 7
-  };
-
-
-/* Result structure for http_parser_parse_url().
- *
- * Callers should index into field_data[] with UF_* values iff field_set
- * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and
- * because we probably have padding left over), we convert any port to
- * a uint16_t.
- */
-struct http_parser_url {
-  uint16_t field_set;           /* Bitmask of (1 << UF_*) values */
-  uint16_t port;                /* Converted UF_PORT string */
-
-  struct {
-    uint16_t off;               /* Offset into buffer in which field starts */
-    uint16_t len;               /* Length of run in buffer */
-  } field_data[UF_MAX];
-};
-
-
-/* Returns the library version. Bits 16-23 contain the major version number,
- * bits 8-15 the minor version number and bits 0-7 the patch level.
- * Usage example:
- *
- *   unsigned long version = http_parser_version();
- *   unsigned major = (version >> 16) & 255;
- *   unsigned minor = (version >> 8) & 255;
- *   unsigned patch = version & 255;
- *   printf("http_parser v%u.%u.%u\n", major, minor, patch);
- */
-unsigned long http_parser_version(void);
-
-void http_parser_init(http_parser *parser, enum http_parser_type type);
-
-
-/* Initialize http_parser_settings members to 0
- */
-void http_parser_settings_init(http_parser_settings *settings);
-
-
-/* Executes the parser. Returns number of parsed bytes. Sets
- * `parser->http_errno` on error. */
-size_t http_parser_execute(http_parser *parser,
-                           const http_parser_settings *settings,
-                           const char *data,
-                           size_t len);
-
-
-/* If http_should_keep_alive() in the on_headers_complete or
- * on_message_complete callback returns 0, then this should be
- * the last message on the connection.
- * If you are the server, respond with the "Connection: close" header.
- * If you are the client, close the connection.
- */
-int http_should_keep_alive(const http_parser *parser);
-
-/* Returns a string version of the HTTP method. */
-const char *http_method_str(enum http_method m);
-
-/* Returns a string version of the HTTP status code. */
-const char *http_status_str(enum http_status s);
-
-/* Return a string name of the given error */
-const char *http_errno_name(enum http_errno err);
-
-/* Return a string description of the given error */
-const char *http_errno_description(enum http_errno err);
-
-/* Initialize all http_parser_url members to 0 */
-void http_parser_url_init(struct http_parser_url *u);
-
-/* Parse a URL; return nonzero on failure */
-int http_parser_parse_url(const char *buf, size_t buflen,
-                          int is_connect,
-                          struct http_parser_url *u);
-
-/* Pause or un-pause the parser; a nonzero value pauses */
-void http_parser_pause(http_parser *parser, int paused);
-
-/* Checks if this is the final chunk of the body. */
-int http_body_is_final(const http_parser *parser);
-
-/* Change the maximum header size provided at compile time. */
-void http_parser_set_max_header_size(uint32_t size);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/deps/http_parser/test.c b/deps/http_parser/test.c
deleted file mode 100644
index 2e5a9ebd6780b0261297f0d2d81afa0ccce45364..0000000000000000000000000000000000000000
--- a/deps/http_parser/test.c
+++ /dev/null
@@ -1,4755 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#include "http_parser.h"
-#include <stdlib.h>
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h> /* rand */
-#include <string.h>
-#include <stdarg.h>
-
-#if defined(__APPLE__)
-# undef strlncpy
-#endif  /* defined(__APPLE__) */
-
-#undef TRUE
-#define TRUE 1
-#undef FALSE
-#define FALSE 0
-
-#define MAX_HEADERS 13
-#define MAX_ELEMENT_SIZE 2048
-#define MAX_CHUNKS 16
-
-#define MIN(a,b) ((a) < (b) ? (a) : (b))
-
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
-
-static http_parser parser;
-
-struct message {
-  const char *name; // for debugging purposes
-  const char *raw;
-  enum http_parser_type type;
-  enum http_method method;
-  int status_code;
-  char response_status[MAX_ELEMENT_SIZE];
-  char request_path[MAX_ELEMENT_SIZE];
-  char request_url[MAX_ELEMENT_SIZE];
-  char fragment[MAX_ELEMENT_SIZE];
-  char query_string[MAX_ELEMENT_SIZE];
-  char body[MAX_ELEMENT_SIZE];
-  size_t body_size;
-  const char *host;
-  const char *userinfo;
-  uint16_t port;
-  int num_headers;
-  enum { NONE=0, FIELD, VALUE } last_header_element;
-  char headers [MAX_HEADERS][2][MAX_ELEMENT_SIZE];
-  int should_keep_alive;
-
-  int num_chunks;
-  int num_chunks_complete;
-  int chunk_lengths[MAX_CHUNKS];
-
-  const char *upgrade; // upgraded body
-
-  unsigned short http_major;
-  unsigned short http_minor;
-  uint64_t content_length;
-
-  int message_begin_cb_called;
-  int headers_complete_cb_called;
-  int message_complete_cb_called;
-  int status_cb_called;
-  int message_complete_on_eof;
-  int body_is_final;
-  int allow_chunked_length;
-};
-
-static int currently_parsing_eof;
-
-static struct message messages[5];
-static int num_messages;
-static http_parser_settings *current_pause_parser;
-
-/* * R E Q U E S T S * */
-const struct message requests[] =
-#define CURL_GET 0
-{ {.name= "curl get"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /test HTTP/1.1\r\n"
-         "User-Agent: curl/7.18.0 (i486-pc-linux-gnu) libcurl/7.18.0 OpenSSL/0.9.8g zlib/1.2.3.3 libidn/1.1\r\n"
-         "Host: 0.0.0.0=5000\r\n"
-         "Accept: */*\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/test"
-  ,.request_url= "/test"
-  ,.content_length= -1
-  ,.num_headers= 3
-  ,.headers=
-    { { "User-Agent", "curl/7.18.0 (i486-pc-linux-gnu) libcurl/7.18.0 OpenSSL/0.9.8g zlib/1.2.3.3 libidn/1.1" }
-    , { "Host", "0.0.0.0=5000" }
-    , { "Accept", "*/*" }
-    }
-  ,.body= ""
-  }
-
-#define FIREFOX_GET 1
-, {.name= "firefox get"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /favicon.ico HTTP/1.1\r\n"
-         "Host: 0.0.0.0=5000\r\n"
-         "User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9) Gecko/2008061015 Firefox/3.0\r\n"
-         "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
-         "Accept-Language: en-us,en;q=0.5\r\n"
-         "Accept-Encoding: gzip,deflate\r\n"
-         "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n"
-         "Keep-Alive: 300\r\n"
-         "Connection: keep-alive\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/favicon.ico"
-  ,.request_url= "/favicon.ico"
-  ,.content_length= -1
-  ,.num_headers= 8
-  ,.headers=
-    { { "Host", "0.0.0.0=5000" }
-    , { "User-Agent", "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9) Gecko/2008061015 Firefox/3.0" }
-    , { "Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" }
-    , { "Accept-Language", "en-us,en;q=0.5" }
-    , { "Accept-Encoding", "gzip,deflate" }
-    , { "Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7" }
-    , { "Keep-Alive", "300" }
-    , { "Connection", "keep-alive" }
-    }
-  ,.body= ""
-  }
-
-#define DUMBLUCK 2
-, {.name= "dumbluck"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /dumbluck HTTP/1.1\r\n"
-         "aaaaaaaaaaaaa:++++++++++\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/dumbluck"
-  ,.request_url= "/dumbluck"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "aaaaaaaaaaaaa",  "++++++++++" }
-    }
-  ,.body= ""
-  }
-
-#define FRAGMENT_IN_URI 3
-, {.name= "fragment in url"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= "page=1"
-  ,.fragment= "posts-17408"
-  ,.request_path= "/forums/1/topics/2375"
-  /* XXX request url does include fragment? */
-  ,.request_url= "/forums/1/topics/2375?page=1#posts-17408"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.body= ""
-  }
-
-#define GET_NO_HEADERS_NO_BODY 4
-, {.name= "get no headers no body"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /get_no_headers_no_body/world HTTP/1.1\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE /* would need Connection: close */
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/get_no_headers_no_body/world"
-  ,.request_url= "/get_no_headers_no_body/world"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.body= ""
-  }
-
-#define GET_ONE_HEADER_NO_BODY 5
-, {.name= "get one header no body"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /get_one_header_no_body HTTP/1.1\r\n"
-         "Accept: */*\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE /* would need Connection: close */
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/get_one_header_no_body"
-  ,.request_url= "/get_one_header_no_body"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Accept" , "*/*" }
-    }
-  ,.body= ""
-  }
-
-#define GET_FUNKY_CONTENT_LENGTH 6
-, {.name= "get funky content length body hello"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /get_funky_content_length_body_hello HTTP/1.0\r\n"
-         "conTENT-Length: 5\r\n"
-         "\r\n"
-         "HELLO"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/get_funky_content_length_body_hello"
-  ,.request_url= "/get_funky_content_length_body_hello"
-  ,.content_length= 5
-  ,.num_headers= 1
-  ,.headers=
-    { { "conTENT-Length" , "5" }
-    }
-  ,.body= "HELLO"
-  }
-
-#define POST_IDENTITY_BODY_WORLD 7
-, {.name= "post identity body world"
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST /post_identity_body_world?q=search#hey HTTP/1.1\r\n"
-         "Accept: */*\r\n"
-         "Content-Length: 5\r\n"
-         "\r\n"
-         "World"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= "q=search"
-  ,.fragment= "hey"
-  ,.request_path= "/post_identity_body_world"
-  ,.request_url= "/post_identity_body_world?q=search#hey"
-  ,.content_length= 5
-  ,.num_headers= 2
-  ,.headers=
-    { { "Accept", "*/*" }
-    , { "Content-Length", "5" }
-    }
-  ,.body= "World"
-  }
-
-#define POST_CHUNKED_ALL_YOUR_BASE 8
-, {.name= "post - chunked body: all your base are belong to us"
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST /post_chunked_all_your_base HTTP/1.1\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "1e\r\nall your base are belong to us\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/post_chunked_all_your_base"
-  ,.request_url= "/post_chunked_all_your_base"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Transfer-Encoding" , "chunked" }
-    }
-  ,.body= "all your base are belong to us"
-  ,.num_chunks_complete= 2
-  ,.chunk_lengths= { 0x1e }
-  }
-
-#define TWO_CHUNKS_MULT_ZERO_END 9
-, {.name= "two chunks ; triple zero ending"
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST /two_chunks_mult_zero_end HTTP/1.1\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "5\r\nhello\r\n"
-         "6\r\n world\r\n"
-         "000\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/two_chunks_mult_zero_end"
-  ,.request_url= "/two_chunks_mult_zero_end"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Transfer-Encoding", "chunked" }
-    }
-  ,.body= "hello world"
-  ,.num_chunks_complete= 3
-  ,.chunk_lengths= { 5, 6 }
-  }
-
-#define CHUNKED_W_TRAILING_HEADERS 10
-, {.name= "chunked with trailing headers. blech."
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST /chunked_w_trailing_headers HTTP/1.1\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "5\r\nhello\r\n"
-         "6\r\n world\r\n"
-         "0\r\n"
-         "Vary: *\r\n"
-         "Content-Type: text/plain\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/chunked_w_trailing_headers"
-  ,.request_url= "/chunked_w_trailing_headers"
-  ,.content_length= -1
-  ,.num_headers= 3
-  ,.headers=
-    { { "Transfer-Encoding",  "chunked" }
-    , { "Vary", "*" }
-    , { "Content-Type", "text/plain" }
-    }
-  ,.body= "hello world"
-  ,.num_chunks_complete= 3
-  ,.chunk_lengths= { 5, 6 }
-  }
-
-#define CHUNKED_W_NONSENSE_AFTER_LENGTH 11
-, {.name= "with nonsense after the length"
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST /chunked_w_nonsense_after_length HTTP/1.1\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "5; ilovew3;whattheluck=aretheseparametersfor\r\nhello\r\n"
-         "6; blahblah; blah\r\n world\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/chunked_w_nonsense_after_length"
-  ,.request_url= "/chunked_w_nonsense_after_length"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Transfer-Encoding", "chunked" }
-    }
-  ,.body= "hello world"
-  ,.num_chunks_complete= 3
-  ,.chunk_lengths= { 5, 6 }
-  }
-
-#define WITH_QUOTES 12
-, {.name= "with quotes"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /with_\"stupid\"_quotes?foo=\"bar\" HTTP/1.1\r\n\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= "foo=\"bar\""
-  ,.fragment= ""
-  ,.request_path= "/with_\"stupid\"_quotes"
-  ,.request_url= "/with_\"stupid\"_quotes?foo=\"bar\""
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= { }
-  ,.body= ""
-  }
-
-#define APACHEBENCH_GET 13
-/* The server receiving this request SHOULD NOT wait for EOF
- * to know that content-length == 0.
- * How to represent this in a unit test? message_complete_on_eof
- * Compare with NO_CONTENT_LENGTH_RESPONSE.
- */
-, {.name = "apachebench get"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /test HTTP/1.0\r\n"
-         "Host: 0.0.0.0:5000\r\n"
-         "User-Agent: ApacheBench/2.3\r\n"
-         "Accept: */*\r\n\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/test"
-  ,.request_url= "/test"
-  ,.content_length= -1
-  ,.num_headers= 3
-  ,.headers= { { "Host", "0.0.0.0:5000" }
-             , { "User-Agent", "ApacheBench/2.3" }
-             , { "Accept", "*/*" }
-             }
-  ,.body= ""
-  }
-
-#define QUERY_URL_WITH_QUESTION_MARK_GET 14
-/* Some clients include '?' characters in query strings.
- */
-, {.name = "query url with question mark"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /test.cgi?foo=bar?baz HTTP/1.1\r\n\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= "foo=bar?baz"
-  ,.fragment= ""
-  ,.request_path= "/test.cgi"
-  ,.request_url= "/test.cgi?foo=bar?baz"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= {}
-  ,.body= ""
-  }
-
-#define PREFIX_NEWLINE_GET 15
-/* Some clients, especially after a POST in a keep-alive connection,
- * will send an extra CRLF before the next request
- */
-, {.name = "newline prefix get"
-  ,.type= HTTP_REQUEST
-  ,.raw= "\r\nGET /test HTTP/1.1\r\n\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/test"
-  ,.request_url= "/test"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= { }
-  ,.body= ""
-  }
-
-#define UPGRADE_REQUEST 16
-, {.name = "upgrade request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /demo HTTP/1.1\r\n"
-         "Host: example.com\r\n"
-         "Connection: Upgrade\r\n"
-         "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
-         "Sec-WebSocket-Protocol: sample\r\n"
-         "Upgrade: WebSocket\r\n"
-         "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
-         "Origin: http://example.com\r\n"
-         "\r\n"
-         "Hot diggity dogg"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/demo"
-  ,.request_url= "/demo"
-  ,.content_length= -1
-  ,.num_headers= 7
-  ,.upgrade="Hot diggity dogg"
-  ,.headers= { { "Host", "example.com" }
-             , { "Connection", "Upgrade" }
-             , { "Sec-WebSocket-Key2", "12998 5 Y3 1  .P00" }
-             , { "Sec-WebSocket-Protocol", "sample" }
-             , { "Upgrade", "WebSocket" }
-             , { "Sec-WebSocket-Key1", "4 @1  46546xW%0l 1 5" }
-             , { "Origin", "http://example.com" }
-             }
-  ,.body= ""
-  }
-
-#define CONNECT_REQUEST 17
-, {.name = "connect request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "CONNECT 0-home0.netscape.com:443 HTTP/1.0\r\n"
-         "User-agent: Mozilla/1.1N\r\n"
-         "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
-         "\r\n"
-         "some data\r\n"
-         "and yet even more data"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.method= HTTP_CONNECT
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= ""
-  ,.request_url= "0-home0.netscape.com:443"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.upgrade="some data\r\nand yet even more data"
-  ,.headers= { { "User-agent", "Mozilla/1.1N" }
-             , { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
-             }
-  ,.body= ""
-  }
-
-#define REPORT_REQ 18
-, {.name= "report request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "REPORT /test HTTP/1.1\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_REPORT
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/test"
-  ,.request_url= "/test"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= {}
-  ,.body= ""
-  }
-
-#define NO_HTTP_VERSION 19
-, {.name= "request with no http version"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 0
-  ,.http_minor= 9
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/"
-  ,.request_url= "/"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= {}
-  ,.body= ""
-  }
-
-#define MSEARCH_REQ 20
-, {.name= "m-search request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "M-SEARCH * HTTP/1.1\r\n"
-         "HOST: 239.255.255.250:1900\r\n"
-         "MAN: \"ssdp:discover\"\r\n"
-         "ST: \"ssdp:all\"\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_MSEARCH
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "*"
-  ,.request_url= "*"
-  ,.content_length= -1
-  ,.num_headers= 3
-  ,.headers= { { "HOST", "239.255.255.250:1900" }
-             , { "MAN", "\"ssdp:discover\"" }
-             , { "ST", "\"ssdp:all\"" }
-             }
-  ,.body= ""
-  }
-
-#define LINE_FOLDING_IN_HEADER 21
-, {.name= "line folding in header value"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET / HTTP/1.1\r\n"
-         "Line1:   abc\r\n"
-         "\tdef\r\n"
-         " ghi\r\n"
-         "\t\tjkl\r\n"
-         "  mno \r\n"
-         "\t \tqrs\r\n"
-         "Line2: \t line2\t\r\n"
-         "Line3:\r\n"
-         " line3\r\n"
-         "Line4: \r\n"
-         " \r\n"
-         "Connection:\r\n"
-         " close\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/"
-  ,.request_url= "/"
-  ,.content_length= -1
-  ,.num_headers= 5
-  ,.headers= { { "Line1", "abc\tdef ghi\t\tjkl  mno \t \tqrs" }
-             , { "Line2", "line2\t" }
-             , { "Line3", "line3" }
-             , { "Line4", "" }
-             , { "Connection", "close" },
-             }
-  ,.body= ""
-  }
-
-
-#define QUERY_TERMINATED_HOST 22
-, {.name= "host terminated by a query string"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET http://hypnotoad.org?hail=all HTTP/1.1\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= "hail=all"
-  ,.fragment= ""
-  ,.request_path= ""
-  ,.request_url= "http://hypnotoad.org?hail=all"
-  ,.host= "hypnotoad.org"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= { }
-  ,.body= ""
-  }
-
-#define QUERY_TERMINATED_HOSTPORT 23
-, {.name= "host:port terminated by a query string"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET http://hypnotoad.org:1234?hail=all HTTP/1.1\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= "hail=all"
-  ,.fragment= ""
-  ,.request_path= ""
-  ,.request_url= "http://hypnotoad.org:1234?hail=all"
-  ,.host= "hypnotoad.org"
-  ,.port= 1234
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= { }
-  ,.body= ""
-  }
-
-#define SPACE_TERMINATED_HOSTPORT 24
-, {.name= "host:port terminated by a space"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET http://hypnotoad.org:1234 HTTP/1.1\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= ""
-  ,.request_url= "http://hypnotoad.org:1234"
-  ,.host= "hypnotoad.org"
-  ,.port= 1234
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= { }
-  ,.body= ""
-  }
-
-#define PATCH_REQ 25
-, {.name = "PATCH request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "PATCH /file.txt HTTP/1.1\r\n"
-         "Host: www.example.com\r\n"
-         "Content-Type: application/example\r\n"
-         "If-Match: \"e0023aa4e\"\r\n"
-         "Content-Length: 10\r\n"
-         "\r\n"
-         "cccccccccc"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_PATCH
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/file.txt"
-  ,.request_url= "/file.txt"
-  ,.content_length= 10
-  ,.num_headers= 4
-  ,.headers= { { "Host", "www.example.com" }
-             , { "Content-Type", "application/example" }
-             , { "If-Match", "\"e0023aa4e\"" }
-             , { "Content-Length", "10" }
-             }
-  ,.body= "cccccccccc"
-  }
-
-#define CONNECT_CAPS_REQUEST 26
-, {.name = "connect caps request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "CONNECT HOME0.NETSCAPE.COM:443 HTTP/1.0\r\n"
-         "User-agent: Mozilla/1.1N\r\n"
-         "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.method= HTTP_CONNECT
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= ""
-  ,.request_url= "HOME0.NETSCAPE.COM:443"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.upgrade=""
-  ,.headers= { { "User-agent", "Mozilla/1.1N" }
-             , { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
-             }
-  ,.body= ""
-  }
-
-#if !HTTP_PARSER_STRICT
-#define UTF8_PATH_REQ 27
-, {.name= "utf-8 path request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /δ¶/δt/pope?q=1#narf HTTP/1.1\r\n"
-         "Host: github.com\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= "q=1"
-  ,.fragment= "narf"
-  ,.request_path= "/δ¶/δt/pope"
-  ,.request_url= "/δ¶/δt/pope?q=1#narf"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers= { {"Host", "github.com" }
-             }
-  ,.body= ""
-  }
-
-#define HOSTNAME_UNDERSCORE 28
-, {.name = "hostname underscore"
-  ,.type= HTTP_REQUEST
-  ,.raw= "CONNECT home_0.netscape.com:443 HTTP/1.0\r\n"
-         "User-agent: Mozilla/1.1N\r\n"
-         "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.method= HTTP_CONNECT
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= ""
-  ,.request_url= "home_0.netscape.com:443"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.upgrade=""
-  ,.headers= { { "User-agent", "Mozilla/1.1N" }
-             , { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
-             }
-  ,.body= ""
-  }
-#endif  /* !HTTP_PARSER_STRICT */
-
-/* see https://github.com/ry/http-parser/issues/47 */
-#define EAT_TRAILING_CRLF_NO_CONNECTION_CLOSE 29
-, {.name = "eat CRLF between requests, no \"Connection: close\" header"
-  ,.raw= "POST / HTTP/1.1\r\n"
-         "Host: www.example.com\r\n"
-         "Content-Type: application/x-www-form-urlencoded\r\n"
-         "Content-Length: 4\r\n"
-         "\r\n"
-         "q=42\r\n" /* note the trailing CRLF */
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/"
-  ,.request_url= "/"
-  ,.content_length= 4
-  ,.num_headers= 3
-  ,.upgrade= 0
-  ,.headers= { { "Host", "www.example.com" }
-             , { "Content-Type", "application/x-www-form-urlencoded" }
-             , { "Content-Length", "4" }
-             }
-  ,.body= "q=42"
-  }
-
-/* see https://github.com/ry/http-parser/issues/47 */
-#define EAT_TRAILING_CRLF_WITH_CONNECTION_CLOSE 30
-, {.name = "eat CRLF between requests even if \"Connection: close\" is set"
-  ,.raw= "POST / HTTP/1.1\r\n"
-         "Host: www.example.com\r\n"
-         "Content-Type: application/x-www-form-urlencoded\r\n"
-         "Content-Length: 4\r\n"
-         "Connection: close\r\n"
-         "\r\n"
-         "q=42\r\n" /* note the trailing CRLF */
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE /* input buffer isn't empty when on_message_complete is called */
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/"
-  ,.request_url= "/"
-  ,.content_length= 4
-  ,.num_headers= 4
-  ,.upgrade= 0
-  ,.headers= { { "Host", "www.example.com" }
-             , { "Content-Type", "application/x-www-form-urlencoded" }
-             , { "Content-Length", "4" }
-             , { "Connection", "close" }
-             }
-  ,.body= "q=42"
-  }
-
-#define PURGE_REQ 31
-, {.name = "PURGE request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "PURGE /file.txt HTTP/1.1\r\n"
-         "Host: www.example.com\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_PURGE
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/file.txt"
-  ,.request_url= "/file.txt"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers= { { "Host", "www.example.com" } }
-  ,.body= ""
-  }
-
-#define SEARCH_REQ 32
-, {.name = "SEARCH request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "SEARCH / HTTP/1.1\r\n"
-         "Host: www.example.com\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_SEARCH
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/"
-  ,.request_url= "/"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers= { { "Host", "www.example.com" } }
-  ,.body= ""
-  }
-
-#define PROXY_WITH_BASIC_AUTH 33
-, {.name= "host:port and basic_auth"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET http://a%12:b!&*$@hypnotoad.org:1234/toto HTTP/1.1\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.fragment= ""
-  ,.request_path= "/toto"
-  ,.request_url= "http://a%12:b!&*$@hypnotoad.org:1234/toto"
-  ,.host= "hypnotoad.org"
-  ,.userinfo= "a%12:b!&*$"
-  ,.port= 1234
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= { }
-  ,.body= ""
-  }
-
-#define LINE_FOLDING_IN_HEADER_WITH_LF 34
-, {.name= "line folding in header value"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET / HTTP/1.1\n"
-         "Line1:   abc\n"
-         "\tdef\n"
-         " ghi\n"
-         "\t\tjkl\n"
-         "  mno \n"
-         "\t \tqrs\n"
-         "Line2: \t line2\t\n"
-         "Line3:\n"
-         " line3\n"
-         "Line4: \n"
-         " \n"
-         "Connection:\n"
-         " close\n"
-         "\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/"
-  ,.request_url= "/"
-  ,.content_length= -1
-  ,.num_headers= 5
-  ,.headers= { { "Line1", "abc\tdef ghi\t\tjkl  mno \t \tqrs" }
-             , { "Line2", "line2\t" }
-             , { "Line3", "line3" }
-             , { "Line4", "" }
-             , { "Connection", "close" },
-             }
-  ,.body= ""
-  }
-
-#define CONNECTION_MULTI 35
-, {.name = "multiple connection header values with folding"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /demo HTTP/1.1\r\n"
-         "Host: example.com\r\n"
-         "Connection: Something,\r\n"
-         " Upgrade, ,Keep-Alive\r\n"
-         "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
-         "Sec-WebSocket-Protocol: sample\r\n"
-         "Upgrade: WebSocket\r\n"
-         "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
-         "Origin: http://example.com\r\n"
-         "\r\n"
-         "Hot diggity dogg"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/demo"
-  ,.request_url= "/demo"
-  ,.content_length= -1
-  ,.num_headers= 7
-  ,.upgrade="Hot diggity dogg"
-  ,.headers= { { "Host", "example.com" }
-             , { "Connection", "Something, Upgrade, ,Keep-Alive" }
-             , { "Sec-WebSocket-Key2", "12998 5 Y3 1  .P00" }
-             , { "Sec-WebSocket-Protocol", "sample" }
-             , { "Upgrade", "WebSocket" }
-             , { "Sec-WebSocket-Key1", "4 @1  46546xW%0l 1 5" }
-             , { "Origin", "http://example.com" }
-             }
-  ,.body= ""
-  }
-
-#define CONNECTION_MULTI_LWS 36
-, {.name = "multiple connection header values with folding and lws"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /demo HTTP/1.1\r\n"
-         "Connection: keep-alive, upgrade\r\n"
-         "Upgrade: WebSocket\r\n"
-         "\r\n"
-         "Hot diggity dogg"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/demo"
-  ,.request_url= "/demo"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.upgrade="Hot diggity dogg"
-  ,.headers= { { "Connection", "keep-alive, upgrade" }
-             , { "Upgrade", "WebSocket" }
-             }
-  ,.body= ""
-  }
-
-#define CONNECTION_MULTI_LWS_CRLF 37
-, {.name = "multiple connection header values with folding and lws"
-  ,.type= HTTP_REQUEST
-  ,.raw= "GET /demo HTTP/1.1\r\n"
-         "Connection: keep-alive, \r\n upgrade\r\n"
-         "Upgrade: WebSocket\r\n"
-         "\r\n"
-         "Hot diggity dogg"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_GET
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/demo"
-  ,.request_url= "/demo"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.upgrade="Hot diggity dogg"
-  ,.headers= { { "Connection", "keep-alive,  upgrade" }
-             , { "Upgrade", "WebSocket" }
-             }
-  ,.body= ""
-  }
-
-#define UPGRADE_POST_REQUEST 38
-, {.name = "upgrade post request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST /demo HTTP/1.1\r\n"
-         "Host: example.com\r\n"
-         "Connection: Upgrade\r\n"
-         "Upgrade: HTTP/2.0\r\n"
-         "Content-Length: 15\r\n"
-         "\r\n"
-         "sweet post body"
-         "Hot diggity dogg"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.request_path= "/demo"
-  ,.request_url= "/demo"
-  ,.content_length= 15
-  ,.num_headers= 4
-  ,.upgrade="Hot diggity dogg"
-  ,.headers= { { "Host", "example.com" }
-             , { "Connection", "Upgrade" }
-             , { "Upgrade", "HTTP/2.0" }
-             , { "Content-Length", "15" }
-             }
-  ,.body= "sweet post body"
-  }
-
-#define CONNECT_WITH_BODY_REQUEST 39
-, {.name = "connect with body request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "CONNECT foo.bar.com:443 HTTP/1.0\r\n"
-         "User-agent: Mozilla/1.1N\r\n"
-         "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
-         "Content-Length: 10\r\n"
-         "\r\n"
-         "blarfcicle"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.method= HTTP_CONNECT
-  ,.request_url= "foo.bar.com:443"
-  ,.content_length= 10
-  ,.num_headers= 3
-  ,.upgrade="blarfcicle"
-  ,.headers= { { "User-agent", "Mozilla/1.1N" }
-             , { "Proxy-authorization", "basic aGVsbG86d29ybGQ=" }
-             , { "Content-Length", "10" }
-             }
-  ,.body= ""
-  }
-
-/* Examples from the Internet draft for LINK/UNLINK methods:
- * https://tools.ietf.org/id/draft-snell-link-method-01.html#rfc.section.5
- */
-
-#define LINK_REQUEST 40
-, {.name = "link request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "LINK /images/my_dog.jpg HTTP/1.1\r\n"
-         "Host: example.com\r\n"
-         "Link: <http://example.com/profiles/joe>; rel=\"tag\"\r\n"
-         "Link: <http://example.com/profiles/sally>; rel=\"tag\"\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_LINK
-  ,.request_path= "/images/my_dog.jpg"
-  ,.request_url= "/images/my_dog.jpg"
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.content_length= -1
-  ,.num_headers= 3
-  ,.headers= { { "Host", "example.com" }
-             , { "Link", "<http://example.com/profiles/joe>; rel=\"tag\"" }
-	     , { "Link", "<http://example.com/profiles/sally>; rel=\"tag\"" }
-             }
-  ,.body= ""
-  }
-
-#define UNLINK_REQUEST 41
-, {.name = "unlink request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "UNLINK /images/my_dog.jpg HTTP/1.1\r\n"
-         "Host: example.com\r\n"
-         "Link: <http://example.com/profiles/sally>; rel=\"tag\"\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_UNLINK
-  ,.request_path= "/images/my_dog.jpg"
-  ,.request_url= "/images/my_dog.jpg"
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.headers= { { "Host", "example.com" }
-	     , { "Link", "<http://example.com/profiles/sally>; rel=\"tag\"" }
-             }
-  ,.body= ""
-  }
-
-#define SOURCE_REQUEST 42
-, {.name = "source request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "SOURCE /music/sweet/music HTTP/1.1\r\n"
-         "Host: example.com\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_SOURCE
-  ,.request_path= "/music/sweet/music"
-  ,.request_url= "/music/sweet/music"
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers= { { "Host", "example.com" } }
-  ,.body= ""
-  }
-
-#define SOURCE_ICE_REQUEST 43
-, {.name = "source request"
-  ,.type= HTTP_REQUEST
-  ,.raw= "SOURCE /music/sweet/music ICE/1.0\r\n"
-         "Host: example.com\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.method= HTTP_SOURCE
-  ,.request_path= "/music/sweet/music"
-  ,.request_url= "/music/sweet/music"
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers= { { "Host", "example.com" } }
-  ,.body= ""
-  }
-
-#define POST_MULTI_TE_LAST_CHUNKED 44
-, {.name= "post - multi coding transfer-encoding chunked body"
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST / HTTP/1.1\r\n"
-         "Transfer-Encoding: deflate, chunked\r\n"
-         "\r\n"
-         "1e\r\nall your base are belong to us\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/"
-  ,.request_url= "/"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Transfer-Encoding" , "deflate, chunked" }
-    }
-  ,.body= "all your base are belong to us"
-  ,.num_chunks_complete= 2
-  ,.chunk_lengths= { 0x1e }
-  }
-
-#define POST_MULTI_LINE_TE_LAST_CHUNKED 45
-, {.name= "post - multi line coding transfer-encoding chunked body"
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST / HTTP/1.1\r\n"
-         "Transfer-Encoding: deflate,\r\n"
-         " chunked\r\n"
-         "\r\n"
-         "1e\r\nall your base are belong to us\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/"
-  ,.request_url= "/"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Transfer-Encoding" , "deflate, chunked" }
-    }
-  ,.body= "all your base are belong to us"
-  ,.num_chunks_complete= 2
-  ,.chunk_lengths= { 0x1e }
-  }
-
-#define CHUNKED_CONTENT_LENGTH 46
-, {.name= "chunked with content-length set, allow_chunked_length flag is set"
-  ,.type= HTTP_REQUEST
-  ,.raw= "POST /chunked_w_content_length HTTP/1.1\r\n"
-         "Content-Length: 10\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "5; ilovew3;whattheluck=aretheseparametersfor\r\nhello\r\n"
-         "6; blahblah; blah\r\n world\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.allow_chunked_length = 1
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.method= HTTP_POST
-  ,.query_string= ""
-  ,.fragment= ""
-  ,.request_path= "/chunked_w_content_length"
-  ,.request_url= "/chunked_w_content_length"
-  ,.content_length= 10
-  ,.num_headers= 2
-  ,.headers={ { "Content-Length", "10"}
-            , { "Transfer-Encoding", "chunked" }
-  }
-  ,.body= "hello world"
-  ,.num_chunks_complete= 3
-  ,.chunk_lengths= { 5, 6 }
-  }
-};
-
-/* * R E S P O N S E S * */
-const struct message responses[] =
-#define GOOGLE_301 0
-{ {.name= "google 301"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 301 Moved Permanently\r\n"
-         "Location: http://www.google.com/\r\n"
-         "Content-Type: text/html; charset=UTF-8\r\n"
-         "Date: Sun, 26 Apr 2009 11:11:49 GMT\r\n"
-         "Expires: Tue, 26 May 2009 11:11:49 GMT\r\n"
-         "X-$PrototypeBI-Version: 1.6.0.3\r\n" /* $ char in header field */
-         "Cache-Control: public, max-age=2592000\r\n"
-         "Server: gws\r\n"
-         "Content-Length:  219  \r\n"
-         "\r\n"
-         "<HTML><HEAD><meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\">\n"
-         "<TITLE>301 Moved</TITLE></HEAD><BODY>\n"
-         "<H1>301 Moved</H1>\n"
-         "The document has moved\n"
-         "<A HREF=\"http://www.google.com/\">here</A>.\r\n"
-         "</BODY></HTML>\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 301
-  ,.response_status= "Moved Permanently"
-  ,.content_length= 219
-  ,.num_headers= 8
-  ,.headers=
-    { { "Location", "http://www.google.com/" }
-    , { "Content-Type", "text/html; charset=UTF-8" }
-    , { "Date", "Sun, 26 Apr 2009 11:11:49 GMT" }
-    , { "Expires", "Tue, 26 May 2009 11:11:49 GMT" }
-    , { "X-$PrototypeBI-Version", "1.6.0.3" }
-    , { "Cache-Control", "public, max-age=2592000" }
-    , { "Server", "gws" }
-    , { "Content-Length", "219  " }
-    }
-  ,.body= "<HTML><HEAD><meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\">\n"
-          "<TITLE>301 Moved</TITLE></HEAD><BODY>\n"
-          "<H1>301 Moved</H1>\n"
-          "The document has moved\n"
-          "<A HREF=\"http://www.google.com/\">here</A>.\r\n"
-          "</BODY></HTML>\r\n"
-  }
-
-#define NO_CONTENT_LENGTH_RESPONSE 1
-/* The client should wait for the server's EOF. That is, when content-length
- * is not specified, and "Connection: close", the end of body is specified
- * by the EOF.
- * Compare with APACHEBENCH_GET
- */
-, {.name= "no content-length response"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Date: Tue, 04 Aug 2009 07:59:32 GMT\r\n"
-         "Server: Apache\r\n"
-         "X-Powered-By: Servlet/2.5 JSP/2.1\r\n"
-         "Content-Type: text/xml; charset=utf-8\r\n"
-         "Connection: close\r\n"
-         "\r\n"
-         "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-         "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
-         "  <SOAP-ENV:Body>\n"
-         "    <SOAP-ENV:Fault>\n"
-         "       <faultcode>SOAP-ENV:Client</faultcode>\n"
-         "       <faultstring>Client Error</faultstring>\n"
-         "    </SOAP-ENV:Fault>\n"
-         "  </SOAP-ENV:Body>\n"
-         "</SOAP-ENV:Envelope>"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 5
-  ,.headers=
-    { { "Date", "Tue, 04 Aug 2009 07:59:32 GMT" }
-    , { "Server", "Apache" }
-    , { "X-Powered-By", "Servlet/2.5 JSP/2.1" }
-    , { "Content-Type", "text/xml; charset=utf-8" }
-    , { "Connection", "close" }
-    }
-  ,.body= "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-          "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
-          "  <SOAP-ENV:Body>\n"
-          "    <SOAP-ENV:Fault>\n"
-          "       <faultcode>SOAP-ENV:Client</faultcode>\n"
-          "       <faultstring>Client Error</faultstring>\n"
-          "    </SOAP-ENV:Fault>\n"
-          "  </SOAP-ENV:Body>\n"
-          "</SOAP-ENV:Envelope>"
-  }
-
-#define NO_HEADERS_NO_BODY_404 2
-, {.name= "404 no headers no body"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 404 Not Found\r\n\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 404
-  ,.response_status= "Not Found"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= {}
-  ,.body_size= 0
-  ,.body= ""
-  }
-
-#define NO_REASON_PHRASE 3
-, {.name= "301 no response phrase"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 301\r\n\r\n"
-  ,.should_keep_alive = FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 301
-  ,.content_length= -1
-  ,.response_status= ""
-  ,.num_headers= 0
-  ,.headers= {}
-  ,.body= ""
-  }
-
-#define TRAILING_SPACE_ON_CHUNKED_BODY 4
-, {.name="200 trailing space on chunked body"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Content-Type: text/plain\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "25  \r\n"
-         "This is the data in the first chunk\r\n"
-         "\r\n"
-         "1C\r\n"
-         "and this is the second one\r\n"
-         "\r\n"
-         "0  \r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.headers=
-    { {"Content-Type", "text/plain" }
-    , {"Transfer-Encoding", "chunked" }
-    }
-  ,.body_size = 37+28
-  ,.body =
-         "This is the data in the first chunk\r\n"
-         "and this is the second one\r\n"
-  ,.num_chunks_complete= 3
-  ,.chunk_lengths= { 0x25, 0x1c }
-  }
-
-#define NO_CARRIAGE_RET 5
-, {.name="no carriage ret"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\n"
-         "Content-Type: text/html; charset=utf-8\n"
-         "Connection: close\n"
-         "\n"
-         "these headers are from http://news.ycombinator.com/"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.headers=
-    { {"Content-Type", "text/html; charset=utf-8" }
-    , {"Connection", "close" }
-    }
-  ,.body= "these headers are from http://news.ycombinator.com/"
-  }
-
-#define PROXY_CONNECTION 6
-, {.name="proxy connection"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Content-Type: text/html; charset=UTF-8\r\n"
-         "Content-Length: 11\r\n"
-         "Proxy-Connection: close\r\n"
-         "Date: Thu, 31 Dec 2009 20:55:48 +0000\r\n"
-         "\r\n"
-         "hello world"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= 11
-  ,.num_headers= 4
-  ,.headers=
-    { {"Content-Type", "text/html; charset=UTF-8" }
-    , {"Content-Length", "11" }
-    , {"Proxy-Connection", "close" }
-    , {"Date", "Thu, 31 Dec 2009 20:55:48 +0000"}
-    }
-  ,.body= "hello world"
-  }
-
-#define UNDERSTORE_HEADER_KEY 7
-  // shown by
-  // curl -o /dev/null -v "http://ad.doubleclick.net/pfadx/DARTSHELLCONFIGXML;dcmt=text/xml;"
-, {.name="underscore header key"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Server: DCLK-AdSvr\r\n"
-         "Content-Type: text/xml\r\n"
-         "Content-Length: 0\r\n"
-         "DCLK_imp: v7;x;114750856;0-0;0;17820020;0/0;21603567/21621457/1;;~okv=;dcmt=text/xml;;~cs=o\r\n\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= 0
-  ,.num_headers= 4
-  ,.headers=
-    { {"Server", "DCLK-AdSvr" }
-    , {"Content-Type", "text/xml" }
-    , {"Content-Length", "0" }
-    , {"DCLK_imp", "v7;x;114750856;0-0;0;17820020;0/0;21603567/21621457/1;;~okv=;dcmt=text/xml;;~cs=o" }
-    }
-  ,.body= ""
-  }
-
-#define BONJOUR_MADAME_FR 8
-/* The client should not merge two headers fields when the first one doesn't
- * have a value.
- */
-, {.name= "bonjourmadame.fr"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.0 301 Moved Permanently\r\n"
-         "Date: Thu, 03 Jun 2010 09:56:32 GMT\r\n"
-         "Server: Apache/2.2.3 (Red Hat)\r\n"
-         "Cache-Control: public\r\n"
-         "Pragma: \r\n"
-         "Location: http://www.bonjourmadame.fr/\r\n"
-         "Vary: Accept-Encoding\r\n"
-         "Content-Length: 0\r\n"
-         "Content-Type: text/html; charset=UTF-8\r\n"
-         "Connection: keep-alive\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.status_code= 301
-  ,.response_status= "Moved Permanently"
-  ,.content_length= 0
-  ,.num_headers= 9
-  ,.headers=
-    { { "Date", "Thu, 03 Jun 2010 09:56:32 GMT" }
-    , { "Server", "Apache/2.2.3 (Red Hat)" }
-    , { "Cache-Control", "public" }
-    , { "Pragma", "" }
-    , { "Location", "http://www.bonjourmadame.fr/" }
-    , { "Vary",  "Accept-Encoding" }
-    , { "Content-Length", "0" }
-    , { "Content-Type", "text/html; charset=UTF-8" }
-    , { "Connection", "keep-alive" }
-    }
-  ,.body= ""
-  }
-
-#define RES_FIELD_UNDERSCORE 9
-/* Should handle spaces in header fields */
-, {.name= "field underscore"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Date: Tue, 28 Sep 2010 01:14:13 GMT\r\n"
-         "Server: Apache\r\n"
-         "Cache-Control: no-cache, must-revalidate\r\n"
-         "Expires: Mon, 26 Jul 1997 05:00:00 GMT\r\n"
-         ".et-Cookie: PlaxoCS=1274804622353690521; path=/; domain=.plaxo.com\r\n"
-         "Vary: Accept-Encoding\r\n"
-         "_eep-Alive: timeout=45\r\n" /* semantic value ignored */
-         "_onnection: Keep-Alive\r\n" /* semantic value ignored */
-         "Transfer-Encoding: chunked\r\n"
-         "Content-Type: text/html\r\n"
-         "Connection: close\r\n"
-         "\r\n"
-         "0\r\n\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 11
-  ,.headers=
-    { { "Date", "Tue, 28 Sep 2010 01:14:13 GMT" }
-    , { "Server", "Apache" }
-    , { "Cache-Control", "no-cache, must-revalidate" }
-    , { "Expires", "Mon, 26 Jul 1997 05:00:00 GMT" }
-    , { ".et-Cookie", "PlaxoCS=1274804622353690521; path=/; domain=.plaxo.com" }
-    , { "Vary", "Accept-Encoding" }
-    , { "_eep-Alive", "timeout=45" }
-    , { "_onnection", "Keep-Alive" }
-    , { "Transfer-Encoding", "chunked" }
-    , { "Content-Type", "text/html" }
-    , { "Connection", "close" }
-    }
-  ,.body= ""
-  ,.num_chunks_complete= 1
-  ,.chunk_lengths= {}
-  }
-
-#define NON_ASCII_IN_STATUS_LINE 10
-/* Should handle non-ASCII in status line */
-, {.name= "non-ASCII in status line"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 500 Oriëntatieprobleem\r\n"
-         "Date: Fri, 5 Nov 2010 23:07:12 GMT+2\r\n"
-         "Content-Length: 0\r\n"
-         "Connection: close\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 500
-  ,.response_status= "Oriëntatieprobleem"
-  ,.content_length= 0
-  ,.num_headers= 3
-  ,.headers=
-    { { "Date", "Fri, 5 Nov 2010 23:07:12 GMT+2" }
-    , { "Content-Length", "0" }
-    , { "Connection", "close" }
-    }
-  ,.body= ""
-  }
-
-#define HTTP_VERSION_0_9 11
-/* Should handle HTTP/0.9 */
-, {.name= "http version 0.9"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/0.9 200 OK\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 0
-  ,.http_minor= 9
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers=
-    {}
-  ,.body= ""
-  }
-
-#define NO_CONTENT_LENGTH_NO_TRANSFER_ENCODING_RESPONSE 12
-/* The client should wait for the server's EOF. That is, when neither
- * content-length nor transfer-encoding is specified, the end of body
- * is specified by the EOF.
- */
-, {.name= "neither content-length nor transfer-encoding response"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Content-Type: text/plain\r\n"
-         "\r\n"
-         "hello world"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Content-Type", "text/plain" }
-    }
-  ,.body= "hello world"
-  }
-
-#define NO_BODY_HTTP10_KA_200 13
-, {.name= "HTTP/1.0 with keep-alive and EOF-terminated 200 status"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.0 200 OK\r\n"
-         "Connection: keep-alive\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Connection", "keep-alive" }
-    }
-  ,.body_size= 0
-  ,.body= ""
-  }
-
-#define NO_BODY_HTTP10_KA_204 14
-, {.name= "HTTP/1.0 with keep-alive and a 204 status"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.0 204 No content\r\n"
-         "Connection: keep-alive\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 0
-  ,.status_code= 204
-  ,.response_status= "No content"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Connection", "keep-alive" }
-    }
-  ,.body_size= 0
-  ,.body= ""
-  }
-
-#define NO_BODY_HTTP11_KA_200 15
-, {.name= "HTTP/1.1 with an EOF-terminated 200 status"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers={}
-  ,.body_size= 0
-  ,.body= ""
-  }
-
-#define NO_BODY_HTTP11_KA_204 16
-, {.name= "HTTP/1.1 with a 204 status"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 204 No content\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 204
-  ,.response_status= "No content"
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers={}
-  ,.body_size= 0
-  ,.body= ""
-  }
-
-#define NO_BODY_HTTP11_NOKA_204 17
-, {.name= "HTTP/1.1 with a 204 status and keep-alive disabled"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 204 No content\r\n"
-         "Connection: close\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 204
-  ,.response_status= "No content"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Connection", "close" }
-    }
-  ,.body_size= 0
-  ,.body= ""
-  }
-
-#define NO_BODY_HTTP11_KA_CHUNKED_200 18
-, {.name= "HTTP/1.1 with chunked endocing and a 200 response"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers=
-    { { "Transfer-Encoding", "chunked" }
-    }
-  ,.body_size= 0
-  ,.body= ""
-  ,.num_chunks_complete= 1
-  }
-
-#if !HTTP_PARSER_STRICT
-#define SPACE_IN_FIELD_RES 19
-/* Should handle spaces in header fields */
-, {.name= "field space"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Server: Microsoft-IIS/6.0\r\n"
-         "X-Powered-By: ASP.NET\r\n"
-         "en-US Content-Type: text/xml\r\n" /* this is the problem */
-         "Content-Type: text/xml\r\n"
-         "Content-Length: 16\r\n"
-         "Date: Fri, 23 Jul 2010 18:45:38 GMT\r\n"
-         "Connection: keep-alive\r\n"
-         "\r\n"
-         "<xml>hello</xml>" /* fake body */
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= 16
-  ,.num_headers= 7
-  ,.headers=
-    { { "Server",  "Microsoft-IIS/6.0" }
-    , { "X-Powered-By", "ASP.NET" }
-    , { "en-US Content-Type", "text/xml" }
-    , { "Content-Type", "text/xml" }
-    , { "Content-Length", "16" }
-    , { "Date", "Fri, 23 Jul 2010 18:45:38 GMT" }
-    , { "Connection", "keep-alive" }
-    }
-  ,.body= "<xml>hello</xml>"
-  }
-#endif /* !HTTP_PARSER_STRICT */
-
-#define AMAZON_COM 20
-, {.name= "amazon.com"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 301 MovedPermanently\r\n"
-         "Date: Wed, 15 May 2013 17:06:33 GMT\r\n"
-         "Server: Server\r\n"
-         "x-amz-id-1: 0GPHKXSJQ826RK7GZEB2\r\n"
-         "p3p: policyref=\"http://www.amazon.com/w3c/p3p.xml\",CP=\"CAO DSP LAW CUR ADM IVAo IVDo CONo OTPo OUR DELi PUBi OTRi BUS PHY ONL UNI PUR FIN COM NAV INT DEM CNT STA HEA PRE LOC GOV OTC \"\r\n"
-         "x-amz-id-2: STN69VZxIFSz9YJLbz1GDbxpbjG6Qjmmq5E3DxRhOUw+Et0p4hr7c/Q8qNcx4oAD\r\n"
-         "Location: http://www.amazon.com/Dan-Brown/e/B000AP9DSU/ref=s9_pop_gw_al1?_encoding=UTF8&refinementId=618073011&pf_rd_m=ATVPDKIKX0DER&pf_rd_s=center-2&pf_rd_r=0SHYY5BZXN3KR20BNFAY&pf_rd_t=101&pf_rd_p=1263340922&pf_rd_i=507846\r\n"
-         "Vary: Accept-Encoding,User-Agent\r\n"
-         "Content-Type: text/html; charset=ISO-8859-1\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "1\r\n"
-         "\n\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 301
-  ,.response_status= "MovedPermanently"
-  ,.content_length= -1
-  ,.num_headers= 9
-  ,.headers= { { "Date", "Wed, 15 May 2013 17:06:33 GMT" }
-             , { "Server", "Server" }
-             , { "x-amz-id-1", "0GPHKXSJQ826RK7GZEB2" }
-             , { "p3p", "policyref=\"http://www.amazon.com/w3c/p3p.xml\",CP=\"CAO DSP LAW CUR ADM IVAo IVDo CONo OTPo OUR DELi PUBi OTRi BUS PHY ONL UNI PUR FIN COM NAV INT DEM CNT STA HEA PRE LOC GOV OTC \"" }
-             , { "x-amz-id-2", "STN69VZxIFSz9YJLbz1GDbxpbjG6Qjmmq5E3DxRhOUw+Et0p4hr7c/Q8qNcx4oAD" }
-             , { "Location", "http://www.amazon.com/Dan-Brown/e/B000AP9DSU/ref=s9_pop_gw_al1?_encoding=UTF8&refinementId=618073011&pf_rd_m=ATVPDKIKX0DER&pf_rd_s=center-2&pf_rd_r=0SHYY5BZXN3KR20BNFAY&pf_rd_t=101&pf_rd_p=1263340922&pf_rd_i=507846" }
-             , { "Vary", "Accept-Encoding,User-Agent" }
-             , { "Content-Type", "text/html; charset=ISO-8859-1" }
-             , { "Transfer-Encoding", "chunked" }
-             }
-  ,.body= "\n"
-  ,.num_chunks_complete= 2
-  ,.chunk_lengths= { 1 }
-  }
-
-#define EMPTY_REASON_PHRASE_AFTER_SPACE 21
-, {.name= "empty reason phrase after space"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 \r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= ""
-  ,.content_length= -1
-  ,.num_headers= 0
-  ,.headers= {}
-  ,.body= ""
-  }
-
-#define CONTENT_LENGTH_X 22
-, {.name= "Content-Length-X"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Content-Length-X: 0\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "2\r\n"
-         "OK\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.headers= { { "Content-Length-X", "0" }
-             , { "Transfer-Encoding", "chunked" }
-             }
-  ,.body= "OK"
-  ,.num_chunks_complete= 2
-  ,.chunk_lengths= { 2 }
-  }
-
-#define HTTP_101_RESPONSE_WITH_UPGRADE_HEADER 23
-, {.name= "HTTP 101 response with Upgrade header"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 101 Switching Protocols\r\n"
-         "Connection: upgrade\r\n"
-         "Upgrade: h2c\r\n"
-         "\r\n"
-         "proto"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 101
-  ,.response_status= "Switching Protocols"
-  ,.upgrade= "proto"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.headers=
-    { { "Connection", "upgrade" }
-    , { "Upgrade", "h2c" }
-    }
-  }
-
-#define HTTP_101_RESPONSE_WITH_UPGRADE_HEADER_AND_CONTENT_LENGTH 24
-, {.name= "HTTP 101 response with Upgrade and Content-Length header"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 101 Switching Protocols\r\n"
-         "Connection: upgrade\r\n"
-         "Upgrade: h2c\r\n"
-         "Content-Length: 4\r\n"
-         "\r\n"
-         "body"
-         "proto"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 101
-  ,.response_status= "Switching Protocols"
-  ,.body= "body"
-  ,.upgrade= "proto"
-  ,.content_length= 4
-  ,.num_headers= 3
-  ,.headers=
-    { { "Connection", "upgrade" }
-    , { "Upgrade", "h2c" }
-    , { "Content-Length", "4" }
-    }
-  }
-
-#define HTTP_101_RESPONSE_WITH_UPGRADE_HEADER_AND_TRANSFER_ENCODING 25
-, {.name= "HTTP 101 response with Upgrade and Transfer-Encoding header"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 101 Switching Protocols\r\n"
-         "Connection: upgrade\r\n"
-         "Upgrade: h2c\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "2\r\n"
-         "bo\r\n"
-         "2\r\n"
-         "dy\r\n"
-         "0\r\n"
-         "\r\n"
-         "proto"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 101
-  ,.response_status= "Switching Protocols"
-  ,.body= "body"
-  ,.upgrade= "proto"
-  ,.content_length= -1
-  ,.num_headers= 3
-  ,.headers=
-    { { "Connection", "upgrade" }
-    , { "Upgrade", "h2c" }
-    , { "Transfer-Encoding", "chunked" }
-    }
-  ,.num_chunks_complete= 3
-  ,.chunk_lengths= { 2, 2 }
-  }
-
-#define HTTP_200_RESPONSE_WITH_UPGRADE_HEADER 26
-, {.name= "HTTP 200 response with Upgrade header"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Connection: upgrade\r\n"
-         "Upgrade: h2c\r\n"
-         "\r\n"
-         "body"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.body= "body"
-  ,.upgrade= NULL
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.headers=
-    { { "Connection", "upgrade" }
-    , { "Upgrade", "h2c" }
-    }
-  }
-
-#define HTTP_200_RESPONSE_WITH_UPGRADE_HEADER_AND_CONTENT_LENGTH 27
-, {.name= "HTTP 200 response with Upgrade and Content-Length header"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Connection: upgrade\r\n"
-         "Upgrade: h2c\r\n"
-         "Content-Length: 4\r\n"
-         "\r\n"
-         "body"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= 4
-  ,.num_headers= 3
-  ,.body= "body"
-  ,.upgrade= NULL
-  ,.headers=
-    { { "Connection", "upgrade" }
-    , { "Upgrade", "h2c" }
-    , { "Content-Length", "4" }
-    }
-  }
-
-#define HTTP_200_RESPONSE_WITH_UPGRADE_HEADER_AND_TRANSFER_ENCODING 28
-, {.name= "HTTP 200 response with Upgrade and Transfer-Encoding header"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Connection: upgrade\r\n"
-         "Upgrade: h2c\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "\r\n"
-         "2\r\n"
-         "bo\r\n"
-         "2\r\n"
-         "dy\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= TRUE
-  ,.message_complete_on_eof= FALSE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 3
-  ,.body= "body"
-  ,.upgrade= NULL
-  ,.headers=
-    { { "Connection", "upgrade" }
-    , { "Upgrade", "h2c" }
-    , { "Transfer-Encoding", "chunked" }
-    }
-  ,.num_chunks_complete= 3
-  ,.chunk_lengths= { 2, 2 }
-  }
-#define HTTP_200_MULTI_TE_NOT_LAST_CHUNKED 29
-, {.name= "HTTP 200 response with `chunked` being *not last* Transfer-Encoding"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Transfer-Encoding: chunked, identity\r\n"
-         "\r\n"
-         "2\r\n"
-         "OK\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 1
-  ,.headers= { { "Transfer-Encoding", "chunked, identity" }
-             }
-  ,.body= "2\r\nOK\r\n0\r\n\r\n"
-  ,.num_chunks_complete= 0
-  }
-#define HTTP_200_DUPLICATE_TE_NOT_LAST_CHUNKED 30
-, {.name= "HTTP 200 response with `chunked` and duplicate Transfer-Encoding"
-  ,.type= HTTP_RESPONSE
-  ,.raw= "HTTP/1.1 200 OK\r\n"
-         "Transfer-Encoding: chunked\r\n"
-         "Transfer-Encoding: identity\r\n"
-         "\r\n"
-         "2\r\n"
-         "OK\r\n"
-         "0\r\n"
-         "\r\n"
-  ,.should_keep_alive= FALSE
-  ,.message_complete_on_eof= TRUE
-  ,.http_major= 1
-  ,.http_minor= 1
-  ,.status_code= 200
-  ,.response_status= "OK"
-  ,.content_length= -1
-  ,.num_headers= 2
-  ,.headers=
-    { { "Transfer-Encoding", "chunked" }
-    , { "Transfer-Encoding", "identity" }
-    }
-  ,.body= "2\r\nOK\r\n0\r\n\r\n"
-  ,.num_chunks_complete= 0
-  }
-};
-
-/* strnlen() is a POSIX.2008 addition. Can't rely on it being available so
- * define it ourselves.
- */
-size_t
-strnlen(const char *s, size_t maxlen)
-{
-  const char *p;
-
-  p = memchr(s, '\0', maxlen);
-  if (p == NULL)
-    return maxlen;
-
-  return p - s;
-}
-
-size_t
-strlncat(char *dst, size_t len, const char *src, size_t n)
-{
-  size_t slen;
-  size_t dlen;
-  size_t rlen;
-  size_t ncpy;
-
-  slen = strnlen(src, n);
-  dlen = strnlen(dst, len);
-
-  if (dlen < len) {
-    rlen = len - dlen;
-    ncpy = slen < rlen ? slen : (rlen - 1);
-    memcpy(dst + dlen, src, ncpy);
-    dst[dlen + ncpy] = '\0';
-  }
-
-  assert(len > slen + dlen);
-  return slen + dlen;
-}
-
-size_t
-strlncpy(char *dst, size_t len, const char *src, size_t n)
-{
-  size_t slen;
-  size_t ncpy;
-
-  slen = strnlen(src, n);
-
-  if (len > 0) {
-    ncpy = slen < len ? slen : (len - 1);
-    memcpy(dst, src, ncpy);
-    dst[ncpy] = '\0';
-  }
-
-  assert(len > slen);
-  return slen;
-}
-
-int
-request_url_cb (http_parser *p, const char *buf, size_t len)
-{
-  assert(p == &parser);
-  strlncat(messages[num_messages].request_url,
-           sizeof(messages[num_messages].request_url),
-           buf,
-           len);
-  return 0;
-}
-
-int
-header_field_cb (http_parser *p, const char *buf, size_t len)
-{
-  assert(p == &parser);
-  struct message *m = &messages[num_messages];
-
-  if (m->last_header_element != FIELD)
-    m->num_headers++;
-
-  strlncat(m->headers[m->num_headers-1][0],
-           sizeof(m->headers[m->num_headers-1][0]),
-           buf,
-           len);
-
-  m->last_header_element = FIELD;
-
-  return 0;
-}
-
-int
-header_value_cb (http_parser *p, const char *buf, size_t len)
-{
-  assert(p == &parser);
-  struct message *m = &messages[num_messages];
-
-  strlncat(m->headers[m->num_headers-1][1],
-           sizeof(m->headers[m->num_headers-1][1]),
-           buf,
-           len);
-
-  m->last_header_element = VALUE;
-
-  return 0;
-}
-
-void
-check_body_is_final (const http_parser *p)
-{
-  if (messages[num_messages].body_is_final) {
-    fprintf(stderr, "\n\n *** Error http_body_is_final() should return 1 "
-                    "on last on_body callback call "
-                    "but it doesn't! ***\n\n");
-    assert(0);
-    abort();
-  }
-  messages[num_messages].body_is_final = http_body_is_final(p);
-}
-
-int
-body_cb (http_parser *p, const char *buf, size_t len)
-{
-  assert(p == &parser);
-  strlncat(messages[num_messages].body,
-           sizeof(messages[num_messages].body),
-           buf,
-           len);
-  messages[num_messages].body_size += len;
-  check_body_is_final(p);
- // printf("body_cb: '%s'\n", requests[num_messages].body);
-  return 0;
-}
-
-int
-count_body_cb (http_parser *p, const char *buf, size_t len)
-{
-  assert(p == &parser);
-  assert(buf);
-  messages[num_messages].body_size += len;
-  check_body_is_final(p);
-  return 0;
-}
-
-int
-message_begin_cb (http_parser *p)
-{
-  assert(p == &parser);
-  assert(!messages[num_messages].message_begin_cb_called);
-  messages[num_messages].message_begin_cb_called = TRUE;
-  return 0;
-}
-
-int
-headers_complete_cb (http_parser *p)
-{
-  assert(p == &parser);
-  messages[num_messages].method = parser.method;
-  messages[num_messages].status_code = parser.status_code;
-  messages[num_messages].http_major = parser.http_major;
-  messages[num_messages].http_minor = parser.http_minor;
-  messages[num_messages].content_length = parser.content_length;
-  messages[num_messages].headers_complete_cb_called = TRUE;
-  messages[num_messages].should_keep_alive = http_should_keep_alive(&parser);
-  return 0;
-}
-
-int
-message_complete_cb (http_parser *p)
-{
-  assert(p == &parser);
-  if (messages[num_messages].should_keep_alive !=
-      http_should_keep_alive(&parser))
-  {
-    fprintf(stderr, "\n\n *** Error http_should_keep_alive() should have same "
-                    "value in both on_message_complete and on_headers_complete "
-                    "but it doesn't! ***\n\n");
-    assert(0);
-    abort();
-  }
-
-  if (messages[num_messages].body_size &&
-      http_body_is_final(p) &&
-      !messages[num_messages].body_is_final)
-  {
-    fprintf(stderr, "\n\n *** Error http_body_is_final() should return 1 "
-                    "on last on_body callback call "
-                    "but it doesn't! ***\n\n");
-    assert(0);
-    abort();
-  }
-
-  messages[num_messages].message_complete_cb_called = TRUE;
-
-  messages[num_messages].message_complete_on_eof = currently_parsing_eof;
-
-  num_messages++;
-  return 0;
-}
-
-int
-response_status_cb (http_parser *p, const char *buf, size_t len)
-{
-  assert(p == &parser);
-
-  messages[num_messages].status_cb_called = TRUE;
-
-  strlncat(messages[num_messages].response_status,
-           sizeof(messages[num_messages].response_status),
-           buf,
-           len);
-  return 0;
-}
-
-int
-chunk_header_cb (http_parser *p)
-{
-  assert(p == &parser);
-  int chunk_idx = messages[num_messages].num_chunks;
-  messages[num_messages].num_chunks++;
-  if (chunk_idx < MAX_CHUNKS) {
-    messages[num_messages].chunk_lengths[chunk_idx] = p->content_length;
-  }
-
-  return 0;
-}
-
-int
-chunk_complete_cb (http_parser *p)
-{
-  assert(p == &parser);
-
-  /* Here we want to verify that each chunk_header_cb is matched by a
-   * chunk_complete_cb, so not only should the total number of calls to
-   * both callbacks be the same, but they also should be interleaved
-   * properly */
-  assert(messages[num_messages].num_chunks ==
-         messages[num_messages].num_chunks_complete + 1);
-
-  messages[num_messages].num_chunks_complete++;
-  return 0;
-}
-
-/* These dontcall_* callbacks exist so that we can verify that when we're
- * paused, no additional callbacks are invoked */
-int
-dontcall_message_begin_cb (http_parser *p)
-{
-  if (p) { } // gcc
-  fprintf(stderr, "\n\n*** on_message_begin() called on paused parser ***\n\n");
-  abort();
-}
-
-int
-dontcall_header_field_cb (http_parser *p, const char *buf, size_t len)
-{
-  if (p || buf || len) { } // gcc
-  fprintf(stderr, "\n\n*** on_header_field() called on paused parser ***\n\n");
-  abort();
-}
-
-int
-dontcall_header_value_cb (http_parser *p, const char *buf, size_t len)
-{
-  if (p || buf || len) { } // gcc
-  fprintf(stderr, "\n\n*** on_header_value() called on paused parser ***\n\n");
-  abort();
-}
-
-int
-dontcall_request_url_cb (http_parser *p, const char *buf, size_t len)
-{
-  if (p || buf || len) { } // gcc
-  fprintf(stderr, "\n\n*** on_request_url() called on paused parser ***\n\n");
-  abort();
-}
-
-int
-dontcall_body_cb (http_parser *p, const char *buf, size_t len)
-{
-  if (p || buf || len) { } // gcc
-  fprintf(stderr, "\n\n*** on_body_cb() called on paused parser ***\n\n");
-  abort();
-}
-
-int
-dontcall_headers_complete_cb (http_parser *p)
-{
-  if (p) { } // gcc
-  fprintf(stderr, "\n\n*** on_headers_complete() called on paused "
-                  "parser ***\n\n");
-  abort();
-}
-
-int
-dontcall_message_complete_cb (http_parser *p)
-{
-  if (p) { } // gcc
-  fprintf(stderr, "\n\n*** on_message_complete() called on paused "
-                  "parser ***\n\n");
-  abort();
-}
-
-int
-dontcall_response_status_cb (http_parser *p, const char *buf, size_t len)
-{
-  if (p || buf || len) { } // gcc
-  fprintf(stderr, "\n\n*** on_status() called on paused parser ***\n\n");
-  abort();
-}
-
-int
-dontcall_chunk_header_cb (http_parser *p)
-{
-  if (p) { } // gcc
-  fprintf(stderr, "\n\n*** on_chunk_header() called on paused parser ***\n\n");
-  exit(1);
-}
-
-int
-dontcall_chunk_complete_cb (http_parser *p)
-{
-  if (p) { } // gcc
-  fprintf(stderr, "\n\n*** on_chunk_complete() "
-          "called on paused parser ***\n\n");
-  exit(1);
-}
-
-static http_parser_settings settings_dontcall =
-  {.on_message_begin = dontcall_message_begin_cb
-  ,.on_header_field = dontcall_header_field_cb
-  ,.on_header_value = dontcall_header_value_cb
-  ,.on_url = dontcall_request_url_cb
-  ,.on_status = dontcall_response_status_cb
-  ,.on_body = dontcall_body_cb
-  ,.on_headers_complete = dontcall_headers_complete_cb
-  ,.on_message_complete = dontcall_message_complete_cb
-  ,.on_chunk_header = dontcall_chunk_header_cb
-  ,.on_chunk_complete = dontcall_chunk_complete_cb
-  };
-
-/* These pause_* callbacks always pause the parser and just invoke the regular
- * callback that tracks content. Before returning, we overwrite the parser
- * settings to point to the _dontcall variety so that we can verify that
- * the pause actually did, you know, pause. */
-int
-pause_message_begin_cb (http_parser *p)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return message_begin_cb(p);
-}
-
-int
-pause_header_field_cb (http_parser *p, const char *buf, size_t len)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return header_field_cb(p, buf, len);
-}
-
-int
-pause_header_value_cb (http_parser *p, const char *buf, size_t len)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return header_value_cb(p, buf, len);
-}
-
-int
-pause_request_url_cb (http_parser *p, const char *buf, size_t len)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return request_url_cb(p, buf, len);
-}
-
-int
-pause_body_cb (http_parser *p, const char *buf, size_t len)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return body_cb(p, buf, len);
-}
-
-int
-pause_headers_complete_cb (http_parser *p)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return headers_complete_cb(p);
-}
-
-int
-pause_message_complete_cb (http_parser *p)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return message_complete_cb(p);
-}
-
-int
-pause_response_status_cb (http_parser *p, const char *buf, size_t len)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return response_status_cb(p, buf, len);
-}
-
-int
-pause_chunk_header_cb (http_parser *p)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return chunk_header_cb(p);
-}
-
-int
-pause_chunk_complete_cb (http_parser *p)
-{
-  http_parser_pause(p, 1);
-  *current_pause_parser = settings_dontcall;
-  return chunk_complete_cb(p);
-}
-
-int
-connect_headers_complete_cb (http_parser *p)
-{
-  headers_complete_cb(p);
-  return 1;
-}
-
-int
-connect_message_complete_cb (http_parser *p)
-{
-  messages[num_messages].should_keep_alive = http_should_keep_alive(&parser);
-  return message_complete_cb(p);
-}
-
-static http_parser_settings settings_pause =
-  {.on_message_begin = pause_message_begin_cb
-  ,.on_header_field = pause_header_field_cb
-  ,.on_header_value = pause_header_value_cb
-  ,.on_url = pause_request_url_cb
-  ,.on_status = pause_response_status_cb
-  ,.on_body = pause_body_cb
-  ,.on_headers_complete = pause_headers_complete_cb
-  ,.on_message_complete = pause_message_complete_cb
-  ,.on_chunk_header = pause_chunk_header_cb
-  ,.on_chunk_complete = pause_chunk_complete_cb
-  };
-
-static http_parser_settings settings =
-  {.on_message_begin = message_begin_cb
-  ,.on_header_field = header_field_cb
-  ,.on_header_value = header_value_cb
-  ,.on_url = request_url_cb
-  ,.on_status = response_status_cb
-  ,.on_body = body_cb
-  ,.on_headers_complete = headers_complete_cb
-  ,.on_message_complete = message_complete_cb
-  ,.on_chunk_header = chunk_header_cb
-  ,.on_chunk_complete = chunk_complete_cb
-  };
-
-static http_parser_settings settings_count_body =
-  {.on_message_begin = message_begin_cb
-  ,.on_header_field = header_field_cb
-  ,.on_header_value = header_value_cb
-  ,.on_url = request_url_cb
-  ,.on_status = response_status_cb
-  ,.on_body = count_body_cb
-  ,.on_headers_complete = headers_complete_cb
-  ,.on_message_complete = message_complete_cb
-  ,.on_chunk_header = chunk_header_cb
-  ,.on_chunk_complete = chunk_complete_cb
-  };
-
-static http_parser_settings settings_connect =
-  {.on_message_begin = message_begin_cb
-  ,.on_header_field = header_field_cb
-  ,.on_header_value = header_value_cb
-  ,.on_url = request_url_cb
-  ,.on_status = response_status_cb
-  ,.on_body = dontcall_body_cb
-  ,.on_headers_complete = connect_headers_complete_cb
-  ,.on_message_complete = connect_message_complete_cb
-  ,.on_chunk_header = chunk_header_cb
-  ,.on_chunk_complete = chunk_complete_cb
-  };
-
-static http_parser_settings settings_null =
-  {.on_message_begin = 0
-  ,.on_header_field = 0
-  ,.on_header_value = 0
-  ,.on_url = 0
-  ,.on_status = 0
-  ,.on_body = 0
-  ,.on_headers_complete = 0
-  ,.on_message_complete = 0
-  ,.on_chunk_header = 0
-  ,.on_chunk_complete = 0
-  };
-
-void
-parser_init (enum http_parser_type type)
-{
-  num_messages = 0;
-  http_parser_init(&parser, type);
-  memset(&messages, 0, sizeof messages);
-}
-
-size_t parse (const char *buf, size_t len)
-{
-  size_t nparsed;
-  currently_parsing_eof = (len == 0);
-  nparsed = http_parser_execute(&parser, &settings, buf, len);
-  return nparsed;
-}
-
-size_t parse_count_body (const char *buf, size_t len)
-{
-  size_t nparsed;
-  currently_parsing_eof = (len == 0);
-  nparsed = http_parser_execute(&parser, &settings_count_body, buf, len);
-  return nparsed;
-}
-
-size_t parse_pause (const char *buf, size_t len)
-{
-  size_t nparsed;
-  http_parser_settings s = settings_pause;
-
-  currently_parsing_eof = (len == 0);
-  current_pause_parser = &s;
-  nparsed = http_parser_execute(&parser, current_pause_parser, buf, len);
-  return nparsed;
-}
-
-size_t parse_connect (const char *buf, size_t len)
-{
-  size_t nparsed;
-  currently_parsing_eof = (len == 0);
-  nparsed = http_parser_execute(&parser, &settings_connect, buf, len);
-  return nparsed;
-}
-
-static inline int
-check_str_eq (const struct message *m,
-              const char *prop,
-              const char *expected,
-              const char *found) {
-  if ((expected == NULL) != (found == NULL)) {
-    printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
-    printf("expected %s\n", (expected == NULL) ? "NULL" : expected);
-    printf("   found %s\n", (found == NULL) ? "NULL" : found);
-    return 0;
-  }
-  if (expected != NULL && 0 != strcmp(expected, found)) {
-    printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
-    printf("expected '%s'\n", expected);
-    printf("   found '%s'\n", found);
-    return 0;
-  }
-  return 1;
-}
-
-static inline int
-check_num_eq (const struct message *m,
-              const char *prop,
-              int expected,
-              int found) {
-  if (expected != found) {
-    printf("\n*** Error: %s in '%s' ***\n\n", prop, m->name);
-    printf("expected %d\n", expected);
-    printf("   found %d\n", found);
-    return 0;
-  }
-  return 1;
-}
-
-#define MESSAGE_CHECK_STR_EQ(expected, found, prop) \
-  if (!check_str_eq(expected, #prop, expected->prop, found->prop)) return 0
-
-#define MESSAGE_CHECK_NUM_EQ(expected, found, prop) \
-  if (!check_num_eq(expected, #prop, expected->prop, found->prop)) return 0
-
-#define MESSAGE_CHECK_URL_EQ(u, expected, found, prop, fn)           \
-do {                                                                 \
-  char ubuf[256];                                                    \
-                                                                     \
-  if ((u)->field_set & (1 << (fn))) {                                \
-    memcpy(ubuf, (found)->request_url + (u)->field_data[(fn)].off,   \
-      (u)->field_data[(fn)].len);                                    \
-    ubuf[(u)->field_data[(fn)].len] = '\0';                          \
-  } else {                                                           \
-    ubuf[0] = '\0';                                                  \
-  }                                                                  \
-                                                                     \
-  check_str_eq(expected, #prop, expected->prop, ubuf);               \
-} while(0)
-
-int
-message_eq (int index, int connect, const struct message *expected)
-{
-  int i;
-  struct message *m = &messages[index];
-
-  MESSAGE_CHECK_NUM_EQ(expected, m, http_major);
-  MESSAGE_CHECK_NUM_EQ(expected, m, http_minor);
-  MESSAGE_CHECK_NUM_EQ(expected, m, content_length);
-
-  if (expected->type == HTTP_REQUEST) {
-    MESSAGE_CHECK_NUM_EQ(expected, m, method);
-  } else {
-    MESSAGE_CHECK_NUM_EQ(expected, m, status_code);
-    MESSAGE_CHECK_STR_EQ(expected, m, response_status);
-    assert(m->status_cb_called);
-  }
-
-  if (!connect) {
-    MESSAGE_CHECK_NUM_EQ(expected, m, should_keep_alive);
-    MESSAGE_CHECK_NUM_EQ(expected, m, message_complete_on_eof);
-  }
-
-  assert(m->message_begin_cb_called);
-  assert(m->headers_complete_cb_called);
-  assert(m->message_complete_cb_called);
-
-
-  MESSAGE_CHECK_STR_EQ(expected, m, request_url);
-
-  /* Check URL components; we can't do this w/ CONNECT since it doesn't
-   * send us a well-formed URL.
-   */
-  if (*m->request_url && m->method != HTTP_CONNECT) {
-    struct http_parser_url u;
-
-    if (http_parser_parse_url(m->request_url, strlen(m->request_url), 0, &u)) {
-      fprintf(stderr, "\n\n*** failed to parse URL %s ***\n\n",
-        m->request_url);
-      abort();
-    }
-
-    if (expected->host) {
-      MESSAGE_CHECK_URL_EQ(&u, expected, m, host, UF_HOST);
-    }
-
-    if (expected->userinfo) {
-      MESSAGE_CHECK_URL_EQ(&u, expected, m, userinfo, UF_USERINFO);
-    }
-
-    m->port = (u.field_set & (1 << UF_PORT)) ?
-      u.port : 0;
-
-    MESSAGE_CHECK_URL_EQ(&u, expected, m, query_string, UF_QUERY);
-    MESSAGE_CHECK_URL_EQ(&u, expected, m, fragment, UF_FRAGMENT);
-    MESSAGE_CHECK_URL_EQ(&u, expected, m, request_path, UF_PATH);
-    MESSAGE_CHECK_NUM_EQ(expected, m, port);
-  }
-
-  if (connect) {
-    check_num_eq(m, "body_size", 0, m->body_size);
-  } else if (expected->body_size) {
-    MESSAGE_CHECK_NUM_EQ(expected, m, body_size);
-  } else {
-    MESSAGE_CHECK_STR_EQ(expected, m, body);
-  }
-
-  if (connect) {
-    check_num_eq(m, "num_chunks_complete", 0, m->num_chunks_complete);
-  } else {
-    assert(m->num_chunks == m->num_chunks_complete);
-    MESSAGE_CHECK_NUM_EQ(expected, m, num_chunks_complete);
-    for (i = 0; i < m->num_chunks && i < MAX_CHUNKS; i++) {
-      MESSAGE_CHECK_NUM_EQ(expected, m, chunk_lengths[i]);
-    }
-  }
-
-  MESSAGE_CHECK_NUM_EQ(expected, m, num_headers);
-
-  int r;
-  for (i = 0; i < m->num_headers; i++) {
-    r = check_str_eq(expected, "header field", expected->headers[i][0], m->headers[i][0]);
-    if (!r) return 0;
-    r = check_str_eq(expected, "header value", expected->headers[i][1], m->headers[i][1]);
-    if (!r) return 0;
-  }
-
-  if (!connect) {
-    MESSAGE_CHECK_STR_EQ(expected, m, upgrade);
-  }
-
-  return 1;
-}
-
-/* Given a sequence of varargs messages, return the number of them that the
- * parser should successfully parse, taking into account that upgraded
- * messages prevent all subsequent messages from being parsed.
- */
-size_t
-count_parsed_messages(const size_t nmsgs, ...) {
-  size_t i;
-  va_list ap;
-
-  va_start(ap, nmsgs);
-
-  for (i = 0; i < nmsgs; i++) {
-    struct message *m = va_arg(ap, struct message *);
-
-    if (m->upgrade) {
-      va_end(ap);
-      return i + 1;
-    }
-  }
-
-  va_end(ap);
-  return nmsgs;
-}
-
-/* Given a sequence of bytes and the number of these that we were able to
- * parse, verify that upgrade bodies are correct.
- */
-void
-upgrade_message_fix(char *body, const size_t nread, const size_t nmsgs, ...) {
-  va_list ap;
-  size_t i;
-  size_t off = 0;
-
-  va_start(ap, nmsgs);
-
-  for (i = 0; i < nmsgs; i++) {
-    struct message *m = va_arg(ap, struct message *);
-
-    off += strlen(m->raw);
-
-    if (m->upgrade) {
-      off -= strlen(m->upgrade);
-
-      /* Check the portion of the response after its specified upgrade */
-      if (!check_str_eq(m, "upgrade", body + off, body + nread)) {
-        abort();
-      }
-
-      /* Fix up the response so that message_eq() will verify the beginning
-       * of the upgrade */
-      *(body + nread + strlen(m->upgrade)) = '\0';
-      messages[num_messages -1 ].upgrade = body + nread;
-
-      va_end(ap);
-      return;
-    }
-  }
-
-  va_end(ap);
-  printf("\n\n*** Error: expected a message with upgrade ***\n");
-
-  abort();
-}
-
-static void
-print_error (const char *raw, size_t error_location)
-{
-  fprintf(stderr, "\n*** %s ***\n\n",
-          http_errno_description(HTTP_PARSER_ERRNO(&parser)));
-
-  int this_line = 0, char_len = 0;
-  size_t i, j, len = strlen(raw), error_location_line = 0;
-  for (i = 0; i < len; i++) {
-    if (i == error_location) this_line = 1;
-    switch (raw[i]) {
-      case '\r':
-        char_len = 2;
-        fprintf(stderr, "\\r");
-        break;
-
-      case '\n':
-        fprintf(stderr, "\\n\n");
-
-        if (this_line) goto print;
-
-        error_location_line = 0;
-        continue;
-
-      default:
-        char_len = 1;
-        fputc(raw[i], stderr);
-        break;
-    }
-    if (!this_line) error_location_line += char_len;
-  }
-
-  fprintf(stderr, "[eof]\n");
-
- print:
-  for (j = 0; j < error_location_line; j++) {
-    fputc(' ', stderr);
-  }
-  fprintf(stderr, "^\n\nerror location: %u\n", (unsigned int)error_location);
-}
-
-void
-test_preserve_data (void)
-{
-  char my_data[] = "application-specific data";
-  http_parser parser;
-  parser.data = my_data;
-  http_parser_init(&parser, HTTP_REQUEST);
-  if (parser.data != my_data) {
-    printf("\n*** parser.data not preserved accross http_parser_init ***\n\n");
-    abort();
-  }
-}
-
-struct url_test {
-  const char *name;
-  const char *url;
-  int is_connect;
-  struct http_parser_url u;
-  int rv;
-};
-
-const struct url_test url_tests[] =
-{ {.name="proxy request"
-  ,.url="http://hostname/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set=(1 << UF_SCHEMA) | (1 << UF_HOST) | (1 << UF_PATH)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  7,  8 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 15,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="proxy request with port"
-  ,.url="http://hostname:444/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set=(1 << UF_SCHEMA) | (1 << UF_HOST) | (1 << UF_PORT) | (1 << UF_PATH)
-    ,.port=444
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  7,  8 } /* UF_HOST */
-      ,{ 16,  3 } /* UF_PORT */
-      ,{ 19,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="CONNECT request"
-  ,.url="hostname:443"
-  ,.is_connect=1
-  ,.u=
-    {.field_set=(1 << UF_HOST) | (1 << UF_PORT)
-    ,.port=443
-    ,.field_data=
-      {{  0,  0 } /* UF_SCHEMA */
-      ,{  0,  8 } /* UF_HOST */
-      ,{  9,  3 } /* UF_PORT */
-      ,{  0,  0 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="CONNECT request but not connect"
-  ,.url="hostname:443"
-  ,.is_connect=0
-  ,.rv=1
-  }
-
-, {.name="proxy ipv6 request"
-  ,.url="http://[1:2::3:4]/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set=(1 << UF_SCHEMA) | (1 << UF_HOST) | (1 << UF_PATH)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  8,  8 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 17,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="proxy ipv6 request with port"
-  ,.url="http://[1:2::3:4]:67/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set=(1 << UF_SCHEMA) | (1 << UF_HOST) | (1 << UF_PORT) | (1 << UF_PATH)
-    ,.port=67
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  8,  8 } /* UF_HOST */
-      ,{ 18,  2 } /* UF_PORT */
-      ,{ 20,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="CONNECT ipv6 address"
-  ,.url="[1:2::3:4]:443"
-  ,.is_connect=1
-  ,.u=
-    {.field_set=(1 << UF_HOST) | (1 << UF_PORT)
-    ,.port=443
-    ,.field_data=
-      {{  0,  0 } /* UF_SCHEMA */
-      ,{  1,  8 } /* UF_HOST */
-      ,{ 11,  3 } /* UF_PORT */
-      ,{  0,  0 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="ipv4 in ipv6 address"
-  ,.url="http://[2001:0000:0000:0000:0000:0000:1.9.1.1]/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set=(1 << UF_SCHEMA) | (1 << UF_HOST) | (1 << UF_PATH)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  8, 37 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 46,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="extra ? in query string"
-  ,.url="http://a.tbcdn.cn/p/fp/2010c/??fp-header-min.css,fp-base-min.css,"
-  "fp-channel-min.css,fp-product-min.css,fp-mall-min.css,fp-category-min.css,"
-  "fp-sub-min.css,fp-gdp4p-min.css,fp-css3-min.css,fp-misc-min.css?t=20101022.css"
-  ,.is_connect=0
-  ,.u=
-    {.field_set=(1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PATH) | (1<<UF_QUERY)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  7, 10 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 17, 12 } /* UF_PATH */
-      ,{ 30,187 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="space URL encoded"
-  ,.url="/toto.html?toto=a%20b"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_PATH) | (1<<UF_QUERY)
-    ,.port=0
-    ,.field_data=
-      {{  0,  0 } /* UF_SCHEMA */
-      ,{  0,  0 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{  0, 10 } /* UF_PATH */
-      ,{ 11, 10 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-
-, {.name="URL fragment"
-  ,.url="/toto.html#titi"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_PATH) | (1<<UF_FRAGMENT)
-    ,.port=0
-    ,.field_data=
-      {{  0,  0 } /* UF_SCHEMA */
-      ,{  0,  0 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{  0, 10 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{ 11,  4 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="complex URL fragment"
-  ,.url="http://www.webmasterworld.com/r.cgi?f=21&d=8405&url="
-    "http://www.example.com/index.html?foo=bar&hello=world#midpage"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PATH) | (1<<UF_QUERY) |\
-      (1<<UF_FRAGMENT)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  7, 22 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 29,  6 } /* UF_PATH */
-      ,{ 36, 69 } /* UF_QUERY */
-      ,{106,  7 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="complex URL from node js url parser doc"
-  ,.url="http://host.com:8080/p/a/t/h?query=string#hash"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PORT) | (1<<UF_PATH) |\
-      (1<<UF_QUERY) | (1<<UF_FRAGMENT)
-    ,.port=8080
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  7,  8 } /* UF_HOST */
-      ,{ 16,  4 } /* UF_PORT */
-      ,{ 20,  8 } /* UF_PATH */
-      ,{ 29, 12 } /* UF_QUERY */
-      ,{ 42,  4 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="complex URL with basic auth from node js url parser doc"
-  ,.url="http://a:b@host.com:8080/p/a/t/h?query=string#hash"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PORT) | (1<<UF_PATH) |\
-      (1<<UF_QUERY) | (1<<UF_FRAGMENT) | (1<<UF_USERINFO)
-    ,.port=8080
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{ 11,  8 } /* UF_HOST */
-      ,{ 20,  4 } /* UF_PORT */
-      ,{ 24,  8 } /* UF_PATH */
-      ,{ 33, 12 } /* UF_QUERY */
-      ,{ 46,  4 } /* UF_FRAGMENT */
-      ,{  7,  3 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="double @"
-  ,.url="http://a:b@@hostname:443/"
-  ,.is_connect=0
-  ,.rv=1
-  }
-
-, {.name="proxy empty host"
-  ,.url="http://:443/"
-  ,.is_connect=0
-  ,.rv=1
-  }
-
-, {.name="proxy empty port"
-  ,.url="http://hostname:/"
-  ,.is_connect=0
-  ,.rv=1
-  }
-
-, {.name="CONNECT with basic auth"
-  ,.url="a:b@hostname:443"
-  ,.is_connect=1
-  ,.rv=1
-  }
-
-, {.name="CONNECT empty host"
-  ,.url=":443"
-  ,.is_connect=1
-  ,.rv=1
-  }
-
-, {.name="CONNECT empty port"
-  ,.url="hostname:"
-  ,.is_connect=1
-  ,.rv=1
-  }
-
-, {.name="CONNECT with extra bits"
-  ,.url="hostname:443/"
-  ,.is_connect=1
-  ,.rv=1
-  }
-
-, {.name="space in URL"
-  ,.url="/foo bar/"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy basic auth with space url encoded"
-  ,.url="http://a%20:b@host.com/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PATH) | (1<<UF_USERINFO)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{ 14,  8 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 22,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  7,  6 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="carriage return in URL"
-  ,.url="/foo\rbar/"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy double : in URL"
-  ,.url="http://hostname::443/"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy basic auth with double :"
-  ,.url="http://a::b@host.com/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PATH) | (1<<UF_USERINFO)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{ 12,  8 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 20,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  7,  4 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="line feed in URL"
-  ,.url="/foo\nbar/"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy empty basic auth"
-  ,.url="http://@hostname/fo"
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PATH)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  8,  8 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 16,  3 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-, {.name="proxy line feed in hostname"
-  ,.url="http://host\name/fo"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy % in hostname"
-  ,.url="http://host%name/fo"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy ; in hostname"
-  ,.url="http://host;ame/fo"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy basic auth with unreservedchars"
-  ,.url="http://a!;-_!=+$@host.com/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PATH) | (1<<UF_USERINFO)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{ 17,  8 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 25,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  7,  9 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="proxy only empty basic auth"
-  ,.url="http://@/fo"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy only basic auth"
-  ,.url="http://toto@/fo"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy emtpy hostname"
-  ,.url="http:///fo"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="proxy = in URL"
-  ,.url="http://host=ame/fo"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="ipv6 address with Zone ID"
-  ,.url="http://[fe80::a%25eth0]/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PATH)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  8, 14 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 23,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="ipv6 address with Zone ID, but '%' is not percent-encoded"
-  ,.url="http://[fe80::a%eth0]/"
-  ,.is_connect=0
-  ,.u=
-    {.field_set= (1<<UF_SCHEMA) | (1<<UF_HOST) | (1<<UF_PATH)
-    ,.port=0
-    ,.field_data=
-      {{  0,  4 } /* UF_SCHEMA */
-      ,{  8, 12 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{ 21,  1 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="ipv6 address ending with '%'"
-  ,.url="http://[fe80::a%]/"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="ipv6 address with Zone ID including bad character"
-  ,.url="http://[fe80::a%$HOME]/"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="just ipv6 Zone ID"
-  ,.url="http://[%eth0]/"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="empty url"
-  ,.url=""
-  ,.is_connect=0
-  ,.rv=1
-  }
-
-, {.name="NULL url"
-  ,.url=NULL
-  ,.is_connect=0
-  ,.rv=1
-  }
-
-, {.name="full of spaces url"
-  ,.url="  "
-  ,.is_connect=0
-  ,.rv=1
-  }
-
-#if HTTP_PARSER_STRICT
-
-, {.name="tab in URL"
-  ,.url="/foo\tbar/"
-  ,.rv=1 /* s_dead */
-  }
-
-, {.name="form feed in URL"
-  ,.url="/foo\fbar/"
-  ,.rv=1 /* s_dead */
-  }
-
-#else /* !HTTP_PARSER_STRICT */
-
-, {.name="tab in URL"
-  ,.url="/foo\tbar/"
-  ,.u=
-    {.field_set=(1 << UF_PATH)
-    ,.field_data=
-      {{  0,  0 } /* UF_SCHEMA */
-      ,{  0,  0 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{  0,  9 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-
-, {.name="form feed in URL"
-  ,.url="/foo\fbar/"
-  ,.u=
-    {.field_set=(1 << UF_PATH)
-    ,.field_data=
-      {{  0,  0 } /* UF_SCHEMA */
-      ,{  0,  0 } /* UF_HOST */
-      ,{  0,  0 } /* UF_PORT */
-      ,{  0,  9 } /* UF_PATH */
-      ,{  0,  0 } /* UF_QUERY */
-      ,{  0,  0 } /* UF_FRAGMENT */
-      ,{  0,  0 } /* UF_USERINFO */
-      }
-    }
-  ,.rv=0
-  }
-#endif
-};
-
-void
-dump_url (const char *url, const struct http_parser_url *u)
-{
-  unsigned int i;
-
-  printf("\tfield_set: 0x%x, port: %u\n", u->field_set, u->port);
-  for (i = 0; i < UF_MAX; i++) {
-    if ((u->field_set & (1 << i)) == 0) {
-      printf("\tfield_data[%u]: unset\n", i);
-      continue;
-    }
-
-    printf("\tfield_data[%u]: off: %u len: %u part: \"%.*s\n\"",
-           i,
-           u->field_data[i].off,
-           u->field_data[i].len,
-           u->field_data[i].len,
-           url + u->field_data[i].off);
-  }
-}
-
-void
-test_parse_url (void)
-{
-  struct http_parser_url u;
-  const struct url_test *test;
-  unsigned int i;
-  int rv;
-
-  for (i = 0; i < (sizeof(url_tests) / sizeof(url_tests[0])); i++) {
-    test = &url_tests[i];
-    memset(&u, 0, sizeof(u));
-
-    rv = http_parser_parse_url(test->url,
-                               test->url ? strlen(test->url) : 0,
-                               test->is_connect,
-                               &u);
-
-    if (test->rv == 0) {
-      if (rv != 0) {
-        printf("\n*** http_parser_parse_url(\"%s\") \"%s\" test failed, "
-               "unexpected rv %d ***\n\n", test->url, test->name, rv);
-        abort();
-      }
-
-      if (memcmp(&u, &test->u, sizeof(u)) != 0) {
-        printf("\n*** http_parser_parse_url(\"%s\") \"%s\" failed ***\n",
-               test->url, test->name);
-
-        printf("target http_parser_url:\n");
-        dump_url(test->url, &test->u);
-        printf("result http_parser_url:\n");
-        dump_url(test->url, &u);
-
-        abort();
-      }
-    } else {
-      /* test->rv != 0 */
-      if (rv == 0) {
-        printf("\n*** http_parser_parse_url(\"%s\") \"%s\" test failed, "
-               "unexpected rv %d ***\n\n", test->url, test->name, rv);
-        abort();
-      }
-    }
-  }
-}
-
-void
-test_method_str (void)
-{
-  assert(0 == strcmp("GET", http_method_str(HTTP_GET)));
-  assert(0 == strcmp("<unknown>", http_method_str(1337)));
-}
-
-void
-test_status_str (void)
-{
-  assert(0 == strcmp("OK", http_status_str(HTTP_STATUS_OK)));
-  assert(0 == strcmp("Not Found", http_status_str(HTTP_STATUS_NOT_FOUND)));
-  assert(0 == strcmp("<unknown>", http_status_str(1337)));
-}
-
-void
-test_message (const struct message *message)
-{
-  size_t raw_len = strlen(message->raw);
-  size_t msg1len;
-  for (msg1len = 0; msg1len < raw_len; msg1len++) {
-    parser_init(message->type);
-    if (message->allow_chunked_length) {
-      parser.allow_chunked_length = 1;
-    }
-
-    size_t read;
-    const char *msg1 = message->raw;
-    const char *msg2 = msg1 + msg1len;
-    size_t msg2len = raw_len - msg1len;
-
-    if (msg1len) {
-      assert(num_messages == 0);
-      messages[0].headers_complete_cb_called = FALSE;
-
-      read = parse(msg1, msg1len);
-
-      if (!messages[0].headers_complete_cb_called && parser.nread != read) {
-        assert(parser.nread == read);
-        print_error(msg1, read);
-        abort();
-      }
-
-      if (message->upgrade && parser.upgrade && num_messages > 0) {
-        messages[num_messages - 1].upgrade = msg1 + read;
-        goto test;
-      }
-
-      if (read != msg1len) {
-        print_error(msg1, read);
-        abort();
-      }
-    }
-
-
-    read = parse(msg2, msg2len);
-
-    if (message->upgrade && parser.upgrade) {
-      messages[num_messages - 1].upgrade = msg2 + read;
-      goto test;
-    }
-
-    if (read != msg2len) {
-      print_error(msg2, read);
-      abort();
-    }
-
-    read = parse(NULL, 0);
-
-    if (read != 0) {
-      print_error(message->raw, read);
-      abort();
-    }
-
-  test:
-
-    if (num_messages != 1) {
-      printf("\n*** num_messages != 1 after testing '%s' ***\n\n", message->name);
-      abort();
-    }
-
-    if(!message_eq(0, 0, message)) abort();
-  }
-}
-
-void
-test_message_count_body (const struct message *message)
-{
-  parser_init(message->type);
-
-  size_t read;
-  size_t l = strlen(message->raw);
-  size_t i, toread;
-  size_t chunk = 4024;
-
-  for (i = 0; i < l; i+= chunk) {
-    toread = MIN(l-i, chunk);
-    read = parse_count_body(message->raw + i, toread);
-    if (read != toread) {
-      print_error(message->raw, read);
-      abort();
-    }
-  }
-
-
-  read = parse_count_body(NULL, 0);
-  if (read != 0) {
-    print_error(message->raw, read);
-    abort();
-  }
-
-  if (num_messages != 1) {
-    printf("\n*** num_messages != 1 after testing '%s' ***\n\n", message->name);
-    abort();
-  }
-
-  if(!message_eq(0, 0, message)) abort();
-}
-
-void
-test_simple_type (const char *buf,
-                  enum http_errno err_expected,
-                  enum http_parser_type type)
-{
-  parser_init(type);
-
-  enum http_errno err;
-
-  parse(buf, strlen(buf));
-  err = HTTP_PARSER_ERRNO(&parser);
-  parse(NULL, 0);
-
-  /* In strict mode, allow us to pass with an unexpected HPE_STRICT as
-   * long as the caller isn't expecting success.
-   */
-#if HTTP_PARSER_STRICT
-  if (err_expected != err && err_expected != HPE_OK && err != HPE_STRICT) {
-#else
-  if (err_expected != err) {
-#endif
-    fprintf(stderr, "\n*** test_simple expected %s, but saw %s ***\n\n%s\n",
-        http_errno_name(err_expected), http_errno_name(err), buf);
-    abort();
-  }
-}
-
-void
-test_simple (const char *buf, enum http_errno err_expected)
-{
-  test_simple_type(buf, err_expected, HTTP_REQUEST);
-}
-
-void
-test_invalid_header_content (int req, const char* str)
-{
-  http_parser parser;
-  http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
-  size_t parsed;
-  const char *buf;
-  buf = req ?
-    "GET / HTTP/1.1\r\n" :
-    "HTTP/1.1 200 OK\r\n";
-  parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
-  assert(parsed == strlen(buf));
-
-  buf = str;
-  size_t buflen = strlen(buf);
-
-  parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
-  if (parsed != buflen) {
-    assert(HTTP_PARSER_ERRNO(&parser) == HPE_INVALID_HEADER_TOKEN);
-    return;
-  }
-
-  fprintf(stderr,
-          "\n*** Error expected but none in invalid header content test ***\n");
-  abort();
-}
-
-void
-test_invalid_header_field_content_error (int req)
-{
-  test_invalid_header_content(req, "Foo: F\01ailure");
-  test_invalid_header_content(req, "Foo: B\02ar");
-}
-
-void
-test_invalid_header_field (int req, const char* str)
-{
-  http_parser parser;
-  http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
-  size_t parsed;
-  const char *buf;
-  buf = req ?
-    "GET / HTTP/1.1\r\n" :
-    "HTTP/1.1 200 OK\r\n";
-  parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
-  assert(parsed == strlen(buf));
-
-  buf = str;
-  size_t buflen = strlen(buf);
-
-  parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
-  if (parsed != buflen) {
-    assert(HTTP_PARSER_ERRNO(&parser) == HPE_INVALID_HEADER_TOKEN);
-    return;
-  }
-
-  fprintf(stderr,
-          "\n*** Error expected but none in invalid header token test ***\n");
-  abort();
-}
-
-void
-test_invalid_header_field_token_error (int req)
-{
-  test_invalid_header_field(req, "Fo@: Failure");
-  test_invalid_header_field(req, "Foo\01\test: Bar");
-}
-
-void
-test_double_content_length_error (int req)
-{
-  http_parser parser;
-  http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
-  size_t parsed;
-  const char *buf;
-  buf = req ?
-    "GET / HTTP/1.1\r\n" :
-    "HTTP/1.1 200 OK\r\n";
-  parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
-  assert(parsed == strlen(buf));
-
-  buf = "Content-Length: 0\r\nContent-Length: 1\r\n\r\n";
-  size_t buflen = strlen(buf);
-
-  parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
-  if (parsed != buflen) {
-    assert(HTTP_PARSER_ERRNO(&parser) == HPE_UNEXPECTED_CONTENT_LENGTH);
-    return;
-  }
-
-  fprintf(stderr,
-          "\n*** Error expected but none in double content-length test ***\n");
-  abort();
-}
-
-void
-test_chunked_content_length_error (int req)
-{
-  http_parser parser;
-  http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
-  size_t parsed;
-  const char *buf;
-  buf = req ?
-    "GET / HTTP/1.1\r\n" :
-    "HTTP/1.1 200 OK\r\n";
-  parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
-  assert(parsed == strlen(buf));
-
-  buf = "Transfer-Encoding: anything\r\nContent-Length: 1\r\n\r\n";
-  size_t buflen = strlen(buf);
-
-  parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
-  if (parsed != buflen) {
-    assert(HTTP_PARSER_ERRNO(&parser) == HPE_UNEXPECTED_CONTENT_LENGTH);
-    return;
-  }
-
-  fprintf(stderr,
-          "\n*** Error expected but none in chunked content-length test ***\n");
-  abort();
-}
-
-void
-test_header_cr_no_lf_error (int req)
-{
-  http_parser parser;
-  http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
-  size_t parsed;
-  const char *buf;
-  buf = req ?
-    "GET / HTTP/1.1\r\n" :
-    "HTTP/1.1 200 OK\r\n";
-  parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
-  assert(parsed == strlen(buf));
-
-  buf = "Foo: 1\rBar: 1\r\n\r\n";
-  size_t buflen = strlen(buf);
-
-  parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
-  if (parsed != buflen) {
-    assert(HTTP_PARSER_ERRNO(&parser) == HPE_LF_EXPECTED);
-    return;
-  }
-
-  fprintf(stderr,
-          "\n*** Error expected but none in header whitespace test ***\n");
-  abort();
-}
-
-void
-test_no_overflow_parse_url (void)
-{
-  int rv;
-  struct http_parser_url u;
-
-  http_parser_url_init(&u);
-  rv = http_parser_parse_url("http://example.com:8001", 22, 0, &u);
-
-  if (rv != 0) {
-    fprintf(stderr,
-            "\n*** test_no_overflow_parse_url invalid return value=%d\n",
-            rv);
-    abort();
-  }
-
-  if (u.port != 800) {
-    fprintf(stderr,
-            "\n*** test_no_overflow_parse_url invalid port number=%d\n",
-            u.port);
-    abort();
-  }
-}
-
-void
-test_header_overflow_error (int req)
-{
-  http_parser parser;
-  http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
-  size_t parsed;
-  const char *buf;
-  buf = req ? "GET / HTTP/1.1\r\n" : "HTTP/1.0 200 OK\r\n";
-  parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
-  assert(parsed == strlen(buf));
-
-  buf = "header-key: header-value\r\n";
-  size_t buflen = strlen(buf);
-
-  int i;
-  for (i = 0; i < 10000; i++) {
-    parsed = http_parser_execute(&parser, &settings_null, buf, buflen);
-    if (parsed != buflen) {
-      //fprintf(stderr, "error found on iter %d\n", i);
-      assert(HTTP_PARSER_ERRNO(&parser) == HPE_HEADER_OVERFLOW);
-      return;
-    }
-  }
-
-  fprintf(stderr, "\n*** Error expected but none in header overflow test ***\n");
-  abort();
-}
-
-
-void
-test_header_nread_value ()
-{
-  http_parser parser;
-  http_parser_init(&parser, HTTP_REQUEST);
-  size_t parsed;
-  const char *buf;
-  buf = "GET / HTTP/1.1\r\nheader: value\nhdr: value\r\n";
-  parsed = http_parser_execute(&parser, &settings_null, buf, strlen(buf));
-  assert(parsed == strlen(buf));
-
-  assert(parser.nread == strlen(buf));
-}
-
-
-static void
-test_content_length_overflow (const char *buf, size_t buflen, int expect_ok)
-{
-  http_parser parser;
-  http_parser_init(&parser, HTTP_RESPONSE);
-  http_parser_execute(&parser, &settings_null, buf, buflen);
-
-  if (expect_ok)
-    assert(HTTP_PARSER_ERRNO(&parser) == HPE_OK);
-  else
-    assert(HTTP_PARSER_ERRNO(&parser) == HPE_INVALID_CONTENT_LENGTH);
-}
-
-void
-test_header_content_length_overflow_error (void)
-{
-#define X(size)                                                               \
-  "HTTP/1.1 200 OK\r\n"                                                       \
-  "Content-Length: " #size "\r\n"                                             \
-  "\r\n"
-  const char a[] = X(1844674407370955160);  /* 2^64 / 10 - 1 */
-  const char b[] = X(18446744073709551615); /* 2^64-1 */
-  const char c[] = X(18446744073709551616); /* 2^64   */
-#undef X
-  test_content_length_overflow(a, sizeof(a) - 1, 1); /* expect ok      */
-  test_content_length_overflow(b, sizeof(b) - 1, 0); /* expect failure */
-  test_content_length_overflow(c, sizeof(c) - 1, 0); /* expect failure */
-}
-
-void
-test_chunk_content_length_overflow_error (void)
-{
-#define X(size)                                                               \
-    "HTTP/1.1 200 OK\r\n"                                                     \
-    "Transfer-Encoding: chunked\r\n"                                          \
-    "\r\n"                                                                    \
-    #size "\r\n"                                                              \
-    "..."
-  const char a[] = X(FFFFFFFFFFFFFFE);   /* 2^64 / 16 - 1 */
-  const char b[] = X(FFFFFFFFFFFFFFFF);  /* 2^64-1 */
-  const char c[] = X(10000000000000000); /* 2^64   */
-#undef X
-  test_content_length_overflow(a, sizeof(a) - 1, 1); /* expect ok      */
-  test_content_length_overflow(b, sizeof(b) - 1, 0); /* expect failure */
-  test_content_length_overflow(c, sizeof(c) - 1, 0); /* expect failure */
-}
-
-void
-test_no_overflow_long_body (int req, size_t length)
-{
-  http_parser parser;
-  http_parser_init(&parser, req ? HTTP_REQUEST : HTTP_RESPONSE);
-  size_t parsed;
-  size_t i;
-  char buf1[3000];
-  size_t buf1len = sprintf(buf1, "%s\r\nConnection: Keep-Alive\r\nContent-Length: %lu\r\n\r\n",
-      req ? "POST / HTTP/1.0" : "HTTP/1.0 200 OK", (unsigned long)length);
-  parsed = http_parser_execute(&parser, &settings_null, buf1, buf1len);
-  if (parsed != buf1len)
-    goto err;
-
-  for (i = 0; i < length; i++) {
-    char foo = 'a';
-    parsed = http_parser_execute(&parser, &settings_null, &foo, 1);
-    if (parsed != 1)
-      goto err;
-  }
-
-  parsed = http_parser_execute(&parser, &settings_null, buf1, buf1len);
-  if (parsed != buf1len) goto err;
-  return;
-
- err:
-  fprintf(stderr,
-          "\n*** error in test_no_overflow_long_body %s of length %lu ***\n",
-          req ? "REQUEST" : "RESPONSE",
-          (unsigned long)length);
-  abort();
-}
-
-void
-test_multiple3 (const struct message *r1, const struct message *r2, const struct message *r3)
-{
-  int message_count = count_parsed_messages(3, r1, r2, r3);
-
-  char total[ strlen(r1->raw)
-            + strlen(r2->raw)
-            + strlen(r3->raw)
-            + 1
-            ];
-  total[0] = '\0';
-
-  strcat(total, r1->raw);
-  strcat(total, r2->raw);
-  strcat(total, r3->raw);
-
-  parser_init(r1->type);
-  if (r1->allow_chunked_length ||
-      r2->allow_chunked_length ||
-      r3->allow_chunked_length) {
-    parser.allow_chunked_length = 1;
-  }
-
-  size_t read;
-
-  read = parse(total, strlen(total));
-
-  if (parser.upgrade) {
-    upgrade_message_fix(total, read, 3, r1, r2, r3);
-    goto test;
-  }
-
-  if (read != strlen(total)) {
-    print_error(total, read);
-    abort();
-  }
-
-  read = parse(NULL, 0);
-
-  if (read != 0) {
-    print_error(total, read);
-    abort();
-  }
-
-test:
-
-  if (message_count != num_messages) {
-    fprintf(stderr, "\n\n*** Parser didn't see 3 messages only %d *** \n", num_messages);
-    abort();
-  }
-
-  if (!message_eq(0, 0, r1)) abort();
-  if (message_count > 1 && !message_eq(1, 0, r2)) abort();
-  if (message_count > 2 && !message_eq(2, 0, r3)) abort();
-}
-
-/* SCAN through every possible breaking to make sure the
- * parser can handle getting the content in any chunks that
- * might come from the socket
- */
-void
-test_scan (const struct message *r1, const struct message *r2, const struct message *r3)
-{
-  char total[80*1024] = "\0";
-  char buf1[80*1024] = "\0";
-  char buf2[80*1024] = "\0";
-  char buf3[80*1024] = "\0";
-
-  strcat(total, r1->raw);
-  strcat(total, r2->raw);
-  strcat(total, r3->raw);
-
-  size_t read;
-
-  int total_len = strlen(total);
-
-  int total_ops = 2 * (total_len - 1) * (total_len - 2) / 2;
-  int ops = 0 ;
-
-  size_t buf1_len, buf2_len, buf3_len;
-  int message_count = count_parsed_messages(3, r1, r2, r3);
-
-  int i,j,type_both;
-  for (type_both = 0; type_both < 2; type_both ++ ) {
-    for (j = 2; j < total_len; j ++ ) {
-      for (i = 1; i < j; i ++ ) {
-
-        if (ops % 1000 == 0)  {
-          printf("\b\b\b\b%3.0f%%", 100 * (float)ops /(float)total_ops);
-          fflush(stdout);
-        }
-        ops += 1;
-
-        parser_init(type_both ? HTTP_BOTH : r1->type);
-
-        buf1_len = i;
-        strlncpy(buf1, sizeof(buf1), total, buf1_len);
-        buf1[buf1_len] = 0;
-
-        buf2_len = j - i;
-        strlncpy(buf2, sizeof(buf1), total+i, buf2_len);
-        buf2[buf2_len] = 0;
-
-        buf3_len = total_len - j;
-        strlncpy(buf3, sizeof(buf1), total+j, buf3_len);
-        buf3[buf3_len] = 0;
-
-        assert(num_messages == 0);
-        messages[0].headers_complete_cb_called = FALSE;
-
-        read = parse(buf1, buf1_len);
-
-        if (!messages[0].headers_complete_cb_called && parser.nread != read) {
-          print_error(buf1, read);
-          goto error;
-        }
-
-        if (parser.upgrade) goto test;
-
-        if (read != buf1_len) {
-          print_error(buf1, read);
-          goto error;
-        }
-
-        read += parse(buf2, buf2_len);
-
-        if (parser.upgrade) goto test;
-
-        if (read != buf1_len + buf2_len) {
-          print_error(buf2, read);
-          goto error;
-        }
-
-        read += parse(buf3, buf3_len);
-
-        if (parser.upgrade) goto test;
-
-        if (read != buf1_len + buf2_len + buf3_len) {
-          print_error(buf3, read);
-          goto error;
-        }
-
-        parse(NULL, 0);
-
-test:
-        if (parser.upgrade) {
-          upgrade_message_fix(total, read, 3, r1, r2, r3);
-        }
-
-        if (message_count != num_messages) {
-          fprintf(stderr, "\n\nParser didn't see %d messages only %d\n",
-            message_count, num_messages);
-          goto error;
-        }
-
-        if (!message_eq(0, 0, r1)) {
-          fprintf(stderr, "\n\nError matching messages[0] in test_scan.\n");
-          goto error;
-        }
-
-        if (message_count > 1 && !message_eq(1, 0, r2)) {
-          fprintf(stderr, "\n\nError matching messages[1] in test_scan.\n");
-          goto error;
-        }
-
-        if (message_count > 2 && !message_eq(2, 0, r3)) {
-          fprintf(stderr, "\n\nError matching messages[2] in test_scan.\n");
-          goto error;
-        }
-      }
-    }
-  }
-  puts("\b\b\b\b100%");
-  return;
-
- error:
-  fprintf(stderr, "i=%d  j=%d\n", i, j);
-  fprintf(stderr, "buf1 (%u) %s\n\n", (unsigned int)buf1_len, buf1);
-  fprintf(stderr, "buf2 (%u) %s\n\n", (unsigned int)buf2_len , buf2);
-  fprintf(stderr, "buf3 (%u) %s\n", (unsigned int)buf3_len, buf3);
-  abort();
-}
-
-// user required to free the result
-// string terminated by \0
-char *
-create_large_chunked_message (int body_size_in_kb, const char* headers)
-{
-  int i;
-  size_t wrote = 0;
-  size_t headers_len = strlen(headers);
-  size_t bufsize = headers_len + (5+1024+2)*body_size_in_kb + 6;
-  char * buf = malloc(bufsize);
-
-  memcpy(buf, headers, headers_len);
-  wrote += headers_len;
-
-  for (i = 0; i < body_size_in_kb; i++) {
-    // write 1kb chunk into the body.
-    memcpy(buf + wrote, "400\r\n", 5);
-    wrote += 5;
-    memset(buf + wrote, 'C', 1024);
-    wrote += 1024;
-    strcpy(buf + wrote, "\r\n");
-    wrote += 2;
-  }
-
-  memcpy(buf + wrote, "0\r\n\r\n", 6);
-  wrote += 6;
-  assert(wrote == bufsize);
-
-  return buf;
-}
-
-/* Verify that we can pause parsing at any of the bytes in the
- * message and still get the result that we're expecting. */
-void
-test_message_pause (const struct message *msg)
-{
-  char *buf = (char*) msg->raw;
-  size_t buflen = strlen(msg->raw);
-  size_t nread;
-
-  parser_init(msg->type);
-  if (msg->allow_chunked_length) {
-    parser.allow_chunked_length = 1;
-  }
-
-  do {
-    nread = parse_pause(buf, buflen);
-
-    // We can only set the upgrade buffer once we've gotten our message
-    // completion callback.
-    if (messages[0].message_complete_cb_called &&
-        msg->upgrade &&
-        parser.upgrade) {
-      messages[0].upgrade = buf + nread;
-      goto test;
-    }
-
-    if (nread < buflen) {
-
-      // Not much do to if we failed a strict-mode check
-      if (HTTP_PARSER_ERRNO(&parser) == HPE_STRICT) {
-        return;
-      }
-
-      assert (HTTP_PARSER_ERRNO(&parser) == HPE_PAUSED);
-    }
-
-    buf += nread;
-    buflen -= nread;
-    http_parser_pause(&parser, 0);
-  } while (buflen > 0);
-
-  nread = parse_pause(NULL, 0);
-  assert (nread == 0);
-
-test:
-  if (num_messages != 1) {
-    printf("\n*** num_messages != 1 after testing '%s' ***\n\n", msg->name);
-    abort();
-  }
-
-  if(!message_eq(0, 0, msg)) abort();
-}
-
-/* Verify that body and next message won't be parsed in responses to CONNECT */
-void
-test_message_connect (const struct message *msg)
-{
-  char *buf = (char*) msg->raw;
-  size_t buflen = strlen(msg->raw);
-
-  parser_init(msg->type);
-
-  parse_connect(buf, buflen);
-
-  if (num_messages != 1) {
-    printf("\n*** num_messages != 1 after testing '%s' ***\n\n", msg->name);
-    abort();
-  }
-
-  if(!message_eq(0, 1, msg)) abort();
-}
-
-int
-main (void)
-{
-  unsigned i, j, k;
-  unsigned long version;
-  unsigned major;
-  unsigned minor;
-  unsigned patch;
-
-  version = http_parser_version();
-  major = (version >> 16) & 255;
-  minor = (version >> 8) & 255;
-  patch = version & 255;
-  printf("http_parser v%u.%u.%u (0x%06lx)\n", major, minor, patch, version);
-
-  printf("sizeof(http_parser) = %u\n", (unsigned int)sizeof(http_parser));
-
-#if defined(__i386__) || defined(__x86_64__)
-  /* Should be 32 on both 32 bits and 64 bits x86 because of struct padding,
-   * see https://github.com/nodejs/http-parser/issues/507.
-   */
-  assert(sizeof(http_parser) == 32);
-#endif
-
-  //// API
-  test_preserve_data();
-  test_parse_url();
-  test_method_str();
-  test_status_str();
-
-  //// NREAD
-  test_header_nread_value();
-
-  //// OVERFLOW CONDITIONS
-  test_no_overflow_parse_url();
-
-  test_header_overflow_error(HTTP_REQUEST);
-  test_no_overflow_long_body(HTTP_REQUEST, 1000);
-  test_no_overflow_long_body(HTTP_REQUEST, 100000);
-
-  test_header_overflow_error(HTTP_RESPONSE);
-  test_no_overflow_long_body(HTTP_RESPONSE, 1000);
-  test_no_overflow_long_body(HTTP_RESPONSE, 100000);
-
-  test_header_content_length_overflow_error();
-  test_chunk_content_length_overflow_error();
-
-  //// HEADER FIELD CONDITIONS
-  test_double_content_length_error(HTTP_REQUEST);
-  test_chunked_content_length_error(HTTP_REQUEST);
-  test_header_cr_no_lf_error(HTTP_REQUEST);
-  test_invalid_header_field_token_error(HTTP_REQUEST);
-  test_invalid_header_field_content_error(HTTP_REQUEST);
-  test_double_content_length_error(HTTP_RESPONSE);
-  test_chunked_content_length_error(HTTP_RESPONSE);
-  test_header_cr_no_lf_error(HTTP_RESPONSE);
-  test_invalid_header_field_token_error(HTTP_RESPONSE);
-  test_invalid_header_field_content_error(HTTP_RESPONSE);
-
-  test_simple_type(
-      "POST / HTTP/1.1\r\n"
-      "Content-Length:\r\n"  // empty
-      "\r\n",
-      HPE_INVALID_CONTENT_LENGTH,
-      HTTP_REQUEST);
-
-  test_simple_type(
-      "POST / HTTP/1.1\r\n"
-      "Content-Length:  42 \r\n"  // Note the surrounding whitespace.
-      "\r\n",
-      HPE_OK,
-      HTTP_REQUEST);
-
-  test_simple_type(
-      "POST / HTTP/1.1\r\n"
-      "Content-Length: 4 2\r\n"
-      "\r\n",
-      HPE_INVALID_CONTENT_LENGTH,
-      HTTP_REQUEST);
-
-  test_simple_type(
-      "POST / HTTP/1.1\r\n"
-      "Content-Length: 13 37\r\n"
-      "\r\n",
-      HPE_INVALID_CONTENT_LENGTH,
-      HTTP_REQUEST);
-
-  test_simple_type(
-      "POST / HTTP/1.1\r\n"
-      "Content-Length:  42\r\n"
-      " Hello world!\r\n",
-      HPE_INVALID_CONTENT_LENGTH,
-      HTTP_REQUEST);
-
-  test_simple_type(
-      "POST / HTTP/1.1\r\n"
-      "Content-Length:  42\r\n"
-      " \r\n",
-      HPE_OK,
-      HTTP_REQUEST);
-
-  //// RESPONSES
-
-  test_simple_type("HTP/1.1 200 OK\r\n\r\n", HPE_INVALID_VERSION, HTTP_RESPONSE);
-  test_simple_type("HTTP/01.1 200 OK\r\n\r\n", HPE_INVALID_VERSION, HTTP_RESPONSE);
-  test_simple_type("HTTP/11.1 200 OK\r\n\r\n", HPE_INVALID_VERSION, HTTP_RESPONSE);
-  test_simple_type("HTTP/1.01 200 OK\r\n\r\n", HPE_INVALID_VERSION, HTTP_RESPONSE);
-  test_simple_type("HTTP/1.1\t200 OK\r\n\r\n", HPE_INVALID_VERSION, HTTP_RESPONSE);
-  test_simple_type("\rHTTP/1.1\t200 OK\r\n\r\n", HPE_INVALID_VERSION, HTTP_RESPONSE);
-
-  for (i = 0; i < ARRAY_SIZE(responses); i++) {
-    test_message(&responses[i]);
-  }
-
-  for (i = 0; i < ARRAY_SIZE(responses); i++) {
-    test_message_pause(&responses[i]);
-  }
-
-  for (i = 0; i < ARRAY_SIZE(responses); i++) {
-    test_message_connect(&responses[i]);
-  }
-
-  for (i = 0; i < ARRAY_SIZE(responses); i++) {
-    if (!responses[i].should_keep_alive) continue;
-    for (j = 0; j < ARRAY_SIZE(responses); j++) {
-      if (!responses[j].should_keep_alive) continue;
-      for (k = 0; k < ARRAY_SIZE(responses); k++) {
-        test_multiple3(&responses[i], &responses[j], &responses[k]);
-      }
-    }
-  }
-
-  test_message_count_body(&responses[NO_HEADERS_NO_BODY_404]);
-  test_message_count_body(&responses[TRAILING_SPACE_ON_CHUNKED_BODY]);
-
-  // test very large chunked response
-  {
-    char * msg = create_large_chunked_message(31337,
-      "HTTP/1.0 200 OK\r\n"
-      "Transfer-Encoding: chunked\r\n"
-      "Content-Type: text/plain\r\n"
-      "\r\n");
-    struct message large_chunked =
-      {.name= "large chunked"
-      ,.type= HTTP_RESPONSE
-      ,.raw= msg
-      ,.should_keep_alive= FALSE
-      ,.message_complete_on_eof= FALSE
-      ,.http_major= 1
-      ,.http_minor= 0
-      ,.status_code= 200
-      ,.response_status= "OK"
-      ,.content_length= -1
-      ,.num_headers= 2
-      ,.headers=
-        { { "Transfer-Encoding", "chunked" }
-        , { "Content-Type", "text/plain" }
-        }
-      ,.body_size= 31337*1024
-      ,.num_chunks_complete= 31338
-      };
-    for (i = 0; i < MAX_CHUNKS; i++) {
-      large_chunked.chunk_lengths[i] = 1024;
-    }
-    test_message_count_body(&large_chunked);
-    free(msg);
-  }
-
-
-
-  printf("response scan 1/2      ");
-  test_scan( &responses[TRAILING_SPACE_ON_CHUNKED_BODY]
-           , &responses[NO_BODY_HTTP10_KA_204]
-           , &responses[NO_REASON_PHRASE]
-           );
-
-  printf("response scan 2/2      ");
-  test_scan( &responses[BONJOUR_MADAME_FR]
-           , &responses[UNDERSTORE_HEADER_KEY]
-           , &responses[NO_CARRIAGE_RET]
-           );
-
-  puts("responses okay");
-
-
-  /// REQUESTS
-
-  test_simple("GET / IHTTP/1.0\r\n\r\n", HPE_INVALID_CONSTANT);
-  test_simple("GET / ICE/1.0\r\n\r\n", HPE_INVALID_CONSTANT);
-  test_simple("GET / HTP/1.1\r\n\r\n", HPE_INVALID_VERSION);
-  test_simple("GET / HTTP/01.1\r\n\r\n", HPE_INVALID_VERSION);
-  test_simple("GET / HTTP/11.1\r\n\r\n", HPE_INVALID_VERSION);
-  test_simple("GET / HTTP/1.01\r\n\r\n", HPE_INVALID_VERSION);
-
-  test_simple("GET / HTTP/1.0\r\nHello: w\1rld\r\n\r\n", HPE_INVALID_HEADER_TOKEN);
-  test_simple("GET / HTTP/1.0\r\nHello: woooo\2rld\r\n\r\n", HPE_INVALID_HEADER_TOKEN);
-
-  // Extended characters - see nodejs/test/parallel/test-http-headers-obstext.js
-  test_simple("GET / HTTP/1.1\r\n"
-              "Test: Düsseldorf\r\n",
-              HPE_OK);
-
-  // Well-formed but incomplete
-  test_simple("GET / HTTP/1.1\r\n"
-              "Content-Type: text/plain\r\n"
-              "Content-Length: 6\r\n"
-              "\r\n"
-              "fooba",
-              HPE_OK);
-
-  // Unknown Transfer-Encoding in request
-  test_simple("GET / HTTP/1.1\r\n"
-              "Transfer-Encoding: unknown\r\n"
-              "\r\n",
-              HPE_INVALID_TRANSFER_ENCODING);
-
-  static const char *all_methods[] = {
-    "DELETE",
-    "GET",
-    "HEAD",
-    "POST",
-    "PUT",
-    //"CONNECT", //CONNECT can't be tested like other methods, it's a tunnel
-    "OPTIONS",
-    "TRACE",
-    "COPY",
-    "LOCK",
-    "MKCOL",
-    "MOVE",
-    "PROPFIND",
-    "PROPPATCH",
-    "SEARCH",
-    "UNLOCK",
-    "BIND",
-    "REBIND",
-    "UNBIND",
-    "ACL",
-    "REPORT",
-    "MKACTIVITY",
-    "CHECKOUT",
-    "MERGE",
-    "M-SEARCH",
-    "NOTIFY",
-    "SUBSCRIBE",
-    "UNSUBSCRIBE",
-    "PATCH",
-    "PURGE",
-    "MKCALENDAR",
-    "LINK",
-    "UNLINK",
-    0 };
-  const char **this_method;
-  for (this_method = all_methods; *this_method; this_method++) {
-    char buf[200];
-    sprintf(buf, "%s / HTTP/1.1\r\n\r\n", *this_method);
-    test_simple(buf, HPE_OK);
-  }
-
-  static const char *bad_methods[] = {
-      "ASDF",
-      "C******",
-      "COLA",
-      "GEM",
-      "GETA",
-      "M****",
-      "MKCOLA",
-      "PROPPATCHA",
-      "PUN",
-      "PX",
-      "SA",
-      "hello world",
-      0 };
-  for (this_method = bad_methods; *this_method; this_method++) {
-    char buf[200];
-    sprintf(buf, "%s / HTTP/1.1\r\n\r\n", *this_method);
-    test_simple(buf, HPE_INVALID_METHOD);
-  }
-
-  // illegal header field name line folding
-  test_simple("GET / HTTP/1.1\r\n"
-              "name\r\n"
-              " : value\r\n"
-              "\r\n",
-              HPE_INVALID_HEADER_TOKEN);
-
-  const char *dumbluck2 =
-    "GET / HTTP/1.1\r\n"
-    "X-SSL-Nonsense:   -----BEGIN CERTIFICATE-----\r\n"
-    "\tMIIFbTCCBFWgAwIBAgICH4cwDQYJKoZIhvcNAQEFBQAwcDELMAkGA1UEBhMCVUsx\r\n"
-    "\tETAPBgNVBAoTCGVTY2llbmNlMRIwEAYDVQQLEwlBdXRob3JpdHkxCzAJBgNVBAMT\r\n"
-    "\tAkNBMS0wKwYJKoZIhvcNAQkBFh5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMu\r\n"
-    "\tdWswHhcNMDYwNzI3MTQxMzI4WhcNMDcwNzI3MTQxMzI4WjBbMQswCQYDVQQGEwJV\r\n"
-    "\tSzERMA8GA1UEChMIZVNjaWVuY2UxEzARBgNVBAsTCk1hbmNoZXN0ZXIxCzAJBgNV\r\n"
-    "\tBAcTmrsogriqMWLAk1DMRcwFQYDVQQDEw5taWNoYWVsIHBhcmQYJKoZIhvcNAQEB\r\n"
-    "\tBQADggEPADCCAQoCggEBANPEQBgl1IaKdSS1TbhF3hEXSl72G9J+WC/1R64fAcEF\r\n"
-    "\tW51rEyFYiIeZGx/BVzwXbeBoNUK41OK65sxGuflMo5gLflbwJtHBRIEKAfVVp3YR\r\n"
-    "\tgW7cMA/s/XKgL1GEC7rQw8lIZT8RApukCGqOVHSi/F1SiFlPDxuDfmdiNzL31+sL\r\n"
-    "\t0iwHDdNkGjy5pyBSB8Y79dsSJtCW/iaLB0/n8Sj7HgvvZJ7x0fr+RQjYOUUfrePP\r\n"
-    "\tu2MSpFyf+9BbC/aXgaZuiCvSR+8Snv3xApQY+fULK/xY8h8Ua51iXoQ5jrgu2SqR\r\n"
-    "\twgA7BUi3G8LFzMBl8FRCDYGUDy7M6QaHXx1ZWIPWNKsCAwEAAaOCAiQwggIgMAwG\r\n"
-    "\tA1UdEwEB/wQCMAAwEQYJYIZIAYb4QgHTTPAQDAgWgMA4GA1UdDwEB/wQEAwID6DAs\r\n"
-    "\tBglghkgBhvhCAQ0EHxYdVUsgZS1TY2llbmNlIFVzZXIgQ2VydGlmaWNhdGUwHQYD\r\n"
-    "\tVR0OBBYEFDTt/sf9PeMaZDHkUIldrDYMNTBZMIGaBgNVHSMEgZIwgY+AFAI4qxGj\r\n"
-    "\tloCLDdMVKwiljjDastqooXSkcjBwMQswCQYDVQQGEwJVSzERMA8GA1UEChMIZVNj\r\n"
-    "\taWVuY2UxEjAQBgNVBAsTCUF1dGhvcml0eTELMAkGA1UEAxMCQ0ExLTArBgkqhkiG\r\n"
-    "\t9w0BCQEWHmNhLW9wZXJhdG9yQGdyaWQtc3VwcG9ydC5hYy51a4IBADApBgNVHRIE\r\n"
-    "\tIjAggR5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMudWswGQYDVR0gBBIwEDAO\r\n"
-    "\tBgwrBgEEAdkvAQEBAQYwPQYJYIZIAYb4QgEEBDAWLmh0dHA6Ly9jYS5ncmlkLXN1\r\n"
-    "\tcHBvcnQuYWMudmT4sopwqlBWsvcHViL2NybC9jYWNybC5jcmwwPQYJYIZIAYb4QgEDBDAWLmh0\r\n"
-    "\tdHA6Ly9jYS5ncmlkLXN1cHBvcnQuYWMudWsvcHViL2NybC9jYWNybC5jcmwwPwYD\r\n"
-    "\tVR0fBDgwNjA0oDKgMIYuaHR0cDovL2NhLmdyaWQt5hYy51ay9wdWIv\r\n"
-    "\tY3JsL2NhY3JsLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAS/U4iiooBENGW/Hwmmd3\r\n"
-    "\tXCy6Zrt08YjKCzGNjorT98g8uGsqYjSxv/hmi0qlnlHs+k/3Iobc3LjS5AMYr5L8\r\n"
-    "\tUO7OSkgFFlLHQyC9JzPfmLCAugvzEbyv4Olnsr8hbxF1MbKZoQxUZtMVu29wjfXk\r\n"
-    "\thTeApBv7eaKCWpSp7MCbvgzm74izKhu3vlDk9w6qVrxePfGgpKPqfHiOoGhFnbTK\r\n"
-    "\twTC6o2xq5y0qZ03JonF7OJspEd3I5zKY3E+ov7/ZhW6DqT8UFvsAdjvQbXyhV8Eu\r\n"
-    "\tYhixw1aKEPzNjNowuIseVogKOLXxWI5vAi5HgXdS0/ES5gDGsABo4fqovUKlgop3\r\n"
-    "\tRA==\r\n"
-    "\t-----END CERTIFICATE-----\r\n"
-    "\r\n";
-  test_simple(dumbluck2, HPE_OK);
-
-  const char *corrupted_connection =
-    "GET / HTTP/1.1\r\n"
-    "Host: www.example.com\r\n"
-    "Connection\r\033\065\325eep-Alive\r\n"
-    "Accept-Encoding: gzip\r\n"
-    "\r\n";
-  test_simple(corrupted_connection, HPE_INVALID_HEADER_TOKEN);
-
-  const char *corrupted_header_name =
-    "GET / HTTP/1.1\r\n"
-    "Host: www.example.com\r\n"
-    "X-Some-Header\r\033\065\325eep-Alive\r\n"
-    "Accept-Encoding: gzip\r\n"
-    "\r\n";
-  test_simple(corrupted_header_name, HPE_INVALID_HEADER_TOKEN);
-
-#if 0
-  // NOTE(Wed Nov 18 11:57:27 CET 2009) this seems okay. we just read body
-  // until EOF.
-  //
-  // no content-length
-  // error if there is a body without content length
-  const char *bad_get_no_headers_no_body = "GET /bad_get_no_headers_no_body/world HTTP/1.1\r\n"
-                                           "Accept: */*\r\n"
-                                           "\r\n"
-                                           "HELLO";
-  test_simple(bad_get_no_headers_no_body, 0);
-#endif
-  /* TODO sending junk and large headers gets rejected */
-
-
-  /* check to make sure our predefined requests are okay */
-  for (i = 0; i < ARRAY_SIZE(requests); i++) {
-    test_message(&requests[i]);
-  }
-
-  for (i = 0; i < ARRAY_SIZE(requests); i++) {
-    test_message_pause(&requests[i]);
-  }
-
-  for (i = 0; i < ARRAY_SIZE(requests); i++) {
-    if (!requests[i].should_keep_alive) continue;
-    for (j = 0; j < ARRAY_SIZE(requests); j++) {
-      if (!requests[j].should_keep_alive) continue;
-      for (k = 0; k < ARRAY_SIZE(requests); k++) {
-        test_multiple3(&requests[i], &requests[j], &requests[k]);
-      }
-    }
-  }
-
-  printf("request scan 1/4      ");
-  test_scan( &requests[GET_NO_HEADERS_NO_BODY]
-           , &requests[GET_ONE_HEADER_NO_BODY]
-           , &requests[GET_NO_HEADERS_NO_BODY]
-           );
-
-  printf("request scan 2/4      ");
-  test_scan( &requests[POST_CHUNKED_ALL_YOUR_BASE]
-           , &requests[POST_IDENTITY_BODY_WORLD]
-           , &requests[GET_FUNKY_CONTENT_LENGTH]
-           );
-
-  printf("request scan 3/4      ");
-  test_scan( &requests[TWO_CHUNKS_MULT_ZERO_END]
-           , &requests[CHUNKED_W_TRAILING_HEADERS]
-           , &requests[CHUNKED_W_NONSENSE_AFTER_LENGTH]
-           );
-
-  printf("request scan 4/4      ");
-  test_scan( &requests[QUERY_URL_WITH_QUESTION_MARK_GET]
-           , &requests[PREFIX_NEWLINE_GET ]
-           , &requests[CONNECT_REQUEST]
-           );
-
-  puts("requests okay");
-
-  return 0;
-}
diff --git a/deps/icu-small/LICENSE b/deps/icu-small/LICENSE
index e7f98ed18391b8f715d86c0da9e8c727fdc5125b..5d664a083b986f3ea5b5b300bf9e465d0035e752 100644
--- a/deps/icu-small/LICENSE
+++ b/deps/icu-small/LICENSE
@@ -284,9 +284,9 @@ property of their respective owners.
  #  Copyright (c) 2013 International Business Machines Corporation
  #  and others. All Rights Reserved.
  #
- # Project: http://code.google.com/p/lao-dictionary/
- # Dictionary: http://lao-dictionary.googlecode.com/git/Lao-Dictionary.txt
- # License: http://lao-dictionary.googlecode.com/git/Lao-Dictionary-LICENSE.txt
+ # Project: https://github.com/veer66/lao-dictionary
+ # Dictionary: https://github.com/veer66/lao-dictionary/blob/master/Lao-Dictionary.txt
+ # License: https://github.com/veer66/lao-dictionary/blob/master/Lao-Dictionary-LICENSE.txt
  #              (copied below)
  #
  #  This file is derived from the above dictionary, with slight
diff --git a/deps/icu-small/README-FULL-ICU.txt b/deps/icu-small/README-FULL-ICU.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2af8c5faf34727af4d16403b97e00665638261e0
--- /dev/null
+++ b/deps/icu-small/README-FULL-ICU.txt
@@ -0,0 +1,8 @@
+ICU sources - auto generated by shrink-icu-src.py
+
+This directory contains the ICU subset used by --with-intl=full-icu
+It is a strict subset of ICU 69 source files with the following exception(s):
+* deps/icu-small/source/data/in/icudt69l.dat.bz2 : compressed data file
+
+
+To rebuild this directory, see ../../tools/icu/README.md
diff --git a/deps/icu-small/README-SMALL-ICU.txt b/deps/icu-small/README-SMALL-ICU.txt
deleted file mode 100644
index b1aeabe031187ceea6affaa77d4fc4aa59b126aa..0000000000000000000000000000000000000000
--- a/deps/icu-small/README-SMALL-ICU.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-Small ICU sources - auto generated by shrink-icu-src.py
-
-This directory contains the ICU subset used by --with-intl=small-icu (the default)
-It is a strict subset of ICU 67 source files with the following exception(s):
-* deps/icu-small/source/data/in/icudt67l.dat : Reduced-size data file
-* deps/icu-small/source/common/uassert.h : Manual backport of ICU-21081
-
-To rebuild this directory, see ../../tools/icu/README.md
diff --git a/deps/icu-small/source/.clang-format b/deps/icu-small/source/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..06bd4885a10a210abe43bb27868575efd1c59ebe
--- /dev/null
+++ b/deps/icu-small/source/.clang-format
@@ -0,0 +1,11 @@
+# © 2020 and later: Unicode, Inc. and others.
+# License & terms of use: http://www.unicode.org/copyright.html
+
+---
+Language: Cpp
+BasedOnStyle: LLVM
+IndentWidth: 4
+ColumnLimit: 105
+AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: true
+...
diff --git a/deps/icu-small/source/common/bmpset.h b/deps/icu-small/source/common/bmpset.h
index 018aeb7f95b078733512cd59c857c29d87959ce8..e1982ac669db859b4ec5dc90aa9659b49395be21 100644
--- a/deps/icu-small/source/common/bmpset.h
+++ b/deps/icu-small/source/common/bmpset.h
@@ -101,7 +101,7 @@ private:
      */
     UBool latin1Contains[0x100];
 
-    /* TRUE if contains(U+FFFD). */
+    /* true if contains(U+FFFD). */
     UBool containsFFFD;
 
     /*
diff --git a/deps/icu-small/source/common/brkeng.h b/deps/icu-small/source/common/brkeng.h
index e40fce13f64b8aa24f6ceacecfae4bc3fc438308..155433b89a86ac0808990912b0760b5cadd3b51a 100644
--- a/deps/icu-small/source/common/brkeng.h
+++ b/deps/icu-small/source/common/brkeng.h
@@ -54,7 +54,7 @@ class LanguageBreakEngine : public UMemory {
   * a particular kind of break.</p>
   *
   * @param c A character which begins a run that the engine might handle
-  * @return TRUE if this engine handles the particular character and break
+  * @return true if this engine handles the particular character and break
   * type.
   */
   virtual UBool handles(UChar32 c) const = 0;
@@ -171,7 +171,7 @@ class UnhandledEngine : public LanguageBreakEngine {
   * a particular kind of break.</p>
   *
   * @param c A character which begins a run that the engine might handle
-  * @return TRUE if this engine handles the particular character and break
+  * @return true if this engine handles the particular character and break
   * type.
   */
   virtual UBool handles(UChar32 c) const;
diff --git a/deps/icu-small/source/common/bytesinkutil.h b/deps/icu-small/source/common/bytesinkutil.h
index 6808fbe6777837470d3808dc701a2c95b4ae5017..ab2516432d31118358159b92ae14c6ce9e5b6b40 100644
--- a/deps/icu-small/source/common/bytesinkutil.h
+++ b/deps/icu-small/source/common/bytesinkutil.h
@@ -45,9 +45,9 @@ public:
     static UBool appendUnchanged(const uint8_t *s, int32_t length,
                                  ByteSink &sink, uint32_t options, Edits *edits,
                                  UErrorCode &errorCode) {
-        if (U_FAILURE(errorCode)) { return FALSE; }
+        if (U_FAILURE(errorCode)) { return false; }
         if (length > 0) { appendNonEmptyUnchanged(s, length, sink, options, edits); }
-        return TRUE;
+        return true;
     }
 
     static UBool appendUnchanged(const uint8_t *s, const uint8_t *limit,
diff --git a/deps/icu-small/source/common/bytestriebuilder.cpp b/deps/icu-small/source/common/bytestriebuilder.cpp
index ec1ab7d8f5080e5af15799fa8636d3ab98b0ec73..28256f272a74a326bb28e9cb48a607e66a8246ae 100644
--- a/deps/icu-small/source/common/bytestriebuilder.cpp
+++ b/deps/icu-small/source/common/bytestriebuilder.cpp
@@ -474,31 +474,39 @@ BytesTrieBuilder::writeDeltaTo(int32_t jumpTarget) {
     U_ASSERT(i>=0);
     if(i<=BytesTrie::kMaxOneByteDelta) {
         return write(i);
+    } else {
+        char intBytes[5];
+        return write(intBytes, internalEncodeDelta(i, intBytes));
     }
-    char intBytes[5];
-    int32_t length;
+}
+
+int32_t
+BytesTrieBuilder::internalEncodeDelta(int32_t i, char intBytes[]) {
+    U_ASSERT(i>=0);
+    if(i<=BytesTrie::kMaxOneByteDelta) {
+        intBytes[0]=(char)i;
+        return 1;
+    }
+    int32_t length=1;
     if(i<=BytesTrie::kMaxTwoByteDelta) {
         intBytes[0]=(char)(BytesTrie::kMinTwoByteDeltaLead+(i>>8));
-        length=1;
     } else {
         if(i<=BytesTrie::kMaxThreeByteDelta) {
             intBytes[0]=(char)(BytesTrie::kMinThreeByteDeltaLead+(i>>16));
-            length=2;
         } else {
             if(i<=0xffffff) {
                 intBytes[0]=(char)BytesTrie::kFourByteDeltaLead;
-                length=3;
             } else {
                 intBytes[0]=(char)BytesTrie::kFiveByteDeltaLead;
                 intBytes[1]=(char)(i>>24);
-                length=4;
+                length=2;
             }
-            intBytes[1]=(char)(i>>16);
+            intBytes[length++]=(char)(i>>16);
         }
-        intBytes[1]=(char)(i>>8);
+        intBytes[length++]=(char)(i>>8);
     }
     intBytes[length++]=(char)i;
-    return write(intBytes, length);
+    return length;
 }
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/common/charstr.cpp b/deps/icu-small/source/common/charstr.cpp
index dda29dac63273c9bd904f45e84fb7182a4842669..c35622882c4523300946a04905f58deda63e43a4 100644
--- a/deps/icu-small/source/common/charstr.cpp
+++ b/deps/icu-small/source/common/charstr.cpp
@@ -14,12 +14,15 @@
 *   created by: Markus W. Scherer
 */
 
+#include <cstdlib>
+
 #include "unicode/utypes.h"
 #include "unicode/putil.h"
 #include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "uinvchar.h"
+#include "ustr_imp.h"
 
 U_NAMESPACE_BEGIN
 
@@ -46,6 +49,19 @@ char *CharString::cloneData(UErrorCode &errorCode) const {
     return p;
 }
 
+int32_t CharString::extract(char *dest, int32_t capacity, UErrorCode &errorCode) const {
+    if (U_FAILURE(errorCode)) { return len; }
+    if (capacity < 0 || (capacity > 0 && dest == nullptr)) {
+        errorCode = U_ILLEGAL_ARGUMENT_ERROR;
+        return len;
+    }
+    const char *src = buffer.getAlias();
+    if (0 < len && len <= capacity && src != dest) {
+        uprv_memcpy(dest, src, len);
+    }
+    return u_terminateChars(dest, capacity, len, &errorCode);
+}
+
 CharString &CharString::copyFrom(const CharString &s, UErrorCode &errorCode) {
     if(U_SUCCESS(errorCode) && this!=&s && ensureCapacity(s.len+1, 0, errorCode)) {
         len=s.len;
@@ -127,6 +143,38 @@ CharString &CharString::append(const char *s, int32_t sLength, UErrorCode &error
     return *this;
 }
 
+CharString &CharString::appendNumber(int32_t number, UErrorCode &status) {
+    if (number < 0) {
+        this->append('-', status);
+        if (U_FAILURE(status)) {
+            return *this;
+        }
+    }
+
+    if (number == 0) {
+        this->append('0', status);
+        return *this;
+    }
+
+    int32_t numLen = 0;
+    while (number != 0) {
+        int32_t residue = number % 10;
+        number /= 10;
+        this->append(std::abs(residue) + '0', status);
+        numLen++;
+        if (U_FAILURE(status)) {
+            return *this;
+        }
+    }
+
+    int32_t start = this->length() - numLen, end = this->length() - 1;
+    while(start < end) {
+        std::swap(this->data()[start++], this->data()[end--]);
+    }
+
+    return *this;
+}
+
 char *CharString::getAppendBuffer(int32_t minCapacity,
                                   int32_t desiredCapacityHint,
                                   int32_t &resultCapacity,
@@ -197,7 +245,7 @@ CharString &CharString::appendPathPart(StringPiece s, UErrorCode &errorCode) {
     }
     char c;
     if(len>0 && (c=buffer[len-1])!=U_FILE_SEP_CHAR && c!=U_FILE_ALT_SEP_CHAR) {
-        append(U_FILE_SEP_CHAR, errorCode);
+        append(getDirSepChar(), errorCode);
     }
     append(s, errorCode);
     return *this;
@@ -207,9 +255,19 @@ CharString &CharString::ensureEndsWithFileSeparator(UErrorCode &errorCode) {
     char c;
     if(U_SUCCESS(errorCode) && len>0 &&
             (c=buffer[len-1])!=U_FILE_SEP_CHAR && c!=U_FILE_ALT_SEP_CHAR) {
-        append(U_FILE_SEP_CHAR, errorCode);
+        append(getDirSepChar(), errorCode);
     }
     return *this;
 }
 
+char CharString::getDirSepChar() const {
+    char dirSepChar = U_FILE_SEP_CHAR;
+#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR)
+    // We may need to return a different directory separator when building for Cygwin or MSYS2.
+    if(len>0 && !uprv_strchr(data(), U_FILE_SEP_CHAR) && uprv_strchr(data(), U_FILE_ALT_SEP_CHAR))
+        dirSepChar = U_FILE_ALT_SEP_CHAR;
+#endif
+    return dirSepChar;
+}
+
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/common/charstr.h b/deps/icu-small/source/common/charstr.h
index 23b950ed6ecc769f275e3018406a2ace87936eb6..175acd1c0a2b408d683c4d87b14dc1fca7a3f191 100644
--- a/deps/icu-small/source/common/charstr.h
+++ b/deps/icu-small/source/common/charstr.h
@@ -87,6 +87,22 @@ public:
      * The caller must uprv_free() the result.
      */
     char *cloneData(UErrorCode &errorCode) const;
+    /**
+     * Copies the contents of the string into dest.
+     * Checks if there is enough space in dest, extracts the entire string if possible,
+     * and NUL-terminates dest if possible.
+     *
+     * If the string fits into dest but cannot be NUL-terminated (length()==capacity),
+     * then the error code is set to U_STRING_NOT_TERMINATED_WARNING.
+     * If the string itself does not fit into dest (length()>capacity),
+     * then the error code is set to U_BUFFER_OVERFLOW_ERROR.
+     *
+     * @param dest Destination string buffer.
+     * @param capacity Size of the dest buffer (number of chars).
+     * @param errorCode ICU error code.
+     * @return length()
+     */
+    int32_t extract(char *dest, int32_t capacity, UErrorCode &errorCode) const;
 
     bool operator==(StringPiece other) const {
         return len == other.length() && (len == 0 || uprv_memcmp(data(), other.data(), len) == 0);
@@ -111,6 +127,9 @@ public:
         return append(s.data(), s.length(), errorCode);
     }
     CharString &append(const char *s, int32_t sLength, UErrorCode &status);
+
+    CharString &appendNumber(int32_t number, UErrorCode &status);
+
     /**
      * Returns a writable buffer for appending and writes the buffer's capacity to
      * resultCapacity. Guarantees resultCapacity>=minCapacity if U_SUCCESS().
@@ -141,13 +160,13 @@ public:
 
     /**
      * Appends a filename/path part, e.g., a directory name.
-     * First appends a U_FILE_SEP_CHAR if necessary.
+     * First appends a U_FILE_SEP_CHAR or U_FILE_ALT_SEP_CHAR if necessary.
      * Does nothing if s is empty.
      */
     CharString &appendPathPart(StringPiece s, UErrorCode &errorCode);
 
     /**
-     * Appends a U_FILE_SEP_CHAR if this string is not empty
+     * Appends a U_FILE_SEP_CHAR or U_FILE_ALT_SEP_CHAR if this string is not empty
      * and does not already end with a U_FILE_SEP_CHAR or U_FILE_ALT_SEP_CHAR.
      */
     CharString &ensureEndsWithFileSeparator(UErrorCode &errorCode);
@@ -160,6 +179,12 @@ private:
 
     CharString(const CharString &other); // forbid copying of this class
     CharString &operator=(const CharString &other); // forbid copying of this class
+
+    /**
+     * Returns U_FILE_ALT_SEP_CHAR if found in string, and U_FILE_SEP_CHAR is not found.
+     * Otherwise returns U_FILE_SEP_CHAR.
+     */
+    char getDirSepChar() const;
 };
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/common/charstrmap.h b/deps/icu-small/source/common/charstrmap.h
new file mode 100644
index 0000000000000000000000000000000000000000..3320a4620852ce7324c43ce07f01655ee99f08b2
--- /dev/null
+++ b/deps/icu-small/source/common/charstrmap.h
@@ -0,0 +1,55 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+// charstrmap.h
+// created: 2020sep01 Frank Yung-Fong Tang
+
+#ifndef __CHARSTRMAP_H__
+#define __CHARSTRMAP_H__
+
+#include <utility>
+#include "unicode/utypes.h"
+#include "unicode/uobject.h"
+#include "uhash.h"
+
+U_NAMESPACE_BEGIN
+
+/**
+ * Map of const char * keys & values.
+ * Stores pointers as is: Does not own/copy/adopt/release strings.
+ */
+class CharStringMap final : public UMemory {
+public:
+    /** Constructs an unusable non-map. */
+    CharStringMap() : map(nullptr) {}
+    CharStringMap(int32_t size, UErrorCode &errorCode) {
+        map = uhash_openSize(uhash_hashChars, uhash_compareChars, uhash_compareChars,
+                             size, &errorCode);
+    }
+    CharStringMap(CharStringMap &&other) U_NOEXCEPT : map(other.map) {
+        other.map = nullptr;
+    }
+    CharStringMap(const CharStringMap &other) = delete;
+    ~CharStringMap() {
+        uhash_close(map);
+    }
+
+    CharStringMap &operator=(CharStringMap &&other) U_NOEXCEPT {
+        map = other.map;
+        other.map = nullptr;
+        return *this;
+    }
+    CharStringMap &operator=(const CharStringMap &other) = delete;
+
+    const char *get(const char *key) const { return static_cast<const char *>(uhash_get(map, key)); }
+    void put(const char *key, const char *value, UErrorCode &errorCode) {
+        uhash_put(map, const_cast<char *>(key), const_cast<char *>(value), &errorCode);
+    }
+
+private:
+    UHashtable *map;
+};
+
+U_NAMESPACE_END
+
+#endif  //  __CHARSTRMAP_H__
diff --git a/deps/icu-small/source/common/cmemory.h b/deps/icu-small/source/common/cmemory.h
index 38f99179631b1060548349dd71b4e5ccd178fb1d..a925f3df637378c152468adf9f60c7978acba514 100644
--- a/deps/icu-small/source/common/cmemory.h
+++ b/deps/icu-small/source/common/cmemory.h
@@ -31,14 +31,63 @@
 #include <stddef.h>
 #include <string.h>
 #include "unicode/localpointer.h"
+#include "uassert.h"
 
 #if U_DEBUG && defined(UPRV_MALLOC_COUNT)
 #include <stdio.h>
 #endif
 
-
-#define uprv_memcpy(dst, src, size) U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size)
-#define uprv_memmove(dst, src, size) U_STANDARD_CPP_NAMESPACE memmove(dst, src, size)
+// uprv_memcpy and uprv_memmove
+#if defined(__clang__)
+#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \
+    /* Suppress warnings about addresses that will never be NULL */ \
+    _Pragma("clang diagnostic push") \
+    _Pragma("clang diagnostic ignored \"-Waddress\"") \
+    U_ASSERT(dst != NULL); \
+    U_ASSERT(src != NULL); \
+    _Pragma("clang diagnostic pop") \
+    U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \
+} UPRV_BLOCK_MACRO_END
+#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \
+    /* Suppress warnings about addresses that will never be NULL */ \
+    _Pragma("clang diagnostic push") \
+    _Pragma("clang diagnostic ignored \"-Waddress\"") \
+    U_ASSERT(dst != NULL); \
+    U_ASSERT(src != NULL); \
+    _Pragma("clang diagnostic pop") \
+    U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \
+} UPRV_BLOCK_MACRO_END
+#elif defined(__GNUC__)
+#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \
+    /* Suppress warnings about addresses that will never be NULL */ \
+    _Pragma("GCC diagnostic push") \
+    _Pragma("GCC diagnostic ignored \"-Waddress\"") \
+    U_ASSERT(dst != NULL); \
+    U_ASSERT(src != NULL); \
+    _Pragma("GCC diagnostic pop") \
+    U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \
+} UPRV_BLOCK_MACRO_END
+#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \
+    /* Suppress warnings about addresses that will never be NULL */ \
+    _Pragma("GCC diagnostic push") \
+    _Pragma("GCC diagnostic ignored \"-Waddress\"") \
+    U_ASSERT(dst != NULL); \
+    U_ASSERT(src != NULL); \
+    _Pragma("GCC diagnostic pop") \
+    U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \
+} UPRV_BLOCK_MACRO_END
+#else
+#define uprv_memcpy(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \
+    U_ASSERT(dst != NULL); \
+    U_ASSERT(src != NULL); \
+    U_STANDARD_CPP_NAMESPACE memcpy(dst, src, size); \
+} UPRV_BLOCK_MACRO_END
+#define uprv_memmove(dst, src, size) UPRV_BLOCK_MACRO_BEGIN { \
+    U_ASSERT(dst != NULL); \
+    U_ASSERT(src != NULL); \
+    U_STANDARD_CPP_NAMESPACE memmove(dst, src, size); \
+} UPRV_BLOCK_MACRO_END
+#endif
 
 /**
  * \def UPRV_LENGTHOF
@@ -292,14 +341,21 @@ public:
     /**
      * Default constructor initializes with internal T[stackCapacity] buffer.
      */
-    MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(FALSE) {}
+    MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {}
     /**
      * Automatically allocates the heap array if the argument is larger than the stack capacity.
      * Intended for use when an approximate capacity is known at compile time but the true
      * capacity is not known until runtime.
      */
-    MaybeStackArray(int32_t newCapacity) : MaybeStackArray() {
-        if (capacity < newCapacity) { resize(newCapacity); }
+    MaybeStackArray(int32_t newCapacity, UErrorCode status) : MaybeStackArray() {
+        if (U_FAILURE(status)) {
+            return;
+        }
+        if (capacity < newCapacity) {
+            if (resize(newCapacity) == nullptr) {
+                status = U_MEMORY_ALLOCATION_ERROR;
+            }
+        }
     }
     /**
      * Destructor deletes the array (if owned).
@@ -355,7 +411,7 @@ public:
             releaseArray();
             ptr=otherArray;
             capacity=otherCapacity;
-            needToRelease=FALSE;
+            needToRelease=false;
         }
     }
     /**
@@ -380,6 +436,20 @@ public:
      *         caller becomes responsible for deleting the array
      */
     inline T *orphanOrClone(int32_t length, int32_t &resultCapacity);
+
+protected:
+    // Resizes the array to the size of src, then copies the contents of src.
+    void copyFrom(const MaybeStackArray &src, UErrorCode &status) {
+        if (U_FAILURE(status)) {
+            return;
+        }
+        if (this->resize(src.capacity, 0) == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        uprv_memcpy(this->ptr, src.ptr, (size_t)capacity * sizeof(T));
+    }
+
 private:
     T *ptr;
     int32_t capacity;
@@ -393,14 +463,14 @@ private:
     void resetToStackArray() {
         ptr=stackArray;
         capacity=stackCapacity;
-        needToRelease=FALSE;
+        needToRelease=false;
     }
     /* No comparison operators with other MaybeStackArray's. */
-    bool operator==(const MaybeStackArray & /*other*/) {return FALSE;}
-    bool operator!=(const MaybeStackArray & /*other*/) {return TRUE;}
+    bool operator==(const MaybeStackArray & /*other*/) = delete;
+    bool operator!=(const MaybeStackArray & /*other*/) = delete;
     /* No ownership transfer: No copy constructor, no assignment operator. */
-    MaybeStackArray(const MaybeStackArray & /*other*/) {}
-    void operator=(const MaybeStackArray & /*other*/) {}
+    MaybeStackArray(const MaybeStackArray & /*other*/) = delete;
+    void operator=(const MaybeStackArray & /*other*/) = delete;
 };
 
 template<typename T, int32_t stackCapacity>
@@ -435,7 +505,7 @@ template<typename T, int32_t stackCapacity>
 inline T *MaybeStackArray<T, stackCapacity>::resize(int32_t newCapacity, int32_t length) {
     if(newCapacity>0) {
 #if U_DEBUG && defined(UPRV_MALLOC_COUNT)
-      ::fprintf(::stderr,"MaybeStacArray (resize) alloc %d * %lu\n", newCapacity,sizeof(T));
+        ::fprintf(::stderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T));
 #endif
         T *p=(T *)uprv_malloc(newCapacity*sizeof(T));
         if(p!=NULL) {
@@ -451,7 +521,7 @@ inline T *MaybeStackArray<T, stackCapacity>::resize(int32_t newCapacity, int32_t
             releaseArray();
             ptr=p;
             capacity=newCapacity;
-            needToRelease=TRUE;
+            needToRelease=true;
         }
         return p;
     } else {
@@ -507,7 +577,7 @@ public:
     /**
      * Default constructor initializes with internal H+T[stackCapacity] buffer.
      */
-    MaybeStackHeaderAndArray() : ptr(&stackHeader), capacity(stackCapacity), needToRelease(FALSE) {}
+    MaybeStackHeaderAndArray() : ptr(&stackHeader), capacity(stackCapacity), needToRelease(false) {}
     /**
      * Destructor deletes the memory (if owned).
      */
@@ -556,7 +626,7 @@ public:
             releaseMemory();
             ptr=otherMemory;
             capacity=otherCapacity;
-            needToRelease=FALSE;
+            needToRelease=false;
         }
     }
     /**
@@ -595,8 +665,8 @@ private:
         }
     }
     /* No comparison operators with other MaybeStackHeaderAndArray's. */
-    bool operator==(const MaybeStackHeaderAndArray & /*other*/) {return FALSE;}
-    bool operator!=(const MaybeStackHeaderAndArray & /*other*/) {return TRUE;}
+    bool operator==(const MaybeStackHeaderAndArray & /*other*/) {return false;}
+    bool operator!=(const MaybeStackHeaderAndArray & /*other*/) {return true;}
     /* No ownership transfer: No copy constructor, no assignment operator. */
     MaybeStackHeaderAndArray(const MaybeStackHeaderAndArray & /*other*/) {}
     void operator=(const MaybeStackHeaderAndArray & /*other*/) {}
@@ -625,7 +695,7 @@ inline H *MaybeStackHeaderAndArray<H, T, stackCapacity>::resize(int32_t newCapac
             releaseMemory();
             ptr=p;
             capacity=newCapacity;
-            needToRelease=TRUE;
+            needToRelease=true;
         }
         return p;
     } else {
@@ -657,7 +727,7 @@ inline H *MaybeStackHeaderAndArray<H, T, stackCapacity>::orphanOrClone(int32_t l
     resultCapacity=length;
     ptr=&stackHeader;
     capacity=stackCapacity;
-    needToRelease=FALSE;
+    needToRelease=false;
     return p;
 }
 
@@ -704,9 +774,14 @@ public:
     }
 
     MemoryPool& operator=(MemoryPool&& other) U_NOEXCEPT {
-        fCount = other.fCount;
-        fPool = std::move(other.fPool);
-        other.fCount = 0;
+        // Since `this` may contain instances that need to be deleted, we can't
+        // just throw them away and replace them with `other`. The normal way of
+        // dealing with this in C++ is to swap `this` and `other`, rather than
+        // simply overwrite: the destruction of `other` can then take care of
+        // running MemoryPool::~MemoryPool() over the still-to-be-deallocated
+        // instances.
+        std::swap(fCount, other.fCount);
+        std::swap(fPool, other.fPool);
         return *this;
     }
 
@@ -728,6 +803,18 @@ public:
         return fPool[fCount++] = new T(std::forward<Args>(args)...);
     }
 
+    template <typename... Args>
+    T* createAndCheckErrorCode(UErrorCode &status, Args &&... args) {
+        if (U_FAILURE(status)) {
+            return nullptr;
+        }
+        T *pointer = this->create(args...);
+        if (U_SUCCESS(status) && pointer == nullptr) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+        }
+        return pointer;
+    }
+
     /**
      * @return Number of elements that have been allocated.
      */
@@ -763,14 +850,16 @@ protected:
 template<typename T, int32_t stackCapacity = 8>
 class MaybeStackVector : protected MemoryPool<T, stackCapacity> {
 public:
-    using MemoryPool<T, stackCapacity>::MemoryPool;
-    using MemoryPool<T, stackCapacity>::operator=;
-
     template<typename... Args>
     T* emplaceBack(Args&&... args) {
         return this->create(args...);
     }
 
+    template <typename... Args>
+    T *emplaceBackAndCheckErrorCode(UErrorCode &status, Args &&... args) {
+        return this->createAndCheckErrorCode(status, args...);
+    }
+
     int32_t length() const {
         return this->fCount;
     }
@@ -779,6 +868,10 @@ public:
         return this->fPool.getAlias();
     }
 
+    const T *const *getAlias() const {
+        return this->fPool.getAlias();
+    }
+
     /**
      * Array item access (read-only).
      * No index bounds check.
@@ -798,19 +891,6 @@ public:
     T* operator[](ptrdiff_t i) {
         return this->fPool[i];
     }
-
-    /**
-     * Append all the items from another MaybeStackVector to this one.
-     */
-    void appendAll(const MaybeStackVector& other, UErrorCode& status) {
-        for (int32_t i = 0; i < other.fCount; i++) {
-            T* item = emplaceBack(*other[i]);
-            if (!item) {
-                status = U_MEMORY_ALLOCATION_ERROR;
-                return;
-            }
-        }
-    }
 };
 
 
diff --git a/deps/icu-small/source/common/dictbe.cpp b/deps/icu-small/source/common/dictbe.cpp
index 6d3bc8780788472482046328aaba3ed86cdd4a9a..88533cedcecc838bf8a60d61279cc1c5ab395ea4 100644
--- a/deps/icu-small/source/common/dictbe.cpp
+++ b/deps/icu-small/source/common/dictbe.cpp
@@ -265,13 +265,9 @@ ThaiBreakEngine::divideUpDictionaryRange( UText *text,
                 goto foundBest;
             }
             do {
-                int32_t wordsMatched = 1;
                 if (words[(wordsFound + 1) % THAI_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) > 0) {
-                    if (wordsMatched < 2) {
-                        // Followed by another dictionary word; mark first word as a good candidate
-                        words[wordsFound%THAI_LOOKAHEAD].markCurrent();
-                        wordsMatched = 2;
-                    }
+                    // Followed by another dictionary word; mark first word as a good candidate
+                    words[wordsFound%THAI_LOOKAHEAD].markCurrent();
 
                     // If we're already at the end of the range, we're done
                     if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) {
@@ -503,13 +499,9 @@ LaoBreakEngine::divideUpDictionaryRange( UText *text,
                 goto foundBest;
             }
             do {
-                int32_t wordsMatched = 1;
                 if (words[(wordsFound + 1) % LAO_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) > 0) {
-                    if (wordsMatched < 2) {
-                        // Followed by another dictionary word; mark first word as a good candidate
-                        words[wordsFound%LAO_LOOKAHEAD].markCurrent();
-                        wordsMatched = 2;
-                    }
+                    // Followed by another dictionary word; mark first word as a good candidate
+                    words[wordsFound%LAO_LOOKAHEAD].markCurrent();
 
                     // If we're already at the end of the range, we're done
                     if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) {
@@ -699,13 +691,9 @@ BurmeseBreakEngine::divideUpDictionaryRange( UText *text,
                 goto foundBest;
             }
             do {
-                int32_t wordsMatched = 1;
                 if (words[(wordsFound + 1) % BURMESE_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) > 0) {
-                    if (wordsMatched < 2) {
-                        // Followed by another dictionary word; mark first word as a good candidate
-                        words[wordsFound%BURMESE_LOOKAHEAD].markCurrent();
-                        wordsMatched = 2;
-                    }
+                    // Followed by another dictionary word; mark first word as a good candidate
+                    words[wordsFound%BURMESE_LOOKAHEAD].markCurrent();
 
                     // If we're already at the end of the range, we're done
                     if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) {
@@ -908,13 +896,9 @@ KhmerBreakEngine::divideUpDictionaryRange( UText *text,
                 goto foundBest;
             }
             do {
-                int32_t wordsMatched = 1;
                 if (words[(wordsFound + 1) % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) > 0) {
-                    if (wordsMatched < 2) {
-                        // Followed by another dictionary word; mark first word as a good candidate
-                        words[wordsFound % KHMER_LOOKAHEAD].markCurrent();
-                        wordsMatched = 2;
-                    }
+                    // Followed by another dictionary word; mark first word as a good candidate
+                    words[wordsFound % KHMER_LOOKAHEAD].markCurrent();
 
                     // If we're already at the end of the range, we're done
                     if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) {
diff --git a/deps/icu-small/source/common/dictbe.h b/deps/icu-small/source/common/dictbe.h
index 99d176cc2e7bcf33185ec1726b0af8d8ed0c32b3..246c1dc6935fbd254d28919d06e03872e67f8fb3 100644
--- a/deps/icu-small/source/common/dictbe.h
+++ b/deps/icu-small/source/common/dictbe.h
@@ -59,7 +59,7 @@ class DictionaryBreakEngine : public LanguageBreakEngine {
    * a particular kind of break.</p>
    *
    * @param c A character which begins a run that the engine might handle
-   * @return TRUE if this engine handles the particular character and break
+   * @return true if this engine handles the particular character and break
    * type.
    */
   virtual UBool handles(UChar32 c) const;
diff --git a/deps/icu-small/source/common/edits.cpp b/deps/icu-small/source/common/edits.cpp
index 95f0c19a728cf411cbfa97de5b8d4878186aafb2..92ca36fb5d04a3003d672b4cc929a3811a362816 100644
--- a/deps/icu-small/source/common/edits.cpp
+++ b/deps/icu-small/source/common/edits.cpp
@@ -86,6 +86,7 @@ Edits &Edits::moveArray(Edits &src) U_NOEXCEPT {
 }
 
 Edits &Edits::operator=(const Edits &other) {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     length = other.length;
     delta = other.delta;
     numChanges = other.numChanges;
diff --git a/deps/icu-small/source/common/filteredbrk.cpp b/deps/icu-small/source/common/filteredbrk.cpp
index ae7cf5270aeabf492216dc0220b75b216aea4ad1..bc9c576223d70e447c0813fac7b1b9e46f7e54ba 100644
--- a/deps/icu-small/source/common/filteredbrk.cpp
+++ b/deps/icu-small/source/common/filteredbrk.cpp
@@ -20,6 +20,7 @@
 #include "ubrkimpl.h" // U_ICUDATA_BRKITR
 #include "uvector.h"
 #include "cmemory.h"
+#include "umutex.h"
 
 U_NAMESPACE_BEGIN
 
@@ -139,13 +140,30 @@ class SimpleFilteredSentenceBreakData : public UMemory {
 public:
   SimpleFilteredSentenceBreakData(UCharsTrie *forwards, UCharsTrie *backwards )
       : fForwardsPartialTrie(forwards), fBackwardsTrie(backwards), refcount(1) { }
-  SimpleFilteredSentenceBreakData *incr() { refcount++;  return this; }
-  SimpleFilteredSentenceBreakData *decr() { if((--refcount) <= 0) delete this; return 0; }
-  virtual ~SimpleFilteredSentenceBreakData();
+    SimpleFilteredSentenceBreakData *incr() {
+        umtx_atomic_inc(&refcount);
+        return this;
+    }
+    SimpleFilteredSentenceBreakData *decr() {
+        if(umtx_atomic_dec(&refcount) <= 0) {
+            delete this;
+        }
+        return 0;
+    }
+    virtual ~SimpleFilteredSentenceBreakData();
+
+    bool hasForwardsPartialTrie() const { return fForwardsPartialTrie.isValid(); }
+    bool hasBackwardsTrie() const { return fBackwardsTrie.isValid(); }
 
-  LocalPointer<UCharsTrie>    fForwardsPartialTrie; //  Has ".a" for "a.M."
-  LocalPointer<UCharsTrie>    fBackwardsTrie; //  i.e. ".srM" for Mrs.
-  int32_t                     refcount;
+    const UCharsTrie &getForwardsPartialTrie() const { return *fForwardsPartialTrie; }
+    const UCharsTrie &getBackwardsTrie() const { return *fBackwardsTrie; }
+
+private:
+    // These tries own their data arrays.
+    // They are shared and must therefore not be modified.
+    LocalPointer<UCharsTrie>    fForwardsPartialTrie; //  Has ".a" for "a.M."
+    LocalPointer<UCharsTrie>    fBackwardsTrie; //  i.e. ".srM" for Mrs.
+    u_atomic_int32_t            refcount;
 };
 
 SimpleFilteredSentenceBreakData::~SimpleFilteredSentenceBreakData() {}
@@ -244,7 +262,13 @@ SimpleFilteredSentenceBreakIterator::SimpleFilteredSentenceBreakIterator(BreakIt
   fData(new SimpleFilteredSentenceBreakData(forwards, backwards)),
   fDelegate(adopt)
 {
-  // all set..
+    if (fData == nullptr) {
+        delete forwards;
+        delete backwards;
+        if (U_SUCCESS(status)) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+        }
+    }
 }
 
 SimpleFilteredSentenceBreakIterator::~SimpleFilteredSentenceBreakIterator() {
@@ -261,59 +285,62 @@ SimpleFilteredSentenceBreakIterator::breakExceptionAt(int32_t n) {
     int32_t bestValue = -1;
     // loops while 'n' points to an exception.
     utext_setNativeIndex(fText.getAlias(), n); // from n..
-    fData->fBackwardsTrie->reset();
-    UChar32 uch;
 
     //if(debug2) u_printf(" n@ %d\n", n);
     // Assume a space is following the '.'  (so we handle the case:  "Mr. /Brown")
-    if((uch=utext_previous32(fText.getAlias()))==(UChar32)0x0020) {  // TODO: skip a class of chars here??
+    if(utext_previous32(fText.getAlias())==u' ') {  // TODO: skip a class of chars here??
       // TODO only do this the 1st time?
       //if(debug2) u_printf("skipping prev: |%C| \n", (UChar)uch);
     } else {
       //if(debug2) u_printf("not skipping prev: |%C| \n", (UChar)uch);
-      uch = utext_next32(fText.getAlias());
+      utext_next32(fText.getAlias());
       //if(debug2) u_printf(" -> : |%C| \n", (UChar)uch);
     }
 
-    UStringTrieResult r = USTRINGTRIE_INTERMEDIATE_VALUE;
-
-    while((uch=utext_previous32(fText.getAlias()))!=U_SENTINEL  &&   // more to consume backwards and..
-          USTRINGTRIE_HAS_NEXT(r=fData->fBackwardsTrie->nextForCodePoint(uch))) {// more in the trie
-      if(USTRINGTRIE_HAS_VALUE(r)) { // remember the best match so far
-        bestPosn = utext_getNativeIndex(fText.getAlias());
-        bestValue = fData->fBackwardsTrie->getValue();
-      }
-      //if(debug2) u_printf("rev< /%C/ cont?%d @%d\n", (UChar)uch, r, utext_getNativeIndex(fText.getAlias()));
+    {
+        // Do not modify the shared trie!
+        UCharsTrie iter(fData->getBackwardsTrie());
+        UChar32 uch;
+        while((uch=utext_previous32(fText.getAlias()))!=U_SENTINEL) {  // more to consume backwards
+            UStringTrieResult r = iter.nextForCodePoint(uch);
+            if(USTRINGTRIE_HAS_VALUE(r)) { // remember the best match so far
+                bestPosn = utext_getNativeIndex(fText.getAlias());
+                bestValue = iter.getValue();
+            }
+            if(!USTRINGTRIE_HAS_NEXT(r)) {
+                break;
+            }
+            //if(debug2) u_printf("rev< /%C/ cont?%d @%d\n", (UChar)uch, r, utext_getNativeIndex(fText.getAlias()));
+        }
     }
 
-    if(USTRINGTRIE_MATCHES(r)) { // exact match?
-      //if(debug2) u_printf("rev<?/%C/?end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue);
-      bestValue = fData->fBackwardsTrie->getValue();
-      bestPosn = utext_getNativeIndex(fText.getAlias());
-      //if(debug2) u_printf("rev<+/%C/+end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue);
-    }
+    //if(bestValue >= 0) {
+        //if(debug2) u_printf("rev<+/%C/+end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue);
+    //}
 
     if(bestPosn>=0) {
       //if(debug2) u_printf("rev< /%C/ end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue);
 
       //if(USTRINGTRIE_MATCHES(r)) {  // matched - so, now what?
-      //int32_t bestValue = fBackwardsTrie->getValue();
+      //int32_t bestValue = iter.getValue();
       ////if(debug2) u_printf("rev< /%C/ matched, skip..%d  bestValue=%d\n", (UChar)uch, r, bestValue);
 
       if(bestValue == kMATCH) { // exact match!
         //if(debug2) u_printf(" exact backward match\n");
         return kExceptionHere; // See if the next is another exception.
       } else if(bestValue == kPARTIAL
-                && fData->fForwardsPartialTrie.isValid()) { // make sure there's a forward trie
+                && fData->hasForwardsPartialTrie()) { // make sure there's a forward trie
         //if(debug2) u_printf(" partial backward match\n");
         // We matched the "Ph." in "Ph.D." - now we need to run everything through the forwards trie
         // to see if it matches something going forward.
-        fData->fForwardsPartialTrie->reset();
         UStringTrieResult rfwd = USTRINGTRIE_INTERMEDIATE_VALUE;
         utext_setNativeIndex(fText.getAlias(), bestPosn); // hope that's close ..
         //if(debug2) u_printf("Retrying at %d\n", bestPosn);
+        // Do not modify the shared trie!
+        UCharsTrie iter(fData->getForwardsPartialTrie());
+        UChar32 uch;
         while((uch=utext_next32(fText.getAlias()))!=U_SENTINEL &&
-              USTRINGTRIE_HAS_NEXT(rfwd=fData->fForwardsPartialTrie->nextForCodePoint(uch))) {
+              USTRINGTRIE_HAS_NEXT(rfwd=iter.nextForCodePoint(uch))) {
           //if(debug2) u_printf("fwd> /%C/ cont?%d @%d\n", (UChar)uch, rfwd, utext_getNativeIndex(fText.getAlias()));
         }
         if(USTRINGTRIE_MATCHES(rfwd)) {
@@ -339,7 +366,7 @@ SimpleFilteredSentenceBreakIterator::breakExceptionAt(int32_t n) {
 int32_t
 SimpleFilteredSentenceBreakIterator::internalNext(int32_t n) {
   if(n == UBRK_DONE || // at end  or
-    fData->fBackwardsTrie.isNull()) { // .. no backwards table loaded == no exceptions
+    !fData->hasBackwardsTrie()) { // .. no backwards table loaded == no exceptions
       return n;
   }
   // OK, do we need to break here?
@@ -369,7 +396,7 @@ SimpleFilteredSentenceBreakIterator::internalNext(int32_t n) {
 int32_t
 SimpleFilteredSentenceBreakIterator::internalPrev(int32_t n) {
   if(n == 0 || n == UBRK_DONE || // at end  or
-    fData->fBackwardsTrie.isNull()) { // .. no backwards table loaded == no exceptions
+    !fData->hasBackwardsTrie()) { // .. no backwards table loaded == no exceptions
       return n;
   }
   // OK, do we need to break here?
@@ -420,7 +447,7 @@ SimpleFilteredSentenceBreakIterator::previous(void) {
 UBool SimpleFilteredSentenceBreakIterator::isBoundary(int32_t offset) {
   if (!fDelegate->isBoundary(offset)) return false; // no break to suppress
 
-  if (fData->fBackwardsTrie.isNull()) return true; // no data = no suppressions
+  if (!fData->hasBackwardsTrie()) return true; // no data = no suppressions
 
   UErrorCode status = U_ZERO_ERROR;
   resetState(status);
diff --git a/deps/icu-small/source/common/hash.h b/deps/icu-small/source/common/hash.h
index fa1e4ee9affc7b4c1803506a7a31a49b9571d2ff..0b0f349999ce82ce7e8c110cf348defbe72ddbdf 100644
--- a/deps/icu-small/source/common/hash.h
+++ b/deps/icu-small/source/common/hash.h
@@ -85,16 +85,22 @@ public:
 
     inline int32_t puti(const UnicodeString& key, int32_t value, UErrorCode& status);
 
+    inline int32_t putiAllowZero(const UnicodeString& key, int32_t value, UErrorCode& status);
+
     inline void* get(const UnicodeString& key) const;
 
     inline int32_t geti(const UnicodeString& key) const;
 
+    inline int32_t getiAndFound(const UnicodeString& key, UBool &found) const;
+
     inline void* remove(const UnicodeString& key);
 
     inline int32_t removei(const UnicodeString& key);
 
     inline void removeAll(void);
 
+    inline UBool containsKey(const UnicodeString& key) const;
+
     inline const UHashElement* find(const UnicodeString& key) const;
 
     /**
@@ -203,6 +209,11 @@ inline int32_t Hashtable::puti(const UnicodeString& key, int32_t value, UErrorCo
     return uhash_puti(hash, new UnicodeString(key), value, &status);
 }
 
+inline int32_t Hashtable::putiAllowZero(const UnicodeString& key, int32_t value,
+                                        UErrorCode& status) {
+    return uhash_putiAllowZero(hash, new UnicodeString(key), value, &status);
+}
+
 inline void* Hashtable::get(const UnicodeString& key) const {
     return uhash_get(hash, &key);
 }
@@ -211,6 +222,10 @@ inline int32_t Hashtable::geti(const UnicodeString& key) const {
     return uhash_geti(hash, &key);
 }
 
+inline int32_t Hashtable::getiAndFound(const UnicodeString& key, UBool &found) const {
+    return uhash_getiAndFound(hash, &key, &found);
+}
+
 inline void* Hashtable::remove(const UnicodeString& key) {
     return uhash_remove(hash, &key);
 }
@@ -219,6 +234,10 @@ inline int32_t Hashtable::removei(const UnicodeString& key) {
     return uhash_removei(hash, &key);
 }
 
+inline UBool Hashtable::containsKey(const UnicodeString& key) const {
+    return uhash_containsKey(hash, &key);
+}
+
 inline const UHashElement* Hashtable::find(const UnicodeString& key) const {
     return uhash_find(hash, &key);
 }
diff --git a/deps/icu-small/source/common/icuplug.cpp b/deps/icu-small/source/common/icuplug.cpp
index c3c8231b77d5726b916001cc7e5d4e499e6572c3..944df5465d0dd24801e44d80e77c88760e31b3a2 100644
--- a/deps/icu-small/source/common/icuplug.cpp
+++ b/deps/icu-small/source/common/icuplug.cpp
@@ -145,7 +145,7 @@ static int32_t searchForLibrary(void *lib) {
   return -1;
 }
 
-U_INTERNAL char * U_EXPORT2
+U_CAPI char * U_EXPORT2
 uplug_findLibrary(void *lib, UErrorCode *status) {
   int32_t libEnt;
   char *ret = NULL;
@@ -161,7 +161,7 @@ uplug_findLibrary(void *lib, UErrorCode *status) {
   return ret;
 }
 
-U_INTERNAL void * U_EXPORT2
+U_CAPI void * U_EXPORT2
 uplug_openLibrary(const char *libName, UErrorCode *status) {
   int32_t libEntry = -1;
   void *lib = NULL;
@@ -209,7 +209,7 @@ uplug_openLibrary(const char *libName, UErrorCode *status) {
   return lib;
 }
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uplug_closeLibrary(void *lib, UErrorCode *status) {
   int32_t i;
 
@@ -507,7 +507,7 @@ uplug_getConfiguration(UPlugData *data) {
   return data->config;
 }
 
-U_INTERNAL UPlugData* U_EXPORT2
+U_CAPI UPlugData* U_EXPORT2
 uplug_getPlugInternal(int32_t n) {
   if(n <0 || n >= pluginCount) {
     return NULL;
@@ -707,7 +707,7 @@ static void uplug_loadWaitingPlugs(UErrorCode *status) {
 static char plugin_file[2048] = "";
 #endif
 
-U_INTERNAL const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uplug_getPluginFile() {
 #if U_ENABLE_DYLOAD && !UCONFIG_NO_FILE_IO
   return plugin_file;
@@ -782,7 +782,7 @@ uplug_init(UErrorCode *status) {
     /* plugin_file is not used for processing - it is only used
        so that uplug_getPluginFile() works (i.e. icuinfo)
     */
-    uprv_strncpy(plugin_file, pluginFile.data(), sizeof(plugin_file));
+    pluginFile.extract(plugin_file, sizeof(plugin_file), *status);
 
 #if UPLUG_TRACE
     DBG((stderr, "pluginfile= %s len %d/%d\n", plugin_file, (int)strlen(plugin_file), (int)sizeof(plugin_file)));
diff --git a/deps/icu-small/source/common/icuplugimp.h b/deps/icu-small/source/common/icuplugimp.h
index 282c639b40e271e120ba5f643182f8bbd53d7117..712fdb236fde350f48e5c5f69426b2c55c1b9dfe 100644
--- a/deps/icu-small/source/common/icuplugimp.h
+++ b/deps/icu-small/source/common/icuplugimp.h
@@ -36,7 +36,7 @@
  * @return the library pointer, or NULL
  * @internal internal use only
  */
-U_INTERNAL void * U_EXPORT2
+U_CAPI void * U_EXPORT2
 uplug_openLibrary(const char *libName, UErrorCode *status);
 
 /**
@@ -45,7 +45,7 @@ uplug_openLibrary(const char *libName, UErrorCode *status);
  * @param status error code
  * @internal internal use only
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uplug_closeLibrary(void *lib, UErrorCode *status);
 
 /**
@@ -55,7 +55,7 @@ uplug_closeLibrary(void *lib, UErrorCode *status);
  * @return the library name, or NULL if not found.
  * @internal internal use only
  */
-U_INTERNAL  char * U_EXPORT2
+U_CAPI  char * U_EXPORT2
 uplug_findLibrary(void *lib, UErrorCode *status);
 
 /** @} */
@@ -69,21 +69,21 @@ uplug_findLibrary(void *lib, UErrorCode *status);
  * @param status error result
  * @internal - Internal use only.
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uplug_init(UErrorCode *status);
 
 /**
  * Get raw plug N
  * @internal - Internal use only
  */
-U_INTERNAL UPlugData* U_EXPORT2
+U_CAPI UPlugData* U_EXPORT2
 uplug_getPlugInternal(int32_t n);
 
 /**
  * Get the name of the plugin file.
  * @internal - Internal use only.
  */
-U_INTERNAL const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uplug_getPluginFile(void);
 
 /** @} */
diff --git a/deps/icu-small/source/common/localematcher.cpp b/deps/icu-small/source/common/localematcher.cpp
index 85db8c8bf3246df0b832efd00649e528eab636ef..132aee290e81a8f058854ff01e8bdde9e8e61872 100644
--- a/deps/icu-small/source/common/localematcher.cpp
+++ b/deps/icu-small/source/common/localematcher.cpp
@@ -1,12 +1,9 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // localematcher.cpp
 // created: 2019may08 Markus W. Scherer
 
-#ifndef __LOCMATCHER_H__
-#define __LOCMATCHER_H__
-
 #include "unicode/utypes.h"
 #include "unicode/localebuilder.h"
 #include "unicode/localematcher.h"
@@ -131,6 +128,7 @@ LocaleMatcher::Builder::Builder(LocaleMatcher::Builder &&src) U_NOEXCEPT :
         thresholdDistance_(src.thresholdDistance_),
         demotion_(src.demotion_),
         defaultLocale_(src.defaultLocale_),
+        withDefault_(src.withDefault_),
         favor_(src.favor_),
         direction_(src.direction_) {
     src.supportedLocales_ = nullptr;
@@ -140,6 +138,8 @@ LocaleMatcher::Builder::Builder(LocaleMatcher::Builder &&src) U_NOEXCEPT :
 LocaleMatcher::Builder::~Builder() {
     delete supportedLocales_;
     delete defaultLocale_;
+    delete maxDistanceDesired_;
+    delete maxDistanceSupported_;
 }
 
 LocaleMatcher::Builder &LocaleMatcher::Builder::operator=(LocaleMatcher::Builder &&src) U_NOEXCEPT {
@@ -150,6 +150,7 @@ LocaleMatcher::Builder &LocaleMatcher::Builder::operator=(LocaleMatcher::Builder
     thresholdDistance_ = src.thresholdDistance_;
     demotion_ = src.demotion_;
     defaultLocale_ = src.defaultLocale_;
+    withDefault_ = src.withDefault_,
     favor_ = src.favor_;
     direction_ = src.direction_;
 
@@ -229,6 +230,14 @@ LocaleMatcher::Builder &LocaleMatcher::Builder::addSupportedLocale(const Locale
     return *this;
 }
 
+LocaleMatcher::Builder &LocaleMatcher::Builder::setNoDefaultLocale() {
+    if (U_FAILURE(errorCode_)) { return *this; }
+    delete defaultLocale_;
+    defaultLocale_ = nullptr;
+    withDefault_ = false;
+    return *this;
+}
+
 LocaleMatcher::Builder &LocaleMatcher::Builder::setDefaultLocale(const Locale *defaultLocale) {
     if (U_FAILURE(errorCode_)) { return *this; }
     Locale *clone = nullptr;
@@ -241,6 +250,7 @@ LocaleMatcher::Builder &LocaleMatcher::Builder::setDefaultLocale(const Locale *d
     }
     delete defaultLocale_;
     defaultLocale_ = clone;
+    withDefault_ = true;
     return *this;
 }
 
@@ -256,6 +266,24 @@ LocaleMatcher::Builder &LocaleMatcher::Builder::setDemotionPerDesiredLocale(ULoc
     return *this;
 }
 
+LocaleMatcher::Builder &LocaleMatcher::Builder::setMaxDistance(const Locale &desired,
+                                                               const Locale &supported) {
+    if (U_FAILURE(errorCode_)) { return *this; }
+    Locale *desiredClone = desired.clone();
+    Locale *supportedClone = supported.clone();
+    if (desiredClone == nullptr || supportedClone == nullptr) {
+        delete desiredClone;  // in case only one could not be allocated
+        delete supportedClone;
+        errorCode_ = U_MEMORY_ALLOCATION_ERROR;
+        return *this;
+    }
+    delete maxDistanceDesired_;
+    delete maxDistanceSupported_;
+    maxDistanceDesired_ = desiredClone;
+    maxDistanceSupported_ = supportedClone;
+    return *this;
+}
+
 #if 0
 /**
  * <i>Internal only!</i>
@@ -317,9 +345,8 @@ UBool compareLSRs(const UHashTok t1, const UHashTok t2) {
 int32_t LocaleMatcher::putIfAbsent(const LSR &lsr, int32_t i, int32_t suppLength,
                                    UErrorCode &errorCode) {
     if (U_FAILURE(errorCode)) { return suppLength; }
-    int32_t index = uhash_geti(supportedLsrToIndex, &lsr);
-    if (index == 0) {
-        uhash_puti(supportedLsrToIndex, const_cast<LSR *>(&lsr), i + 1, &errorCode);
+    if (!uhash_containsKey(supportedLsrToIndex, &lsr)) {
+        uhash_putiAllowZero(supportedLsrToIndex, const_cast<LSR *>(&lsr), i, &errorCode);
         if (U_SUCCESS(errorCode)) {
             supportedLSRs[suppLength] = &lsr;
             supportedIndexes[suppLength++] = i;
@@ -340,9 +367,6 @@ LocaleMatcher::LocaleMatcher(const Builder &builder, UErrorCode &errorCode) :
         supportedLSRs(nullptr), supportedIndexes(nullptr), supportedLSRsLength(0),
         ownedDefaultLocale(nullptr), defaultLocale(nullptr) {
     if (U_FAILURE(errorCode)) { return; }
-    if (thresholdDistance < 0) {
-        thresholdDistance = localeDistance.getDefaultScriptDistance();
-    }
     const Locale *def = builder.defaultLocale_;
     LSR builderDefaultLSR;
     const LSR *defLSR = nullptr;
@@ -408,22 +432,20 @@ LocaleMatcher::LocaleMatcher(const Builder &builder, UErrorCode &errorCode) :
         int32_t suppLength = 0;
         // Determine insertion order.
         // Add locales immediately that are equivalent to the default.
-        MaybeStackArray<int8_t, 100> order(supportedLocalesLength);
-        if (order.getAlias() == nullptr) {
-            errorCode = U_MEMORY_ALLOCATION_ERROR;
-            return;
-        }
+        MaybeStackArray<int8_t, 100> order(supportedLocalesLength, errorCode);
+        if (U_FAILURE(errorCode)) { return; }
         int32_t numParadigms = 0;
         for (int32_t i = 0; i < supportedLocalesLength; ++i) {
             const Locale &locale = *supportedLocales[i];
             const LSR &lsr = lsrs[i];
-            if (defLSR == nullptr) {
+            if (defLSR == nullptr && builder.withDefault_) {
+                // Implicit default locale = first supported locale, if not turned off.
                 U_ASSERT(i == 0);
                 def = &locale;
                 defLSR = &lsr;
                 order[i] = 1;
                 suppLength = putIfAbsent(lsr, 0, suppLength, errorCode);
-            } else if (lsr.isEquivalentTo(*defLSR)) {
+            } else if (defLSR != nullptr && lsr.isEquivalentTo(*defLSR)) {
                 order[i] = 1;
                 suppLength = putIfAbsent(lsr, i, suppLength, errorCode);
             } else if (localeDistance.isParadigmLSR(lsr)) {
@@ -458,6 +480,25 @@ LocaleMatcher::LocaleMatcher(const Builder &builder, UErrorCode &errorCode) :
     if (builder.demotion_ == ULOCMATCH_DEMOTION_REGION) {
         demotionPerDesiredLocale = localeDistance.getDefaultDemotionPerDesiredLocale();
     }
+
+    if (thresholdDistance >= 0) {
+        // already copied
+    } else if (builder.maxDistanceDesired_ != nullptr) {
+        LSR suppLSR = getMaximalLsrOrUnd(likelySubtags, *builder.maxDistanceSupported_, errorCode);
+        const LSR *pSuppLSR = &suppLSR;
+        int32_t indexAndDistance = localeDistance.getBestIndexAndDistance(
+                getMaximalLsrOrUnd(likelySubtags, *builder.maxDistanceDesired_, errorCode),
+                &pSuppLSR, 1,
+                LocaleDistance::shiftDistance(100), favorSubtag, direction);
+        if (U_SUCCESS(errorCode)) {
+            // +1 for an exclusive threshold from an inclusive max.
+            thresholdDistance = LocaleDistance::getDistanceFloor(indexAndDistance) + 1;
+        } else {
+            thresholdDistance = 0;
+        }
+    } else {
+        thresholdDistance = localeDistance.getDefaultScriptDistance();
+    }
 }
 
 LocaleMatcher::LocaleMatcher(LocaleMatcher &&src) U_NOEXCEPT :
@@ -643,12 +684,11 @@ int32_t LocaleMatcher::getBestSuppIndex(LSR desiredLSR, LocaleLsrIterator *remai
     int32_t bestSupportedLsrIndex = -1;
     for (int32_t bestShiftedDistance = LocaleDistance::shiftDistance(thresholdDistance);;) {
         // Quick check for exact maximized LSR.
-        // Returns suppIndex+1 where 0 means not found.
         if (supportedLsrToIndex != nullptr) {
             desiredLSR.setHashCode();
-            int32_t index = uhash_geti(supportedLsrToIndex, &desiredLSR);
-            if (index != 0) {
-                int32_t suppIndex = index - 1;
+            UBool found = false;
+            int32_t suppIndex = uhash_getiAndFound(supportedLsrToIndex, &desiredLSR, &found);
+            if (found) {
                 if (remainingIter != nullptr) {
                     remainingIter->rememberCurrent(desiredIndex, errorCode);
                 }
@@ -683,6 +723,18 @@ int32_t LocaleMatcher::getBestSuppIndex(LSR desiredLSR, LocaleLsrIterator *remai
     return supportedIndexes[bestSupportedLsrIndex];
 }
 
+UBool LocaleMatcher::isMatch(const Locale &desired, const Locale &supported,
+                             UErrorCode &errorCode) const {
+    LSR suppLSR = getMaximalLsrOrUnd(likelySubtags, supported, errorCode);
+    if (U_FAILURE(errorCode)) { return 0; }
+    const LSR *pSuppLSR = &suppLSR;
+    int32_t indexAndDistance = localeDistance.getBestIndexAndDistance(
+            getMaximalLsrOrUnd(likelySubtags, desired, errorCode),
+            &pSuppLSR, 1,
+            LocaleDistance::shiftDistance(thresholdDistance), favorSubtag, direction);
+    return indexAndDistance >= 0;
+}
+
 double LocaleMatcher::internalMatch(const Locale &desired, const Locale &supported, UErrorCode &errorCode) const {
     // Returns the inverse of the distance: That is, 1-distance(desired, supported).
     LSR suppLSR = getMaximalLsrOrUnd(likelySubtags, supported, errorCode);
@@ -790,5 +842,3 @@ uloc_acceptLanguageFromHTTP(char *result, int32_t resultAvailable,
     return acceptLanguage(*availableLocales, desiredLocales,
                           result, resultAvailable, outResult, *status);
 }
-
-#endif  // __LOCMATCHER_H__
diff --git a/deps/icu-small/source/common/localeprioritylist.cpp b/deps/icu-small/source/common/localeprioritylist.cpp
index cee408269c9b3934b97f950b4bc9097ac0788f8e..4455eedb75e67c0b1ea6d2aa45bd5b73d5ecdae9 100644
--- a/deps/icu-small/source/common/localeprioritylist.cpp
+++ b/deps/icu-small/source/common/localeprioritylist.cpp
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // localeprioritylist.cpp
 // created: 2019jul11 Markus W. Scherer
@@ -187,17 +187,18 @@ bool LocalePriorityList::add(const Locale &locale, int32_t weight, UErrorCode &e
         if (U_FAILURE(errorCode)) { return false; }
     }
     LocalPointer<Locale> clone;
-    int32_t index = uhash_geti(map, &locale);
-    if (index != 0) {
+    UBool found = false;
+    int32_t index = uhash_getiAndFound(map, &locale, &found);
+    if (found) {
         // Duplicate: Remove the old item and append it anew.
-        LocaleAndWeight &lw = list->array[index - 1];
+        LocaleAndWeight &lw = list->array[index];
         clone.adoptInstead(lw.locale);
         lw.locale = nullptr;
         lw.weight = 0;
         ++numRemoved;
     }
     if (weight <= 0) {  // do not add q=0
-        if (index != 0) {
+        if (found) {
             // Not strictly necessary but cleaner.
             uhash_removei(map, &locale);
         }
@@ -217,7 +218,7 @@ bool LocalePriorityList::add(const Locale &locale, int32_t weight, UErrorCode &e
             return false;
         }
     }
-    uhash_puti(map, clone.getAlias(), listLength + 1, &errorCode);
+    uhash_putiAllowZero(map, clone.getAlias(), listLength, &errorCode);
     if (U_FAILURE(errorCode)) { return false; }
     LocaleAndWeight &lw = list->array[listLength];
     lw.locale = clone.orphan();
diff --git a/deps/icu-small/source/common/localeprioritylist.h b/deps/icu-small/source/common/localeprioritylist.h
index 80ca38a7b528926c4e1c9ce872d05fd8cc4eeed2..41e9d3ea081f5615f72de3d23e5123ce80a04990 100644
--- a/deps/icu-small/source/common/localeprioritylist.h
+++ b/deps/icu-small/source/common/localeprioritylist.h
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // localeprioritylist.h
 // created: 2019jul11 Markus W. Scherer
diff --git a/deps/icu-small/source/common/locdispnames.cpp b/deps/icu-small/source/common/locdispnames.cpp
index 7216a3a3083e3d9902e5a7c820afaa853b2120d5..3166c76bf5a7fd44e13e6022b36cb2a90c231a9a 100644
--- a/deps/icu-small/source/common/locdispnames.cpp
+++ b/deps/icu-small/source/common/locdispnames.cpp
@@ -26,6 +26,8 @@
 #include "unicode/uloc.h"
 #include "unicode/ures.h"
 #include "unicode/ustring.h"
+#include "bytesinkutil.h"
+#include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "putilimp.h"
@@ -406,20 +408,26 @@ uloc_getDisplayScript(const char* locale,
                       UChar *dest, int32_t destCapacity,
                       UErrorCode *pErrorCode)
 {
-	UErrorCode err = U_ZERO_ERROR;
-	int32_t res = _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
+    UErrorCode err = U_ZERO_ERROR;
+    int32_t res = _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
                 uloc_getScript, _kScriptsStandAlone, &err);
 
-	if ( err == U_USING_DEFAULT_WARNING ) {
+    if (destCapacity == 0 && err == U_BUFFER_OVERFLOW_ERROR) {
+        // For preflight, return the max of the value and the fallback.
+        int32_t fallback_res = _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
+                                                           uloc_getScript, _kScripts, pErrorCode);
+        return (fallback_res > res) ? fallback_res : res;
+    }
+    if ( err == U_USING_DEFAULT_WARNING ) {
         return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
-                    uloc_getScript, _kScripts, pErrorCode);
-	} else {
-		*pErrorCode = err;
-		return res;
-	}
+                                           uloc_getScript, _kScripts, pErrorCode);
+    } else {
+        *pErrorCode = err;
+        return res;
+    }
 }
 
-U_INTERNAL int32_t U_EXPORT2
+static int32_t
 uloc_getDisplayScriptInContext(const char* locale,
                       const char* displayLocale,
                       UChar *dest, int32_t destCapacity,
@@ -690,7 +698,7 @@ uloc_getDisplayName(const char *locale,
                     } /* end switch */
 
                     if (len>0) {
-                        /* we addeed a component, so add separator and write it if there's room. */
+                        /* we added a component, so add separator and write it if there's room. */
                         if(len+sepLen<=cap) {
                             const UChar * plimit = p + len;
                             for (; p < plimit; p++) {
@@ -727,7 +735,7 @@ uloc_getDisplayName(const char *locale,
                     int32_t padLen;
                     patPos+=subLen;
                     padLen=(subi==0 ? sub1Pos : patLen)-patPos;
-                    if(length+padLen < destCapacity) {
+                    if(length+padLen <= destCapacity) {
                         p=dest+length;
                         for(int32_t i=0;i<padLen;++i) {
                             *p++=pattern[patPos++];
@@ -805,10 +813,6 @@ uloc_getDisplayKeywordValue(   const char* locale,
                                UErrorCode* status){
 
 
-    char keywordValue[ULOC_FULLNAME_CAPACITY*4];
-    int32_t capacity = ULOC_FULLNAME_CAPACITY*4;
-    int32_t keywordValueLen =0;
-
     /* argument checking */
     if(status==NULL || U_FAILURE(*status)) {
         return 0;
@@ -820,10 +824,11 @@ uloc_getDisplayKeywordValue(   const char* locale,
     }
 
     /* get the keyword value */
-    keywordValue[0]=0;
-    keywordValueLen = uloc_getKeywordValue(locale, keyword, keywordValue, capacity, status);
-    if (*status == U_STRING_NOT_TERMINATED_WARNING)
-      *status = U_BUFFER_OVERFLOW_ERROR;
+    CharString keywordValue;
+    {
+        CharStringByteSink sink(&keywordValue);
+        ulocimp_getKeywordValue(locale, keyword, sink, status);
+    }
 
     /*
      * if the keyword is equal to currency .. then to get the display name
@@ -839,7 +844,7 @@ uloc_getDisplayKeywordValue(   const char* locale,
         icu::LocalUResourceBundlePointer currencies(
                 ures_getByKey(bundle.getAlias(), _kCurrencies, NULL, status));
         icu::LocalUResourceBundlePointer currency(
-                ures_getByKeyWithFallback(currencies.getAlias(), keywordValue, NULL, status));
+                ures_getByKeyWithFallback(currencies.getAlias(), keywordValue.data(), NULL, status));
 
         dispName = ures_getStringByIndex(currency.getAlias(), UCURRENCY_DISPLAY_NAME_INDEX, &dispNameLen, status);
 
@@ -863,12 +868,12 @@ uloc_getDisplayKeywordValue(   const char* locale,
             }
         }else{
             /* we have not found the display name for the value .. just copy over */
-            if(keywordValueLen <= destCapacity){
-                u_charsToUChars(keywordValue, dest, keywordValueLen);
-                return u_terminateUChars(dest, destCapacity, keywordValueLen, status);
+            if(keywordValue.length() <= destCapacity){
+                u_charsToUChars(keywordValue.data(), dest, keywordValue.length());
+                return u_terminateUChars(dest, destCapacity, keywordValue.length(), status);
             }else{
                  *status = U_BUFFER_OVERFLOW_ERROR;
-                return keywordValueLen;
+                return keywordValue.length();
             }
         }
 
@@ -877,8 +882,8 @@ uloc_getDisplayKeywordValue(   const char* locale,
 
         return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale,
                                    _kTypes, keyword,
-                                   keywordValue,
-                                   keywordValue,
+                                   keywordValue.data(),
+                                   keywordValue.data(),
                                    dest, destCapacity,
                                    status);
     }
diff --git a/deps/icu-small/source/common/locdistance.cpp b/deps/icu-small/source/common/locdistance.cpp
index 18e4d91bce921ba31b6ea5481a094bd656851133..ff8892791b2d988ea50606df891b8277e4586b61 100644
--- a/deps/icu-small/source/common/locdistance.cpp
+++ b/deps/icu-small/source/common/locdistance.cpp
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // locdistance.cpp
 // created: 2019may08 Markus W. Scherer
diff --git a/deps/icu-small/source/common/locdistance.h b/deps/icu-small/source/common/locdistance.h
index ad8415138333dc7e9aa0446eac3c4440f39d73ef..51b777e6272312ff75f99595bb7ebbbace8c7c5b 100644
--- a/deps/icu-small/source/common/locdistance.h
+++ b/deps/icu-small/source/common/locdistance.h
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // locdistance.h
 // created: 2019may08 Markus W. Scherer
@@ -39,6 +39,10 @@ public:
         return shiftedDistance / (1 << DISTANCE_SHIFT);
     }
 
+    static int32_t getDistanceFloor(int32_t indexAndDistance) {
+        return (indexAndDistance & DISTANCE_MASK) >> DISTANCE_SHIFT;
+    }
+
     static int32_t getIndex(int32_t indexAndDistance) {
         // assert indexAndDistance >= 0;
         return indexAndDistance >> INDEX_SHIFT;
@@ -79,10 +83,6 @@ private:
     // tic constexpr int32_t MAX_INDEX = 0x1fffff;  // avoids sign bit
     static constexpr int32_t INDEX_NEG_1 = 0xfffffc00;
 
-    static int32_t getDistanceFloor(int32_t indexAndDistance) {
-        return (indexAndDistance & DISTANCE_MASK) >> DISTANCE_SHIFT;
-    }
-
     LocaleDistance(const LocaleDistanceData &data, const XLikelySubtags &likely);
     LocaleDistance(const LocaleDistance &other) = delete;
     LocaleDistance &operator=(const LocaleDistance &other) = delete;
diff --git a/deps/icu-small/source/common/locid.cpp b/deps/icu-small/source/common/locid.cpp
index 753a452120ee6246e00214e59acd930ee2819807..0d506293a99eca2f6e84679f3ed684090ab67687 100644
--- a/deps/icu-small/source/common/locid.cpp
+++ b/deps/icu-small/source/common/locid.cpp
@@ -35,6 +35,7 @@
 
 #include "unicode/bytestream.h"
 #include "unicode/locid.h"
+#include "unicode/localebuilder.h"
 #include "unicode/strenum.h"
 #include "unicode/stringpiece.h"
 #include "unicode/uloc.h"
@@ -42,6 +43,7 @@
 
 #include "bytesinkutil.h"
 #include "charstr.h"
+#include "charstrmap.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "mutex.h"
@@ -51,7 +53,9 @@
 #include "uhash.h"
 #include "ulocimp.h"
 #include "umutex.h"
+#include "uniquecharstr.h"
 #include "ustr_imp.h"
+#include "uvector.h"
 
 U_CDECL_BEGIN
 static UBool U_CALLCONV locale_cleanup(void);
@@ -102,12 +106,6 @@ typedef enum ELocalePos {
     eMAX_LOCALES
 } ELocalePos;
 
-U_CFUNC int32_t locale_getKeywords(const char *localeID,
-            char prev,
-            char *keywords, int32_t keywordCapacity,
-            UBool valuesToo,
-            UErrorCode *status);
-
 U_CDECL_BEGIN
 //
 // Deleter function for Locales owned by the default Locale hash table/
@@ -252,10 +250,11 @@ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale)
 // '_'
 // In the platform codepage.
 #define SEP_CHAR '_'
+#define NULL_CHAR '\0'
 
 Locale::~Locale()
 {
-    if (baseName != fullName) {
+    if ((baseName != fullName) && (baseName != fullNameBuffer)) {
         uprv_free(baseName);
     }
     baseName = NULL;
@@ -467,7 +466,7 @@ Locale& Locale::operator=(const Locale& other) {
 }
 
 Locale& Locale::operator=(Locale&& other) U_NOEXCEPT {
-    if (baseName != fullName) uprv_free(baseName);
+    if ((baseName != fullName) && (baseName != fullNameBuffer)) uprv_free(baseName);
     if (fullName != fullNameBuffer) uprv_free(fullName);
 
     if (other.fullName == other.fullNameBuffer) {
@@ -506,44 +505,1355 @@ Locale::operator==( const   Locale& other) const
     return (uprv_strcmp(other.fullName, fullName) == 0);
 }
 
-#define ISASCIIALPHA(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
-
 namespace {
 
-CharString& AppendLSCVE(CharString& out, const char* language, const char* script,
-                 const char* country, const char* variants, const char* extension,
-                 UErrorCode& status) {
+UInitOnce gKnownCanonicalizedInitOnce = U_INITONCE_INITIALIZER;
+UHashtable *gKnownCanonicalized = nullptr;
+
+static const char* const KNOWN_CANONICALIZED[] = {
+    "c",
+    // Commonly used locales known are already canonicalized
+    "af", "af_ZA", "am", "am_ET", "ar", "ar_001", "as", "as_IN", "az", "az_AZ",
+    "be", "be_BY", "bg", "bg_BG", "bn", "bn_IN", "bs", "bs_BA", "ca", "ca_ES",
+    "cs", "cs_CZ", "cy", "cy_GB", "da", "da_DK", "de", "de_DE", "el", "el_GR",
+    "en", "en_GB", "en_US", "es", "es_419", "es_ES", "et", "et_EE", "eu",
+    "eu_ES", "fa", "fa_IR", "fi", "fi_FI", "fil", "fil_PH", "fr", "fr_FR",
+    "ga", "ga_IE", "gl", "gl_ES", "gu", "gu_IN", "he", "he_IL", "hi", "hi_IN",
+    "hr", "hr_HR", "hu", "hu_HU", "hy", "hy_AM", "id", "id_ID", "is", "is_IS",
+    "it", "it_IT", "ja", "ja_JP", "jv", "jv_ID", "ka", "ka_GE", "kk", "kk_KZ",
+    "km", "km_KH", "kn", "kn_IN", "ko", "ko_KR", "ky", "ky_KG", "lo", "lo_LA",
+    "lt", "lt_LT", "lv", "lv_LV", "mk", "mk_MK", "ml", "ml_IN", "mn", "mn_MN",
+    "mr", "mr_IN", "ms", "ms_MY", "my", "my_MM", "nb", "nb_NO", "ne", "ne_NP",
+    "nl", "nl_NL", "no", "or", "or_IN", "pa", "pa_IN", "pl", "pl_PL", "ps", "ps_AF",
+    "pt", "pt_BR", "pt_PT", "ro", "ro_RO", "ru", "ru_RU", "sd", "sd_IN", "si",
+    "si_LK", "sk", "sk_SK", "sl", "sl_SI", "so", "so_SO", "sq", "sq_AL", "sr",
+    "sr_Cyrl_RS", "sr_Latn", "sr_RS", "sv", "sv_SE", "sw", "sw_TZ", "ta",
+    "ta_IN", "te", "te_IN", "th", "th_TH", "tk", "tk_TM", "tr", "tr_TR", "uk",
+    "uk_UA", "ur", "ur_PK", "uz", "uz_UZ", "vi", "vi_VN", "yue", "yue_Hant",
+    "yue_Hant_HK", "yue_HK", "zh", "zh_CN", "zh_Hans", "zh_Hans_CN", "zh_Hant",
+    "zh_Hant_TW", "zh_TW", "zu", "zu_ZA"
+};
+
+static UBool U_CALLCONV cleanupKnownCanonicalized() {
+    gKnownCanonicalizedInitOnce.reset();
+    if (gKnownCanonicalized) { uhash_close(gKnownCanonicalized); }
+    return TRUE;
+}
+
+static void U_CALLCONV loadKnownCanonicalized(UErrorCode &status) {
+    ucln_common_registerCleanup(UCLN_COMMON_LOCALE_KNOWN_CANONICALIZED,
+                                cleanupKnownCanonicalized);
+    LocalUHashtablePointer newKnownCanonicalizedMap(
+        uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &status));
+    for (int32_t i = 0;
+            U_SUCCESS(status) && i < UPRV_LENGTHOF(KNOWN_CANONICALIZED);
+            i++) {
+        uhash_puti(newKnownCanonicalizedMap.getAlias(),
+                   (void*)KNOWN_CANONICALIZED[i],
+                   1, &status);
+    }
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    gKnownCanonicalized = newKnownCanonicalizedMap.orphan();
+}
+
+class AliasData;
+
+/**
+ * A Builder class to build the alias data.
+ */
+class AliasDataBuilder {
+public:
+    AliasDataBuilder() {
+    }
+
+    // Build the AliasData from resource.
+    AliasData* build(UErrorCode &status);
+
+private:
+    void readAlias(UResourceBundle* alias,
+                   UniqueCharStrings* strings,
+                   LocalMemory<const char*>& types,
+                   LocalMemory<int32_t>& replacementIndexes,
+                   int32_t &length,
+                   void (*checkType)(const char* type),
+                   void (*checkReplacement)(const UnicodeString& replacement),
+                   UErrorCode &status);
+
+    // Read the languageAlias data from alias to
+    // strings+types+replacementIndexes
+    // The number of record will be stored into length.
+    // Allocate length items for types, to store the type field.
+    // Allocate length items for replacementIndexes,
+    // to store the index in the strings for the replacement script.
+    void readLanguageAlias(UResourceBundle* alias,
+                           UniqueCharStrings* strings,
+                           LocalMemory<const char*>& types,
+                           LocalMemory<int32_t>& replacementIndexes,
+                           int32_t &length,
+                           UErrorCode &status);
+
+    // Read the scriptAlias data from alias to
+    // strings+types+replacementIndexes
+    // Allocate length items for types, to store the type field.
+    // Allocate length items for replacementIndexes,
+    // to store the index in the strings for the replacement script.
+    void readScriptAlias(UResourceBundle* alias,
+                         UniqueCharStrings* strings,
+                         LocalMemory<const char*>& types,
+                         LocalMemory<int32_t>& replacementIndexes,
+                         int32_t &length, UErrorCode &status);
+
+    // Read the territoryAlias data from alias to
+    // strings+types+replacementIndexes
+    // Allocate length items for types, to store the type field.
+    // Allocate length items for replacementIndexes,
+    // to store the index in the strings for the replacement script.
+    void readTerritoryAlias(UResourceBundle* alias,
+                            UniqueCharStrings* strings,
+                            LocalMemory<const char*>& types,
+                            LocalMemory<int32_t>& replacementIndexes,
+                            int32_t &length, UErrorCode &status);
+
+    // Read the variantAlias data from alias to
+    // strings+types+replacementIndexes
+    // Allocate length items for types, to store the type field.
+    // Allocate length items for replacementIndexes,
+    // to store the index in the strings for the replacement variant.
+    void readVariantAlias(UResourceBundle* alias,
+                          UniqueCharStrings* strings,
+                          LocalMemory<const char*>& types,
+                          LocalMemory<int32_t>& replacementIndexes,
+                          int32_t &length, UErrorCode &status);
+
+    // Read the subdivisionAlias data from alias to
+    // strings+types+replacementIndexes
+    // Allocate length items for types, to store the type field.
+    // Allocate length items for replacementIndexes,
+    // to store the index in the strings for the replacement variant.
+    void readSubdivisionAlias(UResourceBundle* alias,
+                          UniqueCharStrings* strings,
+                          LocalMemory<const char*>& types,
+                          LocalMemory<int32_t>& replacementIndexes,
+                          int32_t &length, UErrorCode &status);
+};
+
+/**
+ * A class to hold the Alias Data.
+ */
+class AliasData : public UMemory {
+public:
+    static const AliasData* singleton(UErrorCode& status) {
+        if (U_FAILURE(status)) {
+            // Do not get into loadData if the status already has error.
+            return nullptr;
+        }
+        umtx_initOnce(AliasData::gInitOnce, &AliasData::loadData, status);
+        return gSingleton;
+    }
+
+    const CharStringMap& languageMap() const { return language; }
+    const CharStringMap& scriptMap() const { return script; }
+    const CharStringMap& territoryMap() const { return territory; }
+    const CharStringMap& variantMap() const { return variant; }
+    const CharStringMap& subdivisionMap() const { return subdivision; }
+
+    static void U_CALLCONV loadData(UErrorCode &status);
+    static UBool U_CALLCONV cleanup();
+
+    static UInitOnce gInitOnce;
+
+private:
+    AliasData(CharStringMap languageMap,
+              CharStringMap scriptMap,
+              CharStringMap territoryMap,
+              CharStringMap variantMap,
+              CharStringMap subdivisionMap,
+              CharString* strings)
+        : language(std::move(languageMap)),
+          script(std::move(scriptMap)),
+          territory(std::move(territoryMap)),
+          variant(std::move(variantMap)),
+          subdivision(std::move(subdivisionMap)),
+          strings(strings) {
+    }
+
+    ~AliasData() {
+        delete strings;
+    }
+
+    static const AliasData* gSingleton;
+
+    CharStringMap language;
+    CharStringMap script;
+    CharStringMap territory;
+    CharStringMap variant;
+    CharStringMap subdivision;
+    CharString* strings;
+
+    friend class AliasDataBuilder;
+};
+
+
+const AliasData* AliasData::gSingleton = nullptr;
+UInitOnce AliasData::gInitOnce = U_INITONCE_INITIALIZER;
+
+UBool U_CALLCONV
+AliasData::cleanup()
+{
+    gInitOnce.reset();
+    delete gSingleton;
+    return TRUE;
+}
+
+void
+AliasDataBuilder::readAlias(
+        UResourceBundle* alias,
+        UniqueCharStrings* strings,
+        LocalMemory<const char*>& types,
+        LocalMemory<int32_t>& replacementIndexes,
+        int32_t &length,
+        void (*checkType)(const char* type),
+        void (*checkReplacement)(const UnicodeString& replacement),
+        UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    length = ures_getSize(alias);
+    const char** rawTypes = types.allocateInsteadAndCopy(length);
+    if (rawTypes == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    int32_t* rawIndexes = replacementIndexes.allocateInsteadAndCopy(length);
+    if (rawIndexes == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    int i = 0;
+    while (ures_hasNext(alias)) {
+        LocalUResourceBundlePointer res(
+            ures_getNextResource(alias, nullptr, &status));
+        const char* aliasFrom = ures_getKey(res.getAlias());
+        UnicodeString aliasTo =
+            ures_getUnicodeStringByKey(res.getAlias(), "replacement", &status);
+
+        checkType(aliasFrom);
+        checkReplacement(aliasTo);
+
+        rawTypes[i] = aliasFrom;
+        rawIndexes[i] = strings->add(aliasTo, status);
+        i++;
+    }
+}
+
+/**
+ * Read the languageAlias data from alias to strings+types+replacementIndexes.
+ * Allocate length items for types, to store the type field. Allocate length
+ * items for replacementIndexes, to store the index in the strings for the
+ * replacement language.
+ */
+void
+AliasDataBuilder::readLanguageAlias(
+        UResourceBundle* alias,
+        UniqueCharStrings* strings,
+        LocalMemory<const char*>& types,
+        LocalMemory<int32_t>& replacementIndexes,
+        int32_t &length,
+        UErrorCode &status)
+{
+    return readAlias(
+        alias, strings, types, replacementIndexes, length,
+#if U_DEBUG
+        [](const char* type) {
+            // Assert the aliasFrom only contains the following possibilties
+            // language_REGION_variant
+            // language_REGION
+            // language_variant
+            // language
+            // und_variant
+            Locale test(type);
+            // Assert no script in aliasFrom
+            U_ASSERT(test.getScript()[0] == '\0');
+            // Assert when language is und, no REGION in aliasFrom.
+            U_ASSERT(test.getLanguage()[0] != '\0' || test.getCountry()[0] == '\0');
+        },
+#else
+        [](const char*) {},
+#endif
+        [](const UnicodeString&) {}, status);
+}
+
+/**
+ * Read the scriptAlias data from alias to strings+types+replacementIndexes.
+ * Allocate length items for types, to store the type field. Allocate length
+ * items for replacementIndexes, to store the index in the strings for the
+ * replacement script.
+ */
+void
+AliasDataBuilder::readScriptAlias(
+        UResourceBundle* alias,
+        UniqueCharStrings* strings,
+        LocalMemory<const char*>& types,
+        LocalMemory<int32_t>& replacementIndexes,
+        int32_t &length,
+        UErrorCode &status)
+{
+    return readAlias(
+        alias, strings, types, replacementIndexes, length,
+#if U_DEBUG
+        [](const char* type) {
+            U_ASSERT(uprv_strlen(type) == 4);
+        },
+        [](const UnicodeString& replacement) {
+            U_ASSERT(replacement.length() == 4);
+        },
+#else
+        [](const char*) {},
+        [](const UnicodeString&) { },
+#endif
+        status);
+}
+
+/**
+ * Read the territoryAlias data from alias to strings+types+replacementIndexes.
+ * Allocate length items for types, to store the type field. Allocate length
+ * items for replacementIndexes, to store the index in the strings for the
+ * replacement regions.
+ */
+void
+AliasDataBuilder::readTerritoryAlias(
+        UResourceBundle* alias,
+        UniqueCharStrings* strings,
+        LocalMemory<const char*>& types,
+        LocalMemory<int32_t>& replacementIndexes,
+        int32_t &length,
+        UErrorCode &status)
+{
+    return readAlias(
+        alias, strings, types, replacementIndexes, length,
+#if U_DEBUG
+        [](const char* type) {
+            U_ASSERT(uprv_strlen(type) == 2 || uprv_strlen(type) == 3);
+        },
+#else
+        [](const char*) {},
+#endif
+        [](const UnicodeString&) { },
+        status);
+}
+
+/**
+ * Read the variantAlias data from alias to strings+types+replacementIndexes.
+ * Allocate length items for types, to store the type field. Allocate length
+ * items for replacementIndexes, to store the index in the strings for the
+ * replacement variant.
+ */
+void
+AliasDataBuilder::readVariantAlias(
+        UResourceBundle* alias,
+        UniqueCharStrings* strings,
+        LocalMemory<const char*>& types,
+        LocalMemory<int32_t>& replacementIndexes,
+        int32_t &length,
+        UErrorCode &status)
+{
+    return readAlias(
+        alias, strings, types, replacementIndexes, length,
+#if U_DEBUG
+        [](const char* type) {
+            U_ASSERT(uprv_strlen(type) >= 4 && uprv_strlen(type) <= 8);
+            U_ASSERT(uprv_strlen(type) != 4 ||
+                     (type[0] >= '0' && type[0] <= '9'));
+        },
+        [](const UnicodeString& replacement) {
+            U_ASSERT(replacement.length() >= 4 && replacement.length() <= 8);
+            U_ASSERT(replacement.length() != 4 ||
+                     (replacement.charAt(0) >= u'0' &&
+                      replacement.charAt(0) <= u'9'));
+        },
+#else
+        [](const char*) {},
+        [](const UnicodeString&) { },
+#endif
+        status);
+}
+
+/**
+ * Read the subdivisionAlias data from alias to strings+types+replacementIndexes.
+ * Allocate length items for types, to store the type field. Allocate length
+ * items for replacementIndexes, to store the index in the strings for the
+ * replacement regions.
+ */
+void
+AliasDataBuilder::readSubdivisionAlias(
+        UResourceBundle* alias,
+        UniqueCharStrings* strings,
+        LocalMemory<const char*>& types,
+        LocalMemory<int32_t>& replacementIndexes,
+        int32_t &length,
+        UErrorCode &status)
+{
+    return readAlias(
+        alias, strings, types, replacementIndexes, length,
+#if U_DEBUG
+        [](const char* type) {
+            U_ASSERT(uprv_strlen(type) >= 3 && uprv_strlen(type) <= 8);
+        },
+#else
+        [](const char*) {},
+#endif
+        [](const UnicodeString&) { },
+        status);
+}
+
+/**
+ * Initializes the alias data from the ICU resource bundles. The alias data
+ * contains alias of language, country, script and variants.
+ *
+ * If the alias data has already loaded, then this method simply returns without
+ * doing anything meaningful.
+ */
+void U_CALLCONV
+AliasData::loadData(UErrorCode &status)
+{
+#ifdef LOCALE_CANONICALIZATION_DEBUG
+    UDate start = uprv_getRawUTCtime();
+#endif  // LOCALE_CANONICALIZATION_DEBUG
+    ucln_common_registerCleanup(UCLN_COMMON_LOCALE_ALIAS, cleanup);
+    AliasDataBuilder builder;
+    gSingleton = builder.build(status);
+#ifdef LOCALE_CANONICALIZATION_DEBUG
+    UDate end = uprv_getRawUTCtime();
+    printf("AliasData::loadData took total %f ms\n", end - start);
+#endif  // LOCALE_CANONICALIZATION_DEBUG
+}
+
+/**
+ * Build the alias data from resources.
+ */
+AliasData*
+AliasDataBuilder::build(UErrorCode &status) {
+    LocalUResourceBundlePointer metadata(
+        ures_openDirect(nullptr, "metadata", &status));
+    LocalUResourceBundlePointer metadataAlias(
+        ures_getByKey(metadata.getAlias(), "alias", nullptr, &status));
+    LocalUResourceBundlePointer languageAlias(
+        ures_getByKey(metadataAlias.getAlias(), "language", nullptr, &status));
+    LocalUResourceBundlePointer scriptAlias(
+        ures_getByKey(metadataAlias.getAlias(), "script", nullptr, &status));
+    LocalUResourceBundlePointer territoryAlias(
+        ures_getByKey(metadataAlias.getAlias(), "territory", nullptr, &status));
+    LocalUResourceBundlePointer variantAlias(
+        ures_getByKey(metadataAlias.getAlias(), "variant", nullptr, &status));
+    LocalUResourceBundlePointer subdivisionAlias(
+        ures_getByKey(metadataAlias.getAlias(), "subdivision", nullptr, &status));
+
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+    int32_t languagesLength = 0, scriptLength = 0, territoryLength = 0,
+            variantLength = 0, subdivisionLength = 0;
+
+    // Read the languageAlias into languageTypes, languageReplacementIndexes
+    // and strings
+    UniqueCharStrings strings(status);
+    LocalMemory<const char*> languageTypes;
+    LocalMemory<int32_t> languageReplacementIndexes;
+    readLanguageAlias(languageAlias.getAlias(),
+                      &strings,
+                      languageTypes,
+                      languageReplacementIndexes,
+                      languagesLength,
+                      status);
+
+    // Read the scriptAlias into scriptTypes, scriptReplacementIndexes
+    // and strings
+    LocalMemory<const char*> scriptTypes;
+    LocalMemory<int32_t> scriptReplacementIndexes;
+    readScriptAlias(scriptAlias.getAlias(),
+                    &strings,
+                    scriptTypes,
+                    scriptReplacementIndexes,
+                    scriptLength,
+                    status);
+
+    // Read the territoryAlias into territoryTypes, territoryReplacementIndexes
+    // and strings
+    LocalMemory<const char*> territoryTypes;
+    LocalMemory<int32_t> territoryReplacementIndexes;
+    readTerritoryAlias(territoryAlias.getAlias(),
+                       &strings,
+                       territoryTypes,
+                       territoryReplacementIndexes,
+                       territoryLength, status);
+
+    // Read the variantAlias into variantTypes, variantReplacementIndexes
+    // and strings
+    LocalMemory<const char*> variantTypes;
+    LocalMemory<int32_t> variantReplacementIndexes;
+    readVariantAlias(variantAlias.getAlias(),
+                     &strings,
+                     variantTypes,
+                     variantReplacementIndexes,
+                     variantLength, status);
+
+    // Read the subdivisionAlias into subdivisionTypes, subdivisionReplacementIndexes
+    // and strings
+    LocalMemory<const char*> subdivisionTypes;
+    LocalMemory<int32_t> subdivisionReplacementIndexes;
+    readSubdivisionAlias(subdivisionAlias.getAlias(),
+                         &strings,
+                         subdivisionTypes,
+                         subdivisionReplacementIndexes,
+                         subdivisionLength, status);
+
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+
+    // We can only use strings after freeze it.
+    strings.freeze();
+
+    // Build the languageMap from languageTypes & languageReplacementIndexes
+    CharStringMap languageMap(490, status);
+    for (int32_t i = 0; U_SUCCESS(status) && i < languagesLength; i++) {
+        languageMap.put(languageTypes[i],
+                        strings.get(languageReplacementIndexes[i]),
+                        status);
+    }
+
+    // Build the scriptMap from scriptTypes & scriptReplacementIndexes
+    CharStringMap scriptMap(1, status);
+    for (int32_t i = 0; U_SUCCESS(status) && i < scriptLength; i++) {
+        scriptMap.put(scriptTypes[i],
+                      strings.get(scriptReplacementIndexes[i]),
+                      status);
+    }
+
+    // Build the territoryMap from territoryTypes & territoryReplacementIndexes
+    CharStringMap territoryMap(650, status);
+    for (int32_t i = 0; U_SUCCESS(status) && i < territoryLength; i++) {
+        territoryMap.put(territoryTypes[i],
+                         strings.get(territoryReplacementIndexes[i]),
+                         status);
+    }
+
+    // Build the variantMap from variantTypes & variantReplacementIndexes.
+    CharStringMap variantMap(2, status);
+    for (int32_t i = 0; U_SUCCESS(status) && i < variantLength; i++) {
+        variantMap.put(variantTypes[i],
+                       strings.get(variantReplacementIndexes[i]),
+                       status);
+    }
+
+    // Build the subdivisionMap from subdivisionTypes & subdivisionReplacementIndexes.
+    CharStringMap subdivisionMap(2, status);
+    for (int32_t i = 0; U_SUCCESS(status) && i < subdivisionLength; i++) {
+        subdivisionMap.put(subdivisionTypes[i],
+                       strings.get(subdivisionReplacementIndexes[i]),
+                       status);
+    }
+
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+
+    // copy hashtables
+    auto *data = new AliasData(
+        std::move(languageMap),
+        std::move(scriptMap),
+        std::move(territoryMap),
+        std::move(variantMap),
+        std::move(subdivisionMap),
+        strings.orphanCharStrings());
+
+    if (data == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+    }
+    return data;
+}
+
+/**
+ * A class that find the replacement values of locale fields by using AliasData.
+ */
+class AliasReplacer {
+public:
+    AliasReplacer(UErrorCode status) :
+            language(nullptr), script(nullptr), region(nullptr),
+            extensions(nullptr), variants(status),
+            data(nullptr) {
+    }
+    ~AliasReplacer() {
+    }
+
+    // Check the fields inside locale, if need to replace fields,
+    // place the the replaced locale ID in out and return true.
+    // Otherwise return false for no replacement or error.
+    bool replace(
+        const Locale& locale, CharString& out, UErrorCode& status);
+
+private:
+    const char* language;
+    const char* script;
+    const char* region;
+    const char* extensions;
+    UVector variants;
+
+    const AliasData* data;
+
+    inline bool notEmpty(const char* str) {
+        return str && str[0] != NULL_CHAR;
+    }
+
+    /**
+     * If replacement is neither null nor empty and input is either null or empty,
+     * return replacement.
+     * If replacement is neither null nor empty but input is not empty, return input.
+     * If replacement is either null or empty and type is either null or empty,
+     * return input.
+     * Otherwise return null.
+     *   replacement     input      type        return
+     *    AAA             nullptr    *           AAA
+     *    AAA             BBB        *           BBB
+     *    nullptr || ""   CCC        nullptr     CCC
+     *    nullptr || ""   *          DDD         nullptr
+     */
+    inline const char* deleteOrReplace(
+            const char* input, const char* type, const char* replacement) {
+        return notEmpty(replacement) ?
+            ((input == nullptr) ?  replacement : input) :
+            ((type == nullptr) ? input  : nullptr);
+    }
+
+    inline bool same(const char* a, const char* b) {
+        if (a == nullptr && b == nullptr) {
+            return true;
+        }
+        if ((a == nullptr && b != nullptr) ||
+            (a != nullptr && b == nullptr)) {
+          return false;
+        }
+        return uprv_strcmp(a, b) == 0;
+    }
+
+    // Gather fields and generate locale ID into out.
+    CharString& outputToString(CharString& out, UErrorCode status);
+
+    // Generate the lookup key.
+    CharString& generateKey(const char* language, const char* region,
+                            const char* variant, CharString& out,
+                            UErrorCode status);
+
+    void parseLanguageReplacement(const char* replacement,
+                                  const char*& replaceLanguage,
+                                  const char*& replaceScript,
+                                  const char*& replaceRegion,
+                                  const char*& replaceVariant,
+                                  const char*& replaceExtensions,
+                                  UVector& toBeFreed,
+                                  UErrorCode& status);
+
+    // Replace by using languageAlias.
+    bool replaceLanguage(bool checkLanguage, bool checkRegion,
+                         bool checkVariants, UVector& toBeFreed,
+                         UErrorCode& status);
+
+    // Replace by using territoryAlias.
+    bool replaceTerritory(UVector& toBeFreed, UErrorCode& status);
+
+    // Replace by using scriptAlias.
+    bool replaceScript(UErrorCode& status);
+
+    // Replace by using variantAlias.
+    bool replaceVariant(UErrorCode& status);
+
+    // Replace by using subdivisionAlias.
+    bool replaceSubdivision(StringPiece subdivision,
+                            CharString& output, UErrorCode& status);
+
+    // Replace transformed extensions.
+    bool replaceTransformedExtensions(
+        CharString& transformedExtensions, CharString& output, UErrorCode& status);
+};
+
+CharString&
+AliasReplacer::generateKey(
+        const char* language, const char* region, const char* variant,
+        CharString& out, UErrorCode status)
+{
     out.append(language, status);
-    if (script && script[0] != '\0') {
-        out.append('_', status);
-        out.append(script, status);
+    if (notEmpty(region)) {
+        out.append(SEP_CHAR, status)
+            .append(region, status);
+    }
+    if (notEmpty(variant)) {
+       out.append(SEP_CHAR, status)
+           .append(variant, status);
+    }
+    return out;
+}
+
+void
+AliasReplacer::parseLanguageReplacement(
+    const char* replacement,
+    const char*& replacedLanguage,
+    const char*& replacedScript,
+    const char*& replacedRegion,
+    const char*& replacedVariant,
+    const char*& replacedExtensions,
+    UVector& toBeFreed,
+    UErrorCode& status)
+{
+    if (U_FAILURE(status)) {
+        return;
+    }
+    replacedScript = replacedRegion = replacedVariant
+        = replacedExtensions = nullptr;
+    if (uprv_strchr(replacement, '_') == nullptr) {
+        replacedLanguage = replacement;
+        // reach the end, just return it.
+        return;
     }
-    if (country && country[0] != '\0') {
-        out.append('_', status);
-        out.append(country, status);
+    // We have multiple field so we have to allocate and parse
+    CharString* str = new CharString(
+        replacement, (int32_t)uprv_strlen(replacement), status);
+    if (U_FAILURE(status)) {
+        return;
     }
-    if (variants && variants[0] != '\0') {
-        if ((script == nullptr || script[0] == '\0') &&
-            (country == nullptr || country[0] == '\0')) {
-          out.append('_', status);
+    if (str == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    toBeFreed.addElement(str, status);
+    char* data = str->data();
+    replacedLanguage = (const char*) data;
+    char* endOfField = uprv_strchr(data, '_');
+    *endOfField = '\0'; // null terminiate it.
+    endOfField++;
+    const char* start = endOfField;
+    endOfField = (char*) uprv_strchr(start, '_');
+    size_t len = 0;
+    if (endOfField == nullptr) {
+        len = uprv_strlen(start);
+    } else {
+        len = endOfField - start;
+        *endOfField = '\0'; // null terminiate it.
+    }
+    if (len == 4 && uprv_isASCIILetter(*start)) {
+        // Got a script
+        replacedScript = start;
+        if (endOfField == nullptr) {
+            return;
+        }
+        start = endOfField++;
+        endOfField = (char*)uprv_strchr(start, '_');
+        if (endOfField == nullptr) {
+            len = uprv_strlen(start);
+        } else {
+            len = endOfField - start;
+            *endOfField = '\0'; // null terminiate it.
+        }
+    }
+    if (len >= 2 && len <= 3) {
+        // Got a region
+        replacedRegion = start;
+        if (endOfField == nullptr) {
+            return;
+        }
+        start = endOfField++;
+        endOfField = (char*)uprv_strchr(start, '_');
+        if (endOfField == nullptr) {
+            len = uprv_strlen(start);
+        } else {
+            len = endOfField - start;
+            *endOfField = '\0'; // null terminiate it.
+        }
+    }
+    if (len >= 4) {
+        // Got a variant
+        replacedVariant = start;
+        if (endOfField == nullptr) {
+            return;
+        }
+        start = endOfField++;
+    }
+    replacedExtensions = start;
+}
+
+bool
+AliasReplacer::replaceLanguage(
+        bool checkLanguage, bool checkRegion,
+        bool checkVariants, UVector& toBeFreed, UErrorCode& status)
+{
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    if (    (checkRegion && region == nullptr) ||
+            (checkVariants && variants.size() == 0)) {
+        // Nothing to search.
+        return false;
+    }
+    int32_t variant_size = checkVariants ? variants.size() : 1;
+    // Since we may have more than one variant, we need to loop through them.
+    const char* searchLanguage = checkLanguage ? language : "und";
+    const char* searchRegion = checkRegion ? region : nullptr;
+    const char* searchVariant = nullptr;
+    for (int32_t variant_index = 0;
+            variant_index < variant_size;
+            variant_index++) {
+        if (checkVariants) {
+            U_ASSERT(variant_index < variant_size);
+            searchVariant = (const char*)(variants.elementAt(variant_index));
+        }
+
+        if (searchVariant != nullptr && uprv_strlen(searchVariant) < 4) {
+            // Do not consider  ill-formed variant subtag.
+            searchVariant = nullptr;
+        }
+        CharString typeKey;
+        generateKey(searchLanguage, searchRegion, searchVariant, typeKey,
+                    status);
+        if (U_FAILURE(status)) {
+            return false;
+        }
+        const char *replacement = data->languageMap().get(typeKey.data());
+        if (replacement == nullptr) {
+            // Found no replacement data.
+            continue;
+        }
+
+        const char* replacedLanguage = nullptr;
+        const char* replacedScript = nullptr;
+        const char* replacedRegion = nullptr;
+        const char* replacedVariant = nullptr;
+        const char* replacedExtensions = nullptr;
+        parseLanguageReplacement(replacement,
+                                 replacedLanguage,
+                                 replacedScript,
+                                 replacedRegion,
+                                 replacedVariant,
+                                 replacedExtensions,
+                                 toBeFreed,
+                                 status);
+        replacedLanguage =
+            (replacedLanguage != nullptr && uprv_strcmp(replacedLanguage, "und") == 0) ?
+            language : replacedLanguage;
+        replacedScript = deleteOrReplace(script, nullptr, replacedScript);
+        replacedRegion = deleteOrReplace(region, searchRegion, replacedRegion);
+        replacedVariant = deleteOrReplace(
+            searchVariant, searchVariant, replacedVariant);
+
+        if (    same(language, replacedLanguage) &&
+                same(script, replacedScript) &&
+                same(region, replacedRegion) &&
+                same(searchVariant, replacedVariant) &&
+                replacedExtensions == nullptr) {
+            // Replacement produce no changes.
+            continue;
+        }
+
+        language = replacedLanguage;
+        region = replacedRegion;
+        script = replacedScript;
+        if (searchVariant != nullptr) {
+            if (notEmpty(replacedVariant)) {
+                variants.setElementAt((void*)replacedVariant, variant_index);
+            } else {
+                variants.removeElementAt(variant_index);
+            }
+        }
+        if (replacedExtensions != nullptr) {
+            // DO NOTHING
+            // UTS35 does not specifiy what should we do if we have extensions in the
+            // replacement. Currently we know only the following 4 "BCP47 LegacyRules" have
+            // extensions in them languageAlias:
+            //  i_default => en_x_i_default
+            //  i_enochian => und_x_i_enochian
+            //  i_mingo => see_x_i_mingo
+            //  zh_min => nan_x_zh_min
+            // But all of them are already changed by code inside ultag_parse() before
+            // hitting this code.
+        }
+
+        // Something changed by language alias data.
+        return true;
+    }
+    // Nothing changed by language alias data.
+    return false;
+}
+
+bool
+AliasReplacer::replaceTerritory(UVector& toBeFreed, UErrorCode& status)
+{
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    if (region == nullptr) {
+        // No region to search.
+        return false;
+    }
+    const char *replacement = data->territoryMap().get(region);
+    if (replacement == nullptr) {
+        // Found no replacement data for this region.
+        return false;
+    }
+    const char* replacedRegion = replacement;
+    const char* firstSpace = uprv_strchr(replacement, ' ');
+    if (firstSpace != nullptr) {
+        // If there are are more than one region in the replacement.
+        // We need to check which one match based on the language.
+        // Cannot use nullptr for language because that will construct
+        // the default locale, in that case, use "und" to get the correct
+        // locale.
+        Locale l = LocaleBuilder()
+            .setLanguage(language == nullptr ? "und" : language)
+            .setScript(script)
+            .build(status);
+        l.addLikelySubtags(status);
+        const char* likelyRegion = l.getCountry();
+        LocalPointer<CharString> item;
+        if (likelyRegion != nullptr && uprv_strlen(likelyRegion) > 0) {
+            size_t len = uprv_strlen(likelyRegion);
+            const char* foundInReplacement = uprv_strstr(replacement,
+                                                         likelyRegion);
+            if (foundInReplacement != nullptr) {
+                // Assuming the case there are no three letter region code in
+                // the replacement of territoryAlias
+                U_ASSERT(foundInReplacement == replacement ||
+                         *(foundInReplacement-1) == ' ');
+                U_ASSERT(foundInReplacement[len] == ' ' ||
+                         foundInReplacement[len] == '\0');
+                item.adoptInsteadAndCheckErrorCode(
+                    new CharString(foundInReplacement, (int32_t)len, status), status);
+            }
+        }
+        if (item.isNull() && U_SUCCESS(status)) {
+            item.adoptInsteadAndCheckErrorCode(
+                new CharString(replacement,
+                               (int32_t)(firstSpace - replacement), status), status);
+        }
+        if (U_FAILURE(status)) { return false; }
+        if (item.isNull()) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return false;
+        }
+        replacedRegion = item->data();
+        toBeFreed.addElement(item.orphan(), status);
+    }
+    U_ASSERT(!same(region, replacedRegion));
+    region = replacedRegion;
+    // The region is changed by data in territory alias.
+    return true;
+}
+
+bool
+AliasReplacer::replaceScript(UErrorCode& status)
+{
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    if (script == nullptr) {
+        // No script to search.
+        return false;
+    }
+    const char *replacement = data->scriptMap().get(script);
+    if (replacement == nullptr) {
+        // Found no replacement data for this script.
+        return false;
+    }
+    U_ASSERT(!same(script, replacement));
+    script = replacement;
+    // The script is changed by data in script alias.
+    return true;
+}
+
+bool
+AliasReplacer::replaceVariant(UErrorCode& status)
+{
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    // Since we may have more than one variant, we need to loop through them.
+    for (int32_t i = 0; i < variants.size(); i++) {
+        const char *variant = (const char*)(variants.elementAt(i));
+        const char *replacement = data->variantMap().get(variant);
+        if (replacement == nullptr) {
+            // Found no replacement data for this variant.
+            continue;
+        }
+        U_ASSERT((uprv_strlen(replacement) >= 5  &&
+                  uprv_strlen(replacement) <= 8) ||
+                 (uprv_strlen(replacement) == 4 &&
+                  replacement[0] >= '0' &&
+                  replacement[0] <= '9'));
+        if (!same(variant, replacement)) {
+            variants.setElementAt((void*)replacement, i);
+            // Special hack to handle hepburn-heploc => alalc97
+            if (uprv_strcmp(variant, "heploc") == 0) {
+                for (int32_t j = 0; j < variants.size(); j++) {
+                     if (uprv_strcmp((const char*)(variants.elementAt(j)),
+                                     "hepburn") == 0) {
+                         variants.removeElementAt(j);
+                     }
+                }
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+bool
+AliasReplacer::replaceSubdivision(
+    StringPiece subdivision, CharString& output, UErrorCode& status)
+{
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    const char *replacement = data->subdivisionMap().get(subdivision.data());
+    if (replacement != nullptr) {
+        const char* firstSpace = uprv_strchr(replacement, ' ');
+        // Found replacement data for this subdivision.
+        size_t len = (firstSpace != nullptr) ?
+            (firstSpace - replacement) : uprv_strlen(replacement);
+        if (2 <= len && len <= 8) {
+            output.append(replacement, (int32_t)len, status);
+            if (2 == len) {
+                // Add 'zzzz' based on changes to UTS #35 for CLDR-14312.
+                output.append("zzzz", 4, status);
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+bool
+AliasReplacer::replaceTransformedExtensions(
+    CharString& transformedExtensions, CharString& output, UErrorCode& status)
+{
+    // The content of the transformedExtensions will be modified in this
+    // function to NULL-terminating (tkey-tvalue) pairs.
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    int32_t len = transformedExtensions.length();
+    const char* str = transformedExtensions.data();
+    const char* tkey = ultag_getTKeyStart(str);
+    int32_t tlangLen = (tkey == str) ? 0 :
+        ((tkey == nullptr) ? len : static_cast<int32_t>((tkey - str - 1)));
+    CharStringByteSink sink(&output);
+    if (tlangLen > 0) {
+        Locale tlang = LocaleBuilder()
+            .setLanguageTag(StringPiece(str, tlangLen))
+            .build(status);
+        tlang.canonicalize(status);
+        tlang.toLanguageTag(sink, status);
+        if (U_FAILURE(status)) {
+            return false;
+        }
+        T_CString_toLowerCase(output.data());
+    }
+    if (tkey != nullptr) {
+        // We need to sort the tfields by tkey
+        UVector tfields(status);
+        if (U_FAILURE(status)) {
+            return false;
+        }
+        do {
+            const char* tvalue = uprv_strchr(tkey, '-');
+            if (tvalue == nullptr) {
+                status = U_ILLEGAL_ARGUMENT_ERROR;
+            }
+            const char* nextTKey = ultag_getTKeyStart(tvalue);
+            if (nextTKey != nullptr) {
+                *((char*)(nextTKey-1)) = '\0';  // NULL terminate tvalue
+            }
+            tfields.insertElementAt((void*)tkey, tfields.size(), status);
+            if (U_FAILURE(status)) {
+                return false;
+            }
+            tkey = nextTKey;
+        } while (tkey != nullptr);
+        tfields.sort([](UElement e1, UElement e2) -> int8_t {
+            // uprv_strcmp return int and in some platform, such as arm64-v8a,
+            // it may return positive values > 127 which cause the casted value
+            // of int8_t negative.
+            int res = uprv_strcmp(
+                (const char*)e1.pointer, (const char*)e2.pointer);
+            return (res == 0) ? 0 : ((res > 0) ? 1 : -1);
+        }, status);
+        for (int32_t i = 0; i < tfields.size(); i++) {
+             if (output.length() > 0) {
+                 output.append('-', status);
+             }
+             const char* tfield = (const char*) tfields.elementAt(i);
+             const char* tvalue = uprv_strchr(tfield, '-');
+             // Split the "tkey-tvalue" pair string so that we can canonicalize the tvalue.
+             U_ASSERT(tvalue != nullptr);
+             *((char*)tvalue++) = '\0'; // NULL terminate tkey
+             output.append(tfield, status).append('-', status);
+             const char* bcpTValue = ulocimp_toBcpType(tfield, tvalue, nullptr, nullptr);
+             output.append((bcpTValue == nullptr) ? tvalue : bcpTValue, status);
+        }
+    }
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    return true;
+}
+
+CharString&
+AliasReplacer::outputToString(
+    CharString& out, UErrorCode status)
+{
+    out.append(language, status);
+    if (notEmpty(script)) {
+        out.append(SEP_CHAR, status)
+            .append(script, status);
+    }
+    if (notEmpty(region)) {
+        out.append(SEP_CHAR, status)
+            .append(region, status);
+    }
+    if (variants.size() > 0) {
+        if (!notEmpty(script) && !notEmpty(region)) {
+          out.append(SEP_CHAR, status);
         }
-        out.append('_', status);
-        out.append(variants, status);
+        variants.sort([](UElement e1, UElement e2) -> int8_t {
+            // uprv_strcmp return int and in some platform, such as arm64-v8a,
+            // it may return positive values > 127 which cause the casted value
+            // of int8_t negative.
+            int res = uprv_strcmp(
+                (const char*)e1.pointer, (const char*)e2.pointer);
+            return (res == 0) ? 0 : ((res > 0) ? 1 : -1);
+        }, status);
+        int32_t variantsStart = out.length();
+        for (int32_t i = 0; i < variants.size(); i++) {
+             out.append(SEP_CHAR, status)
+                 .append((const char*)(variants.elementAt(i)),
+                         status);
+        }
+        T_CString_toUpperCase(out.data() + variantsStart);
     }
-    if (extension && extension[0] != '\0') {
-        out.append(extension, status);
+    if (notEmpty(extensions)) {
+        CharString tmp("und_", status);
+        tmp.append(extensions, status);
+        Locale tmpLocale(tmp.data());
+        // only support x extension inside CLDR for now.
+        U_ASSERT(extensions[0] == 'x');
+        out.append(tmpLocale.getName() + 1, status);
     }
     return out;
 }
 
+bool
+AliasReplacer::replace(const Locale& locale, CharString& out, UErrorCode& status)
+{
+    data = AliasData::singleton(status);
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    U_ASSERT(data != nullptr);
+    out.clear();
+    language = locale.getLanguage();
+    if (!notEmpty(language)) {
+        language = nullptr;
+    }
+    script = locale.getScript();
+    if (!notEmpty(script)) {
+        script = nullptr;
+    }
+    region = locale.getCountry();
+    if (!notEmpty(region)) {
+        region = nullptr;
+    }
+    const char* variantsStr = locale.getVariant();
+    CharString variantsBuff(variantsStr, -1, status);
+    if (!variantsBuff.isEmpty()) {
+        if (U_FAILURE(status)) { return false; }
+        char* start = variantsBuff.data();
+        T_CString_toLowerCase(start);
+        char* end;
+        while ((end = uprv_strchr(start, SEP_CHAR)) != nullptr &&
+               U_SUCCESS(status)) {
+            *end = NULL_CHAR;  // null terminate inside variantsBuff
+            variants.addElement(start, status);
+            start = end + 1;
+        }
+        variants.addElement(start, status);
+    }
+    if (U_FAILURE(status)) { return false; }
+
+    // Sort the variants
+    variants.sort([](UElement e1, UElement e2) -> int8_t {
+        // uprv_strcmp return int and in some platform, such as arm64-v8a,
+        // it may return positive values > 127 which cause the casted value
+        // of int8_t negative.
+        int res = uprv_strcmp(
+            (const char*)e1.pointer, (const char*)e2.pointer);
+        return (res == 0) ? 0 : ((res > 0) ? 1 : -1);
+    }, status);
+
+    // A changed count to assert when loop too many times.
+    int changed = 0;
+    // A UVector to to hold CharString allocated by the replace* method
+    // and freed when out of scope from his function.
+    UVector stringsToBeFreed([](void *obj){ delete ((CharString*) obj); },
+                             nullptr, 10, status);
+    while (U_SUCCESS(status)) {
+        // Something wrong with the data cause looping here more than 10 times
+        // already.
+        U_ASSERT(changed < 5);
+        // From observation of key in data/misc/metadata.txt
+        // we know currently we only need to search in the following combination
+        // of fields for type in languageAlias:
+        // * lang_region_variant
+        // * lang_region
+        // * lang_variant
+        // * lang
+        // * und_variant
+        // This assumption is ensured by the U_ASSERT in readLanguageAlias
+        //
+        //                      lang  REGION variant
+        if (    replaceLanguage(true, true,  true,  stringsToBeFreed, status) ||
+                replaceLanguage(true, true,  false, stringsToBeFreed, status) ||
+                replaceLanguage(true, false, true,  stringsToBeFreed, status) ||
+                replaceLanguage(true, false, false, stringsToBeFreed, status) ||
+                replaceLanguage(false,false, true,  stringsToBeFreed, status) ||
+                replaceTerritory(stringsToBeFreed, status) ||
+                replaceScript(status) ||
+                replaceVariant(status)) {
+            // Some values in data is changed, try to match from the beginning
+            // again.
+            changed++;
+            continue;
+        }
+        // Nothing changed. Break out.
+        break;
+    }  // while(1)
+
+    if (U_FAILURE(status)) { return false; }
+    // Nothing changed and we know the order of the vaiants are not change
+    // because we have no variant or only one.
+    const char* extensionsStr = locale_getKeywordsStart(locale.getName());
+    if (changed == 0 && variants.size() <= 1 && extensionsStr == nullptr) {
+        return false;
+    }
+    outputToString(out, status);
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    if (extensionsStr != nullptr) {
+        changed = 0;
+        Locale temp(locale);
+        LocalPointer<icu::StringEnumeration> iter(locale.createKeywords(status));
+        if (U_SUCCESS(status) && !iter.isNull()) {
+            const char* key;
+            while ((key = iter->next(nullptr, status)) != nullptr) {
+                if (uprv_strcmp("sd", key) == 0 || uprv_strcmp("rg", key) == 0 ||
+                        uprv_strcmp("t", key) == 0) {
+                    CharString value;
+                    CharStringByteSink valueSink(&value);
+                    locale.getKeywordValue(key, valueSink, status);
+                    if (U_FAILURE(status)) {
+                        status = U_ZERO_ERROR;
+                        continue;
+                    }
+                    CharString replacement;
+                    if (uprv_strlen(key) == 2) {
+                        if (replaceSubdivision(value.toStringPiece(), replacement, status)) {
+                            changed++;
+                            temp.setKeywordValue(key, replacement.data(), status);
+                        }
+                    } else {
+                        U_ASSERT(uprv_strcmp(key, "t") == 0);
+                        if (replaceTransformedExtensions(value, replacement, status)) {
+                            changed++;
+                            temp.setKeywordValue(key, replacement.data(), status);
+                        }
+                    }
+                    if (U_FAILURE(status)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        if (changed != 0) {
+            extensionsStr = locale_getKeywordsStart(temp.getName());
+        }
+        out.append(extensionsStr, status);
+    }
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    // If the tag is not changed, return.
+    if (uprv_strcmp(out.data(), locale.getName()) == 0) {
+        out.clear();
+        return false;
+    }
+    return true;
+}
+
+// Return true if the locale is changed during canonicalization.
+// The replaced value then will be put into out.
+bool
+canonicalizeLocale(const Locale& locale, CharString& out, UErrorCode& status)
+{
+    AliasReplacer replacer(status);
+    return replacer.replace(locale, out, status);
+}
+
+// Function to optimize for known cases without so we can skip the loading
+// of resources in the startup time until we really need it.
+bool
+isKnownCanonicalizedLocale(const char* locale, UErrorCode& status)
+{
+    if (    uprv_strcmp(locale, "c") == 0 ||
+            uprv_strcmp(locale, "en") == 0 ||
+            uprv_strcmp(locale, "en_US") == 0) {
+        return true;
+    }
+
+    // common well-known Canonicalized.
+    umtx_initOnce(gKnownCanonicalizedInitOnce,
+                  &loadKnownCanonicalized, status);
+    if (U_FAILURE(status)) {
+        return false;
+    }
+    U_ASSERT(gKnownCanonicalized != nullptr);
+    return uhash_geti(gKnownCanonicalized, locale) != 0;
+}
+
 }  // namespace
 
+// Function for testing.
+U_CAPI const char* const*
+ulocimp_getKnownCanonicalizedLocaleForTest(int32_t* length)
+{
+    *length = UPRV_LENGTHOF(KNOWN_CANONICALIZED);
+    return KNOWN_CANONICALIZED;
+}
+
+// Function for testing.
+U_CAPI bool
+ulocimp_isCanonicalizedLocaleForTest(const char* localeName)
+{
+    Locale l(localeName);
+    UErrorCode status = U_ZERO_ERROR;
+    CharString temp;
+    return !canonicalizeLocale(l, temp, status) && U_SUCCESS(status);
+}
+
 /*This function initializes a Locale from a C locale ID*/
 Locale& Locale::init(const char* localeID, UBool canonicalize)
 {
     fIsBogus = FALSE;
     /* Free our current storage */
-    if (baseName != fullName) {
+    if ((baseName != fullName) && (baseName != fullNameBuffer)) {
         uprv_free(baseName);
     }
     baseName = NULL;
@@ -579,6 +1889,7 @@ Locale& Locale::init(const char* localeID, UBool canonicalize)
             uloc_getName(localeID, fullName, sizeof(fullNameBuffer), &err);
 
         if(err == U_BUFFER_OVERFLOW_ERROR || length >= (int32_t)sizeof(fullNameBuffer)) {
+            U_ASSERT(baseName == nullptr);
             /*Go to heap for the fullName if necessary*/
             fullName = (char *)uprv_malloc(sizeof(char)*(length + 1));
             if(fullName == 0) {
@@ -632,9 +1943,9 @@ Locale& Locale::init(const char* localeID, UBool canonicalize)
             uprv_memcpy(language, fullName, fieldLen[0]);
             language[fieldLen[0]] = 0;
         }
-        if (fieldLen[1] == 4 && ISASCIIALPHA(field[1][0]) &&
-                ISASCIIALPHA(field[1][1]) && ISASCIIALPHA(field[1][2]) &&
-                ISASCIIALPHA(field[1][3])) {
+        if (fieldLen[1] == 4 && uprv_isASCIILetter(field[1][0]) &&
+                uprv_isASCIILetter(field[1][1]) && uprv_isASCIILetter(field[1][2]) &&
+                uprv_isASCIILetter(field[1][3])) {
             /* We have at least a script */
             uprv_memcpy(script, field[1], fieldLen[1]);
             script[fieldLen[1]] = 0;
@@ -662,192 +1973,18 @@ Locale& Locale::init(const char* localeID, UBool canonicalize)
         }
 
         if (canonicalize) {
-            UErrorCode status = U_ZERO_ERROR;
-            // TODO: Try to use ResourceDataValue and ures_getValueWithFallback() etc.
-            LocalUResourceBundlePointer metadata(ures_openDirect(NULL, "metadata", &status));
-            LocalUResourceBundlePointer metadataAlias(ures_getByKey(metadata.getAlias(), "alias", NULL, &status));
-            // Look up the metadata:alias:language:$key:replacement entries
-            // key could be one of the following:
-            //   language
-            //   language_Script_REGION
-            //   language_REGION
-            //   language_variant
-            do {
-                // The resource structure looks like
-                // metadata {
-                //   alias {
-                //     language {
-                //       art_lojban {
-                //         replacement{"jbo"}
-                //       }
-                //       ...
-                //       ks_Arab_IN {
-                //         replacement{"ks_IN"}
-                //       }
-                //       ...
-                //       no {
-                //         replacement{"nb"}
-                //       }
-                //       ....
-                //       zh_CN {
-                //         replacement{"zh_Hans_CN"}
-                //       }
-                //     }
-                //     ...
-                //   }
-                // }
-                LocalUResourceBundlePointer languageAlias(ures_getByKey(metadataAlias.getAlias(), "language", NULL, &status));
-                if (U_FAILURE(status))
+            if (!isKnownCanonicalizedLocale(fullName, err)) {
+                CharString replaced;
+                // Not sure it is already canonicalized
+                if (canonicalizeLocale(*this, replaced, err)) {
+                    U_ASSERT(U_SUCCESS(err));
+                    // If need replacement, call init again.
+                    init(replaced.data(), false);
+                }
+                if (U_FAILURE(err)) {
                     break;
-                CharString temp;
-                // Handle cases of key pattern "language _ variant"
-                // ex: Map "art_lojban" to "jbo"
-                const char* variants = getVariant();
-                if (variants != nullptr && variants[0] != '\0') {
-                    const char* begin = variants;
-                    const char* end = begin;
-                    // We may have multiple variants, need to look at each of
-                    // them.
-                    do {
-                        status = U_ZERO_ERROR;
-                        end = uprv_strchr(begin, '_');
-                        int32_t len = (end == nullptr) ? int32_t(uprv_strlen(begin)) : int32_t(end - begin);
-                        temp.clear().append(getLanguage(), status).append("_", status).append(begin, len, status);
-                        LocalUResourceBundlePointer languageVariantAlias(
-                            ures_getByKey(languageAlias.getAlias(),
-                                          temp.data(),
-                                          NULL, &status));
-                        temp.clear().appendInvariantChars(
-                            UnicodeString(ures_getStringByKey(languageVariantAlias.getAlias(), "replacement", nullptr, &status)), status);
-                        if (U_SUCCESS(status)) {
-                            CharString newVar;
-                            if (begin != variants) {
-                                newVar.append(variants, static_cast<int32_t>(begin - variants - 1), status);
-                            }
-                            if (end != nullptr) {
-                                if (begin != variants) {
-                                    newVar.append("_", status);
-                                }
-                                newVar.append(end + 1, status);
-                            }
-                            Locale l(temp.data());
-                            init(AppendLSCVE(temp.clear(),
-                                             l.getLanguage(),
-                                             (getScript() != nullptr && getScript()[0] != '\0') ? getScript() : l.getScript(),
-                                             (getCountry() != nullptr && getCountry()[0] != '\0') ? getCountry() : l.getCountry(),
-                                             newVar.data(),
-                                             uprv_strchr(fullName, '@'), status).data(), false);
-                            break;
-                        }
-                        begin = end + 1;
-                    } while (end != nullptr);
-                }  // End of handle language _ variant
-                // Handle cases of key pattern "language _ Script _ REGION"
-                // ex: Map "ks_Arab_IN" to "ks_IN"
-                if (getScript() != nullptr && getScript()[0] != '\0' &&
-                        getCountry() != nullptr && getCountry()[0] != '\0') {
-                    status = U_ZERO_ERROR;
-                    LocalUResourceBundlePointer replacedAlias(
-                        ures_getByKey(languageAlias.getAlias(),
-                                      AppendLSCVE(temp.clear(), getLanguage(), getScript(), getCountry(),
-                                                  nullptr, nullptr, status).data(), NULL, &status));
-                    temp.clear().appendInvariantChars(
-                        UnicodeString(ures_getStringByKey(replacedAlias.getAlias(), "replacement", nullptr, &status)), status);
-                    if (U_SUCCESS(status)) {
-                        Locale l(temp.data());
-                        init(AppendLSCVE(temp.clear(),
-                                         l.getLanguage(),
-                                         l.getScript(),
-                                         l.getCountry(),
-                                         getVariant(),
-                                         uprv_strchr(fullName, '@'), status).data(), false);
-                    }
-                }  // End of handle language _ Script _ REGION
-                // Handle cases of key pattern "language _ REGION"
-                // ex: Map "zh_CN" to "zh_Hans_CN"
-                if (getCountry() != nullptr && getCountry()[0] != '\0') {
-                    status = U_ZERO_ERROR;
-                    LocalUResourceBundlePointer replacedAlias(
-                        ures_getByKey(languageAlias.getAlias(),
-                                      AppendLSCVE(temp.clear(), getLanguage(), nullptr, getCountry(),
-                                                  nullptr, nullptr, status).data(), NULL, &status));
-                    temp.clear().appendInvariantChars(
-                        UnicodeString(ures_getStringByKey(replacedAlias.getAlias(), "replacement", nullptr, &status)), status);
-                    if (U_SUCCESS(status)) {
-                        Locale l(temp.data());
-                        init(AppendLSCVE(temp.clear(),
-                                         l.getLanguage(),
-                                         (getScript() != nullptr && getScript()[0] != '\0') ? getScript() : l.getScript(),
-                                         l.getCountry(),
-                                         getVariant(),
-                                         uprv_strchr(fullName, '@'), status).data(), false);
-                    }
-                }  // End of handle "language _ REGION"
-                // Handle cases of key pattern "language"
-                // ex: Map "no" to "nb"
-                {
-                    status = U_ZERO_ERROR;
-                    LocalUResourceBundlePointer replaceLanguageAlias(ures_getByKey(languageAlias.getAlias(), getLanguage(), NULL, &status));
-                    temp.clear().appendInvariantChars(
-                        UnicodeString(ures_getStringByKey(replaceLanguageAlias.getAlias(), "replacement", nullptr, &status)), status);
-                    if (U_SUCCESS(status)) {
-                        Locale l(temp.data());
-                        init(AppendLSCVE(temp.clear(),
-                                         l.getLanguage(),
-                                         (getScript() != nullptr && getScript()[0] != '\0') ? getScript() : l.getScript(),
-                                         (getCountry() != nullptr && getCountry()[0] != '\0') ? getCountry() : l.getCountry(),
-                                         getVariant(),
-                                         uprv_strchr(fullName, '@'), status).data(), false);
-                    }
-                }  // End of handle "language"
-
-                // Look up the metadata:alias:territory:$key:replacement entries
-                // key is region code.
-                if (getCountry() != nullptr) {
-                    status = U_ZERO_ERROR;
-                    // The resource structure looks like
-                    // metadata {
-                    //   alias {
-                    //     ...
-                    //     territory: {
-                    //       172 {
-                    //         replacement{"RU AM AZ BY GE KG KZ MD TJ TM UA UZ"}
-                    //       }
-                    //       ...
-                    //       554 {
-                    //         replacement{"NZ"}
-                    //       }
-                    //     }
-                    //   }
-                    // }
-                    LocalUResourceBundlePointer territoryAlias(ures_getByKey(metadataAlias.getAlias(), "territory", NULL, &status));
-                    LocalUResourceBundlePointer countryAlias(ures_getByKey(territoryAlias.getAlias(), getCountry(), NULL, &status));
-                    UnicodeString replacements(
-                        ures_getStringByKey(countryAlias.getAlias(), "replacement", nullptr, &status));
-                    if (U_SUCCESS(status)) {
-                        CharString replacedCountry;
-                        int32_t delPos = replacements.indexOf(' ');
-                        if (delPos == -1) {
-                            replacedCountry.appendInvariantChars(replacements, status);
-                        } else {
-                            Locale l(AppendLSCVE(temp.clear(), getLanguage(), nullptr, getScript(),
-                                                 nullptr, nullptr, status).data());
-                            l.addLikelySubtags(status);
-                            if (replacements.indexOf(UnicodeString(l.getCountry())) != -1) {
-                                replacedCountry.append(l.getCountry(), status);
-                            } else {
-                                replacedCountry.appendInvariantChars(replacements.getBuffer(), delPos, status);
-                            }
-                        }
-                        init(AppendLSCVE(temp.clear(),
-                                         getLanguage(),
-                                         getScript(),
-                                         replacedCountry.data(),
-                                         getVariant(),
-                                         uprv_strchr(fullName, '@'), status).data(), false);
-                    }
-                }   // End of handle REGION
-            } while (0);
+                }
+            }
         }   // if (canonicalize) {
 
         // successful end of init()
@@ -906,7 +2043,7 @@ Locale::hashCode() const
 void
 Locale::setToBogus() {
     /* Free our current storage */
-    if(baseName != fullName) {
+    if((baseName != fullName) && (baseName != fullNameBuffer)) {
         uprv_free(baseName);
     }
     baseName = NULL;
@@ -1024,13 +2161,14 @@ Locale::forLanguageTag(StringPiece tag, UErrorCode& status)
         return result;
     }
 
-    // If a BCP-47 language tag is passed as the language parameter to the
+    // If a BCP 47 language tag is passed as the language parameter to the
     // normal Locale constructor, it will actually fall back to invoking
     // uloc_forLanguageTag() to parse it if it somehow is able to detect that
-    // the string actually is BCP-47. This works well for things like strings
-    // using BCP-47 extensions, but it does not at all work for things like
-    // BCP-47 grandfathered tags (eg. "en-GB-oed") which are possible to also
-    // interpret as ICU locale IDs and because of that won't trigger the BCP-47
+    // the string actually is BCP 47. This works well for things like strings
+    // using BCP 47 extensions, but it does not at all work for things like
+    // legacy language tags (marked as “Type: grandfathered” in BCP 47,
+    // e.g., "en-GB-oed") which are possible to also
+    // interpret as ICU locale IDs and because of that won't trigger the BCP 47
     // parsing. Therefore the code here explicitly calls uloc_forLanguageTag()
     // and then Locale::init(), instead of just calling the normal constructor.
 
@@ -1414,8 +2552,6 @@ UnicodeKeywordEnumeration::~UnicodeKeywordEnumeration() = default;
 StringEnumeration *
 Locale::createKeywords(UErrorCode &status) const
 {
-    char keywords[256];
-    int32_t keywordCapacity = sizeof keywords;
     StringEnumeration *result = NULL;
 
     if (U_FAILURE(status)) {
@@ -1426,9 +2562,11 @@ Locale::createKeywords(UErrorCode &status) const
     const char* assignment = uprv_strchr(fullName, '=');
     if(variantStart) {
         if(assignment > variantStart) {
-            int32_t keyLen = locale_getKeywords(variantStart+1, '@', keywords, keywordCapacity, FALSE, &status);
-            if(U_SUCCESS(status) && keyLen) {
-                result = new KeywordEnumeration(keywords, keyLen, 0, status);
+            CharString keywords;
+            CharStringByteSink sink(&keywords);
+            ulocimp_getKeywords(variantStart+1, '@', sink, FALSE, &status);
+            if (U_SUCCESS(status) && !keywords.isEmpty()) {
+                result = new KeywordEnumeration(keywords.data(), keywords.length(), 0, status);
                 if (!result) {
                     status = U_MEMORY_ALLOCATION_ERROR;
                 }
@@ -1443,8 +2581,6 @@ Locale::createKeywords(UErrorCode &status) const
 StringEnumeration *
 Locale::createUnicodeKeywords(UErrorCode &status) const
 {
-    char keywords[256];
-    int32_t keywordCapacity = sizeof keywords;
     StringEnumeration *result = NULL;
 
     if (U_FAILURE(status)) {
@@ -1455,9 +2591,11 @@ Locale::createUnicodeKeywords(UErrorCode &status) const
     const char* assignment = uprv_strchr(fullName, '=');
     if(variantStart) {
         if(assignment > variantStart) {
-            int32_t keyLen = locale_getKeywords(variantStart+1, '@', keywords, keywordCapacity, FALSE, &status);
-            if(U_SUCCESS(status) && keyLen) {
-                result = new UnicodeKeywordEnumeration(keywords, keyLen, 0, status);
+            CharString keywords;
+            CharStringByteSink sink(&keywords);
+            ulocimp_getKeywords(variantStart+1, '@', sink, FALSE, &status);
+            if (U_SUCCESS(status) && !keywords.isEmpty()) {
+                result = new UnicodeKeywordEnumeration(keywords.data(), keywords.length(), 0, status);
                 if (!result) {
                     status = U_MEMORY_ALLOCATION_ERROR;
                 }
@@ -1492,48 +2630,7 @@ Locale::getKeywordValue(StringPiece keywordName, ByteSink& sink, UErrorCode& sta
         return;
     }
 
-    LocalMemory<char> scratch;
-    int32_t scratch_capacity = 16;  // Arbitrarily chosen default size.
-
-    char* buffer;
-    int32_t result_capacity, reslen;
-
-    for (;;) {
-        if (scratch.allocateInsteadAndReset(scratch_capacity) == nullptr) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-            return;
-        }
-
-        buffer = sink.GetAppendBuffer(
-                /*min_capacity=*/scratch_capacity,
-                /*desired_capacity_hint=*/scratch_capacity,
-                scratch.getAlias(),
-                scratch_capacity,
-                &result_capacity);
-
-        reslen = uloc_getKeywordValue(
-                fullName,
-                keywordName_nul.data(),
-                buffer,
-                result_capacity,
-                &status);
-
-        if (status != U_BUFFER_OVERFLOW_ERROR) {
-            break;
-        }
-
-        scratch_capacity = reslen;
-        status = U_ZERO_ERROR;
-    }
-
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    sink.Append(buffer, reslen);
-    if (status == U_STRING_NOT_TERMINATED_WARNING) {
-        status = U_ZERO_ERROR;  // Terminators not used.
-    }
+    ulocimp_getKeywordValue(fullName, keywordName_nul.data(), sink, &status);
 }
 
 void
@@ -1580,9 +2677,13 @@ Locale::setKeywordValue(const char* keywordName, const char* keywordValue, UErro
     if (U_FAILURE(status)) {
         return;
     }
+    if (status == U_STRING_NOT_TERMINATED_WARNING) {
+        status = U_ZERO_ERROR;
+    }
     int32_t bufferLength = uprv_max((int32_t)(uprv_strlen(fullName) + 1), ULOC_FULLNAME_CAPACITY);
     int32_t newLength = uloc_setKeywordValue(keywordName, keywordValue, fullName,
                                              bufferLength, &status) + 1;
+    U_ASSERT(status != U_STRING_NOT_TERMINATED_WARNING);
     /* Handle the case the current buffer is not enough to hold the new id */
     if (status == U_BUFFER_OVERFLOW_ERROR) {
         U_ASSERT(newLength > bufferLength);
@@ -1599,6 +2700,7 @@ Locale::setKeywordValue(const char* keywordName, const char* keywordValue, UErro
         fullName = newFullName;
         status = U_ZERO_ERROR;
         uloc_setKeywordValue(keywordName, keywordValue, fullName, newLength, &status);
+        U_ASSERT(status != U_STRING_NOT_TERMINATED_WARNING);
     } else {
         U_ASSERT(newLength <= bufferLength);
     }
diff --git a/deps/icu-small/source/common/loclikely.cpp b/deps/icu-small/source/common/loclikely.cpp
index 3b71708e549d5f664d6724b847a67cc0e9b5db66..6a34bb42cecf3fa37bfc3d26e53d88551bd13c6e 100644
--- a/deps/icu-small/source/common/loclikely.cpp
+++ b/deps/icu-small/source/common/loclikely.cpp
@@ -464,8 +464,7 @@ parseTagString(
         goto error;
     }
 
-    subtagLength = ulocimp_getLanguage(position, lang, *langLength, &position);
-    u_terminateChars(lang, *langLength, subtagLength, err);
+    subtagLength = ulocimp_getLanguage(position, &position, *err).extract(lang, *langLength, *err);
 
     /*
      * Note that we explicit consider U_STRING_NOT_TERMINATED_WARNING
@@ -486,8 +485,7 @@ parseTagString(
         ++position;
     }
 
-    subtagLength = ulocimp_getScript(position, script, *scriptLength, &position);
-    u_terminateChars(script, *scriptLength, subtagLength, err);
+    subtagLength = ulocimp_getScript(position, &position, *err).extract(script, *scriptLength, *err);
 
     if(U_FAILURE(*err)) {
         goto error;
@@ -511,8 +509,7 @@ parseTagString(
         }
     }
 
-    subtagLength = ulocimp_getCountry(position, region, *regionLength, &position);
-    u_terminateChars(region, *regionLength, subtagLength, err);
+    subtagLength = ulocimp_getCountry(position, &position, *err).extract(region, *regionLength, *err);
 
     if(U_FAILURE(*err)) {
         goto error;
@@ -826,7 +823,7 @@ error:
     } \
 } UPRV_BLOCK_MACRO_END
 
-static void
+static UBool
 _uloc_addLikelySubtags(const char* localeID,
                        icu::ByteSink& sink,
                        UErrorCode* err) {
@@ -897,15 +894,22 @@ _uloc_addLikelySubtags(const char* localeID,
         sink.Append(localeID, localIDLength);
     }
 
-    return;
+    return success;
 
 error:
 
     if (!U_FAILURE(*err)) {
         *err = U_ILLEGAL_ARGUMENT_ERROR;
     }
+    return FALSE;
 }
 
+// Add likely subtags to the sink
+// return true if the value in the sink is produced by a match during the lookup
+// return false if the value in the sink is the same as input because there are
+// no match after the lookup.
+static UBool _ulocimp_addLikelySubtags(const char*, icu::ByteSink&, UErrorCode*);
+
 static void
 _uloc_minimizeSubtags(const char* localeID,
                       icu::ByteSink& sink,
@@ -921,6 +925,7 @@ _uloc_minimizeSubtags(const char* localeID,
     const char* trailing = "";
     int32_t trailingLength = 0;
     int32_t trailingIndex = 0;
+    UBool successGetMax = FALSE;
 
     if(U_FAILURE(*err)) {
         goto error;
@@ -961,7 +966,7 @@ _uloc_minimizeSubtags(const char* localeID,
     {
         icu::CharString base;
         {
-            icu::CharStringByteSink sink(&base);
+            icu::CharStringByteSink baseSink(&base);
             createTagString(
                 lang,
                 langLength,
@@ -971,7 +976,7 @@ _uloc_minimizeSubtags(const char* localeID,
                 regionLength,
                 NULL,
                 0,
-                sink,
+                baseSink,
                 err);
         }
 
@@ -980,8 +985,8 @@ _uloc_minimizeSubtags(const char* localeID,
          * from AddLikelySubtags.
          **/
         {
-            icu::CharStringByteSink sink(&maximizedTagBuffer);
-            ulocimp_addLikelySubtags(base.data(), sink, err);
+            icu::CharStringByteSink maxSink(&maximizedTagBuffer);
+            successGetMax = _ulocimp_addLikelySubtags(base.data(), maxSink, err);
         }
     }
 
@@ -989,13 +994,40 @@ _uloc_minimizeSubtags(const char* localeID,
         goto error;
     }
 
+    if (!successGetMax) {
+        /**
+         * If we got here, return the locale ID parameter unchanged.
+         **/
+        const int32_t localeIDLength = (int32_t)uprv_strlen(localeID);
+        sink.Append(localeID, localeIDLength);
+        return;
+    }
+
+    // In the following, the lang, script, region are referring to those in
+    // the maximizedTagBuffer, not the one in the localeID.
+    langLength = sizeof(lang);
+    scriptLength = sizeof(script);
+    regionLength = sizeof(region);
+    parseTagString(
+        maximizedTagBuffer.data(),
+        lang,
+        &langLength,
+        script,
+        &scriptLength,
+        region,
+        &regionLength,
+        err);
+    if(U_FAILURE(*err)) {
+        goto error;
+    }
+
     /**
      * Start first with just the language.
      **/
     {
         icu::CharString tagBuffer;
         {
-            icu::CharStringByteSink sink(&tagBuffer);
+            icu::CharStringByteSink tagSink(&tagBuffer);
             createLikelySubtagsString(
                 lang,
                 langLength,
@@ -1005,14 +1037,15 @@ _uloc_minimizeSubtags(const char* localeID,
                 0,
                 NULL,
                 0,
-                sink,
+                tagSink,
                 err);
         }
 
         if(U_FAILURE(*err)) {
             goto error;
         }
-        else if (!tagBuffer.isEmpty() && uprv_strnicmp(
+        else if (!tagBuffer.isEmpty() &&
+                 uprv_strnicmp(
                     maximizedTagBuffer.data(),
                     tagBuffer.data(),
                     tagBuffer.length()) == 0) {
@@ -1039,7 +1072,7 @@ _uloc_minimizeSubtags(const char* localeID,
 
         icu::CharString tagBuffer;
         {
-            icu::CharStringByteSink sink(&tagBuffer);
+            icu::CharStringByteSink tagSink(&tagBuffer);
             createLikelySubtagsString(
                 lang,
                 langLength,
@@ -1049,14 +1082,15 @@ _uloc_minimizeSubtags(const char* localeID,
                 regionLength,
                 NULL,
                 0,
-                sink,
+                tagSink,
                 err);
         }
 
         if(U_FAILURE(*err)) {
             goto error;
         }
-        else if (uprv_strnicmp(
+        else if (!tagBuffer.isEmpty() &&
+                 uprv_strnicmp(
                     maximizedTagBuffer.data(),
                     tagBuffer.data(),
                     tagBuffer.length()) == 0) {
@@ -1081,10 +1115,10 @@ _uloc_minimizeSubtags(const char* localeID,
      * since trying with all three subtags would only yield the
      * maximal version that we already have.
      **/
-    if (scriptLength > 0 && regionLength > 0) {
+    if (scriptLength > 0) {
         icu::CharString tagBuffer;
         {
-            icu::CharStringByteSink sink(&tagBuffer);
+            icu::CharStringByteSink tagSink(&tagBuffer);
             createLikelySubtagsString(
                 lang,
                 langLength,
@@ -1094,14 +1128,15 @@ _uloc_minimizeSubtags(const char* localeID,
                 0,
                 NULL,
                 0,
-                sink,
+                tagSink,
                 err);
         }
 
         if(U_FAILURE(*err)) {
             goto error;
         }
-        else if (uprv_strnicmp(
+        else if (!tagBuffer.isEmpty() &&
+                 uprv_strnicmp(
                     maximizedTagBuffer.data(),
                     tagBuffer.data(),
                     tagBuffer.length()) == 0) {
@@ -1123,10 +1158,19 @@ _uloc_minimizeSubtags(const char* localeID,
 
     {
         /**
-         * If we got here, return the locale ID parameter.
+         * If we got here, return the max + trail.
          **/
-        const int32_t localeIDLength = (int32_t)uprv_strlen(localeID);
-        sink.Append(localeID, localeIDLength);
+        createTagString(
+                    lang,
+                    langLength,
+                    script,
+                    scriptLength,
+                    region,
+                    regionLength,
+                    trailing,
+                    trailingLength,
+                    sink,
+                    err);
         return;
     }
 
@@ -1193,15 +1237,23 @@ uloc_addLikelySubtags(const char* localeID,
     return reslen;
 }
 
-U_CAPI void U_EXPORT2
-ulocimp_addLikelySubtags(const char* localeID,
-                         icu::ByteSink& sink,
-                         UErrorCode* status) {
+static UBool
+_ulocimp_addLikelySubtags(const char* localeID,
+                          icu::ByteSink& sink,
+                          UErrorCode* status) {
     char localeBuffer[ULOC_FULLNAME_CAPACITY];
 
     if (do_canonicalize(localeID, localeBuffer, sizeof localeBuffer, status)) {
-        _uloc_addLikelySubtags(localeBuffer, sink, status);
+        return _uloc_addLikelySubtags(localeBuffer, sink, status);
     }
+    return FALSE;
+}
+
+U_CAPI void U_EXPORT2
+ulocimp_addLikelySubtags(const char* localeID,
+                         icu::ByteSink& sink,
+                         UErrorCode* status) {
+    _ulocimp_addLikelySubtags(localeID, sink, status);
 }
 
 U_CAPI int32_t U_EXPORT2
diff --git a/deps/icu-small/source/common/loclikelysubtags.cpp b/deps/icu-small/source/common/loclikelysubtags.cpp
index 1fbf1a1463299fec9c68177479f9bab6cd28b54a..aa592e6ea807319a8439adb599604be9450038d4 100644
--- a/deps/icu-small/source/common/loclikelysubtags.cpp
+++ b/deps/icu-small/source/common/loclikelysubtags.cpp
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // loclikelysubtags.cpp
 // created: 2019may08 Markus W. Scherer
@@ -20,6 +20,7 @@
 #include "uhash.h"
 #include "uinvchar.h"
 #include "umutex.h"
+#include "uniquecharstr.h"
 #include "uresdata.h"
 #include "uresimp.h"
 
@@ -31,71 +32,6 @@ constexpr char PSEUDO_ACCENTS_PREFIX = '\'';  // -XA, -PSACCENT
 constexpr char PSEUDO_BIDI_PREFIX = '+';  // -XB, -PSBIDI
 constexpr char PSEUDO_CRACKED_PREFIX = ',';  // -XC, -PSCRACK
 
-/**
- * Stores NUL-terminated strings with duplicate elimination.
- * Checks for unique UTF-16 string pointers and converts to invariant characters.
- */
-class UniqueCharStrings {
-public:
-    UniqueCharStrings(UErrorCode &errorCode) : strings(nullptr) {
-        uhash_init(&map, uhash_hashUChars, uhash_compareUChars, uhash_compareLong, &errorCode);
-        if (U_FAILURE(errorCode)) { return; }
-        strings = new CharString();
-        if (strings == nullptr) {
-            errorCode = U_MEMORY_ALLOCATION_ERROR;
-        }
-    }
-    ~UniqueCharStrings() {
-        uhash_close(&map);
-        delete strings;
-    }
-
-    /** Returns/orphans the CharString that contains all strings. */
-    CharString *orphanCharStrings() {
-        CharString *result = strings;
-        strings = nullptr;
-        return result;
-    }
-
-    /** Adds a string and returns a unique number for it. */
-    int32_t add(const UnicodeString &s, UErrorCode &errorCode) {
-        if (U_FAILURE(errorCode)) { return 0; }
-        if (isFrozen) {
-            errorCode = U_NO_WRITE_PERMISSION;
-            return 0;
-        }
-        // The string points into the resource bundle.
-        const char16_t *p = s.getBuffer();
-        int32_t oldIndex = uhash_geti(&map, p);
-        if (oldIndex != 0) {  // found duplicate
-            return oldIndex;
-        }
-        // Explicit NUL terminator for the previous string.
-        // The strings object is also terminated with one implicit NUL.
-        strings->append(0, errorCode);
-        int32_t newIndex = strings->length();
-        strings->appendInvariantChars(s, errorCode);
-        uhash_puti(&map, const_cast<char16_t *>(p), newIndex, &errorCode);
-        return newIndex;
-    }
-
-    void freeze() { isFrozen = true; }
-
-    /**
-     * Returns a string pointer for its unique number, if this object is frozen.
-     * Otherwise nullptr.
-     */
-    const char *get(int32_t i) const {
-        U_ASSERT(isFrozen);
-        return isFrozen && i > 0 ? strings->data() + i : nullptr;
-    }
-
-private:
-    UHashtable map;
-    CharString *strings;
-    bool isFrozen = false;
-};
-
 }  // namespace
 
 LocaleDistanceData::LocaleDistanceData(LocaleDistanceData &&data) :
@@ -384,7 +320,8 @@ XLikelySubtags::~XLikelySubtags() {
 LSR XLikelySubtags::makeMaximizedLsrFrom(const Locale &locale, UErrorCode &errorCode) const {
     const char *name = locale.getName();
     if (uprv_isAtSign(name[0]) && name[1] == 'x' && name[2] == '=') {  // name.startsWith("@x=")
-        // Private use language tag x-subtag-subtag...
+        // Private use language tag x-subtag-subtag... which CLDR changes to
+        // und-x-subtag-subtag...
         return LSR(name, "", "", LSR::EXPLICIT_LSR);
     }
     return makeMaximizedLsr(locale.getLanguage(), locale.getScript(), locale.getCountry(),
diff --git a/deps/icu-small/source/common/loclikelysubtags.h b/deps/icu-small/source/common/loclikelysubtags.h
index 90ddfffaca672d3a738407cab618c1942f673b12..14a01a5eac7ebab829e82932514b06d273f1ce26 100644
--- a/deps/icu-small/source/common/loclikelysubtags.h
+++ b/deps/icu-small/source/common/loclikelysubtags.h
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // loclikelysubtags.h
 // created: 2019may08 Markus W. Scherer
@@ -13,49 +13,13 @@
 #include "unicode/locid.h"
 #include "unicode/uobject.h"
 #include "unicode/ures.h"
+#include "charstrmap.h"
 #include "lsr.h"
-#include "uhash.h"
 
 U_NAMESPACE_BEGIN
 
 struct XLikelySubtagsData;
 
-/**
- * Map of const char * keys & values.
- * Stores pointers as is: Does not own/copy/adopt/release strings.
- */
-class CharStringMap final : public UMemory {
-public:
-    /** Constructs an unusable non-map. */
-    CharStringMap() : map(nullptr) {}
-    CharStringMap(int32_t size, UErrorCode &errorCode) {
-        map = uhash_openSize(uhash_hashChars, uhash_compareChars, uhash_compareChars,
-                             size, &errorCode);
-    }
-    CharStringMap(CharStringMap &&other) U_NOEXCEPT : map(other.map) {
-        other.map = nullptr;
-    }
-    CharStringMap(const CharStringMap &other) = delete;
-    ~CharStringMap() {
-        uhash_close(map);
-    }
-
-    CharStringMap &operator=(CharStringMap &&other) U_NOEXCEPT {
-        map = other.map;
-        other.map = nullptr;
-        return *this;
-    }
-    CharStringMap &operator=(const CharStringMap &other) = delete;
-
-    const char *get(const char *key) const { return static_cast<const char *>(uhash_get(map, key)); }
-    void put(const char *key, const char *value, UErrorCode &errorCode) {
-        uhash_put(map, const_cast<char *>(key), const_cast<char *>(value), &errorCode);
-    }
-
-private:
-    UHashtable *map;
-};
-
 struct LocaleDistanceData {
     LocaleDistanceData() = default;
     LocaleDistanceData(LocaleDistanceData &&data);
diff --git a/deps/icu-small/source/common/locmap.cpp b/deps/icu-small/source/common/locmap.cpp
index 46986399b23e7a6caa9a38c7243714420662c052..515205222a65ac9df56c486c7083d0d877f604bc 100644
--- a/deps/icu-small/source/common/locmap.cpp
+++ b/deps/icu-small/source/common/locmap.cpp
@@ -28,8 +28,11 @@
  */
 
 #include "locmap.h"
+#include "bytesinkutil.h"
+#include "charstr.h"
 #include "cstring.h"
 #include "cmemory.h"
+#include "ulocimp.h"
 #include "unicode/uloc.h"
 
 #if U_PLATFORM_HAS_WIN32_API && UCONFIG_USE_WINDOWS_LCID_MAPPING_API
@@ -1167,15 +1170,18 @@ uprv_convertToLCIDPlatform(const char* localeID, UErrorCode* status)
     // conversion functionality when available.
 #if U_PLATFORM_HAS_WIN32_API && UCONFIG_USE_WINDOWS_LCID_MAPPING_API
     int32_t len;
-    char collVal[ULOC_KEYWORDS_CAPACITY] = {};
     char baseName[ULOC_FULLNAME_CAPACITY] = {};
     const char * mylocaleID = localeID;
 
     // Check any for keywords.
     if (uprv_strchr(localeID, '@'))
     {
-        len = uloc_getKeywordValue(localeID, "collation", collVal, UPRV_LENGTHOF(collVal) - 1, status);
-        if (U_SUCCESS(*status) && len > 0)
+        icu::CharString collVal;
+        {
+            icu::CharStringByteSink sink(&collVal);
+            ulocimp_getKeywordValue(localeID, "collation", sink, status);
+        }
+        if (U_SUCCESS(*status) && !collVal.isEmpty())
         {
             // If it contains the keyword collation, return 0 so that the LCID lookup table will be used.
             return 0;
diff --git a/deps/icu-small/source/common/lsr.cpp b/deps/icu-small/source/common/lsr.cpp
index d4308ad02754288ecb2373f45511a5b53e1ae28a..b81808f2c4aae1c0f6f9e6ca2c298997370e1c2d 100644
--- a/deps/icu-small/source/common/lsr.cpp
+++ b/deps/icu-small/source/common/lsr.cpp
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // lsr.cpp
 // created: 2019may08 Markus W. Scherer
diff --git a/deps/icu-small/source/common/lsr.h b/deps/icu-small/source/common/lsr.h
index d535e5b0376cd3c88c364ea57deddf13034a669e..a33f855245335e5da563ea9e10dd9333db322c4f 100644
--- a/deps/icu-small/source/common/lsr.h
+++ b/deps/icu-small/source/common/lsr.h
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // lsr.h
 // created: 2019may08 Markus W. Scherer
diff --git a/deps/icu-small/source/common/messageimpl.h b/deps/icu-small/source/common/messageimpl.h
index dc7a6edd6c0e5f4510742f4f7a85ccc45e1a3d20..a56479066bc0589218e59f73973e25699279e176 100644
--- a/deps/icu-small/source/common/messageimpl.h
+++ b/deps/icu-small/source/common/messageimpl.h
@@ -33,7 +33,7 @@ U_NAMESPACE_BEGIN
 class U_COMMON_API MessageImpl {
 public:
     /**
-     * @return TRUE if getApostropheMode()==UMSGPAT_APOS_DOUBLE_REQUIRED
+     * @return true if getApostropheMode()==UMSGPAT_APOS_DOUBLE_REQUIRED
      */
     static UBool jdkAposMode(const MessagePattern &msgPattern) {
         return msgPattern.getApostropheMode()==UMSGPAT_APOS_DOUBLE_REQUIRED;
diff --git a/deps/icu-small/source/common/norm2allmodes.h b/deps/icu-small/source/common/norm2allmodes.h
index 682ece28f13092f7a05519f478058e8e116f3e6f..584835da57b6be1487a143b45fb5d34eedb02ed4 100644
--- a/deps/icu-small/source/common/norm2allmodes.h
+++ b/deps/icu-small/source/common/norm2allmodes.h
@@ -38,7 +38,7 @@ public:
     virtual UnicodeString &
     normalize(const UnicodeString &src,
               UnicodeString &dest,
-              UErrorCode &errorCode) const {
+              UErrorCode &errorCode) const U_OVERRIDE {
         if(U_FAILURE(errorCode)) {
             dest.setToBogus();
             return dest;
@@ -64,14 +64,14 @@ public:
     virtual UnicodeString &
     normalizeSecondAndAppend(UnicodeString &first,
                              const UnicodeString &second,
-                             UErrorCode &errorCode) const {
-        return normalizeSecondAndAppend(first, second, TRUE, errorCode);
+                             UErrorCode &errorCode) const U_OVERRIDE {
+        return normalizeSecondAndAppend(first, second, true, errorCode);
     }
     virtual UnicodeString &
     append(UnicodeString &first,
            const UnicodeString &second,
-           UErrorCode &errorCode) const {
-        return normalizeSecondAndAppend(first, second, FALSE, errorCode);
+           UErrorCode &errorCode) const U_OVERRIDE {
+        return normalizeSecondAndAppend(first, second, false, errorCode);
     }
     UnicodeString &
     normalizeSecondAndAppend(UnicodeString &first,
@@ -107,65 +107,65 @@ public:
                        UnicodeString &safeMiddle,
                        ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;
     virtual UBool
-    getDecomposition(UChar32 c, UnicodeString &decomposition) const {
+    getDecomposition(UChar32 c, UnicodeString &decomposition) const U_OVERRIDE {
         UChar buffer[4];
         int32_t length;
         const UChar *d=impl.getDecomposition(c, buffer, length);
         if(d==NULL) {
-            return FALSE;
+            return false;
         }
         if(d==buffer) {
             decomposition.setTo(buffer, length);  // copy the string (Jamos from Hangul syllable c)
         } else {
-            decomposition.setTo(FALSE, d, length);  // read-only alias
+            decomposition.setTo(false, d, length);  // read-only alias
         }
-        return TRUE;
+        return true;
     }
     virtual UBool
-    getRawDecomposition(UChar32 c, UnicodeString &decomposition) const {
+    getRawDecomposition(UChar32 c, UnicodeString &decomposition) const U_OVERRIDE {
         UChar buffer[30];
         int32_t length;
         const UChar *d=impl.getRawDecomposition(c, buffer, length);
         if(d==NULL) {
-            return FALSE;
+            return false;
         }
         if(d==buffer) {
             decomposition.setTo(buffer, length);  // copy the string (algorithmic decomposition)
         } else {
-            decomposition.setTo(FALSE, d, length);  // read-only alias
+            decomposition.setTo(false, d, length);  // read-only alias
         }
-        return TRUE;
+        return true;
     }
     virtual UChar32
-    composePair(UChar32 a, UChar32 b) const {
+    composePair(UChar32 a, UChar32 b) const U_OVERRIDE {
         return impl.composePair(a, b);
     }
 
     virtual uint8_t
-    getCombiningClass(UChar32 c) const {
+    getCombiningClass(UChar32 c) const U_OVERRIDE {
         return impl.getCC(impl.getNorm16(c));
     }
 
     // quick checks
     virtual UBool
-    isNormalized(const UnicodeString &s, UErrorCode &errorCode) const {
+    isNormalized(const UnicodeString &s, UErrorCode &errorCode) const U_OVERRIDE {
         if(U_FAILURE(errorCode)) {
-            return FALSE;
+            return false;
         }
         const UChar *sArray=s.getBuffer();
         if(sArray==NULL) {
             errorCode=U_ILLEGAL_ARGUMENT_ERROR;
-            return FALSE;
+            return false;
         }
         const UChar *sLimit=sArray+s.length();
         return sLimit==spanQuickCheckYes(sArray, sLimit, errorCode);
     }
     virtual UNormalizationCheckResult
-    quickCheck(const UnicodeString &s, UErrorCode &errorCode) const {
+    quickCheck(const UnicodeString &s, UErrorCode &errorCode) const U_OVERRIDE {
         return Normalizer2WithImpl::isNormalized(s, errorCode) ? UNORM_YES : UNORM_NO;
     }
     virtual int32_t
-    spanQuickCheckYes(const UnicodeString &s, UErrorCode &errorCode) const {
+    spanQuickCheckYes(const UnicodeString &s, UErrorCode &errorCode) const U_OVERRIDE {
         if(U_FAILURE(errorCode)) {
             return 0;
         }
@@ -194,27 +194,57 @@ public:
 private:
     virtual void
     normalize(const UChar *src, const UChar *limit,
-              ReorderingBuffer &buffer, UErrorCode &errorCode) const {
+              ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
         impl.decompose(src, limit, &buffer, errorCode);
     }
     using Normalizer2WithImpl::normalize;  // Avoid warning about hiding base class function.
     virtual void
     normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
                        UnicodeString &safeMiddle,
-                       ReorderingBuffer &buffer, UErrorCode &errorCode) const {
+                       ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
         impl.decomposeAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
     }
+
+    void
+    normalizeUTF8(uint32_t options, StringPiece src, ByteSink &sink,
+                  Edits *edits, UErrorCode &errorCode) const U_OVERRIDE {
+        if (U_FAILURE(errorCode)) {
+            return;
+        }
+        if (edits != nullptr && (options & U_EDITS_NO_RESET) == 0) {
+            edits->reset();
+        }
+        const uint8_t *s = reinterpret_cast<const uint8_t *>(src.data());
+        impl.decomposeUTF8(options, s, s + src.length(), &sink, edits, errorCode);
+        sink.Flush();
+    }
+    virtual UBool
+    isNormalizedUTF8(StringPiece sp, UErrorCode &errorCode) const U_OVERRIDE {
+        if(U_FAILURE(errorCode)) {
+            return false;
+        }
+        const uint8_t *s = reinterpret_cast<const uint8_t *>(sp.data());
+        const uint8_t *sLimit = s + sp.length();
+        return sLimit == impl.decomposeUTF8(0, s, sLimit, nullptr, nullptr, errorCode);
+    }
+
     virtual const UChar *
-    spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const {
+    spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const U_OVERRIDE {
         return impl.decompose(src, limit, NULL, errorCode);
     }
     using Normalizer2WithImpl::spanQuickCheckYes;  // Avoid warning about hiding base class function.
-    virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const {
+    virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const U_OVERRIDE {
         return impl.isDecompYes(impl.getNorm16(c)) ? UNORM_YES : UNORM_NO;
     }
-    virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasDecompBoundaryBefore(c); }
-    virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasDecompBoundaryAfter(c); }
-    virtual UBool isInert(UChar32 c) const { return impl.isDecompInert(c); }
+    virtual UBool hasBoundaryBefore(UChar32 c) const U_OVERRIDE {
+        return impl.hasDecompBoundaryBefore(c);
+    }
+    virtual UBool hasBoundaryAfter(UChar32 c) const U_OVERRIDE {
+        return impl.hasDecompBoundaryAfter(c);
+    }
+    virtual UBool isInert(UChar32 c) const U_OVERRIDE {
+        return impl.isDecompInert(c);
+    }
 };
 
 class ComposeNormalizer2 : public Normalizer2WithImpl {
@@ -227,7 +257,7 @@ private:
     virtual void
     normalize(const UChar *src, const UChar *limit,
               ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
-        impl.compose(src, limit, onlyContiguous, TRUE, buffer, errorCode);
+        impl.compose(src, limit, onlyContiguous, true, buffer, errorCode);
     }
     using Normalizer2WithImpl::normalize;  // Avoid warning about hiding base class function.
 
@@ -256,24 +286,24 @@ private:
     virtual UBool
     isNormalized(const UnicodeString &s, UErrorCode &errorCode) const U_OVERRIDE {
         if(U_FAILURE(errorCode)) {
-            return FALSE;
+            return false;
         }
         const UChar *sArray=s.getBuffer();
         if(sArray==NULL) {
             errorCode=U_ILLEGAL_ARGUMENT_ERROR;
-            return FALSE;
+            return false;
         }
         UnicodeString temp;
         ReorderingBuffer buffer(impl, temp);
         if(!buffer.init(5, errorCode)) {  // small destCapacity for substring normalization
-            return FALSE;
+            return false;
         }
-        return impl.compose(sArray, sArray+s.length(), onlyContiguous, FALSE, buffer, errorCode);
+        return impl.compose(sArray, sArray+s.length(), onlyContiguous, false, buffer, errorCode);
     }
     virtual UBool
     isNormalizedUTF8(StringPiece sp, UErrorCode &errorCode) const U_OVERRIDE {
         if(U_FAILURE(errorCode)) {
-            return FALSE;
+            return false;
         }
         const uint8_t *s = reinterpret_cast<const uint8_t *>(sp.data());
         return impl.composeUTF8(0, onlyContiguous, s, s + sp.length(), nullptr, nullptr, errorCode);
@@ -321,29 +351,35 @@ public:
 private:
     virtual void
     normalize(const UChar *src, const UChar *limit,
-              ReorderingBuffer &buffer, UErrorCode &errorCode) const {
+              ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
         impl.makeFCD(src, limit, &buffer, errorCode);
     }
     using Normalizer2WithImpl::normalize;  // Avoid warning about hiding base class function.
     virtual void
     normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
                        UnicodeString &safeMiddle,
-                       ReorderingBuffer &buffer, UErrorCode &errorCode) const {
+                       ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
         impl.makeFCDAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
     }
     virtual const UChar *
-    spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const {
+    spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const U_OVERRIDE {
         return impl.makeFCD(src, limit, NULL, errorCode);
     }
     using Normalizer2WithImpl::spanQuickCheckYes;  // Avoid warning about hiding base class function.
-    virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasFCDBoundaryBefore(c); }
-    virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasFCDBoundaryAfter(c); }
-    virtual UBool isInert(UChar32 c) const { return impl.isFCDInert(c); }
+    virtual UBool hasBoundaryBefore(UChar32 c) const U_OVERRIDE {
+        return impl.hasFCDBoundaryBefore(c);
+    }
+    virtual UBool hasBoundaryAfter(UChar32 c) const U_OVERRIDE {
+        return impl.hasFCDBoundaryAfter(c);
+    }
+    virtual UBool isInert(UChar32 c) const U_OVERRIDE {
+        return impl.isFCDInert(c);
+    }
 };
 
 struct Norm2AllModes : public UMemory {
     Norm2AllModes(Normalizer2Impl *i)
-            : impl(i), comp(*i, FALSE), decomp(*i), fcd(*i), fcc(*i, TRUE) {}
+            : impl(i), comp(*i, false), decomp(*i), fcd(*i), fcc(*i, true) {}
     ~Norm2AllModes();
 
     static Norm2AllModes *createInstance(Normalizer2Impl *impl, UErrorCode &errorCode);
diff --git a/deps/icu-small/source/common/normalizer2impl.cpp b/deps/icu-small/source/common/normalizer2impl.cpp
index cbf6b4d980450a8139accc0835ecbb997a8c84c4..c0ad5c69f3e07de66f60b63ee8a14f210b075e69 100644
--- a/deps/icu-small/source/common/normalizer2impl.cpp
+++ b/deps/icu-small/source/common/normalizer2impl.cpp
@@ -731,9 +731,131 @@ UBool Normalizer2Impl::decompose(UChar32 c, uint16_t norm16,
     return buffer.append((const UChar *)mapping+1, length, TRUE, leadCC, trailCC, errorCode);
 }
 
+// Dual functionality:
+// sink != nullptr: normalize
+// sink == nullptr: isNormalized/spanQuickCheckYes
+const uint8_t *
+Normalizer2Impl::decomposeUTF8(uint32_t options,
+                               const uint8_t *src, const uint8_t *limit,
+                               ByteSink *sink, Edits *edits, UErrorCode &errorCode) const {
+    U_ASSERT(limit != nullptr);
+    UnicodeString s16;
+    uint8_t minNoLead = leadByteForCP(minDecompNoCP);
+
+    const uint8_t *prevBoundary = src;
+    // only for quick check
+    uint8_t prevCC = 0;
+
+    for (;;) {
+        // Fast path: Scan over a sequence of characters below the minimum "no" code point,
+        // or with (decompYes && ccc==0) properties.
+        const uint8_t *fastStart = src;
+        const uint8_t *prevSrc;
+        uint16_t norm16 = 0;
+
+        for (;;) {
+            if (src == limit) {
+                if (prevBoundary != limit && sink != nullptr) {
+                    ByteSinkUtil::appendUnchanged(prevBoundary, limit,
+                                                  *sink, options, edits, errorCode);
+                }
+                return src;
+            }
+            if (*src < minNoLead) {
+                ++src;
+            } else {
+                prevSrc = src;
+                UCPTRIE_FAST_U8_NEXT(normTrie, UCPTRIE_16, src, limit, norm16);
+                if (!isMostDecompYesAndZeroCC(norm16)) {
+                    break;
+                }
+            }
+        }
+        // isMostDecompYesAndZeroCC(norm16) is false, that is, norm16>=minYesNo,
+        // and the current character at [prevSrc..src[ is not a common case with cc=0
+        // (MIN_NORMAL_MAYBE_YES or JAMO_VT).
+        // It could still be a maybeYes with cc=0.
+        if (prevSrc != fastStart) {
+            // The fast path looped over yes/0 characters before the current one.
+            if (sink != nullptr &&
+                    !ByteSinkUtil::appendUnchanged(prevBoundary, prevSrc,
+                                                   *sink, options, edits, errorCode)) {
+                break;
+            }
+            prevBoundary = prevSrc;
+            prevCC = 0;
+        }
+
+        // Medium-fast path: Quick check.
+        if (isMaybeOrNonZeroCC(norm16)) {
+            // Does not decompose.
+            uint8_t cc = getCCFromYesOrMaybe(norm16);
+            if (prevCC <= cc || cc == 0) {
+                prevCC = cc;
+                if (cc <= 1) {
+                    if (sink != nullptr &&
+                            !ByteSinkUtil::appendUnchanged(prevBoundary, src,
+                                                           *sink, options, edits, errorCode)) {
+                        break;
+                    }
+                    prevBoundary = src;
+                }
+                continue;
+            }
+        }
+        if (sink == nullptr) {
+            return prevBoundary;  // quick check: "no" or cc out of order
+        }
+
+        // Slow path
+        // Decompose up to and including the current character.
+        if (prevBoundary != prevSrc && norm16HasDecompBoundaryBefore(norm16)) {
+            if (!ByteSinkUtil::appendUnchanged(prevBoundary, prevSrc,
+                                               *sink, options, edits, errorCode)) {
+                break;
+            }
+            prevBoundary = prevSrc;
+        }
+        ReorderingBuffer buffer(*this, s16, errorCode);
+        if (U_FAILURE(errorCode)) {
+            break;
+        }
+        decomposeShort(prevBoundary, src, STOP_AT_LIMIT, FALSE /* onlyContiguous */,
+                       buffer, errorCode);
+        // Decompose until the next boundary.
+        if (buffer.getLastCC() > 1) {
+            src = decomposeShort(src, limit, STOP_AT_DECOMP_BOUNDARY, FALSE /* onlyContiguous */,
+                                 buffer, errorCode);
+        }
+        if (U_FAILURE(errorCode)) {
+            break;
+        }
+        if ((src - prevSrc) > INT32_MAX) {  // guard before buffer.equals()
+            errorCode = U_INDEX_OUTOFBOUNDS_ERROR;
+            break;
+        }
+        // We already know there was a change if the original character decomposed;
+        // otherwise compare.
+        if (isMaybeOrNonZeroCC(norm16) && buffer.equals(prevBoundary, src)) {
+            if (!ByteSinkUtil::appendUnchanged(prevBoundary, src,
+                                               *sink, options, edits, errorCode)) {
+                break;
+            }
+        } else {
+            if (!ByteSinkUtil::appendChange(prevBoundary, src, buffer.getStart(), buffer.length(),
+                                            *sink, edits, errorCode)) {
+                break;
+            }
+        }
+        prevBoundary = src;
+        prevCC = 0;
+    }
+    return src;
+}
+
 const uint8_t *
 Normalizer2Impl::decomposeShort(const uint8_t *src, const uint8_t *limit,
-                                UBool stopAtCompBoundary, UBool onlyContiguous,
+                                StopAt stopAt, UBool onlyContiguous,
                                 ReorderingBuffer &buffer, UErrorCode &errorCode) const {
     if (U_FAILURE(errorCode)) {
         return nullptr;
@@ -746,21 +868,28 @@ Normalizer2Impl::decomposeShort(const uint8_t *src, const uint8_t *limit,
         UChar32 c = U_SENTINEL;
         if (norm16 >= limitNoNo) {
             if (isMaybeOrNonZeroCC(norm16)) {
-                // No boundaries around this character.
+                // No comp boundaries around this character.
+                uint8_t cc = getCCFromYesOrMaybe(norm16);
+                if (cc == 0 && stopAt == STOP_AT_DECOMP_BOUNDARY) {
+                    return prevSrc;
+                }
                 c = codePointFromValidUTF8(prevSrc, src);
-                if (!buffer.append(c, getCCFromYesOrMaybe(norm16), errorCode)) {
+                if (!buffer.append(c, cc, errorCode)) {
                     return nullptr;
                 }
+                if (stopAt == STOP_AT_DECOMP_BOUNDARY && buffer.getLastCC() <= 1) {
+                    return src;
+                }
                 continue;
             }
             // Maps to an isCompYesAndZeroCC.
-            if (stopAtCompBoundary) {
+            if (stopAt != STOP_AT_LIMIT) {
                 return prevSrc;
             }
             c = codePointFromValidUTF8(prevSrc, src);
             c = mapAlgorithmic(c, norm16);
             norm16 = getRawNorm16(c);
-        } else if (stopAtCompBoundary && norm16 < minNoNoCompNoMaybeCC) {
+        } else if (stopAt != STOP_AT_LIMIT && norm16 < minNoNoCompNoMaybeCC) {
             return prevSrc;
         }
         // norm16!=INERT guarantees that [prevSrc, src[ is valid UTF-8.
@@ -768,7 +897,8 @@ Normalizer2Impl::decomposeShort(const uint8_t *src, const uint8_t *limit,
         // its norm16==INERT is normalization-inert,
         // so it gets copied unchanged in the fast path,
         // and we stop the slow path where invalid UTF-8 begins.
-        U_ASSERT(norm16 != INERT);
+        // c >= 0 is the result of an algorithmic mapping.
+        U_ASSERT(c >= 0 || norm16 != INERT);
         if (norm16 < minYesNo) {
             if (c < 0) {
                 c = codePointFromValidUTF8(prevSrc, src);
@@ -798,11 +928,15 @@ Normalizer2Impl::decomposeShort(const uint8_t *src, const uint8_t *limit,
             } else {
                 leadCC = 0;
             }
+            if (leadCC == 0 && stopAt == STOP_AT_DECOMP_BOUNDARY) {
+                return prevSrc;
+            }
             if (!buffer.append((const char16_t *)mapping+1, length, TRUE, leadCC, trailCC, errorCode)) {
                 return nullptr;
             }
         }
-        if (stopAtCompBoundary && norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
+        if ((stopAt == STOP_AT_COMP_BOUNDARY && norm16HasCompBoundaryAfter(norm16, onlyContiguous)) ||
+                (stopAt == STOP_AT_DECOMP_BOUNDARY && buffer.getLastCC() <= 1)) {
             return src;
         }
     }
@@ -1954,10 +2088,10 @@ Normalizer2Impl::composeUTF8(uint32_t options, UBool onlyContiguous,
             break;
         }
         // We know there is not a boundary here.
-        decomposeShort(prevSrc, src, FALSE /* !stopAtCompBoundary */, onlyContiguous,
+        decomposeShort(prevSrc, src, STOP_AT_LIMIT, onlyContiguous,
                        buffer, errorCode);
         // Decompose until the next boundary.
-        src = decomposeShort(src, limit, TRUE /* stopAtCompBoundary */, onlyContiguous,
+        src = decomposeShort(src, limit, STOP_AT_COMP_BOUNDARY, onlyContiguous,
                              buffer, errorCode);
         if (U_FAILURE(errorCode)) {
             break;
diff --git a/deps/icu-small/source/common/normalizer2impl.h b/deps/icu-small/source/common/normalizer2impl.h
index cf3015ea881bfc7e4c8e7147a4ea55b55859a225..bdb6767a925c90e355603b5f65f89ae58d129a15 100644
--- a/deps/icu-small/source/common/normalizer2impl.h
+++ b/deps/icu-small/source/common/normalizer2impl.h
@@ -171,7 +171,7 @@ public:
                  UErrorCode &errorCode);
     UBool appendBMP(UChar c, uint8_t cc, UErrorCode &errorCode) {
         if(remainingCapacity==0 && !resize(1, errorCode)) {
-            return FALSE;
+            return false;
         }
         if(lastCC<=cc || cc==0) {
             *limit++=c;
@@ -183,7 +183,7 @@ public:
             insert(c, cc);
         }
         --remainingCapacity;
-        return TRUE;
+        return true;
     }
     UBool appendZeroCC(UChar32 c, UErrorCode &errorCode);
     UBool appendZeroCC(const UChar *s, const UChar *sLimit, UErrorCode &errorCode);
@@ -359,7 +359,7 @@ public:
         return getFCD16FromNormData(c);
     }
 
-    /** Returns TRUE if the single-or-lead code unit c might have non-zero FCD data. */
+    /** Returns true if the single-or-lead code unit c might have non-zero FCD data. */
     UBool singleLeadMightHaveNonZeroFCD16(UChar32 lead) const {
         // 0<=lead<=0xffff
         uint8_t bits=smallFCD[lead>>8];
@@ -397,8 +397,8 @@ public:
         MIN_YES_YES_WITH_CC=0xfe02,
         JAMO_VT=0xfe00,
         MIN_NORMAL_MAYBE_YES=0xfc00,
-        JAMO_L=2,  // offset=1 hasCompBoundaryAfter=FALSE
-        INERT=1,  // offset=0 hasCompBoundaryAfter=TRUE
+        JAMO_L=2,  // offset=1 hasCompBoundaryAfter=false
+        INERT=1,  // offset=0 hasCompBoundaryAfter=true
 
         // norm16 bit 0 is comp-boundary-after.
         HAS_COMP_BOUNDARY_AFTER=1,
@@ -491,6 +491,12 @@ public:
                             UnicodeString &safeMiddle,
                             ReorderingBuffer &buffer,
                             UErrorCode &errorCode) const;
+
+    /** sink==nullptr: isNormalized()/spanQuickCheckYes() */
+    const uint8_t *decomposeUTF8(uint32_t options,
+                                 const uint8_t *src, const uint8_t *limit,
+                                 ByteSink *sink, Edits *edits, UErrorCode &errorCode) const;
+
     UBool compose(const UChar *src, const UChar *limit,
                   UBool onlyContiguous,
                   UBool doCompose,
@@ -649,6 +655,9 @@ private:
                                                 UChar32 minNeedDataCP,
                                                 ReorderingBuffer *buffer,
                                                 UErrorCode &errorCode) const;
+
+    enum StopAt { STOP_AT_LIMIT, STOP_AT_DECOMP_BOUNDARY, STOP_AT_COMP_BOUNDARY };
+
     const UChar *decomposeShort(const UChar *src, const UChar *limit,
                                 UBool stopAtCompBoundary, UBool onlyContiguous,
                                 ReorderingBuffer &buffer, UErrorCode &errorCode) const;
@@ -656,7 +665,7 @@ private:
                     ReorderingBuffer &buffer, UErrorCode &errorCode) const;
 
     const uint8_t *decomposeShort(const uint8_t *src, const uint8_t *limit,
-                                  UBool stopAtCompBoundary, UBool onlyContiguous,
+                                  StopAt stopAt, UBool onlyContiguous,
                                   ReorderingBuffer &buffer, UErrorCode &errorCode) const;
 
     static int32_t combine(const uint16_t *list, UChar32 trail);
diff --git a/deps/icu-small/source/common/patternprops.h b/deps/icu-small/source/common/patternprops.h
index b57cdeb6e534f624de7d7ed0237524fa3458771b..95898d580c82f024bdd6f7318bf3e34049d59f93 100644
--- a/deps/icu-small/source/common/patternprops.h
+++ b/deps/icu-small/source/common/patternprops.h
@@ -44,17 +44,17 @@ U_NAMESPACE_BEGIN
 class U_COMMON_API PatternProps {
 public:
     /**
-     * @return TRUE if c is a Pattern_Syntax code point.
+     * @return true if c is a Pattern_Syntax code point.
      */
     static UBool isSyntax(UChar32 c);
 
     /**
-     * @return TRUE if c is a Pattern_Syntax or Pattern_White_Space code point.
+     * @return true if c is a Pattern_Syntax or Pattern_White_Space code point.
      */
     static UBool isSyntaxOrWhiteSpace(UChar32 c);
 
     /**
-     * @return TRUE if c is a Pattern_White_Space character.
+     * @return true if c is a Pattern_White_Space character.
      */
     static UBool isWhiteSpace(UChar32 c);
 
@@ -78,7 +78,7 @@ public:
     /**
      * Tests whether the string contains a "pattern identifier", that is,
      * whether it contains only non-Pattern_White_Space, non-Pattern_Syntax characters.
-     * @return TRUE if there are no Pattern_White_Space or Pattern_Syntax characters in s.
+     * @return true if there are no Pattern_White_Space or Pattern_Syntax characters in s.
      */
     static UBool isIdentifier(const UChar *s, int32_t length);
 
diff --git a/deps/icu-small/source/common/pluralmap.h b/deps/icu-small/source/common/pluralmap.h
index db644093a1fc464aaca86fba50d9389b60ec1e9d..2a14a07af1fcdfba8019c9ff135ec82c662b9422 100644
--- a/deps/icu-small/source/common/pluralmap.h
+++ b/deps/icu-small/source/common/pluralmap.h
@@ -24,7 +24,7 @@ class U_COMMON_API PluralMapBase : public UMemory {
 public:
     /**
      * The names of all the plural categories. NONE is not an actual plural
-     * category, but rather represents the absense of a plural category.
+     * category, but rather represents the absence of a plural category.
      */
     enum Category {
         NONE = -1,
@@ -234,7 +234,7 @@ public:
     }
 
     /**
-     * Returns TRUE if this object equals rhs.
+     * Returns true if this object equals rhs.
      */
     UBool equals(
             const PluralMap<T> &rhs,
@@ -244,13 +244,13 @@ public:
                 continue;
             }
             if (fVariants[i] == NULL || rhs.fVariants[i] == NULL) {
-                return FALSE;
+                return false;
             }
             if (!eqFunc(*fVariants[i], *rhs.fVariants[i])) {
-                return FALSE;
+                return false;
             }
         }
-        return TRUE;
+        return true;
     }
 
 private:
diff --git a/deps/icu-small/source/common/punycode.cpp b/deps/icu-small/source/common/punycode.cpp
index 4f0b9ea9cd385fa097f3338f1a7990290cbadfaa..94d32a66d7678dae5127319df128d1cde3107593 100644
--- a/deps/icu-small/source/common/punycode.cpp
+++ b/deps/icu-small/source/common/punycode.cpp
@@ -107,36 +107,26 @@ digitToBasic(int32_t digit, UBool uppercase) {
 }
 
 /**
- * basicToDigit[] contains the numeric value of a basic code
- * point (for use in representing integers) in the range 0 to
- * BASE-1, or -1 if b is does not represent a value.
+ * @return the numeric value of a basic code point (for use in representing integers)
+ *         in the range 0 to BASE-1, or a negative value if cp is invalid.
  */
-static const int8_t
-basicToDigit[256]={
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
-
-    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-
-    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-};
+static int32_t decodeDigit(int32_t cp) {
+    if(cp<=u'Z') {
+        if(cp<=u'9') {
+            if(cp<u'0') {
+                return -1;
+            } else {
+                return cp-u'0'+26;  // 0..9 -> 26..35
+            }
+        } else {
+            return cp-u'A';  // A-Z -> 0..25
+        }
+    } else if(cp<=u'z') {
+        return cp-'a';  // a..z -> 0..25
+    } else {
+        return -1;
+    }
+}
 
 static inline char
 asciiCaseMap(char b, UBool uppercase) {
@@ -178,15 +168,23 @@ adaptBias(int32_t delta, int32_t length, UBool firstTime) {
     return count+(((BASE-TMIN+1)*delta)/(delta+SKEW));
 }
 
-#define MAX_CP_COUNT    200
+namespace {
 
-U_CFUNC int32_t
+// ICU-13727: Limit input length for n^2 algorithm
+// where well-formed strings are at most 59 characters long.
+constexpr int32_t ENCODE_MAX_CODE_UNITS=1000;
+constexpr int32_t DECODE_MAX_CHARS=2000;
+
+}  // namespace
+
+// encode
+U_CAPI int32_t
 u_strToPunycode(const UChar *src, int32_t srcLength,
                 UChar *dest, int32_t destCapacity,
                 const UBool *caseFlags,
                 UErrorCode *pErrorCode) {
 
-    int32_t cpBuffer[MAX_CP_COUNT];
+    int32_t cpBuffer[ENCODE_MAX_CODE_UNITS];
     int32_t n, delta, handledCPCount, basicLength, destLength, bias, j, m, q, k, t, srcCPCount;
     UChar c, c2;
 
@@ -199,6 +197,10 @@ u_strToPunycode(const UChar *src, int32_t srcLength,
         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
+    if (srcLength>ENCODE_MAX_CODE_UNITS) {
+        *pErrorCode=U_INPUT_TOO_LONG_ERROR;
+        return 0;
+    }
 
     /*
      * Handle the basic code points and
@@ -211,9 +213,8 @@ u_strToPunycode(const UChar *src, int32_t srcLength,
             if((c=src[j])==0) {
                 break;
             }
-            if(srcCPCount==MAX_CP_COUNT) {
-                /* too many input code points */
-                *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
+            if(j>=ENCODE_MAX_CODE_UNITS) {
+                *pErrorCode=U_INPUT_TOO_LONG_ERROR;
                 return 0;
             }
             if(IS_BASIC(c)) {
@@ -243,11 +244,6 @@ u_strToPunycode(const UChar *src, int32_t srcLength,
     } else {
         /* length-specified input */
         for(j=0; j<srcLength; ++j) {
-            if(srcCPCount==MAX_CP_COUNT) {
-                /* too many input code points */
-                *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
-                return 0;
-            }
             c=src[j];
             if(IS_BASIC(c)) {
                 cpBuffer[srcCPCount++]=0;
@@ -312,7 +308,7 @@ u_strToPunycode(const UChar *src, int32_t srcLength,
          * Increase delta enough to advance the decoder's
          * <n,i> state to <m,0>, but guard against overflow:
          */
-        if(m-n>(0x7fffffff-MAX_CP_COUNT-delta)/(handledCPCount+1)) {
+        if(m-n>(0x7fffffff-handledCPCount-delta)/(handledCPCount+1)) {
             *pErrorCode=U_INTERNAL_PROGRAM_ERROR;
             return 0;
         }
@@ -373,7 +369,8 @@ u_strToPunycode(const UChar *src, int32_t srcLength,
     return u_terminateUChars(dest, destCapacity, destLength, pErrorCode);
 }
 
-U_CFUNC int32_t
+// decode
+U_CAPI int32_t
 u_strFromPunycode(const UChar *src, int32_t srcLength,
                   UChar *dest, int32_t destCapacity,
                   UBool *caseFlags,
@@ -395,6 +392,10 @@ u_strFromPunycode(const UChar *src, int32_t srcLength,
     if(srcLength==-1) {
         srcLength=u_strlen(src);
     }
+    if (srcLength>DECODE_MAX_CHARS) {
+        *pErrorCode=U_INPUT_TOO_LONG_ERROR;
+        return 0;
+    }
 
     /*
      * Handle the basic code points:
@@ -455,7 +456,7 @@ u_strFromPunycode(const UChar *src, int32_t srcLength,
                 return 0;
             }
 
-            digit=basicToDigit[(uint8_t)src[in++]];
+            digit=decodeDigit(src[in++]);
             if(digit<0) {
                 *pErrorCode=U_INVALID_CHAR_FOUND;
                 return 0;
diff --git a/deps/icu-small/source/common/punycode.h b/deps/icu-small/source/common/punycode.h
index 5d8a243175cca30e892c4e5c6f04f58a17b211f4..9e28f770c407ec5d349405b874588efb60d140c4 100644
--- a/deps/icu-small/source/common/punycode.h
+++ b/deps/icu-small/source/common/punycode.h
@@ -50,7 +50,7 @@ http://www.nicemice.net/amc/
  * @param caseFlags Vector of boolean values, one per input UChar,
  *                  indicating that the corresponding character is to be
  *                  marked for the decoder optionally
- *                  uppercasing (TRUE) or lowercasing (FALSE)
+ *                  uppercasing (true) or lowercasing (false)
  *                  the character.
  *                  ASCII characters are output directly in the case as marked.
  *                  Flags corresponding to trail surrogates are ignored.
@@ -65,7 +65,7 @@ http://www.nicemice.net/amc/
  *
  * @see u_strFromPunycode
  */
-U_CFUNC int32_t
+U_CAPI int32_t
 u_strToPunycode(const UChar *src, int32_t srcLength,
                 UChar *dest, int32_t destCapacity,
                 const UBool *caseFlags,
@@ -83,10 +83,10 @@ u_strToPunycode(const UChar *src, int32_t srcLength,
  *                     and of caseFlags in numbers of UBools.
  * @param caseFlags Output array for case flags as
  *                  defined by the Punycode string.
- *                  The caller should uppercase (TRUE) or lowercase (FASLE)
+ *                  The caller should uppercase (true) or lowercase (FASLE)
  *                  the corresponding character in dest.
  *                  For supplementary characters, only the lead surrogate
- *                  is marked, and FALSE is stored for the trail surrogate.
+ *                  is marked, and false is stored for the trail surrogate.
  *                  This is redundant and not necessary for ASCII characters
  *                  because they are already in the case indicated.
  *                  Can be NULL if the case flags are not needed.
@@ -100,7 +100,7 @@ u_strToPunycode(const UChar *src, int32_t srcLength,
  *
  * @see u_strToPunycode
  */
-U_CFUNC int32_t
+U_CAPI int32_t
 u_strFromPunycode(const UChar *src, int32_t srcLength,
                   UChar *dest, int32_t destCapacity,
                   UBool *caseFlags,
diff --git a/deps/icu-small/source/common/putil.cpp b/deps/icu-small/source/common/putil.cpp
index 51c2473c982d5daedad0e71c8b763dbc51ef4788..ffcbbcce59b4018ca47192462eb405490c545f80 100644
--- a/deps/icu-small/source/common/putil.cpp
+++ b/deps/icu-small/source/common/putil.cpp
@@ -81,7 +81,7 @@
 #include <float.h>
 
 #ifndef U_COMMON_IMPLEMENTATION
-#error U_COMMON_IMPLEMENTATION not set - must be set for all ICU source files in common/ - see http://userguide.icu-project.org/howtouseicu
+#error U_COMMON_IMPLEMENTATION not set - must be set for all ICU source files in common/ - see https://unicode-org.github.io/icu/userguide/howtouseicu
 #endif
 
 
@@ -118,11 +118,15 @@
 #       ifndef _XPG4_2
 #           define _XPG4_2
 #       endif
+#   elif U_PLATFORM == U_PF_ANDROID
+#       include <sys/system_properties.h>
+#       include <dlfcn.h>
 #   endif
 #elif U_PLATFORM == U_PF_QNX
 #   include <sys/neutrino.h>
 #endif
 
+
 /*
  * Only include langinfo.h if we have a way to get the codeset. If we later
  * depend on more feature, we can test on U_HAVE_NL_LANGINFO.
@@ -1043,9 +1047,53 @@ static char* searchForTZFile(const char* path, DefaultTZInfo* tzInfo) {
 }
 #endif
 
+#if U_PLATFORM == U_PF_ANDROID
+typedef int(system_property_read_callback)(const prop_info* info,
+                                           void (*callback)(void* cookie,
+                                                            const char* name,
+                                                            const char* value,
+                                                            uint32_t serial),
+                                           void* cookie);
+typedef int(system_property_get)(const char*, char*);
+
+static char gAndroidTimeZone[PROP_VALUE_MAX] = { '\0' };
+
+static void u_property_read(void* cookie, const char* name, const char* value,
+                            uint32_t serial) {
+    uprv_strcpy((char* )cookie, value);
+}
+#endif
+
 U_CAPI void U_EXPORT2
-uprv_tzname_clear_cache()
+uprv_tzname_clear_cache(void)
 {
+#if U_PLATFORM == U_PF_ANDROID
+    /* Android's timezone is stored in system property. */
+    gAndroidTimeZone[0] = '\0';
+    void* libc = dlopen("libc.so", RTLD_NOLOAD);
+    if (libc) {
+        /* Android API 26+ has new API to get system property and old API
+         * (__system_property_get) is deprecated */
+        system_property_read_callback* property_read_callback =
+            (system_property_read_callback*)dlsym(
+                libc, "__system_property_read_callback");
+        if (property_read_callback) {
+            const prop_info* info =
+                __system_property_find("persist.sys.timezone");
+            if (info) {
+                property_read_callback(info, &u_property_read, gAndroidTimeZone);
+            }
+        } else {
+            system_property_get* property_get =
+                (system_property_get*)dlsym(libc, "__system_property_get");
+            if (property_get) {
+                property_get("persist.sys.timezone", gAndroidTimeZone);
+            }
+        }
+        dlclose(libc);
+    }
+#endif
+
 #if defined(CHECK_LOCALTIME_LINK) && !defined(DEBUG_SKIP_LOCALTIME_LINK)
     gTimeZoneBufferPtr = NULL;
 #endif
@@ -1084,10 +1132,14 @@ uprv_tzname(int n)
 
 /* This code can be temporarily disabled to test tzname resolution later on. */
 #ifndef DEBUG_TZNAME
+#if U_PLATFORM == U_PF_ANDROID
+    tzid = gAndroidTimeZone;
+#else
     tzid = getenv("TZ");
+#endif
     if (tzid != NULL && isValidOlsonID(tzid)
 #if U_PLATFORM == U_PF_SOLARIS
-    /* When TZ equals localtime on Solaris, check the /etc/localtime file. */
+    /* Don't misinterpret TZ "localtime" on Solaris as a time zone name. */
         && uprv_strcmp(tzid, TZ_ENV_CHECK) != 0
 #endif
     ) {
@@ -1309,7 +1361,7 @@ uprv_pathIsAbsolute(const char *path)
 
 /* Backup setting of ICU_DATA_DIR_PREFIX_ENV_VAR
    (needed for some Darwin ICU build environments) */
-#if U_PLATFORM_IS_DARWIN_BASED && TARGET_OS_SIMULATOR
+#if U_PLATFORM_IS_DARWIN_BASED && defined(TARGET_OS_SIMULATOR) && TARGET_OS_SIMULATOR
 # if !defined(ICU_DATA_DIR_PREFIX_ENV_VAR)
 #  define ICU_DATA_DIR_PREFIX_ENV_VAR "IPHONE_SIMULATOR_ROOT"
 # endif
@@ -2299,7 +2351,7 @@ u_getVersion(UVersionInfo versionArray) {
 #include <dlfcn.h>
 #endif /* HAVE_DLFCN_H */
 
-U_INTERNAL void * U_EXPORT2
+U_CAPI void * U_EXPORT2
 uprv_dl_open(const char *libName, UErrorCode *status) {
   void *ret = NULL;
   if(U_FAILURE(*status)) return ret;
@@ -2313,13 +2365,13 @@ uprv_dl_open(const char *libName, UErrorCode *status) {
   return ret;
 }
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uprv_dl_close(void *lib, UErrorCode *status) {
   if(U_FAILURE(*status)) return;
   dlclose(lib);
 }
 
-U_INTERNAL UVoidFunction* U_EXPORT2
+U_CAPI UVoidFunction* U_EXPORT2
 uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) {
   union {
       UVoidFunction *fp;
@@ -2342,7 +2394,7 @@ uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) {
 /* Windows API implementation. */
 // Note: UWP does not expose/allow these APIs, so the UWP version gets the null implementation. */
 
-U_INTERNAL void * U_EXPORT2
+U_CAPI void * U_EXPORT2
 uprv_dl_open(const char *libName, UErrorCode *status) {
   HMODULE lib = NULL;
 
@@ -2357,7 +2409,7 @@ uprv_dl_open(const char *libName, UErrorCode *status) {
   return (void*)lib;
 }
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uprv_dl_close(void *lib, UErrorCode *status) {
   HMODULE handle = (HMODULE)lib;
   if(U_FAILURE(*status)) return;
@@ -2367,7 +2419,7 @@ uprv_dl_close(void *lib, UErrorCode *status) {
   return;
 }
 
-U_INTERNAL UVoidFunction* U_EXPORT2
+U_CAPI UVoidFunction* U_EXPORT2
 uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) {
   HMODULE handle = (HMODULE)lib;
   UVoidFunction* addr = NULL;
@@ -2392,7 +2444,7 @@ uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) {
 
 /* No dynamic loading, null (nonexistent) implementation. */
 
-U_INTERNAL void * U_EXPORT2
+U_CAPI void * U_EXPORT2
 uprv_dl_open(const char *libName, UErrorCode *status) {
     (void)libName;
     if(U_FAILURE(*status)) return NULL;
@@ -2400,7 +2452,7 @@ uprv_dl_open(const char *libName, UErrorCode *status) {
     return NULL;
 }
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uprv_dl_close(void *lib, UErrorCode *status) {
     (void)lib;
     if(U_FAILURE(*status)) return;
@@ -2408,7 +2460,7 @@ uprv_dl_close(void *lib, UErrorCode *status) {
     return;
 }
 
-U_INTERNAL UVoidFunction* U_EXPORT2
+U_CAPI UVoidFunction* U_EXPORT2
 uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) {
   (void)lib;
   (void)sym;
diff --git a/deps/icu-small/source/common/putilimp.h b/deps/icu-small/source/common/putilimp.h
index 2e9fbcc4837cd800b39f291d4376ebeb583ee94b..5b95a68418c4285c486f2381207e1d9bc25f5ec0 100644
--- a/deps/icu-small/source/common/putilimp.h
+++ b/deps/icu-small/source/common/putilimp.h
@@ -210,93 +210,93 @@ typedef size_t uintptr_t;
  * Floating point utility to determine if a double is Not a Number (NaN).
  * @internal
  */
-U_INTERNAL UBool   U_EXPORT2 uprv_isNaN(double d);
+U_CAPI UBool   U_EXPORT2 uprv_isNaN(double d);
 /**
  * Floating point utility to determine if a double has an infinite value.
  * @internal
  */
-U_INTERNAL UBool   U_EXPORT2 uprv_isInfinite(double d);
+U_CAPI UBool   U_EXPORT2 uprv_isInfinite(double d);
 /**
  * Floating point utility to determine if a double has a positive infinite value.
  * @internal
  */
-U_INTERNAL UBool   U_EXPORT2 uprv_isPositiveInfinity(double d);
+U_CAPI UBool   U_EXPORT2 uprv_isPositiveInfinity(double d);
 /**
  * Floating point utility to determine if a double has a negative infinite value.
  * @internal
  */
-U_INTERNAL UBool   U_EXPORT2 uprv_isNegativeInfinity(double d);
+U_CAPI UBool   U_EXPORT2 uprv_isNegativeInfinity(double d);
 /**
  * Floating point utility that returns a Not a Number (NaN) value.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_getNaN(void);
+U_CAPI double  U_EXPORT2 uprv_getNaN(void);
 /**
  * Floating point utility that returns an infinite value.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_getInfinity(void);
+U_CAPI double  U_EXPORT2 uprv_getInfinity(void);
 
 /**
  * Floating point utility to truncate a double.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_trunc(double d);
+U_CAPI double  U_EXPORT2 uprv_trunc(double d);
 /**
  * Floating point utility to calculate the floor of a double.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_floor(double d);
+U_CAPI double  U_EXPORT2 uprv_floor(double d);
 /**
  * Floating point utility to calculate the ceiling of a double.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_ceil(double d);
+U_CAPI double  U_EXPORT2 uprv_ceil(double d);
 /**
  * Floating point utility to calculate the absolute value of a double.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_fabs(double d);
+U_CAPI double  U_EXPORT2 uprv_fabs(double d);
 /**
  * Floating point utility to calculate the fractional and integer parts of a double.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_modf(double d, double* pinteger);
+U_CAPI double  U_EXPORT2 uprv_modf(double d, double* pinteger);
 /**
  * Floating point utility to calculate the remainder of a double divided by another double.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_fmod(double d, double y);
+U_CAPI double  U_EXPORT2 uprv_fmod(double d, double y);
 /**
  * Floating point utility to calculate d to the power of exponent (d^exponent).
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_pow(double d, double exponent);
+U_CAPI double  U_EXPORT2 uprv_pow(double d, double exponent);
 /**
  * Floating point utility to calculate 10 to the power of exponent (10^exponent).
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_pow10(int32_t exponent);
+U_CAPI double  U_EXPORT2 uprv_pow10(int32_t exponent);
 /**
  * Floating point utility to calculate the maximum value of two doubles.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_fmax(double d, double y);
+U_CAPI double  U_EXPORT2 uprv_fmax(double d, double y);
 /**
  * Floating point utility to calculate the minimum value of two doubles.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_fmin(double d, double y);
+U_CAPI double  U_EXPORT2 uprv_fmin(double d, double y);
 /**
  * Private utility to calculate the maximum value of two integers.
  * @internal
  */
-U_INTERNAL int32_t U_EXPORT2 uprv_max(int32_t d, int32_t y);
+U_CAPI int32_t U_EXPORT2 uprv_max(int32_t d, int32_t y);
 /**
  * Private utility to calculate the minimum value of two integers.
  * @internal
  */
-U_INTERNAL int32_t U_EXPORT2 uprv_min(int32_t d, int32_t y);
+U_CAPI int32_t U_EXPORT2 uprv_min(int32_t d, int32_t y);
 
 #if U_IS_BIG_ENDIAN
 #   define uprv_isNegative(number) (*((signed char *)&(number))<0)
@@ -309,13 +309,13 @@ U_INTERNAL int32_t U_EXPORT2 uprv_min(int32_t d, int32_t y);
  * type of arbitrary bit length.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_maxMantissa(void);
+U_CAPI double  U_EXPORT2 uprv_maxMantissa(void);
 
 /**
  * Floating point utility to calculate the logarithm of a double.
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_log(double d);
+U_CAPI double  U_EXPORT2 uprv_log(double d);
 
 /**
  * Does common notion of rounding e.g. uprv_floor(x + 0.5);
@@ -323,7 +323,7 @@ U_INTERNAL double  U_EXPORT2 uprv_log(double d);
  * @return the rounded double
  * @internal
  */
-U_INTERNAL double  U_EXPORT2 uprv_round(double x);
+U_CAPI double  U_EXPORT2 uprv_round(double x);
 
 /**
  * Adds the signed integers a and b, storing the result in res.
@@ -336,7 +336,7 @@ U_INTERNAL double  U_EXPORT2 uprv_round(double x);
  * @return true if overflow occurred; false if no overflow occurred.
  * @internal
  */
-U_INTERNAL UBool U_EXPORT2 uprv_add32_overflow(int32_t a, int32_t b, int32_t* res);
+U_CAPI UBool U_EXPORT2 uprv_add32_overflow(int32_t a, int32_t b, int32_t* res);
 
 /**
  * Multiplies the signed integers a and b, storing the result in res.
@@ -349,7 +349,7 @@ U_INTERNAL UBool U_EXPORT2 uprv_add32_overflow(int32_t a, int32_t b, int32_t* re
  * @return true if overflow occurred; false if no overflow occurred.
  * @internal
  */
-U_INTERNAL UBool U_EXPORT2 uprv_mul32_overflow(int32_t a, int32_t b, int32_t* res);
+U_CAPI UBool U_EXPORT2 uprv_mul32_overflow(int32_t a, int32_t b, int32_t* res);
 
 #if 0
 /**
@@ -359,7 +359,7 @@ U_INTERNAL UBool U_EXPORT2 uprv_mul32_overflow(int32_t a, int32_t b, int32_t* re
  * @return the number of digits after the decimal point in a double number x.
  * @internal
  */
-/*U_INTERNAL int32_t  U_EXPORT2 uprv_digitsAfterDecimal(double x);*/
+/*U_CAPI int32_t  U_EXPORT2 uprv_digitsAfterDecimal(double x);*/
 #endif
 
 #if !U_CHARSET_IS_UTF8
@@ -371,7 +371,7 @@ U_INTERNAL UBool U_EXPORT2 uprv_mul32_overflow(int32_t a, int32_t b, int32_t* re
  * @return the default codepage for this platform
  * @internal
  */
-U_INTERNAL const char*  U_EXPORT2 uprv_getDefaultCodepage(void);
+U_CAPI const char*  U_EXPORT2 uprv_getDefaultCodepage(void);
 #endif
 
 /**
@@ -383,7 +383,7 @@ U_INTERNAL const char*  U_EXPORT2 uprv_getDefaultCodepage(void);
  * @return the default locale ID string
  * @internal
  */
-U_INTERNAL const char*  U_EXPORT2 uprv_getDefaultLocaleID(void);
+U_CAPI const char*  U_EXPORT2 uprv_getDefaultLocaleID(void);
 
 /**
  * Time zone utilities
@@ -417,7 +417,7 @@ U_INTERNAL const char*  U_EXPORT2 uprv_getDefaultLocaleID(void);
  * Date/Time application.
  * @internal
  */
-U_INTERNAL void     U_EXPORT2 uprv_tzset(void);
+U_CAPI void     U_EXPORT2 uprv_tzset(void);
 
 /**
  * Difference in seconds between coordinated universal
@@ -425,7 +425,7 @@ U_INTERNAL void     U_EXPORT2 uprv_tzset(void);
  * @return the difference in seconds between coordinated universal time and local time.
  * @internal
  */
-U_INTERNAL int32_t  U_EXPORT2 uprv_timezone(void);
+U_CAPI int32_t  U_EXPORT2 uprv_timezone(void);
 
 /**
  *   tzname(0)  Three-letter time-zone name derived from TZ environment
@@ -435,13 +435,13 @@ U_INTERNAL int32_t  U_EXPORT2 uprv_timezone(void);
  *              tzname(1) is an empty string.
  * @internal
  */
-U_INTERNAL const char* U_EXPORT2 uprv_tzname(int n);
+U_CAPI const char* U_EXPORT2 uprv_tzname(int n);
 
 /**
  * Reset the global tzname cache.
  * @internal
  */
-U_INTERNAL void uprv_tzname_clear_cache();
+U_CAPI void uprv_tzname_clear_cache(void);
 
 /**
  * Get UTC (GMT) time measured in milliseconds since 0:00 on 1/1/1970.
@@ -449,7 +449,7 @@ U_INTERNAL void uprv_tzname_clear_cache();
  * @return the UTC time measured in milliseconds
  * @internal
  */
-U_INTERNAL UDate U_EXPORT2 uprv_getUTCtime(void);
+U_CAPI UDate U_EXPORT2 uprv_getUTCtime(void);
 
 /**
  * Get UTC (GMT) time measured in milliseconds since 0:00 on 1/1/1970.
@@ -458,15 +458,15 @@ U_INTERNAL UDate U_EXPORT2 uprv_getUTCtime(void);
  * @return the UTC time measured in milliseconds
  * @internal
  */
-U_INTERNAL UDate U_EXPORT2 uprv_getRawUTCtime(void);
+U_CAPI UDate U_EXPORT2 uprv_getRawUTCtime(void);
 
 /**
  * Determine whether a pathname is absolute or not, as defined by the platform.
  * @param path Pathname to test
- * @return TRUE if the path is absolute
+ * @return true if the path is absolute
  * @internal (ICU 3.0)
  */
-U_INTERNAL UBool U_EXPORT2 uprv_pathIsAbsolute(const char *path);
+U_CAPI UBool U_EXPORT2 uprv_pathIsAbsolute(const char *path);
 
 /**
  * Use U_MAX_PTR instead of this function.
@@ -474,7 +474,7 @@ U_INTERNAL UBool U_EXPORT2 uprv_pathIsAbsolute(const char *path);
  * @return the largest possible pointer greater than the base
  * @internal (ICU 3.8)
  */
-U_INTERNAL void * U_EXPORT2 uprv_maximumPtr(void *base);
+U_CAPI void * U_EXPORT2 uprv_maximumPtr(void *base);
 
 /**
  * Maximum value of a (void*) - use to indicate the limit of an 'infinite' buffer.
@@ -527,7 +527,7 @@ U_INTERNAL void * U_EXPORT2 uprv_maximumPtr(void *base);
  * on the destination pointer and capacity cannot overflow.
  *
  * The pinned capacity must fulfill the following conditions (for positive capacities):
- *   - dest + capacity is a valid pointer according to the machine arcitecture (AS/400, 64-bit, etc.)
+ *   - dest + capacity is a valid pointer according to the machine architecture (AS/400, 64-bit, etc.)
  *   - (dest + capacity) >= dest
  *   - The size (in bytes) of T[capacity] does not exceed 0x7fffffff
  *
@@ -572,26 +572,26 @@ typedef void (UVoidFunction)(void);
  * Load a library
  * @internal (ICU 4.4)
  */
-U_INTERNAL void * U_EXPORT2 uprv_dl_open(const char *libName, UErrorCode *status);
+U_CAPI void * U_EXPORT2 uprv_dl_open(const char *libName, UErrorCode *status);
 
 /**
  * Close a library
  * @internal (ICU 4.4)
  */
-U_INTERNAL void U_EXPORT2 uprv_dl_close( void *lib, UErrorCode *status);
+U_CAPI void U_EXPORT2 uprv_dl_close( void *lib, UErrorCode *status);
 
 /**
  * Extract a symbol from a library (function)
  * @internal (ICU 4.8)
  */
-U_INTERNAL UVoidFunction* U_EXPORT2 uprv_dlsym_func( void *lib, const char *symbolName, UErrorCode *status);
+U_CAPI UVoidFunction* U_EXPORT2 uprv_dlsym_func( void *lib, const char *symbolName, UErrorCode *status);
 
 /**
  * Extract a symbol from a library (function)
  * Not implemented, no clients.
  * @internal
  */
-/* U_INTERNAL void * U_EXPORT2 uprv_dlsym_data( void *lib, const char *symbolName, UErrorCode *status); */
+/* U_CAPI void * U_EXPORT2 uprv_dlsym_data( void *lib, const char *symbolName, UErrorCode *status); */
 
 #endif
 
diff --git a/deps/icu-small/source/common/rbbi.cpp b/deps/icu-small/source/common/rbbi.cpp
index 43ba58ba9e657723cefbc758eecc1264bfd6274a..b821ca4463936985f5d2079cb283afc0859aaf49 100644
--- a/deps/icu-small/source/common/rbbi.cpp
+++ b/deps/icu-small/source/common/rbbi.cpp
@@ -68,10 +68,18 @@ RuleBasedBreakIterator::RuleBasedBreakIterator(RBBIDataHeader* data, UErrorCode
     init(status);
     fData = new RBBIDataWrapper(data, status); // status checked in constructor
     if (U_FAILURE(status)) {return;}
-    if(fData == 0) {
+    if(fData == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
+    if (fData->fForwardTable->fLookAheadResultsSize > 0) {
+        fLookAheadMatches = static_cast<int32_t *>(
+            uprv_malloc(fData->fForwardTable->fLookAheadResultsSize * sizeof(int32_t)));
+        if (fLookAheadMatches == nullptr) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+    }
 }
 
 //
@@ -98,10 +106,18 @@ RuleBasedBreakIterator::RuleBasedBreakIterator(const uint8_t *compiledRules,
     }
     fData = new RBBIDataWrapper(data, RBBIDataWrapper::kDontAdopt, status);
     if (U_FAILURE(status)) {return;}
-    if(fData == 0) {
+    if(fData == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
+    if (fData->fForwardTable->fLookAheadResultsSize > 0) {
+        fLookAheadMatches = static_cast<int32_t *>(
+            uprv_malloc(fData->fForwardTable->fLookAheadResultsSize * sizeof(int32_t)));
+        if (fLookAheadMatches == nullptr) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+    }
 }
 
 
@@ -117,10 +133,18 @@ RuleBasedBreakIterator::RuleBasedBreakIterator(UDataMemory* udm, UErrorCode &sta
     init(status);
     fData = new RBBIDataWrapper(udm, status); // status checked in constructor
     if (U_FAILURE(status)) {return;}
-    if(fData == 0) {
+    if(fData == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
+    if (fData->fForwardTable->fLookAheadResultsSize > 0) {
+        fLookAheadMatches = static_cast<int32_t *>(
+            uprv_malloc(fData->fForwardTable->fLookAheadResultsSize * sizeof(int32_t)));
+        if (fLookAheadMatches == nullptr) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+    }
 }
 
 
@@ -188,30 +212,34 @@ RuleBasedBreakIterator::~RuleBasedBreakIterator() {
         // fCharIter was adopted from the outside.
         delete fCharIter;
     }
-    fCharIter = NULL;
+    fCharIter = nullptr;
 
     utext_close(&fText);
 
-    if (fData != NULL) {
+    if (fData != nullptr) {
         fData->removeReference();
-        fData = NULL;
+        fData = nullptr;
     }
     delete fBreakCache;
-    fBreakCache = NULL;
+    fBreakCache = nullptr;
 
     delete fDictionaryCache;
-    fDictionaryCache = NULL;
+    fDictionaryCache = nullptr;
 
     delete fLanguageBreakEngines;
-    fLanguageBreakEngines = NULL;
+    fLanguageBreakEngines = nullptr;
 
     delete fUnhandledBreakEngine;
-    fUnhandledBreakEngine = NULL;
+    fUnhandledBreakEngine = nullptr;
+
+    uprv_free(fLookAheadMatches);
+    fLookAheadMatches = nullptr;
 }
 
 /**
  * Assignment operator.  Sets this iterator to have the same behavior,
  * and iterate over the same text, as the one passed in.
+ * TODO: needs better handling of memory allocation errors.
  */
 RuleBasedBreakIterator&
 RuleBasedBreakIterator::operator=(const RuleBasedBreakIterator& that) {
@@ -252,6 +280,14 @@ RuleBasedBreakIterator::operator=(const RuleBasedBreakIterator& that) {
         fData = that.fData->addReference();
     }
 
+    uprv_free(fLookAheadMatches);
+    fLookAheadMatches = nullptr;
+    if (fData && fData->fForwardTable->fLookAheadResultsSize > 0) {
+        fLookAheadMatches = static_cast<int32_t *>(
+            uprv_malloc(fData->fForwardTable->fLookAheadResultsSize * sizeof(int32_t)));
+    }
+
+
     fPosition = that.fPosition;
     fRuleStatusIndex = that.fRuleStatusIndex;
     fDone = that.fDone;
@@ -275,16 +311,17 @@ RuleBasedBreakIterator::operator=(const RuleBasedBreakIterator& that) {
 //
 //-----------------------------------------------------------------------------
 void RuleBasedBreakIterator::init(UErrorCode &status) {
-    fCharIter             = NULL;
-    fData                 = NULL;
+    fCharIter             = nullptr;
+    fData                 = nullptr;
     fPosition             = 0;
     fRuleStatusIndex      = 0;
     fDone                 = false;
     fDictionaryCharCount  = 0;
-    fLanguageBreakEngines = NULL;
-    fUnhandledBreakEngine = NULL;
-    fBreakCache           = NULL;
-    fDictionaryCache      = NULL;
+    fLanguageBreakEngines = nullptr;
+    fUnhandledBreakEngine = nullptr;
+    fBreakCache           = nullptr;
+    fDictionaryCache      = nullptr;
+    fLookAheadMatches     = nullptr;
 
     // Note: IBM xlC is unable to assign or initialize member fText from UTEXT_INITIALIZER.
     // fText                 = UTEXT_INITIALIZER;
@@ -700,50 +737,53 @@ enum RBBIRunMode {
 };
 
 
-// Map from look-ahead break states (corresponds to rules) to boundary positions.
-// Allows multiple lookahead break rules to be in flight at the same time.
+// Wrapper functions to select the appropriate handleNext() or handleSafePrevious()
+// instantiation, based on whether an 8 or 16 bit table is required.
 //
-// This is a temporary approach for ICU 57. A better fix is to make the look-ahead numbers
-// in the state table be sequential, then we can just index an array. And the
-// table could also tell us in advance how big that array needs to be.
-//
-// Before ICU 57 there was just a single simple variable for a look-ahead match that
-// was in progress. Two rules at once did not work.
-
-static const int32_t kMaxLookaheads = 8;
-struct LookAheadResults {
-    int32_t    fUsedSlotLimit;
-    int32_t    fPositions[8];
-    int16_t    fKeys[8];
+// These Trie access functions will be inlined within the handleNext()/Previous() instantions.
+static inline uint16_t TrieFunc8(const UCPTrie *trie, UChar32 c) {
+    return UCPTRIE_FAST_GET(trie, UCPTRIE_8, c);
+}
 
-    LookAheadResults() : fUsedSlotLimit(0), fPositions(), fKeys() {}
+static inline uint16_t TrieFunc16(const UCPTrie *trie, UChar32 c) {
+    return UCPTRIE_FAST_GET(trie, UCPTRIE_16, c);
+}
 
-    int32_t getPosition(int16_t key) {
-        for (int32_t i=0; i<fUsedSlotLimit; ++i) {
-            if (fKeys[i] == key) {
-                return fPositions[i];
-            }
+int32_t RuleBasedBreakIterator::handleNext() {
+    const RBBIStateTable *statetable = fData->fForwardTable;
+    bool use8BitsTrie = ucptrie_getValueWidth(fData->fTrie) == UCPTRIE_VALUE_BITS_8;
+    if (statetable->fFlags & RBBI_8BITS_ROWS) {
+        if (use8BitsTrie) {
+            return handleNext<RBBIStateTableRow8, TrieFunc8>();
+        } else {
+            return handleNext<RBBIStateTableRow8, TrieFunc16>();
+        }
+    } else {
+        if (use8BitsTrie) {
+            return handleNext<RBBIStateTableRow16, TrieFunc8>();
+        } else {
+            return handleNext<RBBIStateTableRow16, TrieFunc16>();
         }
-        UPRV_UNREACHABLE;
     }
+}
 
-    void setPosition(int16_t key, int32_t position) {
-        int32_t i;
-        for (i=0; i<fUsedSlotLimit; ++i) {
-            if (fKeys[i] == key) {
-                fPositions[i] = position;
-                return;
-            }
+int32_t RuleBasedBreakIterator::handleSafePrevious(int32_t fromPosition) {
+    const RBBIStateTable *statetable = fData->fReverseTable;
+    bool use8BitsTrie = ucptrie_getValueWidth(fData->fTrie) == UCPTRIE_VALUE_BITS_8;
+    if (statetable->fFlags & RBBI_8BITS_ROWS) {
+        if (use8BitsTrie) {
+            return handleSafePrevious<RBBIStateTableRow8, TrieFunc8>(fromPosition);
+        } else {
+            return handleSafePrevious<RBBIStateTableRow8, TrieFunc16>(fromPosition);
         }
-        if (i >= kMaxLookaheads) {
-            UPRV_UNREACHABLE;
+    } else {
+        if (use8BitsTrie) {
+            return handleSafePrevious<RBBIStateTableRow16, TrieFunc8>(fromPosition);
+        } else {
+            return handleSafePrevious<RBBIStateTableRow16, TrieFunc16>(fromPosition);
         }
-        fKeys[i] = key;
-        fPositions[i] = position;
-        U_ASSERT(fUsedSlotLimit == i);
-        fUsedSlotLimit = i + 1;
     }
-};
+}
 
 
 //-----------------------------------------------------------------------------------
@@ -752,26 +792,27 @@ struct LookAheadResults {
 //     Run the state machine to find a boundary
 //
 //-----------------------------------------------------------------------------------
+template <typename RowType, RuleBasedBreakIterator::PTrieFunc trieFunc>
 int32_t RuleBasedBreakIterator::handleNext() {
     int32_t             state;
     uint16_t            category        = 0;
     RBBIRunMode         mode;
 
-    RBBIStateTableRow  *row;
+    RowType             *row;
     UChar32             c;
-    LookAheadResults    lookAheadMatches;
     int32_t             result             = 0;
     int32_t             initialPosition    = 0;
     const RBBIStateTable *statetable       = fData->fForwardTable;
     const char         *tableData          = statetable->fTableData;
     uint32_t            tableRowLen        = statetable->fRowLen;
+    uint32_t            dictStart          = statetable->fDictCategoriesStart;
     #ifdef RBBI_DEBUG
         if (gTrace) {
             RBBIDebugPuts("Handle Next   pos   char  state category");
         }
     #endif
 
-    // handleNext alway sets the break tag value.
+    // handleNext always sets the break tag value.
     // Set the default for it.
     fRuleStatusIndex = 0;
 
@@ -789,7 +830,7 @@ int32_t RuleBasedBreakIterator::handleNext() {
 
     //  Set the initial state for the state machine
     state = START_STATE;
-    row = (RBBIStateTableRow *)
+    row = (RowType *)
             //(statetable->fTableData + (statetable->fRowLen * state));
             (tableData + tableRowLen * state);
 
@@ -825,21 +866,8 @@ int32_t RuleBasedBreakIterator::handleNext() {
         if (mode == RBBI_RUN) {
             // look up the current character's character category, which tells us
             // which column in the state table to look at.
-            // Note:  the 16 in UTRIE_GET16 refers to the size of the data being returned,
-            //        not the size of the character going in, which is a UChar32.
-            //
-            category = UTRIE2_GET16(fData->fTrie, c);
-
-            // Check the dictionary bit in the character's category.
-            //    Counter is only used by dictionary based iteration.
-            //    Chars that need to be handled by a dictionary have a flag bit set
-            //    in their category values.
-            //
-            if ((category & 0x4000) != 0)  {
-                fDictionaryCharCount++;
-                //  And off the dictionary flag bit.
-                category &= ~0x4000;
-            }
+            category = trieFunc(fData->fTrie, c);
+            fDictionaryCharCount += (category >= dictStart);
         }
 
        #ifdef RBBI_DEBUG
@@ -860,25 +888,24 @@ int32_t RuleBasedBreakIterator::handleNext() {
         // fNextState is a variable-length array.
         U_ASSERT(category<fData->fHeader->fCatCount);
         state = row->fNextState[category];  /*Not accessing beyond memory*/
-        row = (RBBIStateTableRow *)
+        row = (RowType *)
             // (statetable->fTableData + (statetable->fRowLen * state));
             (tableData + tableRowLen * state);
 
 
-        if (row->fAccepting == -1) {
+        uint16_t accepting = row->fAccepting;
+        if (accepting == ACCEPTING_UNCONDITIONAL) {
             // Match found, common case.
             if (mode != RBBI_START) {
                 result = (int32_t)UTEXT_GETNATIVEINDEX(&fText);
             }
-            fRuleStatusIndex = row->fTagIdx;   // Remember the break status (tag) values.
-        }
-
-        int16_t completedRule = row->fAccepting;
-        if (completedRule > 0) {
+            fRuleStatusIndex = row->fTagsIdx;   // Remember the break status (tag) values.
+        } else if (accepting > ACCEPTING_UNCONDITIONAL) {
             // Lookahead match is completed.
-            int32_t lookaheadResult = lookAheadMatches.getPosition(completedRule);
+            U_ASSERT(accepting < fData->fForwardTable->fLookAheadResultsSize);
+            int32_t lookaheadResult = fLookAheadMatches[accepting];
             if (lookaheadResult >= 0) {
-                fRuleStatusIndex = row->fTagIdx;
+                fRuleStatusIndex = row->fTagsIdx;
                 fPosition = lookaheadResult;
                 return lookaheadResult;
             }
@@ -890,10 +917,12 @@ int32_t RuleBasedBreakIterator::handleNext() {
         //       This would enable hard-break rules with no following context.
         //       But there are line break test failures when trying this. Investigate.
         //       Issue ICU-20837
-        int16_t rule = row->fLookAhead;
-        if (rule != 0) {
+        uint16_t rule = row->fLookAhead;
+        U_ASSERT(rule == 0 || rule > ACCEPTING_UNCONDITIONAL);
+        U_ASSERT(rule == 0 || rule < fData->fForwardTable->fLookAheadResultsSize);
+        if (rule > ACCEPTING_UNCONDITIONAL) {
             int32_t  pos = (int32_t)UTEXT_GETNATIVEINDEX(&fText);
-            lookAheadMatches.setPosition(rule, pos);
+            fLookAheadMatches[rule] = pos;
         }
 
         if (state == STOP_STATE) {
@@ -948,10 +977,12 @@ int32_t RuleBasedBreakIterator::handleNext() {
 //      because the safe table does not require as many options.
 //
 //-----------------------------------------------------------------------------------
+template <typename RowType, RuleBasedBreakIterator::PTrieFunc trieFunc>
 int32_t RuleBasedBreakIterator::handleSafePrevious(int32_t fromPosition) {
+
     int32_t             state;
     uint16_t            category        = 0;
-    RBBIStateTableRow  *row;
+    RowType            *row;
     UChar32             c;
     int32_t             result          = 0;
 
@@ -971,7 +1002,7 @@ int32_t RuleBasedBreakIterator::handleSafePrevious(int32_t fromPosition) {
     //  Set the initial state for the state machine
     c = UTEXT_PREVIOUS32(&fText);
     state = START_STATE;
-    row = (RBBIStateTableRow *)
+    row = (RowType *)
             (stateTable->fTableData + (stateTable->fRowLen * state));
 
     // loop until we reach the start of the text or transition to state 0
@@ -980,12 +1011,9 @@ int32_t RuleBasedBreakIterator::handleSafePrevious(int32_t fromPosition) {
 
         // look up the current character's character category, which tells us
         // which column in the state table to look at.
-        // Note:  the 16 in UTRIE_GET16 refers to the size of the data being returned,
-        //        not the size of the character going in, which is a UChar32.
         //
-        //  And off the dictionary flag bit. For reverse iteration it is not used.
-        category = UTRIE2_GET16(fData->fTrie, c);
-        category &= ~0x4000;
+        //  Off the dictionary flag bit. For reverse iteration it is not used.
+        category = trieFunc(fData->fTrie, c);
 
         #ifdef RBBI_DEBUG
             if (gTrace) {
@@ -1004,7 +1032,7 @@ int32_t RuleBasedBreakIterator::handleSafePrevious(int32_t fromPosition) {
         // fNextState is a variable-length array.
         U_ASSERT(category<fData->fHeader->fCatCount);
         state = row->fNextState[category];  /*Not accessing beyond memory*/
-        row = (RBBIStateTableRow *)
+        row = (RowType *)
             (stateTable->fTableData + (stateTable->fRowLen * state));
 
         if (state == STOP_STATE) {
@@ -1024,6 +1052,7 @@ int32_t RuleBasedBreakIterator::handleSafePrevious(int32_t fromPosition) {
     return result;
 }
 
+
 //-------------------------------------------------------------------------------
 //
 //   getRuleStatus()   Return the break rule tag associated with the current
diff --git a/deps/icu-small/source/common/rbbi_cache.cpp b/deps/icu-small/source/common/rbbi_cache.cpp
index 4f9e83360a2a32adc0f9e3f0a28eef4420005e2d..44f19d86973d7589b05ca5ec2b90e01edc6b2d81 100644
--- a/deps/icu-small/source/common/rbbi_cache.cpp
+++ b/deps/icu-small/source/common/rbbi_cache.cpp
@@ -142,13 +142,15 @@ void RuleBasedBreakIterator::DictionaryCache::populateDictionary(int32_t startPo
 
     utext_setNativeIndex(text, rangeStart);
     UChar32     c = utext_current32(text);
-    category = UTRIE2_GET16(fBI->fData->fTrie, c);
+    category = ucptrie_get(fBI->fData->fTrie, c);
+    uint32_t dictStart = fBI->fData->fForwardTable->fDictCategoriesStart;
 
     while(U_SUCCESS(status)) {
-        while((current = (int32_t)UTEXT_GETNATIVEINDEX(text)) < rangeEnd && (category & 0x4000) == 0) {
+        while((current = (int32_t)UTEXT_GETNATIVEINDEX(text)) < rangeEnd
+                && (category < dictStart)) {
             utext_next32(text);           // TODO: cleaner loop structure.
             c = utext_current32(text);
-            category = UTRIE2_GET16(fBI->fData->fTrie, c);
+            category = ucptrie_get(fBI->fData->fTrie, c);
         }
         if (current >= rangeEnd) {
             break;
@@ -166,7 +168,7 @@ void RuleBasedBreakIterator::DictionaryCache::populateDictionary(int32_t startPo
 
         // Reload the loop variables for the next go-round
         c = utext_current32(text);
-        category = UTRIE2_GET16(fBI->fData->fTrie, c);
+        category = ucptrie_get(fBI->fData->fTrie, c);
     }
 
     // If we found breaks, ensure that the first and last entries are
@@ -256,7 +258,7 @@ void RuleBasedBreakIterator::BreakCache::preceding(int32_t startPos, UErrorCode
             previous(status);
         } else {
             // seek() leaves the BreakCache positioned at the preceding boundary
-            //        if the requested position is between two bounaries.
+            //        if the requested position is between two boundaries.
             // current() pushes the BreakCache position out to the BreakIterator itself.
             U_ASSERT(startPos > fTextIdx);
             current();
diff --git a/deps/icu-small/source/common/rbbi_cache.h b/deps/icu-small/source/common/rbbi_cache.h
index 864ff811aaaff385bf613b88b1d080afb8eaa123..8c1fa86e7d1aa11bdb9da6c652418099a68e5592 100644
--- a/deps/icu-small/source/common/rbbi_cache.h
+++ b/deps/icu-small/source/common/rbbi_cache.h
@@ -126,13 +126,13 @@ class RuleBasedBreakIterator::BreakCache: public UMemory {
      * Additional boundaries, either preceding or following, may be added
      * to the cache as a side effect.
      *
-     * Return FALSE if the operation failed.
+     * Return false if the operation failed.
      */
     UBool populateNear(int32_t position, UErrorCode &status);
 
     /**
      *  Add boundary(s) to the cache following the current last boundary.
-     *  Return FALSE if at the end of the text, and no more boundaries can be added.
+     *  Return false if at the end of the text, and no more boundaries can be added.
      *  Leave iteration position at the first newly added boundary, or unchanged if no boundary was added.
      */
     UBool populateFollowing();
@@ -170,7 +170,7 @@ class RuleBasedBreakIterator::BreakCache: public UMemory {
      *  Fails if the requested position is outside of the range of boundaries currently held by the cache.
      *  The startPosition must be on a code point boundary.
      *
-     *  Return TRUE if successful, FALSE if the specified position is after
+     *  Return true if successful, false if the specified position is after
      *  the last cached boundary or before the first.
      */
     UBool                   seek(int32_t startPosition);
diff --git a/deps/icu-small/source/common/rbbicst.pl b/deps/icu-small/source/common/rbbicst.pl
index 839b9501dda953560a33329a65537b55f2daa5a6..29f575d7d093577e36412f5c67921343d386a961 100755
--- a/deps/icu-small/source/common/rbbicst.pl
+++ b/deps/icu-small/source/common/rbbicst.pl
@@ -1,6 +1,6 @@
 #**************************************************************************
 #   Copyright (C) 2016 and later: Unicode, Inc. and others.
-#   License & terms of use: http://www.unicode.org/copyright.html#License
+#   License & terms of use: http://www.unicode.org/copyright.html
 #**************************************************************************
 #**************************************************************************
 #   Copyright (C) 2002-2016 International Business Machines Corporation
diff --git a/deps/icu-small/source/common/rbbidata.cpp b/deps/icu-small/source/common/rbbidata.cpp
index fdcb564961362e2cc7ccc69bbf14a50331ec11bd..f78d9d0668917888cdb78725139d70b6d498820e 100644
--- a/deps/icu-small/source/common/rbbidata.cpp
+++ b/deps/icu-small/source/common/rbbidata.cpp
@@ -11,10 +11,10 @@
 
 #if !UCONFIG_NO_BREAK_ITERATION
 
+#include "unicode/ucptrie.h"
 #include "unicode/utypes.h"
 #include "rbbidata.h"
 #include "rbbirb.h"
-#include "utrie2.h"
 #include "udatamem.h"
 #include "cmemory.h"
 #include "cstring.h"
@@ -110,17 +110,24 @@ void RBBIDataWrapper::init(const RBBIDataHeader *data, UErrorCode &status) {
         fReverseTable = (RBBIStateTable *)((char *)data + fHeader->fRTable);
     }
 
-    fTrie = utrie2_openFromSerialized(UTRIE2_16_VALUE_BITS,
-                                      (uint8_t *)data + fHeader->fTrie,
-                                      fHeader->fTrieLen,
-                                      NULL,           // *actual length
-                                      &status);
+    fTrie = ucptrie_openFromBinary(UCPTRIE_TYPE_FAST,
+                                   UCPTRIE_VALUE_BITS_ANY,
+                                   (uint8_t *)data + fHeader->fTrie,
+                                   fHeader->fTrieLen,
+                                   nullptr,           // *actual length
+                                   &status);
     if (U_FAILURE(status)) {
         return;
     }
 
-    fRuleSource   = (UChar *)((char *)data + fHeader->fRuleSource);
-    fRuleString.setTo(TRUE, fRuleSource, -1);
+    UCPTrieValueWidth width = ucptrie_getValueWidth(fTrie);
+    if (!(width == UCPTRIE_VALUE_BITS_8 || width == UCPTRIE_VALUE_BITS_16)) {
+        status = U_INVALID_FORMAT_ERROR;
+        return;
+    }
+
+    fRuleSource   = ((char *)data + fHeader->fRuleSource);
+    fRuleString = UnicodeString::fromUTF8(StringPiece(fRuleSource, fHeader->fRuleSourceLen));
     U_ASSERT(data->fRuleSourceLen > 0);
 
     fRuleStatusTable = (int32_t *)((char *)data + fHeader->fStatusTable);
@@ -142,8 +149,8 @@ void RBBIDataWrapper::init(const RBBIDataHeader *data, UErrorCode &status) {
 //-----------------------------------------------------------------------------
 RBBIDataWrapper::~RBBIDataWrapper() {
     U_ASSERT(fRefCount == 0);
-    utrie2_close(fTrie);
-    fTrie = NULL;
+    ucptrie_close(fTrie);
+    fTrie = nullptr;
     if (fUDataMem) {
         udata_close(fUDataMem);
     } else if (!fDontFreeData) {
@@ -223,9 +230,16 @@ void  RBBIDataWrapper::printTable(const char *heading, const RBBIStateTable *tab
     uint32_t   c;
     uint32_t   s;
 
-    RBBIDebugPrintf("   %s\n", heading);
+    RBBIDebugPrintf("%s\n", heading);
 
-    RBBIDebugPrintf("State |  Acc  LA TagIx");
+    RBBIDebugPrintf("   fDictCategoriesStart: %d\n", table->fDictCategoriesStart);
+    RBBIDebugPrintf("   fLookAheadResultsSize: %d\n", table->fLookAheadResultsSize);
+    RBBIDebugPrintf("   Flags: %4x RBBI_LOOKAHEAD_HARD_BREAK=%s RBBI_BOF_REQUIRED=%s  RBBI_8BITS_ROWS=%s\n",
+                    table->fFlags,
+                    table->fFlags & RBBI_LOOKAHEAD_HARD_BREAK ? "T" : "F",
+                    table->fFlags & RBBI_BOF_REQUIRED ? "T" : "F",
+                    table->fFlags & RBBI_8BITS_ROWS ? "T" : "F");
+    RBBIDebugPrintf("\nState |  Acc  LA TagIx");
     for (c=0; c<fHeader->fCatCount; c++) {RBBIDebugPrintf("%3d ", c);}
     RBBIDebugPrintf("\n------|---------------"); for (c=0;c<fHeader->fCatCount; c++) {
         RBBIDebugPrintf("----");
@@ -236,12 +250,20 @@ void  RBBIDataWrapper::printTable(const char *heading, const RBBIStateTable *tab
         RBBIDebugPrintf("         N U L L   T A B L E\n\n");
         return;
     }
+    UBool use8Bits = table->fFlags & RBBI_8BITS_ROWS;
     for (s=0; s<table->fNumStates; s++) {
         RBBIStateTableRow *row = (RBBIStateTableRow *)
                                   (table->fTableData + (table->fRowLen * s));
-        RBBIDebugPrintf("%4d  |  %3d %3d %3d ", s, row->fAccepting, row->fLookAhead, row->fTagIdx);
-        for (c=0; c<fHeader->fCatCount; c++)  {
-            RBBIDebugPrintf("%3d ", row->fNextState[c]);
+        if (use8Bits) {
+            RBBIDebugPrintf("%4d  |  %3d %3d %3d ", s, row->r8.fAccepting, row->r8.fLookAhead, row->r8.fTagsIdx);
+            for (c=0; c<fHeader->fCatCount; c++)  {
+                RBBIDebugPrintf("%3d ", row->r8.fNextState[c]);
+            }
+        } else {
+            RBBIDebugPrintf("%4d  |  %3d %3d %3d ", s, row->r16.fAccepting, row->r16.fLookAhead, row->r16.fTagsIdx);
+            for (c=0; c<fHeader->fCatCount; c++)  {
+                RBBIDebugPrintf("%3d ", row->r16.fNextState[c]);
+            }
         }
         RBBIDebugPrintf("\n");
     }
@@ -382,10 +404,23 @@ ubrk_swap(const UDataSwapper *ds, const void *inData, int32_t length, void *outD
     tableLength      = ds->readUInt32(rbbiDH->fFTableLen);
 
     if (tableLength > 0) {
+        RBBIStateTable *rbbiST = (RBBIStateTable *)(inBytes+tableStartOffset);
+        UBool use8Bits = ds->readUInt32(rbbiST->fFlags) & RBBI_8BITS_ROWS;
+
         ds->swapArray32(ds, inBytes+tableStartOffset, topSize,
                             outBytes+tableStartOffset, status);
-        ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
-                            outBytes+tableStartOffset+topSize, status);
+
+        // Swap the state table if the table is in 16 bits.
+        if (use8Bits) {
+            if (outBytes != inBytes) {
+                uprv_memmove(outBytes+tableStartOffset+topSize,
+                             inBytes+tableStartOffset+topSize,
+                             tableLength-topSize);
+            }
+        } else {
+            ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
+                                outBytes+tableStartOffset+topSize, status);
+        }
     }
 
     // Reverse state table.  Same layout as forward table, above.
@@ -393,19 +428,35 @@ ubrk_swap(const UDataSwapper *ds, const void *inData, int32_t length, void *outD
     tableLength      = ds->readUInt32(rbbiDH->fRTableLen);
 
     if (tableLength > 0) {
+        RBBIStateTable *rbbiST = (RBBIStateTable *)(inBytes+tableStartOffset);
+        UBool use8Bits = ds->readUInt32(rbbiST->fFlags) & RBBI_8BITS_ROWS;
+
         ds->swapArray32(ds, inBytes+tableStartOffset, topSize,
                             outBytes+tableStartOffset, status);
-        ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
-                            outBytes+tableStartOffset+topSize, status);
+
+        // Swap the state table if the table is in 16 bits.
+        if (use8Bits) {
+            if (outBytes != inBytes) {
+                uprv_memmove(outBytes+tableStartOffset+topSize,
+                             inBytes+tableStartOffset+topSize,
+                             tableLength-topSize);
+            }
+        } else {
+            ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
+                                outBytes+tableStartOffset+topSize, status);
+        }
     }
 
     // Trie table for character categories
-    utrie2_swap(ds, inBytes+ds->readUInt32(rbbiDH->fTrie), ds->readUInt32(rbbiDH->fTrieLen),
-                    outBytes+ds->readUInt32(rbbiDH->fTrie), status);
-
-    // Source Rules Text.  It's UChar data
-    ds->swapArray16(ds, inBytes+ds->readUInt32(rbbiDH->fRuleSource), ds->readUInt32(rbbiDH->fRuleSourceLen),
-                        outBytes+ds->readUInt32(rbbiDH->fRuleSource), status);
+    ucptrie_swap(ds, inBytes+ds->readUInt32(rbbiDH->fTrie), ds->readUInt32(rbbiDH->fTrieLen),
+                     outBytes+ds->readUInt32(rbbiDH->fTrie), status);
+
+    // Source Rules Text.  It's UTF8 data
+    if (outBytes != inBytes) {
+        uprv_memmove(outBytes+ds->readUInt32(rbbiDH->fRuleSource),
+                     inBytes+ds->readUInt32(rbbiDH->fRuleSource),
+                     ds->readUInt32(rbbiDH->fRuleSourceLen));
+    }
 
     // Table of rule status values.  It's all int_32 values
     ds->swapArray32(ds, inBytes+ds->readUInt32(rbbiDH->fStatusTable), ds->readUInt32(rbbiDH->fStatusTableLen),
diff --git a/deps/icu-small/source/common/rbbidata.h b/deps/icu-small/source/common/rbbidata.h
index 96e4649533f06899980edb3d520ab579e5528ddb..5d725deba4c262bcd24202b25ab8917ca410f1ac 100644
--- a/deps/icu-small/source/common/rbbidata.h
+++ b/deps/icu-small/source/common/rbbidata.h
@@ -49,16 +49,17 @@ ubrk_swap(const UDataSwapper *ds,
 
 #ifdef __cplusplus
 
+#include "unicode/ucptrie.h"
 #include "unicode/uobject.h"
 #include "unicode/unistr.h"
 #include "unicode/uversion.h"
 #include "umutex.h"
-#include "utrie2.h"
+
 
 U_NAMESPACE_BEGIN
 
 // The current RBBI data format version.
-static const uint8_t RBBI_DATA_FORMAT_VERSION[] = {5, 0, 0, 0};
+static const uint8_t RBBI_DATA_FORMAT_VERSION[] = {6, 0, 0, 0};
 
 /*
  *   The following structs map exactly onto the raw data from ICU common data file.
@@ -94,49 +95,61 @@ struct RBBIDataHeader {
 
 
 
-struct  RBBIStateTableRow {
-    int16_t          fAccepting;    /*  Non-zero if this row is for an accepting state.   */
-                                    /*  Value 0: not an accepting state.                  */
-                                    /*       -1: Unconditional Accepting state.           */
-                                    /*    positive:  Look-ahead match has completed.      */
-                                    /*           Actual boundary position happened earlier */
-                                    /*           Value here == fLookAhead in earlier      */
-                                    /*              state, at actual boundary pos.        */
-    int16_t          fLookAhead;    /*  Non-zero if this row is for a state that          */
-                                    /*    corresponds to a '/' in the rule source.        */
-                                    /*    Value is the same as the fAccepting             */
-                                    /*      value for the rule (which will appear         */
-                                    /*      in a different state.                         */
-    int16_t          fTagIdx;       /*  Non-zero if this row covers a {tagged} position   */
-                                    /*     from a rule.  Value is the index in the        */
-                                    /*     StatusTable of the set of matching             */
-                                    /*     tags (rule status values)                      */
-    int16_t          fReserved;
-    uint16_t         fNextState[1]; /*  Next State, indexed by char category.             */
-                                    /*    Variable-length array declared with length 1    */
-                                    /*    to disable bounds checkers.                     */
-                                    /*    Array Size is actually fData->fHeader->fCatCount*/
-                                    /*    CAUTION:  see RBBITableBuilder::getTableSize()  */
-                                    /*              before changing anything here.        */
+template <typename T>
+struct RBBIStateTableRowT {
+    T               fAccepting;    //  Non-zero if this row is for an accepting state.
+                                   //  Value 0: not an accepting state.
+                                   //        1: (ACCEPTING_UNCONDITIONAL) Unconditional Accepting state.
+                                   //       >1: Look-ahead match has completed.
+                                   //           Actual boundary position happened earlier.
+                                   //           Value here == fLookAhead in earlier
+                                   //           state, at actual boundary pos.
+    T               fLookAhead;    //  Non-zero if this row is for a state that
+                                   //    corresponds to a '/' in the rule source.
+                                   //    Value is the same as the fAccepting
+                                   //    value for the rule (which will appear
+                                   //    in a different state.
+    T               fTagsIdx;      //  Non-zero if this row covers a {tagged} position
+                                   //    from a rule.  Value is the index in the
+                                   //    StatusTable of the set of matching
+                                   //    tags (rule status values)
+    T               fNextState[1]; //  Next State, indexed by char category.
+                                   //    Variable-length array declared with length 1
+                                   //    to disable bounds checkers.
+                                   //    Array Size is actually fData->fHeader->fCatCount
+                                   //    CAUTION:  see RBBITableBuilder::getTableSize()
+                                   //              before changing anything here.
 };
 
+typedef RBBIStateTableRowT<uint8_t> RBBIStateTableRow8;
+typedef RBBIStateTableRowT<uint16_t> RBBIStateTableRow16;
+
+constexpr uint16_t ACCEPTING_UNCONDITIONAL = 1;   // Value constant for RBBIStateTableRow::fAccepting
+
+union RBBIStateTableRow {
+  RBBIStateTableRow16 r16;
+  RBBIStateTableRow8 r8;
+};
 
 struct RBBIStateTable {
-    uint32_t         fNumStates;    /*  Number of states.                                 */
-    uint32_t         fRowLen;       /*  Length of a state table row, in bytes.            */
-    uint32_t         fFlags;        /*  Option Flags for this state table                 */
-    uint32_t         fReserved;     /*  reserved                                          */
-    char             fTableData[1]; /*  First RBBIStateTableRow begins here.              */
-                                    /*    Variable-length array declared with length 1    */
-                                    /*    to disable bounds checkers.                     */
-                                    /*    (making it char[] simplifies ugly address       */
-                                    /*     arithmetic for indexing variable length rows.) */
+    uint32_t         fNumStates;            // Number of states.
+    uint32_t         fRowLen;               // Length of a state table row, in bytes.
+    uint32_t         fDictCategoriesStart;  // Char category number of the first dictionary
+                                            //   char class, or the the largest category number + 1
+                                            //   if there are no dictionary categories.
+    uint32_t         fLookAheadResultsSize; // Size of run-time array required for holding
+                                            //   look-ahead results. Indexed by row.fLookAhead.
+    uint32_t         fFlags;                // Option Flags for this state table.
+    char             fTableData[1];         // First RBBIStateTableRow begins here.
+                                            //   Variable-length array declared with length 1
+                                            //   to disable bounds checkers.
+                                            //   (making it char[] simplifies ugly address
+                                            //   arithmetic for indexing variable length rows.)
 };
 
-typedef enum {
-    RBBI_LOOKAHEAD_HARD_BREAK = 1,
-    RBBI_BOF_REQUIRED = 2
-} RBBIStateTableFlags;
+constexpr uint32_t RBBI_LOOKAHEAD_HARD_BREAK = 1;
+constexpr uint32_t RBBI_BOF_REQUIRED = 2;
+constexpr uint32_t RBBI_8BITS_ROWS = 4;
 
 
 /*                                        */
@@ -170,13 +183,13 @@ public:
     const RBBIDataHeader     *fHeader;
     const RBBIStateTable     *fForwardTable;
     const RBBIStateTable     *fReverseTable;
-    const UChar              *fRuleSource;
+    const char               *fRuleSource;
     const int32_t            *fRuleStatusTable;
 
     /* number of int32_t values in the rule status table.   Used to sanity check indexing */
     int32_t             fStatusMaxIdx;
 
-    UTrie2             *fTrie;
+    UCPTrie             *fTrie;
 
 private:
     u_atomic_int32_t    fRefCount;
@@ -184,8 +197,8 @@ private:
     UnicodeString       fRuleString;
     UBool               fDontFreeData;
 
-    RBBIDataWrapper(const RBBIDataWrapper &other); /*  forbid copying of this class */
-    RBBIDataWrapper &operator=(const RBBIDataWrapper &other); /*  forbid copying of this class */
+    RBBIDataWrapper(const RBBIDataWrapper &other) = delete; /*  forbid copying of this class */
+    RBBIDataWrapper &operator=(const RBBIDataWrapper &other) = delete; /*  forbid copying of this class */
 };
 
 
diff --git a/deps/icu-small/source/common/rbbinode.h b/deps/icu-small/source/common/rbbinode.h
index e33662167fe3fd21d8f2c9bb80b9e15dcc4f2355..ef4e4ccac7f08e77c273902b173709956f2885c1 100644
--- a/deps/icu-small/source/common/rbbinode.h
+++ b/deps/icu-small/source/common/rbbinode.h
@@ -79,7 +79,7 @@ class RBBINode : public UMemory {
                                             //   corresponds to columns in the final
                                             //   state transition table.
 
-        UBool         fLookAheadEnd;        // For endMark nodes, set TRUE if
+        UBool         fLookAheadEnd;        // For endMark nodes, set true if
                                             //   marking the end of a look-ahead rule.
 
         UBool         fRuleRoot;            // True if this node is the root of a rule.
diff --git a/deps/icu-small/source/common/rbbirb.cpp b/deps/icu-small/source/common/rbbirb.cpp
index 4df96532643d06e6b573c8021910e32ee3990179..09c8d3de7e668718a6bdcf0ac0b6703ff8479a98 100644
--- a/deps/icu-small/source/common/rbbirb.cpp
+++ b/deps/icu-small/source/common/rbbirb.cpp
@@ -22,6 +22,7 @@
 #include "unicode/uniset.h"
 #include "unicode/uchar.h"
 #include "unicode/uchriter.h"
+#include "unicode/ustring.h"
 #include "unicode/parsepos.h"
 #include "unicode/parseerr.h"
 
@@ -154,7 +155,14 @@ RBBIDataHeader *RBBIRuleBuilder::flattenData() {
     int32_t reverseTableSize  = align8(fForwardTable->getSafeTableSize());
     int32_t trieSize          = align8(fSetBuilder->getTrieSize());
     int32_t statusTableSize   = align8(fRuleStatusVals->size() * sizeof(int32_t));
-    int32_t rulesSize         = align8((fStrippedRules.length()+1) * sizeof(UChar));
+
+    int32_t rulesLengthInUTF8 = 0;
+    u_strToUTF8WithSub(0, 0, &rulesLengthInUTF8,
+                       fStrippedRules.getBuffer(), fStrippedRules.length(),
+                       0xfffd, nullptr, fStatus);
+    *fStatus = U_ZERO_ERROR;
+
+    int32_t rulesSize         = align8((rulesLengthInUTF8+1));
 
     int32_t         totalSize = headerSize
                                 + forwardTableSize
@@ -197,11 +205,11 @@ RBBIDataHeader *RBBIRuleBuilder::flattenData() {
     data->fRTableLen     = reverseTableSize;
 
     data->fTrie          = data->fRTable + data->fRTableLen;
-    data->fTrieLen       = fSetBuilder->getTrieSize();
-    data->fStatusTable   = data->fTrie    + trieSize;
+    data->fTrieLen       = trieSize;
+    data->fStatusTable   = data->fTrie    + data->fTrieLen;
     data->fStatusTableLen= statusTableSize;
     data->fRuleSource    = data->fStatusTable + statusTableSize;
-    data->fRuleSourceLen = fStrippedRules.length() * sizeof(UChar);
+    data->fRuleSourceLen = rulesLengthInUTF8;
 
     uprv_memset(data->fReserved, 0, sizeof(data->fReserved));
 
@@ -214,7 +222,12 @@ RBBIDataHeader *RBBIRuleBuilder::flattenData() {
         ruleStatusTable[i] = fRuleStatusVals->elementAti(i);
     }
 
-    fStrippedRules.extract((UChar *)((uint8_t *)data+data->fRuleSource), rulesSize/2+1, *fStatus);
+    u_strToUTF8WithSub((char *)data+data->fRuleSource, rulesSize, &rulesLengthInUTF8,
+                       fStrippedRules.getBuffer(), fStrippedRules.length(),
+                       0xfffd, nullptr, fStatus);
+    if (U_FAILURE(*fStatus)) {
+        return NULL;
+    }
 
     return data;
 }
@@ -274,9 +287,7 @@ RBBIDataHeader *RBBIRuleBuilder::build(UErrorCode &status) {
 
     //
     // UnicodeSet processing.
-    //    Munge the Unicode Sets to create a set of character categories.
-    //    Generate the mapping tables (TRIE) from input code points to
-    //    the character categories.
+    //    Munge the Unicode Sets to create an initial set of character categories.
     //
     fSetBuilder->buildRanges();
 
@@ -290,6 +301,12 @@ RBBIDataHeader *RBBIRuleBuilder::build(UErrorCode &status) {
     }
 
     fForwardTable->buildForwardTable();
+
+    // State table and character category optimization.
+    // Merge equivalent rows and columns.
+    // Note that this process alters the initial set of character categories,
+    // causing the representation of UnicodeSets in the parse tree to become invalid.
+
     optimizeTables();
     fForwardTable->buildSafeReverseTable(status);
 
@@ -302,6 +319,9 @@ RBBIDataHeader *RBBIRuleBuilder::build(UErrorCode &status) {
     }
 #endif
 
+    //    Generate the mapping tables (TRIE) from input code points to
+    //    the character categories.
+    //
     fSetBuilder->buildTrie();
 
     //
diff --git a/deps/icu-small/source/common/rbbiscan.cpp b/deps/icu-small/source/common/rbbiscan.cpp
index da8246ba6f1e47e5d13ac8d5a177a20121505c74..7838475290b93503cf53fe9e9f4b891d9e68eeec 100644
--- a/deps/icu-small/source/common/rbbiscan.cpp
+++ b/deps/icu-small/source/common/rbbiscan.cpp
@@ -284,7 +284,7 @@ UBool RBBIRuleScanner::doParseActions(int32_t action)
 
     case doEndAssign:
         {
-            // We have reached the end of an assignement statement.
+            // We have reached the end of an assignment statement.
             //   Current scan char is the ';' that terminates the assignment.
 
             // Terminate expression, leaves expression parse tree rooted in TOS node.
@@ -829,16 +829,14 @@ static const UChar      chRParen    = 0x29;
 UnicodeString RBBIRuleScanner::stripRules(const UnicodeString &rules) {
     UnicodeString strippedRules;
     int32_t rulesLength = rules.length();
-    bool skippingSpaces = false;
 
     for (int32_t idx=0; idx<rulesLength; idx = rules.moveIndex32(idx, 1)) {
         UChar32 cp = rules.char32At(idx);
         bool whiteSpace = u_hasBinaryProperty(cp, UCHAR_PATTERN_WHITE_SPACE);
-        if (skippingSpaces && whiteSpace) {
+        if (whiteSpace) {
             continue;
         }
         strippedRules.append(cp);
-        skippingSpaces = whiteSpace;
     }
     return strippedRules;
 }
@@ -858,6 +856,10 @@ UChar32  RBBIRuleScanner::nextCharLL() {
         return (UChar32)-1;
     }
     ch         = fRB->fRules.char32At(fNextIndex);
+    if (U_IS_SURROGATE(ch)) {
+        error(U_ILLEGAL_CHAR_FOUND);
+        return U_SENTINEL;
+    }
     fNextIndex = fRB->fRules.moveIndex32(fNextIndex, 1);
 
     if (ch == chCR ||
diff --git a/deps/icu-small/source/common/rbbiscan.h b/deps/icu-small/source/common/rbbiscan.h
index 559617e78b439ff1ebd852f726f84819a9080e23..f3f26214022f562b6cca9445a3cd606561124404 100644
--- a/deps/icu-small/source/common/rbbiscan.h
+++ b/deps/icu-small/source/common/rbbiscan.h
@@ -54,7 +54,7 @@ public:
     struct RBBIRuleChar {
         UChar32             fChar;
         UBool               fEscaped;
-        RBBIRuleChar() : fChar(0), fEscaped(FALSE) {}
+        RBBIRuleChar() : fChar(0), fEscaped(false) {}
     };
 
     RBBIRuleScanner(RBBIRuleBuilder  *rb);
diff --git a/deps/icu-small/source/common/rbbisetb.cpp b/deps/icu-small/source/common/rbbisetb.cpp
index e6b98cf3e22b981a5cd7d01e0b655bc3eac9befc..2904a3280eaab2ae7c818cad11b780dea45fab40 100644
--- a/deps/icu-small/source/common/rbbisetb.cpp
+++ b/deps/icu-small/source/common/rbbisetb.cpp
@@ -19,7 +19,7 @@
 //                      by the RBBI rules.
 //                   -  compute a set of non-overlapping character ranges
 //                      with all characters within a range belonging to the same
-//                      set of input uniocde sets.
+//                      set of input unicode sets.
 //                   -  Derive a set of non-overlapping UnicodeSet (like things)
 //                      that will correspond to columns in the state table for
 //                      the RBBI execution engine.  All characters within one
@@ -35,7 +35,6 @@
 #if !UCONFIG_NO_BREAK_ITERATION
 
 #include "unicode/uniset.h"
-#include "utrie2.h"
 #include "uvector.h"
 #include "uassert.h"
 #include "cmemory.h"
@@ -46,6 +45,7 @@
 
 U_NAMESPACE_BEGIN
 
+const int32_t kMaxCharCategoriesFor8BitsTrie = 255;
 //------------------------------------------------------------------------
 //
 //   Constructor
@@ -55,11 +55,12 @@ RBBISetBuilder::RBBISetBuilder(RBBIRuleBuilder *rb)
 {
     fRB             = rb;
     fStatus         = rb->fStatus;
-    fRangeList      = 0;
-    fTrie           = 0;
+    fRangeList      = nullptr;
+    fMutableTrie    = nullptr;
+    fTrie           = nullptr;
     fTrieSize       = 0;
     fGroupCount     = 0;
-    fSawBOF         = FALSE;
+    fSawBOF         = false;
 }
 
 
@@ -79,7 +80,8 @@ RBBISetBuilder::~RBBISetBuilder()
         delete r;
     }
 
-    utrie2_close(fTrie);
+    ucptrie_close(fTrie);
+    umutablecptrie_close(fMutableTrie);
 }
 
 
@@ -194,24 +196,47 @@ void RBBISetBuilder::buildRanges() {
     //
     //    Numbering: # 0  (state table column 0) is unused.
     //               # 1  is reserved - table column 1 is for end-of-input
-    //               # 2  is reserved - table column 2 is for beginning-in-input
+    //               # 2  is reserved - table column 2 is for beginning-of-input
     //               # 3  is the first range list.
     //
     RangeDescriptor *rlSearchRange;
-    for (rlRange = fRangeList; rlRange!=0; rlRange=rlRange->fNext) {
+    int32_t dictGroupCount = 0;
+
+    for (rlRange = fRangeList; rlRange!=nullptr; rlRange=rlRange->fNext) {
         for (rlSearchRange=fRangeList; rlSearchRange != rlRange; rlSearchRange=rlSearchRange->fNext) {
             if (rlRange->fIncludesSets->equals(*rlSearchRange->fIncludesSets)) {
                 rlRange->fNum = rlSearchRange->fNum;
+                rlRange->fIncludesDict = rlSearchRange->fIncludesDict;
                 break;
             }
         }
         if (rlRange->fNum == 0) {
-            fGroupCount ++;
-            rlRange->fNum = fGroupCount+2;
-            rlRange->setDictionaryFlag();
-            addValToSets(rlRange->fIncludesSets, fGroupCount+2);
+            rlRange->fFirstInGroup = true;
+            if (rlRange->isDictionaryRange()) {
+                rlRange->fNum = ++dictGroupCount;
+                rlRange->fIncludesDict = true;
+            } else {
+                fGroupCount++;
+                rlRange->fNum = fGroupCount+2;
+                addValToSets(rlRange->fIncludesSets, rlRange->fNum);
+            }
+        }
+    }
+
+    // Move the character category numbers for any dictionary ranges up, so that they
+    // immediately follow the non-dictionary ranges.
+
+    fDictCategoriesStart = fGroupCount + 3;
+    for (rlRange = fRangeList; rlRange!=nullptr; rlRange=rlRange->fNext) {
+        if (rlRange->fIncludesDict) {
+            rlRange->fNum += fDictCategoriesStart - 1;
+            if (rlRange->fFirstInGroup) {
+                addValToSets(rlRange->fIncludesSets, rlRange->fNum);
+            }
         }
     }
+    fGroupCount += dictGroupCount;
+
 
     // Handle input sets that contain the special string {eof}.
     //   Column 1 of the state table is reserved for EOF on input.
@@ -220,13 +245,11 @@ void RBBISetBuilder::buildRanges() {
     //             references to {bof}.)
     //   Add this column value (1 or 2) to the equivalent expression
     //     subtree for each UnicodeSet that contains the string {eof}
-    //   Because {bof} and {eof} are not a characters in the normal sense,
-    //   they doesn't affect the computation of ranges or TRIE.
-    static const UChar eofUString[] = {0x65, 0x6f, 0x66, 0};
-    static const UChar bofUString[] = {0x62, 0x6f, 0x66, 0};
+    //   Because {bof} and {eof} are not characters in the normal sense,
+    //   they don't affect the computation of the ranges or TRIE.
 
-    UnicodeString eofString(eofUString);
-    UnicodeString bofString(bofUString);
+    UnicodeString eofString(u"eof");
+    UnicodeString bofString(u"bof");
     for (ni=0; ; ni++) {        // Loop over each of the UnicodeSets encountered in the input rules
         usetNode = (RBBINode *)this->fRB->fUSetNodes->elementAt(ni);
         if (usetNode==NULL) {
@@ -253,19 +276,17 @@ void RBBISetBuilder::buildRanges() {
 // range group number.
 //
 void RBBISetBuilder::buildTrie() {
-    RangeDescriptor *rlRange;
-
-    fTrie = utrie2_open(0,       //  Initial value for all code points.
+    fMutableTrie = umutablecptrie_open(
+                        0,       //  Initial value for all code points.
                         0,       //  Error value for out-of-range input.
                         fStatus);
 
-    for (rlRange = fRangeList; rlRange!=0 && U_SUCCESS(*fStatus); rlRange=rlRange->fNext) {
-        utrie2_setRange32(fTrie,
-                          rlRange->fStartChar,     // Range start
-                          rlRange->fEndChar,       // Range end (inclusive)
-                          rlRange->fNum,           // value for range
-                          TRUE,                    // Overwrite previously written values
-                          fStatus);
+    for (RangeDescriptor *range = fRangeList; range!=nullptr && U_SUCCESS(*fStatus); range=range->fNext) {
+        umutablecptrie_setRange(fMutableTrie,
+                                range->fStartChar,     // Range start
+                                range->fEndChar,       // Range end (inclusive)
+                                range->fNum,           // value for range
+                                fStatus);
     }
 }
 
@@ -273,16 +294,21 @@ void RBBISetBuilder::buildTrie() {
 void RBBISetBuilder::mergeCategories(IntPair categories) {
     U_ASSERT(categories.first >= 1);
     U_ASSERT(categories.second > categories.first);
+    U_ASSERT((categories.first <  fDictCategoriesStart && categories.second <  fDictCategoriesStart) ||
+             (categories.first >= fDictCategoriesStart && categories.second >= fDictCategoriesStart));
+
     for (RangeDescriptor *rd = fRangeList; rd != nullptr; rd = rd->fNext) {
-        int32_t rangeNum = rd->fNum & ~DICT_BIT;
-        int32_t rangeDict = rd->fNum & DICT_BIT;
+        int32_t rangeNum = rd->fNum;
         if (rangeNum == categories.second) {
-            rd->fNum = categories.first | rangeDict;
+            rd->fNum = categories.first;
         } else if (rangeNum > categories.second) {
             rd->fNum--;
         }
     }
     --fGroupCount;
+    if (categories.second <= fDictCategoriesStart) {
+        --fDictCategoriesStart;
+    }
 }
 
 
@@ -295,15 +321,18 @@ int32_t RBBISetBuilder::getTrieSize()  {
     if (U_FAILURE(*fStatus)) {
         return 0;
     }
-    utrie2_freeze(fTrie, UTRIE2_16_VALUE_BITS, fStatus);
-    fTrieSize  = utrie2_serialize(fTrie,
-                                  NULL,                // Buffer
-                                  0,                   // Capacity
-                                  fStatus);
-    if (*fStatus == U_BUFFER_OVERFLOW_ERROR) {
-        *fStatus = U_ZERO_ERROR;
+    if (fTrie == nullptr) {
+        bool use8Bits = getNumCharCategories() <= kMaxCharCategoriesFor8BitsTrie;
+        fTrie = umutablecptrie_buildImmutable(
+            fMutableTrie,
+            UCPTRIE_TYPE_FAST,
+            use8Bits ? UCPTRIE_VALUE_BITS_8 : UCPTRIE_VALUE_BITS_16,
+            fStatus);
+        fTrieSize = ucptrie_toBinary(fTrie, nullptr, 0, fStatus);
+        if (*fStatus == U_BUFFER_OVERFLOW_ERROR) {
+            *fStatus = U_ZERO_ERROR;
+        }
     }
-    // RBBIDebugPrintf("Trie table size is %d\n", trieSize);
     return fTrieSize;
 }
 
@@ -316,9 +345,9 @@ int32_t RBBISetBuilder::getTrieSize()  {
 //
 //-----------------------------------------------------------------------------------
 void RBBISetBuilder::serializeTrie(uint8_t *where) {
-    utrie2_serialize(fTrie,
-                     where,                   // Buffer
-                     fTrieSize,               // Capacity
+    ucptrie_toBinary(fTrie,
+                     where,                // Buffer
+                     fTrieSize,            // Capacity
                      fStatus);
 }
 
@@ -384,6 +413,16 @@ int32_t  RBBISetBuilder::getNumCharCategories() const {
 }
 
 
+//------------------------------------------------------------------------
+//
+//   getDictCategoriesStart
+//
+//------------------------------------------------------------------------
+int32_t  RBBISetBuilder::getDictCategoriesStart() const {
+    return fDictCategoriesStart;
+}
+
+
 //------------------------------------------------------------------------
 //
 //   sawBOF
@@ -403,7 +442,7 @@ UBool  RBBISetBuilder::sawBOF() const {
 UChar32  RBBISetBuilder::getFirstChar(int32_t category) const {
     RangeDescriptor   *rlRange;
     UChar32            retVal = (UChar32)-1;
-    for (rlRange = fRangeList; rlRange!=0; rlRange=rlRange->fNext) {
+    for (rlRange = fRangeList; rlRange!=nullptr; rlRange=rlRange->fNext) {
         if (rlRange->fNum == category) {
             retVal = rlRange->fStartChar;
             break;
@@ -413,7 +452,6 @@ UChar32  RBBISetBuilder::getFirstChar(int32_t category) const {
 }
 
 
-
 //------------------------------------------------------------------------
 //
 //   printRanges        A debugging function.
@@ -426,16 +464,16 @@ void RBBISetBuilder::printRanges() {
     int                    i;
 
     RBBIDebugPrintf("\n\n Nonoverlapping Ranges ...\n");
-    for (rlRange = fRangeList; rlRange!=0; rlRange=rlRange->fNext) {
-        RBBIDebugPrintf("%2i  %4x-%4x  ", rlRange->fNum, rlRange->fStartChar, rlRange->fEndChar);
+    for (rlRange = fRangeList; rlRange!=nullptr; rlRange=rlRange->fNext) {
+        RBBIDebugPrintf("%4x-%4x  ", rlRange->fStartChar, rlRange->fEndChar);
 
         for (i=0; i<rlRange->fIncludesSets->size(); i++) {
             RBBINode       *usetNode    = (RBBINode *)rlRange->fIncludesSets->elementAt(i);
-            UnicodeString   setName = UNICODE_STRING("anon", 4);
+            UnicodeString   setName {u"anon"};
             RBBINode       *setRef = usetNode->fParent;
-            if (setRef != NULL) {
+            if (setRef != nullptr) {
                 RBBINode *varRef = setRef->fParent;
-                if (varRef != NULL  &&  varRef->fType == RBBINode::varRef) {
+                if (varRef != nullptr  &&  varRef->fType == RBBINode::varRef) {
                     setName = varRef->fText;
                 }
             }
@@ -455,19 +493,15 @@ void RBBISetBuilder::printRanges() {
 //------------------------------------------------------------------------
 #ifdef RBBI_DEBUG
 void RBBISetBuilder::printRangeGroups() {
-    RangeDescriptor       *rlRange;
-    RangeDescriptor       *tRange;
     int                    i;
-    int                    lastPrintedGroupNum = 0;
 
     RBBIDebugPrintf("\nRanges grouped by Unicode Set Membership...\n");
-    for (rlRange = fRangeList; rlRange!=0; rlRange=rlRange->fNext) {
-        int groupNum = rlRange->fNum & 0xbfff;
-        if (groupNum > lastPrintedGroupNum) {
-            lastPrintedGroupNum = groupNum;
+    for (RangeDescriptor *rlRange = fRangeList; rlRange!=nullptr; rlRange=rlRange->fNext) {
+        if (rlRange->fFirstInGroup) {
+            int groupNum = rlRange->fNum;
             RBBIDebugPrintf("%2i  ", groupNum);
 
-            if (rlRange->fNum & DICT_BIT) { RBBIDebugPrintf(" <DICT> ");}
+            if (groupNum >= fDictCategoriesStart) { RBBIDebugPrintf(" <DICT> ");}
 
             for (i=0; i<rlRange->fIncludesSets->size(); i++) {
                 RBBINode       *usetNode    = (RBBINode *)rlRange->fIncludesSets->elementAt(i);
@@ -483,7 +517,7 @@ void RBBISetBuilder::printRangeGroups() {
             }
 
             i = 0;
-            for (tRange = rlRange; tRange != 0; tRange = tRange->fNext) {
+            for (RangeDescriptor *tRange = rlRange; tRange != nullptr; tRange = tRange->fNext) {
                 if (tRange->fNum == rlRange->fNum) {
                     if (i++ % 5 == 0) {
                         RBBIDebugPrintf("\n    ");
@@ -550,28 +584,22 @@ void RBBISetBuilder::printSets() {
 //
 //-------------------------------------------------------------------------------------
 
-RangeDescriptor::RangeDescriptor(const RangeDescriptor &other, UErrorCode &status) {
-    int  i;
-
-    this->fStartChar    = other.fStartChar;
-    this->fEndChar      = other.fEndChar;
-    this->fNum          = other.fNum;
-    this->fNext         = NULL;
-    UErrorCode oldstatus = status;
-    this->fIncludesSets = new UVector(status);
-    if (U_FAILURE(oldstatus)) {
-        status = oldstatus;
-    }
+RangeDescriptor::RangeDescriptor(const RangeDescriptor &other, UErrorCode &status) :
+        fStartChar(other.fStartChar), fEndChar {other.fEndChar}, fNum {other.fNum},
+        fIncludesDict{other.fIncludesDict}, fFirstInGroup{other.fFirstInGroup} {
+
     if (U_FAILURE(status)) {
         return;
     }
-    /* test for NULL */
-    if (this->fIncludesSets == 0) {
+    fIncludesSets = new UVector(status);
+    if (this->fIncludesSets == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
+    }
+    if (U_FAILURE(status)) {
         return;
     }
 
-    for (i=0; i<other.fIncludesSets->size(); i++) {
+    for (int32_t i=0; i<other.fIncludesSets->size(); i++) {
         this->fIncludesSets->addElement(other.fIncludesSets->elementAt(i), status);
     }
 }
@@ -583,24 +611,13 @@ RangeDescriptor::RangeDescriptor(const RangeDescriptor &other, UErrorCode &statu
 //
 //-------------------------------------------------------------------------------------
 RangeDescriptor::RangeDescriptor(UErrorCode &status) {
-    this->fStartChar    = 0;
-    this->fEndChar      = 0;
-    this->fNum          = 0;
-    this->fNext         = NULL;
-    UErrorCode oldstatus = status;
-    this->fIncludesSets = new UVector(status);
-    if (U_FAILURE(oldstatus)) {
-        status = oldstatus;
-    }
     if (U_FAILURE(status)) {
         return;
     }
-    /* test for NULL */
-    if(this->fIncludesSets == 0) {
+    fIncludesSets = new UVector(status);
+    if (fIncludesSets == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
-        return;
     }
-
 }
 
 
@@ -611,7 +628,7 @@ RangeDescriptor::RangeDescriptor(UErrorCode &status) {
 //-------------------------------------------------------------------------------------
 RangeDescriptor::~RangeDescriptor() {
     delete  fIncludesSets;
-    fIncludesSets = NULL;
+    fIncludesSets = nullptr;
 }
 
 //-------------------------------------------------------------------------------------
@@ -622,7 +639,7 @@ RangeDescriptor::~RangeDescriptor() {
 void RangeDescriptor::split(UChar32 where, UErrorCode &status) {
     U_ASSERT(where>fStartChar && where<=fEndChar);
     RangeDescriptor *nr = new RangeDescriptor(*this, status);
-    if(nr == 0) {
+    if(nr == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
@@ -641,27 +658,22 @@ void RangeDescriptor::split(UChar32 where, UErrorCode &status) {
 
 //-------------------------------------------------------------------------------------
 //
-//   RangeDescriptor::setDictionaryFlag
+//   RangeDescriptor::isDictionaryRange
 //
-//            Character Category Numbers that include characters from
-//            the original Unicode Set named "dictionary" have bit 14
-//            set to 1.  The RBBI runtime engine uses this to trigger
-//            use of the word dictionary.
+//            Test whether this range includes characters from
+//            the original Unicode Set named "dictionary".
 //
-//            This function looks through the Unicode Sets that it
-//            (the range) includes, and sets the bit in fNum when
-//            "dictionary" is among them.
+//            This function looks through the Unicode Sets that
+//            the range includes, checking for one named "dictionary"
 //
 //            TODO:  a faster way would be to find the set node for
 //                   "dictionary" just once, rather than looking it
 //                   up by name every time.
 //
 //-------------------------------------------------------------------------------------
-void RangeDescriptor::setDictionaryFlag() {
-    int i;
-
+bool RangeDescriptor::isDictionaryRange() {
     static const char16_t *dictionary = u"dictionary";
-    for (i=0; i<fIncludesSets->size(); i++) {
+    for (int32_t i=0; i<fIncludesSets->size(); i++) {
         RBBINode *usetNode  = (RBBINode *)fIncludesSets->elementAt(i);
         RBBINode *setRef = usetNode->fParent;
         if (setRef != nullptr) {
@@ -669,16 +681,14 @@ void RangeDescriptor::setDictionaryFlag() {
             if (varRef && varRef->fType == RBBINode::varRef) {
                 const UnicodeString *setName = &varRef->fText;
                 if (setName->compare(dictionary, -1) == 0) {
-                    fNum |= RBBISetBuilder::DICT_BIT;
-                    break;
+                    return true;
                 }
             }
         }
     }
+    return false;
 }
 
-
-
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */
diff --git a/deps/icu-small/source/common/rbbisetb.h b/deps/icu-small/source/common/rbbisetb.h
index ed6a76b12146214e8be6d14d8d82afac43169090..6409a4ea57983220f8df3c8aaf1c49614d8ab1ab 100644
--- a/deps/icu-small/source/common/rbbisetb.h
+++ b/deps/icu-small/source/common/rbbisetb.h
@@ -16,9 +16,10 @@
 
 #if !UCONFIG_NO_BREAK_ITERATION
 
+#include "unicode/ucptrie.h"
+#include "unicode/umutablecptrie.h"
 #include "unicode/uobject.h"
 #include "rbbirb.h"
-#include "utrie2.h"
 #include "uvector.h"
 
 U_NAMESPACE_BEGIN
@@ -40,25 +41,26 @@ U_NAMESPACE_BEGIN
 //
 class RangeDescriptor : public UMemory {
 public:
-    UChar32            fStartChar;      // Start of range, unicode 32 bit value.
-    UChar32            fEndChar;        // End of range, unicode 32 bit value.
-    int32_t            fNum;            // runtime-mapped input value for this range.
-    UVector           *fIncludesSets;   // vector of the the original
-                                        //   Unicode sets that include this range.
-                                        //    (Contains ptrs to uset nodes)
-    RangeDescriptor   *fNext;           // Next RangeDescriptor in the linked list.
+    UChar32            fStartChar {};            // Start of range, unicode 32 bit value.
+    UChar32            fEndChar {};              // End of range, unicode 32 bit value.
+    int32_t            fNum {0};                 // runtime-mapped input value for this range.
+    bool               fIncludesDict {false};    // True if the range includes $dictionary.
+    bool               fFirstInGroup {false};    // True if first range in a group with the same fNum.
+    UVector           *fIncludesSets {nullptr};  // vector of the the original
+                                                 //   Unicode sets that include this range.
+                                                 //    (Contains ptrs to uset nodes)
+    RangeDescriptor   *fNext {nullptr};          // Next RangeDescriptor in the linked list.
 
     RangeDescriptor(UErrorCode &status);
     RangeDescriptor(const RangeDescriptor &other, UErrorCode &status);
     ~RangeDescriptor();
     void split(UChar32 where, UErrorCode &status);   // Spit this range in two at "where", with
                                         //   where appearing in the second (higher) part.
-    void setDictionaryFlag();           // Check whether this range appears as part of
+    bool isDictionaryRange();           // Check whether this range appears as part of
                                         //   the Unicode set named "dictionary"
 
-private:
-    RangeDescriptor(const RangeDescriptor &other); // forbid copying of this class
-    RangeDescriptor &operator=(const RangeDescriptor &other); // forbid copying of this class
+    RangeDescriptor(const RangeDescriptor &other) = delete; // forbid default copying of this class
+    RangeDescriptor &operator=(const RangeDescriptor &other) = delete; // forbid assigning of this class
 };
 
 
@@ -89,6 +91,8 @@ public:
     int32_t  getNumCharCategories() const;   // CharCategories are the same as input symbol set to the
                                              //    runtime state machine, which are the same as
                                              //    columns in the DFA state table
+    int32_t  getDictCategoriesStart() const; // First char category that includes $dictionary, or
+                                             // last category + 1 if there are no dictionary categories.
     int32_t  getTrieSize() /*const*/;        // Size in bytes of the serialized Trie.
     void     serializeTrie(uint8_t *where);  // write out the serialized Trie.
     UChar32  getFirstChar(int32_t  val) const;
@@ -101,8 +105,6 @@ public:
      */
     void     mergeCategories(IntPair categories);
 
-    static constexpr int32_t DICT_BIT = 0x4000;
-
 #ifdef RBBI_DEBUG
     void     printSets();
     void     printRanges();
@@ -114,24 +116,22 @@ public:
 #endif
 
 private:
-    void           numberSets();
-
     RBBIRuleBuilder       *fRB;             // The RBBI Rule Compiler that owns us.
     UErrorCode            *fStatus;
 
     RangeDescriptor       *fRangeList;      // Head of the linked list of RangeDescriptors
 
-    UTrie2                *fTrie;           // The mapping TRIE that is the end result of processing
-    uint32_t               fTrieSize;       //  the Unicode Sets.
+    UMutableCPTrie        *fMutableTrie;    // The mapping TRIE that is the end result of processing
+    UCPTrie               *fTrie;           //  the Unicode Sets.
+    uint32_t               fTrieSize;
 
-    // Groups correspond to character categories -
-    //       groups of ranges that are in the same original UnicodeSets.
-    //       fGroupCount is the index of the last used group.
-    //       fGroupCount+1 is also the number of columns in the RBBI state table being compiled.
-    //       State table column 0 is not used.  Column 1 is for end-of-input.
-    //       column 2 is for group 0.  Funny counting.
+    // Number of range groups, which are groups of ranges that are in the same original UnicodeSets.
     int32_t               fGroupCount;
 
+    // The number of the first dictionary char category.
+    // If there are no Dictionary categories, set to the last category + 1.
+    int32_t               fDictCategoriesStart;
+
     UBool                 fSawBOF;
 
     RBBISetBuilder(const RBBISetBuilder &other); // forbid copying of this class
diff --git a/deps/icu-small/source/common/rbbitblb.cpp b/deps/icu-small/source/common/rbbitblb.cpp
index 3b1edc6a15c7008db9f21e0a30a9e2df50f2f5b2..4bc8097886929ef55ecad563d4c86de5b08884e5 100644
--- a/deps/icu-small/source/common/rbbitblb.cpp
+++ b/deps/icu-small/source/common/rbbitblb.cpp
@@ -28,6 +28,8 @@
 
 U_NAMESPACE_BEGIN
 
+const int32_t kMaxStateFor8BitsTable = 255;
+
 RBBITableBuilder::RBBITableBuilder(RBBIRuleBuilder *rb, RBBINode **rootNode, UErrorCode &status) :
         fRB(rb),
         fTree(*rootNode),
@@ -149,7 +151,7 @@ void  RBBITableBuilder::buildForwardTable() {
     //
     // calculate the functions nullable, firstpos, lastpos and followpos on
     // nodes in the parse tree.
-    //    See the alogrithm description in Aho.
+    //    See the algorithm description in Aho.
     //    Understanding how this works by looking at the code alone will be
     //       nearly impossible.
     //
@@ -712,7 +714,6 @@ void RBBITableBuilder::mapLookAheadRules() {
         return;
     }
     fLookAheadRuleMap->setSize(fRB->fScanner->numRules() + 1);
-    int32_t laSlotsInUse = 0;
 
     for (int32_t n=0; n<fDStates->size(); n++) {
         RBBIStateDescriptor *sd = (RBBIStateDescriptor *)fDStates->elementAt(n);
@@ -749,7 +750,7 @@ void RBBITableBuilder::mapLookAheadRules() {
         }
 
         if (laSlotForState == 0) {
-            laSlotForState = ++laSlotsInUse;
+            laSlotForState = ++fLASlotsInUse;
         }
 
         // For each look ahead node covered by this state,
@@ -805,23 +806,23 @@ void     RBBITableBuilder::flagAcceptingStates() {
             if (sd->fPositions->indexOf(endMarker) >= 0) {
                 // Any non-zero value for fAccepting means this is an accepting node.
                 // The value is what will be returned to the user as the break status.
-                // If no other value was specified, force it to -1.
+                // If no other value was specified, force it to ACCEPTING_UNCONDITIONAL (1).
 
                 if (sd->fAccepting==0) {
                     // State hasn't been marked as accepting yet.  Do it now.
                     sd->fAccepting = fLookAheadRuleMap->elementAti(endMarker->fVal);
                     if (sd->fAccepting == 0) {
-                        sd->fAccepting = -1;
+                        sd->fAccepting = ACCEPTING_UNCONDITIONAL;
                     }
                 }
-                if (sd->fAccepting==-1 && endMarker->fVal != 0) {
+                if (sd->fAccepting==ACCEPTING_UNCONDITIONAL && endMarker->fVal != 0) {
                     // Both lookahead and non-lookahead accepting for this state.
                     // Favor the look-ahead, because a look-ahead match needs to
                     // immediately stop the run-time engine. First match, not longest.
                     sd->fAccepting = fLookAheadRuleMap->elementAti(endMarker->fVal);
                 }
                 // implicit else:
-                // if sd->fAccepting already had a value other than 0 or -1, leave it be.
+                // if sd->fAccepting already had a value other than 0 or 1, leave it be.
             }
         }
     }
@@ -855,7 +856,7 @@ void     RBBITableBuilder::flagLookAheadStates() {
             int32_t positionsIdx = sd->fPositions->indexOf(lookAheadNode);
             if (positionsIdx >= 0) {
                 U_ASSERT(lookAheadNode == sd->fPositions->elementAt(positionsIdx));
-                int32_t lookaheadSlot = fLookAheadRuleMap->elementAti(lookAheadNode->fVal);
+                uint32_t lookaheadSlot = fLookAheadRuleMap->elementAti(lookAheadNode->fVal);
                 U_ASSERT(sd->fLookAhead == 0 || sd->fLookAhead == lookaheadSlot);
                 // if (sd->fLookAhead != 0 && sd->fLookAhead != lookaheadSlot) {
                 //     printf("%s:%d Bingo. sd->fLookAhead:%d   lookaheadSlot:%d\n",
@@ -1148,7 +1149,13 @@ bool RBBITableBuilder::findDuplCharClassFrom(IntPair *categories) {
     int32_t numCols = fRB->fSetBuilder->getNumCharCategories();
 
     for (; categories->first < numCols-1; categories->first++) {
-        for (categories->second=categories->first+1; categories->second < numCols; categories->second++) {
+        // Note: dictionary & non-dictionary columns cannot be merged.
+        //       The limitSecond value prevents considering mixed pairs.
+        //       Dictionary categories are >= DictCategoriesStart.
+        //       Non dict categories are   <  DictCategoriesStart.
+        int limitSecond = categories->first < fRB->fSetBuilder->getDictCategoriesStart() ?
+            fRB->fSetBuilder->getDictCategoriesStart() : numCols;
+        for (categories->second=categories->first+1; categories->second < limitSecond; categories->second++) {
             // Initialized to different values to prevent returning true if numStates = 0 (implies no duplicates).
             uint16_t table_base = 0;
             uint16_t table_dupl = 1;
@@ -1335,11 +1342,18 @@ int32_t  RBBITableBuilder::getTableSize() const {
     numRows = fDStates->size();
     numCols = fRB->fSetBuilder->getNumCharCategories();
 
-    rowSize = offsetof(RBBIStateTableRow, fNextState) + sizeof(uint16_t)*numCols;
+    if (use8BitsForTable()) {
+        rowSize = offsetof(RBBIStateTableRow8, fNextState) + sizeof(int8_t)*numCols;
+    } else {
+        rowSize = offsetof(RBBIStateTableRow16, fNextState) + sizeof(int16_t)*numCols;
+    }
     size   += numRows * rowSize;
     return size;
 }
 
+bool RBBITableBuilder::use8BitsForTable() const {
+    return fDStates->size() <= kMaxStateFor8BitsTable;
+}
 
 //-----------------------------------------------------------------------------
 //
@@ -1364,27 +1378,48 @@ void RBBITableBuilder::exportTable(void *where) {
         return;
     }
 
-    table->fRowLen    = offsetof(RBBIStateTableRow, fNextState) + sizeof(uint16_t) * catCount;
     table->fNumStates = fDStates->size();
+    table->fDictCategoriesStart = fRB->fSetBuilder->getDictCategoriesStart();
+    table->fLookAheadResultsSize = fLASlotsInUse == ACCEPTING_UNCONDITIONAL ? 0 : fLASlotsInUse + 1;
     table->fFlags     = 0;
+    if (use8BitsForTable()) {
+        table->fRowLen    = offsetof(RBBIStateTableRow8, fNextState) + sizeof(uint8_t) * catCount;
+        table->fFlags  |= RBBI_8BITS_ROWS;
+    } else {
+        table->fRowLen    = offsetof(RBBIStateTableRow16, fNextState) + sizeof(int16_t) * catCount;
+    }
     if (fRB->fLookAheadHardBreak) {
         table->fFlags  |= RBBI_LOOKAHEAD_HARD_BREAK;
     }
     if (fRB->fSetBuilder->sawBOF()) {
         table->fFlags  |= RBBI_BOF_REQUIRED;
     }
-    table->fReserved  = 0;
 
     for (state=0; state<table->fNumStates; state++) {
         RBBIStateDescriptor *sd = (RBBIStateDescriptor *)fDStates->elementAt(state);
         RBBIStateTableRow   *row = (RBBIStateTableRow *)(table->fTableData + state*table->fRowLen);
-        U_ASSERT (-32768 < sd->fAccepting && sd->fAccepting <= 32767);
-        U_ASSERT (-32768 < sd->fLookAhead && sd->fLookAhead <= 32767);
-        row->fAccepting = (int16_t)sd->fAccepting;
-        row->fLookAhead = (int16_t)sd->fLookAhead;
-        row->fTagIdx    = (int16_t)sd->fTagsIdx;
-        for (col=0; col<catCount; col++) {
-            row->fNextState[col] = (uint16_t)sd->fDtran->elementAti(col);
+        if (use8BitsForTable()) {
+            U_ASSERT (sd->fAccepting <= 255);
+            U_ASSERT (sd->fLookAhead <= 255);
+            U_ASSERT (0 <= sd->fTagsIdx && sd->fTagsIdx <= 255);
+            RBBIStateTableRow8 *r8 = (RBBIStateTableRow8*)row;
+            r8->fAccepting = sd->fAccepting;
+            r8->fLookAhead = sd->fLookAhead;
+            r8->fTagsIdx   = sd->fTagsIdx;
+            for (col=0; col<catCount; col++) {
+                U_ASSERT (sd->fDtran->elementAti(col) <= kMaxStateFor8BitsTable);
+                r8->fNextState[col] = sd->fDtran->elementAti(col);
+            }
+        } else {
+            U_ASSERT (sd->fAccepting <= 0xffff);
+            U_ASSERT (sd->fLookAhead <= 0xffff);
+            U_ASSERT (0 <= sd->fTagsIdx && sd->fTagsIdx <= 0xffff);
+            row->r16.fAccepting = sd->fAccepting;
+            row->r16.fLookAhead = sd->fLookAhead;
+            row->r16.fTagsIdx   = sd->fTagsIdx;
+            for (col=0; col<catCount; col++) {
+                row->r16.fNextState[col] = sd->fDtran->elementAti(col);
+            }
         }
     }
 }
@@ -1520,11 +1555,18 @@ int32_t  RBBITableBuilder::getSafeTableSize() const {
     numRows = fSafeTable->size();
     numCols = fRB->fSetBuilder->getNumCharCategories();
 
-    rowSize = offsetof(RBBIStateTableRow, fNextState) + sizeof(uint16_t)*numCols;
+    if (use8BitsForSafeTable()) {
+        rowSize = offsetof(RBBIStateTableRow8, fNextState) + sizeof(int8_t)*numCols;
+    } else {
+        rowSize = offsetof(RBBIStateTableRow16, fNextState) + sizeof(int16_t)*numCols;
+    }
     size   += numRows * rowSize;
     return size;
 }
 
+bool RBBITableBuilder::use8BitsForSafeTable() const {
+    return fSafeTable->size() <= kMaxStateFor8BitsTable;
+}
 
 //-----------------------------------------------------------------------------
 //
@@ -1549,20 +1591,34 @@ void RBBITableBuilder::exportSafeTable(void *where) {
         return;
     }
 
-    table->fRowLen    = offsetof(RBBIStateTableRow, fNextState) + sizeof(uint16_t) * catCount;
     table->fNumStates = fSafeTable->size();
     table->fFlags     = 0;
-    table->fReserved  = 0;
+    if (use8BitsForSafeTable()) {
+        table->fRowLen    = offsetof(RBBIStateTableRow8, fNextState) + sizeof(uint8_t) * catCount;
+        table->fFlags  |= RBBI_8BITS_ROWS;
+    } else {
+        table->fRowLen    = offsetof(RBBIStateTableRow16, fNextState) + sizeof(int16_t) * catCount;
+    }
 
     for (state=0; state<table->fNumStates; state++) {
         UnicodeString *rowString = (UnicodeString *)fSafeTable->elementAt(state);
         RBBIStateTableRow   *row = (RBBIStateTableRow *)(table->fTableData + state*table->fRowLen);
-        row->fAccepting = 0;
-        row->fLookAhead = 0;
-        row->fTagIdx    = 0;
-        row->fReserved  = 0;
-        for (col=0; col<catCount; col++) {
-            row->fNextState[col] = rowString->charAt(col);
+        if (use8BitsForSafeTable()) {
+            RBBIStateTableRow8 *r8 = (RBBIStateTableRow8*)row;
+            r8->fAccepting = 0;
+            r8->fLookAhead = 0;
+            r8->fTagsIdx    = 0;
+            for (col=0; col<catCount; col++) {
+                U_ASSERT(rowString->charAt(col) <= kMaxStateFor8BitsTable);
+                r8->fNextState[col] = static_cast<uint8_t>(rowString->charAt(col));
+            }
+        } else {
+            row->r16.fAccepting = 0;
+            row->r16.fLookAhead = 0;
+            row->r16.fTagsIdx    = 0;
+            for (col=0; col<catCount; col++) {
+                row->r16.fNextState[col] = rowString->charAt(col);
+            }
         }
     }
 }
@@ -1600,12 +1656,12 @@ void RBBITableBuilder::printStates() {
     RBBIDebugPrintf("state |           i n p u t     s y m b o l s \n");
     RBBIDebugPrintf("      | Acc  LA    Tag");
     for (c=0; c<fRB->fSetBuilder->getNumCharCategories(); c++) {
-        RBBIDebugPrintf(" %2d", c);
+        RBBIDebugPrintf(" %3d", c);
     }
     RBBIDebugPrintf("\n");
     RBBIDebugPrintf("      |---------------");
     for (c=0; c<fRB->fSetBuilder->getNumCharCategories(); c++) {
-        RBBIDebugPrintf("---");
+        RBBIDebugPrintf("----");
     }
     RBBIDebugPrintf("\n");
 
@@ -1614,7 +1670,7 @@ void RBBITableBuilder::printStates() {
         RBBIDebugPrintf("  %3d | " , n);
         RBBIDebugPrintf("%3d %3d %5d ", sd->fAccepting, sd->fLookAhead, sd->fTagsIdx);
         for (c=0; c<fRB->fSetBuilder->getNumCharCategories(); c++) {
-            RBBIDebugPrintf(" %2d", sd->fDtran->elementAti(c));
+            RBBIDebugPrintf(" %3d", sd->fDtran->elementAti(c));
         }
         RBBIDebugPrintf("\n");
     }
diff --git a/deps/icu-small/source/common/rbbitblb.h b/deps/icu-small/source/common/rbbitblb.h
index c2b574fe1b8f933cf0a22c4253484868b2228cd0..fe3db8d7bf1ae8e44be56a77455dbf8705c0368d 100644
--- a/deps/icu-small/source/common/rbbitblb.h
+++ b/deps/icu-small/source/common/rbbitblb.h
@@ -20,6 +20,7 @@
 
 #include "unicode/uobject.h"
 #include "unicode/rbbi.h"
+#include "rbbidata.h"
 #include "rbbirb.h"
 #include "rbbinode.h"
 
@@ -53,6 +54,9 @@ public:
      */
     void     exportTable(void *where);
 
+    /** Use 8 bits to encode the forward table */
+    bool     use8BitsForTable() const;
+
     /**
      *  Find duplicate (redundant) character classes. Begin looking with categories.first.
      *  Duplicate, if found are returned in the categories parameter.
@@ -85,6 +89,8 @@ public:
      */
     void     exportSafeTable(void *where);
 
+    /** Use 8 bits to encode the safe reverse table */
+    bool     use8BitsForSafeTable() const;
 
 private:
     void     calcNullable(RBBINode *n);
@@ -179,9 +185,15 @@ private:
     /** Map from rule number (fVal in look ahead nodes) to sequential lookahead index. */
     UVector32        *fLookAheadRuleMap = nullptr;
 
+    /* Counter used when assigning lookahead rule numbers.
+     * Contains the last look-ahead number already in use.
+     * The first look-ahead number is 2; Number 1 (ACCEPTING_UNCONDITIONAL) is reserved
+     * for non-lookahead accepting states. See the declarations of RBBIStateTableRowT.   */
+    int32_t          fLASlotsInUse = ACCEPTING_UNCONDITIONAL;
+
 
-    RBBITableBuilder(const RBBITableBuilder &other); // forbid copying of this class
-    RBBITableBuilder &operator=(const RBBITableBuilder &other); // forbid copying of this class
+    RBBITableBuilder(const RBBITableBuilder &other) = delete; // forbid copying of this class
+    RBBITableBuilder &operator=(const RBBITableBuilder &other) = delete; // forbid copying of this class
 };
 
 //
@@ -190,8 +202,8 @@ private:
 class RBBIStateDescriptor : public UMemory {
 public:
     UBool            fMarked;
-    int32_t          fAccepting;
-    int32_t          fLookAhead;
+    uint32_t         fAccepting;
+    uint32_t         fLookAhead;
     UVector          *fTagVals;
     int32_t          fTagsIdx;
     UVector          *fPositions;          // Set of parse tree positions associated
diff --git a/deps/icu-small/source/common/resource.h b/deps/icu-small/source/common/resource.h
index 5199b858880770dfab43fde174bfe636651c5a5f..48f5b9fa6ec7cc55274f3699d146609d642d95be 100644
--- a/deps/icu-small/source/common/resource.h
+++ b/deps/icu-small/source/common/resource.h
@@ -60,7 +60,7 @@ public:
     /**
      * @param i Array item index.
      * @param value Output-only, receives the value of the i'th item.
-     * @return TRUE if i is non-negative and less than getSize().
+     * @return true if i is non-negative and less than getSize().
      */
     UBool getValue(int32_t i, ResourceValue &value) const;
 
@@ -97,14 +97,14 @@ public:
      * @param i Table item index.
      * @param key Output-only, receives the key of the i'th item.
      * @param value Output-only, receives the value of the i'th item.
-     * @return TRUE if i is non-negative and less than getSize().
+     * @return true if i is non-negative and less than getSize().
      */
     UBool getKeyAndValue(int32_t i, const char *&key, ResourceValue &value) const;
 
     /**
      * @param key Key string to find in the table.
      * @param value Output-only, receives the value of the item with that key.
-     * @return TRUE if the table contains the key.
+     * @return true if the table contains the key.
      */
     UBool findValue(const char *key, ResourceValue &value) const;
 
@@ -141,7 +141,7 @@ public:
     inline UnicodeString getUnicodeString(UErrorCode &errorCode) const {
         int32_t len = 0;
         const UChar *r = getString(len, errorCode);
-        return UnicodeString(TRUE, r, len);
+        return UnicodeString(true, r, len);
     }
 
     /**
@@ -152,7 +152,7 @@ public:
     inline UnicodeString getAliasUnicodeString(UErrorCode &errorCode) const {
         int32_t len = 0;
         const UChar *r = getAliasString(len, errorCode);
-        return UnicodeString(TRUE, r, len);
+        return UnicodeString(true, r, len);
     }
 
     /**
@@ -199,7 +199,7 @@ public:
      * CLDR no-fallback data values of (three empty-set symbols)=={2205, 2205, 2205}
      * when enumerating tables with fallback from the specific resource bundle to root.
      *
-     * @return TRUE if this is a no-inheritance marker string
+     * @return true if this is a no-inheritance marker string
      */
     virtual UBool isNoInheritanceMarker() const = 0;
 
@@ -274,8 +274,10 @@ public:
      *
      * @param key The key string of the enumeration-start resource.
      *     Empty if the enumeration starts at the top level of the bundle.
-     * @param value Call getArray() or getTable() as appropriate.
-     *     Then reuse for output values from Array and Table getters.
+     * @param value Call getArray() or getTable() as appropriate. Then reuse for
+     *     output values from Array and Table getters. Note: ResourceTable and
+     *     ResourceArray instances must outlive the ResourceValue instance for
+     *     ResourceTracer to be happy.
      * @param noFallback true if the bundle has no parent;
      *     that is, its top-level table has the nofallback attribute,
      *     or it is the root bundle of a locale tree.
diff --git a/deps/icu-small/source/common/restrace.cpp b/deps/icu-small/source/common/restrace.cpp
index 5c6498850e2f8f5e58c3d13dc0d97db212451851..1f83372d682a7f58282b096d25e1c1a3ea67f3a8 100644
--- a/deps/icu-small/source/common/restrace.cpp
+++ b/deps/icu-small/source/common/restrace.cpp
@@ -54,6 +54,9 @@ void ResourceTracer::traceOpen() const {
 
 CharString& ResourceTracer::getFilePath(CharString& output, UErrorCode& status) const {
     if (fResB) {
+        // Note: if you get a segfault around here, check that ResourceTable and
+        // ResourceArray instances outlive ResourceValue instances referring to
+        // their contents:
         output.append(fResB->fData->fPath, status);
         output.append('/', status);
         output.append(fResB->fData->fName, status);
diff --git a/deps/icu-small/source/common/ruleiter.h b/deps/icu-small/source/common/ruleiter.h
index b6edc657aff26191bcba58c9ab9b31b77c76684b..f397f8bccd78172653df3b4c673de014ece487fe 100644
--- a/deps/icu-small/source/common/ruleiter.h
+++ b/deps/icu-small/source/common/ruleiter.h
@@ -114,7 +114,7 @@ public:
      * character.
      * @param options one or more of the following options, bitwise-OR-ed
      * together: PARSE_VARIABLES, PARSE_ESCAPES, SKIP_WHITESPACE.
-     * @param isEscaped output parameter set to TRUE if the character
+     * @param isEscaped output parameter set to true if the character
      * was escaped
      * @param ec input-output error code.  An error will only be set by
      * this routing if options includes PARSE_VARIABLES and an unknown
diff --git a/deps/icu-small/source/common/serv.h b/deps/icu-small/source/common/serv.h
index 70695839a8f3ce67f92e0fa3198cde3f774e0ebf..6a3d1915afdf5a52374d1d37e2c8dae112a290e6 100644
--- a/deps/icu-small/source/common/serv.h
+++ b/deps/icu-small/source/common/serv.h
@@ -138,16 +138,16 @@ class U_COMMON_API ICUServiceKey : public UObject {
   * must eventually return false.  This implementation has no fallbacks
   * and always returns false.</p>
   *
-  * @return TRUE if the ICUServiceKey changed to a valid fallback value.
+  * @return true if the ICUServiceKey changed to a valid fallback value.
   */
   virtual UBool fallback();
 
  /**
-  * <p>Return TRUE if a key created from id matches, or would eventually
+  * <p>Return true if a key created from id matches, or would eventually
   * fallback to match, the canonical ID of this ICUServiceKey.</p>
   *
   * @param id the id to test.
-  * @return TRUE if this ICUServiceKey's canonical ID is a fallback of id.
+  * @return true if this ICUServiceKey's canonical ID is a fallback of id.
   */
   virtual UBool isFallbackOf(const UnicodeString& id) const;
 
@@ -291,15 +291,15 @@ class U_COMMON_API SimpleFactory : public ICUServiceFactory {
  public:
   /**
    * <p>Construct a SimpleFactory that maps a single ID to a single
-   * service instance.  If visible is TRUE, the ID will be visible.
+   * service instance.  If visible is true, the ID will be visible.
    * The instance must not be NULL.  The SimpleFactory will adopt
    * the instance, which must not be changed subsequent to this call.</p>
    *
    * @param instanceToAdopt the service instance to adopt.
    * @param id the ID to assign to this service instance.
-   * @param visible if TRUE, the ID will be visible.
+   * @param visible if true, the ID will be visible.
    */
-  SimpleFactory(UObject* instanceToAdopt, const UnicodeString& id, UBool visible = TRUE);
+  SimpleFactory(UObject* instanceToAdopt, const UnicodeString& id, UBool visible = true);
 
   /**
    * <p>Destructor.</p>
@@ -318,7 +318,7 @@ class U_COMMON_API SimpleFactory : public ICUServiceFactory {
   virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
 
   /**
-   * <p>This implementation adds a mapping from ID -> this to result if visible is TRUE,
+   * <p>This implementation adds a mapping from ID -> this to result if visible is true,
    * otherwise it removes ID from result.</p>
    *
    * @param result the mapping table to update.
@@ -327,7 +327,7 @@ class U_COMMON_API SimpleFactory : public ICUServiceFactory {
   virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
 
   /**
-   * <p>This implementation returns the factory ID if it equals id and visible is TRUE,
+   * <p>This implementation returns the factory ID if it equals id and visible is true,
    * otherwise it returns the empty string.  (This implementation provides
    * no localized id information.)</p>
    *
@@ -427,8 +427,8 @@ public:
                             UErrorCode& status);
 
   /**
-   * <p>Return TRUE if either string of the pair is bogus.</p>
-   * @return TRUE if either string of the pair is bogus.
+   * <p>Return true if either string of the pair is bogus.</p>
+   * @return true if either string of the pair is bogus.
    */
   UBool isBogus() const;
 
@@ -761,7 +761,7 @@ class U_COMMON_API ICUService : public ICUNotifier {
 
     /**
      * <p>A convenience override of registerInstance(UObject*, const UnicodeString&, UBool)
-     * that defaults visible to TRUE.</p>
+     * that defaults visible to true.</p>
      *
      * @param objToAdopt the object to register and adopt.
      * @param id the ID to assign to this object.
@@ -774,7 +774,7 @@ class U_COMMON_API ICUService : public ICUNotifier {
     /**
      * <p>Register a service instance with the provided ID.  The ID will be
      * canonicalized.  The canonicalized ID will be returned by
-     * getVisibleIDs if visible is TRUE.  The service instance will be adopted and
+     * getVisibleIDs if visible is true.  The service instance will be adopted and
      * must not be modified subsequent to this call.</p>
      *
      * <p>This issues a serviceChanged notification to registered listeners.</p>
@@ -784,7 +784,7 @@ class U_COMMON_API ICUService : public ICUNotifier {
      *
      * @param objToAdopt the object to register and adopt.
      * @param id the ID to assign to this object.
-     * @param visible TRUE if getVisibleIDs is to return this ID.
+     * @param visible true if getVisibleIDs is to return this ID.
      * @param status the error code status.
      * @return a registry key that can be passed to unregister() to unregister
      * (and discard) this instance.
@@ -820,7 +820,7 @@ class U_COMMON_API ICUService : public ICUNotifier {
      *
      * @param rkey the registry key.
      * @param status the error code status.
-     * @return TRUE if the call successfully unregistered the factory.
+     * @return true if the call successfully unregistered the factory.
      */
     virtual UBool unregister(URegistryKey rkey, UErrorCode& status);
 
@@ -833,9 +833,9 @@ class U_COMMON_API ICUService : public ICUNotifier {
     virtual void reset(void);
 
     /**
-     * <p>Return TRUE if the service is in its default state.</p>
+     * <p>Return true if the service is in its default state.</p>
      *
-     * <p>The default implementation returns TRUE if there are no
+     * <p>The default implementation returns true if there are no
      * factories registered.</p>
      */
     virtual UBool isDefault(void) const;
@@ -877,7 +877,7 @@ class U_COMMON_API ICUService : public ICUNotifier {
      *
      * @param instanceToAdopt the service instance to adopt.
      * @param id the ID to assign to this service instance.
-     * @param visible if TRUE, the ID will be visible.
+     * @param visible if true, the ID will be visible.
      * @param status the error code status.
      * @return an instance of ICUServiceFactory that maps this instance to the provided ID.
      */
@@ -885,7 +885,7 @@ class U_COMMON_API ICUService : public ICUNotifier {
 
     /**
      * <p>Reinitialize the factory list to its default state.  After this call, isDefault()
-     * must return TRUE.</p>
+     * must return true.</p>
      *
      * <p>This issues a serviceChanged notification to registered listeners.</p>
      *
@@ -928,7 +928,7 @@ class U_COMMON_API ICUService : public ICUNotifier {
      * different listeners.</p>
      *
      * @param l the listener to test.
-     * @return TRUE if the service accepts the listener.
+     * @return true if the service accepts the listener.
      */
     virtual UBool acceptsListener(const EventListener& l) const;
 
diff --git a/deps/icu-small/source/common/servnotf.h b/deps/icu-small/source/common/servnotf.h
index cf92fc169e927f4b47f5284f2de4161c35497369..340496e85c61fd2e79c0976373277c71468326a9 100644
--- a/deps/icu-small/source/common/servnotf.h
+++ b/deps/icu-small/source/common/servnotf.h
@@ -82,7 +82,7 @@ public:
     /**
      * Add a listener to be notified when notifyChanged is called.
      * The listener must not be null. AcceptsListener must return
-     * true for the listener.  Attempts to concurrently
+     * true for the listener. Attempts to concurrently
      * register the identical listener more than once will be
      * silently ignored.
      */
@@ -90,7 +90,7 @@ public:
 
     /**
      * Stop notifying this listener.  The listener must
-     * not be null.  Attemps to remove a listener that is
+     * not be null. Attempts to remove a listener that is
      * not registered will be silently ignored.
      */
     virtual void removeListener(const EventListener* l, UErrorCode& status);
@@ -105,7 +105,7 @@ public:
 
 protected:
     /**
-     * Subclasses implement this to return TRUE if the listener is
+     * Subclasses implement this to return true if the listener is
      * of the appropriate type.
      */
     virtual UBool acceptsListener(const EventListener& l) const = 0;
diff --git a/deps/icu-small/source/common/sharedobject.h b/deps/icu-small/source/common/sharedobject.h
index 878594c7ffa772dba2ccfcec4340c27903a4e8b5..0565de6608a094ee973722eb42d1420781c9e2a3 100644
--- a/deps/icu-small/source/common/sharedobject.h
+++ b/deps/icu-small/source/common/sharedobject.h
@@ -90,13 +90,13 @@ public:
     int32_t getRefCount() const;
 
     /**
-     * If noHardReferences() == TRUE then this object has no hard references.
+     * If noHardReferences() == true then this object has no hard references.
      * Must be called only from within the internals of UnifiedCache.
      */
     inline UBool noHardReferences() const { return getRefCount() == 0; }
 
     /**
-     * If hasHardReferences() == TRUE then this object has hard references.
+     * If hasHardReferences() == true then this object has hard references.
      * Must be called only from within the internals of UnifiedCache.
      */
     inline UBool hasHardReferences() const { return getRefCount() != 0; }
diff --git a/deps/icu-small/source/common/simpleformatter.cpp b/deps/icu-small/source/common/simpleformatter.cpp
index 76d8f54efd4aea7d32c6ea0480cde8fb511c2c1b..f7f7aead6171bbfa07c1a2c7507f8cc0e71e636c 100644
--- a/deps/icu-small/source/common/simpleformatter.cpp
+++ b/deps/icu-small/source/common/simpleformatter.cpp
@@ -263,6 +263,8 @@ UnicodeString SimpleFormatter::getTextWithNoArguments(
             sb.append(compiledPattern + i, n);
             i += n;
         } else if (n < offsetsLength) {
+            // TODO(ICU-20406): This does not distinguish between "{0}{1}" and "{1}{0}".
+            // Consider removing this function and replacing it with an iterator interface.
             offsets[n] = sb.length();
         }
     }
diff --git a/deps/icu-small/source/common/ubidi_props.cpp b/deps/icu-small/source/common/ubidi_props.cpp
index 4141c21938a740d8851305d307b0e5ee02a4c233..afcc4aaf4f99d767b0c9ac8fea9aa4656f2497c2 100644
--- a/deps/icu-small/source/common/ubidi_props.cpp
+++ b/deps/icu-small/source/common/ubidi_props.cpp
@@ -248,7 +248,7 @@ u_charMirror(UChar32 c) {
     return ubidi_getMirror(c);
 }
 
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_getBidiPairedBracket(UChar32 c) {
     return ubidi_getPairedBracket(c);
 }
diff --git a/deps/icu-small/source/common/ubidiimp.h b/deps/icu-small/source/common/ubidiimp.h
index 9746b2bc103102e04d51e9d7df2cbd6ad3648c1f..e48fc6f941621b7fb61b6c6cbe423f24021f54a9 100644
--- a/deps/icu-small/source/common/ubidiimp.h
+++ b/deps/icu-small/source/common/ubidiimp.h
@@ -26,6 +26,14 @@
 
 /* miscellaneous definitions ---------------------------------------------- */
 
+// ICU-20853=ICU-20935 Solaris #defines CS and ES in sys/regset.h
+#ifdef CS
+#   undef CS
+#endif
+#ifdef ES
+#   undef ES
+#endif
+
 typedef uint8_t DirProp;
 typedef uint32_t Flags;
 
@@ -451,26 +459,26 @@ ubidi_getMemory(BidiMemoryForAllocation *pMemory, int32_t *pSize, UBool mayAlloc
 /* additional macros used by ubidi_open() - always allow allocation */
 #define getInitialDirPropsMemory(pBiDi, length) \
         ubidi_getMemory((BidiMemoryForAllocation *)&(pBiDi)->dirPropsMemory, &(pBiDi)->dirPropsSize, \
-                        TRUE, (length))
+                        true, (length))
 
 #define getInitialLevelsMemory(pBiDi, length) \
         ubidi_getMemory((BidiMemoryForAllocation *)&(pBiDi)->levelsMemory, &(pBiDi)->levelsSize, \
-                        TRUE, (length))
+                        true, (length))
 
 #define getInitialOpeningsMemory(pBiDi, length) \
         ubidi_getMemory((BidiMemoryForAllocation *)&(pBiDi)->openingsMemory, &(pBiDi)->openingsSize, \
-                        TRUE, (length)*sizeof(Opening))
+                        true, (length)*sizeof(Opening))
 
 #define getInitialParasMemory(pBiDi, length) \
         ubidi_getMemory((BidiMemoryForAllocation *)&(pBiDi)->parasMemory, &(pBiDi)->parasSize, \
-                        TRUE, (length)*sizeof(Para))
+                        true, (length)*sizeof(Para))
 
 #define getInitialRunsMemory(pBiDi, length) \
         ubidi_getMemory((BidiMemoryForAllocation *)&(pBiDi)->runsMemory, &(pBiDi)->runsSize, \
-                        TRUE, (length)*sizeof(Run))
+                        true, (length)*sizeof(Run))
 
 #define getInitialIsolatesMemory(pBiDi, length) \
         ubidi_getMemory((BidiMemoryForAllocation *)&(pBiDi)->isolatesMemory, &(pBiDi)->isolatesSize, \
-                        TRUE, (length)*sizeof(Isolate))
+                        true, (length)*sizeof(Isolate))
 
 #endif
diff --git a/deps/icu-small/source/common/ubiditransform.cpp b/deps/icu-small/source/common/ubiditransform.cpp
index bb3ce8cb934d435931db9875a5e400ffbb60942b..ab3dcbe14c0cfea1c8ad30f20869f8b1735adbc0 100644
--- a/deps/icu-small/source/common/ubiditransform.cpp
+++ b/deps/icu-small/source/common/ubiditransform.cpp
@@ -89,7 +89,7 @@ struct UBiDiTransform {
     uint32_t                letters;            /* letter option for ArabicShaping */
 };
 
-U_DRAFT UBiDiTransform* U_EXPORT2
+U_CAPI UBiDiTransform* U_EXPORT2
 ubiditransform_open(UErrorCode *pErrorCode)
 {
     UBiDiTransform *pBiDiTransform = NULL;
@@ -102,7 +102,7 @@ ubiditransform_open(UErrorCode *pErrorCode)
     return pBiDiTransform;
 }
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubiditransform_close(UBiDiTransform *pBiDiTransform)
 {
     if (pBiDiTransform != NULL) {
@@ -434,7 +434,7 @@ findMatchingScheme(UBiDiLevel inLevel, UBiDiLevel outLevel,
     return NULL;
 }
 
-U_DRAFT uint32_t U_EXPORT2
+U_CAPI uint32_t U_EXPORT2
 ubiditransform_transform(UBiDiTransform *pBiDiTransform,
             const UChar *src, int32_t srcLength,
             UChar *dest, int32_t destSize,
diff --git a/deps/icu-small/source/common/ubrk.cpp b/deps/icu-small/source/common/ubrk.cpp
index f8bdf5a6b6582270bc97e5472cd29a1cbab81a17..bb5bdd1b5012fbbde236a2e2472255adce303841 100644
--- a/deps/icu-small/source/common/ubrk.cpp
+++ b/deps/icu-small/source/common/ubrk.cpp
@@ -174,6 +174,18 @@ ubrk_safeClone(
     return (UBreakIterator *)newBI;
 }
 
+U_CAPI UBreakIterator * U_EXPORT2
+ubrk_clone(const UBreakIterator *bi, UErrorCode *status) {
+    if (U_FAILURE(*status)) {
+        return nullptr;
+    }
+    BreakIterator *newBI = ((BreakIterator *)bi)->clone();
+    if (newBI == nullptr) {
+        *status = U_MEMORY_ALLOCATION_ERROR;
+        return nullptr;
+    }
+    return (UBreakIterator *)newBI;
+}
 
 
 U_CAPI void U_EXPORT2
diff --git a/deps/icu-small/source/common/ucase.cpp b/deps/icu-small/source/common/ucase.cpp
index 57a40327905c00542a08f17a7f34b8b240b1e1c8..7f779441975d2379809401ec8818386180947169 100644
--- a/deps/icu-small/source/common/ucase.cpp
+++ b/deps/icu-small/source/common/ucase.cpp
@@ -681,7 +681,7 @@ ucase_isCaseSensitive(UChar32 c) {
  *   - In [CoreProps], C has one of the properties Uppercase, or Lowercase
  *   - Given D = NFD(C), then it is not the case that:
  *     D = UCD_lower(D) = UCD_upper(D) = UCD_title(D)
- *     (This third criterium does not add any characters to the list
+ *     (This third criterion does not add any characters to the list
  *      for Unicode 3.2. Ignored.)
  *
  * D2. A character C is defined to be case-ignorable
@@ -707,6 +707,7 @@ ucase_isCaseSensitive(UChar32 c) {
 #define is_r(c) ((c)=='r' || (c)=='R')
 #define is_t(c) ((c)=='t' || (c)=='T')
 #define is_u(c) ((c)=='u' || (c)=='U')
+#define is_y(c) ((c)=='y' || (c)=='Y')
 #define is_z(c) ((c)=='z' || (c)=='Z')
 
 /* separator? */
@@ -804,6 +805,18 @@ ucase_getCaseLocale(const char *locale) {
                     return UCASE_LOC_DUTCH;
                 }
             }
+        } else if(c=='h') {
+            /* hy or hye? *not* hyw */
+            c=*locale++;
+            if(is_y(c)) {
+                c=*locale++;
+                if(is_e(c)) {
+                    c=*locale;
+                }
+                if(is_sep(c)) {
+                    return UCASE_LOC_ARMENIAN;
+                }
+            }
         }
     } else {
         // uppercase c
@@ -868,6 +881,18 @@ ucase_getCaseLocale(const char *locale) {
                     return UCASE_LOC_DUTCH;
                 }
             }
+        } else if(c=='H') {
+            /* hy or hye? *not* hyw */
+            c=*locale++;
+            if(is_y(c)) {
+                c=*locale++;
+                if(is_e(c)) {
+                    c=*locale;
+                }
+                if(is_sep(c)) {
+                    return UCASE_LOC_ARMENIAN;
+                }
+            }
         }
     }
     return UCASE_LOC_ROOT;
@@ -1229,6 +1254,17 @@ toUpperOrTitle(UChar32 c,
                  */
                 *pString=nullptr;
                 return 0; /* remove the dot (continue without output) */
+            } else if(c==0x0587) {
+                // See ICU-13416:
+                // և ligature ech-yiwn
+                // uppercases to ԵՒ=ech+yiwn by default and in Western Armenian,
+                // but to ԵՎ=ech+vew in Eastern Armenian.
+                if(loc==UCASE_LOC_ARMENIAN) {
+                    *pString=upperNotTitle ? u"ԵՎ" : u"Եվ";
+                } else {
+                    *pString=upperNotTitle ? u"ԵՒ" : u"Եւ";
+                }
+                return 2;
             } else {
                 /* no known conditional special case mapping, use a normal mapping */
             }
diff --git a/deps/icu-small/source/common/ucase.h b/deps/icu-small/source/common/ucase.h
index b0a453b87e8afa9936f4ef6780548ee391fb5bd0..a018f82b81b22925c3c6140e36a699cf15cf5c5d 100644
--- a/deps/icu-small/source/common/ucase.h
+++ b/deps/icu-small/source/common/ucase.h
@@ -56,7 +56,8 @@ enum {
     UCASE_LOC_TURKISH,
     UCASE_LOC_LITHUANIAN,
     UCASE_LOC_GREEK,
-    UCASE_LOC_DUTCH
+    UCASE_LOC_DUTCH,
+    UCASE_LOC_ARMENIAN
 };
 
 /**
@@ -117,7 +118,7 @@ ucase_addCaseClosure(UChar32 c, const USetAdder *sa);
  * the string itself is added as well as part of its code points' closure.
  * It must be length>=0.
  *
- * @return TRUE if the string was found
+ * @return true if the string was found
  */
 U_CFUNC UBool U_EXPORT2
 ucase_addStringCaseClosure(const UChar *s, int32_t length, const USetAdder *sa);
diff --git a/deps/icu-small/source/common/ucase_props_data.h b/deps/icu-small/source/common/ucase_props_data.h
index 7c97230957024a5ac2561533d78b511448a25114..aead6d58d1ec9cdd68f70d3161091a606e342387 100644
--- a/deps/icu-small/source/common/ucase_props_data.h
+++ b/deps/icu-small/source/common/ucase_props_data.h
@@ -13,7 +13,7 @@
 
 static const UVersionInfo ucase_props_dataVersion={0xd,0,0,0};
 
-static const int32_t ucase_props_indexes[UCASE_IX_TOP]={0x10,0x70ca,0x6098,0x687,0x172,0,0,0,0,0,0,0,0,0,0,3};
+static const int32_t ucase_props_indexes[UCASE_IX_TOP]={0x10,0x70c2,0x6098,0x683,0x172,0,0,0,0,0,0,0,0,0,0,3};
 
 static const uint16_t ucase_props_trieIndex[12356]={
 0x336,0x33e,0x346,0x34e,0x35c,0x364,0x36c,0x374,0x37c,0x384,0x38b,0x393,0x39b,0x3a3,0x3ab,0x3b3,
@@ -411,18 +411,18 @@ static const uint16_t ucase_props_trieIndex[12356]={
 0,0,0,0,0,4,4,4,4,0,0,0,0,0,0,0,
 0,0,0,0,0,0,4,0,0,4,4,0,0,0,0,0,
 0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,4,0,0,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,
-0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,
-0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0,0x179a,0,0,0,0,0,0x179a,0,0,
-0x17b9,0x17e9,0x1819,0x1849,0x1879,0x18a9,0x18d9,0x1909,0x1939,0x1969,0x1999,0x19c9,0x19f9,0x1a29,0x1a59,0x1a89,
-0x1ab9,0x1ae9,0x1b19,0x1b49,0x1b79,0x1ba9,0x1bd9,0x1c09,0x1c39,0x1c69,0x1c99,0x1cc9,0x1cf9,0x1d29,0x1d59,0x1d89,
-0x1db9,0x1de9,0x1e19,0x1e49,0x1e79,0x1ea9,0x1ed9,0x1f09,0x1f39,0x1f69,0x1f99,0,4,0x1fc9,0x1ff9,0x2029,
+0,4,0,0,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,
+0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,
+0x175a,0x175a,0x175a,0x175a,0x175a,0x175a,0,0x175a,0,0,0,0,0,0x175a,0,0,
+0x1779,0x17a9,0x17d9,0x1809,0x1839,0x1869,0x1899,0x18c9,0x18f9,0x1929,0x1959,0x1989,0x19b9,0x19e9,0x1a19,0x1a49,
+0x1a79,0x1aa9,0x1ad9,0x1b09,0x1b39,0x1b69,0x1b99,0x1bc9,0x1bf9,0x1c29,0x1c59,0x1c89,0x1cb9,0x1ce9,0x1d19,0x1d49,
+0x1d79,0x1da9,0x1dd9,0x1e09,0x1e39,0x1e69,0x1e99,0x1ec9,0x1ef9,0x1f29,0x1f59,0,4,0x1f89,0x1fb9,0x1fe9,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,
-0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,
-0x207a,0x207a,0x207a,0x207a,0x207a,0x207a,0,0,0x2099,0x20c9,0x20f9,0x2129,0x2159,0x2189,0,0,
-0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,
-0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,0x205a,
+0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,
+0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0,0,0x2059,0x2089,0x20b9,0x20e9,0x2119,0x2149,0,0,
+0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,
+0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,0x201a,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,4,4,0x64,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,4,4,0,4,
@@ -458,9 +458,9 @@ static const uint16_t ucase_props_trieIndex[12356]={
 0,0,0,0,4,4,4,4,4,4,4,4,0,0,4,0x64,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,4,4,4,4,4,4,0,0,
-0x21b9,0x21e9,0x2219,0x2249,0x2279,0x22c9,0x2319,0x2349,0x2379,0,0,0,0,0,0,0,
-0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,
-0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0x23aa,0,0,0x23aa,0x23aa,0x23aa,
+0x2179,0x21a9,0x21d9,0x2209,0x2239,0x2289,0x22d9,0x2309,0x2339,0,0,0,0,0,0,0,
+0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,
+0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0x236a,0,0,0x236a,0x236a,0x236a,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0x44,0x44,0x44,0,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,0x64,0x64,0x64,0x64,
 0x44,0,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0,0,0,0,0x64,0,0,
@@ -470,10 +470,10 @@ static const uint16_t ucase_props_trieIndex[12356]={
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,0x25,5,5,5,5,5,5,5,5,1,1,1,1,1,
-1,1,1,1,1,1,1,1,5,0x23c9,1,1,1,0x23e9,1,1,
+1,1,1,1,1,1,1,1,5,0x2389,1,1,1,0x23a9,1,1,
 5,5,5,5,0x25,5,5,5,0x25,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x2409,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x23c9,1,
 1,1,1,1,1,1,0x21,1,1,1,1,5,5,5,5,5,
 0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
 0x44,0x44,0x44,0x44,0x44,0x44,0x64,0x64,0x64,0x64,0,0x44,0x64,0x64,0x44,0x64,
@@ -481,27 +481,27 @@ static const uint16_t ucase_props_trieIndex[12356]={
 0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
 0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xffb1,0x92,0xff91,
 0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
-0x242a,0x2469,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x23ea,0x2429,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
 0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
-0x92,0xff91,0x24a9,0x2529,0x25a9,0x2629,0x26a9,0x2729,1,1,0x275a,1,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x2469,0x24e9,0x2569,0x25e9,0x2669,0x26e9,1,1,0x271a,1,0x92,0xff91,0x92,0xff91,
 0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xffb1,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
 0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x411,0x411,0x411,0x411,
 0x411,0x411,0x411,0x411,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0x411,0x411,0x411,0x411,
 0x411,0x411,0,0,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0,0,0x411,0x411,0x411,0x411,
 0x411,0x411,0x411,0x411,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0x411,0x411,0x411,0x411,
 0x411,0x411,0x411,0x411,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0x411,0x411,0x411,0x411,
-0x411,0x411,0,0,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0,0,0x27a9,0x411,0x2829,0x411,
-0x28d9,0x411,0x2989,0x411,0,0xfc12,0,0xfc12,0,0xfc12,0,0xfc12,0x411,0x411,0x411,0x411,
+0x411,0x411,0,0,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0,0,0x2769,0x411,0x27e9,0x411,
+0x2899,0x411,0x2949,0x411,0,0xfc12,0,0xfc12,0,0xfc12,0,0xfc12,0x411,0x411,0x411,0x411,
 0x411,0x411,0x411,0x411,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0x2511,0x2511,0x2b11,0x2b11,
-0x2b11,0x2b11,0x3211,0x3211,0x4011,0x4011,0x3811,0x3811,0x3f11,0x3f11,0,0,0x2a39,0x2aa9,0x2b19,0x2b89,
-0x2bf9,0x2c69,0x2cd9,0x2d49,0x2dbb,0x2e2b,0x2e9b,0x2f0b,0x2f7b,0x2feb,0x305b,0x30cb,0x3139,0x31a9,0x3219,0x3289,
-0x32f9,0x3369,0x33d9,0x3449,0x34bb,0x352b,0x359b,0x360b,0x367b,0x36eb,0x375b,0x37cb,0x3839,0x38a9,0x3919,0x3989,
-0x39f9,0x3a69,0x3ad9,0x3b49,0x3bbb,0x3c2b,0x3c9b,0x3d0b,0x3d7b,0x3deb,0x3e5b,0x3ecb,0x411,0x411,0x3f39,0x3fb9,
-0x4029,0,0x40a9,0x4129,0xfc12,0xfc12,0xdb12,0xdb12,0x41db,4,0x4249,4,4,4,0x4299,0x4319,
-0x4389,0,0x4409,0x4489,0xd512,0xd512,0xd512,0xd512,0x453b,4,4,4,0x411,0x411,0x45a9,0x4659,
-0,0,0x4729,0x47a9,0xfc12,0xfc12,0xce12,0xce12,0,4,4,4,0x411,0x411,0x4859,0x4909,
-0x49d9,0x391,0x4a59,0x4ad9,0xfc12,0xfc12,0xc812,0xc812,0xfc92,4,4,4,0,0,0x4b89,0x4c09,
-0x4c79,0,0x4cf9,0x4d79,0xc012,0xc012,0xc112,0xc112,0x4e2b,4,4,0,0,0,0,0,
+0x2b11,0x2b11,0x3211,0x3211,0x4011,0x4011,0x3811,0x3811,0x3f11,0x3f11,0,0,0x29f9,0x2a69,0x2ad9,0x2b49,
+0x2bb9,0x2c29,0x2c99,0x2d09,0x2d7b,0x2deb,0x2e5b,0x2ecb,0x2f3b,0x2fab,0x301b,0x308b,0x30f9,0x3169,0x31d9,0x3249,
+0x32b9,0x3329,0x3399,0x3409,0x347b,0x34eb,0x355b,0x35cb,0x363b,0x36ab,0x371b,0x378b,0x37f9,0x3869,0x38d9,0x3949,
+0x39b9,0x3a29,0x3a99,0x3b09,0x3b7b,0x3beb,0x3c5b,0x3ccb,0x3d3b,0x3dab,0x3e1b,0x3e8b,0x411,0x411,0x3ef9,0x3f79,
+0x3fe9,0,0x4069,0x40e9,0xfc12,0xfc12,0xdb12,0xdb12,0x419b,4,0x4209,4,4,4,0x4259,0x42d9,
+0x4349,0,0x43c9,0x4449,0xd512,0xd512,0xd512,0xd512,0x44fb,4,4,4,0x411,0x411,0x4569,0x4619,
+0,0,0x46e9,0x4769,0xfc12,0xfc12,0xce12,0xce12,0,4,4,4,0x411,0x411,0x4819,0x48c9,
+0x4999,0x391,0x4a19,0x4a99,0xfc12,0xfc12,0xc812,0xc812,0xfc92,4,4,4,0,0,0x4b49,0x4bc9,
+0x4c39,0,0x4cb9,0x4d39,0xc012,0xc012,0xc112,0xc112,0x4deb,4,4,0,0,0,0,0,
 0,0,0,0,0,0,0,4,4,4,4,4,0,0,0,0,
 0,0,0,0,4,4,0,0,0,0,0,0,4,0,0,4,
 0,0,4,4,4,4,4,0,0,0,0,0,0,0,0,0,
@@ -515,8 +515,8 @@ static const uint16_t ucase_props_trieIndex[12356]={
 0x64,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,2,
 0,0,1,2,2,2,1,1,2,2,2,1,0,2,0,0,
-0,2,2,2,2,2,0,0,0,0,0,0,2,0,0x4e9a,0,
-2,0,0x4eda,0x4f1a,2,2,0,1,2,2,0xe12,2,1,0,0,0,
+0,2,2,2,2,2,0,0,0,0,0,0,2,0,0x4e5a,0,
+2,0,0x4e9a,0x4eda,2,2,0,1,2,2,0xe12,2,1,0,0,0,
 0,1,0,0,1,1,2,2,0,0,0,0,0,2,1,1,
 0x21,0x21,0,0,0,0,0xf211,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0x812,0x812,0x812,0x812,0x812,0x812,0x812,0x812,
@@ -531,14 +531,14 @@ static const uint16_t ucase_props_trieIndex[12356]={
 0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,
 0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,
 0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,
-0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0,0x92,0xff91,0x4f5a,0x4f7a,0x4f9a,0x4fb9,0x4fd9,0x92,
-0xff91,0x92,0xff91,0x92,0xff91,0x4ffa,0x501a,0x503a,0x505a,1,0x92,0xff91,1,0x92,0xff91,1,
-1,1,1,1,0x25,5,0x507a,0x507a,0x92,0xff91,0x92,0xff91,1,0,0,0,
+0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0,0x92,0xff91,0x4f1a,0x4f3a,0x4f5a,0x4f79,0x4f99,0x92,
+0xff91,0x92,0xff91,0x92,0xff91,0x4fba,0x4fda,0x4ffa,0x501a,1,0x92,0xff91,1,0x92,0xff91,1,
+1,1,1,1,0x25,5,0x503a,0x503a,0x92,0xff91,0x92,0xff91,1,0,0,0,
 0,0,0,0x92,0xff91,0x92,0xff91,0x44,0x44,0x44,0x92,0xff91,0,0,0,0,
-0,0,0,0,0,0,0,0,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,
-0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,
-0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0x5099,0,0x5099,0,0,0,0,
-0,0x5099,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,
+0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,
+0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0,0x5059,0,0,0,0,
+0,0x5059,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
 0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
@@ -552,7 +552,7 @@ static const uint16_t ucase_props_trieIndex[12356]={
 0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0x92,0xff91,0x92,0xff91,
-0x92,0xff91,0x92,0xff91,0x92,0xff91,0x50ba,0x50f9,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x507a,0x50b9,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
 0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0,0x44,
 4,4,4,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,4,
 0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
@@ -564,11 +564,11 @@ static const uint16_t ucase_props_trieIndex[12356]={
 4,4,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
 1,1,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
 0x92,0xff91,0x92,0xff91,5,1,1,1,1,1,1,1,1,0x92,0xff91,0x92,
-0xff91,0x513a,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,4,4,4,0x92,
-0xff91,0x515a,1,0,0x92,0xff91,0x92,0xff91,0x1811,1,0x92,0xff91,0x92,0xff91,0x92,0xff91,
-0x92,0xff91,0x92,0xff91,0x92,0xff91,0x517a,0x519a,0x51ba,0x51da,0x517a,1,0x51fa,0x521a,0x523a,0x525a,
+0xff91,0x50fa,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,4,4,4,0x92,
+0xff91,0x511a,1,0,0x92,0xff91,0x92,0xff91,0x1811,1,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x513a,0x515a,0x517a,0x519a,0x513a,1,0x51ba,0x51da,0x51fa,0x521a,
 0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0,0,0x92,0xff91,
-0xe812,0x527a,0x529a,0x92,0xff91,0x92,0xff91,0,0,0,0,0,0,0,0,0,
+0xe812,0x523a,0x525a,0x92,0xff91,0x92,0xff91,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0x92,0xff91,0,
 5,5,1,0,0,0,0,0,0,0,4,0,0,0,0x64,0,
 0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -597,17 +597,17 @@ static const uint16_t ucase_props_trieIndex[12356]={
 0,0,0,0,4,4,0,0,0,0,0,4,4,0,0x64,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,0x52b9,1,1,1,1,1,1,1,4,5,5,5,5,
+1,1,1,0x5279,1,1,1,1,1,1,1,4,5,5,5,5,
 1,1,1,1,1,1,1,1,1,4,4,4,0,0,0,0,
-0x52d9,0x5309,0x5339,0x5369,0x5399,0x53c9,0x53f9,0x5429,0x5459,0x5489,0x54b9,0x54e9,0x5519,0x5549,0x5579,0x55a9,
-0x5bd9,0x5c09,0x5c39,0x5c69,0x5c99,0x5cc9,0x5cf9,0x5d29,0x5d59,0x5d89,0x5db9,0x5de9,0x5e19,0x5e49,0x5e79,0x5ea9,
-0x5ed9,0x5f09,0x5f39,0x5f69,0x5f99,0x5fc9,0x5ff9,0x6029,0x6059,0x6089,0x60b9,0x60e9,0x6119,0x6149,0x6179,0x61a9,
-0x55d9,0x5609,0x5639,0x5669,0x5699,0x56c9,0x56f9,0x5729,0x5759,0x5789,0x57b9,0x57e9,0x5819,0x5849,0x5879,0x58a9,
-0x58d9,0x5909,0x5939,0x5969,0x5999,0x59c9,0x59f9,0x5a29,0x5a59,0x5a89,0x5ab9,0x5ae9,0x5b19,0x5b49,0x5b79,0x5ba9,
+0x5299,0x52c9,0x52f9,0x5329,0x5359,0x5389,0x53b9,0x53e9,0x5419,0x5449,0x5479,0x54a9,0x54d9,0x5509,0x5539,0x5569,
+0x5b99,0x5bc9,0x5bf9,0x5c29,0x5c59,0x5c89,0x5cb9,0x5ce9,0x5d19,0x5d49,0x5d79,0x5da9,0x5dd9,0x5e09,0x5e39,0x5e69,
+0x5e99,0x5ec9,0x5ef9,0x5f29,0x5f59,0x5f89,0x5fb9,0x5fe9,0x6019,0x6049,0x6079,0x60a9,0x60d9,0x6109,0x6139,0x6169,
+0x5599,0x55c9,0x55f9,0x5629,0x5659,0x5689,0x56b9,0x56e9,0x5719,0x5749,0x5779,0x57a9,0x57d9,0x5809,0x5839,0x5869,
+0x5899,0x58c9,0x58f9,0x5929,0x5959,0x5989,0x59b9,0x59e9,0x5a19,0x5a49,0x5a79,0x5aa9,0x5ad9,0x5b09,0x5b39,0x5b69,
 0,0,0,0,0,4,0,0,4,0,0,0,0,0x64,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x61d9,0x6259,0x62d9,0x6359,0x6409,0x64b9,0x6559,0,0,0,0,0,0,0,0,0,
-0,0,0,0x65f9,0x6679,0x66f9,0x6779,0x67f9,0,0,0,0,0,0,0x64,0,
+0x6199,0x6219,0x6299,0x6319,0x63c9,0x6479,0x6519,0,0,0,0,0,0,0,0,0,
+0,0,0,0x65b9,0x6639,0x66b9,0x6739,0x67b9,0,0,0,0,0,0,0x64,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
 4,4,4,4,0,0,0,4,0,0,0,0,0,0,0,0,
@@ -791,7 +791,7 @@ static const uint16_t ucase_props_trieIndex[12356]={
 0,0,0,0
 };
 
-static const uint16_t ucase_props_exceptions[1671]={
+static const uint16_t ucase_props_exceptions[1667]={
 0xc850,0x20,2,0x130,0x131,0x4810,0x20,0x841,0x6b,1,0x212a,0x841,0x73,1,0x17f,0x5c50,
 0x20,2,0x130,0x131,0x844,0x4b,1,0x212a,0x844,0x53,1,0x17f,0x806,0x3bc,0x39c,0x841,
 0xe5,1,0x212b,0x8c0,1,0x2220,0x73,0x73,0x53,0x53,0x53,0x73,0x1e9e,0x844,0xc5,1,
@@ -815,88 +815,88 @@ static const uint16_t ucase_props_exceptions[1671]={
 0x43e,1,0x1c82,0x841,0x441,1,0x1c83,0x841,0x442,2,0x1c84,0x1c85,0x841,0x44a,1,0x1c86,
 0x844,0x412,1,0x1c80,0x844,0x414,1,0x1c81,0x844,0x41e,1,0x1c82,0x844,0x421,1,0x1c83,
 0x844,0x422,2,0x1c84,0x1c85,0x844,0x42a,1,0x1c86,0x841,0x463,1,0x1c87,0x844,0x462,1,
-0x1c87,0x880,0x2220,0x565,0x582,0x535,0x552,0x535,0x582,0x810,0x1c60,0x80c,0x1c90,0x10d0,0x80c,0x1c91,
-0x10d1,0x80c,0x1c92,0x10d2,0x80c,0x1c93,0x10d3,0x80c,0x1c94,0x10d4,0x80c,0x1c95,0x10d5,0x80c,0x1c96,0x10d6,
-0x80c,0x1c97,0x10d7,0x80c,0x1c98,0x10d8,0x80c,0x1c99,0x10d9,0x80c,0x1c9a,0x10da,0x80c,0x1c9b,0x10db,0x80c,
-0x1c9c,0x10dc,0x80c,0x1c9d,0x10dd,0x80c,0x1c9e,0x10de,0x80c,0x1c9f,0x10df,0x80c,0x1ca0,0x10e0,0x80c,0x1ca1,
-0x10e1,0x80c,0x1ca2,0x10e2,0x80c,0x1ca3,0x10e3,0x80c,0x1ca4,0x10e4,0x80c,0x1ca5,0x10e5,0x80c,0x1ca6,0x10e6,
-0x80c,0x1ca7,0x10e7,0x80c,0x1ca8,0x10e8,0x80c,0x1ca9,0x10e9,0x80c,0x1caa,0x10ea,0x80c,0x1cab,0x10eb,0x80c,
-0x1cac,0x10ec,0x80c,0x1cad,0x10ed,0x80c,0x1cae,0x10ee,0x80c,0x1caf,0x10ef,0x80c,0x1cb0,0x10f0,0x80c,0x1cb1,
-0x10f1,0x80c,0x1cb2,0x10f2,0x80c,0x1cb3,0x10f3,0x80c,0x1cb4,0x10f4,0x80c,0x1cb5,0x10f5,0x80c,0x1cb6,0x10f6,
-0x80c,0x1cb7,0x10f7,0x80c,0x1cb8,0x10f8,0x80c,0x1cb9,0x10f9,0x80c,0x1cba,0x10fa,0x80c,0x1cbd,0x10fd,0x80c,
-0x1cbe,0x10fe,0x80c,0x1cbf,0x10ff,0xa10,0x97d0,0xa10,8,0x806,0x13f0,0x13f0,0x806,0x13f1,0x13f1,0x806,
-0x13f2,0x13f2,0x806,0x13f3,0x13f3,0x806,0x13f4,0x13f4,0x806,0x13f5,0x13f5,0x806,0x432,0x412,0x806,0x434,
-0x414,0x806,0x43e,0x41e,0x806,0x441,0x421,0x846,0x442,0x422,1,0x1c85,0x846,0x442,0x422,1,
-0x1c84,0x806,0x44a,0x42a,0x806,0x463,0x462,0x806,0xa64b,0xa64a,0xc10,0xbc0,0x810,0x8a04,0x810,0xee6,
-0x810,0x8a38,0x841,0x1e61,1,0x1e9b,0x844,0x1e60,1,0x1e9b,0x880,0x2220,0x68,0x331,0x48,0x331,
-0x48,0x331,0x880,0x2220,0x74,0x308,0x54,0x308,0x54,0x308,0x880,0x2220,0x77,0x30a,0x57,0x30a,
-0x57,0x30a,0x880,0x2220,0x79,0x30a,0x59,0x30a,0x59,0x30a,0x880,0x2220,0x61,0x2be,0x41,0x2be,
-0x41,0x2be,0x806,0x1e61,0x1e60,0xc90,0x1dbf,0x20,0x73,0x73,0x880,0x2220,0x3c5,0x313,0x3a5,0x313,
-0x3a5,0x313,0x880,0x3330,0x3c5,0x313,0x300,0x3a5,0x313,0x300,0x3a5,0x313,0x300,0x880,0x3330,0x3c5,
-0x313,0x301,0x3a5,0x313,0x301,0x3a5,0x313,0x301,0x880,0x3330,0x3c5,0x313,0x342,0x3a5,0x313,0x342,
-0x3a5,0x313,0x342,0x890,8,0x220,0x1f00,0x3b9,0x1f08,0x399,0x890,8,0x220,0x1f01,0x3b9,0x1f09,
-0x399,0x890,8,0x220,0x1f02,0x3b9,0x1f0a,0x399,0x890,8,0x220,0x1f03,0x3b9,0x1f0b,0x399,0x890,
-8,0x220,0x1f04,0x3b9,0x1f0c,0x399,0x890,8,0x220,0x1f05,0x3b9,0x1f0d,0x399,0x890,8,0x220,
-0x1f06,0x3b9,0x1f0e,0x399,0x890,8,0x220,0x1f07,0x3b9,0x1f0f,0x399,0xc90,8,0x220,0x1f00,0x3b9,
-0x1f08,0x399,0xc90,8,0x220,0x1f01,0x3b9,0x1f09,0x399,0xc90,8,0x220,0x1f02,0x3b9,0x1f0a,0x399,
-0xc90,8,0x220,0x1f03,0x3b9,0x1f0b,0x399,0xc90,8,0x220,0x1f04,0x3b9,0x1f0c,0x399,0xc90,8,
-0x220,0x1f05,0x3b9,0x1f0d,0x399,0xc90,8,0x220,0x1f06,0x3b9,0x1f0e,0x399,0xc90,8,0x220,0x1f07,
-0x3b9,0x1f0f,0x399,0x890,8,0x220,0x1f20,0x3b9,0x1f28,0x399,0x890,8,0x220,0x1f21,0x3b9,0x1f29,
-0x399,0x890,8,0x220,0x1f22,0x3b9,0x1f2a,0x399,0x890,8,0x220,0x1f23,0x3b9,0x1f2b,0x399,0x890,
-8,0x220,0x1f24,0x3b9,0x1f2c,0x399,0x890,8,0x220,0x1f25,0x3b9,0x1f2d,0x399,0x890,8,0x220,
-0x1f26,0x3b9,0x1f2e,0x399,0x890,8,0x220,0x1f27,0x3b9,0x1f2f,0x399,0xc90,8,0x220,0x1f20,0x3b9,
-0x1f28,0x399,0xc90,8,0x220,0x1f21,0x3b9,0x1f29,0x399,0xc90,8,0x220,0x1f22,0x3b9,0x1f2a,0x399,
-0xc90,8,0x220,0x1f23,0x3b9,0x1f2b,0x399,0xc90,8,0x220,0x1f24,0x3b9,0x1f2c,0x399,0xc90,8,
-0x220,0x1f25,0x3b9,0x1f2d,0x399,0xc90,8,0x220,0x1f26,0x3b9,0x1f2e,0x399,0xc90,8,0x220,0x1f27,
-0x3b9,0x1f2f,0x399,0x890,8,0x220,0x1f60,0x3b9,0x1f68,0x399,0x890,8,0x220,0x1f61,0x3b9,0x1f69,
-0x399,0x890,8,0x220,0x1f62,0x3b9,0x1f6a,0x399,0x890,8,0x220,0x1f63,0x3b9,0x1f6b,0x399,0x890,
-8,0x220,0x1f64,0x3b9,0x1f6c,0x399,0x890,8,0x220,0x1f65,0x3b9,0x1f6d,0x399,0x890,8,0x220,
-0x1f66,0x3b9,0x1f6e,0x399,0x890,8,0x220,0x1f67,0x3b9,0x1f6f,0x399,0xc90,8,0x220,0x1f60,0x3b9,
-0x1f68,0x399,0xc90,8,0x220,0x1f61,0x3b9,0x1f69,0x399,0xc90,8,0x220,0x1f62,0x3b9,0x1f6a,0x399,
-0xc90,8,0x220,0x1f63,0x3b9,0x1f6b,0x399,0xc90,8,0x220,0x1f64,0x3b9,0x1f6c,0x399,0xc90,8,
-0x220,0x1f65,0x3b9,0x1f6d,0x399,0xc90,8,0x220,0x1f66,0x3b9,0x1f6e,0x399,0xc90,8,0x220,0x1f67,
-0x3b9,0x1f6f,0x399,0x880,0x2220,0x1f70,0x3b9,0x1fba,0x399,0x1fba,0x345,0x890,9,0x220,0x3b1,0x3b9,
-0x391,0x399,0x880,0x2220,0x3ac,0x3b9,0x386,0x399,0x386,0x345,0x880,0x2220,0x3b1,0x342,0x391,0x342,
-0x391,0x342,0x880,0x3330,0x3b1,0x342,0x3b9,0x391,0x342,0x399,0x391,0x342,0x345,0xc90,9,0x220,
-0x3b1,0x3b9,0x391,0x399,0x846,0x3b9,0x399,1,0x345,0x880,0x2220,0x1f74,0x3b9,0x1fca,0x399,0x1fca,
-0x345,0x890,9,0x220,0x3b7,0x3b9,0x397,0x399,0x880,0x2220,0x3ae,0x3b9,0x389,0x399,0x389,0x345,
-0x880,0x2220,0x3b7,0x342,0x397,0x342,0x397,0x342,0x880,0x3330,0x3b7,0x342,0x3b9,0x397,0x342,0x399,
-0x397,0x342,0x345,0xc90,9,0x220,0x3b7,0x3b9,0x397,0x399,0x880,0x3330,0x3b9,0x308,0x300,0x399,
-0x308,0x300,0x399,0x308,0x300,0x8c0,1,0x3330,0x3b9,0x308,0x301,0x399,0x308,0x301,0x399,0x308,
-0x301,0x390,0x880,0x2220,0x3b9,0x342,0x399,0x342,0x399,0x342,0x880,0x3330,0x3b9,0x308,0x342,0x399,
-0x308,0x342,0x399,0x308,0x342,0x880,0x3330,0x3c5,0x308,0x300,0x3a5,0x308,0x300,0x3a5,0x308,0x300,
-0x8c0,1,0x3330,0x3c5,0x308,0x301,0x3a5,0x308,0x301,0x3a5,0x308,0x301,0x3b0,0x880,0x2220,0x3c1,
-0x313,0x3a1,0x313,0x3a1,0x313,0x880,0x2220,0x3c5,0x342,0x3a5,0x342,0x3a5,0x342,0x880,0x3330,0x3c5,
-0x308,0x342,0x3a5,0x308,0x342,0x3a5,0x308,0x342,0x880,0x2220,0x1f7c,0x3b9,0x1ffa,0x399,0x1ffa,0x345,
-0x890,9,0x220,0x3c9,0x3b9,0x3a9,0x399,0x880,0x2220,0x3ce,0x3b9,0x38f,0x399,0x38f,0x345,0x880,
-0x2220,0x3c9,0x342,0x3a9,0x342,0x3a9,0x342,0x880,0x3330,0x3c9,0x342,0x3b9,0x3a9,0x342,0x399,0x3a9,
-0x342,0x345,0xc90,9,0x220,0x3c9,0x3b9,0x3a9,0x399,0xc50,0x1d5d,1,0x3a9,0xc50,0x20bf,1,
-0x4b,0xc50,0x2046,1,0xc5,0xc10,0x29f7,0xc10,0xee6,0xc10,0x29e7,0xc10,0x2a2b,0xc10,0x2a28,0xc10,
-0x2a1c,0xc10,0x29fd,0xc10,0x2a1f,0xc10,0x2a1e,0xc10,0x2a3f,0xc10,0x1c60,0x841,0xa64b,1,0x1c88,0x844,
-0xa64a,1,0x1c88,0xc10,0x8a04,0xc10,0xa528,0xc10,0xa544,0xc10,0xa54f,0xc10,0xa54b,0xc10,0xa541,0xc10,
-0xa512,0xc10,0xa52a,0xc10,0xa515,0x810,0x3a0,0xc10,0xa543,0xc10,0x8a38,0xc10,0x3a0,0x806,0x13a0,0x13a0,
-0x806,0x13a1,0x13a1,0x806,0x13a2,0x13a2,0x806,0x13a3,0x13a3,0x806,0x13a4,0x13a4,0x806,0x13a5,0x13a5,0x806,
-0x13a6,0x13a6,0x806,0x13a7,0x13a7,0x806,0x13a8,0x13a8,0x806,0x13a9,0x13a9,0x806,0x13aa,0x13aa,0x806,0x13ab,
-0x13ab,0x806,0x13ac,0x13ac,0x806,0x13ad,0x13ad,0x806,0x13ae,0x13ae,0x806,0x13af,0x13af,0x806,0x13b0,0x13b0,
-0x806,0x13b1,0x13b1,0x806,0x13b2,0x13b2,0x806,0x13b3,0x13b3,0x806,0x13b4,0x13b4,0x806,0x13b5,0x13b5,0x806,
-0x13b6,0x13b6,0x806,0x13b7,0x13b7,0x806,0x13b8,0x13b8,0x806,0x13b9,0x13b9,0x806,0x13ba,0x13ba,0x806,0x13bb,
-0x13bb,0x806,0x13bc,0x13bc,0x806,0x13bd,0x13bd,0x806,0x13be,0x13be,0x806,0x13bf,0x13bf,0x806,0x13c0,0x13c0,
-0x806,0x13c1,0x13c1,0x806,0x13c2,0x13c2,0x806,0x13c3,0x13c3,0x806,0x13c4,0x13c4,0x806,0x13c5,0x13c5,0x806,
-0x13c6,0x13c6,0x806,0x13c7,0x13c7,0x806,0x13c8,0x13c8,0x806,0x13c9,0x13c9,0x806,0x13ca,0x13ca,0x806,0x13cb,
-0x13cb,0x806,0x13cc,0x13cc,0x806,0x13cd,0x13cd,0x806,0x13ce,0x13ce,0x806,0x13cf,0x13cf,0x806,0x13d0,0x13d0,
-0x806,0x13d1,0x13d1,0x806,0x13d2,0x13d2,0x806,0x13d3,0x13d3,0x806,0x13d4,0x13d4,0x806,0x13d5,0x13d5,0x806,
-0x13d6,0x13d6,0x806,0x13d7,0x13d7,0x806,0x13d8,0x13d8,0x806,0x13d9,0x13d9,0x806,0x13da,0x13da,0x806,0x13db,
-0x13db,0x806,0x13dc,0x13dc,0x806,0x13dd,0x13dd,0x806,0x13de,0x13de,0x806,0x13df,0x13df,0x806,0x13e0,0x13e0,
-0x806,0x13e1,0x13e1,0x806,0x13e2,0x13e2,0x806,0x13e3,0x13e3,0x806,0x13e4,0x13e4,0x806,0x13e5,0x13e5,0x806,
-0x13e6,0x13e6,0x806,0x13e7,0x13e7,0x806,0x13e8,0x13e8,0x806,0x13e9,0x13e9,0x806,0x13ea,0x13ea,0x806,0x13eb,
-0x13eb,0x806,0x13ec,0x13ec,0x806,0x13ed,0x13ed,0x806,0x13ee,0x13ee,0x806,0x13ef,0x13ef,0x880,0x2220,0x66,
-0x66,0x46,0x46,0x46,0x66,0x880,0x2220,0x66,0x69,0x46,0x49,0x46,0x69,0x880,0x2220,0x66,
-0x6c,0x46,0x4c,0x46,0x6c,0x880,0x3330,0x66,0x66,0x69,0x46,0x46,0x49,0x46,0x66,0x69,
-0x880,0x3330,0x66,0x66,0x6c,0x46,0x46,0x4c,0x46,0x66,0x6c,0x8c0,1,0x2220,0x73,0x74,
-0x53,0x54,0x53,0x74,0xfb06,0x8c0,1,0x2220,0x73,0x74,0x53,0x54,0x53,0x74,0xfb05,0x880,
-0x2220,0x574,0x576,0x544,0x546,0x544,0x576,0x880,0x2220,0x574,0x565,0x544,0x535,0x544,0x565,0x880,
-0x2220,0x574,0x56b,0x544,0x53b,0x544,0x56b,0x880,0x2220,0x57e,0x576,0x54e,0x546,0x54e,0x576,0x880,
-0x2220,0x574,0x56d,0x544,0x53d,0x544,0x56d
+0x1c87,0x4880,0x20,0x565,0x582,0x810,0x1c60,0x80c,0x1c90,0x10d0,0x80c,0x1c91,0x10d1,0x80c,0x1c92,0x10d2,
+0x80c,0x1c93,0x10d3,0x80c,0x1c94,0x10d4,0x80c,0x1c95,0x10d5,0x80c,0x1c96,0x10d6,0x80c,0x1c97,0x10d7,0x80c,
+0x1c98,0x10d8,0x80c,0x1c99,0x10d9,0x80c,0x1c9a,0x10da,0x80c,0x1c9b,0x10db,0x80c,0x1c9c,0x10dc,0x80c,0x1c9d,
+0x10dd,0x80c,0x1c9e,0x10de,0x80c,0x1c9f,0x10df,0x80c,0x1ca0,0x10e0,0x80c,0x1ca1,0x10e1,0x80c,0x1ca2,0x10e2,
+0x80c,0x1ca3,0x10e3,0x80c,0x1ca4,0x10e4,0x80c,0x1ca5,0x10e5,0x80c,0x1ca6,0x10e6,0x80c,0x1ca7,0x10e7,0x80c,
+0x1ca8,0x10e8,0x80c,0x1ca9,0x10e9,0x80c,0x1caa,0x10ea,0x80c,0x1cab,0x10eb,0x80c,0x1cac,0x10ec,0x80c,0x1cad,
+0x10ed,0x80c,0x1cae,0x10ee,0x80c,0x1caf,0x10ef,0x80c,0x1cb0,0x10f0,0x80c,0x1cb1,0x10f1,0x80c,0x1cb2,0x10f2,
+0x80c,0x1cb3,0x10f3,0x80c,0x1cb4,0x10f4,0x80c,0x1cb5,0x10f5,0x80c,0x1cb6,0x10f6,0x80c,0x1cb7,0x10f7,0x80c,
+0x1cb8,0x10f8,0x80c,0x1cb9,0x10f9,0x80c,0x1cba,0x10fa,0x80c,0x1cbd,0x10fd,0x80c,0x1cbe,0x10fe,0x80c,0x1cbf,
+0x10ff,0xa10,0x97d0,0xa10,8,0x806,0x13f0,0x13f0,0x806,0x13f1,0x13f1,0x806,0x13f2,0x13f2,0x806,0x13f3,
+0x13f3,0x806,0x13f4,0x13f4,0x806,0x13f5,0x13f5,0x806,0x432,0x412,0x806,0x434,0x414,0x806,0x43e,0x41e,
+0x806,0x441,0x421,0x846,0x442,0x422,1,0x1c85,0x846,0x442,0x422,1,0x1c84,0x806,0x44a,0x42a,
+0x806,0x463,0x462,0x806,0xa64b,0xa64a,0xc10,0xbc0,0x810,0x8a04,0x810,0xee6,0x810,0x8a38,0x841,0x1e61,
+1,0x1e9b,0x844,0x1e60,1,0x1e9b,0x880,0x2220,0x68,0x331,0x48,0x331,0x48,0x331,0x880,0x2220,
+0x74,0x308,0x54,0x308,0x54,0x308,0x880,0x2220,0x77,0x30a,0x57,0x30a,0x57,0x30a,0x880,0x2220,
+0x79,0x30a,0x59,0x30a,0x59,0x30a,0x880,0x2220,0x61,0x2be,0x41,0x2be,0x41,0x2be,0x806,0x1e61,
+0x1e60,0xc90,0x1dbf,0x20,0x73,0x73,0x880,0x2220,0x3c5,0x313,0x3a5,0x313,0x3a5,0x313,0x880,0x3330,
+0x3c5,0x313,0x300,0x3a5,0x313,0x300,0x3a5,0x313,0x300,0x880,0x3330,0x3c5,0x313,0x301,0x3a5,0x313,
+0x301,0x3a5,0x313,0x301,0x880,0x3330,0x3c5,0x313,0x342,0x3a5,0x313,0x342,0x3a5,0x313,0x342,0x890,
+8,0x220,0x1f00,0x3b9,0x1f08,0x399,0x890,8,0x220,0x1f01,0x3b9,0x1f09,0x399,0x890,8,0x220,
+0x1f02,0x3b9,0x1f0a,0x399,0x890,8,0x220,0x1f03,0x3b9,0x1f0b,0x399,0x890,8,0x220,0x1f04,0x3b9,
+0x1f0c,0x399,0x890,8,0x220,0x1f05,0x3b9,0x1f0d,0x399,0x890,8,0x220,0x1f06,0x3b9,0x1f0e,0x399,
+0x890,8,0x220,0x1f07,0x3b9,0x1f0f,0x399,0xc90,8,0x220,0x1f00,0x3b9,0x1f08,0x399,0xc90,8,
+0x220,0x1f01,0x3b9,0x1f09,0x399,0xc90,8,0x220,0x1f02,0x3b9,0x1f0a,0x399,0xc90,8,0x220,0x1f03,
+0x3b9,0x1f0b,0x399,0xc90,8,0x220,0x1f04,0x3b9,0x1f0c,0x399,0xc90,8,0x220,0x1f05,0x3b9,0x1f0d,
+0x399,0xc90,8,0x220,0x1f06,0x3b9,0x1f0e,0x399,0xc90,8,0x220,0x1f07,0x3b9,0x1f0f,0x399,0x890,
+8,0x220,0x1f20,0x3b9,0x1f28,0x399,0x890,8,0x220,0x1f21,0x3b9,0x1f29,0x399,0x890,8,0x220,
+0x1f22,0x3b9,0x1f2a,0x399,0x890,8,0x220,0x1f23,0x3b9,0x1f2b,0x399,0x890,8,0x220,0x1f24,0x3b9,
+0x1f2c,0x399,0x890,8,0x220,0x1f25,0x3b9,0x1f2d,0x399,0x890,8,0x220,0x1f26,0x3b9,0x1f2e,0x399,
+0x890,8,0x220,0x1f27,0x3b9,0x1f2f,0x399,0xc90,8,0x220,0x1f20,0x3b9,0x1f28,0x399,0xc90,8,
+0x220,0x1f21,0x3b9,0x1f29,0x399,0xc90,8,0x220,0x1f22,0x3b9,0x1f2a,0x399,0xc90,8,0x220,0x1f23,
+0x3b9,0x1f2b,0x399,0xc90,8,0x220,0x1f24,0x3b9,0x1f2c,0x399,0xc90,8,0x220,0x1f25,0x3b9,0x1f2d,
+0x399,0xc90,8,0x220,0x1f26,0x3b9,0x1f2e,0x399,0xc90,8,0x220,0x1f27,0x3b9,0x1f2f,0x399,0x890,
+8,0x220,0x1f60,0x3b9,0x1f68,0x399,0x890,8,0x220,0x1f61,0x3b9,0x1f69,0x399,0x890,8,0x220,
+0x1f62,0x3b9,0x1f6a,0x399,0x890,8,0x220,0x1f63,0x3b9,0x1f6b,0x399,0x890,8,0x220,0x1f64,0x3b9,
+0x1f6c,0x399,0x890,8,0x220,0x1f65,0x3b9,0x1f6d,0x399,0x890,8,0x220,0x1f66,0x3b9,0x1f6e,0x399,
+0x890,8,0x220,0x1f67,0x3b9,0x1f6f,0x399,0xc90,8,0x220,0x1f60,0x3b9,0x1f68,0x399,0xc90,8,
+0x220,0x1f61,0x3b9,0x1f69,0x399,0xc90,8,0x220,0x1f62,0x3b9,0x1f6a,0x399,0xc90,8,0x220,0x1f63,
+0x3b9,0x1f6b,0x399,0xc90,8,0x220,0x1f64,0x3b9,0x1f6c,0x399,0xc90,8,0x220,0x1f65,0x3b9,0x1f6d,
+0x399,0xc90,8,0x220,0x1f66,0x3b9,0x1f6e,0x399,0xc90,8,0x220,0x1f67,0x3b9,0x1f6f,0x399,0x880,
+0x2220,0x1f70,0x3b9,0x1fba,0x399,0x1fba,0x345,0x890,9,0x220,0x3b1,0x3b9,0x391,0x399,0x880,0x2220,
+0x3ac,0x3b9,0x386,0x399,0x386,0x345,0x880,0x2220,0x3b1,0x342,0x391,0x342,0x391,0x342,0x880,0x3330,
+0x3b1,0x342,0x3b9,0x391,0x342,0x399,0x391,0x342,0x345,0xc90,9,0x220,0x3b1,0x3b9,0x391,0x399,
+0x846,0x3b9,0x399,1,0x345,0x880,0x2220,0x1f74,0x3b9,0x1fca,0x399,0x1fca,0x345,0x890,9,0x220,
+0x3b7,0x3b9,0x397,0x399,0x880,0x2220,0x3ae,0x3b9,0x389,0x399,0x389,0x345,0x880,0x2220,0x3b7,0x342,
+0x397,0x342,0x397,0x342,0x880,0x3330,0x3b7,0x342,0x3b9,0x397,0x342,0x399,0x397,0x342,0x345,0xc90,
+9,0x220,0x3b7,0x3b9,0x397,0x399,0x880,0x3330,0x3b9,0x308,0x300,0x399,0x308,0x300,0x399,0x308,
+0x300,0x8c0,1,0x3330,0x3b9,0x308,0x301,0x399,0x308,0x301,0x399,0x308,0x301,0x390,0x880,0x2220,
+0x3b9,0x342,0x399,0x342,0x399,0x342,0x880,0x3330,0x3b9,0x308,0x342,0x399,0x308,0x342,0x399,0x308,
+0x342,0x880,0x3330,0x3c5,0x308,0x300,0x3a5,0x308,0x300,0x3a5,0x308,0x300,0x8c0,1,0x3330,0x3c5,
+0x308,0x301,0x3a5,0x308,0x301,0x3a5,0x308,0x301,0x3b0,0x880,0x2220,0x3c1,0x313,0x3a1,0x313,0x3a1,
+0x313,0x880,0x2220,0x3c5,0x342,0x3a5,0x342,0x3a5,0x342,0x880,0x3330,0x3c5,0x308,0x342,0x3a5,0x308,
+0x342,0x3a5,0x308,0x342,0x880,0x2220,0x1f7c,0x3b9,0x1ffa,0x399,0x1ffa,0x345,0x890,9,0x220,0x3c9,
+0x3b9,0x3a9,0x399,0x880,0x2220,0x3ce,0x3b9,0x38f,0x399,0x38f,0x345,0x880,0x2220,0x3c9,0x342,0x3a9,
+0x342,0x3a9,0x342,0x880,0x3330,0x3c9,0x342,0x3b9,0x3a9,0x342,0x399,0x3a9,0x342,0x345,0xc90,9,
+0x220,0x3c9,0x3b9,0x3a9,0x399,0xc50,0x1d5d,1,0x3a9,0xc50,0x20bf,1,0x4b,0xc50,0x2046,1,
+0xc5,0xc10,0x29f7,0xc10,0xee6,0xc10,0x29e7,0xc10,0x2a2b,0xc10,0x2a28,0xc10,0x2a1c,0xc10,0x29fd,0xc10,
+0x2a1f,0xc10,0x2a1e,0xc10,0x2a3f,0xc10,0x1c60,0x841,0xa64b,1,0x1c88,0x844,0xa64a,1,0x1c88,0xc10,
+0x8a04,0xc10,0xa528,0xc10,0xa544,0xc10,0xa54f,0xc10,0xa54b,0xc10,0xa541,0xc10,0xa512,0xc10,0xa52a,0xc10,
+0xa515,0x810,0x3a0,0xc10,0xa543,0xc10,0x8a38,0xc10,0x3a0,0x806,0x13a0,0x13a0,0x806,0x13a1,0x13a1,0x806,
+0x13a2,0x13a2,0x806,0x13a3,0x13a3,0x806,0x13a4,0x13a4,0x806,0x13a5,0x13a5,0x806,0x13a6,0x13a6,0x806,0x13a7,
+0x13a7,0x806,0x13a8,0x13a8,0x806,0x13a9,0x13a9,0x806,0x13aa,0x13aa,0x806,0x13ab,0x13ab,0x806,0x13ac,0x13ac,
+0x806,0x13ad,0x13ad,0x806,0x13ae,0x13ae,0x806,0x13af,0x13af,0x806,0x13b0,0x13b0,0x806,0x13b1,0x13b1,0x806,
+0x13b2,0x13b2,0x806,0x13b3,0x13b3,0x806,0x13b4,0x13b4,0x806,0x13b5,0x13b5,0x806,0x13b6,0x13b6,0x806,0x13b7,
+0x13b7,0x806,0x13b8,0x13b8,0x806,0x13b9,0x13b9,0x806,0x13ba,0x13ba,0x806,0x13bb,0x13bb,0x806,0x13bc,0x13bc,
+0x806,0x13bd,0x13bd,0x806,0x13be,0x13be,0x806,0x13bf,0x13bf,0x806,0x13c0,0x13c0,0x806,0x13c1,0x13c1,0x806,
+0x13c2,0x13c2,0x806,0x13c3,0x13c3,0x806,0x13c4,0x13c4,0x806,0x13c5,0x13c5,0x806,0x13c6,0x13c6,0x806,0x13c7,
+0x13c7,0x806,0x13c8,0x13c8,0x806,0x13c9,0x13c9,0x806,0x13ca,0x13ca,0x806,0x13cb,0x13cb,0x806,0x13cc,0x13cc,
+0x806,0x13cd,0x13cd,0x806,0x13ce,0x13ce,0x806,0x13cf,0x13cf,0x806,0x13d0,0x13d0,0x806,0x13d1,0x13d1,0x806,
+0x13d2,0x13d2,0x806,0x13d3,0x13d3,0x806,0x13d4,0x13d4,0x806,0x13d5,0x13d5,0x806,0x13d6,0x13d6,0x806,0x13d7,
+0x13d7,0x806,0x13d8,0x13d8,0x806,0x13d9,0x13d9,0x806,0x13da,0x13da,0x806,0x13db,0x13db,0x806,0x13dc,0x13dc,
+0x806,0x13dd,0x13dd,0x806,0x13de,0x13de,0x806,0x13df,0x13df,0x806,0x13e0,0x13e0,0x806,0x13e1,0x13e1,0x806,
+0x13e2,0x13e2,0x806,0x13e3,0x13e3,0x806,0x13e4,0x13e4,0x806,0x13e5,0x13e5,0x806,0x13e6,0x13e6,0x806,0x13e7,
+0x13e7,0x806,0x13e8,0x13e8,0x806,0x13e9,0x13e9,0x806,0x13ea,0x13ea,0x806,0x13eb,0x13eb,0x806,0x13ec,0x13ec,
+0x806,0x13ed,0x13ed,0x806,0x13ee,0x13ee,0x806,0x13ef,0x13ef,0x880,0x2220,0x66,0x66,0x46,0x46,0x46,
+0x66,0x880,0x2220,0x66,0x69,0x46,0x49,0x46,0x69,0x880,0x2220,0x66,0x6c,0x46,0x4c,0x46,
+0x6c,0x880,0x3330,0x66,0x66,0x69,0x46,0x46,0x49,0x46,0x66,0x69,0x880,0x3330,0x66,0x66,
+0x6c,0x46,0x46,0x4c,0x46,0x66,0x6c,0x8c0,1,0x2220,0x73,0x74,0x53,0x54,0x53,0x74,
+0xfb06,0x8c0,1,0x2220,0x73,0x74,0x53,0x54,0x53,0x74,0xfb05,0x880,0x2220,0x574,0x576,0x544,
+0x546,0x544,0x576,0x880,0x2220,0x574,0x565,0x544,0x535,0x544,0x565,0x880,0x2220,0x574,0x56b,0x544,
+0x53b,0x544,0x56b,0x880,0x2220,0x57e,0x576,0x54e,0x546,0x54e,0x576,0x880,0x2220,0x574,0x56d,0x544,
+0x53d,0x544,0x56d
 };
 
 static const uint16_t ucase_props_unfold[370]={
diff --git a/deps/icu-small/source/common/ucasemap_imp.h b/deps/icu-small/source/common/ucasemap_imp.h
index 7788fd93710305e08e9a8a6bd96b61fd4afb1267..e17a0ae5a36b6d3ddd5dfd49826efb2f083fd7b7 100644
--- a/deps/icu-small/source/common/ucasemap_imp.h
+++ b/deps/icu-small/source/common/ucasemap_imp.h
@@ -68,15 +68,15 @@ class BreakIterator;        // unicode/brkiter.h
 class ByteSink;
 class Locale;               // unicode/locid.h
 
-/** Returns TRUE if the options are valid. Otherwise FALSE, and sets an error. */
+/** Returns true if the options are valid. Otherwise false, and sets an error. */
 inline UBool ustrcase_checkTitleAdjustmentOptions(uint32_t options, UErrorCode &errorCode) {
-    if (U_FAILURE(errorCode)) { return FALSE; }
+    if (U_FAILURE(errorCode)) { return false; }
     if ((options & U_TITLECASE_ADJUSTMENT_MASK) == U_TITLECASE_ADJUSTMENT_MASK) {
         // Both options together.
         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
 
 inline UBool ustrcase_isLNS(UChar32 c) {
diff --git a/deps/icu-small/source/common/uchar.cpp b/deps/icu-small/source/common/uchar.cpp
index f02ae530ccf6d8bba5fcb13ad4cbc84773ab6cfd..f43f9f024a1300fe3612844d8e7888617faa9cd9 100644
--- a/deps/icu-small/source/common/uchar.cpp
+++ b/deps/icu-small/source/common/uchar.cpp
@@ -194,7 +194,7 @@ u_isISOControl(UChar32 c) {
 
 /* Some control characters that are used as space. */
 #define IS_THAT_CONTROL_SPACE(c) \
-    (c<=0x9f && ((c>=TAB && c<=CR) || (c>=0x1c && c <=0x1f) || c==NL))
+    (c<=0x9f && ((c>=TAB && c<=CR) || (c>=0x1c && c <=0x1f) || c==0x85))
 
 /* Java has decided that U+0085 New Line is not whitespace any more. */
 #define IS_THAT_ASCII_CONTROL_SPACE(c) \
@@ -677,14 +677,14 @@ uchar_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) {
     sa->add(sa->set, CR+1); /* range TAB..CR */
     sa->add(sa->set, 0x1c);
     sa->add(sa->set, 0x1f+1);
-    USET_ADD_CP_AND_NEXT(sa, NL);
+    USET_ADD_CP_AND_NEXT(sa, 0x85);  // NEXT LINE (NEL)
 
     /* add for u_isIDIgnorable() what was not added above */
-    sa->add(sa->set, DEL); /* range DEL..NBSP-1, NBSP added below */
+    sa->add(sa->set, 0x7f); /* range DEL..NBSP-1, NBSP added below */
     sa->add(sa->set, HAIRSP);
     sa->add(sa->set, RLM+1);
-    sa->add(sa->set, INHSWAP);
-    sa->add(sa->set, NOMDIG+1);
+    sa->add(sa->set, 0x206a);  // INHIBIT SYMMETRIC SWAPPING
+    sa->add(sa->set, 0x206f+1);  // NOMINAL DIGIT SHAPES
     USET_ADD_CP_AND_NEXT(sa, ZWNBSP);
 
     /* add no-break spaces for u_isWhitespace() what was not added above */
@@ -693,23 +693,25 @@ uchar_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) {
     USET_ADD_CP_AND_NEXT(sa, NNBSP);
 
     /* add for u_digit() */
-    sa->add(sa->set, U_a);
-    sa->add(sa->set, U_z+1);
-    sa->add(sa->set, U_A);
-    sa->add(sa->set, U_Z+1);
-    sa->add(sa->set, U_FW_a);
-    sa->add(sa->set, U_FW_z+1);
-    sa->add(sa->set, U_FW_A);
-    sa->add(sa->set, U_FW_Z+1);
+    sa->add(sa->set, u'a');
+    sa->add(sa->set, u'z'+1);
+    sa->add(sa->set, u'A');
+    sa->add(sa->set, u'Z'+1);
+    // fullwidth
+    sa->add(sa->set, u'ａ');
+    sa->add(sa->set, u'ｚ'+1);
+    sa->add(sa->set, u'Ａ');
+    sa->add(sa->set, u'Ｚ'+1);
 
     /* add for u_isxdigit() */
-    sa->add(sa->set, U_f+1);
-    sa->add(sa->set, U_F+1);
-    sa->add(sa->set, U_FW_f+1);
-    sa->add(sa->set, U_FW_F+1);
+    sa->add(sa->set, u'f'+1);
+    sa->add(sa->set, u'F'+1);
+    // fullwidth
+    sa->add(sa->set, u'ｆ'+1);
+    sa->add(sa->set, u'Ｆ'+1);
 
     /* add for UCHAR_DEFAULT_IGNORABLE_CODE_POINT what was not added above */
-    sa->add(sa->set, WJ); /* range WJ..NOMDIG */
+    sa->add(sa->set, 0x2060); /* range 2060..206f */
     sa->add(sa->set, 0xfff0);
     sa->add(sa->set, 0xfffb+1);
     sa->add(sa->set, 0xe0000);
diff --git a/deps/icu-small/source/common/ucln_cmn.h b/deps/icu-small/source/common/ucln_cmn.h
index b837fb946296a1ad9593cc0a11e93d7df0630d78..44b73e94da791ffc1483aa0929e2a7fe04497b0e 100644
--- a/deps/icu-small/source/common/ucln_cmn.h
+++ b/deps/icu-small/source/common/ucln_cmn.h
@@ -38,6 +38,8 @@ typedef enum ECleanupCommonType {
     UCLN_COMMON_SERVICE,
     UCLN_COMMON_LOCALE_KEY_TYPE,
     UCLN_COMMON_LOCALE,
+    UCLN_COMMON_LOCALE_ALIAS,
+    UCLN_COMMON_LOCALE_KNOWN_CANONICALIZED,
     UCLN_COMMON_LOCALE_AVAILABLE,
     UCLN_COMMON_LIKELY_SUBTAGS,
     UCLN_COMMON_LOCALE_DISTANCE,
diff --git a/deps/icu-small/source/common/ucln_imp.h b/deps/icu-small/source/common/ucln_imp.h
index 2e985669793b823a8ae31f198a8d6aad218c8db3..b08c6e8368b1a30d5ee6d81b553ba5b64810827e 100644
--- a/deps/icu-small/source/common/ucln_imp.h
+++ b/deps/icu-small/source/common/ucln_imp.h
@@ -78,7 +78,7 @@
  * Use the ANSI C 'atexit' function. Note that this mechanism does not
  * guarantee the order of cleanup relative to other users of ICU!
  */
-static UBool gAutoCleanRegistered = FALSE;
+static UBool gAutoCleanRegistered = false;
 
 static void ucln_atexit_handler()
 {
@@ -88,7 +88,7 @@ static void ucln_atexit_handler()
 static void ucln_registerAutomaticCleanup()
 {
     if(!gAutoCleanRegistered) {
-        gAutoCleanRegistered = TRUE;
+        gAutoCleanRegistered = true;
         atexit(&ucln_atexit_handler);
     }
 }
@@ -135,7 +135,7 @@ U_CAPI void U_EXPORT2 UCLN_FINI ()
  */
 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
-    BOOL status = TRUE;
+    BOOL status = true;
 
     switch(fdwReason) {
         case DLL_PROCESS_ATTACH:
diff --git a/deps/icu-small/source/common/ucnv2022.cpp b/deps/icu-small/source/common/ucnv2022.cpp
index 89db9e81ddea0605dedd1a9e90b46d583cc601eb..c274ebe41982f277d3d7c9f2d2be8d85acf39fd0 100644
--- a/deps/icu-small/source/common/ucnv2022.cpp
+++ b/deps/icu-small/source/common/ucnv2022.cpp
@@ -820,7 +820,7 @@ getKey_2022(char c,int32_t* key,int32_t* offset){
     return INVALID_2022;
 }
 
-/*runs through a state machine to determine the escape sequence - codepage correspondance
+/*runs through a state machine to determine the escape sequence - codepage correspondence
  */
 static void
 changeState_2022(UConverter* _this,
@@ -1424,7 +1424,7 @@ toUnicodeCallback(UConverter *cnv,
 *          KSC5601 : alias to ibm-949 mapping table
 *          GB2312 : alias to ibm-1386 mapping table
 *          ISO-8859-1 : Algorithmic implemented as LATIN1 case
-*          ISO-8859-7 : alisas to ibm-9409 mapping table
+*          ISO-8859-7 : alias to ibm-9409 mapping table
 */
 
 /* preference order of JP charsets */
@@ -2324,7 +2324,7 @@ endloop:
 /***************************************************************
 *   Rules for ISO-2022-KR encoding
 *   i) The KSC5601 designator sequence should appear only once in a file,
-*      at the begining of a line before any KSC5601 characters. This usually
+*      at the beginning of a line before any KSC5601 characters. This usually
 *      means that it appears by itself on the first line of the file
 *  ii) There are only 2 shifting sequences SO to shift into double byte mode
 *      and SI to shift into single byte mode
diff --git a/deps/icu-small/source/common/ucnv_bld.cpp b/deps/icu-small/source/common/ucnv_bld.cpp
index 1c2363ea89981f0a9b6145409f0641deca434960..d08eec73696f942443e1028d2839f5943709926f 100644
--- a/deps/icu-small/source/common/ucnv_bld.cpp
+++ b/deps/icu-small/source/common/ucnv_bld.cpp
@@ -262,7 +262,7 @@ static UBool U_CALLCONV ucnv_cleanup(void) {
 }
 
 U_CAPI void U_EXPORT2
-ucnv_enableCleanup() {
+ucnv_enableCleanup(void) {
     ucln_common_registerCleanup(UCLN_COMMON_UCNV, ucnv_cleanup);
 }
 
@@ -427,7 +427,7 @@ getAlgorithmicTypeFromName(const char *realName)
 #define UCNV_CACHE_LOAD_FACTOR 2
 
 /* Puts the shared data in the static hashtable SHARED_DATA_HASHTABLE */
-/*   Will always be called with the cnvCacheMutex alrady being held   */
+/*   Will always be called with the cnvCacheMutex already being held   */
 /*     by the calling function.                                       */
 /* Stores the shared data in the SHARED_DATA_HASHTABLE
  * @param data The shared data
diff --git a/deps/icu-small/source/common/ucnv_bld.h b/deps/icu-small/source/common/ucnv_bld.h
index caa263f56d938b0bc5fe2b2c08b215df8bd51ab6..43e6c09ac0b0f8fc28457bac3eb13e7e38ba2751 100644
--- a/deps/icu-small/source/common/ucnv_bld.h
+++ b/deps/icu-small/source/common/ucnv_bld.h
@@ -101,8 +101,8 @@ struct UConverterSharedData {
 
     const UConverterStaticData *staticData; /* pointer to the static (non changing) data. */
 
-    UBool                sharedDataCached;   /* TRUE:  shared data is in cache, don't destroy on ucnv_close() if 0 ref.  FALSE: shared data isn't in the cache, do attempt to clean it up if the ref is 0 */
-    /** If FALSE, then referenceCounter is not used. Must not change after initialization. */
+    UBool                sharedDataCached;   /* true:  shared data is in cache, don't destroy on ucnv_close() if 0 ref.  false: shared data isn't in the cache, do attempt to clean it up if the ref is 0 */
+    /** If false, then referenceCounter is not used. Must not change after initialization. */
     UBool isReferenceCounted;
 
     const UConverterImpl *impl;     /* vtable-style struct of mostly function pointers */
@@ -128,7 +128,7 @@ struct UConverterSharedData {
 #define UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(pStaticData, pImpl) \
     { \
         sizeof(UConverterSharedData), ~((uint32_t)0), \
-        NULL, pStaticData, FALSE, FALSE, pImpl, \
+        NULL, pStaticData, false, false, pImpl, \
         0, UCNV_MBCS_TABLE_INITIALIZER \
     }
 
@@ -181,9 +181,9 @@ struct UConverter {
 
     uint32_t options; /* options flags from UConverterOpen, may contain additional bits */
 
-    UBool sharedDataIsCached;  /* TRUE:  shared data is in cache, don't destroy on ucnv_close() if 0 ref.  FALSE: shared data isn't in the cache, do attempt to clean it up if the ref is 0 */
-    UBool isCopyLocal;  /* TRUE if UConverter is not owned and not released in ucnv_close() (stack-allocated, safeClone(), etc.) */
-    UBool isExtraLocal; /* TRUE if extraInfo is not owned and not released in ucnv_close() (stack-allocated, safeClone(), etc.) */
+    UBool sharedDataIsCached;  /* true:  shared data is in cache, don't destroy on ucnv_close() if 0 ref.  false: shared data isn't in the cache, do attempt to clean it up if the ref is 0 */
+    UBool isCopyLocal;  /* true if UConverter is not owned and not released in ucnv_close() (stack-allocated, safeClone(), etc.) */
+    UBool isExtraLocal; /* true if extraInfo is not owned and not released in ucnv_close() (stack-allocated, safeClone(), etc.) */
 
     UBool  useFallback;
     int8_t toULength;                   /* number of bytes in toUBytes */
@@ -289,7 +289,7 @@ ucnv_swap(const UDataSwapper *ds,
           UErrorCode *pErrorCode);
 
 U_CAPI void U_EXPORT2
-ucnv_enableCleanup();
+ucnv_enableCleanup(void);
 
 #endif
 
diff --git a/deps/icu-small/source/common/ucnv_cnv.h b/deps/icu-small/source/common/ucnv_cnv.h
index a996e2959784cf5e80d3ef9435a199e3e1727acc..345a1998e44883a15df34bbc3ca83cdc5d530416 100644
--- a/deps/icu-small/source/common/ucnv_cnv.h
+++ b/deps/icu-small/source/common/ucnv_cnv.h
@@ -59,7 +59,7 @@ typedef struct {
 } UConverterLoadArgs;
 
 #define UCNV_LOAD_ARGS_INITIALIZER \
-    { (int32_t)sizeof(UConverterLoadArgs), 0, FALSE, FALSE, 0, 0, NULL, NULL, NULL }
+    { (int32_t)sizeof(UConverterLoadArgs), 0, false, false, 0, 0, NULL, NULL, NULL }
 
 typedef void (*UConverterLoad) (UConverterSharedData *sharedData,
                                 UConverterLoadArgs *pArgs,
@@ -267,8 +267,8 @@ extern const UConverterSharedData
 U_CDECL_END
 
 /** Always use fallbacks from codepage to Unicode */
-#define TO_U_USE_FALLBACK(useFallback) TRUE
-#define UCNV_TO_U_USE_FALLBACK(cnv) TRUE
+#define TO_U_USE_FALLBACK(useFallback) true
+#define UCNV_TO_U_USE_FALLBACK(cnv) true
 
 /** Use fallbacks from Unicode to codepage when cnv->useFallback or for private-use code points */
 #define IS_PRIVATE_USE(c) ((uint32_t)((c)-0xe000)<0x1900 || (uint32_t)((c)-0xf0000)<0x20000)
diff --git a/deps/icu-small/source/common/ucnv_err.cpp b/deps/icu-small/source/common/ucnv_err.cpp
index 63794d2334f62b786c2a2370b188747bcac7c600..7d9ac46506f8feb3b7e70fe66790095642e4b3ca 100644
--- a/deps/icu-small/source/common/ucnv_err.cpp
+++ b/deps/icu-small/source/common/ucnv_err.cpp
@@ -321,7 +321,7 @@ UCNV_FROM_U_CALLBACK_ESCAPE (
       case UCNV_PRV_ESCAPE_CSS2:
           valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT;    /* adding \ */
           valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 0);
-          /* Always add space character, becase the next character might be whitespace,
+          /* Always add space character, because the next character might be whitespace,
              which would erroneously be considered the termination of the escape sequence. */
           valueString[valueStringLength++] = (UChar) UNICODE_SPACE_CODEPOINT;
           break;
diff --git a/deps/icu-small/source/common/ucnv_lmb.cpp b/deps/icu-small/source/common/ucnv_lmb.cpp
index 5e7cfde353d7e32560daf43029deb5640b7164e0..bead464afd4a14b189e57a7955e76b4e626cabb8 100644
--- a/deps/icu-small/source/common/ucnv_lmb.cpp
+++ b/deps/icu-small/source/common/ucnv_lmb.cpp
@@ -81,7 +81,7 @@
   [G] D1 [D2]
 
   That is, a sometimes-optional 'group' byte, followed by 1 and sometimes 2
-  data bytes. The maximum size of a LMBCS chjaracter is 3 bytes:
+  data bytes. The maximum size of a LMBCS character is 3 bytes:
 */
 #define ULMBCS_CHARSIZE_MAX      3
 /*
@@ -164,7 +164,7 @@ beginning of internal 'system' range names: */
 /* Then we needed a place to put all the other ansi control characters
 that must be moved to different values because LMBCS reserves those
 values for other purposes. To represent the control characters, we start
-with a first byte of 0xF & add the control chaarcter value as the
+with a first byte of 0xF & add the control character value as the
 second byte */
 #define ULMBCS_GRP_CTRL       0x0F
 
diff --git a/deps/icu-small/source/common/ucnv_u7.cpp b/deps/icu-small/source/common/ucnv_u7.cpp
index ec7befe9fc9a78a70ee9bc282f367def2912b3d7..a5a9485b73f36b09c06956def5b01fc98761d3c7 100644
--- a/deps/icu-small/source/common/ucnv_u7.cpp
+++ b/deps/icu-small/source/common/ucnv_u7.cpp
@@ -814,7 +814,7 @@ const UConverterSharedData _UTF7Data=
  *       the use of "~" in some servers as a home directory indicator.
  *
  *    5) UTF-7 permits multiple alternate forms to represent the same
- *       string; in particular, printable US-ASCII chararacters can be
+ *       string; in particular, printable US-ASCII characters can be
  *       represented in encoded form.
  *
  * In modified UTF-7, printable US-ASCII characters except for "&"
diff --git a/deps/icu-small/source/common/ucnv_u8.cpp b/deps/icu-small/source/common/ucnv_u8.cpp
index 878d67304c7d89d7c3de4a2d504092754bbc7ddb..9cf4a81ab2ef361db5f9e7fbbe5d1b63a68b17fa 100644
--- a/deps/icu-small/source/common/ucnv_u8.cpp
+++ b/deps/icu-small/source/common/ucnv_u8.cpp
@@ -707,9 +707,9 @@ ucnv_UTF8FromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
 
         // Do not go back into the bytes that will be read for finishing a partial
         // sequence from the previous buffer.
-        int32_t length=count-toULimit;
+        int32_t length=count-toULength;
         U8_TRUNCATE_IF_INCOMPLETE(source, 0, length);
-        count=toULimit+length;
+        count=toULength+length;
     }
 
     if(c!=0) {
diff --git a/deps/icu-small/source/common/ucnvisci.cpp b/deps/icu-small/source/common/ucnvisci.cpp
index c1ab06e137ee22de19797cbf71e23288c705bd3e..4d2815a3a652b389b34f39ca1a4078da8fdc932f 100644
--- a/deps/icu-small/source/common/ucnvisci.cpp
+++ b/deps/icu-small/source/common/ucnvisci.cpp
@@ -992,7 +992,7 @@ UConverter_fromUnicode_ISCII_OFFSETS_LOGIC(
 
                     if (converterData->currentDeltaFromUnicode == PNJ_DELTA) {
                         if (sourceChar == PNJ_TIPPI) {
-                            /* Make sure Tippi is converterd to Bindi. */
+                            /* Make sure Tippi is converted to Bindi. */
                             sourceChar = PNJ_BINDI;
                         } else if (sourceChar == PNJ_ADHAK) {
                             /* This is for consonant cluster handling. */
@@ -1147,7 +1147,7 @@ static const uint16_t lookupTable[][2]={
     /* is the code point valid in current script? */                                     \
     if(sourceChar> ASCII_END &&                                                          \
             (validityTable[(targetUniChar & 0x7F)] & data->currentMaskToUnicode)==0){    \
-        /* Vocallic RR is assigne in ISCII Telugu and Unicode */                         \
+        /* Vocallic RR is assigned in ISCII Telugu and Unicode */                         \
         if(data->currentDeltaToUnicode!=(TELUGU_DELTA) ||                                \
                     targetUniChar!=VOCALLIC_RR){                                         \
             targetUniChar=missingCharMarker;                                             \
@@ -1272,7 +1272,7 @@ UConverter_toUnicode_ISCII_OFFSETS_LOGIC(UConverterToUnicodeArgs *args, UErrorCo
                 goto CALLBACK;
             } else if (*contextCharToUnicode==ISCII_INV) {
                 if (sourceChar==ISCII_HALANT) {
-                    targetUniChar = 0x0020; /* replace with space accoding to Indic FAQ */
+                    targetUniChar = 0x0020; /* replace with space according to Indic FAQ */
                 } else {
                     targetUniChar = ZWJ;
                 }
diff --git a/deps/icu-small/source/common/ucnvmbcs.h b/deps/icu-small/source/common/ucnvmbcs.h
index a750b92e499c6ea17104f3d7cb73900b61fd68ba..ddc55b20fec2715a9b0fdd0f0c3f70300a7662ae 100644
--- a/deps/icu-small/source/common/ucnvmbcs.h
+++ b/deps/icu-small/source/common/ucnvmbcs.h
@@ -420,7 +420,7 @@ typedef struct UConverterMBCSTable {
     NULL, \
     0, \
     0, 0, \
-    FALSE, \
+    false, \
     0, \
      \
     /* roundtrips */ \
diff --git a/deps/icu-small/source/common/ucol_swp.h b/deps/icu-small/source/common/ucol_swp.h
index fd8be9aa54ff45f99a10f84cc41e3a474d3298ef..0c2990a85ecfc2889544559d487ba049afe91168 100644
--- a/deps/icu-small/source/common/ucol_swp.h
+++ b/deps/icu-small/source/common/ucol_swp.h
@@ -31,7 +31,7 @@
  * Does the data look like a collation binary?
  * @internal
  */
-U_INTERNAL UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucol_looksLikeCollationBinary(const UDataSwapper *ds,
                               const void *inData, int32_t length);
 
diff --git a/deps/icu-small/source/common/ucurr.cpp b/deps/icu-small/source/common/ucurr.cpp
index 391b08083b899af1504aa7ae973e72f2c8af5b92..d38ce3d604d15dda83518ff4efe19985609c90c1 100644
--- a/deps/icu-small/source/common/ucurr.cpp
+++ b/deps/icu-small/source/common/ucurr.cpp
@@ -91,6 +91,8 @@ static const char VAR_DELIM = '_';
 // Tag for localized display names (symbols) of currencies
 static const char CURRENCIES[] = "Currencies";
 static const char CURRENCIES_NARROW[] = "Currencies%narrow";
+static const char CURRENCIES_FORMAL[] = "Currencies%formal";
+static const char CURRENCIES_VARIANT[] = "Currencies%variant";
 static const char CURRENCYPLURALS[] = "CurrencyPlurals";
 
 // ISO codes mapping table
@@ -649,7 +651,7 @@ ucurr_getName(const UChar* currency,
     }
 
     int32_t choice = (int32_t) nameStyle;
-    if (choice < 0 || choice > 2) {
+    if (choice < 0 || choice > 4) {
         *ec = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
@@ -684,9 +686,22 @@ ucurr_getName(const UChar* currency,
     ec2 = U_ZERO_ERROR;
     LocalUResourceBundlePointer rb(ures_open(U_ICUDATA_CURR, loc, &ec2));
 
-    if (nameStyle == UCURR_NARROW_SYMBOL_NAME) {
+    if (nameStyle == UCURR_NARROW_SYMBOL_NAME || nameStyle == UCURR_FORMAL_SYMBOL_NAME || nameStyle == UCURR_VARIANT_SYMBOL_NAME) {
         CharString key;
-        key.append(CURRENCIES_NARROW, ec2);
+        switch (nameStyle) {
+        case UCURR_NARROW_SYMBOL_NAME:
+            key.append(CURRENCIES_NARROW, ec2);
+            break;
+        case UCURR_FORMAL_SYMBOL_NAME:
+            key.append(CURRENCIES_FORMAL, ec2);
+            break;
+        case UCURR_VARIANT_SYMBOL_NAME:
+            key.append(CURRENCIES_VARIANT, ec2);
+            break;
+        default:
+            *ec = U_UNSUPPORTED_ERROR;
+            return 0;
+        }
         key.append("/", ec2);
         key.append(buf, ec2);
         s = ures_getStringByKeyWithFallback(rb.getAlias(), key.data(), len, &ec2);
@@ -829,7 +844,7 @@ typedef struct {
 #endif
 
 
-// Comparason function used in quick sort.
+// Comparison function used in quick sort.
 static int U_CALLCONV currencyNameComparator(const void* a, const void* b) {
     const CurrencyNameStruct* currName_1 = (const CurrencyNameStruct*)a;
     const CurrencyNameStruct* currName_2 = (const CurrencyNameStruct*)b;
@@ -1515,7 +1530,7 @@ uprv_parseCurrency(const char* locale,
 
     int32_t max = 0;
     int32_t matchIndex = -1;
-    // case in-sensitive comparision against currency names
+    // case in-sensitive comparison against currency names
     searchCurrencyName(currencyNames, total_currency_name_count,
                        upperText, textLen, partialMatchLen, &max, &matchIndex);
 
@@ -1610,7 +1625,7 @@ ucurr_getDefaultFractionDigits(const UChar* currency, UErrorCode* ec) {
     return ucurr_getDefaultFractionDigitsForUsage(currency,UCURR_USAGE_STANDARD,ec);
 }
 
-U_DRAFT int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucurr_getDefaultFractionDigitsForUsage(const UChar* currency, const UCurrencyUsage usage, UErrorCode* ec) {
     int32_t fracDigits = 0;
     if (U_SUCCESS(*ec)) {
@@ -1633,7 +1648,7 @@ ucurr_getRoundingIncrement(const UChar* currency, UErrorCode* ec) {
     return ucurr_getRoundingIncrementForUsage(currency, UCURR_USAGE_STANDARD, ec);
 }
 
-U_DRAFT double U_EXPORT2
+U_CAPI double U_EXPORT2
 ucurr_getRoundingIncrementForUsage(const UChar* currency, const UCurrencyUsage usage, UErrorCode* ec) {
     double result = 0.0;
 
@@ -2259,7 +2274,6 @@ ucurr_countCurrencies(const char* locale,
         // local variables
         UErrorCode localStatus = U_ZERO_ERROR;
         char id[ULOC_FULLNAME_CAPACITY];
-        uloc_getKeywordValue(locale, "currency", id, ULOC_FULLNAME_CAPACITY, &localStatus);
 
         // get country or country_variant in `id'
         idForLocale(locale, id, sizeof(id), ec);
@@ -2375,7 +2389,6 @@ ucurr_forLocaleAndDate(const char* locale,
             // local variables
             UErrorCode localStatus = U_ZERO_ERROR;
             char id[ULOC_FULLNAME_CAPACITY];
-            resLen = uloc_getKeywordValue(locale, "currency", id, ULOC_FULLNAME_CAPACITY, &localStatus);
 
             // get country or country_variant in `id'
             idForLocale(locale, id, sizeof(id), ec);
diff --git a/deps/icu-small/source/common/uelement.h b/deps/icu-small/source/common/uelement.h
index 9d45f09fb87f65a79f6375d0fa8d22080097f1b5..e4d16afe4e2753e9e12d523919a329bffe0f31f6 100644
--- a/deps/icu-small/source/common/uelement.h
+++ b/deps/icu-small/source/common/uelement.h
@@ -46,7 +46,7 @@ typedef union UElement UElement;
  * An element-equality (boolean) comparison function.
  * @param e1 An element (object or integer)
  * @param e2 An element (object or integer)
- * @return TRUE if the two elements are equal.
+ * @return true if the two elements are equal.
  */
 typedef UBool U_CALLCONV UElementsAreEqual(const UElement e1, const UElement e2);
 
diff --git a/deps/icu-small/source/common/uhash.cpp b/deps/icu-small/source/common/uhash.cpp
index 86311ceb0b25d1db97339286960319740b14f5d5..67c7c36354030788b1dacbc54f49db43d78e094d 100644
--- a/deps/icu-small/source/common/uhash.cpp
+++ b/deps/icu-small/source/common/uhash.cpp
@@ -133,8 +133,10 @@ static const float RESIZE_POLICY_RATIO_TABLE[6] = {
  * or a pointer.  If a hint bit is zero, then the associated
  * token is assumed to be an integer.
  */
+#define HINT_BOTH_INTEGERS (0)
 #define HINT_KEY_POINTER   (1)
 #define HINT_VALUE_POINTER (2)
+#define HINT_ALLOW_ZERO    (4)
 
 /********************************************************************
  * PRIVATE Implementation
@@ -479,8 +481,9 @@ _uhash_put(UHashtable *hash,
         goto err;
     }
     U_ASSERT(hash != NULL);
-    /* Cannot always check pointer here or iSeries sees NULL every time. */
-    if ((hint & HINT_VALUE_POINTER) && value.pointer == NULL) {
+    if ((hint & HINT_VALUE_POINTER) ?
+            value.pointer == NULL :
+            value.integer == 0 && (hint & HINT_ALLOW_ZERO) == 0) {
         /* Disallow storage of NULL values, since NULL is returned by
          * get() to indicate an absent key.  Storing NULL == removing.
          */
@@ -687,6 +690,28 @@ uhash_igeti(const UHashtable *hash,
     return _uhash_find(hash, keyholder, hash->keyHasher(keyholder))->value.integer;
 }
 
+U_CAPI int32_t U_EXPORT2
+uhash_getiAndFound(const UHashtable *hash,
+                   const void *key,
+                   UBool *found) {
+    UHashTok keyholder;
+    keyholder.pointer = (void *)key;
+    const UHashElement *e = _uhash_find(hash, keyholder, hash->keyHasher(keyholder));
+    *found = !IS_EMPTY_OR_DELETED(e->hashcode);
+    return e->value.integer;
+}
+
+U_CAPI int32_t U_EXPORT2
+uhash_igetiAndFound(const UHashtable *hash,
+                    int32_t key,
+                    UBool *found) {
+    UHashTok keyholder;
+    keyholder.integer = key;
+    const UHashElement *e = _uhash_find(hash, keyholder, hash->keyHasher(keyholder));
+    *found = !IS_EMPTY_OR_DELETED(e->hashcode);
+    return e->value.integer;
+}
+
 U_CAPI void* U_EXPORT2
 uhash_put(UHashtable *hash,
           void* key,
@@ -736,7 +761,34 @@ uhash_iputi(UHashtable *hash,
     keyholder.integer = key;
     valueholder.integer = value;
     return _uhash_put(hash, keyholder, valueholder,
-                      0, /* neither is a ptr */
+                      HINT_BOTH_INTEGERS,
+                      status).integer;
+}
+
+U_CAPI int32_t U_EXPORT2
+uhash_putiAllowZero(UHashtable *hash,
+                    void *key,
+                    int32_t value,
+                    UErrorCode *status) {
+    UHashTok keyholder, valueholder;
+    keyholder.pointer = key;
+    valueholder.integer = value;
+    return _uhash_put(hash, keyholder, valueholder,
+                      HINT_KEY_POINTER | HINT_ALLOW_ZERO,
+                      status).integer;
+}
+
+
+U_CAPI int32_t U_EXPORT2
+uhash_iputiAllowZero(UHashtable *hash,
+                     int32_t key,
+                     int32_t value,
+                     UErrorCode *status) {
+    UHashTok keyholder, valueholder;
+    keyholder.integer = key;
+    valueholder.integer = value;
+    return _uhash_put(hash, keyholder, valueholder,
+                      HINT_BOTH_INTEGERS | HINT_ALLOW_ZERO,
                       status).integer;
 }
 
@@ -785,6 +837,29 @@ uhash_removeAll(UHashtable *hash) {
     U_ASSERT(hash->count == 0);
 }
 
+U_CAPI UBool U_EXPORT2
+uhash_containsKey(const UHashtable *hash, const void *key) {
+    UHashTok keyholder;
+    keyholder.pointer = (void *)key;
+    const UHashElement *e = _uhash_find(hash, keyholder, hash->keyHasher(keyholder));
+    return !IS_EMPTY_OR_DELETED(e->hashcode);
+}
+
+/**
+ * Returns true if the UHashtable contains an item with this integer key.
+ *
+ * @param hash The target UHashtable.
+ * @param key An integer key stored in a hashtable
+ * @return true if the key is found.
+ */
+U_CAPI UBool U_EXPORT2
+uhash_icontainsKey(const UHashtable *hash, int32_t key) {
+    UHashTok keyholder;
+    keyholder.integer = key;
+    const UHashElement *e = _uhash_find(hash, keyholder, hash->keyHasher(keyholder));
+    return !IS_EMPTY_OR_DELETED(e->hashcode);
+}
+
 U_CAPI const UHashElement* U_EXPORT2
 uhash_find(const UHashtable *hash, const void* key) {
     UHashTok keyholder;
diff --git a/deps/icu-small/source/common/uhash.h b/deps/icu-small/source/common/uhash.h
index b59d2711bb29d03c0ac7380f0a56cd83071c951e..af75999860dbb4fc678bcdb4fb91d2aaad11ff1c 100644
--- a/deps/icu-small/source/common/uhash.h
+++ b/deps/icu-small/source/common/uhash.h
@@ -23,7 +23,7 @@
 /**
  * UHashtable stores key-value pairs and does moderately fast lookup
  * based on keys.  It provides a good tradeoff between access time and
- * storage space.  As elements are added to it, it grows to accomodate
+ * storage space.  As elements are added to it, it grows to accommodate
  * them.  By default, the table never shrinks, even if all elements
  * are removed from it.
  *
@@ -54,6 +54,13 @@
  * uhash_remove() on that key.  This keeps uhash_get(), uhash_count(),
  * and uhash_nextElement() consistent with one another.
  *
+ * Keys and values can be integers.
+ * Functions that work with an integer key have an "i" prefix.
+ * Functions that work with an integer value have an "i" suffix.
+ * As with putting a NULL value pointer, putting a zero value integer removes the item.
+ * Except, there are pairs of functions that allow setting zero values
+ * and fetching (value, found) pairs.
+ *
  * To see everything in a hashtable, use uhash_nextElement() to
  * iterate through its contents.  Each call to this function returns a
  * UHashElement pointer.  A hash element contains a key, value, and
@@ -405,6 +412,44 @@ uhash_iputi(UHashtable *hash,
            int32_t value,
            UErrorCode *status);
 
+/**
+ * Put a (key=pointer, value=integer) item in a UHashtable.  If the
+ * keyDeleter is non-NULL, then the hashtable owns 'key' after this
+ * call.  valueDeleter must be NULL.
+ * Storing a 0 value is possible; call uhash_igetiAndFound() to retrieve values including zero.
+ *
+ * @param hash The target UHashtable.
+ * @param key The key to store.
+ * @param value The integer value to store.
+ * @param status A pointer to an UErrorCode to receive any errors.
+ * @return The previous value, or 0 if none.
+ * @see uhash_getiAndFound
+ */
+U_CAPI int32_t U_EXPORT2
+uhash_putiAllowZero(UHashtable *hash,
+                    void *key,
+                    int32_t value,
+                    UErrorCode *status);
+
+/**
+ * Put a (key=integer, value=integer) item in a UHashtable.  If the
+ * keyDeleter is non-NULL, then the hashtable owns 'key' after this
+ * call.  valueDeleter must be NULL.
+ * Storing a 0 value is possible; call uhash_igetiAndFound() to retrieve values including zero.
+ *
+ * @param hash The target UHashtable.
+ * @param key The key to store.
+ * @param value The integer value to store.
+ * @param status A pointer to an UErrorCode to receive any errors.
+ * @return The previous value, or 0 if none.
+ * @see uhash_igetiAndFound
+ */
+U_CAPI int32_t U_EXPORT2
+uhash_iputiAllowZero(UHashtable *hash,
+                     int32_t key,
+                     int32_t value,
+                     UErrorCode *status);
+
 /**
  * Retrieve a pointer value from a UHashtable using a pointer key,
  * as previously stored by uhash_put().
@@ -448,6 +493,34 @@ U_CAPI int32_t U_EXPORT2
 uhash_igeti(const UHashtable *hash,
            int32_t key);
 
+/**
+ * Retrieves an integer value from a UHashtable using a pointer key,
+ * as previously stored by uhash_putiAllowZero() or uhash_puti().
+ *
+ * @param hash The target UHashtable.
+ * @param key A pointer key stored in a hashtable
+ * @param found A pointer to a boolean which will be set for whether the key was found.
+ * @return The requested item, or 0 if not found.
+ */
+U_CAPI int32_t U_EXPORT2
+uhash_getiAndFound(const UHashtable *hash,
+                   const void *key,
+                   UBool *found);
+
+/**
+ * Retrieves an integer value from a UHashtable using an integer key,
+ * as previously stored by uhash_iputiAllowZero() or uhash_iputi().
+ *
+ * @param hash The target UHashtable.
+ * @param key An integer key stored in a hashtable
+ * @param found A pointer to a boolean which will be set for whether the key was found.
+ * @return The requested item, or 0 if not found.
+ */
+U_CAPI int32_t U_EXPORT2
+uhash_igetiAndFound(const UHashtable *hash,
+                    int32_t key,
+                    UBool *found);
+
 /**
  * Remove an item from a UHashtable stored by uhash_put().
  * @param hash The target UHashtable.
@@ -495,6 +568,26 @@ uhash_iremovei(UHashtable *hash,
 U_CAPI void U_EXPORT2
 uhash_removeAll(UHashtable *hash);
 
+/**
+ * Returns true if the UHashtable contains an item with this pointer key.
+ *
+ * @param hash The target UHashtable.
+ * @param key A pointer key stored in a hashtable
+ * @return true if the key is found.
+ */
+U_CAPI UBool U_EXPORT2
+uhash_containsKey(const UHashtable *hash, const void *key);
+
+/**
+ * Returns true if the UHashtable contains an item with this integer key.
+ *
+ * @param hash The target UHashtable.
+ * @param key An integer key stored in a hashtable
+ * @return true if the key is found.
+ */
+U_CAPI UBool U_EXPORT2
+uhash_icontainsKey(const UHashtable *hash, int32_t key);
+
 /**
  * Locate an element of a UHashtable.  The caller must not modify the
  * returned object.  The primary use of this function is to obtain the
diff --git a/deps/icu-small/source/common/uinvchar.cpp b/deps/icu-small/source/common/uinvchar.cpp
index ac9716066f22b7fffec863d71d80085c61aa29b8..7fce257baf09125a816fa16aa8cc5a53cb82e9ab 100644
--- a/deps/icu-small/source/common/uinvchar.cpp
+++ b/deps/icu-small/source/common/uinvchar.cpp
@@ -579,7 +579,7 @@ uprv_ebcdicToLowercaseAscii(char c) {
     return (char)lowercaseAsciiFromEbcdic[(uint8_t)c];
 }
 
-U_INTERNAL uint8_t* U_EXPORT2
+U_CAPI uint8_t* U_EXPORT2
 uprv_aestrncpy(uint8_t *dst, const uint8_t *src, int32_t n)
 {
   uint8_t *orig_dst = dst;
@@ -600,7 +600,7 @@ uprv_aestrncpy(uint8_t *dst, const uint8_t *src, int32_t n)
   return orig_dst;
 }
 
-U_INTERNAL uint8_t* U_EXPORT2
+U_CAPI uint8_t* U_EXPORT2
 uprv_eastrncpy(uint8_t *dst, const uint8_t *src, int32_t n)
 {
   uint8_t *orig_dst = dst;
diff --git a/deps/icu-small/source/common/uinvchar.h b/deps/icu-small/source/common/uinvchar.h
index a43cfcd98286fe093a993750de541227101919ed..9b7a9bd114172e285afd026f1d19df6ae0818270 100644
--- a/deps/icu-small/source/common/uinvchar.h
+++ b/deps/icu-small/source/common/uinvchar.h
@@ -33,11 +33,11 @@
  *
  * @param s Input string pointer.
  * @param length Length of the string, can be -1 if NUL-terminated.
- * @return TRUE if s contains only invariant characters.
+ * @return true if s contains only invariant characters.
  *
  * @internal (ICU 2.8)
  */
-U_INTERNAL UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uprv_isInvariantString(const char *s, int32_t length);
 
 /**
@@ -46,11 +46,11 @@ uprv_isInvariantString(const char *s, int32_t length);
  *
  * @param s Input string pointer.
  * @param length Length of the string, can be -1 if NUL-terminated.
- * @return TRUE if s contains only invariant characters.
+ * @return true if s contains only invariant characters.
  *
  * @internal (ICU 2.8)
  */
-U_INTERNAL UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uprv_isInvariantUString(const UChar *s, int32_t length);
 
 /**
@@ -141,7 +141,7 @@ uprv_isEbcdicAtSign(char c);
  * Compare two EBCDIC invariant-character strings in ASCII order.
  * @internal
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uprv_compareInvEbcdicAsAscii(const char *s1, const char *s2);
 
 /**
@@ -161,7 +161,7 @@ uprv_compareInvEbcdicAsAscii(const char *s1, const char *s2);
  * Converts an EBCDIC invariant character to ASCII.
  * @internal
  */
-U_INTERNAL char U_EXPORT2
+U_CAPI char U_EXPORT2
 uprv_ebcdicToAscii(char c);
 
 /**
@@ -181,7 +181,7 @@ uprv_ebcdicToAscii(char c);
  * Converts an EBCDIC invariant character to lowercase ASCII.
  * @internal
  */
-U_INTERNAL char U_EXPORT2
+U_CAPI char U_EXPORT2
 uprv_ebcdicToLowercaseAscii(char c);
 
 /**
@@ -202,7 +202,7 @@ uprv_ebcdicToLowercaseAscii(char c);
  * @internal
  * @see uprv_strncpy
  */
-U_INTERNAL uint8_t* U_EXPORT2
+U_CAPI uint8_t* U_EXPORT2
 uprv_aestrncpy(uint8_t *dst, const uint8_t *src, int32_t n);
 
 
@@ -211,7 +211,7 @@ uprv_aestrncpy(uint8_t *dst, const uint8_t *src, int32_t n);
  * @internal
  * @see uprv_strncpy
  */
-U_INTERNAL uint8_t* U_EXPORT2
+U_CAPI uint8_t* U_EXPORT2
 uprv_eastrncpy(uint8_t *dst, const uint8_t *src, int32_t n);
 
 
diff --git a/deps/icu-small/source/common/uloc.cpp b/deps/icu-small/source/common/uloc.cpp
index 0e235d7958ceb1b6fbda0ca104cc5dfec158a62c..d96e79b8fdd805ce944f49a81ebfd048e46847cc 100644
--- a/deps/icu-small/source/common/uloc.cpp
+++ b/deps/icu-small/source/common/uloc.cpp
@@ -50,9 +50,6 @@
 #include "uassert.h"
 #include "charstr.h"
 
-#include <algorithm>
-#include <stdio.h> /* for sprintf */
-
 U_NAMESPACE_USE
 
 /* ### Declarations **************************************************/
@@ -60,12 +57,6 @@ U_NAMESPACE_USE
 /* Locale stuff from locid.cpp */
 U_CFUNC void locale_set_default(const char *id);
 U_CFUNC const char *locale_get_default(void);
-U_CFUNC int32_t
-locale_getKeywords(const char *localeID,
-            char prev,
-            char *keywords, int32_t keywordCapacity,
-            UBool valuesToo,
-            UErrorCode *status);
 
 /* ### Data tables **************************************************/
 
@@ -152,7 +143,7 @@ static const char * const LANGUAGES[] = {
     "mad", "maf", "mag", "mai", "mak", "man", "mas", "mde",
     "mdf", "mdh", "mdr", "men", "mer", "mfe", "mg",  "mga",
     "mgh", "mgo", "mh",  "mi",  "mic", "min", "mis", "mk",
-    "ml",  "mn",  "mnc", "mni", "mo",
+    "ml",  "mn",  "mnc", "mni",
     "moh", "mos", "mr",  "mrj",
     "ms",  "mt",  "mua", "mul", "mus", "mwl", "mwr", "mwv",
     "my",  "mye", "myv", "mzn",
@@ -175,9 +166,9 @@ static const char * const LANGUAGES[] = {
     "sl",  "sli", "sly", "sm",  "sma", "smj", "smn", "sms",
     "sn",  "snk", "so",  "sog", "sq",  "sr",  "srn", "srr",
     "ss",  "ssy", "st",  "stq", "su",  "suk", "sus", "sux",
-    "sv",  "sw",  "swb", "swc", "syc", "syr", "szl",
+    "sv",  "sw",  "swb", "syc", "syr", "szl",
     "ta",  "tcy", "te",  "tem", "teo", "ter", "tet", "tg",
-    "th",  "ti",  "tig", "tiv", "tk",  "tkl", "tkr", "tl",
+    "th",  "ti",  "tig", "tiv", "tk",  "tkl", "tkr",
     "tlh", "tli", "tly", "tmh", "tn",  "to",  "tog", "tpi",
     "tr",  "tru", "trv", "ts",  "tsd", "tsi", "tt",  "ttt",
     "tum", "tvl", "tw",  "twq", "ty",  "tyv", "tzm",
@@ -190,7 +181,7 @@ static const char * const LANGUAGES[] = {
     "za",  "zap", "zbl", "zea", "zen", "zgh", "zh",  "zu",
     "zun", "zxx", "zza",
 NULL,
-    "in",  "iw",  "ji",  "jw",  "sh",    /* obsolete language codes */
+    "in",  "iw",  "ji",  "jw",  "mo",  "sh",  "swc", "tl",  /* obsolete language codes */
 NULL
 };
 
@@ -269,7 +260,7 @@ static const char * const LANGUAGES_3[] = {
     "mad", "maf", "mag", "mai", "mak", "man", "mas", "mde",
     "mdf", "mdh", "mdr", "men", "mer", "mfe", "mlg", "mga",
     "mgh", "mgo", "mah", "mri", "mic", "min", "mis", "mkd",
-    "mal", "mon", "mnc", "mni", "mol",
+    "mal", "mon", "mnc", "mni",
     "moh", "mos", "mar", "mrj",
     "msa", "mlt", "mua", "mul", "mus", "mwl", "mwr", "mwv",
     "mya", "mye", "myv", "mzn",
@@ -292,9 +283,9 @@ static const char * const LANGUAGES_3[] = {
     "slv", "sli", "sly", "smo", "sma", "smj", "smn", "sms",
     "sna", "snk", "som", "sog", "sqi", "srp", "srn", "srr",
     "ssw", "ssy", "sot", "stq", "sun", "suk", "sus", "sux",
-    "swe", "swa", "swb", "swc", "syc", "syr", "szl",
+    "swe", "swa", "swb", "syc", "syr", "szl",
     "tam", "tcy", "tel", "tem", "teo", "ter", "tet", "tgk",
-    "tha", "tir", "tig", "tiv", "tuk", "tkl", "tkr", "tgl",
+    "tha", "tir", "tig", "tiv", "tuk", "tkl", "tkr",
     "tlh", "tli", "tly", "tmh", "tsn", "ton", "tog", "tpi",
     "tur", "tru", "trv", "tso", "tsd", "tsi", "tat", "ttt",
     "tum", "tvl", "twi", "twq", "tah", "tyv", "tzm",
@@ -307,8 +298,8 @@ static const char * const LANGUAGES_3[] = {
     "zha", "zap", "zbl", "zea", "zen", "zgh", "zho", "zul",
     "zun", "zxx", "zza",
 NULL,
-/*  "in",  "iw",  "ji",  "jw",  "sh",                          */
-    "ind", "heb", "yid", "jaw", "srp",
+/*  "in",  "iw",  "ji",  "jw",  "mo",  "sh",  "swc", "tl",  */
+    "ind", "heb", "yid", "jaw", "mol", "srp", "swc", "tgl",
 NULL
 };
 
@@ -343,13 +334,13 @@ static const char * const COUNTRIES[] = {
     "BJ",  "BL",  "BM",  "BN",  "BO",  "BQ",  "BR",  "BS",  "BT",  "BV",
     "BW",  "BY",  "BZ",  "CA",  "CC",  "CD",  "CF",  "CG",
     "CH",  "CI",  "CK",  "CL",  "CM",  "CN",  "CO",  "CR",
-    "CU",  "CV",  "CW",  "CX",  "CY",  "CZ",  "DE",  "DJ",  "DK",
-    "DM",  "DO",  "DZ",  "EC",  "EE",  "EG",  "EH",  "ER",
+    "CU",  "CV",  "CW",  "CX",  "CY",  "CZ",  "DE",  "DG",  "DJ",  "DK",
+    "DM",  "DO",  "DZ",  "EA",  "EC",  "EE",  "EG",  "EH",  "ER",
     "ES",  "ET",  "FI",  "FJ",  "FK",  "FM",  "FO",  "FR",
     "GA",  "GB",  "GD",  "GE",  "GF",  "GG",  "GH",  "GI",  "GL",
     "GM",  "GN",  "GP",  "GQ",  "GR",  "GS",  "GT",  "GU",
     "GW",  "GY",  "HK",  "HM",  "HN",  "HR",  "HT",  "HU",
-    "ID",  "IE",  "IL",  "IM",  "IN",  "IO",  "IQ",  "IR",  "IS",
+    "IC",  "ID",  "IE",  "IL",  "IM",  "IN",  "IO",  "IQ",  "IR",  "IS",
     "IT",  "JE",  "JM",  "JO",  "JP",  "KE",  "KG",  "KH",  "KI",
     "KM",  "KN",  "KP",  "KR",  "KW",  "KY",  "KZ",  "LA",
     "LB",  "LC",  "LI",  "LK",  "LR",  "LS",  "LT",  "LU",
@@ -366,7 +357,7 @@ static const char * const COUNTRIES[] = {
     "TK",  "TL",  "TM",  "TN",  "TO",  "TR",  "TT",  "TV",
     "TW",  "TZ",  "UA",  "UG",  "UM",  "US",  "UY",  "UZ",
     "VA",  "VC",  "VE",  "VG",  "VI",  "VN",  "VU",  "WF",
-    "WS",  "YE",  "YT",  "ZA",  "ZM",  "ZW",
+    "WS",  "XK",  "YE",  "YT",  "ZA",  "ZM",  "ZW",
 NULL,
     "AN",  "BU", "CS", "FX", "RO", "SU", "TP", "YD", "YU", "ZR",   /* obsolete country codes */
 NULL
@@ -406,10 +397,10 @@ static const char * const COUNTRIES_3[] = {
     "BWA", "BLR", "BLZ", "CAN", "CCK", "COD", "CAF", "COG",
 /*  "CH",  "CI",  "CK",  "CL",  "CM",  "CN",  "CO",  "CR",     */
     "CHE", "CIV", "COK", "CHL", "CMR", "CHN", "COL", "CRI",
-/*  "CU",  "CV",  "CW",  "CX",  "CY",  "CZ",  "DE",  "DJ",  "DK",     */
-    "CUB", "CPV", "CUW", "CXR", "CYP", "CZE", "DEU", "DJI", "DNK",
-/*  "DM",  "DO",  "DZ",  "EC",  "EE",  "EG",  "EH",  "ER",     */
-    "DMA", "DOM", "DZA", "ECU", "EST", "EGY", "ESH", "ERI",
+/*  "CU",  "CV",  "CW",  "CX",  "CY",  "CZ",  "DE",  "DG",  "DJ",  "DK",     */
+    "CUB", "CPV", "CUW", "CXR", "CYP", "CZE", "DEU", "DGA", "DJI", "DNK",
+/*  "DM",  "DO",  "DZ",  "EA",  "EC",  "EE",  "EG",  "EH",  "ER",     */
+    "DMA", "DOM", "DZA", "XEA", "ECU", "EST", "EGY", "ESH", "ERI",
 /*  "ES",  "ET",  "FI",  "FJ",  "FK",  "FM",  "FO",  "FR",     */
     "ESP", "ETH", "FIN", "FJI", "FLK", "FSM", "FRO", "FRA",
 /*  "GA",  "GB",  "GD",  "GE",  "GF",  "GG",  "GH",  "GI",  "GL",     */
@@ -418,8 +409,8 @@ static const char * const COUNTRIES_3[] = {
     "GMB", "GIN", "GLP", "GNQ", "GRC", "SGS", "GTM", "GUM",
 /*  "GW",  "GY",  "HK",  "HM",  "HN",  "HR",  "HT",  "HU",     */
     "GNB", "GUY", "HKG", "HMD", "HND", "HRV", "HTI", "HUN",
-/*  "ID",  "IE",  "IL",  "IM",  "IN",  "IO",  "IQ",  "IR",  "IS" */
-    "IDN", "IRL", "ISR", "IMN", "IND", "IOT", "IRQ", "IRN", "ISL",
+/*  "IC",  "ID",  "IE",  "IL",  "IM",  "IN",  "IO",  "IQ",  "IR",  "IS" */
+    "XIC", "IDN", "IRL", "ISR", "IMN", "IND", "IOT", "IRQ", "IRN", "ISL",
 /*  "IT",  "JE",  "JM",  "JO",  "JP",  "KE",  "KG",  "KH",  "KI",     */
     "ITA", "JEY", "JAM", "JOR", "JPN", "KEN", "KGZ", "KHM", "KIR",
 /*  "KM",  "KN",  "KP",  "KR",  "KW",  "KY",  "KZ",  "LA",     */
@@ -452,8 +443,8 @@ static const char * const COUNTRIES_3[] = {
     "TWN", "TZA", "UKR", "UGA", "UMI", "USA", "URY", "UZB",
 /*  "VA",  "VC",  "VE",  "VG",  "VI",  "VN",  "VU",  "WF",     */
     "VAT", "VCT", "VEN", "VGB", "VIR", "VNM", "VUT", "WLF",
-/*  "WS",  "YE",  "YT",  "ZA",  "ZM",  "ZW",          */
-    "WSM", "YEM", "MYT", "ZAF", "ZMB", "ZWE",
+/*  "WS",  "XK",  "YE",  "YT",  "ZA",  "ZM",  "ZW",          */
+    "WSM", "XXK", "YEM", "MYT", "ZAF", "ZMB", "ZWE",
 NULL,
 /*  "AN",  "BU",  "CS",  "FX",  "RO", "SU",  "TP",  "YD",  "YU",  "ZR" */
     "ANT", "BUR", "SCG", "FXX", "ROM", "SUN", "TMP", "YMD", "YUG", "ZAR",
@@ -601,12 +592,12 @@ compareKeywordStructs(const void * /*context*/, const void *left, const void *ri
     return uprv_strcmp(leftString, rightString);
 }
 
-static void
-_getKeywords(const char *localeID,
-             char prev,
-             ByteSink& sink,
-             UBool valuesToo,
-             UErrorCode *status)
+U_CFUNC void
+ulocimp_getKeywords(const char *localeID,
+                    char prev,
+                    ByteSink& sink,
+                    UBool valuesToo,
+                    UErrorCode *status)
 {
     KeywordStruct keywordList[ULOC_MAX_NO_KEYWORDS];
 
@@ -722,18 +713,18 @@ _getKeywords(const char *localeID,
     }
 }
 
-U_CFUNC int32_t
-locale_getKeywords(const char *localeID,
-                   char prev,
-                   char *keywords, int32_t keywordCapacity,
-                   UBool valuesToo,
-                   UErrorCode *status) {
+U_CAPI int32_t U_EXPORT2
+uloc_getKeywordValue(const char* localeID,
+                     const char* keywordName,
+                     char* buffer, int32_t bufferCapacity,
+                     UErrorCode* status)
+{
     if (U_FAILURE(*status)) {
         return 0;
     }
 
-    CheckedArrayByteSink sink(keywords, keywordCapacity);
-    _getKeywords(localeID, prev, sink, valuesToo, status);
+    CheckedArrayByteSink sink(buffer, bufferCapacity);
+    ulocimp_getKeywordValue(localeID, keywordName, sink, status);
 
     int32_t reslen = sink.NumberOfBytesAppended();
 
@@ -744,26 +735,22 @@ locale_getKeywords(const char *localeID,
     if (sink.Overflowed()) {
         *status = U_BUFFER_OVERFLOW_ERROR;
     } else {
-        u_terminateChars(keywords, keywordCapacity, reslen, status);
+        u_terminateChars(buffer, bufferCapacity, reslen, status);
     }
 
     return reslen;
 }
 
-U_CAPI int32_t U_EXPORT2
-uloc_getKeywordValue(const char* localeID,
-                     const char* keywordName,
-                     char* buffer, int32_t bufferCapacity,
-                     UErrorCode* status)
+U_CAPI void U_EXPORT2
+ulocimp_getKeywordValue(const char* localeID,
+                        const char* keywordName,
+                        icu::ByteSink& sink,
+                        UErrorCode* status)
 {
-    if (buffer != nullptr) {
-        buffer[0] = '\0';
-    }
     const char* startSearchHere = NULL;
     const char* nextSeparator = NULL;
     char keywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
     char localeKeywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
-    int32_t result = 0;
 
     if(status && U_SUCCESS(*status) && localeID) {
       char tempBuffer[ULOC_FULLNAME_CAPACITY];
@@ -771,12 +758,12 @@ uloc_getKeywordValue(const char* localeID,
 
       if (keywordName == NULL || keywordName[0] == 0) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
-        return 0;
+        return;
       }
 
       locale_canonKeywordName(keywordNameBuffer, keywordName, status);
       if(U_FAILURE(*status)) {
-        return 0;
+        return;
       }
 
       if (_hasBCP47Extension(localeID)) {
@@ -788,7 +775,7 @@ uloc_getKeywordValue(const char* localeID,
       startSearchHere = locale_getKeywordsStart(tmpLocaleID);
       if(startSearchHere == NULL) {
           /* no keywords, return at once */
-          return 0;
+          return;
       }
 
       /* find the first keyword */
@@ -800,7 +787,7 @@ uloc_getKeywordValue(const char* localeID,
           nextSeparator = uprv_strchr(startSearchHere, '=');
           if(!nextSeparator) {
               *status = U_ILLEGAL_ARGUMENT_ERROR; /* key must have =value */
-              return 0;
+              return;
           }
           /* strip leading & trailing spaces (TC decided to tolerate these) */
           while(*startSearchHere == ' ') {
@@ -814,20 +801,20 @@ uloc_getKeywordValue(const char* localeID,
           /* copy & normalize keyName from locale */
           if (startSearchHere == keyValueTail) {
               *status = U_ILLEGAL_ARGUMENT_ERROR; /* empty keyword name in passed-in locale */
-              return 0;
+              return;
           }
           keyValueLen = 0;
           while (startSearchHere < keyValueTail) {
             if (!UPRV_ISALPHANUM(*startSearchHere)) {
               *status = U_ILLEGAL_ARGUMENT_ERROR; /* malformed keyword name */
-              return 0;
+              return;
             }
             if (keyValueLen < ULOC_KEYWORD_BUFFER_LEN - 1) {
               localeKeywordNameBuffer[keyValueLen++] = uprv_tolower(*startSearchHere++);
             } else {
               /* keyword name too long for internal buffer */
               *status = U_INTERNAL_PROGRAM_ERROR;
-              return 0;
+              return;
             }
           }
           localeKeywordNameBuffer[keyValueLen] = 0; /* terminate */
@@ -848,28 +835,20 @@ uloc_getKeywordValue(const char* localeID,
               /* Now copy the value, but check well-formedness */
               if (nextSeparator == keyValueTail) {
                 *status = U_ILLEGAL_ARGUMENT_ERROR; /* empty key value name in passed-in locale */
-                return 0;
+                return;
               }
-              keyValueLen = 0;
               while (nextSeparator < keyValueTail) {
                 if (!UPRV_ISALPHANUM(*nextSeparator) && !UPRV_OK_VALUE_PUNCTUATION(*nextSeparator)) {
                   *status = U_ILLEGAL_ARGUMENT_ERROR; /* malformed key value */
-                  return 0;
-                }
-                if (keyValueLen < bufferCapacity) {
-                  /* Should we lowercase value to return here? Tests expect as-is. */
-                  buffer[keyValueLen++] = *nextSeparator++;
-                } else { /* keep advancing so we return correct length in case of overflow */
-                  keyValueLen++;
-                  nextSeparator++;
+                  return;
                 }
+                /* Should we lowercase value to return here? Tests expect as-is. */
+                sink.Append(nextSeparator++, 1);
               }
-              result = u_terminateChars(buffer, bufferCapacity, keyValueLen, status);
-              return result;
+              return;
           }
       }
     }
-    return 0;
 }
 
 U_CAPI int32_t U_EXPORT2
@@ -892,13 +871,15 @@ uloc_setKeywordValue(const char* keywordName,
     char* startSearchHere = NULL;
     char* keywordStart = NULL;
     CharString updatedKeysAndValues;
-    int32_t updatedKeysAndValuesLen;
     UBool handledInputKeyAndValue = FALSE;
     char keyValuePrefix = '@';
 
     if(U_FAILURE(*status)) {
         return -1;
     }
+    if (*status == U_STRING_NOT_TERMINATED_WARNING) {
+        *status = U_ZERO_ERROR;
+    }
     if (keywordName == NULL || keywordName[0] == 0 || bufferCapacity <= 1) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
@@ -936,6 +917,7 @@ uloc_setKeywordValue(const char* keywordName,
     startSearchHere = (char*)locale_getKeywordsStart(buffer);
     if(startSearchHere == NULL || (startSearchHere[1]==0)) {
         if(keywordValueLen == 0) { /* no keywords = nothing to remove */
+            U_ASSERT(*status != U_STRING_NOT_TERMINATED_WARNING);
             return bufLen;
         }
 
@@ -955,6 +937,7 @@ uloc_setKeywordValue(const char* keywordName,
         startSearchHere += keywordNameLen;
         *startSearchHere++ = '=';
         uprv_strcpy(startSearchHere, keywordValueBuffer);
+        U_ASSERT(*status != U_STRING_NOT_TERMINATED_WARNING);
         return needLen;
     } /* end shortcut - no @ */
 
@@ -1069,20 +1052,26 @@ uloc_setKeywordValue(const char* keywordName,
     if (!handledInputKeyAndValue || U_FAILURE(*status)) {
         /* if input key/value specified removal of a keyword not present in locale, or
          * there was an error in CharString.append, leave original locale alone. */
+        U_ASSERT(*status != U_STRING_NOT_TERMINATED_WARNING);
         return bufLen;
     }
 
-    updatedKeysAndValuesLen = updatedKeysAndValues.length();
-    /* needLen = length of the part before '@' + length of updated key-value part including '@' */
-    needLen = (int32_t)(startSearchHere - buffer) + updatedKeysAndValuesLen;
-    if(needLen >= bufferCapacity) {
+    // needLen = length of the part before '@'
+    needLen = (int32_t)(startSearchHere - buffer);
+    // Check to see can we fit the startSearchHere, if not, return
+    // U_BUFFER_OVERFLOW_ERROR without copy updatedKeysAndValues into it.
+    // We do this because this API function does not behave like most others:
+    // It promises never to set a U_STRING_NOT_TERMINATED_WARNING.
+    // When the contents fits but without the terminating NUL, in this case we need to not change
+    // the buffer contents and return with a buffer overflow error.
+    int32_t appendLength = updatedKeysAndValues.length();
+    if (appendLength >= bufferCapacity - needLen) {
         *status = U_BUFFER_OVERFLOW_ERROR;
-        return needLen; /* no change */
-    }
-    if (updatedKeysAndValuesLen > 0) {
-        uprv_strncpy(startSearchHere, updatedKeysAndValues.data(), updatedKeysAndValuesLen);
+        return needLen + appendLength;
     }
-    buffer[needLen]=0;
+    needLen += updatedKeysAndValues.extract(
+                         startSearchHere, bufferCapacity - needLen, *status);
+    U_ASSERT(*status != U_STRING_NOT_TERMINATED_WARNING);
     return needLen;
 }
 
@@ -1148,7 +1137,7 @@ uloc_getCurrentLanguageID(const char* oldID){
  *
  * TODO try to use this in Locale
  */
-static CharString
+CharString U_EXPORT2
 ulocimp_getLanguage(const char *localeID,
                     const char **pEnd,
                     UErrorCode &status) {
@@ -1193,21 +1182,7 @@ ulocimp_getLanguage(const char *localeID,
     return result;
 }
 
-U_CFUNC int32_t
-ulocimp_getLanguage(const char *localeID,
-                    char *language, int32_t languageCapacity,
-                    const char **pEnd) {
-    ErrorCode status;
-    CharString result = ulocimp_getLanguage(localeID, pEnd, status);
-    if (status.isFailure()) {
-        return 0;
-    }
-    int32_t reslen = result.length();
-    uprv_memcpy(language, result.data(), std::min(reslen, languageCapacity));
-    return reslen;
-}
-
-static CharString
+CharString U_EXPORT2
 ulocimp_getScript(const char *localeID,
                   const char **pEnd,
                   UErrorCode &status) {
@@ -1241,21 +1216,7 @@ ulocimp_getScript(const char *localeID,
     return result;
 }
 
-U_CFUNC int32_t
-ulocimp_getScript(const char *localeID,
-                  char *script, int32_t scriptCapacity,
-                  const char **pEnd) {
-    ErrorCode status;
-    CharString result = ulocimp_getScript(localeID, pEnd, status);
-    if (status.isFailure()) {
-        return 0;
-    }
-    int32_t reslen = result.length();
-    uprv_memcpy(script, result.data(), std::min(reslen, scriptCapacity));
-    return reslen;
-}
-
-static CharString
+CharString U_EXPORT2
 ulocimp_getCountry(const char *localeID,
                    const char **pEnd,
                    UErrorCode &status) {
@@ -1290,29 +1251,15 @@ ulocimp_getCountry(const char *localeID,
     return result;
 }
 
-U_CFUNC int32_t
-ulocimp_getCountry(const char *localeID,
-                   char *country, int32_t countryCapacity,
-                   const char **pEnd) {
-    ErrorCode status;
-    CharString result = ulocimp_getCountry(localeID, pEnd, status);
-    if (status.isFailure()) {
-        return 0;
-    }
-    int32_t reslen = result.length();
-    uprv_memcpy(country, result.data(), std::min(reslen, countryCapacity));
-    return reslen;
-}
-
 /**
  * @param needSeparator if true, then add leading '_' if any variants
  * are added to 'variant'
  */
 static void
-_getVariantEx(const char *localeID,
-              char prev,
-              ByteSink& sink,
-              UBool needSeparator) {
+_getVariant(const char *localeID,
+            char prev,
+            ByteSink& sink,
+            UBool needSeparator) {
     UBool hasVariant = FALSE;
 
     /* get one or more variant tags and separate them with '_' */
@@ -1353,23 +1300,6 @@ _getVariantEx(const char *localeID,
     }
 }
 
-static int32_t
-_getVariantEx(const char *localeID,
-              char prev,
-              char *variant, int32_t variantCapacity,
-              UBool needSeparator) {
-    CheckedArrayByteSink sink(variant, variantCapacity);
-    _getVariantEx(localeID, prev, sink, needSeparator);
-    return sink.NumberOfBytesAppended();
-}
-
-static int32_t
-_getVariant(const char *localeID,
-            char prev,
-            char *variant, int32_t variantCapacity) {
-    return _getVariantEx(localeID, prev, variant, variantCapacity, FALSE);
-}
-
 /* Keyword enumeration */
 
 typedef struct UKeywordsContext {
@@ -1466,9 +1396,6 @@ U_CAPI UEnumeration* U_EXPORT2
 uloc_openKeywords(const char* localeID,
                         UErrorCode* status)
 {
-    int32_t i=0;
-    char keywords[256];
-    int32_t keywordsCapacity = 256;
     char tempBuffer[ULOC_FULLNAME_CAPACITY];
     const char* tmpLocaleID;
 
@@ -1486,34 +1413,42 @@ uloc_openKeywords(const char* localeID,
     }
 
     /* Skip the language */
-    ulocimp_getLanguage(tmpLocaleID, NULL, 0, &tmpLocaleID);
+    ulocimp_getLanguage(tmpLocaleID, &tmpLocaleID, *status);
+    if (U_FAILURE(*status)) {
+        return 0;
+    }
+
     if(_isIDSeparator(*tmpLocaleID)) {
         const char *scriptID;
         /* Skip the script if available */
-        ulocimp_getScript(tmpLocaleID+1, NULL, 0, &scriptID);
+        ulocimp_getScript(tmpLocaleID+1, &scriptID, *status);
+        if (U_FAILURE(*status)) {
+            return 0;
+        }
         if(scriptID != tmpLocaleID+1) {
             /* Found optional script */
             tmpLocaleID = scriptID;
         }
         /* Skip the Country */
         if (_isIDSeparator(*tmpLocaleID)) {
-            ulocimp_getCountry(tmpLocaleID+1, NULL, 0, &tmpLocaleID);
-            if(_isIDSeparator(*tmpLocaleID)) {
-                _getVariant(tmpLocaleID+1, *tmpLocaleID, NULL, 0);
+            ulocimp_getCountry(tmpLocaleID+1, &tmpLocaleID, *status);
+            if (U_FAILURE(*status)) {
+                return 0;
             }
         }
     }
 
     /* keywords are located after '@' */
     if((tmpLocaleID = locale_getKeywordsStart(tmpLocaleID)) != NULL) {
-        i=locale_getKeywords(tmpLocaleID+1, '@', keywords, keywordsCapacity, FALSE, status);
-    }
-
-    if(i) {
-        return uloc_openKeywordList(keywords, i, status);
-    } else {
-        return NULL;
+        CharString keywords;
+        CharStringByteSink sink(&keywords);
+        ulocimp_getKeywords(tmpLocaleID+1, '@', sink, FALSE, status);
+        if (U_FAILURE(*status)) {
+            return NULL;
+        }
+        return uloc_openKeywordList(keywords.data(), keywords.length(), status);
     }
+    return NULL;
 }
 
 
@@ -1605,7 +1540,7 @@ _canonicalize(const char* localeID,
                 variantSize = -tag.length();
                 {
                     CharStringByteSink s(&tag);
-                    _getVariantEx(tmpLocaleID+1, *tmpLocaleID, s, FALSE);
+                    _getVariant(tmpLocaleID+1, *tmpLocaleID, s, FALSE);
                 }
                 variantSize += tag.length();
                 if (variantSize > 0) {
@@ -1667,7 +1602,7 @@ _canonicalize(const char* localeID,
             int32_t posixVariantSize = -tag.length();
             {
                 CharStringByteSink s(&tag);
-                _getVariantEx(tmpLocaleID+1, '@', s, (UBool)(variantSize > 0));
+                _getVariant(tmpLocaleID+1, '@', s, (UBool)(variantSize > 0));
             }
             posixVariantSize += tag.length();
             if (posixVariantSize > 0) {
@@ -1696,7 +1631,7 @@ _canonicalize(const char* localeID,
             (!separatorIndicator || separatorIndicator > keywordAssign)) {
             sink.Append("@", 1);
             ++fieldCount;
-            _getKeywords(tmpLocaleID+1, '@', sink, TRUE, err);
+            ulocimp_getKeywords(tmpLocaleID+1, '@', sink, TRUE, err);
         }
     }
 }
@@ -1745,7 +1680,6 @@ uloc_getLanguage(const char*    localeID,
          UErrorCode* err)
 {
     /* uloc_getLanguage will return a 2 character iso-639 code if one exists. *CWB*/
-    int32_t i=0;
 
     if (err==NULL || U_FAILURE(*err)) {
         return 0;
@@ -1755,8 +1689,7 @@ uloc_getLanguage(const char*    localeID,
         localeID=uloc_getDefault();
     }
 
-    i=ulocimp_getLanguage(localeID, language, languageCapacity, NULL);
-    return u_terminateChars(language, languageCapacity, i, err);
+    return ulocimp_getLanguage(localeID, NULL, *err).extract(language, languageCapacity, *err);
 }
 
 U_CAPI int32_t U_EXPORT2
@@ -1765,8 +1698,6 @@ uloc_getScript(const char*    localeID,
          int32_t scriptCapacity,
          UErrorCode* err)
 {
-    int32_t i=0;
-
     if(err==NULL || U_FAILURE(*err)) {
         return 0;
     }
@@ -1776,11 +1707,15 @@ uloc_getScript(const char*    localeID,
     }
 
     /* skip the language */
-    ulocimp_getLanguage(localeID, NULL, 0, &localeID);
+    ulocimp_getLanguage(localeID, &localeID, *err);
+    if (U_FAILURE(*err)) {
+        return 0;
+    }
+
     if(_isIDSeparator(*localeID)) {
-        i=ulocimp_getScript(localeID+1, script, scriptCapacity, NULL);
+        return ulocimp_getScript(localeID+1, NULL, *err).extract(script, scriptCapacity, *err);
     }
-    return u_terminateChars(script, scriptCapacity, i, err);
+    return u_terminateChars(script, scriptCapacity, 0, err);
 }
 
 U_CAPI int32_t  U_EXPORT2
@@ -1789,8 +1724,6 @@ uloc_getCountry(const char* localeID,
             int32_t countryCapacity,
             UErrorCode* err)
 {
-    int32_t i=0;
-
     if(err==NULL || U_FAILURE(*err)) {
         return 0;
     }
@@ -1800,20 +1733,27 @@ uloc_getCountry(const char* localeID,
     }
 
     /* Skip the language */
-    ulocimp_getLanguage(localeID, NULL, 0, &localeID);
+    ulocimp_getLanguage(localeID, &localeID, *err);
+    if (U_FAILURE(*err)) {
+        return 0;
+    }
+
     if(_isIDSeparator(*localeID)) {
         const char *scriptID;
         /* Skip the script if available */
-        ulocimp_getScript(localeID+1, NULL, 0, &scriptID);
+        ulocimp_getScript(localeID+1, &scriptID, *err);
+        if (U_FAILURE(*err)) {
+            return 0;
+        }
         if(scriptID != localeID+1) {
             /* Found optional script */
             localeID = scriptID;
         }
         if(_isIDSeparator(*localeID)) {
-            i=ulocimp_getCountry(localeID+1, country, countryCapacity, NULL);
+            return ulocimp_getCountry(localeID+1, NULL, *err).extract(country, countryCapacity, *err);
         }
     }
-    return u_terminateChars(country, countryCapacity, i, err);
+    return u_terminateChars(country, countryCapacity, 0, err);
 }
 
 U_CAPI int32_t  U_EXPORT2
@@ -1840,11 +1780,18 @@ uloc_getVariant(const char* localeID,
     }
 
     /* Skip the language */
-    ulocimp_getLanguage(tmpLocaleID, NULL, 0, &tmpLocaleID);
+    ulocimp_getLanguage(tmpLocaleID, &tmpLocaleID, *err);
+    if (U_FAILURE(*err)) {
+        return 0;
+    }
+
     if(_isIDSeparator(*tmpLocaleID)) {
         const char *scriptID;
         /* Skip the script if available */
-        ulocimp_getScript(tmpLocaleID+1, NULL, 0, &scriptID);
+        ulocimp_getScript(tmpLocaleID+1, &scriptID, *err);
+        if (U_FAILURE(*err)) {
+            return 0;
+        }
         if(scriptID != tmpLocaleID+1) {
             /* Found optional script */
             tmpLocaleID = scriptID;
@@ -1852,7 +1799,10 @@ uloc_getVariant(const char* localeID,
         /* Skip the Country */
         if (_isIDSeparator(*tmpLocaleID)) {
             const char *cntryID;
-            ulocimp_getCountry(tmpLocaleID+1, NULL, 0, &cntryID);
+            ulocimp_getCountry(tmpLocaleID+1, &cntryID, *err);
+            if (U_FAILURE(*err)) {
+                return 0;
+            }
             if (cntryID != tmpLocaleID+1) {
                 /* Found optional country */
                 tmpLocaleID = cntryID;
@@ -1862,18 +1812,24 @@ uloc_getVariant(const char* localeID,
                 if (tmpLocaleID != cntryID && _isIDSeparator(tmpLocaleID[1])) {
                     tmpLocaleID++;
                 }
-                i=_getVariant(tmpLocaleID+1, *tmpLocaleID, variant, variantCapacity);
+
+                CheckedArrayByteSink sink(variant, variantCapacity);
+                _getVariant(tmpLocaleID+1, *tmpLocaleID, sink, FALSE);
+
+                i = sink.NumberOfBytesAppended();
+
+                if (U_FAILURE(*err)) {
+                    return i;
+                }
+
+                if (sink.Overflowed()) {
+                    *err = U_BUFFER_OVERFLOW_ERROR;
+                    return i;
+                }
             }
         }
     }
 
-    /* removed by weiv. We don't want to handle POSIX variants anymore. Use canonicalization function */
-    /* if we do not have a variant tag yet then try a POSIX variant after '@' */
-/*
-    if(!haveVariant && (localeID=uprv_strrchr(localeID, '@'))!=NULL) {
-        i=_getVariant(localeID+1, '@', variant, variantCapacity);
-    }
-*/
     return u_terminateChars(variant, variantCapacity, i, err);
 }
 
@@ -1905,7 +1861,7 @@ uloc_getName(const char* localeID,
     return reslen;
 }
 
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_getName(const char* localeID,
                 ByteSink& sink,
                 UErrorCode* err)
@@ -1941,7 +1897,7 @@ uloc_getBaseName(const char* localeID,
     return reslen;
 }
 
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_getBaseName(const char* localeID,
                     ByteSink& sink,
                     UErrorCode* err)
@@ -1977,7 +1933,7 @@ uloc_canonicalize(const char* localeID,
     return reslen;
 }
 
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_canonicalize(const char* localeID,
                      ByteSink& sink,
                      UErrorCode* err)
@@ -2058,22 +2014,22 @@ uloc_getLCID(const char* localeID)
         // uprv_convertToLCID does not support keywords other than collation.
         // Remove all keywords except collation.
         int32_t len;
-        char collVal[ULOC_KEYWORDS_CAPACITY];
         char tmpLocaleID[ULOC_FULLNAME_CAPACITY];
 
-        len = uloc_getKeywordValue(localeID, "collation", collVal,
-            UPRV_LENGTHOF(collVal) - 1, &status);
-
-        if (U_SUCCESS(status) && len > 0) {
-            collVal[len] = 0;
+        CharString collVal;
+        {
+            CharStringByteSink sink(&collVal);
+            ulocimp_getKeywordValue(localeID, "collation", sink, &status);
+        }
 
+        if (U_SUCCESS(status) && !collVal.isEmpty()) {
             len = uloc_getBaseName(localeID, tmpLocaleID,
                 UPRV_LENGTHOF(tmpLocaleID) - 1, &status);
 
             if (U_SUCCESS(status) && len > 0) {
                 tmpLocaleID[len] = 0;
 
-                len = uloc_setKeywordValue("collation", collVal, tmpLocaleID,
+                len = uloc_setKeywordValue("collation", collVal.data(), tmpLocaleID,
                     UPRV_LENGTHOF(tmpLocaleID) - len - 1, &status);
 
                 if (U_SUCCESS(status) && len > 0) {
diff --git a/deps/icu-small/source/common/uloc_keytype.cpp b/deps/icu-small/source/common/uloc_keytype.cpp
index 25f35b5ced42d54ea8edd0ef834cdbe9ac756dbd..f45aeb53d2a6ba1385476b93d4a64b4d4fbdc407 100644
--- a/deps/icu-small/source/common/uloc_keytype.cpp
+++ b/deps/icu-small/source/common/uloc_keytype.cpp
@@ -271,7 +271,7 @@ initFromResourceBundle(UErrorCode& sts) {
                         if (U_FAILURE(sts)) {
                             break;
                         }
-                        // check if this is an alias of canoncal legacy type
+                        // check if this is an alias of canonical legacy type
                         if (uprv_compareInvWithUChar(NULL, legacyTypeId, -1, to, toLen) == 0) {
                             const char* from = ures_getKey(typeAliasDataEntry.getAlias());
                             if (isTZ) {
diff --git a/deps/icu-small/source/common/uloc_tag.cpp b/deps/icu-small/source/common/uloc_tag.cpp
index 3bdeddbe066d9699d6dc6fce5783a9f308e5ca19..7cc4511175b08187418dacce0f5040dc6fdfa2ee 100644
--- a/deps/icu-small/source/common/uloc_tag.cpp
+++ b/deps/icu-small/source/common/uloc_tag.cpp
@@ -15,6 +15,7 @@
 #include "unicode/uenum.h"
 #include "unicode/uloc.h"
 #include "ustr_imp.h"
+#include "bytesinkutil.h"
 #include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
@@ -53,7 +54,7 @@ typedef struct ULanguageTag {
     VariantListEntry    *variants;
     ExtensionListEntry  *extensions;
     const char          *privateuse;
-    const char          *grandfathered;
+    const char          *legacy;
 } ULanguageTag;
 
 #define MINLEN 2
@@ -85,8 +86,9 @@ static const char LOCALE_TYPE_YES[] = "yes";
  Updated on 2018-09-12 from
  https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry .
 
- This table has 2 parts. The parts for Grandfathered tags is generated by the
- following scripts from the IANA language tag registry.
+ This table has 2 parts. The part for
+ legacy language tags (marked as “Type: grandfathered” in BCP 47)
+ is generated by the following scripts from the IANA language tag registry.
 
  curl  https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry |\
  egrep -A 7 'Type: grandfathered' | \
@@ -100,8 +102,8 @@ static const char LOCALE_TYPE_YES[] = "yes";
  values. They may have to be removed for the strict BCP 47 compliance.
 
 */
-static const char* const GRANDFATHERED[] = {
-/*  grandfathered   preferred */
+static const char* const LEGACY[] = {
+/*  legacy          preferred */
     "art-lojban",   "jbo",
     "en-gb-oed",    "en-gb-oxendict",
     "i-ami",        "ami",
@@ -124,10 +126,9 @@ static const char* const GRANDFATHERED[] = {
     "zh-min-nan",   "nan",
     "zh-xiang",     "hsn",
 
-    // Grandfathered tags with no preferred value in the IANA
+    // Legacy tags with no preferred value in the IANA
     // registry. Kept for now for the backward compatibility
     // because ICU has mapped them this way.
-    "cel-gaulish",  "xtg-x-cel-gaulish",
     "i-default",    "en-x-i-default",
     "i-enochian",   "und-x-i-enochian",
     "i-mingo",      "see-x-i-mingo",
@@ -346,7 +347,7 @@ ultag_getPrivateUse(const ULanguageTag* langtag);
 
 #if 0
 static const char*
-ultag_getGrandfathered(const ULanguageTag* langtag);
+ultag_getLegacy(const ULanguageTag* langtag);
 #endif
 
 U_NAMESPACE_BEGIN
@@ -645,6 +646,22 @@ _isTKey(const char* s, int32_t len)
     return FALSE;
 }
 
+U_CAPI const char * U_EXPORT2
+ultag_getTKeyStart(const char *localeID) {
+    const char *result = localeID;
+    const char *sep;
+    while((sep = uprv_strchr(result, SEP)) != nullptr) {
+        if (_isTKey(result, static_cast<int32_t>(sep - result))) {
+            return result;
+        }
+        result = ++sep;
+    }
+    if (_isTKey(result, -1)) {
+        return result;
+    }
+    return nullptr;
+}
+
 static UBool
 _isTValue(const char* s, int32_t len)
 {
@@ -669,9 +686,13 @@ _isTransformedExtensionSubtag(int32_t& state, const char* s, int32_t len)
     const int32_t kGotTKey = -1;    // Got tkey, wait for tvalue. ERROR if stop here.
     const int32_t kGotTValue = 6;   // Got tvalue, wait for tkey, tvalue or end
 
+
+    if (len < 0) {
+        len = (int32_t)uprv_strlen(s);
+    }
     switch (state) {
         case kStart:
-            if (ultag_isLanguageSubtag(s, len)) {
+            if (ultag_isLanguageSubtag(s, len) && len != 4) {
                 state = kGotLanguage;
                 return TRUE;
             }
@@ -986,7 +1007,7 @@ _initializeULanguageTag(ULanguageTag* langtag) {
     langtag->variants = NULL;
     langtag->extensions = NULL;
 
-    langtag->grandfathered = EMPTY;
+    langtag->legacy = EMPTY;
     langtag->privateuse = EMPTY;
 }
 
@@ -1268,35 +1289,17 @@ _appendKeywordsToLanguageTag(const char* localeID, icu::ByteSink& sink, UBool st
         UBool isBcpUExt;
 
         while (TRUE) {
-            icu::CharString buf;
             key = uenum_next(keywordEnum.getAlias(), NULL, status);
             if (key == NULL) {
                 break;
             }
-            char* buffer;
-            int32_t resultCapacity = ULOC_KEYWORD_AND_VALUES_CAPACITY;
 
-            for (;;) {
-                buffer = buf.getAppendBuffer(
-                        /*minCapacity=*/resultCapacity,
-                        /*desiredCapacityHint=*/resultCapacity,
-                        resultCapacity,
-                        tmpStatus);
-
-                if (U_FAILURE(tmpStatus)) {
-                    break;
-                }
-
-                len = uloc_getKeywordValue(
-                        localeID, key, buffer, resultCapacity, &tmpStatus);
-
-                if (tmpStatus != U_BUFFER_OVERFLOW_ERROR) {
-                    break;
-                }
-
-                resultCapacity = len;
-                tmpStatus = U_ZERO_ERROR;
+            icu::CharString buf;
+            {
+                icu::CharStringByteSink sink(&buf);
+                ulocimp_getKeywordValue(localeID, key, sink, &tmpStatus);
             }
+            len = buf.length();
 
             if (U_FAILURE(tmpStatus)) {
                 if (tmpStatus == U_MEMORY_ALLOCATION_ERROR) {
@@ -1312,11 +1315,6 @@ _appendKeywordsToLanguageTag(const char* localeID, icu::ByteSink& sink, UBool st
                 continue;
             }
 
-            buf.append(buffer, len, tmpStatus);
-            if (tmpStatus == U_STRING_NOT_TERMINATED_WARNING) {
-                tmpStatus = U_ZERO_ERROR;  // Terminators provided by CharString.
-            }
-
             keylen = (int32_t)uprv_strlen(key);
             isBcpUExt = (keylen > 1);
 
@@ -1395,32 +1393,18 @@ _appendKeywordsToLanguageTag(const char* localeID, icu::ByteSink& sink, UBool st
                     no known mapping. This implementation normalizes the
                     value to lower case
                     */
-                    icu::CharString* extBuf = extBufPool.create();
+                    icu::CharString* extBuf = extBufPool.create(buf, tmpStatus);
+
                     if (extBuf == nullptr) {
                         *status = U_MEMORY_ALLOCATION_ERROR;
                         break;
                     }
-                    int32_t bcpValueLen = static_cast<int32_t>(uprv_strlen(bcpValue));
-                    int32_t resultCapacity;
-                    char* pExtBuf = extBuf->getAppendBuffer(
-                            /*minCapacity=*/bcpValueLen,
-                            /*desiredCapacityHint=*/bcpValueLen,
-                            resultCapacity,
-                            tmpStatus);
-                    if (U_FAILURE(tmpStatus)) {
-                        *status = tmpStatus;
-                        break;
-                    }
-
-                    uprv_strcpy(pExtBuf, bcpValue);
-                    T_CString_toLowerCase(pExtBuf);
-
-                    extBuf->append(pExtBuf, bcpValueLen, tmpStatus);
                     if (U_FAILURE(tmpStatus)) {
                         *status = tmpStatus;
                         break;
                     }
 
+                    T_CString_toLowerCase(extBuf->data());
                     bcpValue = extBuf->data();
                 }
             } else {
@@ -1810,11 +1794,6 @@ _appendKeywords(ULanguageTag* langtag, icu::ByteSink& sink, UErrorCode* status)
         return;
     }
 
-    /* Determine if variants already exists */
-    if (ultag_getVariantsSize(langtag)) {
-        posixVariant = TRUE;
-    }
-
     n = ultag_getExtensionsSize(langtag);
 
     /* resolve locale keywords and reordering keys */
@@ -1822,6 +1801,11 @@ _appendKeywords(ULanguageTag* langtag, icu::ByteSink& sink, UErrorCode* status)
         key = ultag_getExtensionKey(langtag, i);
         type = ultag_getExtensionValue(langtag, i);
         if (*key == LDMLEXT) {
+            /* Determine if variants already exists */
+            if (ultag_getVariantsSize(langtag)) {
+                posixVariant = TRUE;
+            }
+
             _appendLDMLExtensionAsKeywords(type, &kwdFirst, extPool, kwdBuf, &posixVariant, status);
             if (U_FAILURE(*status)) {
                 break;
@@ -2023,11 +2007,12 @@ _appendPrivateuseToLanguageTag(const char* localeID, icu::ByteSink& sink, UBool
 #define PRIV 0x0080
 
 /**
- * Ticket #12705 - Visual Studio 2015 Update 3 contains a new code optimizer which has problems optimizing
- * this function. (See https://blogs.msdn.microsoft.com/vcblog/2016/05/04/new-code-optimizer/ )
- * As a workaround, we will turn off optimization just for this function on VS2015 Update 3 and above.
+ * Ticket #12705 - The optimizer in Visual Studio 2015 Update 3 has problems optimizing this function.
+ * As a work-around, optimization is disabled for this function on VS2015 and VS2017.
+ * This work-around should be removed once the following versions of Visual Studio are no
+ * longer supported: All versions of VS2015/VS2017, and versions of VS2019 below 16.4.
  */
-#if (defined(_MSC_VER) && (_MSC_VER >= 1900) && defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190024210))
+#if defined(_MSC_VER) && (_MSC_VER >= 1900) && (_MSC_VER < 1924)
 #pragma optimize( "", off )
 #endif
 
@@ -2042,7 +2027,7 @@ ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* sta
     char *pExtValueSubtag, *pExtValueSubtagEnd;
     int32_t i;
     UBool privateuseVar = FALSE;
-    int32_t grandfatheredLen = 0;
+    int32_t legacyLen = 0;
 
     if (parsedLen != NULL) {
         *parsedLen = 0;
@@ -2062,7 +2047,10 @@ ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* sta
         *status = U_MEMORY_ALLOCATION_ERROR;
         return NULL;
     }
-    uprv_memcpy(tagBuf, tag, tagLen);
+
+    if (tagLen > 0) {
+        uprv_memcpy(tagBuf, tag, tagLen);
+    }
     *(tagBuf + tagLen) = 0;
 
     /* create a ULanguageTag */
@@ -2082,25 +2070,25 @@ ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* sta
     }
 
     size_t parsedLenDelta = 0;
-    // Grandfathered tag will be consider together. Grandfathered tag with intervening
+    // Legacy tag will be consider together. Legacy tag with intervening
     // script and region such as art-DE-lojban or art-Latn-lojban won't be
     // matched.
-    /* check if the tag is grandfathered */
-    for (i = 0; i < UPRV_LENGTHOF(GRANDFATHERED); i += 2) {
-        int32_t checkGrandfatheredLen = static_cast<int32_t>(uprv_strlen(GRANDFATHERED[i]));
-        if (tagLen < checkGrandfatheredLen) {
+    /* check if the tag is legacy */
+    for (i = 0; i < UPRV_LENGTHOF(LEGACY); i += 2) {
+        int32_t checkLegacyLen = static_cast<int32_t>(uprv_strlen(LEGACY[i]));
+        if (tagLen < checkLegacyLen) {
             continue;
         }
-        if (tagLen > checkGrandfatheredLen && tagBuf[checkGrandfatheredLen] != '-') {
+        if (tagLen > checkLegacyLen && tagBuf[checkLegacyLen] != '-') {
             // make sure next char is '-'.
             continue;
         }
-        if (uprv_strnicmp(GRANDFATHERED[i], tagBuf, checkGrandfatheredLen) == 0) {
+        if (uprv_strnicmp(LEGACY[i], tagBuf, checkLegacyLen) == 0) {
             int32_t newTagLength;
 
-            grandfatheredLen = checkGrandfatheredLen;  /* back up for output parsedLen */
-            int32_t replacementLen = static_cast<int32_t>(uprv_strlen(GRANDFATHERED[i+1]));
-            newTagLength = replacementLen + tagLen - checkGrandfatheredLen;
+            legacyLen = checkLegacyLen;  /* back up for output parsedLen */
+            int32_t replacementLen = static_cast<int32_t>(uprv_strlen(LEGACY[i+1]));
+            newTagLength = replacementLen + tagLen - checkLegacyLen;
             if (tagLen < newTagLength) {
                 uprv_free(tagBuf);
                 tagBuf = (char*)uprv_malloc(newTagLength + 1);
@@ -2111,16 +2099,16 @@ ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* sta
                 t->buf = tagBuf;
                 tagLen = newTagLength;
             }
-            parsedLenDelta = checkGrandfatheredLen - replacementLen;
-            uprv_strcpy(t->buf, GRANDFATHERED[i + 1]);
-            if (checkGrandfatheredLen != tagLen) {
-                uprv_strcpy(t->buf + replacementLen, tag + checkGrandfatheredLen);
+            parsedLenDelta = checkLegacyLen - replacementLen;
+            uprv_strcpy(t->buf, LEGACY[i + 1]);
+            if (checkLegacyLen != tagLen) {
+                uprv_strcpy(t->buf + replacementLen, tag + checkLegacyLen);
             }
             break;
         }
     }
 
-    if (grandfatheredLen == 0) {
+    if (legacyLen == 0) {
         for (i = 0; i < UPRV_LENGTHOF(REDUNDANT); i += 2) {
             const char* redundantTag = REDUNDANT[i];
             size_t redundantTagLen = uprv_strlen(redundantTag);
@@ -2440,10 +2428,8 @@ ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* sta
     return t.orphan();
 }
 
-/**
-* Ticket #12705 - Turn optimization back on.
-*/
-#if (defined(_MSC_VER) && (_MSC_VER >= 1900) && defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190024210))
+// Ticket #12705 - Turn optimization back on.
+#if defined(_MSC_VER) && (_MSC_VER >= 1900) && (_MSC_VER < 1924)
 #pragma optimize( "", on )
 #endif
 
@@ -2608,8 +2594,8 @@ ultag_getPrivateUse(const ULanguageTag* langtag) {
 
 #if 0
 static const char*
-ultag_getGrandfathered(const ULanguageTag* langtag) {
-    return langtag->grandfathered;
+ultag_getLegacy(const ULanguageTag* langtag) {
+    return langtag->legacy;
 }
 #endif
 
@@ -2720,14 +2706,16 @@ ulocimp_toLanguageTag(const char* localeID,
 
                 key = uenum_next(kwdEnum.getAlias(), &len, &tmpStatus);
                 if (len == 1 && *key == PRIVATEUSE) {
-                    char buf[ULOC_KEYWORD_AND_VALUES_CAPACITY];
-                    buf[0] = PRIVATEUSE;
-                    buf[1] = SEP;
-                    len = uloc_getKeywordValue(localeID, key, &buf[2], sizeof(buf) - 2, &tmpStatus);
+                    icu::CharString buf;
+                    {
+                        icu::CharStringByteSink sink(&buf);
+                        ulocimp_getKeywordValue(localeID, key, sink, &tmpStatus);
+                    }
                     if (U_SUCCESS(tmpStatus)) {
-                        if (ultag_isPrivateuseValueSubtags(&buf[2], len)) {
+                        if (ultag_isPrivateuseValueSubtags(buf.data(), buf.length())) {
                             /* return private use only tag */
-                            sink.Append(buf, len + 2);
+                            sink.Append("und-x-", 6);
+                            sink.Append(buf.data(), buf.length());
                             done = TRUE;
                         } else if (strict) {
                             *status = U_ILLEGAL_ARGUMENT_ERROR;
diff --git a/deps/icu-small/source/common/ulocimp.h b/deps/icu-small/source/common/ulocimp.h
index 98b95dddfe75bc5d41d9bd21f4c16d173ae50730..3875664b2d413250cc05f3631ba797500052ad5c 100644
--- a/deps/icu-small/source/common/ulocimp.h
+++ b/deps/icu-small/source/common/ulocimp.h
@@ -13,6 +13,8 @@
 #include "unicode/bytestream.h"
 #include "unicode/uloc.h"
 
+#include "charstr.h"
+
 /**
  * Create an iterator over the specified keywords list
  * @param keywordList double-null terminated list. Will be copied.
@@ -38,7 +40,7 @@ uloc_getTableStringWithFallback(
     int32_t *pLength,
     UErrorCode *pErrorCode);
 
-/*returns TRUE if a is an ID separator FALSE otherwise*/
+/*returns true if a is an ID separator false otherwise*/
 #define _isIDSeparator(a) (a == '_' || a == '-')
 
 U_CFUNC const char*
@@ -47,42 +49,55 @@ uloc_getCurrentCountryID(const char* oldID);
 U_CFUNC const char*
 uloc_getCurrentLanguageID(const char* oldID);
 
-U_CFUNC int32_t
+U_CFUNC void
+ulocimp_getKeywords(const char *localeID,
+             char prev,
+             icu::ByteSink& sink,
+             UBool valuesToo,
+             UErrorCode *status);
+
+icu::CharString U_EXPORT2
 ulocimp_getLanguage(const char *localeID,
-                    char *language, int32_t languageCapacity,
-                    const char **pEnd);
+                    const char **pEnd,
+                    UErrorCode &status);
 
-U_CFUNC int32_t
+icu::CharString U_EXPORT2
 ulocimp_getScript(const char *localeID,
-                   char *script, int32_t scriptCapacity,
-                   const char **pEnd);
+                  const char **pEnd,
+                  UErrorCode &status);
 
-U_CFUNC int32_t
+icu::CharString U_EXPORT2
 ulocimp_getCountry(const char *localeID,
-                   char *country, int32_t countryCapacity,
-                   const char **pEnd);
+                   const char **pEnd,
+                   UErrorCode &status);
 
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_getName(const char* localeID,
                 icu::ByteSink& sink,
                 UErrorCode* err);
 
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_getBaseName(const char* localeID,
                     icu::ByteSink& sink,
                     UErrorCode* err);
 
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_canonicalize(const char* localeID,
                      icu::ByteSink& sink,
                      UErrorCode* err);
 
+U_CAPI void U_EXPORT2
+ulocimp_getKeywordValue(const char* localeID,
+                        const char* keywordName,
+                        icu::ByteSink& sink,
+                        UErrorCode* status);
+
 /**
  * Writes a well-formed language tag for this locale ID.
  *
- * **Note**: When `strict` is FALSE, any locale fields which do not satisfy the
+ * **Note**: When `strict` is false, any locale fields which do not satisfy the
  * BCP47 syntax requirement will be omitted from the result.  When `strict` is
- * TRUE, this function sets U_ILLEGAL_ARGUMENT_ERROR to the `err` if any locale
+ * true, this function sets U_ILLEGAL_ARGUMENT_ERROR to the `err` if any locale
  * fields do not satisfy the BCP47 syntax requirement.
  *
  * @param localeID  the input locale ID
@@ -96,7 +111,7 @@ ulocimp_canonicalize(const char* localeID,
  *
  * @internal ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_toLanguageTag(const char* localeID,
                       icu::ByteSink& sink,
                       UBool strict,
@@ -107,13 +122,17 @@ ulocimp_toLanguageTag(const char* localeID,
  * If the specified language tag contains any ill-formed subtags,
  * the first such subtag and all following subtags are ignored.
  * <p>
- * This implements the 'Language-Tag' production of BCP47, and so
- * supports grandfathered (regular and irregular) as well as private
- * use language tags.  Private use tags are represented as 'x-whatever',
- * and grandfathered tags are converted to their canonical replacements
- * where they exist.  Note that a few grandfathered tags have no modern
- * replacement, these will be converted using the fallback described in
+ * This implements the 'Language-Tag' production of BCP 47, and so
+ * supports legacy language tags (marked as “Type: grandfathered” in BCP 47)
+ * (regular and irregular) as well as private use language tags.
+ *
+ * Private use tags are represented as 'x-whatever',
+ * and legacy tags are converted to their canonical replacements where they exist.
+ *
+ * Note that a few legacy tags have no modern replacement;
+ * these will be converted using the fallback described in
  * the first paragraph, so some information might be lost.
+ *
  * @param langtag   the input BCP47 language tag.
  * @param tagLen    the length of langtag, or -1 to call uprv_strlen().
  * @param sink      the output sink receiving a locale ID for the
@@ -135,7 +154,7 @@ ulocimp_forLanguageTag(const char* langtag,
  * Get the region to use for supplemental data lookup. Uses
  * (1) any region specified by locale tag "rg"; if none then
  * (2) any unicode_region_tag in the locale ID; if none then
- * (3) if inferRegion is TRUE, the region suggested by
+ * (3) if inferRegion is true, the region suggested by
  * getLikelySubtags on the localeID.
  * If no region is found, returns length 0.
  *
@@ -143,7 +162,7 @@ ulocimp_forLanguageTag(const char* langtag,
  *     The complete locale ID (with keywords) from which
  *     to get the region to use for supplemental data.
  * @param inferRegion
- *     If TRUE, will try to infer region from localeID if
+ *     If true, will try to infer region from localeID if
  *     no other region is found.
  * @param region
  *     Buffer in which to put the region ID found; should
@@ -189,7 +208,7 @@ ulocimp_getRegionForSupplementalData(const char *localeID, UBool inferRegion,
  * or the localeId is not well-formed, the error code is U_ILLEGAL_ARGUMENT_ERROR.
  * @internal ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_addLikelySubtags(const char* localeID,
                          icu::ByteSink& sink,
                          UErrorCode* err);
@@ -223,7 +242,7 @@ ulocimp_addLikelySubtags(const char* localeID,
  * or the localeId is not well-formed, the error code is U_ILLEGAL_ARGUMENT_ERROR.
  * @internal ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocimp_minimizeSubtags(const char* localeID,
                         icu::ByteSink& sink,
                         UErrorCode* err);
@@ -267,6 +286,9 @@ ultag_isUnicodeLocaleType(const char* s, int32_t len);
 U_CFUNC UBool
 ultag_isVariantSubtags(const char* s, int32_t len);
 
+U_CAPI const char * U_EXPORT2
+ultag_getTKeyStart(const char *localeID);
+
 U_CFUNC const char*
 ulocimp_toBcpKey(const char* key);
 
@@ -279,4 +301,10 @@ ulocimp_toBcpType(const char* key, const char* type, UBool* isKnownKey, UBool* i
 U_CFUNC const char*
 ulocimp_toLegacyType(const char* key, const char* type, UBool* isKnownKey, UBool* isSpecialType);
 
+/* Function for testing purpose */
+U_CAPI const char* const* ulocimp_getKnownCanonicalizedLocaleForTest(int32_t* length);
+
+// Return true if the value is already canonicalized.
+U_CAPI bool ulocimp_isCanonicalizedLocaleForTest(const char* localeName);
+
 #endif
diff --git a/deps/icu-small/source/common/umutex.h b/deps/icu-small/source/common/umutex.h
index 7588bcc5d9aed62d46175a3b048df4b855337b7d..57955353d0d6ffbbd940de81de81f2c73d377614 100644
--- a/deps/icu-small/source/common/umutex.h
+++ b/deps/icu-small/source/common/umutex.h
@@ -262,13 +262,13 @@ private:
  *              the global ICU mutex.  Recursive locks are an error
  *              and may cause a deadlock on some platforms.
  */
-U_INTERNAL void U_EXPORT2 umtx_lock(UMutex* mutex);
+U_CAPI void U_EXPORT2 umtx_lock(UMutex* mutex);
 
 /* Unlock a mutex.
  * @param mutex The given mutex to be unlocked.  Pass NULL to specify
  *              the global ICU mutex.
  */
-U_INTERNAL void U_EXPORT2 umtx_unlock (UMutex* mutex);
+U_CAPI void U_EXPORT2 umtx_unlock (UMutex* mutex);
 
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/common/unicode/appendable.h b/deps/icu-small/source/common/unicode/appendable.h
index 4beacaf65836207a3c2f64675846cee9c506f810..fc99254de14e582bd5bf064d6cd0a3274e8d7e9d 100644
--- a/deps/icu-small/source/common/unicode/appendable.h
+++ b/deps/icu-small/source/common/unicode/appendable.h
@@ -45,7 +45,7 @@ class UnicodeString;
  *
  * The methods do not take UErrorCode parameters.
  * If an error occurs (e.g., out-of-memory),
- * in addition to returning FALSE from failing operations,
+ * in addition to returning false from failing operations,
  * the implementation must prevent unexpected behavior (e.g., crashes)
  * from further calls and should make the error condition available separately
  * (e.g., store a UErrorCode, make/keep a UnicodeString bogus).
@@ -62,7 +62,7 @@ public:
     /**
      * Appends a 16-bit code unit.
      * @param c code unit
-     * @return TRUE if the operation succeeded
+     * @return true if the operation succeeded
      * @stable ICU 4.8
      */
     virtual UBool appendCodeUnit(char16_t c) = 0;
@@ -71,7 +71,7 @@ public:
      * Appends a code point.
      * The default implementation calls appendCodeUnit(char16_t) once or twice.
      * @param c code point 0..0x10ffff
-     * @return TRUE if the operation succeeded
+     * @return true if the operation succeeded
      * @stable ICU 4.8
      */
     virtual UBool appendCodePoint(UChar32 c);
@@ -81,7 +81,7 @@ public:
      * The default implementation calls appendCodeUnit(char16_t) for each code unit.
      * @param s string, must not be NULL if length!=0
      * @param length string length, or -1 if NUL-terminated
-     * @return TRUE if the operation succeeded
+     * @return true if the operation succeeded
      * @stable ICU 4.8
      */
     virtual UBool appendString(const char16_t *s, int32_t length);
@@ -90,9 +90,9 @@ public:
      * Tells the object that the caller is going to append roughly
      * appendCapacity char16_ts. A subclass might use this to pre-allocate
      * a larger buffer if necessary.
-     * The default implementation does nothing. (It always returns TRUE.)
+     * The default implementation does nothing. (It always returns true.)
      * @param appendCapacity estimated number of char16_ts that will be appended
-     * @return TRUE if the operation succeeded
+     * @return true if the operation succeeded
      * @stable ICU 4.8
      */
     virtual UBool reserveAppendCapacity(int32_t appendCapacity);
@@ -171,7 +171,7 @@ public:
     /**
      * Appends a 16-bit code unit to the string.
      * @param c code unit
-     * @return TRUE if the operation succeeded
+     * @return true if the operation succeeded
      * @stable ICU 4.8
      */
     virtual UBool appendCodeUnit(char16_t c);
@@ -179,7 +179,7 @@ public:
     /**
      * Appends a code point to the string.
      * @param c code point 0..0x10ffff
-     * @return TRUE if the operation succeeded
+     * @return true if the operation succeeded
      * @stable ICU 4.8
      */
     virtual UBool appendCodePoint(UChar32 c);
@@ -188,7 +188,7 @@ public:
      * Appends a string to the UnicodeString.
      * @param s string, must not be NULL if length!=0
      * @param length string length, or -1 if NUL-terminated
-     * @return TRUE if the operation succeeded
+     * @return true if the operation succeeded
      * @stable ICU 4.8
      */
     virtual UBool appendString(const char16_t *s, int32_t length);
@@ -197,7 +197,7 @@ public:
      * Tells the UnicodeString that the caller is going to append roughly
      * appendCapacity char16_ts.
      * @param appendCapacity estimated number of char16_ts that will be appended
-     * @return TRUE if the operation succeeded
+     * @return true if the operation succeeded
      * @stable ICU 4.8
      */
     virtual UBool reserveAppendCapacity(int32_t appendCapacity);
diff --git a/deps/icu-small/source/common/unicode/brkiter.h b/deps/icu-small/source/common/unicode/brkiter.h
index b944497345479b90b2791763d036ce9a50661234..9bba5fcccc319da73040cdcf834e19322cdfe144 100644
--- a/deps/icu-small/source/common/unicode/brkiter.h
+++ b/deps/icu-small/source/common/unicode/brkiter.h
@@ -564,7 +564,7 @@ public:
      * BreakIterator::createXXXInstance to avoid undefined behavior.
      * @param key the registry key returned by a previous call to registerInstance
      * @param status the in/out status code, no special meanings are assigned
-     * @return TRUE if the iterator for the key was successfully unregistered
+     * @return true if the iterator for the key was successfully unregistered
      * @stable ICU 2.4
      */
     static UBool U_EXPORT2 unregister(URegistryKey key, UErrorCode& status);
@@ -655,7 +655,7 @@ private:
 
 inline UBool BreakIterator::isBufferClone()
 {
-    return FALSE;
+    return false;
 }
 
 #endif /* U_HIDE_DEPRECATED_API */
diff --git a/deps/icu-small/source/common/unicode/bytestream.h b/deps/icu-small/source/common/unicode/bytestream.h
index 33505a34299818bdde87a461dd2e201b5e4ca4af..5f116910f46ed61a4dc6220b2430131bcc8deb75 100644
--- a/deps/icu-small/source/common/unicode/bytestream.h
+++ b/deps/icu-small/source/common/unicode/bytestream.h
@@ -71,7 +71,6 @@ public:
    */
   virtual void Append(const char* bytes, int32_t n) = 0;
 
-#ifndef U_HIDE_DRAFT_API
   /**
    * Appends n bytes to this. Same as Append().
    * Call AppendU8() with u8"string literals" which are const char * in C++11
@@ -81,7 +80,7 @@ public:
    *
    * @param bytes the pointer to the bytes
    * @param n the number of bytes; must be non-negative
-   * @draft ICU 67
+   * @stable ICU 67
    */
   inline void AppendU8(const char* bytes, int32_t n) {
     Append(bytes, n);
@@ -97,13 +96,12 @@ public:
    *
    * @param bytes the pointer to the bytes
    * @param n the number of bytes; must be non-negative
-   * @draft ICU 67
+   * @stable ICU 67
    */
   inline void AppendU8(const char8_t* bytes, int32_t n) {
     Append(reinterpret_cast<const char*>(bytes), n);
   }
 #endif
-#endif  // U_HIDE_DRAFT_API
 
   /**
    * Returns a writable buffer for appending and writes the buffer's capacity to
@@ -197,7 +195,7 @@ public:
    * Returns the sink to its original state, without modifying the buffer.
    * Useful for reusing both the buffer and the sink for multiple streams.
    * Resets the state to NumberOfBytesWritten()=NumberOfBytesAppended()=0
-   * and Overflowed()=FALSE.
+   * and Overflowed()=false.
    * @return *this
    * @stable ICU 4.6
    */
@@ -236,7 +234,7 @@ public:
   /**
    * Returns true if any bytes were discarded, i.e., if there was an
    * attempt to write more than 'capacity' bytes.
-   * @return TRUE if more than 'capacity' bytes were Append()ed
+   * @return true if more than 'capacity' bytes were Append()ed
    * @stable ICU 4.2
    */
   UBool Overflowed() const { return overflowed_; }
diff --git a/deps/icu-small/source/common/unicode/bytestrie.h b/deps/icu-small/source/common/unicode/bytestrie.h
index 51405f64a10e64f8bf9d82a88723e6d6d671e7ff..271a81d1b4d7d492ae5d3aa595020fab525e79b2 100644
--- a/deps/icu-small/source/common/unicode/bytestrie.h
+++ b/deps/icu-small/source/common/unicode/bytestrie.h
@@ -30,6 +30,8 @@
 #include "unicode/uobject.h"
 #include "unicode/ustringtrie.h"
 
+class BytesTrieTest;
+
 U_NAMESPACE_BEGIN
 
 class ByteSink;
@@ -97,14 +99,13 @@ public:
         return *this;
     }
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns the state of this trie as a 64-bit integer.
      * The state value is never 0.
      *
      * @return opaque state value
      * @see resetToState64
-     * @draft ICU 65
+     * @stable ICU 65
      */
     uint64_t getState64() const {
         return (static_cast<uint64_t>(remainingMatchLength_ + 2) << kState64RemainingShift) |
@@ -123,14 +124,13 @@ public:
      * @see getState64
      * @see resetToState
      * @see reset
-     * @draft ICU 65
+     * @stable ICU 65
      */
     BytesTrie &resetToState64(uint64_t state) {
         remainingMatchLength_ = static_cast<int32_t>(state >> kState64RemainingShift) - 2;
         pos_ = bytes_ + (state & kState64PosMask);
         return *this;
     }
-#endif  /* U_HIDE_DRAFT_API */
 
     /**
      * BytesTrie state object, for saving a trie's current state
@@ -253,16 +253,16 @@ public:
     /**
      * Determines whether all byte sequences reachable from the current state
      * map to the same value.
-     * @param uniqueValue Receives the unique value, if this function returns TRUE.
+     * @param uniqueValue Receives the unique value, if this function returns true.
      *                    (output-only)
-     * @return TRUE if all byte sequences reachable from the current state
+     * @return true if all byte sequences reachable from the current state
      *         map to the same value.
      * @stable ICU 4.8
      */
     inline UBool hasUniqueValue(int32_t &uniqueValue) const {
         const uint8_t *pos=pos_;
         // Skip the rest of a pending linear-match node.
-        return pos!=NULL && findUniqueValue(pos+remainingMatchLength_+1, FALSE, uniqueValue);
+        return pos!=NULL && findUniqueValue(pos+remainingMatchLength_+1, false, uniqueValue);
     }
 
     /**
@@ -321,7 +321,7 @@ public:
         Iterator &reset();
 
         /**
-         * @return TRUE if there are more elements.
+         * @return true if there are more elements.
          * @stable ICU 4.8
          */
         UBool hasNext() const;
@@ -337,7 +337,7 @@ public:
          *                  pass the U_SUCCESS() test, or else the function returns
          *                  immediately. Check for U_FAILURE() on output or use with
          *                  function chaining. (See User Guide for details.)
-         * @return TRUE if there is another element.
+         * @return true if there is another element.
          * @stable ICU 4.8
          */
         UBool next(UErrorCode &errorCode);
@@ -380,6 +380,7 @@ public:
 
 private:
     friend class BytesTrieBuilder;
+    friend class ::BytesTrieTest;
 
     /**
      * Constructs a BytesTrie reader instance.
diff --git a/deps/icu-small/source/common/unicode/bytestriebuilder.h b/deps/icu-small/source/common/unicode/bytestriebuilder.h
index e58f18755ef9593d121c3409bfdf857e9a1c9f53..1861fb8b3f9a89d39b204cbe85b83a01d7abbbf5 100644
--- a/deps/icu-small/source/common/unicode/bytestriebuilder.h
+++ b/deps/icu-small/source/common/unicode/bytestriebuilder.h
@@ -30,6 +30,8 @@
 #include "unicode/stringpiece.h"
 #include "unicode/stringtriebuilder.h"
 
+class BytesTrieTest;
+
 U_NAMESPACE_BEGIN
 
 class BytesTrieElement;
@@ -101,9 +103,10 @@ public:
      * Multiple calls to buildStringPiece() return StringPieces referring to the
      * builder's same byte array, without rebuilding.
      * If buildStringPiece() is called after build(), the trie will be
-     * re-serialized into a new array.
-     * If build() is called after buildStringPiece(), the trie object will become
-     * the owner of the previously returned array.
+     * re-serialized into a new array (because build() passes on ownership).
+     * If build() is called after buildStringPiece(), the trie object returned
+     * by build() will become the owner of the underlying string for the
+     * previously returned StringPiece.
      * After clear() has been called, a new array will be used as well.
      * @param buildOption Build option, see UStringTrieBuildOption.
      * @param errorCode Standard ICU error code. Its input value must
@@ -124,6 +127,8 @@ public:
     BytesTrieBuilder &clear();
 
 private:
+    friend class ::BytesTrieTest;
+
     BytesTrieBuilder(const BytesTrieBuilder &other);  // no copy constructor
     BytesTrieBuilder &operator=(const BytesTrieBuilder &other);  // no assignment operator
 
@@ -139,7 +144,7 @@ private:
     virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t byteIndex, int32_t count) const;
     virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t byteIndex, char16_t byte) const;
 
-    virtual UBool matchNodesCanHaveValues() const { return FALSE; }
+    virtual UBool matchNodesCanHaveValues() const { return false; }
 
     virtual int32_t getMaxBranchLinearSubNodeLength() const { return BytesTrie::kMaxBranchLinearSubNodeLength; }
     virtual int32_t getMinLinearMatch() const { return BytesTrie::kMinLinearMatch; }
@@ -167,6 +172,7 @@ private:
     virtual int32_t writeValueAndFinal(int32_t i, UBool isFinal);
     virtual int32_t writeValueAndType(UBool hasValue, int32_t value, int32_t node);
     virtual int32_t writeDeltaTo(int32_t jumpTarget);
+    static int32_t internalEncodeDelta(int32_t i, char intBytes[]);
 
     CharString *strings;  // Pointer not object so we need not #include internal charstr.h.
     BytesTrieElement *elements;
diff --git a/deps/icu-small/source/common/unicode/caniter.h b/deps/icu-small/source/common/unicode/caniter.h
index 87c946c2b4db56e12b36ac470aec87c5a1529e58..8ba4cc7daad3c1c19005bb8efa1c4fe5d57b031e 100644
--- a/deps/icu-small/source/common/unicode/caniter.h
+++ b/deps/icu-small/source/common/unicode/caniter.h
@@ -25,11 +25,11 @@
  */
 
 /** Should permutation skip characters with combining class zero
- *  Should be either TRUE or FALSE. This is a compile time option
+ *  Should be either true or false. This is a compile time option
  *  @stable ICU 2.4
  */
 #ifndef CANITER_SKIP_ZEROES
-#define CANITER_SKIP_ZEROES TRUE
+#define CANITER_SKIP_ZEROES true
 #endif
 
 U_NAMESPACE_BEGIN
diff --git a/deps/icu-small/source/common/unicode/chariter.h b/deps/icu-small/source/common/unicode/chariter.h
index 7e4f446bb0f8a8c005f6462236e670215ecfa7fc..f7ecd8e0036ce20c9f1692b43d41faea581557ce 100644
--- a/deps/icu-small/source/common/unicode/chariter.h
+++ b/deps/icu-small/source/common/unicode/chariter.h
@@ -65,7 +65,7 @@ U_NAMESPACE_BEGIN
  * check for the end of the iteration. When there are no more
  * characters in the text object:
  * <ul>
- * <li>The hasNext() function returns FALSE.</li>
+ * <li>The hasNext() function returns false.</li>
  * <li>nextPostInc() and next32PostInc() return DONE
  *     when one attempts to read beyond the end of the text object.</li>
  * </ul>
@@ -165,11 +165,11 @@ public:
     virtual UChar32       next32PostInc(void) = 0;
 
     /**
-     * Returns FALSE if there are no more code units or code points
+     * Returns false if there are no more code units or code points
      * at or after the current position in the iteration range.
      * This is used with nextPostInc() or next32PostInc() in forward
      * iteration.
-     * @returns FALSE if there are no more code units or code points
+     * @returns false if there are no more code units or code points
      * at or after the current position in the iteration range.
      * @stable ICU 2.0
      */
@@ -535,12 +535,12 @@ public:
     virtual UChar32       previous32(void) = 0;
 
     /**
-     * Returns FALSE if there are no more code units or code points
+     * Returns false if there are no more code units or code points
      * before the current position in the iteration range.
      * This is used with previous() or previous32() in backward
      * iteration.
-     * @return FALSE if there are no more code units or code points
-     * before the current position in the iteration range, return TRUE otherwise.
+     * @return false if there are no more code units or code points
+     * before the current position in the iteration range, return true otherwise.
      * @stable ICU 2.0
      */
     virtual UBool        hasPrevious() = 0;
diff --git a/deps/icu-small/source/common/unicode/docmain.h b/deps/icu-small/source/common/unicode/docmain.h
index 2b38692997dd9a24ade47e33ae696cbd53671719..1b88eca92b9e9cc6bff298ebb1a70dd401929294 100644
--- a/deps/icu-small/source/common/unicode/docmain.h
+++ b/deps/icu-small/source/common/unicode/docmain.h
@@ -15,7 +15,7 @@
  * \file
  * \brief (Non API- contains Doxygen definitions)
  *
- * This file contains documentation for Doxygen and doesnot have
+ * This file contains documentation for Doxygen and does not have
  * any significance with respect to C or C++ API
  */
 
@@ -53,10 +53,10 @@
  *
  * <h2>Architecture (User's Guide)</h2>
  * <ul>
- *   <li><a href="http://userguide.icu-project.org/">Introduction</a></li>
- *   <li><a href="http://userguide.icu-project.org/i18n">Internationalization</a></li>
- *   <li><a href="http://userguide.icu-project.org/design">Locale Model, Multithreading, Error Handling, etc.</a></li>
- *   <li><a href="http://userguide.icu-project.org/conversion">Conversion</a></li>
+ *   <li><a href="https://unicode-org.github.io/icu/userguide/">Introduction</a></li>
+ *   <li><a href="https://unicode-org.github.io/icu/userguide/i18n">Internationalization</a></li>
+ *   <li><a href="https://unicode-org.github.io/icu/userguide/design">Locale Model, Multithreading, Error Handling, etc.</a></li>
+ *   <li><a href="https://unicode-org.github.io/icu/userguide/conversion">Conversion</a></li>
  * </ul>
  *
  * <hr>
@@ -74,7 +74,7 @@
  *   </tr>
  *   <tr>
  *     <td>Strings and Character Iteration</td>
- *     <td>ustring.h, utf8.h, utf16.h, UText, UCharIterator</td>
+ *     <td>ustring.h, utf8.h, utf16.h, icu::StringPiece, UText, UCharIterator, icu::ByteSink</td>
  *     <td>icu::UnicodeString, icu::CharacterIterator, icu::Appendable, icu::StringPiece,icu::ByteSink</td>
  *   </tr>
  *   <tr>
@@ -128,9 +128,9 @@
  *     <td>icu::Normalizer2</td>
  *   </tr>
  *   <tr>
- *     <td>Calendars</td>
+ *     <td>Calendars and Time Zones</td>
  *     <td>ucal.h</td>
- *     <td>icu::Calendar</td>
+ *     <td>icu::Calendar, icu::TimeZone</td>
  *   </tr>
  *   <tr>
  *     <td>Date and Time Formatting</td>
@@ -143,13 +143,18 @@
  *     <td>icu::MessageFormat</td>
  *   </tr>
  *   <tr>
+ *     <td>List Formatting</td>
+ *     <td>ulistformatter.h</td>
+ *     <td>icu::ListFormatter</td>
+ *   </tr>
+ *   <tr>
  *     <td>Number Formatting<br/>(includes currency and unit formatting)</td>
  *     <td>unumberformatter.h, unum.h</td>
  *     <td>icu::number::NumberFormatter (ICU 60+) or icu::NumberFormat (older versions)</td>
  *   </tr>
  *   <tr>
  *     <td>Number Range Formatting<br />(includes currency and unit ranges)</td>
- *     <td>(no C API)</td>
+ *     <td>unumberrangeformatter.h</td>
  *     <td>icu::number::NumberRangeFormatter</td>
  *   </tr>
  *   <tr>
diff --git a/deps/icu-small/source/common/unicode/dtintrv.h b/deps/icu-small/source/common/unicode/dtintrv.h
index 325faa3ccb92cbf7f03cdd066915173932070912..7932ea660fa4dde7c2372e7ad02137298a89300b 100644
--- a/deps/icu-small/source/common/unicode/dtintrv.h
+++ b/deps/icu-small/source/common/unicode/dtintrv.h
@@ -106,14 +106,14 @@ public:
 
     /**
      * Equality operator.
-     * @return TRUE if the two DateIntervals are the same
+     * @return true if the two DateIntervals are the same
      * @stable ICU 4.0
      */
     virtual UBool operator==(const DateInterval& other) const;
 
     /**
      * Non-equality operator
-     * @return TRUE if the two DateIntervals are not the same
+     * @return true if the two DateIntervals are not the same
      * @stable ICU 4.0
      */
     inline UBool operator!=(const DateInterval& other) const;
diff --git a/deps/icu-small/source/common/unicode/edits.h b/deps/icu-small/source/common/unicode/edits.h
index c3ceaccb3b3802972b82c50e2541fc891f24f9a3..bfa07fa6765b730d6143f3d9e0e41ea1d853cb01 100644
--- a/deps/icu-small/source/common/unicode/edits.h
+++ b/deps/icu-small/source/common/unicode/edits.h
@@ -159,7 +159,7 @@ public:
      * @param outErrorCode Set to an error code if it does not contain one already
      *                  and an error occurred while recording edits.
      *                  Otherwise unchanged.
-     * @return TRUE if U_FAILURE(outErrorCode)
+     * @return true if U_FAILURE(outErrorCode)
      * @stable ICU 59
      */
     UBool copyErrorTo(UErrorCode &outErrorCode) const;
@@ -171,7 +171,7 @@ public:
      */
     int32_t lengthDelta() const { return delta; }
     /**
-     * @return TRUE if there are any change edits
+     * @return true if there are any change edits
      * @stable ICU 59
      */
     UBool hasChanges() const { return numChanges != 0; }
@@ -207,8 +207,8 @@ public:
          */
         Iterator() :
                 array(nullptr), index(0), length(0),
-                remaining(0), onlyChanges_(FALSE), coarse(FALSE),
-                dir(0), changed(FALSE), oldLength_(0), newLength_(0),
+                remaining(0), onlyChanges_(false), coarse(false),
+                dir(0), changed(false), oldLength_(0), newLength_(0),
                 srcIndex(0), replIndex(0), destIndex(0) {}
         /**
          * Copy constructor.
@@ -226,7 +226,7 @@ public:
          * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
          *                  or else the function returns immediately. Check for U_FAILURE()
          *                  on output or use with function chaining. (See User Guide for details.)
-         * @return TRUE if there is another edit
+         * @return true if there is another edit
          * @stable ICU 59
          */
         UBool next(UErrorCode &errorCode) { return next(onlyChanges_, errorCode); }
@@ -247,11 +247,11 @@ public:
          * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
          *                  or else the function returns immediately. Check for U_FAILURE()
          *                  on output or use with function chaining. (See User Guide for details.)
-         * @return TRUE if the edit for the source index was found
+         * @return true if the edit for the source index was found
          * @stable ICU 59
          */
         UBool findSourceIndex(int32_t i, UErrorCode &errorCode) {
-            return findIndex(i, TRUE, errorCode) == 0;
+            return findIndex(i, true, errorCode) == 0;
         }
 
         /**
@@ -270,11 +270,11 @@ public:
          * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
          *                  or else the function returns immediately. Check for U_FAILURE()
          *                  on output or use with function chaining. (See User Guide for details.)
-         * @return TRUE if the edit for the destination index was found
+         * @return true if the edit for the destination index was found
          * @stable ICU 60
          */
         UBool findDestinationIndex(int32_t i, UErrorCode &errorCode) {
-            return findIndex(i, FALSE, errorCode) == 0;
+            return findIndex(i, false, errorCode) == 0;
         }
 
         /**
@@ -328,8 +328,8 @@ public:
         /**
          * Returns whether the edit currently represented by the iterator is a change edit.
          *
-         * @return TRUE if this edit replaces oldLength() units with newLength() different ones.
-         *         FALSE if oldLength units remain unchanged.
+         * @return true if this edit replaces oldLength() units with newLength() different ones.
+         *         false if oldLength units remain unchanged.
          * @stable ICU 59
          */
         UBool hasChange() const { return changed; }
@@ -347,8 +347,8 @@ public:
          * {@link #destinationIndex}, or in the replacement string, which starts at
          * {@link #replacementIndex}.
          *
-         * @return the number of units in the modified string, if hasChange() is TRUE.
-         *         Same as oldLength if hasChange() is FALSE.
+         * @return the number of units in the modified string, if hasChange() is true.
+         *         Same as oldLength if hasChange() is false.
          * @stable ICU 59
          */
         int32_t newLength() const { return newLength_; }
@@ -436,7 +436,7 @@ public:
      * @stable ICU 59
      */
     Iterator getCoarseChangesIterator() const {
-        return Iterator(array, length, TRUE, TRUE);
+        return Iterator(array, length, true, true);
     }
 
     /**
@@ -448,7 +448,7 @@ public:
      * @stable ICU 59
      */
     Iterator getCoarseIterator() const {
-        return Iterator(array, length, FALSE, TRUE);
+        return Iterator(array, length, false, true);
     }
 
     /**
@@ -460,7 +460,7 @@ public:
      * @stable ICU 59
      */
     Iterator getFineChangesIterator() const {
-        return Iterator(array, length, TRUE, FALSE);
+        return Iterator(array, length, true, false);
     }
 
     /**
@@ -471,7 +471,7 @@ public:
      * @stable ICU 59
      */
     Iterator getFineIterator() const {
-        return Iterator(array, length, FALSE, FALSE);
+        return Iterator(array, length, false, false);
     }
 
     /**
diff --git a/deps/icu-small/source/common/unicode/filteredbrk.h b/deps/icu-small/source/common/unicode/filteredbrk.h
index 42936763259e2d7bd0797c6239cc543e38cb3279..8b07e39ae12bb61bdf56d3e5d682d84a959c92ff 100644
--- a/deps/icu-small/source/common/unicode/filteredbrk.h
+++ b/deps/icu-small/source/common/unicode/filteredbrk.h
@@ -85,8 +85,8 @@ class U_COMMON_API FilteredBreakIteratorBuilder : public UObject {
    * by the iterator.
    * @param string the string to suppress, such as "Mr."
    * @param status error code
-   * @return returns TRUE if the string was not present and now added,
-   * FALSE if the call was a no-op because the string was already being suppressed.
+   * @return returns true if the string was not present and now added,
+   * false if the call was a no-op because the string was already being suppressed.
    * @stable ICU 56
    */
   virtual UBool suppressBreakAfter(const UnicodeString& string, UErrorCode& status) = 0;
@@ -98,8 +98,8 @@ class U_COMMON_API FilteredBreakIteratorBuilder : public UObject {
    * locale data which may be suppressing certain strings.
    * @param string the exception to remove
    * @param status error code
-   * @return returns TRUE if the string was present and now removed,
-   * FALSE if the call was a no-op because the string was not being suppressed.
+   * @return returns true if the string was present and now removed,
+   * false if the call was a no-op because the string was not being suppressed.
    * @stable ICU 56
    */
   virtual UBool unsuppressBreakAfter(const UnicodeString& string, UErrorCode& status) = 0;
diff --git a/deps/icu-small/source/common/unicode/icudataver.h b/deps/icu-small/source/common/unicode/icudataver.h
index d5c728da880f8f20f504efc661ce90413db3c690..a82cb3d89d9d9966404545ba69cf1e07d280a9aa 100644
--- a/deps/icu-small/source/common/unicode/icudataver.h
+++ b/deps/icu-small/source/common/unicode/icudataver.h
@@ -38,6 +38,6 @@
  *
  * @stable ICU 49
  */
-U_STABLE void U_EXPORT2 u_getDataVersion(UVersionInfo dataVersionFillin, UErrorCode *status);
+U_CAPI void U_EXPORT2 u_getDataVersion(UVersionInfo dataVersionFillin, UErrorCode *status);
 
 #endif
diff --git a/deps/icu-small/source/common/unicode/icuplug.h b/deps/icu-small/source/common/unicode/icuplug.h
index 827cbe94b61cf8dc7d442444a2d1c178574e0e4f..f817679acf016cdd6e27bd7b8ad192191662426b 100644
--- a/deps/icu-small/source/common/unicode/icuplug.h
+++ b/deps/icu-small/source/common/unicode/icuplug.h
@@ -117,14 +117,13 @@
 /* === Basic types === */
 
 #ifndef U_HIDE_INTERNAL_API
+struct UPlugData;
 /**
  * @{
- * Opaque structure passed to/from a plugin.
- * use the APIs to access it.
+ * Typedef for opaque structure passed to/from a plugin.
+ * Use the APIs to access it.
  * @internal ICU 4.4 Technology Preview
  */
-
-struct UPlugData;
 typedef struct UPlugData UPlugData;
 
 /** @} */
@@ -208,7 +207,7 @@ typedef UPlugTokenReturn (U_EXPORT2 UPlugEntrypoint) (
  * @param dontUnload  set true if this plugin can't be unloaded
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uplug_setPlugNoUnload(UPlugData *plug, UBool dontUnload);
 
 /**
@@ -217,7 +216,7 @@ uplug_setPlugNoUnload(UPlugData *plug, UBool dontUnload);
  * @param level the level of this plugin
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uplug_setPlugLevel(UPlugData *plug, UPlugLevel level);
 
 /**
@@ -226,7 +225,7 @@ uplug_setPlugLevel(UPlugData *plug, UPlugLevel level);
  * @return the level of this plugin
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL UPlugLevel U_EXPORT2
+U_CAPI UPlugLevel U_EXPORT2
 uplug_getPlugLevel(UPlugData *plug);
 
 /**
@@ -236,7 +235,7 @@ uplug_getPlugLevel(UPlugData *plug);
  * @return the lowest level of plug which can currently load
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL UPlugLevel U_EXPORT2
+U_CAPI UPlugLevel U_EXPORT2
 uplug_getCurrentLevel(void);
 
 
@@ -245,7 +244,7 @@ uplug_getCurrentLevel(void);
  * @return The error code of this plugin's load attempt.
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL UErrorCode U_EXPORT2
+U_CAPI UErrorCode U_EXPORT2
 uplug_getPlugLoadStatus(UPlugData *plug);
 
 /**
@@ -254,7 +253,7 @@ uplug_getPlugLoadStatus(UPlugData *plug);
  * @param name the name of this plugin. The first UPLUG_NAME_MAX characters willi be copied into a new buffer.
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uplug_setPlugName(UPlugData *plug, const char *name);
 
 /**
@@ -263,7 +262,7 @@ uplug_setPlugName(UPlugData *plug, const char *name);
  * @return the name of this plugin
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 uplug_getPlugName(UPlugData *plug);
 
 /**
@@ -272,7 +271,7 @@ uplug_getPlugName(UPlugData *plug);
  * @return the symbol name, or NULL
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 uplug_getSymbolName(UPlugData *plug);
 
 /**
@@ -282,7 +281,7 @@ uplug_getSymbolName(UPlugData *plug);
  * @return the library name, or NULL
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 uplug_getLibraryName(UPlugData *plug, UErrorCode *status);
 
 /**
@@ -292,7 +291,7 @@ uplug_getLibraryName(UPlugData *plug, UErrorCode *status);
  * @return the library, or NULL
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL void * U_EXPORT2
+U_CAPI void * U_EXPORT2
 uplug_getLibrary(UPlugData *plug);
 
 /**
@@ -301,7 +300,7 @@ uplug_getLibrary(UPlugData *plug);
  * @return the context, or NULL if not set
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL void * U_EXPORT2
+U_CAPI void * U_EXPORT2
 uplug_getContext(UPlugData *plug);
 
 /**
@@ -310,7 +309,7 @@ uplug_getContext(UPlugData *plug);
  * @param context new context to set
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uplug_setContext(UPlugData *plug, void *context);
 
 
@@ -321,7 +320,7 @@ uplug_setContext(UPlugData *plug, void *context);
  * @return configuration string, or else null.
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 uplug_getConfiguration(UPlugData *plug);
 
 /**
@@ -339,7 +338,7 @@ uplug_getConfiguration(UPlugData *plug);
  * @return the next oldest plugin, or NULL if no more.
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL UPlugData* U_EXPORT2
+U_CAPI UPlugData* U_EXPORT2
 uplug_nextPlug(UPlugData *prior);
 
 /**
@@ -354,7 +353,7 @@ uplug_nextPlug(UPlugData *prior);
  * @return the new UPlugData associated with this plugin, or NULL if error.
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL UPlugData* U_EXPORT2
+U_CAPI UPlugData* U_EXPORT2
 uplug_loadPlugFromEntrypoint(UPlugEntrypoint *entrypoint, const char *config, UErrorCode *status);
 
 
@@ -368,7 +367,7 @@ uplug_loadPlugFromEntrypoint(UPlugEntrypoint *entrypoint, const char *config, UE
  * @return the new UPlugData associated with this plugin, or NULL if error.
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL UPlugData* U_EXPORT2
+U_CAPI UPlugData* U_EXPORT2
 uplug_loadPlugFromLibrary(const char *libName, const char *sym, const char *config, UErrorCode *status);
 
 /**
@@ -378,7 +377,7 @@ uplug_loadPlugFromLibrary(const char *libName, const char *sym, const char *conf
  * @param status error result
  * @internal ICU 4.4 Technology Preview
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 uplug_removePlug(UPlugData *plug, UErrorCode *status);
 #endif  /* U_HIDE_INTERNAL_API */
 
diff --git a/deps/icu-small/source/common/unicode/idna.h b/deps/icu-small/source/common/unicode/idna.h
index 6dfcfe48db28f1ea9ad21b64ca766091025e66cc..1305dc604842eb5c131d0e0818d6da3244df9835 100644
--- a/deps/icu-small/source/common/unicode/idna.h
+++ b/deps/icu-small/source/common/unicode/idna.h
@@ -95,7 +95,7 @@ public:
 
     /**
      * Converts a single domain name label into its ASCII form for DNS lookup.
-     * If any processing step fails, then info.hasErrors() will be TRUE and
+     * If any processing step fails, then info.hasErrors() will be true and
      * the result might not be an ASCII string.
      * The label might be modified according to the types of errors.
      * Labels with severe errors will be left in (or turned into) their Unicode form.
@@ -119,7 +119,7 @@ public:
 
     /**
      * Converts a single domain name label into its Unicode form for human-readable display.
-     * If any processing step fails, then info.hasErrors() will be TRUE.
+     * If any processing step fails, then info.hasErrors() will be true.
      * The label might be modified according to the types of errors.
      *
      * The UErrorCode indicates an error only in exceptional cases,
@@ -141,7 +141,7 @@ public:
 
     /**
      * Converts a whole domain name into its ASCII form for DNS lookup.
-     * If any processing step fails, then info.hasErrors() will be TRUE and
+     * If any processing step fails, then info.hasErrors() will be true and
      * the result might not be an ASCII string.
      * The domain name might be modified according to the types of errors.
      * Labels with severe errors will be left in (or turned into) their Unicode form.
@@ -165,7 +165,7 @@ public:
 
     /**
      * Converts a whole domain name into its Unicode form for human-readable display.
-     * If any processing step fails, then info.hasErrors() will be TRUE.
+     * If any processing step fails, then info.hasErrors() will be true.
      * The domain name might be modified according to the types of errors.
      *
      * The UErrorCode indicates an error only in exceptional cases,
@@ -273,10 +273,10 @@ public:
      * Constructor for stack allocation.
      * @stable ICU 4.6
      */
-    IDNAInfo() : errors(0), labelErrors(0), isTransDiff(FALSE), isBiDi(FALSE), isOkBiDi(TRUE) {}
+    IDNAInfo() : errors(0), labelErrors(0), isTransDiff(false), isBiDi(false), isOkBiDi(true) {}
     /**
      * Were there IDNA processing errors?
-     * @return TRUE if there were processing errors
+     * @return true if there were processing errors
      * @stable ICU 4.6
      */
     UBool hasErrors() const { return errors!=0; }
@@ -288,7 +288,7 @@ public:
      */
     uint32_t getErrors() const { return errors; }
     /**
-     * Returns TRUE if transitional and nontransitional processing produce different results.
+     * Returns true if transitional and nontransitional processing produce different results.
      * This is the case when the input label or domain name contains
      * one or more deviation characters outside a Punycode label (see UTS #46).
      * <ul>
@@ -297,7 +297,7 @@ public:
      * <li>With transitional processing, such characters are
      * mapped (sharp s/sigma) or removed (joiner/nonjoiner).
      * </ul>
-     * @return TRUE if transitional and nontransitional processing produce different results
+     * @return true if transitional and nontransitional processing produce different results
      * @stable ICU 4.6
      */
     UBool isTransitionalDifferent() const { return isTransDiff; }
@@ -310,9 +310,9 @@ private:
 
     void reset() {
         errors=labelErrors=0;
-        isTransDiff=FALSE;
-        isBiDi=FALSE;
-        isOkBiDi=TRUE;
+        isTransDiff=false;
+        isBiDi=false;
+        isOkBiDi=true;
     }
 
     uint32_t errors, labelErrors;
diff --git a/deps/icu-small/source/common/unicode/localebuilder.h b/deps/icu-small/source/common/unicode/localebuilder.h
index c5836fe27021b3d27d2fe32e0bb5eb5cc9a5ff86..27a894de101def57621cf2976ef5b77f7ade0068 100644
--- a/deps/icu-small/source/common/unicode/localebuilder.h
+++ b/deps/icu-small/source/common/unicode/localebuilder.h
@@ -1,5 +1,5 @@
 // © 2018 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 #ifndef __LOCALEBUILDER_H__
 #define __LOCALEBUILDER_H__
 
@@ -92,11 +92,12 @@ public:
     /**
      * Resets the LocaleBuilder to match the provided
      * [Unicode Locale Identifier](http://www.unicode.org/reports/tr35/tr35.html#unicode_locale_id) .
-     * Discards the existing state. the empty string cause the builder to be
-     * reset, like {@link #clear}.  Grandfathered tags are converted to their
-     * canonical form before being processed.  Otherwise, the <code>language
-     * tag</code> must be well-formed, or else the build() method will later
-     * report an U_ILLEGAL_ARGUMENT_ERROR.
+     * Discards the existing state.
+     * The empty string causes the builder to be reset, like {@link #clear}.
+     * Legacy language tags (marked as “Type: grandfathered” in BCP 47)
+     * are converted to their canonical form before being processed.
+     * Otherwise, the <code>language tag</code> must be well-formed,
+     * or else the build() method will later report an U_ILLEGAL_ARGUMENT_ERROR.
      *
      * <p>This method clears the internal UErrorCode.
      *
@@ -278,18 +279,16 @@ public:
      */
     Locale build(UErrorCode& status);
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Sets the UErrorCode if an error occurred while recording sets.
      * Preserves older error codes in the outErrorCode.
      * @param outErrorCode Set to an error code that occurred while setting subtags.
      *                  Unchanged if there is no such error or if outErrorCode
      *                  already contained an error.
-     * @return TRUE if U_FAILURE(outErrorCode)
-     * @draft ICU 65
+     * @return true if U_FAILURE(outErrorCode)
+     * @stable ICU 65
      */
     UBool copyErrorTo(UErrorCode &outErrorCode) const;
-#endif  /* U_HIDE_DRAFT_API */
 
 private:
     friend class LocaleMatcher::Result;
diff --git a/deps/icu-small/source/common/unicode/localematcher.h b/deps/icu-small/source/common/unicode/localematcher.h
index 2e1a7a349f3983619a029b75678572bb76f7533d..0cd068ef32805b630165b220a02c3fc9d8bc0d32 100644
--- a/deps/icu-small/source/common/unicode/localematcher.h
+++ b/deps/icu-small/source/common/unicode/localematcher.h
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 // localematcher.h
 // created: 2019may08 Markus W. Scherer
@@ -20,26 +20,24 @@
  * \brief C++ API: Locale matcher: User's desired locales vs. application's supported locales.
  */
 
-#ifndef U_FORCE_HIDE_DRAFT_API
-
 /**
  * Builder option for whether the language subtag or the script subtag is most important.
  *
- * @see Builder#setFavorSubtag(ULocMatchFavorSubtag)
- * @draft ICU 65
+ * @see LocaleMatcher::Builder#setFavorSubtag(ULocMatchFavorSubtag)
+ * @stable ICU 65
  */
 enum ULocMatchFavorSubtag {
     /**
      * Language differences are most important, then script differences, then region differences.
      * (This is the default behavior.)
      *
-     * @draft ICU 65
+     * @stable ICU 65
      */
     ULOCMATCH_FAVOR_LANGUAGE,
     /**
      * Makes script differences matter relatively more than language differences.
      *
-     * @draft ICU 65
+     * @stable ICU 65
      */
     ULOCMATCH_FAVOR_SCRIPT
 };
@@ -51,14 +49,14 @@ typedef enum ULocMatchFavorSubtag ULocMatchFavorSubtag;
  * Builder option for whether all desired locales are treated equally or
  * earlier ones are preferred.
  *
- * @see Builder#setDemotionPerDesiredLocale(ULocMatchDemotion)
- * @draft ICU 65
+ * @see LocaleMatcher::Builder#setDemotionPerDesiredLocale(ULocMatchDemotion)
+ * @stable ICU 65
  */
 enum ULocMatchDemotion {
     /**
      * All desired locales are treated equally.
      *
-     * @draft ICU 65
+     * @stable ICU 65
      */
     ULOCMATCH_DEMOTION_NONE,
     /**
@@ -85,7 +83,7 @@ enum ULocMatchDemotion {
      *        this is possible in future versions of the data.)
      * </ul>
      *
-     * @draft ICU 65
+     * @stable ICU 65
      */
     ULOCMATCH_DEMOTION_REGION
 };
@@ -107,21 +105,21 @@ typedef enum ULocMatchDemotion ULocMatchDemotion;
  * if there is a decent match for the original UI language, we want to use it,
  * but not if it is merely a fallback.
  *
- * @see Builder#setDirection(ULocMatchDirection)
- * @draft ICU 67
+ * @see LocaleMatcher::Builder#setDirection(ULocMatchDirection)
+ * @stable ICU 67
  */
 enum ULocMatchDirection {
     /**
      * Locale matching includes one-way matches such as Breton→French. (default)
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     ULOCMATCH_DIRECTION_WITH_ONE_WAY,
     /**
      * Locale matching limited to two-way matches including e.g. Danish↔Norwegian
      * but ignoring one-way matches.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     ULOCMATCH_DIRECTION_ONLY_TWO_WAY
 };
@@ -181,7 +179,7 @@ class XLikelySubtags;
  *
  * <p>This class is not intended for public subclassing.
  *
- * @draft ICU 65
+ * @stable ICU 65
  */
 class U_COMMON_API LocaleMatcher : public UMemory {
 public:
@@ -189,7 +187,7 @@ public:
      * Data for the best-matching pair of a desired and a supported locale.
      * Movable but not copyable.
      *
-     * @draft ICU 65
+     * @stable ICU 65
      */
     class U_COMMON_API Result : public UMemory {
     public:
@@ -198,14 +196,14 @@ public:
          * This object will have the same contents that the source object had.
          *
          * @param src Result to move contents from.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Result(Result &&src) U_NOEXCEPT;
 
         /**
          * Destructor.
          *
-         * @draft ICU 65
+         * @stable ICU 65
          */
         ~Result();
 
@@ -214,28 +212,27 @@ public:
          * This object will have the same contents that the source object had.
          *
          * @param src Result to move contents from.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Result &operator=(Result &&src) U_NOEXCEPT;
 
-#ifndef U_HIDE_DRAFT_API
         /**
          * Returns the best-matching desired locale.
          * nullptr if the list of desired locales is empty or if none matched well enough.
          *
          * @return the best-matching desired locale, or nullptr.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         inline const Locale *getDesiredLocale() const { return desiredLocale; }
 
         /**
          * Returns the best-matching supported locale.
          * If none matched well enough, this is the default locale.
-         * The default locale is nullptr if the list of supported locales is empty and
-         * no explicit default locale is set.
+         * The default locale is nullptr if Builder::setNoDefaultLocale() was called,
+         * or if the list of supported locales is empty and no explicit default locale is set.
          *
          * @return the best-matching supported locale, or nullptr.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         inline const Locale *getSupportedLocale() const { return supportedLocale; }
 
@@ -244,7 +241,7 @@ public:
          * -1 if the list of desired locales is empty or if none matched well enough.
          *
          * @return the index of the best-matching desired locale, or -1.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         inline int32_t getDesiredIndex() const { return desiredIndex; }
 
@@ -256,7 +253,7 @@ public:
          * -1 if the list of supported locales is empty or if none matched well enough.
          *
          * @return the index of the best-matching supported locale, or -1.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         inline int32_t getSupportedIndex() const { return supportedIndex; }
 
@@ -270,10 +267,9 @@ public:
          * <p>Example: desired=ar-SA-u-nu-latn, supported=ar-EG, resolved locale=ar-SA-u-nu-latn
          *
          * @return a locale combining the best-matching desired and supported locales.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Locale makeResolvedLocale(UErrorCode &errorCode) const;
-#endif  // U_HIDE_DRAFT_API
 
     private:
         Result(const Locale *desired, const Locale *supported,
@@ -298,8 +294,7 @@ public:
      * LocaleMatcher builder.
      * Movable but not copyable.
      *
-     * @see LocaleMatcher#builder()
-     * @draft ICU 65
+     * @stable ICU 65
      */
     class U_COMMON_API Builder : public UMemory {
     public:
@@ -307,7 +302,7 @@ public:
          * Constructs a builder used in chaining parameters for building a LocaleMatcher.
          *
          * @return a new Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder() {}
 
@@ -316,14 +311,14 @@ public:
          * This builder will have the same contents that the source builder had.
          *
          * @param src Builder to move contents from.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder(Builder &&src) U_NOEXCEPT;
 
         /**
          * Destructor.
          *
-         * @draft ICU 65
+         * @stable ICU 65
          */
         ~Builder();
 
@@ -332,11 +327,10 @@ public:
          * This builder will have the same contents that the source builder had.
          *
          * @param src Builder to move contents from.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder &operator=(Builder &&src) U_NOEXCEPT;
 
-#ifndef U_HIDE_DRAFT_API
         /**
          * Parses an Accept-Language string
          * (<a href="https://tools.ietf.org/html/rfc2616#section-14.4">RFC 2616 Section 14.4</a>),
@@ -346,7 +340,7 @@ public:
          *
          * @param locales the Accept-Language string of locales to set
          * @return this Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder &setSupportedLocalesFromListString(StringPiece locales);
 
@@ -357,7 +351,7 @@ public:
          *
          * @param locales the list of locale
          * @return this Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder &setSupportedLocales(Locale::Iterator &locales);
 
@@ -372,7 +366,7 @@ public:
          * @param begin Start of range.
          * @param end Exclusive end of range.
          * @return this Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         template<typename Iter>
         Builder &setSupportedLocales(Iter begin, Iter end) {
@@ -397,7 +391,7 @@ public:
          * @param end Exclusive end of range.
          * @param converter Converter from *begin to const Locale & or compatible.
          * @return this Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         template<typename Iter, typename Conv>
         Builder &setSupportedLocalesViaConverter(Iter begin, Iter end, Conv converter) {
@@ -415,17 +409,31 @@ public:
          *
          * @param locale another locale
          * @return this Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder &addSupportedLocale(const Locale &locale);
 
+#ifndef U_HIDE_DRAFT_API
+        /**
+         * Sets no default locale.
+         * There will be no explicit or implicit default locale.
+         * If there is no good match, then the matcher will return nullptr for the
+         * best supported locale.
+         *
+         * @draft ICU 68
+         */
+        Builder &setNoDefaultLocale();
+#endif  // U_HIDE_DRAFT_API
+
         /**
          * Sets the default locale; if nullptr, or if it is not set explicitly,
          * then the first supported locale is used as the default locale.
+         * There is no default locale at all (nullptr will be returned instead)
+         * if setNoDefaultLocale() is called.
          *
          * @param defaultLocale the default locale (will be copied)
          * @return this Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder &setDefaultLocale(const Locale *defaultLocale);
 
@@ -437,7 +445,7 @@ public:
          *
          * @param subtag the subtag to favor
          * @return this Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder &setFavorSubtag(ULocMatchFavorSubtag subtag);
 
@@ -447,7 +455,7 @@ public:
          *
          * @param demotion the demotion per desired locale to set.
          * @return this Builder object
-         * @draft ICU 65
+         * @stable ICU 65
          */
         Builder &setDemotionPerDesiredLocale(ULocMatchDemotion demotion);
 
@@ -457,7 +465,7 @@ public:
          *
          * @param direction the match direction to set.
          * @return this Builder object
-         * @draft ICU 67
+         * @stable ICU 67
          */
         Builder &setDirection(ULocMatchDirection direction) {
             if (U_SUCCESS(errorCode_)) {
@@ -466,6 +474,31 @@ public:
             return *this;
         }
 
+#ifndef U_HIDE_DRAFT_API
+        /**
+         * Sets the maximum distance for an acceptable match.
+         * The matcher will return a match for a pair of locales only if
+         * they match at least as well as the pair given here.
+         *
+         * For example, setMaxDistance(en-US, en-GB) limits matches to ones where the
+         * (desired, support) locales have a distance no greater than a region subtag difference.
+         * This is much stricter than the CLDR default.
+         *
+         * The details of locale matching are subject to changes in
+         * CLDR data and in the algorithm.
+         * Specifying a maximum distance in relative terms via a sample pair of locales
+         * insulates from changes that affect all distance metrics similarly,
+         * but some changes will necessarily affect relative distances between
+         * different pairs of locales.
+         *
+         * @param desired the desired locale for distance comparison.
+         * @param supported the supported locale for distance comparison.
+         * @return this Builder object
+         * @draft ICU 68
+         */
+        Builder &setMaxDistance(const Locale &desired, const Locale &supported);
+#endif  // U_HIDE_DRAFT_API
+
         /**
          * Sets the UErrorCode if an error occurred while setting parameters.
          * Preserves older error codes in the outErrorCode.
@@ -473,8 +506,8 @@ public:
          * @param outErrorCode Set to an error code if it does not contain one already
          *                  and an error occurred while setting parameters.
          *                  Otherwise unchanged.
-         * @return TRUE if U_FAILURE(outErrorCode)
-         * @draft ICU 65
+         * @return true if U_FAILURE(outErrorCode)
+         * @stable ICU 65
          */
         UBool copyErrorTo(UErrorCode &outErrorCode) const;
 
@@ -485,11 +518,10 @@ public:
          * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
          *                  or else the function returns immediately. Check for U_FAILURE()
          *                  on output or use with function chaining. (See User Guide for details.)
-         * @return new LocaleMatcher.
-         * @draft ICU 65
+         * @return LocaleMatcher
+         * @stable ICU 65
          */
         LocaleMatcher build(UErrorCode &errorCode) const;
-#endif  // U_HIDE_DRAFT_API
 
     private:
         friend class LocaleMatcher;
@@ -505,8 +537,11 @@ public:
         int32_t thresholdDistance_ = -1;
         ULocMatchDemotion demotion_ = ULOCMATCH_DEMOTION_REGION;
         Locale *defaultLocale_ = nullptr;
+        bool withDefault_ = true;
         ULocMatchFavorSubtag favor_ = ULOCMATCH_FAVOR_LANGUAGE;
         ULocMatchDirection direction_ = ULOCMATCH_DIRECTION_WITH_ONE_WAY;
+        Locale *maxDistanceDesired_ = nullptr;
+        Locale *maxDistanceSupported_ = nullptr;
     };
 
     // FYI No public LocaleMatcher constructors in C++; use the Builder.
@@ -515,13 +550,13 @@ public:
      * Move copy constructor; might modify the source.
      * This matcher will have the same settings that the source matcher had.
      * @param src source matcher
-     * @draft ICU 65
+     * @stable ICU 65
      */
     LocaleMatcher(LocaleMatcher &&src) U_NOEXCEPT;
 
     /**
      * Destructor.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     ~LocaleMatcher();
 
@@ -531,11 +566,10 @@ public:
      * The behavior is undefined if *this and src are the same object.
      * @param src source matcher
      * @return *this
-     * @draft ICU 65
+     * @stable ICU 65
      */
     LocaleMatcher &operator=(LocaleMatcher &&src) U_NOEXCEPT;
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns the supported locale which best matches the desired locale.
      *
@@ -544,7 +578,7 @@ public:
      *                  or else the function returns immediately. Check for U_FAILURE()
      *                  on output or use with function chaining. (See User Guide for details.)
      * @return the best-matching supported locale.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     const Locale *getBestMatch(const Locale &desiredLocale, UErrorCode &errorCode) const;
 
@@ -556,7 +590,7 @@ public:
      *                  or else the function returns immediately. Check for U_FAILURE()
      *                  on output or use with function chaining. (See User Guide for details.)
      * @return the best-matching supported locale.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     const Locale *getBestMatch(Locale::Iterator &desiredLocales, UErrorCode &errorCode) const;
 
@@ -572,7 +606,7 @@ public:
      *                  or else the function returns immediately. Check for U_FAILURE()
      *                  on output or use with function chaining. (See User Guide for details.)
      * @return the best-matching supported locale.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     const Locale *getBestMatchForListString(StringPiece desiredLocaleList, UErrorCode &errorCode) const;
 
@@ -586,7 +620,7 @@ public:
      *                  or else the function returns immediately. Check for U_FAILURE()
      *                  on output or use with function chaining. (See User Guide for details.)
      * @return the best-matching pair of the desired and a supported locale.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     Result getBestMatchResult(const Locale &desiredLocale, UErrorCode &errorCode) const;
 
@@ -600,9 +634,25 @@ public:
      *                  or else the function returns immediately. Check for U_FAILURE()
      *                  on output or use with function chaining. (See User Guide for details.)
      * @return the best-matching pair of a desired and a supported locale.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     Result getBestMatchResult(Locale::Iterator &desiredLocales, UErrorCode &errorCode) const;
+
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns true if the pair of locales matches acceptably.
+     * This is influenced by Builder options such as setDirection(), setFavorSubtag(),
+     * and setMaxDistance().
+     *
+     * @param desired The desired locale.
+     * @param supported The supported locale.
+     * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
+     *                  or else the function returns immediately. Check for U_FAILURE()
+     *                  on output or use with function chaining. (See User Guide for details.)
+     * @return true if the pair of locales matches acceptably.
+     * @draft ICU 68
+     */
+    UBool isMatch(const Locale &desired, const Locale &supported, UErrorCode &errorCode) const;
 #endif  // U_HIDE_DRAFT_API
 
 #ifndef U_HIDE_INTERNAL_API
@@ -648,7 +698,7 @@ private:
     LSR *lsrs;
     int32_t supportedLocalesLength;
     // These are in preference order: 1. Default locale 2. paradigm locales 3. others.
-    UHashtable *supportedLsrToIndex;  // Map<LSR, Integer> stores index+1 because 0 is "not found"
+    UHashtable *supportedLsrToIndex;  // Map<LSR, Integer>
     // Array versions of the supportedLsrToIndex keys and values.
     // The distance lookup loops over the supportedLSRs and returns the index of the best match.
     const LSR **supportedLSRs;
@@ -660,6 +710,5 @@ private:
 
 U_NAMESPACE_END
 
-#endif  // U_FORCE_HIDE_DRAFT_API
 #endif  // U_SHOW_CPLUSPLUS_API
 #endif  // __LOCALEMATCHER_H__
diff --git a/deps/icu-small/source/common/unicode/localpointer.h b/deps/icu-small/source/common/unicode/localpointer.h
index 61c3020918e578ed7a28b37a46dcd8e338631783..2a65f2d382d2d866049dd50b32c1eb4e3cd76fe0 100644
--- a/deps/icu-small/source/common/unicode/localpointer.h
+++ b/deps/icu-small/source/common/unicode/localpointer.h
@@ -88,13 +88,13 @@ public:
     ~LocalPointerBase() { /* delete ptr; */ }
     /**
      * NULL check.
-     * @return TRUE if ==NULL
+     * @return true if ==NULL
      * @stable ICU 4.4
      */
     UBool isNull() const { return ptr==NULL; }
     /**
      * NULL check.
-     * @return TRUE if !=NULL
+     * @return true if !=NULL
      * @stable ICU 4.4
      */
     UBool isValid() const { return ptr!=NULL; }
diff --git a/deps/icu-small/source/common/unicode/locid.h b/deps/icu-small/source/common/unicode/locid.h
index ee8697b0a57f3e087a4d20fd7ce174e62c336240..b535e77e181015fb1753da868463f96be2aeed54 100644
--- a/deps/icu-small/source/common/unicode/locid.h
+++ b/deps/icu-small/source/common/unicode/locid.h
@@ -253,7 +253,7 @@ public:
     /**
      * Construct a locale from language, country, variant.
      * If an error occurs, then the constructed object will be "bogus"
-     * (isBogus() will return TRUE).
+     * (isBogus() will return true).
      *
      * @param language Lowercase two-letter or three-letter ISO-639 code.
      *  This parameter can instead be an ICU style C locale (e.g. "en_US"),
@@ -393,13 +393,17 @@ public:
      * If the specified language tag contains any ill-formed subtags,
      * the first such subtag and all following subtags are ignored.
      * <p>
-     * This implements the 'Language-Tag' production of BCP47, and so
-     * supports grandfathered (regular and irregular) as well as private
-     * use language tags.  Private use tags are represented as 'x-whatever',
-     * and grandfathered tags are converted to their canonical replacements
-     * where they exist.  Note that a few grandfathered tags have no modern
-     * replacement, these will be converted using the fallback described in
+     * This implements the 'Language-Tag' production of BCP 47, and so
+     * supports legacy language tags (marked as “Type: grandfathered” in BCP 47)
+     * (regular and irregular) as well as private use language tags.
+     *
+     * Private use tags are represented as 'x-whatever',
+     * and legacy tags are converted to their canonical replacements where they exist.
+     *
+     * Note that a few legacy tags have no modern replacement;
+     * these will be converted using the fallback described in
      * the first paragraph, so some information might be lost.
+     *
      * @param tag     the input BCP47 language tag.
      * @param status  error information if creating the Locale failed.
      * @return        the Locale for the specified BCP47 language tag.
@@ -567,15 +571,13 @@ public:
      */
     void minimizeSubtags(UErrorCode& status);
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Canonicalize the locale ID of this object according to CLDR.
      * @param status the status code
-     * @draft ICU 67
+     * @stable ICU 67
      * @see createCanonical
      */
     void canonicalize(UErrorCode& status);
-#endif  // U_HIDE_DRAFT_API
 
     /**
      * Gets the list of keywords for the specified locale.
@@ -795,14 +797,14 @@ public:
     /**
      * Returns whether this locale's script is written right-to-left.
      * If there is no script subtag, then the likely script is used, see uloc_addLikelySubtags().
-     * If no likely script is known, then FALSE is returned.
+     * If no likely script is known, then false is returned.
      *
      * A script is right-to-left according to the CLDR script metadata
      * which corresponds to whether the script's letters have Bidi_Class=R or AL.
      *
-     * Returns TRUE for "ar" and "en-Hebr", FALSE for "zh" and "fa-Cyrl".
+     * Returns true for "ar" and "en-Hebr", false for "zh" and "fa-Cyrl".
      *
-     * @return TRUE if the locale's script is written right-to-left
+     * @return true if the locale's script is written right-to-left
      * @stable ICU 54
      */
     UBool isRightToLeft() const;
@@ -956,7 +958,7 @@ public:
 
     /**
      * Gets the bogus state. Locale object can be bogus if it doesn't exist
-     * @return FALSE if it is a real locale, TRUE if it is a bogus locale
+     * @return false if it is a real locale, true if it is a bogus locale
      * @stable ICU 2.1
      */
     inline UBool isBogus(void) const;
@@ -1005,32 +1007,31 @@ public:
      */
     virtual UClassID getDynamicClassID() const;
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * A Locale iterator interface similar to a Java Iterator<Locale>.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     class U_COMMON_API Iterator /* not : public UObject because this is an interface/mixin class */ {
     public:
-        /** @draft ICU 65 */
+        /** @stable ICU 65 */
         virtual ~Iterator();
 
         /**
-         * @return TRUE if next() can be called again.
-         * @draft ICU 65
+         * @return true if next() can be called again.
+         * @stable ICU 65
          */
         virtual UBool hasNext() const = 0;
 
         /**
          * @return the next locale.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         virtual const Locale &next() = 0;
     };
 
     /**
      * A generic Locale iterator implementation over Locale input iterators.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     template<typename Iter>
     class RangeIterator : public Iterator, public UMemory {
@@ -1042,19 +1043,19 @@ public:
          *
          * @param begin Start of range.
          * @param end Exclusive end of range.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         RangeIterator(Iter begin, Iter end) : it_(begin), end_(end) {}
 
         /**
-         * @return TRUE if next() can be called again.
-         * @draft ICU 65
+         * @return true if next() can be called again.
+         * @stable ICU 65
          */
         UBool hasNext() const override { return it_ != end_; }
 
         /**
          * @return the next locale.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         const Locale &next() override { return *it_++; }
 
@@ -1066,7 +1067,7 @@ public:
     /**
      * A generic Locale iterator implementation over Locale input iterators.
      * Calls the converter to convert each *begin to a const Locale &.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     template<typename Iter, typename Conv>
     class ConvertingIterator : public Iterator, public UMemory {
@@ -1079,20 +1080,20 @@ public:
          * @param begin Start of range.
          * @param end Exclusive end of range.
          * @param converter Converter from *begin to const Locale & or compatible.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         ConvertingIterator(Iter begin, Iter end, Conv converter) :
                 it_(begin), end_(end), converter_(converter) {}
 
         /**
-         * @return TRUE if next() can be called again.
-         * @draft ICU 65
+         * @return true if next() can be called again.
+         * @stable ICU 65
          */
         UBool hasNext() const override { return it_ != end_; }
 
         /**
          * @return the next locale.
-         * @draft ICU 65
+         * @stable ICU 65
          */
         const Locale &next() override { return converter_(*it_++); }
 
@@ -1101,7 +1102,6 @@ public:
         const Iter end_;
         Conv converter_;
     };
-#endif  // U_HIDE_DRAFT_API
 
 protected: /* only protected for testing purposes. DO NOT USE. */
 #ifndef U_HIDE_INTERNAL_API
diff --git a/deps/icu-small/source/common/unicode/messagepattern.h b/deps/icu-small/source/common/unicode/messagepattern.h
index 04f00a8757d7832179098246317ac907738d122a..98e7b70b1fcc13b771d275e227db9b95c2671a40 100644
--- a/deps/icu-small/source/common/unicode/messagepattern.h
+++ b/deps/icu-small/source/common/unicode/messagepattern.h
@@ -265,7 +265,7 @@ typedef enum UMessagePatternArgType UMessagePatternArgType;
 
 /**
  * \def UMSGPAT_ARG_TYPE_HAS_PLURAL_STYLE
- * Returns TRUE if the argument type has a plural style part sequence and semantics,
+ * Returns true if the argument type has a plural style part sequence and semantics,
  * for example UMSGPAT_ARG_TYPE_PLURAL and UMSGPAT_ARG_TYPE_SELECTORDINAL.
  * @stable ICU 50
  */
@@ -523,14 +523,14 @@ public:
 
     /**
      * @param other another object to compare with.
-     * @return TRUE if this object is equivalent to the other one.
+     * @return true if this object is equivalent to the other one.
      * @stable ICU 4.8
      */
     UBool operator==(const MessagePattern &other) const;
 
     /**
      * @param other another object to compare with.
-     * @return FALSE if this object is equivalent to the other one.
+     * @return false if this object is equivalent to the other one.
      * @stable ICU 4.8
      */
     inline UBool operator!=(const MessagePattern &other) const {
@@ -564,7 +564,7 @@ public:
 
     /**
      * Does the parsed pattern have named arguments like {first_name}?
-     * @return TRUE if the parsed pattern has at least one named argument.
+     * @return true if the parsed pattern has at least one named argument.
      * @stable ICU 4.8
      */
     UBool hasNamedArguments() const {
@@ -573,7 +573,7 @@ public:
 
     /**
      * Does the parsed pattern have numbered arguments like {2}?
-     * @return TRUE if the parsed pattern has at least one numbered argument.
+     * @return true if the parsed pattern has at least one numbered argument.
      * @stable ICU 4.8
      */
     UBool hasNumberedArguments() const {
@@ -664,7 +664,7 @@ public:
      * Compares the part's substring with the input string s.
      * @param part a part of this MessagePattern.
      * @param s a string.
-     * @return TRUE if getSubstring(part).equals(s).
+     * @return true if getSubstring(part).equals(s).
      * @stable ICU 4.8
      */
     UBool partSubstringMatches(const Part &part, const UnicodeString &s) const {
@@ -785,7 +785,7 @@ public:
          * Indicates whether the Part type has a numeric value.
          * If so, then that numeric value can be retrieved via MessagePattern.getNumericValue().
          * @param type The Part type to be tested.
-         * @return TRUE if the Part type has a numeric value.
+         * @return true if the Part type has a numeric value.
          * @stable ICU 4.8
          */
         static UBool hasNumericValue(UMessagePatternPartType type) {
@@ -794,14 +794,14 @@ public:
 
         /**
          * @param other another object to compare with.
-         * @return TRUE if this object is equivalent to the other one.
+         * @return true if this object is equivalent to the other one.
          * @stable ICU 4.8
          */
         UBool operator==(const Part &other) const;
 
         /**
          * @param other another object to compare with.
-         * @return FALSE if this object is equivalent to the other one.
+         * @return false if this object is equivalent to the other one.
          * @stable ICU 4.8
          */
         inline UBool operator!=(const Part &other) const {
@@ -869,7 +869,7 @@ private:
      * Parses a number from the specified message substring.
      * @param start start index into the message string
      * @param limit limit index into the message string, must be start<limit
-     * @param allowInfinity TRUE if U+221E is allowed (for ChoiceFormat)
+     * @param allowInfinity true if U+221E is allowed (for ChoiceFormat)
      * @param parseError
      * @param errorCode
      */
@@ -900,13 +900,13 @@ private:
     UBool isOrdinal(int32_t index);
 
     /**
-     * @return TRUE if we are inside a MessageFormat (sub-)pattern,
+     * @return true if we are inside a MessageFormat (sub-)pattern,
      *         as opposed to inside a top-level choice/plural/select pattern.
      */
     UBool inMessageFormatPattern(int32_t nestingLevel);
 
     /**
-     * @return TRUE if we are in a MessageFormat sub-pattern
+     * @return true if we are in a MessageFormat sub-pattern
      *         of a top-level ChoiceFormat pattern.
      */
     UBool inTopLevelChoiceMessage(int32_t nestingLevel, UMessagePatternArgType parentType);
diff --git a/deps/icu-small/source/common/unicode/normalizer2.h b/deps/icu-small/source/common/unicode/normalizer2.h
index 4aeb3bb3d8292107c8cb6098e29ad8119c6d86da..2d355250c29fde5e90d311235cda5d01306221db 100644
--- a/deps/icu-small/source/common/unicode/normalizer2.h
+++ b/deps/icu-small/source/common/unicode/normalizer2.h
@@ -225,10 +225,8 @@ public:
      * Normalizes a UTF-8 string and optionally records how source substrings
      * relate to changed and unchanged result substrings.
      *
-     * Currently implemented completely only for "compose" modes,
-     * such as for NFC, NFKC, and NFKC_Casefold
-     * (UNORM2_COMPOSE and UNORM2_COMPOSE_CONTIGUOUS).
-     * Otherwise currently converts to & from UTF-16 and does not support edits.
+     * Implemented completely for all built-in modes except for FCD.
+     * The base class implementation converts to & from UTF-16 and does not support edits.
      *
      * @param options   Options bit set, usually 0. See U_OMIT_UNCHANGED_TEXT and U_EDITS_NO_RESET.
      * @param src       Source UTF-8 string.
@@ -290,13 +288,13 @@ public:
      * Gets the decomposition mapping of c.
      * Roughly equivalent to normalizing the String form of c
      * on a UNORM2_DECOMPOSE Normalizer2 instance, but much faster, and except that this function
-     * returns FALSE and does not write a string
+     * returns false and does not write a string
      * if c does not have a decomposition mapping in this instance's data.
      * This function is independent of the mode of the Normalizer2.
      * @param c code point
      * @param decomposition String object which will be set to c's
      *                      decomposition mapping, if there is one.
-     * @return TRUE if c has a decomposition, otherwise FALSE
+     * @return true if c has a decomposition, otherwise false
      * @stable ICU 4.6
      */
     virtual UBool
@@ -319,11 +317,11 @@ public:
      * in this case, the result contains either one or two code points (=1..4 char16_ts).
      *
      * This function is independent of the mode of the Normalizer2.
-     * The default implementation returns FALSE.
+     * The default implementation returns false.
      * @param c code point
      * @param decomposition String object which will be set to c's
      *                      raw decomposition mapping, if there is one.
-     * @return TRUE if c has a decomposition, otherwise FALSE
+     * @return true if c has a decomposition, otherwise false
      * @stable ICU 49
      */
     virtual UBool
@@ -369,7 +367,7 @@ public:
      *                  pass the U_SUCCESS() test, or else the function returns
      *                  immediately. Check for U_FAILURE() on output or use with
      *                  function chaining. (See User Guide for details.)
-     * @return TRUE if s is normalized
+     * @return true if s is normalized
      * @stable ICU 4.4
      */
     virtual UBool
@@ -381,18 +379,16 @@ public:
      * resolves to "yes" or "no" to provide a definitive result,
      * at the cost of doing more work in those cases.
      *
-     * This works for all normalization modes,
-     * but it is currently optimized for UTF-8 only for "compose" modes,
-     * such as for NFC, NFKC, and NFKC_Casefold
-     * (UNORM2_COMPOSE and UNORM2_COMPOSE_CONTIGUOUS).
-     * For other modes it currently converts to UTF-16 and calls isNormalized().
+     * This works for all normalization modes.
+     * It is optimized for UTF-8 for all built-in modes except for FCD.
+     * The base class implementation converts to UTF-16 and calls isNormalized().
      *
      * @param s UTF-8 input string
      * @param errorCode Standard ICU error code. Its input value must
      *                  pass the U_SUCCESS() test, or else the function returns
      *                  immediately. Check for U_FAILURE() on output or use with
      *                  function chaining. (See User Guide for details.)
-     * @return TRUE if s is normalized
+     * @return true if s is normalized
      * @stable ICU 60
      */
     virtual UBool
@@ -452,7 +448,7 @@ public:
      * character independently.
      * This is used for iterative normalization. See the class documentation for details.
      * @param c character to test
-     * @return TRUE if c has a normalization boundary before it
+     * @return true if c has a normalization boundary before it
      * @stable ICU 4.4
      */
     virtual UBool hasBoundaryBefore(UChar32 c) const = 0;
@@ -468,7 +464,7 @@ public:
      * This is used for iterative normalization. See the class documentation for details.
      * Note that this operation may be significantly slower than hasBoundaryBefore().
      * @param c character to test
-     * @return TRUE if c has a normalization boundary after it
+     * @return true if c has a normalization boundary after it
      * @stable ICU 4.4
      */
     virtual UBool hasBoundaryAfter(UChar32 c) const = 0;
@@ -483,7 +479,7 @@ public:
      * This is used for iterative normalization. See the class documentation for details.
      * Note that this operation may be significantly slower than hasBoundaryBefore().
      * @param c character to test
-     * @return TRUE if c is normalization-inert
+     * @return true if c is normalization-inert
      * @stable ICU 4.4
      */
     virtual UBool isInert(UChar32 c) const = 0;
@@ -543,10 +539,8 @@ public:
      * Normalizes a UTF-8 string and optionally records how source substrings
      * relate to changed and unchanged result substrings.
      *
-     * Currently implemented completely only for "compose" modes,
-     * such as for NFC, NFKC, and NFKC_Casefold
-     * (UNORM2_COMPOSE and UNORM2_COMPOSE_CONTIGUOUS).
-     * Otherwise currently converts to & from UTF-16 and does not support edits.
+     * Implemented completely for most built-in modes except for FCD.
+     * The base class implementation converts to & from UTF-16 and does not support edits.
      *
      * @param options   Options bit set, usually 0. See U_OMIT_UNCHANGED_TEXT and U_EDITS_NO_RESET.
      * @param src       Source UTF-8 string.
@@ -612,7 +606,7 @@ public:
      * @param c code point
      * @param decomposition String object which will be set to c's
      *                      decomposition mapping, if there is one.
-     * @return TRUE if c has a decomposition, otherwise FALSE
+     * @return true if c has a decomposition, otherwise false
      * @stable ICU 4.6
      */
     virtual UBool
@@ -626,7 +620,7 @@ public:
      * @param c code point
      * @param decomposition String object which will be set to c's
      *                      raw decomposition mapping, if there is one.
-     * @return TRUE if c has a decomposition, otherwise FALSE
+     * @return true if c has a decomposition, otherwise false
      * @stable ICU 49
      */
     virtual UBool
@@ -664,7 +658,7 @@ public:
      *                  pass the U_SUCCESS() test, or else the function returns
      *                  immediately. Check for U_FAILURE() on output or use with
      *                  function chaining. (See User Guide for details.)
-     * @return TRUE if s is normalized
+     * @return true if s is normalized
      * @stable ICU 4.4
      */
     virtual UBool
@@ -676,18 +670,16 @@ public:
      * resolves to "yes" or "no" to provide a definitive result,
      * at the cost of doing more work in those cases.
      *
-     * This works for all normalization modes,
-     * but it is currently optimized for UTF-8 only for "compose" modes,
-     * such as for NFC, NFKC, and NFKC_Casefold
-     * (UNORM2_COMPOSE and UNORM2_COMPOSE_CONTIGUOUS).
-     * For other modes it currently converts to UTF-16 and calls isNormalized().
+     * This works for all normalization modes.
+     * It is optimized for UTF-8 for all built-in modes except for FCD.
+     * The base class implementation converts to UTF-16 and calls isNormalized().
      *
      * @param s UTF-8 input string
      * @param errorCode Standard ICU error code. Its input value must
      *                  pass the U_SUCCESS() test, or else the function returns
      *                  immediately. Check for U_FAILURE() on output or use with
      *                  function chaining. (See User Guide for details.)
-     * @return TRUE if s is normalized
+     * @return true if s is normalized
      * @stable ICU 60
      */
     virtual UBool
@@ -724,7 +716,7 @@ public:
      * regardless of context.
      * For details see the Normalizer2 base class documentation.
      * @param c character to test
-     * @return TRUE if c has a normalization boundary before it
+     * @return true if c has a normalization boundary before it
      * @stable ICU 4.4
      */
     virtual UBool hasBoundaryBefore(UChar32 c) const U_OVERRIDE;
@@ -734,7 +726,7 @@ public:
      * regardless of context.
      * For details see the Normalizer2 base class documentation.
      * @param c character to test
-     * @return TRUE if c has a normalization boundary after it
+     * @return true if c has a normalization boundary after it
      * @stable ICU 4.4
      */
     virtual UBool hasBoundaryAfter(UChar32 c) const U_OVERRIDE;
@@ -743,7 +735,7 @@ public:
      * Tests if the character is normalization-inert.
      * For details see the Normalizer2 base class documentation.
      * @param c character to test
-     * @return TRUE if c is normalization-inert
+     * @return true if c is normalization-inert
      * @stable ICU 4.4
      */
     virtual UBool isInert(UChar32 c) const U_OVERRIDE;
diff --git a/deps/icu-small/source/common/unicode/normlzr.h b/deps/icu-small/source/common/unicode/normlzr.h
index 00dd820474f7340acd325d99954837d108936e21..83dc7cea01771008fb7a992f48a679e192396735 100644
--- a/deps/icu-small/source/common/unicode/normlzr.h
+++ b/deps/icu-small/source/common/unicode/normlzr.h
@@ -234,7 +234,7 @@ public:
    *
    * @param source    the string to be composed.
    * @param compat    Perform compatibility decomposition before composition.
-   *                  If this argument is <code>FALSE</code>, only canonical
+   *                  If this argument is <code>false</code>, only canonical
    *                  decomposition will be performed.
    * @param options   the optional features to be enabled (0 for no options)
    * @param result    The composed string (on output).
@@ -256,7 +256,7 @@ public:
    *
    * @param source    the string to be decomposed.
    * @param compat    Perform compatibility decomposition.
-   *                  If this argument is <code>FALSE</code>, only canonical
+   *                  If this argument is <code>false</code>, only canonical
    *                  decomposition will be performed.
    * @param options   the optional features to be enabled (0 for no options)
    * @param result    The decomposed string (on output).
@@ -315,7 +315,7 @@ public:
    * never a "maybe".
    * For NFD, NFKD, and FCD, both functions work exactly the same.
    * For NFC and NFKC where quickCheck may return "maybe", this function will
-   * perform further tests to arrive at a TRUE/FALSE result.
+   * perform further tests to arrive at a true/false result.
    *
    * @param src        String that is to be tested if it is in a normalization format.
    * @param mode       Which normalization form to test for.
@@ -577,7 +577,7 @@ public:
   int32_t            endIndex(void) const;
 
   /**
-   * Returns TRUE when both iterators refer to the same character in the same
+   * Returns true when both iterators refer to the same character in the same
    * input text.
    *
    * @param that a Normalizer object to compare this one to
@@ -587,7 +587,7 @@ public:
   UBool        operator==(const Normalizer& that) const;
 
   /**
-   * Returns FALSE when both iterators refer to the same character in the same
+   * Returns false when both iterators refer to the same character in the same
    * input text.
    *
    * @param that a Normalizer object to compare this one to
@@ -655,8 +655,8 @@ public:
    * It is possible to specify multiple options that are all turned on or off.
    *
    * @param   option  the option(s) whose value is/are to be set.
-   * @param   value   the new setting for the option.  Use <code>TRUE</code> to
-   *                  turn the option(s) on and <code>FALSE</code> to turn it/them off.
+   * @param   value   the new setting for the option.  Use <code>true</code> to
+   *                  turn the option(s) on and <code>false</code> to turn it/them off.
    *
    * @see #getOption
    * @deprecated ICU 56 Use Normalizer2 instead.
@@ -666,11 +666,11 @@ public:
 
   /**
    * Determine whether an option is turned on or off.
-   * If multiple options are specified, then the result is TRUE if any
+   * If multiple options are specified, then the result is true if any
    * of them are set.
    * <p>
    * @param option the option(s) that are to be checked
-   * @return TRUE if any of the option(s) are set
+   * @return true if any of the option(s) are set
    * @see #setOption
    * @deprecated ICU 56 Use Normalizer2 instead.
    */
diff --git a/deps/icu-small/source/common/unicode/parsepos.h b/deps/icu-small/source/common/unicode/parsepos.h
index ae5754b8d751326c02e33368b6d544ba3ce88854..d6129fd4f1604f76e8991eae360dbd521e1066da 100644
--- a/deps/icu-small/source/common/unicode/parsepos.h
+++ b/deps/icu-small/source/common/unicode/parsepos.h
@@ -97,14 +97,14 @@ public:
 
     /**
      * Equality operator.
-     * @return TRUE if the two parse positions are equal, FALSE otherwise.
+     * @return true if the two parse positions are equal, false otherwise.
      * @stable ICU 2.0
      */
     inline UBool              operator==(const ParsePosition& that) const;
 
     /**
      * Equality operator.
-     * @return TRUE if the two parse positions are not equal, FALSE otherwise.
+     * @return true if the two parse positions are not equal, false otherwise.
      * @stable ICU 2.0
      */
     inline UBool              operator!=(const ParsePosition& that) const;
@@ -196,9 +196,9 @@ inline UBool
 ParsePosition::operator==(const ParsePosition& copy) const
 {
   if(index != copy.index || errorIndex != copy.errorIndex)
-  return FALSE;
+  return false;
   else
-  return TRUE;
+  return true;
 }
 
 inline UBool
diff --git a/deps/icu-small/source/common/unicode/platform.h b/deps/icu-small/source/common/unicode/platform.h
index d6f792ba345b7e5a76100237182ecbf32f3dc140..0dc91234006650dee031a2f327763fdda86dd66e 100644
--- a/deps/icu-small/source/common/unicode/platform.h
+++ b/deps/icu-small/source/common/unicode/platform.h
@@ -880,6 +880,6 @@ namespace std {
 #else
 #    define U_CALLCONV_FPTR
 #endif
-/* @} */
+/** @} */
 
 #endif  // _PLATFORM_H
diff --git a/deps/icu-small/source/common/unicode/putil.h b/deps/icu-small/source/common/unicode/putil.h
index 14bb99ccc545b24821aa9a4250a9c25126efd0ed..f8c510dacc75fc6c333f6c29b22bdda2da464c4b 100644
--- a/deps/icu-small/source/common/unicode/putil.h
+++ b/deps/icu-small/source/common/unicode/putil.h
@@ -66,7 +66,7 @@
  *
  * @stable ICU 2.0
  */
-U_STABLE const char* U_EXPORT2 u_getDataDirectory(void);
+U_CAPI const char* U_EXPORT2 u_getDataDirectory(void);
 
 
 /**
@@ -88,7 +88,7 @@ U_STABLE const char* U_EXPORT2 u_getDataDirectory(void);
  * @see u_init
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 u_setDataDirectory(const char *directory);
+U_CAPI void U_EXPORT2 u_setDataDirectory(const char *directory);
 
 #ifndef U_HIDE_INTERNAL_API
 /**
@@ -99,7 +99,7 @@ U_STABLE void U_EXPORT2 u_setDataDirectory(const char *directory);
   * @return the time zone data override directory.
   * @internal
   */
-U_INTERNAL const char * U_EXPORT2 u_getTimeZoneFilesDirectory(UErrorCode *status);
+U_CAPI const char * U_EXPORT2 u_getTimeZoneFilesDirectory(UErrorCode *status);
 
 /**
   * Set the time zone files override directory.
@@ -109,7 +109,7 @@ U_INTERNAL const char * U_EXPORT2 u_getTimeZoneFilesDirectory(UErrorCode *status
   *   will access the time zone data.
   * @internal
   */
-U_INTERNAL void U_EXPORT2 u_setTimeZoneFilesDirectory(const char *path, UErrorCode *status);
+U_CAPI void U_EXPORT2 u_setTimeZoneFilesDirectory(const char *path, UErrorCode *status);
 #endif  /* U_HIDE_INTERNAL_API */
 
 
@@ -155,7 +155,7 @@ U_INTERNAL void U_EXPORT2 u_setTimeZoneFilesDirectory(const char *path, UErrorCo
  * @see U_CHARSET_FAMILY
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_charsToUChars(const char *cs, UChar *us, int32_t length);
 
 /**
@@ -177,7 +177,7 @@ u_charsToUChars(const char *cs, UChar *us, int32_t length);
  * @see U_CHARSET_FAMILY
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_UCharsToChars(const UChar *us, char *cs, int32_t length);
 
 #endif
diff --git a/deps/icu-small/source/common/unicode/rbbi.h b/deps/icu-small/source/common/unicode/rbbi.h
index 7825f603a51c1b98686c2985372d4d1e6d261365..65117f616cdf5b83bf3b4b95f6aa078d677982a2 100644
--- a/deps/icu-small/source/common/unicode/rbbi.h
+++ b/deps/icu-small/source/common/unicode/rbbi.h
@@ -32,6 +32,8 @@
 #include "unicode/parseerr.h"
 #include "unicode/schriter.h"
 
+struct UCPTrie;
+
 U_NAMESPACE_BEGIN
 
 /** @internal */
@@ -140,6 +142,11 @@ private:
       */
     UBool           fDone;
 
+    /**
+     *  Array of look-ahead tentative results.
+     */
+    int32_t *fLookAheadMatches;
+
     //=======================================================================
     // constructors
     //=======================================================================
@@ -246,20 +253,20 @@ public:
     RuleBasedBreakIterator& operator=(const RuleBasedBreakIterator& that);
 
     /**
-     * Equality operator.  Returns TRUE if both BreakIterators are of the
+     * Equality operator.  Returns true if both BreakIterators are of the
      * same class, have the same behavior, and iterate over the same text.
      * @param that The BreakIterator to be compared for equality
-     * @return TRUE if both BreakIterators are of the
+     * @return true if both BreakIterators are of the
      * same class, have the same behavior, and iterate over the same text.
      *  @stable ICU 2.0
      */
     virtual UBool operator==(const BreakIterator& that) const;
 
     /**
-     * Not-equal operator.  If operator== returns TRUE, this returns FALSE,
+     * Not-equal operator.  If operator== returns true, this returns false,
      * and vice versa.
      * @param that The BreakIterator to be compared for inequality
-     * @return TRUE if both BreakIterators are not same.
+     * @return true if both BreakIterators are not same.
      *  @stable ICU 2.0
      */
     inline UBool operator!=(const BreakIterator& that) const;
@@ -659,6 +666,28 @@ private:
      */
     int32_t handleNext();
 
+    /*
+     * Templatized version of handleNext() and handleSafePrevious().
+     *
+     * There will be exactly four instantiations, two each for 8 and 16 bit tables,
+     * two each for 8 and 16 bit trie.
+     * Having separate instantiations for the table types keeps conditional tests of
+     * the table type out of the inner loops, at the expense of replicated code.
+     *
+     * The template parameter for the Trie access function is a value, not a type.
+     * Doing it this way, the compiler will inline the Trie function in the
+     * expanded functions. (Both the 8 and 16 bit access functions have the same type
+     * signature)
+     */
+
+    typedef uint16_t (*PTrieFunc)(const UCPTrie *, UChar32);
+
+    template<typename RowType, PTrieFunc trieFunc>
+    int32_t handleSafePrevious(int32_t fromPosition);
+
+    template<typename RowType, PTrieFunc trieFunc>
+    int32_t handleNext();
+
 
     /**
      * This function returns the appropriate LanguageBreakEngine for a
@@ -681,7 +710,6 @@ private:
      * @internal
      */
     void dumpTables();
-
 #endif  /* U_HIDE_INTERNAL_API */
 };
 
diff --git a/deps/icu-small/source/common/unicode/resbund.h b/deps/icu-small/source/common/unicode/resbund.h
index 708a3423d2ae2b6446c01c49f26b44df3f82d3da..63ffa506e77eec5c6770c792b6b733e0dddac4c4 100644
--- a/deps/icu-small/source/common/unicode/resbund.h
+++ b/deps/icu-small/source/common/unicode/resbund.h
@@ -286,7 +286,7 @@ public:
     /**
      * Checks whether the resource has another element to iterate over.
      *
-     * @return TRUE if there are more elements, FALSE if there is no more elements
+     * @return true if there are more elements, false if there is no more elements
      * @stable ICU 2.0
      */
     UBool
diff --git a/deps/icu-small/source/common/unicode/simpleformatter.h b/deps/icu-small/source/common/unicode/simpleformatter.h
index 9414bca3085ad448a16211b7627960c1ce1dee53..6d9c04ace2359a6ccaf18dfaafd5edcafc1de537 100644
--- a/deps/icu-small/source/common/unicode/simpleformatter.h
+++ b/deps/icu-small/source/common/unicode/simpleformatter.h
@@ -125,7 +125,7 @@ public:
      * @param errorCode ICU error code in/out parameter.
      *                  Must fulfill U_SUCCESS before the function call.
      *                  Set to U_ILLEGAL_ARGUMENT_ERROR for bad argument syntax.
-     * @return TRUE if U_SUCCESS(errorCode).
+     * @return true if U_SUCCESS(errorCode).
      * @stable ICU 57
      */
     UBool applyPattern(const UnicodeString &pattern, UErrorCode &errorCode) {
@@ -144,7 +144,7 @@ public:
      *                  Must fulfill U_SUCCESS before the function call.
      *                  Set to U_ILLEGAL_ARGUMENT_ERROR for bad argument syntax and
      *                  too few or too many arguments.
-     * @return TRUE if U_SUCCESS(errorCode).
+     * @return true if U_SUCCESS(errorCode).
      * @stable ICU 57
      */
     UBool applyPatternMinMaxArguments(const UnicodeString &pattern,
diff --git a/deps/icu-small/source/common/unicode/strenum.h b/deps/icu-small/source/common/unicode/strenum.h
index e813cd84b3413a70b83f6766f8d061287b077c1d..5d1600156e32e9155e167da9f9e2e1983112852e 100644
--- a/deps/icu-small/source/common/unicode/strenum.h
+++ b/deps/icu-small/source/common/unicode/strenum.h
@@ -196,7 +196,7 @@ public:
      * Compares this enumeration to other to check if both are equal
      *
      * @param that The other string enumeration to compare this object to
-     * @return TRUE if the enumerations are equal. FALSE if not.
+     * @return true if the enumerations are equal. false if not.
      * @stable ICU 3.6
      */
     virtual UBool operator==(const StringEnumeration& that)const;
@@ -204,7 +204,7 @@ public:
      * Compares this enumeration to other to check if both are not equal
      *
      * @param that The other string enumeration to compare this object to
-     * @return TRUE if the enumerations are equal. FALSE if not.
+     * @return true if the enumerations are equal. false if not.
      * @stable ICU 3.6
      */
     virtual UBool operator!=(const StringEnumeration& that)const;
diff --git a/deps/icu-small/source/common/unicode/stringpiece.h b/deps/icu-small/source/common/unicode/stringpiece.h
index 19fbe2e22eb032c3a1699ad3f5e1c0852ba09c5d..c145915fa953b93ccf680174172d37fc28d872dd 100644
--- a/deps/icu-small/source/common/unicode/stringpiece.h
+++ b/deps/icu-small/source/common/unicode/stringpiece.h
@@ -75,12 +75,11 @@ class U_COMMON_API StringPiece : public UMemory {
    * @stable ICU 4.2
    */
   StringPiece(const char* str);
-#ifndef U_HIDE_DRAFT_API
 #if defined(__cpp_char8_t) || defined(U_IN_DOXYGEN)
   /**
    * Constructs from a NUL-terminated const char8_t * pointer.
    * @param str a NUL-terminated const char8_t * pointer
-   * @draft ICU 67
+   * @stable ICU 67
    */
   StringPiece(const char8_t* str) : StringPiece(reinterpret_cast<const char*>(str)) {}
 #endif
@@ -88,10 +87,9 @@ class U_COMMON_API StringPiece : public UMemory {
    * Constructs an empty StringPiece.
    * Needed for type disambiguation from multiple other overloads.
    * @param p nullptr
-   * @draft ICU 67
+   * @stable ICU 67
    */
   StringPiece(std::nullptr_t p) : ptr_(p), length_(0) {}
-#endif  // U_HIDE_DRAFT_API
 
   /**
    * Constructs from a std::string.
@@ -99,19 +97,16 @@ class U_COMMON_API StringPiece : public UMemory {
    */
   StringPiece(const std::string& str)
     : ptr_(str.data()), length_(static_cast<int32_t>(str.size())) { }
-#ifndef U_HIDE_DRAFT_API
 #if defined(__cpp_lib_char8_t) || defined(U_IN_DOXYGEN)
   /**
    * Constructs from a std::u8string.
-   * @draft ICU 67
+   * @stable ICU 67
    */
   StringPiece(const std::u8string& str)
     : ptr_(reinterpret_cast<const char*>(str.data())),
       length_(static_cast<int32_t>(str.size())) { }
 #endif
-#endif  // U_HIDE_DRAFT_API
 
-#ifndef U_HIDE_DRAFT_API
   /**
    * Constructs from some other implementation of a string piece class, from any
    * C++ record type that has these two methods:
@@ -132,7 +127,7 @@ class U_COMMON_API StringPiece : public UMemory {
    * as from std::u8string_view.
    *
    * @param str the other string piece
-   * @draft ICU 65
+   * @stable ICU 65
    */
   template <typename T,
             typename = typename std::enable_if<
@@ -145,7 +140,6 @@ class U_COMMON_API StringPiece : public UMemory {
   StringPiece(T str)
       : ptr_(reinterpret_cast<const char*>(str.data())),
         length_(static_cast<int32_t>(str.size())) {}
-#endif  // U_HIDE_DRAFT_API
 
   /**
    * Constructs from a const char * pointer and a specified length.
@@ -154,18 +148,16 @@ class U_COMMON_API StringPiece : public UMemory {
    * @stable ICU 4.2
    */
   StringPiece(const char* offset, int32_t len) : ptr_(offset), length_(len) { }
-#ifndef U_HIDE_DRAFT_API
 #if defined(__cpp_char8_t) || defined(U_IN_DOXYGEN)
   /**
    * Constructs from a const char8_t * pointer and a specified length.
    * @param str a const char8_t * pointer (need not be terminated)
    * @param len the length of the string; must be non-negative
-   * @draft ICU 67
+   * @stable ICU 67
    */
   StringPiece(const char8_t* str, int32_t len) :
       StringPiece(reinterpret_cast<const char*>(str), len) {}
 #endif
-#endif  // U_HIDE_DRAFT_API
 
   /**
    * Substring of another StringPiece.
@@ -209,7 +201,7 @@ class U_COMMON_API StringPiece : public UMemory {
   int32_t length() const { return length_; }
   /**
    * Returns whether the string is empty.
-   * @return TRUE if the string is empty
+   * @return true if the string is empty
    * @stable ICU 4.2
    */
   UBool empty() const { return length_ == 0; }
@@ -235,13 +227,12 @@ class U_COMMON_API StringPiece : public UMemory {
    */
   void set(const char* str);
 
-#ifndef U_HIDE_DRAFT_API
 #if defined(__cpp_char8_t) || defined(U_IN_DOXYGEN)
   /**
    * Resets the stringpiece to refer to new data.
    * @param xdata pointer the new string data. Need not be NUL-terminated.
    * @param len the length of the new data
-   * @draft ICU 67
+   * @stable ICU 67
    */
   inline void set(const char8_t* xdata, int32_t len) {
       set(reinterpret_cast<const char*>(xdata), len);
@@ -250,13 +241,12 @@ class U_COMMON_API StringPiece : public UMemory {
   /**
    * Resets the stringpiece to refer to new data.
    * @param str a pointer to a NUL-terminated string.
-   * @draft ICU 67
+   * @stable ICU 67
    */
   inline void set(const char8_t* str) {
       set(reinterpret_cast<const char*>(str));
   }
 #endif
-#endif  // U_HIDE_DRAFT_API
 
   /**
    * Removes the first n string units.
@@ -288,13 +278,12 @@ class U_COMMON_API StringPiece : public UMemory {
     }
   }
 
-#ifndef U_HIDE_DRAFT_API
   /**
    * Searches the StringPiece for the given search string (needle);
    * @param needle The string for which to search.
    * @param offset Where to start searching within this string (haystack).
    * @return The offset of needle in haystack, or -1 if not found.
-   * @draft ICU 67
+   * @stable ICU 67
    */
   int32_t find(StringPiece needle, int32_t offset);
 
@@ -303,10 +292,9 @@ class U_COMMON_API StringPiece : public UMemory {
    * similar to std::string::compare().
    * @param other The string to compare to.
    * @return below zero if this < other; above zero if this > other; 0 if this == other.
-   * @draft ICU 67
+   * @stable ICU 67
    */
   int32_t compare(StringPiece other);
-#endif  // U_HIDE_DRAFT_API
 
   /**
    * Maximum integer, used as a default value for substring methods.
@@ -331,7 +319,7 @@ class U_COMMON_API StringPiece : public UMemory {
  * Global operator == for StringPiece
  * @param x The first StringPiece to compare.
  * @param y The second StringPiece to compare.
- * @return TRUE if the string data is equal
+ * @return true if the string data is equal
  * @stable ICU 4.8
  */
 U_EXPORT UBool U_EXPORT2
@@ -341,7 +329,7 @@ operator==(const StringPiece& x, const StringPiece& y);
  * Global operator != for StringPiece
  * @param x The first StringPiece to compare.
  * @param y The second StringPiece to compare.
- * @return TRUE if the string data is not equal
+ * @return true if the string data is not equal
  * @stable ICU 4.8
  */
 inline UBool operator!=(const StringPiece& x, const StringPiece& y) {
diff --git a/deps/icu-small/source/common/unicode/stringtriebuilder.h b/deps/icu-small/source/common/unicode/stringtriebuilder.h
index 2860cbf5513b8e6d59640108674eb717e1f94ded..efd2d49206ca2d3a5ee80167b444a8f1b713bfa6 100644
--- a/deps/icu-small/source/common/unicode/stringtriebuilder.h
+++ b/deps/icu-small/source/common/unicode/stringtriebuilder.h
@@ -279,10 +279,10 @@ protected:
      */
     class ValueNode : public Node {
     public:
-        ValueNode(int32_t initialHash) : Node(initialHash), hasValue(FALSE), value(0) {}
+        ValueNode(int32_t initialHash) : Node(initialHash), hasValue(false), value(0) {}
         virtual UBool operator==(const Node &other) const;
         void setValue(int32_t v) {
-            hasValue=TRUE;
+            hasValue=true;
             value=v;
             hash=hash*37u+v;
         }
diff --git a/deps/icu-small/source/common/unicode/ubidi.h b/deps/icu-small/source/common/unicode/ubidi.h
index f4875c8801efd6c58963c266c9359f937a9ce9e5..63d0e45cb7f3c535eb37f2b46ab809ddba9aab09 100644
--- a/deps/icu-small/source/common/unicode/ubidi.h
+++ b/deps/icu-small/source/common/unicode/ubidi.h
@@ -21,7 +21,10 @@
 
 #include "unicode/utypes.h"
 #include "unicode/uchar.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  *\file
@@ -496,7 +499,7 @@ typedef struct UBiDi UBiDi;
  * @return An empty <code>UBiDi</code> object.
  * @stable ICU 2.0
  */
-U_STABLE UBiDi * U_EXPORT2
+U_CAPI UBiDi * U_EXPORT2
 ubidi_open(void);
 
 /**
@@ -533,7 +536,7 @@ ubidi_open(void);
  * @return An empty <code>UBiDi</code> object with preallocated memory.
  * @stable ICU 2.0
  */
-U_STABLE UBiDi * U_EXPORT2
+U_CAPI UBiDi * U_EXPORT2
 ubidi_openSized(int32_t maxLength, int32_t maxRunCount, UErrorCode *pErrorCode);
 
 /**
@@ -556,7 +559,7 @@ ubidi_openSized(int32_t maxLength, int32_t maxRunCount, UErrorCode *pErrorCode);
  * @see ubidi_setLine
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_close(UBiDi *pBiDi);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -594,7 +597,7 @@ U_NAMESPACE_END
  * this "inverse Bidi" and that the current implementation provides only an
  * approximation of "inverse Bidi".</p>
  *
- * <p>With <code>isInverse</code> set to <code>TRUE</code>,
+ * <p>With <code>isInverse</code> set to <code>true</code>,
  * this function changes the behavior of some of the subsequent functions
  * in a way that they can be used for the inverse Bidi algorithm.
  * Specifically, runs of text with numeric characters will be treated in a
@@ -607,12 +610,12 @@ U_NAMESPACE_END
  * the runs of the logically ordered output.</p>
  *
  * <p>Calling this function with argument <code>isInverse</code> set to
- * <code>TRUE</code> is equivalent to calling
+ * <code>true</code> is equivalent to calling
  * <code>ubidi_setReorderingMode</code> with argument
  * <code>reorderingMode</code>
  * set to <code>#UBIDI_REORDER_INVERSE_NUMBERS_AS_L</code>.<br>
  * Calling this function with argument <code>isInverse</code> set to
- * <code>FALSE</code> is equivalent to calling
+ * <code>false</code> is equivalent to calling
  * <code>ubidi_setReorderingMode</code> with argument
  * <code>reorderingMode</code>
  * set to <code>#UBIDI_REORDER_DEFAULT</code>.
@@ -626,18 +629,18 @@ U_NAMESPACE_END
  * @see ubidi_setReorderingMode
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_setInverse(UBiDi *pBiDi, UBool isInverse);
 
 /**
  * Is this Bidi object set to perform the inverse Bidi algorithm?
  * <p>Note: calling this function after setting the reordering mode with
- * <code>ubidi_setReorderingMode</code> will return <code>TRUE</code> if the
+ * <code>ubidi_setReorderingMode</code> will return <code>true</code> if the
  * reordering mode was set to <code>#UBIDI_REORDER_INVERSE_NUMBERS_AS_L</code>,
- * <code>FALSE</code> for all other values.</p>
+ * <code>false</code> for all other values.</p>
  *
  * @param pBiDi is a <code>UBiDi</code> object.
- * @return TRUE if the Bidi object is set to perform the inverse Bidi algorithm
+ * @return true if the Bidi object is set to perform the inverse Bidi algorithm
  * by handling numbers as L.
  *
  * @see ubidi_setInverse
@@ -645,7 +648,7 @@ ubidi_setInverse(UBiDi *pBiDi, UBool isInverse);
  * @stable ICU 2.0
  */
 
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ubidi_isInverse(UBiDi *pBiDi);
 
 /**
@@ -668,7 +671,7 @@ ubidi_isInverse(UBiDi *pBiDi);
  * @see ubidi_setPara
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_orderParagraphsLTR(UBiDi *pBiDi, UBool orderParagraphsLTR);
 
 /**
@@ -676,13 +679,13 @@ ubidi_orderParagraphsLTR(UBiDi *pBiDi, UBool orderParagraphsLTR);
  * successive paragraphs progress from left to right?
  *
  * @param pBiDi is a <code>UBiDi</code> object.
- * @return TRUE if the Bidi object is set to allocate level 0 to block
+ * @return true if the Bidi object is set to allocate level 0 to block
  *         separators.
  *
  * @see ubidi_orderParagraphsLTR
  * @stable ICU 3.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ubidi_isOrderParagraphsLTR(UBiDi *pBiDi);
 
 /**
@@ -714,7 +717,7 @@ typedef enum UBiDiReorderingMode {
       * @stable ICU 3.6 */
     UBIDI_REORDER_RUNS_ONLY,
     /** Visual to Logical algorithm which handles numbers like L
-      * (same algorithm as selected by <code>ubidi_setInverse(TRUE)</code>.
+      * (same algorithm as selected by <code>ubidi_setInverse(true)</code>.
       * @see ubidi_setInverse
       * @stable ICU 3.6 */
     UBIDI_REORDER_INVERSE_NUMBERS_AS_L,
@@ -833,7 +836,7 @@ typedef enum UBiDiReorderingMode {
  * reordered sequence (the option <code>#UBIDI_INSERT_LRM_FOR_NUMERIC</code> can
  * be used with function <code>ubidi_writeReordered</code> to this end. This
  * mode is equivalent to calling <code>ubidi_setInverse()</code> with
- * argument <code>isInverse</code> set to <code>TRUE</code>.</li>
+ * argument <code>isInverse</code> set to <code>true</code>.</li>
  *
  * <li>When the reordering mode is set to
  * <code>#UBIDI_REORDER_INVERSE_LIKE_DIRECT</code>, the "direct" Logical to Visual
@@ -886,7 +889,7 @@ typedef enum UBiDiReorderingMode {
  * @see ubidi_writeReordered
  * @stable ICU 3.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_setReorderingMode(UBiDi *pBiDi, UBiDiReorderingMode reorderingMode);
 
 /**
@@ -897,7 +900,7 @@ ubidi_setReorderingMode(UBiDi *pBiDi, UBiDiReorderingMode reorderingMode);
  * @see ubidi_setReorderingMode
  * @stable ICU 3.6
  */
-U_STABLE UBiDiReorderingMode U_EXPORT2
+U_CAPI UBiDiReorderingMode U_EXPORT2
 ubidi_getReorderingMode(UBiDi *pBiDi);
 
 /**
@@ -935,7 +938,7 @@ typedef enum UBiDiReorderingOption {
      *
      * <p>If this option is set in conjunction with reordering mode
      * <code>#UBIDI_REORDER_INVERSE_NUMBERS_AS_L</code> or with calling
-     * <code>ubidi_setInverse(TRUE)</code>, it implies
+     * <code>ubidi_setInverse(true)</code>, it implies
      * option <code>#UBIDI_INSERT_LRM_FOR_NUMERIC</code>
      * in calls to function <code>ubidi_writeReordered()</code>.</p>
      *
@@ -1016,7 +1019,7 @@ typedef enum UBiDiReorderingOption {
      *
      * <p>When the <code>UBIDI_OPTION_STREAMING</code> option is used,
      * it is recommended to call <code>ubidi_orderParagraphsLTR()</code> with
-     * argument <code>orderParagraphsLTR</code> set to <code>TRUE</code> before
+     * argument <code>orderParagraphsLTR</code> set to <code>true</code> before
      * calling <code>ubidi_setPara</code> so that later paragraphs may be
      * concatenated to previous paragraphs on the right.</p>
      *
@@ -1042,7 +1045,7 @@ typedef enum UBiDiReorderingOption {
  * @see ubidi_getReorderingOptions
  * @stable ICU 3.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_setReorderingOptions(UBiDi *pBiDi, uint32_t reorderingOptions);
 
 /**
@@ -1053,7 +1056,7 @@ ubidi_setReorderingOptions(UBiDi *pBiDi, uint32_t reorderingOptions);
  * @see ubidi_setReorderingOptions
  * @stable ICU 3.6
  */
-U_STABLE uint32_t U_EXPORT2
+U_CAPI uint32_t U_EXPORT2
 ubidi_getReorderingOptions(UBiDi *pBiDi);
 
 /**
@@ -1140,7 +1143,7 @@ ubidi_getReorderingOptions(UBiDi *pBiDi);
  * @see ubidi_setPara
  * @stable ICU 4.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_setContext(UBiDi *pBiDi,
                  const UChar *prologue, int32_t proLength,
                  const UChar *epilogue, int32_t epiLength,
@@ -1228,7 +1231,7 @@ ubidi_setContext(UBiDi *pBiDi,
  * @param pErrorCode must be a valid pointer to an error code value.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_setPara(UBiDi *pBiDi, const UChar *text, int32_t length,
               UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
               UErrorCode *pErrorCode);
@@ -1279,7 +1282,7 @@ ubidi_setPara(UBiDi *pBiDi, const UChar *text, int32_t length,
  * @see ubidi_getProcessedLength
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_setLine(const UBiDi *pParaBiDi,
               int32_t start, int32_t limit,
               UBiDi *pLineBiDi,
@@ -1300,7 +1303,7 @@ ubidi_setLine(const UBiDi *pParaBiDi,
  * @see UBiDiDirection
  * @stable ICU 2.0
  */
-U_STABLE UBiDiDirection U_EXPORT2
+U_CAPI UBiDiDirection U_EXPORT2
 ubidi_getDirection(const UBiDi *pBiDi);
 
 /**
@@ -1330,7 +1333,7 @@ ubidi_getDirection(const UBiDi *pBiDi);
  * @see UBiDiDirection
  * @stable ICU 4.6
  */
-U_STABLE UBiDiDirection U_EXPORT2
+U_CAPI UBiDiDirection U_EXPORT2
 ubidi_getBaseDirection(const UChar *text,  int32_t length );
 
 /**
@@ -1344,7 +1347,7 @@ ubidi_getBaseDirection(const UChar *text,  int32_t length );
  * @see ubidi_setLine
  * @stable ICU 2.0
  */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 ubidi_getText(const UBiDi *pBiDi);
 
 /**
@@ -1355,7 +1358,7 @@ ubidi_getText(const UBiDi *pBiDi);
  * @return The length of the text that the UBiDi object was created for.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_getLength(const UBiDi *pBiDi);
 
 /**
@@ -1373,7 +1376,7 @@ ubidi_getLength(const UBiDi *pBiDi);
  * @see ubidi_getParagraphByIndex
  * @stable ICU 2.0
  */
-U_STABLE UBiDiLevel U_EXPORT2
+U_CAPI UBiDiLevel U_EXPORT2
 ubidi_getParaLevel(const UBiDi *pBiDi);
 
 /**
@@ -1384,7 +1387,7 @@ ubidi_getParaLevel(const UBiDi *pBiDi);
  * @return The number of paragraphs.
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_countParagraphs(UBiDi *pBiDi);
 
 /**
@@ -1421,7 +1424,7 @@ ubidi_countParagraphs(UBiDi *pBiDi);
  * @see ubidi_getProcessedLength
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_getParagraph(const UBiDi *pBiDi, int32_t charIndex, int32_t *pParaStart,
                    int32_t *pParaLimit, UBiDiLevel *pParaLevel,
                    UErrorCode *pErrorCode);
@@ -1453,7 +1456,7 @@ ubidi_getParagraph(const UBiDi *pBiDi, int32_t charIndex, int32_t *pParaStart,
  *
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_getParagraphByIndex(const UBiDi *pBiDi, int32_t paraIndex,
                           int32_t *pParaStart, int32_t *pParaLimit,
                           UBiDiLevel *pParaLevel, UErrorCode *pErrorCode);
@@ -1473,7 +1476,7 @@ ubidi_getParagraphByIndex(const UBiDi *pBiDi, int32_t paraIndex,
  * @see ubidi_getProcessedLength
  * @stable ICU 2.0
  */
-U_STABLE UBiDiLevel U_EXPORT2
+U_CAPI UBiDiLevel U_EXPORT2
 ubidi_getLevelAt(const UBiDi *pBiDi, int32_t charIndex);
 
 /**
@@ -1494,7 +1497,7 @@ ubidi_getLevelAt(const UBiDi *pBiDi, int32_t charIndex);
  * @see ubidi_getProcessedLength
  * @stable ICU 2.0
  */
-U_STABLE const UBiDiLevel * U_EXPORT2
+U_CAPI const UBiDiLevel * U_EXPORT2
 ubidi_getLevels(UBiDi *pBiDi, UErrorCode *pErrorCode);
 
 /**
@@ -1521,7 +1524,7 @@ ubidi_getLevels(UBiDi *pBiDi, UErrorCode *pErrorCode);
  * @see ubidi_getProcessedLength
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_getLogicalRun(const UBiDi *pBiDi, int32_t logicalPosition,
                     int32_t *pLogicalLimit, UBiDiLevel *pLevel);
 
@@ -1540,7 +1543,7 @@ ubidi_getLogicalRun(const UBiDi *pBiDi, int32_t logicalPosition,
  * @return The number of runs.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_countRuns(UBiDi *pBiDi, UErrorCode *pErrorCode);
 
 /**
@@ -1599,7 +1602,7 @@ ubidi_countRuns(UBiDi *pBiDi, UErrorCode *pErrorCode);
  * to avoid these issues.
  * @stable ICU 2.0
  */
-U_STABLE UBiDiDirection U_EXPORT2
+U_CAPI UBiDiDirection U_EXPORT2
 ubidi_getVisualRun(UBiDi *pBiDi, int32_t runIndex,
                    int32_t *pLogicalStart, int32_t *pLength);
 
@@ -1640,7 +1643,7 @@ ubidi_getVisualRun(UBiDi *pBiDi, int32_t runIndex,
  * @see ubidi_getProcessedLength
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_getVisualIndex(UBiDi *pBiDi, int32_t logicalIndex, UErrorCode *pErrorCode);
 
 /**
@@ -1675,7 +1678,7 @@ ubidi_getVisualIndex(UBiDi *pBiDi, int32_t logicalIndex, UErrorCode *pErrorCode)
  * @see ubidi_getResultLength
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_getLogicalIndex(UBiDi *pBiDi, int32_t visualIndex, UErrorCode *pErrorCode);
 
 /**
@@ -1718,7 +1721,7 @@ ubidi_getLogicalIndex(UBiDi *pBiDi, int32_t visualIndex, UErrorCode *pErrorCode)
  * @see ubidi_getResultLength
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_getLogicalMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode);
 
 /**
@@ -1754,7 +1757,7 @@ ubidi_getLogicalMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode);
  * @see ubidi_getResultLength
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_getVisualMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode);
 
 /**
@@ -1777,7 +1780,7 @@ ubidi_getVisualMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode);
  *        The index map will result in <code>indexMap[logicalIndex]==visualIndex</code>.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_reorderLogical(const UBiDiLevel *levels, int32_t length, int32_t *indexMap);
 
 /**
@@ -1800,7 +1803,7 @@ ubidi_reorderLogical(const UBiDiLevel *levels, int32_t length, int32_t *indexMap
  *        The index map will result in <code>indexMap[visualIndex]==logicalIndex</code>.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_reorderVisual(const UBiDiLevel *levels, int32_t length, int32_t *indexMap);
 
 /**
@@ -1835,7 +1838,7 @@ ubidi_reorderVisual(const UBiDiLevel *levels, int32_t length, int32_t *indexMap)
  * @see UBIDI_MAP_NOWHERE
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_invertMap(const int32_t *srcMap, int32_t *destMap, int32_t length);
 
 /** option flags for ubidi_writeReordered() */
@@ -1940,7 +1943,7 @@ ubidi_invertMap(const int32_t *srcMap, int32_t *destMap, int32_t length);
  * @see UBIDI_OPTION_STREAMING
  * @stable ICU 3.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_getProcessedLength(const UBiDi *pBiDi);
 
 /**
@@ -1970,7 +1973,7 @@ ubidi_getProcessedLength(const UBiDi *pBiDi);
  * @see UBIDI_OPTION_REMOVE_CONTROLS
  * @stable ICU 3.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_getResultLength(const UBiDi *pBiDi);
 
 U_CDECL_BEGIN
@@ -2028,7 +2031,7 @@ U_CDECL_END
  * @see UBiDiClassCallback
  * @stable ICU 3.6
  */
-U_STABLE UCharDirection U_EXPORT2
+U_CAPI UCharDirection U_EXPORT2
 ubidi_getCustomizedClass(UBiDi *pBiDi, UChar32 c);
 
 /**
@@ -2058,7 +2061,7 @@ ubidi_getCustomizedClass(UBiDi *pBiDi, UChar32 c);
  * @see ubidi_getClassCallback
  * @stable ICU 3.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_setClassCallback(UBiDi *pBiDi, UBiDiClassCallback *newFn,
                        const void *newContext, UBiDiClassCallback **oldFn,
                        const void **oldContext, UErrorCode *pErrorCode);
@@ -2075,7 +2078,7 @@ ubidi_setClassCallback(UBiDi *pBiDi, UBiDiClassCallback *newFn,
  * @see ubidi_setClassCallback
  * @stable ICU 3.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubidi_getClassCallback(UBiDi *pBiDi, UBiDiClassCallback **fn, const void **context);
 
 /**
@@ -2143,7 +2146,7 @@ ubidi_getClassCallback(UBiDi *pBiDi, UBiDiClassCallback **fn, const void **conte
  * @see ubidi_getProcessedLength
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_writeReordered(UBiDi *pBiDi,
                      UChar *dest, int32_t destSize,
                      uint16_t options,
@@ -2195,7 +2198,7 @@ ubidi_writeReordered(UBiDi *pBiDi,
  * @return The length of the output string.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubidi_writeReverse(const UChar *src, int32_t srcLength,
                    UChar *dest, int32_t destSize,
                    uint16_t options,
diff --git a/deps/icu-small/source/common/unicode/ubiditransform.h b/deps/icu-small/source/common/unicode/ubiditransform.h
index 5c08ed5df0fd90bd0a571cced3e28551dfc93334..2dd7564010de17e5b773bf35bc6235a000d76b2d 100644
--- a/deps/icu-small/source/common/unicode/ubiditransform.h
+++ b/deps/icu-small/source/common/unicode/ubiditransform.h
@@ -21,7 +21,10 @@
 #include "unicode/utypes.h"
 #include "unicode/ubidi.h"
 #include "unicode/uchar.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -147,10 +150,10 @@ typedef struct UBiDiTransform UBiDiTransform;
  * calling <code>ubidi_setPara</code> with
  * <code>paraLevel == UBIDI_DEFAULT_RTL</code>,</li>
  * <li><Visual LTR, Logical LTR>: this is equivalent to
- * calling <code>ubidi_setInverse(UBiDi*, TRUE)</code> and then
+ * calling <code>ubidi_setInverse(UBiDi*, true)</code> and then
  * <code>ubidi_setPara</code> with <code>paraLevel == UBIDI_LTR</code>,</li>
  * <li><Visual LTR, Logical RTL>: this is equivalent to
- * calling <code>ubidi_setInverse(UBiDi*, TRUE)</code> and then
+ * calling <code>ubidi_setInverse(UBiDi*, true)</code> and then
  * <code>ubidi_setPara</code> with <code>paraLevel == UBIDI_RTL</code>.</li>
  * </ul>
  * All combinations that involve the Visual RTL scheme are unsupported by
@@ -245,7 +248,7 @@ typedef struct UBiDiTransform UBiDiTransform;
  * @see u_shapeArabic
  * @stable ICU 58
  */
-U_STABLE uint32_t U_EXPORT2
+U_CAPI uint32_t U_EXPORT2
 ubiditransform_transform(UBiDiTransform *pBiDiTransform,
             const UChar *src, int32_t srcLength,
             UChar *dest, int32_t destSize,
@@ -291,14 +294,14 @@ ubiditransform_transform(UBiDiTransform *pBiDiTransform,
  * @return An empty <code>UBiDiTransform</code> object.
  * @stable ICU 58
  */
-U_STABLE UBiDiTransform* U_EXPORT2
+U_CAPI UBiDiTransform* U_EXPORT2
 ubiditransform_open(UErrorCode *pErrorCode);
 
 /**
  * Deallocates the given <code>UBiDiTransform</code> object.
  * @stable ICU 58
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubiditransform_close(UBiDiTransform *pBidiTransform);
 
 #if U_SHOW_CPLUSPLUS_API
diff --git a/deps/icu-small/source/common/unicode/ubrk.h b/deps/icu-small/source/common/unicode/ubrk.h
index 73c1553b24395784a0249eb13fd867b6eaba88e5..1249b0b160d3625aeb97bfedebfd14dd69351021 100644
--- a/deps/icu-small/source/common/unicode/ubrk.h
+++ b/deps/icu-small/source/common/unicode/ubrk.h
@@ -13,7 +13,10 @@
 #include "unicode/utypes.h"
 #include "unicode/uloc.h"
 #include "unicode/utext.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * A text-break iterator.
@@ -238,7 +241,7 @@ typedef enum USentenceBreakTag {
  * @see ubrk_openRules
  * @stable ICU 2.0
  */
-U_STABLE UBreakIterator* U_EXPORT2
+U_CAPI UBreakIterator* U_EXPORT2
 ubrk_open(UBreakIteratorType type,
       const char *locale,
       const UChar *text,
@@ -260,7 +263,7 @@ ubrk_open(UBreakIteratorType type,
  * @see ubrk_open
  * @stable ICU 2.2
  */
-U_STABLE UBreakIterator* U_EXPORT2
+U_CAPI UBreakIterator* U_EXPORT2
 ubrk_openRules(const UChar     *rules,
                int32_t         rulesLength,
                const UChar     *text,
@@ -288,11 +291,13 @@ ubrk_openRules(const UChar     *rules,
  * @see ubrk_getBinaryRules
  * @stable ICU 59
  */
-U_STABLE UBreakIterator* U_EXPORT2
+U_CAPI UBreakIterator* U_EXPORT2
 ubrk_openBinaryRules(const uint8_t *binaryRules, int32_t rulesLength,
                      const UChar *  text, int32_t textLength,
                      UErrorCode *   status);
 
+#ifndef U_HIDE_DEPRECATED_API
+
 /**
  * Thread safe cloning operation
  * @param bi iterator to be cloned
@@ -309,15 +314,32 @@ ubrk_openBinaryRules(const uint8_t *binaryRules, int32_t rulesLength,
  * @param status to indicate whether the operation went on smoothly or there were errors
  *  An informational status value, U_SAFECLONE_ALLOCATED_ERROR, is used if any allocations were necessary.
  * @return pointer to the new clone
- * @stable ICU 2.0
+ * @deprecated ICU 69 Use ubrk_clone() instead.
  */
-U_STABLE UBreakIterator * U_EXPORT2
+U_CAPI UBreakIterator * U_EXPORT2
 ubrk_safeClone(
           const UBreakIterator *bi,
           void *stackBuffer,
           int32_t *pBufferSize,
           UErrorCode *status);
 
+#endif /* U_HIDE_DEPRECATED_API */
+
+#ifndef U_HIDE_DRAFT_API
+
+/**
+ * Thread safe cloning operation.
+ * @param bi iterator to be cloned
+ * @param status to indicate whether the operation went on smoothly or there were errors
+ * @return pointer to the new clone
+ * @draft ICU 69
+ */
+U_CAPI UBreakIterator * U_EXPORT2
+ubrk_clone(const UBreakIterator *bi,
+           UErrorCode *status);
+
+#endif  // U_HIDE_DRAFT_API
+
 #ifndef U_HIDE_DEPRECATED_API
 
 /**
@@ -334,7 +356,7 @@ ubrk_safeClone(
 * @param bi The break iterator to close.
  * @stable ICU 2.0
 */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubrk_close(UBreakIterator *bi);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -368,7 +390,7 @@ U_NAMESPACE_END
  * @param status The error code
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubrk_setText(UBreakIterator* bi,
              const UChar*    text,
              int32_t         textLength,
@@ -392,7 +414,7 @@ ubrk_setText(UBreakIterator* bi,
  * @param status The error code
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubrk_setUText(UBreakIterator* bi,
              UText*          text,
              UErrorCode*     status);
@@ -407,7 +429,7 @@ ubrk_setUText(UBreakIterator* bi,
  * \ref ubrk_first, or \ref ubrk_last.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_current(const UBreakIterator *bi);
 
 /**
@@ -419,7 +441,7 @@ ubrk_current(const UBreakIterator *bi);
  * @see ubrk_previous
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_next(UBreakIterator *bi);
 
 /**
@@ -431,7 +453,7 @@ ubrk_next(UBreakIterator *bi);
  * @see ubrk_next
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_previous(UBreakIterator *bi);
 
 /**
@@ -441,7 +463,7 @@ ubrk_previous(UBreakIterator *bi);
  * @see ubrk_last
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_first(UBreakIterator *bi);
 
 /**
@@ -453,7 +475,7 @@ ubrk_first(UBreakIterator *bi);
  * @see ubrk_first
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_last(UBreakIterator *bi);
 
 /**
@@ -465,7 +487,7 @@ ubrk_last(UBreakIterator *bi);
  * @see ubrk_following
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_preceding(UBreakIterator *bi,
            int32_t offset);
 
@@ -478,7 +500,7 @@ ubrk_preceding(UBreakIterator *bi,
  * @see ubrk_preceding
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_following(UBreakIterator *bi,
            int32_t offset);
 
@@ -491,7 +513,7 @@ ubrk_following(UBreakIterator *bi,
 * @see ubrk_countAvailable
 * @stable ICU 2.0
 */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 ubrk_getAvailable(int32_t index);
 
 /**
@@ -502,7 +524,7 @@ ubrk_getAvailable(int32_t index);
 * @see ubrk_getAvailable
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_countAvailable(void);
 
 
@@ -515,7 +537,7 @@ ubrk_countAvailable(void);
 * @return True if "offset" is a boundary position.
 * @stable ICU 2.0
 */
-U_STABLE  UBool U_EXPORT2
+U_CAPI  UBool U_EXPORT2
 ubrk_isBoundary(UBreakIterator *bi, int32_t offset);
 
 /**
@@ -527,7 +549,7 @@ ubrk_isBoundary(UBreakIterator *bi, int32_t offset);
  * For word break iterators, the possible values are defined in enum UWordBreak.
  * @stable ICU 2.2
  */
-U_STABLE  int32_t U_EXPORT2
+U_CAPI  int32_t U_EXPORT2
 ubrk_getRuleStatus(UBreakIterator *bi);
 
 /**
@@ -547,7 +569,7 @@ ubrk_getRuleStatus(UBreakIterator *bi);
  *                  the most recent boundary returned by the break iterator.
  * @stable ICU 3.0
  */
-U_STABLE  int32_t U_EXPORT2
+U_CAPI  int32_t U_EXPORT2
 ubrk_getRuleStatusVec(UBreakIterator *bi, int32_t *fillInVec, int32_t capacity, UErrorCode *status);
 
 /**
@@ -559,7 +581,7 @@ ubrk_getRuleStatusVec(UBreakIterator *bi, int32_t *fillInVec, int32_t capacity,
  * @return locale string
  * @stable ICU 2.8
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 ubrk_getLocaleByType(const UBreakIterator *bi, ULocDataLocaleType type, UErrorCode* status);
 
 /**
@@ -587,7 +609,7 @@ ubrk_getLocaleByType(const UBreakIterator *bi, ULocDataLocaleType type, UErrorCo
   *
   * @stable ICU 49
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ubrk_refreshUText(UBreakIterator *bi,
                        UText          *text,
                        UErrorCode     *status);
@@ -618,7 +640,7 @@ ubrk_refreshUText(UBreakIterator *bi,
  * @see ubrk_openBinaryRules
  * @stable ICU 59
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ubrk_getBinaryRules(UBreakIterator *bi,
                     uint8_t *       binaryRules, int32_t rulesCapacity,
                     UErrorCode *    status);
diff --git a/deps/icu-small/source/common/unicode/ucasemap.h b/deps/icu-small/source/common/unicode/ucasemap.h
index 6b253e3d638475e535179283467914f180a6a55d..d1c1b483ab337ec83bda8855775eee45d8e940ff 100644
--- a/deps/icu-small/source/common/unicode/ucasemap.h
+++ b/deps/icu-small/source/common/unicode/ucasemap.h
@@ -22,10 +22,13 @@
 #define __UCASEMAP_H__
 
 #include "unicode/utypes.h"
-#include "unicode/localpointer.h"
 #include "unicode/stringoptions.h"
 #include "unicode/ustring.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: Unicode case mapping functions using a UCaseMap service object.
@@ -69,7 +72,7 @@ typedef struct UCaseMap UCaseMap; /**< C typedef for struct UCaseMap. @stable IC
  * @see U_TITLECASE_NO_BREAK_ADJUSTMENT
  * @stable ICU 3.4
  */
-U_STABLE UCaseMap * U_EXPORT2
+U_CAPI UCaseMap * U_EXPORT2
 ucasemap_open(const char *locale, uint32_t options, UErrorCode *pErrorCode);
 
 /**
@@ -77,7 +80,7 @@ ucasemap_open(const char *locale, uint32_t options, UErrorCode *pErrorCode);
  * @param csm Object to be closed.
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucasemap_close(UCaseMap *csm);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -105,7 +108,7 @@ U_NAMESPACE_END
  * @return locale ID
  * @stable ICU 3.4
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucasemap_getLocale(const UCaseMap *csm);
 
 /**
@@ -114,7 +117,7 @@ ucasemap_getLocale(const UCaseMap *csm);
  * @return options bit set
  * @stable ICU 3.4
  */
-U_STABLE uint32_t U_EXPORT2
+U_CAPI uint32_t U_EXPORT2
 ucasemap_getOptions(const UCaseMap *csm);
 
 /**
@@ -128,7 +131,7 @@ ucasemap_getOptions(const UCaseMap *csm);
  * @see ucasemap_open
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucasemap_setLocale(UCaseMap *csm, const char *locale, UErrorCode *pErrorCode);
 
 /**
@@ -142,7 +145,7 @@ ucasemap_setLocale(UCaseMap *csm, const char *locale, UErrorCode *pErrorCode);
  * @see ucasemap_open
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucasemap_setOptions(UCaseMap *csm, uint32_t options, UErrorCode *pErrorCode);
 
 #if !UCONFIG_NO_BREAK_ITERATION
@@ -154,7 +157,7 @@ ucasemap_setOptions(UCaseMap *csm, uint32_t options, UErrorCode *pErrorCode);
  * @return titlecasing break iterator
  * @stable ICU 3.8
  */
-U_STABLE const UBreakIterator * U_EXPORT2
+U_CAPI const UBreakIterator * U_EXPORT2
 ucasemap_getBreakIterator(const UCaseMap *csm);
 
 /**
@@ -177,7 +180,7 @@ ucasemap_getBreakIterator(const UCaseMap *csm);
  * @see ucasemap_utf8ToTitle
  * @stable ICU 3.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucasemap_setBreakIterator(UCaseMap *csm, UBreakIterator *iterToAdopt, UErrorCode *pErrorCode);
 
 /**
@@ -226,7 +229,7 @@ ucasemap_setBreakIterator(UCaseMap *csm, UBreakIterator *iterToAdopt, UErrorCode
  * @see u_strToTitle
  * @stable ICU 3.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucasemap_toTitle(UCaseMap *csm,
                  UChar *dest, int32_t destCapacity,
                  const UChar *src, int32_t srcLength,
@@ -257,7 +260,7 @@ ucasemap_toTitle(UCaseMap *csm,
  * @see u_strToLower
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucasemap_utf8ToLower(const UCaseMap *csm,
                      char *dest, int32_t destCapacity,
                      const char *src, int32_t srcLength,
@@ -286,7 +289,7 @@ ucasemap_utf8ToLower(const UCaseMap *csm,
  * @see u_strToUpper
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucasemap_utf8ToUpper(const UCaseMap *csm,
                      char *dest, int32_t destCapacity,
                      const char *src, int32_t srcLength,
@@ -338,7 +341,7 @@ ucasemap_utf8ToUpper(const UCaseMap *csm,
  * @see U_TITLECASE_NO_BREAK_ADJUSTMENT
  * @stable ICU 3.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucasemap_utf8ToTitle(UCaseMap *csm,
                     char *dest, int32_t destCapacity,
                     const char *src, int32_t srcLength,
@@ -376,7 +379,7 @@ ucasemap_utf8ToTitle(UCaseMap *csm,
  * @see U_FOLD_CASE_EXCLUDE_SPECIAL_I
  * @stable ICU 3.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucasemap_utf8FoldCase(const UCaseMap *csm,
                       char *dest, int32_t destCapacity,
                       const char *src, int32_t srcLength,
diff --git a/deps/icu-small/source/common/unicode/ucat.h b/deps/icu-small/source/common/unicode/ucat.h
index f9c18b47d6c9b80c7cd7a70a496ed5d0e014275f..a177639a76bfcb51163eeb90c5f2ba0486b07b4e 100644
--- a/deps/icu-small/source/common/unicode/ucat.h
+++ b/deps/icu-small/source/common/unicode/ucat.h
@@ -103,7 +103,7 @@ typedef UResourceBundle* u_nl_catd;
  *
  * @stable ICU 2.6
  */
-U_STABLE u_nl_catd U_EXPORT2
+U_CAPI u_nl_catd U_EXPORT2
 u_catopen(const char* name, const char* locale, UErrorCode* ec);
 
 /**
@@ -114,7 +114,7 @@ u_catopen(const char* name, const char* locale, UErrorCode* ec);
  *
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_catclose(u_nl_catd catd);
 
 /**
@@ -149,7 +149,7 @@ u_catclose(u_nl_catd catd);
  *
  * @stable ICU 2.6
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 u_catgets(u_nl_catd catd, int32_t set_num, int32_t msg_num,
           const UChar* s,
           int32_t* len, UErrorCode* ec);
diff --git a/deps/icu-small/source/common/unicode/uchar.h b/deps/icu-small/source/common/unicode/uchar.h
index 3b55b2326dfc1f83ef95644baa1d4f659b951839..1e0f82e706c482f231e14151052584d8c1009f28 100644
--- a/deps/icu-small/source/common/unicode/uchar.h
+++ b/deps/icu-small/source/common/unicode/uchar.h
@@ -80,7 +80,7 @@ U_CDECL_BEGIN
  * and the ICU User Guide chapter on Properties (http://icu-project.org/userguide/properties.html).
  *
  * Many properties are accessible via generic functions that take a UProperty selector.
- * - u_hasBinaryProperty() returns a binary value (TRUE/FALSE) per property and code point.
+ * - u_hasBinaryProperty() returns a binary value (true/false) per property and code point.
  * - u_getIntPropertyValue() returns an integer value per property and code point.
  *   For each supported enumerated or catalog property, there is
  *   an enum type for all of the property's values, and
@@ -2586,8 +2586,8 @@ typedef enum UVerticalOrientation {
  * @param c Code point to test.
  * @param which UProperty selector constant, identifies which binary property to check.
  *        Must be UCHAR_BINARY_START<=which<UCHAR_BINARY_LIMIT.
- * @return TRUE or FALSE according to the binary Unicode property value for c.
- *         Also FALSE if 'which' is out of bounds or if the Unicode version
+ * @return true or false according to the binary Unicode property value for c.
+ *         Also false if 'which' is out of bounds or if the Unicode version
  *         does not have data for the property at all, or not for this code point.
  *
  * @see UProperty
@@ -2596,7 +2596,7 @@ typedef enum UVerticalOrientation {
  * @see u_getUnicodeVersion
  * @stable ICU 2.1
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_hasBinaryProperty(UChar32 c, UProperty which);
 
 /**
@@ -2629,7 +2629,7 @@ u_getBinaryPropertySet(UProperty property, UErrorCode *pErrorCode);
  * @see u_hasBinaryProperty
  * @stable ICU 2.1
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isUAlphabetic(UChar32 c);
 
 /**
@@ -2644,7 +2644,7 @@ u_isUAlphabetic(UChar32 c);
  * @see u_hasBinaryProperty
  * @stable ICU 2.1
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isULowercase(UChar32 c);
 
 /**
@@ -2659,7 +2659,7 @@ u_isULowercase(UChar32 c);
  * @see u_hasBinaryProperty
  * @stable ICU 2.1
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isUUppercase(UChar32 c);
 
 /**
@@ -2680,7 +2680,7 @@ u_isUUppercase(UChar32 c);
  * @see u_hasBinaryProperty
  * @stable ICU 2.1
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isUWhiteSpace(UChar32 c);
 
 /**
@@ -2708,7 +2708,7 @@ u_isUWhiteSpace(UChar32 c);
  *         for enumerated properties, corresponds to the numeric value of the enumerated
  *         constant of the respective property value enumeration type
  *         (cast to enum type if necessary).
- *         Returns 0 or 1 (for FALSE/TRUE) for binary Unicode properties.
+ *         Returns 0 or 1 (for false/true) for binary Unicode properties.
  *         Returns a bit-mask for mask properties.
  *         Returns 0 if 'which' is out of bounds or if the Unicode version
  *         does not have data for the property at all, or not for this code point.
@@ -2721,7 +2721,7 @@ u_isUWhiteSpace(UChar32 c);
  * @see u_getUnicodeVersion
  * @stable ICU 2.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_getIntPropertyValue(UChar32 c, UProperty which);
 
 /**
@@ -2742,7 +2742,7 @@ u_getIntPropertyValue(UChar32 c, UProperty which);
  * @see u_getIntPropertyValue
  * @stable ICU 2.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_getIntPropertyMinValue(UProperty which);
 
 /**
@@ -2754,7 +2754,7 @@ u_getIntPropertyMinValue(UProperty which);
  *
  * - UCHAR_BIDI_CLASS:    0/18 (U_LEFT_TO_RIGHT/U_BOUNDARY_NEUTRAL)
  * - UCHAR_SCRIPT:        0/45 (USCRIPT_COMMON/USCRIPT_TAGBANWA)
- * - UCHAR_IDEOGRAPHIC:   0/1  (FALSE/TRUE)
+ * - UCHAR_IDEOGRAPHIC:   0/1  (false/true)
  *
  * For undefined UProperty constant values, min/max values will be 0/-1.
  *
@@ -2771,7 +2771,7 @@ u_getIntPropertyMinValue(UProperty which);
  * @see u_getIntPropertyValue
  * @stable ICU 2.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_getIntPropertyMaxValue(UProperty which);
 
 /**
@@ -2814,7 +2814,7 @@ u_getIntPropertyMap(UProperty property, UErrorCode *pErrorCode);
  * @see U_NO_NUMERIC_VALUE
  * @stable ICU 2.2
  */
-U_STABLE double U_EXPORT2
+U_CAPI double U_EXPORT2
 u_getNumericValue(UChar32 c);
 
 /**
@@ -2842,14 +2842,14 @@ u_getNumericValue(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is an Ll lowercase letter
+ * @return true if the code point is an Ll lowercase letter
  *
  * @see UCHAR_LOWERCASE
  * @see u_isupper
  * @see u_istitle
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_islower(UChar32 c);
 
 /**
@@ -2868,7 +2868,7 @@ u_islower(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is an Lu uppercase letter
+ * @return true if the code point is an Lu uppercase letter
  *
  * @see UCHAR_UPPERCASE
  * @see u_islower
@@ -2876,7 +2876,7 @@ u_islower(UChar32 c);
  * @see u_tolower
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isupper(UChar32 c);
 
 /**
@@ -2886,14 +2886,14 @@ u_isupper(UChar32 c);
  * Same as java.lang.Character.isTitleCase().
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is an Lt titlecase letter
+ * @return true if the code point is an Lt titlecase letter
  *
  * @see u_isupper
  * @see u_islower
  * @see u_totitle
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_istitle(UChar32 c);
 
 /**
@@ -2910,11 +2910,11 @@ u_istitle(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a digit character according to Character.isDigit()
+ * @return true if the code point is a digit character according to Character.isDigit()
  *
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isdigit(UChar32 c);
 
 /**
@@ -2929,13 +2929,13 @@ u_isdigit(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a letter character
+ * @return true if the code point is a letter character
  *
  * @see u_isdigit
  * @see u_isalnum
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isalpha(UChar32 c);
 
 /**
@@ -2952,11 +2952,11 @@ u_isalpha(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is an alphanumeric character according to Character.isLetterOrDigit()
+ * @return true if the code point is an alphanumeric character according to Character.isLetterOrDigit()
  *
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isalnum(UChar32 c);
 
 /**
@@ -2975,11 +2975,11 @@ u_isalnum(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a hexadecimal digit
+ * @return true if the code point is a hexadecimal digit
  *
  * @stable ICU 2.6
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isxdigit(UChar32 c);
 
 /**
@@ -2991,17 +2991,17 @@ u_isxdigit(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a punctuation character
+ * @return true if the code point is a punctuation character
  *
  * @stable ICU 2.6
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_ispunct(UChar32 c);
 
 /**
  * Determines whether the specified code point is a "graphic" character
  * (printable, excluding spaces).
- * TRUE for all characters except those with general categories
+ * true for all characters except those with general categories
  * "Cc" (control codes), "Cf" (format controls), "Cs" (surrogates),
  * "Cn" (unassigned), and "Z" (separators).
  *
@@ -3010,11 +3010,11 @@ u_ispunct(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a "graphic" character
+ * @return true if the code point is a "graphic" character
  *
  * @stable ICU 2.6
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isgraph(UChar32 c);
 
 /**
@@ -3022,13 +3022,13 @@ u_isgraph(UChar32 c);
  * a character that visibly separates words on a line.
  * The following are equivalent definitions:
  *
- * TRUE for Unicode White_Space characters except for "vertical space controls"
+ * true for Unicode White_Space characters except for "vertical space controls"
  * where "vertical space controls" are the following characters:
  * U+000A (LF) U+000B (VT) U+000C (FF) U+000D (CR) U+0085 (NEL) U+2028 (LS) U+2029 (PS)
  *
  * same as
  *
- * TRUE for U+0009 (TAB) and characters with general category "Zs" (space separators).
+ * true for U+0009 (TAB) and characters with general category "Zs" (space separators).
  *
  * Note: There are several ICU whitespace functions; please see the uchar.h
  * file documentation for a detailed comparison.
@@ -3038,11 +3038,11 @@ u_isgraph(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a "blank"
+ * @return true if the code point is a "blank"
  *
  * @stable ICU 2.6
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isblank(UChar32 c);
 
 /**
@@ -3057,7 +3057,7 @@ u_isblank(UChar32 c);
  * Same as java.lang.Character.isDefined().
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is assigned a character
+ * @return true if the code point is assigned a character
  *
  * @see u_isdigit
  * @see u_isalpha
@@ -3067,7 +3067,7 @@ u_isblank(UChar32 c);
  * @see u_istitle
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isdefined(UChar32 c);
 
 /**
@@ -3088,7 +3088,7 @@ u_isdefined(UChar32 c);
  * @see u_isUWhiteSpace
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isspace(UChar32 c);
 
 /**
@@ -3102,14 +3102,14 @@ u_isspace(UChar32 c);
  * file documentation for a detailed comparison.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a space character according to Character.isSpaceChar()
+ * @return true if the code point is a space character according to Character.isSpaceChar()
  *
  * @see u_isspace
  * @see u_isWhitespace
  * @see u_isUWhiteSpace
  * @stable ICU 2.6
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isJavaSpaceChar(UChar32 c);
 
 /**
@@ -3142,14 +3142,14 @@ u_isJavaSpaceChar(UChar32 c);
  * file documentation for a detailed comparison.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a whitespace character according to Java/ICU
+ * @return true if the code point is a whitespace character according to Java/ICU
  *
  * @see u_isspace
  * @see u_isJavaSpaceChar
  * @see u_isUWhiteSpace
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isWhitespace(UChar32 c);
 
 /**
@@ -3167,13 +3167,13 @@ u_isWhitespace(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a control character
+ * @return true if the code point is a control character
  *
  * @see UCHAR_DEFAULT_IGNORABLE_CODE_POINT
  * @see u_isprint
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_iscntrl(UChar32 c);
 
 /**
@@ -3183,12 +3183,12 @@ u_iscntrl(UChar32 c);
  * Same as java.lang.Character.isISOControl().
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is an ISO control code
+ * @return true if the code point is an ISO control code
  *
  * @see u_iscntrl
  * @stable ICU 2.6
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isISOControl(UChar32 c);
 
 /**
@@ -3200,13 +3200,13 @@ u_isISOControl(UChar32 c);
  * documentation at the top of this header file.
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a printable character
+ * @return true if the code point is a printable character
  *
  * @see UCHAR_DEFAULT_IGNORABLE_CODE_POINT
  * @see u_iscntrl
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isprint(UChar32 c);
 
 /**
@@ -3220,13 +3220,13 @@ u_isprint(UChar32 c);
  * Letter (L), Number (N), Punctuation (P), Symbol (S), or Space Separator (Zs).
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is a base character according to this function
+ * @return true if the code point is a base character according to this function
  *
  * @see u_isalpha
  * @see u_isdigit
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isbase(UChar32 c);
 
 /**
@@ -3245,7 +3245,7 @@ u_isbase(UChar32 c);
  * @see UCharDirection
  * @stable ICU 2.0
  */
-U_STABLE UCharDirection U_EXPORT2
+U_CAPI UCharDirection U_EXPORT2
 u_charDirection(UChar32 c);
 
 /**
@@ -3258,12 +3258,12 @@ u_charDirection(UChar32 c);
  * Same as UCHAR_BIDI_MIRRORED
  *
  * @param c the code point to be tested
- * @return TRUE if the character has the Bidi_Mirrored property
+ * @return true if the character has the Bidi_Mirrored property
  *
  * @see UCHAR_BIDI_MIRRORED
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isMirrored(UChar32 c);
 
 /**
@@ -3285,7 +3285,7 @@ u_isMirrored(UChar32 c);
  * @see u_isMirrored
  * @stable ICU 2.0
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_charMirror(UChar32 c);
 
 /**
@@ -3304,7 +3304,7 @@ u_charMirror(UChar32 c);
  * @see u_charMirror
  * @stable ICU 52
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_getBidiPairedBracket(UChar32 c);
 
 /**
@@ -3318,7 +3318,7 @@ u_getBidiPairedBracket(UChar32 c);
  * @see UCharCategory
  * @stable ICU 2.0
  */
-U_STABLE int8_t U_EXPORT2
+U_CAPI int8_t U_EXPORT2
 u_charType(UChar32 c);
 
 /**
@@ -3341,13 +3341,13 @@ u_charType(UChar32 c);
  * of code points c (where start<=c<limit)
  * with the same Unicode general category ("character type").
  *
- * The callback function can stop the enumeration by returning FALSE.
+ * The callback function can stop the enumeration by returning false.
  *
  * @param context an opaque pointer, as passed into utrie_enum()
  * @param start the first code point in a contiguous range with value
  * @param limit one past the last code point in a contiguous range with value
  * @param type the general category for all code points in [start..limit[
- * @return FALSE to stop the enumeration
+ * @return false to stop the enumeration
  *
  * @stable ICU 2.1
  * @see UCharCategory
@@ -3375,7 +3375,7 @@ UCharEnumTypeRange(const void *context, UChar32 start, UChar32 limit, UCharCateg
  * @see UCharCategory
  * @see UCharEnumTypeRange
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_enumCharTypes(UCharEnumTypeRange *enumRange, const void *context);
 
 #if !UCONFIG_NO_NORMALIZATION
@@ -3387,7 +3387,7 @@ u_enumCharTypes(UCharEnumTypeRange *enumRange, const void *context);
  * @return the combining class of the character
  * @stable ICU 2.0
  */
-U_STABLE uint8_t U_EXPORT2
+U_CAPI uint8_t U_EXPORT2
 u_getCombiningClass(UChar32 c);
 
 #endif
@@ -3415,7 +3415,7 @@ u_getCombiningClass(UChar32 c);
  * @see u_getNumericValue
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_charDigitValue(UChar32 c);
 
 /**
@@ -3427,7 +3427,7 @@ u_charDigitValue(UChar32 c);
  * @see UBlockCode
  * @stable ICU 2.0
  */
-U_STABLE UBlockCode U_EXPORT2
+U_CAPI UBlockCode U_EXPORT2
 ublock_getCode(UChar32 c);
 
 /**
@@ -3462,7 +3462,7 @@ ublock_getCode(UChar32 c);
  * @see u_enumCharNames
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_charName(UChar32 code, UCharNameChoice nameChoice,
            char *buffer, int32_t bufferLength,
            UErrorCode *pErrorCode);
@@ -3512,7 +3512,7 @@ u_getISOComment(UChar32 c,
  * @see u_enumCharNames
  * @stable ICU 1.7
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_charFromName(UCharNameChoice nameChoice,
                const char *name,
                UErrorCode *pErrorCode);
@@ -3521,14 +3521,14 @@ u_charFromName(UCharNameChoice nameChoice,
  * Type of a callback function for u_enumCharNames() that gets called
  * for each Unicode character with the code point value and
  * the character name.
- * If such a function returns FALSE, then the enumeration is stopped.
+ * If such a function returns false, then the enumeration is stopped.
  *
  * @param context The context pointer that was passed to u_enumCharNames().
  * @param code The Unicode code point for the character with this name.
  * @param nameChoice Selector for which kind of names is enumerated.
  * @param name The character's name, zero-terminated.
  * @param length The length of the name.
- * @return TRUE if the enumeration should continue, FALSE to stop it.
+ * @return true if the enumeration should continue, false to stop it.
  *
  * @see UCharNameChoice
  * @see u_enumCharNames
@@ -3561,7 +3561,7 @@ typedef UBool U_CALLCONV UEnumCharNamesFn(void *context,
  * @see u_charFromName
  * @stable ICU 1.7
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_enumCharNames(UChar32 start, UChar32 limit,
                 UEnumCharNamesFn *fn,
                 void *context,
@@ -3599,7 +3599,7 @@ u_enumCharNames(UChar32 start, UChar32 limit,
  * @see UPropertyNameChoice
  * @stable ICU 2.4
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 u_getPropertyName(UProperty property,
                   UPropertyNameChoice nameChoice);
 
@@ -3622,7 +3622,7 @@ u_getPropertyName(UProperty property,
  * @see UProperty
  * @stable ICU 2.4
  */
-U_STABLE UProperty U_EXPORT2
+U_CAPI UProperty U_EXPORT2
 u_getPropertyEnum(const char* alias);
 
 /**
@@ -3672,7 +3672,7 @@ u_getPropertyEnum(const char* alias);
  * @see UPropertyNameChoice
  * @stable ICU 2.4
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 u_getPropertyValueName(UProperty property,
                        int32_t value,
                        UPropertyNameChoice nameChoice);
@@ -3708,7 +3708,7 @@ u_getPropertyValueName(UProperty property,
  * @see UProperty
  * @stable ICU 2.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_getPropertyValueEnum(UProperty property,
                        const char* alias);
 
@@ -3722,14 +3722,14 @@ u_getPropertyValueEnum(UProperty property,
  * Same as UCHAR_ID_START
  *
  * @param c the code point to be tested
- * @return TRUE if the code point may start an identifier
+ * @return true if the code point may start an identifier
  *
  * @see UCHAR_ID_START
  * @see u_isalpha
  * @see u_isIDPart
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isIDStart(UChar32 c);
 
 /**
@@ -3746,14 +3746,14 @@ u_isIDStart(UChar32 c);
  * u_isIDIgnorable(c).
  *
  * @param c the code point to be tested
- * @return TRUE if the code point may occur in an identifier according to Java
+ * @return true if the code point may occur in an identifier according to Java
  *
  * @see UCHAR_ID_CONTINUE
  * @see u_isIDStart
  * @see u_isIDIgnorable
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isIDPart(UChar32 c);
 
 /**
@@ -3769,14 +3769,14 @@ u_isIDPart(UChar32 c);
  * Note that Unicode just recommends to ignore Cf (format controls).
  *
  * @param c the code point to be tested
- * @return TRUE if the code point is ignorable in identifiers according to Java
+ * @return true if the code point is ignorable in identifiers according to Java
  *
  * @see UCHAR_DEFAULT_IGNORABLE_CODE_POINT
  * @see u_isIDStart
  * @see u_isIDPart
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isIDIgnorable(UChar32 c);
 
 /**
@@ -3788,14 +3788,14 @@ u_isIDIgnorable(UChar32 c);
  * Same as java.lang.Character.isJavaIdentifierStart().
  *
  * @param c the code point to be tested
- * @return TRUE if the code point may start a Java identifier
+ * @return true if the code point may start a Java identifier
  *
  * @see     u_isJavaIDPart
  * @see     u_isalpha
  * @see     u_isIDStart
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isJavaIDStart(UChar32 c);
 
 /**
@@ -3807,7 +3807,7 @@ u_isJavaIDStart(UChar32 c);
  * Same as java.lang.Character.isJavaIdentifierPart().
  *
  * @param c the code point to be tested
- * @return TRUE if the code point may occur in a Java identifier
+ * @return true if the code point may occur in a Java identifier
  *
  * @see     u_isIDIgnorable
  * @see     u_isJavaIDStart
@@ -3816,7 +3816,7 @@ u_isJavaIDStart(UChar32 c);
  * @see     u_isIDPart
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_isJavaIDPart(UChar32 c);
 
 /**
@@ -3841,7 +3841,7 @@ u_isJavaIDPart(UChar32 c);
  *         otherwise the code point itself.
  * @stable ICU 2.0
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_tolower(UChar32 c);
 
 /**
@@ -3866,7 +3866,7 @@ u_tolower(UChar32 c);
  *         otherwise the code point itself.
  * @stable ICU 2.0
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_toupper(UChar32 c);
 
 /**
@@ -3891,7 +3891,7 @@ u_toupper(UChar32 c);
  *         otherwise the code point itself.
  * @stable ICU 2.0
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_totitle(UChar32 c);
 
 /**
@@ -3916,7 +3916,7 @@ u_totitle(UChar32 c);
  *         otherwise the code point itself.
  * @stable ICU 2.0
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_foldCase(UChar32 c, uint32_t options);
 
 /**
@@ -3957,7 +3957,7 @@ u_foldCase(UChar32 c, uint32_t options);
  * @see     u_isdigit
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_digit(UChar32 ch, int8_t radix);
 
 /**
@@ -3988,7 +3988,7 @@ u_digit(UChar32 ch, int8_t radix);
  * @see     u_isdigit
  * @stable ICU 2.0
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_forDigit(int32_t digit, int8_t radix);
 
 /**
@@ -4005,7 +4005,7 @@ u_forDigit(int32_t digit, int8_t radix);
  *
  * @stable ICU 2.1
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_charAge(UChar32 c, UVersionInfo versionArray);
 
 /**
@@ -4019,7 +4019,7 @@ u_charAge(UChar32 c, UVersionInfo versionArray);
  *                     the Unicode version number
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_getUnicodeVersion(UVersionInfo versionArray);
 
 #if !UCONFIG_NO_NORMALIZATION
@@ -4044,7 +4044,7 @@ u_getUnicodeVersion(UVersionInfo versionArray);
  *
  * @stable ICU 2.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_getFC_NFKC_Closure(UChar32 c, UChar *dest, int32_t destCapacity, UErrorCode *pErrorCode);
 
 #endif
diff --git a/deps/icu-small/source/common/unicode/ucharstrie.h b/deps/icu-small/source/common/unicode/ucharstrie.h
index d5729d944ee3a2a79deda051aa9bf9eb21d60425..b6f9e3e075c8face0f2c6d0377ae0b32cd593db7 100644
--- a/deps/icu-small/source/common/unicode/ucharstrie.h
+++ b/deps/icu-small/source/common/unicode/ucharstrie.h
@@ -97,14 +97,13 @@ public:
         return *this;
     }
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns the state of this trie as a 64-bit integer.
      * The state value is never 0.
      *
      * @return opaque state value
      * @see resetToState64
-     * @draft ICU 65
+     * @stable ICU 65
      */
     uint64_t getState64() const {
         return (static_cast<uint64_t>(remainingMatchLength_ + 2) << kState64RemainingShift) |
@@ -123,14 +122,13 @@ public:
      * @see getState64
      * @see resetToState
      * @see reset
-     * @draft ICU 65
+     * @stable ICU 65
      */
     UCharsTrie &resetToState64(uint64_t state) {
         remainingMatchLength_ = static_cast<int32_t>(state >> kState64RemainingShift) - 2;
         pos_ = uchars_ + (state & kState64PosMask);
         return *this;
     }
-#endif  /* U_HIDE_DRAFT_API */
 
     /**
      * UCharsTrie state object, for saving a trie's current state
@@ -268,16 +266,16 @@ public:
     /**
      * Determines whether all strings reachable from the current state
      * map to the same value.
-     * @param uniqueValue Receives the unique value, if this function returns TRUE.
+     * @param uniqueValue Receives the unique value, if this function returns true.
      *                    (output-only)
-     * @return TRUE if all strings reachable from the current state
+     * @return true if all strings reachable from the current state
      *         map to the same value.
      * @stable ICU 4.8
      */
     inline UBool hasUniqueValue(int32_t &uniqueValue) const {
         const char16_t *pos=pos_;
         // Skip the rest of a pending linear-match node.
-        return pos!=NULL && findUniqueValue(pos+remainingMatchLength_+1, FALSE, uniqueValue);
+        return pos!=NULL && findUniqueValue(pos+remainingMatchLength_+1, false, uniqueValue);
     }
 
     /**
@@ -335,7 +333,7 @@ public:
         Iterator &reset();
 
         /**
-         * @return TRUE if there are more elements.
+         * @return true if there are more elements.
          * @stable ICU 4.8
          */
         UBool hasNext() const;
@@ -351,7 +349,7 @@ public:
          *                  pass the U_SUCCESS() test, or else the function returns
          *                  immediately. Check for U_FAILURE() on output or use with
          *                  function chaining. (See User Guide for details.)
-         * @return TRUE if there is another element.
+         * @return true if there is another element.
          * @stable ICU 4.8
          */
         UBool next(UErrorCode &errorCode);
@@ -371,7 +369,7 @@ public:
         UBool truncateAndStop() {
             pos_=NULL;
             value_=-1;  // no real value for str
-            return TRUE;
+            return true;
         }
 
         const char16_t *branchNext(const char16_t *pos, int32_t length, UErrorCode &errorCode);
diff --git a/deps/icu-small/source/common/unicode/ucharstriebuilder.h b/deps/icu-small/source/common/unicode/ucharstriebuilder.h
index 540dcc047fd563eca8cd6631529c1386f7079a2e..15657702f9d02455524f2c94f414a8218e6e2c21 100644
--- a/deps/icu-small/source/common/unicode/ucharstriebuilder.h
+++ b/deps/icu-small/source/common/unicode/ucharstriebuilder.h
@@ -101,9 +101,10 @@ public:
      * Multiple calls to buildUnicodeString() set the UnicodeStrings to the
      * builder's same char16_t array, without rebuilding.
      * If buildUnicodeString() is called after build(), the trie will be
-     * re-serialized into a new array.
-     * If build() is called after buildUnicodeString(), the trie object will become
-     * the owner of the previously returned array.
+     * re-serialized into a new array (because build() passes on ownership).
+     * If build() is called after buildUnicodeString(), the trie object returned
+     * by build() will become the owner of the underlying data for the
+     * previously returned UnicodeString.
      * After clear() has been called, a new array will be used as well.
      * @param buildOption Build option, see UStringTrieBuildOption.
      * @param result A UnicodeString which will be set to the char16_t-serialized
@@ -147,7 +148,7 @@ private:
     virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t unitIndex, int32_t count) const;
     virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, char16_t unit) const;
 
-    virtual UBool matchNodesCanHaveValues() const { return TRUE; }
+    virtual UBool matchNodesCanHaveValues() const { return true; }
 
     virtual int32_t getMaxBranchLinearSubNodeLength() const { return UCharsTrie::kMaxBranchLinearSubNodeLength; }
     virtual int32_t getMinLinearMatch() const { return UCharsTrie::kMinLinearMatch; }
diff --git a/deps/icu-small/source/common/unicode/uchriter.h b/deps/icu-small/source/common/unicode/uchriter.h
index bee842cc259f0748b846850dc3308492d3897cda..84309b2416d136c9fdb3042585bc0c422e260990 100644
--- a/deps/icu-small/source/common/unicode/uchriter.h
+++ b/deps/icu-small/source/common/unicode/uchriter.h
@@ -274,11 +274,11 @@ public:
   virtual UChar32       next32PostInc(void);
 
   /**
-   * Returns FALSE if there are no more code units or code points
+   * Returns false if there are no more code units or code points
    * at or after the current position in the iteration range.
    * This is used with nextPostInc() or next32PostInc() in forward
    * iteration.
-   * @return FALSE if there are no more code units or code points
+   * @return false if there are no more code units or code points
    * at or after the current position in the iteration range.
    * @stable ICU 2.0
    */
@@ -303,11 +303,11 @@ public:
   virtual UChar32       previous32(void);
 
   /**
-   * Returns FALSE if there are no more code units or code points
+   * Returns false if there are no more code units or code points
    * before the current position in the iteration range.
    * This is used with previous() or previous32() in backward
    * iteration.
-   * @return FALSE if there are no more code units or code points
+   * @return false if there are no more code units or code points
    * before the current position in the iteration range.
    * @stable ICU 2.0
    */
diff --git a/deps/icu-small/source/common/unicode/uclean.h b/deps/icu-small/source/common/unicode/uclean.h
index ab0cd6da6ba7801cc9b248aed34fd4d537c13d72..f03593964a4edd784ad99a40b542f31d97b7ab56 100644
--- a/deps/icu-small/source/common/unicode/uclean.h
+++ b/deps/icu-small/source/common/unicode/uclean.h
@@ -49,7 +49,7 @@
  *
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_init(UErrorCode *status);
 
 #ifndef U_HIDE_SYSTEM_API
@@ -98,7 +98,7 @@ u_init(UErrorCode *status);
  * @stable ICU 2.0
  * @system
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_cleanup(void);
 
 U_CDECL_BEGIN
@@ -148,7 +148,7 @@ typedef void  U_CALLCONV UMemFreeFn (const void *context, void *mem);
  *  @stable ICU 2.8
  *  @system
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_setMemoryFunctions(const void *context, UMemAllocFn * U_CALLCONV_FPTR a, UMemReallocFn * U_CALLCONV_FPTR r, UMemFreeFn * U_CALLCONV_FPTR f,
                     UErrorCode *status);
 
diff --git a/deps/icu-small/source/common/unicode/ucnv.h b/deps/icu-small/source/common/unicode/ucnv.h
index ec7c5f350b497378298874dd869a837137964352..5d784990f2cdcee34940785c34495ce5e7f80ba4 100644
--- a/deps/icu-small/source/common/unicode/ucnv.h
+++ b/deps/icu-small/source/common/unicode/ucnv.h
@@ -51,7 +51,10 @@
 
 #include "unicode/ucnv_err.h"
 #include "unicode/uenum.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 #if !defined(USET_DEFINED) && !defined(U_IN_DOXYGEN)
 
@@ -308,7 +311,7 @@ U_CDECL_END
  * lexically follows name2.
  * @stable ICU 2.0
  */
-U_STABLE int U_EXPORT2
+U_CAPI int U_EXPORT2
 ucnv_compareNames(const char *name1, const char *name2);
 
 
@@ -362,7 +365,7 @@ ucnv_compareNames(const char *name1, const char *name2);
  * @see ucnv_compareNames
  * @stable ICU 2.0
  */
-U_STABLE UConverter* U_EXPORT2
+U_CAPI UConverter* U_EXPORT2
 ucnv_open(const char *converterName, UErrorCode *err);
 
 
@@ -392,7 +395,7 @@ ucnv_open(const char *converterName, UErrorCode *err);
  * @see ucnv_compareNames
  * @stable ICU 2.0
  */
-U_STABLE UConverter* U_EXPORT2
+U_CAPI UConverter* U_EXPORT2
 ucnv_openU(const UChar *name,
            UErrorCode *err);
 
@@ -460,7 +463,7 @@ ucnv_openU(const UChar *name,
  * @see UConverterPlatform
  * @stable ICU 2.0
  */
-U_STABLE UConverter* U_EXPORT2
+U_CAPI UConverter* U_EXPORT2
 ucnv_openCCSID(int32_t codepage,
                UConverterPlatform platform,
                UErrorCode * err);
@@ -476,7 +479,7 @@ ucnv_openCCSID(int32_t codepage,
  * <p>The name will NOT be looked up in the alias mechanism, nor will the converter be
  * stored in the converter cache or the alias table. The only way to open further converters
  * is call this function multiple times, or use the ucnv_safeClone() function to clone a
- * 'master' converter.</p>
+ * 'primary' converter.</p>
  *
  * <p>A future version of ICU may add alias table lookups and/or caching
  * to this function.</p>
@@ -495,7 +498,7 @@ ucnv_openCCSID(int32_t codepage,
  * @see ucnv_close
  * @stable ICU 2.2
  */
-U_STABLE UConverter* U_EXPORT2
+U_CAPI UConverter* U_EXPORT2
 ucnv_openPackage(const char *packageName, const char *converterName, UErrorCode *err);
 
 /**
@@ -537,7 +540,7 @@ ucnv_openPackage(const char *packageName, const char *converterName, UErrorCode
  * @return pointer to the new clone
  * @stable ICU 2.0
  */
-U_STABLE UConverter * U_EXPORT2
+U_CAPI UConverter * U_EXPORT2
 ucnv_safeClone(const UConverter *cnv,
                void             *stackBuffer,
                int32_t          *pBufferSize,
@@ -566,7 +569,7 @@ ucnv_safeClone(const UConverter *cnv,
  * @see ucnv_openCCSID
  * @stable ICU 2.0
  */
-U_STABLE void  U_EXPORT2
+U_CAPI void  U_EXPORT2
 ucnv_close(UConverter * converter);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -605,7 +608,7 @@ U_NAMESPACE_END
  * @see ucnv_setSubstChars
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_getSubstChars(const UConverter *converter,
                    char *subChars,
                    int8_t *len,
@@ -630,7 +633,7 @@ ucnv_getSubstChars(const UConverter *converter,
  * @see ucnv_getSubstChars
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_setSubstChars(UConverter *converter,
                    const char *subChars,
                    int8_t len,
@@ -663,7 +666,7 @@ ucnv_setSubstChars(UConverter *converter,
  * @see ucnv_getSubstChars
  * @stable ICU 3.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_setSubstString(UConverter *cnv,
                     const UChar *s,
                     int32_t length,
@@ -682,7 +685,7 @@ ucnv_setSubstString(UConverter *cnv,
  * <TT>U_INDEX_OUTOFBOUNDS_ERROR</TT> will be returned.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_getInvalidChars(const UConverter *converter,
                      char *errBytes,
                      int8_t *len,
@@ -701,7 +704,7 @@ ucnv_getInvalidChars(const UConverter *converter,
  * <TT>U_INDEX_OUTOFBOUNDS_ERROR</TT> will be returned.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_getInvalidUChars(const UConverter *converter,
                       UChar *errUChars,
                       int8_t *len,
@@ -714,7 +717,7 @@ ucnv_getInvalidUChars(const UConverter *converter,
  * @param converter the Unicode converter
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_reset(UConverter *converter);
 
 /**
@@ -725,7 +728,7 @@ ucnv_reset(UConverter *converter);
  * @param converter the Unicode converter
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_resetToUnicode(UConverter *converter);
 
 /**
@@ -736,7 +739,7 @@ ucnv_resetToUnicode(UConverter *converter);
  * @param converter the Unicode converter
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_resetFromUnicode(UConverter *converter);
 
 /**
@@ -789,7 +792,7 @@ ucnv_resetFromUnicode(UConverter *converter);
  * @see ucnv_getMinCharSize
  * @stable ICU 2.0
  */
-U_STABLE int8_t U_EXPORT2
+U_CAPI int8_t U_EXPORT2
 ucnv_getMaxCharSize(const UConverter *converter);
 
 /**
@@ -822,7 +825,7 @@ ucnv_getMaxCharSize(const UConverter *converter);
  * @see ucnv_getMaxCharSize
  * @stable ICU 2.0
  */
-U_STABLE int8_t U_EXPORT2
+U_CAPI int8_t U_EXPORT2
 ucnv_getMinCharSize(const UConverter *converter);
 
 /**
@@ -839,7 +842,7 @@ ucnv_getMinCharSize(const UConverter *converter);
  * @see ucnv_getName
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_getDisplayName(const UConverter *converter,
                     const char *displayLocale,
                     UChar *displayName,
@@ -856,7 +859,7 @@ ucnv_getDisplayName(const UConverter *converter,
  * @see ucnv_getDisplayName
  * @stable ICU 2.0
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucnv_getName(const UConverter *converter, UErrorCode *err);
 
 /**
@@ -882,7 +885,7 @@ ucnv_getName(const UConverter *converter, UErrorCode *err);
  * @see ucnv_getPlatform
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_getCCSID(const UConverter *converter,
               UErrorCode *err);
 
@@ -896,7 +899,7 @@ ucnv_getCCSID(const UConverter *converter,
  * @return The codepage platform
  * @stable ICU 2.0
  */
-U_STABLE UConverterPlatform U_EXPORT2
+U_CAPI UConverterPlatform U_EXPORT2
 ucnv_getPlatform(const UConverter *converter,
                  UErrorCode *err);
 
@@ -908,14 +911,14 @@ ucnv_getPlatform(const UConverter *converter,
  * @return the type of the converter
  * @stable ICU 2.0
  */
-U_STABLE UConverterType U_EXPORT2
+U_CAPI UConverterType U_EXPORT2
 ucnv_getType(const UConverter * converter);
 
 /**
  * Gets the "starter" (lead) bytes for converters of type MBCS.
  * Will fill in an <TT>U_ILLEGAL_ARGUMENT_ERROR</TT> if converter passed in
  * is not MBCS. Fills in an array of type UBool, with the value of the byte
- * as offset to the array. For example, if (starters[0x20] == TRUE) at return,
+ * as offset to the array. For example, if (starters[0x20] == true) at return,
  * it means that the byte 0x20 is a starter byte in this converter.
  * Context pointers are always owned by the caller.
  *
@@ -926,7 +929,7 @@ ucnv_getType(const UConverter * converter);
  * @see ucnv_getType
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_getStarters(const UConverter* converter,
                  UBool starters[256],
                  UErrorCode* err);
@@ -997,7 +1000,7 @@ typedef enum UConverterUnicodeSet {
  * @see uset_close
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_getUnicodeSet(const UConverter *cnv,
                    USet *setFillIn,
                    UConverterUnicodeSet whichSet,
@@ -1014,7 +1017,7 @@ ucnv_getUnicodeSet(const UConverter *cnv,
  * @see ucnv_setToUCallBack
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_getToUCallBack (const UConverter * converter,
                      UConverterToUCallback *action,
                      const void **context);
@@ -1030,7 +1033,7 @@ ucnv_getToUCallBack (const UConverter * converter,
  * @see ucnv_setFromUCallBack
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_getFromUCallBack (const UConverter * converter,
                        UConverterFromUCallback *action,
                        const void **context);
@@ -1050,7 +1053,7 @@ ucnv_getFromUCallBack (const UConverter * converter,
  * @see ucnv_getToUCallBack
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_setToUCallBack (UConverter * converter,
                      UConverterToUCallback newAction,
                      const void* newContext,
@@ -1073,7 +1076,7 @@ ucnv_setToUCallBack (UConverter * converter,
  * @see ucnv_getFromUCallBack
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_setFromUCallBack (UConverter * converter,
                        UConverterFromUCallback newAction,
                        const void *newContext,
@@ -1100,7 +1103,7 @@ ucnv_setFromUCallBack (UConverter * converter,
  *  consumed. At that point, the caller should reset the source and
  *  sourceLimit pointers to point to the next chunk.
  *
- * At the end of the stream (flush==TRUE), the input is completely consumed
+ * At the end of the stream (flush==true), the input is completely consumed
  * when *source==sourceLimit and no error code is set.
  * The converter object is then automatically reset by this function.
  * (This means that a converter need not be reset explicitly between data
@@ -1125,9 +1128,9 @@ ucnv_setFromUCallBack (UConverter * converter,
  * e.g: <TT>offsets[3]</TT> is equal to 6, it means that the <TT>target[3]</TT> was a result of transcoding <TT>source[6]</TT>
  * For output data carried across calls, and other data without a specific source character
  * (such as from escape sequences or callbacks)  -1 will be placed for offsets.
- * @param flush set to <TT>TRUE</TT> if the current source buffer is the last available
- * chunk of the source, <TT>FALSE</TT> otherwise. Note that if a failing status is returned,
- * this function may have to be called multiple times with flush set to <TT>TRUE</TT> until
+ * @param flush set to <TT>true</TT> if the current source buffer is the last available
+ * chunk of the source, <TT>false</TT> otherwise. Note that if a failing status is returned,
+ * this function may have to be called multiple times with flush set to <TT>true</TT> until
  * the source buffer is consumed.
  * @param err the error status.  <TT>U_ILLEGAL_ARGUMENT_ERROR</TT> will be set if the
  * converter is <TT>NULL</TT>.
@@ -1139,7 +1142,7 @@ ucnv_setFromUCallBack (UConverter * converter,
  * @see ucnv_setToUCallBack
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_fromUnicode (UConverter * converter,
                   char **target,
                   const char *targetLimit,
@@ -1169,7 +1172,7 @@ ucnv_fromUnicode (UConverter * converter,
  *  consumed. At that point, the caller should reset the source and
  *  sourceLimit pointers to point to the next chunk.
  *
- * At the end of the stream (flush==TRUE), the input is completely consumed
+ * At the end of the stream (flush==true), the input is completely consumed
  * when *source==sourceLimit and no error code is set
  * The converter object is then automatically reset by this function.
  * (This means that a converter need not be reset explicitly between data
@@ -1193,9 +1196,9 @@ ucnv_fromUnicode (UConverter * converter,
  * e.g: <TT>offsets[3]</TT> is equal to 6, it means that the <TT>target[3]</TT> was a result of transcoding <TT>source[6]</TT>
  * For output data carried across calls, and other data without a specific source character
  * (such as from escape sequences or callbacks)  -1 will be placed for offsets.
- * @param flush set to <TT>TRUE</TT> if the current source buffer is the last available
- * chunk of the source, <TT>FALSE</TT> otherwise. Note that if a failing status is returned,
- * this function may have to be called multiple times with flush set to <TT>TRUE</TT> until
+ * @param flush set to <TT>true</TT> if the current source buffer is the last available
+ * chunk of the source, <TT>false</TT> otherwise. Note that if a failing status is returned,
+ * this function may have to be called multiple times with flush set to <TT>true</TT> until
  * the source buffer is consumed.
  * @param err the error status.  <TT>U_ILLEGAL_ARGUMENT_ERROR</TT> will be set if the
  * converter is <TT>NULL</TT>.
@@ -1208,7 +1211,7 @@ ucnv_fromUnicode (UConverter * converter,
  * @see ucnv_getNextUChar
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_toUnicode(UConverter *converter,
                UChar **target,
                const UChar *targetLimit,
@@ -1245,7 +1248,7 @@ ucnv_toUnicode(UConverter *converter,
  * @see UCNV_GET_MAX_BYTES_FOR_STRING
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_fromUChars(UConverter *cnv,
                 char *dest, int32_t destCapacity,
                 const UChar *src, int32_t srcLength,
@@ -1277,7 +1280,7 @@ ucnv_fromUChars(UConverter *cnv,
  * @see ucnv_convert
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_toUChars(UConverter *cnv,
               UChar *dest, int32_t destCapacity,
               const char *src, int32_t srcLength,
@@ -1295,7 +1298,7 @@ ucnv_toUChars(UConverter *cnv,
  * - Convenient.
  *
  * Limitations compared to ucnv_toUnicode():
- * - Always assumes flush=TRUE.
+ * - Always assumes flush=true.
  *   This makes ucnv_getNextUChar() unsuitable for "streaming" conversion,
  *   that is, for where the input is supplied in multiple buffers,
  *   because ucnv_getNextUChar() will assume the end of the input at the end
@@ -1306,7 +1309,7 @@ ucnv_toUChars(UConverter *cnv,
  * ucnv_getNextUChar() uses the current state of the converter
  * (unlike ucnv_toUChars() which always resets first).
  * However, if ucnv_getNextUChar() is called after ucnv_toUnicode()
- * stopped in the middle of a character sequence (with flush=FALSE),
+ * stopped in the middle of a character sequence (with flush=false),
  * then ucnv_getNextUChar() will always use the slower ucnv_toUnicode()
  * internally until the next character boundary.
  * (This is new in ICU 2.6. In earlier releases, ucnv_getNextUChar() had to
@@ -1353,7 +1356,7 @@ ucnv_toUChars(UConverter *cnv,
  * @see ucnv_convert
  * @stable ICU 2.0
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 ucnv_getNextUChar(UConverter * converter,
                   const char **source,
                   const char * sourceLimit,
@@ -1385,7 +1388,7 @@ ucnv_getNextUChar(UConverter * converter,
  *
  * ucnv_convertEx() also provides further convenience:
  * - an option to reset the converters at the beginning
- *   (if reset==TRUE, see parameters;
+ *   (if reset==true, see parameters;
  *    also sets *pivotTarget=*pivotSource=pivotStart)
  * - allow NUL-terminated input
  *   (only a single NUL byte, will not work for charsets with multi-byte NULs)
@@ -1442,7 +1445,7 @@ ucnv_getNextUChar(UConverter * converter,
  *                    &target, u8+capacity,
  *                    &s, s+length,
  *                    NULL, NULL, NULL, NULL,
- *                    TRUE, TRUE,
+ *                    true, true,
  *                    pErrorCode);
  *
  *     myReleaseCachedUTF8Converter(utf8Cnv);
@@ -1474,7 +1477,7 @@ ucnv_getNextUChar(UConverter * converter,
  *                      It must be pivotStart<=*pivotSource<=*pivotTarget<=pivotLimit
  *                      and pivotStart<pivotLimit (unless pivotStart==NULL).
  * @param pivotLimit    Pointer to the first unit after the pivot buffer.
- * @param reset         If TRUE, then ucnv_resetToUnicode(sourceCnv) and
+ * @param reset         If true, then ucnv_resetToUnicode(sourceCnv) and
  *                      ucnv_resetFromUnicode(targetCnv) are called, and the
  *                      pivot pointers are reset (*pivotTarget=*pivotSource=pivotStart).
  * @param flush         If true, indicates the end of the input.
@@ -1497,7 +1500,7 @@ ucnv_getNextUChar(UConverter * converter,
  * @see ucnv_toUChars
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_convertEx(UConverter *targetCnv, UConverter *sourceCnv,
                char **target, const char *targetLimit,
                const char **source, const char *sourceLimit,
@@ -1561,7 +1564,7 @@ ucnv_convertEx(UConverter *targetCnv, UConverter *sourceCnv,
  * @see ucnv_getNextUChar
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_convert(const char *toConverterName,
              const char *fromConverterName,
              char *target,
@@ -1615,7 +1618,7 @@ ucnv_convert(const char *toConverterName,
  * @see ucnv_toUChars
  * @stable ICU 2.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_toAlgorithmic(UConverterType algorithmicType,
                    UConverter *cnv,
                    char *target, int32_t targetCapacity,
@@ -1667,7 +1670,7 @@ ucnv_toAlgorithmic(UConverterType algorithmicType,
  * @see ucnv_toUChars
  * @stable ICU 2.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_fromAlgorithmic(UConverter *cnv,
                      UConverterType algorithmicType,
                      char *target, int32_t targetCapacity,
@@ -1681,7 +1684,7 @@ ucnv_fromAlgorithmic(UConverter *cnv,
  * @see ucnv_close
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_flushCache(void);
 
 /**
@@ -1691,20 +1694,20 @@ ucnv_flushCache(void);
  * @see ucnv_getAvailableName
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_countAvailable(void);
 
 /**
  * Gets the canonical converter name of the specified converter from a list of
- * all available converters contaied in the alias file. All converters
+ * all available converters contained in the alias file. All converters
  * in this list can be opened.
  *
- * @param n the index to a converter available on the system (in the range <TT>[0..ucnv_countAvaiable()]</TT>)
+ * @param n the index to a converter available on the system (in the range <TT>[0..ucnv_countAvailable()]</TT>)
  * @return a pointer a string (library owned), or <TT>NULL</TT> if the index is out of bounds.
  * @see ucnv_countAvailable
  * @stable ICU 2.0
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 ucnv_getAvailableName(int32_t n);
 
 /**
@@ -1719,7 +1722,7 @@ ucnv_getAvailableName(int32_t n);
  * @see uenum_next
  * @stable ICU 2.4
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 ucnv_openAllNames(UErrorCode *pErrorCode);
 
 /**
@@ -1732,7 +1735,7 @@ ucnv_openAllNames(UErrorCode *pErrorCode);
  * @return number of names on alias list for given alias
  * @stable ICU 2.0
  */
-U_STABLE uint16_t U_EXPORT2
+U_CAPI uint16_t U_EXPORT2
 ucnv_countAliases(const char *alias, UErrorCode *pErrorCode);
 
 /**
@@ -1747,7 +1750,7 @@ ucnv_countAliases(const char *alias, UErrorCode *pErrorCode);
  * @see ucnv_countAliases
  * @stable ICU 2.0
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucnv_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode);
 
 /**
@@ -1763,7 +1766,7 @@ ucnv_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode);
  * @param pErrorCode result of operation
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_getAliases(const char *alias, const char **aliases, UErrorCode *pErrorCode);
 
 /**
@@ -1789,7 +1792,7 @@ ucnv_getAliases(const char *alias, const char **aliases, UErrorCode *pErrorCode)
  * @see uenum_next
  * @stable ICU 2.2
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 ucnv_openStandardNames(const char *convName,
                        const char *standard,
                        UErrorCode *pErrorCode);
@@ -1799,7 +1802,7 @@ ucnv_openStandardNames(const char *convName,
  * @return number of standards
  * @stable ICU 2.0
  */
-U_STABLE uint16_t U_EXPORT2
+U_CAPI uint16_t U_EXPORT2
 ucnv_countStandards(void);
 
 /**
@@ -1809,7 +1812,7 @@ ucnv_countStandards(void);
  * @return returns the name of the standard at given index. Owned by the library.
  * @stable ICU 2.0
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucnv_getStandard(uint16_t n, UErrorCode *pErrorCode);
 
 /**
@@ -1831,7 +1834,7 @@ ucnv_getStandard(uint16_t n, UErrorCode *pErrorCode);
  *         then <code>NULL</code> is returned. Owned by the library.
  * @stable ICU 2.0
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucnv_getStandardName(const char *name, const char *standard, UErrorCode *pErrorCode);
 
 /**
@@ -1853,7 +1856,7 @@ ucnv_getStandardName(const char *name, const char *standard, UErrorCode *pErrorC
  * @see ucnv_getStandardName
  * @stable ICU 2.4
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucnv_getCanonicalName(const char *alias, const char *standard, UErrorCode *pErrorCode);
 
 /**
@@ -1870,7 +1873,7 @@ ucnv_getCanonicalName(const char *alias, const char *standard, UErrorCode *pErro
  * @see ucnv_setDefaultName
  * @stable ICU 2.0
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucnv_getDefaultName(void);
 
 #ifndef U_HIDE_SYSTEM_API
@@ -1890,7 +1893,7 @@ ucnv_getDefaultName(void);
  * @system
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_setDefaultName(const char *name);
 #endif  /* U_HIDE_SYSTEM_API */
 
@@ -1911,18 +1914,18 @@ ucnv_setDefaultName(const char *name);
  * @see ucnv_isAmbiguous
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_fixFileSeparator(const UConverter *cnv, UChar *source, int32_t sourceLen);
 
 /**
  * Determines if the converter contains ambiguous mappings of the same
  * character or not.
  * @param cnv the converter to be tested
- * @return TRUE if the converter contains ambiguous mapping of the same
- * character, FALSE otherwise.
+ * @return true if the converter contains ambiguous mapping of the same
+ * character, false otherwise.
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucnv_isAmbiguous(const UConverter *cnv);
 
 /**
@@ -1935,12 +1938,12 @@ ucnv_isAmbiguous(const UConverter *cnv);
  * http://www.icu-project.org/userguide/conversion-data.html#ucmformat
  *
  * @param cnv The converter to set the fallback mapping usage on.
- * @param usesFallback TRUE if the user wants the converter to take advantage of the fallback
- * mapping, FALSE otherwise.
+ * @param usesFallback true if the user wants the converter to take advantage of the fallback
+ * mapping, false otherwise.
  * @stable ICU 2.0
  * @see ucnv_usesFallback
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_setFallback(UConverter *cnv, UBool usesFallback);
 
 /**
@@ -1948,11 +1951,11 @@ ucnv_setFallback(UConverter *cnv, UBool usesFallback);
  * This flag has restrictions, see ucnv_setFallback().
  *
  * @param cnv The converter to be tested
- * @return TRUE if the converter uses fallback, FALSE otherwise.
+ * @return true if the converter uses fallback, false otherwise.
  * @stable ICU 2.0
  * @see ucnv_setFallback
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucnv_usesFallback(const UConverter *cnv);
 
 /**
@@ -1984,7 +1987,7 @@ ucnv_usesFallback(const UConverter *cnv);
  * @return The name of the encoding detected. NULL if encoding is not detected.
  * @stable ICU 2.4
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 ucnv_detectUnicodeSignature(const char* source,
                             int32_t sourceLength,
                             int32_t *signatureLength,
@@ -2001,7 +2004,7 @@ ucnv_detectUnicodeSignature(const char* source,
  * @return The number of UChars in the state. -1 if an error is encountered.
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_fromUCountPending(const UConverter* cnv, UErrorCode* status);
 
 /**
@@ -2015,7 +2018,7 @@ ucnv_fromUCountPending(const UConverter* cnv, UErrorCode* status);
  * @return The number of chars in the state. -1 if an error is encountered.
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnv_toUCountPending(const UConverter* cnv, UErrorCode* status);
 
 /**
@@ -2027,13 +2030,13 @@ ucnv_toUCountPending(const UConverter* cnv, UErrorCode* status);
  * but a UTF-32 converter encodes each code point with 4 bytes.
  * Note: This method is not intended to be used to determine whether the charset has a
  * fixed ratio of bytes to Unicode codes <i>units</i> for any particular Unicode encoding form.
- * FALSE is returned with the UErrorCode if error occurs or cnv is NULL.
+ * false is returned with the UErrorCode if error occurs or cnv is NULL.
  * @param cnv       The converter to be tested
  * @param status    ICU error code in/out paramter
- * @return TRUE if the converter is fixed-width
+ * @return true if the converter is fixed-width
  * @stable ICU 4.8
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucnv_isFixedWidth(UConverter *cnv, UErrorCode *status);
 
 #endif
diff --git a/deps/icu-small/source/common/unicode/ucnv_cb.h b/deps/icu-small/source/common/unicode/ucnv_cb.h
index 632cc0b35f26c5403227b9421766aad82a6deeee..18240990dbaed9112faf52d6495266f55d8a73dd 100644
--- a/deps/icu-small/source/common/unicode/ucnv_cb.h
+++ b/deps/icu-small/source/common/unicode/ucnv_cb.h
@@ -84,7 +84,7 @@
  * @see ucnv_cbFromUWriteSub
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_cbFromUWriteBytes (UConverterFromUnicodeArgs *args,
                         const char* source,
                         int32_t length,
@@ -104,7 +104,7 @@ ucnv_cbFromUWriteBytes (UConverterFromUnicodeArgs *args,
  * @see ucnv_cbFromUWriteBytes
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnv_cbFromUWriteSub (UConverterFromUnicodeArgs *args,
                       int32_t offsetIndex,
                       UErrorCode * err);
@@ -121,7 +121,7 @@ ucnv_cbFromUWriteSub (UConverterFromUnicodeArgs *args,
  * @see ucnv_cbToUWriteSub
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 ucnv_cbFromUWriteUChars(UConverterFromUnicodeArgs *args,
+U_CAPI void U_EXPORT2 ucnv_cbFromUWriteUChars(UConverterFromUnicodeArgs *args,
                              const UChar** source,
                              const UChar*  sourceLimit,
                              int32_t offsetIndex,
@@ -140,7 +140,7 @@ U_STABLE void U_EXPORT2 ucnv_cbFromUWriteUChars(UConverterFromUnicodeArgs *args,
  * @see ucnv_cbToUWriteSub
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 ucnv_cbToUWriteUChars (UConverterToUnicodeArgs *args,
+U_CAPI void U_EXPORT2 ucnv_cbToUWriteUChars (UConverterToUnicodeArgs *args,
                                              const UChar* source,
                                              int32_t length,
                                              int32_t offsetIndex,
@@ -156,7 +156,7 @@ U_STABLE void U_EXPORT2 ucnv_cbToUWriteUChars (UConverterToUnicodeArgs *args,
  * @see ucnv_cbToUWriteUChars
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 ucnv_cbToUWriteSub (UConverterToUnicodeArgs *args,
+U_CAPI void U_EXPORT2 ucnv_cbToUWriteSub (UConverterToUnicodeArgs *args,
                        int32_t offsetIndex,
                        UErrorCode * err);
 #endif
diff --git a/deps/icu-small/source/common/unicode/ucnv_err.h b/deps/icu-small/source/common/unicode/ucnv_err.h
index 08c96c14407c222050dc8dc25c512bf7eb873f39..bff90f0ba1e1d4617f37e2fbeee82e6e9bbb1d2b 100644
--- a/deps/icu-small/source/common/unicode/ucnv_err.h
+++ b/deps/icu-small/source/common/unicode/ucnv_err.h
@@ -193,7 +193,7 @@ typedef enum {
  */
 typedef struct {
     uint16_t size;              /**< The size of this struct. @stable ICU 2.0 */
-    UBool flush;                /**< The internal state of converter will be reset and data flushed if set to TRUE. @stable ICU 2.0    */
+    UBool flush;                /**< The internal state of converter will be reset and data flushed if set to true. @stable ICU 2.0    */
     UConverter *converter;      /**< Pointer to the converter that is opened and to which this struct is passed as an argument. @stable ICU 2.0  */
     const UChar *source;        /**< Pointer to the source source buffer. @stable ICU 2.0    */
     const UChar *sourceLimit;   /**< Pointer to the limit (end + 1) of source buffer. @stable ICU 2.0    */
@@ -209,7 +209,7 @@ typedef struct {
  */
 typedef struct {
     uint16_t size;              /**< The size of this struct   @stable ICU 2.0 */
-    UBool flush;                /**< The internal state of converter will be reset and data flushed if set to TRUE. @stable ICU 2.0   */
+    UBool flush;                /**< The internal state of converter will be reset and data flushed if set to true. @stable ICU 2.0   */
     UConverter *converter;      /**< Pointer to the converter that is opened and to which this struct is passed as an argument. @stable ICU 2.0 */
     const char *source;         /**< Pointer to the source source buffer. @stable ICU 2.0    */
     const char *sourceLimit;    /**< Pointer to the limit (end + 1) of source buffer. @stable ICU 2.0    */
@@ -233,7 +233,7 @@ typedef struct {
  * @param err This should always be set to a failure status prior to calling.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_STOP (
+U_CAPI void U_EXPORT2 UCNV_FROM_U_CALLBACK_STOP (
                   const void *context,
                   UConverterFromUnicodeArgs *fromUArgs,
                   const UChar* codeUnits,
@@ -257,7 +257,7 @@ U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_STOP (
  * @param err This should always be set to a failure status prior to calling.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 UCNV_TO_U_CALLBACK_STOP (
+U_CAPI void U_EXPORT2 UCNV_TO_U_CALLBACK_STOP (
                   const void *context,
                   UConverterToUnicodeArgs *toUArgs,
                   const char* codeUnits,
@@ -284,7 +284,7 @@ U_STABLE void U_EXPORT2 UCNV_TO_U_CALLBACK_STOP (
  *      otherwise this value will be set to a failure status.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_SKIP (
+U_CAPI void U_EXPORT2 UCNV_FROM_U_CALLBACK_SKIP (
                   const void *context,
                   UConverterFromUnicodeArgs *fromUArgs,
                   const UChar* codeUnits,
@@ -314,7 +314,7 @@ U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_SKIP (
  * @see ucnv_setSubstChars
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_SUBSTITUTE (
+U_CAPI void U_EXPORT2 UCNV_FROM_U_CALLBACK_SUBSTITUTE (
                   const void *context,
                   UConverterFromUnicodeArgs *fromUArgs,
                   const UChar* codeUnits,
@@ -370,7 +370,7 @@ U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_SUBSTITUTE (
  *      otherwise this value will be set to a failure status.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_ESCAPE (
+U_CAPI void U_EXPORT2 UCNV_FROM_U_CALLBACK_ESCAPE (
                   const void *context,
                   UConverterFromUnicodeArgs *fromUArgs,
                   const UChar* codeUnits,
@@ -398,7 +398,7 @@ U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_ESCAPE (
  *      otherwise this value will be set to a failure status.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 UCNV_TO_U_CALLBACK_SKIP (
+U_CAPI void U_EXPORT2 UCNV_TO_U_CALLBACK_SKIP (
                   const void *context,
                   UConverterToUnicodeArgs *toUArgs,
                   const char* codeUnits,
@@ -424,7 +424,7 @@ U_STABLE void U_EXPORT2 UCNV_TO_U_CALLBACK_SKIP (
  *      otherwise this value will be set to a failure status.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2 UCNV_TO_U_CALLBACK_SUBSTITUTE (
+U_CAPI void U_EXPORT2 UCNV_TO_U_CALLBACK_SUBSTITUTE (
                   const void *context,
                   UConverterToUnicodeArgs *toUArgs,
                   const char* codeUnits,
@@ -450,7 +450,7 @@ U_STABLE void U_EXPORT2 UCNV_TO_U_CALLBACK_SUBSTITUTE (
  * @stable ICU 2.0
  */
 
-U_STABLE void U_EXPORT2 UCNV_TO_U_CALLBACK_ESCAPE (
+U_CAPI void U_EXPORT2 UCNV_TO_U_CALLBACK_ESCAPE (
                   const void *context,
                   UConverterToUnicodeArgs *toUArgs,
                   const char* codeUnits,
diff --git a/deps/icu-small/source/common/unicode/ucnvsel.h b/deps/icu-small/source/common/unicode/ucnvsel.h
index 5fee53f179ace75c8f56c951ad010e86f63439d3..3ba41bd64c1750278fb8f9f77e1e201fe49e59e2 100644
--- a/deps/icu-small/source/common/unicode/ucnvsel.h
+++ b/deps/icu-small/source/common/unicode/ucnvsel.h
@@ -29,7 +29,10 @@
 #include "unicode/utf16.h"
 #include "unicode/uenum.h"
 #include "unicode/ucnv.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -42,11 +45,11 @@
  * from the serialized form.
  */
 
+struct UConverterSelector;
 /**
  * @{
- * The selector data structure
+ * Typedef for selector data structure.
  */
-struct UConverterSelector;
 typedef struct UConverterSelector UConverterSelector;
 /** @} */
 
@@ -72,7 +75,7 @@ typedef struct UConverterSelector UConverterSelector;
  *
  * @stable ICU 4.2
  */
-U_STABLE UConverterSelector* U_EXPORT2
+U_CAPI UConverterSelector* U_EXPORT2
 ucnvsel_open(const char* const*  converterList, int32_t converterListSize,
              const USet* excludedCodePoints,
              const UConverterUnicodeSet whichSet, UErrorCode* status);
@@ -90,7 +93,7 @@ ucnvsel_open(const char* const*  converterList, int32_t converterListSize,
  *
  * @stable ICU 4.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucnvsel_close(UConverterSelector *sel);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -127,7 +130,7 @@ U_NAMESPACE_END
  *
  * @stable ICU 4.2
  */
-U_STABLE UConverterSelector* U_EXPORT2
+U_CAPI UConverterSelector* U_EXPORT2
 ucnvsel_openFromSerialized(const void* buffer, int32_t length, UErrorCode* status);
 
 /**
@@ -144,7 +147,7 @@ ucnvsel_openFromSerialized(const void* buffer, int32_t length, UErrorCode* statu
  *
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucnvsel_serialize(const UConverterSelector* sel,
                   void* buffer, int32_t bufferCapacity, UErrorCode* status);
 
@@ -162,7 +165,7 @@ ucnvsel_serialize(const UConverterSelector* sel,
  *
  * @stable ICU 4.2
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 ucnvsel_selectForString(const UConverterSelector* sel,
                         const UChar *s, int32_t length, UErrorCode *status);
 
@@ -180,7 +183,7 @@ ucnvsel_selectForString(const UConverterSelector* sel,
  *
  * @stable ICU 4.2
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 ucnvsel_selectForUTF8(const UConverterSelector* sel,
                       const char *s, int32_t length, UErrorCode *status);
 
diff --git a/deps/icu-small/source/common/unicode/ucptrie.h b/deps/icu-small/source/common/unicode/ucptrie.h
index be06a227928286c30450475f4b053504fb34570b..b95491b183e9af1083f95ecb3262bafb8f18dffe 100644
--- a/deps/icu-small/source/common/unicode/ucptrie.h
+++ b/deps/icu-small/source/common/unicode/ucptrie.h
@@ -8,11 +8,13 @@
 #define __UCPTRIE_H__
 
 #include "unicode/utypes.h"
-
-#include "unicode/localpointer.h"
 #include "unicode/ucpmap.h"
 #include "unicode/utf8.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 U_CDECL_BEGIN
 
 /**
@@ -580,11 +582,11 @@ enum {
 // Do not conditionalize with #ifndef U_HIDE_INTERNAL_API, needed for public API
 
 /** @internal */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c);
 
 /** @internal */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucptrie_internalSmallU8Index(const UCPTrie *trie, int32_t lt1, uint8_t t2, uint8_t t3);
 
 /**
@@ -592,7 +594,7 @@ ucptrie_internalSmallU8Index(const UCPTrie *trie, int32_t lt1, uint8_t t2, uint8
  * Do not call directly.
  * @internal
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucptrie_internalU8PrevIndex(const UCPTrie *trie, UChar32 c,
                             const uint8_t *start, const uint8_t *src);
 
diff --git a/deps/icu-small/source/common/unicode/ucurr.h b/deps/icu-small/source/common/unicode/ucurr.h
index 7149e7adf130679b3107bf10d09373727e9a705a..4e115cd01e0fb67b9efb50a9d8b17b19196da13d 100644
--- a/deps/icu-small/source/common/unicode/ucurr.h
+++ b/deps/icu-small/source/common/unicode/ucurr.h
@@ -78,7 +78,7 @@ typedef enum UCurrencyUsage UCurrencyUsage;
  *                invalid.
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucurr_forLocale(const char* locale,
                 UChar* buff,
                 int32_t buffCapacity,
@@ -113,7 +113,29 @@ typedef enum UCurrNameStyle {
      *
      * @stable ICU 61
      */
-    UCURR_NARROW_SYMBOL_NAME
+    UCURR_NARROW_SYMBOL_NAME,
+
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Selector for getName() indicating the formal currency symbol.
+     * The formal currency symbol is similar to the regular currency
+     * symbol, but it always takes the form used in formal settings
+     * such as banking; for example, "NT$" instead of "$" for TWD in zh-TW.
+     *
+     * @draft ICU 68
+     */
+    UCURR_FORMAL_SYMBOL_NAME,
+
+    /**
+     * Selector for getName() indicating the variant currency symbol.
+     * The variant symbol for a currency is an alternative symbol
+     * that is not necessarily as widely used as the regular symbol.
+     *
+     * @draft ICU 68
+     */
+    UCURR_VARIANT_SYMBOL_NAME
+#endif  // U_HIDE_DRAFT_API
+
 } UCurrNameStyle;
 
 #if !UCONFIG_NO_SERVICE
@@ -133,7 +155,7 @@ typedef const void* UCurrRegistryKey;
  * if there was an error.
  * @stable ICU 2.6
  */
-U_STABLE UCurrRegistryKey U_EXPORT2
+U_CAPI UCurrRegistryKey U_EXPORT2
 ucurr_register(const UChar* isoCode,
                    const char* locale,
                    UErrorCode* status);
@@ -145,10 +167,10 @@ ucurr_register(const UChar* isoCode,
  * restored.
  * @param key the registry key returned by a previous call to ucurr_register
  * @param status the in/out status code, no special meanings are assigned
- * @return TRUE if the currency for this key was successfully unregistered
+ * @return true if the currency for this key was successfully unregistered
  * @stable ICU 2.6
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucurr_unregister(UCurrRegistryKey key, UErrorCode* status);
 #endif /* UCONFIG_NO_SERVICE */
 
@@ -159,7 +181,7 @@ ucurr_unregister(UCurrRegistryKey key, UErrorCode* status);
  * @param currency null-terminated 3-letter ISO 4217 code
  * @param locale locale in which to display currency
  * @param nameStyle selector for which kind of name to return
- * @param isChoiceFormat always set to FALSE, or can be NULL;
+ * @param isChoiceFormat always set to false, or can be NULL;
  *     display names are static strings;
  *     since ICU 4.4, ChoiceFormat patterns are no longer supported
  * @param len fill-in parameter to receive length of result
@@ -169,7 +191,7 @@ ucurr_unregister(UCurrRegistryKey key, UErrorCode* status);
  * returned.
  * @stable ICU 2.6
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ucurr_getName(const UChar* currency,
               const char* locale,
               UCurrNameStyle nameStyle,
@@ -183,7 +205,7 @@ ucurr_getName(const UChar* currency,
  * currency object in the en_US locale is "US dollar" or "US dollars".
  * @param currency null-terminated 3-letter ISO 4217 code
  * @param locale locale in which to display currency
- * @param isChoiceFormat always set to FALSE, or can be NULL;
+ * @param isChoiceFormat always set to false, or can be NULL;
  *     display names are static strings;
  *     since ICU 4.4, ChoiceFormat patterns are no longer supported
  * @param pluralCount plural count
@@ -194,7 +216,7 @@ ucurr_getName(const UChar* currency,
  * returned.
  * @stable ICU 4.2
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ucurr_getPluralName(const UChar* currency,
                     const char* locale,
                     UBool* isChoiceFormat,
@@ -219,7 +241,7 @@ ucurr_getPluralName(const UChar* currency,
  * displayed, or 0 if there is an error
  * @stable ICU 3.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucurr_getDefaultFractionDigits(const UChar* currency,
                                UErrorCode* ec);
 
@@ -240,7 +262,7 @@ ucurr_getDefaultFractionDigits(const UChar* currency,
  * displayed, or 0 if there is an error
  * @stable ICU 54
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucurr_getDefaultFractionDigitsForUsage(const UChar* currency,
                                        const UCurrencyUsage usage,
                                        UErrorCode* ec);
@@ -255,7 +277,7 @@ ucurr_getDefaultFractionDigitsForUsage(const UChar* currency,
  * or 0.0 if there is an error
  * @stable ICU 3.0
  */
-U_STABLE double U_EXPORT2
+U_CAPI double U_EXPORT2
 ucurr_getRoundingIncrement(const UChar* currency,
                            UErrorCode* ec);
 
@@ -269,7 +291,7 @@ ucurr_getRoundingIncrement(const UChar* currency,
  * or 0.0 if there is an error
  * @stable ICU 54
  */
-U_STABLE double U_EXPORT2
+U_CAPI double U_EXPORT2
 ucurr_getRoundingIncrementForUsage(const UChar* currency,
                                    const UCurrencyUsage usage,
                                    UErrorCode* ec);
@@ -326,7 +348,7 @@ typedef enum UCurrCurrencyType {
  * @param pErrorCode Error code
  * @stable ICU 3.2
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 ucurr_openISOCurrencies(uint32_t currType, UErrorCode *pErrorCode);
 
 /**
@@ -351,11 +373,11 @@ ucurr_openISOCurrencies(uint32_t currType, UErrorCode *pErrorCode);
   * @param errorCode
   *            ICU error code
    *
-  * @return TRUE if the given ISO 4217 3-letter code is supported on the specified date range.
+  * @return true if the given ISO 4217 3-letter code is supported on the specified date range.
   *
   * @stable ICU 4.8
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucurr_isAvailable(const UChar* isoCode,
              UDate from,
              UDate to,
@@ -375,7 +397,7 @@ ucurr_isAvailable(const UChar* isoCode,
  *               values are invalid.
  * @stable ICU 4.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucurr_countCurrencies(const char* locale,
                  UDate date,
                  UErrorCode* ec);
@@ -399,7 +421,7 @@ ucurr_countCurrencies(const char* locale,
  *               invalid.
  * @stable ICU 4.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucurr_forLocaleAndDate(const char* locale,
                 UDate date,
                 int32_t index,
@@ -423,7 +445,7 @@ ucurr_forLocaleAndDate(const char* locale,
  * @return a string enumeration over keyword values for the given key and the locale.
  * @stable ICU 4.2
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucurr_getKeywordValuesForLocale(const char* key,
                                 const char* locale,
                                 UBool commonlyUsed,
@@ -438,7 +460,7 @@ ucurr_getKeywordValuesForLocale(const char* key,
  * @return The ISO 4217 numeric code of the currency
  * @stable ICU 49
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucurr_getNumericCode(const UChar* currency);
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/common/unicode/udata.h b/deps/icu-small/source/common/unicode/udata.h
index 8236877b443d3d85ba32f36c9603cfebdbc8a51b..88c0dded118d00e9b6cea1b3219f614dba4e45dd 100644
--- a/deps/icu-small/source/common/unicode/udata.h
+++ b/deps/icu-small/source/common/unicode/udata.h
@@ -20,7 +20,10 @@
 #define __UDATA_H__
 
 #include "unicode/utypes.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 U_CDECL_BEGIN
 
@@ -166,8 +169,8 @@ typedef struct UDataMemory UDataMemory;
  * @param pInfo A pointer to the <code>UDataInfo</code> structure
  *              of data that has been loaded and will be returned
  *              by <code>udata_openChoice()</code> if this function
- *              returns <code>TRUE</code>.
- * @return TRUE if the current data memory is acceptable
+ *              returns <code>true</code>.
+ * @return true if the current data memory is acceptable
  * @stable ICU 2.0
  */
 typedef UBool U_CALLCONV
@@ -197,7 +200,7 @@ UDataMemoryIsAcceptable(void *context,
  * @see udata_openChoice
  * @stable ICU 2.0
  */
-U_STABLE UDataMemory * U_EXPORT2
+U_CAPI UDataMemory * U_EXPORT2
 udata_open(const char *path, const char *type, const char *name,
            UErrorCode *pErrorCode);
 
@@ -239,7 +242,7 @@ udata_open(const char *path, const char *type, const char *name,
  *             This may be <code>NULL</code> or empty.
  * @param name A string that specifies the name of the data.
  * @param isAcceptable This function is called to verify that loaded data
- *                     is useful for the client code. If it returns FALSE
+ *                     is useful for the client code. If it returns false
  *                     for all data items, then <code>udata_openChoice()</code>
  *                     will return with an error.
  * @param context Arbitrary parameter to be passed into isAcceptable.
@@ -249,7 +252,7 @@ udata_open(const char *path, const char *type, const char *name,
  *         to get a pointer to the actual data.
  * @stable ICU 2.0
  */
-U_STABLE UDataMemory * U_EXPORT2
+U_CAPI UDataMemory * U_EXPORT2
 udata_openChoice(const char *path, const char *type, const char *name,
                  UDataMemoryIsAcceptable *isAcceptable, void *context,
                  UErrorCode *pErrorCode);
@@ -261,7 +264,7 @@ udata_openChoice(const char *path, const char *type, const char *name,
  * @param pData The pointer to data memory object
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udata_close(UDataMemory *pData);
 
 /**
@@ -273,7 +276,7 @@ udata_close(UDataMemory *pData);
  * @param pData The pointer to data memory object
  * @stable ICU 2.0
  */
-U_STABLE const void * U_EXPORT2
+U_CAPI const void * U_EXPORT2
 udata_getMemory(UDataMemory *pData);
 
 /**
@@ -294,7 +297,7 @@ udata_getMemory(UDataMemory *pData);
  * adjusted and only part of the structure will be filled.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udata_getInfo(UDataMemory *pData, UDataInfo *pInfo);
 
 /**
@@ -303,7 +306,7 @@ udata_getInfo(UDataMemory *pData, UDataInfo *pInfo);
  * area in memory.
  *
  * ICU data must be at least 8-aligned, and should be 16-aligned.
- * See http://userguide.icu-project.org/icudata
+ * See https://unicode-org.github.io/icu/userguide/icudata
  *
  * The format of this data is that of the icu common data file, as is
  * generated by the pkgdata tool with mode=common or mode=dll.
@@ -340,7 +343,7 @@ udata_getInfo(UDataMemory *pData, UDataInfo *pInfo);
  * @param err outgoing error status <code>U_USING_DEFAULT_WARNING, U_UNSUPPORTED_ERROR</code>
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udata_setCommonData(const void *data, UErrorCode *err);
 
 
@@ -350,7 +353,7 @@ udata_setCommonData(const void *data, UErrorCode *err);
  * pointer.
  *
  * ICU data must be at least 8-aligned, and should be 16-aligned.
- * See http://userguide.icu-project.org/icudata
+ * See https://unicode-org.github.io/icu/userguide/icudata
  *
  * The format of this data is that of the icu common data file, like 'icudt26l.dat'
  * or the corresponding shared library (DLL) file.
@@ -371,7 +374,7 @@ udata_setCommonData(const void *data, UErrorCode *err);
  * @see udata_setCommonData
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udata_setAppData(const char *packageName, const void *data, UErrorCode *err);
 
 /**
@@ -410,7 +413,7 @@ typedef enum UDataFileAccess {
  * @see UDataFileAccess
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udata_setFileAccess(UDataFileAccess access, UErrorCode *status);
 
 U_CDECL_END
diff --git a/deps/icu-small/source/common/unicode/udisplaycontext.h b/deps/icu-small/source/common/unicode/udisplaycontext.h
index 398481c681224785618f5ad12e11b91b093b1074..6e1421798054f633bf39e4bc27077f12a241bcdf 100644
--- a/deps/icu-small/source/common/unicode/udisplaycontext.h
+++ b/deps/icu-small/source/common/unicode/udisplaycontext.h
@@ -156,7 +156,8 @@ enum UDisplayContext {
     UDISPCTX_SUBSTITUTE = (UDISPCTX_TYPE_SUBSTITUTE_HANDLING<<8) + 0,
     /**
      * A possible setting for SUBSTITUTE_HANDLING:
-     * Returns a null value when no data is available.
+     * Returns a null value with error code set to U_ILLEGAL_ARGUMENT_ERROR when no
+     * data is available.
      * @stable ICU 58
      */
     UDISPCTX_NO_SUBSTITUTE = (UDISPCTX_TYPE_SUBSTITUTE_HANDLING<<8) + 1
diff --git a/deps/icu-small/source/common/unicode/uenum.h b/deps/icu-small/source/common/unicode/uenum.h
index eb8ecdf88b6ec531d1cbba8cb54865141ab1bb2b..f1c506934bec87bfbcdc22d0df829f39e7063d4a 100644
--- a/deps/icu-small/source/common/unicode/uenum.h
+++ b/deps/icu-small/source/common/unicode/uenum.h
@@ -20,13 +20,14 @@
 #define __UENUM_H
 
 #include "unicode/utypes.h"
-#include "unicode/localpointer.h"
 
 #if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+
 U_NAMESPACE_BEGIN
 class StringEnumeration;
 U_NAMESPACE_END
-#endif
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -49,7 +50,7 @@ typedef struct UEnumeration UEnumeration;
  * @param en UEnumeration structure pointer
  * @stable ICU 2.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uenum_close(UEnumeration* en);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -85,7 +86,7 @@ U_NAMESPACE_END
  * @return number of elements in the iterator
  * @stable ICU 2.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uenum_count(UEnumeration* en, UErrorCode* status);
 
 /**
@@ -109,7 +110,7 @@ uenum_count(UEnumeration* en, UErrorCode* status);
  *         traversed, returns NULL.
  * @stable ICU 2.2
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 uenum_unext(UEnumeration* en,
             int32_t* resultLength,
             UErrorCode* status);
@@ -142,7 +143,7 @@ uenum_unext(UEnumeration* en,
  *         traversed, returns NULL.
  * @stable ICU 2.2
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uenum_next(UEnumeration* en,
            int32_t* resultLength,
            UErrorCode* status);
@@ -156,7 +157,7 @@ uenum_next(UEnumeration* en,
  *               the iterator is out of sync with its service.
  * @stable ICU 2.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uenum_reset(UEnumeration* en, UErrorCode* status);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -170,7 +171,7 @@ uenum_reset(UEnumeration* en, UErrorCode* status);
  * @return a UEnumeration wrapping the adopted StringEnumeration.
  * @stable ICU 4.2
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uenum_openFromStringEnumeration(icu::StringEnumeration* adopted, UErrorCode* ec);
 
 #endif
@@ -186,7 +187,7 @@ uenum_openFromStringEnumeration(icu::StringEnumeration* adopted, UErrorCode* ec)
  * @see uenum_close
  * @stable ICU 50
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uenum_openUCharStringsEnumeration(const UChar* const strings[], int32_t count,
                                  UErrorCode* ec);
 
@@ -201,7 +202,7 @@ uenum_openUCharStringsEnumeration(const UChar* const strings[], int32_t count,
  * @see uenum_close
  * @stable ICU 50
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uenum_openCharStringsEnumeration(const char* const strings[], int32_t count,
                                  UErrorCode* ec);
 
diff --git a/deps/icu-small/source/common/unicode/uidna.h b/deps/icu-small/source/common/unicode/uidna.h
index cb79ba8545008e26478ceac8d631cebd731614df..1f75562555c3c2d4ee838fc4c7c7c866fb2e4f09 100644
--- a/deps/icu-small/source/common/unicode/uidna.h
+++ b/deps/icu-small/source/common/unicode/uidna.h
@@ -23,9 +23,13 @@
 
 #if !UCONFIG_NO_IDNA
 
-#include "unicode/localpointer.h"
+#include <stdbool.h>
 #include "unicode/parseerr.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: Internationalizing Domain Names in Applications (IDNA)
@@ -138,7 +142,7 @@ typedef struct UIDNA UIDNA;  /**< C typedef for struct UIDNA. @stable ICU 4.6 */
  * @return the UTS #46 UIDNA instance, if successful
  * @stable ICU 4.6
  */
-U_STABLE UIDNA * U_EXPORT2
+U_CAPI UIDNA * U_EXPORT2
 uidna_openUTS46(uint32_t options, UErrorCode *pErrorCode);
 
 /**
@@ -146,7 +150,7 @@ uidna_openUTS46(uint32_t options, UErrorCode *pErrorCode);
  * @param idna UIDNA instance to be closed
  * @stable ICU 4.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uidna_close(UIDNA *idna);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -182,7 +186,7 @@ typedef struct UIDNAInfo {
     /** sizeof(UIDNAInfo) @stable ICU 4.6 */
     int16_t size;
     /**
-     * Set to TRUE if transitional and nontransitional processing produce different results.
+     * Set to true if transitional and nontransitional processing produce different results.
      * For details see C++ IDNAInfo::isTransitionalDifferent().
      * @stable ICU 4.6
      */
@@ -204,7 +208,7 @@ typedef struct UIDNAInfo {
  */
 #define UIDNA_INFO_INITIALIZER { \
     (int16_t)sizeof(UIDNAInfo), \
-    FALSE, FALSE, \
+    false, false, \
     0, 0, 0 }
 
 /**
@@ -230,7 +234,7 @@ typedef struct UIDNAInfo {
  * @return destination string length
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uidna_labelToASCII(const UIDNA *idna,
                    const UChar *label, int32_t length,
                    UChar *dest, int32_t capacity,
@@ -257,7 +261,7 @@ uidna_labelToASCII(const UIDNA *idna,
  * @return destination string length
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uidna_labelToUnicode(const UIDNA *idna,
                      const UChar *label, int32_t length,
                      UChar *dest, int32_t capacity,
@@ -286,7 +290,7 @@ uidna_labelToUnicode(const UIDNA *idna,
  * @return destination string length
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uidna_nameToASCII(const UIDNA *idna,
                   const UChar *name, int32_t length,
                   UChar *dest, int32_t capacity,
@@ -313,7 +317,7 @@ uidna_nameToASCII(const UIDNA *idna,
  * @return destination string length
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uidna_nameToUnicode(const UIDNA *idna,
                     const UChar *name, int32_t length,
                     UChar *dest, int32_t capacity,
@@ -338,7 +342,7 @@ uidna_nameToUnicode(const UIDNA *idna,
  * @return destination string length
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uidna_labelToASCII_UTF8(const UIDNA *idna,
                         const char *label, int32_t length,
                         char *dest, int32_t capacity,
@@ -361,7 +365,7 @@ uidna_labelToASCII_UTF8(const UIDNA *idna,
  * @return destination string length
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uidna_labelToUnicodeUTF8(const UIDNA *idna,
                          const char *label, int32_t length,
                          char *dest, int32_t capacity,
@@ -384,7 +388,7 @@ uidna_labelToUnicodeUTF8(const UIDNA *idna,
  * @return destination string length
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uidna_nameToASCII_UTF8(const UIDNA *idna,
                        const char *name, int32_t length,
                        char *dest, int32_t capacity,
@@ -407,7 +411,7 @@ uidna_nameToASCII_UTF8(const UIDNA *idna,
  * @return destination string length
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uidna_nameToUnicodeUTF8(const UIDNA *idna,
                         const char *name, int32_t length,
                         char *dest, int32_t capacity,
diff --git a/deps/icu-small/source/common/unicode/uiter.h b/deps/icu-small/source/common/unicode/uiter.h
index 3b8537204cecfaa0981fba0e70b0daa341277fbd..7dbe1266668f24ba4735186ac6c8206c0c3c3f69 100644
--- a/deps/icu-small/source/common/unicode/uiter.h
+++ b/deps/icu-small/source/common/unicode/uiter.h
@@ -492,7 +492,7 @@ struct UCharIterator {
  * @see UnicodeString::char32At()
  * @stable ICU 2.1
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 uiter_current32(UCharIterator *iter);
 
 /**
@@ -509,7 +509,7 @@ uiter_current32(UCharIterator *iter);
  * @see U16_NEXT
  * @stable ICU 2.1
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 uiter_next32(UCharIterator *iter);
 
 /**
@@ -526,7 +526,7 @@ uiter_next32(UCharIterator *iter);
  * @see U16_PREV
  * @stable ICU 2.1
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 uiter_previous32(UCharIterator *iter);
 
 /**
@@ -547,7 +547,7 @@ uiter_previous32(UCharIterator *iter);
  * @see UITER_NO_STATE
  * @stable ICU 2.6
  */
-U_STABLE uint32_t U_EXPORT2
+U_CAPI uint32_t U_EXPORT2
 uiter_getState(const UCharIterator *iter);
 
 /**
@@ -565,7 +565,7 @@ uiter_getState(const UCharIterator *iter);
  * @see UCharIteratorSetState
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uiter_setState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode);
 
 /**
@@ -590,7 +590,7 @@ uiter_setState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode);
  * @see UCharIterator
  * @stable ICU 2.1
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uiter_setString(UCharIterator *iter, const UChar *s, int32_t length);
 
 /**
@@ -613,7 +613,7 @@ uiter_setString(UCharIterator *iter, const UChar *s, int32_t length);
  * @see uiter_setString
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uiter_setUTF16BE(UCharIterator *iter, const char *s, int32_t length);
 
 /**
@@ -649,7 +649,7 @@ uiter_setUTF16BE(UCharIterator *iter, const char *s, int32_t length);
  * @see UCharIterator
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uiter_setUTF8(UCharIterator *iter, const char *s, int32_t length);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -674,7 +674,7 @@ uiter_setUTF8(UCharIterator *iter, const char *s, int32_t length);
  * @see UCharIterator
  * @stable ICU 2.1
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uiter_setCharacterIterator(UCharIterator *iter, icu::CharacterIterator *charIter);
 
 /**
@@ -699,7 +699,7 @@ uiter_setCharacterIterator(UCharIterator *iter, icu::CharacterIterator *charIter
  * @see UCharIterator
  * @stable ICU 2.1
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uiter_setReplaceable(UCharIterator *iter, const icu::Replaceable *rep);
 
 #endif
diff --git a/deps/icu-small/source/common/unicode/uldnames.h b/deps/icu-small/source/common/unicode/uldnames.h
index 3a3c0a06573c369f9edd7241f98d191b0c1f72f9..10f0e91e5526e4d8b4818a658972d9e87365e8e6 100644
--- a/deps/icu-small/source/common/unicode/uldnames.h
+++ b/deps/icu-small/source/common/unicode/uldnames.h
@@ -16,10 +16,13 @@
  */
 
 #include "unicode/utypes.h"
-#include "unicode/localpointer.h"
 #include "unicode/uscript.h"
 #include "unicode/udisplaycontext.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * Enum used in LocaleDisplayNames::createInstance.
  * @stable ICU 4.4
@@ -65,7 +68,7 @@ typedef struct ULocaleDisplayNames ULocaleDisplayNames;
  * @param pErrorCode the status code
  * @stable ICU 4.4
  */
-U_STABLE ULocaleDisplayNames * U_EXPORT2
+U_CAPI ULocaleDisplayNames * U_EXPORT2
 uldn_open(const char * locale,
           UDialectHandling dialectHandling,
           UErrorCode *pErrorCode);
@@ -75,7 +78,7 @@ uldn_open(const char * locale,
  * @param ldn the ULocaleDisplayNames instance to be closed
  * @stable ICU 4.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uldn_close(ULocaleDisplayNames *ldn);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -106,7 +109,7 @@ U_NAMESPACE_END
  * @return the display locale
  * @stable ICU 4.4
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 uldn_getLocale(const ULocaleDisplayNames *ldn);
 
 /**
@@ -115,7 +118,7 @@ uldn_getLocale(const ULocaleDisplayNames *ldn);
  * @return the dialect handling enum
  * @stable ICU 4.4
  */
-U_STABLE UDialectHandling U_EXPORT2
+U_CAPI UDialectHandling U_EXPORT2
 uldn_getDialectHandling(const ULocaleDisplayNames *ldn);
 
 /* names for entire locales */
@@ -131,7 +134,7 @@ uldn_getDialectHandling(const ULocaleDisplayNames *ldn);
  * greater than maxResultSize, the returned name will be truncated.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uldn_localeDisplayName(const ULocaleDisplayNames *ldn,
                        const char *locale,
                        UChar *result,
@@ -151,7 +154,7 @@ uldn_localeDisplayName(const ULocaleDisplayNames *ldn,
  * greater than maxResultSize, the returned name will be truncated.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
                          const char *lang,
                          UChar *result,
@@ -169,7 +172,7 @@ uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
  * greater than maxResultSize, the returned name will be truncated.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
                        const char *script,
                        UChar *result,
@@ -187,7 +190,7 @@ uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
  * greater than maxResultSize, the returned name will be truncated.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uldn_scriptCodeDisplayName(const ULocaleDisplayNames *ldn,
                            UScriptCode scriptCode,
                            UChar *result,
@@ -205,7 +208,7 @@ uldn_scriptCodeDisplayName(const ULocaleDisplayNames *ldn,
  * greater than maxResultSize, the returned name will be truncated.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uldn_regionDisplayName(const ULocaleDisplayNames *ldn,
                        const char *region,
                        UChar *result,
@@ -223,7 +226,7 @@ uldn_regionDisplayName(const ULocaleDisplayNames *ldn,
  * greater than maxResultSize, the returned name will be truncated.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
                         const char *variant,
                         UChar *result,
@@ -241,7 +244,7 @@ uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
  * greater than maxResultSize, the returned name will be truncated.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uldn_keyDisplayName(const ULocaleDisplayNames *ldn,
                     const char *key,
                     UChar *result,
@@ -260,7 +263,7 @@ uldn_keyDisplayName(const ULocaleDisplayNames *ldn,
  * greater than maxResultSize, the returned name will be truncated.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uldn_keyValueDisplayName(const ULocaleDisplayNames *ldn,
                          const char *key,
                          const char *value,
@@ -282,7 +285,7 @@ uldn_keyValueDisplayName(const ULocaleDisplayNames *ldn,
 * @return a ULocaleDisplayNames instance
 * @stable ICU 51
 */
-U_STABLE ULocaleDisplayNames * U_EXPORT2
+U_CAPI ULocaleDisplayNames * U_EXPORT2
 uldn_openForContext(const char * locale, UDisplayContext *contexts,
                     int32_t length, UErrorCode *pErrorCode);
 
@@ -296,7 +299,7 @@ uldn_openForContext(const char * locale, UDisplayContext *contexts,
 * @return the UDisplayContextValue for the specified type.
 * @stable ICU 51
 */
-U_STABLE UDisplayContext U_EXPORT2
+U_CAPI UDisplayContext U_EXPORT2
 uldn_getContext(const ULocaleDisplayNames *ldn, UDisplayContextType type,
                 UErrorCode *pErrorCode);
 
diff --git a/deps/icu-small/source/common/unicode/uloc.h b/deps/icu-small/source/common/unicode/uloc.h
index a10ab526cec141171e76737bec75428ff0713397..56fb4c9b3769e0744385e668ae8f2a63792f3737 100644
--- a/deps/icu-small/source/common/unicode/uloc.h
+++ b/deps/icu-small/source/common/unicode/uloc.h
@@ -371,7 +371,7 @@ typedef enum {
  * @system
  * @stable ICU 2.0
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uloc_getDefault(void);
 
 /**
@@ -391,7 +391,7 @@ uloc_getDefault(void);
  * @system
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uloc_setDefault(const char* localeID,
         UErrorCode*       status);
 #endif  /* U_HIDE_SYSTEM_API */
@@ -408,7 +408,7 @@ uloc_setDefault(const char* localeID,
  * than languageCapacity, the returned language code will be truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getLanguage(const char*    localeID,
          char* language,
          int32_t languageCapacity,
@@ -426,7 +426,7 @@ uloc_getLanguage(const char*    localeID,
  * than scriptCapacity, the returned language code will be truncated.
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getScript(const char*    localeID,
          char* script,
          int32_t scriptCapacity,
@@ -444,7 +444,7 @@ uloc_getScript(const char*    localeID,
  * than countryCapacity, the returned country code will be truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getCountry(const char*    localeID,
         char* country,
         int32_t countryCapacity,
@@ -462,7 +462,7 @@ uloc_getCountry(const char*    localeID,
  * than variantCapacity, the returned variant code will be truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getVariant(const char*    localeID,
         char* variant,
         int32_t variantCapacity,
@@ -485,7 +485,7 @@ uloc_getVariant(const char*    localeID,
  * than nameCapacity, the returned full name will be truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getName(const char*    localeID,
          char* name,
          int32_t nameCapacity,
@@ -508,7 +508,7 @@ uloc_getName(const char*    localeID,
  * than nameCapacity, the returned full name will be truncated.
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_canonicalize(const char*    localeID,
          char* name,
          int32_t nameCapacity,
@@ -521,7 +521,7 @@ uloc_canonicalize(const char*    localeID,
  * @return language the ISO language code for localeID
  * @stable ICU 2.0
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uloc_getISO3Language(const char* localeID);
 
 
@@ -532,7 +532,7 @@ uloc_getISO3Language(const char* localeID);
  * @return country the ISO country code for localeID
  * @stable ICU 2.0
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uloc_getISO3Country(const char* localeID);
 
 /**
@@ -546,26 +546,31 @@ uloc_getISO3Country(const char* localeID);
  * @return country the Win32 LCID for localeID
  * @stable ICU 2.0
  */
-U_STABLE uint32_t U_EXPORT2
+U_CAPI uint32_t U_EXPORT2
 uloc_getLCID(const char* localeID);
 
 /**
  * Gets the language name suitable for display for the specified locale.
  *
  * @param locale the locale to get the ISO language code with
- * @param displayLocale Specifies the locale to be used to display the name.  In other words,
- *                 if the locale's language code is "en", passing Locale::getFrench() for
- *                 inLocale would result in "Anglais", while passing Locale::getGerman()
- *                 for inLocale would result in "Englisch".
+ * @param displayLocale Specifies the locale to be used to display the name. In
+ *                 other words, if the locale's language code is "en", passing
+ *                 Locale::getFrench() for inLocale would result in "Anglais",
+ *                 while passing Locale::getGerman() for inLocale would result
+ *                 in "Englisch".
  * @param language the displayable language code for localeID
  * @param languageCapacity the size of the language buffer to store the
- * displayable language code with
- * @param status error information if retrieving the displayable language code failed
- * @return the actual buffer size needed for the displayable language code.  If it's greater
- * than languageCapacity, the returned language code will be truncated.
+ *                 displayable language code with.
+ * @param status error information if retrieving the displayable language code
+ *                 failed. U_USING_DEFAULT_WARNING indicates that no data was
+ *                 found from the locale resources and a case canonicalized
+ *                 language code is placed into language as fallback.
+ * @return the actual buffer size needed for the displayable language code. If
+ *                 it's greater than languageCapacity, the returned language
+ *                 code will be truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getDisplayLanguage(const char* locale,
             const char* displayLocale,
             UChar* language,
@@ -575,20 +580,26 @@ uloc_getDisplayLanguage(const char* locale,
 /**
  * Gets the script name suitable for display for the specified locale.
  *
- * @param locale the locale to get the displayable script code with. NULL may be used to specify the default.
- * @param displayLocale Specifies the locale to be used to display the name.  In other words,
- *                 if the locale's language code is "en", passing Locale::getFrench() for
- *                 inLocale would result in "", while passing Locale::getGerman()
- *                 for inLocale would result in "". NULL may be used to specify the default.
- * @param script the displayable script for the localeID
- * @param scriptCapacity the size of the script buffer to store the
- * displayable script code with
- * @param status error information if retrieving the displayable script code failed
- * @return the actual buffer size needed for the displayable script code.  If it's greater
- * than scriptCapacity, the returned displayable script code will be truncated.
+ * @param locale the locale to get the displayable script code with. NULL may be
+ *                 used to specify the default.
+ * @param displayLocale Specifies the locale to be used to display the name. In
+ *                 other words, if the locale's language code is "en", passing
+ *                 Locale::getFrench() for inLocale would result in "", while
+ *                 passing Locale::getGerman() for inLocale would result in "".
+ *                 NULL may be used to specify the default.
+ * @param script the displayable script for the localeID.
+ * @param scriptCapacity the size of the script buffer to store the displayable
+ *                 script code with.
+ * @param status error information if retrieving the displayable script code
+ *                 failed. U_USING_DEFAULT_WARNING indicates that no data was
+ *                 found from the locale resources and a case canonicalized
+ *                 script code is placed into script as fallback.
+ * @return the actual buffer size needed for the displayable script code. If
+ *                 it's greater than scriptCapacity, the returned displayable
+ *                 script code will be truncated.
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getDisplayScript(const char* locale,
             const char* displayLocale,
             UChar* script,
@@ -597,23 +608,30 @@ uloc_getDisplayScript(const char* locale,
 
 /**
  * Gets the country name suitable for display for the specified locale.
- * Warning: this is for the region part of a valid locale ID; it cannot just be the region code (like "FR").
- * To get the display name for a region alone, or for other options, use ULocaleDisplayNames instead.
- *
- * @param locale the locale to get the displayable country code with. NULL may be used to specify the default.
- * @param displayLocale Specifies the locale to be used to display the name.  In other words,
- *                 if the locale's language code is "en", passing Locale::getFrench() for
- *                 inLocale would result in "Anglais", while passing Locale::getGerman()
- *                 for inLocale would result in "Englisch". NULL may be used to specify the default.
- * @param country the displayable country code for localeID
+ * Warning: this is for the region part of a valid locale ID; it cannot just be
+ * the region code (like "FR"). To get the display name for a region alone, or
+ * for other options, use ULocaleDisplayNames instead.
+ *
+ * @param locale the locale to get the displayable country code with. NULL may
+ *                 be used to specify the default.
+ * @param displayLocale Specifies the locale to be used to display the name. In
+ *                 other words, if the locale's language code is "en", passing
+ *                 Locale::getFrench() for inLocale would result in "Anglais",
+ *                 while passing Locale::getGerman() for inLocale would result
+ *                 in "Englisch". NULL may be used to specify the default.
+ * @param country the displayable country code for localeID.
  * @param countryCapacity the size of the country buffer to store the
- * displayable country code with
- * @param status error information if retrieving the displayable country code failed
- * @return the actual buffer size needed for the displayable country code.  If it's greater
- * than countryCapacity, the returned displayable country code will be truncated.
+ *                 displayable country code with.
+ * @param status error information if retrieving the displayable country code
+ *                 failed. U_USING_DEFAULT_WARNING indicates that no data was
+ *                 found from the locale resources and a case canonicalized
+ *                 country code is placed into country as fallback.
+ * @return the actual buffer size needed for the displayable country code. If
+ *                 it's greater than countryCapacity, the returned displayable
+ *                 country code will be truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getDisplayCountry(const char* locale,
                        const char* displayLocale,
                        UChar* country,
@@ -624,20 +642,26 @@ uloc_getDisplayCountry(const char* locale,
 /**
  * Gets the variant name suitable for display for the specified locale.
  *
- * @param locale the locale to get the displayable variant code with. NULL may be used to specify the default.
- * @param displayLocale Specifies the locale to be used to display the name.  In other words,
- *                 if the locale's language code is "en", passing Locale::getFrench() for
- *                 inLocale would result in "Anglais", while passing Locale::getGerman()
- *                 for inLocale would result in "Englisch". NULL may be used to specify the default.
- * @param variant the displayable variant code for localeID
+ * @param locale the locale to get the displayable variant code with. NULL may
+ *                 be used to specify the default.
+ * @param displayLocale Specifies the locale to be used to display the name. In
+ *                 other words, if the locale's language code is "en", passing
+ *                 Locale::getFrench() for inLocale would result in "Anglais",
+ *                 while passing Locale::getGerman() for inLocale would result
+ *                 in "Englisch". NULL may be used to specify the default.
+ * @param variant the displayable variant code for localeID.
  * @param variantCapacity the size of the variant buffer to store the
- * displayable variant code with
- * @param status error information if retrieving the displayable variant code failed
- * @return the actual buffer size needed for the displayable variant code.  If it's greater
- * than variantCapacity, the returned displayable variant code will be truncated.
+ *                 displayable variant code with.
+ * @param status error information if retrieving the displayable variant code
+ *                 failed. U_USING_DEFAULT_WARNING indicates that no data was
+ *                 found from the locale resources and a case canonicalized
+ *                 variant code is placed into variant as fallback.
+ * @return the actual buffer size needed for the displayable variant code. If
+ *                 it's greater than variantCapacity, the returned displayable
+ *                 variant code will be truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getDisplayVariant(const char* locale,
                        const char* displayLocale,
                        UChar* variant,
@@ -645,8 +669,8 @@ uloc_getDisplayVariant(const char* locale,
                        UErrorCode* status);
 
 /**
- * Gets the keyword name suitable for display for the specified locale.
- * E.g: for the locale string de_DE\@collation=PHONEBOOK, this API gets the display
+ * Gets the keyword name suitable for display for the specified locale. E.g:
+ * for the locale string de_DE\@collation=PHONEBOOK, this API gets the display
  * string for the keyword collation.
  * Usage:
  * <code>
@@ -680,11 +704,13 @@ uloc_getDisplayVariant(const char* locale,
  *                          result without writing any of the result string (pre-flighting).
  * @param status            error information if retrieving the displayable string failed.
  *                          Should not be NULL and should not indicate failure on entry.
+ *                          U_USING_DEFAULT_WARNING indicates that no data was found from the locale
+ *                          resources and the keyword is placed into dest as fallback.
  * @return the actual buffer size needed for the displayable variant code.
  * @see #uloc_openKeywords
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getDisplayKeyword(const char* keyword,
                        const char* displayLocale,
                        UChar* dest,
@@ -707,10 +733,12 @@ uloc_getDisplayKeyword(const char* keyword,
  *                          result without writing any of the result string (pre-flighting).
  * @param status            error information if retrieving the displayable string failed.
  *                          Should not be NULL and must not indicate failure on entry.
+ *                          U_USING_DEFAULT_WARNING indicates that no data was found from the locale
+ *                          resources and the value of the keyword is placed into dest as fallback.
  * @return the actual buffer size needed for the displayable variant code.
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getDisplayKeywordValue(   const char* locale,
                                const char* keyword,
                                const char* displayLocale,
@@ -733,7 +761,7 @@ uloc_getDisplayKeywordValue(   const char* locale,
  * than maxResultSize, the returned displayable name will be truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getDisplayName(const char* localeID,
             const char* inLocaleID,
             UChar* result,
@@ -757,7 +785,7 @@ uloc_getDisplayName(const char* localeID,
  * @return a specified locale name of all available locales
  * @stable ICU 2.0
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uloc_getAvailable(int32_t n);
 
 /**
@@ -766,21 +794,19 @@ uloc_getAvailable(int32_t n);
  * @return the size of the locale list
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2 uloc_countAvailable(void);
-
-#ifndef U_HIDE_DRAFT_API
+U_CAPI int32_t U_EXPORT2 uloc_countAvailable(void);
 
 /**
  * Types for uloc_getAvailableByType and uloc_countAvailableByType.
  *
- * @draft ICU 65
+ * @stable ICU 65
  */
 typedef enum ULocAvailableType {
   /**
    * Locales that return data when passed to ICU APIs,
    * but not including legacy or alias locales.
    *
-   * @draft ICU 65
+   * @stable ICU 65
    */
   ULOC_AVAILABLE_DEFAULT,
 
@@ -798,7 +824,7 @@ typedef enum ULocAvailableType {
    * ULOC_AVAILABLE_DEFAULT. To get both sets at the same time, use
    * ULOC_AVAILABLE_WITH_LEGACY_ALIASES.
    *
-   * @draft ICU 65
+   * @stable ICU 65
    */
   ULOC_AVAILABLE_ONLY_LEGACY_ALIASES,
 
@@ -806,7 +832,7 @@ typedef enum ULocAvailableType {
    * The union of the locales in ULOC_AVAILABLE_DEFAULT and
    * ULOC_AVAILABLE_ONLY_LEGACY_ALIAS.
    *
-   * @draft ICU 65
+   * @stable ICU 65
    */
   ULOC_AVAILABLE_WITH_LEGACY_ALIASES,
 
@@ -827,13 +853,11 @@ typedef enum ULocAvailableType {
  * @param type Type choice from ULocAvailableType.
  * @param status Set if an error occurred.
  * @return a UEnumeration owned by the caller, or nullptr on failure.
- * @draft ICU 65
+ * @stable ICU 65
  */
-U_DRAFT UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uloc_openAvailableByType(ULocAvailableType type, UErrorCode* status);
 
-#endif // U_HIDE_DRAFT_API
-
 /**
  *
  * Gets a list of all available 2-letter language codes defined in ISO 639,
@@ -845,7 +869,7 @@ uloc_openAvailableByType(ULocAvailableType type, UErrorCode* status);
  * @return a list of all available language codes
  * @stable ICU 2.0
  */
-U_STABLE const char* const* U_EXPORT2
+U_CAPI const char* const* U_EXPORT2
 uloc_getISOLanguages(void);
 
 /**
@@ -857,7 +881,7 @@ uloc_getISOLanguages(void);
  * @return a list of all available country codes
  * @stable ICU 2.0
  */
-U_STABLE const char* const* U_EXPORT2
+U_CAPI const char* const* U_EXPORT2
 uloc_getISOCountries(void);
 
 /**
@@ -873,7 +897,7 @@ uloc_getISOCountries(void);
  * @return The length of the parent locale ID.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getParent(const char*    localeID,
                  char* parent,
                  int32_t parentCapacity,
@@ -904,7 +928,7 @@ uloc_getParent(const char*    localeID,
  * than nameCapacity, the returned full name will be truncated.
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getBaseName(const char*    localeID,
          char* name,
          int32_t nameCapacity,
@@ -919,7 +943,7 @@ uloc_getBaseName(const char*    localeID,
  * @return enumeration of keywords or NULL if there are no keywords.
  * @stable ICU 2.8
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uloc_openKeywords(const char* localeID,
                         UErrorCode* status);
 
@@ -936,7 +960,7 @@ uloc_openKeywords(const char* localeID,
  * @return the length of keyword value
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getKeywordValue(const char* localeID,
                      const char* keywordName,
                      char* buffer, int32_t bufferCapacity,
@@ -973,7 +997,7 @@ uloc_getKeywordValue(const char* localeID,
  * @see uloc_getKeywordValue
  * @stable ICU 3.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_setKeywordValue(const char* keywordName,
                      const char* keywordValue,
                      char* buffer, int32_t bufferCapacity,
@@ -982,18 +1006,18 @@ uloc_setKeywordValue(const char* keywordName,
 /**
  * Returns whether the locale's script is written right-to-left.
  * If there is no script subtag, then the likely script is used, see uloc_addLikelySubtags().
- * If no likely script is known, then FALSE is returned.
+ * If no likely script is known, then false is returned.
  *
  * A script is right-to-left according to the CLDR script metadata
  * which corresponds to whether the script's letters have Bidi_Class=R or AL.
  *
- * Returns TRUE for "ar" and "en-Hebr", FALSE for "zh" and "fa-Cyrl".
+ * Returns true for "ar" and "en-Hebr", false for "zh" and "fa-Cyrl".
  *
  * @param locale input locale ID
- * @return TRUE if the locale's script is written right-to-left
+ * @return true if the locale's script is written right-to-left
  * @stable ICU 54
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uloc_isRightToLeft(const char *locale);
 
 /**
@@ -1017,7 +1041,7 @@ typedef enum {
  * @return an enum indicating the layout orientation for characters.
  * @stable ICU 4.0
  */
-U_STABLE ULayoutType U_EXPORT2
+U_CAPI ULayoutType U_EXPORT2
 uloc_getCharacterOrientation(const char* localeId,
                              UErrorCode *status);
 
@@ -1029,7 +1053,7 @@ uloc_getCharacterOrientation(const char* localeId,
  * @return an enum indicating the layout orientation for lines.
  * @stable ICU 4.0
  */
-U_STABLE ULayoutType U_EXPORT2
+U_CAPI ULayoutType U_EXPORT2
 uloc_getLineOrientation(const char* localeId,
                         UErrorCode *status);
 
@@ -1076,7 +1100,7 @@ typedef enum {
  * @return length needed for the locale.
  * @stable ICU 3.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_acceptLanguageFromHTTP(char *result, int32_t resultAvailable,
                             UAcceptResult *outResult,
                             const char *httpAcceptLanguage,
@@ -1101,7 +1125,7 @@ uloc_acceptLanguageFromHTTP(char *result, int32_t resultAvailable,
  * @return length needed for the locale.
  * @stable ICU 3.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_acceptLanguage(char *result, int32_t resultAvailable,
                     UAcceptResult *outResult, const char **acceptList,
                     int32_t acceptListCount,
@@ -1121,7 +1145,7 @@ uloc_acceptLanguage(char *result, int32_t resultAvailable,
  * @return actual the actual size of the locale ID, not including NUL-termination
  * @stable ICU 3.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_getLocaleForLCID(uint32_t hostID, char *locale, int32_t localeCapacity,
                     UErrorCode *status);
 
@@ -1159,7 +1183,7 @@ uloc_getLocaleForLCID(uint32_t hostID, char *locale, int32_t localeCapacity,
  * On error, the return value is -1.
  * @stable ICU 4.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_addLikelySubtags(const char*    localeID,
          char* maximizedLocaleID,
          int32_t maximizedLocaleIDCapacity,
@@ -1199,7 +1223,7 @@ uloc_addLikelySubtags(const char*    localeID,
  * On error, the return value is -1.
  * @stable ICU 4.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_minimizeSubtags(const char*    localeID,
          char* minimizedLocaleID,
          int32_t minimizedLocaleIDCapacity,
@@ -1210,13 +1234,17 @@ uloc_minimizeSubtags(const char*    localeID,
  * If the specified language tag contains any ill-formed subtags,
  * the first such subtag and all following subtags are ignored.
  * <p>
- * This implements the 'Language-Tag' production of BCP47, and so
- * supports grandfathered (regular and irregular) as well as private
- * use language tags.  Private use tags are represented as 'x-whatever',
- * and grandfathered tags are converted to their canonical replacements
- * where they exist.  Note that a few grandfathered tags have no modern
- * replacement, these will be converted using the fallback described in
+ * This implements the 'Language-Tag' production of BCP 47, and so
+ * supports legacy language tags (marked as “Type: grandfathered” in BCP 47)
+ * (regular and irregular) as well as private use language tags.
+ *
+ * Private use tags are represented as 'x-whatever',
+ * and legacy tags are converted to their canonical replacements where they exist.
+ *
+ * Note that a few legacy tags have no modern replacement;
+ * these will be converted using the fallback described in
  * the first paragraph, so some information might be lost.
+ *
  * @param langtag   the input BCP47 language tag.
  * @param localeID  the output buffer receiving a locale ID for the
  *                  specified BCP47 language tag.
@@ -1228,7 +1256,7 @@ uloc_minimizeSubtags(const char*    localeID,
  * @return          the length of the locale ID.
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_forLanguageTag(const char* langtag,
                     char* localeID,
                     int32_t localeIDCapacity,
@@ -1238,10 +1266,10 @@ uloc_forLanguageTag(const char* langtag,
 /**
  * Returns a well-formed language tag for this locale ID.
  * <p>
- * <b>Note</b>: When <code>strict</code> is FALSE, any locale
+ * <b>Note</b>: When <code>strict</code> is false, any locale
  * fields which do not satisfy the BCP47 syntax requirement will
  * be omitted from the result.  When <code>strict</code> is
- * TRUE, this function sets U_ILLEGAL_ARGUMENT_ERROR to the
+ * true, this function sets U_ILLEGAL_ARGUMENT_ERROR to the
  * <code>err</code> if any locale fields do not satisfy the
  * BCP47 syntax requirement.
  * @param localeID  the input locale ID
@@ -1256,7 +1284,7 @@ uloc_forLanguageTag(const char* langtag,
  * @return          The length of the BCP47 language tag.
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uloc_toLanguageTag(const char* localeID,
                    char* langtag,
                    int32_t langtagCapacity,
@@ -1284,7 +1312,7 @@ uloc_toLanguageTag(const char* localeID,
  * @see uloc_toLegacyKey
  * @stable ICU 54
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uloc_toUnicodeLocaleKey(const char* keyword);
 
 /**
@@ -1315,7 +1343,7 @@ uloc_toUnicodeLocaleKey(const char* keyword);
  * @see uloc_toLegacyType
  * @stable ICU 54
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uloc_toUnicodeLocaleType(const char* keyword, const char* value);
 
 /**
@@ -1330,7 +1358,7 @@ uloc_toUnicodeLocaleType(const char* keyword, const char* value);
  * @see toUnicodeLocaleKey
  * @stable ICU 54
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uloc_toLegacyKey(const char* keyword);
 
 /**
@@ -1359,7 +1387,7 @@ uloc_toLegacyKey(const char* keyword);
  * @see toUnicodeLocaleType
  * @stable ICU 54
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uloc_toLegacyType(const char* keyword, const char* value);
 
 #endif /*_ULOC*/
diff --git a/deps/icu-small/source/common/unicode/umachine.h b/deps/icu-small/source/common/unicode/umachine.h
index ff5deb8d01786ae720f552049b557391b2bfe9ed..219d1ee1911d02cdffb49839313c766379457b36 100644
--- a/deps/icu-small/source/common/unicode/umachine.h
+++ b/deps/icu-small/source/common/unicode/umachine.h
@@ -49,12 +49,13 @@
  * ANSI C headers:
  * stddef.h defines wchar_t
  */
+#include <stdbool.h>
 #include <stddef.h>
 
 /*==========================================================================*/
-/* For C wrappers, we use the symbol U_STABLE.                                */
+/* For C wrappers, we use the symbol U_CAPI.                                */
 /* This works properly if the includer is C or C++.                         */
-/* Functions are declared   U_STABLE return-type U_EXPORT2 function-name()... */
+/* Functions are declared   U_CAPI return-type U_EXPORT2 function-name()... */
 /*==========================================================================*/
 
 /**
@@ -107,15 +108,15 @@
 
 /** This is used to declare a function as a public ICU C API @stable ICU 2.0*/
 #define U_CAPI U_CFUNC U_EXPORT
-/** This is used to declare a function as a stable public ICU C API*/
+/** Obsolete/same as U_CAPI; was used to declare a function as a stable public ICU C API*/
 #define U_STABLE U_CAPI
-/** This is used to declare a function as a draft public ICU C API  */
+/** Obsolete/same as U_CAPI; was used to declare a function as a draft public ICU C API  */
 #define U_DRAFT  U_CAPI
 /** This is used to declare a function as a deprecated public ICU C API  */
 #define U_DEPRECATED U_CAPI U_ATTRIBUTE_DEPRECATED
-/** This is used to declare a function as an obsolete public ICU C API  */
+/** Obsolete/same as U_CAPI; was used to declare a function as an obsolete public ICU C API  */
 #define U_OBSOLETE U_CAPI
-/** This is used to declare a function as an internal ICU C API  */
+/** Obsolete/same as U_CAPI; was used to declare a function as an internal ICU C API  */
 #define U_INTERNAL U_CAPI
 
 /**
@@ -170,11 +171,11 @@
 
 /**
  * \def UPRV_BLOCK_MACRO_END
- * Defined as "while (FALSE)" by default.
+ * Defined as "while (false)" by default.
  * @internal
  */
 #ifndef UPRV_BLOCK_MACRO_END
-#define UPRV_BLOCK_MACRO_END while (FALSE)
+#define UPRV_BLOCK_MACRO_END while (false)
 #endif
 
 /*==========================================================================*/
@@ -257,18 +258,59 @@
 /* Boolean data type                                                        */
 /*==========================================================================*/
 
-/** The ICU boolean type @stable ICU 2.0 */
+/**
+ * The ICU boolean type, a signed-byte integer.
+ * ICU-specific for historical reasons: The C and C++ standards used to not define type bool.
+ * Also provides a fixed type definition, as opposed to
+ * type bool whose details (e.g., sizeof) may vary by compiler and between C and C++.
+ *
+ * @stable ICU 2.0
+ */
 typedef int8_t UBool;
 
+/**
+ * \def U_DEFINE_FALSE_AND_TRUE
+ * Normally turns off defining macros FALSE=0 & TRUE=1 in public ICU headers.
+ * These obsolete macros sometimes break compilation of other code that
+ * defines enum constants or similar with these names.
+ * C++ has long defined bool/false/true.
+ * C99 also added definitions for these, although as macros; see stdbool.h.
+ *
+ * You may transitionally define U_DEFINE_FALSE_AND_TRUE=1 if you need time to migrate code.
+ *
+ * @internal ICU 68
+ */
+#ifdef U_DEFINE_FALSE_AND_TRUE
+    // Use the predefined value.
+#elif defined(U_COMBINED_IMPLEMENTATION) || \
+        defined(U_COMMON_IMPLEMENTATION) || defined(U_I18N_IMPLEMENTATION) || \
+        defined(U_IO_IMPLEMENTATION) || defined(U_LAYOUTEX_IMPLEMENTATION) || \
+        defined(U_TOOLUTIL_IMPLEMENTATION)
+    // Inside ICU: Keep FALSE & TRUE available.
+#   define U_DEFINE_FALSE_AND_TRUE 1
+#else
+    // Outside ICU: Avoid collision with non-macro definitions of FALSE & TRUE.
+#   define U_DEFINE_FALSE_AND_TRUE 0
+#endif
+
+#if U_DEFINE_FALSE_AND_TRUE || defined(U_IN_DOXYGEN)
 #ifndef TRUE
-/** The TRUE value of a UBool @stable ICU 2.0 */
+/**
+ * The TRUE value of a UBool.
+ *
+ * @deprecated ICU 68 Use standard "true" instead.
+ */
 #   define TRUE  1
 #endif
 #ifndef FALSE
-/** The FALSE value of a UBool @stable ICU 2.0 */
+/**
+ * The FALSE value of a UBool.
+ *
+ * @deprecated ICU 68 Use standard "false" instead.
+ */
 #   define FALSE 0
 #endif
-
+#endif  // U_DEFINE_FALSE_AND_TRUE
 
 /*==========================================================================*/
 /* Unicode data types                                                       */
diff --git a/deps/icu-small/source/common/unicode/umutablecptrie.h b/deps/icu-small/source/common/unicode/umutablecptrie.h
index f2af36477d53001ff963a1a6ce3ff7c824229cb2..5325d58147ab1f218d6f8f34d3b514988c591000 100644
--- a/deps/icu-small/source/common/unicode/umutablecptrie.h
+++ b/deps/icu-small/source/common/unicode/umutablecptrie.h
@@ -9,11 +9,14 @@
 
 #include "unicode/utypes.h"
 
-#include "unicode/localpointer.h"
 #include "unicode/ucpmap.h"
 #include "unicode/ucptrie.h"
 #include "unicode/utf8.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 U_CDECL_BEGIN
 
 /**
diff --git a/deps/icu-small/source/common/unicode/unifilt.h b/deps/icu-small/source/common/unicode/unifilt.h
index 1a77089233bf100e3216bafaf7d0a47b1ce180b6..b0789d2e88fb91499a28fea7c7fd40c27771e29e 100644
--- a/deps/icu-small/source/common/unicode/unifilt.h
+++ b/deps/icu-small/source/common/unicode/unifilt.h
@@ -40,8 +40,8 @@ U_NAMESPACE_BEGIN
  *
  * <code>UnicodeFilter</code> defines a protocol for selecting a
  * subset of the full range (U+0000 to U+10FFFF) of Unicode characters.
- * Currently, filters are used in conjunction with classes like {@link
- * Transliterator} to only process selected characters through a
+ * Currently, filters are used in conjunction with classes like
+ * {@link Transliterator} to only process selected characters through a
  * transformation.
  *
  * <p>Note: UnicodeFilter currently stubs out two pure virtual methods
diff --git a/deps/icu-small/source/common/unicode/unimatch.h b/deps/icu-small/source/common/unicode/unimatch.h
index 2d3c5210c38e258b9cd6bf7d9f5aede20412c115..10efd3d007a5cac49227f6357491c20c81b30791 100644
--- a/deps/icu-small/source/common/unicode/unimatch.h
+++ b/deps/icu-small/source/common/unicode/unimatch.h
@@ -115,11 +115,11 @@ public:
      * considered for matching will be text.charAt(limit-1) in the
      * forward direction or text.charAt(limit+1) in the backward
      * direction.
-     * @param incremental if TRUE, then assume further characters may
+     * @param incremental if true, then assume further characters may
      * be inserted at limit and check for partial matching.  Otherwise
      * assume the text as given is complete.
      * @return a match degree value indicating a full match, a partial
-     * match, or a mismatch.  If incremental is FALSE then
+     * match, or a mismatch.  If incremental is false then
      * U_PARTIAL_MATCH should never be returned.
      * @stable ICU 2.4
      */
@@ -134,17 +134,17 @@ public:
      * will produce another matcher that is equal to this one.
      * @param result the string to receive the pattern.  Previous
      * contents will be deleted.
-     * @param escapeUnprintable if TRUE then convert unprintable
+     * @param escapeUnprintable if true then convert unprintable
      * character to their hex escape representations, \\uxxxx or
      * \\Uxxxxxxxx.  Unprintable characters are those other than
      * U+000A, U+0020..U+007E.
      * @stable ICU 2.4
      */
     virtual UnicodeString& toPattern(UnicodeString& result,
-                                     UBool escapeUnprintable = FALSE) const = 0;
+                                     UBool escapeUnprintable = false) const = 0;
 
     /**
-     * Returns TRUE if this matcher will match a character c, where c
+     * Returns true if this matcher will match a character c, where c
      * & 0xFF == v, at offset, in the forward direction (with limit >
      * offset).  This is used by <tt>RuleBasedTransliterator</tt> for
      * indexing.
diff --git a/deps/icu-small/source/common/unicode/uniset.h b/deps/icu-small/source/common/unicode/uniset.h
index 18cc9376442a2fc6de43d8437ca77484446c7020..7344a29a89b0177b6773d346e64ff1c181f56959 100644
--- a/deps/icu-small/source/common/unicode/uniset.h
+++ b/deps/icu-small/source/common/unicode/uniset.h
@@ -178,8 +178,6 @@ class RuleCharacterIterator;
  * Unicode property
  * </table>
  *
- * <p><b>Warning</b>: you cannot add an empty string ("") to a UnicodeSet.</p>
- *
  * <p><b>Formal syntax</b></p>
  *
  * \htmlonly<blockquote>\endhtmlonly
@@ -325,7 +323,7 @@ public:
      * A bogus set has no value. It is different from an empty set.
      * It can be used to indicate that no set value is available.
      *
-     * @return TRUE if the set is bogus/invalid, FALSE otherwise
+     * @return true if the set is bogus/invalid, false otherwise
      * @see setToBogus()
      * @stable ICU 4.0
      */
@@ -333,7 +331,7 @@ public:
 
     /**
      * Make this UnicodeSet object invalid.
-     * The string will test TRUE with isBogus().
+     * The string will test true with isBogus().
      *
      * A bogus set has no value. It is different from an empty set.
      * It can be used to indicate that no set value is available.
@@ -563,7 +561,7 @@ public:
     /**
      * Determines whether the set has been frozen (made immutable) or not.
      * See the ICU4J Freezable interface for details.
-     * @return TRUE/FALSE for whether the set has been frozen
+     * @return true/false for whether the set has been frozen
      * @see freeze
      * @see cloneAsThawed
      * @stable ICU 3.8
@@ -601,7 +599,7 @@ public:
 
     /**
      * Make this object represent the range `start - end`.
-     * If `end > start` then this object is set to an empty range.
+     * If `start > end` then this object is set to an empty range.
      * A frozen set will not be modified.
      *
      * @param start first character in the set, inclusive
@@ -700,14 +698,14 @@ public:
      * A frozen set will not be modified.
      * @param result the string to receive the rules.  Previous
      * contents will be deleted.
-     * @param escapeUnprintable if TRUE then convert unprintable
+     * @param escapeUnprintable if true then convert unprintable
      * character to their hex escape representations, \\uxxxx or
      * \\Uxxxxxxxx.  Unprintable characters are those other than
      * U+000A, U+0020..U+007E.
      * @stable ICU 2.0
      */
     virtual UnicodeString& toPattern(UnicodeString& result,
-                             UBool escapeUnprintable = FALSE) const;
+                                     UBool escapeUnprintable = false) const;
 
     /**
      * Modifies this set to contain those code points which have the given value
@@ -1077,7 +1075,7 @@ public:
     /**
      * Adds the specified range to this set if it is not already
      * present.  If this set already contains the specified range,
-     * the call leaves this set unchanged.  If <code>end > start</code>
+     * the call leaves this set unchanged.  If <code>start > end</code>
      * then an empty range is added, leaving the set unchanged.
      * This is equivalent to a boolean logic OR, or a set UNION.
      * A frozen set will not be modified.
@@ -1095,6 +1093,9 @@ public:
      * present.  If this set already contains the specified character,
      * the call leaves this set unchanged.
      * A frozen set will not be modified.
+     *
+     * @param c the character (code point)
+     * @return this object, for chaining
      * @stable ICU 2.0
      */
     UnicodeSet& add(UChar32 c);
@@ -1104,8 +1105,8 @@ public:
      * present.  If this set already contains the multicharacter,
      * the call leaves this set unchanged.
      * Thus "ch" => {"ch"}
-     * <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
      * A frozen set will not be modified.
+     *
      * @param s the source string
      * @return this object, for chaining
      * @stable ICU 2.4
@@ -1124,8 +1125,8 @@ public:
 
  public:
     /**
-     * Adds each of the characters in this string to the set. Thus "ch" => {"c", "h"}
-     * If this set already any particular character, it has no effect on that character.
+     * Adds each of the characters in this string to the set. Note: "ch" => {"c", "h"}
+     * If this set already contains any particular character, it has no effect on that character.
      * A frozen set will not be modified.
      * @param s the source string
      * @return this object, for chaining
@@ -1135,7 +1136,6 @@ public:
 
     /**
      * Retains EACH of the characters in this string. Note: "ch" == {"c", "h"}
-     * If this set already any particular character, it has no effect on that character.
      * A frozen set will not be modified.
      * @param s the source string
      * @return this object, for chaining
@@ -1145,7 +1145,6 @@ public:
 
     /**
      * Complement EACH of the characters in this string. Note: "ch" == {"c", "h"}
-     * If this set already any particular character, it has no effect on that character.
      * A frozen set will not be modified.
      * @param s the source string
      * @return this object, for chaining
@@ -1155,7 +1154,6 @@ public:
 
     /**
      * Remove EACH of the characters in this string. Note: "ch" == {"c", "h"}
-     * If this set already any particular character, it has no effect on that character.
      * A frozen set will not be modified.
      * @param s the source string
      * @return this object, for chaining
@@ -1165,7 +1163,7 @@ public:
 
     /**
      * Makes a set from a multicharacter string. Thus "ch" => {"ch"}
-     * <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
+     *
      * @param s the source string
      * @return a newly created set containing the given string.
      * The caller owns the return object and is responsible for deleting it.
@@ -1185,15 +1183,13 @@ public:
 
     /**
      * Retain only the elements in this set that are contained in the
-     * specified range.  If <code>end > start</code> then an empty range is
+     * specified range.  If <code>start > end</code> then an empty range is
      * retained, leaving the set empty.  This is equivalent to
      * a boolean logic AND, or a set INTERSECTION.
      * A frozen set will not be modified.
      *
-     * @param start first character, inclusive, of range to be retained
-     * to this set.
-     * @param end last character, inclusive, of range to be retained
-     * to this set.
+     * @param start first character, inclusive, of range
+     * @param end last character, inclusive, of range
      * @stable ICU 2.0
      */
     virtual UnicodeSet& retain(UChar32 start, UChar32 end);
@@ -1202,14 +1198,31 @@ public:
     /**
      * Retain the specified character from this set if it is present.
      * A frozen set will not be modified.
+     *
+     * @param c the character (code point)
+     * @return this object, for chaining
      * @stable ICU 2.0
      */
     UnicodeSet& retain(UChar32 c);
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Retains only the specified string from this set if it is present.
+     * Upon return this set will be empty if it did not contain s, or
+     * will only contain s if it did contain s.
+     * A frozen set will not be modified.
+     *
+     * @param s the source string
+     * @return this object, for chaining
+     * @draft ICU 69
+     */
+    UnicodeSet& retain(const UnicodeString &s);
+#endif  // U_HIDE_DRAFT_API
+
     /**
      * Removes the specified range from this set if it is present.
      * The set will not contain the specified range once the call
-     * returns.  If <code>end > start</code> then an empty range is
+     * returns.  If <code>start > end</code> then an empty range is
      * removed, leaving the set unchanged.
      * A frozen set will not be modified.
      *
@@ -1226,6 +1239,9 @@ public:
      * The set will not contain the specified range once the call
      * returns.
      * A frozen set will not be modified.
+     *
+     * @param c the character (code point)
+     * @return this object, for chaining
      * @stable ICU 2.0
      */
     UnicodeSet& remove(UChar32 c);
@@ -1253,15 +1269,13 @@ public:
     /**
      * Complements the specified range in this set.  Any character in
      * the range will be removed if it is in this set, or will be
-     * added if it is not in this set.  If <code>end > start</code>
+     * added if it is not in this set.  If <code>start > end</code>
      * then an empty range is complemented, leaving the set unchanged.
      * This is equivalent to a boolean logic XOR.
      * A frozen set will not be modified.
      *
-     * @param start first character, inclusive, of range to be removed
-     * from this set.
-     * @param end last character, inclusive, of range to be removed
-     * from this set.
+     * @param start first character, inclusive, of range
+     * @param end last character, inclusive, of range
      * @stable ICU 2.0
      */
     virtual UnicodeSet& complement(UChar32 start, UChar32 end);
@@ -1271,16 +1285,18 @@ public:
      * will be removed if it is in this set, or will be added if it is
      * not in this set.
      * A frozen set will not be modified.
+     *
+     * @param c the character (code point)
+     * @return this object, for chaining
      * @stable ICU 2.0
      */
     UnicodeSet& complement(UChar32 c);
 
     /**
      * Complement the specified string in this set.
-     * The set will not contain the specified string once the call
-     * returns.
-     * <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
+     * The string will be removed if it is in this set, or will be added if it is not in this set.
      * A frozen set will not be modified.
+     *
      * @param s the string to complement
      * @return this object, for chaining
      * @stable ICU 2.4
@@ -1636,7 +1652,7 @@ private:
     static const UnicodeSet* getInclusions(int32_t src, UErrorCode &status);
 
     /**
-     * A filter that returns TRUE if the given code point should be
+     * A filter that returns true if the given code point should be
      * included in the UnicodeSet being constructed.
      */
     typedef UBool (*Filter)(UChar32 codePoint, void* context);
diff --git a/deps/icu-small/source/common/unicode/unistr.h b/deps/icu-small/source/common/unicode/unistr.h
index da79053765acf6fa2ee1f2cde9a5b073e5dd80ce..85bd96495150d38e26aa5d602566bcdeb5e48a56 100644
--- a/deps/icu-small/source/common/unicode/unistr.h
+++ b/deps/icu-small/source/common/unicode/unistr.h
@@ -44,9 +44,10 @@ struct UConverter;          // unicode/ucnv.h
 #ifndef USTRING_H
 /**
  * \ingroup ustring_ustrlen
+ * @param s Pointer to sequence of UChars.
+ * @return Length of sequence.
  */
-U_STABLE int32_t U_EXPORT2
-u_strlen(const UChar *s);
+U_CAPI int32_t U_EXPORT2 u_strlen(const UChar *s);
 #endif
 
 U_NAMESPACE_BEGIN
@@ -113,9 +114,9 @@ class UnicodeStringAppendable;  // unicode/appendable.h
  * @stable ICU 2.0
  */
 #if !U_CHAR16_IS_TYPEDEF
-# define UNICODE_STRING(cs, _length) icu::UnicodeString(TRUE, u ## cs, _length)
+# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length)
 #else
-# define UNICODE_STRING(cs, _length) icu::UnicodeString(TRUE, (const char16_t*)u ## cs, _length)
+# define UNICODE_STRING(cs, _length) icu::UnicodeString(true, (const char16_t*)u ## cs, _length)
 #endif
 
 /**
@@ -227,7 +228,7 @@ class UnicodeStringAppendable;  // unicode/appendable.h
  * The UnicodeString class is not suitable for subclassing.
  *
  * For an overview of Unicode strings in C and C++ see the
- * [User Guide Strings chapter](http://userguide.icu-project.org/strings#TOC-Strings-in-C-C-).
+ * [User Guide Strings chapter](https://unicode-org.github.io/icu/userguide/strings#strings-in-cc).
  *
  * In ICU, a Unicode string consists of 16-bit Unicode *code units*.
  * A Unicode character may be stored with either one code unit
@@ -285,7 +286,7 @@ class UnicodeStringAppendable;  // unicode/appendable.h
  * significant performance improvements.
  * Also, the internal buffer is accessible via special functions.
  * For details see the
- * [User Guide Strings chapter](http://userguide.icu-project.org/strings#TOC-Maximizing-Performance-with-the-UnicodeString-Storage-Model).
+ * [User Guide Strings chapter](https://unicode-org.github.io/icu/userguide/strings#maximizing-performance-with-the-unicodestring-storage-model).
  *
  * @see utf.h
  * @see CharacterIterator
@@ -320,8 +321,8 @@ public:
   /**
    * Equality operator. Performs only bitwise comparison.
    * @param text The UnicodeString to compare to this one.
-   * @return TRUE if `text` contains the same characters as this one,
-   * FALSE otherwise.
+   * @return true if `text` contains the same characters as this one,
+   * false otherwise.
    * @stable ICU 2.0
    */
   inline UBool operator== (const UnicodeString& text) const;
@@ -329,8 +330,8 @@ public:
   /**
    * Inequality operator. Performs only bitwise comparison.
    * @param text The UnicodeString to compare to this one.
-   * @return FALSE if `text` contains the same characters as this one,
-   * TRUE otherwise.
+   * @return false if `text` contains the same characters as this one,
+   * true otherwise.
    * @stable ICU 2.0
    */
   inline UBool operator!= (const UnicodeString& text) const;
@@ -338,8 +339,8 @@ public:
   /**
    * Greater than operator. Performs only bitwise comparison.
    * @param text The UnicodeString to compare to this one.
-   * @return TRUE if the characters in this are bitwise
-   * greater than the characters in `text`, FALSE otherwise
+   * @return true if the characters in this are bitwise
+   * greater than the characters in `text`, false otherwise
    * @stable ICU 2.0
    */
   inline UBool operator> (const UnicodeString& text) const;
@@ -347,8 +348,8 @@ public:
   /**
    * Less than operator. Performs only bitwise comparison.
    * @param text The UnicodeString to compare to this one.
-   * @return TRUE if the characters in this are bitwise
-   * less than the characters in `text`, FALSE otherwise
+   * @return true if the characters in this are bitwise
+   * less than the characters in `text`, false otherwise
    * @stable ICU 2.0
    */
   inline UBool operator< (const UnicodeString& text) const;
@@ -356,8 +357,8 @@ public:
   /**
    * Greater than or equal operator. Performs only bitwise comparison.
    * @param text The UnicodeString to compare to this one.
-   * @return TRUE if the characters in this are bitwise
-   * greater than or equal to the characters in `text`, FALSE otherwise
+   * @return true if the characters in this are bitwise
+   * greater than or equal to the characters in `text`, false otherwise
    * @stable ICU 2.0
    */
   inline UBool operator>= (const UnicodeString& text) const;
@@ -365,8 +366,8 @@ public:
   /**
    * Less than or equal operator. Performs only bitwise comparison.
    * @param text The UnicodeString to compare to this one.
-   * @return TRUE if the characters in this are bitwise
-   * less than or equal to the characters in `text`, FALSE otherwise
+   * @return true if the characters in this are bitwise
+   * less than or equal to the characters in `text`, false otherwise
    * @stable ICU 2.0
    */
   inline UBool operator<= (const UnicodeString& text) const;
@@ -855,8 +856,8 @@ public:
   /**
    * Determine if this starts with the characters in `text`
    * @param text The text to match.
-   * @return TRUE if this starts with the characters in `text`,
-   * FALSE otherwise
+   * @return true if this starts with the characters in `text`,
+   * false otherwise
    * @stable ICU 2.0
    */
   inline UBool startsWith(const UnicodeString& text) const;
@@ -867,8 +868,8 @@ public:
    * @param srcText The text to match.
    * @param srcStart the offset into `srcText` to start matching
    * @param srcLength the number of characters in `srcText` to match
-   * @return TRUE if this starts with the characters in `text`,
-   * FALSE otherwise
+   * @return true if this starts with the characters in `text`,
+   * false otherwise
    * @stable ICU 2.0
    */
   inline UBool startsWith(const UnicodeString& srcText,
@@ -879,8 +880,8 @@ public:
    * Determine if this starts with the characters in `srcChars`
    * @param srcChars The characters to match.
    * @param srcLength the number of characters in `srcChars`
-   * @return TRUE if this starts with the characters in `srcChars`,
-   * FALSE otherwise
+   * @return true if this starts with the characters in `srcChars`,
+   * false otherwise
    * @stable ICU 2.0
    */
   inline UBool startsWith(ConstChar16Ptr srcChars,
@@ -892,7 +893,7 @@ public:
    * @param srcChars The characters to match.
    * @param srcStart the offset into `srcText` to start matching
    * @param srcLength the number of characters in `srcChars` to match
-   * @return TRUE if this ends with the characters in `srcChars`, FALSE otherwise
+   * @return true if this ends with the characters in `srcChars`, false otherwise
    * @stable ICU 2.0
    */
   inline UBool startsWith(const char16_t *srcChars,
@@ -902,8 +903,8 @@ public:
   /**
    * Determine if this ends with the characters in `text`
    * @param text The text to match.
-   * @return TRUE if this ends with the characters in `text`,
-   * FALSE otherwise
+   * @return true if this ends with the characters in `text`,
+   * false otherwise
    * @stable ICU 2.0
    */
   inline UBool endsWith(const UnicodeString& text) const;
@@ -914,8 +915,8 @@ public:
    * @param srcText The text to match.
    * @param srcStart the offset into `srcText` to start matching
    * @param srcLength the number of characters in `srcText` to match
-   * @return TRUE if this ends with the characters in `text`,
-   * FALSE otherwise
+   * @return true if this ends with the characters in `text`,
+   * false otherwise
    * @stable ICU 2.0
    */
   inline UBool endsWith(const UnicodeString& srcText,
@@ -926,8 +927,8 @@ public:
    * Determine if this ends with the characters in `srcChars`
    * @param srcChars The characters to match.
    * @param srcLength the number of characters in `srcChars`
-   * @return TRUE if this ends with the characters in `srcChars`,
-   * FALSE otherwise
+   * @return true if this ends with the characters in `srcChars`,
+   * false otherwise
    * @stable ICU 2.0
    */
   inline UBool endsWith(ConstChar16Ptr srcChars,
@@ -939,8 +940,8 @@ public:
    * @param srcChars The characters to match.
    * @param srcStart the offset into `srcText` to start matching
    * @param srcLength the number of characters in `srcChars` to match
-   * @return TRUE if this ends with the characters in `srcChars`,
-   * FALSE otherwise
+   * @return true if this ends with the characters in `srcChars`,
+   * false otherwise
    * @stable ICU 2.0
    */
   inline UBool endsWith(const char16_t *srcChars,
@@ -1804,7 +1805,7 @@ public:
 
   /**
    * Determine if this string is empty.
-   * @return TRUE if this string contains 0 characters, FALSE otherwise.
+   * @return true if this string contains 0 characters, false otherwise.
    * @stable ICU 2.0
    */
   inline UBool isEmpty(void) const;
@@ -1832,12 +1833,12 @@ public:
   /**
    * Determine if this object contains a valid string.
    * A bogus string has no value. It is different from an empty string,
-   * although in both cases isEmpty() returns TRUE and length() returns 0.
+   * although in both cases isEmpty() returns true and length() returns 0.
    * setToBogus() and isBogus() can be used to indicate that no string value is available.
    * For a bogus string, getBuffer() and getTerminatedBuffer() return NULL, and
    * length() returns 0.
    *
-   * @return TRUE if the string is bogus/invalid, FALSE otherwise
+   * @return true if the string is bogus/invalid, false otherwise
    * @see setToBogus()
    * @stable ICU 2.0
    */
@@ -2067,7 +2068,7 @@ public:
 
   /**
    * Make this UnicodeString object invalid.
-   * The string will test TRUE with isBogus().
+   * The string will test true with isBogus().
    *
    * A bogus string has no value. It is different from an empty string.
    * It can be used to indicate that no string value is available.
@@ -2459,7 +2460,7 @@ public:
 
   /**
    * Replaceable API
-   * @return TRUE if it has MetaData
+   * @return true if it has MetaData
    * @stable ICU 2.4
    */
   virtual UBool hasMetaData() const;
@@ -2590,7 +2591,7 @@ public:
    * @param targetLength the desired length of the string
    * @param padChar the character to use for padding. Defaults to
    * space (U+0020)
-   * @return TRUE if the text was padded, FALSE otherwise.
+   * @return true if the text was padded, false otherwise.
    * @stable ICU 2.0
    */
   UBool padLeading(int32_t targetLength,
@@ -2604,7 +2605,7 @@ public:
    * @param targetLength the desired length of the string
    * @param padChar the character to use for padding. Defaults to
    * space (U+0020)
-   * @return TRUE if the text was padded, FALSE otherwise.
+   * @return true if the text was padded, false otherwise.
    * @stable ICU 2.0
    */
   UBool padTrailing(int32_t targetLength,
@@ -2613,7 +2614,7 @@ public:
   /**
    * Truncate this UnicodeString to the `targetLength`.
    * @param targetLength the desired length of this UnicodeString.
-   * @return TRUE if the text was truncated, FALSE otherwise
+   * @return true if the text was truncated, false otherwise
    * @stable ICU 2.0
    */
   inline UBool truncate(int32_t targetLength);
@@ -2766,7 +2767,6 @@ public:
    * @param options   Options bit set, usually 0. See U_TITLECASE_NO_LOWERCASE,
    *                  U_TITLECASE_NO_BREAK_ADJUSTMENT, U_TITLECASE_ADJUST_TO_CASED,
    *                  U_TITLECASE_WHOLE_STRING, U_TITLECASE_SENTENCES.
-   * @param options Options bit set, see ucasemap_open().
    * @return A reference to this.
    * @stable ICU 3.8
    */
@@ -3614,8 +3614,8 @@ private:
   // turn a bogus string into an empty one
   void unBogus();
 
-  // implements assigment operator, copy constructor, and fastCopyFrom()
-  UnicodeString &copyFrom(const UnicodeString &src, UBool fastCopy=FALSE);
+  // implements assignment operator, copy constructor, and fastCopyFrom()
+  UnicodeString &copyFrom(const UnicodeString &src, UBool fastCopy=false);
 
   // Copies just the fields without memory management.
   void copyFieldsFrom(UnicodeString &src, UBool setSrcToBogus) U_NOEXCEPT;
@@ -3668,13 +3668,13 @@ private:
    * the buffer is refCounted (shared), and refCount>1, or
    * the buffer is too small.
    *
-   * Return FALSE if memory could not be allocated.
+   * Return false if memory could not be allocated.
    */
   UBool cloneArrayIfNeeded(int32_t newCapacity = -1,
                             int32_t growCapacity = -1,
-                            UBool doCopyArray = TRUE,
+                            UBool doCopyArray = true,
                             int32_t **pBufferToDelete = 0,
-                            UBool forceClone = FALSE);
+                            UBool forceClone = false);
 
   /**
    * Common function for UnicodeString case mappings.
@@ -4732,12 +4732,12 @@ UnicodeString::truncate(int32_t targetLength)
   if(isBogus() && targetLength == 0) {
     // truncate(0) of a bogus string makes the string empty and non-bogus
     unBogus();
-    return FALSE;
+    return false;
   } else if((uint32_t)targetLength < (uint32_t)length()) {
     setLength(targetLength);
-    return TRUE;
+    return true;
   } else {
-    return FALSE;
+    return false;
   }
 }
 
diff --git a/deps/icu-small/source/common/unicode/unorm.h b/deps/icu-small/source/common/unicode/unorm.h
index 09dd366a968c1b473d76417e6dec2a6570872788..c3c57582d449d567cfa887a36161d720bbc45497 100644
--- a/deps/icu-small/source/common/unicode/unorm.h
+++ b/deps/icu-small/source/common/unicode/unorm.h
@@ -274,7 +274,7 @@ unorm_quickCheckWithOptions(const UChar *src, int32_t srcLength,
  * never a "maybe".
  * For NFD, NFKD, and FCD, both functions work exactly the same.
  * For NFC and NFKC where quickCheck may return "maybe", this function will
- * perform further tests to arrive at a TRUE/FALSE result.
+ * perform further tests to arrive at a true/false result.
  *
  * @param src        String that is to be tested if it is in a normalization format.
  * @param srcLength  Length of source to test, or -1 if NUL-terminated.
@@ -358,10 +358,10 @@ unorm_isNormalizedWithOptions(const UChar *src, int32_t srcLength,
  * It is useful for operations like a normalizing transliterator, where one would
  * not want to replace a piece of text if it is not modified.
  *
- * If doNormalize==TRUE and pNeededToNormalize!=NULL then *pNeeded... is set TRUE
+ * If doNormalize==true and pNeededToNormalize!=NULL then *pNeeded... is set true
  * if the normalization was necessary.
  *
- * If doNormalize==FALSE then *pNeededToNormalize will be set to FALSE.
+ * If doNormalize==false then *pNeededToNormalize will be set to false.
  *
  * If the buffer overflows, then *pNeededToNormalize will be undefined;
  * essentially, whenever U_FAILURE is true (like in buffer overflows), this result
@@ -373,11 +373,11 @@ unorm_isNormalizedWithOptions(const UChar *src, int32_t srcLength,
  * @param mode The normalization mode.
  * @param options The normalization options, ORed together (0 for no options).
  * @param doNormalize Indicates if the source text up to the next boundary
- *                    is to be normalized (TRUE) or just copied (FALSE).
+ *                    is to be normalized (true) or just copied (false).
  * @param pNeededToNormalize Output flag indicating if the normalization resulted in
  *                           different text from the input.
  *                           Not defined if an error occurs including buffer overflow.
- *                           Always FALSE if !doNormalize.
+ *                           Always false if !doNormalize.
  * @param pErrorCode ICU error code in/out parameter.
  *                   Must fulfill U_SUCCESS before the function call.
  * @return Length of output (number of UChars) when successful or buffer overflow.
@@ -406,11 +406,11 @@ unorm_next(UCharIterator *src,
  * @param mode The normalization mode.
  * @param options The normalization options, ORed together (0 for no options).
  * @param doNormalize Indicates if the source text up to the next boundary
- *                    is to be normalized (TRUE) or just copied (FALSE).
+ *                    is to be normalized (true) or just copied (false).
  * @param pNeededToNormalize Output flag indicating if the normalization resulted in
  *                           different text from the input.
  *                           Not defined if an error occurs including buffer overflow.
- *                           Always FALSE if !doNormalize.
+ *                           Always false if !doNormalize.
  * @param pErrorCode ICU error code in/out parameter.
  *                   Must fulfill U_SUCCESS before the function call.
  * @return Length of output (number of UChars) when successful or buffer overflow.
diff --git a/deps/icu-small/source/common/unicode/unorm2.h b/deps/icu-small/source/common/unicode/unorm2.h
index a9bd02f256361f3438cb75972d93d668e223b331..24417b7103c12ea8111d08ee22c5c24b5c4dee2d 100644
--- a/deps/icu-small/source/common/unicode/unorm2.h
+++ b/deps/icu-small/source/common/unicode/unorm2.h
@@ -31,10 +31,13 @@
  */
 
 #include "unicode/utypes.h"
-#include "unicode/localpointer.h"
 #include "unicode/stringoptions.h"
 #include "unicode/uset.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * Constants for normalization modes.
  * For details about standard Unicode normalization forms
@@ -132,7 +135,7 @@ typedef struct UNormalizer2 UNormalizer2;  /**< C typedef for struct UNormalizer
  * @return the requested Normalizer2, if successful
  * @stable ICU 49
  */
-U_STABLE const UNormalizer2 * U_EXPORT2
+U_CAPI const UNormalizer2 * U_EXPORT2
 unorm2_getNFCInstance(UErrorCode *pErrorCode);
 
 /**
@@ -146,7 +149,7 @@ unorm2_getNFCInstance(UErrorCode *pErrorCode);
  * @return the requested Normalizer2, if successful
  * @stable ICU 49
  */
-U_STABLE const UNormalizer2 * U_EXPORT2
+U_CAPI const UNormalizer2 * U_EXPORT2
 unorm2_getNFDInstance(UErrorCode *pErrorCode);
 
 /**
@@ -160,7 +163,7 @@ unorm2_getNFDInstance(UErrorCode *pErrorCode);
  * @return the requested Normalizer2, if successful
  * @stable ICU 49
  */
-U_STABLE const UNormalizer2 * U_EXPORT2
+U_CAPI const UNormalizer2 * U_EXPORT2
 unorm2_getNFKCInstance(UErrorCode *pErrorCode);
 
 /**
@@ -174,7 +177,7 @@ unorm2_getNFKCInstance(UErrorCode *pErrorCode);
  * @return the requested Normalizer2, if successful
  * @stable ICU 49
  */
-U_STABLE const UNormalizer2 * U_EXPORT2
+U_CAPI const UNormalizer2 * U_EXPORT2
 unorm2_getNFKDInstance(UErrorCode *pErrorCode);
 
 /**
@@ -188,7 +191,7 @@ unorm2_getNFKDInstance(UErrorCode *pErrorCode);
  * @return the requested Normalizer2, if successful
  * @stable ICU 49
  */
-U_STABLE const UNormalizer2 * U_EXPORT2
+U_CAPI const UNormalizer2 * U_EXPORT2
 unorm2_getNFKCCasefoldInstance(UErrorCode *pErrorCode);
 
 /**
@@ -212,7 +215,7 @@ unorm2_getNFKCCasefoldInstance(UErrorCode *pErrorCode);
  * @return the requested UNormalizer2, if successful
  * @stable ICU 4.4
  */
-U_STABLE const UNormalizer2 * U_EXPORT2
+U_CAPI const UNormalizer2 * U_EXPORT2
 unorm2_getInstance(const char *packageName,
                    const char *name,
                    UNormalization2Mode mode,
@@ -233,7 +236,7 @@ unorm2_getInstance(const char *packageName,
  * @return the requested UNormalizer2, if successful
  * @stable ICU 4.4
  */
-U_STABLE UNormalizer2 * U_EXPORT2
+U_CAPI UNormalizer2 * U_EXPORT2
 unorm2_openFiltered(const UNormalizer2 *norm2, const USet *filterSet, UErrorCode *pErrorCode);
 
 /**
@@ -242,7 +245,7 @@ unorm2_openFiltered(const UNormalizer2 *norm2, const USet *filterSet, UErrorCode
  * @param norm2 UNormalizer2 instance to be closed
  * @stable ICU 4.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unorm2_close(UNormalizer2 *norm2);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -280,7 +283,7 @@ U_NAMESPACE_END
  * @return dest
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unorm2_normalize(const UNormalizer2 *norm2,
                  const UChar *src, int32_t length,
                  UChar *dest, int32_t capacity,
@@ -303,7 +306,7 @@ unorm2_normalize(const UNormalizer2 *norm2,
  * @return first
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unorm2_normalizeSecondAndAppend(const UNormalizer2 *norm2,
                                 UChar *first, int32_t firstLength, int32_t firstCapacity,
                                 const UChar *second, int32_t secondLength,
@@ -326,7 +329,7 @@ unorm2_normalizeSecondAndAppend(const UNormalizer2 *norm2,
  * @return first
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unorm2_append(const UNormalizer2 *norm2,
               UChar *first, int32_t firstLength, int32_t firstCapacity,
               const UChar *second, int32_t secondLength,
@@ -351,7 +354,7 @@ unorm2_append(const UNormalizer2 *norm2,
  * @return the non-negative length of c's decomposition, if there is one; otherwise a negative value
  * @stable ICU 4.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unorm2_getDecomposition(const UNormalizer2 *norm2,
                         UChar32 c, UChar *decomposition, int32_t capacity,
                         UErrorCode *pErrorCode);
@@ -385,7 +388,7 @@ unorm2_getDecomposition(const UNormalizer2 *norm2,
  * @return the non-negative length of c's raw decomposition, if there is one; otherwise a negative value
  * @stable ICU 49
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unorm2_getRawDecomposition(const UNormalizer2 *norm2,
                            UChar32 c, UChar *decomposition, int32_t capacity,
                            UErrorCode *pErrorCode);
@@ -405,7 +408,7 @@ unorm2_getRawDecomposition(const UNormalizer2 *norm2,
  * @return The non-negative composite code point if there is one; otherwise a negative value.
  * @stable ICU 49
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 unorm2_composePair(const UNormalizer2 *norm2, UChar32 a, UChar32 b);
 
 /**
@@ -417,7 +420,7 @@ unorm2_composePair(const UNormalizer2 *norm2, UChar32 a, UChar32 b);
  * @return c's combining class
  * @stable ICU 49
  */
-U_STABLE uint8_t U_EXPORT2
+U_CAPI uint8_t U_EXPORT2
 unorm2_getCombiningClass(const UNormalizer2 *norm2, UChar32 c);
 
 /**
@@ -433,10 +436,10 @@ unorm2_getCombiningClass(const UNormalizer2 *norm2, UChar32 c);
  *                   pass the U_SUCCESS() test, or else the function returns
  *                   immediately. Check for U_FAILURE() on output or use with
  *                   function chaining. (See User Guide for details.)
- * @return TRUE if s is normalized
+ * @return true if s is normalized
  * @stable ICU 4.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 unorm2_isNormalized(const UNormalizer2 *norm2,
                     const UChar *s, int32_t length,
                     UErrorCode *pErrorCode);
@@ -458,7 +461,7 @@ unorm2_isNormalized(const UNormalizer2 *norm2,
  * @return UNormalizationCheckResult
  * @stable ICU 4.4
  */
-U_STABLE UNormalizationCheckResult U_EXPORT2
+U_CAPI UNormalizationCheckResult U_EXPORT2
 unorm2_quickCheck(const UNormalizer2 *norm2,
                   const UChar *s, int32_t length,
                   UErrorCode *pErrorCode);
@@ -487,7 +490,7 @@ unorm2_quickCheck(const UNormalizer2 *norm2,
  * @return "yes" span end index
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unorm2_spanQuickCheckYes(const UNormalizer2 *norm2,
                          const UChar *s, int32_t length,
                          UErrorCode *pErrorCode);
@@ -498,10 +501,10 @@ unorm2_spanQuickCheckYes(const UNormalizer2 *norm2,
  * For details see the Normalizer2 base class documentation.
  * @param norm2 UNormalizer2 instance
  * @param c character to test
- * @return TRUE if c has a normalization boundary before it
+ * @return true if c has a normalization boundary before it
  * @stable ICU 4.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 unorm2_hasBoundaryBefore(const UNormalizer2 *norm2, UChar32 c);
 
 /**
@@ -510,10 +513,10 @@ unorm2_hasBoundaryBefore(const UNormalizer2 *norm2, UChar32 c);
  * For details see the Normalizer2 base class documentation.
  * @param norm2 UNormalizer2 instance
  * @param c character to test
- * @return TRUE if c has a normalization boundary after it
+ * @return true if c has a normalization boundary after it
  * @stable ICU 4.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 unorm2_hasBoundaryAfter(const UNormalizer2 *norm2, UChar32 c);
 
 /**
@@ -521,10 +524,10 @@ unorm2_hasBoundaryAfter(const UNormalizer2 *norm2, UChar32 c);
  * For details see the Normalizer2 base class documentation.
  * @param norm2 UNormalizer2 instance
  * @param c character to test
- * @return TRUE if c is normalization-inert
+ * @return true if c is normalization-inert
  * @stable ICU 4.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 unorm2_isInert(const UNormalizer2 *norm2, UChar32 c);
 
 /**
@@ -593,7 +596,7 @@ unorm2_isInert(const UNormalizer2 *norm2, UChar32 c);
  *
  * @stable ICU 2.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unorm_compare(const UChar *s1, int32_t length1,
               const UChar *s2, int32_t length2,
               uint32_t options,
diff --git a/deps/icu-small/source/common/unicode/urename.h b/deps/icu-small/source/common/unicode/urename.h
index 30f4b7af39adc5ccd83a984e6098ef2926ad6885..737f4b308ef83f93be224fb85f33515e7591afdd 100644
--- a/deps/icu-small/source/common/unicode/urename.h
+++ b/deps/icu-small/source/common/unicode/urename.h
@@ -130,7 +130,6 @@
 #define izrule_getStaticClassID U_ICU_ENTRY_POINT_RENAME(izrule_getStaticClassID)
 #define izrule_isEquivalentTo U_ICU_ENTRY_POINT_RENAME(izrule_isEquivalentTo)
 #define izrule_open U_ICU_ENTRY_POINT_RENAME(izrule_open)
-#define locale_getKeywords U_ICU_ENTRY_POINT_RENAME(locale_getKeywords)
 #define locale_getKeywordsStart U_ICU_ENTRY_POINT_RENAME(locale_getKeywordsStart)
 #define locale_get_default U_ICU_ENTRY_POINT_RENAME(locale_get_default)
 #define locale_set_default U_ICU_ENTRY_POINT_RENAME(locale_set_default)
@@ -483,6 +482,7 @@
 #define ubiditransform_open U_ICU_ENTRY_POINT_RENAME(ubiditransform_open)
 #define ubiditransform_transform U_ICU_ENTRY_POINT_RENAME(ubiditransform_transform)
 #define ublock_getCode U_ICU_ENTRY_POINT_RENAME(ublock_getCode)
+#define ubrk_clone U_ICU_ENTRY_POINT_RENAME(ubrk_clone)
 #define ubrk_close U_ICU_ENTRY_POINT_RENAME(ubrk_close)
 #define ubrk_countAvailable U_ICU_ENTRY_POINT_RENAME(ubrk_countAvailable)
 #define ubrk_current U_ICU_ENTRY_POINT_RENAME(ubrk_current)
@@ -535,6 +535,7 @@
 #define ucal_getTimeZoneDisplayName U_ICU_ENTRY_POINT_RENAME(ucal_getTimeZoneDisplayName)
 #define ucal_getTimeZoneID U_ICU_ENTRY_POINT_RENAME(ucal_getTimeZoneID)
 #define ucal_getTimeZoneIDForWindowsID U_ICU_ENTRY_POINT_RENAME(ucal_getTimeZoneIDForWindowsID)
+#define ucal_getTimeZoneOffsetFromLocal U_ICU_ENTRY_POINT_RENAME(ucal_getTimeZoneOffsetFromLocal)
 #define ucal_getTimeZoneTransitionDate U_ICU_ENTRY_POINT_RENAME(ucal_getTimeZoneTransitionDate)
 #define ucal_getType U_ICU_ENTRY_POINT_RENAME(ucal_getType)
 #define ucal_getWeekendTransition U_ICU_ENTRY_POINT_RENAME(ucal_getWeekendTransition)
@@ -918,9 +919,11 @@
 #define udtitvfmt_format U_ICU_ENTRY_POINT_RENAME(udtitvfmt_format)
 #define udtitvfmt_formatCalendarToResult U_ICU_ENTRY_POINT_RENAME(udtitvfmt_formatCalendarToResult)
 #define udtitvfmt_formatToResult U_ICU_ENTRY_POINT_RENAME(udtitvfmt_formatToResult)
+#define udtitvfmt_getContext U_ICU_ENTRY_POINT_RENAME(udtitvfmt_getContext)
 #define udtitvfmt_open U_ICU_ENTRY_POINT_RENAME(udtitvfmt_open)
 #define udtitvfmt_openResult U_ICU_ENTRY_POINT_RENAME(udtitvfmt_openResult)
 #define udtitvfmt_resultAsValue U_ICU_ENTRY_POINT_RENAME(udtitvfmt_resultAsValue)
+#define udtitvfmt_setContext U_ICU_ENTRY_POINT_RENAME(udtitvfmt_setContext)
 #define uenum_close U_ICU_ENTRY_POINT_RENAME(uenum_close)
 #define uenum_count U_ICU_ENTRY_POINT_RENAME(uenum_count)
 #define uenum_next U_ICU_ENTRY_POINT_RENAME(uenum_next)
@@ -961,6 +964,7 @@
 #define uhash_compareScriptSet U_ICU_ENTRY_POINT_RENAME(uhash_compareScriptSet)
 #define uhash_compareUChars U_ICU_ENTRY_POINT_RENAME(uhash_compareUChars)
 #define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUnicodeString)
+#define uhash_containsKey U_ICU_ENTRY_POINT_RENAME(uhash_containsKey)
 #define uhash_count U_ICU_ENTRY_POINT_RENAME(uhash_count)
 #define uhash_deleteHashtable U_ICU_ENTRY_POINT_RENAME(uhash_deleteHashtable)
 #define uhash_deleteScriptSet U_ICU_ENTRY_POINT_RENAME(uhash_deleteScriptSet)
@@ -969,6 +973,7 @@
 #define uhash_find U_ICU_ENTRY_POINT_RENAME(uhash_find)
 #define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get)
 #define uhash_geti U_ICU_ENTRY_POINT_RENAME(uhash_geti)
+#define uhash_getiAndFound U_ICU_ENTRY_POINT_RENAME(uhash_getiAndFound)
 #define uhash_hashCaselessUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_hashCaselessUnicodeString)
 #define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars)
 #define uhash_hashIChars U_ICU_ENTRY_POINT_RENAME(uhash_hashIChars)
@@ -976,12 +981,15 @@
 #define uhash_hashScriptSet U_ICU_ENTRY_POINT_RENAME(uhash_hashScriptSet)
 #define uhash_hashUChars U_ICU_ENTRY_POINT_RENAME(uhash_hashUChars)
 #define uhash_hashUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_hashUnicodeString)
+#define uhash_icontainsKey U_ICU_ENTRY_POINT_RENAME(uhash_icontainsKey)
 #define uhash_iget U_ICU_ENTRY_POINT_RENAME(uhash_iget)
 #define uhash_igeti U_ICU_ENTRY_POINT_RENAME(uhash_igeti)
+#define uhash_igetiAndFound U_ICU_ENTRY_POINT_RENAME(uhash_igetiAndFound)
 #define uhash_init U_ICU_ENTRY_POINT_RENAME(uhash_init)
 #define uhash_initSize U_ICU_ENTRY_POINT_RENAME(uhash_initSize)
 #define uhash_iput U_ICU_ENTRY_POINT_RENAME(uhash_iput)
 #define uhash_iputi U_ICU_ENTRY_POINT_RENAME(uhash_iputi)
+#define uhash_iputiAllowZero U_ICU_ENTRY_POINT_RENAME(uhash_iputiAllowZero)
 #define uhash_iremove U_ICU_ENTRY_POINT_RENAME(uhash_iremove)
 #define uhash_iremovei U_ICU_ENTRY_POINT_RENAME(uhash_iremovei)
 #define uhash_nextElement U_ICU_ENTRY_POINT_RENAME(uhash_nextElement)
@@ -989,6 +997,7 @@
 #define uhash_openSize U_ICU_ENTRY_POINT_RENAME(uhash_openSize)
 #define uhash_put U_ICU_ENTRY_POINT_RENAME(uhash_put)
 #define uhash_puti U_ICU_ENTRY_POINT_RENAME(uhash_puti)
+#define uhash_putiAllowZero U_ICU_ENTRY_POINT_RENAME(uhash_putiAllowZero)
 #define uhash_remove U_ICU_ENTRY_POINT_RENAME(uhash_remove)
 #define uhash_removeAll U_ICU_ENTRY_POINT_RENAME(uhash_removeAll)
 #define uhash_removeElement U_ICU_ENTRY_POINT_RENAME(uhash_removeElement)
@@ -1079,7 +1088,6 @@
 #define uloc_getDisplayLanguage U_ICU_ENTRY_POINT_RENAME(uloc_getDisplayLanguage)
 #define uloc_getDisplayName U_ICU_ENTRY_POINT_RENAME(uloc_getDisplayName)
 #define uloc_getDisplayScript U_ICU_ENTRY_POINT_RENAME(uloc_getDisplayScript)
-#define uloc_getDisplayScriptInContext U_ICU_ENTRY_POINT_RENAME(uloc_getDisplayScriptInContext)
 #define uloc_getDisplayVariant U_ICU_ENTRY_POINT_RENAME(uloc_getDisplayVariant)
 #define uloc_getISO3Country U_ICU_ENTRY_POINT_RENAME(uloc_getISO3Country)
 #define uloc_getISO3Language U_ICU_ENTRY_POINT_RENAME(uloc_getISO3Language)
@@ -1123,16 +1131,21 @@
 #define ulocimp_forLanguageTag U_ICU_ENTRY_POINT_RENAME(ulocimp_forLanguageTag)
 #define ulocimp_getBaseName U_ICU_ENTRY_POINT_RENAME(ulocimp_getBaseName)
 #define ulocimp_getCountry U_ICU_ENTRY_POINT_RENAME(ulocimp_getCountry)
+#define ulocimp_getKeywordValue U_ICU_ENTRY_POINT_RENAME(ulocimp_getKeywordValue)
+#define ulocimp_getKeywords U_ICU_ENTRY_POINT_RENAME(ulocimp_getKeywords)
+#define ulocimp_getKnownCanonicalizedLocaleForTest U_ICU_ENTRY_POINT_RENAME(ulocimp_getKnownCanonicalizedLocaleForTest)
 #define ulocimp_getLanguage U_ICU_ENTRY_POINT_RENAME(ulocimp_getLanguage)
 #define ulocimp_getName U_ICU_ENTRY_POINT_RENAME(ulocimp_getName)
 #define ulocimp_getRegionForSupplementalData U_ICU_ENTRY_POINT_RENAME(ulocimp_getRegionForSupplementalData)
 #define ulocimp_getScript U_ICU_ENTRY_POINT_RENAME(ulocimp_getScript)
+#define ulocimp_isCanonicalizedLocaleForTest U_ICU_ENTRY_POINT_RENAME(ulocimp_isCanonicalizedLocaleForTest)
 #define ulocimp_minimizeSubtags U_ICU_ENTRY_POINT_RENAME(ulocimp_minimizeSubtags)
 #define ulocimp_toBcpKey U_ICU_ENTRY_POINT_RENAME(ulocimp_toBcpKey)
 #define ulocimp_toBcpType U_ICU_ENTRY_POINT_RENAME(ulocimp_toBcpType)
 #define ulocimp_toLanguageTag U_ICU_ENTRY_POINT_RENAME(ulocimp_toLanguageTag)
 #define ulocimp_toLegacyKey U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyKey)
 #define ulocimp_toLegacyType U_ICU_ENTRY_POINT_RENAME(ulocimp_toLegacyType)
+#define ultag_getTKeyStart U_ICU_ENTRY_POINT_RENAME(ultag_getTKeyStart)
 #define ultag_isExtensionSubtags U_ICU_ENTRY_POINT_RENAME(ultag_isExtensionSubtags)
 #define ultag_isLanguageSubtag U_ICU_ENTRY_POINT_RENAME(ultag_isLanguageSubtag)
 #define ultag_isPrivateuseValueSubtags U_ICU_ENTRY_POINT_RENAME(ultag_isPrivateuseValueSubtags)
@@ -1145,6 +1158,8 @@
 #define ultag_isUnicodeLocaleKey U_ICU_ENTRY_POINT_RENAME(ultag_isUnicodeLocaleKey)
 #define ultag_isUnicodeLocaleType U_ICU_ENTRY_POINT_RENAME(ultag_isUnicodeLocaleType)
 #define ultag_isVariantSubtags U_ICU_ENTRY_POINT_RENAME(ultag_isVariantSubtags)
+#define umeas_getPrefixBase U_ICU_ENTRY_POINT_RENAME(umeas_getPrefixBase)
+#define umeas_getPrefixPower U_ICU_ENTRY_POINT_RENAME(umeas_getPrefixPower)
 #define umsg_applyPattern U_ICU_ENTRY_POINT_RENAME(umsg_applyPattern)
 #define umsg_autoQuoteApostrophe U_ICU_ENTRY_POINT_RENAME(umsg_autoQuoteApostrophe)
 #define umsg_clone U_ICU_ENTRY_POINT_RENAME(umsg_clone)
@@ -1245,7 +1260,18 @@
 #define unumf_resultAsValue U_ICU_ENTRY_POINT_RENAME(unumf_resultAsValue)
 #define unumf_resultGetAllFieldPositions U_ICU_ENTRY_POINT_RENAME(unumf_resultGetAllFieldPositions)
 #define unumf_resultNextFieldPosition U_ICU_ENTRY_POINT_RENAME(unumf_resultNextFieldPosition)
+#define unumf_resultToDecimalNumber U_ICU_ENTRY_POINT_RENAME(unumf_resultToDecimalNumber)
 #define unumf_resultToString U_ICU_ENTRY_POINT_RENAME(unumf_resultToString)
+#define unumrf_close U_ICU_ENTRY_POINT_RENAME(unumrf_close)
+#define unumrf_closeResult U_ICU_ENTRY_POINT_RENAME(unumrf_closeResult)
+#define unumrf_formatDecimalRange U_ICU_ENTRY_POINT_RENAME(unumrf_formatDecimalRange)
+#define unumrf_formatDoubleRange U_ICU_ENTRY_POINT_RENAME(unumrf_formatDoubleRange)
+#define unumrf_openForSkeletonWithCollapseAndIdentityFallback U_ICU_ENTRY_POINT_RENAME(unumrf_openForSkeletonWithCollapseAndIdentityFallback)
+#define unumrf_openResult U_ICU_ENTRY_POINT_RENAME(unumrf_openResult)
+#define unumrf_resultAsValue U_ICU_ENTRY_POINT_RENAME(unumrf_resultAsValue)
+#define unumrf_resultGetFirstDecimalNumber U_ICU_ENTRY_POINT_RENAME(unumrf_resultGetFirstDecimalNumber)
+#define unumrf_resultGetIdentityResult U_ICU_ENTRY_POINT_RENAME(unumrf_resultGetIdentityResult)
+#define unumrf_resultGetSecondDecimalNumber U_ICU_ENTRY_POINT_RENAME(unumrf_resultGetSecondDecimalNumber)
 #define unumsys_close U_ICU_ENTRY_POINT_RENAME(unumsys_close)
 #define unumsys_getDescription U_ICU_ENTRY_POINT_RENAME(unumsys_getDescription)
 #define unumsys_getName U_ICU_ENTRY_POINT_RENAME(unumsys_getName)
@@ -1259,6 +1285,7 @@
 #define uplrules_open U_ICU_ENTRY_POINT_RENAME(uplrules_open)
 #define uplrules_openForType U_ICU_ENTRY_POINT_RENAME(uplrules_openForType)
 #define uplrules_select U_ICU_ENTRY_POINT_RENAME(uplrules_select)
+#define uplrules_selectForRange U_ICU_ENTRY_POINT_RENAME(uplrules_selectForRange)
 #define uplrules_selectFormatted U_ICU_ENTRY_POINT_RENAME(uplrules_selectFormatted)
 #define uplrules_selectWithFormat U_ICU_ENTRY_POINT_RENAME(uplrules_selectWithFormat)
 #define uplug_closeLibrary U_ICU_ENTRY_POINT_RENAME(uplug_closeLibrary)
@@ -1655,6 +1682,9 @@
 #define uset_compact U_ICU_ENTRY_POINT_RENAME(uset_compact)
 #define uset_complement U_ICU_ENTRY_POINT_RENAME(uset_complement)
 #define uset_complementAll U_ICU_ENTRY_POINT_RENAME(uset_complementAll)
+#define uset_complementAllCodePoints U_ICU_ENTRY_POINT_RENAME(uset_complementAllCodePoints)
+#define uset_complementRange U_ICU_ENTRY_POINT_RENAME(uset_complementRange)
+#define uset_complementString U_ICU_ENTRY_POINT_RENAME(uset_complementString)
 #define uset_contains U_ICU_ENTRY_POINT_RENAME(uset_contains)
 #define uset_containsAll U_ICU_ENTRY_POINT_RENAME(uset_containsAll)
 #define uset_containsAllCodePoints U_ICU_ENTRY_POINT_RENAME(uset_containsAllCodePoints)
@@ -1678,12 +1708,15 @@
 #define uset_openPatternOptions U_ICU_ENTRY_POINT_RENAME(uset_openPatternOptions)
 #define uset_remove U_ICU_ENTRY_POINT_RENAME(uset_remove)
 #define uset_removeAll U_ICU_ENTRY_POINT_RENAME(uset_removeAll)
+#define uset_removeAllCodePoints U_ICU_ENTRY_POINT_RENAME(uset_removeAllCodePoints)
 #define uset_removeAllStrings U_ICU_ENTRY_POINT_RENAME(uset_removeAllStrings)
 #define uset_removeRange U_ICU_ENTRY_POINT_RENAME(uset_removeRange)
 #define uset_removeString U_ICU_ENTRY_POINT_RENAME(uset_removeString)
 #define uset_resemblesPattern U_ICU_ENTRY_POINT_RENAME(uset_resemblesPattern)
 #define uset_retain U_ICU_ENTRY_POINT_RENAME(uset_retain)
 #define uset_retainAll U_ICU_ENTRY_POINT_RENAME(uset_retainAll)
+#define uset_retainAllCodePoints U_ICU_ENTRY_POINT_RENAME(uset_retainAllCodePoints)
+#define uset_retainString U_ICU_ENTRY_POINT_RENAME(uset_retainString)
 #define uset_serialize U_ICU_ENTRY_POINT_RENAME(uset_serialize)
 #define uset_serializedContains U_ICU_ENTRY_POINT_RENAME(uset_serializedContains)
 #define uset_set U_ICU_ENTRY_POINT_RENAME(uset_set)
diff --git a/deps/icu-small/source/common/unicode/ures.h b/deps/icu-small/source/common/unicode/ures.h
index 839779fada804d6063e6854c575793354e2ed669..fff84043e84785297e0c9bb76d043dfd55920bf0 100644
--- a/deps/icu-small/source/common/unicode/ures.h
+++ b/deps/icu-small/source/common/unicode/ures.h
@@ -27,7 +27,10 @@
 
 #include "unicode/utypes.h"
 #include "unicode/uloc.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -163,7 +166,7 @@ typedef enum {
  * @see ures_close
  * @stable ICU 2.0
  */
-U_STABLE UResourceBundle*  U_EXPORT2
+U_CAPI UResourceBundle*  U_EXPORT2
 ures_open(const char*    packageName,
           const char*  locale,
           UErrorCode*     status);
@@ -186,7 +189,7 @@ ures_open(const char*    packageName,
  * @see ures_close
  * @stable ICU 2.0
  */
-U_STABLE UResourceBundle* U_EXPORT2
+U_CAPI UResourceBundle* U_EXPORT2
 ures_openDirect(const char* packageName,
                 const char* locale,
                 UErrorCode* status);
@@ -209,7 +212,7 @@ ures_openDirect(const char* packageName,
  * @see ures_open
  * @stable ICU 2.0
  */
-U_STABLE UResourceBundle* U_EXPORT2
+U_CAPI UResourceBundle* U_EXPORT2
 ures_openU(const UChar* packageName,
            const char* locale,
            UErrorCode* status);
@@ -245,7 +248,7 @@ ures_countArrayItems(const UResourceBundle* resourceBundle,
  * @see ures_open
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ures_close(UResourceBundle* resourceBundle);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -291,7 +294,7 @@ ures_getVersionNumber(const UResourceBundle*   resourceBundle);
  *                    as specified in the resource bundle or its parent.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ures_getVersion(const UResourceBundle* resB,
                 UVersionInfo versionInfo);
 
@@ -325,7 +328,7 @@ ures_getLocale(const UResourceBundle* resourceBundle,
  * @return  A Locale name
  * @stable ICU 2.8
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 ures_getLocaleByType(const UResourceBundle* resourceBundle,
                      ULocDataLocaleType type,
                      UErrorCode* status);
@@ -348,7 +351,7 @@ ures_getLocaleByType(const UResourceBundle* resourceBundle,
  * @param status The error code.
  * @internal
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 ures_openFillIn(UResourceBundle *r,
                 const char* packageName,
                 const char* localeID,
@@ -372,7 +375,7 @@ ures_openFillIn(UResourceBundle *r,
  * @see ures_getUInt
  * @stable ICU 2.0
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ures_getString(const UResourceBundle* resourceBundle,
                int32_t* len,
                UErrorCode* status);
@@ -383,10 +386,10 @@ ures_getString(const UResourceBundle* resourceBundle,
  * it may need to be copied, or transformed from UTF-16 using u_strToUTF8()
  * or equivalent.
  *
- * If forceCopy==TRUE, then the string is always written to the dest buffer
+ * If forceCopy==true, then the string is always written to the dest buffer
  * and dest is returned.
  *
- * If forceCopy==FALSE, then the string is returned as a pointer if possible,
+ * If forceCopy==false, then the string is returned as a pointer if possible,
  * without needing a dest buffer (it can be NULL). If the string needs to be
  * copied or transformed, then it may be placed into dest at an arbitrary offset.
  *
@@ -404,10 +407,10 @@ ures_getString(const UResourceBundle* resourceBundle,
  *               terminating NUL, even in case of U_BUFFER_OVERFLOW_ERROR.
  *               Can be NULL, meaning capacity=0 and the string length is not
  *               returned to the caller.
- * @param forceCopy If TRUE, then the output string will always be written to
+ * @param forceCopy If true, then the output string will always be written to
  *                  dest, with U_BUFFER_OVERFLOW_ERROR and
  *                  U_STRING_NOT_TERMINATED_WARNING set if appropriate.
- *                  If FALSE, then the dest buffer may or may not contain a
+ *                  If false, then the dest buffer may or may not contain a
  *                  copy of the string. dest may or may not be modified.
  *                  If a copy needs to be written, then the UErrorCode parameter
  *                  indicates overflow etc. as usual.
@@ -424,7 +427,7 @@ ures_getString(const UResourceBundle* resourceBundle,
  * @see u_strToUTF8
  * @stable ICU 3.6
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ures_getUTF8String(const UResourceBundle *resB,
                    char *dest, int32_t *length,
                    UBool forceCopy,
@@ -447,7 +450,7 @@ ures_getUTF8String(const UResourceBundle *resB,
  * @see ures_getUInt
  * @stable ICU 2.0
  */
-U_STABLE const uint8_t* U_EXPORT2
+U_CAPI const uint8_t* U_EXPORT2
 ures_getBinary(const UResourceBundle* resourceBundle,
                int32_t* len,
                UErrorCode* status);
@@ -469,7 +472,7 @@ ures_getBinary(const UResourceBundle* resourceBundle,
  * @see ures_getUInt
  * @stable ICU 2.0
  */
-U_STABLE const int32_t* U_EXPORT2
+U_CAPI const int32_t* U_EXPORT2
 ures_getIntVector(const UResourceBundle* resourceBundle,
                   int32_t* len,
                   UErrorCode* status);
@@ -490,7 +493,7 @@ ures_getIntVector(const UResourceBundle* resourceBundle,
  * @see ures_getString
  * @stable ICU 2.0
  */
-U_STABLE uint32_t U_EXPORT2
+U_CAPI uint32_t U_EXPORT2
 ures_getUInt(const UResourceBundle* resourceBundle,
              UErrorCode *status);
 
@@ -510,7 +513,7 @@ ures_getUInt(const UResourceBundle* resourceBundle,
  * @see ures_getString
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ures_getInt(const UResourceBundle* resourceBundle,
             UErrorCode *status);
 
@@ -524,7 +527,7 @@ ures_getInt(const UResourceBundle* resourceBundle,
  * @return number of resources in a given resource.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ures_getSize(const UResourceBundle *resourceBundle);
 
 /**
@@ -535,7 +538,7 @@ ures_getSize(const UResourceBundle *resourceBundle);
  * @see UResType
  * @stable ICU 2.0
  */
-U_STABLE UResType U_EXPORT2
+U_CAPI UResType U_EXPORT2
 ures_getType(const UResourceBundle *resourceBundle);
 
 /**
@@ -546,7 +549,7 @@ ures_getType(const UResourceBundle *resourceBundle);
  * @return a key associated to this resource, or NULL if it doesn't have a key
  * @stable ICU 2.0
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ures_getKey(const UResourceBundle *resourceBundle);
 
 /* ITERATION API
@@ -559,17 +562,17 @@ ures_getKey(const UResourceBundle *resourceBundle);
  * @param resourceBundle a resource
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ures_resetIterator(UResourceBundle *resourceBundle);
 
 /**
  * Checks whether the given resource has another element to iterate over.
  *
  * @param resourceBundle a resource
- * @return TRUE if there are more elements, FALSE if there is no more elements
+ * @return true if there are more elements, false if there is no more elements
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ures_hasNext(const UResourceBundle *resourceBundle);
 
 /**
@@ -584,7 +587,7 @@ ures_hasNext(const UResourceBundle *resourceBundle);
  * @return                  a pointer to a UResourceBundle struct. If fill in param was NULL, caller must close it
  * @stable ICU 2.0
  */
-U_STABLE UResourceBundle* U_EXPORT2
+U_CAPI UResourceBundle* U_EXPORT2
 ures_getNextResource(UResourceBundle *resourceBundle,
                      UResourceBundle *fillIn,
                      UErrorCode *status);
@@ -601,7 +604,7 @@ ures_getNextResource(UResourceBundle *resourceBundle,
  * @return a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
  * @stable ICU 2.0
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ures_getNextString(UResourceBundle *resourceBundle,
                    int32_t* len,
                    const char ** key,
@@ -619,7 +622,7 @@ ures_getNextString(UResourceBundle *resourceBundle,
  * @return                  a pointer to a UResourceBundle struct. If fill in param was NULL, caller must close it
  * @stable ICU 2.0
  */
-U_STABLE UResourceBundle* U_EXPORT2
+U_CAPI UResourceBundle* U_EXPORT2
 ures_getByIndex(const UResourceBundle *resourceBundle,
                 int32_t indexR,
                 UResourceBundle *fillIn,
@@ -636,7 +639,7 @@ ures_getByIndex(const UResourceBundle *resourceBundle,
  * @return                  a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
  * @stable ICU 2.0
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ures_getStringByIndex(const UResourceBundle *resourceBundle,
                       int32_t indexS,
                       int32_t* len,
@@ -648,10 +651,10 @@ ures_getStringByIndex(const UResourceBundle *resourceBundle,
  * it may need to be copied, or transformed from UTF-16 using u_strToUTF8()
  * or equivalent.
  *
- * If forceCopy==TRUE, then the string is always written to the dest buffer
+ * If forceCopy==true, then the string is always written to the dest buffer
  * and dest is returned.
  *
- * If forceCopy==FALSE, then the string is returned as a pointer if possible,
+ * If forceCopy==false, then the string is returned as a pointer if possible,
  * without needing a dest buffer (it can be NULL). If the string needs to be
  * copied or transformed, then it may be placed into dest at an arbitrary offset.
  *
@@ -670,10 +673,10 @@ ures_getStringByIndex(const UResourceBundle *resourceBundle,
  *               terminating NUL, even in case of U_BUFFER_OVERFLOW_ERROR.
  *               Can be NULL, meaning capacity=0 and the string length is not
  *               returned to the caller.
- * @param forceCopy If TRUE, then the output string will always be written to
+ * @param forceCopy If true, then the output string will always be written to
  *                  dest, with U_BUFFER_OVERFLOW_ERROR and
  *                  U_STRING_NOT_TERMINATED_WARNING set if appropriate.
- *                  If FALSE, then the dest buffer may or may not contain a
+ *                  If false, then the dest buffer may or may not contain a
  *                  copy of the string. dest may or may not be modified.
  *                  If a copy needs to be written, then the UErrorCode parameter
  *                  indicates overflow etc. as usual.
@@ -690,7 +693,7 @@ ures_getStringByIndex(const UResourceBundle *resourceBundle,
  * @see u_strToUTF8
  * @stable ICU 3.6
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ures_getUTF8StringByIndex(const UResourceBundle *resB,
                           int32_t stringIndex,
                           char *dest, int32_t *pLength,
@@ -709,7 +712,7 @@ ures_getUTF8StringByIndex(const UResourceBundle *resB,
  * @return                  a pointer to a UResourceBundle struct. If fill in param was NULL, caller must close it
  * @stable ICU 2.0
  */
-U_STABLE UResourceBundle* U_EXPORT2
+U_CAPI UResourceBundle* U_EXPORT2
 ures_getByKey(const UResourceBundle *resourceBundle,
               const char* key,
               UResourceBundle *fillIn,
@@ -727,7 +730,7 @@ ures_getByKey(const UResourceBundle *resourceBundle,
  * @return                  a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
  * @stable ICU 2.0
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ures_getStringByKey(const UResourceBundle *resB,
                     const char* key,
                     int32_t* len,
@@ -741,10 +744,10 @@ ures_getStringByKey(const UResourceBundle *resB,
  * it may need to be copied, or transformed from UTF-16 using u_strToUTF8()
  * or equivalent.
  *
- * If forceCopy==TRUE, then the string is always written to the dest buffer
+ * If forceCopy==true, then the string is always written to the dest buffer
  * and dest is returned.
  *
- * If forceCopy==FALSE, then the string is returned as a pointer if possible,
+ * If forceCopy==false, then the string is returned as a pointer if possible,
  * without needing a dest buffer (it can be NULL). If the string needs to be
  * copied or transformed, then it may be placed into dest at an arbitrary offset.
  *
@@ -763,10 +766,10 @@ ures_getStringByKey(const UResourceBundle *resB,
  *               terminating NUL, even in case of U_BUFFER_OVERFLOW_ERROR.
  *               Can be NULL, meaning capacity=0 and the string length is not
  *               returned to the caller.
- * @param forceCopy If TRUE, then the output string will always be written to
+ * @param forceCopy If true, then the output string will always be written to
  *                  dest, with U_BUFFER_OVERFLOW_ERROR and
  *                  U_STRING_NOT_TERMINATED_WARNING set if appropriate.
- *                  If FALSE, then the dest buffer may or may not contain a
+ *                  If false, then the dest buffer may or may not contain a
  *                  copy of the string. dest may or may not be modified.
  *                  If a copy needs to be written, then the UErrorCode parameter
  *                  indicates overflow etc. as usual.
@@ -783,7 +786,7 @@ ures_getStringByKey(const UResourceBundle *resB,
  * @see u_strToUTF8
  * @stable ICU 3.6
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ures_getUTF8StringByKey(const UResourceBundle *resB,
                         const char *key,
                         char *dest, int32_t *pLength,
@@ -811,7 +814,7 @@ ures_getUnicodeString(const UResourceBundle *resB, UErrorCode* status) {
     int32_t len = 0;
     const UChar *r = ures_getString(resB, &len, status);
     if(U_SUCCESS(*status)) {
-        result.setTo(TRUE, r, len);
+        result.setTo(true, r, len);
     } else {
         result.setToBogus();
     }
@@ -836,7 +839,7 @@ ures_getNextUnicodeString(UResourceBundle *resB, const char ** key, UErrorCode*
     int32_t len = 0;
     const UChar* r = ures_getNextString(resB, &len, key, status);
     if(U_SUCCESS(*status)) {
-        result.setTo(TRUE, r, len);
+        result.setTo(true, r, len);
     } else {
         result.setToBogus();
     }
@@ -858,7 +861,7 @@ ures_getUnicodeStringByIndex(const UResourceBundle *resB, int32_t indexS, UError
     int32_t len = 0;
     const UChar* r = ures_getStringByIndex(resB, indexS, &len, status);
     if(U_SUCCESS(*status)) {
-        result.setTo(TRUE, r, len);
+        result.setTo(true, r, len);
     } else {
         result.setToBogus();
     }
@@ -881,7 +884,7 @@ ures_getUnicodeStringByKey(const UResourceBundle *resB, const char* key, UErrorC
     int32_t len = 0;
     const UChar* r = ures_getStringByKey(resB, key, &len, status);
     if(U_SUCCESS(*status)) {
-        result.setTo(TRUE, r, len);
+        result.setTo(true, r, len);
     } else {
         result.setToBogus();
     }
@@ -900,7 +903,7 @@ U_NAMESPACE_END
  * @param status error code
  * @stable ICU 3.2
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ures_openAvailableLocales(const char *packageName, UErrorCode *status);
 
 
diff --git a/deps/icu-small/source/common/unicode/uscript.h b/deps/icu-small/source/common/unicode/uscript.h
index 53d57abed14cd0e3f080dc736bf441e86df70988..8448afda761550026b8044605cfe4da0a15d6aee 100644
--- a/deps/icu-small/source/common/unicode/uscript.h
+++ b/deps/icu-small/source/common/unicode/uscript.h
@@ -514,7 +514,7 @@ typedef enum UScriptCode {
  * @return The number of script codes filled in the buffer passed in
  * @stable ICU 2.4
  */
-U_STABLE int32_t  U_EXPORT2
+U_CAPI int32_t  U_EXPORT2
 uscript_getCode(const char* nameOrAbbrOrLocale,UScriptCode* fillIn,int32_t capacity,UErrorCode *err);
 
 /**
@@ -527,7 +527,7 @@ uscript_getCode(const char* nameOrAbbrOrLocale,UScriptCode* fillIn,int32_t capac
  * or NULL if scriptCode is invalid
  * @stable ICU 2.4
  */
-U_STABLE const char*  U_EXPORT2
+U_CAPI const char*  U_EXPORT2
 uscript_getName(UScriptCode scriptCode);
 
 /**
@@ -539,7 +539,7 @@ uscript_getName(UScriptCode scriptCode);
  * @return short script name (4-letter code), or NULL if scriptCode is invalid
  * @stable ICU 2.4
  */
-U_STABLE const char*  U_EXPORT2
+U_CAPI const char*  U_EXPORT2
 uscript_getShortName(UScriptCode scriptCode);
 
 /**
@@ -550,7 +550,7 @@ uscript_getShortName(UScriptCode scriptCode);
  * @return The UScriptCode, or 0 if codepoint is invalid
  * @stable ICU 2.4
  */
-U_STABLE UScriptCode  U_EXPORT2
+U_CAPI UScriptCode  U_EXPORT2
 uscript_getScript(UChar32 codepoint, UErrorCode *err);
 
 /**
@@ -562,10 +562,10 @@ uscript_getScript(UChar32 codepoint, UErrorCode *err);
  * For more information, see UAX #24: http://www.unicode.org/reports/tr24/.
  * @param c code point
  * @param sc script code
- * @return TRUE if sc is in Script_Extensions(c)
+ * @return true if sc is in Script_Extensions(c)
  * @stable ICU 49
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uscript_hasScript(UChar32 c, UScriptCode sc);
 
 /**
@@ -597,7 +597,7 @@ uscript_hasScript(UChar32 c, UScriptCode sc);
  *         written to scripts unless U_BUFFER_OVERFLOW_ERROR indicates insufficient capacity
  * @stable ICU 49
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uscript_getScriptExtensions(UChar32 c,
                             UScriptCode *scripts, int32_t capacity,
                             UErrorCode *errorCode);
@@ -636,7 +636,7 @@ typedef enum UScriptUsage {
  * @return the string length, even if U_BUFFER_OVERFLOW_ERROR
  * @stable ICU 51
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uscript_getSampleString(UScriptCode script, UChar *dest, int32_t capacity, UErrorCode *pErrorCode);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -668,41 +668,41 @@ uscript_getSampleUnicodeString(UScriptCode script);
  * @see UScriptUsage
  * @stable ICU 51
  */
-U_STABLE UScriptUsage U_EXPORT2
+U_CAPI UScriptUsage U_EXPORT2
 uscript_getUsage(UScriptCode script);
 
 /**
- * Returns TRUE if the script is written right-to-left.
+ * Returns true if the script is written right-to-left.
  * For example, Arab and Hebr.
  *
  * @param script script code
- * @return TRUE if the script is right-to-left
+ * @return true if the script is right-to-left
  * @stable ICU 51
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uscript_isRightToLeft(UScriptCode script);
 
 /**
- * Returns TRUE if the script allows line breaks between letters (excluding hyphenation).
+ * Returns true if the script allows line breaks between letters (excluding hyphenation).
  * Such a script typically requires dictionary-based line breaking.
  * For example, Hani and Thai.
  *
  * @param script script code
- * @return TRUE if the script allows line breaks between letters
+ * @return true if the script allows line breaks between letters
  * @stable ICU 51
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uscript_breaksBetweenLetters(UScriptCode script);
 
 /**
- * Returns TRUE if in modern (or most recent) usage of the script case distinctions are customary.
+ * Returns true if in modern (or most recent) usage of the script case distinctions are customary.
  * For example, Latn and Cyrl.
  *
  * @param script script code
- * @return TRUE if the script is cased
+ * @return true if the script is cased
  * @stable ICU 51
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uscript_isCased(UScriptCode script);
 
 #endif
diff --git a/deps/icu-small/source/common/unicode/uset.h b/deps/icu-small/source/common/unicode/uset.h
index ef6bbb5c38f3fb8ecd635298dc3aed03326a626f..a32f52c678a28ae952b32dbf69ecf180c6f81582 100644
--- a/deps/icu-small/source/common/unicode/uset.h
+++ b/deps/icu-small/source/common/unicode/uset.h
@@ -31,7 +31,10 @@
 
 #include "unicode/utypes.h"
 #include "unicode/uchar.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 #ifndef USET_DEFINED
 
@@ -158,7 +161,7 @@ typedef enum USetSpanCondition {
      * Continues a span() while there is no set element at the current position.
      * Increments by one code point at a time.
      * Stops before the first set element (character or string).
-     * (For code points only, this is like while contains(current)==FALSE).
+     * (For code points only, this is like while contains(current)==false).
      *
      * When span() returns, the substring between where it started and the position
      * it returned consists only of characters that are not in the set,
@@ -169,7 +172,7 @@ typedef enum USetSpanCondition {
     USET_SPAN_NOT_CONTAINED = 0,
     /**
      * Spans the longest substring that is a concatenation of set elements (characters or strings).
-     * (For characters only, this is like while contains(current)==TRUE).
+     * (For characters only, this is like while contains(current)==true).
      *
      * When span() returns, the substring between where it started and the position
      * it returned consists only of set elements (characters or strings) that are in the set.
@@ -185,7 +188,7 @@ typedef enum USetSpanCondition {
     /**
      * Continues a span() while there is a set element at the current position.
      * Increments by the longest matching element at each position.
-     * (For characters only, this is like while contains(current)==TRUE).
+     * (For characters only, this is like while contains(current)==true).
      *
      * When span() returns, the substring between where it started and the position
      * it returned consists only of set elements (characters or strings) that are in the set.
@@ -260,7 +263,7 @@ typedef struct USerializedSet {
  * it when done.
  * @stable ICU 4.2
  */
-U_STABLE USet* U_EXPORT2
+U_CAPI USet* U_EXPORT2
 uset_openEmpty(void);
 
 /**
@@ -273,7 +276,7 @@ uset_openEmpty(void);
  * it when done.
  * @stable ICU 2.4
  */
-U_STABLE USet* U_EXPORT2
+U_CAPI USet* U_EXPORT2
 uset_open(UChar32 start, UChar32 end);
 
 /**
@@ -285,7 +288,7 @@ uset_open(UChar32 start, UChar32 end);
  * @param ec the error code
  * @stable ICU 2.4
  */
-U_STABLE USet* U_EXPORT2
+U_CAPI USet* U_EXPORT2
 uset_openPattern(const UChar* pattern, int32_t patternLength,
                  UErrorCode* ec);
 
@@ -300,7 +303,7 @@ uset_openPattern(const UChar* pattern, int32_t patternLength,
  * @param ec the error code
  * @stable ICU 2.4
  */
-U_STABLE USet* U_EXPORT2
+U_CAPI USet* U_EXPORT2
 uset_openPatternOptions(const UChar* pattern, int32_t patternLength,
                  uint32_t options,
                  UErrorCode* ec);
@@ -311,7 +314,7 @@ uset_openPatternOptions(const UChar* pattern, int32_t patternLength,
  * @param set the object to dispose of
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_close(USet* set);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -342,19 +345,19 @@ U_NAMESPACE_END
  * @see uset_cloneAsThawed
  * @stable ICU 3.8
  */
-U_STABLE USet * U_EXPORT2
+U_CAPI USet * U_EXPORT2
 uset_clone(const USet *set);
 
 /**
  * Determines whether the set has been frozen (made immutable) or not.
  * See the ICU4J Freezable interface for details.
  * @param set the set
- * @return TRUE/FALSE for whether the set has been frozen
+ * @return true/false for whether the set has been frozen
  * @see uset_freeze
  * @see uset_cloneAsThawed
  * @stable ICU 3.8
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_isFrozen(const USet *set);
 
 /**
@@ -371,7 +374,7 @@ uset_isFrozen(const USet *set);
  * @see uset_cloneAsThawed
  * @stable ICU 3.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_freeze(USet *set);
 
 /**
@@ -384,7 +387,7 @@ uset_freeze(USet *set);
  * @see uset_clone
  * @stable ICU 3.8
  */
-U_STABLE USet * U_EXPORT2
+U_CAPI USet * U_EXPORT2
 uset_cloneAsThawed(const USet *set);
 
 /**
@@ -396,7 +399,7 @@ uset_cloneAsThawed(const USet *set);
  * @param end last character in the set, inclusive
  * @stable ICU 3.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_set(USet* set,
          UChar32 start, UChar32 end);
 
@@ -421,7 +424,7 @@ uset_set(USet* set,
  *
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_applyPattern(USet *set,
                   const UChar *pattern, int32_t patternLength,
                   uint32_t options,
@@ -449,7 +452,7 @@ uset_applyPattern(USet *set,
  *
  * @stable ICU 3.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_applyIntPropertyValue(USet* set,
                            UProperty prop, int32_t value, UErrorCode* ec);
 
@@ -488,7 +491,7 @@ uset_applyIntPropertyValue(USet* set,
  *
  * @stable ICU 3.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_applyPropertyAlias(USet* set,
                         const UChar *prop, int32_t propLength,
                         const UChar *value, int32_t valueLength,
@@ -503,7 +506,7 @@ uset_applyPropertyAlias(USet* set,
  * @param pos the given position
  * @stable ICU 3.2
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_resemblesPattern(const UChar *pattern, int32_t patternLength,
                       int32_t pos);
 
@@ -514,7 +517,7 @@ uset_resemblesPattern(const UChar *pattern, int32_t patternLength,
  * @param set the set
  * @param result the string to receive the rules, may be NULL
  * @param resultCapacity the capacity of result, may be 0 if result is NULL
- * @param escapeUnprintable if TRUE then convert unprintable
+ * @param escapeUnprintable if true then convert unprintable
  * character to their hex escape representations, \\uxxxx or
  * \\Uxxxxxxxx.  Unprintable characters are those other than
  * U+000A, U+0020..U+007E.
@@ -522,7 +525,7 @@ uset_resemblesPattern(const UChar *pattern, int32_t patternLength,
  * @return length of string, possibly larger than resultCapacity
  * @stable ICU 2.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_toPattern(const USet* set,
                UChar* result, int32_t resultCapacity,
                UBool escapeUnprintable,
@@ -530,13 +533,13 @@ uset_toPattern(const USet* set,
 
 /**
  * Adds the given character to the given USet.  After this call,
- * uset_contains(set, c) will return TRUE.
+ * uset_contains(set, c) will return true.
  * A frozen set will not be modified.
  * @param set the object to which to add the character
  * @param c the character to add
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_add(USet* set, UChar32 c);
 
 /**
@@ -551,80 +554,94 @@ uset_add(USet* set, UChar32 c);
  * @param additionalSet the source set whose elements are to be added to this set.
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_addAll(USet* set, const USet *additionalSet);
 
 /**
  * Adds the given range of characters to the given USet.  After this call,
- * uset_contains(set, start, end) will return TRUE.
+ * uset_contains(set, start, end) will return true.
  * A frozen set will not be modified.
  * @param set the object to which to add the character
  * @param start the first character of the range to add, inclusive
  * @param end the last character of the range to add, inclusive
  * @stable ICU 2.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_addRange(USet* set, UChar32 start, UChar32 end);
 
 /**
  * Adds the given string to the given USet.  After this call,
- * uset_containsString(set, str, strLen) will return TRUE.
+ * uset_containsString(set, str, strLen) will return true.
  * A frozen set will not be modified.
  * @param set the object to which to add the character
  * @param str the string to add
  * @param strLen the length of the string or -1 if null terminated.
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_addString(USet* set, const UChar* str, int32_t strLen);
 
 /**
- * Adds each of the characters in this string to the set. Thus "ch" => {"c", "h"}
- * If this set already any particular character, it has no effect on that character.
+ * Adds each of the characters in this string to the set. Note: "ch" => {"c", "h"}
+ * If this set already contains any particular character, it has no effect on that character.
  * A frozen set will not be modified.
  * @param set the object to which to add the character
  * @param str the source string
  * @param strLen the length of the string or -1 if null terminated.
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_addAllCodePoints(USet* set, const UChar *str, int32_t strLen);
 
 /**
  * Removes the given character from the given USet.  After this call,
- * uset_contains(set, c) will return FALSE.
+ * uset_contains(set, c) will return false.
  * A frozen set will not be modified.
  * @param set the object from which to remove the character
  * @param c the character to remove
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_remove(USet* set, UChar32 c);
 
 /**
  * Removes the given range of characters from the given USet.  After this call,
- * uset_contains(set, start, end) will return FALSE.
+ * uset_contains(set, start, end) will return false.
  * A frozen set will not be modified.
  * @param set the object to which to add the character
  * @param start the first character of the range to remove, inclusive
  * @param end the last character of the range to remove, inclusive
  * @stable ICU 2.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_removeRange(USet* set, UChar32 start, UChar32 end);
 
 /**
  * Removes the given string to the given USet.  After this call,
- * uset_containsString(set, str, strLen) will return FALSE.
+ * uset_containsString(set, str, strLen) will return false.
  * A frozen set will not be modified.
  * @param set the object to which to add the character
  * @param str the string to remove
  * @param strLen the length of the string or -1 if null terminated.
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_removeString(USet* set, const UChar* str, int32_t strLen);
 
+#ifndef U_HIDE_DRAFT_API
+/**
+ * Removes EACH of the characters in this string. Note: "ch" == {"c", "h"}
+ * A frozen set will not be modified.
+ *
+ * @param set the object to be modified
+ * @param str the string
+ * @param length the length of the string, or -1 if NUL-terminated
+ * @draft ICU 69
+ */
+U_CAPI void U_EXPORT2
+uset_removeAllCodePoints(USet *set, const UChar *str, int32_t length);
+#endif  // U_HIDE_DRAFT_API
+
 /**
  * Removes from this set all of its elements that are contained in the
  * specified set.  This operation effectively modifies this
@@ -636,7 +653,7 @@ uset_removeString(USet* set, const UChar* str, int32_t strLen);
  * removed from this set
  * @stable ICU 3.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_removeAll(USet* set, const USet* removeSet);
 
 /**
@@ -647,15 +664,41 @@ uset_removeAll(USet* set, const USet* removeSet);
  * A frozen set will not be modified.
  *
  * @param set the object for which to retain only the specified range
- * @param start first character, inclusive, of range to be retained
- * to this set.
- * @param end last character, inclusive, of range to be retained
- * to this set.
+ * @param start first character, inclusive, of range
+ * @param end last character, inclusive, of range
  * @stable ICU 3.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_retain(USet* set, UChar32 start, UChar32 end);
 
+#ifndef U_HIDE_DRAFT_API
+/**
+ * Retains only the specified string from this set if it is present.
+ * Upon return this set will be empty if it did not contain s, or
+ * will only contain s if it did contain s.
+ * A frozen set will not be modified.
+ *
+ * @param set the object to be modified
+ * @param str the string
+ * @param length the length of the string, or -1 if NUL-terminated
+ * @draft ICU 69
+ */
+U_CAPI void U_EXPORT2
+uset_retainString(USet *set, const UChar *str, int32_t length);
+
+/**
+ * Retains EACH of the characters in this string. Note: "ch" == {"c", "h"}
+ * A frozen set will not be modified.
+ *
+ * @param set the object to be modified
+ * @param str the string
+ * @param length the length of the string, or -1 if NUL-terminated
+ * @draft ICU 69
+ */
+U_CAPI void U_EXPORT2
+uset_retainAllCodePoints(USet *set, const UChar *str, int32_t length);
+#endif  // U_HIDE_DRAFT_API
+
 /**
  * Retains only the elements in this set that are contained in the
  * specified set.  In other words, removes from this set all of
@@ -668,7 +711,7 @@ uset_retain(USet* set, UChar32 start, UChar32 end);
  * @param retain set that defines which elements this set will retain
  * @stable ICU 3.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_retainAll(USet* set, const USet* retain);
 
 /**
@@ -679,7 +722,7 @@ uset_retainAll(USet* set, const USet* retain);
  * @param set the object on which to perfrom the compact
  * @stable ICU 3.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_compact(USet* set);
 
 /**
@@ -690,9 +733,52 @@ uset_compact(USet* set);
  * @param set the set
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_complement(USet* set);
 
+#ifndef U_HIDE_DRAFT_API
+/**
+ * Complements the specified range in this set.  Any character in
+ * the range will be removed if it is in this set, or will be
+ * added if it is not in this set.  If <code>start > end</code>
+ * then an empty range is complemented, leaving the set unchanged.
+ * This is equivalent to a boolean logic XOR.
+ * A frozen set will not be modified.
+ *
+ * @param set the object to be modified
+ * @param start first character, inclusive, of range
+ * @param end last character, inclusive, of range
+ * @draft ICU 69
+ */
+U_CAPI void U_EXPORT2
+uset_complementRange(USet *set, UChar32 start, UChar32 end);
+
+/**
+ * Complements the specified string in this set.
+ * The string will be removed if it is in this set, or will be added if it is not in this set.
+ * A frozen set will not be modified.
+ *
+ * @param set the object to be modified
+ * @param str the string
+ * @param length the length of the string, or -1 if NUL-terminated
+ * @draft ICU 69
+ */
+U_CAPI void U_EXPORT2
+uset_complementString(USet *set, const UChar *str, int32_t length);
+
+/**
+ * Complements EACH of the characters in this string. Note: "ch" == {"c", "h"}
+ * A frozen set will not be modified.
+ *
+ * @param set the object to be modified
+ * @param str the string
+ * @param length the length of the string, or -1 if NUL-terminated
+ * @draft ICU 69
+ */
+U_CAPI void U_EXPORT2
+uset_complementAllCodePoints(USet *set, const UChar *str, int32_t length);
+#endif  // U_HIDE_DRAFT_API
+
 /**
  * Complements in this set all elements contained in the specified
  * set.  Any character in the other set will be removed if it is
@@ -704,7 +790,7 @@ uset_complement(USet* set);
  * from this set.
  * @stable ICU 3.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_complementAll(USet* set, const USet* complement);
 
 /**
@@ -714,7 +800,7 @@ uset_complementAll(USet* set, const USet* complement);
  * @param set the set
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_clear(USet* set);
 
 /**
@@ -743,7 +829,7 @@ uset_clear(USet* set);
  * are ignored.
  * @stable ICU 4.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_closeOver(USet* set, int32_t attributes);
 
 /**
@@ -752,51 +838,51 @@ uset_closeOver(USet* set, int32_t attributes);
  * @param set the set
  * @stable ICU 4.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_removeAllStrings(USet* set);
 
 /**
- * Returns TRUE if the given USet contains no characters and no
+ * Returns true if the given USet contains no characters and no
  * strings.
  * @param set the set
  * @return true if set is empty
  * @stable ICU 2.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_isEmpty(const USet* set);
 
 /**
- * Returns TRUE if the given USet contains the given character.
+ * Returns true if the given USet contains the given character.
  * This function works faster with a frozen set.
  * @param set the set
  * @param c The codepoint to check for within the set
  * @return true if set contains c
  * @stable ICU 2.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_contains(const USet* set, UChar32 c);
 
 /**
- * Returns TRUE if the given USet contains all characters c
+ * Returns true if the given USet contains all characters c
  * where start <= c && c <= end.
  * @param set the set
  * @param start the first character of the range to test, inclusive
  * @param end the last character of the range to test, inclusive
- * @return TRUE if set contains the range
+ * @return true if set contains the range
  * @stable ICU 2.2
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_containsRange(const USet* set, UChar32 start, UChar32 end);
 
 /**
- * Returns TRUE if the given USet contains the given string.
+ * Returns true if the given USet contains the given string.
  * @param set the set
  * @param str the string
  * @param strLen the length of the string or -1 if null terminated.
  * @return true if set contains str
  * @stable ICU 2.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_containsString(const USet* set, const UChar* str, int32_t strLen);
 
 /**
@@ -809,7 +895,7 @@ uset_containsString(const USet* set, const UChar* str, int32_t strLen);
  * @return an index from 0..size()-1, or -1
  * @stable ICU 3.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_indexOf(const USet* set, UChar32 c);
 
 /**
@@ -822,7 +908,7 @@ uset_indexOf(const USet* set, UChar32 c);
  * @return the character at the given index, or (UChar32)-1.
  * @stable ICU 3.2
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 uset_charAt(const USet* set, int32_t charIndex);
 
 /**
@@ -833,7 +919,7 @@ uset_charAt(const USet* set, int32_t charIndex);
  * contained in set
  * @stable ICU 2.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_size(const USet* set);
 
 /**
@@ -844,7 +930,7 @@ uset_size(const USet* set);
  * and/or strings contained in set
  * @stable ICU 2.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_getItemCount(const USet* set);
 
 /**
@@ -865,7 +951,7 @@ uset_getItemCount(const USet* set);
  * itemIndex is out of range
  * @stable ICU 2.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_getItem(const USet* set, int32_t itemIndex,
              UChar32* start, UChar32* end,
              UChar* str, int32_t strCapacity,
@@ -879,7 +965,7 @@ uset_getItem(const USet* set, int32_t itemIndex,
  * @return true if the test condition is met
  * @stable ICU 3.2
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_containsAll(const USet* set1, const USet* set2);
 
 /**
@@ -892,7 +978,7 @@ uset_containsAll(const USet* set1, const USet* set2);
  * @return true if the test condition is met
  * @stable ICU 3.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_containsAllCodePoints(const USet* set, const UChar *str, int32_t strLen);
 
 /**
@@ -903,7 +989,7 @@ uset_containsAllCodePoints(const USet* set, const UChar *str, int32_t strLen);
  * @return true if the test condition is met
  * @stable ICU 3.2
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_containsNone(const USet* set1, const USet* set2);
 
 /**
@@ -914,7 +1000,7 @@ uset_containsNone(const USet* set1, const USet* set2);
  * @return true if the test condition is met
  * @stable ICU 3.2
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_containsSome(const USet* set1, const USet* set2);
 
 /**
@@ -936,7 +1022,7 @@ uset_containsSome(const USet* set1, const USet* set2);
  * @stable ICU 3.8
  * @see USetSpanCondition
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_span(const USet *set, const UChar *s, int32_t length, USetSpanCondition spanCondition);
 
 /**
@@ -957,7 +1043,7 @@ uset_span(const USet *set, const UChar *s, int32_t length, USetSpanCondition spa
  * @stable ICU 3.8
  * @see USetSpanCondition
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_spanBack(const USet *set, const UChar *s, int32_t length, USetSpanCondition spanCondition);
 
 /**
@@ -979,7 +1065,7 @@ uset_spanBack(const USet *set, const UChar *s, int32_t length, USetSpanCondition
  * @stable ICU 3.8
  * @see USetSpanCondition
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_spanUTF8(const USet *set, const char *s, int32_t length, USetSpanCondition spanCondition);
 
 /**
@@ -1000,7 +1086,7 @@ uset_spanUTF8(const USet *set, const char *s, int32_t length, USetSpanCondition
  * @stable ICU 3.8
  * @see USetSpanCondition
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_spanBackUTF8(const USet *set, const char *s, int32_t length, USetSpanCondition spanCondition);
 
 /**
@@ -1011,7 +1097,7 @@ uset_spanBackUTF8(const USet *set, const char *s, int32_t length, USetSpanCondit
  * @return true if the test condition is met
  * @stable ICU 3.2
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_equals(const USet* set1, const USet* set2);
 
 /*********************************************************************
@@ -1067,7 +1153,7 @@ uset_equals(const USet* set1, const USet* set2);
  * than U_BUFFER_OVERFLOW_ERROR.
  * @stable ICU 2.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_serialize(const USet* set, uint16_t* dest, int32_t destCapacity, UErrorCode* pErrorCode);
 
 /**
@@ -1078,7 +1164,7 @@ uset_serialize(const USet* set, uint16_t* dest, int32_t destCapacity, UErrorCode
  * @return true if the given array is valid, otherwise false
  * @stable ICU 2.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_getSerializedSet(USerializedSet* fillSet, const uint16_t* src, int32_t srcLength);
 
 /**
@@ -1088,18 +1174,18 @@ uset_getSerializedSet(USerializedSet* fillSet, const uint16_t* src, int32_t srcL
  * @param c The codepoint to set
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uset_setSerializedToOne(USerializedSet* fillSet, UChar32 c);
 
 /**
- * Returns TRUE if the given USerializedSet contains the given
+ * Returns true if the given USerializedSet contains the given
  * character.
  * @param set the serialized set
  * @param c The codepoint to check for within the set
  * @return true if set contains c
  * @stable ICU 2.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_serializedContains(const USerializedSet* set, UChar32 c);
 
 /**
@@ -1111,7 +1197,7 @@ uset_serializedContains(const USerializedSet* set, UChar32 c);
  * contained in set
  * @stable ICU 2.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uset_getSerializedRangeCount(const USerializedSet* set);
 
 /**
@@ -1127,7 +1213,7 @@ uset_getSerializedRangeCount(const USerializedSet* set);
  * @return true if rangeIndex is valid, otherwise false
  * @stable ICU 2.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uset_getSerializedRange(const USerializedSet* set, int32_t rangeIndex,
                         UChar32* pStart, UChar32* pEnd);
 
diff --git a/deps/icu-small/source/common/unicode/usetiter.h b/deps/icu-small/source/common/unicode/usetiter.h
index f3f470f95aa5f57ebd7bc1cbbb87ce8ea6ae3ac7..45d268a05c9b90725f1ee5236c0d7c6a970191a1 100644
--- a/deps/icu-small/source/common/unicode/usetiter.h
+++ b/deps/icu-small/source/common/unicode/usetiter.h
@@ -176,7 +176,7 @@ class U_COMMON_API UnicodeSetIterator : public UObject {
      * If there are no more elements in the set, return false.
      *
      * <p>
-     * If <tt>isString() == TRUE</tt>, the value is a
+     * If <tt>isString() == true</tt>, the value is a
      * string, otherwise the value is a
      * single code point.  Elements of either type can be retrieved
      * with the function <tt>getString()</tt>, while elements of
@@ -197,7 +197,7 @@ class U_COMMON_API UnicodeSetIterator : public UObject {
     /**
      * Returns the next element in the set, either a code point range
      * or a string.  If there are no more elements in the set, return
-     * false.  If <tt>isString() == TRUE</tt>, the value is a
+     * false.  If <tt>isString() == true</tt>, the value is a
      * string and can be accessed with <tt>getString()</tt>.  Otherwise the value is a
      * range of one or more code points from <tt>getCodepoint()</tt> to
      * <tt>getCodepointeEnd()</tt> inclusive.
@@ -205,7 +205,7 @@ class U_COMMON_API UnicodeSetIterator : public UObject {
      * <p>The order of iteration is all code points ranges in sorted
      * order, followed by all strings sorted order.  Ranges are
      * disjoint and non-contiguous.  The value returned from <tt>getString()</tt>
-     * is undefined unless <tt>isString() == TRUE</tt>.  Do not mix calls to
+     * is undefined unless <tt>isString() == true</tt>.  Do not mix calls to
      * <tt>next()</tt> and <tt>nextRange()</tt> without calling
      * <tt>reset()</tt> between them.  The results of doing so are
      * undefined.
diff --git a/deps/icu-small/source/common/unicode/ushape.h b/deps/icu-small/source/common/unicode/ushape.h
index 3064e0857281c5f71fc46f833cf9e3fcbd06b881..3a4492caff0f0491d6dcdafb5064ab4d5d40cb63 100644
--- a/deps/icu-small/source/common/unicode/ushape.h
+++ b/deps/icu-small/source/common/unicode/ushape.h
@@ -98,7 +98,7 @@
  *         the return value indicates the necessary destination buffer size.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_shapeArabic(const UChar *source, int32_t sourceLength,
               UChar *dest, int32_t destSize,
               uint32_t options,
@@ -323,7 +323,7 @@ u_shapeArabic(const UChar *source, int32_t sourceLength,
 #define U_SHAPE_PRESERVE_PRESENTATION           0x8000
 /** Presentation form option:
  * Replace Arabic Presentation Forms-A and Arabic Presentationo Forms-B with
- * their unshaped correspondants in range 0+06xx, before shaping.
+ * their unshaped correspondents in range 0+06xx, before shaping.
  * @stable ICU 3.6
  */
 #define U_SHAPE_PRESERVE_PRESENTATION_NOOP      0
diff --git a/deps/icu-small/source/common/unicode/usprep.h b/deps/icu-small/source/common/unicode/usprep.h
index 7cdc6cdd18ea6b9d5a54b3e4dec184cf5919f43b..be06189e2e9e6d18f1c6bb0de5d2f7a5bd1825a0 100644
--- a/deps/icu-small/source/common/unicode/usprep.h
+++ b/deps/icu-small/source/common/unicode/usprep.h
@@ -25,7 +25,10 @@
  */
 
 #include "unicode/utypes.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  *
@@ -181,7 +184,7 @@ typedef enum UStringPrepProfileType {
  * @see usprep_close()
  * @stable ICU 2.8
  */
-U_STABLE UStringPrepProfile* U_EXPORT2
+U_CAPI UStringPrepProfile* U_EXPORT2
 usprep_open(const char* path,
             const char* fileName,
             UErrorCode* status);
@@ -197,7 +200,7 @@ usprep_open(const char* path,
  * @see usprep_close()
  * @stable ICU 4.2
  */
-U_STABLE UStringPrepProfile* U_EXPORT2
+U_CAPI UStringPrepProfile* U_EXPORT2
 usprep_openByType(UStringPrepProfileType type,
 				  UErrorCode* status);
 
@@ -206,7 +209,7 @@ usprep_openByType(UStringPrepProfileType type,
  * @param profile The profile to close
  * @stable ICU 2.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 usprep_close(UStringPrepProfile* profile);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -257,7 +260,7 @@ U_NAMESPACE_END
  * @stable ICU 2.8
  */
 
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 usprep_prepare(   const UStringPrepProfile* prep,
                   const UChar* src, int32_t srcLength,
                   UChar* dest, int32_t destCapacity,
diff --git a/deps/icu-small/source/common/unicode/ustring.h b/deps/icu-small/source/common/unicode/ustring.h
index 0d2274a0cabb513fee2b721f27f094586811659f..3243acbb7ebfcefe1d4b61b36b6adbbda730cc57 100644
--- a/deps/icu-small/source/common/unicode/ustring.h
+++ b/deps/icu-small/source/common/unicode/ustring.h
@@ -89,7 +89,7 @@
  * @return The number of UChars in <code>chars</code>, minus the terminator.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strlen(const UChar *s);
 /*@}*/
 
@@ -106,7 +106,7 @@ u_strlen(const UChar *s);
  * @return The number of code points in the specified code units.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_countChar32(const UChar *s, int32_t length);
 
 /**
@@ -127,7 +127,7 @@ u_countChar32(const UChar *s, int32_t length);
  *         than 'number'. Same as (u_countChar32(s, length)>number).
  * @stable ICU 2.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 u_strHasMoreChar32Than(const UChar *s, int32_t length, int32_t number);
 
 /**
@@ -140,7 +140,7 @@ u_strHasMoreChar32Than(const UChar *s, int32_t length, int32_t number);
  * @return A pointer to <code>dst</code>.
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strcat(UChar     *dst,
     const UChar     *src);
 
@@ -158,7 +158,7 @@ u_strcat(UChar     *dst,
  * @return A pointer to <code>dst</code>.
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strncat(UChar     *dst,
      const UChar     *src,
      int32_t     n);
@@ -183,7 +183,7 @@ u_strncat(UChar     *dst,
  * @see u_strFindFirst
  * @see u_strFindLast
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strstr(const UChar *s, const UChar *substring);
 
 /**
@@ -207,7 +207,7 @@ u_strstr(const UChar *s, const UChar *substring);
  * @see u_strstr
  * @see u_strFindLast
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strFindFirst(const UChar *s, int32_t length, const UChar *substring, int32_t subLength);
 
 /**
@@ -227,7 +227,7 @@ u_strFindFirst(const UChar *s, int32_t length, const UChar *substring, int32_t s
  * @see u_strstr
  * @see u_strFindFirst
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strchr(const UChar *s, UChar c);
 
 /**
@@ -247,7 +247,7 @@ u_strchr(const UChar *s, UChar c);
  * @see u_strstr
  * @see u_strFindFirst
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strchr32(const UChar *s, UChar32 c);
 
 /**
@@ -270,7 +270,7 @@ u_strchr32(const UChar *s, UChar32 c);
  * @see u_strFindFirst
  * @see u_strFindLast
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strrstr(const UChar *s, const UChar *substring);
 
 /**
@@ -294,7 +294,7 @@ u_strrstr(const UChar *s, const UChar *substring);
  * @see u_strstr
  * @see u_strFindLast
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strFindLast(const UChar *s, int32_t length, const UChar *substring, int32_t subLength);
 
 /**
@@ -314,7 +314,7 @@ u_strFindLast(const UChar *s, int32_t length, const UChar *substring, int32_t su
  * @see u_strrstr
  * @see u_strFindLast
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strrchr(const UChar *s, UChar c);
 
 /**
@@ -334,7 +334,7 @@ u_strrchr(const UChar *s, UChar c);
  * @see u_strrstr
  * @see u_strFindLast
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strrchr32(const UChar *s, UChar32 c);
 
 /**
@@ -349,7 +349,7 @@ u_strrchr32(const UChar *s, UChar32 c);
  *         characters in <code>matchSet</code>, or NULL if no such character is found.
  * @stable ICU 2.0
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strpbrk(const UChar *string, const UChar *matchSet);
 
 /**
@@ -365,7 +365,7 @@ u_strpbrk(const UChar *string, const UChar *matchSet);
  * @see u_strspn
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strcspn(const UChar *string, const UChar *matchSet);
 
 /**
@@ -381,7 +381,7 @@ u_strcspn(const UChar *string, const UChar *matchSet);
  * @see u_strcspn
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strspn(const UChar *string, const UChar *matchSet);
 
 /**
@@ -409,7 +409,7 @@ u_strspn(const UChar *string, const UChar *matchSet);
  *         when there are no more tokens.
  * @stable ICU 2.0
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strtok_r(UChar    *src,
      const UChar    *delim,
            UChar   **saveState);
@@ -424,7 +424,7 @@ u_strtok_r(UChar    *src,
  * value if <code>s1</code> is bitwise greater than <code>s2</code>.
  * @stable ICU 2.0
  */
-U_STABLE int32_t  U_EXPORT2
+U_CAPI int32_t  U_EXPORT2
 u_strcmp(const UChar     *s1,
          const UChar     *s2);
 
@@ -439,7 +439,7 @@ u_strcmp(const UChar     *s1,
  * in code point order
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strcmpCodePointOrder(const UChar *s1, const UChar *s2);
 
 /**
@@ -462,14 +462,14 @@ u_strcmpCodePointOrder(const UChar *s1, const UChar *s2);
  * @param s2 Second source string.
  * @param length2 Length of second source string, or -1 if NUL-terminated.
  *
- * @param codePointOrder Choose between code unit order (FALSE)
- *                       and code point order (TRUE).
+ * @param codePointOrder Choose between code unit order (false)
+ *                       and code point order (true).
  *
  * @return <0 or 0 or >0 as usual for string comparisons
  *
  * @stable ICU 2.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strCompare(const UChar *s1, int32_t length1,
              const UChar *s2, int32_t length2,
              UBool codePointOrder);
@@ -485,8 +485,8 @@ u_strCompare(const UChar *s1, int32_t length1,
  *
  * @param iter1 First source string iterator.
  * @param iter2 Second source string iterator.
- * @param codePointOrder Choose between code unit order (FALSE)
- *                       and code point order (TRUE).
+ * @param codePointOrder Choose between code unit order (false)
+ *                       and code point order (true).
  *
  * @return <0 or 0 or >0 as usual for string comparisons
  *
@@ -494,7 +494,7 @@ u_strCompare(const UChar *s1, int32_t length1,
  *
  * @stable ICU 2.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strCompareIter(UCharIterator *iter1, UCharIterator *iter2, UBool codePointOrder);
 
 /**
@@ -537,7 +537,7 @@ u_strCompareIter(UCharIterator *iter1, UCharIterator *iter2, UBool codePointOrde
  *
  * @stable ICU 2.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strCaseCompare(const UChar *s1, int32_t length1,
                  const UChar *s2, int32_t length2,
                  uint32_t options,
@@ -555,7 +555,7 @@ u_strCaseCompare(const UChar *s1, int32_t length1,
  * value if <code>s1</code> is bitwise greater than <code>s2</code>.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strncmp(const UChar     *ucs1,
      const UChar     *ucs2,
      int32_t     n);
@@ -573,7 +573,7 @@ u_strncmp(const UChar     *ucs1,
  * in code point order
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strncmpCodePointOrder(const UChar *s1, const UChar *s2, int32_t n);
 
 /**
@@ -595,7 +595,7 @@ u_strncmpCodePointOrder(const UChar *s1, const UChar *s2, int32_t n);
  * @return A negative, zero, or positive integer indicating the comparison result.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strcasecmp(const UChar *s1, const UChar *s2, uint32_t options);
 
 /**
@@ -619,7 +619,7 @@ u_strcasecmp(const UChar *s1, const UChar *s2, uint32_t options);
  * @return A negative, zero, or positive integer indicating the comparison result.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strncasecmp(const UChar *s1, const UChar *s2, int32_t n, uint32_t options);
 
 /**
@@ -643,7 +643,7 @@ u_strncasecmp(const UChar *s1, const UChar *s2, int32_t n, uint32_t options);
  * @return A negative, zero, or positive integer indicating the comparison result.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_memcasecmp(const UChar *s1, const UChar *s2, int32_t length, uint32_t options);
 
 /**
@@ -654,7 +654,7 @@ u_memcasecmp(const UChar *s1, const UChar *s2, int32_t length, uint32_t options)
  * @return A pointer to <code>dst</code>.
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strcpy(UChar     *dst,
     const UChar     *src);
 
@@ -669,7 +669,7 @@ u_strcpy(UChar     *dst,
  * @return A pointer to <code>dst</code>.
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strncpy(UChar     *dst,
      const UChar     *src,
      int32_t     n);
@@ -686,7 +686,7 @@ u_strncpy(UChar     *dst,
  * @return A pointer to <code>dst</code>.
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2 u_uastrcpy(UChar *dst,
+U_CAPI UChar* U_EXPORT2 u_uastrcpy(UChar *dst,
                const char *src );
 
 /**
@@ -701,7 +701,7 @@ U_STABLE UChar* U_EXPORT2 u_uastrcpy(UChar *dst,
  * @return A pointer to <code>dst</code>.
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2 u_uastrncpy(UChar *dst,
+U_CAPI UChar* U_EXPORT2 u_uastrncpy(UChar *dst,
             const char *src,
             int32_t n);
 
@@ -715,7 +715,7 @@ U_STABLE UChar* U_EXPORT2 u_uastrncpy(UChar *dst,
  * @return A pointer to <code>dst</code>.
  * @stable ICU 2.0
  */
-U_STABLE char* U_EXPORT2 u_austrcpy(char *dst,
+U_CAPI char* U_EXPORT2 u_austrcpy(char *dst,
             const UChar *src );
 
 /**
@@ -730,7 +730,7 @@ U_STABLE char* U_EXPORT2 u_austrcpy(char *dst,
  * @return A pointer to <code>dst</code>.
  * @stable ICU 2.0
  */
-U_STABLE char* U_EXPORT2 u_austrncpy(char *dst,
+U_CAPI char* U_EXPORT2 u_austrncpy(char *dst,
             const UChar *src,
             int32_t n );
 
@@ -744,7 +744,7 @@ U_STABLE char* U_EXPORT2 u_austrncpy(char *dst,
  * @return A pointer to <code>dest</code>
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_memcpy(UChar *dest, const UChar *src, int32_t count);
 
 /**
@@ -755,7 +755,7 @@ u_memcpy(UChar *dest, const UChar *src, int32_t count);
  * @return A pointer to <code>dest</code>
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_memmove(UChar *dest, const UChar *src, int32_t count);
 
 /**
@@ -767,7 +767,7 @@ u_memmove(UChar *dest, const UChar *src, int32_t count);
  * @return A pointer to <code>dest</code>.
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_memset(UChar *dest, UChar c, int32_t count);
 
 /**
@@ -781,7 +781,7 @@ u_memset(UChar *dest, UChar c, int32_t count);
  *      When buf1 > buf2, a positive number is returned.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_memcmp(const UChar *buf1, const UChar *buf2, int32_t count);
 
 /**
@@ -797,7 +797,7 @@ u_memcmp(const UChar *buf1, const UChar *buf2, int32_t count);
  * in code point order
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_memcmpCodePointOrder(const UChar *s1, const UChar *s2, int32_t count);
 
 /**
@@ -817,7 +817,7 @@ u_memcmpCodePointOrder(const UChar *s1, const UChar *s2, int32_t count);
  * @see u_memchr32
  * @see u_strFindFirst
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_memchr(const UChar *s, UChar c, int32_t count);
 
 /**
@@ -837,7 +837,7 @@ u_memchr(const UChar *s, UChar c, int32_t count);
  * @see u_memchr
  * @see u_strFindFirst
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_memchr32(const UChar *s, UChar32 c, int32_t count);
 
 /**
@@ -857,7 +857,7 @@ u_memchr32(const UChar *s, UChar32 c, int32_t count);
  * @see u_memrchr32
  * @see u_strFindLast
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_memrchr(const UChar *s, UChar c, int32_t count);
 
 /**
@@ -877,7 +877,7 @@ u_memrchr(const UChar *s, UChar c, int32_t count);
  * @see u_memrchr
  * @see u_strFindLast
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_memrchr32(const UChar *s, UChar32 c, int32_t count);
 
 /**
@@ -903,13 +903,13 @@ u_memrchr32(const UChar *s, UChar32 c, int32_t count);
  *
  *     U_STRING_DECL(ustringVar1, "Quick-Fox 2", 11);
  *     U_STRING_DECL(ustringVar2, "jumps 5%", 8);
- *     static UBool didInit=FALSE;
+ *     static UBool didInit=false;
  *
  *     int32_t function() {
  *         if(!didInit) {
  *             U_STRING_INIT(ustringVar1, "Quick-Fox 2", 11);
  *             U_STRING_INIT(ustringVar2, "jumps 5%", 8);
- *             didInit=TRUE;
+ *             didInit=true;
  *         }
  *         return u_strcmp(ustringVar1, ustringVar2);
  *     }
@@ -992,7 +992,7 @@ u_memrchr32(const UChar *s, UChar32 c, int32_t count);
  * @see UnicodeString#unescapeAt()
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_unescape(const char *src,
            UChar *dest, int32_t destCapacity);
 
@@ -1040,7 +1040,7 @@ U_CDECL_END
  * @see UnicodeString#unescapeAt()
  * @stable ICU 2.0
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 u_unescapeAt(UNESCAPE_CHAR_AT charAt,
              int32_t *offset,
              int32_t length,
@@ -1066,7 +1066,7 @@ u_unescapeAt(UNESCAPE_CHAR_AT charAt,
  *         only some of the result was written to the destination buffer.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strToUpper(UChar *dest, int32_t destCapacity,
              const UChar *src, int32_t srcLength,
              const char *locale,
@@ -1092,7 +1092,7 @@ u_strToUpper(UChar *dest, int32_t destCapacity,
  *         only some of the result was written to the destination buffer.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strToLower(UChar *dest, int32_t destCapacity,
              const UChar *src, int32_t srcLength,
              const char *locale,
@@ -1138,7 +1138,7 @@ u_strToLower(UChar *dest, int32_t destCapacity,
  *         only some of the result was written to the destination buffer.
  * @stable ICU 2.1
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strToTitle(UChar *dest, int32_t destCapacity,
              const UChar *src, int32_t srcLength,
              UBreakIterator *titleIter,
@@ -1171,7 +1171,7 @@ u_strToTitle(UChar *dest, int32_t destCapacity,
  *         only some of the result was written to the destination buffer.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_strFoldCase(UChar *dest, int32_t destCapacity,
               const UChar *src, int32_t srcLength,
               uint32_t options,
@@ -1200,7 +1200,7 @@ u_strFoldCase(UChar *dest, int32_t destCapacity,
  * @return The pointer to destination buffer.
  * @stable ICU 2.0
  */
-U_STABLE wchar_t* U_EXPORT2
+U_CAPI wchar_t* U_EXPORT2
 u_strToWCS(wchar_t *dest,
            int32_t destCapacity,
            int32_t *pDestLength,
@@ -1229,7 +1229,7 @@ u_strToWCS(wchar_t *dest,
  * @return The pointer to destination buffer.
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strFromWCS(UChar   *dest,
              int32_t destCapacity,
              int32_t *pDestLength,
@@ -1260,7 +1260,7 @@ u_strFromWCS(UChar   *dest,
  * @see u_strToUTF8WithSub
  * @see u_strFromUTF8
  */
-U_STABLE char* U_EXPORT2
+U_CAPI char* U_EXPORT2
 u_strToUTF8(char *dest,
             int32_t destCapacity,
             int32_t *pDestLength,
@@ -1290,7 +1290,7 @@ u_strToUTF8(char *dest,
  * @see u_strFromUTF8WithSub
  * @see u_strFromUTF8Lenient
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strFromUTF8(UChar *dest,
               int32_t destCapacity,
               int32_t *pDestLength,
@@ -1333,7 +1333,7 @@ u_strFromUTF8(UChar *dest,
  * @see u_strFromUTF8WithSub
  * @stable ICU 3.6
  */
-U_STABLE char* U_EXPORT2
+U_CAPI char* U_EXPORT2
 u_strToUTF8WithSub(char *dest,
             int32_t destCapacity,
             int32_t *pDestLength,
@@ -1378,7 +1378,7 @@ u_strToUTF8WithSub(char *dest,
  * @see u_strToUTF8WithSub
  * @stable ICU 3.6
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strFromUTF8WithSub(UChar *dest,
               int32_t destCapacity,
               int32_t *pDestLength,
@@ -1438,7 +1438,7 @@ u_strFromUTF8WithSub(UChar *dest,
  * @see u_strToUTF8WithSub
  * @stable ICU 3.6
  */
-U_STABLE UChar * U_EXPORT2
+U_CAPI UChar * U_EXPORT2
 u_strFromUTF8Lenient(UChar *dest,
                      int32_t destCapacity,
                      int32_t *pDestLength,
@@ -1468,7 +1468,7 @@ u_strFromUTF8Lenient(UChar *dest,
  * @see u_strFromUTF32
  * @stable ICU 2.0
  */
-U_STABLE UChar32* U_EXPORT2
+U_CAPI UChar32* U_EXPORT2
 u_strToUTF32(UChar32 *dest,
              int32_t  destCapacity,
              int32_t  *pDestLength,
@@ -1498,7 +1498,7 @@ u_strToUTF32(UChar32 *dest,
  * @see u_strToUTF32
  * @stable ICU 2.0
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strFromUTF32(UChar   *dest,
                int32_t destCapacity,
                int32_t *pDestLength,
@@ -1541,7 +1541,7 @@ u_strFromUTF32(UChar   *dest,
  * @see u_strFromUTF32WithSub
  * @stable ICU 4.2
  */
-U_STABLE UChar32* U_EXPORT2
+U_CAPI UChar32* U_EXPORT2
 u_strToUTF32WithSub(UChar32 *dest,
              int32_t destCapacity,
              int32_t *pDestLength,
@@ -1585,7 +1585,7 @@ u_strToUTF32WithSub(UChar32 *dest,
  * @see u_strToUTF32WithSub
  * @stable ICU 4.2
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strFromUTF32WithSub(UChar *dest,
                int32_t destCapacity,
                int32_t *pDestLength,
@@ -1626,7 +1626,7 @@ u_strFromUTF32WithSub(UChar *dest,
  * @see u_strToUTF8WithSub
  * @see u_strFromJavaModifiedUTF8WithSub
  */
-U_STABLE char* U_EXPORT2
+U_CAPI char* U_EXPORT2
 u_strToJavaModifiedUTF8(
         char *dest,
         int32_t destCapacity,
@@ -1676,7 +1676,7 @@ u_strToJavaModifiedUTF8(
  * @see u_strToJavaModifiedUTF8
  * @stable ICU 4.4
  */
-U_STABLE UChar* U_EXPORT2
+U_CAPI UChar* U_EXPORT2
 u_strFromJavaModifiedUTF8WithSub(
         UChar *dest,
         int32_t destCapacity,
diff --git a/deps/icu-small/source/common/unicode/utext.h b/deps/icu-small/source/common/unicode/utext.h
index d36c1c035e70f1f993bb7cb5efe9c9a58189201a..084362be78fc9d77f62c73b7c0d57be8eb1d9a6c 100644
--- a/deps/icu-small/source/common/unicode/utext.h
+++ b/deps/icu-small/source/common/unicode/utext.h
@@ -180,7 +180,7 @@ typedef struct UText UText; /**< C typedef for struct UText. @stable ICU 3.6 */
   *
   * @stable ICU 3.4
   */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_close(UText *ut);
 
 /**
@@ -204,7 +204,7 @@ utext_close(UText *ut);
  *               will always be used and returned.
  * @stable ICU 3.4
  */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status);
 
 
@@ -222,7 +222,7 @@ utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status);
  *               will always be used and returned.
  * @stable ICU 3.4
  */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status);
 
 
@@ -239,7 +239,7 @@ utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status);
  *                 will always be used and returned.
  * @stable ICU 3.4
  */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_openUnicodeString(UText *ut, icu::UnicodeString *s, UErrorCode *status);
 
 
@@ -255,7 +255,7 @@ utext_openUnicodeString(UText *ut, icu::UnicodeString *s, UErrorCode *status);
  *               will always be used and returned.
  * @stable ICU 3.4
  */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_openConstUnicodeString(UText *ut, const icu::UnicodeString *s, UErrorCode *status);
 
 
@@ -271,7 +271,7 @@ utext_openConstUnicodeString(UText *ut, const icu::UnicodeString *s, UErrorCode
  * @see Replaceable
  * @stable ICU 3.4
  */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_openReplaceable(UText *ut, icu::Replaceable *rep, UErrorCode *status);
 
 /**
@@ -286,7 +286,7 @@ utext_openReplaceable(UText *ut, icu::Replaceable *rep, UErrorCode *status);
  * @see Replaceable
  * @stable ICU 3.4
  */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_openCharacterIterator(UText *ut, icu::CharacterIterator *ci, UErrorCode *status);
 
 #endif
@@ -323,7 +323,7 @@ utext_openCharacterIterator(UText *ut, icu::CharacterIterator *ci, UErrorCode *s
   *  shallow clones provide some protection against errors of this type by
   *  disabling text modification via the cloned UText.
   *
-  *  A shallow clone made with the readOnly parameter == FALSE will preserve the
+  *  A shallow clone made with the readOnly parameter == false will preserve the
   *  utext_isWritable() state of the source object.  Note, however, that
   *  write operations must be avoided while more than one UText exists that refer
   *  to the same underlying text.
@@ -339,8 +339,8 @@ utext_openCharacterIterator(UText *ut, icu::CharacterIterator *ci, UErrorCode *s
   *                If non-NULL, must refer to an already existing UText, which will then
   *                be reset to become the clone.
   *  @param src    The UText to be cloned.
-  *  @param deep   TRUE to request a deep clone, FALSE for a shallow clone.
-  *  @param readOnly TRUE to request that the cloned UText have read only access to the
+  *  @param deep   true to request a deep clone, false for a shallow clone.
+  *  @param readOnly true to request that the cloned UText have read only access to the
   *                underlying text.
 
   *  @param status Errors are returned here.  For deep clones, U_UNSUPPORTED_ERROR
@@ -349,7 +349,7 @@ utext_openCharacterIterator(UText *ut, icu::CharacterIterator *ci, UErrorCode *s
   *  @return       The newly created clone, or NULL if the clone operation failed.
   *  @stable ICU 3.4
   */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *status);
 
 
@@ -357,14 +357,14 @@ utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCod
   *  Compare two UText objects for equality.
   *  UTexts are equal if they are iterating over the same text, and
   *    have the same iteration position within the text.
-  *    If either or both of the parameters are NULL, the comparison is FALSE.
+  *    If either or both of the parameters are NULL, the comparison is false.
   *
   *  @param a   The first of the two UTexts to compare.
   *  @param b   The other UText to be compared.
-  *  @return    TRUE if the two UTexts are equal.
+  *  @return    true if the two UTexts are equal.
   *  @stable ICU 3.6
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 utext_equals(const UText *a, const UText *b);
 
 
@@ -385,11 +385,11 @@ utext_equals(const UText *a, const UText *b);
   *
   * @stable ICU 3.4
   */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 utext_nativeLength(UText *ut);
 
 /**
- *  Return TRUE if calculating the length of the text could be expensive.
+ *  Return true if calculating the length of the text could be expensive.
  *  Finding the length of NUL terminated strings is considered to be expensive.
  *
  *  Note that the value of this function may change
@@ -398,10 +398,10 @@ utext_nativeLength(UText *ut);
  *  be expensive to report it.
  *
  * @param ut the text to be accessed.
- * @return TRUE if determining the length of the text could be time consuming.
+ * @return true if determining the length of the text could be time consuming.
  * @stable ICU 3.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 utext_isLengthExpensive(const UText *ut);
 
 /**
@@ -429,7 +429,7 @@ utext_isLengthExpensive(const UText *ut);
  * @return the code point at the specified index.
  * @stable ICU 3.4
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 utext_char32At(UText *ut, int64_t nativeIndex);
 
 
@@ -443,7 +443,7 @@ utext_char32At(UText *ut, int64_t nativeIndex);
  * @return the Unicode code point at the current iterator position.
  * @stable ICU 3.4
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 utext_current32(UText *ut);
 
 
@@ -465,7 +465,7 @@ utext_current32(UText *ut);
  * @see UTEXT_NEXT32
  * @stable ICU 3.4
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 utext_next32(UText *ut);
 
 
@@ -486,7 +486,7 @@ utext_next32(UText *ut);
  *  @see UTEXT_PREVIOUS32
  *  @stable ICU 3.4
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 utext_previous32(UText *ut);
 
 
@@ -508,7 +508,7 @@ utext_previous32(UText *ut);
   *         or U_SENTINEL (-1) if it is out of bounds.
   * @stable ICU 3.4
   */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 utext_next32From(UText *ut, int64_t nativeIndex);
 
 
@@ -528,7 +528,7 @@ utext_next32From(UText *ut, int64_t nativeIndex);
   *
   * @stable ICU 3.4
   */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 utext_previous32From(UText *ut, int64_t nativeIndex);
 
 /**
@@ -543,7 +543,7 @@ utext_previous32From(UText *ut, int64_t nativeIndex);
   * @return the current index position, in the native units of the text provider.
   * @stable ICU 3.4
   */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 utext_getNativeIndex(const UText *ut);
 
 /**
@@ -569,7 +569,7 @@ utext_getNativeIndex(const UText *ut);
  * @param nativeIndex the native unit index of the new iteration position.
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utext_setNativeIndex(UText *ut, int64_t nativeIndex);
 
 /**
@@ -584,11 +584,11 @@ utext_setNativeIndex(UText *ut, int64_t nativeIndex);
  *
  * @param ut the text to be accessed.
  * @param delta the signed number of code points to move the iteration position.
- * @return TRUE if the position could be moved the requested number of positions while
+ * @return true if the position could be moved the requested number of positions while
  *              staying within the range [0 - text length].
  * @stable ICU 3.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 utext_moveIndex32(UText *ut, int32_t delta);
 
 /**
@@ -613,7 +613,7 @@ utext_moveIndex32(UText *ut, int32_t delta);
  *         or zero if the current position is at the start of the text.
  * @stable ICU 3.6
  */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 utext_getPreviousNativeIndex(UText *ut);
 
 
@@ -651,7 +651,7 @@ utext_getPreviousNativeIndex(UText *ut);
  *
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utext_extract(UText *ut,
              int64_t nativeStart, int64_t nativeLimit,
              UChar *dest, int32_t destCapacity,
@@ -768,16 +768,16 @@ utext_extract(UText *ut,
 
 
 /**
- *  Return TRUE if the text can be written (modified) with utext_replace() or
+ *  Return true if the text can be written (modified) with utext_replace() or
  *  utext_copy().  For the text to be writable, the text provider must
  *  be of a type that supports writing and the UText must not be frozen.
  *
- *  Attempting to modify text when utext_isWriteable() is FALSE will fail -
+ *  Attempting to modify text when utext_isWriteable() is false will fail -
  *  the text will not be modified, and an error will be returned from the function
  *  that attempted the modification.
  *
  * @param  ut   the UText to be tested.
- * @return TRUE if the text is modifiable.
+ * @return true if the text is modifiable.
  *
  * @see    utext_freeze()
  * @see    utext_replace()
@@ -785,7 +785,7 @@ utext_extract(UText *ut,
  * @stable ICU 3.4
  *
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 utext_isWritable(const UText *ut);
 
 
@@ -794,10 +794,10 @@ utext_isWritable(const UText *ut);
   * @see Replaceable::hasMetaData()
   *
   * @param ut The UText to be tested
-  * @return TRUE if the underlying text includes meta data.
+  * @return true if the underlying text includes meta data.
   * @stable ICU 3.4
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 utext_hasMetaData(const UText *ut);
 
 
@@ -808,7 +808,7 @@ utext_hasMetaData(const UText *ut);
  *  newly inserted replacement text.
  *
  * This function is only available on UText types that support writing,
- * that is, ones where utext_isWritable() returns TRUE.
+ * that is, ones where utext_isWritable() returns true.
  *
  * When using this function, there should be only a single UText opened onto the
  * underlying native text string.  Behavior after a replace operation
@@ -828,7 +828,7 @@ utext_hasMetaData(const UText *ut);
  *
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utext_replace(UText *ut,
              int64_t nativeStart, int64_t nativeLimit,
              const UChar *replacementText, int32_t replacementLength,
@@ -850,7 +850,7 @@ utext_replace(UText *ut,
  * at the destination position.
  *
  * This function is only available on UText types that support writing,
- * that is, ones where utext_isWritable() returns TRUE.
+ * that is, ones where utext_isWritable() returns true.
  *
  * When using this function, there should be only a single UText opened onto the
  * underlying native text string.  Behavior after a copy operation
@@ -863,12 +863,12 @@ utext_replace(UText *ut,
  *                     to be copied.
  * @param destIndex    The native destination index to which the source substring is
  *                     copied or moved.
- * @param move         If TRUE, then the substring is moved, not copied/duplicated.
+ * @param move         If true, then the substring is moved, not copied/duplicated.
  * @param status       receives any error status.  Possible errors include U_NO_WRITE_PERMISSION
  *
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utext_copy(UText *ut,
           int64_t nativeStart, int64_t nativeLimit,
           int64_t destIndex,
@@ -897,7 +897,7 @@ utext_copy(UText *ut,
   *  @see   utext_isWritable()
   *  @stable ICU 3.6
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utext_freeze(UText *ut);
 
 
@@ -972,7 +972,7 @@ enum {
   *  @param dest   A UText struct to be filled in with the result of the clone operation,
   *                or NULL if the clone function should heap-allocate a new UText struct.
   *  @param src    The UText to be cloned.
-  *  @param deep   TRUE to request a deep clone, FALSE for a shallow clone.
+  *  @param deep   true to request a deep clone, false for a shallow clone.
   *  @param status Errors are returned here.  For deep clones, U_UNSUPPORTED_ERROR
   *                should be returned if the text provider is unable to clone the
   *                original text.
@@ -1008,9 +1008,9 @@ UTextNativeLength(UText *ut);
  *
  * @param ut          the UText being accessed.
  * @param nativeIndex Requested index of the text to be accessed.
- * @param forward     If TRUE, then the returned chunk must contain text
+ * @param forward     If true, then the returned chunk must contain text
  *                    starting from the index, so that start<=index<limit.
- *                    If FALSE, then the returned chunk must contain text
+ *                    If false, then the returned chunk must contain text
  *                    before the index, so that start<index<=limit.
  * @return            True if the requested index could be accessed.  The chunk
  *                    will contain the requested text.
@@ -1114,7 +1114,7 @@ UTextReplace(UText *ut,
  * @param nativeStart  The index of the start of the region to be copied or moved
  * @param nativeLimit  The index of the character following the region to be replaced.
  * @param nativeDest   The destination index to which the source substring is copied or moved.
- * @param move         If TRUE, then the substring is moved, not copied/duplicated.
+ * @param move         If true, then the substring is moved, not copied/duplicated.
  * @param status       receives any error status.  Possible errors include U_NO_WRITE_PERMISSION
  *
  * @stable ICU 3.4
@@ -1535,7 +1535,7 @@ struct UText {
  * @return pointer to the UText, allocated if necessary, with extra space set up if requested.
  * @stable ICU 3.4
  */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 utext_setup(UText *ut, int32_t extraSpace, UErrorCode *status);
 
 // do not use #ifndef U_HIDE_INTERNAL_API around the following!
diff --git a/deps/icu-small/source/common/unicode/utf.h b/deps/icu-small/source/common/unicode/utf.h
index aa5698069154cc7c14d0bc6319467da2c6c0bc2d..d23345ed0bf1c05e773aaa6ab4c18372a4f01adc 100644
--- a/deps/icu-small/source/common/unicode/utf.h
+++ b/deps/icu-small/source/common/unicode/utf.h
@@ -103,7 +103,7 @@
  * code point values (0..U+10ffff). They are indicated with negative values instead.
  *
  * For more information see the ICU User Guide Strings chapter
- * (http://userguide.icu-project.org/strings).
+ * (https://unicode-org.github.io/icu/userguide/strings).
  *
  * <em>Usage:</em>
  * ICU coding guidelines for if() statements should be followed when using these macros.
@@ -124,7 +124,7 @@
 /**
  * Is this code point a Unicode noncharacter?
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U_IS_UNICODE_NONCHAR(c) \
@@ -145,7 +145,7 @@
  * and that boundary is tested first for performance.
  *
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U_IS_UNICODE_CHAR(c) \
@@ -155,7 +155,7 @@
 /**
  * Is this code point a BMP code point (U+0000..U+ffff)?
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.8
  */
 #define U_IS_BMP(c) ((uint32_t)(c)<=0xffff)
@@ -163,7 +163,7 @@
 /**
  * Is this code point a supplementary code point (U+10000..U+10ffff)?
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.8
  */
 #define U_IS_SUPPLEMENTARY(c) ((uint32_t)((c)-0x10000)<=0xfffff)
@@ -171,7 +171,7 @@
 /**
  * Is this code point a lead surrogate (U+d800..U+dbff)?
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800)
@@ -179,7 +179,7 @@
 /**
  * Is this code point a trail surrogate (U+dc00..U+dfff)?
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00)
@@ -187,7 +187,7 @@
 /**
  * Is this code point a surrogate (U+d800..U+dfff)?
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800)
@@ -196,7 +196,7 @@
  * Assuming c is a surrogate code point (U_IS_SURROGATE(c)),
  * is it a lead surrogate?
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
@@ -205,7 +205,7 @@
  * Assuming c is a surrogate code point (U_IS_SURROGATE(c)),
  * is it a trail surrogate?
  * @param c 32-bit code point
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 4.2
  */
 #define U_IS_SURROGATE_TRAIL(c) (((c)&0x400)!=0)
diff --git a/deps/icu-small/source/common/unicode/utf16.h b/deps/icu-small/source/common/unicode/utf16.h
index 3315214ae69d86a3fcc1bbfc32d1863923d3dbaa..9d68902d2de0f3100d05e24abe9943a19bac14ab 100644
--- a/deps/icu-small/source/common/unicode/utf16.h
+++ b/deps/icu-small/source/common/unicode/utf16.h
@@ -23,7 +23,7 @@
  * This file defines macros to deal with 16-bit Unicode (UTF-16) code units and strings.
  *
  * For more information see utf.h and the ICU User Guide Strings chapter
- * (http://userguide.icu-project.org/strings).
+ * (https://unicode-org.github.io/icu/userguide/strings).
  *
  * <em>Usage:</em>
  * ICU coding guidelines for if() statements should be followed when using these macros.
@@ -34,6 +34,7 @@
 #ifndef __UTF16_H__
 #define __UTF16_H__
 
+#include <stdbool.h>
 #include "unicode/umachine.h"
 #ifndef __UTF_H__
 #   include "unicode/utf.h"
@@ -44,7 +45,7 @@
 /**
  * Does this code unit alone encode a code point (BMP, not a surrogate)?
  * @param c 16-bit code unit
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U16_IS_SINGLE(c) !U_IS_SURROGATE(c)
@@ -52,7 +53,7 @@
 /**
  * Is this code unit a lead surrogate (U+d800..U+dbff)?
  * @param c 16-bit code unit
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800)
@@ -60,7 +61,7 @@
 /**
  * Is this code unit a trail surrogate (U+dc00..U+dfff)?
  * @param c 16-bit code unit
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00)
@@ -68,7 +69,7 @@
 /**
  * Is this code unit a surrogate (U+d800..U+dfff)?
  * @param c 16-bit code unit
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U16_IS_SURROGATE(c) U_IS_SURROGATE(c)
@@ -77,7 +78,7 @@
  * Assuming c is a surrogate code point (U16_IS_SURROGATE(c)),
  * is it a lead surrogate?
  * @param c 16-bit code unit
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
@@ -86,7 +87,7 @@
  * Assuming c is a surrogate code point (U16_IS_SURROGATE(c)),
  * is it a trail surrogate?
  * @param c 16-bit code unit
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 4.2
  */
 #define U16_IS_SURROGATE_TRAIL(c) (((c)&0x400)!=0)
@@ -379,13 +380,13 @@
  * "Safe" macro, checks for a valid code point.
  * If a surrogate pair is written, checks for sufficient space in the string.
  * If the code point is not valid or a trail surrogate does not fit,
- * then isError is set to TRUE.
+ * then isError is set to true.
  *
  * @param s const UChar * string buffer
  * @param i string offset, must be i<capacity
  * @param capacity size of the string buffer
  * @param c code point to append
- * @param isError output UBool set to TRUE if an error occurs, otherwise not modified
+ * @param isError output UBool set to true if an error occurs, otherwise not modified
  * @see U16_APPEND_UNSAFE
  * @stable ICU 2.4
  */
@@ -396,7 +397,7 @@
         (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \
         (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \
     } else /* c>0x10ffff or not enough space */ { \
-        (isError)=TRUE; \
+        (isError)=true; \
     } \
 } UPRV_BLOCK_MACRO_END
 
diff --git a/deps/icu-small/source/common/unicode/utf8.h b/deps/icu-small/source/common/unicode/utf8.h
index bb001303747efec58edf0e60c18561e225467a05..58bda2cbe512901f61c34cadd6aa62a2f4081568 100644
--- a/deps/icu-small/source/common/unicode/utf8.h
+++ b/deps/icu-small/source/common/unicode/utf8.h
@@ -23,7 +23,7 @@
  * This file defines macros to deal with 8-bit Unicode (UTF-8) code units (bytes) and strings.
  *
  * For more information see utf.h and the ICU User Guide Strings chapter
- * (http://userguide.icu-project.org/strings).
+ * (https://unicode-org.github.io/icu/userguide/strings).
  *
  * <em>Usage:</em>
  * ICU coding guidelines for if() statements should be followed when using these macros.
@@ -34,6 +34,7 @@
 #ifndef __UTF8_H__
 #define __UTF8_H__
 
+#include <stdbool.h>
 #include "unicode/umachine.h"
 #ifndef __UTF_H__
 #   include "unicode/utf.h"
@@ -117,48 +118,48 @@
  * Function for handling "next code point" with error-checking.
  *
  * This is internal since it is not meant to be called directly by external clients;
- * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this
+ * however it is called by public macros in this
  * file and thus must remain stable, and should not be hidden when other internal
  * functions are hidden (otherwise public macros would fail to compile).
  * @internal
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, UChar32 c, UBool strict);
 
 /**
  * Function for handling "append code point" with error-checking.
  *
  * This is internal since it is not meant to be called directly by external clients;
- * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this
+ * however it is called by public macros in this
  * file and thus must remain stable, and should not be hidden when other internal
  * functions are hidden (otherwise public macros would fail to compile).
  * @internal
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utf8_appendCharSafeBody(uint8_t *s, int32_t i, int32_t length, UChar32 c, UBool *pIsError);
 
 /**
  * Function for handling "previous code point" with error-checking.
  *
  * This is internal since it is not meant to be called directly by external clients;
- * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this
+ * however it is called by public macros in this
  * file and thus must remain stable, and should not be hidden when other internal
  * functions are hidden (otherwise public macros would fail to compile).
  * @internal
  */
-U_STABLE UChar32 U_EXPORT2
+U_CAPI UChar32 U_EXPORT2
 utf8_prevCharSafeBody(const uint8_t *s, int32_t start, int32_t *pi, UChar32 c, UBool strict);
 
 /**
  * Function for handling "skip backward one code point" with error-checking.
  *
  * This is internal since it is not meant to be called directly by external clients;
- * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this
+ * however it is called by public macros in this
  * file and thus must remain stable, and should not be hidden when other internal
  * functions are hidden (otherwise public macros would fail to compile).
  * @internal
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utf8_back1SafeBody(const uint8_t *s, int32_t start, int32_t i);
 
 /* single-code point definitions -------------------------------------------- */
@@ -166,7 +167,7 @@ utf8_back1SafeBody(const uint8_t *s, int32_t start, int32_t i);
 /**
  * Does this code unit (byte) encode a code point by itself (US-ASCII 0..0x7f)?
  * @param c 8-bit code unit (byte)
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U8_IS_SINGLE(c) (((c)&0x80)==0)
@@ -174,7 +175,7 @@ utf8_back1SafeBody(const uint8_t *s, int32_t start, int32_t i);
 /**
  * Is this code unit (byte) a UTF-8 lead byte? (0xC2..0xF4)
  * @param c 8-bit code unit (byte)
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U8_IS_LEAD(c) ((uint8_t)((c)-0xc2)<=0x32)
@@ -183,7 +184,7 @@ utf8_back1SafeBody(const uint8_t *s, int32_t start, int32_t i);
 /**
  * Is this code unit (byte) a UTF-8 trail byte? (0x80..0xBF)
  * @param c 8-bit code unit (byte)
- * @return TRUE or FALSE
+ * @return true or false
  * @stable ICU 2.4
  */
 #define U8_IS_TRAIL(c) ((int8_t)(c)<-0x40)
@@ -445,13 +446,13 @@ utf8_back1SafeBody(const uint8_t *s, int32_t start, int32_t i);
  * "Safe" macro, checks for a valid code point.
  * If a non-ASCII code point is written, checks for sufficient space in the string.
  * If the code point is not valid or trail bytes do not fit,
- * then isError is set to TRUE.
+ * then isError is set to true.
  *
  * @param s const uint8_t * string buffer
  * @param i int32_t string offset, must be i<capacity
  * @param capacity int32_t size of the string buffer
  * @param c UChar32 code point to append
- * @param isError output UBool set to TRUE if an error occurs, otherwise not modified
+ * @param isError output UBool set to true if an error occurs, otherwise not modified
  * @see U8_APPEND_UNSAFE
  * @stable ICU 2.4
  */
@@ -472,7 +473,7 @@ utf8_back1SafeBody(const uint8_t *s, int32_t start, int32_t i);
         (s)[(i)++]=(uint8_t)(((__uc>>6)&0x3f)|0x80); \
         (s)[(i)++]=(uint8_t)((__uc&0x3f)|0x80); \
     } else { \
-        (isError)=TRUE; \
+        (isError)=true; \
     } \
 } UPRV_BLOCK_MACRO_END
 
diff --git a/deps/icu-small/source/common/unicode/utf_old.h b/deps/icu-small/source/common/unicode/utf_old.h
index b2428e6b31e28273c68180465dd545e0bb914d17..160f5ad0a9f24858f392feefe6770608a013211f 100644
--- a/deps/icu-small/source/common/unicode/utf_old.h
+++ b/deps/icu-small/source/common/unicode/utf_old.h
@@ -109,7 +109,7 @@
  * Where such a distinction is useful, there are two versions of the macros, "unsafe" and "safe"
  * ones with ..._UNSAFE and ..._SAFE suffixes. The unsafe macros are fast but may cause
  * program failures if the strings are not well-formed. The safe macros have an additional, boolean
- * parameter "strict". If strict is FALSE, then only illegal sequences are detected.
+ * parameter "strict". If strict is false, then only illegal sequences are detected.
  * Otherwise, irregular sequences and non-characters are detected as well (like single surrogates).
  * Safe macros return special error code points for illegal/irregular sequences:
  * Typically, U+ffff, or values that would result in a code unit sequence of the same length
@@ -181,7 +181,7 @@ typedef int32_t UTextOffset;
 
 /**
  * The default choice for general Unicode string macros is to use the ..._SAFE macro implementations
- * with strict=FALSE.
+ * with strict=false.
  *
  * @deprecated ICU 2.4. Obsolete, see utf_old.h.
  */
diff --git a/deps/icu-small/source/common/unicode/utrace.h b/deps/icu-small/source/common/unicode/utrace.h
index c7d51ff44f5bf74cb98dbebcf9965b64625e3805..3ed01911058966dc13a7f1d6f70ec2dce2a647e1 100644
--- a/deps/icu-small/source/common/unicode/utrace.h
+++ b/deps/icu-small/source/common/unicode/utrace.h
@@ -112,11 +112,9 @@ typedef enum UTraceFunctionNumber {
     UTRACE_COLLATION_LIMIT,
 #endif  // U_HIDE_DEPRECATED_API
 
-#ifndef U_HIDE_DRAFT_API
-
     /**
      * The lowest resource/data location.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     UTRACE_UDATA_START=0x3000,
 
@@ -133,7 +131,7 @@ typedef enum UTraceFunctionNumber {
      * - "get" (a path was loaded, but the value was not accessed)
      * - "getalias" (a path was loaded, and an alias was resolved)
      *
-     * @draft ICU 65
+     * @stable ICU 65
      */
     UTRACE_UDATA_RESOURCE=UTRACE_UDATA_START,
 
@@ -141,7 +139,7 @@ typedef enum UTraceFunctionNumber {
      * Indicates that a resource bundle was opened.
      *
      * Provides one C-style string to UTraceData: file name.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     UTRACE_UDATA_BUNDLE,
 
@@ -150,7 +148,7 @@ typedef enum UTraceFunctionNumber {
      *
      * Provides one C-style string to UTraceData: file name.
      *
-     * @draft ICU 65
+     * @stable ICU 65
      */
     UTRACE_UDATA_DATA_FILE,
 
@@ -163,12 +161,10 @@ typedef enum UTraceFunctionNumber {
      *
      * Provides one C-style string to UTraceData: file name.
      *
-     * @draft ICU 65
+     * @stable ICU 65
      */
     UTRACE_UDATA_RES_FILE,
 
-#endif  // U_HIDE_DRAFT_API
-
 #ifndef U_HIDE_INTERNAL_API
     /**
      * One more than the highest normal resource/data trace location.
@@ -177,24 +173,23 @@ typedef enum UTraceFunctionNumber {
     UTRACE_RES_DATA_LIMIT,
 #endif  // U_HIDE_INTERNAL_API
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * The lowest break iterator location.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UTRACE_UBRK_START=0x4000,
 
     /**
      * Indicates that a character instance of break iterator was created.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UTRACE_UBRK_CREATE_CHARACTER = UTRACE_UBRK_START,
 
     /**
      * Indicates that a word instance of break iterator was created.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UTRACE_UBRK_CREATE_WORD,
 
@@ -204,21 +199,21 @@ typedef enum UTraceFunctionNumber {
      * Provides one C-style string to UTraceData: the lb value ("",
      * "loose", "strict", or "normal").
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UTRACE_UBRK_CREATE_LINE,
 
     /**
      * Indicates that a sentence instance of break iterator was created.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UTRACE_UBRK_CREATE_SENTENCE,
 
     /**
      * Indicates that a title instance of break iterator was created.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UTRACE_UBRK_CREATE_TITLE,
 
@@ -228,12 +223,10 @@ typedef enum UTraceFunctionNumber {
      * Provides one C-style string to UTraceData: the script code of what
      * the break engine cover ("Hani", "Khmr", "Laoo", "Mymr", or "Thai").
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UTRACE_UBRK_CREATE_BREAK_ENGINE,
 
-#endif  // U_HIDE_DRAFT_API
-
 #ifndef U_HIDE_INTERNAL_API
     /**
      * One more than the highest normal break iterator trace location.
@@ -249,7 +242,7 @@ typedef enum UTraceFunctionNumber {
  * @param traceLevel A UTraceLevel value.
  * @stable ICU 2.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrace_setLevel(int32_t traceLevel);
 
 /**
@@ -257,7 +250,7 @@ utrace_setLevel(int32_t traceLevel);
  * @return The UTraceLevel value being used by ICU.
  * @stable ICU 2.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utrace_getLevel(void);
 
 /* Trace function pointers types  ----------------------------- */
@@ -331,7 +324,7 @@ UTraceData(const void *context, int32_t fnNumber, int32_t level,
   *
   *  @stable ICU 2.8
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrace_setFunctions(const void *context,
                     UTraceEntry *e, UTraceExit *x, UTraceData *d);
 
@@ -345,7 +338,7 @@ utrace_setFunctions(const void *context,
   * @param d        The currently installed UTraceData function.
   * @stable ICU 2.8
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrace_getFunctions(const void **context,
                     UTraceEntry **e, UTraceExit **x, UTraceData **d);
 
@@ -467,7 +460,7 @@ utrace_getFunctions(const void **context,
   *                 If buffer capacity is insufficient, the required capacity is returned.
   *  @stable ICU 2.8
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utrace_vformat(char *outBuf, int32_t capacity,
               int32_t indent, const char *fmt,  va_list args);
 
@@ -488,7 +481,7 @@ utrace_vformat(char *outBuf, int32_t capacity,
   *                 If buffer capacity is insufficient, the required capacity is returned.
   *  @stable ICU 2.8
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utrace_format(char *outBuf, int32_t capacity,
               int32_t indent, const char *fmt,  ...);
 
@@ -505,7 +498,7 @@ utrace_format(char *outBuf, int32_t capacity,
  * @see UTraceFunctionNumber
  * @stable ICU 2.8
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 utrace_functionName(int32_t fnNumber);
 
 U_CDECL_END
diff --git a/deps/icu-small/source/common/unicode/utypes.h b/deps/icu-small/source/common/unicode/utypes.h
index c98de9e6fc3dad07df4da24969c07c0dc9fd8db4..6c57218db8d477f407af381c852e94343ed7dc86 100644
--- a/deps/icu-small/source/common/unicode/utypes.h
+++ b/deps/icu-small/source/common/unicode/utypes.h
@@ -479,13 +479,23 @@ typedef enum UErrorCode {
     U_COLLATOR_VERSION_MISMATCH = 28,   /**< Collator version is not compatible with the base version */
     U_USELESS_COLLATOR_ERROR  = 29,     /**< Collator is options only and no base is specified */
     U_NO_WRITE_PERMISSION     = 30,     /**< Attempt to modify read-only or constant data. */
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * The input is impractically long for an operation.
+     * It is rejected because it may lead to problems such as excessive
+     * processing time, stack depth, or heap memory requirements.
+     *
+     * @draft ICU 68
+     */
+    U_INPUT_TOO_LONG_ERROR = 31,
+#endif  // U_HIDE_DRAFT_API
 
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * One more than the highest standard error code.
      * @deprecated ICU 58 The numeric value may change over time, see ICU ticket #12420.
      */
-    U_STANDARD_ERROR_LIMIT,
+    U_STANDARD_ERROR_LIMIT = 32,
 #endif  // U_HIDE_DEPRECATED_API
 
     /*
@@ -715,7 +725,7 @@ typedef enum UErrorCode {
  * in the UErrorCode enum above.
  * @stable ICU 2.0
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 u_errorName(UErrorCode code);
 
 
diff --git a/deps/icu-small/source/common/unicode/uvernum.h b/deps/icu-small/source/common/unicode/uvernum.h
index c66776d10b58263e751386a96e756902e2721c93..b09d4943c1cc98f2b7dafdf0e1952a6e2cc37bd5 100644
--- a/deps/icu-small/source/common/unicode/uvernum.h
+++ b/deps/icu-small/source/common/unicode/uvernum.h
@@ -60,7 +60,7 @@
  *  This value will change in the subsequent releases of ICU
  *  @stable ICU 2.4
  */
-#define U_ICU_VERSION_MAJOR_NUM 67
+#define U_ICU_VERSION_MAJOR_NUM 69
 
 /** The current ICU minor version as an integer.
  *  This value will change in the subsequent releases of ICU
@@ -86,7 +86,7 @@
  *  This value will change in the subsequent releases of ICU
  *  @stable ICU 2.6
  */
-#define U_ICU_VERSION_SUFFIX _67
+#define U_ICU_VERSION_SUFFIX _69
 
 /**
  * \def U_DEF2_ICU_ENTRY_POINT_RENAME
@@ -139,7 +139,7 @@
  *  This value will change in the subsequent releases of ICU
  *  @stable ICU 2.4
  */
-#define U_ICU_VERSION "67.1"
+#define U_ICU_VERSION "69.1"
 
 /**
  * The current ICU library major version number as a string, for library name suffixes.
@@ -148,17 +148,17 @@
  * Until ICU 4.8, this was the combination of the single-digit major and minor ICU version numbers
  * into one string without dots ("48").
  * Since ICU 49, it is the double-digit major ICU version number.
- * See http://userguide.icu-project.org/design#TOC-Version-Numbers-in-ICU
+ * See https://unicode-org.github.io/icu/userguide/design#version-numbers-in-icu
  *
  * @stable ICU 2.6
  */
-#define U_ICU_VERSION_SHORT "67"
+#define U_ICU_VERSION_SHORT "69"
 
 #ifndef U_HIDE_INTERNAL_API
 /** Data version in ICU4C.
  * @internal ICU 4.4 Internal Use Only
  **/
-#define U_ICU_DATA_VERSION "67.1"
+#define U_ICU_DATA_VERSION "69.1"
 #endif  /* U_HIDE_INTERNAL_API */
 
 /*===========================================================================
diff --git a/deps/icu-small/source/common/unicode/uversion.h b/deps/icu-small/source/common/unicode/uversion.h
index c8c7a374c820b2353e5ee8d684499c6247baf456..dde3059261047c2ce1c9950b9d9c035c3fc76668 100644
--- a/deps/icu-small/source/common/unicode/uversion.h
+++ b/deps/icu-small/source/common/unicode/uversion.h
@@ -141,7 +141,7 @@ typedef uint8_t UVersionInfo[U_MAX_VERSION_LENGTH];
  *                      values of up to 255 each.
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_versionFromString(UVersionInfo versionArray, const char *versionString);
 
 /**
@@ -155,7 +155,7 @@ u_versionFromString(UVersionInfo versionArray, const char *versionString);
  *                      fields with values of up to 255 each.
  * @stable ICU 4.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_versionFromUString(UVersionInfo versionArray, const UChar *versionString);
 
 
@@ -171,7 +171,7 @@ u_versionFromUString(UVersionInfo versionArray, const UChar *versionString);
  *                      The buffer size must be at least U_MAX_VERSION_STRING_LENGTH.
  * @stable ICU 2.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_versionToString(const UVersionInfo versionArray, char *versionString);
 
 /**
@@ -182,6 +182,6 @@ u_versionToString(const UVersionInfo versionArray, char *versionString);
  * @param versionArray the version # information, the result will be filled in
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_getVersion(UVersionInfo versionArray);
 #endif
diff --git a/deps/icu-small/source/common/unifiedcache.cpp b/deps/icu-small/source/common/unifiedcache.cpp
index f2dd916559588cc83e42ecf359726a355a3bc696..493ab79f6d9067e2e90e2dbf20dc41a6d24fae18 100644
--- a/deps/icu-small/source/common/unifiedcache.cpp
+++ b/deps/icu-small/source/common/unifiedcache.cpp
@@ -311,7 +311,7 @@ void UnifiedCache::_putNew(
     }
     keyToAdopt->fCreationStatus = creationStatus;
     if (value->softRefCount == 0) {
-        _registerMaster(keyToAdopt, value);
+        _registerPrimary(keyToAdopt, value);
     }
     void *oldValue = uhash_put(fHashtable, keyToAdopt, (void *) value, &status);
     U_ASSERT(oldValue == nullptr);
@@ -338,7 +338,7 @@ void UnifiedCache::_putIfAbsentAndGet(
     } else {
         _put(element, value, status);
     }
-    // Run an eviction slice. This will run even if we added a master entry
+    // Run an eviction slice. This will run even if we added a primary entry
     // which doesn't increase the unused count, but that is still o.k
     _runEvictionSlice();
 }
@@ -403,9 +403,9 @@ void UnifiedCache::_get(
     }
 }
 
-void UnifiedCache::_registerMaster(
+void UnifiedCache::_registerPrimary(
             const CacheKeyBase *theKey, const SharedObject *value) const {
-    theKey->fIsMaster = true;
+    theKey->fIsPrimary = true;
     value->cachePtr = this;
     ++fNumValuesTotal;
     ++fNumValuesInUse;
@@ -420,7 +420,7 @@ void UnifiedCache::_put(
     const SharedObject *oldValue = (const SharedObject *) element->value.pointer;
     theKey->fCreationStatus = status;
     if (value->softRefCount == 0) {
-        _registerMaster(theKey, value);
+        _registerPrimary(theKey, value);
     }
     value->softRefCount++;
     UHashElement *ptr = const_cast<UHashElement *>(element);
@@ -474,9 +474,9 @@ UBool UnifiedCache::_isEvictable(const UHashElement *element) const
         return FALSE;
     }
 
-    // We can evict entries that are either not a master or have just
+    // We can evict entries that are either not a primary or have just
     // one reference (The one reference being from the cache itself).
-    return (!theKey->fIsMaster || (theValue->softRefCount == 1 && theValue->noHardReferences()));
+    return (!theKey->fIsPrimary || (theValue->softRefCount == 1 && theValue->noHardReferences()));
 }
 
 void UnifiedCache::removeSoftRef(const SharedObject *value) const {
diff --git a/deps/icu-small/source/common/unifiedcache.h b/deps/icu-small/source/common/unifiedcache.h
index 5c0bd76f4a2b94b1af28f669d103569d969c951c..865f4545105cb66ac8b2959a95083e1e871d5058 100644
--- a/deps/icu-small/source/common/unifiedcache.h
+++ b/deps/icu-small/source/common/unifiedcache.h
@@ -34,13 +34,13 @@ class UnifiedCache;
  */
 class U_COMMON_API CacheKeyBase : public UObject {
  public:
-   CacheKeyBase() : fCreationStatus(U_ZERO_ERROR), fIsMaster(FALSE) {}
+   CacheKeyBase() : fCreationStatus(U_ZERO_ERROR), fIsPrimary(false) {}
 
    /**
     * Copy constructor. Needed to support cloning.
     */
    CacheKeyBase(const CacheKeyBase &other)
-           : UObject(other), fCreationStatus(other.fCreationStatus), fIsMaster(FALSE) { }
+           : UObject(other), fCreationStatus(other.fCreationStatus), fIsPrimary(false) { }
    virtual ~CacheKeyBase();
 
    /**
@@ -88,7 +88,7 @@ class U_COMMON_API CacheKeyBase : public UObject {
    }
  private:
    mutable UErrorCode fCreationStatus;
-   mutable UBool fIsMaster;
+   mutable UBool fIsPrimary;
    friend class UnifiedCache;
 };
 
@@ -147,10 +147,10 @@ class LocaleCacheKey : public CacheKey<T> {
    virtual UBool operator == (const CacheKeyBase &other) const {
        // reflexive
        if (this == &other) {
-           return TRUE;
+           return true;
        }
        if (!CacheKey<T>::operator == (other)) {
-           return FALSE;
+           return false;
        }
        // We know this and other are of same class because operator== on
        // CacheKey returned true.
@@ -359,7 +359,7 @@ class U_COMMON_API UnifiedCache : public UnifiedCacheBase {
 
    /**
     * Flushes the contents of the cache. If cache values hold references to other
-    * cache values then _flush should be called in a loop until it returns FALSE.
+    * cache values then _flush should be called in a loop until it returns false.
     *
     * On entry, gCacheMutex must be held.
     * On exit, those values with are evictable are flushed.
@@ -370,7 +370,7 @@ class U_COMMON_API UnifiedCache : public UnifiedCacheBase {
     *                     hard (external) references are not deleted, but are detached from
     *                     the cache, so that a subsequent removeRefs can delete them.
     *                     _flush is not thread safe when all is true.
-    *   @return TRUE if any value in cache was flushed or FALSE otherwise.
+    *   @return true if any value in cache was flushed or false otherwise.
     */
    UBool _flush(UBool all) const;
 
@@ -395,11 +395,11 @@ class U_COMMON_API UnifiedCache : public UnifiedCacheBase {
      * Attempts to fetch value and status for key from cache.
      * On entry, gCacheMutex must not be held value must be NULL and status must
      * be U_ZERO_ERROR.
-     * On exit, either returns FALSE (In this
-     * case caller should try to create the object) or returns TRUE with value
+     * On exit, either returns false (In this
+     * case caller should try to create the object) or returns true with value
      * pointing to the fetched value and status set to fetched status. When
-     * FALSE is returned status may be set to failure if an in progress hash
-     * entry could not be made but value will remain unchanged. When TRUE is
+     * false is returned status may be set to failure if an in progress hash
+     * entry could not be made but value will remain unchanged. When true is
      * returned, caller must call removeRef() on value.
      */
     UBool _poll(
@@ -463,17 +463,17 @@ class U_COMMON_API UnifiedCache : public UnifiedCacheBase {
    void _runEvictionSlice() const;
 
    /**
-    * Register a master cache entry. A master key is the first key to create
+    * Register a primary cache entry. A primary key is the first key to create
     * a given  SharedObject value. Subsequent keys whose create function
-    * produce referneces to an already existing SharedObject are not masters -
+    * produce referneces to an already existing SharedObject are not primary -
     * they can be evicted and subsequently recreated.
     *
     * On entry, gCacheMutex must be held.
-    * On exit, items in use count incremented, entry is marked as a master
+    * On exit, items in use count incremented, entry is marked as a primary
     * entry, and value registered with cache so that subsequent calls to
     * addRef() and removeRef() on it correctly interact with the cache.
     */
-   void _registerMaster(const CacheKeyBase *theKey, const SharedObject *value) const;
+   void _registerPrimary(const CacheKeyBase *theKey, const SharedObject *value) const;
 
    /**
     * Store a value and creation error status in given hash entry.
diff --git a/deps/icu-small/source/common/uniquecharstr.h b/deps/icu-small/source/common/uniquecharstr.h
new file mode 100644
index 0000000000000000000000000000000000000000..10cc924f7f9eb2f6e6c80c97e3d3ccd1153b8c6f
--- /dev/null
+++ b/deps/icu-small/source/common/uniquecharstr.h
@@ -0,0 +1,98 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+// uniquecharstr.h
+// created: 2020sep01 Frank Yung-Fong Tang
+
+#ifndef __UNIQUECHARSTR_H__
+#define __UNIQUECHARSTR_H__
+
+#include "charstr.h"
+#include "uassert.h"
+#include "uhash.h"
+
+U_NAMESPACE_BEGIN
+
+/**
+ * Stores NUL-terminated strings with duplicate elimination.
+ * Checks for unique UTF-16 string pointers and converts to invariant characters.
+ *
+ * Intended to be stack-allocated. Add strings, get a unique number for each,
+ * freeze the object, get a char * pointer for each string,
+ * call orphanCharStrings() to capture the string storage, and let this object go out of scope.
+ */
+class UniqueCharStrings {
+public:
+    UniqueCharStrings(UErrorCode &errorCode) : strings(nullptr) {
+        // Note: We hash on string contents but store stable char16_t * pointers.
+        // If the strings are stored in resource bundles which should be built with
+        // duplicate elimination, then we should be able to hash on just the pointer values.
+        uhash_init(&map, uhash_hashUChars, uhash_compareUChars, uhash_compareLong, &errorCode);
+        if (U_FAILURE(errorCode)) { return; }
+        strings = new CharString();
+        if (strings == nullptr) {
+            errorCode = U_MEMORY_ALLOCATION_ERROR;
+        }
+    }
+    ~UniqueCharStrings() {
+        uhash_close(&map);
+        delete strings;
+    }
+
+    /** Returns/orphans the CharString that contains all strings. */
+    CharString *orphanCharStrings() {
+        CharString *result = strings;
+        strings = nullptr;
+        return result;
+    }
+
+    /**
+     * Adds a string and returns a unique number for it.
+     * The string's buffer contents must not change, nor move around in memory,
+     * while this UniqueCharStrings is in use.
+     * The string contents must be NUL-terminated exactly at s.length().
+     *
+     * Best used with read-only-alias UnicodeString objects that point to
+     * stable storage, such as strings returned by resource bundle functions.
+     */
+    int32_t add(const UnicodeString &s, UErrorCode &errorCode) {
+        if (U_FAILURE(errorCode)) { return 0; }
+        if (isFrozen) {
+            errorCode = U_NO_WRITE_PERMISSION;
+            return 0;
+        }
+        // The string points into the resource bundle.
+        const char16_t *p = s.getBuffer();
+        int32_t oldIndex = uhash_geti(&map, p);
+        if (oldIndex != 0) {  // found duplicate
+            return oldIndex;
+        }
+        // Explicit NUL terminator for the previous string.
+        // The strings object is also terminated with one implicit NUL.
+        strings->append(0, errorCode);
+        int32_t newIndex = strings->length();
+        strings->appendInvariantChars(s, errorCode);
+        uhash_puti(&map, const_cast<char16_t *>(p), newIndex, &errorCode);
+        return newIndex;
+    }
+
+    void freeze() { isFrozen = true; }
+
+    /**
+     * Returns a string pointer for its unique number, if this object is frozen.
+     * Otherwise nullptr.
+     */
+    const char *get(int32_t i) const {
+        U_ASSERT(isFrozen);
+        return isFrozen && i > 0 ? strings->data() + i : nullptr;
+    }
+
+private:
+    UHashtable map;
+    CharString *strings;
+    bool isFrozen = false;
+};
+
+U_NAMESPACE_END
+
+#endif  // __UNIQUECHARSTR_H__
diff --git a/deps/icu-small/source/common/uniset.cpp b/deps/icu-small/source/common/uniset.cpp
index 3807b837475948f1064eb8f839739b56b492886e..067930b73bd6b2ee33c09849e2c4bd3aa3749920 100644
--- a/deps/icu-small/source/common/uniset.cpp
+++ b/deps/icu-small/source/common/uniset.cpp
@@ -30,24 +30,6 @@
 #include "bmpset.h"
 #include "unisetspan.h"
 
-// Define UChar constants using hex for EBCDIC compatibility
-// Used #define to reduce private static exports and memory access time.
-#define SET_OPEN        ((UChar)0x005B) /*[*/
-#define SET_CLOSE       ((UChar)0x005D) /*]*/
-#define HYPHEN          ((UChar)0x002D) /*-*/
-#define COMPLEMENT      ((UChar)0x005E) /*^*/
-#define COLON           ((UChar)0x003A) /*:*/
-#define BACKSLASH       ((UChar)0x005C) /*\*/
-#define INTERSECTION    ((UChar)0x0026) /*&*/
-#define UPPER_U         ((UChar)0x0055) /*U*/
-#define LOWER_U         ((UChar)0x0075) /*u*/
-#define OPEN_BRACE      ((UChar)123)    /*{*/
-#define CLOSE_BRACE     ((UChar)125)    /*}*/
-#define UPPER_P         ((UChar)0x0050) /*P*/
-#define LOWER_P         ((UChar)0x0070) /*p*/
-#define UPPER_N         ((UChar)78)     /*N*/
-#define EQUALS          ((UChar)0x003D) /*=*/
-
 // HIGH_VALUE > all valid values. 110000 for codepoints
 #define UNICODESET_HIGH 0x0110000
 
@@ -444,7 +426,6 @@ UBool UnicodeSet::contains(UChar32 start, UChar32 end) const {
  * @return <tt>true</tt> if this set contains the specified string
  */
 UBool UnicodeSet::contains(const UnicodeString& s) const {
-    if (s.length() == 0) return FALSE;
     int32_t cp = getSingleCP(s);
     if (cp < 0) {
         return stringsContains(s);
@@ -559,11 +540,9 @@ UBool UnicodeSet::matchesIndexValue(uint8_t v) const {
     if (hasStrings()) {
         for (i=0; i<strings->size(); ++i) {
             const UnicodeString& s = *(const UnicodeString*)strings->elementAt(i);
-            //if (s.length() == 0) {
-            //    // Empty strings match everything
-            //    return TRUE;
-            //}
-            // assert(s.length() != 0); // We enforce this elsewhere
+            if (s.isEmpty()) {
+                continue;  // skip the empty string
+            }
             UChar32 c = s.char32At(0);
             if ((c & 0xFF) == v) {
                 return TRUE;
@@ -582,9 +561,6 @@ UMatchDegree UnicodeSet::matches(const Replaceable& text,
                                  int32_t limit,
                                  UBool incremental) {
     if (offset == limit) {
-        // Strings, if any, have length != 0, so we don't worry
-        // about them here.  If we ever allow zero-length strings
-        // we much check for them here.
         if (contains(U_ETHER)) {
             return incremental ? U_PARTIAL_MATCH : U_MATCH;
         } else {
@@ -614,11 +590,9 @@ UMatchDegree UnicodeSet::matches(const Replaceable& text,
 
             for (i=0; i<strings->size(); ++i) {
                 const UnicodeString& trial = *(const UnicodeString*)strings->elementAt(i);
-
-                //if (trial.length() == 0) {
-                //    return U_MATCH; // null-string always matches
-                //}
-                // assert(trial.length() != 0); // We ensure this elsewhere
+                if (trial.isEmpty()) {
+                    continue;  // skip the empty string
+                }
 
                 UChar c = trial.charAt(forward ? 0 : trial.length() - 1);
 
@@ -971,12 +945,12 @@ UnicodeSet& UnicodeSet::add(UChar32 c) {
  * present.  If this set already contains the multicharacter,
  * the call leaves this set unchanged.
  * Thus "ch" => {"ch"}
- * <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
+ *
  * @param s the source string
  * @return the modified set, for chaining
  */
 UnicodeSet& UnicodeSet::add(const UnicodeString& s) {
-    if (s.length() == 0 || isFrozen() || isBogus()) return *this;
+    if (isFrozen() || isBogus()) return *this;
     int32_t cp = getSingleCP(s);
     if (cp < 0) {
         if (!stringsContains(s)) {
@@ -991,8 +965,7 @@ UnicodeSet& UnicodeSet::add(const UnicodeString& s) {
 
 /**
  * Adds the given string, in order, to 'strings'.  The given string
- * must have been checked by the caller to not be empty and to not
- * already be in 'strings'.
+ * must have been checked by the caller to not already be in 'strings'.
  */
 void UnicodeSet::_add(const UnicodeString& s) {
     if (isFrozen() || isBogus()) {
@@ -1021,16 +994,13 @@ void UnicodeSet::_add(const UnicodeString& s) {
  * @param string to test
  */
 int32_t UnicodeSet::getSingleCP(const UnicodeString& s) {
-    //if (s.length() < 1) {
-    //    throw new IllegalArgumentException("Can't use zero-length strings in UnicodeSet");
-    //}
-    if (s.length() > 2) return -1;
-    if (s.length() == 1) return s.charAt(0);
-
-    // at this point, len = 2
-    UChar32 cp = s.char32At(0);
-    if (cp > 0xFFFF) { // is surrogate pair
-        return cp;
+    int32_t sLength = s.length();
+    if (sLength == 1) return s.charAt(0);
+    if (sLength == 2) {
+        UChar32 cp = s.char32At(0);
+        if (cp > 0xFFFF) { // is surrogate pair
+            return cp;
+        }
     }
     return -1;
 }
@@ -1150,6 +1120,26 @@ UnicodeSet& UnicodeSet::retain(UChar32 c) {
     return retain(c, c);
 }
 
+UnicodeSet& UnicodeSet::retain(const UnicodeString &s) {
+    if (isFrozen() || isBogus()) { return *this; }
+    UChar32 cp = getSingleCP(s);
+    if (cp < 0) {
+        bool isIn = stringsContains(s);
+        // Check for getRangeCount() first to avoid somewhat-expensive size()
+        // when there are single code points.
+        if (isIn && getRangeCount() == 0 && size() == 1) {
+            return *this;
+        }
+        clear();
+        if (isIn) {
+            _add(s);
+        }
+    } else {
+        retain(cp, cp);
+    }
+    return *this;
+}
+
 /**
  * Removes the specified range from this set if it is present.
  * The set will not contain the specified range once the call
@@ -1186,7 +1176,7 @@ UnicodeSet& UnicodeSet::remove(UChar32 c) {
  * @return the modified set, for chaining
  */
 UnicodeSet& UnicodeSet::remove(const UnicodeString& s) {
-    if (s.length() == 0 || isFrozen() || isBogus()) return *this;
+    if (isFrozen() || isBogus()) return *this;
     int32_t cp = getSingleCP(s);
     if (cp < 0) {
         if (strings != nullptr && strings->removeElement((void*) &s)) {
@@ -1252,12 +1242,12 @@ UnicodeSet& UnicodeSet::complement(void) {
  * Complement the specified string in this set.
  * The set will not contain the specified string once the call
  * returns.
- * <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
+ *
  * @param s the string to complement
  * @return this object, for chaining
  */
 UnicodeSet& UnicodeSet::complement(const UnicodeString& s) {
-    if (s.length() == 0 || isFrozen() || isBogus()) return *this;
+    if (isFrozen() || isBogus()) return *this;
     int32_t cp = getSingleCP(s);
     if (cp < 0) {
         if (stringsContains(s)) {
@@ -2001,22 +1991,22 @@ escapeUnprintable) {
     }
     // Okay to let ':' pass through
     switch (c) {
-    case SET_OPEN:
-    case SET_CLOSE:
-    case HYPHEN:
-    case COMPLEMENT:
-    case INTERSECTION:
-    case BACKSLASH:
-    case OPEN_BRACE:
-    case CLOSE_BRACE:
-    case COLON:
+    case u'[':
+    case u']':
+    case u'-':
+    case u'^':
+    case u'&':
+    case u'\\':
+    case u'{':
+    case u'}':
+    case u':':
     case SymbolTable::SYMBOL_REF:
-        buf.append(BACKSLASH);
+        buf.append(u'\\');
         break;
     default:
         // Escape whitespace
         if (PatternProps::isWhiteSpace(c)) {
-            buf.append(BACKSLASH);
+            buf.append(u'\\');
         }
         break;
     }
@@ -2049,7 +2039,7 @@ UnicodeString& UnicodeSet::_toPattern(UnicodeString& result,
                 backslashCount = 0;
             } else {
                 result.append(c);
-                if (c == BACKSLASH) {
+                if (c == u'\\') {
                     ++backslashCount;
                 } else {
                     backslashCount = 0;
@@ -2082,13 +2072,13 @@ UnicodeString& UnicodeSet::toPattern(UnicodeString& result,
 UnicodeString& UnicodeSet::_generatePattern(UnicodeString& result,
                                             UBool escapeUnprintable) const
 {
-    result.append(SET_OPEN);
+    result.append(u'[');
 
 //  // Check against the predefined categories.  We implicitly build
 //  // up ALL category sets the first time toPattern() is called.
 //  for (int8_t cat=0; cat<Unicode::GENERAL_TYPES_COUNT; ++cat) {
 //      if (*this == getCategorySet(cat)) {
-//          result.append(COLON);
+//          result.append(u':');
 //          result.append(CATEGORY_NAMES, cat*2, 2);
 //          return result.append(CATEGORY_CLOSE);
 //      }
@@ -2104,7 +2094,7 @@ UnicodeString& UnicodeSet::_generatePattern(UnicodeString& result,
         getRangeEnd(count-1) == MAX_VALUE) {
 
         // Emit the inverse
-        result.append(COMPLEMENT);
+        result.append(u'^');
 
         for (int32_t i = 1; i < count; ++i) {
             UChar32 start = getRangeEnd(i-1)+1;
@@ -2112,7 +2102,7 @@ UnicodeString& UnicodeSet::_generatePattern(UnicodeString& result,
             _appendToPat(result, start, escapeUnprintable);
             if (start != end) {
                 if ((start+1) != end) {
-                    result.append(HYPHEN);
+                    result.append(u'-');
                 }
                 _appendToPat(result, end, escapeUnprintable);
             }
@@ -2127,7 +2117,7 @@ UnicodeString& UnicodeSet::_generatePattern(UnicodeString& result,
             _appendToPat(result, start, escapeUnprintable);
             if (start != end) {
                 if ((start+1) != end) {
-                    result.append(HYPHEN);
+                    result.append(u'-');
                 }
                 _appendToPat(result, end, escapeUnprintable);
             }
@@ -2136,14 +2126,14 @@ UnicodeString& UnicodeSet::_generatePattern(UnicodeString& result,
 
     if (strings != nullptr) {
         for (int32_t i = 0; i<strings->size(); ++i) {
-            result.append(OPEN_BRACE);
+            result.append(u'{');
             _appendToPat(result,
                          *(const UnicodeString*) strings->elementAt(i),
                          escapeUnprintable);
-            result.append(CLOSE_BRACE);
+            result.append(u'}');
         }
     }
-    return result.append(SET_CLOSE);
+    return result.append(u']');
 }
 
 /**
diff --git a/deps/icu-small/source/common/uniset_props.cpp b/deps/icu-small/source/common/uniset_props.cpp
index 45d3dab9938b29aefc9826d4d5be074e58a41595..8c86cc18c7473fbc0209dbe25179e45ca37aaf86 100644
--- a/deps/icu-small/source/common/uniset_props.cpp
+++ b/deps/icu-small/source/common/uniset_props.cpp
@@ -47,31 +47,6 @@
 
 U_NAMESPACE_USE
 
-// Define UChar constants using hex for EBCDIC compatibility
-// Used #define to reduce private static exports and memory access time.
-#define SET_OPEN        ((UChar)0x005B) /*[*/
-#define SET_CLOSE       ((UChar)0x005D) /*]*/
-#define HYPHEN          ((UChar)0x002D) /*-*/
-#define COMPLEMENT      ((UChar)0x005E) /*^*/
-#define COLON           ((UChar)0x003A) /*:*/
-#define BACKSLASH       ((UChar)0x005C) /*\*/
-#define INTERSECTION    ((UChar)0x0026) /*&*/
-#define UPPER_U         ((UChar)0x0055) /*U*/
-#define LOWER_U         ((UChar)0x0075) /*u*/
-#define OPEN_BRACE      ((UChar)123)    /*{*/
-#define CLOSE_BRACE     ((UChar)125)    /*}*/
-#define UPPER_P         ((UChar)0x0050) /*P*/
-#define LOWER_P         ((UChar)0x0070) /*p*/
-#define UPPER_N         ((UChar)78)     /*N*/
-#define EQUALS          ((UChar)0x003D) /*=*/
-
-//static const UChar POSIX_OPEN[]  = { SET_OPEN,COLON,0 };  // "[:"
-static const UChar POSIX_CLOSE[] = { COLON,SET_CLOSE,0 };  // ":]"
-//static const UChar PERL_OPEN[]   = { BACKSLASH,LOWER_P,0 }; // "\\p"
-//static const UChar PERL_CLOSE[]  = { CLOSE_BRACE,0 };    // "}"
-//static const UChar NAME_OPEN[]   = { BACKSLASH,UPPER_N,0 };  // "\\N"
-static const UChar HYPHEN_RIGHT_BRACE[] = {HYPHEN,SET_CLOSE,0}; /*-]*/
-
 // Special property set IDs
 static const char ANY[]   = "ANY";   // [\u0000-\U0010FFFF]
 static const char ASCII[] = "ASCII"; // [\u0000-\u007F]
@@ -81,12 +56,6 @@ static const char ASSIGNED[] = "Assigned"; // [:^Cn:]
 #define NAME_PROP "na"
 #define NAME_PROP_LENGTH 2
 
-/**
- * Delimiter string used in patterns to close a category reference:
- * ":]".  Example: "[:Lu:]".
- */
-//static const UChar CATEGORY_CLOSE[] = {COLON, SET_CLOSE, 0x0000}; /* ":]" */
-
 // Cached sets ------------------------------------------------------------- ***
 
 U_CDECL_BEGIN
@@ -140,27 +109,27 @@ uniset_getUnicode32Instance(UErrorCode &errorCode) {
 static inline UBool
 isPerlOpen(const UnicodeString &pattern, int32_t pos) {
     UChar c;
-    return pattern.charAt(pos)==BACKSLASH && ((c=pattern.charAt(pos+1))==LOWER_P || c==UPPER_P);
+    return pattern.charAt(pos)==u'\\' && ((c=pattern.charAt(pos+1))==u'p' || c==u'P');
 }
 
 /*static inline UBool
 isPerlClose(const UnicodeString &pattern, int32_t pos) {
-    return pattern.charAt(pos)==CLOSE_BRACE;
+    return pattern.charAt(pos)==u'}';
 }*/
 
 static inline UBool
 isNameOpen(const UnicodeString &pattern, int32_t pos) {
-    return pattern.charAt(pos)==BACKSLASH && pattern.charAt(pos+1)==UPPER_N;
+    return pattern.charAt(pos)==u'\\' && pattern.charAt(pos+1)==u'N';
 }
 
 static inline UBool
 isPOSIXOpen(const UnicodeString &pattern, int32_t pos) {
-    return pattern.charAt(pos)==SET_OPEN && pattern.charAt(pos+1)==COLON;
+    return pattern.charAt(pos)==u'[' && pattern.charAt(pos+1)==u':';
 }
 
 /*static inline UBool
 isPOSIXClose(const UnicodeString &pattern, int32_t pos) {
-    return pattern.charAt(pos)==COLON && pattern.charAt(pos+1)==SET_CLOSE;
+    return pattern.charAt(pos)==u':' && pattern.charAt(pos+1)==u']';
 }*/
 
 // TODO memory debugging provided inside uniset.cpp
@@ -326,9 +295,8 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
 
     while (mode != 2 && !chars.atEnd()) {
         U_ASSERT((lastItem == 0 && op == 0) ||
-                 (lastItem == 1 && (op == 0 || op == HYPHEN /*'-'*/)) ||
-                 (lastItem == 2 && (op == 0 || op == HYPHEN /*'-'*/ ||
-                                    op == INTERSECTION /*'&'*/)));
+                 (lastItem == 1 && (op == 0 || op == u'-')) ||
+                 (lastItem == 2 && (op == 0 || op == u'-' || op == u'&')));
 
         UChar32 c = 0;
         UBool literal = FALSE;
@@ -356,27 +324,27 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
             c = chars.next(opts, literal, ec);
             if (U_FAILURE(ec)) return;
 
-            if (c == 0x5B /*'['*/ && !literal) {
+            if (c == u'[' && !literal) {
                 if (mode == 1) {
                     chars.setPos(backup); // backup
                     setMode = 1;
                 } else {
                     // Handle opening '[' delimiter
                     mode = 1;
-                    patLocal.append((UChar) 0x5B /*'['*/);
+                    patLocal.append(u'[');
                     chars.getPos(backup); // prepare to backup
                     c = chars.next(opts, literal, ec);
                     if (U_FAILURE(ec)) return;
-                    if (c == 0x5E /*'^'*/ && !literal) {
+                    if (c == u'^' && !literal) {
                         invert = TRUE;
-                        patLocal.append((UChar) 0x5E /*'^'*/);
+                        patLocal.append(u'^');
                         chars.getPos(backup); // prepare to backup
                         c = chars.next(opts, literal, ec);
                         if (U_FAILURE(ec)) return;
                     }
                     // Fall through to handle special leading '-';
                     // otherwise restart loop for nested [], \p{}, etc.
-                    if (c == HYPHEN /*'-'*/) {
+                    if (c == u'-') {
                         literal = TRUE;
                         // Fall through to handle literal '-' below
                     } else {
@@ -418,7 +386,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                 op = 0;
             }
 
-            if (op == HYPHEN /*'-'*/ || op == INTERSECTION /*'&'*/) {
+            if (op == u'-' || op == u'&') {
                 patLocal.append(op);
             }
 
@@ -454,10 +422,10 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
             }
 
             switch (op) {
-            case HYPHEN: /*'-'*/
+            case u'-':
                 removeAll(*nested);
                 break;
-            case INTERSECTION: /*'&'*/
+            case u'&':
                 retainAll(*nested);
                 break;
             case 0:
@@ -483,24 +451,24 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
 
         if (!literal) {
             switch (c) {
-            case 0x5D /*']'*/:
+            case u']':
                 if (lastItem == 1) {
                     add(lastChar, lastChar);
                     _appendToPat(patLocal, lastChar, FALSE);
                 }
                 // Treat final trailing '-' as a literal
-                if (op == HYPHEN /*'-'*/) {
+                if (op == u'-') {
                     add(op, op);
                     patLocal.append(op);
-                } else if (op == INTERSECTION /*'&'*/) {
+                } else if (op == u'&') {
                     // syntaxError(chars, "Trailing '&'");
                     ec = U_MALFORMED_SET;
                     return;
                 }
-                patLocal.append((UChar) 0x5D /*']'*/);
+                patLocal.append(u']');
                 mode = 2;
                 continue;
-            case HYPHEN /*'-'*/:
+            case u'-':
                 if (op == 0) {
                     if (lastItem != 0) {
                         op = (UChar) c;
@@ -510,8 +478,8 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                         add(c, c);
                         c = chars.next(opts, literal, ec);
                         if (U_FAILURE(ec)) return;
-                        if (c == 0x5D /*']'*/ && !literal) {
-                            patLocal.append(HYPHEN_RIGHT_BRACE, 2);
+                        if (c == u']' && !literal) {
+                            patLocal.append(u"-]", 2);
                             mode = 2;
                             continue;
                         }
@@ -520,7 +488,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                 // syntaxError(chars, "'-' not after char or set");
                 ec = U_MALFORMED_SET;
                 return;
-            case INTERSECTION /*'&'*/:
+            case u'&':
                 if (lastItem == 2 && op == 0) {
                     op = (UChar) c;
                     continue;
@@ -528,11 +496,11 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                 // syntaxError(chars, "'&' not after set");
                 ec = U_MALFORMED_SET;
                 return;
-            case 0x5E /*'^'*/:
+            case u'^':
                 // syntaxError(chars, "'^' not after '['");
                 ec = U_MALFORMED_SET;
                 return;
-            case 0x7B /*'{'*/:
+            case u'{':
                 if (op != 0) {
                     // syntaxError(chars, "Missing operand after operator");
                     ec = U_MALFORMED_SET;
@@ -549,13 +517,13 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                     while (!chars.atEnd()) {
                         c = chars.next(opts, literal, ec);
                         if (U_FAILURE(ec)) return;
-                        if (c == 0x7D /*'}'*/ && !literal) {
+                        if (c == u'}' && !literal) {
                             ok = TRUE;
                             break;
                         }
                         buf.append(c);
                     }
-                    if (buf.length() < 1 || !ok) {
+                    if (!ok) {
                         // syntaxError(chars, "Invalid multicharacter string");
                         ec = U_MALFORMED_SET;
                         return;
@@ -565,9 +533,9 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                 // we don't need to drop through to the further
                 // processing
                 add(buf);
-                patLocal.append((UChar) 0x7B /*'{'*/);
+                patLocal.append(u'{');
                 _appendToPat(patLocal, buf, FALSE);
-                patLocal.append((UChar) 0x7D /*'}'*/);
+                patLocal.append(u'}');
                 continue;
             case SymbolTable::SYMBOL_REF:
                 //         symbols  nosymbols
@@ -580,7 +548,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                     chars.getPos(backup);
                     c = chars.next(opts, literal, ec);
                     if (U_FAILURE(ec)) return;
-                    UBool anchor = (c == 0x5D /*']'*/ && !literal);
+                    UBool anchor = (c == u']' && !literal);
                     if (symbols == 0 && !anchor) {
                         c = SymbolTable::SYMBOL_REF;
                         chars.setPos(backup);
@@ -594,7 +562,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                         add(U_ETHER);
                         usePat = TRUE;
                         patLocal.append((UChar) SymbolTable::SYMBOL_REF);
-                        patLocal.append((UChar) 0x5D /*']'*/);
+                        patLocal.append(u']');
                         mode = 2;
                         continue;
                     }
@@ -617,7 +585,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
             lastChar = c;
             break;
         case 1:
-            if (op == HYPHEN /*'-'*/) {
+            if (op == u'-') {
                 if (lastChar >= c) {
                     // Don't allow redundant (a-a) or empty (b-a) ranges;
                     // these are most likely typos.
@@ -1036,11 +1004,11 @@ UBool UnicodeSet::resemblesPropertyPattern(RuleCharacterIterator& chars,
     RuleCharacterIterator::Pos pos;
     chars.getPos(pos);
     UChar32 c = chars.next(iterOpts, literal, ec);
-    if (c == 0x5B /*'['*/ || c == 0x5C /*'\\'*/) {
+    if (c == u'[' || c == u'\\') {
         UChar32 d = chars.next(iterOpts & ~RuleCharacterIterator::SKIP_WHITESPACE,
                                literal, ec);
-        result = (c == 0x5B /*'['*/) ? (d == 0x3A /*':'*/) :
-                 (d == 0x4E /*'N'*/ || d == 0x70 /*'p'*/ || d == 0x50 /*'P'*/);
+        result = (c == u'[') ? (d == u':') :
+                               (d == u'N' || d == u'p' || d == u'P');
     }
     chars.setPos(pos);
     return result && U_SUCCESS(ec);
@@ -1071,17 +1039,17 @@ UnicodeSet& UnicodeSet::applyPropertyPattern(const UnicodeString& pattern,
         posix = TRUE;
         pos += 2;
         pos = ICU_Utility::skipWhitespace(pattern, pos);
-        if (pos < pattern.length() && pattern.charAt(pos) == COMPLEMENT) {
+        if (pos < pattern.length() && pattern.charAt(pos) == u'^') {
             ++pos;
             invert = TRUE;
         }
     } else if (isPerlOpen(pattern, pos) || isNameOpen(pattern, pos)) {
         UChar c = pattern.charAt(pos+1);
-        invert = (c == UPPER_P);
-        isName = (c == UPPER_N);
+        invert = (c == u'P');
+        isName = (c == u'N');
         pos += 2;
         pos = ICU_Utility::skipWhitespace(pattern, pos);
-        if (pos == pattern.length() || pattern.charAt(pos++) != OPEN_BRACE) {
+        if (pos == pattern.length() || pattern.charAt(pos++) != u'{') {
             // Syntax error; "\p" or "\P" not followed by "{"
             FAIL(ec);
         }
@@ -1093,9 +1061,9 @@ UnicodeSet& UnicodeSet::applyPropertyPattern(const UnicodeString& pattern,
     // Look for the matching close delimiter, either :] or }
     int32_t close;
     if (posix) {
-      close = pattern.indexOf(POSIX_CLOSE, 2, pos);
+      close = pattern.indexOf(u":]", 2, pos);
     } else {
-      close = pattern.indexOf(CLOSE_BRACE, pos);
+      close = pattern.indexOf(u'}', pos);
     }
     if (close < 0) {
         // Syntax error; close delimiter missing
@@ -1105,7 +1073,7 @@ UnicodeSet& UnicodeSet::applyPropertyPattern(const UnicodeString& pattern,
     // Look for an '=' sign.  If this is present, we will parse a
     // medium \p{gc=Cf} or long \p{GeneralCategory=Format}
     // pattern.
-    int32_t equals = pattern.indexOf(EQUALS, pos);
+    int32_t equals = pattern.indexOf(u'=', pos);
     UnicodeString propName, valueName;
     if (equals >= 0 && equals < close && !isName) {
         // Equals seen; parse medium/long pattern
diff --git a/deps/icu-small/source/common/unisetspan.cpp b/deps/icu-small/source/common/unisetspan.cpp
index 68e44d91ee70661ad96c941e03f2edf71d148f97..fe0d74f5b28e76a43384c9bf8c825954ab1aa684 100644
--- a/deps/icu-small/source/common/unisetspan.cpp
+++ b/deps/icu-small/source/common/unisetspan.cpp
@@ -231,6 +231,9 @@ UnicodeSetStringSpan::UnicodeSetStringSpan(const UnicodeSet &set,
         const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
         const UChar *s16=string.getBuffer();
         int32_t length16=string.length();
+        if (length16==0) {
+            continue;  // skip the empty string
+        }
         UBool thisRelevant;
         spanLength=spanSet.span(s16, length16, USET_SPAN_CONTAINED);
         if(spanLength<length16) {  // Relevant string.
@@ -312,7 +315,7 @@ UnicodeSetStringSpan::UnicodeSetStringSpan(const UnicodeSet &set,
         const UChar *s16=string.getBuffer();
         int32_t length16=string.length();
         spanLength=spanSet.span(s16, length16, USET_SPAN_CONTAINED);
-        if(spanLength<length16) {  // Relevant string.
+        if(spanLength<length16 && length16>0) {  // Relevant string.
             if(which&UTF16) {
                 if(which&CONTAINED) {
                     if(which&FWD) {
@@ -362,7 +365,7 @@ UnicodeSetStringSpan::UnicodeSetStringSpan(const UnicodeSet &set,
                     addToSpanNotSet(c);
                 }
             }
-        } else {  // Irrelevant string.
+        } else {  // Irrelevant string. (Also the empty string.)
             if(which&UTF8) {
                 if(which&CONTAINED) {  // Only necessary for LONGEST_MATCH.
                     uint8_t *s8=utf8+utf8Count;
@@ -653,11 +656,12 @@ int32_t UnicodeSetStringSpan::span(const UChar *s, int32_t length, USetSpanCondi
             for(i=0; i<stringsLength; ++i) {
                 int32_t overlap=spanLengths[i];
                 if(overlap==ALL_CP_CONTAINED) {
-                    continue;  // Irrelevant string.
+                    continue;  // Irrelevant string. (Also the empty string.)
                 }
                 const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
                 const UChar *s16=string.getBuffer();
                 int32_t length16=string.length();
+                U_ASSERT(length>0);
 
                 // Try to match this string at pos-overlap..pos.
                 if(overlap>=LONG_SPAN) {
@@ -697,6 +701,9 @@ int32_t UnicodeSetStringSpan::span(const UChar *s, int32_t length, USetSpanCondi
                 const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
                 const UChar *s16=string.getBuffer();
                 int32_t length16=string.length();
+                if (length16==0) {
+                    continue;  // skip the empty string
+                }
 
                 // Try to match this string at pos-overlap..pos.
                 if(overlap>=LONG_SPAN) {
@@ -817,11 +824,12 @@ int32_t UnicodeSetStringSpan::spanBack(const UChar *s, int32_t length, USetSpanC
             for(i=0; i<stringsLength; ++i) {
                 int32_t overlap=spanBackLengths[i];
                 if(overlap==ALL_CP_CONTAINED) {
-                    continue;  // Irrelevant string.
+                    continue;  // Irrelevant string. (Also the empty string.)
                 }
                 const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
                 const UChar *s16=string.getBuffer();
                 int32_t length16=string.length();
+                U_ASSERT(length>0);
 
                 // Try to match this string at pos-(length16-overlap)..pos-length16.
                 if(overlap>=LONG_SPAN) {
@@ -863,6 +871,9 @@ int32_t UnicodeSetStringSpan::spanBack(const UChar *s, int32_t length, USetSpanC
                 const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
                 const UChar *s16=string.getBuffer();
                 int32_t length16=string.length();
+                if (length16==0) {
+                    continue;  // skip the empty string
+                }
 
                 // Try to match this string at pos-(length16-overlap)..pos-length16.
                 if(overlap>=LONG_SPAN) {
@@ -1358,11 +1369,12 @@ int32_t UnicodeSetStringSpan::spanNot(const UChar *s, int32_t length) const {
         // Try to match the strings at pos.
         for(i=0; i<stringsLength; ++i) {
             if(spanLengths[i]==ALL_CP_CONTAINED) {
-                continue;  // Irrelevant string.
+                continue;  // Irrelevant string. (Also the empty string.)
             }
             const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
             const UChar *s16=string.getBuffer();
             int32_t length16=string.length();
+            U_ASSERT(length>0);
             if(length16<=rest && matches16CPB(s, pos, length, s16, length16)) {
                 return pos;  // There is a set element at pos.
             }
@@ -1401,11 +1413,12 @@ int32_t UnicodeSetStringSpan::spanNotBack(const UChar *s, int32_t length) const
             // it is easier and we only need to know whether the string is irrelevant
             // which is the same in either array.
             if(spanLengths[i]==ALL_CP_CONTAINED) {
-                continue;  // Irrelevant string.
+                continue;  // Irrelevant string. (Also the empty string.)
             }
             const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
             const UChar *s16=string.getBuffer();
             int32_t length16=string.length();
+            U_ASSERT(length>0);
             if(length16<=pos && matches16CPB(s, pos-length16, length, s16, length16)) {
                 return pos;  // There is a set element at pos.
             }
diff --git a/deps/icu-small/source/common/unisetspan.h b/deps/icu-small/source/common/unisetspan.h
index f1e78ff3ee2b00bb123819287aa0f5e82749cc48..9a1307a9078aab4bc62e118ca5297ad4db943049 100644
--- a/deps/icu-small/source/common/unisetspan.h
+++ b/deps/icu-small/source/common/unisetspan.h
@@ -65,8 +65,8 @@ public:
 
     /*
      * Do the strings need to be checked in span() etc.?
-     * @return TRUE if strings need to be checked (call span() here),
-     *         FALSE if not (use a BMPSet for best performance).
+     * @return true if strings need to be checked (call span() here),
+     *         false if not (use a BMPSet for best performance).
      */
     inline UBool needsStringSpanUTF16();
     inline UBool needsStringSpanUTF8();
diff --git a/deps/icu-small/source/common/unormimp.h b/deps/icu-small/source/common/unormimp.h
index 7f280551f7ef8e78d2c7543dc7456714f008f948..e09c5c1c916773fbc8f30627923e72d5e092f1fb 100644
--- a/deps/icu-small/source/common/unormimp.h
+++ b/deps/icu-small/source/common/unormimp.h
@@ -418,7 +418,7 @@ enum {
  * The same bit is used for NFC and NFKC; (c) differs for them.
  * As usual, we build the "not skippable" flags so that unassigned
  * code points get a 0 bit.
- * This bit is only valid after (a)..(e) test FALSE; test NFD_NO before (f) as well.
+ * This bit is only valid after (a)..(e) test false; test NFD_NO before (f) as well.
  * Test Hangul LV syllables entirely in code.
  *
  *
diff --git a/deps/icu-small/source/common/uprops.h b/deps/icu-small/source/common/uprops.h
index 8bf929919f200cdfd1787cd7ac18727b8f41f765..09830bdeb998925dacce3b9b24ba8b6d51afcf6e 100644
--- a/deps/icu-small/source/common/uprops.h
+++ b/deps/icu-small/source/common/uprops.h
@@ -310,55 +310,12 @@ u_isgraphPOSIX(UChar32 c);
 U_CFUNC UBool
 u_isprintPOSIX(UChar32 c);
 
-/** Turn a bit index into a bit flag. @internal */
-#define FLAG(n) ((uint32_t)1<<(n))
-
-/** Flags for general categories in the order of UCharCategory. @internal */
-#define _Cn     FLAG(U_GENERAL_OTHER_TYPES)
-#define _Lu     FLAG(U_UPPERCASE_LETTER)
-#define _Ll     FLAG(U_LOWERCASE_LETTER)
-#define _Lt     FLAG(U_TITLECASE_LETTER)
-#define _Lm     FLAG(U_MODIFIER_LETTER)
-/* #define _Lo     FLAG(U_OTHER_LETTER) -- conflicts with MS Visual Studio 9.0 xiosbase */
-#define _Mn     FLAG(U_NON_SPACING_MARK)
-#define _Me     FLAG(U_ENCLOSING_MARK)
-#define _Mc     FLAG(U_COMBINING_SPACING_MARK)
-#define _Nd     FLAG(U_DECIMAL_DIGIT_NUMBER)
-#define _Nl     FLAG(U_LETTER_NUMBER)
-#define _No     FLAG(U_OTHER_NUMBER)
-#define _Zs     FLAG(U_SPACE_SEPARATOR)
-#define _Zl     FLAG(U_LINE_SEPARATOR)
-#define _Zp     FLAG(U_PARAGRAPH_SEPARATOR)
-#define _Cc     FLAG(U_CONTROL_CHAR)
-#define _Cf     FLAG(U_FORMAT_CHAR)
-#define _Co     FLAG(U_PRIVATE_USE_CHAR)
-#define _Cs     FLAG(U_SURROGATE)
-#define _Pd     FLAG(U_DASH_PUNCTUATION)
-#define _Ps     FLAG(U_START_PUNCTUATION)
-/* #define _Pe     FLAG(U_END_PUNCTUATION) -- conflicts with MS Visual Studio 9.0 xlocnum */
-/* #define _Pc     FLAG(U_CONNECTOR_PUNCTUATION) -- conflicts with MS Visual Studio 9.0 streambuf */
-#define _Po     FLAG(U_OTHER_PUNCTUATION)
-#define _Sm     FLAG(U_MATH_SYMBOL)
-#define _Sc     FLAG(U_CURRENCY_SYMBOL)
-#define _Sk     FLAG(U_MODIFIER_SYMBOL)
-#define _So     FLAG(U_OTHER_SYMBOL)
-#define _Pi     FLAG(U_INITIAL_PUNCTUATION)
-/* #define _Pf     FLAG(U_FINAL_PUNCTUATION) -- conflicts with MS Visual Studio 9.0 streambuf */
-
 /** Some code points. @internal */
 enum {
     TAB     =0x0009,
     LF      =0x000a,
     FF      =0x000c,
     CR      =0x000d,
-    U_A     =0x0041,
-    U_F     =0x0046,
-    U_Z     =0x005a,
-    U_a     =0x0061,
-    U_f     =0x0066,
-    U_z     =0x007a,
-    DEL     =0x007f,
-    NL      =0x0085,
     NBSP    =0x00a0,
     CGJ     =0x034f,
     FIGURESP=0x2007,
@@ -367,15 +324,6 @@ enum {
     ZWJ     =0x200d,
     RLM     =0x200f,
     NNBSP   =0x202f,
-    WJ      =0x2060,
-    INHSWAP =0x206a,
-    NOMDIG  =0x206f,
-    U_FW_A  =0xff21,
-    U_FW_F  =0xff26,
-    U_FW_Z  =0xff3a,
-    U_FW_a  =0xff41,
-    U_FW_f  =0xff46,
-    U_FW_z  =0xff5a,
     ZWNBSP  =0xfeff
 };
 
diff --git a/deps/icu-small/source/common/uresbund.cpp b/deps/icu-small/source/common/uresbund.cpp
index f4efb8ccab5a0b04c610130a7d0dac2a76e7a58b..73c4b44037e8aa7051c289717b92189c04f37d9c 100644
--- a/deps/icu-small/source/common/uresbund.cpp
+++ b/deps/icu-small/source/common/uresbund.cpp
@@ -91,6 +91,15 @@ static UBool chopLocale(char *name) {
     return FALSE;
 }
 
+/**
+ *  Called to check whether a name without '_' needs to be checked for a parent.
+ *  Some code had assumed that locale IDs with '_' could not have a non-root parent.
+ *  We may want a better way of doing this.
+ */
+static UBool mayHaveParent(char *name) {
+    return (name[0] != 0 && uprv_strstr("nb nn",name) != nullptr);
+}
+
 /**
  *  Internal function
  */
@@ -529,8 +538,8 @@ loadParentsExceptRoot(UResourceDataEntry *&t1,
                       char name[], int32_t nameCapacity,
                       UBool usingUSRData, char usrDataPath[], UErrorCode *status) {
     if (U_FAILURE(*status)) { return FALSE; }
-    UBool hasChopped = TRUE;
-    while (hasChopped && t1->fParent == NULL && !t1->fData.noFallback &&
+    UBool checkParent = TRUE;
+    while (checkParent && t1->fParent == NULL && !t1->fData.noFallback &&
             res_getResource(&t1->fData,"%%ParentIsRoot") == RES_BOGUS) {
         Resource parentRes = res_getResource(&t1->fData, "%%Parent");
         if (parentRes != RES_BOGUS) {  // An explicit parent was found.
@@ -573,7 +582,7 @@ loadParentsExceptRoot(UResourceDataEntry *&t1,
             }
         }
         t1 = t2;
-        hasChopped = chopLocale(name);
+        checkParent = chopLocale(name) || mayHaveParent(name);
     }
     return TRUE;
 }
@@ -692,7 +701,7 @@ static UResourceDataEntry *entryOpen(const char* path, const char* localeID,
                 }
             }
         }
-        if (hasChopped && !isRoot) {
+        if ((hasChopped || mayHaveParent(name)) && !isRoot) {
             if (!loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name), usingUSRData, usrDataPath, status)) {
                 goto finish;
             }
@@ -716,7 +725,7 @@ static UResourceDataEntry *entryOpen(const char* path, const char* localeID,
             hasRealData = TRUE;
             isDefault = TRUE;
             // TODO: Why not if (usingUSRData) { ... } like in the non-default-locale code path?
-            if (hasChopped && !isRoot) {
+            if ((hasChopped || mayHaveParent(name)) && !isRoot) {
                 if (!loadParentsExceptRoot(t1, name, UPRV_LENGTHOF(name), usingUSRData, usrDataPath, status)) {
                     goto finish;
                 }
@@ -1792,7 +1801,7 @@ ures_findSubResource(const UResourceBundle *resB, char* path, UResourceBundle *f
 
   return result;
 }
-U_INTERNAL const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ures_getStringByKeyWithFallback(const UResourceBundle *resB,
                                 const char* inKey,
                                 int32_t* len,
@@ -1908,6 +1917,8 @@ ures_getByKeyWithFallback(const UResourceBundle *resB,
                             } else {
                               break;
                             }
+                        } else if (res == RES_BOGUS) {
+                            break;
                         }
                     } while(*myPath); /* Continue until the whole path is consumed */
                 }
@@ -2210,7 +2221,7 @@ ures_getUTF8StringByKey(const UResourceBundle *resB,
  *  INTERNAL: Get the name of the first real locale (not placeholder)
  *  that has resource bundle data.
  */
-U_INTERNAL const char*  U_EXPORT2
+U_CAPI const char*  U_EXPORT2
 ures_getLocaleInternal(const UResourceBundle* resourceBundle, UErrorCode* status)
 {
     if (status==NULL || U_FAILURE(*status)) {
@@ -2357,7 +2368,7 @@ ures_openDirect(const char* path, const char* localeID, UErrorCode* status) {
  *
  * Same as ures_open(), but uses the fill-in parameter and does not allocate a new bundle.
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 ures_openFillIn(UResourceBundle *r, const char* path,
                 const char* localeID, UErrorCode* status) {
     if(U_SUCCESS(*status) && r == NULL) {
@@ -2370,7 +2381,7 @@ ures_openFillIn(UResourceBundle *r, const char* path,
 /**
  * Same as ures_openDirect(), but uses the fill-in parameter and does not allocate a new bundle.
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 ures_openDirectFillIn(UResourceBundle *r, const char* path, const char* localeID, UErrorCode* status) {
     if(U_SUCCESS(*status) && r == NULL) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
@@ -2420,7 +2431,7 @@ ures_countArrayItems(const UResourceBundle* resourceBundle,
  * @see ures_getVersion
  * @internal
  */
-U_INTERNAL const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 ures_getVersionNumberInternal(const UResourceBundle *resourceBundle)
 {
     if (!resourceBundle) return NULL;
@@ -3016,10 +3027,10 @@ ures_getKeywordValues(const char *path, const char *keyword, UErrorCode *status)
 }
 #if 0
 /* This code isn't needed, and given the documentation warnings the implementation is suspect */
-U_INTERNAL UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ures_equal(const UResourceBundle* res1, const UResourceBundle* res2){
     if(res1==NULL || res2==NULL){
-        return res1==res2; /* pointer comparision */
+        return res1==res2; /* pointer comparison */
     }
     if(res1->fKey==NULL||  res2->fKey==NULL){
         return (res1->fKey==res2->fKey);
@@ -3052,7 +3063,7 @@ ures_equal(const UResourceBundle* res1, const UResourceBundle* res2){
     }
     return TRUE;
 }
-U_INTERNAL UResourceBundle* U_EXPORT2
+U_CAPI UResourceBundle* U_EXPORT2
 ures_clone(const UResourceBundle* res, UErrorCode* status){
     UResourceBundle* bundle = NULL;
     UResourceBundle* ret = NULL;
@@ -3068,7 +3079,7 @@ ures_clone(const UResourceBundle* res, UErrorCode* status){
     }
     return ret;
 }
-U_INTERNAL const UResourceBundle* U_EXPORT2
+U_CAPI const UResourceBundle* U_EXPORT2
 ures_getParentBundle(const UResourceBundle* res){
     if(res==NULL){
         return NULL;
@@ -3077,7 +3088,7 @@ ures_getParentBundle(const UResourceBundle* res){
 }
 #endif
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 ures_getVersionByKey(const UResourceBundle* res, const char *key, UVersionInfo ver, UErrorCode *status) {
   const UChar *str;
   int32_t len;
diff --git a/deps/icu-small/source/common/uresdata.cpp b/deps/icu-small/source/common/uresdata.cpp
index 1bb938be62c35bfeb03de29a5570dbc5d0f8b61b..26a2fd91a6fdbdc9e3cf95f4949066bbcc9cba9d 100644
--- a/deps/icu-small/source/common/uresdata.cpp
+++ b/deps/icu-small/source/common/uresdata.cpp
@@ -960,14 +960,6 @@ res_findResource(const ResourceData *pResData, Resource r, char** path, const ch
     if(URES_IS_TABLE(type)) {
       *key = pathP;
       t2 = res_getTableItemByKey(pResData, t1, &indexR, key);
-      if(t2 == RES_BOGUS) {
-        /* if we fail to get the resource by key, maybe we got an index */
-        indexR = uprv_strtol(pathP, &closeIndex, 10);
-        if(indexR >= 0 && *closeIndex == 0) {
-          /* if we indeed have an index, try to get the item by index */
-          t2 = res_getTableItemByIndex(pResData, t1, indexR, key);
-        } // else t2 is already RES_BOGUS
-      }
     } else if(URES_IS_ARRAY(type)) {
       indexR = uprv_strtol(pathP, &closeIndex, 10);
       if(indexR >= 0 && *closeIndex == 0) {
diff --git a/deps/icu-small/source/common/uresdata.h b/deps/icu-small/source/common/uresdata.h
index d1b67babf29049c523f77f8d2bec00ef24799a4e..7c2152e57b500d5329d9cc1c65c8571e7f47bd55 100644
--- a/deps/icu-small/source/common/uresdata.h
+++ b/deps/icu-small/source/common/uresdata.h
@@ -402,7 +402,7 @@ typedef struct ResourceData {
 /*
  * Read a resource bundle from memory.
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 res_read(ResourceData *pResData,
          const UDataInfo *pInfo, const void *inBytes, int32_t length,
          UErrorCode *errorCode);
@@ -422,7 +422,7 @@ res_load(ResourceData *pResData,
 U_CFUNC void
 res_unload(ResourceData *pResData);
 
-U_INTERNAL UResType U_EXPORT2
+U_CAPI UResType U_EXPORT2
 res_getPublicType(Resource res);
 
 ///////////////////////////////////////////////////////////////////////////
@@ -434,31 +434,31 @@ res_getPublicType(Resource res);
  * and set its length in *pLength.
  * Returns NULL if not found.
  */
-U_INTERNAL const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 res_getStringNoTrace(const ResourceData *pResData, Resource res, int32_t *pLength);
 
-U_INTERNAL const uint8_t * U_EXPORT2
+U_CAPI const uint8_t * U_EXPORT2
 res_getBinaryNoTrace(const ResourceData *pResData, Resource res, int32_t *pLength);
 
-U_INTERNAL const int32_t * U_EXPORT2
+U_CAPI const int32_t * U_EXPORT2
 res_getIntVectorNoTrace(const ResourceData *pResData, Resource res, int32_t *pLength);
 
-U_INTERNAL const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 res_getAlias(const ResourceData *pResData, Resource res, int32_t *pLength);
 
-U_INTERNAL Resource U_EXPORT2
+U_CAPI Resource U_EXPORT2
 res_getResource(const ResourceData *pResData, const char *key);
 
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 res_countArrayItems(const ResourceData *pResData, Resource res);
 
-U_INTERNAL Resource U_EXPORT2
+U_CAPI Resource U_EXPORT2
 res_getArrayItem(const ResourceData *pResData, Resource array, int32_t indexS);
 
-U_INTERNAL Resource U_EXPORT2
+U_CAPI Resource U_EXPORT2
 res_getTableItemByIndex(const ResourceData *pResData, Resource table, int32_t indexS, const char ** key);
 
-U_INTERNAL Resource U_EXPORT2
+U_CAPI Resource U_EXPORT2
 res_getTableItemByKey(const ResourceData *pResData, Resource table, int32_t *indexS, const char* * key);
 
 /**
diff --git a/deps/icu-small/source/common/uresimp.h b/deps/icu-small/source/common/uresimp.h
index 2e477dfad3e98f789704415c0011d1c442ab384a..cfd15a2dde10e22864c6a78ca46e329adb03bcee 100644
--- a/deps/icu-small/source/common/uresimp.h
+++ b/deps/icu-small/source/common/uresimp.h
@@ -157,7 +157,7 @@ U_CFUNC const char* ures_getName(const UResourceBundle* resB);
 U_CFUNC const char* ures_getPath(const UResourceBundle* resB);
 /**
  * If anything was in the RB cache, dump it to the screen.
- * @return TRUE if there was anything into the cache
+ * @return true if there was anything into the cache
  */
 U_CAPI UBool U_EXPORT2 ures_dumpCacheContents(void);
 #endif
@@ -218,7 +218,7 @@ ures_findSubResource(const UResourceBundle *resB,
  * @param isAvailable If non-null, pointer to fillin parameter that indicates whether the
  * requested locale was available. The locale is defined as 'available' if it physically
  * exists within the specified tree.
- * @param omitDefault if TRUE, omit keyword and value if default. 'de_DE\@collation=standard' -> 'de_DE'
+ * @param omitDefault if true, omit keyword and value if default. 'de_DE\@collation=standard' -> 'de_DE'
  * @param status error code
  * @return  the actual buffer size needed for the full locale.  If it's greater
  * than resultCapacity, the returned full name will be truncated and an error code will be returned.
@@ -270,11 +270,13 @@ ures_getByKeyWithFallback(const UResourceBundle *resB,
  * function can perform fallback on the sub-resources of the table.
  * @param resB              a resource
  * @param inKey             a key associated with the requested resource
+ * @param len               if not NULL, used to return the length of the string
  * @param status: fills in the outgoing error code
  *                could be <TT>U_MISSING_RESOURCE_ERROR</TT> if the key is not found
  *                could be a non-failing error
  *                e.g.: <TT>U_USING_FALLBACK_WARNING</TT>,<TT>U_USING_DEFAULT_WARNING </TT>
- * @return                  a pointer to a UResourceBundle struct. If fill in param was NULL, caller must delete it
+ * @return returns a pointer to a zero-terminated UChar array which lives in a
+ *         memory mapped/DLL file.
  */
 U_CAPI const UChar* U_EXPORT2
 ures_getStringByKeyWithFallback(const UResourceBundle *resB,
diff --git a/deps/icu-small/source/common/uset.cpp b/deps/icu-small/source/common/uset.cpp
index 265a300b19060c75a3fd3342a5657ca7ebf02fd7..ca7e80b082cb36b58d1ac7ddd38deba544066bf5 100644
--- a/deps/icu-small/source/common/uset.cpp
+++ b/deps/icu-small/source/common/uset.cpp
@@ -116,6 +116,12 @@ uset_removeString(USet* set, const UChar* str, int32_t strLen) {
     ((UnicodeSet*) set)->UnicodeSet::remove(s);
 }
 
+U_CAPI void U_EXPORT2
+uset_removeAllCodePoints(USet *set, const UChar *str, int32_t length) {
+    UnicodeString s(length==-1, str, length);
+    ((UnicodeSet*) set)->UnicodeSet::removeAll(s);
+}
+
 U_CAPI void U_EXPORT2
 uset_removeAll(USet* set, const USet* remove) {
     ((UnicodeSet*) set)->UnicodeSet::removeAll(*(const UnicodeSet*)remove);
@@ -126,6 +132,18 @@ uset_retain(USet* set, UChar32 start, UChar32 end) {
     ((UnicodeSet*) set)->UnicodeSet::retain(start, end);
 }
 
+U_CAPI void U_EXPORT2
+uset_retainString(USet *set, const UChar *str, int32_t length) {
+    UnicodeString s(length==-1, str, length);
+    ((UnicodeSet*) set)->UnicodeSet::retain(s);
+}
+
+U_CAPI void U_EXPORT2
+uset_retainAllCodePoints(USet *set, const UChar *str, int32_t length) {
+    UnicodeString s(length==-1, str, length);
+    ((UnicodeSet*) set)->UnicodeSet::retainAll(s);
+}
+
 U_CAPI void U_EXPORT2
 uset_retainAll(USet* set, const USet* retain) {
     ((UnicodeSet*) set)->UnicodeSet::retainAll(*(const UnicodeSet*)retain);
@@ -141,6 +159,23 @@ uset_complement(USet* set) {
     ((UnicodeSet*) set)->UnicodeSet::complement();
 }
 
+U_CAPI void U_EXPORT2
+uset_complementRange(USet *set, UChar32 start, UChar32 end) {
+    ((UnicodeSet*) set)->UnicodeSet::complement(start, end);
+}
+
+U_CAPI void U_EXPORT2
+uset_complementString(USet *set, const UChar *str, int32_t length) {
+    UnicodeString s(length==-1, str, length);
+    ((UnicodeSet*) set)->UnicodeSet::complement(s);
+}
+
+U_CAPI void U_EXPORT2
+uset_complementAllCodePoints(USet *set, const UChar *str, int32_t length) {
+    UnicodeString s(length==-1, str, length);
+    ((UnicodeSet*) set)->UnicodeSet::complementAll(s);
+}
+
 U_CAPI void U_EXPORT2
 uset_complementAll(USet* set, const USet* complement) {
     ((UnicodeSet*) set)->UnicodeSet::complementAll(*(const UnicodeSet*)complement);
diff --git a/deps/icu-small/source/common/usprep.cpp b/deps/icu-small/source/common/usprep.cpp
index f1c075a391116f1897ec73188b80178093c61289..b84a5d93ea49873100fa86cf3b3c2ed65e6f6400 100644
--- a/deps/icu-small/source/common/usprep.cpp
+++ b/deps/icu-small/source/common/usprep.cpp
@@ -575,7 +575,7 @@ usprep_map(  const UStringPrepProfile* profile,
             }
 
         }else if(type==USPREP_DELETE){
-             // just consume the codepoint and contine
+             // just consume the codepoint and continue
             continue;
         }
         //copy the code point into destination
diff --git a/deps/icu-small/source/common/ustr_imp.h b/deps/icu-small/source/common/ustr_imp.h
index 85d8e6d8ee69709491944e316d3033a70f578c2d..5b249ade3d21bb5fe212d8ac0fb6c8863700a83c 100644
--- a/deps/icu-small/source/common/ustr_imp.h
+++ b/deps/icu-small/source/common/ustr_imp.h
@@ -29,7 +29,7 @@
 /**
  * Compare two strings in code point order or code unit order.
  * Works in strcmp style (both lengths -1),
- * strncmp style (lengths equal and >=0, flag TRUE),
+ * strncmp style (lengths equal and >=0, flag true),
  * and memcmp/UnicodeString style (at least one length >=0).
  */
 U_CFUNC int32_t U_EXPORT2
@@ -37,13 +37,13 @@ uprv_strCompare(const UChar *s1, int32_t length1,
                 const UChar *s2, int32_t length2,
                 UBool strncmpStyle, UBool codePointOrder);
 
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ustr_hashUCharsN(const UChar *str, int32_t length);
 
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ustr_hashCharsN(const char *str, int32_t length);
 
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ustr_hashICharsN(const char *str, int32_t length);
 
 /**
@@ -53,7 +53,7 @@ ustr_hashICharsN(const char *str, int32_t length);
  * @return If UChar is a lowercase ASCII character, returns the uppercase version.
  *         Otherwise, returns the input character.
  */
-U_INTERNAL UChar U_EXPORT2
+U_CAPI UChar U_EXPORT2
 u_asciiToUpper(UChar c);
 
 // TODO: Add u_asciiToLower if/when there is a need for it.
@@ -70,28 +70,28 @@ u_asciiToUpper(UChar c);
  * @param pErrorCode ICU error code.
  * @return length
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_terminateUChars(UChar *dest, int32_t destCapacity, int32_t length, UErrorCode *pErrorCode);
 
 /**
  * NUL-terminate a char * string if possible.
  * Same as u_terminateUChars() but for a different string type.
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_terminateChars(char *dest, int32_t destCapacity, int32_t length, UErrorCode *pErrorCode);
 
 /**
  * NUL-terminate a UChar32 * string if possible.
  * Same as u_terminateUChars() but for a different string type.
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_terminateUChar32s(UChar32 *dest, int32_t destCapacity, int32_t length, UErrorCode *pErrorCode);
 
 /**
  * NUL-terminate a wchar_t * string if possible.
  * Same as u_terminateUChars() but for a different string type.
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_terminateWChars(wchar_t *dest, int32_t destCapacity, int32_t length, UErrorCode *pErrorCode);
 
 /**
@@ -133,7 +133,7 @@ public:
      * @param t The i-th byte following the lead byte.
      * @param i The index (1..3) of byte t in the byte sequence. 0<i<length
      * @param length The length (2..4) of the byte sequence according to the lead byte.
-     * @return TRUE if t is a valid trail byte in this context.
+     * @return true if t is a valid trail byte in this context.
      */
     static inline UBool isValidTrail(int32_t prev, uint8_t t, int32_t i, int32_t length) {
         // The first trail byte after a 3- or 4-byte lead byte
diff --git a/deps/icu-small/source/common/ustr_wcs.cpp b/deps/icu-small/source/common/ustr_wcs.cpp
index 0372824f21f61596ec743acc5ced1c1fae3be651..9a49a67744b6f9e2e3eb48db4e8ef946a46726f4 100644
--- a/deps/icu-small/source/common/ustr_wcs.cpp
+++ b/deps/icu-small/source/common/ustr_wcs.cpp
@@ -364,7 +364,7 @@ _strFromWCS( UChar   *dest,
                 }
 
                 /* we have found a null  so convert the
-                 * chunk from begining of non-null char to null
+                 * chunk from beginning of non-null char to null
                  */
                 retVal = uprv_wcstombs(pCSrc,pSrc,remaining);
 
@@ -387,7 +387,7 @@ _strFromWCS( UChar   *dest,
                  * null terminate it and convert wchar_ts to chars
                  */
                 if(nulLen >= _STACK_BUFFER_CAPACITY){
-                    /* Should rarely occcur */
+                    /* Should rarely occur */
                     /* allocate new buffer buffer */
                     pWStack =(wchar_t*) uprv_malloc(sizeof(wchar_t) * (nulLen + 1));
                     if(pWStack==NULL){
diff --git a/deps/icu-small/source/common/ustring.cpp b/deps/icu-small/source/common/ustring.cpp
index 375f66add448354b2d596f71026569b14e226d07..8a6f737dc25202e2d4a991b37f269a3ffb20a585 100644
--- a/deps/icu-small/source/common/ustring.cpp
+++ b/deps/icu-small/source/common/ustring.cpp
@@ -45,7 +45,7 @@ isMatchAtCPBoundary(const UChar *start, const UChar *match, const UChar *matchLi
         /* the leading edge of the match is in the middle of a surrogate pair */
         return FALSE;
     }
-    if(U16_IS_LEAD(*(matchLimit-1)) && match!=limit && U16_IS_TRAIL(*matchLimit)) {
+    if(U16_IS_LEAD(*(matchLimit-1)) && matchLimit!=limit && U16_IS_TRAIL(*matchLimit)) {
         /* the trailing edge of the match is in the middle of a surrogate pair */
         return FALSE;
     }
@@ -1294,7 +1294,15 @@ u_unescapeAt(UNESCAPE_CHAR_AT charAt,
             int32_t ahead = *offset + 1;
             c = charAt(*offset, context);
             if (c == 0x5C /*'\\'*/ && ahead < length) {
-                c = (UChar) u_unescapeAt(charAt, &ahead, length, context);
+                // Calling u_unescapeAt recursively may cause a stack overflow if
+                // we have repeated surrogate lead after that. Limit the
+                // length to 5 ('u' and 4 hex) after ahead.
+                int32_t tailLimit = ahead + 5;
+                if (tailLimit > length) {
+                    tailLimit = length;
+                }
+                c = (UChar) u_unescapeAt(charAt, &ahead, tailLimit,
+                                         context);
             }
             if (U16_IS_TRAIL(c)) {
                 *offset = ahead;
diff --git a/deps/icu-small/source/common/utext.cpp b/deps/icu-small/source/common/utext.cpp
index ac828fbefa81bbb210c07b459173fca37e7b66f0..0dfef36d264176f5fdfc77705b9b64e53a86d8e7 100644
--- a/deps/icu-small/source/common/utext.cpp
+++ b/deps/icu-small/source/common/utext.cpp
@@ -382,7 +382,7 @@ utext_previous32From(UText *ut, int64_t index) {
     //
     UChar32     cPrev;    // The character preceding cCurr, which is what we will return.
 
-    // Address the chunk containg the position preceding the incoming index
+    // Address the chunk containing the position preceding the incoming index
     // A tricky edge case:
     //   We try to test the requested native index against the chunkNativeStart to determine
     //    whether the character preceding the one at the index is in the current chunk.
@@ -894,7 +894,7 @@ struct UTF8Buf {
                                                      //    one for a supplementary starting in the last normal position,
                                                      //    and one for an entry for the buffer limit position.
     uint8_t   mapToUChars[UTF8_TEXT_CHUNK_SIZE*3+6]; // Map native offset from bufNativeStart to
-                                                     //   correspoding offset in filled part of buf.
+                                                     //   corresponding offset in filled part of buf.
     int32_t   align;
 };
 
@@ -1545,7 +1545,7 @@ utf8TextMapOffsetToNative(const UText *ut) {
 }
 
 //
-// Map a native index to the corrsponding chunk offset
+// Map a native index to the corresponding chunk offset
 //
 static int32_t U_CALLCONV
 utf8TextMapIndexToUTF16(const UText *ut, int64_t index64) {
diff --git a/deps/icu-small/source/common/util.h b/deps/icu-small/source/common/util.h
index a2be25056e9acbe52e8536edc2cae3c3ffd42315..74fdd75982cc5a13dbd8188ad3bd2b86b950207e 100644
--- a/deps/icu-small/source/common/util.h
+++ b/deps/icu-small/source/common/util.h
@@ -13,10 +13,10 @@
 #ifndef ICU_UTIL_H
 #define ICU_UTIL_H
 
-#include "unicode/utypes.h"
-#include "unicode/uobject.h"
+#include "charstr.h"
 #include "unicode/unistr.h"
-
+#include "unicode/uobject.h"
+#include "unicode/utypes.h"
 //--------------------------------------------------------------------
 // class ICU_Utility
 // i18n utility functions, scoped into the class ICU_Utility.
@@ -64,8 +64,8 @@ class U_COMMON_API ICU_Utility /* not : public UObject because all methods are s
     /**
      * Escape unprintable characters using \uxxxx notation for U+0000 to
      * U+FFFF and \Uxxxxxxxx for U+10000 and above.  If the character is
-     * printable ASCII, then do nothing and return FALSE.  Otherwise,
-     * append the escaped notation and return TRUE.
+     * printable ASCII, then do nothing and return false.  Otherwise,
+     * append the escaped notation and return true.
      */
     static UBool escapeUnprintable(UnicodeString& result, UChar32 c);
 
@@ -95,7 +95,7 @@ class U_COMMON_API ICU_Utility /* not : public UObject because all methods are s
      * after pos, or str.length(), if there is none.
      */
     static int32_t skipWhitespace(const UnicodeString& str, int32_t& pos,
-                                  UBool advance = FALSE);
+                                  UBool advance = false);
 
     /**
      * Skip over Pattern_White_Space in a Replaceable.
diff --git a/deps/icu-small/source/common/utracimp.h b/deps/icu-small/source/common/utracimp.h
index 84e7031da8bc17c748ae9a096af5547a598b452f..42e92749d65f02860f59279f7486f7c04cdbb890 100644
--- a/deps/icu-small/source/common/utracimp.h
+++ b/deps/icu-small/source/common/utracimp.h
@@ -193,7 +193,7 @@ UPRV_BLOCK_MACRO_BEGIN { \
  * Trace statement for each exit point of a function that has a UTRACE_ENTRY()
  * statement, and that returns a value.
  *
- * @param val       The function's return value, int32_t or comatible type.
+ * @param val       The function's return value, int32_t or compatible type.
  *
  * @internal
  */
diff --git a/deps/icu-small/source/common/utrie.h b/deps/icu-small/source/common/utrie.h
index 532ba778eb6ed143d7c23965ef9fd7a0ba016544..2fd2c461ffb250c9b52d70a1edf543b518fe1ad2 100644
--- a/deps/icu-small/source/common/utrie.h
+++ b/deps/icu-small/source/common/utrie.h
@@ -460,13 +460,13 @@ UTrieEnumValue(const void *context, uint32_t value);
  * of code points with the same value as retrieved from the trie and
  * transformed by the UTrieEnumValue function.
  *
- * The callback function can stop the enumeration by returning FALSE.
+ * The callback function can stop the enumeration by returning false.
  *
  * @param context an opaque pointer, as passed into utrie_enum()
  * @param start the first code point in a contiguous range with value
  * @param limit one past the last code point in a contiguous range with value
  * @param value the value that is set for all code points in [start..limit[
- * @return FALSE to stop the enumeration
+ * @return false to stop the enumeration
  */
 typedef UBool U_CALLCONV
 UTrieEnumRange(const void *context, UChar32 start, UChar32 limit, uint32_t value);
@@ -667,7 +667,7 @@ utrie_getData(UNewTrie *trie, int32_t *pLength);
  * @param trie the build-time trie
  * @param c the code point
  * @param value the value
- * @return FALSE if a failure occurred (illegal argument or data array overrun)
+ * @return false if a failure occurred (illegal argument or data array overrun)
  */
 U_CAPI UBool U_EXPORT2
 utrie_set32(UNewTrie *trie, UChar32 c, uint32_t value);
@@ -677,7 +677,7 @@ utrie_set32(UNewTrie *trie, UChar32 c, uint32_t value);
  *
  * @param trie the build-time trie
  * @param c the code point
- * @param pInBlockZero if not NULL, then *pInBlockZero is set to TRUE
+ * @param pInBlockZero if not NULL, then *pInBlockZero is set to true
  *                     iff the value is retrieved from block 0;
  *                     block 0 is the all-initial-value initial block
  * @return the value
@@ -688,14 +688,14 @@ utrie_get32(UNewTrie *trie, UChar32 c, UBool *pInBlockZero);
 /**
  * Set a value in a range of code points [start..limit[.
  * All code points c with start<=c<limit will get the value if
- * overwrite is TRUE or if the old value is 0.
+ * overwrite is true or if the old value is 0.
  *
  * @param trie the build-time trie
  * @param start the first code point to get the value
  * @param limit one past the last code point to get the value
  * @param value the value
  * @param overwrite flag for whether old non-initial values are to be overwritten
- * @return FALSE if a failure occurred (illegal argument or data array overrun)
+ * @return false if a failure occurred (illegal argument or data array overrun)
  */
 U_CAPI UBool U_EXPORT2
 utrie_setRange32(UNewTrie *trie, UChar32 start, UChar32 limit, uint32_t value, UBool overwrite);
diff --git a/deps/icu-small/source/common/utrie2.h b/deps/icu-small/source/common/utrie2.h
index 671f44e16a65cc561b794741ddb1c6544e775bee..d1e1e15a6e0ca81787755f8d5e98b45974c90721 100644
--- a/deps/icu-small/source/common/utrie2.h
+++ b/deps/icu-small/source/common/utrie2.h
@@ -161,13 +161,13 @@ UTrie2EnumValue(const void *context, uint32_t value);
  * of code points with the same value as retrieved from the trie and
  * transformed by the UTrie2EnumValue function.
  *
- * The callback function can stop the enumeration by returning FALSE.
+ * The callback function can stop the enumeration by returning false.
  *
  * @param context an opaque pointer, as passed into utrie2_enum()
  * @param start the first code point in a contiguous range with value
  * @param end the last code point in a contiguous range with value (inclusive)
  * @param value the value that is set for all code points in [start..end]
- * @return FALSE to stop the enumeration
+ * @return false to stop the enumeration
  */
 typedef UBool U_CALLCONV
 UTrie2EnumRange(const void *context, UChar32 start, UChar32 end, uint32_t value);
@@ -256,7 +256,7 @@ utrie2_set32(UTrie2 *trie, UChar32 c, uint32_t value, UErrorCode *pErrorCode);
 /**
  * Set a value in a range of code points [start..end].
  * All code points c with start<=c<=end will get the value if
- * overwrite is TRUE or if the old value is the initial value.
+ * overwrite is true or if the old value is the initial value.
  *
  * @param trie the unfrozen trie
  * @param start the first code point to get the value
@@ -298,7 +298,7 @@ utrie2_freeze(UTrie2 *trie, UTrie2ValueBits valueBits, UErrorCode *pErrorCode);
  * Test if the trie is frozen. (See utrie2_freeze().)
  *
  * @param trie the trie
- * @return TRUE if the trie is frozen, that is, immutable, ready for serialization
+ * @return true if the trie is frozen, that is, immutable, ready for serialization
  *         and for use with fast macros
  */
 U_CAPI UBool U_EXPORT2
@@ -670,7 +670,7 @@ struct UTrie2 {
     /* private: used by builder and unserialization functions */
     void *memory;           /* serialized bytes; NULL if not frozen yet */
     int32_t length;         /* number of serialized bytes at memory; 0 if not frozen yet */
-    UBool isMemoryOwned;    /* TRUE if the trie owns the memory */
+    UBool isMemoryOwned;    /* true if the trie owns the memory */
     UBool padding1;
     int16_t padding2;
     UNewTrie2 *newTrie;     /* builder object; NULL when frozen */
@@ -796,7 +796,7 @@ enum {
  * Do not call directly.
  * @internal
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utrie2_internalU8NextIndex(const UTrie2 *trie, UChar32 c,
                            const uint8_t *src, const uint8_t *limit);
 
@@ -805,7 +805,7 @@ utrie2_internalU8NextIndex(const UTrie2 *trie, UChar32 c,
  * Do not call directly.
  * @internal
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utrie2_internalU8PrevIndex(const UTrie2 *trie, UChar32 c,
                            const uint8_t *start, const uint8_t *src);
 
diff --git a/deps/icu-small/source/common/utrie_swap.cpp b/deps/icu-small/source/common/utrie_swap.cpp
index 5abe7bd5d77e14731d4420401b7302ecdaa5245d..6e8b1383945678170bf7f001f0b48c912819a217 100644
--- a/deps/icu-small/source/common/utrie_swap.cpp
+++ b/deps/icu-small/source/common/utrie_swap.cpp
@@ -256,20 +256,24 @@ ucptrie_swap(const UDataSwapper *ds,
         ds->swapArray32(ds, &inTrie->signature, 4, &outTrie->signature, pErrorCode);
         ds->swapArray16(ds, &inTrie->options, 12, &outTrie->options, pErrorCode);
 
-        /* swap the index and the data */
+        /* swap the index */
+        const uint16_t *inIndex=reinterpret_cast<const uint16_t *>(inTrie+1);
+        uint16_t *outIndex=reinterpret_cast<uint16_t *>(outTrie+1);
+        ds->swapArray16(ds, inIndex, trie.indexLength*2, outIndex, pErrorCode);
+
+        /* swap the data */
+        const uint16_t *inData=inIndex+trie.indexLength;
+        uint16_t *outData=outIndex+trie.indexLength;
         switch(valueWidth) {
         case UCPTRIE_VALUE_BITS_16:
-            ds->swapArray16(ds, inTrie+1, (trie.indexLength+dataLength)*2, outTrie+1, pErrorCode);
+            ds->swapArray16(ds, inData, dataLength*2, outData, pErrorCode);
             break;
         case UCPTRIE_VALUE_BITS_32:
-            ds->swapArray16(ds, inTrie+1, trie.indexLength*2, outTrie+1, pErrorCode);
-            ds->swapArray32(ds, (const uint16_t *)(inTrie+1)+trie.indexLength, dataLength*4,
-                                     (uint16_t *)(outTrie+1)+trie.indexLength, pErrorCode);
+            ds->swapArray32(ds, inData, dataLength*4, outData, pErrorCode);
             break;
         case UCPTRIE_VALUE_BITS_8:
-            ds->swapArray16(ds, inTrie+1, trie.indexLength*2, outTrie+1, pErrorCode);
             if(inTrie!=outTrie) {
-                uprv_memmove((outTrie+1)+trie.indexLength, (inTrie+1)+trie.indexLength, dataLength);
+                uprv_memmove(outData, inData, dataLength);
             }
             break;
         default:
diff --git a/deps/icu-small/source/common/uts46.cpp b/deps/icu-small/source/common/uts46.cpp
index b9e6cb023bb379964838caf16ff2285c54cfdbf1..f25b4e12f124ca248446c3c5b3d7891dd8aea1eb 100644
--- a/deps/icu-small/source/common/uts46.cpp
+++ b/deps/icu-small/source/common/uts46.cpp
@@ -714,6 +714,16 @@ UTS46::processLabel(UnicodeString &dest,
     UBool wasPunycode;
     if(labelLength>=4 && label[0]==0x78 && label[1]==0x6e && label[2]==0x2d && label[3]==0x2d) {
         // Label starts with "xn--", try to un-Punycode it.
+        // In IDNA2008, labels like "xn--" (decodes to an empty string) and
+        // "xn--ASCII-" (decodes to just "ASCII") fail the round-trip validation from
+        // comparing the ToUnicode input with the back-to-ToASCII output.
+        // They are alternate encodings of the respective ASCII labels.
+        // Ignore "xn---" here: It will fail Punycode.decode() which logically comes before
+        // the round-trip verification.
+        if(labelLength==4 || (labelLength>5 && label[labelLength-1]==u'-')) {
+            info.labelErrors|=UIDNA_ERROR_INVALID_ACE_LABEL;
+            return markBadACELabel(dest, labelStart, labelLength, toASCII, info, errorCode);
+        }
         wasPunycode=TRUE;
         UChar *unicodeBuffer=fromPunycode.getBuffer(-1);  // capacity==-1: most labels should fit
         if(unicodeBuffer==NULL) {
@@ -925,10 +935,10 @@ UTS46::markBadACELabel(UnicodeString &dest,
     UBool isASCII=TRUE;
     UBool onlyLDH=TRUE;
     const UChar *label=dest.getBuffer()+labelStart;
-    // Ok to cast away const because we own the UnicodeString.
-    UChar *s=(UChar *)label+4;  // After the initial "xn--".
     const UChar *limit=label+labelLength;
-    do {
+    // Start after the initial "xn--".
+    // Ok to cast away const because we own the UnicodeString.
+    for(UChar *s=const_cast<UChar *>(label+4); s<limit; ++s) {
         UChar c=*s;
         if(c<=0x7f) {
             if(c==0x2e) {
@@ -945,7 +955,7 @@ UTS46::markBadACELabel(UnicodeString &dest,
         } else {
             isASCII=onlyLDH=FALSE;
         }
-    } while(++s<limit);
+    }
     if(onlyLDH) {
         dest.insert(labelStart+labelLength, (UChar)0xfffd);
         if(dest.isBogus()) {
diff --git a/deps/icu-small/source/common/utypes.cpp b/deps/icu-small/source/common/utypes.cpp
index 7531e465683342739164ff1164d2326417ed899d..63e05b1249b6ff5fe16823c2baeba038518d1776 100644
--- a/deps/icu-small/source/common/utypes.cpp
+++ b/deps/icu-small/source/common/utypes.cpp
@@ -104,7 +104,8 @@ _uErrorName[U_STANDARD_ERROR_LIMIT]={
     "U_INVALID_STATE_ERROR",
     "U_COLLATOR_VERSION_MISMATCH",
     "U_USELESS_COLLATOR_ERROR",
-    "U_NO_WRITE_PERMISSION"
+    "U_NO_WRITE_PERMISSION",
+    "U_INPUT_TOO_LONG_ERROR"
 };
 static const char * const
 _uFmtErrorName[U_FMT_PARSE_ERROR_LIMIT - U_FMT_PARSE_ERROR_START] = {
diff --git a/deps/icu-small/source/common/uvector.cpp b/deps/icu-small/source/common/uvector.cpp
index ad3a813e3706aca74587918bfb3839dad58f6c32..39a92e07c01911d8be35f8ada9de4b85d3f34f9d 100644
--- a/deps/icu-small/source/common/uvector.cpp
+++ b/deps/icu-small/source/common/uvector.cpp
@@ -312,7 +312,7 @@ int32_t UVector::indexOf(UElement key, int32_t startIndex, int8_t hint) const {
     } else {
         for (i=startIndex; i<count; ++i) {
             /* Pointers are not always the same size as ints so to perform
-             * a valid comparision we need to know whether we are being
+             * a valid comparison we need to know whether we are being
              * provided an int or a pointer. */
             if (hint & HINT_KEY_POINTER) {
                 if (key.pointer == elements[i].pointer) {
@@ -518,7 +518,7 @@ sortiComparator(const void * /*context */, const void *left, const void *right)
 }
 
 /**
-  * Sort the vector, assuming it constains ints.
+  * Sort the vector, assuming it contains ints.
   *     (A more general sort would take a comparison function, but it's
   *     not clear whether UVector's UElementComparator or
   *     UComparator from uprv_sortAray would be more appropriate.)
diff --git a/deps/icu-small/source/common/uvector.h b/deps/icu-small/source/common/uvector.h
index a7625cd01ac59a8c265da7f518cdf081039acf48..34f3434a9740125d225fc460d9412c05fb07fe64 100644
--- a/deps/icu-small/source/common/uvector.h
+++ b/deps/icu-small/source/common/uvector.h
@@ -64,7 +64,7 @@ U_NAMESPACE_BEGIN
  * uses a comparison function, or "comparer."  If the comparer is not
  * set, or is set to zero, then all such methods will act as if the
  * vector contains no element.  That is, indexOf() will always return
- * -1, contains() will always return FALSE, etc.
+ * -1, contains() will always return false, etc.
  *
  * <p><b>To do</b>
  *
diff --git a/deps/icu-small/source/common/uvectr32.h b/deps/icu-small/source/common/uvectr32.h
index 91a2dd2009eecb99f0963b101888f92ca2b7e630..92746a4f4782d82f627685e6fb2fbe8de411f8a4 100644
--- a/deps/icu-small/source/common/uvectr32.h
+++ b/deps/icu-small/source/common/uvectr32.h
@@ -214,7 +214,7 @@ public:
 
 inline UBool UVector32::ensureCapacity(int32_t minimumCapacity, UErrorCode &status) {
     if ((minimumCapacity >= 0) && (capacity >= minimumCapacity)) {
-        return TRUE;
+        return true;
     } else {
         return expandCapacity(minimumCapacity, status);
     }
@@ -233,7 +233,7 @@ inline void UVector32::addElement(int32_t elem, UErrorCode &status) {
 }
 
 inline int32_t *UVector32::reserveBlock(int32_t size, UErrorCode &status) {
-    if (ensureCapacity(count+size, status) == FALSE) {
+    if (ensureCapacity(count+size, status) == false) {
         return NULL;
     }
     int32_t  *rp = elements+count;
diff --git a/deps/icu-small/source/common/uvectr64.h b/deps/icu-small/source/common/uvectr64.h
index 6d26863eabc00df1938d2116eaf144b2d527180a..4dab16396c1d13825a5f336599b525b4c95d7f99 100644
--- a/deps/icu-small/source/common/uvectr64.h
+++ b/deps/icu-small/source/common/uvectr64.h
@@ -203,7 +203,7 @@ public:
 
 inline UBool UVector64::ensureCapacity(int32_t minimumCapacity, UErrorCode &status) {
     if ((minimumCapacity >= 0) && (capacity >= minimumCapacity)) {
-        return TRUE;
+        return true;
     } else {
         return expandCapacity(minimumCapacity, status);
     }
@@ -222,7 +222,7 @@ inline void UVector64::addElement(int64_t elem, UErrorCode &status) {
 }
 
 inline int64_t *UVector64::reserveBlock(int32_t size, UErrorCode &status) {
-    if (ensureCapacity(count+size, status) == FALSE) {
+    if (ensureCapacity(count+size, status) == false) {
         return NULL;
     }
     int64_t  *rp = elements+count;
diff --git a/deps/icu-small/source/common/wintz.cpp b/deps/icu-small/source/common/wintz.cpp
index 115512e704cced660041aab623dfe2d5481738a4..fa689678b1ec47ab02945ba844eda0d9b2ab7562 100644
--- a/deps/icu-small/source/common/wintz.cpp
+++ b/deps/icu-small/source/common/wintz.cpp
@@ -16,11 +16,12 @@
 #if U_PLATFORM_USES_ONLY_WIN32_API
 
 #include "wintz.h"
+#include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
 
 #include "unicode/ures.h"
-#include "unicode/ustring.h"
+#include "unicode/unistr.h"
 #include "uresimp.h"
 
 #ifndef WIN32_LEAN_AND_MEAN
@@ -35,89 +36,295 @@
 
 U_NAMESPACE_BEGIN
 
-// The max size of TimeZoneKeyName is 128, defined in DYNAMIC_TIME_ZONE_INFORMATION
-#define MAX_TIMEZONE_ID_LENGTH 128
+// Note these constants and the struct are only used when dealing with the fallback path for RDP sesssions.
+
+// This is the location of the time zones in the registry on Vista+ systems.
+// See: https://docs.microsoft.com/windows/win32/api/timezoneapi/ns-timezoneapi-dynamic_time_zone_information
+#define WINDOWS_TIMEZONES_REG_KEY_PATH L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones"
+
+// Max length for a registry key is 255. +1 for null.
+// See: https://docs.microsoft.com/windows/win32/sysinfo/registry-element-size-limits
+#define WINDOWS_MAX_REG_KEY_LENGTH 256
+
+#if U_PLATFORM_HAS_WINUWP_API == 0
+
+// This is the layout of the TZI binary value in the registry.
+// See: https://docs.microsoft.com/windows/win32/api/timezoneapi/ns-timezoneapi-time_zone_information
+typedef struct _REG_TZI_FORMAT {
+    LONG Bias;
+    LONG StandardBias;
+    LONG DaylightBias;
+    SYSTEMTIME StandardDate;
+    SYSTEMTIME DaylightDate;
+} REG_TZI_FORMAT;
+
+#endif // U_PLATFORM_HAS_WINUWP_API
 
 /**
-* Main Windows time zone detection function.
-* Returns the Windows time zone converted to an ICU time zone as a heap-allocated buffer, or nullptr upon failure.
-* Note: We use the Win32 API GetDynamicTimeZoneInformation to get the current time zone info.
-* This API returns a non-localized time zone name, which we can then map to an ICU time zone name.
+* This is main Windows time zone detection function.
+*
+* It returns the Windows time zone converted to an ICU time zone as a heap-allocated buffer, or nullptr upon failure.
+*
+* We use the Win32 API GetDynamicTimeZoneInformation (which is available since Vista) to get the current time zone info,
+* as this API returns a non-localized time zone name which can be then mapped to an ICU time zone.
+*
+* However, in some RDP/terminal services situations, this struct isn't always fully complete, and the TimeZoneKeyName
+* field of the struct might be NULL. This can happen with some 3rd party RDP clients, and also when using older versions
+* of the RDP protocol, which don't send the newer TimeZoneKeyNamei information and only send the StandardName and DaylightName.
+*
+* Since these 3rd party clients and older RDP clients only send the pre-Vista time zone information to the server, this means that we
+* need to fallback on using the pre-Vista methods to determine the time zone. This unfortunately requires examining the registry directly
+* in order to try and determine the current time zone.
+*
+* Note that this can however still fail in some cases though if the client and server are using different languages, as the StandardName
+* that is sent by client is localized in the client's language. However, we must compare this to the names that are on the server, which
+* are localized in registry using the server's language. Despite that, this is the best we can do.
+*
+* Note: This fallback method won't work for the UWP version though, as we can't use the registry APIs in UWP.
+*
+* Once we have the current Windows time zone, then we can then map it to an ICU time zone ID (~ Olsen ID).
 */
-U_INTERNAL const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uprv_detectWindowsTimeZone()
 {
-    UErrorCode status = U_ZERO_ERROR;
-    char* icuid = nullptr;
-    char dynamicTZKeyName[MAX_TIMEZONE_ID_LENGTH];
-    char tmpid[MAX_TIMEZONE_ID_LENGTH];
-    int32_t len;
-    int id = GEOID_NOT_AVAILABLE;
-    int errorCode;
-    wchar_t ISOcodeW[3] = {}; /* 2 letter ISO code in UTF-16 */
-    char ISOcode[3] = {}; /* 2 letter ISO code in UTF-8 */
-
+    // We first try to obtain the time zone directly by using the TimeZoneKeyName field of the DYNAMIC_TIME_ZONE_INFORMATION struct.
     DYNAMIC_TIME_ZONE_INFORMATION dynamicTZI;
     uprv_memset(&dynamicTZI, 0, sizeof(dynamicTZI));
-    uprv_memset(dynamicTZKeyName, 0, sizeof(dynamicTZKeyName));
-    uprv_memset(tmpid, 0, sizeof(tmpid));
+    SYSTEMTIME systemTimeAllZero;
+    uprv_memset(&systemTimeAllZero, 0, sizeof(systemTimeAllZero));
 
-    /* Obtain TIME_ZONE_INFORMATION from the API and get the non-localized time zone name. */
-    if (TIME_ZONE_ID_INVALID == GetDynamicTimeZoneInformation(&dynamicTZI)) {
+    if (GetDynamicTimeZoneInformation(&dynamicTZI) == TIME_ZONE_ID_INVALID) {
         return nullptr;
     }
 
-    id = GetUserGeoID(GEOCLASS_NATION);
-    errorCode = GetGeoInfoW(id, GEO_ISO2, ISOcodeW, 3, 0);
+    // If the DST setting has been turned off in the Control Panel, then return "Etc/GMT<offset>".
+    //
+    // Note: This logic is based on how the Control Panel itself determines if DST is 'off' on Windows.
+    // The code is somewhat convoluted; in a sort of pseudo-code it looks like this:
+    //
+    //   IF (GetDynamicTimeZoneInformation != TIME_ZONE_ID_INVALID) && (DynamicDaylightTimeDisabled != 0) &&
+    //      (StandardDate == DaylightDate) &&
+    //      (
+    //       (TimeZoneKeyName != Empty && StandardDate == 0) ||
+    //       (TimeZoneKeyName == Empty && StandardDate != 0)
+    //      )
+    //   THEN
+    //     DST setting is "Disabled".
+    //
+    if (dynamicTZI.DynamicDaylightTimeDisabled != 0 &&
+        uprv_memcmp(&dynamicTZI.StandardDate, &dynamicTZI.DaylightDate, sizeof(dynamicTZI.StandardDate)) == 0 &&
+        ((dynamicTZI.TimeZoneKeyName[0] != L'\0' && uprv_memcmp(&dynamicTZI.StandardDate, &systemTimeAllZero, sizeof(systemTimeAllZero)) == 0) ||
+         (dynamicTZI.TimeZoneKeyName[0] == L'\0' && uprv_memcmp(&dynamicTZI.StandardDate, &systemTimeAllZero, sizeof(systemTimeAllZero)) != 0)))
+    {
+        LONG utcOffsetMins = dynamicTZI.Bias;
+        if (utcOffsetMins == 0) {
+            return uprv_strdup("Etc/UTC");
+        }
 
-    // convert from wchar_t* (UTF-16 on Windows) to char* (UTF-8).
-    u_strToUTF8(ISOcode, UPRV_LENGTHOF(ISOcode), nullptr,
-        reinterpret_cast<const UChar*>(ISOcodeW), UPRV_LENGTHOF(ISOcodeW), &status);
+        // No way to support when DST is turned off and the offset in minutes is not a multiple of 60.
+        if (utcOffsetMins % 60 == 0) {
+            char gmtOffsetTz[11] = {}; // "Etc/GMT+dd" is 11-char long with a terminal null.
+            // Important note on the sign convention for zones:
+            //
+            // From https://en.wikipedia.org/wiki/Tz_database#Area
+            //   "In order to conform with the POSIX style, those zone names beginning with "Etc/GMT" have their sign reversed
+            //   from the standard ISO 8601 convention. In the "Etc" area, zones west of GMT have a positive sign and those
+            //   east have a negative sign in their name (e.g "Etc/GMT-14" is 14 hours ahead of GMT)."
+            //
+            // Regarding the POSIX style, from https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
+            //   "The offset specifies the time value you must add to the local time to get a Coordinated Universal Time value."
+            //
+            // However, the Bias value in DYNAMIC_TIME_ZONE_INFORMATION *already* follows the POSIX convention.
+            //
+            // From https://docs.microsoft.com/en-us/windows/win32/api/timezoneapi/ns-timezoneapi-dynamic_time_zone_information
+            //   "The bias is the difference, in minutes, between Coordinated Universal Time (UTC) and
+            //   local time. All translations between UTC and local time are based on the following formula:
+            //      UTC = local time + bias"
+            //
+            // For example, a time zone that is 3 hours ahead of UTC (UTC+03:00) would have a Bias value of -180, and the
+            // corresponding time zone ID would be "Etc/GMT-3". (So there is no need to negate utcOffsetMins below.)
+            int ret = snprintf(gmtOffsetTz, UPRV_LENGTHOF(gmtOffsetTz), "Etc/GMT%+ld", utcOffsetMins / 60);
+            if (ret > 0 && ret < UPRV_LENGTHOF(gmtOffsetTz)) {
+                return uprv_strdup(gmtOffsetTz);
+            }
+        }
+    }
 
-    LocalUResourceBundlePointer bundle(ures_openDirect(nullptr, "windowsZones", &status));
-    ures_getByKey(bundle.getAlias(), "mapTimezones", bundle.getAlias(), &status);
+    // If DST is NOT disabled, but the TimeZoneKeyName field of the struct is NULL, then we may be dealing with a
+    // RDP/terminal services session where the 'Time Zone Redirection' feature is enabled. However, either the RDP
+    // client sent the server incomplete info (some 3rd party RDP clients only send the StandardName and  DaylightName,
+    // but do not send the important TimeZoneKeyName), or if the RDP server has not appropriately populated the struct correctly.
+    //
+    // In this case we unfortunately have no choice but to fallback to using the pre-Vista method of determining the
+    // time zone, which requires examining the registry directly.
+    //
+    // Note that this can however still fail though if the client and server are using different languages, as the StandardName
+    // that is sent by client is *localized* in the client's language. However, we must compare this to the names that are
+    // on the server, which are *localized* in registry using the server's language.
+    //
+    // One other note is that this fallback method doesn't work for the UWP version, as we can't use the registry APIs.
 
-    // convert from wchar_t* (UTF-16 on Windows) to char* (UTF-8).
-    u_strToUTF8(dynamicTZKeyName, UPRV_LENGTHOF(dynamicTZKeyName), nullptr,
-        reinterpret_cast<const UChar*>(dynamicTZI.TimeZoneKeyName), -1, &status);
+    // windowsTimeZoneName will point at timezoneSubKeyName if we had to fallback to using the registry, and we found a match.
+    WCHAR timezoneSubKeyName[WINDOWS_MAX_REG_KEY_LENGTH];
+    WCHAR *windowsTimeZoneName = dynamicTZI.TimeZoneKeyName;
 
-    if (U_FAILURE(status)) {
+    if (dynamicTZI.TimeZoneKeyName[0] == 0) {
+
+// We can't use the registry APIs in the UWP version.
+#if U_PLATFORM_HAS_WINUWP_API == 1
+        (void)timezoneSubKeyName; // suppress unused variable warnings.
         return nullptr;
-    }
+#else
+        // Open the path to the time zones in the Windows registry.
+        LONG ret;
+        HKEY hKeyAllTimeZones = nullptr;
+        ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, WINDOWS_TIMEZONES_REG_KEY_PATH, 0, KEY_READ,
+                            reinterpret_cast<PHKEY>(&hKeyAllTimeZones));
+
+        if (ret != ERROR_SUCCESS) {
+            // If we can't open the key, then we can't do much, so fail.
+            return nullptr;
+        }
+
+        // Read the number of subkeys under the time zone registry path.
+        DWORD numTimeZoneSubKeys;
+        ret = RegQueryInfoKeyW(hKeyAllTimeZones, nullptr, nullptr, nullptr, &numTimeZoneSubKeys,
+                               nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
+
+        if (ret != ERROR_SUCCESS) {
+            RegCloseKey(hKeyAllTimeZones);
+            return nullptr;
+        }
+
+        // Examine each of the subkeys to try and find a match for the localized standard name ("Std").
+        //
+        // Note: The name of the time zone subkey itself is not localized, but the "Std" name is localized. This means
+        // that we could fail to find a match if the RDP client and RDP server are using different languages, but unfortunately
+        // there isn't much we can do about it.
+        HKEY hKeyTimeZoneSubKey = nullptr;
+        ULONG registryValueType;
+        WCHAR registryStandardName[WINDOWS_MAX_REG_KEY_LENGTH];
 
-    if (dynamicTZI.TimeZoneKeyName[0] != 0) {
-        StackUResourceBundle winTZ;
-        ures_getByKey(bundle.getAlias(), dynamicTZKeyName, winTZ.getAlias(), &status);
+        for (DWORD i = 0; i < numTimeZoneSubKeys; i++) {
+            // Note: RegEnumKeyExW wants the size of the buffer in characters.
+            DWORD size = UPRV_LENGTHOF(timezoneSubKeyName);
+            ret = RegEnumKeyExW(hKeyAllTimeZones, i, timezoneSubKeyName, &size, nullptr, nullptr, nullptr, nullptr);
 
-        if (U_SUCCESS(status)) {
-            const UChar* icuTZ = nullptr;
-            if (errorCode != 0) {
-                icuTZ = ures_getStringByKey(winTZ.getAlias(), ISOcode, &len, &status);
+            if (ret != ERROR_SUCCESS) {
+                RegCloseKey(hKeyAllTimeZones);
+                return nullptr;
             }
-            if (errorCode == 0 || icuTZ == nullptr) {
-                /* fallback to default "001" and reset status */
-                status = U_ZERO_ERROR;
-                icuTZ = ures_getStringByKey(winTZ.getAlias(), "001", &len, &status);
+
+            ret = RegOpenKeyExW(hKeyAllTimeZones, timezoneSubKeyName, 0, KEY_READ,
+                                reinterpret_cast<PHKEY>(&hKeyTimeZoneSubKey));
+
+            if (ret != ERROR_SUCCESS) {
+                RegCloseKey(hKeyAllTimeZones);
+                return nullptr;
+            }
+
+            // Note: RegQueryValueExW wants the size of the buffer in bytes.
+            size = sizeof(registryStandardName);
+            ret = RegQueryValueExW(hKeyTimeZoneSubKey, L"Std", nullptr, &registryValueType,
+                                   reinterpret_cast<LPBYTE>(registryStandardName), &size);
+
+            if (ret != ERROR_SUCCESS || registryValueType != REG_SZ) {
+                RegCloseKey(hKeyTimeZoneSubKey);
+                RegCloseKey(hKeyAllTimeZones);
+                return nullptr;
             }
 
-            if (U_SUCCESS(status)) {
-                int index = 0;
+            // Note: wcscmp does an ordinal (byte) comparison.
+            if (wcscmp(reinterpret_cast<WCHAR *>(registryStandardName), dynamicTZI.StandardName) == 0) {
+                // Since we are comparing the *localized* time zone name, it's possible that some languages might use
+                // the same string for more than one time zone. Thus we need to examine the TZI data in the registry to
+                // compare the GMT offset (the bias), and the DST transition dates, to ensure it's the same time zone
+                // as the currently reported one.
+                REG_TZI_FORMAT registryTziValue;
+                uprv_memset(&registryTziValue, 0, sizeof(registryTziValue));
 
-                while (!(*icuTZ == '\0' || *icuTZ == ' ')) {
-                    // time zone IDs only contain ASCII invariant characters.
-                    tmpid[index++] = (char)(*icuTZ++);
+                // Note: RegQueryValueExW wants the size of the buffer in bytes.
+                DWORD timezoneTziValueSize = sizeof(registryTziValue);
+                ret = RegQueryValueExW(hKeyTimeZoneSubKey, L"TZI", nullptr, &registryValueType,
+                                     reinterpret_cast<LPBYTE>(&registryTziValue), &timezoneTziValueSize);
+
+                if (ret == ERROR_SUCCESS) {
+                    if ((dynamicTZI.Bias == registryTziValue.Bias) &&
+                        (memcmp((const void *)&dynamicTZI.StandardDate, (const void *)&registryTziValue.StandardDate, sizeof(SYSTEMTIME)) == 0) &&
+                        (memcmp((const void *)&dynamicTZI.DaylightDate, (const void *)&registryTziValue.DaylightDate, sizeof(SYSTEMTIME)) == 0))
+                    {
+                        // We found a matching time zone.
+                        windowsTimeZoneName = timezoneSubKeyName;
+                        break;
+                    }
                 }
-                tmpid[index] = '\0';
             }
+            RegCloseKey(hKeyTimeZoneSubKey);
+            hKeyTimeZoneSubKey = nullptr;
+        }
+
+        if (hKeyTimeZoneSubKey != nullptr) {
+            RegCloseKey(hKeyTimeZoneSubKey);
         }
+        if (hKeyAllTimeZones != nullptr) {
+            RegCloseKey(hKeyAllTimeZones);
+        }
+#endif // U_PLATFORM_HAS_WINUWP_API
     }
 
-    // Copy the timezone ID to icuid to be returned.
-    if (tmpid[0] != 0) {
-        icuid = uprv_strdup(tmpid);
+    CharString winTZ;
+    UErrorCode status = U_ZERO_ERROR;
+    winTZ.appendInvariantChars(UnicodeString(TRUE, windowsTimeZoneName, -1), status);
+
+    // Map Windows Timezone name (non-localized) to ICU timezone ID (~ Olson timezone id).
+    StackUResourceBundle winTZBundle;
+    ures_openDirectFillIn(winTZBundle.getAlias(), nullptr, "windowsZones", &status);
+    ures_getByKey(winTZBundle.getAlias(), "mapTimezones", winTZBundle.getAlias(), &status);
+    ures_getByKey(winTZBundle.getAlias(), winTZ.data(), winTZBundle.getAlias(), &status);
+
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+
+    // Note: Since the ISO 3166 country/region codes are all invariant ASCII chars, we can
+    // directly downcast from wchar_t to do the conversion.
+    // We could call the A version of the GetGeoInfo API, but that would be slightly slower than calling the W API,
+    // as the A version of the API will end up calling MultiByteToWideChar anyways internally.
+    wchar_t regionCodeW[3] = {};
+    char regionCode[3] = {}; // 2 letter ISO 3166 country/region code made entirely of invariant chars.
+    int geoId = GetUserGeoID(GEOCLASS_NATION);
+    int regionCodeLen = GetGeoInfoW(geoId, GEO_ISO2, regionCodeW, UPRV_LENGTHOF(regionCodeW), 0);
+
+    const UChar *icuTZ16 = nullptr;
+    int32_t tzListLen = 0;
+
+    if (regionCodeLen != 0) {
+        for (int i = 0; i < UPRV_LENGTHOF(regionCodeW); i++) {
+            regionCode[i] = static_cast<char>(regionCodeW[i]);
+        }
+        icuTZ16 = ures_getStringByKey(winTZBundle.getAlias(), regionCode, &tzListLen, &status);
+    }
+    if (regionCodeLen == 0 || U_FAILURE(status)) {
+        // fallback to default "001" (world)
+        status = U_ZERO_ERROR;
+        icuTZ16 = ures_getStringByKey(winTZBundle.getAlias(), "001", &tzListLen, &status);
+    }
+
+    // Note: We want the first entry in the string returned by ures_getStringByKey.
+    // However this string can be a space delimited list of timezones:
+    //  Ex: "America/New_York America/Detroit America/Indiana/Petersburg ..."
+    // We need to stop at the first space, so we pass tzLen (instead of tzListLen) to appendInvariantChars below.
+    int32_t tzLen = 0;
+    if (tzListLen > 0) {
+        while (!(icuTZ16[tzLen] == u'\0' || icuTZ16[tzLen] == u' ')) {
+            tzLen++;
+        }
     }
 
-    return icuid;
+    // Note: cloneData returns nullptr if the status is a failure, so this
+    // will return nullptr if the above look-up fails.
+    CharString icuTZStr;
+    return icuTZStr.appendInvariantChars(icuTZ16, tzLen, status).cloneData(status);
 }
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/common/wintz.h b/deps/icu-small/source/common/wintz.h
index 9140d2729a98f8819e5a78963bed9c4d536cd037..b1ac8c07903738b3ed7cd2dbd8e9e1ed2061277a 100644
--- a/deps/icu-small/source/common/wintz.h
+++ b/deps/icu-small/source/common/wintz.h
@@ -28,7 +28,7 @@ U_CDECL_BEGIN
 typedef struct _TIME_ZONE_INFORMATION TIME_ZONE_INFORMATION;
 U_CDECL_END
 
-U_INTERNAL const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uprv_detectWindowsTimeZone();
 
 #endif /* U_PLATFORM_USES_ONLY_WIN32_API  */
diff --git a/deps/icu-small/source/data/in/icudt67l.dat b/deps/icu-small/source/data/in/icudt67l.dat
deleted file mode 100644
index cb69463d4e3d2348f1ce39fd61eb56883aa3d51a..0000000000000000000000000000000000000000
Binary files a/deps/icu-small/source/data/in/icudt67l.dat and /dev/null differ
diff --git a/deps/icu-small/source/i18n/basictz.cpp b/deps/icu-small/source/i18n/basictz.cpp
index 6cd93f4d3c2c838f0a0f4a36dd58dc8a72fa62fe..4d07d5e1a74c3bc7402e9fdaf365de4c56b1451c 100644
--- a/deps/icu-small/source/i18n/basictz.cpp
+++ b/deps/icu-small/source/i18n/basictz.cpp
@@ -423,7 +423,7 @@ BasicTimeZone::getTimeZoneRulesAfter(UDate start, InitialTimeZoneRule*& initial,
                         goto error;
                     }
                 } else {
-                    // Colllect transitions after the start time
+                    // Collect transitions after the start time
                     int32_t startTimes;
                     DateTimeRule::TimeRuleType timeType;
                     int32_t idx;
@@ -547,14 +547,23 @@ error:
 }
 
 void
-BasicTimeZone::getOffsetFromLocal(UDate /*date*/, int32_t /*nonExistingTimeOpt*/, int32_t /*duplicatedTimeOpt*/,
-                            int32_t& /*rawOffset*/, int32_t& /*dstOffset*/, UErrorCode& status) const {
+BasicTimeZone::getOffsetFromLocal(UDate /*date*/, UTimeZoneLocalOption /*nonExistingTimeOpt*/,
+                                  UTimeZoneLocalOption /*duplicatedTimeOpt*/,
+                                  int32_t& /*rawOffset*/, int32_t& /*dstOffset*/,
+                                  UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     status = U_UNSUPPORTED_ERROR;
 }
 
+void BasicTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
+                                       int32_t& rawOffset, int32_t& dstOffset,
+                                       UErrorCode& status) const {
+    getOffsetFromLocal(date, (UTimeZoneLocalOption)nonExistingTimeOpt,
+                       (UTimeZoneLocalOption)duplicatedTimeOpt, rawOffset, dstOffset, status);
+}
+
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/buddhcal.h b/deps/icu-small/source/i18n/buddhcal.h
index c3ffa6a41d3565a61ab743219704e7e63e3c90a6..e5ce18883ac0391a8255bf1ce089eae5fa28b55f 100644
--- a/deps/icu-small/source/i18n/buddhcal.h
+++ b/deps/icu-small/source/i18n/buddhcal.h
@@ -174,7 +174,7 @@ private:
                                             UBool useMonth) const;
 
     /**
-     * Returns TRUE because the Buddhist Calendar does have a default century
+     * Returns true because the Buddhist Calendar does have a default century
      * @internal
      */
     virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/calendar.cpp b/deps/icu-small/source/i18n/calendar.cpp
index e8b718f3c4619d222bbe8b3d2d7583c11d0237f0..6842f1cfc63c06b212f206dfb6cfa1b57f5d3c78 100644
--- a/deps/icu-small/source/i18n/calendar.cpp
+++ b/deps/icu-small/source/i18n/calendar.cpp
@@ -266,7 +266,7 @@ static ECalType getCalendarTypeForLocale(const char *locid) {
     //TODO: ULOC_FULL_NAME is out of date and too small..
     char canonicalName[256];
 
-    // canonicalize, so grandfathered variant will be transformed to keywords
+    // Canonicalize, so that an old-style variant will be transformed to keywords.
     // e.g ja_JP_TRADITIONAL -> ja_JP@calendar=japanese
     // NOTE: Since ICU-20187, ja_JP_TRADITIONAL no longer canonicalizes, and
     // the Gregorian calendar is returned instead.
@@ -308,7 +308,7 @@ static ECalType getCalendarTypeForLocale(const char *locid) {
 
     calTypeBuf[0] = 0;
     if (U_SUCCESS(status) && order != NULL) {
-        // the first calender type is the default for the region
+        // the first calendar type is the default for the region
         int32_t len = 0;
         const UChar *uCalType = ures_getStringByIndex(order, 0, &len, &status);
         if (len < (int32_t)sizeof(calTypeBuf)) {
@@ -870,7 +870,7 @@ Calendar::createInstance(const TimeZone& zone, UErrorCode& success)
 Calendar* U_EXPORT2
 Calendar::createInstance(const Locale& aLocale, UErrorCode& success)
 {
-    return createInstance(TimeZone::createDefault(), aLocale, success);
+    return createInstance(TimeZone::forLocaleOrDefault(aLocale), aLocale, success);
 }
 
 // ------------------------------------- Adopting
@@ -2291,7 +2291,7 @@ int32_t Calendar::fieldDifference(UDate targetMs, UCalendarDateFields field, UEr
     if (U_FAILURE(ec)) return 0;
     int32_t min = 0;
     double startMs = getTimeInMillis(ec);
-    // Always add from the start millis.  This accomodates
+    // Always add from the start millis.  This accommodates
     // operations like adding years from February 29, 2000 up to
     // February 29, 2004.  If 1, 1, 1, 1 is added to the year
     // field, the DOM gets pinned to 28 and stays there, giving an
diff --git a/deps/icu-small/source/i18n/cecal.cpp b/deps/icu-small/source/i18n/cecal.cpp
index 458fe2f3049b9d0515779b41bf75a1d2e6d34a46..3389b728697db3045cac1787c97c67bc7150aff5 100644
--- a/deps/icu-small/source/i18n/cecal.cpp
+++ b/deps/icu-small/source/i18n/cecal.cpp
@@ -49,7 +49,7 @@ static const int32_t LIMITS[UCAL_FIELD_COUNT][4] = {
 //-------------------------------------------------------------------------
 
 CECalendar::CECalendar(const Locale& aLocale, UErrorCode& success)
-:   Calendar(TimeZone::createDefault(), aLocale, success)
+:   Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success)
 {
     setTimeInMillis(getNow(), success);
 }
diff --git a/deps/icu-small/source/i18n/cecal.h b/deps/icu-small/source/i18n/cecal.h
index c380f0bea30523c34db65f3b7c0039cb26ecb11c..80dab70f6ff0bfa31cdf1b7ac201ed044974fc87 100644
--- a/deps/icu-small/source/i18n/cecal.h
+++ b/deps/icu-small/source/i18n/cecal.h
@@ -88,7 +88,7 @@ protected:
     virtual UBool inDaylightTime(UErrorCode&) const;
 
     /**
-     * Returns TRUE because Coptic/Ethiopic Calendar does have a default century
+     * Returns true because Coptic/Ethiopic Calendar does have a default century
      * @internal
      */
     virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/chnsecal.cpp b/deps/icu-small/source/i18n/chnsecal.cpp
index 2ff9f755afe1f1cf42b8d01de6f09d0ead416e80..2ab08dd33925b2b32166ceda892ddfa6493d08a1 100644
--- a/deps/icu-small/source/i18n/chnsecal.cpp
+++ b/deps/icu-small/source/i18n/chnsecal.cpp
@@ -123,7 +123,7 @@ ChineseCalendar* ChineseCalendar::clone() const {
 }
 
 ChineseCalendar::ChineseCalendar(const Locale& aLocale, UErrorCode& success)
-:   Calendar(TimeZone::createDefault(), aLocale, success),
+:   Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success),
     isLeapYear(FALSE),
     fEpochYear(CHINESE_EPOCH_YEAR),
     fZoneAstroCalc(getChineseCalZoneAstroCalc())
@@ -133,7 +133,7 @@ ChineseCalendar::ChineseCalendar(const Locale& aLocale, UErrorCode& success)
 
 ChineseCalendar::ChineseCalendar(const Locale& aLocale, int32_t epochYear,
                                 const TimeZone* zoneAstroCalc, UErrorCode &success)
-:   Calendar(TimeZone::createDefault(), aLocale, success),
+:   Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success),
     isLeapYear(FALSE),
     fEpochYear(epochYear),
     fZoneAstroCalc(zoneAstroCalc)
diff --git a/deps/icu-small/source/i18n/chnsecal.h b/deps/icu-small/source/i18n/chnsecal.h
index c7c063738145e78bfef98c9313d5ab5a31639357..77a68a48929e10e9fa5983fc8bba005a988578d3 100644
--- a/deps/icu-small/source/i18n/chnsecal.h
+++ b/deps/icu-small/source/i18n/chnsecal.h
@@ -242,7 +242,7 @@ class U_I18N_API ChineseCalendar : public Calendar {
 
 
   /**
-   * Returns TRUE because the Islamic Calendar does have a default century
+   * Returns true because the Islamic Calendar does have a default century
    * @internal
    */
   virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/collation.h b/deps/icu-small/source/i18n/collation.h
index e9256c9c12c5a7be31efdf2578451fa7f4b3fcf7..ecbba29057f03a58f5678c74f5ea78445f439205 100644
--- a/deps/icu-small/source/i18n/collation.h
+++ b/deps/icu-small/source/i18n/collation.h
@@ -356,7 +356,7 @@ public:
     }
 
     /**
-     * @return TRUE if the ce32 yields one or more CEs without further data lookups
+     * @return true if the ce32 yields one or more CEs without further data lookups
      */
     static UBool isSelfContainedCE32(uint32_t ce32) {
         return !isSpecialCE32(ce32) ||
diff --git a/deps/icu-small/source/i18n/collationbuilder.cpp b/deps/icu-small/source/i18n/collationbuilder.cpp
index 45ac6ddcd5839b58d7604fb2d2029e7cea54998a..b411b4f12f6bf95234d177879a5b517d055f5d37 100644
--- a/deps/icu-small/source/i18n/collationbuilder.cpp
+++ b/deps/icu-small/source/i18n/collationbuilder.cpp
@@ -688,7 +688,7 @@ CollationBuilder::addRelation(int32_t strength, const UnicodeString &prefix,
         // A Hangul syllable completely inside a contraction is ok.
     }
     // Note: If there is a prefix, then the parser checked that
-    // both the prefix and the string beging with NFC boundaries (not Jamo V or T).
+    // both the prefix and the string begin with NFC boundaries (not Jamo V or T).
     // Therefore: prefix.isEmpty() || !isJamoVOrT(nfdString.charAt(0))
     // (While handling a Hangul syllable, prefixes on Jamo V or T
     // would not see the previous Jamo of that syllable.)
diff --git a/deps/icu-small/source/i18n/collationbuilder.h b/deps/icu-small/source/i18n/collationbuilder.h
index 2f20050f93ba1d1d5621065e33a20788e90b8ebd..82f0459748f051523c3389de2125f39ff7d31e41 100644
--- a/deps/icu-small/source/i18n/collationbuilder.h
+++ b/deps/icu-small/source/i18n/collationbuilder.h
@@ -42,7 +42,7 @@ public:
     CollationBuilder(const CollationTailoring *base, UErrorCode &errorCode);
     virtual ~CollationBuilder();
 
-    void disableFastLatin() { fastLatinEnabled = FALSE; }
+    void disableFastLatin() { fastLatinEnabled = false; }
 
     CollationTailoring *parseAndBuild(const UnicodeString &ruleString,
                                       const UVersionInfo rulesVersion,
diff --git a/deps/icu-small/source/i18n/collationdatabuilder.cpp b/deps/icu-small/source/i18n/collationdatabuilder.cpp
index fdd264f8aaa65a5d7ea3691be9953ada8500fe50..613124a6f58c505269ae7ac9b9b8e9880d42cdb2 100644
--- a/deps/icu-small/source/i18n/collationdatabuilder.cpp
+++ b/deps/icu-small/source/i18n/collationdatabuilder.cpp
@@ -255,12 +255,18 @@ DataBuilderCollationIterator::getDataCE32(UChar32 c) const {
 
 uint32_t
 DataBuilderCollationIterator::getCE32FromBuilderData(uint32_t ce32, UErrorCode &errorCode) {
+    if (U_FAILURE(errorCode)) { return 0; }
     U_ASSERT(Collation::hasCE32Tag(ce32, Collation::BUILDER_DATA_TAG));
     if((ce32 & CollationDataBuilder::IS_BUILDER_JAMO_CE32) != 0) {
         UChar32 jamo = Collation::indexFromCE32(ce32);
         return utrie2_get32(builder.trie, jamo);
     } else {
         ConditionalCE32 *cond = builder.getConditionalCE32ForCE32(ce32);
+        if (cond == nullptr) {
+            errorCode = U_INTERNAL_PROGRAM_ERROR;
+            // TODO: ICU-21531 figure out why this happens.
+            return 0;
+        }
         if(cond->builtCE32 == Collation::NO_CE32) {
             // Build the context-sensitive mappings into their runtime form and cache the result.
             cond->builtCE32 = builder.buildContext(cond, errorCode);
diff --git a/deps/icu-small/source/i18n/collationdatabuilder.h b/deps/icu-small/source/i18n/collationdatabuilder.h
index fee444deee77dcac15d766e55f8521d4e5b271bc..6ae77772fd5a46be21a69f11492157d99cbdfc7d 100644
--- a/deps/icu-small/source/i18n/collationdatabuilder.h
+++ b/deps/icu-small/source/i18n/collationdatabuilder.h
@@ -73,12 +73,12 @@ public:
     }
 
     /**
-     * @return TRUE if this builder has mappings (e.g., add() has been called)
+     * @return true if this builder has mappings (e.g., add() has been called)
      */
     UBool hasMappings() const { return modified; }
 
     /**
-     * @return TRUE if c has CEs in this builder
+     * @return true if c has CEs in this builder
      */
     UBool isAssigned(UChar32 c) const;
 
@@ -118,7 +118,7 @@ public:
      * @param primary primary weight for 'start'
      * @param step per-code point primary-weight increment
      * @param errorCode ICU in/out error code
-     * @return TRUE if an OFFSET_TAG range was used for start..end
+     * @return true if an OFFSET_TAG range was used for start..end
      */
     UBool maybeSetPrimaryRange(UChar32 start, UChar32 end,
                                uint32_t primary, int32_t step,
@@ -150,7 +150,7 @@ public:
     void optimize(const UnicodeSet &set, UErrorCode &errorCode);
     void suppressContractions(const UnicodeSet &set, UErrorCode &errorCode);
 
-    void enableFastLatin() { fastLatinEnabled = TRUE; }
+    void enableFastLatin() { fastLatinEnabled = true; }
     virtual void build(CollationData &data, UErrorCode &errorCode);
 
     /**
diff --git a/deps/icu-small/source/i18n/collationfcd.h b/deps/icu-small/source/i18n/collationfcd.h
index ec7167d76bab75e68fc269e5cec9b2dfa3dc0bb1..3a5738efb24a7cc0157251a53915aba6e67380cd 100644
--- a/deps/icu-small/source/i18n/collationfcd.h
+++ b/deps/icu-small/source/i18n/collationfcd.h
@@ -84,7 +84,7 @@ public:
         // Handles all of Unicode 0..10FFFF.
         // c can be negative, e.g., U_SENTINEL.
         // U+0300 is the first character with lccc!=0.
-        if(c < 0x300) { return FALSE; }
+        if(c < 0x300) { return false; }
         if(c > 0xffff) { c = U16_LEAD(c); }
         int32_t i;
         return
@@ -101,7 +101,7 @@ public:
      * This is a fast and imprecise test.
      *
      * @param c a code point
-     * @return TRUE if c is U+0F73, U+0F75 or U+0F81 or one of several other Tibetan characters
+     * @return true if c is U+0F73, U+0F75 or U+0F81 or one of several other Tibetan characters
      */
     static inline UBool maybeTibetanCompositeVowel(UChar32 c) {
         return (c & 0x1fff01) == 0xf01;
@@ -116,7 +116,7 @@ public:
      * They have distinct lccc/tccc combinations: 129/130 or 129/132.
      *
      * @param fcd16 the FCD value (lccc/tccc combination) of a code point
-     * @return TRUE if fcd16 is from U+0F73, U+0F75 or U+0F81
+     * @return true if fcd16 is from U+0F73, U+0F75 or U+0F81
      */
     static inline UBool isFCD16OfTibetanCompositeVowel(uint16_t fcd16) {
         return fcd16 == 0x8182 || fcd16 == 0x8184;
diff --git a/deps/icu-small/source/i18n/collationiterator.h b/deps/icu-small/source/i18n/collationiterator.h
index 12e05b4482fab2d45352f20cbe57401feafb0038..869f0956c34d0d204d3c9868caf52aa743ec94a6 100644
--- a/deps/icu-small/source/i18n/collationiterator.h
+++ b/deps/icu-small/source/i18n/collationiterator.h
@@ -76,9 +76,9 @@ private:
             // (Rather than buffer.getCapacity().)
             if(length < INITIAL_CAPACITY || ensureAppendCapacity(1, errorCode)) {
                 ++length;
-                return TRUE;
+                return true;
             } else {
-                return FALSE;
+                return false;
             }
         }
 
@@ -251,9 +251,9 @@ protected:
     virtual UBool foundNULTerminator();
 
     /**
-     * @return FALSE if surrogate code points U+D800..U+DFFF
+     * @return false if surrogate code points U+D800..U+DFFF
      *         map to their own implicit primary weights (for UTF-16),
-     *         or TRUE if they map to CE(U+FFFD) (for UTF-8)
+     *         or true if they map to CE(U+FFFD) (for UTF-8)
      */
     virtual UBool forbidSurrogateCodePoints() const;
 
diff --git a/deps/icu-small/source/i18n/collationkeys.h b/deps/icu-small/source/i18n/collationkeys.h
index 60d9e50c0d9106bb7ae0bbcb26c3d12e772b120d..c526a4f14f2df823aa2e45e340936c0b8a241ae3 100644
--- a/deps/icu-small/source/i18n/collationkeys.h
+++ b/deps/icu-small/source/i18n/collationkeys.h
@@ -65,7 +65,7 @@ public:
     }
 
     UBool Overflowed() const { return appended_ > capacity_; }
-    /** @return FALSE if memory allocation failed */
+    /** @return false if memory allocation failed */
     UBool IsOk() const { return buffer_ != NULL; }
 
 protected:
@@ -94,8 +94,8 @@ public:
         virtual ~LevelCallback();
         /**
          * @param level The next level about to be written to the ByteSink.
-         * @return TRUE if the level is to be written
-         *         (the base class implementation always returns TRUE)
+         * @return true if the level is to be written
+         *         (the base class implementation always returns true)
          */
         virtual UBool needToWrite(Collation::Level level);
     };
@@ -103,7 +103,7 @@ public:
     /**
      * Writes the sort key bytes for minLevel up to the iterator data's strength.
      * Optionally writes the case level.
-     * Stops writing levels when callback.needToWrite(level) returns FALSE.
+     * Stops writing levels when callback.needToWrite(level) returns false.
      * Separates levels with the LEVEL_SEPARATOR_BYTE
      * but does not write a TERMINATOR_BYTE.
      */
diff --git a/deps/icu-small/source/i18n/collationtailoring.h b/deps/icu-small/source/i18n/collationtailoring.h
index e1bc34c7d7683b8198b8e37dd09a971e6b2d5c7d..5fc2bac2d307fb6513e11afd9a07025f571b37ed 100644
--- a/deps/icu-small/source/i18n/collationtailoring.h
+++ b/deps/icu-small/source/i18n/collationtailoring.h
@@ -50,7 +50,7 @@ struct U_I18N_API CollationTailoring : public SharedObject {
     virtual ~CollationTailoring();
 
     /**
-     * Returns TRUE if the constructor could not initialize properly.
+     * Returns true if the constructor could not initialize properly.
      */
     UBool isBogus() { return settings == NULL; }
 
diff --git a/deps/icu-small/source/i18n/collationweights.h b/deps/icu-small/source/i18n/collationweights.h
index d8cee79e33fd872ab6195f1f4992cd2190c881a1..bbd88b27e9e3d70c66e0e8e199345420d93cd6ac 100644
--- a/deps/icu-small/source/i18n/collationweights.h
+++ b/deps/icu-small/source/i18n/collationweights.h
@@ -62,7 +62,7 @@ public:
      *                   weights less than this one.
      * @param n          The number of collation element weights w necessary such that
      *                   lowerLimit<w<upperLimit in lexical order.
-     * @return TRUE if it is possible to fit n elements between the limits
+     * @return true if it is possible to fit n elements between the limits
      */
     UBool allocWeights(uint32_t lowerLimit, uint32_t upperLimit, int32_t n);
 
diff --git a/deps/icu-small/source/i18n/cpdtrans.cpp b/deps/icu-small/source/i18n/cpdtrans.cpp
index 624ae431d35aa658f437e9ddb9380b647517dc94..1d3e6209ec7d36b0e19508d5ab747b21266387ee 100644
--- a/deps/icu-small/source/i18n/cpdtrans.cpp
+++ b/deps/icu-small/source/i18n/cpdtrans.cpp
@@ -282,6 +282,7 @@ void CompoundTransliterator::freeTransliterators(void) {
 CompoundTransliterator& CompoundTransliterator::operator=(
                                              const CompoundTransliterator& t)
 {
+    if (this == &t) { return *this; }  // self-assignment: no-op
     Transliterator::operator=(t);
     int32_t i = 0;
     UBool failed = FALSE;
diff --git a/deps/icu-small/source/i18n/cpdtrans.h b/deps/icu-small/source/i18n/cpdtrans.h
index e51b209411f68bb120bdc76c8ad2b91dda513f6a..c9a9f0519bbbfa55bc3930898b97e0ec9123c479 100644
--- a/deps/icu-small/source/i18n/cpdtrans.h
+++ b/deps/icu-small/source/i18n/cpdtrans.h
@@ -131,7 +131,7 @@ public:
      * to recreate this transliterator.
      * @param result the string to receive the rules.  Previous
      * contents will be deleted.
-     * @param escapeUnprintable if TRUE then convert unprintable
+     * @param escapeUnprintable if true then convert unprintable
      * character to their hex escape representations, \uxxxx or
      * \Uxxxxxxxx.  Unprintable characters are those other than
      * U+000A, U+0020..U+007E.
diff --git a/deps/icu-small/source/i18n/csrecog.h b/deps/icu-small/source/i18n/csrecog.h
index 51c25396adbe14e30d3e04fd4904ff046621364c..42c7d189e5f471e4a2cc6223c6ea0a1cfa48fa55 100644
--- a/deps/icu-small/source/i18n/csrecog.h
+++ b/deps/icu-small/source/i18n/csrecog.h
@@ -43,8 +43,8 @@ class CharsetRecognizer : public UMemory
      * Try the given input text against this Charset, and fill in the results object
      * with the quality of the match plus other information related to the match.
      *
-     * Return TRUE if the the input bytes are a potential match, and
-     * FALSE if the input data is not compatible with, or illegal in this charset.
+     * Return true if the the input bytes are a potential match, and
+     * false if the input data is not compatible with, or illegal in this charset.
      */
     virtual UBool match(InputText *textIn, CharsetMatch *results) const = 0;
 
diff --git a/deps/icu-small/source/i18n/csrmbcs.cpp b/deps/icu-small/source/i18n/csrmbcs.cpp
index 46d626bb3f4ffe4b149cd34c86127fa49f2b68a3..c2f768f7889fe21f6fc2e69a7d14b056dd24b109 100644
--- a/deps/icu-small/source/i18n/csrmbcs.cpp
+++ b/deps/icu-small/source/i18n/csrmbcs.cpp
@@ -186,7 +186,7 @@ int32_t CharsetRecog_mbcs::match_mbcs(InputText *det, const uint16_t commonChars
         if (doubleByteCharCount == 0 && totalCharCount < 10) {
             // There weren't any multibyte sequences, and there was a low density of non-ASCII single bytes.
             // We don't have enough data to have any confidence.
-            // Statistical analysis of single byte non-ASCII charcters would probably help here.
+            // Statistical analysis of single byte non-ASCII characters would probably help here.
             confidence = 0;
         }
         else {
diff --git a/deps/icu-small/source/i18n/csrucode.cpp b/deps/icu-small/source/i18n/csrucode.cpp
index b84011c259095adde700fbae9ee9185ec4e7661d..01d565ec3a9bccb86f03a5ebc3d7c56207a76d7b 100644
--- a/deps/icu-small/source/i18n/csrucode.cpp
+++ b/deps/icu-small/source/i18n/csrucode.cpp
@@ -155,7 +155,7 @@ UBool CharsetRecog_UTF_32::match(InputText* textIn, CharsetMatch *results) const
     } else if (numValid > 0 && numInvalid == 0) {
         confidence = 80;
     } else if (numValid > numInvalid*10) {
-        // Probably corruput UTF-32BE data.  Valid sequences aren't likely by chance.
+        // Probably corrupt UTF-32BE data.  Valid sequences aren't likely by chance.
         confidence = 25;
     }
 
diff --git a/deps/icu-small/source/i18n/csrutf8.cpp b/deps/icu-small/source/i18n/csrutf8.cpp
index bc06fa8bb8dd4e22ec98f3f4570ef7688b95237f..914be35b1f8222cc5c22ac21652cb5db9071b1a4 100644
--- a/deps/icu-small/source/i18n/csrutf8.cpp
+++ b/deps/icu-small/source/i18n/csrutf8.cpp
@@ -99,7 +99,7 @@ UBool CharsetRecog_UTF8::match(InputText* input, CharsetMatch *results) const {
         //              accepts ASCII with confidence = 10.
         confidence = 15;
     } else if (numValid > numInvalid*10) {
-        // Probably corruput utf-8 data.  Valid sequences aren't likely by chance.
+        // Probably corrupt utf-8 data.  Valid sequences aren't likely by chance.
         confidence = 25;
     }
 
diff --git a/deps/icu-small/source/i18n/dayperiodrules.h b/deps/icu-small/source/i18n/dayperiodrules.h
index 610c6175bf5fb93c1033f77c9623b0666eea7bec..4bfca762b8079b15ade638bb54dcf1230ec3abb2 100644
--- a/deps/icu-small/source/i18n/dayperiodrules.h
+++ b/deps/icu-small/source/i18n/dayperiodrules.h
@@ -66,7 +66,7 @@ private:
     // Sets period type for all hours in [startHour, limitHour).
     void add(int32_t startHour, int32_t limitHour, DayPeriod period);
 
-    // Returns TRUE if for all i, DayPeriodForHour[i] has a type other than UNKNOWN.
+    // Returns true if for all i, DayPeriodForHour[i] has a type other than UNKNOWN.
     // Values of HasNoon and HasMidnight do not affect the return value.
     UBool allHoursAreSet();
 
diff --git a/deps/icu-small/source/i18n/decContext.cpp b/deps/icu-small/source/i18n/decContext.cpp
index bead83efff7b830fc0715112964aee0f3cbd0d5c..e22823034fab8889827038cc75ec7c691b229e56 100644
--- a/deps/icu-small/source/i18n/decContext.cpp
+++ b/deps/icu-small/source/i18n/decContext.cpp
@@ -150,7 +150,7 @@ U_CAPI uInt  U_EXPORT2 uprv_decContextGetStatus(decContext *context) {
 /*  newstatus is the source for the bits to be restored               */
 /*  mask indicates the bits to be restored (the status bit that       */
 /*    corresponds to each 1 bit in the mask is set to the value of    */
-/*    the correspnding bit in newstatus)                              */
+/*    the corresponding bit in newstatus)                              */
 /*  returns context                                                   */
 /*                                                                    */
 /* No error is possible.                                              */
diff --git a/deps/icu-small/source/i18n/decContext.h b/deps/icu-small/source/i18n/decContext.h
index 1fd18e5d3df537b15e9d1b4d865f190a6a2f55e6..5f89a516d95c88ab24dd793eb53e1ee3c5602df7 100644
--- a/deps/icu-small/source/i18n/decContext.h
+++ b/deps/icu-small/source/i18n/decContext.h
@@ -250,21 +250,21 @@
   #define DEC_INIT_DECQUAD    DEC_INIT_DECIMAL128
 
   /* decContext routines                                              */
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextClearStatus(decContext *, uint32_t);
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextDefault(decContext *, int32_t);
-  U_INTERNAL enum rounding U_EXPORT2 uprv_decContextGetRounding(decContext *);
-  U_INTERNAL uint32_t      U_EXPORT2 uprv_decContextGetStatus(decContext *);
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextRestoreStatus(decContext *, uint32_t, uint32_t);
-  U_INTERNAL uint32_t      U_EXPORT2 uprv_decContextSaveStatus(decContext *, uint32_t);
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextSetRounding(decContext *, enum rounding);
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextSetStatus(decContext *, uint32_t);
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextSetStatusFromString(decContext *, const char *);
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextSetStatusFromStringQuiet(decContext *, const char *);
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextSetStatusQuiet(decContext *, uint32_t);
-  U_INTERNAL const char  * U_EXPORT2 uprv_decContextStatusToString(const decContext *);
-  U_INTERNAL int32_t       U_EXPORT2 uprv_decContextTestEndian(uint8_t);
-  U_INTERNAL uint32_t      U_EXPORT2 uprv_decContextTestSavedStatus(uint32_t, uint32_t);
-  U_INTERNAL uint32_t      U_EXPORT2 uprv_decContextTestStatus(decContext *, uint32_t);
-  U_INTERNAL decContext  * U_EXPORT2 uprv_decContextZeroStatus(decContext *);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextClearStatus(decContext *, uint32_t);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextDefault(decContext *, int32_t);
+  U_CAPI enum rounding U_EXPORT2 uprv_decContextGetRounding(decContext *);
+  U_CAPI uint32_t      U_EXPORT2 uprv_decContextGetStatus(decContext *);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextRestoreStatus(decContext *, uint32_t, uint32_t);
+  U_CAPI uint32_t      U_EXPORT2 uprv_decContextSaveStatus(decContext *, uint32_t);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextSetRounding(decContext *, enum rounding);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextSetStatus(decContext *, uint32_t);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextSetStatusFromString(decContext *, const char *);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextSetStatusFromStringQuiet(decContext *, const char *);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextSetStatusQuiet(decContext *, uint32_t);
+  U_CAPI const char  * U_EXPORT2 uprv_decContextStatusToString(const decContext *);
+  U_CAPI int32_t       U_EXPORT2 uprv_decContextTestEndian(uint8_t);
+  U_CAPI uint32_t      U_EXPORT2 uprv_decContextTestSavedStatus(uint32_t, uint32_t);
+  U_CAPI uint32_t      U_EXPORT2 uprv_decContextTestStatus(decContext *, uint32_t);
+  U_CAPI decContext  * U_EXPORT2 uprv_decContextZeroStatus(decContext *);
 
 #endif
diff --git a/deps/icu-small/source/i18n/decNumber.cpp b/deps/icu-small/source/i18n/decNumber.cpp
index c19493bdf3bbeea53682f3f042aa07448e10c338..2f9ffafd5710628b502f70f306e7ea11aeadc804 100644
--- a/deps/icu-small/source/i18n/decNumber.cpp
+++ b/deps/icu-small/source/i18n/decNumber.cpp
@@ -2203,7 +2203,7 @@ U_CAPI decNumber * U_EXPORT2 uprv_decNumberPower(decNumber *res, const decNumber
       /* if a negative power the constant 1 is needed, and if not subset  */
       /* invert the lhs now rather than inverting the result later  */
       if (decNumberIsNegative(rhs)) {   /* was a **-n [hence digits>0]  */
-        decNumber *inv=invbuff;         /* asssume use fixed buffer  */
+        decNumber *inv=invbuff;         /* assume use fixed buffer  */
         uprv_decNumberCopy(&dnOne, dac);     /* dnOne=1;  [needed now or later]  */
         #if DECSUBSET
         if (set->extended) {            /* need to calculate 1/lhs  */
@@ -5242,7 +5242,7 @@ static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
 /*    exp(-x) where x can be the tiniest number (Ntiny).              */
 /*                                                                    */
 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop         */
-/*    iterations by appoximately a third with additional (although    */
+/*    iterations by approximately a third with additional (although    */
 /*    diminishing) returns as the range is reduced to even smaller    */
 /*    fractions.  However, h (the power of 10 used to correct the     */
 /*    result at the end, see below) must be kept <=8 as otherwise     */
diff --git a/deps/icu-small/source/i18n/decNumber.h b/deps/icu-small/source/i18n/decNumber.h
index 92be8e8c0acd64158911a033f5c42e4d947942a3..7f5091d275311c34313c5031ec1fb50a765f0de6 100644
--- a/deps/icu-small/source/i18n/decNumber.h
+++ b/deps/icu-small/source/i18n/decNumber.h
@@ -112,74 +112,74 @@
   /* decNumber public functions and macros                            */
   /* ---------------------------------------------------------------- */
   /* Conversions                                                      */
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberFromInt32(decNumber *, int32_t);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberFromUInt32(decNumber *, uint32_t);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberFromString(decNumber *, const char *, decContext *);
-  U_INTERNAL char      * U_EXPORT2 uprv_decNumberToString(const decNumber *, char *);
-  U_INTERNAL char      * U_EXPORT2 uprv_decNumberToEngString(const decNumber *, char *);
-  U_INTERNAL uint32_t    U_EXPORT2 uprv_decNumberToUInt32(const decNumber *, decContext *);
-  U_INTERNAL int32_t     U_EXPORT2 uprv_decNumberToInt32(const decNumber *, decContext *);
-  U_INTERNAL uint8_t   * U_EXPORT2 uprv_decNumberGetBCD(const decNumber *, uint8_t *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberSetBCD(decNumber *, const uint8_t *, uint32_t);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberFromInt32(decNumber *, int32_t);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberFromUInt32(decNumber *, uint32_t);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberFromString(decNumber *, const char *, decContext *);
+  U_CAPI char      * U_EXPORT2 uprv_decNumberToString(const decNumber *, char *);
+  U_CAPI char      * U_EXPORT2 uprv_decNumberToEngString(const decNumber *, char *);
+  U_CAPI uint32_t    U_EXPORT2 uprv_decNumberToUInt32(const decNumber *, decContext *);
+  U_CAPI int32_t     U_EXPORT2 uprv_decNumberToInt32(const decNumber *, decContext *);
+  U_CAPI uint8_t   * U_EXPORT2 uprv_decNumberGetBCD(const decNumber *, uint8_t *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberSetBCD(decNumber *, const uint8_t *, uint32_t);
 
   /* Operators and elementary functions                               */
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberAbs(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberAdd(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberAnd(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberCompare(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberCompareSignal(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberCompareTotal(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberCompareTotalMag(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberDivide(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberDivideInteger(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberExp(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberFMA(decNumber *, const decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberInvert(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberLn(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberLogB(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberLog10(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberMax(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberMaxMag(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberMin(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberMinMag(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberMinus(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberMultiply(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberNormalize(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberOr(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberPlus(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberPower(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberQuantize(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberReduce(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberRemainder(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberRemainderNear(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberRescale(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberRotate(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberSameQuantum(decNumber *, const decNumber *, const decNumber *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberScaleB(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberShift(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberSquareRoot(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberSubtract(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberToIntegralExact(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberToIntegralValue(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber * U_EXPORT2 uprv_decNumberXor(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberAbs(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberAdd(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberAnd(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberCompare(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberCompareSignal(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberCompareTotal(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberCompareTotalMag(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberDivide(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberDivideInteger(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberExp(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberFMA(decNumber *, const decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberInvert(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberLn(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberLogB(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberLog10(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberMax(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberMaxMag(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberMin(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberMinMag(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberMinus(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberMultiply(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberNormalize(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberOr(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberPlus(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberPower(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberQuantize(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberReduce(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberRemainder(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberRemainderNear(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberRescale(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberRotate(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberSameQuantum(decNumber *, const decNumber *, const decNumber *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberScaleB(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberShift(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberSquareRoot(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberSubtract(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberToIntegralExact(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberToIntegralValue(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber * U_EXPORT2 uprv_decNumberXor(decNumber *, const decNumber *, const decNumber *, decContext *);
 
   /* Utilities                                                        */
   enum decClass uprv_decNumberClass(const decNumber *, decContext *);
-  U_INTERNAL const char * U_EXPORT2 uprv_decNumberClassToString(enum decClass);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberCopy(decNumber *, const decNumber *);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberCopyAbs(decNumber *, const decNumber *);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberCopyNegate(decNumber *, const decNumber *);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberCopySign(decNumber *, const decNumber *, const decNumber *);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberNextMinus(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberNextPlus(decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberNextToward(decNumber *, const decNumber *, const decNumber *, decContext *);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberTrim(decNumber *);
-  U_INTERNAL const char * U_EXPORT2 uprv_decNumberVersion(void);
-  U_INTERNAL decNumber  * U_EXPORT2 uprv_decNumberZero(decNumber *);
+  U_CAPI const char * U_EXPORT2 uprv_decNumberClassToString(enum decClass);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberCopy(decNumber *, const decNumber *);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberCopyAbs(decNumber *, const decNumber *);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberCopyNegate(decNumber *, const decNumber *);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberCopySign(decNumber *, const decNumber *, const decNumber *);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberNextMinus(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberNextPlus(decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberNextToward(decNumber *, const decNumber *, const decNumber *, decContext *);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberTrim(decNumber *);
+  U_CAPI const char * U_EXPORT2 uprv_decNumberVersion(void);
+  U_CAPI decNumber  * U_EXPORT2 uprv_decNumberZero(decNumber *);
 
   /* Functions for testing decNumbers (normality depends on context)  */
-  U_INTERNAL int32_t U_EXPORT2 uprv_decNumberIsNormal(const decNumber *, decContext *);
-  U_INTERNAL int32_t U_EXPORT2 uprv_decNumberIsSubnormal(const decNumber *, decContext *);
+  U_CAPI int32_t U_EXPORT2 uprv_decNumberIsNormal(const decNumber *, decContext *);
+  U_CAPI int32_t U_EXPORT2 uprv_decNumberIsSubnormal(const decNumber *, decContext *);
 
   /* Macros for testing decNumber *dn                                 */
   #define decNumberIsCanonical(dn) (1)  /* All decNumbers are saintly */
diff --git a/deps/icu-small/source/i18n/decNumberLocal.h b/deps/icu-small/source/i18n/decNumberLocal.h
index e8d1b38653eb9d2b9edc8818ec0dc0e2f913c9f5..1c5a79b7021f0cf61e3918c356fd07220264d9f5 100644
--- a/deps/icu-small/source/i18n/decNumberLocal.h
+++ b/deps/icu-small/source/i18n/decNumberLocal.h
@@ -146,7 +146,7 @@
 
 
   /* ---------------------------------------------------------------- */
-  /* Definitions for arbitary-precision modules (only valid after     */
+  /* Definitions for arbitrary-precision modules (only valid after     */
   /* decNumber.h has been included)                                   */
   /* ---------------------------------------------------------------- */
 
diff --git a/deps/icu-small/source/i18n/double-conversion-bignum-dtoa.cpp b/deps/icu-small/source/i18n/double-conversion-bignum-dtoa.cpp
index a95910df0421d1fff3f7ece3a3678fb4dbdac437..372e17dc7bd63832e7ef444f331fb9782dac0868 100644
--- a/deps/icu-small/source/i18n/double-conversion-bignum-dtoa.cpp
+++ b/deps/icu-small/source/i18n/double-conversion-bignum-dtoa.cpp
@@ -384,7 +384,7 @@ static void BignumToFixed(int requested_digits, int* decimal_point,
 // Returns an estimation of k such that 10^(k-1) <= v < 10^k where
 // v = f * 2^exponent and 2^52 <= f < 2^53.
 // v is hence a normalized double with the given exponent. The output is an
-// approximation for the exponent of the decimal approimation .digits * 10^k.
+// approximation for the exponent of the decimal approximation .digits * 10^k.
 //
 // The result might undershoot by 1 in which case 10^k <= v < 10^k+1.
 // Note: this property holds for v's upper boundary m+ too.
@@ -562,7 +562,7 @@ static void InitialScaledStartValuesNegativeExponentNegativePower(
 //
 // Let ep == estimated_power, then the returned values will satisfy:
 //  v / 10^ep = numerator / denominator.
-//  v's boundarys m- and m+:
+//  v's boundaries m- and m+:
 //    m- / 10^ep == v / 10^ep - delta_minus / denominator
 //    m+ / 10^ep == v / 10^ep + delta_plus / denominator
 //  Or in other words:
diff --git a/deps/icu-small/source/i18n/double-conversion-double-to-string.cpp b/deps/icu-small/source/i18n/double-conversion-double-to-string.cpp
index 44c176f4f9c9585f52eabdd4d511e0c2db88ca9c..90ba4360600472338978620d208f364dba3653bc 100644
--- a/deps/icu-small/source/i18n/double-conversion-double-to-string.cpp
+++ b/deps/icu-small/source/i18n/double-conversion-double-to-string.cpp
@@ -107,19 +107,19 @@ void DoubleToStringConverter::CreateExponentialRepresentation(
       result_builder->AddCharacter('+');
     }
   }
-  if (exponent == 0) {
-    result_builder->AddCharacter('0');
-    return;
-  }
   DOUBLE_CONVERSION_ASSERT(exponent < 1e4);
   // Changing this constant requires updating the comment of DoubleToStringConverter constructor
   const int kMaxExponentLength = 5;
   char buffer[kMaxExponentLength + 1];
   buffer[kMaxExponentLength] = '\0';
   int first_char_pos = kMaxExponentLength;
-  while (exponent > 0) {
-    buffer[--first_char_pos] = '0' + (exponent % 10);
-    exponent /= 10;
+  if (exponent == 0) {
+    buffer[--first_char_pos] = '0';
+  } else {
+    while (exponent > 0) {
+      buffer[--first_char_pos] = '0' + (exponent % 10);
+      exponent /= 10;
+    }
   }
   // Add prefix '0' to make exponent width >= min(min_exponent_with_, kMaxExponentLength)
   // For example: convert 1e+9 -> 1e+09, if min_exponent_with_ is set to 2
@@ -342,9 +342,21 @@ bool DoubleToStringConverter::ToPrecision(double value,
   int exponent = decimal_point - 1;
 
   int extra_zero = ((flags_ & EMIT_TRAILING_ZERO_AFTER_POINT) != 0) ? 1 : 0;
-  if ((-decimal_point + 1 > max_leading_padding_zeroes_in_precision_mode_) ||
+  bool as_exponential =
+      (-decimal_point + 1 > max_leading_padding_zeroes_in_precision_mode_) ||
       (decimal_point - precision + extra_zero >
-       max_trailing_padding_zeroes_in_precision_mode_)) {
+       max_trailing_padding_zeroes_in_precision_mode_);
+  if ((flags_ & NO_TRAILING_ZERO) != 0) {
+    // Truncate trailing zeros that occur after the decimal point (if exponential,
+    // that is everything after the first digit).
+    int stop = as_exponential ? 1 : std::max(1, decimal_point);
+    while (decimal_rep_length > stop && decimal_rep[decimal_rep_length - 1] == '0') {
+      --decimal_rep_length;
+    }
+    // Clamp precision to avoid the code below re-adding the zeros.
+    precision = std::min(precision, decimal_rep_length);
+  }
+  if (as_exponential) {
     // Fill buffer to contain 'precision' digits.
     // Usually the buffer is already at the correct length, but 'DoubleToAscii'
     // is allowed to return less characters.
diff --git a/deps/icu-small/source/i18n/double-conversion-double-to-string.h b/deps/icu-small/source/i18n/double-conversion-double-to-string.h
index 27bd86784895f83479fb43cfeef805e0e34bddcf..73ff48f109ecd5c20888a379b28032e7f0e26bec 100644
--- a/deps/icu-small/source/i18n/double-conversion-double-to-string.h
+++ b/deps/icu-small/source/i18n/double-conversion-double-to-string.h
@@ -48,12 +48,11 @@ namespace double_conversion {
 
 class DoubleToStringConverter {
  public:
-#if 0 // not needed for ICU
   // When calling ToFixed with a double > 10^kMaxFixedDigitsBeforePoint
   // or a requested_digits parameter > kMaxFixedDigitsAfterPoint then the
   // function returns false.
   static const int kMaxFixedDigitsBeforePoint = 60;
-  static const int kMaxFixedDigitsAfterPoint = 60;
+  static const int kMaxFixedDigitsAfterPoint = 100;
 
   // When calling ToExponential with a requested_digits
   // parameter > kMaxExponentialDigits then the function returns false.
@@ -65,12 +64,36 @@ class DoubleToStringConverter {
   static const int kMinPrecisionDigits = 1;
   static const int kMaxPrecisionDigits = 120;
 
+  // The maximal number of digits that are needed to emit a double in base 10.
+  // A higher precision can be achieved by using more digits, but the shortest
+  // accurate representation of any double will never use more digits than
+  // kBase10MaximalLength.
+  // Note that DoubleToAscii null-terminates its input. So the given buffer
+  // should be at least kBase10MaximalLength + 1 characters long.
+  static const int kBase10MaximalLength = 17;
+
+  // The maximal number of digits that are needed to emit a single in base 10.
+  // A higher precision can be achieved by using more digits, but the shortest
+  // accurate representation of any single will never use more digits than
+  // kBase10MaximalLengthSingle.
+  static const int kBase10MaximalLengthSingle = 9;
+
+  // The length of the longest string that 'ToShortest' can produce when the
+  // converter is instantiated with EcmaScript defaults (see
+  // 'EcmaScriptConverter')
+  // This value does not include the trailing '\0' character.
+  // This amount of characters is needed for negative values that hit the
+  // 'decimal_in_shortest_low' limit. For example: "-0.0000033333333333333333"
+  static const int kMaxCharsEcmaScriptShortest = 25;
+
+#if 0 // not needed for ICU
   enum Flags {
     NO_FLAGS = 0,
     EMIT_POSITIVE_EXPONENT_SIGN = 1,
     EMIT_TRAILING_DECIMAL_POINT = 2,
     EMIT_TRAILING_ZERO_AFTER_POINT = 4,
-    UNIQUE_ZERO = 8
+    UNIQUE_ZERO = 8,
+    NO_TRAILING_ZERO = 16
   };
 
   // Flags should be a bit-or combination of the possible Flags-enum.
@@ -82,9 +105,13 @@ class DoubleToStringConverter {
   //    Example: 2345.0 is converted to "2345.".
   //  - EMIT_TRAILING_ZERO_AFTER_POINT: in addition to a trailing decimal point
   //    emits a trailing '0'-character. This flag requires the
-  //    EXMIT_TRAILING_DECIMAL_POINT flag.
+  //    EMIT_TRAILING_DECIMAL_POINT flag.
   //    Example: 2345.0 is converted to "2345.0".
   //  - UNIQUE_ZERO: "-0.0" is converted to "0.0".
+  //  - NO_TRAILING_ZERO: Trailing zeros are removed from the fractional portion
+  //    of the result in precision mode. Matches printf's %g.
+  //    When EMIT_TRAILING_ZERO_AFTER_POINT is also given, one trailing zero is
+  //    preserved.
   //
   // Infinity symbol and nan_symbol provide the string representation for these
   // special values. If the string is NULL and the special value is encountered
@@ -152,6 +179,14 @@ class DoubleToStringConverter {
   }
 
   // Returns a converter following the EcmaScript specification.
+  //
+  // Flags: UNIQUE_ZERO and EMIT_POSITIVE_EXPONENT_SIGN.
+  // Special values: "Infinity" and "NaN".
+  // Lower case 'e' for exponential values.
+  // decimal_in_shortest_low: -6
+  // decimal_in_shortest_high: 21
+  // max_leading_padding_zeroes_in_precision_mode: 6
+  // max_trailing_padding_zeroes_in_precision_mode: 0
   static const DoubleToStringConverter& EcmaScriptConverter();
 
   // Computes the shortest string of digits that correctly represent the input
@@ -177,6 +212,21 @@ class DoubleToStringConverter {
   // Returns true if the conversion succeeds. The conversion always succeeds
   // except when the input value is special and no infinity_symbol or
   // nan_symbol has been given to the constructor.
+  //
+  // The length of the longest result is the maximum of the length of the
+  // following string representations (each with possible examples):
+  // - NaN and negative infinity: "NaN", "-Infinity", "-inf".
+  // - -10^(decimal_in_shortest_high - 1):
+  //      "-100000000000000000000", "-1000000000000000.0"
+  // - the longest string in range [0; -10^decimal_in_shortest_low]. Generally,
+  //   this string is 3 + kBase10MaximalLength - decimal_in_shortest_low.
+  //   (Sign, '0', decimal point, padding zeroes for decimal_in_shortest_low,
+  //   and the significant digits).
+  //      "-0.0000033333333333333333", "-0.0012345678901234567"
+  // - the longest exponential representation. (A negative number with
+  //   kBase10MaximalLength significant digits).
+  //      "-1.7976931348623157e+308", "-1.7976931348623157E308"
+  // In addition, the buffer must be able to hold the trailing '\0' character.
   bool ToShortest(double value, StringBuilder* result_builder) const {
     return ToShortestIeeeNumber(value, result_builder, SHORTEST);
   }
@@ -217,9 +267,11 @@ class DoubleToStringConverter {
   //     been provided to the constructor,
   //   - 'value' > 10^kMaxFixedDigitsBeforePoint, or
   //   - 'requested_digits' > kMaxFixedDigitsAfterPoint.
-  // The last two conditions imply that the result will never contain more than
-  // 1 + kMaxFixedDigitsBeforePoint + 1 + kMaxFixedDigitsAfterPoint characters
+  // The last two conditions imply that the result for non-special values never
+  // contains more than
+  //  1 + kMaxFixedDigitsBeforePoint + 1 + kMaxFixedDigitsAfterPoint characters
   // (one additional character for the sign, and one for the decimal point).
+  // In addition, the buffer must be able to hold the trailing '\0' character.
   bool ToFixed(double value,
                int requested_digits,
                StringBuilder* result_builder) const;
@@ -248,14 +300,17 @@ class DoubleToStringConverter {
   //   - the input value is special and no infinity_symbol or nan_symbol has
   //     been provided to the constructor,
   //   - 'requested_digits' > kMaxExponentialDigits.
-  // The last condition implies that the result will never contain more than
+  //
+  // The last condition implies that the result never contains more than
   // kMaxExponentialDigits + 8 characters (the sign, the digit before the
   // decimal point, the decimal point, the exponent character, the
   // exponent's sign, and at most 3 exponent digits).
+  // In addition, the buffer must be able to hold the trailing '\0' character.
   bool ToExponential(double value,
                      int requested_digits,
                      StringBuilder* result_builder) const;
 
+
   // Computes 'precision' leading digits of the given 'value' and returns them
   // either in exponential or decimal format, depending on
   // max_{leading|trailing}_padding_zeroes_in_precision_mode (given to the
@@ -287,9 +342,11 @@ class DoubleToStringConverter {
   //     been provided to the constructor,
   //   - precision < kMinPericisionDigits
   //   - precision > kMaxPrecisionDigits
-  // The last condition implies that the result will never contain more than
+  //
+  // The last condition implies that the result never contains more than
   // kMaxPrecisionDigits + 7 characters (the sign, the decimal point, the
   // exponent character, the exponent's sign, and at most 3 exponent digits).
+  // In addition, the buffer must be able to hold the trailing '\0' character.
   bool ToPrecision(double value,
                    int precision,
                    StringBuilder* result_builder) const;
@@ -310,14 +367,6 @@ class DoubleToStringConverter {
     PRECISION
   };
 
-  // The maximal number of digits that are needed to emit a double in base 10.
-  // A higher precision can be achieved by using more digits, but the shortest
-  // accurate representation of any double will never use more digits than
-  // kBase10MaximalLength.
-  // Note that DoubleToAscii null-terminates its input. So the given buffer
-  // should be at least kBase10MaximalLength + 1 characters long.
-  static const int kBase10MaximalLength = 17;
-
   // Converts the given double 'v' to digit characters. 'v' must not be NaN,
   // +Infinity, or -Infinity. In SHORTEST_SINGLE-mode this restriction also
   // applies to 'v' after it has been casted to a single-precision float. That
diff --git a/deps/icu-small/source/i18n/double-conversion-string-to-double.cpp b/deps/icu-small/source/i18n/double-conversion-string-to-double.cpp
index 548cad1f3022416e29d58102701811e1df57df47..3275b9e552f66b0eb729595df73eeec9628f8099 100644
--- a/deps/icu-small/source/i18n/double-conversion-string-to-double.cpp
+++ b/deps/icu-small/source/i18n/double-conversion-string-to-double.cpp
@@ -51,6 +51,18 @@
 // ICU PATCH: Wrap in ICU namespace
 U_NAMESPACE_BEGIN
 
+#ifdef _MSC_VER
+#  if _MSC_VER >= 1900
+// Fix MSVC >= 2015 (_MSC_VER == 1900) warning
+// C4244: 'argument': conversion from 'const uc16' to 'char', possible loss of data
+// against Advance and friends, when instantiated with **it as char, not uc16.
+ __pragma(warning(disable: 4244))
+#  endif
+#  if _MSC_VER <= 1700 // VS2012, see IsDecimalDigitForRadix warning fix, below
+#    define VS2012_RADIXWARN
+#  endif
+#endif
+
 namespace double_conversion {
 
 namespace {
@@ -170,9 +182,9 @@ static double SignedZero(bool sign) {
 //
 // The function is small and could be inlined, but VS2012 emitted a warning
 // because it constant-propagated the radix and concluded that the last
-// condition was always true. By moving it into a separate function the
-// compiler wouldn't warn anymore.
-#ifdef _MSC_VER
+// condition was always true. Moving it into a separate function and
+// suppressing optimisation keeps the compiler from warning.
+#ifdef VS2012_RADIXWARN
 #pragma optimize("",off)
 static bool IsDecimalDigitForRadix(int c, int radix) {
   return '0' <= c && c <= '9' && (c - '0') < radix;
@@ -738,11 +750,17 @@ double StringToDoubleConverter::StringToIeee(
   DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
   buffer[buffer_pos] = '\0';
 
+  // Code above ensures there are no leading zeros and the buffer has fewer than
+  // kMaxSignificantDecimalDigits characters. Trim trailing zeros.
+  Vector<const char> chars(buffer, buffer_pos);
+  chars = TrimTrailingZeros(chars);
+  exponent += buffer_pos - chars.length();
+
   double converted;
   if (read_as_double) {
-    converted = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
+    converted = StrtodTrimmed(chars, exponent);
   } else {
-    converted = Strtof(Vector<const char>(buffer, buffer_pos), exponent);
+    converted = StrtofTrimmed(chars, exponent);
   }
   *processed_characters_count = static_cast<int>(current - input);
   return sign? -converted: converted;
diff --git a/deps/icu-small/source/i18n/double-conversion-strtod.cpp b/deps/icu-small/source/i18n/double-conversion-strtod.cpp
index ee6377782bb82fba972d811c42a5d554aa0b2b96..9eeaa2e40fc73c0390f81e5471a144a52274ba77 100644
--- a/deps/icu-small/source/i18n/double-conversion-strtod.cpp
+++ b/deps/icu-small/source/i18n/double-conversion-strtod.cpp
@@ -115,17 +115,6 @@ static Vector<const char> TrimLeadingZeros(Vector<const char> buffer) {
   return Vector<const char>(buffer.start(), 0);
 }
 
-
-static Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
-  for (int i = buffer.length() - 1; i >= 0; --i) {
-    if (buffer[i] != '0') {
-      return buffer.SubVector(0, i + 1);
-    }
-  }
-  return Vector<const char>(buffer.start(), 0);
-}
-
-
 static void CutToMaxSignificantDigits(Vector<const char> buffer,
                                        int exponent,
                                        char* significant_buffer,
@@ -216,12 +205,14 @@ static bool DoubleStrtod(Vector<const char> trimmed,
                          int exponent,
                          double* result) {
 #if !defined(DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS)
+  // Avoid "unused parameter" warnings
+  (void) trimmed;
+  (void) exponent;
+  (void) result;
   // On x86 the floating-point stack can be 64 or 80 bits wide. If it is
   // 80 bits wide (as is the case on Linux) then double-rounding occurs and the
   // result is not accurate.
   // We know that Windows32 uses 64 bits and is therefore accurate.
-  // Note that the ARM simulator is compiled for 32bits. It therefore exhibits
-  // the same problem.
   return false;
 #else
   if (trimmed.length() <= kMaxExactDoubleIntegerDecimalDigits) {
@@ -473,6 +464,11 @@ static bool IsNonZeroDigit(const char d) {
   return ('1' <= d) && (d <= '9');
 }
 
+#ifdef __has_cpp_attribute
+#if __has_cpp_attribute(maybe_unused)
+[[maybe_unused]]
+#endif
+#endif
 static bool AssertTrimmedDigits(const Vector<const char>& buffer) {
   for(int i = 0; i < buffer.length(); ++i) {
     if(!IsDigit(buffer[i])) {
@@ -545,6 +541,12 @@ float Strtof(Vector<const char> buffer, int exponent) {
   TrimAndCut(buffer, exponent, copy_buffer, kMaxSignificantDecimalDigits,
              &trimmed, &updated_exponent);
   exponent = updated_exponent;
+  return StrtofTrimmed(trimmed, exponent);
+}
+
+float StrtofTrimmed(Vector<const char> trimmed, int exponent) {
+  DOUBLE_CONVERSION_ASSERT(trimmed.length() <= kMaxSignificantDecimalDigits);
+  DOUBLE_CONVERSION_ASSERT(AssertTrimmedDigits(trimmed));
 
   double double_guess;
   bool is_correct = ComputeGuess(trimmed, exponent, &double_guess);
diff --git a/deps/icu-small/source/i18n/double-conversion-strtod.h b/deps/icu-small/source/i18n/double-conversion-strtod.h
index 50ef746401a90840b1012d87ffba87bfcc42680f..abfe00a333102ce0006819b2531552068c991404 100644
--- a/deps/icu-small/source/i18n/double-conversion-strtod.h
+++ b/deps/icu-small/source/i18n/double-conversion-strtod.h
@@ -54,11 +54,25 @@ double Strtod(Vector<const char> buffer, int exponent);
 // contain a dot or a sign. It must not start with '0', and must not be empty.
 float Strtof(Vector<const char> buffer, int exponent);
 
-// For special use cases, the heart of the Strtod() function is also available
-// separately, it assumes that 'trimmed' is as produced by TrimAndCut(), i.e.
-// no leading or trailing zeros, also no lone zero, and not 'too many' digits.
+// Same as Strtod, but assumes that 'trimmed' is already trimmed, as if run
+// through TrimAndCut. That is, 'trimmed' must have no leading or trailing
+// zeros, must not be a lone zero, and must not have 'too many' digits.
 double StrtodTrimmed(Vector<const char> trimmed, int exponent);
 
+// Same as Strtof, but assumes that 'trimmed' is already trimmed, as if run
+// through TrimAndCut. That is, 'trimmed' must have no leading or trailing
+// zeros, must not be a lone zero, and must not have 'too many' digits.
+float StrtofTrimmed(Vector<const char> trimmed, int exponent);
+
+inline Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
+  for (int i = buffer.length() - 1; i >= 0; --i) {
+    if (buffer[i] != '0') {
+      return buffer.SubVector(0, i + 1);
+    }
+  }
+  return Vector<const char>(buffer.start(), 0);
+}
+
 }  // namespace double_conversion
 
 // ICU PATCH: Close ICU namespace
diff --git a/deps/icu-small/source/i18n/double-conversion-utils.h b/deps/icu-small/source/i18n/double-conversion-utils.h
index 8c6a0e16e005fe2a80fc08d28dd7061ea2fcdbfa..c937463647135becaff0e2f9876f5ed4b19122dc 100644
--- a/deps/icu-small/source/i18n/double-conversion-utils.h
+++ b/deps/icu-small/source/i18n/double-conversion-utils.h
@@ -118,7 +118,7 @@ int main(int argc, char** argv) {
     defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \
     defined(__hppa__) || defined(__ia64__) || \
     defined(__mips__) || \
-    defined(__nios2__) || \
+    defined(__nios2__) || defined(__ghs) || \
     defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \
     defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
     defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
diff --git a/deps/icu-small/source/i18n/dtfmtsym.cpp b/deps/icu-small/source/i18n/dtfmtsym.cpp
index 9dde66c1fba4194f910ea6117374e322324377db..5a54e9ebbd4493158f8cfca444cd4a8f005f954c 100644
--- a/deps/icu-small/source/i18n/dtfmtsym.cpp
+++ b/deps/icu-small/source/i18n/dtfmtsym.cpp
@@ -450,6 +450,7 @@ DateFormatSymbols::copyData(const DateFormatSymbols& other) {
  */
 DateFormatSymbols& DateFormatSymbols::operator=(const DateFormatSymbols& other)
 {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     dispose();
     copyData(other);
 
@@ -2330,7 +2331,7 @@ DateFormatSymbols::initializeData(const Locale& locale, const char *type, UError
         // If format/narrow not available, use standalone/narrow
         assignArray(fNarrowMonths, fNarrowMonthsCount, fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount);
     } else if (narrowMonthsEC != U_MISSING_RESOURCE_ERROR && standaloneNarrowMonthsEC == U_MISSING_RESOURCE_ERROR) {
-        // If standalone/narrow not availabe, use format/narrow
+        // If standalone/narrow not available, use format/narrow
         assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, fNarrowMonths, fNarrowMonthsCount);
     } else if (narrowMonthsEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowMonthsEC == U_MISSING_RESOURCE_ERROR) {
         // If neither is available, use format/abbreviated
diff --git a/deps/icu-small/source/i18n/dtitv_impl.h b/deps/icu-small/source/i18n/dtitv_impl.h
index 7c4d8a7214891921cc59f1a4793935ff8f7517f0..9a161ea435d553d5ad9f1dd3b329e305c6df59be 100644
--- a/deps/icu-small/source/i18n/dtitv_impl.h
+++ b/deps/icu-small/source/i18n/dtitv_impl.h
@@ -64,11 +64,13 @@
 #define LOW_Z             ((UChar)0x007A)
 
 #define CAP_A             ((UChar)0x0041)
+#define CAP_B             ((UChar)0x0042)
 #define CAP_C             ((UChar)0x0043)
 #define CAP_D             ((UChar)0x0044)
 #define CAP_E             ((UChar)0x0045)
 #define CAP_F             ((UChar)0x0046)
 #define CAP_G             ((UChar)0x0047)
+#define CAP_J             ((UChar)0x004A)
 #define CAP_H             ((UChar)0x0048)
 #define CAP_K             ((UChar)0x004B)
 #define CAP_L             ((UChar)0x004C)
diff --git a/deps/icu-small/source/i18n/dtitvfmt.cpp b/deps/icu-small/source/i18n/dtitvfmt.cpp
index b71a571d1c490a143573634947a4081da75560d7..18253156ea7e0e6c07d22d7b0d93db33cf3ed467 100644
--- a/deps/icu-small/source/i18n/dtitvfmt.cpp
+++ b/deps/icu-small/source/i18n/dtitvfmt.cpp
@@ -23,6 +23,7 @@
 #include "unicode/dtptngen.h"
 #include "unicode/dtitvinf.h"
 #include "unicode/simpleformatter.h"
+#include "unicode/udisplaycontext.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "dtitv_impl.h"
@@ -143,7 +144,8 @@ DateIntervalFormat::DateIntervalFormat()
     fLocale(Locale::getRoot()),
     fDatePattern(nullptr),
     fTimePattern(nullptr),
-    fDateTimeFormat(nullptr)
+    fDateTimeFormat(nullptr),
+    fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
 {}
 
 
@@ -156,7 +158,8 @@ DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt)
     fLocale(itvfmt.fLocale),
     fDatePattern(nullptr),
     fTimePattern(nullptr),
-    fDateTimeFormat(nullptr) {
+    fDateTimeFormat(nullptr),
+    fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE) {
     *this = itvfmt;
 }
 
@@ -203,6 +206,7 @@ DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) {
         fDatePattern    = (itvfmt.fDatePattern)?    itvfmt.fDatePattern->clone(): nullptr;
         fTimePattern    = (itvfmt.fTimePattern)?    itvfmt.fTimePattern->clone(): nullptr;
         fDateTimeFormat = (itvfmt.fDateTimeFormat)? itvfmt.fDateTimeFormat->clone(): nullptr;
+        fCapitalizationContext = itvfmt.fCapitalizationContext;
     }
     return *this;
 }
@@ -239,7 +243,7 @@ DateIntervalFormat::operator==(const Format& other) const {
         if (fDateFormat && fmt->fDateFormat && (*fDateFormat != *fmt->fDateFormat)) {return FALSE;}
     }
     // note: fFromCalendar and fToCalendar hold no persistent state, and therefore do not participate in operator ==.
-    //       fDateFormat has the master calendar for the DateIntervalFormat.
+    //       fDateFormat has the primary calendar for the DateIntervalFormat.
     if (fSkeleton != fmt->fSkeleton) {return FALSE;}
     if (fDatePattern != fmt->fDatePattern && (fDatePattern == nullptr || fmt->fDatePattern == nullptr)) {return FALSE;}
     if (fDatePattern && fmt->fDatePattern && (*fDatePattern != *fmt->fDatePattern)) {return FALSE;}
@@ -254,6 +258,7 @@ DateIntervalFormat::operator==(const Format& other) const {
         if (fIntervalPatterns[i].secondPart != fmt->fIntervalPatterns[i].secondPart ) {return FALSE;}
         if (fIntervalPatterns[i].laterDateFirst != fmt->fIntervalPatterns[i].laterDateFirst) {return FALSE;}
     }
+    if (fCapitalizationContext != fmt->fCapitalizationContext) {return FALSE;}
     return TRUE;
 }
 
@@ -409,6 +414,7 @@ UnicodeString& DateIntervalFormat::formatIntervalImpl(
 }
 
 
+// The following is only called from within the gFormatterMutex lock
 UnicodeString&
 DateIntervalFormat::formatImpl(Calendar& fromCalendar,
                            Calendar& toCalendar,
@@ -464,6 +470,11 @@ DateIntervalFormat::formatImpl(Calendar& fromCalendar,
     if ( U_FAILURE(status) ) {
         return appendTo;
     }
+    UErrorCode tempStatus = U_ZERO_ERROR; // for setContext, ignored
+    // Set up fDateFormat to handle the first or only part of the interval
+    // (override later for any second part). Inside lock, OK to modify fDateFormat.
+    fDateFormat->setContext(fCapitalizationContext, tempStatus);
+
     if ( field == UCAL_FIELD_COUNT ) {
         /* ignore the millisecond etc. small fields' difference.
          * use single date when all the above are the same.
@@ -521,6 +532,9 @@ DateIntervalFormat::formatImpl(Calendar& fromCalendar,
 
     if ( !intervalPattern.secondPart.isEmpty() ) {
         fDateFormat->applyPattern(intervalPattern.secondPart);
+        // No capitalization for second part of interval
+        tempStatus = U_ZERO_ERROR;
+        fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
         fDateFormat->_format(*secondCal, appendTo, fphandler, status);
     }
     fDateFormat->applyPattern(originalPattern);
@@ -583,7 +597,7 @@ DateIntervalFormat::adoptTimeZone(TimeZone* zone)
     if (fDateFormat != nullptr) {
         fDateFormat->adoptTimeZone(zone);
     }
-    // The fDateFormat has the master calendar for the DateIntervalFormat and has
+    // The fDateFormat has the primary calendar for the DateIntervalFormat and has
     // ownership of any adopted TimeZone; fFromCalendar and fToCalendar are internal
     // work clones of that calendar (and should not also be given ownership of the
     // adopted TimeZone).
@@ -601,7 +615,7 @@ DateIntervalFormat::setTimeZone(const TimeZone& zone)
     if (fDateFormat != nullptr) {
         fDateFormat->setTimeZone(zone);
     }
-    // The fDateFormat has the master calendar for the DateIntervalFormat;
+    // The fDateFormat has the primary calendar for the DateIntervalFormat;
     // fFromCalendar and fToCalendar are internal work clones of that calendar.
     if (fFromCalendar) {
         fFromCalendar->setTimeZone(zone);
@@ -622,6 +636,30 @@ DateIntervalFormat::getTimeZone() const
     return *(TimeZone::createDefault());
 }
 
+void
+DateIntervalFormat::setContext(UDisplayContext value, UErrorCode& status)
+{
+    if (U_FAILURE(status))
+        return;
+    if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
+        fCapitalizationContext = value;
+    } else {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+    }
+}
+
+UDisplayContext
+DateIntervalFormat::getContext(UDisplayContextType type, UErrorCode& status) const
+{
+    if (U_FAILURE(status))
+        return (UDisplayContext)0;
+    if (type != UDISPCTX_TYPE_CAPITALIZATION) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return (UDisplayContext)0;
+    }
+    return fCapitalizationContext;
+}
+
 DateIntervalFormat::DateIntervalFormat(const Locale& locale,
                                        DateIntervalInfo* dtItvInfo,
                                        const UnicodeString* skeleton,
@@ -633,7 +671,8 @@ DateIntervalFormat::DateIntervalFormat(const Locale& locale,
     fLocale(locale),
     fDatePattern(nullptr),
     fTimePattern(nullptr),
-    fDateTimeFormat(nullptr)
+    fDateTimeFormat(nullptr),
+    fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
 {
     LocalPointer<DateIntervalInfo> info(dtItvInfo, status);
     LocalPointer<SimpleDateFormat> dtfmt(static_cast<SimpleDateFormat *>(
@@ -665,7 +704,7 @@ DateIntervalFormat::create(const Locale& locale,
         status = U_MEMORY_ALLOCATION_ERROR;
         delete dtitvinf;
     } else if ( U_FAILURE(status) ) {
-        // safe to delete f, although nothing acutally is saved
+        // safe to delete f, although nothing actually is saved
         delete f;
         f = 0;
     }
@@ -751,7 +790,7 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
 
     /* the difference between time skeleton and normalizedTimeSkeleton are:
      * 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true)
-     * 2. 'a' is omitted in normalized time skeleton.
+     * 2. (Formerly, 'a' was omitted in normalized time skeleton; this is now handled elsewhere)
      * 3. there is only one appearance for 'h' or 'H', 'm','v', 'z' in normalized
      *    time skeleton
      *
@@ -760,7 +799,8 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
      * 2. 'E' and 'EE' are normalized into 'EEE'
      * 3. 'MM' is normalized into 'M'
      */
-    getDateTimeSkeleton(fSkeleton, dateSkeleton, normalizedDateSkeleton,
+    UnicodeString convertedSkeleton = normalizeHourMetacharacters(fSkeleton);
+    getDateTimeSkeleton(convertedSkeleton, dateSkeleton, normalizedDateSkeleton,
                         timeSkeleton, normalizedTimeSkeleton);
 
 #ifdef DTITVFMT_DEBUG
@@ -823,6 +863,14 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
                 setPatternInfo(UCAL_DATE, nullptr, &pattern, fInfo->getDefaultOrder());
                 setPatternInfo(UCAL_MONTH, nullptr, &pattern, fInfo->getDefaultOrder());
                 setPatternInfo(UCAL_YEAR, nullptr, &pattern, fInfo->getDefaultOrder());
+
+                timeSkeleton.insert(0, CAP_G);
+                pattern = DateFormat::getBestPattern(
+                        locale, timeSkeleton, status);
+                if ( U_FAILURE(status) ) {
+                    return;
+                }
+                setPatternInfo(UCAL_ERA, nullptr, &pattern, fInfo->getDefaultOrder());
             } else {
                 // TODO: fall back
             }
@@ -849,15 +897,23 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
         setPatternInfo(UCAL_DATE, nullptr, &pattern, fInfo->getDefaultOrder());
         setPatternInfo(UCAL_MONTH, nullptr, &pattern, fInfo->getDefaultOrder());
         setPatternInfo(UCAL_YEAR, nullptr, &pattern, fInfo->getDefaultOrder());
+
+        timeSkeleton.insert(0, CAP_G);
+        pattern = DateFormat::getBestPattern(
+                locale, timeSkeleton, status);
+        if ( U_FAILURE(status) ) {
+            return;
+        }
+        setPatternInfo(UCAL_ERA, nullptr, &pattern, fInfo->getDefaultOrder());
     } else {
         /* if both present,
-         * 1) when the year, month, or day differs,
+         * 1) when the era, year, month, or day differs,
          * concatenate the two original expressions with a separator between,
          * 2) otherwise, present the date followed by the
          * range expression for the time.
          */
         /*
-         * 1) when the year, month, or day differs,
+         * 1) when the era, year, month, or day differs,
          * concatenate the two original expressions with a separator between,
          */
         // if field exists, use fall back
@@ -877,6 +933,11 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
             skeleton.insert(0, LOW_Y);
             setFallbackPattern(UCAL_YEAR, skeleton, status);
         }
+        if ( !fieldExistsInSkeleton(UCAL_ERA, dateSkeleton) ) {
+            // then prefix skeleton with 'G'
+            skeleton.insert(0, CAP_G);
+            setFallbackPattern(UCAL_ERA, skeleton, status);
+        }
 
         /*
          * 2) otherwise, present the date followed by the
@@ -899,6 +960,91 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
 
 
 
+UnicodeString
+DateIntervalFormat::normalizeHourMetacharacters(const UnicodeString& skeleton) const {
+    UnicodeString result = skeleton;
+
+    UChar hourMetachar = u'\0';
+    int32_t metacharStart = 0;
+    int32_t metacharCount = 0;
+    for (int32_t i = 0; i < result.length(); i++) {
+        UChar c = result[i];
+        if (c == LOW_J || c == CAP_J || c == CAP_C) {
+            if (hourMetachar == u'\0') {
+                hourMetachar = c;
+                metacharStart = i;
+            }
+            ++metacharCount;
+        } else {
+            if (hourMetachar != u'\0') {
+                break;
+            }
+        }
+    }
+
+    if (hourMetachar != u'\0') {
+        UErrorCode err = U_ZERO_ERROR;
+        UChar hourChar = CAP_H;
+        UChar dayPeriodChar = LOW_A;
+        UnicodeString convertedPattern = DateFormat::getBestPattern(fLocale, UnicodeString(hourMetachar), err);
+
+        if (U_SUCCESS(err)) {
+            // strip literal text from the pattern (so literal characters don't get mistaken for pattern
+            // characters-- such as the 'h' in 'Uhr' in Germam)
+            int32_t firstQuotePos;
+            while ((firstQuotePos = convertedPattern.indexOf(u'\'')) != -1) {
+                int32_t secondQuotePos = convertedPattern.indexOf(u'\'', firstQuotePos + 1);
+                if (secondQuotePos == -1) {
+                    secondQuotePos = firstQuotePos;
+                }
+                convertedPattern.replace(firstQuotePos, (secondQuotePos - firstQuotePos) + 1, UnicodeString());
+            }
+
+            if (convertedPattern.indexOf(LOW_H) != -1) {
+                hourChar = LOW_H;
+            } else if (convertedPattern.indexOf(CAP_K) != -1) {
+                hourChar = CAP_K;
+            } else if (convertedPattern.indexOf(LOW_K) != -1) {
+                hourChar = LOW_K;
+            }
+
+            if (convertedPattern.indexOf(LOW_B) != -1) {
+                dayPeriodChar = LOW_B;
+            } else if (convertedPattern.indexOf(CAP_B) != -1) {
+                dayPeriodChar = CAP_B;
+            }
+        }
+
+        if (hourChar == CAP_H || hourChar == LOW_K) {
+            result.replace(metacharStart, metacharCount, hourChar);
+        } else {
+            UnicodeString hourAndDayPeriod(hourChar);
+            switch (metacharCount) {
+                case 1:
+                case 2:
+                default:
+                    hourAndDayPeriod.append(UnicodeString(dayPeriodChar));
+                    break;
+                case 3:
+                case 4:
+                    for (int32_t i = 0; i < 4; i++) {
+                        hourAndDayPeriod.append(dayPeriodChar);
+                    }
+                    break;
+                case 5:
+                case 6:
+                    for (int32_t i = 0; i < 5; i++) {
+                        hourAndDayPeriod.append(dayPeriodChar);
+                    }
+                    break;
+            }
+            result.replace(metacharStart, metacharCount, hourAndDayPeriod);
+        }
+    }
+    return result;
+}
+
+
 void  U_EXPORT2
 DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
                                         UnicodeString& dateSkeleton,
@@ -911,11 +1057,10 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
     int32_t dCount = 0;
     int32_t MCount = 0;
     int32_t yCount = 0;
-    int32_t hCount = 0;
-    int32_t HCount = 0;
     int32_t mCount = 0;
     int32_t vCount = 0;
     int32_t zCount = 0;
+    UChar hourChar = u'\0';
     int32_t i;
 
     for (i = 0; i < skeleton.length(); ++i) {
@@ -956,17 +1101,14 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
             normalizedDateSkeleton.append(ch);
             dateSkeleton.append(ch);
             break;
-          case LOW_A:
-            // 'a' is implicitly handled
-            timeSkeleton.append(ch);
-            break;
           case LOW_H:
-            timeSkeleton.append(ch);
-            ++hCount;
-            break;
           case CAP_H:
+          case LOW_K:
+          case CAP_K:
             timeSkeleton.append(ch);
-            ++HCount;
+            if (hourChar == u'\0') {
+                hourChar = ch;
+            }
             break;
           case LOW_M:
             timeSkeleton.append(ch);
@@ -980,14 +1122,15 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
             ++vCount;
             timeSkeleton.append(ch);
             break;
+          case LOW_A:
           case CAP_V:
           case CAP_Z:
-          case LOW_K:
-          case CAP_K:
           case LOW_J:
           case LOW_S:
           case CAP_S:
           case CAP_A:
+          case LOW_B:
+          case CAP_B:
             timeSkeleton.append(ch);
             normalizedTimeSkeleton.append(ch);
             break;
@@ -1023,11 +1166,8 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
     }
 
     /* generate normalized form for time */
-    if ( HCount != 0 ) {
-        normalizedTimeSkeleton.append(CAP_H);
-    }
-    else if ( hCount != 0 ) {
-        normalizedTimeSkeleton.append(LOW_H);
+    if ( hourChar != u'\0' ) {
+        normalizedTimeSkeleton.append(hourChar);
     }
     if ( mCount != 0 ) {
         normalizedTimeSkeleton.append(LOW_M);
@@ -1303,7 +1443,11 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
         if ( field == UCAL_AM_PM ) {
             fInfo->getIntervalPattern(*bestSkeleton, UCAL_HOUR, pattern,status);
             if ( !pattern.isEmpty() ) {
-                setIntervalPattern(field, pattern);
+                UBool suppressDayPeriodField = fSkeleton.indexOf(CAP_J) != -1;
+                UnicodeString adjustIntervalPattern;
+                adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo,
+                                 suppressDayPeriodField, adjustIntervalPattern);
+                setIntervalPattern(field, adjustIntervalPattern);
             }
             return false;
         }
@@ -1335,10 +1479,11 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
         }
     }
     if ( !pattern.isEmpty() ) {
-        if ( differenceInfo != 0 ) {
+        UBool suppressDayPeriodField = fSkeleton.indexOf(CAP_J) != -1;
+        if ( differenceInfo != 0 || suppressDayPeriodField) {
             UnicodeString adjustIntervalPattern;
             adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo,
-                              adjustIntervalPattern);
+                              suppressDayPeriodField, adjustIntervalPattern);
             setIntervalPattern(field, adjustIntervalPattern);
         } else {
             setIntervalPattern(field, pattern);
@@ -1425,6 +1570,7 @@ DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern)
     return (i - count);
 }
 
+// The following is only called from fallbackFormat, i.e. within the gFormatterMutex lock
 void DateIntervalFormat::fallbackFormatRange(
         Calendar& fromCalendar,
         Calendar& toCalendar,
@@ -1441,12 +1587,15 @@ void DateIntervalFormat::fallbackFormatRange(
     int32_t offsets[2];
     UnicodeString patternBody = sf.getTextWithNoArguments(offsets, 2);
 
+    UErrorCode tempStatus = U_ZERO_ERROR; // for setContext, ignored
     // TODO(ICU-20406): Use SimpleFormatter Iterator interface when available.
     if (offsets[0] < offsets[1]) {
         firstIndex = 0;
         appendTo.append(patternBody.tempSubStringBetween(0, offsets[0]));
         fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
         appendTo.append(patternBody.tempSubStringBetween(offsets[0], offsets[1]));
+        // No capitalization for second part of interval
+        fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
         fDateFormat->_format(toCalendar, appendTo, fphandler, status);
         appendTo.append(patternBody.tempSubStringBetween(offsets[1]));
     } else {
@@ -1454,11 +1603,14 @@ void DateIntervalFormat::fallbackFormatRange(
         appendTo.append(patternBody.tempSubStringBetween(0, offsets[1]));
         fDateFormat->_format(toCalendar, appendTo, fphandler, status);
         appendTo.append(patternBody.tempSubStringBetween(offsets[1], offsets[0]));
+        // No capitalization for second part of interval
+        fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
         fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
         appendTo.append(patternBody.tempSubStringBetween(offsets[0]));
     }
 }
 
+// The following is only called from formatImpl, i.e. within the gFormatterMutex lock
 UnicodeString&
 DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
                                    Calendar& toCalendar,
@@ -1483,6 +1635,7 @@ DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
         UnicodeString fullPattern; // for saving the pattern in fDateFormat
         fDateFormat->toPattern(fullPattern); // save current pattern, restore later
 
+        UErrorCode tempStatus = U_ZERO_ERROR; // for setContext, ignored
         // {0} is time range
         // {1} is single date portion
         // TODO(ICU-20406): Use SimpleFormatter Iterator interface when available.
@@ -1492,6 +1645,8 @@ DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
             fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
             appendTo.append(patternBody.tempSubStringBetween(offsets[0], offsets[1]));
             fDateFormat->applyPattern(*fDatePattern);
+            // No capitalization for second portion
+            fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
             fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
             appendTo.append(patternBody.tempSubStringBetween(offsets[1]));
         } else {
@@ -1500,6 +1655,8 @@ DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
             fDateFormat->_format(fromCalendar, appendTo, fphandler, status);
             appendTo.append(patternBody.tempSubStringBetween(offsets[1], offsets[0]));
             fDateFormat->applyPattern(*fTimePattern);
+            // No capitalization for second portion
+            fDateFormat->setContext(UDISPCTX_CAPITALIZATION_NONE, tempStatus);
             fallbackFormatRange(fromCalendar, toCalendar, appendTo, firstIndex, fphandler, status);
             appendTo.append(patternBody.tempSubStringBetween(offsets[0]));
         }
@@ -1530,6 +1687,7 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
                  const UnicodeString& bestMatchSkeleton,
                  const UnicodeString& bestIntervalPattern,
                  int8_t differenceInfo,
+                 UBool suppressDayPeriodField,
                  UnicodeString& adjustedPtn) {
     adjustedPtn = bestIntervalPattern;
     int32_t inputSkeletonFieldWidth[] =
@@ -1556,19 +1714,40 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
     };
 
+    const int8_t PATTERN_CHAR_BASE = 0x41;
+
     DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth);
     DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth);
-    if ( differenceInfo == 2 ) {
-        adjustedPtn.findAndReplace(UnicodeString((UChar)0x76 /* v */),
-                                   UnicodeString((UChar)0x7a /* z */));
+    if (suppressDayPeriodField) {
+        findReplaceInPattern(adjustedPtn, UnicodeString(LOW_A), UnicodeString());
+        findReplaceInPattern(adjustedPtn, UnicodeString("  "), UnicodeString(" "));
+        adjustedPtn.trim();
     }
+    if ( differenceInfo == 2 ) {
+        if (inputSkeleton.indexOf(LOW_Z) != -1) {
+             findReplaceInPattern(adjustedPtn, UnicodeString(LOW_V), UnicodeString(LOW_Z));
+         }
+         if (inputSkeleton.indexOf(CAP_K) != -1) {
+             findReplaceInPattern(adjustedPtn, UnicodeString(LOW_H), UnicodeString(CAP_K));
+         }
+         if (inputSkeleton.indexOf(LOW_K) != -1) {
+             findReplaceInPattern(adjustedPtn, UnicodeString(CAP_H), UnicodeString(LOW_K));
+         }
+         if (inputSkeleton.indexOf(LOW_B) != -1) {
+             findReplaceInPattern(adjustedPtn, UnicodeString(LOW_A), UnicodeString(LOW_B));
+         }
+    }
+    if (adjustedPtn.indexOf(LOW_A) != -1 && bestMatchSkeletonFieldWidth[LOW_A - PATTERN_CHAR_BASE] == 0) {
+        bestMatchSkeletonFieldWidth[LOW_A - PATTERN_CHAR_BASE] = 1;
+    }
+    if (adjustedPtn.indexOf(LOW_B) != -1 && bestMatchSkeletonFieldWidth[LOW_B - PATTERN_CHAR_BASE] == 0) {
+        bestMatchSkeletonFieldWidth[LOW_B - PATTERN_CHAR_BASE] = 1;
+     }
 
     UBool inQuote = false;
     UChar prevCh = 0;
     int32_t count = 0;
 
-    const int8_t PATTERN_CHAR_BASE = 0x41;
-
     // loop through the pattern string character by character
     int32_t adjustedPtnLength = adjustedPtn.length();
     int32_t i;
@@ -1634,6 +1813,39 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
     }
 }
 
+void
+DateIntervalFormat::findReplaceInPattern(UnicodeString& targetString,
+                                         const UnicodeString& strToReplace,
+                                         const UnicodeString& strToReplaceWith) {
+    int32_t firstQuoteIndex = targetString.indexOf(u'\'');
+    if (firstQuoteIndex == -1) {
+        targetString.findAndReplace(strToReplace, strToReplaceWith);
+    } else {
+        UnicodeString result;
+        UnicodeString source = targetString;
+
+        while (firstQuoteIndex >= 0) {
+            int32_t secondQuoteIndex = source.indexOf(u'\'', firstQuoteIndex + 1);
+            if (secondQuoteIndex == -1) {
+                secondQuoteIndex = source.length() - 1;
+            }
+
+            UnicodeString unquotedText(source, 0, firstQuoteIndex);
+            UnicodeString quotedText(source, firstQuoteIndex, secondQuoteIndex - firstQuoteIndex + 1);
+
+            unquotedText.findAndReplace(strToReplace, strToReplaceWith);
+            result += unquotedText;
+            result += quotedText;
+
+            source.remove(0, secondQuoteIndex + 1);
+            firstQuoteIndex = source.indexOf(u'\'');
+        }
+        source.findAndReplace(strToReplace, strToReplaceWith);
+        result += source;
+        targetString = result;
+    }
+}
+
 
 
 void
diff --git a/deps/icu-small/source/i18n/dtitvinf.cpp b/deps/icu-small/source/i18n/dtitvinf.cpp
index 25536346ec74f03e3185c937cc7d52641dd04f44..39fd44a392d6942b5d1ffadcb16f982291069a94 100644
--- a/deps/icu-small/source/i18n/dtitvinf.cpp
+++ b/deps/icu-small/source/i18n/dtitvinf.cpp
@@ -339,6 +339,9 @@ struct DateIntervalInfo::DateIntervalSink : public ResourceSink {
                 return UCAL_DATE;
             } else if (c0 == 'a') {
                 return UCAL_AM_PM;
+            } else if (c0 == 'B') {
+                // TODO: Using AM/PM as a proxy for flexible day period isn't really correct, but it's close
+                return UCAL_AM_PM;
             } else if (c0 == 'h' || c0 == 'H') {
                 return UCAL_HOUR;
             } else if (c0 == 'm') {
@@ -594,20 +597,23 @@ DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton,
     const int32_t DIFFERENT_FIELD = 0x1000;
     const int32_t STRING_NUMERIC_DIFFERENCE = 0x100;
     const int32_t BASE = 0x41;
-    const UChar CHAR_V = 0x0076;
-    const UChar CHAR_Z = 0x007A;
 
-    // hack for 'v' and 'z'.
-    // resource bundle only have time skeletons ending with 'v',
-    // but not for time skeletons ending with 'z'.
-    UBool replaceZWithV = false;
+    // hack for certain alternate characters
+    // resource bundles only have time skeletons containing 'v', 'h', and 'H'
+    // but not time skeletons containing 'z', 'K', or 'k'
+    // the skeleton may also include 'a' or 'b', which never occur in the resource bundles, so strip them out too
+    UBool replacedAlternateChars = false;
     const UnicodeString* inputSkeleton = &skeleton;
     UnicodeString copySkeleton;
-    if ( skeleton.indexOf(CHAR_Z) != -1 ) {
+    if ( skeleton.indexOf(LOW_Z) != -1 || skeleton.indexOf(LOW_K) != -1 || skeleton.indexOf(CAP_K) != -1 || skeleton.indexOf(LOW_A) != -1 || skeleton.indexOf(LOW_B) != -1 ) {
         copySkeleton = skeleton;
-        copySkeleton.findAndReplace(UnicodeString(CHAR_Z), UnicodeString(CHAR_V));
+        copySkeleton.findAndReplace(UnicodeString(LOW_Z), UnicodeString(LOW_V));
+        copySkeleton.findAndReplace(UnicodeString(LOW_K), UnicodeString(CAP_H));
+        copySkeleton.findAndReplace(UnicodeString(CAP_K), UnicodeString(LOW_H));
+        copySkeleton.findAndReplace(UnicodeString(LOW_A), UnicodeString());
+        copySkeleton.findAndReplace(UnicodeString(LOW_B), UnicodeString());
         inputSkeleton = &copySkeleton;
-        replaceZWithV = true;
+        replacedAlternateChars = true;
     }
 
     parseSkeleton(*inputSkeleton, inputSkeletonFieldWidth);
@@ -616,7 +622,7 @@ DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton,
 
     // 0 means exact the same skeletons;
     // 1 means having the same field, but with different length,
-    // 2 means only z/v differs
+    // 2 means only z/v, h/K, or H/k differs
     // -1 means having different field.
     bestMatchDistanceInfo = 0;
     int8_t fieldLength = UPRV_LENGTHOF(skeletonFieldWidth);
@@ -672,7 +678,7 @@ DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton,
             break;
         }
     }
-    if ( replaceZWithV && bestMatchDistanceInfo != -1 ) {
+    if ( replacedAlternateChars && bestMatchDistanceInfo != -1 ) {
         bestMatchDistanceInfo = 2;
     }
     return bestSkeleton;
diff --git a/deps/icu-small/source/i18n/dtptngen.cpp b/deps/icu-small/source/i18n/dtptngen.cpp
index 279fb49a7aa9b9ef2ee45e5174404a15ed3754ec..78273ef01e2281b11e7f0b73685fd9bc7b962b31 100644
--- a/deps/icu-small/source/i18n/dtptngen.cpp
+++ b/deps/icu-small/source/i18n/dtptngen.cpp
@@ -311,6 +311,16 @@ DateTimePatternGenerator::createInstance(const Locale& locale, UErrorCode& statu
     return U_SUCCESS(status) ? result.orphan() : nullptr;
 }
 
+DateTimePatternGenerator* U_EXPORT2
+DateTimePatternGenerator::createInstanceNoStdPat(const Locale& locale, UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+    LocalPointer<DateTimePatternGenerator> result(
+            new DateTimePatternGenerator(locale, status, true), status);
+    return U_SUCCESS(status) ? result.orphan() : nullptr;
+}
+
 DateTimePatternGenerator*  U_EXPORT2
 DateTimePatternGenerator::createEmptyInstance(UErrorCode& status) {
     if (U_FAILURE(status)) {
@@ -336,7 +346,7 @@ DateTimePatternGenerator::DateTimePatternGenerator(UErrorCode &status) :
     }
 }
 
-DateTimePatternGenerator::DateTimePatternGenerator(const Locale& locale, UErrorCode &status) :
+DateTimePatternGenerator::DateTimePatternGenerator(const Locale& locale, UErrorCode &status, UBool skipStdPatterns) :
     skipMatcher(nullptr),
     fAvailableFormatKeyHash(nullptr),
     fDefaultHourFormatChar(0),
@@ -350,7 +360,7 @@ DateTimePatternGenerator::DateTimePatternGenerator(const Locale& locale, UErrorC
         internalErrorCode = status = U_MEMORY_ALLOCATION_ERROR;
     }
     else {
-        initData(locale, status);
+        initData(locale, status, skipStdPatterns);
     }
 }
 
@@ -489,13 +499,15 @@ enum AllowedHourFormat{
 }  // namespace
 
 void
-DateTimePatternGenerator::initData(const Locale& locale, UErrorCode &status) {
+DateTimePatternGenerator::initData(const Locale& locale, UErrorCode &status, UBool skipStdPatterns) {
     //const char *baseLangName = locale.getBaseName(); // unused
 
     skipMatcher = nullptr;
     fAvailableFormatKeyHash=nullptr;
     addCanonicalItems(status);
-    addICUPatterns(locale, status);
+    if (!skipStdPatterns) { // skip to prevent circular dependency when called from SimpleDateFormat::construct
+        addICUPatterns(locale, status);
+    }
     addCLDRData(locale, status);
     setDateTimeFromCalendar(locale, status);
     setDecimalSymbols(locale, status);
@@ -893,7 +905,7 @@ DateTimePatternGenerator::getCalendarTypeToUse(const Locale& locale, CharString&
             err = localStatus;
             return;
         }
-        if (calendarTypeLen < ULOC_KEYWORDS_CAPACITY) {
+        if (calendarTypeLen > 0 && calendarTypeLen < ULOC_KEYWORDS_CAPACITY) {
             destination.clear().append(calendarType, -1, err);
             if (U_FAILURE(err)) { return; }
         }
diff --git a/deps/icu-small/source/i18n/dtptngen_impl.h b/deps/icu-small/source/i18n/dtptngen_impl.h
index ade9f57331e769067d1361fc94655bf470ff91bf..9b9442d5787142ce577cea357c920cc6334ebac3 100644
--- a/deps/icu-small/source/i18n/dtptngen_impl.h
+++ b/deps/icu-small/source/i18n/dtptngen_impl.h
@@ -195,7 +195,7 @@ public:
     void getQuoteLiteral(UnicodeString& quote, int32_t *itemIndex);
     UBool isPatternSeparator(const UnicodeString& field) const;
     static UBool isQuoteLiteral(const UnicodeString& s);
-    static int32_t getCanonicalIndex(const UnicodeString& s) { return getCanonicalIndex(s, TRUE); }
+    static int32_t getCanonicalIndex(const UnicodeString& s) { return getCanonicalIndex(s, true); }
     static int32_t getCanonicalIndex(const UnicodeString& s, UBool strict);
 
 private:
diff --git a/deps/icu-small/source/i18n/fmtable.cpp b/deps/icu-small/source/i18n/fmtable.cpp
index 10a6fdb0ff34410ad8cb0488fbd05d24fc6c46b2..44c3087fb91aa681f6bcb8dea3b4bdef59bd8a8e 100644
--- a/deps/icu-small/source/i18n/fmtable.cpp
+++ b/deps/icu-small/source/i18n/fmtable.cpp
@@ -895,7 +895,7 @@ U_NAMESPACE_END
 
 U_NAMESPACE_USE
 
-U_DRAFT UFormattable* U_EXPORT2
+U_CAPI UFormattable* U_EXPORT2
 ufmt_open(UErrorCode *status) {
   if( U_FAILURE(*status) ) {
     return NULL;
@@ -908,14 +908,14 @@ ufmt_open(UErrorCode *status) {
   return fmt;
 }
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 ufmt_close(UFormattable *fmt) {
   Formattable *obj = Formattable::fromUFormattable(fmt);
 
   delete obj;
 }
 
-U_INTERNAL UFormattableType U_EXPORT2
+U_CAPI UFormattableType U_EXPORT2
 ufmt_getType(const UFormattable *fmt, UErrorCode *status) {
   if(U_FAILURE(*status)) {
     return (UFormattableType)UFMT_COUNT;
@@ -925,27 +925,27 @@ ufmt_getType(const UFormattable *fmt, UErrorCode *status) {
 }
 
 
-U_INTERNAL UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ufmt_isNumeric(const UFormattable *fmt) {
   const Formattable *obj = Formattable::fromUFormattable(fmt);
   return obj->isNumeric();
 }
 
-U_DRAFT UDate U_EXPORT2
+U_CAPI UDate U_EXPORT2
 ufmt_getDate(const UFormattable *fmt, UErrorCode *status) {
   const Formattable *obj = Formattable::fromUFormattable(fmt);
 
   return obj->getDate(*status);
 }
 
-U_DRAFT double U_EXPORT2
+U_CAPI double U_EXPORT2
 ufmt_getDouble(UFormattable *fmt, UErrorCode *status) {
   Formattable *obj = Formattable::fromUFormattable(fmt);
 
   return obj->getDouble(*status);
 }
 
-U_DRAFT int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ufmt_getLong(UFormattable *fmt, UErrorCode *status) {
   Formattable *obj = Formattable::fromUFormattable(fmt);
 
@@ -953,7 +953,7 @@ ufmt_getLong(UFormattable *fmt, UErrorCode *status) {
 }
 
 
-U_DRAFT const void *U_EXPORT2
+U_CAPI const void *U_EXPORT2
 ufmt_getObject(const UFormattable *fmt, UErrorCode *status) {
   const Formattable *obj = Formattable::fromUFormattable(fmt);
 
@@ -966,7 +966,7 @@ ufmt_getObject(const UFormattable *fmt, UErrorCode *status) {
   return ret;
 }
 
-U_DRAFT const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ufmt_getUChars(UFormattable *fmt, int32_t *len, UErrorCode *status) {
   Formattable *obj = Formattable::fromUFormattable(fmt);
 
@@ -986,7 +986,7 @@ ufmt_getUChars(UFormattable *fmt, int32_t *len, UErrorCode *status) {
   return str.getTerminatedBuffer();
 }
 
-U_DRAFT int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ufmt_getArrayLength(const UFormattable* fmt, UErrorCode *status) {
   const Formattable *obj = Formattable::fromUFormattable(fmt);
 
@@ -995,7 +995,7 @@ ufmt_getArrayLength(const UFormattable* fmt, UErrorCode *status) {
   return count;
 }
 
-U_DRAFT UFormattable * U_EXPORT2
+U_CAPI UFormattable * U_EXPORT2
 ufmt_getArrayItemByIndex(UFormattable* fmt, int32_t n, UErrorCode *status) {
   Formattable *obj = Formattable::fromUFormattable(fmt);
   int32_t count;
@@ -1010,7 +1010,7 @@ ufmt_getArrayItemByIndex(UFormattable* fmt, int32_t n, UErrorCode *status) {
   }
 }
 
-U_DRAFT const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ufmt_getDecNumChars(UFormattable *fmt, int32_t *len, UErrorCode *status) {
   if(U_FAILURE(*status)) {
     return "";
@@ -1031,7 +1031,7 @@ ufmt_getDecNumChars(UFormattable *fmt, int32_t *len, UErrorCode *status) {
   }
 }
 
-U_DRAFT int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 ufmt_getInt64(UFormattable *fmt, UErrorCode *status) {
   Formattable *obj = Formattable::fromUFormattable(fmt);
   return obj->getInt64(*status);
diff --git a/deps/icu-small/source/i18n/fmtable_cnv.cpp b/deps/icu-small/source/i18n/fmtable_cnv.cpp
index 9a647927797dbdc5d3e48468d26e53cb9536b54e..bc3847b6963e705aadbf5b4f7031cd03d1cf3455 100644
--- a/deps/icu-small/source/i18n/fmtable_cnv.cpp
+++ b/deps/icu-small/source/i18n/fmtable_cnv.cpp
@@ -30,8 +30,6 @@ U_NAMESPACE_BEGIN
 // -------------------------------------
 // Creates a formattable object with a char* string.
 // This API is useless. The API that takes a UnicodeString is actually just as good.
-// This is just a grandfathered API.
-
 Formattable::Formattable(const char* stringToCopy)
 {
     init();
diff --git a/deps/icu-small/source/i18n/format.cpp b/deps/icu-small/source/i18n/format.cpp
index e5abbe9eb0fa7dad2c3e9ed470fe9df9593603a6..a010defff93c4095be424e4cfd5fe339b6703631 100644
--- a/deps/icu-small/source/i18n/format.cpp
+++ b/deps/icu-small/source/i18n/format.cpp
@@ -26,7 +26,7 @@
 #include "unicode/utypes.h"
 
 #ifndef U_I18N_IMPLEMENTATION
-#error U_I18N_IMPLEMENTATION not set - must be set for all ICU source files in i18n/ - see http://userguide.icu-project.org/howtouseicu
+#error U_I18N_IMPLEMENTATION not set - must be set for all ICU source files in i18n/ - see https://unicode-org.github.io/icu/userguide/howtouseicu
 #endif
 
 /*
diff --git a/deps/icu-small/source/i18n/formatted_string_builder.cpp b/deps/icu-small/source/i18n/formatted_string_builder.cpp
index 5aabc31cc4391b117f79d7b2e00a8d71ca7dee51..b370f14f2ac4ff0873e5614376ae51fe0232b02d 100644
--- a/deps/icu-small/source/i18n/formatted_string_builder.cpp
+++ b/deps/icu-small/source/i18n/formatted_string_builder.cpp
@@ -276,6 +276,11 @@ int32_t FormattedStringBuilder::prepareForInsertHelper(int32_t index, int32_t co
     char16_t *oldChars = getCharPtr();
     Field *oldFields = getFieldPtr();
     if (fLength + count > oldCapacity) {
+        if ((fLength + count) > INT32_MAX / 2) {
+            // If we continue, then newCapacity will overlow int32_t in the next line.
+            status = U_INPUT_TOO_LONG_ERROR;
+            return -1;
+        }
         int32_t newCapacity = (fLength + count) * 2;
         int32_t newZero = newCapacity / 2 - (fLength + count) / 2;
 
@@ -330,12 +335,14 @@ int32_t FormattedStringBuilder::prepareForInsertHelper(int32_t index, int32_t co
         fZero = newZero;
         fLength += count;
     }
+    U_ASSERT((fZero + index) >= 0);
     return fZero + index;
 }
 
 int32_t FormattedStringBuilder::remove(int32_t index, int32_t count) {
     // TODO: Reset the heap here?  (If the string after removal can fit on stack?)
     int32_t position = index + fZero;
+    U_ASSERT(position >= 0);
     uprv_memmove2(getCharPtr() + position,
             getCharPtr() + position + count,
             sizeof(char16_t) * (fLength - index - count));
diff --git a/deps/icu-small/source/i18n/formatted_string_builder.h b/deps/icu-small/source/i18n/formatted_string_builder.h
index 4567dc1d66b0ce3534ca0574eda7b9fe4a9e3e8d..92bcf07d782cde78b96fa317e0e85fd6d66d5958 100644
--- a/deps/icu-small/source/i18n/formatted_string_builder.h
+++ b/deps/icu-small/source/i18n/formatted_string_builder.h
@@ -25,7 +25,7 @@ class FormattedValueStringBuilderImpl;
  *
  * <ol>
  * <li>Efficient prepend as well as append.
- * <li>Keeps tracks of Fields in an efficient manner.
+ * <li>Keeps track of Fields in an efficient manner.
  * </ol>
  *
  * See also FormattedValueStringBuilderImpl.
@@ -55,7 +55,6 @@ class U_I18N_API FormattedStringBuilder : public UMemory {
     // Convention: bottom 4 bits for field, top 4 bits for field category.
     // Field category 0 implies the number category so that the number field
     // literals can be directly passed as a Field type.
-    // See the helper functions in "StringBuilderFieldUtils" below.
     // Exported as U_I18N_API so it can be used by other exports on Windows.
     struct U_I18N_API Field {
         uint8_t bits;
diff --git a/deps/icu-small/source/i18n/formattedval_impl.h b/deps/icu-small/source/i18n/formattedval_impl.h
index 73ae9a3ea2ab3aded35696c92edadc92acdbcb4f..c43c1020d1ef26d08bc91d7a64c8fd2ff1751598 100644
--- a/deps/icu-small/source/i18n/formattedval_impl.h
+++ b/deps/icu-small/source/i18n/formattedval_impl.h
@@ -69,6 +69,9 @@ U_NAMESPACE_BEGIN
 
 /**
  * Implementation of FormattedValue using FieldPositionHandler to accept fields.
+ *
+ * TODO(ICU-20897): This class is unused. If it is not needed when fixing ICU-20897,
+ * it should be deleted.
  */
 class FormattedValueFieldPositionIteratorImpl : public UMemory, public FormattedValue {
 public:
@@ -114,6 +117,26 @@ private:
 };
 
 
+// Internal struct that must be exported for MSVC
+struct U_I18N_API SpanInfo {
+    UFieldCategory category;
+    int32_t spanValue;
+    int32_t start;
+    int32_t length;
+};
+
+// Export an explicit template instantiation of the MaybeStackArray that
+//    is used as a data member of CEBuffer.
+//
+//    When building DLLs for Windows this is required even though
+//    no direct access to the MaybeStackArray leaks out of the i18n library.
+//
+// See digitlst.h, pluralaffix.h, datefmt.h, and others for similar examples.
+//
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<SpanInfo, 8>;
+#endif
+
 /**
  * Implementation of FormattedValue based on FormattedStringBuilder.
  *
@@ -147,12 +170,26 @@ public:
         return fString;
     }
 
+    /**
+     * Adds additional metadata used for span fields.
+     *
+     * category: the category to use for the span field.
+     * spanValue: the value of the span field: index of the list item, for example.
+     * start: the start position within the string of the span. -1 if unknown.
+     * length: the length of the span, used to split adjacent fields.
+     */
+    void appendSpanInfo(UFieldCategory category, int32_t spanValue, int32_t start, int32_t length, UErrorCode& status);
+    void prependSpanInfo(UFieldCategory category, int32_t spanValue, int32_t start, int32_t length, UErrorCode& status);
+
 private:
     FormattedStringBuilder fString;
     FormattedStringBuilder::Field fNumericField;
+    MaybeStackArray<SpanInfo, 8> spanIndices;
+    int32_t spanIndicesCount = 0;
 
     bool nextPositionImpl(ConstrainedFieldPosition& cfpos, FormattedStringBuilder::Field numericField, UErrorCode& status) const;
     static bool isIntOrGroup(FormattedStringBuilder::Field field);
+    static bool isTrimmable(FormattedStringBuilder::Field field);
     int32_t trimBack(int32_t limit) const;
     int32_t trimFront(int32_t start) const;
 };
@@ -211,7 +248,7 @@ struct UFormattedValueImpl : public UMemory, public UFormattedValueApiHelper {
         return fData->appendTo(appendable, status); \
     } \
     UBool Name::nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const { \
-        UPRV_FORMATTED_VALUE_METHOD_GUARD(FALSE) \
+        UPRV_FORMATTED_VALUE_METHOD_GUARD(false) \
         return fData->nextPosition(cfpos, status); \
     }
 
@@ -230,7 +267,7 @@ struct UFormattedValueImpl : public UMemory, public UFormattedValueApiHelper {
         } \
         return static_cast<HelperType*>(impl)->exportForC(); \
     } \
-    U_DRAFT const UFormattedValue* U_EXPORT2 \
+    U_CAPI const UFormattedValue* U_EXPORT2 \
     Prefix ## _resultAsValue (const CType* uresult, UErrorCode* ec) { \
         const ImplType* result = HelperType::validate(uresult, *ec); \
         if (U_FAILURE(*ec)) { return nullptr; } \
diff --git a/deps/icu-small/source/i18n/formattedval_sbimpl.cpp b/deps/icu-small/source/i18n/formattedval_sbimpl.cpp
index dfe3af6686df2f6bcb980ffa2f59aa5beb16512b..9ec06daf3ea41e8ba794becdd3c1de5609878b5b 100644
--- a/deps/icu-small/source/i18n/formattedval_sbimpl.cpp
+++ b/deps/icu-small/source/i18n/formattedval_sbimpl.cpp
@@ -15,6 +15,7 @@
 #include "formatted_string_builder.h"
 #include "number_utils.h"
 #include "static_unicode_sets.h"
+#include "unicode/listformatter.h"
 
 U_NAMESPACE_BEGIN
 
@@ -45,19 +46,19 @@ Appendable& FormattedValueStringBuilderImpl::appendTo(Appendable& appendable, UE
 
 UBool FormattedValueStringBuilderImpl::nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const {
     // NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
-    return nextPositionImpl(cfpos, fNumericField, status) ? TRUE : FALSE;
+    return nextPositionImpl(cfpos, fNumericField, status) ? true : false;
 }
 
 UBool FormattedValueStringBuilderImpl::nextFieldPosition(FieldPosition& fp, UErrorCode& status) const {
     int32_t rawField = fp.getField();
 
     if (rawField == FieldPosition::DONT_CARE) {
-        return FALSE;
+        return false;
     }
 
     if (rawField < 0 || rawField >= UNUM_FIELD_COUNT) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
-        return FALSE;
+        return false;
     }
 
     ConstrainedFieldPosition cfpos;
@@ -66,7 +67,7 @@ UBool FormattedValueStringBuilderImpl::nextFieldPosition(FieldPosition& fp, UErr
     if (nextPositionImpl(cfpos, kUndefinedField, status)) {
         fp.setBeginIndex(cfpos.getStart());
         fp.setEndIndex(cfpos.getLimit());
-        return TRUE;
+        return true;
     }
 
     // Special case: fraction should start after integer if fraction is not present
@@ -84,7 +85,7 @@ UBool FormattedValueStringBuilderImpl::nextFieldPosition(FieldPosition& fp, UErr
         fp.setEndIndex(i - fString.fZero);
     }
 
-    return FALSE;
+    return false;
 }
 
 void FormattedValueStringBuilderImpl::getAllFieldPositions(FieldPositionIteratorHandler& fpih,
@@ -102,6 +103,27 @@ static constexpr Field kEndField = Field(0xf, 0xf);
 bool FormattedValueStringBuilderImpl::nextPositionImpl(ConstrainedFieldPosition& cfpos, Field numericField, UErrorCode& /*status*/) const {
     int32_t fieldStart = -1;
     Field currField = kUndefinedField;
+    bool prevIsSpan = false;
+    int32_t nextSpanStart = -1;
+    if (spanIndicesCount > 0) {
+        int64_t si = cfpos.getInt64IterationContext();
+        U_ASSERT(si <= spanIndicesCount);
+        if (si < spanIndicesCount) {
+            nextSpanStart = spanIndices[si].start;
+        }
+        if (si > 0) {
+            prevIsSpan = cfpos.getCategory() == spanIndices[si-1].category
+                && cfpos.getField() == spanIndices[si-1].spanValue;
+        }
+    }
+    bool prevIsNumeric = false;
+    if (numericField != kUndefinedField) {
+        prevIsNumeric = cfpos.getCategory() == numericField.getCategory()
+            && cfpos.getField() == numericField.getField();
+    }
+    bool prevIsInteger = cfpos.getCategory() == UFIELD_CATEGORY_NUMBER
+        && cfpos.getField() == UNUM_INTEGER_FIELD;
+
     for (int32_t i = fString.fZero + cfpos.getLimit(); i <= fString.fZero + fString.fLength; i++) {
         Field _field = (i < fString.fZero + fString.fLength) ? fString.getFieldPtr()[i] : kEndField;
         // Case 1: currently scanning a field.
@@ -109,7 +131,7 @@ bool FormattedValueStringBuilderImpl::nextPositionImpl(ConstrainedFieldPosition&
             if (currField != _field) {
                 int32_t end = i - fString.fZero;
                 // Grouping separators can be whitespace; don't throw them out!
-                if (currField != Field(UFIELD_CATEGORY_NUMBER, UNUM_GROUPING_SEPARATOR_FIELD)) {
+                if (isTrimmable(currField)) {
                     end = trimBack(i - fString.fZero);
                 }
                 if (end <= fieldStart) {
@@ -120,7 +142,7 @@ bool FormattedValueStringBuilderImpl::nextPositionImpl(ConstrainedFieldPosition&
                     continue;
                 }
                 int32_t start = fieldStart;
-                if (currField != Field(UFIELD_CATEGORY_NUMBER, UNUM_GROUPING_SEPARATOR_FIELD)) {
+                if (isTrimmable(currField)) {
                     start = trimFront(start);
                 }
                 cfpos.setState(currField.getCategory(), currField.getField(), start, end);
@@ -128,11 +150,38 @@ bool FormattedValueStringBuilderImpl::nextPositionImpl(ConstrainedFieldPosition&
             }
             continue;
         }
+        // Special case: emit normalField if we are pointing at the end of spanField.
+        if (i > fString.fZero && prevIsSpan) {
+            int64_t si = cfpos.getInt64IterationContext() - 1;
+            U_ASSERT(si >= 0);
+            int32_t previ = i - spanIndices[si].length;
+            U_ASSERT(previ >= fString.fZero);
+            Field prevField = fString.getFieldPtr()[previ];
+            if (prevField == Field(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD)) {
+                // Special handling for ULISTFMT_ELEMENT_FIELD
+                if (cfpos.matchesField(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD)) {
+                    fieldStart = i - fString.fZero - spanIndices[si].length;
+                    int32_t end = fieldStart + spanIndices[si].length;
+                    cfpos.setState(
+                        UFIELD_CATEGORY_LIST,
+                        ULISTFMT_ELEMENT_FIELD,
+                        fieldStart,
+                        end);
+                    return true;
+                } else {
+                    prevIsSpan = false;
+                }
+            } else {
+                // Re-wind, since there may be multiple fields in the span.
+                i = previ;
+                _field = prevField;
+            }
+        }
         // Special case: coalesce the INTEGER if we are pointing at the end of the INTEGER.
         if (cfpos.matchesField(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD)
                 && i > fString.fZero
-                // don't return the same field twice in a row:
-                && i - fString.fZero > cfpos.getLimit()
+                && !prevIsInteger
+                && !prevIsNumeric
                 && isIntOrGroup(fString.getFieldPtr()[i - 1])
                 && !isIntOrGroup(_field)) {
             int j = i - 1;
@@ -148,13 +197,11 @@ bool FormattedValueStringBuilderImpl::nextPositionImpl(ConstrainedFieldPosition&
         if (numericField != kUndefinedField
                 && cfpos.matchesField(numericField.getCategory(), numericField.getField())
                 && i > fString.fZero
-                // don't return the same field twice in a row:
-                && (i - fString.fZero > cfpos.getLimit()
-                    || cfpos.getCategory() != numericField.getCategory()
-                    || cfpos.getField() != numericField.getField())
+                && !prevIsNumeric
                 && fString.getFieldPtr()[i - 1].isNumeric()
                 && !_field.isNumeric()) {
-            int j = i - 1;
+            // Re-wind to the beginning of the field and then emit it
+            int32_t j = i - 1;
             for (; j >= fString.fZero && fString.getFieldPtr()[j].isNumeric(); j--) {}
             cfpos.setState(
                 numericField.getCategory(),
@@ -163,30 +210,116 @@ bool FormattedValueStringBuilderImpl::nextPositionImpl(ConstrainedFieldPosition&
                 i - fString.fZero);
             return true;
         }
+        // Check for span field
+        if (!prevIsSpan && (
+                _field == Field(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD) ||
+                i - fString.fZero == nextSpanStart)) {
+            int64_t si = cfpos.getInt64IterationContext();
+            if (si >= spanIndicesCount) {
+                break;
+            }
+            UFieldCategory spanCategory = spanIndices[si].category;
+            int32_t spanValue = spanIndices[si].spanValue;
+            int32_t length = spanIndices[si].length;
+            cfpos.setInt64IterationContext(si + 1);
+            if (si + 1 < spanIndicesCount) {
+                nextSpanStart = spanIndices[si + 1].start;
+            }
+            if (cfpos.matchesField(spanCategory, spanValue)) {
+                fieldStart = i - fString.fZero;
+                int32_t end = fieldStart + length;
+                cfpos.setState(
+                    spanCategory,
+                    spanValue,
+                    fieldStart,
+                    end);
+                return true;
+            } else if (_field == Field(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD)) {
+                // Special handling for ULISTFMT_ELEMENT_FIELD
+                if (cfpos.matchesField(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD)) {
+                    fieldStart = i - fString.fZero;
+                    int32_t end = fieldStart + length;
+                    cfpos.setState(
+                        UFIELD_CATEGORY_LIST,
+                        ULISTFMT_ELEMENT_FIELD,
+                        fieldStart,
+                        end);
+                    return true;
+                } else {
+                    // Failed to match; jump ahead
+                    i += length - 1;
+                    // goto loopend
+                }
+            }
+        }
         // Special case: skip over INTEGER; will be coalesced later.
-        if (_field == Field(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD)) {
+        else if (_field == Field(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD)) {
             _field = kUndefinedField;
         }
-        // Case 2: no field starting at this position.
-        if (_field.isUndefined() || _field == kEndField) {
-            continue;
+        // No field starting at this position.
+        else if (_field.isUndefined() || _field == kEndField) {
+            // goto loopend
         }
-        // Case 3: check for field starting at this position
-        if (cfpos.matchesField(_field.getCategory(), _field.getField())) {
+        // No SpanField
+        else if (cfpos.matchesField(_field.getCategory(), _field.getField())) {
             fieldStart = i - fString.fZero;
             currField = _field;
         }
+        // loopend:
+        prevIsSpan = false;
+        prevIsNumeric = false;
+        prevIsInteger = false;
     }
 
     U_ASSERT(currField == kUndefinedField);
+    // Always set the position to the end so that we don't revisit previous sections
+    cfpos.setState(
+        cfpos.getCategory(),
+        cfpos.getField(),
+        fString.fLength,
+        fString.fLength);
     return false;
 }
 
+void FormattedValueStringBuilderImpl::appendSpanInfo(UFieldCategory category, int32_t spanValue, int32_t start, int32_t length, UErrorCode& status) {
+    if (U_FAILURE(status)) { return; }
+    U_ASSERT(spanIndices.getCapacity() >= spanValue);
+    if (spanIndices.getCapacity() == spanValue) {
+        if (!spanIndices.resize(spanValue * 2, spanValue)) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+    }
+    spanIndices[spanValue] = {category, spanValue, start, length};
+    spanIndicesCount++;
+}
+
+void FormattedValueStringBuilderImpl::prependSpanInfo(UFieldCategory category, int32_t spanValue, int32_t start, int32_t length, UErrorCode& status) {
+    if (U_FAILURE(status)) { return; }
+    U_ASSERT(spanIndices.getCapacity() >= spanValue);
+    if (spanIndices.getCapacity() == spanValue) {
+        if (!spanIndices.resize(spanValue * 2, spanValue)) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+    }
+    for (int32_t i = spanValue - 1; i >= 0; i--) {
+        spanIndices[i+1] = spanIndices[i];
+    }
+    spanIndices[0] = {category, spanValue, start, length};
+    spanIndicesCount++;
+}
+
 bool FormattedValueStringBuilderImpl::isIntOrGroup(Field field) {
     return field == Field(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD)
         || field == Field(UFIELD_CATEGORY_NUMBER, UNUM_GROUPING_SEPARATOR_FIELD);
 }
 
+bool FormattedValueStringBuilderImpl::isTrimmable(Field field) {
+    return field != Field(UFIELD_CATEGORY_NUMBER, UNUM_GROUPING_SEPARATOR_FIELD)
+        && field.getCategory() != UFIELD_CATEGORY_LIST;
+}
+
 int32_t FormattedValueStringBuilderImpl::trimBack(int32_t limit) const {
     return unisets::get(unisets::DEFAULT_IGNORABLES)->spanBack(
         fString.getCharPtr() + fString.fZero,
diff --git a/deps/icu-small/source/i18n/formattedvalue.cpp b/deps/icu-small/source/i18n/formattedvalue.cpp
index e2c9c42fc88a36b4a5fde48969c2984be52510f5..79ecf0a841cf9b34300d0b8441571a7d298fa820 100644
--- a/deps/icu-small/source/i18n/formattedvalue.cpp
+++ b/deps/icu-small/source/i18n/formattedvalue.cpp
@@ -193,7 +193,7 @@ ucfpos_close(UConstrainedFieldPosition* ptr) {
 }
 
 
-U_DRAFT const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ufmtval_getString(
         const UFormattedValue* ufmtval,
         int32_t* pLength,
@@ -213,7 +213,7 @@ ufmtval_getString(
 }
 
 
-U_DRAFT UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ufmtval_nextPosition(
         const UFormattedValue* ufmtval,
         UConstrainedFieldPosition* ucfpos,
diff --git a/deps/icu-small/source/i18n/fphdlimp.h b/deps/icu-small/source/i18n/fphdlimp.h
index b9fa9b218149d4d9aacc05f91b3eda3dd17c98cc..4fb0c7b6fe686e8039300047afef574c38c97b74 100644
--- a/deps/icu-small/source/i18n/fphdlimp.h
+++ b/deps/icu-small/source/i18n/fphdlimp.h
@@ -41,8 +41,8 @@ class U_I18N_API FieldPositionHandler: public UMemory {
 
 class FieldPositionOnlyHandler : public FieldPositionHandler {
   FieldPosition& pos;
-  UBool acceptFirstOnly = FALSE;
-  UBool seenFirst = FALSE;
+  UBool acceptFirstOnly = false;
+  UBool seenFirst = false;
 
  public:
   FieldPositionOnlyHandler(FieldPosition& pos);
diff --git a/deps/icu-small/source/i18n/gregocal.cpp b/deps/icu-small/source/i18n/gregocal.cpp
index 028ab05aa9accc38bd6368428b33e15e0ecc2622..36f7bb933285bdb10f0316e7207ccf626c7f38c4 100644
--- a/deps/icu-small/source/i18n/gregocal.cpp
+++ b/deps/icu-small/source/i18n/gregocal.cpp
@@ -185,7 +185,7 @@ fIsGregorian(TRUE), fInvertGregorian(FALSE)
 // -------------------------------------
 
 GregorianCalendar::GregorianCalendar(const Locale& aLocale, UErrorCode& status)
-:   Calendar(TimeZone::createDefault(), aLocale, status),
+:   Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, status),
 fGregorianCutover(kPapalCutover),
 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
 fIsGregorian(TRUE), fInvertGregorian(FALSE)
@@ -398,7 +398,7 @@ void GregorianCalendar::handleComputeFields(int32_t julianDay, UErrorCode& statu
         // with 8 AD.  Before 8 AD the spacing is irregular; every 3 years
         // from 45 BC to 9 BC, and then none until 8 AD.  However, we don't
         // implement this historical detail; instead, we implement the
-        // computatinally cleaner proleptic calendar, which assumes
+        // computationally cleaner proleptic calendar, which assumes
         // consistent 4-year cycles throughout time.
         UBool isLeap = ((eyear&0x3) == 0); // equiv. to (eyear%4 == 0)
 
diff --git a/deps/icu-small/source/i18n/gregoimp.h b/deps/icu-small/source/i18n/gregoimp.h
index eb3844f8523eebb32444ba6306ef08b0e94f2a16..edcae9dbcc65ff35bdb886ed149229ad9b11c149 100644
--- a/deps/icu-small/source/i18n/gregoimp.h
+++ b/deps/icu-small/source/i18n/gregoimp.h
@@ -148,9 +148,9 @@ class ClockMath {
 class Grego {
  public:
     /**
-     * Return TRUE if the given year is a leap year.
+     * Return true if the given year is a leap year.
      * @param year Gregorian year, with 0 == 1 BCE, -1 == 2 BCE, etc.
-     * @return TRUE if the year is a leap year
+     * @return true if the year is a leap year
      */
     static inline UBool isLeapYear(int32_t year);
 
diff --git a/deps/icu-small/source/i18n/hebrwcal.cpp b/deps/icu-small/source/i18n/hebrwcal.cpp
index 085ded784651a6c1691cb8b55d793c73822f5786..98cbb4a1050d0135425ed8a73b6ca8bd3f194b43 100644
--- a/deps/icu-small/source/i18n/hebrwcal.cpp
+++ b/deps/icu-small/source/i18n/hebrwcal.cpp
@@ -155,7 +155,7 @@ U_NAMESPACE_BEGIN
 * @internal
 */
 HebrewCalendar::HebrewCalendar(const Locale& aLocale, UErrorCode& success)
-:   Calendar(TimeZone::createDefault(), aLocale, success)
+:   Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success)
 
 {
     setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
@@ -393,7 +393,8 @@ int32_t HebrewCalendar::startOfYear(int32_t year, UErrorCode &status)
     int32_t day = CalendarCache::get(&gCache, year, status);
 
     if (day == 0) {
-        int32_t months = (235 * year - 234) / 19;           // # of months before year
+        // # of months before year
+        int32_t months = (int32_t)ClockMath::floorDivide((235 * (int64_t)year - 234), (int64_t)19);
 
         int64_t frac = (int64_t)months * MONTH_FRACT + BAHARAD;  // Fractional part of day #
         day  = months * 29 + (int32_t)(frac / DAY_PARTS);        // Whole # part of calculation
@@ -566,8 +567,8 @@ void HebrewCalendar::validateField(UCalendarDateFields field, UErrorCode &status
 */
 void HebrewCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) {
     int32_t d = julianDay - 347997;
-    double m = ((d * (double)DAY_PARTS)/ (double) MONTH_PARTS);         // Months (approx)
-    int32_t year = (int32_t)( ((19. * m + 234.) / 235.) + 1.);     // Years (approx)
+    double m = ClockMath::floorDivide((d * (double)DAY_PARTS), (double) MONTH_PARTS);  // Months (approx)
+    int32_t year = (int32_t)(ClockMath::floorDivide((19. * m + 234.), 235.) + 1.);     // Years (approx)
     int32_t ys  = startOfYear(year, status);                   // 1st day of year
     int32_t dayOfYear = (d - ys);
 
diff --git a/deps/icu-small/source/i18n/hebrwcal.h b/deps/icu-small/source/i18n/hebrwcal.h
index 97e8511705e776d4c2bc121177e09c1a1cf10ad0..34450ffa61855dd76f37be19403b9ef8919b8420 100644
--- a/deps/icu-small/source/i18n/hebrwcal.h
+++ b/deps/icu-small/source/i18n/hebrwcal.h
@@ -386,7 +386,7 @@ public:
   virtual UBool inDaylightTime(UErrorCode& status) const;
 
     /**
-     * Returns TRUE because the Hebrew Calendar does have a default century
+     * Returns true because the Hebrew Calendar does have a default century
      * @internal
      */
     virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/indiancal.cpp b/deps/icu-small/source/i18n/indiancal.cpp
index f1266bb7757939875db71a2439a14860133239ff..42a91c55e2f526a545a383d18da7519bd90d9486 100644
--- a/deps/icu-small/source/i18n/indiancal.cpp
+++ b/deps/icu-small/source/i18n/indiancal.cpp
@@ -40,7 +40,7 @@ IndianCalendar* IndianCalendar::clone() const {
 }
 
 IndianCalendar::IndianCalendar(const Locale& aLocale, UErrorCode& success)
-  :   Calendar(TimeZone::createDefault(), aLocale, success)
+  :   Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success)
 {
   setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
 }
@@ -83,7 +83,6 @@ static const int32_t LIMITS[UCAL_FIELD_COUNT][4] = {
     {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // IS_LEAP_MONTH
 };
 
-static const double JULIAN_EPOCH = 1721425.5;
 static const int32_t INDIAN_ERA_START  = 78;
 static const int32_t INDIAN_YEAR_START = 80;
 
@@ -96,7 +95,7 @@ int32_t IndianCalendar::handleGetLimit(UCalendarDateFields field, ELimitType lim
  */
 static UBool isGregorianLeap(int32_t year)
 {
-    return ((year % 4) == 0) && (!(((year % 100) == 0) && ((year % 400) != 0)));
+    return Grego::isLeapYear(year);
 }
 
 //----------------------------------------------------------------------
@@ -137,56 +136,22 @@ int32_t IndianCalendar::handleGetYearLength(int32_t eyear) const {
  * Returns the Julian Day corresponding to gregorian date
  *
  * @param year The Gregorian year
- * @param month The month in Gregorian Year
+ * @param month The month in Gregorian Year, 0 based.
  * @param date The date in Gregorian day in month
  */
 static double gregorianToJD(int32_t year, int32_t month, int32_t date) {
-   double julianDay = (JULIAN_EPOCH - 1) +
-      (365 * (year - 1)) +
-      uprv_floor((year - 1) / 4) +
-      (-uprv_floor((year - 1) / 100)) +
-      uprv_floor((year - 1) / 400) +
-      uprv_floor((((367 * month) - 362) / 12) +
-            ((month <= 2) ? 0 :
-             (isGregorianLeap(year) ? -1 : -2)
-            ) +
-            date);
-
-   return julianDay;
+   return Grego::fieldsToDay(year, month, date) + kEpochStartAsJulianDay - 0.5;
 }
 
 /*
  * Returns the Gregorian Date corresponding to a given Julian Day
+ * Month is 0 based.
  * @param jd The Julian Day
  */
 static int32_t* jdToGregorian(double jd, int32_t gregorianDate[3]) {
-   double wjd, depoch, quadricent, dqc, cent, dcent, quad, dquad, yindex, yearday, leapadj;
-   int32_t year, month, day;
-   wjd = uprv_floor(jd - 0.5) + 0.5;
-   depoch = wjd - JULIAN_EPOCH;
-   quadricent = uprv_floor(depoch / 146097);
-   dqc = (int32_t)uprv_floor(depoch) % 146097;
-   cent = uprv_floor(dqc / 36524);
-   dcent = (int32_t)uprv_floor(dqc) % 36524;
-   quad = uprv_floor(dcent / 1461);
-   dquad = (int32_t)uprv_floor(dcent) % 1461;
-   yindex = uprv_floor(dquad / 365);
-   year = (int32_t)((quadricent * 400) + (cent * 100) + (quad * 4) + yindex);
-   if (!((cent == 4) || (yindex == 4))) {
-      year++;
-   }
-   yearday = wjd - gregorianToJD(year, 1, 1);
-   leapadj = ((wjd < gregorianToJD(year, 3, 1)) ? 0
-         :
-         (isGregorianLeap(year) ? 1 : 2)
-         );
-   month = (int32_t)uprv_floor((((yearday + leapadj) * 12) + 373) / 367);
-   day = (int32_t)(wjd - gregorianToJD(year, month, 1)) + 1;
-
-   gregorianDate[0] = year;
-   gregorianDate[1] = month;
-   gregorianDate[2] = day;
-
+   int32_t gdow;
+   Grego::dayToFields(jd - kEpochStartAsJulianDay,
+                      gregorianDate[0], gregorianDate[1], gregorianDate[2], gdow);
    return gregorianDate;
 }
 
@@ -203,11 +168,11 @@ static double IndianToJD(int32_t year, int32_t month, int32_t date) {
 
    if(isGregorianLeap(gyear)) {
       leapMonth = 31;
-      start = gregorianToJD(gyear, 3, 21);
+      start = gregorianToJD(gyear, 2 /* The third month in 0 based month */, 21);
    }
    else {
       leapMonth = 30;
-      start = gregorianToJD(gyear, 3, 22);
+      start = gregorianToJD(gyear, 2 /* The third month in 0 based month */, 22);
    }
 
    if (month == 1) {
@@ -297,7 +262,7 @@ void IndianCalendar::handleComputeFields(int32_t julianDay, UErrorCode&  /* stat
 
     gregorianYear = jdToGregorian(julianDay, gd)[0];          // Gregorian date for Julian day
     IndianYear = gregorianYear - INDIAN_ERA_START;            // Year in Saka era
-    jdAtStartOfGregYear = gregorianToJD(gregorianYear, 1, 1); // JD at start of Gregorian year
+    jdAtStartOfGregYear = gregorianToJD(gregorianYear, 0, 1); // JD at start of Gregorian year
     yday = (int32_t)(julianDay - jdAtStartOfGregYear);        // Day number in Gregorian year (starting from 0)
 
     if (yday < INDIAN_YEAR_START) {
diff --git a/deps/icu-small/source/i18n/indiancal.h b/deps/icu-small/source/i18n/indiancal.h
index 142597ce0e6b025a67b5457a2af0a6906220da83..1a06ebde408e9e5570fe8aeefc05e39727731250 100644
--- a/deps/icu-small/source/i18n/indiancal.h
+++ b/deps/icu-small/source/i18n/indiancal.h
@@ -25,7 +25,7 @@ U_NAMESPACE_BEGIN
  * Concrete class which provides the Indian calendar.
  * <P>
  * <code>IndianCalendar</code> is a subclass of <code>Calendar</code>
- * that numbers years since the begining of SAKA ERA.  This is the civil calendar
+ * that numbers years since the beginning of SAKA ERA.  This is the civil calendar
  * which is accepted by government of India as Indian National Calendar.
  * The two calendars most widely used in India today are the Vikrama calendar
  * followed in North India and the Shalivahana or Saka calendar which is followed
@@ -147,7 +147,7 @@ public:
    * @param aLocale  The given locale.
    * @param success  Indicates the status of IndianCalendar object construction.
    *                 Returns U_ZERO_ERROR if constructed successfully.
-   * @param beCivil  Whether the calendar should be civil (default-TRUE) or religious (FALSE)
+   * @param beCivil  Whether the calendar should be civil (default-true) or religious (false)
    * @internal
    */
   IndianCalendar(const Locale& aLocale, UErrorCode &success);
@@ -303,7 +303,7 @@ protected:
 
 
   /**
-   * Returns TRUE because the Indian Calendar does have a default century
+   * Returns true because the Indian Calendar does have a default century
    * @internal
    */
   virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/islamcal.cpp b/deps/icu-small/source/i18n/islamcal.cpp
index 4e4a6648048208da77bf1985b393bea4274a3592..6e21e51150ab885a7ff0d73091a4f366f2738ea5 100644
--- a/deps/icu-small/source/i18n/islamcal.cpp
+++ b/deps/icu-small/source/i18n/islamcal.cpp
@@ -232,7 +232,7 @@ IslamicCalendar* IslamicCalendar::clone() const {
 }
 
 IslamicCalendar::IslamicCalendar(const Locale& aLocale, UErrorCode& success, ECalculationType type)
-:   Calendar(TimeZone::createDefault(), aLocale, success),
+:   Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success),
 cType(type)
 {
     setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
@@ -368,7 +368,7 @@ int32_t IslamicCalendar::yearStart(int32_t year) const{
     if (cType == CIVIL || cType == TBLA ||
         (cType == UMALQURA && (year < UMALQURA_YEAR_START || year > UMALQURA_YEAR_END)))
     {
-        return (year-1)*354 + ClockMath::floorDivide((3+11*year),30);
+        return (year-1)*354 + ClockMath::floorDivide((3+11*(int64_t)year),(int64_t)30);
     } else if(cType==ASTRONOMICAL){
         return trueMonthStart(12*(year-1));
     } else {
@@ -391,7 +391,7 @@ int32_t IslamicCalendar::monthStart(int32_t year, int32_t month) const {
     if (cType == CIVIL || cType == TBLA) {
         // This does not handle months out of the range 0..11
         return (int32_t)uprv_ceil(29.5*month)
-            + (year-1)*354 + (int32_t)ClockMath::floorDivide((3+11*year),30);
+            + (year-1)*354 + (int32_t)ClockMath::floorDivide((3+11*(int64_t)year),(int64_t)30);
     } else if(cType==ASTRONOMICAL){
         return trueMonthStart(12*(year-1) + month);
     } else {
@@ -447,7 +447,8 @@ int32_t IslamicCalendar::trueMonthStart(int32_t month) const
                 }
             } while (age < 0);
         }
-        start = (int32_t)ClockMath::floorDivide((origin - HIJRA_MILLIS), (double)kOneDay) + 1;
+        start = (int32_t)(ClockMath::floorDivide(
+            (int64_t)((int64_t)origin - HIJRA_MILLIS), (int64_t)kOneDay) + 1);
         CalendarCache::put(&gMonthCache, month, start, status);
     }
 trueMonthStartEnd :
@@ -639,13 +640,14 @@ void IslamicCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status)
             months--;
         }
 
-        year = months / 12 + 1;
-        month = months % 12;
+        year = months >=  0 ? ((months / 12) + 1) : ((months + 1 ) / 12);
+        month = ((months % 12) + 12 ) % 12;
     } else if(cType == UMALQURA) {
         int32_t umalquraStartdays = yearStart(UMALQURA_YEAR_START) ;
         if( days < umalquraStartdays){
                 //Use Civil calculation
-                year  = (int)ClockMath::floorDivide( (double)(30 * days + 10646) , 10631.0 );
+                year  = (int32_t)ClockMath::floorDivide(
+                    (30 * (int64_t)days + 10646) , (int64_t)10631.0 );
                 month = (int32_t)uprv_ceil((days - 29 - yearStart(year)) / 29.5 );
                 month = month<11?month:11;
                 startDate = monthStart(year, month);
diff --git a/deps/icu-small/source/i18n/islamcal.h b/deps/icu-small/source/i18n/islamcal.h
index aad8f07be0f984042c1cf6d00310ffa8fb1d8524..e12e04a6b9c8b4d4a66d7abdcb53defffbb30f85 100644
--- a/deps/icu-small/source/i18n/islamcal.h
+++ b/deps/icu-small/source/i18n/islamcal.h
@@ -67,7 +67,7 @@ U_NAMESPACE_BEGIN
  * moon's illumination, and other factors, it is possible to determine the start
  * of a lunar month with a fairly high degree of certainty.  However, these
  * calculations are extremely complicated and thus slow, so most algorithms,
- * including the one used here, are only approximations of the true astronical
+ * including the one used here, are only approximations of the true astronomical
  * calculations.  At present, the approximations used in this class are fairly
  * simplistic; they will be improved in later versions of the code.
  * <p>
@@ -395,7 +395,7 @@ class U_I18N_API IslamicCalendar : public Calendar {
 
 
   /**
-   * Returns TRUE because the Islamic Calendar does have a default century
+   * Returns true because the Islamic Calendar does have a default century
    * @internal
    */
   virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/japancal.h b/deps/icu-small/source/i18n/japancal.h
index ee86c4ed0e3b936f5cabb9148d5bba16a5c89624..d313fcd99ab50848ae9704d8709d370aca730855 100644
--- a/deps/icu-small/source/i18n/japancal.h
+++ b/deps/icu-small/source/i18n/japancal.h
@@ -167,7 +167,7 @@ public:
     virtual const char * getType() const;
 
     /**
-     * @return FALSE - no default century in Japanese
+     * @return false - no default century in Japanese
      * @internal
      */
     virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/listformatter.cpp b/deps/icu-small/source/i18n/listformatter.cpp
index 4b27587555219cb9397d12a18a10b84fa5a086e0..e5c01c0ab32c2b968f7e8a921da82e31622f10c7 100644
--- a/deps/icu-small/source/i18n/listformatter.cpp
+++ b/deps/icu-small/source/i18n/listformatter.cpp
@@ -16,6 +16,10 @@
 *   created by: Umesh P. Nair
 */
 
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
 #include "cmemory.h"
 #include "unicode/fpositer.h"  // FieldPositionIterator
 #include "unicode/listformatter.h"
@@ -52,10 +56,12 @@ public:
 
     virtual PatternHandler* clone() const { return new PatternHandler(twoPattern, endPattern); }
 
+    /** Argument: final string in the list. */
     virtual const SimpleFormatter& getTwoPattern(const UnicodeString&) const {
         return twoPattern;
     }
 
+    /** Argument: final string in the list. */
     virtual const SimpleFormatter& getEndPattern(const UnicodeString&) const {
         return endPattern;
     }
@@ -169,21 +175,21 @@ PatternHandler* createPatternHandler(
     UErrorCode& status) {
     if (uprv_strcmp(lang, "es") == 0) {
         // Spanish
-        UnicodeString spanishYStr(TRUE, spanishY, -1);
+        UnicodeString spanishYStr(true, spanishY, -1);
         bool twoIsY = two == spanishYStr;
         bool endIsY = end == spanishYStr;
         if (twoIsY || endIsY) {
-            UnicodeString replacement(TRUE, spanishE, -1);
+            UnicodeString replacement(true, spanishE, -1);
             return new ContextualHandler(
                 shouldChangeToE,
                 twoIsY ? replacement : two, two,
                 endIsY ? replacement : end, end, status);
         }
-        UnicodeString spanishOStr(TRUE, spanishO, -1);
+        UnicodeString spanishOStr(true, spanishO, -1);
         bool twoIsO = two == spanishOStr;
         bool endIsO = end == spanishOStr;
         if (twoIsO || endIsO) {
-            UnicodeString replacement(TRUE, spanishU, -1);
+            UnicodeString replacement(true, spanishU, -1);
             return new ContextualHandler(
                 shouldChangeToU,
                 twoIsO ? replacement : two, two,
@@ -191,11 +197,11 @@ PatternHandler* createPatternHandler(
         }
     } else if (uprv_strcmp(lang, "he") == 0 || uprv_strcmp(lang, "iw") == 0) {
         // Hebrew
-        UnicodeString hebrewVavStr(TRUE, hebrewVav, -1);
+        UnicodeString hebrewVavStr(true, hebrewVav, -1);
         bool twoIsVav = two == hebrewVavStr;
         bool endIsVav = end == hebrewVavStr;
         if (twoIsVav || endIsVav) {
-            UnicodeString replacement(TRUE, hebrewVavDash, -1);
+            UnicodeString replacement(true, hebrewVavDash, -1);
             return new ContextualHandler(
                 shouldChangeToVavDash,
                 twoIsVav ? replacement : two, two,
@@ -236,17 +242,15 @@ ListFormatInternal(const ListFormatInternal &other) :
 };
 
 
-#if !UCONFIG_NO_FORMATTING
-class FormattedListData : public FormattedValueFieldPositionIteratorImpl {
+class FormattedListData : public FormattedValueStringBuilderImpl {
 public:
-    FormattedListData(UErrorCode& status) : FormattedValueFieldPositionIteratorImpl(5, status) {}
+    FormattedListData(UErrorCode&) : FormattedValueStringBuilderImpl(kUndefinedField) {}
     virtual ~FormattedListData();
 };
 
 FormattedListData::~FormattedListData() = default;
 
 UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedList)
-#endif
 
 
 static Hashtable* listPatternHash = nullptr;
@@ -255,7 +259,7 @@ U_CDECL_BEGIN
 static UBool U_CALLCONV uprv_listformatter_cleanup() {
     delete listPatternHash;
     listPatternHash = nullptr;
-    return TRUE;
+    return true;
 }
 
 static void U_CALLCONV
@@ -348,7 +352,6 @@ const ListFormatInternal* ListFormatter::getListFormatInternal(
     return result;
 }
 
-#if !UCONFIG_NO_FORMATTING
 static const char* typeWidthToStyleString(UListFormatterType type, UListFormatterWidth width) {
     switch (type) {
         case ULISTFMT_TYPE_AND:
@@ -392,7 +395,6 @@ static const char* typeWidthToStyleString(UListFormatterType type, UListFormatte
 
     return nullptr;
 }
-#endif
 
 static const UChar solidus = 0x2F;
 static const UChar aliasPrefix[] = { 0x6C,0x69,0x73,0x74,0x50,0x61,0x74,0x74,0x65,0x72,0x6E,0x2F }; // "listPattern/"
@@ -513,14 +515,9 @@ ListFormatter* ListFormatter::createInstance(UErrorCode& errorCode) {
 }
 
 ListFormatter* ListFormatter::createInstance(const Locale& locale, UErrorCode& errorCode) {
-#if !UCONFIG_NO_FORMATTING
     return createInstance(locale, ULISTFMT_TYPE_AND, ULISTFMT_WIDTH_WIDE, errorCode);
-#else
-    return createInstance(locale, "standard", errorCode);
-#endif
 }
 
-#if !UCONFIG_NO_FORMATTING
 ListFormatter* ListFormatter::createInstance(
         const Locale& locale, UListFormatterType type, UListFormatterWidth width, UErrorCode& errorCode) {
     const char* style = typeWidthToStyleString(type, width);
@@ -530,7 +527,6 @@ ListFormatter* ListFormatter::createInstance(
     }
     return createInstance(locale, style, errorCode);
 }
-#endif
 
 ListFormatter* ListFormatter::createInstance(const Locale& locale, const char *style, UErrorCode& errorCode) {
     const ListFormatInternal* listFormatInternal = getListFormatInternal(locale, style, errorCode);
@@ -557,50 +553,89 @@ ListFormatter::~ListFormatter() {
     delete owned;
 }
 
-/**
- * Joins first and second using the pattern pat.
- * On entry offset is an offset into first or -1 if offset unspecified.
- * On exit offset is offset of second in result if recordOffset was set
- * Otherwise if it was >=0 it is set to point into result where it used
- * to point into first. On exit, result is the join of first and second
- * according to pat. Any previous value of result gets replaced.
- */
-static void joinStringsAndReplace(
-        const SimpleFormatter& pat,
-        const UnicodeString& first,
-        const UnicodeString& second,
-        UnicodeString &result,
-        UBool recordOffset,
-        int32_t &offset,
-        int32_t *offsetFirst,
-        int32_t *offsetSecond,
-        UErrorCode& errorCode) {
-    if (U_FAILURE(errorCode)) {
-        return;
-    }
-    const UnicodeString *params[2] = {&first, &second};
-    int32_t offsets[2];
-    pat.formatAndReplace(
-            params,
-            UPRV_LENGTHOF(params),
-            result,
-            offsets,
-            UPRV_LENGTHOF(offsets),
-            errorCode);
-    if (U_FAILURE(errorCode)) {
-        return;
+namespace {
+
+class FormattedListBuilder {
+public:
+    LocalPointer<FormattedListData> data;
+
+    /** For lists of length 1+ */
+    FormattedListBuilder(const UnicodeString& start, UErrorCode& status)
+            : data(new FormattedListData(status), status) {
+        if (U_SUCCESS(status)) {
+            data->getStringRef().append(
+                start,
+                {UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD},
+                status);
+            data->appendSpanInfo(UFIELD_CATEGORY_LIST_SPAN, 0, -1, start.length(), status);
+        }
     }
-    if (offsets[0] == -1 || offsets[1] == -1) {
-        errorCode = U_INVALID_FORMAT_ERROR;
-        return;
+
+    /** For lists of length 0 */
+    FormattedListBuilder(UErrorCode& status)
+            : data(new FormattedListData(status), status) {
     }
-    if (recordOffset) {
-        offset = offsets[1];
-    } else if (offset >= 0) {
-        offset += offsets[0];
+
+    void append(const SimpleFormatter& pattern, const UnicodeString& next, int32_t position, UErrorCode& status) {
+        if (U_FAILURE(status)) {
+            return;
+        }
+        if (pattern.getArgumentLimit() != 2) {
+            status = U_INTERNAL_PROGRAM_ERROR;
+            return;
+        }
+        // In the pattern, {0} are the pre-existing elements and {1} is the new element.
+        int32_t offsets[] = {0, 0};
+        UnicodeString temp = pattern.getTextWithNoArguments(offsets, 2);
+        if (offsets[0] <= offsets[1]) {
+            // prefix{0}infix{1}suffix
+            // Prepend prefix, then append infix, element, and suffix
+            data->getStringRef().insert(
+                0,
+                temp.tempSubStringBetween(0, offsets[0]),
+                {UFIELD_CATEGORY_LIST, ULISTFMT_LITERAL_FIELD},
+                status);
+            data->getStringRef().append(
+                temp.tempSubStringBetween(offsets[0], offsets[1]),
+                {UFIELD_CATEGORY_LIST, ULISTFMT_LITERAL_FIELD},
+                status);
+            data->getStringRef().append(
+                next,
+                {UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD},
+                status);
+            data->appendSpanInfo(UFIELD_CATEGORY_LIST_SPAN, position, -1, next.length(), status);
+            data->getStringRef().append(
+                temp.tempSubString(offsets[1]),
+                {UFIELD_CATEGORY_LIST, ULISTFMT_LITERAL_FIELD},
+                status);
+        } else {
+            // prefix{1}infix{0}suffix
+            // Prepend infix, element, and prefix, then append suffix.
+            // (We prepend in reverse order because prepending at index 0 is fast.)
+            data->getStringRef().insert(
+                0,
+                temp.tempSubStringBetween(offsets[1], offsets[0]),
+                {UFIELD_CATEGORY_LIST, ULISTFMT_LITERAL_FIELD},
+                status);
+            data->getStringRef().insert(
+                0,
+                next,
+                {UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD},
+                status);
+            data->prependSpanInfo(UFIELD_CATEGORY_LIST_SPAN, position, -1, next.length(), status);
+            data->getStringRef().insert(
+                0,
+                temp.tempSubStringBetween(0, offsets[1]),
+                {UFIELD_CATEGORY_LIST, ULISTFMT_LITERAL_FIELD},
+                status);
+            data->getStringRef().append(
+                temp.tempSubString(offsets[0]),
+                {UFIELD_CATEGORY_LIST, ULISTFMT_LITERAL_FIELD},
+                status);
+        }
     }
-    if (offsetFirst != nullptr) *offsetFirst = offsets[0];
-    if (offsetSecond != nullptr) *offsetSecond = offsets[1];
+};
+
 }
 
 UnicodeString& ListFormatter::format(
@@ -619,190 +654,86 @@ UnicodeString& ListFormatter::format(
         int32_t index,
         int32_t &offset,
         UErrorCode& errorCode) const {
-  return format_(items, nItems, appendTo, index, offset, nullptr, errorCode);
+    int32_t initialOffset = appendTo.length();
+    auto result = formatStringsToValue(items, nItems, errorCode);
+    UnicodeStringAppendable appendable(appendTo);
+    result.appendTo(appendable, errorCode);
+    if (index >= 0) {
+        ConstrainedFieldPosition cfpos;
+        cfpos.constrainField(UFIELD_CATEGORY_LIST_SPAN, index);
+        result.nextPosition(cfpos, errorCode);
+        offset = initialOffset + cfpos.getStart();
+    }
+    return appendTo;
 }
 
-#if !UCONFIG_NO_FORMATTING
 FormattedList ListFormatter::formatStringsToValue(
         const UnicodeString items[],
         int32_t nItems,
         UErrorCode& errorCode) const {
-    LocalPointer<FormattedListData> result(new FormattedListData(errorCode), errorCode);
-    if (U_FAILURE(errorCode)) {
-        return FormattedList(errorCode);
+    if (nItems == 0) {
+        FormattedListBuilder result(errorCode);
+        if (U_FAILURE(errorCode)) {
+            return FormattedList(errorCode);
+        } else {
+            return FormattedList(result.data.orphan());
+        }
+    } else if (nItems == 1) {
+        FormattedListBuilder result(items[0], errorCode);
+        result.data->getStringRef().writeTerminator(errorCode);
+        if (U_FAILURE(errorCode)) {
+            return FormattedList(errorCode);
+        } else {
+            return FormattedList(result.data.orphan());
+        }
+    } else if (nItems == 2) {
+        FormattedListBuilder result(items[0], errorCode);
+        if (U_FAILURE(errorCode)) {
+            return FormattedList(errorCode);
+        }
+        result.append(
+            data->patternHandler->getTwoPattern(items[1]),
+            items[1],
+            1,
+            errorCode);
+        result.data->getStringRef().writeTerminator(errorCode);
+        if (U_FAILURE(errorCode)) {
+            return FormattedList(errorCode);
+        } else {
+            return FormattedList(result.data.orphan());
+        }
     }
-    UnicodeString string;
-    int32_t offset;
-    auto handler = result->getHandler(errorCode);
-    handler.setCategory(UFIELD_CATEGORY_LIST);
-    format_(items, nItems, string, -1, offset, &handler, errorCode);
-    handler.getError(errorCode);
-    result->appendString(string, errorCode);
+
+    FormattedListBuilder result(items[0], errorCode);
     if (U_FAILURE(errorCode)) {
         return FormattedList(errorCode);
     }
-
-    // Add span fields and sort
-    ConstrainedFieldPosition cfpos;
-    cfpos.constrainField(UFIELD_CATEGORY_LIST, ULISTFMT_ELEMENT_FIELD);
-    int32_t i = 0;
-    handler.setCategory(UFIELD_CATEGORY_LIST_SPAN);
-    while (result->nextPosition(cfpos, errorCode)) {
-        handler.addAttribute(i++, cfpos.getStart(), cfpos.getLimit());
+    result.append(
+        data->startPattern,
+        items[1],
+        1,
+        errorCode);
+    for (int32_t i = 2; i < nItems - 1; i++) {
+        result.append(
+            data->middlePattern,
+            items[i],
+            i,
+            errorCode);
     }
-    handler.getError(errorCode);
+    result.append(
+        data->patternHandler->getEndPattern(items[nItems-1]),
+        items[nItems-1],
+        nItems-1,
+        errorCode);
+    result.data->getStringRef().writeTerminator(errorCode);
     if (U_FAILURE(errorCode)) {
         return FormattedList(errorCode);
-    }
-    result->sort();
-
-    return FormattedList(result.orphan());
-}
-#endif
-
-UnicodeString& ListFormatter::format_(
-        const UnicodeString items[],
-        int32_t nItems,
-        UnicodeString& appendTo,
-        int32_t index,
-        int32_t &offset,
-        FieldPositionHandler* handler,
-        UErrorCode& errorCode) const {
-#if !UCONFIG_NO_FORMATTING
-    offset = -1;
-    if (U_FAILURE(errorCode)) {
-        return appendTo;
-    }
-    if (data == nullptr) {
-        errorCode = U_INVALID_STATE_ERROR;
-        return appendTo;
-    }
-
-    if (nItems <= 0) {
-        return appendTo;
-    }
-    if (nItems == 1) {
-        if (index == 0) {
-            offset = appendTo.length();
-        }
-        if (handler != nullptr) {
-            handler->addAttribute(ULISTFMT_ELEMENT_FIELD,
-                                  appendTo.length(),
-                                  appendTo.length() + items[0].length());
-        }
-        appendTo.append(items[0]);
-        return appendTo;
-    }
-    UnicodeString result(items[0]);
-    if (index == 0) {
-        offset = 0;
-    }
-    int32_t offsetFirst = 0;
-    int32_t offsetSecond = 0;
-    int32_t prefixLength = 0;
-    // for n items, there are 2 * (n + 1) boundary including 0 and the upper
-    // edge.
-    MaybeStackArray<int32_t, 10> offsets((handler != nullptr) ? 2 * (nItems + 1): 0);
-    if (nItems == 2) {
-        joinStringsAndReplace(
-                data->patternHandler->getTwoPattern(items[1]),
-                result,
-                items[1],
-                result,
-                index == 1,
-                offset,
-                &offsetFirst,
-                &offsetSecond,
-                errorCode);
     } else {
-        joinStringsAndReplace(
-                data->startPattern,
-                result,
-                items[1],
-                result,
-                index == 1,
-                offset,
-                &offsetFirst,
-                &offsetSecond,
-                errorCode);
-    }
-    if (handler != nullptr) {
-        offsets[0] = 0;
-        prefixLength += offsetFirst;
-        offsets[1] = offsetSecond - prefixLength;
-    }
-    if (nItems > 2) {
-        for (int32_t i = 2; i < nItems - 1; ++i) {
-             joinStringsAndReplace(
-                     data->middlePattern,
-                     result,
-                     items[i],
-                     result,
-                     index == i,
-                     offset,
-                     &offsetFirst,
-                     &offsetSecond,
-                     errorCode);
-            if (handler != nullptr) {
-                prefixLength += offsetFirst;
-                offsets[i] = offsetSecond - prefixLength;
-            }
-        }
-        joinStringsAndReplace(
-                data->patternHandler->getEndPattern(items[nItems - 1]),
-                result,
-                items[nItems - 1],
-                result,
-                index == nItems - 1,
-                offset,
-                &offsetFirst,
-                &offsetSecond,
-                errorCode);
-        if (handler != nullptr) {
-            prefixLength += offsetFirst;
-            offsets[nItems - 1] = offsetSecond - prefixLength;
-        }
-    }
-    if (handler != nullptr) {
-        // If there are already some data in appendTo, we need to adjust the index
-        // by shifting that lenght while insert into handler.
-        int32_t shift = appendTo.length() + prefixLength;
-        // Output the ULISTFMT_ELEMENT_FIELD in the order of the input elements
-        for (int32_t i = 0; i < nItems; ++i) {
-            offsets[i + nItems] = offsets[i] + items[i].length() + shift;
-            offsets[i] += shift;
-            handler->addAttribute(
-                ULISTFMT_ELEMENT_FIELD,  // id
-                offsets[i],  // index
-                offsets[i + nItems]);  // limit
-        }
-        // The locale pattern may reorder the items (such as in ur-IN locale),
-        // so we cannot assume the array is in accendning order.
-        // To handle the edging case, just insert the two ends into the array
-        // and sort. Then we output ULISTFMT_LITERAL_FIELD if the indecies
-        // between the even and odd position are not the same in the sorted array.
-        offsets[2 * nItems] = shift - prefixLength;
-        offsets[2 * nItems + 1] = result.length() + shift - prefixLength;
-        uprv_sortArray(offsets.getAlias(), 2 * (nItems + 1), sizeof(int32_t),
-               uprv_int32Comparator, nullptr,
-               false, &errorCode);
-        for (int32_t i = 0; i <= nItems; ++i) {
-          if (offsets[i * 2] != offsets[i * 2 + 1]) {
-            handler->addAttribute(
-                ULISTFMT_LITERAL_FIELD,  // id
-                offsets[i * 2],  // index
-                offsets[i * 2 + 1]);  // limit
-          }
-        }
-    }
-    if (U_SUCCESS(errorCode)) {
-        if (offset >= 0) {
-            offset += appendTo.length();
-        }
-        appendTo += result;
+        return FormattedList(result.data.orphan());
     }
-#endif
-    return appendTo;
 }
 
+
 U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/measfmt.cpp b/deps/icu-small/source/i18n/measfmt.cpp
index a98a6dda4705b516f0d8219f19173f1660c1b09a..6334c6f9fdf235100d41c07164293aebdcafc7f7 100644
--- a/deps/icu-small/source/i18n/measfmt.cpp
+++ b/deps/icu-small/source/i18n/measfmt.cpp
@@ -581,7 +581,10 @@ void MeasureFormat::initMeasureFormat(
         UMeasureFormatWidth w,
         NumberFormat *nfToAdopt,
         UErrorCode &status) {
-    static const char *listStyles[] = {"unit", "unit-short", "unit-narrow"};
+    static const UListFormatterWidth listWidths[] = {
+        ULISTFMT_WIDTH_WIDE,
+        ULISTFMT_WIDTH_SHORT,
+        ULISTFMT_WIDTH_NARROW};
     LocalPointer<NumberFormat> nf(nfToAdopt);
     if (U_FAILURE(status)) {
         return;
@@ -620,7 +623,8 @@ void MeasureFormat::initMeasureFormat(
     delete listFormatter;
     listFormatter = ListFormatter::createInstance(
             locale,
-            listStyles[getRegularWidth(fWidth)],
+            ULISTFMT_TYPE_UNITS,
+            listWidths[getRegularWidth(fWidth)],
             status);
 }
 
@@ -861,7 +865,7 @@ UnicodeString &MeasureFormat::formatMeasuresSlowTrack(
         return appendTo;
     }
     // Fix up FieldPosition indexes if our field is found.
-    if (offset != -1) {
+    if (fieldPositionFoundIndex != -1 && offset != -1) {
         pos.setBeginIndex(fpos.getBeginIndex() + offset);
         pos.setEndIndex(fpos.getEndIndex() + offset);
     }
diff --git a/deps/icu-small/source/i18n/measunit.cpp b/deps/icu-small/source/i18n/measunit.cpp
index 2486ca9b15a05e9474d3d1a7a8774ac593a6e666..f57495e65a1b641ecdae9b24f9e005339fd93459 100644
--- a/deps/icu-small/source/i18n/measunit.cpp
+++ b/deps/icu-small/source/i18n/measunit.cpp
@@ -33,62 +33,37 @@ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MeasureUnit)
 // update this code, refer to:
 // http://site.icu-project.org/design/formatting/measureformat/updating-measure-unit
 //
-// Start generated code
-
+// Start generated code for measunit.cpp
 
+// Maps from Type ID to offset in gSubTypes.
 static const int32_t gOffsets[] = {
     0,
     2,
     7,
     17,
-    25,
-    29,
-    328,
-    339,
-    355,
-    359,
-    368,
-    370,
-    374,
-    381,
-    402,
-    404,
-    418,
-    421,
-    427,
-    437,
+    26,
+    30,
+    329,
+    340,
+    356,
+    360,
+    369,
+    371,
+    375,
+    383,
+    405,
+    409,
+    424,
+    425,
+    431,
     441,
     445,
-    447,
-    474
+    449,
+    451,
+    485
 };
 
-static const int32_t gIndexes[] = {
-    0,
-    2,
-    7,
-    17,
-    25,
-    29,
-    29,
-    40,
-    56,
-    60,
-    69,
-    71,
-    75,
-    82,
-    103,
-    105,
-    119,
-    122,
-    128,
-    138,
-    142,
-    146,
-    148,
-    175
-};
+static const int32_t kCurrencyOffset = 5;
 
 // Must be sorted alphabetically.
 static const char * const gTypes[] = {
@@ -137,6 +112,7 @@ static const char * const gSubTypes[] = {
     "square-mile",
     "square-yard",
     "karat",
+    "milligram-ofglucose-per-deciliter",
     "milligram-per-deciliter",
     "millimole-per-liter",
     "mole",
@@ -493,6 +469,7 @@ static const char * const gSubTypes[] = {
     "hertz",
     "kilohertz",
     "megahertz",
+    "dot",
     "dot-per-centimeter",
     "dot-per-inch",
     "em",
@@ -503,6 +480,7 @@ static const char * const gSubTypes[] = {
     "astronomical-unit",
     "centimeter",
     "decimeter",
+    "earth-radius",
     "fathom",
     "foot",
     "furlong",
@@ -521,11 +499,14 @@ static const char * const gSubTypes[] = {
     "point",
     "solar-radius",
     "yard",
+    "candela",
+    "lumen",
     "lux",
     "solar-luminosity",
     "carat",
     "dalton",
     "earth-mass",
+    "grain",
     "gram",
     "kilogram",
     "metric-ton",
@@ -537,9 +518,7 @@ static const char * const gSubTypes[] = {
     "solar-mass",
     "stone",
     "ton",
-    "", // TODO(ICU-21076): manual edit of what should have been generated by Java.
-    "percent", // TODO(ICU-21076): regenerate, deal with duplication.
-    "permille", // TODO(ICU-21076): regenerate, deal with duplication.
+    "",
     "gigawatt",
     "horsepower",
     "kilowatt",
@@ -580,35 +559,28 @@ static const char * const gSubTypes[] = {
     "cup",
     "cup-metric",
     "deciliter",
+    "dessert-spoon",
+    "dessert-spoon-imperial",
+    "dram",
+    "drop",
     "fluid-ounce",
     "fluid-ounce-imperial",
     "gallon",
     "gallon-imperial",
     "hectoliter",
+    "jigger",
     "liter",
     "megaliter",
     "milliliter",
+    "pinch",
     "pint",
     "pint-metric",
     "quart",
+    "quart-imperial",
     "tablespoon",
     "teaspoon"
 };
 
-// Must be sorted by first value and then second value.
-static int32_t unitPerUnitToSingleUnit[][4] = {
-        {378, 382, 12, 5},
-        {378, 387, 12, 6},
-        {388, 343, 19, 0},
-        {390, 350, 19, 2},
-        {392, 343, 19, 3},
-        {392, 463, 4, 2},
-        {392, 464, 4, 3},
-        {411, 460, 3, 1},
-        {414, 12, 18, 9},
-        {466, 388, 4, 1}
-};
-
 // Shortcuts to the base unit in order to make the default constructor fast
 static const int32_t kBaseTypeIdx = 16;
 static const int32_t kBaseSubTypeIdx = 0;
@@ -757,62 +729,70 @@ MeasureUnit MeasureUnit::getKarat() {
     return MeasureUnit(3, 0);
 }
 
-MeasureUnit *MeasureUnit::createMilligramPerDeciliter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMilligramOfglucosePerDeciliter(UErrorCode &status) {
     return MeasureUnit::create(3, 1, status);
 }
 
-MeasureUnit MeasureUnit::getMilligramPerDeciliter() {
+MeasureUnit MeasureUnit::getMilligramOfglucosePerDeciliter() {
     return MeasureUnit(3, 1);
 }
 
-MeasureUnit *MeasureUnit::createMillimolePerLiter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMilligramPerDeciliter(UErrorCode &status) {
     return MeasureUnit::create(3, 2, status);
 }
 
-MeasureUnit MeasureUnit::getMillimolePerLiter() {
+MeasureUnit MeasureUnit::getMilligramPerDeciliter() {
     return MeasureUnit(3, 2);
 }
 
-MeasureUnit *MeasureUnit::createMole(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMillimolePerLiter(UErrorCode &status) {
     return MeasureUnit::create(3, 3, status);
 }
 
-MeasureUnit MeasureUnit::getMole() {
+MeasureUnit MeasureUnit::getMillimolePerLiter() {
     return MeasureUnit(3, 3);
 }
 
-MeasureUnit *MeasureUnit::createPartPerMillion(UErrorCode &status) {
-    return MeasureUnit::create(3, 6, status);
+MeasureUnit *MeasureUnit::createMole(UErrorCode &status) {
+    return MeasureUnit::create(3, 4, status);
 }
 
-MeasureUnit MeasureUnit::getPartPerMillion() {
-    return MeasureUnit(3, 6);
+MeasureUnit MeasureUnit::getMole() {
+    return MeasureUnit(3, 4);
 }
 
 MeasureUnit *MeasureUnit::createPercent(UErrorCode &status) {
-    return MeasureUnit::create(3, 4, status);
+    return MeasureUnit::create(3, 5, status);
 }
 
 MeasureUnit MeasureUnit::getPercent() {
-    return MeasureUnit(3, 4);
+    return MeasureUnit(3, 5);
 }
 
 MeasureUnit *MeasureUnit::createPermille(UErrorCode &status) {
-    return MeasureUnit::create(3, 5, status);
+    return MeasureUnit::create(3, 6, status);
 }
 
 MeasureUnit MeasureUnit::getPermille() {
-    return MeasureUnit(3, 5);
+    return MeasureUnit(3, 6);
 }
 
-MeasureUnit *MeasureUnit::createPermyriad(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createPartPerMillion(UErrorCode &status) {
     return MeasureUnit::create(3, 7, status);
 }
 
-MeasureUnit MeasureUnit::getPermyriad() {
+MeasureUnit MeasureUnit::getPartPerMillion() {
     return MeasureUnit(3, 7);
 }
 
+MeasureUnit *MeasureUnit::createPermyriad(UErrorCode &status) {
+    return MeasureUnit::create(3, 8, status);
+}
+
+MeasureUnit MeasureUnit::getPermyriad() {
+    return MeasureUnit(3, 8);
+}
+
 MeasureUnit *MeasureUnit::createLiterPer100Kilometers(UErrorCode &status) {
     return MeasureUnit::create(4, 0, status);
 }
@@ -1213,62 +1193,70 @@ MeasureUnit MeasureUnit::getMegahertz() {
     return MeasureUnit(11, 3);
 }
 
-MeasureUnit *MeasureUnit::createDotPerCentimeter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createDot(UErrorCode &status) {
     return MeasureUnit::create(12, 0, status);
 }
 
-MeasureUnit MeasureUnit::getDotPerCentimeter() {
+MeasureUnit MeasureUnit::getDot() {
     return MeasureUnit(12, 0);
 }
 
-MeasureUnit *MeasureUnit::createDotPerInch(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createDotPerCentimeter(UErrorCode &status) {
     return MeasureUnit::create(12, 1, status);
 }
 
-MeasureUnit MeasureUnit::getDotPerInch() {
+MeasureUnit MeasureUnit::getDotPerCentimeter() {
     return MeasureUnit(12, 1);
 }
 
-MeasureUnit *MeasureUnit::createEm(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createDotPerInch(UErrorCode &status) {
     return MeasureUnit::create(12, 2, status);
 }
 
-MeasureUnit MeasureUnit::getEm() {
+MeasureUnit MeasureUnit::getDotPerInch() {
     return MeasureUnit(12, 2);
 }
 
-MeasureUnit *MeasureUnit::createMegapixel(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createEm(UErrorCode &status) {
     return MeasureUnit::create(12, 3, status);
 }
 
-MeasureUnit MeasureUnit::getMegapixel() {
+MeasureUnit MeasureUnit::getEm() {
     return MeasureUnit(12, 3);
 }
 
-MeasureUnit *MeasureUnit::createPixel(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMegapixel(UErrorCode &status) {
     return MeasureUnit::create(12, 4, status);
 }
 
-MeasureUnit MeasureUnit::getPixel() {
+MeasureUnit MeasureUnit::getMegapixel() {
     return MeasureUnit(12, 4);
 }
 
-MeasureUnit *MeasureUnit::createPixelPerCentimeter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createPixel(UErrorCode &status) {
     return MeasureUnit::create(12, 5, status);
 }
 
-MeasureUnit MeasureUnit::getPixelPerCentimeter() {
+MeasureUnit MeasureUnit::getPixel() {
     return MeasureUnit(12, 5);
 }
 
-MeasureUnit *MeasureUnit::createPixelPerInch(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createPixelPerCentimeter(UErrorCode &status) {
     return MeasureUnit::create(12, 6, status);
 }
 
-MeasureUnit MeasureUnit::getPixelPerInch() {
+MeasureUnit MeasureUnit::getPixelPerCentimeter() {
     return MeasureUnit(12, 6);
 }
 
+MeasureUnit *MeasureUnit::createPixelPerInch(UErrorCode &status) {
+    return MeasureUnit::create(12, 7, status);
+}
+
+MeasureUnit MeasureUnit::getPixelPerInch() {
+    return MeasureUnit(12, 7);
+}
+
 MeasureUnit *MeasureUnit::createAstronomicalUnit(UErrorCode &status) {
     return MeasureUnit::create(13, 0, status);
 }
@@ -1293,166 +1281,190 @@ MeasureUnit MeasureUnit::getDecimeter() {
     return MeasureUnit(13, 2);
 }
 
-MeasureUnit *MeasureUnit::createFathom(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createEarthRadius(UErrorCode &status) {
     return MeasureUnit::create(13, 3, status);
 }
 
-MeasureUnit MeasureUnit::getFathom() {
+MeasureUnit MeasureUnit::getEarthRadius() {
     return MeasureUnit(13, 3);
 }
 
-MeasureUnit *MeasureUnit::createFoot(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createFathom(UErrorCode &status) {
     return MeasureUnit::create(13, 4, status);
 }
 
-MeasureUnit MeasureUnit::getFoot() {
+MeasureUnit MeasureUnit::getFathom() {
     return MeasureUnit(13, 4);
 }
 
-MeasureUnit *MeasureUnit::createFurlong(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createFoot(UErrorCode &status) {
     return MeasureUnit::create(13, 5, status);
 }
 
-MeasureUnit MeasureUnit::getFurlong() {
+MeasureUnit MeasureUnit::getFoot() {
     return MeasureUnit(13, 5);
 }
 
-MeasureUnit *MeasureUnit::createInch(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createFurlong(UErrorCode &status) {
     return MeasureUnit::create(13, 6, status);
 }
 
-MeasureUnit MeasureUnit::getInch() {
+MeasureUnit MeasureUnit::getFurlong() {
     return MeasureUnit(13, 6);
 }
 
-MeasureUnit *MeasureUnit::createKilometer(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createInch(UErrorCode &status) {
     return MeasureUnit::create(13, 7, status);
 }
 
-MeasureUnit MeasureUnit::getKilometer() {
+MeasureUnit MeasureUnit::getInch() {
     return MeasureUnit(13, 7);
 }
 
-MeasureUnit *MeasureUnit::createLightYear(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createKilometer(UErrorCode &status) {
     return MeasureUnit::create(13, 8, status);
 }
 
-MeasureUnit MeasureUnit::getLightYear() {
+MeasureUnit MeasureUnit::getKilometer() {
     return MeasureUnit(13, 8);
 }
 
-MeasureUnit *MeasureUnit::createMeter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createLightYear(UErrorCode &status) {
     return MeasureUnit::create(13, 9, status);
 }
 
-MeasureUnit MeasureUnit::getMeter() {
+MeasureUnit MeasureUnit::getLightYear() {
     return MeasureUnit(13, 9);
 }
 
-MeasureUnit *MeasureUnit::createMicrometer(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMeter(UErrorCode &status) {
     return MeasureUnit::create(13, 10, status);
 }
 
-MeasureUnit MeasureUnit::getMicrometer() {
+MeasureUnit MeasureUnit::getMeter() {
     return MeasureUnit(13, 10);
 }
 
-MeasureUnit *MeasureUnit::createMile(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMicrometer(UErrorCode &status) {
     return MeasureUnit::create(13, 11, status);
 }
 
-MeasureUnit MeasureUnit::getMile() {
+MeasureUnit MeasureUnit::getMicrometer() {
     return MeasureUnit(13, 11);
 }
 
-MeasureUnit *MeasureUnit::createMileScandinavian(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMile(UErrorCode &status) {
     return MeasureUnit::create(13, 12, status);
 }
 
-MeasureUnit MeasureUnit::getMileScandinavian() {
+MeasureUnit MeasureUnit::getMile() {
     return MeasureUnit(13, 12);
 }
 
-MeasureUnit *MeasureUnit::createMillimeter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMileScandinavian(UErrorCode &status) {
     return MeasureUnit::create(13, 13, status);
 }
 
-MeasureUnit MeasureUnit::getMillimeter() {
+MeasureUnit MeasureUnit::getMileScandinavian() {
     return MeasureUnit(13, 13);
 }
 
-MeasureUnit *MeasureUnit::createNanometer(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMillimeter(UErrorCode &status) {
     return MeasureUnit::create(13, 14, status);
 }
 
-MeasureUnit MeasureUnit::getNanometer() {
+MeasureUnit MeasureUnit::getMillimeter() {
     return MeasureUnit(13, 14);
 }
 
-MeasureUnit *MeasureUnit::createNauticalMile(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createNanometer(UErrorCode &status) {
     return MeasureUnit::create(13, 15, status);
 }
 
-MeasureUnit MeasureUnit::getNauticalMile() {
+MeasureUnit MeasureUnit::getNanometer() {
     return MeasureUnit(13, 15);
 }
 
-MeasureUnit *MeasureUnit::createParsec(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createNauticalMile(UErrorCode &status) {
     return MeasureUnit::create(13, 16, status);
 }
 
-MeasureUnit MeasureUnit::getParsec() {
+MeasureUnit MeasureUnit::getNauticalMile() {
     return MeasureUnit(13, 16);
 }
 
-MeasureUnit *MeasureUnit::createPicometer(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createParsec(UErrorCode &status) {
     return MeasureUnit::create(13, 17, status);
 }
 
-MeasureUnit MeasureUnit::getPicometer() {
+MeasureUnit MeasureUnit::getParsec() {
     return MeasureUnit(13, 17);
 }
 
-MeasureUnit *MeasureUnit::createPoint(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createPicometer(UErrorCode &status) {
     return MeasureUnit::create(13, 18, status);
 }
 
-MeasureUnit MeasureUnit::getPoint() {
+MeasureUnit MeasureUnit::getPicometer() {
     return MeasureUnit(13, 18);
 }
 
-MeasureUnit *MeasureUnit::createSolarRadius(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createPoint(UErrorCode &status) {
     return MeasureUnit::create(13, 19, status);
 }
 
-MeasureUnit MeasureUnit::getSolarRadius() {
+MeasureUnit MeasureUnit::getPoint() {
     return MeasureUnit(13, 19);
 }
 
-MeasureUnit *MeasureUnit::createYard(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createSolarRadius(UErrorCode &status) {
     return MeasureUnit::create(13, 20, status);
 }
 
-MeasureUnit MeasureUnit::getYard() {
+MeasureUnit MeasureUnit::getSolarRadius() {
     return MeasureUnit(13, 20);
 }
 
-MeasureUnit *MeasureUnit::createLux(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createYard(UErrorCode &status) {
+    return MeasureUnit::create(13, 21, status);
+}
+
+MeasureUnit MeasureUnit::getYard() {
+    return MeasureUnit(13, 21);
+}
+
+MeasureUnit *MeasureUnit::createCandela(UErrorCode &status) {
     return MeasureUnit::create(14, 0, status);
 }
 
-MeasureUnit MeasureUnit::getLux() {
+MeasureUnit MeasureUnit::getCandela() {
     return MeasureUnit(14, 0);
 }
 
-MeasureUnit *MeasureUnit::createSolarLuminosity(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createLumen(UErrorCode &status) {
     return MeasureUnit::create(14, 1, status);
 }
 
-MeasureUnit MeasureUnit::getSolarLuminosity() {
+MeasureUnit MeasureUnit::getLumen() {
     return MeasureUnit(14, 1);
 }
 
+MeasureUnit *MeasureUnit::createLux(UErrorCode &status) {
+    return MeasureUnit::create(14, 2, status);
+}
+
+MeasureUnit MeasureUnit::getLux() {
+    return MeasureUnit(14, 2);
+}
+
+MeasureUnit *MeasureUnit::createSolarLuminosity(UErrorCode &status) {
+    return MeasureUnit::create(14, 3, status);
+}
+
+MeasureUnit MeasureUnit::getSolarLuminosity() {
+    return MeasureUnit(14, 3);
+}
+
 MeasureUnit *MeasureUnit::createCarat(UErrorCode &status) {
     return MeasureUnit::create(15, 0, status);
 }
@@ -1477,94 +1489,102 @@ MeasureUnit MeasureUnit::getEarthMass() {
     return MeasureUnit(15, 2);
 }
 
-MeasureUnit *MeasureUnit::createGram(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createGrain(UErrorCode &status) {
     return MeasureUnit::create(15, 3, status);
 }
 
-MeasureUnit MeasureUnit::getGram() {
+MeasureUnit MeasureUnit::getGrain() {
     return MeasureUnit(15, 3);
 }
 
-MeasureUnit *MeasureUnit::createKilogram(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createGram(UErrorCode &status) {
     return MeasureUnit::create(15, 4, status);
 }
 
-MeasureUnit MeasureUnit::getKilogram() {
+MeasureUnit MeasureUnit::getGram() {
     return MeasureUnit(15, 4);
 }
 
-MeasureUnit *MeasureUnit::createMetricTon(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createKilogram(UErrorCode &status) {
     return MeasureUnit::create(15, 5, status);
 }
 
-MeasureUnit MeasureUnit::getMetricTon() {
+MeasureUnit MeasureUnit::getKilogram() {
     return MeasureUnit(15, 5);
 }
 
-MeasureUnit *MeasureUnit::createMicrogram(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMetricTon(UErrorCode &status) {
     return MeasureUnit::create(15, 6, status);
 }
 
-MeasureUnit MeasureUnit::getMicrogram() {
+MeasureUnit MeasureUnit::getMetricTon() {
     return MeasureUnit(15, 6);
 }
 
-MeasureUnit *MeasureUnit::createMilligram(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMicrogram(UErrorCode &status) {
     return MeasureUnit::create(15, 7, status);
 }
 
-MeasureUnit MeasureUnit::getMilligram() {
+MeasureUnit MeasureUnit::getMicrogram() {
     return MeasureUnit(15, 7);
 }
 
-MeasureUnit *MeasureUnit::createOunce(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMilligram(UErrorCode &status) {
     return MeasureUnit::create(15, 8, status);
 }
 
-MeasureUnit MeasureUnit::getOunce() {
+MeasureUnit MeasureUnit::getMilligram() {
     return MeasureUnit(15, 8);
 }
 
-MeasureUnit *MeasureUnit::createOunceTroy(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createOunce(UErrorCode &status) {
     return MeasureUnit::create(15, 9, status);
 }
 
-MeasureUnit MeasureUnit::getOunceTroy() {
+MeasureUnit MeasureUnit::getOunce() {
     return MeasureUnit(15, 9);
 }
 
-MeasureUnit *MeasureUnit::createPound(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createOunceTroy(UErrorCode &status) {
     return MeasureUnit::create(15, 10, status);
 }
 
-MeasureUnit MeasureUnit::getPound() {
+MeasureUnit MeasureUnit::getOunceTroy() {
     return MeasureUnit(15, 10);
 }
 
-MeasureUnit *MeasureUnit::createSolarMass(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createPound(UErrorCode &status) {
     return MeasureUnit::create(15, 11, status);
 }
 
-MeasureUnit MeasureUnit::getSolarMass() {
+MeasureUnit MeasureUnit::getPound() {
     return MeasureUnit(15, 11);
 }
 
-MeasureUnit *MeasureUnit::createStone(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createSolarMass(UErrorCode &status) {
     return MeasureUnit::create(15, 12, status);
 }
 
-MeasureUnit MeasureUnit::getStone() {
+MeasureUnit MeasureUnit::getSolarMass() {
     return MeasureUnit(15, 12);
 }
 
-MeasureUnit *MeasureUnit::createTon(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createStone(UErrorCode &status) {
     return MeasureUnit::create(15, 13, status);
 }
 
-MeasureUnit MeasureUnit::getTon() {
+MeasureUnit MeasureUnit::getStone() {
     return MeasureUnit(15, 13);
 }
 
+MeasureUnit *MeasureUnit::createTon(UErrorCode &status) {
+    return MeasureUnit::create(15, 14, status);
+}
+
+MeasureUnit MeasureUnit::getTon() {
+    return MeasureUnit(15, 14);
+}
+
 MeasureUnit *MeasureUnit::createGigawatt(UErrorCode &status) {
     return MeasureUnit::create(17, 0, status);
 }
@@ -1885,111 +1905,167 @@ MeasureUnit MeasureUnit::getDeciliter() {
     return MeasureUnit(22, 13);
 }
 
-MeasureUnit *MeasureUnit::createFluidOunce(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createDessertSpoon(UErrorCode &status) {
     return MeasureUnit::create(22, 14, status);
 }
 
-MeasureUnit MeasureUnit::getFluidOunce() {
+MeasureUnit MeasureUnit::getDessertSpoon() {
     return MeasureUnit(22, 14);
 }
 
-MeasureUnit *MeasureUnit::createFluidOunceImperial(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createDessertSpoonImperial(UErrorCode &status) {
     return MeasureUnit::create(22, 15, status);
 }
 
-MeasureUnit MeasureUnit::getFluidOunceImperial() {
+MeasureUnit MeasureUnit::getDessertSpoonImperial() {
     return MeasureUnit(22, 15);
 }
 
-MeasureUnit *MeasureUnit::createGallon(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createDram(UErrorCode &status) {
     return MeasureUnit::create(22, 16, status);
 }
 
-MeasureUnit MeasureUnit::getGallon() {
+MeasureUnit MeasureUnit::getDram() {
     return MeasureUnit(22, 16);
 }
 
-MeasureUnit *MeasureUnit::createGallonImperial(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createDrop(UErrorCode &status) {
     return MeasureUnit::create(22, 17, status);
 }
 
-MeasureUnit MeasureUnit::getGallonImperial() {
+MeasureUnit MeasureUnit::getDrop() {
     return MeasureUnit(22, 17);
 }
 
-MeasureUnit *MeasureUnit::createHectoliter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createFluidOunce(UErrorCode &status) {
     return MeasureUnit::create(22, 18, status);
 }
 
-MeasureUnit MeasureUnit::getHectoliter() {
+MeasureUnit MeasureUnit::getFluidOunce() {
     return MeasureUnit(22, 18);
 }
 
-MeasureUnit *MeasureUnit::createLiter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createFluidOunceImperial(UErrorCode &status) {
     return MeasureUnit::create(22, 19, status);
 }
 
-MeasureUnit MeasureUnit::getLiter() {
+MeasureUnit MeasureUnit::getFluidOunceImperial() {
     return MeasureUnit(22, 19);
 }
 
-MeasureUnit *MeasureUnit::createMegaliter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createGallon(UErrorCode &status) {
     return MeasureUnit::create(22, 20, status);
 }
 
-MeasureUnit MeasureUnit::getMegaliter() {
+MeasureUnit MeasureUnit::getGallon() {
     return MeasureUnit(22, 20);
 }
 
-MeasureUnit *MeasureUnit::createMilliliter(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createGallonImperial(UErrorCode &status) {
     return MeasureUnit::create(22, 21, status);
 }
 
-MeasureUnit MeasureUnit::getMilliliter() {
+MeasureUnit MeasureUnit::getGallonImperial() {
     return MeasureUnit(22, 21);
 }
 
-MeasureUnit *MeasureUnit::createPint(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createHectoliter(UErrorCode &status) {
     return MeasureUnit::create(22, 22, status);
 }
 
-MeasureUnit MeasureUnit::getPint() {
+MeasureUnit MeasureUnit::getHectoliter() {
     return MeasureUnit(22, 22);
 }
 
-MeasureUnit *MeasureUnit::createPintMetric(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createJigger(UErrorCode &status) {
     return MeasureUnit::create(22, 23, status);
 }
 
-MeasureUnit MeasureUnit::getPintMetric() {
+MeasureUnit MeasureUnit::getJigger() {
     return MeasureUnit(22, 23);
 }
 
-MeasureUnit *MeasureUnit::createQuart(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createLiter(UErrorCode &status) {
     return MeasureUnit::create(22, 24, status);
 }
 
-MeasureUnit MeasureUnit::getQuart() {
+MeasureUnit MeasureUnit::getLiter() {
     return MeasureUnit(22, 24);
 }
 
-MeasureUnit *MeasureUnit::createTablespoon(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMegaliter(UErrorCode &status) {
     return MeasureUnit::create(22, 25, status);
 }
 
-MeasureUnit MeasureUnit::getTablespoon() {
+MeasureUnit MeasureUnit::getMegaliter() {
     return MeasureUnit(22, 25);
 }
 
-MeasureUnit *MeasureUnit::createTeaspoon(UErrorCode &status) {
+MeasureUnit *MeasureUnit::createMilliliter(UErrorCode &status) {
     return MeasureUnit::create(22, 26, status);
 }
 
-MeasureUnit MeasureUnit::getTeaspoon() {
+MeasureUnit MeasureUnit::getMilliliter() {
     return MeasureUnit(22, 26);
 }
 
-// End generated code
+MeasureUnit *MeasureUnit::createPinch(UErrorCode &status) {
+    return MeasureUnit::create(22, 27, status);
+}
+
+MeasureUnit MeasureUnit::getPinch() {
+    return MeasureUnit(22, 27);
+}
+
+MeasureUnit *MeasureUnit::createPint(UErrorCode &status) {
+    return MeasureUnit::create(22, 28, status);
+}
+
+MeasureUnit MeasureUnit::getPint() {
+    return MeasureUnit(22, 28);
+}
+
+MeasureUnit *MeasureUnit::createPintMetric(UErrorCode &status) {
+    return MeasureUnit::create(22, 29, status);
+}
+
+MeasureUnit MeasureUnit::getPintMetric() {
+    return MeasureUnit(22, 29);
+}
+
+MeasureUnit *MeasureUnit::createQuart(UErrorCode &status) {
+    return MeasureUnit::create(22, 30, status);
+}
+
+MeasureUnit MeasureUnit::getQuart() {
+    return MeasureUnit(22, 30);
+}
+
+MeasureUnit *MeasureUnit::createQuartImperial(UErrorCode &status) {
+    return MeasureUnit::create(22, 31, status);
+}
+
+MeasureUnit MeasureUnit::getQuartImperial() {
+    return MeasureUnit(22, 31);
+}
+
+MeasureUnit *MeasureUnit::createTablespoon(UErrorCode &status) {
+    return MeasureUnit::create(22, 32, status);
+}
+
+MeasureUnit MeasureUnit::getTablespoon() {
+    return MeasureUnit(22, 32);
+}
+
+MeasureUnit *MeasureUnit::createTeaspoon(UErrorCode &status) {
+    return MeasureUnit::create(22, 33, status);
+}
+
+MeasureUnit MeasureUnit::getTeaspoon() {
+    return MeasureUnit(22, 33);
+}
+
+// End generated code for measunit.cpp
 
 static int32_t binarySearch(
         const char * const * array, int32_t start, int32_t end, StringPiece key) {
@@ -2038,7 +2114,9 @@ MeasureUnit &MeasureUnit::operator=(const MeasureUnit &other) {
     if (this == &other) {
         return *this;
     }
-    delete fImpl;
+    if (fImpl != nullptr) {
+        delete fImpl;
+    }
     if (other.fImpl) {
         ErrorCode localStatus;
         fImpl = new MeasureUnitImpl(other.fImpl->copy(localStatus));
@@ -2059,7 +2137,9 @@ MeasureUnit &MeasureUnit::operator=(MeasureUnit &&other) noexcept {
     if (this == &other) {
         return *this;
     }
-    delete fImpl;
+    if (fImpl != nullptr) {
+        delete fImpl;
+    }
     fImpl = other.fImpl;
     other.fImpl = nullptr;
     fTypeId = other.fTypeId;
@@ -2072,8 +2152,10 @@ MeasureUnit *MeasureUnit::clone() const {
 }
 
 MeasureUnit::~MeasureUnit() {
-    delete fImpl;
-    fImpl = nullptr;
+    if (fImpl != nullptr) {
+        delete fImpl;
+        fImpl = nullptr;
+    }
 }
 
 const char *MeasureUnit::getType() const {
@@ -2107,10 +2189,6 @@ UBool MeasureUnit::operator==(const UObject& other) const {
     return uprv_strcmp(getIdentifier(), rhs.getIdentifier()) == 0;
 }
 
-int32_t MeasureUnit::getIndex() const {
-    return gIndexes[fTypeId] + fSubTypeId;
-}
-
 int32_t MeasureUnit::getAvailable(
         MeasureUnit *dest,
         int32_t destCapacity,
@@ -2173,26 +2251,14 @@ StringEnumeration* MeasureUnit::getAvailableTypes(UErrorCode &errorCode) {
     return result;
 }
 
-int32_t MeasureUnit::getIndexCount() {
-    return gIndexes[UPRV_LENGTHOF(gIndexes) - 1];
-}
-
-int32_t MeasureUnit::internalGetIndexForTypeAndSubtype(const char *type, const char *subtype) {
-    int32_t t = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), type);
-    if (t < 0) {
-        return t;
-    }
-    int32_t st = binarySearch(gSubTypes, gOffsets[t], gOffsets[t + 1], subtype);
-    if (st < 0) {
-        return st;
-    }
-    return gIndexes[t] + st - gOffsets[t];
-}
-
 bool MeasureUnit::findBySubType(StringPiece subType, MeasureUnit* output) {
+    // Sanity checking kCurrencyOffset and final entry in gOffsets
+    U_ASSERT(uprv_strcmp(gTypes[kCurrencyOffset], "currency") == 0);
+    U_ASSERT(gOffsets[UPRV_LENGTHOF(gOffsets) - 1] == UPRV_LENGTHOF(gSubTypes));
+
     for (int32_t t = 0; t < UPRV_LENGTHOF(gOffsets) - 1; t++) {
         // Skip currency units
-        if (gIndexes[t] == gIndexes[t + 1]) {
+        if (t == kCurrencyOffset) {
             continue;
         }
         int32_t st = binarySearch(gSubTypes, gOffsets[t], gOffsets[t + 1], subType);
@@ -2204,41 +2270,6 @@ bool MeasureUnit::findBySubType(StringPiece subType, MeasureUnit* output) {
     return false;
 }
 
-MeasureUnit MeasureUnit::resolveUnitPerUnit(
-        const MeasureUnit &unit, const MeasureUnit &perUnit, bool* isResolved) {
-    int32_t unitOffset = unit.getOffset();
-    int32_t perUnitOffset = perUnit.getOffset();
-    if (unitOffset == -1 || perUnitOffset == -1) {
-        *isResolved = false;
-        return MeasureUnit();
-    }
-
-    // binary search for (unitOffset, perUnitOffset)
-    int32_t start = 0;
-    int32_t end = UPRV_LENGTHOF(unitPerUnitToSingleUnit);
-    while (start < end) {
-        int32_t mid = (start + end) / 2;
-        int32_t *midRow = unitPerUnitToSingleUnit[mid];
-        if (unitOffset < midRow[0]) {
-            end = mid;
-        } else if (unitOffset > midRow[0]) {
-            start = mid + 1;
-        } else if (perUnitOffset < midRow[1]) {
-            end = mid;
-        } else if (perUnitOffset > midRow[1]) {
-            start = mid + 1;
-        } else {
-            // We found a resolution for our unit / per-unit combo
-            // return it.
-            *isResolved = true;
-            return MeasureUnit(midRow[2], midRow[3]);
-        }
-    }
-
-    *isResolved = false;
-    return MeasureUnit();
-}
-
 MeasureUnit *MeasureUnit::create(int typeId, int subTypeId, UErrorCode &status) {
     if (U_FAILURE(status)) {
         return NULL;
@@ -2279,20 +2310,13 @@ void MeasureUnit::initCurrency(StringPiece isoCurrency) {
     fSubTypeId = result - gOffsets[fTypeId];
 }
 
-void MeasureUnit::initNoUnit(const char *subtype) {
-    int32_t result = binarySearch(gTypes, 0, UPRV_LENGTHOF(gTypes), "none");
-    U_ASSERT(result != -1);
-    fTypeId = result;
-    result = binarySearch(gSubTypes, gOffsets[fTypeId], gOffsets[fTypeId + 1], subtype);
-    U_ASSERT(result != -1);
-    fSubTypeId = result - gOffsets[fTypeId];
-}
-
 void MeasureUnit::setTo(int32_t typeId, int32_t subTypeId) {
     fTypeId = typeId;
     fSubTypeId = subTypeId;
-    delete fImpl;
-    fImpl = nullptr;
+    if (fImpl != nullptr) {
+        delete fImpl;
+        fImpl = nullptr;
+    }
 }
 
 int32_t MeasureUnit::getOffset() const {
@@ -2302,6 +2326,20 @@ int32_t MeasureUnit::getOffset() const {
     return gOffsets[fTypeId] + fSubTypeId;
 }
 
+MeasureUnitImpl MeasureUnitImpl::copy(UErrorCode &status) const {
+    MeasureUnitImpl result;
+    result.complexity = complexity;
+    result.identifier.append(identifier, status);
+    for (int32_t i = 0; i < singleUnits.length(); i++) {
+        SingleUnitImpl *item = result.singleUnits.emplaceBack(*singleUnits[i]);
+        if (!item) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return result;
+        }
+    }
+    return result;
+}
+
 U_NAMESPACE_END
 
 #endif /* !UNCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/measunit_extra.cpp b/deps/icu-small/source/i18n/measunit_extra.cpp
index aeb60017a18fcebbc190ba22a609ccaf9caf0f7a..76ada0e89cd6689543a29c0e47e170a53049fc7a 100644
--- a/deps/icu-small/source/i18n/measunit_extra.cpp
+++ b/deps/icu-small/source/i18n/measunit_extra.cpp
@@ -12,20 +12,26 @@
 // Helpful in toString methods and elsewhere.
 #define UNISTR_FROM_STRING_EXPLICIT
 
-#include <cstdlib>
+#include "charstr.h"
+#include "cmemory.h"
 #include "cstring.h"
 #include "measunit_impl.h"
+#include "resource.h"
 #include "uarrsort.h"
 #include "uassert.h"
 #include "ucln_in.h"
 #include "umutex.h"
-#include "unicode/errorcode.h"
+#include "unicode/bytestrie.h"
+#include "unicode/bytestriebuilder.h"
 #include "unicode/localpointer.h"
 #include "unicode/measunit.h"
-#include "unicode/ucharstrie.h"
-#include "unicode/ucharstriebuilder.h"
-
-#include "cstr.h"
+#include "unicode/stringpiece.h"
+#include "unicode/stringtriebuilder.h"
+#include "unicode/ures.h"
+#include "unicode/ustringtrie.h"
+#include "uresimp.h"
+#include "util.h"
+#include <cstdlib>
 
 U_NAMESPACE_BEGIN
 
@@ -35,12 +41,20 @@ namespace {
 // TODO: Propose a new error code for this?
 constexpr UErrorCode kUnitIdentifierSyntaxError = U_ILLEGAL_ARGUMENT_ERROR;
 
-// Trie value offset for SI Prefixes. This is big enough to ensure we only
+// Trie value offset for SI or binary prefixes. This is big enough to ensure we only
 // insert positive integers into the trie.
-constexpr int32_t kSIPrefixOffset = 64;
+constexpr int32_t kPrefixOffset = 64;
+static_assert(kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MIN_BIN > 0,
+              "kPrefixOffset is too small for minimum UMeasurePrefix value");
+static_assert(kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MIN_SI > 0,
+              "kPrefixOffset is too small for minimum UMeasurePrefix value");
 
 // Trie value offset for compound parts, e.g. "-per-", "-", "-and-".
 constexpr int32_t kCompoundPartOffset = 128;
+static_assert(kCompoundPartOffset > kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MAX_BIN,
+              "Ambiguous token values: prefix tokens are overlapping with CompoundPart tokens");
+static_assert(kCompoundPartOffset > kPrefixOffset + UMEASURE_PREFIX_INTERNAL_MAX_SI,
+              "Ambiguous token values: prefix tokens are overlapping with CompoundPart tokens");
 
 enum CompoundPart {
     // Represents "-per-"
@@ -60,7 +74,7 @@ enum InitialCompoundPart {
     INITIAL_COMPOUND_PART_PER = kInitialCompoundPartOffset,
 };
 
-// Trie value offset for powers like "square-", "cubic-", "p2-" etc.
+// Trie value offset for powers like "square-", "cubic-", "pow2-" etc.
 constexpr int32_t kPowerPartOffset = 256;
 
 enum PowerPart {
@@ -84,201 +98,371 @@ enum PowerPart {
 // "fluid-ounce-imperial".
 constexpr int32_t kSimpleUnitOffset = 512;
 
-const struct SIPrefixStrings {
+const struct UnitPrefixStrings {
     const char* const string;
-    UMeasureSIPrefix value;
-} gSIPrefixStrings[] = {
-    { "yotta", UMEASURE_SI_PREFIX_YOTTA },
-    { "zetta", UMEASURE_SI_PREFIX_ZETTA },
-    { "exa", UMEASURE_SI_PREFIX_EXA },
-    { "peta", UMEASURE_SI_PREFIX_PETA },
-    { "tera", UMEASURE_SI_PREFIX_TERA },
-    { "giga", UMEASURE_SI_PREFIX_GIGA },
-    { "mega", UMEASURE_SI_PREFIX_MEGA },
-    { "kilo", UMEASURE_SI_PREFIX_KILO },
-    { "hecto", UMEASURE_SI_PREFIX_HECTO },
-    { "deka", UMEASURE_SI_PREFIX_DEKA },
-    { "deci", UMEASURE_SI_PREFIX_DECI },
-    { "centi", UMEASURE_SI_PREFIX_CENTI },
-    { "milli", UMEASURE_SI_PREFIX_MILLI },
-    { "micro", UMEASURE_SI_PREFIX_MICRO },
-    { "nano", UMEASURE_SI_PREFIX_NANO },
-    { "pico", UMEASURE_SI_PREFIX_PICO },
-    { "femto", UMEASURE_SI_PREFIX_FEMTO },
-    { "atto", UMEASURE_SI_PREFIX_ATTO },
-    { "zepto", UMEASURE_SI_PREFIX_ZEPTO },
-    { "yocto", UMEASURE_SI_PREFIX_YOCTO },
+    UMeasurePrefix value;
+} gUnitPrefixStrings[] = {
+    // SI prefixes
+    { "yotta", UMEASURE_PREFIX_YOTTA },
+    { "zetta", UMEASURE_PREFIX_ZETTA },
+    { "exa", UMEASURE_PREFIX_EXA },
+    { "peta", UMEASURE_PREFIX_PETA },
+    { "tera", UMEASURE_PREFIX_TERA },
+    { "giga", UMEASURE_PREFIX_GIGA },
+    { "mega", UMEASURE_PREFIX_MEGA },
+    { "kilo", UMEASURE_PREFIX_KILO },
+    { "hecto", UMEASURE_PREFIX_HECTO },
+    { "deka", UMEASURE_PREFIX_DEKA },
+    { "deci", UMEASURE_PREFIX_DECI },
+    { "centi", UMEASURE_PREFIX_CENTI },
+    { "milli", UMEASURE_PREFIX_MILLI },
+    { "micro", UMEASURE_PREFIX_MICRO },
+    { "nano", UMEASURE_PREFIX_NANO },
+    { "pico", UMEASURE_PREFIX_PICO },
+    { "femto", UMEASURE_PREFIX_FEMTO },
+    { "atto", UMEASURE_PREFIX_ATTO },
+    { "zepto", UMEASURE_PREFIX_ZEPTO },
+    { "yocto", UMEASURE_PREFIX_YOCTO },
+    // Binary prefixes
+    { "yobi", UMEASURE_PREFIX_YOBI },
+    { "zebi", UMEASURE_PREFIX_ZEBI },
+    { "exbi", UMEASURE_PREFIX_EXBI },
+    { "pebi", UMEASURE_PREFIX_PEBI },
+    { "tebi", UMEASURE_PREFIX_TEBI },
+    { "gibi", UMEASURE_PREFIX_GIBI },
+    { "mebi", UMEASURE_PREFIX_MEBI },
+    { "kibi", UMEASURE_PREFIX_KIBI },
+};
+
+/**
+ * A ResourceSink that collects simple unit identifiers from the keys of the
+ * convertUnits table into an array, and adds these values to a TrieBuilder,
+ * with associated values being their index into this array plus a specified
+ * offset.
+ *
+ * Example code:
+ *
+ *     UErrorCode status = U_ZERO_ERROR;
+ *     BytesTrieBuilder b(status);
+ *     int32_t ARR_SIZE = 200;
+ *     const char *unitIdentifiers[ARR_SIZE];
+ *     int32_t *unitCategories[ARR_SIZE];
+ *     SimpleUnitIdentifiersSink identifierSink(gSerializedUnitCategoriesTrie, unitIdentifiers,
+ *                                              unitCategories, ARR_SIZE, b, kTrieValueOffset);
+ *     LocalUResourceBundlePointer unitsBundle(ures_openDirect(NULL, "units", &status));
+ *     ures_getAllItemsWithFallback(unitsBundle.getAlias(), "convertUnits", identifierSink, status);
+ */
+class SimpleUnitIdentifiersSink : public icu::ResourceSink {
+  public:
+    /**
+     * Constructor.
+     * @param quantitiesTrieData The data for constructing a quantitiesTrie,
+     *     which maps from a simple unit identifier to an index into the
+     *     gCategories array.
+     * @param out Array of char* to which pointers to the simple unit
+     *     identifiers will be saved. (Does not take ownership.)
+     * @param outCategories Array of int32_t to which category indexes will be
+     *     saved: this corresponds to simple unit IDs saved to `out`, mapping
+     *     from the ID to the value produced by the quantitiesTrie (which is an
+     *     index into the gCategories array).
+     * @param outSize The size of `out` and `outCategories`.
+     * @param trieBuilder The trie builder to which the simple unit identifier
+     *     should be added. The trie builder must outlive this resource sink.
+     * @param trieValueOffset This is added to the index of the identifier in
+     *     the `out` array, before adding to `trieBuilder` as the value
+     *     associated with the identifier.
+     */
+    explicit SimpleUnitIdentifiersSink(StringPiece quantitiesTrieData, const char **out,
+                                       int32_t *outCategories, int32_t outSize,
+                                       BytesTrieBuilder &trieBuilder, int32_t trieValueOffset)
+        : outArray(out), outCategories(outCategories), outSize(outSize), trieBuilder(trieBuilder),
+          trieValueOffset(trieValueOffset), quantitiesTrieData(quantitiesTrieData), outIndex(0) {}
+
+    /**
+     * Adds the table keys found in value to the output vector.
+     * @param key The key of the resource passed to `value`: the second
+     *     parameter of the ures_getAllItemsWithFallback() call.
+     * @param value Should be a ResourceTable value, if
+     *     ures_getAllItemsWithFallback() was called correctly for this sink.
+     * @param noFallback Ignored.
+     * @param status The standard ICU error code output parameter.
+     */
+    void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) {
+        ResourceTable table = value.getTable(status);
+        if (U_FAILURE(status)) return;
+
+        if (outIndex + table.getSize() > outSize) {
+            status = U_INDEX_OUTOFBOUNDS_ERROR;
+            return;
+        }
+
+        BytesTrie quantitiesTrie(quantitiesTrieData.data());
+
+        // Collect keys from the table resource.
+        const char *simpleUnitID;
+        for (int32_t i = 0; table.getKeyAndValue(i, simpleUnitID, value); ++i) {
+            U_ASSERT(i < table.getSize());
+            U_ASSERT(outIndex < outSize);
+            if (uprv_strcmp(simpleUnitID, "kilogram") == 0) {
+                // For parsing, we use "gram", the prefixless metric mass unit. We
+                // thus ignore the SI Base Unit of Mass: it exists due to being the
+                // mass conversion target unit, but not needed for MeasureUnit
+                // parsing.
+                continue;
+            }
+            outArray[outIndex] = simpleUnitID;
+            trieBuilder.add(simpleUnitID, trieValueOffset + outIndex, status);
+
+            // Find the base target unit for this simple unit
+            ResourceTable table = value.getTable(status);
+            if (U_FAILURE(status)) { return; }
+            if (!table.findValue("target", value)) {
+                status = U_INVALID_FORMAT_ERROR;
+                break;
+            }
+            int32_t len;
+            const UChar* uTarget = value.getString(len, status);
+            CharString target;
+            target.appendInvariantChars(uTarget, len, status);
+            if (U_FAILURE(status)) { return; }
+            quantitiesTrie.reset();
+            UStringTrieResult result = quantitiesTrie.next(target.data(), target.length());
+            if (!USTRINGTRIE_HAS_VALUE(result)) {
+                status = U_INVALID_FORMAT_ERROR;
+                break;
+            }
+            outCategories[outIndex] = quantitiesTrie.getValue();
+
+            outIndex++;
+        }
+    }
+
+  private:
+    const char **outArray;
+    int32_t *outCategories;
+    int32_t outSize;
+    BytesTrieBuilder &trieBuilder;
+    int32_t trieValueOffset;
+
+    StringPiece quantitiesTrieData;
+
+    int32_t outIndex;
 };
 
-// TODO(ICU-21059): Get this list from data
-const char16_t* const gSimpleUnits[] = {
-    u"candela",
-    u"carat",
-    u"gram",
-    u"ounce",
-    u"ounce-troy",
-    u"pound",
-    u"kilogram",
-    u"stone",
-    u"ton",
-    u"metric-ton",
-    u"earth-mass",
-    u"solar-mass",
-    u"point",
-    u"inch",
-    u"foot",
-    u"yard",
-    u"meter",
-    u"fathom",
-    u"furlong",
-    u"mile",
-    u"nautical-mile",
-    u"mile-scandinavian",
-    u"100-kilometer",
-    u"earth-radius",
-    u"solar-radius",
-    u"astronomical-unit",
-    u"light-year",
-    u"parsec",
-    u"second",
-    u"minute",
-    u"hour",
-    u"day",
-    u"day-person",
-    u"week",
-    u"week-person",
-    u"month",
-    u"month-person",
-    u"year",
-    u"year-person",
-    u"decade",
-    u"century",
-    u"ampere",
-    u"fahrenheit",
-    u"kelvin",
-    u"celsius",
-    u"arc-second",
-    u"arc-minute",
-    u"degree",
-    u"radian",
-    u"revolution",
-    u"item",
-    u"mole",
-    u"permillion",
-    u"permyriad",
-    u"permille",
-    u"percent",
-    u"karat",
-    u"portion",
-    u"bit",
-    u"byte",
-    u"dot",
-    u"pixel",
-    u"em",
-    u"hertz",
-    u"newton",
-    u"pound-force",
-    u"pascal",
-    u"bar",
-    u"atmosphere",
-    u"ofhg",
-    u"electronvolt",
-    u"dalton",
-    u"joule",
-    u"calorie",
-    u"british-thermal-unit",
-    u"foodcalorie",
-    u"therm-us",
-    u"watt",
-    u"horsepower",
-    u"solar-luminosity",
-    u"volt",
-    u"ohm",
-    u"dunam",
-    u"acre",
-    u"hectare",
-    u"teaspoon",
-    u"tablespoon",
-    u"fluid-ounce-imperial",
-    u"fluid-ounce",
-    u"cup",
-    u"cup-metric",
-    u"pint",
-    u"pint-metric",
-    u"quart",
-    u"liter",
-    u"gallon",
-    u"gallon-imperial",
-    u"bushel",
-    u"barrel",
-    u"knot",
-    u"g-force",
-    u"lux",
+/**
+ * A ResourceSink that collects information from `unitQuantities` in the `units`
+ * resource to provide key->value lookups from base unit to category, as well as
+ * preserving ordering information for these categories. See `units.txt`.
+ *
+ * For example: "kilogram" -> "mass", "meter-per-second" -> "speed".
+ *
+ * In C++ unitQuantity values are collected in order into a UChar* array, while
+ * unitQuantity keys are added added to a TrieBuilder, with associated values
+ * being the index into the aforementioned UChar* array.
+ */
+class CategoriesSink : public icu::ResourceSink {
+  public:
+    /**
+     * Constructor.
+     * @param out Array of UChar* to which unitQuantity values will be saved.
+     *     The pointers returned  not owned: they point directly at the resource
+     *     strings in static memory.
+     * @param outSize The size of the `out` array.
+     * @param trieBuilder The trie builder to which the keys (base units) of
+     *     each unitQuantity will be added, each with value being the offset
+     *     into `out`.
+     */
+    explicit CategoriesSink(const UChar **out, int32_t &outSize, BytesTrieBuilder &trieBuilder)
+        : outQuantitiesArray(out), outSize(outSize), trieBuilder(trieBuilder), outIndex(0) {}
+
+    void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) {
+        ResourceArray array = value.getArray(status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+
+        if (outIndex + array.getSize() > outSize) {
+            status = U_INDEX_OUTOFBOUNDS_ERROR;
+            return;
+        }
+
+        for (int32_t i = 0; array.getValue(i, value); ++i) {
+            U_ASSERT(outIndex < outSize);
+            ResourceTable table = value.getTable(status);
+            if (U_FAILURE(status)) {
+                return;
+            }
+            if (table.getSize() != 1) {
+                status = U_INVALID_FORMAT_ERROR;
+                return;
+            }
+            const char *key;
+            table.getKeyAndValue(0, key, value);
+            int32_t uTmpLen;
+            outQuantitiesArray[outIndex] = value.getString(uTmpLen, status);
+            trieBuilder.add(key, outIndex, status);
+            outIndex++;
+        }
+    }
+
+  private:
+    const UChar **outQuantitiesArray;
+    int32_t &outSize;
+    BytesTrieBuilder &trieBuilder;
+
+    int32_t outIndex;
 };
 
 icu::UInitOnce gUnitExtrasInitOnce = U_INITONCE_INITIALIZER;
 
-char16_t* kSerializedUnitExtrasStemTrie = nullptr;
+// Array of simple unit IDs.
+//
+// The array memory itself is owned by this pointer, but the individual char* in
+// that array point at static memory. (Note that these char* are also returned
+// by SingleUnitImpl::getSimpleUnitID().)
+const char **gSimpleUnits = nullptr;
+
+// Maps from the value associated with each simple unit ID to an index into the
+// gCategories array.
+int32_t *gSimpleUnitCategories = nullptr;
+
+char *gSerializedUnitExtrasStemTrie = nullptr;
+
+// Array of UChar* pointing at the unit categories (aka "quantities", aka
+// "types"), as found in the `unitQuantities` resource. The array memory itself
+// is owned by this pointer, but the individual UChar* in that array point at
+// static memory.
+const UChar **gCategories = nullptr;
+// Number of items in `gCategories`.
+int32_t gCategoriesCount = 0;
+// TODO: rather save an index into gCategories?
+const char *kConsumption = "consumption";
+size_t kConsumptionLen = strlen("consumption");
+// Serialized BytesTrie for mapping from base units to indices into gCategories.
+char *gSerializedUnitCategoriesTrie = nullptr;
 
 UBool U_CALLCONV cleanupUnitExtras() {
-    uprv_free(kSerializedUnitExtrasStemTrie);
-    kSerializedUnitExtrasStemTrie = nullptr;
+    uprv_free(gSerializedUnitCategoriesTrie);
+    gSerializedUnitCategoriesTrie = nullptr;
+    uprv_free(gCategories);
+    gCategories = nullptr;
+    uprv_free(gSerializedUnitExtrasStemTrie);
+    gSerializedUnitExtrasStemTrie = nullptr;
+    uprv_free(gSimpleUnitCategories);
+    gSimpleUnitCategories = nullptr;
+    uprv_free(gSimpleUnits);
+    gSimpleUnits = nullptr;
     gUnitExtrasInitOnce.reset();
     return TRUE;
 }
 
 void U_CALLCONV initUnitExtras(UErrorCode& status) {
     ucln_i18n_registerCleanup(UCLN_I18N_UNIT_EXTRAS, cleanupUnitExtras);
+    LocalUResourceBundlePointer unitsBundle(ures_openDirect(nullptr, "units", &status));
+
+    // Collect unitQuantities information into gSerializedUnitCategoriesTrie and gCategories.
+    const char *CATEGORY_TABLE_NAME = "unitQuantities";
+    LocalUResourceBundlePointer unitQuantities(
+        ures_getByKey(unitsBundle.getAlias(), CATEGORY_TABLE_NAME, nullptr, &status));
+    if (U_FAILURE(status)) { return; }
+    gCategoriesCount = unitQuantities.getAlias()->fSize;
+    size_t quantitiesMallocSize = sizeof(UChar *) * gCategoriesCount;
+    gCategories = static_cast<const UChar **>(uprv_malloc(quantitiesMallocSize));
+    if (gCategories == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    uprv_memset(gCategories, 0, quantitiesMallocSize);
+    BytesTrieBuilder quantitiesBuilder(status);
+    CategoriesSink categoriesSink(gCategories, gCategoriesCount, quantitiesBuilder);
+    ures_getAllItemsWithFallback(unitsBundle.getAlias(), CATEGORY_TABLE_NAME, categoriesSink, status);
+    StringPiece resultQuantities = quantitiesBuilder.buildStringPiece(USTRINGTRIE_BUILD_FAST, status);
+    if (U_FAILURE(status)) { return; }
+    // Copy the result into the global constant pointer
+    size_t numBytesQuantities = resultQuantities.length();
+    gSerializedUnitCategoriesTrie = static_cast<char *>(uprv_malloc(numBytesQuantities));
+    if (gSerializedUnitCategoriesTrie == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    uprv_memcpy(gSerializedUnitCategoriesTrie, resultQuantities.data(), numBytesQuantities);
+
+    // Build the BytesTrie that Parser needs for parsing unit identifiers.
 
-    UCharsTrieBuilder b(status);
+    BytesTrieBuilder b(status);
     if (U_FAILURE(status)) { return; }
 
-    // Add SI prefixes
-    for (const auto& siPrefixInfo : gSIPrefixStrings) {
-        UnicodeString uSIPrefix(siPrefixInfo.string, -1, US_INV);
-        b.add(uSIPrefix, siPrefixInfo.value + kSIPrefixOffset, status);
+    // Add SI and binary prefixes
+    for (const auto& unitPrefixInfo : gUnitPrefixStrings) {
+        b.add(unitPrefixInfo.string, unitPrefixInfo.value + kPrefixOffset, status);
     }
     if (U_FAILURE(status)) { return; }
 
     // Add syntax parts (compound, power prefixes)
-    b.add(u"-per-", COMPOUND_PART_PER, status);
-    b.add(u"-", COMPOUND_PART_TIMES, status);
-    b.add(u"-and-", COMPOUND_PART_AND, status);
-    b.add(u"per-", INITIAL_COMPOUND_PART_PER, status);
-    b.add(u"square-", POWER_PART_P2, status);
-    b.add(u"cubic-", POWER_PART_P3, status);
-    b.add(u"p2-", POWER_PART_P2, status);
-    b.add(u"p3-", POWER_PART_P3, status);
-    b.add(u"p4-", POWER_PART_P4, status);
-    b.add(u"p5-", POWER_PART_P5, status);
-    b.add(u"p6-", POWER_PART_P6, status);
-    b.add(u"p7-", POWER_PART_P7, status);
-    b.add(u"p8-", POWER_PART_P8, status);
-    b.add(u"p9-", POWER_PART_P9, status);
-    b.add(u"p10-", POWER_PART_P10, status);
-    b.add(u"p11-", POWER_PART_P11, status);
-    b.add(u"p12-", POWER_PART_P12, status);
-    b.add(u"p13-", POWER_PART_P13, status);
-    b.add(u"p14-", POWER_PART_P14, status);
-    b.add(u"p15-", POWER_PART_P15, status);
+    b.add("-per-", COMPOUND_PART_PER, status);
+    b.add("-", COMPOUND_PART_TIMES, status);
+    b.add("-and-", COMPOUND_PART_AND, status);
+    b.add("per-", INITIAL_COMPOUND_PART_PER, status);
+    b.add("square-", POWER_PART_P2, status);
+    b.add("cubic-", POWER_PART_P3, status);
+    b.add("pow2-", POWER_PART_P2, status);
+    b.add("pow3-", POWER_PART_P3, status);
+    b.add("pow4-", POWER_PART_P4, status);
+    b.add("pow5-", POWER_PART_P5, status);
+    b.add("pow6-", POWER_PART_P6, status);
+    b.add("pow7-", POWER_PART_P7, status);
+    b.add("pow8-", POWER_PART_P8, status);
+    b.add("pow9-", POWER_PART_P9, status);
+    b.add("pow10-", POWER_PART_P10, status);
+    b.add("pow11-", POWER_PART_P11, status);
+    b.add("pow12-", POWER_PART_P12, status);
+    b.add("pow13-", POWER_PART_P13, status);
+    b.add("pow14-", POWER_PART_P14, status);
+    b.add("pow15-", POWER_PART_P15, status);
+    if (U_FAILURE(status)) { return; }
+
+    // Add sanctioned simple units by offset: simple units all have entries in
+    // units/convertUnits resources.
+    LocalUResourceBundlePointer convertUnits(
+        ures_getByKey(unitsBundle.getAlias(), "convertUnits", nullptr, &status));
     if (U_FAILURE(status)) { return; }
 
-    // Add sanctioned simple units by offset
-    int32_t simpleUnitOffset = kSimpleUnitOffset;
-    for (auto simpleUnit : gSimpleUnits) {
-        b.add(simpleUnit, simpleUnitOffset++, status);
+    // Allocate enough space: with identifierSink below skipping kilogram, we're
+    // probably allocating one more than needed.
+    int32_t simpleUnitsCount = convertUnits.getAlias()->fSize;
+    int32_t arrayMallocSize = sizeof(char *) * simpleUnitsCount;
+    gSimpleUnits = static_cast<const char **>(uprv_malloc(arrayMallocSize));
+    if (gSimpleUnits == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    uprv_memset(gSimpleUnits, 0, arrayMallocSize);
+    arrayMallocSize = sizeof(int32_t) * simpleUnitsCount;
+    gSimpleUnitCategories = static_cast<int32_t *>(uprv_malloc(arrayMallocSize));
+    if (gSimpleUnitCategories == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
     }
+    uprv_memset(gSimpleUnitCategories, 0, arrayMallocSize);
+
+    // Populate gSimpleUnits and build the associated trie.
+    SimpleUnitIdentifiersSink identifierSink(resultQuantities, gSimpleUnits, gSimpleUnitCategories,
+                                             simpleUnitsCount, b, kSimpleUnitOffset);
+    ures_getAllItemsWithFallback(unitsBundle.getAlias(), "convertUnits", identifierSink, status);
 
     // Build the CharsTrie
     // TODO: Use SLOW or FAST here?
-    UnicodeString result;
-    b.buildUnicodeString(USTRINGTRIE_BUILD_FAST, result, status);
+    StringPiece result = b.buildStringPiece(USTRINGTRIE_BUILD_FAST, status);
     if (U_FAILURE(status)) { return; }
 
     // Copy the result into the global constant pointer
-    size_t numBytes = result.length() * sizeof(char16_t);
-    kSerializedUnitExtrasStemTrie = static_cast<char16_t*>(uprv_malloc(numBytes));
-    uprv_memcpy(kSerializedUnitExtrasStemTrie, result.getBuffer(), numBytes);
+    size_t numBytes = result.length();
+    gSerializedUnitExtrasStemTrie = static_cast<char *>(uprv_malloc(numBytes));
+    if (gSerializedUnitExtrasStemTrie == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    uprv_memcpy(gSerializedUnitExtrasStemTrie, result.data(), numBytes);
 }
 
 class Token {
@@ -287,7 +471,7 @@ public:
 
     enum Type {
         TYPE_UNDEFINED,
-        TYPE_SI_PREFIX,
+        TYPE_PREFIX,
         // Token type for "-per-", "-", and "-and-".
         TYPE_COMPOUND_PART,
         // Token type for "per-".
@@ -301,7 +485,7 @@ public:
     Type getType() const {
         U_ASSERT(fMatch > 0);
         if (fMatch < kCompoundPartOffset) {
-            return TYPE_SI_PREFIX;
+            return TYPE_PREFIX;
         }
         if (fMatch < kInitialCompoundPartOffset) {
             return TYPE_COMPOUND_PART;
@@ -315,9 +499,9 @@ public:
         return TYPE_SIMPLE_UNIT;
     }
 
-    UMeasureSIPrefix getSIPrefix() const {
-        U_ASSERT(getType() == TYPE_SI_PREFIX);
-        return static_cast<UMeasureSIPrefix>(fMatch - kSIPrefixOffset);
+    UMeasurePrefix getUnitPrefix() const {
+        U_ASSERT(getType() == TYPE_PREFIX);
+        return static_cast<UMeasurePrefix>(fMatch - kPrefixOffset);
     }
 
     // Valid only for tokens with type TYPE_COMPOUND_PART.
@@ -373,7 +557,53 @@ public:
 
     MeasureUnitImpl parse(UErrorCode& status) {
         MeasureUnitImpl result;
-        parseImpl(result, status);
+
+        if (U_FAILURE(status)) {
+            return result;
+        }
+        if (fSource.empty()) {
+            // The dimenionless unit: nothing to parse. leave result as is.
+            return result;
+        }
+
+        while (hasNext()) {
+            bool sawAnd = false;
+
+            SingleUnitImpl singleUnit = nextSingleUnit(sawAnd, status);
+            if (U_FAILURE(status)) {
+                return result;
+            }
+
+            bool added = result.appendSingleUnit(singleUnit, status);
+            if (U_FAILURE(status)) {
+                return result;
+            }
+
+            if (sawAnd && !added) {
+                // Two similar units are not allowed in a mixed unit.
+                status = kUnitIdentifierSyntaxError;
+                return result;
+            }
+
+            if (result.singleUnits.length() >= 2) {
+                // nextSingleUnit fails appropriately for "per" and "and" in the
+                // same identifier. It doesn't fail for other compound units
+                // (COMPOUND_PART_TIMES). Consequently we take care of that
+                // here.
+                UMeasureUnitComplexity complexity =
+                    sawAnd ? UMEASURE_UNIT_MIXED : UMEASURE_UNIT_COMPOUND;
+                if (result.singleUnits.length() == 2) {
+                    // After appending two singleUnits, the complexity will be `UMEASURE_UNIT_COMPOUND`
+                    U_ASSERT(result.complexity == UMEASURE_UNIT_COMPOUND);
+                    result.complexity = complexity;
+                } else if (result.complexity != complexity) {
+                    // Can't have mixed compound units
+                    status = kUnitIdentifierSyntaxError;
+                    return result;
+                }
+            }
+        }
+
         return result;
     }
 
@@ -385,7 +615,7 @@ private:
     // should live longer than this Parser - and the parser shouldn't return any
     // references to that string.
     StringPiece fSource;
-    UCharsTrie fTrie;
+    BytesTrie fTrie;
 
     // Set to true when we've seen a "-per-" or a "per-", after which all units
     // are in the denominator. Until we find an "-and-", at which point the
@@ -395,7 +625,7 @@ private:
     Parser() : fSource(""), fTrie(u"") {}
 
     Parser(StringPiece source)
-        : fSource(source), fTrie(kSerializedUnitExtrasStemTrie) {}
+        : fSource(source), fTrie(gSerializedUnitExtrasStemTrie) {}
 
     inline bool hasNext() const {
         return fIndex < fSource.length();
@@ -450,20 +680,23 @@ private:
      * unit", sawAnd is set to true. If not, it is left as is.
      * @param status ICU error code.
      */
-    void nextSingleUnit(SingleUnitImpl& result, bool& sawAnd, UErrorCode& status) {
+    SingleUnitImpl nextSingleUnit(bool &sawAnd, UErrorCode &status) {
+        SingleUnitImpl result;
         if (U_FAILURE(status)) {
-            return;
+            return result;
         }
 
         // state:
-        // 0 = no tokens seen yet (will accept power, SI prefix, or simple unit)
+        // 0 = no tokens seen yet (will accept power, SI or binary prefix, or simple unit)
         // 1 = power token seen (will not accept another power token)
-        // 2 = SI prefix token seen (will not accept a power or SI prefix token)
+        // 2 = SI or binary prefix token seen (will not accept a power, or SI or binary prefix token)
         int32_t state = 0;
 
         bool atStart = fIndex == 0;
         Token token = nextToken(status);
-        if (U_FAILURE(status)) { return; }
+        if (U_FAILURE(status)) {
+            return result;
+        }
 
         if (atStart) {
             // Identifiers optionally start with "per-".
@@ -473,14 +706,16 @@ private:
                 result.dimensionality = -1;
 
                 token = nextToken(status);
-                if (U_FAILURE(status)) { return; }
+                if (U_FAILURE(status)) {
+                    return result;
+                }
             }
         } else {
             // All other SingleUnit's are separated from previous SingleUnit's
             // via a compound part:
             if (token.getType() != Token::TYPE_COMPOUND_PART) {
                 status = kUnitIdentifierSyntaxError;
-                return;
+                return result;
             }
 
             switch (token.getMatch()) {
@@ -489,7 +724,7 @@ private:
                     // Mixed compound units not yet supported,
                     // TODO(CLDR-13700).
                     status = kUnitIdentifierSyntaxError;
-                    return;
+                    return result;
                 }
                 fAfterPer = true;
                 result.dimensionality = -1;
@@ -506,14 +741,16 @@ private:
                     // Can't start with "-and-", and mixed compound units
                     // not yet supported, TODO(CLDR-13700).
                     status = kUnitIdentifierSyntaxError;
-                    return;
+                    return result;
                 }
                 sawAnd = true;
                 break;
             }
 
             token = nextToken(status);
-            if (U_FAILURE(status)) { return; }
+            if (U_FAILURE(status)) {
+                return result;
+            }
         }
 
         // Read tokens until we have a complete SingleUnit or we reach the end.
@@ -522,87 +759,46 @@ private:
                 case Token::TYPE_POWER_PART:
                     if (state > 0) {
                         status = kUnitIdentifierSyntaxError;
-                        return;
+                        return result;
                     }
                     result.dimensionality *= token.getPower();
                     state = 1;
                     break;
 
-                case Token::TYPE_SI_PREFIX:
+                case Token::TYPE_PREFIX:
                     if (state > 1) {
                         status = kUnitIdentifierSyntaxError;
-                        return;
+                        return result;
                     }
-                    result.siPrefix = token.getSIPrefix();
+                    result.unitPrefix = token.getUnitPrefix();
                     state = 2;
                     break;
 
                 case Token::TYPE_SIMPLE_UNIT:
                     result.index = token.getSimpleUnitIndex();
-                    return;
+                    return result;
 
                 default:
                     status = kUnitIdentifierSyntaxError;
-                    return;
+                    return result;
             }
 
             if (!hasNext()) {
                 // We ran out of tokens before finding a complete single unit.
                 status = kUnitIdentifierSyntaxError;
-                return;
+                return result;
             }
             token = nextToken(status);
             if (U_FAILURE(status)) {
-                return;
+                return result;
             }
         }
-    }
 
-    /// @param result is modified, not overridden. Caller must pass in a
-    /// default-constructed (empty) MeasureUnitImpl instance.
-    void parseImpl(MeasureUnitImpl& result, UErrorCode& status) {
-        if (U_FAILURE(status)) {
-            return;
-        }
-        if (fSource.empty()) {
-            // The dimenionless unit: nothing to parse. leave result as is.
-            return;
-        }
-        int32_t unitNum = 0;
-        while (hasNext()) {
-            bool sawAnd = false;
-            SingleUnitImpl singleUnit;
-            nextSingleUnit(singleUnit, sawAnd, status);
-            if (U_FAILURE(status)) {
-                return;
-            }
-            U_ASSERT(!singleUnit.isDimensionless());
-            bool added = result.append(singleUnit, status);
-            if (sawAnd && !added) {
-                // Two similar units are not allowed in a mixed unit
-                status = kUnitIdentifierSyntaxError;
-                return;
-            }
-            if ((++unitNum) >= 2) {
-                // nextSingleUnit fails appropriately for "per" and "and" in the
-                // same identifier. It doesn't fail for other compound units
-                // (COMPOUND_PART_TIMES). Consequently we take care of that
-                // here.
-                UMeasureUnitComplexity complexity =
-                    sawAnd ? UMEASURE_UNIT_MIXED : UMEASURE_UNIT_COMPOUND;
-                if (unitNum == 2) {
-                    U_ASSERT(result.complexity == UMEASURE_UNIT_SINGLE);
-                    result.complexity = complexity;
-                } else if (result.complexity != complexity) {
-                    // Can't have mixed compound units
-                    status = kUnitIdentifierSyntaxError;
-                    return;
-                }
-            }
-        }
+        return result;
     }
 };
 
+// Sorting function wrapping SingleUnitImpl::compareTo for use with uprv_sortArray.
 int32_t U_CALLCONV
 compareSingleUnits(const void* /*context*/, const void* left, const void* right) {
     auto realLeft = static_cast<const SingleUnitImpl* const*>(left);
@@ -610,162 +806,86 @@ compareSingleUnits(const void* /*context*/, const void* left, const void* right)
     return (*realLeft)->compareTo(**realRight);
 }
 
-/**
- * Generate the identifier string for a single unit in place.
- *
- * Does not support the dimensionless SingleUnitImpl: calling serializeSingle
- * with the dimensionless unit results in an U_INTERNAL_PROGRAM_ERROR.
- *
- * @param first If singleUnit is part of a compound unit, and not its first
- * single unit, set this to false. Otherwise: set to true.
- */
-void serializeSingle(const SingleUnitImpl& singleUnit, bool first, CharString& output, UErrorCode& status) {
-    if (first && singleUnit.dimensionality < 0) {
-        // Essentially the "unary per". For compound units with a numerator, the
-        // caller takes care of the "binary per".
-        output.append("per-", status);
-    }
-
-    if (singleUnit.isDimensionless()) {
-        status = U_INTERNAL_PROGRAM_ERROR;
-        return;
-    }
-    int8_t posPower = std::abs(singleUnit.dimensionality);
-    if (posPower == 0) {
-        status = U_INTERNAL_PROGRAM_ERROR;
-    } else if (posPower == 1) {
-        // no-op
-    } else if (posPower == 2) {
-        output.append("square-", status);
-    } else if (posPower == 3) {
-        output.append("cubic-", status);
-    } else if (posPower < 10) {
-        output.append('p', status);
-        output.append(posPower + '0', status);
-        output.append('-', status);
-    } else if (posPower <= 15) {
-        output.append("p1", status);
-        output.append('0' + (posPower % 10), status);
-        output.append('-', status);
-    } else {
-        status = kUnitIdentifierSyntaxError;
-    }
+// Returns an index into the gCategories array, for the "unitQuantity" (aka
+// "type" or "category") associated with the given base unit identifier. Returns
+// -1 on failure, together with U_UNSUPPORTED_ERROR.
+int32_t getUnitCategoryIndex(StringPiece baseUnitIdentifier, UErrorCode &status) {
+    umtx_initOnce(gUnitExtrasInitOnce, &initUnitExtras, status);
     if (U_FAILURE(status)) {
-        return;
+        return -1;
     }
-
-    if (singleUnit.siPrefix != UMEASURE_SI_PREFIX_ONE) {
-        for (const auto& siPrefixInfo : gSIPrefixStrings) {
-            if (siPrefixInfo.value == singleUnit.siPrefix) {
-                output.append(siPrefixInfo.string, status);
-                break;
-            }
-        }
+    BytesTrie trie(gSerializedUnitCategoriesTrie);
+    UStringTrieResult result = trie.next(baseUnitIdentifier.data(), baseUnitIdentifier.length());
+    if (!USTRINGTRIE_HAS_VALUE(result)) {
+        status = U_UNSUPPORTED_ERROR;
+        return -1;
     }
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    output.appendInvariantChars(gSimpleUnits[singleUnit.index], status);
+    return trie.getValue();
 }
 
-/**
- * Normalize a MeasureUnitImpl and generate the identifier string in place.
- */
-void serialize(MeasureUnitImpl& impl, UErrorCode& status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    U_ASSERT(impl.identifier.isEmpty());
-    if (impl.units.length() == 0) {
-        // Dimensionless, constructed by the default constructor: no appending
-        // to impl.identifier, we wish it to contain the zero-length string.
-        return;
-    }
-    if (impl.complexity == UMEASURE_UNIT_COMPOUND) {
-        // Note: don't sort a MIXED unit
-        uprv_sortArray(
-            impl.units.getAlias(),
-            impl.units.length(),
-            sizeof(impl.units[0]),
-            compareSingleUnits,
-            nullptr,
-            false,
-            &status);
-        if (U_FAILURE(status)) {
-            return;
-        }
-    }
-    serializeSingle(*impl.units[0], true, impl.identifier, status);
-    if (impl.units.length() == 1) {
-        return;
-    }
-    for (int32_t i = 1; i < impl.units.length(); i++) {
-        const SingleUnitImpl& prev = *impl.units[i-1];
-        const SingleUnitImpl& curr = *impl.units[i];
-        if (impl.complexity == UMEASURE_UNIT_MIXED) {
-            impl.identifier.append("-and-", status);
-            serializeSingle(curr, true, impl.identifier, status);
-        } else {
-            if (prev.dimensionality > 0 && curr.dimensionality < 0) {
-                impl.identifier.append("-per-", status);
-            } else {
-                impl.identifier.append('-', status);
-            }
-            serializeSingle(curr, false, impl.identifier, status);
-        }
+} // namespace
+
+U_CAPI int32_t U_EXPORT2
+umeas_getPrefixPower(UMeasurePrefix unitPrefix) {
+    if (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_BIN &&
+        unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_BIN) {
+        return unitPrefix - UMEASURE_PREFIX_INTERNAL_ONE_BIN;
     }
+    U_ASSERT(unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI &&
+             unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI);
+    return unitPrefix - UMEASURE_PREFIX_ONE;
+}
 
+U_CAPI int32_t U_EXPORT2
+umeas_getPrefixBase(UMeasurePrefix unitPrefix) {
+    if (unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_BIN &&
+        unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_BIN) {
+        return 1024;
+    }
+    U_ASSERT(unitPrefix >= UMEASURE_PREFIX_INTERNAL_MIN_SI &&
+             unitPrefix <= UMEASURE_PREFIX_INTERNAL_MAX_SI);
+    return 10;
 }
 
-/**
- * Appends a SingleUnitImpl to a MeasureUnitImpl.
- *
- * @return true if a new item was added. If unit is the dimensionless unit, it
- * is never added: the return value will always be false.
- */
-bool appendImpl(MeasureUnitImpl& impl, const SingleUnitImpl& unit, UErrorCode& status) {
-    if (unit.isDimensionless()) {
-        // We don't append dimensionless units.
-        return false;
+CharString U_I18N_API getUnitQuantity(StringPiece baseUnitIdentifier, UErrorCode &status) {
+    CharString result;
+    U_ASSERT(result.length() == 0);
+    if (U_FAILURE(status)) {
+        return result;
     }
-    // Find a similar unit that already exists, to attempt to coalesce
-    SingleUnitImpl* oldUnit = nullptr;
-    for (int32_t i = 0; i < impl.units.length(); i++) {
-        auto* candidate = impl.units[i];
-        if (candidate->isCompatibleWith(unit)) {
-            oldUnit = candidate;
+    UErrorCode localStatus = U_ZERO_ERROR;
+    int32_t idx = getUnitCategoryIndex(baseUnitIdentifier, localStatus);
+    if (U_FAILURE(localStatus)) {
+        // TODO(icu-units#130): support inverting any unit, with correct
+        // fallback logic: inversion and fallback may depend on presence or
+        // absence of a usage for that category.
+        if (uprv_strcmp(baseUnitIdentifier.data(), "meter-per-cubic-meter") == 0) {
+            result.append(kConsumption, (int32_t)kConsumptionLen, status);
+            return result;
         }
+        status = U_INVALID_FORMAT_ERROR;
+        return result;
     }
-    if (oldUnit) {
-        // Both dimensionalities will be positive, or both will be negative, by
-        // virtue of isCompatibleWith().
-        oldUnit->dimensionality += unit.dimensionality;
-    } else {
-        SingleUnitImpl* destination = impl.units.emplaceBack();
-        if (!destination) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-            return false;
-        }
-        *destination = unit;
+    if (idx < 0 || idx >= gCategoriesCount) {
+        status = U_INVALID_FORMAT_ERROR;
+        return result;
     }
-    return (oldUnit == nullptr);
+    result.appendInvariantChars(gCategories[idx], u_strlen(gCategories[idx]), status);
+    return result;
 }
 
-} // namespace
-
-
+// In ICU4J, this is MeasureUnit.getSingleUnitImpl().
 SingleUnitImpl SingleUnitImpl::forMeasureUnit(const MeasureUnit& measureUnit, UErrorCode& status) {
     MeasureUnitImpl temp;
     const MeasureUnitImpl& impl = MeasureUnitImpl::forMeasureUnit(measureUnit, temp, status);
     if (U_FAILURE(status)) {
         return {};
     }
-    if (impl.units.length() == 0) {
+    if (impl.singleUnits.length() == 0) {
         return {};
     }
-    if (impl.units.length() == 1) {
-        return *impl.units[0];
+    if (impl.singleUnits.length() == 1) {
+        return *impl.singleUnits[0];
     }
     status = U_ILLEGAL_ARGUMENT_ERROR;
     return {};
@@ -773,10 +893,71 @@ SingleUnitImpl SingleUnitImpl::forMeasureUnit(const MeasureUnit& measureUnit, UE
 
 MeasureUnit SingleUnitImpl::build(UErrorCode& status) const {
     MeasureUnitImpl temp;
-    temp.append(*this, status);
+    temp.appendSingleUnit(*this, status);
+    // TODO(icu-units#28): the MeasureUnitImpl::build() method uses
+    // findBySubtype, which is relatively slow.
+    // - At the time of loading the simple unit IDs, we could also save a
+    //   mapping to the builtin MeasureUnit type and subtype they correspond to.
+    // - This method could then check dimensionality and index, and if both are
+    //   1, directly return MeasureUnit instances very quickly.
     return std::move(temp).build(status);
 }
 
+const char *SingleUnitImpl::getSimpleUnitID() const {
+    return gSimpleUnits[index];
+}
+
+void SingleUnitImpl::appendNeutralIdentifier(CharString &result, UErrorCode &status) const {
+    int32_t absPower = std::abs(this->dimensionality);
+
+    U_ASSERT(absPower > 0); // "this function does not support the dimensionless single units";
+
+    if (absPower == 1) {
+        // no-op
+    } else if (absPower == 2) {
+        result.append(StringPiece("square-"), status);
+    } else if (absPower == 3) {
+        result.append(StringPiece("cubic-"), status);
+    } else if (absPower <= 15) {
+        result.append(StringPiece("pow"), status);
+        result.appendNumber(absPower, status);
+        result.append(StringPiece("-"), status);
+    } else {
+        status = U_ILLEGAL_ARGUMENT_ERROR; // Unit Identifier Syntax Error
+        return;
+    }
+
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    if (this->unitPrefix != UMEASURE_PREFIX_ONE) {
+        bool found = false;
+        for (const auto &unitPrefixInfo : gUnitPrefixStrings) {
+            // TODO: consider using binary search? If we do this, add a unit
+            // test to ensure gUnitPrefixStrings is sorted?
+            if (unitPrefixInfo.value == this->unitPrefix) {
+                result.append(unitPrefixInfo.string, status);
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            status = U_UNSUPPORTED_ERROR;
+            return;
+        }
+    }
+
+    result.append(StringPiece(this->getSimpleUnitID()), status);
+}
+
+int32_t SingleUnitImpl::getUnitCategoryIndex() const {
+    return gSimpleUnitCategories[index];
+}
+
+MeasureUnitImpl::MeasureUnitImpl(const SingleUnitImpl &singleUnit, UErrorCode &status) {
+    this->appendSingleUnit(singleUnit, status);
+}
 
 MeasureUnitImpl MeasureUnitImpl::forIdentifier(StringPiece identifier, UErrorCode& status) {
     return Parser::from(identifier, status).parse(status);
@@ -803,22 +984,138 @@ MeasureUnitImpl MeasureUnitImpl::forMeasureUnitMaybeCopy(
 
 void MeasureUnitImpl::takeReciprocal(UErrorCode& /*status*/) {
     identifier.clear();
-    for (int32_t i = 0; i < units.length(); i++) {
-        units[i]->dimensionality *= -1;
+    for (int32_t i = 0; i < singleUnits.length(); i++) {
+        singleUnits[i]->dimensionality *= -1;
     }
 }
 
-bool MeasureUnitImpl::append(const SingleUnitImpl& singleUnit, UErrorCode& status) {
+bool MeasureUnitImpl::appendSingleUnit(const SingleUnitImpl &singleUnit, UErrorCode &status) {
     identifier.clear();
-    return appendImpl(*this, singleUnit, status);
+
+    if (singleUnit.isDimensionless()) {
+        // Do not append dimensionless units.
+        return false;
+    }
+
+    // Find a similar unit that already exists, to attempt to coalesce
+    SingleUnitImpl *oldUnit = nullptr;
+    for (int32_t i = 0; i < this->singleUnits.length(); i++) {
+        auto *candidate = this->singleUnits[i];
+        if (candidate->isCompatibleWith(singleUnit)) {
+            oldUnit = candidate;
+        }
+    }
+
+    if (oldUnit) {
+        // Both dimensionalities will be positive, or both will be negative, by
+        // virtue of isCompatibleWith().
+        oldUnit->dimensionality += singleUnit.dimensionality;
+
+        return false;
+    }
+
+    // Add a copy of singleUnit
+    // NOTE: MaybeStackVector::emplaceBackAndCheckErrorCode creates new copy of  singleUnit.
+    this->singleUnits.emplaceBackAndCheckErrorCode(status, singleUnit);
+    if (U_FAILURE(status)) {
+        return false;
+    }
+
+    // If the MeasureUnitImpl is `UMEASURE_UNIT_SINGLE` and after the appending a unit, the `singleUnits`
+    // contains more than one. thus means the complexity should be `UMEASURE_UNIT_COMPOUND`
+    if (this->singleUnits.length() > 1 &&
+        this->complexity == UMeasureUnitComplexity::UMEASURE_UNIT_SINGLE) {
+        this->complexity = UMeasureUnitComplexity::UMEASURE_UNIT_COMPOUND;
+    }
+
+    return true;
+}
+
+MaybeStackVector<MeasureUnitImplWithIndex>
+MeasureUnitImpl::extractIndividualUnitsWithIndices(UErrorCode &status) const {
+    MaybeStackVector<MeasureUnitImplWithIndex> result;
+
+    if (this->complexity != UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
+        result.emplaceBackAndCheckErrorCode(status, 0, *this, status);
+        return result;
+    }
+
+    for (int32_t i = 0; i < singleUnits.length(); ++i) {
+        result.emplaceBackAndCheckErrorCode(status, i, *singleUnits[i], status);
+        if (U_FAILURE(status)) {
+            return result;
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Normalize a MeasureUnitImpl and generate the identifier string in place.
+ */
+void MeasureUnitImpl::serialize(UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    if (this->singleUnits.length() == 0) {
+        // Dimensionless, constructed by the default constructor.
+        return;
+    }
+
+    if (this->complexity == UMEASURE_UNIT_COMPOUND) {
+        // Note: don't sort a MIXED unit
+        uprv_sortArray(this->singleUnits.getAlias(), this->singleUnits.length(),
+                       sizeof(this->singleUnits[0]), compareSingleUnits, nullptr, false, &status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+    }
+
+    CharString result;
+    bool beforePer = true;
+    bool firstTimeNegativeDimension = false;
+    for (int32_t i = 0; i < this->singleUnits.length(); i++) {
+        if (beforePer && (*this->singleUnits[i]).dimensionality < 0) {
+            beforePer = false;
+            firstTimeNegativeDimension = true;
+        } else if ((*this->singleUnits[i]).dimensionality < 0) {
+            firstTimeNegativeDimension = false;
+        }
+
+        if (U_FAILURE(status)) {
+            return;
+        }
+
+        if (this->complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
+            if (result.length() != 0) {
+                result.append(StringPiece("-and-"), status);
+            }
+        } else {
+            if (firstTimeNegativeDimension) {
+                if (result.length() == 0) {
+                    result.append(StringPiece("per-"), status);
+                } else {
+                    result.append(StringPiece("-per-"), status);
+                }
+            } else {
+                if (result.length() != 0) {
+                    result.append(StringPiece("-"), status);
+                }
+            }
+        }
+
+        this->singleUnits[i]->appendNeutralIdentifier(result, status);
+    }
+
+    this->identifier = CharString(result, status);
 }
 
 MeasureUnit MeasureUnitImpl::build(UErrorCode& status) && {
-    serialize(*this, status);
+    this->serialize(status);
     return MeasureUnit(std::move(*this));
 }
 
-
 MeasureUnit MeasureUnit::forIdentifier(StringPiece identifier, UErrorCode& status) {
     return Parser::from(identifier, status).parse(status).build(status);
 }
@@ -828,13 +1125,13 @@ UMeasureUnitComplexity MeasureUnit::getComplexity(UErrorCode& status) const {
     return MeasureUnitImpl::forMeasureUnit(*this, temp, status).complexity;
 }
 
-UMeasureSIPrefix MeasureUnit::getSIPrefix(UErrorCode& status) const {
-    return SingleUnitImpl::forMeasureUnit(*this, status).siPrefix;
+UMeasurePrefix MeasureUnit::getPrefix(UErrorCode& status) const {
+    return SingleUnitImpl::forMeasureUnit(*this, status).unitPrefix;
 }
 
-MeasureUnit MeasureUnit::withSIPrefix(UMeasureSIPrefix prefix, UErrorCode& status) const {
+MeasureUnit MeasureUnit::withPrefix(UMeasurePrefix prefix, UErrorCode& status) const {
     SingleUnitImpl singleUnit = SingleUnitImpl::forMeasureUnit(*this, status);
-    singleUnit.siPrefix = prefix;
+    singleUnit.unitPrefix = prefix;
     return singleUnit.build(status);
 }
 
@@ -867,22 +1164,26 @@ MeasureUnit MeasureUnit::product(const MeasureUnit& other, UErrorCode& status) c
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return {};
     }
-    for (int32_t i = 0; i < otherImpl.units.length(); i++) {
-        impl.append(*otherImpl.units[i], status);
+    for (int32_t i = 0; i < otherImpl.singleUnits.length(); i++) {
+        impl.appendSingleUnit(*otherImpl.singleUnits[i], status);
     }
-    if (impl.units.length() > 1) {
+    if (impl.singleUnits.length() > 1) {
         impl.complexity = UMEASURE_UNIT_COMPOUND;
     }
     return std::move(impl).build(status);
 }
 
-LocalArray<MeasureUnit> MeasureUnit::splitToSingleUnits(int32_t& outCount, UErrorCode& status) const {
+LocalArray<MeasureUnit> MeasureUnit::splitToSingleUnitsImpl(int32_t& outCount, UErrorCode& status) const {
     MeasureUnitImpl temp;
     const MeasureUnitImpl& impl = MeasureUnitImpl::forMeasureUnit(*this, temp, status);
-    outCount = impl.units.length();
+    outCount = impl.singleUnits.length();
     MeasureUnit* arr = new MeasureUnit[outCount];
+    if (arr == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return LocalArray<MeasureUnit>();
+    }
     for (int32_t i = 0; i < outCount; i++) {
-        arr[i] = impl.units[i]->build(status);
+        arr[i] = impl.singleUnits[i]->build(status);
     }
     return LocalArray<MeasureUnit>(arr, status);
 }
diff --git a/deps/icu-small/source/i18n/measunit_impl.h b/deps/icu-small/source/i18n/measunit_impl.h
index c886d3c29a38b29bbad47b5cc5c711cb7eb248cd..5028210ab09b3de60e6132203c618cea1502ca82 100644
--- a/deps/icu-small/source/i18n/measunit_impl.h
+++ b/deps/icu-small/source/i18n/measunit_impl.h
@@ -14,15 +14,33 @@
 
 U_NAMESPACE_BEGIN
 
+namespace number {
+namespace impl {
+class LongNameHandler;
+}
+} // namespace number
 
 static const char16_t kDefaultCurrency[] = u"XXX";
 static const char kDefaultCurrency8[] = "XXX";
 
+/**
+ * Looks up the "unitQuantity" (aka "type" or "category") of a base unit
+ * identifier. The category is returned via `result`, which must initially be
+ * empty.
+ *
+ * This only supports base units: other units must be resolved to base units
+ * before passing to this function, otherwise U_UNSUPPORTED_ERROR status will be
+ * returned.
+ *
+ * Categories are found in `unitQuantities` in the `units` resource (see
+ * `units.txt`).
+ */
+CharString U_I18N_API getUnitQuantity(StringPiece baseUnitIdentifier, UErrorCode &status);
 
 /**
- * A struct representing a single unit (optional SI prefix and dimensionality).
+ * A struct representing a single unit (optional SI or binary prefix, and dimensionality).
  */
-struct SingleUnitImpl : public UMemory {
+struct U_I18N_API SingleUnitImpl : public UMemory {
     /**
      * Gets a single unit from the MeasureUnit. If there are multiple single units, sets an error
      * code and returns the base dimensionless unit. Parses if necessary.
@@ -32,10 +50,36 @@ struct SingleUnitImpl : public UMemory {
     /** Transform this SingleUnitImpl into a MeasureUnit, simplifying if possible. */
     MeasureUnit build(UErrorCode& status) const;
 
+    /**
+     * Returns the "simple unit ID", without SI or dimensionality prefix: this
+     * instance may represent a square-kilometer, but only "meter" will be
+     * returned.
+     *
+     * The returned pointer points at memory that exists for the duration of the
+     * program's running.
+     */
+    const char *getSimpleUnitID() const;
+
+    /**
+     * Generates and append a neutral identifier string for a single unit which means we do not include
+     * the dimension signal.
+     */
+    void appendNeutralIdentifier(CharString &result, UErrorCode &status) const;
+
+    /**
+     * Returns the index of this unit's "quantity" in unitQuantities (in
+     * measunit_extra.cpp). The value of this index determines sort order for
+     * normalization of unit identifiers.
+     */
+    int32_t getUnitCategoryIndex() const;
+
     /**
      * Compare this SingleUnitImpl to another SingleUnitImpl for the sake of
      * sorting and coalescing.
      *
+     * Sort order of units is specified by UTS #35
+     * (https://unicode.org/reports/tr35/tr35-info.html#Unit_Identifier_Normalization).
+     *
      * Takes the sign of dimensionality into account, but not the absolute
      * value: per-meter is not considered the same as meter, but meter is
      * considered the same as square-meter.
@@ -52,16 +96,29 @@ struct SingleUnitImpl : public UMemory {
         if (dimensionality > 0 && other.dimensionality < 0) {
             return -1;
         }
+        // Sort by official quantity order
+        int32_t thisQuantity = this->getUnitCategoryIndex();
+        int32_t otherQuantity = other.getUnitCategoryIndex();
+        if (thisQuantity < otherQuantity) {
+            return -1;
+        }
+        if (thisQuantity > otherQuantity) {
+            return 1;
+        }
+        // If quantity order didn't help, then we go by index.
         if (index < other.index) {
             return -1;
         }
         if (index > other.index) {
             return 1;
         }
-        if (siPrefix < other.siPrefix) {
+        // TODO: revisit if the spec dictates prefix sort order - it doesn't
+        // currently. For now we're sorting binary prefixes before SI prefixes,
+        // as per enum values order.
+        if (unitPrefix < other.unitPrefix) {
             return -1;
         }
-        if (siPrefix > other.siPrefix) {
+        if (unitPrefix > other.unitPrefix) {
             return 1;
         }
         return 0;
@@ -70,8 +127,8 @@ struct SingleUnitImpl : public UMemory {
     /**
      * Return whether this SingleUnitImpl is compatible with another for the purpose of coalescing.
      *
-     * Units with the same base unit and SI prefix should match, except that they must also have
-     * the same dimensionality sign, such that we don't merge numerator and denominator.
+     * Units with the same base unit and SI or binary prefix should match, except that they must also
+     * have the same dimensionality sign, such that we don't merge numerator and denominator.
      */
     bool isCompatibleWith(const SingleUnitImpl& other) const {
         return (compareTo(other) == 0);
@@ -88,7 +145,8 @@ struct SingleUnitImpl : public UMemory {
 
     /**
      * Simple unit index, unique for every simple unit, -1 for the dimensionless
-     * unit. This is an index into a string list in measunit_extra.cpp.
+     * unit. This is an index into a string list in measunit_extra.cpp, as
+     * loaded by SimpleUnitIdentifiersSink.
      *
      * The default value is -1, meaning the dimensionless unit:
      * isDimensionless() will return true, until index is changed.
@@ -96,11 +154,11 @@ struct SingleUnitImpl : public UMemory {
     int32_t index = -1;
 
     /**
-     * SI prefix.
+     * SI or binary prefix.
      *
      * This is ignored for the dimensionless unit.
      */
-    UMeasureSIPrefix siPrefix = UMEASURE_SI_PREFIX_ONE;
+    UMeasurePrefix unitPrefix = UMEASURE_PREFIX_ONE;
 
     /**
      * Dimensionality.
@@ -110,14 +168,34 @@ struct SingleUnitImpl : public UMemory {
     int32_t dimensionality = 1;
 };
 
+// Forward declaration
+struct MeasureUnitImplWithIndex;
+
+// Export explicit template instantiations of MaybeStackArray, MemoryPool and
+// MaybeStackVector. This is required when building DLLs for Windows. (See
+// datefmt.h, collationiterator.h, erarules.h and others for similar examples.)
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<SingleUnitImpl *, 8>;
+template class U_I18N_API MemoryPool<SingleUnitImpl, 8>;
+template class U_I18N_API MaybeStackVector<SingleUnitImpl, 8>;
+#endif
 
 /**
  * Internal representation of measurement units. Capable of representing all complexities of units,
  * including mixed and compound units.
  */
-struct MeasureUnitImpl : public UMemory {
+class U_I18N_API MeasureUnitImpl : public UMemory {
+  public:
+    MeasureUnitImpl() = default;
+    MeasureUnitImpl(MeasureUnitImpl &&other) = default;
+    // No copy constructor, use MeasureUnitImpl::copy() to make it explicit.
+    MeasureUnitImpl(const MeasureUnitImpl &other, UErrorCode &status) = delete;
+    MeasureUnitImpl(const SingleUnitImpl &singleUnit, UErrorCode &status);
+
+    MeasureUnitImpl &operator=(MeasureUnitImpl &&other) noexcept = default;
+
     /** Extract the MeasureUnitImpl from a MeasureUnit. */
-    static inline const MeasureUnitImpl* get(const MeasureUnit& measureUnit) {
+    static inline const MeasureUnitImpl *get(const MeasureUnit &measureUnit) {
         return measureUnit.fImpl;
     }
 
@@ -169,13 +247,18 @@ struct MeasureUnitImpl : public UMemory {
     /**
      * Create a copy of this MeasureUnitImpl. Don't use copy constructor to make this explicit.
      */
-    inline MeasureUnitImpl copy(UErrorCode& status) const {
-        MeasureUnitImpl result;
-        result.complexity = complexity;
-        result.units.appendAll(units, status);
-        result.identifier.append(identifier, status);
-        return result;
-    }
+    MeasureUnitImpl copy(UErrorCode& status) const;
+
+    /**
+     * Extracts the list of all the individual units inside the `MeasureUnitImpl` with their indices.
+     *      For example:
+     *          -   if the `MeasureUnitImpl` is `foot-per-hour`
+     *                  it will return a list of 1 {(0, `foot-per-hour`)}
+     *          -   if the `MeasureUnitImpl` is `foot-and-inch`
+     *                  it will return a list of 2 {(0, `foot`), (1, `inch`)}
+     */
+    MaybeStackVector<MeasureUnitImplWithIndex>
+    extractIndividualUnitsWithIndices(UErrorCode &status) const;
 
     /** Mutates this MeasureUnitImpl to take the reciprocal. */
     void takeReciprocal(UErrorCode& status);
@@ -186,26 +269,70 @@ struct MeasureUnitImpl : public UMemory {
      * @return true if a new item was added. If unit is the dimensionless unit,
      * it is never added: the return value will always be false.
      */
-    bool append(const SingleUnitImpl& singleUnit, UErrorCode& status);
+    bool appendSingleUnit(const SingleUnitImpl& singleUnit, UErrorCode& status);
 
     /** The complexity, either SINGLE, COMPOUND, or MIXED. */
     UMeasureUnitComplexity complexity = UMEASURE_UNIT_SINGLE;
 
     /**
-     * The list of simple units. These may be summed or multiplied, based on the
+     * The list of single units. These may be summed or multiplied, based on the
      * value of the complexity field.
      *
      * The "dimensionless" unit (SingleUnitImpl default constructor) must not be
      * added to this list.
      */
-    MaybeStackVector<SingleUnitImpl> units;
+    MaybeStackVector<SingleUnitImpl> singleUnits;
 
     /**
      * The full unit identifier.  Owned by the MeasureUnitImpl.  Empty if not computed.
      */
     CharString identifier;
+
+  private:
+    /**
+     * Normalizes a MeasureUnitImpl and generate the identifier string in place.
+     */
+    void serialize(UErrorCode &status);
+
+    // For calling serialize
+    // TODO(icu-units#147): revisit serialization
+    friend class number::impl::LongNameHandler;
+};
+
+struct U_I18N_API MeasureUnitImplWithIndex : public UMemory {
+    const int32_t index;
+    MeasureUnitImpl unitImpl;
+    // Makes a copy of unitImpl.
+    MeasureUnitImplWithIndex(int32_t index, const MeasureUnitImpl &unitImpl, UErrorCode &status)
+        : index(index), unitImpl(unitImpl.copy(status)) {
+    }
+    MeasureUnitImplWithIndex(int32_t index, const SingleUnitImpl &singleUnitImpl, UErrorCode &status)
+        : index(index), unitImpl(MeasureUnitImpl(singleUnitImpl, status)) {
+    }
 };
 
+// Export explicit template instantiations of MaybeStackArray, MemoryPool and
+// MaybeStackVector. This is required when building DLLs for Windows. (See
+// datefmt.h, collationiterator.h, erarules.h and others for similar examples.)
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<MeasureUnitImplWithIndex *, 8>;
+template class U_I18N_API MemoryPool<MeasureUnitImplWithIndex, 8>;
+template class U_I18N_API MaybeStackVector<MeasureUnitImplWithIndex, 8>;
+
+// Export an explicit template instantiation of the LocalPointer that is used as a
+// data member of MeasureUnitImpl.
+// (When building DLLs for Windows this is required.)
+#if defined(_MSC_VER)
+// Ignore warning 4661 as LocalPointerBase does not use operator== or operator!=
+#pragma warning(push)
+#pragma warning(disable : 4661)
+#endif
+template class U_I18N_API LocalPointerBase<MeasureUnitImpl>;
+template class U_I18N_API LocalPointer<MeasureUnitImpl>;
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+#endif
 
 U_NAMESPACE_END
 
diff --git a/deps/icu-small/source/i18n/measure.cpp b/deps/icu-small/source/i18n/measure.cpp
index bffa44215e3cde31f7d01faba6230bd942eac266..23adba100707aa2338433a51664983987bb906e0 100644
--- a/deps/icu-small/source/i18n/measure.cpp
+++ b/deps/icu-small/source/i18n/measure.cpp
@@ -23,7 +23,7 @@ U_NAMESPACE_BEGIN
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Measure)
 
-Measure::Measure() {}
+Measure::Measure() : unit(nullptr) {}
 
 Measure::Measure(const Formattable& _number, MeasureUnit* adoptedUnit,
                  UErrorCode& ec) :
@@ -35,7 +35,7 @@ Measure::Measure(const Formattable& _number, MeasureUnit* adoptedUnit,
 }
 
 Measure::Measure(const Measure& other) :
-    UObject(other), unit(0) {
+    UObject(other), unit(nullptr) {
     *this = other;
 }
 
@@ -43,7 +43,11 @@ Measure& Measure::operator=(const Measure& other) {
     if (this != &other) {
         delete unit;
         number = other.number;
-        unit = other.unit->clone();
+        if (other.unit != nullptr) {
+            unit = other.unit->clone();
+        } else {
+            unit = nullptr;
+        }
     }
     return *this;
 }
diff --git a/deps/icu-small/source/i18n/msgfmt.cpp b/deps/icu-small/source/i18n/msgfmt.cpp
index 3ca368ef954846521a37d0fb3ff744d48397427e..d2631776e83bb0afd1365acbce6081c16937832e 100644
--- a/deps/icu-small/source/i18n/msgfmt.cpp
+++ b/deps/icu-small/source/i18n/msgfmt.cpp
@@ -1107,7 +1107,7 @@ void MessageFormat::format(int32_t msgStart, const void *plNumber,
         } else if (argType == UMSGPAT_ARG_TYPE_NONE || (cachedFormatters && uhash_iget(cachedFormatters, i - 2))) {
             // We arrive here if getCachedFormatter returned NULL, but there was actually an element in the hash table.
             // This can only happen if the hash table contained a DummyFormat, so the if statement above is a check
-            // for the hash table containind DummyFormat.
+            // for the hash table containing DummyFormat.
             if (arg->isNumeric()) {
                 const NumberFormat* nf = getDefaultNumberFormat(success);
                 appendTo.formatAndAppend(nf, *arg, success);
@@ -1440,7 +1440,7 @@ MessageFormat::parse(int32_t msgStart,
             argType==UMSGPAT_ARG_TYPE_NONE || (cachedFormatters && uhash_iget(cachedFormatters, i -2))) {
             // We arrive here if getCachedFormatter returned NULL, but there was actually an element in the hash table.
             // This can only happen if the hash table contained a DummyFormat, so the if statement above is a check
-            // for the hash table containind DummyFormat.
+            // for the hash table containing DummyFormat.
 
             // Match as a string.
             // if at end, use longest possible match
diff --git a/deps/icu-small/source/i18n/name2uni.cpp b/deps/icu-small/source/i18n/name2uni.cpp
index b1812178660421fd84d99c5dc3a97938389e718d..8e13b0025475ed31dcc0b85a8c1fd36bb0197d6d 100644
--- a/deps/icu-small/source/i18n/name2uni.cpp
+++ b/deps/icu-small/source/i18n/name2uni.cpp
@@ -119,7 +119,7 @@ void NameUnicodeTransliterator::handleTransliterate(Replaceable& text, UTransPos
         return;
     }
 
-    // Accomodate the longest possible name
+    // Accommodate the longest possible name
     ++maxLen; // allow for temporary trailing space
     char* cbuf = (char*) uprv_malloc(maxLen);
     if (cbuf == NULL) {
diff --git a/deps/icu-small/source/i18n/nfrs.cpp b/deps/icu-small/source/i18n/nfrs.cpp
index 659cfcbbf5a85781f2783d06cd5500fcbebb9ada..11056dbc68281e2d0601d4785e8b2c0489a03106 100644
--- a/deps/icu-small/source/i18n/nfrs.cpp
+++ b/deps/icu-small/source/i18n/nfrs.cpp
@@ -37,7 +37,7 @@ enum {
     /** 0.x */
     PROPER_FRACTION_RULE_INDEX = 2,
     /** x.0 */
-    MASTER_RULE_INDEX = 3,
+    DEFAULT_RULE_INDEX = 3,
     /** Inf */
     INFINITY_RULE_INDEX = 4,
     /** NaN */
@@ -231,7 +231,7 @@ NFRuleSet::parseRules(UnicodeString& description, UErrorCode& status)
 
     // (this isn't a for loop because we might be deleting items from
     // the vector-- we want to make sure we only increment i when
-    // we _didn't_ delete aything from the vector)
+    // we _didn't_ delete anything from the vector)
     int32_t rulesSize = rules.size();
     for (int32_t i = 0; i < rulesSize; i++) {
         NFRule* rule = rules[i];
@@ -278,8 +278,8 @@ void NFRuleSet::setNonNumericalRule(NFRule *rule) {
     else if (baseValue == NFRule::kProperFractionRule) {
         setBestFractionRule(PROPER_FRACTION_RULE_INDEX, rule, TRUE);
     }
-    else if (baseValue == NFRule::kMasterRule) {
-        setBestFractionRule(MASTER_RULE_INDEX, rule, TRUE);
+    else if (baseValue == NFRule::kDefaultRule) {
+        setBestFractionRule(DEFAULT_RULE_INDEX, rule, TRUE);
     }
     else if (baseValue == NFRule::kInfinityRule) {
         delete nonNumericalRules[INFINITY_RULE_INDEX];
@@ -323,7 +323,7 @@ NFRuleSet::~NFRuleSet()
     for (int i = 0; i < NON_NUMERICAL_RULE_LENGTH; i++) {
         if (i != IMPROPER_FRACTION_RULE_INDEX
             && i != PROPER_FRACTION_RULE_INDEX
-            && i != MASTER_RULE_INDEX)
+            && i != DEFAULT_RULE_INDEX)
         {
             delete nonNumericalRules[i];
         }
@@ -375,7 +375,7 @@ NFRuleSet::setDecimalFormatSymbols(const DecimalFormatSymbols &newSymbols, UErro
         rules[i]->setDecimalFormatSymbols(newSymbols, status);
     }
     // Switch the fraction rules to mirror the DecimalFormatSymbols.
-    for (int32_t nonNumericalIdx = IMPROPER_FRACTION_RULE_INDEX; nonNumericalIdx <= MASTER_RULE_INDEX; nonNumericalIdx++) {
+    for (int32_t nonNumericalIdx = IMPROPER_FRACTION_RULE_INDEX; nonNumericalIdx <= DEFAULT_RULE_INDEX; nonNumericalIdx++) {
         if (nonNumericalRules[nonNumericalIdx]) {
             for (uint32_t fIdx = 0; fIdx < fractionRules.size(); fIdx++) {
                 NFRule *fractionRule = fractionRules[fIdx];
@@ -472,9 +472,9 @@ NFRuleSet::findDoubleRule(double number) const
         }
     }
 
-    // if there's a master rule, use it to format the number
-    if (nonNumericalRules[MASTER_RULE_INDEX]) {
-        return nonNumericalRules[MASTER_RULE_INDEX];
+    // if there's a default rule, use it to format the number
+    if (nonNumericalRules[DEFAULT_RULE_INDEX]) {
+        return nonNumericalRules[DEFAULT_RULE_INDEX];
     }
 
     // and if we haven't yet returned a rule, use findNormalRule()
@@ -507,13 +507,13 @@ NFRuleSet::findNormalRule(int64_t number) const
     // do them in findRule(), because the version of format() that
     // takes a long bypasses findRule() and goes straight to this
     // function.  This function does skip the fraction rules since
-    // we know the value is an integer (it also skips the master
+    // we know the value is an integer (it also skips the default
     // rule, since it's considered a fraction rule.  Skipping the
-    // master rule in this function is also how we avoid infinite
+    // default rule in this function is also how we avoid infinite
     // recursion)
 
     // {dlf} unfortunately this fails if there are no rules except
-    // special rules.  If there are no rules, use the master rule.
+    // special rules.  If there are no rules, use the default rule.
 
     // binary-search the rule list for the applicable rule
     // (a rule is used for all values from its base value to
@@ -553,8 +553,8 @@ NFRuleSet::findNormalRule(int64_t number) const
         }
         return result;
     }
-    // else use the master rule
-    return nonNumericalRules[MASTER_RULE_INDEX];
+    // else use the default rule
+    return nonNumericalRules[DEFAULT_RULE_INDEX];
 }
 
 /**
@@ -647,7 +647,7 @@ NFRuleSet::findFractionRuleSetRule(double number) const
 /**
  * Parses a string.  Matches the string to be parsed against each
  * of its rules (with a base value less than upperBound) and returns
- * the value produced by the rule that matched the most charcters
+ * the value produced by the rule that matched the most characters
  * in the source string.
  * @param text The string to parse
  * @param parsePosition The initial position is ignored and assumed
@@ -792,7 +792,7 @@ NFRuleSet::appendRules(UnicodeString& result) const
         if (nonNumericalRules[i]) {
             if (rule->getBaseValue() == NFRule::kImproperFractionRule
                 || rule->getBaseValue() == NFRule::kProperFractionRule
-                || rule->getBaseValue() == NFRule::kMasterRule)
+                || rule->getBaseValue() == NFRule::kDefaultRule)
             {
                 for (uint32_t fIdx = 0; fIdx < fractionRules.size(); fIdx++) {
                     NFRule *fractionRule = fractionRules[fIdx];
diff --git a/deps/icu-small/source/i18n/nfrs.h b/deps/icu-small/source/i18n/nfrs.h
index c56fc0707851a74b05e961eec1ed23e6d1804ff1..e9b955ddff142d5ff98c0e6f7ca7c8196b79ab43 100644
--- a/deps/icu-small/source/i18n/nfrs.h
+++ b/deps/icu-small/source/i18n/nfrs.h
@@ -36,7 +36,7 @@ public:
     void parseRules(UnicodeString& rules, UErrorCode& status);
     void setNonNumericalRule(NFRule *rule);
     void setBestFractionRule(int32_t originalIndex, NFRule *newRule, UBool rememberRule);
-    void makeIntoFractionRuleSet() { fIsFractionRuleSet = TRUE; }
+    void makeIntoFractionRuleSet() { fIsFractionRuleSet = true; }
 
     ~NFRuleSet();
 
@@ -93,11 +93,11 @@ int64_t util64_fromDouble(double d);
 uint64_t util64_pow(uint32_t radix, uint16_t exponent);
 
 // convert n to digit string in buffer, return length of string
-uint32_t util64_tou(int64_t n, UChar* buffer, uint32_t buflen, uint32_t radix = 10, UBool raw = FALSE);
+uint32_t util64_tou(int64_t n, UChar* buffer, uint32_t buflen, uint32_t radix = 10, UBool raw = false);
 
 #ifdef RBNF_DEBUG
 int64_t util64_utoi(const UChar* str, uint32_t radix = 10);
-uint32_t util64_toa(int64_t n, char* buffer, uint32_t buflen, uint32_t radix = 10, UBool raw = FALSE);
+uint32_t util64_toa(int64_t n, char* buffer, uint32_t buflen, uint32_t radix = 10, UBool raw = false);
 int64_t util64_atoi(const char* str, uint32_t radix);
 #endif
 
diff --git a/deps/icu-small/source/i18n/nfrule.cpp b/deps/icu-small/source/i18n/nfrule.cpp
index b5e7892d5e68cbfd877aa3441e583398c8772bc3..cba41d14bb1fa853e6a5eda4b332e3710d4a2883 100644
--- a/deps/icu-small/source/i18n/nfrule.cpp
+++ b/deps/icu-small/source/i18n/nfrule.cpp
@@ -153,7 +153,7 @@ NFRule::makeRules(UnicodeString& description,
         if ((rule1->baseValue > 0
             && (rule1->baseValue % util64_pow(rule1->radix, rule1->exponent)) == 0)
             || rule1->getType() == kImproperFractionRule
-            || rule1->getType() == kMasterRule) {
+            || rule1->getType() == kDefaultRule) {
 
             // if it passes that test, new up the second rule.  If the
             // rule set both rules will belong to is a fraction rule
@@ -181,9 +181,9 @@ NFRule::makeRules(UnicodeString& description,
             }
 
             // if the description began with "x.0" and contains bracketed
-            // text, it describes both the master rule and the
+            // text, it describes both the default rule and the
             // improper fraction rule
-            else if (rule1->getType() == kMasterRule) {
+            else if (rule1->getType() == kDefaultRule) {
                 rule2->baseValue = rule1->baseValue;
                 rule1->setType(kImproperFractionRule);
             }
@@ -376,7 +376,7 @@ NFRule::parseRuleDescriptor(UnicodeString& description, UErrorCode& status)
                 decimalPoint = descriptor.charAt(1);
             }
             else if (firstChar == gX && lastChar == gZero) {
-                setBaseValue(kMasterRule, status);
+                setBaseValue(kDefaultRule, status);
                 decimalPoint = descriptor.charAt(1);
             }
             else if (descriptor.compare(gNaN, 3) == 0) {
@@ -663,7 +663,7 @@ NFRule::_appendRuleText(UnicodeString& result) const
     case kNegativeNumberRule: result.append(gMinusX, 2); break;
     case kImproperFractionRule: result.append(gX).append(decimalPoint == 0 ? gDot : decimalPoint).append(gX); break;
     case kProperFractionRule: result.append(gZero).append(decimalPoint == 0 ? gDot : decimalPoint).append(gX); break;
-    case kMasterRule: result.append(gX).append(decimalPoint == 0 ? gDot : decimalPoint).append(gZero); break;
+    case kDefaultRule: result.append(gX).append(decimalPoint == 0 ? gDot : decimalPoint).append(gZero); break;
     case kInfinityRule: result.append(gInf, 3); break;
     case kNaNRule: result.append(gNaN, 3); break;
     default:
@@ -1297,6 +1297,10 @@ NFRule::prefixLength(const UnicodeString& str, const UnicodeString& prefix, UErr
 #if !UCONFIG_NO_COLLATION
     // go through all this grief if we're in lenient-parse mode
     if (formatter->isLenient()) {
+        // Check if non-lenient rule finds the text before call lenient parsing
+        if (str.startsWith(prefix)) {
+            return prefix.length();
+        }
         // get the formatter's collator and use it to create two
         // collation element iterators, one over the target string
         // and another over the prefix (right now, we'll throw an
@@ -1505,9 +1509,15 @@ NFRule::findText(const UnicodeString& str,
         return str.indexOf(key, startingAt);
     }
     else {
-        // but if lenient parsing is turned ON, we've got some work
-        // ahead of us
-        return findTextLenient(str, key, startingAt, length);
+        // Check if non-lenient rule finds the text before call lenient parsing
+        *length = key.length();
+        int32_t pos = str.indexOf(key, startingAt);
+        if(pos >= 0) {
+            return pos;
+        } else {
+            // but if lenient parsing is turned ON, we've got some work ahead of us
+            return findTextLenient(str, key, startingAt, length);
+        }
     }
 }
 
diff --git a/deps/icu-small/source/i18n/nfrule.h b/deps/icu-small/source/i18n/nfrule.h
index 2b030390ea7dcb9715c996e8434e8cbc5c455e14..12431c0dba33e8dd52a5560bf2f9b720dc421d2a 100644
--- a/deps/icu-small/source/i18n/nfrule.h
+++ b/deps/icu-small/source/i18n/nfrule.h
@@ -38,7 +38,7 @@ public:
         kNegativeNumberRule = -1,
         kImproperFractionRule = -2,
         kProperFractionRule = -3,
-        kMasterRule = -4,
+        kDefaultRule = -4,
         kInfinityRule = -5,
         kNaNRule = -6,
         kOtherRule = -7
diff --git a/deps/icu-small/source/i18n/nfsubs.cpp b/deps/icu-small/source/i18n/nfsubs.cpp
index 3733f0ca74d3e3929604fc13e7d17ce6824d0e58..e3ea3938835ea384e144e982c79852488bc20b24 100644
--- a/deps/icu-small/source/i18n/nfsubs.cpp
+++ b/deps/icu-small/source/i18n/nfsubs.cpp
@@ -342,7 +342,7 @@ NFSubstitution::makeSubstitution(int32_t pos,
         // IntegralPartSubstitution
         else if (rule->getBaseValue() == NFRule::kImproperFractionRule
             || rule->getBaseValue() == NFRule::kProperFractionRule
-            || rule->getBaseValue() == NFRule::kMasterRule) {
+            || rule->getBaseValue() == NFRule::kDefaultRule) {
             return new IntegralPartSubstitution(pos, ruleSet, description, status);
         }
 
@@ -371,7 +371,7 @@ NFSubstitution::makeSubstitution(int32_t pos,
         // FractionalPartSubstitution
         else if (rule->getBaseValue() == NFRule::kImproperFractionRule
             || rule->getBaseValue() == NFRule::kProperFractionRule
-            || rule->getBaseValue() == NFRule::kMasterRule) {
+            || rule->getBaseValue() == NFRule::kDefaultRule) {
             return new FractionalPartSubstitution(pos, ruleSet, description, status);
         }
 
diff --git a/deps/icu-small/source/i18n/nounit.cpp b/deps/icu-small/source/i18n/nounit.cpp
deleted file mode 100644
index 1d4aa05506e98df1099be28c6d6c19a711ddb57c..0000000000000000000000000000000000000000
--- a/deps/icu-small/source/i18n/nounit.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// © 2017 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-
-#include "unicode/nounit.h"
-#include "uassert.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-U_NAMESPACE_BEGIN
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NoUnit)
-
-NoUnit U_EXPORT2 NoUnit::base() {
-    return NoUnit("");
-}
-
-NoUnit U_EXPORT2 NoUnit::percent() {
-    return NoUnit("percent");
-}
-
-NoUnit U_EXPORT2 NoUnit::permille() {
-    return NoUnit("permille");
-}
-
-NoUnit::NoUnit(const char* subtype) {
-    initNoUnit(subtype);
-}
-
-NoUnit::NoUnit(const NoUnit& other) : MeasureUnit(other) {
-}
-
-NoUnit* NoUnit::clone() const {
-    return new NoUnit(*this);
-}
-
-NoUnit::~NoUnit() {
-}
-
-
-U_NAMESPACE_END
-
-#endif
diff --git a/deps/icu-small/source/i18n/number_asformat.h b/deps/icu-small/source/i18n/number_asformat.h
index 7b0a1dee6f438bfb628609fef19048e09ff777ff..3a2fe3185bee1c8bafe23775e12720ad88457faf 100644
--- a/deps/icu-small/source/i18n/number_asformat.h
+++ b/deps/icu-small/source/i18n/number_asformat.h
@@ -25,7 +25,6 @@ namespace impl {
  * A wrapper around LocalizedNumberFormatter implementing the Format interface, enabling improved
  * compatibility with other APIs.
  *
- * @draft ICU 62
  * @see NumberFormatter
  */
 class U_I18N_API LocalizedNumberFormatterAsFormat : public Format {
diff --git a/deps/icu-small/source/i18n/number_capi.cpp b/deps/icu-small/source/i18n/number_capi.cpp
index d61440d081e9fbbba965ef47830ee71374ff17b4..ef5f0a41ff07a47d56c0bf0732ef2629875f87d3 100644
--- a/deps/icu-small/source/i18n/number_capi.cpp
+++ b/deps/icu-small/source/i18n/number_capi.cpp
@@ -13,6 +13,7 @@
 #include "number_utypes.h"
 #include "numparse_types.h"
 #include "formattedval_impl.h"
+#include "number_decnum.h"
 #include "unicode/numberformatter.h"
 #include "unicode/unumberformatter.h"
 
@@ -196,6 +197,23 @@ unumf_resultGetAllFieldPositions(const UFormattedNumber* uresult, UFieldPosition
     result->fData.getAllFieldPositions(fpih, *ec);
 }
 
+U_CAPI int32_t U_EXPORT2
+unumf_resultToDecimalNumber(
+        const UFormattedNumber* uresult,
+        char* dest,
+        int32_t destCapacity,
+        UErrorCode* ec) {
+    const auto* result = UFormattedNumberApiHelper::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) {
+        return 0;
+    }
+    DecNum decnum;
+    return result->fData.quantity
+        .toDecNum(decnum, *ec)
+        .toCharString(*ec)
+        .extract(dest, destCapacity, *ec);
+}
+
 U_CAPI void U_EXPORT2
 unumf_close(UNumberFormatter* f) {
     UErrorCode localStatus = U_ZERO_ERROR;
diff --git a/deps/icu-small/source/i18n/number_compact.cpp b/deps/icu-small/source/i18n/number_compact.cpp
index e1fef8feb52298a6cd5c27ef8326b7eb8c19f392..8f898e704703a431a0e0ac32c634b2f2a209880b 100644
--- a/deps/icu-small/source/i18n/number_compact.cpp
+++ b/deps/icu-small/source/i18n/number_compact.cpp
@@ -55,7 +55,7 @@ int32_t countZeros(const UChar *patternString, int32_t patternLength) {
 } // namespace
 
 // NOTE: patterns and multipliers both get zero-initialized.
-CompactData::CompactData() : patterns(), multipliers(), largestMagnitude(0), isEmpty(TRUE) {
+CompactData::CompactData() : patterns(), multipliers(), largestMagnitude(0), isEmpty(true) {
 }
 
 void CompactData::populate(const Locale &locale, const char *nsName, CompactStyle compactStyle,
@@ -104,14 +104,30 @@ int32_t CompactData::getMultiplier(int32_t magnitude) const {
     return multipliers[magnitude];
 }
 
-const UChar *CompactData::getPattern(int32_t magnitude, StandardPlural::Form plural) const {
+const UChar *CompactData::getPattern(
+        int32_t magnitude,
+        const PluralRules *rules,
+        const DecimalQuantity &dq) const {
     if (magnitude < 0) {
         return nullptr;
     }
     if (magnitude > largestMagnitude) {
         magnitude = largestMagnitude;
     }
-    const UChar *patternString = patterns[getIndex(magnitude, plural)];
+    const UChar *patternString = nullptr;
+    if (dq.hasIntegerValue()) {
+        int64_t i = dq.toLong(true);
+        if (i == 0) {
+            patternString = patterns[getIndex(magnitude, StandardPlural::Form::EQ_0)];
+        } else if (i == 1) {
+            patternString = patterns[getIndex(magnitude, StandardPlural::Form::EQ_1)];
+        }
+        if (patternString != nullptr) {
+            return patternString;
+        }
+    }
+    StandardPlural::Form plural = utils::getStandardPlural(rules, dq);
+    patternString = patterns[getIndex(magnitude, plural)];
     if (patternString == nullptr && plural != StandardPlural::OTHER) {
         // Fall back to "other" plural variant
         patternString = patterns[getIndex(magnitude, StandardPlural::OTHER)];
@@ -166,7 +182,6 @@ void CompactData::CompactDataSink::put(const char *key, ResourceValue &value, UB
         ResourceTable pluralVariantsTable = value.getTable(status);
         if (U_FAILURE(status)) { return; }
         for (int i4 = 0; pluralVariantsTable.getKeyAndValue(i4, key, value); ++i4) {
-
             // Skip this magnitude/plural if we already have it from a child locale.
             // Note: This also skips USE_FALLBACK entries.
             StandardPlural::Form plural = StandardPlural::fromString(key, status);
@@ -291,8 +306,7 @@ void CompactHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micr
         magnitude -= multiplier;
     }
 
-    StandardPlural::Form plural = utils::getStandardPlural(rules, quantity);
-    const UChar *patternString = data.getPattern(magnitude, plural);
+    const UChar *patternString = data.getPattern(magnitude, rules, quantity);
     if (patternString == nullptr) {
         // Use the default (non-compact) modifier.
         // No need to take any action.
diff --git a/deps/icu-small/source/i18n/number_compact.h b/deps/icu-small/source/i18n/number_compact.h
index 199d39f65911caa8b7b04462f61e8f2cfc993fbe..9802b9fb10ee723e1e085ba7e242f53384fa78e2 100644
--- a/deps/icu-small/source/i18n/number_compact.h
+++ b/deps/icu-small/source/i18n/number_compact.h
@@ -28,7 +28,10 @@ class CompactData : public MultiplierProducer {
 
     int32_t getMultiplier(int32_t magnitude) const U_OVERRIDE;
 
-    const UChar *getPattern(int32_t magnitude, StandardPlural::Form plural) const;
+    const UChar *getPattern(
+        int32_t magnitude,
+        const PluralRules *rules,
+        const DecimalQuantity &dq) const;
 
     void getUniquePatterns(UVector &output, UErrorCode &status) const;
 
diff --git a/deps/icu-small/source/i18n/number_currencysymbols.cpp b/deps/icu-small/source/i18n/number_currencysymbols.cpp
index 4d6fb2cb1d8decc6b856b3b8a890e32302685be9..9208427904cceb6ee7c2f2f6f6f586c82f610efc 100644
--- a/deps/icu-small/source/i18n/number_currencysymbols.cpp
+++ b/deps/icu-small/source/i18n/number_currencysymbols.cpp
@@ -44,6 +44,16 @@ UnicodeString CurrencySymbols::getNarrowCurrencySymbol(UErrorCode& status) const
     return loadSymbol(UCURR_NARROW_SYMBOL_NAME, status);
 }
 
+UnicodeString CurrencySymbols::getFormalCurrencySymbol(UErrorCode& status) const {
+    // Note: currently no override is available for formal currency symbol
+    return loadSymbol(UCURR_FORMAL_SYMBOL_NAME, status);
+}
+
+UnicodeString CurrencySymbols::getVariantCurrencySymbol(UErrorCode& status) const {
+    // Note: currently no override is available for variant currency symbol
+    return loadSymbol(UCURR_VARIANT_SYMBOL_NAME, status);
+}
+
 UnicodeString CurrencySymbols::getCurrencySymbol(UErrorCode& status) const {
     if (!fCurrencySymbol.isBogus()) {
         return fCurrencySymbol;
diff --git a/deps/icu-small/source/i18n/number_currencysymbols.h b/deps/icu-small/source/i18n/number_currencysymbols.h
index 9996bf96ae08a12f1d70edf1388520597ec1a6ea..7e38fdf8287e145910a852f8460dff08fbde4ee3 100644
--- a/deps/icu-small/source/i18n/number_currencysymbols.h
+++ b/deps/icu-small/source/i18n/number_currencysymbols.h
@@ -31,6 +31,10 @@ class U_I18N_API CurrencySymbols : public UMemory {
 
     UnicodeString getNarrowCurrencySymbol(UErrorCode& status) const;
 
+    UnicodeString getFormalCurrencySymbol(UErrorCode& status) const;
+
+    UnicodeString getVariantCurrencySymbol(UErrorCode& status) const;
+
     UnicodeString getCurrencySymbol(UErrorCode& status) const;
 
     UnicodeString getIntlCurrencySymbol(UErrorCode& status) const;
diff --git a/deps/icu-small/source/i18n/number_decimalquantity.cpp b/deps/icu-small/source/i18n/number_decimalquantity.cpp
index 5ce9c27cbf4a761062e12974e0a7223b5539d232..1f020ff87001cd1b6813b14a51cdd8082ed40177 100644
--- a/deps/icu-small/source/i18n/number_decimalquantity.cpp
+++ b/deps/icu-small/source/i18n/number_decimalquantity.cpp
@@ -20,6 +20,7 @@
 #include "charstr.h"
 #include "number_utils.h"
 #include "uassert.h"
+#include "util.h"
 
 using namespace icu;
 using namespace icu::number;
@@ -272,6 +273,9 @@ double DecimalQuantity::getPluralOperand(PluralOperand operand) const {
             return fractionCountWithoutTrailingZeros();
         case PLURAL_OPERAND_E:
             return static_cast<double>(getExponent());
+        case PLURAL_OPERAND_C:
+            // Plural operand `c` is currently an alias for `e`.
+            return static_cast<double>(getExponent());
         default:
             return std::abs(toDouble());
     }
@@ -626,7 +630,7 @@ double DecimalQuantity::toDouble() const {
             &count);
 }
 
-void DecimalQuantity::toDecNum(DecNum& output, UErrorCode& status) const {
+DecNum& DecimalQuantity::toDecNum(DecNum& output, UErrorCode& status) const {
     // Special handling for zero
     if (precision == 0) {
         output.setTo("0", status);
@@ -634,11 +638,15 @@ void DecimalQuantity::toDecNum(DecNum& output, UErrorCode& status) const {
 
     // Use the BCD constructor. We need to do a little bit of work to convert, though.
     // The decNumber constructor expects most-significant first, but we store least-significant first.
-    MaybeStackArray<uint8_t, 20> ubcd(precision);
+    MaybeStackArray<uint8_t, 20> ubcd(precision, status);
+    if (U_FAILURE(status)) {
+        return output;
+    }
     for (int32_t m = 0; m < precision; m++) {
         ubcd[precision - m - 1] = static_cast<uint8_t>(getDigitPos(m));
     }
     output.setTo(ubcd.getAlias(), precision, scale, isNegative(), status);
+    return output;
 }
 
 void DecimalQuantity::truncate() {
@@ -1004,13 +1012,8 @@ void DecimalQuantity::shiftLeft(int32_t numDigits) {
     }
     if (usingBytes) {
         ensureCapacity(precision + numDigits);
-        int i = precision + numDigits - 1;
-        for (; i >= numDigits; i--) {
-            fBCD.bcdBytes.ptr[i] = fBCD.bcdBytes.ptr[i - numDigits];
-        }
-        for (; i >= 0; i--) {
-            fBCD.bcdBytes.ptr[i] = 0;
-        }
+        uprv_memmove(fBCD.bcdBytes.ptr + numDigits, fBCD.bcdBytes.ptr, precision);
+        uprv_memset(fBCD.bcdBytes.ptr, 0, numDigits);
     } else {
         fBCD.bcdLong <<= (numDigits * 4);
     }
@@ -1324,7 +1327,11 @@ bool DecimalQuantity::operator==(const DecimalQuantity& other) const {
 }
 
 UnicodeString DecimalQuantity::toString() const {
-    MaybeStackArray<char, 30> digits(precision + 1);
+    UErrorCode localStatus = U_ZERO_ERROR;
+    MaybeStackArray<char, 30> digits(precision + 1, localStatus);
+    if (U_FAILURE(localStatus)) {
+        return ICU_Utility::makeBogusString();
+    }
     for (int32_t i = 0; i < precision; i++) {
         digits[i] = getDigitPos(precision - i - 1) + '0';
     }
diff --git a/deps/icu-small/source/i18n/number_decimalquantity.h b/deps/icu-small/source/i18n/number_decimalquantity.h
index 53a9eb33b26caf9b77fc80c3dc3d175e04f2f5b4..839424775a0d8deb0df6aaac3b154a37eeb648b2 100644
--- a/deps/icu-small/source/i18n/number_decimalquantity.h
+++ b/deps/icu-small/source/i18n/number_decimalquantity.h
@@ -20,7 +20,7 @@ namespace impl {
 class DecNum;
 
 /**
- * An class for representing a number to be processed by the decimal formatting pipeline. Includes
+ * A class for representing a number to be processed by the decimal formatting pipeline. Includes
  * methods for rounding, plural rules, and decimal digit extraction.
  *
  * <p>By design, this is NOT IMMUTABLE and NOT THREAD SAFE. It is intended to be an intermediate
@@ -209,7 +209,7 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
     double toDouble() const;
 
     /** Computes a DecNum representation of this DecimalQuantity, saving it to the output parameter. */
-    void toDecNum(DecNum& output, UErrorCode& status) const;
+    DecNum& toDecNum(DecNum& output, UErrorCode& status) const;
 
     DecimalQuantity &setToInt(int32_t n);
 
@@ -217,7 +217,13 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
 
     DecimalQuantity &setToDouble(double n);
 
-    /** decNumber is similar to BigDecimal in Java. */
+    /**
+     * Produces a DecimalQuantity that was parsed from a string by the decNumber
+     * C Library.
+     *
+     * decNumber is similar to BigDecimal in Java, and supports parsing strings
+     * such as "123.456621E+40".
+     */
     DecimalQuantity &setToDecNumber(StringPiece n, UErrorCode& status);
 
     /** Internal method if the caller already has a DecNum. */
diff --git a/deps/icu-small/source/i18n/number_decimfmtprops.h b/deps/icu-small/source/i18n/number_decimfmtprops.h
index 1ce84d9dc388d7164f0fc5d8df4f93e6bfb1ef91..0ace241adae8ab75dc58a2506328128a7df599f4 100644
--- a/deps/icu-small/source/i18n/number_decimfmtprops.h
+++ b/deps/icu-small/source/i18n/number_decimfmtprops.h
@@ -38,7 +38,7 @@ namespace impl {
 
 // Exported as U_I18N_API because it is a public member field of exported DecimalFormatProperties
 // Using this wrapper is rather unfortunate, but is needed on Windows platforms in order to allow
-// for DLL-exporting an fully specified template instantiation.
+// for DLL-exporting a fully specified template instantiation.
 class U_I18N_API CurrencyPluralInfoWrapper {
 public:
     LocalPointer<CurrencyPluralInfo> fPtr;
@@ -52,7 +52,8 @@ public:
     }
 
     CurrencyPluralInfoWrapper& operator=(const CurrencyPluralInfoWrapper& other) {
-        if (!other.fPtr.isNull()) {
+        if (this != &other &&  // self-assignment: no-op
+                !other.fPtr.isNull()) {
             fPtr.adoptInstead(new CurrencyPluralInfo(*other.fPtr));
         }
         return *this;
diff --git a/deps/icu-small/source/i18n/number_decnum.h b/deps/icu-small/source/i18n/number_decnum.h
index 0c7399dbddd43b539b0183e0245f5f2953d8d629..3bb8d107807967b52e330a8e66993b47f4a028f5 100644
--- a/deps/icu-small/source/i18n/number_decnum.h
+++ b/deps/icu-small/source/i18n/number_decnum.h
@@ -9,6 +9,7 @@
 
 #include "decNumber.h"
 #include "charstr.h"
+#include "bytesinkutil.h"
 
 U_NAMESPACE_BEGIN
 
@@ -57,6 +58,13 @@ class U_I18N_API DecNum : public UMemory {
 
     void toString(ByteSink& output, UErrorCode& status) const;
 
+    inline CharString toCharString(UErrorCode& status) const {
+      CharString cstr;
+      CharStringByteSink sink(&cstr);
+      toString(sink, status);
+      return cstr;
+    }
+
     inline const decNumber* getRawDecNumber() const {
         return fData.getAlias();
     }
diff --git a/deps/icu-small/source/i18n/number_fluent.cpp b/deps/icu-small/source/i18n/number_fluent.cpp
index 9cdb8b7156e614c0723073107ac132e2247522cf..a79f224829d8053e743c2a4fddca1a444abd8358 100644
--- a/deps/icu-small/source/i18n/number_fluent.cpp
+++ b/deps/icu-small/source/i18n/number_fluent.cpp
@@ -13,6 +13,7 @@
 #include "number_asformat.h"
 #include "number_utils.h"
 #include "number_utypes.h"
+#include "number_mapper.h"
 #include "util.h"
 #include "fphdlimp.h"
 
@@ -273,6 +274,34 @@ Derived NumberFormatterSettings<Derived>::scale(const Scale& scale)&& {
     return move;
 }
 
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::usage(const StringPiece usage) const& {
+    Derived copy(*this);
+    copy.fMacros.usage.set(usage);
+    return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::usage(const StringPiece usage)&& {
+    Derived move(std::move(*this));
+    move.fMacros.usage.set(usage);
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::unitDisplayCase(const StringPiece unitDisplayCase) const& {
+    Derived copy(*this);
+    copy.fMacros.unitDisplayCase.set(unitDisplayCase);
+    return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::unitDisplayCase(const StringPiece unitDisplayCase)&& {
+    Derived move(std::move(*this));
+    move.fMacros.unitDisplayCase.set(unitDisplayCase);
+    return move;
+}
+
 template<typename Derived>
 Derived NumberFormatterSettings<Derived>::padding(const Padder& padder) const& {
     Derived copy(*this);
@@ -400,7 +429,8 @@ LocalizedNumberFormatter::LocalizedNumberFormatter(const LNF& other)
 
 LocalizedNumberFormatter::LocalizedNumberFormatter(const NFS<LNF>& other)
         : NFS<LNF>(other) {
-    // No additional fields to assign (let call count and compiled formatter reset to defaults)
+    UErrorCode localStatus = U_ZERO_ERROR; // Can't bubble up the error
+    lnfCopyHelper(static_cast<const LNF&>(other), localStatus);
 }
 
 LocalizedNumberFormatter::LocalizedNumberFormatter(LocalizedNumberFormatter&& src) U_NOEXCEPT
@@ -408,38 +438,26 @@ LocalizedNumberFormatter::LocalizedNumberFormatter(LocalizedNumberFormatter&& sr
 
 LocalizedNumberFormatter::LocalizedNumberFormatter(NFS<LNF>&& src) U_NOEXCEPT
         : NFS<LNF>(std::move(src)) {
-    // For the move operators, copy over the compiled formatter.
-    // Note: if the formatter is not compiled, call count information is lost.
-    if (static_cast<LNF&&>(src).fCompiled != nullptr) {
-        lnfMoveHelper(static_cast<LNF&&>(src));
-    }
+    lnfMoveHelper(std::move(static_cast<LNF&&>(src)));
 }
 
 LocalizedNumberFormatter& LocalizedNumberFormatter::operator=(const LNF& other) {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     NFS<LNF>::operator=(static_cast<const NFS<LNF>&>(other));
-    // Reset to default values.
-    clear();
+    UErrorCode localStatus = U_ZERO_ERROR; // Can't bubble up the error
+    lnfCopyHelper(other, localStatus);
     return *this;
 }
 
 LocalizedNumberFormatter& LocalizedNumberFormatter::operator=(LNF&& src) U_NOEXCEPT {
     NFS<LNF>::operator=(static_cast<NFS<LNF>&&>(src));
-    // For the move operators, copy over the compiled formatter.
-    // Note: if the formatter is not compiled, call count information is lost.
-    if (static_cast<LNF&&>(src).fCompiled != nullptr) {
-        // Formatter is compiled
-        lnfMoveHelper(static_cast<LNF&&>(src));
-    } else {
-        clear();
-    }
+    lnfMoveHelper(std::move(src));
     return *this;
 }
 
-void LocalizedNumberFormatter::clear() {
-    // Reset to default values.
+void LocalizedNumberFormatter::resetCompiled() {
     auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
     umtx_storeRelease(*callCount, 0);
-    delete fCompiled;
     fCompiled = nullptr;
 }
 
@@ -447,19 +465,56 @@ void LocalizedNumberFormatter::lnfMoveHelper(LNF&& src) {
     // Copy over the compiled formatter and set call count to INT32_MIN as in computeCompiled().
     // Don't copy the call count directly because doing so requires a loadAcquire/storeRelease.
     // The bits themselves appear to be platform-dependent, so copying them might not be safe.
-    auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
-    umtx_storeRelease(*callCount, INT32_MIN);
     delete fCompiled;
-    fCompiled = src.fCompiled;
-    // Reset the source object to leave it in a safe state.
-    auto* srcCallCount = reinterpret_cast<u_atomic_int32_t*>(src.fUnsafeCallCount);
-    umtx_storeRelease(*srcCallCount, 0);
-    src.fCompiled = nullptr;
+    if (src.fCompiled != nullptr) {
+        auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
+        umtx_storeRelease(*callCount, INT32_MIN);
+        fCompiled = src.fCompiled;
+        // Reset the source object to leave it in a safe state.
+        src.resetCompiled();
+    } else {
+        resetCompiled();
+    }
+
+    // Unconditionally move the warehouse
+    delete fWarehouse;
+    fWarehouse = src.fWarehouse;
+    src.fWarehouse = nullptr;
+}
+
+void LocalizedNumberFormatter::lnfCopyHelper(const LNF&, UErrorCode& status) {
+    // When copying, always reset the compiled formatter.
+    delete fCompiled;
+    resetCompiled();
+
+    // If MacroProps has a reference to AffixPatternProvider, we need to copy it.
+    // If MacroProps has a reference to PluralRules, copy that one, too.
+    delete fWarehouse;
+    if (fMacros.affixProvider || fMacros.rules) {
+        LocalPointer<DecimalFormatWarehouse> warehouse(new DecimalFormatWarehouse(), status);
+        if (U_FAILURE(status)) {
+            fWarehouse = nullptr;
+            return;
+        }
+        if (fMacros.affixProvider) {
+            warehouse->affixProvider.setTo(fMacros.affixProvider, status);
+            fMacros.affixProvider = &warehouse->affixProvider.get();
+        }
+        if (fMacros.rules) {
+            warehouse->rules.adoptInsteadAndCheckErrorCode(
+                new PluralRules(*fMacros.rules), status);
+            fMacros.rules = warehouse->rules.getAlias();
+        }
+        fWarehouse = warehouse.orphan();
+    } else {
+        fWarehouse = nullptr;
+    }
 }
 
 
 LocalizedNumberFormatter::~LocalizedNumberFormatter() {
     delete fCompiled;
+    delete fWarehouse;
 }
 
 LocalizedNumberFormatter::LocalizedNumberFormatter(const MacroProps& macros, const Locale& locale) {
@@ -480,123 +535,6 @@ LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale& locale
     return LocalizedNumberFormatter(std::move(fMacros), locale);
 }
 
-SymbolsWrapper::SymbolsWrapper(const SymbolsWrapper& other) {
-    doCopyFrom(other);
-}
-
-SymbolsWrapper::SymbolsWrapper(SymbolsWrapper&& src) U_NOEXCEPT {
-    doMoveFrom(std::move(src));
-}
-
-SymbolsWrapper& SymbolsWrapper::operator=(const SymbolsWrapper& other) {
-    if (this == &other) {
-        return *this;
-    }
-    doCleanup();
-    doCopyFrom(other);
-    return *this;
-}
-
-SymbolsWrapper& SymbolsWrapper::operator=(SymbolsWrapper&& src) U_NOEXCEPT {
-    if (this == &src) {
-        return *this;
-    }
-    doCleanup();
-    doMoveFrom(std::move(src));
-    return *this;
-}
-
-SymbolsWrapper::~SymbolsWrapper() {
-    doCleanup();
-}
-
-void SymbolsWrapper::setTo(const DecimalFormatSymbols& dfs) {
-    doCleanup();
-    fType = SYMPTR_DFS;
-    fPtr.dfs = new DecimalFormatSymbols(dfs);
-}
-
-void SymbolsWrapper::setTo(const NumberingSystem* ns) {
-    doCleanup();
-    fType = SYMPTR_NS;
-    fPtr.ns = ns;
-}
-
-void SymbolsWrapper::doCopyFrom(const SymbolsWrapper& other) {
-    fType = other.fType;
-    switch (fType) {
-        case SYMPTR_NONE:
-            // No action necessary
-            break;
-        case SYMPTR_DFS:
-            // Memory allocation failures are exposed in copyErrorTo()
-            if (other.fPtr.dfs != nullptr) {
-                fPtr.dfs = new DecimalFormatSymbols(*other.fPtr.dfs);
-            } else {
-                fPtr.dfs = nullptr;
-            }
-            break;
-        case SYMPTR_NS:
-            // Memory allocation failures are exposed in copyErrorTo()
-            if (other.fPtr.ns != nullptr) {
-                fPtr.ns = new NumberingSystem(*other.fPtr.ns);
-            } else {
-                fPtr.ns = nullptr;
-            }
-            break;
-    }
-}
-
-void SymbolsWrapper::doMoveFrom(SymbolsWrapper&& src) {
-    fType = src.fType;
-    switch (fType) {
-        case SYMPTR_NONE:
-            // No action necessary
-            break;
-        case SYMPTR_DFS:
-            fPtr.dfs = src.fPtr.dfs;
-            src.fPtr.dfs = nullptr;
-            break;
-        case SYMPTR_NS:
-            fPtr.ns = src.fPtr.ns;
-            src.fPtr.ns = nullptr;
-            break;
-    }
-}
-
-void SymbolsWrapper::doCleanup() {
-    switch (fType) {
-        case SYMPTR_NONE:
-            // No action necessary
-            break;
-        case SYMPTR_DFS:
-            delete fPtr.dfs;
-            break;
-        case SYMPTR_NS:
-            delete fPtr.ns;
-            break;
-    }
-}
-
-bool SymbolsWrapper::isDecimalFormatSymbols() const {
-    return fType == SYMPTR_DFS;
-}
-
-bool SymbolsWrapper::isNumberingSystem() const {
-    return fType == SYMPTR_NS;
-}
-
-const DecimalFormatSymbols* SymbolsWrapper::getDecimalFormatSymbols() const {
-    U_ASSERT(fType == SYMPTR_DFS);
-    return fPtr.dfs;
-}
-
-const NumberingSystem* SymbolsWrapper::getNumberingSystem() const {
-    U_ASSERT(fType == SYMPTR_NS);
-    return fPtr.ns;
-}
-
-
 FormattedNumber LocalizedNumberFormatter::formatInt(int64_t value, UErrorCode& status) const {
     if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
     auto results = new UFormattedNumberData();
@@ -676,9 +614,9 @@ LocalizedNumberFormatter::formatDecimalQuantity(const DecimalQuantity& dq, UErro
 
 void LocalizedNumberFormatter::formatImpl(impl::UFormattedNumberData* results, UErrorCode& status) const {
     if (computeCompiled(status)) {
-        fCompiled->format(results->quantity, results->getStringRef(), status);
+        fCompiled->format(results, status);
     } else {
-        NumberFormatterImpl::formatStatic(fMacros, results->quantity, results->getStringRef(), status);
+        NumberFormatterImpl::formatStatic(fMacros, results, status);
     }
     if (U_FAILURE(status)) {
         return;
diff --git a/deps/icu-small/source/i18n/number_formatimpl.cpp b/deps/icu-small/source/i18n/number_formatimpl.cpp
index 5bba09cfb5293e0caf3696704f56f79e52330799..b2325aa8e591eb276d836af133089a022e7d6ad6 100644
--- a/deps/icu-small/source/i18n/number_formatimpl.cpp
+++ b/deps/icu-small/source/i18n/number_formatimpl.cpp
@@ -25,20 +25,21 @@ using namespace icu::number;
 using namespace icu::number::impl;
 
 
-MicroPropsGenerator::~MicroPropsGenerator() = default;
-
-
 NumberFormatterImpl::NumberFormatterImpl(const MacroProps& macros, UErrorCode& status)
     : NumberFormatterImpl(macros, true, status) {
 }
 
-int32_t NumberFormatterImpl::formatStatic(const MacroProps& macros, DecimalQuantity& inValue,
-                                       FormattedStringBuilder& outString, UErrorCode& status) {
+int32_t NumberFormatterImpl::formatStatic(const MacroProps &macros, UFormattedNumberData *results,
+                                          UErrorCode &status) {
+    DecimalQuantity &inValue = results->quantity;
+    FormattedStringBuilder &outString = results->getStringRef();
     NumberFormatterImpl impl(macros, false, status);
     MicroProps& micros = impl.preProcessUnsafe(inValue, status);
     if (U_FAILURE(status)) { return 0; }
     int32_t length = writeNumber(micros, inValue, outString, 0, status);
     length += writeAffixes(micros, outString, 0, length, status);
+    results->outputUnit = std::move(micros.outputUnit);
+    results->gender = micros.gender;
     return length;
 }
 
@@ -54,13 +55,16 @@ int32_t NumberFormatterImpl::getPrefixSuffixStatic(const MacroProps& macros, Sig
 // The "unsafe" method simply re-uses fMicros, eliminating the extra copy operation.
 // See MicroProps::processQuantity() for details.
 
-int32_t NumberFormatterImpl::format(DecimalQuantity& inValue, FormattedStringBuilder& outString,
-                                UErrorCode& status) const {
+int32_t NumberFormatterImpl::format(UFormattedNumberData *results, UErrorCode &status) const {
+    DecimalQuantity &inValue = results->quantity;
+    FormattedStringBuilder &outString = results->getStringRef();
     MicroProps micros;
     preProcess(inValue, micros, status);
     if (U_FAILURE(status)) { return 0; }
     int32_t length = writeNumber(micros, inValue, outString, 0, status);
     length += writeAffixes(micros, outString, 0, length, status);
+    results->outputUnit = std::move(micros.outputUnit);
+    results->gender = micros.gender;
     return length;
 }
 
@@ -130,12 +134,15 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
 
     // Pre-compute a few values for efficiency.
     bool isCurrency = utils::unitIsCurrency(macros.unit);
-    bool isNoUnit = utils::unitIsNoUnit(macros.unit);
+    bool isBaseUnit = utils::unitIsBaseUnit(macros.unit);
     bool isPercent = utils::unitIsPercent(macros.unit);
     bool isPermille = utils::unitIsPermille(macros.unit);
+    bool isCompactNotation = macros.notation.fType == Notation::NTN_COMPACT;
     bool isAccounting =
-            macros.sign == UNUM_SIGN_ACCOUNTING || macros.sign == UNUM_SIGN_ACCOUNTING_ALWAYS ||
-            macros.sign == UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO;
+            macros.sign == UNUM_SIGN_ACCOUNTING ||
+            macros.sign == UNUM_SIGN_ACCOUNTING_ALWAYS ||
+            macros.sign == UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO ||
+            macros.sign == UNUM_SIGN_ACCOUNTING_NEGATIVE;
     CurrencyUnit currency(u"", status);
     if (isCurrency) {
         currency = CurrencyUnit(macros.unit, status); // Restore CurrencyUnit from MeasureUnit
@@ -144,8 +151,20 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
     if (macros.unitWidth != UNUM_UNIT_WIDTH_COUNT) {
         unitWidth = macros.unitWidth;
     }
-    bool isCldrUnit = !isCurrency && !isNoUnit &&
-        (unitWidth == UNUM_UNIT_WIDTH_FULL_NAME || !(isPercent || isPermille));
+    // Use CLDR unit data for all MeasureUnits (not currency and not
+    // no-unit), except use the dedicated percent pattern for percent and
+    // permille. However, use the CLDR unit data for percent/permille if a
+    // long name was requested OR if compact notation is being used, since
+    // compact notation overrides the middle modifier (micros.modMiddle)
+    // normally used for the percent pattern.
+    bool isCldrUnit = !isCurrency
+        && !isBaseUnit
+        && (unitWidth == UNUM_UNIT_WIDTH_FULL_NAME
+            || !(isPercent || isPermille)
+            || isCompactNotation
+        );
+    bool isMixedUnit = isCldrUnit && (uprv_strcmp(macros.unit.getType(), "") == 0) &&
+                       macros.unit.getComplexity(status) == UMEASURE_UNIT_MIXED;
 
     // Select the numbering system.
     LocalPointer<const NumberingSystem> nsLocal;
@@ -162,6 +181,9 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
     uprv_strncpy(fMicros.nsName, nsName, 8);
     fMicros.nsName[8] = 0; // guarantee NUL-terminated
 
+    // Default gender: none.
+    fMicros.gender = "";
+
     // Resolve the symbols. Do this here because currency may need to customize them.
     if (macros.symbols.isDecimalFormatSymbols()) {
         fMicros.symbols = macros.symbols.getDecimalFormatSymbols();
@@ -222,6 +244,24 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
     /// START POPULATING THE DEFAULT MICROPROPS AND BUILDING THE MICROPROPS GENERATOR ///
     /////////////////////////////////////////////////////////////////////////////////////
 
+    // Unit Preferences and Conversions as our first step
+    if (macros.usage.isSet()) {
+        if (!isCldrUnit) {
+            // We only support "usage" when the input unit is specified, and is
+            // a CLDR Unit.
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+            return nullptr;
+        }
+        auto usagePrefsHandler =
+            new UsagePrefsHandler(macros.locale, macros.unit, macros.usage.fValue, chain, status);
+        fUsagePrefsHandler.adoptInsteadAndCheckErrorCode(usagePrefsHandler, status);
+        chain = fUsagePrefsHandler.getAlias();
+    } else if (isMixedUnit) {
+        auto unitConversionHandler = new UnitConversionHandler(macros.unit, chain, status);
+        fUnitConversionHandler.adoptInsteadAndCheckErrorCode(unitConversionHandler, status);
+        chain = fUnitConversionHandler.getAlias();
+    }
+
     // Multiplier
     if (macros.scale.isValid()) {
         fMicros.helpers.multiplier.setAndChain(macros.scale, chain);
@@ -232,20 +272,18 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
     Precision precision;
     if (!macros.precision.isBogus()) {
         precision = macros.precision;
-    } else if (macros.notation.fType == Notation::NTN_COMPACT) {
+    } else if (isCompactNotation) {
         precision = Precision::integer().withMinDigits(2);
     } else if (isCurrency) {
         precision = Precision::currency(UCURR_USAGE_STANDARD);
+    } else if (macros.usage.isSet()) {
+        // Bogus Precision - it will get set in the UsagePrefsHandler instead
+        precision = Precision();
     } else {
         precision = Precision::maxFraction(6);
     }
     UNumberFormatRoundingMode roundingMode;
-    if (macros.roundingMode != kDefaultMode) {
-        roundingMode = macros.roundingMode;
-    } else {
-        // Temporary until ICU 64
-        roundingMode = precision.fRoundingMode;
-    }
+    roundingMode = macros.roundingMode;
     fMicros.rounder = {precision, roundingMode, currency, status};
     if (U_FAILURE(status)) {
         return nullptr;
@@ -254,7 +292,7 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
     // Grouping strategy
     if (!macros.grouper.isBogus()) {
         fMicros.grouping = macros.grouper;
-    } else if (macros.notation.fType == Notation::NTN_COMPACT) {
+    } else if (isCompactNotation) {
         // Compact notation uses minGrouping by default since ICU 59
         fMicros.grouping = Grouper::forStrategy(UNUM_GROUPING_MIN2);
     } else {
@@ -330,7 +368,8 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
         patternModifier->setSymbols(fMicros.symbols, currency, unitWidth, nullptr, status);
     }
     if (safe) {
-        fImmutablePatternModifier.adoptInstead(patternModifier->createImmutable(status));
+        fImmutablePatternModifier.adoptInsteadAndCheckErrorCode(patternModifier->createImmutable(status),
+                                                                status);
     }
     if (U_FAILURE(status)) {
         return nullptr;
@@ -338,24 +377,52 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
 
     // Outer modifier (CLDR units and currency long names)
     if (isCldrUnit) {
-        fLongNameHandler.adoptInstead(
-                LongNameHandler::forMeasureUnit(
-                        macros.locale,
-                        macros.unit,
-                        macros.perUnit,
-                        unitWidth,
-                        resolvePluralRules(macros.rules, macros.locale, status),
-                        chain,
-                        status));
-        chain = fLongNameHandler.getAlias();
+        const char *unitDisplayCase = "";
+        if (macros.unitDisplayCase.isSet()) {
+            unitDisplayCase = macros.unitDisplayCase.fValue;
+        }
+        if (macros.usage.isSet()) {
+            fLongNameMultiplexer.adoptInsteadAndCheckErrorCode(
+                LongNameMultiplexer::forMeasureUnits(
+                    macros.locale, *fUsagePrefsHandler->getOutputUnits(), unitWidth, unitDisplayCase,
+                    resolvePluralRules(macros.rules, macros.locale, status), chain, status),
+                status);
+            chain = fLongNameMultiplexer.getAlias();
+        } else if (isMixedUnit) {
+            fMixedUnitLongNameHandler.adoptInsteadAndCheckErrorCode(new MixedUnitLongNameHandler(),
+                                                                    status);
+            MixedUnitLongNameHandler::forMeasureUnit(
+                macros.locale, macros.unit, unitWidth, unitDisplayCase,
+                resolvePluralRules(macros.rules, macros.locale, status), chain,
+                fMixedUnitLongNameHandler.getAlias(), status);
+            chain = fMixedUnitLongNameHandler.getAlias();
+        } else {
+            MeasureUnit unit = macros.unit;
+            if (!utils::unitIsBaseUnit(macros.perUnit)) {
+                unit = unit.product(macros.perUnit.reciprocal(status), status);
+                // This isn't strictly necessary, but was what we specced out
+                // when perUnit became a backward-compatibility thing:
+                // unit/perUnit use case is only valid if both units are
+                // built-ins, or the product is a built-in.
+                if (uprv_strcmp(unit.getType(), "") == 0 &&
+                    (uprv_strcmp(macros.unit.getType(), "") == 0 ||
+                     uprv_strcmp(macros.perUnit.getType(), "") == 0)) {
+                    status = U_UNSUPPORTED_ERROR;
+                    return nullptr;
+                }
+            }
+            fLongNameHandler.adoptInsteadAndCheckErrorCode(new LongNameHandler(), status);
+            LongNameHandler::forMeasureUnit(macros.locale, unit, unitWidth, unitDisplayCase,
+                                            resolvePluralRules(macros.rules, macros.locale, status),
+                                            chain, fLongNameHandler.getAlias(), status);
+            chain = fLongNameHandler.getAlias();
+        }
     } else if (isCurrency && unitWidth == UNUM_UNIT_WIDTH_FULL_NAME) {
-        fLongNameHandler.adoptInstead(
-                LongNameHandler::forCurrencyLongNames(
-                        macros.locale,
-                        currency,
-                        resolvePluralRules(macros.rules, macros.locale, status),
-                        chain,
-                        status));
+        fLongNameHandler.adoptInsteadAndCheckErrorCode(
+            LongNameHandler::forCurrencyLongNames(
+                macros.locale, currency, resolvePluralRules(macros.rules, macros.locale, status), chain,
+                status),
+            status);
         chain = fLongNameHandler.getAlias();
     } else {
         // No outer modifier required
@@ -366,7 +433,7 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
     }
 
     // Compact notation
-    if (macros.notation.fType == Notation::NTN_COMPACT) {
+    if (isCompactNotation) {
         CompactType compactType = (isCurrency && unitWidth != UNUM_UNIT_WIDTH_FULL_NAME)
                                   ? CompactType::TYPE_CURRENCY : CompactType::TYPE_DECIMAL;
         auto newCompactHandler = new CompactHandler(
@@ -379,6 +446,9 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
             safe,
             chain,
             status);
+        if (U_FAILURE(status)) {
+            return nullptr;
+        }
         if (newCompactHandler == nullptr) {
             status = U_MEMORY_ALLOCATION_ERROR;
             return nullptr;
@@ -417,6 +487,7 @@ NumberFormatterImpl::resolvePluralRules(const PluralRules* rulesPtr, const Local
 
 int32_t NumberFormatterImpl::writeAffixes(const MicroProps& micros, FormattedStringBuilder& string,
                                           int32_t start, int32_t end, UErrorCode& status) {
+    U_ASSERT(micros.modOuter != nullptr);
     // Always apply the inner modifier (which is "strong").
     int32_t length = micros.modInner->apply(string, start, end, status);
     if (micros.padding.isValid()) {
diff --git a/deps/icu-small/source/i18n/number_formatimpl.h b/deps/icu-small/source/i18n/number_formatimpl.h
index 084bc4a9d0b20932dfb77f036779bc1176435780..5cd549e54a363ffb9a3871aa1cd6694af732794f 100644
--- a/deps/icu-small/source/i18n/number_formatimpl.h
+++ b/deps/icu-small/source/i18n/number_formatimpl.h
@@ -10,11 +10,13 @@
 #include "number_types.h"
 #include "formatted_string_builder.h"
 #include "number_patternstring.h"
+#include "number_usageprefs.h"
 #include "number_utils.h"
 #include "number_patternmodifier.h"
 #include "number_longnames.h"
 #include "number_compact.h"
 #include "number_microprops.h"
+#include "number_utypes.h"
 
 U_NAMESPACE_BEGIN namespace number {
 namespace impl {
@@ -34,9 +36,8 @@ class NumberFormatterImpl : public UMemory {
     /**
      * Builds and evaluates an "unsafe" MicroPropsGenerator, which is cheaper but can be used only once.
      */
-    static int32_t
-    formatStatic(const MacroProps &macros, DecimalQuantity &inValue, FormattedStringBuilder &outString,
-                 UErrorCode &status);
+    static int32_t formatStatic(const MacroProps &macros, UFormattedNumberData *results,
+                                UErrorCode &status);
 
     /**
      * Prints only the prefix and suffix; used for DecimalFormat getters.
@@ -51,7 +52,7 @@ class NumberFormatterImpl : public UMemory {
     /**
      * Evaluates the "safe" MicroPropsGenerator created by "fromMacros".
      */
-    int32_t format(DecimalQuantity& inValue, FormattedStringBuilder& outString, UErrorCode& status) const;
+    int32_t format(UFormattedNumberData *results, UErrorCode &status) const;
 
     /**
      * Like format(), but saves the result into an output MicroProps without additional processing.
@@ -82,7 +83,9 @@ class NumberFormatterImpl : public UMemory {
                                 int32_t end, UErrorCode& status);
 
   private:
-    // Head of the MicroPropsGenerator linked list:
+    // Head of the MicroPropsGenerator linked list. Subclasses' processQuantity
+    // methods process this list in a parent-first order, such that the last
+    // item added, which this points to, typically has its logic executed last.
     const MicroPropsGenerator *fMicroPropsGenerator = nullptr;
 
     // Tail of the list:
@@ -90,13 +93,20 @@ class NumberFormatterImpl : public UMemory {
 
     // Other fields possibly used by the number formatting pipeline:
     // TODO: Convert more of these LocalPointers to value objects to reduce the number of news?
+    LocalPointer<const UsagePrefsHandler> fUsagePrefsHandler;
+    LocalPointer<const UnitConversionHandler> fUnitConversionHandler;
     LocalPointer<const DecimalFormatSymbols> fSymbols;
     LocalPointer<const PluralRules> fRules;
     LocalPointer<const ParsedPatternInfo> fPatternInfo;
     LocalPointer<const ScientificHandler> fScientificHandler;
     LocalPointer<MutablePatternModifier> fPatternModifier;
     LocalPointer<ImmutablePatternModifier> fImmutablePatternModifier;
-    LocalPointer<const LongNameHandler> fLongNameHandler;
+    LocalPointer<LongNameHandler> fLongNameHandler;
+    // TODO: use a common base class that enables fLongNameHandler,
+    // fLongNameMultiplexer, and fMixedUnitLongNameHandler to be merged into one
+    // member?
+    LocalPointer<MixedUnitLongNameHandler> fMixedUnitLongNameHandler;
+    LocalPointer<const LongNameMultiplexer> fLongNameMultiplexer;
     LocalPointer<const CompactHandler> fCompactHandler;
 
     // Value objects possibly used by the number formatting pipeline:
diff --git a/deps/icu-small/source/i18n/number_grouping.cpp b/deps/icu-small/source/i18n/number_grouping.cpp
index 41f727a458f943ea44b5ffa179511557eb3d52dc..6b1642cfd34abdc0a97f162c782f0e9a151b96c9 100644
--- a/deps/icu-small/source/i18n/number_grouping.cpp
+++ b/deps/icu-small/source/i18n/number_grouping.cpp
@@ -64,6 +64,13 @@ Grouper Grouper::forProperties(const DecimalFormatProperties& properties) {
 }
 
 void Grouper::setLocaleData(const impl::ParsedPatternInfo &patternInfo, const Locale& locale) {
+    if (fMinGrouping == -2) {
+        fMinGrouping = getMinGroupingForLocale(locale);
+    } else if (fMinGrouping == -3) {
+        fMinGrouping = static_cast<int16_t>(uprv_max(2, getMinGroupingForLocale(locale)));
+    } else {
+        // leave fMinGrouping alone
+    }
     if (fGrouping1 != -2 && fGrouping2 != -4) {
         return;
     }
@@ -76,13 +83,6 @@ void Grouper::setLocaleData(const impl::ParsedPatternInfo &patternInfo, const Lo
     if (grouping3 == -1) {
         grouping2 = grouping1;
     }
-    if (fMinGrouping == -2) {
-        fMinGrouping = getMinGroupingForLocale(locale);
-    } else if (fMinGrouping == -3) {
-        fMinGrouping = static_cast<int16_t>(uprv_max(2, getMinGroupingForLocale(locale)));
-    } else {
-        // leave fMinGrouping alone
-    }
     fGrouping1 = grouping1;
     fGrouping2 = grouping2;
 }
diff --git a/deps/icu-small/source/i18n/number_integerwidth.cpp b/deps/icu-small/source/i18n/number_integerwidth.cpp
index d62aef444dca96f9ac5b62186948e7a9cf297653..10b853423c847a35700d4c61eb2b4d27abd58a7f 100644
--- a/deps/icu-small/source/i18n/number_integerwidth.cpp
+++ b/deps/icu-small/source/i18n/number_integerwidth.cpp
@@ -40,6 +40,9 @@ IntegerWidth IntegerWidth::truncateAt(int32_t maxInt) {
 }
 
 void IntegerWidth::apply(impl::DecimalQuantity& quantity, UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return;
+    }
     if (fHasError) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
     } else if (fUnion.minMaxInt.fMaxInt == -1) {
diff --git a/deps/icu-small/source/i18n/number_longnames.cpp b/deps/icu-small/source/i18n/number_longnames.cpp
index bb32d0381a507e4aab72841c2df100b96ffcb3dd..fd23a81a8df840a2e4dd269168cb045b770f03e7 100644
--- a/deps/icu-small/source/i18n/number_longnames.cpp
+++ b/deps/icu-small/source/i18n/number_longnames.cpp
@@ -5,11 +5,14 @@
 
 #if !UCONFIG_NO_FORMATTING
 
+#include <cstdlib>
+
 #include "unicode/simpleformatter.h"
 #include "unicode/ures.h"
 #include "ureslocs.h"
 #include "charstr.h"
 #include "uresimp.h"
+#include "measunit_impl.h"
 #include "number_longnames.h"
 #include "number_microprops.h"
 #include <algorithm>
@@ -22,22 +25,100 @@ using namespace icu::number::impl;
 
 namespace {
 
+/**
+ * Display Name (this format has no placeholder).
+ *
+ * Used as an index into the LongNameHandler::simpleFormats array. Units
+ * resources cover the normal set of PluralRules keys, as well as `dnam` and
+ * `per` forms.
+ */
 constexpr int32_t DNAM_INDEX = StandardPlural::Form::COUNT;
+/**
+ * "per" form (e.g. "{0} per day" is day's "per" form).
+ *
+ * Used as an index into the LongNameHandler::simpleFormats array. Units
+ * resources cover the normal set of PluralRules keys, as well as `dnam` and
+ * `per` forms.
+ */
 constexpr int32_t PER_INDEX = StandardPlural::Form::COUNT + 1;
-constexpr int32_t ARRAY_LENGTH = StandardPlural::Form::COUNT + 2;
+/**
+ * Gender of the word, in languages with grammatical gender.
+ */
+constexpr int32_t GENDER_INDEX = StandardPlural::Form::COUNT + 2;
+// Number of keys in the array populated by PluralTableSink.
+constexpr int32_t ARRAY_LENGTH = StandardPlural::Form::COUNT + 3;
+
+// TODO(icu-units#28): load this list from resources, after creating a "&set"
+// function for use in ldml2icu rules.
+const int32_t GENDER_COUNT = 7;
+const char *gGenders[GENDER_COUNT] = {"animate",   "common", "feminine", "inanimate",
+                                      "masculine", "neuter", "personal"};
+
+// Converts a UnicodeString to a const char*, either pointing to a string in
+// gGenders, or pointing to an empty string if an appropriate string was not
+// found.
+const char *getGenderString(UnicodeString uGender, UErrorCode status) {
+    if (uGender.length() == 0) {
+        return "";
+    }
+    CharString gender;
+    gender.appendInvariantChars(uGender, status);
+    if (U_FAILURE(status)) {
+        return "";
+    }
+    int32_t first = 0;
+    int32_t last = GENDER_COUNT;
+    while (first < last) {
+        int32_t mid = (first + last) / 2;
+        int32_t cmp = uprv_strcmp(gender.data(), gGenders[mid]);
+        if (cmp == 0) {
+            return gGenders[mid];
+        } else if (cmp > 0) {
+            first = mid + 1;
+        } else if (cmp < 0) {
+            last = mid;
+        }
+    }
+    // We don't return an error in case our gGenders list is incomplete in
+    // production.
+    //
+    // TODO(icu-units#28): a unit test checking all locales' genders are covered
+    // by gGenders? Else load a complete list of genders found in
+    // grammaticalFeatures in an initOnce.
+    return "";
+}
 
+// Returns the array index that corresponds to the given pluralKeyword.
 static int32_t getIndex(const char* pluralKeyword, UErrorCode& status) {
-    // pluralKeyword can also be "dnam" or "per"
-    if (uprv_strcmp(pluralKeyword, "dnam") == 0) {
-        return DNAM_INDEX;
-    } else if (uprv_strcmp(pluralKeyword, "per") == 0) {
-        return PER_INDEX;
-    } else {
-        StandardPlural::Form plural = StandardPlural::fromString(pluralKeyword, status);
-        return plural;
+    // pluralKeyword can also be "dnam", "per", or "gender"
+    switch (*pluralKeyword) {
+    case 'd':
+        if (uprv_strcmp(pluralKeyword + 1, "nam") == 0) {
+            return DNAM_INDEX;
+        }
+        break;
+    case 'g':
+        if (uprv_strcmp(pluralKeyword + 1, "ender") == 0) {
+            return GENDER_INDEX;
+        }
+        break;
+    case 'p':
+        if (uprv_strcmp(pluralKeyword + 1, "er") == 0) {
+            return PER_INDEX;
+        }
+        break;
+    default:
+        break;
     }
+    StandardPlural::Form plural = StandardPlural::fromString(pluralKeyword, status);
+    return plural;
 }
 
+// Selects a string out of the `strings` array which corresponds to the
+// specified plural form, with fallback to the OTHER form.
+//
+// The `strings` array must have ARRAY_LENGTH items: one corresponding to each
+// of the plural forms, plus a display name ("dnam") and a "per" form.
 static UnicodeString getWithPlural(
         const UnicodeString* strings,
         StandardPlural::Form plural,
@@ -53,13 +134,260 @@ static UnicodeString getWithPlural(
     return result;
 }
 
+enum PlaceholderPosition { PH_EMPTY, PH_NONE, PH_BEGINNING, PH_MIDDLE, PH_END };
+
+/**
+ * Returns three outputs extracted from pattern.
+ *
+ * @param coreUnit is extracted as per Extract(...) in the spec:
+ *   https://unicode.org/reports/tr35/tr35-general.html#compound-units
+ * @param PlaceholderPosition indicates where in the string the placeholder was
+ *   found.
+ * @param joinerChar Iff the placeholder was at the beginning or end, joinerChar
+ *   contains the space character (if any) that separated the placeholder from
+ *   the rest of the pattern. Otherwise, joinerChar is set to NUL. Only one
+ *   space character is considered.
+ */
+void extractCorePattern(const UnicodeString &pattern,
+                        UnicodeString &coreUnit,
+                        PlaceholderPosition &placeholderPosition,
+                        UChar &joinerChar) {
+    joinerChar = 0;
+    int32_t len = pattern.length();
+    if (pattern.startsWith(u"{0}", 3)) {
+        placeholderPosition = PH_BEGINNING;
+        if (u_isJavaSpaceChar(pattern[3])) {
+            joinerChar = pattern[3];
+            coreUnit.setTo(pattern, 4, len - 4);
+        } else {
+            coreUnit.setTo(pattern, 3, len - 3);
+        }
+    } else if (pattern.endsWith(u"{0}", 3)) {
+        placeholderPosition = PH_END;
+        if (u_isJavaSpaceChar(pattern[len - 4])) {
+            coreUnit.setTo(pattern, 0, len - 4);
+            joinerChar = pattern[len - 4];
+        } else {
+            coreUnit.setTo(pattern, 0, len - 3);
+        }
+    } else if (pattern.indexOf(u"{0}", 3, 1, len - 2) == -1) {
+        placeholderPosition = PH_NONE;
+        coreUnit = pattern;
+    } else {
+        placeholderPosition = PH_MIDDLE;
+        coreUnit = pattern;
+    }
+}
 
 //////////////////////////
 /// BEGIN DATA LOADING ///
 //////////////////////////
 
+// Gets the gender of a built-in unit: unit must be a built-in. Returns an empty
+// string both in case of unknown gender and in case of unknown unit.
+UnicodeString
+getGenderForBuiltin(const Locale &locale, const MeasureUnit &builtinUnit, UErrorCode &status) {
+    LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
+    if (U_FAILURE(status)) { return {}; }
+
+    // Map duration-year-person, duration-week-person, etc. to duration-year, duration-week, ...
+    // TODO(ICU-20400): Get duration-*-person data properly with aliases.
+    StringPiece subtypeForResource;
+    int32_t subtypeLen = static_cast<int32_t>(uprv_strlen(builtinUnit.getSubtype()));
+    if (subtypeLen > 7 && uprv_strcmp(builtinUnit.getSubtype() + subtypeLen - 7, "-person") == 0) {
+        subtypeForResource = {builtinUnit.getSubtype(), subtypeLen - 7};
+    } else {
+        subtypeForResource = builtinUnit.getSubtype();
+    }
+
+    CharString key;
+    key.append("units/", status);
+    key.append(builtinUnit.getType(), status);
+    key.append("/", status);
+    key.append(subtypeForResource, status);
+    key.append("/gender", status);
+
+    UErrorCode localStatus = status;
+    int32_t resultLen = 0;
+    const UChar *result =
+        ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &resultLen, &localStatus);
+    if (U_SUCCESS(localStatus)) {
+        status = localStatus;
+        return UnicodeString(true, result, resultLen);
+    } else {
+        // TODO(icu-units#28): "$unitRes/gender" does not exist. Do we want to
+        // check whether the parent "$unitRes" exists? Then we could return
+        // U_MISSING_RESOURCE_ERROR for incorrect usage (e.g. builtinUnit not
+        // being a builtin).
+        return {};
+    }
+}
+
+// Loads data from a resource tree with paths matching
+// $key/$pluralForm/$gender/$case, with lateral inheritance for missing cases
+// and genders.
+//
+// An InflectedPluralSink is configured to load data for a specific gender and
+// case. It loads all plural forms, because selection between plural forms is
+// dependent upon the value being formatted.
+//
+// See data/unit/de.txt and data/unit/fr.txt for examples - take a look at
+// units/compound/power2: German has case, French has differences for gender,
+// but no case.
+//
+// TODO(icu-units#138): Conceptually similar to PluralTableSink, however the
+// tree structures are different. After homogenizing the structures, we may be
+// able to unify the two classes.
+//
+// TODO: Spec violation: expects presence of "count" - does not fallback to an
+// absent "count"! If this fallback were added, getCompoundValue could be
+// superseded?
+class InflectedPluralSink : public ResourceSink {
+  public:
+    // Accepts `char*` rather than StringPiece because
+    // ResourceTable::findValue(...) requires a null-terminated `char*`.
+    //
+    // NOTE: outArray MUST have a length of at least ARRAY_LENGTH. No bounds
+    // checking is performed.
+    explicit InflectedPluralSink(const char *gender, const char *caseVariant, UnicodeString *outArray)
+        : gender(gender), caseVariant(caseVariant), outArray(outArray) {
+        // Initialize the array to bogus strings.
+        for (int32_t i = 0; i < ARRAY_LENGTH; i++) {
+            outArray[i].setToBogus();
+        }
+    }
+
+    // See ResourceSink::put().
+    void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) U_OVERRIDE {
+        ResourceTable pluralsTable = value.getTable(status);
+        if (U_FAILURE(status)) { return; }
+        for (int32_t i = 0; pluralsTable.getKeyAndValue(i, key, value); ++i) {
+            int32_t pluralIndex = getIndex(key, status);
+            if (U_FAILURE(status)) { return; }
+            if (!outArray[pluralIndex].isBogus()) {
+                // We already have a pattern
+                continue;
+            }
+            ResourceTable genderTable = value.getTable(status);
+            ResourceTable caseTable; // This instance has to outlive `value`
+            if (loadForPluralForm(genderTable, caseTable, value, status)) {
+                outArray[pluralIndex] = value.getUnicodeString(status);
+            }
+        }
+    }
+
+  private:
+    // Tries to load data for the configured gender from `genderTable`. Returns
+    // true if found, returning the data in `value`. The returned data will be
+    // for the configured gender if found, falling back to "neuter" and
+    // no-gender if not. The caseTable parameter holds the intermediate
+    // ResourceTable for the sake of lifetime management.
+    bool loadForPluralForm(const ResourceTable &genderTable,
+                           ResourceTable &caseTable,
+                           ResourceValue &value,
+                           UErrorCode &status) {
+        if (uprv_strcmp(gender, "") != 0) {
+            if (loadForGender(genderTable, gender, caseTable, value, status)) {
+                return true;
+            }
+            if (uprv_strcmp(gender, "neuter") != 0 &&
+                loadForGender(genderTable, "neuter", caseTable, value, status)) {
+                return true;
+            }
+        }
+        if (loadForGender(genderTable, "_", caseTable, value, status)) {
+            return true;
+        }
+        return false;
+    }
+
+    // Tries to load data for the given gender from `genderTable`. Returns true
+    // if found, returning the data in `value`. The returned data will be for
+    // the configured case if found, falling back to "nominative" and no-case if
+    // not.
+    bool loadForGender(const ResourceTable &genderTable,
+                       const char *genderVal,
+                       ResourceTable &caseTable,
+                       ResourceValue &value,
+                       UErrorCode &status) {
+        if (!genderTable.findValue(genderVal, value)) {
+            return false;
+        }
+        caseTable = value.getTable(status);
+        if (uprv_strcmp(caseVariant, "") != 0) {
+            if (loadForCase(caseTable, caseVariant, value)) {
+                return true;
+            }
+            if (uprv_strcmp(caseVariant, "nominative") != 0 &&
+                loadForCase(caseTable, "nominative", value)) {
+                return true;
+            }
+        }
+        if (loadForCase(caseTable, "_", value)) {
+            return true;
+        }
+        return false;
+    }
+
+    // Tries to load data for the given case from `caseTable`. Returns true if
+    // found, returning the data in `value`.
+    bool loadForCase(const ResourceTable &caseTable, const char *caseValue, ResourceValue &value) {
+        if (!caseTable.findValue(caseValue, value)) {
+            return false;
+        }
+        return true;
+    }
+
+    const char *gender;
+    const char *caseVariant;
+    UnicodeString *outArray;
+};
+
+// Fetches localised formatting patterns for the given subKey. See documentation
+// for InflectedPluralSink for details.
+//
+// Data is loaded for the appropriate unit width, with missing data filled in
+// from unitsShort.
+void getInflectedMeasureData(StringPiece subKey,
+                             const Locale &locale,
+                             const UNumberUnitWidth &width,
+                             const char *gender,
+                             const char *caseVariant,
+                             UnicodeString *outArray,
+                             UErrorCode &status) {
+    InflectedPluralSink sink(gender, caseVariant, outArray);
+    LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
+    if (U_FAILURE(status)) { return; }
+
+    CharString key;
+    key.append("units", status);
+    if (width == UNUM_UNIT_WIDTH_NARROW) {
+        key.append("Narrow", status);
+    } else if (width == UNUM_UNIT_WIDTH_SHORT) {
+        key.append("Short", status);
+    }
+    key.append("/", status);
+    key.append(subKey, status);
+
+    UErrorCode localStatus = status;
+    ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, localStatus);
+    if (width == UNUM_UNIT_WIDTH_SHORT) {
+        status = localStatus;
+        return;
+    }
+
+    // TODO(ICU-13353): The fallback to short does not work in ICU4C.
+    // Manually fall back to short (this is done automatically in Java).
+    key.clear();
+    key.append("unitsShort/", status);
+    key.append(subKey, status);
+    ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, status);
+}
+
 class PluralTableSink : public ResourceSink {
   public:
+    // NOTE: outArray MUST have a length of at least ARRAY_LENGTH. No bounds
+    // checking is performed.
     explicit PluralTableSink(UnicodeString *outArray) : outArray(outArray) {
         // Initialize the array to bogus strings.
         for (int32_t i = 0; i < ARRAY_LENGTH; i++) {
@@ -71,6 +399,9 @@ class PluralTableSink : public ResourceSink {
         ResourceTable pluralsTable = value.getTable(status);
         if (U_FAILURE(status)) { return; }
         for (int32_t i = 0; pluralsTable.getKeyAndValue(i, key, value); ++i) {
+            if (uprv_strcmp(key, "case") == 0) {
+                continue;
+            }
             int32_t index = getIndex(key, status);
             if (U_FAILURE(status)) { return; }
             if (!outArray[index].isBogus()) {
@@ -85,22 +416,55 @@ class PluralTableSink : public ResourceSink {
     UnicodeString *outArray;
 };
 
-// NOTE: outArray MUST have room for all StandardPlural values.  No bounds checking is performed.
-
-void getMeasureData(const Locale &locale, const MeasureUnit &unit, const UNumberUnitWidth &width,
-                    UnicodeString *outArray, UErrorCode &status) {
+/**
+ * Populates outArray with `locale`-specific values for `unit` through use of
+ * PluralTableSink. Only the set of basic units are supported!
+ *
+ * Reading from resources *unitsNarrow* and *unitsShort* (for width
+ * UNUM_UNIT_WIDTH_NARROW), or just *unitsShort* (for width
+ * UNUM_UNIT_WIDTH_SHORT). For other widths, it reads just "units".
+ *
+ * @param unit must be a built-in unit, i.e. must have a type and subtype,
+ *     listed in gTypes and gSubTypes in measunit.cpp.
+ * @param unitDisplayCase the empty string and "nominative" are treated the
+ *     same. For other cases, strings for the requested case are used if found.
+ *     (For any missing case-specific data, we fall back to nominative.)
+ * @param outArray must be of fixed length ARRAY_LENGTH.
+ */
+void getMeasureData(const Locale &locale,
+                    const MeasureUnit &unit,
+                    const UNumberUnitWidth &width,
+                    const char *unitDisplayCase,
+                    UnicodeString *outArray,
+                    UErrorCode &status) {
     PluralTableSink sink(outArray);
     LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
     if (U_FAILURE(status)) { return; }
 
+    CharString subKey;
+    subKey.append("/", status);
+    subKey.append(unit.getType(), status);
+    subKey.append("/", status);
+
     // Map duration-year-person, duration-week-person, etc. to duration-year, duration-week, ...
     // TODO(ICU-20400): Get duration-*-person data properly with aliases.
-    StringPiece subtypeForResource;
     int32_t subtypeLen = static_cast<int32_t>(uprv_strlen(unit.getSubtype()));
     if (subtypeLen > 7 && uprv_strcmp(unit.getSubtype() + subtypeLen - 7, "-person") == 0) {
-        subtypeForResource = {unit.getSubtype(), subtypeLen - 7};
+        subKey.append({unit.getSubtype(), subtypeLen - 7}, status);
     } else {
-        subtypeForResource = unit.getSubtype();
+        subKey.append({unit.getSubtype(), subtypeLen}, status);
+    }
+
+    if (width != UNUM_UNIT_WIDTH_FULL_NAME) {
+        UErrorCode localStatus = status;
+        CharString genderKey;
+        genderKey.append("units", localStatus);
+        genderKey.append(subKey, localStatus);
+        genderKey.append("/gender", localStatus);
+        StackUResourceBundle fillIn;
+        ures_getByKeyWithFallback(unitsBundle.getAlias(), genderKey.data(), fillIn.getAlias(),
+                                  &localStatus);
+        outArray[GENDER_INDEX] = ures_getUnicodeString(fillIn.getAlias(), &localStatus);
     }
 
     CharString key;
@@ -110,11 +474,30 @@ void getMeasureData(const Locale &locale, const MeasureUnit &unit, const UNumber
     } else if (width == UNUM_UNIT_WIDTH_SHORT) {
         key.append("Short", status);
     }
-    key.append("/", status);
-    key.append(unit.getType(), status);
-    key.append("/", status);
-    key.append(subtypeForResource, status);
+    key.append(subKey, status);
+
+    // Grab desired case first, if available. Then grab no-case data to fill in
+    // the gaps.
+    if (width == UNUM_UNIT_WIDTH_FULL_NAME && unitDisplayCase[0] != 0) {
+        CharString caseKey;
+        caseKey.append(key, status);
+        caseKey.append("/case/", status);
+        caseKey.append(unitDisplayCase, status);
 
+        UErrorCode localStatus = U_ZERO_ERROR;
+        // TODO(icu-units#138): our fallback logic is not spec-compliant:
+        // lateral fallback should happen before locale fallback. Switch to
+        // getInflectedMeasureData after homogenizing data format? Find a unit
+        // test case that demonstrates the incorrect fallback logic (via
+        // regional variant of an inflected language?)
+        ures_getAllItemsWithFallback(unitsBundle.getAlias(), caseKey.data(), sink, localStatus);
+    }
+
+    // TODO(icu-units#138): our fallback logic is not spec-compliant: we
+    // check the given case, then go straight to the no-case data. The spec
+    // states we should first look for case="nominative". As part of #138,
+    // either get the spec changed, or add unit tests that warn us if
+    // case="nominative" data differs from no-case data?
     UErrorCode localStatus = U_ZERO_ERROR;
     ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, localStatus);
     if (width == UNUM_UNIT_WIDTH_SHORT) {
@@ -127,13 +510,12 @@ void getMeasureData(const Locale &locale, const MeasureUnit &unit, const UNumber
     // TODO(ICU-13353): The fallback to short does not work in ICU4C.
     // Manually fall back to short (this is done automatically in Java).
     key.clear();
-    key.append("unitsShort/", status);
-    key.append(unit.getType(), status);
-    key.append("/", status);
-    key.append(subtypeForResource, status);
+    key.append("unitsShort", status);
+    key.append(subKey, status);
     ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, status);
 }
 
+// NOTE: outArray MUST have a length of at least ARRAY_LENGTH.
 void getCurrencyLongNameData(const Locale &locale, const CurrencyUnit &currency, UnicodeString *outArray,
                              UErrorCode &status) {
     // In ICU4J, this method gets a CurrencyData from CurrencyData.provider.
@@ -162,7 +544,10 @@ void getCurrencyLongNameData(const Locale &locale, const CurrencyUnit &currency,
     }
 }
 
-UnicodeString getPerUnitFormat(const Locale& locale, const UNumberUnitWidth &width, UErrorCode& status) {
+UnicodeString getCompoundValue(StringPiece compoundKey,
+                               const Locale &locale,
+                               const UNumberUnitWidth &width,
+                               UErrorCode &status) {
     LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
     if (U_FAILURE(status)) { return {}; }
     CharString key;
@@ -172,90 +557,893 @@ UnicodeString getPerUnitFormat(const Locale& locale, const UNumberUnitWidth &wid
     } else if (width == UNUM_UNIT_WIDTH_SHORT) {
         key.append("Short", status);
     }
-    key.append("/compound/per", status);
+    key.append("/compound/", status);
+    key.append(compoundKey, status);
+
+    UErrorCode localStatus = status;
     int32_t len = 0;
-    const UChar* ptr = ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &len, &status);
+    const UChar *ptr =
+        ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &len, &localStatus);
+    if (U_FAILURE(localStatus) && width != UNUM_UNIT_WIDTH_SHORT) {
+        // Fall back to short, which contains more compound data
+        key.clear();
+        key.append("unitsShort/compound/", status);
+        key.append(compoundKey, status);
+        ptr = ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &len, &status);
+    } else {
+        status = localStatus;
+    }
+    if (U_FAILURE(status)) {
+        return {};
+    }
     return UnicodeString(ptr, len);
 }
 
+/**
+ * Loads and applies deriveComponent rules from CLDR's grammaticalFeatures.xml.
+ *
+ * Consider a deriveComponent rule that looks like this:
+ *
+ *     <deriveComponent feature="case" structure="per" value0="compound" value1="nominative"/>
+ *
+ * Instantiating an instance as follows:
+ *
+ *     DerivedComponents d(loc, "case", "per");
+ *
+ * Applying the rule in the XML element above, `d.value0("foo")` will be "foo",
+ * and `d.value1("foo")` will be "nominative".
+ *
+ * The values returned by value0(...) and value1(...) are valid only while the
+ * instance exists. In case of any kind of failure, value0(...) and value1(...)
+ * will return "".
+ */
+class DerivedComponents {
+  public:
+    /**
+     * Constructor.
+     *
+     * The feature and structure parameters must be null-terminated. The string
+     * referenced by compoundValue must exist for longer than the
+     * DerivedComponents instance.
+     */
+    DerivedComponents(const Locale &locale, const char *feature, const char *structure) {
+        StackUResourceBundle derivationsBundle, stackBundle;
+        ures_openDirectFillIn(derivationsBundle.getAlias(), NULL, "grammaticalFeatures", &status);
+        ures_getByKey(derivationsBundle.getAlias(), "grammaticalData", derivationsBundle.getAlias(),
+                      &status);
+        ures_getByKey(derivationsBundle.getAlias(), "derivations", derivationsBundle.getAlias(),
+                      &status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        UErrorCode localStatus = U_ZERO_ERROR;
+        // TODO(icu-units#28): use standard normal locale resolution algorithms
+        // rather than just grabbing language:
+        ures_getByKey(derivationsBundle.getAlias(), locale.getLanguage(), stackBundle.getAlias(),
+                      &localStatus);
+        // TODO(icu-units#28):
+        // - code currently assumes if the locale exists, the rules are there -
+        //   instead of falling back to root when the requested rule is missing.
+        // - investigate ures.h functions, see if one that uses res_findResource()
+        //   might be better (or use res_findResource directly), or maybe help
+        //   improve ures documentation to guide function selection?
+        if (localStatus == U_MISSING_RESOURCE_ERROR) {
+            ures_getByKey(derivationsBundle.getAlias(), "root", stackBundle.getAlias(), &status);
+        } else {
+            status = localStatus;
+        }
+        ures_getByKey(stackBundle.getAlias(), "component", stackBundle.getAlias(), &status);
+        ures_getByKey(stackBundle.getAlias(), feature, stackBundle.getAlias(), &status);
+        ures_getByKey(stackBundle.getAlias(), structure, stackBundle.getAlias(), &status);
+        UnicodeString val0 = ures_getUnicodeStringByIndex(stackBundle.getAlias(), 0, &status);
+        UnicodeString val1 = ures_getUnicodeStringByIndex(stackBundle.getAlias(), 1, &status);
+        if (U_SUCCESS(status)) {
+            if (val0.compare(UnicodeString(u"compound")) == 0) {
+                compound0_ = true;
+            } else {
+                compound0_ = false;
+                value0_.appendInvariantChars(val0, status);
+            }
+            if (val1.compare(UnicodeString(u"compound")) == 0) {
+                compound1_ = true;
+            } else {
+                compound1_ = false;
+                value1_.appendInvariantChars(val1, status);
+            }
+        }
+    }
+
+    // Returns a StringPiece that is only valid as long as the instance exists.
+    StringPiece value0(const StringPiece compoundValue) const {
+        return compound0_ ? compoundValue : value0_.toStringPiece();
+    }
+
+    // Returns a StringPiece that is only valid as long as the instance exists.
+    StringPiece value1(const StringPiece compoundValue) const {
+        return compound1_ ? compoundValue : value1_.toStringPiece();
+    }
+
+    // Returns a char* that is only valid as long as the instance exists.
+    const char *value0(const char *compoundValue) const {
+        return compound0_ ? compoundValue : value0_.data();
+    }
+
+    // Returns a char* that is only valid as long as the instance exists.
+    const char *value1(const char *compoundValue) const {
+        return compound1_ ? compoundValue : value1_.data();
+    }
+
+  private:
+    UErrorCode status = U_ZERO_ERROR;
+
+    // Holds strings referred to by value0 and value1;
+    bool compound0_ = false, compound1_ = false;
+    CharString value0_, value1_;
+};
+
+// TODO(icu-units#28): test somehow? Associate with an ICU ticket for adding
+// testsuite support for testing with synthetic data?
+/**
+ * Loads and returns the value in rules that look like these:
+ *
+ * <deriveCompound feature="gender" structure="per" value="0"/>
+ * <deriveCompound feature="gender" structure="times" value="1"/>
+ *
+ * Currently a fake example, but spec compliant:
+ * <deriveCompound feature="gender" structure="power" value="feminine"/>
+ *
+ * NOTE: If U_FAILURE(status), returns an empty string.
+ */
+UnicodeString
+getDeriveCompoundRule(Locale locale, const char *feature, const char *structure, UErrorCode &status) {
+    StackUResourceBundle derivationsBundle, stackBundle;
+    ures_openDirectFillIn(derivationsBundle.getAlias(), NULL, "grammaticalFeatures", &status);
+    ures_getByKey(derivationsBundle.getAlias(), "grammaticalData", derivationsBundle.getAlias(),
+                  &status);
+    ures_getByKey(derivationsBundle.getAlias(), "derivations", derivationsBundle.getAlias(), &status);
+    // TODO: use standard normal locale resolution algorithms rather than just grabbing language:
+    ures_getByKey(derivationsBundle.getAlias(), locale.getLanguage(), stackBundle.getAlias(), &status);
+    // TODO:
+    // - code currently assumes if the locale exists, the rules are there -
+    //   instead of falling back to root when the requested rule is missing.
+    // - investigate ures.h functions, see if one that uses res_findResource()
+    //   might be better (or use res_findResource directly), or maybe help
+    //   improve ures documentation to guide function selection?
+    if (status == U_MISSING_RESOURCE_ERROR) {
+        status = U_ZERO_ERROR;
+        ures_getByKey(derivationsBundle.getAlias(), "root", stackBundle.getAlias(), &status);
+    }
+    ures_getByKey(stackBundle.getAlias(), "compound", stackBundle.getAlias(), &status);
+    ures_getByKey(stackBundle.getAlias(), feature, stackBundle.getAlias(), &status);
+    UnicodeString uVal = ures_getUnicodeStringByKey(stackBundle.getAlias(), structure, &status);
+    if (U_FAILURE(status)) {
+        return {};
+    }
+    U_ASSERT(!uVal.isBogus());
+    return uVal;
+}
+
+// Returns the gender string for structures following these rules:
+//
+// <deriveCompound feature="gender" structure="per" value="0"/>
+// <deriveCompound feature="gender" structure="times" value="1"/>
+//
+// Fake example:
+// <deriveCompound feature="gender" structure="power" value="feminine"/>
+//
+// data0 and data1 should be pattern arrays (UnicodeString[ARRAY_SIZE]) that
+// correspond to value="0" and value="1".
+//
+// Pass a nullptr to data1 if the structure has no concept of value="1" (e.g.
+// "prefix" doesn't).
+UnicodeString getDerivedGender(Locale locale,
+                               const char *structure,
+                               UnicodeString *data0,
+                               UnicodeString *data1,
+                               UErrorCode &status) {
+    UnicodeString val = getDeriveCompoundRule(locale, "gender", structure, status);
+    if (val.length() == 1) {
+        switch (val[0]) {
+        case u'0':
+            return data0[GENDER_INDEX];
+        case u'1':
+            if (data1 == nullptr) {
+                return {};
+            }
+            return data1[GENDER_INDEX];
+        }
+    }
+    return val;
+}
+
 ////////////////////////
 /// END DATA LOADING ///
 ////////////////////////
 
-} // namespace
+// TODO: promote this somewhere? It's based on patternprops.cpp' trimWhitespace
+const UChar *trimSpaceChars(const UChar *s, int32_t &length) {
+    if (length <= 0 || (!u_isJavaSpaceChar(s[0]) && !u_isJavaSpaceChar(s[length - 1]))) {
+        return s;
+    }
+    int32_t start = 0;
+    int32_t limit = length;
+    while (start < limit && u_isJavaSpaceChar(s[start])) {
+        ++start;
+    }
+    if (start < limit) {
+        // There is non-white space at start; we will not move limit below that,
+        // so we need not test start<limit in the loop.
+        while (u_isJavaSpaceChar(s[limit - 1])) {
+            --limit;
+        }
+    }
+    length = limit - start;
+    return s + start;
+}
 
-LongNameHandler*
-LongNameHandler::forMeasureUnit(const Locale &loc, const MeasureUnit &unitRef, const MeasureUnit &perUnit,
-                                const UNumberUnitWidth &width, const PluralRules *rules,
-                                const MicroPropsGenerator *parent, UErrorCode &status) {
-    if (uprv_strlen(unitRef.getType()) == 0 || uprv_strlen(perUnit.getType()) == 0) {
-        // TODO(ICU-20941): Unsanctioned unit. Not yet fully supported. Set an error code.
-        status = U_UNSUPPORTED_ERROR;
-        return nullptr;
+/**
+ * Calculates the gender of an arbitrary unit: this is the *second*
+ * implementation of an algorithm to do this:
+ *
+ * Gender is also calculated in "processPatternTimes": that code path is "bottom
+ * up", loading the gender for every component of a compound unit (at the same
+ * time as loading the Long Names formatting patterns), even if the gender is
+ * unneeded, then combining the single units' genders into the compound unit's
+ * gender, according to the rules. This algorithm does a lazier "top-down"
+ * evaluation, starting with the compound unit, calculating which single unit's
+ * gender is needed by breaking it down according to the rules, and then loading
+ * only the gender of the one single unit who's gender is needed.
+ *
+ * For future refactorings:
+ * 1. we could drop processPatternTimes' gender calculation and just call this
+ *    function: for UNUM_UNIT_WIDTH_FULL_NAME, the unit gender is in the very
+ *    same table as the formatting patterns, so loading it then may be
+ *    efficient. For other unit widths however, it needs to be explicitly looked
+ *    up anyway.
+ * 2. alternatively, if CLDR is providing all the genders we need such that we
+ *    don't need to calculate them in ICU anymore, we could drop this function
+ *    and keep only processPatternTimes' calculation. (And optimise it a bit?)
+ *
+ * @param locale The desired locale.
+ * @param unit The measure unit to calculate the gender for.
+ * @return The gender string for the unit, or an empty string if unknown or
+ *     ungendered.
+ */
+UnicodeString calculateGenderForUnit(const Locale &locale, const MeasureUnit &unit, UErrorCode &status) {
+    MeasureUnitImpl impl;
+    const MeasureUnitImpl& mui = MeasureUnitImpl::forMeasureUnit(unit, impl, status);
+    int32_t singleUnitIndex = 0;
+    if (mui.complexity == UMEASURE_UNIT_COMPOUND) {
+        int32_t startSlice = 0;
+        // inclusive
+        int32_t endSlice = mui.singleUnits.length()-1;
+        U_ASSERT(endSlice > 0); // Else it would not be COMPOUND
+        if (mui.singleUnits[endSlice]->dimensionality < 0) {
+            // We have a -per- construct
+            UnicodeString perRule = getDeriveCompoundRule(locale, "gender", "per", status);
+            if (perRule.length() != 1) {
+                // Fixed gender for -per- units
+                return perRule;
+            }
+            if (perRule[0] == u'1') {
+                // Find the start of the denominator. We already know there is one.
+                while (mui.singleUnits[startSlice]->dimensionality >= 0) {
+                    startSlice++;
+                }
+            } else {
+                // Find the end of the numerator
+                while (endSlice >= 0 && mui.singleUnits[endSlice]->dimensionality < 0) {
+                    endSlice--;
+                }
+                if (endSlice < 0) {
+                    // We have only a denominator, e.g. "per-second".
+                    // TODO(icu-units#28): find out what gender to use in the
+                    // absence of a first value - mentioned in CLDR-14253.
+                    return {};
+                }
+            }
+        }
+        if (endSlice > startSlice) {
+            // We have a -times- construct
+            UnicodeString timesRule = getDeriveCompoundRule(locale, "gender", "times", status);
+            if (timesRule.length() != 1) {
+                // Fixed gender for -times- units
+                return timesRule;
+            }
+            if (timesRule[0] == u'0') {
+                endSlice = startSlice;
+            } else {
+                // We assume timesRule[0] == u'1'
+                startSlice = endSlice;
+            }
+        }
+        U_ASSERT(startSlice == endSlice);
+        singleUnitIndex = startSlice;
+    } else if (mui.complexity == UMEASURE_UNIT_MIXED) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return {};
+    } else {
+        U_ASSERT(mui.complexity == UMEASURE_UNIT_SINGLE);
+        U_ASSERT(mui.singleUnits.length() == 1);
     }
 
-    MeasureUnit unit = unitRef;
-    if (uprv_strcmp(perUnit.getType(), "none") != 0) {
-        // Compound unit: first try to simplify (e.g., meters per second is its own unit).
-        bool isResolved = false;
-        MeasureUnit resolved = MeasureUnit::resolveUnitPerUnit(unit, perUnit, &isResolved);
-        if (isResolved) {
-            unit = resolved;
-        } else {
-            // No simplified form is available.
-            return forCompoundUnit(loc, unit, perUnit, width, rules, parent, status);
+    // Now we know which singleUnit's gender we want
+    const SingleUnitImpl *singleUnit = mui.singleUnits[singleUnitIndex];
+    // Check for any power-prefix gender override:
+    if (std::abs(singleUnit->dimensionality) != 1) {
+        UnicodeString powerRule = getDeriveCompoundRule(locale, "gender", "power", status);
+        if (powerRule.length() != 1) {
+            // Fixed gender for -powN- units
+            return powerRule;
+        }
+        // powerRule[0] == u'0'; u'1' not currently in spec.
+    }
+    // Check for any SI and binary prefix gender override:
+    if (std::abs(singleUnit->dimensionality) != 1) {
+        UnicodeString prefixRule = getDeriveCompoundRule(locale, "gender", "prefix", status);
+        if (prefixRule.length() != 1) {
+            // Fixed gender for -powN- units
+            return prefixRule;
         }
+        // prefixRule[0] == u'0'; u'1' not currently in spec.
     }
+    // Now we've boiled it down to the gender of one simple unit identifier:
+    return getGenderForBuiltin(locale, MeasureUnit::forIdentifier(singleUnit->getSimpleUnitID(), status),
+                               status);
+}
 
-    auto* result = new LongNameHandler(rules, parent);
-    if (result == nullptr) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return nullptr;
+void maybeCalculateGender(const Locale &locale,
+                          const MeasureUnit &unitRef,
+                          UnicodeString *outArray,
+                          UErrorCode &status) {
+    if (outArray[GENDER_INDEX].isBogus()) {
+        UnicodeString meterGender = getGenderForBuiltin(locale, MeasureUnit::getMeter(), status);
+        if (meterGender.isEmpty()) {
+            // No gender for meter: assume ungendered language
+            return;
+        }
+        // We have a gendered language, but are lacking gender for unitRef.
+        outArray[GENDER_INDEX] = calculateGenderForUnit(locale, unitRef, status);
     }
-    UnicodeString simpleFormats[ARRAY_LENGTH];
-    getMeasureData(loc, unit, width, simpleFormats, status);
-    if (U_FAILURE(status)) { return result; }
-    result->simpleFormatsToModifiers(simpleFormats, {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
-    return result;
 }
 
-LongNameHandler*
-LongNameHandler::forCompoundUnit(const Locale &loc, const MeasureUnit &unit, const MeasureUnit &perUnit,
-                                 const UNumberUnitWidth &width, const PluralRules *rules,
-                                 const MicroPropsGenerator *parent, UErrorCode &status) {
-    auto* result = new LongNameHandler(rules, parent);
-    if (result == nullptr) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return nullptr;
+} // namespace
+
+void LongNameHandler::forMeasureUnit(const Locale &loc,
+                                     const MeasureUnit &unitRef,
+                                     const UNumberUnitWidth &width,
+                                     const char *unitDisplayCase,
+                                     const PluralRules *rules,
+                                     const MicroPropsGenerator *parent,
+                                     LongNameHandler *fillIn,
+                                     UErrorCode &status) {
+    // From https://unicode.org/reports/tr35/tr35-general.html#compound-units -
+    // Points 1 and 2 are mostly handled by MeasureUnit:
+    //
+    // 1. If the unitId is empty or invalid, fail
+    // 2. Put the unitId into normalized order
+    U_ASSERT(fillIn != nullptr);
+
+    if (uprv_strcmp(unitRef.getType(), "") != 0) {
+        // Handling built-in units:
+        //
+        // 3. Set result to be getValue(unitId with length, pluralCategory, caseVariant)
+        //    - If result is not empty, return it
+        UnicodeString simpleFormats[ARRAY_LENGTH];
+        getMeasureData(loc, unitRef, width, unitDisplayCase, simpleFormats, status);
+        maybeCalculateGender(loc, unitRef, simpleFormats, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        fillIn->rules = rules;
+        fillIn->parent = parent;
+        fillIn->simpleFormatsToModifiers(simpleFormats,
+                                         {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
+        if (!simpleFormats[GENDER_INDEX].isBogus()) {
+            fillIn->gender = getGenderString(simpleFormats[GENDER_INDEX], status);
+        }
+        return;
+
+        // TODO(icu-units#145): figure out why this causes a failure in
+        // format/MeasureFormatTest/TestIndividualPluralFallback and other
+        // tests, when it should have been an alternative for the lines above:
+
+        // forArbitraryUnit(loc, unitRef, width, unitDisplayCase, fillIn, status);
+        // fillIn->rules = rules;
+        // fillIn->parent = parent;
+        // return;
+    } else {
+        // Check if it is a MeasureUnit this constructor handles: this
+        // constructor does not handle mixed units
+        U_ASSERT(unitRef.getComplexity(status) != UMEASURE_UNIT_MIXED);
+        forArbitraryUnit(loc, unitRef, width, unitDisplayCase, fillIn, status);
+        fillIn->rules = rules;
+        fillIn->parent = parent;
+        return;
+    }
+}
+
+void LongNameHandler::forArbitraryUnit(const Locale &loc,
+                                       const MeasureUnit &unitRef,
+                                       const UNumberUnitWidth &width,
+                                       const char *unitDisplayCase,
+                                       LongNameHandler *fillIn,
+                                       UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    if (fillIn == nullptr) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return;
+    }
+
+    // Numbered list items are from the algorithms at
+    // https://unicode.org/reports/tr35/tr35-general.html#compound-units:
+    //
+    // 4. Divide the unitId into numerator (the part before the "-per-") and
+    //    denominator (the part after the "-per-). If both are empty, fail
+    MeasureUnitImpl unit;
+    MeasureUnitImpl perUnit;
+    {
+        MeasureUnitImpl fullUnit = MeasureUnitImpl::forMeasureUnitMaybeCopy(unitRef, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        for (int32_t i = 0; i < fullUnit.singleUnits.length(); i++) {
+            SingleUnitImpl *subUnit = fullUnit.singleUnits[i];
+            if (subUnit->dimensionality > 0) {
+                unit.appendSingleUnit(*subUnit, status);
+            } else {
+                subUnit->dimensionality *= -1;
+                perUnit.appendSingleUnit(*subUnit, status);
+            }
+        }
     }
-    UnicodeString primaryData[ARRAY_LENGTH];
-    getMeasureData(loc, unit, width, primaryData, status);
-    if (U_FAILURE(status)) { return result; }
-    UnicodeString secondaryData[ARRAY_LENGTH];
-    getMeasureData(loc, perUnit, width, secondaryData, status);
-    if (U_FAILURE(status)) { return result; }
 
-    UnicodeString perUnitFormat;
-    if (!secondaryData[PER_INDEX].isBogus()) {
-        perUnitFormat = secondaryData[PER_INDEX];
+    // TODO(icu-units#28): check placeholder logic, see if it needs to be
+    // present here instead of only in processPatternTimes:
+    //
+    // 5. Set both globalPlaceholder and globalPlaceholderPosition to be empty
+
+    DerivedComponents derivedPerCases(loc, "case", "per");
+
+    // 6. numeratorUnitString
+    UnicodeString numeratorUnitData[ARRAY_LENGTH];
+    processPatternTimes(std::move(unit), loc, width, derivedPerCases.value0(unitDisplayCase),
+                        numeratorUnitData, status);
+
+    // 7. denominatorUnitString
+    UnicodeString denominatorUnitData[ARRAY_LENGTH];
+    processPatternTimes(std::move(perUnit), loc, width, derivedPerCases.value1(unitDisplayCase),
+                        denominatorUnitData, status);
+
+    // TODO(icu-units#139):
+    // - implement DerivedComponents for "plural/times" and "plural/power":
+    //   French has different rules, we'll be producing the wrong results
+    //   currently. (Prove via tests!)
+    // - implement DerivedComponents for "plural/per", "plural/prefix",
+    //   "case/times", "case/power", and "case/prefix" - although they're
+    //   currently hardcoded. Languages with different rules are surely on the
+    //   way.
+    //
+    // Currently we only use "case/per", "plural/times", "case/times", and
+    // "case/power".
+    //
+    // This may have impact on multiSimpleFormatsToModifiers(...) below too?
+    // These rules are currently (ICU 69) all the same and hard-coded below.
+    UnicodeString perUnitPattern;
+    if (!denominatorUnitData[PER_INDEX].isBogus()) {
+        // If we have no denominator, we obtain the empty string:
+        perUnitPattern = denominatorUnitData[PER_INDEX];
     } else {
-        UnicodeString rawPerUnitFormat = getPerUnitFormat(loc, width, status);
-        if (U_FAILURE(status)) { return result; }
-        // rawPerUnitFormat is something like "{0}/{1}"; we need to substitute in the secondary unit.
-        SimpleFormatter compiled(rawPerUnitFormat, 2, 2, status);
-        if (U_FAILURE(status)) { return result; }
-        UnicodeString secondaryFormat = getWithPlural(secondaryData, StandardPlural::Form::ONE, status);
-        if (U_FAILURE(status)) { return result; }
+        // 8. Set perPattern to be getValue([per], locale, length)
+        UnicodeString rawPerUnitFormat = getCompoundValue("per", loc, width, status);
+        // rawPerUnitFormat is something like "{0} per {1}"; we need to substitute in the secondary unit.
+        SimpleFormatter perPatternFormatter(rawPerUnitFormat, 2, 2, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        // Plural and placeholder handling for 7. denominatorUnitString:
+        // TODO(icu-units#139): hardcoded:
+        // <deriveComponent feature="plural" structure="per" value0="compound" value1="one"/>
+        UnicodeString denominatorFormat =
+            getWithPlural(denominatorUnitData, StandardPlural::Form::ONE, status);
         // Some "one" pattern may not contain "{0}". For example in "ar" or "ne" locale.
-        SimpleFormatter secondaryCompiled(secondaryFormat, 0, 1, status);
-        if (U_FAILURE(status)) { return result; }
-        UnicodeString secondaryString = secondaryCompiled.getTextWithNoArguments().trim();
-        // TODO: Why does UnicodeString need to be explicit in the following line?
-        compiled.format(UnicodeString(u"{0}"), secondaryString, perUnitFormat, status);
-        if (U_FAILURE(status)) { return result; }
-    }
-    result->multiSimpleFormatsToModifiers(primaryData, perUnitFormat, {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
-    return result;
+        SimpleFormatter denominatorFormatter(denominatorFormat, 0, 1, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        UnicodeString denominatorPattern = denominatorFormatter.getTextWithNoArguments();
+        int32_t trimmedLen = denominatorPattern.length();
+        const UChar *trimmed = trimSpaceChars(denominatorPattern.getBuffer(), trimmedLen);
+        UnicodeString denominatorString(false, trimmed, trimmedLen);
+        // 9. If the denominatorString is empty, set result to
+        //    [numeratorString], otherwise set result to format(perPattern,
+        //    numeratorString, denominatorString)
+        //
+        // TODO(icu-units#28): Why does UnicodeString need to be explicit in the
+        // following line?
+        perPatternFormatter.format(UnicodeString(u"{0}"), denominatorString, perUnitPattern, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+    }
+    if (perUnitPattern.length() == 0) {
+        fillIn->simpleFormatsToModifiers(numeratorUnitData,
+                                         {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
+    } else {
+        fillIn->multiSimpleFormatsToModifiers(numeratorUnitData, perUnitPattern,
+                                              {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
+    }
+
+    // Gender
+    //
+    // TODO(icu-units#28): find out what gender to use in the absence of a first
+    // value - e.g. what's the gender of "per-second"? Mentioned in CLDR-14253.
+    //
+    // gender/per deriveCompound rules don't say:
+    // <deriveCompound feature="gender" structure="per" value="0"/> <!-- gender(gram-per-meter) ←  gender(gram) -->
+    fillIn->gender = getGenderString(
+        getDerivedGender(loc, "per", numeratorUnitData, denominatorUnitData, status), status);
+}
+
+void LongNameHandler::processPatternTimes(MeasureUnitImpl &&productUnit,
+                                          Locale loc,
+                                          const UNumberUnitWidth &width,
+                                          const char *caseVariant,
+                                          UnicodeString *outArray,
+                                          UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    if (productUnit.complexity == UMEASURE_UNIT_MIXED) {
+        // These are handled by MixedUnitLongNameHandler
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+
+#if U_DEBUG
+    for (int32_t pluralIndex = 0; pluralIndex < ARRAY_LENGTH; pluralIndex++) {
+        U_ASSERT(outArray[pluralIndex].length() == 0);
+        U_ASSERT(!outArray[pluralIndex].isBogus());
+    }
+#endif
+
+    if (productUnit.identifier.isEmpty()) {
+        // TODO(icu-units#28): consider when serialize should be called.
+        // identifier might also be empty for MeasureUnit().
+        productUnit.serialize(status);
+    }
+    if (U_FAILURE(status)) {
+        return;
+    }
+    if (productUnit.identifier.length() == 0) {
+        // MeasureUnit(): no units: return empty strings.
+        return;
+    }
+
+    MeasureUnit builtinUnit;
+    if (MeasureUnit::findBySubType(productUnit.identifier.toStringPiece(), &builtinUnit)) {
+        // TODO(icu-units#145): spec doesn't cover builtin-per-builtin, it
+        // breaks them all down. Do we want to drop this?
+        // - findBySubType isn't super efficient, if we skip it and go to basic
+        //   singles, we don't have to construct MeasureUnit's anymore.
+        // - Check all the existing unit tests that fail without this: is it due
+        //   to incorrect fallback via getMeasureData?
+        // - Do those unit tests cover this code path representatively?
+        if (builtinUnit != MeasureUnit()) {
+            getMeasureData(loc, builtinUnit, width, caseVariant, outArray, status);
+            maybeCalculateGender(loc, builtinUnit, outArray, status);
+        }
+        return;
+    }
+
+    // 2. Set timesPattern to be getValue(times, locale, length)
+    UnicodeString timesPattern = getCompoundValue("times", loc, width, status);
+    SimpleFormatter timesPatternFormatter(timesPattern, 2, 2, status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    PlaceholderPosition globalPlaceholder[ARRAY_LENGTH];
+    UChar globalJoinerChar = 0;
+    // Numbered list items are from the algorithms at
+    // https://unicode.org/reports/tr35/tr35-general.html#compound-units:
+    //
+    // pattern(...) point 5:
+    // - Set both globalPlaceholder and globalPlaceholderPosition to be empty
+    //
+    // 3. Set result to be empty
+    for (int32_t pluralIndex = 0; pluralIndex < ARRAY_LENGTH; pluralIndex++) {
+        // Initial state: empty string pattern, via all falling back to OTHER:
+        if (pluralIndex == StandardPlural::Form::OTHER) {
+            outArray[pluralIndex].remove();
+        } else {
+            outArray[pluralIndex].setToBogus();
+        }
+        globalPlaceholder[pluralIndex] = PH_EMPTY;
+    }
+
+    // Empty string represents "compound" (propagate the plural form).
+    const char *pluralCategory = "";
+    DerivedComponents derivedTimesPlurals(loc, "plural", "times");
+    DerivedComponents derivedTimesCases(loc, "case", "times");
+    DerivedComponents derivedPowerCases(loc, "case", "power");
+
+    // 4. For each single_unit in product_unit
+    for (int32_t singleUnitIndex = 0; singleUnitIndex < productUnit.singleUnits.length();
+         singleUnitIndex++) {
+        SingleUnitImpl *singleUnit = productUnit.singleUnits[singleUnitIndex];
+        const char *singlePluralCategory;
+        const char *singleCaseVariant;
+        // TODO(icu-units#28): ensure we have unit tests that change/fail if we
+        // assign incorrect case variants here:
+        if (singleUnitIndex < productUnit.singleUnits.length() - 1) {
+            // 4.1. If hasMultiple
+            singlePluralCategory = derivedTimesPlurals.value0(pluralCategory);
+            singleCaseVariant = derivedTimesCases.value0(caseVariant);
+            pluralCategory = derivedTimesPlurals.value1(pluralCategory);
+            caseVariant = derivedTimesCases.value1(caseVariant);
+        } else {
+            singlePluralCategory = derivedTimesPlurals.value1(pluralCategory);
+            singleCaseVariant = derivedTimesCases.value1(caseVariant);
+        }
+
+        // 4.2. Get the gender of that single_unit
+        MeasureUnit simpleUnit;
+        if (!MeasureUnit::findBySubType(singleUnit->getSimpleUnitID(), &simpleUnit)) {
+            // Ideally all simple units should be known, but they're not:
+            // 100-kilometer is internally treated as a simple unit, but it is
+            // not a built-in unit and does not have formatting data in CLDR 39.
+            //
+            // TODO(icu-units#28): test (desirable) invariants in unit tests.
+            status = U_UNSUPPORTED_ERROR;
+            return;
+        }
+        const char *gender = getGenderString(getGenderForBuiltin(loc, simpleUnit, status), status);
+
+        // 4.3. If singleUnit starts with a dimensionality_prefix, such as 'square-'
+        U_ASSERT(singleUnit->dimensionality > 0);
+        int32_t dimensionality = singleUnit->dimensionality;
+        UnicodeString dimensionalityPrefixPatterns[ARRAY_LENGTH];
+        if (dimensionality != 1) {
+            // 4.3.1. set dimensionalityPrefixPattern to be
+            //   getValue(that dimensionality_prefix, locale, length, singlePluralCategory, singleCaseVariant, gender),
+            //   such as "{0} kwadratowym"
+            CharString dimensionalityKey("compound/power", status);
+            dimensionalityKey.appendNumber(dimensionality, status);
+            getInflectedMeasureData(dimensionalityKey.toStringPiece(), loc, width, gender,
+                                    singleCaseVariant, dimensionalityPrefixPatterns, status);
+            if (U_FAILURE(status)) {
+                // At the time of writing, only pow2 and pow3 are supported.
+                // Attempting to format other powers results in a
+                // U_RESOURCE_TYPE_MISMATCH. We convert the error if we
+                // understand it:
+                if (status == U_RESOURCE_TYPE_MISMATCH && dimensionality > 3) {
+                    status = U_UNSUPPORTED_ERROR;
+                }
+                return;
+            }
+
+            // TODO(icu-units#139):
+            // 4.3.2. set singlePluralCategory to be power0(singlePluralCategory)
+
+            // 4.3.3. set singleCaseVariant to be power0(singleCaseVariant)
+            singleCaseVariant = derivedPowerCases.value0(singleCaseVariant);
+            // 4.3.4. remove the dimensionality_prefix from singleUnit
+            singleUnit->dimensionality = 1;
+        }
+
+        // 4.4. if singleUnit starts with an si_prefix, such as 'centi'
+        UMeasurePrefix prefix = singleUnit->unitPrefix;
+        UnicodeString prefixPattern;
+        if (prefix != UMEASURE_PREFIX_ONE) {
+            // 4.4.1. set siPrefixPattern to be getValue(that si_prefix, locale,
+            //        length), such as "centy{0}"
+            CharString prefixKey;
+            // prefixKey looks like "1024p3" or "10p-2":
+            prefixKey.appendNumber(umeas_getPrefixBase(prefix), status);
+            prefixKey.append('p', status);
+            prefixKey.appendNumber(umeas_getPrefixPower(prefix), status);
+            // Contains a pattern like "centy{0}".
+            prefixPattern = getCompoundValue(prefixKey.toStringPiece(), loc, width, status);
+
+            // 4.4.2. set singlePluralCategory to be prefix0(singlePluralCategory)
+            //
+            // TODO(icu-units#139): that refers to these rules:
+            // <deriveComponent feature="plural" structure="prefix" value0="one" value1="compound"/>
+            // though I'm not sure what other value they might end up having.
+            //
+            // 4.4.3. set singleCaseVariant to be prefix0(singleCaseVariant)
+            //
+            // TODO(icu-units#139): that refers to:
+            // <deriveComponent feature="case" structure="prefix" value0="nominative"
+            // value1="compound"/> but the prefix (value0) doesn't have case, the rest simply
+            // propagates.
+
+            // 4.4.4. remove the si_prefix from singleUnit
+            singleUnit->unitPrefix = UMEASURE_PREFIX_ONE;
+        }
+
+        // 4.5. Set corePattern to be the getValue(singleUnit, locale, length,
+        //      singlePluralCategory, singleCaseVariant), such as "{0} metrem"
+        UnicodeString singleUnitArray[ARRAY_LENGTH];
+        // At this point we are left with a Simple Unit:
+        U_ASSERT(uprv_strcmp(singleUnit->build(status).getIdentifier(), singleUnit->getSimpleUnitID()) ==
+                 0);
+        getMeasureData(loc, singleUnit->build(status), width, singleCaseVariant, singleUnitArray,
+                       status);
+        if (U_FAILURE(status)) {
+            // Shouldn't happen if we have data for all single units
+            return;
+        }
+
+        // Calculate output gender
+        if (!singleUnitArray[GENDER_INDEX].isBogus()) {
+            U_ASSERT(!singleUnitArray[GENDER_INDEX].isEmpty());
+            UnicodeString uVal;
+
+            if (prefix != UMEASURE_PREFIX_ONE) {
+                singleUnitArray[GENDER_INDEX] =
+                    getDerivedGender(loc, "prefix", singleUnitArray, nullptr, status);
+            }
+
+            if (dimensionality != 1) {
+                singleUnitArray[GENDER_INDEX] =
+                    getDerivedGender(loc, "power", singleUnitArray, nullptr, status);
+            }
+
+            UnicodeString timesGenderRule = getDeriveCompoundRule(loc, "gender", "times", status);
+            if (timesGenderRule.length() == 1) {
+                switch (timesGenderRule[0]) {
+                case u'0':
+                    if (singleUnitIndex == 0) {
+                        U_ASSERT(outArray[GENDER_INDEX].isBogus());
+                        outArray[GENDER_INDEX] = singleUnitArray[GENDER_INDEX];
+                    }
+                    break;
+                case u'1':
+                    if (singleUnitIndex == productUnit.singleUnits.length() - 1) {
+                        U_ASSERT(outArray[GENDER_INDEX].isBogus());
+                        outArray[GENDER_INDEX] = singleUnitArray[GENDER_INDEX];
+                    }
+                }
+            } else {
+                if (outArray[GENDER_INDEX].isBogus()) {
+                    outArray[GENDER_INDEX] = timesGenderRule;
+                }
+            }
+        }
+
+        // Calculate resulting patterns for each plural form
+        for (int32_t pluralIndex = 0; pluralIndex < StandardPlural::Form::COUNT; pluralIndex++) {
+            StandardPlural::Form plural = static_cast<StandardPlural::Form>(pluralIndex);
+
+            // singleUnitArray[pluralIndex] looks something like "{0} Meter"
+            if (outArray[pluralIndex].isBogus()) {
+                if (singleUnitArray[pluralIndex].isBogus()) {
+                    // Let the usual plural fallback mechanism take care of this
+                    // plural form
+                    continue;
+                } else {
+                    // Since our singleUnit can have a plural form that outArray
+                    // doesn't yet have (relying on fallback to OTHER), we start
+                    // by grabbing it with the normal plural fallback mechanism
+                    outArray[pluralIndex] = getWithPlural(outArray, plural, status);
+                    if (U_FAILURE(status)) {
+                        return;
+                    }
+                }
+            }
+
+            if (uprv_strcmp(singlePluralCategory, "") != 0) {
+                plural = static_cast<StandardPlural::Form>(getIndex(singlePluralCategory, status));
+            }
+
+            // 4.6. Extract(corePattern, coreUnit, placeholder, placeholderPosition) from that pattern.
+            UnicodeString coreUnit;
+            PlaceholderPosition placeholderPosition;
+            UChar joinerChar;
+            extractCorePattern(getWithPlural(singleUnitArray, plural, status), coreUnit,
+                               placeholderPosition, joinerChar);
+
+            // 4.7 If the position is middle, then fail
+            if (placeholderPosition == PH_MIDDLE) {
+                status = U_UNSUPPORTED_ERROR;
+                return;
+            }
+
+            // 4.8. If globalPlaceholder is empty
+            if (globalPlaceholder[pluralIndex] == PH_EMPTY) {
+                globalPlaceholder[pluralIndex] = placeholderPosition;
+                globalJoinerChar = joinerChar;
+            } else {
+                // Expect all units involved to have the same placeholder position
+                U_ASSERT(globalPlaceholder[pluralIndex] == placeholderPosition);
+                // TODO(icu-units#28): Do we want to add a unit test that checks
+                // for consistent joiner chars? Probably not, given how
+                // inconsistent they are. File a CLDR ticket with examples?
+            }
+            // Now coreUnit would be just "Meter"
+
+            // 4.9. If siPrefixPattern is not empty
+            if (prefix != UMEASURE_PREFIX_ONE) {
+                SimpleFormatter prefixCompiled(prefixPattern, 1, 1, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+
+                // 4.9.1. Set coreUnit to be the combineLowercasing(locale, length, siPrefixPattern,
+                //        coreUnit)
+                UnicodeString tmp;
+                // combineLowercasing(locale, length, prefixPattern, coreUnit)
+                //
+                // TODO(icu-units#28): run this only if prefixPattern does not
+                // contain space characters - do languages "as", "bn", "hi",
+                // "kk", etc have concepts of upper and lower case?:
+                if (width == UNUM_UNIT_WIDTH_FULL_NAME) {
+                    coreUnit.toLower(loc);
+                }
+                prefixCompiled.format(coreUnit, tmp, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+                coreUnit = tmp;
+            }
+
+            // 4.10. If dimensionalityPrefixPattern is not empty
+            if (dimensionality != 1) {
+                SimpleFormatter dimensionalityCompiled(
+                    getWithPlural(dimensionalityPrefixPatterns, plural, status), 1, 1, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+
+                // 4.10.1. Set coreUnit to be the combineLowercasing(locale, length,
+                //         dimensionalityPrefixPattern, coreUnit)
+                UnicodeString tmp;
+                // combineLowercasing(locale, length, prefixPattern, coreUnit)
+                //
+                // TODO(icu-units#28): run this only if prefixPattern does not
+                // contain space characters - do languages "as", "bn", "hi",
+                // "kk", etc have concepts of upper and lower case?:
+                if (width == UNUM_UNIT_WIDTH_FULL_NAME) {
+                    coreUnit.toLower(loc);
+                }
+                dimensionalityCompiled.format(coreUnit, tmp, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+                coreUnit = tmp;
+            }
+
+            if (outArray[pluralIndex].length() == 0) {
+                // 4.11. If the result is empty, set result to be coreUnit
+                outArray[pluralIndex] = coreUnit;
+            } else {
+                // 4.12. Otherwise set result to be format(timesPattern, result, coreUnit)
+                UnicodeString tmp;
+                timesPatternFormatter.format(outArray[pluralIndex], coreUnit, tmp, status);
+                outArray[pluralIndex] = tmp;
+            }
+        }
+    }
+    for (int32_t pluralIndex = 0; pluralIndex < StandardPlural::Form::COUNT; pluralIndex++) {
+        if (globalPlaceholder[pluralIndex] == PH_BEGINNING) {
+            UnicodeString tmp;
+            tmp.append(u"{0}", 3);
+            if (globalJoinerChar != 0) {
+                tmp.append(globalJoinerChar);
+            }
+            tmp.append(outArray[pluralIndex]);
+            outArray[pluralIndex] = tmp;
+        } else if (globalPlaceholder[pluralIndex] == PH_END) {
+            if (globalJoinerChar != 0) {
+                outArray[pluralIndex].append(globalJoinerChar);
+            }
+            outArray[pluralIndex].append(u"{0}", 3);
+        }
+    }
 }
 
 UnicodeString LongNameHandler::getUnitDisplayName(
@@ -267,7 +1455,7 @@ UnicodeString LongNameHandler::getUnitDisplayName(
         return ICU_Utility::makeBogusString();
     }
     UnicodeString simpleFormats[ARRAY_LENGTH];
-    getMeasureData(loc, unit, width, simpleFormats, status);
+    getMeasureData(loc, unit, width, "", simpleFormats, status);
     return simpleFormats[DNAM_INDEX];
 }
 
@@ -281,7 +1469,7 @@ UnicodeString LongNameHandler::getUnitPattern(
         return ICU_Utility::makeBogusString();
     }
     UnicodeString simpleFormats[ARRAY_LENGTH];
-    getMeasureData(loc, unit, width, simpleFormats, status);
+    getMeasureData(loc, unit, width, "", simpleFormats, status);
     // The above already handles fallback from other widths to short
     if (U_FAILURE(status)) {
         return ICU_Utility::makeBogusString();
@@ -304,6 +1492,7 @@ LongNameHandler* LongNameHandler::forCurrencyLongNames(const Locale &loc, const
     getCurrencyLongNameData(loc, currency, simpleFormats, status);
     if (U_FAILURE(status)) { return nullptr; }
     result->simpleFormatsToModifiers(simpleFormats, {UFIELD_CATEGORY_NUMBER, UNUM_CURRENCY_FIELD}, status);
+    // TODO(icu-units#28): currency gender?
     return result;
 }
 
@@ -328,8 +1517,12 @@ void LongNameHandler::multiSimpleFormatsToModifiers(const UnicodeString *leadFor
         UnicodeString leadFormat = getWithPlural(leadFormats, plural, status);
         if (U_FAILURE(status)) { return; }
         UnicodeString compoundFormat;
-        trailCompiled.format(leadFormat, compoundFormat, status);
-        if (U_FAILURE(status)) { return; }
+        if (leadFormat.length() == 0) {
+            compoundFormat = trailFormat;
+        } else {
+            trailCompiled.format(leadFormat, compoundFormat, status);
+            if (U_FAILURE(status)) { return; }
+        }
         SimpleFormatter compoundCompiled(compoundFormat, 0, 1, status);
         if (U_FAILURE(status)) { return; }
         fModifiers[i] = SimpleModifier(compoundCompiled, field, false, {this, SIGNUM_POS_ZERO, plural});
@@ -338,13 +1531,238 @@ void LongNameHandler::multiSimpleFormatsToModifiers(const UnicodeString *leadFor
 
 void LongNameHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
                                       UErrorCode &status) const {
-    parent->processQuantity(quantity, micros, status);
+    if (parent != NULL) {
+        parent->processQuantity(quantity, micros, status);
+    }
     StandardPlural::Form pluralForm = utils::getPluralSafe(micros.rounder, rules, quantity, status);
     micros.modOuter = &fModifiers[pluralForm];
+    micros.gender = gender;
 }
 
 const Modifier* LongNameHandler::getModifier(Signum /*signum*/, StandardPlural::Form plural) const {
     return &fModifiers[plural];
 }
 
+void MixedUnitLongNameHandler::forMeasureUnit(const Locale &loc,
+                                              const MeasureUnit &mixedUnit,
+                                              const UNumberUnitWidth &width,
+                                              const char *unitDisplayCase,
+                                              const PluralRules *rules,
+                                              const MicroPropsGenerator *parent,
+                                              MixedUnitLongNameHandler *fillIn,
+                                              UErrorCode &status) {
+    U_ASSERT(mixedUnit.getComplexity(status) == UMEASURE_UNIT_MIXED);
+    U_ASSERT(fillIn != nullptr);
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    MeasureUnitImpl temp;
+    const MeasureUnitImpl &impl = MeasureUnitImpl::forMeasureUnit(mixedUnit, temp, status);
+    // Defensive, for production code:
+    if (impl.complexity != UMEASURE_UNIT_MIXED) {
+        // Should be using the normal LongNameHandler
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+
+    fillIn->fMixedUnitCount = impl.singleUnits.length();
+    fillIn->fMixedUnitData.adoptInstead(new UnicodeString[fillIn->fMixedUnitCount * ARRAY_LENGTH]);
+    for (int32_t i = 0; i < fillIn->fMixedUnitCount; i++) {
+        // Grab data for each of the components.
+        UnicodeString *unitData = &fillIn->fMixedUnitData[i * ARRAY_LENGTH];
+        // TODO(CLDR-14502): check from the CLDR-14502 ticket whether this
+        // propagation of unitDisplayCase is correct:
+        getMeasureData(loc, impl.singleUnits[i]->build(status), width, unitDisplayCase, unitData,
+                       status);
+        // TODO(ICU-21494): if we add support for gender for mixed units, we may
+        // need maybeCalculateGender() here.
+    }
+
+    // TODO(icu-units#120): Make sure ICU doesn't output zero-valued
+    // high-magnitude fields
+    // * for mixed units count N, produce N listFormatters, one for each subset
+    //   that might be formatted.
+    UListFormatterWidth listWidth = ULISTFMT_WIDTH_SHORT;
+    if (width == UNUM_UNIT_WIDTH_NARROW) {
+        listWidth = ULISTFMT_WIDTH_NARROW;
+    } else if (width == UNUM_UNIT_WIDTH_FULL_NAME) {
+        // This might be the same as SHORT in most languages:
+        listWidth = ULISTFMT_WIDTH_WIDE;
+    }
+    fillIn->fListFormatter.adoptInsteadAndCheckErrorCode(
+        ListFormatter::createInstance(loc, ULISTFMT_TYPE_UNITS, listWidth, status), status);
+    // TODO(ICU-21494): grab gender of each unit, calculate the gender
+    // associated with this list formatter, save it for later.
+    fillIn->rules = rules;
+    fillIn->parent = parent;
+
+    // We need a localised NumberFormatter for the numbers of the bigger units
+    // (providing Arabic numerals, for example).
+    fillIn->fNumberFormatter = NumberFormatter::withLocale(loc);
+}
+
+void MixedUnitLongNameHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                                               UErrorCode &status) const {
+    U_ASSERT(fMixedUnitCount > 1);
+    if (parent != nullptr) {
+        parent->processQuantity(quantity, micros, status);
+    }
+    micros.modOuter = getMixedUnitModifier(quantity, micros, status);
+}
+
+const Modifier *MixedUnitLongNameHandler::getMixedUnitModifier(DecimalQuantity &quantity,
+                                                               MicroProps &micros,
+                                                               UErrorCode &status) const {
+    if (micros.mixedMeasuresCount == 0) {
+        U_ASSERT(micros.mixedMeasuresCount > 0); // Mixed unit: we must have more than one unit value
+        status = U_UNSUPPORTED_ERROR;
+        return &micros.helpers.emptyWeakModifier;
+    }
+
+    // Algorithm:
+    //
+    // For the mixed-units measurement of: "3 yard, 1 foot, 2.6 inch", we should
+    // find "3 yard" and "1 foot" in micros.mixedMeasures.
+    //
+    // Obtain long-names with plural forms corresponding to measure values:
+    //   * {0} yards, {0} foot, {0} inches
+    //
+    // Format the integer values appropriately and modify with the format
+    // strings:
+    //   - 3 yards, 1 foot
+    //
+    // Use ListFormatter to combine, with one placeholder:
+    //   - 3 yards, 1 foot and {0} inches
+    //
+    // Return a SimpleModifier for this pattern, letting the rest of the
+    // pipeline take care of the remaining inches.
+
+    LocalArray<UnicodeString> outputMeasuresList(new UnicodeString[fMixedUnitCount], status);
+    if (U_FAILURE(status)) {
+        return &micros.helpers.emptyWeakModifier;
+    }
+
+    StandardPlural::Form quantityPlural = StandardPlural::Form::OTHER;
+    for (int32_t i = 0; i < micros.mixedMeasuresCount; i++) {
+        DecimalQuantity fdec;
+
+        // If numbers are negative, only the first number needs to have its
+        // negative sign formatted.
+        int64_t number = i > 0 ? std::abs(micros.mixedMeasures[i]) : micros.mixedMeasures[i];
+
+        if (micros.indexOfQuantity == i) { // Insert placeholder for `quantity`
+            // If quantity is not the first value and quantity is negative
+            if (micros.indexOfQuantity > 0 && quantity.isNegative()) {
+                quantity.negate();
+            }
+
+            StandardPlural::Form quantityPlural =
+                utils::getPluralSafe(micros.rounder, rules, quantity, status);
+            UnicodeString quantityFormatWithPlural =
+                getWithPlural(&fMixedUnitData[i * ARRAY_LENGTH], quantityPlural, status);
+            SimpleFormatter quantityFormatter(quantityFormatWithPlural, 0, 1, status);
+            quantityFormatter.format(UnicodeString(u"{0}"), outputMeasuresList[i], status);
+        } else {
+            fdec.setToLong(number);
+            StandardPlural::Form pluralForm = utils::getStandardPlural(rules, fdec);
+            UnicodeString simpleFormat =
+                getWithPlural(&fMixedUnitData[i * ARRAY_LENGTH], pluralForm, status);
+            SimpleFormatter compiledFormatter(simpleFormat, 0, 1, status);
+            UnicodeString num;
+            auto appendable = UnicodeStringAppendable(num);
+
+            fNumberFormatter.formatDecimalQuantity(fdec, status).appendTo(appendable, status);
+            compiledFormatter.format(num, outputMeasuresList[i], status);
+        }
+    }
+
+    // TODO(ICU-21494): implement gender for lists of mixed units. Presumably we
+    // can set micros.gender to the gender associated with the list formatter in
+    // use below (once we have correct support for that). And then document this
+    // appropriately? "getMixedUnitModifier" doesn't sound like it would do
+    // something like this.
+
+    // Combine list into a "premixed" pattern
+    UnicodeString premixedFormatPattern;
+    fListFormatter->format(outputMeasuresList.getAlias(), fMixedUnitCount, premixedFormatPattern,
+                           status);
+    SimpleFormatter premixedCompiled(premixedFormatPattern, 0, 1, status);
+    if (U_FAILURE(status)) {
+        return &micros.helpers.emptyWeakModifier;
+    }
+
+    micros.helpers.mixedUnitModifier =
+        SimpleModifier(premixedCompiled, kUndefinedField, false, {this, SIGNUM_POS_ZERO, quantityPlural});
+    return &micros.helpers.mixedUnitModifier;
+}
+
+const Modifier *MixedUnitLongNameHandler::getModifier(Signum /*signum*/,
+                                                      StandardPlural::Form /*plural*/) const {
+    // TODO(icu-units#28): investigate this method when investigating where
+    // ModifierStore::getModifier() gets used. To be sure it remains
+    // unreachable:
+    UPRV_UNREACHABLE;
+    return nullptr;
+}
+
+LongNameMultiplexer *LongNameMultiplexer::forMeasureUnits(const Locale &loc,
+                                                          const MaybeStackVector<MeasureUnit> &units,
+                                                          const UNumberUnitWidth &width,
+                                                          const char *unitDisplayCase,
+                                                          const PluralRules *rules,
+                                                          const MicroPropsGenerator *parent,
+                                                          UErrorCode &status) {
+    LocalPointer<LongNameMultiplexer> result(new LongNameMultiplexer(parent), status);
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+    U_ASSERT(units.length() > 0);
+    if (result->fHandlers.resize(units.length()) == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return nullptr;
+    }
+    result->fMeasureUnits.adoptInstead(new MeasureUnit[units.length()]);
+    for (int32_t i = 0, length = units.length(); i < length; i++) {
+        const MeasureUnit &unit = *units[i];
+        result->fMeasureUnits[i] = unit;
+        if (unit.getComplexity(status) == UMEASURE_UNIT_MIXED) {
+            MixedUnitLongNameHandler *mlnh = result->fMixedUnitHandlers.createAndCheckErrorCode(status);
+            MixedUnitLongNameHandler::forMeasureUnit(loc, unit, width, unitDisplayCase, rules, NULL,
+                                                     mlnh, status);
+            result->fHandlers[i] = mlnh;
+        } else {
+            LongNameHandler *lnh = result->fLongNameHandlers.createAndCheckErrorCode(status);
+            LongNameHandler::forMeasureUnit(loc, unit, width, unitDisplayCase, rules, NULL, lnh, status);
+            result->fHandlers[i] = lnh;
+        }
+        if (U_FAILURE(status)) {
+            return nullptr;
+        }
+    }
+    return result.orphan();
+}
+
+void LongNameMultiplexer::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                                          UErrorCode &status) const {
+    // We call parent->processQuantity() from the Multiplexer, instead of
+    // letting LongNameHandler handle it: we don't know which LongNameHandler to
+    // call until we've called the parent!
+    fParent->processQuantity(quantity, micros, status);
+
+    // Call the correct LongNameHandler based on outputUnit
+    for (int i = 0; i < fHandlers.getCapacity(); i++) {
+        if (fMeasureUnits[i] == micros.outputUnit) {
+            fHandlers[i]->processQuantity(quantity, micros, status);
+            return;
+        }
+    }
+    if (U_FAILURE(status)) {
+        return;
+    }
+    // We shouldn't receive any outputUnit for which we haven't already got a
+    // LongNameHandler:
+    status = U_INTERNAL_PROGRAM_ERROR;
+}
+
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_longnames.h b/deps/icu-small/source/i18n/number_longnames.h
index a19425aa268af62ef19c6498b2321b4599ad2b48..bca55e010317dc8e89a4ece75f40a32edd7b7e51 100644
--- a/deps/icu-small/source/i18n/number_longnames.h
+++ b/deps/icu-small/source/i18n/number_longnames.h
@@ -7,6 +7,8 @@
 #ifndef __NUMBER_LONGNAMES_H__
 #define __NUMBER_LONGNAMES_H__
 
+#include "cmemory.h"
+#include "unicode/listformatter.h"
 #include "unicode/uversion.h"
 #include "number_utils.h"
 #include "number_modifiers.h"
@@ -14,6 +16,8 @@
 U_NAMESPACE_BEGIN namespace number {
 namespace impl {
 
+// LongNameHandler takes care of formatting currency and measurement unit names,
+// as well as populating the gender of measure units.
 class LongNameHandler : public MicroPropsGenerator, public ModifierStore, public UMemory {
   public:
     static UnicodeString getUnitDisplayName(
@@ -22,6 +26,8 @@ class LongNameHandler : public MicroPropsGenerator, public ModifierStore, public
         UNumberUnitWidth width,
         UErrorCode& status);
 
+    // This function does not support inflections or other newer NumberFormatter
+    // features: it exists to support the older not-recommended MeasureFormat.
     static UnicodeString getUnitPattern(
         const Locale& loc,
         const MeasureUnit& unit,
@@ -33,34 +39,230 @@ class LongNameHandler : public MicroPropsGenerator, public ModifierStore, public
     forCurrencyLongNames(const Locale &loc, const CurrencyUnit &currency, const PluralRules *rules,
                          const MicroPropsGenerator *parent, UErrorCode &status);
 
-    static LongNameHandler*
-    forMeasureUnit(const Locale &loc, const MeasureUnit &unit, const MeasureUnit &perUnit,
-                   const UNumberUnitWidth &width, const PluralRules *rules,
-                   const MicroPropsGenerator *parent, UErrorCode &status);
+    /**
+     * Construct a localized LongNameHandler for the specified MeasureUnit.
+     *
+     * Mixed units are not supported, use MixedUnitLongNameHandler::forMeasureUnit.
+     *
+     * This function uses a fillIn intead of returning a pointer, because we
+     * want to fill in instances in a MemoryPool (which cannot adopt pointers it
+     * didn't create itself).
+     *
+     * @param loc The desired locale.
+     * @param unitRef The measure unit to construct a LongNameHandler for.
+     * @param width Specifies the desired unit rendering.
+     * @param unitDisplayCase Specifies the desired grammatical case. If the
+     *     specified case is not found, we fall back to nominative or no-case.
+     * @param rules Does not take ownership.
+     * @param parent Does not take ownership.
+     * @param fillIn Required.
+     */
+    static void forMeasureUnit(const Locale &loc,
+                               const MeasureUnit &unitRef,
+                               const UNumberUnitWidth &width,
+                               const char *unitDisplayCase,
+                               const PluralRules *rules,
+                               const MicroPropsGenerator *parent,
+                               LongNameHandler *fillIn,
+                               UErrorCode &status);
 
+    /**
+     * Selects the plural-appropriate Modifier from the set of fModifiers based
+     * on the plural form.
+     */
     void
     processQuantity(DecimalQuantity &quantity, MicroProps &micros, UErrorCode &status) const U_OVERRIDE;
 
     const Modifier* getModifier(Signum signum, StandardPlural::Form plural) const U_OVERRIDE;
 
   private:
+    // A set of pre-computed modifiers, one for each plural form.
     SimpleModifier fModifiers[StandardPlural::Form::COUNT];
+    // Not owned
     const PluralRules *rules;
+    // Not owned
     const MicroPropsGenerator *parent;
+    // Grammatical gender of the formatted result. Not owned: must point at
+    // static or global strings.
+    const char *gender = "";
 
     LongNameHandler(const PluralRules *rules, const MicroPropsGenerator *parent)
-            : rules(rules), parent(parent) {}
+        : rules(rules), parent(parent) {
+    }
 
-    static LongNameHandler*
-    forCompoundUnit(const Locale &loc, const MeasureUnit &unit, const MeasureUnit &perUnit,
-                    const UNumberUnitWidth &width, const PluralRules *rules,
-                    const MicroPropsGenerator *parent, UErrorCode &status);
+    LongNameHandler() : rules(nullptr), parent(nullptr) {
+    }
+
+    // Enables MemoryPool<LongNameHandler>::emplaceBack(): requires access to
+    // the private constructors.
+    friend class MemoryPool<LongNameHandler>;
+
+    // Allow macrosToMicroGenerator to call the private default constructor.
+    friend class NumberFormatterImpl;
+
+    // Fills in LongNameHandler fields for formatting units identified `unit`.
+    static void forArbitraryUnit(const Locale &loc,
+                                 const MeasureUnit &unit,
+                                 const UNumberUnitWidth &width,
+                                 const char *unitDisplayCase,
+                                 LongNameHandler *fillIn,
+                                 UErrorCode &status);
 
+    // Roughly corresponds to patternTimes(...) in the spec:
+    // https://unicode.org/reports/tr35/tr35-general.html#compound-units
+    //
+    // productUnit is an rvalue reference to indicate this function consumes it,
+    // leaving it in a not-useful / undefined state.
+    static void processPatternTimes(MeasureUnitImpl &&productUnit,
+                                    Locale loc,
+                                    const UNumberUnitWidth &width,
+                                    const char *caseVariant,
+                                    UnicodeString *outArray,
+                                    UErrorCode &status);
+
+    // Sets fModifiers to use the patterns from `simpleFormats`.
     void simpleFormatsToModifiers(const UnicodeString *simpleFormats, Field field, UErrorCode &status);
+
+    // Sets fModifiers to a combination of `leadFormats` (one per plural form)
+    // and `trailFormat` appended to each.
+    //
+    // With a leadFormat of "{0}m" and a trailFormat of "{0}/s", it produces a
+    // pattern of "{0}m/s" by inserting each leadFormat pattern into trailFormat.
     void multiSimpleFormatsToModifiers(const UnicodeString *leadFormats, UnicodeString trailFormat,
                                        Field field, UErrorCode &status);
 };
 
+// Similar to LongNameHandler, but only for MIXED units.
+class MixedUnitLongNameHandler : public MicroPropsGenerator, public ModifierStore, public UMemory {
+  public:
+    /**
+     * Construct a localized MixedUnitLongNameHandler for the specified
+     * MeasureUnit. It must be a MIXED unit.
+     *
+     * This function uses a fillIn intead of returning a pointer, because we
+     * want to fill in instances in a MemoryPool (which cannot adopt pointers it
+     * didn't create itself).
+     *
+     * @param loc The desired locale.
+     * @param mixedUnit The mixed measure unit to construct a
+     *     MixedUnitLongNameHandler for.
+     * @param width Specifies the desired unit rendering.
+     * @param unitDisplayCase Specifies the desired grammatical case. If the
+     *     specified case is not found, we fall back to nominative or no-case.
+     * @param rules Does not take ownership.
+     * @param parent Does not take ownership.
+     * @param fillIn Required.
+     */
+    static void forMeasureUnit(const Locale &loc,
+                               const MeasureUnit &mixedUnit,
+                               const UNumberUnitWidth &width,
+                               const char *unitDisplayCase,
+                               const PluralRules *rules,
+                               const MicroPropsGenerator *parent,
+                               MixedUnitLongNameHandler *fillIn,
+                               UErrorCode &status);
+
+    /**
+     * Produces a plural-appropriate Modifier for a mixed unit: `quantity` is
+     * taken as the final smallest unit, while the larger unit values must be
+     * provided via `micros.mixedMeasures`.
+     */
+    void processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                         UErrorCode &status) const U_OVERRIDE;
+
+    // Required for ModifierStore. And ModifierStore is required by
+    // SimpleModifier constructor's last parameter. We assert his will never get
+    // called though.
+    const Modifier *getModifier(Signum signum, StandardPlural::Form plural) const U_OVERRIDE;
+
+  private:
+    // Not owned
+    const PluralRules *rules;
+
+    // Not owned
+    const MicroPropsGenerator *parent;
+
+    // Total number of units in the MeasureUnit this handler was configured for:
+    // for "foot-and-inch", this will be 2.
+    int32_t fMixedUnitCount = 1;
+
+    // Stores unit data for each of the individual units. For each unit, it
+    // stores ARRAY_LENGTH strings, as returned by getMeasureData. (Each unit
+    // with index `i` has ARRAY_LENGTH strings starting at index
+    // `i*ARRAY_LENGTH` in this array.)
+    LocalArray<UnicodeString> fMixedUnitData;
+
+    // Formats the larger units of Mixed Unit measurements.
+    LocalizedNumberFormatter fNumberFormatter;
+
+    // Joins mixed units together.
+    LocalPointer<ListFormatter> fListFormatter;
+
+    MixedUnitLongNameHandler(const PluralRules *rules, const MicroPropsGenerator *parent)
+        : rules(rules), parent(parent) {
+    }
+
+    MixedUnitLongNameHandler() : rules(nullptr), parent(nullptr) {
+    }
+
+    // Allow macrosToMicroGenerator to call the private default constructor.
+    friend class NumberFormatterImpl;
+
+    // Enables MemoryPool<LongNameHandler>::emplaceBack(): requires access to
+    // the private constructors.
+    friend class MemoryPool<MixedUnitLongNameHandler>;
+
+    // For a mixed unit, returns a Modifier that takes only one parameter: the
+    // smallest and final unit of the set. The bigger units' values and labels
+    // get baked into this Modifier, together with the unit label of the final
+    // unit.
+    const Modifier *getMixedUnitModifier(DecimalQuantity &quantity, MicroProps &micros,
+                                         UErrorCode &status) const;
+};
+
+/**
+ * A MicroPropsGenerator that multiplexes between different LongNameHandlers,
+ * depending on the outputUnit.
+ *
+ * See processQuantity() for the input requirements.
+ */
+class LongNameMultiplexer : public MicroPropsGenerator, public UMemory {
+  public:
+    // Produces a multiplexer for LongNameHandlers, one for each unit in
+    // `units`. An individual unit might be a mixed unit.
+    static LongNameMultiplexer *forMeasureUnits(const Locale &loc,
+                                                const MaybeStackVector<MeasureUnit> &units,
+                                                const UNumberUnitWidth &width,
+                                                const char *unitDisplayCase,
+                                                const PluralRules *rules,
+                                                const MicroPropsGenerator *parent,
+                                                UErrorCode &status);
+
+    // The output unit must be provided via `micros.outputUnit`, it must match
+    // one of the units provided to the factory function.
+    void processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                         UErrorCode &status) const U_OVERRIDE;
+
+  private:
+    /**
+     * Because we only know which LongNameHandler we wish to call after calling
+     * earlier MicroPropsGenerators in the chain, LongNameMultiplexer keeps the
+     * parent link, while the LongNameHandlers are given no parents.
+     */
+    MemoryPool<LongNameHandler> fLongNameHandlers;
+    MemoryPool<MixedUnitLongNameHandler> fMixedUnitHandlers;
+    // Unowned pointers to instances owned by MaybeStackVectors.
+    MaybeStackArray<MicroPropsGenerator *, 8> fHandlers;
+    // Each MeasureUnit corresponds to the same-index MicroPropsGenerator
+    // pointed to in fHandlers.
+    LocalArray<MeasureUnit> fMeasureUnits;
+
+    const MicroPropsGenerator *fParent;
+
+    LongNameMultiplexer(const MicroPropsGenerator *parent) : fParent(parent) {
+    }
+};
+
 }  // namespace impl
 }  // namespace number
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/number_mapper.cpp b/deps/icu-small/source/i18n/number_mapper.cpp
index ec617438c9a9e3a5adedb2a05f8edce808e61925..e2a0d284b7cf5d4c50a494267fb7ff4533c25c66 100644
--- a/deps/icu-small/source/i18n/number_mapper.cpp
+++ b/deps/icu-small/source/i18n/number_mapper.cpp
@@ -92,6 +92,8 @@ MacroProps NumberPropertyMapper::oldToNew(const DecimalFormatProperties& propert
     int32_t minSig = properties.minimumSignificantDigits;
     int32_t maxSig = properties.maximumSignificantDigits;
     double roundingIncrement = properties.roundingIncrement;
+    // Not assigning directly to macros.roundingMode here: we change
+    // roundingMode if and when we also change macros.precision.
     RoundingMode roundingMode = properties.roundingMode.getOrDefault(UNUM_ROUND_HALFEVEN);
     bool explicitMinMaxFrac = minFrac != -1 || maxFrac != -1;
     bool explicitMinMaxSig = minSig != -1 || maxSig != -1;
@@ -145,7 +147,7 @@ MacroProps NumberPropertyMapper::oldToNew(const DecimalFormatProperties& propert
         precision = Precision::constructCurrency(currencyUsage);
     }
     if (!precision.isBogus()) {
-        precision.fRoundingMode = roundingMode;
+        macros.roundingMode = roundingMode;
         macros.precision = precision;
     }
 
@@ -239,7 +241,7 @@ MacroProps NumberPropertyMapper::oldToNew(const DecimalFormatProperties& propert
                 // TODO: Reset maxSig_ = 1 + minFrac_ to follow the spec.
                 macros.precision = Precision::constructSignificant(minSig_, maxSig_);
             }
-            macros.precision.fRoundingMode = roundingMode;
+            macros.roundingMode = roundingMode;
         }
     }
 
diff --git a/deps/icu-small/source/i18n/number_mapper.h b/deps/icu-small/source/i18n/number_mapper.h
index d18b8b3c438cf42c48a288337ec51c57cbd6c49d..9ecd776b3b4795512159c3e60c3b2c32cbb81c50 100644
--- a/deps/icu-small/source/i18n/number_mapper.h
+++ b/deps/icu-small/source/i18n/number_mapper.h
@@ -136,6 +136,16 @@ class AutoAffixPatternProvider {
         }
     }
 
+    inline void setTo(const AffixPatternProvider* provider, UErrorCode& status) {
+        if (auto ptr = dynamic_cast<const PropertiesAffixPatternProvider*>(provider)) {
+            propertiesAPP = *ptr;
+        } else if (auto ptr = dynamic_cast<const CurrencyPluralInfoAffixProvider*>(provider)) {
+            currencyPluralInfoAPP = *ptr;
+        } else {
+            status = U_INTERNAL_PROGRAM_ERROR;
+        }
+    }
+
     inline const AffixPatternProvider& get() const {
       if (!currencyPluralInfoAPP.isBogus()) {
         return currencyPluralInfoAPP;
@@ -153,9 +163,9 @@ class AutoAffixPatternProvider {
 /**
  * A struct for ownership of a few objects needed for formatting.
  */
-struct DecimalFormatWarehouse {
+struct DecimalFormatWarehouse : public UMemory {
     AutoAffixPatternProvider affixProvider;
-
+    LocalPointer<PluralRules> rules;
 };
 
 
diff --git a/deps/icu-small/source/i18n/number_microprops.h b/deps/icu-small/source/i18n/number_microprops.h
index 56512f5e6f94ac8c239b4c6cb4bd91c34db9e666..a18d5fc470eda1559bfd12f8bbd84a92b2e73590 100644
--- a/deps/icu-small/source/i18n/number_microprops.h
+++ b/deps/icu-small/source/i18n/number_microprops.h
@@ -22,6 +22,55 @@
 U_NAMESPACE_BEGIN namespace number {
 namespace impl {
 
+/**
+ * A copyable container for the integer values of mixed unit measurements.
+ *
+ * If memory allocation fails during copying, no values are copied and status is
+ * set to U_MEMORY_ALLOCATION_ERROR.
+ */
+class IntMeasures : public MaybeStackArray<int64_t, 2> {
+  public:
+    /**
+     * Default constructor initializes with internal T[stackCapacity] buffer.
+     *
+     * Stack Capacity: most mixed units are expected to consist of two or three
+     * subunits, so one or two integer measures should be enough.
+     */
+    IntMeasures() : MaybeStackArray<int64_t, 2>() {}
+
+    /**
+     * Copy constructor.
+     *
+     * If memory allocation fails during copying, no values are copied and
+     * status is set to U_MEMORY_ALLOCATION_ERROR.
+     */
+    IntMeasures(const IntMeasures &other) : MaybeStackArray<int64_t, 2>() {
+        this->operator=(other);
+    }
+
+    // Assignment operator
+    IntMeasures &operator=(const IntMeasures &rhs) {
+        if (this == &rhs) {
+            return *this;
+        }
+        copyFrom(rhs, status);
+        return *this;
+    }
+
+    /** Move constructor */
+    IntMeasures(IntMeasures &&src) = default;
+
+    /** Move assignment */
+    IntMeasures &operator=(IntMeasures &&src) = default;
+
+    UErrorCode status = U_ZERO_ERROR;
+};
+
+/**
+ * MicroProps is the first MicroPropsGenerator that should be should be called,
+ * producing an initialized MicroProps instance that will be passed on and
+ * modified throughout the rest of the chain of MicroPropsGenerator instances.
+ */
 struct MicroProps : public MicroPropsGenerator {
 
     // NOTE: All of these fields are properly initialized in NumberFormatterImpl.
@@ -34,21 +83,59 @@ struct MicroProps : public MicroPropsGenerator {
     bool useCurrency;
     char nsName[9];
 
+    // No ownership: must point at a string which will outlive MicroProps
+    // instances, e.g. a string with static storage duration, or just a string
+    // that will never be deallocated or modified.
+    const char *gender;
+
     // Note: This struct has no direct ownership of the following pointers.
     const DecimalFormatSymbols* symbols;
+
+    // Pointers to Modifiers provided by the number formatting pipeline (when
+    // the value is known):
+
+    // A Modifier provided by LongNameHandler, used for currency long names and
+    // units. If there is no LongNameHandler needed, this should be an
+    // EmptyModifier. (This is typically the third modifier applied.)
     const Modifier* modOuter;
+    // A Modifier for short currencies and compact notation. (This is typically
+    // the second modifier applied.)
     const Modifier* modMiddle = nullptr;
+    // A Modifier provided by ScientificHandler, used for scientific notation.
+    // This is typically the first modifier applied.
     const Modifier* modInner;
 
     // The following "helper" fields may optionally be used during the MicroPropsGenerator.
     // They live here to retain memory.
     struct {
+        // The ScientificModifier for which ScientificHandler is responsible.
+        // ScientificHandler::processQuantity() modifies this Modifier.
         ScientificModifier scientificModifier;
+        // EmptyModifier used for modOuter
         EmptyModifier emptyWeakModifier{false};
+        // EmptyModifier used for modInner
         EmptyModifier emptyStrongModifier{true};
         MultiplierFormatHandler multiplier;
+        // A Modifier used for Mixed Units. When formatting mixed units,
+        // LongNameHandler assigns this Modifier.
+        SimpleModifier mixedUnitModifier;
     } helpers;
 
+    // The MeasureUnit with which the output is represented. May also have
+    // UMEASURE_UNIT_MIXED complexity, in which case mixedMeasures comes into
+    // play.
+    MeasureUnit outputUnit;
+
+    // Contains all the values of each unit in mixed units. For quantity (which is the floating value of
+    // the smallest unit in the mixed unit), the value stores in `quantity`.
+    // NOTE: the value of quantity in `mixedMeasures` will be left unset.
+    IntMeasures mixedMeasures;
+
+    // Points to quantity position, -1 if the position is not set yet.
+    int32_t indexOfQuantity = -1;
+
+    // Number of mixedMeasures that have been populated
+    int32_t mixedMeasuresCount = 0;
 
     MicroProps() = default;
 
@@ -56,7 +143,23 @@ struct MicroProps : public MicroPropsGenerator {
 
     MicroProps& operator=(const MicroProps& other) = default;
 
-    void processQuantity(DecimalQuantity&, MicroProps& micros, UErrorCode& status) const U_OVERRIDE {
+    /**
+     * As MicroProps is the "base instance", this implementation of
+     * MicroPropsGenerator::processQuantity() just ensures that the output
+     * `micros` is correctly initialized.
+     *
+     * For the "safe" invocation of this function, micros must not be *this,
+     * such that a copy of the base instance is made. For the "unsafe" path,
+     * this function can be used only once, because the base MicroProps instance
+     * will be modified and thus not be available for re-use.
+     *
+     * @param quantity The quantity for consideration and optional mutation.
+     * @param micros The MicroProps instance to populate. If this parameter is
+     * not already `*this`, it will be overwritten with a copy of `*this`.
+     */
+    void processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                         UErrorCode &status) const U_OVERRIDE {
+        (void) quantity;
         (void) status;
         if (this == &micros) {
             // Unsafe path: no need to perform a copy.
@@ -65,6 +168,7 @@ struct MicroProps : public MicroPropsGenerator {
             U_ASSERT(exhausted);
         } else {
             // Safe path: copy self into the output micros.
+            U_ASSERT(!exhausted);
             micros = *this;
         }
     }
diff --git a/deps/icu-small/source/i18n/number_modifiers.cpp b/deps/icu-small/source/i18n/number_modifiers.cpp
index 3becb7ba852336a05d324d97a6288d76ac21ae00..b7d825f499e4d2bf2f3ffa4f10bb716f254aa11d 100644
--- a/deps/icu-small/source/i18n/number_modifiers.cpp
+++ b/deps/icu-small/source/i18n/number_modifiers.cpp
@@ -25,13 +25,13 @@ const int32_t ARG_NUM_LIMIT = 0x100;
 icu::UInitOnce gDefaultCurrencySpacingInitOnce = U_INITONCE_INITIALIZER;
 
 UnicodeSet *UNISET_DIGIT = nullptr;
-UnicodeSet *UNISET_NOTS = nullptr;
+UnicodeSet *UNISET_NOTSZ = nullptr;
 
 UBool U_CALLCONV cleanupDefaultCurrencySpacing() {
     delete UNISET_DIGIT;
     UNISET_DIGIT = nullptr;
-    delete UNISET_NOTS;
-    UNISET_NOTS = nullptr;
+    delete UNISET_NOTSZ;
+    UNISET_NOTSZ = nullptr;
     gDefaultCurrencySpacingInitOnce.reset();
     return TRUE;
 }
@@ -39,13 +39,13 @@ UBool U_CALLCONV cleanupDefaultCurrencySpacing() {
 void U_CALLCONV initDefaultCurrencySpacing(UErrorCode &status) {
     ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY_SPACING, cleanupDefaultCurrencySpacing);
     UNISET_DIGIT = new UnicodeSet(UnicodeString(u"[:digit:]"), status);
-    UNISET_NOTS = new UnicodeSet(UnicodeString(u"[:^S:]"), status);
-    if (UNISET_DIGIT == nullptr || UNISET_NOTS == nullptr) {
+    UNISET_NOTSZ = new UnicodeSet(UnicodeString(u"[[:^S:]&[:^Z:]]"), status);
+    if (UNISET_DIGIT == nullptr || UNISET_NOTSZ == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
     UNISET_DIGIT->freeze();
-    UNISET_NOTS->freeze();
+    UNISET_NOTSZ->freeze();
 }
 
 }  // namespace
@@ -469,8 +469,8 @@ CurrencySpacingEnabledModifier::getUnicodeSet(const DecimalFormatSymbols &symbol
             status);
     if (pattern.compare(u"[:digit:]", -1) == 0) {
         return *UNISET_DIGIT;
-    } else if (pattern.compare(u"[:^S:]", -1) == 0) {
-        return *UNISET_NOTS;
+    } else if (pattern.compare(u"[[:^S:]&[:^Z:]]", -1) == 0) {
+        return *UNISET_NOTSZ;
     } else {
         return UnicodeSet(pattern, status);
     }
diff --git a/deps/icu-small/source/i18n/number_multiplier.cpp b/deps/icu-small/source/i18n/number_multiplier.cpp
index 8f07e548de121b57b31a0d06badd2086e4736f8e..58e1e441bd28c55096c8459ceaa0af8b9dceb5cd 100644
--- a/deps/icu-small/source/i18n/number_multiplier.cpp
+++ b/deps/icu-small/source/i18n/number_multiplier.cpp
@@ -46,6 +46,7 @@ Scale::Scale(const Scale& other)
 }
 
 Scale& Scale::operator=(const Scale& other) {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     fMagnitude = other.fMagnitude;
     if (other.fArbitrary != nullptr) {
         UErrorCode localStatus = U_ZERO_ERROR;
diff --git a/deps/icu-small/source/i18n/number_output.cpp b/deps/icu-small/source/i18n/number_output.cpp
index 40192a9225b9de98635d991b5f55457999ef4108..2c2c25eaedb4270a91211824e5df7811217d1c63 100644
--- a/deps/icu-small/source/i18n/number_output.cpp
+++ b/deps/icu-small/source/i18n/number_output.cpp
@@ -5,11 +5,13 @@
 
 #if !UCONFIG_NO_FORMATTING
 
+#include "unicode/measunit.h"
 #include "unicode/numberformatter.h"
 #include "number_utypes.h"
 #include "util.h"
 #include "number_decimalquantity.h"
 #include "number_decnum.h"
+#include "numrange_impl.h"
 
 U_NAMESPACE_BEGIN
 namespace number {
@@ -32,6 +34,16 @@ void FormattedNumber::getAllFieldPositionsImpl(FieldPositionIteratorHandler& fpi
     fData->getAllFieldPositions(fpih, status);
 }
 
+MeasureUnit FormattedNumber::getOutputUnit(UErrorCode& status) const {
+    UPRV_FORMATTED_VALUE_METHOD_GUARD(MeasureUnit())
+    return fData->outputUnit;
+}
+
+const char *FormattedNumber::getGender(UErrorCode &status) const {
+    UPRV_FORMATTED_VALUE_METHOD_GUARD("")
+    return fData->gender;
+}
+
 void FormattedNumber::getDecimalQuantity(impl::DecimalQuantity& output, UErrorCode& status) const {
     UPRV_FORMATTED_VALUE_METHOD_GUARD(UPRV_NOARG)
     output = fData->quantity;
@@ -41,6 +53,32 @@ void FormattedNumber::getDecimalQuantity(impl::DecimalQuantity& output, UErrorCo
 impl::UFormattedNumberData::~UFormattedNumberData() = default;
 
 
+UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedNumberRange)
+
+#define UPRV_NOARG
+
+void FormattedNumberRange::getDecimalNumbers(ByteSink& sink1, ByteSink& sink2, UErrorCode& status) const {
+    UPRV_FORMATTED_VALUE_METHOD_GUARD(UPRV_NOARG)
+    impl::DecNum decnum1;
+    impl::DecNum decnum2;
+    fData->quantity1.toDecNum(decnum1, status).toString(sink1, status);
+    fData->quantity2.toDecNum(decnum2, status).toString(sink2, status);
+}
+
+UNumberRangeIdentityResult FormattedNumberRange::getIdentityResult(UErrorCode& status) const {
+    UPRV_FORMATTED_VALUE_METHOD_GUARD(UNUM_IDENTITY_RESULT_NOT_EQUAL)
+    return fData->identityResult;
+}
+
+const impl::UFormattedNumberRangeData* FormattedNumberRange::getData(UErrorCode& status) const {
+    UPRV_FORMATTED_VALUE_METHOD_GUARD(nullptr)
+    return fData;
+}
+
+
+impl::UFormattedNumberRangeData::~UFormattedNumberRangeData() = default;
+
+
 } // namespace number
 U_NAMESPACE_END
 
diff --git a/deps/icu-small/source/i18n/number_patternmodifier.cpp b/deps/icu-small/source/i18n/number_patternmodifier.cpp
index 45602942aefe8e7acc3e74e16339f9554e761771..314e7cb75ee169c86e13161d8045f9fe255b6ad0 100644
--- a/deps/icu-small/source/i18n/number_patternmodifier.cpp
+++ b/deps/icu-small/source/i18n/number_patternmodifier.cpp
@@ -294,14 +294,20 @@ UnicodeString MutablePatternModifier::getSymbol(AffixPatternType type) const {
         case AffixPatternType::TYPE_PERMILLE:
             return fSymbols->getSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kPerMillSymbol);
         case AffixPatternType::TYPE_CURRENCY_SINGLE: {
-            // UnitWidth ISO and HIDDEN overrides the singular currency symbol.
-            if (fUnitWidth == UNumberUnitWidth::UNUM_UNIT_WIDTH_ISO_CODE) {
+            switch (fUnitWidth) {
+            case UNumberUnitWidth::UNUM_UNIT_WIDTH_NARROW:
+                return fCurrencySymbols.getNarrowCurrencySymbol(localStatus);
+            case UNumberUnitWidth::UNUM_UNIT_WIDTH_SHORT:
+                return fCurrencySymbols.getCurrencySymbol(localStatus);
+            case UNumberUnitWidth::UNUM_UNIT_WIDTH_ISO_CODE:
                 return fCurrencySymbols.getIntlCurrencySymbol(localStatus);
-            } else if (fUnitWidth == UNumberUnitWidth::UNUM_UNIT_WIDTH_HIDDEN) {
+            case UNumberUnitWidth::UNUM_UNIT_WIDTH_FORMAL:
+                return fCurrencySymbols.getFormalCurrencySymbol(localStatus);
+            case UNumberUnitWidth::UNUM_UNIT_WIDTH_VARIANT:
+                return fCurrencySymbols.getVariantCurrencySymbol(localStatus);
+            case UNumberUnitWidth::UNUM_UNIT_WIDTH_HIDDEN:
                 return UnicodeString();
-            } else if (fUnitWidth == UNumberUnitWidth::UNUM_UNIT_WIDTH_NARROW) {
-                return fCurrencySymbols.getNarrowCurrencySymbol(localStatus);
-            } else {
+            default:
                 return fCurrencySymbols.getCurrencySymbol(localStatus);
             }
         }
diff --git a/deps/icu-small/source/i18n/number_patternstring.cpp b/deps/icu-small/source/i18n/number_patternstring.cpp
index 9d845056069b800f78f283102a54519f199505dd..ac9e8b7e8e4d7521841a2f8f01acc04e1467b8c8 100644
--- a/deps/icu-small/source/i18n/number_patternstring.cpp
+++ b/deps/icu-small/source/i18n/number_patternstring.cpp
@@ -1106,6 +1106,20 @@ PatternSignType PatternStringUtils::resolveSignDisplay(UNumberSignDisplay signDi
             }
             break;
 
+        case UNUM_SIGN_NEGATIVE:
+        case UNUM_SIGN_ACCOUNTING_NEGATIVE:
+            switch (signum) {
+                case SIGNUM_NEG:
+                    return PATTERN_SIGN_TYPE_NEG;
+                case SIGNUM_NEG_ZERO:
+                case SIGNUM_POS_ZERO:
+                case SIGNUM_POS:
+                    return PATTERN_SIGN_TYPE_POS;
+                default:
+                    break;
+            }
+            break;
+
         case UNUM_SIGN_NEVER:
             return PATTERN_SIGN_TYPE_POS;
 
diff --git a/deps/icu-small/source/i18n/number_rounding.cpp b/deps/icu-small/source/i18n/number_rounding.cpp
index 3ffce673ad08856de61e26297044f518a5e84f2d..40392ee857e493dd3ff3bc4fa7afff437eba7b89 100644
--- a/deps/icu-small/source/i18n/number_rounding.cpp
+++ b/deps/icu-small/source/i18n/number_rounding.cpp
@@ -5,13 +5,16 @@
 
 #if !UCONFIG_NO_FORMATTING
 
+#include "charstr.h"
 #include "uassert.h"
 #include "unicode/numberformatter.h"
 #include "number_types.h"
 #include "number_decimalquantity.h"
 #include "double-conversion.h"
 #include "number_roundingutils.h"
+#include "number_skeletons.h"
 #include "putilimp.h"
+#include "string_segment.h"
 
 using namespace icu;
 using namespace icu::number;
@@ -19,6 +22,39 @@ using namespace icu::number::impl;
 
 
 using double_conversion::DoubleToStringConverter;
+using icu::StringSegment;
+
+void number::impl::parseIncrementOption(const StringSegment &segment,
+                                        Precision &outPrecision,
+                                        UErrorCode &status) {
+    // Need to do char <-> UChar conversion...
+    U_ASSERT(U_SUCCESS(status));
+    CharString buffer;
+    SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status);
+
+    // Utilize DecimalQuantity/decNumber to parse this for us.
+    DecimalQuantity dq;
+    UErrorCode localStatus = U_ZERO_ERROR;
+    dq.setToDecNumber({buffer.data(), buffer.length()}, localStatus);
+    if (U_FAILURE(localStatus)) {
+        // throw new SkeletonSyntaxException("Invalid rounding increment", segment, e);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+    double increment = dq.toDouble();
+
+    // We also need to figure out how many digits. Do a brute force string operation.
+    int decimalOffset = 0;
+    while (decimalOffset < segment.length() && segment.charAt(decimalOffset) != '.') {
+        decimalOffset++;
+    }
+    if (decimalOffset == segment.length()) {
+        outPrecision = Precision::increment(increment);
+    } else {
+        int32_t fractionLength = segment.length() - decimalOffset - 1;
+        outPrecision = Precision::increment(increment).withMinFraction(fractionLength);
+    }
+}
 
 namespace {
 
@@ -84,7 +120,7 @@ digits_t roundingutils::doubleFractionLength(double input, int8_t* singleDigit)
 
 
 Precision Precision::unlimited() {
-    return Precision(RND_NONE, {}, kDefaultMode);
+    return Precision(RND_NONE, {});
 }
 
 FractionPrecision Precision::integer() {
@@ -157,6 +193,12 @@ Precision Precision::minMaxSignificantDigits(int32_t minSignificantDigits, int32
     }
 }
 
+Precision Precision::trailingZeroDisplay(UNumberTrailingZeroDisplay trailingZeroDisplay) const {
+    Precision result(*this); // copy constructor
+    result.fTrailingZeroDisplay = trailingZeroDisplay;
+    return result;
+}
+
 IncrementPrecision Precision::increment(double roundingIncrement) {
     if (roundingIncrement > 0.0) {
         return constructIncrement(roundingIncrement, 0);
@@ -169,10 +211,32 @@ CurrencyPrecision Precision::currency(UCurrencyUsage currencyUsage) {
     return constructCurrency(currencyUsage);
 }
 
+Precision FractionPrecision::withSignificantDigits(
+        int32_t minSignificantDigits,
+        int32_t maxSignificantDigits,
+        UNumberRoundingPriority priority) const {
+    if (fType == RND_ERROR) { return *this; } // no-op in error state
+    if (minSignificantDigits >= 1 &&
+            maxSignificantDigits >= minSignificantDigits &&
+            maxSignificantDigits <= kMaxIntFracSig) {
+        return constructFractionSignificant(
+            *this,
+            minSignificantDigits,
+            maxSignificantDigits,
+            priority);
+    } else {
+        return {U_NUMBER_ARG_OUTOFBOUNDS_ERROR};
+    }
+}
+
 Precision FractionPrecision::withMinDigits(int32_t minSignificantDigits) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     if (minSignificantDigits >= 1 && minSignificantDigits <= kMaxIntFracSig) {
-        return constructFractionSignificant(*this, minSignificantDigits, -1);
+        return constructFractionSignificant(
+            *this,
+            1,
+            minSignificantDigits,
+            UNUM_ROUNDING_PRIORITY_RELAXED);
     } else {
         return {U_NUMBER_ARG_OUTOFBOUNDS_ERROR};
     }
@@ -181,7 +245,10 @@ Precision FractionPrecision::withMinDigits(int32_t minSignificantDigits) const {
 Precision FractionPrecision::withMaxDigits(int32_t maxSignificantDigits) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     if (maxSignificantDigits >= 1 && maxSignificantDigits <= kMaxIntFracSig) {
-        return constructFractionSignificant(*this, -1, maxSignificantDigits);
+        return constructFractionSignificant(*this,
+            1,
+            maxSignificantDigits,
+            UNUM_ROUNDING_PRIORITY_STRICT);
     } else {
         return {U_NUMBER_ARG_OUTOFBOUNDS_ERROR};
     }
@@ -195,11 +262,11 @@ Precision Precision::withCurrency(const CurrencyUnit &currency, UErrorCode &stat
     double increment = ucurr_getRoundingIncrementForUsage(isoCode, fUnion.currencyUsage, &status);
     int32_t minMaxFrac = ucurr_getDefaultFractionDigitsForUsage(
             isoCode, fUnion.currencyUsage, &status);
-    if (increment != 0.0) {
-        return constructIncrement(increment, minMaxFrac);
-    } else {
-        return constructFraction(minMaxFrac, minMaxFrac);
-    }
+    Precision retval = (increment != 0.0)
+        ? static_cast<Precision>(constructIncrement(increment, minMaxFrac))
+        : static_cast<Precision>(constructFraction(minMaxFrac, minMaxFrac));
+    retval.fTrailingZeroDisplay = fTrailingZeroDisplay;
+    return retval;
 }
 
 // Public method on CurrencyPrecision subclass
@@ -229,7 +296,7 @@ FractionPrecision Precision::constructFraction(int32_t minFrac, int32_t maxFrac)
     settings.fMaxSig = -1;
     PrecisionUnion union_;
     union_.fracSig = settings;
-    return {RND_FRACTION, union_, kDefaultMode};
+    return {RND_FRACTION, union_};
 }
 
 Precision Precision::constructSignificant(int32_t minSig, int32_t maxSig) {
@@ -240,17 +307,22 @@ Precision Precision::constructSignificant(int32_t minSig, int32_t maxSig) {
     settings.fMaxSig = static_cast<digits_t>(maxSig);
     PrecisionUnion union_;
     union_.fracSig = settings;
-    return {RND_SIGNIFICANT, union_, kDefaultMode};
+    return {RND_SIGNIFICANT, union_};
 }
 
 Precision
-Precision::constructFractionSignificant(const FractionPrecision &base, int32_t minSig, int32_t maxSig) {
+Precision::constructFractionSignificant(
+        const FractionPrecision &base,
+        int32_t minSig,
+        int32_t maxSig,
+        UNumberRoundingPriority priority) {
     FractionSignificantSettings settings = base.fUnion.fracSig;
     settings.fMinSig = static_cast<digits_t>(minSig);
     settings.fMaxSig = static_cast<digits_t>(maxSig);
+    settings.fPriority = priority;
     PrecisionUnion union_;
     union_.fracSig = settings;
-    return {RND_FRACTION_SIGNIFICANT, union_, kDefaultMode};
+    return {RND_FRACTION_SIGNIFICANT, union_};
 }
 
 IncrementPrecision Precision::constructIncrement(double increment, int32_t minFrac) {
@@ -270,18 +342,18 @@ IncrementPrecision Precision::constructIncrement(double increment, int32_t minFr
         // NOTE: In C++, we must return the correct value type with the correct union.
         // It would be invalid to return a RND_FRACTION here because the methods on the
         // IncrementPrecision type assume that the union is backed by increment data.
-        return {RND_INCREMENT_ONE, union_, kDefaultMode};
+        return {RND_INCREMENT_ONE, union_};
     } else if (singleDigit == 5) {
-        return {RND_INCREMENT_FIVE, union_, kDefaultMode};
+        return {RND_INCREMENT_FIVE, union_};
     } else {
-        return {RND_INCREMENT, union_, kDefaultMode};
+        return {RND_INCREMENT, union_};
     }
 }
 
 CurrencyPrecision Precision::constructCurrency(UCurrencyUsage usage) {
     PrecisionUnion union_;
     union_.currencyUsage = usage;
-    return {RND_CURRENCY, union_, kDefaultMode};
+    return {RND_CURRENCY, union_};
 }
 
 
@@ -341,9 +413,13 @@ RoundingImpl::chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl:
 
 /** This is the method that contains the actual rounding logic. */
 void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return;
+    }
     if (fPassThrough) {
         return;
     }
+    int32_t resolvedMinFraction = 0;
     switch (fPrecision.fType) {
         case Precision::RND_BOGUS:
         case Precision::RND_ERROR:
@@ -360,8 +436,8 @@ void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const
                     getRoundingMagnitudeFraction(fPrecision.fUnion.fracSig.fMaxFrac),
                     fRoundingMode,
                     status);
-            value.setMinFraction(
-                    uprv_max(0, -getDisplayMagnitudeFraction(fPrecision.fUnion.fracSig.fMinFrac)));
+            resolvedMinFraction =
+                    uprv_max(0, -getDisplayMagnitudeFraction(fPrecision.fUnion.fracSig.fMinFrac));
             break;
 
         case Precision::RND_SIGNIFICANT:
@@ -369,8 +445,8 @@ void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const
                     getRoundingMagnitudeSignificant(value, fPrecision.fUnion.fracSig.fMaxSig),
                     fRoundingMode,
                     status);
-            value.setMinFraction(
-                    uprv_max(0, -getDisplayMagnitudeSignificant(value, fPrecision.fUnion.fracSig.fMinSig)));
+            resolvedMinFraction =
+                    uprv_max(0, -getDisplayMagnitudeSignificant(value, fPrecision.fUnion.fracSig.fMinSig));
             // Make sure that digits are displayed on zero.
             if (value.isZeroish() && fPrecision.fUnion.fracSig.fMinSig > 0) {
                 value.setMinInteger(1);
@@ -378,23 +454,21 @@ void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const
             break;
 
         case Precision::RND_FRACTION_SIGNIFICANT: {
-            int32_t displayMag = getDisplayMagnitudeFraction(fPrecision.fUnion.fracSig.fMinFrac);
-            int32_t roundingMag = getRoundingMagnitudeFraction(fPrecision.fUnion.fracSig.fMaxFrac);
-            if (fPrecision.fUnion.fracSig.fMinSig == -1) {
-                // Max Sig override
-                int32_t candidate = getRoundingMagnitudeSignificant(
-                        value,
-                        fPrecision.fUnion.fracSig.fMaxSig);
-                roundingMag = uprv_max(roundingMag, candidate);
+            int32_t roundingMag1 = getRoundingMagnitudeFraction(fPrecision.fUnion.fracSig.fMaxFrac);
+            int32_t roundingMag2 = getRoundingMagnitudeSignificant(value, fPrecision.fUnion.fracSig.fMaxSig);
+            int32_t roundingMag;
+            if (fPrecision.fUnion.fracSig.fPriority == UNUM_ROUNDING_PRIORITY_RELAXED) {
+                roundingMag = uprv_min(roundingMag1, roundingMag2);
             } else {
-                // Min Sig override
-                int32_t candidate = getDisplayMagnitudeSignificant(
-                        value,
-                        fPrecision.fUnion.fracSig.fMinSig);
-                roundingMag = uprv_min(roundingMag, candidate);
+                roundingMag = uprv_max(roundingMag1, roundingMag2);
             }
             value.roundToMagnitude(roundingMag, fRoundingMode, status);
-            value.setMinFraction(uprv_max(0, -displayMag));
+
+            int32_t displayMag1 = getDisplayMagnitudeFraction(fPrecision.fUnion.fracSig.fMinFrac);
+            int32_t displayMag2 = getDisplayMagnitudeSignificant(value, fPrecision.fUnion.fracSig.fMinSig);
+            int32_t displayMag = uprv_min(displayMag1, displayMag2);
+            resolvedMinFraction = uprv_max(0, -displayMag);
+
             break;
         }
 
@@ -403,7 +477,7 @@ void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const
                     fPrecision.fUnion.increment.fIncrement,
                     fRoundingMode,
                     status);
-            value.setMinFraction(fPrecision.fUnion.increment.fMinFrac);
+            resolvedMinFraction = fPrecision.fUnion.increment.fMinFrac;
             break;
 
         case Precision::RND_INCREMENT_ONE:
@@ -411,7 +485,7 @@ void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const
                     -fPrecision.fUnion.increment.fMaxFrac,
                     fRoundingMode,
                     status);
-            value.setMinFraction(fPrecision.fUnion.increment.fMinFrac);
+            resolvedMinFraction = fPrecision.fUnion.increment.fMinFrac;
             break;
 
         case Precision::RND_INCREMENT_FIVE:
@@ -419,7 +493,7 @@ void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const
                     -fPrecision.fUnion.increment.fMaxFrac,
                     fRoundingMode,
                     status);
-            value.setMinFraction(fPrecision.fUnion.increment.fMinFrac);
+            resolvedMinFraction = fPrecision.fUnion.increment.fMinFrac;
             break;
 
         case Precision::RND_CURRENCY:
@@ -429,10 +503,17 @@ void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const
         default:
             UPRV_UNREACHABLE;
     }
+
+    if (fPrecision.fTrailingZeroDisplay == UNUM_TRAILING_ZERO_AUTO ||
+            // PLURAL_OPERAND_T returns fraction digits as an integer
+            value.getPluralOperand(PLURAL_OPERAND_T) != 0) {
+        value.setMinFraction(resolvedMinFraction);
+    }
 }
 
 void RoundingImpl::apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode /*status*/) {
     // This method is intended for the one specific purpose of helping print "00.000E0".
+    // Question: Is it useful to look at trailingZeroDisplay here?
     U_ASSERT(isSignificantDigits());
     U_ASSERT(value.isZeroish());
     value.setMinFraction(fPrecision.fUnion.fracSig.fMinSig - minInt);
diff --git a/deps/icu-small/source/i18n/number_roundingutils.h b/deps/icu-small/source/i18n/number_roundingutils.h
index 3e37f3195408fe8b3d90560fca64fc5f2a7ba29d..06fadd29fd544e032d367720052b56f4fd47d431 100644
--- a/deps/icu-small/source/i18n/number_roundingutils.h
+++ b/deps/icu-small/source/i18n/number_roundingutils.h
@@ -8,6 +8,7 @@
 #define __NUMBER_ROUNDINGUTILS_H__
 
 #include "number_types.h"
+#include "string_segment.h"
 
 U_NAMESPACE_BEGIN
 namespace number {
@@ -44,6 +45,9 @@ enum Section {
 inline bool
 getRoundingDirection(bool isEven, bool isNegative, Section section, RoundingMode roundingMode,
                      UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return false;
+    }
     switch (roundingMode) {
         case RoundingMode::UNUM_ROUND_UP:
             // round away from zero
@@ -100,6 +104,45 @@ getRoundingDirection(bool isEven, bool isNegative, Section section, RoundingMode
             }
             break;
 
+        case RoundingMode::UNUM_ROUND_HALF_ODD:
+            switch (section) {
+                case SECTION_MIDPOINT:
+                    return !isEven;
+                case SECTION_LOWER:
+                    return true;
+                case SECTION_UPPER:
+                    return false;
+                default:
+                    break;
+            }
+            break;
+
+        case RoundingMode::UNUM_ROUND_HALF_CEILING:
+            switch (section) {
+                case SECTION_MIDPOINT:
+                    return isNegative;
+                case SECTION_LOWER:
+                    return true;
+                case SECTION_UPPER:
+                    return false;
+                default:
+                    break;
+            }
+            break;
+
+        case RoundingMode::UNUM_ROUND_HALF_FLOOR:
+            switch (section) {
+                case SECTION_MIDPOINT:
+                    return !isNegative;
+                case SECTION_LOWER:
+                    return true;
+                case SECTION_UPPER:
+                    return false;
+                default:
+                    break;
+            }
+            break;
+
         default:
             break;
     }
@@ -187,8 +230,22 @@ class RoundingImpl {
     Precision fPrecision;
     UNumberFormatRoundingMode fRoundingMode;
     bool fPassThrough = true;  // default value
+
+    // Permits access to fPrecision.
+    friend class units::UnitsRouter;
+
+    // Permits access to fPrecision.
+    friend class UnitConversionHandler;
 };
 
+/**
+ * Parses Precision-related skeleton strings without knowledge of MacroProps
+ * - see blueprint_helpers::parseIncrementOption().
+ *
+ * Referencing MacroProps means needing to pull in the .o files that have the
+ * destructors for the SymbolsWrapper, StringProp, and Scale classes.
+ */
+void parseIncrementOption(const StringSegment &segment, Precision &outPrecision, UErrorCode &status);
 
 } // namespace impl
 } // namespace number
diff --git a/deps/icu-small/source/i18n/number_skeletons.cpp b/deps/icu-small/source/i18n/number_skeletons.cpp
index 4ba2647986c755ab7e1cde837cc3ca6732ff7c83..97d74303a4358e33928d6eaf80a13ae66ca153b4 100644
--- a/deps/icu-small/source/i18n/number_skeletons.cpp
+++ b/deps/icu-small/source/i18n/number_skeletons.cpp
@@ -10,6 +10,7 @@
 #define UNISTR_FROM_STRING_EXPLICIT
 
 #include "number_decnum.h"
+#include "number_roundingutils.h"
 #include "number_skeletons.h"
 #include "umutex.h"
 #include "ucln_in.h"
@@ -67,6 +68,9 @@ void U_CALLCONV initNumberSkeletons(UErrorCode& status) {
     b.add(u"rounding-mode-down", STEM_ROUNDING_MODE_DOWN, status);
     b.add(u"rounding-mode-up", STEM_ROUNDING_MODE_UP, status);
     b.add(u"rounding-mode-half-even", STEM_ROUNDING_MODE_HALF_EVEN, status);
+    b.add(u"rounding-mode-half-odd", STEM_ROUNDING_MODE_HALF_ODD, status);
+    b.add(u"rounding-mode-half-ceiling", STEM_ROUNDING_MODE_HALF_CEILING, status);
+    b.add(u"rounding-mode-half-floor", STEM_ROUNDING_MODE_HALF_FLOOR, status);
     b.add(u"rounding-mode-half-down", STEM_ROUNDING_MODE_HALF_DOWN, status);
     b.add(u"rounding-mode-half-up", STEM_ROUNDING_MODE_HALF_UP, status);
     b.add(u"rounding-mode-unnecessary", STEM_ROUNDING_MODE_UNNECESSARY, status);
@@ -80,6 +84,8 @@ void U_CALLCONV initNumberSkeletons(UErrorCode& status) {
     b.add(u"unit-width-short", STEM_UNIT_WIDTH_SHORT, status);
     b.add(u"unit-width-full-name", STEM_UNIT_WIDTH_FULL_NAME, status);
     b.add(u"unit-width-iso-code", STEM_UNIT_WIDTH_ISO_CODE, status);
+    b.add(u"unit-width-formal", STEM_UNIT_WIDTH_FORMAL, status);
+    b.add(u"unit-width-variant", STEM_UNIT_WIDTH_VARIANT, status);
     b.add(u"unit-width-hidden", STEM_UNIT_WIDTH_HIDDEN, status);
     b.add(u"sign-auto", STEM_SIGN_AUTO, status);
     b.add(u"sign-always", STEM_SIGN_ALWAYS, status);
@@ -88,6 +94,8 @@ void U_CALLCONV initNumberSkeletons(UErrorCode& status) {
     b.add(u"sign-accounting-always", STEM_SIGN_ACCOUNTING_ALWAYS, status);
     b.add(u"sign-except-zero", STEM_SIGN_EXCEPT_ZERO, status);
     b.add(u"sign-accounting-except-zero", STEM_SIGN_ACCOUNTING_EXCEPT_ZERO, status);
+    b.add(u"sign-negative", STEM_SIGN_NEGATIVE, status);
+    b.add(u"sign-accounting-negative", STEM_SIGN_ACCOUNTING_NEGATIVE, status);
     b.add(u"decimal-auto", STEM_DECIMAL_AUTO, status);
     b.add(u"decimal-always", STEM_DECIMAL_ALWAYS, status);
     if (U_FAILURE(status)) { return; }
@@ -97,6 +105,7 @@ void U_CALLCONV initNumberSkeletons(UErrorCode& status) {
     b.add(u"measure-unit", STEM_MEASURE_UNIT, status);
     b.add(u"per-measure-unit", STEM_PER_MEASURE_UNIT, status);
     b.add(u"unit", STEM_UNIT, status);
+    b.add(u"usage", STEM_UNIT_USAGE, status);
     b.add(u"currency", STEM_CURRENCY, status);
     b.add(u"integer-width", STEM_INTEGER_WIDTH, status);
     b.add(u"numbering-system", STEM_NUMBERING_SYSTEM, status);
@@ -117,6 +126,8 @@ void U_CALLCONV initNumberSkeletons(UErrorCode& status) {
     b.add(u"()!", STEM_SIGN_ACCOUNTING_ALWAYS, status);
     b.add(u"+?", STEM_SIGN_EXCEPT_ZERO, status);
     b.add(u"()?", STEM_SIGN_ACCOUNTING_EXCEPT_ZERO, status);
+    b.add(u"+-", STEM_SIGN_NEGATIVE, status);
+    b.add(u"()-", STEM_SIGN_ACCOUNTING_NEGATIVE, status);
     if (U_FAILURE(status)) { return; }
 
     // Build the CharsTrie
@@ -149,21 +160,6 @@ UPRV_BLOCK_MACRO_BEGIN { \
 } UPRV_BLOCK_MACRO_END
 
 
-#define SKELETON_UCHAR_TO_CHAR(dest, src, start, end, status) (void)(dest); \
-UPRV_BLOCK_MACRO_BEGIN { \
-    UErrorCode conversionStatus = U_ZERO_ERROR; \
-    (dest).appendInvariantChars({FALSE, (src).getBuffer() + (start), (end) - (start)}, conversionStatus); \
-    if (conversionStatus == U_INVARIANT_CONVERSION_ERROR) { \
-        /* Don't propagate the invariant conversion error; it is a skeleton syntax error */ \
-        (status) = U_NUMBER_SKELETON_SYNTAX_ERROR; \
-        return; \
-    } else if (U_FAILURE(conversionStatus)) { \
-        (status) = conversionStatus; \
-        return; \
-    } \
-} UPRV_BLOCK_MACRO_END
-
-
 } // anonymous namespace
 
 
@@ -187,14 +183,11 @@ Notation stem_to_object::notation(skeleton::StemEnum stem) {
 MeasureUnit stem_to_object::unit(skeleton::StemEnum stem) {
     switch (stem) {
         case STEM_BASE_UNIT:
-            // Slicing is okay
-            return NoUnit::base(); // NOLINT
+            return MeasureUnit();
         case STEM_PERCENT:
-            // Slicing is okay
-            return NoUnit::percent(); // NOLINT
+            return MeasureUnit::getPercent();
         case STEM_PERMILLE:
-            // Slicing is okay
-            return NoUnit::permille(); // NOLINT
+            return MeasureUnit::getPermille();
         default:
             UPRV_UNREACHABLE;
     }
@@ -227,6 +220,12 @@ UNumberFormatRoundingMode stem_to_object::roundingMode(skeleton::StemEnum stem)
             return UNUM_ROUND_UP;
         case STEM_ROUNDING_MODE_HALF_EVEN:
             return UNUM_ROUND_HALFEVEN;
+        case STEM_ROUNDING_MODE_HALF_ODD:
+            return UNUM_ROUND_HALF_ODD;
+        case STEM_ROUNDING_MODE_HALF_CEILING:
+            return UNUM_ROUND_HALF_CEILING;
+        case STEM_ROUNDING_MODE_HALF_FLOOR:
+            return UNUM_ROUND_HALF_FLOOR;
         case STEM_ROUNDING_MODE_HALF_DOWN:
             return UNUM_ROUND_HALFDOWN;
         case STEM_ROUNDING_MODE_HALF_UP:
@@ -265,6 +264,10 @@ UNumberUnitWidth stem_to_object::unitWidth(skeleton::StemEnum stem) {
             return UNUM_UNIT_WIDTH_FULL_NAME;
         case STEM_UNIT_WIDTH_ISO_CODE:
             return UNUM_UNIT_WIDTH_ISO_CODE;
+        case STEM_UNIT_WIDTH_FORMAL:
+            return UNUM_UNIT_WIDTH_FORMAL;
+        case STEM_UNIT_WIDTH_VARIANT:
+            return UNUM_UNIT_WIDTH_VARIANT;
         case STEM_UNIT_WIDTH_HIDDEN:
             return UNUM_UNIT_WIDTH_HIDDEN;
         default:
@@ -288,6 +291,10 @@ UNumberSignDisplay stem_to_object::signDisplay(skeleton::StemEnum stem) {
             return UNUM_SIGN_EXCEPT_ZERO;
         case STEM_SIGN_ACCOUNTING_EXCEPT_ZERO:
             return UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO;
+        case STEM_SIGN_NEGATIVE:
+            return UNUM_SIGN_NEGATIVE;
+        case STEM_SIGN_ACCOUNTING_NEGATIVE:
+            return UNUM_SIGN_ACCOUNTING_NEGATIVE;
         default:
             return UNUM_SIGN_COUNT; // for objects, throw; for enums, return COUNT
     }
@@ -322,6 +329,15 @@ void enum_to_stem_string::roundingMode(UNumberFormatRoundingMode value, UnicodeS
         case UNUM_ROUND_HALFEVEN:
             sb.append(u"rounding-mode-half-even", -1);
             break;
+        case UNUM_ROUND_HALF_ODD:
+            sb.append(u"rounding-mode-half-odd", -1);
+            break;
+        case UNUM_ROUND_HALF_CEILING:
+            sb.append(u"rounding-mode-half-ceiling", -1);
+            break;
+        case UNUM_ROUND_HALF_FLOOR:
+            sb.append(u"rounding-mode-half-floor", -1);
+            break;
         case UNUM_ROUND_HALFDOWN:
             sb.append(u"rounding-mode-half-down", -1);
             break;
@@ -372,6 +388,12 @@ void enum_to_stem_string::unitWidth(UNumberUnitWidth value, UnicodeString& sb) {
         case UNUM_UNIT_WIDTH_ISO_CODE:
             sb.append(u"unit-width-iso-code", -1);
             break;
+        case UNUM_UNIT_WIDTH_FORMAL:
+            sb.append(u"unit-width-formal", -1);
+            break;
+        case UNUM_UNIT_WIDTH_VARIANT:
+            sb.append(u"unit-width-variant", -1);
+            break;
         case UNUM_UNIT_WIDTH_HIDDEN:
             sb.append(u"unit-width-hidden", -1);
             break;
@@ -403,6 +425,12 @@ void enum_to_stem_string::signDisplay(UNumberSignDisplay value, UnicodeString& s
         case UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO:
             sb.append(u"sign-accounting-except-zero", -1);
             break;
+        case UNUM_SIGN_NEGATIVE:
+            sb.append(u"sign-negative", -1);
+            break;
+        case UNUM_SIGN_ACCOUNTING_NEGATIVE:
+            sb.append(u"sign-accounting-negative", -1);
+            break;
         default:
             UPRV_UNREACHABLE;
     }
@@ -470,6 +498,7 @@ UnicodeString skeleton::generate(const MacroProps& macros, UErrorCode& status) {
 MacroProps skeleton::parseSkeleton(
         const UnicodeString& skeletonString, int32_t& errOffset, UErrorCode& status) {
     U_ASSERT(U_SUCCESS(status));
+    U_ASSERT(kSerializedStemTrie != nullptr);
 
     // Add a trailing whitespace to the end of the skeleton string to make code cleaner.
     UnicodeString tempSkeletonString(skeletonString);
@@ -550,6 +579,7 @@ MacroProps skeleton::parseSkeleton(
                 case STATE_MEASURE_UNIT:
                 case STATE_PER_MEASURE_UNIT:
                 case STATE_IDENTIFIER_UNIT:
+                case STATE_UNIT_USAGE:
                 case STATE_CURRENCY_UNIT:
                 case STATE_INTEGER_WIDTH:
                 case STATE_NUMBERING_SYSTEM:
@@ -575,6 +605,8 @@ MacroProps skeleton::parseSkeleton(
 ParseState
 skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, SeenMacroProps& seen,
                     MacroProps& macros, UErrorCode& status) {
+    U_ASSERT(U_SUCCESS(status));
+
     // First check for "blueprint" stems, which start with a "signal char"
     switch (segment.charAt(0)) {
         case u'.':
@@ -584,7 +616,7 @@ skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, Se
         case u'@':
             CHECK_NULL(seen, precision, status);
             blueprint_helpers::parseDigitsStem(segment, macros, status);
-            return STATE_NULL;
+            return STATE_PRECISION;
         case u'E':
             CHECK_NULL(seen, notation, status);
             blueprint_helpers::parseScientificStem(segment, macros, status);
@@ -650,7 +682,7 @@ skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, Se
                 case STEM_PRECISION_INTEGER:
                     return STATE_FRACTION_PRECISION; // allows for "precision-integer/@##"
                 default:
-                    return STATE_NULL;
+                    return STATE_PRECISION;
             }
 
         case STEM_ROUNDING_MODE_CEILING:
@@ -658,6 +690,9 @@ skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, Se
         case STEM_ROUNDING_MODE_DOWN:
         case STEM_ROUNDING_MODE_UP:
         case STEM_ROUNDING_MODE_HALF_EVEN:
+        case STEM_ROUNDING_MODE_HALF_ODD:
+        case STEM_ROUNDING_MODE_HALF_CEILING:
+        case STEM_ROUNDING_MODE_HALF_FLOOR:
         case STEM_ROUNDING_MODE_HALF_DOWN:
         case STEM_ROUNDING_MODE_HALF_UP:
         case STEM_ROUNDING_MODE_UNNECESSARY:
@@ -683,6 +718,8 @@ skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, Se
         case STEM_UNIT_WIDTH_SHORT:
         case STEM_UNIT_WIDTH_FULL_NAME:
         case STEM_UNIT_WIDTH_ISO_CODE:
+        case STEM_UNIT_WIDTH_FORMAL:
+        case STEM_UNIT_WIDTH_VARIANT:
         case STEM_UNIT_WIDTH_HIDDEN:
             CHECK_NULL(seen, unitWidth, status);
             macros.unitWidth = stem_to_object::unitWidth(stem);
@@ -695,6 +732,8 @@ skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, Se
         case STEM_SIGN_ACCOUNTING_ALWAYS:
         case STEM_SIGN_EXCEPT_ZERO:
         case STEM_SIGN_ACCOUNTING_EXCEPT_ZERO:
+        case STEM_SIGN_NEGATIVE:
+        case STEM_SIGN_ACCOUNTING_NEGATIVE:
             CHECK_NULL(seen, sign, status);
             macros.sign = stem_to_object::signDisplay(stem);
             return STATE_NULL;
@@ -705,7 +744,7 @@ skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, Se
             macros.decimal = stem_to_object::decimalSeparatorDisplay(stem);
             return STATE_NULL;
 
-            // Stems requiring an option:
+        // Stems requiring an option:
 
         case STEM_PRECISION_INCREMENT:
             CHECK_NULL(seen, precision, status);
@@ -724,8 +763,13 @@ skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, Se
             CHECK_NULL(seen, perUnit, status);
             return STATE_IDENTIFIER_UNIT;
 
+        case STEM_UNIT_USAGE:
+            CHECK_NULL(seen, usage, status);
+            return STATE_UNIT_USAGE;
+
         case STEM_CURRENCY:
             CHECK_NULL(seen, unit, status);
+            CHECK_NULL(seen, perUnit, status);
             return STATE_CURRENCY_UNIT;
 
         case STEM_INTEGER_WIDTH:
@@ -747,6 +791,7 @@ skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, Se
 
 ParseState skeleton::parseOption(ParseState stem, const StringSegment& segment, MacroProps& macros,
                                  UErrorCode& status) {
+    U_ASSERT(U_SUCCESS(status));
 
     ///// Required options: /////
 
@@ -763,9 +808,12 @@ ParseState skeleton::parseOption(ParseState stem, const StringSegment& segment,
         case STATE_IDENTIFIER_UNIT:
             blueprint_helpers::parseIdentifierUnitOption(segment, macros, status);
             return STATE_NULL;
+        case STATE_UNIT_USAGE:
+            blueprint_helpers::parseUnitUsageOption(segment, macros, status);
+            return STATE_NULL;
         case STATE_INCREMENT_PRECISION:
             blueprint_helpers::parseIncrementOption(segment, macros, status);
-            return STATE_NULL;
+            return STATE_PRECISION;
         case STATE_INTEGER_WIDTH:
             blueprint_helpers::parseIntegerWidthOption(segment, macros, status);
             return STATE_NULL;
@@ -805,6 +853,22 @@ ParseState skeleton::parseOption(ParseState stem, const StringSegment& segment,
     switch (stem) {
         case STATE_FRACTION_PRECISION:
             if (blueprint_helpers::parseFracSigOption(segment, macros, status)) {
+                return STATE_PRECISION;
+            }
+            if (U_FAILURE(status)) {
+                return {};
+            }
+            // If the fracSig option was not found, try normal precision options.
+            stem = STATE_PRECISION;
+            break;
+        default:
+            break;
+    }
+
+    // Trailing zeros option
+    switch (stem) {
+        case STATE_PRECISION:
+            if (blueprint_helpers::parseTrailingZeroOption(segment, macros, status)) {
                 return STATE_NULL;
             }
             if (U_FAILURE(status)) {
@@ -833,7 +897,7 @@ void GeneratorHelpers::generateSkeleton(const MacroProps& macros, UnicodeString&
         sb.append(u' ');
     }
     if (U_FAILURE(status)) { return; }
-    if (GeneratorHelpers::perUnit(macros, sb, status)) {
+    if (GeneratorHelpers::usage(macros, sb, status)) {
         sb.append(u' ');
     }
     if (U_FAILURE(status)) { return; }
@@ -879,6 +943,10 @@ void GeneratorHelpers::generateSkeleton(const MacroProps& macros, UnicodeString&
         status = U_UNSUPPORTED_ERROR;
         return;
     }
+    if (macros.unitDisplayCase.isSet()) {
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
     if (macros.affixProvider != nullptr) {
         status = U_UNSUPPORTED_ERROR;
         return;
@@ -968,6 +1036,7 @@ blueprint_helpers::generateCurrencyOption(const CurrencyUnit& currency, UnicodeS
 
 void blueprint_helpers::parseMeasureUnitOption(const StringSegment& segment, MacroProps& macros,
                                                UErrorCode& status) {
+    U_ASSERT(U_SUCCESS(status));
     const UnicodeString stemString = segment.toTempUnicodeString();
 
     // NOTE: The category (type) of the unit is guaranteed to be a valid subtag (alphanumeric)
@@ -983,14 +1052,13 @@ void blueprint_helpers::parseMeasureUnitOption(const StringSegment& segment, Mac
     }
 
     // Need to do char <-> UChar conversion...
-    U_ASSERT(U_SUCCESS(status));
     CharString type;
     SKELETON_UCHAR_TO_CHAR(type, stemString, 0, firstHyphen, status);
     CharString subType;
     SKELETON_UCHAR_TO_CHAR(subType, stemString, firstHyphen + 1, stemString.length(), status);
 
-    // Note: the largest type as of this writing (March 2018) is "volume", which has 24 units.
-    static constexpr int32_t CAPACITY = 30;
+    // Note: the largest type as of this writing (Aug 2020) is "volume", which has 33 units.
+    static constexpr int32_t CAPACITY = 40;
     MeasureUnit units[CAPACITY];
     UErrorCode localStatus = U_ZERO_ERROR;
     int32_t numUnits = MeasureUnit::getAvailable(type.data(), units, CAPACITY, localStatus);
@@ -1011,14 +1079,6 @@ void blueprint_helpers::parseMeasureUnitOption(const StringSegment& segment, Mac
     status = U_NUMBER_SKELETON_SYNTAX_ERROR;
 }
 
-void blueprint_helpers::generateMeasureUnitOption(const MeasureUnit& measureUnit, UnicodeString& sb,
-                                                  UErrorCode&) {
-    // Need to do char <-> UChar conversion...
-    sb.append(UnicodeString(measureUnit.getType(), -1, US_INV));
-    sb.append(u'-');
-    sb.append(UnicodeString(measureUnit.getSubtype(), -1, US_INV));
-}
-
 void blueprint_helpers::parseMeasurePerUnitOption(const StringSegment& segment, MacroProps& macros,
                                                   UErrorCode& status) {
     // A little bit of a hack: save the current unit (numerator), call the main measure unit
@@ -1038,23 +1098,23 @@ void blueprint_helpers::parseIdentifierUnitOption(const StringSegment& segment,
     SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status);
 
     ErrorCode internalStatus;
-    auto fullUnit = MeasureUnitImpl::forIdentifier(buffer.toStringPiece(), internalStatus);
+    macros.unit = MeasureUnit::forIdentifier(buffer.toStringPiece(), internalStatus);
     if (internalStatus.isFailure()) {
         // throw new SkeletonSyntaxException("Invalid core unit identifier", segment, e);
         status = U_NUMBER_SKELETON_SYNTAX_ERROR;
         return;
     }
+}
 
-    // TODO(ICU-20941): Clean this up.
-    for (int32_t i = 0; i < fullUnit.units.length(); i++) {
-        SingleUnitImpl* subUnit = fullUnit.units[i];
-        if (subUnit->dimensionality > 0) {
-            macros.unit = macros.unit.product(subUnit->build(status), status);
-        } else {
-            subUnit->dimensionality *= -1;
-            macros.perUnit = macros.perUnit.product(subUnit->build(status), status);
-        }
-    }
+void blueprint_helpers::parseUnitUsageOption(const StringSegment &segment, MacroProps &macros,
+                                             UErrorCode &status) {
+    // Need to do char <-> UChar conversion...
+    U_ASSERT(U_SUCCESS(status));
+    CharString buffer;
+    SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status);
+    macros.usage.set(buffer.toStringPiece());
+    // We do not do any validation of the usage string: it depends on the
+    // unitPreferenceData in the units resources.
 }
 
 void blueprint_helpers::parseFractionStem(const StringSegment& segment, MacroProps& macros,
@@ -1198,6 +1258,7 @@ void blueprint_helpers::parseScientificStem(const StringSegment& segment, MacroP
             } else if (segment.charAt(offset) == u'?') {
                 signDisplay = UNUM_SIGN_EXCEPT_ZERO;
             } else {
+                // NOTE: Other sign displays are not included because they aren't useful in this context
                 goto fail;
             }
             offset++;
@@ -1256,21 +1317,14 @@ bool blueprint_helpers::parseFracSigOption(const StringSegment& segment, MacroPr
             break;
         }
     }
-    // For the frac-sig option, there must be minSig or maxSig but not both.
-    // Valid: @+, @@+, @@@+
-    // Valid: @#, @##, @###
-    // Invalid: @, @@, @@@
-    // Invalid: @@#, @@##, @@@#
     if (offset < segment.length()) {
         if (isWildcardChar(segment.charAt(offset))) {
+            // @+, @@+, @@@+
             maxSig = -1;
             offset++;
-        } else if (minSig > 1) {
-            // @@#, @@##, @@@#
-            // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment);
-            status = U_NUMBER_SKELETON_SYNTAX_ERROR;
-            return false;
         } else {
+            // @#, @##, @###
+            // @@#, @@##, @@@#
             maxSig = minSig;
             for (; offset < segment.length(); offset++) {
                 if (segment.charAt(offset) == u'#') {
@@ -1282,54 +1336,59 @@ bool blueprint_helpers::parseFracSigOption(const StringSegment& segment, MacroPr
         }
     } else {
         // @, @@, @@@
-        // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment);
-        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
-        return false;
+        maxSig = minSig;
     }
+    UNumberRoundingPriority priority;
     if (offset < segment.length()) {
-        // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment);
+        if (maxSig == -1) {
+            // The wildcard character is not allowed with the priority annotation
+            status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+            return false;
+        }
+        if (segment.codePointAt(offset) == u'r') {
+            priority = UNUM_ROUNDING_PRIORITY_RELAXED;
+            offset++;
+        } else if (segment.codePointAt(offset) == u's') {
+            priority = UNUM_ROUNDING_PRIORITY_STRICT;
+            offset++;
+        } else {
+            U_ASSERT(offset < segment.length());
+        }
+        if (offset < segment.length()) {
+            // Invalid digits option for fraction rounder
+            status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+            return false;
+        }
+    } else if (maxSig == -1) {
+        // withMinDigits
+        maxSig = minSig;
+        minSig = 1;
+        priority = UNUM_ROUNDING_PRIORITY_RELAXED;
+    } else if (minSig == 1) {
+        // withMaxDigits
+        priority = UNUM_ROUNDING_PRIORITY_STRICT;
+    } else {
+        // Digits options with both min and max sig require the priority option
         status = U_NUMBER_SKELETON_SYNTAX_ERROR;
         return false;
     }
 
     auto& oldPrecision = static_cast<const FractionPrecision&>(macros.precision);
-    if (maxSig == -1) {
-        macros.precision = oldPrecision.withMinDigits(minSig);
-    } else {
-        macros.precision = oldPrecision.withMaxDigits(maxSig);
-    }
+    macros.precision = oldPrecision.withSignificantDigits(minSig, maxSig, priority);
     return true;
 }
 
-void blueprint_helpers::parseIncrementOption(const StringSegment& segment, MacroProps& macros,
-                                             UErrorCode& status) {
-    // Need to do char <-> UChar conversion...
-    U_ASSERT(U_SUCCESS(status));
-    CharString buffer;
-    SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status);
-
-    // Utilize DecimalQuantity/decNumber to parse this for us.
-    DecimalQuantity dq;
-    UErrorCode localStatus = U_ZERO_ERROR;
-    dq.setToDecNumber({buffer.data(), buffer.length()}, localStatus);
-    if (U_FAILURE(localStatus)) {
-        // throw new SkeletonSyntaxException("Invalid rounding increment", segment, e);
-        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
-        return;
+bool blueprint_helpers::parseTrailingZeroOption(const StringSegment& segment, MacroProps& macros, UErrorCode&) {
+    if (segment == u"w") {
+        macros.precision = macros.precision.trailingZeroDisplay(UNUM_TRAILING_ZERO_HIDE_IF_WHOLE);
+        return true;
     }
-    double increment = dq.toDouble();
+    return false;
+}
 
-    // We also need to figure out how many digits. Do a brute force string operation.
-    int decimalOffset = 0;
-    while (decimalOffset < segment.length() && segment.charAt(decimalOffset) != '.') {
-        decimalOffset++;
-    }
-    if (decimalOffset == segment.length()) {
-        macros.precision = Precision::increment(increment);
-    } else {
-        int32_t fractionLength = segment.length() - decimalOffset - 1;
-        macros.precision = Precision::increment(increment).withMinFraction(fractionLength);
-    }
+void blueprint_helpers::parseIncrementOption(const StringSegment &segment, MacroProps &macros,
+                                             UErrorCode &status) {
+    number::impl::parseIncrementOption(segment, macros.precision, status);
 }
 
 void blueprint_helpers::generateIncrementOption(double increment, int32_t trailingZeros, UnicodeString& sb,
@@ -1499,50 +1558,46 @@ bool GeneratorHelpers::notation(const MacroProps& macros, UnicodeString& sb, UEr
 }
 
 bool GeneratorHelpers::unit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
-    if (utils::unitIsCurrency(macros.unit)) {
+    MeasureUnit unit = macros.unit;
+    if (!utils::unitIsBaseUnit(macros.perUnit)) {
+        if (utils::unitIsCurrency(macros.unit) || utils::unitIsCurrency(macros.perUnit)) {
+            status = U_UNSUPPORTED_ERROR;
+            return false;
+        }
+        unit = unit.product(macros.perUnit.reciprocal(status), status);
+    }
+
+    if (utils::unitIsCurrency(unit)) {
         sb.append(u"currency/", -1);
-        CurrencyUnit currency(macros.unit, status);
+        CurrencyUnit currency(unit, status);
         if (U_FAILURE(status)) {
             return false;
         }
         blueprint_helpers::generateCurrencyOption(currency, sb, status);
         return true;
-    } else if (utils::unitIsNoUnit(macros.unit)) {
-        if (utils::unitIsPercent(macros.unit)) {
-            sb.append(u"percent", -1);
-            return true;
-        } else if (utils::unitIsPermille(macros.unit)) {
-            sb.append(u"permille", -1);
-            return true;
-        } else {
-            // Default value is not shown in normalized form
-            return false;
-        }
+    } else if (utils::unitIsBaseUnit(unit)) {
+        // Default value is not shown in normalized form
+        return false;
+    } else if (utils::unitIsPercent(unit)) {
+        sb.append(u"percent", -1);
+        return true;
+    } else if (utils::unitIsPermille(unit)) {
+        sb.append(u"permille", -1);
+        return true;
     } else {
-        sb.append(u"measure-unit/", -1);
-        blueprint_helpers::generateMeasureUnitOption(macros.unit, sb, status);
+        sb.append(u"unit/", -1);
+        sb.append(unit.getIdentifier());
         return true;
     }
 }
 
-bool GeneratorHelpers::perUnit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
-    // Per-units are currently expected to be only MeasureUnits.
-    if (utils::unitIsNoUnit(macros.perUnit)) {
-        if (utils::unitIsPercent(macros.perUnit) || utils::unitIsPermille(macros.perUnit)) {
-            status = U_UNSUPPORTED_ERROR;
-            return false;
-        } else {
-            // Default value: ok to ignore
-            return false;
-        }
-    } else if (utils::unitIsCurrency(macros.perUnit)) {
-        status = U_UNSUPPORTED_ERROR;
-        return false;
-    } else {
-        sb.append(u"per-measure-unit/", -1);
-        blueprint_helpers::generateMeasureUnitOption(macros.perUnit, sb, status);
+bool GeneratorHelpers::usage(const MacroProps& macros, UnicodeString& sb, UErrorCode& /* status */) {
+    if (macros.usage.isSet()) {
+        sb.append(u"usage/", -1);
+        sb.append(UnicodeString(macros.usage.fValue, -1, US_INV));
         return true;
     }
+    return false;
 }
 
 bool GeneratorHelpers::precision(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
@@ -1558,10 +1613,11 @@ bool GeneratorHelpers::precision(const MacroProps& macros, UnicodeString& sb, UE
         const Precision::FractionSignificantSettings& impl = macros.precision.fUnion.fracSig;
         blueprint_helpers::generateFractionStem(impl.fMinFrac, impl.fMaxFrac, sb, status);
         sb.append(u'/');
-        if (impl.fMinSig == -1) {
-            blueprint_helpers::generateDigitsStem(1, impl.fMaxSig, sb, status);
+        blueprint_helpers::generateDigitsStem(impl.fMinSig, impl.fMaxSig, sb, status);
+        if (impl.fPriority == UNUM_ROUNDING_PRIORITY_RELAXED) {
+            sb.append(u'r');
         } else {
-            blueprint_helpers::generateDigitsStem(impl.fMinSig, -1, sb, status);
+            sb.append(u's');
         }
     } else if (macros.precision.fType == Precision::RND_INCREMENT
             || macros.precision.fType == Precision::RND_INCREMENT_ONE
@@ -1585,6 +1641,10 @@ bool GeneratorHelpers::precision(const MacroProps& macros, UnicodeString& sb, UE
         return false;
     }
 
+    if (macros.precision.fTrailingZeroDisplay == UNUM_TRAILING_ZERO_HIDE_IF_WHOLE) {
+        sb.append(u"/w", -1);
+    }
+
     // NOTE: Always return true for rounding because the default value depends on other options.
     return true;
 }
diff --git a/deps/icu-small/source/i18n/number_skeletons.h b/deps/icu-small/source/i18n/number_skeletons.h
index d9b2c0ee0b19abc88cc8bab11fa190a778378878..af6365042830595e8c79bb4d50fbb730a8d6bde9 100644
--- a/deps/icu-small/source/i18n/number_skeletons.h
+++ b/deps/icu-small/source/i18n/number_skeletons.h
@@ -22,10 +22,12 @@ struct SeenMacroProps;
 // namespace for enums and entrypoint functions
 namespace skeleton {
 
-///////////////////////////////////////////////////////////////////////////////////////
-// NOTE: For an example of how to add a new stem to the number skeleton parser, see: //
-// http://bugs.icu-project.org/trac/changeset/41193                                  //
-///////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////
+// NOTE: For examples of how to add a new stem to the number skeleton parser, see:    //
+// https://github.com/unicode-org/icu/commit/a2a7982216b2348070dc71093775ac7195793d73 //
+// and                                                                                //
+// https://github.com/unicode-org/icu/commit/6fe86f3934a8a5701034f648a8f7c5087e84aa28 //
+////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * While parsing a skeleton, this enum records what type of option we expect to find next.
@@ -40,6 +42,7 @@ enum ParseState {
 
     STATE_SCIENTIFIC,
     STATE_FRACTION_PRECISION,
+    STATE_PRECISION,
 
     // Section 2: An option is required:
 
@@ -47,6 +50,7 @@ enum ParseState {
     STATE_MEASURE_UNIT,
     STATE_PER_MEASURE_UNIT,
     STATE_IDENTIFIER_UNIT,
+    STATE_UNIT_USAGE,
     STATE_CURRENCY_UNIT,
     STATE_INTEGER_WIDTH,
     STATE_NUMBERING_SYSTEM,
@@ -82,6 +86,9 @@ enum StemEnum {
     STEM_ROUNDING_MODE_DOWN,
     STEM_ROUNDING_MODE_UP,
     STEM_ROUNDING_MODE_HALF_EVEN,
+    STEM_ROUNDING_MODE_HALF_ODD,
+    STEM_ROUNDING_MODE_HALF_CEILING,
+    STEM_ROUNDING_MODE_HALF_FLOOR,
     STEM_ROUNDING_MODE_HALF_DOWN,
     STEM_ROUNDING_MODE_HALF_UP,
     STEM_ROUNDING_MODE_UNNECESSARY,
@@ -95,6 +102,8 @@ enum StemEnum {
     STEM_UNIT_WIDTH_SHORT,
     STEM_UNIT_WIDTH_FULL_NAME,
     STEM_UNIT_WIDTH_ISO_CODE,
+    STEM_UNIT_WIDTH_FORMAL,
+    STEM_UNIT_WIDTH_VARIANT,
     STEM_UNIT_WIDTH_HIDDEN,
     STEM_SIGN_AUTO,
     STEM_SIGN_ALWAYS,
@@ -103,6 +112,8 @@ enum StemEnum {
     STEM_SIGN_ACCOUNTING_ALWAYS,
     STEM_SIGN_EXCEPT_ZERO,
     STEM_SIGN_ACCOUNTING_EXCEPT_ZERO,
+    STEM_SIGN_NEGATIVE,
+    STEM_SIGN_ACCOUNTING_NEGATIVE,
     STEM_DECIMAL_AUTO,
     STEM_DECIMAL_ALWAYS,
 
@@ -112,6 +123,7 @@ enum StemEnum {
     STEM_MEASURE_UNIT,
     STEM_PER_MEASURE_UNIT,
     STEM_UNIT,
+    STEM_UNIT_USAGE,
     STEM_CURRENCY,
     STEM_INTEGER_WIDTH,
     STEM_NUMBERING_SYSTEM,
@@ -234,14 +246,20 @@ void parseCurrencyOption(const StringSegment& segment, MacroProps& macros, UErro
 
 void generateCurrencyOption(const CurrencyUnit& currency, UnicodeString& sb, UErrorCode& status);
 
+// "measure-unit/" is deprecated in favour of "unit/".
 void parseMeasureUnitOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
 
-void generateMeasureUnitOption(const MeasureUnit& measureUnit, UnicodeString& sb, UErrorCode& status);
-
+// "per-measure-unit/" is deprecated in favour of "unit/".
 void parseMeasurePerUnitOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
 
+/**
+ * Parses unit identifiers like "meter-per-second" and "foot-and-inch", as
+ * specified via a "unit/" concise skeleton.
+ */
 void parseIdentifierUnitOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
 
+void parseUnitUsageOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
 void parseFractionStem(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
 
 void generateFractionStem(int32_t minFrac, int32_t maxFrac, UnicodeString& sb, UErrorCode& status);
@@ -261,6 +279,9 @@ void parseIntegerStem(const StringSegment& segment, MacroProps& macros, UErrorCo
 /** @return Whether we successfully found and parsed a frac-sig option. */
 bool parseFracSigOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
 
+/** @return Whether we successfully found and parsed a trailing zero option. */
+bool parseTrailingZeroOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
 void parseIncrementOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
 
 void
@@ -302,7 +323,7 @@ class GeneratorHelpers {
 
     static bool unit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
 
-    static bool perUnit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+    static bool usage(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
 
     static bool precision(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
 
@@ -332,6 +353,7 @@ struct SeenMacroProps {
     bool notation = false;
     bool unit = false;
     bool perUnit = false;
+    bool usage = false;
     bool precision = false;
     bool roundingMode = false;
     bool grouper = false;
@@ -344,6 +366,24 @@ struct SeenMacroProps {
     bool scale = false;
 };
 
+namespace {
+
+#define SKELETON_UCHAR_TO_CHAR(dest, src, start, end, status) (void)(dest); \
+UPRV_BLOCK_MACRO_BEGIN { \
+    UErrorCode conversionStatus = U_ZERO_ERROR; \
+    (dest).appendInvariantChars({false, (src).getBuffer() + (start), (end) - (start)}, conversionStatus); \
+    if (conversionStatus == U_INVARIANT_CONVERSION_ERROR) { \
+        /* Don't propagate the invariant conversion error; it is a skeleton syntax error */ \
+        (status) = U_NUMBER_SKELETON_SYNTAX_ERROR; \
+        return; \
+    } else if (U_FAILURE(conversionStatus)) { \
+        (status) = conversionStatus; \
+        return; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+} // namespace
+
 } // namespace impl
 } // namespace number
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/number_symbolswrapper.cpp b/deps/icu-small/source/i18n/number_symbolswrapper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac3043d1ca11c2f332fca9d53013c99ddd71c873
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_symbolswrapper.cpp
@@ -0,0 +1,131 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "number_microprops.h"
+#include "unicode/numberformatter.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+SymbolsWrapper::SymbolsWrapper(const SymbolsWrapper &other) {
+    doCopyFrom(other);
+}
+
+SymbolsWrapper::SymbolsWrapper(SymbolsWrapper &&src) U_NOEXCEPT {
+    doMoveFrom(std::move(src));
+}
+
+SymbolsWrapper &SymbolsWrapper::operator=(const SymbolsWrapper &other) {
+    if (this == &other) {
+        return *this;
+    }
+    doCleanup();
+    doCopyFrom(other);
+    return *this;
+}
+
+SymbolsWrapper &SymbolsWrapper::operator=(SymbolsWrapper &&src) U_NOEXCEPT {
+    if (this == &src) {
+        return *this;
+    }
+    doCleanup();
+    doMoveFrom(std::move(src));
+    return *this;
+}
+
+SymbolsWrapper::~SymbolsWrapper() {
+    doCleanup();
+}
+
+void SymbolsWrapper::setTo(const DecimalFormatSymbols &dfs) {
+    doCleanup();
+    fType = SYMPTR_DFS;
+    fPtr.dfs = new DecimalFormatSymbols(dfs);
+}
+
+void SymbolsWrapper::setTo(const NumberingSystem *ns) {
+    doCleanup();
+    fType = SYMPTR_NS;
+    fPtr.ns = ns;
+}
+
+void SymbolsWrapper::doCopyFrom(const SymbolsWrapper &other) {
+    fType = other.fType;
+    switch (fType) {
+    case SYMPTR_NONE:
+        // No action necessary
+        break;
+    case SYMPTR_DFS:
+        // Memory allocation failures are exposed in copyErrorTo()
+        if (other.fPtr.dfs != nullptr) {
+            fPtr.dfs = new DecimalFormatSymbols(*other.fPtr.dfs);
+        } else {
+            fPtr.dfs = nullptr;
+        }
+        break;
+    case SYMPTR_NS:
+        // Memory allocation failures are exposed in copyErrorTo()
+        if (other.fPtr.ns != nullptr) {
+            fPtr.ns = new NumberingSystem(*other.fPtr.ns);
+        } else {
+            fPtr.ns = nullptr;
+        }
+        break;
+    }
+}
+
+void SymbolsWrapper::doMoveFrom(SymbolsWrapper &&src) {
+    fType = src.fType;
+    switch (fType) {
+    case SYMPTR_NONE:
+        // No action necessary
+        break;
+    case SYMPTR_DFS:
+        fPtr.dfs = src.fPtr.dfs;
+        src.fPtr.dfs = nullptr;
+        break;
+    case SYMPTR_NS:
+        fPtr.ns = src.fPtr.ns;
+        src.fPtr.ns = nullptr;
+        break;
+    }
+}
+
+void SymbolsWrapper::doCleanup() {
+    switch (fType) {
+    case SYMPTR_NONE:
+        // No action necessary
+        break;
+    case SYMPTR_DFS:
+        delete fPtr.dfs;
+        break;
+    case SYMPTR_NS:
+        delete fPtr.ns;
+        break;
+    }
+}
+
+bool SymbolsWrapper::isDecimalFormatSymbols() const {
+    return fType == SYMPTR_DFS;
+}
+
+bool SymbolsWrapper::isNumberingSystem() const {
+    return fType == SYMPTR_NS;
+}
+
+const DecimalFormatSymbols *SymbolsWrapper::getDecimalFormatSymbols() const {
+    U_ASSERT(fType == SYMPTR_DFS);
+    return fPtr.dfs;
+}
+
+const NumberingSystem *SymbolsWrapper::getNumberingSystem() const {
+    U_ASSERT(fType == SYMPTR_NS);
+    return fPtr.ns;
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_types.h b/deps/icu-small/source/i18n/number_types.h
index 5c2b8cf8b5d19c5deb9d61ab21175b6840216852..8078851ba3fdb35723547ef62e2380978d2545d7 100644
--- a/deps/icu-small/source/i18n/number_types.h
+++ b/deps/icu-small/source/i18n/number_types.h
@@ -246,31 +246,31 @@ class U_I18N_API ModifierStore {
  * itself. The {@link #processQuantity} method performs the final step in the number processing pipeline: it uses the
  * quantity to generate a finalized {@link MicroProps}, which can be used to render the number to output.
  *
- * <p>
  * In other words, this interface is used for the parts of number processing that are <em>quantity-dependent</em>.
  *
- * <p>
  * In order to allow for multiple different objects to all mutate the same MicroProps, a "chain" of MicroPropsGenerators
  * are linked together, and each one is responsible for manipulating a certain quantity-dependent part of the
  * MicroProps. At the tail of the linked list is a base instance of {@link MicroProps} with properties that are not
  * quantity-dependent. Each element in the linked list calls {@link #processQuantity} on its "parent", then does its
  * work, and then returns the result.
  *
+ * This chain of MicroPropsGenerators is typically constructed by NumberFormatterImpl::macrosToMicroGenerator() when
+ * constructing a NumberFormatter.
+ *
  * Exported as U_I18N_API because it is a base class for other exported types
  *
  */
 class U_I18N_API MicroPropsGenerator {
   public:
-    virtual ~MicroPropsGenerator();
+    virtual ~MicroPropsGenerator() = default;
 
     /**
-     * Considers the given {@link DecimalQuantity}, optionally mutates it, and returns a {@link MicroProps}.
+     * Considers the given {@link DecimalQuantity}, optionally mutates it, and
+     * populates a {@link MicroProps} instance.
      *
-     * @param quantity
-     *            The quantity for consideration and optional mutation.
-     * @param micros
-     *            The MicroProps instance to populate.
-     * @return A MicroProps instance resolved for the quantity.
+     * @param quantity The quantity for consideration and optional mutation.
+     * @param micros The MicroProps instance to populate. It will be modified as
+     *   needed for the given quantity.
      */
     virtual void processQuantity(DecimalQuantity& quantity, MicroProps& micros,
                                  UErrorCode& status) const = 0;
diff --git a/deps/icu-small/source/i18n/number_usageprefs.cpp b/deps/icu-small/source/i18n/number_usageprefs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed426da086e32727709b5e7222e992edc395ba65
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_usageprefs.cpp
@@ -0,0 +1,214 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "number_usageprefs.h"
+#include "cstring.h"
+#include "number_decimalquantity.h"
+#include "number_microprops.h"
+#include "number_roundingutils.h"
+#include "number_skeletons.h"
+#include "unicode/char16ptr.h"
+#include "unicode/currunit.h"
+#include "unicode/fmtable.h"
+#include "unicode/measure.h"
+#include "unicode/numberformatter.h"
+#include "unicode/platform.h"
+#include "unicode/unum.h"
+#include "unicode/urename.h"
+#include "units_data.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+using icu::StringSegment;
+using icu::units::ConversionRates;
+
+// Copy constructor
+StringProp::StringProp(const StringProp &other) : StringProp() {
+    this->operator=(other);
+}
+
+// Copy assignment operator
+StringProp &StringProp::operator=(const StringProp &other) {
+    if (this == &other) { return *this; }  // self-assignment: no-op
+    fLength = 0;
+    fError = other.fError;
+    if (fValue != nullptr) {
+        uprv_free(fValue);
+        fValue = nullptr;
+    }
+    if (other.fValue == nullptr) {
+        return *this;
+    }
+    if (U_FAILURE(other.fError)) {
+        // We don't bother trying to allocating memory if we're in any case busy
+        // copying an errored StringProp.
+        return *this;
+    }
+    fValue = (char *)uprv_malloc(other.fLength + 1);
+    if (fValue == nullptr) {
+        fError = U_MEMORY_ALLOCATION_ERROR;
+        return *this;
+    }
+    fLength = other.fLength;
+    uprv_strncpy(fValue, other.fValue, fLength + 1);
+    return *this;
+}
+
+// Move constructor
+StringProp::StringProp(StringProp &&src) U_NOEXCEPT : fValue(src.fValue),
+                                                      fLength(src.fLength),
+                                                      fError(src.fError) {
+    // Take ownership away from src if necessary
+    src.fValue = nullptr;
+}
+
+// Move assignment operator
+StringProp &StringProp::operator=(StringProp &&src) U_NOEXCEPT {
+    if (this == &src) {
+        return *this;
+    }
+    if (fValue != nullptr) {
+        uprv_free(fValue);
+    }
+    fValue = src.fValue;
+    fLength = src.fLength;
+    fError = src.fError;
+    // Take ownership away from src if necessary
+    src.fValue = nullptr;
+    return *this;
+}
+
+StringProp::~StringProp() {
+    if (fValue != nullptr) {
+        uprv_free(fValue);
+        fValue = nullptr;
+    }
+}
+
+void StringProp::set(StringPiece value) {
+    if (fValue != nullptr) {
+        uprv_free(fValue);
+        fValue = nullptr;
+    }
+    fLength = value.length();
+    fValue = (char *)uprv_malloc(fLength + 1);
+    if (fValue == nullptr) {
+        fLength = 0;
+        fError = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    uprv_strncpy(fValue, value.data(), fLength);
+    fValue[fLength] = 0;
+}
+
+// Populates micros.mixedMeasures and modifies quantity, based on the values in
+// measures.
+void mixedMeasuresToMicros(const MaybeStackVector<Measure> &measures, DecimalQuantity *quantity,
+                           MicroProps *micros, UErrorCode status) {
+    micros->mixedMeasuresCount = measures.length();
+
+    if (micros->mixedMeasures.getCapacity() < micros->mixedMeasuresCount) {
+        if (micros->mixedMeasures.resize(micros->mixedMeasuresCount) == nullptr) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+    }
+
+    for (int32_t i = 0; i < micros->mixedMeasuresCount; i++) {
+        switch (measures[i]->getNumber().getType()) {
+        case Formattable::kInt64:
+            micros->mixedMeasures[i] = measures[i]->getNumber().getInt64();
+            break;
+
+        case Formattable::kDouble:
+            U_ASSERT(micros->indexOfQuantity < 0);
+            quantity->setToDouble(measures[i]->getNumber().getDouble());
+            micros->indexOfQuantity = i;
+            break;
+
+        default:
+            U_ASSERT(0 == "Found a Measure Number which is neither a double nor an int");
+            UPRV_UNREACHABLE;
+            break;
+        }
+
+        if (U_FAILURE(status)) {
+            return;
+        }
+    }
+
+    if (micros->indexOfQuantity < 0) {
+        // There is no quantity.
+        status = U_INTERNAL_PROGRAM_ERROR;
+    }
+}
+
+UsagePrefsHandler::UsagePrefsHandler(const Locale &locale,
+                                     const MeasureUnit &inputUnit,
+                                     const StringPiece usage,
+                                     const MicroPropsGenerator *parent,
+                                     UErrorCode &status)
+    : fUnitsRouter(inputUnit, StringPiece(locale.getCountry()), usage, status),
+      fParent(parent) {
+}
+
+void UsagePrefsHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                                        UErrorCode &status) const {
+    fParent->processQuantity(quantity, micros, status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    quantity.roundToInfinity(); // Enables toDouble
+    const units::RouteResult routed = fUnitsRouter.route(quantity.toDouble(), &micros.rounder, status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+    const MaybeStackVector<Measure>& routedMeasures = routed.measures;
+    micros.outputUnit = routed.outputUnit.copy(status).build(status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    mixedMeasuresToMicros(routedMeasures, &quantity, &micros, status);
+}
+
+UnitConversionHandler::UnitConversionHandler(const MeasureUnit &targetUnit,
+                                             const MicroPropsGenerator *parent, UErrorCode &status)
+    : fOutputUnit(targetUnit), fParent(parent) {
+    MeasureUnitImpl tempInput, tempOutput;
+
+    ConversionRates conversionRates(status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    const MeasureUnitImpl &targetUnitImpl =
+        MeasureUnitImpl::forMeasureUnit(targetUnit, tempOutput, status);
+    fUnitConverter.adoptInsteadAndCheckErrorCode(
+        new ComplexUnitsConverter(targetUnitImpl, conversionRates, status), status);
+}
+
+void UnitConversionHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                                            UErrorCode &status) const {
+    fParent->processQuantity(quantity, micros, status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+    quantity.roundToInfinity(); // Enables toDouble
+    MaybeStackVector<Measure> measures =
+        fUnitConverter->convert(quantity.toDouble(), &micros.rounder, status);
+    micros.outputUnit = fOutputUnit;
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    mixedMeasuresToMicros(measures, &quantity, &micros, status);
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_usageprefs.h b/deps/icu-small/source/i18n/number_usageprefs.h
new file mode 100644
index 0000000000000000000000000000000000000000..70547225a00761b84027aa11b6e7fabdebb4a7ae
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_usageprefs.h
@@ -0,0 +1,126 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMBER_USAGEPREFS_H__
+#define __NUMBER_USAGEPREFS_H__
+
+#include "cmemory.h"
+#include "number_types.h"
+#include "unicode/listformatter.h"
+#include "unicode/localpointer.h"
+#include "unicode/locid.h"
+#include "unicode/measunit.h"
+#include "unicode/stringpiece.h"
+#include "unicode/uobject.h"
+#include "units_converter.h"
+#include "units_router.h"
+
+U_NAMESPACE_BEGIN
+
+using ::icu::units::ComplexUnitsConverter;
+using ::icu::units::UnitsRouter;
+
+namespace number {
+namespace impl {
+
+/**
+ * A MicroPropsGenerator which uses UnitsRouter to produce output converted to a
+ * MeasureUnit appropriate for a particular localized usage: see
+ * NumberFormatterSettings::usage().
+ */
+class U_I18N_API UsagePrefsHandler : public MicroPropsGenerator, public UMemory {
+  public:
+    UsagePrefsHandler(const Locale &locale, const MeasureUnit &inputUnit, const StringPiece usage,
+                      const MicroPropsGenerator *parent, UErrorCode &status);
+
+    /**
+     * Obtains the appropriate output value, MeasureUnit and
+     * rounding/precision behaviour from the UnitsRouter.
+     *
+     * The output unit is passed on to the LongNameHandler via
+     * micros.outputUnit.
+     */
+    void processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                         UErrorCode &status) const U_OVERRIDE;
+
+    /**
+     * Returns the list of possible output units, i.e. the full set of
+     * preferences, for the localized, usage-specific unit preferences.
+     *
+     * The returned pointer should be valid for the lifetime of the
+     * UsagePrefsHandler instance.
+     */
+    const MaybeStackVector<MeasureUnit> *getOutputUnits() const {
+        return fUnitsRouter.getOutputUnits();
+    }
+
+  private:
+    UnitsRouter fUnitsRouter;
+    const MicroPropsGenerator *fParent;
+};
+
+} // namespace impl
+} // namespace number
+
+// Export explicit template instantiations of LocalPointerBase and LocalPointer.
+// This is required when building DLLs for Windows. (See datefmt.h,
+// collationiterator.h, erarules.h and others for similar examples.)
+//
+// Note: These need to be outside of the number::impl namespace, or Clang will
+// generate a compile error.
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+#if defined(_MSC_VER)
+// Ignore warning 4661 as LocalPointerBase does not use operator== or operator!=
+#pragma warning(push)
+#pragma warning(disable: 4661)
+#endif
+template class U_I18N_API LocalPointerBase<ComplexUnitsConverter>;
+template class U_I18N_API LocalPointer<ComplexUnitsConverter>;
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+#endif
+
+namespace number {
+namespace impl {
+
+/**
+ * A MicroPropsGenerator which converts a measurement from one MeasureUnit to
+ * another. In particular, the output MeasureUnit may be a mixed unit. (The
+ * input unit may not be a mixed unit.)
+ */
+class U_I18N_API UnitConversionHandler : public MicroPropsGenerator, public UMemory {
+  public:
+    /**
+     * Constructor.
+     *
+     * @param targetUnit Specifies the output MeasureUnit. The input MeasureUnit
+     *     is derived from it: in case of a mixed unit, the biggest unit is
+     *     taken as the input unit. If not a mixed unit, the input unit will be
+     *     the same as the output unit and no unit conversion takes place.
+     * @param parent The parent MicroPropsGenerator.
+     * @param status Receives status.
+     */
+    UnitConversionHandler(const MeasureUnit &targetUnit, const MicroPropsGenerator *parent,
+                          UErrorCode &status);
+
+    /**
+     * Obtains the appropriate output values from the Unit Converter.
+     */
+    void processQuantity(DecimalQuantity &quantity, MicroProps &micros,
+                         UErrorCode &status) const U_OVERRIDE;
+  private:
+    MeasureUnit fOutputUnit;
+    LocalPointer<ComplexUnitsConverter> fUnitConverter;
+    const MicroPropsGenerator *fParent;
+};
+
+} // namespace impl
+} // namespace number
+U_NAMESPACE_END
+
+#endif // __NUMBER_USAGEPREFS_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_utils.cpp b/deps/icu-small/source/i18n/number_utils.cpp
index 91d7f335cd82d3daa91b4abddffdd115e486b7fc..bef7ea6c61f30b48d8544febc0ed1e78c7066696 100644
--- a/deps/icu-small/source/i18n/number_utils.cpp
+++ b/deps/icu-small/source/i18n/number_utils.cpp
@@ -258,7 +258,10 @@ void DecNum::toString(ByteSink& output, UErrorCode& status) const {
     }
     // "string must be at least dn->digits+14 characters long"
     int32_t minCapacity = fData.getAlias()->digits + 14;
-    MaybeStackArray<char, 30> buffer(minCapacity);
+    MaybeStackArray<char, 30> buffer(minCapacity, status);
+    if (U_FAILURE(status)) {
+        return;
+    }
     uprv_decNumberToString(fData, buffer.getAlias());
     output.Append(buffer.getAlias(), static_cast<int32_t>(uprv_strlen(buffer.getAlias())));
 }
diff --git a/deps/icu-small/source/i18n/number_utils.h b/deps/icu-small/source/i18n/number_utils.h
index 93195f080b2787bde8b8058f2e11f4a2adfe2ba1..bc369c940f7962d1bc427454191d124e9d5d448e 100644
--- a/deps/icu-small/source/i18n/number_utils.h
+++ b/deps/icu-small/source/i18n/number_utils.h
@@ -49,8 +49,8 @@ inline bool unitIsCurrency(const MeasureUnit& unit) {
     return uprv_strcmp("currency", unit.getType()) == 0;
 }
 
-inline bool unitIsNoUnit(const MeasureUnit& unit) {
-    return uprv_strcmp("none", unit.getType()) == 0;
+inline bool unitIsBaseUnit(const MeasureUnit& unit) {
+    return unit == MeasureUnit();
 }
 
 inline bool unitIsPercent(const MeasureUnit& unit) {
diff --git a/deps/icu-small/source/i18n/number_utypes.h b/deps/icu-small/source/i18n/number_utypes.h
index 7a1b7a4e80ac3150c9b5844ae6e8e0d273d6c724..50c861787f4ed9c2b6300fb2a87aacbea624c191 100644
--- a/deps/icu-small/source/i18n/number_utypes.h
+++ b/deps/icu-small/source/i18n/number_utypes.h
@@ -28,9 +28,6 @@ const DecimalQuantity* validateUFormattedNumberToDecimalQuantity(
  * This struct is held internally by the C++ version FormattedNumber since the member types are not
  * declared in the public header file.
  *
- * The DecimalQuantity is not currently being used by FormattedNumber, but at some point it could be used
- * to add a toDecNumber() or similar method.
- *
  * Exported as U_I18N_API for tests
  */
 class U_I18N_API UFormattedNumberData : public FormattedValueStringBuilderImpl {
@@ -38,7 +35,16 @@ public:
     UFormattedNumberData() : FormattedValueStringBuilderImpl(kUndefinedField) {}
     virtual ~UFormattedNumberData();
 
+    // The formatted quantity.
     DecimalQuantity quantity;
+
+    // The output unit for the formatted quantity.
+    // TODO(units,hugovdm): populate this correctly for the general case - it's
+    // currently only implemented for the .usage() use case.
+    MeasureUnit outputUnit;
+
+    // The gender of the formatted output.
+    const char *gender = "";
 };
 
 
diff --git a/deps/icu-small/source/i18n/numfmt.cpp b/deps/icu-small/source/i18n/numfmt.cpp
index bf78179bcddefef462dc389eb7a44bef5bba1d17..bffefa5e3998b8ba71644fdff214e39046e99bc5 100644
--- a/deps/icu-small/source/i18n/numfmt.cpp
+++ b/deps/icu-small/source/i18n/numfmt.cpp
@@ -13,7 +13,7 @@
 *   Date        Name        Description
 *   02/19/97    aliu        Converted from java.
 *   03/18/97    clhuang     Implemented with C++ APIs.
-*   04/17/97    aliu        Enlarged MAX_INTEGER_DIGITS to fully accomodate the
+*   04/17/97    aliu        Enlarged MAX_INTEGER_DIGITS to fully accommodate the
 *                           largest double, by default.
 *                           Changed DigitCount to int per code review.
 *    07/20/98    stephen        Changed operator== to check for grouping
diff --git a/deps/icu-small/source/i18n/numparse_affixes.cpp b/deps/icu-small/source/i18n/numparse_affixes.cpp
index 187830fb6fc0dff8669bb383a4a7cd7a78678736..cef1685d03cd852d823770f20eda137d8fc14b3c 100644
--- a/deps/icu-small/source/i18n/numparse_affixes.cpp
+++ b/deps/icu-small/source/i18n/numparse_affixes.cpp
@@ -127,8 +127,8 @@ void AffixPatternMatcherBuilder::addMatcher(NumberParseMatcher& matcher) {
     fMatchers[fMatchersLen++] = &matcher;
 }
 
-AffixPatternMatcher AffixPatternMatcherBuilder::build() {
-    return AffixPatternMatcher(fMatchers, fMatchersLen, fPattern);
+AffixPatternMatcher AffixPatternMatcherBuilder::build(UErrorCode& status) {
+    return AffixPatternMatcher(fMatchers, fMatchersLen, fPattern, status);
 }
 
 AffixTokenMatcherWarehouse::AffixTokenMatcherWarehouse(const AffixTokenMatcherSetupData* setupData)
@@ -209,12 +209,13 @@ AffixPatternMatcher AffixPatternMatcher::fromAffixPattern(const UnicodeString& a
 
     AffixPatternMatcherBuilder builder(affixPattern, tokenWarehouse, ignorables);
     AffixUtils::iterateWithConsumer(affixPattern, builder, status);
-    return builder.build();
+    return builder.build(status);
 }
 
 AffixPatternMatcher::AffixPatternMatcher(MatcherArray& matchers, int32_t matchersLen,
-                                         const UnicodeString& pattern)
-        : ArraySeriesMatcher(matchers, matchersLen), fPattern(pattern) {}
+                                         const UnicodeString& pattern, UErrorCode& status)
+    : ArraySeriesMatcher(matchers, matchersLen), fPattern(pattern, status) {
+}
 
 UnicodeString AffixPatternMatcher::getPattern() const {
     return fPattern.toAliasedUnicodeString();
diff --git a/deps/icu-small/source/i18n/numparse_affixes.h b/deps/icu-small/source/i18n/numparse_affixes.h
index 2ac69df109519edd3786580aafe57fbcfc31079b..511c73c745380d7e4e1f4cb7e56241e1cb1c0ab9 100644
--- a/deps/icu-small/source/i18n/numparse_affixes.h
+++ b/deps/icu-small/source/i18n/numparse_affixes.h
@@ -128,7 +128,7 @@ class AffixPatternMatcherBuilder : public TokenConsumer, public MutableMatcherCo
     void consumeToken(::icu::number::impl::AffixPatternType type, UChar32 cp, UErrorCode& status) override;
 
     /** NOTE: You can build only once! */
-    AffixPatternMatcher build();
+    AffixPatternMatcher build(UErrorCode& status);
 
   private:
     ArraySeriesMatcher::MatcherArray fMatchers;
@@ -160,7 +160,8 @@ class U_I18N_API AffixPatternMatcher : public ArraySeriesMatcher {
   private:
     CompactUnicodeString<4> fPattern;
 
-    AffixPatternMatcher(MatcherArray& matchers, int32_t matchersLen, const UnicodeString& pattern);
+    AffixPatternMatcher(MatcherArray& matchers, int32_t matchersLen, const UnicodeString& pattern,
+                        UErrorCode& status);
 
     friend class AffixPatternMatcherBuilder;
 };
diff --git a/deps/icu-small/source/i18n/numparse_types.h b/deps/icu-small/source/i18n/numparse_types.h
index b4007c2ff5b52ceb28d330e477f4a761c48f029d..623f0e80f1668a574f1657a7e09da55d511ec944 100644
--- a/deps/icu-small/source/i18n/numparse_types.h
+++ b/deps/icu-small/source/i18n/numparse_types.h
@@ -64,14 +64,15 @@ class CompactUnicodeString {
         fBuffer[0] = 0;
     }
 
-    CompactUnicodeString(const UnicodeString& text)
-            : fBuffer(text.length() + 1) {
+    CompactUnicodeString(const UnicodeString& text, UErrorCode& status)
+            : fBuffer(text.length() + 1, status) {
+        if (U_FAILURE(status)) { return; }
         uprv_memcpy(fBuffer.getAlias(), text.getBuffer(), sizeof(UChar) * text.length());
         fBuffer[text.length()] = 0;
     }
 
     inline UnicodeString toAliasedUnicodeString() const {
-        return UnicodeString(TRUE, fBuffer.getAlias(), -1);
+        return UnicodeString(true, fBuffer.getAlias(), -1);
     }
 
     bool operator==(const CompactUnicodeString& other) const {
diff --git a/deps/icu-small/source/i18n/numrange_capi.cpp b/deps/icu-small/source/i18n/numrange_capi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a440a53fe6b173e0456773b381b207956c219071
--- /dev/null
+++ b/deps/icu-small/source/i18n/numrange_capi.cpp
@@ -0,0 +1,193 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "fphdlimp.h"
+#include "number_utypes.h"
+#include "numparse_types.h"
+#include "formattedval_impl.h"
+#include "numrange_impl.h"
+#include "number_decnum.h"
+#include "unicode/numberrangeformatter.h"
+#include "unicode/unumberrangeformatter.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+
+U_NAMESPACE_BEGIN
+namespace number {
+namespace impl {
+
+/**
+ * Implementation class for UNumberRangeFormatter. Wraps a LocalizedRangeNumberFormatter.
+ */
+struct UNumberRangeFormatterData : public UMemory,
+        // Magic number as ASCII == "NRF" (NumberRangeFormatter)
+        public IcuCApiHelper<UNumberRangeFormatter, UNumberRangeFormatterData, 0x4E524600> {
+    LocalizedNumberRangeFormatter fFormatter;
+};
+
+struct UFormattedNumberRangeImpl;
+
+// Magic number as ASCII == "FDN" (FormatteDNumber)
+typedef IcuCApiHelper<UFormattedNumberRange, UFormattedNumberRangeImpl, 0x46444E00> UFormattedNumberRangeApiHelper;
+
+struct UFormattedNumberRangeImpl : public UFormattedValueImpl, public UFormattedNumberRangeApiHelper {
+    UFormattedNumberRangeImpl();
+    ~UFormattedNumberRangeImpl();
+
+    FormattedNumberRange fImpl;
+    UFormattedNumberRangeData fData;
+};
+
+UFormattedNumberRangeImpl::UFormattedNumberRangeImpl()
+        : fImpl(&fData) {
+    fFormattedValue = &fImpl;
+}
+
+UFormattedNumberRangeImpl::~UFormattedNumberRangeImpl() {
+    // Disown the data from fImpl so it doesn't get deleted twice
+    fImpl.fData = nullptr;
+}
+
+} // namespace impl
+} // namespace number
+U_NAMESPACE_END
+
+
+UPRV_FORMATTED_VALUE_CAPI_NO_IMPLTYPE_AUTO_IMPL(
+    UFormattedNumberRange,
+    UFormattedNumberRangeImpl,
+    UFormattedNumberRangeApiHelper,
+    unumrf)
+
+
+const UFormattedNumberRangeData* number::impl::validateUFormattedNumberRange(
+        const UFormattedNumberRange* uresult, UErrorCode& status) {
+    auto* result = UFormattedNumberRangeApiHelper::validate(uresult, status);
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+    return &result->fData;
+}
+
+
+U_CAPI UNumberRangeFormatter* U_EXPORT2
+unumrf_openForSkeletonWithCollapseAndIdentityFallback(
+        const UChar* skeleton,
+        int32_t skeletonLen,
+        UNumberRangeCollapse collapse,
+        UNumberRangeIdentityFallback identityFallback,
+        const char* locale,
+        UParseError* perror,
+        UErrorCode* ec) {
+    auto* impl = new UNumberRangeFormatterData();
+    if (impl == nullptr) {
+        *ec = U_MEMORY_ALLOCATION_ERROR;
+        return nullptr;
+    }
+    // Readonly-alias constructor (first argument is whether we are NUL-terminated)
+    UnicodeString skeletonString(skeletonLen == -1, skeleton, skeletonLen);
+    impl->fFormatter = NumberRangeFormatter::withLocale(locale)
+        .numberFormatterBoth(NumberFormatter::forSkeleton(skeletonString, *perror, *ec))
+        .collapse(collapse)
+        .identityFallback(identityFallback);
+    return impl->exportForC();
+}
+
+U_CAPI void U_EXPORT2
+unumrf_formatDoubleRange(
+        const UNumberRangeFormatter* uformatter,
+        double first,
+        double second,
+        UFormattedNumberRange* uresult,
+        UErrorCode* ec) {
+    const UNumberRangeFormatterData* formatter = UNumberRangeFormatterData::validate(uformatter, *ec);
+    auto* result = UFormattedNumberRangeApiHelper::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) { return; }
+
+    result->fData.getStringRef().clear();
+    result->fData.quantity1.setToDouble(first);
+    result->fData.quantity2.setToDouble(second);
+    formatter->fFormatter.formatImpl(result->fData, first == second, *ec);
+}
+
+U_CAPI void U_EXPORT2
+unumrf_formatDecimalRange(
+        const UNumberRangeFormatter* uformatter,
+        const char* first, int32_t firstLen,
+        const char* second, int32_t secondLen,
+        UFormattedNumberRange* uresult,
+        UErrorCode* ec) {
+    const UNumberRangeFormatterData* formatter = UNumberRangeFormatterData::validate(uformatter, *ec);
+    auto* result = UFormattedNumberRangeApiHelper::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) { return; }
+
+    result->fData.getStringRef().clear();
+    result->fData.quantity1.setToDecNumber({first, firstLen}, *ec);
+    result->fData.quantity2.setToDecNumber({second, secondLen}, *ec);
+    formatter->fFormatter.formatImpl(result->fData, first == second, *ec);
+}
+
+U_CAPI UNumberRangeIdentityResult U_EXPORT2
+unumrf_resultGetIdentityResult(
+        const UFormattedNumberRange* uresult,
+        UErrorCode* ec) {
+    auto* result = UFormattedNumberRangeApiHelper::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) {
+        return UNUM_IDENTITY_RESULT_COUNT;
+    }
+    return result->fData.identityResult;
+}
+
+U_CAPI int32_t U_EXPORT2
+unumrf_resultGetFirstDecimalNumber(
+        const UFormattedNumberRange* uresult,
+        char* dest,
+        int32_t destCapacity,
+        UErrorCode* ec) {
+    const auto* result = UFormattedNumberRangeApiHelper::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) {
+        return 0;
+    }
+    DecNum decnum;
+    return result->fData.quantity1.toDecNum(decnum, *ec)
+        .toCharString(*ec)
+        .extract(dest, destCapacity, *ec);
+}
+
+U_CAPI int32_t U_EXPORT2
+unumrf_resultGetSecondDecimalNumber(
+        const UFormattedNumberRange* uresult,
+        char* dest,
+        int32_t destCapacity,
+        UErrorCode* ec) {
+    const auto* result = UFormattedNumberRangeApiHelper::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) {
+        return 0;
+    }
+    DecNum decnum;
+    return result->fData.quantity2
+        .toDecNum(decnum, *ec)
+        .toCharString(*ec)
+        .extract(dest, destCapacity, *ec);
+}
+
+U_CAPI void U_EXPORT2
+unumrf_close(UNumberRangeFormatter* f) {
+    UErrorCode localStatus = U_ZERO_ERROR;
+    const UNumberRangeFormatterData* impl = UNumberRangeFormatterData::validate(f, localStatus);
+    delete impl;
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numrange_fluent.cpp b/deps/icu-small/source/i18n/numrange_fluent.cpp
index 33179026f8d2b53f3cbbb18eaf2fbf82bdc51167..f1060b3c21d45ea9239690daaf5a42ca5f11e86b 100644
--- a/deps/icu-small/source/i18n/numrange_fluent.cpp
+++ b/deps/icu-small/source/i18n/numrange_fluent.cpp
@@ -12,6 +12,7 @@
 #include "numrange_impl.h"
 #include "util.h"
 #include "number_utypes.h"
+#include "number_decnum.h"
 
 using namespace icu;
 using namespace icu::number;
@@ -244,6 +245,7 @@ LocalizedNumberRangeFormatter::LocalizedNumberRangeFormatter(NFS<LNF>&& src) U_N
 }
 
 LocalizedNumberRangeFormatter& LocalizedNumberRangeFormatter::operator=(const LNF& other) {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     NFS<LNF>::operator=(static_cast<const NFS<LNF>&>(other));
     // Do not steal; just clear
     delete fAtomicFormatter.exchange(nullptr);
@@ -375,28 +377,4 @@ LocalizedNumberRangeFormatter::getFormatter(UErrorCode& status) const {
 }
 
 
-UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedNumberRange)
-
-#define UPRV_NOARG
-
-UnicodeString FormattedNumberRange::getFirstDecimal(UErrorCode& status) const {
-    UPRV_FORMATTED_VALUE_METHOD_GUARD(ICU_Utility::makeBogusString())
-    return fData->quantity1.toScientificString();
-}
-
-UnicodeString FormattedNumberRange::getSecondDecimal(UErrorCode& status) const {
-    UPRV_FORMATTED_VALUE_METHOD_GUARD(ICU_Utility::makeBogusString())
-    return fData->quantity2.toScientificString();
-}
-
-UNumberRangeIdentityResult FormattedNumberRange::getIdentityResult(UErrorCode& status) const {
-    UPRV_FORMATTED_VALUE_METHOD_GUARD(UNUM_IDENTITY_RESULT_NOT_EQUAL)
-    return fData->identityResult;
-}
-
-
-UFormattedNumberRangeData::~UFormattedNumberRangeData() = default;
-
-
-
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numrange_impl.cpp b/deps/icu-small/source/i18n/numrange_impl.cpp
index 9fb3dee861f1f611546ea936deb89db0c4262afd..aa713f1398b5027bd24e4e20038f40c62a18590a 100644
--- a/deps/icu-small/source/i18n/numrange_impl.cpp
+++ b/deps/icu-small/source/i18n/numrange_impl.cpp
@@ -12,6 +12,7 @@
 #include "unicode/numberrangeformatter.h"
 #include "numrange_impl.h"
 #include "patternprops.h"
+#include "pluralranges.h"
 #include "uresimp.h"
 #include "util.h"
 
@@ -106,92 +107,9 @@ void getNumberRangeData(const char* localeName, const char* nsName, NumberRangeD
     sink.fillInDefaults(status);
 }
 
-class PluralRangesDataSink : public ResourceSink {
-  public:
-    PluralRangesDataSink(StandardPluralRanges& output) : fOutput(output) {}
-
-    void put(const char* /*key*/, ResourceValue& value, UBool /*noFallback*/, UErrorCode& status) U_OVERRIDE {
-        ResourceArray entriesArray = value.getArray(status);
-        if (U_FAILURE(status)) { return; }
-        fOutput.setCapacity(entriesArray.getSize());
-        for (int i = 0; entriesArray.getValue(i, value); i++) {
-            ResourceArray pluralFormsArray = value.getArray(status);
-            if (U_FAILURE(status)) { return; }
-            pluralFormsArray.getValue(0, value);
-            StandardPlural::Form first = StandardPlural::fromString(value.getUnicodeString(status), status);
-            if (U_FAILURE(status)) { return; }
-            pluralFormsArray.getValue(1, value);
-            StandardPlural::Form second = StandardPlural::fromString(value.getUnicodeString(status), status);
-            if (U_FAILURE(status)) { return; }
-            pluralFormsArray.getValue(2, value);
-            StandardPlural::Form result = StandardPlural::fromString(value.getUnicodeString(status), status);
-            if (U_FAILURE(status)) { return; }
-            fOutput.addPluralRange(first, second, result);
-        }
-    }
-
-  private:
-    StandardPluralRanges& fOutput;
-};
-
-void getPluralRangesData(const Locale& locale, StandardPluralRanges& output, UErrorCode& status) {
-    if (U_FAILURE(status)) { return; }
-    LocalUResourceBundlePointer rb(ures_openDirect(nullptr, "pluralRanges", &status));
-    if (U_FAILURE(status)) { return; }
-
-    CharString dataPath;
-    dataPath.append("locales/", -1, status);
-    dataPath.append(locale.getLanguage(), -1, status);
-    if (U_FAILURE(status)) { return; }
-    int32_t setLen;
-    // Not all languages are covered: fail gracefully
-    UErrorCode internalStatus = U_ZERO_ERROR;
-    const UChar* set = ures_getStringByKeyWithFallback(rb.getAlias(), dataPath.data(), &setLen, &internalStatus);
-    if (U_FAILURE(internalStatus)) { return; }
-
-    dataPath.clear();
-    dataPath.append("rules/", -1, status);
-    dataPath.appendInvariantChars(set, setLen, status);
-    if (U_FAILURE(status)) { return; }
-    PluralRangesDataSink sink(output);
-    ures_getAllItemsWithFallback(rb.getAlias(), dataPath.data(), sink, status);
-    if (U_FAILURE(status)) { return; }
-}
-
 } // namespace
 
 
-void StandardPluralRanges::initialize(const Locale& locale, UErrorCode& status) {
-    getPluralRangesData(locale, *this, status);
-}
-
-void StandardPluralRanges::addPluralRange(
-        StandardPlural::Form first,
-        StandardPlural::Form second,
-        StandardPlural::Form result) {
-    U_ASSERT(fTriplesLen < fTriples.getCapacity());
-    fTriples[fTriplesLen] = {first, second, result};
-    fTriplesLen++;
-}
-
-void StandardPluralRanges::setCapacity(int32_t length) {
-    if (length > fTriples.getCapacity()) {
-        fTriples.resize(length, 0);
-    }
-}
-
-StandardPlural::Form
-StandardPluralRanges::resolve(StandardPlural::Form first, StandardPlural::Form second) const {
-    for (int32_t i=0; i<fTriplesLen; i++) {
-        const auto& triple = fTriples[i];
-        if (triple.first == first && triple.second == second) {
-            return triple.result;
-        }
-    }
-    // Default fallback
-    return StandardPlural::OTHER;
-}
-
 
 NumberRangeFormatterImpl::NumberRangeFormatterImpl(const RangeMacroProps& macros, UErrorCode& status)
     : formatterImpl1(macros.formatter1.fMacros, status),
@@ -213,7 +131,7 @@ NumberRangeFormatterImpl::NumberRangeFormatterImpl(const RangeMacroProps& macros
     fApproximatelyModifier = {data.approximatelyPattern, kUndefinedField, false};
 
     // TODO: Get locale from PluralRules instead?
-    fPluralRanges.initialize(macros.locale, status);
+    fPluralRanges = StandardPluralRanges::forLocale(macros.locale, status);
     if (U_FAILURE(status)) { return; }
 }
 
@@ -387,7 +305,7 @@ void NumberRangeFormatterImpl::formatRange(UFormattedNumberRangeData& data,
             // INNER MODIFIER
             collapseInner = micros1.modInner->semanticallyEquivalent(*micros2.modInner);
 
-            // All done checking for collapsability.
+            // All done checking for collapsibility.
             break;
         }
 
@@ -410,6 +328,7 @@ void NumberRangeFormatterImpl::formatRange(UFormattedNumberRangeData& data,
     #define UPRV_INDEX_1 (lengthPrefix + length1)
     #define UPRV_INDEX_2 (lengthPrefix + length1 + lengthInfix)
     #define UPRV_INDEX_3 (lengthPrefix + length1 + lengthInfix + length2)
+    #define UPRV_INDEX_4 (lengthPrefix + length1 + lengthInfix + length2 + lengthSuffix)
 
     int32_t lengthRange = SimpleModifier::formatTwoArgPattern(
         fRangeFormatter,
@@ -449,31 +368,38 @@ void NumberRangeFormatterImpl::formatRange(UFormattedNumberRangeData& data,
     // TODO: Support padding?
 
     if (collapseInner) {
-        // Note: this is actually a mix of prefix and suffix, but adding to infix length works
         const Modifier& mod = resolveModifierPlurals(*micros1.modInner, *micros2.modInner);
-        lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
+        lengthSuffix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_4, status);
+        lengthPrefix += mod.getPrefixLength();
+        lengthSuffix -= mod.getPrefixLength();
     } else {
         length1 += micros1.modInner->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
-        length2 += micros2.modInner->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
+        length2 += micros2.modInner->apply(string, UPRV_INDEX_2, UPRV_INDEX_4, status);
     }
 
     if (collapseMiddle) {
-        // Note: this is actually a mix of prefix and suffix, but adding to infix length works
         const Modifier& mod = resolveModifierPlurals(*micros1.modMiddle, *micros2.modMiddle);
-        lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
+        lengthSuffix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_4, status);
+        lengthPrefix += mod.getPrefixLength();
+        lengthSuffix -= mod.getPrefixLength();
     } else {
         length1 += micros1.modMiddle->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
-        length2 += micros2.modMiddle->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
+        length2 += micros2.modMiddle->apply(string, UPRV_INDEX_2, UPRV_INDEX_4, status);
     }
 
     if (collapseOuter) {
-        // Note: this is actually a mix of prefix and suffix, but adding to infix length works
         const Modifier& mod = resolveModifierPlurals(*micros1.modOuter, *micros2.modOuter);
-        lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
+        lengthSuffix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_4, status);
+        lengthPrefix += mod.getPrefixLength();
+        lengthSuffix -= mod.getPrefixLength();
     } else {
         length1 += micros1.modOuter->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
-        length2 += micros2.modOuter->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
+        length2 += micros2.modOuter->apply(string, UPRV_INDEX_2, UPRV_INDEX_4, status);
     }
+
+    // Now that all pieces are added, save the span info.
+    data.appendSpanInfo(UFIELD_CATEGORY_NUMBER_RANGE_SPAN, 0, UPRV_INDEX_0, length1, status);
+    data.appendSpanInfo(UFIELD_CATEGORY_NUMBER_RANGE_SPAN, 1, UPRV_INDEX_2, length2, status);
 }
 
 
diff --git a/deps/icu-small/source/i18n/numrange_impl.h b/deps/icu-small/source/i18n/numrange_impl.h
index 8f4c8a40ba2fdc7e7ece251d2cb618d73f187ed5..b81a311a5f393d300729d6334d9b6973ffea05ad 100644
--- a/deps/icu-small/source/i18n/numrange_impl.h
+++ b/deps/icu-small/source/i18n/numrange_impl.h
@@ -15,6 +15,7 @@
 #include "number_formatimpl.h"
 #include "formatted_string_builder.h"
 #include "formattedval_impl.h"
+#include "pluralranges.h"
 
 U_NAMESPACE_BEGIN namespace number {
 namespace impl {
@@ -40,36 +41,6 @@ public:
 };
 
 
-class StandardPluralRanges : public UMemory {
-  public:
-    void initialize(const Locale& locale, UErrorCode& status);
-    StandardPlural::Form resolve(StandardPlural::Form first, StandardPlural::Form second) const;
-
-    /** Used for data loading. */
-    void addPluralRange(
-        StandardPlural::Form first,
-        StandardPlural::Form second,
-        StandardPlural::Form result);
-
-    /** Used for data loading. */
-    void setCapacity(int32_t length);
-
-  private:
-    struct StandardPluralRangeTriple {
-        StandardPlural::Form first;
-        StandardPlural::Form second;
-        StandardPlural::Form result;
-    };
-
-    // TODO: An array is simple here, but it results in linear lookup time.
-    // Certain locales have 20-30 entries in this list.
-    // Consider changing to a smarter data structure.
-    typedef MaybeStackArray<StandardPluralRangeTriple, 3> PluralRangeTriples;
-    PluralRangeTriples fTriples;
-    int32_t fTriplesLen = 0;
-};
-
-
 class NumberRangeFormatterImpl : public UMemory {
   public:
     NumberRangeFormatterImpl(const RangeMacroProps& macros, UErrorCode& status);
@@ -105,6 +76,11 @@ class NumberRangeFormatterImpl : public UMemory {
 };
 
 
+/** Helper function used in upluralrules.cpp */
+const UFormattedNumberRangeData* validateUFormattedNumberRange(
+    const UFormattedNumberRange* uresult, UErrorCode& status);
+
+
 } // namespace impl
 } // namespace number
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/olsontz.cpp b/deps/icu-small/source/i18n/olsontz.cpp
index dd01180f8cc078195fbdcf87e63ee047ee018030..67aa1f7af81d680bd1677c76574b8d9b315f7c3b 100644
--- a/deps/icu-small/source/i18n/olsontz.cpp
+++ b/deps/icu-small/source/i18n/olsontz.cpp
@@ -197,58 +197,60 @@ OlsonTimeZone::OlsonTimeZone(const UResourceBundle* top,
         }
 
         // Process final rule and data, if any
-        const UChar *ruleIdUStr = ures_getStringByKey(res, kFINALRULE, &len, &ec);
-        ures_getByKey(res, kFINALRAW, r.getAlias(), &ec);
-        int32_t ruleRaw = ures_getInt(r.getAlias(), &ec);
-        ures_getByKey(res, kFINALYEAR, r.getAlias(), &ec);
-        int32_t ruleYear = ures_getInt(r.getAlias(), &ec);
         if (U_SUCCESS(ec)) {
-            UnicodeString ruleID(TRUE, ruleIdUStr, len);
-            UResourceBundle *rule = TimeZone::loadRule(top, ruleID, NULL, ec);
-            const int32_t *ruleData = ures_getIntVector(rule, &len, &ec);
-            if (U_SUCCESS(ec) && len == 11) {
-                UnicodeString emptyStr;
-                finalZone = new SimpleTimeZone(
-                    ruleRaw * U_MILLIS_PER_SECOND,
-                    emptyStr,
-                    (int8_t)ruleData[0], (int8_t)ruleData[1], (int8_t)ruleData[2],
-                    ruleData[3] * U_MILLIS_PER_SECOND,
-                    (SimpleTimeZone::TimeMode) ruleData[4],
-                    (int8_t)ruleData[5], (int8_t)ruleData[6], (int8_t)ruleData[7],
-                    ruleData[8] * U_MILLIS_PER_SECOND,
-                    (SimpleTimeZone::TimeMode) ruleData[9],
-                    ruleData[10] * U_MILLIS_PER_SECOND, ec);
-                if (finalZone == NULL) {
-                    ec = U_MEMORY_ALLOCATION_ERROR;
-                } else {
-                    finalStartYear = ruleYear;
+            const UChar *ruleIdUStr = ures_getStringByKey(res, kFINALRULE, &len, &ec);
+            ures_getByKey(res, kFINALRAW, r.getAlias(), &ec);
+            int32_t ruleRaw = ures_getInt(r.getAlias(), &ec);
+            ures_getByKey(res, kFINALYEAR, r.getAlias(), &ec);
+            int32_t ruleYear = ures_getInt(r.getAlias(), &ec);
+            if (U_SUCCESS(ec)) {
+                UnicodeString ruleID(TRUE, ruleIdUStr, len);
+                UResourceBundle *rule = TimeZone::loadRule(top, ruleID, NULL, ec);
+                const int32_t *ruleData = ures_getIntVector(rule, &len, &ec);
+                if (U_SUCCESS(ec) && len == 11) {
+                    UnicodeString emptyStr;
+                    finalZone = new SimpleTimeZone(
+                        ruleRaw * U_MILLIS_PER_SECOND,
+                        emptyStr,
+                        (int8_t)ruleData[0], (int8_t)ruleData[1], (int8_t)ruleData[2],
+                        ruleData[3] * U_MILLIS_PER_SECOND,
+                        (SimpleTimeZone::TimeMode) ruleData[4],
+                        (int8_t)ruleData[5], (int8_t)ruleData[6], (int8_t)ruleData[7],
+                        ruleData[8] * U_MILLIS_PER_SECOND,
+                        (SimpleTimeZone::TimeMode) ruleData[9],
+                        ruleData[10] * U_MILLIS_PER_SECOND, ec);
+                    if (finalZone == NULL) {
+                        ec = U_MEMORY_ALLOCATION_ERROR;
+                    } else {
+                        finalStartYear = ruleYear;
 
-                    // Note: Setting finalStartYear to the finalZone is problematic.  When a date is around
-                    // year boundary, SimpleTimeZone may return false result when DST is observed at the
-                    // beginning of year.  We could apply safe margin (day or two), but when one of recurrent
-                    // rules falls around year boundary, it could return false result.  Without setting the
-                    // start year, finalZone works fine around the year boundary of the start year.
+                        // Note: Setting finalStartYear to the finalZone is problematic.  When a date is around
+                        // year boundary, SimpleTimeZone may return false result when DST is observed at the
+                        // beginning of year.  We could apply safe margin (day or two), but when one of recurrent
+                        // rules falls around year boundary, it could return false result.  Without setting the
+                        // start year, finalZone works fine around the year boundary of the start year.
 
-                    // finalZone->setStartYear(finalStartYear);
+                        // finalZone->setStartYear(finalStartYear);
 
 
-                    // Compute the millis for Jan 1, 0:00 GMT of the finalYear
+                        // Compute the millis for Jan 1, 0:00 GMT of the finalYear
 
-                    // Note: finalStartMillis is used for detecting either if
-                    // historic transition data or finalZone to be used.  In an
-                    // extreme edge case - for example, two transitions fall into
-                    // small windows of time around the year boundary, this may
-                    // result incorrect offset computation.  But I think it will
-                    // never happen practically.  Yoshito - Feb 20, 2010
-                    finalStartMillis = Grego::fieldsToDay(finalStartYear, 0, 1) * U_MILLIS_PER_DAY;
+                        // Note: finalStartMillis is used for detecting either if
+                        // historic transition data or finalZone to be used.  In an
+                        // extreme edge case - for example, two transitions fall into
+                        // small windows of time around the year boundary, this may
+                        // result incorrect offset computation.  But I think it will
+                        // never happen practically.  Yoshito - Feb 20, 2010
+                        finalStartMillis = Grego::fieldsToDay(finalStartYear, 0, 1) * U_MILLIS_PER_DAY;
+                    }
+                } else {
+                    ec = U_INVALID_FORMAT_ERROR;
                 }
-            } else {
-                ec = U_INVALID_FORMAT_ERROR;
+                ures_close(rule);
+            } else if (ec == U_MISSING_RESOURCE_ERROR) {
+                // No final zone
+                ec = U_ZERO_ERROR;
             }
-            ures_close(rule);
-        } else if (ec == U_MISSING_RESOURCE_ERROR) {
-            // No final zone
-            ec = U_ZERO_ERROR;
         }
 
         // initialize canonical ID
@@ -272,6 +274,7 @@ OlsonTimeZone::OlsonTimeZone(const OlsonTimeZone& other) :
  * Assignment operator
  */
 OlsonTimeZone& OlsonTimeZone::operator=(const OlsonTimeZone& other) {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     canonicalID = other.canonicalID;
 
     transitionTimesPre32 = other.transitionTimesPre32;
@@ -397,9 +400,9 @@ void OlsonTimeZone::getOffset(UDate date, UBool local, int32_t& rawoff,
     }
 }
 
-void
-OlsonTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
-                                  int32_t& rawoff, int32_t& dstoff, UErrorCode& ec) const {
+void OlsonTimeZone::getOffsetFromLocal(UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+                                       UTimeZoneLocalOption duplicatedTimeOpt,
+                                       int32_t& rawoff, int32_t& dstoff, UErrorCode& ec) const {
     if (U_FAILURE(ec)) {
         return;
     }
@@ -810,7 +813,7 @@ OlsonTimeZone::initTransitionRules(UErrorCode& status) {
         if (finalZone->useDaylightTime()) {
             /*
              * Note: When an OlsonTimeZone is constructed, we should set the final year
-             * as the start year of finalZone.  However, the bounday condition used for
+             * as the start year of finalZone.  However, the boundary condition used for
              * getting offset from finalZone has some problems.
              * For now, we do not set the valid start year when the construction time
              * and create a clone and set the start year when extracting rules.
diff --git a/deps/icu-small/source/i18n/olsontz.h b/deps/icu-small/source/i18n/olsontz.h
index 79601546984a23843dc575bb9ebc4229fe98aa31..6bedb8792b0cd4dde35a0d3a5be764b5f258f9a8 100644
--- a/deps/icu-small/source/i18n/olsontz.h
+++ b/deps/icu-small/source/i18n/olsontz.h
@@ -187,8 +187,10 @@ class U_I18N_API OlsonTimeZone: public BasicTimeZone {
     /**
      * BasicTimeZone API.
      */
-    virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
-        int32_t& rawoff, int32_t& dstoff, UErrorCode& ec) const;
+    virtual void getOffsetFromLocal(
+        UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+        UTimeZoneLocalOption duplicatedTimeOpt,
+        int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
 
     /**
      * TimeZone API.  This method has no effect since objects of this
@@ -208,7 +210,7 @@ class U_I18N_API OlsonTimeZone: public BasicTimeZone {
     /**
      * TimeZone API.  For a historical zone, whether DST is used or
      * not varies over time.  In order to approximate expected
-     * behavior, this method returns TRUE if DST is observed at any
+     * behavior, this method returns true if DST is observed at any
      * point in the current year.
      */
     virtual UBool useDaylightTime() const;
@@ -234,7 +236,7 @@ class U_I18N_API OlsonTimeZone: public BasicTimeZone {
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the first transition after the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      */
     virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
 
@@ -244,7 +246,7 @@ class U_I18N_API OlsonTimeZone: public BasicTimeZone {
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the most recent transition before the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      */
     virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
 
diff --git a/deps/icu-small/source/i18n/persncal.cpp b/deps/icu-small/source/i18n/persncal.cpp
index 4d366d41f0dffe3596edb6298e93339d8ae9cbf7..ba306653af28e0423656b746d6d9d5901f4f92e4 100644
--- a/deps/icu-small/source/i18n/persncal.cpp
+++ b/deps/icu-small/source/i18n/persncal.cpp
@@ -79,7 +79,7 @@ PersianCalendar* PersianCalendar::clone() const {
 }
 
 PersianCalendar::PersianCalendar(const Locale& aLocale, UErrorCode& success)
-  :   Calendar(TimeZone::createDefault(), aLocale, success)
+  :   Calendar(TimeZone::forLocaleOrDefault(aLocale), aLocale, success)
 {
     setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
 }
diff --git a/deps/icu-small/source/i18n/persncal.h b/deps/icu-small/source/i18n/persncal.h
index a9d940db78e6c7d939f087ba2d47fb1ed3d71a3e..f330ea8a0319b26dcefe018d09b488e6157a0826 100644
--- a/deps/icu-small/source/i18n/persncal.h
+++ b/deps/icu-small/source/i18n/persncal.h
@@ -295,7 +295,7 @@ class PersianCalendar : public Calendar {
   virtual UBool inDaylightTime(UErrorCode& status) const;
 
   /**
-   * Returns TRUE because the Persian Calendar does have a default century
+   * Returns true because the Persian Calendar does have a default century
    * @internal
    */
   virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/pluralranges.cpp b/deps/icu-small/source/i18n/pluralranges.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..da10e2117d04ad42a42772d0ff347d8d8b996a66
--- /dev/null
+++ b/deps/icu-small/source/i18n/pluralranges.cpp
@@ -0,0 +1,144 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "unicode/numberrangeformatter.h"
+#include "pluralranges.h"
+#include "uresimp.h"
+#include "charstr.h"
+#include "uassert.h"
+#include "util.h"
+#include "numrange_impl.h"
+
+U_NAMESPACE_BEGIN
+
+
+namespace {
+
+class PluralRangesDataSink : public ResourceSink {
+  public:
+    PluralRangesDataSink(StandardPluralRanges& output) : fOutput(output) {}
+
+    void put(const char* /*key*/, ResourceValue& value, UBool /*noFallback*/, UErrorCode& status) U_OVERRIDE {
+        ResourceArray entriesArray = value.getArray(status);
+        if (U_FAILURE(status)) { return; }
+        fOutput.setCapacity(entriesArray.getSize(), status);
+        if (U_FAILURE(status)) { return; }
+        for (int i = 0; entriesArray.getValue(i, value); i++) {
+            ResourceArray pluralFormsArray = value.getArray(status);
+            if (U_FAILURE(status)) { return; }
+            if (pluralFormsArray.getSize() != 3) {
+                status = U_RESOURCE_TYPE_MISMATCH;
+                return;
+            }
+            pluralFormsArray.getValue(0, value);
+            StandardPlural::Form first = StandardPlural::fromString(value.getUnicodeString(status), status);
+            if (U_FAILURE(status)) { return; }
+            pluralFormsArray.getValue(1, value);
+            StandardPlural::Form second = StandardPlural::fromString(value.getUnicodeString(status), status);
+            if (U_FAILURE(status)) { return; }
+            pluralFormsArray.getValue(2, value);
+            StandardPlural::Form result = StandardPlural::fromString(value.getUnicodeString(status), status);
+            if (U_FAILURE(status)) { return; }
+            fOutput.addPluralRange(first, second, result);
+        }
+    }
+
+  private:
+    StandardPluralRanges& fOutput;
+};
+
+void getPluralRangesData(const Locale& locale, StandardPluralRanges& output, UErrorCode& status) {
+    LocalUResourceBundlePointer rb(ures_openDirect(nullptr, "pluralRanges", &status));
+    if (U_FAILURE(status)) { return; }
+
+    CharString dataPath;
+    dataPath.append("locales/", -1, status);
+    dataPath.append(locale.getLanguage(), -1, status);
+    if (U_FAILURE(status)) { return; }
+    int32_t setLen;
+    // Not all languages are covered: fail gracefully
+    UErrorCode internalStatus = U_ZERO_ERROR;
+    const UChar* set = ures_getStringByKeyWithFallback(rb.getAlias(), dataPath.data(), &setLen, &internalStatus);
+    if (U_FAILURE(internalStatus)) { return; }
+
+    dataPath.clear();
+    dataPath.append("rules/", -1, status);
+    dataPath.appendInvariantChars(set, setLen, status);
+    if (U_FAILURE(status)) { return; }
+    PluralRangesDataSink sink(output);
+    ures_getAllItemsWithFallback(rb.getAlias(), dataPath.data(), sink, status);
+}
+
+} // namespace
+
+
+StandardPluralRanges
+StandardPluralRanges::forLocale(const Locale& locale, UErrorCode& status) {
+    StandardPluralRanges result;
+    getPluralRangesData(locale, result, status);
+    return result;
+}
+
+StandardPluralRanges
+StandardPluralRanges::copy(UErrorCode& status) const {
+    StandardPluralRanges result;
+    if (fTriplesLen > result.fTriples.getCapacity()) {
+        if (result.fTriples.resize(fTriplesLen) == nullptr) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return result;
+        }
+    }
+    uprv_memcpy(result.fTriples.getAlias(),
+        fTriples.getAlias(),
+        fTriplesLen * sizeof(fTriples[0]));
+    result.fTriplesLen = fTriplesLen;
+    return result;
+}
+
+LocalPointer<StandardPluralRanges>
+StandardPluralRanges::toPointer(UErrorCode& status) && noexcept {
+    return LocalPointer<StandardPluralRanges>(new StandardPluralRanges(std::move(*this)), status);
+}
+
+void StandardPluralRanges::addPluralRange(
+        StandardPlural::Form first,
+        StandardPlural::Form second,
+        StandardPlural::Form result) {
+    U_ASSERT(fTriplesLen < fTriples.getCapacity());
+    fTriples[fTriplesLen] = {first, second, result};
+    fTriplesLen++;
+}
+
+void StandardPluralRanges::setCapacity(int32_t length, UErrorCode& status) {
+    if (U_FAILURE(status)) { return; }
+    if (length > fTriples.getCapacity()) {
+        if (fTriples.resize(length, 0) == nullptr) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+        }
+    }
+}
+
+StandardPlural::Form
+StandardPluralRanges::resolve(StandardPlural::Form first, StandardPlural::Form second) const {
+    for (int32_t i=0; i<fTriplesLen; i++) {
+        const auto& triple = fTriples[i];
+        if (triple.first == first && triple.second == second) {
+            return triple.result;
+        }
+    }
+    // Default fallback
+    return StandardPlural::OTHER;
+}
+
+
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/pluralranges.h b/deps/icu-small/source/i18n/pluralranges.h
new file mode 100644
index 0000000000000000000000000000000000000000..eba59c70ed7f02f302a568fc4961628050a434c1
--- /dev/null
+++ b/deps/icu-small/source/i18n/pluralranges.h
@@ -0,0 +1,67 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#ifndef __PLURALRANGES_H__
+#define __PLURALRANGES_H__
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/uobject.h"
+#include "unicode/locid.h"
+#include "unicode/plurrule.h"
+#include "standardplural.h"
+#include "cmemory.h"
+
+U_NAMESPACE_BEGIN
+
+// Forward declarations
+namespace number {
+namespace impl {
+class UFormattedNumberRangeData;
+}
+}
+
+class StandardPluralRanges : public UMemory {
+  public:
+    /** Create a new StandardPluralRanges for the given locale */
+    static StandardPluralRanges forLocale(const Locale& locale, UErrorCode& status);
+
+    /** Explicit copy constructor */
+    StandardPluralRanges copy(UErrorCode& status) const;
+
+    /** Create an object (called on an rvalue) */
+    LocalPointer<StandardPluralRanges> toPointer(UErrorCode& status) && noexcept;
+
+    /** Select rule based on the first and second forms */
+    StandardPlural::Form resolve(StandardPlural::Form first, StandardPlural::Form second) const;
+
+    /** Used for data loading. */
+    void addPluralRange(
+        StandardPlural::Form first,
+        StandardPlural::Form second,
+        StandardPlural::Form result);
+
+    /** Used for data loading. */
+    void setCapacity(int32_t length, UErrorCode& status);
+
+  private:
+    struct StandardPluralRangeTriple {
+        StandardPlural::Form first;
+        StandardPlural::Form second;
+        StandardPlural::Form result;
+    };
+
+    // TODO: An array is simple here, but it results in linear lookup time.
+    // Certain locales have 20-30 entries in this list.
+    // Consider changing to a smarter data structure.
+    typedef MaybeStackArray<StandardPluralRangeTriple, 3> PluralRangeTriples;
+    PluralRangeTriples fTriples;
+    int32_t fTriplesLen = 0;
+};
+
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
+#endif //__PLURALRANGES_H__
diff --git a/deps/icu-small/source/i18n/plurfmt.cpp b/deps/icu-small/source/i18n/plurfmt.cpp
index b99437630e67b5d2dc6d99ae1a1a9c8cb40c7100..aac35c5b094ff9cecf0456538f559d263cfb171e 100644
--- a/deps/icu-small/source/i18n/plurfmt.cpp
+++ b/deps/icu-small/source/i18n/plurfmt.cpp
@@ -549,9 +549,15 @@ void PluralFormat::parseType(const UnicodeString& source, const NFRule *rbnfLeni
 
         UnicodeString currArg = pattern.tempSubString(partStart->getLimit(), partLimit->getIndex() - partStart->getLimit());
         if (rbnfLenientScanner != NULL) {
-            // If lenient parsing is turned ON, we've got some time consuming parsing ahead of us.
-            int32_t length = -1;
-            currMatchIndex = rbnfLenientScanner->findTextLenient(source, currArg, startingAt, &length);
+            // Check if non-lenient rule finds the text before call lenient parsing
+            int32_t tempIndex = source.indexOf(currArg, startingAt);
+            if (tempIndex >= 0) {
+                currMatchIndex = tempIndex;
+            } else {
+                // If lenient parsing is turned ON, we've got some time consuming parsing ahead of us.
+                int32_t length = -1;
+                currMatchIndex = rbnfLenientScanner->findTextLenient(source, currArg, startingAt, &length);
+            }
         }
         else {
             currMatchIndex = source.indexOf(currArg, startingAt);
diff --git a/deps/icu-small/source/i18n/plurrule.cpp b/deps/icu-small/source/i18n/plurrule.cpp
index 54e3b2cd86c960598a75388e35d4790bf40faab5..bc106acce23aef0fb5a350c105516d75ecab72e0 100644
--- a/deps/icu-small/source/i18n/plurrule.cpp
+++ b/deps/icu-small/source/i18n/plurrule.cpp
@@ -19,6 +19,7 @@
 #include "unicode/ures.h"
 #include "unicode/numfmt.h"
 #include "unicode/decimfmt.h"
+#include "unicode/numberrangeformatter.h"
 #include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
@@ -36,6 +37,8 @@
 #include "unifiedcache.h"
 #include "number_decimalquantity.h"
 #include "util.h"
+#include "pluralranges.h"
+#include "numrange_impl.h"
 
 #if !UCONFIG_NO_FORMATTING
 
@@ -56,6 +59,8 @@ static const UChar PK_VAR_N[]={LOW_N,0};
 static const UChar PK_VAR_I[]={LOW_I,0};
 static const UChar PK_VAR_F[]={LOW_F,0};
 static const UChar PK_VAR_T[]={LOW_T,0};
+static const UChar PK_VAR_E[]={LOW_E,0};
+static const UChar PK_VAR_C[]={LOW_C,0};
 static const UChar PK_VAR_V[]={LOW_V,0};
 static const UChar PK_WITHIN[]={LOW_W,LOW_I,LOW_T,LOW_H,LOW_I,LOW_N,0};
 static const UChar PK_DECIMAL[]={LOW_D,LOW_E,LOW_C,LOW_I,LOW_M,LOW_A,LOW_L,0};
@@ -67,6 +72,7 @@ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralKeywordEnumeration)
 PluralRules::PluralRules(UErrorCode& /*status*/)
 :   UObject(),
     mRules(nullptr),
+    mStandardPluralRanges(nullptr),
     mInternalStatus(U_ZERO_ERROR)
 {
 }
@@ -74,6 +80,7 @@ PluralRules::PluralRules(UErrorCode& /*status*/)
 PluralRules::PluralRules(const PluralRules& other)
 : UObject(other),
     mRules(nullptr),
+    mStandardPluralRanges(nullptr),
     mInternalStatus(U_ZERO_ERROR)
 {
     *this=other;
@@ -81,6 +88,7 @@ PluralRules::PluralRules(const PluralRules& other)
 
 PluralRules::~PluralRules() {
     delete mRules;
+    delete mStandardPluralRanges;
 }
 
 SharedPluralRules::~SharedPluralRules() {
@@ -89,14 +97,20 @@ SharedPluralRules::~SharedPluralRules() {
 
 PluralRules*
 PluralRules::clone() const {
-    PluralRules* newObj = new PluralRules(*this);
     // Since clone doesn't have a 'status' parameter, the best we can do is return nullptr if
     // the newly created object was not fully constructed properly (an error occurred).
-    if (newObj != nullptr && U_FAILURE(newObj->mInternalStatus)) {
-        delete newObj;
-        newObj = nullptr;
+    UErrorCode localStatus = U_ZERO_ERROR;
+    return clone(localStatus);
+}
+
+PluralRules*
+PluralRules::clone(UErrorCode& status) const {
+    LocalPointer<PluralRules> newObj(new PluralRules(*this), status);
+    if (U_SUCCESS(status) && U_FAILURE(newObj->mInternalStatus)) {
+        status = newObj->mInternalStatus;
+        newObj.adoptInstead(nullptr);
     }
-    return newObj;
+    return newObj.orphan();
 }
 
 PluralRules&
@@ -104,6 +118,8 @@ PluralRules::operator=(const PluralRules& other) {
     if (this != &other) {
         delete mRules;
         mRules = nullptr;
+        delete mStandardPluralRanges;
+        mStandardPluralRanges = nullptr;
         mInternalStatus = other.mInternalStatus;
         if (U_FAILURE(mInternalStatus)) {
             // bail out early if the object we were copying from was already 'invalid'.
@@ -119,6 +135,11 @@ PluralRules::operator=(const PluralRules& other) {
                 mInternalStatus = mRules->fInternalStatus;
             }
         }
+        if (other.mStandardPluralRanges != nullptr) {
+            mStandardPluralRanges = other.mStandardPluralRanges->copy(mInternalStatus)
+                .toPointer(mInternalStatus)
+                .orphan();
+        }
     }
     return *this;
 }
@@ -211,11 +232,8 @@ PluralRules::forLocale(const Locale& locale, UPluralType type, UErrorCode& statu
     if (U_FAILURE(status)) {
         return nullptr;
     }
-    PluralRules *result = (*shared)->clone();
+    PluralRules *result = (*shared)->clone(status);
     shared->removeRef();
-    if (result == nullptr) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-    }
     return result;
 }
 
@@ -252,6 +270,10 @@ PluralRules::internalForLocale(const Locale& locale, UPluralType type, UErrorCod
         //        Original impl used default rules.
         //        Ask the question to ICU Core.
 
+    newObj->mStandardPluralRanges = StandardPluralRanges::forLocale(locale, status)
+        .toPointer(status)
+        .orphan();
+
     return newObj.orphan();
 }
 
@@ -272,6 +294,10 @@ PluralRules::select(const number::FormattedNumber& number, UErrorCode& status) c
     if (U_FAILURE(status)) {
         return ICU_Utility::makeBogusString();
     }
+    if (U_FAILURE(mInternalStatus)) {
+        status = mInternalStatus;
+        return ICU_Utility::makeBogusString();
+    }
     return select(dq);
 }
 
@@ -285,6 +311,33 @@ PluralRules::select(const IFixedDecimal &number) const {
     }
 }
 
+UnicodeString
+PluralRules::select(const number::FormattedNumberRange& range, UErrorCode& status) const {
+    return select(range.getData(status), status);
+}
+
+UnicodeString
+PluralRules::select(const number::impl::UFormattedNumberRangeData* impl, UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return ICU_Utility::makeBogusString();
+    }
+    if (U_FAILURE(mInternalStatus)) {
+        status = mInternalStatus;
+        return ICU_Utility::makeBogusString();
+    }
+    if (mStandardPluralRanges == nullptr) {
+        // Happens if PluralRules was constructed via createRules()
+        status = U_UNSUPPORTED_ERROR;
+        return ICU_Utility::makeBogusString();
+    }
+    auto form1 = StandardPlural::fromString(select(impl->quantity1), status);
+    auto form2 = StandardPlural::fromString(select(impl->quantity2), status);
+    if (U_FAILURE(status)) {
+        return ICU_Utility::makeBogusString();
+    }
+    auto result = mStandardPluralRanges->resolve(form1, form2);
+    return UnicodeString(StandardPlural::getKeyword(result), -1, US_INV);
+}
 
 
 StringEnumeration*
@@ -326,9 +379,23 @@ static double scaleForInt(double d) {
     return scale;
 }
 
+/**
+ * Helper method for the overrides of getSamples() for double and FixedDecimal
+ * return value types.  Provide only one of an allocated array of doubles or
+ * FixedDecimals, and a nullptr for the other.
+ */
 static int32_t
-getSamplesFromString(const UnicodeString &samples, double *dest,
-                        int32_t destCapacity, UErrorCode& status) {
+getSamplesFromString(const UnicodeString &samples, double *destDbl,
+                        FixedDecimal* destFd, int32_t destCapacity,
+                        UErrorCode& status) {
+
+    if ((destDbl == nullptr && destFd == nullptr)
+            || (destDbl != nullptr && destFd != nullptr)) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return 0;
+    }
+
+    bool isDouble = destDbl != nullptr;
     int32_t sampleCount = 0;
     int32_t sampleStartIdx = 0;
     int32_t sampleEndIdx = 0;
@@ -346,12 +413,15 @@ getSamplesFromString(const UnicodeString &samples, double *dest,
         int32_t tildeIndex = sampleRange.indexOf(TILDE);
         if (tildeIndex < 0) {
             FixedDecimal fixed(sampleRange, status);
-            double sampleValue = fixed.source;
-            if (fixed.visibleDecimalDigitCount == 0 || sampleValue != floor(sampleValue)) {
-                dest[sampleCount++] = sampleValue;
+            if (isDouble) {
+                double sampleValue = fixed.source;
+                if (fixed.visibleDecimalDigitCount == 0 || sampleValue != floor(sampleValue)) {
+                    destDbl[sampleCount++] = sampleValue;
+                }
+            } else {
+                destFd[sampleCount++] = fixed;
             }
         } else {
-
             FixedDecimal fixedLo(sampleRange.tempSubStringBetween(0, tildeIndex), status);
             FixedDecimal fixedHi(sampleRange.tempSubStringBetween(tildeIndex+1), status);
             double rangeLo = fixedLo.source;
@@ -375,14 +445,21 @@ getSamplesFromString(const UnicodeString &samples, double *dest,
             rangeLo *= scale;
             rangeHi *= scale;
             for (double n=rangeLo; n<=rangeHi; n+=1) {
-                // Hack Alert: don't return any decimal samples with integer values that
-                //    originated from a format with trailing decimals.
-                //    This API is returning doubles, which can't distinguish having displayed
-                //    zeros to the right of the decimal.
-                //    This results in test failures with values mapping back to a different keyword.
                 double sampleValue = n/scale;
-                if (!(sampleValue == floor(sampleValue) && fixedLo.visibleDecimalDigitCount > 0)) {
-                    dest[sampleCount++] = sampleValue;
+                if (isDouble) {
+                    // Hack Alert: don't return any decimal samples with integer values that
+                    //    originated from a format with trailing decimals.
+                    //    This API is returning doubles, which can't distinguish having displayed
+                    //    zeros to the right of the decimal.
+                    //    This results in test failures with values mapping back to a different keyword.
+                    if (!(sampleValue == floor(sampleValue) && fixedLo.visibleDecimalDigitCount > 0)) {
+                        destDbl[sampleCount++] = sampleValue;
+                    }
+                } else {
+                    int32_t v = (int32_t) fixedLo.getPluralOperand(PluralOperand::PLURAL_OPERAND_V);
+                    int32_t e = (int32_t) fixedLo.getPluralOperand(PluralOperand::PLURAL_OPERAND_E);
+                    FixedDecimal newSample = FixedDecimal::createWithExponent(sampleValue, v, e);
+                    destFd[sampleCount++] = newSample;
                 }
                 if (sampleCount >= destCapacity) {
                     break;
@@ -394,24 +471,53 @@ getSamplesFromString(const UnicodeString &samples, double *dest,
     return sampleCount;
 }
 
-
 int32_t
 PluralRules::getSamples(const UnicodeString &keyword, double *dest,
                         int32_t destCapacity, UErrorCode& status) {
-    if (destCapacity == 0 || U_FAILURE(status)) {
+    if (U_FAILURE(status)) {
         return 0;
     }
     if (U_FAILURE(mInternalStatus)) {
         status = mInternalStatus;
         return 0;
     }
+    if (dest != nullptr ? destCapacity < 0 : destCapacity != 0) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return 0;
+    }
     RuleChain *rc = rulesForKeyword(keyword);
     if (rc == nullptr) {
         return 0;
     }
-    int32_t numSamples = getSamplesFromString(rc->fIntegerSamples, dest, destCapacity, status);
+    int32_t numSamples = getSamplesFromString(rc->fIntegerSamples, dest, nullptr, destCapacity, status);
     if (numSamples == 0) {
-        numSamples = getSamplesFromString(rc->fDecimalSamples, dest, destCapacity, status);
+        numSamples = getSamplesFromString(rc->fDecimalSamples, dest, nullptr, destCapacity, status);
+    }
+    return numSamples;
+}
+
+int32_t
+PluralRules::getSamples(const UnicodeString &keyword, FixedDecimal *dest,
+                        int32_t destCapacity, UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return 0;
+    }
+    if (U_FAILURE(mInternalStatus)) {
+        status = mInternalStatus;
+        return 0;
+    }
+    if (dest != nullptr ? destCapacity < 0 : destCapacity != 0) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return 0;
+    }
+    RuleChain *rc = rulesForKeyword(keyword);
+    if (rc == nullptr) {
+        return 0;
+    }
+
+    int32_t numSamples = getSamplesFromString(rc->fIntegerSamples, nullptr, dest, destCapacity, status);
+    if (numSamples == 0) {
+        numSamples = getSamplesFromString(rc->fDecimalSamples, nullptr, dest, destCapacity, status);
     }
     return numSamples;
 }
@@ -600,6 +706,8 @@ PluralRuleParser::parse(const UnicodeString& ruleData, PluralRules *prules, UErr
         case tVariableI:
         case tVariableF:
         case tVariableT:
+        case tVariableE:
+        case tVariableC:
         case tVariableV:
             U_ASSERT(curAndConstraint != nullptr);
             curAndConstraint->digitsType = type;
@@ -984,6 +1092,10 @@ static UnicodeString tokenString(tokenType tok) {
         s.append(LOW_V); break;
       case tVariableT:
         s.append(LOW_T); break;
+      case tVariableE:
+        s.append(LOW_E); break;
+    case tVariableC:
+        s.append(LOW_C); break;
       default:
         s.append(TILDE);
     }
@@ -1160,6 +1272,8 @@ PluralRuleParser::checkSyntax(UErrorCode &status)
     case tVariableI:
     case tVariableF:
     case tVariableT:
+    case tVariableE:
+    case tVariableC:
     case tVariableV:
         if (type != tIs && type != tMod && type != tIn &&
             type != tNot && type != tWithin && type != tEqual && type != tNotEqual) {
@@ -1176,6 +1290,8 @@ PluralRuleParser::checkSyntax(UErrorCode &status)
               type == tVariableI ||
               type == tVariableF ||
               type == tVariableT ||
+              type == tVariableE ||
+              type == tVariableC ||
               type == tVariableV ||
               type == tAt)) {
             status = U_UNEXPECTED_TOKEN;
@@ -1207,6 +1323,8 @@ PluralRuleParser::checkSyntax(UErrorCode &status)
              type != tVariableI &&
              type != tVariableF &&
              type != tVariableT &&
+             type != tVariableE &&
+             type != tVariableC &&
              type != tVariableV) {
             status = U_UNEXPECTED_TOKEN;
         }
@@ -1384,6 +1502,10 @@ PluralRuleParser::getKeyType(const UnicodeString &token, tokenType keyType)
         keyType = tVariableF;
     } else if (0 == token.compare(PK_VAR_T, 1)) {
         keyType = tVariableT;
+    } else if (0 == token.compare(PK_VAR_E, 1)) {
+        keyType = tVariableE;
+    } else if (0 == token.compare(PK_VAR_C, 1)) {
+        keyType = tVariableC;
     } else if (0 == token.compare(PK_VAR_V, 1)) {
         keyType = tVariableV;
     } else if (0 == token.compare(PK_IS, 2)) {
@@ -1481,13 +1603,21 @@ PluralOperand tokenTypeToPluralOperand(tokenType tt) {
         return PLURAL_OPERAND_V;
     case tVariableT:
         return PLURAL_OPERAND_T;
+    case tVariableE:
+        return PLURAL_OPERAND_E;
+    case tVariableC:
+        return PLURAL_OPERAND_E;
     default:
         UPRV_UNREACHABLE;  // unexpected.
     }
 }
 
-FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f) {
-    init(n, v, f);
+FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f, int32_t e, int32_t c) {
+    init(n, v, f, e, c);
+}
+
+FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f, int32_t e) {
+    init(n, v, f, e);
     // check values. TODO make into unit test.
     //
     //            long visiblePower = (int) Math.pow(10, v);
@@ -1503,6 +1633,10 @@ FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f) {
     //            }
 }
 
+FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f) {
+    init(n, v, f);
+}
+
 FixedDecimal::FixedDecimal(double n, int32_t v) {
     // Ugly, but for samples we don't care.
     init(n, v, getFractionalDigits(n, v));
@@ -1522,20 +1656,50 @@ FixedDecimal::FixedDecimal() {
 
 FixedDecimal::FixedDecimal(const UnicodeString &num, UErrorCode &status) {
     CharString cs;
-    cs.appendInvariantChars(num, status);
+    int32_t parsedExponent = 0;
+    int32_t parsedCompactExponent = 0;
+
+    int32_t exponentIdx = num.indexOf(u'e');
+    if (exponentIdx < 0) {
+        exponentIdx = num.indexOf(u'E');
+    }
+    int32_t compactExponentIdx = num.indexOf(u'c');
+    if (compactExponentIdx < 0) {
+        compactExponentIdx = num.indexOf(u'C');
+    }
+
+    if (exponentIdx >= 0) {
+        cs.appendInvariantChars(num.tempSubString(0, exponentIdx), status);
+        int32_t expSubstrStart = exponentIdx + 1;
+        parsedExponent = ICU_Utility::parseAsciiInteger(num, expSubstrStart);
+    }
+    else if (compactExponentIdx >= 0) {
+        cs.appendInvariantChars(num.tempSubString(0, compactExponentIdx), status);
+        int32_t expSubstrStart = compactExponentIdx + 1;
+        parsedCompactExponent = ICU_Utility::parseAsciiInteger(num, expSubstrStart);
+
+        parsedExponent = parsedCompactExponent;
+        exponentIdx = compactExponentIdx;
+    }
+    else {
+        cs.appendInvariantChars(num, status);
+    }
+
     DecimalQuantity dl;
     dl.setToDecNumber(cs.toStringPiece(), status);
     if (U_FAILURE(status)) {
         init(0, 0, 0);
         return;
     }
+
     int32_t decimalPoint = num.indexOf(DOT);
     double n = dl.toDouble();
     if (decimalPoint == -1) {
-        init(n, 0, 0);
+        init(n, 0, 0, parsedExponent);
     } else {
-        int32_t v = num.length() - decimalPoint - 1;
-        init(n, v, getFractionalDigits(n, v));
+        int32_t fractionNumLength = exponentIdx < 0 ? num.length() : cs.length();
+        int32_t v = fractionNumLength - decimalPoint - 1;
+        init(n, v, getFractionalDigits(n, v), parsedExponent);
     }
 }
 
@@ -1546,6 +1710,7 @@ FixedDecimal::FixedDecimal(const FixedDecimal &other) {
     decimalDigits = other.decimalDigits;
     decimalDigitsWithoutTrailingZeros = other.decimalDigitsWithoutTrailingZeros;
     intValue = other.intValue;
+    exponent = other.exponent;
     _hasIntegerValue = other._hasIntegerValue;
     isNegative = other.isNegative;
     _isNaN = other._isNaN;
@@ -1554,6 +1719,10 @@ FixedDecimal::FixedDecimal(const FixedDecimal &other) {
 
 FixedDecimal::~FixedDecimal() = default;
 
+FixedDecimal FixedDecimal::createWithExponent(double n, int32_t v, int32_t e) {
+    return FixedDecimal(n, v, getFractionalDigits(n, v), e);
+}
+
 
 void FixedDecimal::init(double n) {
     int32_t numFractionDigits = decimals(n);
@@ -1562,10 +1731,24 @@ void FixedDecimal::init(double n) {
 
 
 void FixedDecimal::init(double n, int32_t v, int64_t f) {
+    int32_t exponent = 0;
+    init(n, v, f, exponent);
+}
+
+void FixedDecimal::init(double n, int32_t v, int64_t f, int32_t e) {
+    // Currently, `c` is an alias for `e`
+    init(n, v, f, e, e);
+}
+
+void FixedDecimal::init(double n, int32_t v, int64_t f, int32_t e, int32_t c) {
     isNegative = n < 0.0;
     source = fabs(n);
     _isNaN = uprv_isNaN(source);
     _isInfinite = uprv_isInfinite(source);
+    exponent = e;
+    if (exponent == 0) {
+        exponent = c;
+    }
     if (_isNaN || _isInfinite) {
         v = 0;
         f = 0;
@@ -1661,7 +1844,9 @@ int64_t FixedDecimal::getFractionalDigits(double n, int32_t v) {
       case 3: return (int64_t)(fract*1000.0 + 0.5);
       default:
           double scaled = floor(fract * pow(10.0, (double)v) + 0.5);
-          if (scaled > U_INT64_MAX) {
+          if (scaled >= static_cast<double>(U_INT64_MAX)) {
+              // Note: a double cannot accurately represent U_INT64_MAX. Casting it to double
+              //       will round up to the next representable value, which is U_INT64_MAX + 1.
               return U_INT64_MAX;
           } else {
               return (int64_t)scaled;
@@ -1693,7 +1878,8 @@ double FixedDecimal::getPluralOperand(PluralOperand operand) const {
         case PLURAL_OPERAND_F: return static_cast<double>(decimalDigits);
         case PLURAL_OPERAND_T: return static_cast<double>(decimalDigitsWithoutTrailingZeros);
         case PLURAL_OPERAND_V: return visibleDecimalDigitCount;
-        case PLURAL_OPERAND_E: return 0;
+        case PLURAL_OPERAND_E: return exponent;
+        case PLURAL_OPERAND_C: return exponent;
         default:
              UPRV_UNREACHABLE;  // unexpected.
     }
@@ -1719,6 +1905,23 @@ int32_t FixedDecimal::getVisibleFractionDigitCount() const {
     return visibleDecimalDigitCount;
 }
 
+bool FixedDecimal::operator==(const FixedDecimal &other) const {
+    return source == other.source && visibleDecimalDigitCount == other.visibleDecimalDigitCount
+        && decimalDigits == other.decimalDigits && exponent == other.exponent;
+}
+
+UnicodeString FixedDecimal::toString() const {
+    char pattern[15];
+    char buffer[20];
+    if (exponent != 0) {
+        snprintf(pattern, sizeof(pattern), "%%.%dfe%%d", visibleDecimalDigitCount);
+        snprintf(buffer, sizeof(buffer), pattern, source, exponent);
+    } else {
+        snprintf(pattern, sizeof(pattern), "%%.%df", visibleDecimalDigitCount);
+        snprintf(buffer, sizeof(buffer), pattern, source);
+    }
+    return UnicodeString(buffer, -1, US_INV);
+}
 
 
 PluralAvailableLocalesEnumeration::PluralAvailableLocalesEnumeration(UErrorCode &status) {
diff --git a/deps/icu-small/source/i18n/plurrule_impl.h b/deps/icu-small/source/i18n/plurrule_impl.h
index a18cb0847a840e46b4f81cf491f98b1faa64ad1d..69d44f83d4a0fadb4d87a9b085391db96d58c5b8 100644
--- a/deps/icu-small/source/i18n/plurrule_impl.h
+++ b/deps/icu-small/source/i18n/plurrule_impl.h
@@ -30,6 +30,12 @@
 #include "hash.h"
 #include "uassert.h"
 
+/**
+ * A FixedDecimal version of UPLRULES_NO_UNIQUE_VALUE used in PluralRulesTest
+ * for parsing of samples.
+ */
+#define UPLRULES_NO_UNIQUE_VALUE_DECIMAL (FixedDecimal((double)-0.00123456777))
+
 class PluralRulesTest;
 
 U_NAMESPACE_BEGIN
@@ -138,6 +144,8 @@ enum tokenType {
   tVariableF,
   tVariableV,
   tVariableT,
+  tVariableE,
+  tVariableC,
   tDecimal,
   tInteger,
   tEOF
@@ -215,11 +223,20 @@ enum PluralOperand {
     PLURAL_OPERAND_W,
 
     /**
-     * Suppressed exponent for compact notation (exponent needed in
-     * scientific notation with compact notation to approximate i).
+     * Suppressed exponent for scientific notation (exponent needed in
+     * scientific notation to approximate i).
      */
     PLURAL_OPERAND_E,
 
+    /**
+     * This operand is currently treated as an alias for `PLURAL_OPERAND_E`.
+     * In the future, it will represent:
+     *
+     * Suppressed exponent for compact notation (exponent needed in
+     * compact notation to approximate i).
+     */
+    PLURAL_OPERAND_C,
+
     /**
      * THIS OPERAND IS DEPRECATED AND HAS BEEN REMOVED FROM THE SPEC.
      *
@@ -273,7 +290,11 @@ class U_I18N_API FixedDecimal: public IFixedDecimal, public UObject {
       * @param n   the number, e.g. 12.345
       * @param v   The number of visible fraction digits, e.g. 3
       * @param f   The fraction digits, e.g. 345
+      * @param e   The exponent, e.g. 7 in 1.2e7, for scientific notation
+      * @param c   Currently: an alias for param `e`.
       */
+    FixedDecimal(double  n, int32_t v, int64_t f, int32_t e, int32_t c);
+    FixedDecimal(double  n, int32_t v, int64_t f, int32_t e);
     FixedDecimal(double  n, int32_t v, int64_t f);
     FixedDecimal(double n, int32_t);
     explicit FixedDecimal(double n);
@@ -282,6 +303,8 @@ class U_I18N_API FixedDecimal: public IFixedDecimal, public UObject {
     FixedDecimal(const UnicodeString &s, UErrorCode &ec);
     FixedDecimal(const FixedDecimal &other);
 
+    static FixedDecimal createWithExponent(double n, int32_t v, int32_t e);
+
     double getPluralOperand(PluralOperand operand) const U_OVERRIDE;
     bool isNaN() const U_OVERRIDE;
     bool isInfinite() const U_OVERRIDE;
@@ -291,19 +314,26 @@ class U_I18N_API FixedDecimal: public IFixedDecimal, public UObject {
 
     int32_t getVisibleFractionDigitCount() const;
 
+    void init(double n, int32_t v, int64_t f, int32_t e, int32_t c);
+    void init(double n, int32_t v, int64_t f, int32_t e);
     void init(double n, int32_t v, int64_t f);
     void init(double n);
     UBool quickInit(double n);  // Try a fast-path only initialization,
-                                //    return TRUE if successful.
+                                //    return true if successful.
     void adjustForMinFractionDigits(int32_t min);
     static int64_t getFractionalDigits(double n, int32_t v);
     static int32_t decimals(double n);
 
+    bool operator==(const FixedDecimal &other) const;
+
+    UnicodeString toString() const;
+
     double      source;
     int32_t     visibleDecimalDigitCount;
     int64_t     decimalDigits;
     int64_t     decimalDigitsWithoutTrailingZeros;
     int64_t     intValue;
+    int32_t     exponent;
     UBool       _hasIntegerValue;
     UBool       isNegative;
     UBool       _isNaN;
@@ -320,8 +350,8 @@ public:
     int32_t opNum = -1;             // for mod expressions, the right operand of the mod.
     int32_t value = -1;             // valid for 'is' rules only.
     UVector32 *rangeList = nullptr; // for 'in', 'within' rules. Null otherwise.
-    UBool negated = FALSE;          // TRUE for negated rules.
-    UBool integerOnly = FALSE;      // TRUE for 'within' rules.
+    UBool negated = false;          // true for negated rules.
+    UBool integerOnly = false;      // true for 'within' rules.
     tokenType digitsType = none;    // n | i | v | f constraint.
     AndConstraint *next = nullptr;
     // Internal error status, used for errors that occur during the copy constructor.
@@ -357,8 +387,8 @@ public:
     OrConstraint   *ruleHeader = nullptr;
     UnicodeString   fDecimalSamples;  // Samples strings from rule source
     UnicodeString   fIntegerSamples;  //   without @decimal or @integer, otherwise unprocessed.
-    UBool           fDecimalSamplesUnbounded = FALSE;
-    UBool           fIntegerSamplesUnbounded = FALSE;
+    UBool           fDecimalSamplesUnbounded = false;
+    UBool           fIntegerSamplesUnbounded = false;
     // Internal error status, used for errors that occur during the copy constructor.
     UErrorCode      fInternalStatus = U_ZERO_ERROR;
 
diff --git a/deps/icu-small/source/i18n/quant.h b/deps/icu-small/source/i18n/quant.h
index d5aa8e5eeeedee388a34035ed708ccae8b168590..df6924cc127ba62023b2e1b38fdab6f0225c641d 100644
--- a/deps/icu-small/source/i18n/quant.h
+++ b/deps/icu-small/source/i18n/quant.h
@@ -62,11 +62,11 @@ class Quantifier : public UnicodeFunctor, public UnicodeMatcher {
      * considered for matching will be text.charAt(limit-1) in the
      * forward direction or text.charAt(limit+1) in the backward
      * direction.
-     * @param incremental  if TRUE, then assume further characters may
+     * @param incremental  if true, then assume further characters may
      * be inserted at limit and check for partial matching.  Otherwise
      * assume the text as given is complete.
      * @return a match degree value indicating a full match, a partial
-     * match, or a mismatch.  If incremental is FALSE then
+     * match, or a mismatch.  If incremental is false then
      * U_PARTIAL_MATCH should never be returned.
      */
     virtual UMatchDegree matches(const Replaceable& text,
@@ -81,7 +81,7 @@ class Quantifier : public UnicodeFunctor, public UnicodeMatcher {
      * @return                  A reference to 'result'.
      */
     virtual UnicodeString& toPattern(UnicodeString& result,
-                                     UBool escapeUnprintable = FALSE) const;
+                                     UBool escapeUnprintable = false) const;
 
     /**
      * Implement UnicodeMatcher
diff --git a/deps/icu-small/source/i18n/quantityformatter.h b/deps/icu-small/source/i18n/quantityformatter.h
index 88c3f3844e924db064e343c0663a55333b66e754..30bef08634a3f4d0a11bb0257d2aab44ae4ca71c 100644
--- a/deps/icu-small/source/i18n/quantityformatter.h
+++ b/deps/icu-small/source/i18n/quantityformatter.h
@@ -74,18 +74,18 @@ public:
      * @param variant "zero", "one", "two", "few", "many", "other"
      * @param rawPattern the pattern for the variant e.g "{0} meters"
      * @param status any error returned here.
-     * @return TRUE on success; FALSE if status was set to a non zero error.
+     * @return true on success; false if status was set to a non zero error.
      */
     UBool addIfAbsent(const char *variant, const UnicodeString &rawPattern, UErrorCode &status);
 
     /**
-     * returns TRUE if this object has at least the "other" variant.
+     * returns true if this object has at least the "other" variant.
      */
     UBool isValid() const;
 
     /**
      * Gets the pattern formatter that would be used for a particular variant.
-     * If isValid() returns TRUE, this method is guaranteed to return a
+     * If isValid() returns true, this method is guaranteed to return a
      * non-NULL value.
      */
     const SimpleFormatter *getByVariant(const char *variant) const;
@@ -112,7 +112,7 @@ public:
 
     /**
      * Selects the standard plural form for the number/formatter/rules.
-     * TODO(13591): Remove this method.
+     * Used in MeasureFormat for backwards compatibility with NumberFormat.
      */
     static StandardPlural::Form selectPlural(
             const Formattable &number,
diff --git a/deps/icu-small/source/i18n/rbt.cpp b/deps/icu-small/source/i18n/rbt.cpp
index 02d0ce6ceb20f843aaca607dba7584286f0e6b3a..651994784490148cbc8576416281ec74abcf4c1a 100644
--- a/deps/icu-small/source/i18n/rbt.cpp
+++ b/deps/icu-small/source/i18n/rbt.cpp
@@ -101,7 +101,7 @@ RuleBasedTransliterator::RuleBasedTransliterator(
 }*/
 
 /**
- * Covenience constructor with no filter.
+ * Convenience constructor with no filter.
  */
 /*RuleBasedTransliterator::RuleBasedTransliterator(
                             const UnicodeString& id,
@@ -114,7 +114,7 @@ RuleBasedTransliterator::RuleBasedTransliterator(
 }*/
 
 /**
- * Covenience constructor with no filter and FORWARD direction.
+ * Convenience constructor with no filter and FORWARD direction.
  */
 /*RuleBasedTransliterator::RuleBasedTransliterator(
                             const UnicodeString& id,
@@ -126,7 +126,7 @@ RuleBasedTransliterator::RuleBasedTransliterator(
 }*/
 
 /**
- * Covenience constructor with FORWARD direction.
+ * Convenience constructor with FORWARD direction.
  */
 /*RuleBasedTransliterator::RuleBasedTransliterator(
                             const UnicodeString& id,
diff --git a/deps/icu-small/source/i18n/rbt.h b/deps/icu-small/source/i18n/rbt.h
index b450dc23f4975c86b402372eb5c9fd009d270825..4d9991c48f8b72842ee04b00de788d04b5b875dd 100644
--- a/deps/icu-small/source/i18n/rbt.h
+++ b/deps/icu-small/source/i18n/rbt.h
@@ -80,7 +80,7 @@ public:
                             UErrorCode& status);*/
 
     /**
-     * Covenience constructor with no filter.
+     * Convenience constructor with no filter.
      * @internal Use transliterator factory methods instead since this class will be removed in that release.
      */
     /*RuleBasedTransliterator(const UnicodeString& id,
@@ -89,7 +89,7 @@ public:
                             UErrorCode& status);*/
 
     /**
-     * Covenience constructor with no filter and FORWARD direction.
+     * Convenience constructor with no filter and FORWARD direction.
      * @internal Use transliterator factory methods instead since this class will be removed in that release.
      */
     /*RuleBasedTransliterator(const UnicodeString& id,
@@ -97,7 +97,7 @@ public:
                             UErrorCode& status);*/
 
     /**
-     * Covenience constructor with FORWARD direction.
+     * Convenience constructor with FORWARD direction.
      * @internal Use transliterator factory methods instead since this class will be removed in that release.
      */
     /*RuleBasedTransliterator(const UnicodeString& id,
@@ -108,7 +108,7 @@ private:
 
      friend class TransliteratorRegistry; // to access TransliterationRuleData convenience ctor
     /**
-     * Covenience constructor.
+     * Convenience constructor.
      * @param id            the id for the transliterator.
      * @param theData       the rule data for the transliterator.
      * @param adoptedFilter the filter for the transliterator
@@ -161,7 +161,7 @@ public:
      * to construct a new transliterator.
      * @param result the string to receive the rules.  Previous
      * contents will be deleted.
-     * @param escapeUnprintable if TRUE then convert unprintable
+     * @param escapeUnprintable if true then convert unprintable
      * character to their hex escape representations, \uxxxx or
      * \Uxxxxxxxx.  Unprintable characters are those other than
      * U+000A, U+0020..U+007E.
diff --git a/deps/icu-small/source/i18n/rbt_pars.cpp b/deps/icu-small/source/i18n/rbt_pars.cpp
index 3eb58a2a904a469bc932bded6a6d157bf811f3f1..69465aecb9b1423e40fec13ff7bb4e6d516d9283 100644
--- a/deps/icu-small/source/i18n/rbt_pars.cpp
+++ b/deps/icu-small/source/i18n/rbt_pars.cpp
@@ -945,7 +945,7 @@ void TransliteratorParser::parseRules(const UnicodeString& rule,
         if (c == RULE_COMMENT_CHAR) {
             pos = rule.indexOf((UChar)0x000A /*\n*/, pos) + 1;
             if (pos == 0) {
-                break; // No "\n" found; rest of rule is a commnet
+                break; // No "\n" found; rest of rule is a comment
             }
             continue; // Either fall out or restart with next line
         }
@@ -1159,7 +1159,7 @@ void TransliteratorParser::setVariableRange(int32_t start, int32_t end, UErrorCo
 
 /**
  * Assert that the given character is NOT within the variable range.
- * If it is, return FALSE.  This is neccesary to ensure that the
+ * If it is, return FALSE.  This is necessary to ensure that the
  * variable range does not overlap characters used in a rule.
  */
 UBool TransliteratorParser::checkVariableRange(UChar32 ch) const {
@@ -1557,7 +1557,7 @@ UChar TransliteratorParser::getSegmentStandin(int32_t seg, UErrorCode& status) {
             return 0;
         }
         c = variableNext++;
-        // Set a placeholder in the master variables vector that will be
+        // Set a placeholder in the primary variables vector that will be
         // filled in later by setSegmentObject().  We know that we will get
         // called first because setSegmentObject() will call us.
         variablesVector.addElement((void*) NULL, status);
diff --git a/deps/icu-small/source/i18n/rbt_pars.h b/deps/icu-small/source/i18n/rbt_pars.h
index d51f2e852bb5b44cfa3fd8e629ab9acca01b4935..9336d410d351e582bdbe92ac7bd423fd68cb0fa1 100644
--- a/deps/icu-small/source/i18n/rbt_pars.h
+++ b/deps/icu-small/source/i18n/rbt_pars.h
@@ -210,7 +210,7 @@ private:
 
     /**
      * Assert that the given character is NOT within the variable range.
-     * If it is, return FALSE.  This is neccesary to ensure that the
+     * If it is, return false.  This is necessary to ensure that the
      * variable range does not overlap characters used in a rule.
      * @param ch     the given character.
      * @return       True, if the given character is NOT within the variable range.
diff --git a/deps/icu-small/source/i18n/rbt_rule.h b/deps/icu-small/source/i18n/rbt_rule.h
index eb8556df0cda5dbcfb7be488b4e13853fe3699fd..76feeee3913e6ac327e8470bf2fa696b24a429cf 100644
--- a/deps/icu-small/source/i18n/rbt_rule.h
+++ b/deps/icu-small/source/i18n/rbt_rule.h
@@ -172,9 +172,9 @@ public:
      *                       segments, or null if there are none.  The array itself is adopted,
      *                       but the pointers within it are not.
      * @param segsCount      number of elements in segs[].
-     * @param anchorStart    TRUE if the the rule is anchored on the left to
+     * @param anchorStart    true if the the rule is anchored on the left to
      *                       the context start.
-     * @param anchorEnd      TRUE if the rule is anchored on the right to the
+     * @param anchorEnd      true if the rule is anchored on the right to the
      *                       context limit.
      * @param data           the rule data.
      * @param status         Output parameter filled in with success or failure status.
@@ -267,11 +267,11 @@ public:
      *
      * @param text the text
      * @param pos the position indices
-     * @param incremental if TRUE, test for partial matches that may
+     * @param incremental if true, test for partial matches that may
      * be completed by additional text inserted at pos.limit.
      * @return one of <code>U_MISMATCH</code>,
      * <code>U_PARTIAL_MATCH</code>, or <code>U_MATCH</code>.  If
-     * incremental is FALSE then U_PARTIAL_MATCH will not be returned.
+     * incremental is false then U_PARTIAL_MATCH will not be returned.
      */
     UMatchDegree matchAndReplace(Replaceable& text,
                                  UTransPosition& pos,
diff --git a/deps/icu-small/source/i18n/rbt_set.h b/deps/icu-small/source/i18n/rbt_set.h
index 9b2b8b38dba5cab97a52f29182df724504956c26..b1163a0193f862f53ba4e24d2c6fbc1cd4a6378c 100644
--- a/deps/icu-small/source/i18n/rbt_set.h
+++ b/deps/icu-small/source/i18n/rbt_set.h
@@ -123,14 +123,14 @@ public:
 
     /**
      * Transliterate the given text with the given UTransPosition
-     * indices.  Return TRUE if the transliteration should continue
-     * or FALSE if it should halt (because of a U_PARTIAL_MATCH match).
-     * Note that FALSE is only ever returned if isIncremental is TRUE.
+     * indices.  Return true if the transliteration should continue
+     * or false if it should halt (because of a U_PARTIAL_MATCH match).
+     * Note that false is only ever returned if isIncremental is true.
      * @param text the text to be transliterated
      * @param index the position indices, which will be updated
-     * @param isIncremental if TRUE, assume new text may be inserted
-     * at index.limit, and return FALSE if thre is a partial match.
-     * @return TRUE unless a U_PARTIAL_MATCH has been obtained,
+     * @param isIncremental if true, assume new text may be inserted
+     * at index.limit, and return false if thre is a partial match.
+     * @return true unless a U_PARTIAL_MATCH has been obtained,
      * indicating that transliteration should stop until more text
      * arrives.
      */
diff --git a/deps/icu-small/source/i18n/rbtz.cpp b/deps/icu-small/source/i18n/rbtz.cpp
index 2c3747abdafeaf07e0a4ce9f36de9b65334e9d86..9d8eea9263a280b81a008bfcf12cf43969d67f99 100644
--- a/deps/icu-small/source/i18n/rbtz.cpp
+++ b/deps/icu-small/source/i18n/rbtz.cpp
@@ -403,9 +403,9 @@ RuleBasedTimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset,
     getOffsetInternal(date, local, kFormer, kLatter, rawOffset, dstOffset, status);
 }
 
-void
-RuleBasedTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
-                                      int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const {
+void RuleBasedTimeZone::getOffsetFromLocal(UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+                                           UTimeZoneLocalOption duplicatedTimeOpt,
+                                           int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const {
     getOffsetInternal(date, TRUE, nonExistingTimeOpt, duplicatedTimeOpt, rawOffset, dstOffset, status);
 }
 
diff --git a/deps/icu-small/source/i18n/regexcmp.cpp b/deps/icu-small/source/i18n/regexcmp.cpp
index 7b67ce82b5db1223da9bab2ecd65e0a2ba1f4281..6c3a9e10ba12f264a0c8f68c5141de0ece400ed8 100644
--- a/deps/icu-small/source/i18n/regexcmp.cpp
+++ b/deps/icu-small/source/i18n/regexcmp.cpp
@@ -557,7 +557,7 @@ UBool RegexCompile::doParseActions(int32_t action)
         //
         //   Note:   Addition of transparent input regions, with the need to
         //           restore the original regions when failing out of a lookahead
-        //           block, complicated this sequence.  Some conbined opcodes
+        //           block, complicated this sequence.  Some combined opcodes
         //           might make sense - or might not, lookahead aren't that common.
         //
         //      Caution:  min match length optimization knows about this
@@ -2397,7 +2397,7 @@ void        RegexCompile::compileSet(UnicodeSet *theSet)
     }
     //  Remove any strings from the set.
     //  There shoudn't be any, but just in case.
-    //     (Case Closure can add them; if we had a simple case closure avaialble that
+    //     (Case Closure can add them; if we had a simple case closure available that
     //      ignored strings, that would be better.)
     theSet->removeAllStrings();
     int32_t  setSize = theSet->size();
@@ -2485,7 +2485,7 @@ void        RegexCompile::compileInterval(int32_t InitOp,  int32_t LoopOp)
     fRXPat->fCompiledPat->setElementAt(fIntervalLow, topOfBlock+2);
     fRXPat->fCompiledPat->setElementAt(fIntervalUpper, topOfBlock+3);
 
-    // Apend the CTR_LOOP op.  The operand is the location of the CTR_INIT op.
+    // Append the CTR_LOOP op.  The operand is the location of the CTR_INIT op.
     //   Goes at end of the block being looped over, so just append to the code so far.
     appendOp(LoopOp, topOfBlock);
 
@@ -3475,6 +3475,9 @@ int32_t   RegexCompile::minMatchLength(int32_t start, int32_t end) {
 //                     value may be longer than the actual maximum; it must
 //                     never be shorter.
 //
+//                     start, end: the range of the pattern to check.
+//                     end is inclusive.
+//
 //------------------------------------------------------------------------------
 int32_t   RegexCompile::maxMatchLength(int32_t start, int32_t end) {
     if (U_FAILURE(*fStatus)) {
@@ -3720,14 +3723,14 @@ int32_t   RegexCompile::maxMatchLength(int32_t start, int32_t end) {
                 // Look-behind.  Scan forward until the matching look-around end,
                 //   without processing the look-behind block.
                 int32_t dataLoc = URX_VAL(op);
-                for (loc = loc + 1; loc < end; ++loc) {
+                for (loc = loc + 1; loc <= end; ++loc) {
                     op = (int32_t)fRXPat->fCompiledPat->elementAti(loc);
                     int32_t opType = URX_TYPE(op);
                     if ((opType == URX_LA_END || opType == URX_LBN_END) && (URX_VAL(op) == dataLoc)) {
                         break;
                     }
                 }
-                U_ASSERT(loc < end);
+                U_ASSERT(loc <= end);
             }
             break;
 
diff --git a/deps/icu-small/source/i18n/regexcmp.h b/deps/icu-small/source/i18n/regexcmp.h
index 85b7586793b9ff2404c3da8cffb72583ace1370e..5804ff302674a1804a1667f1b9563ef4cc9169a6 100644
--- a/deps/icu-small/source/i18n/regexcmp.h
+++ b/deps/icu-small/source/i18n/regexcmp.h
@@ -104,7 +104,7 @@ private:
                                int32_t LoopOp);
     UBool       compileInlineInterval();             // Generate inline code for a {min,max} quantifier
     void        literalChar(UChar32 c);              // Compile a literal char
-    void        fixLiterals(UBool split=FALSE);      // Generate code for pending literal characters.
+    void        fixLiterals(UBool split=false);      // Generate code for pending literal characters.
     void        insertOp(int32_t where);             // Open up a slot for a new op in the
                                                      //   generated code at the specified location.
     void        appendOp(int32_t op);                // Append a new op to the compiled pattern.
diff --git a/deps/icu-small/source/i18n/regextxt.h b/deps/icu-small/source/i18n/regextxt.h
index 9cfabbe4153416d0e14cdd6ed6d27d60b86abfff..0f64b8437e7c3291aff198c8d5ed6c1d5ba65577 100644
--- a/deps/icu-small/source/i18n/regextxt.h
+++ b/deps/icu-small/source/i18n/regextxt.h
@@ -29,7 +29,7 @@ U_NAMESPACE_BEGIN
 #endif
 
 #ifdef REGEX_DISABLE_CHUNK_MODE
-#  define UTEXT_FULL_TEXT_IN_CHUNK(ut,len) (FALSE)
+#  define UTEXT_FULL_TEXT_IN_CHUNK(ut,len) (false)
 #else
 #  define UTEXT_FULL_TEXT_IN_CHUNK(ut,len) ((0==((ut)->chunkNativeStart))&&((len)==((ut)->chunkNativeLimit))&&((len)==((ut)->nativeIndexingLimit)))
 #endif
diff --git a/deps/icu-small/source/i18n/region.cpp b/deps/icu-small/source/i18n/region.cpp
index 198bea8f643a5bb68a3b8e920fab13e16a22f737..8364bd1c1b2280ce0680f69c7c83adb90d962d44 100644
--- a/deps/icu-small/source/i18n/region.cpp
+++ b/deps/icu-small/source/i18n/region.cpp
@@ -217,7 +217,7 @@ void U_CALLCONV Region::loadRegionData(UErrorCode &status) {
         if ( aliasToRegion != NULL && aliasFromRegion == NULL ) { // This is just an alias from some string to a region
             uhash_put(newRegionAliases.getAlias(),(void *)aliasFromStr.orphan(), (void *)aliasToRegion,&status);
         } else {
-            if ( aliasFromRegion == NULL ) { // Deprecated region code not in the master codes list - so need to create a deprecated region for it.
+            if ( aliasFromRegion == NULL ) { // Deprecated region code not in the primary codes list - so need to create a deprecated region for it.
                 LocalPointer<Region> newRgn(new Region, status);
                 if ( U_SUCCESS(status) ) {
                     aliasFromRegion = newRgn.orphan();
diff --git a/deps/icu-small/source/i18n/reldatefmt.cpp b/deps/icu-small/source/i18n/reldatefmt.cpp
index f10c5ba4884b841a874ba01fe63566853c57bef6..d41ff22b9c212a45fad1e15289684672d2fb9af6 100644
--- a/deps/icu-small/source/i18n/reldatefmt.cpp
+++ b/deps/icu-small/source/i18n/reldatefmt.cpp
@@ -95,7 +95,7 @@ public:
 
     const UnicodeString emptyString;
 
-    // Mappping from source to target styles for alias fallback.
+    // Mapping from source to target styles for alias fallback.
     int32_t fallBackCache[UDAT_STYLE_COUNT];
 
     void adoptCombinedDateAndTime(SimpleFormatter *fmtToAdopt) {
@@ -1326,7 +1326,7 @@ ureldatefmt_formatNumeric( const URelativeDateTimeFormatter* reldatefmt,
     return res.extract(result, resultCapacity, *status);
 }
 
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ureldatefmt_formatNumericToResult(
         const URelativeDateTimeFormatter* reldatefmt,
         double                            offset,
@@ -1369,7 +1369,7 @@ ureldatefmt_format( const URelativeDateTimeFormatter* reldatefmt,
     return res.extract(result, resultCapacity, *status);
 }
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 ureldatefmt_formatToResult(
         const URelativeDateTimeFormatter* reldatefmt,
         double                            offset,
diff --git a/deps/icu-small/source/i18n/reldtfmt.cpp b/deps/icu-small/source/i18n/reldtfmt.cpp
index c74c30c20ca38307237d3a03160bbcb1a2494a43..2bc59c5128b43a188234717fe327741e7a8a183a 100644
--- a/deps/icu-small/source/i18n/reldtfmt.cpp
+++ b/deps/icu-small/source/i18n/reldtfmt.cpp
@@ -334,7 +334,7 @@ UDate
 RelativeDateFormat::parse( const UnicodeString& text,
                          ParsePosition& pos) const {
     // redefined here because the other parse() function hides this function's
-    // cunterpart on DateFormat
+    // counterpart on DateFormat
     return DateFormat::parse(text, pos);
 }
 
diff --git a/deps/icu-small/source/i18n/rematch.cpp b/deps/icu-small/source/i18n/rematch.cpp
index 123aa8602ba474581fb6686783703cf4acc688d1..e358dbd1e983f885888fa6caba5d0db3097ddc12 100644
--- a/deps/icu-small/source/i18n/rematch.cpp
+++ b/deps/icu-small/source/i18n/rematch.cpp
@@ -2072,7 +2072,7 @@ int32_t  RegexMatcher::split(UText *input,
         UErrorCode      &status)
 {
     //
-    // Check arguements for validity
+    // Check arguments for validity
     //
     if (U_FAILURE(status)) {
         return 0;
@@ -3913,7 +3913,7 @@ void RegexMatcher::MatchAt(int64_t startIdx, UBool toEnd, UErrorCode &status) {
                     // First time through loop.
                     lbStartIdx = fp->fInputIdx - minML;
                     if (lbStartIdx > 0) {
-                        // move index to a code point boudary, if it's not on one already.
+                        // move index to a code point boundary, if it's not on one already.
                         UTEXT_SETNATIVEINDEX(fInputText, lbStartIdx);
                         lbStartIdx = UTEXT_GETNATIVEINDEX(fInputText);
                     }
@@ -3999,7 +3999,7 @@ void RegexMatcher::MatchAt(int64_t startIdx, UBool toEnd, UErrorCode &status) {
                     // First time through loop.
                     lbStartIdx = fp->fInputIdx - minML;
                     if (lbStartIdx > 0) {
-                        // move index to a code point boudary, if it's not on one already.
+                        // move index to a code point boundary, if it's not on one already.
                         UTEXT_SETNATIVEINDEX(fInputText, lbStartIdx);
                         lbStartIdx = UTEXT_GETNATIVEINDEX(fInputText);
                     }
diff --git a/deps/icu-small/source/i18n/rulebasedcollator.cpp b/deps/icu-small/source/i18n/rulebasedcollator.cpp
index 60acf17815a5ee4ba7214d8d02354472fb8966f7..917482d65bb4d651b0880f7b50f3a3d6d0fda184 100644
--- a/deps/icu-small/source/i18n/rulebasedcollator.cpp
+++ b/deps/icu-small/source/i18n/rulebasedcollator.cpp
@@ -1600,10 +1600,7 @@ RuleBasedCollator::internalGetShortDefinitionString(const char *locale,
     appendSubtag(result, 'Z', subtag, length, errorCode);
 
     if(U_FAILURE(errorCode)) { return 0; }
-    if(result.length() <= capacity) {
-        uprv_memcpy(buffer, result.data(), result.length());
-    }
-    return u_terminateChars(buffer, capacity, result.length(), &errorCode);
+    return result.extract(buffer, capacity, errorCode);
 }
 
 UBool
diff --git a/deps/icu-small/source/i18n/scriptset.h b/deps/icu-small/source/i18n/scriptset.h
index a41ab737a6dc3819b18d2ec5971caf0bc4a8541c..b770995832872d64c7d28a984f5cae199252f066 100644
--- a/deps/icu-small/source/i18n/scriptset.h
+++ b/deps/icu-small/source/i18n/scriptset.h
@@ -51,7 +51,7 @@ class U_I18N_API ScriptSet: public UMemory {
     ScriptSet &reset(UScriptCode script, UErrorCode &status);
     ScriptSet &intersect(const ScriptSet &other);
     ScriptSet &intersect(UScriptCode script, UErrorCode &status);
-    UBool      intersects(const ScriptSet &other) const;  // Sets contain at least one script in commmon.
+    UBool      intersects(const ScriptSet &other) const;  // Sets contain at least one script in common.
     UBool      contains(const ScriptSet &other) const;    // All set bits in other are also set in this.
 
     ScriptSet &setAll();
diff --git a/deps/icu-small/source/i18n/simpletz.cpp b/deps/icu-small/source/i18n/simpletz.cpp
index 12c220595cd2c1cf42ab934eed19d972191a43a4..0007d4aec8977e7e68bb26eeb80783d16d75f4cd 100644
--- a/deps/icu-small/source/i18n/simpletz.cpp
+++ b/deps/icu-small/source/i18n/simpletz.cpp
@@ -42,7 +42,7 @@ U_NAMESPACE_BEGIN
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleTimeZone)
 
 // Use only for decodeStartRule() and decodeEndRule() where the year is not
-// available. Set February to 29 days to accomodate rules with that date
+// available. Set February to 29 days to accommodate rules with that date
 // and day-of-week-on-or-before-that-date mode (DOW_LE_DOM_MODE).
 // The compareToRule() method adjusts to February 28 in non-leap years.
 //
@@ -509,8 +509,10 @@ SimpleTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
 }
 
 void
-SimpleTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
-                                   int32_t& rawOffsetGMT, int32_t& savingsDST, UErrorCode& status) const {
+SimpleTimeZone::getOffsetFromLocal(UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+                                   UTimeZoneLocalOption duplicatedTimeOpt, int32_t& rawOffsetGMT,
+                                   int32_t& savingsDST, UErrorCode& status) const
+{
     if (U_FAILURE(status)) {
         return;
     }
diff --git a/deps/icu-small/source/i18n/smpdtfmt.cpp b/deps/icu-small/source/i18n/smpdtfmt.cpp
index d704642b0536a4df54080a5a0a624febca459bfd..a3ec7cb026591c72f45a804a975496c4f2f2f046 100644
--- a/deps/icu-small/source/i18n/smpdtfmt.cpp
+++ b/deps/icu-small/source/i18n/smpdtfmt.cpp
@@ -54,6 +54,7 @@
 #include "unicode/udisplaycontext.h"
 #include "unicode/brkiter.h"
 #include "unicode/rbnf.h"
+#include "unicode/dtptngen.h"
 #include "uresimp.h"
 #include "olsontz.h"
 #include "patternprops.h"
@@ -230,6 +231,13 @@ static const int32_t gFieldRangeBias[] = {
 static const int32_t HEBREW_CAL_CUR_MILLENIUM_START_YEAR = 5000;
 static const int32_t HEBREW_CAL_CUR_MILLENIUM_END_YEAR = 6000;
 
+/**
+ * Maximum range for detecting daylight offset of a time zone when parsed time zone
+ * string indicates it's daylight saving time, but the detected time zone does not
+ * observe daylight saving time at the parsed date.
+ */
+static const double MAX_DAYLIGHT_DETECTION_RANGE = 30*365*24*60*60*1000.0;
+
 static UMutex LOCK;
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleDateFormat)
@@ -650,6 +658,12 @@ SimpleDateFormat::operator==(const Format& other) const
 }
 
 //----------------------------------------------------------------------
+static const UChar* timeSkeletons[4] = {
+    u"jmmsszzzz",   // kFull
+    u"jmmssz",      // kLong
+    u"jmmss",       // kMedium
+    u"jmm",         // kShort
+};
 
 void SimpleDateFormat::construct(EStyle timeStyle,
                                  EStyle dateStyle,
@@ -714,35 +728,75 @@ void SimpleDateFormat::construct(EStyle timeStyle,
     fDateOverride.setToBogus();
     fTimeOverride.setToBogus();
 
+    UnicodeString timePattern;
+    if (timeStyle >= kFull && timeStyle <= kShort) {
+        const char* baseLocID = locale.getBaseName();
+        if (baseLocID[0]!=0 && uprv_strcmp(baseLocID,"und")!=0) {
+            UErrorCode useStatus = U_ZERO_ERROR;
+            Locale baseLoc(baseLocID);
+            Locale validLoc(getLocale(ULOC_VALID_LOCALE, useStatus));
+            if (U_SUCCESS(useStatus) && validLoc!=baseLoc) {
+                bool useDTPG = false;
+                const char* baseReg = baseLoc.getCountry(); // empty string if no region
+                if ((baseReg[0]!=0 && uprv_strncmp(baseReg,validLoc.getCountry(),ULOC_COUNTRY_CAPACITY)!=0)
+                        || uprv_strncmp(baseLoc.getLanguage(),validLoc.getLanguage(),ULOC_LANG_CAPACITY)!=0) {
+                    // use DTPG if
+                    // * baseLoc has a region and validLoc does not have the same one (or has none), OR
+                    // * validLoc has a different language code than baseLoc
+                    useDTPG = true;
+                }
+                if (useDTPG) {
+                    // The standard time formats may have the wrong time cycle, because:
+                    // the valid locale differs in important ways (region, language) from
+                    // the base locale.
+                    // We could *also* check whether they do actually have a mismatch with
+                    // the time cycle preferences for the region, but that is a lot more
+                    // work for little or no additional benefit, since just going ahead
+                    // and always synthesizing the time format as per the following should
+                    // create a locale-appropriate pattern with cycle that matches the
+                    // region preferences anyway.
+                    LocalPointer<DateTimePatternGenerator> dtpg(DateTimePatternGenerator::createInstanceNoStdPat(locale, useStatus));
+                    if (U_SUCCESS(useStatus)) {
+                        UnicodeString timeSkeleton(TRUE, timeSkeletons[timeStyle], -1);
+                        timePattern = dtpg->getBestPattern(timeSkeleton, useStatus);
+                    }
+                }
+            }
+        }
+    }
+
     // if the pattern should include both date and time information, use the date/time
     // pattern string as a guide to tell use how to glue together the appropriate date
     // and time pattern strings.
     if ((timeStyle != kNone) && (dateStyle != kNone))
     {
-        currentBundle.adoptInstead(
-                ures_getByIndex(dateTimePatterns.getAlias(), (int32_t)timeStyle, NULL, &status));
-        if (U_FAILURE(status)) {
-           status = U_INVALID_FORMAT_ERROR;
-           return;
-        }
-        switch (ures_getType(currentBundle.getAlias())) {
-            case URES_STRING: {
-               resStr = ures_getString(currentBundle.getAlias(), &resStrLen, &status);
-               break;
-            }
-            case URES_ARRAY: {
-               resStr = ures_getStringByIndex(currentBundle.getAlias(), 0, &resStrLen, &status);
-               ovrStr = ures_getStringByIndex(currentBundle.getAlias(), 1, &ovrStrLen, &status);
-               fTimeOverride.setTo(TRUE, ovrStr, ovrStrLen);
-               break;
-            }
-            default: {
+        UnicodeString tempus1(timePattern);
+        if (tempus1.length() == 0) {
+            currentBundle.adoptInstead(
+                    ures_getByIndex(dateTimePatterns.getAlias(), (int32_t)timeStyle, NULL, &status));
+            if (U_FAILURE(status)) {
                status = U_INVALID_FORMAT_ERROR;
                return;
             }
-        }
+            switch (ures_getType(currentBundle.getAlias())) {
+                case URES_STRING: {
+                   resStr = ures_getString(currentBundle.getAlias(), &resStrLen, &status);
+                   break;
+                }
+                case URES_ARRAY: {
+                   resStr = ures_getStringByIndex(currentBundle.getAlias(), 0, &resStrLen, &status);
+                   ovrStr = ures_getStringByIndex(currentBundle.getAlias(), 1, &ovrStrLen, &status);
+                   fTimeOverride.setTo(TRUE, ovrStr, ovrStrLen);
+                   break;
+                }
+                default: {
+                   status = U_INVALID_FORMAT_ERROR;
+                   return;
+                }
+            }
 
-        UnicodeString tempus1(TRUE, resStr, resStrLen);
+            tempus1.setTo(TRUE, resStr, resStrLen);
+        }
 
         currentBundle.adoptInstead(
                 ures_getByIndex(dateTimePatterns.getAlias(), (int32_t)dateStyle, NULL, &status));
@@ -784,29 +838,32 @@ void SimpleDateFormat::construct(EStyle timeStyle,
     // pattern string from the resources
     // setTo() - see DateFormatSymbols::assignArray comments
     else if (timeStyle != kNone) {
-        currentBundle.adoptInstead(
-                ures_getByIndex(dateTimePatterns.getAlias(), (int32_t)timeStyle, NULL, &status));
-        if (U_FAILURE(status)) {
-           status = U_INVALID_FORMAT_ERROR;
-           return;
-        }
-        switch (ures_getType(currentBundle.getAlias())) {
-            case URES_STRING: {
-               resStr = ures_getString(currentBundle.getAlias(), &resStrLen, &status);
-               break;
-            }
-            case URES_ARRAY: {
-               resStr = ures_getStringByIndex(currentBundle.getAlias(), 0, &resStrLen, &status);
-               ovrStr = ures_getStringByIndex(currentBundle.getAlias(), 1, &ovrStrLen, &status);
-               fDateOverride.setTo(TRUE, ovrStr, ovrStrLen);
-               break;
-            }
-            default: {
+        fPattern.setTo(timePattern);
+        if (fPattern.length() == 0) {
+            currentBundle.adoptInstead(
+                    ures_getByIndex(dateTimePatterns.getAlias(), (int32_t)timeStyle, NULL, &status));
+            if (U_FAILURE(status)) {
                status = U_INVALID_FORMAT_ERROR;
                return;
             }
+            switch (ures_getType(currentBundle.getAlias())) {
+                case URES_STRING: {
+                   resStr = ures_getString(currentBundle.getAlias(), &resStrLen, &status);
+                   break;
+                }
+                case URES_ARRAY: {
+                   resStr = ures_getStringByIndex(currentBundle.getAlias(), 0, &resStrLen, &status);
+                   ovrStr = ures_getStringByIndex(currentBundle.getAlias(), 1, &ovrStrLen, &status);
+                   fDateOverride.setTo(TRUE, ovrStr, ovrStrLen);
+                   break;
+                }
+                default: {
+                   status = U_INVALID_FORMAT_ERROR;
+                   return;
+                }
+            }
+            fPattern.setTo(TRUE, resStr, resStrLen);
         }
-        fPattern.setTo(TRUE, resStr, resStrLen);
     }
     else if (dateStyle != kNone) {
         currentBundle.adoptInstead(
@@ -848,7 +905,8 @@ Calendar*
 SimpleDateFormat::initializeCalendar(TimeZone* adoptZone, const Locale& locale, UErrorCode& status)
 {
     if(!U_FAILURE(status)) {
-        fCalendar = Calendar::createInstance(adoptZone?adoptZone:TimeZone::createDefault(), locale, status);
+        fCalendar = Calendar::createInstance(
+            adoptZone ? adoptZone : TimeZone::forLocaleOrDefault(locale), locale, status);
     }
     return fCalendar;
 }
@@ -2524,51 +2582,47 @@ SimpleDateFormat::parse(const UnicodeString& text, Calendar& cal, ParsePosition&
             } else { // tztype == TZTYPE_DST
                 if (dst == 0) {
                     if (btz != NULL) {
-                        UDate time = localMillis + raw;
-                        // We use the nearest daylight saving time rule.
-                        TimeZoneTransition beforeTrs, afterTrs;
-                        UDate beforeT = time, afterT = time;
-                        int32_t beforeSav = 0, afterSav = 0;
-                        UBool beforeTrsAvail, afterTrsAvail;
-
-                        // Search for DST rule before or on the time
-                        while (TRUE) {
-                            beforeTrsAvail = btz->getPreviousTransition(beforeT, TRUE, beforeTrs);
-                            if (!beforeTrsAvail) {
+                        // This implementation resolves daylight saving time offset
+                        // closest rule after the given time.
+                        UDate baseTime = localMillis + raw;
+                        UDate time = baseTime;
+                        UDate limit = baseTime + MAX_DAYLIGHT_DETECTION_RANGE;
+                        TimeZoneTransition trs;
+                        UBool trsAvail;
+
+                        // Search for DST rule after the given time
+                        while (time < limit) {
+                            trsAvail = btz->getNextTransition(time, FALSE, trs);
+                            if (!trsAvail) {
                                 break;
                             }
-                            beforeT = beforeTrs.getTime() - 1;
-                            beforeSav = beforeTrs.getFrom()->getDSTSavings();
-                            if (beforeSav != 0) {
+                            resolvedSavings = trs.getTo()->getDSTSavings();
+                            if (resolvedSavings != 0) {
                                 break;
                             }
+                            time = trs.getTime();
                         }
 
-                        // Search for DST rule after the time
-                        while (TRUE) {
-                            afterTrsAvail = btz->getNextTransition(afterT, FALSE, afterTrs);
-                            if (!afterTrsAvail) {
-                                break;
+                        if (resolvedSavings == 0) {
+                            // If no DST rule after the given time was found, search for
+                            // DST rule before.
+                            time = baseTime;
+                            limit = baseTime - MAX_DAYLIGHT_DETECTION_RANGE;
+                            while (time > limit) {
+                                trsAvail = btz->getPreviousTransition(time, TRUE, trs);
+                                if (!trsAvail) {
+                                    break;
+                                }
+                                resolvedSavings = trs.getFrom()->getDSTSavings();
+                                if (resolvedSavings != 0) {
+                                    break;
+                                }
+                                time = trs.getTime() - 1;
                             }
-                            afterT = afterTrs.getTime();
-                            afterSav = afterTrs.getTo()->getDSTSavings();
-                            if (afterSav != 0) {
-                                break;
-                            }
-                        }
 
-                        if (beforeTrsAvail && afterTrsAvail) {
-                            if (time - beforeT > afterT - time) {
-                                resolvedSavings = afterSav;
-                            } else {
-                                resolvedSavings = beforeSav;
+                            if (resolvedSavings == 0) {
+                                resolvedSavings = btz->getDSTSavings();
                             }
-                        } else if (beforeTrsAvail && beforeSav != 0) {
-                            resolvedSavings = beforeSav;
-                        } else if (afterTrsAvail && afterSav != 0) {
-                            resolvedSavings = afterSav;
-                        } else {
-                            resolvedSavings = btz->getDSTSavings();
                         }
                     } else {
                         resolvedSavings = tz.getDSTSavings();
diff --git a/deps/icu-small/source/i18n/sortkey.cpp b/deps/icu-small/source/i18n/sortkey.cpp
index fb030c499083e6f1259a9e0412b8c091a9901dc9..430fd5d3500948e088c9b7d15c9bd6e7a5ec8672 100644
--- a/deps/icu-small/source/i18n/sortkey.cpp
+++ b/deps/icu-small/source/i18n/sortkey.cpp
@@ -20,7 +20,7 @@
 //
 //  6/20/97      helena        Java class name change.
 //  6/23/97      helena        Added comments to make code more readable.
-//  6/26/98      erm           Canged to use byte arrays instead of UnicodeString
+//  6/26/98      erm           Changed to use byte arrays instead of UnicodeString
 //  7/31/98      erm           hashCode: minimum inc should be 2 not 1,
 //                             Cleaned up operator=
 // 07/12/99      helena        HPUX 11 CC port.
diff --git a/deps/icu-small/source/i18n/standardplural.cpp b/deps/icu-small/source/i18n/standardplural.cpp
index 0391034b3e4a8dcec42c5c0a1db06c01e4c44646..5a6069bf7ddc47a5484433c1c8eedbe48b2c7c0d 100644
--- a/deps/icu-small/source/i18n/standardplural.cpp
+++ b/deps/icu-small/source/i18n/standardplural.cpp
@@ -23,7 +23,7 @@
 U_NAMESPACE_BEGIN
 
 static const char *gKeywords[StandardPlural::COUNT] = {
-    "zero", "one", "two", "few", "many", "other"
+    "zero", "one", "two", "few", "many", "other", "=0", "=1"
 };
 
 const char *StandardPlural::getKeyword(Form p) {
@@ -60,21 +60,55 @@ int32_t StandardPlural::indexOrNegativeFromString(const char *keyword) {
             return ZERO;
         }
         break;
+    case '=':
+        if (uprv_strcmp(keyword, "0") == 0) {
+            return EQ_0;
+        } else if (uprv_strcmp(keyword, "1") == 0) {
+            return EQ_1;
+        }
+        break;
+    // Also allow "0" and "1"
+    case '0':
+        if (*keyword == 0) {
+            return EQ_0;
+        }
+        break;
+    case '1':
+        if (*keyword == 0) {
+            return EQ_1;
+        }
+        break;
     default:
         break;
     }
     return -1;
 }
 
-static const UChar gZero[] = { 0x7A, 0x65, 0x72, 0x6F };
-static const UChar gOne[] = { 0x6F, 0x6E, 0x65 };
-static const UChar gTwo[] = { 0x74, 0x77, 0x6F };
-static const UChar gFew[] = { 0x66, 0x65, 0x77 };
-static const UChar gMany[] = { 0x6D, 0x61, 0x6E, 0x79 };
-static const UChar gOther[] = { 0x6F, 0x74, 0x68, 0x65, 0x72 };
+static const UChar gZero[] = u"zero";
+static const UChar gOne[] = u"one";
+static const UChar gTwo[] = u"two";
+static const UChar gFew[] = u"few";
+static const UChar gMany[] = u"many";
+static const UChar gOther[] = u"other";
+static const UChar gEq0[] = u"=0";
+static const UChar gEq1[] = u"=1";
 
 int32_t StandardPlural::indexOrNegativeFromString(const UnicodeString &keyword) {
     switch (keyword.length()) {
+    case 1:
+        if (keyword.charAt(0) == '0') {
+            return EQ_0;
+        } else if (keyword.charAt(0) == '1') {
+            return EQ_1;
+        }
+        break;
+    case 2:
+        if (keyword.compare(gEq0, 2) == 0) {
+            return EQ_0;
+        } else if (keyword.compare(gEq1, 2) == 0) {
+            return EQ_1;
+        }
+        break;
     case 3:
         if (keyword.compare(gOne, 3) == 0) {
             return ONE;
diff --git a/deps/icu-small/source/i18n/standardplural.h b/deps/icu-small/source/i18n/standardplural.h
index 33e1d605f6856bc0a7ff7e674ad38365c50a2efc..16593065c8aa91bda194bafebb917f18346fe166 100644
--- a/deps/icu-small/source/i18n/standardplural.h
+++ b/deps/icu-small/source/i18n/standardplural.h
@@ -35,6 +35,8 @@ public:
         FEW,
         MANY,
         OTHER,
+        EQ_0,
+        EQ_1,
         COUNT
     };
 
diff --git a/deps/icu-small/source/i18n/strmatch.h b/deps/icu-small/source/i18n/strmatch.h
index 09d04ede13e61acea9c1353608da11f7789f97c6..84b1d47398fd60d1c81627c91410401071cd798f 100644
--- a/deps/icu-small/source/i18n/strmatch.h
+++ b/deps/icu-small/source/i18n/strmatch.h
@@ -109,11 +109,11 @@ class StringMatcher : public UnicodeFunctor, public UnicodeMatcher, public Unico
      * considered for matching will be text.charAt(limit-1) in the
      * forward direction or text.charAt(limit+1) in the backward
      * direction.
-     * @param incremental  if TRUE, then assume further characters may
+     * @param incremental  if true, then assume further characters may
      * be inserted at limit and check for partial matching.  Otherwise
      * assume the text as given is complete.
      * @return a match degree value indicating a full match, a partial
-     * match, or a mismatch.  If incremental is FALSE then
+     * match, or a mismatch.  If incremental is false then
      * U_PARTIAL_MATCH should never be returned.
      */
     virtual UMatchDegree matches(const Replaceable& text,
@@ -128,16 +128,16 @@ class StringMatcher : public UnicodeFunctor, public UnicodeMatcher, public Unico
      * @return                  A reference to 'result'.
      */
     virtual UnicodeString& toPattern(UnicodeString& result,
-                                     UBool escapeUnprintable = FALSE) const;
+                                     UBool escapeUnprintable = false) const;
 
     /**
      * Implement UnicodeMatcher
-     * Returns TRUE if this matcher will match a character c, where c
+     * Returns true if this matcher will match a character c, where c
      * & 0xFF == v, at offset, in the forward direction (with limit >
      * offset).  This is used by <tt>RuleBasedTransliterator</tt> for
      * indexing.
      * @param v    the given value
-     * @return     TRUE if this matcher will match a character c,
+     * @return     true if this matcher will match a character c,
      *             where c & 0xFF == v
      */
     virtual UBool matchesIndexValue(uint8_t v) const;
@@ -181,7 +181,7 @@ class StringMatcher : public UnicodeFunctor, public UnicodeMatcher, public Unico
      * replacer that is equal to this one.
      * @param result the string to receive the pattern.  Previous
      * contents will be deleted.
-     * @param escapeUnprintable if TRUE then convert unprintable
+     * @param escapeUnprintable if true then convert unprintable
      * character to their hex escape representations, \\uxxxx or
      * \\Uxxxxxxxx.  Unprintable characters are defined by
      * Utility.isUnprintable().
diff --git a/deps/icu-small/source/i18n/stsearch.cpp b/deps/icu-small/source/i18n/stsearch.cpp
index 32481a1400407528b08eb4c1ca98e1a4693ee4c3..003d86b64016f00e4722157446107ca7990039e6 100644
--- a/deps/icu-small/source/i18n/stsearch.cpp
+++ b/deps/icu-small/source/i18n/stsearch.cpp
@@ -184,7 +184,7 @@ StringSearch::clone() const {
 // operator overloading ---------------------------------------------
 StringSearch & StringSearch::operator=(const StringSearch &that)
 {
-    if ((*this) != that) {
+    if (this != &that) {
         UErrorCode status = U_ZERO_ERROR;
         m_text_          = that.m_text_;
         m_breakiterator_ = that.m_breakiterator_;
diff --git a/deps/icu-small/source/i18n/taiwncal.h b/deps/icu-small/source/i18n/taiwncal.h
index daadc124f40a18cf7867f47b83a6ef0915d92e11..bf384fa714f05b8f05ed5830eaa62b6c93e1aaa7 100644
--- a/deps/icu-small/source/i18n/taiwncal.h
+++ b/deps/icu-small/source/i18n/taiwncal.h
@@ -156,7 +156,7 @@ private:
     virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
 
     /**
-     * Returns TRUE because the Taiwan Calendar does have a default century
+     * Returns true because the Taiwan Calendar does have a default century
      * @internal
      */
     virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/timezone.cpp b/deps/icu-small/source/i18n/timezone.cpp
index b90b78614aa00f2b157ed405f33422c25c175fae..fe564e6530e7b16b9647e200d1474dba9ad0a8fa 100644
--- a/deps/icu-small/source/i18n/timezone.cpp
+++ b/deps/icu-small/source/i18n/timezone.cpp
@@ -579,6 +579,24 @@ TimeZone::createDefault()
 
 // -------------------------------------
 
+TimeZone* U_EXPORT2
+TimeZone::forLocaleOrDefault(const Locale& locale)
+{
+    char buffer[ULOC_KEYWORDS_CAPACITY] = "";
+    UErrorCode localStatus = U_ZERO_ERROR;
+    int32_t count = locale.getKeywordValue("timezone", buffer, sizeof(buffer), localStatus);
+    if (U_FAILURE(localStatus) || localStatus == U_STRING_NOT_TERMINATED_WARNING) {
+        // the "timezone" keyword exceeds ULOC_KEYWORDS_CAPACITY; ignore and use default.
+        count = 0;
+    }
+    if (count > 0) {
+        return TimeZone::createTimeZone(UnicodeString(buffer, count, US_INV));
+    }
+    return TimeZone::createDefault();
+}
+
+// -------------------------------------
+
 void U_EXPORT2
 TimeZone::adoptDefault(TimeZone* zone)
 {
@@ -1660,7 +1678,7 @@ TimeZone::getIDForWindowsID(const UnicodeString& winid, const char* region, Unic
     winidKey[winKeyLen] = 0;
 
     ures_getByKey(zones, winidKey, zones, &tmperr); // use tmperr, because windows mapping might not
-                                                    // be avaiable by design
+                                                    // be available by design
     if (U_FAILURE(tmperr)) {
         ures_close(zones);
         return id;
diff --git a/deps/icu-small/source/i18n/translit.cpp b/deps/icu-small/source/i18n/translit.cpp
index a2ade1b4fe8578f83082d9edd53c65e944207740..c2a15837bedb0dbc654c8d0df5cc9e503febcc62 100644
--- a/deps/icu-small/source/i18n/translit.cpp
+++ b/deps/icu-small/source/i18n/translit.cpp
@@ -170,6 +170,7 @@ Transliterator* Transliterator::clone() const {
  * Assignment operator.
  */
 Transliterator& Transliterator::operator=(const Transliterator& other) {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     ID = other.ID;
     // NUL-terminate the ID string
     ID.getTerminatedBuffer();
diff --git a/deps/icu-small/source/i18n/transreg.h b/deps/icu-small/source/i18n/transreg.h
index 041244e1b02d774d0ec81381d5b829f133fba64f..0a0698862be1ac8f283748a6367f5034151f0839 100644
--- a/deps/icu-small/source/i18n/transreg.h
+++ b/deps/icu-small/source/i18n/transreg.h
@@ -69,7 +69,7 @@ class TransliteratorAlias : public UMemory {
      * it when the registry mutex is NOT held, to prevent deadlock.
      * It may only be called once.
      *
-     * Note: Only call create() if isRuleBased() returns FALSE.
+     * Note: Only call create() if isRuleBased() returns false.
      *
      * This method must be called *outside* of the TransliteratorRegistry
      * mutex.
@@ -77,17 +77,17 @@ class TransliteratorAlias : public UMemory {
     Transliterator* create(UParseError&, UErrorCode&);
 
     /**
-     * Return TRUE if this alias is rule-based.  If so, the caller
+     * Return true if this alias is rule-based.  If so, the caller
      * must call parse() on it, then call TransliteratorRegistry::reget().
      */
     UBool isRuleBased() const;
 
     /**
-     * If isRuleBased() returns TRUE, then the caller must call this
+     * If isRuleBased() returns true, then the caller must call this
      * method, followed by TransliteratorRegistry::reget().  The latter
      * method must be called inside the TransliteratorRegistry mutex.
      *
-     * Note: Only call parse() if isRuleBased() returns TRUE.
+     * Note: Only call parse() if isRuleBased() returns true.
      *
      * This method must be called *outside* of the TransliteratorRegistry
      * mutex, because it can instantiate Transliterators embedded in
@@ -144,7 +144,7 @@ class TransliteratorRegistry : public UMemory {
  public:
 
     /**
-     * Contructor
+     * Constructor
      * @param status Output param set to success/failure code.
      */
     TransliteratorRegistry(UErrorCode& status);
diff --git a/deps/icu-small/source/i18n/tridpars.h b/deps/icu-small/source/i18n/tridpars.h
index 3d657ed17c9784b6837f14186875c5924d04a131..cd56146023162f6284d8f5d729c5703d7cf2036e 100644
--- a/deps/icu-small/source/i18n/tridpars.h
+++ b/deps/icu-small/source/i18n/tridpars.h
@@ -222,7 +222,7 @@ class TransliteratorIDParser /* not : public UObject because all methods are sta
      * @param source          the given source.
      * @param target          the given target.
      * @param variant         the given variant
-     * @param isSourcePresent If TRUE then the source is present.
+     * @param isSourcePresent If true then the source is present.
      *                        If the source is not present, ANY will be
      *                        given as the source, and isSourcePresent will be null
      * @return an array of 4 strings: source, target, variant, and
diff --git a/deps/icu-small/source/i18n/tzfmt.cpp b/deps/icu-small/source/i18n/tzfmt.cpp
index 267d507aa7eca6a7d51496e9915751b0ff9d3b54..e70005a384085e71e9d5c53298138d5bbeb1df4f 100644
--- a/deps/icu-small/source/i18n/tzfmt.cpp
+++ b/deps/icu-small/source/i18n/tzfmt.cpp
@@ -1873,7 +1873,7 @@ TimeZoneFormat::parseOffsetFieldsWithPattern(const UnicodeString& text, int32_t
                 // When TimeZoneFormat parse() is called from SimpleDateFormat,
                 // leading space characters might be truncated. If the first pattern text
                 // starts with such character (e.g. Bidi control), then we need to
-                // skip the leading space charcters.
+                // skip the leading space characters.
                 if (idx < text.length() && !PatternProps::isWhiteSpace(text.char32At(idx))) {
                     while (len > 0) {
                         UChar32 ch;
diff --git a/deps/icu-small/source/i18n/tznames_impl.h b/deps/icu-small/source/i18n/tznames_impl.h
index 1286eeb80dc5030084671bf777f18db9a1bb80c8..417c0511f81f8ab2ba0808d1fd370ea9b1bef908 100644
--- a/deps/icu-small/source/i18n/tznames_impl.h
+++ b/deps/icu-small/source/i18n/tznames_impl.h
@@ -92,9 +92,9 @@ struct CharacterNode {
     UBool    fHasValuesVector;
     UBool    fPadding;
 
-    // No value:   fValues == NULL               and  fHasValuesVector == FALSE
-    // One value:  fValues == value              and  fHasValuesVector == FALSE
-    // >=2 values: fValues == UVector of values  and  fHasValuesVector == TRUE
+    // No value:   fValues == NULL               and  fHasValuesVector == false
+    // One value:  fValues == value              and  fHasValuesVector == false
+    // >=2 values: fValues == UVector of values  and  fHasValuesVector == true
 };
 
 inline UBool CharacterNode::hasValues() const {
diff --git a/deps/icu-small/source/i18n/ucal.cpp b/deps/icu-small/source/i18n/ucal.cpp
index 8ea7fbf4f5693954449ece7759437e9b0f5795d0..39a9508ca93443a66ad21c510a428adca3cf05fd 100644
--- a/deps/icu-small/source/i18n/ucal.cpp
+++ b/deps/icu-small/source/i18n/ucal.cpp
@@ -33,8 +33,8 @@ U_NAMESPACE_USE
 
 static TimeZone*
 _createTimeZone(const UChar* zoneID, int32_t len, UErrorCode* ec) {
-    TimeZone* zone = NULL;
-    if (ec != NULL && U_SUCCESS(*ec)) {
+    TimeZone* zone = nullptr;
+    if (ec != nullptr && U_SUCCESS(*ec)) {
         // Note that if zoneID is invalid, we get back GMT. This odd
         // behavior is by design and goes back to the JDK. The only
         // failure we will see is a memory allocation failure.
@@ -42,7 +42,7 @@ _createTimeZone(const UChar* zoneID, int32_t len, UErrorCode* ec) {
         UnicodeString zoneStrID;
         zoneStrID.setTo((UBool)(len < 0), zoneID, l); /* temporary read-only alias */
         zone = TimeZone::createTimeZone(zoneStrID);
-        if (zone == NULL) {
+        if (zone == nullptr) {
             *ec = U_MEMORY_ALLOCATION_ERROR;
         }
     }
@@ -58,20 +58,20 @@ ucal_openTimeZoneIDEnumeration(USystemTimeZoneType zoneType, const char* region,
 
 U_CAPI UEnumeration* U_EXPORT2
 ucal_openTimeZones(UErrorCode* ec) {
-    return uenum_openFromStringEnumeration(TimeZone::createEnumeration(), ec);
+    return ucal_openTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, nullptr, nullptr, ec);
 }
 
 U_CAPI UEnumeration* U_EXPORT2
 ucal_openCountryTimeZones(const char* country, UErrorCode* ec) {
-    return uenum_openFromStringEnumeration(TimeZone::createEnumeration(country), ec);
+    return ucal_openTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, country, nullptr, ec);
 }
 
 U_CAPI int32_t U_EXPORT2
 ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) {
     int32_t len = 0;
-    if (ec != NULL && U_SUCCESS(*ec)) {
+    if (ec != nullptr && U_SUCCESS(*ec)) {
         TimeZone* zone = TimeZone::createDefault();
-        if (zone == NULL) {
+        if (zone == nullptr) {
             *ec = U_MEMORY_ALLOCATION_ERROR;
         } else {
             UnicodeString id;
@@ -86,17 +86,17 @@ ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) {
 U_CAPI void U_EXPORT2
 ucal_setDefaultTimeZone(const UChar* zoneID, UErrorCode* ec) {
     TimeZone* zone = _createTimeZone(zoneID, -1, ec);
-    if (zone != NULL) {
+    if (zone != nullptr) {
         TimeZone::adoptDefault(zone);
     }
 }
 
-U_DRAFT int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getHostTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) {
     int32_t len = 0;
-    if (ec != NULL && U_SUCCESS(*ec)) {
+    if (ec != nullptr && U_SUCCESS(*ec)) {
         TimeZone *zone = TimeZone::detectHostTimeZone();
-        if (zone == NULL) {
+        if (zone == nullptr) {
             *ec = U_MEMORY_ALLOCATION_ERROR;
         } else {
             UnicodeString id;
@@ -114,7 +114,7 @@ ucal_getDSTSavings(const UChar* zoneID, UErrorCode* ec) {
     TimeZone* zone = _createTimeZone(zoneID, -1, ec);
     if (U_SUCCESS(*ec)) {
         SimpleTimeZone* stz = dynamic_cast<SimpleTimeZone*>(zone);
-        if (stz != NULL) {
+        if (stz != nullptr) {
             result = stz->getDSTSavings();
         } else {
             // Since there is no getDSTSavings on TimeZone, we use a
@@ -219,10 +219,10 @@ ucal_setTimeZone(    UCalendar*      cal,
   if(U_FAILURE(*status))
     return;
 
-  TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault()
+  TimeZone* zone = (zoneID==nullptr) ? TimeZone::createDefault()
       : _createTimeZone(zoneID, len, status);
 
-  if (zone != NULL) {
+  if (zone != nullptr) {
       ((Calendar*)cal)->adoptTimeZone(zone);
   }
 }
@@ -255,8 +255,8 @@ ucal_getTimeZoneDisplayName(const     UCalendar*                 cal,
 
     const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
     UnicodeString id;
-    if(!(result==NULL && resultLength==0)) {
-        // NULL destination for pure preflighting: empty dummy string
+    if (!(result == nullptr && resultLength == 0)) {
+        // Null destination for pure preflighting: empty dummy string
         // otherwise, alias the destination buffer
         id.setTo(result, 0, resultLength);
     }
@@ -298,12 +298,12 @@ ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode) {
     }
     Calendar *cpp_cal = (Calendar *)cal;
     GregorianCalendar *gregocal = dynamic_cast<GregorianCalendar *>(cpp_cal);
-    // Not if(gregocal == NULL) {
+    // Not if(gregocal == nullptr) {
     // because we really want to work only with a GregorianCalendar, not with
     // its subclasses like BuddhistCalendar.
-    if (cpp_cal == NULL) {
-        // We normally don't check "this" pointers for NULL, but this here avoids
-        // compiler-generated exception-throwing code in case cal == NULL.
+    if (cpp_cal == nullptr) {
+        // We normally don't check "this" pointers for nullptr, but this here avoids
+        // compiler-generated exception-throwing code in case cal == nullptr.
         *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
         return;
     }
@@ -321,11 +321,11 @@ ucal_getGregorianChange(const UCalendar *cal, UErrorCode *pErrorCode) {
     }
     const Calendar *cpp_cal = (const Calendar *)cal;
     const GregorianCalendar *gregocal = dynamic_cast<const GregorianCalendar *>(cpp_cal);
-    // Not if(gregocal == NULL) {
+    // Not if(gregocal == nullptr) {
     // see comments in ucal_setGregorianChange().
-    if (cpp_cal == NULL) {
-        // We normally don't check "this" pointers for NULL, but this here avoids
-        // compiler-generated exception-throwing code in case cal == NULL.
+    if (cpp_cal == nullptr) {
+        // We normally don't check "this" pointers for nullptr, but this here avoids
+        // compiler-generated exception-throwing code in case cal == nullptr.
         *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
         return (UDate)0;
     }
@@ -572,11 +572,11 @@ ucal_getLimit(    const    UCalendar*              cal,
 U_CAPI const char * U_EXPORT2
 ucal_getLocaleByType(const UCalendar *cal, ULocDataLocaleType type, UErrorCode* status)
 {
-    if (cal == NULL) {
+    if (cal == nullptr) {
         if (U_SUCCESS(*status)) {
             *status = U_ILLEGAL_ARGUMENT_ERROR;
         }
-        return NULL;
+        return nullptr;
     }
     return ((Calendar*)cal)->getLocaleID(type, *status);
 }
@@ -617,7 +617,7 @@ U_CAPI const char * U_EXPORT2
 ucal_getType(const UCalendar *cal, UErrorCode* status)
 {
     if (U_FAILURE(*status)) {
-        return NULL;
+        return nullptr;
     }
     return ((Calendar*)cal)->getType();
 }
@@ -662,8 +662,8 @@ ucal_getFieldDifference(UCalendar* cal, UDate target,
 
 
 static const UEnumeration defaultKeywordValues = {
-    NULL,
-    NULL,
+    nullptr,
+    nullptr,
     ulist_close_keyword_values_iterator,
     ulist_count_keyword_values,
     uenum_unextDefault,
@@ -690,7 +690,7 @@ static const char * const CAL_TYPES[] = {
         "islamic-umalqura",
         "islamic-tbla",
         "islamic-rgsa",
-        NULL
+        nullptr
 };
 
 U_CAPI UEnumeration* U_EXPORT2
@@ -700,16 +700,16 @@ ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool
     (void)ulocimp_getRegionForSupplementalData(locale, TRUE, prefRegion, sizeof(prefRegion), status);
 
     // Read preferred calendar values from supplementalData calendarPreference
-    UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", status);
+    UResourceBundle *rb = ures_openDirect(nullptr, "supplementalData", status);
     ures_getByKey(rb, "calendarPreferenceData", rb, status);
-    UResourceBundle *order = ures_getByKey(rb, prefRegion, NULL, status);
-    if (*status == U_MISSING_RESOURCE_ERROR && rb != NULL) {
+    UResourceBundle *order = ures_getByKey(rb, prefRegion, nullptr, status);
+    if (*status == U_MISSING_RESOURCE_ERROR && rb != nullptr) {
         *status = U_ZERO_ERROR;
-        order = ures_getByKey(rb, "001", NULL, status);
+        order = ures_getByKey(rb, "001", nullptr, status);
     }
 
     // Create a list of calendar type strings
-    UList *values = NULL;
+    UList *values = nullptr;
     if (U_SUCCESS(*status)) {
         values = ulist_createEmptyList(status);
         if (U_SUCCESS(*status)) {
@@ -717,7 +717,7 @@ ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool
                 int32_t len;
                 const UChar *type = ures_getStringByIndex(order, i, &len, status);
                 char *caltype = (char*)uprv_malloc(len + 1);
-                if (caltype == NULL) {
+                if (caltype == nullptr) {
                     *status = U_MEMORY_ALLOCATION_ERROR;
                     break;
                 }
@@ -732,7 +732,7 @@ ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool
 
             if (U_SUCCESS(*status) && !commonlyUsed) {
                 // If not commonlyUsed, add other available values
-                for (int32_t i = 0; CAL_TYPES[i] != NULL; i++) {
+                for (int32_t i = 0; CAL_TYPES[i] != nullptr; i++) {
                     if (!ulist_containsString(values, CAL_TYPES[i], (int32_t)uprv_strlen(CAL_TYPES[i]))) {
                         ulist_addItemEndList(values, CAL_TYPES[i], FALSE, status);
                         if (U_FAILURE(*status)) {
@@ -743,7 +743,7 @@ ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool
             }
             if (U_FAILURE(*status)) {
                 ulist_deleteList(values);
-                values = NULL;
+                values = nullptr;
             }
         }
     }
@@ -751,16 +751,16 @@ ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool
     ures_close(order);
     ures_close(rb);
 
-    if (U_FAILURE(*status) || values == NULL) {
-        return NULL;
+    if (U_FAILURE(*status) || values == nullptr) {
+        return nullptr;
     }
 
     // Create string enumeration
     UEnumeration *en = (UEnumeration*)uprv_malloc(sizeof(UEnumeration));
-    if (en == NULL) {
+    if (en == nullptr) {
         *status = U_MEMORY_ALLOCATION_ERROR;
         ulist_deleteList(values);
-        return NULL;
+        return nullptr;
     }
     ulist_resetList(values);
     memcpy(en, &defaultKeywordValues, sizeof(UEnumeration));
@@ -778,7 +778,7 @@ ucal_getTimeZoneTransitionDate(const UCalendar* cal, UTimeZoneTransitionType typ
     UDate base = ((Calendar*)cal)->getTime(*status);
     const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
     const BasicTimeZone * btz = dynamic_cast<const BasicTimeZone *>(&tz);
-    if (btz != NULL && U_SUCCESS(*status)) {
+    if (btz != nullptr && U_SUCCESS(*status)) {
         TimeZoneTransition tzt;
         UBool inclusive = (type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE || type == UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE);
         UBool result = (type == UCAL_TZ_TRANSITION_NEXT || type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE)?
@@ -828,4 +828,28 @@ ucal_getTimeZoneIDForWindowsID(const UChar* winid, int32_t len, const char* regi
     return resultLen;
 }
 
+U_CAPI void U_EXPORT2 ucal_getTimeZoneOffsetFromLocal(
+    const UCalendar* cal,
+    UTimeZoneLocalOption nonExistingTimeOpt,
+    UTimeZoneLocalOption duplicatedTimeOpt,
+    int32_t* rawOffset, int32_t* dstOffset, UErrorCode* status)
+{
+    if (U_FAILURE(*status)) {
+        return;
+    }
+    UDate date = ((Calendar*)cal)->getTime(*status);
+    if (U_FAILURE(*status)) {
+        return;
+    }
+    const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
+    const BasicTimeZone* btz = dynamic_cast<const BasicTimeZone *>(&tz);
+    if (btz == nullptr) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return;
+    }
+    btz->getOffsetFromLocal(
+        date, nonExistingTimeOpt, duplicatedTimeOpt,
+        *rawOffset, *dstOffset, *status);
+}
+
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/ucol_imp.h b/deps/icu-small/source/i18n/ucol_imp.h
index a251fc461d3ac21c794e307fe9df50dd811d45be..f463957fd4f2d861db2f7758950e2853b6a93f49 100644
--- a/deps/icu-small/source/i18n/ucol_imp.h
+++ b/deps/icu-small/source/i18n/ucol_imp.h
@@ -41,10 +41,10 @@
  *  rules must be equivalent.
  *  @param source first collator
  *  @param target second collator
- *  @return TRUE or FALSE
+ *  @return true or false
  *  @internal ICU 3.0
  */
-U_INTERNAL UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucol_equals(const UCollator *source, const UCollator *target);
 
 /**
diff --git a/deps/icu-small/source/i18n/ucol_sit.cpp b/deps/icu-small/source/i18n/ucol_sit.cpp
index 9fa7cd5fd73851b3b7fbf96e909ec7db7668fad1..d6bbf97b310bd352e1600dc6d224d5c21c0711dc 100644
--- a/deps/icu-small/source/i18n/ucol_sit.cpp
+++ b/deps/icu-small/source/i18n/ucol_sit.cpp
@@ -372,10 +372,7 @@ int32_t ucol_sit_dumpSpecs(CollatorSpec *s, char *destination, int32_t capacity,
                     }
                     len += s->entries[i].length();
                 } else {
-                    len += s->entries[i].length();
-                    if(len < capacity) {
-                        uprv_strncat(destination,s->entries[i].data(), s->entries[i].length());
-                    }
+                    len += s->entries[i].extract(destination + len, capacity - len, *status);
                 }
             }
         }
diff --git a/deps/icu-small/source/i18n/ucsdet.cpp b/deps/icu-small/source/i18n/ucsdet.cpp
index 46f69cf90cba6b34e1e5d89564e99d3fb1b92457..63f204d0e104210104528762a558f477416e80e2 100644
--- a/deps/icu-small/source/i18n/ucsdet.cpp
+++ b/deps/icu-small/source/i18n/ucsdet.cpp
@@ -193,7 +193,7 @@ ucsdet_getAllDetectableCharsets(const UCharsetDetector * /*ucsd*/, UErrorCode *s
     return CharsetDetector::getAllDetectableCharsets(*status);
 }
 
-U_DRAFT UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 ucsdet_getDetectableCharsets(const UCharsetDetector *ucsd,  UErrorCode *status)
 {
     return ((CharsetDetector *)ucsd)->getDetectableCharsets(*status);
diff --git a/deps/icu-small/source/i18n/udat.cpp b/deps/icu-small/source/i18n/udat.cpp
index da8befc9e3c65b221137dcbf90ce3a9c079b2515..016805aab66fddec47d1b5540182bfab5a476d0c 100644
--- a/deps/icu-small/source/i18n/udat.cpp
+++ b/deps/icu-small/source/i18n/udat.cpp
@@ -82,19 +82,24 @@ static UCalendarDateFields gDateFieldMapping[] = {
     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_ISO_FIELD = 32 (also UCAL_DST_OFFSET)
     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_ISO_LOCAL_FIELD = 33 (also UCAL_DST_OFFSET)
     UCAL_EXTENDED_YEAR,        // UDAT_RELATED_YEAR_FIELD = 34 (not an exact match)
-    UCAL_FIELD_COUNT,          // UDAT_FIELD_COUNT = 35
+    UCAL_FIELD_COUNT,          // UDAT_AM_PM_MIDNIGHT_NOON_FIELD=35 (no match)
+    UCAL_FIELD_COUNT,          // UDAT_FLEXIBLE_DAY_PERIOD_FIELD=36 (no match)
+    UCAL_FIELD_COUNT,          // UDAT_TIME_SEPARATOR_FIELD = 37 (no match)
+                               // UDAT_FIELD_COUNT = 38 as of ICU 67
     // UCAL_IS_LEAP_MONTH is not the target of a mapping
 };
 
 U_CAPI UCalendarDateFields U_EXPORT2
 udat_toCalendarDateField(UDateFormatField field) {
-  return gDateFieldMapping[field];
+  static_assert(UDAT_FIELD_COUNT == UPRV_LENGTHOF(gDateFieldMapping),
+    "UDateFormatField and gDateFieldMapping should have the same number of entries and be kept in sync.");
+  return (field >= UDAT_ERA_FIELD && field < UPRV_LENGTHOF(gDateFieldMapping))? gDateFieldMapping[field]: UCAL_FIELD_COUNT;
 }
 
 /* For now- one opener. */
 static UDateFormatOpener gOpener = NULL;
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 udat_registerOpener(UDateFormatOpener opener, UErrorCode *status)
 {
   if(U_FAILURE(*status)) return;
@@ -107,7 +112,7 @@ udat_registerOpener(UDateFormatOpener opener, UErrorCode *status)
   umtx_unlock(NULL);
 }
 
-U_INTERNAL UDateFormatOpener U_EXPORT2
+U_CAPI UDateFormatOpener U_EXPORT2
 udat_unregisterOpener(UDateFormatOpener opener, UErrorCode *status)
 {
   if(U_FAILURE(*status)) return NULL;
@@ -419,7 +424,7 @@ udat_setLenient(    UDateFormat*    fmt,
     ((DateFormat*)fmt)->setLenient(isLenient);
 }
 
-U_DRAFT UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 udat_getBooleanAttribute(const UDateFormat* fmt,
                          UDateFormatBooleanAttribute attr,
                          UErrorCode* status)
@@ -429,7 +434,7 @@ udat_getBooleanAttribute(const UDateFormat* fmt,
     //return FALSE;
 }
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 udat_setBooleanAttribute(UDateFormat *fmt,
                          UDateFormatBooleanAttribute attr,
                          UBool newValue,
@@ -452,7 +457,7 @@ udat_setCalendar(UDateFormat*    fmt,
     ((DateFormat*)fmt)->setCalendar(*((Calendar*)calendarToSet));
 }
 
-U_DRAFT const UNumberFormat* U_EXPORT2
+U_CAPI const UNumberFormat* U_EXPORT2
 udat_getNumberFormatForField(const UDateFormat* fmt, UChar field)
 {
     UErrorCode status = U_ZERO_ERROR;
@@ -467,7 +472,7 @@ udat_getNumberFormat(const UDateFormat* fmt)
     return (const UNumberFormat*) ((DateFormat*)fmt)->getNumberFormat();
 }
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 udat_adoptNumberFormatForFields(           UDateFormat*    fmt,
                                     const  UChar*          fields,
                                            UNumberFormat*  numberFormatToSet,
@@ -489,7 +494,7 @@ udat_setNumberFormat(UDateFormat*    fmt,
     ((DateFormat*)fmt)->setNumberFormat(*((NumberFormat*)numberFormatToSet));
 }
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 udat_adoptNumberFormat(      UDateFormat*    fmt,
                              UNumberFormat*  numberFormatToAdopt)
 {
diff --git a/deps/icu-small/source/i18n/udateintervalformat.cpp b/deps/icu-small/source/i18n/udateintervalformat.cpp
index 388960384b563ffba239fc6837203c20c187f497..355744346a39d729c5b279a6fccd062e22e2d4fe 100644
--- a/deps/icu-small/source/i18n/udateintervalformat.cpp
+++ b/deps/icu-small/source/i18n/udateintervalformat.cpp
@@ -18,6 +18,7 @@
 #include "unicode/timezone.h"
 #include "unicode/locid.h"
 #include "unicode/unistr.h"
+#include "unicode/udisplaycontext.h"
 #include "formattedval_impl.h"
 
 U_NAMESPACE_USE
@@ -116,7 +117,7 @@ udtitvfmt_format(const UDateIntervalFormat* formatter,
 }
 
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 udtitvfmt_formatToResult(
                 const UDateIntervalFormat* formatter,
                 UDate           fromDate,
@@ -134,7 +135,7 @@ udtitvfmt_formatToResult(
     }
 }
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 udtitvfmt_formatCalendarToResult(
                 const UDateIntervalFormat* formatter,
                 UCalendar*      fromCalendar,
@@ -151,5 +152,25 @@ udtitvfmt_formatCalendarToResult(
     }
 }
 
+U_CAPI void U_EXPORT2
+udtitvfmt_setContext(UDateIntervalFormat* formatter,
+                     UDisplayContext value,
+                     UErrorCode* status) {
+    if (U_FAILURE(*status)) {
+        return;
+    }
+    reinterpret_cast<DateIntervalFormat*>(formatter)->setContext( value, *status );
+}
+
+U_CAPI UDisplayContext U_EXPORT2
+udtitvfmt_getContext(const UDateIntervalFormat* formatter,
+                     UDisplayContextType type,
+                     UErrorCode* status) {
+    if (U_FAILURE(*status)) {
+        return (UDisplayContext)0;
+    }
+    return reinterpret_cast<const DateIntervalFormat*>(formatter)->getContext( type, *status );
+}
+
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/uitercollationiterator.h b/deps/icu-small/source/i18n/uitercollationiterator.h
index 62b6f8341933bb3d0e540887cd05055a2144507c..3a7b1a0ec23b4728f52c3e018d77f0f199408d38 100644
--- a/deps/icu-small/source/i18n/uitercollationiterator.h
+++ b/deps/icu-small/source/i18n/uitercollationiterator.h
@@ -96,7 +96,7 @@ private:
 
     /**
      * Extends the FCD text segment forward or normalizes around pos.
-     * @return TRUE if success
+     * @return true if success
      */
     UBool nextSegment(UErrorCode &errorCode);
 
@@ -107,7 +107,7 @@ private:
 
     /**
      * Extends the FCD text segment backward or normalizes around pos.
-     * @return TRUE if success
+     * @return true if success
      */
     UBool previousSegment(UErrorCode &errorCode);
 
diff --git a/deps/icu-small/source/i18n/ulocdata.cpp b/deps/icu-small/source/i18n/ulocdata.cpp
index f651fee6fc4efa3ac8626f7aae68073b21003d02..3046167b328db8b5af58b5d6e4fe4efd73911296 100644
--- a/deps/icu-small/source/i18n/ulocdata.cpp
+++ b/deps/icu-small/source/i18n/ulocdata.cpp
@@ -172,7 +172,7 @@ ulocdata_getDelimiter(ULocaleData *uld, ULocaleDataDelimiterType type,
         return 0;
     }
 
-    delimiter = ures_getStringByKey(delimiterBundle, delimiterKeys[type], &len, &localStatus);
+    delimiter = ures_getStringByKeyWithFallback(delimiterBundle, delimiterKeys[type], &len, &localStatus);
     ures_close(delimiterBundle);
 
     if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
diff --git a/deps/icu-small/source/i18n/uni2name.cpp b/deps/icu-small/source/i18n/uni2name.cpp
index 9df3924ae5f1477379c43e567ff6d851b10889fb..729a1e5fa82a62f3bdb2b203912e8afa86a0dfa9 100644
--- a/deps/icu-small/source/i18n/uni2name.cpp
+++ b/deps/icu-small/source/i18n/uni2name.cpp
@@ -81,7 +81,7 @@ void UnicodeNameTransliterator::handleTransliterate(Replaceable& text, UTransPos
         return;
     }
 
-    // Accomodate the longest possible name plus padding
+    // Accommodate the longest possible name plus padding
     char* buf = (char*) uprv_malloc(maxLen);
     if (buf == NULL) {
         offsets.start = offsets.limit;
diff --git a/deps/icu-small/source/i18n/unicode/alphaindex.h b/deps/icu-small/source/i18n/unicode/alphaindex.h
index fe43995fe81155e3bc6eaa773615eeebcfcc9bfc..d72abce9acd3ecfe3f104396e0714fac49b2022f 100644
--- a/deps/icu-small/source/i18n/unicode/alphaindex.h
+++ b/deps/icu-small/source/i18n/unicode/alphaindex.h
@@ -549,14 +549,14 @@ public:
 
 
     /**
-     *   Advance the iteration over the Buckets of this index.  Return FALSE if
+     *   Advance the iteration over the Buckets of this index.  Return false if
      *   there are no more Buckets.
      *
      *   @param status  Error code, will be set with the reason if the operation fails.
      *   U_ENUM_OUT_OF_SYNC_ERROR will be reported if the index is modified while
      *   an enumeration of its contents are in process.
      *
-     *   @return TRUE if success, FALSE if at end of iteration
+     *   @return true if success, false if at end of iteration
      *   @stable ICU 4.8
      */
     virtual UBool nextBucket(UErrorCode &status);
@@ -609,7 +609,7 @@ public:
      *   @param status  Error code, will be set with the reason if the operation fails.
      *   U_ENUM_OUT_OF_SYNC_ERROR will be reported if the index is modified while
      *   an enumeration of its contents are in process.
-     *   @return TRUE if successful, FALSE when the iteration advances past the last item.
+     *   @return true if successful, false when the iteration advances past the last item.
      *   @stable ICU 4.8
      */
     virtual UBool nextRecord(UErrorCode &status);
diff --git a/deps/icu-small/source/i18n/unicode/basictz.h b/deps/icu-small/source/i18n/unicode/basictz.h
index cc8059709f49b00ce5603d1adfe369e137ead87b..ea8720ed13cf41c5eba8088cfd72ed4434cdf7ab 100644
--- a/deps/icu-small/source/i18n/unicode/basictz.h
+++ b/deps/icu-small/source/i18n/unicode/basictz.h
@@ -56,7 +56,7 @@ public:
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the first transition after the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      * @stable ICU 3.8
      */
     virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const = 0;
@@ -66,7 +66,7 @@ public:
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the most recent transition before the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      * @stable ICU 3.8
      */
     virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const = 0;
@@ -152,6 +152,17 @@ public:
     virtual void getSimpleRulesNear(UDate date, InitialTimeZoneRule*& initial,
         AnnualTimeZoneRule*& std, AnnualTimeZoneRule*& dst, UErrorCode& status) const;
 
+#ifndef U_FORCE_HIDE_DRAFT_API
+    /**
+     * Get time zone offsets from local wall time.
+     * @draft ICU 69
+     */
+    virtual void getOffsetFromLocal(
+        UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+        UTimeZoneLocalOption duplicatedTimeOpt, int32_t& rawOffset,
+        int32_t& dstOffset, UErrorCode& status) const;
+
+#endif /* U_FORCE_HIDE_DRAFT_API */
 
 #ifndef U_HIDE_INTERNAL_API
     /**
@@ -161,17 +172,17 @@ public:
     enum {
         kStandard = 0x01,
         kDaylight = 0x03,
-        kFormer = 0x04,
-        kLatter = 0x0C
+        kFormer = 0x04, /* UCAL_TZ_LOCAL_FORMER */
+        kLatter = 0x0C  /* UCAL_TZ_LOCAL_LATTER */
     };
-#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Get time zone offsets from local wall time.
      * @internal
      */
-    virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
+    void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
         int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
+#endif  /* U_HIDE_INTERNAL_API */
 
 protected:
 
diff --git a/deps/icu-small/source/i18n/unicode/calendar.h b/deps/icu-small/source/i18n/unicode/calendar.h
index 2a8c2935ca8e24696353e1a7e62e43e67d2703e0..be774ab26fb61998b8e888495353afcc6ac5caea 100644
--- a/deps/icu-small/source/i18n/unicode/calendar.h
+++ b/deps/icu-small/source/i18n/unicode/calendar.h
@@ -47,6 +47,8 @@ U_NAMESPACE_BEGIN
 
 class ICUServiceFactory;
 
+// Do not conditionalize the following with #ifndef U_HIDE_INTERNAL_API,
+// it is a return type for a virtual method (@internal)
 /**
  * @internal
  */
@@ -464,10 +466,10 @@ public:
     UBool operator!=(const Calendar& that) const {return !operator==(that);}
 
     /**
-     * Returns TRUE if the given Calendar object is equivalent to this
+     * Returns true if the given Calendar object is equivalent to this
      * one.  An equivalent Calendar will behave exactly as this one
      * does, but it may be set to a different time.  By contrast, for
-     * the operator==() method to return TRUE, the other Calendar must
+     * the operator==() method to return true, the other Calendar must
      * be set to the same time.
      *
      * @param other the Calendar to be compared with this Calendar
@@ -1359,7 +1361,7 @@ public:
      *     localeID.append(calType);
      *     char langTag[100];
      *     UErrorCode errorCode = U_ZERO_ERROR;
-     *     int32_t length = uloc_toLanguageTag(localeID.c_str(), langTag, (int32_t)sizeof(langTag), TRUE, &errorCode);
+     *     int32_t length = uloc_toLanguageTag(localeID.c_str(), langTag, (int32_t)sizeof(langTag), true, &errorCode);
      *     if (U_FAILURE(errorCode)) {
      *         // deal with errors & overflow
      *     }
@@ -1410,21 +1412,21 @@ public:
     virtual int32_t getWeekendTransition(UCalendarDaysOfWeek dayOfWeek, UErrorCode &status) const;
 
     /**
-     * Returns TRUE if the given UDate is in the weekend in
+     * Returns true if the given UDate is in the weekend in
      * this calendar system.
      * @param date The UDate in question.
      * @param status The error code for the operation.
-     * @return TRUE if the given UDate is in the weekend in
-     * this calendar system, FALSE otherwise.
+     * @return true if the given UDate is in the weekend in
+     * this calendar system, false otherwise.
      * @stable ICU 4.4
      */
     virtual UBool isWeekend(UDate date, UErrorCode &status) const;
 
     /**
-     * Returns TRUE if this Calendar's current date-time is in the weekend in
+     * Returns true if this Calendar's current date-time is in the weekend in
      * this calendar system.
-     * @return TRUE if this Calendar's current date-time is in the weekend in
-     * this calendar system, FALSE otherwise.
+     * @return true if this Calendar's current date-time is in the weekend in
+     * this calendar system, false otherwise.
      * @stable ICU 4.4
      */
     virtual UBool isWeekend(void) const;
@@ -1849,7 +1851,7 @@ private:
      * @param startValue starting (least max) value of field
      * @param endValue ending (greatest max) value of field
      * @param status return type
-     * @internal
+     * @internal (private)
      */
     int32_t getActualHelper(UCalendarDateFields field, int32_t startValue, int32_t endValue, UErrorCode &status) const;
 
@@ -2372,7 +2374,7 @@ private:
      *
      * @param key the registry key returned by a previous call to registerFactory
      * @param status the in/out status code, no special meanings are assigned
-     * @return TRUE if the factory for the key was successfully unregistered
+     * @return true if the factory for the key was successfully unregistered
      * @internal
      */
     static UBool unregister(URegistryKey key, UErrorCode& status);
@@ -2398,7 +2400,7 @@ private:
 #endif /* !UCONFIG_NO_SERVICE */
 
     /**
-     * @return TRUE if this calendar has a default century (i.e. 03 -> 2003)
+     * @return true if this calendar has a default century (i.e. 03 -> 2003)
      * @internal
      */
     virtual UBool haveDefaultCentury() const = 0;
@@ -2458,7 +2460,7 @@ private:
      * @param base The base time, inclusive
      * @param transitionTime Receives the result time
      * @param status The error status
-     * @return TRUE if a transition is found.
+     * @return true if a transition is found.
      */
     UBool getImmediatePreviousZoneTransition(UDate base, UDate *transitionTime, UErrorCode& status) const;
 
@@ -2531,7 +2533,7 @@ Calendar::internalSet(UCalendarDateFields field, int32_t value)
 {
     fFields[field] = value;
     fStamp[field] = kInternallySet;
-    fIsSet[field]     = TRUE; // Remove later
+    fIsSet[field]     = true; // Remove later
 }
 
 
diff --git a/deps/icu-small/source/i18n/unicode/choicfmt.h b/deps/icu-small/source/i18n/unicode/choicfmt.h
index 3b2f48cb1f853ca1c3f84a735e7fc67c844daa82..cb01fca253355d7104fc9c57695de218921f621e 100644
--- a/deps/icu-small/source/i18n/unicode/choicfmt.h
+++ b/deps/icu-small/source/i18n/unicode/choicfmt.h
@@ -106,7 +106,7 @@ class MessageFormat;
  * arrays of numbers, closure flags and strings,
  * they are interpreted just like
  * the sequence of <code>(number separator string)</code> in an equivalent pattern string.
- * <code>closure[i]==TRUE</code> corresponds to a <code>less_than</code> separator sign.
+ * <code>closure[i]==true</code> corresponds to a <code>less_than</code> separator sign.
  * The equivalent pattern string will be constructed automatically.</p>
  *
  * <p>During formatting, a number is mapped to the first range
@@ -126,7 +126,7 @@ class MessageFormat;
  * <p>Here is an example of two arrays that map the number
  * <code>1..7</code> to the English day of the week abbreviations
  * <code>Sun..Sat</code>. No closures array is given; this is the same as
- * specifying all closures to be <code>FALSE</code>.</p>
+ * specifying all closures to be <code>false</code>.</p>
  *
  * <pre>    {1,2,3,4,5,6,7},
  *     {&quot;Sun&quot;,&quot;Mon&quot;,&quot;Tue&quot;,&quot;Wed&quot;,&quot;Thur&quot;,&quot;Fri&quot;,&quot;Sat&quot;}</pre>
@@ -138,7 +138,7 @@ class MessageFormat;
  * like the turned bracket in European notation: [-Inf, 1) == [-Inf, 1[  )</p>
  *
  * <pre>    {0, 1, 1},
- *     {FALSE, FALSE, TRUE},
+ *     {false, false, true},
  *     {&quot;no files&quot;, &quot;one file&quot;, &quot;many files&quot;}</pre>
  *
  * <p>Here is an example that shows formatting and parsing: </p>
@@ -189,7 +189,7 @@ public:
 
     /**
      * Constructs a new ChoiceFormat with the given limits and message strings.
-     * All closure flags default to <code>FALSE</code>,
+     * All closure flags default to <code>false</code>,
      * equivalent to <code>less_than_or_equal</code> separators.
      *
      * Copies the limits and formats instead of adopting them.
@@ -210,9 +210,9 @@ public:
      *
      * @param limits Array of limit values
      * @param closures Array of booleans specifying whether each
-     * element of 'limits' is open or closed.  If FALSE, then the
+     * element of 'limits' is open or closed.  If false, then the
      * corresponding limit number is a member of its range.
-     * If TRUE, then the limit number belongs to the previous range it.
+     * If true, then the limit number belongs to the previous range it.
      * @param formats Array of formats
      * @param count Size of 'limits', 'closures', and 'formats' arrays
      * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
@@ -568,13 +568,13 @@ private:
      * The intervals may be closed, half open, or open.  This affects
      * formatting but does not affect parsing.  Interval i is affected
      * by fClosures[i] and fClosures[i+1].  If fClosures[i]
-     * is FALSE, then the value fChoiceLimits[i] is in interval i.
+     * is false, then the value fChoiceLimits[i] is in interval i.
      * That is, intervals i and i are:
      *
      *  i-1:                 ... x < fChoiceLimits[i]
      *    i: fChoiceLimits[i] <= x ...
      *
-     * If fClosures[i] is TRUE, then the value fChoiceLimits[i] is
+     * If fClosures[i] is true, then the value fChoiceLimits[i] is
      * in interval i-1.  That is, intervals i-1 and i are:
      *
      *  i-1:                ... x <= fChoiceLimits[i]
diff --git a/deps/icu-small/source/i18n/unicode/coleitr.h b/deps/icu-small/source/i18n/unicode/coleitr.h
index 809d435e509b49bb7b37eeb620f3c84b3fc2061e..2696b588278cde38cfdf36773738e798182b7c91 100644
--- a/deps/icu-small/source/i18n/unicode/coleitr.h
+++ b/deps/icu-small/source/i18n/unicode/coleitr.h
@@ -253,7 +253,7 @@ public:
     /**
     * Checks if a comparison order is ignorable.
     * @param order the collation order.
-    * @return TRUE if a character is ignorable, FALSE otherwise.
+    * @return true if a character is ignorable, false otherwise.
     * @stable ICU 2.0
     */
     static inline UBool isIgnorable(int32_t order);
diff --git a/deps/icu-small/source/i18n/unicode/coll.h b/deps/icu-small/source/i18n/unicode/coll.h
index f5564c73944bcb1bf30123fbe5818e7ca5398b27..c750711fc158cffe55be7b21f83c8be62d45ad01 100644
--- a/deps/icu-small/source/i18n/unicode/coll.h
+++ b/deps/icu-small/source/i18n/unicode/coll.h
@@ -236,21 +236,21 @@ public:
     // Collator public methods --------------------------------------------
 
     /**
-     * Returns TRUE if "other" is the same as "this".
+     * Returns true if "other" is the same as "this".
      *
-     * The base class implementation returns TRUE if "other" has the same type/class as "this":
+     * The base class implementation returns true if "other" has the same type/class as "this":
      * `typeid(*this) == typeid(other)`.
      *
      * Subclass implementations should do something like the following:
      *
-     *     if (this == &other) { return TRUE; }
-     *     if (!Collator::operator==(other)) { return FALSE; }  // not the same class
+     *     if (this == &other) { return true; }
+     *     if (!Collator::operator==(other)) { return false; }  // not the same class
      *
      *     const MyCollator &o = (const MyCollator&)other;
      *     (compare this vs. o's subclass fields)
      *
      * @param other Collator object to be compared
-     * @return TRUE if other is the same as this.
+     * @return true if other is the same as this.
      * @stable ICU 2.0
      */
     virtual UBool operator==(const Collator& other) const;
@@ -259,7 +259,7 @@ public:
      * Returns true if "other" is not the same as "this".
      * Calls ! operator==(const Collator&) const which works for all subclasses.
      * @param other Collator object to be compared
-     * @return TRUE if other is not the same as this.
+     * @return true if other is not the same as this.
      * @stable ICU 2.0
      */
     virtual UBool operator!=(const Collator& other) const;
@@ -304,7 +304,7 @@ public:
      * Starting with ICU 54, collation attributes can be specified via locale keywords as well,
      * in the old locale extension syntax ("el@colCaseFirst=upper")
      * or in language tag syntax ("el-u-kf-upper").
-     * See <a href="http://userguide.icu-project.org/collation/api">User Guide: Collation API</a>.
+     * See <a href="https://unicode-org.github.io/icu/userguide/collation/api">User Guide: Collation API</a>.
      *
      * The UErrorCode& err parameter is used to return status information to the user.
      * To check whether the construction succeeded or not, you should check
@@ -788,7 +788,7 @@ public:
      * applications who wish to cache collators, or otherwise reuse
      * collators when possible.  The functional equivalent may change
      * over time.  For more information, please see the <a
-     * href="http://userguide.icu-project.org/locale#TOC-Locales-and-Services">
+     * href="https://unicode-org.github.io/icu/userguide/locale#locales-and-services">
      * Locales and Services</a> section of the ICU User Guide.
      * @param keyword a particular keyword as enumerated by
      * ucol_getKeywords.
@@ -841,7 +841,7 @@ public:
      * Collator::createInstance to avoid undefined behavior.
      * @param key the registry key returned by a previous call to registerInstance
      * @param status the in/out status code, no special meanings are assigned
-     * @return TRUE if the collator for the key was successfully unregistered
+     * @return true if the collator for the key was successfully unregistered
      * @stable ICU 2.6
      */
     static UBool U_EXPORT2 unregister(URegistryKey key, UErrorCode& status);
@@ -1139,7 +1139,7 @@ public:
      *  This string will be normalized.
      *  The structure and the syntax of the string is defined in the "Naming collators"
      *  section of the users guide:
-     *  http://userguide.icu-project.org/collation/concepts#TOC-Collator-naming-scheme
+     *  https://unicode-org.github.io/icu/userguide/collation/concepts#collator-naming-scheme
      *  This function supports preflighting.
      *
      *  This is internal, and intended to be used with delegate converters.
diff --git a/deps/icu-small/source/i18n/unicode/curramt.h b/deps/icu-small/source/i18n/unicode/curramt.h
index 65e6619db30c161d6225eb8d5a9792ce32fa964c..9c8496381d7aa3826454eb0d71f6495244784e11 100644
--- a/deps/icu-small/source/i18n/unicode/curramt.h
+++ b/deps/icu-small/source/i18n/unicode/curramt.h
@@ -41,7 +41,7 @@ class U_I18N_API CurrencyAmount: public Measure {
     /**
      * Construct an object with the given numeric amount and the given
      * ISO currency code.
-     * @param amount a numeric object; amount.isNumeric() must be TRUE
+     * @param amount a numeric object; amount.isNumeric() must be true
      * @param isoCode the 3-letter ISO 4217 currency code; must not be
      * NULL and must have length 3
      * @param ec input-output error code. If the amount or the isoCode
diff --git a/deps/icu-small/source/i18n/unicode/datefmt.h b/deps/icu-small/source/i18n/unicode/datefmt.h
index 21217e567acf7d9589a856304aa878c52b6b342a..bbba0785edaccc6cb2006193899739676dbae35c 100644
--- a/deps/icu-small/source/i18n/unicode/datefmt.h
+++ b/deps/icu-small/source/i18n/unicode/datefmt.h
@@ -139,7 +139,7 @@ template class U_I18N_API EnumSet<UDateFormatBooleanAttribute,
  * more control over the format or parsing, (or want to give your users more
  * control), you can try casting the DateFormat you get from the factory methods
  * to a SimpleDateFormat. This will work for the majority of countries; just
- * remember to chck getDynamicClassID() before carrying out the cast.
+ * remember to check getDynamicClassID() before carrying out the cast.
  * <P>
  * You can also use forms of the parse and format methods with ParsePosition and
  * FieldPosition to allow you to
diff --git a/deps/icu-small/source/i18n/unicode/dcfmtsym.h b/deps/icu-small/source/i18n/unicode/dcfmtsym.h
index 582e7533a4aceb3af4d52c9c54464ac4c0c3600d..d0f844a51a369fa7ec8df0fbc297bc497f0074e9 100644
--- a/deps/icu-small/source/i18n/unicode/dcfmtsym.h
+++ b/deps/icu-small/source/i18n/unicode/dcfmtsym.h
@@ -378,7 +378,7 @@ private:
      *                             back to the locale.
      */
     void initialize(const Locale& locale, UErrorCode& success,
-        UBool useLastResortData = FALSE, const NumberingSystem* ns = nullptr);
+                    UBool useLastResortData = false, const NumberingSystem* ns = nullptr);
 
     /**
      * Initialize the symbols with default values.
@@ -446,7 +446,7 @@ public:
     inline const UnicodeString& getConstDigitSymbol(int32_t digit) const;
 
     /**
-     * Returns that pattern stored in currecy info. Internal API for use by NumberFormat API.
+     * Returns that pattern stored in currency info. Internal API for use by NumberFormat API.
      * @internal
      */
     inline const char16_t* getCurrencyPattern(void) const;
@@ -543,12 +543,12 @@ inline const UnicodeString& DecimalFormatSymbols::getConstDigitSymbol(int32_t di
 // -------------------------------------
 
 inline void
-DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value, const UBool propogateDigits = TRUE) {
+DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value, const UBool propagateDigits = true) {
     if (symbol == kCurrencySymbol) {
-        fIsCustomCurrencySymbol = TRUE;
+        fIsCustomCurrencySymbol = true;
     }
     else if (symbol == kIntlCurrencySymbol) {
-        fIsCustomIntlCurrencySymbol = TRUE;
+        fIsCustomIntlCurrencySymbol = true;
     }
     if(symbol<kFormatSymbolCount) {
         fSymbols[symbol]=value;
@@ -559,7 +559,7 @@ DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, const UnicodeString
     // Also record updates to fCodePointZero. Be conservative if in doubt.
     if (symbol == kZeroDigitSymbol) {
         UChar32 sym = value.char32At(0);
-        if ( propogateDigits && u_charDigitValue(sym) == 0 && value.countChar32() == 1 ) {
+        if ( propagateDigits && u_charDigitValue(sym) == 0 && value.countChar32() == 1 ) {
             fCodePointZero = sym;
             for ( int8_t i = 1 ; i<= 9 ; i++ ) {
                 sym++;
diff --git a/deps/icu-small/source/i18n/unicode/decimfmt.h b/deps/icu-small/source/i18n/unicode/decimfmt.h
index b176ee78faca4928f16bdf76dddca37e9477ecf5..b0da8efb1e68b580f1253bd6b789fbfec430944a 100644
--- a/deps/icu-small/source/i18n/unicode/decimfmt.h
+++ b/deps/icu-small/source/i18n/unicode/decimfmt.h
@@ -564,11 +564,11 @@ class NumberParserImpl;
  *
  * <li>In order to enable significant digits formatting, use a pattern
  * containing the <code>'@'</code> pattern character.  Alternatively,
- * call setSignificantDigitsUsed(TRUE).
+ * call setSignificantDigitsUsed(true).
  *
  * <li>In order to disable significant digits formatting, use a
  * pattern that does not contain the <code>'@'</code> pattern
- * character. Alternatively, call setSignificantDigitsUsed(FALSE).
+ * character. Alternatively, call setSignificantDigitsUsed(false).
  *
  * <li>The number of significant digits has no effect on parsing.
  *
@@ -817,8 +817,8 @@ class U_I18N_API DecimalFormat : public NumberFormat {
     /**
      * Sets whether lenient parsing should be enabled (it is off by default).
      *
-     * @param enable \c TRUE if lenient parsing should be used,
-     *               \c FALSE otherwise.
+     * @param enable \c true if lenient parsing should be used,
+     *               \c false otherwise.
      * @stable ICU 4.8
      */
     void setLenient(UBool enable) U_OVERRIDE;
@@ -1507,7 +1507,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
 
     /**
      * Return whether or not scientific notation is used.
-     * @return TRUE if this object formats and parses scientific notation
+     * @return true if this object formats and parses scientific notation
      * @see #setScientificNotation
      * @see #getMinimumExponentDigits
      * @see #setMinimumExponentDigits
@@ -1523,7 +1523,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
      * maximum number of integer digits is set to more than 8, the effective
      * maximum will be 1.  This allows this call to generate a 'default' scientific
      * number format without additional changes.
-     * @param useScientific TRUE if this object formats and parses scientific
+     * @param useScientific true if this object formats and parses scientific
      * notation
      * @see #isScientificNotation
      * @see #getMinimumExponentDigits
@@ -1562,7 +1562,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
 
     /**
      * Return whether the exponent sign is always shown.
-     * @return TRUE if the exponent is always prefixed with either the
+     * @return true if the exponent is always prefixed with either the
      * localized minus sign or the localized plus sign, false if only negative
      * exponents are prefixed with the localized minus sign.
      * @see #setScientificNotation
@@ -1577,7 +1577,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
     /**
      * Set whether the exponent sign is always shown.  This has no effect
      * unless scientific notation is in use.
-     * @param expSignAlways TRUE if the exponent is always prefixed with either
+     * @param expSignAlways true if the exponent is always prefixed with either
      * the localized minus sign or the localized plus sign, false if only
      * negative exponents are prefixed with the localized minus sign.
      * @see #setScientificNotation
@@ -1674,8 +1674,15 @@ class U_I18N_API DecimalFormat : public NumberFormat {
     int32_t getMinimumGroupingDigits() const;
 
     /**
-     * Sets the minimum grouping digits. Setting to a value less than or
-     * equal to 1 turns off minimum grouping digits.
+     * Sets the minimum grouping digits. Setting the value to
+     *  - 1: Turns off minimum grouping digits.
+     *  - 0 or -1: The behavior is undefined.
+     *  - UNUM_MINIMUM_GROUPING_DIGITS_AUTO: Display grouping using the default
+     *      strategy for all locales.
+     *  - UNUM_MINIMUM_GROUPING_DIGITS_MIN2: Display grouping using locale
+     *      defaults, except do not show grouping on values smaller than 10000
+     *      (such that there is a minimum of two digits before the first
+     *      separator).
      *
      * For more control over grouping strategies, use NumberFormatter.
      *
@@ -1689,7 +1696,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
      * Allows you to get the behavior of the decimal separator with integers.
      * (The decimal separator will always appear with decimals.)
      *
-     * @return    TRUE if the decimal separator always appear with decimals.
+     * @return    true if the decimal separator always appear with decimals.
      * Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
      * @stable ICU 2.0
      */
@@ -1699,7 +1706,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
      * Allows you to set the behavior of the decimal separator with integers.
      * (The decimal separator will always appear with decimals.)
      *
-     * @param newValue    set TRUE if the decimal separator will always appear with decimals.
+     * @param newValue    set true if the decimal separator will always appear with decimals.
      * Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
      * @stable ICU 2.0
      */
@@ -1708,7 +1715,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
     /**
      * Allows you to get the parse behavior of the pattern decimal mark.
      *
-     * @return    TRUE if input must contain a match to decimal mark in pattern
+     * @return    true if input must contain a match to decimal mark in pattern
      * @stable ICU 54
      */
     UBool isDecimalPatternMatchRequired(void) const;
@@ -1716,10 +1723,10 @@ class U_I18N_API DecimalFormat : public NumberFormat {
     /**
      * Allows you to set the parse behavior of the pattern decimal mark.
      *
-     * if TRUE, the input must have a decimal mark if one was specified in the pattern. When
-     * FALSE the decimal mark may be omitted from the input.
+     * if true, the input must have a decimal mark if one was specified in the pattern. When
+     * false the decimal mark may be omitted from the input.
      *
-     * @param newValue    set TRUE if input must contain a match to decimal mark in pattern
+     * @param newValue    set true if input must contain a match to decimal mark in pattern
      * @stable ICU 54
      */
     virtual void setDecimalPatternMatchRequired(UBool newValue);
@@ -1962,7 +1969,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
      * to one.  If the maximum significant digits count is less than
      * <code>min</code>, then it is set to <code>min</code>.
      * This function also enables the use of significant digits
-     * by this formatter - areSignificantDigitsUsed() will return TRUE.
+     * by this formatter - areSignificantDigitsUsed() will return true.
      * @see #areSignificantDigitsUsed
      * @param min the fewest significant digits to be shown
      * @stable ICU 3.0
@@ -1975,7 +1982,7 @@ class U_I18N_API DecimalFormat : public NumberFormat {
      * to one.  If the minimum significant digits count is greater
      * than <code>max</code>, then it is set to <code>max</code>.
      * This function also enables the use of significant digits
-     * by this formatter - areSignificantDigitsUsed() will return TRUE.
+     * by this formatter - areSignificantDigitsUsed() will return true.
      * @see #areSignificantDigitsUsed
      * @param max the most significant digits to be shown
      * @stable ICU 3.0
diff --git a/deps/icu-small/source/i18n/unicode/dtfmtsym.h b/deps/icu-small/source/i18n/unicode/dtfmtsym.h
index f9ec88272b2b5ce26a0ffd9b54cd135a35cbf848..f368eaef551434afacbeb27b6d3879a11a9fe635 100644
--- a/deps/icu-small/source/i18n/unicode/dtfmtsym.h
+++ b/deps/icu-small/source/i18n/unicode/dtfmtsym.h
@@ -919,7 +919,8 @@ private:
      *                             failure code upon return.
      * @param useLastResortData    determine if use last resort data
      */
-    void initializeData(const Locale& locale, const char *type, UErrorCode& status, UBool useLastResortData = FALSE);
+    void initializeData(const Locale& locale, const char *type,
+                        UErrorCode& status, UBool useLastResortData = false);
 
     /**
      * Copy or alias an array in another object, as appropriate.
@@ -983,12 +984,12 @@ private:
     static UDateFormatField U_EXPORT2 getPatternCharIndex(char16_t c);
 
     /**
-     * Returns TRUE if f (with its pattern character repeated count times) is a numeric field.
+     * Returns true if f (with its pattern character repeated count times) is a numeric field.
      */
     static UBool U_EXPORT2 isNumericField(UDateFormatField f, int32_t count);
 
     /**
-     * Returns TRUE if c (repeated count times) is the pattern character for a numeric field.
+     * Returns true if c (repeated count times) is the pattern character for a numeric field.
      */
     static UBool U_EXPORT2 isNumericPatternChar(char16_t c, int32_t count);
 public:
diff --git a/deps/icu-small/source/i18n/unicode/dtitvfmt.h b/deps/icu-small/source/i18n/unicode/dtitvfmt.h
index 4e4d712b4f5b5cc7b4ce24bfc036d177d8d9f76d..4a1ab801a04c9db51f19cd7aa94018847a0ff9ce 100644
--- a/deps/icu-small/source/i18n/unicode/dtitvfmt.h
+++ b/deps/icu-small/source/i18n/unicode/dtitvfmt.h
@@ -31,6 +31,7 @@
 #include "unicode/dtitvinf.h"
 #include "unicode/dtptngen.h"
 #include "unicode/formattedvalue.h"
+#include "unicode/udisplaycontext.h"
 
 U_NAMESPACE_BEGIN
 
@@ -651,6 +652,34 @@ public:
      */
     virtual void setTimeZone(const TimeZone& zone);
 
+#ifndef U_FORCE_HIDE_DRAFT_API
+    /**
+     * Set a particular UDisplayContext value in the formatter, such as
+     * UDISPCTX_CAPITALIZATION_FOR_STANDALONE. This causes the formatted
+     * result to be capitalized appropriately for the context in which
+     * it is intended to be used, considering both the locale and the
+     * type of field at the beginning of the formatted result.
+     * @param value The UDisplayContext value to set.
+     * @param status Input/output status. If at entry this indicates a failure
+     *               status, the function will do nothing; otherwise this will be
+     *               updated with any new status from the function.
+     * @draft ICU 68
+     */
+    virtual void setContext(UDisplayContext value, UErrorCode& status);
+
+    /**
+     * Get the formatter's UDisplayContext value for the specified UDisplayContextType,
+     * such as UDISPCTX_TYPE_CAPITALIZATION.
+     * @param type The UDisplayContextType whose value to return
+     * @param status Input/output status. If at entry this indicates a failure
+     *               status, the function will do nothing; otherwise this will be
+     *               updated with any new status from the function.
+     * @return The UDisplayContextValue for the specified type.
+     * @draft ICU 68
+     */
+    virtual UDisplayContext getContext(UDisplayContextType type, UErrorCode& status) const;
+#endif  // U_FORCE_HIDE_DRAFT_API
+
     /**
      * Return the class ID for this class. This is useful only for comparing to
      * a return value from getDynamicClassID(). For example:
@@ -796,7 +825,7 @@ private:
      *                          to be formatted into date interval string
      * @param toCalendar        calendar set to the to date in date interval
      *                          to be formatted into date interval string
-     * @param fromToOnSameDay   TRUE iff from and to dates are on the same day
+     * @param fromToOnSameDay   true iff from and to dates are on the same day
      *                          (any difference is in ampm/hours or below)
      * @param appendTo          Output parameter to receive result.
      *                          Result is appended to existing contents.
@@ -867,6 +896,19 @@ private:
 
 
 
+    /**
+     * Converts special hour metacharacters (such as 'j') in the skeleton into locale-appropriate
+     * pattern characters.
+     *
+     *
+     *  @param skeleton               The skeleton to convert
+     *  @return A copy of the skeleton, which "j" and any other special hour metacharacters converted to the regular ones.
+     *
+     */
+    UnicodeString normalizeHourMetacharacters(const UnicodeString& skeleton) const;
+
+
+
     /**
      * get separated date and time skeleton from a combined skeleton.
      *
@@ -919,8 +961,8 @@ private:
      * @param dateSkeleton   normalized date skeleton
      * @param timeSkeleton   normalized time skeleton
      * @return               whether the resource is found for the skeleton.
-     *                       TRUE if interval pattern found for the skeleton,
-     *                       FALSE otherwise.
+     *                       true if interval pattern found for the skeleton,
+     *                       false otherwise.
      */
     UBool setSeparateDateTimePtn(const UnicodeString& dateSkeleton,
                                  const UnicodeString& timeSkeleton);
@@ -948,8 +990,8 @@ private:
      * @param extendedBestSkeleton  extended best match skeleton
      * @return                      whether the interval pattern is found
      *                              through extending skeleton or not.
-     *                              TRUE if interval pattern is found by
-     *                              extending skeleton, FALSE otherwise.
+     *                              true if interval pattern is found by
+     *                              extending skeleton, false otherwise.
      */
     UBool setIntervalPattern(UCalendarDateFields field,
                              const UnicodeString* skeleton,
@@ -984,6 +1026,7 @@ private:
      * @param differenceInfo           the difference between 2 skeletons
      *                                 1 means only field width differs
      *                                 2 means v/z exchange
+     * @param suppressDayPeriodField if true, remove the day period field from the pattern, if there is one
      * @param adjustedIntervalPattern  adjusted interval pattern
      */
     static void U_EXPORT2 adjustFieldWidth(
@@ -991,8 +1034,20 @@ private:
                             const UnicodeString& bestMatchSkeleton,
                             const UnicodeString& bestMatchIntervalPattern,
                             int8_t differenceInfo,
+                            UBool suppressDayPeriodField,
                             UnicodeString& adjustedIntervalPattern);
 
+    /**
+     * Does the same thing as UnicodeString::findAndReplace(), except that it won't perform
+     * the substitution inside quoted literal text.
+     * @param targetString The string to perform the find-replace operation on.
+     * @param strToReplace The string to search for and replace in the target string.
+     * @param strToReplaceWith The string to substitute in wherever `stringToReplace` was found.
+     */
+    static void U_EXPORT2 findReplaceInPattern(UnicodeString& targetString,
+                                               const UnicodeString& strToReplace,
+                                               const UnicodeString& strToReplaceWith);
+
     /**
      * Concat a single date pattern with a time interval pattern,
      * set it into the intervalPatterns, while field is time field.
@@ -1137,6 +1192,11 @@ private:
     UnicodeString* fDatePattern;
     UnicodeString* fTimePattern;
     UnicodeString* fDateTimeFormat;
+
+    /**
+     * Other formatting information
+     */
+    UDisplayContext fCapitalizationContext;
 };
 
 inline UBool
diff --git a/deps/icu-small/source/i18n/unicode/dtitvinf.h b/deps/icu-small/source/i18n/unicode/dtitvinf.h
index 50e19abb4ce2cbd85ca48c63f7a7b6fa04fd570d..8452614bfb8d87fd72c8f7f988ddaa8a28d3f162 100644
--- a/deps/icu-small/source/i18n/unicode/dtitvinf.h
+++ b/deps/icu-small/source/i18n/unicode/dtitvinf.h
@@ -307,8 +307,8 @@ public:
 
     /** Get default order -- whether the first date in pattern is later date
                              or not.
-     * return default date ordering in interval pattern. TRUE if the first date
-     *        in pattern is later date, FALSE otherwise.
+     * return default date ordering in interval pattern. true if the first date
+     *        in pattern is later date, false otherwise.
      * @stable ICU 4.0
      */
     UBool getDefaultOrder() const;
diff --git a/deps/icu-small/source/i18n/unicode/dtptngen.h b/deps/icu-small/source/i18n/unicode/dtptngen.h
index f79c6d45dc6b2967f1f5ab85c6c21274cbfa40b4..dab7dcfb3dc61acbafcd610da96cda260c941dba 100644
--- a/deps/icu-small/source/i18n/unicode/dtptngen.h
+++ b/deps/icu-small/source/i18n/unicode/dtptngen.h
@@ -76,6 +76,13 @@ public:
 
 #ifndef U_HIDE_INTERNAL_API
 
+    /**
+     * For ICU use only. Skips loading the standard date/time patterns (which is done via DateFormat).
+     *
+     * @internal
+     */
+    static DateTimePatternGenerator* U_EXPORT2 createInstanceNoStdPat(const Locale& uLocale, UErrorCode& status);
+
     /**
      * For ICU use only
      *
@@ -485,7 +492,6 @@ public:
 
 #if !UCONFIG_NO_FORMATTING
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Get the default hour cycle for a locale. Uses the locale that the
      * DateTimePatternGenerator was initially created with.
@@ -496,10 +502,9 @@ public:
      *                which must not indicate a failure before the function call.
      *                Set to U_UNSUPPORTED_ERROR if used on an empty instance.
      * @return the default hour cycle.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UDateFormatHourCycle getDefaultHourCycle(UErrorCode& status) const;
-#endif  /* U_HIDE_DRAFT_API */
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
@@ -526,7 +531,7 @@ private:
     /**
      * Constructor.
      */
-    DateTimePatternGenerator(const Locale& locale, UErrorCode & status);
+    DateTimePatternGenerator(const Locale& locale, UErrorCode & status, UBool skipStdPatterns = false);
 
     /**
      * Copy constructor.
@@ -573,7 +578,7 @@ private:
         // with #13183, no longer need flags for b, B
     };
 
-    void initData(const Locale &locale, UErrorCode &status);
+    void initData(const Locale &locale, UErrorCode &status, UBool skipStdPatterns = false);
     void addCanonicalItems(UErrorCode &status);
     void addICUPatterns(const Locale& locale, UErrorCode& status);
     void hackTimes(const UnicodeString& hackPattern, UErrorCode& status);
diff --git a/deps/icu-small/source/i18n/unicode/fieldpos.h b/deps/icu-small/source/i18n/unicode/fieldpos.h
index c9849d67a37d29da40dc9c3d37ed173ad06b7846..6c28d2d3159b66766e4b0fac5472f353aed44a14 100644
--- a/deps/icu-small/source/i18n/unicode/fieldpos.h
+++ b/deps/icu-small/source/i18n/unicode/fieldpos.h
@@ -161,7 +161,7 @@ public:
     /**
      * Equality operator.
      * @param that    the object to be compared with.
-     * @return        TRUE if the two field positions are equal, FALSE otherwise.
+     * @return        true if the two field positions are equal, false otherwise.
      * @stable ICU 2.0
      */
     UBool              operator==(const FieldPosition& that) const;
@@ -169,7 +169,7 @@ public:
     /**
      * Equality operator.
      * @param that    the object to be compared with.
-     * @return        TRUE if the two field positions are not equal, FALSE otherwise.
+     * @return        true if the two field positions are not equal, false otherwise.
      * @stable ICU 2.0
      */
     UBool              operator!=(const FieldPosition& that) const;
diff --git a/deps/icu-small/source/i18n/unicode/fmtable.h b/deps/icu-small/source/i18n/unicode/fmtable.h
index 7bec4f6906e7ee4e1de0e8eb26192115a0796c6f..3a090393ac4bec545e768af6cfb4263e7f4242ce 100644
--- a/deps/icu-small/source/i18n/unicode/fmtable.h
+++ b/deps/icu-small/source/i18n/unicode/fmtable.h
@@ -179,7 +179,7 @@ public:
     /**
      * Equality comparison.
      * @param other    the object to be compared with.
-     * @return        TRUE if other are equal to this, FALSE otherwise.
+     * @return        true if other are equal to this, false otherwise.
      * @stable ICU 2.0
      */
     UBool          operator==(const Formattable &other) const;
@@ -187,7 +187,7 @@ public:
     /**
      * Equality operator.
      * @param other    the object to be compared with.
-     * @return        TRUE if other are unequal to this, FALSE otherwise.
+     * @return        true if other are unequal to this, false otherwise.
      * @stable ICU 2.0
      */
     UBool          operator!=(const Formattable& other) const
@@ -277,9 +277,9 @@ public:
     Type            getType(void) const;
 
     /**
-     * Returns TRUE if the data type of this Formattable object
+     * Returns true if the data type of this Formattable object
      * is kDouble, kLong, or kInt64
-     * @return TRUE if this is a pure numeric object
+     * @return true if this is a pure numeric object
      * @stable ICU 3.0
      */
     UBool           isNumeric() const;
diff --git a/deps/icu-small/source/i18n/unicode/formattedvalue.h b/deps/icu-small/source/i18n/unicode/formattedvalue.h
index 4469b6328e7cb9bdd6306f96462e9ec02c6d29f4..f4e588d01cbddf48c7948439a46b21fc9abab982 100644
--- a/deps/icu-small/source/i18n/unicode/formattedvalue.h
+++ b/deps/icu-small/source/i18n/unicode/formattedvalue.h
@@ -116,7 +116,7 @@ class U_I18N_API ConstrainedFieldPosition : public UMemory {
      * Gets the field category for the current position.
      *
      * The return value is well-defined only after
-     * FormattedValue#nextPosition returns TRUE.
+     * FormattedValue#nextPosition returns true.
      *
      * @return The field category saved in the instance.
      * @stable ICU 64
@@ -129,7 +129,7 @@ class U_I18N_API ConstrainedFieldPosition : public UMemory {
      * Gets the field for the current position.
      *
      * The return value is well-defined only after
-     * FormattedValue#nextPosition returns TRUE.
+     * FormattedValue#nextPosition returns true.
      *
      * @return The field saved in the instance.
      * @stable ICU 64
@@ -141,7 +141,7 @@ class U_I18N_API ConstrainedFieldPosition : public UMemory {
     /**
      * Gets the INCLUSIVE start index for the current position.
      *
-     * The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
+     * The return value is well-defined only after FormattedValue#nextPosition returns true.
      *
      * @return The start index saved in the instance.
      * @stable ICU 64
@@ -153,7 +153,7 @@ class U_I18N_API ConstrainedFieldPosition : public UMemory {
     /**
      * Gets the EXCLUSIVE end index stored for the current position.
      *
-     * The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
+     * The return value is well-defined only after FormattedValue#nextPosition returns true.
      *
      * @return The end index saved in the instance.
      * @stable ICU 64
@@ -301,8 +301,8 @@ class U_I18N_API FormattedValue /* not : public UObject because this is an inter
      *         see ConstrainedFieldPosition#constrainCategory
      *         and ConstrainedFieldPosition#constrainField.
      * @param status Set if an error occurs.
-     * @return TRUE if a new occurrence of the field was found;
-     *         FALSE otherwise or if an error was set.
+     * @return true if a new occurrence of the field was found;
+     *         false otherwise or if an error was set.
      *
      * @stable ICU 64
      */
diff --git a/deps/icu-small/source/i18n/unicode/fpositer.h b/deps/icu-small/source/i18n/unicode/fpositer.h
index ba2a838315c7cb65ee6495503bd0e9cc964f9784..35aa5da20f2cfaa9dbdb139d1b5b21dc5de4684e 100644
--- a/deps/icu-small/source/i18n/unicode/fpositer.h
+++ b/deps/icu-small/source/i18n/unicode/fpositer.h
@@ -96,7 +96,7 @@ public:
 
     /**
      * If the current position is valid, updates the FieldPosition values, advances the iterator,
-     * and returns TRUE, otherwise returns FALSE.
+     * and returns true, otherwise returns false.
      * @stable ICU 4.4
      */
     UBool next(FieldPosition& fp);
diff --git a/deps/icu-small/source/i18n/unicode/gregocal.h b/deps/icu-small/source/i18n/unicode/gregocal.h
index 236bd003c160a6df43c30959ca983949048263ff..139258d822a30ca7228a3ada9dd301bd9a254cf7 100644
--- a/deps/icu-small/source/i18n/unicode/gregocal.h
+++ b/deps/icu-small/source/i18n/unicode/gregocal.h
@@ -344,7 +344,7 @@ public:
     UBool isLeapYear(int32_t year) const;
 
     /**
-     * Returns TRUE if the given Calendar object is equivalent to this
+     * Returns true if the given Calendar object is equivalent to this
      * one.  Calendar override.
      *
      * @param other the Calendar to be compared with this Calendar
@@ -756,7 +756,7 @@ public:
  public: // internal implementation
 
     /**
-     * @return TRUE if this calendar has the notion of a default century
+     * @return true if this calendar has the notion of a default century
      * @internal
      */
     virtual UBool haveDefaultCentury() const;
diff --git a/deps/icu-small/source/i18n/unicode/listformatter.h b/deps/icu-small/source/i18n/unicode/listformatter.h
index a969a8744dcf586ba76bdfc48d8da417d6a4a160..3cc750c83874991f5e8d6815d39fe4f0efc26cbf 100644
--- a/deps/icu-small/source/i18n/unicode/listformatter.h
+++ b/deps/icu-small/source/i18n/unicode/listformatter.h
@@ -23,6 +23,8 @@
 
 #if U_SHOW_CPLUSPLUS_API
 
+#if !UCONFIG_NO_FORMATTING
+
 #include "unicode/unistr.h"
 #include "unicode/locid.h"
 #include "unicode/formattedvalue.h"
@@ -65,7 +67,6 @@ struct ListFormatData : public UMemory {
  */
 
 
-#if !UCONFIG_NO_FORMATTING
 /**
  * An immutable class containing the result of a list formatting operation.
  *
@@ -135,7 +136,6 @@ class U_I18N_API FormattedList : public UMemory, public FormattedValue {
         : fData(nullptr), fErrorCode(errorCode) {}
     friend class ListFormatter;
 };
-#endif // !UCONFIG_NO_FORMATTING
 
 
 /**
@@ -185,8 +185,6 @@ class U_I18N_API ListFormatter : public UObject{
      */
     static ListFormatter* createInstance(const Locale& locale, UErrorCode& errorCode);
 
-#ifndef U_HIDE_DRAFT_API
-#if !UCONFIG_NO_FORMATTING
     /**
      * Creates a ListFormatter for the given locale, list type, and style.
      *
@@ -195,28 +193,10 @@ class U_I18N_API ListFormatter : public UObject{
      * @param width The width of formatting to use.
      * @param errorCode ICU error code, set if no data available for the given locale.
      * @return A ListFormatter object created from internal data derived from CLDR data.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     static ListFormatter* createInstance(
       const Locale& locale, UListFormatterType type, UListFormatterWidth width, UErrorCode& errorCode);
-#endif  /* !UCONFIG_NO_FORMATTING */
-#endif  /* U_HIDE_DRAFT_API */
-
-#ifndef U_HIDE_INTERNAL_API
-    /**
-     * Creates a ListFormatter appropriate for a locale and style.
-     *
-     * TODO(ICU-20888): Remove this in ICU 68.
-     *
-     * @param locale The locale.
-     * @param style the style, either "standard", "or", "unit", "unit-narrow", or "unit-short"
-     * @param errorCode ICU error code, set if no data available for the given locale.
-     * @return A ListFormatter object created from internal data derived from
-     *     CLDR data.
-     * @internal
-     */
-    static ListFormatter* createInstance(const Locale& locale, const char* style, UErrorCode& errorCode);
-#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Destructor.
@@ -239,7 +219,6 @@ class U_I18N_API ListFormatter : public UObject{
     UnicodeString& format(const UnicodeString items[], int32_t n_items,
         UnicodeString& appendTo, UErrorCode& errorCode) const;
 
-#if !UCONFIG_NO_FORMATTING
     /**
      * Formats a list of strings to a FormattedList, which exposes field
      * position information. The FormattedList contains more information than
@@ -255,7 +234,6 @@ class U_I18N_API ListFormatter : public UObject{
         const UnicodeString items[],
         int32_t n_items,
         UErrorCode& errorCode) const;
-#endif // !UCONFIG_NO_FORMATTING
 
 #ifndef U_HIDE_INTERNAL_API
     /**
@@ -279,6 +257,15 @@ class U_I18N_API ListFormatter : public UObject{
 #endif  /* U_HIDE_INTERNAL_API */
 
   private:
+
+    /**
+     * Creates a ListFormatter appropriate for a locale and style.
+     *
+     * @param locale The locale.
+     * @param style the style, either "standard", "or", "unit", "unit-narrow", or "unit-short"
+     */
+    static ListFormatter* createInstance(const Locale& locale, const char* style, UErrorCode& errorCode);
+
     static void initializeHash(UErrorCode& errorCode);
     static const ListFormatInternal* getListFormatInternal(const Locale& locale, const char *style, UErrorCode& errorCode);
     struct ListPatternsSink;
@@ -296,6 +283,8 @@ class U_I18N_API ListFormatter : public UObject{
 
 U_NAMESPACE_END
 
+#endif /* #if !UCONFIG_NO_FORMATTING */
+
 #endif /* U_SHOW_CPLUSPLUS_API */
 
 #endif // __LISTFORMATTER_H__
diff --git a/deps/icu-small/source/i18n/unicode/measfmt.h b/deps/icu-small/source/i18n/unicode/measfmt.h
index 8f73de87fa55d63c2500fdc6e4f6b7202b21380a..f48dada2abf02af6d6d8f3060e147a71ee191b34 100644
--- a/deps/icu-small/source/i18n/unicode/measfmt.h
+++ b/deps/icu-small/source/i18n/unicode/measfmt.h
@@ -91,7 +91,8 @@ class DateFormat;
 /**
  * <p><strong>IMPORTANT:</strong> New users are strongly encouraged to see if
  * numberformatter.h fits their use case.  Although not deprecated, this header
- * is provided for backwards compatibility only.
+ * is provided for backwards compatibility only, and has much more limited
+ * capabilities.
  *
  * @see Format
  * @author Alan Liu
@@ -309,7 +310,7 @@ class U_I18N_API MeasureFormat : public Format {
     /**
      * ICU use only.
      * Allows subclass to change locale. Note that this method also changes
-     * the NumberFormat object. Returns TRUE if locale changed; FALSE if no
+     * the NumberFormat object. Returns true if locale changed; false if no
      * change was made.
      * @internal.
      */
diff --git a/deps/icu-small/source/i18n/unicode/measunit.h b/deps/icu-small/source/i18n/unicode/measunit.h
index 8b65497e12eb63f3d3b1d33bf54f26188996b9ac..0985ba0706eaa44a0c16081af81ad96ece8ed994 100644
--- a/deps/icu-small/source/i18n/unicode/measunit.h
+++ b/deps/icu-small/source/i18n/unicode/measunit.h
@@ -30,201 +30,333 @@
 U_NAMESPACE_BEGIN
 
 class StringEnumeration;
-struct MeasureUnitImpl;
+class MeasureUnitImpl;
+
+namespace number {
+namespace impl {
+class LongNameHandler;
+}
+} // namespace number
 
-#ifndef U_HIDE_DRAFT_API
 /**
  * Enumeration for unit complexity. There are three levels:
  *
- * - SINGLE: A single unit, optionally with a power and/or SI prefix. Examples: hectare,
- *           square-kilometer, kilojoule, per-second.
+ * - SINGLE: A single unit, optionally with a power and/or SI or binary prefix.
+ *           Examples: hectare, square-kilometer, kilojoule, per-second, mebibyte.
  * - COMPOUND: A unit composed of the product of multiple single units. Examples:
  *             meter-per-second, kilowatt-hour, kilogram-meter-per-square-second.
  * - MIXED: A unit composed of the sum of multiple single units. Examples: foot+inch,
  *          hour+minute+second, degree+arcminute+arcsecond.
  *
  * The complexity determines which operations are available. For example, you cannot set the power
- * or SI prefix of a compound unit.
+ * or prefix of a compound unit.
  *
- * @draft ICU 67
+ * @stable ICU 67
  */
 enum UMeasureUnitComplexity {
     /**
      * A single unit, like kilojoule.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UMEASURE_UNIT_SINGLE,
 
     /**
      * A compound unit, like meter-per-second.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UMEASURE_UNIT_COMPOUND,
 
     /**
      * A mixed unit, like hour+minute.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UMEASURE_UNIT_MIXED
 };
 
+
+#ifndef U_HIDE_DRAFT_API
 /**
- * Enumeration for SI prefixes, such as "kilo".
+ * Enumeration for SI and binary prefixes, e.g. "kilo-", "nano-", "mebi-".
+ *
+ * Enum values should be treated as opaque: use umeas_getPrefixPower() and
+ * umeas_getPrefixBase() to find their corresponding values.
  *
- * @draft ICU 67
+ * @draft ICU 69
+ * @see umeas_getPrefixBase
+ * @see umeas_getPrefixPower
  */
-typedef enum UMeasureSIPrefix {
+typedef enum UMeasurePrefix {
+    /**
+     * The absence of an SI or binary prefix.
+     *
+     * The integer representation of this enum value is an arbitrary
+     * implementation detail and should not be relied upon: use
+     * umeas_getPrefixPower() to obtain meaningful values.
+     *
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_ONE = 30 + 0,
 
     /**
      * SI prefix: yotta, 10^24.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_YOTTA = 24,
+    UMEASURE_PREFIX_YOTTA = UMEASURE_PREFIX_ONE + 24,
+
+    /**
+     * ICU use only.
+     * Used to determine the set of base-10 SI prefixes.
+     * @internal
+     */
+    UMEASURE_PREFIX_INTERNAL_MAX_SI = UMEASURE_PREFIX_YOTTA,
 
     /**
      * SI prefix: zetta, 10^21.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_ZETTA = 21,
+    UMEASURE_PREFIX_ZETTA = UMEASURE_PREFIX_ONE + 21,
 
     /**
      * SI prefix: exa, 10^18.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_EXA = 18,
+    UMEASURE_PREFIX_EXA = UMEASURE_PREFIX_ONE + 18,
 
     /**
      * SI prefix: peta, 10^15.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_PETA = 15,
+    UMEASURE_PREFIX_PETA = UMEASURE_PREFIX_ONE + 15,
 
     /**
      * SI prefix: tera, 10^12.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_TERA = 12,
+    UMEASURE_PREFIX_TERA = UMEASURE_PREFIX_ONE + 12,
 
     /**
      * SI prefix: giga, 10^9.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_GIGA = 9,
+    UMEASURE_PREFIX_GIGA = UMEASURE_PREFIX_ONE + 9,
 
     /**
      * SI prefix: mega, 10^6.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_MEGA = 6,
+    UMEASURE_PREFIX_MEGA = UMEASURE_PREFIX_ONE + 6,
 
     /**
      * SI prefix: kilo, 10^3.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_KILO = 3,
+    UMEASURE_PREFIX_KILO = UMEASURE_PREFIX_ONE + 3,
 
     /**
      * SI prefix: hecto, 10^2.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_HECTO = 2,
+    UMEASURE_PREFIX_HECTO = UMEASURE_PREFIX_ONE + 2,
 
     /**
      * SI prefix: deka, 10^1.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_DEKA = 1,
-
-    /**
-     * The absence of an SI prefix.
-     *
-     * @draft ICU 67
-     */
-    UMEASURE_SI_PREFIX_ONE = 0,
+    UMEASURE_PREFIX_DEKA = UMEASURE_PREFIX_ONE + 1,
 
     /**
      * SI prefix: deci, 10^-1.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_DECI = -1,
+    UMEASURE_PREFIX_DECI = UMEASURE_PREFIX_ONE + -1,
 
     /**
      * SI prefix: centi, 10^-2.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_CENTI = -2,
+    UMEASURE_PREFIX_CENTI = UMEASURE_PREFIX_ONE + -2,
 
     /**
      * SI prefix: milli, 10^-3.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_MILLI = -3,
+    UMEASURE_PREFIX_MILLI = UMEASURE_PREFIX_ONE + -3,
 
     /**
      * SI prefix: micro, 10^-6.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_MICRO = -6,
+    UMEASURE_PREFIX_MICRO = UMEASURE_PREFIX_ONE + -6,
 
     /**
      * SI prefix: nano, 10^-9.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_NANO = -9,
+    UMEASURE_PREFIX_NANO = UMEASURE_PREFIX_ONE + -9,
 
     /**
      * SI prefix: pico, 10^-12.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_PICO = -12,
+    UMEASURE_PREFIX_PICO = UMEASURE_PREFIX_ONE + -12,
 
     /**
      * SI prefix: femto, 10^-15.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_FEMTO = -15,
+    UMEASURE_PREFIX_FEMTO = UMEASURE_PREFIX_ONE + -15,
 
     /**
      * SI prefix: atto, 10^-18.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_ATTO = -18,
+    UMEASURE_PREFIX_ATTO = UMEASURE_PREFIX_ONE + -18,
 
     /**
      * SI prefix: zepto, 10^-21.
      *
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_ZEPTO = -21,
+    UMEASURE_PREFIX_ZEPTO = UMEASURE_PREFIX_ONE + -21,
 
     /**
      * SI prefix: yocto, 10^-24.
      *
-     * @draft ICU 67
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_YOCTO = UMEASURE_PREFIX_ONE + -24,
+
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * ICU use only.
+     * Used to determine the set of base-10 SI prefixes.
+     * @internal
+     */
+    UMEASURE_PREFIX_INTERNAL_MIN_SI = UMEASURE_PREFIX_YOCTO,
+#endif  // U_HIDE_INTERNAL_API
+
+    // Cannot conditionalize the following with #ifndef U_HIDE_INTERNAL_API,
+    // used in definitions of non-internal enum values
+    /**
+     * ICU use only.
+     * Sets the arbitrary offset of the base-1024 binary prefixes' enum values.
+     * @internal
+     */
+    UMEASURE_PREFIX_INTERNAL_ONE_BIN = -60,
+
+    /**
+     * Binary prefix: kibi, 1024^1.
+     *
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_KIBI = UMEASURE_PREFIX_INTERNAL_ONE_BIN + 1,
+
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * ICU use only.
+     * Used to determine the set of base-1024 binary prefixes.
+     * @internal
+     */
+    UMEASURE_PREFIX_INTERNAL_MIN_BIN = UMEASURE_PREFIX_KIBI,
+#endif  // U_HIDE_INTERNAL_API
+
+    /**
+     * Binary prefix: mebi, 1024^2.
+     *
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_MEBI = UMEASURE_PREFIX_INTERNAL_ONE_BIN + 2,
+
+    /**
+     * Binary prefix: gibi, 1024^3.
+     *
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_GIBI = UMEASURE_PREFIX_INTERNAL_ONE_BIN + 3,
+
+    /**
+     * Binary prefix: tebi, 1024^4.
+     *
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_TEBI = UMEASURE_PREFIX_INTERNAL_ONE_BIN + 4,
+
+    /**
+     * Binary prefix: pebi, 1024^5.
+     *
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_PEBI = UMEASURE_PREFIX_INTERNAL_ONE_BIN + 5,
+
+    /**
+     * Binary prefix: exbi, 1024^6.
+     *
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_EXBI = UMEASURE_PREFIX_INTERNAL_ONE_BIN + 6,
+
+    /**
+     * Binary prefix: zebi, 1024^7.
+     *
+     * @draft ICU 69
+     */
+    UMEASURE_PREFIX_ZEBI = UMEASURE_PREFIX_INTERNAL_ONE_BIN + 7,
+
+    /**
+     * Binary prefix: yobi, 1024^8.
+     *
+     * @draft ICU 69
      */
-    UMEASURE_SI_PREFIX_YOCTO = -24
-} UMeasureSIPrefix;
+    UMEASURE_PREFIX_YOBI = UMEASURE_PREFIX_INTERNAL_ONE_BIN + 8,
+
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * ICU use only.
+     * Used to determine the set of base-1024 binary prefixes.
+     * @internal
+     */
+    UMEASURE_PREFIX_INTERNAL_MAX_BIN = UMEASURE_PREFIX_YOBI,
+#endif  // U_HIDE_INTERNAL_API
+} UMeasurePrefix;
+
+/**
+ * Returns the base of the factor associated with the given unit prefix: the
+ * base is 10 for SI prefixes (kilo, micro) and 1024 for binary prefixes (kibi,
+ * mebi).
+ *
+ * @draft ICU 69
+ */
+U_CAPI int32_t U_EXPORT2 umeas_getPrefixBase(UMeasurePrefix unitPrefix);
+
+/**
+ * Returns the exponent of the factor associated with the given unit prefix, for
+ * example 3 for kilo, -6 for micro, 1 for kibi, 2 for mebi, 3 for gibi.
+ *
+ * @draft ICU 69
+ */
+U_CAPI int32_t U_EXPORT2 umeas_getPrefixPower(UMeasurePrefix unitPrefix);
+
 #endif // U_HIDE_DRAFT_API
 
 /**
@@ -250,27 +382,26 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     MeasureUnit(const MeasureUnit &other);
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Move constructor.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     MeasureUnit(MeasureUnit &&other) noexcept;
 
     /**
-     * Construct a MeasureUnit from a CLDR Unit Identifier, defined in UTS 35.
-     * Validates and canonicalizes the identifier.
+     * Construct a MeasureUnit from a CLDR Core Unit Identifier, defined in UTS
+     * 35. (Core unit identifiers and mixed unit identifiers are supported, long
+     * unit identifiers are not.) Validates and canonicalizes the identifier.
      *
      * <pre>
      * MeasureUnit example = MeasureUnit::forIdentifier("furlong-per-nanosecond")
      * </pre>
      *
-     * @param identifier The CLDR Unit Identifier
+     * @param identifier The CLDR Unit Identifier.
      * @param status Set if the identifier is invalid.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     static MeasureUnit forIdentifier(StringPiece identifier, UErrorCode& status);
-#endif // U_HIDE_DRAFT_API
 
     /**
      * Copy assignment operator.
@@ -278,13 +409,11 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     MeasureUnit &operator=(const MeasureUnit &other);
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Move assignment operator.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     MeasureUnit &operator=(MeasureUnit &&other) noexcept;
-#endif // U_HIDE_DRAFT_API
 
     /**
      * Returns a polymorphic clone of this object.  The result will
@@ -333,12 +462,11 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     const char *getSubtype() const;
 
-#ifndef U_HIDE_DRAFT_API
     /**
-     * Get the CLDR Unit Identifier for this MeasureUnit, as defined in UTS 35.
+     * Get CLDR Unit Identifier for this MeasureUnit, as defined in UTS 35.
      *
      * @return The string form of this unit, owned by this MeasureUnit.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     const char* getIdentifier() const;
 
@@ -347,38 +475,43 @@ class U_I18N_API MeasureUnit: public UObject {
      *
      * @param status Set if an error occurs.
      * @return The unit complexity.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UMeasureUnitComplexity getComplexity(UErrorCode& status) const;
 
+#ifndef U_HIDE_DRAFT_API
     /**
-     * Creates a MeasureUnit which is this SINGLE unit augmented with the specified SI prefix.
-     * For example, UMEASURE_SI_PREFIX_KILO for "kilo".
+     * Creates a MeasureUnit which is this SINGLE unit augmented with the specified prefix.
+     * For example, UMEASURE_PREFIX_KILO for "kilo", or UMEASURE_PREFIX_KIBI for "kibi".
      *
-     * There is sufficient locale data to format all standard SI prefixes.
+     * There is sufficient locale data to format all standard prefixes.
      *
      * NOTE: Only works on SINGLE units. If this is a COMPOUND or MIXED unit, an error will
      * occur. For more information, see UMeasureUnitComplexity.
      *
-     * @param prefix The SI prefix, from UMeasureSIPrefix.
+     * @param prefix The prefix, from UMeasurePrefix.
      * @param status Set if this is not a SINGLE unit or if another error occurs.
      * @return A new SINGLE unit.
-     * @draft ICU 67
+     * @draft ICU 69
      */
-    MeasureUnit withSIPrefix(UMeasureSIPrefix prefix, UErrorCode& status) const;
+    MeasureUnit withPrefix(UMeasurePrefix prefix, UErrorCode& status) const;
 
     /**
-     * Gets the current SI prefix of this SINGLE unit. For example, if the unit has the SI prefix
-     * "kilo", then UMEASURE_SI_PREFIX_KILO is returned.
+     * Returns the current SI or binary prefix of this SINGLE unit. For example,
+     * if the unit has the prefix "kilo", then UMEASURE_PREFIX_KILO is
+     * returned.
      *
      * NOTE: Only works on SINGLE units. If this is a COMPOUND or MIXED unit, an error will
      * occur. For more information, see UMeasureUnitComplexity.
      *
      * @param status Set if this is not a SINGLE unit or if another error occurs.
-     * @return The SI prefix of this SINGLE unit, from UMeasureSIPrefix.
-     * @draft ICU 67
+     * @return The prefix of this SINGLE unit, from UMeasurePrefix.
+     * @see umeas_getPrefixBase
+     * @see umeas_getPrefixPower
+     * @draft ICU 69
      */
-    UMeasureSIPrefix getSIPrefix(UErrorCode& status) const;
+    UMeasurePrefix getPrefix(UErrorCode& status) const;
+#endif // U_HIDE_DRAFT_API
 
     /**
      * Creates a MeasureUnit which is this SINGLE unit augmented with the specified dimensionality
@@ -392,7 +525,7 @@ class U_I18N_API MeasureUnit: public UObject {
      * @param dimensionality The dimensionality (power).
      * @param status Set if this is not a SINGLE unit or if another error occurs.
      * @return A new SINGLE unit.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     MeasureUnit withDimensionality(int32_t dimensionality, UErrorCode& status) const;
 
@@ -407,7 +540,7 @@ class U_I18N_API MeasureUnit: public UObject {
      *
      * @param status Set if this is not a SINGLE unit or if another error occurs.
      * @return The dimensionality (power) of this simple unit.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     int32_t getDimensionality(UErrorCode& status) const;
 
@@ -421,7 +554,7 @@ class U_I18N_API MeasureUnit: public UObject {
      *
      * @param status Set if this is a MIXED unit or if another error occurs.
      * @return The reciprocal of the target unit.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     MeasureUnit reciprocal(UErrorCode& status) const;
 
@@ -434,20 +567,19 @@ class U_I18N_API MeasureUnit: public UObject {
      * For example, if the receiver is "kilowatt" and the argument is "hour-per-day", then the
      * unit "kilowatt-hour-per-day" is returned.
      *
-     * NOTE: Only works on SINGLE and COMPOUND units. If either unit (receivee and argument) is a
+     * NOTE: Only works on SINGLE and COMPOUND units. If either unit (receiver and argument) is a
      * MIXED unit, an error will occur. For more information, see UMeasureUnitComplexity.
      *
      * @param other The MeasureUnit to multiply with the target.
      * @param status Set if this or other is a MIXED unit or if another error occurs.
      * @return The product of the target unit with the provided unit.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     MeasureUnit product(const MeasureUnit& other, UErrorCode& status) const;
-#endif // U_HIDE_DRAFT_API
 
-#ifndef U_HIDE_INTERNAL_API
+#ifndef U_HIDE_DRAFT_API
     /**
-     * Gets the list of SINGLE units contained within a MIXED of COMPOUND unit.
+     * Gets the list of SINGLE units contained within a MIXED or COMPOUND unit.
      *
      * Examples:
      * - Given "meter-kilogram-per-second", three units will be returned: "meter",
@@ -457,15 +589,12 @@ class U_I18N_API MeasureUnit: public UObject {
      *
      * If this is a SINGLE unit, an array of length 1 will be returned.
      *
-     * TODO(ICU-21021): Finalize this API and propose it as draft.
-     *
-     * @param outCount The number of elements in the return array.
      * @param status Set if an error occurs.
-     * @return An array of single units, owned by the caller.
-     * @internal ICU 67 Technical Preview
+     * @return A pair with the list of units as a LocalArray and the number of units in the list.
+     * @draft ICU 68
      */
-    LocalArray<MeasureUnit> splitToSingleUnits(int32_t& outCount, UErrorCode& status) const;
-#endif // U_HIDE_INTERNAL_API
+    inline std::pair<LocalArray<MeasureUnit>, int32_t> splitToSingleUnits(UErrorCode& status) const;
+#endif // U_HIDE_DRAFT_API
 
     /**
      * getAvailable gets all of the available units.
@@ -540,40 +669,17 @@ class U_I18N_API MeasureUnit: public UObject {
 #ifndef U_HIDE_INTERNAL_API
     /**
      * ICU use only.
-     * Returns associated array index for this measure unit. Only valid for
-     * non-currency measure units.
-     * @internal
-     */
-    int32_t getIndex() const;
-
-    /**
-     * ICU use only.
-     * Returns maximum value from getIndex plus 1.
-     * @internal
-     */
-    static int32_t getIndexCount();
-
-    /**
-     * ICU use only.
-     * @return the unit.getIndex() of the unit which has this unit.getType() and unit.getSubtype(),
-     *         or a negative value if there is no such unit
+     * Returns associated array index for this measure unit.
      * @internal
      */
-    static int32_t internalGetIndexForTypeAndSubtype(const char *type, const char *subtype);
-
-    /**
-     * ICU use only.
-     * @internal
-     */
-    static MeasureUnit resolveUnitPerUnit(
-            const MeasureUnit &unit, const MeasureUnit &perUnit, bool* isResolved);
+    int32_t getOffset() const;
 #endif /* U_HIDE_INTERNAL_API */
 
 // All code between the "Start generated createXXX methods" comment and
 // the "End generated createXXX methods" comment is auto generated code
 // and must not be edited manually. For instructions on how to correctly
 // update this code, refer to:
-// http://site.icu-project.org/design/formatting/measureformat/updating-measure-unit
+// docs/processes/release/tasks/updating-measure-unit.md
 //
 // Start generated createXXX methods
 
@@ -865,6 +971,24 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getKarat();
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of concentr: milligram-ofglucose-per-deciliter.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getMilligramOfglucosePerDeciliter()}.
+     * @param status ICU error code.
+     * @draft ICU 69
+     */
+    static MeasureUnit *createMilligramOfglucosePerDeciliter(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of concentr: milligram-ofglucose-per-deciliter.
+     * Also see {@link #createMilligramOfglucosePerDeciliter()}.
+     * @draft ICU 69
+     */
+    static MeasureUnit getMilligramOfglucosePerDeciliter();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of concentr: milligram-per-deciliter.
      * Caller owns returned value and must free it.
@@ -913,22 +1037,6 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getMole();
 
-    /**
-     * Returns by pointer, unit of concentr: permillion.
-     * Caller owns returned value and must free it.
-     * Also see {@link #getPartPerMillion()}.
-     * @param status ICU error code.
-     * @stable ICU 57
-     */
-    static MeasureUnit *createPartPerMillion(UErrorCode &status);
-
-    /**
-     * Returns by value, unit of concentr: permillion.
-     * Also see {@link #createPartPerMillion()}.
-     * @stable ICU 64
-     */
-    static MeasureUnit getPartPerMillion();
-
     /**
      * Returns by pointer, unit of concentr: percent.
      * Caller owns returned value and must free it.
@@ -961,6 +1069,22 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getPermille();
 
+    /**
+     * Returns by pointer, unit of concentr: permillion.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getPartPerMillion()}.
+     * @param status ICU error code.
+     * @stable ICU 57
+     */
+    static MeasureUnit *createPartPerMillion(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of concentr: permillion.
+     * Also see {@link #createPartPerMillion()}.
+     * @stable ICU 64
+     */
+    static MeasureUnit getPartPerMillion();
+
     /**
      * Returns by pointer, unit of concentr: permyriad.
      * Caller owns returned value and must free it.
@@ -1265,23 +1389,21 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getDayPerson();
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of duration: decade.
      * Caller owns returned value and must free it.
      * Also see {@link #getDecade()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createDecade(UErrorCode &status);
 
     /**
      * Returns by value, unit of duration: decade.
      * Also see {@link #createDecade()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getDecade();
-#endif /* U_HIDE_DRAFT_API */
 
     /**
      * Returns by pointer, unit of duration: hour.
@@ -1667,23 +1789,21 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getKilowattHour();
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of energy: therm-us.
      * Caller owns returned value and must free it.
      * Also see {@link #getThermUs()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createThermUs(UErrorCode &status);
 
     /**
      * Returns by value, unit of energy: therm-us.
      * Also see {@link #createThermUs()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getThermUs();
-#endif /* U_HIDE_DRAFT_API */
 
     /**
      * Returns by pointer, unit of force: newton.
@@ -1782,130 +1902,134 @@ class U_I18N_API MeasureUnit: public UObject {
     static MeasureUnit getMegahertz();
 
 #ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of graphics: dot.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getDot()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createDot(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of graphics: dot.
+     * Also see {@link #createDot()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getDot();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of graphics: dot-per-centimeter.
      * Caller owns returned value and must free it.
      * Also see {@link #getDotPerCentimeter()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createDotPerCentimeter(UErrorCode &status);
 
     /**
      * Returns by value, unit of graphics: dot-per-centimeter.
      * Also see {@link #createDotPerCentimeter()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getDotPerCentimeter();
-#endif /* U_HIDE_DRAFT_API */
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of graphics: dot-per-inch.
      * Caller owns returned value and must free it.
      * Also see {@link #getDotPerInch()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createDotPerInch(UErrorCode &status);
 
     /**
      * Returns by value, unit of graphics: dot-per-inch.
      * Also see {@link #createDotPerInch()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getDotPerInch();
-#endif /* U_HIDE_DRAFT_API */
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of graphics: em.
      * Caller owns returned value and must free it.
      * Also see {@link #getEm()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createEm(UErrorCode &status);
 
     /**
      * Returns by value, unit of graphics: em.
      * Also see {@link #createEm()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getEm();
-#endif /* U_HIDE_DRAFT_API */
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of graphics: megapixel.
      * Caller owns returned value and must free it.
      * Also see {@link #getMegapixel()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createMegapixel(UErrorCode &status);
 
     /**
      * Returns by value, unit of graphics: megapixel.
      * Also see {@link #createMegapixel()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getMegapixel();
-#endif /* U_HIDE_DRAFT_API */
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of graphics: pixel.
      * Caller owns returned value and must free it.
      * Also see {@link #getPixel()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createPixel(UErrorCode &status);
 
     /**
      * Returns by value, unit of graphics: pixel.
      * Also see {@link #createPixel()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getPixel();
-#endif /* U_HIDE_DRAFT_API */
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of graphics: pixel-per-centimeter.
      * Caller owns returned value and must free it.
      * Also see {@link #getPixelPerCentimeter()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createPixelPerCentimeter(UErrorCode &status);
 
     /**
      * Returns by value, unit of graphics: pixel-per-centimeter.
      * Also see {@link #createPixelPerCentimeter()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getPixelPerCentimeter();
-#endif /* U_HIDE_DRAFT_API */
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of graphics: pixel-per-inch.
      * Caller owns returned value and must free it.
      * Also see {@link #getPixelPerInch()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createPixelPerInch(UErrorCode &status);
 
     /**
      * Returns by value, unit of graphics: pixel-per-inch.
      * Also see {@link #createPixelPerInch()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getPixelPerInch();
-#endif /* U_HIDE_DRAFT_API */
 
     /**
      * Returns by pointer, unit of length: astronomical-unit.
@@ -1955,6 +2079,24 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getDecimeter();
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of length: earth-radius.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getEarthRadius()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createEarthRadius(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of length: earth-radius.
+     * Also see {@link #createEarthRadius()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getEarthRadius();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of length: fathom.
      * Caller owns returned value and must free it.
@@ -2243,6 +2385,42 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getYard();
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of light: candela.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getCandela()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createCandela(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of light: candela.
+     * Also see {@link #createCandela()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getCandela();
+#endif /* U_HIDE_DRAFT_API */
+
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of light: lumen.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getLumen()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createLumen(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of light: lumen.
+     * Also see {@link #createLumen()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getLumen();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of light: lux.
      * Caller owns returned value and must free it.
@@ -2323,6 +2501,24 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getEarthMass();
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of mass: grain.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getGrain()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createGrain(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of mass: grain.
+     * Also see {@link #createGrain()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getGrain();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of mass: gram.
      * Caller owns returned value and must free it.
@@ -2611,23 +2807,21 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getAtmosphere();
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of pressure: bar.
      * Caller owns returned value and must free it.
      * Also see {@link #getBar()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createBar(UErrorCode &status);
 
     /**
      * Returns by value, unit of pressure: bar.
      * Also see {@link #createBar()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getBar();
-#endif /* U_HIDE_DRAFT_API */
 
     /**
      * Returns by pointer, unit of pressure: hectopascal.
@@ -2725,23 +2919,21 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getMillimeterOfMercury();
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Returns by pointer, unit of pressure: pascal.
      * Caller owns returned value and must free it.
      * Also see {@link #getPascal()}.
      * @param status ICU error code.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit *createPascal(UErrorCode &status);
 
     /**
      * Returns by value, unit of pressure: pascal.
      * Also see {@link #createPascal()}.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     static MeasureUnit getPascal();
-#endif /* U_HIDE_DRAFT_API */
 
     /**
      * Returns by pointer, unit of pressure: pound-force-per-square-inch.
@@ -3143,6 +3335,78 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getDeciliter();
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of volume: dessert-spoon.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getDessertSpoon()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createDessertSpoon(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of volume: dessert-spoon.
+     * Also see {@link #createDessertSpoon()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getDessertSpoon();
+#endif /* U_HIDE_DRAFT_API */
+
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of volume: dessert-spoon-imperial.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getDessertSpoonImperial()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createDessertSpoonImperial(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of volume: dessert-spoon-imperial.
+     * Also see {@link #createDessertSpoonImperial()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getDessertSpoonImperial();
+#endif /* U_HIDE_DRAFT_API */
+
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of volume: dram.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getDram()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createDram(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of volume: dram.
+     * Also see {@link #createDram()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getDram();
+#endif /* U_HIDE_DRAFT_API */
+
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of volume: drop.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getDrop()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createDrop(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of volume: drop.
+     * Also see {@link #createDrop()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getDrop();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of volume: fluid-ounce.
      * Caller owns returned value and must free it.
@@ -3223,6 +3487,24 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getHectoliter();
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of volume: jigger.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getJigger()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createJigger(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of volume: jigger.
+     * Also see {@link #createJigger()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getJigger();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of volume: liter.
      * Caller owns returned value and must free it.
@@ -3271,6 +3553,24 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getMilliliter();
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of volume: pinch.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getPinch()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createPinch(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of volume: pinch.
+     * Also see {@link #createPinch()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getPinch();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of volume: pint.
      * Caller owns returned value and must free it.
@@ -3319,6 +3619,24 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getQuart();
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Returns by pointer, unit of volume: quart-imperial.
+     * Caller owns returned value and must free it.
+     * Also see {@link #getQuartImperial()}.
+     * @param status ICU error code.
+     * @draft ICU 68
+     */
+    static MeasureUnit *createQuartImperial(UErrorCode &status);
+
+    /**
+     * Returns by value, unit of volume: quart-imperial.
+     * Also see {@link #createQuartImperial()}.
+     * @draft ICU 68
+     */
+    static MeasureUnit getQuartImperial();
+#endif /* U_HIDE_DRAFT_API */
+
     /**
      * Returns by pointer, unit of volume: tablespoon.
      * Caller owns returned value and must free it.
@@ -3351,7 +3669,6 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit getTeaspoon();
 
-
 // End generated createXXX methods
 
  protected:
@@ -3369,12 +3686,6 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     void initCurrency(StringPiece isoCurrency);
 
-    /**
-     * For ICU use only.
-     * @internal
-     */
-    void initNoUnit(const char *subtype);
-
 #endif  /* U_HIDE_INTERNAL_API */
 
 private:
@@ -3393,7 +3704,6 @@ private:
     MeasureUnit(int32_t typeId, int32_t subTypeId);
     MeasureUnit(MeasureUnitImpl&& impl);
     void setTo(int32_t typeId, int32_t subTypeId);
-    int32_t getOffset() const;
     static MeasureUnit *create(int typeId, int subTypeId, UErrorCode &status);
 
     /**
@@ -3405,9 +3715,25 @@ private:
      */
     static bool findBySubType(StringPiece subType, MeasureUnit* output);
 
-    friend struct MeasureUnitImpl;
+    /** Internal version of public API */
+    LocalArray<MeasureUnit> splitToSingleUnitsImpl(int32_t& outCount, UErrorCode& status) const;
+
+    friend class MeasureUnitImpl;
+
+    // For access to findBySubType
+    friend class number::impl::LongNameHandler;
 };
 
+#ifndef U_HIDE_DRAFT_API
+// inline impl of @draft ICU 68 method
+inline std::pair<LocalArray<MeasureUnit>, int32_t>
+MeasureUnit::splitToSingleUnits(UErrorCode& status) const {
+    int32_t length;
+    auto array = splitToSingleUnitsImpl(length, status);
+    return std::make_pair(std::move(array), length);
+}
+#endif // U_HIDE_DRAFT_API
+
 U_NAMESPACE_END
 
 #endif // !UNCONFIG_NO_FORMATTING
diff --git a/deps/icu-small/source/i18n/unicode/measure.h b/deps/icu-small/source/i18n/unicode/measure.h
index a15173d739d94fcf09a69d32ea657a4bf1901e89..0ed02626b13b8f6032f0318161732f3239b0e4a2 100644
--- a/deps/icu-small/source/i18n/unicode/measure.h
+++ b/deps/icu-small/source/i18n/unicode/measure.h
@@ -48,7 +48,7 @@ class U_I18N_API Measure: public UObject {
      * Construct an object with the given numeric amount and the given
      * unit.  After this call, the caller must not delete the given
      * unit object.
-     * @param number a numeric object; amount.isNumeric() must be TRUE
+     * @param number a numeric object; amount.isNumeric() must be true
      * @param adoptedUnit the unit object, which must not be NULL
      * @param ec input-output error code. If the amount or the unit
      * is invalid, then this will be set to a failing value.
diff --git a/deps/icu-small/source/i18n/unicode/msgfmt.h b/deps/icu-small/source/i18n/unicode/msgfmt.h
index 99b0eaeec1dcd82733cec5b4efafa8f11668891b..14b57a114dc3a53fd46434841ff2b7af89c4afb5 100644
--- a/deps/icu-small/source/i18n/unicode/msgfmt.h
+++ b/deps/icu-small/source/i18n/unicode/msgfmt.h
@@ -132,7 +132,7 @@ class NumberFormat;
  *   <li>messageText can contain quoted literal strings including syntax characters.
  *       A quoted literal string begins with an ASCII apostrophe and a syntax character
  *       (usually a {curly brace}) and continues until the next single apostrophe.
- *       A double ASCII apostrohpe inside or outside of a quoted string represents
+ *       A double ASCII apostrophe inside or outside of a quoted string represents
  *       one literal apostrophe.
  *   <li>Quotable syntax characters are the {curly braces} in all messageText parts,
  *       plus the '#' sign in a messageText immediately inside a pluralStyle,
@@ -255,7 +255,7 @@ class NumberFormat;
  * or preformatted values, but not pattern strings or custom format objects.</p>
  *
  * <p>For more details, see the
- * <a href="http://userguide.icu-project.org/formatparse/messages">ICU User Guide</a>.</p>
+ * <a href="https://unicode-org.github.io/icu/userguide/format_parse/messages">ICU User Guide</a>.</p>
  *
  * <h4>Usage Information</h4>
  *
@@ -920,7 +920,7 @@ private:
     int32_t            argTypeCapacity;
 
     /**
-     * TRUE if there are different argTypes for the same argument.
+     * true if there are different argTypes for the same argument.
      * This only matters when the MessageFormat is used in the plain C (umsg_xxx) API
      * where the pattern argTypes determine how the va_arg list is read.
      */
diff --git a/deps/icu-small/source/i18n/unicode/nounit.h b/deps/icu-small/source/i18n/unicode/nounit.h
index 61b5c16ee3955b7a02959a185dbc92699e64eb42..cee45e352df4731f78642a8dc18cf0daa2a3b439 100644
--- a/deps/icu-small/source/i18n/unicode/nounit.h
+++ b/deps/icu-small/source/i18n/unicode/nounit.h
@@ -29,80 +29,53 @@ U_NAMESPACE_BEGIN
 
 /**
  * Dimensionless unit for percent and permille.
+ * Prior to ICU 68, this namespace was a class with the same name.
  * @see NumberFormatter
- * @draft ICU 60
+ * @draft ICU 68
  */
-class U_I18N_API NoUnit: public MeasureUnit {
-public:
+namespace NoUnit {
     /**
      * Returns an instance for the base unit (dimensionless and no scaling).
      *
-     * @return               a NoUnit instance
-     * @draft ICU 60
+     * Prior to ICU 68, this function returned a NoUnit by value.
+     *
+     * Since ICU 68, this function returns the same value as the default MeasureUnit constructor.
+     *
+     * @return               a MeasureUnit instance
+     * @draft ICU 68
      */
-    static NoUnit U_EXPORT2 base();
+    static inline MeasureUnit U_EXPORT2 base() {
+        return MeasureUnit();
+    }
 
     /**
      * Returns an instance for percent, or 1/100 of a base unit.
      *
-     * @return               a NoUnit instance
-     * @draft ICU 60
+     * Prior to ICU 68, this function returned a NoUnit by value.
+     *
+     * Since ICU 68, this function returns the same value as MeasureUnit::getPercent().
+     *
+     * @return               a MeasureUnit instance
+     * @draft ICU 68
      */
-    static NoUnit U_EXPORT2 percent();
+    static inline MeasureUnit U_EXPORT2 percent() {
+        return MeasureUnit::getPercent();
+    }
 
     /**
      * Returns an instance for permille, or 1/1000 of a base unit.
      *
-     * @return               a NoUnit instance
-     * @draft ICU 60
-     */
-    static NoUnit U_EXPORT2 permille();
-
-    /**
-     * Copy operator.
-     * @draft ICU 60
-     */
-    NoUnit(const NoUnit& other);
-
-    /**
-     * Destructor.
-     * @draft ICU 60
-     */
-    virtual ~NoUnit();
-
-    /**
-     * Return a polymorphic clone of this object.  The result will
-     * have the same class as returned by getDynamicClassID().
-     * @draft ICU 60
-     */
-    virtual NoUnit* clone() const;
-
-    /**
-     * Returns a unique class ID for this object POLYMORPHICALLY.
-     * This method implements a simple form of RTTI used by ICU.
-     * @return The class ID for this object. All objects of a given
-     * class have the same class ID.  Objects of other classes have
-     * different class IDs.
-     * @draft ICU 60
-     */
-    virtual UClassID getDynamicClassID() const;
-
-    /**
-     * Returns the class ID for this class. This is used to compare to
-     * the return value of getDynamicClassID().
-     * @return The class ID for all objects of this class.
-     * @draft ICU 60
-     */
-    static UClassID U_EXPORT2 getStaticClassID();
-
-private:
-    /**
-     * Constructor
-     * @internal (private)
+     * Prior to ICU 68, this function returned a NoUnit by value.
+     *
+     * Since ICU 68, this function returns the same value as MeasureUnit::getPermille().
+     *
+     * @return               a MeasureUnit instance
+     * @draft ICU 68
      */
-    NoUnit(const char* subtype);
-
-};
+    static inline MeasureUnit U_EXPORT2 permille() {
+        return MeasureUnit::getPermille();
+    }
+}
 
 U_NAMESPACE_END
 
diff --git a/deps/icu-small/source/i18n/unicode/numberformatter.h b/deps/icu-small/source/i18n/unicode/numberformatter.h
index 615cf49f7b7539ee501a2a5af77e94e9802fc1b6..b987e64b937455bc4efca099bb4ff9087aedc93c 100644
--- a/deps/icu-small/source/i18n/unicode/numberformatter.h
+++ b/deps/icu-small/source/i18n/unicode/numberformatter.h
@@ -28,10 +28,9 @@
 
 /**
  * \file
- * \brief C++ API: Library for localized number formatting introduced in ICU 60.
+ * \brief C++ API: All-in-one formatter for localized numbers, currencies, and units.
  *
- * This library was introduced in ICU 60 to simplify the process of formatting localized number strings.
- * Basic usage examples:
+ * For a full list of options, see icu::number::NumberFormatterSettings.
  *
  * <pre>
  * // Most basic usage:
@@ -99,6 +98,13 @@ class MultiplierParseHandler;
 }
 }
 
+namespace units {
+
+// Forward declarations:
+class UnitsRouter;
+
+} // namespace units
+
 namespace number {  // icu::number
 
 // Forward declarations:
@@ -157,6 +163,7 @@ struct RangeMacroProps;
 struct UFormattedNumberImpl;
 class MutablePatternModifier;
 class ImmutablePatternModifier;
+struct DecimalFormatWarehouse;
 
 /**
  * Used for NumberRangeFormatter and implemented in numrange_fluent.cpp.
@@ -339,15 +346,15 @@ class U_I18N_API Notation : public UMemory {
 
     union NotationUnion {
         // For NTN_SCIENTIFIC
-        /** @internal */
+        /** @internal (private) */
         struct ScientificSettings {
-            /** @internal */
+            /** @internal (private) */
             int8_t fEngineeringInterval;
-            /** @internal */
+            /** @internal (private) */
             bool fRequireMinInt;
-            /** @internal */
+            /** @internal (private) */
             impl::digits_t fMinExponentDigits;
-            /** @internal */
+            /** @internal (private) */
             UNumberSignDisplay fExponentSignDisplay;
         } scientific;
 
@@ -371,9 +378,9 @@ class U_I18N_API Notation : public UMemory {
     UBool copyErrorTo(UErrorCode &status) const {
         if (fType == NTN_ERROR) {
             status = fUnion.errorCode;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
 
     // To allow MacroProps to initialize empty instances:
@@ -652,6 +659,17 @@ class U_I18N_API Precision : public UMemory {
      */
     static CurrencyPrecision currency(UCurrencyUsage currencyUsage);
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Configure how trailing zeros are displayed on numbers. For example, to hide trailing zeros
+     * when the number is an integer, use UNUM_TRAILING_ZERO_HIDE_IF_WHOLE.
+     *
+     * @param trailingZeroDisplay Option to configure the display of trailing zeros.
+     * @draft ICU 69
+     */
+    Precision trailingZeroDisplay(UNumberTrailingZeroDisplay trailingZeroDisplay) const;
+#endif // U_HIDE_DRAFT_API
+
   private:
     enum PrecisionType {
         RND_BOGUS,
@@ -676,41 +694,41 @@ class U_I18N_API Precision : public UMemory {
     } fType;
 
     union PrecisionUnion {
-        /** @internal */
+        /** @internal (private) */
         struct FractionSignificantSettings {
             // For RND_FRACTION, RND_SIGNIFICANT, and RND_FRACTION_SIGNIFICANT
-            /** @internal */
+            /** @internal (private) */
             impl::digits_t fMinFrac;
-            /** @internal */
+            /** @internal (private) */
             impl::digits_t fMaxFrac;
-            /** @internal */
+            /** @internal (private) */
             impl::digits_t fMinSig;
-            /** @internal */
+            /** @internal (private) */
             impl::digits_t fMaxSig;
+            /** @internal (private) */
+            UNumberRoundingPriority fPriority;
         } fracSig;
-        /** @internal */
+        /** @internal (private) */
         struct IncrementSettings {
             // For RND_INCREMENT, RND_INCREMENT_ONE, and RND_INCREMENT_FIVE
-            /** @internal */
+            /** @internal (private) */
             double fIncrement;
-            /** @internal */
+            /** @internal (private) */
             impl::digits_t fMinFrac;
-            /** @internal */
+            /** @internal (private) */
             impl::digits_t fMaxFrac;
         } increment;
         UCurrencyUsage currencyUsage; // For RND_CURRENCY
         UErrorCode errorCode; // For RND_ERROR
     } fUnion;
 
+    UNumberTrailingZeroDisplay fTrailingZeroDisplay = UNUM_TRAILING_ZERO_AUTO;
+
     typedef PrecisionUnion::FractionSignificantSettings FractionSignificantSettings;
     typedef PrecisionUnion::IncrementSettings IncrementSettings;
 
-    /** The Precision encapsulates the RoundingMode when used within the implementation. */
-    UNumberFormatRoundingMode fRoundingMode;
-
-    Precision(const PrecisionType& type, const PrecisionUnion& union_,
-              UNumberFormatRoundingMode roundingMode)
-            : fType(type), fUnion(union_), fRoundingMode(roundingMode) {}
+    Precision(const PrecisionType& type, const PrecisionUnion& union_)
+            : fType(type), fUnion(union_) {}
 
     Precision(UErrorCode errorCode) : fType(RND_ERROR) {
         fUnion.errorCode = errorCode;
@@ -725,9 +743,9 @@ class U_I18N_API Precision : public UMemory {
     UBool copyErrorTo(UErrorCode &status) const {
         if (fType == RND_ERROR) {
             status = fUnion.errorCode;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
 
     // On the parent type so that this method can be called internally on Precision instances.
@@ -737,15 +755,16 @@ class U_I18N_API Precision : public UMemory {
 
     static Precision constructSignificant(int32_t minSig, int32_t maxSig);
 
-    static Precision
-    constructFractionSignificant(const FractionPrecision &base, int32_t minSig, int32_t maxSig);
+    static Precision constructFractionSignificant(
+        const FractionPrecision &base,
+        int32_t minSig,
+        int32_t maxSig,
+        UNumberRoundingPriority priority);
 
     static IncrementPrecision constructIncrement(double increment, int32_t minFrac);
 
     static CurrencyPrecision constructCurrency(UCurrencyUsage usage);
 
-    static Precision constructPassThrough();
-
     // To allow MacroProps/MicroProps to initialize bogus instances:
     friend struct impl::MacroProps;
     friend struct impl::MicroProps;
@@ -766,6 +785,9 @@ class U_I18N_API Precision : public UMemory {
 
     // To allow access to the skeleton generation code:
     friend class impl::GeneratorHelpers;
+
+    // To allow access to isBogus and the default (bogus) constructor:
+    friend class units::UnitsRouter;
 };
 
 /**
@@ -779,16 +801,38 @@ class U_I18N_API Precision : public UMemory {
  */
 class U_I18N_API FractionPrecision : public Precision {
   public:
+#ifndef U_HIDE_DRAFT_API
     /**
-     * Ensure that no less than this number of significant digits are retained when rounding according to fraction
-     * rules.
+     * Override maximum fraction digits with maximum significant digits depending on the magnitude
+     * of the number. See UNumberRoundingPriority.
      *
-     * <p>
-     * For example, with integer rounding, the number 3.141 becomes "3". However, with minimum figures set to 2, 3.141
-     * becomes "3.1" instead.
+     * @param minSignificantDigits
+     *            Pad trailing zeros to achieve this minimum number of significant digits.
+     * @param maxSignificantDigits
+     *            Round the number to achieve this maximum number of significant digits.
+     * @param priority
+     *            How to disambiguate between fraction digits and significant digits.
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
      *
-     * <p>
-     * This setting does not affect the number of trailing zeros. For example, 3.01 would print as "3", not "3.0".
+     * @draft ICU 69
+     */
+    Precision withSignificantDigits(
+        int32_t minSignificantDigits,
+        int32_t maxSignificantDigits,
+        UNumberRoundingPriority priority) const;
+#endif // U_HIDE_DRAFT_API
+
+    /**
+     * Ensure that no less than this number of significant digits are retained when rounding
+     * according to fraction rules.
+     *
+     * For example, with integer rounding, the number 3.141 becomes "3". However, with minimum
+     * figures set to 2, 3.141 becomes "3.1" instead.
+     *
+     * This setting does not affect the number of trailing zeros. For example, 3.01 would print as
+     * "3", not "3.0".
+     *
+     * This is equivalent to `withSignificantDigits(1, minSignificantDigits, RELAXED)`.
      *
      * @param minSignificantDigits
      *            The number of significant figures to guarantee.
@@ -798,16 +842,16 @@ class U_I18N_API FractionPrecision : public Precision {
     Precision withMinDigits(int32_t minSignificantDigits) const;
 
     /**
-     * Ensure that no more than this number of significant digits are retained when rounding according to fraction
-     * rules.
+     * Ensure that no more than this number of significant digits are retained when rounding
+     * according to fraction rules.
      *
-     * <p>
-     * For example, with integer rounding, the number 123.4 becomes "123". However, with maximum figures set to 2, 123.4
-     * becomes "120" instead.
+     * For example, with integer rounding, the number 123.4 becomes "123". However, with maximum
+     * figures set to 2, 123.4 becomes "120" instead.
      *
-     * <p>
-     * This setting does not affect the number of trailing zeros. For example, with fixed fraction of 2, 123.4 would
-     * become "120.00".
+     * This setting does not affect the number of trailing zeros. For example, with fixed fraction
+     * of 2, 123.4 would become "120.00".
+     *
+     * This is equivalent to `withSignificantDigits(1, maxSignificantDigits, STRICT)`.
      *
      * @param maxSignificantDigits
      *            Round the number to no more than this number of significant figures.
@@ -969,9 +1013,9 @@ class U_I18N_API IntegerWidth : public UMemory {
     UBool copyErrorTo(UErrorCode &status) const {
         if (fHasError) {
             status = fUnion.errorCode;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
 
     void apply(impl::DecimalQuantity &quantity, UErrorCode &status) const;
@@ -1095,11 +1139,11 @@ class U_I18N_API Scale : public UMemory {
     }
 
     UBool copyErrorTo(UErrorCode &status) const {
-        if (fError != U_ZERO_ERROR) {
+        if (U_FAILURE(fError)) {
             status = fError;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
 
     void applyTo(impl::DecimalQuantity& quantity) const;
@@ -1126,6 +1170,76 @@ class U_I18N_API Scale : public UMemory {
 
 namespace impl {
 
+// Do not enclose entire StringProp with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
+/**
+ * Manages NumberFormatterSettings::usage()'s char* instance on the heap.
+ * @internal
+ */
+class U_I18N_API StringProp : public UMemory {
+
+#ifndef U_HIDE_INTERNAL_API
+
+  public:
+    /** @internal */
+    StringProp(const StringProp &other);
+
+    /** @internal */
+    StringProp &operator=(const StringProp &other);
+
+    /** @internal */
+    StringProp(StringProp &&src) U_NOEXCEPT;
+
+    /** @internal */
+    StringProp &operator=(StringProp &&src) U_NOEXCEPT;
+
+    /** @internal */
+    ~StringProp();
+
+    /** @internal */
+    int16_t length() const {
+        return fLength;
+    }
+
+    /** @internal
+     * Makes a copy of value. Set to "" to unset.
+     */
+    void set(StringPiece value);
+
+    /** @internal */
+    bool isSet() const {
+        return fLength > 0;
+    }
+
+#endif // U_HIDE_INTERNAL_API
+
+  private:
+    char *fValue;
+    int16_t fLength;
+    UErrorCode fError;
+
+    StringProp() : fValue(nullptr), fLength(0), fError(U_ZERO_ERROR) {
+    }
+
+    /** @internal (private) */
+    UBool copyErrorTo(UErrorCode &status) const {
+        if (U_FAILURE(fError)) {
+            status = fError;
+            return true;
+        }
+        return false;
+    }
+
+    // Allow NumberFormatterImpl to access fValue.
+    friend class impl::NumberFormatterImpl;
+
+    // Allow skeleton generation code to access private members.
+    friend class impl::GeneratorHelpers;
+
+    // Allow MacroProps/MicroProps to initialize empty instances and to call
+    // copyErrorTo().
+    friend struct impl::MacroProps;
+};
+
 // Do not enclose entire SymbolsWrapper with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
 /** @internal */
 class U_I18N_API SymbolsWrapper : public UMemory {
@@ -1192,12 +1306,12 @@ class U_I18N_API SymbolsWrapper : public UMemory {
     UBool copyErrorTo(UErrorCode &status) const {
         if (fType == SYMPTR_DFS && fPtr.dfs == nullptr) {
             status = U_MEMORY_ALLOCATION_ERROR;
-            return TRUE;
+            return true;
         } else if (fType == SYMPTR_NS && fPtr.ns == nullptr) {
             status = U_MEMORY_ALLOCATION_ERROR;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
 
   private:
@@ -1239,13 +1353,13 @@ class U_I18N_API Grouper : public UMemory {
               fGrouping2(grouping2),
               fMinGrouping(minGrouping),
               fStrategy(strategy) {}
-#endif  // U_HIDE_INTERNAL_API
 
     /** @internal */
     int16_t getPrimary() const;
 
     /** @internal */
     int16_t getSecondary() const;
+#endif  // U_HIDE_INTERNAL_API
 
   private:
     /**
@@ -1309,10 +1423,10 @@ class U_I18N_API Padder : public UMemory {
 
     /** @internal */
     static Padder codePoints(UChar32 cp, int32_t targetWidth, UNumberFormatPadPosition position);
-#endif  // U_HIDE_INTERNAL_API
 
     /** @internal */
     static Padder forProperties(const DecimalFormatProperties& properties);
+#endif  // U_HIDE_INTERNAL_API
 
   private:
     UChar32 fWidth;  // -3 = error; -2 = bogus; -1 = no padding
@@ -1341,9 +1455,9 @@ class U_I18N_API Padder : public UMemory {
     UBool copyErrorTo(UErrorCode &status) const {
         if (fWidth == -3) {
             status = fUnion.errorCode;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
 
     bool isValid() const {
@@ -1372,10 +1486,10 @@ struct U_I18N_API MacroProps : public UMemory {
     Notation notation;
 
     /** @internal */
-    MeasureUnit unit; // = NoUnit::base();
+    MeasureUnit unit;  // = MeasureUnit();  (the base dimensionless unit)
 
     /** @internal */
-    MeasureUnit perUnit; // = NoUnit::base();
+    MeasureUnit perUnit;  // = MeasureUnit();  (the base dimensionless unit)
 
     /** @internal */
     Precision precision;  // = Precision();  (bogus)
@@ -1409,6 +1523,12 @@ struct U_I18N_API MacroProps : public UMemory {
     /** @internal */
     Scale scale;  // = Scale();  (benign value)
 
+    /** @internal */
+    StringProp usage;  // = StringProp();  (no usage)
+
+    /** @internal */
+    StringProp unitDisplayCase;  // = StringProp();  (nominative)
+
     /** @internal */
     const AffixPatternProvider* affixProvider = nullptr;  // no ownership
 
@@ -1430,7 +1550,8 @@ struct U_I18N_API MacroProps : public UMemory {
     bool copyErrorTo(UErrorCode &status) const {
         return notation.copyErrorTo(status) || precision.copyErrorTo(status) ||
                padder.copyErrorTo(status) || integerWidth.copyErrorTo(status) ||
-               symbols.copyErrorTo(status) || scale.copyErrorTo(status);
+               symbols.copyErrorTo(status) || scale.copyErrorTo(status) || usage.copyErrorTo(status) ||
+               unitDisplayCase.copyErrorTo(status);
     }
 };
 
@@ -1507,10 +1628,15 @@ class U_I18N_API NumberFormatterSettings {
      * All units will be properly localized with locale data, and all units are compatible with notation styles,
      * rounding precisions, and other number formatter settings.
      *
+     * \note If the usage() is set, the output unit **will be changed** to
+     *       produce localised units, according to usage, locale and unit. See
+     *       FormattedNumber::getOutputUnit().
+     *
      * Pass this method any instance of {@link MeasureUnit}. For units of measure:
      *
      * <pre>
      * NumberFormatter::with().unit(MeasureUnit::getMeter())
+     * NumberFormatter::with().unit(MeasureUnit::forIdentifier("foot-per-second", status))
      * </pre>
      *
      * Currency:
@@ -1693,7 +1819,7 @@ class U_I18N_API NumberFormatterSettings {
      *
      * The default is HALF_EVEN. For more information on rounding mode, see the ICU userguide here:
      *
-     * http://userguide.icu-project.org/formatparse/numbers/rounding-modes
+     * https://unicode-org.github.io/icu/userguide/format_parse/numbers/rounding-modes
      *
      * @param roundingMode The rounding mode to use.
      * @return The fluent chain.
@@ -2038,6 +2164,80 @@ class U_I18N_API NumberFormatterSettings {
      */
     Derived scale(const Scale &scale) &&;
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Specifies the usage for which numbers will be formatted ("person-height",
+     * "road", "rainfall", etc.)
+     *
+     * When a `usage` is specified, the output unit will change depending on the
+     * `Locale` and the unit quantity. For example, formatting length
+     * measurements specified in meters:
+     *
+     * `NumberFormatter::with().usage("person").unit(MeasureUnit::getMeter()).locale("en-US")`
+     *   * When formatting 0.25, the output will be "10 inches".
+     *   * When formatting 1.50, the output will be "4 feet and 11 inches".
+     *
+     * The input unit specified via unit() determines the type of measurement
+     * being formatted (e.g. "length" when the unit is "foot"). The usage
+     * requested will be looked for only within this category of measurement
+     * units.
+     *
+     * The output unit can be found via FormattedNumber::getOutputUnit().
+     *
+     * If the usage has multiple parts (e.g. "land-agriculture-grain") and does
+     * not match a known usage preference, the last part will be dropped
+     * repeatedly until a match is found (e.g. trying "land-agriculture", then
+     * "land"). If a match is still not found, usage will fall back to
+     * "default".
+     *
+     * Setting usage to an empty string clears the usage (disables usage-based
+     * localized formatting).
+     *
+     * Setting a usage string but not a correct input unit will result in an
+     * U_ILLEGAL_ARGUMENT_ERROR.
+     *
+     * When using usage, specifying rounding or precision is unnecessary.
+     * Specifying a precision in some manner will override the default
+     * formatting.
+     *
+     * @param usage A `usage` parameter from the units resource. See the
+     * unitPreferenceData in *source/data/misc/units.txt*, generated from
+     * `unitPreferenceData` in [CLDR's
+     * supplemental/units.xml](https://github.com/unicode-org/cldr/blob/master/common/supplemental/units.xml).
+     * @return The fluent chain.
+     * @draft ICU 68
+     */
+    Derived usage(StringPiece usage) const &;
+
+    /**
+     * Overload of usage() for use on an rvalue reference.
+     *
+     * @param usage The unit `usage`.
+     * @return The fluent chain.
+     * @draft ICU 68
+     */
+    Derived usage(StringPiece usage) &&;
+#endif // U_HIDE_DRAFT_API
+
+#ifndef U_HIDE_DRAFT_API
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * Specifies the desired case for a unit formatter's output (e.g.
+     * accusative, dative, genitive).
+     *
+     * @internal ICU 69 technology preview
+     */
+    Derived unitDisplayCase(StringPiece unitDisplayCase) const &;
+
+    /**
+     * Overload of unitDisplayCase() for use on an rvalue reference.
+     *
+     * @internal ICU 69 technology preview
+     */
+    Derived unitDisplayCase(StringPiece unitDisplayCase) &&;
+#endif // U_HIDE_INTERNAL_API
+#endif // U_HIDE_DRAFT_API
+
 #ifndef U_HIDE_INTERNAL_API
 
     /**
@@ -2090,6 +2290,9 @@ class U_I18N_API NumberFormatterSettings {
      * The returned skeleton is in normalized form, such that two number formatters with equivalent
      * behavior should produce the same skeleton.
      *
+     * For more information on number skeleton strings, see:
+     * https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html
+     *
      * @return A number skeleton string with behavior corresponding to this number formatter.
      * @stable ICU 62
      */
@@ -2120,13 +2323,13 @@ class U_I18N_API NumberFormatterSettings {
     /**
      * Sets the UErrorCode if an error occurred in the fluent chain.
      * Preserves older error codes in the outErrorCode.
-     * @return TRUE if U_FAILURE(outErrorCode)
+     * @return true if U_FAILURE(outErrorCode)
      * @stable ICU 60
      */
     UBool copyErrorTo(UErrorCode &outErrorCode) const {
         if (U_FAILURE(outErrorCode)) {
             // Do not overwrite the older error code
-            return TRUE;
+            return true;
         }
         fMacros.copyErrorTo(outErrorCode);
         return U_FAILURE(outErrorCode);
@@ -2385,6 +2588,10 @@ class U_I18N_API LocalizedNumberFormatter
     const impl::NumberFormatterImpl* fCompiled {nullptr};
     char fUnsafeCallCount[8] {};  // internally cast to u_atomic_int32_t
 
+    // Owned pointer to a DecimalFormatWarehouse, used when copying a LocalizedNumberFormatter
+    // from a DecimalFormat.
+    const impl::DecimalFormatWarehouse* fWarehouse {nullptr};
+
     explicit LocalizedNumberFormatter(const NumberFormatterSettings<LocalizedNumberFormatter>& other);
 
     explicit LocalizedNumberFormatter(NumberFormatterSettings<LocalizedNumberFormatter>&& src) U_NOEXCEPT;
@@ -2393,10 +2600,12 @@ class U_I18N_API LocalizedNumberFormatter
 
     LocalizedNumberFormatter(impl::MacroProps &&macros, const Locale &locale);
 
-    void clear();
+    void resetCompiled();
 
     void lnfMoveHelper(LocalizedNumberFormatter&& src);
 
+    void lnfCopyHelper(const LocalizedNumberFormatter& src, UErrorCode& status);
+
     /**
      * @return true if the compiled formatter is available.
      */
@@ -2485,7 +2694,6 @@ class U_I18N_API FormattedNumber : public UMemory, public FormattedValue {
     /** @copydoc FormattedValue::nextPosition() */
     UBool nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const U_OVERRIDE;
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Export the formatted number as a "numeric string" conforming to the
      * syntax defined in the Decimal Arithmetic Specification, available at
@@ -2502,10 +2710,32 @@ class U_I18N_API FormattedNumber : public UMemory, public FormattedValue {
      *         for example, std::string.
      * @param status Set if an error occurs.
      * @return A StringClass containing the numeric string.
-     * @draft ICU 65
+     * @stable ICU 65
      */
     template<typename StringClass>
     inline StringClass toDecimalNumber(UErrorCode& status) const;
+
+#ifndef U_HIDE_DRAFT_API
+	/**
+     * Gets the resolved output unit.
+     *
+     * The output unit is dependent upon the localized preferences for the usage
+     * specified via NumberFormatterSettings::usage(), and may be a unit with
+     * UMEASURE_UNIT_MIXED unit complexity (MeasureUnit::getComplexity()), such
+     * as "foot-and-inch" or "hour-and-minute-and-second".
+     *
+     * @return `MeasureUnit`.
+     * @draft ICU 68
+     */
+    MeasureUnit getOutputUnit(UErrorCode& status) const;
+
+    /**
+     * Gets the gender of the formatted output. Returns "" when the gender is
+     * unknown, or for ungendered languages.
+     *
+     * @internal ICU 69 technology preview.
+     */
+    const char *getGender(UErrorCode& status) const;
 #endif // U_HIDE_DRAFT_API
 
 #ifndef U_HIDE_INTERNAL_API
@@ -2533,7 +2763,7 @@ class U_I18N_API FormattedNumber : public UMemory, public FormattedValue {
 
     /**
      * Internal constructor from data type. Adopts the data pointer.
-     * @internal
+     * @internal (private)
      */
     explicit FormattedNumber(impl::UFormattedNumberData *results)
         : fData(results), fErrorCode(U_ZERO_ERROR) {}
@@ -2541,7 +2771,6 @@ class U_I18N_API FormattedNumber : public UMemory, public FormattedValue {
     explicit FormattedNumber(UErrorCode errorCode)
         : fData(nullptr), fErrorCode(errorCode) {}
 
-    // TODO(ICU-20775): Propose this as API.
     void toDecimalNumber(ByteSink& sink, UErrorCode& status) const;
 
     // To give LocalizedNumberFormatter format methods access to this class's constructor:
@@ -2551,8 +2780,6 @@ class U_I18N_API FormattedNumber : public UMemory, public FormattedValue {
     friend struct impl::UFormattedNumberImpl;
 };
 
-#ifndef U_HIDE_DRAFT_API
-// Note: This is draft ICU 65
 template<typename StringClass>
 StringClass FormattedNumber::toDecimalNumber(UErrorCode& status) const {
     StringClass result;
@@ -2560,7 +2787,6 @@ StringClass FormattedNumber::toDecimalNumber(UErrorCode& status) const {
     toDecimalNumber(sink, status);
     return result;
 }
-#endif // U_HIDE_DRAFT_API
 
 /**
  * See the main description in numberformatter.h for documentation and examples.
@@ -2596,6 +2822,9 @@ class U_I18N_API NumberFormatter final {
      * It is possible for an error to occur while parsing. See the overload of this method if you are
      * interested in the location of a possible parse error.
      *
+     * For more information on number skeleton strings, see:
+     * https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html
+     *
      * @param skeleton
      *            The skeleton string off of which to base this NumberFormatter.
      * @param status
@@ -2612,6 +2841,9 @@ class U_I18N_API NumberFormatter final {
      * If an error occurs while parsing the skeleton string, the offset into the skeleton string at
      * which the error occurred will be saved into the UParseError, if provided.
      *
+     * For more information on number skeleton strings, see:
+     * https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html
+     *
      * @param skeleton
      *            The skeleton string off of which to base this NumberFormatter.
      * @param perror
@@ -2639,4 +2871,3 @@ U_NAMESPACE_END
 #endif /* U_SHOW_CPLUSPLUS_API */
 
 #endif // __NUMBERFORMATTER_H__
-
diff --git a/deps/icu-small/source/i18n/unicode/numberrangeformatter.h b/deps/icu-small/source/i18n/unicode/numberrangeformatter.h
index 59f14d8be53189fdc3f2892db4c9266ef67cb38d..432f2f6095dedfa9e654e3fd8a94cbf5601cd28d 100644
--- a/deps/icu-small/source/i18n/unicode/numberrangeformatter.h
+++ b/deps/icu-small/source/i18n/unicode/numberrangeformatter.h
@@ -16,6 +16,7 @@
 #include "unicode/formattedvalue.h"
 #include "unicode/fpositer.h"
 #include "unicode/numberformatter.h"
+#include "unicode/unumberrangeformatter.h"
 
 /**
  * \file
@@ -31,7 +32,7 @@
  *     .numberFormatterFirst(NumberFormatter::with().adoptUnit(MeasureUnit::createMeter()))
  *     .numberFormatterSecond(NumberFormatter::with().adoptUnit(MeasureUnit::createKilometer()))
  *     .locale("en-GB")
- *     .formatRange(750, 1.2, status)
+ *     .formatFormattableRange(750, 1.2, status)
  *     .toString(status);
  * // => "750 m - 1.2 km"
  * </pre>
@@ -44,130 +45,11 @@
  */
 
 
-/**
- * Defines how to merge fields that are identical across the range sign.
- *
- * @stable ICU 63
- */
-typedef enum UNumberRangeCollapse {
-    /**
-     * Use locale data and heuristics to determine how much of the string to collapse. Could end up collapsing none,
-     * some, or all repeated pieces in a locale-sensitive way.
-     *
-     * The heuristics used for this option are subject to change over time.
-     *
-     * @stable ICU 63
-     */
-    UNUM_RANGE_COLLAPSE_AUTO,
-
-    /**
-     * Do not collapse any part of the number. Example: "3.2 thousand kilograms – 5.3 thousand kilograms"
-     *
-     * @stable ICU 63
-     */
-    UNUM_RANGE_COLLAPSE_NONE,
-
-    /**
-     * Collapse the unit part of the number, but not the notation, if present. Example: "3.2 thousand – 5.3 thousand
-     * kilograms"
-     *
-     * @stable ICU 63
-     */
-    UNUM_RANGE_COLLAPSE_UNIT,
-
-    /**
-     * Collapse any field that is equal across the range sign. May introduce ambiguity on the magnitude of the
-     * number. Example: "3.2 – 5.3 thousand kilograms"
-     *
-     * @stable ICU 63
-     */
-    UNUM_RANGE_COLLAPSE_ALL
-} UNumberRangeCollapse;
-
-/**
- * Defines the behavior when the two numbers in the range are identical after rounding. To programmatically detect
- * when the identity fallback is used, compare the lower and upper BigDecimals via FormattedNumber.
- *
- * @stable ICU 63
- * @see NumberRangeFormatter
- */
-typedef enum UNumberRangeIdentityFallback {
-    /**
-     * Show the number as a single value rather than a range. Example: "$5"
-     *
-     * @stable ICU 63
-     */
-    UNUM_IDENTITY_FALLBACK_SINGLE_VALUE,
-
-    /**
-     * Show the number using a locale-sensitive approximation pattern. If the numbers were the same before rounding,
-     * show the single value. Example: "~$5" or "$5"
-     *
-     * @stable ICU 63
-     */
-    UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE,
-
-    /**
-     * Show the number using a locale-sensitive approximation pattern. Use the range pattern always, even if the
-     * inputs are the same. Example: "~$5"
-     *
-     * @stable ICU 63
-     */
-    UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
-
-    /**
-     * Show the number as the range of two equal values. Use the range pattern always, even if the inputs are the
-     * same. Example (with RangeCollapse.NONE): "$5 – $5"
-     *
-     * @stable ICU 63
-     */
-    UNUM_IDENTITY_FALLBACK_RANGE
-} UNumberRangeIdentityFallback;
-
-/**
- * Used in the result class FormattedNumberRange to indicate to the user whether the numbers formatted in the range
- * were equal or not, and whether or not the identity fallback was applied.
- *
- * @stable ICU 63
- * @see NumberRangeFormatter
- */
-typedef enum UNumberRangeIdentityResult {
-    /**
-     * Used to indicate that the two numbers in the range were equal, even before any rounding rules were applied.
-     *
-     * @stable ICU 63
-     * @see NumberRangeFormatter
-     */
-    UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING,
-
-    /**
-     * Used to indicate that the two numbers in the range were equal, but only after rounding rules were applied.
-     *
-     * @stable ICU 63
-     * @see NumberRangeFormatter
-     */
-    UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING,
-
-    /**
-     * Used to indicate that the two numbers in the range were not equal, even after rounding rules were applied.
-     *
-     * @stable ICU 63
-     * @see NumberRangeFormatter
-     */
-    UNUM_IDENTITY_RESULT_NOT_EQUAL,
-
-#ifndef U_HIDE_INTERNAL_API
-    /**
-     * The number of entries in this enum.
-     * @internal
-     */
-    UNUM_IDENTITY_RESULT_COUNT
-#endif
-
-} UNumberRangeIdentityResult;
-
 U_NAMESPACE_BEGIN
 
+// Forward declarations:
+class PluralRules;
+
 namespace number {  // icu::number
 
 // Forward declarations:
@@ -182,6 +64,7 @@ struct RangeMacroProps;
 class DecimalQuantity;
 class UFormattedNumberRangeData;
 class NumberRangeFormatterImpl;
+struct UFormattedNumberRangeImpl;
 
 } // namespace impl
 
@@ -190,7 +73,7 @@ class NumberRangeFormatterImpl;
  * Export an explicit template instantiation. See datefmt.h
  * (When building DLLs for Windows this is required.)
  */
-#if U_PLATFORM == U_PF_WINDOWS && !defined(U_IN_DOXYGEN)
+#if U_PLATFORM == U_PF_WINDOWS && !defined(U_IN_DOXYGEN) && !defined(U_STATIC_IMPLEMENTATION)
 } // namespace icu::number
 U_NAMESPACE_END
 
@@ -418,8 +301,8 @@ class U_I18N_API NumberRangeFormatterSettings {
 
     /**
      * Sets the behavior when the two sides of the range are the same. This could happen if the same two numbers are
-     * passed to the formatRange function, or if different numbers are passed to the function but they become the same
-     * after rounding rules are applied. Possible values:
+     * passed to the formatFormattableRange function, or if different numbers are passed to the function but they
+     * become the same after rounding rules are applied. Possible values:
      * <p>
      * <ul>
      * <li>SINGLE_VALUE: "5 miles"</li>
@@ -474,13 +357,13 @@ class U_I18N_API NumberRangeFormatterSettings {
     /**
      * Sets the UErrorCode if an error occurred in the fluent chain.
      * Preserves older error codes in the outErrorCode.
-     * @return TRUE if U_FAILURE(outErrorCode)
+     * @return true if U_FAILURE(outErrorCode)
      * @stable ICU 63
      */
     UBool copyErrorTo(UErrorCode &outErrorCode) const {
         if (U_FAILURE(outErrorCode)) {
             // Do not overwrite the older error code
-            return TRUE;
+            return true;
         }
         fMacros.copyErrorTo(outErrorCode);
         return U_FAILURE(outErrorCode);
@@ -727,36 +610,26 @@ class U_I18N_API FormattedNumberRange : public UMemory, public FormattedValue {
 
 #ifndef U_HIDE_DRAFT_API
     /**
-     * Export the first formatted number as a decimal number. This endpoint
+     * Extracts the formatted range as a pair of decimal numbers. This endpoint
      * is useful for obtaining the exact number being printed after scaling
      * and rounding have been applied by the number range formatting pipeline.
      *
-     * The syntax of the unformatted number is a "numeric string"
+     * The syntax of the unformatted numbers is a "numeric string"
      * as defined in the Decimal Arithmetic Specification, available at
      * http://speleotrove.com/decimal
      *
-     * @return A decimal representation of the first formatted number.
-     * @draft ICU 63
-     * @see NumberRangeFormatter
-     * @see #getSecondDecimal
-     */
-    UnicodeString getFirstDecimal(UErrorCode& status) const;
-
-    /**
-     * Export the second formatted number as a decimal number. This endpoint
-     * is useful for obtaining the exact number being printed after scaling
-     * and rounding have been applied by the number range formatting pipeline.
+     * Example C++17 call site:
      *
-     * The syntax of the unformatted number is a "numeric string"
-     * as defined in the Decimal Arithmetic Specification, available at
-     * http://speleotrove.com/decimal
+     *     auto [ first, second ] = range.getDecimalNumbers<std::string>(status);
      *
-     * @return A decimal representation of the second formatted number.
-     * @draft ICU 63
-     * @see NumberRangeFormatter
-     * @see #getFirstDecimal
+     * @tparam StringClass A string class compatible with StringByteSink;
+     *         for example, std::string.
+     * @param status Set if an error occurs.
+     * @return A pair of StringClasses containing the numeric strings.
+     * @draft ICU 68
      */
-    UnicodeString getSecondDecimal(UErrorCode& status) const;
+    template<typename StringClass>
+    inline std::pair<StringClass, StringClass> getDecimalNumbers(UErrorCode& status) const;
 #endif // U_HIDE_DRAFT_API
 
     /**
@@ -818,10 +691,33 @@ class U_I18N_API FormattedNumberRange : public UMemory, public FormattedValue {
 
     void getAllFieldPositionsImpl(FieldPositionIteratorHandler& fpih, UErrorCode& status) const;
 
+    void getDecimalNumbers(ByteSink& sink1, ByteSink& sink2, UErrorCode& status) const;
+
+    const impl::UFormattedNumberRangeData* getData(UErrorCode& status) const;
+
+    // To allow PluralRules to access the underlying data
+    friend class ::icu::PluralRules;
+
     // To give LocalizedNumberRangeFormatter format methods access to this class's constructor:
     friend class LocalizedNumberRangeFormatter;
+
+    // To give C API access to internals
+    friend struct impl::UFormattedNumberRangeImpl;
 };
 
+#ifndef U_HIDE_DRAFT_API
+// inline impl of @draft ICU 68 method
+template<typename StringClass>
+std::pair<StringClass, StringClass> FormattedNumberRange::getDecimalNumbers(UErrorCode& status) const {
+    StringClass str1;
+    StringClass str2;
+    StringByteSink<StringClass> sink1(&str1);
+    StringByteSink<StringClass> sink2(&str2);
+    getDecimalNumbers(sink1, sink2, status);
+    return std::make_pair(str1, str2);
+}
+#endif // U_HIDE_DRAFT_API
+
 /**
  * See the main description in numberrangeformatter.h for documentation and examples.
  *
diff --git a/deps/icu-small/source/i18n/unicode/numfmt.h b/deps/icu-small/source/i18n/unicode/numfmt.h
index a882b6d2e5667dcf1d33012eba1e62e3268b7914..058ccb38c7f1a4a92a258232c9eee28ae1883da7 100644
--- a/deps/icu-small/source/i18n/unicode/numfmt.h
+++ b/deps/icu-small/source/i18n/unicode/numfmt.h
@@ -179,7 +179,7 @@ public:
      *
      * <p>
      * For more detail on rounding modes, see:
-     * http://userguide.icu-project.org/formatparse/numbers/rounding-modes
+     * https://unicode-org.github.io/icu/userguide/format_parse/numbers/rounding-modes
      *
      * @stable ICU 2.4
      */
@@ -704,8 +704,8 @@ public:
     /**
      * Sets whether lenient parsing should be enabled (it is off by default).
      *
-     * @param enable \c TRUE if lenient parsing should be used,
-     *               \c FALSE otherwise.
+     * @param enable \c true if lenient parsing should be used,
+     *               \c false otherwise.
      * @stable ICU 4.8
      */
     virtual void setLenient(UBool enable);
@@ -713,8 +713,8 @@ public:
     /**
      * Returns whether lenient parsing is enabled (it is off by default).
      *
-     * @return \c TRUE if lenient parsing is enabled,
-     *         \c FALSE otherwise.
+     * @return \c true if lenient parsing is enabled,
+     *         \c false otherwise.
      * @see #setLenient
      * @stable ICU 4.8
      */
@@ -870,7 +870,7 @@ public:
      * NumberFormat::createInstance to avoid undefined behavior.
      * @param key the registry key returned by a previous call to registerFactory
      * @param status the in/out status code, no special meanings are assigned
-     * @return TRUE if the factory for the key was successfully unregistered
+     * @return true if the factory for the key was successfully unregistered
      * @stable ICU 2.6
      */
     static UBool U_EXPORT2 unregister(URegistryKey key, UErrorCode& status);
@@ -1112,7 +1112,7 @@ protected:
 #ifndef U_HIDE_INTERNAL_API
     /**
      * Creates the specified number format style of the desired locale.
-     * If mustBeDecimalFormat is TRUE, then the returned pointer is
+     * If mustBeDecimalFormat is true, then the returned pointer is
      * either a DecimalFormat or it is NULL.
      * @internal
      */
@@ -1151,7 +1151,7 @@ private:
 
   private:
     UBool      fParseIntegerOnly;
-    UBool      fLenient; // TRUE => lenient parse is enabled
+    UBool      fLenient; // true => lenient parse is enabled
 
     // ISO currency code
     char16_t      fCurrency[4];
@@ -1228,7 +1228,7 @@ public:
     /**
      * @stable ICU 2.6
      */
-    SimpleNumberFormatFactory(const Locale& locale, UBool visible = TRUE);
+    SimpleNumberFormatFactory(const Locale& locale, UBool visible = true);
 
     /**
      * @stable ICU 3.0
diff --git a/deps/icu-small/source/i18n/unicode/numsys.h b/deps/icu-small/source/i18n/unicode/numsys.h
index 88c172bd422a511db8651951c7ee82f60cc50923..efdf0c0f669a35abaa6e13bd416aa0eb4153ff80 100644
--- a/deps/icu-small/source/i18n/unicode/numsys.h
+++ b/deps/icu-small/source/i18n/unicode/numsys.h
@@ -102,7 +102,7 @@ public:
     /**
      * Create a numbering system using the specified radix, type, and description.
      * @param radix         The radix (base) for this numbering system.
-     * @param isAlgorithmic TRUE if the numbering system is algorithmic rather than numeric.
+     * @param isAlgorithmic true if the numbering system is algorithmic rather than numeric.
      * @param description   The string representing the set of digits used in a numeric system, or the name of the RBNF
      *                      ruleset to be used in an algorithmic system.
      * @param status ICU status
@@ -171,10 +171,10 @@ public:
 
 
     /**
-     * Returns TRUE if the given numbering system is algorithmic
+     * Returns true if the given numbering system is algorithmic
      *
-     * @return         TRUE if the numbering system is algorithmic.
-     *                 Otherwise, return FALSE.
+     * @return         true if the numbering system is algorithmic.
+     *                 Otherwise, return false.
      * @stable ICU 4.2
      */
     UBool isAlgorithmic() const;
diff --git a/deps/icu-small/source/i18n/unicode/plurfmt.h b/deps/icu-small/source/i18n/unicode/plurfmt.h
index 7373476dca8fc2274ec129a40d0a97b3eed92d6a..fde2abcfae5ac28107ad5bb5b138cbb0670b78d9 100644
--- a/deps/icu-small/source/i18n/unicode/plurfmt.h
+++ b/deps/icu-small/source/i18n/unicode/plurfmt.h
@@ -587,7 +587,7 @@ private:
      */
     static int32_t findSubMessage(
          const MessagePattern& pattern, int32_t partIndex,
-         const PluralSelector& selector, void *context, double number, UErrorCode& ec); /**< @internal */
+         const PluralSelector& selector, void *context, double number, UErrorCode& ec);
 
     void parseType(const UnicodeString& source, const NFRule *rbnfLenientScanner,
         Formattable& result, FieldPosition& pos) const;
diff --git a/deps/icu-small/source/i18n/unicode/plurrule.h b/deps/icu-small/source/i18n/unicode/plurrule.h
index 408efbcc4a84f8f69a377044b4a0453ca0d1cc69..19956cd32c61807a14c863714c1fc76d452d69a3 100644
--- a/deps/icu-small/source/i18n/unicode/plurrule.h
+++ b/deps/icu-small/source/i18n/unicode/plurrule.h
@@ -46,14 +46,20 @@ U_NAMESPACE_BEGIN
 
 class Hashtable;
 class IFixedDecimal;
+class FixedDecimal;
 class RuleChain;
 class PluralRuleParser;
 class PluralKeywordEnumeration;
 class AndConstraint;
 class SharedPluralRules;
+class StandardPluralRanges;
 
 namespace number {
 class FormattedNumber;
+class FormattedNumberRange;
+namespace impl {
+class UFormattedNumberRangeData;
+}
 }
 
 /**
@@ -367,11 +373,35 @@ public:
      */
     UnicodeString select(const number::FormattedNumber& number, UErrorCode& status) const;
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Given a formatted number range, returns the overall plural form of the
+     * range. For example, "3-5" returns "other" in English.
+     *
+     * To get a FormattedNumberRange, see NumberRangeFormatter.
+     *
+     * This method only works if PluralRules was created with a locale. If it was created
+     * from PluralRules::createRules(), this method sets status code U_UNSUPPORTED_ERROR.
+     *
+     * @param range  The number range onto which the rules will be applied.
+     * @param status Set if an error occurs while selecting plural keyword.
+     *               This could happen if the FormattedNumberRange is invalid,
+     *               or if plural ranges data is unavailable.
+     * @return       The keyword of the selected rule.
+     * @draft ICU 68
+     */
+    UnicodeString select(const number::FormattedNumberRange& range, UErrorCode& status) const;
+#endif // U_HIDE_DRAFT_API
+
 #ifndef U_HIDE_INTERNAL_API
     /**
-      * @internal
-      */
+     * @internal
+     */
     UnicodeString select(const IFixedDecimal &number) const;
+    /**
+     * @internal
+     */
+    UnicodeString select(const number::impl::UFormattedNumberRangeData* urange, UErrorCode& status) const;
 #endif  /* U_HIDE_INTERNAL_API */
 
     /**
@@ -446,13 +476,39 @@ public:
                        double *dest, int32_t destCapacity,
                        UErrorCode& status);
 
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * Internal-only function that returns FixedDecimals instead of doubles.
+     *
+     * Returns sample values for which select() would return the keyword.  If
+     * the keyword is unknown, returns no values, but this is not an error.
+     *
+     * The number of returned values is typically small.
+     *
+     * @param keyword      The keyword.
+     * @param dest         Array into which to put the returned values.  May
+     *                     be NULL if destCapacity is 0.
+     * @param destCapacity The capacity of the array, must be at least 0.
+     * @param status       The error code.
+     * @return             The count of values written.
+     *                     If more than destCapacity samples are available, then
+     *                     only destCapacity are written, and destCapacity is returned as the count,
+     *                     rather than setting a U_BUFFER_OVERFLOW_ERROR.
+     *                     (The actual number of keyword values could be unlimited.)
+     * @internal
+     */
+    int32_t getSamples(const UnicodeString &keyword,
+                       FixedDecimal *dest, int32_t destCapacity,
+                       UErrorCode& status);
+#endif  /* U_HIDE_INTERNAL_API */
+
     /**
-     * Returns TRUE if the given keyword is defined in this
+     * Returns true if the given keyword is defined in this
      * <code>PluralRules</code> object.
      *
      * @param keyword  the input keyword.
-     * @return         TRUE if the input keyword is defined.
-     *                 Otherwise, return FALSE.
+     * @return         true if the input keyword is defined.
+     *                 Otherwise, return false.
      * @stable ICU 4.0
      */
     UBool isKeyword(const UnicodeString& keyword) const;
@@ -513,12 +569,14 @@ public:
 
 private:
     RuleChain  *mRules;
+    StandardPluralRanges *mStandardPluralRanges;
 
     PluralRules();   // default constructor not implemented
     void            parseDescription(const UnicodeString& ruleData, UErrorCode &status);
     int32_t         getNumberValue(const UnicodeString& token) const;
     UnicodeString   getRuleFromResource(const Locale& locale, UPluralType type, UErrorCode& status);
     RuleChain      *rulesForKeyword(const UnicodeString &keyword) const;
+    PluralRules    *clone(UErrorCode& status) const;
 
     /**
     * An internal status variable used to indicate that the object is in an 'invalid' state.
diff --git a/deps/icu-small/source/i18n/unicode/rbnf.h b/deps/icu-small/source/i18n/unicode/rbnf.h
index 1144bd2fb8b1babe2057eb13d9e71bbe71279f25..ce60b9bec6853a6128e7668b97f407a5afcda9da 100644
--- a/deps/icu-small/source/i18n/unicode/rbnf.h
+++ b/deps/icu-small/source/i18n/unicode/rbnf.h
@@ -297,7 +297,7 @@ enum URBNFRuleSetTag {
  *   </tr>
  *   <tr>
  *     <td>x.0:</td>
- *     <td>The rule is a <em>master rule</em>. If the full stop in
+ *     <td>The rule is a <em>default rule</em>. If the full stop in
  *     the middle of the rule name is replaced with the decimal point
  *     that is used in the language or DecimalFormatSymbols, then that rule will
  *     have precedence when formatting and parsing this rule. For example, some
@@ -332,9 +332,9 @@ enum URBNFRuleSetTag {
  * algorithms: If the rule set is a regular rule set, do the following:
  *
  * <ul>
- *   <li>If the rule set includes a master rule (and the number was passed in as a <tt>double</tt>),
- *     use the master rule.&nbsp; (If the number being formatted was passed in as a <tt>long</tt>,
- *     the master rule is ignored.)</li>
+ *   <li>If the rule set includes a default rule (and the number was passed in as a <tt>double</tt>),
+ *     use the default rule.&nbsp; (If the number being formatted was passed in as a <tt>long</tt>,
+ *     the default rule is ignored.)</li>
  *   <li>If the number is negative, use the negative-number rule.</li>
  *   <li>If the number has a fractional part and is greater than 1, use the improper fraction
  *     rule.</li>
@@ -393,7 +393,7 @@ enum URBNFRuleSetTag {
  *   </tr>
  *   <tr>
  *     <td></td>
- *     <td>in fraction or master rule</td>
+ *     <td>in fraction or default rule</td>
  *     <td>Isolate the number's fractional part and format it.</td>
  *   </tr>
  *   <tr>
@@ -425,7 +425,7 @@ enum URBNFRuleSetTag {
  *   </tr>
  *   <tr>
  *     <td></td>
- *     <td>in fraction or master rule</td>
+ *     <td>in fraction or default rule</td>
  *     <td>Isolate the number's integral part and format it.</td>
  *   </tr>
  *   <tr>
@@ -456,7 +456,7 @@ enum URBNFRuleSetTag {
  *   </tr>
  *   <tr>
  *     <td></td>
- *     <td>in master rule</td>
+ *     <td>in default rule</td>
  *     <td>Omit the optional text if the number is an integer (same as specifying both an x.x
  *     rule and an x.0 rule)</td>
  *   </tr>
@@ -543,7 +543,7 @@ enum URBNFRuleSetTag {
  * names in this array will be treated as public rule set names by the API.  Each subsequent
  * element is an array of localizations of these names.  The first element of one of these
  * subarrays is the locale name, and the remaining elements are localizations of the
- * public rule set names, in the same order as they were listed in the first arrray.</p>
+ * public rule set names, in the same order as they were listed in the first array.</p>
  * <p>In the syntax, angle brackets '<', '>' are used to delimit the arrays, and comma ',' is used
  * to separate elements of an array.  Whitespace is ignored, unless quoted.</p>
  * <p>For example:<pre>
@@ -653,7 +653,7 @@ public:
 
   /**
    * Creates a RuleBasedNumberFormat from a predefined ruleset.  The selector
-   * code choosed among three possible predefined formats: spellout, ordinal,
+   * code chose among three possible predefined formats: spellout, ordinal,
    * and duration.
    * @param tag A selector code specifying which kind of formatter to create for that
    * locale.  There are four legal values: URBNF_SPELLOUT, which creates a formatter that
diff --git a/deps/icu-small/source/i18n/unicode/rbtz.h b/deps/icu-small/source/i18n/unicode/rbtz.h
index 95fd7ab85dd13ac75cb46aa9a81a9c5bc8a28c79..9fc0fd4657e7b80dc287907500551fbeb4045ca0 100644
--- a/deps/icu-small/source/i18n/unicode/rbtz.h
+++ b/deps/icu-small/source/i18n/unicode/rbtz.h
@@ -107,7 +107,7 @@ public:
 
     /**
      * Makes the <code>TimeZoneRule</code> ready to handle actual timezone
-     * calcuation APIs.  This method collects time zone rules specified
+     * calculation APIs.  This method collects time zone rules specified
      * by the caller via the constructor and addTransitionRule() and
      * builds internal structure for making the object ready to support
      * time zone APIs such as getOffset(), getNextTransition() and others.
@@ -258,7 +258,7 @@ public:
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the first transition after the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      * @stable ICU 3.8
      */
     virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
@@ -268,7 +268,7 @@ public:
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the most recent transition before the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      * @stable ICU 3.8
      */
     virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
@@ -302,12 +302,16 @@ public:
     virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,
         const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const;
 
+#ifndef U_FORCE_HIDE_DRAFT_API
     /**
      * Get time zone offsets from local wall time.
-     * @internal
+     * @draft ICU 69
      */
-    virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
+    virtual void getOffsetFromLocal(
+        UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+        UTimeZoneLocalOption duplicatedTimeOpt,
         int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
+#endif /* U_FORCE_HIDE_DRAFT_API */
 
 private:
     void deleteRules(void);
diff --git a/deps/icu-small/source/i18n/unicode/regex.h b/deps/icu-small/source/i18n/unicode/regex.h
index 2f8d31d97f012fb2902c62383710610427daf92c..8ee74c3903816382ac1f4cd78feabe25b18ca12e 100644
--- a/deps/icu-small/source/i18n/unicode/regex.h
+++ b/deps/icu-small/source/i18n/unicode/regex.h
@@ -116,7 +116,7 @@ public:
      * were constructed from identical source patterns using the same #URegexpFlag
      * settings.
      * @param that a RegexPattern object to compare with "this".
-     * @return TRUE if the objects are equivalent.
+     * @return true if the objects are equivalent.
      * @stable ICU 2.4
      */
     UBool           operator==(const RegexPattern& that) const;
@@ -126,7 +126,7 @@ public:
      * were constructed from identical source patterns using the same #URegexpFlag
      * settings.
      * @param that a RegexPattern object to compare with "this".
-     * @return TRUE if the objects are different.
+     * @return true if the objects are different.
      * @stable ICU 2.4
      */
     inline UBool    operator!=(const RegexPattern& that) const {return ! operator ==(that);}
@@ -764,7 +764,7 @@ public:
    /**
     *   Attempts to match the entire input region against the pattern.
     *    @param   status     A reference to a UErrorCode to receive any errors.
-    *    @return TRUE if there is a match
+    *    @return true if there is a match
     *    @stable ICU 2.4
     */
     virtual UBool matches(UErrorCode &status);
@@ -777,7 +777,7 @@ public:
     *   A successful match must extend to the end of the input.
     *    @param   startIndex The input string (native) index at which to begin matching.
     *    @param   status     A reference to a UErrorCode to receive any errors.
-    *    @return TRUE if there is a match
+    *    @return true if there is a match
     *    @stable ICU 2.8
     */
     virtual UBool matches(int64_t startIndex, UErrorCode &status);
@@ -793,7 +793,7 @@ public:
     *   end(), and group() functions.
     *
     *    @param   status     A reference to a UErrorCode to receive any errors.
-    *    @return  TRUE if there is a match at the start of the input string.
+    *    @return  true if there is a match at the start of the input string.
     *    @stable ICU 2.4
     */
     virtual UBool lookingAt(UErrorCode &status);
@@ -809,7 +809,7 @@ public:
     *
     *    @param   startIndex The input string (native) index at which to begin matching.
     *    @param   status     A reference to a UErrorCode to receive any errors.
-    *    @return  TRUE if there is a match.
+    *    @return  true if there is a match.
     *    @stable ICU 2.8
     */
     virtual UBool lookingAt(int64_t startIndex, UErrorCode &status);
@@ -824,7 +824,7 @@ public:
     *  Note that if the input string is changed by the application,
     *     use find(startPos, status) instead of find(), because the saved starting
     *     position may not be valid with the altered input string.
-    *  @return  TRUE if a match is found.
+    *  @return  true if a match is found.
     *  @stable ICU 2.4
     */
     virtual UBool find();
@@ -841,7 +841,7 @@ public:
     *  use find(startPos, status) instead of find(), because the saved starting
     *  position may not be valid with the altered input string.
     *  @param   status  A reference to a UErrorCode to receive any errors.
-    *  @return  TRUE if a match is found.
+    *  @return  true if a match is found.
     * @stable ICU 55
     */
     virtual UBool find(UErrorCode &status);
@@ -852,7 +852,7 @@ public:
     *
     *   @param   start     The (native) index in the input string to begin the search.
     *   @param   status    A reference to a UErrorCode to receive any errors.
-    *   @return  TRUE if a match is found.
+    *   @return  true if a match is found.
     *   @stable ICU 2.4
     */
     virtual UBool find(int64_t start, UErrorCode &status);
@@ -1271,7 +1271,7 @@ public:
       * See useTransparentBounds for a description of transparent and opaque bounds.
       * By default, a matcher uses opaque region boundaries.
       *
-      * @return TRUE if this matcher is using opaque bounds, false if it is not.
+      * @return true if this matcher is using opaque bounds, false if it is not.
       * @stable ICU 4.0
       */
       virtual UBool hasTransparentBounds() const;
@@ -1290,7 +1290,7 @@ public:
       *
       * By default, a matcher uses opaque bounds.
       *
-      * @param   b TRUE for transparent bounds; FALSE for opaque bounds
+      * @param   b true for transparent bounds; false for opaque bounds
       * @return  This Matcher;
       * @stable ICU 4.0
       **/
@@ -1301,7 +1301,7 @@ public:
       * Return true if this matcher is using anchoring bounds.
       * By default, matchers use anchoring region bounds.
       *
-      * @return TRUE if this matcher is using anchoring bounds.
+      * @return true if this matcher is using anchoring bounds.
       * @stable ICU 4.0
       */
       virtual UBool hasAnchoringBounds() const;
@@ -1315,7 +1315,7 @@ public:
       *
       * Anchoring Bounds are the default for regions.
       *
-      * @param b TRUE if to enable anchoring bounds; FALSE to disable them.
+      * @param b true if to enable anchoring bounds; false to disable them.
       * @return  This Matcher
       * @stable ICU 4.0
       */
@@ -1323,26 +1323,26 @@ public:
 
 
     /**
-      * Return TRUE if the most recent matching operation attempted to access
+      * Return true if the most recent matching operation attempted to access
       *  additional input beyond the available input text.
       *  In this case, additional input text could change the results of the match.
       *
       *  hitEnd() is defined for both successful and unsuccessful matches.
-      *  In either case hitEnd() will return TRUE if if the end of the text was
+      *  In either case hitEnd() will return true if if the end of the text was
       *  reached at any point during the matching process.
       *
-      *  @return  TRUE if the most recent match hit the end of input
+      *  @return  true if the most recent match hit the end of input
       *  @stable ICU 4.0
       */
       virtual UBool hitEnd() const;
 
     /**
-      * Return TRUE the most recent match succeeded and additional input could cause
+      * Return true the most recent match succeeded and additional input could cause
       * it to fail. If this method returns false and a match was found, then more input
       * might change the match but the match won't be lost. If a match was not found,
       * then requireEnd has no meaning.
       *
-      * @return TRUE if more input could cause the most recent match to no longer match.
+      * @return true if more input could cause the most recent match to no longer match.
       * @stable ICU 4.0
       */
       virtual UBool requireEnd() const;
@@ -1781,7 +1781,7 @@ private:
     inline REStackFrame *StateSave(REStackFrame *fp, int64_t savePatIdx, UErrorCode &status);
     void                 IncrementTime(UErrorCode &status);
 
-    // Call user find callback function, if set. Return TRUE if operation should be interrupted.
+    // Call user find callback function, if set. Return true if operation should be interrupted.
     inline UBool         findProgressInterrupt(int64_t matchIndex, UErrorCode &status);
 
     int64_t              appendGroup(int32_t groupNum, UText *dest, UErrorCode &status) const;
diff --git a/deps/icu-small/source/i18n/unicode/reldatefmt.h b/deps/icu-small/source/i18n/unicode/reldatefmt.h
index a991bc7986b32d442eaf543cc250d50cff2b1069..f3feeead87b6bcef717ac94c7edafed4a89c3bf2 100644
--- a/deps/icu-small/source/i18n/unicode/reldatefmt.h
+++ b/deps/icu-small/source/i18n/unicode/reldatefmt.h
@@ -175,19 +175,17 @@ typedef enum UDateAbsoluteUnit {
      */
     UDAT_ABSOLUTE_QUARTER,
 
-#ifndef U_HIDE_DRAFT_API
     /**
      * Hour
-     * @draft ICU 65
+     * @stable ICU 65
      */
     UDAT_ABSOLUTE_HOUR,
 
     /**
      * Minute
-     * @draft ICU 65
+     * @stable ICU 65
      */
     UDAT_ABSOLUTE_MINUTE,
-#endif // U_HIDE_DRAFT_API
 
 #ifndef U_HIDE_DEPRECATED_API
     /**
diff --git a/deps/icu-small/source/i18n/unicode/search.h b/deps/icu-small/source/i18n/unicode/search.h
index 986205c62f1ec59ec269aa9a30c2db62bc183fc0..3074839b5fbafc2757026ca0618d954237547354 100644
--- a/deps/icu-small/source/i18n/unicode/search.h
+++ b/deps/icu-small/source/i18n/unicode/search.h
@@ -267,9 +267,9 @@ public:
     /**
      * Equality operator.
      * @param that SearchIterator instance to be compared.
-     * @return TRUE if both BreakIterators are of the same class, have the
+     * @return true if both BreakIterators are of the same class, have the
      *         same behavior, terates over the same text and have the same
-     *         attributes. FALSE otherwise.
+     *         attributes. false otherwise.
      * @stable ICU 2.0
      */
     virtual UBool operator==(const SearchIterator &that) const;
@@ -277,7 +277,7 @@ public:
     /**
      * Not-equal operator.
      * @param that SearchIterator instance to be compared.
-     * @return FALSE if operator== returns TRUE, and vice versa.
+     * @return false if operator== returns true, and vice versa.
      * @stable ICU 2.0
      */
     UBool operator!=(const SearchIterator &that) const;
diff --git a/deps/icu-small/source/i18n/unicode/simpletz.h b/deps/icu-small/source/i18n/unicode/simpletz.h
index d7d4123187e071debbe8adf9aeb8d4ed5aaab0bf..eb888cea675ea0a87acc51fad9d615871e755a6c 100644
--- a/deps/icu-small/source/i18n/unicode/simpletz.h
+++ b/deps/icu-small/source/i18n/unicode/simpletz.h
@@ -620,12 +620,16 @@ public:
     virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
                            int32_t& dstOffset, UErrorCode& ec) const;
 
+#ifndef U_FORCE_HIDE_DRAFT_API
     /**
      * Get time zone offsets from local wall time.
-     * @internal
+     * @draft ICU 69
      */
-    virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
+    virtual void getOffsetFromLocal(
+        UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+        UTimeZoneLocalOption duplicatedTimeOpt,
         int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
+#endif /* U_FORCE_HIDE_DRAFT_API */
 
     /**
      * Returns the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
@@ -714,7 +718,7 @@ public:
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the first transition after the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      * @stable ICU 3.8
      */
     virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
@@ -724,7 +728,7 @@ public:
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the most recent transition before the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      * @stable ICU 3.8
      */
     virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
diff --git a/deps/icu-small/source/i18n/unicode/smpdtfmt.h b/deps/icu-small/source/i18n/unicode/smpdtfmt.h
index b4b0e5fb3908015237c275fd3176df2240eec866..3296c6b3ab75b68cfe2a03c78c6125611ffca6b8 100644
--- a/deps/icu-small/source/i18n/unicode/smpdtfmt.h
+++ b/deps/icu-small/source/i18n/unicode/smpdtfmt.h
@@ -81,7 +81,7 @@ class LocalizedNumberFormatter;
  * the date and time formatting algorithm and pattern letters defined by
  * <a href="http://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table">UTS#35
  * Unicode Locale Data Markup Language (LDML)</a> and further documented for ICU in the
- * <a href="https://sites.google.com/site/icuprojectuserguide/formatparse/datetime?pli=1#TOC-Date-Field-Symbol-Table">ICU
+ * <a href="https://unicode-org.github.io/icu/userguide/format_parse/datetime/#date-field-symbol-table">ICU
  * User Guide</a>. The following pattern letters are currently available (note that the actual
  * values depend on CLDR and may change from the examples shown here):</p>
  *
@@ -1183,11 +1183,11 @@ public:
     /**
      * This is for ICU internal use only. Please do not use.
      * Check whether the 'field' is smaller than all the fields covered in
-     * pattern, return TRUE if it is. The sequence of calendar field,
+     * pattern, return true if it is. The sequence of calendar field,
      * from large to small is: ERA, YEAR, MONTH, DATE, AM_PM, HOUR, MINUTE,...
      * @param field    the calendar field need to check against
-     * @return         TRUE if the 'field' is smaller than all the fields
-     *                 covered in pattern. FALSE otherwise.
+     * @return         true if the 'field' is smaller than all the fields
+     *                 covered in pattern. false otherwise.
      * @internal ICU 4.0
      */
     UBool isFieldUnitIgnored(UCalendarDateFields field) const;
@@ -1196,12 +1196,12 @@ public:
     /**
      * This is for ICU internal use only. Please do not use.
      * Check whether the 'field' is smaller than all the fields covered in
-     * pattern, return TRUE if it is. The sequence of calendar field,
+     * pattern, return true if it is. The sequence of calendar field,
      * from large to small is: ERA, YEAR, MONTH, DATE, AM_PM, HOUR, MINUTE,...
      * @param pattern  the pattern to check against
      * @param field    the calendar field need to check against
-     * @return         TRUE if the 'field' is smaller than all the fields
-     *                 covered in pattern. FALSE otherwise.
+     * @return         true if the 'field' is smaller than all the fields
+     *                 covered in pattern. false otherwise.
      * @internal ICU 4.0
      */
     static UBool isFieldUnitIgnored(const UnicodeString& pattern,
@@ -1305,12 +1305,12 @@ private:
     static UBool isNumeric(char16_t formatChar, int32_t count);
 
     /**
-     * Returns TRUE if the patternOffset is at the start of a numeric field.
+     * Returns true if the patternOffset is at the start of a numeric field.
      */
     static UBool isAtNumericField(const UnicodeString &pattern, int32_t patternOffset);
 
     /**
-     * Returns TRUE if the patternOffset is right after a non-numeric field.
+     * Returns true if the patternOffset is right after a non-numeric field.
      */
     static UBool isAfterNonNumericField(const UnicodeString &pattern, int32_t patternOffset);
 
@@ -1390,11 +1390,11 @@ private:
      * @param text the text being parsed
      * @param textOffset the starting offset into the text. On output
      *                   will be set to the offset of the character after the match
-     * @param whitespaceLenient <code>TRUE</code> if whitespace parse is lenient, <code>FALSE</code> otherwise.
-     * @param partialMatchLenient <code>TRUE</code> if partial match parse is lenient, <code>FALSE</code> otherwise.
-     * @param oldLeniency <code>TRUE</code> if old leniency control is lenient, <code>FALSE</code> otherwise.
+     * @param whitespaceLenient <code>true</code> if whitespace parse is lenient, <code>false</code> otherwise.
+     * @param partialMatchLenient <code>true</code> if partial match parse is lenient, <code>false</code> otherwise.
+     * @param oldLeniency <code>true</code> if old leniency control is lenient, <code>false</code> otherwise.
      *
-     * @return <code>TRUE</code> if the literal text could be matched, <code>FALSE</code> otherwise.
+     * @return <code>true</code> if the literal text could be matched, <code>false</code> otherwise.
      */
     static UBool matchLiterals(const UnicodeString &pattern, int32_t &patternOffset,
                                const UnicodeString &text, int32_t &textOffset,
diff --git a/deps/icu-small/source/i18n/unicode/sortkey.h b/deps/icu-small/source/i18n/unicode/sortkey.h
index d2d3ca9fd57dd8b95de1eb433cdc2f1d32ab729b..14902668a2d4f23716da2c68efe458038bdc866e 100644
--- a/deps/icu-small/source/i18n/unicode/sortkey.h
+++ b/deps/icu-small/source/i18n/unicode/sortkey.h
@@ -150,7 +150,7 @@ public:
     /**
     * Compare if two collation keys are not the same.
     * @param source the collation key to compare to.
-    * @return Returns TRUE if two collation keys are different, FALSE otherwise.
+    * @return Returns true if two collation keys are different, false otherwise.
     * @stable ICU 2.0
     */
     UBool                   operator!=(const CollationKey& source) const;
@@ -159,7 +159,7 @@ public:
     /**
     * Test to see if the key is in an invalid state. The key will be in an
     * invalid state if it couldn't allocate memory for some operation.
-    * @return Returns TRUE if the key is in an invalid, FALSE otherwise.
+    * @return Returns true if the key is in an invalid, false otherwise.
     * @stable ICU 2.0
     */
     UBool                   isBogus(void) const;
diff --git a/deps/icu-small/source/i18n/unicode/stsearch.h b/deps/icu-small/source/i18n/unicode/stsearch.h
index f39637114329866597ac4598d6d31a73dc0d9cf2..3cfd68d64771b9f69a2588aab8a33fbeff7e0c54 100644
--- a/deps/icu-small/source/i18n/unicode/stsearch.h
+++ b/deps/icu-small/source/i18n/unicode/stsearch.h
@@ -292,7 +292,7 @@ public:
     /**
      * Equality operator.
      * @param that instance to be compared.
-     * @return TRUE if both instances have the same attributes,
+     * @return true if both instances have the same attributes,
      *         breakiterators, collators and iterate over the same text
      *         while looking for the same pattern.
      * @stable ICU 2.0
diff --git a/deps/icu-small/source/i18n/unicode/tblcoll.h b/deps/icu-small/source/i18n/unicode/tblcoll.h
index f5dc135bc49fc1aa9afef169210e11066237bca4..1709e836dd4e98621fbbad2a57e83c751d2685db 100644
--- a/deps/icu-small/source/i18n/unicode/tblcoll.h
+++ b/deps/icu-small/source/i18n/unicode/tblcoll.h
@@ -99,20 +99,20 @@ class UVector64;
  * table-based collation.
  * <p>
  * For more information about the collation service see
- * <a href="http://userguide.icu-project.org/collation">the User Guide</a>.
+ * <a href="https://unicode-org.github.io/icu/userguide/collation">the User Guide</a>.
  * <p>
  * Collation service provides correct sorting orders for most locales supported in ICU.
  * If specific data for a locale is not available, the orders eventually falls back
  * to the <a href="http://www.unicode.org/reports/tr35/tr35-collation.html#Root_Collation">CLDR root sort order</a>.
  * <p>
  * Sort ordering may be customized by providing your own set of rules. For more on
- * this subject see the <a href="http://userguide.icu-project.org/collation/customization">
+ * this subject see the <a href="https://unicode-org.github.io/icu/userguide/collation/customization">
  * Collation Customization</a> section of the User Guide.
  * <p>
  * Note, RuleBasedCollator is not to be subclassed.
  * @see        Collator
  */
-class U_I18N_API RuleBasedCollator : public Collator {
+class U_I18N_API RuleBasedCollator U_FINAL : public Collator {
 public:
     /**
      * RuleBasedCollator constructor. This takes the table rules and builds a
@@ -495,7 +495,7 @@ public:
      * just the tailoring.
      *
      * getRules(void) should normally be used instead.
-     * See http://userguide.icu-project.org/collation/customization#TOC-Building-on-Existing-Locales
+     * See https://unicode-org.github.io/icu/userguide/collation/customization#building-on-existing-locales
      * @param delta one of UCOL_TAILORING_ONLY, UCOL_FULL_RULES.
      * @param buffer UnicodeString to store the result rules
      * @stable ICU 2.2
@@ -702,7 +702,7 @@ public:
      *  This string will be normalized.
      *  The structure and the syntax of the string is defined in the "Naming collators"
      *  section of the users guide:
-     *  http://userguide.icu-project.org/collation/concepts#TOC-Collator-naming-scheme
+     *  https://unicode-org.github.io/icu/userguide/collation/concepts#collator-naming-scheme
      *  This function supports preflighting.
      *
      *  This is internal, and intended to be used with delegate converters.
@@ -752,7 +752,7 @@ public:
      * Implements ucol_getContractionsAndExpansions().
      * Gets this collator's sets of contraction strings and/or
      * characters and strings that map to multiple collation elements (expansions).
-     * If addPrefixes is TRUE, then contractions that are expressed as
+     * If addPrefixes is true, then contractions that are expressed as
      * prefix/pre-context rules are included.
      * @param contractions if not NULL, the set to hold the contractions
      * @param expansions if not NULL, the set to hold the expansions
@@ -857,7 +857,7 @@ private:
      * Tests whether a character is "unsafe" for use as a collation starting point.
      *
      * @param c code point or code unit
-     * @return TRUE if c is unsafe
+     * @return true if c is unsafe
      * @see CollationElementIterator#setOffset(int)
      */
     UBool isUnsafe(UChar32 c) const;
diff --git a/deps/icu-small/source/i18n/unicode/timezone.h b/deps/icu-small/source/i18n/unicode/timezone.h
index 4d321186be495d278c622d0a2df34e04be206165..73cae44d533365efdc2a60ea3cac2a979d007e8a 100644
--- a/deps/icu-small/source/i18n/unicode/timezone.h
+++ b/deps/icu-small/source/i18n/unicode/timezone.h
@@ -317,6 +317,19 @@ public:
      */
     static TimeZone* U_EXPORT2 createDefault(void);
 
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * If the locale contains the timezone keyword, creates a copy of that TimeZone.
+     * Otherwise, create the default timezone.
+     *
+     * @param locale a locale which may contains 'timezone' keyword/value.
+     * @return   A TimeZone. Clients are responsible for deleting the time zone
+     *           object returned.
+     * @internal
+     */
+    static TimeZone* U_EXPORT2 forLocaleOrDefault(const Locale& locale);
+#endif  /* U_HIDE_INTERNAL_API */
+
     /**
      * Sets the default time zone (i.e., what's returned by createDefault()) to be the
      * specified time zone.  If NULL is specified for the time zone, the default time
@@ -392,7 +405,7 @@ public:
     *
     * <p>This implementation utilizes <a href="http://unicode.org/cldr/charts/supplemental/zone_tzid.html">
     * Zone-Tzid mapping data</a>. The mapping data is updated time to time. To get the latest changes,
-    * please read the ICU user guide section <a href="http://userguide.icu-project.org/datetime/timezone#TOC-Updating-the-Time-Zone-Data">
+    * please read the ICU user guide section <a href="https://unicode-org.github.io/icu/userguide/datetime/timezone#updating-the-time-zone-data">
     * Updating the Time Zone Data</a>.
     *
     * @param id        A system time zone ID.
@@ -420,7 +433,7 @@ public:
     *
     * <p>This implementation utilizes <a href="http://unicode.org/cldr/charts/supplemental/zone_tzid.html">
     * Zone-Tzid mapping data</a>. The mapping data is updated time to time. To get the latest changes,
-    * please read the ICU user guide section <a href="http://userguide.icu-project.org/datetime/timezone#TOC-Updating-the-Time-Zone-Data">
+    * please read the ICU user guide section <a href="https://unicode-org.github.io/icu/userguide/datetime/timezone#updating-the-time-zone-data">
     * Updating the Time Zone Data</a>.
     *
     * @param winid     A Windows time zone ID.
@@ -696,8 +709,8 @@ public:
      * there are time zones that used daylight savings time in the
      * past, but no longer used currently. For example, Asia/Tokyo has
      * never used daylight savings time since 1951. Most clients would
-     * expect that this method to return <code>FALSE</code> for such case.
-     * The default implementation of this method returns <code>TRUE</code>
+     * expect that this method to return <code>false</code> for such case.
+     * The default implementation of this method returns <code>true</code>
      * when the time zone uses daylight savings time in the current
      * (Gregorian) calendar year.
      * <p>In Java 7, <code>observesDaylightTime()</code> was added in
@@ -914,7 +927,7 @@ private:
      * @param hour Receives parsed hour field
      * @param minute Receives parsed minute field
      * @param second Receives parsed second field
-     * @return Returns TRUE when the given custom id is valid.
+     * @return Returns true when the given custom id is valid.
      */
     static UBool parseCustomID(const UnicodeString& id, int32_t& sign, int32_t& hour,
         int32_t& minute, int32_t& second);
@@ -937,7 +950,7 @@ private:
      * @param hour offset hours
      * @param min offset minutes
      * @param sec offset seconds
-     * @param negative sign of the offset, TRUE for negative offset.
+     * @param negative sign of the offset, true for negative offset.
      * @param id Receves the format result (normalized custom ID)
      * @return The reference to id
      */
diff --git a/deps/icu-small/source/i18n/unicode/tmutamt.h b/deps/icu-small/source/i18n/unicode/tmutamt.h
index 5ce5922cea8346918cdd45ef68c5594da7664c4e..bb9144e2d072dc1f63ecc3d06f2b32b0521eebfd 100644
--- a/deps/icu-small/source/i18n/unicode/tmutamt.h
+++ b/deps/icu-small/source/i18n/unicode/tmutamt.h
@@ -39,7 +39,7 @@ public:
     /**
      * Construct TimeUnitAmount object with the given number and the
      * given time unit.
-     * @param number        a numeric object; number.isNumeric() must be TRUE
+     * @param number        a numeric object; number.isNumeric() must be true
      * @param timeUnitField the time unit field of a time unit
      * @param status        the input-output error code.
      *                      If the number is not numeric or the timeUnitField
diff --git a/deps/icu-small/source/i18n/unicode/translit.h b/deps/icu-small/source/i18n/unicode/translit.h
index fe2568d50aa0205610ce38f878dc9cf80787e9f0..0556b740fab7923f246a77dbcee427ef5c521bf6 100644
--- a/deps/icu-small/source/i18n/unicode/translit.h
+++ b/deps/icu-small/source/i18n/unicode/translit.h
@@ -375,7 +375,7 @@ class TransliteratorIDParser;
  *
  * <p>It is also possible to match the beginning or the end of the text using a <code>UnicodeSet</code>.
  * This is done by including a virtual anchor character '<code>$</code>' at the end of the
- * set pattern. Although this is usually the match chafacter for the end anchor, the set will
+ * set pattern. Although this is usually the match character for the end anchor, the set will
  * match either the beginning or the end of the text, depending on its placement. For
  * example:
  *
@@ -683,8 +683,8 @@ public:
      * unambiguous transliterations.  After the last call to this
      * method, there may be untransliterated text that is waiting for
      * more input to resolve an ambiguity.  In order to perform these
-     * pending transliterations, clients should call {@link
-     * #finishTransliteration } after the last call to this
+     * pending transliterations, clients should call
+     * {@link #finishTransliteration } after the last call to this
      * method has been made.
      *
      * @param text the buffer holding transliterated and untransliterated text
@@ -741,8 +741,7 @@ public:
     /**
      * Transliterates the portion of the text buffer that can be
      * transliterated unambiguosly.  This is a convenience method; see
-     * {@link
-     * #transliterate(Replaceable&, UTransPosition&, const UnicodeString&, UErrorCode&) const }
+     * {@link #transliterate(Replaceable&, UTransPosition&, const UnicodeString&, UErrorCode&) const }
      * for details.
      * @param text the buffer holding transliterated and
      * untransliterated text
@@ -761,8 +760,7 @@ public:
      * <code>transliterate()</code>.
      * @param text the buffer holding transliterated and
      * untransliterated text.
-     * @param index the array of indices previously passed to {@link
-     * #transliterate }
+     * @param index the array of indices previously passed to {@link #transliterate }
      * @stable ICU 2.0
      */
     virtual void finishTransliteration(Replaceable& text,
@@ -882,8 +880,8 @@ public:
      * another transliterator.
      * @param text the text to be transliterated
      * @param index the position indices
-     * @param incremental if TRUE, then assume more characters may be inserted
-     * at index.limit, and postpone processing to accomodate future incoming
+     * @param incremental if true, then assume more characters may be inserted
+     * at index.limit, and postpone processing to accommodate future incoming
      * characters
      * @stable ICU 2.4
      */
@@ -897,14 +895,14 @@ private:
      * Top-level transliteration method, handling filtering, incremental and
      * non-incremental transliteration, and rollback.  All transliteration
      * public API methods eventually call this method with a rollback argument
-     * of TRUE.  Other entities may call this method but rollback should be
-     * FALSE.
+     * of true.  Other entities may call this method but rollback should be
+     * false.
      *
      * <p>If this transliterator has a filter, break up the input text into runs
      * of unfiltered characters.  Pass each run to
      * subclass.handleTransliterate().
      *
-     * <p>In incremental mode, if rollback is TRUE, perform a special
+     * <p>In incremental mode, if rollback is true, perform a special
      * incremental procedure in which several passes are made over the input
      * text, adding one character at a time, and committing successful
      * transliterations as they occur.  Unsuccessful transliterations are rolled
@@ -912,12 +910,12 @@ private:
      *
      * @param text the text to be transliterated
      * @param index the position indices
-     * @param incremental if TRUE, then assume more characters may be inserted
-     * at index.limit, and postpone processing to accomodate future incoming
+     * @param incremental if true, then assume more characters may be inserted
+     * at index.limit, and postpone processing to accommodate future incoming
      * characters
-     * @param rollback if TRUE and if incremental is TRUE, then perform special
+     * @param rollback if true and if incremental is true, then perform special
      * incremental processing, as described above, and undo partial
-     * transliterations where necessary.  If incremental is FALSE then this
+     * transliterations where necessary.  If incremental is false then this
      * parameter is ignored.
      */
     virtual void filteredTransliterate(Replaceable& text,
@@ -968,8 +966,8 @@ public:
 
     /**
      * Returns a name for this transliterator that is appropriate for
-     * display to the user in the default locale.  See {@link
-     * #getDisplayName } for details.
+     * display to the user in the default locale.  See {@link #getDisplayName }
+     * for details.
      * @param ID     the string identifier for this transliterator
      * @param result Output param to receive the display name
      * @return       A reference to 'result'.
@@ -1119,7 +1117,7 @@ public:
      * to recreate this transliterator.
      * @param result the string to receive the rules.  Previous
      * contents will be deleted.
-     * @param escapeUnprintable if TRUE then convert unprintable
+     * @param escapeUnprintable if true then convert unprintable
      * character to their hex escape representations, \\uxxxx or
      * \\Uxxxxxxxx.  Unprintable characters are those other than
      * U+000A, U+0020..U+007E.
@@ -1168,8 +1166,8 @@ public:
      * input text by this Transliterator.  This incorporates this
      * object's current filter; if the filter is changed, the return
      * value of this function will change.  The default implementation
-     * returns an empty set.  Some subclasses may override {@link
-     * #handleGetSourceSet } to return a more precise result.  The
+     * returns an empty set.  Some subclasses may override
+     * {@link #handleGetSourceSet } to return a more precise result. The
      * return result is approximate in any case and is intended for
      * use by tests, tools, or utilities.
      * @param result receives result set; previous contents lost
diff --git a/deps/icu-small/source/i18n/unicode/tzfmt.h b/deps/icu-small/source/i18n/unicode/tzfmt.h
index 6d3863b1e5add8bf1f8ee55c67125e55999ed245..4411865984b54e1b8f5351dae5853d554ab828e8 100644
--- a/deps/icu-small/source/i18n/unicode/tzfmt.h
+++ b/deps/icu-small/source/i18n/unicode/tzfmt.h
@@ -295,7 +295,7 @@ public:
      * Return true if the given Format objects are semantically equal.
      * Objects of different subclasses are considered unequal.
      * @param other The object to be compared with.
-     * @return Return TRUE if the given Format objects are semantically equal.
+     * @return Return true if the given Format objects are semantically equal.
      *                Objects of different subclasses are considered unequal.
      * @stable ICU 50
      */
@@ -814,7 +814,7 @@ private:
      * @param str the string
      * @param codeArray receives the result
      * @param capacity the capacity of codeArray
-     * @return TRUE when the specified code array is fully filled with code points
+     * @return true when the specified code array is fully filled with code points
      *         (no under/overflow).
      */
     static UBool toCodePoints(const UnicodeString& str, UChar32* codeArray, int32_t capacity);
@@ -849,8 +849,8 @@ private:
      * @param text the text contains ISO 8601 style time zone string (e.g. "-08:00", "Z")
      *      at the position.
      * @param pos the position, non-negative error index will be set on failure.
-     * @param extendedOnly TRUE if parsing the text as ISO 8601 extended offset format (e.g. "-08:00"),
-     *      or FALSE to evaluate the text as basic format.
+     * @param extendedOnly true if parsing the text as ISO 8601 extended offset format (e.g. "-08:00"),
+     *      or false to evaluate the text as basic format.
      * @param hasDigitOffset receiving if the parsed zone string contains offset digits.
      * @return the offset from GMT(UTC) in milliseconds for the given ISO 8601 style
      *      time zone string.
diff --git a/deps/icu-small/source/i18n/unicode/tznames.h b/deps/icu-small/source/i18n/unicode/tznames.h
index 860494221df4f8625630d9ce87a09095b7412d3e..19858cd7e2cf6dece14acc21bc75c2195763dfba 100644
--- a/deps/icu-small/source/i18n/unicode/tznames.h
+++ b/deps/icu-small/source/i18n/unicode/tznames.h
@@ -139,7 +139,7 @@ public:
     /**
      * Return true if the given TimeZoneNames objects are semantically equal.
      * @param other the object to be compared with.
-     * @return Return TRUE if the given Format objects are semantically equal.
+     * @return Return true if the given Format objects are semantically equal.
      * @stable ICU 50
      */
     virtual UBool operator==(const TimeZoneNames& other) const = 0;
@@ -148,7 +148,7 @@ public:
      * Return true if the given TimeZoneNames objects are not semantically
      * equal.
      * @param other the object to be compared with.
-     * @return Return TRUE if the given Format objects are not semantically equal.
+     * @return Return true if the given Format objects are not semantically equal.
      * @stable ICU 50
      */
     UBool operator!=(const TimeZoneNames& other) const { return !operator==(other); }
@@ -193,7 +193,7 @@ public:
 
     /**
      * Returns an enumeration of all available meta zone IDs used by the given time zone.
-     * @param tzID The canoical tiem zone ID.
+     * @param tzID The canonical time zone ID.
      * @param status Receives the status.
      * @return an enumeration object, owned by the caller.
      * @stable ICU 50
@@ -373,7 +373,7 @@ public:
          * Gets the zone ID of a match at the specified index.
          * @param idx The index
          * @param tzID Receives the zone ID.
-         * @return TRUE if the zone ID was set to tzID.
+         * @return true if the zone ID was set to tzID.
          * @internal
          */
         UBool getTimeZoneIDAt(int32_t idx, UnicodeString& tzID) const;
@@ -382,7 +382,7 @@ public:
          * Gets the metazone ID of a match at the specified index.
          * @param idx The index
          * @param mzID Receives the metazone ID
-         * @return TRUE if the meta zone ID was set to mzID.
+         * @return true if the meta zone ID was set to mzID.
          * @internal
          */
         UBool getMetaZoneIDAt(int32_t idx, UnicodeString& mzID) const;
diff --git a/deps/icu-small/source/i18n/unicode/tzrule.h b/deps/icu-small/source/i18n/unicode/tzrule.h
index c6d6b9631fcd69abc83a4ec12d5212c9df986be4..2a983ef58ac448b0ca5e6ec08bfb611eb267ad9e 100644
--- a/deps/icu-small/source/i18n/unicode/tzrule.h
+++ b/deps/icu-small/source/i18n/unicode/tzrule.h
@@ -372,7 +372,7 @@ public:
 
 /**
  * <code>AnnualTimeZoneRule</code> is a class used for representing a time zone
- * rule which takes effect annually.  The calenday system used for the rule is
+ * rule which takes effect annually.  The calendar system used for the rule is
  * is based on Gregorian calendar
  *
  * @stable ICU 3.8
diff --git a/deps/icu-small/source/i18n/unicode/ucal.h b/deps/icu-small/source/i18n/unicode/ucal.h
index eee2ae9e226474d2072971e66a531c178cbd002b..04c4a25de9995147b11364f13df6b1c62bc36e75 100644
--- a/deps/icu-small/source/i18n/unicode/ucal.h
+++ b/deps/icu-small/source/i18n/unicode/ucal.h
@@ -13,7 +13,10 @@
 #include "unicode/utypes.h"
 #include "unicode/uenum.h"
 #include "unicode/uloc.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 #if !UCONFIG_NO_FORMATTING
 
@@ -32,7 +35,7 @@
  *
  * <p>
  * Types of <code>UCalendar</code> interpret a <code>UDate</code>
- * according to the rules of a specific calendar system. The U_STABLE
+ * according to the rules of a specific calendar system. The C API
  * provides the enum UCalendarType with UCAL_TRADITIONAL and
  * UCAL_GREGORIAN.
  * <p>
@@ -584,7 +587,7 @@ typedef enum USystemTimeZoneType USystemTimeZoneType;
  *          *ec will indicate the error.
  * @stable ICU 4.8
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucal_openTimeZoneIDEnumeration(USystemTimeZoneType zoneType, const char* region,
                                 const int32_t* rawOffset, UErrorCode* ec);
 
@@ -599,7 +602,7 @@ ucal_openTimeZoneIDEnumeration(USystemTimeZoneType zoneType, const char* region,
  *
  * @stable ICU 2.6
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucal_openTimeZones(UErrorCode* ec);
 
 /**
@@ -618,7 +621,7 @@ ucal_openTimeZones(UErrorCode* ec);
  *
  * @stable ICU 2.6
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucal_openCountryTimeZones(const char* country, UErrorCode* ec);
 
 /**
@@ -644,7 +647,7 @@ ucal_openCountryTimeZones(const char* country, UErrorCode* ec);
  *
  * @stable ICU 2.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec);
 
 /**
@@ -656,11 +659,9 @@ ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec);
  *
  * @stable ICU 2.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_setDefaultTimeZone(const UChar* zoneID, UErrorCode* ec);
 
-#ifndef U_HIDE_DRAFT_API
-
 /**
  * Return the current host time zone. The host time zone is detected from
  * the current host system configuration by querying the host operating
@@ -688,13 +689,11 @@ ucal_setDefaultTimeZone(const UChar* zoneID, UErrorCode* ec);
  *
  * @see #UCAL_UNKNOWN_ZONE_ID
  *
- * @draft ICU 65
+ * @stable ICU 65
  */
-U_DRAFT int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getHostTimeZone(UChar *result, int32_t resultCapacity, UErrorCode *ec);
 
-#endif // U_HIDE_DRAFT_API
-
 /**
  * Return the amount of time in milliseconds that the clock is
  * advanced during daylight savings time for the given time zone, or
@@ -711,7 +710,7 @@ ucal_getHostTimeZone(UChar *result, int32_t resultCapacity, UErrorCode *ec);
  *
  * @stable ICU 2.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getDSTSavings(const UChar* zoneID, UErrorCode* ec);
 
 /**
@@ -720,7 +719,7 @@ ucal_getDSTSavings(const UChar* zoneID, UErrorCode* ec);
  * @return The current date and time.
  * @stable ICU 2.0
  */
-U_STABLE UDate U_EXPORT2
+U_CAPI UDate U_EXPORT2
 ucal_getNow(void);
 
 /**
@@ -746,7 +745,7 @@ ucal_getNow(void);
  * @see #UCAL_UNKNOWN_ZONE_ID
  * @stable ICU 2.0
  */
-U_STABLE UCalendar* U_EXPORT2
+U_CAPI UCalendar* U_EXPORT2
 ucal_open(const UChar*   zoneID,
           int32_t        len,
           const char*    locale,
@@ -759,7 +758,7 @@ ucal_open(const UChar*   zoneID,
  * @param cal The UCalendar to close.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_close(UCalendar *cal);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -789,7 +788,7 @@ U_NAMESPACE_END
  * @return A pointer to a UCalendar identical to cal.
  * @stable ICU 4.0
  */
-U_STABLE UCalendar* U_EXPORT2
+U_CAPI UCalendar* U_EXPORT2
 ucal_clone(const UCalendar* cal,
            UErrorCode*      status);
 
@@ -802,7 +801,7 @@ ucal_clone(const UCalendar* cal,
  * @param status A pointer to an UErrorCode to receive any errors.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_setTimeZone(UCalendar*    cal,
                  const UChar*  zoneID,
                  int32_t       len,
@@ -818,7 +817,7 @@ ucal_setTimeZone(UCalendar*    cal,
  * @return              The total buffer size needed; if greater than resultLength, the output was truncated.
  * @stable ICU 51
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getTimeZoneID(const UCalendar *cal,
                    UChar *result,
                    int32_t resultLength,
@@ -855,7 +854,7 @@ typedef enum UCalendarDisplayNameType UCalendarDisplayNameType;
  * @return             The total buffer size needed; if greater than resultLength, the output was truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getTimeZoneDisplayName(const UCalendar*          cal,
                             UCalendarDisplayNameType  type,
                             const char*               locale,
@@ -868,10 +867,10 @@ ucal_getTimeZoneDisplayName(const UCalendar*          cal,
  * Daylight savings time is not used in all parts of the world.
  * @param cal The UCalendar to query.
  * @param status A pointer to an UErrorCode to receive any errors
- * @return TRUE if cal is currently in daylight savings time, FALSE otherwise
+ * @return true if cal is currently in daylight savings time, false otherwise
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucal_inDaylightTime(const UCalendar*  cal,
                     UErrorCode*       status );
 
@@ -895,7 +894,7 @@ ucal_inDaylightTime(const UCalendar*  cal,
  * @see ucal_getGregorianChange
  * @stable ICU 3.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode);
 
 /**
@@ -918,7 +917,7 @@ ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode);
  * @see ucal_setGregorianChange
  * @stable ICU 3.6
  */
-U_STABLE UDate U_EXPORT2
+U_CAPI UDate U_EXPORT2
 ucal_getGregorianChange(const UCalendar *cal, UErrorCode *pErrorCode);
 
 /**
@@ -999,7 +998,7 @@ typedef enum UCalendarWallTimeOption UCalendarWallTimeOption;
  * @see ucal_setAttribute
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getAttribute(const UCalendar*    cal,
                   UCalendarAttribute  attr);
 
@@ -1014,7 +1013,7 @@ ucal_getAttribute(const UCalendar*    cal,
  * @see ucal_getAttribute
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_setAttribute(UCalendar*          cal,
                   UCalendarAttribute  attr,
                   int32_t             newValue);
@@ -1028,7 +1027,7 @@ ucal_setAttribute(UCalendar*          cal,
  * @see ucal_countAvailable
  * @stable ICU 2.0
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 ucal_getAvailable(int32_t localeIndex);
 
 /**
@@ -1039,7 +1038,7 @@ ucal_getAvailable(int32_t localeIndex);
  * @see ucal_getAvailable
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_countAvailable(void);
 
 /**
@@ -1053,7 +1052,7 @@ ucal_countAvailable(void);
  * @see ucal_setDateTime
  * @stable ICU 2.0
  */
-U_STABLE UDate U_EXPORT2
+U_CAPI UDate U_EXPORT2
 ucal_getMillis(const UCalendar*  cal,
                UErrorCode*       status);
 
@@ -1068,7 +1067,7 @@ ucal_getMillis(const UCalendar*  cal,
  * @see ucal_setDateTime
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_setMillis(UCalendar*   cal,
                UDate        dateTime,
                UErrorCode*  status );
@@ -1087,7 +1086,7 @@ ucal_setMillis(UCalendar*   cal,
  * @see ucal_setDateTime
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_setDate(UCalendar*   cal,
              int32_t      year,
              int32_t      month,
@@ -1111,7 +1110,7 @@ ucal_setDate(UCalendar*   cal,
  * @see ucal_setDate
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_setDateTime(UCalendar*   cal,
                  int32_t      year,
                  int32_t      month,
@@ -1122,15 +1121,15 @@ ucal_setDateTime(UCalendar*   cal,
                  UErrorCode*  status);
 
 /**
- * Returns TRUE if two UCalendars are equivalent.  Equivalent
+ * Returns true if two UCalendars are equivalent.  Equivalent
  * UCalendars will behave identically, but they may be set to
  * different times.
  * @param cal1 The first of the UCalendars to compare.
  * @param cal2 The second of the UCalendars to compare.
- * @return TRUE if cal1 and cal2 are equivalent, FALSE otherwise.
+ * @return true if cal1 and cal2 are equivalent, false otherwise.
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucal_equivalentTo(const UCalendar*  cal1,
                   const UCalendar*  cal2);
 
@@ -1152,7 +1151,7 @@ ucal_equivalentTo(const UCalendar*  cal1,
  * @see ucal_roll
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_add(UCalendar*           cal,
          UCalendarDateFields  field,
          int32_t              amount,
@@ -1182,7 +1181,7 @@ ucal_add(UCalendar*           cal,
  * @see ucal_add
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_roll(UCalendar*           cal,
           UCalendarDateFields  field,
           int32_t              amount,
@@ -1204,7 +1203,7 @@ ucal_roll(UCalendar*           cal,
  * @see ucal_clear
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_get(const UCalendar*     cal,
          UCalendarDateFields  field,
          UErrorCode*          status );
@@ -1224,7 +1223,7 @@ ucal_get(const UCalendar*     cal,
  * @see ucal_clear
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_set(UCalendar*           cal,
          UCalendarDateFields  field,
          int32_t              value);
@@ -1237,14 +1236,14 @@ ucal_set(UCalendar*           cal,
  * UCAL_WEEK_OF_YEAR, UCAL_WEEK_OF_MONTH, UCAL_DATE, UCAL_DAY_OF_YEAR, UCAL_DAY_OF_WEEK,
  * UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_AM_PM, UCAL_HOUR, UCAL_HOUR_OF_DAY, UCAL_MINUTE, UCAL_SECOND,
  * UCAL_MILLISECOND, UCAL_ZONE_OFFSET, UCAL_DST_OFFSET.
- * @return TRUE if field is set, FALSE otherwise.
+ * @return true if field is set, false otherwise.
  * @see ucal_get
  * @see ucal_set
  * @see ucal_clearField
  * @see ucal_clear
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucal_isSet(const UCalendar*     cal,
            UCalendarDateFields  field);
 
@@ -1262,7 +1261,7 @@ ucal_isSet(const UCalendar*     cal,
  * @see ucal_clear
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_clearField(UCalendar*           cal,
                 UCalendarDateFields  field);
 
@@ -1276,7 +1275,7 @@ ucal_clearField(UCalendar*           cal,
  * @see ucal_clearField
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucal_clear(UCalendar* calendar);
 
 /**
@@ -1315,7 +1314,7 @@ typedef enum UCalendarLimitType UCalendarLimitType;
  * @return The requested value.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getLimit(const UCalendar*     cal,
               UCalendarDateFields  field,
               UCalendarLimitType   type,
@@ -1328,7 +1327,7 @@ ucal_getLimit(const UCalendar*     cal,
  *  @return the locale name
  *  @stable ICU 2.8
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucal_getLocaleByType(const UCalendar *cal, ULocDataLocaleType type, UErrorCode* status);
 
 /**
@@ -1337,7 +1336,7 @@ ucal_getLocaleByType(const UCalendar *cal, ULocDataLocaleType type, UErrorCode*
  * @return the version string, such as "2007f"
  * @stable ICU 3.8
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucal_getTZDataVersion(UErrorCode* status);
 
 /**
@@ -1358,7 +1357,7 @@ ucal_getTZDataVersion(UErrorCode* status);
  *                  null.
  * @stable ICU 4.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getCanonicalTimeZoneID(const UChar* id, int32_t len,
                             UChar* result, int32_t resultCapacity, UBool *isSystemID, UErrorCode* status);
 /**
@@ -1368,7 +1367,7 @@ ucal_getCanonicalTimeZoneID(const UChar* id, int32_t len,
  * @return The resource keyword value string.
  * @stable ICU 4.2
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucal_getType(const UCalendar *cal, UErrorCode* status);
 
 /**
@@ -1387,7 +1386,7 @@ ucal_getType(const UCalendar *cal, UErrorCode* status);
  * @return a string enumeration over keyword values for the given key and the locale.
  * @stable ICU 4.2
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucal_getKeywordValuesForLocale(const char* key,
                                const char* locale,
                                UBool commonlyUsed,
@@ -1442,7 +1441,7 @@ typedef enum UCalendarWeekdayType UCalendarWeekdayType;
  * @return The UCalendarWeekdayType for the day of the week.
  * @stable ICU 4.4
  */
-U_STABLE UCalendarWeekdayType U_EXPORT2
+U_CAPI UCalendarWeekdayType U_EXPORT2
 ucal_getDayOfWeekType(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode* status);
 
 /**
@@ -1460,20 +1459,20 @@ ucal_getDayOfWeekType(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErro
  * @return The milliseconds after midnight at which the weekend begins or ends.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getWeekendTransition(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode *status);
 
 /**
- * Returns TRUE if the given UDate is in the weekend in
+ * Returns true if the given UDate is in the weekend in
  * this calendar system.
  * @param cal The UCalendar to query.
  * @param date The UDate in question.
  * @param status The error code for the operation.
- * @return TRUE if the given UDate is in the weekend in
- * this calendar system, FALSE otherwise.
+ * @return true if the given UDate is in the weekend in
+ * this calendar system, false otherwise.
  * @stable ICU 4.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucal_isWeekend(const UCalendar *cal, UDate date, UErrorCode *status);
 
 /**
@@ -1500,7 +1499,7 @@ ucal_isWeekend(const UCalendar *cal, UDate date, UErrorCode *status);
  * @return The date difference for the specified field.
  * @stable ICU 4.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getFieldDifference(UCalendar* cal,
                         UDate target,
                         UCalendarDateFields field,
@@ -1544,17 +1543,17 @@ typedef enum UTimeZoneTransitionType UTimeZoneTransitionType; /**< @stable ICU 5
 * the calendar's current date, in the time zone to which the calendar
 * is currently set. If there is no known time zone transition of the
 * requested type relative to the calendar's date, the function returns
-* FALSE.
+* false.
 * @param cal The UCalendar to query.
 * @param type The type of transition desired.
 * @param transition A pointer to a UDate to be set to the transition time.
-*         If the function returns FALSE, the value set is unspecified.
+*         If the function returns false, the value set is unspecified.
 * @param status A pointer to a UErrorCode to receive any errors.
-* @return TRUE if a valid transition time is set in *transition, FALSE
+* @return true if a valid transition time is set in *transition, false
 *         otherwise.
 * @stable ICU 50
 */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucal_getTimeZoneTransitionDate(const UCalendar* cal, UTimeZoneTransitionType type,
                                UDate* transition, UErrorCode* status);
 
@@ -1569,7 +1568,7 @@ ucal_getTimeZoneTransitionDate(const UCalendar* cal, UTimeZoneTransitionType typ
 *
 * <p>This implementation utilizes <a href="http://unicode.org/cldr/charts/supplemental/zone_tzid.html">
 * Zone-Tzid mapping data</a>. The mapping data is updated time to time. To get the latest changes,
-* please read the ICU user guide section <a href="http://userguide.icu-project.org/datetime/timezone#TOC-Updating-the-Time-Zone-Data">
+* please read the ICU user guide section <a href="https://unicode-org.github.io/icu/userguide/datetime/timezone#updating-the-time-zone-data">
 * Updating the Time Zone Data</a>.
 *
 * @param id            A system time zone ID.
@@ -1582,7 +1581,7 @@ ucal_getTimeZoneTransitionDate(const UCalendar* cal, UTimeZoneTransitionType typ
 *
 * @stable ICU 52
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getWindowsTimeZoneID(const UChar* id, int32_t len,
                             UChar* winid, int32_t winidCapacity, UErrorCode* status);
 
@@ -1600,7 +1599,7 @@ ucal_getWindowsTimeZoneID(const UChar* id, int32_t len,
 *
 * <p>This implementation utilizes <a href="http://unicode.org/cldr/charts/supplemental/zone_tzid.html">
 * Zone-Tzid mapping data</a>. The mapping data is updated time to time. To get the latest changes,
-* please read the ICU user guide section <a href="http://userguide.icu-project.org/datetime/timezone#TOC-Updating-the-Time-Zone-Data">
+* please read the ICU user guide section <a href="https://unicode-org.github.io/icu/userguide/datetime/timezone#updating-the-time-zone-data">
 * Updating the Time Zone Data</a>.
 *
 * @param winid         A Windows time zone ID.
@@ -1614,10 +1613,113 @@ ucal_getWindowsTimeZoneID(const UChar* id, int32_t len,
 *
 * @stable ICU 52
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucal_getTimeZoneIDForWindowsID(const UChar* winid, int32_t len, const char* region,
                                 UChar* id, int32_t idCapacity, UErrorCode* status);
 
+#ifndef U_FORCE_HIDE_DRAFT_API
+/**
+ * Options used by ucal_getTimeZoneOffsetFromLocal and BasicTimeZone::getOffsetFromLocal()
+ * to specify how to interpret an input time when it does not exist, or when it is ambiguous,
+ * around a time zone transition.
+ * @draft ICU 69
+ */
+enum UTimeZoneLocalOption {
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * An input time is always interpreted as local time before
+     * a time zone transition.
+     * @draft ICU 69
+     */
+    UCAL_TZ_LOCAL_FORMER = 0x04,
+    /**
+     * An input time is always interpreted as local time after
+     * a time zone transition.
+     * @draft ICU 69
+     */
+    UCAL_TZ_LOCAL_LATTER = 0x0C,
+    /**
+     * An input time is interpreted as standard time when local
+     * time is switched to/from daylight saving time. When both
+     * sides of a time zone transition are standard time,
+     * or daylight saving time, the local time before the
+     * transition is used.
+     * @draft ICU 69
+     */
+    UCAL_TZ_LOCAL_STANDARD_FORMER = UCAL_TZ_LOCAL_FORMER | 0x01,
+    /**
+     * An input time is interpreted as standard time when local
+     * time is switched to/from daylight saving time. When both
+     * sides of a time zone transition are standard time,
+     * or daylight saving time, the local time after the
+     * transition is used.
+     * @draft ICU 69
+     */
+    UCAL_TZ_LOCAL_STANDARD_LATTER = UCAL_TZ_LOCAL_LATTER | 0x01,
+    /**
+     * An input time is interpreted as daylight saving time when
+     * local time is switched to/from standard time. When both
+     * sides of a time zone transition are standard time,
+     * or daylight saving time, the local time before the
+     * transition is used.
+     * @draft ICU 69
+     */
+    UCAL_TZ_LOCAL_DAYLIGHT_FORMER = UCAL_TZ_LOCAL_FORMER | 0x03,
+    /**
+     * An input time is interpreted as daylight saving time when
+     * local time is switched to/from standard time. When both
+     * sides of a time zone transition are standard time,
+     * or daylight saving time, the local time after the
+     * transition is used.
+     * @draft ICU 69
+     */
+    UCAL_TZ_LOCAL_DAYLIGHT_LATTER = UCAL_TZ_LOCAL_LATTER | 0x03,
+#else /* U_HIDE_DRAFT_API */
+    /**
+     * Dummy value to prevent empty enum if U_HIDE_DRAFT_API.
+     * This will go away when draft conditionals are removed.
+     * @internal
+     */
+    UCAL_TZ_LOCAL_NONE = 0,
+#endif /* U_HIDE_DRAFT_API */
+};
+typedef enum UTimeZoneLocalOption UTimeZoneLocalOption; /**< @draft ICU 69 */
+
+/**
+* Returns the time zone raw and GMT offset for the given moment
+* in time.  Upon return, local-millis = GMT-millis + rawOffset +
+* dstOffset.  All computations are performed in the proleptic
+* Gregorian calendar.
+*
+* @param cal The UCalendar which specify the local date and time value to query.
+* @param nonExistingTimeOpt The option to indicate how to interpret the date and
+* time in the calendar represent a local time that skipped at a positive time
+* zone transitions (e.g. when the daylight saving time starts or the time zone
+* offset is increased due to a time zone rule change).
+* @param duplicatedTimeOpt The option to indicate how to interpret the date and
+* time in the calendar represent a local time that repeating multiple times at a
+* negative time zone transition (e.g. when the daylight saving time ends or the
+* time zone offset is decreased due to a time zone rule change)
+* @param rawOffset output parameter to receive the raw offset, that
+* is, the offset not including DST adjustments.
+* If the status is set to one of the error code, the value set is unspecified.
+* @param dstOffset output parameter to receive the DST offset,
+* that is, the offset to be added to `rawOffset' to obtain the
+* total offset between local and GMT time. If DST is not in
+* effect, this value is zero; otherwise it is a positive value,
+* typically one hour.
+* If the status is set to one of the error code, the value set is unspecified.
+* @param status A pointer to a UErrorCode to receive any errors.
+* @draft ICU 69
+*/
+U_CAPI void U_EXPORT2
+ucal_getTimeZoneOffsetFromLocal(
+    const UCalendar* cal,
+    UTimeZoneLocalOption nonExistingTimeOpt,
+    UTimeZoneLocalOption duplicatedTimeOpt,
+    int32_t* rawOffset, int32_t* dstOffset, UErrorCode* status);
+#endif /* U_FORCE_HIDE_DRAFT_API */
+
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 #endif
diff --git a/deps/icu-small/source/i18n/unicode/ucol.h b/deps/icu-small/source/i18n/unicode/ucol.h
index 34b5d2476aaaa5f64b418904a4802a44e59b5175..6122cc1d59cbf3eac5eb920b5890d84b0eccdd10 100644
--- a/deps/icu-small/source/i18n/unicode/ucol.h
+++ b/deps/icu-small/source/i18n/unicode/ucol.h
@@ -15,12 +15,15 @@
 #if !UCONFIG_NO_COLLATION
 
 #include "unicode/unorm.h"
-#include "unicode/localpointer.h"
 #include "unicode/parseerr.h"
 #include "unicode/uloc.h"
 #include "unicode/uset.h"
 #include "unicode/uscript.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: Collator
@@ -32,14 +35,14 @@
  * searching and sorting routines for natural language text.
  * <p>
  * For more information about the collation service see
- * <a href="http://userguide.icu-project.org/collation">the User Guide</a>.
+ * <a href="https://unicode-org.github.io/icu/userguide/collation">the User Guide</a>.
  * <p>
  * Collation service provides correct sorting orders for most locales supported in ICU.
  * If specific data for a locale is not available, the orders eventually falls back
  * to the <a href="http://www.unicode.org/reports/tr35/tr35-collation.html#Root_Collation">CLDR root sort order</a>.
  * <p>
  * Sort ordering may be customized by providing your own set of rules. For more on
- * this subject see the <a href="http://userguide.icu-project.org/collation/customization">
+ * this subject see the <a href="https://unicode-org.github.io/icu/userguide/collation/customization">
  * Collation Customization</a> section of the User Guide.
  * <p>
  * @see         UCollationResult
@@ -80,7 +83,7 @@ typedef enum {
 } UCollationResult ;
 
 
-/** Enum containing attribute values for controling collation behavior.
+/** Enum containing attribute values for controlling collation behavior.
  * Here are all the allowable values. Not every attribute can take every value. The only
  * universal value is UCOL_DEFAULT, which resets the attribute value to the predefined
  * value for that locale
@@ -367,7 +370,7 @@ typedef enum {
    * Retrieves the "UCA rules" concatenated with the tailoring rules.
    * The "UCA rules" are an <i>approximation</i> of the root collator's sort order.
    * They are almost never used or useful at runtime and can be removed from the data.
-   * See http://userguide.icu-project.org/collation/customization#TOC-Building-on-Existing-Locales
+   * See https://unicode-org.github.io/icu/userguide/collation/customization#building-on-existing-locales
    * @stable ICU 2.0
    */
   UCOL_FULL_RULES
@@ -381,7 +384,7 @@ typedef enum {
  * Starting with ICU 54, collation attributes can be specified via locale keywords as well,
  * in the old locale extension syntax ("el@colCaseFirst=upper")
  * or in language tag syntax ("el-u-kf-upper").
- * See <a href="http://userguide.icu-project.org/collation/api">User Guide: Collation API</a>.
+ * See <a href="https://unicode-org.github.io/icu/userguide/collation/api">User Guide: Collation API</a>.
  *
  * The UCollator pointer is used in all the calls to the Collation
  * service. After finished, collator must be disposed of by calling
@@ -398,7 +401,7 @@ typedef enum {
  * @see ucol_close
  * @stable ICU 2.0
  */
-U_STABLE UCollator* U_EXPORT2
+U_CAPI UCollator* U_EXPORT2
 ucol_open(const char *loc, UErrorCode *status);
 
 /**
@@ -426,7 +429,7 @@ ucol_open(const char *loc, UErrorCode *status);
  * @see ucol_close
  * @stable ICU 2.0
  */
-U_STABLE UCollator* U_EXPORT2
+U_CAPI UCollator* U_EXPORT2
 ucol_openRules( const UChar        *rules,
                 int32_t            rulesLength,
                 UColAttributeValue normalizationMode,
@@ -439,7 +442,7 @@ ucol_openRules( const UChar        *rules,
  * Open a collator defined by a short form string.
  * The structure and the syntax of the string is defined in the "Naming collators"
  * section of the users guide:
- * http://userguide.icu-project.org/collation/concepts#TOC-Collator-naming-scheme
+ * https://unicode-org.github.io/icu/userguide/collation/concepts#collator-naming-scheme
  * Attributes are overriden by the subsequent attributes. So, for "S2_S3", final
  * strength will be 3. 3066bis locale overrides individual locale parts.
  * The call to this function is equivalent to a call to ucol_open, followed by a
@@ -449,12 +452,12 @@ ucol_openRules( const UChar        *rules,
  *                   state for a locale.
  * @param parseError if not NULL, structure that will get filled with error's pre
  *                   and post context in case of error.
- * @param forceDefaults if FALSE, the settings that are the same as the collator
+ * @param forceDefaults if false, the settings that are the same as the collator
  *                   default settings will not be applied (for example, setting
  *                   French secondary on a French collator would not be executed).
- *                   If TRUE, all the settings will be applied regardless of the
+ *                   If true, all the settings will be applied regardless of the
  *                   collator default value. If the definition
- *                   strings are to be cached, should be set to FALSE.
+ *                   strings are to be cached, should be set to false.
  * @param status     Error code. Apart from regular error conditions connected to
  *                   instantiating collators (like out of memory or similar), this
  *                   API will return an error if an invalid attribute or attribute/value
@@ -506,7 +509,7 @@ ucol_getContractions( const UCollator *coll,
  *
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_getContractionsAndExpansions( const UCollator *coll,
                   USet *contractions, USet *expansions,
                   UBool addPrefixes, UErrorCode *status);
@@ -521,7 +524,7 @@ ucol_getContractionsAndExpansions( const UCollator *coll,
  * @see ucol_safeClone
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_close(UCollator *coll);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -558,7 +561,7 @@ U_NAMESPACE_END
  * @see ucol_equal
  * @stable ICU 2.0
  */
-U_STABLE UCollationResult U_EXPORT2
+U_CAPI UCollationResult U_EXPORT2
 ucol_strcoll(    const    UCollator    *coll,
         const    UChar        *source,
         int32_t            sourceLength,
@@ -583,7 +586,7 @@ ucol_strcoll(    const    UCollator    *coll,
 * @see ucol_equal
 * @stable ICU 50
 */
-U_STABLE UCollationResult U_EXPORT2
+U_CAPI UCollationResult U_EXPORT2
 ucol_strcollUTF8(
         const UCollator *coll,
         const char      *source,
@@ -600,13 +603,13 @@ ucol_strcollUTF8(
  * @param sourceLength The length of source, or -1 if null-terminated.
  * @param target The target string.
  * @param targetLength The length of target, or -1 if null-terminated.
- * @return TRUE if source is greater than target, FALSE otherwise.
+ * @return true if source is greater than target, false otherwise.
  * @see ucol_strcoll
  * @see ucol_greaterOrEqual
  * @see ucol_equal
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucol_greater(const UCollator *coll,
              const UChar     *source, int32_t sourceLength,
              const UChar     *target, int32_t targetLength);
@@ -619,13 +622,13 @@ ucol_greater(const UCollator *coll,
  * @param sourceLength The length of source, or -1 if null-terminated.
  * @param target The target string.
  * @param targetLength The length of target, or -1 if null-terminated.
- * @return TRUE if source is greater than or equal to target, FALSE otherwise.
+ * @return true if source is greater than or equal to target, false otherwise.
  * @see ucol_strcoll
  * @see ucol_greater
  * @see ucol_equal
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucol_greaterOrEqual(const UCollator *coll,
                     const UChar     *source, int32_t sourceLength,
                     const UChar     *target, int32_t targetLength);
@@ -638,13 +641,13 @@ ucol_greaterOrEqual(const UCollator *coll,
  * @param sourceLength The length of source, or -1 if null-terminated.
  * @param target The target string.
  * @param targetLength The length of target, or -1 if null-terminated.
- * @return TRUE if source is equal to target, FALSE otherwise
+ * @return true if source is equal to target, false otherwise
  * @see ucol_strcoll
  * @see ucol_greater
  * @see ucol_greaterOrEqual
  * @stable ICU 2.0
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucol_equal(const UCollator *coll,
            const UChar     *source, int32_t sourceLength,
            const UChar     *target, int32_t targetLength);
@@ -661,7 +664,7 @@ ucol_equal(const UCollator *coll,
  * @see ucol_strcoll
  * @stable ICU 2.6
  */
-U_STABLE UCollationResult U_EXPORT2
+U_CAPI UCollationResult U_EXPORT2
 ucol_strcollIter(  const    UCollator    *coll,
                   UCharIterator *sIter,
                   UCharIterator *tIter,
@@ -676,7 +679,7 @@ ucol_strcollIter(  const    UCollator    *coll,
  * @see ucol_setStrength
  * @stable ICU 2.0
  */
-U_STABLE UCollationStrength U_EXPORT2
+U_CAPI UCollationStrength U_EXPORT2
 ucol_getStrength(const UCollator *coll);
 
 /**
@@ -688,7 +691,7 @@ ucol_getStrength(const UCollator *coll);
  * @see ucol_getStrength
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_setStrength(UCollator *coll,
                  UCollationStrength strength);
 
@@ -708,7 +711,7 @@ ucol_setStrength(UCollator *coll,
  * @see UColReorderCode
  * @stable ICU 4.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getReorderCodes(const UCollator* coll,
                     int32_t* dest,
                     int32_t destCapacity,
@@ -753,7 +756,7 @@ ucol_getReorderCodes(const UCollator* coll,
  * @see UColReorderCode
  * @stable ICU 4.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_setReorderCodes(UCollator* coll,
                     const int32_t* reorderCodes,
                     int32_t reorderCodesLength,
@@ -778,7 +781,7 @@ ucol_setReorderCodes(UCollator* coll,
  * @see UColReorderCode
  * @stable ICU 4.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getEquivalentReorderCodes(int32_t reorderCode,
                     int32_t* dest,
                     int32_t destCapacity,
@@ -796,7 +799,7 @@ ucol_getEquivalentReorderCodes(int32_t reorderCode,
  * the output was truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getDisplayName(    const    char        *objLoc,
             const    char        *dispLoc,
             UChar             *result,
@@ -812,7 +815,7 @@ ucol_getDisplayName(    const    char        *objLoc,
  * @see ucol_countAvailable
  * @stable ICU 2.0
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 ucol_getAvailable(int32_t localeIndex);
 
 /**
@@ -823,7 +826,7 @@ ucol_getAvailable(int32_t localeIndex);
  * @see ucol_getAvailable
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_countAvailable(void);
 
 #if !UCONFIG_NO_SERVICE
@@ -835,7 +838,7 @@ ucol_countAvailable(void);
  * responsible for closing the result.
  * @stable ICU 3.0
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucol_openAvailableLocales(UErrorCode *status);
 #endif
 
@@ -848,7 +851,7 @@ ucol_openAvailableLocales(UErrorCode *status);
  * responsible for closing the result.
  * @stable ICU 3.0
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucol_getKeywords(UErrorCode *status);
 
 /**
@@ -862,7 +865,7 @@ ucol_getKeywords(UErrorCode *status);
  * upon error. The caller is responsible for closing the result.
  * @stable ICU 3.0
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucol_getKeywordValues(const char *keyword, UErrorCode *status);
 
 /**
@@ -881,7 +884,7 @@ ucol_getKeywordValues(const char *keyword, UErrorCode *status);
  * @return a string enumeration over keyword values for the given key and the locale.
  * @stable ICU 4.2
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 ucol_getKeywordValuesForLocale(const char* key,
                                const char* locale,
                                UBool commonlyUsed,
@@ -901,7 +904,7 @@ ucol_getKeywordValuesForLocale(const char* key,
  * applications who wish to cache collators, or otherwise reuse
  * collators when possible. The functional equivalent may change
  * over time. For more information, please see the <a
- * href="http://userguide.icu-project.org/locale#TOC-Locales-and-Services">
+ * href="https://unicode-org.github.io/icu/userguide/locale#locales-and-services">
  * Locales and Services</a> section of the ICU User Guide.
  * @param result fillin for the functionally equivalent result locale
  * @param resultCapacity capacity of the fillin buffer
@@ -918,7 +921,7 @@ ucol_getKeywordValuesForLocale(const char* key,
  * an error code will be returned.
  * @stable ICU 3.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
                              const char* keyword, const char* locale,
                              UBool* isAvailable, UErrorCode* status);
@@ -931,7 +934,7 @@ ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
  * @return The collation tailoring rules.
  * @stable ICU 2.0
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ucol_getRules(    const    UCollator    *coll,
         int32_t            *length);
 
@@ -942,7 +945,7 @@ ucol_getRules(    const    UCollator    *coll,
  *  This string will be normalized.
  *  The structure and the syntax of the string is defined in the "Naming collators"
  *  section of the users guide:
- *  http://userguide.icu-project.org/collation/concepts#TOC-Collator-naming-scheme
+ *  https://unicode-org.github.io/icu/userguide/collation/concepts#collator-naming-scheme
  *  This API supports preflighting.
  *  @param coll a collator
  *  @param locale a locale that will appear as a collators locale in the resulting
@@ -1014,7 +1017,7 @@ ucol_normalizeShortDefinitionString(const char *source,
  * @see ucol_keyHashCode
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getSortKey(const    UCollator    *coll,
         const    UChar        *source,
         int32_t        sourceLength,
@@ -1042,7 +1045,7 @@ ucol_getSortKey(const    UCollator    *coll,
  *          the sort key.
  *  @stable ICU 2.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_nextSortKeyPart(const UCollator *coll,
                      UCharIterator *iter,
                      uint32_t state[2],
@@ -1109,7 +1112,7 @@ typedef enum {
  * @see ucol_keyHashCode
  * @stable ICU 2.1
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getBound(const uint8_t       *source,
         int32_t             sourceLength,
         UColBoundMode       boundType,
@@ -1126,7 +1129,7 @@ ucol_getBound(const uint8_t       *source,
  * @param info the version # information, the result will be filled in
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_getVersion(const UCollator* coll, UVersionInfo info);
 
 /**
@@ -1136,7 +1139,7 @@ ucol_getVersion(const UCollator* coll, UVersionInfo info);
  * @param info the version # information, the result will be filled in
  * @stable ICU 2.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_getUCAVersion(const UCollator* coll, UVersionInfo info);
 
 /**
@@ -1155,7 +1158,7 @@ ucol_getUCAVersion(const UCollator* coll, UVersionInfo info);
  * Using strings with U+FFFE may yield shorter sort keys.
  *
  * For details about Sort Key Features see
- * http://userguide.icu-project.org/collation/api#TOC-Sort-Key-Features
+ * https://unicode-org.github.io/icu/userguide/collation/api#sort-key-features
  *
  * It is possible to merge multiple sort keys by consecutively merging
  * another one with the intermediate result.
@@ -1186,7 +1189,7 @@ ucol_getUCAVersion(const UCollator* coll, UVersionInfo info);
  *         in which cases the contents of dest is undefined
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length,
                    const uint8_t *src2, int32_t src2Length,
                    uint8_t *dest, int32_t destCapacity);
@@ -1202,7 +1205,7 @@ ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length,
  * @see ucol_getAttribute
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status);
 
 /**
@@ -1216,7 +1219,7 @@ ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value,
  * @see ucol_setAttribute
  * @stable ICU 2.0
  */
-U_STABLE UColAttributeValue  U_EXPORT2
+U_CAPI UColAttributeValue  U_EXPORT2
 ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status);
 
 /**
@@ -1235,7 +1238,7 @@ ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status)
  * @see ucol_getMaxVariable
  * @stable ICU 53
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_setMaxVariable(UCollator *coll, UColReorderCode group, UErrorCode *pErrorCode);
 
 /**
@@ -1245,7 +1248,7 @@ ucol_setMaxVariable(UCollator *coll, UColReorderCode group, UErrorCode *pErrorCo
  * @see ucol_setMaxVariable
  * @stable ICU 53
  */
-U_STABLE UColReorderCode U_EXPORT2
+U_CAPI UColReorderCode U_EXPORT2
 ucol_getMaxVariable(const UCollator *coll);
 
 #ifndef U_HIDE_DEPRECATED_API
@@ -1286,7 +1289,7 @@ ucol_setVariableTop(UCollator *coll,
  * @see ucol_restoreVariableTop
  * @stable ICU 2.0
  */
-U_STABLE uint32_t U_EXPORT2 ucol_getVariableTop(const UCollator *coll, UErrorCode *status);
+U_CAPI uint32_t U_EXPORT2 ucol_getVariableTop(const UCollator *coll, UErrorCode *status);
 
 #ifndef U_HIDE_DEPRECATED_API
 /**
@@ -1330,7 +1333,7 @@ ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *stat
  * @see ucol_close
  * @stable ICU 2.0
  */
-U_STABLE UCollator* U_EXPORT2
+U_CAPI UCollator* U_EXPORT2
 ucol_safeClone(const UCollator *coll,
                void            *stackBuffer,
                int32_t         *pBufferSize,
@@ -1351,7 +1354,7 @@ ucol_safeClone(const UCollator *coll,
  * to store rules, will store up to available space.
  *
  * ucol_getRules() should normally be used instead.
- * See http://userguide.icu-project.org/collation/customization#TOC-Building-on-Existing-Locales
+ * See https://unicode-org.github.io/icu/userguide/collation/customization#building-on-existing-locales
  * @param coll collator to get the rules from
  * @param delta one of UCOL_TAILORING_ONLY, UCOL_FULL_RULES.
  * @param buffer buffer to store the result in. If NULL, you'll get no rules.
@@ -1360,7 +1363,7 @@ ucol_safeClone(const UCollator *coll,
  * @stable ICU 2.0
  * @see UCOL_FULL_RULES
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen);
 
 #ifndef U_HIDE_DEPRECATED_API
@@ -1396,7 +1399,7 @@ ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *statu
  *         NULL.
  * @stable ICU 2.8
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status);
 
 /**
@@ -1409,7 +1412,7 @@ ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode
  * @see uset_close
  * @stable ICU 2.4
  */
-U_STABLE USet * U_EXPORT2
+U_CAPI USet * U_EXPORT2
 ucol_getTailoredSet(const UCollator *coll, UErrorCode *status);
 
 #ifndef U_HIDE_INTERNAL_API
@@ -1424,7 +1427,7 @@ ucol_getTailoredSet(const UCollator *coll, UErrorCode *status);
  *  @return number of elements in the set
  *  @internal ICU 3.0
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getUnsafeSet( const UCollator *coll,
                   USet *unsafe,
                   UErrorCode *status);
@@ -1436,12 +1439,12 @@ ucol_getUnsafeSet( const UCollator *coll,
  *                   state for a locale.
  * @param parseError if not NULL, structure that will get filled with error's pre
  *                   and post context in case of error.
- * @param forceDefaults if FALSE, the settings that are the same as the collator
+ * @param forceDefaults if false, the settings that are the same as the collator
  *                   default settings will not be applied (for example, setting
  *                   French secondary on a French collator would not be executed).
- *                   If TRUE, all the settings will be applied regardless of the
+ *                   If true, all the settings will be applied regardless of the
  *                   collator default value. If the definition
- *                   strings are to be cached, should be set to FALSE.
+ *                   strings are to be cached, should be set to false.
  * @param status     Error code. Apart from regular error conditions connected to
  *                   instantiating collators (like out of memory or similar), this
  *                   API will return an error if an invalid attribute or attribute/value
@@ -1449,7 +1452,7 @@ ucol_getUnsafeSet( const UCollator *coll,
  * @see ucol_openFromShortString
  * @internal ICU 3.2.1
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_prepareShortStringOpen( const char *definition,
                           UBool forceDefaults,
                           UParseError *parseError,
@@ -1467,7 +1470,7 @@ ucol_prepareShortStringOpen( const char *definition,
  *  @see ucol_openBinary
  *  @stable ICU 3.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_cloneBinary(const UCollator *coll,
                  uint8_t *buffer, int32_t capacity,
                  UErrorCode *status);
@@ -1489,7 +1492,7 @@ ucol_cloneBinary(const UCollator *coll,
  *  @see ucol_cloneBinary
  *  @stable ICU 3.2
  */
-U_STABLE UCollator* U_EXPORT2
+U_CAPI UCollator* U_EXPORT2
 ucol_openBinary(const uint8_t *bin, int32_t length,
                 const UCollator *base,
                 UErrorCode *status);
diff --git a/deps/icu-small/source/i18n/unicode/ucoleitr.h b/deps/icu-small/source/i18n/unicode/ucoleitr.h
index 96c67f2018a6c3996a5513fb25bc91e741e99fbe..e8bcd368d4f0a4a3b5731d6af64288213ad60a4f 100644
--- a/deps/icu-small/source/i18n/unicode/ucoleitr.h
+++ b/deps/icu-small/source/i18n/unicode/ucoleitr.h
@@ -23,7 +23,7 @@
 #if !UCONFIG_NO_COLLATION
 
 /**
- * This indicates an error has occured during processing or if no more CEs is
+ * This indicates an error has occurred during processing or if no more CEs is
  * to be returned.
  * @stable ICU 2.0
  */
@@ -66,14 +66,14 @@ typedef struct UCollationElements UCollationElements;
  * .      UCollationElements *c;
  * .      UCollatorOld *coll;
  * .      UErrorCode success = U_ZERO_ERROR;
- * .      s=(UChar*)malloc(sizeof(UChar) * (strlen("This is a test")+1) );
- * .      u_uastrcpy(s, "This is a test");
+ * .      str=(UChar*)malloc(sizeof(UChar) * (strlen("This is a test")+1) );
+ * .      u_uastrcpy(str, "This is a test");
  * .      coll = ucol_open(NULL, &success);
  * .      c = ucol_openElements(coll, str, u_strlen(str), &status);
  * .      order = ucol_next(c, &success);
  * .      ucol_reset(c);
  * .      order = ucol_prev(c, &success);
- * .      free(s);
+ * .      free(str);
  * .      ucol_close(coll);
  * .      ucol_closeElements(c);
  * .  }
@@ -102,6 +102,10 @@ typedef struct UCollationElements UCollationElements;
 /**
  * Open the collation elements for a string.
  *
+ * The UCollationElements retains a pointer to the supplied text.
+ * The caller must not modify or delete the text while the UCollationElements
+ * object is used to iterate over this text.
+ *
  * @param coll The collator containing the desired collation rules.
  * @param text The text to iterate over.
  * @param textLength The number of characters in text, or -1 if null-terminated
@@ -109,13 +113,12 @@ typedef struct UCollationElements UCollationElements;
  * @return a struct containing collation element information
  * @stable ICU 2.0
  */
-U_STABLE UCollationElements* U_EXPORT2
+U_CAPI UCollationElements* U_EXPORT2
 ucol_openElements(const UCollator  *coll,
                   const UChar      *text,
                         int32_t    textLength,
                         UErrorCode *status);
 
-
 /**
  * get a hash code for a key... Not very useful!
  * @param key    the given key.
@@ -123,7 +126,7 @@ ucol_openElements(const UCollator  *coll,
  * @return       the hash code.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_keyHashCode(const uint8_t* key, int32_t length);
 
 /**
@@ -132,7 +135,7 @@ ucol_keyHashCode(const uint8_t* key, int32_t length);
  * @param elems The UCollationElements to close.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_closeElements(UCollationElements *elems);
 
 /**
@@ -144,7 +147,7 @@ ucol_closeElements(UCollationElements *elems);
  * @see ucol_previous
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_reset(UCollationElements *elems);
 
 /**
@@ -153,10 +156,10 @@ ucol_reset(UCollationElements *elems);
  * @param elems The UCollationElements containing the text.
  * @param status A pointer to a UErrorCode to receive any errors.
  * @return The next collation elements ordering, otherwise returns UCOL_NULLORDER
- *         if an error has occured or if the end of string has been reached
+ *         if an error has occurred or if the end of string has been reached
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_next(UCollationElements *elems, UErrorCode *status);
 
 /**
@@ -168,11 +171,11 @@ ucol_next(UCollationElements *elems, UErrorCode *status);
  *               a U_BUFFER_OVERFLOW_ERROR is returned if the internal stack
  *               buffer has been exhausted.
  * @return The previous collation elements ordering, otherwise returns
- *         UCOL_NULLORDER if an error has occured or if the start of string has
+ *         UCOL_NULLORDER if an error has occurred or if the start of string has
  *         been reached.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_previous(UCollationElements *elems, UErrorCode *status);
 
 /**
@@ -186,7 +189,7 @@ ucol_previous(UCollationElements *elems, UErrorCode *status);
  *         expansion sequence
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getMaxExpansion(const UCollationElements *elems, int32_t order);
 
 /**
@@ -194,6 +197,11 @@ ucol_getMaxExpansion(const UCollationElements *elems, int32_t order);
  * Property settings for collation will remain the same.
  * In order to reset the iterator to the current collation property settings,
  * the API reset() has to be called.
+ *
+ * The UCollationElements retains a pointer to the supplied text.
+ * The caller must not modify or delete the text while the UCollationElements
+ * object is used to iterate over this text.
+ *
  * @param elems The UCollationElements to set.
  * @param text The source text containing the collation elements.
  * @param textLength The length of text, or -1 if null-terminated.
@@ -201,7 +209,7 @@ ucol_getMaxExpansion(const UCollationElements *elems, int32_t order);
  * @see ucol_getText
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_setText(      UCollationElements *elems,
              const UChar              *text,
                    int32_t            textLength,
@@ -216,7 +224,7 @@ ucol_setText(      UCollationElements *elems,
  * @see ucol_setOffset
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_getOffset(const UCollationElements *elems);
 
 /**
@@ -231,9 +239,9 @@ ucol_getOffset(const UCollationElements *elems);
  * @see ucol_getOffset
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucol_setOffset(UCollationElements *elems,
-               int32_t        offset,
+               int32_t             offset,
                UErrorCode         *status);
 
 /**
@@ -242,7 +250,7 @@ ucol_setOffset(UCollationElements *elems,
 * @return the primary order of a collation order.
 * @stable ICU 2.6
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_primaryOrder (int32_t order);
 
 /**
@@ -251,7 +259,7 @@ ucol_primaryOrder (int32_t order);
 * @return the secondary order of a collation order.
 * @stable ICU 2.6
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_secondaryOrder (int32_t order);
 
 /**
@@ -260,7 +268,7 @@ ucol_secondaryOrder (int32_t order);
 * @return the tertiary order of a collation order.
 * @stable ICU 2.6
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucol_tertiaryOrder (int32_t order);
 
 #endif /* #if !UCONFIG_NO_COLLATION */
diff --git a/deps/icu-small/source/i18n/unicode/ucsdet.h b/deps/icu-small/source/i18n/unicode/ucsdet.h
index 7a8564f9eabe37f8e8191738c78e076b19abfd22..50281ad1fb54cb4870e41d0d19dfaa023a775b60 100644
--- a/deps/icu-small/source/i18n/unicode/ucsdet.h
+++ b/deps/icu-small/source/i18n/unicode/ucsdet.h
@@ -25,9 +25,12 @@
 
 #if !UCONFIG_NO_CONVERSION
 
-#include "unicode/localpointer.h"
 #include "unicode/uenum.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: Charset Detection API
@@ -75,7 +78,7 @@ typedef struct UCharsetMatch UCharsetMatch;
   *  @return the newly opened charset detector.
   *  @stable ICU 3.6
   */
-U_STABLE UCharsetDetector * U_EXPORT2
+U_CAPI UCharsetDetector * U_EXPORT2
 ucsdet_open(UErrorCode   *status);
 
 /**
@@ -87,7 +90,7 @@ ucsdet_open(UErrorCode   *status);
   *  @param ucsd  The charset detector to be closed.
   *  @stable ICU 3.6
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucsdet_close(UCharsetDetector *ucsd);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -124,7 +127,7 @@ U_NAMESPACE_END
   *
   * @stable ICU 3.6
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucsdet_setText(UCharsetDetector *ucsd, const char *textIn, int32_t len, UErrorCode *status);
 
 
@@ -146,7 +149,7 @@ ucsdet_setText(UCharsetDetector *ucsd, const char *textIn, int32_t len, UErrorCo
  *
  * @stable ICU 3.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucsdet_setDeclaredEncoding(UCharsetDetector *ucsd, const char *encoding, int32_t length, UErrorCode *status);
 
 
@@ -175,7 +178,7 @@ ucsdet_setDeclaredEncoding(UCharsetDetector *ucsd, const char *encoding, int32_t
  *
  * @stable ICU 3.6
  */
-U_STABLE const UCharsetMatch * U_EXPORT2
+U_CAPI const UCharsetMatch * U_EXPORT2
 ucsdet_detect(UCharsetDetector *ucsd, UErrorCode *status);
 
 
@@ -209,7 +212,7 @@ ucsdet_detect(UCharsetDetector *ucsd, UErrorCode *status);
  *                      the detector is closed or modified.
  * @stable ICU 3.6
  */
-U_STABLE const UCharsetMatch ** U_EXPORT2
+U_CAPI const UCharsetMatch ** U_EXPORT2
 ucsdet_detectAll(UCharsetDetector *ucsd, int32_t *matchesFound, UErrorCode *status);
 
 
@@ -229,7 +232,7 @@ ucsdet_detectAll(UCharsetDetector *ucsd, int32_t *matchesFound, UErrorCode *stat
  *
  *  @stable ICU 3.6
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucsdet_getName(const UCharsetMatch *ucsm, UErrorCode *status);
 
 /**
@@ -255,7 +258,7 @@ ucsdet_getName(const UCharsetMatch *ucsm, UErrorCode *status);
  *
  *  @stable ICU 3.6
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucsdet_getConfidence(const UCharsetMatch *ucsm, UErrorCode *status);
 
 /**
@@ -287,7 +290,7 @@ ucsdet_getConfidence(const UCharsetMatch *ucsm, UErrorCode *status);
  *
  *  @stable ICU 3.6
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ucsdet_getLanguage(const UCharsetMatch *ucsm, UErrorCode *status);
 
 
@@ -313,7 +316,7 @@ ucsdet_getLanguage(const UCharsetMatch *ucsm, UErrorCode *status);
   *
   * @stable ICU 3.6
   */
-U_STABLE  int32_t U_EXPORT2
+U_CAPI  int32_t U_EXPORT2
 ucsdet_getUChars(const UCharsetMatch *ucsm,
                  UChar *buf, int32_t cap, UErrorCode *status);
 
@@ -347,7 +350,7 @@ ucsdet_getUChars(const UCharsetMatch *ucsm,
   *  @return an iterator providing access to the detectable charset names.
   *  @stable ICU 3.6
   */
-U_STABLE  UEnumeration * U_EXPORT2
+U_CAPI  UEnumeration * U_EXPORT2
 ucsdet_getAllDetectableCharsets(const UCharsetDetector *ucsd,  UErrorCode *status);
 
 /**
@@ -357,11 +360,11 @@ ucsdet_getAllDetectableCharsets(const UCharsetDetector *ucsd,  UErrorCode *statu
   *  heuristics.
   *
   *  @param ucsd  The charset detector to check.
-  *  @return TRUE if filtering is enabled.
+  *  @return true if filtering is enabled.
   *  @stable ICU 3.6
   */
 
-U_STABLE  UBool U_EXPORT2
+U_CAPI  UBool U_EXPORT2
 ucsdet_isInputFilterEnabled(const UCharsetDetector *ucsd);
 
 
@@ -376,7 +379,7 @@ ucsdet_isInputFilterEnabled(const UCharsetDetector *ucsd);
  *
  * @stable ICU 3.6
  */
-U_STABLE  UBool U_EXPORT2
+U_CAPI  UBool U_EXPORT2
 ucsdet_enableInputFilter(UCharsetDetector *ucsd, UBool filter);
 
 #ifndef U_HIDE_INTERNAL_API
@@ -393,7 +396,7 @@ ucsdet_enableInputFilter(UCharsetDetector *ucsd, UBool filter);
   *  the specified charset detector.
   *  @internal
   */
-U_INTERNAL UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 ucsdet_getDetectableCharsets(const UCharsetDetector *ucsd,  UErrorCode *status);
 
 /**
@@ -403,13 +406,13 @@ ucsdet_getDetectableCharsets(const UCharsetDetector *ucsd,  UErrorCode *status);
   *
   * @param ucsd a Charset detector.
   * @param encoding encoding the name of charset encoding.
-  * @param enabled <code>TRUE</code> to enable, or <code>FALSE</code> to disable the
+  * @param enabled <code>true</code> to enable, or <code>false</code> to disable the
   *   charset encoding.
   * @param status receives the return status. When the name of charset encoding
   *   is not supported, U_ILLEGAL_ARGUMENT_ERROR is set.
   * @internal
   */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucsdet_setDetectableCharset(UCharsetDetector *ucsd, const char *encoding, UBool enabled, UErrorCode *status);
 #endif  /* U_HIDE_INTERNAL_API */
 
diff --git a/deps/icu-small/source/i18n/unicode/udat.h b/deps/icu-small/source/i18n/unicode/udat.h
index cf7a165e70ab4f85e7aba3acd381cf3f4b275a32..2963e5506c821ddafb6e33a184307d09ca58ad9e 100644
--- a/deps/icu-small/source/i18n/unicode/udat.h
+++ b/deps/icu-small/source/i18n/unicode/udat.h
@@ -14,11 +14,15 @@
 
 #if !UCONFIG_NO_FORMATTING
 
-#include "unicode/localpointer.h"
 #include "unicode/ucal.h"
 #include "unicode/unum.h"
 #include "unicode/udisplaycontext.h"
 #include "unicode/ufieldpositer.h"
+
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: DateFormat
@@ -142,7 +146,7 @@
  * the date and time formatting algorithm and pattern letters defined by
  * <a href="http://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table">UTS#35
  * Unicode Locale Data Markup Language (LDML)</a> and further documented for ICU in the
- * <a href="https://sites.google.com/site/icuprojectuserguide/formatparse/datetime?pli=1#TOC-Date-Field-Symbol-Table">ICU
+ * <a href="https://unicode-org.github.io/icu/userguide/format_parse/datetime#date-field-symbol-table">ICU
  * User Guide</a>.</p>
  */
 
@@ -832,10 +836,24 @@ typedef enum UDateFormatField {
 
 /**
  * Maps from a UDateFormatField to the corresponding UCalendarDateFields.
- * Note: since the mapping is many-to-one, there is no inverse mapping.
+ *
+ * Note 1: Since the mapping is many-to-one, there is no inverse mapping.
+ *
+ * Note 2: There is no UErrorCode parameter, so in case of error (UDateFormatField is
+ * unknown or has no corresponding UCalendarDateFields value), the function returns the
+ * current value of UCAL_FIELD_COUNT. However, that value may change from release to
+ * release and is consequently deprecated. For a future-proof runtime way of checking
+ * for errors:
+ * a) First save the value returned by the function when it is passed an invalid value
+ *    such as "(UDateFormatField)-1".
+ * b) Then, to test for errors when passing some other UDateFormatField value, check
+ *     whether the function returns that saved value.
+ *
  * @param field the UDateFormatField.
- * @return the UCalendarDateField.  This will be UCAL_FIELD_COUNT in case
- * of error (e.g., the input field is UDAT_FIELD_COUNT).
+ * @return the UCalendarDateField. In case of error (UDateFormatField is unknown or has
+ *   no corresponding UCalendarDateFields value) this will be the current value of
+ *   UCAL_FIELD_COUNT, but that value may change from release to release.
+ *   See Note 2 above.
  * @stable ICU 4.4
  */
 U_CAPI UCalendarDateFields U_EXPORT2
@@ -958,37 +976,35 @@ udat_getBooleanAttribute(const UDateFormat* fmt, UDateFormatBooleanAttribute att
 U_CAPI void U_EXPORT2
 udat_setBooleanAttribute(UDateFormat *fmt, UDateFormatBooleanAttribute attr, UBool newValue, UErrorCode* status);
 
-#ifndef U_HIDE_DRAFT_API
 /**
  * Hour Cycle.
- * @draft ICU 67
+ * @stable ICU 67
  */
 typedef enum UDateFormatHourCycle {
     /**
      * Hour in am/pm (0~11)
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UDAT_HOUR_CYCLE_11,
 
     /**
      * Hour in am/pm (1~12)
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UDAT_HOUR_CYCLE_12,
 
     /**
      * Hour in day (0~23)
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UDAT_HOUR_CYCLE_23,
 
     /**
      * Hour in day (1~24)
-     * @draft ICU 67
+     * @stable ICU 67
      */
     UDAT_HOUR_CYCLE_24
 } UDateFormatHourCycle;
-#endif  /* U_HIDE_DRAFT_API */
 
 #if U_SHOW_CPLUSPLUS_API
 
@@ -1217,7 +1233,7 @@ udat_parseCalendar(const    UDateFormat*    format,
 * With lenient parsing, the parser may use heuristics to interpret inputs that do not
 * precisely match the pattern. With strict parsing, inputs must match the pattern.
 * @param fmt The formatter to query
-* @return TRUE if fmt is set to perform lenient parsing, FALSE otherwise.
+* @return true if fmt is set to perform lenient parsing, false otherwise.
 * @see udat_setLenient
 * @stable ICU 2.0
 */
@@ -1229,7 +1245,7 @@ udat_isLenient(const UDateFormat* fmt);
 * With lenient parsing, the parser may use heuristics to interpret inputs that do not
 * precisely match the pattern. With strict parsing, inputs must match the pattern.
 * @param fmt The formatter to set
-* @param isLenient TRUE if fmt should perform lenient parsing, FALSE otherwise.
+* @param isLenient true if fmt should perform lenient parsing, false otherwise.
 * @see dat_isLenient
 * @stable ICU 2.0
 */
@@ -1389,7 +1405,7 @@ udat_set2DigitYearStart(    UDateFormat     *fmt,
 * Extract the pattern from a UDateFormat.
 * The pattern will follow the pattern syntax rules.
 * @param fmt The formatter to query.
-* @param localized TRUE if the pattern should be localized, FALSE otherwise.
+* @param localized true if the pattern should be localized, false otherwise.
 * @param result A pointer to a buffer to receive the pattern.
 * @param resultLength The maximum size of result.
 * @param status A pointer to an UErrorCode to receive any errors
@@ -1408,7 +1424,7 @@ udat_toPattern(    const   UDateFormat     *fmt,
 * Set the pattern used by an UDateFormat.
 * The pattern should follow the pattern syntax rules.
 * @param format The formatter to set.
-* @param localized TRUE if the pattern is localized, FALSE otherwise.
+* @param localized true if the pattern is localized, false otherwise.
 * @param pattern The new pattern
 * @param patternLength The length of pattern, or -1 if null-terminated.
 * @see udat_toPattern
@@ -1636,7 +1652,7 @@ udat_getContext(const UDateFormat* fmt, UDisplayContextType type, UErrorCode* st
 * @see udat_applyPatternRelative
 * @internal ICU 4.2 technology preview
 */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udat_toPatternRelativeDate(const UDateFormat *fmt,
                            UChar             *result,
                            int32_t           resultLength,
@@ -1653,7 +1669,7 @@ udat_toPatternRelativeDate(const UDateFormat *fmt,
 * @see udat_applyPatternRelative
 * @internal ICU 4.2 technology preview
 */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udat_toPatternRelativeTime(const UDateFormat *fmt,
                            UChar             *result,
                            int32_t           resultLength,
@@ -1671,7 +1687,7 @@ udat_toPatternRelativeTime(const UDateFormat *fmt,
 * @see udat_toPatternRelativeDate, udat_toPatternRelativeTime
 * @internal ICU 4.2 technology preview
 */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 udat_applyPatternRelative(UDateFormat *format,
                           const UChar *datePattern,
                           int32_t     datePatternLength,
@@ -1696,14 +1712,14 @@ typedef UDateFormat* (U_EXPORT2 *UDateFormatOpener) (UDateFormatStyle  timeStyle
  * Register a provider factory
  * @internal ICU 49
  */
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 udat_registerOpener(UDateFormatOpener opener, UErrorCode *status);
 
 /**
  * Un-Register a provider factory
  * @internal ICU 49
  */
-U_INTERNAL UDateFormatOpener U_EXPORT2
+U_CAPI UDateFormatOpener U_EXPORT2
 udat_unregisterOpener(UDateFormatOpener opener, UErrorCode *status);
 #endif  /* U_HIDE_INTERNAL_API */
 
diff --git a/deps/icu-small/source/i18n/unicode/udateintervalformat.h b/deps/icu-small/source/i18n/unicode/udateintervalformat.h
index 6235ab710622ce299db0e82ac1ae8ae274710edd..9ed53a87d689046b95462b83d4cacd71a63fbd21 100644
--- a/deps/icu-small/source/i18n/unicode/udateintervalformat.h
+++ b/deps/icu-small/source/i18n/unicode/udateintervalformat.h
@@ -16,8 +16,12 @@
 
 #include "unicode/ucal.h"
 #include "unicode/umisc.h"
-#include "unicode/localpointer.h"
 #include "unicode/uformattedvalue.h"
+#include "unicode/udisplaycontext.h"
+
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -114,7 +118,7 @@ typedef struct UFormattedDateInterval UFormattedDateInterval;
  *            or NULL if an error occurred.
  * @stable ICU 4.8
  */
-U_STABLE UDateIntervalFormat* U_EXPORT2
+U_CAPI UDateIntervalFormat* U_EXPORT2
 udtitvfmt_open(const char*  locale,
               const UChar* skeleton,
               int32_t      skeletonLength,
@@ -128,7 +132,7 @@ udtitvfmt_open(const char*  locale,
  *            The UDateIntervalFormat object to close.
  * @stable ICU 4.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udtitvfmt_close(UDateIntervalFormat *formatter);
 
 /**
@@ -238,7 +242,7 @@ U_NAMESPACE_END
  *            output was truncated.
  * @stable ICU 4.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udtitvfmt_format(const UDateIntervalFormat* formatter,
                 UDate           fromDate,
                 UDate           toDate,
@@ -248,7 +252,6 @@ udtitvfmt_format(const UDateIntervalFormat* formatter,
                 UErrorCode*     status);
 
 
-#ifndef U_HIDE_DRAFT_API
 /**
  * Formats a date/time range using the conventions established for the
  * UDateIntervalFormat object.
@@ -263,9 +266,9 @@ udtitvfmt_format(const UDateIntervalFormat* formatter,
  *            formatting operation.
  * @param status
  *            A pointer to a UErrorCode to receive any errors.
- * @draft ICU 67
+ * @stable ICU 67
  */
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 udtitvfmt_formatToResult(
                 const UDateIntervalFormat* formatter,
                 UDate           fromDate,
@@ -287,18 +290,45 @@ udtitvfmt_formatToResult(
  *            formatting operation.
  * @param status
  *            A pointer to a UErrorCode to receive any errors.
- * @draft ICU 67
+ * @stable ICU 67
  */
 
-U_DRAFT void U_EXPORT2
+U_CAPI void U_EXPORT2
 udtitvfmt_formatCalendarToResult(
                 const UDateIntervalFormat* formatter,
                 UCalendar*      fromCalendar,
                 UCalendar*      toCalendar,
                 UFormattedDateInterval* result,
                 UErrorCode*     status);
-#endif /* U_HIDE_DRAFT_API */
 
+#ifndef U_HIDE_DRAFT_API
+/**
+ * Set a particular UDisplayContext value in the formatter, such as
+ * UDISPCTX_CAPITALIZATION_FOR_STANDALONE. This causes the formatted
+ * result to be capitalized appropriately for the context in which
+ * it is intended to be used, considering both the locale and the
+ * type of field at the beginning of the formatted result.
+ * @param formatter The formatter for which to set a UDisplayContext value.
+ * @param value The UDisplayContext value to set.
+ * @param status A pointer to an UErrorCode to receive any errors
+ * @draft ICU 68
+ */
+U_CAPI void U_EXPORT2
+udtitvfmt_setContext(UDateIntervalFormat* formatter, UDisplayContext value, UErrorCode* status);
+
+/**
+ * Get the formatter's UDisplayContext value for the specified UDisplayContextType,
+ * such as UDISPCTX_TYPE_CAPITALIZATION.
+ * @param formatter The formatter to query.
+ * @param type The UDisplayContextType whose value to return
+ * @param status A pointer to an UErrorCode to receive any errors
+ * @return The UDisplayContextValue for the specified type.
+ * @draft ICU 68
+ */
+U_CAPI UDisplayContext U_EXPORT2
+udtitvfmt_getContext(const UDateIntervalFormat* formatter, UDisplayContextType type, UErrorCode* status);
+
+#endif /* U_HIDE_DRAFT_API */
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
diff --git a/deps/icu-small/source/i18n/unicode/udatpg.h b/deps/icu-small/source/i18n/unicode/udatpg.h
index 4ec4a2d05116cb09123655a3f0a41c771c80f365..893e1e6831ae34e3d4b3661ba626fab79991ade2 100644
--- a/deps/icu-small/source/i18n/unicode/udatpg.h
+++ b/deps/icu-small/source/i18n/unicode/udatpg.h
@@ -22,7 +22,10 @@
 #include "unicode/utypes.h"
 #include "unicode/udat.h"
 #include "unicode/uenum.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -161,7 +164,7 @@ typedef enum UDateTimePatternConflict {
   * @return a pointer to UDateTimePatternGenerator.
   * @stable ICU 3.8
   */
-U_STABLE UDateTimePatternGenerator * U_EXPORT2
+U_CAPI UDateTimePatternGenerator * U_EXPORT2
 udatpg_open(const char *locale, UErrorCode *pErrorCode);
 
 /**
@@ -171,7 +174,7 @@ udatpg_open(const char *locale, UErrorCode *pErrorCode);
   * @return a pointer to UDateTimePatternGenerator.
   * @stable ICU 3.8
   */
-U_STABLE UDateTimePatternGenerator * U_EXPORT2
+U_CAPI UDateTimePatternGenerator * U_EXPORT2
 udatpg_openEmpty(UErrorCode *pErrorCode);
 
 /**
@@ -179,7 +182,7 @@ udatpg_openEmpty(UErrorCode *pErrorCode);
   * @param dtpg a pointer to UDateTimePatternGenerator.
   * @stable ICU 3.8
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udatpg_close(UDateTimePatternGenerator *dtpg);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -209,7 +212,7 @@ U_NAMESPACE_END
   * @return a pointer to a new UDateTimePatternGenerator.
   * @stable ICU 3.8
  */
-U_STABLE UDateTimePatternGenerator * U_EXPORT2
+U_CAPI UDateTimePatternGenerator * U_EXPORT2
 udatpg_clone(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode);
 
 /**
@@ -235,7 +238,7 @@ udatpg_clone(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode);
  * @return the length of bestPattern.
  * @stable ICU 3.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udatpg_getBestPattern(UDateTimePatternGenerator *dtpg,
                       const UChar *skeleton, int32_t length,
                       UChar *bestPattern, int32_t capacity,
@@ -271,7 +274,7 @@ udatpg_getBestPattern(UDateTimePatternGenerator *dtpg,
  * @return the length of bestPattern.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udatpg_getBestPatternWithOptions(UDateTimePatternGenerator *dtpg,
                                  const UChar *skeleton, int32_t length,
                                  UDateTimePatternMatchOptions options,
@@ -299,7 +302,7 @@ udatpg_getBestPatternWithOptions(UDateTimePatternGenerator *dtpg,
   * @return the length of skeleton.
   * @stable ICU 3.8
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udatpg_getSkeleton(UDateTimePatternGenerator *unusedDtpg,
                    const UChar *pattern, int32_t length,
                    UChar *skeleton, int32_t capacity,
@@ -329,7 +332,7 @@ udatpg_getSkeleton(UDateTimePatternGenerator *unusedDtpg,
  * @return the length of baseSkeleton.
  * @stable ICU 3.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udatpg_getBaseSkeleton(UDateTimePatternGenerator *unusedDtpg,
                        const UChar *pattern, int32_t length,
                        UChar *baseSkeleton, int32_t capacity,
@@ -359,7 +362,7 @@ udatpg_getBaseSkeleton(UDateTimePatternGenerator *unusedDtpg,
  *                  UDATPG_BASE_CONFLICT or UDATPG_CONFLICT.
  * @stable ICU 3.8
  */
-U_STABLE UDateTimePatternConflict U_EXPORT2
+U_CAPI UDateTimePatternConflict U_EXPORT2
 udatpg_addPattern(UDateTimePatternGenerator *dtpg,
                   const UChar *pattern, int32_t patternLength,
                   UBool override,
@@ -386,7 +389,7 @@ udatpg_addPattern(UDateTimePatternGenerator *dtpg,
   * @param length the length of value.
   * @stable ICU 3.8
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udatpg_setAppendItemFormat(UDateTimePatternGenerator *dtpg,
                            UDateTimePatternField field,
                            const UChar *value, int32_t length);
@@ -401,7 +404,7 @@ udatpg_setAppendItemFormat(UDateTimePatternGenerator *dtpg,
  * @return appendItemFormat for field.
  * @stable ICU 3.8
  */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 udatpg_getAppendItemFormat(const UDateTimePatternGenerator *dtpg,
                            UDateTimePatternField field,
                            int32_t *pLength);
@@ -419,7 +422,7 @@ udatpg_getAppendItemFormat(const UDateTimePatternGenerator *dtpg,
    * @param length the length of value.
    * @stable ICU 3.8
    */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udatpg_setAppendItemName(UDateTimePatternGenerator *dtpg,
                          UDateTimePatternField field,
                          const UChar *value, int32_t length);
@@ -436,7 +439,7 @@ udatpg_setAppendItemName(UDateTimePatternGenerator *dtpg,
  * @see udatpg_getFieldDisplayName
  * @stable ICU 3.8
  */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 udatpg_getAppendItemName(const UDateTimePatternGenerator *dtpg,
                          UDateTimePatternField field,
                          int32_t *pLength);
@@ -466,7 +469,7 @@ udatpg_getAppendItemName(const UDateTimePatternGenerator *dtpg,
  *         truncated result.
  * @stable ICU 61
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udatpg_getFieldDisplayName(const UDateTimePatternGenerator *dtpg,
                            UDateTimePatternField field,
                            UDateTimePGDisplayWidth width,
@@ -496,7 +499,7 @@ udatpg_getFieldDisplayName(const UDateTimePatternGenerator *dtpg,
  * @param length the length of dtFormat.
  * @stable ICU 3.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udatpg_setDateTimeFormat(const UDateTimePatternGenerator *dtpg,
                          const UChar *dtFormat, int32_t length);
 
@@ -507,7 +510,7 @@ udatpg_setDateTimeFormat(const UDateTimePatternGenerator *dtpg,
  * @return dateTimeFormat.
  * @stable ICU 3.8
  */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 udatpg_getDateTimeFormat(const UDateTimePatternGenerator *dtpg,
                          int32_t *pLength);
 
@@ -524,7 +527,7 @@ udatpg_getDateTimeFormat(const UDateTimePatternGenerator *dtpg,
  * @param length the length of decimal.
  * @stable ICU 3.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 udatpg_setDecimal(UDateTimePatternGenerator *dtpg,
                   const UChar *decimal, int32_t length);
 
@@ -536,7 +539,7 @@ udatpg_setDecimal(UDateTimePatternGenerator *dtpg,
  * @return corresponding to the decimal point.
  * @stable ICU 3.8
  */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 udatpg_getDecimal(const UDateTimePatternGenerator *dtpg,
                   int32_t *pLength);
 
@@ -565,7 +568,7 @@ udatpg_getDecimal(const UDateTimePatternGenerator *dtpg,
  * @return the length of dest.
  * @stable ICU 3.8
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udatpg_replaceFieldTypes(UDateTimePatternGenerator *dtpg,
                          const UChar *pattern, int32_t patternLength,
                          const UChar *skeleton, int32_t skeletonLength,
@@ -602,7 +605,7 @@ udatpg_replaceFieldTypes(UDateTimePatternGenerator *dtpg,
  * @return the length of dest.
  * @stable ICU 4.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 udatpg_replaceFieldTypesWithOptions(UDateTimePatternGenerator *dtpg,
                                     const UChar *pattern, int32_t patternLength,
                                     const UChar *skeleton, int32_t skeletonLength,
@@ -621,7 +624,7 @@ udatpg_replaceFieldTypesWithOptions(UDateTimePatternGenerator *dtpg,
  *         The caller must close the object.
  * @stable ICU 3.8
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 udatpg_openSkeletons(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode);
 
 /**
@@ -634,7 +637,7 @@ udatpg_openSkeletons(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCo
  *             The caller must close the object.
  * @stable ICU 3.8
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 udatpg_openBaseSkeletons(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode);
 
 /**
@@ -647,14 +650,13 @@ udatpg_openBaseSkeletons(const UDateTimePatternGenerator *dtpg, UErrorCode *pErr
  * @return pattern corresponding to a given skeleton.
  * @stable ICU 3.8
  */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 udatpg_getPatternForSkeleton(const UDateTimePatternGenerator *dtpg,
                              const UChar *skeleton, int32_t skeletonLength,
                              int32_t *pLength);
 
 #if !UCONFIG_NO_FORMATTING
 
-#ifndef U_HIDE_DRAFT_API
 /**
  * Return the default hour cycle for a locale. Uses the locale that the
  * UDateTimePatternGenerator was initially created with.
@@ -666,11 +668,10 @@ udatpg_getPatternForSkeleton(const UDateTimePatternGenerator *dtpg,
  *                   failure before the function call. Set to U_UNSUPPORTED_ERROR
  *                   if used on an empty instance.
  * @return the default hour cycle.
- * @draft ICU 67
+ * @stable ICU 67
  */
-U_DRAFT UDateFormatHourCycle U_EXPORT2
+U_CAPI UDateFormatHourCycle U_EXPORT2
 udatpg_getDefaultHourCycle(const UDateTimePatternGenerator *dtpg, UErrorCode* pErrorCode);
-#endif  /* U_HIDE_DRAFT_API */
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
diff --git a/deps/icu-small/source/i18n/unicode/ufieldpositer.h b/deps/icu-small/source/i18n/unicode/ufieldpositer.h
index 3ae73b6d843974999a4b391cde84447d970d1a4d..83df184f0a5958312fbc1751472adbf819382d39 100644
--- a/deps/icu-small/source/i18n/unicode/ufieldpositer.h
+++ b/deps/icu-small/source/i18n/unicode/ufieldpositer.h
@@ -14,7 +14,9 @@
 
 #if !UCONFIG_NO_FORMATTING
 
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -52,7 +54,7 @@ typedef struct UFieldPositionIterator UFieldPositionIterator;  /**< C typedef fo
  *          or NULL if an error occurred.
  * @stable ICU 55
  */
-U_STABLE UFieldPositionIterator* U_EXPORT2
+U_CAPI UFieldPositionIterator* U_EXPORT2
 ufieldpositer_open(UErrorCode* status);
 
 /**
@@ -61,7 +63,7 @@ ufieldpositer_open(UErrorCode* status);
  *          A pointer to the UFieldPositionIterator object to close.
  * @stable ICU 55
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ufieldpositer_close(UFieldPositionIterator *fpositer);
 
 
@@ -112,7 +114,7 @@ U_NAMESPACE_END
  *
  * @stable ICU 55
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ufieldpositer_next(UFieldPositionIterator *fpositer,
                    int32_t *beginIndex, int32_t *endIndex);
 
diff --git a/deps/icu-small/source/i18n/unicode/uformattable.h b/deps/icu-small/source/i18n/unicode/uformattable.h
index 9ba2a36901aa8356c5d4d744ec038e2bf10cba84..6b8bee1f3dfe7c89ae6f27755b456496b81680f7 100644
--- a/deps/icu-small/source/i18n/unicode/uformattable.h
+++ b/deps/icu-small/source/i18n/unicode/uformattable.h
@@ -34,7 +34,9 @@
 
 #if !UCONFIG_NO_FORMATTING
 
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * Enum designating the type of a UFormattable instance.
@@ -79,7 +81,7 @@ typedef void *UFormattable;
  * @see ufmt_close
  * @see icu::Formattable::Formattable()
  */
-U_STABLE UFormattable* U_EXPORT2
+U_CAPI UFormattable* U_EXPORT2
 ufmt_open(UErrorCode* status);
 
 /**
@@ -88,7 +90,7 @@ ufmt_open(UErrorCode* status);
  * @stable ICU 52
  * @see ufmt_open
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ufmt_close(UFormattable* fmt);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -120,7 +122,7 @@ U_NAMESPACE_END
  * @see icu::Formattable::getType() const
  * @stable ICU 52
  */
-U_STABLE UFormattableType U_EXPORT2
+U_CAPI UFormattableType U_EXPORT2
 ufmt_getType(const UFormattable* fmt, UErrorCode *status);
 
 /**
@@ -131,7 +133,7 @@ ufmt_getType(const UFormattable* fmt, UErrorCode *status);
  * @see icu::Formattable::isNumeric() const
  * @stable ICU 52
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ufmt_isNumeric(const UFormattable* fmt);
 
 /**
@@ -144,7 +146,7 @@ ufmt_isNumeric(const UFormattable* fmt);
  * @stable ICU 52
  * @see icu::Formattable::getDate(UErrorCode&) const
  */
-U_STABLE UDate U_EXPORT2
+U_CAPI UDate U_EXPORT2
 ufmt_getDate(const UFormattable* fmt, UErrorCode *status);
 
 /**
@@ -162,7 +164,7 @@ ufmt_getDate(const UFormattable* fmt, UErrorCode *status);
  * @stable ICU 52
  * @see icu::Formattable::getDouble(UErrorCode&) const
  */
-U_STABLE double U_EXPORT2
+U_CAPI double U_EXPORT2
 ufmt_getDouble(UFormattable* fmt, UErrorCode *status);
 
 /**
@@ -183,7 +185,7 @@ ufmt_getDouble(UFormattable* fmt, UErrorCode *status);
  * @stable ICU 52
  * @see icu::Formattable::getLong(UErrorCode&) const
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ufmt_getLong(UFormattable* fmt, UErrorCode *status);
 
 
@@ -204,7 +206,7 @@ ufmt_getLong(UFormattable* fmt, UErrorCode *status);
  * @stable ICU 52
  * @see icu::Formattable::getInt64(UErrorCode&) const
  */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 ufmt_getInt64(UFormattable* fmt, UErrorCode *status);
 
 /**
@@ -217,7 +219,7 @@ ufmt_getInt64(UFormattable* fmt, UErrorCode *status);
  * @stable ICU 52
  * @see icu::Formattable::getObject() const
  */
-U_STABLE const void *U_EXPORT2
+U_CAPI const void *U_EXPORT2
 ufmt_getObject(const UFormattable* fmt, UErrorCode *status);
 
 /**
@@ -232,7 +234,7 @@ ufmt_getObject(const UFormattable* fmt, UErrorCode *status);
  * @stable ICU 52
  * @see icu::Formattable::getString(UnicodeString&)const
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ufmt_getUChars(UFormattable* fmt, int32_t *len, UErrorCode *status);
 
 /**
@@ -243,7 +245,7 @@ ufmt_getUChars(UFormattable* fmt, int32_t *len, UErrorCode *status);
  * @stable ICU 52
  * @see ufmt_getArrayItemByIndex
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ufmt_getArrayLength(const UFormattable* fmt, UErrorCode *status);
 
 /**
@@ -255,7 +257,7 @@ ufmt_getArrayLength(const UFormattable* fmt, UErrorCode *status);
  * @stable ICU 52
  * @see icu::Formattable::getArray(int32_t&, UErrorCode&) const
  */
-U_STABLE UFormattable * U_EXPORT2
+U_CAPI UFormattable * U_EXPORT2
 ufmt_getArrayItemByIndex(UFormattable* fmt, int32_t n, UErrorCode *status);
 
 /**
@@ -280,7 +282,7 @@ ufmt_getArrayItemByIndex(UFormattable* fmt, int32_t n, UErrorCode *status);
  * @stable ICU 52
  * @see icu::Formattable::getDecimalNumber(UErrorCode&)
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 ufmt_getDecNumChars(UFormattable *fmt, int32_t *len, UErrorCode *status);
 
 #endif
diff --git a/deps/icu-small/source/i18n/unicode/uformattedvalue.h b/deps/icu-small/source/i18n/unicode/uformattedvalue.h
index 71a6592e9dd062ea911cf68ee2af240be085c127..c964b3a74dd3a1d3956f08d3b1794642388815a3 100644
--- a/deps/icu-small/source/i18n/unicode/uformattedvalue.h
+++ b/deps/icu-small/source/i18n/unicode/uformattedvalue.h
@@ -93,6 +93,15 @@ typedef enum UFieldCategory {
      */
     UFIELD_CATEGORY_DATE_INTERVAL_SPAN = 0x1000 + UFIELD_CATEGORY_DATE_INTERVAL,
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Category for spans in a number range.
+     *
+     * @draft ICU 69
+     */
+    UFIELD_CATEGORY_NUMBER_RANGE_SPAN = 0x1000 + UFIELD_CATEGORY_NUMBER,
+#endif // U_HIDE_DRAFT_API
+
 } UFieldCategory;
 
 
@@ -120,7 +129,7 @@ typedef struct UConstrainedFieldPosition UConstrainedFieldPosition;
  * @return The new object, or NULL if an error occurs.
  * @stable ICU 64
  */
-U_STABLE UConstrainedFieldPosition* U_EXPORT2
+U_CAPI UConstrainedFieldPosition* U_EXPORT2
 ucfpos_open(UErrorCode* ec);
 
 
@@ -133,7 +142,7 @@ ucfpos_open(UErrorCode* ec);
  * @param ec Set if an error occurs.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucfpos_reset(
     UConstrainedFieldPosition* ucfpos,
     UErrorCode* ec);
@@ -145,7 +154,7 @@ ucfpos_reset(
  * @param ucfpos The instance of UConstrainedFieldPosition.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucfpos_close(UConstrainedFieldPosition* ucfpos);
 
 
@@ -174,7 +183,7 @@ ucfpos_close(UConstrainedFieldPosition* ucfpos);
  * @param ec Set if an error occurs.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucfpos_constrainCategory(
     UConstrainedFieldPosition* ucfpos,
     int32_t category,
@@ -207,7 +216,7 @@ ucfpos_constrainCategory(
  * @param ec Set if an error occurs.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucfpos_constrainField(
     UConstrainedFieldPosition* ucfpos,
     int32_t category,
@@ -220,14 +229,14 @@ ucfpos_constrainField(
  *
  * If a category or field constraint was set, this function returns the constrained
  * category. Otherwise, the return value is well-defined only after
- * ufmtval_nextPosition returns TRUE.
+ * ufmtval_nextPosition returns true.
  *
  * @param ucfpos The instance of UConstrainedFieldPosition.
  * @param ec Set if an error occurs.
  * @return The field category saved in the instance.
  * @stable ICU 64
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucfpos_getCategory(
     const UConstrainedFieldPosition* ucfpos,
     UErrorCode* ec);
@@ -238,14 +247,14 @@ ucfpos_getCategory(
  *
  * If a field constraint was set, this function returns the constrained
  * field. Otherwise, the return value is well-defined only after
- * ufmtval_nextPosition returns TRUE.
+ * ufmtval_nextPosition returns true.
  *
  * @param ucfpos The instance of UConstrainedFieldPosition.
  * @param ec Set if an error occurs.
  * @return The field saved in the instance.
  * @stable ICU 64
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ucfpos_getField(
     const UConstrainedFieldPosition* ucfpos,
     UErrorCode* ec);
@@ -254,7 +263,7 @@ ucfpos_getField(
 /**
  * Gets the INCLUSIVE start and EXCLUSIVE end index stored for the current position.
  *
- * The output values are well-defined only after ufmtval_nextPosition returns TRUE.
+ * The output values are well-defined only after ufmtval_nextPosition returns true.
  *
  * @param ucfpos The instance of UConstrainedFieldPosition.
  * @param pStart Set to the start index saved in the instance. Ignored if nullptr.
@@ -262,7 +271,7 @@ ucfpos_getField(
  * @param ec Set if an error occurs.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucfpos_getIndexes(
     const UConstrainedFieldPosition* ucfpos,
     int32_t* pStart,
@@ -282,7 +291,7 @@ ucfpos_getIndexes(
  * @return The current iteration context from ucfpos_setInt64IterationContext.
  * @stable ICU 64
  */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 ucfpos_getInt64IterationContext(
     const UConstrainedFieldPosition* ucfpos,
     UErrorCode* ec);
@@ -298,7 +307,7 @@ ucfpos_getInt64IterationContext(
  * @param ec Set if an error occurs.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucfpos_setInt64IterationContext(
     UConstrainedFieldPosition* ucfpos,
     int64_t context,
@@ -317,7 +326,7 @@ ucfpos_setInt64IterationContext(
  * @param ec Set if an error occurs.
  * @stable ICU 64
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ucfpos_matchesField(
     const UConstrainedFieldPosition* ucfpos,
     int32_t category,
@@ -341,7 +350,7 @@ ucfpos_matchesField(
  * @param ec Set if an error occurs.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ucfpos_setState(
     UConstrainedFieldPosition* ucfpos,
     int32_t category,
@@ -374,7 +383,7 @@ typedef struct UFormattedValue UFormattedValue;
  * @return A NUL-terminated char16 string owned by the UFormattedValue.
  * @stable ICU 64
  */
-U_STABLE const UChar* U_EXPORT2
+U_CAPI const UChar* U_EXPORT2
 ufmtval_getString(
     const UFormattedValue* ufmtval,
     int32_t* pLength,
@@ -401,10 +410,10 @@ ufmtval_getString(
  *         see ucfpos_constrainCategory
  *         and ucfpos_constrainField.
  * @param ec Set if an error occurs.
- * @return TRUE if another position was found; FALSE otherwise.
+ * @return true if another position was found; false otherwise.
  * @stable ICU 64
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ufmtval_nextPosition(
     const UFormattedValue* ufmtval,
     UConstrainedFieldPosition* ucfpos,
diff --git a/deps/icu-small/source/i18n/unicode/ugender.h b/deps/icu-small/source/i18n/unicode/ugender.h
index 903f3dd5deebbe6d51339155108c349bbd10d5a1..7093686b8fdab5f58d4ec53ce5aae97bc96cfba2 100644
--- a/deps/icu-small/source/i18n/unicode/ugender.h
+++ b/deps/icu-small/source/i18n/unicode/ugender.h
@@ -14,7 +14,9 @@
 
 #if !UCONFIG_NO_FORMATTING
 
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -63,7 +65,7 @@ typedef struct UGenderInfo UGenderInfo;
  * @return A UGenderInfo for the specified locale, or NULL if an error occurred.
  * @stable ICU 50
  */
-U_STABLE const UGenderInfo* U_EXPORT2
+U_CAPI const UGenderInfo* U_EXPORT2
 ugender_getInstance(const char *locale, UErrorCode *status);
 
 
@@ -76,7 +78,7 @@ ugender_getInstance(const char *locale, UErrorCode *status);
  * @return The gender of the list.
  * @stable ICU 50
  */
-U_STABLE UGender U_EXPORT2
+U_CAPI UGender U_EXPORT2
 ugender_getListGender(const UGenderInfo* genderInfo, const UGender *genders, int32_t size, UErrorCode *status);
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/unicode/ulistformatter.h b/deps/icu-small/source/i18n/unicode/ulistformatter.h
index 66cf50190bb0eb8035c57c7f7b8cd867a137333d..28a1e5803700060bfb15332721a0d142473fe051 100644
--- a/deps/icu-small/source/i18n/unicode/ulistformatter.h
+++ b/deps/icu-small/source/i18n/unicode/ulistformatter.h
@@ -14,9 +14,12 @@
 
 #if !UCONFIG_NO_FORMATTING
 
-#include "unicode/localpointer.h"
 #include "unicode/uformattedvalue.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: Format a list in a locale-appropriate way.
@@ -59,17 +62,16 @@ typedef enum UListFormatterField {
     ULISTFMT_ELEMENT_FIELD
 } UListFormatterField;
 
-#ifndef U_HIDE_DRAFT_API
 /**
  * Type of meaning expressed by the list.
  *
- * @draft ICU 67
+ * @stable ICU 67
  */
 typedef enum UListFormatterType {
     /**
      * Conjunction formatting, e.g. "Alice, Bob, Charlie, and Delta".
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     ULISTFMT_TYPE_AND,
 
@@ -77,14 +79,14 @@ typedef enum UListFormatterType {
      * Disjunction (or alternative, or simply one of) formatting, e.g.
      * "Alice, Bob, Charlie, or Delta".
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     ULISTFMT_TYPE_OR,
 
     /**
      * Formatting of a list of values with units, e.g. "5 pounds, 12 ounces".
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     ULISTFMT_TYPE_UNITS
 } UListFormatterType;
@@ -92,29 +94,28 @@ typedef enum UListFormatterType {
 /**
  * Verbosity level of the list patterns.
  *
- * @draft ICU 67
+ * @stable ICU 67
  */
 typedef enum UListFormatterWidth {
     /**
      * Use list formatting with full words (no abbreviations) when possible.
      *
-     * @draft ICU 67
+     * @stable ICU 67
      */
     ULISTFMT_WIDTH_WIDE,
 
     /**
      * Use list formatting of typical length.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     ULISTFMT_WIDTH_SHORT,
 
     /**
      * Use list formatting of the shortest possible length.
-     * @draft ICU 67
+     * @stable ICU 67
      */
     ULISTFMT_WIDTH_NARROW,
 } UListFormatterWidth;
-#endif /* U_HIDE_DRAFT_API */
 
 /**
  * Open a new UListFormatter object using the rules for a given locale.
@@ -138,7 +139,6 @@ U_CAPI UListFormatter* U_EXPORT2
 ulistfmt_open(const char*  locale,
               UErrorCode*  status);
 
-#ifndef U_HIDE_DRAFT_API
 /**
  * Open a new UListFormatter object appropriate for the given locale, list type,
  * and style.
@@ -159,12 +159,11 @@ ulistfmt_open(const char*  locale,
  * @return
  *            A pointer to a UListFormatter object for the specified locale,
  *            or NULL if an error occurred.
- * @draft ICU 67
+ * @stable ICU 67
  */
-U_DRAFT UListFormatter* U_EXPORT2
+U_CAPI UListFormatter* U_EXPORT2
 ulistfmt_openForType(const char*  locale, UListFormatterType type,
                      UListFormatterWidth width, UErrorCode*  status);
-#endif /* U_HIDE_DRAFT_API */
 
 /**
  * Close a UListFormatter object. Once closed it may no longer be used.
diff --git a/deps/icu-small/source/i18n/unicode/ulocdata.h b/deps/icu-small/source/i18n/unicode/ulocdata.h
index de8d8539c6749accd50537bf69f1ed3fb12685d4..3977743e3238ec0169dc2179897c37c0e312fd3b 100644
--- a/deps/icu-small/source/i18n/unicode/ulocdata.h
+++ b/deps/icu-small/source/i18n/unicode/ulocdata.h
@@ -22,7 +22,10 @@
 #include "unicode/ures.h"
 #include "unicode/uloc.h"
 #include "unicode/uset.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -87,7 +90,7 @@ typedef enum ULocaleDataDelimiterType {
  * @param status    Pointer to error status code.
  * @stable ICU 3.4
  */
-U_STABLE ULocaleData* U_EXPORT2
+U_CAPI ULocaleData* U_EXPORT2
 ulocdata_open(const char *localeID, UErrorCode *status);
 
 /**
@@ -96,7 +99,7 @@ ulocdata_open(const char *localeID, UErrorCode *status);
  * @param uld       The locale data object to close
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocdata_close(ULocaleData *uld);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -129,7 +132,7 @@ U_NAMESPACE_END
  * @param setting   Value of the "no substitute" attribute.
  * @stable ICU 3.4
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocdata_setNoSubstitute(ULocaleData *uld, UBool setting);
 
 /**
@@ -143,7 +146,7 @@ ulocdata_setNoSubstitute(ULocaleData *uld, UBool setting);
  * @return UBool    Value of the "no substitute" attribute.
  * @stable ICU 3.4
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 ulocdata_getNoSubstitute(ULocaleData *uld);
 
 /**
@@ -173,7 +176,7 @@ ulocdata_getNoSubstitute(ULocaleData *uld);
  *                  In case of error, NULL is returned.
  * @stable ICU 3.4
  */
-U_STABLE USet* U_EXPORT2
+U_CAPI USet* U_EXPORT2
 ulocdata_getExemplarSet(ULocaleData *uld, USet *fillIn,
                         uint32_t options, ULocaleDataExemplarSetType extype, UErrorCode *status);
 
@@ -190,7 +193,7 @@ ulocdata_getExemplarSet(ULocaleData *uld, USet *fillIn,
  *                      the output was truncated.
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ulocdata_getDelimiter(ULocaleData *uld, ULocaleDataDelimiterType type, UChar *result, int32_t resultLength, UErrorCode *status);
 
 /**
@@ -220,7 +223,7 @@ typedef enum UMeasurementSystem {
  * @return UMeasurementSystem the measurement system used in the locale.
  * @stable ICU 2.8
  */
-U_STABLE UMeasurementSystem U_EXPORT2
+U_CAPI UMeasurementSystem U_EXPORT2
 ulocdata_getMeasurementSystem(const char *localeID, UErrorCode *status);
 
 /**
@@ -239,7 +242,7 @@ ulocdata_getMeasurementSystem(const char *localeID, UErrorCode *status);
  *                      which must not indicate a failure before the function call.
  * @stable ICU 2.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocdata_getPaperSize(const char *localeID, int32_t *height, int32_t *width, UErrorCode *status);
 
 /**
@@ -248,7 +251,7 @@ ulocdata_getPaperSize(const char *localeID, int32_t *height, int32_t *width, UEr
  * @param status error code - could be U_MISSING_RESOURCE_ERROR if the version was not found.
  * @stable ICU 4.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ulocdata_getCLDRVersion(UVersionInfo versionArray, UErrorCode *status);
 
 /**
@@ -266,7 +269,7 @@ ulocdata_getCLDRVersion(UVersionInfo versionArray, UErrorCode *status);
  *
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ulocdata_getLocaleDisplayPattern(ULocaleData *uld,
                                  UChar *pattern,
                                  int32_t patternCapacity,
@@ -288,7 +291,7 @@ ulocdata_getLocaleDisplayPattern(ULocaleData *uld,
  *
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ulocdata_getLocaleSeparator(ULocaleData *uld,
                             UChar *separator,
                             int32_t separatorCapacity,
diff --git a/deps/icu-small/source/i18n/unicode/umsg.h b/deps/icu-small/source/i18n/unicode/umsg.h
index 68188206129148423e7eb157f63bd1eae6ceba4e..c087031c6d4e35dcd7c6b1d96118dea0b4d0a170 100644
--- a/deps/icu-small/source/i18n/unicode/umsg.h
+++ b/deps/icu-small/source/i18n/unicode/umsg.h
@@ -24,11 +24,14 @@
 
 #if !UCONFIG_NO_FORMATTING
 
-#include "unicode/localpointer.h"
 #include "unicode/uloc.h"
 #include "unicode/parseerr.h"
 #include <stdarg.h>
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: MessageFormat
@@ -175,7 +178,7 @@
  * @see u_parseMessage
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_formatMessage(const char  *locale,
                  const UChar *pattern,
                 int32_t     patternLength,
@@ -202,7 +205,7 @@ u_formatMessage(const char  *locale,
  * @see u_parseMessage
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_vformatMessage(   const char  *locale,
                     const UChar *pattern,
                     int32_t     patternLength,
@@ -227,7 +230,7 @@ u_vformatMessage(   const char  *locale,
  * @see u_formatMessage
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_parseMessage( const char   *locale,
                 const UChar  *pattern,
                 int32_t      patternLength,
@@ -252,7 +255,7 @@ u_parseMessage( const char   *locale,
  * @see u_formatMessage
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_vparseMessage(const char  *locale,
                 const UChar *pattern,
                 int32_t     patternLength,
@@ -281,7 +284,7 @@ u_vparseMessage(const char  *locale,
  * @see u_parseMessage
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_formatMessageWithError(   const char    *locale,
                             const UChar   *pattern,
                             int32_t       patternLength,
@@ -310,7 +313,7 @@ u_formatMessageWithError(   const char    *locale,
  * output was truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 u_vformatMessageWithError(  const char   *locale,
                             const UChar  *pattern,
                             int32_t      patternLength,
@@ -338,7 +341,7 @@ u_vformatMessageWithError(  const char   *locale,
  * @see u_formatMessage
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_parseMessageWithError(const char  *locale,
                         const UChar *pattern,
                         int32_t     patternLength,
@@ -366,7 +369,7 @@ u_parseMessageWithError(const char  *locale,
  * @see u_formatMessage
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 u_vparseMessageWithError(const char  *locale,
                          const UChar *pattern,
                          int32_t     patternLength,
@@ -396,7 +399,7 @@ typedef void* UMessageFormat;
  *                      messages, or 0 if an error occurred.
  * @stable ICU 2.0
  */
-U_STABLE UMessageFormat* U_EXPORT2
+U_CAPI UMessageFormat* U_EXPORT2
 umsg_open(  const UChar     *pattern,
             int32_t         patternLength,
             const  char     *locale,
@@ -409,7 +412,7 @@ umsg_open(  const UChar     *pattern,
  * @param format The formatter to close.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 umsg_close(UMessageFormat* format);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -439,7 +442,7 @@ U_NAMESPACE_END
  * @return A pointer to a UDateFormat identical to fmt.
  * @stable ICU 2.0
  */
-U_STABLE UMessageFormat U_EXPORT2
+U_CAPI UMessageFormat U_EXPORT2
 umsg_clone(const UMessageFormat *fmt,
            UErrorCode *status);
 
@@ -450,7 +453,7 @@ umsg_clone(const UMessageFormat *fmt,
  * @param locale The locale the formatter should use.
  * @stable ICU 2.0
  */
-U_STABLE void  U_EXPORT2
+U_CAPI void  U_EXPORT2
 umsg_setLocale(UMessageFormat *fmt,
                const char* locale);
 
@@ -461,7 +464,7 @@ umsg_setLocale(UMessageFormat *fmt,
  * @return the locale.
  * @stable ICU 2.0
  */
-U_STABLE const char*  U_EXPORT2
+U_CAPI const char*  U_EXPORT2
 umsg_getLocale(const UMessageFormat *fmt);
 
 /**
@@ -476,7 +479,7 @@ umsg_getLocale(const UMessageFormat *fmt);
  *                      set to a failure result.
  * @stable ICU 2.0
  */
-U_STABLE void  U_EXPORT2
+U_CAPI void  U_EXPORT2
 umsg_applyPattern( UMessageFormat *fmt,
                    const UChar* pattern,
                    int32_t patternLength,
@@ -494,7 +497,7 @@ umsg_applyPattern( UMessageFormat *fmt,
  * @return the pattern of the format
  * @stable ICU 2.0
  */
-U_STABLE int32_t  U_EXPORT2
+U_CAPI int32_t  U_EXPORT2
 umsg_toPattern(const UMessageFormat *fmt,
                UChar* result,
                int32_t resultLength,
@@ -515,7 +518,7 @@ umsg_toPattern(const UMessageFormat *fmt,
  *                      the output was truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 umsg_format(    const UMessageFormat *fmt,
                 UChar          *result,
                 int32_t        resultLength,
@@ -537,7 +540,7 @@ umsg_format(    const UMessageFormat *fmt,
  *                     the output was truncated.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 umsg_vformat(   const UMessageFormat *fmt,
                 UChar          *result,
                 int32_t        resultLength,
@@ -558,7 +561,7 @@ umsg_vformat(   const UMessageFormat *fmt,
  *                      specified in pattern.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 umsg_parse( const UMessageFormat *fmt,
             const UChar    *source,
             int32_t        sourceLength,
@@ -581,7 +584,7 @@ umsg_parse( const UMessageFormat *fmt,
  * @see u_formatMessage
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 umsg_vparse(const UMessageFormat *fmt,
             const UChar    *source,
             int32_t        sourceLength,
@@ -613,7 +616,7 @@ umsg_vparse(const UMessageFormat *fmt,
  *        not
  * @stable ICU 3.4
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 umsg_autoQuoteApostrophe(const UChar* pattern,
                          int32_t patternLength,
                          UChar* dest,
diff --git a/deps/icu-small/source/i18n/unicode/unirepl.h b/deps/icu-small/source/i18n/unicode/unirepl.h
index 61ee37f07054fbadf2b8c0e8103fd6d912187788..891a1d527fd84aae06eaf06072e3011381bd701d 100644
--- a/deps/icu-small/source/i18n/unicode/unirepl.h
+++ b/deps/icu-small/source/i18n/unicode/unirepl.h
@@ -77,7 +77,7 @@ class U_I18N_API UnicodeReplacer /* not : public UObject because this is an inte
      * replacer that is equal to this one.
      * @param result the string to receive the pattern.  Previous
      * contents will be deleted.
-     * @param escapeUnprintable if TRUE then convert unprintable
+     * @param escapeUnprintable if true then convert unprintable
      * character to their hex escape representations, \\uxxxx or
      * \\Uxxxxxxxx.  Unprintable characters are defined by
      * Utility.isUnprintable().
diff --git a/deps/icu-small/source/i18n/unicode/unum.h b/deps/icu-small/source/i18n/unicode/unum.h
index b5f21ea5859071fca02c52f611f9a83a55e6f677..76c7d151357875e9800d598416b1dc50fb18e288 100644
--- a/deps/icu-small/source/i18n/unicode/unum.h
+++ b/deps/icu-small/source/i18n/unicode/unum.h
@@ -18,7 +18,6 @@
 
 #if !UCONFIG_NO_FORMATTING
 
-#include "unicode/localpointer.h"
 #include "unicode/uloc.h"
 #include "unicode/ucurr.h"
 #include "unicode/umisc.h"
@@ -27,6 +26,10 @@
 #include "unicode/udisplaycontext.h"
 #include "unicode/ufieldpositer.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: Compatibility APIs for number formatting.
@@ -272,7 +275,7 @@ typedef enum UNumberFormatStyle {
  *
  * <p>
  * For more detail on rounding modes, see:
- * http://userguide.icu-project.org/formatparse/numbers/rounding-modes
+ * https://unicode-org.github.io/icu/userguide/format_parse/numbers/rounding-modes
  *
  * @stable ICU 2.0
  */
@@ -299,7 +302,24 @@ typedef enum UNumberFormatRoundingMode {
       * ROUND_UNNECESSARY reports an error if formatted result is not exact.
       * @stable ICU 4.8
       */
-    UNUM_ROUND_UNNECESSARY
+    UNUM_ROUND_UNNECESSARY,
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Rounds ties toward the odd number.
+     * @draft ICU 69
+     */
+    UNUM_ROUND_HALF_ODD,
+    /**
+     * Rounds ties toward +∞.
+     * @draft ICU 69
+     */
+    UNUM_ROUND_HALF_CEILING,
+    /**
+     * Rounds ties toward -∞.
+     * @draft ICU 69
+     */
+    UNUM_ROUND_HALF_FLOOR,
+#endif  // U_HIDE_DRAFT_API
 } UNumberFormatRoundingMode;
 
 /** The possible number format pad positions.
@@ -392,6 +412,30 @@ typedef enum UNumberFormatFields {
 } UNumberFormatFields;
 
 
+#ifndef U_HIDE_DRAFT_API
+/**
+ * Selectors with special numeric values to use locale default minimum grouping
+ * digits for the DecimalFormat/UNumberFormat setMinimumGroupingDigits method.
+ * Do not use these constants with the [U]NumberFormatter API.
+ *
+ * @draft ICU 68
+ */
+typedef enum UNumberFormatMinimumGroupingDigits {
+    /**
+     * Display grouping using the default strategy for all locales.
+     * @draft ICU 68
+     */
+    UNUM_MINIMUM_GROUPING_DIGITS_AUTO = -2,
+    /**
+     * Display grouping using locale defaults, except do not show grouping on
+     * values smaller than 10000 (such that there is a minimum of two digits
+     * before the first separator).
+     * @draft ICU 68
+     */
+    UNUM_MINIMUM_GROUPING_DIGITS_MIN2 = -3,
+} UNumberFormatMinimumGroupingDigits;
+#endif  // U_HIDE_DRAFT_API
+
 /**
  * Create and return a new UNumberFormat for formatting and parsing
  * numbers.  A UNumberFormat may be used to format numbers by calling
@@ -429,7 +473,7 @@ typedef enum UNumberFormatFields {
  * @see DecimalFormat
  * @stable ICU 2.0
  */
-U_STABLE UNumberFormat* U_EXPORT2
+U_CAPI UNumberFormat* U_EXPORT2
 unum_open(  UNumberFormatStyle    style,
             const    UChar*    pattern,
             int32_t            patternLength,
@@ -444,7 +488,7 @@ unum_open(  UNumberFormatStyle    style,
 * @param fmt The formatter to close.
 * @stable ICU 2.0
 */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unum_close(UNumberFormat* fmt);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -474,7 +518,7 @@ U_NAMESPACE_END
  * @return A pointer to a UNumberFormat identical to fmt.
  * @stable ICU 2.0
  */
-U_STABLE UNumberFormat* U_EXPORT2
+U_CAPI UNumberFormat* U_EXPORT2
 unum_clone(const UNumberFormat *fmt,
        UErrorCode *status);
 
@@ -502,7 +546,7 @@ unum_clone(const UNumberFormat *fmt,
 * @see UFieldPosition
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_format(    const    UNumberFormat*    fmt,
         int32_t            number,
         UChar*            result,
@@ -534,7 +578,7 @@ unum_format(    const    UNumberFormat*    fmt,
 * @see UFieldPosition
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_formatInt64(const UNumberFormat *fmt,
         int64_t         number,
         UChar*          result,
@@ -566,7 +610,7 @@ unum_formatInt64(const UNumberFormat *fmt,
 * @see UFieldPosition
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_formatDouble(    const    UNumberFormat*  fmt,
             double          number,
             UChar*          result,
@@ -616,7 +660,7 @@ unum_formatDouble(    const    UNumberFormat*  fmt,
 * @see UNumberFormatFields
 * @stable ICU 59
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_formatDoubleForFields(const UNumberFormat* format,
                            double number,
                            UChar* result,
@@ -653,7 +697,7 @@ unum_formatDoubleForFields(const UNumberFormat* format,
 * @see UFieldPosition
 * @stable ICU 4.4
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_formatDecimal(    const    UNumberFormat*  fmt,
             const char *    number,
             int32_t         length,
@@ -665,6 +709,12 @@ unum_formatDecimal(    const    UNumberFormat*  fmt,
 /**
  * Format a double currency amount using a UNumberFormat.
  * The double will be formatted according to the UNumberFormat's locale.
+ *
+ * To format an exact decimal value with a currency, use
+ * `unum_setTextAttribute(UNUM_CURRENCY_CODE, ...)` followed by unum_formatDecimal.
+ * Your UNumberFormat must be created with the UNUM_CURRENCY style. Alternatively,
+ * consider using unumf_openForSkeletonAndLocale.
+ *
  * @param fmt the formatter to use
  * @param number the number to format
  * @param currency the 3-letter null-terminated ISO 4217 currency code
@@ -686,7 +736,7 @@ unum_formatDecimal(    const    UNumberFormat*  fmt,
  * @see UFieldPosition
  * @stable ICU 3.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_formatDoubleCurrency(const UNumberFormat* fmt,
                           double number,
                           UChar* currency,
@@ -715,7 +765,7 @@ unum_formatDoubleCurrency(const UNumberFormat* fmt,
  * @see unum_parseToUFormattable
  * @stable ICU 52
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_formatUFormattable(const UNumberFormat* fmt,
                         const UFormattable *number,
                         UChar *result,
@@ -742,7 +792,7 @@ unum_formatUFormattable(const UNumberFormat* fmt,
 * @see unum_formatDouble
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_parse(    const   UNumberFormat*  fmt,
         const   UChar*          text,
         int32_t         textLength,
@@ -768,7 +818,7 @@ unum_parse(    const   UNumberFormat*  fmt,
 * @see unum_formatDouble
 * @stable ICU 2.8
 */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 unum_parseInt64(const UNumberFormat*  fmt,
         const UChar*  text,
         int32_t       textLength,
@@ -794,7 +844,7 @@ unum_parseInt64(const UNumberFormat*  fmt,
 * @see unum_formatDouble
 * @stable ICU 2.0
 */
-U_STABLE double U_EXPORT2
+U_CAPI double U_EXPORT2
 unum_parseDouble(    const   UNumberFormat*  fmt,
             const   UChar*          text,
             int32_t         textLength,
@@ -829,7 +879,7 @@ unum_parseDouble(    const   UNumberFormat*  fmt,
 * @see unum_formatDouble
 * @stable ICU 4.4
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_parseDecimal(const   UNumberFormat*  fmt,
                  const   UChar*          text,
                          int32_t         textLength,
@@ -857,7 +907,7 @@ unum_parseDecimal(const   UNumberFormat*  fmt,
  * @see unum_formatDoubleCurrency
  * @stable ICU 3.0
  */
-U_STABLE double U_EXPORT2
+U_CAPI double U_EXPORT2
 unum_parseDoubleCurrency(const UNumberFormat* fmt,
                          const UChar* text,
                          int32_t textLength,
@@ -885,7 +935,7 @@ unum_parseDoubleCurrency(const UNumberFormat* fmt,
  * @see ufmt_close
  * @stable ICU 52
  */
-U_STABLE UFormattable* U_EXPORT2
+U_CAPI UFormattable* U_EXPORT2
 unum_parseToUFormattable(const UNumberFormat* fmt,
                          UFormattable *result,
                          const UChar* text,
@@ -898,7 +948,7 @@ unum_parseToUFormattable(const UNumberFormat* fmt,
  * on a DecimalFormat, other formats return U_UNSUPPORTED_ERROR
  * in the status.
  * @param format The formatter to set.
- * @param localized TRUE if the pattern is localized, FALSE otherwise.
+ * @param localized true if the pattern is localized, false otherwise.
  * @param pattern The new pattern
  * @param patternLength The length of pattern, or -1 if null-terminated.
  * @param parseError A pointer to UParseError to receive information
@@ -909,7 +959,7 @@ unum_parseToUFormattable(const UNumberFormat* fmt,
  * @see DecimalFormat
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unum_applyPattern(          UNumberFormat  *format,
                             UBool          localized,
                     const   UChar          *pattern,
@@ -928,7 +978,7 @@ unum_applyPattern(          UNumberFormat  *format,
 * @see unum_countAvailable
 * @stable ICU 2.0
 */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 unum_getAvailable(int32_t localeIndex);
 
 /**
@@ -940,7 +990,7 @@ unum_getAvailable(int32_t localeIndex);
 * @see unum_getAvailable
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_countAvailable(void);
 
 #if UCONFIG_HAVE_PARSEALLINPUT
@@ -1121,7 +1171,7 @@ typedef enum UNumberFormatAttribute {
 * @see unum_setTextAttribute
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_getAttribute(const UNumberFormat*          fmt,
           UNumberFormatAttribute  attr);
 
@@ -1144,7 +1194,7 @@ unum_getAttribute(const UNumberFormat*          fmt,
 * @see unum_setTextAttribute
 * @stable ICU 2.0
 */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unum_setAttribute(    UNumberFormat*          fmt,
             UNumberFormatAttribute  attr,
             int32_t                 newValue);
@@ -1164,7 +1214,7 @@ unum_setAttribute(    UNumberFormat*          fmt,
 * @see unum_setTextAttribute
 * @stable ICU 2.0
 */
-U_STABLE double U_EXPORT2
+U_CAPI double U_EXPORT2
 unum_getDoubleAttribute(const UNumberFormat*          fmt,
           UNumberFormatAttribute  attr);
 
@@ -1182,7 +1232,7 @@ unum_getDoubleAttribute(const UNumberFormat*          fmt,
 * @see unum_setTextAttribute
 * @stable ICU 2.0
 */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unum_setDoubleAttribute(    UNumberFormat*          fmt,
             UNumberFormatAttribute  attr,
             double                 newValue);
@@ -1239,7 +1289,7 @@ typedef enum UNumberFormatTextAttribute {
 * @see unum_setAttribute
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_getTextAttribute(    const    UNumberFormat*                    fmt,
             UNumberFormatTextAttribute      tag,
             UChar*                            result,
@@ -1262,7 +1312,7 @@ unum_getTextAttribute(    const    UNumberFormat*                    fmt,
 * @see unum_setAttribute
 * @stable ICU 2.0
 */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unum_setTextAttribute(    UNumberFormat*                    fmt,
             UNumberFormatTextAttribute      tag,
             const    UChar*                            newValue,
@@ -1273,8 +1323,8 @@ unum_setTextAttribute(    UNumberFormat*                    fmt,
  * Extract the pattern from a UNumberFormat.  The pattern will follow
  * the DecimalFormat pattern syntax.
  * @param fmt The formatter to query.
- * @param isPatternLocalized TRUE if the pattern should be localized,
- * FALSE otherwise.  This is ignored if the formatter is a rule-based
+ * @param isPatternLocalized true if the pattern should be localized,
+ * false otherwise.  This is ignored if the formatter is a rule-based
  * formatter.
  * @param result A pointer to a buffer to receive the pattern.
  * @param resultLength The maximum size of result.
@@ -1285,7 +1335,7 @@ unum_setTextAttribute(    UNumberFormat*                    fmt,
  * @see DecimalFormat
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_toPattern(    const    UNumberFormat*          fmt,
         UBool                  isPatternLocalized,
         UChar*                  result,
@@ -1404,7 +1454,7 @@ typedef enum UNumberFormatSymbol {
 * @see unum_setSymbol
 * @stable ICU 2.0
 */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_getSymbol(const UNumberFormat *fmt,
                UNumberFormatSymbol symbol,
                UChar *buffer,
@@ -1424,7 +1474,7 @@ unum_getSymbol(const UNumberFormat *fmt,
 * @see unum_getSymbol
 * @stable ICU 2.0
 */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unum_setSymbol(UNumberFormat *fmt,
                UNumberFormatSymbol symbol,
                const UChar *value,
@@ -1441,7 +1491,7 @@ unum_setSymbol(UNumberFormat *fmt,
  * @return the locale name
  * @stable ICU 2.8
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 unum_getLocaleByType(const UNumberFormat *fmt,
                      ULocDataLocaleType type,
                      UErrorCode* status);
@@ -1454,7 +1504,7 @@ unum_getLocaleByType(const UNumberFormat *fmt,
  * @param status A pointer to an UErrorCode to receive any errors
  * @stable ICU 53
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unum_setContext(UNumberFormat* fmt, UDisplayContext value, UErrorCode* status);
 
 /**
@@ -1466,7 +1516,7 @@ unum_setContext(UNumberFormat* fmt, UDisplayContext value, UErrorCode* status);
  * @return The UDisplayContextValue for the specified type.
  * @stable ICU 53
  */
-U_STABLE UDisplayContext U_EXPORT2
+U_CAPI UDisplayContext U_EXPORT2
 unum_getContext(const UNumberFormat *fmt, UDisplayContextType type, UErrorCode* status);
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/unicode/unumberformatter.h b/deps/icu-small/source/i18n/unicode/unumberformatter.h
index af98ba0027238a5cddcc7882605ffd2e3a1b80ef..341d9e4ad9c62880457c91e6178c28a8c6033081 100644
--- a/deps/icu-small/source/i18n/unicode/unumberformatter.h
+++ b/deps/icu-small/source/i18n/unicode/unumberformatter.h
@@ -1,11 +1,12 @@
 // © 2018 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
 
+#ifndef __UNUMBERFORMATTER_H__
+#define __UNUMBERFORMATTER_H__
+
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
-#ifndef __UNUMBERFORMATTER_H__
-#define __UNUMBERFORMATTER_H__
 
 #include "unicode/parseerr.h"
 #include "unicode/ufieldpositer.h"
@@ -77,6 +78,62 @@
  * </pre>
  */
 
+#ifndef U_FORCE_HIDE_DRAFT_API
+/**
+ * An enum declaring how to resolve conflicts between maximum fraction digits and maximum
+ * significant digits.
+ *
+ * There are two modes, RELAXED and STRICT:
+ *
+ * - RELAXED: Relax one of the two constraints (fraction digits or significant digits) in order
+ *   to round the number to a higher level of precision.
+ * - STRICT: Enforce both constraints, resulting in the number being rounded to a lower
+ *   level of precision.
+ *
+ * The default settings for compact notation rounding are Max-Fraction = 0 (round to the nearest
+ * integer), Max-Significant = 2 (round to 2 significant digits), and priority RELAXED (choose
+ * the constraint that results in more digits being displayed).
+ *
+ * Conflicting *minimum* fraction and significant digits are always resolved in the direction that
+ * results in more trailing zeros.
+ *
+ * Example 1: Consider the number 3.141, with various different settings:
+ *
+ * - Max-Fraction = 1: "3.1"
+ * - Max-Significant = 3: "3.14"
+ *
+ * The rounding priority determines how to resolve the conflict when both Max-Fraction and
+ * Max-Significant are set. With RELAXED, the less-strict setting (the one that causes more digits
+ * to be displayed) will be used; Max-Significant wins. With STRICT, the more-strict setting (the
+ * one that causes fewer digits to be displayed) will be used; Max-Fraction wins.
+ *
+ * Example 2: Consider the number 8317, with various different settings:
+ *
+ * - Max-Fraction = 1: "8317"
+ * - Max-Significant = 3: "8320"
+ *
+ * Here, RELAXED favors Max-Fraction and STRICT favors Max-Significant. Note that this larger
+ * number caused the two modes to favor the opposite result.
+ *
+ * @draft ICU 69
+ */
+typedef enum UNumberRoundingPriority {
+    /**
+     * Favor greater precision by relaxing one of the rounding constraints.
+     *
+     * @draft ICU 69
+     */
+    UNUM_ROUNDING_PRIORITY_RELAXED,
+
+    /**
+     * Favor adherence to all rounding constraints by producing lower precision.
+     *
+     * @draft ICU 69
+     */
+    UNUM_ROUNDING_PRIORITY_STRICT,
+} UNumberRoundingPriority;
+#endif // U_FORCE_HIDE_DRAFT_API
+
 /**
  * An enum declaring how to render units, including currencies. Example outputs when formatting 123 USD and 123
  * meters in <em>en-CA</em>:
@@ -107,7 +164,7 @@ typedef enum UNumberUnitWidth {
      *
      * @stable ICU 60
      */
-            UNUM_UNIT_WIDTH_NARROW,
+            UNUM_UNIT_WIDTH_NARROW = 0,
 
     /**
      * Print an abbreviated version of the unit name. Similar to NARROW, but use a slightly wider abbreviation or
@@ -123,7 +180,7 @@ typedef enum UNumberUnitWidth {
      *
      * @stable ICU 60
      */
-            UNUM_UNIT_WIDTH_SHORT,
+            UNUM_UNIT_WIDTH_SHORT = 1,
 
     /**
      * Print the full name of the unit, without any abbreviations.
@@ -134,7 +191,7 @@ typedef enum UNumberUnitWidth {
      *
      * @stable ICU 60
      */
-            UNUM_UNIT_WIDTH_FULL_NAME,
+            UNUM_UNIT_WIDTH_FULL_NAME = 2,
 
     /**
      * Use the three-digit ISO XXX code in place of the symbol for displaying currencies. The behavior of this
@@ -145,7 +202,31 @@ typedef enum UNumberUnitWidth {
      *
      * @stable ICU 60
      */
-            UNUM_UNIT_WIDTH_ISO_CODE,
+            UNUM_UNIT_WIDTH_ISO_CODE = 3,
+
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Use the formal variant of the currency symbol; for example, "NT$" for the New Taiwan
+     * dollar in zh-TW.
+     *
+     * <p>
+     * Behavior of this option with non-currency units is not defined at this time.
+     *
+     * @draft ICU 68
+     */
+            UNUM_UNIT_WIDTH_FORMAL = 4,
+
+    /**
+     * Use the alternate variant of the currency symbol; for example, "TL" for the Turkish
+     * lira (TRY).
+     *
+     * <p>
+     * Behavior of this option with non-currency units is not defined at this time.
+     *
+     * @draft ICU 68
+     */
+            UNUM_UNIT_WIDTH_VARIANT = 5,
+#endif  // U_HIDE_DRAFT_API
 
     /**
      * Format the number according to the specified unit, but do not display the unit. For currencies, apply
@@ -154,14 +235,16 @@ typedef enum UNumberUnitWidth {
      *
      * @stable ICU 60
      */
-            UNUM_UNIT_WIDTH_HIDDEN,
+            UNUM_UNIT_WIDTH_HIDDEN = 6,
 
+    // Do not conditionalize the following with #ifndef U_HIDE_INTERNAL_API,
+    // needed for unconditionalized struct MacroProps
     /**
      * One more than the highest UNumberUnitWidth value.
      *
      * @internal ICU 60: The numeric value may change over time; see ICU ticket #12420.
      */
-            UNUM_UNIT_WIDTH_COUNT
+            UNUM_UNIT_WIDTH_COUNT = 7
 } UNumberUnitWidth;
 
 /**
@@ -289,9 +372,12 @@ typedef enum UNumberSignDisplay {
      * Show the minus sign on negative numbers, and do not show the sign on positive numbers. This is the default
      * behavior.
      *
+     * If using this option, a sign will be displayed on negative zero, including negative numbers
+     * that round to zero. To hide the sign on negative zero, use the NEGATIVE option.
+     *
      * @stable ICU 60
      */
-            UNUM_SIGN_AUTO,
+    UNUM_SIGN_AUTO,
 
     /**
      * Show the minus sign on negative numbers and the plus sign on positive numbers, including zero.
@@ -299,14 +385,14 @@ typedef enum UNumberSignDisplay {
      *
      * @stable ICU 60
      */
-            UNUM_SIGN_ALWAYS,
+    UNUM_SIGN_ALWAYS,
 
     /**
      * Do not show the sign on positive or negative numbers.
      *
      * @stable ICU 60
      */
-            UNUM_SIGN_NEVER,
+    UNUM_SIGN_NEVER,
 
     /**
      * Use the locale-dependent accounting format on negative numbers, and do not show the sign on positive numbers.
@@ -322,7 +408,7 @@ typedef enum UNumberSignDisplay {
      *
      * @stable ICU 60
      */
-            UNUM_SIGN_ACCOUNTING,
+    UNUM_SIGN_ACCOUNTING,
 
     /**
      * Use the locale-dependent accounting format on negative numbers, and show the plus sign on
@@ -332,7 +418,7 @@ typedef enum UNumberSignDisplay {
      *
      * @stable ICU 60
      */
-            UNUM_SIGN_ACCOUNTING_ALWAYS,
+    UNUM_SIGN_ACCOUNTING_ALWAYS,
 
     /**
      * Show the minus sign on negative numbers and the plus sign on positive numbers. Do not show a
@@ -340,7 +426,7 @@ typedef enum UNumberSignDisplay {
      *
      * @stable ICU 61
      */
-            UNUM_SIGN_EXCEPT_ZERO,
+    UNUM_SIGN_EXCEPT_ZERO,
 
     /**
      * Use the locale-dependent accounting format on negative numbers, and show the plus sign on
@@ -349,14 +435,32 @@ typedef enum UNumberSignDisplay {
      *
      * @stable ICU 61
      */
-            UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO,
+    UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO,
+
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Same as AUTO, but do not show the sign on negative zero.
+     *
+     * @draft ICU 69
+     */
+    UNUM_SIGN_NEGATIVE,
+
+    /**
+     * Same as ACCOUNTING, but do not show the sign on negative zero.
+     *
+     * @draft ICU 69
+     */
+    UNUM_SIGN_ACCOUNTING_NEGATIVE,
+#endif // U_HIDE_DRAFT_API
 
+    // Do not conditionalize the following with #ifndef U_HIDE_INTERNAL_API,
+    // needed for unconditionalized struct MacroProps
     /**
      * One more than the highest UNumberSignDisplay value.
      *
      * @internal ICU 60: The numeric value may change over time; see ICU ticket #12420.
      */
-            UNUM_SIGN_COUNT
+    UNUM_SIGN_COUNT = 9,
 } UNumberSignDisplay;
 
 /**
@@ -386,6 +490,8 @@ typedef enum UNumberDecimalSeparatorDisplay {
      */
             UNUM_DECIMAL_SEPARATOR_ALWAYS,
 
+    // Do not conditionalize the following with #ifndef U_HIDE_INTERNAL_API,
+    // needed for unconditionalized struct MacroProps
     /**
      * One more than the highest UNumberDecimalSeparatorDisplay value.
      *
@@ -394,6 +500,32 @@ typedef enum UNumberDecimalSeparatorDisplay {
             UNUM_DECIMAL_SEPARATOR_COUNT
 } UNumberDecimalSeparatorDisplay;
 
+#ifndef U_FORCE_HIDE_DRAFT_API
+/**
+ * An enum declaring how to render trailing zeros.
+ *
+ * - UNUM_TRAILING_ZERO_AUTO: 0.90, 1.00, 1.10
+ * - UNUM_TRAILING_ZERO_HIDE_IF_WHOLE: 0.90, 1, 1.10
+ *
+ * @draft ICU 69
+ */
+typedef enum UNumberTrailingZeroDisplay {
+    /**
+     * Display trailing zeros according to the settings for minimum fraction and significant digits.
+     *
+     * @draft ICU 69
+     */
+    UNUM_TRAILING_ZERO_AUTO,
+
+    /**
+     * Same as AUTO, but hide trailing zeros after the decimal separator if they are all zero.
+     *
+     * @draft ICU 69
+     */
+    UNUM_TRAILING_ZERO_HIDE_IF_WHOLE,
+} UNumberTrailingZeroDisplay;
+#endif // U_FORCE_HIDE_DRAFT_API
+
 struct UNumberFormatter;
 /**
  * C-compatible version of icu::number::LocalizedNumberFormatter.
@@ -424,6 +556,9 @@ typedef struct UFormattedNumber UFormattedNumber;
  * For more details on skeleton strings, see the documentation in numberformatter.h. For more details on
  * the usage of this API, see the documentation at the top of unumberformatter.h.
  *
+ * For more information on number skeleton strings, see:
+ * https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html
+ *
  * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
  *
  * @param skeleton The skeleton string, like u"percent precision-integer"
@@ -432,7 +567,7 @@ typedef struct UFormattedNumber UFormattedNumber;
  * @param ec Set if an error occurs.
  * @stable ICU 62
  */
-U_STABLE UNumberFormatter* U_EXPORT2
+U_CAPI UNumberFormatter* U_EXPORT2
 unumf_openForSkeletonAndLocale(const UChar* skeleton, int32_t skeletonLen, const char* locale,
                                UErrorCode* ec);
 
@@ -441,6 +576,9 @@ unumf_openForSkeletonAndLocale(const UChar* skeleton, int32_t skeletonLen, const
  * Like unumf_openForSkeletonAndLocale, but accepts a UParseError, which will be populated with the
  * location of a skeleton syntax error if such a syntax error exists.
  *
+ * For more information on number skeleton strings, see:
+ * https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html
+ *
  * @param skeleton The skeleton string, like u"percent precision-integer"
  * @param skeletonLen The number of UChars in the skeleton string, or -1 if it is NUL-terminated.
  * @param locale The NUL-terminated locale ID.
@@ -449,7 +587,7 @@ unumf_openForSkeletonAndLocale(const UChar* skeleton, int32_t skeletonLen, const
  * @param ec Set if an error occurs.
  * @stable ICU 64
  */
-U_STABLE UNumberFormatter* U_EXPORT2
+U_CAPI UNumberFormatter* U_EXPORT2
 unumf_openForSkeletonAndLocaleWithError(
        const UChar* skeleton, int32_t skeletonLen, const char* locale, UParseError* perror, UErrorCode* ec);
 
@@ -462,7 +600,7 @@ unumf_openForSkeletonAndLocaleWithError(
  * @param ec Set if an error occurs.
  * @stable ICU 62
  */
-U_STABLE UFormattedNumber* U_EXPORT2
+U_CAPI UFormattedNumber* U_EXPORT2
 unumf_openResult(UErrorCode* ec);
 
 
@@ -481,7 +619,7 @@ unumf_openResult(UErrorCode* ec);
  * @param ec Set if an error occurs.
  * @stable ICU 62
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unumf_formatInt(const UNumberFormatter* uformatter, int64_t value, UFormattedNumber* uresult,
                 UErrorCode* ec);
 
@@ -501,7 +639,7 @@ unumf_formatInt(const UNumberFormatter* uformatter, int64_t value, UFormattedNum
  * @param ec Set if an error occurs.
  * @stable ICU 62
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unumf_formatDouble(const UNumberFormatter* uformatter, double value, UFormattedNumber* uresult,
                    UErrorCode* ec);
 
@@ -525,7 +663,7 @@ unumf_formatDouble(const UNumberFormatter* uformatter, double value, UFormattedN
  * @param ec Set if an error occurs.
  * @stable ICU 62
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unumf_formatDecimal(const UNumberFormatter* uformatter, const char* value, int32_t valueLen,
                     UFormattedNumber* uresult, UErrorCode* ec);
 
@@ -543,7 +681,7 @@ unumf_formatDecimal(const UNumberFormatter* uformatter, const char* value, int32
  * @return A UFormattedValue owned by the input object.
  * @stable ICU 64
  */
-U_STABLE const UFormattedValue* U_EXPORT2
+U_CAPI const UFormattedValue* U_EXPORT2
 unumf_resultAsValue(const UFormattedNumber* uresult, UErrorCode* ec);
 
 
@@ -566,7 +704,7 @@ unumf_resultAsValue(const UFormattedNumber* uresult, UErrorCode* ec);
  * @return The required length.
  * @stable ICU 62
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unumf_resultToString(const UFormattedNumber* uresult, UChar* buffer, int32_t bufferCapacity,
                      UErrorCode* ec);
 
@@ -600,11 +738,11 @@ unumf_resultToString(const UFormattedNumber* uresult, UChar* buffer, int32_t buf
  *            "beginIndex" field is set to the beginning of the first occurrence of the field after the
  *            input "endIndex", and "endIndex" is set to the end of that occurrence of the field
  *            (exclusive index). If a field position is not found, the FieldPosition is not changed and
- *            the method returns FALSE.
+ *            the method returns false.
  * @param ec Set if an error occurs.
  * @stable ICU 62
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 unumf_resultNextFieldPosition(const UFormattedNumber* uresult, UFieldPosition* ufpos, UErrorCode* ec);
 
 
@@ -629,16 +767,37 @@ unumf_resultNextFieldPosition(const UFormattedNumber* uresult, UFieldPosition* u
  * @param ec Set if an error occurs.
  * @stable ICU 62
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unumf_resultGetAllFieldPositions(const UFormattedNumber* uresult, UFieldPositionIterator* ufpositer,
                                  UErrorCode* ec);
 
 
-// TODO(ICU-20775): Propose this as API.
-// NOTE: This is not currently implemented.
-// U_DRAFT int32_t U_EXPORT2
-// unumf_resultToDecimalNumber(const UFormattedNumber* uresult, char* buffer, int32_t bufferCapacity,
-//                             UErrorCode* ec);
+#ifndef U_HIDE_DRAFT_API
+/**
+ * Extracts the formatted number as a "numeric string" conforming to the
+ * syntax defined in the Decimal Arithmetic Specification, available at
+ * http://speleotrove.com/decimal
+ *
+ * This endpoint is useful for obtaining the exact number being printed
+ * after scaling and rounding have been applied by the number formatter.
+ *
+ * @param uresult        The input object containing the formatted number.
+ * @param  dest          the 8-bit char buffer into which the decimal number is placed
+ * @param  destCapacity  The size, in chars, of the destination buffer.  May be zero
+ *                       for precomputing the required size.
+ * @param  ec            receives any error status.
+ *                       If U_BUFFER_OVERFLOW_ERROR: Returns number of chars for
+ *                       preflighting.
+ * @return Number of chars in the data.  Does not include a trailing NUL.
+ * @draft ICU 68
+ */
+U_CAPI int32_t U_EXPORT2
+unumf_resultToDecimalNumber(
+       const UFormattedNumber* uresult,
+       char* dest,
+       int32_t destCapacity,
+       UErrorCode* ec);
+#endif // U_HIDE_DRAFT_API
 
 
 /**
@@ -647,7 +806,7 @@ unumf_resultGetAllFieldPositions(const UFormattedNumber* uresult, UFieldPosition
  * @param uformatter An object created by unumf_openForSkeletonAndLocale().
  * @stable ICU 62
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unumf_close(UNumberFormatter* uformatter);
 
 
@@ -657,7 +816,7 @@ unumf_close(UNumberFormatter* uformatter);
  * @param uresult An object created by unumf_openResult().
  * @stable ICU 62
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unumf_closeResult(UFormattedNumber* uresult);
 
 
@@ -701,5 +860,5 @@ U_DEFINE_LOCAL_OPEN_POINTER(LocalUFormattedNumberPointer, UFormattedNumber, unum
 U_NAMESPACE_END
 #endif // U_SHOW_CPLUSPLUS_API
 
-#endif //__UNUMBERFORMATTER_H__
 #endif /* #if !UCONFIG_NO_FORMATTING */
+#endif //__UNUMBERFORMATTER_H__
diff --git a/deps/icu-small/source/i18n/unicode/unumberrangeformatter.h b/deps/icu-small/source/i18n/unicode/unumberrangeformatter.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1c5a5760fd55a3ea954f75257265d88bc264006
--- /dev/null
+++ b/deps/icu-small/source/i18n/unicode/unumberrangeformatter.h
@@ -0,0 +1,475 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#ifndef __UNUMBERRANGEFORMATTER_H__
+#define __UNUMBERRANGEFORMATTER_H__
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/parseerr.h"
+#include "unicode/ufieldpositer.h"
+#include "unicode/umisc.h"
+#include "unicode/uformattedvalue.h"
+#include "unicode/uformattable.h"
+
+
+/**
+ * \file
+ * \brief C-compatible API for localized number range formatting.
+ *
+ * This is the C-compatible version of the NumberRangeFormatter API. C++ users
+ * should include unicode/numberrangeformatter.h and use the proper C++ APIs.
+ *
+ * First create a UNumberRangeFormatter, which is immutable, and then format to
+ * a UFormattedNumberRange.
+ *
+ * Example code:
+ * <pre>
+ * // Setup:
+ * UErrorCode ec = U_ZERO_ERROR;
+ * UNumberRangeFormatter* uformatter = unumrf_openForSkeletonCollapseIdentityFallbackAndLocaleWithError(
+ *     u"currency/USD precision-integer",
+ *     -1,
+ *     UNUM_RANGE_COLLAPSE_AUTO,
+ *     UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
+ *     "en-US",
+ *     NULL,
+ *     &ec);
+ * UFormattedNumberRange* uresult = unumrf_openResult(&ec);
+ * if (U_FAILURE(ec)) { return; }
+ *
+ * // Format a double range:
+ * unumrf_formatDoubleRange(uformatter, 3.0, 5.0, uresult, &ec);
+ * if (U_FAILURE(ec)) { return; }
+ *
+ * // Get the result string:
+ * int32_t len;
+ * const UChar* str = ufmtval_getString(unumrf_resultAsValue(uresult, &ec), &len, &ec);
+ * if (U_FAILURE(ec)) { return; }
+ * // str should equal "$3 – $5"
+ *
+ * // Cleanup:
+ * unumf_close(uformatter);
+ * unumf_closeResult(uresult);
+ * </pre>
+ *
+ * If you are a C++ user linking against the C libraries, you can use the LocalPointer versions of these
+ * APIs. The following example uses LocalPointer with the decimal number and field position APIs:
+ *
+ * <pre>
+ * // Setup:
+ * LocalUNumberRangeFormatterPointer uformatter(
+ *     unumrf_openForSkeletonCollapseIdentityFallbackAndLocaleWithError(...));
+ * LocalUFormattedNumberRangePointer uresult(unumrf_openResult(&ec));
+ * if (U_FAILURE(ec)) { return; }
+ *
+ * // Format a double number range:
+ * unumrf_formatDoubleRange(uformatter.getAlias(), 3.0, 5.0, uresult.getAlias(), &ec);
+ * if (U_FAILURE(ec)) { return; }
+ *
+ * // No need to do any cleanup since we are using LocalPointer.
+ * </pre>
+ *
+ * You can also get field positions. For more information, see uformattedvalue.h.
+ */
+
+/**
+ * Defines how to merge fields that are identical across the range sign.
+ *
+ * @stable ICU 63
+ */
+typedef enum UNumberRangeCollapse {
+    /**
+     * Use locale data and heuristics to determine how much of the string to collapse. Could end up collapsing none,
+     * some, or all repeated pieces in a locale-sensitive way.
+     *
+     * The heuristics used for this option are subject to change over time.
+     *
+     * @stable ICU 63
+     */
+    UNUM_RANGE_COLLAPSE_AUTO,
+
+    /**
+     * Do not collapse any part of the number. Example: "3.2 thousand kilograms – 5.3 thousand kilograms"
+     *
+     * @stable ICU 63
+     */
+    UNUM_RANGE_COLLAPSE_NONE,
+
+    /**
+     * Collapse the unit part of the number, but not the notation, if present. Example: "3.2 thousand – 5.3 thousand
+     * kilograms"
+     *
+     * @stable ICU 63
+     */
+    UNUM_RANGE_COLLAPSE_UNIT,
+
+    /**
+     * Collapse any field that is equal across the range sign. May introduce ambiguity on the magnitude of the
+     * number. Example: "3.2 – 5.3 thousand kilograms"
+     *
+     * @stable ICU 63
+     */
+    UNUM_RANGE_COLLAPSE_ALL
+} UNumberRangeCollapse;
+
+/**
+ * Defines the behavior when the two numbers in the range are identical after rounding. To programmatically detect
+ * when the identity fallback is used, compare the lower and upper BigDecimals via FormattedNumber.
+ *
+ * @stable ICU 63
+ * @see NumberRangeFormatter
+ */
+typedef enum UNumberRangeIdentityFallback {
+    /**
+     * Show the number as a single value rather than a range. Example: "$5"
+     *
+     * @stable ICU 63
+     */
+    UNUM_IDENTITY_FALLBACK_SINGLE_VALUE,
+
+    /**
+     * Show the number using a locale-sensitive approximation pattern. If the numbers were the same before rounding,
+     * show the single value. Example: "~$5" or "$5"
+     *
+     * @stable ICU 63
+     */
+    UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE,
+
+    /**
+     * Show the number using a locale-sensitive approximation pattern. Use the range pattern always, even if the
+     * inputs are the same. Example: "~$5"
+     *
+     * @stable ICU 63
+     */
+    UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
+
+    /**
+     * Show the number as the range of two equal values. Use the range pattern always, even if the inputs are the
+     * same. Example (with RangeCollapse.NONE): "$5 – $5"
+     *
+     * @stable ICU 63
+     */
+    UNUM_IDENTITY_FALLBACK_RANGE
+} UNumberRangeIdentityFallback;
+
+/**
+ * Used in the result class FormattedNumberRange to indicate to the user whether the numbers formatted in the range
+ * were equal or not, and whether or not the identity fallback was applied.
+ *
+ * @stable ICU 63
+ * @see NumberRangeFormatter
+ */
+typedef enum UNumberRangeIdentityResult {
+    /**
+     * Used to indicate that the two numbers in the range were equal, even before any rounding rules were applied.
+     *
+     * @stable ICU 63
+     * @see NumberRangeFormatter
+     */
+    UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING,
+
+    /**
+     * Used to indicate that the two numbers in the range were equal, but only after rounding rules were applied.
+     *
+     * @stable ICU 63
+     * @see NumberRangeFormatter
+     */
+    UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING,
+
+    /**
+     * Used to indicate that the two numbers in the range were not equal, even after rounding rules were applied.
+     *
+     * @stable ICU 63
+     * @see NumberRangeFormatter
+     */
+    UNUM_IDENTITY_RESULT_NOT_EQUAL,
+
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * The number of entries in this enum.
+     * @internal
+     */
+    UNUM_IDENTITY_RESULT_COUNT
+#endif
+
+} UNumberRangeIdentityResult;
+
+
+#ifndef U_HIDE_DRAFT_API
+
+struct UNumberRangeFormatter;
+/**
+ * C-compatible version of icu::number::LocalizedNumberRangeFormatter.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberrangeformatter.h instead.
+ *
+ * @draft ICU 68
+ */
+typedef struct UNumberRangeFormatter UNumberRangeFormatter;
+
+
+struct UFormattedNumberRange;
+/**
+ * C-compatible version of icu::number::FormattedNumberRange.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberrangeformatter.h instead.
+ *
+ * @draft ICU 68
+ */
+typedef struct UFormattedNumberRange UFormattedNumberRange;
+
+
+/**
+ * Creates a new UNumberFormatter for the given skeleton string, collapse option, identity fallback
+ * option, and locale. This is currently the only method for creating a new UNumberRangeFormatter.
+ *
+ * Objects of type UNumberRangeFormatter returned by this method are threadsafe.
+ *
+ * For more details on skeleton strings, see the documentation in numberrangeformatter.h. For more
+ * details on the usage of this API, see the documentation at the top of unumberrangeformatter.h.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberrangeformatter.h instead.
+ *
+ * @param skeleton The skeleton string, like u"percent precision-integer"
+ * @param skeletonLen The number of UChars in the skeleton string, or -1 if it is NUL-terminated.
+ * @param collapse Option for how to merge affixes (if unsure, use UNUM_RANGE_COLLAPSE_AUTO)
+ * @param identityFallback Option for resolving when both sides of the range are equal.
+ * @param locale The NUL-terminated locale ID.
+ * @param perror A parse error struct populated if an error occurs when parsing. Can be NULL.
+ *               If no error occurs, perror->offset will be set to -1.
+ * @param ec Set if an error occurs.
+ * @draft ICU 68
+ */
+U_CAPI UNumberRangeFormatter* U_EXPORT2
+unumrf_openForSkeletonWithCollapseAndIdentityFallback(
+    const UChar* skeleton,
+    int32_t skeletonLen,
+    UNumberRangeCollapse collapse,
+    UNumberRangeIdentityFallback identityFallback,
+    const char* locale,
+    UParseError* perror,
+    UErrorCode* ec);
+
+
+/**
+ * Creates an object to hold the result of a UNumberRangeFormatter
+ * operation. The object can be used repeatedly; it is cleared whenever
+ * passed to a format function.
+ *
+ * @param ec Set if an error occurs.
+ * @draft ICU 68
+ */
+U_CAPI UFormattedNumberRange* U_EXPORT2
+unumrf_openResult(UErrorCode* ec);
+
+
+/**
+ * Uses a UNumberRangeFormatter to format a range of doubles.
+ *
+ * The UNumberRangeFormatter can be shared between threads. Each thread should have its own local
+ * UFormattedNumberRange, however, for storing the result of the formatting operation.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberrangeformatter.h instead.
+ *
+ * @param uformatter A formatter object; see unumberrangeformatter.h.
+ * @param first The first (usually smaller) number in the range.
+ * @param second The second (usually larger) number in the range.
+ * @param uresult The object that will be mutated to store the result; see unumrf_openResult.
+ * @param ec Set if an error occurs.
+ * @draft ICU 68
+ */
+U_CAPI void U_EXPORT2
+unumrf_formatDoubleRange(
+    const UNumberRangeFormatter* uformatter,
+    double first,
+    double second,
+    UFormattedNumberRange* uresult,
+    UErrorCode* ec);
+
+
+/**
+ * Uses a UNumberRangeFormatter to format a range of decimal numbers.
+ *
+ * With a decimal number string, you can specify an input with arbitrary precision.
+ *
+ * The UNumberRangeFormatter can be shared between threads. Each thread should have its own local
+ * UFormattedNumberRange, however, for storing the result of the formatting operation.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberrangeformatter.h instead.
+ *
+ * @param uformatter A formatter object; see unumberrangeformatter.h.
+ * @param first The first (usually smaller) number in the range.
+ * @param firstLen The length of the first decimal number string.
+ * @param second The second (usually larger) number in the range.
+ * @param secondLen The length of the second decimal number string.
+ * @param uresult The object that will be mutated to store the result; see unumrf_openResult.
+ * @param ec Set if an error occurs.
+ * @draft ICU 68
+ */
+U_CAPI void U_EXPORT2
+unumrf_formatDecimalRange(
+    const UNumberRangeFormatter* uformatter,
+    const char* first,
+    int32_t firstLen,
+    const char* second,
+    int32_t secondLen,
+    UFormattedNumberRange* uresult,
+    UErrorCode* ec);
+
+
+/**
+ * Returns a representation of a UFormattedNumberRange as a UFormattedValue,
+ * which can be subsequently passed to any API requiring that type.
+ *
+ * The returned object is owned by the UFormattedNumberRange and is valid
+ * only as long as the UFormattedNumber is present and unchanged in memory.
+ *
+ * You can think of this method as a cast between types.
+ *
+ * @param uresult The object containing the formatted number range.
+ * @param ec Set if an error occurs.
+ * @return A UFormattedValue owned by the input object.
+ * @draft ICU 68
+ */
+U_CAPI const UFormattedValue* U_EXPORT2
+unumrf_resultAsValue(const UFormattedNumberRange* uresult, UErrorCode* ec);
+
+
+/**
+ * Extracts the identity result from a UFormattedNumberRange.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param uresult The object containing the formatted number range.
+ * @param ec Set if an error occurs.
+ * @return The identity result; see UNumberRangeIdentityResult.
+ * @draft ICU 68
+ */
+U_CAPI UNumberRangeIdentityResult U_EXPORT2
+unumrf_resultGetIdentityResult(
+    const UFormattedNumberRange* uresult,
+    UErrorCode* ec);
+
+
+/**
+ * Extracts the first formatted number as a decimal number. This endpoint
+ * is useful for obtaining the exact number being printed after scaling
+ * and rounding have been applied by the number range formatting pipeline.
+ *
+ * The syntax of the unformatted number is a "numeric string"
+ * as defined in the Decimal Arithmetic Specification, available at
+ * http://speleotrove.com/decimal
+ *
+ * @param  uresult       The input object containing the formatted number range.
+ * @param  dest          the 8-bit char buffer into which the decimal number is placed
+ * @param  destCapacity  The size, in chars, of the destination buffer.  May be zero
+ *                       for precomputing the required size.
+ * @param  ec            receives any error status.
+ *                       If U_BUFFER_OVERFLOW_ERROR: Returns number of chars for
+ *                       preflighting.
+ * @return Number of chars in the data.  Does not include a trailing NUL.
+ * @draft ICU 68
+ */
+U_CAPI int32_t U_EXPORT2
+unumrf_resultGetFirstDecimalNumber(
+    const UFormattedNumberRange* uresult,
+    char* dest,
+    int32_t destCapacity,
+    UErrorCode* ec);
+
+
+/**
+ * Extracts the second formatted number as a decimal number. This endpoint
+ * is useful for obtaining the exact number being printed after scaling
+ * and rounding have been applied by the number range formatting pipeline.
+ *
+ * The syntax of the unformatted number is a "numeric string"
+ * as defined in the Decimal Arithmetic Specification, available at
+ * http://speleotrove.com/decimal
+ *
+ * @param  uresult       The input object containing the formatted number range.
+ * @param  dest          the 8-bit char buffer into which the decimal number is placed
+ * @param  destCapacity  The size, in chars, of the destination buffer.  May be zero
+ *                       for precomputing the required size.
+ * @param  ec            receives any error status.
+ *                       If U_BUFFER_OVERFLOW_ERROR: Returns number of chars for
+ *                       preflighting.
+ * @return Number of chars in the data.  Does not include a trailing NUL.
+ * @draft ICU 68
+ */
+U_CAPI int32_t U_EXPORT2
+unumrf_resultGetSecondDecimalNumber(
+    const UFormattedNumberRange* uresult,
+    char* dest,
+    int32_t destCapacity,
+    UErrorCode* ec);
+
+
+/**
+ * Releases the UNumberFormatter created by unumf_openForSkeletonAndLocale().
+ *
+ * @param uformatter An object created by unumf_openForSkeletonAndLocale().
+ * @draft ICU 68
+ */
+U_CAPI void U_EXPORT2
+unumrf_close(UNumberRangeFormatter* uformatter);
+
+
+/**
+ * Releases the UFormattedNumber created by unumf_openResult().
+ *
+ * @param uresult An object created by unumf_openResult().
+ * @draft ICU 68
+ */
+U_CAPI void U_EXPORT2
+unumrf_closeResult(UFormattedNumberRange* uresult);
+
+
+#if U_SHOW_CPLUSPLUS_API
+U_NAMESPACE_BEGIN
+
+/**
+ * \class LocalUNumberRangeFormatterPointer
+ * "Smart pointer" class; closes a UNumberFormatter via unumf_close().
+ * For most methods see the LocalPointerBase base class.
+ *
+ * Usage:
+ * <pre>
+ * LocalUNumberRangeFormatterPointer uformatter(
+ *     unumrf_openForSkeletonCollapseIdentityFallbackAndLocaleWithError(...));
+ * // no need to explicitly call unumrf_close()
+ * </pre>
+ *
+ * @see LocalPointerBase
+ * @see LocalPointer
+ * @draft ICU 68
+ */
+U_DEFINE_LOCAL_OPEN_POINTER(LocalUNumberRangeFormatterPointer, UNumberRangeFormatter, unumrf_close);
+
+/**
+ * \class LocalUFormattedNumberPointer
+ * "Smart pointer" class; closes a UFormattedNumber via unumf_closeResult().
+ * For most methods see the LocalPointerBase base class.
+ *
+ * Usage:
+ * <pre>
+ * LocalUFormattedNumberRangePointer uresult(unumrf_openResult(...));
+ * // no need to explicitly call unumrf_closeResult()
+ * </pre>
+ *
+ * @see LocalPointerBase
+ * @see LocalPointer
+ * @draft ICU 68
+ */
+U_DEFINE_LOCAL_OPEN_POINTER(LocalUFormattedNumberRangePointer, UFormattedNumberRange, unumrf_closeResult);
+
+U_NAMESPACE_END
+#endif // U_SHOW_CPLUSPLUS_API
+
+#endif // U_HIDE_DRAFT_API
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
+#endif //__UNUMBERRANGEFORMATTER_H__
diff --git a/deps/icu-small/source/i18n/unicode/unumsys.h b/deps/icu-small/source/i18n/unicode/unumsys.h
index 84ceddf84f73f9b2a527905ea3b02a3463b2d494..c767cf3d79a09cc2115f8cd6989659832823fc7b 100644
--- a/deps/icu-small/source/i18n/unicode/unumsys.h
+++ b/deps/icu-small/source/i18n/unicode/unumsys.h
@@ -15,7 +15,10 @@
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/uenum.h"
+
+#if U_SHOW_CPLUSPLUS_API
 #include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
@@ -54,7 +57,7 @@ typedef struct UNumberingSystem UNumberingSystem;  /**< C typedef for struct UNu
  *                  occurred.
  * @stable ICU 52
  */
-U_STABLE UNumberingSystem * U_EXPORT2
+U_CAPI UNumberingSystem * U_EXPORT2
 unumsys_open(const char *locale, UErrorCode *status);
 
 /**
@@ -75,7 +78,7 @@ unumsys_open(const char *locale, UErrorCode *status);
  *                  occurred.
  * @stable ICU 52
  */
-U_STABLE UNumberingSystem * U_EXPORT2
+U_CAPI UNumberingSystem * U_EXPORT2
 unumsys_openByName(const char *name, UErrorCode *status);
 
 /**
@@ -83,7 +86,7 @@ unumsys_openByName(const char *name, UErrorCode *status);
  * @param unumsys   The UNumberingSystem object to close.
  * @stable ICU 52
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 unumsys_close(UNumberingSystem *unumsys);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -111,7 +114,7 @@ U_NAMESPACE_END
  *                  or NULL if an error occurred.
  * @stable ICU 52
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 unumsys_openAvailableNames(UErrorCode *status);
 
 /**
@@ -123,18 +126,18 @@ unumsys_openAvailableNames(UErrorCode *status);
  *                  is only valid for the lifetime of the UNumberingSystem object.
  * @stable ICU 52
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 unumsys_getName(const UNumberingSystem *unumsys);
 
 /**
  * Returns whether the given UNumberingSystem object is for an algorithmic (not purely
  * positional) system.
  * @param unumsys   The UNumberingSystem whose algorithmic status is desired.
- * @return          TRUE if the specified UNumberingSystem object is for an algorithmic
+ * @return          true if the specified UNumberingSystem object is for an algorithmic
  *                  system.
  * @stable ICU 52
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 unumsys_isAlgorithmic(const UNumberingSystem *unumsys);
 
 /**
@@ -145,7 +148,7 @@ unumsys_isAlgorithmic(const UNumberingSystem *unumsys);
  * @return          The radix of the specified UNumberingSystem object.
  * @stable ICU 52
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unumsys_getRadix(const UNumberingSystem *unumsys);
 
 /**
@@ -164,7 +167,7 @@ unumsys_getRadix(const UNumberingSystem *unumsys);
  *                  output was truncated.
  * @stable ICU 52
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unumsys_getDescription(const UNumberingSystem *unumsys, UChar *result,
                        int32_t resultLength, UErrorCode *status);
 
diff --git a/deps/icu-small/source/i18n/unicode/upluralrules.h b/deps/icu-small/source/i18n/unicode/upluralrules.h
index 9c09dfab8bb9f6106b4009e584630d8ea3ac5713..71a45ddf85b5cdce2c4406aec19fa42fd782b9ba 100644
--- a/deps/icu-small/source/i18n/unicode/upluralrules.h
+++ b/deps/icu-small/source/i18n/unicode/upluralrules.h
@@ -14,14 +14,19 @@
 
 #if !UCONFIG_NO_FORMATTING
 
-#include "unicode/localpointer.h"
 #include "unicode/uenum.h"
+
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 #ifndef U_HIDE_INTERNAL_API
 #include "unicode/unum.h"
 #endif  /* U_HIDE_INTERNAL_API */
 
 // Forward-declaration
 struct UFormattedNumber;
+struct UFormattedNumberRange;
 
 /**
  * \file
@@ -163,7 +168,7 @@ uplrules_select(const UPluralRules *uplrules,
  * @param uplrules The UPluralRules object specifying the rules.
  * @param number The formatted number for which the rule has to be determined.
  * @param keyword The destination buffer for the keyword of the rule that
- *         applies to number.
+ *         applies to the number.
  * @param capacity The capacity of the keyword buffer.
  * @param status A pointer to a UErrorCode to receive any errors.
  * @return The length of the keyword.
@@ -175,6 +180,29 @@ uplrules_selectFormatted(const UPluralRules *uplrules,
                UChar *keyword, int32_t capacity,
                UErrorCode *status);
 
+#ifndef U_HIDE_DRAFT_API
+/**
+ * Given a formatted number range, returns the overall plural form of the
+ * range. For example, "3-5" returns "other" in English.
+ *
+ * To get a UFormattedNumberRange, see UNumberRangeFormatter.
+ *
+ * @param uplrules The UPluralRules object specifying the rules.
+ * @param urange The number range onto which the rules will be applied.
+ * @param keyword The destination buffer for the keyword of the rule that
+ *         applies to the number range.
+ * @param capacity The capacity of the keyword buffer.
+ * @param status A pointer to a UErrorCode to receive any errors.
+ * @return The length of the keyword.
+ * @draft ICU 68
+ */
+U_CAPI int32_t U_EXPORT2
+uplrules_selectForRange(const UPluralRules *uplrules,
+               const struct UFormattedNumberRange* urange,
+               UChar *keyword, int32_t capacity,
+               UErrorCode *status);
+#endif // U_HIDE_DRAFT_API
+
 #ifndef U_HIDE_INTERNAL_API
 /**
  * Given a number, returns the keyword of the first rule that applies to the
@@ -194,7 +222,7 @@ uplrules_selectFormatted(const UPluralRules *uplrules,
  * @return The length of keyword.
  * @internal ICU 59 technology preview, may be removed in the future
  */
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uplrules_selectWithFormat(const UPluralRules *uplrules,
                           double number,
                           const UNumberFormat *fmt,
@@ -213,7 +241,7 @@ uplrules_selectWithFormat(const UPluralRules *uplrules,
  * upon error. The caller is responsible for closing the result.
  * @stable ICU 59
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uplrules_getKeywords(const UPluralRules *uplrules,
                      UErrorCode *status);
 
diff --git a/deps/icu-small/source/i18n/unicode/uregex.h b/deps/icu-small/source/i18n/unicode/uregex.h
index cb5e51ef01e856d6fb5166c2d88a306ce0302db5..70956882471ab420e5f2f9b21cd9a73a29700814 100644
--- a/deps/icu-small/source/i18n/unicode/uregex.h
+++ b/deps/icu-small/source/i18n/unicode/uregex.h
@@ -30,9 +30,12 @@
 
 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
 
-#include "unicode/localpointer.h"
 #include "unicode/parseerr.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 struct URegularExpression;
 /**
   * Structure representing a compiled regular expression, plus the results
@@ -131,7 +134,7 @@ typedef enum URegexpFlag{
   * @stable ICU 3.0
   *
   */
-U_STABLE URegularExpression * U_EXPORT2
+U_CAPI URegularExpression * U_EXPORT2
 uregex_open( const  UChar          *pattern,
                     int32_t         patternLength,
                     uint32_t        flags,
@@ -161,7 +164,7 @@ uregex_open( const  UChar          *pattern,
   *
   * @stable ICU 4.6
   */
-U_STABLE URegularExpression *  U_EXPORT2
+U_CAPI URegularExpression *  U_EXPORT2
 uregex_openUText(UText          *pattern,
                  uint32_t        flags,
                  UParseError    *pe,
@@ -191,7 +194,7 @@ uregex_openUText(UText          *pattern,
   *
   * @stable ICU 3.0
   */
-U_STABLE URegularExpression * U_EXPORT2
+U_CAPI URegularExpression * U_EXPORT2
 uregex_openC( const char           *pattern,
                     uint32_t        flags,
                     UParseError    *pe,
@@ -207,7 +210,7 @@ uregex_openC( const char           *pattern,
   * @param regexp   The regular expression to be closed.
   * @stable ICU 3.0
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_close(URegularExpression *regexp);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -247,7 +250,7 @@ U_NAMESPACE_END
  * @return the cloned copy of the compiled regular expression.
  * @stable ICU 3.0
  */
-U_STABLE URegularExpression * U_EXPORT2
+U_CAPI URegularExpression * U_EXPORT2
 uregex_clone(const URegularExpression *regexp, UErrorCode *status);
 
 /**
@@ -267,7 +270,7 @@ uregex_clone(const URegularExpression *regexp, UErrorCode *status);
  *                   will remain valid until the regular expression is closed.
  * @stable ICU 3.0
  */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 uregex_pattern(const URegularExpression *regexp,
                      int32_t            *patLength,
                      UErrorCode         *status);
@@ -283,7 +286,7 @@ uregex_pattern(const URegularExpression *regexp,
  *
  * @stable ICU 4.6
  */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 uregex_patternUText(const URegularExpression *regexp,
                           UErrorCode         *status);
 
@@ -295,7 +298,7 @@ uregex_patternUText(const URegularExpression *regexp,
   * @see URegexpFlag
   * @stable ICU 3.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_flags(const  URegularExpression   *regexp,
                     UErrorCode           *status);
 
@@ -320,7 +323,7 @@ uregex_flags(const  URegularExpression   *regexp,
   * @param status     Receives errors detected by this function.
   * @stable ICU 3.0
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setText(URegularExpression *regexp,
                const UChar        *text,
                int32_t             textLength,
@@ -343,7 +346,7 @@ uregex_setText(URegularExpression *regexp,
   *
   * @stable ICU 4.6
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setUText(URegularExpression *regexp,
                 UText              *text,
                 UErrorCode         *status);
@@ -368,7 +371,7 @@ uregex_setUText(URegularExpression *regexp,
   *                    this regular expression.
   * @stable ICU 3.0
   */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 uregex_getText(URegularExpression *regexp,
                int32_t            *textLength,
                UErrorCode         *status);
@@ -389,7 +392,7 @@ uregex_getText(URegularExpression *regexp,
   *
   * @stable ICU 4.6
   */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 uregex_getUText(URegularExpression *regexp,
                 UText              *dest,
                 UErrorCode         *status);
@@ -419,7 +422,7 @@ uregex_getUText(URegularExpression *regexp,
   *
   * @stable ICU 4.8
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_refreshUText(URegularExpression *regexp,
                     UText              *text,
                     UErrorCode         *status);
@@ -441,10 +444,10 @@ uregex_refreshUText(URegularExpression *regexp,
   *    @param  startIndex  The input string (native) index at which to begin matching, or -1
   *                        to match the input Region.
   *    @param  status      Receives errors detected by this function.
-  *    @return             TRUE if there is a match
+  *    @return             true if there is a match
   *    @stable ICU 3.0
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_matches(URegularExpression *regexp,
                 int32_t            startIndex,
                 UErrorCode        *status);
@@ -467,10 +470,10 @@ uregex_matches(URegularExpression *regexp,
   *    @param  startIndex  The input string (native) index at which to begin matching, or -1
   *                        to match the input Region.
   *    @param  status      Receives errors detected by this function.
-  *    @return             TRUE if there is a match
+  *    @return             true if there is a match
   *   @stable ICU 4.6
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_matches64(URegularExpression *regexp,
                  int64_t            startIndex,
                  UErrorCode        *status);
@@ -495,10 +498,10 @@ uregex_matches64(URegularExpression *regexp,
   *    @param   startIndex  The input string (native) index at which to begin matching, or
   *                         -1 to match the Input Region
   *    @param   status      A reference to a UErrorCode to receive any errors.
-  *    @return  TRUE if there is a match.
+  *    @return  true if there is a match.
   *    @stable ICU 3.0
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_lookingAt(URegularExpression *regexp,
                  int32_t             startIndex,
                  UErrorCode         *status);
@@ -524,10 +527,10 @@ uregex_lookingAt(URegularExpression *regexp,
   *    @param   startIndex  The input string (native) index at which to begin matching, or
   *                         -1 to match the Input Region
   *    @param   status      A reference to a UErrorCode to receive any errors.
-  *    @return  TRUE if there is a match.
+  *    @return  true if there is a match.
   *    @stable ICU 4.6
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_lookingAt64(URegularExpression *regexp,
                    int64_t             startIndex,
                    UErrorCode         *status);
@@ -548,10 +551,10 @@ uregex_lookingAt64(URegularExpression *regexp,
   *   @param   startIndex  The position (native) in the input string to begin the search, or
   *                        -1 to search within the Input Region.
   *   @param   status      A reference to a UErrorCode to receive any errors.
-  *   @return              TRUE if a match is found.
+  *   @return              true if a match is found.
   *   @stable ICU 3.0
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_find(URegularExpression *regexp,
             int32_t             startIndex,
             UErrorCode         *status);
@@ -573,10 +576,10 @@ uregex_find(URegularExpression *regexp,
   *   @param   startIndex  The position (native) in the input string to begin the search, or
   *                        -1 to search within the Input Region.
   *   @param   status      A reference to a UErrorCode to receive any errors.
-  *   @return              TRUE if a match is found.
+  *   @return              true if a match is found.
   *   @stable ICU 4.6
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_find64(URegularExpression *regexp,
               int64_t             startIndex,
               UErrorCode         *status);
@@ -590,11 +593,11 @@ uregex_find64(URegularExpression *regexp,
   *
   *  @param   regexp      The compiled regular expression.
   *  @param   status      A reference to a UErrorCode to receive any errors.
-  *  @return              TRUE if a match is found.
+  *  @return              true if a match is found.
   *  @see uregex_reset
   *  @stable ICU 3.0
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_findNext(URegularExpression *regexp,
                 UErrorCode         *status);
 
@@ -605,7 +608,7 @@ uregex_findNext(URegularExpression *regexp,
   *   @return the number of capture groups
   *   @stable ICU 3.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_groupCount(URegularExpression *regexp,
                   UErrorCode         *status);
 
@@ -625,7 +628,7 @@ uregex_groupCount(URegularExpression *regexp,
   *
   * @stable ICU 55
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_groupNumberFromName(URegularExpression *regexp,
                            const UChar        *groupName,
                            int32_t             nameLength,
@@ -649,7 +652,7 @@ uregex_groupNumberFromName(URegularExpression *regexp,
   *
   * @stable ICU 55
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_groupNumberFromCName(URegularExpression *regexp,
                             const char         *groupName,
                             int32_t             nameLength,
@@ -671,7 +674,7 @@ uregex_groupNumberFromCName(URegularExpression *regexp,
   *                         or -1 if no applicable match.
   *   @stable ICU 3.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_group(URegularExpression *regexp,
              int32_t             groupNum,
              UChar              *dest,
@@ -700,7 +703,7 @@ uregex_group(URegularExpression *regexp,
   *
   *   @stable ICU 4.6
   */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 uregex_groupUText(URegularExpression *regexp,
                   int32_t             groupNum,
                   UText              *dest,
@@ -721,7 +724,7 @@ uregex_groupUText(URegularExpression *regexp,
   *                         by the specified group.
   *    @stable ICU 3.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_start(URegularExpression *regexp,
              int32_t             groupNum,
              UErrorCode          *status);
@@ -741,7 +744,7 @@ uregex_start(URegularExpression *regexp,
   *                         by the specified group.
   *   @stable ICU 4.6
   */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 uregex_start64(URegularExpression *regexp,
                int32_t             groupNum,
                UErrorCode          *status);
@@ -759,7 +762,7 @@ uregex_start64(URegularExpression *regexp,
   *    @return              the (native) index of the position following the last matched character.
   *    @stable ICU 3.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_end(URegularExpression   *regexp,
            int32_t               groupNum,
            UErrorCode           *status);
@@ -778,7 +781,7 @@ uregex_end(URegularExpression   *regexp,
   *    @return              the (native) index of the position following the last matched character.
   *   @stable ICU 4.6
   */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 uregex_end64(URegularExpression *regexp,
              int32_t               groupNum,
              UErrorCode           *status);
@@ -796,7 +799,7 @@ uregex_end64(URegularExpression *regexp,
   *    @param   status      A reference to a UErrorCode to receive any errors.
   *    @stable ICU 3.0
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_reset(URegularExpression    *regexp,
              int32_t               index,
              UErrorCode            *status);
@@ -815,7 +818,7 @@ uregex_reset(URegularExpression    *regexp,
   *    @param   status      A reference to a UErrorCode to receive any errors.
   *    @stable ICU 4.6
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_reset64(URegularExpression  *regexp,
                int64_t               index,
                UErrorCode            *status);
@@ -840,7 +843,7 @@ uregex_reset64(URegularExpression  *regexp,
   * @param status A pointer to a UErrorCode to receive any errors.
   * @stable ICU 4.0
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setRegion(URegularExpression   *regexp,
                  int32_t               regionStart,
                  int32_t               regionLimit,
@@ -867,7 +870,7 @@ uregex_setRegion(URegularExpression   *regexp,
   * @param status A pointer to a UErrorCode to receive any errors.
   * @stable ICU 4.6
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setRegion64(URegularExpression *regexp,
                  int64_t               regionStart,
                  int64_t               regionLimit,
@@ -887,7 +890,7 @@ uregex_setRegion64(URegularExpression *regexp,
   * @param status A pointer to a UErrorCode to receive any errors.
   * @stable ICU 4.6
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setRegionAndStart(URegularExpression *regexp,
                  int64_t               regionStart,
                  int64_t               regionLimit,
@@ -903,7 +906,7 @@ uregex_setRegionAndStart(URegularExpression *regexp,
   * @return The starting (native) index of this matcher's region.
   * @stable ICU 4.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_regionStart(const  URegularExpression   *regexp,
                           UErrorCode           *status);
 
@@ -917,7 +920,7 @@ uregex_regionStart(const  URegularExpression   *regexp,
   * @return The starting (native) index of this matcher's region.
   * @stable ICU 4.6
   */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 uregex_regionStart64(const  URegularExpression   *regexp,
                             UErrorCode           *status);
 
@@ -931,7 +934,7 @@ uregex_regionStart64(const  URegularExpression   *regexp,
   * @return The ending point (native) of this matcher's region.
   * @stable ICU 4.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_regionEnd(const  URegularExpression   *regexp,
                         UErrorCode           *status);
 
@@ -946,7 +949,7 @@ uregex_regionEnd(const  URegularExpression   *regexp,
   * @return The ending point (native) of this matcher's region.
   * @stable ICU 4.6
   */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
 uregex_regionEnd64(const  URegularExpression   *regexp,
                           UErrorCode           *status);
 
@@ -957,18 +960,18 @@ uregex_regionEnd64(const  URegularExpression   *regexp,
   *
   * @param regexp The compiled regular expression.
   * @param status A pointer to a UErrorCode to receive any errors.
-  * @return TRUE if this matcher is using opaque bounds, false if it is not.
+  * @return true if this matcher is using opaque bounds, false if it is not.
   * @stable ICU 4.0
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_hasTransparentBounds(const  URegularExpression   *regexp,
                                    UErrorCode           *status);
 
 
 /**
   * Sets the transparency of region bounds for this URegularExpression.
-  * Invoking this function with an argument of TRUE will set matches to use transparent bounds.
-  * If the boolean argument is FALSE, then opaque bounds will be used.
+  * Invoking this function with an argument of true will set matches to use transparent bounds.
+  * If the boolean argument is false, then opaque bounds will be used.
   *
   * Using transparent bounds, the boundaries of the matching region are transparent
   * to lookahead, lookbehind, and boundary matching constructs. Those constructs can
@@ -980,11 +983,11 @@ uregex_hasTransparentBounds(const  URegularExpression   *regexp,
   * By default, opaque bounds are used.
   *
   * @param   regexp The compiled regular expression.
-  * @param   b      TRUE for transparent bounds; FALSE for opaque bounds
+  * @param   b      true for transparent bounds; false for opaque bounds
   * @param   status A pointer to a UErrorCode to receive any errors.
   * @stable ICU 4.0
   **/
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_useTransparentBounds(URegularExpression   *regexp,
                             UBool                b,
                             UErrorCode           *status);
@@ -996,10 +999,10 @@ uregex_useTransparentBounds(URegularExpression   *regexp,
   *
   * @param  regexp The compiled regular expression.
   * @param  status A pointer to a UErrorCode to receive any errors.
-  * @return TRUE if this matcher is using anchoring bounds.
+  * @return true if this matcher is using anchoring bounds.
   * @stable ICU 4.0
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_hasAnchoringBounds(const  URegularExpression   *regexp,
                                  UErrorCode           *status);
 
@@ -1013,41 +1016,41 @@ uregex_hasAnchoringBounds(const  URegularExpression   *regexp,
   * Anchoring Bounds are the default for regions.
   *
   * @param regexp The compiled regular expression.
-  * @param b      TRUE if to enable anchoring bounds; FALSE to disable them.
+  * @param b      true if to enable anchoring bounds; false to disable them.
   * @param status A pointer to a UErrorCode to receive any errors.
   * @stable ICU 4.0
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_useAnchoringBounds(URegularExpression   *regexp,
                           UBool                 b,
                           UErrorCode           *status);
 
 /**
-  * Return TRUE if the most recent matching operation touched the
+  * Return true if the most recent matching operation touched the
   *  end of the text being processed.  In this case, additional input text could
   *  change the results of that match.
   *
   *  @param regexp The compiled regular expression.
   *  @param status A pointer to a UErrorCode to receive any errors.
-  *  @return  TRUE if the most recent match hit the end of input
+  *  @return  true if the most recent match hit the end of input
   *  @stable ICU 4.0
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_hitEnd(const  URegularExpression   *regexp,
                      UErrorCode           *status);
 
 /**
-  * Return TRUE the most recent match succeeded and additional input could cause
+  * Return true the most recent match succeeded and additional input could cause
   * it to fail. If this function returns false and a match was found, then more input
   * might change the match but the match won't be lost. If a match was not found,
   * then requireEnd has no meaning.
   *
   * @param regexp The compiled regular expression.
   * @param status A pointer to a UErrorCode to receive any errors.
-  * @return TRUE  if more input could cause the most recent match to no longer match.
+  * @return true  if more input could cause the most recent match to no longer match.
   * @stable ICU 4.0
   */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregex_requireEnd(const  URegularExpression   *regexp,
                          UErrorCode           *status);
 
@@ -1079,7 +1082,7 @@ uregex_requireEnd(const  URegularExpression   *regexp,
   *                                is still the full length of the untruncated string.
   *    @stable ICU 3.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_replaceAll(URegularExpression    *regexp,
                   const UChar           *replacementText,
                   int32_t                replacementLength,
@@ -1108,7 +1111,7 @@ uregex_replaceAll(URegularExpression    *regexp,
   *
   *    @stable ICU 4.6
   */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 uregex_replaceAllUText(URegularExpression *regexp,
                        UText              *replacement,
                        UText              *dest,
@@ -1138,7 +1141,7 @@ uregex_replaceAllUText(URegularExpression *regexp,
   *                                is still the full length of the untruncated string.
   *    @stable ICU 3.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_replaceFirst(URegularExpression  *regexp,
                     const UChar         *replacementText,
                     int32_t              replacementLength,
@@ -1167,7 +1170,7 @@ uregex_replaceFirst(URegularExpression  *regexp,
   *
   *    @stable ICU 4.6
   */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 uregex_replaceFirstUText(URegularExpression *regexp,
                          UText              *replacement,
                          UText              *dest,
@@ -1219,7 +1222,7 @@ uregex_replaceFirstUText(URegularExpression *regexp,
   *   @stable ICU 3.0
   *
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_appendReplacement(URegularExpression    *regexp,
                          const UChar           *replacementText,
                          int32_t                replacementLength,
@@ -1249,7 +1252,7 @@ uregex_appendReplacement(URegularExpression    *regexp,
   *
   *   @stable ICU 4.6
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_appendReplacementUText(URegularExpression    *regexp,
                               UText                 *replacementText,
                               UText                 *dest,
@@ -1279,7 +1282,7 @@ uregex_appendReplacementUText(URegularExpression    *regexp,
   *
   *   @stable ICU 3.0
   */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_appendTail(URegularExpression    *regexp,
                   UChar                **destBuf,
                   int32_t               *destCapacity,
@@ -1303,7 +1306,7 @@ uregex_appendTail(URegularExpression    *regexp,
   *
   *   @stable ICU 4.6
   */
-U_STABLE UText * U_EXPORT2
+U_CAPI UText * U_EXPORT2
 uregex_appendTailUText(URegularExpression    *regexp,
                        UText                 *dest,
                        UErrorCode            *status);
@@ -1359,7 +1362,7 @@ uregex_appendTailUText(URegularExpression    *regexp,
    * @return        The number of fields into which the input string was split.
    * @stable ICU 3.0
    */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_split(   URegularExpression      *regexp,
                   UChar                 *destBuf,
                   int32_t                destCapacity,
@@ -1394,7 +1397,7 @@ uregex_split(   URegularExpression      *regexp,
    *
    * @stable ICU 4.6
    */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_splitUText(URegularExpression    *regexp,
                   UText                 *destFields[],
                   int32_t                destFieldsCapacity,
@@ -1422,7 +1425,7 @@ uregex_splitUText(URegularExpression    *regexp,
  * @param   status      A reference to a UErrorCode to receive any errors.
  * @stable ICU 4.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setTimeLimit(URegularExpression      *regexp,
                     int32_t                  limit,
                     UErrorCode              *status);
@@ -1436,7 +1439,7 @@ uregex_setTimeLimit(URegularExpression      *regexp,
  * @return the maximum allowed time for a match, in units of processing steps.
  * @stable ICU 4.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_getTimeLimit(const URegularExpression      *regexp,
                           UErrorCode              *status);
 
@@ -1460,7 +1463,7 @@ uregex_getTimeLimit(const URegularExpression      *regexp,
  *
  * @stable ICU 4.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setStackLimit(URegularExpression      *regexp,
                      int32_t                  limit,
                      UErrorCode              *status);
@@ -1472,7 +1475,7 @@ uregex_setStackLimit(URegularExpression      *regexp,
  *          stack size is unlimited.
  * @stable ICU 4.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregex_getStackLimit(const URegularExpression      *regexp,
                            UErrorCode              *status);
 
@@ -1480,7 +1483,7 @@ uregex_getStackLimit(const URegularExpression      *regexp,
 /**
  * Function pointer for a regular expression matching callback function.
  * When set, a callback function will be called periodically during matching
- * operations.  If the call back function returns FALSE, the matching
+ * operations.  If the call back function returns false, the matching
  * operation will be terminated early.
  *
  * Note:  the callback function must not call other functions on this
@@ -1491,8 +1494,8 @@ uregex_getStackLimit(const URegularExpression      *regexp,
  *                 uregex_setMatchCallback() is called.
  * @param steps    the accumulated processing time, in match steps,
  *                 for this matching operation.
- * @return         TRUE to continue the matching operation.
- *                 FALSE to terminate the matching operation.
+ * @return         true to continue the matching operation.
+ *                 false to terminate the matching operation.
  * @stable ICU 4.0
  */
 U_CDECL_BEGIN
@@ -1515,7 +1518,7 @@ U_CDECL_END
  * @param   status      A reference to a UErrorCode to receive any errors.
  * @stable ICU 4.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setMatchCallback(URegularExpression      *regexp,
                         URegexMatchCallback     *callback,
                         const void              *context,
@@ -1533,7 +1536,7 @@ uregex_setMatchCallback(URegularExpression      *regexp,
  * @param   status      A reference to a UErrorCode to receive any errors.
  * @stable ICU 4.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_getMatchCallback(const URegularExpression    *regexp,
                         URegexMatchCallback        **callback,
                         const void                 **context,
@@ -1554,7 +1557,7 @@ uregex_getMatchCallback(const URegularExpression    *regexp,
  * to be attempted, giving the application the opportunity to terminate a long-running
  * find operation.
  *
- * If the call back function returns FALSE, the find operation will be terminated early.
+ * If the call back function returns false, the find operation will be terminated early.
  *
  * Note:  the callback function must not call other functions on this
  *        URegularExpression
@@ -1565,8 +1568,8 @@ uregex_getMatchCallback(const URegularExpression    *regexp,
  * @param matchIndex  the next index at which a match attempt will be attempted for this
  *                 find operation.  If this callback interrupts the search, this is the
  *                 index at which a find/findNext operation may be re-initiated.
- * @return         TRUE to continue the matching operation.
- *                 FALSE to terminate the matching operation.
+ * @return         true to continue the matching operation.
+ *                 false to terminate the matching operation.
  * @stable ICU 4.6
  */
 U_CDECL_BEGIN
@@ -1587,7 +1590,7 @@ U_CDECL_END
  * @param   status      A reference to a UErrorCode to receive any errors.
  * @stable ICU 4.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_setFindProgressCallback(URegularExpression              *regexp,
                                 URegexFindProgressCallback      *callback,
                                 const void                      *context,
@@ -1604,7 +1607,7 @@ uregex_setFindProgressCallback(URegularExpression              *regexp,
  * @param   status      A reference to a UErrorCode to receive any errors.
  * @stable ICU 4.6
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uregex_getFindProgressCallback(const URegularExpression          *regexp,
                                 URegexFindProgressCallback        **callback,
                                 const void                        **context,
diff --git a/deps/icu-small/source/i18n/unicode/uregion.h b/deps/icu-small/source/i18n/unicode/uregion.h
index 9d0c1e99de3864217d67f4d91d5781c4d5b7b7cb..4e4e6aac9f8fccc1b34f088d8f9584f3ff575963 100644
--- a/deps/icu-small/source/i18n/unicode/uregion.h
+++ b/deps/icu-small/source/i18n/unicode/uregion.h
@@ -133,7 +133,7 @@ typedef struct URegion URegion; /**< @stable ICU 52 */
  * (U_ILLEGAL_ARGUMENT_ERROR).
  * @stable ICU 52
  */
-U_STABLE const URegion* U_EXPORT2
+U_CAPI const URegion* U_EXPORT2
 uregion_getRegionFromCode(const char *regionCode, UErrorCode *status);
 
 /**
@@ -141,7 +141,7 @@ uregion_getRegionFromCode(const char *regionCode, UErrorCode *status);
  * code is not recognized, the appropriate error code will be set (U_ILLEGAL_ARGUMENT_ERROR).
  * @stable ICU 52
  */
-U_STABLE const URegion* U_EXPORT2
+U_CAPI const URegion* U_EXPORT2
 uregion_getRegionFromNumericCode (int32_t code, UErrorCode *status);
 
 /**
@@ -149,14 +149,14 @@ uregion_getRegionFromNumericCode (int32_t code, UErrorCode *status);
  * The enumeration must be closed with with uenum_close().
  * @stable ICU 52
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uregion_getAvailable(URegionType type, UErrorCode *status);
 
 /**
  * Returns true if the specified uregion is equal to the specified otherRegion.
  * @stable ICU 52
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregion_areEqual(const URegion* uregion, const URegion* otherRegion);
 
 /**
@@ -165,7 +165,7 @@ uregion_areEqual(const URegion* uregion, const URegion* otherRegion);
  * this method with region "IT" (Italy) returns the URegion for "039" (Southern Europe).
  * @stable ICU 52
  */
-U_STABLE const URegion* U_EXPORT2
+U_CAPI const URegion* U_EXPORT2
 uregion_getContainingRegion(const URegion* uregion);
 
 /**
@@ -177,7 +177,7 @@ uregion_getContainingRegion(const URegion* uregion);
  * URegion "150" (Europe).
  * @stable ICU 52
  */
-U_STABLE const URegion* U_EXPORT2
+U_CAPI const URegion* U_EXPORT2
 uregion_getContainingRegionOfType(const URegion* uregion, URegionType type);
 
 /**
@@ -190,7 +190,7 @@ uregion_getContainingRegionOfType(const URegion* uregion, URegionType type);
  * and "155" (Western Europe). The enumeration must be closed with with uenum_close().
  * @stable ICU 52
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uregion_getContainedRegions(const URegion* uregion, UErrorCode *status);
 
 /**
@@ -202,7 +202,7 @@ uregion_getContainedRegions(const URegion* uregion, UErrorCode *status);
  * etc. The enumeration must be closed with with uenum_close().
  * @stable ICU 52
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uregion_getContainedRegionsOfType(const URegion* uregion, URegionType type, UErrorCode *status);
 
 /**
@@ -210,7 +210,7 @@ uregion_getContainedRegionsOfType(const URegion* uregion, URegionType type, UErr
  * hierarchy.
  * @stable ICU 52
  */
-U_STABLE UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 uregion_contains(const URegion* uregion, const URegion* otherRegion);
 
 /**
@@ -221,14 +221,14 @@ uregion_contains(const URegion* uregion, const URegion* otherRegion);
  * "AZ" (Azerbaijan), etc... The enumeration must be closed with with uenum_close().
  * @stable ICU 52
  */
-U_STABLE UEnumeration* U_EXPORT2
+U_CAPI UEnumeration* U_EXPORT2
 uregion_getPreferredValues(const URegion* uregion, UErrorCode *status);
 
 /**
  * Returns the specified uregion's canonical code.
  * @stable ICU 52
  */
-U_STABLE const char* U_EXPORT2
+U_CAPI const char* U_EXPORT2
 uregion_getRegionCode(const URegion* uregion);
 
 /**
@@ -236,14 +236,14 @@ uregion_getRegionCode(const URegion* uregion);
  * for the specified uregion.
  * @stable ICU 52
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uregion_getNumericCode(const URegion* uregion);
 
 /**
  * Returns the URegionType of the specified uregion.
  * @stable ICU 52
  */
-U_STABLE URegionType U_EXPORT2
+U_CAPI URegionType U_EXPORT2
 uregion_getType(const URegion* uregion);
 
 
diff --git a/deps/icu-small/source/i18n/unicode/ureldatefmt.h b/deps/icu-small/source/i18n/unicode/ureldatefmt.h
index d12f0988a88ed1a0a0d0ed047fe0f05171bc9a06..b66139461b53adcc8d58fa0d074325e61ba334f0 100644
--- a/deps/icu-small/source/i18n/unicode/ureldatefmt.h
+++ b/deps/icu-small/source/i18n/unicode/ureldatefmt.h
@@ -16,9 +16,12 @@
 
 #include "unicode/unum.h"
 #include "unicode/udisplaycontext.h"
-#include "unicode/localpointer.h"
 #include "unicode/uformattedvalue.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: URelativeDateTimeFormatter, relative date formatting of unit + numeric offset.
@@ -234,7 +237,7 @@ typedef struct URelativeDateTimeFormatter URelativeDateTimeFormatter;  /**< C ty
  *          or NULL if an error occurred.
  * @stable ICU 57
  */
-U_STABLE URelativeDateTimeFormatter* U_EXPORT2
+U_CAPI URelativeDateTimeFormatter* U_EXPORT2
 ureldatefmt_open( const char*          locale,
                   UNumberFormat*       nfToAdopt,
                   UDateRelativeDateTimeFormatterStyle width,
@@ -247,7 +250,7 @@ ureldatefmt_open( const char*          locale,
  *            The URelativeDateTimeFormatter object to close.
  * @stable ICU 57
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ureldatefmt_close(URelativeDateTimeFormatter *reldatefmt);
 
 struct UFormattedRelativeDateTime;
@@ -266,7 +269,7 @@ typedef struct UFormattedRelativeDateTime UFormattedRelativeDateTime;
  * @return A pointer needing ownership.
  * @stable ICU 64
  */
-U_STABLE UFormattedRelativeDateTime* U_EXPORT2
+U_CAPI UFormattedRelativeDateTime* U_EXPORT2
 ureldatefmt_openResult(UErrorCode* ec);
 
 /**
@@ -283,7 +286,7 @@ ureldatefmt_openResult(UErrorCode* ec);
  * @return A UFormattedValue owned by the input object.
  * @stable ICU 64
  */
-U_STABLE const UFormattedValue* U_EXPORT2
+U_CAPI const UFormattedValue* U_EXPORT2
 ureldatefmt_resultAsValue(const UFormattedRelativeDateTime* ufrdt, UErrorCode* ec);
 
 /**
@@ -292,7 +295,7 @@ ureldatefmt_resultAsValue(const UFormattedRelativeDateTime* ufrdt, UErrorCode* e
  * @param ufrdt The object to release.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ureldatefmt_closeResult(UFormattedRelativeDateTime* ufrdt);
 
 
@@ -354,7 +357,7 @@ U_NAMESPACE_END
  *          than resultCapacity, in which case an error is returned.
  * @stable ICU 57
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ureldatefmt_formatNumeric( const URelativeDateTimeFormatter* reldatefmt,
                     double                offset,
                     URelativeDateTimeUnit unit,
@@ -385,7 +388,7 @@ ureldatefmt_formatNumeric( const URelativeDateTimeFormatter* reldatefmt,
  *          undefined.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ureldatefmt_formatNumericToResult(
     const URelativeDateTimeFormatter* reldatefmt,
     double                            offset,
@@ -421,7 +424,7 @@ ureldatefmt_formatNumericToResult(
  *          than resultCapacity, in which case an error is returned.
  * @stable ICU 57
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ureldatefmt_format( const URelativeDateTimeFormatter* reldatefmt,
                     double                offset,
                     URelativeDateTimeUnit unit,
@@ -455,7 +458,7 @@ ureldatefmt_format( const URelativeDateTimeFormatter* reldatefmt,
  *          undefined.
  * @stable ICU 64
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 ureldatefmt_formatToResult(
     const URelativeDateTimeFormatter* reldatefmt,
     double                            offset,
@@ -492,7 +495,7 @@ ureldatefmt_formatToResult(
  *          in which case an error is returned.
  * @stable ICU 57
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 ureldatefmt_combineDateAndTime( const URelativeDateTimeFormatter* reldatefmt,
                     const UChar *     relativeDateString,
                     int32_t           relativeDateStringLen,
diff --git a/deps/icu-small/source/i18n/unicode/usearch.h b/deps/icu-small/source/i18n/unicode/usearch.h
index d9d84b4f6a971592d544a637de3a7c4a580161a8..26c22b7353953dab88daa329579002d05ce44504 100644
--- a/deps/icu-small/source/i18n/unicode/usearch.h
+++ b/deps/icu-small/source/i18n/unicode/usearch.h
@@ -15,18 +15,21 @@
 
 #if !UCONFIG_NO_COLLATION && !UCONFIG_NO_BREAK_ITERATION
 
-#include "unicode/localpointer.h"
 #include "unicode/ucol.h"
 #include "unicode/ucoleitr.h"
 #include "unicode/ubrk.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /**
  * \file
  * \brief C API: StringSearch
  *
  * C APIs for an engine that provides language-sensitive text searching based
- * on the comparison rules defined in a <tt>UCollator</tt> data struct,
- * see <tt>ucol.h</tt>. This ensures that language eccentricity can be
+ * on the comparison rules defined in a <code>UCollator</code> data struct,
+ * see <code>ucol.h</code>. This ensures that language eccentricity can be
  * handled, e.g. for the German collator, characters &szlig; and SS will be matched
  * if case is chosen to be ignored.
  * See the <a href="http://source.icu-project.org/repos/icu/icuhtml/trunk/design/collation/ICU_collation_design.htm">
@@ -54,18 +57,18 @@
  * Option 2. will be the default.
  * <p>
  * This search has APIs similar to that of other text iteration mechanisms
- * such as the break iterators in <tt>ubrk.h</tt>. Using these
+ * such as the break iterators in <code>ubrk.h</code>. Using these
  * APIs, it is easy to scan through text looking for all occurrences of
  * a given pattern. This search iterator allows changing of direction by
- * calling a <tt>reset</tt> followed by a <tt>next</tt> or <tt>previous</tt>.
- * Though a direction change can occur without calling <tt>reset</tt> first,
+ * calling a <code>reset</code> followed by a <code>next</code> or <code>previous</code>.
+ * Though a direction change can occur without calling <code>reset</code> first,
  * this operation comes with some speed penalty.
  * Generally, match results in the forward direction will match the result
  * matches in the backwards direction in the reverse order
  * <p>
- * <tt>usearch.h</tt> provides APIs to specify the starting position
- * within the text string to be searched, e.g. <tt>usearch_setOffset</tt>,
- * <tt>usearch_preceding</tt> and <tt>usearch_following</tt>. Since the
+ * <code>usearch.h</code> provides APIs to specify the starting position
+ * within the text string to be searched, e.g. <code>usearch_setOffset</code>,
+ * <code>usearch_preceding</code> and <code>usearch_following</code>. Since the
  * starting position will be set as it is specified, please take note that
  * there are some dangerous positions which the search may render incorrect
  * results:
@@ -101,7 +104,7 @@
  * Though collator attributes will be taken into consideration while
  * performing matches, there are no APIs here for setting and getting the
  * attributes. These attributes can be set by getting the collator
- * from <tt>usearch_getCollator</tt> and using the APIs in <tt>ucol.h</tt>.
+ * from <code>usearch_getCollator</code> and using the APIs in <code>ucol.h</code>.
  * Lastly to update String Search to the new collator attributes,
  * usearch_reset() has to be called.
  * <p>
@@ -277,9 +280,13 @@ typedef enum {
 /* open and close ------------------------------------------------------ */
 
 /**
-* Creating a search iterator data struct using the argument locale language
+* Creates a String Search iterator data struct using the argument locale language
 * rule set. A collator will be created in the process, which will be owned by
-* this search and will be deleted in <tt>usearch_close</tt>.
+* this String Search and will be deleted in <code>usearch_close</code>.
+*
+* The UStringSearch retains a pointer to both the pattern and text strings.
+* The caller must not modify or delete them while using the UStringSearch.
+*
 * @param pattern for matching
 * @param patternlength length of the pattern, -1 for null-termination
 * @param text text string
@@ -288,9 +295,9 @@ typedef enum {
 * @param breakiter A BreakIterator that will be used to restrict the points
 *                  at which matches are detected. If a match is found, but
 *                  the match's start or end index is not a boundary as
-*                  determined by the <tt>BreakIterator</tt>, the match will
+*                  determined by the <code>BreakIterator</code>, the match will
 *                  be rejected and another will be searched for.
-*                  If this parameter is <tt>NULL</tt>, no break detection is
+*                  If this parameter is <code>NULL</code>, no break detection is
 *                  attempted.
 * @param status for errors if it occurs. If pattern or text is NULL, or if
 *               patternlength or textlength is 0 then an
@@ -298,7 +305,7 @@ typedef enum {
 * @return search iterator data structure, or NULL if there is an error.
 * @stable ICU 2.4
 */
-U_STABLE UStringSearch * U_EXPORT2 usearch_open(const UChar          *pattern,
+U_CAPI UStringSearch * U_EXPORT2 usearch_open(const UChar    *pattern,
                                               int32_t         patternlength,
                                         const UChar          *text,
                                               int32_t         textlength,
@@ -307,11 +314,16 @@ U_STABLE UStringSearch * U_EXPORT2 usearch_open(const UChar          *pattern,
                                               UErrorCode     *status);
 
 /**
-* Creating a search iterator data struct using the argument collator language
+* Creates a String Search iterator data struct using the argument collator language
 * rule set. Note, user retains the ownership of this collator, thus the
 * responsibility of deletion lies with the user.
-* NOTE: string search cannot be instantiated from a collator that has
-* collate digits as numbers (CODAN) turned on.
+
+* NOTE: String Search cannot be instantiated from a collator that has
+* collate digits as numbers (CODAN) turned on (UCOL_NUMERIC_COLLATION).
+*
+* The UStringSearch retains a pointer to both the pattern and text strings.
+* The caller must not modify or delete them while using the UStringSearch.
+*
 * @param pattern for matching
 * @param patternlength length of the pattern, -1 for null-termination
 * @param text text string
@@ -320,9 +332,9 @@ U_STABLE UStringSearch * U_EXPORT2 usearch_open(const UChar          *pattern,
 * @param breakiter A BreakIterator that will be used to restrict the points
 *                  at which matches are detected. If a match is found, but
 *                  the match's start or end index is not a boundary as
-*                  determined by the <tt>BreakIterator</tt>, the match will
+*                  determined by the <code>BreakIterator</code>, the match will
 *                  be rejected and another will be searched for.
-*                  If this parameter is <tt>NULL</tt>, no break detection is
+*                  If this parameter is <code>NULL</code>, no break detection is
 *                  attempted.
 * @param status for errors if it occurs. If collator, pattern or text is NULL,
 *               or if patternlength or textlength is 0 then an
@@ -330,8 +342,8 @@ U_STABLE UStringSearch * U_EXPORT2 usearch_open(const UChar          *pattern,
 * @return search iterator data structure, or NULL if there is an error.
 * @stable ICU 2.4
 */
-U_STABLE UStringSearch * U_EXPORT2 usearch_openFromCollator(
-                                         const UChar *pattern,
+U_CAPI UStringSearch * U_EXPORT2 usearch_openFromCollator(
+                                         const UChar          *pattern,
                                                int32_t         patternlength,
                                          const UChar          *text,
                                                int32_t         textlength,
@@ -340,12 +352,12 @@ U_STABLE UStringSearch * U_EXPORT2 usearch_openFromCollator(
                                                UErrorCode     *status);
 
 /**
-* Destroying and cleaning up the search iterator data struct.
-* If a collator is created in <tt>usearch_open</tt>, it will be destroyed here.
-* @param searchiter data struct to clean up
-* @stable ICU 2.4
-*/
-U_STABLE void U_EXPORT2 usearch_close(UStringSearch *searchiter);
+ * Destroys and cleans up the String Search iterator data struct.
+ * If a collator was created in <code>usearch_open</code>, then it will be destroyed here.
+ * @param searchiter The UStringSearch to clean up
+ * @stable ICU 2.4
+ */
+U_CAPI void U_EXPORT2 usearch_close(UStringSearch *searchiter);
 
 #if U_SHOW_CPLUSPLUS_API
 
@@ -383,24 +395,24 @@ U_NAMESPACE_END
 * @param status error status if any.
 * @stable ICU 2.4
 */
-U_STABLE void U_EXPORT2 usearch_setOffset(UStringSearch *strsrch,
-                                        int32_t    position,
+U_CAPI void U_EXPORT2 usearch_setOffset(UStringSearch *strsrch,
+                                        int32_t        position,
                                         UErrorCode    *status);
 
 /**
 * Return the current index in the string text being searched.
 * If the iteration has gone past the end of the text (or past the beginning
-* for a backwards search), <tt>USEARCH_DONE</tt> is returned.
+* for a backwards search), <code>USEARCH_DONE</code> is returned.
 * @param strsrch search iterator data struct
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_getOffset(const UStringSearch *strsrch);
+U_CAPI int32_t U_EXPORT2 usearch_getOffset(const UStringSearch *strsrch);
 
 /**
 * Sets the text searching attributes located in the enum USearchAttribute
 * with values from the enum USearchAttributeValue.
-* <tt>USEARCH_DEFAULT</tt> can be used for all attributes for resetting.
+* <code>USEARCH_DEFAULT</code> can be used for all attributes for resetting.
 * @param strsrch search iterator data struct
 * @param attribute text attribute to be set
 * @param value text attribute value
@@ -408,7 +420,7 @@ U_STABLE int32_t U_EXPORT2 usearch_getOffset(const UStringSearch *strsrch);
 * @see #usearch_getAttribute
 * @stable ICU 2.4
 */
-U_STABLE void U_EXPORT2 usearch_setAttribute(UStringSearch         *strsrch,
+U_CAPI void U_EXPORT2 usearch_setAttribute(UStringSearch         *strsrch,
                                            USearchAttribute       attribute,
                                            USearchAttributeValue  value,
                                            UErrorCode            *status);
@@ -421,19 +433,19 @@ U_STABLE void U_EXPORT2 usearch_setAttribute(UStringSearch         *strsrch,
 * @see #usearch_setAttribute
 * @stable ICU 2.4
 */
-U_STABLE USearchAttributeValue U_EXPORT2 usearch_getAttribute(
+U_CAPI USearchAttributeValue U_EXPORT2 usearch_getAttribute(
                                          const UStringSearch    *strsrch,
                                                USearchAttribute  attribute);
 
 /**
 * Returns the index to the match in the text string that was searched.
 * This call returns a valid result only after a successful call to
-* <tt>usearch_first</tt>, <tt>usearch_next</tt>, <tt>usearch_previous</tt>,
-* or <tt>usearch_last</tt>.
+* <code>usearch_first</code>, <code>usearch_next</code>, <code>usearch_previous</code>,
+* or <code>usearch_last</code>.
 * Just after construction, or after a searching method returns
-* <tt>USEARCH_DONE</tt>, this method will return <tt>USEARCH_DONE</tt>.
+* <code>USEARCH_DONE</code>, this method will return <code>USEARCH_DONE</code>.
 * <p>
-* Use <tt>usearch_getMatchedLength</tt> to get the matched string length.
+* Use <code>usearch_getMatchedLength</code> to get the matched string length.
 * @param strsrch search iterator data struct
 * @return index to a substring within the text string that is being
 *         searched.
@@ -444,16 +456,16 @@ U_STABLE USearchAttributeValue U_EXPORT2 usearch_getAttribute(
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_getMatchedStart(
+U_CAPI int32_t U_EXPORT2 usearch_getMatchedStart(
                                                const UStringSearch *strsrch);
 
 /**
 * Returns the length of text in the string which matches the search pattern.
 * This call returns a valid result only after a successful call to
-* <tt>usearch_first</tt>, <tt>usearch_next</tt>, <tt>usearch_previous</tt>,
-* or <tt>usearch_last</tt>.
+* <code>usearch_first</code>, <code>usearch_next</code>, <code>usearch_previous</code>,
+* or <code>usearch_last</code>.
 * Just after construction, or after a searching method returns
-* <tt>USEARCH_DONE</tt>, this method will return 0.
+* <code>USEARCH_DONE</code>, this method will return 0.
 * @param strsrch search iterator data struct
 * @return The length of the match in the string text, or 0 if there is no
 *         match currently.
@@ -464,22 +476,22 @@ U_STABLE int32_t U_EXPORT2 usearch_getMatchedStart(
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_getMatchedLength(
+U_CAPI int32_t U_EXPORT2 usearch_getMatchedLength(
                                                const UStringSearch *strsrch);
 
 /**
 * Returns the text that was matched by the most recent call to
-* <tt>usearch_first</tt>, <tt>usearch_next</tt>, <tt>usearch_previous</tt>,
-* or <tt>usearch_last</tt>.
+* <code>usearch_first</code>, <code>usearch_next</code>, <code>usearch_previous</code>,
+* or <code>usearch_last</code>.
 * If the iterator is not pointing at a valid match (e.g. just after
-* construction or after <tt>USEARCH_DONE</tt> has been returned, returns
+* construction or after <code>USEARCH_DONE</code> has been returned, returns
 * an empty string. If result is not large enough to store the matched text,
 * result will be filled with the partial text and an U_BUFFER_OVERFLOW_ERROR
 * will be returned in status. result will be null-terminated whenever
 * possible. If the buffer fits the matched text exactly, a null-termination
 * is not possible, then a U_STRING_NOT_TERMINATED_ERROR set in status.
 * Pre-flighting can be either done with length = 0 or the API
-* <tt>usearch_getMatchedLength</tt>.
+* <code>usearch_getMatchedLength</code>.
 * @param strsrch search iterator data struct
 * @param result UChar buffer to store the matched string
 * @param resultCapacity length of the result buffer
@@ -492,7 +504,7 @@ U_STABLE int32_t U_EXPORT2 usearch_getMatchedLength(
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_getMatchedText(const UStringSearch *strsrch,
+U_CAPI int32_t U_EXPORT2 usearch_getMatchedText(const UStringSearch *strsrch,
                                             UChar         *result,
                                             int32_t        resultCapacity,
                                             UErrorCode    *status);
@@ -506,30 +518,30 @@ U_STABLE int32_t U_EXPORT2 usearch_getMatchedText(const UStringSearch *strsrch,
 * @param breakiter A BreakIterator that will be used to restrict the points
 *                  at which matches are detected. If a match is found, but
 *                  the match's start or end index is not a boundary as
-*                  determined by the <tt>BreakIterator</tt>, the match will
+*                  determined by the <code>BreakIterator</code>, the match will
 *                  be rejected and another will be searched for.
-*                  If this parameter is <tt>NULL</tt>, no break detection is
+*                  If this parameter is <code>NULL</code>, no break detection is
 *                  attempted.
 * @param status for errors if it occurs
 * @see #usearch_getBreakIterator
 * @stable ICU 2.4
 */
-U_STABLE void U_EXPORT2 usearch_setBreakIterator(UStringSearch  *strsrch,
+U_CAPI void U_EXPORT2 usearch_setBreakIterator(UStringSearch  *strsrch,
                                                UBreakIterator *breakiter,
                                                UErrorCode     *status);
 
 /**
 * Returns the BreakIterator that is used to restrict the points at which
 * matches are detected. This will be the same object that was passed to the
-* constructor or to <tt>usearch_setBreakIterator</tt>. Note that
-* <tt>NULL</tt>
+* constructor or to <code>usearch_setBreakIterator</code>. Note that
+* <code>NULL</code>
 * is a legal value; it means that break detection should not be attempted.
 * @param strsrch search iterator data struct
 * @return break iterator used
 * @see #usearch_setBreakIterator
 * @stable ICU 2.4
 */
-U_STABLE const UBreakIterator * U_EXPORT2 usearch_getBreakIterator(
+U_CAPI const UBreakIterator * U_EXPORT2 usearch_getBreakIterator(
                                               const UStringSearch *strsrch);
 
 #endif
@@ -538,6 +550,10 @@ U_STABLE const UBreakIterator * U_EXPORT2 usearch_getBreakIterator(
 * Set the string text to be searched. Text iteration will hence begin at the
 * start of the text string. This method is useful if you want to re-use an
 * iterator to search for the same pattern within a different body of text.
+*
+* The UStringSearch retains a pointer to the text string. The caller must not
+* modify or delete the string while using the UStringSearch.
+*
 * @param strsrch search iterator data struct
 * @param text new string to look for match
 * @param textlength length of the new string, -1 for null-termination
@@ -547,7 +563,7 @@ U_STABLE const UBreakIterator * U_EXPORT2 usearch_getBreakIterator(
 * @see #usearch_getText
 * @stable ICU 2.4
 */
-U_STABLE void U_EXPORT2 usearch_setText(      UStringSearch *strsrch,
+U_CAPI void U_EXPORT2 usearch_setText(      UStringSearch *strsrch,
                                       const UChar         *text,
                                             int32_t        textlength,
                                             UErrorCode    *status);
@@ -560,20 +576,20 @@ U_STABLE void U_EXPORT2 usearch_setText(      UStringSearch *strsrch,
 * @see #usearch_setText
 * @stable ICU 2.4
 */
-U_STABLE const UChar * U_EXPORT2 usearch_getText(const UStringSearch *strsrch,
+U_CAPI const UChar * U_EXPORT2 usearch_getText(const UStringSearch *strsrch,
                                                int32_t       *length);
 
 /**
 * Gets the collator used for the language rules.
 * <p>
-* Deleting the returned <tt>UCollator</tt> before calling
-* <tt>usearch_close</tt> would cause the string search to fail.
-* <tt>usearch_close</tt> will delete the collator if this search owns it.
+* Deleting the returned <code>UCollator</code> before calling
+* <code>usearch_close</code> would cause the string search to fail.
+* <code>usearch_close</code> will delete the collator if this search owns it.
 * @param strsrch search iterator data struct
 * @return collator
 * @stable ICU 2.4
 */
-U_STABLE UCollator * U_EXPORT2 usearch_getCollator(
+U_CAPI UCollator * U_EXPORT2 usearch_getCollator(
                                                const UStringSearch *strsrch);
 
 /**
@@ -586,7 +602,7 @@ U_STABLE UCollator * U_EXPORT2 usearch_getCollator(
 * @param status for errors if it occurs
 * @stable ICU 2.4
 */
-U_STABLE void U_EXPORT2 usearch_setCollator(      UStringSearch *strsrch,
+U_CAPI void U_EXPORT2 usearch_setCollator(      UStringSearch *strsrch,
                                           const UCollator     *collator,
                                                 UErrorCode    *status);
 
@@ -594,6 +610,10 @@ U_STABLE void U_EXPORT2 usearch_setCollator(      UStringSearch *strsrch,
 * Sets the pattern used for matching.
 * Internal data like the Boyer Moore table will be recalculated, but the
 * iterator's position is unchanged.
+*
+* The UStringSearch retains a pointer to the pattern string. The caller must not
+* modify or delete the string while using the UStringSearch.
+*
 * @param strsrch search iterator data struct
 * @param pattern string
 * @param patternlength pattern length, -1 for null-terminated string
@@ -602,7 +622,7 @@ U_STABLE void U_EXPORT2 usearch_setCollator(      UStringSearch *strsrch,
 *               done to strsrch.
 * @stable ICU 2.4
 */
-U_STABLE void U_EXPORT2 usearch_setPattern(      UStringSearch *strsrch,
+U_CAPI void U_EXPORT2 usearch_setPattern(      UStringSearch *strsrch,
                                          const UChar         *pattern,
                                                int32_t        patternlength,
                                                UErrorCode    *status);
@@ -615,7 +635,7 @@ U_STABLE void U_EXPORT2 usearch_setPattern(      UStringSearch *strsrch,
 * @return pattern string
 * @stable ICU 2.4
 */
-U_STABLE const UChar * U_EXPORT2 usearch_getPattern(
+U_CAPI const UChar * U_EXPORT2 usearch_getPattern(
                                                const UStringSearch *strsrch,
                                                      int32_t       *length);
 
@@ -625,28 +645,28 @@ U_STABLE const UChar * U_EXPORT2 usearch_getPattern(
 * Returns the first index at which the string text matches the search
 * pattern.
 * The iterator is adjusted so that its current index (as returned by
-* <tt>usearch_getOffset</tt>) is the match position if one was found.
-* If a match is not found, <tt>USEARCH_DONE</tt> will be returned and
-* the iterator will be adjusted to the index <tt>USEARCH_DONE</tt>.
+* <code>usearch_getOffset</code>) is the match position if one was found.
+* If a match is not found, <code>USEARCH_DONE</code> will be returned and
+* the iterator will be adjusted to the index <code>USEARCH_DONE</code>.
 * @param strsrch search iterator data struct
 * @param status for errors if it occurs
 * @return The character index of the first match, or
-* <tt>USEARCH_DONE</tt> if there are no matches.
+* <code>USEARCH_DONE</code> if there are no matches.
 * @see #usearch_getOffset
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_first(UStringSearch *strsrch,
+U_CAPI int32_t U_EXPORT2 usearch_first(UStringSearch *strsrch,
                                            UErrorCode    *status);
 
 /**
-* Returns the first index equal or greater than <tt>position</tt> at which
+* Returns the first index equal or greater than <code>position</code> at which
 * the string text
 * matches the search pattern. The iterator is adjusted so that its current
-* index (as returned by <tt>usearch_getOffset</tt>) is the match position if
+* index (as returned by <code>usearch_getOffset</code>) is the match position if
 * one was found.
-* If a match is not found, <tt>USEARCH_DONE</tt> will be returned and
-* the iterator will be adjusted to the index <tt>USEARCH_DONE</tt>
+* If a match is not found, <code>USEARCH_DONE</code> will be returned and
+* the iterator will be adjusted to the index <code>USEARCH_DONE</code>
 * <p>
 * Search positions that may render incorrect results are highlighted in the
 * header comments. If position is less than or greater than the text range
@@ -654,60 +674,60 @@ U_STABLE int32_t U_EXPORT2 usearch_first(UStringSearch *strsrch,
 * @param strsrch search iterator data struct
 * @param position to start the search at
 * @param status for errors if it occurs
-* @return The character index of the first match following <tt>pos</tt>,
-*         or <tt>USEARCH_DONE</tt> if there are no matches.
+* @return The character index of the first match following <code>pos</code>,
+*         or <code>USEARCH_DONE</code> if there are no matches.
 * @see #usearch_getOffset
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_following(UStringSearch *strsrch,
+U_CAPI int32_t U_EXPORT2 usearch_following(UStringSearch *strsrch,
                                                int32_t    position,
                                                UErrorCode    *status);
 
 /**
 * Returns the last index in the target text at which it matches the search
 * pattern. The iterator is adjusted so that its current
-* index (as returned by <tt>usearch_getOffset</tt>) is the match position if
+* index (as returned by <code>usearch_getOffset</code>) is the match position if
 * one was found.
-* If a match is not found, <tt>USEARCH_DONE</tt> will be returned and
-* the iterator will be adjusted to the index <tt>USEARCH_DONE</tt>.
+* If a match is not found, <code>USEARCH_DONE</code> will be returned and
+* the iterator will be adjusted to the index <code>USEARCH_DONE</code>.
 * @param strsrch search iterator data struct
 * @param status for errors if it occurs
-* @return The index of the first match, or <tt>USEARCH_DONE</tt> if there
+* @return The index of the first match, or <code>USEARCH_DONE</code> if there
 *         are no matches.
 * @see #usearch_getOffset
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_last(UStringSearch *strsrch,
+U_CAPI int32_t U_EXPORT2 usearch_last(UStringSearch *strsrch,
                                           UErrorCode    *status);
 
 /**
-* Returns the first index less than <tt>position</tt> at which the string text
+* Returns the first index less than <code>position</code> at which the string text
 * matches the search pattern. The iterator is adjusted so that its current
-* index (as returned by <tt>usearch_getOffset</tt>) is the match position if
+* index (as returned by <code>usearch_getOffset</code>) is the match position if
 * one was found.
-* If a match is not found, <tt>USEARCH_DONE</tt> will be returned and
-* the iterator will be adjusted to the index <tt>USEARCH_DONE</tt>
+* If a match is not found, <code>USEARCH_DONE</code> will be returned and
+* the iterator will be adjusted to the index <code>USEARCH_DONE</code>
 * <p>
 * Search positions that may render incorrect results are highlighted in the
 * header comments. If position is less than or greater than the text range
 * for searching, an U_INDEX_OUTOFBOUNDS_ERROR will be returned.
 * <p>
-* When <tt>USEARCH_OVERLAP</tt> option is off, the last index of the
-* result match is always less than <tt>position</tt>.
-* When <tt>USERARCH_OVERLAP</tt> is on, the result match may span across
-* <tt>position</tt>.
+* When <code>USEARCH_OVERLAP</code> option is off, the last index of the
+* result match is always less than <code>position</code>.
+* When <code>USERARCH_OVERLAP</code> is on, the result match may span across
+* <code>position</code>.
 * @param strsrch search iterator data struct
 * @param position index position the search is to begin at
 * @param status for errors if it occurs
-* @return The character index of the first match preceding <tt>pos</tt>,
-*         or <tt>USEARCH_DONE</tt> if there are no matches.
+* @return The character index of the first match preceding <code>pos</code>,
+*         or <code>USEARCH_DONE</code> if there are no matches.
 * @see #usearch_getOffset
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_preceding(UStringSearch *strsrch,
+U_CAPI int32_t U_EXPORT2 usearch_preceding(UStringSearch *strsrch,
                                                int32_t    position,
                                                UErrorCode    *status);
 
@@ -715,40 +735,40 @@ U_STABLE int32_t U_EXPORT2 usearch_preceding(UStringSearch *strsrch,
 * Returns the index of the next point at which the string text matches the
 * search pattern, starting from the current position.
 * The iterator is adjusted so that its current
-* index (as returned by <tt>usearch_getOffset</tt>) is the match position if
+* index (as returned by <code>usearch_getOffset</code>) is the match position if
 * one was found.
-* If a match is not found, <tt>USEARCH_DONE</tt> will be returned and
-* the iterator will be adjusted to the index <tt>USEARCH_DONE</tt>
+* If a match is not found, <code>USEARCH_DONE</code> will be returned and
+* the iterator will be adjusted to the index <code>USEARCH_DONE</code>
 * @param strsrch search iterator data struct
 * @param status for errors if it occurs
 * @return The index of the next match after the current position, or
-*         <tt>USEARCH_DONE</tt> if there are no more matches.
+*         <code>USEARCH_DONE</code> if there are no more matches.
 * @see #usearch_first
 * @see #usearch_getOffset
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_next(UStringSearch *strsrch,
+U_CAPI int32_t U_EXPORT2 usearch_next(UStringSearch *strsrch,
                                           UErrorCode    *status);
 
 /**
 * Returns the index of the previous point at which the string text matches
 * the search pattern, starting at the current position.
 * The iterator is adjusted so that its current
-* index (as returned by <tt>usearch_getOffset</tt>) is the match position if
+* index (as returned by <code>usearch_getOffset</code>) is the match position if
 * one was found.
-* If a match is not found, <tt>USEARCH_DONE</tt> will be returned and
-* the iterator will be adjusted to the index <tt>USEARCH_DONE</tt>
+* If a match is not found, <code>USEARCH_DONE</code> will be returned and
+* the iterator will be adjusted to the index <code>USEARCH_DONE</code>
 * @param strsrch search iterator data struct
 * @param status for errors if it occurs
 * @return The index of the previous match before the current position,
-*         or <tt>USEARCH_DONE</tt> if there are no more matches.
+*         or <code>USEARCH_DONE</code> if there are no more matches.
 * @see #usearch_last
 * @see #usearch_getOffset
 * @see #USEARCH_DONE
 * @stable ICU 2.4
 */
-U_STABLE int32_t U_EXPORT2 usearch_previous(UStringSearch *strsrch,
+U_CAPI int32_t U_EXPORT2 usearch_previous(UStringSearch *strsrch,
                                               UErrorCode    *status);
 
 /**
@@ -761,7 +781,7 @@ U_STABLE int32_t U_EXPORT2 usearch_previous(UStringSearch *strsrch,
 * @see #usearch_first
 * @stable ICU 2.4
 */
-U_STABLE void U_EXPORT2 usearch_reset(UStringSearch *strsrch);
+U_CAPI void U_EXPORT2 usearch_reset(UStringSearch *strsrch);
 
 #ifndef U_HIDE_INTERNAL_API
 /**
@@ -814,11 +834,11 @@ U_STABLE void U_EXPORT2 usearch_reset(UStringSearch *strsrch);
   *                    A value of -1 will be returned if no match was found.
   *
   *  @param status     Report any errors.  Note that no match found is not an error.
-  *  @return           TRUE if a match was found, FALSE otherwise.
+  *  @return           true if a match was found, false otherwise.
   *
   *  @internal
   */
-U_INTERNAL UBool U_EXPORT2 usearch_search(UStringSearch *strsrch,
+U_CAPI UBool U_EXPORT2 usearch_search(UStringSearch *strsrch,
                                           int32_t        startIdx,
                                           int32_t        *matchStart,
                                           int32_t        *matchLimit,
@@ -874,11 +894,11 @@ U_INTERNAL UBool U_EXPORT2 usearch_search(UStringSearch *strsrch,
   *                    A value of -1 will be returned if no match was found.
   *
   *  @param status     Report any errors.  Note that no match found is not an error.
-  *  @return           TRUE if a match was found, FALSE otherwise.
+  *  @return           true if a match was found, false otherwise.
   *
   *  @internal
   */
-U_INTERNAL UBool U_EXPORT2 usearch_searchBackwards(UStringSearch *strsrch,
+U_CAPI UBool U_EXPORT2 usearch_searchBackwards(UStringSearch *strsrch,
                                                    int32_t        startIdx,
                                                    int32_t        *matchStart,
                                                    int32_t        *matchLimit,
diff --git a/deps/icu-small/source/i18n/unicode/uspoof.h b/deps/icu-small/source/i18n/unicode/uspoof.h
index 63a13387b063be27bff286090c17f99063f40152..bf675bef51b51cdd59088fad69ac6bc7f063013b 100644
--- a/deps/icu-small/source/i18n/unicode/uspoof.h
+++ b/deps/icu-small/source/i18n/unicode/uspoof.h
@@ -22,12 +22,12 @@
 #include "unicode/utypes.h"
 #include "unicode/uset.h"
 #include "unicode/parseerr.h"
-#include "unicode/localpointer.h"
 
 #if !UCONFIG_NO_NORMALIZATION
 
 
 #if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
 #include "unicode/unistr.h"
 #include "unicode/uniset.h"
 #endif
@@ -154,10 +154,10 @@
  *     UChar* skel = (UChar*) malloc(++len * sizeof(UChar));
  *     status = U_ZERO_ERROR;
  *     uspoof_getSkeleton(sc, 0, str, -1, skel, len, &status);
- *     UBool result = FALSE;
+ *     UBool result = false;
  *     for (size_t i=0; i<DICTIONARY_LENGTH; i++) {
  *         result = u_strcmp(skel, skeletons[i]) == 0;
- *         if (result == TRUE) { break; }
+ *         if (result == true) { break; }
  *     }
  *     // Has confusable in dictionary: 1 (status: U_ZERO_ERROR)
  *     printf("Has confusable in dictionary: %d (status: %s)\n", result, u_errorName(status));
@@ -502,7 +502,7 @@ typedef enum USpoofChecks {
     USPOOF_ALL_CHECKS               = 0xFFFF,
 
     /**
-      * Enable the return of auxillary (non-error) information in the
+      * Enable the return of auxiliary (non-error) information in the
       * upper bits of the check results value.
       *
       * If this "check" is not enabled, the results of {@link uspoof_check} will be
@@ -601,7 +601,7 @@ typedef enum USpoofChecks {
  *  @return        the newly created Spoof Checker
  *  @stable ICU 4.2
  */
-U_STABLE USpoofChecker * U_EXPORT2
+U_CAPI USpoofChecker * U_EXPORT2
 uspoof_open(UErrorCode *status);
 
 
@@ -626,7 +626,7 @@ uspoof_open(UErrorCode *status);
  * @see uspoof_serialize
  * @stable ICU 4.2
  */
-U_STABLE USpoofChecker * U_EXPORT2
+U_CAPI USpoofChecker * U_EXPORT2
 uspoof_openFromSerialized(const void *data, int32_t length, int32_t *pActualLength,
                           UErrorCode *pErrorCode);
 
@@ -660,7 +660,7 @@ uspoof_openFromSerialized(const void *data, int32_t length, int32_t *pActualLeng
   * @return            A spoof checker that uses the rules from the input files.
   * @stable ICU 4.2
   */
-U_STABLE USpoofChecker * U_EXPORT2
+U_CAPI USpoofChecker * U_EXPORT2
 uspoof_openFromSource(const char *confusables,  int32_t confusablesLen,
                       const char *confusablesWholeScript, int32_t confusablesWholeScriptLen,
                       int32_t *errType, UParseError *pe, UErrorCode *status);
@@ -671,7 +671,7 @@ uspoof_openFromSource(const char *confusables,  int32_t confusablesLen,
   *   its implementation.
   * @stable ICU 4.2
   */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uspoof_close(USpoofChecker *sc);
 
 /**
@@ -683,7 +683,7 @@ uspoof_close(USpoofChecker *sc);
  * @return
  * @stable ICU 4.2
  */
-U_STABLE USpoofChecker * U_EXPORT2
+U_CAPI USpoofChecker * U_EXPORT2
 uspoof_clone(const USpoofChecker *sc, UErrorCode *status);
 
 
@@ -691,8 +691,10 @@ uspoof_clone(const USpoofChecker *sc, UErrorCode *status);
  * Specify the bitmask of checks that will be performed by {@link uspoof_check}. Calling this method
  * overwrites any checks that may have already been enabled. By default, all checks are enabled.
  *
- * To enable specific checks and disable all others, the "whitelisted" checks should be ORed together. For
- * example, to fail strings containing characters outside of the set specified by {@link uspoof_setAllowedChars} and
+ * To enable specific checks and disable all others,
+ * OR together only the bit constants for the desired checks.
+ * For example, to fail strings containing characters outside of
+ * the set specified by {@link uspoof_setAllowedChars} and
  * also strings that contain digits from mixed numbering systems:
  *
  * <pre>
@@ -701,8 +703,9 @@ uspoof_clone(const USpoofChecker *sc, UErrorCode *status);
  * }
  * </pre>
  *
- * To disable specific checks and enable all others, the "blacklisted" checks should be ANDed away from
- * ALL_CHECKS. For example, if you are not planning to use the {@link uspoof_areConfusable} functionality,
+ * To disable specific checks and enable all others,
+ * start with ALL_CHECKS and "AND away" the not-desired checks.
+ * For example, if you are not planning to use the {@link uspoof_areConfusable} functionality,
  * it is good practice to disable the CONFUSABLE check:
  *
  * <pre>
@@ -724,7 +727,7 @@ uspoof_clone(const USpoofChecker *sc, UErrorCode *status);
  * @stable ICU 4.2
  *
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uspoof_setChecks(USpoofChecker *sc, int32_t checks, UErrorCode *status);
 
 /**
@@ -738,7 +741,7 @@ uspoof_setChecks(USpoofChecker *sc, int32_t checks, UErrorCode *status);
  * @stable ICU 4.2
  *
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_getChecks(const USpoofChecker *sc, UErrorCode *status);
 
 /**
@@ -752,7 +755,7 @@ uspoof_getChecks(const USpoofChecker *sc, UErrorCode *status);
  * @see URestrictionLevel
  * @stable ICU 51
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uspoof_setRestrictionLevel(USpoofChecker *sc, URestrictionLevel restrictionLevel);
 
 
@@ -763,7 +766,7 @@ uspoof_setRestrictionLevel(USpoofChecker *sc, URestrictionLevel restrictionLevel
   * @see URestrictionLevel
   * @stable ICU 51
   */
-U_STABLE URestrictionLevel U_EXPORT2
+U_CAPI URestrictionLevel U_EXPORT2
 uspoof_getRestrictionLevel(const USpoofChecker *sc);
 
 /**
@@ -808,7 +811,7 @@ uspoof_getRestrictionLevel(const USpoofChecker *sc);
  * @param status       The error code, set if this function encounters a problem.
  * @stable ICU 4.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uspoof_setAllowedLocales(USpoofChecker *sc, const char *localesList, UErrorCode *status);
 
 /**
@@ -832,7 +835,7 @@ uspoof_setAllowedLocales(USpoofChecker *sc, const char *localesList, UErrorCode
  *
  * @stable ICU 4.2
  */
-U_STABLE const char * U_EXPORT2
+U_CAPI const char * U_EXPORT2
 uspoof_getAllowedLocales(USpoofChecker *sc, UErrorCode *status);
 
 
@@ -854,7 +857,7 @@ uspoof_getAllowedLocales(USpoofChecker *sc, UErrorCode *status);
  * @param status   The error code, set if this function encounters a problem.
  * @stable ICU 4.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uspoof_setAllowedChars(USpoofChecker *sc, const USet *chars, UErrorCode *status);
 
 
@@ -878,7 +881,7 @@ uspoof_setAllowedChars(USpoofChecker *sc, const USet *chars, UErrorCode *status)
  *                 the USPOOF_CHAR_LIMIT test.
  * @stable ICU 4.2
  */
-U_STABLE const USet * U_EXPORT2
+U_CAPI const USet * U_EXPORT2
 uspoof_getAllowedChars(const USpoofChecker *sc, UErrorCode *status);
 
 
@@ -914,7 +917,7 @@ uspoof_getAllowedChars(const USpoofChecker *sc, UErrorCode *status);
  * @see uspoof_check2
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_check(const USpoofChecker *sc,
                          const UChar *id, int32_t length,
                          int32_t *position,
@@ -953,7 +956,7 @@ uspoof_check(const USpoofChecker *sc,
  * @see uspoof_check2UTF8
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_checkUTF8(const USpoofChecker *sc,
                  const char *id, int32_t length,
                  int32_t *position,
@@ -988,7 +991,7 @@ uspoof_checkUTF8(const USpoofChecker *sc,
  * @see uspoof_check2UnicodeString
  * @stable ICU 58
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_check2(const USpoofChecker *sc,
     const UChar* id, int32_t length,
     USpoofCheckResult* checkResult,
@@ -1025,7 +1028,7 @@ uspoof_check2(const USpoofChecker *sc,
  * @see uspoof_check2UnicodeString
  * @stable ICU 58
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_check2UTF8(const USpoofChecker *sc,
     const char *id, int32_t length,
     USpoofCheckResult* checkResult,
@@ -1049,7 +1052,7 @@ uspoof_check2UTF8(const USpoofChecker *sc,
  * @see uspoof_check2UnicodeString
  * @stable ICU 58
  */
-U_STABLE USpoofCheckResult* U_EXPORT2
+U_CAPI USpoofCheckResult* U_EXPORT2
 uspoof_openCheckResult(UErrorCode *status);
 
 /**
@@ -1059,7 +1062,7 @@ uspoof_openCheckResult(UErrorCode *status);
  * @param checkResult  The instance of USpoofCheckResult to close
  * @stable ICU 58
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uspoof_closeCheckResult(USpoofCheckResult *checkResult);
 
 /**
@@ -1076,7 +1079,7 @@ uspoof_closeCheckResult(USpoofCheckResult *checkResult);
  * @see uspoof_setChecks
  * @stable ICU 58
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_getCheckResultChecks(const USpoofCheckResult *checkResult, UErrorCode *status);
 
 /**
@@ -1089,7 +1092,7 @@ uspoof_getCheckResultChecks(const USpoofCheckResult *checkResult, UErrorCode *st
  * @see uspoof_setRestrictionLevel
  * @stable ICU 58
  */
-U_STABLE URestrictionLevel U_EXPORT2
+U_CAPI URestrictionLevel U_EXPORT2
 uspoof_getCheckResultRestrictionLevel(const USpoofCheckResult *checkResult, UErrorCode *status);
 
 /**
@@ -1103,7 +1106,7 @@ uspoof_getCheckResultRestrictionLevel(const USpoofCheckResult *checkResult, UErr
  * @param status       The error code, set if an error occurred.
  * @stable ICU 58
  */
-U_STABLE const USet* U_EXPORT2
+U_CAPI const USet* U_EXPORT2
 uspoof_getCheckResultNumerics(const USpoofCheckResult *checkResult, UErrorCode *status);
 
 
@@ -1150,7 +1153,7 @@ uspoof_getCheckResultNumerics(const USpoofCheckResult *checkResult, UErrorCode *
  *
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_areConfusable(const USpoofChecker *sc,
                      const UChar *id1, int32_t length1,
                      const UChar *id2, int32_t length2,
@@ -1183,7 +1186,7 @@ uspoof_areConfusable(const USpoofChecker *sc,
  *
  * @see uspoof_areConfusable
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_areConfusableUTF8(const USpoofChecker *sc,
                          const char *id1, int32_t length1,
                          const char *id2, int32_t length2,
@@ -1223,7 +1226,7 @@ uspoof_areConfusableUTF8(const USpoofChecker *sc,
  * @stable ICU 4.2
  * @see uspoof_areConfusable
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_getSkeleton(const USpoofChecker *sc,
                    uint32_t type,
                    const UChar *id,  int32_t length,
@@ -1263,7 +1266,7 @@ uspoof_getSkeleton(const USpoofChecker *sc,
  *
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_getSkeletonUTF8(const USpoofChecker *sc,
                        uint32_t type,
                        const char *id,  int32_t length,
@@ -1282,7 +1285,7 @@ uspoof_getSkeletonUTF8(const USpoofChecker *sc,
   *
   * @stable ICU 51
   */
-U_STABLE const USet * U_EXPORT2
+U_CAPI const USet * U_EXPORT2
 uspoof_getInclusionSet(UErrorCode *status);
 
 /**
@@ -1297,7 +1300,7 @@ uspoof_getInclusionSet(UErrorCode *status);
   *
   * @stable ICU 51
   */
-U_STABLE const USet * U_EXPORT2
+U_CAPI const USet * U_EXPORT2
 uspoof_getRecommendedSet(UErrorCode *status);
 
 /**
@@ -1322,7 +1325,7 @@ uspoof_getRecommendedSet(UErrorCode *status);
  * @see utrie2_openFromSerialized()
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_serialize(USpoofChecker *sc,
                  void *data, int32_t capacity,
                  UErrorCode *status);
@@ -1388,7 +1391,7 @@ U_NAMESPACE_END
  * @param status   The error code, set if this function encounters a problem.
  * @stable ICU 4.2
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 uspoof_setAllowedUnicodeSet(USpoofChecker *sc, const icu::UnicodeSet *chars, UErrorCode *status);
 
 
@@ -1412,7 +1415,7 @@ uspoof_setAllowedUnicodeSet(USpoofChecker *sc, const icu::UnicodeSet *chars, UEr
  *                 the USPOOF_CHAR_LIMIT test.
  * @stable ICU 4.2
  */
-U_STABLE const icu::UnicodeSet * U_EXPORT2
+U_CAPI const icu::UnicodeSet * U_EXPORT2
 uspoof_getAllowedUnicodeSet(const USpoofChecker *sc, UErrorCode *status);
 
 /**
@@ -1443,7 +1446,7 @@ uspoof_getAllowedUnicodeSet(const USpoofChecker *sc, UErrorCode *status);
  * @see uspoof_check2UnicodeString
  * @stable ICU 4.2
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_checkUnicodeString(const USpoofChecker *sc,
                           const icu::UnicodeString &id,
                           int32_t *position,
@@ -1474,7 +1477,7 @@ uspoof_checkUnicodeString(const USpoofChecker *sc,
  * @see uspoof_check2UTF8
  * @stable ICU 58
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_check2UnicodeString(const USpoofChecker *sc,
     const icu::UnicodeString &id,
     USpoofCheckResult* checkResult,
@@ -1501,7 +1504,7 @@ uspoof_check2UnicodeString(const USpoofChecker *sc,
  *
  * @see uspoof_areConfusable
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 uspoof_areConfusableUnicodeString(const USpoofChecker *sc,
                                   const icu::UnicodeString &s1,
                                   const icu::UnicodeString &s2,
@@ -1549,7 +1552,7 @@ uspoof_getSkeletonUnicodeString(const USpoofChecker *sc,
   *
   * @stable ICU 51
   */
-U_STABLE const icu::UnicodeSet * U_EXPORT2
+U_CAPI const icu::UnicodeSet * U_EXPORT2
 uspoof_getInclusionUnicodeSet(UErrorCode *status);
 
 /**
@@ -1564,7 +1567,7 @@ uspoof_getInclusionUnicodeSet(UErrorCode *status);
   *
   * @stable ICU 51
   */
-U_STABLE const icu::UnicodeSet * U_EXPORT2
+U_CAPI const icu::UnicodeSet * U_EXPORT2
 uspoof_getRecommendedUnicodeSet(UErrorCode *status);
 
 #endif /* U_SHOW_CPLUSPLUS_API */
diff --git a/deps/icu-small/source/i18n/unicode/utmscale.h b/deps/icu-small/source/i18n/unicode/utmscale.h
index 2392c6414e4f8b316ac8b0d98d1a5f62b766a082..b7dca15367dcfe9dcd3aefc8cb13b01f11df8fa6 100644
--- a/deps/icu-small/source/i18n/unicode/utmscale.h
+++ b/deps/icu-small/source/i18n/unicode/utmscale.h
@@ -449,7 +449,7 @@ typedef enum UTimeScaleValue {
  *
  * @stable ICU 3.2
  */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
     utmscale_getTimeScaleValue(UDateTimeScale timeScale, UTimeScaleValue value, UErrorCode *status);
 
 /* Conversion to 'universal time scale' */
@@ -465,7 +465,7 @@ U_STABLE int64_t U_EXPORT2
  *
  * @stable ICU 3.2
  */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
     utmscale_fromInt64(int64_t otherTime, UDateTimeScale timeScale, UErrorCode *status);
 
 /* Conversion from 'universal time scale' */
@@ -481,7 +481,7 @@ U_STABLE int64_t U_EXPORT2
  *
  * @stable ICU 3.2
  */
-U_STABLE int64_t U_EXPORT2
+U_CAPI int64_t U_EXPORT2
     utmscale_toInt64(int64_t universalTime, UDateTimeScale timeScale, UErrorCode *status);
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/unicode/utrans.h b/deps/icu-small/source/i18n/unicode/utrans.h
index 56640eda967cbe18e1cf382400f38676c5b07070..e959378285cfb887e99690c5ed3c00e34961878d 100644
--- a/deps/icu-small/source/i18n/unicode/utrans.h
+++ b/deps/icu-small/source/i18n/unicode/utrans.h
@@ -17,12 +17,15 @@
 
 #if !UCONFIG_NO_TRANSLITERATION
 
-#include "unicode/localpointer.h"
 #include "unicode/urep.h"
 #include "unicode/parseerr.h"
 #include "unicode/uenum.h"
 #include "unicode/uset.h"
 
+#if U_SHOW_CPLUSPLUS_API
+#include "unicode/localpointer.h"
+#endif   // U_SHOW_CPLUSPLUS_API
+
 /********************************************************************
  * General Notes
  ********************************************************************
@@ -188,7 +191,7 @@ typedef struct UTransPosition {
  *         utrans_xxx() functions, or NULL if the open call fails.
  * @stable ICU 2.8
  */
-U_STABLE UTransliterator* U_EXPORT2
+U_CAPI UTransliterator* U_EXPORT2
 utrans_openU(const UChar *id,
              int32_t idLength,
              UTransDirection dir,
@@ -212,7 +215,7 @@ utrans_openU(const UChar *id,
  * inverse of trans, or NULL if the open call fails.
  * @stable ICU 2.0
  */
-U_STABLE UTransliterator* U_EXPORT2
+U_CAPI UTransliterator* U_EXPORT2
 utrans_openInverse(const UTransliterator* trans,
                    UErrorCode* status);
 
@@ -226,7 +229,7 @@ utrans_openInverse(const UTransliterator* trans,
  * utrans_xxx() functions, or NULL if the clone call fails.
  * @stable ICU 2.0
  */
-U_STABLE UTransliterator* U_EXPORT2
+U_CAPI UTransliterator* U_EXPORT2
 utrans_clone(const UTransliterator* trans,
              UErrorCode* status);
 
@@ -236,7 +239,7 @@ utrans_clone(const UTransliterator* trans,
  * @param trans the transliterator to be closed.
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrans_close(UTransliterator* trans);
 
 #if U_SHOW_CPLUSPLUS_API
@@ -272,7 +275,7 @@ U_NAMESPACE_END
  *
  * @stable ICU 2.8
  */
-U_STABLE const UChar * U_EXPORT2
+U_CAPI const UChar * U_EXPORT2
 utrans_getUnicodeID(const UTransliterator *trans,
                     int32_t *resultLength);
 
@@ -290,7 +293,7 @@ utrans_getUnicodeID(const UTransliterator *trans,
  * @param status a pointer to the UErrorCode
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrans_register(UTransliterator* adoptedTrans,
                 UErrorCode* status);
 
@@ -303,7 +306,7 @@ utrans_register(UTransliterator* adoptedTrans,
  * @param idLength the length of id, or -1 if id is zero-terminated
  * @stable ICU 2.8
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrans_unregisterID(const UChar* id, int32_t idLength);
 
 /**
@@ -324,7 +327,7 @@ utrans_unregisterID(const UChar* id, int32_t idLength);
  * @see UnicodeSet
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrans_setFilter(UTransliterator* trans,
                  const UChar* filterPattern,
                  int32_t filterPatternLen,
@@ -337,7 +340,7 @@ utrans_setFilter(UTransliterator* trans,
  * @return the number of system transliterators.
  * @stable ICU 2.0
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utrans_countAvailableIDs(void);
 
 /**
@@ -349,7 +352,7 @@ utrans_countAvailableIDs(void);
  *
  * @stable ICU 2.8
  */
-U_STABLE UEnumeration * U_EXPORT2
+U_CAPI UEnumeration * U_EXPORT2
 utrans_openIDs(UErrorCode *pErrorCode);
 
 /********************************************************************
@@ -379,7 +382,7 @@ utrans_openIDs(UErrorCode *pErrorCode);
  * @param status a pointer to the UErrorCode
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrans_trans(const UTransliterator* trans,
              UReplaceable* rep,
              const UReplaceableCallbacks* repFunc,
@@ -430,7 +433,7 @@ utrans_trans(const UTransliterator* trans,
  * @param status a pointer to the UErrorCode
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrans_transIncremental(const UTransliterator* trans,
                         UReplaceable* rep,
                         const UReplaceableCallbacks* repFunc,
@@ -467,7 +470,7 @@ utrans_transIncremental(const UTransliterator* trans,
  * @param status a pointer to the UErrorCode
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrans_transUChars(const UTransliterator* trans,
                    UChar* text,
                    int32_t* textLength,
@@ -502,7 +505,7 @@ utrans_transUChars(const UTransliterator* trans,
  * @see utrans_transIncremental
  * @stable ICU 2.0
  */
-U_STABLE void U_EXPORT2
+U_CAPI void U_EXPORT2
 utrans_transIncrementalUChars(const UTransliterator* trans,
                               UChar* text,
                               int32_t* textLength,
@@ -515,7 +518,7 @@ utrans_transIncrementalUChars(const UTransliterator* trans,
  * transliterator.
  *
  * @param trans     The transliterator
- * @param escapeUnprintable if TRUE then convert unprintable characters to their
+ * @param escapeUnprintable if true then convert unprintable characters to their
  *                  hex escape representations, \\uxxxx or \\Uxxxxxxxx.
  *                  Unprintable characters are those other than
  *                  U+000A, U+0020..U+007E.
@@ -527,7 +530,7 @@ utrans_transIncrementalUChars(const UTransliterator* trans,
  *                  in which case an error is returned).
  * @stable ICU 53
  */
-U_STABLE int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 utrans_toRules(     const UTransliterator* trans,
                     UBool escapeUnprintable,
                     UChar* result, int32_t resultLength,
@@ -537,9 +540,9 @@ utrans_toRules(     const UTransliterator* trans,
  * Returns the set of all characters that may be modified in the input text by
  * this UTransliterator, optionally ignoring the transliterator's current filter.
  * @param trans     The transliterator.
- * @param ignoreFilter If FALSE, the returned set incorporates the
+ * @param ignoreFilter If false, the returned set incorporates the
  *                  UTransliterator's current filter; if the filter is changed,
- *                  the return value of this function will change. If TRUE, the
+ *                  the return value of this function will change. If true, the
  *                  returned set ignores the effect of the UTransliterator's
  *                  current filter.
  * @param fillIn    Pointer to a USet object to receive the modifiable characters
@@ -552,7 +555,7 @@ utrans_toRules(     const UTransliterator* trans,
  *                  error, NULL is returned.
  * @stable ICU 53
  */
-U_STABLE USet* U_EXPORT2
+U_CAPI USet* U_EXPORT2
 utrans_getSourceSet(const UTransliterator* trans,
                     UBool ignoreFilter,
                     USet* fillIn,
diff --git a/deps/icu-small/source/i18n/unicode/vtzone.h b/deps/icu-small/source/i18n/unicode/vtzone.h
index 43a5652d6a20f0b0ed7d282d7638076ae1d1c408..c0a2a14c897077259f36883dccb93635fcd8c8e7 100644
--- a/deps/icu-small/source/i18n/unicode/vtzone.h
+++ b/deps/icu-small/source/i18n/unicode/vtzone.h
@@ -119,7 +119,7 @@ public:
      * created from VTIMEZONE data, the initial value is set by the TZURL property value
      * in the data.  Otherwise, the initial value is not set.
      * @param url Receives the RFC2445 TZURL property value.
-     * @return TRUE if TZURL attribute is available and value is set.
+     * @return true if TZURL attribute is available and value is set.
      * @stable ICU 3.8
      */
     UBool getTZURL(UnicodeString& url) const;
@@ -136,7 +136,7 @@ public:
      * was created from VTIMEZONE data, the initial value is set by the LAST-MODIFIED property
      * value in the data.  Otherwise, the initial value is not set.
      * @param lastModified Receives the last modified date.
-     * @return TRUE if lastModified attribute is available and value is set.
+     * @return true if lastModified attribute is available and value is set.
      * @stable ICU 3.8
      */
     UBool getLastModified(UDate& lastModified) const;
@@ -157,7 +157,7 @@ public:
     void write(UnicodeString& result, UErrorCode& status) const;
 
     /**
-     * Writes RFC2445 VTIMEZONE data for this time zone applicalbe
+     * Writes RFC2445 VTIMEZONE data for this time zone applicable
      * for dates after the specified start time.
      * @param start The start date.
      * @param result Output param to filled in with the VTIMEZONE data.
@@ -167,7 +167,7 @@ public:
     void write(UDate start, UnicodeString& result, UErrorCode& status) const;
 
     /**
-     * Writes RFC2445 VTIMEZONE data applicalbe for the specified date.
+     * Writes RFC2445 VTIMEZONE data applicable for the specified date.
      * Some common iCalendar implementations can only handle a single time
      * zone property or a pair of standard and daylight time properties using
      * BYDAY rule with day of week (such as BYDAY=1SUN).  This method produce
@@ -264,6 +264,17 @@ public:
     virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
                            int32_t& dstOffset, UErrorCode& ec) const;
 
+#ifndef U_FORCE_HIDE_DRAFT_API
+    /**
+     * Get time zone offsets from local wall time.
+     * @draft ICU 69
+     */
+    virtual void getOffsetFromLocal(
+        UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+        UTimeZoneLocalOption duplicatedTimeOpt,
+        int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
+#endif /* U_FORCE_HIDE_DRAFT_API */
+
     /**
      * Sets the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
      * to GMT to get local time, before taking daylight savings time into account).
@@ -322,7 +333,7 @@ public:
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the first transition after the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      * @stable ICU 3.8
      */
     virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
@@ -332,7 +343,7 @@ public:
      * @param base      The base time.
      * @param inclusive Whether the base time is inclusive or not.
      * @param result    Receives the most recent transition before the base time.
-     * @return  TRUE if the transition is found.
+     * @return  true if the transition is found.
      * @stable ICU 3.8
      */
     virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
diff --git a/deps/icu-small/source/i18n/units_complexconverter.cpp b/deps/icu-small/source/i18n/units_complexconverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db56f5ded9cf98660e7793cc2a785a8573104c8b
--- /dev/null
+++ b/deps/icu-small/source/i18n/units_complexconverter.cpp
@@ -0,0 +1,268 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include <cmath>
+
+#include "cmemory.h"
+#include "number_decimalquantity.h"
+#include "number_roundingutils.h"
+#include "putilimp.h"
+#include "uarrsort.h"
+#include "uassert.h"
+#include "unicode/fmtable.h"
+#include "unicode/localpointer.h"
+#include "unicode/measunit.h"
+#include "unicode/measure.h"
+#include "units_complexconverter.h"
+#include "units_converter.h"
+
+U_NAMESPACE_BEGIN
+namespace units {
+ComplexUnitsConverter::ComplexUnitsConverter(const MeasureUnitImpl &targetUnit,
+                                             const ConversionRates &ratesInfo, UErrorCode &status)
+    : units_(targetUnit.extractIndividualUnitsWithIndices(status)) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    U_ASSERT(units_.length() != 0);
+
+    // Just borrowing a pointer to the instance
+    MeasureUnitImpl *biggestUnit = &units_[0]->unitImpl;
+    for (int32_t i = 1; i < units_.length(); i++) {
+        if (UnitsConverter::compareTwoUnits(units_[i]->unitImpl, *biggestUnit, ratesInfo, status) > 0 &&
+            U_SUCCESS(status)) {
+            biggestUnit = &units_[i]->unitImpl;
+        }
+
+        if (U_FAILURE(status)) {
+            return;
+        }
+    }
+
+    this->init(*biggestUnit, ratesInfo, status);
+}
+
+ComplexUnitsConverter::ComplexUnitsConverter(StringPiece inputUnitIdentifier,
+                                             StringPiece outputUnitsIdentifier, UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    MeasureUnitImpl inputUnit = MeasureUnitImpl::forIdentifier(inputUnitIdentifier, status);
+    MeasureUnitImpl outputUnits = MeasureUnitImpl::forIdentifier(outputUnitsIdentifier, status);
+
+    this->units_ = outputUnits.extractIndividualUnitsWithIndices(status);
+    U_ASSERT(units_.length() != 0);
+
+    this->init(inputUnit, ConversionRates(status), status);
+}
+
+ComplexUnitsConverter::ComplexUnitsConverter(const MeasureUnitImpl &inputUnit,
+                                             const MeasureUnitImpl &outputUnits,
+                                             const ConversionRates &ratesInfo, UErrorCode &status)
+    : units_(outputUnits.extractIndividualUnitsWithIndices(status)) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    U_ASSERT(units_.length() != 0);
+
+    this->init(inputUnit, ratesInfo, status);
+}
+
+void ComplexUnitsConverter::init(const MeasureUnitImpl &inputUnit,
+                                 const ConversionRates &ratesInfo,
+                                 UErrorCode &status) {
+    // Sorts units in descending order. Therefore, we return -1 if
+    // the left is bigger than right and so on.
+    auto descendingCompareUnits = [](const void *context, const void *left, const void *right) {
+        UErrorCode status = U_ZERO_ERROR;
+
+        const auto *leftPointer = static_cast<const MeasureUnitImplWithIndex *const *>(left);
+        const auto *rightPointer = static_cast<const MeasureUnitImplWithIndex *const *>(right);
+
+        // Multiply by -1 to sort in descending order
+        return (-1) * UnitsConverter::compareTwoUnits((**leftPointer).unitImpl,                       //
+                                                      (**rightPointer).unitImpl,                      //
+                                                      *static_cast<const ConversionRates *>(context), //
+                                                      status);
+    };
+
+    uprv_sortArray(units_.getAlias(),                                                                  //
+                   units_.length(),                                                                    //
+                   sizeof units_[0], /* NOTE: we have already asserted that the units_ is not empty.*/ //
+                   descendingCompareUnits,                                                             //
+                   &ratesInfo,                                                                         //
+                   false,                                                                              //
+                   &status                                                                             //
+    );
+
+    // In case the `outputUnits` are `UMEASURE_UNIT_MIXED` such as `foot+inch`. In this case we need more
+    // converters to convert from the `inputUnit` to the first unit in the `outputUnits`. Then, a
+    // converter from the first unit in the `outputUnits` to the second unit and so on.
+    //      For Example:
+    //          - inputUnit is `meter`
+    //          - outputUnits is `foot+inch`
+    //              - Therefore, we need to have two converters:
+    //                      1. a converter from `meter` to `foot`
+    //                      2. a converter from `foot` to `inch`
+    //          - Therefore, if the input is `2 meter`:
+    //              1. convert `meter` to `foot` --> 2 meter to 6.56168 feet
+    //              2. convert the residual of 6.56168 feet (0.56168) to inches, which will be (6.74016
+    //              inches)
+    //              3. then, the final result will be (6 feet and 6.74016 inches)
+    for (int i = 0, n = units_.length(); i < n; i++) {
+        if (i == 0) { // first element
+            unitsConverters_.emplaceBackAndCheckErrorCode(status, inputUnit, units_[i]->unitImpl,
+                                                          ratesInfo, status);
+        } else {
+            unitsConverters_.emplaceBackAndCheckErrorCode(status, units_[i - 1]->unitImpl,
+                                                          units_[i]->unitImpl, ratesInfo, status);
+        }
+
+        if (U_FAILURE(status)) {
+            return;
+        }
+    }
+}
+
+UBool ComplexUnitsConverter::greaterThanOrEqual(double quantity, double limit) const {
+    U_ASSERT(unitsConverters_.length() > 0);
+
+    // First converter converts to the biggest quantity.
+    double newQuantity = unitsConverters_[0]->convert(quantity);
+    return newQuantity >= limit;
+}
+
+MaybeStackVector<Measure> ComplexUnitsConverter::convert(double quantity,
+                                                         icu::number::impl::RoundingImpl *rounder,
+                                                         UErrorCode &status) const {
+    // TODO: return an error for "foot-and-foot"?
+    MaybeStackVector<Measure> result;
+    int sign = 1;
+    if (quantity < 0) {
+        quantity *= -1;
+        sign = -1;
+    }
+
+    // For N converters:
+    // - the first converter converts from the input unit to the largest unit,
+    // - the following N-2 converters convert to bigger units for which we want integers,
+    // - the Nth converter (index N-1) converts to the smallest unit, for which
+    //   we keep a double.
+    MaybeStackArray<int64_t, 5> intValues(unitsConverters_.length() - 1, status);
+    if (U_FAILURE(status)) {
+        return result;
+    }
+    uprv_memset(intValues.getAlias(), 0, (unitsConverters_.length() - 1) * sizeof(int64_t));
+
+    for (int i = 0, n = unitsConverters_.length(); i < n; ++i) {
+        quantity = (*unitsConverters_[i]).convert(quantity);
+        if (i < n - 1) {
+            // If quantity is at the limits of double's precision from an
+            // integer value, we take that integer value.
+            int64_t flooredQuantity = floor(quantity * (1 + DBL_EPSILON));
+            if (uprv_isNaN(quantity)) {
+                // With clang on Linux: floor does not support NaN, resulting in
+                // a giant negative number. For now, we produce "0 feet, NaN
+                // inches". TODO(icu-units#131): revisit desired output.
+                flooredQuantity = 0;
+            }
+            intValues[i] = flooredQuantity;
+
+            // Keep the residual of the quantity.
+            //   For example: `3.6 feet`, keep only `0.6 feet`
+            double remainder = quantity - flooredQuantity;
+            if (remainder < 0) {
+                // Because we nudged flooredQuantity up by eps, remainder may be
+                // negative: we must treat such a remainder as zero.
+                quantity = 0;
+            } else {
+                quantity = remainder;
+            }
+        }
+    }
+
+    applyRounder(intValues, quantity, rounder, status);
+
+    // Initialize empty result. We use a MaybeStackArray directly so we can
+    // assign pointers - for this privilege we have to take care of cleanup.
+    MaybeStackArray<Measure *, 4> tmpResult(unitsConverters_.length(), status);
+    if (U_FAILURE(status)) {
+        return result;
+    }
+
+    // Package values into temporary Measure instances in tmpResult:
+    for (int i = 0, n = unitsConverters_.length(); i < n; ++i) {
+        if (i < n - 1) {
+            Formattable formattableQuantity(intValues[i] * sign);
+            // Measure takes ownership of the MeasureUnit*
+            MeasureUnit *type = new MeasureUnit(units_[i]->unitImpl.copy(status).build(status));
+            tmpResult[units_[i]->index] = new Measure(formattableQuantity, type, status);
+        } else { // LAST ELEMENT
+            Formattable formattableQuantity(quantity * sign);
+            // Measure takes ownership of the MeasureUnit*
+            MeasureUnit *type = new MeasureUnit(units_[i]->unitImpl.copy(status).build(status));
+            tmpResult[units_[i]->index] = new Measure(formattableQuantity, type, status);
+        }
+    }
+
+
+    // Transfer values into result and return:
+    for(int32_t i = 0, n = unitsConverters_.length(); i < n; ++i) {
+        U_ASSERT(tmpResult[i] != nullptr);
+        result.emplaceBackAndCheckErrorCode(status, *tmpResult[i]);
+        delete tmpResult[i];
+    }
+
+    return result;
+}
+
+void ComplexUnitsConverter::applyRounder(MaybeStackArray<int64_t, 5> &intValues, double &quantity,
+                                         icu::number::impl::RoundingImpl *rounder,
+                                         UErrorCode &status) const {
+    if (rounder == nullptr) {
+        // Nothing to do for the quantity.
+        return;
+    }
+
+    number::impl::DecimalQuantity decimalQuantity;
+    decimalQuantity.setToDouble(quantity);
+    rounder->apply(decimalQuantity, status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+    quantity = decimalQuantity.toDouble();
+
+    int32_t lastIndex = unitsConverters_.length() - 1;
+    if (lastIndex == 0) {
+        // Only one element, no need to bubble up the carry
+        return;
+    }
+
+    // Check if there's a carry, and bubble it back up the resulting intValues.
+    int64_t carry = floor(unitsConverters_[lastIndex]->convertInverse(quantity) * (1 + DBL_EPSILON));
+    if (carry <= 0) {
+        return;
+    }
+    quantity -= unitsConverters_[lastIndex]->convert(carry);
+    intValues[lastIndex - 1] += carry;
+
+    // We don't use the first converter: that one is for the input unit
+    for (int32_t j = lastIndex - 1; j > 0; j--) {
+        carry = floor(unitsConverters_[j]->convertInverse(intValues[j]) * (1 + DBL_EPSILON));
+        if (carry <= 0) {
+            return;
+        }
+        intValues[j] -= round(unitsConverters_[j]->convert(carry));
+        intValues[j - 1] += carry;
+    }
+}
+
+} // namespace units
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/units_complexconverter.h b/deps/icu-small/source/i18n/units_complexconverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c669b45ddd7df189b3b7b891ca854ddf88c1c96
--- /dev/null
+++ b/deps/icu-small/source/i18n/units_complexconverter.h
@@ -0,0 +1,134 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __UNITS_COMPLEXCONVERTER_H__
+#define __UNITS_COMPLEXCONVERTER_H__
+
+#include "cmemory.h"
+#include "measunit_impl.h"
+#include "number_roundingutils.h"
+#include "unicode/errorcode.h"
+#include "unicode/measure.h"
+#include "units_converter.h"
+#include "units_data.h"
+
+U_NAMESPACE_BEGIN
+
+// Export explicit template instantiations of MaybeStackArray, MemoryPool and
+// MaybeStackVector. This is required when building DLLs for Windows. (See
+// datefmt.h, collationiterator.h, erarules.h and others for similar examples.)
+//
+// Note: These need to be outside of the units namespace, or Clang will generate
+// a compile error.
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<units::UnitsConverter*, 8>;
+template class U_I18N_API MemoryPool<units::UnitsConverter, 8>;
+template class U_I18N_API MaybeStackVector<units::UnitsConverter, 8>;
+template class U_I18N_API MaybeStackArray<MeasureUnitImpl*, 8>;
+template class U_I18N_API MemoryPool<MeasureUnitImpl, 8>;
+template class U_I18N_API MaybeStackVector<MeasureUnitImpl, 8>;
+template class U_I18N_API MaybeStackArray<MeasureUnit*, 8>;
+template class U_I18N_API MemoryPool<MeasureUnit, 8>;
+template class U_I18N_API MaybeStackVector<MeasureUnit, 8>;
+#endif
+
+namespace units {
+
+/**
+ *  Converts from single or compound unit to single, compound or mixed units.
+ * For example, from `meter` to `foot+inch`.
+ *
+ *  DESIGN:
+ *    This class uses `UnitsConverter` in order to perform the single converter (i.e. converters from a
+ *    single unit to another single unit). Therefore, `ComplexUnitsConverter` class contains multiple
+ *    instances of the `UnitsConverter` to perform the conversion.
+ */
+class U_I18N_API ComplexUnitsConverter : public UMemory {
+  public:
+    /**
+     * Constructs `ComplexUnitsConverter` for an `targetUnit` that could be Single, Compound or Mixed.
+     * In case of:
+     * 1- Single and Compound units,
+     *    the conversion will not perform anything, the input will be equal to the output.
+     * 2- Mixed Unit
+     *    the conversion will consider the input is the biggest unit. And will convert it to be spread
+     *    through the target units. For example: if target unit is "inch-and-foot", and the input is 2.5.
+     *    The converter will consider the input value in "foot", because foot is the biggest unit.
+     *    Then, it will convert 2.5 feet to "inch-and-foot".
+     *
+     * @param targetUnit could be any units type (single, compound or mixed).
+     * @param ratesInfo
+     * @param status
+     */
+    ComplexUnitsConverter(const MeasureUnitImpl &targetUnit, const ConversionRates &ratesInfo,
+                          UErrorCode &status);
+    /**
+     * Constructor of `ComplexUnitsConverter`.
+     * NOTE:
+     *   - inputUnit and outputUnits must be under the same category
+     *      - e.g. meter to feet and inches --> all of them are length units.
+     *
+     * @param inputUnit represents the source unit. (should be single or compound unit).
+     * @param outputUnits represents the output unit. could be any type. (single, compound or mixed).
+     * @param status
+     */
+    ComplexUnitsConverter(StringPiece inputUnitIdentifier, StringPiece outputUnitsIdentifier,
+                          UErrorCode &status);
+
+    /**
+     * Constructor of `ComplexUnitsConverter`.
+     * NOTE:
+     *   - inputUnit and outputUnits must be under the same category
+     *      - e.g. meter to feet and inches --> all of them are length units.
+     *
+     * @param inputUnit represents the source unit. (should be single or compound unit).
+     * @param outputUnits represents the output unit. could be any type. (single, compound or mixed).
+     * @param ratesInfo a ConversionRates instance containing the unit conversion rates.
+     * @param status
+     */
+    ComplexUnitsConverter(const MeasureUnitImpl &inputUnit, const MeasureUnitImpl &outputUnits,
+                          const ConversionRates &ratesInfo, UErrorCode &status);
+
+    // Returns true if the specified `quantity` of the `inputUnit`, expressed in terms of the biggest
+    // unit in the MeasureUnit `outputUnit`, is greater than or equal to `limit`.
+    //    For example, if the input unit is `meter` and the target unit is `foot+inch`. Therefore, this
+    //    function will convert the `quantity` from `meter` to `foot`, then, it will compare the value in
+    //    `foot` with the `limit`.
+    UBool greaterThanOrEqual(double quantity, double limit) const;
+
+    // Returns outputMeasures which is an array with the corresponding values.
+    //    - E.g. converting meters to feet and inches.
+    //                  1 meter --> 3 feet, 3.3701 inches
+    //         NOTE:
+    //           the smallest element is the only element that could have fractional values. And all
+    //           other elements are floored to the nearest integer
+    MaybeStackVector<Measure>
+    convert(double quantity, icu::number::impl::RoundingImpl *rounder, UErrorCode &status) const;
+
+  private:
+    MaybeStackVector<UnitsConverter> unitsConverters_;
+
+    // Individual units of mixed units, sorted big to small, with indices
+    // indicating the requested output mixed unit order.
+    MaybeStackVector<MeasureUnitImplWithIndex> units_;
+
+    // Sorts units_, which must be populated before calling this, and populates
+    // unitsConverters_.
+    void init(const MeasureUnitImpl &inputUnit, const ConversionRates &ratesInfo, UErrorCode &status);
+
+    // Applies the rounder to the quantity (last element) and bubble up any carried value to all the
+    // intValues.
+    // TODO(ICU-21288): get smarter about precision for mixed units.
+    void applyRounder(MaybeStackArray<int64_t, 5> &intValues, double &quantity,
+                      icu::number::impl::RoundingImpl *rounder, UErrorCode &status) const;
+};
+
+} // namespace units
+U_NAMESPACE_END
+
+#endif //__UNITS_COMPLEXCONVERTER_H__
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/units_converter.cpp b/deps/icu-small/source/i18n/units_converter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2854ad30b3288f5f8413a69108eb3866eec2649e
--- /dev/null
+++ b/deps/icu-small/source/i18n/units_converter.cpp
@@ -0,0 +1,633 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "charstr.h"
+#include "cmemory.h"
+#include "double-conversion-string-to-double.h"
+#include "measunit_impl.h"
+#include "uassert.h"
+#include "unicode/errorcode.h"
+#include "unicode/localpointer.h"
+#include "unicode/stringpiece.h"
+#include "units_converter.h"
+#include <algorithm>
+#include <cmath>
+#include <stdlib.h>
+#include <utility>
+
+U_NAMESPACE_BEGIN
+namespace units {
+
+void U_I18N_API Factor::multiplyBy(const Factor &rhs) {
+    factorNum *= rhs.factorNum;
+    factorDen *= rhs.factorDen;
+    for (int i = 0; i < CONSTANTS_COUNT; i++) {
+        constantExponents[i] += rhs.constantExponents[i];
+    }
+
+    // NOTE
+    //  We need the offset when the source and the target are simple units. e.g. the source is
+    //  celsius and the target is Fahrenheit. Therefore, we just keep the value using `std::max`.
+    offset = std::max(rhs.offset, offset);
+}
+
+void U_I18N_API Factor::divideBy(const Factor &rhs) {
+    factorNum *= rhs.factorDen;
+    factorDen *= rhs.factorNum;
+    for (int i = 0; i < CONSTANTS_COUNT; i++) {
+        constantExponents[i] -= rhs.constantExponents[i];
+    }
+
+    // NOTE
+    //  We need the offset when the source and the target are simple units. e.g. the source is
+    //  celsius and the target is Fahrenheit. Therefore, we just keep the value using `std::max`.
+    offset = std::max(rhs.offset, offset);
+}
+
+void U_I18N_API Factor::power(int32_t power) {
+    // multiply all the constant by the power.
+    for (int i = 0; i < CONSTANTS_COUNT; i++) {
+        constantExponents[i] *= power;
+    }
+
+    bool shouldFlip = power < 0; // This means that after applying the absolute power, we should flip
+                                 // the Numerator and Denominator.
+
+    factorNum = std::pow(factorNum, std::abs(power));
+    factorDen = std::pow(factorDen, std::abs(power));
+
+    if (shouldFlip) {
+        // Flip Numerator and Denominator.
+        std::swap(factorNum, factorDen);
+    }
+}
+
+void U_I18N_API Factor::applyPrefix(UMeasurePrefix unitPrefix) {
+    if (unitPrefix == UMeasurePrefix::UMEASURE_PREFIX_ONE) {
+        // No need to do anything
+        return;
+    }
+
+    int32_t prefixPower = umeas_getPrefixPower(unitPrefix);
+    double prefixFactor = std::pow((double)umeas_getPrefixBase(unitPrefix), (double)std::abs(prefixPower));
+    if (prefixPower >= 0) {
+        factorNum *= prefixFactor;
+    } else {
+        factorDen *= prefixFactor;
+    }
+}
+
+void U_I18N_API Factor::substituteConstants() {
+    for (int i = 0; i < CONSTANTS_COUNT; i++) {
+        if (this->constantExponents[i] == 0) {
+            continue;
+        }
+
+        auto absPower = std::abs(this->constantExponents[i]);
+        Signum powerSig = this->constantExponents[i] < 0 ? Signum::NEGATIVE : Signum::POSITIVE;
+        double absConstantValue = std::pow(constantsValues[i], absPower);
+
+        if (powerSig == Signum::NEGATIVE) {
+            this->factorDen *= absConstantValue;
+        } else {
+            this->factorNum *= absConstantValue;
+        }
+
+        this->constantExponents[i] = 0;
+    }
+}
+
+namespace {
+
+/* Helpers */
+
+using icu::double_conversion::StringToDoubleConverter;
+
+// TODO: Make this a shared-utility function.
+// Returns `double` from a scientific number(i.e. "1", "2.01" or "3.09E+4")
+double strToDouble(StringPiece strNum, UErrorCode &status) {
+    // We are processing well-formed input, so we don't need any special options to
+    // StringToDoubleConverter.
+    StringToDoubleConverter converter(0, 0, 0, "", "");
+    int32_t count;
+    double result = converter.StringToDouble(strNum.data(), strNum.length(), &count);
+    if (count != strNum.length()) {
+        status = U_INVALID_FORMAT_ERROR;
+    }
+
+    return result;
+}
+
+// Returns `double` from a scientific number that could has a division sign (i.e. "1", "2.01", "3.09E+4"
+// or "2E+2/3")
+double strHasDivideSignToDouble(StringPiece strWithDivide, UErrorCode &status) {
+    int divisionSignInd = -1;
+    for (int i = 0, n = strWithDivide.length(); i < n; ++i) {
+        if (strWithDivide.data()[i] == '/') {
+            divisionSignInd = i;
+            break;
+        }
+    }
+
+    if (divisionSignInd >= 0) {
+        return strToDouble(strWithDivide.substr(0, divisionSignInd), status) /
+               strToDouble(strWithDivide.substr(divisionSignInd + 1), status);
+    }
+
+    return strToDouble(strWithDivide, status);
+}
+
+/*
+  Adds single factor to a `Factor` object. Single factor means "23^2", "23.3333", "ft2m^3" ...etc.
+  However, complex factor are not included, such as "ft2m^3*200/3"
+*/
+void addFactorElement(Factor &factor, StringPiece elementStr, Signum signum, UErrorCode &status) {
+    StringPiece baseStr;
+    StringPiece powerStr;
+    int32_t power =
+        1; // In case the power is not written, then, the power is equal 1 ==> `ft2m^1` == `ft2m`
+
+    // Search for the power part
+    int32_t powerInd = -1;
+    for (int32_t i = 0, n = elementStr.length(); i < n; ++i) {
+        if (elementStr.data()[i] == '^') {
+            powerInd = i;
+            break;
+        }
+    }
+
+    if (powerInd > -1) {
+        // There is power
+        baseStr = elementStr.substr(0, powerInd);
+        powerStr = elementStr.substr(powerInd + 1);
+
+        power = static_cast<int32_t>(strToDouble(powerStr, status));
+    } else {
+        baseStr = elementStr;
+    }
+
+    addSingleFactorConstant(baseStr, power, signum, factor, status);
+}
+
+/*
+ * Extracts `Factor` from a complete string factor. e.g. "ft2m^3*1007/cup2m3*3"
+ */
+Factor extractFactorConversions(StringPiece stringFactor, UErrorCode &status) {
+    Factor result;
+    Signum signum = Signum::POSITIVE;
+    auto factorData = stringFactor.data();
+    for (int32_t i = 0, start = 0, n = stringFactor.length(); i < n; i++) {
+        if (factorData[i] == '*' || factorData[i] == '/') {
+            StringPiece factorElement = stringFactor.substr(start, i - start);
+            addFactorElement(result, factorElement, signum, status);
+
+            start = i + 1; // Set `start` to point to the start of the new element.
+        } else if (i == n - 1) {
+            // Last element
+            addFactorElement(result, stringFactor.substr(start, i + 1), signum, status);
+        }
+
+        if (factorData[i] == '/') {
+            signum = Signum::NEGATIVE; // Change the signum because we reached the Denominator.
+        }
+    }
+
+    return result;
+}
+
+// Load factor for a single source
+Factor loadSingleFactor(StringPiece source, const ConversionRates &ratesInfo, UErrorCode &status) {
+    const auto conversionUnit = ratesInfo.extractConversionInfo(source, status);
+    if (U_FAILURE(status)) return Factor();
+    if (conversionUnit == nullptr) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return Factor();
+    }
+
+    Factor result = extractFactorConversions(conversionUnit->factor.toStringPiece(), status);
+    result.offset = strHasDivideSignToDouble(conversionUnit->offset.toStringPiece(), status);
+
+    return result;
+}
+
+// Load Factor of a compound source unit.
+// In ICU4J, this is a pair of ConversionRates.getFactorToBase() functions.
+Factor loadCompoundFactor(const MeasureUnitImpl &source, const ConversionRates &ratesInfo,
+                          UErrorCode &status) {
+
+    Factor result;
+    for (int32_t i = 0, n = source.singleUnits.length(); i < n; i++) {
+        SingleUnitImpl singleUnit = *source.singleUnits[i];
+
+        Factor singleFactor = loadSingleFactor(singleUnit.getSimpleUnitID(), ratesInfo, status);
+        if (U_FAILURE(status)) return result;
+
+        // Prefix before power, because:
+        // - square-kilometer to square-meter: (1000)^2
+        // - square-kilometer to square-foot (approximate): (3.28*1000)^2
+        singleFactor.applyPrefix(singleUnit.unitPrefix);
+
+        // Apply the power of the `dimensionality`
+        singleFactor.power(singleUnit.dimensionality);
+
+        result.multiplyBy(singleFactor);
+    }
+
+    return result;
+}
+
+/**
+ * Checks if the source unit and the target unit are simple. For example celsius or fahrenheit. But not
+ * square-celsius or square-fahrenheit.
+ *
+ * NOTE:
+ *  Empty unit means simple unit.
+ *
+ * In ICU4J, this is ConversionRates.checkSimpleUnit().
+ */
+UBool checkSimpleUnit(const MeasureUnitImpl &unit, UErrorCode &status) {
+    if (U_FAILURE(status)) return false;
+
+    if (unit.complexity != UMEASURE_UNIT_SINGLE) {
+        return false;
+    }
+    if (unit.singleUnits.length() == 0) {
+        // Empty units means simple unit.
+        return true;
+    }
+
+    auto singleUnit = *(unit.singleUnits[0]);
+
+    if (singleUnit.dimensionality != 1 || singleUnit.unitPrefix != UMEASURE_PREFIX_ONE) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ *  Extract conversion rate from `source` to `target`
+ */
+// In ICU4J, this function is partially inlined in the UnitsConverter constructor.
+void loadConversionRate(ConversionRate &conversionRate, const MeasureUnitImpl &source,
+                        const MeasureUnitImpl &target, Convertibility unitsState,
+                        const ConversionRates &ratesInfo, UErrorCode &status) {
+    // Represents the conversion factor from the source to the target.
+    Factor finalFactor;
+
+    // Represents the conversion factor from the source to the base unit that specified in the conversion
+    // data which is considered as the root of the source and the target.
+    Factor sourceToBase = loadCompoundFactor(source, ratesInfo, status);
+    Factor targetToBase = loadCompoundFactor(target, ratesInfo, status);
+
+    // Merger Factors
+    finalFactor.multiplyBy(sourceToBase);
+    if (unitsState == Convertibility::CONVERTIBLE) {
+        finalFactor.divideBy(targetToBase);
+    } else if (unitsState == Convertibility::RECIPROCAL) {
+        finalFactor.multiplyBy(targetToBase);
+    } else {
+        status = UErrorCode::U_ARGUMENT_TYPE_MISMATCH;
+        return;
+    }
+
+    finalFactor.substituteConstants();
+
+    conversionRate.factorNum = finalFactor.factorNum;
+    conversionRate.factorDen = finalFactor.factorDen;
+
+    // This code corresponds to ICU4J's ConversionRates.getOffset().
+    // In case of simple units (such as: celsius or fahrenheit), offsets are considered.
+    if (checkSimpleUnit(source, status) && checkSimpleUnit(target, status)) {
+        conversionRate.sourceOffset =
+            sourceToBase.offset * sourceToBase.factorDen / sourceToBase.factorNum;
+        conversionRate.targetOffset =
+            targetToBase.offset * targetToBase.factorDen / targetToBase.factorNum;
+    }
+    // TODO(icu-units#127): should we consider failure if there's an offset for
+    // a not-simple-unit? What about kilokelvin / kilocelsius?
+
+    conversionRate.reciprocal = unitsState == Convertibility::RECIPROCAL;
+}
+
+struct UnitIndexAndDimension : UMemory {
+    int32_t index = 0;
+    int32_t dimensionality = 0;
+
+    UnitIndexAndDimension(const SingleUnitImpl &singleUnit, int32_t multiplier) {
+        index = singleUnit.index;
+        dimensionality = singleUnit.dimensionality * multiplier;
+    }
+};
+
+void mergeSingleUnitWithDimension(MaybeStackVector<UnitIndexAndDimension> &unitIndicesWithDimension,
+                                  const SingleUnitImpl &shouldBeMerged, int32_t multiplier) {
+    for (int32_t i = 0; i < unitIndicesWithDimension.length(); i++) {
+        auto &unitWithIndex = *unitIndicesWithDimension[i];
+        if (unitWithIndex.index == shouldBeMerged.index) {
+            unitWithIndex.dimensionality += shouldBeMerged.dimensionality * multiplier;
+            return;
+        }
+    }
+
+    unitIndicesWithDimension.emplaceBack(shouldBeMerged, multiplier);
+}
+
+void mergeUnitsAndDimensions(MaybeStackVector<UnitIndexAndDimension> &unitIndicesWithDimension,
+                             const MeasureUnitImpl &shouldBeMerged, int32_t multiplier) {
+    for (int32_t unit_i = 0; unit_i < shouldBeMerged.singleUnits.length(); unit_i++) {
+        auto singleUnit = *shouldBeMerged.singleUnits[unit_i];
+        mergeSingleUnitWithDimension(unitIndicesWithDimension, singleUnit, multiplier);
+    }
+}
+
+UBool checkAllDimensionsAreZeros(const MaybeStackVector<UnitIndexAndDimension> &dimensionVector) {
+    for (int32_t i = 0; i < dimensionVector.length(); i++) {
+        if (dimensionVector[i]->dimensionality != 0) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+} // namespace
+
+// Conceptually, this modifies factor: factor *= baseStr^(signum*power).
+//
+// baseStr must be a known constant or a value that strToDouble() is able to
+// parse.
+void U_I18N_API addSingleFactorConstant(StringPiece baseStr, int32_t power, Signum signum,
+                                        Factor &factor, UErrorCode &status) {
+    if (baseStr == "ft_to_m") {
+        factor.constantExponents[CONSTANT_FT2M] += power * signum;
+    } else if (baseStr == "ft2_to_m2") {
+        factor.constantExponents[CONSTANT_FT2M] += 2 * power * signum;
+    } else if (baseStr == "ft3_to_m3") {
+        factor.constantExponents[CONSTANT_FT2M] += 3 * power * signum;
+    } else if (baseStr == "in3_to_m3") {
+        factor.constantExponents[CONSTANT_FT2M] += 3 * power * signum;
+        factor.factorDen *= 12 * 12 * 12;
+    } else if (baseStr == "gal_to_m3") {
+        factor.factorNum *= 231;
+        factor.constantExponents[CONSTANT_FT2M] += 3 * power * signum;
+        factor.factorDen *= 12 * 12 * 12;
+    } else if (baseStr == "gal_imp_to_m3") {
+        factor.constantExponents[CONSTANT_GAL_IMP2M3] += power * signum;
+    } else if (baseStr == "G") {
+        factor.constantExponents[CONSTANT_G] += power * signum;
+    } else if (baseStr == "gravity") {
+        factor.constantExponents[CONSTANT_GRAVITY] += power * signum;
+    } else if (baseStr == "lb_to_kg") {
+        factor.constantExponents[CONSTANT_LB2KG] += power * signum;
+    } else if (baseStr == "glucose_molar_mass") {
+        factor.constantExponents[CONSTANT_GLUCOSE_MOLAR_MASS] += power * signum;
+    } else if (baseStr == "item_per_mole") {
+        factor.constantExponents[CONSTANT_ITEM_PER_MOLE] += power * signum;
+    } else if (baseStr == "PI") {
+        factor.constantExponents[CONSTANT_PI] += power * signum;
+    } else {
+        if (signum == Signum::NEGATIVE) {
+            factor.factorDen *= std::pow(strToDouble(baseStr, status), power);
+        } else {
+            factor.factorNum *= std::pow(strToDouble(baseStr, status), power);
+        }
+    }
+}
+
+/**
+ * Extracts the compound base unit of a compound unit (`source`). For example, if the source unit is
+ * `square-mile-per-hour`, the compound base unit will be `square-meter-per-second`
+ */
+MeasureUnitImpl U_I18N_API extractCompoundBaseUnit(const MeasureUnitImpl &source,
+                                                   const ConversionRates &conversionRates,
+                                                   UErrorCode &status) {
+
+    MeasureUnitImpl result;
+    if (U_FAILURE(status)) return result;
+
+    const auto &singleUnits = source.singleUnits;
+    for (int i = 0, count = singleUnits.length(); i < count; ++i) {
+        const auto &singleUnit = *singleUnits[i];
+        // Extract `ConversionRateInfo` using the absolute unit. For example: in case of `square-meter`,
+        // we will use `meter`
+        const auto rateInfo =
+            conversionRates.extractConversionInfo(singleUnit.getSimpleUnitID(), status);
+        if (U_FAILURE(status)) {
+            return result;
+        }
+        if (rateInfo == nullptr) {
+            status = U_INTERNAL_PROGRAM_ERROR;
+            return result;
+        }
+
+        // Multiply the power of the singleUnit by the power of the baseUnit. For example, square-hectare
+        // must be pow4-meter. (NOTE: hectare --> square-meter)
+        auto baseUnits =
+            MeasureUnitImpl::forIdentifier(rateInfo->baseUnit.toStringPiece(), status).singleUnits;
+        for (int32_t i = 0, baseUnitsCount = baseUnits.length(); i < baseUnitsCount; i++) {
+            baseUnits[i]->dimensionality *= singleUnit.dimensionality;
+            // TODO: Deal with SI-prefix
+            result.appendSingleUnit(*baseUnits[i], status);
+
+            if (U_FAILURE(status)) {
+                return result;
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Determine the convertibility between `source` and `target`.
+ * For example:
+ *    `meter` and `foot` are `CONVERTIBLE`.
+ *    `meter-per-second` and `second-per-meter` are `RECIPROCAL`.
+ *    `meter` and `pound` are `UNCONVERTIBLE`.
+ *
+ * NOTE:
+ *    Only works with SINGLE and COMPOUND units. If one of the units is a
+ *    MIXED unit, an error will occur. For more information, see UMeasureUnitComplexity.
+ */
+Convertibility U_I18N_API extractConvertibility(const MeasureUnitImpl &source,
+                                                const MeasureUnitImpl &target,
+                                                const ConversionRates &conversionRates,
+                                                UErrorCode &status) {
+
+    if (source.complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED ||
+        target.complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return UNCONVERTIBLE;
+    }
+
+    MeasureUnitImpl sourceBaseUnit = extractCompoundBaseUnit(source, conversionRates, status);
+    MeasureUnitImpl targetBaseUnit = extractCompoundBaseUnit(target, conversionRates, status);
+    if (U_FAILURE(status)) return UNCONVERTIBLE;
+
+    MaybeStackVector<UnitIndexAndDimension> convertible;
+    MaybeStackVector<UnitIndexAndDimension> reciprocal;
+
+    mergeUnitsAndDimensions(convertible, sourceBaseUnit, 1);
+    mergeUnitsAndDimensions(reciprocal, sourceBaseUnit, 1);
+
+    mergeUnitsAndDimensions(convertible, targetBaseUnit, -1);
+    mergeUnitsAndDimensions(reciprocal, targetBaseUnit, 1);
+
+    if (checkAllDimensionsAreZeros(convertible)) {
+        return CONVERTIBLE;
+    }
+
+    if (checkAllDimensionsAreZeros(reciprocal)) {
+        return RECIPROCAL;
+    }
+
+    return UNCONVERTIBLE;
+}
+
+UnitsConverter::UnitsConverter(const MeasureUnitImpl &source, const MeasureUnitImpl &target,
+                               const ConversionRates &ratesInfo, UErrorCode &status)
+    : conversionRate_(source.copy(status), target.copy(status)) {
+    this->init(ratesInfo, status);
+}
+
+UnitsConverter::UnitsConverter(StringPiece sourceIdentifier, StringPiece targetIdentifier,
+                               UErrorCode &status)
+    : conversionRate_(MeasureUnitImpl::forIdentifier(sourceIdentifier, status),
+                      MeasureUnitImpl::forIdentifier(targetIdentifier, status)) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    ConversionRates ratesInfo(status);
+    this->init(ratesInfo, status);
+}
+
+void UnitsConverter::init(const ConversionRates &ratesInfo, UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    if (this->conversionRate_.source.complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED ||
+        this->conversionRate_.target.complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return;
+    }
+
+    Convertibility unitsState = extractConvertibility(this->conversionRate_.source,
+                                                      this->conversionRate_.target, ratesInfo, status);
+    if (U_FAILURE(status)) return;
+    if (unitsState == Convertibility::UNCONVERTIBLE) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return;
+    }
+
+    loadConversionRate(conversionRate_, conversionRate_.source, conversionRate_.target, unitsState,
+                       ratesInfo, status);
+
+}
+
+int32_t UnitsConverter::compareTwoUnits(const MeasureUnitImpl &firstUnit,
+                                        const MeasureUnitImpl &secondUnit,
+                                        const ConversionRates &ratesInfo, UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return 0;
+    }
+
+    if (firstUnit.complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED ||
+        secondUnit.complexity == UMeasureUnitComplexity::UMEASURE_UNIT_MIXED) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return 0;
+    }
+
+    Convertibility unitsState = extractConvertibility(firstUnit, secondUnit, ratesInfo, status);
+    if (U_FAILURE(status)) {
+        return 0;
+    }
+
+    if (unitsState == Convertibility::UNCONVERTIBLE || unitsState == Convertibility::RECIPROCAL) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return 0;
+    }
+
+    // Represents the conversion factor from the firstUnit to the base
+    // unit that specified in the conversion data which is considered as
+    // the root of the firstUnit and the secondUnit.
+    Factor firstUnitToBase = loadCompoundFactor(firstUnit, ratesInfo, status);
+    Factor secondUnitToBase = loadCompoundFactor(secondUnit, ratesInfo, status);
+
+    firstUnitToBase.substituteConstants();
+    secondUnitToBase.substituteConstants();
+
+    double firstUnitToBaseConversionRate = firstUnitToBase.factorNum / firstUnitToBase.factorDen;
+    double secondUnitToBaseConversionRate = secondUnitToBase.factorNum / secondUnitToBase.factorDen;
+
+    double diff = firstUnitToBaseConversionRate - secondUnitToBaseConversionRate;
+    if (diff > 0) {
+        return 1;
+    }
+
+    if (diff < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+double UnitsConverter::convert(double inputValue) const {
+    double result =
+        inputValue + conversionRate_.sourceOffset; // Reset the input to the target zero index.
+    // Convert the quantity to from the source scale to the target scale.
+    result *= conversionRate_.factorNum / conversionRate_.factorDen;
+
+    result -= conversionRate_.targetOffset; // Set the result to its index.
+
+    if (conversionRate_.reciprocal) {
+        if (result == 0) {
+            // TODO: demonstrate the resulting behaviour in tests... and figure
+            // out desired behaviour. (Theoretical result should be infinity,
+            // not 0.)
+            return 0.0;
+        }
+        result = 1.0 / result;
+    }
+
+    return result;
+}
+
+double UnitsConverter::convertInverse(double inputValue) const {
+    double result = inputValue;
+    if (conversionRate_.reciprocal) {
+        if (result == 0) {
+            // TODO: demonstrate the resulting behaviour in tests... and figure
+            // out desired behaviour. (Theoretical result should be infinity,
+            // not 0.)
+            return 0.0;
+        }
+        result = 1.0 / result;
+    }
+    result += conversionRate_.targetOffset;
+    result *= conversionRate_.factorDen / conversionRate_.factorNum;
+    result -= conversionRate_.sourceOffset;
+    return result;
+}
+
+ConversionInfo UnitsConverter::getConversionInfo() const {
+    ConversionInfo result;
+    result.conversionRate = conversionRate_.factorNum / conversionRate_.factorDen;
+    result.offset =
+        (conversionRate_.sourceOffset * (conversionRate_.factorNum / conversionRate_.factorDen)) -
+        conversionRate_.targetOffset;
+    result.reciprocal = conversionRate_.reciprocal;
+
+    return result;
+}
+
+} // namespace units
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/units_converter.h b/deps/icu-small/source/i18n/units_converter.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b83155a17b57132de9e0ea658f21533c8759154
--- /dev/null
+++ b/deps/icu-small/source/i18n/units_converter.h
@@ -0,0 +1,220 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __UNITS_CONVERTER_H__
+#define __UNITS_CONVERTER_H__
+
+#include "cmemory.h"
+#include "measunit_impl.h"
+#include "unicode/errorcode.h"
+#include "unicode/stringpiece.h"
+#include "unicode/uobject.h"
+#include "units_converter.h"
+#include "units_data.h"
+
+U_NAMESPACE_BEGIN
+namespace units {
+
+/* Internal Structure */
+
+// Constants corresponding to unitConstants in CLDR's units.xml.
+enum Constants {
+    CONSTANT_FT2M,       // ft_to_m
+    CONSTANT_PI,         // PI
+    CONSTANT_GRAVITY,    // Gravity of earth (9.80665 m/s^2), "g".
+    CONSTANT_G,          // Newtonian constant of gravitation, "G".
+    CONSTANT_GAL_IMP2M3, // Gallon imp to m3
+    CONSTANT_LB2KG,      // Pound to Kilogram
+    CONSTANT_GLUCOSE_MOLAR_MASS,
+    CONSTANT_ITEM_PER_MOLE,
+
+    // Must be the last element.
+    CONSTANTS_COUNT
+};
+
+// These values are a hard-coded subset of unitConstants in the units
+// resources file. A unit test checks that all constants in the resource
+// file are at least recognised by the code. Derived constants' values or
+// hard-coded derivations are not checked.
+// In ICU4J, these constants live in UnitConverter.Factor.getConversionRate().
+static const double constantsValues[CONSTANTS_COUNT] = {
+    0.3048,                    // CONSTANT_FT2M
+    411557987.0 / 131002976.0, // CONSTANT_PI
+    9.80665,                   // CONSTANT_GRAVITY
+    6.67408E-11,               // CONSTANT_G
+    0.00454609,                // CONSTANT_GAL_IMP2M3
+    0.45359237,                // CONSTANT_LB2KG
+    180.1557,                  // CONSTANT_GLUCOSE_MOLAR_MASS
+    6.02214076E+23,            // CONSTANT_ITEM_PER_MOLE
+};
+
+typedef enum Signum {
+    NEGATIVE = -1,
+    POSITIVE = 1,
+} Signum;
+
+/* Represents a conversion factor */
+struct U_I18N_API Factor {
+    double factorNum = 1;
+    double factorDen = 1;
+    double offset = 0;
+    bool reciprocal = false;
+
+    // Exponents for the symbolic constants
+    int32_t constantExponents[CONSTANTS_COUNT] = {};
+
+    void multiplyBy(const Factor &rhs);
+    void divideBy(const Factor &rhs);
+
+    // Apply the power to the factor.
+    void power(int32_t power);
+
+    // Apply SI or binary prefix to the Factor.
+    void applyPrefix(UMeasurePrefix unitPrefix);
+
+    // Does an in-place substition of the "symbolic constants" based on
+    // constantExponents (resetting the exponents).
+    //
+    // In ICU4J, see UnitConverter.Factor.getConversionRate().
+    void substituteConstants();
+};
+
+struct U_I18N_API ConversionInfo {
+    double conversionRate;
+    double offset;
+    bool reciprocal;
+};
+
+/*
+ * Adds a single factor element to the `Factor`. e.g "ft3m", "2.333" or "cup2m3". But not "cup2m3^3".
+ */
+void U_I18N_API addSingleFactorConstant(StringPiece baseStr, int32_t power, Signum sigNum,
+                                        Factor &factor, UErrorCode &status);
+
+/**
+ * Represents the conversion rate between `source` and `target`.
+ */
+struct U_I18N_API ConversionRate : public UMemory {
+    const MeasureUnitImpl source;
+    const MeasureUnitImpl target;
+    double factorNum = 1;
+    double factorDen = 1;
+    double sourceOffset = 0;
+    double targetOffset = 0;
+    bool reciprocal = false;
+
+    ConversionRate(MeasureUnitImpl &&source, MeasureUnitImpl &&target)
+        : source(std::move(source)), target(std::move(target)) {}
+};
+
+enum Convertibility {
+    RECIPROCAL,
+    CONVERTIBLE,
+    UNCONVERTIBLE,
+};
+
+MeasureUnitImpl U_I18N_API extractCompoundBaseUnit(const MeasureUnitImpl &source,
+                                                   const ConversionRates &conversionRates,
+                                                   UErrorCode &status);
+
+/**
+ * Check if the convertibility between `source` and `target`.
+ * For example:
+ *    `meter` and `foot` are `CONVERTIBLE`.
+ *    `meter-per-second` and `second-per-meter` are `RECIPROCAL`.
+ *    `meter` and `pound` are `UNCONVERTIBLE`.
+ *
+ * NOTE:
+ *    Only works with SINGLE and COMPOUND units. If one of the units is a
+ *    MIXED unit, an error will occur. For more information, see UMeasureUnitComplexity.
+ */
+Convertibility U_I18N_API extractConvertibility(const MeasureUnitImpl &source,
+                                                const MeasureUnitImpl &target,
+                                                const ConversionRates &conversionRates,
+                                                UErrorCode &status);
+
+/**
+ * Converts from a source `MeasureUnit` to a target `MeasureUnit`.
+ *
+ * NOTE:
+ *    Only works with SINGLE and COMPOUND units. If one of the units is a
+ *    MIXED unit, an error will occur. For more information, see UMeasureUnitComplexity.
+ */
+class U_I18N_API UnitsConverter : public UMemory {
+  public:
+    /**
+     * Constructor of `UnitConverter`.
+     * NOTE:
+     *   - source and target must be under the same category
+     *      - e.g. meter to mile --> both of them are length units.
+     * NOTE:
+     *    This constructor creates an instance of `ConversionRates` internally.
+     *
+     * @param sourceIdentifier represents the source unit identifier.
+     * @param targetIdentifier represents the target unit identifier.
+     * @param status
+     */
+    UnitsConverter(StringPiece sourceIdentifier, StringPiece targetIdentifier, UErrorCode &status);
+
+    /**
+     * Constructor of `UnitConverter`.
+     * NOTE:
+     *   - source and target must be under the same category
+     *      - e.g. meter to mile --> both of them are length units.
+     *
+     * @param source represents the source unit.
+     * @param target represents the target unit.
+     * @param ratesInfo Contains all the needed conversion rates.
+     * @param status
+     */
+    UnitsConverter(const MeasureUnitImpl &source, const MeasureUnitImpl &target,
+                  const ConversionRates &ratesInfo, UErrorCode &status);
+
+    /**
+     * Compares two single units and returns 1 if the first one is greater, -1 if the second
+     * one is greater and 0 if they are equal.
+     *
+     * NOTE:
+     *  Compares only single units that are convertible.
+     */
+    static int32_t compareTwoUnits(const MeasureUnitImpl &firstUnit, const MeasureUnitImpl &SecondUnit,
+                                   const ConversionRates &ratesInfo, UErrorCode &status);
+
+    /**
+     * Convert a measurement expressed in the source unit to a measurement
+     * expressed in the target unit.
+     *
+     * @param inputValue the value to be converted.
+     * @return the converted value.
+     */
+    double convert(double inputValue) const;
+
+    /**
+     * The inverse of convert(): convert a measurement expressed in the target
+     * unit to a measurement expressed in the source unit.
+     *
+     * @param inputValue the value to be converted.
+     * @return the converted value.
+     */
+    double convertInverse(double inputValue) const;
+
+    ConversionInfo getConversionInfo() const;
+
+  private:
+    ConversionRate conversionRate_;
+
+    /**
+     * Initialises the object.
+     */
+    void init(const ConversionRates &ratesInfo, UErrorCode &status);
+};
+
+} // namespace units
+U_NAMESPACE_END
+
+#endif //__UNITS_CONVERTER_H__
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/units_data.cpp b/deps/icu-small/source/i18n/units_data.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..61f537479fa9086aa3be98781f4607b26d3f8084
--- /dev/null
+++ b/deps/icu-small/source/i18n/units_data.cpp
@@ -0,0 +1,413 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "cstring.h"
+#include "number_decimalquantity.h"
+#include "resource.h"
+#include "uassert.h"
+#include "unicode/unistr.h"
+#include "unicode/ures.h"
+#include "units_data.h"
+#include "uresimp.h"
+#include "util.h"
+#include <utility>
+
+U_NAMESPACE_BEGIN
+namespace units {
+
+namespace {
+
+using icu::number::impl::DecimalQuantity;
+
+void trimSpaces(CharString& factor, UErrorCode& status){
+   CharString trimmed;
+   for (int i = 0 ; i < factor.length(); i++) {
+       if (factor[i] == ' ') continue;
+
+       trimmed.append(factor[i], status);
+   }
+
+   factor = std::move(trimmed);
+}
+
+/**
+ * A ResourceSink that collects conversion rate information.
+ *
+ * This class is for use by ures_getAllItemsWithFallback.
+ */
+class ConversionRateDataSink : public ResourceSink {
+  public:
+    /**
+     * Constructor.
+     * @param out The vector to which ConversionRateInfo instances are to be
+     * added. This vector must outlive the use of the ResourceSink.
+     */
+    explicit ConversionRateDataSink(MaybeStackVector<ConversionRateInfo> *out) : outVector(out) {}
+
+    /**
+     * Method for use by `ures_getAllItemsWithFallback`. Adds the unit
+     * conversion rates that are found in `value` to the output vector.
+     *
+     * @param source This string must be "convertUnits": the resource that this
+     * class supports reading.
+     * @param value The "convertUnits" resource, containing unit conversion rate
+     * information.
+     * @param noFallback Ignored.
+     * @param status The standard ICU error code output parameter.
+     */
+    void put(const char *source, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) {
+        if (U_FAILURE(status)) { return; }
+        if (uprv_strcmp(source, "convertUnits") != 0) {
+            // This is very strict, however it is the cheapest way to be sure
+            // that with `value`, we're looking at the convertUnits table.
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+            return;
+        }
+        ResourceTable conversionRateTable = value.getTable(status);
+        const char *srcUnit;
+        // We're reusing `value`, which seems to be a common pattern:
+        for (int32_t unit = 0; conversionRateTable.getKeyAndValue(unit, srcUnit, value); unit++) {
+            ResourceTable unitTable = value.getTable(status);
+            const char *key;
+            UnicodeString baseUnit = ICU_Utility::makeBogusString();
+            UnicodeString factor = ICU_Utility::makeBogusString();
+            UnicodeString offset = ICU_Utility::makeBogusString();
+            for (int32_t i = 0; unitTable.getKeyAndValue(i, key, value); i++) {
+                if (uprv_strcmp(key, "target") == 0) {
+                    baseUnit = value.getUnicodeString(status);
+                } else if (uprv_strcmp(key, "factor") == 0) {
+                    factor = value.getUnicodeString(status);
+                } else if (uprv_strcmp(key, "offset") == 0) {
+                    offset = value.getUnicodeString(status);
+                }
+            }
+            if (U_FAILURE(status)) { return; }
+            if (baseUnit.isBogus() || factor.isBogus()) {
+                // We could not find a usable conversion rate: bad resource.
+                status = U_MISSING_RESOURCE_ERROR;
+                return;
+            }
+
+            // We don't have this ConversionRateInfo yet: add it.
+            ConversionRateInfo *cr = outVector->emplaceBack();
+            if (!cr) {
+                status = U_MEMORY_ALLOCATION_ERROR;
+                return;
+            } else {
+                cr->sourceUnit.append(srcUnit, status);
+                cr->baseUnit.appendInvariantChars(baseUnit, status);
+                cr->factor.appendInvariantChars(factor, status);
+                trimSpaces(cr->factor, status);
+                if (!offset.isBogus()) cr->offset.appendInvariantChars(offset, status);
+            }
+        }
+        return;
+    }
+
+  private:
+    MaybeStackVector<ConversionRateInfo> *outVector;
+};
+
+bool operator<(const UnitPreferenceMetadata &a, const UnitPreferenceMetadata &b) {
+    return a.compareTo(b) < 0;
+}
+
+/**
+ * A ResourceSink that collects unit preferences information.
+ *
+ * This class is for use by ures_getAllItemsWithFallback.
+ */
+class UnitPreferencesSink : public ResourceSink {
+  public:
+    /**
+     * Constructor.
+     * @param outPrefs The vector to which UnitPreference instances are to be
+     * added. This vector must outlive the use of the ResourceSink.
+     * @param outMetadata  The vector to which UnitPreferenceMetadata instances
+     * are to be added. This vector must outlive the use of the ResourceSink.
+     */
+    explicit UnitPreferencesSink(MaybeStackVector<UnitPreference> *outPrefs,
+                                 MaybeStackVector<UnitPreferenceMetadata> *outMetadata)
+        : preferences(outPrefs), metadata(outMetadata) {}
+
+    /**
+     * Method for use by `ures_getAllItemsWithFallback`. Adds the unit
+     * preferences info that are found in `value` to the output vector.
+     *
+     * @param source This string must be "unitPreferenceData": the resource that
+     * this class supports reading.
+     * @param value The "unitPreferenceData" resource, containing unit
+     * preferences data.
+     * @param noFallback Ignored.
+     * @param status The standard ICU error code output parameter. Note: if an
+     * error is returned, outPrefs and outMetadata may be inconsistent.
+     */
+    void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) {
+        if (U_FAILURE(status)) { return; }
+        if (uprv_strcmp(key, "unitPreferenceData") != 0) {
+            // This is very strict, however it is the cheapest way to be sure
+            // that with `value`, we're looking at the convertUnits table.
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+            return;
+        }
+        // The unitPreferenceData structure (see data/misc/units.txt) contains a
+        // hierarchy of category/usage/region, within which are a set of
+        // preferences. Hence three for-loops and another loop for the
+        // preferences themselves:
+        ResourceTable unitPreferenceDataTable = value.getTable(status);
+        const char *category;
+        for (int32_t i = 0; unitPreferenceDataTable.getKeyAndValue(i, category, value); i++) {
+            ResourceTable categoryTable = value.getTable(status);
+            const char *usage;
+            for (int32_t j = 0; categoryTable.getKeyAndValue(j, usage, value); j++) {
+                ResourceTable regionTable = value.getTable(status);
+                const char *region;
+                for (int32_t k = 0; regionTable.getKeyAndValue(k, region, value); k++) {
+                    // `value` now contains the set of preferences for
+                    // category/usage/region.
+                    ResourceArray unitPrefs = value.getArray(status);
+                    if (U_FAILURE(status)) { return; }
+                    int32_t prefLen = unitPrefs.getSize();
+
+                    // Update metadata for this set of preferences.
+                    UnitPreferenceMetadata *meta = metadata->emplaceBack(
+                        category, usage, region, preferences->length(), prefLen, status);
+                    if (!meta) {
+                        status = U_MEMORY_ALLOCATION_ERROR;
+                        return;
+                    }
+                    if (U_FAILURE(status)) { return; }
+                    if (metadata->length() > 1) {
+                        // Verify that unit preferences are sorted and
+                        // without duplicates.
+                        if (!(*(*metadata)[metadata->length() - 2] <
+                              *(*metadata)[metadata->length() - 1])) {
+                            status = U_INVALID_FORMAT_ERROR;
+                            return;
+                        }
+                    }
+
+                    // Collect the individual preferences.
+                    for (int32_t i = 0; unitPrefs.getValue(i, value); i++) {
+                        UnitPreference *up = preferences->emplaceBack();
+                        if (!up) {
+                            status = U_MEMORY_ALLOCATION_ERROR;
+                            return;
+                        }
+                        ResourceTable unitPref = value.getTable(status);
+                        if (U_FAILURE(status)) { return; }
+                        for (int32_t i = 0; unitPref.getKeyAndValue(i, key, value); ++i) {
+                            if (uprv_strcmp(key, "unit") == 0) {
+                                int32_t length;
+                                const UChar *u = value.getString(length, status);
+                                up->unit.appendInvariantChars(u, length, status);
+                            } else if (uprv_strcmp(key, "geq") == 0) {
+                                int32_t length;
+                                const UChar *g = value.getString(length, status);
+                                CharString geq;
+                                geq.appendInvariantChars(g, length, status);
+                                DecimalQuantity dq;
+                                dq.setToDecNumber(geq.data(), status);
+                                up->geq = dq.toDouble();
+                            } else if (uprv_strcmp(key, "skeleton") == 0) {
+                                up->skeleton = value.getUnicodeString(status);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+  private:
+    MaybeStackVector<UnitPreference> *preferences;
+    MaybeStackVector<UnitPreferenceMetadata> *metadata;
+};
+
+int32_t binarySearch(const MaybeStackVector<UnitPreferenceMetadata> *metadata,
+                     const UnitPreferenceMetadata &desired, bool *foundCategory, bool *foundUsage,
+                     bool *foundRegion, UErrorCode &status) {
+    if (U_FAILURE(status)) { return -1; }
+    int32_t start = 0;
+    int32_t end = metadata->length();
+    *foundCategory = false;
+    *foundUsage = false;
+    *foundRegion = false;
+    while (start < end) {
+        int32_t mid = (start + end) / 2;
+        int32_t cmp = (*metadata)[mid]->compareTo(desired, foundCategory, foundUsage, foundRegion);
+        if (cmp < 0) {
+            start = mid + 1;
+        } else if (cmp > 0) {
+            end = mid;
+        } else {
+            return mid;
+        }
+    }
+    return -1;
+}
+
+/**
+ * Finds the UnitPreferenceMetadata instance that matches the given category,
+ * usage and region: if missing, region falls back to "001", and usage
+ * repeatedly drops tailing components, eventually trying "default"
+ * ("land-agriculture-grain" -> "land-agriculture" -> "land" -> "default").
+ *
+ * @param metadata The full list of UnitPreferenceMetadata instances.
+ * @param category The category to search for. See getUnitCategory().
+ * @param usage The usage for which formatting preferences is needed. If the
+ * given usage is not known, automatic fallback occurs, see function description
+ * above.
+ * @param region The region for which preferences are needed. If there are no
+ * region-specific preferences, this function automatically falls back to the
+ * "001" region (global).
+ * @param status The standard ICU error code output parameter.
+ *   * If an invalid category is given, status will be U_ILLEGAL_ARGUMENT_ERROR.
+ *   * If fallback to "default" or "001" didn't resolve, status will be
+ *     U_MISSING_RESOURCE.
+ * @return The index into the metadata vector which represents the appropriate
+ * preferences. If appropriate preferences are not found, -1 is returned.
+ */
+int32_t getPreferenceMetadataIndex(const MaybeStackVector<UnitPreferenceMetadata> *metadata,
+                                   StringPiece category, StringPiece usage, StringPiece region,
+                                   UErrorCode &status) {
+    if (U_FAILURE(status)) { return -1; }
+    bool foundCategory, foundUsage, foundRegion;
+    UnitPreferenceMetadata desired(category, usage, region, -1, -1, status);
+    int32_t idx = binarySearch(metadata, desired, &foundCategory, &foundUsage, &foundRegion, status);
+    if (U_FAILURE(status)) { return -1; }
+    if (idx >= 0) { return idx; }
+    if (!foundCategory) {
+        // TODO: failures can happen if units::getUnitCategory returns a category
+        // that does not appear in unitPreferenceData. Do we want a unit test that
+        // checks unitPreferenceData has full coverage of categories? Or just trust
+        // CLDR?
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return -1;
+    }
+    U_ASSERT(foundCategory);
+    while (!foundUsage) {
+        int32_t lastDashIdx = desired.usage.lastIndexOf('-');
+        if (lastDashIdx > 0) {
+            desired.usage.truncate(lastDashIdx);
+        } else if (uprv_strcmp(desired.usage.data(), "default") != 0) {
+            desired.usage.truncate(0).append("default", status);
+        } else {
+            // "default" is not supposed to be missing for any valid category.
+            status = U_MISSING_RESOURCE_ERROR;
+            return -1;
+        }
+        idx = binarySearch(metadata, desired, &foundCategory, &foundUsage, &foundRegion, status);
+        if (U_FAILURE(status)) { return -1; }
+    }
+    U_ASSERT(foundCategory);
+    U_ASSERT(foundUsage);
+    if (!foundRegion) {
+        if (uprv_strcmp(desired.region.data(), "001") != 0) {
+            desired.region.truncate(0).append("001", status);
+            idx = binarySearch(metadata, desired, &foundCategory, &foundUsage, &foundRegion, status);
+        }
+        if (!foundRegion) {
+            // "001" is not supposed to be missing for any valid usage.
+            status = U_MISSING_RESOURCE_ERROR;
+            return -1;
+        }
+    }
+    U_ASSERT(foundCategory);
+    U_ASSERT(foundUsage);
+    U_ASSERT(foundRegion);
+    U_ASSERT(idx >= 0);
+    return idx;
+}
+
+} // namespace
+
+UnitPreferenceMetadata::UnitPreferenceMetadata(StringPiece category, StringPiece usage,
+                                               StringPiece region, int32_t prefsOffset,
+                                               int32_t prefsCount, UErrorCode &status) {
+    this->category.append(category, status);
+    this->usage.append(usage, status);
+    this->region.append(region, status);
+    this->prefsOffset = prefsOffset;
+    this->prefsCount = prefsCount;
+}
+
+int32_t UnitPreferenceMetadata::compareTo(const UnitPreferenceMetadata &other) const {
+    int32_t cmp = uprv_strcmp(category.data(), other.category.data());
+    if (cmp == 0) {
+        cmp = uprv_strcmp(usage.data(), other.usage.data());
+    }
+    if (cmp == 0) {
+        cmp = uprv_strcmp(region.data(), other.region.data());
+    }
+    return cmp;
+}
+
+int32_t UnitPreferenceMetadata::compareTo(const UnitPreferenceMetadata &other, bool *foundCategory,
+                                          bool *foundUsage, bool *foundRegion) const {
+    int32_t cmp = uprv_strcmp(category.data(), other.category.data());
+    if (cmp == 0) {
+        *foundCategory = true;
+        cmp = uprv_strcmp(usage.data(), other.usage.data());
+    }
+    if (cmp == 0) {
+        *foundUsage = true;
+        cmp = uprv_strcmp(region.data(), other.region.data());
+    }
+    if (cmp == 0) {
+        *foundRegion = true;
+    }
+    return cmp;
+}
+
+// TODO: this may be unnecessary. Fold into ConversionRates class? Or move to anonymous namespace?
+void U_I18N_API getAllConversionRates(MaybeStackVector<ConversionRateInfo> &result, UErrorCode &status) {
+    LocalUResourceBundlePointer unitsBundle(ures_openDirect(NULL, "units", &status));
+    ConversionRateDataSink sink(&result);
+    ures_getAllItemsWithFallback(unitsBundle.getAlias(), "convertUnits", sink, status);
+}
+
+const ConversionRateInfo *ConversionRates::extractConversionInfo(StringPiece source,
+                                                                 UErrorCode &status) const {
+    for (size_t i = 0, n = conversionInfo_.length(); i < n; ++i) {
+        if (conversionInfo_[i]->sourceUnit.toStringPiece() == source) return conversionInfo_[i];
+    }
+
+    status = U_INTERNAL_PROGRAM_ERROR;
+    return nullptr;
+}
+
+U_I18N_API UnitPreferences::UnitPreferences(UErrorCode &status) {
+    LocalUResourceBundlePointer unitsBundle(ures_openDirect(NULL, "units", &status));
+    UnitPreferencesSink sink(&unitPrefs_, &metadata_);
+    ures_getAllItemsWithFallback(unitsBundle.getAlias(), "unitPreferenceData", sink, status);
+}
+
+// TODO: make outPreferences const?
+//
+// TODO: consider replacing `UnitPreference **&outPreferences` with slice class
+// of some kind.
+void U_I18N_API UnitPreferences::getPreferencesFor(StringPiece category, StringPiece usage,
+                                                   StringPiece region,
+                                                   const UnitPreference *const *&outPreferences,
+                                                   int32_t &preferenceCount, UErrorCode &status) const {
+    int32_t idx = getPreferenceMetadataIndex(&metadata_, category, usage, region, status);
+    if (U_FAILURE(status)) {
+        outPreferences = nullptr;
+        preferenceCount = 0;
+        return;
+    }
+    U_ASSERT(idx >= 0); // Failures should have been taken care of by `status`.
+    const UnitPreferenceMetadata *m = metadata_[idx];
+    outPreferences = unitPrefs_.getAlias() + m->prefsOffset;
+    preferenceCount = m->prefsCount;
+}
+
+} // namespace units
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/units_data.h b/deps/icu-small/source/i18n/units_data.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c19b9434bd02b49180544e46902112c782a8ec9
--- /dev/null
+++ b/deps/icu-small/source/i18n/units_data.h
@@ -0,0 +1,213 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __UNITS_DATA_H__
+#define __UNITS_DATA_H__
+
+#include <limits>
+
+#include "charstr.h"
+#include "cmemory.h"
+#include "unicode/stringpiece.h"
+#include "unicode/uobject.h"
+
+U_NAMESPACE_BEGIN
+namespace units {
+
+/**
+ * Encapsulates "convertUnits" information from units resources, specifying how
+ * to convert from one unit to another.
+ *
+ * Information in this class is still in the form of strings: symbolic constants
+ * need to be interpreted. Rationale: symbols can cancel out for higher
+ * precision conversion - going from feet to inches should cancel out the
+ * `ft_to_m` constant.
+ */
+class U_I18N_API ConversionRateInfo : public UMemory {
+  public:
+    ConversionRateInfo() {}
+    ConversionRateInfo(StringPiece sourceUnit, StringPiece baseUnit, StringPiece factor,
+                       StringPiece offset, UErrorCode &status)
+        : sourceUnit(), baseUnit(), factor(), offset() {
+        this->sourceUnit.append(sourceUnit, status);
+        this->baseUnit.append(baseUnit, status);
+        this->factor.append(factor, status);
+        this->offset.append(offset, status);
+    }
+    CharString sourceUnit;
+    CharString baseUnit;
+    CharString factor;
+    CharString offset;
+};
+
+} // namespace units
+
+// Export explicit template instantiations of MaybeStackArray, MemoryPool and
+// MaybeStackVector. This is required when building DLLs for Windows. (See
+// datefmt.h, collationiterator.h, erarules.h and others for similar examples.)
+//
+// Note: These need to be outside of the units namespace, or Clang will generate
+// a compile error.
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<units::ConversionRateInfo*, 8>;
+template class U_I18N_API MemoryPool<units::ConversionRateInfo, 8>;
+template class U_I18N_API MaybeStackVector<units::ConversionRateInfo, 8>;
+#endif
+
+namespace units {
+
+/**
+ * Returns ConversionRateInfo for all supported conversions.
+ *
+ * @param result Receives the set of conversion rates.
+ * @param status Receives status.
+ */
+void U_I18N_API getAllConversionRates(MaybeStackVector<ConversionRateInfo> &result, UErrorCode &status);
+
+/**
+ * Contains all the supported conversion rates.
+ */
+class U_I18N_API ConversionRates {
+  public:
+    /**
+     * Constructor
+     *
+     * @param status Receives status.
+     */
+    ConversionRates(UErrorCode &status) { getAllConversionRates(conversionInfo_, status); }
+
+    /**
+     * Returns a pointer to the conversion rate info that match the `source`.
+     *
+     * @param source Contains the source.
+     * @param status Receives status.
+     */
+    const ConversionRateInfo *extractConversionInfo(StringPiece source, UErrorCode &status) const;
+
+  private:
+    MaybeStackVector<ConversionRateInfo> conversionInfo_;
+};
+
+// Encapsulates unitPreferenceData information from units resources, specifying
+// a sequence of output unit preferences.
+struct U_I18N_API UnitPreference : public UMemory {
+    // Set geq to 1.0 by default
+    UnitPreference() : geq(1.0) {}
+    CharString unit;
+    double geq;
+    UnicodeString skeleton;
+};
+
+/**
+ * Metadata about the preferences in UnitPreferences::unitPrefs_.
+ *
+ * This class owns all of its data.
+ *
+ * UnitPreferenceMetadata lives in the anonymous namespace, because it should
+ * only be useful to internal code and unit testing code.
+ */
+class U_I18N_API UnitPreferenceMetadata : public UMemory {
+  public:
+    UnitPreferenceMetadata() {}
+    // Constructor, makes copies of the parameters passed to it.
+    UnitPreferenceMetadata(StringPiece category, StringPiece usage, StringPiece region,
+                           int32_t prefsOffset, int32_t prefsCount, UErrorCode &status);
+
+    // Unit category (e.g. "length", "mass", "electric-capacitance").
+    CharString category;
+    // Usage (e.g. "road", "vehicle-fuel", "blood-glucose"). Every category
+    // should have an entry for "default" usage. TODO(hugovdm): add a test for
+    // this.
+    CharString usage;
+    // Region code (e.g. "US", "CZ", "001"). Every usage should have an entry
+    // for the "001" region ("world"). TODO(hugovdm): add a test for this.
+    CharString region;
+    // Offset into the UnitPreferences::unitPrefs_ list where the relevant
+    // preferences are found.
+    int32_t prefsOffset;
+    // The number of preferences that form this set.
+    int32_t prefsCount;
+
+    int32_t compareTo(const UnitPreferenceMetadata &other) const;
+    int32_t compareTo(const UnitPreferenceMetadata &other, bool *foundCategory, bool *foundUsage,
+                      bool *foundRegion) const;
+};
+
+} // namespace units
+
+// Export explicit template instantiations of MaybeStackArray, MemoryPool and
+// MaybeStackVector. This is required when building DLLs for Windows. (See
+// datefmt.h, collationiterator.h, erarules.h and others for similar examples.)
+//
+// Note: These need to be outside of the units namespace, or Clang will generate
+// a compile error.
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<units::UnitPreferenceMetadata*, 8>;
+template class U_I18N_API MemoryPool<units::UnitPreferenceMetadata, 8>;
+template class U_I18N_API MaybeStackVector<units::UnitPreferenceMetadata, 8>;
+template class U_I18N_API MaybeStackArray<units::UnitPreference*, 8>;
+template class U_I18N_API MemoryPool<units::UnitPreference, 8>;
+template class U_I18N_API MaybeStackVector<units::UnitPreference, 8>;
+#endif
+
+namespace units {
+
+/**
+ * Unit Preferences information for various locales and usages.
+ */
+class U_I18N_API UnitPreferences {
+  public:
+    /**
+     * Constructor, loads all the preference data.
+     *
+     * @param status Receives status.
+     */
+    UnitPreferences(UErrorCode &status);
+
+    /**
+     * Returns the set of unit preferences in the particular category that best
+     * matches the specified usage and region.
+     *
+     * If region can't be found, falls back to global (001). If usage can't be
+     * found, falls back to "default".
+     *
+     * @param category The category within which to look up usage and region.
+     * (TODO(hugovdm): improve docs on how to find the category, once the lookup
+     * function is added.)
+     * @param usage The usage parameter. (TODO(hugovdm): improve this
+     * documentation. Add reference to some list of usages we support.) If the
+     * given usage is not found, the method automatically falls back to
+     * "default".
+     * @param region The region whose preferences are desired. If there are no
+     * specific preferences for the requested region, the method automatically
+     * falls back to region "001" ("world").
+     * @param outPreferences A pointer into an array of preferences: essentially
+     * an array slice in combination with preferenceCount.
+     * @param preferenceCount The number of unit preferences that belong to the
+     * result set.
+     * @param status Receives status.
+     *
+     * TODO(hugovdm): maybe replace `UnitPreference **&outPreferences` with a slice class?
+     */
+    void getPreferencesFor(StringPiece category, StringPiece usage, StringPiece region,
+                           const UnitPreference *const *&outPreferences, int32_t &preferenceCount,
+                           UErrorCode &status) const;
+
+  protected:
+    // Metadata about the sets of preferences, this is the index for looking up
+    // preferences in the unitPrefs_ list.
+    MaybeStackVector<UnitPreferenceMetadata> metadata_;
+    // All the preferences as a flat list: which usage and region preferences
+    // are associated with is stored in `metadata_`.
+    MaybeStackVector<UnitPreference> unitPrefs_;
+};
+
+} // namespace units
+U_NAMESPACE_END
+
+#endif //__UNITS_DATA_H__
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/units_router.cpp b/deps/icu-small/source/i18n/units_router.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..51f66bfa892be7ec309619281562d5721bbac2a5
--- /dev/null
+++ b/deps/icu-small/source/i18n/units_router.cpp
@@ -0,0 +1,152 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "charstr.h"
+#include "cmemory.h"
+#include "cstring.h"
+#include "measunit_impl.h"
+#include "number_decimalquantity.h"
+#include "number_roundingutils.h"
+#include "resource.h"
+#include "unicode/measure.h"
+#include "units_data.h"
+#include "units_router.h"
+#include <cmath>
+
+U_NAMESPACE_BEGIN
+namespace units {
+
+using number::Precision;
+using number::impl::parseIncrementOption;
+
+Precision UnitsRouter::parseSkeletonToPrecision(icu::UnicodeString precisionSkeleton,
+                                                UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        // As a member of UsagePrefsHandler, which is a friend of Precision, we
+        // get access to the default constructor.
+        return {};
+    }
+    constexpr int32_t kSkelPrefixLen = 20;
+    if (!precisionSkeleton.startsWith(UNICODE_STRING_SIMPLE("precision-increment/"))) {
+        status = U_INVALID_FORMAT_ERROR;
+        return {};
+    }
+    U_ASSERT(precisionSkeleton[kSkelPrefixLen - 1] == u'/');
+    StringSegment segment(precisionSkeleton, false);
+    segment.adjustOffset(kSkelPrefixLen);
+    Precision result;
+    parseIncrementOption(segment, result, status);
+    return result;
+}
+
+UnitsRouter::UnitsRouter(StringPiece inputUnitIdentifier, StringPiece region, StringPiece usage,
+                         UErrorCode &status) {
+    this->init(MeasureUnit::forIdentifier(inputUnitIdentifier, status), region, usage, status);
+}
+
+UnitsRouter::UnitsRouter(const MeasureUnit &inputUnit, StringPiece region, StringPiece usage,
+                         UErrorCode &status) {
+    this->init(std::move(inputUnit), region, usage, status);
+}
+
+void UnitsRouter::init(const MeasureUnit &inputUnit, StringPiece region, StringPiece usage,
+                       UErrorCode &status) {
+
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    // TODO: do we want to pass in ConversionRates and UnitPreferences instead
+    // of loading in each UnitsRouter instance? (Or make global?)
+    ConversionRates conversionRates(status);
+    UnitPreferences prefs(status);
+
+    MeasureUnitImpl inputUnitImpl = MeasureUnitImpl::forMeasureUnitMaybeCopy(inputUnit, status);
+    MeasureUnit baseUnit =
+        (extractCompoundBaseUnit(inputUnitImpl, conversionRates, status)).build(status);
+    CharString category = getUnitQuantity(baseUnit.getIdentifier(), status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    const UnitPreference *const *unitPreferences;
+    int32_t preferencesCount = 0;
+    prefs.getPreferencesFor(category.toStringPiece(), usage, region, unitPreferences, preferencesCount,
+                            status);
+
+    for (int i = 0; i < preferencesCount; ++i) {
+        U_ASSERT(unitPreferences[i] != nullptr);
+        const auto &preference = *unitPreferences[i];
+
+        MeasureUnitImpl complexTargetUnitImpl =
+            MeasureUnitImpl::forIdentifier(preference.unit.data(), status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+
+        UnicodeString precision = preference.skeleton;
+
+        // For now, we only have "precision-increment" in Units Preferences skeleton.
+        // Therefore, we check if the skeleton starts with "precision-increment" and force the program to
+        // fail otherwise.
+        // NOTE:
+        //  It is allowed to have an empty precision.
+        if (!precision.isEmpty() && !precision.startsWith(u"precision-increment", 19)) {
+            status = U_INTERNAL_PROGRAM_ERROR;
+            return;
+        }
+
+        outputUnits_.emplaceBackAndCheckErrorCode(status,
+                                                  complexTargetUnitImpl.copy(status).build(status));
+        converterPreferences_.emplaceBackAndCheckErrorCode(status, inputUnitImpl, complexTargetUnitImpl,
+                                                           preference.geq, std::move(precision),
+                                                           conversionRates, status);
+
+        if (U_FAILURE(status)) {
+            return;
+        }
+    }
+}
+
+RouteResult UnitsRouter::route(double quantity, icu::number::impl::RoundingImpl *rounder, UErrorCode &status) const {
+    // Find the matching preference
+    const ConverterPreference *converterPreference = nullptr;
+    for (int32_t i = 0, n = converterPreferences_.length(); i < n; i++) {
+        converterPreference = converterPreferences_[i];
+        if (converterPreference->converter.greaterThanOrEqual(std::abs(quantity) * (1 + DBL_EPSILON),
+                                                              converterPreference->limit)) {
+            break;
+        }
+    }
+    U_ASSERT(converterPreference != nullptr);
+
+    // Set up the rounder for this preference's precision
+    if (rounder != nullptr && rounder->fPrecision.isBogus()) {
+        if (converterPreference->precision.length() > 0) {
+            rounder->fPrecision = parseSkeletonToPrecision(converterPreference->precision, status);
+        } else {
+            // We use the same rounding mode as COMPACT notation: known to be a
+            // human-friendly rounding mode: integers, but add a decimal digit
+            // as needed to ensure we have at least 2 significant digits.
+            rounder->fPrecision = Precision::integer().withMinDigits(2);
+        }
+    }
+
+    return RouteResult(converterPreference->converter.convert(quantity, rounder, status),
+                       converterPreference->targetUnit.copy(status));
+}
+
+const MaybeStackVector<MeasureUnit> *UnitsRouter::getOutputUnits() const {
+    // TODO: consider pulling this from converterPreferences_ and dropping
+    // outputUnits_?
+    return &outputUnits_;
+}
+
+} // namespace units
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/units_router.h b/deps/icu-small/source/i18n/units_router.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6e4e4f52883639c9ff11004ca11c6a01d8c8615
--- /dev/null
+++ b/deps/icu-small/source/i18n/units_router.h
@@ -0,0 +1,166 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __UNITS_ROUTER_H__
+#define __UNITS_ROUTER_H__
+
+#include <limits>
+
+#include "cmemory.h"
+#include "measunit_impl.h"
+#include "unicode/measunit.h"
+#include "unicode/stringpiece.h"
+#include "unicode/uobject.h"
+#include "units_complexconverter.h"
+#include "units_data.h"
+
+U_NAMESPACE_BEGIN
+
+// Forward declarations
+class Measure;
+namespace number {
+class Precision;
+}
+
+namespace units {
+
+struct RouteResult : UMemory {
+    // A list of measures: a single measure for single units, multiple measures
+    // for mixed units.
+    //
+    // TODO(icu-units/icu#21): figure out the right mixed unit API.
+    MaybeStackVector<Measure> measures;
+
+    // The output unit for this RouteResult. This may be a MIXED unit - for
+    // example: "yard-and-foot-and-inch", for which `measures` will have three
+    // elements.
+    MeasureUnitImpl outputUnit;
+
+    RouteResult(MaybeStackVector<Measure> measures, MeasureUnitImpl outputUnit)
+        : measures(std::move(measures)), outputUnit(std::move(outputUnit)) {}
+};
+
+/**
+ * Contains the complex unit converter and the limit which representing the smallest value that the
+ * converter should accept. For example, if the converter is converting to `foot+inch` and the limit
+ * equals 3.0, thus means the converter should not convert to a value less than `3.0 feet`.
+ *
+ * NOTE:
+ *    if the limit doest not has a value `i.e. (std::numeric_limits<double>::lowest())`, this mean there
+ *    is no limit for the converter.
+ */
+struct ConverterPreference : UMemory {
+    ComplexUnitsConverter converter;
+    double limit;
+    UnicodeString precision;
+
+    // The output unit for this ConverterPreference. This may be a MIXED unit -
+    // for example: "yard-and-foot-and-inch".
+    MeasureUnitImpl targetUnit;
+
+    // In case there is no limit, the limit will be -inf.
+    ConverterPreference(const MeasureUnitImpl &source, const MeasureUnitImpl &complexTarget,
+                        UnicodeString precision, const ConversionRates &ratesInfo, UErrorCode &status)
+        : ConverterPreference(source, complexTarget, std::numeric_limits<double>::lowest(), precision,
+                              ratesInfo, status) {}
+
+    ConverterPreference(const MeasureUnitImpl &source, const MeasureUnitImpl &complexTarget,
+                        double limit, UnicodeString precision, const ConversionRates &ratesInfo,
+                        UErrorCode &status)
+        : converter(source, complexTarget, ratesInfo, status), limit(limit),
+          precision(std::move(precision)), targetUnit(complexTarget.copy(status)) {}
+};
+
+} // namespace units
+
+// Export explicit template instantiations of MaybeStackArray, MemoryPool and
+// MaybeStackVector. This is required when building DLLs for Windows. (See
+// datefmt.h, collationiterator.h, erarules.h and others for similar examples.)
+//
+// Note: These need to be outside of the units namespace, or Clang will generate
+// a compile error.
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<units::ConverterPreference*, 8>;
+template class U_I18N_API MemoryPool<units::ConverterPreference, 8>;
+template class U_I18N_API MaybeStackVector<units::ConverterPreference, 8>;
+#endif
+
+namespace units {
+
+/**
+ * `UnitsRouter` responsible for converting from a single unit (such as `meter` or `meter-per-second`) to
+ * one of the complex units based on the limits.
+ * For example:
+ *    if the input is `meter` and the output as following
+ *    {`foot+inch`, limit: 3.0}
+ *    {`inch`     , limit: no value (-inf)}
+ *    Thus means if the input in `meter` is greater than or equal to `3.0 feet`, the output will be in
+ *    `foot+inch`, otherwise, the output will be in `inch`.
+ *
+ * NOTE:
+ *    the output units and the their limits MUST BE in order, for example, if the output units, from the
+ *    previous example, are the following:
+ *        {`inch`     , limit: no value (-inf)}
+ *        {`foot+inch`, limit: 3.0}
+ *     IN THIS CASE THE OUTPUT WILL BE ALWAYS IN `inch`.
+ *
+ * NOTE:
+ *    the output units  and their limits will be extracted from the units preferences database by knowing
+ *    the followings:
+ *        - input unit
+ *        - locale
+ *        - usage
+ *
+ * DESIGN:
+ *    `UnitRouter` uses internally `ComplexUnitConverter` in order to convert the input units to the
+ *    desired complex units and to check the limit too.
+ */
+class U_I18N_API UnitsRouter {
+  public:
+    UnitsRouter(StringPiece inputUnitIdentifier, StringPiece locale, StringPiece usage,
+                UErrorCode &status);
+    UnitsRouter(const MeasureUnit &inputUnit, StringPiece locale, StringPiece usage, UErrorCode &status);
+
+    /**
+     * Performs locale and usage sensitive unit conversion.
+     * @param quantity The quantity to convert, expressed in terms of inputUnit.
+     * @param rounder If not null, this RoundingImpl will be used to do rounding
+     *     on the converted value. If the rounder lacks an fPrecision, the
+     *     rounder will be modified to use the preferred precision for the usage
+     *     and locale preference, alternatively with the default precision.
+     * @param status Receives status.
+     */
+    RouteResult route(double quantity, icu::number::impl::RoundingImpl *rounder, UErrorCode &status) const;
+
+    /**
+     * Returns the list of possible output units, i.e. the full set of
+     * preferences, for the localized, usage-specific unit preferences.
+     *
+     * The returned pointer should be valid for the lifetime of the
+     * UnitsRouter instance.
+     */
+    const MaybeStackVector<MeasureUnit> *getOutputUnits() const;
+
+  private:
+    // List of possible output units. TODO: converterPreferences_ now also has
+    // this data available. Maybe drop outputUnits_ and have getOutputUnits
+    // construct a the list from data in converterPreferences_ instead?
+    MaybeStackVector<MeasureUnit> outputUnits_;
+
+    MaybeStackVector<ConverterPreference> converterPreferences_;
+
+    static number::Precision parseSkeletonToPrecision(icu::UnicodeString precisionSkeleton,
+                                                      UErrorCode &status);
+
+    void init(const MeasureUnit &inputUnit, StringPiece locale, StringPiece usage, UErrorCode &status);
+};
+
+} // namespace units
+U_NAMESPACE_END
+
+#endif //__UNITS_ROUTER_H__
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/unum.cpp b/deps/icu-small/source/i18n/unum.cpp
index ba3d519162ce54895d0d4525b7979d5499efeeb2..de693fc7276244c81a73041b20781ef102d678a4 100644
--- a/deps/icu-small/source/i18n/unum.cpp
+++ b/deps/icu-small/source/i18n/unum.cpp
@@ -898,7 +898,7 @@ unum_getContext(const UNumberFormat *fmt, UDisplayContextType type, UErrorCode*
     return ((const NumberFormat*)fmt)->getContext(type, *status);
 }
 
-U_INTERNAL UFormattable * U_EXPORT2
+U_CAPI UFormattable * U_EXPORT2
 unum_parseToUFormattable(const UNumberFormat* fmt,
                          UFormattable *result,
                          const UChar* text,
@@ -922,7 +922,7 @@ unum_parseToUFormattable(const UNumberFormat* fmt,
   return result;
 }
 
-U_INTERNAL int32_t U_EXPORT2
+U_CAPI int32_t U_EXPORT2
 unum_formatUFormattable(const UNumberFormat* fmt,
                         const UFormattable *number,
                         UChar *result,
diff --git a/deps/icu-small/source/i18n/upluralrules.cpp b/deps/icu-small/source/i18n/upluralrules.cpp
index 5119257fd804f7d9aa92755ad05a0faa3b9a5d01..73e59a75c4d016593439edc8cd212596b2a76f37 100644
--- a/deps/icu-small/source/i18n/upluralrules.cpp
+++ b/deps/icu-small/source/i18n/upluralrules.cpp
@@ -20,6 +20,7 @@
 #include "unicode/unumberformatter.h"
 #include "number_decimalquantity.h"
 #include "number_utypes.h"
+#include "numrange_impl.h"
 
 U_NAMESPACE_USE
 
@@ -115,6 +116,25 @@ uplrules_selectFormatted(const UPluralRules *uplrules,
     return result.extract(keyword, capacity, *status);
 }
 
+U_CAPI int32_t U_EXPORT2
+uplrules_selectForRange(const UPluralRules *uplrules,
+                const UFormattedNumberRange* urange,
+                UChar *keyword, int32_t capacity,
+                UErrorCode *status)
+{
+    if (U_FAILURE(*status)) {
+        return 0;
+    }
+    if (keyword == NULL ? capacity != 0 : capacity < 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return 0;
+    }
+    const number::impl::UFormattedNumberRangeData* impl =
+        number::impl::validateUFormattedNumberRange(urange, *status);
+    UnicodeString result = ((PluralRules*)uplrules)->select(impl, *status);
+    return result.extract(keyword, capacity, *status);
+}
+
 U_CAPI int32_t U_EXPORT2
 uplrules_selectWithFormat(const UPluralRules *uplrules,
                           double number,
diff --git a/deps/icu-small/source/i18n/usearch.cpp b/deps/icu-small/source/i18n/usearch.cpp
index 1b22e201e5329439d3da37bd45b4ced4340fe605..47da3d7364de3fc0324bd47a778a59e02ee59dfc 100644
--- a/deps/icu-small/source/i18n/usearch.cpp
+++ b/deps/icu-small/source/i18n/usearch.cpp
@@ -4061,7 +4061,7 @@ U_CAPI UBool U_EXPORT2 usearch_search(UStringSearch  *strsrch,
         // * do NOT require that match limit be on a breakIter boundary
 
         //  Advance the match end position to the first acceptable match boundary.
-        //    This advances the index over any combining charcters.
+        //    This advances the index over any combining characters.
         mLimit = maxLimit;
         if (minLimit < maxLimit) {
             // When the last CE's low index is same with its high index, the CE is likely
diff --git a/deps/icu-small/source/i18n/uspoof_conf.cpp b/deps/icu-small/source/i18n/uspoof_conf.cpp
index 672b3e0a6c8023a7df64224a506deda6f8f8e286..f3f649d5d2c25962e800d64973bd077b779c8337 100644
--- a/deps/icu-small/source/i18n/uspoof_conf.cpp
+++ b/deps/icu-small/source/i18n/uspoof_conf.cpp
@@ -15,7 +15,7 @@
 *   created on: 2009Jan05  (refactoring earlier files)
 *   created by: Andy Heninger
 *
-*   Internal classes for compililing confusable data into its binary (runtime) form.
+*   Internal classes for compiling confusable data into its binary (runtime) form.
 */
 
 #include "unicode/utypes.h"
diff --git a/deps/icu-small/source/i18n/uspoof_impl.h b/deps/icu-small/source/i18n/uspoof_impl.h
index 8844a96446e2b5c709b0ae566b6a972a2fd23d11..e825f343da19157f0423489d4892ae5767298982 100644
--- a/deps/icu-small/source/i18n/uspoof_impl.h
+++ b/deps/icu-small/source/i18n/uspoof_impl.h
@@ -157,7 +157,7 @@ public:
 //
 //    String Table:
 //       The strings table contains all of the value strings (those of length two or greater)
-//       concatentated together into one long UChar (UTF-16) array.
+//       concatenated together into one long UChar (UTF-16) array.
 //
 //       There is no nul character or other mark between adjacent strings.
 //
@@ -222,7 +222,7 @@ class SpoofData: public UMemory {
     SpoofData(const void *serializedData, int32_t length, UErrorCode &status);
 
     //  Check raw Spoof Data Version compatibility.
-    //  Return TRUE it looks good.
+    //  Return true it looks good.
     UBool validateDataVersion(UErrorCode &status) const;
 
     ~SpoofData();                    // Destructor not normally used.
diff --git a/deps/icu-small/source/i18n/usrchimp.h b/deps/icu-small/source/i18n/usrchimp.h
index 5438417e7e60aa483aa58428aa128a1ea3f1fb9d..e056337caecdefeba3b16a14dd393dc119592c49 100644
--- a/deps/icu-small/source/i18n/usrchimp.h
+++ b/deps/icu-small/source/i18n/usrchimp.h
@@ -206,7 +206,7 @@ struct UStringSearch {
 * the text "\u00e6"
 * @param strsrch string search data
 * @param status error status if any
-* @return TRUE if an exact match is found, FALSE otherwise
+* @return true if an exact match is found, false otherwise
 */
 U_CFUNC
 UBool usearch_handleNextExact(UStringSearch *strsrch, UErrorCode *status);
@@ -217,7 +217,7 @@ UBool usearch_handleNextExact(UStringSearch *strsrch, UErrorCode *status);
 * of beginning and ending accents if it overlaps that region.
 * @param strsrch string search data
 * @param status error status if any
-* @return TRUE if a canonical match is found, FALSE otherwise
+* @return true if a canonical match is found, false otherwise
 */
 U_CFUNC
 UBool usearch_handleNextCanonical(UStringSearch *strsrch, UErrorCode *status);
@@ -227,7 +227,7 @@ UBool usearch_handleNextCanonical(UStringSearch *strsrch, UErrorCode *status);
 * Comments follows from handleNextExact
 * @param strsrch string search data
 * @param status error status if any
-* @return True if a exact math is found, FALSE otherwise.
+* @return True if a exact math is found, false otherwise.
 */
 U_CFUNC
 UBool usearch_handlePreviousExact(UStringSearch *strsrch, UErrorCode *status);
@@ -238,7 +238,7 @@ UBool usearch_handlePreviousExact(UStringSearch *strsrch, UErrorCode *status);
 * of beginning and ending accents if it overlaps that region.
 * @param strsrch string search data
 * @param status error status if any
-* @return TRUE if a canonical match is found, FALSE otherwise
+* @return true if a canonical match is found, false otherwise
 */
 U_CFUNC
 UBool usearch_handlePreviousCanonical(UStringSearch *strsrch,
diff --git a/deps/icu-small/source/i18n/utf16collationiterator.h b/deps/icu-small/source/i18n/utf16collationiterator.h
index fd3a05e9efab0b6bda34c58a7218b5e0dbcfb3fb..6305d81c30c66bd092312580a029a50b4b277874 100644
--- a/deps/icu-small/source/i18n/utf16collationiterator.h
+++ b/deps/icu-small/source/i18n/utf16collationiterator.h
@@ -125,7 +125,7 @@ private:
     /**
      * Extend the FCD text segment forward or normalize around pos.
      * To be called when checkDir > 0 && pos != limit.
-     * @return TRUE if success, checkDir == 0 and pos != limit
+     * @return true if success, checkDir == 0 and pos != limit
      */
     UBool nextSegment(UErrorCode &errorCode);
 
@@ -139,7 +139,7 @@ private:
     /**
      * Extend the FCD text segment backward or normalize around pos.
      * To be called when checkDir < 0 && pos != start.
-     * @return TRUE if success, checkDir == 0 and pos != start
+     * @return true if success, checkDir == 0 and pos != start
      */
     UBool previousSegment(UErrorCode &errorCode);
 
diff --git a/deps/icu-small/source/i18n/utf8collationiterator.h b/deps/icu-small/source/i18n/utf8collationiterator.h
index 9a3ec45aeb41eb3a4141075292ac814d1f5b9668..9059e72dcf9e63d2899bbce3fb2daadaf32474d0 100644
--- a/deps/icu-small/source/i18n/utf8collationiterator.h
+++ b/deps/icu-small/source/i18n/utf8collationiterator.h
@@ -54,7 +54,7 @@ protected:
      * together with a bogus code point. The caller will ignore that code point.
      *
      * Special values may be returned for surrogate code points, which are also illegal in UTF-8,
-     * but the caller will treat them like U+FFFD because forbidSurrogateCodePoints() returns TRUE.
+     * but the caller will treat them like U+FFFD because forbidSurrogateCodePoints() returns true.
      *
      * Valid lead surrogates are returned from inside a normalized text segment,
      * where handleGetTrailSurrogate() will return the matching trail surrogate.
@@ -117,7 +117,7 @@ private:
 
     /**
      * Extends the FCD text segment forward or normalizes around pos.
-     * @return TRUE if success
+     * @return true if success
      */
     UBool nextSegment(UErrorCode &errorCode);
 
@@ -128,7 +128,7 @@ private:
 
     /**
      * Extends the FCD text segment backward or normalizes around pos.
-     * @return TRUE if success
+     * @return true if success
      */
     UBool previousSegment(UErrorCode &errorCode);
 
diff --git a/deps/icu-small/source/i18n/vtzone.cpp b/deps/icu-small/source/i18n/vtzone.cpp
index aa2e1763966710fe7b5326a574118da758a0e8d1..94fa6a4158ae1d4fc358980e491caed64948297c 100644
--- a/deps/icu-small/source/i18n/vtzone.cpp
+++ b/deps/icu-small/source/i18n/vtzone.cpp
@@ -376,7 +376,7 @@ static void getDefaultTZName(const UnicodeString &tzid, UBool isDST, UnicodeStri
  * dow      day of week in BYDAY, or 0 when not found
  * wim      day of week ordinal number in BYDAY, or 0 when not found
  * dom      an array of day of month
- * domCount number of availble days in dom (domCount is specifying the size of dom on input)
+ * domCount number of available days in dom (domCount is specifying the size of dom on input)
  * until    time defined by UNTIL attribute or MIN_MILLIS if not available
  */
 static void parseRRULE(const UnicodeString& rrule, int32_t& month, int32_t& dow, int32_t& wim,
@@ -1217,6 +1217,12 @@ VTimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset,
     return tz->getOffset(date, local, rawOffset, dstOffset, status);
 }
 
+void VTimeZone::getOffsetFromLocal(UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
+                                   UTimeZoneLocalOption duplicatedTimeOpt,
+                                   int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const {
+    tz->getOffsetFromLocal(date, nonExistingTimeOpt, duplicatedTimeOpt, rawOffset, dstOffset, status);
+}
+
 void
 VTimeZone::setRawOffset(int32_t offsetMillis) {
     tz->setRawOffset(offsetMillis);
@@ -2649,7 +2655,7 @@ VTimeZone::endZoneProps(VTZWriter& writer, UBool isDst, UErrorCode& status) cons
 }
 
 /*
- * Write the beggining part of RRULE line
+ * Write the beginning part of RRULE line
  */
 void
 VTimeZone::beginRRULE(VTZWriter& writer, int32_t month, UErrorCode& status) const {
diff --git a/deps/icu-small/source/i18n/vzone.h b/deps/icu-small/source/i18n/vzone.h
index 700687e0cb76ab24a3ddc96ef92fb09e8cecb486..2e8433908c03300a27708ae5b9d65f9495327eca 100644
--- a/deps/icu-small/source/i18n/vzone.h
+++ b/deps/icu-small/source/i18n/vzone.h
@@ -91,7 +91,7 @@ vzone_equals(const VZone* zone1, const VZone* zone2);
  * @param zone, the vzone to use
  * @param url Receives the RFC2445 TZURL property value.
  * @param urlLength, length of the url
- * @return TRUE if TZURL attribute is available and value is set.
+ * @return true if TZURL attribute is available and value is set.
  */
 U_CAPI UBool U_EXPORT2
 vzone_getTZURL(VZone* zone, UChar* & url, int32_t & urlLength);
@@ -112,7 +112,7 @@ vzone_setTZURL(VZone* zone, UChar* url, int32_t urlLength);
  * is not set.
  * @param zone, the vzone to use
  * @param lastModified Receives the last modified date.
- * @return TRUE if lastModified attribute is available and value is set.
+ * @return true if lastModified attribute is available and value is set.
  */
 U_CAPI UBool U_EXPORT2
 vzone_getLastModified(VZone* zone, UDate& lastModified);
@@ -136,7 +136,7 @@ U_CAPI void U_EXPORT2
 vzone_write(VZone* zone, UChar* & result, int32_t & resultLength, UErrorCode& status);
 
 /**
- * Writes RFC2445 VTIMEZONE data for this time zone applicalbe
+ * Writes RFC2445 VTIMEZONE data for this time zone applicable
  * for dates after the specified start time.
  * @param zone, the vzone to use
  * @param start The start date.
@@ -148,7 +148,7 @@ U_CAPI void U_EXPORT2
 vzone_writeFromStart(VZone* zone, UDate start, UChar* & result, int32_t & resultLength, UErrorCode& status);
 
 /**
- * Writes RFC2445 VTIMEZONE data applicalbe for the specified date.
+ * Writes RFC2445 VTIMEZONE data applicable for the specified date.
  * Some common iCalendar implementations can only handle a single time
  * zone property or a pair of standard and daylight time properties using
  * BYDAY rule with day of week (such as BYDAY=1SUN).  This method produce
@@ -283,7 +283,7 @@ vzone_useDaylightTime(VZone* zone);
  * @return true if the given date is in daylight savings time,
  * false, otherwise.
  */
-U_INTERNAL UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 vzone_inDaylightTime(VZone* zone, UDate date, UErrorCode& status);
 
 /**
@@ -303,7 +303,7 @@ vzone_hasSameRules(VZone* zone, const VZone* other);
  * @param base      The base time.
  * @param inclusive Whether the base time is inclusive or not.
  * @param result    Receives the first transition after the base time.
- * @return  TRUE if the transition is found.
+ * @return  true if the transition is found.
  */
 U_CAPI UBool U_EXPORT2
 vzone_getNextTransition(VZone* zone, UDate base, UBool inclusive, ZTrans* result);
@@ -314,7 +314,7 @@ vzone_getNextTransition(VZone* zone, UDate base, UBool inclusive, ZTrans* result
  * @param base      The base time.
  * @param inclusive Whether the base time is inclusive or not.
  * @param result    Receives the most recent transition before the base time.
- * @return  TRUE if the transition is found.
+ * @return  true if the transition is found.
  */
 U_CAPI UBool U_EXPORT2
 vzone_getPreviousTransition(VZone* zone, UDate base, UBool inclusive, ZTrans* result);
diff --git a/deps/icu-small/source/i18n/windtfmt.cpp b/deps/icu-small/source/i18n/windtfmt.cpp
index c35adc09875724a8a5616aee7e82e33a778ab9ef..b5cb8f367b662ca891fea35966022a255ac3159f 100644
--- a/deps/icu-small/source/i18n/windtfmt.cpp
+++ b/deps/icu-small/source/i18n/windtfmt.cpp
@@ -193,6 +193,7 @@ Win32DateFormat::~Win32DateFormat()
 
 Win32DateFormat &Win32DateFormat::operator=(const Win32DateFormat &other)
 {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     // The following handles fCalendar
     DateFormat::operator=(other);
 
diff --git a/deps/icu-small/source/i18n/winnmfmt.cpp b/deps/icu-small/source/i18n/winnmfmt.cpp
index 1ae2310123a252195dd902e711a599fe4aa13524..2e44631c85074e029f7cecb3db0985622883db25 100644
--- a/deps/icu-small/source/i18n/winnmfmt.cpp
+++ b/deps/icu-small/source/i18n/winnmfmt.cpp
@@ -268,6 +268,7 @@ Win32NumberFormat::~Win32NumberFormat()
 
 Win32NumberFormat &Win32NumberFormat::operator=(const Win32NumberFormat &other)
 {
+    if (this == &other) { return *this; }  // self-assignment: no-op
     NumberFormat::operator=(other);
 
     this->fCurrency          = other.fCurrency;
diff --git a/deps/icu-small/source/i18n/wintzimpl.cpp b/deps/icu-small/source/i18n/wintzimpl.cpp
index c55ed95fa8aea20b80ae628dfc1d0cd0d32cab00..211d3564029db894bf32623de0799a89f9239d41 100644
--- a/deps/icu-small/source/i18n/wintzimpl.cpp
+++ b/deps/icu-small/source/i18n/wintzimpl.cpp
@@ -145,7 +145,7 @@ static UBool getWindowsTimeZoneInfo(TIME_ZONE_INFORMATION *zoneInfo, const UChar
 }
 
 /*
- * Given the timezone icuid, fill in zoneInfo by calling auxillary functions that creates a timezone and extract the
+ * Given the timezone icuid, fill in zoneInfo by calling auxiliary functions that creates a timezone and extract the
  * information to put into zoneInfo. This includes bias and standard time date and daylight saving date.
  */
 U_CAPI UBool U_EXPORT2
diff --git a/deps/icu-small/source/i18n/zonemeta.h b/deps/icu-small/source/i18n/zonemeta.h
index 9dbcc878a22dc8f5537e814e01612fc221c8e0f1..a5a446d8ccdad96ba7d5fd9cefe601fb4117c7da 100644
--- a/deps/icu-small/source/i18n/zonemeta.h
+++ b/deps/icu-small/source/i18n/zonemeta.h
@@ -50,7 +50,7 @@ public:
     static const UChar* U_EXPORT2 getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status);
 
     /*
-     * Conveninent method returning CLDR canonical ID for the given time zone
+     * Convenient method returning CLDR canonical ID for the given time zone
      */
     static const UChar* U_EXPORT2 getCanonicalCLDRID(const TimeZone& tz);
 
@@ -59,7 +59,7 @@ public:
      * is not associated with a country, return bogus string.
      * @param tzid Zone ID
      * @param country [output] Country code
-     * @param isPrimary [output] TRUE if the zone is the primary zone for the country
+     * @param isPrimary [output] true if the zone is the primary zone for the country
      * @return A reference to the result country
      */
     static UnicodeString& U_EXPORT2 getCanonicalCountry(const UnicodeString &tzid, UnicodeString &country, UBool *isPrimary = NULL);
diff --git a/deps/icu-small/source/python/icutools/databuilder/filtration_schema.json b/deps/icu-small/source/python/icutools/databuilder/filtration_schema.json
index 2b7ff9989992a12e77a81ad9d6f2a6418351f22e..3aed41a3341f654510aae34e8491c7e1d9d250ff 100644
--- a/deps/icu-small/source/python/icutools/databuilder/filtration_schema.json
+++ b/deps/icu-small/source/python/icutools/databuilder/filtration_schema.json
@@ -90,7 +90,7 @@
                 {
                     "properties": {
                         "filterType": {
-                            "$ref": "#/definitions/blacklistWhitelistFilterTypes"
+                            "$ref": "#/definitions/includeExcludeFilterTypes"
                         },
                         "whitelist": { "$ref": "#/definitions/stringList" }
                     },
@@ -100,13 +100,33 @@
                 {
                     "properties": {
                         "filterType": {
-                            "$ref": "#/definitions/blacklistWhitelistFilterTypes"
+                            "$ref": "#/definitions/includeExcludeFilterTypes"
                         },
                         "blacklist": { "$ref": "#/definitions/stringList" }
                     },
                     "required": ["blacklist"],
                     "additionalProperties": false
                 },
+                {
+                    "properties": {
+                        "filterType": {
+                            "$ref": "#/definitions/includeExcludeFilterTypes"
+                        },
+                        "includelist": { "$ref": "#/definitions/stringList" }
+                    },
+                    "required": ["includelist"],
+                    "additionalProperties": false
+                },
+                {
+                    "properties": {
+                        "filterType": {
+                            "$ref": "#/definitions/includeExcludeFilterTypes"
+                        },
+                        "excludelist": { "$ref": "#/definitions/stringList" }
+                    },
+                    "required": ["excludelist"],
+                    "additionalProperties": false
+                },
                 {
                     "properties": {
                         "filterType": {
@@ -134,6 +154,23 @@
                     "required": ["filterType", "whitelist"],
                     "additionalProperties": false
                 },
+                {
+                    "properties": {
+                        "filterType": {
+                            "type": "string",
+                            "enum": ["locale"]
+                        },
+                        "includeChildren": {
+                            "type": "boolean"
+                        },
+                        "includeScripts": {
+                            "type": "boolean"
+                        },
+                        "includelist": { "$ref": "#/definitions/stringList" }
+                    },
+                    "required": ["filterType", "includelist"],
+                    "additionalProperties": false
+                },
                 {
                     "properties": {
                         "filterType": {
@@ -150,7 +187,7 @@
                 }
             ]
         },
-        "blacklistWhitelistFilterTypes": {
+        "includeExcludeFilterTypes": {
             "type": "string",
             "enum": [
                 "language",
diff --git a/deps/icu-small/source/python/icutools/databuilder/test/sample_data/brkitr/LOCALE_DEPS.json b/deps/icu-small/source/python/icutools/databuilder/test/sample_data/brkitr/LOCALE_DEPS.json
index 89329e87eea539eb343e46d6d854ae78b1e42cd1..674db09278fc3733287af76c90a0a993fef0737e 100644
--- a/deps/icu-small/source/python/icutools/databuilder/test/sample_data/brkitr/LOCALE_DEPS.json
+++ b/deps/icu-small/source/python/icutools/databuilder/test/sample_data/brkitr/LOCALE_DEPS.json
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 //////////////////////////////////////////////////////////////
 // This is a sample LOCALE_DEPS.json file for testing only. //
diff --git a/deps/icu-small/source/python/icutools/databuilder/test/sample_data/locales/LOCALE_DEPS.json b/deps/icu-small/source/python/icutools/databuilder/test/sample_data/locales/LOCALE_DEPS.json
index fd28a741ef67c2f724ecd3ea93f0300adad9247d..1456ea0d9acff4239244ec59a6a02b990f57f6b0 100644
--- a/deps/icu-small/source/python/icutools/databuilder/test/sample_data/locales/LOCALE_DEPS.json
+++ b/deps/icu-small/source/python/icutools/databuilder/test/sample_data/locales/LOCALE_DEPS.json
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 //////////////////////////////////////////////////////////////
 // This is a sample LOCALE_DEPS.json file for testing only. //
diff --git a/deps/icu-small/source/python/icutools/databuilder/test/sample_data/rbnf/LOCALE_DEPS.json b/deps/icu-small/source/python/icutools/databuilder/test/sample_data/rbnf/LOCALE_DEPS.json
index f079619a3685bae200a7c048ecc721de51656094..c6ec208add2b419be2a69351d16aeaba1521a8a2 100644
--- a/deps/icu-small/source/python/icutools/databuilder/test/sample_data/rbnf/LOCALE_DEPS.json
+++ b/deps/icu-small/source/python/icutools/databuilder/test/sample_data/rbnf/LOCALE_DEPS.json
@@ -1,5 +1,5 @@
 // © 2019 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html#License
+// License & terms of use: http://www.unicode.org/copyright.html
 
 //////////////////////////////////////////////////////////////
 // This is a sample LOCALE_DEPS.json file for testing only. //
diff --git a/deps/icu-small/source/tools/genrb/errmsg.c b/deps/icu-small/source/tools/genrb/errmsg.c
index 603f26a174c4e924b7674f2cbacde612ed97afa9..91dfd3265e1149ffed77a7781f3664b99cddd4d3 100644
--- a/deps/icu-small/source/tools/genrb/errmsg.c
+++ b/deps/icu-small/source/tools/genrb/errmsg.c
@@ -21,6 +21,7 @@
 #include <stdio.h>
 #include "cstring.h"
 #include "errmsg.h"
+#include "toolutil.h"
 
 U_CFUNC void error(uint32_t linenumber, const char *msg, ...)
 {
diff --git a/deps/icu-small/source/tools/genrb/parse.cpp b/deps/icu-small/source/tools/genrb/parse.cpp
index 18a8c76dbc5df15560ece84ce1e665207f83b140..5abe5d656733f9be607520c467274d3913a04a0c 100644
--- a/deps/icu-small/source/tools/genrb/parse.cpp
+++ b/deps/icu-small/source/tools/genrb/parse.cpp
@@ -1191,7 +1191,7 @@ realParseTable(ParseState* state, TableResource *table, char *tag, uint32_t star
 
         if (token == TOK_CLOSE_BRACE)
         {
-            if (!readToken) {
+            if (!readToken && isVerbose()) {
                 warning(startline, "Encountered empty table");
             }
             return table;
diff --git a/deps/icu-small/source/tools/genrb/prscmnts.cpp b/deps/icu-small/source/tools/genrb/prscmnts.cpp
index 5d494cd9ad3f2b38d98304c075a4784f0d6a3537..d79d59e3916bc58193ad806c7123260ba55ab605 100644
--- a/deps/icu-small/source/tools/genrb/prscmnts.cpp
+++ b/deps/icu-small/source/tools/genrb/prscmnts.cpp
@@ -78,7 +78,7 @@ trim(UChar *src, int32_t srcLen, UErrorCode *status){
 U_CFUNC int32_t
 removeCmtText(UChar* source, int32_t srcLen, UErrorCode* status){
     srcLen = trim(source, srcLen, status);
-    UnicodeString patString("^\\s*?\\*\\s*?");  // remove pattern like " * " at the begining of the line
+    UnicodeString patString("^\\s*?\\*\\s*?");  // remove pattern like " * " at the beginning of the line
     srcLen = removeText(source, srcLen, patString, UREGEX_MULTILINE, UnicodeString(), status);
     return removeText(source, srcLen, UnicodeString("[ \\r\\n]+"), 0, UnicodeString(" "), status);// remove new lines;
 }
diff --git a/deps/icu-small/source/tools/genrb/read.c b/deps/icu-small/source/tools/genrb/read.c
index c20b4510a28ac415bed330838b2fcf05dc3623fd..141e285d25efb9ca83cd84f1b1b9a84e71c44382 100644
--- a/deps/icu-small/source/tools/genrb/read.c
+++ b/deps/icu-small/source/tools/genrb/read.c
@@ -20,6 +20,7 @@
 
 #include "read.h"
 #include "errmsg.h"
+#include "toolutil.h"
 #include "unicode/ustring.h"
 #include "unicode/utf16.h"
 
diff --git a/deps/icu-small/source/tools/genrb/reslist.cpp b/deps/icu-small/source/tools/genrb/reslist.cpp
index 3186c781e934f3767b3007e85c5092379294dc9f..389ad19b38b88fa9047d36918fba6fdbce43cda9 100644
--- a/deps/icu-small/source/tools/genrb/reslist.cpp
+++ b/deps/icu-small/source/tools/genrb/reslist.cpp
@@ -39,6 +39,7 @@
 #include "unicode/putil.h"
 #include "errmsg.h"
 #include "filterrb.h"
+#include "toolutil.h"
 
 #include "uarrsort.h"
 #include "uelement.h"
@@ -339,7 +340,8 @@ IntResource::~IntResource() {}
 IntVectorResource::IntVectorResource(SRBRoot *bundle, const char *tag,
                   const UString* comment, UErrorCode &errorCode)
         : SResource(bundle, tag, URES_INT_VECTOR, comment, errorCode),
-          fCount(0), fArray(new uint32_t[RESLIST_MAX_INT_VECTOR]) {
+          fCount(0), fSize(RESLIST_INT_VECTOR_INIT_SIZE),
+          fArray(new uint32_t[fSize]) {
     if (fArray == NULL) {
         errorCode = U_MEMORY_ALLOCATION_ERROR;
         return;
@@ -351,6 +353,17 @@ IntVectorResource::~IntVectorResource() {
 }
 
 void IntVectorResource::add(int32_t value, UErrorCode &errorCode) {
+    if (fCount == fSize) {
+        uint32_t* tmp = new uint32_t[2 * fSize];
+        if (tmp == nullptr) {
+            errorCode = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+        uprv_memcpy(tmp, fArray, fSize * sizeof(uint32_t));
+        delete[] fArray;
+        fArray = tmp;
+        fSize *= 2;
+    }
     if (U_SUCCESS(errorCode)) {
         fArray[fCount++] = value;
     }
diff --git a/deps/icu-small/source/tools/genrb/reslist.h b/deps/icu-small/source/tools/genrb/reslist.h
index 34b710c4232670cf481571185b9830cccf339bd8..400f0a97debea4e94121ae59ecdbd8120f3dd31a 100644
--- a/deps/icu-small/source/tools/genrb/reslist.h
+++ b/deps/icu-small/source/tools/genrb/reslist.h
@@ -21,7 +21,7 @@
 #define RESLIST_H
 
 #define KEY_SPACE_SIZE 65536
-#define RESLIST_MAX_INT_VECTOR 2048
+#define RESLIST_INT_VECTOR_INIT_SIZE 2048
 
 #include <functional>
 
@@ -355,7 +355,7 @@ public:
               fNumCopies(0), fNumUnitsSaved(0), fNumCharsForLength(numCharsForLength) {
         // v3 pool string encoded as string-v2 with low offset
         fRes = URES_MAKE_RESOURCE(URES_STRING_V2, poolStringIndex);
-        fWritten = TRUE;
+        fWritten = true;
     }
     virtual ~StringResource();
 
@@ -405,7 +405,8 @@ public:
     virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
 
     // TODO: UVector32
-    uint32_t fCount;
+    size_t fCount;
+    size_t fSize;
     uint32_t *fArray;
 };
 
diff --git a/deps/icu-small/source/tools/genrb/rle.c b/deps/icu-small/source/tools/genrb/rle.c
index 3d034f78ca38818bfac21af428034cbfa89f667c..c5d29ba1d24b6b1c6e55832b26d946e6db0aa9f2 100644
--- a/deps/icu-small/source/tools/genrb/rle.c
+++ b/deps/icu-small/source/tools/genrb/rle.c
@@ -16,6 +16,7 @@
 *   01/11/02    Ram        Creation.
 *******************************************************************************
 */
+#include <stdbool.h>
 #include "rle.h"
 /**
  * The ESCAPE character is used during run-length encoding.  It signals
@@ -297,7 +298,7 @@ int32_t
 rleStringToByteArray(uint16_t* src, int32_t srcLen, uint8_t* target, int32_t tgtLen, UErrorCode* status) {
 
     int32_t length = 0;
-    UBool nextChar = TRUE;
+    UBool nextChar = true;
     uint16_t c = 0;
     int32_t node = 0;
     int32_t runLength = 0;
@@ -334,11 +335,11 @@ rleStringToByteArray(uint16_t* src, int32_t srcLen, uint8_t* target, int32_t tgt
         if (nextChar) {
             c = src[i++];
             b = (uint8_t) (c >> 8);
-            nextChar = FALSE;
+            nextChar = false;
         }
         else {
             b = (uint8_t) (c & 0xFF);
-            nextChar = TRUE;
+            nextChar = true;
         }
 
        /* This part of the loop is a tiny state machine which handles
diff --git a/deps/icu-small/source/tools/icupkg/icupkg.cpp b/deps/icu-small/source/tools/icupkg/icupkg.cpp
index ea7be4a90923fd7adda726a46c63928892522b7c..39707946b0943ccf0785c829eded79145eca046c 100644
--- a/deps/icu-small/source/tools/icupkg/icupkg.cpp
+++ b/deps/icu-small/source/tools/icupkg/icupkg.cpp
@@ -59,6 +59,7 @@ printUsage(const char *pname, UBool isHelp) {
             "%csage: %s [-h|-?|--help ] [-tl|-tb|-te] [-c] [-C comment]\n"
             "\t[-a list] [-r list] [-x list] [-l [-o outputListFileName]]\n"
             "\t[-s path] [-d path] [-w] [-m mode]\n"
+            "\t[--ignore-deps]\n"
             "\t[--auto_toc_prefix] [--auto_toc_prefix_with_type] [--toc_prefix]\n"
             "\tinfilename [outfilename]\n",
             isHelp ? 'U' : 'u', pname);
@@ -119,6 +120,10 @@ printUsage(const char *pname, UBool isHelp) {
             "\t-m mode or --matchmode mode  set the matching mode for item names with\n"
             "\t                             wildcards\n"
             "\t        noslash: the '*' wildcard does not match the '/' tree separator\n");
+        fprintf(where,
+            "\n"
+            "\t--ignore-deps     Do not fail if not all resource dependencies are met. Use this\n"
+            "\t                  option if the missing resources come from another source.");
         fprintf(where,
             "\n"
             "\tIn the .dat package, the Table of Contents (ToC) contains an entry\n"
@@ -198,6 +203,8 @@ static UOption options[]={
 
     UOPTION_DEF("matchmode", 'm', UOPT_REQUIRES_ARG),
 
+    UOPTION_DEF("ignore-deps", '\1', UOPT_NO_ARG),
+
     UOPTION_DEF("add", 'a', UOPT_REQUIRES_ARG),
     UOPTION_DEF("remove", 'r', UOPT_REQUIRES_ARG),
     UOPTION_DEF("extract", 'x', UOPT_REQUIRES_ARG),
@@ -225,6 +232,8 @@ enum {
 
     OPT_MATCHMODE,
 
+    OPT_IGNORE_DEPS,
+
     OPT_ADD_LIST,
     OPT_REMOVE_LIST,
     OPT_EXTRACT_LIST,
@@ -501,7 +510,7 @@ main(int argc, char *argv[]) {
     }
 
     /* check dependencies between items */
-    if(!pkg->checkDependencies()) {
+    if(!options[OPT_IGNORE_DEPS].doesOccur && !pkg->checkDependencies()) {
         /* some dependencies are not fulfilled */
         return U_MISSING_RESOURCE_ERROR;
     }
diff --git a/deps/icu-small/source/tools/pkgdata/pkgtypes.c b/deps/icu-small/source/tools/pkgdata/pkgtypes.c
index 43ee3dfb5e2c33ec4b6141cbbfd2591a40fb23be..26bd945df73d4858280dfa389ae67d9235d309a4 100644
--- a/deps/icu-small/source/tools/pkgdata/pkgtypes.c
+++ b/deps/icu-small/source/tools/pkgdata/pkgtypes.c
@@ -17,6 +17,7 @@
 *  common types for pkgdata
 */
 
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "unicode/utypes.h"
@@ -294,9 +295,9 @@ UBool  pkg_listContains(CharList *l, const char *str)
 {
   for(;l;l=l->next){
     if(!uprv_strcmp(l->str, str)) {
-      return TRUE;
+      return true;
     }
   }
 
-  return FALSE;
+  return false;
 }
diff --git a/deps/icu-small/source/tools/toolutil/dbgutil.cpp b/deps/icu-small/source/tools/toolutil/dbgutil.cpp
index 29bab927535e78ce706e0bef3de8a78dea75efeb..17fdfbb1444e29653accc69dd702f6b42d49fdef 100644
--- a/deps/icu-small/source/tools/toolutil/dbgutil.cpp
+++ b/deps/icu-small/source/tools/toolutil/dbgutil.cpp
@@ -29,7 +29,7 @@ static const UnicodeString&  _fieldString(UDebugEnumType type, int32_t field, Un
     if(str == NULL) {
         return fillin.remove();
     } else {
-        return fillin = UnicodeString(str, ""); // optimize?
+        return fillin = UnicodeString(str, -1, US_INV);
     }
 }
 
diff --git a/deps/icu-small/source/tools/toolutil/filetools.h b/deps/icu-small/source/tools/toolutil/filetools.h
index 6a25c3601c0178117cc6ef25bef3de7ef5a3a12b..40a606a7d490767ce21cbbb719e7b87cd8df6e88 100644
--- a/deps/icu-small/source/tools/toolutil/filetools.h
+++ b/deps/icu-small/source/tools/toolutil/filetools.h
@@ -26,7 +26,7 @@
 #include "unicode/utypes.h"
 
 U_CAPI UBool U_EXPORT2
-isFileModTimeLater(const char *filePath, const char *checkAgainst, UBool isDir=FALSE);
+isFileModTimeLater(const char *filePath, const char *checkAgainst, UBool isDir=false);
 
 U_CAPI void U_EXPORT2
 swapFileSepChar(char *filePath, const char oldFileSepChar, const char newFileSepChar);
diff --git a/deps/icu-small/source/tools/toolutil/package.h b/deps/icu-small/source/tools/toolutil/package.h
index 3263c84feb4c37fe7313ff0b94a5c1308a7fc82f..5f74eb73ef5c9a3536063dfa662ac35b981cc4a6 100644
--- a/deps/icu-small/source/tools/toolutil/package.h
+++ b/deps/icu-small/source/tools/toolutil/package.h
@@ -57,13 +57,13 @@ public:
      * Uses the prefix of the first entry of the package in readPackage(),
      * rather than the package basename.
      */
-    void setAutoPrefix() { doAutoPrefix=TRUE; }
+    void setAutoPrefix() { doAutoPrefix=true; }
     /**
      * Same as setAutoPrefix(), plus the prefix must end with the platform type letter.
      */
     void setAutoPrefixWithType() {
-        doAutoPrefix=TRUE;
-        prefixEndsWithType=TRUE;
+        doAutoPrefix=true;
+        prefixEndsWithType=true;
     }
     void setPrefix(const char *p);
 
@@ -128,7 +128,7 @@ public:
     const Item *getItem(int32_t idx) const;
 
     /*
-     * Check dependencies and return TRUE if all dependencies are fulfilled.
+     * Check dependencies and return true if all dependencies are fulfilled.
      */
     UBool checkDependencies();
 
diff --git a/deps/icu-small/source/tools/toolutil/pkg_genc.cpp b/deps/icu-small/source/tools/toolutil/pkg_genc.cpp
index 31db2e2184b3bedb78fcbf52b1e2194c395e2f22..f9400c5058c206c5fda1f811a308eaed28f576ff 100644
--- a/deps/icu-small/source/tools/toolutil/pkg_genc.cpp
+++ b/deps/icu-small/source/tools/toolutil/pkg_genc.cpp
@@ -738,8 +738,8 @@ getOutFilename(
         exit(U_ILLEGAL_ARGUMENT_ERROR);
     }
 
-    uprv_strcpy(outFilename, outFilenameBuilder.data());
-    uprv_strcpy(entryName, entryNameBuilder.data());
+    outFilenameBuilder.extract(outFilename, outFilenameCapacity, status);
+    entryNameBuilder.extract(entryName, entryNameCapacity, status);
 }
 
 #ifdef CAN_GENERATE_OBJECTS
diff --git a/deps/icu-small/source/tools/toolutil/pkg_genc.h b/deps/icu-small/source/tools/toolutil/pkg_genc.h
index b231aa6170c2874360cacda01a5fc379be3549ae..72d968703550205cd3baca551f42206083c7b552 100644
--- a/deps/icu-small/source/tools/toolutil/pkg_genc.h
+++ b/deps/icu-small/source/tools/toolutil/pkg_genc.h
@@ -68,13 +68,13 @@
 
 
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 printAssemblyHeadersToStdErr(void);
 
-U_INTERNAL UBool U_EXPORT2
+U_CAPI UBool U_EXPORT2
 checkAssemblyHeaderName(const char* optAssembly);
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 writeCCode(
     const char *filename,
     const char *destdir,
@@ -83,7 +83,7 @@ writeCCode(
     char *outFilePath,
     size_t outFilePathCapacity);
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 writeAssemblyCode(
     const char *filename,
     const char *destdir,
@@ -92,7 +92,7 @@ writeAssemblyCode(
     char *outFilePath,
     size_t outFilePathCapacity);
 
-U_INTERNAL void U_EXPORT2
+U_CAPI void U_EXPORT2
 writeObjectCode(
     const char *filename,
     const char *destdir,
diff --git a/deps/icu-small/source/tools/toolutil/pkgitems.cpp b/deps/icu-small/source/tools/toolutil/pkgitems.cpp
index b0ea980d605dcbe5a66713cc94570bcf10ea967a..16b18a3e27345fe0941e5baa905d8e88789f6d69 100644
--- a/deps/icu-small/source/tools/toolutil/pkgitems.cpp
+++ b/deps/icu-small/source/tools/toolutil/pkgitems.cpp
@@ -441,6 +441,7 @@ ures_enumDependencies(const char *itemName, const UDataInfo *pInfo,
 
 // get dependencies from conversion tables --------------------------------- ***
 
+#if !UCONFIG_NO_CONVERSION
 /* code adapted from ucnv_swap() */
 static void
 ucnv_enumDependencies(const UDataSwapper *ds,
@@ -631,5 +632,6 @@ Package::enumDependencies(Item *pItem, void *context, CheckDependency check) {
         }
     }
 }
+#endif /* UCONFIG_NO_CONVERSION */
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/tools/toolutil/toolutil.cpp b/deps/icu-small/source/tools/toolutil/toolutil.cpp
index f0d6be5cf5ee2afa4847003cfbb8ee30cfc2a6b3..0ce9b02115dd32a8f12df5487056ebb5d2bc7c9f 100644
--- a/deps/icu-small/source/tools/toolutil/toolutil.cpp
+++ b/deps/icu-small/source/tools/toolutil/toolutil.cpp
@@ -33,7 +33,7 @@
 #include "unicode/utypes.h"
 
 #ifndef U_TOOLUTIL_IMPLEMENTATION
-#error U_TOOLUTIL_IMPLEMENTATION not set - must be set for all ICU source files in common/ - see http://userguide.icu-project.org/howtouseicu
+#error U_TOOLUTIL_IMPLEMENTATION not set - must be set for all ICU source files in common/ - see https://unicode-org.github.io/icu/userguide/howtouseicu
 #endif
 
 #if U_PLATFORM_USES_ONLY_WIN32_API
@@ -166,14 +166,11 @@ findBasename(const char *filename) {
     const char *basename=uprv_strrchr(filename, U_FILE_SEP_CHAR);
 
 #if U_FILE_ALT_SEP_CHAR!=U_FILE_SEP_CHAR
-#if !(U_PLATFORM == U_PF_CYGWIN && U_PLATFORM_USES_ONLY_WIN32_API)
-    if(basename==NULL)
-#endif
-    {
-        /* Use lenient matching on Windows, which can accept either \ or /
-           This is useful for environments like Win32+CygWin which have both.
-        */
-        basename=uprv_strrchr(filename, U_FILE_ALT_SEP_CHAR);
+    //be lenient about pathname separators on Windows, like official implementation of C++17 std::filesystem in MSVC
+    //would be convenient to merge this loop with the one above, but alas, there is no such solution in the standard library
+    const char *alt_basename=uprv_strrchr(filename, U_FILE_ALT_SEP_CHAR);
+    if(alt_basename>basename) {
+        basename=alt_basename;
     }
 #endif
 
diff --git a/deps/icu-small/source/tools/toolutil/toolutil.h b/deps/icu-small/source/tools/toolutil/toolutil.h
index be07787a9fa950de28e68766fc893c3287bcbec0..1d0d26c97477c5da14a6070769590edcd948dcfd 100644
--- a/deps/icu-small/source/tools/toolutil/toolutil.h
+++ b/deps/icu-small/source/tools/toolutil/toolutil.h
@@ -23,6 +23,12 @@
 
 #include "unicode/utypes.h"
 
+#ifndef TRUE
+#   define TRUE  1
+#endif
+#ifndef FALSE
+#   define FALSE 0
+#endif
 
 #ifdef __cplusplus
 
diff --git a/deps/icu-small/source/tools/toolutil/ucbuf.cpp b/deps/icu-small/source/tools/toolutil/ucbuf.cpp
index 9b5e615d258c92248bc88a77ce9baed8aaa7f7d9..195963c78c5af94f8b0ceba2c728258ee0fdc1cd 100644
--- a/deps/icu-small/source/tools/toolutil/ucbuf.cpp
+++ b/deps/icu-small/source/tools/toolutil/ucbuf.cpp
@@ -531,14 +531,14 @@ ucbuf_open(const char* fileName,const char** cp,UBool showWarning, UBool buffere
 
 
 /* TODO: this method will fail if at the
- * begining of buffer and the uchar to unget
+ * beginning of buffer and the uchar to unget
  * is from the previous buffer. Need to implement
  * system to take care of that situation.
  */
 U_CAPI void U_EXPORT2
 ucbuf_ungetc(int32_t c,UCHARBUF* buf){
     /* decrement currentPos pointer
-     * if not at the begining of buffer
+     * if not at the beginning of buffer
      */
     if(buf->currentPos!=buf->buffer){
         if(*(buf->currentPos-1)==c){
@@ -736,7 +736,7 @@ ucbuf_readline(UCHARBUF* buf,int32_t* len,UErrorCode* err){
                 }
             }
             /*
-             * Accoding to TR 13 readLine functions must interpret
+             * According to TR 13 readLine functions must interpret
              * CR, CR+LF, LF, NEL, PS, LS or FF as line seperators
              */
             /* Windows CR LF */
diff --git a/deps/icu-small/source/tools/toolutil/ucbuf.h b/deps/icu-small/source/tools/toolutil/ucbuf.h
index 7a9b7af5cc71ac076d63014e4cc8d2496ff48147..a854150bfba95b7bbcec581955e7ada75d37aa82 100644
--- a/deps/icu-small/source/tools/toolutil/ucbuf.h
+++ b/deps/icu-small/source/tools/toolutil/ucbuf.h
@@ -49,7 +49,7 @@ struct  ULine {
  * Opens the UCHARBUF with the given file stream and code page for conversion
  * @param fileName  Name of the file to open.
  * @param codepage  The encoding of the file stream to convert to Unicode.
- *                  If *codepoge is NULL on input the API will try to autodetect
+ *                  If *codepage is NULL on input the API will try to autodetect
  *                  popular Unicode encodings
  * @param showWarning Flag to print out warnings to STDOUT
  * @param buffered  If TRUE performs a buffered read of the input file. If FALSE reads
diff --git a/deps/icu-small/source/tools/toolutil/udbgutil.cpp b/deps/icu-small/source/tools/toolutil/udbgutil.cpp
index 285f68a0ec66a1607c64003d8b266583b4f8f0fb..993694546f4a7233e2b36164883ea4367f509232 100644
--- a/deps/icu-small/source/tools/toolutil/udbgutil.cpp
+++ b/deps/icu-small/source/tools/toolutil/udbgutil.cpp
@@ -594,24 +594,11 @@ U_CAPI void udbg_writeIcuInfo(FILE *out) {
   fprintf(out, " </icuSystemParams>\n");
 }
 
-#define ICU_TRAC_URL "http://bugs.icu-project.org/trac/ticket/"
-#define CLDR_TRAC_URL "http://unicode.org/cldr/trac/ticket/"
-#define CLDR_TICKET_PREFIX "cldrbug:"
+#define UNICODE_BUG_URL "https://unicode-org.atlassian.net/browse/"
+#define OLD_CLDR_PREFIX "cldrbug:"
+#define CLDR_BUG_PREFIX "CLDR-"
+#define ICU_BUG_PREFIX "ICU-"
 
-U_CAPI char *udbg_knownIssueURLFrom(const char *ticket, char *buf) {
-  if( ticket==NULL ) {
-    return NULL;
-  }
-
-  if( !strncmp(ticket, CLDR_TICKET_PREFIX, strlen(CLDR_TICKET_PREFIX)) ) {
-    strcpy( buf, CLDR_TRAC_URL );
-    strcat( buf, ticket+strlen(CLDR_TICKET_PREFIX) );
-  } else {
-    strcpy( buf, ICU_TRAC_URL );
-    strcat( buf, ticket );
-  }
-  return buf;
-}
 
 
 #include <set>
@@ -641,8 +628,27 @@ KnownIssues::~KnownIssues()
 {
 }
 
-void KnownIssues::add(const char *ticket, const char *where, const UChar *msg, UBool *firstForTicket, UBool *firstForWhere)
+/**
+ * Map cldr:1234 to CLDR-1234
+ * Map 1234 to ICU-1234
+ */
+static std::string mapTicketId(const char *ticketStr) {
+  std::string ticket(ticketStr);
+  // TODO: Can remove this function once all logKnownIssue calls are switched over
+  // to the ICU-1234 and CLDR-1234 format.
+  if(ticket.rfind(OLD_CLDR_PREFIX) == 0) {
+    // map cldrbug:1234 to CLDR-1234
+    ticket.replace(0, uprv_strlen(OLD_CLDR_PREFIX), CLDR_BUG_PREFIX);
+  } else if(::isdigit(ticket[0])) {
+    // map 1234 to ICU-1234
+    ticket.insert(0, ICU_BUG_PREFIX);
+  }
+  return ticket;
+}
+
+void KnownIssues::add(const char *ticketStr, const char *where, const UChar *msg, UBool *firstForTicket, UBool *firstForWhere)
 {
+  const std::string ticket = mapTicketId(ticketStr);
   if(fTable.find(ticket) == fTable.end()) {
     if(firstForTicket!=NULL) *firstForTicket = TRUE;
     fTable[ticket] = std::map < std::string, std::set < std::string > >();
@@ -664,8 +670,9 @@ void KnownIssues::add(const char *ticket, const char *where, const UChar *msg, U
   fTable[ticket][where].insert(std::string(icu::CStr(ustr)()));
 }
 
-void KnownIssues::add(const char *ticket, const char *where, const char *msg, UBool *firstForTicket, UBool *firstForWhere)
+void KnownIssues::add(const char *ticketStr, const char *where, const char *msg, UBool *firstForTicket, UBool *firstForWhere)
 {
+  const std::string ticket = mapTicketId(ticketStr);
   if(fTable.find(ticket) == fTable.end()) {
     if(firstForTicket!=NULL) *firstForTicket = TRUE;
     fTable[ticket] = std::map < std::string, std::set < std::string > >();
@@ -697,8 +704,13 @@ UBool KnownIssues::print()
           std::map <  std::string,  std::set <  std::string > > >::iterator i = fTable.begin();
        i != fTable.end();
        i++ ) {
-    char URL[1024];
-    std::cout << '#' << (*i).first << " <" << udbg_knownIssueURLFrom( (*i).first.c_str(), URL ) << ">" << std::endl;
+    const std::string ticketid = (*i).first;
+    std::cout << "[" << ticketid << "] ";
+    if(ticketid.rfind(ICU_BUG_PREFIX) == 0 || ticketid.rfind(CLDR_BUG_PREFIX) == 0) {
+      // If it's a unicode.org bug.
+      std::cout << UNICODE_BUG_URL << ticketid;
+    } // Else: some other kind of bug. Allow this, but without a URL.
+    std::cout << std::endl;
 
     for( std::map< std::string, std::set < std::string > >::iterator ii = (*i).second.begin();
          ii != (*i).second.end();
diff --git a/deps/icu-small/source/tools/toolutil/udbgutil.h b/deps/icu-small/source/tools/toolutil/udbgutil.h
index 2f186e6ed87f262a063ab4445451715adeeb8c38..b9af132da5ba6409a665d2251d51f29fd7666c67 100644
--- a/deps/icu-small/source/tools/toolutil/udbgutil.h
+++ b/deps/icu-small/source/tools/toolutil/udbgutil.h
@@ -113,14 +113,6 @@ U_CAPI void udbg_writeIcuInfo(FILE *f);
  */
 #define UDBG_KNOWNISSUE_LEN 255
 
-/**
- * Convert a "known issue" string into a URL
- * @param ticket ticket string such as "10245" or "cldrbug:5013"
- * @param buf output buffer - must be UDBG_KNOWNISSUE_LEN in size
- * @return pointer to output buffer, or NULL on err
- */
-U_CAPI char *udbg_knownIssueURLFrom(const char *ticket, char *buf);
-
 /**
  * Open (or reopen) a 'known issue' table.
  * @param ptr pointer to 'table'. Opaque.
diff --git a/deps/icu-small/source/tools/toolutil/unewdata.cpp b/deps/icu-small/source/tools/toolutil/unewdata.cpp
index 22d8540881f45490182691f420dee04cd6e64d52..20f13be5b83ef1ebf7805bfd0d9472e01b9ebbe7 100644
--- a/deps/icu-small/source/tools/toolutil/unewdata.cpp
+++ b/deps/icu-small/source/tools/toolutil/unewdata.cpp
@@ -57,6 +57,16 @@ udata_create(const char *dir, const char *type, const char *name,
         return NULL;
     }
 
+    char dirSepChar = U_FILE_SEP_CHAR;
+#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR)
+    // We may need to append a different directory separator when building for Cygwin or MSYS2.
+    if(dir && *dir) {
+      if(!uprv_strchr(dir, U_FILE_SEP_CHAR) && uprv_strchr(dir, U_FILE_ALT_SEP_CHAR)) {
+          dirSepChar = U_FILE_ALT_SEP_CHAR;
+      }
+    }
+#endif
+
     /* Check that the full path won't be too long */
     length = 0;					/* Start with nothing */
     if(dir != NULL  && *dir !=0)	/* Add directory length if one was given */
@@ -64,7 +74,7 @@ udata_create(const char *dir, const char *type, const char *name,
 	length += static_cast<int32_t>(strlen(dir));
 
 	/* Add 1 if dir doesn't end with path sep */
-        if (dir[strlen(dir) - 1]!= U_FILE_SEP_CHAR) {
+        if (dir[strlen(dir) - 1]!= dirSepChar) {
             length++;
         }
 	}
@@ -87,8 +97,8 @@ udata_create(const char *dir, const char *type, const char *name,
     if(dir!=NULL && *dir!=0) { /* if dir has a value, we prepend it to the filename */
         char *p=filename+strlen(dir);
         uprv_strcpy(filename, dir);
-        if (*(p-1)!=U_FILE_SEP_CHAR) {
-            *p++=U_FILE_SEP_CHAR;
+        if (*(p-1)!=dirSepChar) {
+            *p++=dirSepChar;
             *p=0;
         }
     } else { /* otherwise, we'll output to the current dir */
diff --git a/deps/icu-small/source/tools/toolutil/xmlparser.cpp b/deps/icu-small/source/tools/toolutil/xmlparser.cpp
index e3d5b42ef47a733ac1056a272f3909f6c752b683..d421a79ead6f2b7c684242e019393b69be85d535 100644
--- a/deps/icu-small/source/tools/toolutil/xmlparser.cpp
+++ b/deps/icu-small/source/tools/toolutil/xmlparser.cpp
@@ -79,7 +79,7 @@ UXMLParser::UXMLParser(UErrorCode &status) :
       //       or      "<!DOCTYPE foo [internal dtd]>
       //    TODO:  we don't actually parse the DOCTYPE or internal subsets.
       //           Some internal dtd subsets could confuse this simple-minded
-      //           attempt at skipping over them, specifically, occcurences
+      //           attempt at skipping over them, specifically, occurrences
       //           of closeing square brackets.  These could appear in comments,
       //           or in parameter entity declarations, for example.
       mXMLDoctype(UnicodeString(
@@ -243,7 +243,7 @@ UXMLParser::parseFile(const char *filename, UErrorCode &errorCode) {
                 UnicodeString attValue = mAttrValue.group(2, errorCode);
 
                 // Trim the quotes from the att value.  These are left over from the original regex
-                //   that parsed the attribue, which couldn't conveniently strip them.
+                //   that parsed the attribute, which couldn't conveniently strip them.
                 attValue.remove(0,1);                    // one char from the beginning
                 attValue.truncate(attValue.length()-1);  // and one from the end.
 
@@ -498,7 +498,7 @@ UXMLParser::createElement(RegexMatcher  &mEl, UErrorCode &status) {
         UnicodeString attValue = mAttrValue.group(2, status);
 
         // Trim the quotes from the att value.  These are left over from the original regex
-        //   that parsed the attribue, which couldn't conveniently strip them.
+        //   that parsed the attribute, which couldn't conveniently strip them.
         attValue.remove(0,1);                    // one char from the beginning
         attValue.truncate(attValue.length()-1);  // and one from the end.
 
@@ -658,7 +658,7 @@ UXMLParser::intern(const UnicodeString &s, UErrorCode &errorCode) {
         return (const UnicodeString *)he->key.pointer;
     } else {
         // add this new name and return its hashed key pointer
-        fNames.puti(s, 0, errorCode);
+        fNames.puti(s, 1, errorCode);
         he=fNames.find(s);
         return (const UnicodeString *)he->key.pointer;
     }
diff --git a/deps/nghttp2/lib/CMakeLists.txt b/deps/nghttp2/lib/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a02a534b1a8436a4578ccae1f84269b69771959f
--- /dev/null
+++ b/deps/nghttp2/lib/CMakeLists.txt
@@ -0,0 +1,77 @@
+add_subdirectory(includes)
+
+include_directories(
+  "${CMAKE_CURRENT_SOURCE_DIR}/includes"
+  "${CMAKE_CURRENT_BINARY_DIR}/includes"
+)
+
+add_definitions(-DBUILDING_NGHTTP2)
+
+set(NGHTTP2_SOURCES
+  nghttp2_pq.c nghttp2_map.c nghttp2_queue.c
+  nghttp2_frame.c
+  nghttp2_buf.c
+  nghttp2_stream.c nghttp2_outbound_item.c
+  nghttp2_session.c nghttp2_submit.c
+  nghttp2_helper.c
+  nghttp2_npn.c
+  nghttp2_hd.c nghttp2_hd_huffman.c nghttp2_hd_huffman_data.c
+  nghttp2_version.c
+  nghttp2_priority_spec.c
+  nghttp2_option.c
+  nghttp2_callbacks.c
+  nghttp2_mem.c
+  nghttp2_http.c
+  nghttp2_rcbuf.c
+  nghttp2_debug.c
+  nghttp2_ksl.c
+)
+
+set(NGHTTP2_RES "")
+
+if(WIN32)
+  configure_file(
+    version.rc.in
+    ${CMAKE_CURRENT_BINARY_DIR}/version.rc
+    @ONLY)
+
+  set(NGHTTP2_RES ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
+endif()
+
+# Public shared library
+if(ENABLE_SHARED_LIB)
+  add_library(nghttp2 SHARED ${NGHTTP2_SOURCES} ${NGHTTP2_RES})
+  set_target_properties(nghttp2 PROPERTIES
+    COMPILE_FLAGS "${WARNCFLAGS}"
+    VERSION ${LT_VERSION} SOVERSION ${LT_SOVERSION}
+    C_VISIBILITY_PRESET hidden
+  )
+  target_include_directories(nghttp2 INTERFACE
+    "${CMAKE_CURRENT_BINARY_DIR}/includes"
+    "${CMAKE_CURRENT_SOURCE_DIR}/includes"
+  )
+
+  install(TARGETS nghttp2
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+endif()
+
+if(HAVE_CUNIT OR ENABLE_STATIC_LIB)
+  # Static library (for unittests because of symbol visibility)
+  add_library(nghttp2_static STATIC ${NGHTTP2_SOURCES})
+  set_target_properties(nghttp2_static PROPERTIES
+    COMPILE_FLAGS "${WARNCFLAGS}"
+    VERSION ${LT_VERSION} SOVERSION ${LT_SOVERSION}
+    ARCHIVE_OUTPUT_NAME nghttp2${STATIC_LIB_SUFFIX}
+  )
+  target_compile_definitions(nghttp2_static PUBLIC "-DNGHTTP2_STATICLIB")
+  if(ENABLE_STATIC_LIB)
+    install(TARGETS nghttp2_static
+      DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+  endif()
+endif()
+
+
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libnghttp2.pc"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
diff --git a/deps/nghttp2/lib/Makefile.am b/deps/nghttp2/lib/Makefile.am
index 24a5bd62645054cfa1191caf0b611749c323668a..63fa0fa8324d0ad82bb6806e8ede99eb31f3f499 100644
--- a/deps/nghttp2/lib/Makefile.am
+++ b/deps/nghttp2/lib/Makefile.am
@@ -49,7 +49,8 @@ OBJECTS = nghttp2_pq.c nghttp2_map.c nghttp2_queue.c \
 	nghttp2_mem.c \
 	nghttp2_http.c \
 	nghttp2_rcbuf.c \
-	nghttp2_debug.c
+	nghttp2_debug.c \
+	nghttp2_ksl.c
 
 HFILES = nghttp2_pq.h nghttp2_int.h nghttp2_map.h nghttp2_queue.h \
 	nghttp2_frame.h \
@@ -65,7 +66,8 @@ HFILES = nghttp2_pq.h nghttp2_int.h nghttp2_map.h nghttp2_queue.h \
 	nghttp2_mem.h \
 	nghttp2_http.h \
 	nghttp2_rcbuf.h \
-	nghttp2_debug.h
+	nghttp2_debug.h \
+	nghttp2_ksl.h
 
 libnghttp2_la_SOURCES = $(HFILES) $(OBJECTS)
 libnghttp2_la_LDFLAGS = -no-undefined \
diff --git a/deps/nghttp2/lib/Makefile.in b/deps/nghttp2/lib/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..14ec74591ba3dfe4c4546e67ad409c3ac1ce454f
--- /dev/null
+++ b/deps/nghttp2/lib/Makefile.in
@@ -0,0 +1,1028 @@
+# Makefile.in generated by automake 1.16.2 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2020 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+# nghttp2 - HTTP/2 C Library
+
+# Copyright (c) 2012, 2013 Tatsuhiro Tsujikawa
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+target_triplet = @target@
+subdir = lib
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_boost_asio.m4 \
+	$(top_srcdir)/m4/ax_boost_base.m4 \
+	$(top_srcdir)/m4/ax_boost_system.m4 \
+	$(top_srcdir)/m4/ax_boost_thread.m4 \
+	$(top_srcdir)/m4/ax_check_compile_flag.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \
+	$(top_srcdir)/m4/ax_python_devel.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES = libnghttp2.pc
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+libnghttp2_la_LIBADD =
+am__objects_1 =
+am__objects_2 = nghttp2_pq.lo nghttp2_map.lo nghttp2_queue.lo \
+	nghttp2_frame.lo nghttp2_buf.lo nghttp2_stream.lo \
+	nghttp2_outbound_item.lo nghttp2_session.lo nghttp2_submit.lo \
+	nghttp2_helper.lo nghttp2_npn.lo nghttp2_hd.lo \
+	nghttp2_hd_huffman.lo nghttp2_hd_huffman_data.lo \
+	nghttp2_version.lo nghttp2_priority_spec.lo nghttp2_option.lo \
+	nghttp2_callbacks.lo nghttp2_mem.lo nghttp2_http.lo \
+	nghttp2_rcbuf.lo nghttp2_debug.lo nghttp2_ksl.lo
+am_libnghttp2_la_OBJECTS = $(am__objects_1) $(am__objects_2)
+libnghttp2_la_OBJECTS = $(am_libnghttp2_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+libnghttp2_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(libnghttp2_la_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/nghttp2_buf.Plo \
+	./$(DEPDIR)/nghttp2_callbacks.Plo \
+	./$(DEPDIR)/nghttp2_debug.Plo ./$(DEPDIR)/nghttp2_frame.Plo \
+	./$(DEPDIR)/nghttp2_hd.Plo ./$(DEPDIR)/nghttp2_hd_huffman.Plo \
+	./$(DEPDIR)/nghttp2_hd_huffman_data.Plo \
+	./$(DEPDIR)/nghttp2_helper.Plo ./$(DEPDIR)/nghttp2_http.Plo \
+	./$(DEPDIR)/nghttp2_ksl.Plo ./$(DEPDIR)/nghttp2_map.Plo \
+	./$(DEPDIR)/nghttp2_mem.Plo ./$(DEPDIR)/nghttp2_npn.Plo \
+	./$(DEPDIR)/nghttp2_option.Plo \
+	./$(DEPDIR)/nghttp2_outbound_item.Plo \
+	./$(DEPDIR)/nghttp2_pq.Plo \
+	./$(DEPDIR)/nghttp2_priority_spec.Plo \
+	./$(DEPDIR)/nghttp2_queue.Plo ./$(DEPDIR)/nghttp2_rcbuf.Plo \
+	./$(DEPDIR)/nghttp2_session.Plo ./$(DEPDIR)/nghttp2_stream.Plo \
+	./$(DEPDIR)/nghttp2_submit.Plo ./$(DEPDIR)/nghttp2_version.Plo
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 = 
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 = 
+SOURCES = $(libnghttp2_la_SOURCES)
+DIST_SOURCES = $(libnghttp2_la_SOURCES)
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+	ctags-recursive dvi-recursive html-recursive info-recursive \
+	install-data-recursive install-dvi-recursive \
+	install-exec-recursive install-html-recursive \
+	install-info-recursive install-pdf-recursive \
+	install-ps-recursive install-recursive installcheck-recursive \
+	installdirs-recursive pdf-recursive ps-recursive \
+	tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+DATA = $(pkgconfig_DATA)
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
+  distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+  $(RECURSIVE_TARGETS) \
+  $(RECURSIVE_CLEAN_TARGETS) \
+  $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+	distdir distdir-am
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DIST_SUBDIRS = $(SUBDIRS)
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/libnghttp2.pc.in \
+	$(top_srcdir)/depcomp
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+am__relativize = \
+  dir0=`pwd`; \
+  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+  sed_rest='s,^[^/]*/*,,'; \
+  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+  sed_butlast='s,/*[^/]*$$,,'; \
+  while test -n "$$dir1"; do \
+    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+    if test "$$first" != "."; then \
+      if test "$$first" = ".."; then \
+        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+      else \
+        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+        if test "$$first2" = "$$first"; then \
+          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+        else \
+          dir2="../$$dir2"; \
+        fi; \
+        dir0="$$dir0"/"$$first"; \
+      fi; \
+    fi; \
+    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+  done; \
+  reldir="$$dir2"
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+APPLDFLAGS = @APPLDFLAGS@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BOOST_ASIO_LIB = @BOOST_ASIO_LIB@
+BOOST_CPPFLAGS = @BOOST_CPPFLAGS@
+BOOST_LDFLAGS = @BOOST_LDFLAGS@
+BOOST_SYSTEM_LIB = @BOOST_SYSTEM_LIB@
+BOOST_THREAD_LIB = @BOOST_THREAD_LIB@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CUNIT_CFLAGS = @CUNIT_CFLAGS@
+CUNIT_LIBS = @CUNIT_LIBS@
+CXX = @CXX@
+CXX1XCXXFLAGS = @CXX1XCXXFLAGS@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+CYTHON = @CYTHON@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+EXTRACFLAG = @EXTRACFLAG@
+FGREP = @FGREP@
+GREP = @GREP@
+HAVE_CXX14 = @HAVE_CXX14@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+JANSSON_CFLAGS = @JANSSON_CFLAGS@
+JANSSON_LIBS = @JANSSON_LIBS@
+JEMALLOC_LIBS = @JEMALLOC_LIBS@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBCARES_CFLAGS = @LIBCARES_CFLAGS@
+LIBCARES_LIBS = @LIBCARES_LIBS@
+LIBEVENT_OPENSSL_CFLAGS = @LIBEVENT_OPENSSL_CFLAGS@
+LIBEVENT_OPENSSL_LIBS = @LIBEVENT_OPENSSL_LIBS@
+LIBEV_CFLAGS = @LIBEV_CFLAGS@
+LIBEV_LIBS = @LIBEV_LIBS@
+LIBMRUBY_CFLAGS = @LIBMRUBY_CFLAGS@
+LIBMRUBY_LIBS = @LIBMRUBY_LIBS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIBXML2_CFLAGS = @LIBXML2_CFLAGS@
+LIBXML2_LIBS = @LIBXML2_LIBS@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_AGE = @LT_AGE@
+LT_CURRENT = @LT_CURRENT@
+LT_REVISION = @LT_REVISION@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OPENSSL_CFLAGS = @OPENSSL_CFLAGS@
+OPENSSL_LIBS = @OPENSSL_LIBS@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PACKAGE_VERSION_NUM = @PACKAGE_VERSION_NUM@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+SYSTEMD_CFLAGS = @SYSTEMD_CFLAGS@
+SYSTEMD_LIBS = @SYSTEMD_LIBS@
+TESTLDADD = @TESTLDADD@
+VERSION = @VERSION@
+WARNCFLAGS = @WARNCFLAGS@
+WARNCXXFLAGS = @WARNCXXFLAGS@
+ZLIB_CFLAGS = @ZLIB_CFLAGS@
+ZLIB_LIBS = @ZLIB_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_os = @target_os@
+target_vendor = @target_vendor@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+SUBDIRS = includes
+EXTRA_DIST = Makefile.msvc CMakeLists.txt version.rc.in
+AM_CFLAGS = $(WARNCFLAGS) $(EXTRACFLAG)
+AM_CPPFLAGS = -I$(srcdir)/includes -I$(builddir)/includes -DBUILDING_NGHTTP2 \
+	@DEFS@
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libnghttp2.pc
+DISTCLEANFILES = $(pkgconfig_DATA)
+lib_LTLIBRARIES = libnghttp2.la
+OBJECTS = nghttp2_pq.c nghttp2_map.c nghttp2_queue.c \
+	nghttp2_frame.c \
+	nghttp2_buf.c \
+	nghttp2_stream.c nghttp2_outbound_item.c \
+	nghttp2_session.c nghttp2_submit.c \
+	nghttp2_helper.c \
+	nghttp2_npn.c \
+	nghttp2_hd.c nghttp2_hd_huffman.c nghttp2_hd_huffman_data.c \
+	nghttp2_version.c \
+	nghttp2_priority_spec.c \
+	nghttp2_option.c \
+	nghttp2_callbacks.c \
+	nghttp2_mem.c \
+	nghttp2_http.c \
+	nghttp2_rcbuf.c \
+	nghttp2_debug.c \
+	nghttp2_ksl.c
+
+HFILES = nghttp2_pq.h nghttp2_int.h nghttp2_map.h nghttp2_queue.h \
+	nghttp2_frame.h \
+	nghttp2_buf.h \
+	nghttp2_session.h nghttp2_helper.h nghttp2_stream.h nghttp2_int.h \
+	nghttp2_npn.h \
+	nghttp2_submit.h nghttp2_outbound_item.h \
+	nghttp2_net.h \
+	nghttp2_hd.h nghttp2_hd_huffman.h \
+	nghttp2_priority_spec.h \
+	nghttp2_option.h \
+	nghttp2_callbacks.h \
+	nghttp2_mem.h \
+	nghttp2_http.h \
+	nghttp2_rcbuf.h \
+	nghttp2_debug.h \
+	nghttp2_ksl.h
+
+libnghttp2_la_SOURCES = $(HFILES) $(OBJECTS)
+libnghttp2_la_LDFLAGS = -no-undefined \
+	-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
+
+all: all-recursive
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu lib/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+libnghttp2.pc: $(top_builddir)/config.status $(srcdir)/libnghttp2.pc.in
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+	}
+
+uninstall-libLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	for p in $$list; do \
+	  $(am__strip_dir) \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+	done
+
+clean-libLTLIBRARIES:
+	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+	@list='$(lib_LTLIBRARIES)'; \
+	locs=`for p in $$list; do echo $$p; done | \
+	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+	      sort -u`; \
+	test -z "$$locs" || { \
+	  echo rm -f $${locs}; \
+	  rm -f $${locs}; \
+	}
+
+libnghttp2.la: $(libnghttp2_la_OBJECTS) $(libnghttp2_la_DEPENDENCIES) $(EXTRA_libnghttp2_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(libnghttp2_la_LINK) -rpath $(libdir) $(libnghttp2_la_OBJECTS) $(libnghttp2_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_buf.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_callbacks.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_debug.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_frame.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_hd.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_hd_huffman.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_hd_huffman_data.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_helper.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_http.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_ksl.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_map.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_mem.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_npn.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_option.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_outbound_item.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_pq.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_priority_spec.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_queue.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_rcbuf.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_session.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_stream.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_submit.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nghttp2_version.Plo@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
+
+.c.o:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-pkgconfigDATA: $(pkgconfig_DATA)
+	@$(NORMAL_INSTALL)
+	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
+	  $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
+	done
+
+uninstall-pkgconfigDATA:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+#     (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+	@fail=; \
+	if $(am__make_keepgoing); then \
+	  failcom='fail=yes'; \
+	else \
+	  failcom='exit 1'; \
+	fi; \
+	dot_seen=no; \
+	target=`echo $@ | sed s/-recursive//`; \
+	case "$@" in \
+	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+	  *) list='$(SUBDIRS)' ;; \
+	esac; \
+	for subdir in $$list; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    dot_seen=yes; \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done; \
+	if test "$$dot_seen" = "no"; then \
+	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+	fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+	  include_option=--etags-include; \
+	  empty_fix=.; \
+	else \
+	  include_option=--include; \
+	  empty_fix=; \
+	fi; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test ! -f $$subdir/TAGS || \
+	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+	  fi; \
+	done; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    $(am__make_dryrun) \
+	      || test -d "$(distdir)/$$subdir" \
+	      || $(MKDIR_P) "$(distdir)/$$subdir" \
+	      || exit 1; \
+	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+	    $(am__relativize); \
+	    new_distdir=$$reldir; \
+	    dir1=$$subdir; dir2="$(top_distdir)"; \
+	    $(am__relativize); \
+	    new_top_distdir=$$reldir; \
+	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+	    ($(am__cd) $$subdir && \
+	      $(MAKE) $(AM_MAKEFLAGS) \
+	        top_distdir="$$new_top_distdir" \
+	        distdir="$$new_distdir" \
+		am__remove_distdir=: \
+		am__skip_length_check=: \
+		am__skip_mode_fix=: \
+	        distdir) \
+	      || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-recursive
+all-am: Makefile $(LTLIBRARIES) $(DATA)
+installdirs: installdirs-recursive
+installdirs-am:
+	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+	-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
+	mostlyclean-am
+
+distclean: distclean-recursive
+		-rm -f ./$(DEPDIR)/nghttp2_buf.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_callbacks.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_debug.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_frame.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_hd.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_hd_huffman.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_hd_huffman_data.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_helper.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_http.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_ksl.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_map.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_mem.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_npn.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_option.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_outbound_item.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_pq.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_priority_spec.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_queue.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_rcbuf.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_session.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_stream.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_submit.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_version.Plo
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am: install-pkgconfigDATA
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+		-rm -f ./$(DEPDIR)/nghttp2_buf.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_callbacks.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_debug.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_frame.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_hd.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_hd_huffman.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_hd_huffman_data.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_helper.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_http.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_ksl.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_map.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_mem.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_npn.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_option.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_outbound_item.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_pq.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_priority_spec.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_queue.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_rcbuf.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_session.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_stream.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_submit.Plo
+	-rm -f ./$(DEPDIR)/nghttp2_version.Plo
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES uninstall-pkgconfigDATA
+
+.MAKE: $(am__recursive_targets) install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
+	am--depfiles check check-am clean clean-generic \
+	clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \
+	ctags-am distclean distclean-compile distclean-generic \
+	distclean-libtool distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-libLTLIBRARIES install-man install-pdf \
+	install-pdf-am install-pkgconfigDATA install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	installdirs-am maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
+	uninstall-am uninstall-libLTLIBRARIES uninstall-pkgconfigDATA
+
+.PRECIOUS: Makefile
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/deps/nghttp2/lib/includes/Makefile.in b/deps/nghttp2/lib/includes/Makefile.in
new file mode 100644
index 0000000000000000000000000000000000000000..e1948dfeaa3f1c244530feafbfccff6f4ca394ee
--- /dev/null
+++ b/deps/nghttp2/lib/includes/Makefile.in
@@ -0,0 +1,658 @@
+# Makefile.in generated by automake 1.16.2 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2020 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+# nghttp2 - HTTP/2 C Library
+
+# Copyright (c) 2012 Tatsuhiro Tsujikawa
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+target_triplet = @target@
+subdir = lib/includes
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ax_boost_asio.m4 \
+	$(top_srcdir)/m4/ax_boost_base.m4 \
+	$(top_srcdir)/m4/ax_boost_system.m4 \
+	$(top_srcdir)/m4/ax_boost_thread.m4 \
+	$(top_srcdir)/m4/ax_check_compile_flag.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \
+	$(top_srcdir)/m4/ax_python_devel.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(nobase_include_HEADERS) \
+	$(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+SOURCES =
+DIST_SOURCES =
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(includedir)"
+HEADERS = $(nobase_include_HEADERS)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+am__DIST_COMMON = $(srcdir)/Makefile.in
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+APPLDFLAGS = @APPLDFLAGS@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BOOST_ASIO_LIB = @BOOST_ASIO_LIB@
+BOOST_CPPFLAGS = @BOOST_CPPFLAGS@
+BOOST_LDFLAGS = @BOOST_LDFLAGS@
+BOOST_SYSTEM_LIB = @BOOST_SYSTEM_LIB@
+BOOST_THREAD_LIB = @BOOST_THREAD_LIB@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CUNIT_CFLAGS = @CUNIT_CFLAGS@
+CUNIT_LIBS = @CUNIT_LIBS@
+CXX = @CXX@
+CXX1XCXXFLAGS = @CXX1XCXXFLAGS@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+CYTHON = @CYTHON@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+EXTRACFLAG = @EXTRACFLAG@
+FGREP = @FGREP@
+GREP = @GREP@
+HAVE_CXX14 = @HAVE_CXX14@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+JANSSON_CFLAGS = @JANSSON_CFLAGS@
+JANSSON_LIBS = @JANSSON_LIBS@
+JEMALLOC_LIBS = @JEMALLOC_LIBS@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBCARES_CFLAGS = @LIBCARES_CFLAGS@
+LIBCARES_LIBS = @LIBCARES_LIBS@
+LIBEVENT_OPENSSL_CFLAGS = @LIBEVENT_OPENSSL_CFLAGS@
+LIBEVENT_OPENSSL_LIBS = @LIBEVENT_OPENSSL_LIBS@
+LIBEV_CFLAGS = @LIBEV_CFLAGS@
+LIBEV_LIBS = @LIBEV_LIBS@
+LIBMRUBY_CFLAGS = @LIBMRUBY_CFLAGS@
+LIBMRUBY_LIBS = @LIBMRUBY_LIBS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIBXML2_CFLAGS = @LIBXML2_CFLAGS@
+LIBXML2_LIBS = @LIBXML2_LIBS@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_AGE = @LT_AGE@
+LT_CURRENT = @LT_CURRENT@
+LT_REVISION = @LT_REVISION@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OPENSSL_CFLAGS = @OPENSSL_CFLAGS@
+OPENSSL_LIBS = @OPENSSL_LIBS@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PACKAGE_VERSION_NUM = @PACKAGE_VERSION_NUM@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+SYSTEMD_CFLAGS = @SYSTEMD_CFLAGS@
+SYSTEMD_LIBS = @SYSTEMD_LIBS@
+TESTLDADD = @TESTLDADD@
+VERSION = @VERSION@
+WARNCFLAGS = @WARNCFLAGS@
+WARNCXXFLAGS = @WARNCXXFLAGS@
+ZLIB_CFLAGS = @ZLIB_CFLAGS@
+ZLIB_LIBS = @ZLIB_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_os = @target_os@
+target_vendor = @target_vendor@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+EXTRA_DIST = CMakeLists.txt
+nobase_include_HEADERS = nghttp2/nghttp2.h nghttp2/nghttp2ver.h
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/includes/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu lib/includes/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-nobase_includeHEADERS: $(nobase_include_HEADERS)
+	@$(NORMAL_INSTALL)
+	@list='$(nobase_include_HEADERS)'; test -n "$(includedir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \
+	fi; \
+	$(am__nobase_list) | while read dir files; do \
+	  xfiles=; for file in $$files; do \
+	    if test -f "$$file"; then xfiles="$$xfiles $$file"; \
+	    else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \
+	  test -z "$$xfiles" || { \
+	    test "x$$dir" = x. || { \
+	      echo " $(MKDIR_P) '$(DESTDIR)$(includedir)/$$dir'"; \
+	      $(MKDIR_P) "$(DESTDIR)$(includedir)/$$dir"; }; \
+	    echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(includedir)/$$dir'"; \
+	    $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(includedir)/$$dir" || exit $$?; }; \
+	done
+
+uninstall-nobase_includeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(nobase_include_HEADERS)'; test -n "$(includedir)" || list=; \
+	$(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \
+	dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir)
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(HEADERS)
+installdirs:
+	for dir in "$(DESTDIR)$(includedir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-nobase_includeHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-nobase_includeHEADERS
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+	clean-libtool cscopelist-am ctags ctags-am distclean \
+	distclean-generic distclean-libtool distclean-tags distdir dvi \
+	dvi-am html html-am info info-am install install-am \
+	install-data install-data-am install-dvi install-dvi-am \
+	install-exec install-exec-am install-html install-html-am \
+	install-info install-info-am install-man \
+	install-nobase_includeHEADERS install-pdf install-pdf-am \
+	install-ps install-ps-am install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
+	uninstall-am uninstall-nobase_includeHEADERS
+
+.PRECIOUS: Makefile
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h
index 9be6eea5c02257ac12522e43829f47b3f371b857..d9fae5bf0c138e2508aa6e7919e7124c977f7e97 100644
--- a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h
+++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h
@@ -2851,9 +2851,11 @@ NGHTTP2_EXTERN void nghttp2_session_del(nghttp2_session *session);
  *
  * This function retrieves the highest prioritized frame from the
  * outbound queue and sends it to the remote peer.  It does this as
- * many as possible until the user callback
+ * many times as possible until the user callback
  * :type:`nghttp2_send_callback` returns
- * :enum:`NGHTTP2_ERR_WOULDBLOCK` or the outbound queue becomes empty.
+ * :enum:`NGHTTP2_ERR_WOULDBLOCK`, the outbound queue becomes empty
+ * or flow control is triggered (remote window size becomes depleted
+ * or maximum number of concurrent streams is reached).
  * This function calls several callback functions which are passed
  * when initializing the |session|.  Here is the simple time chart
  * which tells when each callback is invoked:
diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h
index 795a44c1e86863119e33e09309d7305e579af132..ff6bf3d3b22e4fc80307a29b9b6e4bf198c4167a 100644
--- a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h
+++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h
@@ -29,7 +29,7 @@
  * @macro
  * Version number of the nghttp2 library release
  */
-#define NGHTTP2_VERSION "1.41.0"
+#define NGHTTP2_VERSION "1.42.0"
 
 /**
  * @macro
@@ -37,6 +37,6 @@
  * release. This is a 24 bit number with 8 bits for major number, 8 bits
  * for minor and 8 bits for patch. Version 1.2.3 becomes 0x010203.
  */
-#define NGHTTP2_VERSION_NUM 0x012900
+#define NGHTTP2_VERSION_NUM 0x012a00
 
 #endif /* NGHTTP2VER_H */
diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h.in b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..7717a647f7558135328d2877ad0f6aa45a3c5518
--- /dev/null
+++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h.in
@@ -0,0 +1,42 @@
+/*
+ * nghttp2 - HTTP/2 C Library
+ *
+ * Copyright (c) 2012, 2013 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NGHTTP2VER_H
+#define NGHTTP2VER_H
+
+/**
+ * @macro
+ * Version number of the nghttp2 library release
+ */
+#define NGHTTP2_VERSION "@PACKAGE_VERSION@"
+
+/**
+ * @macro
+ * Numerical representation of the version number of the nghttp2 library
+ * release. This is a 24 bit number with 8 bits for major number, 8 bits
+ * for minor and 8 bits for patch. Version 1.2.3 becomes 0x010203.
+ */
+#define NGHTTP2_VERSION_NUM @PACKAGE_VERSION_NUM@
+
+#endif /* NGHTTP2VER_H */
diff --git a/deps/nghttp2/lib/nghttp2_buf.c b/deps/nghttp2/lib/nghttp2_buf.c
index 2a435bebf927bd56a54b3a55f7c156b7a7fe5a89..a32844712e449335c3b39bd3c88e73ac0d9281c6 100644
--- a/deps/nghttp2/lib/nghttp2_buf.c
+++ b/deps/nghttp2/lib/nghttp2_buf.c
@@ -82,8 +82,10 @@ void nghttp2_buf_reset(nghttp2_buf *buf) {
 }
 
 void nghttp2_buf_wrap_init(nghttp2_buf *buf, uint8_t *begin, size_t len) {
-  buf->begin = buf->pos = buf->last = buf->mark = begin;
-  buf->end = begin + len;
+  buf->begin = buf->pos = buf->last = buf->mark = buf->end = begin;
+  if (len) {
+    buf->end += len;
+  }
 }
 
 static int buf_chain_new(nghttp2_buf_chain **chain, size_t chunk_length,
diff --git a/deps/nghttp2/lib/nghttp2_frame.c b/deps/nghttp2/lib/nghttp2_frame.c
index 4821de40885736e5a6b312b388b07978cbb811b6..382a26c818dd7bc1fe31cdf860752db691d32329 100644
--- a/deps/nghttp2/lib/nghttp2_frame.c
+++ b/deps/nghttp2/lib/nghttp2_frame.c
@@ -818,8 +818,10 @@ int nghttp2_frame_unpack_origin_payload(nghttp2_extension *frame,
   size_t len = 0;
 
   origin = frame->payload;
-  p = payload;
-  end = p + payloadlen;
+  p = end = payload;
+  if (payloadlen) {
+    end += payloadlen;
+  }
 
   for (; p != end;) {
     if (end - p < 2) {
@@ -897,9 +899,25 @@ nghttp2_settings_entry *nghttp2_frame_iv_copy(const nghttp2_settings_entry *iv,
 }
 
 int nghttp2_nv_equal(const nghttp2_nv *a, const nghttp2_nv *b) {
-  return a->namelen == b->namelen && a->valuelen == b->valuelen &&
-         memcmp(a->name, b->name, a->namelen) == 0 &&
-         memcmp(a->value, b->value, a->valuelen) == 0;
+  if (a->namelen != b->namelen || a->valuelen != b->valuelen) {
+    return 0;
+  }
+
+  if (a->name == NULL || b->name == NULL) {
+    assert(a->namelen == 0);
+    assert(b->namelen == 0);
+  } else if (memcmp(a->name, b->name, a->namelen) != 0) {
+    return 0;
+  }
+
+  if (a->value == NULL || b->value == NULL) {
+    assert(a->valuelen == 0);
+    assert(b->valuelen == 0);
+  } else if (memcmp(a->value, b->value, a->valuelen) != 0) {
+    return 0;
+  }
+
+  return 1;
 }
 
 void nghttp2_nv_array_del(nghttp2_nv *nva, nghttp2_mem *mem) {
diff --git a/deps/nghttp2/lib/nghttp2_ksl.c b/deps/nghttp2/lib/nghttp2_ksl.c
new file mode 100644
index 0000000000000000000000000000000000000000..dffd1cbcffc48483e0fc672c8002b00c20adb42b
--- /dev/null
+++ b/deps/nghttp2/lib/nghttp2_ksl.c
@@ -0,0 +1,707 @@
+/*
+ * nghttp2 - HTTP/2 C Library
+ *
+ * Copyright (c) 2020 nghttp2 contributors
+ * Copyright (c) 2018 ngtcp2 contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "nghttp2_ksl.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include "nghttp2_mem.h"
+
+static size_t ksl_nodelen(size_t keylen) {
+  return (sizeof(nghttp2_ksl_node) + keylen - sizeof(uint64_t) + 0xf) &
+         (size_t)~0xf;
+}
+
+static size_t ksl_blklen(size_t nodelen) {
+  return sizeof(nghttp2_ksl_blk) + nodelen * NGHTTP2_KSL_MAX_NBLK -
+         sizeof(uint64_t);
+}
+
+/*
+ * ksl_node_set_key sets |key| to |node|.
+ */
+static void ksl_node_set_key(nghttp2_ksl *ksl, nghttp2_ksl_node *node,
+                             const void *key) {
+  memcpy(node->key, key, ksl->keylen);
+}
+
+int nghttp2_ksl_init(nghttp2_ksl *ksl, nghttp2_ksl_compar compar, size_t keylen,
+                     nghttp2_mem *mem) {
+  size_t nodelen = ksl_nodelen(keylen);
+  size_t blklen = ksl_blklen(nodelen);
+  nghttp2_ksl_blk *head;
+
+  ksl->head = nghttp2_mem_malloc(mem, blklen);
+  if (!ksl->head) {
+    return NGHTTP2_ERR_NOMEM;
+  }
+  ksl->front = ksl->back = ksl->head;
+  ksl->compar = compar;
+  ksl->keylen = keylen;
+  ksl->nodelen = nodelen;
+  ksl->n = 0;
+  ksl->mem = mem;
+
+  head = ksl->head;
+  head->next = head->prev = NULL;
+  head->n = 0;
+  head->leaf = 1;
+
+  return 0;
+}
+
+/*
+ * ksl_free_blk frees |blk| recursively.
+ */
+static void ksl_free_blk(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk) {
+  size_t i;
+
+  if (!blk->leaf) {
+    for (i = 0; i < blk->n; ++i) {
+      ksl_free_blk(ksl, nghttp2_ksl_nth_node(ksl, blk, i)->blk);
+    }
+  }
+
+  nghttp2_mem_free(ksl->mem, blk);
+}
+
+void nghttp2_ksl_free(nghttp2_ksl *ksl) {
+  if (!ksl) {
+    return;
+  }
+
+  ksl_free_blk(ksl, ksl->head);
+}
+
+/*
+ * ksl_split_blk splits |blk| into 2 nghttp2_ksl_blk objects.  The new
+ * nghttp2_ksl_blk is always the "right" block.
+ *
+ * It returns the pointer to the nghttp2_ksl_blk created which is the
+ * located at the right of |blk|, or NULL which indicates out of
+ * memory error.
+ */
+static nghttp2_ksl_blk *ksl_split_blk(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk) {
+  nghttp2_ksl_blk *rblk;
+
+  rblk = nghttp2_mem_malloc(ksl->mem, ksl_blklen(ksl->nodelen));
+  if (rblk == NULL) {
+    return NULL;
+  }
+
+  rblk->next = blk->next;
+  blk->next = rblk;
+  if (rblk->next) {
+    rblk->next->prev = rblk;
+  } else if (ksl->back == blk) {
+    ksl->back = rblk;
+  }
+  rblk->prev = blk;
+  rblk->leaf = blk->leaf;
+
+  rblk->n = blk->n / 2;
+
+  memcpy(rblk->nodes, blk->nodes + ksl->nodelen * (blk->n - rblk->n),
+         ksl->nodelen * rblk->n);
+
+  blk->n -= rblk->n;
+
+  assert(blk->n >= NGHTTP2_KSL_MIN_NBLK);
+  assert(rblk->n >= NGHTTP2_KSL_MIN_NBLK);
+
+  return rblk;
+}
+
+/*
+ * ksl_split_node splits a node included in |blk| at the position |i|
+ * into 2 adjacent nodes.  The new node is always inserted at the
+ * position |i+1|.
+ *
+ * It returns 0 if it succeeds, or one of the following negative error
+ * codes:
+ *
+ * NGHTTP2_ERR_NOMEM
+ *   Out of memory.
+ */
+static int ksl_split_node(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk, size_t i) {
+  nghttp2_ksl_node *node;
+  nghttp2_ksl_blk *lblk = nghttp2_ksl_nth_node(ksl, blk, i)->blk, *rblk;
+
+  rblk = ksl_split_blk(ksl, lblk);
+  if (rblk == NULL) {
+    return NGHTTP2_ERR_NOMEM;
+  }
+
+  memmove(blk->nodes + (i + 2) * ksl->nodelen,
+          blk->nodes + (i + 1) * ksl->nodelen,
+          ksl->nodelen * (blk->n - (i + 1)));
+
+  node = nghttp2_ksl_nth_node(ksl, blk, i + 1);
+  node->blk = rblk;
+  ++blk->n;
+  ksl_node_set_key(ksl, node,
+                   nghttp2_ksl_nth_node(ksl, rblk, rblk->n - 1)->key);
+
+  node = nghttp2_ksl_nth_node(ksl, blk, i);
+  ksl_node_set_key(ksl, node,
+                   nghttp2_ksl_nth_node(ksl, lblk, lblk->n - 1)->key);
+
+  return 0;
+}
+
+/*
+ * ksl_split_head splits a head (root) block.  It increases the height
+ * of skip list by 1.
+ *
+ * It returns 0 if it succeeds, or one of the following negative error
+ * codes:
+ *
+ * NGHTTP2_ERR_NOMEM
+ *   Out of memory.
+ */
+static int ksl_split_head(nghttp2_ksl *ksl) {
+  nghttp2_ksl_blk *rblk = NULL, *lblk, *nhead = NULL;
+  nghttp2_ksl_node *node;
+
+  rblk = ksl_split_blk(ksl, ksl->head);
+  if (rblk == NULL) {
+    return NGHTTP2_ERR_NOMEM;
+  }
+
+  lblk = ksl->head;
+
+  nhead = nghttp2_mem_malloc(ksl->mem, ksl_blklen(ksl->nodelen));
+  if (nhead == NULL) {
+    nghttp2_mem_free(ksl->mem, rblk);
+    return NGHTTP2_ERR_NOMEM;
+  }
+  nhead->next = nhead->prev = NULL;
+  nhead->n = 2;
+  nhead->leaf = 0;
+
+  node = nghttp2_ksl_nth_node(ksl, nhead, 0);
+  ksl_node_set_key(ksl, node,
+                   nghttp2_ksl_nth_node(ksl, lblk, lblk->n - 1)->key);
+  node->blk = lblk;
+
+  node = nghttp2_ksl_nth_node(ksl, nhead, 1);
+  ksl_node_set_key(ksl, node,
+                   nghttp2_ksl_nth_node(ksl, rblk, rblk->n - 1)->key);
+  node->blk = rblk;
+
+  ksl->head = nhead;
+
+  return 0;
+}
+
+/*
+ * insert_node inserts a node whose key is |key| with the associated
+ * |data| at the index of |i|.  This function assumes that the number
+ * of nodes contained by |blk| is strictly less than
+ * NGHTTP2_KSL_MAX_NBLK.
+ */
+static void ksl_insert_node(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk, size_t i,
+                            const nghttp2_ksl_key *key, void *data) {
+  nghttp2_ksl_node *node;
+
+  assert(blk->n < NGHTTP2_KSL_MAX_NBLK);
+
+  memmove(blk->nodes + (i + 1) * ksl->nodelen, blk->nodes + i * ksl->nodelen,
+          ksl->nodelen * (blk->n - i));
+
+  node = nghttp2_ksl_nth_node(ksl, blk, i);
+  ksl_node_set_key(ksl, node, key);
+  node->data = data;
+
+  ++blk->n;
+}
+
+static size_t ksl_bsearch(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk,
+                          const nghttp2_ksl_key *key,
+                          nghttp2_ksl_compar compar) {
+  ssize_t left = -1, right = (ssize_t)blk->n, mid;
+  nghttp2_ksl_node *node;
+
+  while (right - left > 1) {
+    mid = (left + right) / 2;
+    node = nghttp2_ksl_nth_node(ksl, blk, (size_t)mid);
+    if (compar((nghttp2_ksl_key *)node->key, key)) {
+      left = mid;
+    } else {
+      right = mid;
+    }
+  }
+
+  return (size_t)right;
+}
+
+int nghttp2_ksl_insert(nghttp2_ksl *ksl, nghttp2_ksl_it *it,
+                       const nghttp2_ksl_key *key, void *data) {
+  nghttp2_ksl_blk *blk = ksl->head;
+  nghttp2_ksl_node *node;
+  size_t i;
+  int rv;
+
+  if (blk->n == NGHTTP2_KSL_MAX_NBLK) {
+    rv = ksl_split_head(ksl);
+    if (rv != 0) {
+      return rv;
+    }
+    blk = ksl->head;
+  }
+
+  for (;;) {
+    i = ksl_bsearch(ksl, blk, key, ksl->compar);
+
+    if (blk->leaf) {
+      if (i < blk->n &&
+          !ksl->compar(key, nghttp2_ksl_nth_node(ksl, blk, i)->key)) {
+        if (it) {
+          *it = nghttp2_ksl_end(ksl);
+        }
+        return NGHTTP2_ERR_INVALID_ARGUMENT;
+      }
+      ksl_insert_node(ksl, blk, i, key, data);
+      ++ksl->n;
+      if (it) {
+        nghttp2_ksl_it_init(it, ksl, blk, i);
+      }
+      return 0;
+    }
+
+    if (i == blk->n) {
+      /* This insertion extends the largest key in this subtree. */
+      for (; !blk->leaf;) {
+        node = nghttp2_ksl_nth_node(ksl, blk, blk->n - 1);
+        if (node->blk->n == NGHTTP2_KSL_MAX_NBLK) {
+          rv = ksl_split_node(ksl, blk, blk->n - 1);
+          if (rv != 0) {
+            return rv;
+          }
+          node = nghttp2_ksl_nth_node(ksl, blk, blk->n - 1);
+        }
+        ksl_node_set_key(ksl, node, key);
+        blk = node->blk;
+      }
+      ksl_insert_node(ksl, blk, blk->n, key, data);
+      ++ksl->n;
+      if (it) {
+        nghttp2_ksl_it_init(it, ksl, blk, blk->n - 1);
+      }
+      return 0;
+    }
+
+    node = nghttp2_ksl_nth_node(ksl, blk, i);
+
+    if (node->blk->n == NGHTTP2_KSL_MAX_NBLK) {
+      rv = ksl_split_node(ksl, blk, i);
+      if (rv != 0) {
+        return rv;
+      }
+      if (ksl->compar((nghttp2_ksl_key *)node->key, key)) {
+        node = nghttp2_ksl_nth_node(ksl, blk, i + 1);
+        if (ksl->compar((nghttp2_ksl_key *)node->key, key)) {
+          ksl_node_set_key(ksl, node, key);
+        }
+      }
+    }
+
+    blk = node->blk;
+  }
+}
+
+/*
+ * ksl_remove_node removes the node included in |blk| at the index of
+ * |i|.
+ */
+static void ksl_remove_node(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk, size_t i) {
+  memmove(blk->nodes + i * ksl->nodelen, blk->nodes + (i + 1) * ksl->nodelen,
+          ksl->nodelen * (blk->n - (i + 1)));
+
+  --blk->n;
+}
+
+/*
+ * ksl_merge_node merges 2 nodes which are the nodes at the index of
+ * |i| and |i + 1|.
+ *
+ * If |blk| is the direct descendant of head (root) block and the head
+ * block contains just 2 nodes, the merged block becomes head block,
+ * which decreases the height of |ksl| by 1.
+ *
+ * This function returns the pointer to the merged block.
+ */
+static nghttp2_ksl_blk *ksl_merge_node(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk,
+                                       size_t i) {
+  nghttp2_ksl_blk *lblk, *rblk;
+
+  assert(i + 1 < blk->n);
+
+  lblk = nghttp2_ksl_nth_node(ksl, blk, i)->blk;
+  rblk = nghttp2_ksl_nth_node(ksl, blk, i + 1)->blk;
+
+  assert(lblk->n + rblk->n < NGHTTP2_KSL_MAX_NBLK);
+
+  memcpy(lblk->nodes + ksl->nodelen * lblk->n, rblk->nodes,
+         ksl->nodelen * rblk->n);
+
+  lblk->n += rblk->n;
+  lblk->next = rblk->next;
+  if (lblk->next) {
+    lblk->next->prev = lblk;
+  } else if (ksl->back == rblk) {
+    ksl->back = lblk;
+  }
+
+  nghttp2_mem_free(ksl->mem, rblk);
+
+  if (ksl->head == blk && blk->n == 2) {
+    nghttp2_mem_free(ksl->mem, ksl->head);
+    ksl->head = lblk;
+  } else {
+    ksl_remove_node(ksl, blk, i + 1);
+    ksl_node_set_key(ksl, nghttp2_ksl_nth_node(ksl, blk, i),
+                     nghttp2_ksl_nth_node(ksl, lblk, lblk->n - 1)->key);
+  }
+
+  return lblk;
+}
+
+/*
+ * ksl_shift_left moves the first node in blk->nodes[i]->blk->nodes to
+ * blk->nodes[i - 1]->blk->nodes.
+ */
+static void ksl_shift_left(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk, size_t i) {
+  nghttp2_ksl_node *lnode, *rnode, *dest, *src;
+
+  assert(i > 0);
+
+  lnode = nghttp2_ksl_nth_node(ksl, blk, i - 1);
+  rnode = nghttp2_ksl_nth_node(ksl, blk, i);
+
+  assert(lnode->blk->n < NGHTTP2_KSL_MAX_NBLK);
+  assert(rnode->blk->n > NGHTTP2_KSL_MIN_NBLK);
+
+  dest = nghttp2_ksl_nth_node(ksl, lnode->blk, lnode->blk->n);
+  src = nghttp2_ksl_nth_node(ksl, rnode->blk, 0);
+
+  memcpy(dest, src, ksl->nodelen);
+  ksl_node_set_key(ksl, lnode, dest->key);
+  ++lnode->blk->n;
+
+  --rnode->blk->n;
+  memmove(rnode->blk->nodes, rnode->blk->nodes + ksl->nodelen,
+          ksl->nodelen * rnode->blk->n);
+}
+
+/*
+ * ksl_shift_right moves the last node in blk->nodes[i]->blk->nodes to
+ * blk->nodes[i + 1]->blk->nodes.
+ */
+static void ksl_shift_right(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk, size_t i) {
+  nghttp2_ksl_node *lnode, *rnode, *dest, *src;
+
+  assert(i < blk->n - 1);
+
+  lnode = nghttp2_ksl_nth_node(ksl, blk, i);
+  rnode = nghttp2_ksl_nth_node(ksl, blk, i + 1);
+
+  assert(lnode->blk->n > NGHTTP2_KSL_MIN_NBLK);
+  assert(rnode->blk->n < NGHTTP2_KSL_MAX_NBLK);
+
+  memmove(rnode->blk->nodes + ksl->nodelen, rnode->blk->nodes,
+          ksl->nodelen * rnode->blk->n);
+  ++rnode->blk->n;
+
+  dest = nghttp2_ksl_nth_node(ksl, rnode->blk, 0);
+  src = nghttp2_ksl_nth_node(ksl, lnode->blk, lnode->blk->n - 1);
+
+  memcpy(dest, src, ksl->nodelen);
+
+  --lnode->blk->n;
+  ksl_node_set_key(
+      ksl, lnode,
+      nghttp2_ksl_nth_node(ksl, lnode->blk, lnode->blk->n - 1)->key);
+}
+
+/*
+ * key_equal returns nonzero if |lhs| and |rhs| are equal using the
+ * function |compar|.
+ */
+static int key_equal(nghttp2_ksl_compar compar, const nghttp2_ksl_key *lhs,
+                     const nghttp2_ksl_key *rhs) {
+  return !compar(lhs, rhs) && !compar(rhs, lhs);
+}
+
+int nghttp2_ksl_remove(nghttp2_ksl *ksl, nghttp2_ksl_it *it,
+                       const nghttp2_ksl_key *key) {
+  nghttp2_ksl_blk *blk = ksl->head;
+  nghttp2_ksl_node *node;
+  size_t i;
+
+  if (!blk->leaf && blk->n == 2 &&
+      nghttp2_ksl_nth_node(ksl, blk, 0)->blk->n == NGHTTP2_KSL_MIN_NBLK &&
+      nghttp2_ksl_nth_node(ksl, blk, 1)->blk->n == NGHTTP2_KSL_MIN_NBLK) {
+    blk = ksl_merge_node(ksl, ksl->head, 0);
+  }
+
+  for (;;) {
+    i = ksl_bsearch(ksl, blk, key, ksl->compar);
+
+    if (i == blk->n) {
+      if (it) {
+        *it = nghttp2_ksl_end(ksl);
+      }
+      return NGHTTP2_ERR_INVALID_ARGUMENT;
+    }
+
+    if (blk->leaf) {
+      if (ksl->compar(key, nghttp2_ksl_nth_node(ksl, blk, i)->key)) {
+        if (it) {
+          *it = nghttp2_ksl_end(ksl);
+        }
+        return NGHTTP2_ERR_INVALID_ARGUMENT;
+      }
+      ksl_remove_node(ksl, blk, i);
+      --ksl->n;
+      if (it) {
+        if (blk->n == i && blk->next) {
+          nghttp2_ksl_it_init(it, ksl, blk->next, 0);
+        } else {
+          nghttp2_ksl_it_init(it, ksl, blk, i);
+        }
+      }
+      return 0;
+    }
+
+    node = nghttp2_ksl_nth_node(ksl, blk, i);
+
+    if (node->blk->n == NGHTTP2_KSL_MIN_NBLK) {
+      if (i > 0 && nghttp2_ksl_nth_node(ksl, blk, i - 1)->blk->n >
+                       NGHTTP2_KSL_MIN_NBLK) {
+        ksl_shift_right(ksl, blk, i - 1);
+        blk = node->blk;
+      } else if (i + 1 < blk->n &&
+                 nghttp2_ksl_nth_node(ksl, blk, i + 1)->blk->n >
+                     NGHTTP2_KSL_MIN_NBLK) {
+        ksl_shift_left(ksl, blk, i + 1);
+        blk = node->blk;
+      } else if (i > 0) {
+        blk = ksl_merge_node(ksl, blk, i - 1);
+      } else {
+        assert(i + 1 < blk->n);
+        blk = ksl_merge_node(ksl, blk, i);
+      }
+    } else {
+      blk = node->blk;
+    }
+  }
+}
+
+nghttp2_ksl_it nghttp2_ksl_lower_bound(nghttp2_ksl *ksl,
+                                       const nghttp2_ksl_key *key) {
+  nghttp2_ksl_blk *blk = ksl->head;
+  nghttp2_ksl_it it;
+  size_t i;
+
+  for (;;) {
+    i = ksl_bsearch(ksl, blk, key, ksl->compar);
+
+    if (blk->leaf) {
+      if (i == blk->n && blk->next) {
+        blk = blk->next;
+        i = 0;
+      }
+      nghttp2_ksl_it_init(&it, ksl, blk, i);
+      return it;
+    }
+
+    if (i == blk->n) {
+      /* This happens if descendant has smaller key.  Fast forward to
+         find last node in this subtree. */
+      for (; !blk->leaf; blk = nghttp2_ksl_nth_node(ksl, blk, blk->n - 1)->blk)
+        ;
+      if (blk->next) {
+        blk = blk->next;
+        i = 0;
+      } else {
+        i = blk->n;
+      }
+      nghttp2_ksl_it_init(&it, ksl, blk, i);
+      return it;
+    }
+    blk = nghttp2_ksl_nth_node(ksl, blk, i)->blk;
+  }
+}
+
+nghttp2_ksl_it nghttp2_ksl_lower_bound_compar(nghttp2_ksl *ksl,
+                                              const nghttp2_ksl_key *key,
+                                              nghttp2_ksl_compar compar) {
+  nghttp2_ksl_blk *blk = ksl->head;
+  nghttp2_ksl_it it;
+  size_t i;
+
+  for (;;) {
+    i = ksl_bsearch(ksl, blk, key, compar);
+
+    if (blk->leaf) {
+      if (i == blk->n && blk->next) {
+        blk = blk->next;
+        i = 0;
+      }
+      nghttp2_ksl_it_init(&it, ksl, blk, i);
+      return it;
+    }
+
+    if (i == blk->n) {
+      /* This happens if descendant has smaller key.  Fast forward to
+         find last node in this subtree. */
+      for (; !blk->leaf; blk = nghttp2_ksl_nth_node(ksl, blk, blk->n - 1)->blk)
+        ;
+      if (blk->next) {
+        blk = blk->next;
+        i = 0;
+      } else {
+        i = blk->n;
+      }
+      nghttp2_ksl_it_init(&it, ksl, blk, i);
+      return it;
+    }
+    blk = nghttp2_ksl_nth_node(ksl, blk, i)->blk;
+  }
+}
+
+void nghttp2_ksl_update_key(nghttp2_ksl *ksl, const nghttp2_ksl_key *old_key,
+                            const nghttp2_ksl_key *new_key) {
+  nghttp2_ksl_blk *blk = ksl->head;
+  nghttp2_ksl_node *node;
+  size_t i;
+
+  for (;;) {
+    i = ksl_bsearch(ksl, blk, old_key, ksl->compar);
+
+    assert(i < blk->n);
+    node = nghttp2_ksl_nth_node(ksl, blk, i);
+
+    if (blk->leaf) {
+      assert(key_equal(ksl->compar, (nghttp2_ksl_key *)node->key, old_key));
+      ksl_node_set_key(ksl, node, new_key);
+      return;
+    }
+
+    if (key_equal(ksl->compar, (nghttp2_ksl_key *)node->key, old_key) ||
+        ksl->compar((nghttp2_ksl_key *)node->key, new_key)) {
+      ksl_node_set_key(ksl, node, new_key);
+    }
+
+    blk = node->blk;
+  }
+}
+
+static void ksl_print(nghttp2_ksl *ksl, nghttp2_ksl_blk *blk, size_t level) {
+  size_t i;
+  nghttp2_ksl_node *node;
+
+  fprintf(stderr, "LV=%zu n=%zu\n", level, blk->n);
+
+  if (blk->leaf) {
+    for (i = 0; i < blk->n; ++i) {
+      node = nghttp2_ksl_nth_node(ksl, blk, i);
+      fprintf(stderr, " %" PRId64, *(int64_t *)(void *)node->key);
+    }
+    fprintf(stderr, "\n");
+    return;
+  }
+
+  for (i = 0; i < blk->n; ++i) {
+    ksl_print(ksl, nghttp2_ksl_nth_node(ksl, blk, i)->blk, level + 1);
+  }
+}
+
+size_t nghttp2_ksl_len(nghttp2_ksl *ksl) { return ksl->n; }
+
+void nghttp2_ksl_clear(nghttp2_ksl *ksl) {
+  size_t i;
+  nghttp2_ksl_blk *head;
+
+  if (!ksl->head->leaf) {
+    for (i = 0; i < ksl->head->n; ++i) {
+      ksl_free_blk(ksl, nghttp2_ksl_nth_node(ksl, ksl->head, i)->blk);
+    }
+  }
+
+  ksl->front = ksl->back = ksl->head;
+  ksl->n = 0;
+
+  head = ksl->head;
+
+  head->next = head->prev = NULL;
+  head->n = 0;
+  head->leaf = 1;
+}
+
+void nghttp2_ksl_print(nghttp2_ksl *ksl) { ksl_print(ksl, ksl->head, 0); }
+
+nghttp2_ksl_it nghttp2_ksl_begin(const nghttp2_ksl *ksl) {
+  nghttp2_ksl_it it;
+  nghttp2_ksl_it_init(&it, ksl, ksl->front, 0);
+  return it;
+}
+
+nghttp2_ksl_it nghttp2_ksl_end(const nghttp2_ksl *ksl) {
+  nghttp2_ksl_it it;
+  nghttp2_ksl_it_init(&it, ksl, ksl->back, ksl->back->n);
+  return it;
+}
+
+void nghttp2_ksl_it_init(nghttp2_ksl_it *it, const nghttp2_ksl *ksl,
+                         nghttp2_ksl_blk *blk, size_t i) {
+  it->ksl = ksl;
+  it->blk = blk;
+  it->i = i;
+}
+
+void *nghttp2_ksl_it_get(const nghttp2_ksl_it *it) {
+  assert(it->i < it->blk->n);
+  return nghttp2_ksl_nth_node(it->ksl, it->blk, it->i)->data;
+}
+
+void nghttp2_ksl_it_prev(nghttp2_ksl_it *it) {
+  assert(!nghttp2_ksl_it_begin(it));
+
+  if (it->i == 0) {
+    it->blk = it->blk->prev;
+    it->i = it->blk->n - 1;
+  } else {
+    --it->i;
+  }
+}
+
+int nghttp2_ksl_it_begin(const nghttp2_ksl_it *it) {
+  return it->i == 0 && it->blk->prev == NULL;
+}
diff --git a/deps/nghttp2/lib/nghttp2_ksl.h b/deps/nghttp2/lib/nghttp2_ksl.h
new file mode 100644
index 0000000000000000000000000000000000000000..39d900ffbf5bd60bdd47ab4ea0bf49548b593076
--- /dev/null
+++ b/deps/nghttp2/lib/nghttp2_ksl.h
@@ -0,0 +1,315 @@
+/*
+ * nghttp2 - HTTP/2 C Library
+ *
+ * Copyright (c) 2020 nghttp2 contributors
+ * Copyright (c) 2018 ngtcp2 contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NGHTTP2_KSL_H
+#define NGHTTP2_KSL_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+
+#include <nghttp2/nghttp2.h>
+
+/*
+ * Skip List using single key instead of range.
+ */
+
+#define NGHTTP2_KSL_DEGR 16
+/* NGHTTP2_KSL_MAX_NBLK is the maximum number of nodes which a single
+   block can contain. */
+#define NGHTTP2_KSL_MAX_NBLK (2 * NGHTTP2_KSL_DEGR - 1)
+/* NGHTTP2_KSL_MIN_NBLK is the minimum number of nodes which a single
+   block other than root must contains. */
+#define NGHTTP2_KSL_MIN_NBLK (NGHTTP2_KSL_DEGR - 1)
+
+/*
+ * nghttp2_ksl_key represents key in nghttp2_ksl.
+ */
+typedef void nghttp2_ksl_key;
+
+struct nghttp2_ksl_node;
+typedef struct nghttp2_ksl_node nghttp2_ksl_node;
+
+struct nghttp2_ksl_blk;
+typedef struct nghttp2_ksl_blk nghttp2_ksl_blk;
+
+/*
+ * nghttp2_ksl_node is a node which contains either nghttp2_ksl_blk or
+ * opaque data.  If a node is an internal node, it contains
+ * nghttp2_ksl_blk.  Otherwise, it has data.  The key is stored at the
+ * location starting at key.
+ */
+struct nghttp2_ksl_node {
+  union {
+    nghttp2_ksl_blk *blk;
+    void *data;
+  };
+  union {
+    uint64_t align;
+    /* key is a buffer to include key associated to this node.
+       Because the length of key is unknown until nghttp2_ksl_init is
+       called, the actual buffer will be allocated after this
+       field. */
+    uint8_t key[1];
+  };
+};
+
+/*
+ * nghttp2_ksl_blk contains nghttp2_ksl_node objects.
+ */
+struct nghttp2_ksl_blk {
+  /* next points to the next block if leaf field is nonzero. */
+  nghttp2_ksl_blk *next;
+  /* prev points to the previous block if leaf field is nonzero. */
+  nghttp2_ksl_blk *prev;
+  /* n is the number of nodes this object contains in nodes. */
+  size_t n;
+  /* leaf is nonzero if this block contains leaf nodes. */
+  int leaf;
+  union {
+    uint64_t align;
+    /* nodes is a buffer to contain NGHTTP2_KSL_MAX_NBLK
+       nghttp2_ksl_node objects.  Because nghttp2_ksl_node object is
+       allocated along with the additional variable length key
+       storage, the size of buffer is unknown until nghttp2_ksl_init is
+       called. */
+    uint8_t nodes[1];
+  };
+};
+
+/*
+ * nghttp2_ksl_compar is a function type which returns nonzero if key
+ * |lhs| should be placed before |rhs|.  It returns 0 otherwise.
+ */
+typedef int (*nghttp2_ksl_compar)(const nghttp2_ksl_key *lhs,
+                                  const nghttp2_ksl_key *rhs);
+
+struct nghttp2_ksl;
+typedef struct nghttp2_ksl nghttp2_ksl;
+
+struct nghttp2_ksl_it;
+typedef struct nghttp2_ksl_it nghttp2_ksl_it;
+
+/*
+ * nghttp2_ksl_it is a forward iterator to iterate nodes.
+ */
+struct nghttp2_ksl_it {
+  const nghttp2_ksl *ksl;
+  nghttp2_ksl_blk *blk;
+  size_t i;
+};
+
+/*
+ * nghttp2_ksl is a deterministic paged skip list.
+ */
+struct nghttp2_ksl {
+  /* head points to the root block. */
+  nghttp2_ksl_blk *head;
+  /* front points to the first leaf block. */
+  nghttp2_ksl_blk *front;
+  /* back points to the last leaf block. */
+  nghttp2_ksl_blk *back;
+  nghttp2_ksl_compar compar;
+  size_t n;
+  /* keylen is the size of key */
+  size_t keylen;
+  /* nodelen is the actual size of nghttp2_ksl_node including key
+     storage. */
+  size_t nodelen;
+  nghttp2_mem *mem;
+};
+
+/*
+ * nghttp2_ksl_init initializes |ksl|.  |compar| specifies compare
+ * function.  |keylen| is the length of key.
+ *
+ * It returns 0 if it succeeds, or one of the following negative error
+ * codes:
+ *
+ * NGHTTP2_ERR_NOMEM
+ *   Out of memory.
+ */
+int nghttp2_ksl_init(nghttp2_ksl *ksl, nghttp2_ksl_compar compar, size_t keylen,
+                     nghttp2_mem *mem);
+
+/*
+ * nghttp2_ksl_free frees resources allocated for |ksl|.  If |ksl| is
+ * NULL, this function does nothing.  It does not free the memory
+ * region pointed by |ksl| itself.
+ */
+void nghttp2_ksl_free(nghttp2_ksl *ksl);
+
+/*
+ * nghttp2_ksl_insert inserts |key| with its associated |data|.  On
+ * successful insertion, the iterator points to the inserted node is
+ * stored in |*it|.
+ *
+ * This function returns 0 if it succeeds, or one of the following
+ * negative error codes:
+ *
+ * NGHTTP2_ERR_NOMEM
+ *   Out of memory.
+ * NGHTTP2_ERR_INVALID_ARGUMENT
+ *   |key| already exists.
+ */
+int nghttp2_ksl_insert(nghttp2_ksl *ksl, nghttp2_ksl_it *it,
+                       const nghttp2_ksl_key *key, void *data);
+
+/*
+ * nghttp2_ksl_remove removes the |key| from |ksl|.
+ *
+ * This function assigns the iterator to |*it|, which points to the
+ * node which is located at the right next of the removed node if |it|
+ * is not NULL.  If |key| is not found, no deletion takes place and
+ * the return value of nghttp2_ksl_end(ksl) is assigned to |*it|.
+ *
+ * This function returns 0 if it succeeds, or one of the following
+ * negative error codes:
+ *
+ * NGHTTP2_ERR_INVALID_ARGUMENT
+ *   |key| does not exist.
+ */
+int nghttp2_ksl_remove(nghttp2_ksl *ksl, nghttp2_ksl_it *it,
+                       const nghttp2_ksl_key *key);
+
+/*
+ * nghttp2_ksl_lower_bound returns the iterator which points to the
+ * first node which has the key which is equal to |key| or the last
+ * node which satisfies !compar(&node->key, key).  If there is no such
+ * node, it returns the iterator which satisfies nghttp2_ksl_it_end(it)
+ * != 0.
+ */
+nghttp2_ksl_it nghttp2_ksl_lower_bound(nghttp2_ksl *ksl,
+                                       const nghttp2_ksl_key *key);
+
+/*
+ * nghttp2_ksl_lower_bound_compar works like nghttp2_ksl_lower_bound,
+ * but it takes custom function |compar| to do lower bound search.
+ */
+nghttp2_ksl_it nghttp2_ksl_lower_bound_compar(nghttp2_ksl *ksl,
+                                              const nghttp2_ksl_key *key,
+                                              nghttp2_ksl_compar compar);
+
+/*
+ * nghttp2_ksl_update_key replaces the key of nodes which has |old_key|
+ * with |new_key|.  |new_key| must be strictly greater than the
+ * previous node and strictly smaller than the next node.
+ */
+void nghttp2_ksl_update_key(nghttp2_ksl *ksl, const nghttp2_ksl_key *old_key,
+                            const nghttp2_ksl_key *new_key);
+
+/*
+ * nghttp2_ksl_begin returns the iterator which points to the first
+ * node.  If there is no node in |ksl|, it returns the iterator which
+ * satisfies nghttp2_ksl_it_end(it) != 0.
+ */
+nghttp2_ksl_it nghttp2_ksl_begin(const nghttp2_ksl *ksl);
+
+/*
+ * nghttp2_ksl_end returns the iterator which points to the node
+ * following the last node.  The returned object satisfies
+ * nghttp2_ksl_it_end().  If there is no node in |ksl|, it returns the
+ * iterator which satisfies nghttp2_ksl_it_begin(it) != 0.
+ */
+nghttp2_ksl_it nghttp2_ksl_end(const nghttp2_ksl *ksl);
+
+/*
+ * nghttp2_ksl_len returns the number of elements stored in |ksl|.
+ */
+size_t nghttp2_ksl_len(nghttp2_ksl *ksl);
+
+/*
+ * nghttp2_ksl_clear removes all elements stored in |ksl|.
+ */
+void nghttp2_ksl_clear(nghttp2_ksl *ksl);
+
+/*
+ * nghttp2_ksl_nth_node returns the |n|th node under |blk|.
+ */
+#define nghttp2_ksl_nth_node(KSL, BLK, N)                                      \
+  ((nghttp2_ksl_node *)(void *)((BLK)->nodes + (KSL)->nodelen * (N)))
+
+/*
+ * nghttp2_ksl_print prints its internal state in stderr.  It assumes
+ * that the key is of type int64_t.  This function should be used for
+ * the debugging purpose only.
+ */
+void nghttp2_ksl_print(nghttp2_ksl *ksl);
+
+/*
+ * nghttp2_ksl_it_init initializes |it|.
+ */
+void nghttp2_ksl_it_init(nghttp2_ksl_it *it, const nghttp2_ksl *ksl,
+                         nghttp2_ksl_blk *blk, size_t i);
+
+/*
+ * nghttp2_ksl_it_get returns the data associated to the node which
+ * |it| points to.  It is undefined to call this function when
+ * nghttp2_ksl_it_end(it) returns nonzero.
+ */
+void *nghttp2_ksl_it_get(const nghttp2_ksl_it *it);
+
+/*
+ * nghttp2_ksl_it_next advances the iterator by one.  It is undefined
+ * if this function is called when nghttp2_ksl_it_end(it) returns
+ * nonzero.
+ */
+#define nghttp2_ksl_it_next(IT)                                                \
+  (++(IT)->i == (IT)->blk->n && (IT)->blk->next                                \
+       ? ((IT)->blk = (IT)->blk->next, (IT)->i = 0)                            \
+       : 0)
+
+/*
+ * nghttp2_ksl_it_prev moves backward the iterator by one.  It is
+ * undefined if this function is called when nghttp2_ksl_it_begin(it)
+ * returns nonzero.
+ */
+void nghttp2_ksl_it_prev(nghttp2_ksl_it *it);
+
+/*
+ * nghttp2_ksl_it_end returns nonzero if |it| points to the beyond the
+ * last node.
+ */
+#define nghttp2_ksl_it_end(IT)                                                 \
+  ((IT)->blk->n == (IT)->i && (IT)->blk->next == NULL)
+
+/*
+ * nghttp2_ksl_it_begin returns nonzero if |it| points to the first
+ * node.  |it| might satisfy both nghttp2_ksl_it_begin(&it) and
+ * nghttp2_ksl_it_end(&it) if the skip list has no node.
+ */
+int nghttp2_ksl_it_begin(const nghttp2_ksl_it *it);
+
+/*
+ * nghttp2_ksl_key returns the key of the node which |it| points to.
+ * It is undefined to call this function when nghttp2_ksl_it_end(it)
+ * returns nonzero.
+ */
+#define nghttp2_ksl_it_key(IT)                                                 \
+  ((nghttp2_ksl_key *)nghttp2_ksl_nth_node((IT)->ksl, (IT)->blk, (IT)->i)->key)
+
+#endif /* NGHTTP2_KSL_H */
diff --git a/deps/nghttp2/lib/nghttp2_map.c b/deps/nghttp2/lib/nghttp2_map.c
index 4d9f97b47e2f54cb877be40bd0dafae7ad87c022..d12a1f4757b72575c30c0136d3ae7d2866433542 100644
--- a/deps/nghttp2/lib/nghttp2_map.c
+++ b/deps/nghttp2/lib/nghttp2_map.c
@@ -1,7 +1,8 @@
 /*
  * nghttp2 - HTTP/2 C Library
  *
- * Copyright (c) 2012 Tatsuhiro Tsujikawa
+ * Copyright (c) 2017 ngtcp2 contributors
+ * Copyright (c) 2012 nghttp2 contributors
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -25,6 +26,9 @@
 #include "nghttp2_map.h"
 
 #include <string.h>
+#include <assert.h>
+
+#include "nghttp2_helper.h"
 
 #define INITIAL_TABLE_LENGTH 256
 
@@ -32,7 +36,7 @@ int nghttp2_map_init(nghttp2_map *map, nghttp2_mem *mem) {
   map->mem = mem;
   map->tablelen = INITIAL_TABLE_LENGTH;
   map->table =
-      nghttp2_mem_calloc(mem, map->tablelen, sizeof(nghttp2_map_entry *));
+      nghttp2_mem_calloc(mem, map->tablelen, sizeof(nghttp2_map_bucket));
   if (map->table == NULL) {
     return NGHTTP2_ERR_NOMEM;
   }
@@ -43,6 +47,21 @@ int nghttp2_map_init(nghttp2_map *map, nghttp2_mem *mem) {
 }
 
 void nghttp2_map_free(nghttp2_map *map) {
+  size_t i;
+  nghttp2_map_bucket *bkt;
+
+  if (!map) {
+    return;
+  }
+
+  for (i = 0; i < map->tablelen; ++i) {
+    bkt = &map->table[i];
+    if (bkt->ksl) {
+      nghttp2_ksl_free(bkt->ksl);
+      nghttp2_mem_free(map->mem, bkt->ksl);
+    }
+  }
+
   nghttp2_mem_free(map->mem, map->table);
 }
 
@@ -50,14 +69,29 @@ void nghttp2_map_each_free(nghttp2_map *map,
                            int (*func)(nghttp2_map_entry *entry, void *ptr),
                            void *ptr) {
   uint32_t i;
+  nghttp2_map_bucket *bkt;
+  nghttp2_ksl_it it;
+
   for (i = 0; i < map->tablelen; ++i) {
-    nghttp2_map_entry *entry;
-    for (entry = map->table[i]; entry;) {
-      nghttp2_map_entry *next = entry->next;
-      func(entry, ptr);
-      entry = next;
+    bkt = &map->table[i];
+
+    if (bkt->ptr) {
+      func(bkt->ptr, ptr);
+      bkt->ptr = NULL;
+      assert(bkt->ksl == NULL || nghttp2_ksl_len(bkt->ksl) == 0);
+      continue;
+    }
+
+    if (bkt->ksl) {
+      for (it = nghttp2_ksl_begin(bkt->ksl); !nghttp2_ksl_it_end(&it);
+           nghttp2_ksl_it_next(&it)) {
+        func(nghttp2_ksl_it_get(&it), ptr);
+      }
+
+      nghttp2_ksl_free(bkt->ksl);
+      nghttp2_mem_free(map->mem, bkt->ksl);
+      bkt->ksl = NULL;
     }
-    map->table[i] = NULL;
   }
 }
 
@@ -66,13 +100,29 @@ int nghttp2_map_each(nghttp2_map *map,
                      void *ptr) {
   int rv;
   uint32_t i;
+  nghttp2_map_bucket *bkt;
+  nghttp2_ksl_it it;
+
   for (i = 0; i < map->tablelen; ++i) {
-    nghttp2_map_entry *entry;
-    for (entry = map->table[i]; entry; entry = entry->next) {
-      rv = func(entry, ptr);
+    bkt = &map->table[i];
+
+    if (bkt->ptr) {
+      rv = func(bkt->ptr, ptr);
       if (rv != 0) {
         return rv;
       }
+      assert(bkt->ksl == NULL || nghttp2_ksl_len(bkt->ksl) == 0);
+      continue;
+    }
+
+    if (bkt->ksl) {
+      for (it = nghttp2_ksl_begin(bkt->ksl); !nghttp2_ksl_it_end(&it);
+           nghttp2_ksl_it_next(&it)) {
+        rv = func(nghttp2_ksl_it_get(&it), ptr);
+        if (rv != 0) {
+          return rv;
+        }
+      }
     }
   }
   return 0;
@@ -83,72 +133,133 @@ void nghttp2_map_entry_init(nghttp2_map_entry *entry, key_type key) {
   entry->next = NULL;
 }
 
-/* Same hash function in android HashMap source code. */
-/* The |mod| must be power of 2 */
-static uint32_t hash(int32_t key, uint32_t mod) {
-  uint32_t h = (uint32_t)key;
-  h ^= (h >> 20) ^ (h >> 12);
-  h ^= (h >> 7) ^ (h >> 4);
+/* FNV1a hash */
+static uint32_t hash(key_type key, uint32_t mod) {
+  uint8_t *p, *end;
+  uint32_t h = 0x811C9DC5u;
+
+  p = (uint8_t *)&key;
+  end = p + sizeof(key_type);
+
+  for (; p != end;) {
+    h ^= *p++;
+    h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
+  }
+
   return h & (mod - 1);
 }
 
-static int insert(nghttp2_map_entry **table, uint32_t tablelen,
-                  nghttp2_map_entry *entry) {
+static int less(const nghttp2_ksl_key *lhs, const nghttp2_ksl_key *rhs) {
+  return *(key_type *)lhs < *(key_type *)rhs;
+}
+
+static int map_insert(nghttp2_map *map, nghttp2_map_bucket *table,
+                      uint32_t tablelen, nghttp2_map_entry *entry) {
   uint32_t h = hash(entry->key, tablelen);
-  if (table[h] == NULL) {
-    table[h] = entry;
-  } else {
-    nghttp2_map_entry *p;
-    /* We won't allow duplicated key, so check it out. */
-    for (p = table[h]; p; p = p->next) {
-      if (p->key == entry->key) {
-        return NGHTTP2_ERR_INVALID_ARGUMENT;
-      }
+  nghttp2_map_bucket *bkt = &table[h];
+  nghttp2_mem *mem = map->mem;
+  int rv;
+
+  if (bkt->ptr == NULL &&
+      (bkt->ksl == NULL || nghttp2_ksl_len(bkt->ksl) == 0)) {
+    bkt->ptr = entry;
+    return 0;
+  }
+
+  if (!bkt->ksl) {
+    bkt->ksl = nghttp2_mem_malloc(mem, sizeof(*bkt->ksl));
+    if (bkt->ksl == NULL) {
+      return NGHTTP2_ERR_NOMEM;
     }
-    entry->next = table[h];
-    table[h] = entry;
+    nghttp2_ksl_init(bkt->ksl, less, sizeof(key_type), mem);
   }
-  return 0;
+
+  if (bkt->ptr) {
+    rv = nghttp2_ksl_insert(bkt->ksl, NULL, &bkt->ptr->key, bkt->ptr);
+    if (rv != 0) {
+      return rv;
+    }
+
+    bkt->ptr = NULL;
+  }
+
+  return nghttp2_ksl_insert(bkt->ksl, NULL, &entry->key, entry);
 }
 
 /* new_tablelen must be power of 2 */
-static int resize(nghttp2_map *map, uint32_t new_tablelen) {
+static int map_resize(nghttp2_map *map, uint32_t new_tablelen) {
   uint32_t i;
-  nghttp2_map_entry **new_table;
+  nghttp2_map_bucket *new_table;
+  nghttp2_map_bucket *bkt;
+  nghttp2_ksl_it it;
+  int rv;
 
   new_table =
-      nghttp2_mem_calloc(map->mem, new_tablelen, sizeof(nghttp2_map_entry *));
+      nghttp2_mem_calloc(map->mem, new_tablelen, sizeof(nghttp2_map_bucket));
   if (new_table == NULL) {
     return NGHTTP2_ERR_NOMEM;
   }
 
   for (i = 0; i < map->tablelen; ++i) {
-    nghttp2_map_entry *entry;
-    for (entry = map->table[i]; entry;) {
-      nghttp2_map_entry *next = entry->next;
-      entry->next = NULL;
-      /* This function must succeed */
-      insert(new_table, new_tablelen, entry);
-      entry = next;
+    bkt = &map->table[i];
+
+    if (bkt->ptr) {
+      rv = map_insert(map, new_table, new_tablelen, bkt->ptr);
+      if (rv != 0) {
+        goto fail;
+      }
+      assert(bkt->ksl == NULL || nghttp2_ksl_len(bkt->ksl) == 0);
+      continue;
+    }
+
+    if (bkt->ksl) {
+      for (it = nghttp2_ksl_begin(bkt->ksl); !nghttp2_ksl_it_end(&it);
+           nghttp2_ksl_it_next(&it)) {
+        rv = map_insert(map, new_table, new_tablelen, nghttp2_ksl_it_get(&it));
+        if (rv != 0) {
+          goto fail;
+        }
+      }
+    }
+  }
+
+  for (i = 0; i < map->tablelen; ++i) {
+    bkt = &map->table[i];
+    if (bkt->ksl) {
+      nghttp2_ksl_free(bkt->ksl);
+      nghttp2_mem_free(map->mem, bkt->ksl);
     }
   }
+
   nghttp2_mem_free(map->mem, map->table);
   map->tablelen = new_tablelen;
   map->table = new_table;
 
   return 0;
+
+fail:
+  for (i = 0; i < new_tablelen; ++i) {
+    bkt = &new_table[i];
+    if (bkt->ksl) {
+      nghttp2_ksl_free(bkt->ksl);
+      nghttp2_mem_free(map->mem, bkt->ksl);
+    }
+  }
+
+  return rv;
 }
 
 int nghttp2_map_insert(nghttp2_map *map, nghttp2_map_entry *new_entry) {
   int rv;
+
   /* Load factor is 0.75 */
   if ((map->size + 1) * 4 > map->tablelen * 3) {
-    rv = resize(map, map->tablelen * 2);
+    rv = map_resize(map, map->tablelen * 2);
     if (rv != 0) {
       return rv;
     }
   }
-  rv = insert(map->table, map->tablelen, new_entry);
+  rv = map_insert(map, map->table, map->tablelen, new_entry);
   if (rv != 0) {
     return rv;
   }
@@ -157,33 +268,68 @@ int nghttp2_map_insert(nghttp2_map *map, nghttp2_map_entry *new_entry) {
 }
 
 nghttp2_map_entry *nghttp2_map_find(nghttp2_map *map, key_type key) {
-  uint32_t h;
-  nghttp2_map_entry *entry;
-  h = hash(key, map->tablelen);
-  for (entry = map->table[h]; entry; entry = entry->next) {
-    if (entry->key == key) {
-      return entry;
+  nghttp2_map_bucket *bkt = &map->table[hash(key, map->tablelen)];
+  nghttp2_ksl_it it;
+
+  if (bkt->ptr) {
+    if (bkt->ptr->key == key) {
+      return bkt->ptr;
+    }
+    return NULL;
+  }
+
+  if (bkt->ksl) {
+    it = nghttp2_ksl_lower_bound(bkt->ksl, &key);
+    if (nghttp2_ksl_it_end(&it) ||
+        *(key_type *)nghttp2_ksl_it_key(&it) != key) {
+      return NULL;
     }
+    return nghttp2_ksl_it_get(&it);
   }
+
   return NULL;
 }
 
 int nghttp2_map_remove(nghttp2_map *map, key_type key) {
-  uint32_t h;
-  nghttp2_map_entry **dst;
-
-  h = hash(key, map->tablelen);
+  nghttp2_map_bucket *bkt = &map->table[hash(key, map->tablelen)];
+  int rv;
 
-  for (dst = &map->table[h]; *dst; dst = &(*dst)->next) {
-    if ((*dst)->key != key) {
-      continue;
+  if (bkt->ptr) {
+    if (bkt->ptr->key == key) {
+      bkt->ptr = NULL;
+      --map->size;
+      return 0;
     }
+    return NGHTTP2_ERR_INVALID_ARGUMENT;
+  }
 
-    *dst = (*dst)->next;
+  if (bkt->ksl) {
+    rv = nghttp2_ksl_remove(bkt->ksl, NULL, &key);
+    if (rv != 0) {
+      return rv;
+    }
     --map->size;
     return 0;
   }
+
   return NGHTTP2_ERR_INVALID_ARGUMENT;
 }
 
+void nghttp2_map_clear(nghttp2_map *map) {
+  uint32_t i;
+  nghttp2_map_bucket *bkt;
+
+  for (i = 0; i < map->tablelen; ++i) {
+    bkt = &map->table[i];
+    bkt->ptr = NULL;
+    if (bkt->ksl) {
+      nghttp2_ksl_free(bkt->ksl);
+      nghttp2_mem_free(map->mem, bkt->ksl);
+      bkt->ksl = NULL;
+    }
+  }
+
+  map->size = 0;
+}
+
 size_t nghttp2_map_size(nghttp2_map *map) { return map->size; }
diff --git a/deps/nghttp2/lib/nghttp2_map.h b/deps/nghttp2/lib/nghttp2_map.h
index f6e29e35f2de3f52b0e166725ca394f9c038f854..2cf59f698e35bb5594e3cdab29f071394df779b9 100644
--- a/deps/nghttp2/lib/nghttp2_map.h
+++ b/deps/nghttp2/lib/nghttp2_map.h
@@ -1,7 +1,8 @@
 /*
  * nghttp2 - HTTP/2 C Library
  *
- * Copyright (c) 2012 Tatsuhiro Tsujikawa
+ * Copyright (c) 2017 ngtcp2 contributors
+ * Copyright (c) 2012 nghttp2 contributors
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -30,8 +31,9 @@
 #endif /* HAVE_CONFIG_H */
 
 #include <nghttp2/nghttp2.h>
-#include "nghttp2_int.h"
+
 #include "nghttp2_mem.h"
+#include "nghttp2_ksl.h"
 
 /* Implementation of unordered map */
 
@@ -46,8 +48,13 @@ typedef struct nghttp2_map_entry {
 #endif
 } nghttp2_map_entry;
 
+typedef struct nghttp2_map_bucket {
+  nghttp2_map_entry *ptr;
+  nghttp2_ksl *ksl;
+} nghttp2_map_bucket;
+
 typedef struct {
-  nghttp2_map_entry **table;
+  nghttp2_map_bucket *table;
   nghttp2_mem *mem;
   size_t size;
   uint32_t tablelen;
@@ -118,6 +125,11 @@ nghttp2_map_entry *nghttp2_map_find(nghttp2_map *map, key_type key);
  */
 int nghttp2_map_remove(nghttp2_map *map, key_type key);
 
+/*
+ * Removes all entries from |map|.
+ */
+void nghttp2_map_clear(nghttp2_map *map);
+
 /*
  * Returns the number of items stored in the map |map|.
  */
diff --git a/deps/nghttp2/lib/nghttp2_session.c b/deps/nghttp2/lib/nghttp2_session.c
index 39f81f498cda798bcd18926414d7297f34361d2b..2e7e907f25e19942ad1e84ce8e214ffdf9a6e270 100644
--- a/deps/nghttp2/lib/nghttp2_session.c
+++ b/deps/nghttp2/lib/nghttp2_session.c
@@ -959,6 +959,18 @@ int nghttp2_session_add_rst_stream(nghttp2_session *session, int32_t stream_id,
     return 0;
   }
 
+  /* Sending RST_STREAM to an idle stream is subject to protocol
+     violation.  Historically, nghttp2 allows this.  In order not to
+     disrupt the existing applications, we don't error out this case
+     and simply ignore it. */
+  if (nghttp2_session_is_my_stream_id(session, stream_id)) {
+    if ((uint32_t)stream_id >= session->next_stream_id) {
+      return 0;
+    }
+  } else if (session->last_recv_stream_id < stream_id) {
+    return 0;
+  }
+
   /* Cancel pending request HEADERS in ob_syn if this RST_STREAM
      refers to that stream. */
   if (!session->server && nghttp2_session_is_my_stream_id(session, stream_id) &&
@@ -969,8 +981,7 @@ int nghttp2_session_add_rst_stream(nghttp2_session *session, int32_t stream_id,
     headers_frame = &nghttp2_outbound_queue_top(&session->ob_syn)->frame;
     assert(headers_frame->hd.type == NGHTTP2_HEADERS);
 
-    if (headers_frame->hd.stream_id <= stream_id &&
-        (uint32_t)stream_id < session->next_stream_id) {
+    if (headers_frame->hd.stream_id <= stream_id) {
 
       for (item = session->ob_syn.head; item; item = item->qnext) {
         aux_data = &item->aux_data.headers;
@@ -5353,9 +5364,11 @@ static ssize_t inbound_frame_effective_readlen(nghttp2_inbound_frame *iframe,
   return (ssize_t)(readlen);
 }
 
+static const uint8_t static_in[] = {0};
+
 ssize_t nghttp2_session_mem_recv(nghttp2_session *session, const uint8_t *in,
                                  size_t inlen) {
-  const uint8_t *first = in, *last = in + inlen;
+  const uint8_t *first, *last;
   nghttp2_inbound_frame *iframe = &session->iframe;
   size_t readlen;
   ssize_t padlen;
@@ -5366,6 +5379,14 @@ ssize_t nghttp2_session_mem_recv(nghttp2_session *session, const uint8_t *in,
   size_t pri_fieldlen;
   nghttp2_mem *mem;
 
+  if (in == NULL) {
+    assert(inlen == 0);
+    in = static_in;
+  }
+
+  first = in;
+  last = in + inlen;
+
   DEBUGF("recv: connection recv_window_size=%d, local_window=%d\n",
          session->recv_window_size, session->local_window_size);
 
@@ -7448,8 +7469,8 @@ static int nghttp2_session_upgrade_internal(nghttp2_session *session,
     return NGHTTP2_ERR_INVALID_ARGUMENT;
   }
   /* SETTINGS frame contains too many settings */
-  if (settings_payloadlen / NGHTTP2_FRAME_SETTINGS_ENTRY_LENGTH
-        > session->max_settings) {
+  if (settings_payloadlen / NGHTTP2_FRAME_SETTINGS_ENTRY_LENGTH >
+      session->max_settings) {
     return NGHTTP2_ERR_TOO_MANY_SETTINGS;
   }
   rv = nghttp2_frame_unpack_settings_payload2(&iv, &niv, settings_payload,
diff --git a/deps/nghttp2/nghttp2.gyp b/deps/nghttp2/nghttp2.gyp
index 0dcd034b8169da12c768c18b55e285460de0d2c6..21fd6ba5ecf46db33f529834adecf4d96fff3c06 100644
--- a/deps/nghttp2/nghttp2.gyp
+++ b/deps/nghttp2/nghttp2.gyp
@@ -44,6 +44,7 @@
         'lib/nghttp2_hd_huffman_data.c',
         'lib/nghttp2_helper.c',
         'lib/nghttp2_http.c',
+        'lib/nghttp2_ksl.c',
         'lib/nghttp2_map.c',
         'lib/nghttp2_mem.c',
         'lib/nghttp2_npn.c',
diff --git a/deps/node-inspect/.editorconfig b/deps/node-inspect/.editorconfig
deleted file mode 100644
index beffa3084e7a693343fff8701f413ec3efa87b24..0000000000000000000000000000000000000000
--- a/deps/node-inspect/.editorconfig
+++ /dev/null
@@ -1,11 +0,0 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false
diff --git a/deps/node-inspect/.eslintrc b/deps/node-inspect/.eslintrc
deleted file mode 100644
index b6d45aa499655bf836e9275ed503df82d90adfc8..0000000000000000000000000000000000000000
--- a/deps/node-inspect/.eslintrc
+++ /dev/null
@@ -1,147 +0,0 @@
-root: true
-
-env:
-  node: true
-  es6: true
-
-parserOptions:
-  ecmaVersion: 2017
-
-rules:
-  # Possible Errors
-  # http://eslint.org/docs/rules/#possible-errors
-  comma-dangle: [2, only-multiline]
-  no-control-regex: 2
-  no-debugger: 2
-  no-dupe-args: 2
-  no-dupe-keys: 2
-  no-duplicate-case: 2
-  no-empty-character-class: 2
-  no-ex-assign: 2
-  no-extra-boolean-cast: 2
-  no-extra-parens: [2, functions]
-  no-extra-semi: 2
-  no-func-assign: 2
-  no-invalid-regexp: 2
-  no-irregular-whitespace: 2
-  no-obj-calls: 2
-  no-proto: 2
-  no-template-curly-in-string: 2
-  no-unexpected-multiline: 2
-  no-unreachable: 2
-  no-unsafe-negation: 2
-  use-isnan: 2
-  valid-typeof: 2
-
-  # Best Practices
-  # http://eslint.org/docs/rules/#best-practices
-  dot-location: [2, property]
-  no-fallthrough: 2
-  no-global-assign: 2
-  no-multi-spaces: 2
-  no-octal: 2
-  no-redeclare: 2
-  no-self-assign: 2
-  no-unused-labels: 2
-  no-useless-call: 2
-  no-useless-escape: 2
-  no-void: 2
-  no-with: 2
-
-  # Strict Mode
-  # http://eslint.org/docs/rules/#strict-mode
-  strict: [2, global]
-
-  # Variables
-  # http://eslint.org/docs/rules/#variables
-  no-delete-var: 2
-  no-undef: 2
-  no-unused-vars: [2, {args: none}]
-
-  # Node.js and CommonJS
-  # http://eslint.org/docs/rules/#nodejs-and-commonjs
-  no-mixed-requires: 2
-  no-new-require: 2
-  no-path-concat: 2
-  no-restricted-modules: [2, sys, _linklist]
-  no-restricted-properties: [2, {
-    object: assert,
-    property: deepEqual,
-    message: Please use assert.deepStrictEqual().
-  }, {
-    property: __defineGetter__,
-    message: __defineGetter__ is deprecated.
-  }, {
-    property: __defineSetter__,
-    message: __defineSetter__ is deprecated.
-  }]
-
-  # Stylistic Issues
-  # http://eslint.org/docs/rules/#stylistic-issues
-  brace-style: [2, 1tbs, {allowSingleLine: true}]
-  comma-spacing: 2
-  comma-style: 2
-  computed-property-spacing: 2
-  eol-last: 2
-  func-call-spacing: 2
-  func-name-matching: 2
-  indent: [2, 2, {SwitchCase: 1, MemberExpression: 1}]
-  key-spacing: [2, {mode: minimum}]
-  keyword-spacing: 2
-  linebreak-style: [2, unix]
-  max-len: [2, 80, 2]
-  new-parens: 2
-  no-mixed-spaces-and-tabs: 2
-  no-multiple-empty-lines: [2, {max: 2, maxEOF: 0, maxBOF: 0}]
-  no-tabs: 2
-  no-trailing-spaces: 2
-  quotes: [2, single, avoid-escape]
-  semi: 2
-  semi-spacing: 2
-  space-before-blocks: [2, always]
-  space-before-function-paren: [2, never]
-  space-in-parens: [2, never]
-  space-infix-ops: 2
-  space-unary-ops: 2
-
-  # ECMAScript 6
-  # http://eslint.org/docs/rules/#ecmascript-6
-  arrow-parens: [2, always]
-  arrow-spacing: [2, {before: true, after: true}]
-  constructor-super: 2
-  no-class-assign: 2
-  no-confusing-arrow: 2
-  no-const-assign: 2
-  no-dupe-class-members: 2
-  no-new-symbol: 2
-  no-this-before-super: 2
-  prefer-const: [2, {ignoreReadBeforeAssign: true}]
-  rest-spread-spacing: 2
-  template-curly-spacing: 2
-
-  # Custom rules in tools/eslint-rules
-  align-function-arguments: 2
-  align-multiline-assignment: 2
-  assert-fail-single-argument: 2
-  new-with-error: [2, Error, RangeError, TypeError, SyntaxError, ReferenceError]
-
-# Global scoped method and vars
-globals:
-  COUNTER_HTTP_CLIENT_REQUEST: false
-  COUNTER_HTTP_CLIENT_RESPONSE: false
-  COUNTER_HTTP_SERVER_REQUEST: false
-  COUNTER_HTTP_SERVER_RESPONSE: false
-  COUNTER_NET_SERVER_CONNECTION: false
-  COUNTER_NET_SERVER_CONNECTION_CLOSE: false
-  DTRACE_HTTP_CLIENT_REQUEST: false
-  DTRACE_HTTP_CLIENT_RESPONSE: false
-  DTRACE_HTTP_SERVER_REQUEST: false
-  DTRACE_HTTP_SERVER_RESPONSE: false
-  DTRACE_NET_SERVER_CONNECTION: false
-  DTRACE_NET_STREAM_END: false
-  LTTNG_HTTP_CLIENT_REQUEST: false
-  LTTNG_HTTP_CLIENT_RESPONSE: false
-  LTTNG_HTTP_SERVER_REQUEST: false
-  LTTNG_HTTP_SERVER_RESPONSE: false
-  LTTNG_NET_SERVER_CONNECTION: false
-  LTTNG_NET_STREAM_END: false
diff --git a/deps/node-inspect/.github/workflows/ci.yml b/deps/node-inspect/.github/workflows/ci.yml
deleted file mode 100644
index 968316a34779a556dbc646df332f249ba05c0b90..0000000000000000000000000000000000000000
--- a/deps/node-inspect/.github/workflows/ci.yml
+++ /dev/null
@@ -1,31 +0,0 @@
-name: Node CI
-
-on: [push, pull_request]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        node-version:
-        # See https://github.com/nodejs/node-inspect/pull/78
-        # - 10.x
-        - 12.x
-        - 13.x
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: npm install, build, and test
-      run: |
-        npm install
-        npm run build --if-present
-        npm test
-      env:
-        CI: true
diff --git a/deps/node-inspect/.npmrc b/deps/node-inspect/.npmrc
deleted file mode 100644
index b7c8444fee52a68cc2c0b5bb813554a614ea1abc..0000000000000000000000000000000000000000
--- a/deps/node-inspect/.npmrc
+++ /dev/null
@@ -1,2 +0,0 @@
-registry=https://registry.npmjs.org
-package-lock=false
diff --git a/deps/node-inspect/.travis.yml b/deps/node-inspect/.travis.yml
deleted file mode 100644
index 07418a91eb79864a6305d4dd4bde21be0dc1bb93..0000000000000000000000000000000000000000
--- a/deps/node-inspect/.travis.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-language: node_js
-node_js:
-  - '6.8'
-before_deploy:
-  - git config --global user.email "jan.krems@gmail.com"
-  - git config --global user.name "Jan Krems"
-deploy:
-  provider: script
-  script: ./node_modules/.bin/nlm release
-  skip_cleanup: true
-  'on':
-    branch: master
-    node: '6.8'
diff --git a/deps/node-inspect/CHANGELOG.md b/deps/node-inspect/CHANGELOG.md
deleted file mode 100644
index 73aeb4df93fe8b16a73a0b58caad9061ca37c2d4..0000000000000000000000000000000000000000
--- a/deps/node-inspect/CHANGELOG.md
+++ /dev/null
@@ -1,296 +0,0 @@
-### 1.11.6
-
-* fix: replace the deprecated "repl.cli" with "repl" - **[@oyyd](https://github.com/oyyd)** [#66](https://github.com/nodejs/node-inspect/pull/66)
-  - [`5c1d771`](https://github.com/nodejs/node-inspect/commit/5c1d7716523b73e26f98f4f594ee34b7daa920a0) **fix:** replace the deprecated "repl.cli" with "repl" - see: [26260](Refs: https://github.com/nodejs/node/pull/26260)
-* Address regressions due to changes in node - **[@jkrems](https://github.com/jkrems)** [#67](https://github.com/nodejs/node-inspect/pull/67)
-  - [`5b3511e`](https://github.com/nodejs/node-inspect/commit/5b3511ef21d0eba8304d8b2fed33f33aae22f308) **fix:** Address regressions due to changes in node
-
-
-### 1.11.5
-
-* Fix eslint issues - **[@jkrems](https://github.com/jkrems)** [#63](https://github.com/nodejs/node-inspect/pull/63)
-  - [`2adadbc`](https://github.com/nodejs/node-inspect/commit/2adadbc1086d2e374c425acbf96260a122705db2) **style:** Fix eslint issues
-  - [`a6d2f88`](https://github.com/nodejs/node-inspect/commit/a6d2f882c026409696a1b063ff40ceba7e1ddb86) **doc:** Remove redundant newline at the end
-
-
-### 1.11.4
-
-* Handle blocked port - **[@jkrems](https://github.com/jkrems)** [#62](https://github.com/nodejs/node-inspect/pull/62)
-  - [`3388969`](https://github.com/nodejs/node-inspect/commit/3388969d0032a78ff0cdb8146f170b978ec13b7b) **chore:** Disable package-lock
-  - [`d278b23`](https://github.com/nodejs/node-inspect/commit/d278b233ae5e11a2b62d01ccbaae594f39b32a96) **fix:** Stop asking to report a blocked port - see: [#60](https://github.com/nodejs/node-inspect/issues/60)
-
-
-### 1.11.3
-
-* [`93caa0f`](https://github.com/nodejs/node-inspect/commit/93caa0f5267c7ab452b258d3b03329a0bb5ac7f7) **docs:** Add missing oc in protocol
-* [`2d87cbe`](https://github.com/nodejs/node-inspect/commit/2d87cbe76aa968dfc1ac69d9571af1be81abd8e0) **fix:** Make --inspect-port=0 work
-* [`ebfd02e`](https://github.com/nodejs/node-inspect/commit/ebfd02ece9b642586023f7791da71defeb13d746) **chore:** Bump tap to 10.7
-* [`c07adb1`](https://github.com/nodejs/node-inspect/commit/c07adb17b164c1cf3da8d38659ea9f5d7ff42e9c) **test:** Use useful break location
-* [`94f0bf9`](https://github.com/nodejs/node-inspect/commit/94f0bf97d24c376baf3ecced2088d81715a73464) **fix:** Fix `takeHeapSnapshot()` truncation bug
-
-
-### 1.11.2
-
-* [`42e0cd1`](https://github.com/nodejs/node-inspect/commit/42e0cd111d89ed09faba1c0ec45089b0b44de011) **fix:** look for generic hint text
-
-
-### 1.11.1
-
-* Prefer --inspect-brk over --debug-brk - **[@ofrobots](https://github.com/ofrobots)** [#43](https://github.com/nodejs/node-inspect/pull/43)
-  - [`2c1ed27`](https://github.com/nodejs/node-inspect/commit/2c1ed27ee44d9aebb3c5ac50039abae8166a54e3) **fix:** use --inspect-brk with Node 8+
-
-
-### 1.11.0
-
-* doc: add profile and heap to help - **[@joshgav](https://github.com/joshgav)** [#39](https://github.com/nodejs/node-inspect/pull/39)
-  - [`f64c920`](https://github.com/nodejs/node-inspect/commit/f64c9205bd8382289660aa677d3ac192a9c81fd5) **doc:** add profile and heap to help
-* Update test suite to pass on latest nightly - **[@jkrems](https://github.com/jkrems)** [#36](https://github.com/nodejs/node-inspect/pull/36)
-  - [`41148d7`](https://github.com/nodejs/node-inspect/commit/41148d74a2d563eea3b7ad5463622b6b9fd4c46e) **test:** Remove outdated test
-  - [`2c224c5`](https://github.com/nodejs/node-inspect/commit/2c224c551619e386e80fc3154cc14562cac063b9) **test:** Accept any kind of "break"
-  - [`22bf349`](https://github.com/nodejs/node-inspect/commit/22bf349bc86d7bf6fd449791c9d1e7eaf66c2681) **test:** Adjust for v8 5.7
-  - [`6ce8c16`](https://github.com/nodejs/node-inspect/commit/6ce8c165c45a491bea8cfb3c67d2ae80e7c34dcb) **test:** Revert to old assertions
-* Verify custom port support - **[@jkrems](https://github.com/jkrems)** [#41](https://github.com/nodejs/node-inspect/pull/41)
-  - [`e3a489f`](https://github.com/nodejs/node-inspect/commit/e3a489f23b089d3d57a25d5efe40daf06de63e23) **test:** custom port
-* Support for debugging a pid - **[@jkrems](https://github.com/jkrems)** [#37](https://github.com/nodejs/node-inspect/pull/37)
-  - [`4179506`](https://github.com/nodejs/node-inspect/commit/4179506a4d546bac2c93b2a7ff491b1fa4494fd9) **feat:** Support for debugging a pid
-
-
-### 1.10.6
-
-* chore: Fix usage text for embedded mode - **[@addaleax](https://github.com/addaleax)** [#20](https://github.com/nodejs/node-inspect/pull/20)
-  - [`b0779f5`](https://github.com/nodejs/node-inspect/commit/b0779f597104e9ada5681f64d7e714525b753511) **chore:** Fix usage text for embedded mode
-* print 'ok' after connection - **[@ofrobots](https://github.com/ofrobots)** [#25](https://github.com/nodejs/node-inspect/pull/25)
-  - [`2a47125`](https://github.com/nodejs/node-inspect/commit/2a4712577f6996fbb078dcfcd7320c397685d76a) **fix:** print 'ok' after connection
-* Make autocompletion in REPL work - **[@aqrln](https://github.com/aqrln)** [#28](https://github.com/nodejs/node-inspect/pull/28)
-  - [`ccab737`](https://github.com/nodejs/node-inspect/commit/ccab737399249a8c2230ed6adfec579c7d724364) **fix:** Make autocompletion in REPL work
-* Remove console.error() statement - **[@aqrln](https://github.com/aqrln)** [#30](https://github.com/nodejs/node-inspect/pull/30)
-  - [`032b045`](https://github.com/nodejs/node-inspect/commit/032b045d4d73622c77b7ebcc26781c6ad98200b3) **style:** Remove console.error() statement
-* Take --debug-port into account - **[@jkrems](https://github.com/jkrems)** [#26](https://github.com/nodejs/node-inspect/pull/26)
-  - [`054d4b1`](https://github.com/nodejs/node-inspect/commit/054d4b10e65f12a3a4b10b4c0ab2a4768cc5e893) **fix:** Take --debug-port into account
-* Delay run until breakpoints are restored - **[@jkrems](https://github.com/jkrems)** [#34](https://github.com/nodejs/node-inspect/pull/34)
-  - [`802b88c`](https://github.com/nodejs/node-inspect/commit/802b88c8ad0a57608cb9e0cb4bf46ed683bb6344) **fix:** Delay run until breakpoints are restored
-  - [`2b93173`](https://github.com/nodejs/node-inspect/commit/2b93173d95e7f8b30d85603613cb2ae3b3ec18db) **fix:** Use single string for paused notice
-  - [`b4d5ee2`](https://github.com/nodejs/node-inspect/commit/b4d5ee2a3d25613b35a2e8e10a0eb75582cc5654) **fix:** Work around inconsistent handling of strict directive
-  - [`f6ccfc7`](https://github.com/nodejs/node-inspect/commit/f6ccfc7f4d00ad4fdf3b581b677f8d7f1699c44c) **fix:** Only restart after port is free
-  - [`8b101bf`](https://github.com/nodejs/node-inspect/commit/8b101bf669ca102df4980bfad3e0436ef1c2f1a4) **test:** Skip exact match on AIX
-* [`a4e4b6f`](https://github.com/nodejs/node-inspect/commit/a4e4b6feeba4dedfd2c89ef32f39e813314d3bbd) **chore:** Fix repo info in package.json
-
-
-### 1.10.5
-
-* docs: minor edits to governance docs - **[@joshgav](https://github.com/joshgav)** [#17](https://github.com/buggerjs/node-inspect/pull/17)
-  - [`a70fe04`](https://github.com/buggerjs/node-inspect/commit/a70fe04bdde9b7c74588685066291f9b11183328) **docs:** minor edits to governance docs
-
-
-### 1.10.4
-
-* [`1c31bf7`](https://github.com/buggerjs/node-inspect/commit/1c31bf7d1b3ea1b424ae0662526596670cb506c9) **chore:** Support embedded mode
-
-
-### 1.10.3
-
-* [`7b20379`](https://github.com/buggerjs/node-inspect/commit/7b20379069af692a9038a31a4465f72db9eb532f) **chore:** Mark .eslintrc as root
-
-
-### 1.10.2
-
-* Run tests on windows - **[@jkrems](https://github.com/jkrems)** [#16](https://github.com/buggerjs/node-inspect/pull/16)
-  - [`5a57f98`](https://github.com/buggerjs/node-inspect/commit/5a57f9865e02eef0763c2a7f26236c34a632ccdd) **chore:** Run tests on windows
-  - [`0a04b50`](https://github.com/buggerjs/node-inspect/commit/0a04b50cc8b4dc6ce868927c635c479d75ce71f4) **chore:** Bump nlm to get rid of postinstall
-  - [`4a8b27c`](https://github.com/buggerjs/node-inspect/commit/4a8b27cea814a37895effd2a0c1b85dbfee3a7f4) **test:** Remove unix path assumptions
-
-
-### 1.10.1
-
-* [`4ba3c72`](https://github.com/buggerjs/node-inspect/commit/4ba3c72270fae9a71343ddca11aa27980678a67c) **refactor:** Undo weird bundling into one file
-
-
-### 1.10.0
-
-* [`3e1a66a`](https://github.com/buggerjs/node-inspect/commit/3e1a66a489bef19beaa5f859e99e027274ff43cb) **feat:** Support CPU & heap profiles
-
-
-### 1.9.3
-
-* Move back to single file - **[@jkrems](https://github.com/jkrems)** [#15](https://github.com/buggerjs/node-inspect/pull/15)
-  - [`9877660`](https://github.com/buggerjs/node-inspect/commit/9877660a73ff0ec0885ad7f939ba62020a46b4b6) **refactor:** Wrap client in IIFE
-  - [`7795c53`](https://github.com/buggerjs/node-inspect/commit/7795c533f0605eb128db610a5874b27e555251ef) **refactor:** Move more code in createRepl scope
-  - [`be34a39`](https://github.com/buggerjs/node-inspect/commit/be34a398e823612bdf5ac90bad5222af27035a00) **refactor:** Move back to single file
-  - [`ab45b62`](https://github.com/buggerjs/node-inspect/commit/ab45b6273dc0d3a49d3cf46a80cb48ab79d1caf8) **refactor:** Remove single-use functions
-  - [`37a711e`](https://github.com/buggerjs/node-inspect/commit/37a711ed5334c06ed4d85f995e567a9f176a68d5) **style:** Stop using `new Buffer`
-  - [`d669dc5`](https://github.com/buggerjs/node-inspect/commit/d669dc593f5ad5ca7a48f19f0905ef66ec0e540d) **chore:** Switch to node eslint rules
-  - [`15e7917`](https://github.com/buggerjs/node-inspect/commit/15e79177918d96dcffd2384715faf0308e97a26c) **style:** Use var in classical for loops
-
-
-### 1.9.2
-
-* [`c9dc4be`](https://github.com/buggerjs/node-inspect/commit/c9dc4beb08236e33d64f19417682cf5b3f5aeed6) **doc:** Link directly to GOVERNANCE file
-
-
-### 1.9.1
-
-* Handle big ws frames correctly - **[@jkrems](https://github.com/jkrems)** [#14](https://github.com/buggerjs/node-inspect/pull/14)
-  - [`f80100e`](https://github.com/buggerjs/node-inspect/commit/f80100e932710d232d074b239cbf8fefa564c789) **fix:** Handle big ws frames correctly - see: [#10](https://github.com/buggerjs/node-inspect/issues/10)
-
-
-### 1.9.0
-
-* Support for low-level agent access - **[@jkrems](https://github.com/jkrems)** [#13](https://github.com/buggerjs/node-inspect/pull/13)
-  - [`90ed431`](https://github.com/buggerjs/node-inspect/commit/90ed4310c62d130637c12f8ecdb752075c43ac36) **feat:** Support for low-level agent access
-
-
-### 1.8.4
-
-* Use proper path for websocket - **[@jkrems](https://github.com/jkrems)** [#12](https://github.com/buggerjs/node-inspect/pull/12)
-  - [`3405225`](https://github.com/buggerjs/node-inspect/commit/3405225979dfc2058bcc6d1b90f41c060dbd1f92) **fix:** Use proper path for websocket - see: [#11](https://github.com/buggerjs/node-inspect/issues/11)
-
-
-### 1.8.3
-
-* [`6f9883d`](https://github.com/buggerjs/node-inspect/commit/6f9883d4b29419831133988981b83e891b19739a) **fix:** Breakpoints & scripts work when not paused
-* [`ecb1362`](https://github.com/buggerjs/node-inspect/commit/ecb1362c842e6ed5bc28c091a32bfd540742db75) **chore:** Pin node to 6.8
-
-
-### 1.8.2
-
-* [`4219a98`](https://github.com/buggerjs/node-inspect/commit/4219a98d6514f1068feabce2945c21a0d5ba6561) **refactor:** Decouple source snippet from repl
-
-
-### 1.8.1
-
-* [`95402ee`](https://github.com/buggerjs/node-inspect/commit/95402ee5dff04057f074677d39db2f61ec74c151) **refactor:** Move `list` into CallFrame
-
-
-### 1.8.0
-
-* [`d0e6499`](https://github.com/buggerjs/node-inspect/commit/d0e6499084f5d656ef0c5fd470d3ab21f2e9a6b4) **feat:** `exec .scope`
-
-
-### 1.7.0
-
-* `breakOn{Exception,Uncaught,None}` - **[@jkrems](https://github.com/jkrems)** [#8](https://github.com/buggerjs/node-inspect/pull/8)
-  - [`fa8c4c7`](https://github.com/buggerjs/node-inspect/commit/fa8c4c7d7bb6972733c92da4d04fdd62c02b0e3b) **feat:** `breakOn{Exception,Uncaught,None}` - see: [#6](https://github.com/buggerjs/node-inspect/issues/6)
-
-
-### 1.6.0
-
-* Add `help` command - **[@jkrems](https://github.com/jkrems)** [#7](https://github.com/buggerjs/node-inspect/pull/7)
-  - [`09b37a0`](https://github.com/buggerjs/node-inspect/commit/09b37a02e04e16a38ce27f69538d3b098548b47c) **feat:** Add `help` command - see: [#5](https://github.com/buggerjs/node-inspect/issues/5)
-
-
-### 1.5.0
-
-* [`7e0fd99`](https://github.com/buggerjs/node-inspect/commit/7e0fd99fcfc65d8b647a2259df78f4cabf1d3d63) **feat:** Add `r` shortcut for `run`
-
-
-### 1.4.1
-
-* [`484d098`](https://github.com/buggerjs/node-inspect/commit/484d0983f06d6ff9639ab5197ba0a58313f532df) **chore:** Remove old implementation
-
-
-### 1.4.0
-
-* Properly tested implementation - **[@jkrems](https://github.com/jkrems)** [#4](https://github.com/buggerjs/node-inspect/pull/4)
-  - [`ba060d3`](https://github.com/buggerjs/node-inspect/commit/ba060d3ef65ae84df2a3a9b9f16d563f3c4b29be) **feat:** Error handling w/o args
-  - [`b39b3bc`](https://github.com/buggerjs/node-inspect/commit/b39b3bc07c13adc48fc8bb720889285c51e62548) **feat:** Launch child
-  - [`481693f`](https://github.com/buggerjs/node-inspect/commit/481693f676ee099b7787cd2426b980858e973602) **feat:** Connect debug client
-  - [`3bba0f2`](https://github.com/buggerjs/node-inspect/commit/3bba0f2416b2e3b4e6010de675003fcc328b16e8) **chore:** Disable lint for inactive code
-  - [`cc7bdfc`](https://github.com/buggerjs/node-inspect/commit/cc7bdfcf7f21ef5cd5c32c7800407238b0d4f100) **feat:** Properly fail with invalid host:port
-  - [`73f34f9`](https://github.com/buggerjs/node-inspect/commit/73f34f902634e9778597e129f46895aa8b643d72) **refactor:** Remove unused field
-  - [`6a23e0c`](https://github.com/buggerjs/node-inspect/commit/6a23e0cf3179f43ca6fc5a0fa2b1dd18ebc044b5) **refactor:** Better debug output & support node 6.6
-  - [`63b0f9b`](https://github.com/buggerjs/node-inspect/commit/63b0f9b6ef8bd9af0f7cb14a5938a45838731fc9) **test:** Add timeout to waitFor(pattern)
-  - [`cfa197b`](https://github.com/buggerjs/node-inspect/commit/cfa197bf8325a1a4ca1b296f8d6971d368bfbfbb) **refactor:** Move REPL setup into own file
-  - [`3f46c2c`](https://github.com/buggerjs/node-inspect/commit/3f46c2c43f836e1135b66871087aa74969f6b330) **feat:** Working repl eval
-  - [`6911eb1`](https://github.com/buggerjs/node-inspect/commit/6911eb1a00b964bc5683506d433fa4f665f5a82c) **feat:** Enter repeats last command
-  - [`7d20b7d`](https://github.com/buggerjs/node-inspect/commit/7d20b7deadf1b251ea8cf2cc9167c175624932c4) **chore:** Add missing license header
-  - [`23c62f8`](https://github.com/buggerjs/node-inspect/commit/23c62f8375ca7c8b71d032047e728dace02f4efa) **feat:** Print break context
-  - [`5dbc83d`](https://github.com/buggerjs/node-inspect/commit/5dbc83df31171f9c38a974c99340bde26f2e24ec) **feat:** Stepping and breakpoints
-  - [`8deb8cc`](https://github.com/buggerjs/node-inspect/commit/8deb8cc36b9fca432ab8df63a82e9de7ab5adaf0) **feat:** list for printing source
-  - [`1ed2ec9`](https://github.com/buggerjs/node-inspect/commit/1ed2ec9937070652be611dbb6b11dfb42cb840f8) **chore:** Disable verbose output on CI
-  - [`625a435`](https://github.com/buggerjs/node-inspect/commit/625a435925dd8fd980bed2dc9e3fd73dd27df4ef) **fix:** Gracefully handle delayed scriptParsed
-  - [`8823c60`](https://github.com/buggerjs/node-inspect/commit/8823c60d347600b2313cfdd8cb5e96fe02419a8a) **chore:** Run all the tests
-  - [`00506f7`](https://github.com/buggerjs/node-inspect/commit/00506f763928cc440505a81030167a11b9a84e00) **feat:** backtrace/bt
-  - [`e1ee02d`](https://github.com/buggerjs/node-inspect/commit/e1ee02d5cc389916489d387d07d5dd161230427a) **refactor:** Leverage util.inspect.custom
-  - [`5dcc319`](https://github.com/buggerjs/node-inspect/commit/5dcc31922d40f56c7435319d1538390a442e8e4b) **feat:** scripts and scripts(true)
-  - [`085cd5a`](https://github.com/buggerjs/node-inspect/commit/085cd5a76a961edfcaa342fff5eb09bf2f9c8983) **refactor:** Consistent import style
-  - [`1c60f91`](https://github.com/buggerjs/node-inspect/commit/1c60f91f233848c05d865617dc7f5aacb36270b6) **feat:** Set breakpoint before file is loaded
-  - [`bc82ecc`](https://github.com/buggerjs/node-inspect/commit/bc82eccb2a1a7c0f5332371254f6584e748216aa) **feat:** breakpoints to list breakpoints
-  - [`7f48c95`](https://github.com/buggerjs/node-inspect/commit/7f48c9510696ec400d51afaca8d23a9c292640f8) **feat:** watchers & exec
-  - [`0f8cd13`](https://github.com/buggerjs/node-inspect/commit/0f8cd13a092e5dbeb395ff04cbe2ed97cb986423) **feat:** clearBreakpoint
-  - [`0d31560`](https://github.com/buggerjs/node-inspect/commit/0d315603bdcb9f4da42fab24dc569c325151269e) **feat:** version to print v8 version
-  - [`df6b89d`](https://github.com/buggerjs/node-inspect/commit/df6b89df580a9afcb3b8883b0e4224cbcebb384f) **feat:** Paused & global exec
-  - [`9e97d73`](https://github.com/buggerjs/node-inspect/commit/9e97d73073ceffd70974d45887c84fadb9159d5c) **feat:** repl to enter exec mode
-  - [`9ee9f90`](https://github.com/buggerjs/node-inspect/commit/9ee9f903d6202f54ed2b3b3559da4006b65d39b5) **feat:** run & restart
-* [`3a752aa`](https://github.com/buggerjs/node-inspect/commit/3a752aaa773968bfe16c5f543bd739feed598bea) **feat:** kill
-* [`a67e470`](https://github.com/buggerjs/node-inspect/commit/a67e47018b20d46aeeaa7abd27eb8e7770fd0b8f) **feat:** Restore breakpoints on restart
-
-
-### 1.3.3
-
-* [`eb7a54c`](https://github.com/buggerjs/node-inspect/commit/eb7a54c6fa731ed3276072c72034046fc5ffbac6) **chore:** Switch to tap for tests
-
-
-### 1.3.2
-
-* Add notes about governance - **[@jkrems](https://github.com/jkrems)** [#3](https://github.com/buggerjs/node-inspect/pull/3)
-  - [`e94089d`](https://github.com/buggerjs/node-inspect/commit/e94089d93689cacf5c953e94563463d1e174452d) **chore:** Add notes about governance
-
-
-### 1.3.1
-
-* [`8767137`](https://github.com/buggerjs/node-inspect/commit/8767137c53a2f6b1d36970074ea95be9871e50e3) **style:** Remove rogue console.log
-
-
-### 1.3.0
-
-* [`3ac6232`](https://github.com/buggerjs/node-inspect/commit/3ac623219ba44b0af40ef66826610a26a46c7966) **feat:** Add `version` command
-
-
-### 1.2.0
-
-* [`86b5812`](https://github.com/buggerjs/node-inspect/commit/86b581218ccab44e6bde259a17ad1e71645a6137) **feat:** scripts & listScripts(true)
-
-
-### 1.1.1
-
-* [`feaea38`](https://github.com/buggerjs/node-inspect/commit/feaea385a981e6b72a8d99277fbf575c54e15fc6) **style:** Typo in comment
-
-
-### 1.1.0
-
-* [`c64155f`](https://github.com/buggerjs/node-inspect/commit/c64155faa552f71463842a26330aa5bcbfc31670) **feat:** repl command
-
-
-### 1.0.0
-
-* [`44c4c79`](https://github.com/buggerjs/node-inspect/commit/44c4c79af5a228ccfd8906f11409b2a33390b878) **chore:** Initial commit
-* [`985873c`](https://github.com/buggerjs/node-inspect/commit/985873cfb97146b38480080f9907219c473f1f6f) **feat:** Launching the example works
-* [`3d92d05`](https://github.com/buggerjs/node-inspect/commit/3d92d05cca152a2c2647aa64eefc80432638bc4d) **chore:** Proper license and passing tests
-* [`b3f99d9`](https://github.com/buggerjs/node-inspect/commit/b3f99d981038b17663fcfd984d2f5d6d9b51ee18) **feat:** Futile attempts to send a valid ws frame
-* [`465cfb7`](https://github.com/buggerjs/node-inspect/commit/465cfb7b295aebb48b285c26f6de9c4657fe590d) **feat:** Working ws connection
-* [`da9f011`](https://github.com/buggerjs/node-inspect/commit/da9f01118e2b144f2da8cd370113a608526774a1) **fix:** Fix remote connect
-* [`5ef33d7`](https://github.com/buggerjs/node-inspect/commit/5ef33d7892cc49becb4c66098fc7927bc74b014a) **feat:** Working step-by-step
-* [`534e1e4`](https://github.com/buggerjs/node-inspect/commit/534e1e46b307d61d51eb4c0aab4a3b17c17aea3d) **chore:** Add bin entry
-* [`8cff9cf`](https://github.com/buggerjs/node-inspect/commit/8cff9cfb0138b5ecff0f5f6a7839dbfddc0684fd) **style:** Use simpler key thingy
-* [`720ec53`](https://github.com/buggerjs/node-inspect/commit/720ec53a5b251ab3caf27f06b60924efb9e03a92) **doc:** Add instructions
-* [`b89ad60`](https://github.com/buggerjs/node-inspect/commit/b89ad601b885a417e6433b1609477d8453f498a1) **doc:** More helpful docs
-* [`de9243c`](https://github.com/buggerjs/node-inspect/commit/de9243c95eabe733d05952229340808c3cebf129) **feat:** Watchers
-* [`e16978f`](https://github.com/buggerjs/node-inspect/commit/e16978ff8e4b2b2bdccf88fd7d3905f525822981) **docs:** Working usage hints
-* [`2dbc204`](https://github.com/buggerjs/node-inspect/commit/2dbc2042145fd97169fc7536186a449715e27810) **refactor:** Use proxies
-* [`b8c9b14`](https://github.com/buggerjs/node-inspect/commit/b8c9b147713f63181396d5a7fe4c2f737b733b4c) **style:** Remove unused var
-* [`f6b4b20`](https://github.com/buggerjs/node-inspect/commit/f6b4b20a1d28d91cfe452b995f7dbe5f7c749e89) **feat:** Nicer inspect of remote values
-* [`36887c6`](https://github.com/buggerjs/node-inspect/commit/36887c66bbf26d540f087f80ddfec38462a33bdf) **fix:** Properly print watchers
-* [`7729442`](https://github.com/buggerjs/node-inspect/commit/77294426157a28cc76e339cb13916a205182641e) **feat:** Add pause command
-* [`e39a713`](https://github.com/buggerjs/node-inspect/commit/e39a7134873f06da37baaa9b6252cede4ad38d7a) **fix:** Properly format boolean properties
-* [`f8f51d7`](https://github.com/buggerjs/node-inspect/commit/f8f51d7a01e8d74023306a08a3d6e2da63d123e1) **fix:** Properly format numeric properties
-* [`89e6e08`](https://github.com/buggerjs/node-inspect/commit/89e6e087220f3c3cb628ac7541c44298485a2e04) **feat:** Add backtrace command
-* [`82362ac`](https://github.com/buggerjs/node-inspect/commit/82362acfc7ce22b4cccc64889ec136dedc8895ec) **feat:** Add setBreakpoint()
-* [`7064cce`](https://github.com/buggerjs/node-inspect/commit/7064ccec3b103683088d532abfe5b4e7c066948b) **feat:** Add `setBreakpoint(line)`
-* [`360580e`](https://github.com/buggerjs/node-inspect/commit/360580eba4353e81311e56df018eec0ca233da11) **feat:** Add run/kill/restart
-* [`b1b576e`](https://github.com/buggerjs/node-inspect/commit/b1b576e2645723a8575df544e0bfb672d60d9d91) **feat:** Add `help` command
-* [`2db4660`](https://github.com/buggerjs/node-inspect/commit/2db46609cd1c8543d31ebd5dc47e4c27ec254841) **feat:** Add remaining sb() variants
-* [`f2ad1ae`](https://github.com/buggerjs/node-inspect/commit/f2ad1aeedafb154043d70bb9195b10986d311d26) **fix:** Display breakpoints set into the future
-* [`73272f9`](https://github.com/buggerjs/node-inspect/commit/73272f9ace1f8546f8cad1d53627dbffba50bb4e) **refactor:** Make breakpoints more inspect friendly
-* [`507a71d`](https://github.com/buggerjs/node-inspect/commit/507a71de345a3de7fe144517e9f5ea264ff993e3) **feat:** Add breakpoints command
-* [`5fb3e5d`](https://github.com/buggerjs/node-inspect/commit/5fb3e5d17bbcfd45b264431547b3cf0b781c7640) **docs:** Link to Command Line API docs
-* [`81af501`](https://github.com/buggerjs/node-inspect/commit/81af501bbf85397e2078310c7f24a9ac5b7f02dc) **chore:** Fix license field
diff --git a/deps/node-inspect/CONTRIBUTING.md b/deps/node-inspect/CONTRIBUTING.md
deleted file mode 100644
index 012d29471462dec6d776b862aa4974af5102a1f5..0000000000000000000000000000000000000000
--- a/deps/node-inspect/CONTRIBUTING.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# Contributing
-
-🎉🏅 Thanks for helping us improve this project! 🙏
-
-This document outlines some of the practices we care about.
-If you have any questions or suggestions about the process,
-feel free to [open an issue](#reporting-issues).
-
-## Code of Conduct
-
-The [Node.js Code of Conduct][] applies to this repo.
-
-[Node.js Code of Conduct]: https://github.com/nodejs/node/blob/master/CODE_OF_CONDUCT.md
-
-## Governance
-
-This project falls under the governance of the Node.js Diagnostics WG as
-described at <https://github.com/nodejs/diagnostics/blob/master/GOVERNANCE.md>.
-
-## Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-* (a) The contribution was created in whole or in part by me and I
-  have the right to submit it under the open source license
-  indicated in the file; or
-
-* (b) The contribution is based upon previous work that, to the best
-  of my knowledge, is covered under an appropriate open source
-  license and I have the right under that license to submit that
-  work with modifications, whether created in whole or in part
-  by me, under the same open source license (unless I am
-  permitted to submit under a different license), as indicated
-  in the file; or
-
-* (c) The contribution was provided directly to me by some other
-  person who certified (a), (b) or (c) and I have not modified
-  it.
-
-* (d) I understand and agree that this project and the contribution
-  are public and that a record of the contribution (including all
-  personal information I submit with it, including my sign-off) is
-  maintained indefinitely and may be redistributed consistent with
-  this project or the open source license(s) involved.
-
-## How Can I Contribute?
-
-### Reporting Issues
-
-If you find any mistakes in the docs or a bug in the code,
-please [open an issue in Github](https://github.com/nodejs/node-inspect/issues/new) so we can look into it.
-You can also [create a PR](#contributing-code) fixing it yourself of course.
-
-If you report a bug, please follow these guidelines:
-
-* Make sure the bug exists in the latest version.
-* Include instructions on how to reproduce the issue.
-  The instructions should be as minimal as possible
-  and answer the three big questions:
-  1. What are the exact steps you took? This includes the exact versions of node, npm, and any packages involved.
-  1. What result are you expecting?
-  1. What is the actual result?
-
-### Improving Documentation
-
-For small documentation changes, you can use [Github's editing feature](https://help.github.com/articles/editing-files-in-another-user-s-repository/).
-The only thing to keep in mind is to prefix the commit message with "docs: ".
-The default commit message generated by Github will lead to a failing CI build.
-
-For larger updates to the documentation
-it might be better to follow the [instructions for contributing code below](#contributing-code).
-
-### Contributing Code
-
-**Note:** If you're planning on making substantial changes,
-please [open an issue first to discuss your idea](#reporting-issues).
-Otherwise you might end up investing a lot of work
-only to discover that it conflicts with plans the maintainers might have.
-
-The general steps for creating a pull request are:
-
-1. Create a branch for your change.
-   Always start your branch from the latest `master`.
-   We often prefix the branch name with our initials, e.g. `jk-a-change`.
-1. Run `npm install` to install the dependencies.
-1. If you're fixing a bug, be sure to write a test *first*.
-   That way you can validate that the test actually catches the bug and doesn't pass.
-1. Make your changes to the code.
-   Remember to update the tests if you add new features or change behavior.
-1. Run the tests via `npm test`. This will also run style checks and other validations.
-   You might see errors about uncommitted files.
-   This is expected until you commit your changes.
-1. Once you're done, `git add .` and `git commit`.
-   Please follow the [commit message conventions](#commits--commit-messages) described below.
-1. Push your branch to Github & create a PR.
-
-#### Code Style
-
-In addition to any linting rules the project might include,
-a few general rules of thumb:
-
-* Try to match the style of the rest of the code.
-* We prefer simple code that is easy to understand over terse, expressive code.
-* We try to structure projects by semantics instead of role.
-  E.g. we'd rather have a `tree.js` module that contains tree traversal-related helpers
-  than a `helpers.js` module.
-* Actually, if you create helpers you might want to put those into a separate package.
-  That way it's easier to reuse them.
-
-#### Commits & Commit Messages
-
-Please follow the [angular commit message conventions](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md#-git-commit-guidelines).
-We use an automated tool for generating releases
-that depends on the conventions to determine the next version and the content of the changelog.
-Commit messages that don't follow the conventions will cause `npm test` (and thus CI) to fail.
-
-The short summary - a commit message should look like this:
-
-```
-<type>: <subject>
-
-<body>
-
-<references>
-
-<footer>
-```
-
-Everything but the first line is optional.
-The empty lines between the different parts are required.
-
-* `<type>`: One of the following:
-  - **feat:** Introduces a new feature. This will cause the minor version to go up.
-  - **fix:** A bug fix. Causes a patch version bump.
-  - **docs:** Changes to the documentation.
-    This will also cause an increase of the patch version so that the changes show up in the npm registry.
-  - **style:** Cleanup & lint rule fixes.
-    Note that often it's better to just amend the previous commit if it introduced lint errors.
-  - **refactor:** Changes to the code structure without fixing bugs or adding features.
-  - **perf:** Performance optimizations.
-  - **test:** Fixing existing tests or adding missing ones.
-    Just like with **style**, if you add tests to a feature you just introduced in the previous commit,
-    consider keeping the tests and the feature in the same commit instead.
-  - **chore:** Changes to the project setup and tools, dependency bumps, house-keeping.
-* `<subject>`: A [good git commit message subject](http://chris.beams.io/posts/git-commit/#limit-50).
-  - Keep it brief. If possible the whole first line should have at most 50 characters.
-  - Use imperative mood. "Create" instead of "creates" or "created".
-  - No period (".") at the end.
-* `<body>`: Motivation for the change and any context required for understanding the choices made.
-  Just like the subject, it should use imperative mood.
-* `<references>`: Any URLs relevant to the PR go here.
-  Use one line per URL and prefix it with the kind of relationship, e.g. "Closes: " or "See: ".
-  If you are referencing an issue in your commit body or PR description,
-  never use `#123` but the full URL to the issue or PR you are referencing.
-  That way the reference is easy to resolve from the git history without having to "guess" the correct link
-  even if the commit got cherry-picked or merged into a different project.
-* `<footer>`: This part only applies if your commit introduces a breaking change.
-  It's important this is present, otherwise the major version will not increase.
-  See below for an example.
-
-##### Examples
-
-A feature that introduces a breaking change:
-
-```
-feat: Support --yes CLI option
-
-For existing projects all prompts can be inferred automatically.
-Manual confirmation for each default provides no value in that case.
-
-Closes https://github.com/my/project/issues/123
-
-BREAKING CHANGE: This removes support for interactive password entry.
-Users will have to login beforehand.
-```
-
-A simple bug fix:
-
-```
-fix: Handle multi-byte characters in search logic
-```
diff --git a/deps/node-inspect/GOVERNANCE.md b/deps/node-inspect/GOVERNANCE.md
deleted file mode 100644
index 20e333a247cbfd0a7fb2c6de51f13cf4f08d6d29..0000000000000000000000000000000000000000
--- a/deps/node-inspect/GOVERNANCE.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# node-inspect Project Governance
-
-The node-inspect project is governed by the Node.js Diagnostics WG as described
-at <https://github.com/nodejs/diagnostics/blob/master/GOVERNANCE.md>.
diff --git a/deps/node-inspect/LICENSE b/deps/node-inspect/LICENSE
deleted file mode 100644
index d8d7f9437dbf5ad54701a187f05988bcf0006fd8..0000000000000000000000000000000000000000
--- a/deps/node-inspect/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright Node.js contributors. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-IN THE SOFTWARE.
diff --git a/deps/node-inspect/README.md b/deps/node-inspect/README.md
deleted file mode 100644
index b52cc188a62f5bdb50e186fbf1a04a7620db901e..0000000000000000000000000000000000000000
--- a/deps/node-inspect/README.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# `node-inspect`
-
-```bash
-npm install --global node-inspect
-```
-
-For the old V8 debugger protocol,
-node has two options:
-
-1. `node --debug <file>`: Start `file` with remote debugging enabled.
-2. `node debug <file>`: Start an interactive CLI debugger for `<file>`.
-
-But for the Chrome inspector protocol,
-there's only one: `node --inspect <file>`.
-
-This project tries to provide the missing second option
-by re-implementing `node debug` against the new protocol.
-
-```
-Usage: node-inspect script.js
-       node-inspect <host>:<port>
-```
-
-#### References
-
-* [Debugger Documentation](https://nodejs.org/api/debugger.html)
-* [EPS: `node inspect` CLI debugger](https://github.com/nodejs/node-eps/pull/42)
-* [Debugger Protocol Viewer](https://chromedevtools.github.io/debugger-protocol-viewer/)
-* [Command Line API](https://developers.google.com/web/tools/chrome-devtools/debug/command-line/command-line-reference?hl=en)
diff --git a/deps/node-inspect/appveyor.yml b/deps/node-inspect/appveyor.yml
deleted file mode 100644
index c25a2d013aadbf6db2ee620996a91c010e5743b3..0000000000000000000000000000000000000000
--- a/deps/node-inspect/appveyor.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-environment:
-  nodejs_version: "6"
-
-install:
-- ps: Install-Product node $env:nodejs_version
-- npm install
-
-test_script:
-- node --version
-- npm --version
-- npm test
-
-build: off
diff --git a/deps/node-inspect/lib/cli.js b/deps/node-inspect/lib/cli.js
deleted file mode 100644
index a4880df2d56be86a4fae8bd146ef32c1f539a0bd..0000000000000000000000000000000000000000
--- a/deps/node-inspect/lib/cli.js
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright Node.js contributors. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-'use strict';
-// ~= NativeModule.require('_debugger').start();
-require('./_inspect').start();
diff --git a/deps/node-inspect/package.json b/deps/node-inspect/package.json
deleted file mode 100644
index 925fb03f21a53d52e24b258ad45755097075f65c..0000000000000000000000000000000000000000
--- a/deps/node-inspect/package.json
+++ /dev/null
@@ -1,45 +0,0 @@
-{
-  "name": "node-inspect",
-  "version": "2.0.0",
-  "description": "Node Inspect",
-  "license": "MIT",
-  "main": "lib/_inspect.js",
-  "bin": "cli.js",
-  "homepage": "https://github.com/nodejs/node-inspect",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/nodejs/node-inspect"
-  },
-  "bugs": {
-    "url": "https://github.com/nodejs/node-inspect/issues"
-  },
-  "scripts": {
-    "pretest": "eslint --rulesdir=tools/eslint-rules lib test",
-    "test": "tap test",
-    "posttest": "nlm verify"
-  },
-  "nlm": {
-    "license": {
-      "files": [
-        "lib"
-      ]
-    }
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "eslint": "^6.8.0",
-    "nlm": "^3.0.0",
-    "tap": "^10.7.0"
-  },
-  "author": {
-    "name": "Jan Krems",
-    "email": "jan.krems@gmail.com"
-  },
-  "files": [
-    "*.js",
-    "lib"
-  ],
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org"
-  }
-}
diff --git a/deps/node-inspect/test/cli/launch.test.js b/deps/node-inspect/test/cli/launch.test.js
deleted file mode 100644
index c4ff3d855a82bcde181d588b5e96b80f3c5a9c80..0000000000000000000000000000000000000000
--- a/deps/node-inspect/test/cli/launch.test.js
+++ /dev/null
@@ -1,196 +0,0 @@
-'use strict';
-const Path = require('path');
-
-const { test } = require('tap');
-
-const startCLI = require('./start-cli');
-
-test('custom port', (t) => {
-  const CUSTOM_PORT = '9230';
-  const script = Path.join('examples', 'three-lines.js');
-
-  const cli = startCLI([`--port=${CUSTOM_PORT}`, script]);
-
-  return cli.waitForInitialBreak()
-    .then(() => cli.waitForPrompt())
-    .then(() => {
-      t.match(cli.output, 'debug>', 'prints a prompt');
-      t.match(
-        cli.output,
-        new RegExp(`< Debugger listening on [^\n]*${CUSTOM_PORT}`),
-        'forwards child output');
-    })
-    .then(() => cli.quit())
-    .then((code) => {
-      t.equal(code, 0, 'exits with success');
-    });
-});
-
-test('random port', (t) => {
-  const script = Path.join('examples', 'three-lines.js');
-
-  const cli = startCLI(['--port=0', script]);
-
-  return cli.waitForInitialBreak()
-    .then(() => cli.waitForPrompt())
-    .then(() => {
-      t.match(cli.output, 'debug>', 'prints a prompt');
-      t.match(
-        cli.output,
-        /< Debugger listening on /,
-        'forwards child output');
-    })
-    .then(() => cli.quit())
-    .then((code) => {
-      t.equal(code, 0, 'exits with success');
-    });
-});
-
-test('random port with --inspect-port=0', (t) => {
-  const script = Path.join('examples', 'three-lines.js');
-
-  const cli = startCLI([script], ['--inspect-port=0']);
-
-  return cli.waitForInitialBreak()
-    .then(() => cli.waitForPrompt())
-    .then(() => {
-      t.match(cli.output, 'debug>', 'prints a prompt');
-      t.match(
-        cli.output,
-        /< Debugger listening on /,
-        'forwards child output');
-    })
-    .then(() => cli.quit())
-    .then((code) => {
-      t.equal(code, 0, 'exits with success');
-    });
-});
-
-test('examples/three-lines.js', (t) => {
-  const script = Path.join('examples', 'three-lines.js');
-  const cli = startCLI([script]);
-
-  return cli.waitForInitialBreak()
-    .then(() => cli.waitForPrompt())
-    .then(() => {
-      t.match(cli.output, 'debug>', 'prints a prompt');
-      t.match(
-        cli.output,
-        /< Debugger listening on [^\n]*9229/,
-        'forwards child output');
-    })
-    .then(() => cli.command('["hello", "world"].join(" ")'))
-    .then(() => {
-      t.match(cli.output, 'hello world', 'prints the result');
-    })
-    .then(() => cli.command(''))
-    .then(() => {
-      t.match(cli.output, 'hello world', 'repeats the last command on <enter>');
-    })
-    .then(() => cli.command('version'))
-    .then(() => {
-      t.match(cli.output, process.versions.v8, 'version prints the v8 version');
-    })
-    .then(() => cli.quit())
-    .then((code) => {
-      t.equal(code, 0, 'exits with success');
-    });
-});
-
-test('run after quit / restart', (t) => {
-  const script = Path.join('examples', 'three-lines.js');
-  const cli = startCLI([script]);
-
-  function onFatal(error) {
-    cli.quit();
-    throw error;
-  }
-
-  return cli.waitForInitialBreak()
-    .then(() => cli.waitForPrompt())
-    .then(() => cli.stepCommand('n'))
-    .then(() => {
-      t.match(
-        cli.output,
-        `break in ${script}:2`,
-        'steps to the 2nd line');
-    })
-    .then(() => cli.command('cont'))
-    .then(() => cli.waitFor(/disconnect/))
-    .then(() => {
-      t.match(
-        cli.output,
-        'Waiting for the debugger to disconnect',
-        'the child was done');
-    })
-    .then(() => {
-      // On windows the socket won't close by itself
-      return cli.command('kill');
-    })
-    .then(() => cli.command('cont'))
-    .then(() => cli.waitFor(/start the app/))
-    .then(() => {
-      t.match(cli.output, 'Use `run` to start the app again');
-    })
-    .then(() => cli.stepCommand('run'))
-    .then(() => cli.waitForInitialBreak())
-    .then(() => cli.waitForPrompt())
-    .then(() => {
-      t.match(
-        cli.breakInfo,
-        { filename: script, line: 1 },
-        'is back at the beginning');
-    })
-    .then(() => cli.stepCommand('n'))
-    .then(() => {
-      t.match(
-        cli.breakInfo,
-        { filename: script, line: 2 },
-        'steps to the 2nd line');
-    })
-    .then(() => cli.stepCommand('restart'))
-    .then(() => cli.waitForInitialBreak())
-    .then(() => {
-      t.match(
-        cli.breakInfo,
-        { filename: script, line: 1 },
-        'is back at the beginning');
-    })
-    .then(() => cli.command('kill'))
-    .then(() => cli.command('cont'))
-    .then(() => cli.waitFor(/start the app/))
-    .then(() => {
-      t.match(cli.output, 'Use `run` to start the app again');
-    })
-    .then(() => cli.stepCommand('run'))
-    .then(() => cli.waitForInitialBreak())
-    .then(() => cli.waitForPrompt())
-    .then(() => {
-      t.match(
-        cli.breakInfo,
-        { filename: script, line: 1 },
-        'is back at the beginning');
-    })
-    .then(() => cli.quit())
-    .then(null, onFatal);
-});
-
-test('auto-resume on start if the environment variable is defined', (t) => {
-  const script = Path.join('examples', 'break.js');
-
-  const cli = startCLI([script], [], {
-    env: { NODE_INSPECT_RESUME_ON_START: '1' }
-  });
-
-  return cli.waitForInitialBreak()
-    .then(() => {
-      t.match(
-        cli.breakInfo,
-        { filename: script, line: 10 },
-        'skips to the first breakpoint');
-    })
-    .then(() => cli.quit())
-    .then((code) => {
-      t.equal(code, 0, 'exits with success');
-    });
-});
diff --git a/deps/node-inspect/tools/eslint-rules/align-function-arguments.js b/deps/node-inspect/tools/eslint-rules/align-function-arguments.js
deleted file mode 100644
index 015552489a9d4457f53ed0a2f0ccf072eaaed9bf..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/align-function-arguments.js
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- * @fileoverview Align arguments in multiline function calls
- * @author Rich Trott
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-function checkArgumentAlignment(context, node) {
-
-  function isNodeFirstInLine(node, byEndLocation) {
-    const firstToken = byEndLocation === true ? context.getLastToken(node, 1) :
-      context.getTokenBefore(node);
-    const startLine = byEndLocation === true ? node.loc.end.line :
-      node.loc.start.line;
-    const endLine = firstToken ? firstToken.loc.end.line : -1;
-
-    return startLine !== endLine;
-  }
-
-  if (node.arguments.length === 0)
-    return;
-
-  var msg = '';
-  const first = node.arguments[0];
-  var currentLine = first.loc.start.line;
-  const firstColumn = first.loc.start.column;
-
-  const ignoreTypes = [
-    'ArrowFunctionExpression',
-    'FunctionExpression',
-    'ObjectExpression',
-  ];
-
-  const args = node.arguments;
-
-  // For now, don't bother trying to validate potentially complicating things
-  // like closures. Different people will have very different ideas and it's
-  // probably best to implement configuration options.
-  if (args.some((node) => { return ignoreTypes.indexOf(node.type) !== -1; })) {
-    return;
-  }
-
-  if (!isNodeFirstInLine(node)) {
-    return;
-  }
-
-  var misaligned;
-
-  args.slice(1).forEach((argument) => {
-    if (!misaligned) {
-      if (argument.loc.start.line === currentLine + 1) {
-        if (argument.loc.start.column !== firstColumn) {
-          if (isNodeFirstInLine(argument)) {
-            msg = 'Function argument in column ' +
-                  `${argument.loc.start.column + 1}, ` +
-                  `expected in ${firstColumn + 1}`;
-            misaligned = argument;
-          }
-        }
-      }
-    }
-    currentLine = argument.loc.start.line;
-  });
-
-  if (msg)
-    context.report(misaligned, msg);
-}
-
-module.exports = function(context) {
-  return {
-    'CallExpression': (node) => checkArgumentAlignment(context, node)
-  };
-};
diff --git a/deps/node-inspect/tools/eslint-rules/align-multiline-assignment.js b/deps/node-inspect/tools/eslint-rules/align-multiline-assignment.js
deleted file mode 100644
index 80896b5e96296de7fa8e6fc886c831b398b238cb..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/align-multiline-assignment.js
+++ /dev/null
@@ -1,68 +0,0 @@
-/**
- * @fileoverview Align multiline variable assignments
- * @author Rich Trott
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-function getBinaryExpressionStarts(binaryExpression, starts) {
-  function getStartsFromOneSide(side, starts) {
-    starts.push(side.loc.start);
-    if (side.type === 'BinaryExpression') {
-      starts = getBinaryExpressionStarts(side, starts);
-    }
-    return starts;
-  }
-
-  starts = getStartsFromOneSide(binaryExpression.left, starts);
-  starts = getStartsFromOneSide(binaryExpression.right, starts);
-  return starts;
-}
-
-function checkExpressionAlignment(expression) {
-  if (!expression)
-    return;
-
-  var msg = '';
-
-  switch (expression.type) {
-    case 'BinaryExpression':
-      var starts = getBinaryExpressionStarts(expression, []);
-      var startLine = starts[0].line;
-      const startColumn = starts[0].column;
-      starts.forEach((loc) => {
-        if (loc.line > startLine) {
-          startLine = loc.line;
-          if (loc.column !== startColumn) {
-            msg = 'Misaligned multiline assignment';
-          }
-        }
-      });
-      break;
-  }
-  return msg;
-}
-
-function testAssignment(context, node) {
-  const msg = checkExpressionAlignment(node.right);
-  if (msg)
-    context.report(node, msg);
-}
-
-function testDeclaration(context, node) {
-  node.declarations.forEach((declaration) => {
-    const msg = checkExpressionAlignment(declaration.init);
-    // const start = declaration.init.loc.start;
-    if (msg)
-      context.report(node, msg);
-  });
-}
-
-module.exports = function(context) {
-  return {
-    'AssignmentExpression': (node) => testAssignment(context, node),
-    'VariableDeclaration': (node) => testDeclaration(context, node)
-  };
-};
diff --git a/deps/node-inspect/tools/eslint-rules/assert-fail-single-argument.js b/deps/node-inspect/tools/eslint-rules/assert-fail-single-argument.js
deleted file mode 100644
index 4ce790238181ccda30f8df9888de106a80fff9c1..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/assert-fail-single-argument.js
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- * @fileoverview Prohibit use of a single argument only in `assert.fail()`. It
- * is almost always an error.
- * @author Rich Trott
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const msg = 'assert.fail() message should be third argument';
-
-function isAssert(node) {
-  return node.callee.object && node.callee.object.name === 'assert';
-}
-
-function isFail(node) {
-  return node.callee.property && node.callee.property.name === 'fail';
-}
-
-module.exports = function(context) {
-  return {
-    'CallExpression': function(node) {
-      if (isAssert(node) && isFail(node) && node.arguments.length === 1) {
-        context.report(node, msg);
-      }
-    }
-  };
-};
diff --git a/deps/node-inspect/tools/eslint-rules/buffer-constructor.js b/deps/node-inspect/tools/eslint-rules/buffer-constructor.js
deleted file mode 100644
index 938598e8dbf618c22632db613cebb8c69813abb8..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/buffer-constructor.js
+++ /dev/null
@@ -1,25 +0,0 @@
-/**
- * @fileoverview Require use of new Buffer constructor methods in lib
- * @author James M Snell
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-const msg = 'Use of the Buffer() constructor has been deprecated. ' +
-            'Please use either Buffer.alloc(), Buffer.allocUnsafe(), ' +
-            'or Buffer.from()';
-
-function test(context, node) {
-  if (node.callee.name === 'Buffer') {
-    context.report(node, msg);
-  }
-}
-
-module.exports = function(context) {
-  return {
-    'NewExpression': (node) => test(context, node),
-    'CallExpression': (node) => test(context, node)
-  };
-};
diff --git a/deps/node-inspect/tools/eslint-rules/new-with-error.js b/deps/node-inspect/tools/eslint-rules/new-with-error.js
deleted file mode 100644
index 655f34bf080956a71a4fe0b0414cd782607ebfc8..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/new-with-error.js
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * @fileoverview Require `throw new Error()` rather than `throw Error()`
- * @author Rich Trott
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-  var errorList = context.options.length !== 0 ? context.options : ['Error'];
-
-  return {
-    'ThrowStatement': function(node) {
-      if (node.argument.type === 'CallExpression' &&
-          errorList.indexOf(node.argument.callee.name) !== -1) {
-        context.report(node, 'Use new keyword when throwing.');
-      }
-    }
-  };
-};
-
-module.exports.schema = {
-  'type': 'array',
-  'additionalItems': {
-    'type': 'string'
-  },
-  'uniqueItems': true
-};
diff --git a/deps/node-inspect/tools/eslint-rules/no-let-in-for-declaration.js b/deps/node-inspect/tools/eslint-rules/no-let-in-for-declaration.js
deleted file mode 100644
index 8b1a6783e0773d328d7974118e42f7c1dfb30030..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/no-let-in-for-declaration.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * @fileoverview Prohibit the use of `let` as the loop variable
- *               in the initialization of for, and the left-hand
- *               iterator in forIn and forOf loops.
- *
- * @author Jessica Quynh Tran
- */
-
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
-  create(context) {
-
-    const msg = 'Use of `let` as the loop variable in a for-loop is ' +
-                'not recommended. Please use `var` instead.';
-
-    /**
-     * Report function to test if the for-loop is declared using `let`.
-     */
-    function testForLoop(node) {
-      if (node.init && node.init.kind === 'let') {
-        context.report(node.init, msg);
-      }
-    }
-
-    /**
-     * Report function to test if the for-in or for-of loop
-     * is declared using `let`.
-     */
-    function testForInOfLoop(node) {
-      if (node.left && node.left.kind === 'let') {
-        context.report(node.left, msg);
-      }
-    }
-
-    return {
-      'ForStatement': testForLoop,
-      'ForInStatement': testForInOfLoop,
-      'ForOfStatement': testForInOfLoop
-    };
-  }
-};
diff --git a/deps/node-inspect/tools/eslint-rules/prefer-assert-methods.js b/deps/node-inspect/tools/eslint-rules/prefer-assert-methods.js
deleted file mode 100644
index fa345eb7c3fc33a92dee51ae59036c24b7161d2e..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/prefer-assert-methods.js
+++ /dev/null
@@ -1,39 +0,0 @@
-'use strict';
-
-function isAssert(node) {
-  return node.expression &&
-    node.expression.type === 'CallExpression' &&
-    node.expression.callee &&
-    node.expression.callee.name === 'assert';
-}
-
-function getFirstArg(expression) {
-  return expression.arguments && expression.arguments[0];
-}
-
-function parseError(method, op) {
-  return `'assert.${method}' should be used instead of '${op}'`;
-}
-
-const preferedAssertMethod = {
-  '===': 'strictEqual',
-  '!==': 'notStrictEqual',
-  '==': 'equal',
-  '!=': 'notEqual'
-};
-
-module.exports = function(context) {
-  return {
-    ExpressionStatement(node) {
-      if (isAssert(node)) {
-        const arg = getFirstArg(node.expression);
-        if (arg && arg.type === 'BinaryExpression') {
-          const assertMethod = preferedAssertMethod[arg.operator];
-          if (assertMethod) {
-            context.report(node, parseError(assertMethod, arg.operator));
-          }
-        }
-      }
-    }
-  };
-};
diff --git a/deps/node-inspect/tools/eslint-rules/require-buffer.js b/deps/node-inspect/tools/eslint-rules/require-buffer.js
deleted file mode 100644
index c9818cb758f7bdcb2643c9746b2b3ace64bff650..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/require-buffer.js
+++ /dev/null
@@ -1,19 +0,0 @@
-'use strict';
-
-module.exports = function(context) {
-  function flagIt(reference) {
-    const msg = 'Use const Buffer = require(\'buffer\').Buffer; ' +
-                'at the beginning of this file';
-    context.report(reference.identifier, msg);
-  }
-
-  return {
-    'Program:exit': function() {
-      const globalScope = context.getScope();
-      const variable = globalScope.set.get('Buffer');
-      if (variable) {
-        variable.references.forEach(flagIt);
-      }
-    }
-  };
-};
diff --git a/deps/node-inspect/tools/eslint-rules/required-modules.js b/deps/node-inspect/tools/eslint-rules/required-modules.js
deleted file mode 100644
index 3e4a8e8aadfc823b653de9612e7e6c232e88fb0a..0000000000000000000000000000000000000000
--- a/deps/node-inspect/tools/eslint-rules/required-modules.js
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * @fileoverview Require usage of specified node modules.
- * @author Rich Trott
- */
-'use strict';
-
-var path = require('path');
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-  // trim required module names
-  var requiredModules = context.options;
-
-  var foundModules = [];
-
-  // if no modules are required we don't need to check the CallExpressions
-  if (requiredModules.length === 0) {
-    return {};
-  }
-
-  /**
-   * Function to check if a node is a string literal.
-   * @param {ASTNode} node The node to check.
-   * @returns {boolean} If the node is a string literal.
-   */
-  function isString(node) {
-    return node && node.type === 'Literal' && typeof node.value === 'string';
-  }
-
-  /**
-   * Function to check if a node is a require call.
-   * @param {ASTNode} node The node to check.
-   * @returns {boolean} If the node is a require call.
-   */
-  function isRequireCall(node) {
-    return node.callee.type === 'Identifier' && node.callee.name === 'require';
-  }
-
-  /**
-   * Function to check if a node has an argument that is a required module and
-   * return its name.
-   * @param {ASTNode} node The node to check
-   * @returns {undefined|String} required module name or undefined
-   */
-  function getRequiredModuleName(node) {
-    var moduleName;
-
-    // node has arguments and first argument is string
-    if (node.arguments.length && isString(node.arguments[0])) {
-      var argValue = path.basename(node.arguments[0].value.trim());
-
-      // check if value is in required modules array
-      if (requiredModules.indexOf(argValue) !== -1) {
-        moduleName = argValue;
-      }
-    }
-
-    return moduleName;
-  }
-
-  return {
-    'CallExpression': function(node) {
-      if (isRequireCall(node)) {
-        var requiredModuleName = getRequiredModuleName(node);
-
-        if (requiredModuleName) {
-          foundModules.push(requiredModuleName);
-        }
-      }
-    },
-    'Program:exit': function(node) {
-      if (foundModules.length < requiredModules.length) {
-        var missingModules = requiredModules.filter(
-          function(module) {
-            return foundModules.indexOf(module === -1);
-          }
-          );
-        missingModules.forEach(function(moduleName) {
-          context.report(
-            node,
-            'Mandatory module "{{moduleName}}" must be loaded.',
-            { moduleName: moduleName }
-            );
-        });
-      }
-    }
-  };
-};
-
-module.exports.schema = {
-  'type': 'array',
-  'additionalItems': {
-    'type': 'string'
-  },
-  'uniqueItems': true
-};
diff --git a/deps/npm/docs/public/icons/icon-144x144.png b/deps/npm/docs/public/icons/icon-144x144.png
deleted file mode 100644
index cdc55431449e2e71a25227d51dfd87d2aeda4378..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/public/icons/icon-144x144.png and /dev/null differ
diff --git a/deps/npm/docs/public/icons/icon-192x192.png b/deps/npm/docs/public/icons/icon-192x192.png
deleted file mode 100644
index 31dcbfa6bdc2191bbbe2185d6e08761e1bfcef58..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/public/icons/icon-192x192.png and /dev/null differ
diff --git a/deps/npm/docs/public/icons/icon-256x256.png b/deps/npm/docs/public/icons/icon-256x256.png
deleted file mode 100644
index ea952cc115d9b447c35ace7bdba75aa0788f7098..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/public/icons/icon-256x256.png and /dev/null differ
diff --git a/deps/npm/docs/public/icons/icon-384x384.png b/deps/npm/docs/public/icons/icon-384x384.png
deleted file mode 100644
index 57649823c6c3c37759da614fb2b85ba3413d636c..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/public/icons/icon-384x384.png and /dev/null differ
diff --git a/deps/npm/docs/public/icons/icon-48x48.png b/deps/npm/docs/public/icons/icon-48x48.png
deleted file mode 100644
index a6fe2644f92e34d9fc860144f128074c78a72290..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/public/icons/icon-48x48.png and /dev/null differ
diff --git a/deps/npm/docs/public/icons/icon-512x512.png b/deps/npm/docs/public/icons/icon-512x512.png
deleted file mode 100644
index 7abc6a5865306996887152d76cfa29abfa394740..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/public/icons/icon-512x512.png and /dev/null differ
diff --git a/deps/npm/docs/public/icons/icon-72x72.png b/deps/npm/docs/public/icons/icon-72x72.png
deleted file mode 100644
index f4ccb61f49c6eb08342a70aebc346bc46a1748b7..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/public/icons/icon-72x72.png and /dev/null differ
diff --git a/deps/npm/docs/public/icons/icon-96x96.png b/deps/npm/docs/public/icons/icon-96x96.png
deleted file mode 100644
index 739a5fe5379e124bfeacf15b341d9b01d270ea12..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/public/icons/icon-96x96.png and /dev/null differ
diff --git a/deps/npm/docs/src/images/npm-icon.png b/deps/npm/docs/src/images/npm-icon.png
deleted file mode 100644
index a977a685a668aa75dcd90cfbe5ec395d97acdbe1..0000000000000000000000000000000000000000
Binary files a/deps/npm/docs/src/images/npm-icon.png and /dev/null differ
diff --git a/deps/npm/node_modules/agent-base/test/ssl-cert-snakeoil.pem b/deps/npm/node_modules/agent-base/test/ssl-cert-snakeoil.pem
deleted file mode 100644
index b115a5e91498de8c0e4ab0e3c06ebab8fe9f784d..0000000000000000000000000000000000000000
--- a/deps/npm/node_modules/agent-base/test/ssl-cert-snakeoil.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB1TCCAT4CCQDV5mPlzm9+izANBgkqhkiG9w0BAQUFADAvMS0wKwYDVQQDEyQ3
-NTI3YmQ3Ny1hYjNlLTQ3NGItYWNlNy1lZWQ2MDUzOTMxZTcwHhcNMTUwNzA2MjI0
-NTA3WhcNMjUwNzAzMjI0NTA3WjAvMS0wKwYDVQQDEyQ3NTI3YmQ3Ny1hYjNlLTQ3
-NGItYWNlNy1lZWQ2MDUzOTMxZTcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
-ALNRHEirN6vQAIBtf+Ud2yfgZ308sqt/sR4Nh8h1XQdko8PxYOtsHHb98G7Q5bay
-OfO/9JVlsnQMC48T+nT55PSpvaoLXSLP2JMPuuJt3uDGGKtVvzJvd8GNezFzxXyn
-g3LUty81KoKPBRsmp1GiB+gl5OKo8znzPmw3O6/mKruLAgMBAAEwDQYJKoZIhvcN
-AQEFBQADgYEACzoHUF8UV2Z6541Q2wKEA0UFUzmUjf/E1XwBO+1P15ZZ64uw34B4
-1RwMPtAo9RY/PmICTWtNxWGxkzwb2JtDWtnxVER/lF8k2XcXPE76fxTHJF/BKk9J
-QU8OTD1dd9gHCBviQB9TqntRZ5X7axjtuWjb2umY+owBYzAHZkp1HKI=
------END CERTIFICATE-----
diff --git a/deps/npm/node_modules/clone/LICENSE b/deps/npm/node_modules/clone/LICENSE
deleted file mode 100644
index cc3c87bc3bfd853333eb78ca931e4df3afbff89f..0000000000000000000000000000000000000000
--- a/deps/npm/node_modules/clone/LICENSE
+++ /dev/null
@@ -1,18 +0,0 @@
-Copyright © 2011-2015 Paul Vorbach <paul@vorba.ch>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the “Software”), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/deps/npm/node_modules/http-proxy-agent/test/ssl-cert-snakeoil.pem b/deps/npm/node_modules/http-proxy-agent/test/ssl-cert-snakeoil.pem
deleted file mode 100644
index b115a5e91498de8c0e4ab0e3c06ebab8fe9f784d..0000000000000000000000000000000000000000
--- a/deps/npm/node_modules/http-proxy-agent/test/ssl-cert-snakeoil.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB1TCCAT4CCQDV5mPlzm9+izANBgkqhkiG9w0BAQUFADAvMS0wKwYDVQQDEyQ3
-NTI3YmQ3Ny1hYjNlLTQ3NGItYWNlNy1lZWQ2MDUzOTMxZTcwHhcNMTUwNzA2MjI0
-NTA3WhcNMjUwNzAzMjI0NTA3WjAvMS0wKwYDVQQDEyQ3NTI3YmQ3Ny1hYjNlLTQ3
-NGItYWNlNy1lZWQ2MDUzOTMxZTcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
-ALNRHEirN6vQAIBtf+Ud2yfgZ308sqt/sR4Nh8h1XQdko8PxYOtsHHb98G7Q5bay
-OfO/9JVlsnQMC48T+nT55PSpvaoLXSLP2JMPuuJt3uDGGKtVvzJvd8GNezFzxXyn
-g3LUty81KoKPBRsmp1GiB+gl5OKo8znzPmw3O6/mKruLAgMBAAEwDQYJKoZIhvcN
-AQEFBQADgYEACzoHUF8UV2Z6541Q2wKEA0UFUzmUjf/E1XwBO+1P15ZZ64uw34B4
-1RwMPtAo9RY/PmICTWtNxWGxkzwb2JtDWtnxVER/lF8k2XcXPE76fxTHJF/BKk9J
-QU8OTD1dd9gHCBviQB9TqntRZ5X7axjtuWjb2umY+owBYzAHZkp1HKI=
------END CERTIFICATE-----
diff --git a/deps/npm/node_modules/mute-stream/coverage/lcov-report/sort-arrow-sprite.png b/deps/npm/node_modules/mute-stream/coverage/lcov-report/sort-arrow-sprite.png
deleted file mode 100644
index 03f704a609c6fd0dbfdac63466a7d7c958b5cbf3..0000000000000000000000000000000000000000
Binary files a/deps/npm/node_modules/mute-stream/coverage/lcov-report/sort-arrow-sprite.png and /dev/null differ
diff --git a/deps/npm/node_modules/promise-retry/node_modules/retry/equation.gif b/deps/npm/node_modules/promise-retry/node_modules/retry/equation.gif
deleted file mode 100644
index 97107237ba19f51997d8d76135bc7d1486d856f0..0000000000000000000000000000000000000000
Binary files a/deps/npm/node_modules/promise-retry/node_modules/retry/equation.gif and /dev/null differ
diff --git a/deps/npm/node_modules/qrcode-terminal/example/basic.png b/deps/npm/node_modules/qrcode-terminal/example/basic.png
deleted file mode 100644
index 2ab5c226f4311f6892bd73a0f0f279257d5cafd5..0000000000000000000000000000000000000000
Binary files a/deps/npm/node_modules/qrcode-terminal/example/basic.png and /dev/null differ
diff --git a/deps/npm/node_modules/retry/equation.gif b/deps/npm/node_modules/retry/equation.gif
deleted file mode 100644
index 97107237ba19f51997d8d76135bc7d1486d856f0..0000000000000000000000000000000000000000
Binary files a/deps/npm/node_modules/retry/equation.gif and /dev/null differ
diff --git a/deps/npm/node_modules/socks-proxy-agent/node_modules/agent-base/test/ssl-cert-snakeoil.pem b/deps/npm/node_modules/socks-proxy-agent/node_modules/agent-base/test/ssl-cert-snakeoil.pem
deleted file mode 100644
index b115a5e91498de8c0e4ab0e3c06ebab8fe9f784d..0000000000000000000000000000000000000000
--- a/deps/npm/node_modules/socks-proxy-agent/node_modules/agent-base/test/ssl-cert-snakeoil.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB1TCCAT4CCQDV5mPlzm9+izANBgkqhkiG9w0BAQUFADAvMS0wKwYDVQQDEyQ3
-NTI3YmQ3Ny1hYjNlLTQ3NGItYWNlNy1lZWQ2MDUzOTMxZTcwHhcNMTUwNzA2MjI0
-NTA3WhcNMjUwNzAzMjI0NTA3WjAvMS0wKwYDVQQDEyQ3NTI3YmQ3Ny1hYjNlLTQ3
-NGItYWNlNy1lZWQ2MDUzOTMxZTcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
-ALNRHEirN6vQAIBtf+Ud2yfgZ308sqt/sR4Nh8h1XQdko8PxYOtsHHb98G7Q5bay
-OfO/9JVlsnQMC48T+nT55PSpvaoLXSLP2JMPuuJt3uDGGKtVvzJvd8GNezFzxXyn
-g3LUty81KoKPBRsmp1GiB+gl5OKo8znzPmw3O6/mKruLAgMBAAEwDQYJKoZIhvcN
-AQEFBQADgYEACzoHUF8UV2Z6541Q2wKEA0UFUzmUjf/E1XwBO+1P15ZZ64uw34B4
-1RwMPtAo9RY/PmICTWtNxWGxkzwb2JtDWtnxVER/lF8k2XcXPE76fxTHJF/BKk9J
-QU8OTD1dd9gHCBviQB9TqntRZ5X7axjtuWjb2umY+owBYzAHZkp1HKI=
------END CERTIFICATE-----
diff --git a/deps/npm/node_modules/socks-proxy-agent/test/ssl-cert-snakeoil.pem b/deps/npm/node_modules/socks-proxy-agent/test/ssl-cert-snakeoil.pem
deleted file mode 100644
index b115a5e91498de8c0e4ab0e3c06ebab8fe9f784d..0000000000000000000000000000000000000000
--- a/deps/npm/node_modules/socks-proxy-agent/test/ssl-cert-snakeoil.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB1TCCAT4CCQDV5mPlzm9+izANBgkqhkiG9w0BAQUFADAvMS0wKwYDVQQDEyQ3
-NTI3YmQ3Ny1hYjNlLTQ3NGItYWNlNy1lZWQ2MDUzOTMxZTcwHhcNMTUwNzA2MjI0
-NTA3WhcNMjUwNzAzMjI0NTA3WjAvMS0wKwYDVQQDEyQ3NTI3YmQ3Ny1hYjNlLTQ3
-NGItYWNlNy1lZWQ2MDUzOTMxZTcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
-ALNRHEirN6vQAIBtf+Ud2yfgZ308sqt/sR4Nh8h1XQdko8PxYOtsHHb98G7Q5bay
-OfO/9JVlsnQMC48T+nT55PSpvaoLXSLP2JMPuuJt3uDGGKtVvzJvd8GNezFzxXyn
-g3LUty81KoKPBRsmp1GiB+gl5OKo8znzPmw3O6/mKruLAgMBAAEwDQYJKoZIhvcN
-AQEFBQADgYEACzoHUF8UV2Z6541Q2wKEA0UFUzmUjf/E1XwBO+1P15ZZ64uw34B4
-1RwMPtAo9RY/PmICTWtNxWGxkzwb2JtDWtnxVER/lF8k2XcXPE76fxTHJF/BKk9J
-QU8OTD1dd9gHCBviQB9TqntRZ5X7axjtuWjb2umY+owBYzAHZkp1HKI=
------END CERTIFICATE-----
diff --git a/deps/npm/node_modules/term-size/vendor/macos/term-size b/deps/npm/node_modules/term-size/vendor/macos/term-size
deleted file mode 100755
index c32a1fdc1b073bb41e9ddbabbd694a741ed67abc..0000000000000000000000000000000000000000
Binary files a/deps/npm/node_modules/term-size/vendor/macos/term-size and /dev/null differ
diff --git a/deps/npm/node_modules/term-size/vendor/windows/term-size.exe b/deps/npm/node_modules/term-size/vendor/windows/term-size.exe
deleted file mode 100644
index e6075896800312b51890983acfc1fc38d0a92f88..0000000000000000000000000000000000000000
--- a/deps/npm/node_modules/term-size/vendor/windows/term-size.exe
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:87808453a974763661a0ac83375ae4f9733207653d1627ea7900bb85be1f6c57
-size 17408
diff --git a/deps/npm/node_modules/unique-filename/coverage/sort-arrow-sprite.png b/deps/npm/node_modules/unique-filename/coverage/sort-arrow-sprite.png
deleted file mode 100644
index 03f704a609c6fd0dbfdac63466a7d7c958b5cbf3..0000000000000000000000000000000000000000
Binary files a/deps/npm/node_modules/unique-filename/coverage/sort-arrow-sprite.png and /dev/null differ
diff --git a/deps/npm/test/fixtures/forked-underscore-1.5.1.tgz b/deps/npm/test/fixtures/forked-underscore-1.5.1.tgz
deleted file mode 100644
index afc38bc11e1a8af12bf6792c1e3a2ecf6937aa23..0000000000000000000000000000000000000000
--- a/deps/npm/test/fixtures/forked-underscore-1.5.1.tgz
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b3468ed302fb28e5946a4385e505b152957eb257665c393d42d713b178e40c3f
-size 583
diff --git a/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-bar.git.tar.gz b/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-bar.git.tar.gz
deleted file mode 100644
index fb27e17f4812fa2bc5bb5630e195df0fcc1c9d58..0000000000000000000000000000000000000000
Binary files a/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-bar.git.tar.gz and /dev/null differ
diff --git a/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-buzz.git.tar.gz b/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-buzz.git.tar.gz
deleted file mode 100644
index 0ea851fbec946ac8d7499b6a487953a73e3011b2..0000000000000000000000000000000000000000
Binary files a/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-buzz.git.tar.gz and /dev/null differ
diff --git a/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-foo.git.tar.gz b/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-foo.git.tar.gz
deleted file mode 100644
index 8e1abc6d05e704f29f8699e6e44e63e4e6a6f2dd..0000000000000000000000000000000000000000
Binary files a/deps/npm/test/fixtures/github-com-BryanDonovan-dummy-npm-foo.git.tar.gz and /dev/null differ
diff --git a/deps/npm/test/fixtures/github-com-BryanDonovan-npm-git-test.git.tar.gz b/deps/npm/test/fixtures/github-com-BryanDonovan-npm-git-test.git.tar.gz
deleted file mode 100644
index 7a4b9e813173126fa20aa514672041140f7b3174..0000000000000000000000000000000000000000
Binary files a/deps/npm/test/fixtures/github-com-BryanDonovan-npm-git-test.git.tar.gz and /dev/null differ
diff --git a/deps/npm/test/fixtures/gitignore-and-npmignore-2.tar b/deps/npm/test/fixtures/gitignore-and-npmignore-2.tar
deleted file mode 100644
index 289dd568bd6f8c08cab0f40184ca4e792ce8d0e0..0000000000000000000000000000000000000000
Binary files a/deps/npm/test/fixtures/gitignore-and-npmignore-2.tar and /dev/null differ
diff --git a/deps/npm/test/fixtures/gitignore-and-npmignore.tar b/deps/npm/test/fixtures/gitignore-and-npmignore.tar
deleted file mode 100644
index 8b638b114a5e0881218f55aa7fa07addb49c2bc1..0000000000000000000000000000000000000000
Binary files a/deps/npm/test/fixtures/gitignore-and-npmignore.tar and /dev/null differ
diff --git a/deps/npm/test/fixtures/gitignore-and-npmignore.tgz b/deps/npm/test/fixtures/gitignore-and-npmignore.tgz
deleted file mode 100644
index 56c522724d93e9e8080448ffa0a2751edcff82dd..0000000000000000000000000000000000000000
--- a/deps/npm/test/fixtures/gitignore-and-npmignore.tgz
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:32e40a5fd625ac9d8c4d7a0ceb8fd6daddaf4dc0c9c848010b8ad9d867eed86c
-size 360
diff --git a/deps/npm/test/fixtures/gitignore.tgz b/deps/npm/test/fixtures/gitignore.tgz
deleted file mode 100644
index 21957c53852ad617a913d71b7a1d624cee101b23..0000000000000000000000000000000000000000
--- a/deps/npm/test/fixtures/gitignore.tgz
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1638ef71d4915f1641602c9cda38f1dd2762789e2acfa362bcff0df5b1343825
-size 319
diff --git a/deps/npm/test/fixtures/npmignore.tgz b/deps/npm/test/fixtures/npmignore.tgz
deleted file mode 100644
index c72385a0a1e5b3fa6d1951560d55615144c9f8f3..0000000000000000000000000000000000000000
--- a/deps/npm/test/fixtures/npmignore.tgz
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f6522a59ca9d18a19146fd16634bf0e3828e572438147340530ceebba55e338d
-size 320
diff --git a/deps/npm/test/fixtures/scoped-underscore-1.3.1.tgz b/deps/npm/test/fixtures/scoped-underscore-1.3.1.tgz
deleted file mode 100644
index 0ab2c68009b0a858df288efe89a9b5411a5f268b..0000000000000000000000000000000000000000
--- a/deps/npm/test/fixtures/scoped-underscore-1.3.1.tgz
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bbf26d4144d81019b7c740e5abd7b012365b381538cd8da9c748eed5b08d3e89
-size 55415
diff --git a/deps/uvwasi/uvwasi.gyp b/deps/uvwasi/uvwasi.gyp
index d4189eeee2fc94a90ee126a7055832f5fa07e090..5822f8d59bd9e9160a9e3a0bf0a9719343d48d9a 100644
--- a/deps/uvwasi/uvwasi.gyp
+++ b/deps/uvwasi/uvwasi.gyp
@@ -18,9 +18,6 @@
         'src/wasi_rights.c',
         'src/wasi_serdes.c',
       ],
-      'dependencies': [
-        '../uv/uv.gyp:libuv',
-      ],
       'direct_dependent_settings': {
         'include_dirs': ['include']
       },
@@ -31,6 +28,11 @@
             '_POSIX_C_SOURCE=200112',
           ],
         }],
+        [ 'node_shared_libuv=="false"', {
+          'dependencies': [
+            '../uv/uv.gyp:libuv',
+          ],
+        }],
       ],
     }
   ]
diff --git a/deps/zlib/contrib/optimizations/chunkcopy.h b/deps/zlib/contrib/optimizations/chunkcopy.h
index 38ba0ed8a27f4560f80e1d3249af84676caa18a2..8bcdadad05a817b3008f39ee83c46e3bd261883c 100644
--- a/deps/zlib/contrib/optimizations/chunkcopy.h
+++ b/deps/zlib/contrib/optimizations/chunkcopy.h
@@ -29,6 +29,7 @@
 #include <arm_neon.h>
 typedef uint8x16_t z_vec128i_t;
 #elif defined(INFLATE_CHUNK_SIMD_SSE2)
+#pragma GCC target ("sse2")
 #include <emmintrin.h>
 typedef __m128i z_vec128i_t;
 #else
diff --git a/deps/zlib/fill_window_sse.c b/deps/zlib/fill_window_sse.c
index ed1e5d1d6735b12529cf8896446e73a6f962a2ba..e19154bc14d23827f24dd7f14206373c20c5f323 100644
--- a/deps/zlib/fill_window_sse.c
+++ b/deps/zlib/fill_window_sse.c
@@ -9,6 +9,7 @@
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
+#pragma GCC target ("sse2")
 #include <immintrin.h>
 #include "deflate.h"
 
diff --git a/deps/zlib/google/test/data/evil.zip b/deps/zlib/google/test/data/evil.zip
deleted file mode 100644
index 2100011493ee72ac0dd90c4d6113c5e6bd972119..0000000000000000000000000000000000000000
--- a/deps/zlib/google/test/data/evil.zip
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2a90a6231fa6f01448ed4a7dc71761659af45103bae518edf90c8930b7d2ecda
-size 241
diff --git a/deps/zlib/google/test/data/evil_via_absolute_file_name.zip b/deps/zlib/google/test/data/evil_via_absolute_file_name.zip
deleted file mode 100644
index e8977c291b9172818343ae1a85acc82a957d42ea..0000000000000000000000000000000000000000
--- a/deps/zlib/google/test/data/evil_via_absolute_file_name.zip
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9722b4e0782e7bbab00ce084e56cadbbf1d0dc70bec241f710cda571fa98e0cc
-size 172
diff --git a/deps/zlib/google/test/data/evil_via_invalid_utf8.zip b/deps/zlib/google/test/data/evil_via_invalid_utf8.zip
deleted file mode 100644
index 827eb2100ea1a093e5f1fe49739f49206e6194bc..0000000000000000000000000000000000000000
--- a/deps/zlib/google/test/data/evil_via_invalid_utf8.zip
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b9625c82de43d898e794d77954ac3fdacc85b7b585c13fdf9ba1dfc357a017f9
-size 4585
diff --git a/deps/zlib/google/test/data/test.zip b/deps/zlib/google/test/data/test.zip
deleted file mode 100644
index db9b651ffcdbdb0313d4f281b66fffd70107d8e9..0000000000000000000000000000000000000000
--- a/deps/zlib/google/test/data/test.zip
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bf4efc0897e82fbb9940a05a6b507ab75d700de59ca14e458283789323d2b524
-size 5065
diff --git a/deps/zlib/google/test/data/test_encrypted.zip b/deps/zlib/google/test/data/test_encrypted.zip
deleted file mode 100644
index 2d6989235d4be74476a1d6b4561d4c2f75598a0d..0000000000000000000000000000000000000000
--- a/deps/zlib/google/test/data/test_encrypted.zip
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:96e34dca4deb618e4062cf1a3916da1659b91c8343ccd966cce01c4ee6904922
-size 5325
diff --git a/deps/zlib/google/test/data/test_mismatch_size.zip b/deps/zlib/google/test/data/test_mismatch_size.zip
deleted file mode 100644
index 8bfad8509a2701661e70d5ae8361982aad623d18..0000000000000000000000000000000000000000
--- a/deps/zlib/google/test/data/test_mismatch_size.zip
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:23e0649f22e18996cd111603c8f11ed6bb4e586e711b5a0140123c25e9b58e09
-size 886
diff --git a/deps/zlib/google/test/data/test_nocompress.zip b/deps/zlib/google/test/data/test_nocompress.zip
deleted file mode 100644
index 442a203cd33b53ca6e761c42fc5385024472bb8d..0000000000000000000000000000000000000000
--- a/deps/zlib/google/test/data/test_nocompress.zip
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:32cc05dcdf501c9ff5c22cacb40e7170dab609be196e67d151d4538a8150ca3d
-size 14252
diff --git a/deps/zlib/zlib.gyp b/deps/zlib/zlib.gyp
index 6f5a8ce3464b31c5ada94292e5190822eda5d92e..bbfb561b89b52fcf21a87d018a7987619d0f444b 100644
--- a/deps/zlib/zlib.gyp
+++ b/deps/zlib/zlib.gyp
@@ -122,7 +122,7 @@
                     ['OS=="linux"', {
                       'defines': [ 'ARMV8_OS_LINUX' ],
                     }],
-                    ['OS="win"', {
+                    ['OS=="win"', {
                       'defines': [ 'ARMV8_OS_WINDOWS' ],
                     }],
                     ['OS!="android" and OS!="win" and llvm_version=="0.0"', {
diff --git a/doc/abi_version_registry.json b/doc/abi_version_registry.json
index c16a93fa36a8df3ef878cde98017c4e406874f02..fc17f039193f4fb0407981859d42a8cb4246ccc2 100644
--- a/doc/abi_version_registry.json
+++ b/doc/abi_version_registry.json
@@ -1,5 +1,14 @@
 {
   "NODE_MODULE_VERSION": [
+    { "modules": 85, "runtime": "electron", "variant": "electron",             "versions": "11" },
+    { "modules": 84, "runtime": "node",     "variant": "v8_8.3",               "versions": "15.0.0-pre" },
+    { "modules": 83, "runtime": "node",     "variant": "v8_8.1",               "versions": "14.0.0" },
+    { "modules": 82, "runtime": "electron", "variant": "electron",             "versions": "10" },
+    { "modules": 81, "runtime": "node",     "variant": "v8_7.9",               "versions": "14.0.0-pre" },
+    { "modules": 80, "runtime": "electron", "variant": "electron",             "versions": "9" },
+    { "modules": 79, "runtime": "node",     "variant": "v8_7.8",               "versions": "13" },
+    { "modules": 78, "runtime": "node",     "variant": "v8_7.7",               "versions": "13.0.0-pre" },
+    { "modules": 77, "runtime": "node",     "variant": "v8_7.6",               "versions": "13.0.0-pre" },
     { "modules": 76, "runtime": "electron", "variant": "electron",             "versions": "8" },
     { "modules": 75, "runtime": "electron", "variant": "electron",             "versions": "7" },
     { "modules": 74, "runtime": "node",     "variant": "v8_7.5",               "versions": "13.0.0-pre" },
diff --git a/doc/api/addons.html b/doc/api/addons.html
index 067dcc02864686318f5821b0e652559e1a10cde8..8b2c23f4dfdc5da6d0e4642272eb3c62dc74c2d7 100644
--- a/doc/api/addons.html
+++ b/doc/api/addons.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>C++ addons | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>C++ addons | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons active">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons active">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="addons" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/addons.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/addons.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/addons.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/addons.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/addons.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/addons.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/addons.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/addons.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/addons.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#addons_c_addons">C++ addons</a>
 <ul>
 <li><a href="#addons_hello_world">Hello world</a>
@@ -142,7 +155,7 @@
 </ul>
 </li>
 <li><a href="#addons_native_abstractions_for_node_js">Native abstractions for Node.js</a></li>
-<li><a href="#addons_n_api">N-API</a></li>
+<li><span class="stability_2"><a href="#addons_node_api">Node-API</a></span></li>
 <li><a href="#addons_addon_examples">Addon examples</a>
 <ul>
 <li><a href="#addons_function_arguments">Function arguments</a></li>
@@ -156,25 +169,25 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>C++ addons<span><a class="mark" href="#addons_c_addons" id="addons_c_addons">#</a></span></h1>
+        <h2>C++ addons<span><a class="mark" href="#addons_c_addons" id="addons_c_addons">#</a></span></h2>
 
 
 <p><em>Addons</em> are dynamically-linked shared objects written in C++. The
 <a href="modules.html#modules_require_id"><code>require()</code></a> function can load addons as ordinary Node.js modules.
 Addons provide an interface between JavaScript and C/C++ libraries.</p>
-<p>There are three options for implementing addons: N-API, nan, or direct
+<p>There are three options for implementing addons: Node-API, nan, or direct
 use of internal V8, libuv and Node.js libraries. Unless there is a need for
-direct access to functionality which is not exposed by N-API, use N-API.
-Refer to <a href="n-api.html">C/C++ addons with N-API</a> for more information on N-API.</p>
-<p>When not using N-API, implementing addons is complicated,
+direct access to functionality which is not exposed by Node-API, use Node-API.
+Refer to <a href="n-api.html">C/C++ addons with Node-API</a> for more information on
+Node-API.</p>
+<p>When not using Node-API, implementing addons is complicated,
 involving knowledge of several components and APIs:</p>
 <ul>
 <li>
-<p>V8: the C++ library Node.js uses to provide the
+<p><a href="https://v8.dev/">V8</a>: the C++ library Node.js uses to provide the
 JavaScript implementation. V8 provides the mechanisms for creating objects,
 calling functions, etc. V8's API is documented mostly in the
 <code>v8.h</code> header file (<code>deps/v8/include/v8.h</code> in the Node.js source
@@ -186,12 +199,12 @@ threads and all of the asynchronous behaviors of the platform. It also
 serves as a cross-platform abstraction library, giving easy, POSIX-like
 access across all major operating systems to many common system tasks, such
 as interacting with the filesystem, sockets, timers, and system events. libuv
-also provides a pthreads-like threading abstraction that may be used to
-power more sophisticated asynchronous addons that need to move beyond the
-standard event loop. Addon authors are encouraged to think about how to
+also provides a threading abstraction similar to POSIX threads for
+more sophisticated asynchronous addons that need to move beyond the
+standard event loop. Addon authors should
 avoid blocking the event loop with I/O or other time-intensive tasks by
-off-loading work via libuv to non-blocking system operations, worker threads
-or a custom use of libuv's threads.</p>
+offloading work via libuv to non-blocking system operations, worker threads,
+or a custom use of libuv threads.</p>
 </li>
 <li>
 <p>Internal Node.js libraries. Node.js itself exports C++ APIs that addons can
@@ -207,41 +220,40 @@ re-exported by Node.js and may be used to various extents by addons. See
 </ul>
 <p>All of the following examples are available for <a href="https://github.com/nodejs/node-addon-examples">download</a> and may
 be used as the starting-point for an addon.</p>
-<h2>Hello world<span><a class="mark" href="#addons_hello_world" id="addons_hello_world">#</a></span></h2>
+<section><h3>Hello world<span><a class="mark" href="#addons_hello_world" id="addons_hello_world">#</a></span></h3>
 <p>This "Hello world" example is a simple addon, written in C++, that is the
 equivalent of the following JavaScript code:</p>
-<pre><code class="language-js"><span class="hljs-built_in">module</span>.exports.hello = <span class="hljs-function">() =></span> <span class="hljs-string">'world'</span>;</code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-property">hello</span> = <span class="hljs-function">() =></span> <span class="hljs-string">'world'</span>;</code></pre>
 <p>First, create the file <code>hello.cc</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// hello.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
 <span class="hljs-keyword">using</span> v8::FunctionCallbackInfo;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Method</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  args.GetReturnValue().Set(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"world"</span>, NewStringType::kNormal).ToLocalChecked());
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Method</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(
+      isolate, <span class="hljs-string">"world"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Initialize</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  NODE_SET_METHOD(exports, <span class="hljs-string">"hello"</span>, Method);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Initialize</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(exports, <span class="hljs-string">"hello"</span>, Method);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Initialize)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>All Node.js addons must export an initialization function following
 the pattern:</p>
-<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Initialize</span><span class="hljs-params">(Local&#x3C;Object> exports)</span></span>;
-NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)</code></pre>
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Initialize</span><span class="hljs-params">(Local&#x3C;Object> exports)</span></span>;
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Initialize)</code></pre>
 <p>There is no semi-colon after <code>NODE_MODULE</code> as it's not a function (see
 <code>node.h</code>).</p>
 <p>The <code>module_name</code> must match the filename of the final binary (excluding
@@ -251,20 +263,20 @@ and the addon module name is <code>addon</code>.</p>
 <p>When building addons with <code>node-gyp</code>, using the macro <code>NODE_GYP_MODULE_NAME</code> as
 the first parameter of <code>NODE_MODULE()</code> will ensure that the name of the final
 binary will be passed to <code>NODE_MODULE()</code>.</p>
-<h3>Context-aware addons<span><a class="mark" href="#addons_context_aware_addons" id="addons_context_aware_addons">#</a></span></h3>
+<h4>Context-aware addons<span><a class="mark" href="#addons_context_aware_addons" id="addons_context_aware_addons">#</a></span></h4>
 <p>There are environments in which Node.js addons may need to be loaded multiple
 times in multiple contexts. For example, the <a href="https://electronjs.org/">Electron</a> runtime runs multiple
 instances of Node.js in a single process. Each instance will have its own
 <code>require()</code> cache, and thus each instance will need a native addon to behave
-correctly when loaded via <code>require()</code>. From the addon's perspective, this means
-that it must support multiple initializations.</p>
+correctly when loaded via <code>require()</code>. This means that the addon
+must support multiple initializations.</p>
 <p>A context-aware addon can be constructed by using the macro
 <code>NODE_MODULE_INITIALIZER</code>, which expands to the name of a function which Node.js
 will expect to find when it loads an addon. An addon can thus be initialized as
 in the following example:</p>
 <pre><code class="language-cpp"><span class="hljs-keyword">using</span> <span class="hljs-keyword">namespace</span> v8;
 
-<span class="hljs-keyword">extern</span> <span class="hljs-string">"C"</span> <span class="hljs-function">NODE_MODULE_EXPORT <span class="hljs-keyword">void</span>
+<span class="hljs-keyword">extern</span> <span class="hljs-string">"C"</span> <span class="hljs-function">NODE_MODULE_EXPORT <span class="hljs-type">void</span>
 <span class="hljs-title">NODE_MODULE_INITIALIZER</span><span class="hljs-params">(Local&#x3C;Object> exports,
                         Local&#x3C;Value> <span class="hljs-keyword">module</span>,
                         Local&#x3C;Context> context)</span> </span>{
@@ -295,7 +307,7 @@ performing the following steps:</p>
 <ul>
 <li>Define a class which will hold per-addon-instance data and which has a static
 member of the form
-<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">DeleteInstance</span><span class="hljs-params">(<span class="hljs-keyword">void</span>* data)</span> </span>{
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">DeleteInstance</span><span class="hljs-params">(<span class="hljs-type">void</span>* data)</span> </span>{
   <span class="hljs-comment">// Cast `data` to an instance of the class and delete it.</span>
 }</code></pre>
 </li>
@@ -316,61 +328,60 @@ native-backed JavaScript functions. The third parameter of
 be called from JavaScript. The per-addon-instance data must also be passed into
 any asynchronous callbacks the addon may create.</p>
 <p>The following example illustrates the implementation of a context-aware addon:</p>
-<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">using</span> <span class="hljs-keyword">namespace</span> v8;
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">AddonData</span> {</span>
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">AddonData</span> {
  <span class="hljs-keyword">public</span>:
   <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">AddonData</span><span class="hljs-params">(Isolate* isolate)</span>:
-      <span class="hljs-title">call_count</span><span class="hljs-params">(<span class="hljs-number">0</span>)</span> </span>{
+      call_count(<span class="hljs-number">0</span>) {</span>
     <span class="hljs-comment">// Ensure this per-addon-instance data is deleted at environment cleanup.</span>
-    node::AddEnvironmentCleanupHook(isolate, DeleteInstance, <span class="hljs-keyword">this</span>);
+    node::<span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, DeleteInstance, <span class="hljs-keyword">this</span>);
   }
 
   <span class="hljs-comment">// Per-addon data.</span>
-  <span class="hljs-keyword">int</span> call_count;
+  <span class="hljs-type">int</span> call_count;
 
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">DeleteInstance</span><span class="hljs-params">(<span class="hljs-keyword">void</span>* data)</span> </span>{
-    <span class="hljs-keyword">delete</span> <span class="hljs-keyword">static_cast</span>&#x3C;AddonData*>(data);
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">DeleteInstance</span><span class="hljs-params">(<span class="hljs-type">void</span>* data)</span> </span>{
+    <span class="hljs-keyword">delete</span> <span class="hljs-built_in">static_cast</span>&#x3C;AddonData*>(data);
   }
 };
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Method</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; info)</span> </span>{
+<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">Method</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; info)</span> </span>{
   <span class="hljs-comment">// Retrieve the per-addon-instance data.</span>
   AddonData* data =
-      <span class="hljs-keyword">reinterpret_cast</span>&#x3C;AddonData*>(info.Data().As&#x3C;External>()->Value());
+      <span class="hljs-built_in">reinterpret_cast</span>&#x3C;AddonData*>(info.<span class="hljs-built_in">Data</span>().<span class="hljs-built_in">As</span>&#x3C;External>()-><span class="hljs-built_in">Value</span>());
   data->call_count++;
-  info.GetReturnValue().Set((<span class="hljs-keyword">double</span>)data->call_count);
+  info.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>((<span class="hljs-type">double</span>)data->call_count);
 }
 
 <span class="hljs-comment">// Initialize this addon to be context-aware.</span>
-NODE_MODULE_INIT(<span class="hljs-comment">/* exports, module, context */</span>) {
-  Isolate* isolate = context->GetIsolate();
+<span class="hljs-built_in">NODE_MODULE_INIT</span>(<span class="hljs-comment">/* exports, module, context */</span>) {
+  Isolate* isolate = context-><span class="hljs-built_in">GetIsolate</span>();
 
   <span class="hljs-comment">// Create a new instance of `AddonData` for this instance of the addon and</span>
   <span class="hljs-comment">// tie its life cycle to that of the Node.js environment.</span>
-  AddonData* data = <span class="hljs-keyword">new</span> AddonData(isolate);
+  AddonData* data = <span class="hljs-keyword">new</span> <span class="hljs-built_in">AddonData</span>(isolate);
 
   <span class="hljs-comment">// Wrap the data in a `v8::External` so we can pass it to the method we</span>
   <span class="hljs-comment">// expose.</span>
-  Local&#x3C;External> external = External::New(isolate, data);
+  Local&#x3C;External> external = External::<span class="hljs-built_in">New</span>(isolate, data);
 
   <span class="hljs-comment">// Expose the method `Method` to JavaScript, and make sure it receives the</span>
   <span class="hljs-comment">// per-addon-instance data we created above by passing `external` as the</span>
   <span class="hljs-comment">// third parameter to the `FunctionTemplate` constructor.</span>
-  exports->Set(context,
-               String::NewFromUtf8(isolate, <span class="hljs-string">"method"</span>, NewStringType::kNormal)
-                  .ToLocalChecked(),
-               FunctionTemplate::New(isolate, Method, external)
-                  ->GetFunction(context).ToLocalChecked()).FromJust();
+  exports-><span class="hljs-built_in">Set</span>(context,
+               String::<span class="hljs-built_in">NewFromUtf8</span>(isolate, <span class="hljs-string">"method"</span>).<span class="hljs-built_in">ToLocalChecked</span>(),
+               FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, Method, external)
+                  -><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>()).<span class="hljs-built_in">FromJust</span>();
 }</code></pre>
-<h4>Worker support<span><a class="mark" href="#addons_worker_support" id="addons_worker_support">#</a></span></h4>
+<h5>Worker support<span><a class="mark" href="#addons_worker_support" id="addons_worker_support">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.8.0</td>
 <td><p>Cleanup hooks may now be asynchronous.</p></td></tr>
 </tbody></table>
 </details>
@@ -378,15 +389,15 @@ NODE_MODULE_INIT(<span class="hljs-comment">/* exports, module, context */</span
 <p>In order to be loaded from multiple Node.js environments,
 such as a main thread and a Worker thread, an add-on needs to either:</p>
 <ul>
-<li>Be an N-API addon, or</li>
+<li>Be an Node-API addon, or</li>
 <li>Be declared as context-aware using <code>NODE_MODULE_INIT()</code> as described above</li>
 </ul>
 <p>In order to support <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads, addons need to clean up any resources
 they may have allocated when such a thread exists. This can be achieved through
 the usage of the <code>AddEnvironmentCleanupHook()</code> function:</p>
-<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">AddEnvironmentCleanupHook</span><span class="hljs-params">(v8::Isolate* isolate,
-                               <span class="hljs-keyword">void</span> (*fun)(<span class="hljs-keyword">void</span>* arg),
-                               <span class="hljs-keyword">void</span>* arg)</span></span>;</code></pre>
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">AddEnvironmentCleanupHook</span><span class="hljs-params">(v8::Isolate* isolate,
+                               <span class="hljs-type">void</span> (*fun)(<span class="hljs-type">void</span>* arg),
+                               <span class="hljs-type">void</span>* arg)</span></span>;</code></pre>
 <p>This function adds a hook that will run before a given Node.js instance shuts
 down. If necessary, such hooks can be removed before they are run using
 <code>RemoveEnvironmentCleanupHook()</code>, which has the same signature. Callbacks are
@@ -397,9 +408,9 @@ callback function. This can be used for shutting down asynchronous resources,
 such as any libuv handles registered by the addon.</p>
 <p>The following <code>addon.cc</code> uses <code>AddEnvironmentCleanupHook</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;assert.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;stdlib.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;assert.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;stdlib.h></span></span>
 
 <span class="hljs-keyword">using</span> node::AddEnvironmentCleanupHook;
 <span class="hljs-keyword">using</span> v8::HandleScope;
@@ -408,54 +419,54 @@ such as any libuv handles registered by the addon.</p>
 <span class="hljs-keyword">using</span> v8::Object;
 
 <span class="hljs-comment">// Note: In a real-world application, do not rely on static/global data.</span>
-<span class="hljs-keyword">static</span> <span class="hljs-keyword">char</span> cookie[] = <span class="hljs-string">"yum yum"</span>;
-<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> cleanup_cb1_called = <span class="hljs-number">0</span>;
-<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> cleanup_cb2_called = <span class="hljs-number">0</span>;
+<span class="hljs-keyword">static</span> <span class="hljs-type">char</span> cookie[] = <span class="hljs-string">"yum yum"</span>;
+<span class="hljs-keyword">static</span> <span class="hljs-type">int</span> cleanup_cb1_called = <span class="hljs-number">0</span>;
+<span class="hljs-keyword">static</span> <span class="hljs-type">int</span> cleanup_cb2_called = <span class="hljs-number">0</span>;
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">cleanup_cb1</span><span class="hljs-params">(<span class="hljs-keyword">void</span>* arg)</span> </span>{
-  Isolate* isolate = <span class="hljs-keyword">static_cast</span>&#x3C;Isolate*>(arg);
+<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">cleanup_cb1</span><span class="hljs-params">(<span class="hljs-type">void</span>* arg)</span> </span>{
+  Isolate* isolate = <span class="hljs-built_in">static_cast</span>&#x3C;Isolate*>(arg);
   <span class="hljs-function">HandleScope <span class="hljs-title">scope</span><span class="hljs-params">(isolate)</span></span>;
-  Local&#x3C;Object> obj = Object::New(isolate);
-  assert(!obj.IsEmpty());  <span class="hljs-comment">// assert VM is still alive</span>
-  assert(obj->IsObject());
+  Local&#x3C;Object> obj = Object::<span class="hljs-built_in">New</span>(isolate);
+  <span class="hljs-built_in">assert</span>(!obj.<span class="hljs-built_in">IsEmpty</span>());  <span class="hljs-comment">// assert VM is still alive</span>
+  <span class="hljs-built_in">assert</span>(obj-><span class="hljs-built_in">IsObject</span>());
   cleanup_cb1_called++;
 }
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">cleanup_cb2</span><span class="hljs-params">(<span class="hljs-keyword">void</span>* arg)</span> </span>{
-  assert(arg == <span class="hljs-keyword">static_cast</span>&#x3C;<span class="hljs-keyword">void</span>*>(cookie));
+<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">cleanup_cb2</span><span class="hljs-params">(<span class="hljs-type">void</span>* arg)</span> </span>{
+  <span class="hljs-built_in">assert</span>(arg == <span class="hljs-built_in">static_cast</span>&#x3C;<span class="hljs-type">void</span>*>(cookie));
   cleanup_cb2_called++;
 }
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">sanity_check</span><span class="hljs-params">(<span class="hljs-keyword">void</span>*)</span> </span>{
-  assert(cleanup_cb1_called == <span class="hljs-number">1</span>);
-  assert(cleanup_cb2_called == <span class="hljs-number">1</span>);
+<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">sanity_check</span><span class="hljs-params">(<span class="hljs-type">void</span>*)</span> </span>{
+  <span class="hljs-built_in">assert</span>(cleanup_cb1_called == <span class="hljs-number">1</span>);
+  <span class="hljs-built_in">assert</span>(cleanup_cb2_called == <span class="hljs-number">1</span>);
 }
 
 <span class="hljs-comment">// Initialize this addon to be context-aware.</span>
-NODE_MODULE_INIT(<span class="hljs-comment">/* exports, module, context */</span>) {
-  Isolate* isolate = context->GetIsolate();
+<span class="hljs-built_in">NODE_MODULE_INIT</span>(<span class="hljs-comment">/* exports, module, context */</span>) {
+  Isolate* isolate = context-><span class="hljs-built_in">GetIsolate</span>();
 
-  AddEnvironmentCleanupHook(isolate, sanity_check, <span class="hljs-literal">nullptr</span>);
-  AddEnvironmentCleanupHook(isolate, cleanup_cb2, cookie);
-  AddEnvironmentCleanupHook(isolate, cleanup_cb1, isolate);
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, sanity_check, <span class="hljs-literal">nullptr</span>);
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, cleanup_cb2, cookie);
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, cleanup_cb1, isolate);
 }</code></pre>
 <p>Test in JavaScript by running:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);</code></pre>
-<h3>Building<span><a class="mark" href="#addons_building" id="addons_building">#</a></span></h3>
+<h4>Building<span><a class="mark" href="#addons_building" id="addons_building">#</a></span></h4>
 <p>Once the source code has been written, it must be compiled into the binary
 <code>addon.node</code> file. To do so, create a file called <code>binding.gyp</code> in the
 top-level of the project describing the build configuration of the module
 using a JSON-like format. This file is used by <a href="https://github.com/nodejs/node-gyp">node-gyp</a>, a tool written
 specifically to compile Node.js addons.</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"targets"</span>: [
-    {
-      <span class="hljs-attr">"target_name"</span>: <span class="hljs-string">"addon"</span>,
-      <span class="hljs-attr">"sources"</span>: [ <span class="hljs-string">"hello.cc"</span> ]
-    }
-  ]
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"targets"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"target_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"addon"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span> <span class="hljs-string">"hello.cc"</span> <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>A version of the <code>node-gyp</code> utility is bundled and distributed with
 Node.js as part of <code>npm</code>. This version is not made directly available for
 developers to use and is intended only to support the ability to use the
@@ -477,7 +488,7 @@ compiled version of the addon for the user's platform on demand.</p>
 <pre><code class="language-js"><span class="hljs-comment">// hello.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-built_in">console</span>.log(addon.hello());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(addon.<span class="hljs-title function_">hello</span>());
 <span class="hljs-comment">// Prints: 'world'</span></code></pre>
 <p>Because the exact path to the compiled addon binary can vary depending on how
 it is compiled (i.e. sometimes it may be in <code>./build/Debug/</code>), addons can use
@@ -489,7 +500,7 @@ locates addon modules, it is essentially using a <code>try…catch</code> patter
 } <span class="hljs-keyword">catch</span> (err) {
   <span class="hljs-keyword">return</span> <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Debug/addon.node'</span>);
 }</code></pre>
-<h3>Linking to libraries included with Node.js<span><a class="mark" href="#addons_linking_to_libraries_included_with_node_js" id="addons_linking_to_libraries_included_with_node_js">#</a></span></h3>
+<h4>Linking to libraries included with Node.js<span><a class="mark" href="#addons_linking_to_libraries_included_with_node_js" id="addons_linking_to_libraries_included_with_node_js">#</a></span></h4>
 <p>Node.js uses statically linked libraries such as V8, libuv and OpenSSL. All
 addons are required to link to V8 and may link to any of the other dependencies
 as well. Typically, this is as simple as including the appropriate
@@ -501,8 +512,8 @@ aware of:</p>
 <p>When <code>node-gyp</code> runs, it will detect the specific release version of Node.js
 and download either the full source tarball or just the headers. If the full
 source is downloaded, addons will have complete access to the full set of
-Node.js dependencies. However, if only the Node.js headers are downloaded, then
-only the symbols exported by Node.js will be available.</p>
+Node.js dependencies. However, if only the Node.js headers are downloaded,
+then only the symbols exported by Node.js will be available.</p>
 </li>
 <li>
 <p><code>node-gyp</code> can be run using the <code>--nodedir</code> flag pointing at a local Node.js
@@ -510,7 +521,7 @@ source image. Using this option, the addon will have access to the full set of
 dependencies.</p>
 </li>
 </ul>
-<h3>Loading addons using <code>require()</code><span><a class="mark" href="#addons_loading_addons_using_require" id="addons_loading_addons_using_require">#</a></span></h3>
+<h4>Loading addons using <code>require()</code><span><a class="mark" href="#addons_loading_addons_using_require" id="addons_loading_addons_using_require">#</a></span></h4>
 <p>The filename extension of the compiled addon binary is <code>.node</code> (as opposed
 to <code>.dll</code> or <code>.so</code>). The <a href="modules.html#modules_require_id"><code>require()</code></a> function is written to look for
 files with the <code>.node</code> file extension and initialize those as dynamically-linked
@@ -522,7 +533,7 @@ JavaScript files that happen to share the same base name. For instance, if
 there is a file <code>addon.js</code> in the same directory as the binary <code>addon.node</code>,
 then <a href="modules.html#modules_require_id"><code>require('addon')</code></a> will give precedence to the <code>addon.js</code> file
 and load it instead.</p>
-<h2>Native abstractions for Node.js<span><a class="mark" href="#addons_native_abstractions_for_node_js" id="addons_native_abstractions_for_node_js">#</a></span></h2>
+</section><section><h3>Native abstractions for Node.js<span><a class="mark" href="#addons_native_abstractions_for_node_js" id="addons_native_abstractions_for_node_js">#</a></span></h3>
 <p>Each of the examples illustrated in this document directly use the
 Node.js and V8 APIs for implementing addons. The V8 API can, and has, changed
 dramatically from one V8 release to the next (and one major Node.js release to
@@ -532,11 +543,11 @@ minimize the frequency and impact of such changes but there is little that
 Node.js can do to ensure stability of the V8 APIs.</p>
 <p>The <a href="https://github.com/nodejs/nan">Native Abstractions for Node.js</a> (or <code>nan</code>) provide a set of tools that
 addon developers are recommended to use to keep compatibility between past and
-future releases of V8 and Node.js. See the <code>nan</code> <a href="https://github.com/nodejs/nan/tree/master/examples/">examples</a> for an
+future releases of V8 and Node.js. See the <code>nan</code> <a href="https://github.com/nodejs/nan/tree/HEAD/examples/">examples</a> for an
 illustration of how it can be used.</p>
-<h2>N-API<span><a class="mark" href="#addons_n_api" id="addons_n_api">#</a></span></h2>
+</section><section><h3>Node-API<span><a class="mark" href="#addons_node_api" id="addons_node_api">#</a></span></h3>
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p>N-API is an API for building native addons. It is independent from
+<p>Node-API is an API for building native addons. It is independent from
 the underlying JavaScript runtime (e.g. V8) and is maintained as part of
 Node.js itself. This API will be Application Binary Interface (ABI) stable
 across versions of Node.js. It is intended to insulate addons from
@@ -546,14 +557,14 @@ recompilation. Addons are built/packaged with the same approach/tools
 outlined in this document (node-gyp, etc.). The only difference is the
 set of APIs that are used by the native code. Instead of using the V8
 or <a href="https://github.com/nodejs/nan">Native Abstractions for Node.js</a> APIs, the functions available
-in the N-API are used.</p>
+in the Node-API are used.</p>
 <p>Creating and maintaining an addon that benefits from the ABI stability
-provided by N-API carries with it certain
+provided by Node-API carries with it certain
 <a href="n-api.html#n_api_implications_of_abi_stability">implementation considerations</a>.</p>
-<p>To use N-API in the above "Hello world" example, replace the content of
+<p>To use Node-API in the above "Hello world" example, replace the content of
 <code>hello.cc</code> with the following. All other instructions remain the same.</p>
-<pre><code class="language-cpp"><span class="hljs-comment">// hello.cc using N-API</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span>
+<pre><code class="language-cpp"><span class="hljs-comment">// hello.cc using Node-API</span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -561,7 +572,7 @@ provided by N-API carries with it certain
   napi_value greeting;
   napi_status status;
 
-  status = napi_create_string_utf8(env, <span class="hljs-string">"world"</span>, NAPI_AUTO_LENGTH, &#x26;greeting);
+  status = <span class="hljs-built_in">napi_create_string_utf8</span>(env, <span class="hljs-string">"world"</span>, NAPI_AUTO_LENGTH, &#x26;greeting);
   <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> <span class="hljs-literal">nullptr</span>;
   <span class="hljs-keyword">return</span> greeting;
 }
@@ -570,41 +581,41 @@ provided by N-API carries with it certain
   napi_status status;
   napi_value fn;
 
-  status = napi_create_function(env, <span class="hljs-literal">nullptr</span>, <span class="hljs-number">0</span>, Method, <span class="hljs-literal">nullptr</span>, &#x26;fn);
+  status = <span class="hljs-built_in">napi_create_function</span>(env, <span class="hljs-literal">nullptr</span>, <span class="hljs-number">0</span>, Method, <span class="hljs-literal">nullptr</span>, &#x26;fn);
   <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> <span class="hljs-literal">nullptr</span>;
 
-  status = napi_set_named_property(env, exports, <span class="hljs-string">"hello"</span>, fn);
+  status = <span class="hljs-built_in">napi_set_named_property</span>(env, exports, <span class="hljs-string">"hello"</span>, fn);
   <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> <span class="hljs-literal">nullptr</span>;
   <span class="hljs-keyword">return</span> exports;
 }
 
-NAPI_MODULE(NODE_GYP_MODULE_NAME, init)
+<span class="hljs-built_in">NAPI_MODULE</span>(NODE_GYP_MODULE_NAME, init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>The functions available and how to use them are documented in
-<a href="n-api.html">C/C++ addons with N-API</a>.</p>
-<h2>Addon examples<span><a class="mark" href="#addons_addon_examples" id="addons_addon_examples">#</a></span></h2>
+<a href="n-api.html">C/C++ addons with Node-API</a>.</p>
+</section><section><h3>Addon examples<span><a class="mark" href="#addons_addon_examples" id="addons_addon_examples">#</a></span></h3>
 <p>Following are some example addons intended to help developers get started. The
 examples use the V8 APIs. Refer to the online <a href="https://v8docs.nodesource.com/">V8 reference</a>
 for help with the various V8 calls, and V8's <a href="https://github.com/v8/v8/wiki/Embedder&#x27;s%20Guide">Embedder's Guide</a> for an
 explanation of several concepts used such as handles, scopes, function
 templates, etc.</p>
 <p>Each of these examples using the following <code>binding.gyp</code> file:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"targets"</span>: [
-    {
-      <span class="hljs-attr">"target_name"</span>: <span class="hljs-string">"addon"</span>,
-      <span class="hljs-attr">"sources"</span>: [ <span class="hljs-string">"addon.cc"</span> ]
-    }
-  ]
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"targets"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"target_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"addon"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span> <span class="hljs-string">"addon.cc"</span> <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>In cases where there is more than one <code>.cc</code> file, simply add the additional
 filename to the <code>sources</code> array:</p>
-<pre><code class="language-json">"sources": ["addon.cc", "myexample.cc"]</code></pre>
+<pre><code class="language-json"><span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span><span class="hljs-string">"addon.cc"</span><span class="hljs-punctuation">,</span> <span class="hljs-string">"myexample.cc"</span><span class="hljs-punctuation">]</span></code></pre>
 <p>Once the <code>binding.gyp</code> file is ready, the example addons can be configured and
 built using <code>node-gyp</code>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node-gyp configure build</span></code></pre>
-<h3>Function arguments<span><a class="mark" href="#addons_function_arguments" id="addons_function_arguments">#</a></span></h3>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node-gyp configure build</span></code></pre>
+<h4>Function arguments<span><a class="mark" href="#addons_function_arguments" id="addons_function_arguments">#</a></span></h4>
 <p>Addons will typically expose objects and functions that can be accessed from
 JavaScript running within Node.js. When functions are invoked from JavaScript,
 the input arguments and return value must be mapped to and from the C/C++
@@ -612,7 +623,7 @@ code.</p>
 <p>The following example illustrates how to read function arguments passed from
 JavaScript and how to return a result:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -620,7 +631,6 @@ JavaScript and how to return a result:</p>
 <span class="hljs-keyword">using</span> v8::FunctionCallbackInfo;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Number;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
@@ -629,56 +639,54 @@ JavaScript and how to return a result:</p>
 <span class="hljs-comment">// This is the implementation of the "add" method</span>
 <span class="hljs-comment">// Input arguments are passed using the</span>
 <span class="hljs-comment">// const FunctionCallbackInfo&#x3C;Value>&#x26; args struct</span>
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Add</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Add</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
   <span class="hljs-comment">// Check the number of arguments passed.</span>
-  <span class="hljs-keyword">if</span> (args.Length() &#x3C; <span class="hljs-number">2</span>) {
+  <span class="hljs-keyword">if</span> (args.<span class="hljs-built_in">Length</span>() &#x3C; <span class="hljs-number">2</span>) {
     <span class="hljs-comment">// Throw an Error that is passed back to JavaScript</span>
-    isolate->ThrowException(Exception::TypeError(
-        String::NewFromUtf8(isolate,
-                            <span class="hljs-string">"Wrong number of arguments"</span>,
-                            NewStringType::kNormal).ToLocalChecked()));
+    isolate-><span class="hljs-built_in">ThrowException</span>(Exception::<span class="hljs-built_in">TypeError</span>(
+        String::<span class="hljs-built_in">NewFromUtf8</span>(isolate,
+                            <span class="hljs-string">"Wrong number of arguments"</span>).<span class="hljs-built_in">ToLocalChecked</span>()));
     <span class="hljs-keyword">return</span>;
   }
 
   <span class="hljs-comment">// Check the argument types</span>
-  <span class="hljs-keyword">if</span> (!args[<span class="hljs-number">0</span>]->IsNumber() || !args[<span class="hljs-number">1</span>]->IsNumber()) {
-    isolate->ThrowException(Exception::TypeError(
-        String::NewFromUtf8(isolate,
-                            <span class="hljs-string">"Wrong arguments"</span>,
-                            NewStringType::kNormal).ToLocalChecked()));
+  <span class="hljs-keyword">if</span> (!args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">IsNumber</span>() || !args[<span class="hljs-number">1</span>]-><span class="hljs-built_in">IsNumber</span>()) {
+    isolate-><span class="hljs-built_in">ThrowException</span>(Exception::<span class="hljs-built_in">TypeError</span>(
+        String::<span class="hljs-built_in">NewFromUtf8</span>(isolate,
+                            <span class="hljs-string">"Wrong arguments"</span>).<span class="hljs-built_in">ToLocalChecked</span>()));
     <span class="hljs-keyword">return</span>;
   }
 
   <span class="hljs-comment">// Perform the operation</span>
-  <span class="hljs-keyword">double</span> value =
-      args[<span class="hljs-number">0</span>].As&#x3C;Number>()->Value() + args[<span class="hljs-number">1</span>].As&#x3C;Number>()->Value();
-  Local&#x3C;Number> num = Number::New(isolate, value);
+  <span class="hljs-type">double</span> value =
+      args[<span class="hljs-number">0</span>].<span class="hljs-built_in">As</span>&#x3C;Number>()-><span class="hljs-built_in">Value</span>() + args[<span class="hljs-number">1</span>].<span class="hljs-built_in">As</span>&#x3C;Number>()-><span class="hljs-built_in">Value</span>();
+  Local&#x3C;Number> num = Number::<span class="hljs-built_in">New</span>(isolate, value);
 
   <span class="hljs-comment">// Set the return value (using the passed in</span>
   <span class="hljs-comment">// FunctionCallbackInfo&#x3C;Value>&#x26;)</span>
-  args.GetReturnValue().Set(num);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(num);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  NODE_SET_METHOD(exports, <span class="hljs-string">"add"</span>, Add);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(exports, <span class="hljs-string">"add"</span>, Add);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>Once compiled, the example addon can be required and used from within Node.js:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This should be eight:'</span>, addon.add(<span class="hljs-number">3</span>, <span class="hljs-number">5</span>));</code></pre>
-<h3>Callbacks<span><a class="mark" href="#addons_callbacks" id="addons_callbacks">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This should be eight:'</span>, addon.<span class="hljs-title function_">add</span>(<span class="hljs-number">3</span>, <span class="hljs-number">5</span>));</code></pre>
+<h4>Callbacks<span><a class="mark" href="#addons_callbacks" id="addons_callbacks">#</a></span></h4>
 <p>It is common practice within addons to pass JavaScript functions to a C++
 function and execute them from there. The following example illustrates how
 to invoke such callbacks:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -687,29 +695,27 @@ to invoke such callbacks:</p>
 <span class="hljs-keyword">using</span> v8::FunctionCallbackInfo;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Null;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">RunCallback</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
-  Local&#x3C;Function> cb = Local&#x3C;Function>::Cast(args[<span class="hljs-number">0</span>]);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">RunCallback</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
+  Local&#x3C;Function> cb = Local&#x3C;Function>::<span class="hljs-built_in">Cast</span>(args[<span class="hljs-number">0</span>]);
   <span class="hljs-keyword">const</span> <span class="hljs-keyword">unsigned</span> argc = <span class="hljs-number">1</span>;
   Local&#x3C;Value> argv[argc] = {
-      String::NewFromUtf8(isolate,
-                          <span class="hljs-string">"hello world"</span>,
-                          NewStringType::kNormal).ToLocalChecked() };
-  cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();
+      String::<span class="hljs-built_in">NewFromUtf8</span>(isolate,
+                          <span class="hljs-string">"hello world"</span>).<span class="hljs-built_in">ToLocalChecked</span>() };
+  cb-><span class="hljs-built_in">Call</span>(context, <span class="hljs-built_in">Null</span>(isolate), argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
-  NODE_SET_METHOD(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, RunCallback);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, RunCallback);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>This example uses a two-argument form of <code>Init()</code> that receives the full
@@ -720,17 +726,17 @@ property of <code>exports</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-addon(<span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(msg);
+<span class="hljs-title function_">addon</span>(<span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(msg);
 <span class="hljs-comment">// Prints: 'hello world'</span>
 });</code></pre>
 <p>In this example, the callback function is invoked synchronously.</p>
-<h3>Object factory<span><a class="mark" href="#addons_object_factory" id="addons_object_factory">#</a></span></h3>
+<h4>Object factory<span><a class="mark" href="#addons_object_factory" id="addons_object_factory">#</a></span></h4>
 <p>Addons can create and return new objects from within a C++ function as
 illustrated in the following example. An object is created and returned with a
 property <code>msg</code> that echoes the string passed to <code>createObject()</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -738,46 +744,44 @@ property <code>msg</code> that echoes the string passed to <code>createObject()<
 <span class="hljs-keyword">using</span> v8::FunctionCallbackInfo;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  Local&#x3C;Object> obj = Object::New(isolate);
-  obj->Set(context,
-           String::NewFromUtf8(isolate,
-                               <span class="hljs-string">"msg"</span>,
-                               NewStringType::kNormal).ToLocalChecked(),
-                               args[<span class="hljs-number">0</span>]->ToString(context).ToLocalChecked())
-           .FromJust();
+  Local&#x3C;Object> obj = Object::<span class="hljs-built_in">New</span>(isolate);
+  obj-><span class="hljs-built_in">Set</span>(context,
+           String::<span class="hljs-built_in">NewFromUtf8</span>(isolate,
+                               <span class="hljs-string">"msg"</span>).<span class="hljs-built_in">ToLocalChecked</span>(),
+                               args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">ToString</span>(context).<span class="hljs-built_in">ToLocalChecked</span>())
+           .<span class="hljs-built_in">FromJust</span>();
 
-  args.GetReturnValue().Set(obj);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(obj);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
-  NODE_SET_METHOD(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateObject);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateObject);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>To test it in JavaScript:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> obj1 = addon(<span class="hljs-string">'hello'</span>);
-<span class="hljs-keyword">const</span> obj2 = addon(<span class="hljs-string">'world'</span>);
-<span class="hljs-built_in">console</span>.log(obj1.msg, obj2.msg);
+<span class="hljs-keyword">const</span> obj1 = <span class="hljs-title function_">addon</span>(<span class="hljs-string">'hello'</span>);
+<span class="hljs-keyword">const</span> obj2 = <span class="hljs-title function_">addon</span>(<span class="hljs-string">'world'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj1.<span class="hljs-property">msg</span>, obj2.<span class="hljs-property">msg</span>);
 <span class="hljs-comment">// Prints: 'hello world'</span></code></pre>
-<h3>Function factory<span><a class="mark" href="#addons_function_factory" id="addons_function_factory">#</a></span></h3>
+<h4>Function factory<span><a class="mark" href="#addons_function_factory" id="addons_function_factory">#</a></span></h4>
 <p>Another common scenario is creating JavaScript functions that wrap C++
 functions and returning those back to JavaScript:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -787,96 +791,95 @@ functions and returning those back to JavaScript:</p>
 <span class="hljs-keyword">using</span> v8::FunctionTemplate;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyFunction</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  args.GetReturnValue().Set(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"hello world"</span>, NewStringType::kNormal).ToLocalChecked());
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyFunction</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(
+      isolate, <span class="hljs-string">"hello world"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">CreateFunction</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">CreateFunction</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
-  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, MyFunction);
-  Local&#x3C;Function> fn = tpl->GetFunction(context).ToLocalChecked();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
+  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, MyFunction);
+  Local&#x3C;Function> fn = tpl-><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>();
 
   <span class="hljs-comment">// omit this to make it anonymous</span>
-  fn->SetName(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"theFunction"</span>, NewStringType::kNormal).ToLocalChecked());
+  fn-><span class="hljs-built_in">SetName</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(
+      isolate, <span class="hljs-string">"theFunction"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
 
-  args.GetReturnValue().Set(fn);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(fn);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
-  NODE_SET_METHOD(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateFunction);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateFunction);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>To test:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> fn = addon();
-<span class="hljs-built_in">console</span>.log(fn());
+<span class="hljs-keyword">const</span> fn = <span class="hljs-title function_">addon</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">fn</span>());
 <span class="hljs-comment">// Prints: 'hello world'</span></code></pre>
-<h3>Wrapping C++ objects<span><a class="mark" href="#addons_wrapping_c_objects" id="addons_wrapping_c_objects">#</a></span></h3>
+<h4>Wrapping C++ objects<span><a class="mark" href="#addons_wrapping_c_objects" id="addons_wrapping_c_objects">#</a></span></h4>
 <p>It is also possible to wrap C++ objects/classes in a way that allows new
 instances to be created using the JavaScript <code>new</code> operator:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
 <span class="hljs-keyword">using</span> v8::Local;
 <span class="hljs-keyword">using</span> v8::Object;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  MyObject::Init(exports);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  MyObject::<span class="hljs-built_in">Init</span>(exports);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, InitAll)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>Then, in <code>myobject.h</code>, the wrapper class inherits from <code>node::ObjectWrap</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.h</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">ifndef</span> MYOBJECT_H</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">ifndef</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> MYOBJECT_H</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyObject</span> :</span> <span class="hljs-keyword">public</span> node::ObjectWrap {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyObject</span> : <span class="hljs-keyword">public</span> node::ObjectWrap {
  <span class="hljs-keyword">public</span>:
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Local&#x3C;v8::Object> exports)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Local&#x3C;v8::Object> exports)</span></span>;
 
  <span class="hljs-keyword">private</span>:
-  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-keyword">double</span> value = <span class="hljs-number">0</span>)</span></span>;
-  ~MyObject();
+  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-type">double</span> value = <span class="hljs-number">0</span>)</span></span>;
+  ~<span class="hljs-built_in">MyObject</span>();
 
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
 
-  <span class="hljs-keyword">double</span> value_;
+  <span class="hljs-type">double</span> value_;
 };
 
 }  <span class="hljs-comment">// namespace demo</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">endif</span></span></code></pre>
+<span class="hljs-meta">#<span class="hljs-keyword">endif</span></span></code></pre>
 <p>In <code>myobject.cc</code>, implement the various methods that are to be exposed.
 Below, the method <code>plusOne()</code> is exposed by adding it to the constructor's
 prototype:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -886,100 +889,98 @@ prototype:</p>
 <span class="hljs-keyword">using</span> v8::FunctionTemplate;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Number;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::ObjectTemplate;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-MyObject::MyObject(<span class="hljs-keyword">double</span> value) : value_(value) {
+MyObject::<span class="hljs-built_in">MyObject</span>(<span class="hljs-type">double</span> value) : <span class="hljs-built_in">value_</span>(value) {
 }
 
-MyObject::~MyObject() {
+MyObject::~<span class="hljs-built_in">MyObject</span>() {
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  Isolate* isolate = exports->GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  Isolate* isolate = exports-><span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  Local&#x3C;ObjectTemplate> addon_data_tpl = ObjectTemplate::New(isolate);
-  addon_data_tpl->SetInternalFieldCount(<span class="hljs-number">1</span>);  <span class="hljs-comment">// 1 field for the MyObject::New()</span>
+  Local&#x3C;ObjectTemplate> addon_data_tpl = ObjectTemplate::<span class="hljs-built_in">New</span>(isolate);
+  addon_data_tpl-><span class="hljs-built_in">SetInternalFieldCount</span>(<span class="hljs-number">1</span>);  <span class="hljs-comment">// 1 field for the MyObject::New()</span>
   Local&#x3C;Object> addon_data =
-      addon_data_tpl->NewInstance(context).ToLocalChecked();
+      addon_data_tpl-><span class="hljs-built_in">NewInstance</span>(context).<span class="hljs-built_in">ToLocalChecked</span>();
 
   <span class="hljs-comment">// Prepare constructor template</span>
-  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"MyObject"</span>, NewStringType::kNormal).ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(<span class="hljs-number">1</span>);
+  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, New, addon_data);
+  tpl-><span class="hljs-built_in">SetClassName</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(isolate, <span class="hljs-string">"MyObject"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
+  tpl-><span class="hljs-built_in">InstanceTemplate</span>()-><span class="hljs-built_in">SetInternalFieldCount</span>(<span class="hljs-number">1</span>);
 
   <span class="hljs-comment">// Prototype</span>
-  NODE_SET_PROTOTYPE_METHOD(tpl, <span class="hljs-string">"plusOne"</span>, PlusOne);
+  <span class="hljs-built_in">NODE_SET_PROTOTYPE_METHOD</span>(tpl, <span class="hljs-string">"plusOne"</span>, PlusOne);
 
-  Local&#x3C;Function> constructor = tpl->GetFunction(context).ToLocalChecked();
-  addon_data->SetInternalField(<span class="hljs-number">0</span>, constructor);
-  exports->Set(context, String::NewFromUtf8(
-      isolate, <span class="hljs-string">"MyObject"</span>, NewStringType::kNormal).ToLocalChecked(),
-               constructor).FromJust();
+  Local&#x3C;Function> constructor = tpl-><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>();
+  addon_data-><span class="hljs-built_in">SetInternalField</span>(<span class="hljs-number">0</span>, constructor);
+  exports-><span class="hljs-built_in">Set</span>(context, String::<span class="hljs-built_in">NewFromUtf8</span>(
+      isolate, <span class="hljs-string">"MyObject"</span>).<span class="hljs-built_in">ToLocalChecked</span>(),
+      constructor).<span class="hljs-built_in">FromJust</span>();
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  <span class="hljs-keyword">if</span> (args.IsConstructCall()) {
+  <span class="hljs-keyword">if</span> (args.<span class="hljs-built_in">IsConstructCall</span>()) {
     <span class="hljs-comment">// Invoked as constructor: `new MyObject(...)`</span>
-    <span class="hljs-keyword">double</span> value = args[<span class="hljs-number">0</span>]->IsUndefined() ?
-        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]->NumberValue(context).FromMaybe(<span class="hljs-number">0</span>);
-    MyObject* obj = <span class="hljs-keyword">new</span> MyObject(value);
-    obj->Wrap(args.This());
-    args.GetReturnValue().Set(args.This());
+    <span class="hljs-type">double</span> value = args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">IsUndefined</span>() ?
+        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">NumberValue</span>(context).<span class="hljs-built_in">FromMaybe</span>(<span class="hljs-number">0</span>);
+    MyObject* obj = <span class="hljs-keyword">new</span> <span class="hljs-built_in">MyObject</span>(value);
+    obj-><span class="hljs-built_in">Wrap</span>(args.<span class="hljs-built_in">This</span>());
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(args.<span class="hljs-built_in">This</span>());
   } <span class="hljs-keyword">else</span> {
     <span class="hljs-comment">// Invoked as plain function `MyObject(...)`, turn into construct call.</span>
-    <span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span> argc = <span class="hljs-number">1</span>;
+    <span class="hljs-keyword">const</span> <span class="hljs-type">int</span> argc = <span class="hljs-number">1</span>;
     Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
     Local&#x3C;Function> cons =
-        args.Data().As&#x3C;Object>()->GetInternalField(<span class="hljs-number">0</span>).As&#x3C;Function>();
+        args.<span class="hljs-built_in">Data</span>().<span class="hljs-built_in">As</span>&#x3C;Object>()-><span class="hljs-built_in">GetInternalField</span>(<span class="hljs-number">0</span>).<span class="hljs-built_in">As</span>&#x3C;Function>();
     Local&#x3C;Object> result =
-        cons->NewInstance(context, argc, argv).ToLocalChecked();
-    args.GetReturnValue().Set(result);
+        cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(result);
   }
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
-  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());
+  MyObject* obj = ObjectWrap::<span class="hljs-built_in">Unwrap</span>&#x3C;MyObject>(args.<span class="hljs-built_in">Holder</span>());
   obj->value_ += <span class="hljs-number">1</span>;
 
-  args.GetReturnValue().Set(Number::New(isolate, obj->value_));
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(Number::<span class="hljs-built_in">New</span>(isolate, obj->value_));
 }
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>To build this example, the <code>myobject.cc</code> file must be added to the
 <code>binding.gyp</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"targets"</span>: [
-    {
-      <span class="hljs-attr">"target_name"</span>: <span class="hljs-string">"addon"</span>,
-      <span class="hljs-attr">"sources"</span>: [
-        <span class="hljs-string">"addon.cc"</span>,
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"targets"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"target_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"addon"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+        <span class="hljs-string">"addon.cc"</span><span class="hljs-punctuation">,</span>
         <span class="hljs-string">"myobject.cc"</span>
-      ]
-    }
-  ]
-}</code></pre>
+      <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Test it with:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> obj = <span class="hljs-keyword">new</span> addon.MyObject(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-keyword">const</span> obj = <span class="hljs-keyword">new</span> addon.<span class="hljs-title class_">MyObject</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 11</span>
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 12</span>
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 13</span></code></pre>
 <p>The destructor for a wrapper object will run when the object is
 garbage-collected. For destructor testing, there are command-line flags that
@@ -987,16 +988,16 @@ can be used to make it possible to force garbage collection. These flags are
 provided by the underlying V8 JavaScript engine. They are subject to change
 or removal at any time. They are not documented by Node.js or V8, and they
 should never be used outside of testing.</p>
-<h3>Factory of wrapped objects<span><a class="mark" href="#addons_factory_of_wrapped_objects" id="addons_factory_of_wrapped_objects">#</a></span></h3>
+<h4>Factory of wrapped objects<span><a class="mark" href="#addons_factory_of_wrapped_objects" id="addons_factory_of_wrapped_objects">#</a></span></h4>
 <p>Alternatively, it is possible to use a factory pattern to avoid explicitly
 creating object instances using the JavaScript <code>new</code> operator:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> obj = addon.createObject();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> obj = addon.<span class="hljs-title function_">createObject</span>();
 <span class="hljs-comment">// instead of:</span>
 <span class="hljs-comment">// const obj = new addon.Object();</span></code></pre>
 <p>First, the <code>createObject()</code> method is implemented in <code>addon.cc</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -1007,53 +1008,53 @@ creating object instances using the JavaScript <code>new</code> operator:</p>
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  MyObject::NewInstance(args);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  MyObject::<span class="hljs-built_in">NewInstance</span>(args);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
-  MyObject::Init(exports->GetIsolate());
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
+  MyObject::<span class="hljs-built_in">Init</span>(exports-><span class="hljs-built_in">GetIsolate</span>());
 
-  NODE_SET_METHOD(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateObject);
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateObject);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, InitAll)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>In <code>myobject.h</code>, the static method <code>NewInstance()</code> is added to handle
 instantiating the object. This method takes the place of using <code>new</code> in
 JavaScript:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.h</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">ifndef</span> MYOBJECT_H</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">ifndef</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> MYOBJECT_H</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyObject</span> :</span> <span class="hljs-keyword">public</span> node::ObjectWrap {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyObject</span> : <span class="hljs-keyword">public</span> node::ObjectWrap {
  <span class="hljs-keyword">public</span>:
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Isolate* isolate)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Isolate* isolate)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
 
  <span class="hljs-keyword">private</span>:
-  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-keyword">double</span> value = <span class="hljs-number">0</span>)</span></span>;
-  ~MyObject();
+  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-type">double</span> value = <span class="hljs-number">0</span>)</span></span>;
+  ~<span class="hljs-built_in">MyObject</span>();
 
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
   <span class="hljs-keyword">static</span> v8::Global&#x3C;v8::Function> constructor;
-  <span class="hljs-keyword">double</span> value_;
+  <span class="hljs-type">double</span> value_;
 };
 
 }  <span class="hljs-comment">// namespace demo</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">endif</span></span></code></pre>
+<span class="hljs-meta">#<span class="hljs-keyword">endif</span></span></code></pre>
 <p>The implementation in <code>myobject.cc</code> is similar to the previous example:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -1065,7 +1066,6 @@ JavaScript:</p>
 <span class="hljs-keyword">using</span> v8::Global;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Number;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
@@ -1075,116 +1075,115 @@ JavaScript:</p>
 <span class="hljs-comment">// threads.</span>
 Global&#x3C;Function> MyObject::constructor;
 
-MyObject::MyObject(<span class="hljs-keyword">double</span> value) : value_(value) {
+MyObject::<span class="hljs-built_in">MyObject</span>(<span class="hljs-type">double</span> value) : <span class="hljs-built_in">value_</span>(value) {
 }
 
-MyObject::~MyObject() {
+MyObject::~<span class="hljs-built_in">MyObject</span>() {
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Isolate* isolate)</span> </span>{
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Isolate* isolate)</span> </span>{
   <span class="hljs-comment">// Prepare constructor template</span>
-  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"MyObject"</span>, NewStringType::kNormal).ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(<span class="hljs-number">1</span>);
+  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, New);
+  tpl-><span class="hljs-built_in">SetClassName</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(isolate, <span class="hljs-string">"MyObject"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
+  tpl-><span class="hljs-built_in">InstanceTemplate</span>()-><span class="hljs-built_in">SetInternalFieldCount</span>(<span class="hljs-number">1</span>);
 
   <span class="hljs-comment">// Prototype</span>
-  NODE_SET_PROTOTYPE_METHOD(tpl, <span class="hljs-string">"plusOne"</span>, PlusOne);
+  <span class="hljs-built_in">NODE_SET_PROTOTYPE_METHOD</span>(tpl, <span class="hljs-string">"plusOne"</span>, PlusOne);
 
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
-  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
+  constructor.<span class="hljs-built_in">Reset</span>(isolate, tpl-><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>());
 
-  AddEnvironmentCleanupHook(isolate, [](<span class="hljs-keyword">void</span>*) {
-    constructor.Reset();
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, [](<span class="hljs-type">void</span>*) {
+    constructor.<span class="hljs-built_in">Reset</span>();
   }, <span class="hljs-literal">nullptr</span>);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  <span class="hljs-keyword">if</span> (args.IsConstructCall()) {
+  <span class="hljs-keyword">if</span> (args.<span class="hljs-built_in">IsConstructCall</span>()) {
     <span class="hljs-comment">// Invoked as constructor: `new MyObject(...)`</span>
-    <span class="hljs-keyword">double</span> value = args[<span class="hljs-number">0</span>]->IsUndefined() ?
-        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]->NumberValue(context).FromMaybe(<span class="hljs-number">0</span>);
-    MyObject* obj = <span class="hljs-keyword">new</span> MyObject(value);
-    obj->Wrap(args.This());
-    args.GetReturnValue().Set(args.This());
+    <span class="hljs-type">double</span> value = args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">IsUndefined</span>() ?
+        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">NumberValue</span>(context).<span class="hljs-built_in">FromMaybe</span>(<span class="hljs-number">0</span>);
+    MyObject* obj = <span class="hljs-keyword">new</span> <span class="hljs-built_in">MyObject</span>(value);
+    obj-><span class="hljs-built_in">Wrap</span>(args.<span class="hljs-built_in">This</span>());
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(args.<span class="hljs-built_in">This</span>());
   } <span class="hljs-keyword">else</span> {
     <span class="hljs-comment">// Invoked as plain function `MyObject(...)`, turn into construct call.</span>
-    <span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span> argc = <span class="hljs-number">1</span>;
+    <span class="hljs-keyword">const</span> <span class="hljs-type">int</span> argc = <span class="hljs-number">1</span>;
     Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
-    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);
+    Local&#x3C;Function> cons = Local&#x3C;Function>::<span class="hljs-built_in">New</span>(isolate, constructor);
     Local&#x3C;Object> instance =
-        cons->NewInstance(context, argc, argv).ToLocalChecked();
-    args.GetReturnValue().Set(instance);
+        cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(instance);
   }
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
   <span class="hljs-keyword">const</span> <span class="hljs-keyword">unsigned</span> argc = <span class="hljs-number">1</span>;
   Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
-  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+  Local&#x3C;Function> cons = Local&#x3C;Function>::<span class="hljs-built_in">New</span>(isolate, constructor);
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
   Local&#x3C;Object> instance =
-      cons->NewInstance(context, argc, argv).ToLocalChecked();
+      cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
 
-  args.GetReturnValue().Set(instance);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(instance);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
-  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());
+  MyObject* obj = ObjectWrap::<span class="hljs-built_in">Unwrap</span>&#x3C;MyObject>(args.<span class="hljs-built_in">Holder</span>());
   obj->value_ += <span class="hljs-number">1</span>;
 
-  args.GetReturnValue().Set(Number::New(isolate, obj->value_));
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(Number::<span class="hljs-built_in">New</span>(isolate, obj->value_));
 }
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>Once again, to build this example, the <code>myobject.cc</code> file must be added to the
 <code>binding.gyp</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"targets"</span>: [
-    {
-      <span class="hljs-attr">"target_name"</span>: <span class="hljs-string">"addon"</span>,
-      <span class="hljs-attr">"sources"</span>: [
-        <span class="hljs-string">"addon.cc"</span>,
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"targets"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"target_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"addon"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+        <span class="hljs-string">"addon.cc"</span><span class="hljs-punctuation">,</span>
         <span class="hljs-string">"myobject.cc"</span>
-      ]
-    }
-  ]
-}</code></pre>
+      <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Test it with:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> createObject = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> obj = createObject(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-keyword">const</span> obj = <span class="hljs-title function_">createObject</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 11</span>
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 12</span>
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 13</span>
 
-<span class="hljs-keyword">const</span> obj2 = createObject(<span class="hljs-number">20</span>);
-<span class="hljs-built_in">console</span>.log(obj2.plusOne());
+<span class="hljs-keyword">const</span> obj2 = <span class="hljs-title function_">createObject</span>(<span class="hljs-number">20</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj2.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 21</span>
-<span class="hljs-built_in">console</span>.log(obj2.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj2.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 22</span>
-<span class="hljs-built_in">console</span>.log(obj2.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj2.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 23</span></code></pre>
-<h3>Passing wrapped objects around<span><a class="mark" href="#addons_passing_wrapped_objects_around" id="addons_passing_wrapped_objects_around">#</a></span></h3>
+<h4>Passing wrapped objects around<span><a class="mark" href="#addons_passing_wrapped_objects_around" id="addons_passing_wrapped_objects_around">#</a></span></h4>
 <p>In addition to wrapping and returning C++ objects, it is possible to pass
 wrapped objects around by unwrapping them with the Node.js helper function
 <code>node::ObjectWrap::Unwrap</code>. The following examples shows a function <code>add()</code>
 that can take two <code>MyObject</code> objects as input arguments:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -1197,66 +1196,66 @@ that can take two <code>MyObject</code> objects as input arguments:</p>
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  MyObject::NewInstance(args);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  MyObject::<span class="hljs-built_in">NewInstance</span>(args);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Add</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Add</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  MyObject* obj1 = node::ObjectWrap::Unwrap&#x3C;MyObject>(
-      args[<span class="hljs-number">0</span>]->ToObject(context).ToLocalChecked());
-  MyObject* obj2 = node::ObjectWrap::Unwrap&#x3C;MyObject>(
-      args[<span class="hljs-number">1</span>]->ToObject(context).ToLocalChecked());
+  MyObject* obj1 = node::ObjectWrap::<span class="hljs-built_in">Unwrap</span>&#x3C;MyObject>(
+      args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">ToObject</span>(context).<span class="hljs-built_in">ToLocalChecked</span>());
+  MyObject* obj2 = node::ObjectWrap::<span class="hljs-built_in">Unwrap</span>&#x3C;MyObject>(
+      args[<span class="hljs-number">1</span>]-><span class="hljs-built_in">ToObject</span>(context).<span class="hljs-built_in">ToLocalChecked</span>());
 
-  <span class="hljs-keyword">double</span> sum = obj1->value() + obj2->value();
-  args.GetReturnValue().Set(Number::New(isolate, sum));
+  <span class="hljs-type">double</span> sum = obj1-><span class="hljs-built_in">value</span>() + obj2-><span class="hljs-built_in">value</span>();
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(Number::<span class="hljs-built_in">New</span>(isolate, sum));
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  MyObject::Init(exports->GetIsolate());
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  MyObject::<span class="hljs-built_in">Init</span>(exports-><span class="hljs-built_in">GetIsolate</span>());
 
-  NODE_SET_METHOD(exports, <span class="hljs-string">"createObject"</span>, CreateObject);
-  NODE_SET_METHOD(exports, <span class="hljs-string">"add"</span>, Add);
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(exports, <span class="hljs-string">"createObject"</span>, CreateObject);
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(exports, <span class="hljs-string">"add"</span>, Add);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, InitAll)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>In <code>myobject.h</code>, a new public method is added to allow access to private values
 after unwrapping the object.</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.h</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">ifndef</span> MYOBJECT_H</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">ifndef</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> MYOBJECT_H</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyObject</span> :</span> <span class="hljs-keyword">public</span> node::ObjectWrap {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyObject</span> : <span class="hljs-keyword">public</span> node::ObjectWrap {
  <span class="hljs-keyword">public</span>:
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Isolate* isolate)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">inline</span> <span class="hljs-keyword">double</span> <span class="hljs-title">value</span><span class="hljs-params">()</span> <span class="hljs-keyword">const</span> </span>{ <span class="hljs-keyword">return</span> value_; }
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Isolate* isolate)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">inline</span> <span class="hljs-type">double</span> <span class="hljs-title">value</span><span class="hljs-params">()</span> <span class="hljs-keyword">const</span> </span>{ <span class="hljs-keyword">return</span> value_; }
 
  <span class="hljs-keyword">private</span>:
-  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-keyword">double</span> value = <span class="hljs-number">0</span>)</span></span>;
-  ~MyObject();
+  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-type">double</span> value = <span class="hljs-number">0</span>)</span></span>;
+  ~<span class="hljs-built_in">MyObject</span>();
 
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
   <span class="hljs-keyword">static</span> v8::Global&#x3C;v8::Function> constructor;
-  <span class="hljs-keyword">double</span> value_;
+  <span class="hljs-type">double</span> value_;
 };
 
 }  <span class="hljs-comment">// namespace demo</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">endif</span></span></code></pre>
+<span class="hljs-meta">#<span class="hljs-keyword">endif</span></span></code></pre>
 <p>The implementation of <code>myobject.cc</code> is similar to before:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -1268,7 +1267,6 @@ after unwrapping the object.</p>
 <span class="hljs-keyword">using</span> v8::Global;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
@@ -1277,60 +1275,59 @@ after unwrapping the object.</p>
 <span class="hljs-comment">// threads.</span>
 Global&#x3C;Function> MyObject::constructor;
 
-MyObject::MyObject(<span class="hljs-keyword">double</span> value) : value_(value) {
+MyObject::<span class="hljs-built_in">MyObject</span>(<span class="hljs-type">double</span> value) : <span class="hljs-built_in">value_</span>(value) {
 }
 
-MyObject::~MyObject() {
+MyObject::~<span class="hljs-built_in">MyObject</span>() {
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Isolate* isolate)</span> </span>{
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Isolate* isolate)</span> </span>{
   <span class="hljs-comment">// Prepare constructor template</span>
-  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"MyObject"</span>, NewStringType::kNormal).ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(<span class="hljs-number">1</span>);
+  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, New);
+  tpl-><span class="hljs-built_in">SetClassName</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(isolate, <span class="hljs-string">"MyObject"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
+  tpl-><span class="hljs-built_in">InstanceTemplate</span>()-><span class="hljs-built_in">SetInternalFieldCount</span>(<span class="hljs-number">1</span>);
 
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
-  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
+  constructor.<span class="hljs-built_in">Reset</span>(isolate, tpl-><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>());
 
-  AddEnvironmentCleanupHook(isolate, [](<span class="hljs-keyword">void</span>*) {
-    constructor.Reset();
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, [](<span class="hljs-type">void</span>*) {
+    constructor.<span class="hljs-built_in">Reset</span>();
   }, <span class="hljs-literal">nullptr</span>);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  <span class="hljs-keyword">if</span> (args.IsConstructCall()) {
+  <span class="hljs-keyword">if</span> (args.<span class="hljs-built_in">IsConstructCall</span>()) {
     <span class="hljs-comment">// Invoked as constructor: `new MyObject(...)`</span>
-    <span class="hljs-keyword">double</span> value = args[<span class="hljs-number">0</span>]->IsUndefined() ?
-        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]->NumberValue(context).FromMaybe(<span class="hljs-number">0</span>);
-    MyObject* obj = <span class="hljs-keyword">new</span> MyObject(value);
-    obj->Wrap(args.This());
-    args.GetReturnValue().Set(args.This());
+    <span class="hljs-type">double</span> value = args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">IsUndefined</span>() ?
+        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">NumberValue</span>(context).<span class="hljs-built_in">FromMaybe</span>(<span class="hljs-number">0</span>);
+    MyObject* obj = <span class="hljs-keyword">new</span> <span class="hljs-built_in">MyObject</span>(value);
+    obj-><span class="hljs-built_in">Wrap</span>(args.<span class="hljs-built_in">This</span>());
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(args.<span class="hljs-built_in">This</span>());
   } <span class="hljs-keyword">else</span> {
     <span class="hljs-comment">// Invoked as plain function `MyObject(...)`, turn into construct call.</span>
-    <span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span> argc = <span class="hljs-number">1</span>;
+    <span class="hljs-keyword">const</span> <span class="hljs-type">int</span> argc = <span class="hljs-number">1</span>;
     Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
-    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);
+    Local&#x3C;Function> cons = Local&#x3C;Function>::<span class="hljs-built_in">New</span>(isolate, constructor);
     Local&#x3C;Object> instance =
-        cons->NewInstance(context, argc, argv).ToLocalChecked();
-    args.GetReturnValue().Set(instance);
+        cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(instance);
   }
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
   <span class="hljs-keyword">const</span> <span class="hljs-keyword">unsigned</span> argc = <span class="hljs-number">1</span>;
   Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
-  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+  Local&#x3C;Function> cons = Local&#x3C;Function>::<span class="hljs-built_in">New</span>(isolate, constructor);
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
   Local&#x3C;Object> instance =
-      cons->NewInstance(context, argc, argv).ToLocalChecked();
+      cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
 
-  args.GetReturnValue().Set(instance);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(instance);
 }
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
@@ -1338,15 +1335,51 @@ MyObject::~MyObject() {
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> obj1 = addon.createObject(<span class="hljs-number">10</span>);
-<span class="hljs-keyword">const</span> obj2 = addon.createObject(<span class="hljs-number">20</span>);
-<span class="hljs-keyword">const</span> result = addon.add(obj1, obj2);
+<span class="hljs-keyword">const</span> obj1 = addon.<span class="hljs-title function_">createObject</span>(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> obj2 = addon.<span class="hljs-title function_">createObject</span>(<span class="hljs-number">20</span>);
+<span class="hljs-keyword">const</span> result = addon.<span class="hljs-title function_">add</span>(obj1, obj2);
 
-<span class="hljs-built_in">console</span>.log(result);
-<span class="hljs-comment">// Prints: 30</span></code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result);
+<span class="hljs-comment">// Prints: 30</span></code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/addons.json b/doc/api/addons.json
index 12a6f6e724675af93d2f07aa5a7e21c260adcfc5..6f78b505e0e03503deb30e3bdf566dde1ff097fa 100644
--- a/doc/api/addons.json
+++ b/doc/api/addons.json
@@ -8,17 +8,17 @@
       "name": "C++ addons",
       "introduced_in": "v0.10.0",
       "type": "misc",
-      "desc": "<p><em>Addons</em> are dynamically-linked shared objects written in C++. The\n<a href=\"modules.html#modules_require_id\"><code>require()</code></a> function can load addons as ordinary Node.js modules.\nAddons provide an interface between JavaScript and C/C++ libraries.</p>\n<p>There are three options for implementing addons: N-API, nan, or direct\nuse of internal V8, libuv and Node.js libraries. Unless there is a need for\ndirect access to functionality which is not exposed by N-API, use N-API.\nRefer to <a href=\"n-api.html\">C/C++ addons with N-API</a> for more information on N-API.</p>\n<p>When not using N-API, implementing addons is complicated,\ninvolving knowledge of several components and APIs:</p>\n<ul>\n<li>\n<p>V8: the C++ library Node.js uses to provide the\nJavaScript implementation. V8 provides the mechanisms for creating objects,\ncalling functions, etc. V8's API is documented mostly in the\n<code>v8.h</code> header file (<code>deps/v8/include/v8.h</code> in the Node.js source\ntree), which is also available <a href=\"https://v8docs.nodesource.com/\">online</a>.</p>\n</li>\n<li>\n<p><a href=\"https://github.com/libuv/libuv\">libuv</a>: The C library that implements the Node.js event loop, its worker\nthreads and all of the asynchronous behaviors of the platform. It also\nserves as a cross-platform abstraction library, giving easy, POSIX-like\naccess across all major operating systems to many common system tasks, such\nas interacting with the filesystem, sockets, timers, and system events. libuv\nalso provides a pthreads-like threading abstraction that may be used to\npower more sophisticated asynchronous addons that need to move beyond the\nstandard event loop. Addon authors are encouraged to think about how to\navoid blocking the event loop with I/O or other time-intensive tasks by\noff-loading work via libuv to non-blocking system operations, worker threads\nor a custom use of libuv's threads.</p>\n</li>\n<li>\n<p>Internal Node.js libraries. Node.js itself exports C++ APIs that addons can\nuse, the most important of which is the <code>node::ObjectWrap</code> class.</p>\n</li>\n<li>\n<p>Node.js includes other statically linked libraries including OpenSSL. These\nother libraries are located in the <code>deps/</code> directory in the Node.js source\ntree. Only the libuv, OpenSSL, V8 and zlib symbols are purposefully\nre-exported by Node.js and may be used to various extents by addons. See\n<a href=\"#addons_linking_to_libraries_included_with_node_js\">Linking to libraries included with Node.js</a> for additional information.</p>\n</li>\n</ul>\n<p>All of the following examples are available for <a href=\"https://github.com/nodejs/node-addon-examples\">download</a> and may\nbe used as the starting-point for an addon.</p>",
+      "desc": "<p><em>Addons</em> are dynamically-linked shared objects written in C++. The\n<a href=\"modules.html#modules_require_id\"><code>require()</code></a> function can load addons as ordinary Node.js modules.\nAddons provide an interface between JavaScript and C/C++ libraries.</p>\n<p>There are three options for implementing addons: Node-API, nan, or direct\nuse of internal V8, libuv and Node.js libraries. Unless there is a need for\ndirect access to functionality which is not exposed by Node-API, use Node-API.\nRefer to <a href=\"n-api.html\">C/C++ addons with Node-API</a> for more information on\nNode-API.</p>\n<p>When not using Node-API, implementing addons is complicated,\ninvolving knowledge of several components and APIs:</p>\n<ul>\n<li>\n<p><a href=\"https://v8.dev/\">V8</a>: the C++ library Node.js uses to provide the\nJavaScript implementation. V8 provides the mechanisms for creating objects,\ncalling functions, etc. V8's API is documented mostly in the\n<code>v8.h</code> header file (<code>deps/v8/include/v8.h</code> in the Node.js source\ntree), which is also available <a href=\"https://v8docs.nodesource.com/\">online</a>.</p>\n</li>\n<li>\n<p><a href=\"https://github.com/libuv/libuv\">libuv</a>: The C library that implements the Node.js event loop, its worker\nthreads and all of the asynchronous behaviors of the platform. It also\nserves as a cross-platform abstraction library, giving easy, POSIX-like\naccess across all major operating systems to many common system tasks, such\nas interacting with the filesystem, sockets, timers, and system events. libuv\nalso provides a threading abstraction similar to POSIX threads for\nmore sophisticated asynchronous addons that need to move beyond the\nstandard event loop. Addon authors should\navoid blocking the event loop with I/O or other time-intensive tasks by\noffloading work via libuv to non-blocking system operations, worker threads,\nor a custom use of libuv threads.</p>\n</li>\n<li>\n<p>Internal Node.js libraries. Node.js itself exports C++ APIs that addons can\nuse, the most important of which is the <code>node::ObjectWrap</code> class.</p>\n</li>\n<li>\n<p>Node.js includes other statically linked libraries including OpenSSL. These\nother libraries are located in the <code>deps/</code> directory in the Node.js source\ntree. Only the libuv, OpenSSL, V8 and zlib symbols are purposefully\nre-exported by Node.js and may be used to various extents by addons. See\n<a href=\"#addons_linking_to_libraries_included_with_node_js\">Linking to libraries included with Node.js</a> for additional information.</p>\n</li>\n</ul>\n<p>All of the following examples are available for <a href=\"https://github.com/nodejs/node-addon-examples\">download</a> and may\nbe used as the starting-point for an addon.</p>",
       "miscs": [
         {
           "textRaw": "Hello world",
           "name": "hello_world",
-          "desc": "<p>This \"Hello world\" example is a simple addon, written in C++, that is the\nequivalent of the following JavaScript code:</p>\n<pre><code class=\"language-js\">module.exports.hello = () => 'world';\n</code></pre>\n<p>First, create the file <code>hello.cc</code>:</p>\n<pre><code class=\"language-cpp\">// hello.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid Method(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  args.GetReturnValue().Set(String::NewFromUtf8(\n      isolate, \"world\", NewStringType::kNormal).ToLocalChecked());\n}\n\nvoid Initialize(Local&#x3C;Object> exports) {\n  NODE_SET_METHOD(exports, \"hello\", Method);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)\n\n}  // namespace demo\n</code></pre>\n<p>All Node.js addons must export an initialization function following\nthe pattern:</p>\n<pre><code class=\"language-cpp\">void Initialize(Local&#x3C;Object> exports);\nNODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)\n</code></pre>\n<p>There is no semi-colon after <code>NODE_MODULE</code> as it's not a function (see\n<code>node.h</code>).</p>\n<p>The <code>module_name</code> must match the filename of the final binary (excluding\nthe <code>.node</code> suffix).</p>\n<p>In the <code>hello.cc</code> example, then, the initialization function is <code>Initialize</code>\nand the addon module name is <code>addon</code>.</p>\n<p>When building addons with <code>node-gyp</code>, using the macro <code>NODE_GYP_MODULE_NAME</code> as\nthe first parameter of <code>NODE_MODULE()</code> will ensure that the name of the final\nbinary will be passed to <code>NODE_MODULE()</code>.</p>",
+          "desc": "<p>This \"Hello world\" example is a simple addon, written in C++, that is the\nequivalent of the following JavaScript code:</p>\n<pre><code class=\"language-js\">module.exports.hello = () => 'world';\n</code></pre>\n<p>First, create the file <code>hello.cc</code>:</p>\n<pre><code class=\"language-cpp\">// hello.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid Method(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  args.GetReturnValue().Set(String::NewFromUtf8(\n      isolate, \"world\").ToLocalChecked());\n}\n\nvoid Initialize(Local&#x3C;Object> exports) {\n  NODE_SET_METHOD(exports, \"hello\", Method);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)\n\n}  // namespace demo\n</code></pre>\n<p>All Node.js addons must export an initialization function following\nthe pattern:</p>\n<pre><code class=\"language-cpp\">void Initialize(Local&#x3C;Object> exports);\nNODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)\n</code></pre>\n<p>There is no semi-colon after <code>NODE_MODULE</code> as it's not a function (see\n<code>node.h</code>).</p>\n<p>The <code>module_name</code> must match the filename of the final binary (excluding\nthe <code>.node</code> suffix).</p>\n<p>In the <code>hello.cc</code> example, then, the initialization function is <code>Initialize</code>\nand the addon module name is <code>addon</code>.</p>\n<p>When building addons with <code>node-gyp</code>, using the macro <code>NODE_GYP_MODULE_NAME</code> as\nthe first parameter of <code>NODE_MODULE()</code> will ensure that the name of the final\nbinary will be passed to <code>NODE_MODULE()</code>.</p>",
           "modules": [
             {
               "textRaw": "Context-aware addons",
               "name": "context-aware_addons",
-              "desc": "<p>There are environments in which Node.js addons may need to be loaded multiple\ntimes in multiple contexts. For example, the <a href=\"https://electronjs.org/\">Electron</a> runtime runs multiple\ninstances of Node.js in a single process. Each instance will have its own\n<code>require()</code> cache, and thus each instance will need a native addon to behave\ncorrectly when loaded via <code>require()</code>. From the addon's perspective, this means\nthat it must support multiple initializations.</p>\n<p>A context-aware addon can be constructed by using the macro\n<code>NODE_MODULE_INITIALIZER</code>, which expands to the name of a function which Node.js\nwill expect to find when it loads an addon. An addon can thus be initialized as\nin the following example:</p>\n<pre><code class=\"language-cpp\">using namespace v8;\n\nextern \"C\" NODE_MODULE_EXPORT void\nNODE_MODULE_INITIALIZER(Local&#x3C;Object> exports,\n                        Local&#x3C;Value> module,\n                        Local&#x3C;Context> context) {\n  /* Perform addon initialization steps here. */\n}\n</code></pre>\n<p>Another option is to use the macro <code>NODE_MODULE_INIT()</code>, which will also\nconstruct a context-aware addon. Unlike <code>NODE_MODULE()</code>, which is used to\nconstruct an addon around a given addon initializer function,\n<code>NODE_MODULE_INIT()</code> serves as the declaration of such an initializer to be\nfollowed by a function body.</p>\n<p>The following three variables may be used inside the function body following an\ninvocation of <code>NODE_MODULE_INIT()</code>:</p>\n<ul>\n<li><code>Local&#x3C;Object> exports</code>,</li>\n<li><code>Local&#x3C;Value> module</code>, and</li>\n<li><code>Local&#x3C;Context> context</code></li>\n</ul>\n<p>The choice to build a context-aware addon carries with it the responsibility of\ncarefully managing global static data. Since the addon may be loaded multiple\ntimes, potentially even from different threads, any global static data stored\nin the addon must be properly protected, and must not contain any persistent\nreferences to JavaScript objects. The reason for this is that JavaScript\nobjects are only valid in one context, and will likely cause a crash when\naccessed from the wrong context or from a different thread than the one on which\nthey were created.</p>\n<p>The context-aware addon can be structured to avoid global static data by\nperforming the following steps:</p>\n<ul>\n<li>Define a class which will hold per-addon-instance data and which has a static\nmember of the form\n<pre><code class=\"language-cpp\">static void DeleteInstance(void* data) {\n  // Cast `data` to an instance of the class and delete it.\n}\n</code></pre>\n</li>\n<li>Heap-allocate an instance of this class in the addon initializer. This can be\naccomplished using the <code>new</code> keyword.</li>\n<li>Call <code>node::AddEnvironmentCleanupHook()</code>, passing it the above-created\ninstance and a pointer to <code>DeleteInstance()</code>. This will ensure the instance is\ndeleted when the environment is torn down.</li>\n<li>Store the instance of the class in a <code>v8::External</code>, and</li>\n<li>Pass the <code>v8::External</code> to all methods exposed to JavaScript by passing it\nto <code>v8::FunctionTemplate::New()</code> or <code>v8::Function::New()</code> which creates the\nnative-backed JavaScript functions. The third parameter of\n<code>v8::FunctionTemplate::New()</code> or <code>v8::Function::New()</code>  accepts the\n<code>v8::External</code> and makes it available in the native callback using the\n<code>v8::FunctionCallbackInfo::Data()</code> method.</li>\n</ul>\n<p>This will ensure that the per-addon-instance data reaches each binding that can\nbe called from JavaScript. The per-addon-instance data must also be passed into\nany asynchronous callbacks the addon may create.</p>\n<p>The following example illustrates the implementation of a context-aware addon:</p>\n<pre><code class=\"language-cpp\">#include &#x3C;node.h>\n\nusing namespace v8;\n\nclass AddonData {\n public:\n  explicit AddonData(Isolate* isolate):\n      call_count(0) {\n    // Ensure this per-addon-instance data is deleted at environment cleanup.\n    node::AddEnvironmentCleanupHook(isolate, DeleteInstance, this);\n  }\n\n  // Per-addon data.\n  int call_count;\n\n  static void DeleteInstance(void* data) {\n    delete static_cast&#x3C;AddonData*>(data);\n  }\n};\n\nstatic void Method(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; info) {\n  // Retrieve the per-addon-instance data.\n  AddonData* data =\n      reinterpret_cast&#x3C;AddonData*>(info.Data().As&#x3C;External>()->Value());\n  data->call_count++;\n  info.GetReturnValue().Set((double)data->call_count);\n}\n\n// Initialize this addon to be context-aware.\nNODE_MODULE_INIT(/* exports, module, context */) {\n  Isolate* isolate = context->GetIsolate();\n\n  // Create a new instance of `AddonData` for this instance of the addon and\n  // tie its life cycle to that of the Node.js environment.\n  AddonData* data = new AddonData(isolate);\n\n  // Wrap the data in a `v8::External` so we can pass it to the method we\n  // expose.\n  Local&#x3C;External> external = External::New(isolate, data);\n\n  // Expose the method `Method` to JavaScript, and make sure it receives the\n  // per-addon-instance data we created above by passing `external` as the\n  // third parameter to the `FunctionTemplate` constructor.\n  exports->Set(context,\n               String::NewFromUtf8(isolate, \"method\", NewStringType::kNormal)\n                  .ToLocalChecked(),\n               FunctionTemplate::New(isolate, Method, external)\n                  ->GetFunction(context).ToLocalChecked()).FromJust();\n}\n</code></pre>",
+              "desc": "<p>There are environments in which Node.js addons may need to be loaded multiple\ntimes in multiple contexts. For example, the <a href=\"https://electronjs.org/\">Electron</a> runtime runs multiple\ninstances of Node.js in a single process. Each instance will have its own\n<code>require()</code> cache, and thus each instance will need a native addon to behave\ncorrectly when loaded via <code>require()</code>. This means that the addon\nmust support multiple initializations.</p>\n<p>A context-aware addon can be constructed by using the macro\n<code>NODE_MODULE_INITIALIZER</code>, which expands to the name of a function which Node.js\nwill expect to find when it loads an addon. An addon can thus be initialized as\nin the following example:</p>\n<pre><code class=\"language-cpp\">using namespace v8;\n\nextern \"C\" NODE_MODULE_EXPORT void\nNODE_MODULE_INITIALIZER(Local&#x3C;Object> exports,\n                        Local&#x3C;Value> module,\n                        Local&#x3C;Context> context) {\n  /* Perform addon initialization steps here. */\n}\n</code></pre>\n<p>Another option is to use the macro <code>NODE_MODULE_INIT()</code>, which will also\nconstruct a context-aware addon. Unlike <code>NODE_MODULE()</code>, which is used to\nconstruct an addon around a given addon initializer function,\n<code>NODE_MODULE_INIT()</code> serves as the declaration of such an initializer to be\nfollowed by a function body.</p>\n<p>The following three variables may be used inside the function body following an\ninvocation of <code>NODE_MODULE_INIT()</code>:</p>\n<ul>\n<li><code>Local&#x3C;Object> exports</code>,</li>\n<li><code>Local&#x3C;Value> module</code>, and</li>\n<li><code>Local&#x3C;Context> context</code></li>\n</ul>\n<p>The choice to build a context-aware addon carries with it the responsibility of\ncarefully managing global static data. Since the addon may be loaded multiple\ntimes, potentially even from different threads, any global static data stored\nin the addon must be properly protected, and must not contain any persistent\nreferences to JavaScript objects. The reason for this is that JavaScript\nobjects are only valid in one context, and will likely cause a crash when\naccessed from the wrong context or from a different thread than the one on which\nthey were created.</p>\n<p>The context-aware addon can be structured to avoid global static data by\nperforming the following steps:</p>\n<ul>\n<li>Define a class which will hold per-addon-instance data and which has a static\nmember of the form\n<pre><code class=\"language-cpp\">static void DeleteInstance(void* data) {\n  // Cast `data` to an instance of the class and delete it.\n}\n</code></pre>\n</li>\n<li>Heap-allocate an instance of this class in the addon initializer. This can be\naccomplished using the <code>new</code> keyword.</li>\n<li>Call <code>node::AddEnvironmentCleanupHook()</code>, passing it the above-created\ninstance and a pointer to <code>DeleteInstance()</code>. This will ensure the instance is\ndeleted when the environment is torn down.</li>\n<li>Store the instance of the class in a <code>v8::External</code>, and</li>\n<li>Pass the <code>v8::External</code> to all methods exposed to JavaScript by passing it\nto <code>v8::FunctionTemplate::New()</code> or <code>v8::Function::New()</code> which creates the\nnative-backed JavaScript functions. The third parameter of\n<code>v8::FunctionTemplate::New()</code> or <code>v8::Function::New()</code>  accepts the\n<code>v8::External</code> and makes it available in the native callback using the\n<code>v8::FunctionCallbackInfo::Data()</code> method.</li>\n</ul>\n<p>This will ensure that the per-addon-instance data reaches each binding that can\nbe called from JavaScript. The per-addon-instance data must also be passed into\nany asynchronous callbacks the addon may create.</p>\n<p>The following example illustrates the implementation of a context-aware addon:</p>\n<pre><code class=\"language-cpp\">#include &#x3C;node.h>\n\nusing namespace v8;\n\nclass AddonData {\n public:\n  explicit AddonData(Isolate* isolate):\n      call_count(0) {\n    // Ensure this per-addon-instance data is deleted at environment cleanup.\n    node::AddEnvironmentCleanupHook(isolate, DeleteInstance, this);\n  }\n\n  // Per-addon data.\n  int call_count;\n\n  static void DeleteInstance(void* data) {\n    delete static_cast&#x3C;AddonData*>(data);\n  }\n};\n\nstatic void Method(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; info) {\n  // Retrieve the per-addon-instance data.\n  AddonData* data =\n      reinterpret_cast&#x3C;AddonData*>(info.Data().As&#x3C;External>()->Value());\n  data->call_count++;\n  info.GetReturnValue().Set((double)data->call_count);\n}\n\n// Initialize this addon to be context-aware.\nNODE_MODULE_INIT(/* exports, module, context */) {\n  Isolate* isolate = context->GetIsolate();\n\n  // Create a new instance of `AddonData` for this instance of the addon and\n  // tie its life cycle to that of the Node.js environment.\n  AddonData* data = new AddonData(isolate);\n\n  // Wrap the data in a `v8::External` so we can pass it to the method we\n  // expose.\n  Local&#x3C;External> external = External::New(isolate, data);\n\n  // Expose the method `Method` to JavaScript, and make sure it receives the\n  // per-addon-instance data we created above by passing `external` as the\n  // third parameter to the `FunctionTemplate` constructor.\n  exports->Set(context,\n               String::NewFromUtf8(isolate, \"method\").ToLocalChecked(),\n               FunctionTemplate::New(isolate, Method, external)\n                  ->GetFunction(context).ToLocalChecked()).FromJust();\n}\n</code></pre>",
               "modules": [
                 {
                   "textRaw": "Worker support",
@@ -26,13 +26,13 @@
                   "meta": {
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.8.0",
                         "pr-url": "https://github.com/nodejs/node/pull/34572",
                         "description": "Cleanup hooks may now be asynchronous."
                       }
                     ]
                   },
-                  "desc": "<p>In order to be loaded from multiple Node.js environments,\nsuch as a main thread and a Worker thread, an add-on needs to either:</p>\n<ul>\n<li>Be an N-API addon, or</li>\n<li>Be declared as context-aware using <code>NODE_MODULE_INIT()</code> as described above</li>\n</ul>\n<p>In order to support <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads, addons need to clean up any resources\nthey may have allocated when such a thread exists. This can be achieved through\nthe usage of the <code>AddEnvironmentCleanupHook()</code> function:</p>\n<pre><code class=\"language-cpp\">void AddEnvironmentCleanupHook(v8::Isolate* isolate,\n                               void (*fun)(void* arg),\n                               void* arg);\n</code></pre>\n<p>This function adds a hook that will run before a given Node.js instance shuts\ndown. If necessary, such hooks can be removed before they are run using\n<code>RemoveEnvironmentCleanupHook()</code>, which has the same signature. Callbacks are\nrun in last-in first-out order.</p>\n<p>If necessary, there is an additional pair of <code>AddEnvironmentCleanupHook()</code>\nand <code>RemoveEnvironmentCleanupHook()</code> overloads, where the cleanup hook takes a\ncallback function. This can be used for shutting down asynchronous resources,\nsuch as any libuv handles registered by the addon.</p>\n<p>The following <code>addon.cc</code> uses <code>AddEnvironmentCleanupHook</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;assert.h>\n#include &#x3C;stdlib.h>\n#include &#x3C;node.h>\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::HandleScope;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\n\n// Note: In a real-world application, do not rely on static/global data.\nstatic char cookie[] = \"yum yum\";\nstatic int cleanup_cb1_called = 0;\nstatic int cleanup_cb2_called = 0;\n\nstatic void cleanup_cb1(void* arg) {\n  Isolate* isolate = static_cast&#x3C;Isolate*>(arg);\n  HandleScope scope(isolate);\n  Local&#x3C;Object> obj = Object::New(isolate);\n  assert(!obj.IsEmpty());  // assert VM is still alive\n  assert(obj->IsObject());\n  cleanup_cb1_called++;\n}\n\nstatic void cleanup_cb2(void* arg) {\n  assert(arg == static_cast&#x3C;void*>(cookie));\n  cleanup_cb2_called++;\n}\n\nstatic void sanity_check(void*) {\n  assert(cleanup_cb1_called == 1);\n  assert(cleanup_cb2_called == 1);\n}\n\n// Initialize this addon to be context-aware.\nNODE_MODULE_INIT(/* exports, module, context */) {\n  Isolate* isolate = context->GetIsolate();\n\n  AddEnvironmentCleanupHook(isolate, sanity_check, nullptr);\n  AddEnvironmentCleanupHook(isolate, cleanup_cb2, cookie);\n  AddEnvironmentCleanupHook(isolate, cleanup_cb1, isolate);\n}\n</code></pre>\n<p>Test in JavaScript by running:</p>\n<pre><code class=\"language-js\">// test.js\nrequire('./build/Release/addon');\n</code></pre>",
+                  "desc": "<p>In order to be loaded from multiple Node.js environments,\nsuch as a main thread and a Worker thread, an add-on needs to either:</p>\n<ul>\n<li>Be an Node-API addon, or</li>\n<li>Be declared as context-aware using <code>NODE_MODULE_INIT()</code> as described above</li>\n</ul>\n<p>In order to support <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads, addons need to clean up any resources\nthey may have allocated when such a thread exists. This can be achieved through\nthe usage of the <code>AddEnvironmentCleanupHook()</code> function:</p>\n<pre><code class=\"language-cpp\">void AddEnvironmentCleanupHook(v8::Isolate* isolate,\n                               void (*fun)(void* arg),\n                               void* arg);\n</code></pre>\n<p>This function adds a hook that will run before a given Node.js instance shuts\ndown. If necessary, such hooks can be removed before they are run using\n<code>RemoveEnvironmentCleanupHook()</code>, which has the same signature. Callbacks are\nrun in last-in first-out order.</p>\n<p>If necessary, there is an additional pair of <code>AddEnvironmentCleanupHook()</code>\nand <code>RemoveEnvironmentCleanupHook()</code> overloads, where the cleanup hook takes a\ncallback function. This can be used for shutting down asynchronous resources,\nsuch as any libuv handles registered by the addon.</p>\n<p>The following <code>addon.cc</code> uses <code>AddEnvironmentCleanupHook</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include &#x3C;assert.h>\n#include &#x3C;stdlib.h>\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::HandleScope;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\n\n// Note: In a real-world application, do not rely on static/global data.\nstatic char cookie[] = \"yum yum\";\nstatic int cleanup_cb1_called = 0;\nstatic int cleanup_cb2_called = 0;\n\nstatic void cleanup_cb1(void* arg) {\n  Isolate* isolate = static_cast&#x3C;Isolate*>(arg);\n  HandleScope scope(isolate);\n  Local&#x3C;Object> obj = Object::New(isolate);\n  assert(!obj.IsEmpty());  // assert VM is still alive\n  assert(obj->IsObject());\n  cleanup_cb1_called++;\n}\n\nstatic void cleanup_cb2(void* arg) {\n  assert(arg == static_cast&#x3C;void*>(cookie));\n  cleanup_cb2_called++;\n}\n\nstatic void sanity_check(void*) {\n  assert(cleanup_cb1_called == 1);\n  assert(cleanup_cb2_called == 1);\n}\n\n// Initialize this addon to be context-aware.\nNODE_MODULE_INIT(/* exports, module, context */) {\n  Isolate* isolate = context->GetIsolate();\n\n  AddEnvironmentCleanupHook(isolate, sanity_check, nullptr);\n  AddEnvironmentCleanupHook(isolate, cleanup_cb2, cookie);\n  AddEnvironmentCleanupHook(isolate, cleanup_cb1, isolate);\n}\n</code></pre>\n<p>Test in JavaScript by running:</p>\n<pre><code class=\"language-js\">// test.js\nrequire('./build/Release/addon');\n</code></pre>",
                   "type": "module",
                   "displayName": "Worker support"
                 }
@@ -50,7 +50,7 @@
             {
               "textRaw": "Linking to libraries included with Node.js",
               "name": "linking_to_libraries_included_with_node.js",
-              "desc": "<p>Node.js uses statically linked libraries such as V8, libuv and OpenSSL. All\naddons are required to link to V8 and may link to any of the other dependencies\nas well. Typically, this is as simple as including the appropriate\n<code>#include &#x3C;...></code> statements (e.g. <code>#include &#x3C;v8.h></code>) and <code>node-gyp</code> will locate\nthe appropriate headers automatically. However, there are a few caveats to be\naware of:</p>\n<ul>\n<li>\n<p>When <code>node-gyp</code> runs, it will detect the specific release version of Node.js\nand download either the full source tarball or just the headers. If the full\nsource is downloaded, addons will have complete access to the full set of\nNode.js dependencies. However, if only the Node.js headers are downloaded, then\nonly the symbols exported by Node.js will be available.</p>\n</li>\n<li>\n<p><code>node-gyp</code> can be run using the <code>--nodedir</code> flag pointing at a local Node.js\nsource image. Using this option, the addon will have access to the full set of\ndependencies.</p>\n</li>\n</ul>",
+              "desc": "<p>Node.js uses statically linked libraries such as V8, libuv and OpenSSL. All\naddons are required to link to V8 and may link to any of the other dependencies\nas well. Typically, this is as simple as including the appropriate\n<code>#include &#x3C;...></code> statements (e.g. <code>#include &#x3C;v8.h></code>) and <code>node-gyp</code> will locate\nthe appropriate headers automatically. However, there are a few caveats to be\naware of:</p>\n<ul>\n<li>\n<p>When <code>node-gyp</code> runs, it will detect the specific release version of Node.js\nand download either the full source tarball or just the headers. If the full\nsource is downloaded, addons will have complete access to the full set of\nNode.js dependencies. However, if only the Node.js headers are downloaded,\nthen only the symbols exported by Node.js will be available.</p>\n</li>\n<li>\n<p><code>node-gyp</code> can be run using the <code>--nodedir</code> flag pointing at a local Node.js\nsource image. Using this option, the addon will have access to the full set of\ndependencies.</p>\n</li>\n</ul>",
               "type": "module",
               "displayName": "Linking to libraries included with Node.js"
             },
@@ -68,18 +68,18 @@
         {
           "textRaw": "Native abstractions for Node.js",
           "name": "native_abstractions_for_node.js",
-          "desc": "<p>Each of the examples illustrated in this document directly use the\nNode.js and V8 APIs for implementing addons. The V8 API can, and has, changed\ndramatically from one V8 release to the next (and one major Node.js release to\nthe next). With each change, addons may need to be updated and recompiled in\norder to continue functioning. The Node.js release schedule is designed to\nminimize the frequency and impact of such changes but there is little that\nNode.js can do to ensure stability of the V8 APIs.</p>\n<p>The <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a> (or <code>nan</code>) provide a set of tools that\naddon developers are recommended to use to keep compatibility between past and\nfuture releases of V8 and Node.js. See the <code>nan</code> <a href=\"https://github.com/nodejs/nan/tree/master/examples/\">examples</a> for an\nillustration of how it can be used.</p>",
+          "desc": "<p>Each of the examples illustrated in this document directly use the\nNode.js and V8 APIs for implementing addons. The V8 API can, and has, changed\ndramatically from one V8 release to the next (and one major Node.js release to\nthe next). With each change, addons may need to be updated and recompiled in\norder to continue functioning. The Node.js release schedule is designed to\nminimize the frequency and impact of such changes but there is little that\nNode.js can do to ensure stability of the V8 APIs.</p>\n<p>The <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a> (or <code>nan</code>) provide a set of tools that\naddon developers are recommended to use to keep compatibility between past and\nfuture releases of V8 and Node.js. See the <code>nan</code> <a href=\"https://github.com/nodejs/nan/tree/HEAD/examples/\">examples</a> for an\nillustration of how it can be used.</p>",
           "type": "misc",
           "displayName": "Native abstractions for Node.js"
         },
         {
-          "textRaw": "N-API",
-          "name": "n-api",
+          "textRaw": "Node-API",
+          "name": "node-api",
           "stability": 2,
           "stabilityText": "Stable",
-          "desc": "<p>N-API is an API for building native addons. It is independent from\nthe underlying JavaScript runtime (e.g. V8) and is maintained as part of\nNode.js itself. This API will be Application Binary Interface (ABI) stable\nacross versions of Node.js. It is intended to insulate addons from\nchanges in the underlying JavaScript engine and allow modules\ncompiled for one version to run on later versions of Node.js without\nrecompilation. Addons are built/packaged with the same approach/tools\noutlined in this document (node-gyp, etc.). The only difference is the\nset of APIs that are used by the native code. Instead of using the V8\nor <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a> APIs, the functions available\nin the N-API are used.</p>\n<p>Creating and maintaining an addon that benefits from the ABI stability\nprovided by N-API carries with it certain\n<a href=\"n-api.html#n_api_implications_of_abi_stability\">implementation considerations</a>.</p>\n<p>To use N-API in the above \"Hello world\" example, replace the content of\n<code>hello.cc</code> with the following. All other instructions remain the same.</p>\n<pre><code class=\"language-cpp\">// hello.cc using N-API\n#include &#x3C;node_api.h>\n\nnamespace demo {\n\nnapi_value Method(napi_env env, napi_callback_info args) {\n  napi_value greeting;\n  napi_status status;\n\n  status = napi_create_string_utf8(env, \"world\", NAPI_AUTO_LENGTH, &#x26;greeting);\n  if (status != napi_ok) return nullptr;\n  return greeting;\n}\n\nnapi_value init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_value fn;\n\n  status = napi_create_function(env, nullptr, 0, Method, nullptr, &#x26;fn);\n  if (status != napi_ok) return nullptr;\n\n  status = napi_set_named_property(env, exports, \"hello\", fn);\n  if (status != napi_ok) return nullptr;\n  return exports;\n}\n\nNAPI_MODULE(NODE_GYP_MODULE_NAME, init)\n\n}  // namespace demo\n</code></pre>\n<p>The functions available and how to use them are documented in\n<a href=\"n-api.html\">C/C++ addons with N-API</a>.</p>",
+          "desc": "<p>Node-API is an API for building native addons. It is independent from\nthe underlying JavaScript runtime (e.g. V8) and is maintained as part of\nNode.js itself. This API will be Application Binary Interface (ABI) stable\nacross versions of Node.js. It is intended to insulate addons from\nchanges in the underlying JavaScript engine and allow modules\ncompiled for one version to run on later versions of Node.js without\nrecompilation. Addons are built/packaged with the same approach/tools\noutlined in this document (node-gyp, etc.). The only difference is the\nset of APIs that are used by the native code. Instead of using the V8\nor <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a> APIs, the functions available\nin the Node-API are used.</p>\n<p>Creating and maintaining an addon that benefits from the ABI stability\nprovided by Node-API carries with it certain\n<a href=\"n-api.html#n_api_implications_of_abi_stability\">implementation considerations</a>.</p>\n<p>To use Node-API in the above \"Hello world\" example, replace the content of\n<code>hello.cc</code> with the following. All other instructions remain the same.</p>\n<pre><code class=\"language-cpp\">// hello.cc using Node-API\n#include &#x3C;node_api.h>\n\nnamespace demo {\n\nnapi_value Method(napi_env env, napi_callback_info args) {\n  napi_value greeting;\n  napi_status status;\n\n  status = napi_create_string_utf8(env, \"world\", NAPI_AUTO_LENGTH, &#x26;greeting);\n  if (status != napi_ok) return nullptr;\n  return greeting;\n}\n\nnapi_value init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_value fn;\n\n  status = napi_create_function(env, nullptr, 0, Method, nullptr, &#x26;fn);\n  if (status != napi_ok) return nullptr;\n\n  status = napi_set_named_property(env, exports, \"hello\", fn);\n  if (status != napi_ok) return nullptr;\n  return exports;\n}\n\nNAPI_MODULE(NODE_GYP_MODULE_NAME, init)\n\n}  // namespace demo\n</code></pre>\n<p>The functions available and how to use them are documented in\n<a href=\"n-api.html\">C/C++ addons with Node-API</a>.</p>",
           "type": "misc",
-          "displayName": "N-API"
+          "displayName": "Node-API"
         },
         {
           "textRaw": "Addon examples",
@@ -89,49 +89,49 @@
             {
               "textRaw": "Function arguments",
               "name": "function_arguments",
-              "desc": "<p>Addons will typically expose objects and functions that can be accessed from\nJavaScript running within Node.js. When functions are invoked from JavaScript,\nthe input arguments and return value must be mapped to and from the C/C++\ncode.</p>\n<p>The following example illustrates how to read function arguments passed from\nJavaScript and how to return a result:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Exception;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// This is the implementation of the \"add\" method\n// Input arguments are passed using the\n// const FunctionCallbackInfo&#x3C;Value>&#x26; args struct\nvoid Add(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  // Check the number of arguments passed.\n  if (args.Length() &#x3C; 2) {\n    // Throw an Error that is passed back to JavaScript\n    isolate->ThrowException(Exception::TypeError(\n        String::NewFromUtf8(isolate,\n                            \"Wrong number of arguments\",\n                            NewStringType::kNormal).ToLocalChecked()));\n    return;\n  }\n\n  // Check the argument types\n  if (!args[0]->IsNumber() || !args[1]->IsNumber()) {\n    isolate->ThrowException(Exception::TypeError(\n        String::NewFromUtf8(isolate,\n                            \"Wrong arguments\",\n                            NewStringType::kNormal).ToLocalChecked()));\n    return;\n  }\n\n  // Perform the operation\n  double value =\n      args[0].As&#x3C;Number>()->Value() + args[1].As&#x3C;Number>()->Value();\n  Local&#x3C;Number> num = Number::New(isolate, value);\n\n  // Set the return value (using the passed in\n  // FunctionCallbackInfo&#x3C;Value>&#x26;)\n  args.GetReturnValue().Set(num);\n}\n\nvoid Init(Local&#x3C;Object> exports) {\n  NODE_SET_METHOD(exports, \"add\", Add);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>Once compiled, the example addon can be required and used from within Node.js:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconsole.log('This should be eight:', addon.add(3, 5));\n</code></pre>",
+              "desc": "<p>Addons will typically expose objects and functions that can be accessed from\nJavaScript running within Node.js. When functions are invoked from JavaScript,\nthe input arguments and return value must be mapped to and from the C/C++\ncode.</p>\n<p>The following example illustrates how to read function arguments passed from\nJavaScript and how to return a result:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Exception;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// This is the implementation of the \"add\" method\n// Input arguments are passed using the\n// const FunctionCallbackInfo&#x3C;Value>&#x26; args struct\nvoid Add(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  // Check the number of arguments passed.\n  if (args.Length() &#x3C; 2) {\n    // Throw an Error that is passed back to JavaScript\n    isolate->ThrowException(Exception::TypeError(\n        String::NewFromUtf8(isolate,\n                            \"Wrong number of arguments\").ToLocalChecked()));\n    return;\n  }\n\n  // Check the argument types\n  if (!args[0]->IsNumber() || !args[1]->IsNumber()) {\n    isolate->ThrowException(Exception::TypeError(\n        String::NewFromUtf8(isolate,\n                            \"Wrong arguments\").ToLocalChecked()));\n    return;\n  }\n\n  // Perform the operation\n  double value =\n      args[0].As&#x3C;Number>()->Value() + args[1].As&#x3C;Number>()->Value();\n  Local&#x3C;Number> num = Number::New(isolate, value);\n\n  // Set the return value (using the passed in\n  // FunctionCallbackInfo&#x3C;Value>&#x26;)\n  args.GetReturnValue().Set(num);\n}\n\nvoid Init(Local&#x3C;Object> exports) {\n  NODE_SET_METHOD(exports, \"add\", Add);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>Once compiled, the example addon can be required and used from within Node.js:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconsole.log('This should be eight:', addon.add(3, 5));\n</code></pre>",
               "type": "module",
               "displayName": "Function arguments"
             },
             {
               "textRaw": "Callbacks",
               "name": "callbacks",
-              "desc": "<p>It is common practice within addons to pass JavaScript functions to a C++\nfunction and execute them from there. The following example illustrates how\nto invoke such callbacks:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Null;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid RunCallback(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Function> cb = Local&#x3C;Function>::Cast(args[0]);\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = {\n      String::NewFromUtf8(isolate,\n                          \"hello world\",\n                          NewStringType::kNormal).ToLocalChecked() };\n  cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", RunCallback);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>This example uses a two-argument form of <code>Init()</code> that receives the full\n<code>module</code> object as the second argument. This allows the addon to completely\noverwrite <code>exports</code> with a single function instead of adding the function as a\nproperty of <code>exports</code>.</p>\n<p>To test it, run the following JavaScript:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\naddon((msg) => {\n  console.log(msg);\n// Prints: 'hello world'\n});\n</code></pre>\n<p>In this example, the callback function is invoked synchronously.</p>",
+              "desc": "<p>It is common practice within addons to pass JavaScript functions to a C++\nfunction and execute them from there. The following example illustrates how\nto invoke such callbacks:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Null;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid RunCallback(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Function> cb = Local&#x3C;Function>::Cast(args[0]);\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = {\n      String::NewFromUtf8(isolate,\n                          \"hello world\").ToLocalChecked() };\n  cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", RunCallback);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>This example uses a two-argument form of <code>Init()</code> that receives the full\n<code>module</code> object as the second argument. This allows the addon to completely\noverwrite <code>exports</code> with a single function instead of adding the function as a\nproperty of <code>exports</code>.</p>\n<p>To test it, run the following JavaScript:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\naddon((msg) => {\n  console.log(msg);\n// Prints: 'hello world'\n});\n</code></pre>\n<p>In this example, the callback function is invoked synchronously.</p>",
               "type": "module",
               "displayName": "Callbacks"
             },
             {
               "textRaw": "Object factory",
               "name": "object_factory",
-              "desc": "<p>Addons can create and return new objects from within a C++ function as\nillustrated in the following example. An object is created and returned with a\nproperty <code>msg</code> that echoes the string passed to <code>createObject()</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  Local&#x3C;Object> obj = Object::New(isolate);\n  obj->Set(context,\n           String::NewFromUtf8(isolate,\n                               \"msg\",\n                               NewStringType::kNormal).ToLocalChecked(),\n                               args[0]->ToString(context).ToLocalChecked())\n           .FromJust();\n\n  args.GetReturnValue().Set(obj);\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", CreateObject);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>To test it in JavaScript:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj1 = addon('hello');\nconst obj2 = addon('world');\nconsole.log(obj1.msg, obj2.msg);\n// Prints: 'hello world'\n</code></pre>",
+              "desc": "<p>Addons can create and return new objects from within a C++ function as\nillustrated in the following example. An object is created and returned with a\nproperty <code>msg</code> that echoes the string passed to <code>createObject()</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  Local&#x3C;Object> obj = Object::New(isolate);\n  obj->Set(context,\n           String::NewFromUtf8(isolate,\n                               \"msg\").ToLocalChecked(),\n                               args[0]->ToString(context).ToLocalChecked())\n           .FromJust();\n\n  args.GetReturnValue().Set(obj);\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", CreateObject);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>To test it in JavaScript:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj1 = addon('hello');\nconst obj2 = addon('world');\nconsole.log(obj1.msg, obj2.msg);\n// Prints: 'hello world'\n</code></pre>",
               "type": "module",
               "displayName": "Object factory"
             },
             {
               "textRaw": "Function factory",
               "name": "function_factory",
-              "desc": "<p>Another common scenario is creating JavaScript functions that wrap C++\nfunctions and returning those back to JavaScript:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid MyFunction(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  args.GetReturnValue().Set(String::NewFromUtf8(\n      isolate, \"hello world\", NewStringType::kNormal).ToLocalChecked());\n}\n\nvoid CreateFunction(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, MyFunction);\n  Local&#x3C;Function> fn = tpl->GetFunction(context).ToLocalChecked();\n\n  // omit this to make it anonymous\n  fn->SetName(String::NewFromUtf8(\n      isolate, \"theFunction\", NewStringType::kNormal).ToLocalChecked());\n\n  args.GetReturnValue().Set(fn);\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", CreateFunction);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>To test:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst fn = addon();\nconsole.log(fn());\n// Prints: 'hello world'\n</code></pre>",
+              "desc": "<p>Another common scenario is creating JavaScript functions that wrap C++\nfunctions and returning those back to JavaScript:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid MyFunction(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  args.GetReturnValue().Set(String::NewFromUtf8(\n      isolate, \"hello world\").ToLocalChecked());\n}\n\nvoid CreateFunction(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, MyFunction);\n  Local&#x3C;Function> fn = tpl->GetFunction(context).ToLocalChecked();\n\n  // omit this to make it anonymous\n  fn->SetName(String::NewFromUtf8(\n      isolate, \"theFunction\").ToLocalChecked());\n\n  args.GetReturnValue().Set(fn);\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", CreateFunction);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>To test:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst fn = addon();\nconsole.log(fn());\n// Prints: 'hello world'\n</code></pre>",
               "type": "module",
               "displayName": "Function factory"
             },
             {
               "textRaw": "Wrapping C++ objects",
               "name": "wrapping_c++_objects",
-              "desc": "<p>It is also possible to wrap C++ objects/classes in a way that allows new\ninstances to be created using the JavaScript <code>new</code> operator:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Local;\nusing v8::Object;\n\nvoid InitAll(Local&#x3C;Object> exports) {\n  MyObject::Init(exports);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>Then, in <code>myobject.h</code>, the wrapper class inherits from <code>node::ObjectWrap</code>:</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Local&#x3C;v8::Object> exports);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static void PlusOne(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>In <code>myobject.cc</code>, implement the various methods that are to be exposed.\nBelow, the method <code>plusOne()</code> is exposed by adding it to the constructor's\nprototype:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Number;\nusing v8::Object;\nusing v8::ObjectTemplate;\nusing v8::String;\nusing v8::Value;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Local&#x3C;Object> exports) {\n  Isolate* isolate = exports->GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  Local&#x3C;ObjectTemplate> addon_data_tpl = ObjectTemplate::New(isolate);\n  addon_data_tpl->SetInternalFieldCount(1);  // 1 field for the MyObject::New()\n  Local&#x3C;Object> addon_data =\n      addon_data_tpl->NewInstance(context).ToLocalChecked();\n\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);\n  tpl->SetClassName(String::NewFromUtf8(\n      isolate, \"MyObject\", NewStringType::kNormal).ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  // Prototype\n  NODE_SET_PROTOTYPE_METHOD(tpl, \"plusOne\", PlusOne);\n\n  Local&#x3C;Function> constructor = tpl->GetFunction(context).ToLocalChecked();\n  addon_data->SetInternalField(0, constructor);\n  exports->Set(context, String::NewFromUtf8(\n      isolate, \"MyObject\", NewStringType::kNormal).ToLocalChecked(),\n               constructor).FromJust();\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons =\n        args.Data().As&#x3C;Object>()->GetInternalField(0).As&#x3C;Function>();\n    Local&#x3C;Object> result =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(result);\n  }\n}\n\nvoid MyObject::PlusOne(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());\n  obj->value_ += 1;\n\n  args.GetReturnValue().Set(Number::New(isolate, obj->value_));\n}\n\n}  // namespace demo\n</code></pre>\n<p>To build this example, the <code>myobject.cc</code> file must be added to the\n<code>binding.gyp</code>:</p>\n<pre><code class=\"language-json\">{\n  \"targets\": [\n    {\n      \"target_name\": \"addon\",\n      \"sources\": [\n        \"addon.cc\",\n        \"myobject.cc\"\n      ]\n    }\n  ]\n}\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj = new addon.MyObject(10);\nconsole.log(obj.plusOne());\n// Prints: 11\nconsole.log(obj.plusOne());\n// Prints: 12\nconsole.log(obj.plusOne());\n// Prints: 13\n</code></pre>\n<p>The destructor for a wrapper object will run when the object is\ngarbage-collected. For destructor testing, there are command-line flags that\ncan be used to make it possible to force garbage collection. These flags are\nprovided by the underlying V8 JavaScript engine. They are subject to change\nor removal at any time. They are not documented by Node.js or V8, and they\nshould never be used outside of testing.</p>",
+              "desc": "<p>It is also possible to wrap C++ objects/classes in a way that allows new\ninstances to be created using the JavaScript <code>new</code> operator:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Local;\nusing v8::Object;\n\nvoid InitAll(Local&#x3C;Object> exports) {\n  MyObject::Init(exports);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>Then, in <code>myobject.h</code>, the wrapper class inherits from <code>node::ObjectWrap</code>:</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Local&#x3C;v8::Object> exports);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static void PlusOne(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>In <code>myobject.cc</code>, implement the various methods that are to be exposed.\nBelow, the method <code>plusOne()</code> is exposed by adding it to the constructor's\nprototype:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::ObjectTemplate;\nusing v8::String;\nusing v8::Value;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Local&#x3C;Object> exports) {\n  Isolate* isolate = exports->GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  Local&#x3C;ObjectTemplate> addon_data_tpl = ObjectTemplate::New(isolate);\n  addon_data_tpl->SetInternalFieldCount(1);  // 1 field for the MyObject::New()\n  Local&#x3C;Object> addon_data =\n      addon_data_tpl->NewInstance(context).ToLocalChecked();\n\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);\n  tpl->SetClassName(String::NewFromUtf8(isolate, \"MyObject\").ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  // Prototype\n  NODE_SET_PROTOTYPE_METHOD(tpl, \"plusOne\", PlusOne);\n\n  Local&#x3C;Function> constructor = tpl->GetFunction(context).ToLocalChecked();\n  addon_data->SetInternalField(0, constructor);\n  exports->Set(context, String::NewFromUtf8(\n      isolate, \"MyObject\").ToLocalChecked(),\n      constructor).FromJust();\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons =\n        args.Data().As&#x3C;Object>()->GetInternalField(0).As&#x3C;Function>();\n    Local&#x3C;Object> result =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(result);\n  }\n}\n\nvoid MyObject::PlusOne(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());\n  obj->value_ += 1;\n\n  args.GetReturnValue().Set(Number::New(isolate, obj->value_));\n}\n\n}  // namespace demo\n</code></pre>\n<p>To build this example, the <code>myobject.cc</code> file must be added to the\n<code>binding.gyp</code>:</p>\n<pre><code class=\"language-json\">{\n  \"targets\": [\n    {\n      \"target_name\": \"addon\",\n      \"sources\": [\n        \"addon.cc\",\n        \"myobject.cc\"\n      ]\n    }\n  ]\n}\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj = new addon.MyObject(10);\nconsole.log(obj.plusOne());\n// Prints: 11\nconsole.log(obj.plusOne());\n// Prints: 12\nconsole.log(obj.plusOne());\n// Prints: 13\n</code></pre>\n<p>The destructor for a wrapper object will run when the object is\ngarbage-collected. For destructor testing, there are command-line flags that\ncan be used to make it possible to force garbage collection. These flags are\nprovided by the underlying V8 JavaScript engine. They are subject to change\nor removal at any time. They are not documented by Node.js or V8, and they\nshould never be used outside of testing.</p>",
               "type": "module",
               "displayName": "Wrapping C++ objects"
             },
             {
               "textRaw": "Factory of wrapped objects",
               "name": "factory_of_wrapped_objects",
-              "desc": "<p>Alternatively, it is possible to use a factory pattern to avoid explicitly\ncreating object instances using the JavaScript <code>new</code> operator:</p>\n<pre><code class=\"language-js\">const obj = addon.createObject();\n// instead of:\n// const obj = new addon.Object();\n</code></pre>\n<p>First, the <code>createObject()</code> method is implemented in <code>addon.cc</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  MyObject::NewInstance(args);\n}\n\nvoid InitAll(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  MyObject::Init(exports->GetIsolate());\n\n  NODE_SET_METHOD(module, \"exports\", CreateObject);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>In <code>myobject.h</code>, the static method <code>NewInstance()</code> is added to handle\ninstantiating the object. This method takes the place of using <code>new</code> in\nJavaScript:</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Isolate* isolate);\n  static void NewInstance(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static void PlusOne(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static v8::Global&#x3C;v8::Function> constructor;\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>The implementation in <code>myobject.cc</code> is similar to the previous example:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Global;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// Warning! This is not thread-safe, this addon cannot be used for worker\n// threads.\nGlobal&#x3C;Function> MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Isolate* isolate) {\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);\n  tpl->SetClassName(String::NewFromUtf8(\n      isolate, \"MyObject\", NewStringType::kNormal).ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  // Prototype\n  NODE_SET_PROTOTYPE_METHOD(tpl, \"plusOne\", PlusOne);\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());\n\n  AddEnvironmentCleanupHook(isolate, [](void*) {\n    constructor.Reset();\n  }, nullptr);\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n    Local&#x3C;Object> instance =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(instance);\n  }\n}\n\nvoid MyObject::NewInstance(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = { args[0] };\n  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Object> instance =\n      cons->NewInstance(context, argc, argv).ToLocalChecked();\n\n  args.GetReturnValue().Set(instance);\n}\n\nvoid MyObject::PlusOne(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());\n  obj->value_ += 1;\n\n  args.GetReturnValue().Set(Number::New(isolate, obj->value_));\n}\n\n}  // namespace demo\n</code></pre>\n<p>Once again, to build this example, the <code>myobject.cc</code> file must be added to the\n<code>binding.gyp</code>:</p>\n<pre><code class=\"language-json\">{\n  \"targets\": [\n    {\n      \"target_name\": \"addon\",\n      \"sources\": [\n        \"addon.cc\",\n        \"myobject.cc\"\n      ]\n    }\n  ]\n}\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst createObject = require('./build/Release/addon');\n\nconst obj = createObject(10);\nconsole.log(obj.plusOne());\n// Prints: 11\nconsole.log(obj.plusOne());\n// Prints: 12\nconsole.log(obj.plusOne());\n// Prints: 13\n\nconst obj2 = createObject(20);\nconsole.log(obj2.plusOne());\n// Prints: 21\nconsole.log(obj2.plusOne());\n// Prints: 22\nconsole.log(obj2.plusOne());\n// Prints: 23\n</code></pre>",
+              "desc": "<p>Alternatively, it is possible to use a factory pattern to avoid explicitly\ncreating object instances using the JavaScript <code>new</code> operator:</p>\n<pre><code class=\"language-js\">const obj = addon.createObject();\n// instead of:\n// const obj = new addon.Object();\n</code></pre>\n<p>First, the <code>createObject()</code> method is implemented in <code>addon.cc</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  MyObject::NewInstance(args);\n}\n\nvoid InitAll(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  MyObject::Init(exports->GetIsolate());\n\n  NODE_SET_METHOD(module, \"exports\", CreateObject);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>In <code>myobject.h</code>, the static method <code>NewInstance()</code> is added to handle\ninstantiating the object. This method takes the place of using <code>new</code> in\nJavaScript:</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Isolate* isolate);\n  static void NewInstance(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static void PlusOne(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static v8::Global&#x3C;v8::Function> constructor;\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>The implementation in <code>myobject.cc</code> is similar to the previous example:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Global;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// Warning! This is not thread-safe, this addon cannot be used for worker\n// threads.\nGlobal&#x3C;Function> MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Isolate* isolate) {\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);\n  tpl->SetClassName(String::NewFromUtf8(isolate, \"MyObject\").ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  // Prototype\n  NODE_SET_PROTOTYPE_METHOD(tpl, \"plusOne\", PlusOne);\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());\n\n  AddEnvironmentCleanupHook(isolate, [](void*) {\n    constructor.Reset();\n  }, nullptr);\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n    Local&#x3C;Object> instance =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(instance);\n  }\n}\n\nvoid MyObject::NewInstance(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = { args[0] };\n  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Object> instance =\n      cons->NewInstance(context, argc, argv).ToLocalChecked();\n\n  args.GetReturnValue().Set(instance);\n}\n\nvoid MyObject::PlusOne(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());\n  obj->value_ += 1;\n\n  args.GetReturnValue().Set(Number::New(isolate, obj->value_));\n}\n\n}  // namespace demo\n</code></pre>\n<p>Once again, to build this example, the <code>myobject.cc</code> file must be added to the\n<code>binding.gyp</code>:</p>\n<pre><code class=\"language-json\">{\n  \"targets\": [\n    {\n      \"target_name\": \"addon\",\n      \"sources\": [\n        \"addon.cc\",\n        \"myobject.cc\"\n      ]\n    }\n  ]\n}\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst createObject = require('./build/Release/addon');\n\nconst obj = createObject(10);\nconsole.log(obj.plusOne());\n// Prints: 11\nconsole.log(obj.plusOne());\n// Prints: 12\nconsole.log(obj.plusOne());\n// Prints: 13\n\nconst obj2 = createObject(20);\nconsole.log(obj2.plusOne());\n// Prints: 21\nconsole.log(obj2.plusOne());\n// Prints: 22\nconsole.log(obj2.plusOne());\n// Prints: 23\n</code></pre>",
               "type": "module",
               "displayName": "Factory of wrapped objects"
             },
             {
               "textRaw": "Passing wrapped objects around",
               "name": "passing_wrapped_objects_around",
-              "desc": "<p>In addition to wrapping and returning C++ objects, it is possible to pass\nwrapped objects around by unwrapping them with the Node.js helper function\n<code>node::ObjectWrap::Unwrap</code>. The following examples shows a function <code>add()</code>\nthat can take two <code>MyObject</code> objects as input arguments:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  MyObject::NewInstance(args);\n}\n\nvoid Add(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  MyObject* obj1 = node::ObjectWrap::Unwrap&#x3C;MyObject>(\n      args[0]->ToObject(context).ToLocalChecked());\n  MyObject* obj2 = node::ObjectWrap::Unwrap&#x3C;MyObject>(\n      args[1]->ToObject(context).ToLocalChecked());\n\n  double sum = obj1->value() + obj2->value();\n  args.GetReturnValue().Set(Number::New(isolate, sum));\n}\n\nvoid InitAll(Local&#x3C;Object> exports) {\n  MyObject::Init(exports->GetIsolate());\n\n  NODE_SET_METHOD(exports, \"createObject\", CreateObject);\n  NODE_SET_METHOD(exports, \"add\", Add);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>In <code>myobject.h</code>, a new public method is added to allow access to private values\nafter unwrapping the object.</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Isolate* isolate);\n  static void NewInstance(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  inline double value() const { return value_; }\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static v8::Global&#x3C;v8::Function> constructor;\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>The implementation of <code>myobject.cc</code> is similar to before:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Global;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// Warning! This is not thread-safe, this addon cannot be used for worker\n// threads.\nGlobal&#x3C;Function> MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Isolate* isolate) {\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);\n  tpl->SetClassName(String::NewFromUtf8(\n      isolate, \"MyObject\", NewStringType::kNormal).ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());\n\n  AddEnvironmentCleanupHook(isolate, [](void*) {\n    constructor.Reset();\n  }, nullptr);\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n    Local&#x3C;Object> instance =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(instance);\n  }\n}\n\nvoid MyObject::NewInstance(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = { args[0] };\n  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Object> instance =\n      cons->NewInstance(context, argc, argv).ToLocalChecked();\n\n  args.GetReturnValue().Set(instance);\n}\n\n}  // namespace demo\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj1 = addon.createObject(10);\nconst obj2 = addon.createObject(20);\nconst result = addon.add(obj1, obj2);\n\nconsole.log(result);\n// Prints: 30\n</code></pre>",
+              "desc": "<p>In addition to wrapping and returning C++ objects, it is possible to pass\nwrapped objects around by unwrapping them with the Node.js helper function\n<code>node::ObjectWrap::Unwrap</code>. The following examples shows a function <code>add()</code>\nthat can take two <code>MyObject</code> objects as input arguments:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  MyObject::NewInstance(args);\n}\n\nvoid Add(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  MyObject* obj1 = node::ObjectWrap::Unwrap&#x3C;MyObject>(\n      args[0]->ToObject(context).ToLocalChecked());\n  MyObject* obj2 = node::ObjectWrap::Unwrap&#x3C;MyObject>(\n      args[1]->ToObject(context).ToLocalChecked());\n\n  double sum = obj1->value() + obj2->value();\n  args.GetReturnValue().Set(Number::New(isolate, sum));\n}\n\nvoid InitAll(Local&#x3C;Object> exports) {\n  MyObject::Init(exports->GetIsolate());\n\n  NODE_SET_METHOD(exports, \"createObject\", CreateObject);\n  NODE_SET_METHOD(exports, \"add\", Add);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>In <code>myobject.h</code>, a new public method is added to allow access to private values\nafter unwrapping the object.</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Isolate* isolate);\n  static void NewInstance(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  inline double value() const { return value_; }\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static v8::Global&#x3C;v8::Function> constructor;\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>The implementation of <code>myobject.cc</code> is similar to before:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Global;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// Warning! This is not thread-safe, this addon cannot be used for worker\n// threads.\nGlobal&#x3C;Function> MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Isolate* isolate) {\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);\n  tpl->SetClassName(String::NewFromUtf8(isolate, \"MyObject\").ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());\n\n  AddEnvironmentCleanupHook(isolate, [](void*) {\n    constructor.Reset();\n  }, nullptr);\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n    Local&#x3C;Object> instance =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(instance);\n  }\n}\n\nvoid MyObject::NewInstance(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = { args[0] };\n  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Object> instance =\n      cons->NewInstance(context, argc, argv).ToLocalChecked();\n\n  args.GetReturnValue().Set(instance);\n}\n\n}  // namespace demo\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj1 = addon.createObject(10);\nconst obj2 = addon.createObject(20);\nconst result = addon.add(obj1, obj2);\n\nconsole.log(result);\n// Prints: 30\n</code></pre>",
               "type": "module",
               "displayName": "Passing wrapped objects around"
             }
diff --git a/doc/api/addons.md b/doc/api/addons.md
index 2ad560a14e1400ccb96fab32d6f4fe1dea04eade..d3fcc6425772085838007cc71d8160f6660b3def 100644
--- a/doc/api/addons.md
+++ b/doc/api/addons.md
@@ -7,15 +7,16 @@ _Addons_ are dynamically-linked shared objects written in C++. The
 [`require()`][require] function can load addons as ordinary Node.js modules.
 Addons provide an interface between JavaScript and C/C++ libraries.
 
-There are three options for implementing addons: N-API, nan, or direct
+There are three options for implementing addons: Node-API, nan, or direct
 use of internal V8, libuv and Node.js libraries. Unless there is a need for
-direct access to functionality which is not exposed by N-API, use N-API.
-Refer to [C/C++ addons with N-API](n-api.html) for more information on N-API.
+direct access to functionality which is not exposed by Node-API, use Node-API.
+Refer to [C/C++ addons with Node-API](n-api.md) for more information on
+Node-API.
 
-When not using N-API, implementing addons is complicated,
+When not using Node-API, implementing addons is complicated,
 involving knowledge of several components and APIs:
 
-* V8: the C++ library Node.js uses to provide the
+* [V8][]: the C++ library Node.js uses to provide the
   JavaScript implementation. V8 provides the mechanisms for creating objects,
   calling functions, etc. V8's API is documented mostly in the
   `v8.h` header file (`deps/v8/include/v8.h` in the Node.js source
@@ -26,12 +27,12 @@ involving knowledge of several components and APIs:
   serves as a cross-platform abstraction library, giving easy, POSIX-like
   access across all major operating systems to many common system tasks, such
   as interacting with the filesystem, sockets, timers, and system events. libuv
-  also provides a pthreads-like threading abstraction that may be used to
-  power more sophisticated asynchronous addons that need to move beyond the
-  standard event loop. Addon authors are encouraged to think about how to
+  also provides a threading abstraction similar to POSIX threads for
+  more sophisticated asynchronous addons that need to move beyond the
+  standard event loop. Addon authors should
   avoid blocking the event loop with I/O or other time-intensive tasks by
-  off-loading work via libuv to non-blocking system operations, worker threads
-  or a custom use of libuv's threads.
+  offloading work via libuv to non-blocking system operations, worker threads,
+  or a custom use of libuv threads.
 
 * Internal Node.js libraries. Node.js itself exports C++ APIs that addons can
   use, the most important of which is the `node::ObjectWrap` class.
@@ -65,7 +66,6 @@ namespace demo {
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
@@ -73,7 +73,7 @@ using v8::Value;
 void Method(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(String::NewFromUtf8(
-      isolate, "world", NewStringType::kNormal).ToLocalChecked());
+      isolate, "world").ToLocalChecked());
 }
 
 void Initialize(Local<Object> exports) {
@@ -112,8 +112,8 @@ There are environments in which Node.js addons may need to be loaded multiple
 times in multiple contexts. For example, the [Electron][] runtime runs multiple
 instances of Node.js in a single process. Each instance will have its own
 `require()` cache, and thus each instance will need a native addon to behave
-correctly when loaded via `require()`. From the addon's perspective, this means
-that it must support multiple initializations.
+correctly when loaded via `require()`. This means that the addon
+must support multiple initializations.
 
 A context-aware addon can be constructed by using the macro
 `NODE_MODULE_INITIALIZER`, which expands to the name of a function which Node.js
@@ -155,25 +155,26 @@ they were created.
 
 The context-aware addon can be structured to avoid global static data by
 performing the following steps:
+
 * Define a class which will hold per-addon-instance data and which has a static
-member of the form
+  member of the form
   ```cpp
   static void DeleteInstance(void* data) {
     // Cast `data` to an instance of the class and delete it.
   }
   ```
 * Heap-allocate an instance of this class in the addon initializer. This can be
-accomplished using the `new` keyword.
+  accomplished using the `new` keyword.
 * Call `node::AddEnvironmentCleanupHook()`, passing it the above-created
-instance and a pointer to `DeleteInstance()`. This will ensure the instance is
-deleted when the environment is torn down.
+  instance and a pointer to `DeleteInstance()`. This will ensure the instance is
+  deleted when the environment is torn down.
 * Store the instance of the class in a `v8::External`, and
 * Pass the `v8::External` to all methods exposed to JavaScript by passing it
-to `v8::FunctionTemplate::New()` or `v8::Function::New()` which creates the
-native-backed JavaScript functions. The third parameter of
-`v8::FunctionTemplate::New()` or `v8::Function::New()`  accepts the
-`v8::External` and makes it available in the native callback using the
-`v8::FunctionCallbackInfo::Data()` method.
+  to `v8::FunctionTemplate::New()` or `v8::Function::New()` which creates the
+  native-backed JavaScript functions. The third parameter of
+  `v8::FunctionTemplate::New()` or `v8::Function::New()`  accepts the
+  `v8::External` and makes it available in the native callback using the
+  `v8::FunctionCallbackInfo::Data()` method.
 
 This will ensure that the per-addon-instance data reaches each binding that can
 be called from JavaScript. The per-addon-instance data must also be passed into
@@ -226,8 +227,7 @@ NODE_MODULE_INIT(/* exports, module, context */) {
   // per-addon-instance data we created above by passing `external` as the
   // third parameter to the `FunctionTemplate` constructor.
   exports->Set(context,
-               String::NewFromUtf8(isolate, "method", NewStringType::kNormal)
-                  .ToLocalChecked(),
+               String::NewFromUtf8(isolate, "method").ToLocalChecked(),
                FunctionTemplate::New(isolate, Method, external)
                   ->GetFunction(context).ToLocalChecked()).FromJust();
 }
@@ -236,7 +236,7 @@ NODE_MODULE_INIT(/* exports, module, context */) {
 #### Worker support
 <!-- YAML
 changes:
-  - version: v12.19.0
+  - version: v14.8.0
     pr-url: https://github.com/nodejs/node/pull/34572
     description: Cleanup hooks may now be asynchronous.
 -->
@@ -244,7 +244,7 @@ changes:
 In order to be loaded from multiple Node.js environments,
 such as a main thread and a Worker thread, an add-on needs to either:
 
-* Be an N-API addon, or
+* Be an Node-API addon, or
 * Be declared as context-aware using `NODE_MODULE_INIT()` as described above
 
 In order to support [`Worker`][] threads, addons need to clean up any resources
@@ -271,9 +271,9 @@ The following `addon.cc` uses `AddEnvironmentCleanupHook`:
 
 ```cpp
 // addon.cc
+#include <node.h>
 #include <assert.h>
 #include <stdlib.h>
-#include <node.h>
 
 using node::AddEnvironmentCleanupHook;
 using v8::HandleScope;
@@ -397,14 +397,14 @@ the appropriate headers automatically. However, there are a few caveats to be
 aware of:
 
 * When `node-gyp` runs, it will detect the specific release version of Node.js
-and download either the full source tarball or just the headers. If the full
-source is downloaded, addons will have complete access to the full set of
-Node.js dependencies. However, if only the Node.js headers are downloaded, then
-only the symbols exported by Node.js will be available.
+  and download either the full source tarball or just the headers. If the full
+  source is downloaded, addons will have complete access to the full set of
+  Node.js dependencies. However, if only the Node.js headers are downloaded,
+  then only the symbols exported by Node.js will be available.
 
 * `node-gyp` can be run using the `--nodedir` flag pointing at a local Node.js
-source image. Using this option, the addon will have access to the full set of
-dependencies.
+  source image. Using this option, the addon will have access to the full set of
+  dependencies.
 
 ### Loading addons using `require()`
 
@@ -436,11 +436,11 @@ addon developers are recommended to use to keep compatibility between past and
 future releases of V8 and Node.js. See the `nan` [examples][] for an
 illustration of how it can be used.
 
-## N-API
+## Node-API
 
 > Stability: 2 - Stable
 
-N-API is an API for building native addons. It is independent from
+Node-API is an API for building native addons. It is independent from
 the underlying JavaScript runtime (e.g. V8) and is maintained as part of
 Node.js itself. This API will be Application Binary Interface (ABI) stable
 across versions of Node.js. It is intended to insulate addons from
@@ -450,17 +450,17 @@ recompilation. Addons are built/packaged with the same approach/tools
 outlined in this document (node-gyp, etc.). The only difference is the
 set of APIs that are used by the native code. Instead of using the V8
 or [Native Abstractions for Node.js][] APIs, the functions available
-in the N-API are used.
+in the Node-API are used.
 
 Creating and maintaining an addon that benefits from the ABI stability
-provided by N-API carries with it certain
-[implementation considerations](n-api.html#n_api_implications_of_abi_stability).
+provided by Node-API carries with it certain
+[implementation considerations](n-api.md#n_api_implications_of_abi_stability).
 
-To use N-API in the above "Hello world" example, replace the content of
+To use Node-API in the above "Hello world" example, replace the content of
 `hello.cc` with the following. All other instructions remain the same.
 
 ```cpp
-// hello.cc using N-API
+// hello.cc using Node-API
 #include <node_api.h>
 
 namespace demo {
@@ -492,7 +492,7 @@ NAPI_MODULE(NODE_GYP_MODULE_NAME, init)
 ```
 
 The functions available and how to use them are documented in
-[C/C++ addons with N-API](n-api.html).
+[C/C++ addons with Node-API](n-api.md).
 
 ## Addon examples
 
@@ -549,7 +549,6 @@ using v8::Exception;
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Number;
 using v8::Object;
 using v8::String;
@@ -566,8 +565,7 @@ void Add(const FunctionCallbackInfo<Value>& args) {
     // Throw an Error that is passed back to JavaScript
     isolate->ThrowException(Exception::TypeError(
         String::NewFromUtf8(isolate,
-                            "Wrong number of arguments",
-                            NewStringType::kNormal).ToLocalChecked()));
+                            "Wrong number of arguments").ToLocalChecked()));
     return;
   }
 
@@ -575,8 +573,7 @@ void Add(const FunctionCallbackInfo<Value>& args) {
   if (!args[0]->IsNumber() || !args[1]->IsNumber()) {
     isolate->ThrowException(Exception::TypeError(
         String::NewFromUtf8(isolate,
-                            "Wrong arguments",
-                            NewStringType::kNormal).ToLocalChecked()));
+                            "Wrong arguments").ToLocalChecked()));
     return;
   }
 
@@ -625,7 +622,6 @@ using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Null;
 using v8::Object;
 using v8::String;
@@ -638,8 +634,7 @@ void RunCallback(const FunctionCallbackInfo<Value>& args) {
   const unsigned argc = 1;
   Local<Value> argv[argc] = {
       String::NewFromUtf8(isolate,
-                          "hello world",
-                          NewStringType::kNormal).ToLocalChecked() };
+                          "hello world").ToLocalChecked() };
   cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();
 }
 
@@ -687,7 +682,6 @@ using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
@@ -699,8 +693,7 @@ void CreateObject(const FunctionCallbackInfo<Value>& args) {
   Local<Object> obj = Object::New(isolate);
   obj->Set(context,
            String::NewFromUtf8(isolate,
-                               "msg",
-                               NewStringType::kNormal).ToLocalChecked(),
+                               "msg").ToLocalChecked(),
                                args[0]->ToString(context).ToLocalChecked())
            .FromJust();
 
@@ -745,7 +738,6 @@ using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
@@ -753,7 +745,7 @@ using v8::Value;
 void MyFunction(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(String::NewFromUtf8(
-      isolate, "hello world", NewStringType::kNormal).ToLocalChecked());
+      isolate, "hello world").ToLocalChecked());
 }
 
 void CreateFunction(const FunctionCallbackInfo<Value>& args) {
@@ -765,7 +757,7 @@ void CreateFunction(const FunctionCallbackInfo<Value>& args) {
 
   // omit this to make it anonymous
   fn->SetName(String::NewFromUtf8(
-      isolate, "theFunction", NewStringType::kNormal).ToLocalChecked());
+      isolate, "theFunction").ToLocalChecked());
 
   args.GetReturnValue().Set(fn);
 }
@@ -861,7 +853,6 @@ using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
@@ -885,8 +876,7 @@ void MyObject::Init(Local<Object> exports) {
 
   // Prepare constructor template
   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, "MyObject", NewStringType::kNormal).ToLocalChecked());
+  tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   // Prototype
@@ -895,8 +885,8 @@ void MyObject::Init(Local<Object> exports) {
   Local<Function> constructor = tpl->GetFunction(context).ToLocalChecked();
   addon_data->SetInternalField(0, constructor);
   exports->Set(context, String::NewFromUtf8(
-      isolate, "MyObject", NewStringType::kNormal).ToLocalChecked(),
-               constructor).FromJust();
+      isolate, "MyObject").ToLocalChecked(),
+      constructor).FromJust();
 }
 
 void MyObject::New(const FunctionCallbackInfo<Value>& args) {
@@ -1066,7 +1056,6 @@ using v8::FunctionTemplate;
 using v8::Global;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Number;
 using v8::Object;
 using v8::String;
@@ -1085,8 +1074,7 @@ MyObject::~MyObject() {
 void MyObject::Init(Isolate* isolate) {
   // Prepare constructor template
   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, "MyObject", NewStringType::kNormal).ToLocalChecked());
+  tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   // Prototype
@@ -1290,7 +1278,6 @@ using v8::FunctionTemplate;
 using v8::Global;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
@@ -1308,8 +1295,7 @@ MyObject::~MyObject() {
 void MyObject::Init(Isolate* isolate) {
   // Prepare constructor template
   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, "MyObject", NewStringType::kNormal).ToLocalChecked());
+  tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   Local<Context> context = isolate->GetCurrentContext();
@@ -1372,16 +1358,17 @@ console.log(result);
 // Prints: 30
 ```
 
-[`Worker`]: worker_threads.html#worker_threads_class_worker
 [Electron]: https://electronjs.org/
 [Embedder's Guide]: https://github.com/v8/v8/wiki/Embedder's%20Guide
 [Linking to libraries included with Node.js]: #addons_linking_to_libraries_included_with_node_js
 [Native Abstractions for Node.js]: https://github.com/nodejs/nan
+[V8]: https://v8.dev/
+[`Worker`]: worker_threads.md#worker_threads_class_worker
 [bindings]: https://github.com/TooTallNate/node-bindings
 [download]: https://github.com/nodejs/node-addon-examples
-[examples]: https://github.com/nodejs/nan/tree/master/examples/
+[examples]: https://github.com/nodejs/nan/tree/HEAD/examples/
 [installation instructions]: https://github.com/nodejs/node-gyp#installation
 [libuv]: https://github.com/libuv/libuv
 [node-gyp]: https://github.com/nodejs/node-gyp
-[require]: modules.html#modules_require_id
+[require]: modules.md#modules_require_id
 [v8-docs]: https://v8docs.nodesource.com/
diff --git a/doc/api/all.html b/doc/api/all.html
index 7dcf5e1f6549abaa7a5125b4ee146e18a1ca9522..f0a5196213a7b55e425e0c6797023b9a270eb119 100644
--- a/doc/api/all.html
+++ b/doc/api/all.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="all" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/all.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/all.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/all.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/all.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/all.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/all.html">13.x</a></li>
@@ -124,14 +139,13 @@
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        
-      <ul>
+      <!-- TOC --><details id="toc" open><summary>Table of contents</summary>
+<ul>
 <li><a href="#documentation_about_this_documentation">About this documentation</a>
 <ul>
 <li><a href="#documentation_contributing">Contributing</a></li>
 <li><a href="#documentation_stability_index">Stability index</a></li>
+<li><a href="#documentation_stability_overview">Stability overview</a></li>
 <li><a href="#documentation_json_output">JSON output</a></li>
 <li><a href="#documentation_system_calls_and_man_pages">System calls and man pages</a></li>
 </ul>
@@ -153,6 +167,7 @@
 </li>
 <li><span class="stability_1"><a href="#assert_class_assert_calltracker">Class: <code>assert.CallTracker</code></a></span>
 <ul>
+<li><a href="#assert_new_assert_calltracker"><code>new assert.CallTracker()</code></a></li>
 <li><a href="#assert_tracker_calls_fn_exact"><code>tracker.calls([fn][, exact])</code></a></li>
 <li><a href="#assert_tracker_report"><code>tracker.report()</code></a></li>
 <li><a href="#assert_tracker_verify"><code>tracker.verify()</code></a></li>
@@ -190,18 +205,13 @@
 <li><span class="stability_1"><a href="#async_hooks_async_hooks">Async hooks</a></span>
 <ul>
 <li><a href="#async_hooks_terminology">Terminology</a></li>
-<li><a href="#async_hooks_public_api">Public API</a>
-<ul>
-<li><a href="#async_hooks_overview">Overview</a>
-<ul>
+<li><a href="#async_hooks_overview">Overview</a></li>
 <li><a href="#async_hooks_async_hooks_createhook_callbacks"><code>async_hooks.createHook(callbacks)</code></a>
 <ul>
 <li><a href="#async_hooks_error_handling">Error handling</a></li>
 <li><a href="#async_hooks_printing_in_asynchooks_callbacks">Printing in AsyncHooks callbacks</a></li>
 </ul>
 </li>
-</ul>
-</li>
 <li><a href="#async_hooks_class_asynchook">Class: <code>AsyncHook</code></a>
 <ul>
 <li><a href="#async_hooks_asynchook_enable"><code>asyncHook.enable()</code></a></li>
@@ -227,8 +237,6 @@
 <li><a href="#async_hooks_async_hooks_triggerasyncid"><code>async_hooks.triggerAsyncId()</code></a></li>
 </ul>
 </li>
-</ul>
-</li>
 <li><a href="#async_hooks_promise_execution_tracking">Promise execution tracking</a></li>
 <li><a href="#async_hooks_javascript_embedder_api">JavaScript embedder API</a>
 <ul>
@@ -266,6 +274,17 @@
 <li><a href="#buffer_buffers_and_character_encodings">Buffers and character encodings</a></li>
 <li><a href="#buffer_buffers_and_typedarrays">Buffers and TypedArrays</a></li>
 <li><a href="#buffer_buffers_and_iteration">Buffers and iteration</a></li>
+<li><span class="stability_1"><a href="#buffer_class_blob">Class: <code>Blob</code></a></span>
+<ul>
+<li><a href="#buffer_new_buffer_blob_sources_options"><code>new buffer.Blob([sources[, options]])</code></a></li>
+<li><a href="#buffer_blob_arraybuffer"><code>blob.arrayBuffer()</code></a></li>
+<li><a href="#buffer_blob_size"><code>blob.size</code></a></li>
+<li><a href="#buffer_blob_slice_start_end_type"><code>blob.slice([start, [end, [type]]])</code></a></li>
+<li><a href="#buffer_blob_text"><code>blob.text()</code></a></li>
+<li><a href="#buffer_blob_type"><code>blob.type</code></a></li>
+<li><a href="#buffer_blob_objects_and_messagechannel"><code>Blob</code> objects and <code>MessageChannel</code></a></li>
+</ul>
+</li>
 <li><a href="#buffer_class_buffer">Class: <code>Buffer</code></a>
 <ul>
 <li><a href="#buffer_static_method_buffer_alloc_size_fill_encoding">Static method: <code>Buffer.alloc(size[, fill[, encoding]])</code></a></li>
@@ -358,8 +377,11 @@
 </li>
 <li><a href="#buffer_buffer_module_apis"><code>buffer</code> module APIs</a>
 <ul>
+<li><a href="#buffer_buffer_atob_data"><code>buffer.atob(data)</code></a></li>
+<li><a href="#buffer_buffer_btoa_data"><code>buffer.btoa(data)</code></a></li>
 <li><a href="#buffer_buffer_inspect_max_bytes"><code>buffer.INSPECT_MAX_BYTES</code></a></li>
 <li><a href="#buffer_buffer_kmaxlength"><code>buffer.kMaxLength</code></a></li>
+<li><a href="#buffer_buffer_kstringmaxlength"><code>buffer.kStringMaxLength</code></a></li>
 <li><a href="#buffer_buffer_transcode_source_fromenc_toenc"><code>buffer.transcode(source, fromEnc, toEnc)</code></a></li>
 <li><span class="stability_0"><a href="#buffer_class_slowbuffer">Class: <code>SlowBuffer</code></a></span>
 <ul>
@@ -376,7 +398,7 @@
 </li>
 <li><a href="#buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe"><code>Buffer.from()</code>, <code>Buffer.alloc()</code>, and <code>Buffer.allocUnsafe()</code></a>
 <ul>
-<li><a href="#buffer_the_zero_fill_buffers_command_line_option">The <code>--zero-fill-buffers</code> command line option</a></li>
+<li><a href="#buffer_the_zero_fill_buffers_command_line_option">The <code>--zero-fill-buffers</code> command-line option</a></li>
 <li><a href="#buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe">What makes <code>Buffer.allocUnsafe()</code> and <code>Buffer.allocUnsafeSlow()</code> "unsafe"?</a></li>
 </ul>
 </li>
@@ -397,7 +419,7 @@
 </ul>
 </li>
 <li><a href="#addons_native_abstractions_for_node_js">Native abstractions for Node.js</a></li>
-<li><a href="#addons_n_api">N-API</a></li>
+<li><span class="stability_2"><a href="#addons_node_api">Node-API</a></span></li>
 <li><a href="#addons_addon_examples">Addon examples</a>
 <ul>
 <li><a href="#addons_function_arguments">Function arguments</a></li>
@@ -411,7 +433,7 @@
 </li>
 </ul>
 </li>
-<li><span class="stability_2"><a href="#n_api_n_api">N-API</a></span>
+<li><span class="stability_2"><a href="#n_api_node_api">Node-API</a></span>
 <ul>
 <li><a href="#n_api_implications_of_abi_stability">Implications of ABI stability</a></li>
 <li><a href="#n_api_building">Building</a>
@@ -432,14 +454,14 @@
 </ul>
 </li>
 <li><a href="#n_api_usage">Usage</a></li>
-<li><a href="#n_api_n_api_version_matrix">N-API version matrix</a></li>
+<li><a href="#n_api_node_api_version_matrix">Node-API version matrix</a></li>
 <li><a href="#n_api_environment_life_cycle_apis">Environment life cycle APIs</a>
 <ul>
 <li><a href="#n_api_napi_set_instance_data">napi_set_instance_data</a></li>
 <li><a href="#n_api_napi_get_instance_data">napi_get_instance_data</a></li>
 </ul>
 </li>
-<li><a href="#n_api_basic_n_api_data_types">Basic N-API data types</a>
+<li><a href="#n_api_basic_node_api_data_types">Basic Node-API data types</a>
 <ul>
 <li><a href="#n_api_napi_status">napi_status</a></li>
 <li><a href="#n_api_napi_extended_error_info">napi_extended_error_info</a></li>
@@ -448,7 +470,7 @@
 <li><a href="#n_api_napi_threadsafe_function">napi_threadsafe_function</a></li>
 <li><a href="#n_api_napi_threadsafe_function_release_mode">napi_threadsafe_function_release_mode</a></li>
 <li><a href="#n_api_napi_threadsafe_function_call_mode">napi_threadsafe_function_call_mode</a></li>
-<li><a href="#n_api_n_api_memory_management_types">N-API memory management types</a>
+<li><a href="#n_api_node_api_memory_management_types">Node-API memory management types</a>
 <ul>
 <li><a href="#n_api_napi_handle_scope">napi_handle_scope</a></li>
 <li><a href="#n_api_napi_escapable_handle_scope">napi_escapable_handle_scope</a></li>
@@ -457,7 +479,7 @@
 <li><a href="#n_api_napi_async_cleanup_hook_handle">napi_async_cleanup_hook_handle</a></li>
 </ul>
 </li>
-<li><a href="#n_api_n_api_callback_types">N-API callback types</a>
+<li><a href="#n_api_node_api_callback_types">Node-API callback types</a>
 <ul>
 <li><a href="#n_api_napi_callback_info">napi_callback_info</a></li>
 <li><a href="#n_api_napi_callback">napi_callback</a></li>
@@ -558,7 +580,7 @@
 <li><a href="#n_api_napi_create_dataview">napi_create_dataview</a></li>
 </ul>
 </li>
-<li><a href="#n_api_functions_to_convert_from_c_types_to_n_api">Functions to convert from C types to N-API</a>
+<li><a href="#n_api_functions_to_convert_from_c_types_to_node_api">Functions to convert from C types to Node-API</a>
 <ul>
 <li><a href="#n_api_napi_create_int32">napi_create_int32</a></li>
 <li><a href="#n_api_napi_create_uint32">napi_create_uint32</a></li>
@@ -572,7 +594,7 @@
 <li><a href="#n_api_napi_create_string_utf8">napi_create_string_utf8</a></li>
 </ul>
 </li>
-<li><a href="#n_api_functions_to_convert_from_n_api_to_c_types">Functions to convert from N-API to C types</a>
+<li><a href="#n_api_functions_to_convert_from_node_api_to_c_types">Functions to convert from Node-API to C types</a>
 <ul>
 <li><a href="#n_api_napi_get_array_length">napi_get_array_length</a></li>
 <li><a href="#n_api_napi_get_arraybuffer_info">napi_get_arraybuffer_info</a></li>
@@ -740,7 +762,7 @@
 <li><span class="stability_1"><a href="#n_api_node_api_get_module_file_name">node_api_get_module_file_name</a></span></li>
 </ul>
 </li>
-<li><a href="#embedding_c_embedder_api">C++ Embedder API</a>
+<li><a href="#embedding_c_embedder_api">C++ embedder API</a>
 <ul>
 <li><a href="#embedding_example_embedding_application">Example embedding application</a>
 <ul>
@@ -780,7 +802,13 @@
 <li><a href="#child_process_event_error">Event: <code>'error'</code></a></li>
 <li><a href="#child_process_event_exit">Event: <code>'exit'</code></a></li>
 <li><a href="#child_process_event_message">Event: <code>'message'</code></a></li>
-<li><a href="#child_process_subprocess_channel"><code>subprocess.channel</code></a></li>
+<li><a href="#child_process_event_spawn">Event: <code>'spawn'</code></a></li>
+<li><a href="#child_process_subprocess_channel"><code>subprocess.channel</code></a>
+<ul>
+<li><a href="#child_process_subprocess_channel_ref"><code>subprocess.channel.ref()</code></a></li>
+<li><a href="#child_process_subprocess_channel_unref"><code>subprocess.channel.unref()</code></a></li>
+</ul>
+</li>
 <li><a href="#child_process_subprocess_connected"><code>subprocess.connected</code></a></li>
 <li><a href="#child_process_subprocess_disconnect"><code>subprocess.disconnect()</code></a></li>
 <li><a href="#child_process_subprocess_exitcode"><code>subprocess.exitCode</code></a></li>
@@ -849,7 +877,7 @@
 <li><a href="#cluster_cluster_workers"><code>cluster.workers</code></a></li>
 </ul>
 </li>
-<li><a href="#cli_command_line_options">Command line options</a>
+<li><a href="#cli_command_line_options">Command-line options</a>
 <ul>
 <li><a href="#cli_synopsis">Synopsis</a></li>
 <li><a href="#cli_options">Options</a>
@@ -858,7 +886,7 @@
 <li><a href="#cli_1"><code>--</code></a></li>
 <li><a href="#cli_abort_on_uncaught_exception"><code>--abort-on-uncaught-exception</code></a></li>
 <li><a href="#cli_completion_bash"><code>--completion-bash</code></a></li>
-<li><span class="stability_1"><a href="#cli_conditions_condition"><code>--conditions=condition</code></a></span></li>
+<li><span class="stability_1"><a href="#cli_c_condition_conditions_condition"><code>-C=condition</code>, <code>--conditions=condition</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_cpu_prof"><code>--cpu-prof</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_cpu_prof_dir"><code>--cpu-prof-dir</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_cpu_prof_interval"><code>--cpu-prof-interval</code></a></span></li>
@@ -866,8 +894,10 @@
 <li><a href="#cli_diagnostic_dir_directory"><code>--diagnostic-dir=directory</code></a></li>
 <li><a href="#cli_disable_proto_mode"><code>--disable-proto=mode</code></a></li>
 <li><a href="#cli_disallow_code_generation_from_strings"><code>--disallow-code-generation-from-strings</code></a></li>
+<li><a href="#cli_dns_result_order_order"><code>--dns-result-order=order</code></a></li>
 <li><a href="#cli_enable_fips"><code>--enable-fips</code></a></li>
-<li><span class="stability_1"><a href="#cli_enable_source_maps"><code>--enable-source-maps</code></a></span></li>
+<li><a href="#cli_enable_source_maps"><code>--enable-source-maps</code></a></li>
+<li><a href="#cli_experimental_abortcontroller"><code>--experimental-abortcontroller</code></a></li>
 <li><a href="#cli_experimental_import_meta_resolve"><code>--experimental-import-meta-resolve</code></a></li>
 <li><a href="#cli_experimental_json_modules"><code>--experimental-json-modules</code></a></li>
 <li><a href="#cli_experimental_loader_module"><code>--experimental-loader=module</code></a></li>
@@ -881,13 +911,12 @@
 <li><a href="#cli_force_context_aware"><code>--force-context-aware</code></a></li>
 <li><a href="#cli_force_fips"><code>--force-fips</code></a></li>
 <li><span class="stability_1"><a href="#cli_frozen_intrinsics"><code>--frozen-intrinsics</code></a></span></li>
+<li><span class="stability_1"><a href="#cli_heapsnapshot_near_heap_limit_max_count"><code>--heapsnapshot-near-heap-limit=max_count</code></a></span></li>
 <li><a href="#cli_heapsnapshot_signal_signal"><code>--heapsnapshot-signal=signal</code></a></li>
 <li><span class="stability_1"><a href="#cli_heap_prof"><code>--heap-prof</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_heap_prof_dir"><code>--heap-prof-dir</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_heap_prof_interval"><code>--heap-prof-interval</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_heap_prof_name"><code>--heap-prof-name</code></a></span></li>
-<li><a href="#cli_http_parser_library"><code>--http-parser=library</code></a></li>
-<li><a href="#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout=milliseconds</code></a></li>
 <li><a href="#cli_icu_data_dir_file"><code>--icu-data-dir=file</code></a></li>
 <li><a href="#cli_input_type_type"><code>--input-type=type</code></a></li>
 <li><a href="#cli_inspect_brk_host_port"><code>--inspect-brk[=[host:]port]</code></a></li>
@@ -905,6 +934,7 @@
 <li><a href="#cli_no_deprecation"><code>--no-deprecation</code></a></li>
 <li><a href="#cli_no_force_async_hooks_checks"><code>--no-force-async-hooks-checks</code></a></li>
 <li><a href="#cli_no_warnings"><code>--no-warnings</code></a></li>
+<li><a href="#cli_node_memory_debug"><code>--node-memory-debug</code></a></li>
 <li><a href="#cli_openssl_config_file"><code>--openssl-config=file</code></a></li>
 <li><a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a></li>
 <li><span class="stability_1"><a href="#cli_policy_integrity_sri"><code>--policy-integrity=sri</code></a></span></li>
@@ -930,6 +960,7 @@
 <li><a href="#cli_tls_min_v1_1"><code>--tls-min-v1.1</code></a></li>
 <li><a href="#cli_tls_min_v1_2"><code>--tls-min-v1.2</code></a></li>
 <li><a href="#cli_tls_min_v1_3"><code>--tls-min-v1.3</code></a></li>
+<li><a href="#cli_trace_atomics_wait"><code>--trace-atomics-wait</code></a></li>
 <li><a href="#cli_trace_deprecation"><code>--trace-deprecation</code></a></li>
 <li><a href="#cli_trace_event_categories"><code>--trace-event-categories</code></a></li>
 <li><a href="#cli_trace_event_file_pattern"><code>--trace-event-file-pattern</code></a></li>
@@ -958,6 +989,7 @@
 </li>
 <li><a href="#cli_environment_variables">Environment variables</a>
 <ul>
+<li><a href="#cli_force_color_1_2_3"><code>FORCE_COLOR=[1, 2, 3]</code></a></li>
 <li><a href="#cli_node_debug_module"><code>NODE_DEBUG=module[,…]</code></a></li>
 <li><a href="#cli_node_debug_native_module"><code>NODE_DEBUG_NATIVE=module[,…]</code></a></li>
 <li><a href="#cli_node_disable_colors_1"><code>NODE_DISABLE_COLORS=1</code></a></li>
@@ -972,13 +1004,15 @@
 <li><a href="#cli_node_redirect_warnings_file"><code>NODE_REDIRECT_WARNINGS=file</code></a></li>
 <li><a href="#cli_node_repl_history_file"><code>NODE_REPL_HISTORY=file</code></a></li>
 <li><a href="#cli_node_repl_external_module_file"><code>NODE_REPL_EXTERNAL_MODULE=file</code></a></li>
+<li><a href="#cli_node_skip_platform_check_value"><code>NODE_SKIP_PLATFORM_CHECK=value</code></a></li>
 <li><a href="#cli_node_tls_reject_unauthorized_value"><code>NODE_TLS_REJECT_UNAUTHORIZED=value</code></a></li>
 <li><a href="#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE=dir</code></a>
 <ul>
 <li><a href="#cli_coverage_output">Coverage output</a></li>
-<li><a href="#cli_source_map_cache">Source map cache</a></li>
+<li><span class="stability_1"><a href="#cli_source_map_cache">Source map cache</a></span></li>
 </ul>
 </li>
+<li><a href="#cli_no_color_any"><code>NO_COLOR=&#x3C;any></code></a></li>
 <li><a href="#cli_openssl_conf_file"><code>OPENSSL_CONF=file</code></a></li>
 <li><a href="#cli_ssl_cert_dir_dir"><code>SSL_CERT_DIR=dir</code></a></li>
 <li><a href="#cli_ssl_cert_file_file"><code>SSL_CERT_FILE=file</code></a></li>
@@ -1036,7 +1070,7 @@
 <li><a href="#crypto_certificate_exportchallenge_spkac"><code>Certificate.exportChallenge(spkac)</code></a></li>
 <li><a href="#crypto_certificate_exportpublickey_spkac_encoding"><code>Certificate.exportPublicKey(spkac[, encoding])</code></a></li>
 <li><a href="#crypto_certificate_verifyspkac_spkac"><code>Certificate.verifySpkac(spkac)</code></a></li>
-<li><a href="#crypto_legacy_api">Legacy API</a>
+<li><span class="stability_0"><a href="#crypto_legacy_api">Legacy API</a></span>
 <ul>
 <li><a href="#crypto_new_crypto_certificate"><code>new crypto.Certificate()</code></a></li>
 <li><a href="#crypto_certificate_exportchallenge_spkac_1"><code>certificate.exportChallenge(spkac)</code></a></li>
@@ -1049,8 +1083,8 @@
 <li><a href="#crypto_class_cipher">Class: <code>Cipher</code></a>
 <ul>
 <li><a href="#crypto_cipher_final_outputencoding"><code>cipher.final([outputEncoding])</code></a></li>
-<li><a href="#crypto_cipher_setaad_buffer_options"><code>cipher.setAAD(buffer[, options])</code></a></li>
 <li><a href="#crypto_cipher_getauthtag"><code>cipher.getAuthTag()</code></a></li>
+<li><a href="#crypto_cipher_setaad_buffer_options"><code>cipher.setAAD(buffer[, options])</code></a></li>
 <li><a href="#crypto_cipher_setautopadding_autopadding"><code>cipher.setAutoPadding([autoPadding])</code></a></li>
 <li><a href="#crypto_cipher_update_data_inputencoding_outputencoding"><code>cipher.update(data[, inputEncoding][, outputEncoding])</code></a></li>
 </ul>
@@ -1160,6 +1194,7 @@
 <li><a href="#crypto_crypto_randomfillsync_buffer_offset_size"><code>crypto.randomFillSync(buffer[, offset][, size])</code></a></li>
 <li><a href="#crypto_crypto_randomfill_buffer_offset_size_callback"><code>crypto.randomFill(buffer[, offset][, size], callback)</code></a></li>
 <li><a href="#crypto_crypto_randomint_min_max_callback"><code>crypto.randomInt([min, ]max[, callback])</code></a></li>
+<li><a href="#crypto_crypto_randomuuid_options"><code>crypto.randomUUID([options])</code></a></li>
 <li><a href="#crypto_crypto_scrypt_password_salt_keylen_options_callback"><code>crypto.scrypt(password, salt, keylen[, options], callback)</code></a></li>
 <li><a href="#crypto_crypto_scryptsync_password_salt_keylen_options"><code>crypto.scryptSync(password, salt, keylen[, options])</code></a></li>
 <li><a href="#crypto_crypto_setengine_engine_flags"><code>crypto.setEngine(engine[, flags])</code></a></li>
@@ -1171,7 +1206,7 @@
 </li>
 <li><a href="#crypto_notes">Notes</a>
 <ul>
-<li><a href="#crypto_legacy_streams_api_prior_to_node_js_0_10">Legacy Streams API (prior to Node.js 0.10)</a></li>
+<li><a href="#crypto_legacy_streams_api_prior_to_node_js_0_10">Legacy streams API (prior to Node.js 0.10)</a></li>
 <li><a href="#crypto_recent_ecdh_changes">Recent ECDH changes</a></li>
 <li><a href="#crypto_support_for_weak_or_compromised_algorithms">Support for weak or compromised algorithms</a></li>
 <li><a href="#crypto_ccm_mode">CCM mode</a></li>
@@ -1211,141 +1246,174 @@
 <li><a href="#deprecations_revoking_deprecations">Revoking deprecations</a></li>
 <li><a href="#deprecations_list_of_deprecated_apis">List of deprecated APIs</a>
 <ul>
-<li><a href="#deprecations_dep0001_http_outgoingmessage_prototype_flush">DEP0001: <code>http.OutgoingMessage.prototype.flush</code></a></li>
-<li><a href="#deprecations_dep0002_require_linklist">DEP0002: <code>require('_linklist')</code></a></li>
-<li><a href="#deprecations_dep0003_writablestate_buffer">DEP0003: <code>_writableState.buffer</code></a></li>
-<li><a href="#deprecations_dep0004_cryptostream_prototype_readystate">DEP0004: <code>CryptoStream.prototype.readyState</code></a></li>
-<li><a href="#deprecations_dep0005_buffer_constructor">DEP0005: <code>Buffer()</code> constructor</a></li>
-<li><a href="#deprecations_dep0006_child_process_options_customfds">DEP0006: <code>child_process</code> <code>options.customFds</code></a></li>
-<li><a href="#deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect">DEP0007: Replace <code>cluster</code> <code>worker.suicide</code> with <code>worker.exitedAfterDisconnect</code></a></li>
-<li><a href="#deprecations_dep0008_require_constants">DEP0008: <code>require('constants')</code></a></li>
-<li><a href="#deprecations_dep0009_crypto_pbkdf2_without_digest">DEP0009: <code>crypto.pbkdf2</code> without digest</a></li>
-<li><a href="#deprecations_dep0010_crypto_createcredentials">DEP0010: <code>crypto.createCredentials</code></a></li>
-<li><a href="#deprecations_dep0011_crypto_credentials">DEP0011: <code>crypto.Credentials</code></a></li>
-<li><a href="#deprecations_dep0012_domain_dispose">DEP0012: <code>Domain.dispose</code></a></li>
-<li><a href="#deprecations_dep0013_fs_asynchronous_function_without_callback">DEP0013: <code>fs</code> asynchronous function without callback</a></li>
-<li><a href="#deprecations_dep0014_fs_read_legacy_string_interface">DEP0014: <code>fs.read</code> legacy String interface</a></li>
-<li><a href="#deprecations_dep0015_fs_readsync_legacy_string_interface">DEP0015: <code>fs.readSync</code> legacy String interface</a></li>
-<li><a href="#deprecations_dep0016_global_root">DEP0016: <code>GLOBAL</code>/<code>root</code></a></li>
-<li><a href="#deprecations_dep0017_intl_v8breakiterator">DEP0017: <code>Intl.v8BreakIterator</code></a></li>
-<li><a href="#deprecations_dep0018_unhandled_promise_rejections">DEP0018: Unhandled promise rejections</a></li>
-<li><a href="#deprecations_dep0019_require_resolved_outside_directory">DEP0019: <code>require('.')</code> resolved outside directory</a></li>
-<li><a href="#deprecations_dep0020_server_connections">DEP0020: <code>Server.connections</code></a></li>
-<li><a href="#deprecations_dep0021_server_listenfd">DEP0021: <code>Server.listenFD</code></a></li>
-<li><a href="#deprecations_dep0022_os_tmpdir">DEP0022: <code>os.tmpDir()</code></a></li>
-<li><a href="#deprecations_dep0023_os_getnetworkinterfaces">DEP0023: <code>os.getNetworkInterfaces()</code></a></li>
-<li><a href="#deprecations_dep0024_replserver_prototype_converttocontext">DEP0024: <code>REPLServer.prototype.convertToContext()</code></a></li>
-<li><a href="#deprecations_dep0025_require_sys">DEP0025: <code>require('sys')</code></a></li>
-<li><a href="#deprecations_dep0026_util_print">DEP0026: <code>util.print()</code></a></li>
-<li><a href="#deprecations_dep0027_util_puts">DEP0027: <code>util.puts()</code></a></li>
-<li><a href="#deprecations_dep0028_util_debug">DEP0028: <code>util.debug()</code></a></li>
-<li><a href="#deprecations_dep0029_util_error">DEP0029: <code>util.error()</code></a></li>
-<li><a href="#deprecations_dep0030_slowbuffer">DEP0030: <code>SlowBuffer</code></a></li>
-<li><a href="#deprecations_dep0031_ecdh_setpublickey">DEP0031: <code>ecdh.setPublicKey()</code></a></li>
-<li><a href="#deprecations_dep0032_domain_module">DEP0032: <code>domain</code> module</a></li>
-<li><a href="#deprecations_dep0033_eventemitter_listenercount">DEP0033: <code>EventEmitter.listenerCount()</code></a></li>
-<li><a href="#deprecations_dep0034_fs_exists_path_callback">DEP0034: <code>fs.exists(path, callback)</code></a></li>
-<li><a href="#deprecations_dep0035_fs_lchmod_path_mode_callback">DEP0035: <code>fs.lchmod(path, mode, callback)</code></a></li>
-<li><a href="#deprecations_dep0036_fs_lchmodsync_path_mode">DEP0036: <code>fs.lchmodSync(path, mode)</code></a></li>
-<li><a href="#deprecations_dep0037_fs_lchown_path_uid_gid_callback">DEP0037: <code>fs.lchown(path, uid, gid, callback)</code></a></li>
-<li><a href="#deprecations_dep0038_fs_lchownsync_path_uid_gid">DEP0038: <code>fs.lchownSync(path, uid, gid)</code></a></li>
-<li><a href="#deprecations_dep0039_require_extensions">DEP0039: <code>require.extensions</code></a></li>
-<li><a href="#deprecations_dep0040_punycode_module">DEP0040: <code>punycode</code> module</a></li>
-<li><a href="#deprecations_dep0041_node_repl_history_file_environment_variable">DEP0041: <code>NODE_REPL_HISTORY_FILE</code> environment variable</a></li>
-<li><a href="#deprecations_dep0042_tls_cryptostream">DEP0042: <code>tls.CryptoStream</code></a></li>
-<li><a href="#deprecations_dep0043_tls_securepair">DEP0043: <code>tls.SecurePair</code></a></li>
-<li><a href="#deprecations_dep0044_util_isarray">DEP0044: <code>util.isArray()</code></a></li>
-<li><a href="#deprecations_dep0045_util_isboolean">DEP0045: <code>util.isBoolean()</code></a></li>
-<li><a href="#deprecations_dep0046_util_isbuffer">DEP0046: <code>util.isBuffer()</code></a></li>
-<li><a href="#deprecations_dep0047_util_isdate">DEP0047: <code>util.isDate()</code></a></li>
-<li><a href="#deprecations_dep0048_util_iserror">DEP0048: <code>util.isError()</code></a></li>
-<li><a href="#deprecations_dep0049_util_isfunction">DEP0049: <code>util.isFunction()</code></a></li>
-<li><a href="#deprecations_dep0050_util_isnull">DEP0050: <code>util.isNull()</code></a></li>
-<li><a href="#deprecations_dep0051_util_isnullorundefined">DEP0051: <code>util.isNullOrUndefined()</code></a></li>
-<li><a href="#deprecations_dep0052_util_isnumber">DEP0052: <code>util.isNumber()</code></a></li>
-<li><a href="#deprecations_dep0053_util_isobject">DEP0053 <code>util.isObject()</code></a></li>
-<li><a href="#deprecations_dep0054_util_isprimitive">DEP0054: <code>util.isPrimitive()</code></a></li>
-<li><a href="#deprecations_dep0055_util_isregexp">DEP0055: <code>util.isRegExp()</code></a></li>
-<li><a href="#deprecations_dep0056_util_isstring">DEP0056: <code>util.isString()</code></a></li>
-<li><a href="#deprecations_dep0057_util_issymbol">DEP0057: <code>util.isSymbol()</code></a></li>
-<li><a href="#deprecations_dep0058_util_isundefined">DEP0058: <code>util.isUndefined()</code></a></li>
-<li><a href="#deprecations_dep0059_util_log">DEP0059: <code>util.log()</code></a></li>
-<li><a href="#deprecations_dep0060_util_extend">DEP0060: <code>util._extend()</code></a></li>
-<li><a href="#deprecations_dep0061_fs_syncwritestream">DEP0061: <code>fs.SyncWriteStream</code></a></li>
-<li><a href="#deprecations_dep0062_node_debug">DEP0062: <code>node --debug</code></a></li>
-<li><a href="#deprecations_dep0063_serverresponse_prototype_writeheader">DEP0063: <code>ServerResponse.prototype.writeHeader()</code></a></li>
-<li><a href="#deprecations_dep0064_tls_createsecurepair">DEP0064: <code>tls.createSecurePair()</code></a></li>
-<li><a href="#deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic">DEP0065: <code>repl.REPL_MODE_MAGIC</code> and <code>NODE_REPL_MODE=magic</code></a></li>
-<li><a href="#deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames">DEP0066: <code>OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames</code></a></li>
-<li><a href="#deprecations_dep0067_outgoingmessage_prototype_renderheaders">DEP0067: <code>OutgoingMessage.prototype._renderHeaders</code></a></li>
-<li><a href="#deprecations_dep0068_node_debug">DEP0068: <code>node debug</code></a></li>
-<li><a href="#deprecations_dep0069_vm_runindebugcontext_string">DEP0069: <code>vm.runInDebugContext(string)</code></a></li>
-<li><a href="#deprecations_dep0070_async_hooks_currentid">DEP0070: <code>async_hooks.currentId()</code></a></li>
-<li><a href="#deprecations_dep0071_async_hooks_triggerid">DEP0071: <code>async_hooks.triggerId()</code></a></li>
-<li><a href="#deprecations_dep0072_async_hooks_asyncresource_triggerid">DEP0072: <code>async_hooks.AsyncResource.triggerId()</code></a></li>
-<li><a href="#deprecations_dep0073_several_internal_properties_of_net_server">DEP0073: Several internal properties of <code>net.Server</code></a></li>
-<li><a href="#deprecations_dep0074_replserver_bufferedcommand">DEP0074: <code>REPLServer.bufferedCommand</code></a></li>
-<li><a href="#deprecations_dep0075_replserver_parsereplkeyword">DEP0075: <code>REPLServer.parseREPLKeyword()</code></a></li>
-<li><a href="#deprecations_dep0076_tls_parsecertstring">DEP0076: <code>tls.parseCertString()</code></a></li>
-<li><a href="#deprecations_dep0077_module_debug">DEP0077: <code>Module._debug()</code></a></li>
-<li><a href="#deprecations_dep0078_replserver_turnoffeditormode">DEP0078: <code>REPLServer.turnOffEditorMode()</code></a></li>
-<li><a href="#deprecations_dep0079_custom_inspection_function_on_objects_via_inspect">DEP0079: Custom inspection function on objects via <code>.inspect()</code></a></li>
-<li><a href="#deprecations_dep0080_path_makelong">DEP0080: <code>path._makeLong()</code></a></li>
-<li><a href="#deprecations_dep0081_fs_truncate_using_a_file_descriptor">DEP0081: <code>fs.truncate()</code> using a file descriptor</a></li>
-<li><a href="#deprecations_dep0082_replserver_prototype_memory">DEP0082: <code>REPLServer.prototype.memory()</code></a></li>
-<li><a href="#deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false">DEP0083: Disabling ECDH by setting <code>ecdhCurve</code> to <code>false</code></a></li>
-<li><a href="#deprecations_dep0084_requiring_bundled_internal_dependencies">DEP0084: requiring bundled internal dependencies</a></li>
-<li><a href="#deprecations_dep0085_asynchooks_sensitive_api">DEP0085: AsyncHooks sensitive API</a></li>
-<li><a href="#deprecations_dep0086_remove_runinasyncidscope">DEP0086: Remove <code>runInAsyncIdScope</code></a></li>
-<li><a href="#deprecations_dep0089_require_assert">DEP0089: <code>require('assert')</code></a></li>
-<li><a href="#deprecations_dep0090_invalid_gcm_authentication_tag_lengths">DEP0090: Invalid GCM authentication tag lengths</a></li>
-<li><a href="#deprecations_dep0091_crypto_default_encoding">DEP0091: <code>crypto.DEFAULT_ENCODING</code></a></li>
-<li><a href="#deprecations_dep0092_top_level_this_bound_to_module_exports">DEP0092: Top-level <code>this</code> bound to <code>module.exports</code></a></li>
-<li><a href="#deprecations_dep0093_crypto_fips_is_deprecated_and_replaced">DEP0093: <code>crypto.fips</code> is deprecated and replaced.</a></li>
-<li><a href="#deprecations_dep0094_using_assert_fail_with_more_than_one_argument">DEP0094: Using <code>assert.fail()</code> with more than one argument.</a></li>
-<li><a href="#deprecations_dep0095_timers_enroll">DEP0095: <code>timers.enroll()</code></a></li>
-<li><a href="#deprecations_dep0096_timers_unenroll">DEP0096: <code>timers.unenroll()</code></a></li>
-<li><a href="#deprecations_dep0097_makecallback_with_domain_property">DEP0097: <code>MakeCallback</code> with <code>domain</code> property</a></li>
-<li><a href="#deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis">DEP0098: AsyncHooks embedder <code>AsyncResource.emitBefore</code> and <code>AsyncResource.emitAfter</code> APIs</a></li>
-<li><a href="#deprecations_dep0099_async_context_unaware_node_makecallback_c_apis">DEP0099: Async context-unaware <code>node::MakeCallback</code> C++ APIs</a></li>
-<li><a href="#deprecations_dep0100_process_assert">DEP0100: <code>process.assert()</code></a></li>
-<li><a href="#deprecations_dep0101_with_lttng">DEP0101: <code>--with-lttng</code></a></li>
-<li><a href="#deprecations_dep0102_using_noassert_in_buffer_read_write_operations">DEP0102: Using <code>noAssert</code> in <code>Buffer#(read|write)</code> operations.</a></li>
-<li><a href="#deprecations_dep0103_process_binding_util_is_typechecks">DEP0103: <code>process.binding('util').is[...]</code> typechecks</a></li>
-<li><a href="#deprecations_dep0104_process_env_string_coercion">DEP0104: <code>process.env</code> string coercion</a></li>
-<li><a href="#deprecations_dep0105_decipher_finaltol">DEP0105: <code>decipher.finaltol</code></a></li>
-<li><a href="#deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher">DEP0106: <code>crypto.createCipher</code> and <code>crypto.createDecipher</code></a></li>
-<li><a href="#deprecations_dep0107_tls_convertnpnprotocols">DEP0107: <code>tls.convertNPNProtocols()</code></a></li>
-<li><a href="#deprecations_dep0108_zlib_bytesread">DEP0108: <code>zlib.bytesRead</code></a></li>
-<li><a href="#deprecations_dep0109_http_https_and_tls_support_for_invalid_urls">DEP0109: <code>http</code>, <code>https</code>, and <code>tls</code> support for invalid URLs</a></li>
-<li><a href="#deprecations_dep0110_vm_script_cached_data">DEP0110: <code>vm.Script</code> cached data</a></li>
-<li><a href="#deprecations_dep0111_process_binding">DEP0111: <code>process.binding()</code></a></li>
-<li><a href="#deprecations_dep0112_dgram_private_apis">DEP0112: <code>dgram</code> private APIs</a></li>
-<li><a href="#deprecations_dep0113_cipher_setauthtag_decipher_getauthtag">DEP0113: <code>Cipher.setAuthTag()</code>, <code>Decipher.getAuthTag()</code></a></li>
-<li><a href="#deprecations_dep0114_crypto_tobuf">DEP0114: <code>crypto._toBuf()</code></a></li>
-<li><a href="#deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng">DEP0115: <code>crypto.prng()</code>, <code>crypto.pseudoRandomBytes()</code>, <code>crypto.rng()</code></a></li>
-<li><a href="#deprecations_dep0116_legacy_url_api">DEP0116: Legacy URL API</a></li>
-<li><a href="#deprecations_dep0117_native_crypto_handles">DEP0117: Native crypto handles</a></li>
-<li><a href="#deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name">DEP0118: <code>dns.lookup()</code> support for a falsy host name</a></li>
-<li><a href="#deprecations_dep0119_process_binding_uv_errname_private_api">DEP0119: <code>process.binding('uv').errname()</code> private API</a></li>
-<li><a href="#deprecations_dep0120_windows_performance_counter_support">DEP0120: Windows Performance Counter support</a></li>
-<li><a href="#deprecations_dep0121_net_setsimultaneousaccepts">DEP0121: <code>net._setSimultaneousAccepts()</code></a></li>
-<li><a href="#deprecations_dep0122_tls_server_prototype_setoptions">DEP0122: <code>tls</code> <code>Server.prototype.setOptions()</code></a></li>
-<li><a href="#deprecations_dep0123_setting_the_tls_servername_to_an_ip_address">DEP0123: setting the TLS ServerName to an IP address</a></li>
-<li><a href="#deprecations_dep0124_using_replserver_rli">DEP0124: using <code>REPLServer.rli</code></a></li>
-<li><a href="#deprecations_dep0125_require_stream_wrap">DEP0125: <code>require('_stream_wrap')</code></a></li>
-<li><a href="#deprecations_dep0126_timers_active">DEP0126: <code>timers.active()</code></a></li>
-<li><a href="#deprecations_dep0127_timers_unrefactive">DEP0127: <code>timers._unrefActive()</code></a></li>
-<li><a href="#deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file">DEP0128: modules with an invalid <code>main</code> entry and an <code>index.js</code> file</a></li>
-<li><a href="#deprecations_dep0129_childprocess_channel">DEP0129: <code>ChildProcess._channel</code></a></li>
-<li><a href="#deprecations_dep0130_module_createrequirefrompath">DEP0130: <code>Module.createRequireFromPath()</code></a></li>
-<li><a href="#deprecations_dep0131_legacy_http_parser">DEP0131: Legacy HTTP parser</a></li>
-<li><a href="#deprecations_dep0132_worker_terminate_with_callback">DEP0132: <code>worker.terminate()</code> with callback</a></li>
-<li><a href="#deprecations_dep0133_http_connection">DEP0133: <code>http</code> <code>connection</code></a></li>
-<li><a href="#deprecations_dep0134_process_tickcallback">DEP0134: <code>process._tickCallback</code></a></li>
-<li><a href="#deprecations_dep0136_http_finished">DEP0136: <code>http</code> <code>finished</code></a></li>
-<li><a href="#deprecations_dep0139_process_umask_with_no_arguments">DEP0139: <code>process.umask()</code> with no arguments</a></li>
-<li><a href="#deprecations_dep0144_module_parent">DEP0144: <code>module.parent</code></a></li>
+<li><a href="#DEP0001">DEP0001: <code>http.OutgoingMessage.prototype.flush</code></a></li>
+<li><a href="#DEP0002">DEP0002: <code>require('_linklist')</code></a></li>
+<li><a href="#DEP0003">DEP0003: <code>_writableState.buffer</code></a></li>
+<li><a href="#DEP0004">DEP0004: <code>CryptoStream.prototype.readyState</code></a></li>
+<li><a href="#DEP0005">DEP0005: <code>Buffer()</code> constructor</a></li>
+<li><a href="#DEP0006">DEP0006: <code>child_process</code> <code>options.customFds</code></a></li>
+<li><a href="#DEP0007">DEP0007: Replace <code>cluster</code> <code>worker.suicide</code> with <code>worker.exitedAfterDisconnect</code></a></li>
+<li><a href="#DEP0008">DEP0008: <code>require('constants')</code></a></li>
+<li><a href="#DEP0009">DEP0009: <code>crypto.pbkdf2</code> without digest</a></li>
+<li><a href="#DEP0010">DEP0010: <code>crypto.createCredentials</code></a></li>
+<li><a href="#DEP0011">DEP0011: <code>crypto.Credentials</code></a></li>
+<li><a href="#DEP0012">DEP0012: <code>Domain.dispose</code></a></li>
+<li><a href="#DEP0013">DEP0013: <code>fs</code> asynchronous function without callback</a></li>
+<li><a href="#DEP0014">DEP0014: <code>fs.read</code> legacy String interface</a></li>
+<li><a href="#DEP0015">DEP0015: <code>fs.readSync</code> legacy String interface</a></li>
+<li><a href="#DEP0016">DEP0016: <code>GLOBAL</code>/<code>root</code></a></li>
+<li><a href="#DEP0017">DEP0017: <code>Intl.v8BreakIterator</code></a></li>
+<li><a href="#DEP0018">DEP0018: Unhandled promise rejections</a></li>
+<li><a href="#DEP0019">DEP0019: <code>require('.')</code> resolved outside directory</a></li>
+<li><a href="#DEP0020">DEP0020: <code>Server.connections</code></a></li>
+<li><a href="#DEP0021">DEP0021: <code>Server.listenFD</code></a></li>
+<li><a href="#DEP0022">DEP0022: <code>os.tmpDir()</code></a></li>
+<li><a href="#DEP0023">DEP0023: <code>os.getNetworkInterfaces()</code></a></li>
+<li><a href="#DEP0024">DEP0024: <code>REPLServer.prototype.convertToContext()</code></a></li>
+<li><a href="#DEP0025">DEP0025: <code>require('sys')</code></a></li>
+<li><a href="#DEP0026">DEP0026: <code>util.print()</code></a></li>
+<li><a href="#DEP0027">DEP0027: <code>util.puts()</code></a></li>
+<li><a href="#DEP0028">DEP0028: <code>util.debug()</code></a></li>
+<li><a href="#DEP0029">DEP0029: <code>util.error()</code></a></li>
+<li><a href="#DEP0030">DEP0030: <code>SlowBuffer</code></a></li>
+<li><a href="#DEP0031">DEP0031: <code>ecdh.setPublicKey()</code></a></li>
+<li><a href="#DEP0032">DEP0032: <code>domain</code> module</a></li>
+<li><a href="#DEP0033">DEP0033: <code>EventEmitter.listenerCount()</code></a></li>
+<li><a href="#DEP0034">DEP0034: <code>fs.exists(path, callback)</code></a></li>
+<li><a href="#DEP0035">DEP0035: <code>fs.lchmod(path, mode, callback)</code></a></li>
+<li><a href="#DEP0036">DEP0036: <code>fs.lchmodSync(path, mode)</code></a></li>
+<li><a href="#DEP0037">DEP0037: <code>fs.lchown(path, uid, gid, callback)</code></a></li>
+<li><a href="#DEP0038">DEP0038: <code>fs.lchownSync(path, uid, gid)</code></a></li>
+<li><a href="#DEP0039">DEP0039: <code>require.extensions</code></a></li>
+<li><a href="#DEP0040">DEP0040: <code>punycode</code> module</a></li>
+<li><a href="#DEP0041">DEP0041: <code>NODE_REPL_HISTORY_FILE</code> environment variable</a></li>
+<li><a href="#DEP0042">DEP0042: <code>tls.CryptoStream</code></a></li>
+<li><a href="#DEP0043">DEP0043: <code>tls.SecurePair</code></a></li>
+<li><a href="#DEP0044">DEP0044: <code>util.isArray()</code></a></li>
+<li><a href="#DEP0045">DEP0045: <code>util.isBoolean()</code></a></li>
+<li><a href="#DEP0046">DEP0046: <code>util.isBuffer()</code></a></li>
+<li><a href="#DEP0047">DEP0047: <code>util.isDate()</code></a></li>
+<li><a href="#DEP0048">DEP0048: <code>util.isError()</code></a></li>
+<li><a href="#DEP0049">DEP0049: <code>util.isFunction()</code></a></li>
+<li><a href="#DEP0050">DEP0050: <code>util.isNull()</code></a></li>
+<li><a href="#DEP0051">DEP0051: <code>util.isNullOrUndefined()</code></a></li>
+<li><a href="#DEP0052">DEP0052: <code>util.isNumber()</code></a></li>
+<li><a href="#DEP0053">DEP0053: <code>util.isObject()</code></a></li>
+<li><a href="#DEP0054">DEP0054: <code>util.isPrimitive()</code></a></li>
+<li><a href="#DEP0055">DEP0055: <code>util.isRegExp()</code></a></li>
+<li><a href="#DEP0056">DEP0056: <code>util.isString()</code></a></li>
+<li><a href="#DEP0057">DEP0057: <code>util.isSymbol()</code></a></li>
+<li><a href="#DEP0058">DEP0058: <code>util.isUndefined()</code></a></li>
+<li><a href="#DEP0059">DEP0059: <code>util.log()</code></a></li>
+<li><a href="#DEP0060">DEP0060: <code>util._extend()</code></a></li>
+<li><a href="#DEP0061">DEP0061: <code>fs.SyncWriteStream</code></a></li>
+<li><a href="#DEP0062">DEP0062: <code>node --debug</code></a></li>
+<li><a href="#DEP0063">DEP0063: <code>ServerResponse.prototype.writeHeader()</code></a></li>
+<li><a href="#DEP0064">DEP0064: <code>tls.createSecurePair()</code></a></li>
+<li><a href="#DEP0065">DEP0065: <code>repl.REPL_MODE_MAGIC</code> and <code>NODE_REPL_MODE=magic</code></a></li>
+<li><a href="#DEP0066">DEP0066: <code>OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames</code></a></li>
+<li><a href="#DEP0067">DEP0067: <code>OutgoingMessage.prototype._renderHeaders</code></a></li>
+<li><a href="#DEP0068">DEP0068: <code>node debug</code></a></li>
+<li><a href="#DEP0069">DEP0069: <code>vm.runInDebugContext(string)</code></a></li>
+<li><a href="#DEP0070">DEP0070: <code>async_hooks.currentId()</code></a></li>
+<li><a href="#DEP0071">DEP0071: <code>async_hooks.triggerId()</code></a></li>
+<li><a href="#DEP0072">DEP0072: <code>async_hooks.AsyncResource.triggerId()</code></a></li>
+<li><a href="#DEP0073">DEP0073: Several internal properties of <code>net.Server</code></a></li>
+<li><a href="#DEP0074">DEP0074: <code>REPLServer.bufferedCommand</code></a></li>
+<li><a href="#DEP0075">DEP0075: <code>REPLServer.parseREPLKeyword()</code></a></li>
+<li><a href="#DEP0076">DEP0076: <code>tls.parseCertString()</code></a></li>
+<li><a href="#DEP0077">DEP0077: <code>Module._debug()</code></a></li>
+<li><a href="#DEP0078">DEP0078: <code>REPLServer.turnOffEditorMode()</code></a></li>
+<li><a href="#DEP0079">DEP0079: Custom inspection function on objects via <code>.inspect()</code></a></li>
+<li><a href="#DEP0080">DEP0080: <code>path._makeLong()</code></a></li>
+<li><a href="#DEP0081">DEP0081: <code>fs.truncate()</code> using a file descriptor</a></li>
+<li><a href="#DEP0082">DEP0082: <code>REPLServer.prototype.memory()</code></a></li>
+<li><a href="#DEP0083">DEP0083: Disabling ECDH by setting <code>ecdhCurve</code> to <code>false</code></a></li>
+<li><a href="#DEP0084">DEP0084: requiring bundled internal dependencies</a></li>
+<li><a href="#DEP0085">DEP0085: AsyncHooks sensitive API</a></li>
+<li><a href="#DEP0086">DEP0086: Remove <code>runInAsyncIdScope</code></a></li>
+<li><a href="#DEP0089">DEP0089: <code>require('assert')</code></a></li>
+<li><a href="#DEP0090">DEP0090: Invalid GCM authentication tag lengths</a></li>
+<li><a href="#DEP0091">DEP0091: <code>crypto.DEFAULT_ENCODING</code></a></li>
+<li><a href="#DEP0092">DEP0092: Top-level <code>this</code> bound to <code>module.exports</code></a></li>
+<li><a href="#DEP0093">DEP0093: <code>crypto.fips</code> is deprecated and replaced</a></li>
+<li><a href="#DEP0094">DEP0094: Using <code>assert.fail()</code> with more than one argument</a></li>
+<li><a href="#DEP0095">DEP0095: <code>timers.enroll()</code></a></li>
+<li><a href="#DEP0096">DEP0096: <code>timers.unenroll()</code></a></li>
+<li><a href="#DEP0097">DEP0097: <code>MakeCallback</code> with <code>domain</code> property</a></li>
+<li><a href="#DEP0098">DEP0098: AsyncHooks embedder <code>AsyncResource.emitBefore</code> and <code>AsyncResource.emitAfter</code> APIs</a></li>
+<li><a href="#DEP0099">DEP0099: Async context-unaware <code>node::MakeCallback</code> C++ APIs</a></li>
+<li><a href="#DEP0100">DEP0100: <code>process.assert()</code></a></li>
+<li><a href="#DEP0101">DEP0101: <code>--with-lttng</code></a></li>
+<li><a href="#DEP0102">DEP0102: Using <code>noAssert</code> in <code>Buffer#(read|write)</code> operations</a></li>
+<li><a href="#DEP0103">DEP0103: <code>process.binding('util').is[...]</code> typechecks</a></li>
+<li><a href="#DEP0104">DEP0104: <code>process.env</code> string coercion</a></li>
+<li><a href="#DEP0105">DEP0105: <code>decipher.finaltol</code></a></li>
+<li><a href="#DEP0106">DEP0106: <code>crypto.createCipher</code> and <code>crypto.createDecipher</code></a></li>
+<li><a href="#DEP0107">DEP0107: <code>tls.convertNPNProtocols()</code></a></li>
+<li><a href="#DEP0108">DEP0108: <code>zlib.bytesRead</code></a></li>
+<li><a href="#DEP0109">DEP0109: <code>http</code>, <code>https</code>, and <code>tls</code> support for invalid URLs</a></li>
+<li><a href="#DEP0110">DEP0110: <code>vm.Script</code> cached data</a></li>
+<li><a href="#DEP0111">DEP0111: <code>process.binding()</code></a></li>
+<li><a href="#DEP0112">DEP0112: <code>dgram</code> private APIs</a></li>
+<li><a href="#DEP0113">DEP0113: <code>Cipher.setAuthTag()</code>, <code>Decipher.getAuthTag()</code></a></li>
+<li><a href="#DEP0114">DEP0114: <code>crypto._toBuf()</code></a></li>
+<li><a href="#DEP0115">DEP0115: <code>crypto.prng()</code>, <code>crypto.pseudoRandomBytes()</code>, <code>crypto.rng()</code></a></li>
+<li><a href="#DEP0116">DEP0116: Legacy URL API</a></li>
+<li><a href="#DEP0117">DEP0117: Native crypto handles</a></li>
+<li><a href="#DEP0118">DEP0118: <code>dns.lookup()</code> support for a falsy host name</a></li>
+<li><a href="#DEP0119">DEP0119: <code>process.binding('uv').errname()</code> private API</a></li>
+<li><a href="#DEP0120">DEP0120: Windows Performance Counter support</a></li>
+<li><a href="#DEP0121">DEP0121: <code>net._setSimultaneousAccepts()</code></a></li>
+<li><a href="#DEP0122">DEP0122: <code>tls</code> <code>Server.prototype.setOptions()</code></a></li>
+<li><a href="#DEP0123">DEP0123: setting the TLS ServerName to an IP address</a></li>
+<li><a href="#DEP0124">DEP0124: using <code>REPLServer.rli</code></a></li>
+<li><a href="#DEP0125">DEP0125: <code>require('_stream_wrap')</code></a></li>
+<li><a href="#DEP0126">DEP0126: <code>timers.active()</code></a></li>
+<li><a href="#DEP0127">DEP0127: <code>timers._unrefActive()</code></a></li>
+<li><a href="#DEP0128">DEP0128: modules with an invalid <code>main</code> entry and an <code>index.js</code> file</a></li>
+<li><a href="#DEP0129">DEP0129: <code>ChildProcess._channel</code></a></li>
+<li><a href="#DEP0130">DEP0130: <code>Module.createRequireFromPath()</code></a></li>
+<li><a href="#DEP0131">DEP0131: Legacy HTTP parser</a></li>
+<li><a href="#DEP0132">DEP0132: <code>worker.terminate()</code> with callback</a></li>
+<li><a href="#DEP0133">DEP0133: <code>http</code> <code>connection</code></a></li>
+<li><a href="#DEP0134">DEP0134: <code>process._tickCallback</code></a></li>
+<li><a href="#DEP0135">DEP0135: <code>WriteStream.open()</code> and <code>ReadStream.open()</code> are internal</a></li>
+<li><a href="#DEP0136">DEP0136: <code>http</code> <code>finished</code></a></li>
+<li><a href="#DEP0137">DEP0137: Closing fs.FileHandle on garbage collection</a></li>
+<li><a href="#DEP0138">DEP0138: <code>process.mainModule</code></a></li>
+<li><a href="#DEP0139">DEP0139: <code>process.umask()</code> with no arguments</a></li>
+<li><a href="#DEP0140">DEP0140: Use <code>request.destroy()</code> instead of <code>request.abort()</code></a></li>
+<li><a href="#DEP0141">DEP0141: <code>repl.inputStream</code> and <code>repl.outputStream</code></a></li>
+<li><a href="#DEP0142">DEP0142: <code>repl._builtinLibs</code></a></li>
+<li><a href="#DEP0143">DEP0143: <code>Transform._transformState</code></a></li>
+<li><a href="#DEP0144">DEP0144: <code>module.parent</code></a></li>
+<li><a href="#DEP0145">DEP0145: <code>socket.bufferSize</code></a></li>
+<li><a href="#DEP0146">DEP0146: <code>new crypto.Certificate()</code></a></li>
+<li><a href="#DEP0147">DEP0147: <code>fs.rmdir(path, { recursive: true })</code></a></li>
+<li><a href="#DEP0151">DEP0151: Main index lookup and extension searching</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><span class="stability_1"><a href="#diagnostics_channel_diagnostics_channel">Diagnostics Channel</a></span>
+<ul>
+<li><a href="#diagnostics_channel_public_api">Public API</a>
+<ul>
+<li><a href="#diagnostics_channel_overview">Overview</a>
+<ul>
+<li><a href="#diagnostics_channel_diagnostics_channel_hassubscribers_name"><code>diagnostics_channel.hasSubscribers(name)</code></a></li>
+<li><a href="#diagnostics_channel_diagnostics_channel_channel_name"><code>diagnostics_channel.channel(name)</code></a></li>
+</ul>
+</li>
+<li><a href="#diagnostics_channel_class_channel">Class: <code>Channel</code></a>
+<ul>
+<li><a href="#diagnostics_channel_channel_hassubscribers"><code>channel.hasSubscribers</code></a></li>
+<li><a href="#diagnostics_channel_channel_publish_message"><code>channel.publish(message)</code></a></li>
+<li><a href="#diagnostics_channel_channel_subscribe_onmessage"><code>channel.subscribe(onMessage)</code></a></li>
+<li><a href="#diagnostics_channel_channel_unsubscribe_onmessage"><code>channel.unsubscribe(onMessage)</code></a></li>
+</ul>
+</li>
 </ul>
 </li>
 </ul>
@@ -1356,6 +1424,7 @@
 <ul>
 <li><a href="#dns_resolver_options"><code>Resolver([options])</code></a></li>
 <li><a href="#dns_resolver_cancel"><code>resolver.cancel()</code></a></li>
+<li><a href="#dns_resolver_setlocaladdress_ipv4_ipv6"><code>resolver.setLocalAddress([ipv4][, ipv6])</code></a></li>
 </ul>
 </li>
 <li><a href="#dns_dns_getservers"><code>dns.getServers()</code></a></li>
@@ -1370,6 +1439,7 @@
 <li><a href="#dns_dns_resolve6_hostname_options_callback"><code>dns.resolve6(hostname[, options], callback)</code></a></li>
 <li><a href="#dns_dns_resolveany_hostname_callback"><code>dns.resolveAny(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvecname_hostname_callback"><code>dns.resolveCname(hostname, callback)</code></a></li>
+<li><a href="#dns_dns_resolvecaa_hostname_callback"><code>dns.resolveCaa(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvemx_hostname_callback"><code>dns.resolveMx(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvenaptr_hostname_callback"><code>dns.resolveNaptr(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvens_hostname_callback"><code>dns.resolveNs(hostname, callback)</code></a></li>
@@ -1378,10 +1448,12 @@
 <li><a href="#dns_dns_resolvesrv_hostname_callback"><code>dns.resolveSrv(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvetxt_hostname_callback"><code>dns.resolveTxt(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_reverse_ip_callback"><code>dns.reverse(ip, callback)</code></a></li>
+<li><a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder(order)</code></a></li>
 <li><a href="#dns_dns_setservers_servers"><code>dns.setServers(servers)</code></a></li>
 <li><a href="#dns_dns_promises_api">DNS promises API</a>
 <ul>
 <li><a href="#dns_class_dnspromises_resolver">Class: <code>dnsPromises.Resolver</code></a></li>
+<li><a href="#dns_resolver_cancel_1"><code>resolver.cancel()</code></a></li>
 <li><a href="#dns_dnspromises_getservers"><code>dnsPromises.getServers()</code></a></li>
 <li><a href="#dns_dnspromises_lookup_hostname_options"><code>dnsPromises.lookup(hostname[, options])</code></a></li>
 <li><a href="#dns_dnspromises_lookupservice_address_port"><code>dnsPromises.lookupService(address, port)</code></a></li>
@@ -1389,6 +1461,7 @@
 <li><a href="#dns_dnspromises_resolve4_hostname_options"><code>dnsPromises.resolve4(hostname[, options])</code></a></li>
 <li><a href="#dns_dnspromises_resolve6_hostname_options"><code>dnsPromises.resolve6(hostname[, options])</code></a></li>
 <li><a href="#dns_dnspromises_resolveany_hostname"><code>dnsPromises.resolveAny(hostname)</code></a></li>
+<li><a href="#dns_dnspromises_resolvecaa_hostname"><code>dnsPromises.resolveCaa(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_resolvecname_hostname"><code>dnsPromises.resolveCname(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_resolvemx_hostname"><code>dnsPromises.resolveMx(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_resolvenaptr_hostname"><code>dnsPromises.resolveNaptr(hostname)</code></a></li>
@@ -1398,6 +1471,7 @@
 <li><a href="#dns_dnspromises_resolvesrv_hostname"><code>dnsPromises.resolveSrv(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_resolvetxt_hostname"><code>dnsPromises.resolveTxt(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_reverse_ip"><code>dnsPromises.reverse(ip)</code></a></li>
+<li><a href="#dns_dnspromises_setdefaultresultorder_order"><code>dnsPromises.setDefaultResultOrder(order)</code></a></li>
 <li><a href="#dns_dnspromises_setservers_servers"><code>dnsPromises.setServers(servers)</code></a></li>
 </ul>
 </li>
@@ -1479,6 +1553,7 @@
 </li>
 <li><a href="#errors_node_js_error_codes">Node.js error codes</a>
 <ul>
+<li><a href="#errors_abort_err"><code>ABORT_ERR</code></a></li>
 <li><a href="#errors_err_ambiguous_argument"><code>ERR_AMBIGUOUS_ARGUMENT</code></a></li>
 <li><a href="#errors_err_arg_not_iterable"><code>ERR_ARG_NOT_ITERABLE</code></a></li>
 <li><a href="#errors_err_assertion"><code>ERR_ASSERTION</code></a></li>
@@ -1493,9 +1568,11 @@
 <li><a href="#errors_err_child_closed_before_reply"><code>ERR_CHILD_CLOSED_BEFORE_REPLY</code></a></li>
 <li><a href="#errors_err_child_process_ipc_required"><code>ERR_CHILD_PROCESS_IPC_REQUIRED</code></a></li>
 <li><a href="#errors_err_child_process_stdio_maxbuffer"><code>ERR_CHILD_PROCESS_STDIO_MAXBUFFER</code></a></li>
+<li><a href="#errors_err_closed_message_port"><code>ERR_CLOSED_MESSAGE_PORT</code></a></li>
 <li><a href="#errors_err_console_writable_stream"><code>ERR_CONSOLE_WRITABLE_STREAM</code></a></li>
-<li><a href="#errors_err_construct_call_required"><code>ERR_CONSTRUCT_CALL_REQUIRED</code></a></li>
 <li><a href="#errors_err_construct_call_invalid"><code>ERR_CONSTRUCT_CALL_INVALID</code></a></li>
+<li><a href="#errors_err_construct_call_required"><code>ERR_CONSTRUCT_CALL_REQUIRED</code></a></li>
+<li><a href="#errors_err_context_not_initialized"><code>ERR_CONTEXT_NOT_INITIALIZED</code></a></li>
 <li><a href="#errors_err_cpu_usage"><code>ERR_CPU_USAGE</code></a></li>
 <li><a href="#errors_err_crypto_custom_engine_not_supported"><code>ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED</code></a></li>
 <li><a href="#errors_err_crypto_ecdh_invalid_format"><code>ERR_CRYPTO_ECDH_INVALID_FORMAT</code></a></li>
@@ -1517,6 +1594,9 @@
 <li><a href="#errors_err_crypto_timing_safe_equal_length"><code>ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH</code></a></li>
 <li><a href="#errors_err_crypto_unknown_cipher"><code>ERR_CRYPTO_UNKNOWN_CIPHER</code></a></li>
 <li><a href="#errors_err_crypto_unknown_dh_group"><code>ERR_CRYPTO_UNKNOWN_DH_GROUP</code></a></li>
+<li><a href="#errors_err_dlopen_failed"><code>ERR_DLOPEN_FAILED</code></a></li>
+<li><a href="#errors_err_debugger_error"><code>ERR_DEBUGGER_ERROR</code></a></li>
+<li><a href="#errors_err_debugger_startup_error"><code>ERR_DEBUGGER_STARTUP_ERROR</code></a></li>
 <li><a href="#errors_err_dir_closed"><code>ERR_DIR_CLOSED</code></a></li>
 <li><a href="#errors_err_dir_concurrent_operation"><code>ERR_DIR_CONCURRENT_OPERATION</code></a></li>
 <li><a href="#errors_err_dns_set_servers_failed"><code>ERR_DNS_SET_SERVERS_FAILED</code></a></li>
@@ -1524,8 +1604,12 @@
 <li><a href="#errors_err_domain_cannot_set_uncaught_exception_capture"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a></li>
 <li><a href="#errors_err_encoding_invalid_encoded_data"><code>ERR_ENCODING_INVALID_ENCODED_DATA</code></a></li>
 <li><a href="#errors_err_encoding_not_supported"><code>ERR_ENCODING_NOT_SUPPORTED</code></a></li>
+<li><a href="#errors_err_eval_esm_cannot_print"><code>ERR_EVAL_ESM_CANNOT_PRINT</code></a></li>
+<li><a href="#errors_err_event_recursion"><code>ERR_EVENT_RECURSION</code></a></li>
 <li><a href="#errors_err_execution_environment_not_available"><code>ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE</code></a></li>
 <li><a href="#errors_err_falsy_value_rejection"><code>ERR_FALSY_VALUE_REJECTION</code></a></li>
+<li><a href="#errors_err_feature_unavailable_on_platform"><code>ERR_FEATURE_UNAVAILABLE_ON_PLATFORM</code></a></li>
+<li><a href="#errors_err_fs_eisdir"><code>ERR_FS_EISDIR</code></a></li>
 <li><a href="#errors_err_fs_file_too_large"><code>ERR_FS_FILE_TOO_LARGE</code></a></li>
 <li><a href="#errors_err_fs_invalid_symlink_type"><code>ERR_FS_INVALID_SYMLINK_TYPE</code></a></li>
 <li><a href="#errors_err_http_headers_sent"><code>ERR_HTTP_HEADERS_SENT</code></a></li>
@@ -1539,9 +1623,9 @@
 <li><a href="#errors_err_http2_connect_scheme"><code>ERR_HTTP2_CONNECT_SCHEME</code></a></li>
 <li><a href="#errors_err_http2_error"><code>ERR_HTTP2_ERROR</code></a></li>
 <li><a href="#errors_err_http2_goaway_session"><code>ERR_HTTP2_GOAWAY_SESSION</code></a></li>
+<li><a href="#errors_err_http2_header_single_value"><code>ERR_HTTP2_HEADER_SINGLE_VALUE</code></a></li>
 <li><a href="#errors_err_http2_headers_after_respond"><code>ERR_HTTP2_HEADERS_AFTER_RESPOND</code></a></li>
 <li><a href="#errors_err_http2_headers_sent"><code>ERR_HTTP2_HEADERS_SENT</code></a></li>
-<li><a href="#errors_err_http2_header_single_value"><code>ERR_HTTP2_HEADER_SINGLE_VALUE</code></a></li>
 <li><a href="#errors_err_http2_info_status_not_allowed"><code>ERR_HTTP2_INFO_STATUS_NOT_ALLOWED</code></a></li>
 <li><a href="#errors_err_http2_invalid_connection_headers"><code>ERR_HTTP2_INVALID_CONNECTION_HEADERS</code></a></li>
 <li><a href="#errors_err_http2_invalid_header_value"><code>ERR_HTTP2_INVALID_HEADER_VALUE</code></a></li>
@@ -1554,6 +1638,7 @@
 <li><a href="#errors_err_http2_invalid_stream"><code>ERR_HTTP2_INVALID_STREAM</code></a></li>
 <li><a href="#errors_err_http2_max_pending_settings_ack"><code>ERR_HTTP2_MAX_PENDING_SETTINGS_ACK</code></a></li>
 <li><a href="#errors_err_http2_nested_push"><code>ERR_HTTP2_NESTED_PUSH</code></a></li>
+<li><a href="#errors_err_http2_no_mem"><code>ERR_HTTP2_NO_MEM</code></a></li>
 <li><a href="#errors_err_http2_no_socket_manipulation"><code>ERR_HTTP2_NO_SOCKET_MANIPULATION</code></a></li>
 <li><a href="#errors_err_http2_origin_length"><code>ERR_HTTP2_ORIGIN_LENGTH</code></a></li>
 <li><a href="#errors_err_http2_out_of_streams"><code>ERR_HTTP2_OUT_OF_STREAMS</code></a></li>
@@ -1576,9 +1661,8 @@
 <li><a href="#errors_err_http2_trailers_already_sent"><code>ERR_HTTP2_TRAILERS_ALREADY_SENT</code></a></li>
 <li><a href="#errors_err_http2_trailers_not_ready"><code>ERR_HTTP2_TRAILERS_NOT_READY</code></a></li>
 <li><a href="#errors_err_http2_unsupported_protocol"><code>ERR_HTTP2_UNSUPPORTED_PROTOCOL</code></a></li>
-<li><a href="#errors_err_internal_assertion"><code>ERR_INTERNAL_ASSERTION</code></a></li>
 <li><a href="#errors_err_incompatible_option_pair"><code>ERR_INCOMPATIBLE_OPTION_PAIR</code></a></li>
-<li><a href="#errors_err_input_type_not_allowed"><code>ERR_INPUT_TYPE_NOT_ALLOWED</code></a></li>
+<li><span class="stability_1"><a href="#errors_err_input_type_not_allowed"><code>ERR_INPUT_TYPE_NOT_ALLOWED</code></a></span></li>
 <li><a href="#errors_err_inspector_already_activated"><code>ERR_INSPECTOR_ALREADY_ACTIVATED</code></a></li>
 <li><a href="#errors_err_inspector_already_connected"><code>ERR_INSPECTOR_ALREADY_CONNECTED</code></a></li>
 <li><a href="#errors_err_inspector_closed"><code>ERR_INSPECTOR_CLOSED</code></a></li>
@@ -1587,6 +1671,7 @@
 <li><a href="#errors_err_inspector_not_available"><code>ERR_INSPECTOR_NOT_AVAILABLE</code></a></li>
 <li><a href="#errors_err_inspector_not_connected"><code>ERR_INSPECTOR_NOT_CONNECTED</code></a></li>
 <li><a href="#errors_err_inspector_not_worker"><code>ERR_INSPECTOR_NOT_WORKER</code></a></li>
+<li><a href="#errors_err_internal_assertion"><code>ERR_INTERNAL_ASSERTION</code></a></li>
 <li><a href="#errors_err_invalid_address_family"><code>ERR_INVALID_ADDRESS_FAMILY</code></a></li>
 <li><a href="#errors_err_invalid_arg_type"><code>ERR_INVALID_ARG_TYPE</code></a></li>
 <li><a href="#errors_err_invalid_arg_value"><code>ERR_INVALID_ARG_VALUE</code></a></li>
@@ -1602,6 +1687,7 @@
 <li><a href="#errors_err_invalid_handle_type"><code>ERR_INVALID_HANDLE_TYPE</code></a></li>
 <li><a href="#errors_err_invalid_http_token"><code>ERR_INVALID_HTTP_TOKEN</code></a></li>
 <li><a href="#errors_err_invalid_ip_address"><code>ERR_INVALID_IP_ADDRESS</code></a></li>
+<li><a href="#errors_err_invalid_module"><code>ERR_INVALID_MODULE</code></a></li>
 <li><a href="#errors_err_invalid_module_specifier"><code>ERR_INVALID_MODULE_SPECIFIER</code></a></li>
 <li><a href="#errors_err_invalid_opt_value"><code>ERR_INVALID_OPT_VALUE</code></a></li>
 <li><a href="#errors_err_invalid_opt_value_encoding"><code>ERR_INVALID_OPT_VALUE_ENCODING</code></a></li>
@@ -1629,6 +1715,7 @@
 <li><a href="#errors_err_manifest_dependency_missing"><code>ERR_MANIFEST_DEPENDENCY_MISSING</code></a></li>
 <li><a href="#errors_err_manifest_integrity_mismatch"><code>ERR_MANIFEST_INTEGRITY_MISMATCH</code></a></li>
 <li><a href="#errors_err_manifest_invalid_resource_field"><code>ERR_MANIFEST_INVALID_RESOURCE_FIELD</code></a></li>
+<li><a href="#errors_err_manifest_invalid_specifier"><code>ERR_MANIFEST_INVALID_SPECIFIER</code></a></li>
 <li><a href="#errors_err_manifest_parse_policy"><code>ERR_MANIFEST_PARSE_POLICY</code></a></li>
 <li><a href="#errors_err_manifest_tdz"><code>ERR_MANIFEST_TDZ</code></a></li>
 <li><a href="#errors_err_manifest_unknown_onerror"><code>ERR_MANIFEST_UNKNOWN_ONERROR</code></a></li>
@@ -1636,12 +1723,11 @@
 <li><a href="#errors_err_message_target_context_unavailable"><code>ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE</code></a></li>
 <li><a href="#errors_err_method_not_implemented"><code>ERR_METHOD_NOT_IMPLEMENTED</code></a></li>
 <li><a href="#errors_err_missing_args"><code>ERR_MISSING_ARGS</code></a></li>
-<li><a href="#errors_err_missing_dynamic_instantiate_hook"><code>ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK</code></a></li>
-<li><a href="#errors_err_missing_option"><code>ERR_MISSING_OPTION</code></a></li>
 <li><a href="#errors_err_missing_message_port_in_transfer_list"><code>ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST</code></a></li>
+<li><a href="#errors_err_missing_option"><code>ERR_MISSING_OPTION</code></a></li>
 <li><a href="#errors_err_missing_passphrase"><code>ERR_MISSING_PASSPHRASE</code></a></li>
 <li><a href="#errors_err_missing_platform_for_worker"><code>ERR_MISSING_PLATFORM_FOR_WORKER</code></a></li>
-<li><a href="#errors_err_module_not_found"><code>ERR_MODULE_NOT_FOUND</code></a></li>
+<li><span class="stability_1"><a href="#errors_err_module_not_found"><code>ERR_MODULE_NOT_FOUND</code></a></span></li>
 <li><a href="#errors_err_multiple_callback"><code>ERR_MULTIPLE_CALLBACK</code></a></li>
 <li><a href="#errors_err_napi_cons_function"><code>ERR_NAPI_CONS_FUNCTION</code></a></li>
 <li><a href="#errors_err_napi_invalid_dataview_args"><code>ERR_NAPI_INVALID_DATAVIEW_ARGS</code></a></li>
@@ -1654,11 +1740,12 @@
 <li><a href="#errors_err_no_crypto"><code>ERR_NO_CRYPTO</code></a></li>
 <li><a href="#errors_err_no_icu"><code>ERR_NO_ICU</code></a></li>
 <li><a href="#errors_err_non_context_aware_disabled"><code>ERR_NON_CONTEXT_AWARE_DISABLED</code></a></li>
+<li><a href="#errors_err_operation_failed"><code>ERR_OPERATION_FAILED</code></a></li>
 <li><a href="#errors_err_out_of_range"><code>ERR_OUT_OF_RANGE</code></a></li>
 <li><a href="#errors_err_package_import_not_defined"><code>ERR_PACKAGE_IMPORT_NOT_DEFINED</code></a></li>
 <li><a href="#errors_err_package_path_not_exported"><code>ERR_PACKAGE_PATH_NOT_EXPORTED</code></a></li>
 <li><a href="#errors_err_proto_access"><code>ERR_PROTO_ACCESS</code></a></li>
-<li><a href="#errors_err_require_esm"><code>ERR_REQUIRE_ESM</code></a></li>
+<li><span class="stability_1"><a href="#errors_err_require_esm"><code>ERR_REQUIRE_ESM</code></a></span></li>
 <li><a href="#errors_err_script_execution_interrupted"><code>ERR_SCRIPT_EXECUTION_INTERRUPTED</code></a></li>
 <li><a href="#errors_err_script_execution_timeout"><code>ERR_SCRIPT_EXECUTION_TIMEOUT</code></a></li>
 <li><a href="#errors_err_server_already_listen"><code>ERR_SERVER_ALREADY_LISTEN</code></a></li>
@@ -1668,12 +1755,12 @@
 <li><a href="#errors_err_socket_bad_port"><code>ERR_SOCKET_BAD_PORT</code></a></li>
 <li><a href="#errors_err_socket_bad_type"><code>ERR_SOCKET_BAD_TYPE</code></a></li>
 <li><a href="#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a></li>
-<li><a href="#errors_err_socket_cannot_send"><code>ERR_SOCKET_CANNOT_SEND</code></a></li>
 <li><a href="#errors_err_socket_closed"><code>ERR_SOCKET_CLOSED</code></a></li>
 <li><a href="#errors_err_socket_dgram_is_connected"><code>ERR_SOCKET_DGRAM_IS_CONNECTED</code></a></li>
 <li><a href="#errors_err_socket_dgram_not_connected"><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code></a></li>
 <li><a href="#errors_err_socket_dgram_not_running"><code>ERR_SOCKET_DGRAM_NOT_RUNNING</code></a></li>
 <li><a href="#errors_err_sri_parse"><code>ERR_SRI_PARSE</code></a></li>
+<li><a href="#errors_err_stream_already_finished"><code>ERR_STREAM_ALREADY_FINISHED</code></a></li>
 <li><a href="#errors_err_stream_cannot_pipe"><code>ERR_STREAM_CANNOT_PIPE</code></a></li>
 <li><a href="#errors_err_stream_destroyed"><code>ERR_STREAM_DESTROYED</code></a></li>
 <li><a href="#errors_err_stream_null_values"><code>ERR_STREAM_NULL_VALUES</code></a></li>
@@ -1685,22 +1772,22 @@
 <li><a href="#errors_err_string_too_long"><code>ERR_STRING_TOO_LONG</code></a></li>
 <li><a href="#errors_err_synthetic"><code>ERR_SYNTHETIC</code></a></li>
 <li><a href="#errors_err_system_error"><code>ERR_SYSTEM_ERROR</code></a></li>
+<li><a href="#errors_err_tls_cert_altname_format"><code>ERR_TLS_CERT_ALTNAME_FORMAT</code></a></li>
 <li><a href="#errors_err_tls_cert_altname_invalid"><code>ERR_TLS_CERT_ALTNAME_INVALID</code></a></li>
 <li><a href="#errors_err_tls_dh_param_size"><code>ERR_TLS_DH_PARAM_SIZE</code></a></li>
 <li><a href="#errors_err_tls_handshake_timeout"><code>ERR_TLS_HANDSHAKE_TIMEOUT</code></a></li>
 <li><a href="#errors_err_tls_invalid_context"><code>ERR_TLS_INVALID_CONTEXT</code></a></li>
-<li><a href="#errors_err_tls_invalid_state"><code>ERR_TLS_INVALID_STATE</code></a></li>
 <li><a href="#errors_err_tls_invalid_protocol_method"><code>ERR_TLS_INVALID_PROTOCOL_METHOD</code></a></li>
 <li><a href="#errors_err_tls_invalid_protocol_version"><code>ERR_TLS_INVALID_PROTOCOL_VERSION</code></a></li>
+<li><a href="#errors_err_tls_invalid_state"><code>ERR_TLS_INVALID_STATE</code></a></li>
 <li><a href="#errors_err_tls_protocol_version_conflict"><code>ERR_TLS_PROTOCOL_VERSION_CONFLICT</code></a></li>
+<li><a href="#errors_err_tls_psk_set_identiy_hint_failed"><code>ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED</code></a></li>
 <li><a href="#errors_err_tls_renegotiation_disabled"><code>ERR_TLS_RENEGOTIATION_DISABLED</code></a></li>
 <li><a href="#errors_err_tls_required_server_name"><code>ERR_TLS_REQUIRED_SERVER_NAME</code></a></li>
 <li><a href="#errors_err_tls_session_attack"><code>ERR_TLS_SESSION_ATTACK</code></a></li>
 <li><a href="#errors_err_tls_sni_from_server"><code>ERR_TLS_SNI_FROM_SERVER</code></a></li>
-<li><a href="#errors_err_tls_psk_set_identiy_hint_failed"><code>ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED</code></a></li>
 <li><a href="#errors_err_trace_events_category_required"><code>ERR_TRACE_EVENTS_CATEGORY_REQUIRED</code></a></li>
 <li><a href="#errors_err_trace_events_unavailable"><code>ERR_TRACE_EVENTS_UNAVAILABLE</code></a></li>
-<li><a href="#errors_err_transferring_externalized_sharedarraybuffer"><code>ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER</code></a></li>
 <li><a href="#errors_err_transform_already_transforming"><code>ERR_TRANSFORM_ALREADY_TRANSFORMING</code></a></li>
 <li><a href="#errors_err_transform_with_length_0"><code>ERR_TRANSFORM_WITH_LENGTH_0</code></a></li>
 <li><a href="#errors_err_tty_init_failed"><code>ERR_TTY_INIT_FAILED</code></a></li>
@@ -1711,8 +1798,8 @@
 <li><a href="#errors_err_unknown_builtin_module"><code>ERR_UNKNOWN_BUILTIN_MODULE</code></a></li>
 <li><a href="#errors_err_unknown_credential"><code>ERR_UNKNOWN_CREDENTIAL</code></a></li>
 <li><a href="#errors_err_unknown_encoding"><code>ERR_UNKNOWN_ENCODING</code></a></li>
-<li><a href="#errors_err_unknown_file_extension"><code>ERR_UNKNOWN_FILE_EXTENSION</code></a></li>
-<li><a href="#errors_err_unknown_module_format"><code>ERR_UNKNOWN_MODULE_FORMAT</code></a></li>
+<li><span class="stability_1"><a href="#errors_err_unknown_file_extension"><code>ERR_UNKNOWN_FILE_EXTENSION</code></a></span></li>
+<li><span class="stability_1"><a href="#errors_err_unknown_module_format"><code>ERR_UNKNOWN_MODULE_FORMAT</code></a></span></li>
 <li><a href="#errors_err_unknown_signal"><code>ERR_UNKNOWN_SIGNAL</code></a></li>
 <li><a href="#errors_err_unsupported_dir_import"><code>ERR_UNSUPPORTED_DIR_IMPORT</code></a></li>
 <li><a href="#errors_err_unsupported_esm_url_scheme"><code>ERR_UNSUPPORTED_ESM_URL_SCHEME</code></a></li>
@@ -1723,6 +1810,7 @@
 <li><a href="#errors_err_vm_module_cannot_create_cached_data"><code>ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA</code></a></li>
 <li><a href="#errors_err_vm_module_different_context"><code>ERR_VM_MODULE_DIFFERENT_CONTEXT</code></a></li>
 <li><a href="#errors_err_vm_module_linking_errored"><code>ERR_VM_MODULE_LINKING_ERRORED</code></a></li>
+<li><a href="#errors_err_vm_module_link_failure"><code>ERR_VM_MODULE_LINK_FAILURE</code></a></li>
 <li><a href="#errors_err_vm_module_not_module"><code>ERR_VM_MODULE_NOT_MODULE</code></a></li>
 <li><a href="#errors_err_vm_module_status"><code>ERR_VM_MODULE_STATUS</code></a></li>
 <li><a href="#errors_err_wasi_already_started"><code>ERR_WASI_ALREADY_STARTED</code></a></li>
@@ -1741,10 +1829,9 @@
 <li><a href="#errors_module_not_found"><code>MODULE_NOT_FOUND</code></a></li>
 </ul>
 </li>
-<li><a href="#errors_legacy_node_js_error_codes">Legacy Node.js error codes</a>
+<li><span class="stability_0"><a href="#errors_legacy_node_js_error_codes">Legacy Node.js error codes</a></span>
 <ul>
 <li><a href="#errors_err_cannot_transfer_object"><code>ERR_CANNOT_TRANSFER_OBJECT</code></a></li>
-<li><a href="#errors_err_closed_message_port"><code>ERR_CLOSED_MESSAGE_PORT</code></a></li>
 <li><a href="#errors_err_crypto_hash_digest_no_utf16"><code>ERR_CRYPTO_HASH_DIGEST_NO_UTF16</code></a></li>
 <li><a href="#errors_err_http2_frame_error"><code>ERR_HTTP2_FRAME_ERROR</code></a></li>
 <li><a href="#errors_err_http2_headers_object"><code>ERR_HTTP2_HEADERS_OBJECT</code></a></li>
@@ -1752,16 +1839,18 @@
 <li><a href="#errors_err_http2_info_headers_after_respond"><code>ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND</code></a></li>
 <li><a href="#errors_err_http2_stream_closed"><code>ERR_HTTP2_STREAM_CLOSED</code></a></li>
 <li><a href="#errors_err_http_invalid_char"><code>ERR_HTTP_INVALID_CHAR</code></a></li>
+<li><a href="#errors_err_http_request_timeout"><code>ERR_HTTP_REQUEST_TIMEOUT</code></a></li>
 <li><a href="#errors_err_index_out_of_range"><code>ERR_INDEX_OUT_OF_RANGE</code></a></li>
 <li><a href="#errors_err_napi_cons_prototype_object"><code>ERR_NAPI_CONS_PROTOTYPE_OBJECT</code></a></li>
 <li><a href="#errors_err_no_longer_supported"><code>ERR_NO_LONGER_SUPPORTED</code></a></li>
 <li><a href="#errors_err_outofmemory"><code>ERR_OUTOFMEMORY</code></a></li>
 <li><a href="#errors_err_parse_history_data"><code>ERR_PARSE_HISTORY_DATA</code></a></li>
+<li><a href="#errors_err_socket_cannot_send"><code>ERR_SOCKET_CANNOT_SEND</code></a></li>
 <li><a href="#errors_err_stderr_close"><code>ERR_STDERR_CLOSE</code></a></li>
 <li><a href="#errors_err_stdout_close"><code>ERR_STDOUT_CLOSE</code></a></li>
 <li><a href="#errors_err_stream_read_not_implemented"><code>ERR_STREAM_READ_NOT_IMPLEMENTED</code></a></li>
 <li><a href="#errors_err_tls_renegotiation_failed"><code>ERR_TLS_RENEGOTIATION_FAILED</code></a></li>
-<li><a href="#errors_err_unknown_builtin_module_1"><code>ERR_UNKNOWN_BUILTIN_MODULE</code></a></li>
+<li><a href="#errors_err_transferring_externalized_sharedarraybuffer"><code>ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER</code></a></li>
 <li><a href="#errors_err_unknown_stdin_type"><code>ERR_UNKNOWN_STDIN_TYPE</code></a></li>
 <li><a href="#errors_err_unknown_stream_type"><code>ERR_UNKNOWN_STREAM_TYPE</code></a></li>
 <li><a href="#errors_err_v8breakiterator"><code>ERR_V8BREAKITERATOR</code></a></li>
@@ -1778,14 +1867,11 @@
 <li><a href="#events_asynchronous_vs_synchronous">Asynchronous vs. synchronous</a></li>
 <li><a href="#events_handling_events_only_once">Handling events only once</a></li>
 <li><a href="#events_error_events">Error events</a></li>
-<li><a href="#events_capture_rejections_of_promises">Capture rejections of promises</a></li>
+<li><span class="stability_1"><a href="#events_capture_rejections_of_promises">Capture rejections of promises</a></span></li>
 <li><a href="#events_class_eventemitter">Class: <code>EventEmitter</code></a>
 <ul>
-<li><a href="#events_event_newlistener">Event: 'newListener'</a></li>
+<li><a href="#events_event_newlistener">Event: <code>'newListener'</code></a></li>
 <li><a href="#events_event_removelistener">Event: <code>'removeListener'</code></a></li>
-<li><span class="stability_0"><a href="#events_eventemitter_listenercount_emitter_eventname"><code>EventEmitter.listenerCount(emitter, eventName)</code></a></span></li>
-<li><a href="#events_eventemitter_defaultmaxlisteners"><code>EventEmitter.defaultMaxListeners</code></a></li>
-<li><a href="#events_eventemitter_errormonitor"><code>EventEmitter.errorMonitor</code></a></li>
 <li><a href="#events_emitter_addlistener_eventname_listener"><code>emitter.addListener(eventName, listener)</code></a></li>
 <li><a href="#events_emitter_emit_eventname_args"><code>emitter.emit(eventName[, ...args])</code></a></li>
 <li><a href="#events_emitter_eventnames"><code>emitter.eventNames()</code></a></li>
@@ -1804,29 +1890,252 @@
 <li><span class="stability_1"><a href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args"><code>emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])</code></a></span></li>
 </ul>
 </li>
-<li><a href="#events_events_once_emitter_name"><code>events.once(emitter, name)</code></a>
+<li><a href="#events_events_defaultmaxlisteners"><code>events.defaultMaxListeners</code></a></li>
+<li><a href="#events_events_errormonitor"><code>events.errorMonitor</code></a></li>
+<li><a href="#events_events_geteventlisteners_emitterortarget_eventname"><code>events.getEventListeners(emitterOrTarget, eventName)</code></a></li>
+<li><a href="#events_events_once_emitter_name_options"><code>events.once(emitter, name[, options])</code></a>
 <ul>
 <li><a href="#events_awaiting_multiple_events_emitted_on_process_nexttick">Awaiting multiple events emitted on <code>process.nextTick()</code></a></li>
 </ul>
 </li>
 <li><span class="stability_1"><a href="#events_events_capturerejections"><code>events.captureRejections</code></a></span></li>
-<li><span class="stability_1"><a href="#events_events_capturerejectionsymbol">events.captureRejectionSymbol</a></span></li>
-<li><a href="#events_events_on_emitter_eventname">events.on(emitter, eventName)</a></li>
+<li><span class="stability_1"><a href="#events_events_capturerejectionsymbol"><code>events.captureRejectionSymbol</code></a></span></li>
+<li><span class="stability_0"><a href="#events_events_listenercount_emitter_eventname"><code>events.listenerCount(emitter, eventName)</code></a></span></li>
+<li><a href="#events_events_on_emitter_eventname_options"><code>events.on(emitter, eventName[, options])</code></a></li>
+<li><a href="#events_events_setmaxlisteners_n_eventtargets"><code>events.setMaxListeners(n[, ...eventTargets])</code></a></li>
+<li><span class="stability_1"><a href="#events_eventtarget_and_event_api"><code>EventTarget</code> and <code>Event</code> API</a></span>
+<ul>
+<li><a href="#events_node_js_eventtarget_vs_dom_eventtarget">Node.js <code>EventTarget</code> vs. DOM <code>EventTarget</code></a></li>
+<li><a href="#events_nodeeventtarget_vs_eventemitter"><code>NodeEventTarget</code> vs. <code>EventEmitter</code></a></li>
+<li><a href="#events_event_listener">Event listener</a></li>
+<li><a href="#events_eventtarget_error_handling"><code>EventTarget</code> error handling</a></li>
+<li><a href="#events_class_event">Class: <code>Event</code></a>
+<ul>
+<li><a href="#events_event_bubbles"><code>event.bubbles</code></a></li>
+<li><a href="#events_event_cancelbubble"><code>event.cancelBubble()</code></a></li>
+<li><a href="#events_event_cancelable"><code>event.cancelable</code></a></li>
+<li><a href="#events_event_composed"><code>event.composed</code></a></li>
+<li><a href="#events_event_composedpath"><code>event.composedPath()</code></a></li>
+<li><a href="#events_event_currenttarget"><code>event.currentTarget</code></a></li>
+<li><a href="#events_event_defaultprevented"><code>event.defaultPrevented</code></a></li>
+<li><a href="#events_event_eventphase"><code>event.eventPhase</code></a></li>
+<li><a href="#events_event_istrusted"><code>event.isTrusted</code></a></li>
+<li><a href="#events_event_preventdefault"><code>event.preventDefault()</code></a></li>
+<li><a href="#events_event_returnvalue"><code>event.returnValue</code></a></li>
+<li><a href="#events_event_srcelement"><code>event.srcElement</code></a></li>
+<li><a href="#events_event_stopimmediatepropagation"><code>event.stopImmediatePropagation()</code></a></li>
+<li><a href="#events_event_stoppropagation"><code>event.stopPropagation()</code></a></li>
+<li><a href="#events_event_target"><code>event.target</code></a></li>
+<li><a href="#events_event_timestamp"><code>event.timeStamp</code></a></li>
+<li><a href="#events_event_type"><code>event.type</code></a></li>
+</ul>
+</li>
+<li><a href="#events_class_eventtarget">Class: <code>EventTarget</code></a>
+<ul>
+<li><a href="#events_eventtarget_addeventlistener_type_listener_options"><code>eventTarget.addEventListener(type, listener[, options])</code></a></li>
+<li><a href="#events_eventtarget_dispatchevent_event"><code>eventTarget.dispatchEvent(event)</code></a></li>
+<li><a href="#events_eventtarget_removeeventlistener_type_listener"><code>eventTarget.removeEventListener(type, listener)</code></a></li>
+</ul>
+</li>
+<li><a href="#events_class_nodeeventtarget">Class: <code>NodeEventTarget</code></a>
+<ul>
+<li><a href="#events_nodeeventtarget_addlistener_type_listener_options"><code>nodeEventTarget.addListener(type, listener[, options])</code></a></li>
+<li><a href="#events_nodeeventtarget_eventnames"><code>nodeEventTarget.eventNames()</code></a></li>
+<li><a href="#events_nodeeventtarget_listenercount_type"><code>nodeEventTarget.listenerCount(type)</code></a></li>
+<li><a href="#events_nodeeventtarget_off_type_listener"><code>nodeEventTarget.off(type, listener)</code></a></li>
+<li><a href="#events_nodeeventtarget_on_type_listener_options"><code>nodeEventTarget.on(type, listener[, options])</code></a></li>
+<li><a href="#events_nodeeventtarget_once_type_listener_options"><code>nodeEventTarget.once(type, listener[, options])</code></a></li>
+<li><a href="#events_nodeeventtarget_removealllisteners_type"><code>nodeEventTarget.removeAllListeners([type])</code></a></li>
+<li><a href="#events_nodeeventtarget_removelistener_type_listener"><code>nodeEventTarget.removeListener(type, listener)</code></a></li>
+</ul>
+</li>
+</ul>
+</li>
 </ul>
 </li>
 <li><span class="stability_2"><a href="#fs_file_system">File system</a></span>
 <ul>
-<li><a href="#fs_synchronous_example">Synchronous example</a></li>
-<li><a href="#fs_callback_example">Callback example</a></li>
 <li><a href="#fs_promise_example">Promise example</a></li>
-<li><a href="#fs_ordering_of_callback_and_promise_based_operations">Ordering of callback and promise-based operations</a></li>
-<li><a href="#fs_file_paths">File paths</a>
+<li><a href="#fs_callback_example">Callback example</a></li>
+<li><a href="#fs_synchronous_example">Synchronous example</a></li>
+<li><a href="#fs_promises_api">Promises API</a>
+<ul>
+<li><a href="#fs_class_filehandle">Class: <code>FileHandle</code></a>
 <ul>
-<li><a href="#fs_url_object_support">URL object support</a></li>
+<li><a href="#fs_filehandle_appendfile_data_options"><code>filehandle.appendFile(data[, options])</code></a></li>
+<li><a href="#fs_filehandle_chmod_mode"><code>filehandle.chmod(mode)</code></a></li>
+<li><a href="#fs_filehandle_chown_uid_gid"><code>filehandle.chown(uid, gid)</code></a></li>
+<li><a href="#fs_filehandle_close"><code>filehandle.close()</code></a></li>
+<li><a href="#fs_filehandle_datasync"><code>filehandle.datasync()</code></a></li>
+<li><a href="#fs_filehandle_fd"><code>filehandle.fd</code></a></li>
+<li><a href="#fs_filehandle_read_buffer_offset_length_position"><code>filehandle.read(buffer, offset, length, position)</code></a></li>
+<li><a href="#fs_filehandle_read_options"><code>filehandle.read([options])</code></a></li>
+<li><a href="#fs_filehandle_readfile_options"><code>filehandle.readFile(options)</code></a></li>
+<li><a href="#fs_filehandle_readv_buffers_position"><code>filehandle.readv(buffers[, position])</code></a></li>
+<li><a href="#fs_filehandle_stat_options"><code>filehandle.stat([options])</code></a></li>
+<li><a href="#fs_filehandle_sync"><code>filehandle.sync()</code></a></li>
+<li><a href="#fs_filehandle_truncate_len"><code>filehandle.truncate(len)</code></a></li>
+<li><a href="#fs_filehandle_utimes_atime_mtime"><code>filehandle.utimes(atime, mtime)</code></a></li>
+<li><a href="#fs_filehandle_write_buffer_offset_length_position"><code>filehandle.write(buffer[, offset[, length[, position]]])</code></a></li>
+<li><a href="#fs_filehandle_write_string_position_encoding"><code>filehandle.write(string[, position[, encoding]])</code></a></li>
+<li><a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile(data, options)</code></a></li>
+<li><a href="#fs_filehandle_writev_buffers_position"><code>filehandle.writev(buffers[, position])</code></a></li>
 </ul>
 </li>
+<li><a href="#fs_fspromises_access_path_mode"><code>fsPromises.access(path[, mode])</code></a></li>
+<li><a href="#fs_fspromises_appendfile_path_data_options"><code>fsPromises.appendFile(path, data[, options])</code></a></li>
+<li><a href="#fs_fspromises_chmod_path_mode"><code>fsPromises.chmod(path, mode)</code></a></li>
+<li><a href="#fs_fspromises_chown_path_uid_gid"><code>fsPromises.chown(path, uid, gid)</code></a></li>
+<li><a href="#fs_fspromises_copyfile_src_dest_mode"><code>fsPromises.copyFile(src, dest[, mode])</code></a></li>
+<li><a href="#fs_fspromises_lchmod_path_mode"><code>fsPromises.lchmod(path, mode)</code></a></li>
+<li><a href="#fs_fspromises_lchown_path_uid_gid"><code>fsPromises.lchown(path, uid, gid)</code></a></li>
+<li><a href="#fs_fspromises_lutimes_path_atime_mtime"><code>fsPromises.lutimes(path, atime, mtime)</code></a></li>
+<li><a href="#fs_fspromises_link_existingpath_newpath"><code>fsPromises.link(existingPath, newPath)</code></a></li>
+<li><a href="#fs_fspromises_lstat_path_options"><code>fsPromises.lstat(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_mkdir_path_options"><code>fsPromises.mkdir(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_mkdtemp_prefix_options"><code>fsPromises.mkdtemp(prefix[, options])</code></a></li>
+<li><a href="#fs_fspromises_open_path_flags_mode"><code>fsPromises.open(path, flags[, mode])</code></a></li>
+<li><a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_readdir_path_options"><code>fsPromises.readdir(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_readfile_path_options"><code>fsPromises.readFile(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_readlink_path_options"><code>fsPromises.readlink(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_realpath_path_options"><code>fsPromises.realpath(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_rename_oldpath_newpath"><code>fsPromises.rename(oldPath, newPath)</code></a></li>
+<li><a href="#fs_fspromises_rmdir_path_options"><code>fsPromises.rmdir(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_rm_path_options"><code>fsPromises.rm(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_stat_path_options"><code>fsPromises.stat(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_symlink_target_path_type"><code>fsPromises.symlink(target, path[, type])</code></a></li>
+<li><a href="#fs_fspromises_truncate_path_len"><code>fsPromises.truncate(path[, len])</code></a></li>
+<li><a href="#fs_fspromises_unlink_path"><code>fsPromises.unlink(path)</code></a></li>
+<li><a href="#fs_fspromises_utimes_path_atime_mtime"><code>fsPromises.utimes(path, atime, mtime)</code></a></li>
+<li><a href="#fs_fspromises_watch_filename_options"><code>fsPromises.watch(filename[, options])</code></a></li>
+<li><a href="#fs_fspromises_writefile_file_data_options"><code>fsPromises.writeFile(file, data[, options])</code></a></li>
+</ul>
+</li>
+<li><a href="#fs_callback_api">Callback API</a>
+<ul>
+<li><a href="#fs_fs_access_path_mode_callback"><code>fs.access(path[, mode], callback)</code></a></li>
+<li><a href="#fs_fs_appendfile_path_data_options_callback"><code>fs.appendFile(path, data[, options], callback)</code></a></li>
+<li><a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod(path, mode, callback)</code></a>
+<ul>
+<li><a href="#fs_file_modes">File modes</a></li>
+</ul>
+</li>
+<li><a href="#fs_fs_chown_path_uid_gid_callback"><code>fs.chown(path, uid, gid, callback)</code></a></li>
+<li><a href="#fs_fs_close_fd_callback"><code>fs.close(fd[, callback])</code></a></li>
+<li><a href="#fs_fs_copyfile_src_dest_mode_callback"><code>fs.copyFile(src, dest[, mode], callback)</code></a></li>
+<li><a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream(path[, options])</code></a></li>
+<li><a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream(path[, options])</code></a></li>
+<li><span class="stability_0"><a href="#fs_fs_exists_path_callback"><code>fs.exists(path, callback)</code></a></span></li>
+<li><a href="#fs_fs_fchmod_fd_mode_callback"><code>fs.fchmod(fd, mode, callback)</code></a></li>
+<li><a href="#fs_fs_fchown_fd_uid_gid_callback"><code>fs.fchown(fd, uid, gid, callback)</code></a></li>
+<li><a href="#fs_fs_fdatasync_fd_callback"><code>fs.fdatasync(fd, callback)</code></a></li>
+<li><a href="#fs_fs_fstat_fd_options_callback"><code>fs.fstat(fd[, options], callback)</code></a></li>
+<li><a href="#fs_fs_fsync_fd_callback"><code>fs.fsync(fd, callback)</code></a></li>
+<li><a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate(fd[, len], callback)</code></a></li>
+<li><a href="#fs_fs_futimes_fd_atime_mtime_callback"><code>fs.futimes(fd, atime, mtime, callback)</code></a></li>
+<li><a href="#fs_fs_lchmod_path_mode_callback"><code>fs.lchmod(path, mode, callback)</code></a></li>
+<li><a href="#fs_fs_lchown_path_uid_gid_callback"><code>fs.lchown(path, uid, gid, callback)</code></a></li>
+<li><a href="#fs_fs_lutimes_path_atime_mtime_callback"><code>fs.lutimes(path, atime, mtime, callback)</code></a></li>
+<li><a href="#fs_fs_link_existingpath_newpath_callback"><code>fs.link(existingPath, newPath, callback)</code></a></li>
+<li><a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_mkdir_path_options_callback"><code>fs.mkdir(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_mkdtemp_prefix_options_callback"><code>fs.mkdtemp(prefix[, options], callback)</code></a></li>
+<li><a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open(path[, flags[, mode]], callback)</code></a></li>
+<li><a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read(fd, buffer, offset, length, position, callback)</code></a></li>
+<li><a href="#fs_fs_read_fd_options_callback"><code>fs.read(fd, [options,] callback)</code></a></li>
+<li><a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile(path[, options], callback)</code></a>
+<ul>
 <li><a href="#fs_file_descriptors">File descriptors</a></li>
-<li><a href="#fs_threadpool_usage">Threadpool usage</a></li>
+<li><a href="#fs_performance_considerations">Performance Considerations</a></li>
+</ul>
+</li>
+<li><a href="#fs_fs_readlink_path_options_callback"><code>fs.readlink(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv(fd, buffers[, position], callback)</code></a></li>
+<li><a href="#fs_fs_realpath_path_options_callback"><code>fs.realpath(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_realpath_native_path_options_callback"><code>fs.realpath.native(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_rename_oldpath_newpath_callback"><code>fs.rename(oldPath, newPath, callback)</code></a></li>
+<li><a href="#fs_fs_rmdir_path_options_callback"><code>fs.rmdir(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_rm_path_options_callback"><code>fs.rm(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_stat_path_options_callback"><code>fs.stat(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink(target, path[, type], callback)</code></a></li>
+<li><a href="#fs_fs_truncate_path_len_callback"><code>fs.truncate(path[, len], callback)</code></a></li>
+<li><a href="#fs_fs_unlink_path_callback"><code>fs.unlink(path, callback)</code></a></li>
+<li><a href="#fs_fs_unwatchfile_filename_listener"><code>fs.unwatchFile(filename[, listener])</code></a></li>
+<li><a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes(path, atime, mtime, callback)</code></a></li>
+<li><a href="#fs_fs_watch_filename_options_listener"><code>fs.watch(filename[, options][, listener])</code></a>
+<ul>
+<li><a href="#fs_caveats">Caveats</a>
+<ul>
+<li><a href="#fs_availability">Availability</a></li>
+<li><a href="#fs_inodes">Inodes</a></li>
+<li><a href="#fs_filename_argument">Filename argument</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a href="#fs_fs_watchfile_filename_options_listener"><code>fs.watchFile(filename[, options], listener)</code></a></li>
+<li><a href="#fs_fs_write_fd_buffer_offset_length_position_callback"><code>fs.write(fd, buffer[, offset[, length[, position]]], callback)</code></a></li>
+<li><a href="#fs_fs_write_fd_string_position_encoding_callback"><code>fs.write(fd, string[, position[, encoding]], callback)</code></a></li>
+<li><a href="#fs_fs_writefile_file_data_options_callback"><code>fs.writeFile(file, data[, options], callback)</code></a>
+<ul>
+<li><a href="#fs_using_fs_writefile_with_file_descriptors">Using <code>fs.writeFile()</code> with file descriptors</a></li>
+</ul>
+</li>
+<li><a href="#fs_fs_writev_fd_buffers_position_callback"><code>fs.writev(fd, buffers[, position], callback)</code></a></li>
+</ul>
+</li>
+<li><a href="#fs_synchronous_api">Synchronous API</a>
+<ul>
+<li><a href="#fs_fs_accesssync_path_mode"><code>fs.accessSync(path[, mode])</code></a></li>
+<li><a href="#fs_fs_appendfilesync_path_data_options"><code>fs.appendFileSync(path, data[, options])</code></a></li>
+<li><a href="#fs_fs_chmodsync_path_mode"><code>fs.chmodSync(path, mode)</code></a></li>
+<li><a href="#fs_fs_chownsync_path_uid_gid"><code>fs.chownSync(path, uid, gid)</code></a></li>
+<li><a href="#fs_fs_closesync_fd"><code>fs.closeSync(fd)</code></a></li>
+<li><a href="#fs_fs_copyfilesync_src_dest_mode"><code>fs.copyFileSync(src, dest[, mode])</code></a></li>
+<li><a href="#fs_fs_existssync_path"><code>fs.existsSync(path)</code></a></li>
+<li><a href="#fs_fs_fchmodsync_fd_mode"><code>fs.fchmodSync(fd, mode)</code></a></li>
+<li><a href="#fs_fs_fchownsync_fd_uid_gid"><code>fs.fchownSync(fd, uid, gid)</code></a></li>
+<li><a href="#fs_fs_fdatasyncsync_fd"><code>fs.fdatasyncSync(fd)</code></a></li>
+<li><a href="#fs_fs_fstatsync_fd_options"><code>fs.fstatSync(fd[, options])</code></a></li>
+<li><a href="#fs_fs_fsyncsync_fd"><code>fs.fsyncSync(fd)</code></a></li>
+<li><a href="#fs_fs_ftruncatesync_fd_len"><code>fs.ftruncateSync(fd[, len])</code></a></li>
+<li><a href="#fs_fs_futimessync_fd_atime_mtime"><code>fs.futimesSync(fd, atime, mtime)</code></a></li>
+<li><a href="#fs_fs_lchmodsync_path_mode"><code>fs.lchmodSync(path, mode)</code></a></li>
+<li><a href="#fs_fs_lchownsync_path_uid_gid"><code>fs.lchownSync(path, uid, gid)</code></a></li>
+<li><a href="#fs_fs_lutimessync_path_atime_mtime"><code>fs.lutimesSync(path, atime, mtime)</code></a></li>
+<li><a href="#fs_fs_linksync_existingpath_newpath"><code>fs.linkSync(existingPath, newPath)</code></a></li>
+<li><a href="#fs_fs_lstatsync_path_options"><code>fs.lstatSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_mkdirsync_path_options"><code>fs.mkdirSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_mkdtempsync_prefix_options"><code>fs.mkdtempSync(prefix[, options])</code></a></li>
+<li><a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_opensync_path_flags_mode"><code>fs.openSync(path[, flags[, mode]])</code></a></li>
+<li><a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_readfilesync_path_options"><code>fs.readFileSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_readlinksync_path_options"><code>fs.readlinkSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_readsync_fd_buffer_offset_length_position"><code>fs.readSync(fd, buffer, offset, length, position)</code></a></li>
+<li><a href="#fs_fs_readsync_fd_buffer_options"><code>fs.readSync(fd, buffer, [options])</code></a></li>
+<li><a href="#fs_fs_readvsync_fd_buffers_position"><code>fs.readvSync(fd, buffers[, position])</code></a></li>
+<li><a href="#fs_fs_realpathsync_path_options"><code>fs.realpathSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_realpathsync_native_path_options"><code>fs.realpathSync.native(path[, options])</code></a></li>
+<li><a href="#fs_fs_renamesync_oldpath_newpath"><code>fs.renameSync(oldPath, newPath)</code></a></li>
+<li><a href="#fs_fs_rmdirsync_path_options"><code>fs.rmdirSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_rmsync_path_options"><code>fs.rmSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_statsync_path_options"><code>fs.statSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_symlinksync_target_path_type"><code>fs.symlinkSync(target, path[, type])</code></a></li>
+<li><a href="#fs_fs_truncatesync_path_len"><code>fs.truncateSync(path[, len])</code></a></li>
+<li><a href="#fs_fs_unlinksync_path"><code>fs.unlinkSync(path)</code></a></li>
+<li><a href="#fs_fs_utimessync_path_atime_mtime"><code>fs.utimesSync(path, atime, mtime)</code></a></li>
+<li><a href="#fs_fs_writefilesync_file_data_options"><code>fs.writeFileSync(file, data[, options])</code></a></li>
+<li><a href="#fs_fs_writesync_fd_buffer_offset_length_position"><code>fs.writeSync(fd, buffer[, offset[, length[, position]]])</code></a></li>
+<li><a href="#fs_fs_writesync_fd_string_position_encoding"><code>fs.writeSync(fd, string[, position[, encoding]])</code></a></li>
+<li><a href="#fs_fs_writevsync_fd_buffers_position"><code>fs.writevSync(fd, buffers[, position])</code></a></li>
+</ul>
+</li>
+<li><a href="#fs_common_objects">Common Objects</a>
+<ul>
 <li><a href="#fs_class_fs_dir">Class: <code>fs.Dir</code></a>
 <ul>
 <li><a href="#fs_dir_close"><code>dir.close()</code></a></li>
@@ -1917,188 +2226,64 @@
 <li><a href="#fs_event_open_1">Event: <code>'open'</code></a></li>
 <li><a href="#fs_event_ready_1">Event: <code>'ready'</code></a></li>
 <li><a href="#fs_writestream_byteswritten"><code>writeStream.bytesWritten</code></a></li>
+<li><a href="#fs_writestream_close_callback"><code>writeStream.close([callback])</code></a></li>
 <li><a href="#fs_writestream_path"><code>writeStream.path</code></a></li>
 <li><a href="#fs_writestream_pending"><code>writeStream.pending</code></a></li>
 </ul>
 </li>
-<li><a href="#fs_fs_access_path_mode_callback"><code>fs.access(path[, mode], callback)</code></a></li>
-<li><a href="#fs_fs_accesssync_path_mode"><code>fs.accessSync(path[, mode])</code></a></li>
-<li><a href="#fs_fs_appendfile_path_data_options_callback"><code>fs.appendFile(path, data[, options], callback)</code></a></li>
-<li><a href="#fs_fs_appendfilesync_path_data_options"><code>fs.appendFileSync(path, data[, options])</code></a></li>
-<li><a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod(path, mode, callback)</code></a>
+<li><a href="#fs_fs_constants"><code>fs.constants</code></a>
 <ul>
-<li><a href="#fs_file_modes">File modes</a></li>
-</ul>
-</li>
-<li><a href="#fs_fs_chmodsync_path_mode"><code>fs.chmodSync(path, mode)</code></a></li>
-<li><a href="#fs_fs_chown_path_uid_gid_callback"><code>fs.chown(path, uid, gid, callback)</code></a></li>
-<li><a href="#fs_fs_chownsync_path_uid_gid"><code>fs.chownSync(path, uid, gid)</code></a></li>
-<li><a href="#fs_fs_close_fd_callback"><code>fs.close(fd, callback)</code></a></li>
-<li><a href="#fs_fs_closesync_fd"><code>fs.closeSync(fd)</code></a></li>
-<li><a href="#fs_fs_constants"><code>fs.constants</code></a></li>
-<li><a href="#fs_fs_copyfile_src_dest_flags_callback"><code>fs.copyFile(src, dest[, flags], callback)</code></a></li>
-<li><a href="#fs_fs_copyfilesync_src_dest_flags"><code>fs.copyFileSync(src, dest[, flags])</code></a></li>
-<li><a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream(path[, options])</code></a></li>
-<li><a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream(path[, options])</code></a></li>
-<li><span class="stability_0"><a href="#fs_fs_exists_path_callback"><code>fs.exists(path, callback)</code></a></span></li>
-<li><a href="#fs_fs_existssync_path"><code>fs.existsSync(path)</code></a></li>
-<li><a href="#fs_fs_fchmod_fd_mode_callback"><code>fs.fchmod(fd, mode, callback)</code></a></li>
-<li><a href="#fs_fs_fchmodsync_fd_mode"><code>fs.fchmodSync(fd, mode)</code></a></li>
-<li><a href="#fs_fs_fchown_fd_uid_gid_callback"><code>fs.fchown(fd, uid, gid, callback)</code></a></li>
-<li><a href="#fs_fs_fchownsync_fd_uid_gid"><code>fs.fchownSync(fd, uid, gid)</code></a></li>
-<li><a href="#fs_fs_fdatasync_fd_callback"><code>fs.fdatasync(fd, callback)</code></a></li>
-<li><a href="#fs_fs_fdatasyncsync_fd"><code>fs.fdatasyncSync(fd)</code></a></li>
-<li><a href="#fs_fs_fstat_fd_options_callback"><code>fs.fstat(fd[, options], callback)</code></a></li>
-<li><a href="#fs_fs_fstatsync_fd_options"><code>fs.fstatSync(fd[, options])</code></a></li>
-<li><a href="#fs_fs_fsync_fd_callback"><code>fs.fsync(fd, callback)</code></a></li>
-<li><a href="#fs_fs_fsyncsync_fd"><code>fs.fsyncSync(fd)</code></a></li>
-<li><a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate(fd[, len], callback)</code></a></li>
-<li><a href="#fs_fs_ftruncatesync_fd_len"><code>fs.ftruncateSync(fd[, len])</code></a></li>
-<li><a href="#fs_fs_futimes_fd_atime_mtime_callback"><code>fs.futimes(fd, atime, mtime, callback)</code></a></li>
-<li><a href="#fs_fs_futimessync_fd_atime_mtime"><code>fs.futimesSync(fd, atime, mtime)</code></a></li>
-<li><a href="#fs_fs_lchmod_path_mode_callback"><code>fs.lchmod(path, mode, callback)</code></a></li>
-<li><a href="#fs_fs_lchmodsync_path_mode"><code>fs.lchmodSync(path, mode)</code></a></li>
-<li><a href="#fs_fs_lchown_path_uid_gid_callback"><code>fs.lchown(path, uid, gid, callback)</code></a></li>
-<li><a href="#fs_fs_lchownsync_path_uid_gid"><code>fs.lchownSync(path, uid, gid)</code></a></li>
-<li><a href="#fs_fs_lutimes_path_atime_mtime_callback"><code>fs.lutimes(path, atime, mtime, callback)</code></a></li>
-<li><a href="#fs_fs_lutimessync_path_atime_mtime"><code>fs.lutimesSync(path, atime, mtime)</code></a></li>
-<li><a href="#fs_fs_link_existingpath_newpath_callback"><code>fs.link(existingPath, newPath, callback)</code></a></li>
-<li><a href="#fs_fs_linksync_existingpath_newpath"><code>fs.linkSync(existingPath, newPath)</code></a></li>
-<li><a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_lstatsync_path_options"><code>fs.lstatSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_mkdir_path_options_callback"><code>fs.mkdir(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_mkdirsync_path_options"><code>fs.mkdirSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_mkdtemp_prefix_options_callback"><code>fs.mkdtemp(prefix[, options], callback)</code></a></li>
-<li><a href="#fs_fs_mkdtempsync_prefix_options"><code>fs.mkdtempSync(prefix[, options])</code></a></li>
-<li><a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open(path[, flags[, mode]], callback)</code></a></li>
-<li><a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_opensync_path_flags_mode"><code>fs.openSync(path[, flags, mode])</code></a></li>
-<li><a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read(fd, buffer, offset, length, position, callback)</code></a></li>
-<li><a href="#fs_fs_read_fd_options_callback"><code>fs.read(fd, [options,] callback)</code></a></li>
-<li><a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile(path[, options], callback)</code></a>
+<li><a href="#fs_fs_constants_1">FS constants</a>
 <ul>
-<li><a href="#fs_file_descriptors_1">File descriptors</a></li>
+<li><a href="#fs_file_access_constants">File access constants</a></li>
+<li><a href="#fs_file_copy_constants">File copy constants</a></li>
+<li><a href="#fs_file_open_constants">File open constants</a></li>
+<li><a href="#fs_file_type_constants">File type constants</a></li>
+<li><a href="#fs_file_mode_constants">File mode constants</a></li>
 </ul>
 </li>
-<li><a href="#fs_fs_readfilesync_path_options"><code>fs.readFileSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_readlink_path_options_callback"><code>fs.readlink(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_readlinksync_path_options"><code>fs.readlinkSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_readsync_fd_buffer_offset_length_position"><code>fs.readSync(fd, buffer, offset, length, position)</code></a></li>
-<li><a href="#fs_fs_readsync_fd_buffer_options"><code>fs.readSync(fd, buffer, [options])</code></a></li>
-<li><a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv(fd, buffers[, position], callback)</code></a></li>
-<li><a href="#fs_fs_readvsync_fd_buffers_position"><code>fs.readvSync(fd, buffers[, position])</code></a></li>
-<li><a href="#fs_fs_realpath_path_options_callback"><code>fs.realpath(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_realpath_native_path_options_callback"><code>fs.realpath.native(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_realpathsync_path_options"><code>fs.realpathSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_realpathsync_native_path_options"><code>fs.realpathSync.native(path[, options])</code></a></li>
-<li><a href="#fs_fs_rename_oldpath_newpath_callback"><code>fs.rename(oldPath, newPath, callback)</code></a></li>
-<li><a href="#fs_fs_renamesync_oldpath_newpath"><code>fs.renameSync(oldPath, newPath)</code></a></li>
-<li><span class="stability_1"><a href="#fs_fs_rmdir_path_options_callback"><code>fs.rmdir(path[, options], callback)</code></a></span></li>
-<li><span class="stability_1"><a href="#fs_fs_rmdirsync_path_options"><code>fs.rmdirSync(path[, options])</code></a></span></li>
-<li><a href="#fs_fs_stat_path_options_callback"><code>fs.stat(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_statsync_path_options"><code>fs.statSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink(target, path[, type], callback)</code></a></li>
-<li><a href="#fs_fs_symlinksync_target_path_type"><code>fs.symlinkSync(target, path[, type])</code></a></li>
-<li><a href="#fs_fs_truncate_path_len_callback"><code>fs.truncate(path[, len], callback)</code></a></li>
-<li><a href="#fs_fs_truncatesync_path_len"><code>fs.truncateSync(path[, len])</code></a></li>
-<li><a href="#fs_fs_unlink_path_callback"><code>fs.unlink(path, callback)</code></a></li>
-<li><a href="#fs_fs_unlinksync_path"><code>fs.unlinkSync(path)</code></a></li>
-<li><a href="#fs_fs_unwatchfile_filename_listener"><code>fs.unwatchFile(filename[, listener])</code></a></li>
-<li><a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes(path, atime, mtime, callback)</code></a></li>
-<li><a href="#fs_fs_utimessync_path_atime_mtime"><code>fs.utimesSync(path, atime, mtime)</code></a></li>
-<li><a href="#fs_fs_watch_filename_options_listener"><code>fs.watch(filename[, options][, listener])</code></a>
-<ul>
-<li><a href="#fs_caveats">Caveats</a>
-<ul>
-<li><a href="#fs_availability">Availability</a></li>
-<li><a href="#fs_inodes">Inodes</a></li>
-<li><a href="#fs_filename_argument">Filename argument</a></li>
 </ul>
 </li>
 </ul>
 </li>
-<li><a href="#fs_fs_watchfile_filename_options_listener"><code>fs.watchFile(filename[, options], listener)</code></a></li>
-<li><a href="#fs_fs_write_fd_buffer_offset_length_position_callback"><code>fs.write(fd, buffer[, offset[, length[, position]]], callback)</code></a></li>
-<li><a href="#fs_fs_write_fd_string_position_encoding_callback"><code>fs.write(fd, string[, position[, encoding]], callback)</code></a></li>
-<li><a href="#fs_fs_writefile_file_data_options_callback"><code>fs.writeFile(file, data[, options], callback)</code></a>
+<li><a href="#fs_notes">Notes</a>
 <ul>
-<li><a href="#fs_using_fs_writefile_with_file_descriptors">Using <code>fs.writeFile()</code> with file descriptors</a></li>
-</ul>
-</li>
-<li><a href="#fs_fs_writefilesync_file_data_options"><code>fs.writeFileSync(file, data[, options])</code></a></li>
-<li><a href="#fs_fs_writesync_fd_buffer_offset_length_position"><code>fs.writeSync(fd, buffer[, offset[, length[, position]]])</code></a></li>
-<li><a href="#fs_fs_writesync_fd_string_position_encoding"><code>fs.writeSync(fd, string[, position[, encoding]])</code></a></li>
-<li><a href="#fs_fs_writev_fd_buffers_position_callback"><code>fs.writev(fd, buffers[, position], callback)</code></a></li>
-<li><a href="#fs_fs_writevsync_fd_buffers_position"><code>fs.writevSync(fd, buffers[, position])</code></a></li>
-<li><a href="#fs_fs_promises_api"><code>fs</code> Promises API</a>
+<li><a href="#fs_ordering_of_callback_and_promise_based_operations">Ordering of callback and promise-based operations</a></li>
+<li><a href="#fs_file_paths">File paths</a>
 <ul>
-<li><a href="#fs_class_filehandle">Class: <code>FileHandle</code></a>
+<li><a href="#fs_string_paths">String paths</a></li>
+<li><a href="#fs_file_url_paths">File URL paths</a>
 <ul>
-<li><a href="#fs_filehandle_appendfile_data_options"><code>filehandle.appendFile(data, options)</code></a></li>
-<li><a href="#fs_filehandle_chmod_mode"><code>filehandle.chmod(mode)</code></a></li>
-<li><a href="#fs_filehandle_chown_uid_gid"><code>filehandle.chown(uid, gid)</code></a></li>
-<li><a href="#fs_filehandle_close"><code>filehandle.close()</code></a></li>
-<li><a href="#fs_filehandle_datasync"><code>filehandle.datasync()</code></a></li>
-<li><a href="#fs_filehandle_fd"><code>filehandle.fd</code></a></li>
-<li><a href="#fs_filehandle_read_buffer_offset_length_position"><code>filehandle.read(buffer, offset, length, position)</code></a></li>
-<li><a href="#fs_filehandle_read_options"><code>filehandle.read(options)</code></a></li>
-<li><a href="#fs_filehandle_readfile_options"><code>filehandle.readFile(options)</code></a></li>
-<li><a href="#fs_filehandle_readv_buffers_position"><code>filehandle.readv(buffers[, position])</code></a></li>
-<li><a href="#fs_filehandle_stat_options"><code>filehandle.stat([options])</code></a></li>
-<li><a href="#fs_filehandle_sync"><code>filehandle.sync()</code></a></li>
-<li><a href="#fs_filehandle_truncate_len"><code>filehandle.truncate(len)</code></a></li>
-<li><a href="#fs_filehandle_utimes_atime_mtime"><code>filehandle.utimes(atime, mtime)</code></a></li>
-<li><a href="#fs_filehandle_write_buffer_offset_length_position"><code>filehandle.write(buffer[, offset[, length[, position]]])</code></a></li>
-<li><a href="#fs_filehandle_write_string_position_encoding"><code>filehandle.write(string[, position[, encoding]])</code></a></li>
-<li><a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile(data, options)</code></a></li>
-<li><a href="#fs_filehandle_writev_buffers_position"><code>filehandle.writev(buffers[, position])</code></a></li>
+<li><a href="#fs_platform_specific_considerations">Platform-specific considerations</a></li>
 </ul>
 </li>
-<li><a href="#fs_fspromises_access_path_mode"><code>fsPromises.access(path[, mode])</code></a></li>
-<li><a href="#fs_fspromises_appendfile_path_data_options"><code>fsPromises.appendFile(path, data[, options])</code></a></li>
-<li><a href="#fs_fspromises_chmod_path_mode"><code>fsPromises.chmod(path, mode)</code></a></li>
-<li><a href="#fs_fspromises_chown_path_uid_gid"><code>fsPromises.chown(path, uid, gid)</code></a></li>
-<li><a href="#fs_fspromises_copyfile_src_dest_flags"><code>fsPromises.copyFile(src, dest[, flags])</code></a></li>
-<li><a href="#fs_fspromises_lchmod_path_mode"><code>fsPromises.lchmod(path, mode)</code></a></li>
-<li><a href="#fs_fspromises_lchown_path_uid_gid"><code>fsPromises.lchown(path, uid, gid)</code></a></li>
-<li><a href="#fs_fspromises_lutimes_path_atime_mtime"><code>fsPromises.lutimes(path, atime, mtime)</code></a></li>
-<li><a href="#fs_fspromises_link_existingpath_newpath"><code>fsPromises.link(existingPath, newPath)</code></a></li>
-<li><a href="#fs_fspromises_lstat_path_options"><code>fsPromises.lstat(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_mkdir_path_options"><code>fsPromises.mkdir(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_mkdtemp_prefix_options"><code>fsPromises.mkdtemp(prefix[, options])</code></a></li>
-<li><a href="#fs_fspromises_open_path_flags_mode"><code>fsPromises.open(path, flags[, mode])</code></a></li>
-<li><a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_readdir_path_options"><code>fsPromises.readdir(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_readfile_path_options"><code>fsPromises.readFile(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_readlink_path_options"><code>fsPromises.readlink(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_realpath_path_options"><code>fsPromises.realpath(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_rename_oldpath_newpath"><code>fsPromises.rename(oldPath, newPath)</code></a></li>
-<li><span class="stability_1"><a href="#fs_fspromises_rmdir_path_options"><code>fsPromises.rmdir(path[, options])</code></a></span></li>
-<li><a href="#fs_fspromises_stat_path_options"><code>fsPromises.stat(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_symlink_target_path_type"><code>fsPromises.symlink(target, path[, type])</code></a></li>
-<li><a href="#fs_fspromises_truncate_path_len"><code>fsPromises.truncate(path[, len])</code></a></li>
-<li><a href="#fs_fspromises_unlink_path"><code>fsPromises.unlink(path)</code></a></li>
-<li><a href="#fs_fspromises_utimes_path_atime_mtime"><code>fsPromises.utimes(path, atime, mtime)</code></a></li>
-<li><a href="#fs_fspromises_writefile_file_data_options"><code>fsPromises.writeFile(file, data[, options])</code></a></li>
+<li><a href="#fs_buffer_paths">Buffer paths</a></li>
+<li><a href="#fs_per_drive_working_directories_on_windows">Per-drive working directories on Windows</a></li>
 </ul>
 </li>
-<li><a href="#fs_fs_constants_1">FS constants</a>
-<ul>
-<li><a href="#fs_file_access_constants">File access constants</a></li>
-<li><a href="#fs_file_copy_constants">File copy constants</a></li>
-<li><a href="#fs_file_open_constants">File open constants</a></li>
-<li><a href="#fs_file_type_constants">File type constants</a></li>
-<li><a href="#fs_file_mode_constants">File mode constants</a></li>
+<li><a href="#fs_file_descriptors_1">File descriptors</a></li>
+<li><a href="#fs_threadpool_usage">Threadpool usage</a></li>
+<li><a href="#fs_file_system_flags">File system flags</a></li>
 </ul>
 </li>
-<li><a href="#fs_file_system_flags">File system flags</a></li>
 </ul>
 </li>
 <li><a href="#globals_global_objects">Global objects</a>
 <ul>
+<li><span class="stability_1"><a href="#globals_class_abortcontroller">Class: <code>AbortController</code></a></span>
+<ul>
+<li><a href="#globals_abortcontroller_abort"><code>abortController.abort()</code></a></li>
+<li><a href="#globals_abortcontroller_signal"><code>abortController.signal</code></a></li>
+<li><a href="#globals_class_abortsignal">Class: <code>AbortSignal</code></a>
+<ul>
+<li><a href="#globals_static_method_abortsignal_abort">Static method: <code>AbortSignal.abort()</code></a></li>
+<li><a href="#globals_event_abort">Event: <code>'abort'</code></a></li>
+<li><a href="#globals_abortsignal_aborted"><code>abortSignal.aborted</code></a></li>
+<li><a href="#globals_abortsignal_onabort"><code>abortSignal.onabort</code></a></li>
+</ul>
+</li>
+</ul>
+</li>
 <li><a href="#globals_class_buffer">Class: <code>Buffer</code></a></li>
 <li><a href="#globals_dirname"><code>__dirname</code></a></li>
 <li><a href="#globals_filename"><code>__filename</code></a></li>
@@ -2150,13 +2335,19 @@
 <li><a href="#http_event_socket">Event: <code>'socket'</code></a></li>
 <li><a href="#http_event_timeout">Event: <code>'timeout'</code></a></li>
 <li><a href="#http_event_upgrade">Event: <code>'upgrade'</code></a></li>
-<li><a href="#http_request_abort"><code>request.abort()</code></a></li>
+<li><span class="stability_0"><a href="#http_request_abort"><code>request.abort()</code></a></span></li>
 <li><a href="#http_request_aborted"><code>request.aborted</code></a></li>
-<li><a href="#http_request_connection"><code>request.connection</code></a></li>
+<li><span class="stability_0"><a href="#http_request_connection"><code>request.connection</code></a></span></li>
 <li><a href="#http_request_end_data_encoding_callback"><code>request.end([data[, encoding]][, callback])</code></a></li>
+<li><a href="#http_request_destroy_error"><code>request.destroy([error])</code></a>
+<ul>
+<li><a href="#http_request_destroyed"><code>request.destroyed</code></a></li>
+</ul>
+</li>
 <li><span class="stability_0"><a href="#http_request_finished"><code>request.finished</code></a></span></li>
 <li><a href="#http_request_flushheaders"><code>request.flushHeaders()</code></a></li>
 <li><a href="#http_request_getheader_name"><code>request.getHeader(name)</code></a></li>
+<li><a href="#http_request_getrawheadernames"><code>request.getRawHeaderNames()</code></a></li>
 <li><a href="#http_request_maxheaderscount"><code>request.maxHeadersCount</code></a></li>
 <li><a href="#http_request_path"><code>request.path</code></a></li>
 <li><a href="#http_request_method"><code>request.method</code></a></li>
@@ -2189,6 +2380,7 @@
 <li><a href="#http_server_listen"><code>server.listen()</code></a></li>
 <li><a href="#http_server_listening"><code>server.listening</code></a></li>
 <li><a href="#http_server_maxheaderscount"><code>server.maxHeadersCount</code></a></li>
+<li><a href="#http_server_requesttimeout"><code>server.requestTimeout</code></a></li>
 <li><a href="#http_server_settimeout_msecs_callback"><code>server.setTimeout([msecs][, callback])</code></a></li>
 <li><a href="#http_server_timeout"><code>server.timeout</code></a></li>
 <li><a href="#http_server_keepalivetimeout"><code>server.keepAliveTimeout</code></a></li>
@@ -2199,7 +2391,7 @@
 <li><a href="#http_event_close_1">Event: <code>'close'</code></a></li>
 <li><a href="#http_event_finish">Event: <code>'finish'</code></a></li>
 <li><a href="#http_response_addtrailers_headers"><code>response.addTrailers(headers)</code></a></li>
-<li><a href="#http_response_connection"><code>response.connection</code></a></li>
+<li><span class="stability_0"><a href="#http_response_connection"><code>response.connection</code></a></span></li>
 <li><a href="#http_response_cork"><code>response.cork()</code></a></li>
 <li><a href="#http_response_end_data_encoding_callback"><code>response.end([data[, encoding]][, callback])</code></a></li>
 <li><span class="stability_0"><a href="#http_response_finished"><code>response.finished</code></a></span></li>
@@ -2245,6 +2437,37 @@
 <li><a href="#http_message_url"><code>message.url</code></a></li>
 </ul>
 </li>
+<li><a href="#http_class_http_outgoingmessage">Class: <code>http.OutgoingMessage</code></a>
+<ul>
+<li><a href="#http_event_drain">Event: <code>drain</code></a></li>
+<li><a href="#http_event_finish_1">Event: <code>finish</code></a></li>
+<li><a href="#http_event_prefinish">Event: <code>prefinish</code></a></li>
+<li><a href="#http_outgoingmessage_addtrailers_headers"><code>outgoingMessage.addTrailers(headers)</code></a></li>
+<li><span class="stability_0"><a href="#http_outgoingmessage_connection"><code>outgoingMessage.connection</code></a></span></li>
+<li><a href="#http_outgoingmessage_cork"><code>outgoingMessage.cork()</code></a></li>
+<li><a href="#http_outgoingmessage_destroy_error"><code>outgoingMessage.destroy([error])</code></a></li>
+<li><a href="#http_outgoingmessage_end_chunk_encoding_callback"><code>outgoingMessage.end(chunk[, encoding][, callback])</code></a></li>
+<li><a href="#http_outgoingmessage_flushheaders"><code>outgoingMessage.flushHeaders()</code></a></li>
+<li><a href="#http_outgoingmessage_getheader_name"><code>outgoingMessage.getHeader(name)</code></a></li>
+<li><a href="#http_outgoingmessage_getheadernames"><code>outgoingMessage.getHeaderNames()</code></a></li>
+<li><a href="#http_outgoingmessage_getheaders"><code>outgoingMessage.getHeaders()</code></a></li>
+<li><a href="#http_outgoingmessage_hasheader_name"><code>outgoingMessage.hasHeader(name)</code></a></li>
+<li><a href="#http_outgoingmessage_headerssent"><code>outgoingMessage.headersSent</code></a></li>
+<li><a href="#http_outgoingmessage_pipe"><code>outgoingMessage.pipe()</code></a></li>
+<li><a href="#http_outgoingmessage_removeheader"><code>outgoingMessage.removeHeader()</code></a></li>
+<li><a href="#http_outgoingmessage_setheader_name_value"><code>outgoingMessage.setHeader(name, value)</code></a></li>
+<li><a href="#http_outgoingmessage_settimeout_msesc_callback"><code>outgoingMessage.setTimeout(msesc[, callback])</code></a></li>
+<li><a href="#http_outgoingmessage_socket"><code>outgoingMessage.socket</code></a></li>
+<li><a href="#http_outgoingmessage_uncork"><code>outgoingMessage.uncork()</code></a></li>
+<li><a href="#http_outgoingmessage_writablecorked"><code>outgoingMessage.writableCorked</code></a></li>
+<li><a href="#http_outgoingmessage_writableended"><code>outgoingMessage.writableEnded</code></a></li>
+<li><a href="#http_outgoingmessage_writablefinished"><code>outgoingMessage.writableFinished</code></a></li>
+<li><a href="#http_outgoingmessage_writablehighwatermark"><code>outgoingMessage.writableHighWaterMark</code></a></li>
+<li><a href="#http_outgoingmessage_writablelength"><code>outgoingMessage.writableLength</code></a></li>
+<li><a href="#http_outgoingmessage_writableobjectmode"><code>outgoingMessage.writableObjectMode</code></a></li>
+<li><a href="#http_outgoingmessage_write_chunk_encoding_callback"><code>outgoingMessage.write(chunk[, encoding][, callback])</code></a></li>
+</ul>
+</li>
 <li><a href="#http_http_methods"><code>http.METHODS</code></a></li>
 <li><a href="#http_http_status_codes"><code>http.STATUS_CODES</code></a></li>
 <li><a href="#http_http_createserver_options_requestlistener"><code>http.createServer([options][, requestListener])</code></a></li>
@@ -2254,6 +2477,8 @@
 <li><a href="#http_http_maxheadersize"><code>http.maxHeaderSize</code></a></li>
 <li><a href="#http_http_request_options_callback"><code>http.request(options[, callback])</code></a></li>
 <li><a href="#http_http_request_url_options_callback"><code>http.request(url[, options][, callback])</code></a></li>
+<li><a href="#http_http_validateheadername_name"><code>http.validateHeaderName(name)</code></a></li>
+<li><a href="#http_http_validateheadervalue_name_value"><code>http.validateHeaderValue(name, value)</code></a></li>
 </ul>
 </li>
 <li><span class="stability_2"><a href="#http2_http_2">HTTP/2</a></span>
@@ -2289,6 +2514,7 @@
 <li><a href="#http2_http2session_ping_payload_callback"><code>http2session.ping([payload, ]callback)</code></a></li>
 <li><a href="#http2_http2session_ref"><code>http2session.ref()</code></a></li>
 <li><a href="#http2_http2session_remotesettings"><code>http2session.remoteSettings</code></a></li>
+<li><a href="#http2_http2session_setlocalwindowsize_windowsize"><code>http2session.setLocalWindowSize(windowSize)</code></a></li>
 <li><a href="#http2_http2session_settimeout_msecs_callback"><code>http2session.setTimeout(msecs, callback)</code></a></li>
 <li><a href="#http2_http2session_socket"><code>http2session.socket</code></a></li>
 <li><a href="#http2_http2session_state"><code>http2session.state</code></a></li>
@@ -2368,10 +2594,7 @@
 <li><a href="#http2_class_http2server">Class: <code>Http2Server</code></a>
 <ul>
 <li><a href="#http2_event_checkcontinue">Event: <code>'checkContinue'</code></a></li>
-</ul>
-</li>
-<li><a href="#http2_event_connection">Event: <code>'connection'</code></a>
-<ul>
+<li><a href="#http2_event_connection">Event: <code>'connection'</code></a></li>
 <li><a href="#http2_event_request">Event: <code>'request'</code></a></li>
 <li><a href="#http2_event_session">Event: <code>'session'</code></a></li>
 <li><a href="#http2_event_sessionerror">Event: <code>'sessionError'</code></a></li>
@@ -2379,15 +2602,14 @@
 <li><a href="#http2_event_timeout_2">Event: <code>'timeout'</code></a></li>
 <li><a href="#http2_server_close_callback"><code>server.close([callback])</code></a></li>
 <li><a href="#http2_server_settimeout_msecs_callback"><code>server.setTimeout([msecs][, callback])</code></a></li>
+<li><a href="#http2_server_timeout"><code>server.timeout</code></a></li>
+<li><a href="#http2_server_updatesettings_settings"><code>server.updateSettings([settings])</code></a></li>
 </ul>
 </li>
 <li><a href="#http2_class_http2secureserver">Class: <code>Http2SecureServer</code></a>
 <ul>
 <li><a href="#http2_event_checkcontinue_1">Event: <code>'checkContinue'</code></a></li>
-</ul>
-</li>
-<li><a href="#http2_event_connection_1">Event: <code>'connection'</code></a>
-<ul>
+<li><a href="#http2_event_connection_1">Event: <code>'connection'</code></a></li>
 <li><a href="#http2_event_request_1">Event: <code>'request'</code></a></li>
 <li><a href="#http2_event_session_1">Event: <code>'session'</code></a></li>
 <li><a href="#http2_event_sessionerror_1">Event: <code>'sessionError'</code></a></li>
@@ -2396,6 +2618,8 @@
 <li><a href="#http2_event_unknownprotocol">Event: <code>'unknownProtocol'</code></a></li>
 <li><a href="#http2_server_close_callback_1"><code>server.close([callback])</code></a></li>
 <li><a href="#http2_server_settimeout_msecs_callback_1"><code>server.setTimeout([msecs][, callback])</code></a></li>
+<li><a href="#http2_server_timeout_1"><code>server.timeout</code></a></li>
+<li><a href="#http2_server_updatesettings_settings_1"><code>server.updateSettings([settings])</code></a></li>
 </ul>
 </li>
 <li><a href="#http2_http2_createserver_options_onrequesthandler"><code>http2.createServer(options[, onRequestHandler])</code></a></li>
@@ -2409,9 +2633,13 @@
 <li><a href="#http2_http2_getdefaultsettings"><code>http2.getDefaultSettings()</code></a></li>
 <li><a href="#http2_http2_getpackedsettings_settings"><code>http2.getPackedSettings([settings])</code></a></li>
 <li><a href="#http2_http2_getunpackedsettings_buf"><code>http2.getUnpackedSettings(buf)</code></a></li>
-<li><a href="#http2_headers_object">Headers object</a></li>
+<li><a href="#http2_http2_sensitiveheaders"><code>http2.sensitiveHeaders</code></a></li>
+<li><a href="#http2_headers_object">Headers object</a>
+<ul>
+<li><a href="#http2_sensitive_headers">Sensitive headers</a></li>
+</ul>
+</li>
 <li><a href="#http2_settings_object">Settings object</a></li>
-<li><a href="#http2_using_options_selectpadding">Using <code>options.selectPadding()</code></a></li>
 <li><a href="#http2_error_handling">Error handling</a></li>
 <li><a href="#http2_invalid_character_handling_in_header_names_and_values">Invalid character handling in header names and values</a></li>
 <li><a href="#http2_push_streams_on_the_client">Push streams on the client</a></li>
@@ -2429,6 +2657,7 @@
 <li><a href="#http2_request_aborted"><code>request.aborted</code></a></li>
 <li><a href="#http2_request_authority"><code>request.authority</code></a></li>
 <li><a href="#http2_request_complete"><code>request.complete</code></a></li>
+<li><span class="stability_0"><a href="#http2_request_connection"><code>request.connection</code></a></span></li>
 <li><a href="#http2_request_destroy_error"><code>request.destroy([error])</code></a></li>
 <li><a href="#http2_request_headers"><code>request.headers</code></a></li>
 <li><a href="#http2_request_httpversion"><code>request.httpVersion</code></a></li>
@@ -2448,7 +2677,8 @@
 <li><a href="#http2_event_close_3">Event: <code>'close'</code></a></li>
 <li><a href="#http2_event_finish">Event: <code>'finish'</code></a></li>
 <li><a href="#http2_response_addtrailers_headers"><code>response.addTrailers(headers)</code></a></li>
-<li><a href="#http2_response_connection"><code>response.connection</code></a></li>
+<li><span class="stability_0"><a href="#http2_response_connection"><code>response.connection</code></a></span></li>
+<li><a href="#http2_response_createpushresponse_headers_callback"><code>response.createPushResponse(headers, callback)</code></a></li>
 <li><a href="#http2_response_end_data_encoding_callback"><code>response.end([data[, encoding]][, callback])</code></a></li>
 <li><span class="stability_0"><a href="#http2_response_finished"><code>response.finished</code></a></span></li>
 <li><a href="#http2_response_getheader_name"><code>response.getHeader(name)</code></a></li>
@@ -2468,7 +2698,6 @@
 <li><a href="#http2_response_write_chunk_encoding_callback"><code>response.write(chunk[, encoding][, callback])</code></a></li>
 <li><a href="#http2_response_writecontinue"><code>response.writeContinue()</code></a></li>
 <li><a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead(statusCode[, statusMessage][, headers])</code></a></li>
-<li><a href="#http2_response_createpushresponse_headers_callback"><code>response.createPushResponse(headers, callback)</code></a></li>
 </ul>
 </li>
 </ul>
@@ -2493,6 +2722,7 @@
 <li><a href="#https_server_headerstimeout"><code>server.headersTimeout</code></a></li>
 <li><a href="#https_server_listen"><code>server.listen()</code></a></li>
 <li><a href="#https_server_maxheaderscount"><code>server.maxHeadersCount</code></a></li>
+<li><a href="#https_server_requesttimeout"><code>server.requestTimeout</code></a></li>
 <li><a href="#https_server_settimeout_msecs_callback"><code>server.setTimeout([msecs][, callback])</code></a></li>
 <li><a href="#https_server_timeout"><code>server.timeout</code></a></li>
 <li><a href="#https_server_keepalivetimeout"><code>server.keepAliveTimeout</code></a></li>
@@ -2506,7 +2736,7 @@
 <li><a href="#https_https_request_url_options_callback"><code>https.request(url[, options][, callback])</code></a></li>
 </ul>
 </li>
-<li><span class="stability_1"><a href="#inspector_inspector">Inspector</a></span>
+<li><span class="stability_2"><a href="#inspector_inspector">Inspector</a></span>
 <ul>
 <li><a href="#inspector_inspector_close"><code>inspector.close()</code></a></li>
 <li><a href="#inspector_inspector_console"><code>inspector.console</code></a></li>
@@ -2552,8 +2782,8 @@
 <li><span class="stability_2"><a href="#modules_modules_commonjs_modules">Modules: CommonJS modules</a></span>
 <ul>
 <li><a href="#modules_accessing_the_main_module">Accessing the main module</a></li>
-<li><a href="#modules_addenda_package_manager_tips">Addenda: Package manager tips</a></li>
-<li><a href="#modules_addenda_the_mjs_extension">Addenda: The <code>.mjs</code> extension</a></li>
+<li><a href="#modules_package_manager_tips">Package manager tips</a></li>
+<li><a href="#modules_the_mjs_extension">The <code>.mjs</code> extension</a></li>
 <li><a href="#modules_all_together">All together...</a></li>
 <li><a href="#modules_caching">Caching</a>
 <ul>
@@ -2597,6 +2827,7 @@
 </li>
 <li><a href="#modules_module_filename"><code>module.filename</code></a></li>
 <li><a href="#modules_module_id"><code>module.id</code></a></li>
+<li><a href="#modules_module_ispreloading"><code>module.isPreloading</code></a></li>
 <li><a href="#modules_module_loaded"><code>module.loaded</code></a></li>
 <li><span class="stability_0"><a href="#modules_module_parent"><code>module.parent</code></a></span></li>
 <li><a href="#modules_module_path"><code>module.path</code></a></li>
@@ -2615,39 +2846,48 @@
 <li><a href="#esm_packages">Packages</a></li>
 <li><a href="#esm_import_specifiers"><code>import</code> Specifiers</a>
 <ul>
-<li><a href="#esm_terminology">Terminology</a>
+<li><a href="#esm_terminology">Terminology</a></li>
+<li><a href="#esm_mandatory_file_extensions">Mandatory file extensions</a></li>
+<li><a href="#esm_urls">URLs</a>
 <ul>
-<li><a href="#esm_node_imports"><code>node:</code> Imports</a></li>
+<li><a href="#esm_file_urls"><code>file:</code> URLs</a></li>
 <li><a href="#esm_data_imports"><code>data:</code> Imports</a></li>
+<li><a href="#esm_node_imports"><code>node:</code> Imports</a></li>
 </ul>
 </li>
 </ul>
 </li>
-<li><a href="#esm_import_meta"><code>import.meta</code></a></li>
+<li><a href="#esm_builtin_modules">Builtin modules</a></li>
+<li><a href="#esm_import_expressions"><code>import()</code> expressions</a></li>
+<li><a href="#esm_import_meta"><code>import.meta</code></a>
+<ul>
+<li><a href="#esm_import_meta_url"><code>import.meta.url</code></a></li>
+<li><span class="stability_1"><a href="#esm_import_meta_resolve_specifier_parent"><code>import.meta.resolve(specifier[, parent])</code></a></span></li>
+</ul>
+</li>
+<li><a href="#esm_interoperability_with_commonjs">Interoperability with CommonJS</a>
+<ul>
+<li><a href="#esm_import_statements"><code>import</code> statements</a></li>
+<li><a href="#esm_require"><code>require</code></a></li>
+<li><a href="#esm_commonjs_namespaces">CommonJS Namespaces</a></li>
 <li><a href="#esm_differences_between_es_modules_and_commonjs">Differences between ES modules and CommonJS</a>
 <ul>
-<li><a href="#esm_mandatory_file_extensions">Mandatory file extensions</a></li>
-<li><a href="#esm_no_node_path">No <code>NODE_PATH</code></a></li>
-<li><a href="#esm_no_require_exports_module_exports_filename_dirname">No <code>require</code>, <code>exports</code>, <code>module.exports</code>, <code>__filename</code>, <code>__dirname</code></a></li>
+<li><a href="#esm_no_require_exports_or_module_exports">No <code>require</code>, <code>exports</code> or <code>module.exports</code></a></li>
+<li><a href="#esm_no_filename_or_dirname">No <code>__filename</code> or <code>__dirname</code></a></li>
+<li><a href="#esm_no_json_module_loading">No JSON Module Loading</a></li>
+<li><a href="#esm_no_native_module_loading">No Native Module Loading</a></li>
 <li><a href="#esm_no_require_resolve">No <code>require.resolve</code></a></li>
+<li><a href="#esm_no_node_path">No <code>NODE_PATH</code></a></li>
 <li><a href="#esm_no_require_extensions">No <code>require.extensions</code></a></li>
 <li><a href="#esm_no_require_cache">No <code>require.cache</code></a></li>
-<li><a href="#esm_url_based_paths">URL-based paths</a></li>
 </ul>
 </li>
-<li><a href="#esm_interoperability_with_commonjs">Interoperability with CommonJS</a>
-<ul>
-<li><a href="#esm_require"><code>require</code></a></li>
-<li><a href="#esm_import_statements"><code>import</code> statements</a></li>
-<li><a href="#esm_import_expressions"><code>import()</code> expressions</a></li>
 </ul>
 </li>
-<li><a href="#esm_commonjs_namespaces">CommonJS Namespaces</a></li>
-<li><a href="#esm_builtin_modules">Builtin modules</a></li>
-<li><a href="#esm_commonjs_json_and_native_modules">CommonJS, JSON, and native modules</a></li>
-<li><a href="#esm_experimental_json_modules">Experimental JSON modules</a></li>
-<li><a href="#esm_experimental_wasm_modules">Experimental Wasm modules</a></li>
-<li><a href="#esm_experimental_loaders">Experimental loaders</a>
+<li><span class="stability_1"><a href="#esm_json_modules">JSON modules</a></span></li>
+<li><span class="stability_1"><a href="#esm_wasm_modules">Wasm modules</a></span></li>
+<li><span class="stability_1"><a href="#esm_top_level_await">Top-level <code>await</code></a></span></li>
+<li><span class="stability_1"><a href="#esm_loaders">Loaders</a></span>
 <ul>
 <li><a href="#esm_hooks">Hooks</a>
 <ul>
@@ -2656,7 +2896,6 @@
 <li><a href="#esm_getsource_url_context_defaultgetsource"><code>getSource(url, context, defaultGetSource)</code></a></li>
 <li><a href="#esm_transformsource_source_context_defaulttransformsource"><code>transformSource(source, context, defaultTransformSource)</code></a></li>
 <li><a href="#esm_getglobalpreloadcode"><code>getGlobalPreloadCode()</code></a></li>
-<li><a href="#esm_code_dynamicinstantiate_code_hook"><code>dynamicInstantiate</code> hook</a></li>
 </ul>
 </li>
 <li><a href="#esm_examples">Examples</a>
@@ -2672,7 +2911,7 @@
 <li><a href="#esm_features">Features</a></li>
 <li><a href="#esm_resolver_algorithm">Resolver algorithm</a></li>
 <li><a href="#esm_resolver_algorithm_specification">Resolver Algorithm Specification</a></li>
-<li><a href="#esm_customizing_esm_specifier_resolution_algorithm">Customizing ESM specifier resolution algorithm</a></li>
+<li><span class="stability_1"><a href="#esm_customizing_esm_specifier_resolution_algorithm">Customizing ESM specifier resolution algorithm</a></span></li>
 </ul>
 </li>
 </ul>
@@ -2689,7 +2928,7 @@
 </li>
 <li><span class="stability_1"><a href="#module_source_map_v3_support">Source map v3 support</a></span>
 <ul>
-<li><a href="#module_module_findsourcemap_path_error"><code>module.findSourceMap(path[, error])</code></a></li>
+<li><a href="#module_module_findsourcemap_path"><code>module.findSourceMap(path)</code></a></li>
 <li><a href="#module_class_module_sourcemap">Class: <code>module.SourceMap</code></a>
 <ul>
 <li><a href="#module_new_sourcemap_payload"><code>new SourceMap(payload)</code></a></li>
@@ -2720,6 +2959,7 @@
 <li><a href="#packages_conditional_exports">Conditional exports</a></li>
 <li><a href="#packages_nested_conditions">Nested conditions</a></li>
 <li><a href="#packages_resolving_user_conditions">Resolving user conditions</a></li>
+<li><a href="#packages_conditions_definitions">Conditions Definitions</a></li>
 <li><a href="#packages_self_referencing_a_package_using_its_name">Self-referencing a package using its name</a></li>
 </ul>
 </li>
@@ -2737,10 +2977,10 @@
 <li><a href="#packages_node_js_package_json_field_definitions">Node.js <code>package.json</code> field definitions</a>
 <ul>
 <li><a href="#packages_name"><code>"name"</code></a></li>
+<li><a href="#packages_main"><code>"main"</code></a></li>
 <li><a href="#packages_type"><code>"type"</code></a></li>
 <li><a href="#packages_exports"><code>"exports"</code></a></li>
-<li><a href="#packages_main"><code>"main"</code></a></li>
-<li><span class="stability_1"><a href="#packages_imports"><code>"imports"</code></a></span></li>
+<li><a href="#packages_imports"><code>"imports"</code></a></li>
 </ul>
 </li>
 </ul>
@@ -2752,6 +2992,24 @@
 <li><a href="#net_identifying_paths_for_ipc_connections">Identifying paths for IPC connections</a></li>
 </ul>
 </li>
+<li><a href="#net_class_net_blocklist">Class: <code>net.BlockList</code></a>
+<ul>
+<li><a href="#net_blocklist_addaddress_address_type"><code>blockList.addAddress(address[, type])</code></a></li>
+<li><a href="#net_blocklist_addrange_start_end_type"><code>blockList.addRange(start, end[, type])</code></a></li>
+<li><a href="#net_blocklist_addsubnet_net_prefix_type"><code>blockList.addSubnet(net, prefix[, type])</code></a></li>
+<li><a href="#net_blocklist_check_address_type"><code>blockList.check(address[, type])</code></a></li>
+<li><a href="#net_blocklist_rules"><code>blockList.rules</code></a></li>
+</ul>
+</li>
+<li><a href="#net_class_net_socketaddress">Class: <code>net.SocketAddress</code></a>
+<ul>
+<li><a href="#net_new_net_socketaddress_options"><code>new net.SocketAddress([options])</code></a></li>
+<li><a href="#net_socketaddress_address"><code>socketaddress.address</code></a></li>
+<li><a href="#net_socketaddress_family"><code>socketaddress.family</code></a></li>
+<li><a href="#net_socketaddress_flowlabel"><code>socketaddress.flowlabel</code></a></li>
+<li><a href="#net_socketaddress_port"><code>socketaddress.port</code></a></li>
+</ul>
+</li>
 <li><a href="#net_class_net_server">Class: <code>net.Server</code></a>
 <ul>
 <li><a href="#net_new_net_server_options_connectionlistener"><code>new net.Server([options][, connectionListener])</code></a></li>
@@ -2790,7 +3048,7 @@
 <li><a href="#net_event_ready">Event: <code>'ready'</code></a></li>
 <li><a href="#net_event_timeout">Event: <code>'timeout'</code></a></li>
 <li><a href="#net_socket_address"><code>socket.address()</code></a></li>
-<li><a href="#net_socket_buffersize"><code>socket.bufferSize</code></a></li>
+<li><span class="stability_0"><a href="#net_socket_buffersize"><code>socket.bufferSize</code></a></span></li>
 <li><a href="#net_socket_bytesread"><code>socket.bytesRead</code></a></li>
 <li><a href="#net_socket_byteswritten"><code>socket.bytesWritten</code></a></li>
 <li><a href="#net_socket_connect"><code>socket.connect()</code></a>
@@ -2817,8 +3075,10 @@
 <li><a href="#net_socket_setkeepalive_enable_initialdelay"><code>socket.setKeepAlive([enable][, initialDelay])</code></a></li>
 <li><a href="#net_socket_setnodelay_nodelay"><code>socket.setNoDelay([noDelay])</code></a></li>
 <li><a href="#net_socket_settimeout_timeout_callback"><code>socket.setTimeout(timeout[, callback])</code></a></li>
+<li><a href="#net_socket_timeout"><code>socket.timeout</code></a></li>
 <li><a href="#net_socket_unref"><code>socket.unref()</code></a></li>
 <li><a href="#net_socket_write_data_encoding_callback"><code>socket.write(data[, encoding][, callback])</code></a></li>
+<li><a href="#net_socket_readystate"><code>socket.readyState</code></a></li>
 </ul>
 </li>
 <li><a href="#net_net_connect"><code>net.connect()</code></a>
@@ -2847,6 +3107,7 @@
 <li><a href="#os_os_arch"><code>os.arch()</code></a></li>
 <li><a href="#os_os_constants"><code>os.constants</code></a></li>
 <li><a href="#os_os_cpus"><code>os.cpus()</code></a></li>
+<li><a href="#os_os_devnull"><code>os.devNull</code></a></li>
 <li><a href="#os_os_endianness"><code>os.endianness()</code></a></li>
 <li><a href="#os_os_freemem"><code>os.freemem()</code></a></li>
 <li><a href="#os_os_getpriority_pid"><code>os.getPriority([pid])</code></a></li>
@@ -2911,28 +3172,27 @@
 <li><a href="#perf_hooks_performance_now"><code>performance.now()</code></a></li>
 <li><a href="#perf_hooks_performance_timeorigin"><code>performance.timeOrigin</code></a></li>
 <li><a href="#perf_hooks_performance_timerify_fn"><code>performance.timerify(fn)</code></a></li>
-<li><a href="#perf_hooks_performance_eventlooputilization_util1_util2"><code>performance.eventLoopUtilization([util1][,util2])</code></a></li>
 </ul>
 </li>
 <li><a href="#perf_hooks_class_performanceentry">Class: <code>PerformanceEntry</code></a>
 <ul>
 <li><a href="#perf_hooks_performanceentry_duration"><code>performanceEntry.duration</code></a></li>
-<li><a href="#perf_hooks_performanceentry_name"><code>performanceEntry.name</code></a></li>
-<li><a href="#perf_hooks_performanceentry_starttime"><code>performanceEntry.startTime</code></a></li>
 <li><a href="#perf_hooks_performanceentry_entrytype"><code>performanceEntry.entryType</code></a></li>
+<li><a href="#perf_hooks_performanceentry_flags"><code>performanceEntry.flags</code></a></li>
+<li><a href="#perf_hooks_performanceentry_name"><code>performanceEntry.name</code></a></li>
 <li><a href="#perf_hooks_performanceentry_kind"><code>performanceEntry.kind</code></a></li>
-<li><a href="#perf_hooks_performanceentry_flags">performanceEntry.flags</a></li>
+<li><a href="#perf_hooks_performanceentry_starttime"><code>performanceEntry.startTime</code></a></li>
 </ul>
 </li>
-<li><a href="#perf_hooks_class_performancenodetiming_extends_performanceentry">Class: <code>PerformanceNodeTiming extends PerformanceEntry</code></a>
+<li><a href="#perf_hooks_class_performancenodetiming">Class: <code>PerformanceNodeTiming</code></a>
 <ul>
 <li><a href="#perf_hooks_performancenodetiming_bootstrapcomplete"><code>performanceNodeTiming.bootstrapComplete</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_environment"><code>performanceNodeTiming.environment</code></a></li>
+<li><a href="#perf_hooks_performancenodetiming_idletime"><code>performanceNodeTiming.idleTime</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_loopexit"><code>performanceNodeTiming.loopExit</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_loopstart"><code>performanceNodeTiming.loopStart</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_nodestart"><code>performanceNodeTiming.nodeStart</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_v8start"><code>performanceNodeTiming.v8Start</code></a></li>
-<li><a href="#perf_hooks_performancenodetiming_idletime"><code>performanceNodeTiming.idleTime</code></a></li>
 </ul>
 </li>
 <li><a href="#perf_hooks_class_perf_hooks_performanceobserver">Class: <code>perf_hooks.PerformanceObserver</code></a>
@@ -2949,12 +3209,10 @@
 <li><a href="#perf_hooks_performanceobserverentrylist_getentriesbytype_type"><code>performanceObserverEntryList.getEntriesByType(type)</code></a></li>
 </ul>
 </li>
-<li><a href="#perf_hooks_perf_hooks_monitoreventloopdelay_options"><code>perf_hooks.monitorEventLoopDelay([options])</code></a>
-<ul>
+<li><a href="#perf_hooks_perf_hooks_createhistogram_options"><code>perf_hooks.createHistogram([options])</code></a></li>
+<li><a href="#perf_hooks_perf_hooks_monitoreventloopdelay_options"><code>perf_hooks.monitorEventLoopDelay([options])</code></a></li>
 <li><a href="#perf_hooks_class_histogram">Class: <code>Histogram</code></a>
 <ul>
-<li><a href="#perf_hooks_histogram_disable"><code>histogram.disable()</code></a></li>
-<li><a href="#perf_hooks_histogram_enable"><code>histogram.enable()</code></a></li>
 <li><a href="#perf_hooks_histogram_exceeds"><code>histogram.exceeds</code></a></li>
 <li><a href="#perf_hooks_histogram_max"><code>histogram.max</code></a></li>
 <li><a href="#perf_hooks_histogram_mean"><code>histogram.mean</code></a></li>
@@ -2965,6 +3223,17 @@
 <li><a href="#perf_hooks_histogram_stddev"><code>histogram.stddev</code></a></li>
 </ul>
 </li>
+<li><a href="#perf_hooks_class_intervalhistogram_extends_histogram">Class: <code>IntervalHistogram extends Histogram</code></a>
+<ul>
+<li><a href="#perf_hooks_histogram_disable"><code>histogram.disable()</code></a></li>
+<li><a href="#perf_hooks_histogram_enable"><code>histogram.enable()</code></a></li>
+<li><a href="#perf_hooks_cloning_an_intervalhistogram">Cloning an <code>IntervalHistogram</code></a></li>
+</ul>
+</li>
+<li><a href="#perf_hooks_class_recordablehistogram_extends_histogram">Class: <code>RecordableHistogram extends Histogram</code></a>
+<ul>
+<li><a href="#perf_hooks_histogram_record_val"><code>histogram.record(val)</code></a></li>
+<li><a href="#perf_hooks_histogram_recorddelta"><code>histogram.recordDelta()</code></a></li>
 </ul>
 </li>
 <li><a href="#perf_hooks_examples">Examples</a>
@@ -2987,6 +3256,14 @@
 <li><a href="#policy_example_patched_dependency">Example: Patched dependency</a></li>
 </ul>
 </li>
+<li><a href="#policy_scopes">Scopes</a>
+<ul>
+<li><a href="#policy_example">Example</a></li>
+<li><a href="#policy_integrity_using_scopes">Integrity using scopes</a></li>
+<li><a href="#policy_dependency_redirection_using_scopes">Dependency redirection using scopes</a></li>
+<li><a href="#policy_example_import_maps_emulation">Example: [import maps][] emulation</a></li>
+</ul>
+</li>
 </ul>
 </li>
 </ul>
@@ -3008,9 +3285,11 @@
 </li>
 <li><a href="#process_event_uncaughtexceptionmonitor">Event: <code>'uncaughtExceptionMonitor'</code></a></li>
 <li><a href="#process_event_unhandledrejection">Event: <code>'unhandledRejection'</code></a></li>
-<li><a href="#process_event_warning">Event: <code>'warning'</code></a>
+<li><a href="#process_event_warning">Event: <code>'warning'</code></a></li>
+<li><a href="#process_event_worker">Event: <code>'worker'</code></a>
 <ul>
 <li><a href="#process_emitting_custom_warnings">Emitting custom warnings</a></li>
+<li><a href="#process_node_js_warning_names">Node.js warning names</a></li>
 </ul>
 </li>
 <li><a href="#process_signal_events">Signal events</a></li>
@@ -3021,7 +3300,12 @@
 <li><a href="#process_process_arch"><code>process.arch</code></a></li>
 <li><a href="#process_process_argv"><code>process.argv</code></a></li>
 <li><a href="#process_process_argv0"><code>process.argv0</code></a></li>
-<li><a href="#process_process_channel"><code>process.channel</code></a></li>
+<li><a href="#process_process_channel"><code>process.channel</code></a>
+<ul>
+<li><a href="#process_process_channel_ref"><code>process.channel.ref()</code></a></li>
+<li><a href="#process_process_channel_unref"><code>process.channel.unref()</code></a></li>
+</ul>
+</li>
 <li><a href="#process_process_chdir_directory"><code>process.chdir(directory)</code></a></li>
 <li><a href="#process_process_config"><code>process.config</code></a></li>
 <li><a href="#process_process_connected"><code>process.connected</code></a></li>
@@ -3047,13 +3331,18 @@
 <li><a href="#process_process_getgroups"><code>process.getgroups()</code></a></li>
 <li><a href="#process_process_getuid"><code>process.getuid()</code></a></li>
 <li><a href="#process_process_hasuncaughtexceptioncapturecallback"><code>process.hasUncaughtExceptionCaptureCallback()</code></a></li>
-<li><a href="#process_process_hrtime_time"><code>process.hrtime([time])</code></a></li>
+<li><span class="stability_3"><a href="#process_process_hrtime_time"><code>process.hrtime([time])</code></a></span></li>
 <li><a href="#process_process_hrtime_bigint"><code>process.hrtime.bigint()</code></a></li>
 <li><a href="#process_process_initgroups_user_extragroup"><code>process.initgroups(user, extraGroup)</code></a></li>
 <li><a href="#process_process_kill_pid_signal"><code>process.kill(pid[, signal])</code></a></li>
-<li><a href="#process_process_mainmodule"><code>process.mainModule</code></a></li>
+<li><span class="stability_0"><a href="#process_process_mainmodule"><code>process.mainModule</code></a></span></li>
 <li><a href="#process_process_memoryusage"><code>process.memoryUsage()</code></a></li>
-<li><a href="#process_process_nexttick_callback_args"><code>process.nextTick(callback[, ...args])</code></a></li>
+<li><a href="#process_process_memoryusage_rss"><code>process.memoryUsage.rss()</code></a></li>
+<li><a href="#process_process_nexttick_callback_args"><code>process.nextTick(callback[, ...args])</code></a>
+<ul>
+<li><a href="#process_when_to_use_queuemicrotask_vs_process_nexttick">When to use <code>queueMicrotask()</code> vs. <code>process.nextTick()</code></a></li>
+</ul>
+</li>
 <li><a href="#process_process_nodeprecation"><code>process.noDeprecation</code></a></li>
 <li><a href="#process_process_pid"><code>process.pid</code></a></li>
 <li><a href="#process_process_platform"><code>process.platform</code></a></li>
@@ -3065,7 +3354,7 @@
 <li><a href="#process_process_report_directory"><code>process.report.directory</code></a></li>
 <li><a href="#process_process_report_filename"><code>process.report.filename</code></a></li>
 <li><a href="#process_process_report_getreport_err"><code>process.report.getReport([err])</code></a></li>
-<li><span class="stability_1"><a href="#process_process_report_reportonfatalerror"><code>process.report.reportOnFatalError</code></a></span></li>
+<li><a href="#process_process_report_reportonfatalerror"><code>process.report.reportOnFatalError</code></a></li>
 <li><a href="#process_process_report_reportonsignal"><code>process.report.reportOnSignal</code></a></li>
 <li><a href="#process_process_report_reportonuncaughtexception"><code>process.report.reportOnUncaughtException</code></a></li>
 <li><a href="#process_process_report_signal"><code>process.report.signal</code></a></li>
@@ -3079,6 +3368,7 @@
 <li><a href="#process_process_setgid_id"><code>process.setgid(id)</code></a></li>
 <li><a href="#process_process_setgroups_groups"><code>process.setgroups(groups)</code></a></li>
 <li><a href="#process_process_setuid_id"><code>process.setuid(id)</code></a></li>
+<li><span class="stability_1"><a href="#process_process_setsourcemapsenabled_val"><code>process.setSourceMapsEnabled(val)</code></a></span></li>
 <li><a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback(fn)</code></a></li>
 <li><a href="#process_process_stderr"><code>process.stderr</code></a>
 <ul>
@@ -3122,7 +3412,7 @@
 <li><a href="#punycode_punycode_version"><code>punycode.version</code></a></li>
 </ul>
 </li>
-<li><span class="stability_2"><a href="#querystring_query_string">Query string</a></span>
+<li><span class="stability_3"><a href="#querystring_query_string">Query string</a></span>
 <ul>
 <li><a href="#querystring_querystring_decode"><code>querystring.decode()</code></a></li>
 <li><a href="#querystring_querystring_encode"><code>querystring.encode()</code></a></li>
@@ -3138,6 +3428,7 @@
 <ul>
 <li><a href="#readline_event_close">Event: <code>'close'</code></a></li>
 <li><a href="#readline_event_line">Event: <code>'line'</code></a></li>
+<li><a href="#readline_event_history">Event: <code>'history'</code></a></li>
 <li><a href="#readline_event_pause">Event: <code>'pause'</code></a></li>
 <li><a href="#readline_event_resume">Event: <code>'resume'</code></a></li>
 <li><a href="#readline_event_sigcont">Event: <code>'SIGCONT'</code></a></li>
@@ -3146,13 +3437,14 @@
 <li><a href="#readline_rl_close"><code>rl.close()</code></a></li>
 <li><a href="#readline_rl_pause"><code>rl.pause()</code></a></li>
 <li><a href="#readline_rl_prompt_preservecursor"><code>rl.prompt([preserveCursor])</code></a></li>
-<li><a href="#readline_rl_question_query_callback"><code>rl.question(query, callback)</code></a></li>
+<li><a href="#readline_rl_question_query_options_callback"><code>rl.question(query[, options], callback)</code></a></li>
 <li><a href="#readline_rl_resume"><code>rl.resume()</code></a></li>
 <li><a href="#readline_rl_setprompt_prompt"><code>rl.setPrompt(prompt)</code></a></li>
+<li><a href="#readline_rl_getprompt"><code>rl.getPrompt()</code></a></li>
 <li><a href="#readline_rl_write_data_key"><code>rl.write(data[, key])</code></a></li>
 <li><a href="#readline_rl_symbol_asynciterator"><code>rl[Symbol.asyncIterator]()</code></a></li>
-<li><a href="#readline_rl_line">rl.line</a></li>
-<li><a href="#readline_rl_cursor">rl.cursor</a></li>
+<li><a href="#readline_rl_line"><code>rl.line</code></a></li>
+<li><a href="#readline_rl_cursor"><code>rl.cursor</code></a></li>
 <li><a href="#readline_rl_getcursorpos"><code>rl.getCursorPos()</code></a></li>
 </ul>
 </li>
@@ -3206,6 +3498,7 @@
 <li><a href="#repl_replserver_setuphistory_historypath_callback"><code>replServer.setupHistory(historyPath, callback)</code></a></li>
 </ul>
 </li>
+<li><a href="#repl_repl_builtinmodules"><code>repl.builtinModules</code></a></li>
 <li><a href="#repl_repl_start_options"><code>repl.start([options])</code></a></li>
 <li><a href="#repl_the_node_js_repl">The Node.js REPL</a>
 <ul>
@@ -3257,6 +3550,7 @@
 <li><a href="#stream_writable_writablefinished"><code>writable.writableFinished</code></a></li>
 <li><a href="#stream_writable_writablehighwatermark"><code>writable.writableHighWaterMark</code></a></li>
 <li><a href="#stream_writable_writablelength"><code>writable.writableLength</code></a></li>
+<li><a href="#stream_writable_writableneeddrain"><code>writable.writableNeedDrain</code></a></li>
 <li><a href="#stream_writable_writableobjectmode"><code>writable.writableObjectMode</code></a></li>
 <li><a href="#stream_writable_write_chunk_encoding_callback"><code>writable.write(chunk[, encoding][, callback])</code></a></li>
 </ul>
@@ -3284,6 +3578,7 @@
 <li><a href="#stream_readable_pipe_destination_options"><code>readable.pipe(destination[, options])</code></a></li>
 <li><a href="#stream_readable_read_size"><code>readable.read([size])</code></a></li>
 <li><a href="#stream_readable_readable"><code>readable.readable</code></a></li>
+<li><a href="#stream_readable_readabledidread"><code>readable.readableDidRead</code></a></li>
 <li><a href="#stream_readable_readableencoding"><code>readable.readableEncoding</code></a></li>
 <li><a href="#stream_readable_readableended"><code>readable.readableEnded</code></a></li>
 <li><a href="#stream_readable_readableflowing"><code>readable.readableFlowing</code></a></li>
@@ -3311,7 +3606,8 @@
 </ul>
 </li>
 <li><a href="#stream_stream_finished_stream_options_callback"><code>stream.finished(stream[, options], callback)</code></a></li>
-<li><a href="#stream_stream_pipeline_streams_callback"><code>stream.pipeline(...streams, callback)</code></a></li>
+<li><a href="#stream_stream_pipeline_source_transforms_destination_callback"><code>stream.pipeline(source[, ...transforms], destination, callback)</code></a></li>
+<li><a href="#stream_stream_pipeline_streams_callback"><code>stream.pipeline(streams, callback)</code></a></li>
 <li><a href="#stream_stream_readable_from_iterable_options"><code>stream.Readable.from(iterable, [options])</code></a></li>
 </ul>
 </li>
@@ -3350,7 +3646,8 @@
 <li><a href="#stream_implementing_a_transform_stream">Implementing a transform stream</a>
 <ul>
 <li><a href="#stream_new_stream_transform_options"><code>new stream.Transform([options])</code></a></li>
-<li><a href="#stream_events_finish_and_end">Events: <code>'finish'</code> and <code>'end'</code></a></li>
+<li><a href="#stream_event_end_1">Event: <code>'end'</code></a></li>
+<li><a href="#stream_event_finish_1">Event: <code>'finish'</code></a></li>
 <li><a href="#stream_transform_flush_callback"><code>transform._flush(callback)</code></a></li>
 <li><a href="#stream_transform_transform_chunk_encoding_callback"><code>transform._transform(chunk, encoding, callback)</code></a></li>
 <li><a href="#stream_class_stream_passthrough">Class: <code>stream.PassThrough</code></a></li>
@@ -3407,8 +3704,8 @@
 <li><a href="#timers_scheduling_timers">Scheduling timers</a>
 <ul>
 <li><a href="#timers_setimmediate_callback_args"><code>setImmediate(callback[, ...args])</code></a></li>
-<li><a href="#timers_setinterval_callback_delay_args"><code>setInterval(callback, delay[, ...args])</code></a></li>
-<li><a href="#timers_settimeout_callback_delay_args"><code>setTimeout(callback, delay[, ...args])</code></a></li>
+<li><a href="#timers_setinterval_callback_delay_args"><code>setInterval(callback[, delay[, ...args]])</code></a></li>
+<li><a href="#timers_settimeout_callback_delay_args"><code>setTimeout(callback[, delay[, ...args]])</code></a></li>
 </ul>
 </li>
 <li><a href="#timers_cancelling_timers">Cancelling timers</a>
@@ -3617,7 +3914,11 @@
 </li>
 <li><span class="stability_2"><a href="#url_url">URL</a></span>
 <ul>
-<li><a href="#url_url_strings_and_url_objects">URL strings and URL objects</a></li>
+<li><a href="#url_url_strings_and_url_objects">URL strings and URL objects</a>
+<ul>
+<li><a href="#url_constructing_a_url_from_component_parts_and_getting_the_constructed_string">Constructing a URL from component parts and getting the constructed string</a></li>
+</ul>
+</li>
 <li><a href="#url_the_whatwg_url_api">The WHATWG URL API</a>
 <ul>
 <li><a href="#url_class_url">Class: <code>URL</code></a>
@@ -3669,11 +3970,12 @@
 <li><a href="#url_url_fileurltopath_url"><code>url.fileURLToPath(url)</code></a></li>
 <li><a href="#url_url_format_url_options"><code>url.format(URL[, options])</code></a></li>
 <li><a href="#url_url_pathtofileurl_path"><code>url.pathToFileURL(path)</code></a></li>
+<li><a href="#url_url_urltohttpoptions_url"><code>url.urlToHttpOptions(url)</code></a></li>
 </ul>
 </li>
-<li><a href="#url_legacy_url_api">Legacy URL API</a>
+<li><span class="stability_3"><a href="#url_legacy_url_api">Legacy URL API</a></span>
 <ul>
-<li><span class="stability_0"><a href="#url_legacy_urlobject">Legacy <code>urlObject</code></a></span>
+<li><span class="stability_3"><a href="#url_legacy_urlobject">Legacy <code>urlObject</code></a></span>
 <ul>
 <li><a href="#url_urlobject_auth"><code>urlObject.auth</code></a></li>
 <li><a href="#url_urlobject_hash"><code>urlObject.hash</code></a></li>
@@ -3689,9 +3991,9 @@
 <li><a href="#url_urlobject_slashes"><code>urlObject.slashes</code></a></li>
 </ul>
 </li>
-<li><span class="stability_0"><a href="#url_url_format_urlobject"><code>url.format(urlObject)</code></a></span></li>
-<li><span class="stability_0"><a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse(urlString[, parseQueryString[, slashesDenoteHost]])</code></a></span></li>
-<li><span class="stability_0"><a href="#url_url_resolve_from_to"><code>url.resolve(from, to)</code></a></span></li>
+<li><span class="stability_3"><a href="#url_url_format_urlobject"><code>url.format(urlObject)</code></a></span></li>
+<li><span class="stability_3"><a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse(urlString[, parseQueryString[, slashesDenoteHost]])</code></a></span></li>
+<li><span class="stability_3"><a href="#url_url_resolve_from_to"><code>url.resolve(from, to)</code></a></span></li>
 </ul>
 </li>
 <li><a href="#url_percent_encoding_in_urls">Percent-encoding in URLs</a>
@@ -3705,12 +4007,18 @@
 <li><span class="stability_2"><a href="#util_util">Util</a></span>
 <ul>
 <li><a href="#util_util_callbackify_original"><code>util.callbackify(original)</code></a></li>
-<li><a href="#util_util_debuglog_section_callback"><code>util.debuglog(section[, callback])</code></a></li>
+<li><a href="#util_util_debuglog_section_callback"><code>util.debuglog(section[, callback])</code></a>
+<ul>
+<li><a href="#util_debuglog_enabled"><code>debuglog().enabled</code></a></li>
+</ul>
+</li>
+<li><a href="#util_util_debug_section"><code>util.debug(section)</code></a></li>
 <li><a href="#util_util_deprecate_fn_msg_code"><code>util.deprecate(fn, msg[, code])</code></a></li>
 <li><a href="#util_util_format_format_args"><code>util.format(format[, ...args])</code></a></li>
 <li><a href="#util_util_formatwithoptions_inspectoptions_format_args"><code>util.formatWithOptions(inspectOptions, format[, ...args])</code></a></li>
 <li><a href="#util_util_getsystemerrorname_err"><code>util.getSystemErrorName(err)</code></a></li>
-<li><a href="#util_util_inherits_constructor_superconstructor"><code>util.inherits(constructor, superConstructor)</code></a></li>
+<li><a href="#util_util_getsystemerrormap"><code>util.getSystemErrorMap()</code></a></li>
+<li><span class="stability_3"><a href="#util_util_inherits_constructor_superconstructor"><code>util.inherits(constructor, superConstructor)</code></a></span></li>
 <li><a href="#util_util_inspect_object_options"><code>util.inspect(object[, options])</code></a></li>
 <li><a href="#util_util_inspect_object_showhidden_depth_colors"><code>util.inspect(object[, showHidden[, depth[, colors]]])</code></a>
 <ul>
@@ -3737,9 +4045,9 @@
 <ul>
 <li><a href="#util_whatwg_supported_encodings">WHATWG supported encodings</a>
 <ul>
-<li><a href="#util_encodings_supported_without_icu">Encodings Supported Without ICU</a></li>
-<li><a href="#util_encodings_supported_by_default_with_icu">Encodings Supported by Default (With ICU)</a></li>
-<li><a href="#util_encodings_requiring_full_icu_data">Encodings requiring full ICU data</a></li>
+<li><a href="#util_encodings_supported_by_default_with_full_icu_data">Encodings supported by default (with full ICU data)</a></li>
+<li><a href="#util_encodings_supported_when_node_js_is_built_with_the_small_icu_option">Encodings supported when Node.js is built with the <code>small-icu</code> option</a></li>
+<li><a href="#util_encodings_supported_when_icu_is_disabled">Encodings supported when ICU is disabled</a></li>
 </ul>
 </li>
 <li><a href="#util_new_textdecoder_encoding_options"><code>new TextDecoder([encoding[, options]])</code></a></li>
@@ -3756,6 +4064,7 @@
 <li><a href="#util_textencoder_encoding"><code>textEncoder.encoding</code></a></li>
 </ul>
 </li>
+<li><a href="#util_util_tousvstring_string"><code>util.toUSVString(string)</code></a></li>
 <li><a href="#util_util_types"><code>util.types</code></a>
 <ul>
 <li><a href="#util_util_types_isanyarraybuffer_value"><code>util.types.isAnyArrayBuffer(value)</code></a></li>
@@ -3797,7 +4106,7 @@
 <li><a href="#util_util_types_isuint32array_value"><code>util.types.isUint32Array(value)</code></a></li>
 <li><a href="#util_util_types_isweakmap_value"><code>util.types.isWeakMap(value)</code></a></li>
 <li><a href="#util_util_types_isweakset_value"><code>util.types.isWeakSet(value)</code></a></li>
-<li><a href="#util_util_types_iswebassemblycompiledmodule_value"><code>util.types.isWebAssemblyCompiledModule(value)</code></a></li>
+<li><span class="stability_0"><a href="#util_util_types_iswebassemblycompiledmodule_value"><code>util.types.isWebAssemblyCompiledModule(value)</code></a></span></li>
 </ul>
 </li>
 <li><a href="#util_deprecated_apis">Deprecated APIs</a>
@@ -3826,13 +4135,13 @@
 <li><a href="#v8_v8">V8</a>
 <ul>
 <li><a href="#v8_v8_cacheddataversiontag"><code>v8.cachedDataVersionTag()</code></a></li>
-<li><a href="#v8_v8_getheapspacestatistics"><code>v8.getHeapSpaceStatistics()</code></a></li>
+<li><a href="#v8_v8_getheapcodestatistics"><code>v8.getHeapCodeStatistics()</code></a></li>
 <li><a href="#v8_v8_getheapsnapshot"><code>v8.getHeapSnapshot()</code></a></li>
+<li><a href="#v8_v8_getheapspacestatistics"><code>v8.getHeapSpaceStatistics()</code></a></li>
 <li><a href="#v8_v8_getheapstatistics"><code>v8.getHeapStatistics()</code></a></li>
-<li><a href="#v8_v8_getheapcodestatistics"><code>v8.getHeapCodeStatistics()</code></a></li>
 <li><a href="#v8_v8_setflagsfromstring_flags"><code>v8.setFlagsFromString(flags)</code></a></li>
-<li><a href="#v8_v8_takecoverage"><code>v8.takeCoverage()</code></a></li>
 <li><a href="#v8_v8_stopcoverage"><code>v8.stopCoverage()</code></a></li>
+<li><a href="#v8_v8_takecoverage"><code>v8.takeCoverage()</code></a></li>
 <li><a href="#v8_v8_writeheapsnapshot_filename"><code>v8.writeHeapSnapshot([filename])</code></a></li>
 <li><a href="#v8_serialization_api">Serialization API</a>
 <ul>
@@ -3891,10 +4200,10 @@
 <li><a href="#vm_module_dependencyspecifiers"><code>module.dependencySpecifiers</code></a></li>
 <li><a href="#vm_module_error"><code>module.error</code></a></li>
 <li><a href="#vm_module_evaluate_options"><code>module.evaluate([options])</code></a></li>
+<li><a href="#vm_module_identifier"><code>module.identifier</code></a></li>
 <li><a href="#vm_module_link_linker"><code>module.link(linker)</code></a></li>
 <li><a href="#vm_module_namespace"><code>module.namespace</code></a></li>
 <li><a href="#vm_module_status"><code>module.status</code></a></li>
-<li><a href="#vm_module_identifier"><code>module.identifier</code></a></li>
 </ul>
 </li>
 <li><span class="stability_1"><a href="#vm_class_vm_sourcetextmodule">Class: <code>vm.SourceTextModule</code></a></span>
@@ -3912,12 +4221,13 @@
 <li><a href="#vm_vm_compilefunction_code_params_options"><code>vm.compileFunction(code[, params[, options]])</code></a></li>
 <li><a href="#vm_vm_createcontext_contextobject_options"><code>vm.createContext([contextObject[, options]])</code></a></li>
 <li><a href="#vm_vm_iscontext_object"><code>vm.isContext(object)</code></a></li>
+<li><span class="stability_1"><a href="#vm_vm_measurememory_options"><code>vm.measureMemory([options])</code></a></span></li>
 <li><a href="#vm_vm_runincontext_code_contextifiedobject_options"><code>vm.runInContext(code, contextifiedObject[, options])</code></a></li>
 <li><a href="#vm_vm_runinnewcontext_code_contextobject_options"><code>vm.runInNewContext(code[, contextObject[, options]])</code></a></li>
 <li><a href="#vm_vm_runinthiscontext_code_options"><code>vm.runInThisContext(code[, options])</code></a></li>
 <li><a href="#vm_example_running_an_http_server_within_a_vm">Example: Running an HTTP server within a VM</a></li>
 <li><a href="#vm_what_does_it_mean_to_contextify_an_object">What does it mean to "contextify" an object?</a></li>
-<li><a href="#vm_timeout_limitations_when_using_process_nexttick_promises_and_queuemicrotask">Timeout limitations when using <code>process.nextTick()</code>, promises, and <code>queueMicrotask()</code></a></li>
+<li><a href="#vm_timeout_interactions_with_asynchronous_tasks_and_promises">Timeout interactions with asynchronous tasks and Promises</a></li>
 </ul>
 </li>
 <li><span class="stability_1"><a href="#wasi_webassembly_system_interface_wasi">WebAssembly System Interface (WASI)</a></span>
@@ -3934,6 +4244,7 @@
 </li>
 <li><span class="stability_2"><a href="#worker_threads_worker_threads">Worker threads</a></span>
 <ul>
+<li><span class="stability_1"><a href="#worker_threads_worker_getenvironmentdata_key"><code>worker.getEnvironmentData(key)</code></a></span></li>
 <li><a href="#worker_threads_worker_ismainthread"><code>worker.isMainThread</code></a></li>
 <li><a href="#worker_threads_worker_markasuntransferable_object"><code>worker.markAsUntransferable(object)</code></a></li>
 <li><a href="#worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox"><code>worker.moveMessagePortToContext(port, contextifiedSandbox)</code></a></li>
@@ -3941,6 +4252,7 @@
 <li><a href="#worker_threads_worker_receivemessageonport_port"><code>worker.receiveMessageOnPort(port)</code></a></li>
 <li><a href="#worker_threads_worker_resourcelimits"><code>worker.resourceLimits</code></a></li>
 <li><a href="#worker_threads_worker_share_env"><code>worker.SHARE_ENV</code></a></li>
+<li><span class="stability_1"><a href="#worker_threads_worker_setenvironmentdata_key_value"><code>worker.setEnvironmentData(key[, value])</code></a></span></li>
 <li><a href="#worker_threads_worker_threadid"><code>worker.threadId</code></a></li>
 <li><a href="#worker_threads_worker_workerdata"><code>worker.workerData</code></a></li>
 <li><a href="#worker_threads_class_messagechannel">Class: <code>MessageChannel</code></a></li>
@@ -3985,6 +4297,12 @@
 <li><a href="#worker_threads_worker_unref"><code>worker.unref()</code></a></li>
 </ul>
 </li>
+<li><a href="#worker_threads_notes">Notes</a>
+<ul>
+<li><a href="#worker_threads_synchronous_blocking_of_stdio">Synchronous blocking of stdio</a></li>
+<li><a href="#worker_threads_launching_worker_threads_from_preload_scripts">Launching worker threads from preload scripts</a></li>
+</ul>
+</li>
 </ul>
 </li>
 <li><span class="stability_2"><a href="#zlib_zlib">Zlib</a></span>
@@ -4066,56 +4384,65 @@
 </ul>
 </li>
 </ul>
-</div>
+</details>
+
 
       <div id="apicontent">
-        <h1>About this documentation<span><a class="mark" href="#documentation_about_this_documentation" id="documentation_about_this_documentation">#</a></span></h1>
+        <section><h2>About this documentation<span><a class="mark" href="#documentation_about_this_documentation" id="documentation_about_this_documentation">#</a></span></h2>
 
 
 <p>Welcome to the official API reference documentation for Node.js!</p>
 <p>Node.js is a JavaScript runtime built on the <a href="https://v8.dev/">V8 JavaScript engine</a>.</p>
-<h2>Contributing<span><a class="mark" href="#documentation_contributing" id="documentation_contributing">#</a></span></h2>
+<section><h3>Contributing<span><a class="mark" href="#documentation_contributing" id="documentation_contributing">#</a></span></h3>
 <p>Report errors in this documentation in <a href="https://github.com/nodejs/node/issues/new">the issue tracker</a>. See
-<a href="https://github.com/nodejs/node/blob/master/CONTRIBUTING.md">the contributing guide</a> for directions on how to submit pull requests.</p>
-<h2>Stability index<span><a class="mark" href="#documentation_stability_index" id="documentation_stability_index">#</a></span></h2>
+<a href="https://github.com/nodejs/node/blob/HEAD/CONTRIBUTING.md">the contributing guide</a> for directions on how to submit pull requests.</p>
+</section><section><h3>Stability index<span><a class="mark" href="#documentation_stability_index" id="documentation_stability_index">#</a></span></h3>
 
 <p>Throughout the documentation are indications of a section's stability. Some APIs
 are so proven and so relied upon that they are unlikely to ever change at all.
 Others are brand new and experimental, or known to be hazardous.</p>
 <p>The stability indices are as follows:</p>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. The feature may emit warnings. Backward
+<p></p><div class="api_stability api_stability_0">Stability: 0 - Deprecated. The feature may emit warnings. Backward
 compatibility is not guaranteed.</div><p></p>
 <!-- separator -->
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental. The feature is not subject to
+<p></p><div class="api_stability api_stability_1">Stability: 1 - Experimental. The feature is not subject to
 <a href="https://semver.org/">Semantic Versioning</a> rules. Non-backward compatible changes or removal may
 occur in any future release. Use of the feature is not recommended in
 production environments.</div><p></p>
 <!-- separator -->
-<p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable. Compatibility with the npm ecosystem is a high
+<p></p><div class="api_stability api_stability_2">Stability: 2 - Stable. Compatibility with the npm ecosystem is a high
 priority.</div><p></p>
+<!-- separator -->
+<p></p><div class="api_stability api_stability_3">Stability: 3 - Legacy. The feature is no longer recommended for use. While it
+likely will not be removed, and is still covered by semantic-versioning
+guarantees, use of the feature should be avoided.</div><p></p>
 <p>Use caution when making use of Experimental features, particularly within
 modules. Users may not be aware that experimental features are being used.
 Bugs or behavior changes may surprise users when Experimental API
 modifications occur. To avoid surprises, use of an Experimental feature may need
 a command-line flag. Experimental features may also emit a <a href="#process_event_warning">warning</a>.</p>
-<h2>JSON output<span><a class="mark" href="#documentation_json_output" id="documentation_json_output">#</a></span></h2>
+</section><section><h3>Stability overview<span><a class="mark" href="#documentation_stability_overview" id="documentation_stability_overview">#</a></span></h3>
+<!-- STABILITY_OVERVIEW_SLOT_BEGIN -->
+<!-- STABILITY_OVERVIEW_SLOT_END -->
+</section><section><h3>JSON output<span><a class="mark" href="#documentation_json_output" id="documentation_json_output">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.12</span>
 </div>
 <p>Every <code>.html</code> document has a corresponding <code>.json</code> document. This is for IDEs
 and other utilities that consume the documentation.</p>
-<h2>System calls and man pages<span><a class="mark" href="#documentation_system_calls_and_man_pages" id="documentation_system_calls_and_man_pages">#</a></span></h2>
+</section><section><h3>System calls and man pages<span><a class="mark" href="#documentation_system_calls_and_man_pages" id="documentation_system_calls_and_man_pages">#</a></span></h3>
 <p>Node.js functions which wrap a system call will document that. The docs link
 to the corresponding man pages which describe how the system call works.</p>
 <p>Most Unix system calls have Windows analogues. Still, behavior differences may
-be unavoidable.</p>
-<h1>Usage and example<span><a class="mark" href="#synopsis_usage_and_example" id="synopsis_usage_and_example">#</a></span></h1>
-<h2>Usage<span><a class="mark" href="#synopsis_usage" id="synopsis_usage">#</a></span></h2>
+be unavoidable.</p></section>
+        </section>
+<section><h2>Usage and example<span><a class="mark" href="#synopsis_usage_and_example" id="synopsis_usage_and_example">#</a></span></h2>
+<section><h3>Usage<span><a class="mark" href="#synopsis_usage" id="synopsis_usage">#</a></span></h3>
 
 
 <p><code>node [options] [V8 options] [script.js | -e "script" | - ] [arguments]</code></p>
-<p>Please see the <a href="#cli_command_line_options">Command Line Options</a> document for more information.</p>
-<h2>Example<span><a class="mark" href="#synopsis_example" id="synopsis_example">#</a></span></h2>
+<p>Please see the <a href="#cli_command_line_options">Command-line options</a> document for more information.</p>
+</section><section><h3>Example<span><a class="mark" href="#synopsis_example" id="synopsis_example">#</a></span></h3>
 <p>An example of a <a href="http.html">web server</a> written with Node.js which responds with
 <code>'Hello, World!'</code>:</p>
 <p>Commands in this document start with <code>$</code> or <code>></code> to replicate how they would
@@ -4123,18 +4450,18 @@ appear in a user's terminal. Do not include the <code>$</code> and <code>></code
 there to show the start of each command.</p>
 <p>Lines that don’t start with <code>$</code> or <code>></code> character show the output of the previous
 command.</p>
-<p>First, make sure to have downloaded and installed Node.js. See <a href="https://nodejs.org/en/download/package-manager/">this guide</a>
-for further install information.</p>
+<p>First, make sure to have downloaded and installed Node.js. See
+<a href="https://nodejs.org/en/download/package-manager/">Installing Node.js via package manager</a> for further install information.</p>
 <p>Now, create an empty project folder called <code>projects</code>, then navigate into it.</p>
 <p>Linux and Mac:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> mkdir ~/projects</span>
-<span class="hljs-meta">$</span><span class="bash"> <span class="hljs-built_in">cd</span> ~/projects</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">mkdir ~/projects</span>
+<span class="hljs-meta">$ </span><span class="language-bash"><span class="hljs-built_in">cd</span> ~/projects</span></code></pre>
 <p>Windows CMD:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> mkdir %USERPROFILE%\projects</span>
-<span class="hljs-meta">></span><span class="bash"> <span class="hljs-built_in">cd</span> %USERPROFILE%\projects</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">mkdir %USERPROFILE%\projects</span>
+<span class="hljs-meta">> </span><span class="language-bash"><span class="hljs-built_in">cd</span> %USERPROFILE%\projects</span></code></pre>
 <p>Windows PowerShell:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> mkdir <span class="hljs-variable">$env</span>:USERPROFILE\projects</span>
-<span class="hljs-meta">></span><span class="bash"> <span class="hljs-built_in">cd</span> <span class="hljs-variable">$env</span>:USERPROFILE\projects</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">mkdir <span class="hljs-variable">$env</span>:USERPROFILE\projects</span>
+<span class="hljs-meta">> </span><span class="language-bash"><span class="hljs-built_in">cd</span> <span class="hljs-variable">$env</span>:USERPROFILE\projects</span></code></pre>
 <p>Next, create a new source file in the <code>projects</code>
 folder and call it <code>hello-world.js</code>.</p>
 <p>Open <code>hello-world.js</code> in any preferred text editor and
@@ -4144,34 +4471,35 @@ paste in the following content:</p>
 <span class="hljs-keyword">const</span> hostname = <span class="hljs-string">'127.0.0.1'</span>;
 <span class="hljs-keyword">const</span> port = <span class="hljs-number">3000</span>;
 
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.statusCode = <span class="hljs-number">200</span>;
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/plain'</span>);
-  res.end(<span class="hljs-string">'Hello, World!\n'</span>);
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-property">statusCode</span> = <span class="hljs-number">200</span>;
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/plain'</span>);
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Hello, World!\n'</span>);
 });
 
-server.listen(port, hostname, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Server running at http://<span class="hljs-subst">${hostname}</span>:<span class="hljs-subst">${port}</span>/`</span>);
+server.<span class="hljs-title function_">listen</span>(port, hostname, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Server running at http://<span class="hljs-subst">${hostname}</span>:<span class="hljs-subst">${port}</span>/`</span>);
 });</code></pre>
 <p>Save the file, go back to the terminal window, and enter the following command:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node hello-world.js</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node hello-world.js</span></code></pre>
 <p>Output like this should appear in the terminal:</p>
 <pre><code class="language-console">Server running at http://127.0.0.1:3000/</code></pre>
 <p>Now, open any preferred web browser and visit <code>http://127.0.0.1:3000</code>.</p>
 <p>If the browser displays the string <code>Hello, World!</code>, that indicates
-the server is working.</p>
-<h1>Assert<span><a class="mark" href="#assert_assert" id="assert_assert">#</a></span></h1>
+the server is working.</p></section>
+        </section>
+<section><h2>Assert<span><a class="mark" href="#assert_assert" id="assert_assert">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/assert.js">lib/assert.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/assert.js">lib/assert.js</a></p>
 <p>The <code>assert</code> module provides a set of assertion functions for verifying
 invariants.</p>
-<h2>Strict assertion mode<span><a class="mark" href="#assert_strict_assertion_mode" id="assert_strict_assertion_mode">#</a></span></h2>
+<section><h3>Strict assertion mode<span><a class="mark" href="#assert_strict_assertion_mode" id="assert_strict_assertion_mode">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.2</td>
+<tr><td>v13.9.0, v12.16.2</td>
 <td><p>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".</p></td></tr>
 <tr><td>v9.9.0</td>
 <td><p>Added error diffs to the strict assertion mode.</p></td></tr>
@@ -4188,11 +4516,11 @@ strict methods. For example, <a href="#assert_assert_deepequal_actual_expected_m
 <p>In strict assertion mode, error messages for objects display a diff. In legacy
 assertion mode, error messages for objects display the objects, often truncated.</p>
 <p>To use strict assertion mode:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;</code></pre>
 <p>Example error diff:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.deepEqual([[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]], <span class="hljs-number">4</span>, <span class="hljs-number">5</span>], [[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'3'</span>]], <span class="hljs-number">4</span>, <span class="hljs-number">5</span>]);
+assert.<span class="hljs-title function_">deepEqual</span>([[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]], <span class="hljs-number">4</span>, <span class="hljs-number">5</span>], [[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'3'</span>]], <span class="hljs-number">4</span>, <span class="hljs-number">5</span>]);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected ... Lines skipped</span>
 <span class="hljs-comment">//</span>
@@ -4210,7 +4538,7 @@ assert.deepEqual([[[<span class="hljs-number">1</span>, <span class="hljs-number
 environment variables. This will also deactivate the colors in the REPL. For
 more on color support in terminal environments, read the tty
 <a href="#tty_writestream_getcolordepth_env">getColorDepth()</a> documentation.</p>
-<h2>Legacy assertion mode<span><a class="mark" href="#assert_legacy_assertion_mode" id="assert_legacy_assertion_mode">#</a></span></h2>
+</section><section><h3>Legacy assertion mode<span><a class="mark" href="#assert_legacy_assertion_mode" id="assert_legacy_assertion_mode">#</a></span></h3>
 <p>Legacy assertion mode uses the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> in:</p>
 <ul>
 <li><a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a></li>
@@ -4225,14 +4553,14 @@ more on color support in terminal environments, read the tty
 especially true for <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a>, where the comparison rules are
 lax:</p>
 <pre><code class="language-js"><span class="hljs-comment">// WARNING: This does not throw an AssertionError!</span>
-assert.deepEqual(<span class="hljs-regexp">/a/gi</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>());</code></pre>
-<h2>Class: assert.AssertionError<a class="srclink" href="https://github.com/nodejs/node/blob/360a294f1f19cb8ccc9505d44a2e9efff414a5c7/lib/assert.js#L147">[src]</a><span><a class="mark" href="#assert_class_assert_assertionerror" id="assert_class_assert_assertionerror">#</a></span></h2>
+assert.<span class="hljs-title function_">deepEqual</span>(<span class="hljs-regexp">/a/gi</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>());</code></pre>
+</section><section><h3>Class: assert.AssertionError<a class="srclink" href="https://github.com/nodejs/node/blob/92df3d654b366aa115fb672756cb051d480d8acc/lib/assert.js#L172">[src]</a><span><a class="mark" href="#assert_class_assert_assertionerror" id="assert_class_assert_assertionerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
 <p>Indicates the failure of an assertion. All errors thrown by the <code>assert</code> module
 will be instances of the <code>AssertionError</code> class.</p>
-<h3><code>new assert.AssertionError(options)</code><span><a class="mark" href="#assert_new_assert_assertionerror_options" id="assert_new_assert_assertionerror_options">#</a></span></h3>
+<h4><code>new assert.AssertionError(options)</code><span><a class="mark" href="#assert_new_assert_assertionerror_options" id="assert_new_assert_assertionerror_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.21</span>
 </div>
@@ -4265,7 +4593,7 @@ assertion error.</li>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Generate an AssertionError to compare the error message later:</span>
-<span class="hljs-keyword">const</span> { message } = <span class="hljs-keyword">new</span> assert.AssertionError({
+<span class="hljs-keyword">const</span> { message } = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">AssertionError</span>({
   <span class="hljs-attr">actual</span>: <span class="hljs-number">1</span>,
   <span class="hljs-attr">expected</span>: <span class="hljs-number">2</span>,
   <span class="hljs-attr">operator</span>: <span class="hljs-string">'strictEqual'</span>
@@ -4273,26 +4601,26 @@ assertion error.</li>
 
 <span class="hljs-comment">// Verify error output:</span>
 <span class="hljs-keyword">try</span> {
-  assert.strictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  assert(err <span class="hljs-keyword">instanceof</span> assert.AssertionError);
-  assert.strictEqual(err.message, message);
-  assert.strictEqual(err.name, <span class="hljs-string">'AssertionError'</span>);
-  assert.strictEqual(err.actual, <span class="hljs-number">1</span>);
-  assert.strictEqual(err.expected, <span class="hljs-number">2</span>);
-  assert.strictEqual(err.code, <span class="hljs-string">'ERR_ASSERTION'</span>);
-  assert.strictEqual(err.operator, <span class="hljs-string">'strictEqual'</span>);
-  assert.strictEqual(err.generatedMessage, <span class="hljs-literal">true</span>);
+  <span class="hljs-title function_">assert</span>(err <span class="hljs-keyword">instanceof</span> assert.<span class="hljs-property">AssertionError</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">message</span>, message);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">name</span>, <span class="hljs-string">'AssertionError'</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">actual</span>, <span class="hljs-number">1</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">expected</span>, <span class="hljs-number">2</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">code</span>, <span class="hljs-string">'ERR_ASSERTION'</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">operator</span>, <span class="hljs-string">'strictEqual'</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">generatedMessage</span>, <span class="hljs-literal">true</span>);
 }</code></pre>
-<h2>Class: <code>assert.CallTracker</code><span><a class="mark" href="#assert_class_assert_calltracker" id="assert_class_assert_calltracker">#</a></span></h2>
+</section><section><h3>Class: <code>assert.CallTracker</code><span><a class="mark" href="#assert_class_assert_calltracker" id="assert_class_assert_calltracker">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>This feature is currently experimental and behavior might still change.</p>
-<p>### <code>new assert.CallTracker()</code></p>
+<h4><code>new assert.CallTracker()</code><span><a class="mark" href="#assert_new_assert_calltracker" id="assert_new_assert_calltracker">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <p>Creates a new <a href="#assert_class_assert_calltracker"><code>CallTracker</code></a> object which can be used to track if functions
 were called a specific number of times. The <code>tracker.verify()</code> must be called
@@ -4300,23 +4628,23 @@ for the verification to take place. The usual pattern would be to call it in a
 <a href="#process_event_exit"><code>process.on('exit')</code></a> handler.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
-<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.CallTracker();
+<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">CallTracker</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">func</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">func</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// callsfunc() must be called exactly 1 time before tracker.verify().</span>
-<span class="hljs-keyword">const</span> callsfunc = tracker.calls(func, <span class="hljs-number">1</span>);
+<span class="hljs-keyword">const</span> callsfunc = tracker.<span class="hljs-title function_">calls</span>(func, <span class="hljs-number">1</span>);
 
-callsfunc();
+<span class="hljs-title function_">callsfunc</span>();
 
 <span class="hljs-comment">// Calls tracker.verify() and verifies if all tracker.calls() functions have</span>
 <span class="hljs-comment">// been called exact times.</span>
-process.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-  tracker.verify();
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+  tracker.<span class="hljs-title function_">verify</span>();
 });</code></pre>
-<h3><code>tracker.calls([fn][, exact])</code><span><a class="mark" href="#assert_tracker_calls_fn_exact" id="assert_tracker_calls_fn_exact">#</a></span></h3>
+<h4><code>tracker.calls([fn][, exact])</code><span><a class="mark" href="#assert_tracker_calls_fn_exact" id="assert_tracker_calls_fn_exact">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> <strong>Default</strong> A no-op function.</li>
@@ -4330,16 +4658,16 @@ error.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Creates call tracker.</span>
-<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.CallTracker();
+<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">CallTracker</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">func</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">func</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// Returns a function that wraps func() that must be called exact times</span>
 <span class="hljs-comment">// before tracker.verify().</span>
-<span class="hljs-keyword">const</span> callsfunc = tracker.calls(func);</code></pre>
-<h3><code>tracker.report()</code><span><a class="mark" href="#assert_tracker_report" id="assert_tracker_report">#</a></span></h3>
+<span class="hljs-keyword">const</span> callsfunc = tracker.<span class="hljs-title function_">calls</span>(func);</code></pre>
+<h4><code>tracker.report()</code><span><a class="mark" href="#assert_tracker_report" id="assert_tracker_report">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> of objects containing information about the wrapper functions
@@ -4360,18 +4688,18 @@ the functions that have not been called the expected number of times.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Creates call tracker.</span>
-<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.CallTracker();
+<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">CallTracker</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">func</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">func</span>(<span class="hljs-params"></span>) {}
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// Returns a function that wraps func() that must be called exact times</span>
 <span class="hljs-comment">// before tracker.verify().</span>
-<span class="hljs-keyword">const</span> callsfunc = tracker.calls(func, <span class="hljs-number">2</span>);
+<span class="hljs-keyword">const</span> callsfunc = tracker.<span class="hljs-title function_">calls</span>(func, <span class="hljs-number">2</span>);
 
 <span class="hljs-comment">// Returns an array containing information on callsfunc()</span>
-tracker.report();
+tracker.<span class="hljs-title function_">report</span>();
 <span class="hljs-comment">// [</span>
 <span class="hljs-comment">//  {</span>
 <span class="hljs-comment">//    message: 'Expected the func function to be executed 2 time(s) but was</span>
@@ -4382,9 +4710,9 @@ tracker.report();
 <span class="hljs-comment">//    stack: stack trace</span>
 <span class="hljs-comment">//  }</span>
 <span class="hljs-comment">// ]</span></code></pre>
-<h3><code>tracker.verify()</code><span><a class="mark" href="#assert_tracker_verify" id="assert_tracker_verify">#</a></span></h3>
+<h4><code>tracker.verify()</code><span><a class="mark" href="#assert_tracker_verify" id="assert_tracker_verify">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <p>Iterates through the list of functions passed to
 <a href="#assert_tracker_calls_fn_exact"><code>tracker.calls()</code></a> and will throw an error for functions that
@@ -4392,19 +4720,19 @@ have not been called the expected number of times.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Creates call tracker.</span>
-<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.CallTracker();
+<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">CallTracker</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">func</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">func</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// Returns a function that wraps func() that must be called exact times</span>
 <span class="hljs-comment">// before tracker.verify().</span>
-<span class="hljs-keyword">const</span> callsfunc = tracker.calls(func, <span class="hljs-number">2</span>);
+<span class="hljs-keyword">const</span> callsfunc = tracker.<span class="hljs-title function_">calls</span>(func, <span class="hljs-number">2</span>);
 
-callsfunc();
+<span class="hljs-title function_">callsfunc</span>();
 
 <span class="hljs-comment">// Will throw an error since callsfunc() was only called once.</span>
-tracker.verify();</code></pre>
-<h2><code>assert(value[, message])</code><span><a class="mark" href="#assert_assert_value_message" id="assert_assert_value_message">#</a></span></h2>
+tracker.<span class="hljs-title function_">verify</span>();</code></pre>
+</section><section><h3><code>assert(value[, message])</code><span><a class="mark" href="#assert_assert_value_message" id="assert_assert_value_message">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -4413,17 +4741,21 @@ tracker.verify();</code></pre>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 <p>An alias of <a href="#assert_assert_ok_value_message"><code>assert.ok()</code></a>.</p>
-<h2><code>assert.deepEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_deepequal_actual_expected_message" id="assert_assert_deepequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.deepEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_deepequal_actual_expected_message" id="assert_assert_deepequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>In Legacy assertion mode, changed status from Deprecated to Legacy.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>NaN is now treated as being identical in case both sides are NaN.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>The type tags are now properly compared and there are a couple minor comparison adjustments to make the check less surprising.</p></td></tr>
 <tr><td>v9.0.0</td>
-<td><p>The <code>Error</code> names and messages are now properly compared</p></td></tr>
+<td><p>The <code>Error</code> names and messages are now properly compared.</p></td></tr>
 <tr><td>v8.0.0</td>
-<td><p>The <code>Set</code> and <code>Map</code> content is also compared</p></td></tr>
+<td><p>The <code>Set</code> and <code>Map</code> content is also compared.</p></td></tr>
 <tr><td>v6.4.0, v4.7.1</td>
 <td><p>Typed array slices are handled correctly now.</p></td></tr>
 <tr><td>v6.1.0, v4.5.0</td>
@@ -4443,16 +4775,17 @@ tracker.verify();</code></pre>
 <p><strong>Strict assertion mode</strong></p>
 <p>An alias of <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a>.</p>
 <p><strong>Legacy assertion mode</strong></p>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> instead.</div><p></p>
 <p>Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters. Consider
 using <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> instead. <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a> can have
 surprising results.</p>
 <p><em>Deep equality</em> means that the enumerable "own" properties of child objects
 are also recursively evaluated by the following rules.</p>
-<h3>Comparison details<span><a class="mark" href="#assert_comparison_details" id="assert_comparison_details">#</a></span></h3>
+<h4>Comparison details<span><a class="mark" href="#assert_comparison_details" id="assert_comparison_details">#</a></span></h4>
 <ul>
 <li>Primitive values are compared with the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
-( <code>==</code> ).</li>
+( <code>==</code> ) with the exception of <code>NaN</code>. It is treated as being identical in case
+both sides are <code>NaN</code>.</li>
 <li><a href="https://tc39.github.io/ecma262/#sec-object.prototype.tostring">Type tags</a> of objects should be the same.</li>
 <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>
 <li><a href="#errors_class_error"><code>Error</code></a> names and messages are always compared, even if these are not
@@ -4471,7 +4804,7 @@ objects.</li>
 primitives are considered equal by the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
 ( <code>==</code> ).</p>
 <pre><code class="language-js"><span class="hljs-comment">// WARNING: This does not throw an AssertionError!</span>
-assert.deepEqual(<span class="hljs-string">'+00000000'</span>, <span class="hljs-literal">false</span>);</code></pre>
+assert.<span class="hljs-title function_">deepEqual</span>(<span class="hljs-string">'+00000000'</span>, <span class="hljs-literal">false</span>);</code></pre>
 <p>"Deep" equality means that the enumerable "own" properties of child objects
 are evaluated also:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
@@ -4491,27 +4824,27 @@ are evaluated also:</p>
     <span class="hljs-attr">b</span>: <span class="hljs-number">1</span>
   }
 };
-<span class="hljs-keyword">const</span> obj4 = <span class="hljs-built_in">Object</span>.create(obj1);
+<span class="hljs-keyword">const</span> obj4 = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(obj1);
 
-assert.deepEqual(obj1, obj1);
+assert.<span class="hljs-title function_">deepEqual</span>(obj1, obj1);
 <span class="hljs-comment">// OK</span>
 
 <span class="hljs-comment">// Values of b are different:</span>
-assert.deepEqual(obj1, obj2);
+assert.<span class="hljs-title function_">deepEqual</span>(obj1, obj2);
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }</span>
 
-assert.deepEqual(obj1, obj3);
+assert.<span class="hljs-title function_">deepEqual</span>(obj1, obj3);
 <span class="hljs-comment">// OK</span>
 
 <span class="hljs-comment">// Prototypes are ignored:</span>
-assert.deepEqual(obj1, obj4);
+assert.<span class="hljs-title function_">deepEqual</span>(obj1, obj4);
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } deepEqual {}</span></code></pre>
 <p>If the values are not equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
 property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
 parameter is undefined, a default error message is assigned. If the <code>message</code>
 parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.deepStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_deepstrictequal_actual_expected_message" id="assert_assert_deepstrictequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.deepStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_deepstrictequal_actual_expected_message" id="assert_assert_deepstrictequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -4521,13 +4854,13 @@ parameter is an instance of an <a href="#errors_class_error"><code>Error</code><
 <tr><td>v9.0.0</td>
 <td><p>The <code>NaN</code> is now compared using the <a href="https://tc39.github.io/ecma262/#sec-samevaluezero">SameValueZero</a> comparison.</p></td></tr>
 <tr><td>v8.5.0</td>
-<td><p>The <code>Error</code> names and messages are now properly compared</p></td></tr>
+<td><p>The <code>Error</code> names and messages are now properly compared.</p></td></tr>
 <tr><td>v8.0.0</td>
-<td><p>The <code>Set</code> and <code>Map</code> content is also compared</p></td></tr>
-<tr><td>v6.4.0, v4.7.1</td>
-<td><p>Typed array slices are handled correctly now.</p></td></tr>
+<td><p>The <code>Set</code> and <code>Map</code> content is also compared.</p></td></tr>
 <tr><td>v6.1.0</td>
 <td><p>Objects with circular references can be used as inputs now.</p></td></tr>
+<tr><td>v6.4.0, v4.7.1</td>
+<td><p>Typed array slices are handled correctly now.</p></td></tr>
 <tr><td>v5.10.1, v4.4.3</td>
 <td><p>Handle non-<code>Uint8Array</code> typed arrays correctly.</p></td></tr>
 <tr><td>v1.2.0</td>
@@ -4543,7 +4876,7 @@ parameter is an instance of an <a href="#errors_class_error"><code>Error</code><
 <p>Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters.
 "Deep" equality means that the enumerable "own" properties of child objects
 are recursively evaluated also by the following rules.</p>
-<h3>Comparison details<span><a class="mark" href="#assert_comparison_details_1" id="assert_comparison_details_1">#</a></span></h3>
+<h4>Comparison details<span><a class="mark" href="#assert_comparison_details_1" id="assert_comparison_details_1">#</a></span></h4>
 <ul>
 <li>Primitive values are compared using the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>, used by
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is()</code></a>.</li>
@@ -4562,10 +4895,10 @@ reference.</li>
 <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
 below for further details.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
 <span class="hljs-comment">// This fails because 1 !== '1'.</span>
-assert.deepStrictEqual({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'1'</span> });
+assert.<span class="hljs-title function_">deepStrictEqual</span>({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'1'</span> });
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
@@ -4575,13 +4908,13 @@ assert.deepStrictEqual({ <span class="hljs-attr">a</span>: <span class="hljs-num
 <span class="hljs-comment">//   }</span>
 
 <span class="hljs-comment">// The following objects don't have own properties</span>
-<span class="hljs-keyword">const</span> date = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>();
+<span class="hljs-keyword">const</span> date = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>();
 <span class="hljs-keyword">const</span> object = {};
 <span class="hljs-keyword">const</span> fakeDate = {};
-<span class="hljs-built_in">Object</span>.setPrototypeOf(fakeDate, <span class="hljs-built_in">Date</span>.prototype);
+<span class="hljs-title class_">Object</span>.<span class="hljs-title function_">setPrototypeOf</span>(fakeDate, <span class="hljs-title class_">Date</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>);
 
 <span class="hljs-comment">// Different [[Prototype]]:</span>
-assert.deepStrictEqual(object, fakeDate);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(object, fakeDate);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
@@ -4589,60 +4922,60 @@ assert.deepStrictEqual(object, fakeDate);
 <span class="hljs-comment">// - Date {}</span>
 
 <span class="hljs-comment">// Different type tags:</span>
-assert.deepStrictEqual(date, fakeDate);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(date, fakeDate);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// + 2018-04-26T00:49:08.604Z</span>
 <span class="hljs-comment">// - Date {}</span>
 
-assert.deepStrictEqual(<span class="hljs-literal">NaN</span>, <span class="hljs-literal">NaN</span>);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(<span class="hljs-title class_">Na</span>N, <span class="hljs-title class_">Na</span>N);
 <span class="hljs-comment">// OK, because of the SameValue comparison</span>
 
 <span class="hljs-comment">// Different unwrapped numbers:</span>
-assert.deepStrictEqual(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Number</span>(<span class="hljs-number">1</span>), <span class="hljs-keyword">new</span> <span class="hljs-built_in">Number</span>(<span class="hljs-number">2</span>));
+assert.<span class="hljs-title function_">deepStrictEqual</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Number</span>(<span class="hljs-number">1</span>), <span class="hljs-keyword">new</span> <span class="hljs-title class_">Number</span>(<span class="hljs-number">2</span>));
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// + [Number: 1]</span>
 <span class="hljs-comment">// - [Number: 2]</span>
 
-assert.deepStrictEqual(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'foo'</span>), <span class="hljs-built_in">Object</span>(<span class="hljs-string">'foo'</span>));
+assert.<span class="hljs-title function_">deepStrictEqual</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(<span class="hljs-string">'foo'</span>), <span class="hljs-title class_">Object</span>(<span class="hljs-string">'foo'</span>));
 <span class="hljs-comment">// OK because the object and the string are identical when unwrapped.</span>
 
-assert.deepStrictEqual(<span class="hljs-number">-0</span>, <span class="hljs-number">-0</span>);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(-<span class="hljs-number">0</span>, -<span class="hljs-number">0</span>);
 <span class="hljs-comment">// OK</span>
 
 <span class="hljs-comment">// Different zeros using the SameValue Comparison:</span>
-assert.deepStrictEqual(<span class="hljs-number">0</span>, <span class="hljs-number">-0</span>);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(<span class="hljs-number">0</span>, -<span class="hljs-number">0</span>);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// + 0</span>
 <span class="hljs-comment">// - -0</span>
 
-<span class="hljs-keyword">const</span> symbol1 = <span class="hljs-built_in">Symbol</span>();
-<span class="hljs-keyword">const</span> symbol2 = <span class="hljs-built_in">Symbol</span>();
-assert.deepStrictEqual({ [symbol1]: <span class="hljs-number">1</span> }, { [symbol1]: <span class="hljs-number">1</span> });
+<span class="hljs-keyword">const</span> symbol1 = <span class="hljs-title class_">Symbol</span>();
+<span class="hljs-keyword">const</span> symbol2 = <span class="hljs-title class_">Symbol</span>();
+assert.<span class="hljs-title function_">deepStrictEqual</span>({ [symbol1]: <span class="hljs-number">1</span> }, { [symbol1]: <span class="hljs-number">1</span> });
 <span class="hljs-comment">// OK, because it is the same symbol on both objects.</span>
 
-assert.deepStrictEqual({ [symbol1]: <span class="hljs-number">1</span> }, { [symbol2]: <span class="hljs-number">1</span> });
+assert.<span class="hljs-title function_">deepStrictEqual</span>({ [symbol1]: <span class="hljs-number">1</span> }, { [symbol2]: <span class="hljs-number">1</span> });
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// {</span>
 <span class="hljs-comment">//   [Symbol()]: 1</span>
 <span class="hljs-comment">// }</span>
 
-<span class="hljs-keyword">const</span> weakMap1 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakMap</span>();
-<span class="hljs-keyword">const</span> weakMap2 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakMap</span>([[{}, {}]]);
-<span class="hljs-keyword">const</span> weakMap3 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakMap</span>();
-weakMap3.unequal = <span class="hljs-literal">true</span>;
+<span class="hljs-keyword">const</span> weakMap1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakMap</span>();
+<span class="hljs-keyword">const</span> weakMap2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakMap</span>([[{}, {}]]);
+<span class="hljs-keyword">const</span> weakMap3 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakMap</span>();
+weakMap3.<span class="hljs-property">unequal</span> = <span class="hljs-literal">true</span>;
 
-assert.deepStrictEqual(weakMap1, weakMap2);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(weakMap1, weakMap2);
 <span class="hljs-comment">// OK, because it is impossible to compare the entries</span>
 
 <span class="hljs-comment">// Fails because weakMap3 has a property that weakMap1 does not contain:</span>
-assert.deepStrictEqual(weakMap1, weakMap3);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(weakMap1, weakMap3);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
@@ -4656,9 +4989,9 @@ property set equal to the value of the <code>message</code> parameter. If the <c
 parameter is undefined, a default error message is assigned. If the <code>message</code>
 parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <code>AssertionError</code>.</p>
-<h2><code>assert.doesNotMatch(string, regexp[, message])</code><span><a class="mark" href="#assert_assert_doesnotmatch_string_regexp_message" id="assert_assert_doesnotmatch_string_regexp_message">#</a></span></h2>
+</section><section><h3><code>assert.doesNotMatch(string, regexp[, message])</code><span><a class="mark" href="#assert_assert_doesnotmatch_string_regexp_message" id="assert_assert_doesnotmatch_string_regexp_message">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.6.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -4669,15 +5002,15 @@ parameter is an instance of an <a href="#errors_class_error"><code>Error</code><
 <p>Expects the <code>string</code> input not to match the regular expression.</p>
 <p>This feature is currently experimental and the name might change or it might be
 completely removed again.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.doesNotMatch(<span class="hljs-string">'I will fail'</span>, <span class="hljs-regexp">/fail/</span>);
+assert.<span class="hljs-title function_">doesNotMatch</span>(<span class="hljs-string">'I will fail'</span>, <span class="hljs-regexp">/fail/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...</span>
 
-assert.doesNotMatch(<span class="hljs-number">123</span>, <span class="hljs-regexp">/pass/</span>);
+assert.<span class="hljs-title function_">doesNotMatch</span>(<span class="hljs-number">123</span>, <span class="hljs-regexp">/pass/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.</span>
 
-assert.doesNotMatch(<span class="hljs-string">'I will pass'</span>, <span class="hljs-regexp">/different/</span>);
+assert.<span class="hljs-title function_">doesNotMatch</span>(<span class="hljs-string">'I will pass'</span>, <span class="hljs-regexp">/different/</span>);
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values do match, or if the <code>string</code> argument is of another type than
 <code>string</code>, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code> property set equal
@@ -4685,7 +5018,7 @@ to the value of the <code>message</code> parameter. If the <code>message</code>
 undefined, a default error message is assigned. If the <code>message</code> parameter is an
 instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.doesNotReject(asyncFn[, error][, message])</code><span><a class="mark" href="#assert_assert_doesnotreject_asyncfn_error_message" id="assert_assert_doesnotreject_asyncfn_error_message">#</a></span></h2>
+</section><section><h3><code>assert.doesNotReject(asyncFn[, error][, message])</code><span><a class="mark" href="#assert_assert_doesnotreject_asyncfn_error_message" id="assert_assert_doesnotreject_asyncfn_error_message">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -4712,19 +5045,19 @@ function. See <a href="#assert_assert_throws_fn_error_message"><code>assert.thro
 <a href="#assert_assert_doesnotthrow_fn_error_message"><code>assert.doesNotThrow()</code></a>.</p>
 <!-- eslint-disable no-restricted-syntax -->
 <pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">await</span> assert.doesNotReject(
+  <span class="hljs-keyword">await</span> assert.<span class="hljs-title function_">doesNotReject</span>(
     <span class="hljs-keyword">async</span> () => {
-      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
     },
-    <span class="hljs-built_in">SyntaxError</span>
+    <span class="hljs-title class_">SyntaxError</span>
   );
 })();</code></pre>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js">assert.doesNotReject(<span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>)))
-  .then(<span class="hljs-function">() =></span> {
+<pre><code class="language-js">assert.<span class="hljs-title function_">doesNotReject</span>(<span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>)))
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> {
     <span class="hljs-comment">// ...</span>
   });</code></pre>
-<h2><code>assert.doesNotThrow(fn[, error][, message])</code><span><a class="mark" href="#assert_assert_doesnotthrow_fn_error_message" id="assert_assert_doesnotthrow_fn_error_message">#</a></span></h2>
+</section><section><h3><code>assert.doesNotThrow(fn[, error][, message])</code><span><a class="mark" href="#assert_assert_doesnotthrow_fn_error_message" id="assert_assert_doesnotthrow_fn_error_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -4759,36 +5092,46 @@ function. See <a href="#assert_assert_throws_fn_error_message"><code>assert.thro
 <p>The following, for instance, will throw the <a href="#errors_class_typeerror"><code>TypeError</code></a> because there is no
 matching error type in the assertion:</p>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js">assert.doesNotThrow(
+<pre><code class="language-js">assert.<span class="hljs-title function_">doesNotThrow</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
   },
-  <span class="hljs-built_in">SyntaxError</span>
+  <span class="hljs-title class_">SyntaxError</span>
 );</code></pre>
 <p>However, the following will result in an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> with the message
 'Got unwanted exception...':</p>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js">assert.doesNotThrow(
+<pre><code class="language-js">assert.<span class="hljs-title function_">doesNotThrow</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
   },
-  <span class="hljs-built_in">TypeError</span>
+  <span class="hljs-title class_">TypeError</span>
 );</code></pre>
 <p>If an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown and a value is provided for the <code>message</code>
 parameter, the value of <code>message</code> will be appended to the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>
 message:</p>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js">assert.doesNotThrow(
+<pre><code class="language-js">assert.<span class="hljs-title function_">doesNotThrow</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
   },
   <span class="hljs-regexp">/Wrong value/</span>,
   <span class="hljs-string">'Whoops'</span>
 );
 <span class="hljs-comment">// Throws: AssertionError: Got unwanted exception: Whoops</span></code></pre>
-<h2><code>assert.equal(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_equal_actual_expected_message" id="assert_assert_equal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.equal(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_equal_actual_expected_message" id="assert_assert_equal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.1.21</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>In Legacy assertion mode, changed status from Deprecated to Legacy.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>NaN is now treated as being identical in case both sides are NaN.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
@@ -4798,26 +5141,29 @@ message:</p>
 <p><strong>Strict assertion mode</strong></p>
 <p>An alias of <a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a>.</p>
 <p><strong>Legacy assertion mode</strong></p>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a> instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use <a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a> instead.</div><p></p>
 <p>Tests shallow, coercive equality between the <code>actual</code> and <code>expected</code> parameters
-using the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> ( <code>==</code> ).</p>
+using the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> ( <code>==</code> ). <code>NaN</code> is special handled
+and treated as being identical in case both sides are <code>NaN</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
-assert.equal(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">equal</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
 <span class="hljs-comment">// OK, 1 == 1</span>
-assert.equal(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
+assert.<span class="hljs-title function_">equal</span>(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
 <span class="hljs-comment">// OK, 1 == '1'</span>
+assert.<span class="hljs-title function_">equal</span>(<span class="hljs-title class_">Na</span>N, <span class="hljs-title class_">Na</span>N);
+<span class="hljs-comment">// OK</span>
 
-assert.equal(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+assert.<span class="hljs-title function_">equal</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 <span class="hljs-comment">// AssertionError: 1 == 2</span>
-assert.equal({ <span class="hljs-attr">a</span>: { <span class="hljs-attr">b</span>: <span class="hljs-number">1</span> } }, { <span class="hljs-attr">a</span>: { <span class="hljs-attr">b</span>: <span class="hljs-number">1</span> } });
+assert.<span class="hljs-title function_">equal</span>({ <span class="hljs-attr">a</span>: { <span class="hljs-attr">b</span>: <span class="hljs-number">1</span> } }, { <span class="hljs-attr">a</span>: { <span class="hljs-attr">b</span>: <span class="hljs-number">1</span> } });
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }</span></code></pre>
 <p>If the values are not equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
 property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
 parameter is undefined, a default error message is assigned. If the <code>message</code>
 parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <code>AssertionError</code>.</p>
-<h2><code>assert.fail([message])</code><span><a class="mark" href="#assert_assert_fail_message" id="assert_assert_fail_message">#</a></span></h2>
+</section><section><h3><code>assert.fail([message])</code><span><a class="mark" href="#assert_assert_fail_message" id="assert_assert_fail_message">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.21</span>
 </div>
@@ -4827,19 +5173,19 @@ parameter is an instance of an <a href="#errors_class_error"><code>Error</code><
 <p>Throws an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> with the provided error message or a default
 error message. If the <code>message</code> parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then
 it will be thrown instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.fail();
+assert.<span class="hljs-title function_">fail</span>();
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Failed</span>
 
-assert.fail(<span class="hljs-string">'boom'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-string">'boom'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: boom</span>
 
-assert.fail(<span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'need array'</span>));
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'need array'</span>));
 <span class="hljs-comment">// TypeError: need array</span></code></pre>
 <p>Using <code>assert.fail()</code> with more than two arguments is possible but deprecated.
 See below for further details.</p>
-<h2><code>assert.fail(actual, expected[, message[, operator[, stackStartFn]]])</code><span><a class="mark" href="#assert_assert_fail_actual_expected_message_operator_stackstartfn" id="assert_assert_fail_actual_expected_message_operator_stackstartfn">#</a></span></h2>
+</section><section><h3><code>assert.fail(actual, expected[, message[, operator[, stackStartFn]]])</code><span><a class="mark" href="#assert_assert_fail_actual_expected_message_operator_stackstartfn" id="assert_assert_fail_actual_expected_message_operator_stackstartfn">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -4868,34 +5214,34 @@ the other arguments will be stored as properties on the thrown object. If
 <code>stackStartFn</code> is provided, all stack frames above that function will be
 removed from stacktrace (see <a href="#errors_error_capturestacktrace_targetobject_constructoropt"><code>Error.captureStackTrace</code></a>). If no arguments are
 given, the default message <code>Failed</code> will be used.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.fail(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: 'a' != 'b'</span>
 
-assert.fail(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'>'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'>'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: 1 > 2</span>
 
-assert.fail(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'fail'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'fail'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: fail</span>
 
-assert.fail(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'whoops'</span>, <span class="hljs-string">'>'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'whoops'</span>, <span class="hljs-string">'>'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: whoops</span>
 
-assert.fail(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'need array'</span>));
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'need array'</span>));
 <span class="hljs-comment">// TypeError: need array</span></code></pre>
 <p>In the last three cases <code>actual</code>, <code>expected</code>, and <code>operator</code> have no
 influence on the error message.</p>
 <p>Example use of <code>stackStartFn</code> for truncating the exception's stacktrace:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">suppressFrame</span>(<span class="hljs-params"></span>) </span>{
-  assert.fail(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'!=='</span>, suppressFrame);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">suppressFrame</span>(<span class="hljs-params"></span>) {
+  assert.<span class="hljs-title function_">fail</span>(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'!=='</span>, suppressFrame);
 }
-suppressFrame();
+<span class="hljs-title function_">suppressFrame</span>();
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: 'a' !== 'b'</span>
 <span class="hljs-comment">//     at repl:1:1</span>
 <span class="hljs-comment">//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)</span>
 <span class="hljs-comment">//     ...</span></code></pre>
-<h2><code>assert.ifError(value)</code><span><a class="mark" href="#assert_assert_iferror_value" id="assert_assert_iferror_value">#</a></span></h2>
+</section><section><h3><code>assert.ifError(value)</code><span><a class="mark" href="#assert_assert_iferror_value" id="assert_assert_iferror_value">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -4916,32 +5262,32 @@ suppressFrame();
 testing the <code>error</code> argument in callbacks. The stack trace contains all frames
 from the error passed to <code>ifError()</code> including the potential new frames for
 <code>ifError()</code> itself.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.ifError(<span class="hljs-literal">null</span>);
+assert.<span class="hljs-title function_">ifError</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// OK</span>
-assert.ifError(<span class="hljs-number">0</span>);
+assert.<span class="hljs-title function_">ifError</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0</span>
-assert.ifError(<span class="hljs-string">'error'</span>);
+assert.<span class="hljs-title function_">ifError</span>(<span class="hljs-string">'error'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'</span>
-assert.ifError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>());
+assert.<span class="hljs-title function_">ifError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>());
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error</span>
 
 <span class="hljs-comment">// Create some random error frames.</span>
 <span class="hljs-keyword">let</span> err;
-(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">errorFrame</span>(<span class="hljs-params"></span>) </span>{
-  err = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'test error'</span>);
+(<span class="hljs-keyword">function</span> <span class="hljs-title function_">errorFrame</span>(<span class="hljs-params"></span>) {
+  err = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'test error'</span>);
 })();
 
-(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">ifErrorFrame</span>(<span class="hljs-params"></span>) </span>{
-  assert.ifError(err);
+(<span class="hljs-keyword">function</span> <span class="hljs-title function_">ifErrorFrame</span>(<span class="hljs-params"></span>) {
+  assert.<span class="hljs-title function_">ifError</span>(err);
 })();
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error</span>
 <span class="hljs-comment">//     at ifErrorFrame</span>
 <span class="hljs-comment">//     at errorFrame</span></code></pre>
-<h2><code>assert.match(string, regexp[, message])</code><span><a class="mark" href="#assert_assert_match_string_regexp_message" id="assert_assert_match_string_regexp_message">#</a></span></h2>
+</section><section><h3><code>assert.match(string, regexp[, message])</code><span><a class="mark" href="#assert_assert_match_string_regexp_message" id="assert_assert_match_string_regexp_message">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.6.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -4952,15 +5298,15 @@ assert.ifError(<span class="hljs-keyword">new</span> <span class="hljs-built_in"
 <p>Expects the <code>string</code> input to match the regular expression.</p>
 <p>This feature is currently experimental and the name might change or it might be
 completely removed again.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.match(<span class="hljs-string">'I will fail'</span>, <span class="hljs-regexp">/pass/</span>);
+assert.<span class="hljs-title function_">match</span>(<span class="hljs-string">'I will fail'</span>, <span class="hljs-regexp">/pass/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: The input did not match the regular ...</span>
 
-assert.match(<span class="hljs-number">123</span>, <span class="hljs-regexp">/pass/</span>);
+assert.<span class="hljs-title function_">match</span>(<span class="hljs-number">123</span>, <span class="hljs-regexp">/pass/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.</span>
 
-assert.match(<span class="hljs-string">'I will pass'</span>, <span class="hljs-regexp">/pass/</span>);
+assert.<span class="hljs-title function_">match</span>(<span class="hljs-string">'I will pass'</span>, <span class="hljs-regexp">/pass/</span>);
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values do not match, or if the <code>string</code> argument is of another type than
 <code>string</code>, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code> property set equal
@@ -4968,15 +5314,19 @@ to the value of the <code>message</code> parameter. If the <code>message</code>
 undefined, a default error message is assigned. If the <code>message</code> parameter is an
 instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.notDeepEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notdeepequal_actual_expected_message" id="assert_assert_notdeepequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.notDeepEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notdeepequal_actual_expected_message" id="assert_assert_notdeepequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>In Legacy assertion mode, changed status from Deprecated to Legacy.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>NaN is now treated as being identical in case both sides are NaN.</p></td></tr>
 <tr><td>v9.0.0</td>
-<td><p>The <code>Error</code> names and messages are now properly compared</p></td></tr>
+<td><p>The <code>Error</code> names and messages are now properly compared.</p></td></tr>
 <tr><td>v8.0.0</td>
-<td><p>The <code>Set</code> and <code>Map</code> content is also compared</p></td></tr>
+<td><p>The <code>Set</code> and <code>Map</code> content is also compared.</p></td></tr>
 <tr><td>v6.4.0, v4.7.1</td>
 <td><p>Typed array slices are handled correctly now.</p></td></tr>
 <tr><td>v6.1.0, v4.5.0</td>
@@ -4996,7 +5346,7 @@ instance of an <a href="#errors_class_error"><code>Error</code></a> then it will
 <p><strong>Strict assertion mode</strong></p>
 <p>An alias of <a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual()</code></a>.</p>
 <p><strong>Legacy assertion mode</strong></p>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual()</code></a> instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use <a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual()</code></a> instead.</div><p></p>
 <p>Tests for any deep inequality. Opposite of <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
@@ -5015,25 +5365,25 @@ instance of an <a href="#errors_class_error"><code>Error</code></a> then it will
     <span class="hljs-attr">b</span>: <span class="hljs-number">1</span>
   }
 };
-<span class="hljs-keyword">const</span> obj4 = <span class="hljs-built_in">Object</span>.create(obj1);
+<span class="hljs-keyword">const</span> obj4 = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(obj1);
 
-assert.notDeepEqual(obj1, obj1);
+assert.<span class="hljs-title function_">notDeepEqual</span>(obj1, obj1);
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }</span>
 
-assert.notDeepEqual(obj1, obj2);
+assert.<span class="hljs-title function_">notDeepEqual</span>(obj1, obj2);
 <span class="hljs-comment">// OK</span>
 
-assert.notDeepEqual(obj1, obj3);
+assert.<span class="hljs-title function_">notDeepEqual</span>(obj1, obj3);
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }</span>
 
-assert.notDeepEqual(obj1, obj4);
+assert.<span class="hljs-title function_">notDeepEqual</span>(obj1, obj4);
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values are deeply equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
 <code>message</code> property set equal to the value of the <code>message</code> parameter. If the
 <code>message</code> parameter is undefined, a default error message is assigned. If the
 <code>message</code> parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown
 instead of the <code>AssertionError</code>.</p>
-<h2><code>assert.notDeepStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notdeepstrictequal_actual_expected_message" id="assert_assert_notdeepstrictequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.notDeepStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notdeepstrictequal_actual_expected_message" id="assert_assert_notdeepstrictequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -5043,13 +5393,13 @@ instead of the <code>AssertionError</code>.</p>
 <tr><td>v9.0.0</td>
 <td><p>The <code>NaN</code> is now compared using the <a href="https://tc39.github.io/ecma262/#sec-samevaluezero">SameValueZero</a> comparison.</p></td></tr>
 <tr><td>v9.0.0</td>
-<td><p>The <code>Error</code> names and messages are now properly compared</p></td></tr>
+<td><p>The <code>Error</code> names and messages are now properly compared.</p></td></tr>
 <tr><td>v8.0.0</td>
-<td><p>The <code>Set</code> and <code>Map</code> content is also compared</p></td></tr>
-<tr><td>v6.4.0, v4.7.1</td>
-<td><p>Typed array slices are handled correctly now.</p></td></tr>
+<td><p>The <code>Set</code> and <code>Map</code> content is also compared.</p></td></tr>
 <tr><td>v6.1.0</td>
 <td><p>Objects with circular references can be used as inputs now.</p></td></tr>
+<tr><td>v6.4.0, v4.7.1</td>
+<td><p>Typed array slices are handled correctly now.</p></td></tr>
 <tr><td>v5.10.1, v4.4.3</td>
 <td><p>Handle non-<code>Uint8Array</code> typed arrays correctly.</p></td></tr>
 <tr><td>v1.2.0</td>
@@ -5063,18 +5413,28 @@ instead of the <code>AssertionError</code>.</p>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 <p>Tests for deep strict inequality. Opposite of <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.notDeepStrictEqual({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'1'</span> });
+assert.<span class="hljs-title function_">notDeepStrictEqual</span>({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'1'</span> });
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values are deeply and strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown
 with a <code>message</code> property set equal to the value of the <code>message</code> parameter. If
 the <code>message</code> parameter is undefined, a default error message is assigned. If
 the <code>message</code> parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown
 instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.notEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notequal_actual_expected_message" id="assert_assert_notequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.notEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notequal_actual_expected_message" id="assert_assert_notequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.1.21</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>In Legacy assertion mode, changed status from Deprecated to Legacy.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>NaN is now treated as being identical in case both sides are NaN.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
@@ -5084,31 +5444,32 @@ instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionErro
 <p><strong>Strict assertion mode</strong></p>
 <p>An alias of <a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual()</code></a>.</p>
 <p><strong>Legacy assertion mode</strong></p>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual()</code></a> instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use <a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual()</code></a> instead.</div><p></p>
 <p>Tests shallow, coercive inequality with the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
-( <code>!=</code> ).</p>
+(<code>!=</code> ). <code>NaN</code> is special handled and treated as being identical in case both
+sides are <code>NaN</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
-assert.notEqual(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+assert.<span class="hljs-title function_">notEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 <span class="hljs-comment">// OK</span>
 
-assert.notEqual(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">notEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
 <span class="hljs-comment">// AssertionError: 1 != 1</span>
 
-assert.notEqual(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
+assert.<span class="hljs-title function_">notEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
 <span class="hljs-comment">// AssertionError: 1 != '1'</span></code></pre>
 <p>If the values are equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
 property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
 parameter is undefined, a default error message is assigned. If the <code>message</code>
 parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <code>AssertionError</code>.</p>
-<h2><code>assert.notStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notstrictequal_actual_expected_message" id="assert_assert_notstrictequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.notStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notstrictequal_actual_expected_message" id="assert_assert_notstrictequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
-<td><p>Used comparison changed from Strict Equality to <code>Object.is()</code></p></td></tr>
+<td><p>Used comparison changed from Strict Equality to <code>Object.is()</code>.</p></td></tr>
 <tr><td>v0.1.21</td>
 <td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
@@ -5121,24 +5482,24 @@ parameter is an instance of an <a href="#errors_class_error"><code>Error</code><
 </ul>
 <p>Tests strict inequality between the <code>actual</code> and <code>expected</code> parameters as
 determined by the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.notStrictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+assert.<span class="hljs-title function_">notStrictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 <span class="hljs-comment">// OK</span>
 
-assert.notStrictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">notStrictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// 1</span>
 
-assert.notStrictEqual(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
+assert.<span class="hljs-title function_">notStrictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values are strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
 <code>message</code> property set equal to the value of the <code>message</code> parameter. If the
 <code>message</code> parameter is undefined, a default error message is assigned. If the
 <code>message</code> parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown
 instead of the <code>AssertionError</code>.</p>
-<h2><code>assert.ok(value[, message])</code><span><a class="mark" href="#assert_assert_ok_value_message" id="assert_assert_ok_value_message">#</a></span></h2>
+</section><section><h3><code>assert.ok(value[, message])</code><span><a class="mark" href="#assert_assert_ok_value_message" id="assert_assert_ok_value_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -5165,45 +5526,45 @@ If no arguments are passed in at all <code>message</code> will be set to the str
 <code>'No value argument passed to `assert.ok()`'</code>.</p>
 <p>Be aware that in the <code>repl</code> the error message will be different to the one
 thrown in a file! See below for further details.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.ok(<span class="hljs-literal">true</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-literal">true</span>);
 <span class="hljs-comment">// OK</span>
-assert.ok(<span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-number">1</span>);
 <span class="hljs-comment">// OK</span>
 
-assert.ok();
+assert.<span class="hljs-title function_">ok</span>();
 <span class="hljs-comment">// AssertionError: No value argument passed to `assert.ok()`</span>
 
-assert.ok(<span class="hljs-literal">false</span>, <span class="hljs-string">'it\'s false'</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-literal">false</span>, <span class="hljs-string">'it\'s false'</span>);
 <span class="hljs-comment">// AssertionError: it's false</span>
 
 <span class="hljs-comment">// In the repl:</span>
-assert.ok(<span class="hljs-keyword">typeof</span> <span class="hljs-number">123</span> === <span class="hljs-string">'string'</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-keyword">typeof</span> <span class="hljs-number">123</span> === <span class="hljs-string">'string'</span>);
 <span class="hljs-comment">// AssertionError: false == true</span>
 
 <span class="hljs-comment">// In a file (e.g. test.js):</span>
-assert.ok(<span class="hljs-keyword">typeof</span> <span class="hljs-number">123</span> === <span class="hljs-string">'string'</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-keyword">typeof</span> <span class="hljs-number">123</span> === <span class="hljs-string">'string'</span>);
 <span class="hljs-comment">// AssertionError: The expression evaluated to a falsy value:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">//   assert.ok(typeof 123 === 'string')</span>
 
-assert.ok(<span class="hljs-literal">false</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-literal">false</span>);
 <span class="hljs-comment">// AssertionError: The expression evaluated to a falsy value:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">//   assert.ok(false)</span>
 
-assert.ok(<span class="hljs-number">0</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// AssertionError: The expression evaluated to a falsy value:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">//   assert.ok(0)</span>
 
 <span class="hljs-comment">// Using `assert()` works the same:</span>
-assert(<span class="hljs-number">0</span>);
+<span class="hljs-title function_">assert</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// AssertionError: The expression evaluated to a falsy value:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">//   assert(0)</span></code></pre>
-<h2><code>assert.rejects(asyncFn[, error][, message])</code><span><a class="mark" href="#assert_assert_rejects_asyncfn_error_message" id="assert_assert_rejects_asyncfn_error_message">#</a></span></h2>
+</section><section><h3><code>assert.rejects(asyncFn[, error][, message])</code><span><a class="mark" href="#assert_assert_rejects_asyncfn_error_message" id="assert_assert_rejects_asyncfn_error_message">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -5229,9 +5590,9 @@ each property will be tested for including the non-enumerable <code>message</cod
 <p>If specified, <code>message</code> will be the message provided by the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>
 if the <code>asyncFn</code> fails to reject.</p>
 <pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">await</span> assert.rejects(
+  <span class="hljs-keyword">await</span> assert.<span class="hljs-title function_">rejects</span>(
     <span class="hljs-keyword">async</span> () => {
-      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
     },
     {
       <span class="hljs-attr">name</span>: <span class="hljs-string">'TypeError'</span>,
@@ -5240,21 +5601,21 @@ if the <code>asyncFn</code> fails to reject.</p>
   );
 })();</code></pre>
 <pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">await</span> assert.rejects(
+  <span class="hljs-keyword">await</span> assert.<span class="hljs-title function_">rejects</span>(
     <span class="hljs-keyword">async</span> () => {
-      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
     },
     <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-      assert.strictEqual(err.name, <span class="hljs-string">'TypeError'</span>);
-      assert.strictEqual(err.message, <span class="hljs-string">'Wrong value'</span>);
+      assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">name</span>, <span class="hljs-string">'TypeError'</span>);
+      assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">message</span>, <span class="hljs-string">'Wrong value'</span>);
       <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
     }
   );
 })();</code></pre>
-<pre><code class="language-js">assert.rejects(
-  <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Wrong value'</span>)),
-  <span class="hljs-built_in">Error</span>
-).then(<span class="hljs-function">() =></span> {
+<pre><code class="language-js">assert.<span class="hljs-title function_">rejects</span>(
+  <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Wrong value'</span>)),
+  <span class="hljs-title class_">Error</span>
+).<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p><code>error</code> cannot be a string. If a string is provided as the second
@@ -5262,13 +5623,13 @@ argument, then <code>error</code> is assumed to be omitted and the string will b
 <code>message</code> instead. This can lead to easy-to-miss mistakes. Please read the
 example in <a href="#assert_assert_throws_fn_error_message"><code>assert.throws()</code></a> carefully if using a string as the second
 argument gets considered.</p>
-<h2><code>assert.strictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_strictequal_actual_expected_message" id="assert_assert_strictequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.strictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_strictequal_actual_expected_message" id="assert_assert_strictequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
-<td><p>Used comparison changed from Strict Equality to <code>Object.is()</code></p></td></tr>
+<td><p>Used comparison changed from Strict Equality to <code>Object.is()</code>.</p></td></tr>
 <tr><td>v0.1.21</td>
 <td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
@@ -5281,17 +5642,17 @@ argument gets considered.</p>
 </ul>
 <p>Tests strict equality between the <code>actual</code> and <code>expected</code> parameters as
 determined by the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.strictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// 1 !== 2</span>
 
-assert.strictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
 <span class="hljs-comment">// OK</span>
 
-assert.strictEqual(<span class="hljs-string">'Hello foobar'</span>, <span class="hljs-string">'Hello World!'</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-string">'Hello foobar'</span>, <span class="hljs-string">'Hello World!'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
@@ -5301,17 +5662,17 @@ assert.strictEqual(<span class="hljs-string">'Hello foobar'</span>, <span class=
 
 <span class="hljs-keyword">const</span> apples = <span class="hljs-number">1</span>;
 <span class="hljs-keyword">const</span> oranges = <span class="hljs-number">2</span>;
-assert.strictEqual(apples, oranges, <span class="hljs-string">`apples <span class="hljs-subst">${apples}</span> !== oranges <span class="hljs-subst">${oranges}</span>`</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(apples, oranges, <span class="hljs-string">`apples <span class="hljs-subst">${apples}</span> !== oranges <span class="hljs-subst">${oranges}</span>`</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2</span>
 
-assert.strictEqual(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Inputs are not identical'</span>));
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Inputs are not identical'</span>));
 <span class="hljs-comment">// TypeError: Inputs are not identical</span></code></pre>
 <p>If the values are not strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
 <code>message</code> property set equal to the value of the <code>message</code> parameter. If the
 <code>message</code> parameter is undefined, a default error message is assigned. If the
 <code>message</code> parameter is an instance of an <a href="#errors_class_error"><code>Error</code></a> then it will be thrown
 instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.throws(fn[, error][, message])</code><span><a class="mark" href="#assert_assert_throws_fn_error_message" id="assert_assert_throws_fn_error_message">#</a></span></h2>
+</section><section><h3><code>assert.throws(fn[, error][, message])</code><span><a class="mark" href="#assert_assert_throws_fn_error_message" id="assert_assert_throws_fn_error_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -5343,16 +5704,16 @@ validating against a string property. See below for examples.</p>
 <code>AssertionError</code> if the <code>fn</code> call fails to throw or in case the error validation
 fails.</p>
 <p>Custom validation object/error instance:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
-err.code = <span class="hljs-number">404</span>;
-err.foo = <span class="hljs-string">'bar'</span>;
-err.info = {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+err.<span class="hljs-property">code</span> = <span class="hljs-number">404</span>;
+err.<span class="hljs-property">foo</span> = <span class="hljs-string">'bar'</span>;
+err.<span class="hljs-property">info</span> = {
   <span class="hljs-attr">nested</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">baz</span>: <span class="hljs-string">'text'</span>
 };
-err.reg = <span class="hljs-regexp">/abc/i</span>;
+err.<span class="hljs-property">reg</span> = <span class="hljs-regexp">/abc/i</span>;
 
-assert.throws(
+assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
     <span class="hljs-keyword">throw</span> err;
   },
@@ -5370,7 +5731,7 @@ assert.throws(
 );
 
 <span class="hljs-comment">// Using regular expressions to validate error properties:</span>
-assert.throws(
+assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
     <span class="hljs-keyword">throw</span> err;
   },
@@ -5379,8 +5740,8 @@ assert.throws(
     <span class="hljs-comment">// expressions on those will match against the string. If they fail, an</span>
     <span class="hljs-comment">// error is thrown.</span>
     <span class="hljs-attr">name</span>: <span class="hljs-regexp">/^TypeError$/</span>,
-    message: <span class="hljs-regexp">/Wrong/</span>,
-    foo: <span class="hljs-string">'bar'</span>,
+    <span class="hljs-attr">message</span>: <span class="hljs-regexp">/Wrong/</span>,
+    <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>,
     <span class="hljs-attr">info</span>: {
       <span class="hljs-attr">nested</span>: <span class="hljs-literal">true</span>,
       <span class="hljs-comment">// It is not possible to use regular expressions for nested properties!</span>
@@ -5394,11 +5755,11 @@ assert.throws(
 );
 
 <span class="hljs-comment">// Fails due to the different `message` and `name` properties:</span>
-assert.throws(
+assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">const</span> otherErr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Not found'</span>);
+    <span class="hljs-keyword">const</span> otherErr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Not found'</span>);
     <span class="hljs-comment">// Copy all enumerable properties from `err` to `otherErr`.</span>
-    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> [key, value] <span class="hljs-keyword">of</span> <span class="hljs-built_in">Object</span>.entries(err)) {
+    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> [key, value] <span class="hljs-keyword">of</span> <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">entries</span>(err)) {
       otherErr[key] = value;
     }
     <span class="hljs-keyword">throw</span> otherErr;
@@ -5408,31 +5769,31 @@ assert.throws(
   err
 );</code></pre>
 <p>Validate instanceof using constructor:</p>
-<pre><code class="language-js">assert.throws(
+<pre><code class="language-js">assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Wrong value'</span>);
   },
-  <span class="hljs-built_in">Error</span>
+  <span class="hljs-title class_">Error</span>
 );</code></pre>
 <p>Validate error message using <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions"><code>RegExp</code></a>:</p>
 <p>Using a regular expression runs <code>.toString</code> on the error object, and will
 therefore also include the error name.</p>
-<pre><code class="language-js">assert.throws(
+<pre><code class="language-js">assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Wrong value'</span>);
   },
   <span class="hljs-regexp">/^Error: Wrong value$/</span>
 );</code></pre>
 <p>Custom error validation:</p>
 <p>The function must return <code>true</code> to indicate all internal validations passed.
 It will otherwise fail with an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<pre><code class="language-js">assert.throws(
+<pre><code class="language-js">assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Wrong value'</span>);
   },
   <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    assert(err <span class="hljs-keyword">instanceof</span> <span class="hljs-built_in">Error</span>);
-    assert(<span class="hljs-regexp">/value/</span>.test(err));
+    <span class="hljs-title function_">assert</span>(err <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">Error</span>);
+    <span class="hljs-title function_">assert</span>(<span class="hljs-regexp">/value/</span>.<span class="hljs-title function_">test</span>(err));
     <span class="hljs-comment">// Avoid returning anything from validation functions besides `true`.</span>
     <span class="hljs-comment">// Otherwise, it's not clear what part of the validation failed. Instead,</span>
     <span class="hljs-comment">// throw an error about the specific validation that failed (as done in this</span>
@@ -5449,47 +5810,48 @@ message as the thrown error message is going to result in an
 <code>ERR_AMBIGUOUS_ARGUMENT</code> error. Please read the example below carefully if using
 a string as the second argument gets considered:</p>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">throwingFirst</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'First'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">throwingFirst</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'First'</span>);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">throwingSecond</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Second'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">throwingSecond</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Second'</span>);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">notThrowing</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">notThrowing</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// The second argument is a string and the input function threw an Error.</span>
 <span class="hljs-comment">// The first case will not throw as it does not match for the error message</span>
 <span class="hljs-comment">// thrown by the input function!</span>
-assert.throws(throwingFirst, <span class="hljs-string">'Second'</span>);
+assert.<span class="hljs-title function_">throws</span>(throwingFirst, <span class="hljs-string">'Second'</span>);
 <span class="hljs-comment">// In the next example the message has no benefit over the message from the</span>
 <span class="hljs-comment">// error and since it is not clear if the user intended to actually match</span>
 <span class="hljs-comment">// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.</span>
-assert.throws(throwingSecond, <span class="hljs-string">'Second'</span>);
+assert.<span class="hljs-title function_">throws</span>(throwingSecond, <span class="hljs-string">'Second'</span>);
 <span class="hljs-comment">// TypeError [ERR_AMBIGUOUS_ARGUMENT]</span>
 
 <span class="hljs-comment">// The string is only used (as message) in case the function does not throw:</span>
-assert.throws(notThrowing, <span class="hljs-string">'Second'</span>);
+assert.<span class="hljs-title function_">throws</span>(notThrowing, <span class="hljs-string">'Second'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Missing expected exception: Second</span>
 
 <span class="hljs-comment">// If it was intended to match for the error message do this instead:</span>
 <span class="hljs-comment">// It does not throw because the error messages match.</span>
-assert.throws(throwingSecond, <span class="hljs-regexp">/Second$/</span>);
+assert.<span class="hljs-title function_">throws</span>(throwingSecond, <span class="hljs-regexp">/Second$/</span>);
 
 <span class="hljs-comment">// If the error message does not match, an AssertionError is thrown.</span>
-assert.throws(throwingFirst, <span class="hljs-regexp">/Second$/</span>);
+assert.<span class="hljs-title function_">throws</span>(throwingFirst, <span class="hljs-regexp">/Second$/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]</span></code></pre>
 <p>Due to the confusing error-prone notation, avoid a string as the second
-argument.</p>
-<h1>Async hooks<span><a class="mark" href="#async_hooks_async_hooks" id="async_hooks_async_hooks">#</a></span></h1>
+argument.</p></section>
+        </section>
+<section><h2>Async hooks<span><a class="mark" href="#async_hooks_async_hooks" id="async_hooks_async_hooks">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/async_hooks.js">lib/async_hooks.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/async_hooks.js">lib/async_hooks.js</a></p>
 <p>The <code>async_hooks</code> module provides an API to track asynchronous resources. It
 can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);</code></pre>
-<h2>Terminology<span><a class="mark" href="#async_hooks_terminology" id="async_hooks_terminology">#</a></span></h2>
+<section><h3>Terminology<span><a class="mark" href="#async_hooks_terminology" id="async_hooks_terminology">#</a></span></h3>
 <p>An asynchronous resource represents an object with an associated callback.
 This callback may be called multiple times, for example, the <code>'connection'</code>
 event in <code>net.createServer()</code>, or just a single time like in <code>fs.open()</code>.
@@ -5498,29 +5860,28 @@ not explicitly distinguish between these different cases but will represent them
 as the abstract concept that is a resource.</p>
 <p>If <a href="#worker_threads_class_worker"><code>Worker</code></a>s are used, each thread has an independent <code>async_hooks</code>
 interface, and each thread will use a new set of async IDs.</p>
-<h2>Public API<span><a class="mark" href="#async_hooks_public_api" id="async_hooks_public_api">#</a></span></h2>
-<h3>Overview<span><a class="mark" href="#async_hooks_overview" id="async_hooks_overview">#</a></span></h3>
+</section><section><h3>Overview<span><a class="mark" href="#async_hooks_overview" id="async_hooks_overview">#</a></span></h3>
 <p>Following is a simple overview of the public API.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
 <span class="hljs-comment">// Return the ID of the current execution context.</span>
-<span class="hljs-keyword">const</span> eid = async_hooks.executionAsyncId();
+<span class="hljs-keyword">const</span> eid = async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
 
 <span class="hljs-comment">// Return the ID of the handle responsible for triggering the callback of the</span>
 <span class="hljs-comment">// current execution scope to call.</span>
-<span class="hljs-keyword">const</span> tid = async_hooks.triggerAsyncId();
+<span class="hljs-keyword">const</span> tid = async_hooks.<span class="hljs-title function_">triggerAsyncId</span>();
 
 <span class="hljs-comment">// Create a new AsyncHook instance. All of these callbacks are optional.</span>
 <span class="hljs-keyword">const</span> asyncHook =
-    async_hooks.createHook({ init, before, after, destroy, promiseResolve });
+    async_hooks.<span class="hljs-title function_">createHook</span>({ init, before, after, destroy, promiseResolve });
 
 <span class="hljs-comment">// Allow callbacks of this AsyncHook instance to call. This is not an implicit</span>
 <span class="hljs-comment">// action after running the constructor, and must be explicitly run to begin</span>
 <span class="hljs-comment">// executing callbacks.</span>
-asyncHook.enable();
+asyncHook.<span class="hljs-title function_">enable</span>();
 
 <span class="hljs-comment">// Disable listening for new asynchronous events.</span>
-asyncHook.disable();
+asyncHook.<span class="hljs-title function_">disable</span>();
 
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// The following are the callbacks that can be passed to createHook().</span>
@@ -5529,24 +5890,24 @@ asyncHook.disable();
 <span class="hljs-comment">// init is called during object construction. The resource may not have</span>
 <span class="hljs-comment">// completed construction when this callback runs, therefore all fields of the</span>
 <span class="hljs-comment">// resource referenced by "asyncId" may not have been populated.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) </span>{ }
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) { }
 
 <span class="hljs-comment">// Before is called just before the resource's callback is called. It can be</span>
-<span class="hljs-comment">// called 0-N times for handles (e.g. TCPWrap), and will be called exactly 1</span>
-<span class="hljs-comment">// time for requests (e.g. FSReqCallback).</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">before</span>(<span class="hljs-params">asyncId</span>) </span>{ }
+<span class="hljs-comment">// called 0-N times for handles (such as TCPWrap), and will be called exactly 1</span>
+<span class="hljs-comment">// time for requests (such as FSReqCallback).</span>
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">before</span>(<span class="hljs-params">asyncId</span>) { }
 
 <span class="hljs-comment">// After is called just after the resource's callback has finished.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">after</span>(<span class="hljs-params">asyncId</span>) </span>{ }
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">after</span>(<span class="hljs-params">asyncId</span>) { }
 
 <span class="hljs-comment">// Destroy is called when the resource is destroyed.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">destroy</span>(<span class="hljs-params">asyncId</span>) </span>{ }
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">destroy</span>(<span class="hljs-params">asyncId</span>) { }
 
 <span class="hljs-comment">// promiseResolve is called only for promise resources, when the</span>
 <span class="hljs-comment">// `resolve` function passed to the `Promise` constructor is invoked</span>
 <span class="hljs-comment">// (either directly or through other means of resolving a promise).</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">promiseResolve</span>(<span class="hljs-params">asyncId</span>) </span>{ }</code></pre>
-<h4><code>async_hooks.createHook(callbacks)</code><span><a class="mark" href="#async_hooks_async_hooks_createhook_callbacks" id="async_hooks_async_hooks_createhook_callbacks">#</a></span></h4>
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">promiseResolve</span>(<span class="hljs-params">asyncId</span>) { }</code></pre>
+</section><section><h3><code>async_hooks.createHook(callbacks)</code><span><a class="mark" href="#async_hooks_async_hooks_createhook_callbacks" id="async_hooks_async_hooks_createhook_callbacks">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.1.0</span>
 </div>
@@ -5572,23 +5933,26 @@ specifics of all functions that can be passed to <code>callbacks</code> is in th
 <a href="#async_hooks_hook_callbacks">Hook Callbacks</a> section.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-keyword">const</span> asyncHook = async_hooks.createHook({
-  init(asyncId, type, triggerAsyncId, resource) { },
-  destroy(asyncId) { }
+<span class="hljs-keyword">const</span> asyncHook = async_hooks.<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) { },
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">asyncId</span>) { }
 });</code></pre>
 <p>The callbacks will be inherited via the prototype chain:</p>
-<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyAsyncCallbacks</span> </span>{
-  init(asyncId, type, triggerAsyncId, resource) { }
-  destroy(asyncId) {}
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">MyAsyncCallbacks</span> {
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) { }
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">asyncId</span>) {}
 }
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyAddedCallbacks</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">MyAsyncCallbacks</span> </span>{
-  before(asyncId) { }
-  after(asyncId) { }
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyAddedCallbacks</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">MyAsyncCallbacks</span> {
+  <span class="hljs-title function_">before</span>(<span class="hljs-params">asyncId</span>) { }
+  <span class="hljs-title function_">after</span>(<span class="hljs-params">asyncId</span>) { }
 }
 
-<span class="hljs-keyword">const</span> asyncHook = async_hooks.createHook(<span class="hljs-keyword">new</span> MyAddedCallbacks());</code></pre>
-<h5>Error handling<span><a class="mark" href="#async_hooks_error_handling" id="async_hooks_error_handling">#</a></span></h5>
+<span class="hljs-keyword">const</span> asyncHook = async_hooks.<span class="hljs-title function_">createHook</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">MyAddedCallbacks</span>());</code></pre>
+<p>Because promises are asynchronous resources whose lifecycle is tracked
+via the async hooks mechanism, the <code>init()</code>, <code>before()</code>, <code>after()</code>, and
+<code>destroy()</code> callbacks <em>must not</em> be async functions that return promises.</p>
+<h4>Error handling<span><a class="mark" href="#async_hooks_error_handling" id="async_hooks_error_handling">#</a></span></h4>
 <p>If any <code>AsyncHook</code> callbacks throw, the application will print the stack trace
 and exit. The exit path does follow that of an uncaught exception, but
 all <code>'uncaughtException'</code> listeners are removed, thus forcing the process to
@@ -5602,7 +5966,7 @@ bring down the process quickly in order to prevent an unintentional abort in the
 future. This is subject to change in the future if a comprehensive analysis is
 performed to ensure an exception can follow the normal control flow without
 unintentional side effects.</p>
-<h5>Printing in AsyncHooks callbacks<span><a class="mark" href="#async_hooks_printing_in_asynchooks_callbacks" id="async_hooks_printing_in_asynchooks_callbacks">#</a></span></h5>
+<h4>Printing in AsyncHooks callbacks<span><a class="mark" href="#async_hooks_printing_in_asynchooks_callbacks" id="async_hooks_printing_in_asynchooks_callbacks">#</a></span></h4>
 <p>Because printing to the console is an asynchronous operation, <code>console.log()</code>
 will cause the AsyncHooks callbacks to be called. Using <code>console.log()</code> or
 similar asynchronous operations inside an AsyncHooks callback function will thus
@@ -5613,16 +5977,16 @@ it is synchronous.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">debug</span>(<span class="hljs-params">...args</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">debug</span>(<span class="hljs-params">...args</span>) {
   <span class="hljs-comment">// Use a function like this one when debugging inside an AsyncHooks callback</span>
-  fs.writeFileSync(<span class="hljs-string">'log.out'</span>, <span class="hljs-string">`<span class="hljs-subst">${util.format(...args)}</span>\n`</span>, { <span class="hljs-attr">flag</span>: <span class="hljs-string">'a'</span> });
+  fs.<span class="hljs-title function_">writeFileSync</span>(<span class="hljs-string">'log.out'</span>, <span class="hljs-string">`<span class="hljs-subst">${util.format(...args)}</span>\n`</span>, { <span class="hljs-attr">flag</span>: <span class="hljs-string">'a'</span> });
 }</code></pre>
 <p>If an asynchronous operation is needed for logging, it is possible to keep
 track of what caused the asynchronous operation using the information
 provided by AsyncHooks itself. The logging should then be skipped when
 it was the logging itself that caused AsyncHooks callback to call. By
 doing this the otherwise infinite recursion is broken.</p>
-<h3>Class: <code>AsyncHook</code><span><a class="mark" href="#async_hooks_class_asynchook" id="async_hooks_class_asynchook">#</a></span></h3>
+</section><section><h3>Class: <code>AsyncHook</code><span><a class="mark" href="#async_hooks_class_asynchook" id="async_hooks_class_asynchook">#</a></span></h3>
 <p>The class <code>AsyncHook</code> exposes an interface for tracking lifetime events
 of asynchronous operations.</p>
 <h4><code>asyncHook.enable()</code><span><a class="mark" href="#async_hooks_asynchook_enable" id="async_hooks_asynchook_enable">#</a></span></h4>
@@ -5630,12 +5994,12 @@ of asynchronous operations.</p>
 <li>Returns: <a href="#async_hooks_async_hooks_createhook_callbacks" class="type">&#x3C;AsyncHook></a> A reference to <code>asyncHook</code>.</li>
 </ul>
 <p>Enable the callbacks for a given <code>AsyncHook</code> instance. If no callbacks are
-provided enabling is a noop.</p>
+provided, enabling is a no-op.</p>
 <p>The <code>AsyncHook</code> instance is disabled by default. If the <code>AsyncHook</code> instance
 should be enabled immediately after creation, the following pattern can be used.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-keyword">const</span> hook = async_hooks.createHook(callbacks).enable();</code></pre>
+<span class="hljs-keyword">const</span> hook = async_hooks.<span class="hljs-title function_">createHook</span>(callbacks).<span class="hljs-title function_">enable</span>();</code></pre>
 <h4><code>asyncHook.disable()</code><span><a class="mark" href="#async_hooks_asynchook_disable" id="async_hooks_asynchook_disable">#</a></span></h4>
 <ul>
 <li>Returns: <a href="#async_hooks_async_hooks_createhook_callbacks" class="type">&#x3C;AsyncHook></a> A reference to <code>asyncHook</code>.</li>
@@ -5664,7 +6028,7 @@ exists.</p>
 <p>This behavior can be observed by doing something like opening a resource then
 closing it before the resource can be used. The following snippet demonstrates
 this.</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer().listen(<span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{ <span class="hljs-built_in">this</span>.close(); });
+<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-title function_">createServer</span>().<span class="hljs-title function_">listen</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) { <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">close</span>(); });
 <span class="hljs-comment">// OR</span>
 <span class="hljs-built_in">clearTimeout</span>(<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {}, <span class="hljs-number">10</span>));</code></pre>
 <p>Every new resource is assigned an ID that is unique within the scope of the
@@ -5690,16 +6054,18 @@ the new resource to initialize and that caused <code>init</code> to call. This i
 from <code>async_hooks.executionAsyncId()</code> that only shows <em>when</em> a resource was
 created, while <code>triggerAsyncId</code> shows <em>why</em> a resource was created.</p>
 <p>The following is a simple demonstration of <code>triggerAsyncId</code>:</p>
-<pre><code class="language-js">async_hooks.createHook({
-  init(asyncId, type, triggerAsyncId) {
-    <span class="hljs-keyword">const</span> eid = async_hooks.executionAsyncId();
-    fs.writeSync(
-      process.stdout.fd,
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { fd } = process.<span class="hljs-property">stdout</span>;
+
+async_hooks.<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId</span>) {
+    <span class="hljs-keyword">const</span> eid = async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
+    fs.<span class="hljs-title function_">writeSync</span>(
+      fd,
       <span class="hljs-string">`<span class="hljs-subst">${type}</span>(<span class="hljs-subst">${asyncId}</span>): trigger: <span class="hljs-subst">${triggerAsyncId}</span> execution: <span class="hljs-subst">${eid}</span>\n`</span>);
   }
-}).enable();
+}).<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {}).listen(<span class="hljs-number">8080</span>);</code></pre>
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8080</span>);</code></pre>
 <p>Output when hitting the server with <code>nc localhost 8080</code>:</p>
 <pre><code class="language-console">TCPSERVERWRAP(5): trigger: 1 execution: 1
 TCPWRAP(7): trigger: 5 execution: 0</code></pre>
@@ -5720,10 +6086,6 @@ host in <code>net.Server.listen()</code>. The API for accessing this information
 not supported, but using the Embedder API, users can provide
 and document their own resource objects. For example, such a resource object
 could contain the SQL query being executed.</p>
-<p>In the case of Promises, the <code>resource</code> object will have an
-<code>isChainedPromise</code> property, set to <code>true</code> if the promise has a parent promise,
-and <code>false</code> otherwise. For example, in the case of <code>b = a.then(handler)</code>, <code>a</code> is
-considered a parent <code>Promise</code> of <code>b</code>. Here, <code>b</code> is considered a chained promise.</p>
 <p>In some cases the resource object is reused for performance reasons, it is
 thus not safe to use it as a key in a <code>WeakMap</code> or add properties to it.</p>
 <h6>Asynchronous context example<span><a class="mark" href="#async_hooks_asynchronous_context_example" id="async_hooks_asynchronous_context_example">#</a></span></h6>
@@ -5731,36 +6093,38 @@ thus not safe to use it as a key in a <code>WeakMap</code> or add properties to
 <code>init</code> between the <code>before</code> and <code>after</code> calls, specifically what the
 callback to <code>listen()</code> will look like. The output formatting is slightly more
 elaborate to make calling context easier to see.</p>
-<pre><code class="language-js"><span class="hljs-keyword">let</span> indent = <span class="hljs-number">0</span>;
-async_hooks.createHook({
-  init(asyncId, type, triggerAsyncId) {
-    <span class="hljs-keyword">const</span> eid = async_hooks.executionAsyncId();
-    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.repeat(indent);
-    fs.writeSync(
-      process.stdout.fd,
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { fd } = process.<span class="hljs-property">stdout</span>;
+
+<span class="hljs-keyword">let</span> indent = <span class="hljs-number">0</span>;
+async_hooks.<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId</span>) {
+    <span class="hljs-keyword">const</span> eid = async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
+    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(indent);
+    fs.<span class="hljs-title function_">writeSync</span>(
+      fd,
       <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span><span class="hljs-subst">${type}</span>(<span class="hljs-subst">${asyncId}</span>):`</span> +
       <span class="hljs-string">` trigger: <span class="hljs-subst">${triggerAsyncId}</span> execution: <span class="hljs-subst">${eid}</span>\n`</span>);
   },
-  before(asyncId) {
-    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.repeat(indent);
-    fs.writeSync(process.stdout.fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>before:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
+  <span class="hljs-title function_">before</span>(<span class="hljs-params">asyncId</span>) {
+    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(indent);
+    fs.<span class="hljs-title function_">writeSync</span>(fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>before:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
     indent += <span class="hljs-number">2</span>;
   },
-  after(asyncId) {
+  <span class="hljs-title function_">after</span>(<span class="hljs-params">asyncId</span>) {
     indent -= <span class="hljs-number">2</span>;
-    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.repeat(indent);
-    fs.writeSync(process.stdout.fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>after:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
+    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(indent);
+    fs.<span class="hljs-title function_">writeSync</span>(fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>after:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
   },
-  destroy(asyncId) {
-    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.repeat(indent);
-    fs.writeSync(process.stdout.fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>destroy:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">asyncId</span>) {
+    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(indent);
+    fs.<span class="hljs-title function_">writeSync</span>(fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>destroy:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
   },
-}).enable();
+}).<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer(<span class="hljs-function">() =></span> {}).listen(<span class="hljs-number">8080</span>, <span class="hljs-function">() =></span> {
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">() =></span> {}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8080</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Let's wait 10ms before logging the server started.</span>
   <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'>>>'</span>, async_hooks.executionAsyncId());
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'>>>'</span>, async_hooks.<span class="hljs-title function_">executionAsyncId</span>());
   }, <span class="hljs-number">10</span>);
 });</code></pre>
 <p>Output from only starting the server:</p>
@@ -5771,7 +6135,7 @@ before:  6
 after:   6
 destroy: 6
 before:  7
-<span class="hljs-meta">></span><span class="bash">>> 7</span>
+<span class="hljs-meta">></span><span class="language-bash">>> 7</span>
   TickObject(8): trigger: 7 execution: 7
 after:   7
 before:  8
@@ -5851,7 +6215,7 @@ invoked (either directly or through other means of resolving a promise).</p>
 <p><code>resolve()</code> does not do any observable synchronous work.</p>
 <p>The <code>Promise</code> is not necessarily fulfilled or rejected at this point if the
 <code>Promise</code> was resolved by assuming the state of another <code>Promise</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve</span>) =></span> resolve(<span class="hljs-literal">true</span>)).then(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> {});</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve</span>) =></span> <span class="hljs-title function_">resolve</span>(<span class="hljs-literal">true</span>)).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> {});</code></pre>
 <p>calls the following callbacks:</p>
 <pre><code class="language-text">init for PROMISE with id 5, trigger id: 1
   promise resolve 5      # corresponds to resolve(true)
@@ -5861,7 +6225,7 @@ init for PROMISE with id 6, trigger id: 5  # the Promise returned by then()
   after 6</code></pre>
 <h4><code>async_hooks.executionAsyncResource()</code><span><a class="mark" href="#async_hooks_async_hooks_executionasyncresource" id="async_hooks_async_hooks_executionasyncresource">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.9.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The resource representing the current execution.
@@ -5876,9 +6240,9 @@ but having an object representing the top-level can be helpful.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { open } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { executionAsyncId, executionAsyncResource } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-built_in">console</span>.log(executionAsyncId(), executionAsyncResource());  <span class="hljs-comment">// 1 {}</span>
-open(__filename, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(executionAsyncId(), executionAsyncResource());  <span class="hljs-comment">// 7 FSReqWrap</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">executionAsyncId</span>(), <span class="hljs-title function_">executionAsyncResource</span>());  <span class="hljs-comment">// 1 {}</span>
+<span class="hljs-title function_">open</span>(__filename, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">executionAsyncId</span>(), <span class="hljs-title function_">executionAsyncResource</span>());  <span class="hljs-comment">// 7 FSReqWrap</span>
 });</code></pre>
 <p>This can be used to implement continuation local storage without the
 use of a tracking <code>Map</code> to store the metadata:</p>
@@ -5888,30 +6252,30 @@ use of a tracking <code>Map</code> to store the metadata:</p>
   executionAsyncResource,
   createHook
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
-<span class="hljs-keyword">const</span> sym = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'state'</span>); <span class="hljs-comment">// Private symbol to avoid pollution</span>
+<span class="hljs-keyword">const</span> sym = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'state'</span>); <span class="hljs-comment">// Private symbol to avoid pollution</span>
 
-createHook({
-  init(asyncId, type, triggerAsyncId, resource) {
-    <span class="hljs-keyword">const</span> cr = executionAsyncResource();
+<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) {
+    <span class="hljs-keyword">const</span> cr = <span class="hljs-title function_">executionAsyncResource</span>();
     <span class="hljs-keyword">if</span> (cr) {
       resource[sym] = cr[sym];
     }
   }
-}).enable();
+}).<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-keyword">const</span> server = createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  executionAsyncResource()[sym] = { <span class="hljs-attr">state</span>: req.url };
-  <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-    res.end(<span class="hljs-built_in">JSON</span>.stringify(executionAsyncResource()[sym]));
+<span class="hljs-keyword">const</span> server = <span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  <span class="hljs-title function_">executionAsyncResource</span>()[sym] = { <span class="hljs-attr">state</span>: req.<span class="hljs-property">url</span> };
+  <span class="hljs-built_in">setTimeout</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
+    res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(<span class="hljs-title function_">executionAsyncResource</span>()[sym]));
   }, <span class="hljs-number">100</span>);
-}).listen(<span class="hljs-number">3000</span>);</code></pre>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);</code></pre>
 <h4><code>async_hooks.executionAsyncId()</code><span><a class="mark" href="#async_hooks_async_hooks_executionasyncid" id="async_hooks_async_hooks_executionasyncid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v8.2.0</td>
-<td><p>Renamed from <code>currentId</code></p></td></tr>
+<td><p>Renamed from <code>currentId</code>.</p></td></tr>
 <tr><td>v8.1.0</td>
 <td><p><span>Added in: v8.1.0</span></p></td></tr>
 </tbody></table>
@@ -5923,21 +6287,21 @@ track when something calls.</li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-built_in">console</span>.log(async_hooks.executionAsyncId());  <span class="hljs-comment">// 1 - bootstrap</span>
-fs.open(path, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(async_hooks.executionAsyncId());  <span class="hljs-comment">// 6 - open()</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(async_hooks.<span class="hljs-title function_">executionAsyncId</span>());  <span class="hljs-comment">// 1 - bootstrap</span>
+fs.<span class="hljs-title function_">open</span>(path, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(async_hooks.<span class="hljs-title function_">executionAsyncId</span>());  <span class="hljs-comment">// 6 - open()</span>
 });</code></pre>
 <p>The ID returned from <code>executionAsyncId()</code> is related to execution timing, not
 causality (which is covered by <code>triggerAsyncId()</code>):</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {
   <span class="hljs-comment">// Returns the ID of the server, not of the new connection, because the</span>
   <span class="hljs-comment">// callback runs in the execution scope of the server's MakeCallback().</span>
-  async_hooks.executionAsyncId();
+  async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
 
-}).listen(port, <span class="hljs-function">() =></span> {
-  <span class="hljs-comment">// Returns the ID of a TickObject (i.e. process.nextTick()) because all</span>
+}).<span class="hljs-title function_">listen</span>(port, <span class="hljs-function">() =></span> {
+  <span class="hljs-comment">// Returns the ID of a TickObject (process.nextTick()) because all</span>
   <span class="hljs-comment">// callbacks passed to .listen() are wrapped in a nextTick().</span>
-  async_hooks.executionAsyncId();
+  async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
 });</code></pre>
 <p>Promise contexts may not get precise <code>executionAsyncIds</code> by default.
 See the section on <a href="#async_hooks_promise_execution_tracking">promise execution tracking</a>.</p>
@@ -5946,28 +6310,28 @@ See the section on <a href="#async_hooks_promise_execution_tracking">promise exe
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The ID of the resource responsible for calling the callback
 that is currently being executed.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {
   <span class="hljs-comment">// The resource that caused (or triggered) this callback to be called</span>
   <span class="hljs-comment">// was that of the new connection. Thus the return value of triggerAsyncId()</span>
   <span class="hljs-comment">// is the asyncId of "conn".</span>
-  async_hooks.triggerAsyncId();
+  async_hooks.<span class="hljs-title function_">triggerAsyncId</span>();
 
-}).listen(port, <span class="hljs-function">() =></span> {
+}).<span class="hljs-title function_">listen</span>(port, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Even though all callbacks passed to .listen() are wrapped in a nextTick()</span>
   <span class="hljs-comment">// the callback itself exists because the call to the server's .listen()</span>
   <span class="hljs-comment">// was made. So the return value would be the ID of the server.</span>
-  async_hooks.triggerAsyncId();
+  async_hooks.<span class="hljs-title function_">triggerAsyncId</span>();
 });</code></pre>
 <p>Promise contexts may not get valid <code>triggerAsyncId</code>s by default. See
 the section on <a href="#async_hooks_promise_execution_tracking">promise execution tracking</a>.</p>
-<h2>Promise execution tracking<span><a class="mark" href="#async_hooks_promise_execution_tracking" id="async_hooks_promise_execution_tracking">#</a></span></h2>
+</section><section><h3>Promise execution tracking<span><a class="mark" href="#async_hooks_promise_execution_tracking" id="async_hooks_promise_execution_tracking">#</a></span></h3>
 <p>By default, promise executions are not assigned <code>asyncId</code>s due to the relatively
 expensive nature of the <a href="https://docs.google.com/document/d/1rda3yKGHimKIhg5YeoAmCOtyURgsbTH_qaYR79FELlk/edit">promise introspection API</a> provided by
 V8. This means that programs using promises or <code>async</code>/<code>await</code> will not get
 correct execution and trigger ids for promise callback contexts by default.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> ah = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
-<span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">1729</span>).then(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`eid <span class="hljs-subst">${ah.executionAsyncId()}</span> tid <span class="hljs-subst">${ah.triggerAsyncId()}</span>`</span>);
+<span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">1729</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`eid <span class="hljs-subst">${ah.executionAsyncId()}</span> tid <span class="hljs-subst">${ah.triggerAsyncId()}</span>`</span>);
 });
 <span class="hljs-comment">// produces:</span>
 <span class="hljs-comment">// eid 1 tid 0</span></code></pre>
@@ -5978,9 +6342,9 @@ the resource that caused (triggered) the <code>then()</code> callback to be exec
 <p>Installing async hooks via <code>async_hooks.createHook</code> enables promise execution
 tracking:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> ah = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
-ah.createHook({ init() {} }).enable(); <span class="hljs-comment">// forces PromiseHooks to be enabled.</span>
-<span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">1729</span>).then(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`eid <span class="hljs-subst">${ah.executionAsyncId()}</span> tid <span class="hljs-subst">${ah.triggerAsyncId()}</span>`</span>);
+ah.<span class="hljs-title function_">createHook</span>({ <span class="hljs-title function_">init</span>(<span class="hljs-params"></span>) {} }).<span class="hljs-title function_">enable</span>(); <span class="hljs-comment">// forces PromiseHooks to be enabled.</span>
+<span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">1729</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`eid <span class="hljs-subst">${ah.executionAsyncId()}</span> tid <span class="hljs-subst">${ah.triggerAsyncId()}</span>`</span>);
 });
 <span class="hljs-comment">// produces:</span>
 <span class="hljs-comment">// eid 7 tid 6</span></code></pre>
@@ -5995,23 +6359,23 @@ async resource <code>6</code>.</p>
 only on chained promises. That means promises not created by <code>then()</code>/<code>catch()</code>
 will not have the <code>before</code> and <code>after</code> callbacks fired on them. For more details
 see the details of the V8 <a href="https://docs.google.com/document/d/1rda3yKGHimKIhg5YeoAmCOtyURgsbTH_qaYR79FELlk/edit">PromiseHooks</a> API.</p>
-<h2>JavaScript embedder API<span><a class="mark" href="#async_hooks_javascript_embedder_api" id="async_hooks_javascript_embedder_api">#</a></span></h2>
+</section><section><h3>JavaScript embedder API<span><a class="mark" href="#async_hooks_javascript_embedder_api" id="async_hooks_javascript_embedder_api">#</a></span></h3>
 <p>Library developers that handle their own asynchronous resources performing tasks
 like I/O, connection pooling, or managing callback queues may use the
 <code>AsyncResource</code> JavaScript API so that all the appropriate callbacks are called.</p>
-<h3>Class: <code>AsyncResource</code><span><a class="mark" href="#async_hooks_class_asyncresource" id="async_hooks_class_asyncresource">#</a></span></h3>
+<h4>Class: <code>AsyncResource</code><span><a class="mark" href="#async_hooks_class_asyncresource" id="async_hooks_class_asyncresource">#</a></span></h4>
 <p>The class <code>AsyncResource</code> is designed to be extended by the embedder's async
 resources. Using this, users can easily trigger the lifetime events of their
 own resources.</p>
 <p>The <code>init</code> hook will trigger when an <code>AsyncResource</code> is instantiated.</p>
 <p>The following is an overview of the <code>AsyncResource</code> API.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { AsyncResource, executionAsyncId } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">AsyncResource</span>, executionAsyncId } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
 <span class="hljs-comment">// AsyncResource() is meant to be extended. Instantiating a</span>
 <span class="hljs-comment">// new AsyncResource() also triggers init. If triggerAsyncId is omitted then</span>
 <span class="hljs-comment">// async_hook.executionAsyncId() is used.</span>
-<span class="hljs-keyword">const</span> asyncResource = <span class="hljs-keyword">new</span> AsyncResource(
-  type, { <span class="hljs-attr">triggerAsyncId</span>: executionAsyncId(), <span class="hljs-attr">requireManualDestroy</span>: <span class="hljs-literal">false</span> }
+<span class="hljs-keyword">const</span> asyncResource = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AsyncResource</span>(
+  type, { <span class="hljs-attr">triggerAsyncId</span>: <span class="hljs-title function_">executionAsyncId</span>(), <span class="hljs-attr">requireManualDestroy</span>: <span class="hljs-literal">false</span> }
 );
 
 <span class="hljs-comment">// Run a function in the execution context of the resource. This will</span>
@@ -6020,17 +6384,17 @@ own resources.</p>
 <span class="hljs-comment">// * call the provided function `fn` with the supplied arguments</span>
 <span class="hljs-comment">// * trigger the AsyncHooks after callbacks</span>
 <span class="hljs-comment">// * restore the original execution context</span>
-asyncResource.runInAsyncScope(fn, thisArg, ...args);
+asyncResource.<span class="hljs-title function_">runInAsyncScope</span>(fn, thisArg, ...args);
 
 <span class="hljs-comment">// Call AsyncHooks destroy callbacks.</span>
-asyncResource.emitDestroy();
+asyncResource.<span class="hljs-title function_">emitDestroy</span>();
 
 <span class="hljs-comment">// Return the unique ID assigned to the AsyncResource instance.</span>
-asyncResource.asyncId();
+asyncResource.<span class="hljs-title function_">asyncId</span>();
 
 <span class="hljs-comment">// Return the trigger ID for the AsyncResource instance.</span>
-asyncResource.triggerAsyncId();</code></pre>
-<h4><code>new AsyncResource(type[, options])</code><span><a class="mark" href="#async_hooks_new_asyncresource_type_options" id="async_hooks_new_asyncresource_type_options">#</a></span></h4>
+asyncResource.<span class="hljs-title function_">triggerAsyncId</span>();</code></pre>
+<h5><code>new AsyncResource(type[, options])</code><span><a class="mark" href="#async_hooks_new_asyncresource_type_options" id="async_hooks_new_asyncresource_type_options">#</a></span></h5>
 <ul>
 <li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The type of async event.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -6048,26 +6412,26 @@ will only take place if there is at least one active <code>destroy</code> hook.
 </li>
 </ul>
 <p>Example usage:</p>
-<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">DBQuery</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">AsyncResource</span> </span>{
-  <span class="hljs-keyword">constructor</span>(db) {
-    <span class="hljs-built_in">super</span>(<span class="hljs-string">'DBQuery'</span>);
-    <span class="hljs-built_in">this</span>.db = db;
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">DBQuery</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">AsyncResource</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">db</span>) {
+    <span class="hljs-variable language_">super</span>(<span class="hljs-string">'DBQuery'</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">db</span> = db;
   }
 
-  getInfo(query, callback) {
-    <span class="hljs-built_in">this</span>.db.get(query, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
-      <span class="hljs-built_in">this</span>.runInAsyncScope(callback, <span class="hljs-literal">null</span>, err, data);
+  <span class="hljs-title function_">getInfo</span>(<span class="hljs-params">query, callback</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">db</span>.<span class="hljs-title function_">get</span>(query, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">runInAsyncScope</span>(callback, <span class="hljs-literal">null</span>, err, data);
     });
   }
 
-  close() {
-    <span class="hljs-built_in">this</span>.db = <span class="hljs-literal">null</span>;
-    <span class="hljs-built_in">this</span>.emitDestroy();
+  <span class="hljs-title function_">close</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">db</span> = <span class="hljs-literal">null</span>;
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emitDestroy</span>();
   }
 }</code></pre>
-<h4>Static method: <code>AsyncResource.bind(fn[, type])</code><span><a class="mark" href="#async_hooks_static_method_asyncresource_bind_fn_type" id="async_hooks_static_method_asyncresource_bind_fn_type">#</a></span></h4>
+<h5>Static method: <code>AsyncResource.bind(fn[, type])</code><span><a class="mark" href="#async_hooks_static_method_asyncresource_bind_fn_type" id="async_hooks_static_method_asyncresource_bind_fn_type">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0</span>
 </div>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to bind to the current execution context.</li>
@@ -6077,9 +6441,9 @@ will only take place if there is at least one active <code>destroy</code> hook.
 <p>Binds the given function to the current execution context.</p>
 <p>The returned function will have an <code>asyncResource</code> property referencing
 the <code>AsyncResource</code> to which the function is bound.</p>
-<h4><code>asyncResource.bind(fn)</code><span><a class="mark" href="#async_hooks_asyncresource_bind_fn" id="async_hooks_asyncresource_bind_fn">#</a></span></h4>
+<h5><code>asyncResource.bind(fn)</code><span><a class="mark" href="#async_hooks_asyncresource_bind_fn" id="async_hooks_asyncresource_bind_fn">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0</span>
 </div>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to bind to the current <code>AsyncResource</code>.</li>
@@ -6087,7 +6451,7 @@ the <code>AsyncResource</code> to which the function is bound.</p>
 <p>Binds the given function to execute to this <code>AsyncResource</code>'s scope.</p>
 <p>The returned function will have an <code>asyncResource</code> property referencing
 the <code>AsyncResource</code> to which the function is bound.</p>
-<h4><code>asyncResource.runInAsyncScope(fn[, thisArg, ...args])</code><span><a class="mark" href="#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args" id="async_hooks_asyncresource_runinasyncscope_fn_thisarg_args">#</a></span></h4>
+<h5><code>asyncResource.runInAsyncScope(fn[, thisArg, ...args])</code><span><a class="mark" href="#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args" id="async_hooks_asyncresource_runinasyncscope_fn_thisarg_args">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 </div>
@@ -6101,7 +6465,7 @@ resource.</li>
 of the async resource. This will establish the context, trigger the AsyncHooks
 before callbacks, call the function, trigger the AsyncHooks after callbacks, and
 then restore the original execution context.</p>
-<h4><code>asyncResource.emitDestroy()</code><span><a class="mark" href="#async_hooks_asyncresource_emitdestroy" id="async_hooks_asyncresource_emitdestroy">#</a></span></h4>
+<h5><code>asyncResource.emitDestroy()</code><span><a class="mark" href="#async_hooks_asyncresource_emitdestroy" id="async_hooks_asyncresource_emitdestroy">#</a></span></h5>
 <ul>
 <li>Returns: <a href="#async_hooks_class_asyncresource" class="type">&#x3C;AsyncResource></a> A reference to <code>asyncResource</code>.</li>
 </ul>
@@ -6109,124 +6473,134 @@ then restore the original execution context.</p>
 be thrown if it is called more than once. This <strong>must</strong> be manually called. If
 the resource is left to be collected by the GC then the <code>destroy</code> hooks will
 never be called.</p>
-<h4><code>asyncResource.asyncId()</code><span><a class="mark" href="#async_hooks_asyncresource_asyncid" id="async_hooks_asyncresource_asyncid">#</a></span></h4>
+<h5><code>asyncResource.asyncId()</code><span><a class="mark" href="#async_hooks_asyncresource_asyncid" id="async_hooks_asyncresource_asyncid">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The unique <code>asyncId</code> assigned to the resource.</li>
 </ul>
-<h4><code>asyncResource.triggerAsyncId()</code><span><a class="mark" href="#async_hooks_asyncresource_triggerasyncid" id="async_hooks_asyncresource_triggerasyncid">#</a></span></h4>
+<h5><code>asyncResource.triggerAsyncId()</code><span><a class="mark" href="#async_hooks_asyncresource_triggerasyncid" id="async_hooks_asyncresource_triggerasyncid">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The same <code>triggerAsyncId</code> that is passed to the
 <code>AsyncResource</code> constructor.</li>
 </ul>
 <p><a id="async-resource-worker-pool"></a></p>
-<h3>Using <code>AsyncResource</code> for a <code>Worker</code> thread pool<span><a class="mark" href="#async_hooks_using_asyncresource_for_a_worker_thread_pool" id="async_hooks_using_asyncresource_for_a_worker_thread_pool">#</a></span></h3>
+<h4>Using <code>AsyncResource</code> for a <code>Worker</code> thread pool<span><a class="mark" href="#async_hooks_using_asyncresource_for_a_worker_thread_pool" id="async_hooks_using_asyncresource_for_a_worker_thread_pool">#</a></span></h4>
 <p>The following example shows how to use the <code>AsyncResource</code> class to properly
 provide async tracking for a <a href="#worker_threads_class_worker"><code>Worker</code></a> pool. Other resource pools, such as
 database connection pools, can follow a similar model.</p>
 <p>Assuming that the task is adding two numbers, using a file named
 <code>task_processor.js</code> with the following content:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-parentPort.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">task</span>) =></span> {
-  parentPort.postMessage(task.a + task.b);
+parentPort.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">task</span>) =></span> {
+  parentPort.<span class="hljs-title function_">postMessage</span>(task.<span class="hljs-property">a</span> + task.<span class="hljs-property">b</span>);
 });</code></pre>
 <p>a Worker pool around it could use the following structure:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { AsyncResource } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
-<span class="hljs-keyword">const</span> { EventEmitter } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">AsyncResource</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 <span class="hljs-keyword">const</span> path = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);
-<span class="hljs-keyword">const</span> { Worker } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
-<span class="hljs-keyword">const</span> kTaskInfo = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'kTaskInfo'</span>);
-<span class="hljs-keyword">const</span> kWorkerFreedEvent = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'kWorkerFreedEvent'</span>);
+<span class="hljs-keyword">const</span> kTaskInfo = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'kTaskInfo'</span>);
+<span class="hljs-keyword">const</span> kWorkerFreedEvent = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'kWorkerFreedEvent'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">WorkerPoolTaskInfo</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">AsyncResource</span> </span>{
-  <span class="hljs-keyword">constructor</span>(callback) {
-    <span class="hljs-built_in">super</span>(<span class="hljs-string">'WorkerPoolTaskInfo'</span>);
-    <span class="hljs-built_in">this</span>.callback = callback;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">WorkerPoolTaskInfo</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">AsyncResource</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">callback</span>) {
+    <span class="hljs-variable language_">super</span>(<span class="hljs-string">'WorkerPoolTaskInfo'</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">callback</span> = callback;
   }
 
-  done(err, result) {
-    <span class="hljs-built_in">this</span>.runInAsyncScope(<span class="hljs-built_in">this</span>.callback, <span class="hljs-literal">null</span>, err, result);
-    <span class="hljs-built_in">this</span>.emitDestroy();  <span class="hljs-comment">// `TaskInfo`s are used only once.</span>
+  <span class="hljs-title function_">done</span>(<span class="hljs-params">err, result</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">runInAsyncScope</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">callback</span>, <span class="hljs-literal">null</span>, err, result);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emitDestroy</span>();  <span class="hljs-comment">// `TaskInfo`s are used only once.</span>
   }
 }
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">WorkerPool</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">EventEmitter</span> </span>{
-  <span class="hljs-keyword">constructor</span>(numThreads) {
-    <span class="hljs-built_in">super</span>();
-    <span class="hljs-built_in">this</span>.numThreads = numThreads;
-    <span class="hljs-built_in">this</span>.workers = [];
-    <span class="hljs-built_in">this</span>.freeWorkers = [];
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">WorkerPool</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">numThreads</span>) {
+    <span class="hljs-variable language_">super</span>();
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">numThreads</span> = numThreads;
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span> = [];
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span> = [];
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">tasks</span> = [];
 
     <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; numThreads; i++)
-      <span class="hljs-built_in">this</span>.addNewWorker();
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">addNewWorker</span>();
+
+    <span class="hljs-comment">// Any time the kWorkerFreedEvent is emitted, dispatch</span>
+    <span class="hljs-comment">// the next task pending in the queue, if any.</span>
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">on</span>(kWorkerFreedEvent, <span class="hljs-function">() =></span> {
+      <span class="hljs-keyword">if</span> (<span class="hljs-variable language_">this</span>.<span class="hljs-property">tasks</span>.<span class="hljs-property">length</span> > <span class="hljs-number">0</span>) {
+        <span class="hljs-keyword">const</span> { task, callback } = <span class="hljs-variable language_">this</span>.<span class="hljs-property">tasks</span>.<span class="hljs-title function_">shift</span>();
+        <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">runTask</span>(task, callback);
+      }
+    });
   }
 
-  addNewWorker() {
-    <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(path.resolve(__dirname, <span class="hljs-string">'task_processor.js'</span>));
-    worker.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+  <span class="hljs-title function_">addNewWorker</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(path.<span class="hljs-title function_">resolve</span>(__dirname, <span class="hljs-string">'task_processor.js'</span>));
+    worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
       <span class="hljs-comment">// In case of success: Call the callback that was passed to `runTask`,</span>
       <span class="hljs-comment">// remove the `TaskInfo` associated with the Worker, and mark it as free</span>
       <span class="hljs-comment">// again.</span>
-      worker[kTaskInfo].done(<span class="hljs-literal">null</span>, result);
+      worker[kTaskInfo].<span class="hljs-title function_">done</span>(<span class="hljs-literal">null</span>, result);
       worker[kTaskInfo] = <span class="hljs-literal">null</span>;
-      <span class="hljs-built_in">this</span>.freeWorkers.push(worker);
-      <span class="hljs-built_in">this</span>.emit(kWorkerFreedEvent);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span>.<span class="hljs-title function_">push</span>(worker);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(kWorkerFreedEvent);
     });
-    worker.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
       <span class="hljs-comment">// In case of an uncaught exception: Call the callback that was passed to</span>
       <span class="hljs-comment">// `runTask` with the error.</span>
       <span class="hljs-keyword">if</span> (worker[kTaskInfo])
-        worker[kTaskInfo].done(err, <span class="hljs-literal">null</span>);
+        worker[kTaskInfo].<span class="hljs-title function_">done</span>(err, <span class="hljs-literal">null</span>);
       <span class="hljs-keyword">else</span>
-        <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'error'</span>, err);
+        <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, err);
       <span class="hljs-comment">// Remove the worker from the list and start a new Worker to replace the</span>
       <span class="hljs-comment">// current one.</span>
-      <span class="hljs-built_in">this</span>.workers.splice(<span class="hljs-built_in">this</span>.workers.indexOf(worker), <span class="hljs-number">1</span>);
-      <span class="hljs-built_in">this</span>.addNewWorker();
+      <span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span>.<span class="hljs-title function_">splice</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span>.<span class="hljs-title function_">indexOf</span>(worker), <span class="hljs-number">1</span>);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">addNewWorker</span>();
     });
-    <span class="hljs-built_in">this</span>.workers.push(worker);
-    <span class="hljs-built_in">this</span>.freeWorkers.push(worker);
-    <span class="hljs-built_in">this</span>.emit(kWorkerFreedEvent);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span>.<span class="hljs-title function_">push</span>(worker);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span>.<span class="hljs-title function_">push</span>(worker);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(kWorkerFreedEvent);
   }
 
-  runTask(task, callback) {
-    <span class="hljs-keyword">if</span> (<span class="hljs-built_in">this</span>.freeWorkers.length === <span class="hljs-number">0</span>) {
+  <span class="hljs-title function_">runTask</span>(<span class="hljs-params">task, callback</span>) {
+    <span class="hljs-keyword">if</span> (<span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span>.<span class="hljs-property">length</span> === <span class="hljs-number">0</span>) {
       <span class="hljs-comment">// No free threads, wait until a worker thread becomes free.</span>
-      <span class="hljs-built_in">this</span>.once(kWorkerFreedEvent, <span class="hljs-function">() =></span> <span class="hljs-built_in">this</span>.runTask(task, callback));
+      <span class="hljs-variable language_">this</span>.<span class="hljs-property">tasks</span>.<span class="hljs-title function_">push</span>({ task, callback });
       <span class="hljs-keyword">return</span>;
     }
 
-    <span class="hljs-keyword">const</span> worker = <span class="hljs-built_in">this</span>.freeWorkers.pop();
-    worker[kTaskInfo] = <span class="hljs-keyword">new</span> WorkerPoolTaskInfo(callback);
-    worker.postMessage(task);
+    <span class="hljs-keyword">const</span> worker = <span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span>.<span class="hljs-title function_">pop</span>();
+    worker[kTaskInfo] = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WorkerPoolTaskInfo</span>(callback);
+    worker.<span class="hljs-title function_">postMessage</span>(task);
   }
 
-  close() {
-    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> worker <span class="hljs-keyword">of</span> <span class="hljs-built_in">this</span>.workers) worker.terminate();
+  <span class="hljs-title function_">close</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> worker <span class="hljs-keyword">of</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span>) worker.<span class="hljs-title function_">terminate</span>();
   }
 }
 
-<span class="hljs-built_in">module</span>.exports = WorkerPool;</code></pre>
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-title class_">WorkerPool</span>;</code></pre>
 <p>Without the explicit tracking added by the <code>WorkerPoolTaskInfo</code> objects,
 it would appear that the callbacks are associated with the individual <code>Worker</code>
 objects. However, the creation of the <code>Worker</code>s is not associated with the
 creation of the tasks and does not provide information about when tasks
 were scheduled.</p>
 <p>This pool could be used as follows:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> WorkerPool = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./worker_pool.js'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">WorkerPool</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./worker_pool.js'</span>);
 <span class="hljs-keyword">const</span> os = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>);
 
-<span class="hljs-keyword">const</span> pool = <span class="hljs-keyword">new</span> WorkerPool(os.cpus().length);
+<span class="hljs-keyword">const</span> pool = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WorkerPool</span>(os.<span class="hljs-title function_">cpus</span>().<span class="hljs-property">length</span>);
 
 <span class="hljs-keyword">let</span> finished = <span class="hljs-number">0</span>;
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">10</span>; i++) {
-  pool.runTask({ <span class="hljs-attr">a</span>: <span class="hljs-number">42</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">100</span> }, <span class="hljs-function">(<span class="hljs-params">err, result</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(i, err, result);
+  pool.<span class="hljs-title function_">runTask</span>({ <span class="hljs-attr">a</span>: <span class="hljs-number">42</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">100</span> }, <span class="hljs-function">(<span class="hljs-params">err, result</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(i, err, result);
     <span class="hljs-keyword">if</span> (++finished === <span class="hljs-number">10</span>)
-      pool.close();
+      pool.<span class="hljs-title function_">close</span>();
   });
 }</code></pre>
-<h3>Integrating <code>AsyncResource</code> with <code>EventEmitter</code><span><a class="mark" href="#async_hooks_integrating_asyncresource_with_eventemitter" id="async_hooks_integrating_asyncresource_with_eventemitter">#</a></span></h3>
+<h4>Integrating <code>AsyncResource</code> with <code>EventEmitter</code><span><a class="mark" href="#async_hooks_integrating_asyncresource_with_eventemitter" id="async_hooks_integrating_asyncresource_with_eventemitter">#</a></span></h4>
 <p>Event listeners triggered by an <a href="#events_class_eventemitter"><code>EventEmitter</code></a> may be run in a different
 execution context than the one that was active when <code>eventEmitter.on()</code> was
 called.</p>
@@ -6234,52 +6608,56 @@ called.</p>
 associate an event listener with the correct execution context. The same
 approach can be applied to a <a href="#stream_stream"><code>Stream</code></a> or a similar event-driven class.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { createServer } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> { AsyncResource, executionAsyncId } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">AsyncResource</span>, executionAsyncId } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-keyword">const</span> server = createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  req.on(<span class="hljs-string">'close'</span>, AsyncResource.bind(<span class="hljs-function">() =></span> {
+<span class="hljs-keyword">const</span> server = <span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-title class_">AsyncResource</span>.<span class="hljs-title function_">bind</span>(<span class="hljs-function">() =></span> {
     <span class="hljs-comment">// Execution context is bound to the current outer scope.</span>
   }));
-  req.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> {
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-comment">// Execution context is bound to the scope that caused 'close' to emit.</span>
   });
-  res.end();
-}).listen(<span class="hljs-number">3000</span>);</code></pre>
-<h2>Class: <code>AsyncLocalStorage</code><span><a class="mark" href="#async_hooks_class_asynclocalstorage" id="async_hooks_class_asynclocalstorage">#</a></span></h2>
+  res.<span class="hljs-title function_">end</span>();
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);</code></pre>
+</section><section><h3>Class: <code>AsyncLocalStorage</code><span><a class="mark" href="#async_hooks_class_asynclocalstorage" id="async_hooks_class_asynclocalstorage">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <p>This class is used to create asynchronous state within callbacks and promise
 chains. It allows storing data throughout the lifetime of a web request
 or any other asynchronous duration. It is similar to thread-local storage
 in other languages.</p>
+<p>While you can create your own implementation on top of the <code>async_hooks</code> module,
+<code>AsyncLocalStorage</code> should be preferred as it is a performant and memory safe
+implementation that involves significant optimizations that are non-obvious to
+implement.</p>
 <p>The following example uses <code>AsyncLocalStorage</code> to build a simple logger
 that assigns IDs to incoming HTTP requests and includes them in messages
 logged within each request.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> { AsyncLocalStorage } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">AsyncLocalStorage</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-keyword">const</span> asyncLocalStorage = <span class="hljs-keyword">new</span> AsyncLocalStorage();
+<span class="hljs-keyword">const</span> asyncLocalStorage = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AsyncLocalStorage</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">logWithId</span>(<span class="hljs-params">msg</span>) </span>{
-  <span class="hljs-keyword">const</span> id = asyncLocalStorage.getStore();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${id !== <span class="hljs-literal">undefined</span> ? id : <span class="hljs-string">'-'</span>}</span>:`</span>, msg);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">logWithId</span>(<span class="hljs-params">msg</span>) {
+  <span class="hljs-keyword">const</span> id = asyncLocalStorage.<span class="hljs-title function_">getStore</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${id !== <span class="hljs-literal">undefined</span> ? id : <span class="hljs-string">'-'</span>}</span>:`</span>, msg);
 }
 
 <span class="hljs-keyword">let</span> idSeq = <span class="hljs-number">0</span>;
-http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  asyncLocalStorage.run(idSeq++, <span class="hljs-function">() =></span> {
-    logWithId(<span class="hljs-string">'start'</span>);
+http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  asyncLocalStorage.<span class="hljs-title function_">run</span>(idSeq++, <span class="hljs-function">() =></span> {
+    <span class="hljs-title function_">logWithId</span>(<span class="hljs-string">'start'</span>);
     <span class="hljs-comment">// Imagine any chain of async operations here</span>
-    setImmediate(<span class="hljs-function">() =></span> {
-      logWithId(<span class="hljs-string">'finish'</span>);
-      res.end();
+    <span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> {
+      <span class="hljs-title function_">logWithId</span>(<span class="hljs-string">'finish'</span>);
+      res.<span class="hljs-title function_">end</span>();
     });
   });
-}).listen(<span class="hljs-number">8080</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8080</span>);
 
-http.get(<span class="hljs-string">'http://localhost:8080'</span>);
-http.get(<span class="hljs-string">'http://localhost:8080'</span>);
+http.<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:8080'</span>);
+http.<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:8080'</span>);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   0: start</span>
 <span class="hljs-comment">//   1: start</span>
@@ -6287,139 +6665,144 @@ http.get(<span class="hljs-string">'http://localhost:8080'</span>);
 <span class="hljs-comment">//   1: finish</span></code></pre>
 <p>When having multiple instances of <code>AsyncLocalStorage</code>, they are independent
 from each other. It is safe to instantiate this class multiple times.</p>
-<h3><code>new AsyncLocalStorage()</code><span><a class="mark" href="#async_hooks_new_asynclocalstorage" id="async_hooks_new_asynclocalstorage">#</a></span></h3>
+<h4><code>new AsyncLocalStorage()</code><span><a class="mark" href="#async_hooks_new_asynclocalstorage" id="async_hooks_new_asynclocalstorage">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <p>Creates a new instance of <code>AsyncLocalStorage</code>. Store is only provided within a
-<code>run</code> method call.</p>
-<h3><code>asyncLocalStorage.disable()</code><span><a class="mark" href="#async_hooks_asynclocalstorage_disable" id="async_hooks_asynclocalstorage_disable">#</a></span></h3>
+<code>run()</code> call or after an <code>enterWith()</code> call.</p>
+<h4><code>asyncLocalStorage.disable()</code><span><a class="mark" href="#async_hooks_asynclocalstorage_disable" id="async_hooks_asynclocalstorage_disable">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
-<p>This method disables the instance of <code>AsyncLocalStorage</code>. All subsequent calls
+<p>Disables the instance of <code>AsyncLocalStorage</code>. All subsequent calls
 to <code>asyncLocalStorage.getStore()</code> will return <code>undefined</code> until
-<code>asyncLocalStorage.run()</code> is called again.</p>
+<code>asyncLocalStorage.run()</code> or <code>asyncLocalStorage.enterWith()</code> is called again.</p>
 <p>When calling <code>asyncLocalStorage.disable()</code>, all current contexts linked to the
 instance will be exited.</p>
 <p>Calling <code>asyncLocalStorage.disable()</code> is required before the
 <code>asyncLocalStorage</code> can be garbage collected. This does not apply to stores
 provided by the <code>asyncLocalStorage</code>, as those objects are garbage collected
 along with the corresponding async resources.</p>
-<p>This method is to be used when the <code>asyncLocalStorage</code> is not in use anymore
+<p>Use this method when the <code>asyncLocalStorage</code> is not in use anymore
 in the current process.</p>
-<h3><code>asyncLocalStorage.getStore()</code><span><a class="mark" href="#async_hooks_asynclocalstorage_getstore" id="async_hooks_asynclocalstorage_getstore">#</a></span></h3>
+<h4><code>asyncLocalStorage.getStore()</code><span><a class="mark" href="#async_hooks_asynclocalstorage_getstore" id="async_hooks_asynclocalstorage_getstore">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
-<p>This method returns the current store.
-If this method is called outside of an asynchronous context initialized by
-calling <code>asyncLocalStorage.run</code>, it will return <code>undefined</code>.</p>
-<h3><code>asyncLocalStorage.enterWith(store)</code><span><a class="mark" href="#async_hooks_asynclocalstorage_enterwith_store" id="async_hooks_asynclocalstorage_enterwith_store">#</a></span></h3>
+<p>Returns the current store.
+If called outside of an asynchronous context initialized by
+calling <code>asyncLocalStorage.run()</code> or <code>asyncLocalStorage.enterWith()</code>, it
+returns <code>undefined</code>.</p>
+<h4><code>asyncLocalStorage.enterWith(store)</code><span><a class="mark" href="#async_hooks_asynclocalstorage_enterwith_store" id="async_hooks_asynclocalstorage_enterwith_store">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.11.0</span>
 </div>
 <ul>
 <li><code>store</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
-<p>Calling <code>asyncLocalStorage.enterWith(store)</code> will transition into the context
-for the remainder of the current synchronous execution and will persist
-through any following asynchronous calls.</p>
+<p>Transitions into the context for the remainder of the current
+synchronous execution and then persists the store through any following
+asynchronous calls.</p>
 <p>Example:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> store = { <span class="hljs-attr">id</span>: <span class="hljs-number">1</span> };
-asyncLocalStorage.enterWith(store);
-asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the store object</span>
-someAsyncOperation(<span class="hljs-function">() =></span> {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the same object</span>
+<span class="hljs-comment">// Replaces previous store with the given store object</span>
+asyncLocalStorage.<span class="hljs-title function_">enterWith</span>(store);
+asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the store object</span>
+<span class="hljs-title function_">someAsyncOperation</span>(<span class="hljs-function">() =></span> {
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the same object</span>
 });</code></pre>
 <p>This transition will continue for the <em>entire</em> synchronous execution.
 This means that if, for example, the context is entered within an event
 handler subsequent event handlers will also run within that context unless
-specifically bound to another context with an <code>AsyncResource</code>.</p>
+specifically bound to another context with an <code>AsyncResource</code>. That is why
+<code>run()</code> should be preferred over <code>enterWith()</code> unless there are strong reasons
+to use the latter method.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> store = { <span class="hljs-attr">id</span>: <span class="hljs-number">1</span> };
 
-emitter.on(<span class="hljs-string">'my-event'</span>, <span class="hljs-function">() =></span> {
-  asyncLocalStorage.enterWith(store);
+emitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'my-event'</span>, <span class="hljs-function">() =></span> {
+  asyncLocalStorage.<span class="hljs-title function_">enterWith</span>(store);
 });
-emitter.on(<span class="hljs-string">'my-event'</span>, <span class="hljs-function">() =></span> {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the same object</span>
+emitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'my-event'</span>, <span class="hljs-function">() =></span> {
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the same object</span>
 });
 
-asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns undefined</span>
-emitter.emit(<span class="hljs-string">'my-event'</span>);
-asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the same object</span></code></pre>
-<h3><code>asyncLocalStorage.run(store, callback[, ...args])</code><span><a class="mark" href="#async_hooks_asynclocalstorage_run_store_callback_args" id="async_hooks_asynclocalstorage_run_store_callback_args">#</a></span></h3>
+asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns undefined</span>
+emitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'my-event'</span>);
+asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the same object</span></code></pre>
+<h4><code>asyncLocalStorage.run(store, callback[, ...args])</code><span><a class="mark" href="#async_hooks_asynclocalstorage_run_store_callback_args" id="async_hooks_asynclocalstorage_run_store_callback_args">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <ul>
 <li><code>store</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
-<p>This methods runs a function synchronously within a context and return its
-return value. The store is not accessible outside of the callback function or
-the asynchronous operations created within the callback.</p>
-<p>Optionally, arguments can be passed to the function. They will be passed to
-the callback function.</p>
-<p>If the callback function throws an error, it will be thrown by <code>run</code> too.
-The stacktrace will not be impacted by this call and the context will
-be exited.</p>
+<p>Runs a function synchronously within a context and returns its
+return value. The store is not accessible outside of the callback function.
+The store is accessible to any asynchronous operations created within the
+callback.</p>
+<p>The optional <code>args</code> are passed to the callback function.</p>
+<p>If the callback function throws an error, the error is thrown by <code>run()</code> too.
+The stacktrace is not impacted by this call and the context is exited.</p>
 <p>Example:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> store = { <span class="hljs-attr">id</span>: <span class="hljs-number">2</span> };
 <span class="hljs-keyword">try</span> {
-  asyncLocalStorage.run(store, <span class="hljs-function">() =></span> {
-    asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the store object</span>
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>();
+  asyncLocalStorage.<span class="hljs-title function_">run</span>(store, <span class="hljs-function">() =></span> {
+    asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the store object</span>
+    <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
+      asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the store object</span>
+    }, <span class="hljs-number">200</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>();
   });
 } <span class="hljs-keyword">catch</span> (e) {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns undefined</span>
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns undefined</span>
   <span class="hljs-comment">// The error will be caught here</span>
 }</code></pre>
-<h3><code>asyncLocalStorage.exit(callback[, ...args])</code><span><a class="mark" href="#async_hooks_asynclocalstorage_exit_callback_args" id="async_hooks_asynclocalstorage_exit_callback_args">#</a></span></h3>
+<h4><code>asyncLocalStorage.exit(callback[, ...args])</code><span><a class="mark" href="#async_hooks_asynclocalstorage_exit_callback_args" id="async_hooks_asynclocalstorage_exit_callback_args">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
-<p>This methods runs a function synchronously outside of a context and return its
+<p>Runs a function synchronously outside of a context and returns its
 return value. The store is not accessible within the callback function or
-the asynchronous operations created within the callback.</p>
-<p>Optionally, arguments can be passed to the function. They will be passed to
-the callback function.</p>
-<p>If the callback function throws an error, it will be thrown by <code>exit</code> too.
-The stacktrace will not be impacted by this call and
-the context will be re-entered.</p>
+the asynchronous operations created within the callback. Any <code>getStore()</code>
+call done within the callback function will always return <code>undefined</code>.</p>
+<p>The optional <code>args</code> are passed to the callback function.</p>
+<p>If the callback function throws an error, the error is thrown by <code>exit()</code> too.
+The stacktrace is not impacted by this call and the context is re-entered.</p>
 <p>Example:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Within a call to run</span>
 <span class="hljs-keyword">try</span> {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the store object or value</span>
-  asyncLocalStorage.exit(<span class="hljs-function">() =></span> {
-    asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns undefined</span>
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>();
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the store object or value</span>
+  asyncLocalStorage.<span class="hljs-title function_">exit</span>(<span class="hljs-function">() =></span> {
+    asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns undefined</span>
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>();
   });
 } <span class="hljs-keyword">catch</span> (e) {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the same object or value</span>
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the same object or value</span>
   <span class="hljs-comment">// The error will be caught here</span>
 }</code></pre>
-<h3>Usage with <code>async/await</code><span><a class="mark" href="#async_hooks_usage_with_async_await" id="async_hooks_usage_with_async_await">#</a></span></h3>
+<h4>Usage with <code>async/await</code><span><a class="mark" href="#async_hooks_usage_with_async_await" id="async_hooks_usage_with_async_await">#</a></span></h4>
 <p>If, within an async function, only one <code>await</code> call is to run within a context,
 the following pattern should be used:</p>
-<pre><code class="language-js"><span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">fn</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> asyncLocalStorage.run(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>(), <span class="hljs-function">() =></span> {
-    asyncLocalStorage.getStore().set(<span class="hljs-string">'key'</span>, value);
-    <span class="hljs-keyword">return</span> foo(); <span class="hljs-comment">// The return value of foo will be awaited</span>
+<pre><code class="language-js"><span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">fn</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> asyncLocalStorage.<span class="hljs-title function_">run</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>(), <span class="hljs-function">() =></span> {
+    asyncLocalStorage.<span class="hljs-title function_">getStore</span>().<span class="hljs-title function_">set</span>(<span class="hljs-string">'key'</span>, value);
+    <span class="hljs-keyword">return</span> <span class="hljs-title function_">foo</span>(); <span class="hljs-comment">// The return value of foo will be awaited</span>
   });
 }</code></pre>
 <p>In this example, the store is only available in the callback function and the
 functions called by <code>foo</code>. Outside of <code>run</code>, calling <code>getStore</code> will return
 <code>undefined</code>.</p>
-<h3>Troubleshooting<span><a class="mark" href="#async_hooks_troubleshooting" id="async_hooks_troubleshooting">#</a></span></h3>
+<h4>Troubleshooting<span><a class="mark" href="#async_hooks_troubleshooting" id="async_hooks_troubleshooting">#</a></span></h4>
 <p>In most cases your application or library code should have no issues with
 <code>AsyncLocalStorage</code>. But in rare cases you may face situations when the
 current store is lost in one of asynchronous operations. In those cases,
@@ -6428,11 +6811,12 @@ consider the following options.</p>
 <a href="#util_util_promisify_original"><code>util.promisify()</code></a>, so it starts working with native promises.</p>
 <p>If you need to keep using callback-based API, or your code assumes
 a custom thenable implementation, use the <a href="#async_hooks_class_asyncresource"><code>AsyncResource</code></a> class
-to associate the asynchronous operation with the correct execution context.</p>
-<h1>Buffer<span><a class="mark" href="#buffer_buffer" id="buffer_buffer">#</a></span></h1>
+to associate the asynchronous operation with the correct execution context.</p></section>
+        </section>
+<section><h2>Buffer<span><a class="mark" href="#buffer_buffer" id="buffer_buffer">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/buffer.js">lib/buffer.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/buffer.js">lib/buffer.js</a></p>
 <p><code>Buffer</code> objects are used to represent a fixed-length sequence of bytes. Many
 Node.js APIs support <code>Buffer</code>s.</p>
 <p>The <code>Buffer</code> class is a subclass of JavaScript's <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> class and
@@ -6441,38 +6825,40 @@ plain <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference
 <p>The <code>Buffer</code> class is within the global scope, making it unlikely that one
 would need to ever use <code>require('buffer').Buffer</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Creates a zero-filled Buffer of length 10.</span>
-<span class="hljs-keyword">const</span> buf1 = Buffer.alloc(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
 
 <span class="hljs-comment">// Creates a Buffer of length 10,</span>
 <span class="hljs-comment">// filled with bytes which all have the value `1`.</span>
-<span class="hljs-keyword">const</span> buf2 = Buffer.alloc(<span class="hljs-number">10</span>, <span class="hljs-number">1</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>, <span class="hljs-number">1</span>);
 
 <span class="hljs-comment">// Creates an uninitialized buffer of length 10.</span>
 <span class="hljs-comment">// This is faster than calling Buffer.alloc() but the returned</span>
 <span class="hljs-comment">// Buffer instance might contain old data that needs to be</span>
 <span class="hljs-comment">// overwritten using fill(), write(), or other functions that fill the Buffer's</span>
 <span class="hljs-comment">// contents.</span>
-<span class="hljs-keyword">const</span> buf3 = Buffer.allocUnsafe(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buf3 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">10</span>);
 
 <span class="hljs-comment">// Creates a Buffer containing the bytes [1, 2, 3].</span>
-<span class="hljs-keyword">const</span> buf4 = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
+<span class="hljs-keyword">const</span> buf4 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
 
 <span class="hljs-comment">// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries</span>
 <span class="hljs-comment">// are all truncated using `(value &#x26; 255)` to fit into the range 0–255.</span>
-<span class="hljs-keyword">const</span> buf5 = Buffer.from([<span class="hljs-number">257</span>, <span class="hljs-number">257.5</span>, <span class="hljs-number">-255</span>, <span class="hljs-string">'1'</span>]);
+<span class="hljs-keyword">const</span> buf5 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">257</span>, <span class="hljs-number">257.5</span>, -<span class="hljs-number">255</span>, <span class="hljs-string">'1'</span>]);
 
 <span class="hljs-comment">// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':</span>
 <span class="hljs-comment">// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)</span>
 <span class="hljs-comment">// [116, 195, 169, 115, 116] (in decimal notation)</span>
-<span class="hljs-keyword">const</span> buf6 = Buffer.from(<span class="hljs-string">'tést'</span>);
+<span class="hljs-keyword">const</span> buf6 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'tést'</span>);
 
 <span class="hljs-comment">// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].</span>
-<span class="hljs-keyword">const</span> buf7 = Buffer.from(<span class="hljs-string">'tést'</span>, <span class="hljs-string">'latin1'</span>);</code></pre>
-<h2>Buffers and character encodings<span><a class="mark" href="#buffer_buffers_and_character_encodings" id="buffer_buffers_and_character_encodings">#</a></span></h2>
+<span class="hljs-keyword">const</span> buf7 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'tést'</span>, <span class="hljs-string">'latin1'</span>);</code></pre>
+<section><h3>Buffers and character encodings<span><a class="mark" href="#buffer_buffers_and_character_encodings" id="buffer_buffers_and_character_encodings">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Introduced <code>base64url</code> encoding.</p></td></tr>
 <tr><td>v6.4.0</td>
 <td><p>Introduced <code>latin1</code> as an alias for <code>binary</code>.</p></td></tr>
 <tr><td>v5.0.0</td>
@@ -6483,16 +6869,16 @@ would need to ever use <code>require('buffer').Buffer</code>.</p>
 <p>When converting between <code>Buffer</code>s and strings, a character encoding may be
 specified. If no character encoding is specified, UTF-8 will be used as the
 default.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'hello world'</span>, <span class="hljs-string">'utf8'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'hello world'</span>, <span class="hljs-string">'utf8'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: 68656c6c6f20776f726c64</span>
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'base64'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'base64'</span>));
 <span class="hljs-comment">// Prints: aGVsbG8gd29ybGQ=</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.from(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf8'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer 66 68 71 77 68 67 61 64 73></span>
-<span class="hljs-built_in">console</span>.log(Buffer.from(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00></span></code></pre>
 <p>The character encodings currently supported by Node.js are the following:</p>
 <ul>
@@ -6517,7 +6903,7 @@ truncated and will be mapped to characters in that range.</p>
 </ul>
 <p>Converting a <code>Buffer</code> into a string using one of the above is referred to as
 decoding, and converting a string into a <code>Buffer</code> is referred to as encoding.</p>
-<p>Node.js also supports the following two binary-to-text encodings. For
+<p>Node.js also supports the following binary-to-text encodings. For
 binary-to-text encodings, the naming convention is reversed: Converting a
 <code>Buffer</code> into a string is typically referred to as encoding, and converting a
 string into a <code>Buffer</code> as decoding.</p>
@@ -6529,6 +6915,12 @@ specified in <a href="https://tools.ietf.org/html/rfc4648#section-5">RFC 4648, S
 tabs, and new lines contained within the base64-encoded string are ignored.</p>
 </li>
 <li>
+<p><code>'base64url'</code>: <a href="https://tools.ietf.org/html/rfc4648#section-5">base64url</a> encoding as specified in
+<a href="https://tools.ietf.org/html/rfc4648#section-5">RFC 4648, Section 5</a>. When creating a <code>Buffer</code> from a string, this
+encoding will also correctly accept regular base64-encoded strings. When
+encoding a <code>Buffer</code> to a string, this encoding will omit padding.</p>
+</li>
+<li>
 <p><code>'hex'</code>: Encode each byte as two hexadecimal characters. Data truncation
 may occur when decoding strings that do exclusively contain valid hexadecimal
 characters. See below for an example.</p>
@@ -6558,14 +6950,14 @@ that did not support characters that had code points larger than U+FFFF.
 In Node.js, these code points are always supported.</p>
 </li>
 </ul>
-<pre><code class="language-js">Buffer.from(<span class="hljs-string">'1ag'</span>, <span class="hljs-string">'hex'</span>);
+<pre><code class="language-js"><span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'1ag'</span>, <span class="hljs-string">'hex'</span>);
 <span class="hljs-comment">// Prints &#x3C;Buffer 1a>, data truncated when first non-hexadecimal value</span>
 <span class="hljs-comment">// ('g') encountered.</span>
 
-Buffer.from(<span class="hljs-string">'1a7g'</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'1a7g'</span>, <span class="hljs-string">'hex'</span>);
 <span class="hljs-comment">// Prints &#x3C;Buffer 1a>, data truncated when data ends in single digit ('7').</span>
 
-Buffer.from(<span class="hljs-string">'1634'</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'1634'</span>, <span class="hljs-string">'hex'</span>);
 <span class="hljs-comment">// Prints &#x3C;Buffer 16 34>, all data represented.</span></code></pre>
 <p>Modern Web browsers follow the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a> which aliases
 both <code>'latin1'</code> and <code>'ISO-8859-1'</code> to <code>'win-1252'</code>. This means that while doing
@@ -6573,7 +6965,7 @@ something like <code>http.get()</code>, if the returned charset is one of those
 the WHATWG specification it is possible that the server actually returned
 <code>'win-1252'</code>-encoded data, and using <code>'latin1'</code> encoding may incorrectly decode
 the characters.</p>
-<h2>Buffers and TypedArrays<span><a class="mark" href="#buffer_buffers_and_typedarrays" id="buffer_buffers_and_typedarrays">#</a></span></h2>
+</section><section><h3>Buffers and TypedArrays<span><a class="mark" href="#buffer_buffers_and_typedarrays" id="buffer_buffers_and_typedarrays">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -6589,12 +6981,12 @@ however, subtle incompatibilities between the <code>Buffer</code> API and the
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> API.</p>
 <p>In particular:</p>
 <ul>
-<li>While <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice"><code>TypedArray#slice()</code></a> creates a copy of part of the <code>TypedArray</code>,
-<a href="#buffer_buf_slice_start_end"><code>Buffer#slice()</code></a> creates a view over the existing <code>Buffer</code>
+<li>While <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice"><code>TypedArray.prototype.slice()</code></a> creates a copy of part of the <code>TypedArray</code>,
+<a href="#buffer_buf_slice_start_end"><code>Buffer.prototype.slice()</code></a> creates a view over the existing <code>Buffer</code>
 without copying. This behavior can be surprising, and only exists for legacy
-compatibility. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray#subarray()</code></a> can be used to achieve the behavior
-of <a href="#buffer_buf_slice_start_end"><code>Buffer#slice()</code></a> on both <code>Buffer</code>s and other
-<code>TypedArray</code>s.</li>
+compatibility. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray.prototype.subarray()</code></a> can be used to achieve
+the behavior of <a href="#buffer_buf_slice_start_end"><code>Buffer.prototype.slice()</code></a> on both <code>Buffer</code>s
+and other <code>TypedArray</code>s.</li>
 <li><a href="#buffer_buf_tostring_encoding_start_end"><code>buf.toString()</code></a> is incompatible with its <code>TypedArray</code> equivalent.</li>
 <li>A number of methods, e.g. <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf()</code></a>, support additional arguments.</li>
 </ul>
@@ -6604,58 +6996,58 @@ of <a href="#buffer_buf_slice_start_end"><code>Buffer#slice()</code></a> on both
 contents, interpreted as an array of integers, and not as a byte sequence
 of the target type.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
-<span class="hljs-keyword">const</span> uint32array = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>(buf);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
+<span class="hljs-keyword">const</span> uint32array = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>32<span class="hljs-built_in">Array</span>(buf);
 
-<span class="hljs-built_in">console</span>.log(uint32array);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(uint32array);
 
 <span class="hljs-comment">// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]</span></code></pre>
 <ul>
 <li>Passing the <code>Buffer</code>s underlying <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> will create a
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> that shares its memory with the <code>Buffer</code>.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'hello'</span>, <span class="hljs-string">'utf16le'</span>);
-<span class="hljs-keyword">const</span> uint16arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(
-  buf.buffer,
-  buf.byteOffset,
-  buf.length / <span class="hljs-built_in">Uint16Array</span>.BYTES_PER_ELEMENT);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'hello'</span>, <span class="hljs-string">'utf16le'</span>);
+<span class="hljs-keyword">const</span> uint16array = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(
+  buf.<span class="hljs-property">buffer</span>,
+  buf.<span class="hljs-property">byteOffset</span>,
+  buf.<span class="hljs-property">length</span> / <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>.<span class="hljs-property">BYTES_PER_ELEMENT</span>);
 
-<span class="hljs-built_in">console</span>.log(uint16array);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(uint16array);
 
 <span class="hljs-comment">// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]</span></code></pre>
 <p>It is possible to create a new <code>Buffer</code> that shares the same allocated
 memory as a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instance by using the <code>TypedArray</code> object’s
 <code>.buffer</code> property in the same way. <a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from()</code></a>
 behaves like <code>new Uint8Array()</code> in this context.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(<span class="hljs-number">2</span>);
 
 arr[<span class="hljs-number">0</span>] = <span class="hljs-number">5000</span>;
 arr[<span class="hljs-number">1</span>] = <span class="hljs-number">4000</span>;
 
 <span class="hljs-comment">// Copies the contents of `arr`.</span>
-<span class="hljs-keyword">const</span> buf1 = Buffer.from(arr);
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arr);
 
 <span class="hljs-comment">// Shares memory with `arr`.</span>
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(arr.buffer);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arr.<span class="hljs-property">buffer</span>);
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 a0></span>
-<span class="hljs-built_in">console</span>.log(buf2);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 13 a0 0f></span>
 
 arr[<span class="hljs-number">1</span>] = <span class="hljs-number">6000</span>;
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 a0></span>
-<span class="hljs-built_in">console</span>.log(buf2);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 13 70 17></span></code></pre>
 <p>When creating a <code>Buffer</code> using a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>'s <code>.buffer</code>, it is
 possible to use only a portion of the underlying <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> by passing in
 <code>byteOffset</code> and <code>length</code> parameters.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">20</span>);
-<span class="hljs-keyword">const</span> buf = Buffer.from(arr.buffer, <span class="hljs-number">0</span>, <span class="hljs-number">16</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(<span class="hljs-number">20</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arr.<span class="hljs-property">buffer</span>, <span class="hljs-number">0</span>, <span class="hljs-number">16</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 16</span></code></pre>
 <p>The <code>Buffer.from()</code> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from"><code>TypedArray.from()</code></a> have different signatures and
 implementations. Specifically, the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> variants accept a second
@@ -6672,12 +7064,12 @@ function:</p>
 <li><a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a></li>
 <li><a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string[, encoding])</code></a></li>
 </ul>
-<h2>Buffers and iteration<span><a class="mark" href="#buffer_buffers_and_iteration" id="buffer_buffers_and_iteration">#</a></span></h2>
+</section><section><h3>Buffers and iteration<span><a class="mark" href="#buffer_buffers_and_iteration" id="buffer_buffers_and_iteration">#</a></span></h3>
 <p><code>Buffer</code> instances can be iterated over using <code>for..of</code> syntax:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> b <span class="hljs-keyword">of</span> buf) {
-  <span class="hljs-built_in">console</span>.log(b);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   1</span>
@@ -6685,10 +7077,109 @@ function:</p>
 <span class="hljs-comment">//   3</span></code></pre>
 <p>Additionally, the <a href="#buffer_buf_values"><code>buf.values()</code></a>, <a href="#buffer_buf_keys"><code>buf.keys()</code></a>, and
 <a href="#buffer_buf_entries"><code>buf.entries()</code></a> methods can be used to create iterators.</p>
-<h2>Class: <code>Buffer</code><span><a class="mark" href="#buffer_class_buffer" id="buffer_class_buffer">#</a></span></h2>
+</section><section><h3>Class: <code>Blob</code><span><a class="mark" href="#buffer_class_blob" id="buffer_class_blob">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>A <a href="https://developer.mozilla.org/en-US/docs/Web/API/Blob"><code>Blob</code></a> encapsulates immutable, raw data that can be safely shared across
+multiple worker threads.</p>
+<h4><code>new buffer.Blob([sources[, options]])</code><span><a class="mark" href="#buffer_new_buffer_blob_sources_options" id="buffer_new_buffer_blob_sources_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>sources</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a> | <a href="#buffer_class_blob" class="type">&#x3C;Blob[]></a> An array
+of string, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a>, or <a href="#buffer_class_blob" class="type">&#x3C;Blob></a> objects, or
+any mix of such objects, that will be stored within the <code>Blob</code>.</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The character encoding to use for string sources.
+<strong>Default</strong>: <code>'utf8'</code>.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The Blob content-type. The intent is for <code>type</code> to convey
+the MIME media type of the data, however no validation of the type format
+is performed.</li>
+</ul>
+</li>
+</ul>
+<p>Creates a new <code>Blob</code> object containing a concatenation of the given sources.</p>
+<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a>, and <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> sources are copied into
+the 'Blob' and can therefore be safely modified after the 'Blob' is created.</p>
+<p>String sources are also copied into the <code>Blob</code>.</p>
+<h4><code>blob.arrayBuffer()</code><span><a class="mark" href="#buffer_blob_arraybuffer" id="buffer_blob_arraybuffer">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Returns a promise that fulfills with an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> containing a copy of
+the <code>Blob</code> data.</p>
+<h4><code>blob.size</code><span><a class="mark" href="#buffer_blob_size" id="buffer_blob_size">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>The total size of the <code>Blob</code> in bytes.</p>
+<h4><code>blob.slice([start, [end, [type]]])</code><span><a class="mark" href="#buffer_blob_slice_start_end_type" id="buffer_blob_slice_start_end_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The starting index.</li>
+<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The ending index.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The content-type for the new <code>Blob</code></li>
+</ul>
+<p>Creates and returns a new <code>Blob</code> containing a subset of this <code>Blob</code> objects
+data. The original <code>Blob</code> is not alterered.</p>
+<h4><code>blob.text()</code><span><a class="mark" href="#buffer_blob_text" id="buffer_blob_text">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Returns a promise that resolves the contents of the <code>Blob</code> decoded as a UTF-8
+string.</p>
+<h4><code>blob.type</code><span><a class="mark" href="#buffer_blob_type" id="buffer_blob_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>The content-type of the <code>Blob</code>.</p>
+<h4><code>Blob</code> objects and <code>MessageChannel</code><span><a class="mark" href="#buffer_blob_objects_and_messagechannel" id="buffer_blob_objects_and_messagechannel">#</a></span></h4>
+<p>Once a <a href="#buffer_class_blob" class="type">&#x3C;Blob></a> object is created, it can be sent via <code>MessagePort</code> to multiple
+destinations without transfering or immediately copying the data. The data
+contained by the <code>Blob</code> is copied only when the <code>arrayBuffer()</code> or <code>text()</code>
+methods are called.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Blob</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'buffer'</span>);
+<span class="hljs-keyword">const</span> blob = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Blob</span>([<span class="hljs-string">'hello there'</span>]);
+<span class="hljs-keyword">const</span> { <span class="hljs-attr">setTimeout</span>: delay } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'timers/promises'</span>);
+
+<span class="hljs-keyword">const</span> mc1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+<span class="hljs-keyword">const</span> mc2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+
+mc1.<span class="hljs-property">port1</span>.<span class="hljs-property">onmessage</span> = <span class="hljs-keyword">async</span> ({ data }) => {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-keyword">await</span> data.<span class="hljs-title function_">arrayBuffer</span>());
+  mc1.<span class="hljs-property">port1</span>.<span class="hljs-title function_">close</span>();
+};
+
+mc2.<span class="hljs-property">port1</span>.<span class="hljs-property">onmessage</span> = <span class="hljs-keyword">async</span> ({ data }) => {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">delay</span>(<span class="hljs-number">1000</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-keyword">await</span> data.<span class="hljs-title function_">arrayBuffer</span>());
+  mc2.<span class="hljs-property">port1</span>.<span class="hljs-title function_">close</span>();
+};
+
+mc1.<span class="hljs-property">port2</span>.<span class="hljs-title function_">postMessage</span>(blob);
+mc2.<span class="hljs-property">port2</span>.<span class="hljs-title function_">postMessage</span>(blob);
+
+<span class="hljs-comment">// The Blob is still usable after posting.</span>
+data.<span class="hljs-title function_">text</span>().<span class="hljs-title function_">then</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>);</code></pre>
+</section><section><h3>Class: <code>Buffer</code><span><a class="mark" href="#buffer_class_buffer" id="buffer_class_buffer">#</a></span></h3>
 <p>The <code>Buffer</code> class is a global type for dealing with binary data directly.
 It can be constructed in a variety of ways.</p>
-<h3>Static method: <code>Buffer.alloc(size[, fill[, encoding]])</code><span><a class="mark" href="#buffer_static_method_buffer_alloc_size_fill_encoding" id="buffer_static_method_buffer_alloc_size_fill_encoding">#</a></span></h3>
+<h4>Static method: <code>Buffer.alloc(size[, fill[, encoding]])</code><span><a class="mark" href="#buffer_static_method_buffer_alloc_size_fill_encoding" id="buffer_static_method_buffer_alloc_size_fill_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -6713,31 +7204,31 @@ with. <strong>Default:</strong> <code>0</code>.</li>
 </ul>
 <p>Allocates a new <code>Buffer</code> of <code>size</code> bytes. If <code>fill</code> is <code>undefined</code>, the
 <code>Buffer</code> will be zero-filled.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">5</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">5</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 00 00 00 00 00></span></code></pre>
 <p>If <code>size</code> is larger than
 <a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a> or smaller than 0, <a href="#ERR_INVALID_OPT_VALUE"><code>ERR_INVALID_OPT_VALUE</code></a>
 is thrown.</p>
 <p>If <code>fill</code> is specified, the allocated <code>Buffer</code> will be initialized by calling
 <a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(fill)</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">5</span>, <span class="hljs-string">'a'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">5</span>, <span class="hljs-string">'a'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 61 61 61 61 61></span></code></pre>
 <p>If both <code>fill</code> and <code>encoding</code> are specified, the allocated <code>Buffer</code> will be
 initialized by calling <a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(fill, encoding)</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">11</span>, <span class="hljs-string">'aGVsbG8gd29ybGQ='</span>, <span class="hljs-string">'base64'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">11</span>, <span class="hljs-string">'aGVsbG8gd29ybGQ='</span>, <span class="hljs-string">'base64'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64></span></code></pre>
 <p>Calling <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> can be measurably slower than the alternative
 <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> but ensures that the newly created <code>Buffer</code> instance
 contents will never contain sensitive data from previous allocations, including
 data that might not have been allocated for <code>Buffer</code>s.</p>
 <p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
-<h3>Static method: <code>Buffer.allocUnsafe(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafe_size" id="buffer_static_method_buffer_allocunsafe_size">#</a></span></h3>
+<h4>Static method: <code>Buffer.allocUnsafe(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafe_size" id="buffer_static_method_buffer_allocunsafe_size">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -6759,14 +7250,14 @@ is thrown.</p>
 initialized</em>. The contents of the newly created <code>Buffer</code> are unknown and
 <em>may contain sensitive data</em>. Use <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> instead to initialize
 <code>Buffer</code> instances with zeroes.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">10</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">10</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints (contents may vary): &#x3C;Buffer a0 8b 28 3f 01 00 00 00 50 32></span>
 
-buf.fill(<span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">fill</span>(<span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 00 00 00 00 00 00 00 00 00 00></span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
 <p>The <code>Buffer</code> module pre-allocates an internal <code>Buffer</code> instance of
@@ -6782,7 +7273,7 @@ pool, while <code>Buffer.allocUnsafe(size).fill(fill)</code> <em>will</em> use t
 <code>Buffer</code> pool if <code>size</code> is less than or equal to half <a href="#buffer_class_property_buffer_poolsize"><code>Buffer.poolSize</code></a>. The
 difference is subtle but can be important when an application requires the
 additional performance that <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> provides.</p>
-<h3>Static method: <code>Buffer.allocUnsafeSlow(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafeslow_size" id="buffer_static_method_buffer_allocunsafeslow_size">#</a></span></h3>
+<h4>Static method: <code>Buffer.allocUnsafeSlow(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafeslow_size" id="buffer_static_method_buffer_allocunsafeslow_size">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.12.0</span>
 </div>
@@ -6809,20 +7300,20 @@ then copying out the relevant bits.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Need to keep around a few small chunks of memory.</span>
 <span class="hljs-keyword">const</span> store = [];
 
-socket.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-keyword">let</span> data;
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (data = readable.read())) {
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (data = readable.<span class="hljs-title function_">read</span>())) {
     <span class="hljs-comment">// Allocate for retained data.</span>
-    <span class="hljs-keyword">const</span> sb = Buffer.allocUnsafeSlow(<span class="hljs-number">10</span>);
+    <span class="hljs-keyword">const</span> sb = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafeSlow</span>(<span class="hljs-number">10</span>);
 
     <span class="hljs-comment">// Copy the data into the new allocation.</span>
-    data.copy(sb, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">10</span>);
+    data.<span class="hljs-title function_">copy</span>(sb, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">10</span>);
 
-    store.push(sb);
+    store.<span class="hljs-title function_">push</span>(sb);
   }
 });</code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
-<h3>Static method: <code>Buffer.byteLength(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_bytelength_string_encoding" id="buffer_static_method_buffer_bytelength_string_encoding">#</a></span></h3>
+<h4>Static method: <code>Buffer.byteLength(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_bytelength_string_encoding" id="buffer_static_method_buffer_bytelength_string_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -6846,18 +7337,19 @@ value to calculate the length of.</li>
 <p>Returns the byte length of a string when encoded using <code>encoding</code>.
 This is not the same as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length"><code>String.prototype.length</code></a>, which does not account
 for the encoding that is used to convert the string into bytes.</p>
-<p>For <code>'base64'</code> and <code>'hex'</code>, this function assumes valid input. For strings that
-contain non-base64/hex-encoded data (e.g. whitespace), the return value might be
-greater than the length of a <code>Buffer</code> created from the string.</p>
+<p>For <code>'base64'</code>, <code>'base64url'</code>, and <code>'hex'</code>, this function assumes valid input.
+For strings that contain non-base64/hex-encoded data (e.g. whitespace), the
+return value might be greater than the length of a <code>Buffer</code> created from the
+string.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> str = <span class="hljs-string">'\u00bd + \u00bc = \u00be'</span>;
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${str}</span>: <span class="hljs-subst">${str.length}</span> characters, `</span> +
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${str}</span>: <span class="hljs-subst">${str.length}</span> characters, `</span> +
             <span class="hljs-string">`<span class="hljs-subst">${Buffer.byteLength(str, <span class="hljs-string">'utf8'</span>)}</span> bytes`</span>);
 <span class="hljs-comment">// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes</span></code></pre>
 <p>When <code>string</code> is a <code>Buffer</code>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>/
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a>, the byte length as reported by <code>.byteLength</code>
 is returned.</p>
-<h3>Static method: <code>Buffer.compare(buf1, buf2)</code><span><a class="mark" href="#buffer_static_method_buffer_compare_buf1_buf2" id="buffer_static_method_buffer_compare_buf1_buf2">#</a></span></h3>
+<h4>Static method: <code>Buffer.compare(buf1, buf2)</code><span><a class="mark" href="#buffer_static_method_buffer_compare_buf1_buf2" id="buffer_static_method_buffer_compare_buf1_buf2">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -6878,14 +7370,14 @@ comparison. See <a href="#buffer_buf_compare_target_targetstart_targetend_source
 <p>Compares <code>buf1</code> to <code>buf2</code>, typically for the purpose of sorting arrays of
 <code>Buffer</code> instances. This is equivalent to calling
 <a href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend"><code>buf1.compare(buf2)</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'1234'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'0123'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'1234'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'0123'</span>);
 <span class="hljs-keyword">const</span> arr = [buf1, buf2];
 
-<span class="hljs-built_in">console</span>.log(arr.sort(Buffer.compare));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arr.<span class="hljs-title function_">sort</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-property">compare</span>));
 <span class="hljs-comment">// Prints: [ &#x3C;Buffer 30 31 32 33>, &#x3C;Buffer 31 32 33 34> ]</span>
 <span class="hljs-comment">// (This result is equal to: [buf2, buf1].)</span></code></pre>
-<h3>Static method: <code>Buffer.concat(list[, totalLength])</code><span><a class="mark" href="#buffer_static_method_buffer_concat_list_totallength" id="buffer_static_method_buffer_concat_list_totallength">#</a></span></h3>
+<h4>Static method: <code>Buffer.concat(list[, totalLength])</code><span><a class="mark" href="#buffer_static_method_buffer_concat_list_totallength" id="buffer_static_method_buffer_concat_list_totallength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -6915,23 +7407,23 @@ combined length of the <code>Buffer</code>s in <code>list</code> exceeds <code>t
 truncated to <code>totalLength</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a single `Buffer` from a list of three `Buffer` instances.</span>
 
-<span class="hljs-keyword">const</span> buf1 = Buffer.alloc(<span class="hljs-number">10</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.alloc(<span class="hljs-number">14</span>);
-<span class="hljs-keyword">const</span> buf3 = Buffer.alloc(<span class="hljs-number">18</span>);
-<span class="hljs-keyword">const</span> totalLength = buf1.length + buf2.length + buf3.length;
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">14</span>);
+<span class="hljs-keyword">const</span> buf3 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">18</span>);
+<span class="hljs-keyword">const</span> totalLength = buf1.<span class="hljs-property">length</span> + buf2.<span class="hljs-property">length</span> + buf3.<span class="hljs-property">length</span>;
 
-<span class="hljs-built_in">console</span>.log(totalLength);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(totalLength);
 <span class="hljs-comment">// Prints: 42</span>
 
-<span class="hljs-keyword">const</span> bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
+<span class="hljs-keyword">const</span> bufA = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">concat</span>([buf1, buf2, buf3], totalLength);
 
-<span class="hljs-built_in">console</span>.log(bufA);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(bufA);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 00 00 00 00 ...></span>
-<span class="hljs-built_in">console</span>.log(bufA.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(bufA.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 42</span></code></pre>
 <p><code>Buffer.concat()</code> may also use the internal <code>Buffer</code> pool like
 <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> does.</p>
-<h3>Static method: <code>Buffer.from(array)</code><span><a class="mark" href="#buffer_static_method_buffer_from_array" id="buffer_static_method_buffer_from_array">#</a></span></h3>
+<h4>Static method: <code>Buffer.from(array)</code><span><a class="mark" href="#buffer_static_method_buffer_from_array" id="buffer_static_method_buffer_from_array">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -6941,12 +7433,12 @@ truncated to <code>totalLength</code>.</p>
 <p>Allocates a new <code>Buffer</code> using an <code>array</code> of bytes in the range <code>0</code> – <code>255</code>.
 Array entries outside that range will be truncated to fit into it.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.</span>
-<span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x62</span>, <span class="hljs-number">0x75</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x65</span>, <span class="hljs-number">0x72</span>]);</code></pre>
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x62</span>, <span class="hljs-number">0x75</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x65</span>, <span class="hljs-number">0x72</span>]);</code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>array</code> is not an <code>Array</code> or another type
 appropriate for <code>Buffer.from()</code> variants.</p>
 <p><code>Buffer.from(array)</code> and <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string)</code></a> may also use the internal
 <code>Buffer</code> pool like <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> does.</p>
-<h3>Static method: <code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length" id="buffer_static_method_buffer_from_arraybuffer_byteoffset_length">#</a></span></h3>
+<h4>Static method: <code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length" id="buffer_static_method_buffer_from_arraybuffer_byteoffset_length">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -6961,34 +7453,45 @@ appropriate for <code>Buffer.from()</code> variants.</p>
 <p>This creates a view of the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> without copying the underlying
 memory. For example, when passed a reference to the <code>.buffer</code> property of a
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instance, the newly created <code>Buffer</code> will share the same
-allocated memory as the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">2</span>);
+allocated memory as the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>'s underlying <code>ArrayBuffer</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(<span class="hljs-number">2</span>);
 
 arr[<span class="hljs-number">0</span>] = <span class="hljs-number">5000</span>;
 arr[<span class="hljs-number">1</span>] = <span class="hljs-number">4000</span>;
 
 <span class="hljs-comment">// Shares memory with `arr`.</span>
-<span class="hljs-keyword">const</span> buf = Buffer.from(arr.buffer);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arr.<span class="hljs-property">buffer</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 13 a0 0f></span>
 
 <span class="hljs-comment">// Changing the original Uint16Array changes the Buffer also.</span>
 arr[<span class="hljs-number">1</span>] = <span class="hljs-number">6000</span>;
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 13 70 17></span></code></pre>
 <p>The optional <code>byteOffset</code> and <code>length</code> arguments specify a memory range within
 the <code>arrayBuffer</code> that will be shared by the <code>Buffer</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>);
-<span class="hljs-keyword">const</span> buf = Buffer.from(ab, <span class="hljs-number">0</span>, <span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(ab, <span class="hljs-number">0</span>, <span class="hljs-number">2</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 2</span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>arrayBuffer</code> is not an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> or a
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> or another type appropriate for <code>Buffer.from()</code>
 variants.</p>
-<h3>Static method: <code>Buffer.from(buffer)</code><span><a class="mark" href="#buffer_static_method_buffer_from_buffer" id="buffer_static_method_buffer_from_buffer">#</a></span></h3>
+<p>It is important to remember that a backing <code>ArrayBuffer</code> can cover a range
+of memory that extends beyond the bounds of a <code>TypedArray</code> view. A new
+<code>Buffer</code> created using the <code>buffer</code> property of a <code>TypedArray</code> may extend
+beyond the range of the <code>TypedArray</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arrA = <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x63</span>, <span class="hljs-number">0x64</span>, <span class="hljs-number">0x65</span>, <span class="hljs-number">0x66</span>]); <span class="hljs-comment">// 4 elements</span>
+<span class="hljs-keyword">const</span> arrB = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(arrA.<span class="hljs-property">buffer</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>); <span class="hljs-comment">// 2 elements</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arrA.<span class="hljs-property">buffer</span> === arrB.<span class="hljs-property">buffer</span>); <span class="hljs-comment">// true</span>
+
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arrB.<span class="hljs-property">buffer</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
+<span class="hljs-comment">// Prints: &#x3C;Buffer 63 64 65 66></span></code></pre>
+<h4>Static method: <code>Buffer.from(buffer)</code><span><a class="mark" href="#buffer_static_method_buffer_from_buffer" id="buffer_static_method_buffer_from_buffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -6997,18 +7500,18 @@ variants.</p>
 which to copy data.</li>
 </ul>
 <p>Copies the passed <code>buffer</code> data onto a new <code>Buffer</code> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'buffer'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(buf1);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(buf1);
 
 buf1[<span class="hljs-number">0</span>] = <span class="hljs-number">0x61</span>;
 
-<span class="hljs-built_in">console</span>.log(buf1.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: auffer</span>
-<span class="hljs-built_in">console</span>.log(buf2.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: buffer</span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>buffer</code> is not a <code>Buffer</code> or another type
 appropriate for <code>Buffer.from()</code> variants.</p>
-<h3>Static method: <code>Buffer.from(object[, offsetOrEncoding[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_object_offsetorencoding_length" id="buffer_static_method_buffer_from_object_offsetorencoding_length">#</a></span></h3>
+<h4>Static method: <code>Buffer.from(object[, offsetOrEncoding[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_object_offsetorencoding_length" id="buffer_static_method_buffer_from_object_offsetorencoding_length">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 </div>
@@ -7019,21 +7522,21 @@ appropriate for <code>Buffer.from()</code> variants.</p>
 </ul>
 <p>For objects whose <code>valueOf()</code> function returns a value not strictly equal to
 <code>object</code>, returns <code>Buffer.from(object.valueOf(), offsetOrEncoding, length)</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'this is a test'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(<span class="hljs-string">'this is a test'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74></span></code></pre>
 <p>For objects that support <code>Symbol.toPrimitive</code>, returns
 <code>Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding)</code>.</p>
-<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Foo</span> </span>{
-  [<span class="hljs-built_in">Symbol</span>.toPrimitive]() {
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Foo</span> {
+  [<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">toPrimitive</span>]() {
     <span class="hljs-keyword">return</span> <span class="hljs-string">'this is a test'</span>;
   }
 }
 
-<span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-keyword">new</span> Foo(), <span class="hljs-string">'utf8'</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Foo</span>(), <span class="hljs-string">'utf8'</span>);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74></span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>object</code> does not have the mentioned methods or
 is not of another type appropriate for <code>Buffer.from()</code> variants.</p>
-<h3>Static method: <code>Buffer.from(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_from_string_encoding" id="buffer_static_method_buffer_from_string_encoding">#</a></span></h3>
+<h4>Static method: <code>Buffer.from(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_from_string_encoding" id="buffer_static_method_buffer_from_string_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -7043,18 +7546,18 @@ is not of another type appropriate for <code>Buffer.from()</code> variants.</p>
 </ul>
 <p>Creates a new <code>Buffer</code> containing <code>string</code>. The <code>encoding</code> parameter identifies
 the character encoding to be used when converting <code>string</code> into bytes.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'this is a tést'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'7468697320697320612074c3a97374'</span>, <span class="hljs-string">'hex'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'this is a tést'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'7468697320697320612074c3a97374'</span>, <span class="hljs-string">'hex'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf1.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: this is a tést</span>
-<span class="hljs-built_in">console</span>.log(buf2.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: this is a tést</span>
-<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'latin1'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'latin1'</span>));
 <span class="hljs-comment">// Prints: this is a tést</span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>string</code> is not a string or another type
 appropriate for <code>Buffer.from()</code> variants.</p>
-<h3>Static method: <code>Buffer.isBuffer(obj)</code><span><a class="mark" href="#buffer_static_method_buffer_isbuffer_obj" id="buffer_static_method_buffer_isbuffer_obj">#</a></span></h3>
+<h4>Static method: <code>Buffer.isBuffer(obj)</code><span><a class="mark" href="#buffer_static_method_buffer_isbuffer_obj" id="buffer_static_method_buffer_isbuffer_obj">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.101</span>
 </div>
@@ -7063,7 +7566,12 @@ appropriate for <code>Buffer.from()</code> variants.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if <code>obj</code> is a <code>Buffer</code>, <code>false</code> otherwise.</p>
-<h3>Static method: <code>Buffer.isEncoding(encoding)</code><span><a class="mark" href="#buffer_static_method_buffer_isencoding_encoding" id="buffer_static_method_buffer_isencoding_encoding">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>)); <span class="hljs-comment">// true</span>
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// true</span>
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-string">'a string'</span>); <span class="hljs-comment">// false</span>
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>([]); <span class="hljs-comment">// false</span>
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-number">1024</span>)); <span class="hljs-comment">// false</span></code></pre>
+<h4>Static method: <code>Buffer.isEncoding(encoding)</code><span><a class="mark" href="#buffer_static_method_buffer_isencoding_encoding" id="buffer_static_method_buffer_isencoding_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -7073,18 +7581,18 @@ appropriate for <code>Buffer.from()</code> variants.</p>
 </ul>
 <p>Returns <code>true</code> if <code>encoding</code> is the name of a supported character encoding,
 or <code>false</code> otherwise.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'utf-8'</span>));
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isEncoding</span>(<span class="hljs-string">'utf-8'</span>));
 <span class="hljs-comment">// Prints: true</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isEncoding</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: true</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'utf/8'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isEncoding</span>(<span class="hljs-string">'utf/8'</span>));
 <span class="hljs-comment">// Prints: false</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">''</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isEncoding</span>(<span class="hljs-string">''</span>));
 <span class="hljs-comment">// Prints: false</span></code></pre>
-<h3>Class property: <code>Buffer.poolSize</code><span><a class="mark" href="#buffer_class_property_buffer_poolsize" id="buffer_class_property_buffer_poolsize">#</a></span></h3>
+<h4>Class property: <code>Buffer.poolSize</code><span><a class="mark" href="#buffer_class_property_buffer_poolsize" id="buffer_class_property_buffer_poolsize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -7093,10 +7601,7 @@ or <code>false</code> otherwise.</p>
 </ul>
 <p>This is the size (in bytes) of pre-allocated internal <code>Buffer</code> instances used
 for pooling. This value may be modified.</p>
-<h3><code>buf[index]</code><span><a class="mark" href="#buffer_buf_index" id="buffer_buf_index">#</a></span></h3>
-<div class="api_metadata">
-
-</div>
+<h4><code>buf[index]</code><span><a class="mark" href="#buffer_buf_index" id="buffer_buf_index">#</a></span></h4>
 <ul>
 <li><code>index</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
@@ -7113,27 +7618,27 @@ access is the same as <code>Uint8Array</code>. In other words, <code>buf[index]<
 <span class="hljs-comment">// `Buffer.from()` to perform this conversion.)</span>
 
 <span class="hljs-keyword">const</span> str = <span class="hljs-string">'Node.js'</span>;
-<span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(str.length);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(str.<span class="hljs-property">length</span>);
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; str.length; i++) {
-  buf[i] = str.charCodeAt(i);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; str.<span class="hljs-property">length</span>; i++) {
+  buf[i] = str.<span class="hljs-title function_">charCodeAt</span>(i);
 }
 
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'utf8'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: Node.js</span></code></pre>
-<h3><code>buf.buffer</code><span><a class="mark" href="#buffer_buf_buffer" id="buffer_buf_buffer">#</a></span></h3>
+<h4><code>buf.buffer</code><span><a class="mark" href="#buffer_buf_buffer" id="buffer_buf_buffer">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> The underlying <code>ArrayBuffer</code> object based on which this <code>Buffer</code>
 object is created.</li>
 </ul>
 <p>This <code>ArrayBuffer</code> is not guaranteed to correspond exactly to the original
 <code>Buffer</code>. See the notes on <code>buf.byteOffset</code> for details.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> arrayBuffer = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">16</span>);
-<span class="hljs-keyword">const</span> buffer = Buffer.from(arrayBuffer);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arrayBuffer = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">16</span>);
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arrayBuffer);
 
-<span class="hljs-built_in">console</span>.log(buffer.buffer === arrayBuffer);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buffer.<span class="hljs-property">buffer</span> === arrayBuffer);
 <span class="hljs-comment">// Prints: true</span></code></pre>
-<h3><code>buf.byteOffset</code><span><a class="mark" href="#buffer_buf_byteoffset" id="buffer_buf_byteoffset">#</a></span></h3>
+<h4><code>buf.byteOffset</code><span><a class="mark" href="#buffer_buf_byteoffset" id="buffer_buf_byteoffset">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The <code>byteOffset</code> of the <code>Buffer</code>s underlying <code>ArrayBuffer</code> object.</li>
 </ul>
@@ -7146,13 +7651,13 @@ to the <code>Buffer</code> object itself.</p>
 <p>A common issue when creating a <code>TypedArray</code> object that shares its memory with
 a <code>Buffer</code> is that in this case one needs to specify the <code>byteOffset</code> correctly:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a buffer smaller than `Buffer.poolSize`.</span>
-<span class="hljs-keyword">const</span> nodeBuffer = <span class="hljs-keyword">new</span> Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
+<span class="hljs-keyword">const</span> nodeBuffer = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
 
 <span class="hljs-comment">// When casting the Node.js Buffer to an Int8Array, use the byteOffset</span>
 <span class="hljs-comment">// to refer only to the part of `nodeBuffer.buffer` that contains the memory</span>
 <span class="hljs-comment">// for `nodeBuffer`.</span>
-<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int8Array</span>(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);</code></pre>
-<h3><code>buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])</code><span><a class="mark" href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend" id="buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend">#</a></span></h3>
+<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>8<span class="hljs-built_in">Array</span>(nodeBuffer.<span class="hljs-property">buffer</span>, nodeBuffer.<span class="hljs-property">byteOffset</span>, nodeBuffer.<span class="hljs-property">length</span>);</code></pre>
+<h4><code>buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])</code><span><a class="mark" href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend" id="buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7187,38 +7692,38 @@ Comparison is based on the actual sequence of bytes in each <code>Buffer</code>.
 <li><code>1</code> is returned if <code>target</code> should come <em>before</em> <code>buf</code> when sorted.</li>
 <li><code>-1</code> is returned if <code>target</code> should come <em>after</em> <code>buf</code> when sorted.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'ABC'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'BCD'</span>);
-<span class="hljs-keyword">const</span> buf3 = Buffer.from(<span class="hljs-string">'ABCD'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'ABC'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'BCD'</span>);
+<span class="hljs-keyword">const</span> buf3 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'ABCD'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf1));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf1));
 <span class="hljs-comment">// Prints: 0</span>
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf2));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf2));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf3));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf3));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf2.compare(buf1));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">compare</span>(buf1));
 <span class="hljs-comment">// Prints: 1</span>
-<span class="hljs-built_in">console</span>.log(buf2.compare(buf3));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">compare</span>(buf3));
 <span class="hljs-comment">// Prints: 1</span>
-<span class="hljs-built_in">console</span>.log([buf1, buf2, buf3].sort(Buffer.compare));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>([buf1, buf2, buf3].<span class="hljs-title function_">sort</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-property">compare</span>));
 <span class="hljs-comment">// Prints: [ &#x3C;Buffer 41 42 43>, &#x3C;Buffer 41 42 43 44>, &#x3C;Buffer 42 43 44> ]</span>
 <span class="hljs-comment">// (This result is equal to: [buf1, buf3, buf2].)</span></code></pre>
 <p>The optional <code>targetStart</code>, <code>targetEnd</code>, <code>sourceStart</code>, and <code>sourceEnd</code>
 arguments can be used to limit the comparison to specific ranges within <code>target</code>
 and <code>buf</code> respectively.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">9</span>, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">9</span>, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>));
 <span class="hljs-comment">// Prints: 0</span>
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>, <span class="hljs-number">4</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf2, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>, <span class="hljs-number">4</span>));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">5</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">5</span>));
 <span class="hljs-comment">// Prints: 1</span></code></pre>
 <p><a href="#ERR_OUT_OF_RANGE"><code>ERR_OUT_OF_RANGE</code></a> is thrown if <code>targetStart &#x3C; 0</code>, <code>sourceStart &#x3C; 0</code>,
 <code>targetEnd > target.byteLength</code>, or <code>sourceEnd > source.byteLength</code>.</p>
-<h3><code>buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])</code><span><a class="mark" href="#buffer_buf_copy_target_targetstart_sourcestart_sourceend" id="buffer_buf_copy_target_targetstart_sourcestart_sourceend">#</a></span></h3>
+<h4><code>buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])</code><span><a class="mark" href="#buffer_buf_copy_target_targetstart_sourcestart_sourceend" id="buffer_buf_copy_target_targetstart_sourcestart_sourceend">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -7234,12 +7739,12 @@ inclusive). <strong>Default:</strong> <a href="#buffer_buf_length"><code>buf.len
 </ul>
 <p>Copies data from a region of <code>buf</code> to a region in <code>target</code>, even if the <code>target</code>
 memory region overlaps with <code>buf</code>.</p>
-<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set"><code>TypedArray#set()</code></a> performs the same operation, and is available for all
-TypedArrays, including Node.js <code>Buffer</code>s, although it takes different
-function arguments.</p>
+<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set"><code>TypedArray.prototype.set()</code></a> performs the same operation, and is available
+for all TypedArrays, including Node.js <code>Buffer</code>s, although it takes
+different function arguments.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create two `Buffer` instances.</span>
-<span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.allocUnsafe(<span class="hljs-number">26</span>).fill(<span class="hljs-string">'!'</span>);
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>).<span class="hljs-title function_">fill</span>(<span class="hljs-string">'!'</span>);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">26</span>; i++) {
   <span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
@@ -7247,27 +7752,27 @@ function arguments.</p>
 }
 
 <span class="hljs-comment">// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.</span>
-buf1.copy(buf2, <span class="hljs-number">8</span>, <span class="hljs-number">16</span>, <span class="hljs-number">20</span>);
+buf1.<span class="hljs-title function_">copy</span>(buf2, <span class="hljs-number">8</span>, <span class="hljs-number">16</span>, <span class="hljs-number">20</span>);
 <span class="hljs-comment">// This is equivalent to:</span>
 <span class="hljs-comment">// buf2.set(buf1.subarray(16, 20), 8);</span>
 
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">25</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">25</span>));
 <span class="hljs-comment">// Prints: !!!!!!!!qrst!!!!!!!!!!!!!</span></code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` and copy data from one region to an overlapping region</span>
 <span class="hljs-comment">// within the same `Buffer`.</span>
 
-<span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">26</span>; i++) {
   <span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
   buf[i] = i + <span class="hljs-number">97</span>;
 }
 
-buf.copy(buf, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">10</span>);
+buf.<span class="hljs-title function_">copy</span>(buf, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">10</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: efghijghijklmnopqrstuvwxyz</span></code></pre>
-<h3><code>buf.entries()</code><span><a class="mark" href="#buffer_buf_entries" id="buffer_buf_entries">#</a></span></h3>
+<h4><code>buf.entries()</code><span><a class="mark" href="#buffer_buf_entries" id="buffer_buf_entries">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.1.0</span>
 </div>
@@ -7278,10 +7783,10 @@ buf.copy(buf, <span class="hljs-number">0</span>, <span class="hljs-number">4</s
 of <code>buf</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Log the entire contents of a `Buffer`.</span>
 
-<span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> pair <span class="hljs-keyword">of</span> buf.entries()) {
-  <span class="hljs-built_in">console</span>.log(pair);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> pair <span class="hljs-keyword">of</span> buf.<span class="hljs-title function_">entries</span>()) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(pair);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   [0, 98]</span>
@@ -7290,7 +7795,7 @@ of <code>buf</code>.</p>
 <span class="hljs-comment">//   [3, 102]</span>
 <span class="hljs-comment">//   [4, 101]</span>
 <span class="hljs-comment">//   [5, 114]</span></code></pre>
-<h3><code>buf.equals(otherBuffer)</code><span><a class="mark" href="#buffer_buf_equals_otherbuffer" id="buffer_buf_equals_otherbuffer">#</a></span></h3>
+<h4><code>buf.equals(otherBuffer)</code><span><a class="mark" href="#buffer_buf_equals_otherbuffer" id="buffer_buf_equals_otherbuffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7310,15 +7815,15 @@ compare <code>buf</code>.</li>
 <p>Returns <code>true</code> if both <code>buf</code> and <code>otherBuffer</code> have exactly the same bytes,
 <code>false</code> otherwise. Equivalent to
 <a href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend"><code>buf.compare(otherBuffer) === 0</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'ABC'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'414243'</span>, <span class="hljs-string">'hex'</span>);
-<span class="hljs-keyword">const</span> buf3 = Buffer.from(<span class="hljs-string">'ABCD'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'ABC'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'414243'</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> buf3 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'ABCD'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf1.equals(buf2));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">equals</span>(buf2));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf1.equals(buf3));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">equals</span>(buf3));
 <span class="hljs-comment">// Prints: false</span></code></pre>
-<h3><code>buf.fill(value[, offset[, end]][, encoding])</code><span><a class="mark" href="#buffer_buf_fill_value_offset_end_encoding" id="buffer_buf_fill_value_offset_end_encoding">#</a></span></h3>
+<h4><code>buf.fill(value[, offset[, end]][, encoding])</code><span><a class="mark" href="#buffer_buf_fill_value_offset_end_encoding" id="buffer_buf_fill_value_offset_end_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7352,9 +7857,9 @@ compare <code>buf</code>.</li>
 the entire <code>buf</code> will be filled:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Fill a `Buffer` with the ASCII character 'h'.</span>
 
-<span class="hljs-keyword">const</span> b = Buffer.allocUnsafe(<span class="hljs-number">50</span>).fill(<span class="hljs-string">'h'</span>);
+<span class="hljs-keyword">const</span> b = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">50</span>).<span class="hljs-title function_">fill</span>(<span class="hljs-string">'h'</span>);
 
-<span class="hljs-built_in">console</span>.log(b.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh</span></code></pre>
 <p><code>value</code> is coerced to a <code>uint32</code> value if it is not a string, <code>Buffer</code>, or
 integer. If the resulting integer is greater than <code>255</code> (decimal), <code>buf</code> will be
@@ -7363,19 +7868,19 @@ filled with <code>value &#x26; 255</code>.</p>
 then only the bytes of that character that fit into <code>buf</code> are written:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Fill a `Buffer` with character that takes up two bytes in UTF-8.</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.allocUnsafe(<span class="hljs-number">5</span>).fill(<span class="hljs-string">'\u0222'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">5</span>).<span class="hljs-title function_">fill</span>(<span class="hljs-string">'\u0222'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer c8 a2 c8 a2 c8></span></code></pre>
 <p>If <code>value</code> contains invalid characters, it is truncated; if no valid
 fill data remains, an exception is thrown:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">5</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">5</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'a'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">fill</span>(<span class="hljs-string">'a'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer 61 61 61 61 61></span>
-<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'aazz'</span>, <span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">fill</span>(<span class="hljs-string">'aazz'</span>, <span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer aa aa aa aa aa></span>
-<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'zz'</span>, <span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">fill</span>(<span class="hljs-string">'zz'</span>, <span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Throws an exception.</span></code></pre>
-<h3><code>buf.includes(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_includes_value_byteoffset_encoding" id="buffer_buf_includes_value_byteoffset_encoding">#</a></span></h3>
+<h4><code>buf.includes(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_includes_value_byteoffset_encoding" id="buffer_buf_includes_value_byteoffset_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.3.0</span>
 </div>
@@ -7388,23 +7893,23 @@ offset is calculated from the end of <code>buf</code>. <strong>Default:</strong>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if <code>value</code> was found in <code>buf</code>, <code>false</code> otherwise.</li>
 </ul>
 <p>Equivalent to <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf() !== -1</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this is a buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'this is a buffer'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'this'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-string">'this'</span>));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'is'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-string">'is'</span>));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer'</span>)));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-number">97</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-number">97</span>));
 <span class="hljs-comment">// Prints: true (97 is the decimal ASCII value for 'a')</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer example'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer example'</span>)));
 <span class="hljs-comment">// Prints: false</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer example'</span>).slice(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer example'</span>).<span class="hljs-title function_">slice</span>(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'this'</span>, <span class="hljs-number">4</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-string">'this'</span>, <span class="hljs-number">4</span>));
 <span class="hljs-comment">// Prints: false</span></code></pre>
-<h3><code>buf.indexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_indexof_value_byteoffset_encoding" id="buffer_buf_indexof_value_byteoffset_encoding">#</a></span></h3>
+<h4><code>buf.indexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_indexof_value_byteoffset_encoding" id="buffer_buf_indexof_value_byteoffset_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7437,50 +7942,50 @@ To compare a partial <code>Buffer</code>, use <a href="#buffer_buf_slice_start_e
 <li>a number, <code>value</code> will be interpreted as an unsigned 8-bit integer
 value between <code>0</code> and <code>255</code>.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this is a buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'this is a buffer'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-string">'this'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'this'</span>));
 <span class="hljs-comment">// Prints: 0</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-string">'is'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'is'</span>));
 <span class="hljs-comment">// Prints: 2</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer'</span>)));
 <span class="hljs-comment">// Prints: 8</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-number">97</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-number">97</span>));
 <span class="hljs-comment">// Prints: 8 (97 is the decimal ASCII value for 'a')</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer example'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer example'</span>)));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer example'</span>).slice(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer example'</span>).<span class="hljs-title function_">slice</span>(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
 <span class="hljs-comment">// Prints: 8</span>
 
-<span class="hljs-keyword">const</span> utf16Buffer = Buffer.from(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
+<span class="hljs-keyword">const</span> utf16Buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
 
-<span class="hljs-built_in">console</span>.log(utf16Buffer.indexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(utf16Buffer.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: 4</span>
-<span class="hljs-built_in">console</span>.log(utf16Buffer.indexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">-4</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(utf16Buffer.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'\u03a3'</span>, -<span class="hljs-number">4</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: 6</span></code></pre>
 <p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a
 <code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,
 an integer between 0 and 255.</p>
 <p>If <code>byteOffset</code> is not a number, it will be coerced to a number. If the result
 of coercion is <code>NaN</code> or <code>0</code>, then the entire buffer will be searched. This
-behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf"><code>String#indexOf()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> b = Buffer.from(<span class="hljs-string">'abcdef'</span>);
+behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf"><code>String.prototype.indexOf()</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> b = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'abcdef'</span>);
 
 <span class="hljs-comment">// Passing a value that's a number, but not a valid byte.</span>
 <span class="hljs-comment">// Prints: 2, equivalent to searching for 99 or 'c'.</span>
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-number">99.9</span>));
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-number">99.9</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
 
 <span class="hljs-comment">// Passing a byteOffset that coerces to NaN or 0.</span>
 <span class="hljs-comment">// Prints: 1, searching the whole buffer.</span>
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, {}));
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, []));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'b'</span>, {}));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'b'</span>, []));</code></pre>
 <p>If <code>value</code> is an empty string or empty <code>Buffer</code> and <code>byteOffset</code> is less
 than <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code>value</code> is empty and
 <code>byteOffset</code> is at least <code>buf.length</code>, <code>buf.length</code> will be returned.</p>
-<h3><code>buf.keys()</code><span><a class="mark" href="#buffer_buf_keys" id="buffer_buf_keys">#</a></span></h3>
+<h4><code>buf.keys()</code><span><a class="mark" href="#buffer_buf_keys" id="buffer_buf_keys">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.1.0</span>
 </div>
@@ -7488,10 +7993,10 @@ than <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
 <p>Creates and returns an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">iterator</a> of <code>buf</code> keys (indices).</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> key <span class="hljs-keyword">of</span> buf.keys()) {
-  <span class="hljs-built_in">console</span>.log(key);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> key <span class="hljs-keyword">of</span> buf.<span class="hljs-title function_">keys</span>()) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   0</span>
@@ -7500,7 +8005,7 @@ than <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code
 <span class="hljs-comment">//   3</span>
 <span class="hljs-comment">//   4</span>
 <span class="hljs-comment">//   5</span></code></pre>
-<h3><code>buf.lastIndexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_lastindexof_value_byteoffset_encoding" id="buffer_buf_lastindexof_value_byteoffset_encoding">#</a></span></h3>
+<h4><code>buf.lastIndexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_lastindexof_value_byteoffset_encoding" id="buffer_buf_lastindexof_value_byteoffset_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7525,53 +8030,53 @@ determine the binary representation of the string that will be searched for in
 </ul>
 <p>Identical to <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf()</code></a>, except the last occurrence of <code>value</code> is found
 rather than the first occurrence.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this buffer is a buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'this buffer is a buffer'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'this'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'this'</span>));
 <span class="hljs-comment">// Prints: 0</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'buffer'</span>));
 <span class="hljs-comment">// Prints: 17</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(Buffer.from(<span class="hljs-string">'buffer'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>)));
 <span class="hljs-comment">// Prints: 17</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-number">97</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-number">97</span>));
 <span class="hljs-comment">// Prints: 15 (97 is the decimal ASCII value for 'a')</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(Buffer.from(<span class="hljs-string">'yolo'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'yolo'</span>)));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">5</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">5</span>));
 <span class="hljs-comment">// Prints: 5</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">4</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">4</span>));
 <span class="hljs-comment">// Prints: -1</span>
 
-<span class="hljs-keyword">const</span> utf16Buffer = Buffer.from(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
+<span class="hljs-keyword">const</span> utf16Buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
 
-<span class="hljs-built_in">console</span>.log(utf16Buffer.lastIndexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(utf16Buffer.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: 6</span>
-<span class="hljs-built_in">console</span>.log(utf16Buffer.lastIndexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">-5</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(utf16Buffer.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'\u03a3'</span>, -<span class="hljs-number">5</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: 4</span></code></pre>
 <p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a
 <code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,
 an integer between 0 and 255.</p>
 <p>If <code>byteOffset</code> is not a number, it will be coerced to a number. Any arguments
 that coerce to <code>NaN</code>, like <code>{}</code> or <code>undefined</code>, will search the whole buffer.
-This behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf"><code>String#lastIndexOf()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> b = Buffer.from(<span class="hljs-string">'abcdef'</span>);
+This behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf"><code>String.prototype.lastIndexOf()</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> b = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'abcdef'</span>);
 
 <span class="hljs-comment">// Passing a value that's a number, but not a valid byte.</span>
 <span class="hljs-comment">// Prints: 2, equivalent to searching for 99 or 'c'.</span>
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-number">99.9</span>));
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-number">99.9</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
 
 <span class="hljs-comment">// Passing a byteOffset that coerces to NaN.</span>
 <span class="hljs-comment">// Prints: 1, searching the whole buffer.</span>
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, {}));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'b'</span>, {}));
 
 <span class="hljs-comment">// Passing a byteOffset that coerces to 0.</span>
 <span class="hljs-comment">// Prints: -1, equivalent to passing 0.</span>
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, []));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'b'</span>, []));</code></pre>
 <p>If <code>value</code> is an empty string or empty <code>Buffer</code>, <code>byteOffset</code> will be returned.</p>
-<h3><code>buf.length</code><span><a class="mark" href="#buffer_buf_length" id="buffer_buf_length">#</a></span></h3>
+<h4><code>buf.length</code><span><a class="mark" href="#buffer_buf_length" id="buffer_buf_length">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -7581,22 +8086,22 @@ This behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/Java
 <p>Returns the number of bytes in <code>buf</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` and write a shorter string to it using UTF-8.</span>
 
-<span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">1234</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">1234</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 1234</span>
 
-buf.write(<span class="hljs-string">'some string'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf8'</span>);
+buf.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some string'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf8'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 1234</span></code></pre>
-<h3><code>buf.parent</code><span><a class="mark" href="#buffer_buf_parent" id="buffer_buf_parent">#</a></span></h3>
+<h4><code>buf.parent</code><span><a class="mark" href="#buffer_buf_parent" id="buffer_buf_parent">#</a></span></h4>
 <div class="api_metadata">
 <span>Deprecated since: v8.0.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#buffer_buf_buffer"><code>buf.buffer</code></a> instead.</div><p></p>
 <p>The <code>buf.parent</code> property is a deprecated alias for <code>buf.buffer</code>.</p>
-<h3><code>buf.readBigInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64be_offset" id="buffer_buf_readbigint64be_offset">#</a></span></h3>
+<h4><code>buf.readBigInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64be_offset" id="buffer_buf_readbigint64be_offset">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0, v10.20.0</span>
 </div>
@@ -7608,9 +8113,9 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 <p>Reads a signed, big-endian 64-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed
 values.</p>
-<h3><code>buf.readBigInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64le_offset" id="buffer_buf_readbigint64le_offset">#</a></span></h3>
+<h4><code>buf.readBigInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64le_offset" id="buffer_buf_readbigint64le_offset">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <ul>
 <li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Number of bytes to skip before starting to read. Must
@@ -7621,15 +8126,15 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed
 values.</p>
-<h3><code>buf.readBigUInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64be_offset" id="buffer_buf_readbiguint64be_offset">#</a></span></h3>
+<h4><code>buf.readBigUInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64be_offset" id="buffer_buf_readbiguint64be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>This function is also available as <code>buf.readBigUint64BE()</code>.</p></td></tr>
-<tr><td>v12.0.0</td>
-<td><p><span>Added in: v12.0.0</span></p></td></tr>
+<tr><td>v12.0.0, v10.20.0</td>
+<td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -7640,16 +8145,17 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 </ul>
 <p>Reads an unsigned, big-endian 64-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
+<p>This function is also available under the <code>readBigUint64BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readBigUInt64BE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readBigUInt64BE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 4294967295n</span></code></pre>
-<h3><code>buf.readBigUInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64le_offset" id="buffer_buf_readbiguint64le_offset">#</a></span></h3>
+<h4><code>buf.readBigUInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64le_offset" id="buffer_buf_readbiguint64le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0, v12.19.0</td>
 <td><p>This function is also available as <code>buf.readBigUint64LE()</code>.</p></td></tr>
 <tr><td>v12.0.0, v10.20.0</td>
 <td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
@@ -7663,11 +8169,12 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 </ul>
 <p>Reads an unsigned, little-endian 64-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
+<p>This function is also available under the <code>readBigUint64LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readBigUInt64LE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readBigUInt64LE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 18446744069414584320n</span></code></pre>
-<h3><code>buf.readDoubleBE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublebe_offset" id="buffer_buf_readdoublebe_offset">#</a></span></h3>
+<h4><code>buf.readDoubleBE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublebe_offset" id="buffer_buf_readdoublebe_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7685,11 +8192,11 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Reads a 64-bit, big-endian double from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readDoubleBE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readDoubleBE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 8.20788039913184e-304</span></code></pre>
-<h3><code>buf.readDoubleLE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublele_offset" id="buffer_buf_readdoublele_offset">#</a></span></h3>
+<h4><code>buf.readDoubleLE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublele_offset" id="buffer_buf_readdoublele_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7707,13 +8214,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Reads a 64-bit, little-endian double from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readDoubleLE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readDoubleLE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 5.447603722011605e-270</span>
-<span class="hljs-built_in">console</span>.log(buf.readDoubleLE(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readDoubleLE</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readFloatBE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatbe_offset" id="buffer_buf_readfloatbe_offset">#</a></span></h3>
+<h4><code>buf.readFloatBE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatbe_offset" id="buffer_buf_readfloatbe_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7731,11 +8238,11 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Reads a 32-bit, big-endian float from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readFloatBE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readFloatBE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 2.387939260590663e-38</span></code></pre>
-<h3><code>buf.readFloatLE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatle_offset" id="buffer_buf_readfloatle_offset">#</a></span></h3>
+<h4><code>buf.readFloatLE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatle_offset" id="buffer_buf_readfloatle_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7753,13 +8260,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Reads a 32-bit, little-endian float from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readFloatLE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readFloatLE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 1.539989614439558e-36</span>
-<span class="hljs-built_in">console</span>.log(buf.readFloatLE(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readFloatLE</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readInt8([offset])</code><span><a class="mark" href="#buffer_buf_readint8_offset" id="buffer_buf_readint8_offset">#</a></span></h3>
+<h4><code>buf.readInt8([offset])</code><span><a class="mark" href="#buffer_buf_readint8_offset" id="buffer_buf_readint8_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7778,15 +8285,15 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 1</code>. <strong>Default:</
 </ul>
 <p>Reads a signed 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">-1</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([-<span class="hljs-number">1</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt8</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt8</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Prints: 5</span>
-<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">2</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt8</span>(<span class="hljs-number">2</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readint16be_offset" id="buffer_buf_readint16be_offset">#</a></span></h3>
+<h4><code>buf.readInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readint16be_offset" id="buffer_buf_readint16be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7805,11 +8312,11 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 </ul>
 <p>Reads a signed, big-endian 16-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt16BE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt16BE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 5</span></code></pre>
-<h3><code>buf.readInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readint16le_offset" id="buffer_buf_readint16le_offset">#</a></span></h3>
+<h4><code>buf.readInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readint16le_offset" id="buffer_buf_readint16le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7829,13 +8336,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 <p>Reads a signed, little-endian 16-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt16LE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt16LE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 1280</span>
-<span class="hljs-built_in">console</span>.log(buf.readInt16LE(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt16LE</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readint32be_offset" id="buffer_buf_readint32be_offset">#</a></span></h3>
+<h4><code>buf.readInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readint32be_offset" id="buffer_buf_readint32be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7854,11 +8361,11 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Reads a signed, big-endian 32-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt32BE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt32BE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 5</span></code></pre>
-<h3><code>buf.readInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readint32le_offset" id="buffer_buf_readint32le_offset">#</a></span></h3>
+<h4><code>buf.readInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readint32le_offset" id="buffer_buf_readint32le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7878,13 +8385,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <p>Reads a signed, little-endian 32-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt32LE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt32LE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 83886080</span>
-<span class="hljs-built_in">console</span>.log(buf.readInt32LE(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt32LE</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintbe_offset_bytelength" id="buffer_buf_readintbe_offset_bytelength">#</a></span></h3>
+<h4><code>buf.readIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintbe_offset_bytelength" id="buffer_buf_readintbe_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7906,15 +8413,15 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
 and interprets the result as a big-endian, two's complement signed value
 supporting up to 48 bits of accuracy.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readIntBE</span>(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 1234567890ab</span>
-<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readIntBE</span>(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span>
-<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readIntBE</span>(<span class="hljs-number">1</span>, <span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintle_offset_bytelength" id="buffer_buf_readintle_offset_bytelength">#</a></span></h3>
+<h4><code>buf.readIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintle_offset_bytelength" id="buffer_buf_readintle_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -7936,16 +8443,16 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
 and interprets the result as a little-endian, two's complement signed value
 supporting up to 48 bits of accuracy.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readIntLE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readIntLE</span>(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: -546f87a9cbee</span></code></pre>
-<h3><code>buf.readUInt8([offset])</code><span><a class="mark" href="#buffer_buf_readuint8_offset" id="buffer_buf_readuint8_offset">#</a></span></h3>
+<h4><code>buf.readUInt8([offset])</code><span><a class="mark" href="#buffer_buf_readuint8_offset" id="buffer_buf_readuint8_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint8()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -7960,20 +8467,21 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 1</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Reads an unsigned 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">-2</span>]);
+<p>This function is also available under the <code>readUint8</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, -<span class="hljs-number">2</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt8</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 1</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt8</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Prints: 254</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">2</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt8</span>(<span class="hljs-number">2</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readUInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16be_offset" id="buffer_buf_readuint16be_offset">#</a></span></h3>
+<h4><code>buf.readUInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16be_offset" id="buffer_buf_readuint16be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint16BE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -7989,18 +8497,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 </ul>
 <p>Reads an unsigned, big-endian 16-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
+<p>This function is also available under the <code>readUint16BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt16BE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16BE</span>(<span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 1234</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt16BE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16BE</span>(<span class="hljs-number">1</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 3456</span></code></pre>
-<h3><code>buf.readUInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16le_offset" id="buffer_buf_readuint16le_offset">#</a></span></h3>
+<h4><code>buf.readUInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16le_offset" id="buffer_buf_readuint16le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint16LE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -8016,20 +8525,21 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 </ul>
 <p>Reads an unsigned, little-endian 16-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
+<p>This function is also available under the <code>readUint16LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16LE</span>(<span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 3412</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16LE</span>(<span class="hljs-number">1</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 5634</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">2</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16LE</span>(<span class="hljs-number">2</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readUInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32be_offset" id="buffer_buf_readuint32be_offset">#</a></span></h3>
+<h4><code>buf.readUInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32be_offset" id="buffer_buf_readuint32be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint32BE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -8045,16 +8555,17 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Reads an unsigned, big-endian 32-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
+<p>This function is also available under the <code>readUint32BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt32BE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt32BE</span>(<span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 12345678</span></code></pre>
-<h3><code>buf.readUInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32le_offset" id="buffer_buf_readuint32le_offset">#</a></span></h3>
+<h4><code>buf.readUInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32le_offset" id="buffer_buf_readuint32le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint32LE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -8070,18 +8581,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Reads an unsigned, little-endian 32-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
+<p>This function is also available under the <code>readUint32LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt32LE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt32LE</span>(<span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 78563412</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt32LE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt32LE</span>(<span class="hljs-number">1</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readUIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintbe_offset_bytelength" id="buffer_buf_readuintbe_offset_bytelength">#</a></span></h3>
+<h4><code>buf.readUIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintbe_offset_bytelength" id="buffer_buf_readuintbe_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUintBE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
@@ -8100,18 +8612,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
 and interprets the result as an unsigned big-endian integer supporting
 up to 48 bits of accuracy.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
+<p>This function is also available under the <code>readUintBE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUIntBE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUIntBE</span>(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 1234567890ab</span>
-<span class="hljs-built_in">console</span>.log(buf.readUIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUIntBE</span>(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readUIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintle_offset_bytelength" id="buffer_buf_readuintle_offset_bytelength">#</a></span></h3>
+<h4><code>buf.readUIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintle_offset_bytelength" id="buffer_buf_readuintle_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUintLE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
@@ -8130,11 +8643,12 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
 and interprets the result as an unsigned, little-endian integer supporting
 up to 48 bits of accuracy.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
+<p>This function is also available under the <code>readUintLE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUIntLE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUIntLE</span>(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: ab9078563412</span></code></pre>
-<h3><code>buf.subarray([start[, end]])</code><span><a class="mark" href="#buffer_buf_subarray_start_end" id="buffer_buf_subarray_start_end">#</a></span></h3>
+<h4><code>buf.subarray([start[, end]])</code><span><a class="mark" href="#buffer_buf_subarray_start_end" id="buffer_buf_subarray_start_end">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
@@ -8148,52 +8662,52 @@ up to 48 bits of accuracy.</p>
 offset and cropped by the <code>start</code> and <code>end</code> indices.</p>
 <p>Specifying <code>end</code> greater than <a href="#buffer_buf_length"><code>buf.length</code></a> will return the same result as
 that of <code>end</code> equal to <a href="#buffer_buf_length"><code>buf.length</code></a>.</p>
-<p>This method is inherited from <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray#subarray()</code></a>.</p>
+<p>This method is inherited from <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray.prototype.subarray()</code></a>.</p>
 <p>Modifying the new <code>Buffer</code> slice will modify the memory in the original <code>Buffer</code>
 because the allocated memory of the two objects overlap.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte</span>
 <span class="hljs-comment">// from the original `Buffer`.</span>
 
-<span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">26</span>; i++) {
   <span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
   buf1[i] = i + <span class="hljs-number">97</span>;
 }
 
-<span class="hljs-keyword">const</span> buf2 = buf1.subarray(<span class="hljs-number">0</span>, <span class="hljs-number">3</span>);
+<span class="hljs-keyword">const</span> buf2 = buf1.<span class="hljs-title function_">subarray</span>(<span class="hljs-number">0</span>, <span class="hljs-number">3</span>);
 
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.length));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.<span class="hljs-property">length</span>));
 <span class="hljs-comment">// Prints: abc</span>
 
 buf1[<span class="hljs-number">0</span>] = <span class="hljs-number">33</span>;
 
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.length));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.<span class="hljs-property">length</span>));
 <span class="hljs-comment">// Prints: !bc</span></code></pre>
 <p>Specifying negative indexes causes the slice to be generated relative to the
 end of <code>buf</code> rather than the beginning.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-6</span>, <span class="hljs-number">-1</span>).toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">subarray</span>(-<span class="hljs-number">6</span>, -<span class="hljs-number">1</span>).<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: buffe</span>
 <span class="hljs-comment">// (Equivalent to buf.subarray(0, 5).)</span>
 
-<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-6</span>, <span class="hljs-number">-2</span>).toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">subarray</span>(-<span class="hljs-number">6</span>, -<span class="hljs-number">2</span>).<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: buff</span>
 <span class="hljs-comment">// (Equivalent to buf.subarray(0, 4).)</span>
 
-<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-5</span>, <span class="hljs-number">-2</span>).toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">subarray</span>(-<span class="hljs-number">5</span>, -<span class="hljs-number">2</span>).<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: uff</span>
 <span class="hljs-comment">// (Equivalent to buf.subarray(1, 4).)</span></code></pre>
-<h3><code>buf.slice([start[, end]])</code><span><a class="mark" href="#buffer_buf_slice_start_end" id="buffer_buf_slice_start_end">#</a></span></h3>
+<h4><code>buf.slice([start[, end]])</code><span><a class="mark" href="#buffer_buf_slice_start_end" id="buffer_buf_slice_start_end">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.1.0, v6.9.2</td>
-<td><p>Coercing the offsets to integers now handles values outside the 32-bit integer range properly.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>All offsets are now coerced to integers before doing any calculations with them.</p></td></tr>
+<tr><td>v7.1.0, v6.9.2</td>
+<td><p>Coercing the offsets to integers now handles values outside the 32-bit integer range properly.</p></td></tr>
 <tr><td>v0.3.0</td>
 <td><p><span>Added in: v0.3.0</span></p></td></tr>
 </tbody></table>
@@ -8211,16 +8725,16 @@ offset and cropped by the <code>start</code> and <code>end</code> indices.</p>
 <p>This method is not compatible with the <code>Uint8Array.prototype.slice()</code>,
 which is a superclass of <code>Buffer</code>. To copy the slice, use
 <code>Uint8Array.prototype.slice()</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">const</span> copiedBuf = <span class="hljs-built_in">Uint8Array</span>.prototype.slice.call(buf);
+<span class="hljs-keyword">const</span> copiedBuf = <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">slice</span>.<span class="hljs-title function_">call</span>(buf);
 copiedBuf[<span class="hljs-number">0</span>]++;
-<span class="hljs-built_in">console</span>.log(copiedBuf.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(copiedBuf.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: cuffer</span>
 
-<span class="hljs-built_in">console</span>.log(buf.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: buffer</span></code></pre>
-<h3><code>buf.swap16()</code><span><a class="mark" href="#buffer_buf_swap16" id="buffer_buf_swap16">#</a></span></h3>
+<h4><code>buf.swap16()</code><span><a class="mark" href="#buffer_buf_swap16" id="buffer_buf_swap16">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -8230,25 +8744,25 @@ copiedBuf[<span class="hljs-number">0</span>]++;
 <p>Interprets <code>buf</code> as an array of unsigned 16-bit integers and swaps the
 byte order <em>in-place</em>. Throws <a href="#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a>
 is not a multiple of 2.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05 06 07 08></span>
 
-buf1.swap16();
+buf1.<span class="hljs-title function_">swap16</span>();
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 02 01 04 03 06 05 08 07></span>
 
-<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
 
-buf2.swap16();
+buf2.<span class="hljs-title function_">swap16</span>();
 <span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
 <p>One convenient use of <code>buf.swap16()</code> is to perform a fast in-place conversion
 between UTF-16 little-endian and UTF-16 big-endian:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'This is little-endian UTF-16'</span>, <span class="hljs-string">'utf16le'</span>);
-buf.swap16(); <span class="hljs-comment">// Convert to big-endian UTF-16 text.</span></code></pre>
-<h3><code>buf.swap32()</code><span><a class="mark" href="#buffer_buf_swap32" id="buffer_buf_swap32">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'This is little-endian UTF-16'</span>, <span class="hljs-string">'utf16le'</span>);
+buf.<span class="hljs-title function_">swap16</span>(); <span class="hljs-comment">// Convert to big-endian UTF-16 text.</span></code></pre>
+<h4><code>buf.swap32()</code><span><a class="mark" href="#buffer_buf_swap32" id="buffer_buf_swap32">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -8258,21 +8772,21 @@ buf.swap16(); <span class="hljs-comment">// Convert to big-endian UTF-16 text.</
 <p>Interprets <code>buf</code> as an array of unsigned 32-bit integers and swaps the
 byte order <em>in-place</em>. Throws <a href="#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a>
 is not a multiple of 4.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05 06 07 08></span>
 
-buf1.swap32();
+buf1.<span class="hljs-title function_">swap32</span>();
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 04 03 02 01 08 07 06 05></span>
 
-<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
 
-buf2.swap32();
+buf2.<span class="hljs-title function_">swap32</span>();
 <span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
-<h3><code>buf.swap64()</code><span><a class="mark" href="#buffer_buf_swap64" id="buffer_buf_swap64">#</a></span></h3>
+<h4><code>buf.swap64()</code><span><a class="mark" href="#buffer_buf_swap64" id="buffer_buf_swap64">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -8281,21 +8795,21 @@ buf2.swap32();
 </ul>
 <p>Interprets <code>buf</code> as an array of 64-bit numbers and swaps byte order <em>in-place</em>.
 Throws <a href="#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a> is not a multiple of 8.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05 06 07 08></span>
 
-buf1.swap64();
+buf1.<span class="hljs-title function_">swap64</span>();
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 08 07 06 05 04 03 02 01></span>
 
-<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
 
-buf2.swap64();
+buf2.<span class="hljs-title function_">swap64</span>();
 <span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
-<h3><code>buf.toJSON()</code><span><a class="mark" href="#buffer_buf_tojson" id="buffer_buf_tojson">#</a></span></h3>
+<h4><code>buf.toJSON()</code><span><a class="mark" href="#buffer_buf_tojson" id="buffer_buf_tojson">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.2</span>
 </div>
@@ -8306,21 +8820,21 @@ buf2.swap64();
 this function when stringifying a <code>Buffer</code> instance.</p>
 <p><code>Buffer.from()</code> accepts objects in the format returned from this method.
 In particular, <code>Buffer.from(buf.toJSON())</code> works like <code>Buffer.from(buf)</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>]);
-<span class="hljs-keyword">const</span> json = <span class="hljs-built_in">JSON</span>.stringify(buf);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>]);
+<span class="hljs-keyword">const</span> json = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(buf);
 
-<span class="hljs-built_in">console</span>.log(json);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(json);
 <span class="hljs-comment">// Prints: {"type":"Buffer","data":[1,2,3,4,5]}</span>
 
-<span class="hljs-keyword">const</span> copy = <span class="hljs-built_in">JSON</span>.parse(json, <span class="hljs-function">(<span class="hljs-params">key, value</span>) =></span> {
-  <span class="hljs-keyword">return</span> value &#x26;&#x26; value.type === <span class="hljs-string">'Buffer'</span> ?
-    Buffer.from(value) :
+<span class="hljs-keyword">const</span> copy = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(json, <span class="hljs-function">(<span class="hljs-params">key, value</span>) =></span> {
+  <span class="hljs-keyword">return</span> value &#x26;&#x26; value.<span class="hljs-property">type</span> === <span class="hljs-string">'Buffer'</span> ?
+    <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(value) :
     value;
 });
 
-<span class="hljs-built_in">console</span>.log(copy);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(copy);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05></span></code></pre>
-<h3><code>buf.toString([encoding[, start[, end]]])</code><span><a class="mark" href="#buffer_buf_tostring_encoding_start_end" id="buffer_buf_tostring_encoding_start_end">#</a></span></h3>
+<h4><code>buf.toString([encoding[, start[, end]]])</code><span><a class="mark" href="#buffer_buf_tostring_encoding_start_end" id="buffer_buf_tostring_encoding_start_end">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -8337,27 +8851,27 @@ In particular, <code>Buffer.from(buf.toJSON())</code> works like <code>Buffer.fr
 then each invalid byte is replaced with the replacement character <code>U+FFFD</code>.</p>
 <p>The maximum length of a string instance (in UTF-16 code units) is available
 as <a href="#buffer_buffer_constants_max_string_length"><code>buffer.constants.MAX_STRING_LENGTH</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">26</span>; i++) {
   <span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
   buf1[i] = i + <span class="hljs-number">97</span>;
 }
 
-<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'utf8'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: abcdefghijklmnopqrstuvwxyz</span>
-<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>));
 <span class="hljs-comment">// Prints: abcde</span>
 
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'tést'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'tést'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: 74c3a97374</span>
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
 <span class="hljs-comment">// Prints: té</span>
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-literal">undefined</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-literal">undefined</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
 <span class="hljs-comment">// Prints: té</span></code></pre>
-<h3><code>buf.values()</code><span><a class="mark" href="#buffer_buf_values" id="buffer_buf_values">#</a></span></h3>
+<h4><code>buf.values()</code><span><a class="mark" href="#buffer_buf_values" id="buffer_buf_values">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.1.0</span>
 </div>
@@ -8366,10 +8880,10 @@ as <a href="#buffer_buffer_constants_max_string_length"><code>buffer.constants.M
 </ul>
 <p>Creates and returns an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">iterator</a> for <code>buf</code> values (bytes). This function is
 called automatically when a <code>Buffer</code> is used in a <code>for..of</code> statement.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> value <span class="hljs-keyword">of</span> buf.values()) {
-  <span class="hljs-built_in">console</span>.log(value);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> value <span class="hljs-keyword">of</span> buf.<span class="hljs-title function_">values</span>()) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   98</span>
@@ -8380,7 +8894,7 @@ called automatically when a <code>Buffer</code> is used in a <code>for..of</code
 <span class="hljs-comment">//   114</span>
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> value <span class="hljs-keyword">of</span> buf) {
-  <span class="hljs-built_in">console</span>.log(value);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   98</span>
@@ -8389,7 +8903,7 @@ called automatically when a <code>Buffer</code> is used in a <code>for..of</code
 <span class="hljs-comment">//   102</span>
 <span class="hljs-comment">//   101</span>
 <span class="hljs-comment">//   114</span></code></pre>
-<h3><code>buf.write(string[, offset[, length]][, encoding])</code><span><a class="mark" href="#buffer_buf_write_string_offset_length_encoding" id="buffer_buf_write_string_offset_length_encoding">#</a></span></h3>
+<h4><code>buf.write(string[, offset[, length]][, encoding])</code><span><a class="mark" href="#buffer_buf_write_string_offset_length_encoding" id="buffer_buf_write_string_offset_length_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -8406,22 +8920,22 @@ exceed <code>buf.length - offset</code>). <strong>Default:</strong> <code>buf.le
 <code>encoding</code>. The <code>length</code> parameter is the number of bytes to write. If <code>buf</code> did
 not contain enough space to fit the entire string, only part of <code>string</code> will be
 written. However, partially encoded characters will not be written.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">256</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">256</span>);
 
-<span class="hljs-keyword">const</span> len = buf.write(<span class="hljs-string">'\u00bd + \u00bc = \u00be'</span>, <span class="hljs-number">0</span>);
+<span class="hljs-keyword">const</span> len = buf.<span class="hljs-title function_">write</span>(<span class="hljs-string">'\u00bd + \u00bc = \u00be'</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${len}</span> bytes: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, len)}</span>`</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${len}</span> bytes: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, len)}</span>`</span>);
 <span class="hljs-comment">// Prints: 12 bytes: ½ + ¼ = ¾</span>
 
-<span class="hljs-keyword">const</span> buffer = Buffer.alloc(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
 
-<span class="hljs-keyword">const</span> length = buffer.write(<span class="hljs-string">'abcd'</span>, <span class="hljs-number">8</span>);
+<span class="hljs-keyword">const</span> length = buffer.<span class="hljs-title function_">write</span>(<span class="hljs-string">'abcd'</span>, <span class="hljs-number">8</span>);
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${length}</span> bytes: <span class="hljs-subst">${buffer.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">8</span>, <span class="hljs-number">10</span>)}</span>`</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${length}</span> bytes: <span class="hljs-subst">${buffer.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">8</span>, <span class="hljs-number">10</span>)}</span>`</span>);
 <span class="hljs-comment">// Prints: 2 bytes : ab</span></code></pre>
-<h3><code>buf.writeBigInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64be_value_offset" id="buffer_buf_writebigint64be_value_offset">#</a></span></h3>
+<h4><code>buf.writeBigInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64be_value_offset" id="buffer_buf_writebigint64be_value_offset">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> Number to be written to <code>buf</code>.</li>
@@ -8431,13 +8945,13 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>
 <p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeBigInt64BE(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeBigInt64BE</span>(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05 06 07 08></span></code></pre>
-<h3><code>buf.writeBigInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64le_value_offset" id="buffer_buf_writebigint64le_value_offset">#</a></span></h3>
+<h4><code>buf.writeBigInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64le_value_offset" id="buffer_buf_writebigint64le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0, v10.20.0</span>
 </div>
@@ -8449,18 +8963,18 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian.</p>
 <p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeBigInt64LE(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeBigInt64LE</span>(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 08 07 06 05 04 03 02 01></span></code></pre>
-<h3><code>buf.writeBigUInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64be_value_offset" id="buffer_buf_writebiguint64be_value_offset">#</a></span></h3>
+<h4><code>buf.writeBigUInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64be_value_offset" id="buffer_buf_writebiguint64be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>This function is also available as <code>buf.writeBigUint64BE()</code>.</p></td></tr>
 <tr><td>v12.0.0, v10.20.0</td>
 <td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
@@ -8474,21 +8988,22 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <code>offset</code> plus the number of bytes written.</li>
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<p>This function is also available under the <code>writeBigUint64BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeBigUInt64BE(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeBigUInt64BE</span>(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer de ca fa fe ca ce fa de></span></code></pre>
-<h3><code>buf.writeBigUInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64le_value_offset" id="buffer_buf_writebiguint64le_value_offset">#</a></span></h3>
+<h4><code>buf.writeBigUInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64le_value_offset" id="buffer_buf_writebiguint64le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>This function is also available as <code>buf.writeBigUint64LE()</code>.</p></td></tr>
-<tr><td>v12.0.0</td>
-<td><p><span>Added in: v12.0.0</span></p></td></tr>
+<tr><td>v12.0.0, v10.20.0</td>
+<td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -8499,13 +9014,14 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <code>offset</code> plus the number of bytes written.</li>
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeBigUInt64LE(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeBigUInt64LE</span>(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer de fa ce ca fe fa ca de></span></code></pre>
-<h3><code>buf.writeDoubleBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublebe_value_offset" id="buffer_buf_writedoublebe_value_offset">#</a></span></h3>
+<p>This function is also available under the <code>writeBigUint64LE</code> alias.</p>
+<h4><code>buf.writeDoubleBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublebe_value_offset" id="buffer_buf_writedoublebe_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8526,13 +9042,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
 must be a JavaScript number. Behavior is undefined when <code>value</code> is anything
 other than a JavaScript number.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeDoubleBE(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeDoubleBE</span>(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 40 5e dd 2f 1a 9f be 77></span></code></pre>
-<h3><code>buf.writeDoubleLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublele_value_offset" id="buffer_buf_writedoublele_value_offset">#</a></span></h3>
+<h4><code>buf.writeDoubleLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublele_value_offset" id="buffer_buf_writedoublele_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8553,13 +9069,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
 must be a JavaScript number. Behavior is undefined when <code>value</code> is anything
 other than a JavaScript number.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeDoubleLE(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeDoubleLE</span>(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 77 be 9f 1a 2f dd 5e 40></span></code></pre>
-<h3><code>buf.writeFloatBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatbe_value_offset" id="buffer_buf_writefloatbe_value_offset">#</a></span></h3>
+<h4><code>buf.writeFloatBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatbe_value_offset" id="buffer_buf_writefloatbe_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8579,14 +9095,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. Behavior is
 undefined when <code>value</code> is anything other than a JavaScript number.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeFloatBE(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeFloatBE</span>(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
-<span class="hljs-comment">// Prints: &#x3C;Buffer 4f 4a fe bb></span>
-</code></pre>
-<h3><code>buf.writeFloatLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatle_value_offset" id="buffer_buf_writefloatle_value_offset">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
+<span class="hljs-comment">// Prints: &#x3C;Buffer 4f 4a fe bb></span></code></pre>
+<h4><code>buf.writeFloatLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatle_value_offset" id="buffer_buf_writefloatle_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8606,13 +9121,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. Behavior is
 undefined when <code>value</code> is anything other than a JavaScript number.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeFloatLE(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeFloatLE</span>(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer bb fe 4a 4f></span></code></pre>
-<h3><code>buf.writeInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint8_value_offset" id="buffer_buf_writeint8_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint8_value_offset" id="buffer_buf_writeint8_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8634,14 +9149,14 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 1</code>. <strong>Default:</
 signed 8-bit integer. Behavior is undefined when <code>value</code> is anything other than
 a signed 8-bit integer.</p>
 <p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">2</span>);
 
-buf.writeInt8(<span class="hljs-number">2</span>, <span class="hljs-number">0</span>);
-buf.writeInt8(<span class="hljs-number">-2</span>, <span class="hljs-number">1</span>);
+buf.<span class="hljs-title function_">writeInt8</span>(<span class="hljs-number">2</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt8</span>(-<span class="hljs-number">2</span>, <span class="hljs-number">1</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 02 fe></span></code></pre>
-<h3><code>buf.writeInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16be_value_offset" id="buffer_buf_writeint16be_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16be_value_offset" id="buffer_buf_writeint16be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8663,13 +9178,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 must be a valid signed 16-bit integer. Behavior is undefined when <code>value</code> is
 anything other than a signed 16-bit integer.</p>
 <p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">2</span>);
 
-buf.writeInt16BE(<span class="hljs-number">0x0102</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt16BE</span>(<span class="hljs-number">0x0102</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02></span></code></pre>
-<h3><code>buf.writeInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16le_value_offset" id="buffer_buf_writeint16le_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16le_value_offset" id="buffer_buf_writeint16le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8691,13 +9206,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 must be a valid signed 16-bit integer. Behavior is undefined when <code>value</code> is
 anything other than a signed 16-bit integer.</p>
 <p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">2</span>);
 
-buf.writeInt16LE(<span class="hljs-number">0x0304</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt16LE</span>(<span class="hljs-number">0x0304</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 04 03></span></code></pre>
-<h3><code>buf.writeInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32be_value_offset" id="buffer_buf_writeint32be_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32be_value_offset" id="buffer_buf_writeint32be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8719,13 +9234,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 must be a valid signed 32-bit integer. Behavior is undefined when <code>value</code> is
 anything other than a signed 32-bit integer.</p>
 <p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeInt32BE(<span class="hljs-number">0x01020304</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt32BE</span>(<span class="hljs-number">0x01020304</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04></span></code></pre>
-<h3><code>buf.writeInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32le_value_offset" id="buffer_buf_writeint32le_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32le_value_offset" id="buffer_buf_writeint32le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8747,13 +9262,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 must be a valid signed 32-bit integer. Behavior is undefined when <code>value</code> is
 anything other than a signed 32-bit integer.</p>
 <p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeInt32LE(<span class="hljs-number">0x05060708</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt32LE</span>(<span class="hljs-number">0x05060708</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 08 07 06 05></span></code></pre>
-<h3><code>buf.writeIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintbe_value_offset_bytelength" id="buffer_buf_writeintbe_value_offset_bytelength">#</a></span></h3>
+<h4><code>buf.writeIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintbe_value_offset_bytelength" id="buffer_buf_writeintbe_value_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8776,14 +9291,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
 as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when
 <code>value</code> is anything other than a signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">6</span>);
 
-buf.writeIntBE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
+buf.<span class="hljs-title function_">writeIntBE</span>(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
-<span class="hljs-comment">// Prints: &#x3C;Buffer 12 34 56 78 90 ab></span>
-</code></pre>
-<h3><code>buf.writeIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintle_value_offset_bytelength" id="buffer_buf_writeintle_value_offset_bytelength">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
+<span class="hljs-comment">// Prints: &#x3C;Buffer 12 34 56 78 90 ab></span></code></pre>
+<h4><code>buf.writeIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintle_value_offset_bytelength" id="buffer_buf_writeintle_value_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -8806,18 +9320,18 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
 as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
 when <code>value</code> is anything other than a signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">6</span>);
 
-buf.writeIntLE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
+buf.<span class="hljs-title function_">writeIntLE</span>(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer ab 90 78 56 34 12></span></code></pre>
-<h3><code>buf.writeUInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint8_value_offset" id="buffer_buf_writeuint8_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint8_value_offset" id="buffer_buf_writeuint8_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUint8()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -8835,21 +9349,22 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 1</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code>. <code>value</code> must be a
 valid unsigned 8-bit integer. Behavior is undefined when <code>value</code> is anything
 other than an unsigned 8-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint8</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt8(<span class="hljs-number">0x3</span>, <span class="hljs-number">0</span>);
-buf.writeUInt8(<span class="hljs-number">0x4</span>, <span class="hljs-number">1</span>);
-buf.writeUInt8(<span class="hljs-number">0x23</span>, <span class="hljs-number">2</span>);
-buf.writeUInt8(<span class="hljs-number">0x42</span>, <span class="hljs-number">3</span>);
+buf.<span class="hljs-title function_">writeUInt8</span>(<span class="hljs-number">0x3</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt8</span>(<span class="hljs-number">0x4</span>, <span class="hljs-number">1</span>);
+buf.<span class="hljs-title function_">writeUInt8</span>(<span class="hljs-number">0x23</span>, <span class="hljs-number">2</span>);
+buf.<span class="hljs-title function_">writeUInt8</span>(<span class="hljs-number">0x42</span>, <span class="hljs-number">3</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 03 04 23 42></span></code></pre>
-<h3><code>buf.writeUInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16be_value_offset" id="buffer_buf_writeuint16be_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16be_value_offset" id="buffer_buf_writeuint16be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUint16BE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -8867,19 +9382,20 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
 must be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code>
 is anything other than an unsigned 16-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint16BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt16BE(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
-buf.writeUInt16BE(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
+buf.<span class="hljs-title function_">writeUInt16BE</span>(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt16BE</span>(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer de ad be ef></span></code></pre>
-<h3><code>buf.writeUInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16le_value_offset" id="buffer_buf_writeuint16le_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16le_value_offset" id="buffer_buf_writeuint16le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0, v12.19.0</td>
 <td><p>This function is also available as <code>buf.writeUint16LE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -8897,19 +9413,20 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
 must be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code> is
 anything other than an unsigned 16-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint16LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt16LE(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
-buf.writeUInt16LE(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
+buf.<span class="hljs-title function_">writeUInt16LE</span>(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt16LE</span>(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer ad de ef be></span></code></pre>
-<h3><code>buf.writeUInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32be_value_offset" id="buffer_buf_writeuint32be_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32be_value_offset" id="buffer_buf_writeuint32be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUint32BE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -8927,18 +9444,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
 must be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code>
 is anything other than an unsigned 32-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint32BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt32BE(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt32BE</span>(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer fe ed fa ce></span></code></pre>
-<h3><code>buf.writeUInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32le_value_offset" id="buffer_buf_writeuint32le_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32le_value_offset" id="buffer_buf_writeuint32le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUint32LE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -8956,18 +9474,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
 must be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code> is
 anything other than an unsigned 32-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint32LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt32LE(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt32LE</span>(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer ce fa ed fe></span></code></pre>
-<h3><code>buf.writeUIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintbe_value_offset_bytelength" id="buffer_buf_writeuintbe_value_offset_bytelength">#</a></span></h3>
+<h4><code>buf.writeUIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintbe_value_offset_bytelength" id="buffer_buf_writeuintbe_value_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUintBE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
@@ -8987,18 +9506,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
 as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined
 when <code>value</code> is anything other than an unsigned integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
+<p>This function is also available under the <code>writeUintBE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">6</span>);
 
-buf.writeUIntBE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
+buf.<span class="hljs-title function_">writeUIntBE</span>(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 12 34 56 78 90 ab></span></code></pre>
-<h3><code>buf.writeUIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintle_value_offset_bytelength" id="buffer_buf_writeuintle_value_offset_bytelength">#</a></span></h3>
+<h4><code>buf.writeUIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintle_value_offset_bytelength" id="buffer_buf_writeuintle_value_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUintLE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
@@ -9018,13 +9538,14 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
 as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
 when <code>value</code> is anything other than an unsigned integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
+<p>This function is also available under the <code>writeUintLE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">6</span>);
 
-buf.writeUIntLE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
+buf.<span class="hljs-title function_">writeUIntLE</span>(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer ab 90 78 56 34 12></span></code></pre>
-<h3><code>new Buffer(array)</code><span><a class="mark" href="#buffer_new_buffer_array" id="buffer_new_buffer_array">#</a></span></h3>
+<h4><code>new Buffer(array)</code><span><a class="mark" href="#buffer_new_buffer_array" id="buffer_new_buffer_array">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -9045,7 +9566,7 @@ buf.writeUIntLE(<span class="hljs-number">0x1234567890ab</span>, <span class="hl
 <li><code>array</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer[]></a> An array of bytes to copy from.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_from_array"><code>Buffer.from(array)</code></a>.</p>
-<h3><code>new Buffer(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_new_buffer_arraybuffer_byteoffset_length" id="buffer_new_buffer_arraybuffer_byteoffset_length">#</a></span></h3>
+<h4><code>new Buffer(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_new_buffer_arraybuffer_byteoffset_length" id="buffer_new_buffer_arraybuffer_byteoffset_length">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -9077,7 +9598,7 @@ instead.</div><p></p>
 </ul>
 <p>See
 <a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a>.</p>
-<h3><code>new Buffer(buffer)</code><span><a class="mark" href="#buffer_new_buffer_buffer" id="buffer_new_buffer_buffer">#</a></span></h3>
+<h4><code>new Buffer(buffer)</code><span><a class="mark" href="#buffer_new_buffer_buffer" id="buffer_new_buffer_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -9099,7 +9620,7 @@ instead.</div><p></p>
 which to copy data.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_from_buffer"><code>Buffer.from(buffer)</code></a>.</p>
-<h3><code>new Buffer(size)</code><span><a class="mark" href="#buffer_new_buffer_size" id="buffer_new_buffer_size">#</a></span></h3>
+<h4><code>new Buffer(size)</code><span><a class="mark" href="#buffer_new_buffer_size" id="buffer_new_buffer_size">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -9124,7 +9645,7 @@ which to copy data.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> and <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>. This variant of the
 constructor is equivalent to <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a>.</p>
-<h3><code>new Buffer(string[, encoding])</code><span><a class="mark" href="#buffer_new_buffer_string_encoding" id="buffer_new_buffer_string_encoding">#</a></span></h3>
+<h4><code>new Buffer(string[, encoding])</code><span><a class="mark" href="#buffer_new_buffer_string_encoding" id="buffer_new_buffer_string_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -9147,11 +9668,43 @@ Use <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.fro
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The encoding of <code>string</code>. <strong>Default:</strong> <code>'utf8'</code>.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string[, encoding])</code></a>.</p>
-<h2><code>buffer</code> module APIs<span><a class="mark" href="#buffer_buffer_module_apis" id="buffer_buffer_module_apis">#</a></span></h2>
+</section><section><h3><code>buffer</code> module APIs<span><a class="mark" href="#buffer_buffer_module_apis" id="buffer_buffer_module_apis">#</a></span></h3>
 <p>While, the <code>Buffer</code> object is available as a global, there are additional
 <code>Buffer</code>-related APIs that are available only via the <code>buffer</code> module
 accessed using <code>require('buffer')</code>.</p>
-<h3><code>buffer.INSPECT_MAX_BYTES</code><span><a class="mark" href="#buffer_buffer_inspect_max_bytes" id="buffer_buffer_inspect_max_bytes">#</a></span></h3>
+<h4><code>buffer.atob(data)</code><span><a class="mark" href="#buffer_buffer_atob_data" id="buffer_buffer_atob_data">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The Base64-encoded input string.</li>
+</ul>
+<p>Decodes a string of Base64-encoded data into bytes, and encodes those bytes
+into a string using Latin-1 (ISO-8859-1).</p>
+<p>The <code>data</code> may be any JavaScript-value that can be coerced into a string.</p>
+<p><strong>This function is only provided for compatibility with legacy web platform APIs
+and should never be used in new code, because they use strings to represent
+binary data and predate the introduction of typed arrays in JavaScript.
+For code running using Node.js APIs, converting between base64-encoded strings
+and binary data should be performed using <code>Buffer.from(str, 'base64')</code> and
+<code>buf.toString('base64')</code>.</strong></p>
+<h4><code>buffer.btoa(data)</code><span><a class="mark" href="#buffer_buffer_btoa_data" id="buffer_buffer_btoa_data">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> An ASCII (Latin1) string.</li>
+</ul>
+<p>Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes
+into a string using Base64.</p>
+<p>The <code>data</code> may be any JavaScript-value that can be coerced into a string.</p>
+<p><strong>This function is only provided for compatibility with legacy web platform APIs
+and should never be used in new code, because they use strings to represent
+binary data and predate the introduction of typed arrays in JavaScript.
+For code running using Node.js APIs, converting between base64-encoded strings
+and binary data should be performed using <code>Buffer.from(str, 'base64')</code> and
+<code>buf.toString('base64')</code>.</strong></p>
+<h4><code>buffer.INSPECT_MAX_BYTES</code><span><a class="mark" href="#buffer_buffer_inspect_max_bytes" id="buffer_buffer_inspect_max_bytes">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.4</span>
 </div>
@@ -9161,7 +9714,7 @@ accessed using <code>require('buffer')</code>.</p>
 <p>Returns the maximum number of bytes that will be returned when
 <code>buf.inspect()</code> is called. This can be overridden by user modules. See
 <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a> for more details on <code>buf.inspect()</code> behavior.</p>
-<h3><code>buffer.kMaxLength</code><span><a class="mark" href="#buffer_buffer_kmaxlength" id="buffer_buffer_kmaxlength">#</a></span></h3>
+<h4><code>buffer.kMaxLength</code><span><a class="mark" href="#buffer_buffer_kmaxlength" id="buffer_buffer_kmaxlength">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
@@ -9169,7 +9722,15 @@ accessed using <code>require('buffer')</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The largest size allowed for a single <code>Buffer</code> instance.</li>
 </ul>
 <p>An alias for <a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a>.</p>
-<h3><code>buffer.transcode(source, fromEnc, toEnc)</code><span><a class="mark" href="#buffer_buffer_transcode_source_fromenc_toenc" id="buffer_buffer_transcode_source_fromenc_toenc">#</a></span></h3>
+<h4><code>buffer.kStringMaxLength</code><span><a class="mark" href="#buffer_buffer_kstringmaxlength" id="buffer_buffer_kstringmaxlength">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v3.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The largest length allowed for a single <code>string</code> instance.</li>
+</ul>
+<p>An alias for <a href="#buffer_buffer_constants_max_string_length"><code>buffer.constants.MAX_STRING_LENGTH</code></a>.</p>
+<h4><code>buffer.transcode(source, fromEnc, toEnc)</code><span><a class="mark" href="#buffer_buffer_transcode_source_fromenc_toenc" id="buffer_buffer_transcode_source_fromenc_toenc">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -9197,12 +9758,12 @@ conversion from <code>fromEnc</code> to <code>toEnc</code> is not permitted.</p>
 sequence cannot be adequately represented in the target encoding. For instance:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> buffer = <span class="hljs-built_in">require</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">const</span> newBuf = buffer.transcode(Buffer.from(<span class="hljs-string">'€'</span>), <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'ascii'</span>);
-<span class="hljs-built_in">console</span>.log(newBuf.toString(<span class="hljs-string">'ascii'</span>));
+<span class="hljs-keyword">const</span> newBuf = buffer.<span class="hljs-title function_">transcode</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'€'</span>), <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'ascii'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(newBuf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'ascii'</span>));
 <span class="hljs-comment">// Prints: '?'</span></code></pre>
 <p>Because the Euro (<code>€</code>) sign is not representable in US-ASCII, it is replaced
 with <code>?</code> in the transcoded <code>Buffer</code>.</p>
-<h3>Class: <code>SlowBuffer</code><span><a class="mark" href="#buffer_class_slowbuffer" id="buffer_class_slowbuffer">#</a></span></h3>
+<h4>Class: <code>SlowBuffer</code><span><a class="mark" href="#buffer_class_slowbuffer" id="buffer_class_slowbuffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Deprecated since: v6.0.0</span>
 </div>
@@ -9210,7 +9771,7 @@ with <code>?</code> in the transcoded <code>Buffer</code>.</p>
 <p>See <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>. This was never a class in the sense that
 the constructor always returned a <code>Buffer</code> instance, rather than a <code>SlowBuffer</code>
 instance.</p>
-<h4><code>new SlowBuffer(size)</code><span><a class="mark" href="#buffer_new_slowbuffer_size" id="buffer_new_slowbuffer_size">#</a></span></h4>
+<h5><code>new SlowBuffer(size)</code><span><a class="mark" href="#buffer_new_slowbuffer_size" id="buffer_new_slowbuffer_size">#</a></span></h5>
 <div class="api_metadata">
 <span>Deprecated since: v6.0.0</span>
 </div>
@@ -9219,21 +9780,30 @@ instance.</p>
 <li><code>size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The desired length of the new <code>SlowBuffer</code>.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>.</p>
-<h3>Buffer constants<span><a class="mark" href="#buffer_buffer_constants" id="buffer_buffer_constants">#</a></span></h3>
+<h4>Buffer constants<span><a class="mark" href="#buffer_buffer_constants" id="buffer_buffer_constants">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 </div>
-<h4><code>buffer.constants.MAX_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_length" id="buffer_buffer_constants_max_length">#</a></span></h4>
+<h5><code>buffer.constants.MAX_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_length" id="buffer_buffer_constants_max_length">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.2.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Value is changed from 2<sup>31</sup> - 1 to 2<sup>32</sup> - 1 on 64-bit architectures.</p></td></tr>
+<tr><td>v8.2.0</td>
+<td><p><span>Added in: v8.2.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The largest size allowed for a single <code>Buffer</code> instance.</li>
 </ul>
-<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).
-On 64-bit architectures, this value currently is 2<sup>31</sup> - 1 (~2GB).</p>
+<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).</p>
+<p>On 64-bit architectures, this value currently is 2<sup>32</sup> - 1 (~4GB).</p>
+<p>It reflects <a href="https://v8.github.io/api/head/classv8_1_1TypedArray.html#a54a48f4373da0850663c4393d843b9b0"><code>v8::TypedArray::kMaxLength</code></a> under the hood.</p>
 <p>This value is also available as <a href="#buffer_buffer_kmaxlength"><code>buffer.kMaxLength</code></a>.</p>
-<h4><code>buffer.constants.MAX_STRING_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_string_length" id="buffer_buffer_constants_max_string_length">#</a></span></h4>
+<h5><code>buffer.constants.MAX_STRING_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_string_length" id="buffer_buffer_constants_max_string_length">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 </div>
@@ -9243,7 +9813,7 @@ On 64-bit architectures, this value currently is 2<sup>31</sup> - 1 (~2GB).</p>
 <p>Represents the largest <code>length</code> that a <code>string</code> primitive can have, counted
 in UTF-16 code units.</p>
 <p>This value may depend on the JS engine that is being used.</p>
-<h2><code>Buffer.from()</code>, <code>Buffer.alloc()</code>, and <code>Buffer.allocUnsafe()</code><span><a class="mark" href="#buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe" id="buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe">#</a></span></h2>
+</section><section><h3><code>Buffer.from()</code>, <code>Buffer.alloc()</code>, and <code>Buffer.allocUnsafe()</code><span><a class="mark" href="#buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe" id="buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe">#</a></span></h3>
 <p>In versions of Node.js prior to 6.0.0, <code>Buffer</code> instances were created using the
 <code>Buffer</code> constructor function, which allocates the returned <code>Buffer</code>
 differently based on what arguments are provided:</p>
@@ -9312,21 +9882,21 @@ potentially sensitive.</li>
 if <code>size</code> is less than or equal to half <a href="#buffer_class_property_buffer_poolsize"><code>Buffer.poolSize</code></a>. Instances
 returned by <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a> <em>never</em> use the shared internal
 memory pool.</p>
-<h3>The <code>--zero-fill-buffers</code> command line option<span><a class="mark" href="#buffer_the_zero_fill_buffers_command_line_option" id="buffer_the_zero_fill_buffers_command_line_option">#</a></span></h3>
+<h4>The <code>--zero-fill-buffers</code> command-line option<span><a class="mark" href="#buffer_the_zero_fill_buffers_command_line_option" id="buffer_the_zero_fill_buffers_command_line_option">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
-<p>Node.js can be started using the <code>--zero-fill-buffers</code> command line option to
+<p>Node.js can be started using the <code>--zero-fill-buffers</code> command-line option to
 cause all newly-allocated <code>Buffer</code> instances to be zero-filled upon creation by
 default. Without the option, buffers created with <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>,
 <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>, and <code>new SlowBuffer(size)</code> are not zero-filled.
 Use of this flag can have a measurable negative impact on performance. Use the
 <code>--zero-fill-buffers</code> option only when necessary to enforce that newly allocated
 <code>Buffer</code> instances cannot contain old data that is potentially sensitive.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --zero-fill-buffers</span>
-<span class="hljs-meta">></span><span class="bash"> Buffer.allocUnsafe(5);</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --zero-fill-buffers</span>
+<span class="hljs-meta">> </span><span class="language-bash">Buffer.allocUnsafe(5);</span>
 &#x3C;Buffer 00 00 00 00 00></code></pre>
-<h3>What makes <code>Buffer.allocUnsafe()</code> and <code>Buffer.allocUnsafeSlow()</code> "unsafe"?<span><a class="mark" href="#buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe" id="buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe">#</a></span></h3>
+<h4>What makes <code>Buffer.allocUnsafe()</code> and <code>Buffer.allocUnsafeSlow()</code> "unsafe"?<span><a class="mark" href="#buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe" id="buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe">#</a></span></h4>
 <p>When calling <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> and <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>, the
 segment of allocated memory is <em>uninitialized</em> (it is not zeroed-out). While
 this design makes the allocation of memory quite fast, the allocated segment of
@@ -9335,22 +9905,24 @@ created by <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.
 memory can allow this old data to be leaked when the <code>Buffer</code> memory is read.</p>
 <p>While there are clear performance advantages to using
 <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>, extra care <em>must</em> be taken in order to avoid
-introducing security vulnerabilities into an application.</p>
-<h1>C++ addons<span><a class="mark" href="#addons_c_addons" id="addons_c_addons">#</a></span></h1>
+introducing security vulnerabilities into an application.</p></section>
+        </section>
+<section><h2>C++ addons<span><a class="mark" href="#addons_c_addons" id="addons_c_addons">#</a></span></h2>
 
 
 <p><em>Addons</em> are dynamically-linked shared objects written in C++. The
 <a href="#modules_require_id"><code>require()</code></a> function can load addons as ordinary Node.js modules.
 Addons provide an interface between JavaScript and C/C++ libraries.</p>
-<p>There are three options for implementing addons: N-API, nan, or direct
+<p>There are three options for implementing addons: Node-API, nan, or direct
 use of internal V8, libuv and Node.js libraries. Unless there is a need for
-direct access to functionality which is not exposed by N-API, use N-API.
-Refer to <a href="n-api.html">C/C++ addons with N-API</a> for more information on N-API.</p>
-<p>When not using N-API, implementing addons is complicated,
+direct access to functionality which is not exposed by Node-API, use Node-API.
+Refer to <a href="n-api.html">C/C++ addons with Node-API</a> for more information on
+Node-API.</p>
+<p>When not using Node-API, implementing addons is complicated,
 involving knowledge of several components and APIs:</p>
 <ul>
 <li>
-<p>V8: the C++ library Node.js uses to provide the
+<p><a href="https://v8.dev/">V8</a>: the C++ library Node.js uses to provide the
 JavaScript implementation. V8 provides the mechanisms for creating objects,
 calling functions, etc. V8's API is documented mostly in the
 <code>v8.h</code> header file (<code>deps/v8/include/v8.h</code> in the Node.js source
@@ -9362,12 +9934,12 @@ threads and all of the asynchronous behaviors of the platform. It also
 serves as a cross-platform abstraction library, giving easy, POSIX-like
 access across all major operating systems to many common system tasks, such
 as interacting with the filesystem, sockets, timers, and system events. libuv
-also provides a pthreads-like threading abstraction that may be used to
-power more sophisticated asynchronous addons that need to move beyond the
-standard event loop. Addon authors are encouraged to think about how to
+also provides a threading abstraction similar to POSIX threads for
+more sophisticated asynchronous addons that need to move beyond the
+standard event loop. Addon authors should
 avoid blocking the event loop with I/O or other time-intensive tasks by
-off-loading work via libuv to non-blocking system operations, worker threads
-or a custom use of libuv's threads.</p>
+offloading work via libuv to non-blocking system operations, worker threads,
+or a custom use of libuv threads.</p>
 </li>
 <li>
 <p>Internal Node.js libraries. Node.js itself exports C++ APIs that addons can
@@ -9383,41 +9955,40 @@ re-exported by Node.js and may be used to various extents by addons. See
 </ul>
 <p>All of the following examples are available for <a href="https://github.com/nodejs/node-addon-examples">download</a> and may
 be used as the starting-point for an addon.</p>
-<h2>Hello world<span><a class="mark" href="#addons_hello_world" id="addons_hello_world">#</a></span></h2>
+<section><h3>Hello world<span><a class="mark" href="#addons_hello_world" id="addons_hello_world">#</a></span></h3>
 <p>This "Hello world" example is a simple addon, written in C++, that is the
 equivalent of the following JavaScript code:</p>
-<pre><code class="language-js"><span class="hljs-built_in">module</span>.exports.hello = <span class="hljs-function">() =></span> <span class="hljs-string">'world'</span>;</code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-property">hello</span> = <span class="hljs-function">() =></span> <span class="hljs-string">'world'</span>;</code></pre>
 <p>First, create the file <code>hello.cc</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// hello.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
 <span class="hljs-keyword">using</span> v8::FunctionCallbackInfo;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Method</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  args.GetReturnValue().Set(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"world"</span>, NewStringType::kNormal).ToLocalChecked());
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Method</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(
+      isolate, <span class="hljs-string">"world"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Initialize</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  NODE_SET_METHOD(exports, <span class="hljs-string">"hello"</span>, Method);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Initialize</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(exports, <span class="hljs-string">"hello"</span>, Method);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Initialize)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>All Node.js addons must export an initialization function following
 the pattern:</p>
-<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Initialize</span><span class="hljs-params">(Local&#x3C;Object> exports)</span></span>;
-NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)</code></pre>
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Initialize</span><span class="hljs-params">(Local&#x3C;Object> exports)</span></span>;
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Initialize)</code></pre>
 <p>There is no semi-colon after <code>NODE_MODULE</code> as it's not a function (see
 <code>node.h</code>).</p>
 <p>The <code>module_name</code> must match the filename of the final binary (excluding
@@ -9427,20 +9998,20 @@ and the addon module name is <code>addon</code>.</p>
 <p>When building addons with <code>node-gyp</code>, using the macro <code>NODE_GYP_MODULE_NAME</code> as
 the first parameter of <code>NODE_MODULE()</code> will ensure that the name of the final
 binary will be passed to <code>NODE_MODULE()</code>.</p>
-<h3>Context-aware addons<span><a class="mark" href="#addons_context_aware_addons" id="addons_context_aware_addons">#</a></span></h3>
+<h4>Context-aware addons<span><a class="mark" href="#addons_context_aware_addons" id="addons_context_aware_addons">#</a></span></h4>
 <p>There are environments in which Node.js addons may need to be loaded multiple
 times in multiple contexts. For example, the <a href="https://electronjs.org/">Electron</a> runtime runs multiple
 instances of Node.js in a single process. Each instance will have its own
 <code>require()</code> cache, and thus each instance will need a native addon to behave
-correctly when loaded via <code>require()</code>. From the addon's perspective, this means
-that it must support multiple initializations.</p>
+correctly when loaded via <code>require()</code>. This means that the addon
+must support multiple initializations.</p>
 <p>A context-aware addon can be constructed by using the macro
 <code>NODE_MODULE_INITIALIZER</code>, which expands to the name of a function which Node.js
 will expect to find when it loads an addon. An addon can thus be initialized as
 in the following example:</p>
 <pre><code class="language-cpp"><span class="hljs-keyword">using</span> <span class="hljs-keyword">namespace</span> v8;
 
-<span class="hljs-keyword">extern</span> <span class="hljs-string">"C"</span> <span class="hljs-function">NODE_MODULE_EXPORT <span class="hljs-keyword">void</span>
+<span class="hljs-keyword">extern</span> <span class="hljs-string">"C"</span> <span class="hljs-function">NODE_MODULE_EXPORT <span class="hljs-type">void</span>
 <span class="hljs-title">NODE_MODULE_INITIALIZER</span><span class="hljs-params">(Local&#x3C;Object> exports,
                         Local&#x3C;Value> <span class="hljs-keyword">module</span>,
                         Local&#x3C;Context> context)</span> </span>{
@@ -9471,7 +10042,7 @@ performing the following steps:</p>
 <ul>
 <li>Define a class which will hold per-addon-instance data and which has a static
 member of the form
-<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">DeleteInstance</span><span class="hljs-params">(<span class="hljs-keyword">void</span>* data)</span> </span>{
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">DeleteInstance</span><span class="hljs-params">(<span class="hljs-type">void</span>* data)</span> </span>{
   <span class="hljs-comment">// Cast `data` to an instance of the class and delete it.</span>
 }</code></pre>
 </li>
@@ -9492,61 +10063,60 @@ native-backed JavaScript functions. The third parameter of
 be called from JavaScript. The per-addon-instance data must also be passed into
 any asynchronous callbacks the addon may create.</p>
 <p>The following example illustrates the implementation of a context-aware addon:</p>
-<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">using</span> <span class="hljs-keyword">namespace</span> v8;
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">AddonData</span> {</span>
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">AddonData</span> {
  <span class="hljs-keyword">public</span>:
   <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">AddonData</span><span class="hljs-params">(Isolate* isolate)</span>:
-      <span class="hljs-title">call_count</span><span class="hljs-params">(<span class="hljs-number">0</span>)</span> </span>{
+      call_count(<span class="hljs-number">0</span>) {</span>
     <span class="hljs-comment">// Ensure this per-addon-instance data is deleted at environment cleanup.</span>
-    node::AddEnvironmentCleanupHook(isolate, DeleteInstance, <span class="hljs-keyword">this</span>);
+    node::<span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, DeleteInstance, <span class="hljs-keyword">this</span>);
   }
 
   <span class="hljs-comment">// Per-addon data.</span>
-  <span class="hljs-keyword">int</span> call_count;
+  <span class="hljs-type">int</span> call_count;
 
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">DeleteInstance</span><span class="hljs-params">(<span class="hljs-keyword">void</span>* data)</span> </span>{
-    <span class="hljs-keyword">delete</span> <span class="hljs-keyword">static_cast</span>&#x3C;AddonData*>(data);
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">DeleteInstance</span><span class="hljs-params">(<span class="hljs-type">void</span>* data)</span> </span>{
+    <span class="hljs-keyword">delete</span> <span class="hljs-built_in">static_cast</span>&#x3C;AddonData*>(data);
   }
 };
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Method</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; info)</span> </span>{
+<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">Method</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; info)</span> </span>{
   <span class="hljs-comment">// Retrieve the per-addon-instance data.</span>
   AddonData* data =
-      <span class="hljs-keyword">reinterpret_cast</span>&#x3C;AddonData*>(info.Data().As&#x3C;External>()->Value());
+      <span class="hljs-built_in">reinterpret_cast</span>&#x3C;AddonData*>(info.<span class="hljs-built_in">Data</span>().<span class="hljs-built_in">As</span>&#x3C;External>()-><span class="hljs-built_in">Value</span>());
   data->call_count++;
-  info.GetReturnValue().Set((<span class="hljs-keyword">double</span>)data->call_count);
+  info.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>((<span class="hljs-type">double</span>)data->call_count);
 }
 
 <span class="hljs-comment">// Initialize this addon to be context-aware.</span>
-NODE_MODULE_INIT(<span class="hljs-comment">/* exports, module, context */</span>) {
-  Isolate* isolate = context->GetIsolate();
+<span class="hljs-built_in">NODE_MODULE_INIT</span>(<span class="hljs-comment">/* exports, module, context */</span>) {
+  Isolate* isolate = context-><span class="hljs-built_in">GetIsolate</span>();
 
   <span class="hljs-comment">// Create a new instance of `AddonData` for this instance of the addon and</span>
   <span class="hljs-comment">// tie its life cycle to that of the Node.js environment.</span>
-  AddonData* data = <span class="hljs-keyword">new</span> AddonData(isolate);
+  AddonData* data = <span class="hljs-keyword">new</span> <span class="hljs-built_in">AddonData</span>(isolate);
 
   <span class="hljs-comment">// Wrap the data in a `v8::External` so we can pass it to the method we</span>
   <span class="hljs-comment">// expose.</span>
-  Local&#x3C;External> external = External::New(isolate, data);
+  Local&#x3C;External> external = External::<span class="hljs-built_in">New</span>(isolate, data);
 
   <span class="hljs-comment">// Expose the method `Method` to JavaScript, and make sure it receives the</span>
   <span class="hljs-comment">// per-addon-instance data we created above by passing `external` as the</span>
   <span class="hljs-comment">// third parameter to the `FunctionTemplate` constructor.</span>
-  exports->Set(context,
-               String::NewFromUtf8(isolate, <span class="hljs-string">"method"</span>, NewStringType::kNormal)
-                  .ToLocalChecked(),
-               FunctionTemplate::New(isolate, Method, external)
-                  ->GetFunction(context).ToLocalChecked()).FromJust();
+  exports-><span class="hljs-built_in">Set</span>(context,
+               String::<span class="hljs-built_in">NewFromUtf8</span>(isolate, <span class="hljs-string">"method"</span>).<span class="hljs-built_in">ToLocalChecked</span>(),
+               FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, Method, external)
+                  -><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>()).<span class="hljs-built_in">FromJust</span>();
 }</code></pre>
-<h4>Worker support<span><a class="mark" href="#addons_worker_support" id="addons_worker_support">#</a></span></h4>
+<h5>Worker support<span><a class="mark" href="#addons_worker_support" id="addons_worker_support">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.8.0</td>
 <td><p>Cleanup hooks may now be asynchronous.</p></td></tr>
 </tbody></table>
 </details>
@@ -9554,15 +10124,15 @@ NODE_MODULE_INIT(<span class="hljs-comment">/* exports, module, context */</span
 <p>In order to be loaded from multiple Node.js environments,
 such as a main thread and a Worker thread, an add-on needs to either:</p>
 <ul>
-<li>Be an N-API addon, or</li>
+<li>Be an Node-API addon, or</li>
 <li>Be declared as context-aware using <code>NODE_MODULE_INIT()</code> as described above</li>
 </ul>
 <p>In order to support <a href="#worker_threads_class_worker"><code>Worker</code></a> threads, addons need to clean up any resources
 they may have allocated when such a thread exists. This can be achieved through
 the usage of the <code>AddEnvironmentCleanupHook()</code> function:</p>
-<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">AddEnvironmentCleanupHook</span><span class="hljs-params">(v8::Isolate* isolate,
-                               <span class="hljs-keyword">void</span> (*fun)(<span class="hljs-keyword">void</span>* arg),
-                               <span class="hljs-keyword">void</span>* arg)</span></span>;</code></pre>
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">AddEnvironmentCleanupHook</span><span class="hljs-params">(v8::Isolate* isolate,
+                               <span class="hljs-type">void</span> (*fun)(<span class="hljs-type">void</span>* arg),
+                               <span class="hljs-type">void</span>* arg)</span></span>;</code></pre>
 <p>This function adds a hook that will run before a given Node.js instance shuts
 down. If necessary, such hooks can be removed before they are run using
 <code>RemoveEnvironmentCleanupHook()</code>, which has the same signature. Callbacks are
@@ -9573,9 +10143,9 @@ callback function. This can be used for shutting down asynchronous resources,
 such as any libuv handles registered by the addon.</p>
 <p>The following <code>addon.cc</code> uses <code>AddEnvironmentCleanupHook</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;assert.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;stdlib.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;assert.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;stdlib.h></span></span>
 
 <span class="hljs-keyword">using</span> node::AddEnvironmentCleanupHook;
 <span class="hljs-keyword">using</span> v8::HandleScope;
@@ -9584,54 +10154,54 @@ such as any libuv handles registered by the addon.</p>
 <span class="hljs-keyword">using</span> v8::Object;
 
 <span class="hljs-comment">// Note: In a real-world application, do not rely on static/global data.</span>
-<span class="hljs-keyword">static</span> <span class="hljs-keyword">char</span> cookie[] = <span class="hljs-string">"yum yum"</span>;
-<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> cleanup_cb1_called = <span class="hljs-number">0</span>;
-<span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> cleanup_cb2_called = <span class="hljs-number">0</span>;
+<span class="hljs-keyword">static</span> <span class="hljs-type">char</span> cookie[] = <span class="hljs-string">"yum yum"</span>;
+<span class="hljs-keyword">static</span> <span class="hljs-type">int</span> cleanup_cb1_called = <span class="hljs-number">0</span>;
+<span class="hljs-keyword">static</span> <span class="hljs-type">int</span> cleanup_cb2_called = <span class="hljs-number">0</span>;
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">cleanup_cb1</span><span class="hljs-params">(<span class="hljs-keyword">void</span>* arg)</span> </span>{
-  Isolate* isolate = <span class="hljs-keyword">static_cast</span>&#x3C;Isolate*>(arg);
+<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">cleanup_cb1</span><span class="hljs-params">(<span class="hljs-type">void</span>* arg)</span> </span>{
+  Isolate* isolate = <span class="hljs-built_in">static_cast</span>&#x3C;Isolate*>(arg);
   <span class="hljs-function">HandleScope <span class="hljs-title">scope</span><span class="hljs-params">(isolate)</span></span>;
-  Local&#x3C;Object> obj = Object::New(isolate);
-  assert(!obj.IsEmpty());  <span class="hljs-comment">// assert VM is still alive</span>
-  assert(obj->IsObject());
+  Local&#x3C;Object> obj = Object::<span class="hljs-built_in">New</span>(isolate);
+  <span class="hljs-built_in">assert</span>(!obj.<span class="hljs-built_in">IsEmpty</span>());  <span class="hljs-comment">// assert VM is still alive</span>
+  <span class="hljs-built_in">assert</span>(obj-><span class="hljs-built_in">IsObject</span>());
   cleanup_cb1_called++;
 }
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">cleanup_cb2</span><span class="hljs-params">(<span class="hljs-keyword">void</span>* arg)</span> </span>{
-  assert(arg == <span class="hljs-keyword">static_cast</span>&#x3C;<span class="hljs-keyword">void</span>*>(cookie));
+<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">cleanup_cb2</span><span class="hljs-params">(<span class="hljs-type">void</span>* arg)</span> </span>{
+  <span class="hljs-built_in">assert</span>(arg == <span class="hljs-built_in">static_cast</span>&#x3C;<span class="hljs-type">void</span>*>(cookie));
   cleanup_cb2_called++;
 }
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">sanity_check</span><span class="hljs-params">(<span class="hljs-keyword">void</span>*)</span> </span>{
-  assert(cleanup_cb1_called == <span class="hljs-number">1</span>);
-  assert(cleanup_cb2_called == <span class="hljs-number">1</span>);
+<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">sanity_check</span><span class="hljs-params">(<span class="hljs-type">void</span>*)</span> </span>{
+  <span class="hljs-built_in">assert</span>(cleanup_cb1_called == <span class="hljs-number">1</span>);
+  <span class="hljs-built_in">assert</span>(cleanup_cb2_called == <span class="hljs-number">1</span>);
 }
 
 <span class="hljs-comment">// Initialize this addon to be context-aware.</span>
-NODE_MODULE_INIT(<span class="hljs-comment">/* exports, module, context */</span>) {
-  Isolate* isolate = context->GetIsolate();
+<span class="hljs-built_in">NODE_MODULE_INIT</span>(<span class="hljs-comment">/* exports, module, context */</span>) {
+  Isolate* isolate = context-><span class="hljs-built_in">GetIsolate</span>();
 
-  AddEnvironmentCleanupHook(isolate, sanity_check, <span class="hljs-literal">nullptr</span>);
-  AddEnvironmentCleanupHook(isolate, cleanup_cb2, cookie);
-  AddEnvironmentCleanupHook(isolate, cleanup_cb1, isolate);
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, sanity_check, <span class="hljs-literal">nullptr</span>);
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, cleanup_cb2, cookie);
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, cleanup_cb1, isolate);
 }</code></pre>
 <p>Test in JavaScript by running:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);</code></pre>
-<h3>Building<span><a class="mark" href="#addons_building" id="addons_building">#</a></span></h3>
+<h4>Building<span><a class="mark" href="#addons_building" id="addons_building">#</a></span></h4>
 <p>Once the source code has been written, it must be compiled into the binary
 <code>addon.node</code> file. To do so, create a file called <code>binding.gyp</code> in the
 top-level of the project describing the build configuration of the module
 using a JSON-like format. This file is used by <a href="https://github.com/nodejs/node-gyp">node-gyp</a>, a tool written
 specifically to compile Node.js addons.</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"targets"</span>: [
-    {
-      <span class="hljs-attr">"target_name"</span>: <span class="hljs-string">"addon"</span>,
-      <span class="hljs-attr">"sources"</span>: [ <span class="hljs-string">"hello.cc"</span> ]
-    }
-  ]
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"targets"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"target_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"addon"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span> <span class="hljs-string">"hello.cc"</span> <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>A version of the <code>node-gyp</code> utility is bundled and distributed with
 Node.js as part of <code>npm</code>. This version is not made directly available for
 developers to use and is intended only to support the ability to use the
@@ -9653,7 +10223,7 @@ compiled version of the addon for the user's platform on demand.</p>
 <pre><code class="language-js"><span class="hljs-comment">// hello.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-built_in">console</span>.log(addon.hello());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(addon.<span class="hljs-title function_">hello</span>());
 <span class="hljs-comment">// Prints: 'world'</span></code></pre>
 <p>Because the exact path to the compiled addon binary can vary depending on how
 it is compiled (i.e. sometimes it may be in <code>./build/Debug/</code>), addons can use
@@ -9665,7 +10235,7 @@ locates addon modules, it is essentially using a <code>try…catch</code> patter
 } <span class="hljs-keyword">catch</span> (err) {
   <span class="hljs-keyword">return</span> <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Debug/addon.node'</span>);
 }</code></pre>
-<h3>Linking to libraries included with Node.js<span><a class="mark" href="#addons_linking_to_libraries_included_with_node_js" id="addons_linking_to_libraries_included_with_node_js">#</a></span></h3>
+<h4>Linking to libraries included with Node.js<span><a class="mark" href="#addons_linking_to_libraries_included_with_node_js" id="addons_linking_to_libraries_included_with_node_js">#</a></span></h4>
 <p>Node.js uses statically linked libraries such as V8, libuv and OpenSSL. All
 addons are required to link to V8 and may link to any of the other dependencies
 as well. Typically, this is as simple as including the appropriate
@@ -9677,8 +10247,8 @@ aware of:</p>
 <p>When <code>node-gyp</code> runs, it will detect the specific release version of Node.js
 and download either the full source tarball or just the headers. If the full
 source is downloaded, addons will have complete access to the full set of
-Node.js dependencies. However, if only the Node.js headers are downloaded, then
-only the symbols exported by Node.js will be available.</p>
+Node.js dependencies. However, if only the Node.js headers are downloaded,
+then only the symbols exported by Node.js will be available.</p>
 </li>
 <li>
 <p><code>node-gyp</code> can be run using the <code>--nodedir</code> flag pointing at a local Node.js
@@ -9686,7 +10256,7 @@ source image. Using this option, the addon will have access to the full set of
 dependencies.</p>
 </li>
 </ul>
-<h3>Loading addons using <code>require()</code><span><a class="mark" href="#addons_loading_addons_using_require" id="addons_loading_addons_using_require">#</a></span></h3>
+<h4>Loading addons using <code>require()</code><span><a class="mark" href="#addons_loading_addons_using_require" id="addons_loading_addons_using_require">#</a></span></h4>
 <p>The filename extension of the compiled addon binary is <code>.node</code> (as opposed
 to <code>.dll</code> or <code>.so</code>). The <a href="#modules_require_id"><code>require()</code></a> function is written to look for
 files with the <code>.node</code> file extension and initialize those as dynamically-linked
@@ -9698,7 +10268,7 @@ JavaScript files that happen to share the same base name. For instance, if
 there is a file <code>addon.js</code> in the same directory as the binary <code>addon.node</code>,
 then <a href="#modules_require_id"><code>require('addon')</code></a> will give precedence to the <code>addon.js</code> file
 and load it instead.</p>
-<h2>Native abstractions for Node.js<span><a class="mark" href="#addons_native_abstractions_for_node_js" id="addons_native_abstractions_for_node_js">#</a></span></h2>
+</section><section><h3>Native abstractions for Node.js<span><a class="mark" href="#addons_native_abstractions_for_node_js" id="addons_native_abstractions_for_node_js">#</a></span></h3>
 <p>Each of the examples illustrated in this document directly use the
 Node.js and V8 APIs for implementing addons. The V8 API can, and has, changed
 dramatically from one V8 release to the next (and one major Node.js release to
@@ -9708,11 +10278,11 @@ minimize the frequency and impact of such changes but there is little that
 Node.js can do to ensure stability of the V8 APIs.</p>
 <p>The <a href="https://github.com/nodejs/nan">Native Abstractions for Node.js</a> (or <code>nan</code>) provide a set of tools that
 addon developers are recommended to use to keep compatibility between past and
-future releases of V8 and Node.js. See the <code>nan</code> <a href="https://github.com/nodejs/nan/tree/master/examples/">examples</a> for an
+future releases of V8 and Node.js. See the <code>nan</code> <a href="https://github.com/nodejs/nan/tree/HEAD/examples/">examples</a> for an
 illustration of how it can be used.</p>
-<h2>N-API<span><a class="mark" href="#addons_n_api" id="addons_n_api">#</a></span></h2>
+</section><section><h3>Node-API<span><a class="mark" href="#addons_node_api" id="addons_node_api">#</a></span></h3>
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p>N-API is an API for building native addons. It is independent from
+<p>Node-API is an API for building native addons. It is independent from
 the underlying JavaScript runtime (e.g. V8) and is maintained as part of
 Node.js itself. This API will be Application Binary Interface (ABI) stable
 across versions of Node.js. It is intended to insulate addons from
@@ -9722,14 +10292,14 @@ recompilation. Addons are built/packaged with the same approach/tools
 outlined in this document (node-gyp, etc.). The only difference is the
 set of APIs that are used by the native code. Instead of using the V8
 or <a href="https://github.com/nodejs/nan">Native Abstractions for Node.js</a> APIs, the functions available
-in the N-API are used.</p>
+in the Node-API are used.</p>
 <p>Creating and maintaining an addon that benefits from the ABI stability
-provided by N-API carries with it certain
+provided by Node-API carries with it certain
 <a href="#n_api_implications_of_abi_stability">implementation considerations</a>.</p>
-<p>To use N-API in the above "Hello world" example, replace the content of
+<p>To use Node-API in the above "Hello world" example, replace the content of
 <code>hello.cc</code> with the following. All other instructions remain the same.</p>
-<pre><code class="language-cpp"><span class="hljs-comment">// hello.cc using N-API</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span>
+<pre><code class="language-cpp"><span class="hljs-comment">// hello.cc using Node-API</span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -9737,7 +10307,7 @@ provided by N-API carries with it certain
   napi_value greeting;
   napi_status status;
 
-  status = napi_create_string_utf8(env, <span class="hljs-string">"world"</span>, NAPI_AUTO_LENGTH, &#x26;greeting);
+  status = <span class="hljs-built_in">napi_create_string_utf8</span>(env, <span class="hljs-string">"world"</span>, NAPI_AUTO_LENGTH, &#x26;greeting);
   <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> <span class="hljs-literal">nullptr</span>;
   <span class="hljs-keyword">return</span> greeting;
 }
@@ -9746,41 +10316,41 @@ provided by N-API carries with it certain
   napi_status status;
   napi_value fn;
 
-  status = napi_create_function(env, <span class="hljs-literal">nullptr</span>, <span class="hljs-number">0</span>, Method, <span class="hljs-literal">nullptr</span>, &#x26;fn);
+  status = <span class="hljs-built_in">napi_create_function</span>(env, <span class="hljs-literal">nullptr</span>, <span class="hljs-number">0</span>, Method, <span class="hljs-literal">nullptr</span>, &#x26;fn);
   <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> <span class="hljs-literal">nullptr</span>;
 
-  status = napi_set_named_property(env, exports, <span class="hljs-string">"hello"</span>, fn);
+  status = <span class="hljs-built_in">napi_set_named_property</span>(env, exports, <span class="hljs-string">"hello"</span>, fn);
   <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> <span class="hljs-literal">nullptr</span>;
   <span class="hljs-keyword">return</span> exports;
 }
 
-NAPI_MODULE(NODE_GYP_MODULE_NAME, init)
+<span class="hljs-built_in">NAPI_MODULE</span>(NODE_GYP_MODULE_NAME, init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>The functions available and how to use them are documented in
-<a href="n-api.html">C/C++ addons with N-API</a>.</p>
-<h2>Addon examples<span><a class="mark" href="#addons_addon_examples" id="addons_addon_examples">#</a></span></h2>
+<a href="n-api.html">C/C++ addons with Node-API</a>.</p>
+</section><section><h3>Addon examples<span><a class="mark" href="#addons_addon_examples" id="addons_addon_examples">#</a></span></h3>
 <p>Following are some example addons intended to help developers get started. The
 examples use the V8 APIs. Refer to the online <a href="https://v8docs.nodesource.com/">V8 reference</a>
 for help with the various V8 calls, and V8's <a href="https://github.com/v8/v8/wiki/Embedder&#x27;s%20Guide">Embedder's Guide</a> for an
 explanation of several concepts used such as handles, scopes, function
 templates, etc.</p>
 <p>Each of these examples using the following <code>binding.gyp</code> file:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"targets"</span>: [
-    {
-      <span class="hljs-attr">"target_name"</span>: <span class="hljs-string">"addon"</span>,
-      <span class="hljs-attr">"sources"</span>: [ <span class="hljs-string">"addon.cc"</span> ]
-    }
-  ]
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"targets"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"target_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"addon"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span> <span class="hljs-string">"addon.cc"</span> <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>In cases where there is more than one <code>.cc</code> file, simply add the additional
 filename to the <code>sources</code> array:</p>
-<pre><code class="language-json">"sources": ["addon.cc", "myexample.cc"]</code></pre>
+<pre><code class="language-json"><span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span><span class="hljs-string">"addon.cc"</span><span class="hljs-punctuation">,</span> <span class="hljs-string">"myexample.cc"</span><span class="hljs-punctuation">]</span></code></pre>
 <p>Once the <code>binding.gyp</code> file is ready, the example addons can be configured and
 built using <code>node-gyp</code>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node-gyp configure build</span></code></pre>
-<h3>Function arguments<span><a class="mark" href="#addons_function_arguments" id="addons_function_arguments">#</a></span></h3>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node-gyp configure build</span></code></pre>
+<h4>Function arguments<span><a class="mark" href="#addons_function_arguments" id="addons_function_arguments">#</a></span></h4>
 <p>Addons will typically expose objects and functions that can be accessed from
 JavaScript running within Node.js. When functions are invoked from JavaScript,
 the input arguments and return value must be mapped to and from the C/C++
@@ -9788,7 +10358,7 @@ code.</p>
 <p>The following example illustrates how to read function arguments passed from
 JavaScript and how to return a result:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -9796,7 +10366,6 @@ JavaScript and how to return a result:</p>
 <span class="hljs-keyword">using</span> v8::FunctionCallbackInfo;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Number;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
@@ -9805,56 +10374,54 @@ JavaScript and how to return a result:</p>
 <span class="hljs-comment">// This is the implementation of the "add" method</span>
 <span class="hljs-comment">// Input arguments are passed using the</span>
 <span class="hljs-comment">// const FunctionCallbackInfo&#x3C;Value>&#x26; args struct</span>
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Add</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Add</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
   <span class="hljs-comment">// Check the number of arguments passed.</span>
-  <span class="hljs-keyword">if</span> (args.Length() &#x3C; <span class="hljs-number">2</span>) {
+  <span class="hljs-keyword">if</span> (args.<span class="hljs-built_in">Length</span>() &#x3C; <span class="hljs-number">2</span>) {
     <span class="hljs-comment">// Throw an Error that is passed back to JavaScript</span>
-    isolate->ThrowException(Exception::TypeError(
-        String::NewFromUtf8(isolate,
-                            <span class="hljs-string">"Wrong number of arguments"</span>,
-                            NewStringType::kNormal).ToLocalChecked()));
+    isolate-><span class="hljs-built_in">ThrowException</span>(Exception::<span class="hljs-built_in">TypeError</span>(
+        String::<span class="hljs-built_in">NewFromUtf8</span>(isolate,
+                            <span class="hljs-string">"Wrong number of arguments"</span>).<span class="hljs-built_in">ToLocalChecked</span>()));
     <span class="hljs-keyword">return</span>;
   }
 
   <span class="hljs-comment">// Check the argument types</span>
-  <span class="hljs-keyword">if</span> (!args[<span class="hljs-number">0</span>]->IsNumber() || !args[<span class="hljs-number">1</span>]->IsNumber()) {
-    isolate->ThrowException(Exception::TypeError(
-        String::NewFromUtf8(isolate,
-                            <span class="hljs-string">"Wrong arguments"</span>,
-                            NewStringType::kNormal).ToLocalChecked()));
+  <span class="hljs-keyword">if</span> (!args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">IsNumber</span>() || !args[<span class="hljs-number">1</span>]-><span class="hljs-built_in">IsNumber</span>()) {
+    isolate-><span class="hljs-built_in">ThrowException</span>(Exception::<span class="hljs-built_in">TypeError</span>(
+        String::<span class="hljs-built_in">NewFromUtf8</span>(isolate,
+                            <span class="hljs-string">"Wrong arguments"</span>).<span class="hljs-built_in">ToLocalChecked</span>()));
     <span class="hljs-keyword">return</span>;
   }
 
   <span class="hljs-comment">// Perform the operation</span>
-  <span class="hljs-keyword">double</span> value =
-      args[<span class="hljs-number">0</span>].As&#x3C;Number>()->Value() + args[<span class="hljs-number">1</span>].As&#x3C;Number>()->Value();
-  Local&#x3C;Number> num = Number::New(isolate, value);
+  <span class="hljs-type">double</span> value =
+      args[<span class="hljs-number">0</span>].<span class="hljs-built_in">As</span>&#x3C;Number>()-><span class="hljs-built_in">Value</span>() + args[<span class="hljs-number">1</span>].<span class="hljs-built_in">As</span>&#x3C;Number>()-><span class="hljs-built_in">Value</span>();
+  Local&#x3C;Number> num = Number::<span class="hljs-built_in">New</span>(isolate, value);
 
   <span class="hljs-comment">// Set the return value (using the passed in</span>
   <span class="hljs-comment">// FunctionCallbackInfo&#x3C;Value>&#x26;)</span>
-  args.GetReturnValue().Set(num);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(num);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  NODE_SET_METHOD(exports, <span class="hljs-string">"add"</span>, Add);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(exports, <span class="hljs-string">"add"</span>, Add);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>Once compiled, the example addon can be required and used from within Node.js:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This should be eight:'</span>, addon.add(<span class="hljs-number">3</span>, <span class="hljs-number">5</span>));</code></pre>
-<h3>Callbacks<span><a class="mark" href="#addons_callbacks" id="addons_callbacks">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This should be eight:'</span>, addon.<span class="hljs-title function_">add</span>(<span class="hljs-number">3</span>, <span class="hljs-number">5</span>));</code></pre>
+<h4>Callbacks<span><a class="mark" href="#addons_callbacks" id="addons_callbacks">#</a></span></h4>
 <p>It is common practice within addons to pass JavaScript functions to a C++
 function and execute them from there. The following example illustrates how
 to invoke such callbacks:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -9863,29 +10430,27 @@ to invoke such callbacks:</p>
 <span class="hljs-keyword">using</span> v8::FunctionCallbackInfo;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Null;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">RunCallback</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
-  Local&#x3C;Function> cb = Local&#x3C;Function>::Cast(args[<span class="hljs-number">0</span>]);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">RunCallback</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
+  Local&#x3C;Function> cb = Local&#x3C;Function>::<span class="hljs-built_in">Cast</span>(args[<span class="hljs-number">0</span>]);
   <span class="hljs-keyword">const</span> <span class="hljs-keyword">unsigned</span> argc = <span class="hljs-number">1</span>;
   Local&#x3C;Value> argv[argc] = {
-      String::NewFromUtf8(isolate,
-                          <span class="hljs-string">"hello world"</span>,
-                          NewStringType::kNormal).ToLocalChecked() };
-  cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();
+      String::<span class="hljs-built_in">NewFromUtf8</span>(isolate,
+                          <span class="hljs-string">"hello world"</span>).<span class="hljs-built_in">ToLocalChecked</span>() };
+  cb-><span class="hljs-built_in">Call</span>(context, <span class="hljs-built_in">Null</span>(isolate), argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
-  NODE_SET_METHOD(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, RunCallback);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, RunCallback);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>This example uses a two-argument form of <code>Init()</code> that receives the full
@@ -9896,17 +10461,17 @@ property of <code>exports</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-addon(<span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(msg);
+<span class="hljs-title function_">addon</span>(<span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(msg);
 <span class="hljs-comment">// Prints: 'hello world'</span>
 });</code></pre>
 <p>In this example, the callback function is invoked synchronously.</p>
-<h3>Object factory<span><a class="mark" href="#addons_object_factory" id="addons_object_factory">#</a></span></h3>
+<h4>Object factory<span><a class="mark" href="#addons_object_factory" id="addons_object_factory">#</a></span></h4>
 <p>Addons can create and return new objects from within a C++ function as
 illustrated in the following example. An object is created and returned with a
 property <code>msg</code> that echoes the string passed to <code>createObject()</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -9914,46 +10479,44 @@ property <code>msg</code> that echoes the string passed to <code>createObject()<
 <span class="hljs-keyword">using</span> v8::FunctionCallbackInfo;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  Local&#x3C;Object> obj = Object::New(isolate);
-  obj->Set(context,
-           String::NewFromUtf8(isolate,
-                               <span class="hljs-string">"msg"</span>,
-                               NewStringType::kNormal).ToLocalChecked(),
-                               args[<span class="hljs-number">0</span>]->ToString(context).ToLocalChecked())
-           .FromJust();
+  Local&#x3C;Object> obj = Object::<span class="hljs-built_in">New</span>(isolate);
+  obj-><span class="hljs-built_in">Set</span>(context,
+           String::<span class="hljs-built_in">NewFromUtf8</span>(isolate,
+                               <span class="hljs-string">"msg"</span>).<span class="hljs-built_in">ToLocalChecked</span>(),
+                               args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">ToString</span>(context).<span class="hljs-built_in">ToLocalChecked</span>())
+           .<span class="hljs-built_in">FromJust</span>();
 
-  args.GetReturnValue().Set(obj);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(obj);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
-  NODE_SET_METHOD(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateObject);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateObject);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>To test it in JavaScript:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> obj1 = addon(<span class="hljs-string">'hello'</span>);
-<span class="hljs-keyword">const</span> obj2 = addon(<span class="hljs-string">'world'</span>);
-<span class="hljs-built_in">console</span>.log(obj1.msg, obj2.msg);
+<span class="hljs-keyword">const</span> obj1 = <span class="hljs-title function_">addon</span>(<span class="hljs-string">'hello'</span>);
+<span class="hljs-keyword">const</span> obj2 = <span class="hljs-title function_">addon</span>(<span class="hljs-string">'world'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj1.<span class="hljs-property">msg</span>, obj2.<span class="hljs-property">msg</span>);
 <span class="hljs-comment">// Prints: 'hello world'</span></code></pre>
-<h3>Function factory<span><a class="mark" href="#addons_function_factory" id="addons_function_factory">#</a></span></h3>
+<h4>Function factory<span><a class="mark" href="#addons_function_factory" id="addons_function_factory">#</a></span></h4>
 <p>Another common scenario is creating JavaScript functions that wrap C++
 functions and returning those back to JavaScript:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -9963,96 +10526,95 @@ functions and returning those back to JavaScript:</p>
 <span class="hljs-keyword">using</span> v8::FunctionTemplate;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyFunction</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  args.GetReturnValue().Set(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"hello world"</span>, NewStringType::kNormal).ToLocalChecked());
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyFunction</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(
+      isolate, <span class="hljs-string">"hello world"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">CreateFunction</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">CreateFunction</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
-  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, MyFunction);
-  Local&#x3C;Function> fn = tpl->GetFunction(context).ToLocalChecked();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
+  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, MyFunction);
+  Local&#x3C;Function> fn = tpl-><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>();
 
   <span class="hljs-comment">// omit this to make it anonymous</span>
-  fn->SetName(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"theFunction"</span>, NewStringType::kNormal).ToLocalChecked());
+  fn-><span class="hljs-built_in">SetName</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(
+      isolate, <span class="hljs-string">"theFunction"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
 
-  args.GetReturnValue().Set(fn);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(fn);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
-  NODE_SET_METHOD(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateFunction);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateFunction);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Init)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, Init)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>To test:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> fn = addon();
-<span class="hljs-built_in">console</span>.log(fn());
+<span class="hljs-keyword">const</span> fn = <span class="hljs-title function_">addon</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">fn</span>());
 <span class="hljs-comment">// Prints: 'hello world'</span></code></pre>
-<h3>Wrapping C++ objects<span><a class="mark" href="#addons_wrapping_c_objects" id="addons_wrapping_c_objects">#</a></span></h3>
+<h4>Wrapping C++ objects<span><a class="mark" href="#addons_wrapping_c_objects" id="addons_wrapping_c_objects">#</a></span></h4>
 <p>It is also possible to wrap C++ objects/classes in a way that allows new
 instances to be created using the JavaScript <code>new</code> operator:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
 <span class="hljs-keyword">using</span> v8::Local;
 <span class="hljs-keyword">using</span> v8::Object;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  MyObject::Init(exports);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  MyObject::<span class="hljs-built_in">Init</span>(exports);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, InitAll)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>Then, in <code>myobject.h</code>, the wrapper class inherits from <code>node::ObjectWrap</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.h</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">ifndef</span> MYOBJECT_H</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">ifndef</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> MYOBJECT_H</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyObject</span> :</span> <span class="hljs-keyword">public</span> node::ObjectWrap {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyObject</span> : <span class="hljs-keyword">public</span> node::ObjectWrap {
  <span class="hljs-keyword">public</span>:
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Local&#x3C;v8::Object> exports)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Local&#x3C;v8::Object> exports)</span></span>;
 
  <span class="hljs-keyword">private</span>:
-  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-keyword">double</span> value = <span class="hljs-number">0</span>)</span></span>;
-  ~MyObject();
+  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-type">double</span> value = <span class="hljs-number">0</span>)</span></span>;
+  ~<span class="hljs-built_in">MyObject</span>();
 
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
 
-  <span class="hljs-keyword">double</span> value_;
+  <span class="hljs-type">double</span> value_;
 };
 
 }  <span class="hljs-comment">// namespace demo</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">endif</span></span></code></pre>
+<span class="hljs-meta">#<span class="hljs-keyword">endif</span></span></code></pre>
 <p>In <code>myobject.cc</code>, implement the various methods that are to be exposed.
 Below, the method <code>plusOne()</code> is exposed by adding it to the constructor's
 prototype:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -10062,100 +10624,98 @@ prototype:</p>
 <span class="hljs-keyword">using</span> v8::FunctionTemplate;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Number;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::ObjectTemplate;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-MyObject::MyObject(<span class="hljs-keyword">double</span> value) : value_(value) {
+MyObject::<span class="hljs-built_in">MyObject</span>(<span class="hljs-type">double</span> value) : <span class="hljs-built_in">value_</span>(value) {
 }
 
-MyObject::~MyObject() {
+MyObject::~<span class="hljs-built_in">MyObject</span>() {
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  Isolate* isolate = exports->GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  Isolate* isolate = exports-><span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  Local&#x3C;ObjectTemplate> addon_data_tpl = ObjectTemplate::New(isolate);
-  addon_data_tpl->SetInternalFieldCount(<span class="hljs-number">1</span>);  <span class="hljs-comment">// 1 field for the MyObject::New()</span>
+  Local&#x3C;ObjectTemplate> addon_data_tpl = ObjectTemplate::<span class="hljs-built_in">New</span>(isolate);
+  addon_data_tpl-><span class="hljs-built_in">SetInternalFieldCount</span>(<span class="hljs-number">1</span>);  <span class="hljs-comment">// 1 field for the MyObject::New()</span>
   Local&#x3C;Object> addon_data =
-      addon_data_tpl->NewInstance(context).ToLocalChecked();
+      addon_data_tpl-><span class="hljs-built_in">NewInstance</span>(context).<span class="hljs-built_in">ToLocalChecked</span>();
 
   <span class="hljs-comment">// Prepare constructor template</span>
-  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"MyObject"</span>, NewStringType::kNormal).ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(<span class="hljs-number">1</span>);
+  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, New, addon_data);
+  tpl-><span class="hljs-built_in">SetClassName</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(isolate, <span class="hljs-string">"MyObject"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
+  tpl-><span class="hljs-built_in">InstanceTemplate</span>()-><span class="hljs-built_in">SetInternalFieldCount</span>(<span class="hljs-number">1</span>);
 
   <span class="hljs-comment">// Prototype</span>
-  NODE_SET_PROTOTYPE_METHOD(tpl, <span class="hljs-string">"plusOne"</span>, PlusOne);
+  <span class="hljs-built_in">NODE_SET_PROTOTYPE_METHOD</span>(tpl, <span class="hljs-string">"plusOne"</span>, PlusOne);
 
-  Local&#x3C;Function> constructor = tpl->GetFunction(context).ToLocalChecked();
-  addon_data->SetInternalField(<span class="hljs-number">0</span>, constructor);
-  exports->Set(context, String::NewFromUtf8(
-      isolate, <span class="hljs-string">"MyObject"</span>, NewStringType::kNormal).ToLocalChecked(),
-               constructor).FromJust();
+  Local&#x3C;Function> constructor = tpl-><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>();
+  addon_data-><span class="hljs-built_in">SetInternalField</span>(<span class="hljs-number">0</span>, constructor);
+  exports-><span class="hljs-built_in">Set</span>(context, String::<span class="hljs-built_in">NewFromUtf8</span>(
+      isolate, <span class="hljs-string">"MyObject"</span>).<span class="hljs-built_in">ToLocalChecked</span>(),
+      constructor).<span class="hljs-built_in">FromJust</span>();
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  <span class="hljs-keyword">if</span> (args.IsConstructCall()) {
+  <span class="hljs-keyword">if</span> (args.<span class="hljs-built_in">IsConstructCall</span>()) {
     <span class="hljs-comment">// Invoked as constructor: `new MyObject(...)`</span>
-    <span class="hljs-keyword">double</span> value = args[<span class="hljs-number">0</span>]->IsUndefined() ?
-        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]->NumberValue(context).FromMaybe(<span class="hljs-number">0</span>);
-    MyObject* obj = <span class="hljs-keyword">new</span> MyObject(value);
-    obj->Wrap(args.This());
-    args.GetReturnValue().Set(args.This());
+    <span class="hljs-type">double</span> value = args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">IsUndefined</span>() ?
+        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">NumberValue</span>(context).<span class="hljs-built_in">FromMaybe</span>(<span class="hljs-number">0</span>);
+    MyObject* obj = <span class="hljs-keyword">new</span> <span class="hljs-built_in">MyObject</span>(value);
+    obj-><span class="hljs-built_in">Wrap</span>(args.<span class="hljs-built_in">This</span>());
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(args.<span class="hljs-built_in">This</span>());
   } <span class="hljs-keyword">else</span> {
     <span class="hljs-comment">// Invoked as plain function `MyObject(...)`, turn into construct call.</span>
-    <span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span> argc = <span class="hljs-number">1</span>;
+    <span class="hljs-keyword">const</span> <span class="hljs-type">int</span> argc = <span class="hljs-number">1</span>;
     Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
     Local&#x3C;Function> cons =
-        args.Data().As&#x3C;Object>()->GetInternalField(<span class="hljs-number">0</span>).As&#x3C;Function>();
+        args.<span class="hljs-built_in">Data</span>().<span class="hljs-built_in">As</span>&#x3C;Object>()-><span class="hljs-built_in">GetInternalField</span>(<span class="hljs-number">0</span>).<span class="hljs-built_in">As</span>&#x3C;Function>();
     Local&#x3C;Object> result =
-        cons->NewInstance(context, argc, argv).ToLocalChecked();
-    args.GetReturnValue().Set(result);
+        cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(result);
   }
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
-  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());
+  MyObject* obj = ObjectWrap::<span class="hljs-built_in">Unwrap</span>&#x3C;MyObject>(args.<span class="hljs-built_in">Holder</span>());
   obj->value_ += <span class="hljs-number">1</span>;
 
-  args.GetReturnValue().Set(Number::New(isolate, obj->value_));
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(Number::<span class="hljs-built_in">New</span>(isolate, obj->value_));
 }
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>To build this example, the <code>myobject.cc</code> file must be added to the
 <code>binding.gyp</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"targets"</span>: [
-    {
-      <span class="hljs-attr">"target_name"</span>: <span class="hljs-string">"addon"</span>,
-      <span class="hljs-attr">"sources"</span>: [
-        <span class="hljs-string">"addon.cc"</span>,
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"targets"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"target_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"addon"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+        <span class="hljs-string">"addon.cc"</span><span class="hljs-punctuation">,</span>
         <span class="hljs-string">"myobject.cc"</span>
-      ]
-    }
-  ]
-}</code></pre>
+      <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Test it with:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> obj = <span class="hljs-keyword">new</span> addon.MyObject(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-keyword">const</span> obj = <span class="hljs-keyword">new</span> addon.<span class="hljs-title class_">MyObject</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 11</span>
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 12</span>
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 13</span></code></pre>
 <p>The destructor for a wrapper object will run when the object is
 garbage-collected. For destructor testing, there are command-line flags that
@@ -10163,16 +10723,16 @@ can be used to make it possible to force garbage collection. These flags are
 provided by the underlying V8 JavaScript engine. They are subject to change
 or removal at any time. They are not documented by Node.js or V8, and they
 should never be used outside of testing.</p>
-<h3>Factory of wrapped objects<span><a class="mark" href="#addons_factory_of_wrapped_objects" id="addons_factory_of_wrapped_objects">#</a></span></h3>
+<h4>Factory of wrapped objects<span><a class="mark" href="#addons_factory_of_wrapped_objects" id="addons_factory_of_wrapped_objects">#</a></span></h4>
 <p>Alternatively, it is possible to use a factory pattern to avoid explicitly
 creating object instances using the JavaScript <code>new</code> operator:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> obj = addon.createObject();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> obj = addon.<span class="hljs-title function_">createObject</span>();
 <span class="hljs-comment">// instead of:</span>
 <span class="hljs-comment">// const obj = new addon.Object();</span></code></pre>
 <p>First, the <code>createObject()</code> method is implemented in <code>addon.cc</code>:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -10183,53 +10743,53 @@ creating object instances using the JavaScript <code>new</code> operator:</p>
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  MyObject::NewInstance(args);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  MyObject::<span class="hljs-built_in">NewInstance</span>(args);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
-  MyObject::Init(exports->GetIsolate());
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports, Local&#x3C;Object> <span class="hljs-keyword">module</span>)</span> </span>{
+  MyObject::<span class="hljs-built_in">Init</span>(exports-><span class="hljs-built_in">GetIsolate</span>());
 
-  NODE_SET_METHOD(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateObject);
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(<span class="hljs-keyword">module</span>, <span class="hljs-string">"exports"</span>, CreateObject);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, InitAll)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>In <code>myobject.h</code>, the static method <code>NewInstance()</code> is added to handle
 instantiating the object. This method takes the place of using <code>new</code> in
 JavaScript:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.h</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">ifndef</span> MYOBJECT_H</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">ifndef</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> MYOBJECT_H</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyObject</span> :</span> <span class="hljs-keyword">public</span> node::ObjectWrap {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyObject</span> : <span class="hljs-keyword">public</span> node::ObjectWrap {
  <span class="hljs-keyword">public</span>:
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Isolate* isolate)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Isolate* isolate)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
 
  <span class="hljs-keyword">private</span>:
-  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-keyword">double</span> value = <span class="hljs-number">0</span>)</span></span>;
-  ~MyObject();
+  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-type">double</span> value = <span class="hljs-number">0</span>)</span></span>;
+  ~<span class="hljs-built_in">MyObject</span>();
 
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
   <span class="hljs-keyword">static</span> v8::Global&#x3C;v8::Function> constructor;
-  <span class="hljs-keyword">double</span> value_;
+  <span class="hljs-type">double</span> value_;
 };
 
 }  <span class="hljs-comment">// namespace demo</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">endif</span></span></code></pre>
+<span class="hljs-meta">#<span class="hljs-keyword">endif</span></span></code></pre>
 <p>The implementation in <code>myobject.cc</code> is similar to the previous example:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -10241,7 +10801,6 @@ JavaScript:</p>
 <span class="hljs-keyword">using</span> v8::Global;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Number;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
@@ -10251,116 +10810,115 @@ JavaScript:</p>
 <span class="hljs-comment">// threads.</span>
 Global&#x3C;Function> MyObject::constructor;
 
-MyObject::MyObject(<span class="hljs-keyword">double</span> value) : value_(value) {
+MyObject::<span class="hljs-built_in">MyObject</span>(<span class="hljs-type">double</span> value) : <span class="hljs-built_in">value_</span>(value) {
 }
 
-MyObject::~MyObject() {
+MyObject::~<span class="hljs-built_in">MyObject</span>() {
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Isolate* isolate)</span> </span>{
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Isolate* isolate)</span> </span>{
   <span class="hljs-comment">// Prepare constructor template</span>
-  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"MyObject"</span>, NewStringType::kNormal).ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(<span class="hljs-number">1</span>);
+  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, New);
+  tpl-><span class="hljs-built_in">SetClassName</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(isolate, <span class="hljs-string">"MyObject"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
+  tpl-><span class="hljs-built_in">InstanceTemplate</span>()-><span class="hljs-built_in">SetInternalFieldCount</span>(<span class="hljs-number">1</span>);
 
   <span class="hljs-comment">// Prototype</span>
-  NODE_SET_PROTOTYPE_METHOD(tpl, <span class="hljs-string">"plusOne"</span>, PlusOne);
+  <span class="hljs-built_in">NODE_SET_PROTOTYPE_METHOD</span>(tpl, <span class="hljs-string">"plusOne"</span>, PlusOne);
 
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
-  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
+  constructor.<span class="hljs-built_in">Reset</span>(isolate, tpl-><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>());
 
-  AddEnvironmentCleanupHook(isolate, [](<span class="hljs-keyword">void</span>*) {
-    constructor.Reset();
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, [](<span class="hljs-type">void</span>*) {
+    constructor.<span class="hljs-built_in">Reset</span>();
   }, <span class="hljs-literal">nullptr</span>);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  <span class="hljs-keyword">if</span> (args.IsConstructCall()) {
+  <span class="hljs-keyword">if</span> (args.<span class="hljs-built_in">IsConstructCall</span>()) {
     <span class="hljs-comment">// Invoked as constructor: `new MyObject(...)`</span>
-    <span class="hljs-keyword">double</span> value = args[<span class="hljs-number">0</span>]->IsUndefined() ?
-        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]->NumberValue(context).FromMaybe(<span class="hljs-number">0</span>);
-    MyObject* obj = <span class="hljs-keyword">new</span> MyObject(value);
-    obj->Wrap(args.This());
-    args.GetReturnValue().Set(args.This());
+    <span class="hljs-type">double</span> value = args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">IsUndefined</span>() ?
+        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">NumberValue</span>(context).<span class="hljs-built_in">FromMaybe</span>(<span class="hljs-number">0</span>);
+    MyObject* obj = <span class="hljs-keyword">new</span> <span class="hljs-built_in">MyObject</span>(value);
+    obj-><span class="hljs-built_in">Wrap</span>(args.<span class="hljs-built_in">This</span>());
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(args.<span class="hljs-built_in">This</span>());
   } <span class="hljs-keyword">else</span> {
     <span class="hljs-comment">// Invoked as plain function `MyObject(...)`, turn into construct call.</span>
-    <span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span> argc = <span class="hljs-number">1</span>;
+    <span class="hljs-keyword">const</span> <span class="hljs-type">int</span> argc = <span class="hljs-number">1</span>;
     Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
-    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);
+    Local&#x3C;Function> cons = Local&#x3C;Function>::<span class="hljs-built_in">New</span>(isolate, constructor);
     Local&#x3C;Object> instance =
-        cons->NewInstance(context, argc, argv).ToLocalChecked();
-    args.GetReturnValue().Set(instance);
+        cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(instance);
   }
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
   <span class="hljs-keyword">const</span> <span class="hljs-keyword">unsigned</span> argc = <span class="hljs-number">1</span>;
   Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
-  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+  Local&#x3C;Function> cons = Local&#x3C;Function>::<span class="hljs-built_in">New</span>(isolate, constructor);
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
   Local&#x3C;Object> instance =
-      cons->NewInstance(context, argc, argv).ToLocalChecked();
+      cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
 
-  args.GetReturnValue().Set(instance);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(instance);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::PlusOne</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
-  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());
+  MyObject* obj = ObjectWrap::<span class="hljs-built_in">Unwrap</span>&#x3C;MyObject>(args.<span class="hljs-built_in">Holder</span>());
   obj->value_ += <span class="hljs-number">1</span>;
 
-  args.GetReturnValue().Set(Number::New(isolate, obj->value_));
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(Number::<span class="hljs-built_in">New</span>(isolate, obj->value_));
 }
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>Once again, to build this example, the <code>myobject.cc</code> file must be added to the
 <code>binding.gyp</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"targets"</span>: [
-    {
-      <span class="hljs-attr">"target_name"</span>: <span class="hljs-string">"addon"</span>,
-      <span class="hljs-attr">"sources"</span>: [
-        <span class="hljs-string">"addon.cc"</span>,
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"targets"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"target_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"addon"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+        <span class="hljs-string">"addon.cc"</span><span class="hljs-punctuation">,</span>
         <span class="hljs-string">"myobject.cc"</span>
-      ]
-    }
-  ]
-}</code></pre>
+      <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Test it with:</p>
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> createObject = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> obj = createObject(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-keyword">const</span> obj = <span class="hljs-title function_">createObject</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 11</span>
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 12</span>
-<span class="hljs-built_in">console</span>.log(obj.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 13</span>
 
-<span class="hljs-keyword">const</span> obj2 = createObject(<span class="hljs-number">20</span>);
-<span class="hljs-built_in">console</span>.log(obj2.plusOne());
+<span class="hljs-keyword">const</span> obj2 = <span class="hljs-title function_">createObject</span>(<span class="hljs-number">20</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj2.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 21</span>
-<span class="hljs-built_in">console</span>.log(obj2.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj2.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 22</span>
-<span class="hljs-built_in">console</span>.log(obj2.plusOne());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj2.<span class="hljs-title function_">plusOne</span>());
 <span class="hljs-comment">// Prints: 23</span></code></pre>
-<h3>Passing wrapped objects around<span><a class="mark" href="#addons_passing_wrapped_objects_around" id="addons_passing_wrapped_objects_around">#</a></span></h3>
+<h4>Passing wrapped objects around<span><a class="mark" href="#addons_passing_wrapped_objects_around" id="addons_passing_wrapped_objects_around">#</a></span></h4>
 <p>In addition to wrapping and returning C++ objects, it is possible to pass
 wrapped objects around by unwrapping them with the Node.js helper function
 <code>node::ObjectWrap::Unwrap</code>. The following examples shows a function <code>add()</code>
 that can take two <code>MyObject</code> objects as input arguments:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// addon.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -10373,66 +10931,66 @@ that can take two <code>MyObject</code> objects as input arguments:</p>
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  MyObject::NewInstance(args);
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">CreateObject</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  MyObject::<span class="hljs-built_in">NewInstance</span>(args);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">Add</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">Add</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  MyObject* obj1 = node::ObjectWrap::Unwrap&#x3C;MyObject>(
-      args[<span class="hljs-number">0</span>]->ToObject(context).ToLocalChecked());
-  MyObject* obj2 = node::ObjectWrap::Unwrap&#x3C;MyObject>(
-      args[<span class="hljs-number">1</span>]->ToObject(context).ToLocalChecked());
+  MyObject* obj1 = node::ObjectWrap::<span class="hljs-built_in">Unwrap</span>&#x3C;MyObject>(
+      args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">ToObject</span>(context).<span class="hljs-built_in">ToLocalChecked</span>());
+  MyObject* obj2 = node::ObjectWrap::<span class="hljs-built_in">Unwrap</span>&#x3C;MyObject>(
+      args[<span class="hljs-number">1</span>]-><span class="hljs-built_in">ToObject</span>(context).<span class="hljs-built_in">ToLocalChecked</span>());
 
-  <span class="hljs-keyword">double</span> sum = obj1->value() + obj2->value();
-  args.GetReturnValue().Set(Number::New(isolate, sum));
+  <span class="hljs-type">double</span> sum = obj1-><span class="hljs-built_in">value</span>() + obj2-><span class="hljs-built_in">value</span>();
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(Number::<span class="hljs-built_in">New</span>(isolate, sum));
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
-  MyObject::Init(exports->GetIsolate());
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">InitAll</span><span class="hljs-params">(Local&#x3C;Object> exports)</span> </span>{
+  MyObject::<span class="hljs-built_in">Init</span>(exports-><span class="hljs-built_in">GetIsolate</span>());
 
-  NODE_SET_METHOD(exports, <span class="hljs-string">"createObject"</span>, CreateObject);
-  NODE_SET_METHOD(exports, <span class="hljs-string">"add"</span>, Add);
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(exports, <span class="hljs-string">"createObject"</span>, CreateObject);
+  <span class="hljs-built_in">NODE_SET_METHOD</span>(exports, <span class="hljs-string">"add"</span>, Add);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
+<span class="hljs-built_in">NODE_MODULE</span>(NODE_GYP_MODULE_NAME, InitAll)
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
 <p>In <code>myobject.h</code>, a new public method is added to allow access to private values
 after unwrapping the object.</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.h</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">ifndef</span> MYOBJECT_H</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">ifndef</span> MYOBJECT_H</span>
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> MYOBJECT_H</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyObject</span> :</span> <span class="hljs-keyword">public</span> node::ObjectWrap {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyObject</span> : <span class="hljs-keyword">public</span> node::ObjectWrap {
  <span class="hljs-keyword">public</span>:
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Isolate* isolate)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
-  <span class="hljs-function"><span class="hljs-keyword">inline</span> <span class="hljs-keyword">double</span> <span class="hljs-title">value</span><span class="hljs-params">()</span> <span class="hljs-keyword">const</span> </span>{ <span class="hljs-keyword">return</span> value_; }
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">Init</span><span class="hljs-params">(v8::Isolate* isolate)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">inline</span> <span class="hljs-type">double</span> <span class="hljs-title">value</span><span class="hljs-params">()</span> <span class="hljs-keyword">const</span> </span>{ <span class="hljs-keyword">return</span> value_; }
 
  <span class="hljs-keyword">private</span>:
-  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-keyword">double</span> value = <span class="hljs-number">0</span>)</span></span>;
-  ~MyObject();
+  <span class="hljs-function"><span class="hljs-keyword">explicit</span> <span class="hljs-title">MyObject</span><span class="hljs-params">(<span class="hljs-type">double</span> value = <span class="hljs-number">0</span>)</span></span>;
+  ~<span class="hljs-built_in">MyObject</span>();
 
-  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
+  <span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-type">void</span> <span class="hljs-title">New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args)</span></span>;
   <span class="hljs-keyword">static</span> v8::Global&#x3C;v8::Function> constructor;
-  <span class="hljs-keyword">double</span> value_;
+  <span class="hljs-type">double</span> value_;
 };
 
 }  <span class="hljs-comment">// namespace demo</span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">endif</span></span></code></pre>
+<span class="hljs-meta">#<span class="hljs-keyword">endif</span></span></code></pre>
 <p>The implementation of <code>myobject.cc</code> is similar to before:</p>
 <pre><code class="language-cpp"><span class="hljs-comment">// myobject.cc</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"myobject.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"myobject.h"</span></span>
 
 <span class="hljs-keyword">namespace</span> demo {
 
@@ -10444,7 +11002,6 @@ after unwrapping the object.</p>
 <span class="hljs-keyword">using</span> v8::Global;
 <span class="hljs-keyword">using</span> v8::Isolate;
 <span class="hljs-keyword">using</span> v8::Local;
-<span class="hljs-keyword">using</span> v8::NewStringType;
 <span class="hljs-keyword">using</span> v8::Object;
 <span class="hljs-keyword">using</span> v8::String;
 <span class="hljs-keyword">using</span> v8::Value;
@@ -10453,60 +11010,59 @@ after unwrapping the object.</p>
 <span class="hljs-comment">// threads.</span>
 Global&#x3C;Function> MyObject::constructor;
 
-MyObject::MyObject(<span class="hljs-keyword">double</span> value) : value_(value) {
+MyObject::<span class="hljs-built_in">MyObject</span>(<span class="hljs-type">double</span> value) : <span class="hljs-built_in">value_</span>(value) {
 }
 
-MyObject::~MyObject() {
+MyObject::~<span class="hljs-built_in">MyObject</span>() {
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Isolate* isolate)</span> </span>{
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::Init</span><span class="hljs-params">(Isolate* isolate)</span> </span>{
   <span class="hljs-comment">// Prepare constructor template</span>
-  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
-  tpl->SetClassName(String::NewFromUtf8(
-      isolate, <span class="hljs-string">"MyObject"</span>, NewStringType::kNormal).ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(<span class="hljs-number">1</span>);
+  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::<span class="hljs-built_in">New</span>(isolate, New);
+  tpl-><span class="hljs-built_in">SetClassName</span>(String::<span class="hljs-built_in">NewFromUtf8</span>(isolate, <span class="hljs-string">"MyObject"</span>).<span class="hljs-built_in">ToLocalChecked</span>());
+  tpl-><span class="hljs-built_in">InstanceTemplate</span>()-><span class="hljs-built_in">SetInternalFieldCount</span>(<span class="hljs-number">1</span>);
 
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
-  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
+  constructor.<span class="hljs-built_in">Reset</span>(isolate, tpl-><span class="hljs-built_in">GetFunction</span>(context).<span class="hljs-built_in">ToLocalChecked</span>());
 
-  AddEnvironmentCleanupHook(isolate, [](<span class="hljs-keyword">void</span>*) {
-    constructor.Reset();
+  <span class="hljs-built_in">AddEnvironmentCleanupHook</span>(isolate, [](<span class="hljs-type">void</span>*) {
+    constructor.<span class="hljs-built_in">Reset</span>();
   }, <span class="hljs-literal">nullptr</span>);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::New</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
 
-  <span class="hljs-keyword">if</span> (args.IsConstructCall()) {
+  <span class="hljs-keyword">if</span> (args.<span class="hljs-built_in">IsConstructCall</span>()) {
     <span class="hljs-comment">// Invoked as constructor: `new MyObject(...)`</span>
-    <span class="hljs-keyword">double</span> value = args[<span class="hljs-number">0</span>]->IsUndefined() ?
-        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]->NumberValue(context).FromMaybe(<span class="hljs-number">0</span>);
-    MyObject* obj = <span class="hljs-keyword">new</span> MyObject(value);
-    obj->Wrap(args.This());
-    args.GetReturnValue().Set(args.This());
+    <span class="hljs-type">double</span> value = args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">IsUndefined</span>() ?
+        <span class="hljs-number">0</span> : args[<span class="hljs-number">0</span>]-><span class="hljs-built_in">NumberValue</span>(context).<span class="hljs-built_in">FromMaybe</span>(<span class="hljs-number">0</span>);
+    MyObject* obj = <span class="hljs-keyword">new</span> <span class="hljs-built_in">MyObject</span>(value);
+    obj-><span class="hljs-built_in">Wrap</span>(args.<span class="hljs-built_in">This</span>());
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(args.<span class="hljs-built_in">This</span>());
   } <span class="hljs-keyword">else</span> {
     <span class="hljs-comment">// Invoked as plain function `MyObject(...)`, turn into construct call.</span>
-    <span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span> argc = <span class="hljs-number">1</span>;
+    <span class="hljs-keyword">const</span> <span class="hljs-type">int</span> argc = <span class="hljs-number">1</span>;
     Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
-    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);
+    Local&#x3C;Function> cons = Local&#x3C;Function>::<span class="hljs-built_in">New</span>(isolate, constructor);
     Local&#x3C;Object> instance =
-        cons->NewInstance(context, argc, argv).ToLocalChecked();
-    args.GetReturnValue().Set(instance);
+        cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
+    args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(instance);
   }
 }
 
-<span class="hljs-function"><span class="hljs-keyword">void</span> <span class="hljs-title">MyObject::NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
-  Isolate* isolate = args.GetIsolate();
+<span class="hljs-function"><span class="hljs-type">void</span> <span class="hljs-title">MyObject::NewInstance</span><span class="hljs-params">(<span class="hljs-keyword">const</span> FunctionCallbackInfo&#x3C;Value>&#x26; args)</span> </span>{
+  Isolate* isolate = args.<span class="hljs-built_in">GetIsolate</span>();
 
   <span class="hljs-keyword">const</span> <span class="hljs-keyword">unsigned</span> argc = <span class="hljs-number">1</span>;
   Local&#x3C;Value> argv[argc] = { args[<span class="hljs-number">0</span>] };
-  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);
-  Local&#x3C;Context> context = isolate->GetCurrentContext();
+  Local&#x3C;Function> cons = Local&#x3C;Function>::<span class="hljs-built_in">New</span>(isolate, constructor);
+  Local&#x3C;Context> context = isolate-><span class="hljs-built_in">GetCurrentContext</span>();
   Local&#x3C;Object> instance =
-      cons->NewInstance(context, argc, argv).ToLocalChecked();
+      cons-><span class="hljs-built_in">NewInstance</span>(context, argc, argv).<span class="hljs-built_in">ToLocalChecked</span>();
 
-  args.GetReturnValue().Set(instance);
+  args.<span class="hljs-built_in">GetReturnValue</span>().<span class="hljs-built_in">Set</span>(instance);
 }
 
 }  <span class="hljs-comment">// namespace demo</span></code></pre>
@@ -10514,34 +11070,34 @@ MyObject::~MyObject() {
 <pre><code class="language-js"><span class="hljs-comment">// test.js</span>
 <span class="hljs-keyword">const</span> addon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./build/Release/addon'</span>);
 
-<span class="hljs-keyword">const</span> obj1 = addon.createObject(<span class="hljs-number">10</span>);
-<span class="hljs-keyword">const</span> obj2 = addon.createObject(<span class="hljs-number">20</span>);
-<span class="hljs-keyword">const</span> result = addon.add(obj1, obj2);
+<span class="hljs-keyword">const</span> obj1 = addon.<span class="hljs-title function_">createObject</span>(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> obj2 = addon.<span class="hljs-title function_">createObject</span>(<span class="hljs-number">20</span>);
+<span class="hljs-keyword">const</span> result = addon.<span class="hljs-title function_">add</span>(obj1, obj2);
 
-<span class="hljs-built_in">console</span>.log(result);
-<span class="hljs-comment">// Prints: 30</span></code></pre>
-<h1>N-API<span><a class="mark" href="#n_api_n_api" id="n_api_n_api">#</a></span></h1>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result);
+<span class="hljs-comment">// Prints: 30</span></code></pre></section>
+        </section>
+<section><h2>Node-API<span><a class="mark" href="#n_api_node_api" id="n_api_node_api">#</a></span></h2>
 
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p>N-API (pronounced N as in the letter, followed by API)
-is an API for building native Addons. It is independent from
-the underlying JavaScript runtime (for example, V8) and is maintained as part of
-Node.js itself. This API will be Application Binary Interface (ABI) stable
-across versions of Node.js. It is intended to insulate Addons from
-changes in the underlying JavaScript engine and allow modules
+<p>Node-API (formerly N-API) is an API for building native Addons. It is
+independent from the underlying JavaScript runtime (for example, V8) and is
+maintained as part of Node.js itself. This API will be Application Binary
+Interface (ABI) stable across versions of Node.js. It is intended to insulate
+addons from changes in the underlying JavaScript engine and allow modules
 compiled for one major version to run on later major versions of Node.js without
 recompilation. The <a href="https://nodejs.org/en/docs/guides/abi-stability/">ABI Stability</a> guide provides a more in-depth explanation.</p>
 <p>Addons are built/packaged with the same approach/tools outlined in the section
 titled <a href="addons.html">C++ Addons</a>. The only difference is the set of APIs that are used by
 the native code. Instead of using the V8 or <a href="https://github.com/nodejs/nan">Native Abstractions for Node.js</a>
-APIs, the functions available in the N-API are used.</p>
-<p>APIs exposed by N-API are generally used to create and manipulate
+APIs, the functions available in Node-API are used.</p>
+<p>APIs exposed by Node-API are generally used to create and manipulate
 JavaScript values. Concepts and operations generally map to ideas specified
 in the ECMA-262 Language Specification. The APIs have the following
 properties:</p>
 <ul>
-<li>All N-API calls return a status code of type <code>napi_status</code>. This
+<li>All Node-API calls return a status code of type <code>napi_status</code>. This
 status indicates whether the API call succeeded or failed.</li>
 <li>The API's return value is passed via an out parameter.</li>
 <li>All JavaScript values are abstracted behind an opaque type named
@@ -10550,75 +11106,75 @@ status indicates whether the API call succeeded or failed.</li>
 using <code>napi_get_last_error_info</code>. More information can be found in the error
 handling section <a href="#n_api_error_handling">Error handling</a>.</li>
 </ul>
-<p>The N-API is a C API that ensures ABI stability across Node.js versions
+<p>Node-API is a C API that ensures ABI stability across Node.js versions
 and different compiler levels. A C++ API can be easier to use.
 To support using C++, the project maintains a
 C++ wrapper module called <a href="https://github.com/nodejs/node-addon-api"><code>node-addon-api</code></a>.
 This wrapper provides an inlineable C++ API. Binaries built
-with <code>node-addon-api</code> will depend on the symbols for the N-API C-based
+with <code>node-addon-api</code> will depend on the symbols for the Node-API C-based
 functions exported by Node.js. <code>node-addon-api</code> is a more
-efficient way to write code that calls N-API. Take, for example, the
+efficient way to write code that calls Node-API. Take, for example, the
 following <code>node-addon-api</code> code. The first section shows the
 <code>node-addon-api</code> code and the second section shows what actually gets
 used in the addon.</p>
-<pre><code class="language-cpp">Object obj = Object::New(env);
-obj[<span class="hljs-string">"foo"</span>] = String::New(env, <span class="hljs-string">"bar"</span>);</code></pre>
+<pre><code class="language-cpp">Object obj = Object::<span class="hljs-built_in">New</span>(env);
+obj[<span class="hljs-string">"foo"</span>] = String::<span class="hljs-built_in">New</span>(env, <span class="hljs-string">"bar"</span>);</code></pre>
 <pre><code class="language-cpp">napi_status status;
-napi_value object, <span class="hljs-built_in">string</span>;
-status = napi_create_object(env, &#x26;object);
+napi_value object, string;
+status = <span class="hljs-built_in">napi_create_object</span>(env, &#x26;object);
 <span class="hljs-keyword">if</span> (status != napi_ok) {
-  napi_throw_error(env, ...);
+  <span class="hljs-built_in">napi_throw_error</span>(env, ...);
   <span class="hljs-keyword">return</span>;
 }
 
-status = napi_create_string_utf8(env, <span class="hljs-string">"bar"</span>, NAPI_AUTO_LENGTH, &#x26;<span class="hljs-built_in">string</span>);
+status = <span class="hljs-built_in">napi_create_string_utf8</span>(env, <span class="hljs-string">"bar"</span>, NAPI_AUTO_LENGTH, &#x26;string);
 <span class="hljs-keyword">if</span> (status != napi_ok) {
-  napi_throw_error(env, ...);
+  <span class="hljs-built_in">napi_throw_error</span>(env, ...);
   <span class="hljs-keyword">return</span>;
 }
 
-status = napi_set_named_property(env, object, <span class="hljs-string">"foo"</span>, <span class="hljs-built_in">string</span>);
+status = <span class="hljs-built_in">napi_set_named_property</span>(env, object, <span class="hljs-string">"foo"</span>, string);
 <span class="hljs-keyword">if</span> (status != napi_ok) {
-  napi_throw_error(env, ...);
+  <span class="hljs-built_in">napi_throw_error</span>(env, ...);
   <span class="hljs-keyword">return</span>;
 }</code></pre>
 <p>The end result is that the addon only uses the exported C APIs. As a result,
 it still gets the benefits of the ABI stability provided by the C API.</p>
 <p>When using <code>node-addon-api</code> instead of the C APIs, start with the API <a href="https://github.com/nodejs/node-addon-api#api-documentation">docs</a>
 for <code>node-addon-api</code>.</p>
-<p>The <a href="https://nodejs.github.io/node-addon-examples/">N-API Resource</a> offers an
-excellent orientation and tips for developers just getting started with N-API
-and <code>node-addon-api</code>.</p>
-<h2>Implications of ABI stability<span><a class="mark" href="#n_api_implications_of_abi_stability" id="n_api_implications_of_abi_stability">#</a></span></h2>
-<p>Although N-API provides an ABI stability guarantee, other parts of Node.js do
+<p>The <a href="https://nodejs.github.io/node-addon-examples/">Node-API Resource</a> offers
+an excellent orientation and tips for developers just getting started with
+Node-API and <code>node-addon-api</code>.</p>
+<section><h3>Implications of ABI stability<span><a class="mark" href="#n_api_implications_of_abi_stability" id="n_api_implications_of_abi_stability">#</a></span></h3>
+<p>Although Node-API provides an ABI stability guarantee, other parts of Node.js do
 not, and any external libraries used from the addon may not. In particular,
 none of the following APIs provide an ABI stability guarantee across major
 versions:</p>
 <ul>
 <li>
 <p>the Node.js C++ APIs available via any of</p>
-<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_buffer.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_version.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span></code></pre>
+<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_buffer.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_version.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span></code></pre>
 </li>
 <li>
 <p>the libuv APIs which are also included with Node.js and available via</p>
-<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;uv.h></span></span></code></pre>
+<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;uv.h></span></span></code></pre>
 </li>
 <li>
 <p>the V8 API available via</p>
-<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;v8.h></span></span></code></pre>
+<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;v8.h></span></span></code></pre>
 </li>
 </ul>
 <p>Thus, for an addon to remain ABI-compatible across Node.js major versions, it
-must use N-API exclusively by restricting itself to using</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span></code></pre>
+must use Node-API exclusively by restricting itself to using</p>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span></code></pre>
 <p>and by checking, for all external libraries that it uses, that the external
-library makes ABI stability guarantees similar to N-API.</p>
-<h2>Building<span><a class="mark" href="#n_api_building" id="n_api_building">#</a></span></h2>
+library makes ABI stability guarantees similar to Node-API.</p>
+</section><section><h3>Building<span><a class="mark" href="#n_api_building" id="n_api_building">#</a></span></h3>
 <p>Unlike modules written in JavaScript, developing and deploying Node.js
-native addons using N-API requires an additional set of tools. Besides the
+native addons using Node-API requires an additional set of tools. Besides the
 basic tools required to develop for Node.js, the native addon developer
 requires a toolchain that can compile C and C++ code into a binary. In
 addition, depending upon how the native addon is deployed, the <em>user</em> of
@@ -10637,198 +11193,215 @@ IDE. The following command installs the necessary toolchain:</p>
 <pre><code class="language-bash">npm install --global windows-build-tools</code></pre>
 <p>The sections below describe the additional tools available for developing
 and deploying Node.js native addons.</p>
-<h3>Build tools<span><a class="mark" href="#n_api_build_tools" id="n_api_build_tools">#</a></span></h3>
+<h4>Build tools<span><a class="mark" href="#n_api_build_tools" id="n_api_build_tools">#</a></span></h4>
 <p>Both the tools listed here require that <em>users</em> of the native
 addon have a C/C++ toolchain installed in order to successfully install
 the native addon.</p>
-<h4>node-gyp<span><a class="mark" href="#n_api_node_gyp" id="n_api_node_gyp">#</a></span></h4>
-<p><a href="https://github.com/nodejs/node-gyp">node-gyp</a> is a build system based on Google's <a href="https://gyp.gsrc.io">GYP</a> tool and comes
-bundled with npm. GYP, and therefore node-gyp, requires that Python be
-installed.</p>
+<h5>node-gyp<span><a class="mark" href="#n_api_node_gyp" id="n_api_node_gyp">#</a></span></h5>
+<p><a href="https://github.com/nodejs/node-gyp">node-gyp</a> is a build system based on the <a href="https://github.com/nodejs/gyp-next">gyp-next</a> fork of
+Google's <a href="https://gyp.gsrc.io">GYP</a> tool and comes bundled with npm. GYP, and therefore node-gyp,
+requires that Python be installed.</p>
 <p>Historically, node-gyp has been the tool of choice for building native
 addons. It has widespread adoption and documentation. However, some
 developers have run into limitations in node-gyp.</p>
-<h4>CMake.js<span><a class="mark" href="#n_api_cmake_js" id="n_api_cmake_js">#</a></span></h4>
+<h5>CMake.js<span><a class="mark" href="#n_api_cmake_js" id="n_api_cmake_js">#</a></span></h5>
 <p><a href="https://github.com/cmake-js/cmake-js">CMake.js</a> is an alternative build system based on <a href="https://cmake.org">CMake</a>.</p>
 <p>CMake.js is a good choice for projects that already use CMake or for
 developers affected by limitations in node-gyp.</p>
-<h3>Uploading precompiled binaries<span><a class="mark" href="#n_api_uploading_precompiled_binaries" id="n_api_uploading_precompiled_binaries">#</a></span></h3>
+<h4>Uploading precompiled binaries<span><a class="mark" href="#n_api_uploading_precompiled_binaries" id="n_api_uploading_precompiled_binaries">#</a></span></h4>
 <p>The three tools listed here permit native addon developers and maintainers
 to create and upload binaries to public or private servers. These tools are
 typically integrated with CI/CD build systems like <a href="https://travis-ci.org">Travis CI</a> and
 <a href="https://www.appveyor.com">AppVeyor</a> to build and upload binaries for a variety of platforms and
 architectures. These binaries are then available for download by users who
 do not need to have a C/C++ toolchain installed.</p>
-<h4>node-pre-gyp<span><a class="mark" href="#n_api_node_pre_gyp" id="n_api_node_pre_gyp">#</a></span></h4>
+<h5>node-pre-gyp<span><a class="mark" href="#n_api_node_pre_gyp" id="n_api_node_pre_gyp">#</a></span></h5>
 <p><a href="https://github.com/mapbox/node-pre-gyp">node-pre-gyp</a> is a tool based on node-gyp that adds the ability to
 upload binaries to a server of the developer's choice. node-pre-gyp has
 particularly good support for uploading binaries to Amazon S3.</p>
-<h4>prebuild<span><a class="mark" href="#n_api_prebuild" id="n_api_prebuild">#</a></span></h4>
+<h5>prebuild<span><a class="mark" href="#n_api_prebuild" id="n_api_prebuild">#</a></span></h5>
 <p><a href="https://github.com/prebuild/prebuild">prebuild</a> is a tool that supports builds using either node-gyp or
 CMake.js. Unlike node-pre-gyp which supports a variety of servers, prebuild
 uploads binaries only to <a href="https://help.github.com/en/github/administering-a-repository/about-releases">GitHub releases</a>. prebuild is a good choice for
 GitHub projects using CMake.js.</p>
-<h4>prebuildify<span><a class="mark" href="#n_api_prebuildify" id="n_api_prebuildify">#</a></span></h4>
+<h5>prebuildify<span><a class="mark" href="#n_api_prebuildify" id="n_api_prebuildify">#</a></span></h5>
 <p><a href="https://github.com/prebuild/prebuildify">prebuildify</a> is a tool based on node-gyp. The advantage of prebuildify is
 that the built binaries are bundled with the native module when it's
 uploaded to npm. The binaries are downloaded from npm and are immediately
 available to the module user when the native module is installed.</p>
-<h2>Usage<span><a class="mark" href="#n_api_usage" id="n_api_usage">#</a></span></h2>
-<p>In order to use the N-API functions, include the file <a href="https://github.com/nodejs/node/blob/master/src/node_api.h"><code>node_api.h</code></a> which is
-located in the src directory in the node development tree:</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span></code></pre>
+</section><section><h3>Usage<span><a class="mark" href="#n_api_usage" id="n_api_usage">#</a></span></h3>
+<p>In order to use the Node-API functions, include the file <a href="https://github.com/nodejs/node/blob/HEAD/src/node_api.h"><code>node_api.h</code></a> which
+is located in the src directory in the node development tree:</p>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span></code></pre>
 <p>This will opt into the default <code>NAPI_VERSION</code> for the given release of Node.js.
-In order to ensure compatibility with specific versions of N-API, the version
+In order to ensure compatibility with specific versions of Node-API, the version
 can be specified explicitly when including the header:</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> NAPI_VERSION 3</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span></code></pre>
-<p>This restricts the N-API surface to just the functionality that was available in
-the specified (and earlier) versions.</p>
-<p>Some of the N-API surface is experimental and requires explicit opt-in:</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> NAPI_EXPERIMENTAL</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span></code></pre>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">define</span> NAPI_VERSION 3</span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span></code></pre>
+<p>This restricts the Node-API surface to just the functionality that was available
+in the specified (and earlier) versions.</p>
+<p>Some of the Node-API surface is experimental and requires explicit opt-in:</p>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">define</span> NAPI_EXPERIMENTAL</span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span></code></pre>
 <p>In this case the entire API surface, including any experimental APIs, will be
 available to the module code.</p>
-<h2>N-API version matrix<span><a class="mark" href="#n_api_n_api_version_matrix" id="n_api_n_api_version_matrix">#</a></span></h2>
-<p>N-API versions are additive and versioned independently from Node.js.
+</section><section><h3>Node-API version matrix<span><a class="mark" href="#n_api_node_api_version_matrix" id="n_api_node_api_version_matrix">#</a></span></h3>
+<p>Node-API versions are additive and versioned independently from Node.js.
 Version 4 is an extension to version 3 in that it has all of the APIs
 from version 3 with some additions. This means that it is not necessary
 to recompile for new versions of Node.js which are
 listed as supporting a later version.</p>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-<table><thead><tr><th></th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th><th>6</th></tr></thead><tbody><tr><td>v6.x</td><td></td><td></td><td>v6.14.2*</td><td></td><td></td><td></td></tr><tr><td>v8.x</td><td>v8.0.0*</td><td>v8.10.0*</td><td>v8.11.2</td><td>v8.16.0</td><td></td><td></td></tr><tr><td>v9.x</td><td>v9.0.0*</td><td>v9.3.0*</td><td>v9.11.0*</td><td></td><td></td><td></td></tr><tr><td>v10.x</td><td>v10.0.0</td><td>v10.0.0</td><td>v10.0.0</td><td>v10.16.0</td><td>v10.17.0</td><td>v10.20.0</td></tr><tr><td>v11.x</td><td>v11.0.0</td><td>v11.0.0</td><td>v11.0.0</td><td>v11.8.0</td><td></td><td></td></tr><tr><td>v12.x</td><td>v12.0.0</td><td>v12.0.0</td><td>v12.0.0</td><td>v12.0.0</td><td>v12.11.0</td><td>v12.17.0</td></tr><tr><td>v13.x</td><td>v13.0.0</td><td>v13.0.0</td><td>v13.0.0</td><td>v13.0.0</td><td>v13.0.0</td><td></td></tr><tr><td>v14.x</td><td>v14.0.0</td><td>v14.0.0</td><td>v14.0.0</td><td>v14.0.0</td><td>v14.0.0</td><td>v14.0.0</td></tr></tbody></table>
-<p>* Indicates that the N-API version was released as experimental</p>
-<p>Each API documented for N-API will have a header named <code>added in:</code>, and APIs
-which are stable will have the additional header <code>N-API version:</code>.
+<!-- For accessibility purposes, this table needs row headers. That means we
+     can't do it in markdown. Hence, the raw HTML. -->
+<table>
+  <tbody><tr>
+    <td></td>
+    <th scope="col">1</th>
+    <th scope="col">2</th>
+    <th scope="col">3</th>
+  </tr>
+  <tr>
+    <th scope="row">v6.x</th>
+    <td></td>
+    <td></td>
+    <td>v6.14.2*</td>
+  </tr>
+  <tr>
+    <th scope="row">v8.x</th>
+    <td>v8.6.0**</td>
+    <td>v8.10.0*</td>
+    <td>v8.11.2</td>
+  </tr>
+  <tr>
+    <th scope="row">v9.x</th>
+    <td>v9.0.0*</td>
+    <td>v9.3.0*</td>
+    <td>v9.11.0*</td>
+  </tr>
+  <tr>
+    <th scope="row">≥ v10.x</th>
+    <td>all releases</td>
+    <td>all releases</td>
+    <td>all releases</td>
+  </tr>
+</tbody></table>
+<table>
+  <tbody><tr>
+    <td></td>
+    <th scope="col">4</th>
+    <th scope="col">5</th>
+    <th scope="col">6</th>
+    <th scope="col">7</th>
+    <th scope="col">8</th>
+  </tr>
+  <tr>
+    <th scope="row">v10.x</th>
+    <td>v10.16.0</td>
+    <td>v10.17.0</td>
+    <td>v10.20.0</td>
+    <td>v10.23.0</td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v11.x</th>
+    <td>v11.8.0</td>
+    <td></td>
+    <td></td>
+    <td></td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v12.x</th>
+    <td>v12.0.0</td>
+    <td>v12.11.0</td>
+    <td>v12.17.0</td>
+    <td>v12.19.0</td>
+    <td>v12.22.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v13.x</th>
+    <td>v13.0.0</td>
+    <td>v13.0.0</td>
+    <td></td>
+    <td></td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v14.x</th>
+    <td>v14.0.0</td>
+    <td>v14.0.0</td>
+    <td>v14.0.0</td>
+    <td>v14.12.0</td>
+    <td>v14.17.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v15.x</th>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.12.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v16.x</th>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+  </tr>
+</tbody></table>
+<p>* Node-API was experimental.</p>
+<p>** Node.js 8.0.0 included Node-API as experimental. It was released as
+Node-API version 1 but continued to evolve until Node.js 8.6.0. The API is
+different in versions prior to Node.js 8.6.0. We recommend Node-API version 3 or
+later.</p>
+<p>Each API documented for Node-API will have a header named <code>added in:</code>, and APIs
+which are stable will have the additional header <code>Node-API version:</code>.
 APIs are directly usable when using a Node.js version which supports
-the N-API version shown in <code>N-API version:</code> or higher.
+the Node-API version shown in <code>Node-API version:</code> or higher.
 When using a Node.js version that does not support the
-<code>N-API version:</code> listed or if there is no <code>N-API version:</code> listed,
+<code>Node-API version:</code> listed or if there is no <code>Node-API version:</code> listed,
 then the API will only be available if
 <code>#define NAPI_EXPERIMENTAL</code> precedes the inclusion of <code>node_api.h</code>
 or <code>js_native_api.h</code>. If an API appears not to be available on
 a version of Node.js which is later than the one shown in <code>added in:</code> then
 this is most likely the reason for the apparent absence.</p>
-<p>The N-APIs associated strictly with accessing ECMAScript features from native
+<p>The Node-APIs associated strictly with accessing ECMAScript features from native
 code can be found separately in <code>js_native_api.h</code> and <code>js_native_api_types.h</code>.
 The APIs defined in these headers are included in <code>node_api.h</code> and
 <code>node_api_types.h</code>. The headers are structured in this way in order to allow
-implementations of N-API outside of Node.js. For those implementations the
+implementations of Node-API outside of Node.js. For those implementations the
 Node.js specific APIs may not be applicable.</p>
 <p>The Node.js-specific parts of an addon can be separated from the code that
 exposes the actual functionality to the JavaScript environment so that the
-latter may be used with multiple implementations of N-API. In the example below,
-<code>addon.c</code> and <code>addon.h</code> refer only to <code>js_native_api.h</code>. This ensures that
-<code>addon.c</code> can be reused to compile against either the Node.js implementation of
-N-API or any implementation of N-API outside of Node.js.</p>
+latter may be used with multiple implementations of Node-API. In the example
+below, <code>addon.c</code> and <code>addon.h</code> refer only to <code>js_native_api.h</code>. This ensures
+that <code>addon.c</code> can be reused to compile against either the Node.js
+implementation of Node-API or any implementation of Node-API outside of Node.js.</p>
 <p><code>addon_node.c</code> is a separate file that contains the Node.js specific entry point
 to the addon and which instantiates the addon by calling into <code>addon.c</code> when the
 addon is loaded into a Node.js environment.</p>
 <pre><code class="language-c"><span class="hljs-comment">// addon.h</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">ifndef</span> _ADDON_H_</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> _ADDON_H_</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;js_native_api.h></span></span>
-<span class="hljs-function">napi_value <span class="hljs-title">create_addon</span><span class="hljs-params">(napi_env env)</span></span>;
-<span class="hljs-meta">#<span class="hljs-meta-keyword">endif</span>  <span class="hljs-comment">// _ADDON_H_</span></span></code></pre>
+<span class="hljs-meta">#<span class="hljs-keyword">ifndef</span> _ADDON_H_</span>
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> _ADDON_H_</span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;js_native_api.h></span></span>
+napi_value <span class="hljs-title function_">create_addon</span><span class="hljs-params">(napi_env env)</span>;
+<span class="hljs-meta">#<span class="hljs-keyword">endif</span>  <span class="hljs-comment">// _ADDON_H_</span></span></code></pre>
 <pre><code class="language-c"><span class="hljs-comment">// addon.c</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"addon.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"addon.h"</span></span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> NAPI_CALL(env, call)                                      \
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> NAPI_CALL(env, call)                                      \
   do {                                                            \
     napi_status status = (call);                                  \
-    <span class="hljs-meta-keyword">if</span> (status != napi_ok) {                                      \
+    <span class="hljs-keyword">if</span> (status != napi_ok) {                                      \
       const napi_extended_error_info* error_info = NULL;          \
       napi_get_last_error_info((env), &#x26;error_info);               \
       bool is_pending;                                            \
       napi_is_exception_pending((env), &#x26;is_pending);              \
-      <span class="hljs-meta-keyword">if</span> (!is_pending) {                                          \
+      <span class="hljs-keyword">if</span> (!is_pending) {                                          \
         const char* message = (error_info->error_message == NULL) \
-            ? <span class="hljs-meta-string">"empty error message"</span>                               \
+            ? <span class="hljs-string">"empty error message"</span>                               \
             : error_info->error_message;                          \
         napi_throw_error((env), NULL, message);                   \
         return NULL;                                              \
@@ -10836,13 +11409,13 @@ addon is loaded into a Node.js environment.</p>
     }                                                             \
   } while(0)</span>
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> napi_value
-<span class="hljs-title">DoSomethingUseful</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
+<span class="hljs-keyword">static</span> napi_value
+<span class="hljs-title function_">DoSomethingUseful</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
   <span class="hljs-comment">// Do something useful.</span>
   <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
 }
 
-<span class="hljs-function">napi_value <span class="hljs-title">create_addon</span><span class="hljs-params">(napi_env env)</span> </span>{
+napi_value <span class="hljs-title function_">create_addon</span><span class="hljs-params">(napi_env env)</span> {
   napi_value result;
   NAPI_CALL(env, napi_create_object(env, &#x26;result));
 
@@ -10862,8 +11435,8 @@ addon is loaded into a Node.js environment.</p>
   <span class="hljs-keyword">return</span> result;
 }</code></pre>
 <pre><code class="language-c"><span class="hljs-comment">// addon_node.c</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"addon.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"addon.h"</span></span>
 
 NAPI_MODULE_INIT() {
   <span class="hljs-comment">// This function body is expected to return a `napi_value`.</span>
@@ -10871,7 +11444,7 @@ NAPI_MODULE_INIT() {
   <span class="hljs-comment">// the body, as they are provided by the definition of `NAPI_MODULE_INIT()`.</span>
   <span class="hljs-keyword">return</span> create_addon(env);
 }</code></pre>
-<h2>Environment life cycle APIs<span><a class="mark" href="#n_api_environment_life_cycle_apis" id="n_api_environment_life_cycle_apis">#</a></span></h2>
+</section><section><h3>Environment life cycle APIs<span><a class="mark" href="#n_api_environment_life_cycle_apis" id="n_api_environment_life_cycle_apis">#</a></span></h3>
 <p><a href="https://tc39.es/ecma262/#sec-agents">Section 8.7</a> of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a> defines the concept
 of an "Agent" as a self-contained environment in which JavaScript code runs.
 Multiple such Agents may be started and terminated either concurrently or in
@@ -10890,19 +11463,19 @@ multiple threads.</p>
 <p>Native addons may need to allocate global state which they use during
 their entire life cycle such that the state must be unique to each instance of
 the addon.</p>
-<p>To this end, N-API provides a way to allocate data such that its life cycle is
-tied to the life cycle of the Agent.</p>
-<h3>napi_set_instance_data<span><a class="mark" href="#n_api_napi_set_instance_data" id="n_api_napi_set_instance_data">#</a></span></h3>
+<p>To this end, Node-API provides a way to allocate data such that its life cycle
+is tied to the life cycle of the Agent.</p>
+<h4>napi_set_instance_data<span><a class="mark" href="#n_api_napi_set_instance_data" id="n_api_napi_set_instance_data">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.8.0</span>
+<span>Added in: v12.8.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_set_instance_data</span><span class="hljs-params">(napi_env env,
-                                   <span class="hljs-keyword">void</span>* data,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_set_instance_data</span><span class="hljs-params">(napi_env env,
+                                   <span class="hljs-type">void</span>* data,
                                    napi_finalize finalize_cb,
-                                   <span class="hljs-keyword">void</span>* finalize_hint)</span></span>;</code></pre>
+                                   <span class="hljs-type">void</span>* finalize_hint)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] data</code>: The data item to make available to bindings of this instance.</li>
 <li><code>[in] finalize_cb</code>: The function to call when the environment is being torn
 down. The function receives <code>data</code> so that it might free it.
@@ -10916,15 +11489,15 @@ be retrieved using <code>napi_get_instance_data()</code>. Any existing data asso
 the currently running Agent which was set by means of a previous call to
 <code>napi_set_instance_data()</code> will be overwritten. If a <code>finalize_cb</code> was provided
 by the previous call, it will not be called.</p>
-<h3>napi_get_instance_data<span><a class="mark" href="#n_api_napi_get_instance_data" id="n_api_napi_get_instance_data">#</a></span></h3>
+<h4>napi_get_instance_data<span><a class="mark" href="#n_api_napi_get_instance_data" id="n_api_napi_get_instance_data">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.8.0</span>
+<span>Added in: v12.8.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_instance_data</span><span class="hljs-params">(napi_env env,
-                                   <span class="hljs-keyword">void</span>** data)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_instance_data</span><span class="hljs-params">(napi_env env,
+                                   <span class="hljs-type">void</span>** data)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[out] data</code>: The data item that was previously associated with the currently
 running Agent by a call to <code>napi_set_instance_data()</code>.</li>
 </ul>
@@ -10932,18 +11505,18 @@ running Agent by a call to <code>napi_set_instance_data()</code>.</li>
 <p>This API retrieves data that was previously associated with the currently
 running Agent via <code>napi_set_instance_data()</code>. If no data is set, the call will
 succeed and <code>data</code> will be set to <code>NULL</code>.</p>
-<h2>Basic N-API data types<span><a class="mark" href="#n_api_basic_n_api_data_types" id="n_api_basic_n_api_data_types">#</a></span></h2>
-<p>N-API exposes the following fundamental datatypes as abstractions that are
+</section><section><h3>Basic Node-API data types<span><a class="mark" href="#n_api_basic_node_api_data_types" id="n_api_basic_node_api_data_types">#</a></span></h3>
+<p>Node-API exposes the following fundamental datatypes as abstractions that are
 consumed by the various APIs. These APIs should be treated as opaque,
-introspectable only with other N-API calls.</p>
-<h3>napi_status<span><a class="mark" href="#n_api_napi_status" id="n_api_napi_status">#</a></span></h3>
+introspectable only with other Node-API calls.</p>
+<h4>napi_status<span><a class="mark" href="#n_api_napi_status" id="n_api_napi_status">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<p>Integral status code indicating the success or failure of a N-API call.
+<p>Integral status code indicating the success or failure of a Node-API call.
 Currently, the following status codes are supported.</p>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_ok,
   napi_invalid_arg,
   napi_object_expected,
@@ -10965,18 +11538,19 @@ Currently, the following status codes are supported.</p>
   napi_date_expected,
   napi_arraybuffer_expected,
   napi_detachable_arraybuffer_expected,
+  napi_would_deadlock,  <span class="hljs-comment">/* unused */</span>
 } napi_status;</code></pre>
 <p>If additional information is required upon an API returning a failed status,
 it can be obtained by calling <code>napi_get_last_error_info</code>.</p>
-<h3>napi_extended_error_info<span><a class="mark" href="#n_api_napi_extended_error_info" id="n_api_napi_extended_error_info">#</a></span></h3>
+<h4>napi_extended_error_info<span><a class="mark" href="#n_api_napi_extended_error_info" id="n_api_napi_extended_error_info">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> {</span>
-  <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* error_message;
-  <span class="hljs-keyword">void</span>* engine_reserved;
-  <span class="hljs-keyword">uint32_t</span> engine_error_code;
+  <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* error_message;
+  <span class="hljs-type">void</span>* engine_reserved;
+  <span class="hljs-type">uint32_t</span> engine_error_code;
   napi_status error_code;
 } napi_extended_error_info;</code></pre>
 <ul>
@@ -10986,24 +11560,24 @@ the error.</li>
 not implemented for any VM.</li>
 <li><code>engine_error_code</code>: VM-specific error code. This is currently
 not implemented for any VM.</li>
-<li><code>error_code</code>: The N-API status code that originated with the last error.</li>
+<li><code>error_code</code>: The Node-API status code that originated with the last error.</li>
 </ul>
 <p>See the <a href="#n_api_error_handling">Error handling</a> section for additional information.</p>
-<h3>napi_env<span><a class="mark" href="#n_api_napi_env" id="n_api_napi_env">#</a></span></h3>
-<p><code>napi_env</code> is used to represent a context that the underlying N-API
+<h4>napi_env<span><a class="mark" href="#n_api_napi_env" id="n_api_napi_env">#</a></span></h4>
+<p><code>napi_env</code> is used to represent a context that the underlying Node-API
 implementation can use to persist VM-specific state. This structure is passed
 to native functions when they're invoked, and it must be passed back when
-making N-API calls. Specifically, the same <code>napi_env</code> that was passed in when
+making Node-API calls. Specifically, the same <code>napi_env</code> that was passed in when
 the initial native function was called must be passed to any subsequent
-nested N-API calls. Caching the <code>napi_env</code> for the purpose of general reuse,
+nested Node-API calls. Caching the <code>napi_env</code> for the purpose of general reuse,
 and passing the <code>napi_env</code> between instances of the same addon running on
 different <a href="#worker_threads_class_worker"><code>Worker</code></a> threads is not allowed. The <code>napi_env</code> becomes invalid
 when an instance of a native addon is unloaded. Notification of this event is
 delivered through the callbacks given to <a href="#n_api_napi_add_env_cleanup_hook"><code>napi_add_env_cleanup_hook</code></a> and
 <a href="#n_api_napi_set_instance_data"><code>napi_set_instance_data</code></a>.</p>
-<h3>napi_value<span><a class="mark" href="#n_api_napi_value" id="n_api_napi_value">#</a></span></h3>
+<h4>napi_value<span><a class="mark" href="#n_api_napi_value" id="n_api_napi_value">#</a></span></h4>
 <p>This is an opaque pointer that is used to represent a JavaScript value.</p>
-<h3>napi_threadsafe_function<span><a class="mark" href="#n_api_napi_threadsafe_function" id="n_api_napi_threadsafe_function">#</a></span></h3>
+<h4>napi_threadsafe_function<span><a class="mark" href="#n_api_napi_threadsafe_function" id="n_api_napi_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
@@ -11011,7 +11585,7 @@ delivered through the callbacks given to <a href="#n_api_napi_add_env_cleanup_ho
 <p>This is an opaque pointer that represents a JavaScript function which can be
 called asynchronously from multiple threads via
 <code>napi_call_threadsafe_function()</code>.</p>
-<h3>napi_threadsafe_function_release_mode<span><a class="mark" href="#n_api_napi_threadsafe_function_release_mode" id="n_api_napi_threadsafe_function_release_mode">#</a></span></h3>
+<h4>napi_threadsafe_function_release_mode<span><a class="mark" href="#n_api_napi_threadsafe_function_release_mode" id="n_api_napi_threadsafe_function_release_mode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
@@ -11020,11 +11594,11 @@ called asynchronously from multiple threads via
 the thread-safe function is to be closed immediately (<code>napi_tsfn_abort</code>) or
 merely released (<code>napi_tsfn_release</code>) and thus available for subsequent use via
 <code>napi_acquire_threadsafe_function()</code> and <code>napi_call_threadsafe_function()</code>.</p>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_tsfn_release,
   napi_tsfn_abort
 } napi_threadsafe_function_release_mode;</code></pre>
-<h3>napi_threadsafe_function_call_mode<span><a class="mark" href="#n_api_napi_threadsafe_function_call_mode" id="n_api_napi_threadsafe_function_call_mode">#</a></span></h3>
+<h4>napi_threadsafe_function_call_mode<span><a class="mark" href="#n_api_napi_threadsafe_function_call_mode" id="n_api_napi_threadsafe_function_call_mode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
@@ -11032,17 +11606,17 @@ merely released (<code>napi_tsfn_release</code>) and thus available for subseque
 <p>A value to be given to <code>napi_call_threadsafe_function()</code> to indicate whether
 the call should block whenever the queue associated with the thread-safe
 function is full.</p>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_tsfn_nonblocking,
   napi_tsfn_blocking
 } napi_threadsafe_function_call_mode;</code></pre>
-<h3>N-API memory management types<span><a class="mark" href="#n_api_n_api_memory_management_types" id="n_api_n_api_memory_management_types">#</a></span></h3>
-<h4>napi_handle_scope<span><a class="mark" href="#n_api_napi_handle_scope" id="n_api_napi_handle_scope">#</a></span></h4>
+<h4>Node-API memory management types<span><a class="mark" href="#n_api_node_api_memory_management_types" id="n_api_node_api_memory_management_types">#</a></span></h4>
+<h5>napi_handle_scope<span><a class="mark" href="#n_api_napi_handle_scope" id="n_api_napi_handle_scope">#</a></span></h5>
 <p>This is an abstraction used to control and modify the lifetime of objects
-created within a particular scope. In general, N-API values are created within
-the context of a handle scope. When a native method is called from
+created within a particular scope. In general, Node-API values are created
+within the context of a handle scope. When a native method is called from
 JavaScript, a default handle scope will exist. If the user does not explicitly
-create a new handle scope, N-API values will be created in the default handle
+create a new handle scope, Node-API values will be created in the default handle
 scope. For any invocations of code outside the execution of a native method
 (for instance, during a libuv callback invocation), the module is required to
 create a scope before invoking any functions that can result in the creation
@@ -11052,14 +11626,14 @@ using <a href="#n_api_napi_close_handle_scope"><code>napi_close_handle_scope</co
 that all <code>napi_value</code>s created during the lifetime of the handle scope are no
 longer referenced from the current stack frame.</p>
 <p>For more details, review the <a href="#n_api_object_lifetime_management">Object lifetime management</a>.</p>
-<h4>napi_escapable_handle_scope<span><a class="mark" href="#n_api_napi_escapable_handle_scope" id="n_api_napi_escapable_handle_scope">#</a></span></h4>
+<h5>napi_escapable_handle_scope<span><a class="mark" href="#n_api_napi_escapable_handle_scope" id="n_api_napi_escapable_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <p>Escapable handle scopes are a special type of handle scope to return values
 created within a particular handle scope to a parent scope.</p>
-<h4>napi_ref<span><a class="mark" href="#n_api_napi_ref" id="n_api_napi_ref">#</a></span></h4>
+<h5>napi_ref<span><a class="mark" href="#n_api_napi_ref" id="n_api_napi_ref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
@@ -11068,9 +11642,9 @@ created within a particular handle scope to a parent scope.</p>
 users to manage the lifetimes of JavaScript values, including defining their
 minimum lifetimes explicitly.</p>
 <p>For more details, review the <a href="#n_api_object_lifetime_management">Object lifetime management</a>.</p>
-<h4>napi_type_tag<span><a class="mark" href="#n_api_napi_type_tag" id="n_api_napi_type_tag">#</a></span></h4>
+<h5>napi_type_tag<span><a class="mark" href="#n_api_napi_type_tag" id="n_api_napi_type_tag">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0, v12.19.0</span>
 <span>N-API version: 8</span>
 </div>
 <p>A 128-bit value stored as two unsigned 64-bit integers. It serves as a UUID
@@ -11082,18 +11656,18 @@ because it ensures that the pointer retrieved from a wrapped object can be
 safely cast to the native type corresponding to the type tag that had been
 previously applied to the JavaScript object.</p>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> {</span>
-  <span class="hljs-keyword">uint64_t</span> lower;
-  <span class="hljs-keyword">uint64_t</span> upper;
+  <span class="hljs-type">uint64_t</span> lower;
+  <span class="hljs-type">uint64_t</span> upper;
 } napi_type_tag;</code></pre>
-<h4>napi_async_cleanup_hook_handle<span><a class="mark" href="#n_api_napi_async_cleanup_hook_handle" id="n_api_napi_async_cleanup_hook_handle">#</a></span></h4>
+<h5>napi_async_cleanup_hook_handle<span><a class="mark" href="#n_api_napi_async_cleanup_hook_handle" id="n_api_napi_async_cleanup_hook_handle">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.10.0</span>
 </div>
 <p>An opaque value returned by <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a>. It must be passed
 to <a href="#n_api_napi_remove_async_cleanup_hook"><code>napi_remove_async_cleanup_hook</code></a> when the chain of asynchronous cleanup
 events completes.</p>
-<h3>N-API callback types<span><a class="mark" href="#n_api_n_api_callback_types" id="n_api_n_api_callback_types">#</a></span></h3>
-<h4>napi_callback_info<span><a class="mark" href="#n_api_napi_callback_info" id="n_api_napi_callback_info">#</a></span></h4>
+<h4>Node-API callback types<span><a class="mark" href="#n_api_node_api_callback_types" id="n_api_node_api_callback_types">#</a></span></h4>
+<h5>napi_callback_info<span><a class="mark" href="#n_api_napi_callback_info" id="n_api_napi_callback_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
@@ -11101,18 +11675,18 @@ events completes.</p>
 <p>Opaque datatype that is passed to a callback function. It can be used for
 getting additional information about the context in which the callback was
 invoked.</p>
-<h4>napi_callback<span><a class="mark" href="#n_api_napi_callback" id="n_api_napi_callback">#</a></span></h4>
+<h5>napi_callback<span><a class="mark" href="#n_api_napi_callback" id="n_api_napi_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <p>Function pointer type for user-provided native functions which are to be
-exposed to JavaScript via N-API. Callback functions should satisfy the
+exposed to JavaScript via Node-API. Callback functions should satisfy the
 following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">napi_value</span> <span class="hljs-params">(*napi_callback)</span><span class="hljs-params">(napi_env, napi_callback_info)</span></span>;</code></pre>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">napi_value</span> <span class="hljs-params">(*napi_callback)</span><span class="hljs-params">(napi_env, napi_callback_info)</span>;</code></pre>
 <p>Unless for reasons discussed in <a href="#n_api_object_lifetime_management">Object Lifetime Management</a>, creating a
 handle and/or callback scope inside a <code>napi_callback</code> is not necessary.</p>
-<h4>napi_finalize<span><a class="mark" href="#n_api_napi_finalize" id="n_api_napi_finalize">#</a></span></h4>
+<h5>napi_finalize<span><a class="mark" href="#n_api_napi_finalize" id="n_api_napi_finalize">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
@@ -11123,36 +11697,36 @@ object with which it was associated with, has been garbage-collected. The user
 must provide a function satisfying the following signature which would get
 called upon the object's collection. Currently, <code>napi_finalize</code> can be used for
 finding out when objects that have external data are collected.</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_finalize)</span><span class="hljs-params">(napi_env env,
-                              <span class="hljs-keyword">void</span>* finalize_data,
-                              <span class="hljs-keyword">void</span>* finalize_hint)</span></span>;</code></pre>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_finalize)</span><span class="hljs-params">(napi_env env,
+                              <span class="hljs-type">void</span>* finalize_data,
+                              <span class="hljs-type">void</span>* finalize_hint)</span>;</code></pre>
 <p>Unless for reasons discussed in <a href="#n_api_object_lifetime_management">Object Lifetime Management</a>, creating a
 handle and/or callback scope inside the function body is not necessary.</p>
-<h4>napi_async_execute_callback<span><a class="mark" href="#n_api_napi_async_execute_callback" id="n_api_napi_async_execute_callback">#</a></span></h4>
+<h5>napi_async_execute_callback<span><a class="mark" href="#n_api_napi_async_execute_callback" id="n_api_napi_async_execute_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <p>Function pointer used with functions that support asynchronous
 operations. Callback functions must satisfy the following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_execute_callback)</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
-<p>Implementations of this function must avoid making N-API calls that execute
-JavaScript or interact with JavaScript objects. N-API calls should be in the
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_execute_callback)</span><span class="hljs-params">(napi_env env, <span class="hljs-type">void</span>* data)</span>;</code></pre>
+<p>Implementations of this function must avoid making Node-API calls that execute
+JavaScript or interact with JavaScript objects. Node-API calls should be in the
 <code>napi_async_complete_callback</code> instead. Do not use the <code>napi_env</code> parameter as
 it will likely result in execution of JavaScript.</p>
-<h4>napi_async_complete_callback<span><a class="mark" href="#n_api_napi_async_complete_callback" id="n_api_napi_async_complete_callback">#</a></span></h4>
+<h5>napi_async_complete_callback<span><a class="mark" href="#n_api_napi_async_complete_callback" id="n_api_napi_async_complete_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <p>Function pointer used with functions that support asynchronous
 operations. Callback functions must satisfy the following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_complete_callback)</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_complete_callback)</span><span class="hljs-params">(napi_env env,
                                              napi_status status,
-                                             <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
+                                             <span class="hljs-type">void</span>* data)</span>;</code></pre>
 <p>Unless for reasons discussed in <a href="#n_api_object_lifetime_management">Object Lifetime Management</a>, creating a
 handle and/or callback scope inside the function body is not necessary.</p>
-<h4>napi_threadsafe_function_call_js<span><a class="mark" href="#n_api_napi_threadsafe_function_call_js" id="n_api_napi_threadsafe_function_call_js">#</a></span></h4>
+<h5>napi_threadsafe_function_call_js<span><a class="mark" href="#n_api_napi_threadsafe_function_call_js" id="n_api_napi_threadsafe_function_call_js">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
@@ -11165,14 +11739,14 @@ make the call into JavaScript.</p>
 <p>The data arriving from the secondary thread via the queue is given in the <code>data</code>
 parameter and the JavaScript function to call is given in the <code>js_callback</code>
 parameter.</p>
-<p>N-API sets up the environment prior to calling this callback, so it is
+<p>Node-API sets up the environment prior to calling this callback, so it is
 sufficient to call the JavaScript function via <code>napi_call_function</code> rather than
 via <code>napi_make_callback</code>.</p>
 <p>Callback functions must satisfy the following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_threadsafe_function_call_js)</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_threadsafe_function_call_js)</span><span class="hljs-params">(napi_env env,
                                                  napi_value js_callback,
-                                                 <span class="hljs-keyword">void</span>* context,
-                                                 <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
+                                                 <span class="hljs-type">void</span>* context,
+                                                 <span class="hljs-type">void</span>* data)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment to use for API calls, or <code>NULL</code> if the thread-safe
 function is being torn down and <code>data</code> may need to be freed.</li>
@@ -11183,22 +11757,22 @@ may also be <code>NULL</code> if the thread-safe function was created without
 <li><code>[in] context</code>: The optional data with which the thread-safe function was
 created.</li>
 <li><code>[in] data</code>: Data created by the secondary thread. It is the responsibility of
-the callback to convert this native data to JavaScript values (with N-API
+the callback to convert this native data to JavaScript values (with Node-API
 functions) that can be passed as parameters when <code>js_callback</code> is invoked.
 This pointer is managed entirely by the threads and this callback. Thus this
 callback should free the data.</li>
 </ul>
 <p>Unless for reasons discussed in <a href="#n_api_object_lifetime_management">Object Lifetime Management</a>, creating a
 handle and/or callback scope inside the function body is not necessary.</p>
-<h4>napi_async_cleanup_hook<span><a class="mark" href="#n_api_napi_async_cleanup_hook" id="n_api_napi_async_cleanup_hook">#</a></span></h4>
+<h5>napi_async_cleanup_hook<span><a class="mark" href="#n_api_napi_async_cleanup_hook" id="n_api_napi_async_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.10.0</span>
 </div>
 <p>Function pointer used with <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a>. It will be called
 when the environment is being torn down.</p>
 <p>Callback functions must satisfy the following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_cleanup_hook)</span><span class="hljs-params">(napi_async_cleanup_hook_handle handle,
-                                        <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_cleanup_hook)</span><span class="hljs-params">(napi_async_cleanup_hook_handle handle,
+                                        <span class="hljs-type">void</span>* data)</span>;</code></pre>
 <ul>
 <li><code>[in] handle</code>: The handle that must be passed to
 <a href="#n_api_napi_remove_async_cleanup_hook"><code>napi_remove_async_cleanup_hook</code></a> after completion of the asynchronous
@@ -11208,11 +11782,11 @@ cleanup.</li>
 <p>The body of the function should initiate the asynchronous cleanup actions at the
 end of which <code>handle</code> must be passed in a call to
 <a href="#n_api_napi_remove_async_cleanup_hook"><code>napi_remove_async_cleanup_hook</code></a>.</p>
-<h2>Error handling<span><a class="mark" href="#n_api_error_handling" id="n_api_error_handling">#</a></span></h2>
-<p>N-API uses both return values and JavaScript exceptions for error handling.
+</section><section><h3>Error handling<span><a class="mark" href="#n_api_error_handling" id="n_api_error_handling">#</a></span></h3>
+<p>Node-API uses both return values and JavaScript exceptions for error handling.
 The following sections explain the approach for each case.</p>
-<h3>Return values<span><a class="mark" href="#n_api_return_values" id="n_api_return_values">#</a></span></h3>
-<p>All of the N-API functions share the same error handling pattern. The
+<h4>Return values<span><a class="mark" href="#n_api_return_values" id="n_api_return_values">#</a></span></h4>
+<p>All of the Node-API functions share the same error handling pattern. The
 return type of all API functions is <code>napi_status</code>.</p>
 <p>The return value will be <code>napi_ok</code> if the request was successful and
 no uncaught JavaScript exception was thrown. If an error occurred AND
@@ -11237,30 +11811,30 @@ The format of the <code>napi_extended_error_info</code> structure is as follows:
 <span>N-API version: 1</span>
 </div>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> <span class="hljs-title">napi_extended_error_info</span> {</span>
-  <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* error_message;
-  <span class="hljs-keyword">void</span>* engine_reserved;
-  <span class="hljs-keyword">uint32_t</span> engine_error_code;
+  <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* error_message;
+  <span class="hljs-type">void</span>* engine_reserved;
+  <span class="hljs-type">uint32_t</span> engine_error_code;
   napi_status error_code;
 };</code></pre>
 <ul>
 <li><code>error_message</code>: Textual representation of the error that occurred.</li>
 <li><code>engine_reserved</code>: Opaque handle reserved for engine use only.</li>
 <li><code>engine_error_code</code>: VM specific error code.</li>
-<li><code>error_code</code>: n-api status code for the last error.</li>
+<li><code>error_code</code>: Node-API status code for the last error.</li>
 </ul>
 <p><a href="#n_api_napi_get_last_error_info"><code>napi_get_last_error_info</code></a> returns the information for the last
-N-API call that was made.</p>
+Node-API call that was made.</p>
 <p>Do not rely on the content or format of any of the extended information as it
 is not subject to SemVer and may change at any time. It is intended only for
 logging purposes.</p>
-<h4>napi_get_last_error_info<span><a class="mark" href="#n_api_napi_get_last_error_info" id="n_api_napi_get_last_error_info">#</a></span></h4>
+<h5>napi_get_last_error_info<span><a class="mark" href="#n_api_napi_get_last_error_info" id="n_api_napi_get_last_error_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status
-<span class="hljs-title">napi_get_last_error_info</span><span class="hljs-params">(napi_env env,
-                         <span class="hljs-keyword">const</span> napi_extended_error_info** result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status
+<span class="hljs-title function_">napi_get_last_error_info</span><span class="hljs-params">(napi_env env,
+                         <span class="hljs-keyword">const</span> napi_extended_error_info** result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: The <code>napi_extended_error_info</code> structure with more
@@ -11270,13 +11844,13 @@ information about the error.</li>
 <p>This API retrieves a <code>napi_extended_error_info</code> structure with information
 about the last error that occurred.</p>
 <p>The content of the <code>napi_extended_error_info</code> returned is only valid up until
-an n-api function is called on the same <code>env</code>.</p>
+a Node-API function is called on the same <code>env</code>.</p>
 <p>Do not rely on the content or format of any of the extended information as it
 is not subject to SemVer and may change at any time. It is intended only for
 logging purposes.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h3>Exceptions<span><a class="mark" href="#n_api_exceptions" id="n_api_exceptions">#</a></span></h3>
-<p>Any N-API function call may result in a pending JavaScript exception. This is
+<h4>Exceptions<span><a class="mark" href="#n_api_exceptions" id="n_api_exceptions">#</a></span></h4>
+<p>Any Node-API function call may result in a pending JavaScript exception. This is
 the case for any of the API functions, even those that may not cause the
 execution of JavaScript.</p>
 <p>If the <code>napi_status</code> returned by a function is <code>napi_ok</code> then no
@@ -11285,10 +11859,10 @@ exception is pending and no additional action is required. If the
 <code>napi_pending_exception</code>, in order to try to recover and continue
 instead of simply returning immediately, <a href="#n_api_napi_is_exception_pending"><code>napi_is_exception_pending</code></a>
 must be called in order to determine if an exception is pending or not.</p>
-<p>In many cases when an N-API function is called and an exception is
+<p>In many cases when a Node-API function is called and an exception is
 already pending, the function will return immediately with a
 <code>napi_status</code> of <code>napi_pending_exception</code>. However, this is not the case
-for all functions. N-API allows a subset of the functions to be
+for all functions. Node-API allows a subset of the functions to be
 called to allow for some minimal cleanup before returning to JavaScript.
 In that case, <code>napi_status</code> will reflect the status for the function. It
 will not reflect previous pending exceptions. To avoid confusion, check
@@ -11297,7 +11871,7 @@ the error status after every function call.</p>
 <p>The first approach is to do any appropriate cleanup and then return so that
 execution will return to JavaScript. As part of the transition back to
 JavaScript, the exception will be thrown at the point in the JavaScript
-code where the native method was invoked. The behavior of most N-API calls
+code where the native method was invoked. The behavior of most Node-API calls
 is unspecified while an exception is pending, and many will simply return
 <code>napi_pending_exception</code>, so do as little as possible and then return to
 JavaScript where the exception can be handled.</p>
@@ -11310,7 +11884,7 @@ clear the exception. On success, result will contain the handle to
 the last JavaScript <code>Object</code> thrown. If it is determined, after
 retrieving the exception, the exception cannot be handled after all
 it can be re-thrown it with <a href="#n_api_napi_throw"><code>napi_throw</code></a> where error is the
-JavaScript <code>Error</code> object to be thrown.</p>
+JavaScript value to be thrown.</p>
 <p>The following utility functions are also available in case native code
 needs to throw an exception or determine if a <code>napi_value</code> is an instance
 of a JavaScript <code>Error</code> object: <a href="#n_api_napi_throw_error"><code>napi_throw_error</code></a>,
@@ -11326,7 +11900,7 @@ generated internally. The goal is for applications to use these
 error codes for all error checking. The associated error messages
 will remain, but will only be meant to be used for logging and
 display with the expectation that the message can change without
-SemVer applying. In order to support this model with N-API, both
+SemVer applying. In order to support this model with Node-API, both
 in internal functionality and for module specific functionality
 (as its good practice), the <code>throw_</code> and <code>create_</code> functions
 take an optional code parameter which is the string for the code
@@ -11338,26 +11912,26 @@ the name associated with the error is also updated to be:</p>
 and <code>code</code> is the code that was provided. For example, if the code
 is <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the name will be:</p>
 <pre><code class="language-text">TypeError [ERR_ERROR_1]</code></pre>
-<h4>napi_throw<span><a class="mark" href="#n_api_napi_throw" id="n_api_napi_throw">#</a></span></h4>
+<h5>napi_throw<span><a class="mark" href="#n_api_napi_throw" id="n_api_napi_throw">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_throw</span><span class="hljs-params">(napi_env env, napi_value error)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_throw</span><span class="hljs-params">(napi_env env, napi_value error)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] error</code>: The JavaScript value to be thrown.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API throws the JavaScript value provided.</p>
-<h4>napi_throw_error<span><a class="mark" href="#n_api_napi_throw_error" id="n_api_napi_throw_error">#</a></span></h4>
+<h5>napi_throw_error<span><a class="mark" href="#n_api_napi_throw_error" id="n_api_napi_throw_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_throw_error</span><span class="hljs-params">(napi_env env,
-                                         <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* code,
-                                         <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* msg)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_throw_error</span><span class="hljs-params">(napi_env env,
+                                         <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* code,
+                                         <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* msg)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional error code to be set on the error.</li>
@@ -11365,14 +11939,14 @@ is <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API throws a JavaScript <code>Error</code> with the text provided.</p>
-<h4>napi_throw_type_error<span><a class="mark" href="#n_api_napi_throw_type_error" id="n_api_napi_throw_type_error">#</a></span></h4>
+<h5>napi_throw_type_error<span><a class="mark" href="#n_api_napi_throw_type_error" id="n_api_napi_throw_type_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_throw_type_error</span><span class="hljs-params">(napi_env env,
-                                              <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* code,
-                                              <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* msg)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_throw_type_error</span><span class="hljs-params">(napi_env env,
+                                              <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* code,
+                                              <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* msg)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional error code to be set on the error.</li>
@@ -11380,14 +11954,14 @@ is <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API throws a JavaScript <code>TypeError</code> with the text provided.</p>
-<h4>napi_throw_range_error<span><a class="mark" href="#n_api_napi_throw_range_error" id="n_api_napi_throw_range_error">#</a></span></h4>
+<h5>napi_throw_range_error<span><a class="mark" href="#n_api_napi_throw_range_error" id="n_api_napi_throw_range_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_throw_range_error</span><span class="hljs-params">(napi_env env,
-                                               <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* code,
-                                               <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* msg)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_throw_range_error</span><span class="hljs-params">(napi_env env,
+                                               <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* code,
+                                               <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* msg)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional error code to be set on the error.</li>
@@ -11395,14 +11969,14 @@ is <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API throws a JavaScript <code>RangeError</code> with the text provided.</p>
-<h4>napi_is_error<span><a class="mark" href="#n_api_napi_is_error" id="n_api_napi_is_error">#</a></span></h4>
+<h5>napi_is_error<span><a class="mark" href="#n_api_napi_is_error" id="n_api_napi_is_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_is_error</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_is_error</span><span class="hljs-params">(napi_env env,
                                       napi_value value,
-                                      <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                      <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The <code>napi_value</code> to be checked.</li>
@@ -11411,112 +11985,112 @@ an error, false otherwise.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API queries a <code>napi_value</code> to check if it represents an error object.</p>
-<h4>napi_create_error<span><a class="mark" href="#n_api_napi_create_error" id="n_api_napi_create_error">#</a></span></h4>
+<h5>napi_create_error<span><a class="mark" href="#n_api_napi_create_error" id="n_api_napi_create_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_create_error</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_create_error</span><span class="hljs-params">(napi_env env,
                                           napi_value code,
                                           napi_value msg,
-                                          napi_value* result)</span></span>;</code></pre>
+                                          napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be
 associated with the error.</li>
-<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as
+<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as
 the message for the <code>Error</code>.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns a JavaScript <code>Error</code> with the text provided.</p>
-<h4>napi_create_type_error<span><a class="mark" href="#n_api_napi_create_type_error" id="n_api_napi_create_type_error">#</a></span></h4>
+<h5>napi_create_type_error<span><a class="mark" href="#n_api_napi_create_type_error" id="n_api_napi_create_type_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_create_type_error</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_create_type_error</span><span class="hljs-params">(napi_env env,
                                                napi_value code,
                                                napi_value msg,
-                                               napi_value* result)</span></span>;</code></pre>
+                                               napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be
 associated with the error.</li>
-<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as
+<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as
 the message for the <code>Error</code>.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns a JavaScript <code>TypeError</code> with the text provided.</p>
-<h4>napi_create_range_error<span><a class="mark" href="#n_api_napi_create_range_error" id="n_api_napi_create_range_error">#</a></span></h4>
+<h5>napi_create_range_error<span><a class="mark" href="#n_api_napi_create_range_error" id="n_api_napi_create_range_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_create_range_error</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_create_range_error</span><span class="hljs-params">(napi_env env,
                                                 napi_value code,
                                                 napi_value msg,
-                                                napi_value* result)</span></span>;</code></pre>
+                                                napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be
 associated with the error.</li>
-<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as
+<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as
 the message for the <code>Error</code>.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns a JavaScript <code>RangeError</code> with the text provided.</p>
-<h4>napi_get_and_clear_last_exception<span><a class="mark" href="#n_api_napi_get_and_clear_last_exception" id="n_api_napi_get_and_clear_last_exception">#</a></span></h4>
+<h5>napi_get_and_clear_last_exception<span><a class="mark" href="#n_api_napi_get_and_clear_last_exception" id="n_api_napi_get_and_clear_last_exception">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_and_clear_last_exception</span><span class="hljs-params">(napi_env env,
-                                              napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_and_clear_last_exception</span><span class="hljs-params">(napi_env env,
+                                              napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: The exception if one is pending, <code>NULL</code> otherwise.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_is_exception_pending<span><a class="mark" href="#n_api_napi_is_exception_pending" id="n_api_napi_is_exception_pending">#</a></span></h4>
+<h5>napi_is_exception_pending<span><a class="mark" href="#n_api_napi_is_exception_pending" id="n_api_napi_is_exception_pending">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_exception_pending</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_exception_pending</span><span class="hljs-params">(napi_env env, <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: Boolean value that is set to true if an exception is pending.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_fatal_exception<span><a class="mark" href="#n_api_napi_fatal_exception" id="n_api_napi_fatal_exception">#</a></span></h4>
+<h5>napi_fatal_exception<span><a class="mark" href="#n_api_napi_fatal_exception" id="n_api_napi_fatal_exception">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.10.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_fatal_exception</span><span class="hljs-params">(napi_env env, napi_value err)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_fatal_exception</span><span class="hljs-params">(napi_env env, napi_value err)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] err</code>: The error that is passed to <code>'uncaughtException'</code>.</li>
 </ul>
 <p>Trigger an <code>'uncaughtException'</code> in JavaScript. Useful if an async
 callback throws an exception with no way to recover.</p>
-<h3>Fatal errors<span><a class="mark" href="#n_api_fatal_errors" id="n_api_fatal_errors">#</a></span></h3>
+<h4>Fatal errors<span><a class="mark" href="#n_api_fatal_errors" id="n_api_fatal_errors">#</a></span></h4>
 <p>In the event of an unrecoverable error in a native module, a fatal error can be
 thrown to immediately terminate the process.</p>
-<h4>napi_fatal_error<span><a class="mark" href="#n_api_napi_fatal_error" id="n_api_napi_fatal_error">#</a></span></h4>
+<h5>napi_fatal_error<span><a class="mark" href="#n_api_napi_fatal_error" id="n_api_napi_fatal_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_NO_RETURN <span class="hljs-keyword">void</span> <span class="hljs-title">napi_fatal_error</span><span class="hljs-params">(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* location,
-                                                 <span class="hljs-keyword">size_t</span> location_len,
-                                                 <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* message,
-                                                 <span class="hljs-keyword">size_t</span> message_len)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_NO_RETURN <span class="hljs-type">void</span> <span class="hljs-title function_">napi_fatal_error</span><span class="hljs-params">(<span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* location,
+                                     <span class="hljs-type">size_t</span> location_len,
+                                     <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* message,
+                                     <span class="hljs-type">size_t</span> message_len)</span>;</code></pre>
 <ul>
 <li><code>[in] location</code>: Optional location at which the error occurred.</li>
 <li><code>[in] location_len</code>: The length of the location in bytes, or
@@ -11527,8 +12101,8 @@ if it is null-terminated.</li>
 </ul>
 <p>The function call does not return, the process will be terminated.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h2>Object lifetime management<span><a class="mark" href="#n_api_object_lifetime_management" id="n_api_object_lifetime_management">#</a></span></h2>
-<p>As N-API calls are made, handles to objects in the heap for the underlying
+</section><section><h3>Object lifetime management<span><a class="mark" href="#n_api_object_lifetime_management" id="n_api_object_lifetime_management">#</a></span></h3>
+<p>As Node-API calls are made, handles to objects in the heap for the underlying
 VM may be returned as <code>napi_values</code>. These handles must hold the
 objects 'live' until they are no longer required by the native code,
 otherwise the objects could be collected before the native code was
@@ -11540,13 +12114,13 @@ remain valid and the objects associated with these handles will be
 held live for the lifespan of the native method call.</p>
 <p>In many cases, however, it is necessary that the handles remain valid for
 either a shorter or longer lifespan than that of the native method.
-The sections which follow describe the N-API functions that can be used
+The sections which follow describe the Node-API functions that can be used
 to change the handle lifespan from the default.</p>
-<h3>Making handle lifespan shorter than that of the native method<span><a class="mark" href="#n_api_making_handle_lifespan_shorter_than_that_of_the_native_method" id="n_api_making_handle_lifespan_shorter_than_that_of_the_native_method">#</a></span></h3>
+<h4>Making handle lifespan shorter than that of the native method<span><a class="mark" href="#n_api_making_handle_lifespan_shorter_than_that_of_the_native_method" id="n_api_making_handle_lifespan_shorter_than_that_of_the_native_method">#</a></span></h4>
 <p>It is often necessary to make the lifespan of handles shorter than
 the lifespan of a native method. For example, consider a native method
 that has a loop which iterates through the elements in a large array:</p>
-<pre><code class="language-c"><span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000000</span>; i++) {
+<pre><code class="language-c"><span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000000</span>; i++) {
   napi_value result;
   napi_status status = napi_get_element(env, object, i, &#x26;result);
   <span class="hljs-keyword">if</span> (status != napi_ok) {
@@ -11558,12 +12132,12 @@ that has a loop which iterates through the elements in a large array:</p>
 substantial resources. In addition, even though the native code could only
 use the most recent handle, all of the associated objects would also be
 kept alive since they all share the same scope.</p>
-<p>To handle this case, N-API provides the ability to establish a new 'scope' to
+<p>To handle this case, Node-API provides the ability to establish a new 'scope' to
 which newly created handles will be associated. Once those handles
 are no longer required, the scope can be 'closed' and any handles associated
 with the scope are invalidated. The methods available to open/close scopes are
 <a href="#n_api_napi_open_handle_scope"><code>napi_open_handle_scope</code></a> and <a href="#n_api_napi_close_handle_scope"><code>napi_close_handle_scope</code></a>.</p>
-<p>N-API only supports a single nested hierarchy of scopes. There is only one
+<p>Node-API only supports a single nested hierarchy of scopes. There is only one
 active scope at any time, and all new handles will be associated with that
 scope while it is active. Scopes must be closed in the reverse order from
 which they are opened. In addition, all scopes created within a native method
@@ -11571,7 +12145,7 @@ must be closed before returning from that method.</p>
 <p>Taking the earlier example, adding calls to <a href="#n_api_napi_open_handle_scope"><code>napi_open_handle_scope</code></a> and
 <a href="#n_api_napi_close_handle_scope"><code>napi_close_handle_scope</code></a> would ensure that at most a single handle
 is valid throughout the execution of the loop:</p>
-<pre><code class="language-c"><span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000000</span>; i++) {
+<pre><code class="language-c"><span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000000</span>; i++) {
   napi_handle_scope scope;
   napi_status status = napi_open_handle_scope(env, &#x26;scope);
   <span class="hljs-keyword">if</span> (status != napi_ok) {
@@ -11589,8 +12163,8 @@ is valid throughout the execution of the loop:</p>
   }
 }</code></pre>
 <p>When nesting scopes, there are cases where a handle from an
-inner scope needs to live beyond the lifespan of that scope. N-API supports an
-'escapable scope' in order to support this case. An escapable scope
+inner scope needs to live beyond the lifespan of that scope. Node-API supports
+an 'escapable scope' in order to support this case. An escapable scope
 allows one handle to be 'promoted' so that it 'escapes' the
 current scope and the lifespan of the handle changes from the current
 scope to that of the outer scope.</p>
@@ -11599,26 +12173,26 @@ scope to that of the outer scope.</p>
 <a href="#n_api_napi_close_escapable_handle_scope"><code>napi_close_escapable_handle_scope</code></a>.</p>
 <p>The request to promote a handle is made through <a href="#n_api_napi_escape_handle"><code>napi_escape_handle</code></a> which
 can only be called once.</p>
-<h4>napi_open_handle_scope<span><a class="mark" href="#n_api_napi_open_handle_scope" id="n_api_napi_open_handle_scope">#</a></span></h4>
+<h5>napi_open_handle_scope<span><a class="mark" href="#n_api_napi_open_handle_scope" id="n_api_napi_open_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_open_handle_scope</span><span class="hljs-params">(napi_env env,
-                                               napi_handle_scope* result)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_open_handle_scope</span><span class="hljs-params">(napi_env env,
+                                               napi_handle_scope* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the new scope.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API opens a new scope.</p>
-<h4>napi_close_handle_scope<span><a class="mark" href="#n_api_napi_close_handle_scope" id="n_api_napi_close_handle_scope">#</a></span></h4>
+<h5>napi_close_handle_scope<span><a class="mark" href="#n_api_napi_close_handle_scope" id="n_api_napi_close_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_close_handle_scope</span><span class="hljs-params">(napi_env env,
-                                                napi_handle_scope scope)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_close_handle_scope</span><span class="hljs-params">(napi_env env,
+                                                napi_handle_scope scope)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] scope</code>: <code>napi_value</code> representing the scope to be closed.</li>
@@ -11627,14 +12201,14 @@ can only be called once.</p>
 <p>This API closes the scope passed in. Scopes must be closed in the
 reverse order from which they were created.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_open_escapable_handle_scope<span><a class="mark" href="#n_api_napi_open_escapable_handle_scope" id="n_api_napi_open_escapable_handle_scope">#</a></span></h4>
+<h5>napi_open_escapable_handle_scope<span><a class="mark" href="#n_api_napi_open_escapable_handle_scope" id="n_api_napi_open_escapable_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-    <span class="hljs-title">napi_open_escapable_handle_scope</span><span class="hljs-params">(napi_env env,
-                                     napi_handle_scope* result)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+    <span class="hljs-title function_">napi_open_escapable_handle_scope</span><span class="hljs-params">(napi_env env,
+                                     napi_handle_scope* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the new scope.</li>
@@ -11642,14 +12216,14 @@ reverse order from which they were created.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API opens a new scope from which one object can be promoted
 to the outer scope.</p>
-<h4>napi_close_escapable_handle_scope<span><a class="mark" href="#n_api_napi_close_escapable_handle_scope" id="n_api_napi_close_escapable_handle_scope">#</a></span></h4>
+<h5>napi_close_escapable_handle_scope<span><a class="mark" href="#n_api_napi_close_escapable_handle_scope" id="n_api_napi_close_escapable_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-    <span class="hljs-title">napi_close_escapable_handle_scope</span><span class="hljs-params">(napi_env env,
-                                      napi_handle_scope scope)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+    <span class="hljs-title function_">napi_close_escapable_handle_scope</span><span class="hljs-params">(napi_env env,
+                                      napi_handle_scope scope)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] scope</code>: <code>napi_value</code> representing the scope to be closed.</li>
@@ -11658,15 +12232,15 @@ to the outer scope.</p>
 <p>This API closes the scope passed in. Scopes must be closed in the
 reverse order from which they were created.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_escape_handle<span><a class="mark" href="#n_api_napi_escape_handle" id="n_api_napi_escape_handle">#</a></span></h4>
+<h5>napi_escape_handle<span><a class="mark" href="#n_api_napi_escape_handle" id="n_api_napi_escape_handle">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_escape_handle</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_escape_handle</span><span class="hljs-params">(napi_env env,
                                napi_escapable_handle_scope scope,
                                napi_value escapee,
-                               napi_value* result)</span></span>;</code></pre>
+                               napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] scope</code>: <code>napi_value</code> representing the current scope.</li>
@@ -11680,7 +12254,7 @@ in the outer scope.</li>
 for the lifetime of the outer scope. It can only be called once per scope.
 If it is called more than once an error will be returned.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h3>References to objects with a lifespan longer than that of the native method<span><a class="mark" href="#n_api_references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method" id="n_api_references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method">#</a></span></h3>
+<h4>References to objects with a lifespan longer than that of the native method<span><a class="mark" href="#n_api_references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method" id="n_api_references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method">#</a></span></h4>
 <p>In some cases an addon will need to be able to create and reference objects
 with a lifespan longer than that of a single native method invocation. For
 example, to create a constructor and later use that constructor
@@ -11690,7 +12264,7 @@ would not be possible with a normal handle returned as a <code>napi_value</code>
 described in the earlier section. The lifespan of a normal handle is
 managed by scopes and all scopes must be closed before the end of a native
 method.</p>
-<p>N-API provides methods to create persistent references to an object.
+<p>Node-API provides methods to create persistent references to an object.
 Each persistent reference has an associated count with a value of 0
 or higher. The count determines if the reference will keep
 the corresponding object live. References with a count of 0 do not
@@ -11704,24 +12278,24 @@ for a reference is 0, all subsequent calls to
 get the object associated with the reference <a href="#n_api_napi_get_reference_value"><code>napi_get_reference_value</code></a>
 will return <code>NULL</code> for the returned <code>napi_value</code>. An attempt to call
 <a href="#n_api_napi_reference_ref"><code>napi_reference_ref</code></a> for a reference whose object has been collected
-will result in an error.</p>
+results in an error.</p>
 <p>References must be deleted once they are no longer required by the addon. When
-a reference is deleted it will no longer prevent the corresponding object from
-being collected. Failure to delete a persistent reference will result in
+a reference is deleted, it will no longer prevent the corresponding object from
+being collected. Failure to delete a persistent reference results in
 a 'memory leak' with both the native memory for the persistent reference and
 the corresponding object on the heap being retained forever.</p>
 <p>There can be multiple persistent references created which refer to the same
 object, each of which will either keep the object live or not based on its
 individual count.</p>
-<h4>napi_create_reference<span><a class="mark" href="#n_api_napi_create_reference" id="n_api_napi_create_reference">#</a></span></h4>
+<h5>napi_create_reference<span><a class="mark" href="#n_api_napi_create_reference" id="n_api_napi_create_reference">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_create_reference</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_create_reference</span><span class="hljs-params">(napi_env env,
                                               napi_value value,
-                                              <span class="hljs-keyword">uint32_t</span> initial_refcount,
-                                              napi_ref* result)</span></span>;</code></pre>
+                                              <span class="hljs-type">uint32_t</span> initial_refcount,
+                                              napi_ref* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing the <code>Object</code> to which we want a
@@ -11732,12 +12306,12 @@ reference.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API create a new reference with the specified reference count
 to the <code>Object</code> passed in.</p>
-<h4>napi_delete_reference<span><a class="mark" href="#n_api_napi_delete_reference" id="n_api_napi_delete_reference">#</a></span></h4>
+<h5>napi_delete_reference<span><a class="mark" href="#n_api_napi_delete_reference" id="n_api_napi_delete_reference">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_delete_reference</span><span class="hljs-params">(napi_env env, napi_ref ref)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_delete_reference</span><span class="hljs-params">(napi_env env, napi_ref ref)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] ref</code>: <code>napi_ref</code> to be deleted.</li>
@@ -11745,14 +12319,14 @@ to the <code>Object</code> passed in.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API deletes the reference passed in.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_reference_ref<span><a class="mark" href="#n_api_napi_reference_ref" id="n_api_napi_reference_ref">#</a></span></h4>
+<h5>napi_reference_ref<span><a class="mark" href="#n_api_napi_reference_ref" id="n_api_napi_reference_ref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_reference_ref</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_reference_ref</span><span class="hljs-params">(napi_env env,
                                            napi_ref ref,
-                                           <span class="hljs-keyword">uint32_t</span>* result)</span></span>;</code></pre>
+                                           <span class="hljs-type">uint32_t</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] ref</code>: <code>napi_ref</code> for which the reference count will be incremented.</li>
@@ -11761,14 +12335,14 @@ to the <code>Object</code> passed in.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API increments the reference count for the reference
 passed in and returns the resulting reference count.</p>
-<h4>napi_reference_unref<span><a class="mark" href="#n_api_napi_reference_unref" id="n_api_napi_reference_unref">#</a></span></h4>
+<h5>napi_reference_unref<span><a class="mark" href="#n_api_napi_reference_unref" id="n_api_napi_reference_unref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_reference_unref</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_reference_unref</span><span class="hljs-params">(napi_env env,
                                              napi_ref ref,
-                                             <span class="hljs-keyword">uint32_t</span>* result)</span></span>;</code></pre>
+                                             <span class="hljs-type">uint32_t</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] ref</code>: <code>napi_ref</code> for which the reference count will be decremented.</li>
@@ -11777,14 +12351,14 @@ passed in and returns the resulting reference count.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API decrements the reference count for the reference
 passed in and returns the resulting reference count.</p>
-<h4>napi_get_reference_value<span><a class="mark" href="#n_api_napi_get_reference_value" id="n_api_napi_get_reference_value">#</a></span></h4>
+<h5>napi_get_reference_value<span><a class="mark" href="#n_api_napi_get_reference_value" id="n_api_napi_get_reference_value">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_get_reference_value</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_get_reference_value</span><span class="hljs-params">(napi_env env,
                                                  napi_ref ref,
-                                                 napi_value* result)</span></span>;</code></pre>
+                                                 napi_value* result)</span>;</code></pre>
 <p>the <code>napi_value passed</code> in or out of these methods is a handle to the
 object to which the reference is related.</p>
 <ul>
@@ -11797,21 +12371,21 @@ object to which the reference is related.</p>
 <p>If still valid, this API returns the <code>napi_value</code> representing the
 JavaScript <code>Object</code> associated with the <code>napi_ref</code>. Otherwise, result
 will be <code>NULL</code>.</p>
-<h3>Cleanup on exit of the current Node.js instance<span><a class="mark" href="#n_api_cleanup_on_exit_of_the_current_node_js_instance" id="n_api_cleanup_on_exit_of_the_current_node_js_instance">#</a></span></h3>
+<h4>Cleanup on exit of the current Node.js instance<span><a class="mark" href="#n_api_cleanup_on_exit_of_the_current_node_js_instance" id="n_api_cleanup_on_exit_of_the_current_node_js_instance">#</a></span></h4>
 <p>While a Node.js process typically releases all its resources when exiting,
 embedders of Node.js, or future Worker support, may require addons to register
 clean-up hooks that will be run once the current Node.js instance exits.</p>
-<p>N-API provides functions for registering and un-registering such callbacks.
+<p>Node-API provides functions for registering and un-registering such callbacks.
 When those callbacks are run, all resources that are being held by the addon
 should be freed up.</p>
-<h4>napi_add_env_cleanup_hook<span><a class="mark" href="#n_api_napi_add_env_cleanup_hook" id="n_api_napi_add_env_cleanup_hook">#</a></span></h4>
+<h5>napi_add_env_cleanup_hook<span><a class="mark" href="#n_api_napi_add_env_cleanup_hook" id="n_api_napi_add_env_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.2.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NODE_EXTERN napi_status <span class="hljs-title">napi_add_env_cleanup_hook</span><span class="hljs-params">(napi_env env,
-                                                  <span class="hljs-keyword">void</span> (*fun)(<span class="hljs-keyword">void</span>* arg),
-                                                  <span class="hljs-keyword">void</span>* arg)</span></span>;</code></pre>
+<pre><code class="language-c">NODE_EXTERN napi_status <span class="hljs-title function_">napi_add_env_cleanup_hook</span><span class="hljs-params">(napi_env env,
+                                                  <span class="hljs-type">void</span> (*fun)(<span class="hljs-type">void</span>* arg),
+                                                  <span class="hljs-type">void</span>* arg)</span>;</code></pre>
 <p>Registers <code>fun</code> as a function to be run with the <code>arg</code> parameter once the
 current Node.js environment exits.</p>
 <p>A function can safely be specified multiple times with different
@@ -11824,37 +12398,37 @@ will be called first.</p>
 Typically, that happens when the resource for which this hook was added
 is being torn down anyway.</p>
 <p>For asynchronous cleanup, <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a> is available.</p>
-<h4>napi_remove_env_cleanup_hook<span><a class="mark" href="#n_api_napi_remove_env_cleanup_hook" id="n_api_napi_remove_env_cleanup_hook">#</a></span></h4>
+<h5>napi_remove_env_cleanup_hook<span><a class="mark" href="#n_api_napi_remove_env_cleanup_hook" id="n_api_napi_remove_env_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.2.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_remove_env_cleanup_hook</span><span class="hljs-params">(napi_env env,
-                                                     <span class="hljs-keyword">void</span> (*fun)(<span class="hljs-keyword">void</span>* arg),
-                                                     <span class="hljs-keyword">void</span>* arg)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_remove_env_cleanup_hook</span><span class="hljs-params">(napi_env env,
+                                                     <span class="hljs-type">void</span> (*fun)(<span class="hljs-type">void</span>* arg),
+                                                     <span class="hljs-type">void</span>* arg)</span>;</code></pre>
 <p>Unregisters <code>fun</code> as a function to be run with the <code>arg</code> parameter once the
 current Node.js environment exits. Both the argument and the function value
 need to be exact matches.</p>
 <p>The function must have originally been registered
 with <code>napi_add_env_cleanup_hook</code>, otherwise the process will abort.</p>
-<h4>napi_add_async_cleanup_hook<span><a class="mark" href="#n_api_napi_add_async_cleanup_hook" id="n_api_napi_add_async_cleanup_hook">#</a></span></h4>
+<h5>napi_add_async_cleanup_hook<span><a class="mark" href="#n_api_napi_add_async_cleanup_hook" id="n_api_napi_add_async_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>Changed signature of the <code>hook</code> callback.</p></td></tr>
-<tr><td>v12.19.0</td>
-<td><p><span>Added in: v12.19.0</span></p></td></tr>
+<tr><td>v14.8.0, v12.19.0</td>
+<td><p><span>Added in: v14.8.0, v12.19.0</span></p></td></tr>
 </tbody></table>
 </details>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_add_async_cleanup_hook</span><span class="hljs-params">(
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_add_async_cleanup_hook</span><span class="hljs-params">(
     napi_env env,
     napi_async_cleanup_hook hook,
-    <span class="hljs-keyword">void</span>* arg,
-    napi_async_cleanup_hook_handle* remove_handle)</span></span>;</code></pre>
+    <span class="hljs-type">void</span>* arg,
+    napi_async_cleanup_hook_handle* remove_handle)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] hook</code>: The function pointer to call at environment teardown.</li>
@@ -11872,20 +12446,20 @@ that must later be passed to <a href="#n_api_napi_remove_async_cleanup_hook"><co
 regardless of whether the hook has already been invoked.
 Typically, that happens when the resource for which this hook was added
 is being torn down anyway.</p>
-<h4>napi_remove_async_cleanup_hook<span><a class="mark" href="#n_api_napi_remove_async_cleanup_hook" id="n_api_napi_remove_async_cleanup_hook">#</a></span></h4>
+<h5>napi_remove_async_cleanup_hook<span><a class="mark" href="#n_api_napi_remove_async_cleanup_hook" id="n_api_napi_remove_async_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>Removed <code>env</code> parameter.</p></td></tr>
-<tr><td>v12.19.0</td>
-<td><p><span>Added in: v12.19.0</span></p></td></tr>
+<tr><td>v14.8.0</td>
+<td><p><span>Added in: v14.8.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_remove_async_cleanup_hook</span><span class="hljs-params">(
-    napi_async_cleanup_hook_handle remove_handle)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_remove_async_cleanup_hook</span><span class="hljs-params">(
+    napi_async_cleanup_hook_handle remove_handle)</span>;</code></pre>
 <ul>
 <li><code>[in] remove_handle</code>: The handle to an asynchronous cleanup hook that was
 created with <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a>.</li>
@@ -11894,22 +12468,22 @@ created with <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_c
 the hook from being executed, unless it has already started executing.
 This must be called on any <code>napi_async_cleanup_hook_handle</code> value obtained
 from <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a>.</p>
-<h2>Module registration<span><a class="mark" href="#n_api_module_registration" id="n_api_module_registration">#</a></span></h2>
-<p>N-API modules are registered in a manner similar to other modules
+</section><section><h3>Module registration<span><a class="mark" href="#n_api_module_registration" id="n_api_module_registration">#</a></span></h3>
+<p>Node-API modules are registered in a manner similar to other modules
 except that instead of using the <code>NODE_MODULE</code> macro the following
 is used:</p>
 <pre><code class="language-c">NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)</code></pre>
-<p>The next difference is the signature for the <code>Init</code> method. For a N-API
+<p>The next difference is the signature for the <code>Init</code> method. For a Node-API
 module it is as follows:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span></span>;</code></pre>
+<pre><code class="language-c">napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span>;</code></pre>
 <p>The return value from <code>Init</code> is treated as the <code>exports</code> object for the module.
 The <code>Init</code> method is passed an empty object via the <code>exports</code> parameter as a
 convenience. If <code>Init</code> returns <code>NULL</code>, the parameter passed as <code>exports</code> is
-exported by the module. N-API modules cannot modify the <code>module</code> object but can
-specify anything as the <code>exports</code> property of the module.</p>
+exported by the module. Node-API modules cannot modify the <code>module</code> object but
+can specify anything as the <code>exports</code> property of the module.</p>
 <p>To add the method <code>hello</code> as a function so that it can be called as a method
 provided by the addon:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> </span>{
+<pre><code class="language-c">napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> {
   napi_status status;
   napi_property_descriptor desc = {
     <span class="hljs-string">"hello"</span>,
@@ -11926,7 +12500,7 @@ provided by the addon:</p>
   <span class="hljs-keyword">return</span> exports;
 }</code></pre>
 <p>To set a function to be returned by the <code>require()</code> for the addon:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> </span>{
+<pre><code class="language-c">napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> {
   napi_value method;
   napi_status status;
   status = napi_create_function(env, <span class="hljs-string">"exports"</span>, NAPI_AUTO_LENGTH, Method, <span class="hljs-literal">NULL</span>, &#x26;method);
@@ -11936,7 +12510,7 @@ provided by the addon:</p>
 <p>To define a class so that new instances can be created (often used with
 <a href="#n_api_object_wrap">Object wrap</a>):</p>
 <pre><code class="language-c"><span class="hljs-comment">// <span class="hljs-doctag">NOTE:</span> partial example, not all referenced code is included</span>
-<span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> </span>{
+napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> {
   napi_status status;
   napi_property_descriptor properties[] = {
     { <span class="hljs-string">"value"</span>, <span class="hljs-literal">NULL</span>, <span class="hljs-literal">NULL</span>, GetValue, SetValue, <span class="hljs-literal">NULL</span>, napi_writable | napi_configurable, <span class="hljs-literal">NULL</span> },
@@ -11957,8 +12531,8 @@ provided by the addon:</p>
 
   <span class="hljs-keyword">return</span> exports;
 }</code></pre>
-<p>If the module will be loaded multiple times during the lifetime of the Node.js
-process, use the <code>NAPI_MODULE_INIT</code> macro to initialize the module:</p>
+<p>You can also use the <code>NAPI_MODULE_INIT</code> macro, which acts as a shorthand
+for <code>NAPI_MODULE</code> and defining an <code>Init</code> function:</p>
 <pre><code class="language-c">NAPI_MODULE_INIT() {
   napi_value answer;
   napi_status result;
@@ -11971,41 +12545,38 @@ process, use the <code>NAPI_MODULE_INIT</code> macro to initialize the module:</
 
   <span class="hljs-keyword">return</span> exports;
 }</code></pre>
-<p>This macro includes <code>NAPI_MODULE</code>, and declares an <code>Init</code> function with a
-special name and with visibility beyond the addon. This will allow Node.js to
-initialize the module even if it is loaded multiple times.</p>
-<p>There are a few design considerations when declaring a module that may be loaded
-multiple times. The documentation of <a href="#addons_context_aware_addons">context-aware addons</a> provides more
-details.</p>
+<p>All Node-API addons are context-aware, meaning they may be loaded multiple
+times. There are a few design considerations when declaring such a module.
+The documentation on <a href="#addons_context_aware_addons">context-aware addons</a> provides more details.</p>
 <p>The variables <code>env</code> and <code>exports</code> will be available inside the function body
 following the macro invocation.</p>
 <p>For more details on setting properties on objects, see the section on
 <a href="#n_api_working_with_javascript_properties">Working with JavaScript properties</a>.</p>
 <p>For more details on building addon modules in general, refer to the existing
 API.</p>
-<h2>Working with JavaScript values<span><a class="mark" href="#n_api_working_with_javascript_values" id="n_api_working_with_javascript_values">#</a></span></h2>
-<p>N-API exposes a set of APIs to create all types of JavaScript values.
+</section><section><h3>Working with JavaScript values<span><a class="mark" href="#n_api_working_with_javascript_values" id="n_api_working_with_javascript_values">#</a></span></h3>
+<p>Node-API exposes a set of APIs to create all types of JavaScript values.
 Some of these types are documented under <a href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Section 6</a>
 of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>.</p>
 <p>Fundamentally, these APIs are used to do one of the following:</p>
 <ol>
 <li>Create a new JavaScript object</li>
-<li>Convert from a primitive C type to an N-API value</li>
-<li>Convert from N-API value to a primitive C type</li>
+<li>Convert from a primitive C type to a Node-API value</li>
+<li>Convert from Node-API value to a primitive C type</li>
 <li>Get global instances including <code>undefined</code> and <code>null</code></li>
 </ol>
-<p>N-API values are represented by the type <code>napi_value</code>.
-Any N-API call that requires a JavaScript value takes in a <code>napi_value</code>.
+<p>Node-API values are represented by the type <code>napi_value</code>.
+Any Node-API call that requires a JavaScript value takes in a <code>napi_value</code>.
 In some cases, the API does check the type of the <code>napi_value</code> up-front.
 However, for better performance, it's better for the caller to make sure that
 the <code>napi_value</code> in question is of the JavaScript type expected by the API.</p>
-<h3>Enum types<span><a class="mark" href="#n_api_enum_types" id="n_api_enum_types">#</a></span></h3>
-<h4>napi_key_collection_mode<span><a class="mark" href="#n_api_napi_key_collection_mode" id="n_api_napi_key_collection_mode">#</a></span></h4>
+<h4>Enum types<span><a class="mark" href="#n_api_enum_types" id="n_api_enum_types">#</a></span></h4>
+<h5>napi_key_collection_mode<span><a class="mark" href="#n_api_napi_key_collection_mode" id="n_api_napi_key_collection_mode">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_key_include_prototypes,
   napi_key_own_only
 } napi_key_collection_mode;</code></pre>
@@ -12014,12 +12585,12 @@ the <code>napi_value</code> in question is of the JavaScript type expected by th
 <p><code>napi_key_own_only</code> limits the collected properties to the given
 object only. <code>napi_key_include_prototypes</code> will include all keys
 of the objects's prototype chain as well.</p>
-<h4>napi_key_filter<span><a class="mark" href="#n_api_napi_key_filter" id="n_api_napi_key_filter">#</a></span></h4>
+<h5>napi_key_filter<span><a class="mark" href="#n_api_napi_key_filter" id="n_api_napi_key_filter">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_key_all_properties = <span class="hljs-number">0</span>,
   napi_key_writable = <span class="hljs-number">1</span>,
   napi_key_enumerable = <span class="hljs-number">1</span> &#x3C;&#x3C; <span class="hljs-number">1</span>,
@@ -12028,20 +12599,20 @@ of the objects's prototype chain as well.</p>
   napi_key_skip_symbols = <span class="hljs-number">1</span> &#x3C;&#x3C; <span class="hljs-number">4</span>
 } napi_key_filter;</code></pre>
 <p>Property filter bits. They can be or'ed to build a composite filter.</p>
-<h4>napi_key_conversion<span><a class="mark" href="#n_api_napi_key_conversion" id="n_api_napi_key_conversion">#</a></span></h4>
+<h5>napi_key_conversion<span><a class="mark" href="#n_api_napi_key_conversion" id="n_api_napi_key_conversion">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_key_keep_numbers,
   napi_key_numbers_to_strings
 } napi_key_conversion;</code></pre>
 <p><code>napi_key_numbers_to_strings</code> will convert integer indices to
 strings. <code>napi_key_keep_numbers</code> will return numbers for integer
 indices.</p>
-<h4>napi_valuetype<span><a class="mark" href="#n_api_napi_valuetype" id="n_api_napi_valuetype">#</a></span></h4>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<h5>napi_valuetype<span><a class="mark" href="#n_api_napi_valuetype" id="n_api_napi_valuetype">#</a></span></h5>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   <span class="hljs-comment">// ES6 types (corresponds to typeof)</span>
   napi_undefined,
   napi_null,
@@ -12060,8 +12631,8 @@ In addition to types in that section, <code>napi_valuetype</code> can also repre
 <code>Function</code>s and <code>Object</code>s with external data.</p>
 <p>A JavaScript value of type <code>napi_external</code> appears in JavaScript as a plain
 object such that no properties can be set on it, and no prototype.</p>
-<h4>napi_typedarray_type<span><a class="mark" href="#n_api_napi_typedarray_type" id="n_api_napi_typedarray_type">#</a></span></h4>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<h5>napi_typedarray_type<span><a class="mark" href="#n_api_napi_typedarray_type" id="n_api_napi_typedarray_type">#</a></span></h5>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_int8_array,
   napi_uint8_array,
   napi_uint8_clamped_array,
@@ -12077,36 +12648,36 @@ object such that no properties can be set on it, and no prototype.</p>
 <p>This represents the underlying binary scalar datatype of the <code>TypedArray</code>.
 Elements of this enum correspond to
 <a href="https://tc39.github.io/ecma262/#sec-typedarray-objects">Section 22.2</a> of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>.</p>
-<h3>Object creation functions<span><a class="mark" href="#n_api_object_creation_functions" id="n_api_object_creation_functions">#</a></span></h3>
-<h4>napi_create_array<span><a class="mark" href="#n_api_napi_create_array" id="n_api_napi_create_array">#</a></span></h4>
+<h4>Object creation functions<span><a class="mark" href="#n_api_object_creation_functions" id="n_api_object_creation_functions">#</a></span></h4>
+<h5>napi_create_array<span><a class="mark" href="#n_api_napi_create_array" id="n_api_napi_create_array">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_array</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_array</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns an N-API value corresponding to a JavaScript <code>Array</code> type.
+<p>This API returns a Node-API value corresponding to a JavaScript <code>Array</code> type.
 JavaScript arrays are described in
 <a href="https://tc39.github.io/ecma262/#sec-array-objects">Section 22.1</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_array_with_length<span><a class="mark" href="#n_api_napi_create_array_with_length" id="n_api_napi_create_array_with_length">#</a></span></h4>
+<h5>napi_create_array_with_length<span><a class="mark" href="#n_api_napi_create_array_with_length" id="n_api_napi_create_array_with_length">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_array_with_length</span><span class="hljs-params">(napi_env env,
-                                          <span class="hljs-keyword">size_t</span> length,
-                                          napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_array_with_length</span><span class="hljs-params">(napi_env env,
+                                          <span class="hljs-type">size_t</span> length,
+                                          napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] length</code>: The initial length of the <code>Array</code>.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns an N-API value corresponding to a JavaScript <code>Array</code> type.
+<p>This API returns a Node-API value corresponding to a JavaScript <code>Array</code> type.
 The <code>Array</code>'s length property is set to the passed-in length parameter.
 However, the underlying buffer is not guaranteed to be pre-allocated by the VM
 when the array is created. That behavior is left to the underlying VM
@@ -12115,15 +12686,15 @@ directly read and/or written via C, consider using
 <a href="#n_api_napi_create_external_arraybuffer"><code>napi_create_external_arraybuffer</code></a>.</p>
 <p>JavaScript arrays are described in
 <a href="https://tc39.github.io/ecma262/#sec-array-objects">Section 22.1</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_arraybuffer<span><a class="mark" href="#n_api_napi_create_arraybuffer" id="n_api_napi_create_arraybuffer">#</a></span></h4>
+<h5>napi_create_arraybuffer<span><a class="mark" href="#n_api_napi_create_arraybuffer" id="n_api_napi_create_arraybuffer">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_arraybuffer</span><span class="hljs-params">(napi_env env,
-                                    <span class="hljs-keyword">size_t</span> byte_length,
-                                    <span class="hljs-keyword">void</span>** data,
-                                    napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_arraybuffer</span><span class="hljs-params">(napi_env env,
+                                    <span class="hljs-type">size_t</span> byte_length,
+                                    <span class="hljs-type">void</span>** data,
+                                    napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] length</code>: The length in bytes of the array buffer to create.</li>
@@ -12131,7 +12702,7 @@ directly read and/or written via C, consider using
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns an N-API value corresponding to a JavaScript <code>ArrayBuffer</code>.
+<p>This API returns a Node-API value corresponding to a JavaScript <code>ArrayBuffer</code>.
 <code>ArrayBuffer</code>s are used to represent fixed-length binary data buffers. They are
 normally used as a backing-buffer for <code>TypedArray</code> objects.
 The <code>ArrayBuffer</code> allocated will have an underlying byte buffer whose size is
@@ -12142,15 +12713,15 @@ written to directly from native code. To write to this buffer from JavaScript,
 a typed array or <code>DataView</code> object would need to be created.</p>
 <p>JavaScript <code>ArrayBuffer</code> objects are described in
 <a href="https://tc39.github.io/ecma262/#sec-arraybuffer-objects">Section 24.1</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_buffer<span><a class="mark" href="#n_api_napi_create_buffer" id="n_api_napi_create_buffer">#</a></span></h4>
+<h5>napi_create_buffer<span><a class="mark" href="#n_api_napi_create_buffer" id="n_api_napi_create_buffer">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_buffer</span><span class="hljs-params">(napi_env env,
-                               <span class="hljs-keyword">size_t</span> size,
-                               <span class="hljs-keyword">void</span>** data,
-                               napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_buffer</span><span class="hljs-params">(napi_env env,
+                               <span class="hljs-type">size_t</span> size,
+                               <span class="hljs-type">void</span>** data,
+                               napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] size</code>: Size in bytes of the underlying buffer.</li>
@@ -12160,16 +12731,16 @@ a typed array or <code>DataView</code> object would need to be created.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API allocates a <code>node::Buffer</code> object. While this is still a
 fully-supported data structure, in most cases using a <code>TypedArray</code> will suffice.</p>
-<h4>napi_create_buffer_copy<span><a class="mark" href="#n_api_napi_create_buffer_copy" id="n_api_napi_create_buffer_copy">#</a></span></h4>
+<h5>napi_create_buffer_copy<span><a class="mark" href="#n_api_napi_create_buffer_copy" id="n_api_napi_create_buffer_copy">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_buffer_copy</span><span class="hljs-params">(napi_env env,
-                                    <span class="hljs-keyword">size_t</span> length,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">void</span>* data,
-                                    <span class="hljs-keyword">void</span>** result_data,
-                                    napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_buffer_copy</span><span class="hljs-params">(napi_env env,
+                                    <span class="hljs-type">size_t</span> length,
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">void</span>* data,
+                                    <span class="hljs-type">void</span>** result_data,
+                                    napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] size</code>: Size in bytes of the input buffer (should be the same as the size
@@ -12182,14 +12753,14 @@ of the new buffer).</li>
 <p>This API allocates a <code>node::Buffer</code> object and initializes it with data copied
 from the passed-in buffer. While this is still a fully-supported data
 structure, in most cases using a <code>TypedArray</code> will suffice.</p>
-<h4>napi_create_date<span><a class="mark" href="#n_api_napi_create_date" id="n_api_napi_create_date">#</a></span></h4>
+<h5>napi_create_date<span><a class="mark" href="#n_api_napi_create_date" id="n_api_napi_create_date">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v11.11.0</span>
+<span>Added in: v11.11.0, v10.17.0</span>
 <span>N-API version: 5</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_date</span><span class="hljs-params">(napi_env env,
-                             <span class="hljs-keyword">double</span> time,
-                             napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_date</span><span class="hljs-params">(napi_env env,
+                             <span class="hljs-type">double</span> time,
+                             napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] time</code>: ECMAScript time value in milliseconds since 01 January, 1970 UTC.</li>
@@ -12201,16 +12772,16 @@ ECMAScript aligns with POSIX time specification.</p>
 <p>This API allocates a JavaScript <code>Date</code> object.</p>
 <p>JavaScript <code>Date</code> objects are described in
 <a href="https://tc39.github.io/ecma262/#sec-date-objects">Section 20.3</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_external<span><a class="mark" href="#n_api_napi_create_external" id="n_api_napi_create_external">#</a></span></h4>
+<h5>napi_create_external<span><a class="mark" href="#n_api_napi_create_external" id="n_api_napi_create_external">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_external</span><span class="hljs-params">(napi_env env,
-                                 <span class="hljs-keyword">void</span>* data,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_external</span><span class="hljs-params">(napi_env env,
+                                 <span class="hljs-type">void</span>* data,
                                  napi_finalize finalize_cb,
-                                 <span class="hljs-keyword">void</span>* finalize_hint,
-                                 napi_value* result)</span></span></code></pre>
+                                 <span class="hljs-type">void</span>* finalize_hint,
+                                 napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] data</code>: Raw pointer to the external data.</li>
@@ -12235,18 +12806,18 @@ object just created is ready for garbage collection. It is similar to
 <p>The created value is not an object, and therefore does not support additional
 properties. It is considered a distinct value type: calling <code>napi_typeof()</code> with
 an external value yields <code>napi_external</code>.</p>
-<h4>napi_create_external_arraybuffer<span><a class="mark" href="#n_api_napi_create_external_arraybuffer" id="n_api_napi_create_external_arraybuffer">#</a></span></h4>
+<h5>napi_create_external_arraybuffer<span><a class="mark" href="#n_api_napi_create_external_arraybuffer" id="n_api_napi_create_external_arraybuffer">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status
-<span class="hljs-title">napi_create_external_arraybuffer</span><span class="hljs-params">(napi_env env,
-                                 <span class="hljs-keyword">void</span>* external_data,
-                                 <span class="hljs-keyword">size_t</span> byte_length,
+<pre><code class="language-c">napi_status
+<span class="hljs-title function_">napi_create_external_arraybuffer</span><span class="hljs-params">(napi_env env,
+                                 <span class="hljs-type">void</span>* external_data,
+                                 <span class="hljs-type">size_t</span> byte_length,
                                  napi_finalize finalize_cb,
-                                 <span class="hljs-keyword">void</span>* finalize_hint,
-                                 napi_value* result)</span></span></code></pre>
+                                 <span class="hljs-type">void</span>* finalize_hint,
+                                 napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] external_data</code>: Pointer to the underlying byte buffer of the
@@ -12259,7 +12830,7 @@ collection.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns an N-API value corresponding to a JavaScript <code>ArrayBuffer</code>.
+<p>This API returns a Node-API value corresponding to a JavaScript <code>ArrayBuffer</code>.
 The underlying byte buffer of the <code>ArrayBuffer</code> is externally allocated and
 managed. The caller must ensure that the byte buffer remains valid until the
 finalize callback is called.</p>
@@ -12273,17 +12844,17 @@ object just created is ready for garbage collection. It is similar to
 </ul>
 <p>JavaScript <code>ArrayBuffer</code>s are described in
 <a href="https://tc39.github.io/ecma262/#sec-arraybuffer-objects">Section 24.1</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_external_buffer<span><a class="mark" href="#n_api_napi_create_external_buffer" id="n_api_napi_create_external_buffer">#</a></span></h4>
+<h5>napi_create_external_buffer<span><a class="mark" href="#n_api_napi_create_external_buffer" id="n_api_napi_create_external_buffer">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_external_buffer</span><span class="hljs-params">(napi_env env,
-                                        <span class="hljs-keyword">size_t</span> length,
-                                        <span class="hljs-keyword">void</span>* data,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_external_buffer</span><span class="hljs-params">(napi_env env,
+                                        <span class="hljs-type">size_t</span> length,
+                                        <span class="hljs-type">void</span>* data,
                                         napi_finalize finalize_cb,
-                                        <span class="hljs-keyword">void</span>* finalize_hint,
-                                        napi_value* result)</span></span></code></pre>
+                                        <span class="hljs-type">void</span>* finalize_hint,
+                                        napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] length</code>: Size in bytes of the input buffer (should be the same as the
@@ -12308,12 +12879,12 @@ object just created is ready for garbage collection. It is similar to
 <li>the object created by the API can be used with <code>napi_wrap()</code>.</li>
 </ul>
 <p>For Node.js >=4 <code>Buffers</code> are <code>Uint8Array</code>s.</p>
-<h4>napi_create_object<span><a class="mark" href="#n_api_napi_create_object" id="n_api_napi_create_object">#</a></span></h4>
+<h5>napi_create_object<span><a class="mark" href="#n_api_napi_create_object" id="n_api_napi_create_object">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_object</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_object</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Object</code>.</li>
@@ -12323,35 +12894,35 @@ object just created is ready for garbage collection. It is similar to
 It is the equivalent of doing <code>new Object()</code> in JavaScript.</p>
 <p>The JavaScript <code>Object</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-object-type">Section 6.1.7</a> of the
 ECMAScript Language Specification.</p>
-<h4>napi_create_symbol<span><a class="mark" href="#n_api_napi_create_symbol" id="n_api_napi_create_symbol">#</a></span></h4>
+<h5>napi_create_symbol<span><a class="mark" href="#n_api_napi_create_symbol" id="n_api_napi_create_symbol">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_symbol</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_symbol</span><span class="hljs-params">(napi_env env,
                                napi_value description,
-                               napi_value* result)</span></span></code></pre>
+                               napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] description</code>: Optional <code>napi_value</code> which refers to a JavaScript
-<code>String</code> to be set as the description for the symbol.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Symbol</code>.</li>
+<code>string</code> to be set as the description for the symbol.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>symbol</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API creates a JavaScript <code>Symbol</code> object from a UTF8-encoded C string.</p>
-<p>The JavaScript <code>Symbol</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-symbol-objects">Section 19.4</a>
+<p>This API creates a JavaScript <code>symbol</code> value from a UTF8-encoded C string.</p>
+<p>The JavaScript <code>symbol</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-symbol-objects">Section 19.4</a>
 of the ECMAScript Language Specification.</p>
-<h4>napi_create_typedarray<span><a class="mark" href="#n_api_napi_create_typedarray" id="n_api_napi_create_typedarray">#</a></span></h4>
+<h5>napi_create_typedarray<span><a class="mark" href="#n_api_napi_create_typedarray" id="n_api_napi_create_typedarray">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_typedarray</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_typedarray</span><span class="hljs-params">(napi_env env,
                                    napi_typedarray_type type,
-                                   <span class="hljs-keyword">size_t</span> length,
+                                   <span class="hljs-type">size_t</span> length,
                                    napi_value arraybuffer,
-                                   <span class="hljs-keyword">size_t</span> byte_offset,
-                                   napi_value* result)</span></span></code></pre>
+                                   <span class="hljs-type">size_t</span> byte_offset,
+                                   napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] type</code>: Scalar datatype of the elements within the <code>TypedArray</code>.</li>
@@ -12371,16 +12942,16 @@ be &#x3C;= the size in bytes of the array passed in. If not, a <code>RangeError<
 is raised.</p>
 <p>JavaScript <code>TypedArray</code> objects are described in
 <a href="https://tc39.github.io/ecma262/#sec-typedarray-objects">Section 22.2</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_dataview<span><a class="mark" href="#n_api_napi_create_dataview" id="n_api_napi_create_dataview">#</a></span></h4>
+<h5>napi_create_dataview<span><a class="mark" href="#n_api_napi_create_dataview" id="n_api_napi_create_dataview">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_dataview</span><span class="hljs-params">(napi_env env,
-                                 <span class="hljs-keyword">size_t</span> byte_length,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_dataview</span><span class="hljs-params">(napi_env env,
+                                 <span class="hljs-type">size_t</span> byte_length,
                                  napi_value arraybuffer,
-                                 <span class="hljs-keyword">size_t</span> byte_offset,
-                                 napi_value* result)</span></span></code></pre>
+                                 <span class="hljs-type">size_t</span> byte_offset,
+                                 napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] length</code>: Number of elements in the <code>DataView</code>.</li>
@@ -12398,82 +12969,82 @@ size in bytes of the array passed in. If not, a <code>RangeError</code> exceptio
 raised.</p>
 <p>JavaScript <code>DataView</code> objects are described in
 <a href="https://tc39.github.io/ecma262/#sec-dataview-objects">Section 24.3</a> of the ECMAScript Language Specification.</p>
-<h3>Functions to convert from C types to N-API<span><a class="mark" href="#n_api_functions_to_convert_from_c_types_to_n_api" id="n_api_functions_to_convert_from_c_types_to_n_api">#</a></span></h3>
-<h4>napi_create_int32<span><a class="mark" href="#n_api_napi_create_int32" id="n_api_napi_create_int32">#</a></span></h4>
+<h4>Functions to convert from C types to Node-API<span><a class="mark" href="#n_api_functions_to_convert_from_c_types_to_node_api" id="n_api_functions_to_convert_from_c_types_to_node_api">#</a></span></h4>
+<h5>napi_create_int32<span><a class="mark" href="#n_api_napi_create_int32" id="n_api_napi_create_int32">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_int32</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">int32_t</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_int32</span><span class="hljs-params">(napi_env env, <span class="hljs-type">int32_t</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to convert from the C <code>int32_t</code> type to the JavaScript
-<code>Number</code> type.</p>
-<p>The JavaScript <code>Number</code> type is described in
+<code>number</code> type.</p>
+<p>The JavaScript <code>number</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_uint32<span><a class="mark" href="#n_api_napi_create_uint32" id="n_api_napi_create_uint32">#</a></span></h4>
+<h5>napi_create_uint32<span><a class="mark" href="#n_api_napi_create_uint32" id="n_api_napi_create_uint32">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_uint32</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">uint32_t</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_uint32</span><span class="hljs-params">(napi_env env, <span class="hljs-type">uint32_t</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Unsigned integer value to be represented in JavaScript.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to convert from the C <code>uint32_t</code> type to the JavaScript
-<code>Number</code> type.</p>
-<p>The JavaScript <code>Number</code> type is described in
+<code>number</code> type.</p>
+<p>The JavaScript <code>number</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_int64<span><a class="mark" href="#n_api_napi_create_int64" id="n_api_napi_create_int64">#</a></span></h4>
+<h5>napi_create_int64<span><a class="mark" href="#n_api_napi_create_int64" id="n_api_napi_create_int64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_int64</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">int64_t</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_int64</span><span class="hljs-params">(napi_env env, <span class="hljs-type">int64_t</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to convert from the C <code>int64_t</code> type to the JavaScript
-<code>Number</code> type.</p>
-<p>The JavaScript <code>Number</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a>
+<code>number</code> type.</p>
+<p>The JavaScript <code>number</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a>
 of the ECMAScript Language Specification. Note the complete range of <code>int64_t</code>
 cannot be represented with full precision in JavaScript. Integer values
 outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_safe_integer"><code>Number.MIN_SAFE_INTEGER</code></a> <code>-(2**53 - 1)</code> -
 <a href="https://tc39.github.io/ecma262/#sec-number.max_safe_integer"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose precision.</p>
-<h4>napi_create_double<span><a class="mark" href="#n_api_napi_create_double" id="n_api_napi_create_double">#</a></span></h4>
+<h5>napi_create_double<span><a class="mark" href="#n_api_napi_create_double" id="n_api_napi_create_double">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_double</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">double</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_double</span><span class="hljs-params">(napi_env env, <span class="hljs-type">double</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Double-precision value to be represented in JavaScript.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to convert from the C <code>double</code> type to the JavaScript
-<code>Number</code> type.</p>
-<p>The JavaScript <code>Number</code> type is described in
+<code>number</code> type.</p>
+<p>The JavaScript <code>number</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_bigint_int64<span><a class="mark" href="#n_api_napi_create_bigint_int64" id="n_api_napi_create_bigint_int64">#</a></span></h4>
+<h5>napi_create_bigint_int64<span><a class="mark" href="#n_api_napi_create_bigint_int64" id="n_api_napi_create_bigint_int64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_bigint_int64</span><span class="hljs-params">(napi_env env,
-                                     <span class="hljs-keyword">int64_t</span> value,
-                                     napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_bigint_int64</span><span class="hljs-params">(napi_env env,
+                                     <span class="hljs-type">int64_t</span> value,
+                                     napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>
@@ -12481,14 +13052,14 @@ outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_saf
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API converts the C <code>int64_t</code> type to the JavaScript <code>BigInt</code> type.</p>
-<h4>napi_create_bigint_uint64<span><a class="mark" href="#n_api_napi_create_bigint_uint64" id="n_api_napi_create_bigint_uint64">#</a></span></h4>
+<h5>napi_create_bigint_uint64<span><a class="mark" href="#n_api_napi_create_bigint_uint64" id="n_api_napi_create_bigint_uint64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_bigint_uint64</span><span class="hljs-params">(napi_env env,
-                                      <span class="hljs-keyword">uint64_t</span> value,
-                                      napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_bigint_uint64</span><span class="hljs-params">(napi_env env,
+                                      <span class="hljs-type">uint64_t</span> value,
+                                      napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Unsigned integer value to be represented in JavaScript.</li>
@@ -12496,16 +13067,16 @@ outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_saf
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API converts the C <code>uint64_t</code> type to the JavaScript <code>BigInt</code> type.</p>
-<h4>napi_create_bigint_words<span><a class="mark" href="#n_api_napi_create_bigint_words" id="n_api_napi_create_bigint_words">#</a></span></h4>
+<h5>napi_create_bigint_words<span><a class="mark" href="#n_api_napi_create_bigint_words" id="n_api_napi_create_bigint_words">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_bigint_words</span><span class="hljs-params">(napi_env env,
-                                     <span class="hljs-keyword">int</span> sign_bit,
-                                     <span class="hljs-keyword">size_t</span> word_count,
-                                     <span class="hljs-keyword">const</span> <span class="hljs-keyword">uint64_t</span>* words,
-                                     napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_bigint_words</span><span class="hljs-params">(napi_env env,
+                                     <span class="hljs-type">int</span> sign_bit,
+                                     <span class="hljs-type">size_t</span> word_count,
+                                     <span class="hljs-keyword">const</span> <span class="hljs-type">uint64_t</span>* words,
+                                     napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] sign_bit</code>: Determines if the resulting <code>BigInt</code> will be positive or
@@ -12519,78 +13090,78 @@ negative.</li>
 value.</p>
 <p>The resulting <code>BigInt</code> is calculated as: (–1)<sup><code>sign_bit</code></sup> (<code>words[0]</code>
 × (2<sup>64</sup>)<sup>0</sup> + <code>words[1]</code> × (2<sup>64</sup>)<sup>1</sup> + …)</p>
-<h4>napi_create_string_latin1<span><a class="mark" href="#n_api_napi_create_string_latin1" id="n_api_napi_create_string_latin1">#</a></span></h4>
+<h5>napi_create_string_latin1<span><a class="mark" href="#n_api_napi_create_string_latin1" id="n_api_napi_create_string_latin1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_string_latin1</span><span class="hljs-params">(napi_env env,
-                                      <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* str,
-                                      <span class="hljs-keyword">size_t</span> length,
-                                      napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_string_latin1</span><span class="hljs-params">(napi_env env,
+                                      <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* str,
+                                      <span class="hljs-type">size_t</span> length,
+                                      napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] str</code>: Character buffer representing an ISO-8859-1-encoded string.</li>
 <li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it
 is null-terminated.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API creates a JavaScript <code>String</code> object from an ISO-8859-1-encoded C
+<p>This API creates a JavaScript <code>string</code> value from an ISO-8859-1-encoded C
 string. The native string is copied.</p>
-<p>The JavaScript <code>String</code> type is described in
+<p>The JavaScript <code>string</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type">Section 6.1.4</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_string_utf16<span><a class="mark" href="#n_api_napi_create_string_utf16" id="n_api_napi_create_string_utf16">#</a></span></h4>
+<h5>napi_create_string_utf16<span><a class="mark" href="#n_api_napi_create_string_utf16" id="n_api_napi_create_string_utf16">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_string_utf16</span><span class="hljs-params">(napi_env env,
-                                     <span class="hljs-keyword">const</span> <span class="hljs-keyword">char16_t</span>* str,
-                                     <span class="hljs-keyword">size_t</span> length,
-                                     napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_string_utf16</span><span class="hljs-params">(napi_env env,
+                                     <span class="hljs-keyword">const</span> <span class="hljs-type">char16_t</span>* str,
+                                     <span class="hljs-type">size_t</span> length,
+                                     napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] str</code>: Character buffer representing a UTF16-LE-encoded string.</li>
 <li><code>[in] length</code>: The length of the string in two-byte code units, or
 <code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API creates a JavaScript <code>String</code> object from a UTF16-LE-encoded C string.
+<p>This API creates a JavaScript <code>string</code> value from a UTF16-LE-encoded C string.
 The native string is copied.</p>
-<p>The JavaScript <code>String</code> type is described in
+<p>The JavaScript <code>string</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type">Section 6.1.4</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_string_utf8<span><a class="mark" href="#n_api_napi_create_string_utf8" id="n_api_napi_create_string_utf8">#</a></span></h4>
+<h5>napi_create_string_utf8<span><a class="mark" href="#n_api_napi_create_string_utf8" id="n_api_napi_create_string_utf8">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_string_utf8</span><span class="hljs-params">(napi_env env,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* str,
-                                    <span class="hljs-keyword">size_t</span> length,
-                                    napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_string_utf8</span><span class="hljs-params">(napi_env env,
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* str,
+                                    <span class="hljs-type">size_t</span> length,
+                                    napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] str</code>: Character buffer representing a UTF8-encoded string.</li>
 <li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it
 is null-terminated.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API creates a JavaScript <code>String</code> object from a UTF8-encoded C string.
+<p>This API creates a JavaScript <code>string</code> value from a UTF8-encoded C string.
 The native string is copied.</p>
-<p>The JavaScript <code>String</code> type is described in
+<p>The JavaScript <code>string</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type">Section 6.1.4</a> of the ECMAScript Language Specification.</p>
-<h3>Functions to convert from N-API to C types<span><a class="mark" href="#n_api_functions_to_convert_from_n_api_to_c_types" id="n_api_functions_to_convert_from_n_api_to_c_types">#</a></span></h3>
-<h4>napi_get_array_length<span><a class="mark" href="#n_api_napi_get_array_length" id="n_api_napi_get_array_length">#</a></span></h4>
+<h4>Functions to convert from Node-API to C types<span><a class="mark" href="#n_api_functions_to_convert_from_node_api_to_c_types" id="n_api_functions_to_convert_from_node_api_to_c_types">#</a></span></h4>
+<h5>napi_get_array_length<span><a class="mark" href="#n_api_napi_get_array_length" id="n_api_napi_get_array_length">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_array_length</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_array_length</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  <span class="hljs-keyword">uint32_t</span>* result)</span></span></code></pre>
+                                  <span class="hljs-type">uint32_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing the JavaScript <code>Array</code> whose length is
@@ -12601,15 +13172,15 @@ being queried.</li>
 <p>This API returns the length of an array.</p>
 <p><code>Array</code> length is described in <a href="https://tc39.github.io/ecma262/#sec-properties-of-array-instances-length">Section 22.1.4.1</a> of the ECMAScript Language
 Specification.</p>
-<h4>napi_get_arraybuffer_info<span><a class="mark" href="#n_api_napi_get_arraybuffer_info" id="n_api_napi_get_arraybuffer_info">#</a></span></h4>
+<h5>napi_get_arraybuffer_info<span><a class="mark" href="#n_api_napi_get_arraybuffer_info" id="n_api_napi_get_arraybuffer_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_arraybuffer_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_arraybuffer_info</span><span class="hljs-params">(napi_env env,
                                       napi_value arraybuffer,
-                                      <span class="hljs-keyword">void</span>** data,
-                                      <span class="hljs-keyword">size_t</span>* byte_length)</span></span></code></pre>
+                                      <span class="hljs-type">void</span>** data,
+                                      <span class="hljs-type">size_t</span>* byte_length)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] arraybuffer</code>: <code>napi_value</code> representing the <code>ArrayBuffer</code> being queried.</li>
@@ -12627,15 +13198,15 @@ possible safe way to use this API is in conjunction with
 lifetime of the <code>ArrayBuffer</code>. It's also safe to use the returned data buffer
 within the same callback as long as there are no calls to other APIs that might
 trigger a GC.</p>
-<h4>napi_get_buffer_info<span><a class="mark" href="#n_api_napi_get_buffer_info" id="n_api_napi_get_buffer_info">#</a></span></h4>
+<h5>napi_get_buffer_info<span><a class="mark" href="#n_api_napi_get_buffer_info" id="n_api_napi_get_buffer_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_buffer_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_buffer_info</span><span class="hljs-params">(napi_env env,
                                  napi_value value,
-                                 <span class="hljs-keyword">void</span>** data,
-                                 <span class="hljs-keyword">size_t</span>* length)</span></span></code></pre>
+                                 <span class="hljs-type">void</span>** data,
+                                 <span class="hljs-type">size_t</span>* length)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing the <code>node::Buffer</code> being queried.</li>
@@ -12648,14 +13219,14 @@ If length is <code>0</code>, this may be <code>NULL</code> or any other pointer
 and it's length.</p>
 <p><em>Warning</em>: Use caution while using this API since the underlying data buffer's
 lifetime is not guaranteed if it's managed by the VM.</p>
-<h4>napi_get_prototype<span><a class="mark" href="#n_api_napi_get_prototype" id="n_api_napi_get_prototype">#</a></span></h4>
+<h5>napi_get_prototype<span><a class="mark" href="#n_api_napi_get_prototype" id="n_api_napi_get_prototype">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_prototype</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_prototype</span><span class="hljs-params">(napi_env env,
                                napi_value object,
-                               napi_value* result)</span></span></code></pre>
+                               napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] object</code>: <code>napi_value</code> representing JavaScript <code>Object</code> whose prototype
@@ -12664,18 +13235,18 @@ not the same as the function's <code>prototype</code> property).</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing prototype of the given object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<h4>napi_get_typedarray_info<span><a class="mark" href="#n_api_napi_get_typedarray_info" id="n_api_napi_get_typedarray_info">#</a></span></h4>
+<h5>napi_get_typedarray_info<span><a class="mark" href="#n_api_napi_get_typedarray_info" id="n_api_napi_get_typedarray_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_typedarray_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_typedarray_info</span><span class="hljs-params">(napi_env env,
                                      napi_value typedarray,
                                      napi_typedarray_type* type,
-                                     <span class="hljs-keyword">size_t</span>* length,
-                                     <span class="hljs-keyword">void</span>** data,
+                                     <span class="hljs-type">size_t</span>* length,
+                                     <span class="hljs-type">void</span>** data,
                                      napi_value* arraybuffer,
-                                     <span class="hljs-keyword">size_t</span>* byte_offset)</span></span></code></pre>
+                                     <span class="hljs-type">size_t</span>* byte_offset)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] typedarray</code>: <code>napi_value</code> representing the <code>TypedArray</code> whose
@@ -12697,22 +13268,22 @@ in the array. Therefore, the first byte of the native array would be at
 <p>This API returns various properties of a typed array.</p>
 <p><em>Warning</em>: Use caution while using this API since the underlying data buffer
 is managed by the VM.</p>
-<h4>napi_get_dataview_info<span><a class="mark" href="#n_api_napi_get_dataview_info" id="n_api_napi_get_dataview_info">#</a></span></h4>
+<h5>napi_get_dataview_info<span><a class="mark" href="#n_api_napi_get_dataview_info" id="n_api_napi_get_dataview_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_dataview_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_dataview_info</span><span class="hljs-params">(napi_env env,
                                    napi_value dataview,
-                                   <span class="hljs-keyword">size_t</span>* byte_length,
-                                   <span class="hljs-keyword">void</span>** data,
+                                   <span class="hljs-type">size_t</span>* byte_length,
+                                   <span class="hljs-type">void</span>** data,
                                    napi_value* arraybuffer,
-                                   <span class="hljs-keyword">size_t</span>* byte_offset)</span></span></code></pre>
+                                   <span class="hljs-type">size_t</span>* byte_offset)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] dataview</code>: <code>napi_value</code> representing the <code>DataView</code> whose
 properties to query.</li>
-<li><code>[out] byte_length</code>: <code>Number</code> of bytes in the <code>DataView</code>.</li>
+<li><code>[out] byte_length</code>: Number of bytes in the <code>DataView</code>.</li>
 <li><code>[out] data</code>: The data buffer underlying the <code>DataView</code>.
 If byte_length is <code>0</code>, this may be <code>NULL</code> or any other pointer value.</li>
 <li><code>[out] arraybuffer</code>: <code>ArrayBuffer</code> underlying the <code>DataView</code>.</li>
@@ -12721,14 +13292,14 @@ to start projecting the <code>DataView</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns various properties of a <code>DataView</code>.</p>
-<h4>napi_get_date_value<span><a class="mark" href="#n_api_napi_get_date_value" id="n_api_napi_get_date_value">#</a></span></h4>
+<h5>napi_get_date_value<span><a class="mark" href="#n_api_napi_get_date_value" id="n_api_napi_get_date_value">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v11.11.0</span>
+<span>Added in: v11.11.0, v10.17.0</span>
 <span>N-API version: 5</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_date_value</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_date_value</span><span class="hljs-params">(napi_env env,
                                 napi_value value,
-                                <span class="hljs-keyword">double</span>* result)</span></span></code></pre>
+                                <span class="hljs-type">double</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing a JavaScript <code>Date</code>.</li>
@@ -12741,12 +13312,12 @@ ECMAScript aligns with POSIX time specification.</p>
 in it returns <code>napi_date_expected</code>.</p>
 <p>This API returns the C double primitive of time value for the given JavaScript
 <code>Date</code>.</p>
-<h4>napi_get_value_bool<span><a class="mark" href="#n_api_napi_get_value_bool" id="n_api_napi_get_value_bool">#</a></span></h4>
+<h5>napi_get_value_bool<span><a class="mark" href="#n_api_napi_get_value_bool" id="n_api_napi_get_value_bool">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_bool</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_bool</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Boolean</code>.</li>
@@ -12757,33 +13328,33 @@ in it returns <code>napi_date_expected</code>.</p>
 passed in it returns <code>napi_boolean_expected</code>.</p>
 <p>This API returns the C boolean primitive equivalent of the given JavaScript
 <code>Boolean</code>.</p>
-<h4>napi_get_value_double<span><a class="mark" href="#n_api_napi_get_value_double" id="n_api_napi_get_value_double">#</a></span></h4>
+<h5>napi_get_value_double<span><a class="mark" href="#n_api_napi_get_value_double" id="n_api_napi_get_value_double">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_double</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_double</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  <span class="hljs-keyword">double</span>* result)</span></span></code></pre>
+                                  <span class="hljs-type">double</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>
+<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>
 <li><code>[out] result</code>: C double primitive equivalent of the given JavaScript
-<code>Number</code>.</li>
+<code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code> is passed
 in it returns <code>napi_number_expected</code>.</p>
 <p>This API returns the C double primitive equivalent of the given JavaScript
-<code>Number</code>.</p>
-<h4>napi_get_value_bigint_int64<span><a class="mark" href="#n_api_napi_get_value_bigint_int64" id="n_api_napi_get_value_bigint_int64">#</a></span></h4>
+<code>number</code>.</p>
+<h5>napi_get_value_bigint_int64<span><a class="mark" href="#n_api_napi_get_value_bigint_int64" id="n_api_napi_get_value_bigint_int64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_bigint_int64</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_bigint_int64</span><span class="hljs-params">(napi_env env,
                                         napi_value value,
-                                        <span class="hljs-keyword">int64_t</span>* result,
-                                        <span class="hljs-keyword">bool</span>* lossless)</span></span>;</code></pre>
+                                        <span class="hljs-type">int64_t</span>* result,
+                                        <span class="hljs-type">bool</span>* lossless)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>BigInt</code>.</li>
@@ -12796,15 +13367,15 @@ losslessly.</li>
 returns <code>napi_bigint_expected</code>.</p>
 <p>This API returns the C <code>int64_t</code> primitive equivalent of the given JavaScript
 <code>BigInt</code>. If needed it will truncate the value, setting <code>lossless</code> to <code>false</code>.</p>
-<h4>napi_get_value_bigint_uint64<span><a class="mark" href="#n_api_napi_get_value_bigint_uint64" id="n_api_napi_get_value_bigint_uint64">#</a></span></h4>
+<h5>napi_get_value_bigint_uint64<span><a class="mark" href="#n_api_napi_get_value_bigint_uint64" id="n_api_napi_get_value_bigint_uint64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_bigint_uint64</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_bigint_uint64</span><span class="hljs-params">(napi_env env,
                                         napi_value value,
-                                        <span class="hljs-keyword">uint64_t</span>* result,
-                                        <span class="hljs-keyword">bool</span>* lossless)</span></span>;</code></pre>
+                                        <span class="hljs-type">uint64_t</span>* result,
+                                        <span class="hljs-type">bool</span>* lossless)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>BigInt</code>.</li>
@@ -12817,16 +13388,16 @@ losslessly.</li>
 returns <code>napi_bigint_expected</code>.</p>
 <p>This API returns the C <code>uint64_t</code> primitive equivalent of the given JavaScript
 <code>BigInt</code>. If needed it will truncate the value, setting <code>lossless</code> to <code>false</code>.</p>
-<h4>napi_get_value_bigint_words<span><a class="mark" href="#n_api_napi_get_value_bigint_words" id="n_api_napi_get_value_bigint_words">#</a></span></h4>
+<h5>napi_get_value_bigint_words<span><a class="mark" href="#n_api_napi_get_value_bigint_words" id="n_api_napi_get_value_bigint_words">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_bigint_words</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_bigint_words</span><span class="hljs-params">(napi_env env,
                                         napi_value value,
-                                        <span class="hljs-keyword">int</span>* sign_bit,
-                                        <span class="hljs-keyword">size_t</span>* word_count,
-                                        <span class="hljs-keyword">uint64_t</span>* words)</span></span>;</code></pre>
+                                        <span class="hljs-type">int</span>* sign_bit,
+                                        <span class="hljs-type">size_t</span>* word_count,
+                                        <span class="hljs-type">uint64_t</span>* words)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>BigInt</code>.</li>
@@ -12841,14 +13412,14 @@ would be needed to store this <code>BigInt</code>.</li>
 <p>This API converts a single <code>BigInt</code> value into a sign bit, 64-bit little-endian
 array, and the number of elements in the array. <code>sign_bit</code> and <code>words</code> may be
 both set to <code>NULL</code>, in order to get only <code>word_count</code>.</p>
-<h4>napi_get_value_external<span><a class="mark" href="#n_api_napi_get_value_external" id="n_api_napi_get_value_external">#</a></span></h4>
+<h5>napi_get_value_external<span><a class="mark" href="#n_api_napi_get_value_external" id="n_api_napi_get_value_external">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_external</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_external</span><span class="hljs-params">(napi_env env,
                                     napi_value value,
-                                    <span class="hljs-keyword">void</span>** result)</span></span></code></pre>
+                                    <span class="hljs-type">void</span>** result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript external value.</li>
@@ -12858,133 +13429,136 @@ both set to <code>NULL</code>, in order to get only <code>word_count</code>.</p>
 passed in it returns <code>napi_invalid_arg</code>.</p>
 <p>This API retrieves the external data pointer that was previously passed to
 <code>napi_create_external()</code>.</p>
-<h4>napi_get_value_int32<span><a class="mark" href="#n_api_napi_get_value_int32" id="n_api_napi_get_value_int32">#</a></span></h4>
+<h5>napi_get_value_int32<span><a class="mark" href="#n_api_napi_get_value_int32" id="n_api_napi_get_value_int32">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_int32</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_int32</span><span class="hljs-params">(napi_env env,
                                  napi_value value,
-                                 <span class="hljs-keyword">int32_t</span>* result)</span></span></code></pre>
+                                 <span class="hljs-type">int32_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>
+<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>
 <li><code>[out] result</code>: C <code>int32</code> primitive equivalent of the given JavaScript
-<code>Number</code>.</li>
+<code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>
 is passed in <code>napi_number_expected</code>.</p>
 <p>This API returns the C <code>int32</code> primitive equivalent
-of the given JavaScript <code>Number</code>.</p>
+of the given JavaScript <code>number</code>.</p>
 <p>If the number exceeds the range of the 32 bit integer, then the result is
 truncated to the equivalent of the bottom 32 bits. This can result in a large
 positive number becoming a negative number if the value is > 2<sup>31</sup> - 1.</p>
 <p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the
 result to zero.</p>
-<h4>napi_get_value_int64<span><a class="mark" href="#n_api_napi_get_value_int64" id="n_api_napi_get_value_int64">#</a></span></h4>
+<h5>napi_get_value_int64<span><a class="mark" href="#n_api_napi_get_value_int64" id="n_api_napi_get_value_int64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_int64</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_int64</span><span class="hljs-params">(napi_env env,
                                  napi_value value,
-                                 <span class="hljs-keyword">int64_t</span>* result)</span></span></code></pre>
+                                 <span class="hljs-type">int64_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>
+<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>
 <li><code>[out] result</code>: C <code>int64</code> primitive equivalent of the given JavaScript
-<code>Number</code>.</li>
+<code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>
 is passed in it returns <code>napi_number_expected</code>.</p>
 <p>This API returns the C <code>int64</code> primitive equivalent of the given JavaScript
-<code>Number</code>.</p>
-<p><code>Number</code> values outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_safe_integer"><code>Number.MIN_SAFE_INTEGER</code></a>
+<code>number</code>.</p>
+<p><code>number</code> values outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_safe_integer"><code>Number.MIN_SAFE_INTEGER</code></a>
 <code>-(2**53 - 1)</code> - <a href="https://tc39.github.io/ecma262/#sec-number.max_safe_integer"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose
 precision.</p>
 <p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the
 result to zero.</p>
-<h4>napi_get_value_string_latin1<span><a class="mark" href="#n_api_napi_get_value_string_latin1" id="n_api_napi_get_value_string_latin1">#</a></span></h4>
+<h5>napi_get_value_string_latin1<span><a class="mark" href="#n_api_napi_get_value_string_latin1" id="n_api_napi_get_value_string_latin1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_string_latin1</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_string_latin1</span><span class="hljs-params">(napi_env env,
                                          napi_value value,
-                                         <span class="hljs-keyword">char</span>* buf,
-                                         <span class="hljs-keyword">size_t</span> bufsize,
-                                         <span class="hljs-keyword">size_t</span>* result)</span></span></code></pre>
+                                         <span class="hljs-type">char</span>* buf,
+                                         <span class="hljs-type">size_t</span> bufsize,
+                                         <span class="hljs-type">size_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>
 <li><code>[in] buf</code>: Buffer to write the ISO-8859-1-encoded string into. If <code>NULL</code> is
-passed in, the length of the string (in bytes) is returned.</li>
+passed in, the length of the string in bytes and excluding the null terminator
+is returned in <code>result</code>.</li>
 <li><code>[in] bufsize</code>: Size of the destination buffer. When this value is
-insufficient, the returned string will be truncated.</li>
+insufficient, the returned string is truncated and null-terminated.</li>
 <li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null
 terminator.</li>
 </ul>
-<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>
+<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>
 is passed in it returns <code>napi_string_expected</code>.</p>
 <p>This API returns the ISO-8859-1-encoded string corresponding the value passed
 in.</p>
-<h4>napi_get_value_string_utf8<span><a class="mark" href="#n_api_napi_get_value_string_utf8" id="n_api_napi_get_value_string_utf8">#</a></span></h4>
+<h5>napi_get_value_string_utf8<span><a class="mark" href="#n_api_napi_get_value_string_utf8" id="n_api_napi_get_value_string_utf8">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_string_utf8</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_string_utf8</span><span class="hljs-params">(napi_env env,
                                        napi_value value,
-                                       <span class="hljs-keyword">char</span>* buf,
-                                       <span class="hljs-keyword">size_t</span> bufsize,
-                                       <span class="hljs-keyword">size_t</span>* result)</span></span></code></pre>
+                                       <span class="hljs-type">char</span>* buf,
+                                       <span class="hljs-type">size_t</span> bufsize,
+                                       <span class="hljs-type">size_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>
 <li><code>[in] buf</code>: Buffer to write the UTF8-encoded string into. If <code>NULL</code> is passed
-in, the length of the string (in bytes) is returned.</li>
+in, the length of the string in bytes and excluding the null terminator is
+returned in <code>result</code>.</li>
 <li><code>[in] bufsize</code>: Size of the destination buffer. When this value is
-insufficient, the returned string will be truncated.</li>
+insufficient, the returned string is truncated and null-terminated.</li>
 <li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null
 terminator.</li>
 </ul>
-<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>
+<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>
 is passed in it returns <code>napi_string_expected</code>.</p>
 <p>This API returns the UTF8-encoded string corresponding the value passed in.</p>
-<h4>napi_get_value_string_utf16<span><a class="mark" href="#n_api_napi_get_value_string_utf16" id="n_api_napi_get_value_string_utf16">#</a></span></h4>
+<h5>napi_get_value_string_utf16<span><a class="mark" href="#n_api_napi_get_value_string_utf16" id="n_api_napi_get_value_string_utf16">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_string_utf16</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_string_utf16</span><span class="hljs-params">(napi_env env,
                                         napi_value value,
-                                        <span class="hljs-keyword">char16_t</span>* buf,
-                                        <span class="hljs-keyword">size_t</span> bufsize,
-                                        <span class="hljs-keyword">size_t</span>* result)</span></span></code></pre>
+                                        <span class="hljs-type">char16_t</span>* buf,
+                                        <span class="hljs-type">size_t</span> bufsize,
+                                        <span class="hljs-type">size_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>
 <li><code>[in] buf</code>: Buffer to write the UTF16-LE-encoded string into. If <code>NULL</code> is
-passed in, the length of the string (in 2-byte code units) is returned.</li>
+passed in, the length of the string in 2-byte code units and excluding the
+null terminator is returned.</li>
 <li><code>[in] bufsize</code>: Size of the destination buffer. When this value is
-insufficient, the returned string will be truncated.</li>
+insufficient, the returned string is truncated and null-terminated.</li>
 <li><code>[out] result</code>: Number of 2-byte code units copied into the buffer, excluding
 the null terminator.</li>
 </ul>
-<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>
+<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>
 is passed in it returns <code>napi_string_expected</code>.</p>
 <p>This API returns the UTF16-encoded string corresponding the value passed in.</p>
-<h4>napi_get_value_uint32<span><a class="mark" href="#n_api_napi_get_value_uint32" id="n_api_napi_get_value_uint32">#</a></span></h4>
+<h5>napi_get_value_uint32<span><a class="mark" href="#n_api_napi_get_value_uint32" id="n_api_napi_get_value_uint32">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_uint32</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_uint32</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  <span class="hljs-keyword">uint32_t</span>* result)</span></span></code></pre>
+                                  <span class="hljs-type">uint32_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>
+<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>
 <li><code>[out] result</code>: C primitive equivalent of the given <code>napi_value</code> as a
 <code>uint32_t</code>.</li>
 </ul>
@@ -12992,13 +13566,13 @@ is passed in it returns <code>napi_string_expected</code>.</p>
 is passed in it returns <code>napi_number_expected</code>.</p>
 <p>This API returns the C primitive equivalent of the given <code>napi_value</code> as a
 <code>uint32_t</code>.</p>
-<h3>Functions to get global instances<span><a class="mark" href="#n_api_functions_to_get_global_instances" id="n_api_functions_to_get_global_instances">#</a></span></h3>
-<h4>napi_get_boolean<span><a class="mark" href="#n_api_napi_get_boolean" id="n_api_napi_get_boolean">#</a></span></h4>
+<h4>Functions to get global instances<span><a class="mark" href="#n_api_functions_to_get_global_instances" id="n_api_functions_to_get_global_instances">#</a></span></h4>
+<h5>napi_get_boolean<span><a class="mark" href="#n_api_napi_get_boolean" id="n_api_napi_get_boolean">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_boolean</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">bool</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_boolean</span><span class="hljs-params">(napi_env env, <span class="hljs-type">bool</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The value of the boolean to retrieve.</li>
@@ -13008,61 +13582,61 @@ retrieve.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to return the JavaScript singleton object that is used to
 represent the given boolean value.</p>
-<h4>napi_get_global<span><a class="mark" href="#n_api_napi_get_global" id="n_api_napi_get_global">#</a></span></h4>
+<h5>napi_get_global<span><a class="mark" href="#n_api_napi_get_global" id="n_api_napi_get_global">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_global</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_global</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing JavaScript <code>global</code> object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns the <code>global</code> object.</p>
-<h4>napi_get_null<span><a class="mark" href="#n_api_napi_get_null" id="n_api_napi_get_null">#</a></span></h4>
+<h5>napi_get_null<span><a class="mark" href="#n_api_napi_get_null" id="n_api_napi_get_null">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_null</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_null</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing JavaScript <code>null</code> object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns the <code>null</code> object.</p>
-<h4>napi_get_undefined<span><a class="mark" href="#n_api_napi_get_undefined" id="n_api_napi_get_undefined">#</a></span></h4>
+<h5>napi_get_undefined<span><a class="mark" href="#n_api_napi_get_undefined" id="n_api_napi_get_undefined">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_undefined</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_undefined</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing JavaScript Undefined value.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns the Undefined object.</p>
-<h2>Working with JavaScript values and abstract operations<span><a class="mark" href="#n_api_working_with_javascript_values_and_abstract_operations" id="n_api_working_with_javascript_values_and_abstract_operations">#</a></span></h2>
-<p>N-API exposes a set of APIs to perform some abstract operations on JavaScript
+</section><section><h3>Working with JavaScript values and abstract operations<span><a class="mark" href="#n_api_working_with_javascript_values_and_abstract_operations" id="n_api_working_with_javascript_values_and_abstract_operations">#</a></span></h3>
+<p>Node-API exposes a set of APIs to perform some abstract operations on JavaScript
 values. Some of these operations are documented under <a href="https://tc39.github.io/ecma262/#sec-abstract-operations">Section 7</a>
 of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>.</p>
 <p>These APIs support doing one of the following:</p>
 <ol>
-<li>Coerce JavaScript values to specific JavaScript types (such as <code>Number</code> or
-<code>String</code>).</li>
+<li>Coerce JavaScript values to specific JavaScript types (such as <code>number</code> or
+<code>string</code>).</li>
 <li>Check the type of a JavaScript value.</li>
 <li>Check for equality between two JavaScript values.</li>
 </ol>
-<h3>napi_coerce_to_bool<span><a class="mark" href="#n_api_napi_coerce_to_bool" id="n_api_napi_coerce_to_bool">#</a></span></h3>
+<h4>napi_coerce_to_bool<span><a class="mark" href="#n_api_napi_coerce_to_bool" id="n_api_napi_coerce_to_bool">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_coerce_to_bool</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_coerce_to_bool</span><span class="hljs-params">(napi_env env,
                                 napi_value value,
-                                napi_value* result)</span></span></code></pre>
+                                napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to coerce.</li>
@@ -13072,31 +13646,31 @@ of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specificati
 <p>This API implements the abstract operation <code>ToBoolean()</code> as defined in
 <a href="https://tc39.github.io/ecma262/#sec-toboolean">Section 7.1.2</a> of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>
-<h3>napi_coerce_to_number<span><a class="mark" href="#n_api_napi_coerce_to_number" id="n_api_napi_coerce_to_number">#</a></span></h3>
+<h4>napi_coerce_to_number<span><a class="mark" href="#n_api_napi_coerce_to_number" id="n_api_napi_coerce_to_number">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_coerce_to_number</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_coerce_to_number</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  napi_value* result)</span></span></code></pre>
+                                  napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to coerce.</li>
-<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API implements the abstract operation <code>ToNumber()</code> as defined in
 <a href="https://tc39.github.io/ecma262/#sec-tonumber">Section 7.1.3</a> of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>
-<h3>napi_coerce_to_object<span><a class="mark" href="#n_api_napi_coerce_to_object" id="n_api_napi_coerce_to_object">#</a></span></h3>
+<h4>napi_coerce_to_object<span><a class="mark" href="#n_api_napi_coerce_to_object" id="n_api_napi_coerce_to_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_coerce_to_object</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_coerce_to_object</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  napi_value* result)</span></span></code></pre>
+                                  napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to coerce.</li>
@@ -13106,29 +13680,29 @@ This API can be re-entrant if getters are defined on the passed-in <code>Object<
 <p>This API implements the abstract operation <code>ToObject()</code> as defined in
 <a href="https://tc39.github.io/ecma262/#sec-toobject">Section 7.1.13</a> of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>
-<h3>napi_coerce_to_string<span><a class="mark" href="#n_api_napi_coerce_to_string" id="n_api_napi_coerce_to_string">#</a></span></h3>
+<h4>napi_coerce_to_string<span><a class="mark" href="#n_api_napi_coerce_to_string" id="n_api_napi_coerce_to_string">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_coerce_to_string</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_coerce_to_string</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  napi_value* result)</span></span></code></pre>
+                                  napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to coerce.</li>
-<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>String</code>.</li>
+<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>string</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API implements the abstract operation <code>ToString()</code> as defined in
 <a href="https://tc39.github.io/ecma262/#sec-toobject">Section 7.1.13</a> of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>
-<h3>napi_typeof<span><a class="mark" href="#n_api_napi_typeof" id="n_api_napi_typeof">#</a></span></h3>
+<h4>napi_typeof<span><a class="mark" href="#n_api_napi_typeof" id="n_api_napi_typeof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_typeof</span><span class="hljs-params">(napi_env env, napi_value value, napi_valuetype* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_typeof</span><span class="hljs-params">(napi_env env, napi_value value, napi_valuetype* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value whose type to query.</li>
@@ -13148,15 +13722,15 @@ Specification. However, there are some differences:</p>
 <code>object</code>.</li>
 </ol>
 <p>If <code>value</code> has a type that is invalid, an error is returned.</p>
-<h3>napi_instanceof<span><a class="mark" href="#n_api_napi_instanceof" id="n_api_napi_instanceof">#</a></span></h3>
+<h4>napi_instanceof<span><a class="mark" href="#n_api_napi_instanceof" id="n_api_napi_instanceof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_instanceof</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_instanceof</span><span class="hljs-params">(napi_env env,
                             napi_value object,
                             napi_value constructor,
-                            <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+                            <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] object</code>: The JavaScript value to check.</li>
@@ -13168,12 +13742,12 @@ is true.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API represents invoking the <code>instanceof</code> Operator on the object as
 defined in <a href="https://tc39.github.io/ecma262/#sec-instanceofoperator">Section 12.10.4</a> of the ECMAScript Language Specification.</p>
-<h3>napi_is_array<span><a class="mark" href="#n_api_napi_is_array" id="n_api_napi_is_array">#</a></span></h3>
+<h4>napi_is_array<span><a class="mark" href="#n_api_napi_is_array" id="n_api_napi_is_array">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_array</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_array</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -13182,12 +13756,12 @@ defined in <a href="https://tc39.github.io/ecma262/#sec-instanceofoperator">Sect
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API represents invoking the <code>IsArray</code> operation on the object
 as defined in <a href="https://tc39.github.io/ecma262/#sec-isarray">Section 7.2.2</a> of the ECMAScript Language Specification.</p>
-<h3>napi_is_arraybuffer<span><a class="mark" href="#n_api_napi_is_arraybuffer" id="n_api_napi_is_arraybuffer">#</a></span></h3>
+<h4>napi_is_arraybuffer<span><a class="mark" href="#n_api_napi_is_arraybuffer" id="n_api_napi_is_arraybuffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_arraybuffer</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_arraybuffer</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -13195,12 +13769,12 @@ as defined in <a href="https://tc39.github.io/ecma262/#sec-isarray">Section 7.2.
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is an array buffer.</p>
-<h3>napi_is_buffer<span><a class="mark" href="#n_api_napi_is_buffer" id="n_api_napi_is_buffer">#</a></span></h3>
+<h4>napi_is_buffer<span><a class="mark" href="#n_api_napi_is_buffer" id="n_api_napi_is_buffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_buffer</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_buffer</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -13209,12 +13783,12 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is a buffer.</p>
-<h3>napi_is_date<span><a class="mark" href="#n_api_napi_is_date" id="n_api_napi_is_date">#</a></span></h3>
+<h4>napi_is_date<span><a class="mark" href="#n_api_napi_is_date" id="n_api_napi_is_date">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.11.0</span>
+<span>Added in: v11.11.0, v10.17.0</span>
 <span>N-API version: 5</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_date</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_date</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -13223,12 +13797,12 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is a date.</p>
-<h3>napi_is_error<span><a class="mark" href="#n_api_napi_is_error_1" id="n_api_napi_is_error_1">#</a></span></h3>
+<h4>napi_is_error<span><a class="mark" href="#n_api_napi_is_error_1" id="n_api_napi_is_error_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_error</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_error</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -13236,12 +13810,12 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is an <code>Error</code>.</p>
-<h3>napi_is_typedarray<span><a class="mark" href="#n_api_napi_is_typedarray" id="n_api_napi_is_typedarray">#</a></span></h3>
+<h4>napi_is_typedarray<span><a class="mark" href="#n_api_napi_is_typedarray" id="n_api_napi_is_typedarray">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_typedarray</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_typedarray</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -13249,12 +13823,12 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is a typed array.</p>
-<h3>napi_is_dataview<span><a class="mark" href="#n_api_napi_is_dataview" id="n_api_napi_is_dataview">#</a></span></h3>
+<h4>napi_is_dataview<span><a class="mark" href="#n_api_napi_is_dataview" id="n_api_napi_is_dataview">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_dataview</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_dataview</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -13262,15 +13836,15 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is a <code>DataView</code>.</p>
-<h3>napi_strict_equals<span><a class="mark" href="#n_api_napi_strict_equals" id="n_api_napi_strict_equals">#</a></span></h3>
+<h4>napi_strict_equals<span><a class="mark" href="#n_api_napi_strict_equals" id="n_api_napi_strict_equals">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_strict_equals</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_strict_equals</span><span class="hljs-params">(napi_env env,
                                napi_value lhs,
                                napi_value rhs,
-                               <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+                               <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] lhs</code>: The JavaScript value to check.</li>
@@ -13280,13 +13854,13 @@ object.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API represents the invocation of the Strict Equality algorithm as
 defined in <a href="https://tc39.github.io/ecma262/#sec-strict-equality-comparison">Section 7.2.14</a> of the ECMAScript Language Specification.</p>
-<h3>napi_detach_arraybuffer<span><a class="mark" href="#n_api_napi_detach_arraybuffer" id="n_api_napi_detach_arraybuffer">#</a></span></h3>
+<h4>napi_detach_arraybuffer<span><a class="mark" href="#n_api_napi_detach_arraybuffer" id="n_api_napi_detach_arraybuffer">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0, v10.22.0</span>
 <span>N-API version: 7</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_detach_arraybuffer</span><span class="hljs-params">(napi_env env,
-                                    napi_value arraybuffer)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_detach_arraybuffer</span><span class="hljs-params">(napi_env env,
+                                    napi_value arraybuffer)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] arraybuffer</code>: The JavaScript <code>ArrayBuffer</code> to be detached.</li>
@@ -13299,14 +13873,14 @@ detachable. For example, V8 requires that the <code>ArrayBuffer</code> be extern
 that is, created with <a href="#n_api_napi_create_external_arraybuffer"><code>napi_create_external_arraybuffer</code></a>.</p>
 <p>This API represents the invocation of the <code>ArrayBuffer</code> detach operation as
 defined in <a href="https://tc39.es/ecma262/#sec-detacharraybuffer">Section 24.1.1.3</a> of the ECMAScript Language Specification.</p>
-<h3>napi_is_detached_arraybuffer<span><a class="mark" href="#n_api_napi_is_detached_arraybuffer" id="n_api_napi_is_detached_arraybuffer">#</a></span></h3>
+<h4>napi_is_detached_arraybuffer<span><a class="mark" href="#n_api_napi_is_detached_arraybuffer" id="n_api_napi_is_detached_arraybuffer">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0, v10.22.0</span>
 <span>N-API version: 7</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_detached_arraybuffer</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_detached_arraybuffer</span><span class="hljs-params">(napi_env env,
                                          napi_value arraybuffer,
-                                         <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+                                         <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] arraybuffer</code>: The JavaScript <code>ArrayBuffer</code> to be checked.</li>
@@ -13317,21 +13891,21 @@ defined in <a href="https://tc39.es/ecma262/#sec-detacharraybuffer">Section 24.1
 <p>This API represents the invocation of the <code>ArrayBuffer</code> <code>IsDetachedBuffer</code>
 operation as defined in <a href="https://tc39.es/ecma262/#sec-isdetachedbuffer">Section 24.1.1.2</a> of the ECMAScript Language
 Specification.</p>
-<h2>Working with JavaScript properties<span><a class="mark" href="#n_api_working_with_javascript_properties" id="n_api_working_with_javascript_properties">#</a></span></h2>
-<p>N-API exposes a set of APIs to get and set properties on JavaScript
+</section><section><h3>Working with JavaScript properties<span><a class="mark" href="#n_api_working_with_javascript_properties" id="n_api_working_with_javascript_properties">#</a></span></h3>
+<p>Node-API exposes a set of APIs to get and set properties on JavaScript
 objects. Some of these types are documented under <a href="https://tc39.github.io/ecma262/#sec-abstract-operations">Section 7</a> of the
 <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>.</p>
 <p>Properties in JavaScript are represented as a tuple of a key and a value.
-Fundamentally, all property keys in N-API can be represented in one of the
+Fundamentally, all property keys in Node-API can be represented in one of the
 following forms:</p>
 <ul>
 <li>Named: a simple UTF8-encoded string</li>
 <li>Integer-Indexed: an index value represented by <code>uint32_t</code></li>
-<li>JavaScript value: these are represented in N-API by <code>napi_value</code>. This can
-be a <code>napi_value</code> representing a <code>String</code>, <code>Number</code>, or <code>Symbol</code>.</li>
+<li>JavaScript value: these are represented in Node-API by <code>napi_value</code>. This can
+be a <code>napi_value</code> representing a <code>string</code>, <code>number</code>, or <code>symbol</code>.</li>
 </ul>
-<p>N-API values are represented by the type <code>napi_value</code>.
-Any N-API call that requires a JavaScript value takes in a <code>napi_value</code>.
+<p>Node-API values are represented by the type <code>napi_value</code>.
+Any Node-API call that requires a JavaScript value takes in a <code>napi_value</code>.
 However, it's the caller's responsibility to make sure that the
 <code>napi_value</code> in question is of the JavaScript type expected by the API.</p>
 <p>The APIs documented in this section provide a simple interface to
@@ -13339,8 +13913,8 @@ get and set properties on arbitrary JavaScript objects represented by
 <code>napi_value</code>.</p>
 <p>For instance, consider the following JavaScript code snippet:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> obj = {};
-obj.myProp = <span class="hljs-number">123</span>;</code></pre>
-<p>The equivalent can be done using N-API values with the following snippet:</p>
+obj.<span class="hljs-property">myProp</span> = <span class="hljs-number">123</span>;</code></pre>
+<p>The equivalent can be done using Node-API values with the following snippet:</p>
 <pre><code class="language-c">napi_status status = napi_generic_failure;
 
 <span class="hljs-comment">// const obj = {}</span>
@@ -13359,7 +13933,7 @@ status = napi_set_named_property(env, obj, <span class="hljs-string">"myProp"</s
 JavaScript snippet:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> arr = [];
 arr[<span class="hljs-number">123</span>] = <span class="hljs-string">'hello'</span>;</code></pre>
-<p>The equivalent can be done using N-API values with the following snippet:</p>
+<p>The equivalent can be done using Node-API values with the following snippet:</p>
 <pre><code class="language-c">napi_status status = napi_generic_failure;
 
 <span class="hljs-comment">// const arr = [];</span>
@@ -13378,7 +13952,7 @@ status = napi_set_element(env, arr, <span class="hljs-number">123</span>, value)
 Consider the following JavaScript snippet:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> arr = [];
 <span class="hljs-keyword">const</span> value = arr[<span class="hljs-number">123</span>];</code></pre>
-<p>The following is the approximate equivalent of the N-API counterpart:</p>
+<p>The following is the approximate equivalent of the Node-API counterpart:</p>
 <pre><code class="language-c">napi_status status = napi_generic_failure;
 
 <span class="hljs-comment">// const arr = []</span>
@@ -13392,11 +13966,11 @@ status = napi_get_element(env, arr, <span class="hljs-number">123</span>, &#x26;
 <p>Finally, multiple properties can also be defined on an object for performance
 reasons. Consider the following JavaScript:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> obj = {};
-<span class="hljs-built_in">Object</span>.defineProperties(obj, {
+<span class="hljs-title class_">Object</span>.<span class="hljs-title function_">defineProperties</span>(obj, {
   <span class="hljs-string">'foo'</span>: { <span class="hljs-attr">value</span>: <span class="hljs-number">123</span>, <span class="hljs-attr">writable</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">configurable</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">enumerable</span>: <span class="hljs-literal">true</span> },
   <span class="hljs-string">'bar'</span>: { <span class="hljs-attr">value</span>: <span class="hljs-number">456</span>, <span class="hljs-attr">writable</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">configurable</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">enumerable</span>: <span class="hljs-literal">true</span> }
 });</code></pre>
-<p>The following is the approximate equivalent of the N-API counterpart:</p>
+<p>The following is the approximate equivalent of the Node-API counterpart:</p>
 <pre><code class="language-c">napi_status status = napi_status_generic_failure;
 
 <span class="hljs-comment">// const obj = {};</span>
@@ -13421,18 +13995,18 @@ status = napi_define_properties(env,
                                 <span class="hljs-keyword">sizeof</span>(descriptors) / <span class="hljs-keyword">sizeof</span>(descriptors[<span class="hljs-number">0</span>]),
                                 descriptors);
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> status;</code></pre>
-<h3>Structures<span><a class="mark" href="#n_api_structures" id="n_api_structures">#</a></span></h3>
-<h4>napi_property_attributes<span><a class="mark" href="#n_api_napi_property_attributes" id="n_api_napi_property_attributes">#</a></span></h4>
+<h4>Structures<span><a class="mark" href="#n_api_structures" id="n_api_structures">#</a></span></h4>
+<h5>napi_property_attributes<span><a class="mark" href="#n_api_napi_property_attributes" id="n_api_napi_property_attributes">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.20.0</td>
-<td><p>added <code>napi_default_method</code> and <code>napi_default_property</code></p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>added <code>napi_default_method</code> and <code>napi_default_property</code>.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_default = <span class="hljs-number">0</span>,
   napi_writable = <span class="hljs-number">1</span> &#x3C;&#x3C; <span class="hljs-number">0</span>,
   napi_enumerable = <span class="hljs-number">1</span> &#x3C;&#x3C; <span class="hljs-number">1</span>,
@@ -13446,7 +14020,7 @@ status = napi_define_properties(env,
   napi_default_method = napi_writable | napi_configurable,
 
   <span class="hljs-comment">// Default for object properties, like in JS obj[prop].</span>
-  napi_default_property = napi_writable |
+  napi_default_jsproperty = napi_writable |
                           napi_enumerable |
                           napi_configurable,
 } napi_property_attributes;</code></pre>
@@ -13465,15 +14039,15 @@ property is read only, not enumerable and not configurable.</li>
 <li><code>napi_static</code>: The property will be defined as a static property on a class as
 opposed to an instance property, which is the default. This is used only by
 <a href="#n_api_napi_define_class"><code>napi_define_class</code></a>. It is ignored by <code>napi_define_properties</code>.</li>
-<li><code>napi_default_method</code>: The property is configureable, writeable but not
-enumerable like a method in a JS class.</li>
-<li><code>napi_default_property</code>: The property is writable, enumerable and configurable
-like a property set via JS code <code>obj.key = value</code>.</li>
+<li><code>napi_default_method</code>: Like a method in a JS class, the property is
+configurable and writeable, but not enumerable.</li>
+<li><code>napi_default_jsproperty</code>: Like a property set via assignment in JavaScript,
+the property is writable, enumerable, and configurable.</li>
 </ul>
-<h4>napi_property_descriptor<span><a class="mark" href="#n_api_napi_property_descriptor" id="n_api_napi_property_descriptor">#</a></span></h4>
+<h5>napi_property_descriptor<span><a class="mark" href="#n_api_napi_property_descriptor" id="n_api_napi_property_descriptor">#</a></span></h5>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> {</span>
   <span class="hljs-comment">// One of utf8name or name should be NULL.</span>
-  <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8name;
+  <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8name;
   napi_value name;
 
   napi_callback method;
@@ -13482,10 +14056,10 @@ like a property set via JS code <code>obj.key = value</code>.</li>
   napi_value value;
 
   napi_property_attributes attributes;
-  <span class="hljs-keyword">void</span>* data;
+  <span class="hljs-type">void</span>* data;
 } napi_property_descriptor;</code></pre>
 <ul>
-<li><code>utf8name</code>: Optional <code>String</code> describing the key for the property,
+<li><code>utf8name</code>: Optional string describing the key for the property,
 encoded as UTF8. One of <code>utf8name</code> or <code>name</code> must be provided for the
 property.</li>
 <li><code>name</code>: Optional <code>napi_value</code> that points to a JavaScript string or symbol
@@ -13498,12 +14072,12 @@ property is a data property. If this is passed in, set <code>getter</code>, <cod
 If this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members
 won't be used). The given function is called implicitly by the runtime when
 the property is accessed from JavaScript code (or if a get on the property is
-performed using a N-API call). <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
+performed using a Node-API call). <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
 <li><code>setter</code>: A function to call when a set access of the property is performed.
 If this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members
 won't be used). The given function is called implicitly by the runtime when
 the property is set from JavaScript code (or if a set on the property is
-performed using a N-API call). <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
+performed using a Node-API call). <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
 <li><code>method</code>: Set this to make the property descriptor object's <code>value</code>
 property to be a JavaScript function represented by <code>method</code>. If this is
 passed in, set <code>value</code>, <code>getter</code> and <code>setter</code> to <code>NULL</code> (since these members
@@ -13513,17 +14087,17 @@ won't be used). <a href="#n_api_napi_callback"><code>napi_callback</code></a> pr
 <li><code>data</code>: The callback data passed into <code>method</code>, <code>getter</code> and <code>setter</code> if this
 function is invoked.</li>
 </ul>
-<h3>Functions<span><a class="mark" href="#n_api_functions" id="n_api_functions">#</a></span></h3>
-<h4>napi_get_property_names<span><a class="mark" href="#n_api_napi_get_property_names" id="n_api_napi_get_property_names">#</a></span></h4>
+<h4>Functions<span><a class="mark" href="#n_api_functions" id="n_api_functions">#</a></span></h4>
+<h5>napi_get_property_names<span><a class="mark" href="#n_api_napi_get_property_names" id="n_api_napi_get_property_names">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_property_names</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_property_names</span><span class="hljs-params">(napi_env env,
                                     napi_value object,
-                                    napi_value* result)</span></span>;</code></pre>
+                                    napi_value* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the properties.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values
 that represent the property names of the object. The API can be used to
@@ -13534,9 +14108,9 @@ and <a href="#n_api_napi_get_element"><code>napi_get_element</code></a>.</li>
 <p>This API returns the names of the enumerable properties of <code>object</code> as an array
 of strings. The properties of <code>object</code> whose key is a symbol will not be
 included.</p>
-<h4>napi_get_all_property_names<span><a class="mark" href="#n_api_napi_get_all_property_names" id="n_api_napi_get_all_property_names">#</a></span></h4>
+<h5>napi_get_all_property_names<span><a class="mark" href="#n_api_napi_get_all_property_names" id="n_api_napi_get_all_property_names">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
 <pre><code class="language-c">napi_get_all_property_names(napi_env env,
@@ -13546,81 +14120,81 @@ included.</p>
                             napi_key_conversion key_conversion,
                             napi_value* result);</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the properties.</li>
 <li><code>[in] key_mode</code>: Whether to retrieve prototype properties as well.</li>
 <li><code>[in] key_filter</code>: Which properties to retrieve
 (enumerable/readable/writable).</li>
 <li><code>[in] key_conversion</code>: Whether to convert numbered property keys to strings.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values
-that represent the property names of the object. <a href="#n_api_napi_get_array_length"><code>napi_get_array_length</code></a> and
-<a href="#n_api_napi_get_element"><code>napi_get_element</code></a> can be used to iterate over <code>result</code>.</li>
+that represent the property names of the object. <a href="#n_api_napi_get_array_length"><code>napi_get_array_length</code></a>
+and <a href="#n_api_napi_get_element"><code>napi_get_element</code></a> can be used to iterate over <code>result</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns an array containing the names of the available properties
 of this object.</p>
-<h4>napi_set_property<span><a class="mark" href="#n_api_napi_set_property" id="n_api_napi_set_property">#</a></span></h4>
+<h5>napi_set_property<span><a class="mark" href="#n_api_napi_set_property" id="n_api_napi_set_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_set_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_set_property</span><span class="hljs-params">(napi_env env,
                               napi_value object,
                               napi_value key,
-                              napi_value value)</span></span>;</code></pre>
+                              napi_value value)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object on which to set the property.</li>
 <li><code>[in] key</code>: The name of the property to set.</li>
 <li><code>[in] value</code>: The property value.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API set a property on the <code>Object</code> passed in.</p>
-<h4>napi_get_property<span><a class="mark" href="#n_api_napi_get_property" id="n_api_napi_get_property">#</a></span></h4>
+<h5>napi_get_property<span><a class="mark" href="#n_api_napi_get_property" id="n_api_napi_get_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_property</span><span class="hljs-params">(napi_env env,
                               napi_value object,
                               napi_value key,
-                              napi_value* result)</span></span>;</code></pre>
+                              napi_value* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the property.</li>
 <li><code>[in] key</code>: The name of the property to retrieve.</li>
 <li><code>[out] result</code>: The value of the property.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API gets the requested property from the <code>Object</code> passed in.</p>
-<h4>napi_has_property<span><a class="mark" href="#n_api_napi_has_property" id="n_api_napi_has_property">#</a></span></h4>
+<h5>napi_has_property<span><a class="mark" href="#n_api_napi_has_property" id="n_api_napi_has_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_has_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_has_property</span><span class="hljs-params">(napi_env env,
                               napi_value object,
                               napi_value key,
-                              <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                              <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] key</code>: The name of the property whose existence to check.</li>
 <li><code>[out] result</code>: Whether the property exists on the object or not.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in has the named property.</p>
-<h4>napi_delete_property<span><a class="mark" href="#n_api_napi_delete_property" id="n_api_napi_delete_property">#</a></span></h4>
+<h5>napi_delete_property<span><a class="mark" href="#n_api_napi_delete_property" id="n_api_napi_delete_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_delete_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_delete_property</span><span class="hljs-params">(napi_env env,
                                  napi_value object,
                                  napi_value key,
-                                 <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                 <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] key</code>: The name of the property to delete.</li>
 <li><code>[out] result</code>: Whether the property deletion succeeded or not. <code>result</code> can
@@ -13628,36 +14202,36 @@ optionally be ignored by passing <code>NULL</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API attempts to delete the <code>key</code> own property from <code>object</code>.</p>
-<h4>napi_has_own_property<span><a class="mark" href="#n_api_napi_has_own_property" id="n_api_napi_has_own_property">#</a></span></h4>
+<h5>napi_has_own_property<span><a class="mark" href="#n_api_napi_has_own_property" id="n_api_napi_has_own_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_has_own_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_has_own_property</span><span class="hljs-params">(napi_env env,
                                   napi_value object,
                                   napi_value key,
-                                  <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                  <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] key</code>: The name of the own property whose existence to check.</li>
 <li><code>[out] result</code>: Whether the own property exists on the object or not.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in has the named own property. <code>key</code> must
-be a string or a <code>Symbol</code>, or an error will be thrown. N-API will not perform
-any conversion between data types.</p>
-<h4>napi_set_named_property<span><a class="mark" href="#n_api_napi_set_named_property" id="n_api_napi_set_named_property">#</a></span></h4>
+be a <code>string</code> or a <code>symbol</code>, or an error will be thrown. Node-API will not
+perform any conversion between data types.</p>
+<h5>napi_set_named_property<span><a class="mark" href="#n_api_napi_set_named_property" id="n_api_napi_set_named_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_set_named_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_set_named_property</span><span class="hljs-params">(napi_env env,
                                     napi_value object,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8Name,
-                                    napi_value value)</span></span>;</code></pre>
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8Name,
+                                    napi_value value)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object on which to set the property.</li>
 <li><code>[in] utf8Name</code>: The name of the property to set.</li>
 <li><code>[in] value</code>: The property value.</li>
@@ -13665,17 +14239,17 @@ any conversion between data types.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This method is equivalent to calling <a href="#n_api_napi_set_property"><code>napi_set_property</code></a> with a <code>napi_value</code>
 created from the string passed in as <code>utf8Name</code>.</p>
-<h4>napi_get_named_property<span><a class="mark" href="#n_api_napi_get_named_property" id="n_api_napi_get_named_property">#</a></span></h4>
+<h5>napi_get_named_property<span><a class="mark" href="#n_api_napi_get_named_property" id="n_api_napi_get_named_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_named_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_named_property</span><span class="hljs-params">(napi_env env,
                                     napi_value object,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8Name,
-                                    napi_value* result)</span></span>;</code></pre>
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8Name,
+                                    napi_value* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the property.</li>
 <li><code>[in] utf8Name</code>: The name of the property to get.</li>
 <li><code>[out] result</code>: The value of the property.</li>
@@ -13683,17 +14257,17 @@ created from the string passed in as <code>utf8Name</code>.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This method is equivalent to calling <a href="#n_api_napi_get_property"><code>napi_get_property</code></a> with a <code>napi_value</code>
 created from the string passed in as <code>utf8Name</code>.</p>
-<h4>napi_has_named_property<span><a class="mark" href="#n_api_napi_has_named_property" id="n_api_napi_has_named_property">#</a></span></h4>
+<h5>napi_has_named_property<span><a class="mark" href="#n_api_napi_has_named_property" id="n_api_napi_has_named_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_has_named_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_has_named_property</span><span class="hljs-params">(napi_env env,
                                     napi_value object,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8Name,
-                                    <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8Name,
+                                    <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] utf8Name</code>: The name of the property whose existence to check.</li>
 <li><code>[out] result</code>: Whether the property exists on the object or not.</li>
@@ -13701,51 +14275,51 @@ created from the string passed in as <code>utf8Name</code>.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This method is equivalent to calling <a href="#n_api_napi_has_property"><code>napi_has_property</code></a> with a <code>napi_value</code>
 created from the string passed in as <code>utf8Name</code>.</p>
-<h4>napi_set_element<span><a class="mark" href="#n_api_napi_set_element" id="n_api_napi_set_element">#</a></span></h4>
+<h5>napi_set_element<span><a class="mark" href="#n_api_napi_set_element" id="n_api_napi_set_element">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_set_element</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_set_element</span><span class="hljs-params">(napi_env env,
                              napi_value object,
-                             <span class="hljs-keyword">uint32_t</span> index,
-                             napi_value value)</span></span>;</code></pre>
+                             <span class="hljs-type">uint32_t</span> index,
+                             napi_value value)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to set the properties.</li>
 <li><code>[in] index</code>: The index of the property to set.</li>
 <li><code>[in] value</code>: The property value.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API sets and element on the <code>Object</code> passed in.</p>
-<h4>napi_get_element<span><a class="mark" href="#n_api_napi_get_element" id="n_api_napi_get_element">#</a></span></h4>
+<h5>napi_get_element<span><a class="mark" href="#n_api_napi_get_element" id="n_api_napi_get_element">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_element</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_element</span><span class="hljs-params">(napi_env env,
                              napi_value object,
-                             <span class="hljs-keyword">uint32_t</span> index,
-                             napi_value* result)</span></span>;</code></pre>
+                             <span class="hljs-type">uint32_t</span> index,
+                             napi_value* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the property.</li>
 <li><code>[in] index</code>: The index of the property to get.</li>
 <li><code>[out] result</code>: The value of the property.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API gets the element at the requested index.</p>
-<h4>napi_has_element<span><a class="mark" href="#n_api_napi_has_element" id="n_api_napi_has_element">#</a></span></h4>
+<h5>napi_has_element<span><a class="mark" href="#n_api_napi_has_element" id="n_api_napi_has_element">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_has_element</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_has_element</span><span class="hljs-params">(napi_env env,
                              napi_value object,
-                             <span class="hljs-keyword">uint32_t</span> index,
-                             <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                             <span class="hljs-type">uint32_t</span> index,
+                             <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] index</code>: The index of the property whose existence to check.</li>
 <li><code>[out] result</code>: Whether the property exists on the object or not.</li>
@@ -13753,17 +14327,17 @@ created from the string passed in as <code>utf8Name</code>.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns if the <code>Object</code> passed in has an element at the
 requested index.</p>
-<h4>napi_delete_element<span><a class="mark" href="#n_api_napi_delete_element" id="n_api_napi_delete_element">#</a></span></h4>
+<h5>napi_delete_element<span><a class="mark" href="#n_api_napi_delete_element" id="n_api_napi_delete_element">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_delete_element</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_delete_element</span><span class="hljs-params">(napi_env env,
                                 napi_value object,
-                                <span class="hljs-keyword">uint32_t</span> index,
-                                <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                <span class="hljs-type">uint32_t</span> index,
+                                <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] index</code>: The index of the property to delete.</li>
 <li><code>[out] result</code>: Whether the element deletion succeeded or not. <code>result</code> can
@@ -13771,17 +14345,17 @@ optionally be ignored by passing <code>NULL</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API attempts to delete the specified <code>index</code> from <code>object</code>.</p>
-<h4>napi_define_properties<span><a class="mark" href="#n_api_napi_define_properties" id="n_api_napi_define_properties">#</a></span></h4>
+<h5>napi_define_properties<span><a class="mark" href="#n_api_napi_define_properties" id="n_api_napi_define_properties">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_define_properties</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_define_properties</span><span class="hljs-params">(napi_env env,
                                    napi_value object,
-                                   <span class="hljs-keyword">size_t</span> property_count,
-                                   <span class="hljs-keyword">const</span> napi_property_descriptor* properties)</span></span>;</code></pre>
+                                   <span class="hljs-type">size_t</span> property_count,
+                                   <span class="hljs-keyword">const</span> napi_property_descriptor* properties)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the properties.</li>
 <li><code>[in] property_count</code>: The number of elements in the <code>properties</code> array.</li>
 <li><code>[in] properties</code>: The array of property descriptors.</li>
@@ -13793,15 +14367,15 @@ object. The properties are defined using property descriptors (see
 this API will set the properties on the object one at a time, as defined by
 <code>DefineOwnProperty()</code> (described in <a href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc">Section 9.1.6</a> of the ECMA-262
 specification).</p>
-<h4>napi_object_freeze<span><a class="mark" href="#n_api_napi_object_freeze" id="n_api_napi_object_freeze">#</a></span></h4>
+<h5>napi_object_freeze<span><a class="mark" href="#n_api_napi_object_freeze" id="n_api_napi_object_freeze">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v14.14.0, v12.20.0</span>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_object_freeze</span><span class="hljs-params">(napi_env env,
-                               napi_value object)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_object_freeze</span><span class="hljs-params">(napi_env env,
+                               napi_value object)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to freeze.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
@@ -13812,15 +14386,15 @@ properties, and prevents the values of existing properties from being changed.
 It also prevents the object's prototype from being changed. This is described
 in <a href="https://tc39.es/ecma262/#sec-object.freeze">Section 19.1.2.6</a> of the
 ECMA-262 specification.</p>
-<h4>napi_object_seal<span><a class="mark" href="#n_api_napi_object_seal" id="n_api_napi_object_seal">#</a></span></h4>
+<h5>napi_object_seal<span><a class="mark" href="#n_api_napi_object_seal" id="n_api_napi_object_seal">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v14.14.0, v12.20.0</span>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_object_seal</span><span class="hljs-params">(napi_env env,
-                             napi_value object)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_object_seal</span><span class="hljs-params">(napi_env env,
+                             napi_value object)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to seal.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
@@ -13828,9 +14402,9 @@ ECMA-262 specification.</p>
 added to it, as well as marking all existing properties as non-configurable.
 This is described in <a href="https://tc39.es/ecma262/#sec-object.seal">Section 19.1.2.20</a>
 of the ECMA-262 specification.</p>
-<h2>Working with JavaScript functions<span><a class="mark" href="#n_api_working_with_javascript_functions" id="n_api_working_with_javascript_functions">#</a></span></h2>
-<p>N-API provides a set of APIs that allow JavaScript code to
-call back into native code. N-API APIs that support calling back
+</section><section><h3>Working with JavaScript functions<span><a class="mark" href="#n_api_working_with_javascript_functions" id="n_api_working_with_javascript_functions">#</a></span></h3>
+<p>Node-API provides a set of APIs that allow JavaScript code to
+call back into native code. Node-APIs that support calling back
 into native code take in a callback functions represented by
 the <code>napi_callback</code> type. When the JavaScript VM calls back to
 native code, the <code>napi_callback</code> function provided is invoked. The APIs
@@ -13841,7 +14415,7 @@ following:</p>
 <li>Get the arguments passed into the callback.</li>
 <li>Return a <code>napi_value</code> back from the callback.</li>
 </ul>
-<p>Additionally, N-API provides a set of functions which allow calling
+<p>Additionally, Node-API provides a set of functions which allow calling
 JavaScript functions from native code. One can either call a function
 like a regular JavaScript function call, or as a constructor
 function.</p>
@@ -13849,20 +14423,20 @@ function.</p>
 <code>napi_property_descriptor</code> items can be associated with <code>object</code> and freed
 whenever <code>object</code> is garbage-collected by passing both <code>object</code> and the data to
 <a href="#n_api_napi_add_finalizer"><code>napi_add_finalizer</code></a>.</p>
-<h3>napi_call_function<span><a class="mark" href="#n_api_napi_call_function" id="n_api_napi_call_function">#</a></span></h3>
+<h4>napi_call_function<span><a class="mark" href="#n_api_napi_call_function" id="n_api_napi_call_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_call_function</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_call_function</span><span class="hljs-params">(napi_env env,
                                            napi_value recv,
                                            napi_value func,
-                                           <span class="hljs-keyword">size_t</span> argc,
+                                           <span class="hljs-type">size_t</span> argc,
                                            <span class="hljs-keyword">const</span> napi_value* argv,
-                                           napi_value* result)</span></span>;</code></pre>
+                                           napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] recv</code>: The <code>this</code> object passed to the called function.</li>
+<li><code>[in] recv</code>: The <code>this</code> value passed to the called function.</li>
 <li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>
 <li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>
 <li><code>[in] argv</code>: Array of <code>napi_values</code> representing JavaScript values passed in
@@ -13876,7 +14450,7 @@ native code <em>into</em> JavaScript. For the special case of calling into JavaS
 after an async operation, see <a href="#n_api_napi_make_callback"><code>napi_make_callback</code></a>.</p>
 <p>A sample use case might look as follows. Consider the following JavaScript
 snippet:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">AddTwo</span>(<span class="hljs-params">num</span>) </span>{
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">AddTwo</span>(<span class="hljs-params">num</span>) {
   <span class="hljs-keyword">return</span> num + <span class="hljs-number">2</span>;
 }</code></pre>
 <p>Then, the above function can be invoked from a native add-on using the
@@ -13894,7 +14468,7 @@ status = napi_create_int32(env, <span class="hljs-number">1337</span>, &#x26;arg
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span>;
 
 napi_value* argv = &#x26;arg;
-<span class="hljs-keyword">size_t</span> argc = <span class="hljs-number">1</span>;
+<span class="hljs-type">size_t</span> argc = <span class="hljs-number">1</span>;
 
 <span class="hljs-comment">// AddTwo(arg);</span>
 napi_value return_val;
@@ -13902,20 +14476,20 @@ status = napi_call_function(env, global, add_two, argc, argv, &#x26;return_val);
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span>;
 
 <span class="hljs-comment">// Convert the result back to a native type</span>
-<span class="hljs-keyword">int32_t</span> result;
+<span class="hljs-type">int32_t</span> result;
 status = napi_get_value_int32(env, return_val, &#x26;result);
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span>;</code></pre>
-<h3>napi_create_function<span><a class="mark" href="#n_api_napi_create_function" id="n_api_napi_create_function">#</a></span></h3>
+<h4>napi_create_function<span><a class="mark" href="#n_api_napi_create_function" id="n_api_napi_create_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_function</span><span class="hljs-params">(napi_env env,
-                                 <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8name,
-                                 <span class="hljs-keyword">size_t</span> length,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_function</span><span class="hljs-params">(napi_env env,
+                                 <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8name,
+                                 <span class="hljs-type">size_t</span> length,
                                  napi_callback cb,
-                                 <span class="hljs-keyword">void</span>* data,
-                                 napi_value* result)</span></span>;</code></pre>
+                                 <span class="hljs-type">void</span>* data,
+                                 napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] utf8Name</code>: The name of the function encoded as UTF8. This is visible
@@ -13939,12 +14513,12 @@ to JavaScript, in order for the function to be accessible from script.</p>
 <p>In order to expose a function as part of the
 add-on's module exports, set the newly created function on the exports
 object. A sample module might look as follows:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_value <span class="hljs-title">SayHello</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
+<pre><code class="language-c">napi_value <span class="hljs-title function_">SayHello</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
   <span class="hljs-built_in">printf</span>(<span class="hljs-string">"Hello\n"</span>);
   <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
 }
 
-<span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> </span>{
+napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> {
   napi_status status;
 
   napi_value fn;
@@ -13960,7 +14534,7 @@ object. A sample module might look as follows:</p>
 NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)</code></pre>
 <p>Given the above code, the add-on can be used from JavaScript as follows:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> myaddon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./addon'</span>);
-myaddon.sayHello();</code></pre>
+myaddon.<span class="hljs-title function_">sayHello</span>();</code></pre>
 <p>The string passed to <code>require()</code> is the name of the target in <code>binding.gyp</code>
 responsible for creating the <code>.node</code> file.</p>
 <p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> parameter can
@@ -13969,22 +14543,22 @@ be associated with the resulting JavaScript function (which is returned in the
 passing both the JavaScript function and the data to <a href="#n_api_napi_add_finalizer"><code>napi_add_finalizer</code></a>.</p>
 <p>JavaScript <code>Function</code>s are described in <a href="https://tc39.github.io/ecma262/#sec-function-objects">Section 19.2</a> of the ECMAScript
 Language Specification.</p>
-<h3>napi_get_cb_info<span><a class="mark" href="#n_api_napi_get_cb_info" id="n_api_napi_get_cb_info">#</a></span></h3>
+<h4>napi_get_cb_info<span><a class="mark" href="#n_api_napi_get_cb_info" id="n_api_napi_get_cb_info">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_cb_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_cb_info</span><span class="hljs-params">(napi_env env,
                              napi_callback_info cbinfo,
-                             <span class="hljs-keyword">size_t</span>* argc,
+                             <span class="hljs-type">size_t</span>* argc,
                              napi_value* argv,
                              napi_value* thisArg,
-                             <span class="hljs-keyword">void</span>** data)</span></span></code></pre>
+                             <span class="hljs-type">void</span>** data)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] cbinfo</code>: The callback info passed into the callback function.</li>
-<li><code>[in-out] argc</code>: Specifies the size of the provided <code>argv</code> array and receives
-the actual count of arguments.</li>
+<li><code>[in-out] argc</code>: Specifies the length of the provided <code>argv</code> array and
+receives the actual count of arguments.</li>
 <li><code>[out] argv</code>: Buffer to which the <code>napi_value</code> representing the arguments are
 copied. If there are more arguments than the provided count, only the
 requested number of arguments are copied. If there are fewer arguments
@@ -13996,14 +14570,14 @@ that represent <code>undefined</code>.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This method is used within a callback function to retrieve details about the
 call like the arguments and the <code>this</code> pointer from a given callback info.</p>
-<h3>napi_get_new_target<span><a class="mark" href="#n_api_napi_get_new_target" id="n_api_napi_get_new_target">#</a></span></h3>
+<h4>napi_get_new_target<span><a class="mark" href="#n_api_napi_get_new_target" id="n_api_napi_get_new_target">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.6.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_new_target</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_new_target</span><span class="hljs-params">(napi_env env,
                                 napi_callback_info cbinfo,
-                                napi_value* result)</span></span></code></pre>
+                                napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] cbinfo</code>: The callback info passed into the callback function.</li>
@@ -14012,16 +14586,16 @@ call like the arguments and the <code>this</code> pointer from a given callback
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns the <code>new.target</code> of the constructor call. If the current
 callback is not a constructor call, the result is <code>NULL</code>.</p>
-<h3>napi_new_instance<span><a class="mark" href="#n_api_napi_new_instance" id="n_api_napi_new_instance">#</a></span></h3>
+<h4>napi_new_instance<span><a class="mark" href="#n_api_napi_new_instance" id="n_api_napi_new_instance">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_new_instance</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_new_instance</span><span class="hljs-params">(napi_env env,
                               napi_value cons,
-                              <span class="hljs-keyword">size_t</span> argc,
+                              <span class="hljs-type">size_t</span> argc,
                               napi_value* argv,
-                              napi_value* result)</span></span></code></pre>
+                              napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] cons</code>: <code>napi_value</code> representing the JavaScript function to be invoked
@@ -14035,13 +14609,13 @@ which in this case is the constructed object.</li>
 <p>This method is used to instantiate a new JavaScript value using a given
 <code>napi_value</code> that represents the constructor for the object. For example,
 consider the following snippet:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyObject</span>(<span class="hljs-params">param</span>) </span>{
-  <span class="hljs-built_in">this</span>.param = param;
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">MyObject</span>(<span class="hljs-params">param</span>) {
+  <span class="hljs-variable language_">this</span>.<span class="hljs-property">param</span> = param;
 }
 
 <span class="hljs-keyword">const</span> arg = <span class="hljs-string">'hello'</span>;
-<span class="hljs-keyword">const</span> value = <span class="hljs-keyword">new</span> MyObject(arg);</code></pre>
-<p>The following can be approximated in N-API using the following snippet:</p>
+<span class="hljs-keyword">const</span> value = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyObject</span>(arg);</code></pre>
+<p>The following can be approximated in Node-API using the following snippet:</p>
 <pre><code class="language-c"><span class="hljs-comment">// Get the constructor function MyObject</span>
 napi_value global, constructor, arg, value;
 napi_status status = napi_get_global(env, &#x26;global);
@@ -14055,13 +14629,13 @@ status = napi_create_string_utf8(env, <span class="hljs-string">"hello"</span>,
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span>;
 
 napi_value* argv = &#x26;arg;
-<span class="hljs-keyword">size_t</span> argc = <span class="hljs-number">1</span>;
+<span class="hljs-type">size_t</span> argc = <span class="hljs-number">1</span>;
 
 <span class="hljs-comment">// const value = new MyObject(arg)</span>
 status = napi_new_instance(env, constructor, argc, argv, &#x26;value);</code></pre>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<h2>Object wrap<span><a class="mark" href="#n_api_object_wrap" id="n_api_object_wrap">#</a></span></h2>
-<p>N-API offers a way to "wrap" C++ classes and instances so that the class
+</section><section><h3>Object wrap<span><a class="mark" href="#n_api_object_wrap" id="n_api_object_wrap">#</a></span></h3>
+<p>Node-API offers a way to "wrap" C++ classes and instances so that the class
 constructor and methods can be called from JavaScript.</p>
 <ol>
 <li>The <a href="#n_api_napi_define_class"><code>napi_define_class</code></a> API defines a JavaScript class with constructor,
@@ -14082,7 +14656,7 @@ reference to the class constructor for later <code>instanceof</code> checks.</p>
 <pre><code class="language-c">napi_value MyClass_constructor = <span class="hljs-literal">NULL</span>;
 status = napi_get_reference_value(env, MyClass::es_constructor, &#x26;MyClass_constructor);
 assert(napi_ok == status);
-<span class="hljs-keyword">bool</span> is_instance = <span class="hljs-literal">false</span>;
+<span class="hljs-type">bool</span> is_instance = <span class="hljs-literal">false</span>;
 status = napi_instanceof(env, es_this, MyClass_constructor, &#x26;is_instance);
 assert(napi_ok == status);
 <span class="hljs-keyword">if</span> (is_instance) {
@@ -14100,10 +14674,10 @@ cases there is a chance that they may be unwrapped incorrectly.</p>
 
 <span class="hljs-comment">// `openDatabase()` returns a JavaScript object that wraps a native database</span>
 <span class="hljs-comment">// handle.</span>
-<span class="hljs-keyword">const</span> dbHandle = myAddon.openDatabase();
+<span class="hljs-keyword">const</span> dbHandle = myAddon.<span class="hljs-title function_">openDatabase</span>();
 
 <span class="hljs-comment">// `query()` returns a JavaScript object that wraps a native query handle.</span>
-<span class="hljs-keyword">const</span> queryHandle = myAddon.query(dbHandle, <span class="hljs-string">'Gimme ALL the things!'</span>);
+<span class="hljs-keyword">const</span> queryHandle = myAddon.<span class="hljs-title function_">query</span>(dbHandle, <span class="hljs-string">'Gimme ALL the things!'</span>);
 
 <span class="hljs-comment">// There is an accidental error in the line below. The first parameter to</span>
 <span class="hljs-comment">// `myAddon.queryHasRecords()` should be the database handle (`dbHandle`), not</span>
@@ -14112,7 +14686,7 @@ cases there is a chance that they may be unwrapped incorrectly.</p>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// myAddon.queryHasRecords(dbHandle, queryHandle)</span>
 <span class="hljs-comment">//</span>
-<span class="hljs-keyword">while</span> (myAddon.queryHasRecords(queryHandle, dbHandle)) {
+<span class="hljs-keyword">while</span> (myAddon.<span class="hljs-title function_">queryHasRecords</span>(queryHandle, dbHandle)) {
   <span class="hljs-comment">// retrieve records</span>
 }</code></pre>
 <p>In the above example <code>myAddon.queryHasRecords()</code> is a method that accepts two
@@ -14136,8 +14710,8 @@ set to the prototype of the constructor for query handle instances. In this
 case, the database handle instance can appear as a query handle instance, and it
 will pass the <code>napi_instanceof()</code> test for a query handle instance, while still
 containing a pointer to a database handle.</p>
-<p>To this end, N-API provides type-tagging capabilities.</p>
-<p>A type tag is a 128-bit integer unique to the addon. N-API provides the
+<p>To this end, Node-API provides type-tagging capabilities.</p>
+<p>A type tag is a 128-bit integer unique to the addon. Node-API provides the
 <code>napi_type_tag</code> structure for storing a type tag. When such a value is passed
 along with a JavaScript object stored in a <code>napi_value</code> to
 <code>napi_type_tag_object()</code>, the JavaScript object will be "marked" with the
@@ -14164,8 +14738,8 @@ illustrates the use of <code>napi_type_tag_object()</code> and
   <span class="hljs-number">0x9c73317f9fad44a3</span>, <span class="hljs-number">0x93c3920bf3b0ad6a</span>
 };
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> napi_value
-<span class="hljs-title">openDatabase</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
+<span class="hljs-keyword">static</span> napi_value
+<span class="hljs-title function_">openDatabase</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
   napi_status status;
   napi_value result;
 
@@ -14191,12 +14765,12 @@ illustrates the use of <code>napi_type_tag_object()</code> and
 <span class="hljs-comment">// we can use `napi_check_object_type_tag()` to ensure that it is indeed such a</span>
 <span class="hljs-comment">// handle.</span>
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> napi_value
-<span class="hljs-title">query</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
+<span class="hljs-keyword">static</span> napi_value
+<span class="hljs-title function_">query</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
   napi_status status;
-  <span class="hljs-keyword">size_t</span> argc = <span class="hljs-number">2</span>;
+  <span class="hljs-type">size_t</span> argc = <span class="hljs-number">2</span>;
   napi_value argv[<span class="hljs-number">2</span>];
-  <span class="hljs-keyword">bool</span> is_db_handle;
+  <span class="hljs-type">bool</span> is_db_handle;
 
   status = napi_get_cb_info(env, info, &#x26;argc, argv, <span class="hljs-literal">NULL</span>, <span class="hljs-literal">NULL</span>);
   <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
@@ -14215,29 +14789,30 @@ illustrates the use of <code>napi_type_tag_object()</code> and
     <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
   }
 }</code></pre>
-<h3>napi_define_class<span><a class="mark" href="#n_api_napi_define_class" id="n_api_napi_define_class">#</a></span></h3>
+<h4>napi_define_class<span><a class="mark" href="#n_api_napi_define_class" id="n_api_napi_define_class">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_define_class</span><span class="hljs-params">(napi_env env,
-                              <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8name,
-                              <span class="hljs-keyword">size_t</span> length,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_define_class</span><span class="hljs-params">(napi_env env,
+                              <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8name,
+                              <span class="hljs-type">size_t</span> length,
                               napi_callback constructor,
-                              <span class="hljs-keyword">void</span>* data,
-                              <span class="hljs-keyword">size_t</span> property_count,
+                              <span class="hljs-type">void</span>* data,
+                              <span class="hljs-type">size_t</span> property_count,
                               <span class="hljs-keyword">const</span> napi_property_descriptor* properties,
-                              napi_value* result)</span></span>;</code></pre>
+                              napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] utf8name</code>: Name of the JavaScript constructor function; this is
-not required to be the same as the C++ class name, though it is recommended
-for clarity.</li>
+<li><code>[in] utf8name</code>: Name of the JavaScript constructor function; When wrapping a
+C++ class, we recommend for clarity that this name be the same as that of
+the C++ class.</li>
 <li><code>[in] length</code>: The length of the <code>utf8name</code> in bytes, or <code>NAPI_AUTO_LENGTH</code>
 if it is null-terminated.</li>
 <li><code>[in] constructor</code>: Callback function that handles constructing instances
-of the class. This should be a static method on the class, not an actual
-C++ constructor function. <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
+of the class. When wrapping a C++ class, this method must be a static member
+with the <a href="#n_api_napi_callback"><code>napi_callback</code></a> signature. A C++ class constructor cannot be
+used. <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
 <li><code>[in] data</code>: Optional data to be passed to the constructor callback as
 the <code>data</code> property of the callback info.</li>
 <li><code>[in] property_count</code>: Number of items in the <code>properties</code> array argument.</li>
@@ -14248,42 +14823,48 @@ See <code>napi_property_descriptor</code>.</li>
 the class.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>Defines a JavaScript class that corresponds to a C++ class, including:</p>
-<ul>
-<li>A JavaScript constructor function that has the class name and invokes the
-provided C++ constructor callback.</li>
-<li>Properties on the constructor function corresponding to <em>static</em> data
-properties, accessors, and methods of the C++ class (defined by
-property descriptors with the <code>napi_static</code> attribute).</li>
-<li>Properties on the constructor function's <code>prototype</code> object corresponding to
-<em>non-static</em> data properties, accessors, and methods of the C++ class
-(defined by property descriptors without the <code>napi_static</code> attribute).</li>
-</ul>
-<p>The C++ constructor callback should be a static method on the class that calls
-the actual class constructor, then wraps the new C++ instance in a JavaScript
-object, and returns the wrapper object. See <code>napi_wrap()</code> for details.</p>
+<p>Defines a JavaScript class, including:</p>
+<ul>
+<li>A JavaScript constructor function that has the class name. When wrapping a
+corresponding C++ class, the callback passed via <code>constructor</code> can be used to
+instantiate a new C++ class instance, which can then be placed inside the
+JavaScript object instance being constructed using <a href="#n_api_napi_wrap"><code>napi_wrap</code></a>.</li>
+<li>Properties on the constructor function whose implementation can call
+corresponding <em>static</em> data properties, accessors, and methods of the C++
+class (defined by property descriptors with the <code>napi_static</code> attribute).</li>
+<li>Properties on the constructor function's <code>prototype</code> object. When wrapping a
+C++ class, <em>non-static</em> data properties, accessors, and methods of the C++
+class can be called from the static functions given in the property
+descriptors without the <code>napi_static</code> attribute after retrieving the C++ class
+instance placed inside the JavaScript object instance by using
+<a href="#n_api_napi_unwrap"><code>napi_unwrap</code></a>.</li>
+</ul>
+<p>When wrapping a C++ class, the C++ constructor callback passed via <code>constructor</code>
+should be a static method on the class that calls the actual class constructor,
+then wraps the new C++ instance in a JavaScript object, and returns the wrapper
+object. See <a href="#n_api_napi_wrap"><code>napi_wrap</code></a> for details.</p>
 <p>The JavaScript constructor function returned from <a href="#n_api_napi_define_class"><code>napi_define_class</code></a> is
-often saved and used later, to construct new instances of the class from native
-code, and/or check whether provided values are instances of the class. In that
-case, to prevent the function value from being garbage-collected, create a
-persistent reference to it using <a href="#n_api_napi_create_reference"><code>napi_create_reference</code></a> and ensure the
-reference count is kept >= 1.</p>
+often saved and used later to construct new instances of the class from native
+code, and/or to check whether provided values are instances of the class. In
+that case, to prevent the function value from being garbage-collected, a
+strong persistent reference to it can be created using
+<a href="#n_api_napi_create_reference"><code>napi_create_reference</code></a>, ensuring that the reference count is kept >= 1.</p>
 <p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> parameter or via
 the <code>data</code> field of the <code>napi_property_descriptor</code> array items can be associated
 with the resulting JavaScript constructor (which is returned in the <code>result</code>
 parameter) and freed whenever the class is garbage-collected by passing both
 the JavaScript function and the data to <a href="#n_api_napi_add_finalizer"><code>napi_add_finalizer</code></a>.</p>
-<h3>napi_wrap<span><a class="mark" href="#n_api_napi_wrap" id="n_api_napi_wrap">#</a></span></h3>
+<h4>napi_wrap<span><a class="mark" href="#n_api_napi_wrap" id="n_api_napi_wrap">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_wrap</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_wrap</span><span class="hljs-params">(napi_env env,
                       napi_value js_object,
-                      <span class="hljs-keyword">void</span>* native_object,
+                      <span class="hljs-type">void</span>* native_object,
                       napi_finalize finalize_cb,
-                      <span class="hljs-keyword">void</span>* finalize_hint,
-                      napi_ref* result)</span></span>;</code></pre>
+                      <span class="hljs-type">void</span>* finalize_hint,
+                      napi_ref* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The JavaScript object that will be the wrapper for the
@@ -14321,14 +14902,14 @@ required in order to enable correct disposal of the reference.</p>
 <p>Calling <code>napi_wrap()</code> a second time on an object will return an error. To
 associate another native instance with the object, use <code>napi_remove_wrap()</code>
 first.</p>
-<h3>napi_unwrap<span><a class="mark" href="#n_api_napi_unwrap" id="n_api_napi_unwrap">#</a></span></h3>
+<h4>napi_unwrap<span><a class="mark" href="#n_api_napi_unwrap" id="n_api_napi_unwrap">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_unwrap</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_unwrap</span><span class="hljs-params">(napi_env env,
                         napi_value js_object,
-                        <span class="hljs-keyword">void</span>** result)</span></span>;</code></pre>
+                        <span class="hljs-type">void</span>** result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The object associated with the native instance.</li>
@@ -14342,14 +14923,14 @@ corresponding <code>napi_callback</code> is invoked. If the callback is for an i
 method or accessor, then the <code>this</code> argument to the callback is the wrapper
 object; the wrapped C++ instance that is the target of the call can be obtained
 then by calling <code>napi_unwrap()</code> on the wrapper object.</p>
-<h3>napi_remove_wrap<span><a class="mark" href="#n_api_napi_remove_wrap" id="n_api_napi_remove_wrap">#</a></span></h3>
+<h4>napi_remove_wrap<span><a class="mark" href="#n_api_napi_remove_wrap" id="n_api_napi_remove_wrap">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_remove_wrap</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_remove_wrap</span><span class="hljs-params">(napi_env env,
                              napi_value js_object,
-                             <span class="hljs-keyword">void</span>** result)</span></span>;</code></pre>
+                             <span class="hljs-type">void</span>** result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The object associated with the native instance.</li>
@@ -14360,14 +14941,14 @@ then by calling <code>napi_unwrap()</code> on the wrapper object.</p>
 object <code>js_object</code> using <code>napi_wrap()</code> and removes the wrapping. If a finalize
 callback was associated with the wrapping, it will no longer be called when the
 JavaScript object becomes garbage-collected.</p>
-<h3>napi_type_tag_object<span><a class="mark" href="#n_api_napi_type_tag_object" id="n_api_napi_type_tag_object">#</a></span></h3>
+<h4>napi_type_tag_object<span><a class="mark" href="#n_api_napi_type_tag_object" id="n_api_napi_type_tag_object">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0, v12.19.0</span>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_type_tag_object</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_type_tag_object</span><span class="hljs-params">(napi_env env,
                                  napi_value js_object,
-                                 <span class="hljs-keyword">const</span> napi_type_tag* type_tag)</span></span>;</code></pre>
+                                 <span class="hljs-keyword">const</span> napi_type_tag* type_tag)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The JavaScript object to be marked.</li>
@@ -14380,15 +14961,15 @@ attached to the object with one owned by the addon to ensure that the object
 has the right type.</p>
 <p>If the object already has an associated type tag, this API will return
 <code>napi_invalid_arg</code>.</p>
-<h3>napi_check_object_type_tag<span><a class="mark" href="#n_api_napi_check_object_type_tag" id="n_api_napi_check_object_type_tag">#</a></span></h3>
+<h4>napi_check_object_type_tag<span><a class="mark" href="#n_api_napi_check_object_type_tag" id="n_api_napi_check_object_type_tag">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0, v12.19.0</span>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_check_object_type_tag</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_check_object_type_tag</span><span class="hljs-params">(napi_env env,
                                        napi_value js_object,
                                        <span class="hljs-keyword">const</span> napi_type_tag* type_tag,
-                                       <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                       <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The JavaScript object whose type tag to examine.</li>
@@ -14401,17 +14982,17 @@ object. <code>false</code> is also returned if no type tag was found on the obje
 <code>js_object</code>. If no tag is found on <code>js_object</code> or, if a tag is found but it does
 not match <code>type_tag</code>, then <code>result</code> is set to <code>false</code>. If a tag is found and it
 matches <code>type_tag</code>, then <code>result</code> is set to <code>true</code>.</p>
-<h3>napi_add_finalizer<span><a class="mark" href="#n_api_napi_add_finalizer" id="n_api_napi_add_finalizer">#</a></span></h3>
+<h4>napi_add_finalizer<span><a class="mark" href="#n_api_napi_add_finalizer" id="n_api_napi_add_finalizer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 5</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_add_finalizer</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_add_finalizer</span><span class="hljs-params">(napi_env env,
                                napi_value js_object,
-                               <span class="hljs-keyword">void</span>* native_object,
+                               <span class="hljs-type">void</span>* native_object,
                                napi_finalize finalize_cb,
-                               <span class="hljs-keyword">void</span>* finalize_hint,
-                               napi_ref* result)</span></span>;</code></pre>
+                               <span class="hljs-type">void</span>* finalize_hint,
+                               napi_ref* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The JavaScript object to which the native data will be
@@ -14441,45 +15022,45 @@ attach each of them to the JavaScript object, and</li>
 invocation. If it is deleted before then, then the finalize callback may never
 be invoked. Therefore, when obtaining a reference a finalize callback is also
 required in order to enable correct disposal of the reference.</p>
-<h2>Simple asynchronous operations<span><a class="mark" href="#n_api_simple_asynchronous_operations" id="n_api_simple_asynchronous_operations">#</a></span></h2>
+</section><section><h3>Simple asynchronous operations<span><a class="mark" href="#n_api_simple_asynchronous_operations" id="n_api_simple_asynchronous_operations">#</a></span></h3>
 <p>Addon modules often need to leverage async helpers from libuv as part of their
 implementation. This allows them to schedule work to be executed asynchronously
 so that their methods can return in advance of the work being completed. This
 allows them to avoid blocking overall execution of the Node.js application.</p>
-<p>N-API provides an ABI-stable interface for these
+<p>Node-API provides an ABI-stable interface for these
 supporting functions which covers the most common asynchronous use cases.</p>
-<p>N-API defines the <code>napi_async_work</code> structure which is used to manage
+<p>Node-API defines the <code>napi_async_work</code> structure which is used to manage
 asynchronous workers. Instances are created/deleted with
 <a href="#n_api_napi_create_async_work"><code>napi_create_async_work</code></a> and <a href="#n_api_napi_delete_async_work"><code>napi_delete_async_work</code></a>.</p>
 <p>The <code>execute</code> and <code>complete</code> callbacks are functions that will be
 invoked when the executor is ready to execute and when it completes its
 task respectively.</p>
-<p>The <code>execute</code> function should avoid making any N-API calls
+<p>The <code>execute</code> function should avoid making any Node-API calls
 that could result in the execution of JavaScript or interaction with
-JavaScript objects. Most often, any code that needs to make N-API
+JavaScript objects. Most often, any code that needs to make Node-API
 calls should be made in <code>complete</code> callback instead.
 Avoid using the <code>napi_env</code> parameter in the execute callback as
 it will likely execute JavaScript.</p>
 <p>These functions implement the following interfaces:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_execute_callback)</span><span class="hljs-params">(napi_env env,
-                                            <span class="hljs-keyword">void</span>* data)</span></span>;
-<span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_complete_callback)</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_execute_callback)</span><span class="hljs-params">(napi_env env,
+                                            <span class="hljs-type">void</span>* data)</span>;
+<span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_complete_callback)</span><span class="hljs-params">(napi_env env,
                                              napi_status status,
-                                             <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
+                                             <span class="hljs-type">void</span>* data)</span>;</code></pre>
 <p>When these methods are invoked, the <code>data</code> parameter passed will be the
 addon-provided <code>void*</code> data that was passed into the
 <code>napi_create_async_work</code> call.</p>
 <p>Once created the async worker can be queued
 for execution using the <a href="#n_api_napi_queue_async_work"><code>napi_queue_async_work</code></a> function:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_queue_async_work</span><span class="hljs-params">(napi_env env,
-                                  napi_async_work work)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_queue_async_work</span><span class="hljs-params">(napi_env env,
+                                  napi_async_work work)</span>;</code></pre>
 <p><a href="#n_api_napi_cancel_async_work"><code>napi_cancel_async_work</code></a> can be used if the work needs
 to be cancelled before the work has started execution.</p>
 <p>After calling <a href="#n_api_napi_cancel_async_work"><code>napi_cancel_async_work</code></a>, the <code>complete</code> callback
 will be invoked with a status value of <code>napi_cancelled</code>.
 The work should not be deleted before the <code>complete</code>
 callback invocation, even when it was cancelled.</p>
-<h3>napi_create_async_work<span><a class="mark" href="#n_api_napi_create_async_work" id="n_api_napi_create_async_work">#</a></span></h3>
+<h4>napi_create_async_work<span><a class="mark" href="#n_api_napi_create_async_work" id="n_api_napi_create_async_work">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -14492,13 +15073,13 @@ callback invocation, even when it was cancelled.</p>
 </details>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_async_work</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_async_work</span><span class="hljs-params">(napi_env env,
                                    napi_value async_resource,
                                    napi_value async_resource_name,
                                    napi_async_execute_callback execute,
                                    napi_async_complete_callback complete,
-                                   <span class="hljs-keyword">void</span>* data,
-                                   napi_async_work* result)</span></span>;</code></pre>
+                                   <span class="hljs-type">void</span>* data,
+                                   napi_async_work* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] async_resource</code>: An optional object associated with the async work
@@ -14526,13 +15107,13 @@ required.</p>
 representative of the type of async work being performed. It is also recommended
 to apply namespacing to the identifier, e.g. by including the module name. See
 the <a href="#async_hooks_type"><code>async_hooks</code> documentation</a> for more information.</p>
-<h3>napi_delete_async_work<span><a class="mark" href="#n_api_napi_delete_async_work" id="n_api_napi_delete_async_work">#</a></span></h3>
+<h4>napi_delete_async_work<span><a class="mark" href="#n_api_napi_delete_async_work" id="n_api_napi_delete_async_work">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_delete_async_work</span><span class="hljs-params">(napi_env env,
-                                   napi_async_work work)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_delete_async_work</span><span class="hljs-params">(napi_env env,
+                                   napi_async_work work)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] work</code>: The handle returned by the call to <code>napi_create_async_work</code>.</li>
@@ -14540,13 +15121,13 @@ the <a href="#async_hooks_type"><code>async_hooks</code> documentation</a> for m
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API frees a previously allocated work object.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h3>napi_queue_async_work<span><a class="mark" href="#n_api_napi_queue_async_work" id="n_api_napi_queue_async_work">#</a></span></h3>
+<h4>napi_queue_async_work<span><a class="mark" href="#n_api_napi_queue_async_work" id="n_api_napi_queue_async_work">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_queue_async_work</span><span class="hljs-params">(napi_env env,
-                                  napi_async_work work)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_queue_async_work</span><span class="hljs-params">(napi_env env,
+                                  napi_async_work work)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] work</code>: The handle returned by the call to <code>napi_create_async_work</code>.</li>
@@ -14555,13 +15136,13 @@ the <a href="#async_hooks_type"><code>async_hooks</code> documentation</a> for m
 <p>This API requests that the previously allocated work be scheduled
 for execution. Once it returns successfully, this API must not be called again
 with the same <code>napi_async_work</code> item or the result will be undefined.</p>
-<h3>napi_cancel_async_work<span><a class="mark" href="#n_api_napi_cancel_async_work" id="n_api_napi_cancel_async_work">#</a></span></h3>
+<h4>napi_cancel_async_work<span><a class="mark" href="#n_api_napi_cancel_async_work" id="n_api_napi_cancel_async_work">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_cancel_async_work</span><span class="hljs-params">(napi_env env,
-                                   napi_async_work work)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_cancel_async_work</span><span class="hljs-params">(napi_env env,
+                                   napi_async_work work)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] work</code>: The handle returned by the call to <code>napi_create_async_work</code>.</li>
@@ -14574,49 +15155,59 @@ the <code>complete</code> callback will be invoked with a status value of
 <code>napi_cancelled</code>. The work should not be deleted before the <code>complete</code>
 callback invocation, even if it has been successfully cancelled.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h2>Custom asynchronous operations<span><a class="mark" href="#n_api_custom_asynchronous_operations" id="n_api_custom_asynchronous_operations">#</a></span></h2>
+</section><section><h3>Custom asynchronous operations<span><a class="mark" href="#n_api_custom_asynchronous_operations" id="n_api_custom_asynchronous_operations">#</a></span></h3>
 <p>The simple asynchronous work APIs above may not be appropriate for every
 scenario. When using any other asynchronous mechanism, the following APIs
 are necessary to ensure an asynchronous operation is properly tracked by
 the runtime.</p>
-<h3>napi_async_init<span><a class="mark" href="#n_api_napi_async_init" id="n_api_napi_async_init">#</a></span></h3>
+<h4>napi_async_init<span><a class="mark" href="#n_api_napi_async_init" id="n_api_napi_async_init">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.6.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_async_init</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_async_init</span><span class="hljs-params">(napi_env env,
                             napi_value async_resource,
                             napi_value async_resource_name,
-                            napi_async_context* result)</span></span></code></pre>
+                            napi_async_context* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] async_resource</code>: Object associated with the async work
-that will be passed to possible <code>async_hooks</code> <a href="#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a>.
-In order to retain ABI compatibility with previous versions,
-passing <code>NULL</code> for <code>async_resource</code> will not result in an error, however,
-this will result incorrect operation of async hooks for the
-napi_async_context created. Potential issues include
-loss of async context when using the AsyncLocalStorage API.</li>
-<li><code>[in] async_resource_name</code>: Identifier for the kind of resource
-that is being provided for diagnostic information exposed by the
-<code>async_hooks</code> API.</li>
+that will be passed to possible <code>async_hooks</code> <a href="#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a> and can be
+accessed by <a href="#async_hooks_async_hooks_executionasyncresource"><code>async_hooks.executionAsyncResource()</code></a>.</li>
+<li><code>[in] async_resource_name</code>: Identifier for the kind of resource that is being
+provided for diagnostic information exposed by the <code>async_hooks</code> API.</li>
 <li><code>[out] result</code>: The initialized async context.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<h3>napi_async_destroy<span><a class="mark" href="#n_api_napi_async_destroy" id="n_api_napi_async_destroy">#</a></span></h3>
+<p>The <code>async_resource</code> object needs to be kept alive until
+<a href="#n_api_napi_async_destroy"><code>napi_async_destroy</code></a> to keep <code>async_hooks</code> related API acts correctly. In
+order to retain ABI compatibility with previous versions, <code>napi_async_context</code>s
+are not maintaining the strong reference to the <code>async_resource</code> objects to
+avoid introducing causing memory leaks. However, if the <code>async_resource</code> is
+garbage collected by JavaScript engine before the <code>napi_async_context</code> was
+destroyed by <code>napi_async_destroy</code>, calling <code>napi_async_context</code> related APIs
+like <a href="#n_api_napi_open_callback_scope"><code>napi_open_callback_scope</code></a> and <a href="#n_api_napi_make_callback"><code>napi_make_callback</code></a> can cause
+problems like loss of async context when using the <code>AsyncLocalStoage</code> API.</p>
+<p>In order to retain ABI compatibility with previous versions, passing <code>NULL</code>
+for <code>async_resource</code> does not result in an error. However, this is not
+recommended as this will result poor results with  <code>async_hooks</code>
+<a href="#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a> and <code>async_hooks.executionAsyncResource()</code> as the resource is
+now required by the underlying <code>async_hooks</code> implementation in order to provide
+the linkage between async callbacks.</p>
+<h4>napi_async_destroy<span><a class="mark" href="#n_api_napi_async_destroy" id="n_api_napi_async_destroy">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.6.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_async_destroy</span><span class="hljs-params">(napi_env env,
-                               napi_async_context async_context)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_async_destroy</span><span class="hljs-params">(napi_env env,
+                               napi_async_context async_context)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] async_context</code>: The async context to be destroyed.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h3>napi_make_callback<span><a class="mark" href="#n_api_napi_make_callback" id="n_api_napi_make_callback">#</a></span></h3>
+<h4>napi_make_callback<span><a class="mark" href="#n_api_napi_make_callback" id="n_api_napi_make_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -14629,21 +15220,23 @@ that is being provided for diagnostic information exposed by the
 </details>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_make_callback</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_make_callback</span><span class="hljs-params">(napi_env env,
                                            napi_async_context async_context,
                                            napi_value recv,
                                            napi_value func,
-                                           <span class="hljs-keyword">size_t</span> argc,
+                                           <span class="hljs-type">size_t</span> argc,
                                            <span class="hljs-keyword">const</span> napi_value* argv,
-                                           napi_value* result)</span></span>;</code></pre>
+                                           napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] async_context</code>: Context for the async operation that is
 invoking the callback. This should normally be a value previously
-obtained from <a href="#n_api_napi_async_init"><code>napi_async_init</code></a>. However <code>NULL</code> is also allowed,
-which indicates the current async context (if any) is to be used
-for the callback.</li>
-<li><code>[in] recv</code>: The <code>this</code> object passed to the called function.</li>
+obtained from <a href="#n_api_napi_async_init"><code>napi_async_init</code></a>.
+In order to retain ABI compatibility with previous versions, passing <code>NULL</code>
+for <code>async_context</code> does not result in an error. However, this results
+in incorrect operation of async hooks. Potential issues include loss of
+async context when using the <code>AsyncLocalStorage</code> API.</li>
+<li><code>[in] recv</code>: The <code>this</code> value passed to the called function.</li>
 <li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>
 <li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>
 <li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the
@@ -14664,56 +15257,58 @@ may be required when implementing custom async behavior that does not use
 <code>napi_create_async_work</code>.</p>
 <p>Any <code>process.nextTick</code>s or Promises scheduled on the microtask queue by
 JavaScript during the callback are ran before returning back to C/C++.</p>
-<h3>napi_open_callback_scope<span><a class="mark" href="#n_api_napi_open_callback_scope" id="n_api_napi_open_callback_scope">#</a></span></h3>
+<h4>napi_open_callback_scope<span><a class="mark" href="#n_api_napi_open_callback_scope" id="n_api_napi_open_callback_scope">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_open_callback_scope</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_open_callback_scope</span><span class="hljs-params">(napi_env env,
                                                  napi_value resource_object,
                                                  napi_async_context context,
-                                                 napi_callback_scope* result)</span></span></code></pre>
+                                                 napi_callback_scope* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] resource_object</code>: An object associated with the async work
-that will be passed to possible <code>async_hooks</code> <a href="#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a>.</li>
+that will be passed to possible <code>async_hooks</code> <a href="#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a>. This
+parameter has been deprecated and is ignored at runtime. Use the
+<code>async_resource</code> parameter in <a href="#n_api_napi_async_init"><code>napi_async_init</code></a> instead.</li>
 <li><code>[in] context</code>: Context for the async operation that is invoking the callback.
 This should be a value previously obtained from <a href="#n_api_napi_async_init"><code>napi_async_init</code></a>.</li>
 <li><code>[out] result</code>: The newly created scope.</li>
 </ul>
 <p>There are cases (for example, resolving promises) where it is
 necessary to have the equivalent of the scope associated with a callback
-in place when making certain N-API calls. If there is no other script on
+in place when making certain Node-API calls. If there is no other script on
 the stack the <a href="#n_api_napi_open_callback_scope"><code>napi_open_callback_scope</code></a> and
 <a href="#n_api_napi_close_callback_scope"><code>napi_close_callback_scope</code></a> functions can be used to open/close
 the required scope.</p>
-<h3>napi_close_callback_scope<span><a class="mark" href="#n_api_napi_close_callback_scope" id="n_api_napi_close_callback_scope">#</a></span></h3>
+<h4>napi_close_callback_scope<span><a class="mark" href="#n_api_napi_close_callback_scope" id="n_api_napi_close_callback_scope">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_close_callback_scope</span><span class="hljs-params">(napi_env env,
-                                                  napi_callback_scope scope)</span></span></code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_close_callback_scope</span><span class="hljs-params">(napi_env env,
+                                                  napi_callback_scope scope)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] scope</code>: The scope to be closed.</li>
 </ul>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h2>Version management<span><a class="mark" href="#n_api_version_management" id="n_api_version_management">#</a></span></h2>
-<h3>napi_get_node_version<span><a class="mark" href="#n_api_napi_get_node_version" id="n_api_napi_get_node_version">#</a></span></h3>
+</section><section><h3>Version management<span><a class="mark" href="#n_api_version_management" id="n_api_version_management">#</a></span></h3>
+<h4>napi_get_node_version<span><a class="mark" href="#n_api_napi_get_node_version" id="n_api_napi_get_node_version">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> {</span>
-  <span class="hljs-keyword">uint32_t</span> major;
-  <span class="hljs-keyword">uint32_t</span> minor;
-  <span class="hljs-keyword">uint32_t</span> patch;
-  <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* release;
+  <span class="hljs-type">uint32_t</span> major;
+  <span class="hljs-type">uint32_t</span> minor;
+  <span class="hljs-type">uint32_t</span> patch;
+  <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* release;
 } napi_node_version;
 
-<span class="hljs-function">napi_status <span class="hljs-title">napi_get_node_version</span><span class="hljs-params">(napi_env env,
-                                  <span class="hljs-keyword">const</span> napi_node_version** version)</span></span>;</code></pre>
+napi_status <span class="hljs-title function_">napi_get_node_version</span><span class="hljs-params">(napi_env env,
+                                  <span class="hljs-keyword">const</span> napi_node_version** version)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] version</code>: A pointer to version information for Node.js itself.</li>
@@ -14723,20 +15318,20 @@ the required scope.</p>
 version of Node.js that is currently running, and the <code>release</code> field with the
 value of <a href="#process_process_release"><code>process.release.name</code></a>.</p>
 <p>The returned buffer is statically allocated and does not need to be freed.</p>
-<h3>napi_get_version<span><a class="mark" href="#n_api_napi_get_version" id="n_api_napi_get_version">#</a></span></h3>
+<h4>napi_get_version<span><a class="mark" href="#n_api_napi_get_version" id="n_api_napi_get_version">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_version</span><span class="hljs-params">(napi_env env,
-                             <span class="hljs-keyword">uint32_t</span>* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_version</span><span class="hljs-params">(napi_env env,
+                             <span class="hljs-type">uint32_t</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[out] result</code>: The highest version of N-API supported.</li>
+<li><code>[out] result</code>: The highest version of Node-API supported.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns the highest N-API version supported by the
-Node.js runtime. N-API is planned to be additive such that
+<p>This API returns the highest Node-API version supported by the
+Node.js runtime. Node-API is planned to be additive such that
 newer releases of Node.js may support additional API functions.
 In order to allow an addon to use a newer function when running with
 versions of Node.js that support it, while providing
@@ -14749,15 +15344,15 @@ support it:</p>
 <li>If the function is not available, provide an alternate implementation
 that does not use the function.</li>
 </ul>
-<h2>Memory management<span><a class="mark" href="#n_api_memory_management" id="n_api_memory_management">#</a></span></h2>
-<h3>napi_adjust_external_memory<span><a class="mark" href="#n_api_napi_adjust_external_memory" id="n_api_napi_adjust_external_memory">#</a></span></h3>
+</section><section><h3>Memory management<span><a class="mark" href="#n_api_memory_management" id="n_api_memory_management">#</a></span></h3>
+<h4>napi_adjust_external_memory<span><a class="mark" href="#n_api_napi_adjust_external_memory" id="n_api_napi_adjust_external_memory">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_adjust_external_memory</span><span class="hljs-params">(napi_env env,
-                                                    <span class="hljs-keyword">int64_t</span> change_in_bytes,
-                                                    <span class="hljs-keyword">int64_t</span>* result)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_adjust_external_memory</span><span class="hljs-params">(napi_env env,
+                                                    <span class="hljs-type">int64_t</span> change_in_bytes,
+                                                    <span class="hljs-type">int64_t</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] change_in_bytes</code>: The change in externally allocated memory that is kept
@@ -14770,8 +15365,8 @@ memory that is kept alive by JavaScript objects (i.e. a JavaScript object
 that points to its own memory allocated by a native module). Registering
 externally allocated memory will trigger global garbage collections more
 often than it would otherwise.</p>
-<h2>Promises<span><a class="mark" href="#n_api_promises" id="n_api_promises">#</a></span></h2>
-<p>N-API provides facilities for creating <code>Promise</code> objects as described in
+</section><section><h3>Promises<span><a class="mark" href="#n_api_promises" id="n_api_promises">#</a></span></h3>
+<p>Node-API provides facilities for creating <code>Promise</code> objects as described in
 <a href="https://tc39.github.io/ecma262/#sec-promise-objects">Section 25.4</a> of the ECMA specification. It implements promises as a pair of
 objects. When a promise is created by <code>napi_create_promise()</code>, a "deferred"
 object is created and returned alongside the <code>Promise</code>. The deferred object is
@@ -14816,14 +15411,14 @@ status = napi_get_undefined(env, &#x26;undefined);
 
 <span class="hljs-comment">// At this point the deferred has been freed, so we should assign NULL to it.</span>
 deferred = <span class="hljs-literal">NULL</span>;</code></pre>
-<h3>napi_create_promise<span><a class="mark" href="#n_api_napi_create_promise" id="n_api_napi_create_promise">#</a></span></h3>
+<h4>napi_create_promise<span><a class="mark" href="#n_api_napi_create_promise" id="n_api_napi_create_promise">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_promise</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_promise</span><span class="hljs-params">(napi_env env,
                                 napi_deferred* deferred,
-                                napi_value* promise)</span></span>;</code></pre>
+                                napi_value* promise)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] deferred</code>: A newly created deferred object which can later be passed to
@@ -14833,14 +15428,14 @@ the associated promise.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API creates a deferred object and a JavaScript promise.</p>
-<h3>napi_resolve_deferred<span><a class="mark" href="#n_api_napi_resolve_deferred" id="n_api_napi_resolve_deferred">#</a></span></h3>
+<h4>napi_resolve_deferred<span><a class="mark" href="#n_api_napi_resolve_deferred" id="n_api_napi_resolve_deferred">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_resolve_deferred</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_resolve_deferred</span><span class="hljs-params">(napi_env env,
                                   napi_deferred deferred,
-                                  napi_value resolution)</span></span>;</code></pre>
+                                  napi_value resolution)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] deferred</code>: The deferred object whose associated promise to resolve.</li>
@@ -14853,14 +15448,14 @@ effectively means that the promise must have been created using
 <code>napi_create_promise()</code> and the deferred object returned from that call must
 have been retained in order to be passed to this API.</p>
 <p>The deferred object is freed upon successful completion.</p>
-<h3>napi_reject_deferred<span><a class="mark" href="#n_api_napi_reject_deferred" id="n_api_napi_reject_deferred">#</a></span></h3>
+<h4>napi_reject_deferred<span><a class="mark" href="#n_api_napi_reject_deferred" id="n_api_napi_reject_deferred">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_reject_deferred</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_reject_deferred</span><span class="hljs-params">(napi_env env,
                                  napi_deferred deferred,
-                                 napi_value rejection)</span></span>;</code></pre>
+                                 napi_value rejection)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] deferred</code>: The deferred object whose associated promise to resolve.</li>
@@ -14873,31 +15468,31 @@ effectively means that the promise must have been created using
 <code>napi_create_promise()</code> and the deferred object returned from that call must
 have been retained in order to be passed to this API.</p>
 <p>The deferred object is freed upon successful completion.</p>
-<h3>napi_is_promise<span><a class="mark" href="#n_api_napi_is_promise" id="n_api_napi_is_promise">#</a></span></h3>
+<h4>napi_is_promise<span><a class="mark" href="#n_api_napi_is_promise" id="n_api_napi_is_promise">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_promise</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_promise</span><span class="hljs-params">(napi_env env,
                             napi_value value,
-                            <span class="hljs-keyword">bool</span>* is_promise)</span></span>;</code></pre>
+                            <span class="hljs-type">bool</span>* is_promise)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The value to examine</li>
 <li><code>[out] is_promise</code>: Flag indicating whether <code>promise</code> is a native promise
 object (that is, a promise object created by the underlying engine).</li>
 </ul>
-<h2>Script execution<span><a class="mark" href="#n_api_script_execution" id="n_api_script_execution">#</a></span></h2>
-<p>N-API provides an API for executing a string containing JavaScript using the
+</section><section><h3>Script execution<span><a class="mark" href="#n_api_script_execution" id="n_api_script_execution">#</a></span></h3>
+<p>Node-API provides an API for executing a string containing JavaScript using the
 underlying JavaScript engine.</p>
-<h3>napi_run_script<span><a class="mark" href="#n_api_napi_run_script" id="n_api_napi_run_script">#</a></span></h3>
+<h4>napi_run_script<span><a class="mark" href="#n_api_napi_run_script" id="n_api_napi_run_script">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_run_script</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_run_script</span><span class="hljs-params">(napi_env env,
                                         napi_value script,
-                                        napi_value* result)</span></span>;</code></pre>
+                                        napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] script</code>: A JavaScript string containing the script to execute.</li>
@@ -14916,23 +15511,23 @@ made using <code>let</code> and <code>const</code> will be visible globally, but
 to the <a href="#globals_global"><code>global</code></a> object.</li>
 <li>The value of <code>this</code> is <a href="#globals_global"><code>global</code></a> within the script.</li>
 </ul>
-<h2>libuv event loop<span><a class="mark" href="#n_api_libuv_event_loop" id="n_api_libuv_event_loop">#</a></span></h2>
-<p>N-API provides a function for getting the current event loop associated with
+</section><section><h3>libuv event loop<span><a class="mark" href="#n_api_libuv_event_loop" id="n_api_libuv_event_loop">#</a></span></h3>
+<p>Node-API provides a function for getting the current event loop associated with
 a specific <code>napi_env</code>.</p>
-<h3>napi_get_uv_event_loop<span><a class="mark" href="#n_api_napi_get_uv_event_loop" id="n_api_napi_get_uv_event_loop">#</a></span></h3>
+<h4>napi_get_uv_event_loop<span><a class="mark" href="#n_api_napi_get_uv_event_loop" id="n_api_napi_get_uv_event_loop">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v8.10.0, v9.3.0</span>
+<span>Added in: v9.3.0, v8.10.0</span>
 <span>N-API version: 2</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_get_uv_event_loop</span><span class="hljs-params">(napi_env env,
-                                               struct uv_loop_s** loop)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_get_uv_event_loop</span><span class="hljs-params">(napi_env env,
+                                               <span class="hljs-keyword">struct</span> uv_loop_s** loop)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] loop</code>: The current libuv loop instance.</li>
 </ul>
-<h2>Asynchronous thread-safe function calls<span><a class="mark" href="#n_api_asynchronous_thread_safe_function_calls" id="n_api_asynchronous_thread_safe_function_calls">#</a></span></h2>
+</section><section><h3>Asynchronous thread-safe function calls<span><a class="mark" href="#n_api_asynchronous_thread_safe_function_calls" id="n_api_asynchronous_thread_safe_function_calls">#</a></span></h3>
 <p>JavaScript functions can normally only be called from a native addon's main
-thread. If an addon creates additional threads, then N-API functions that
+thread. If an addon creates additional threads, then Node-API functions that
 require a <code>napi_env</code>, <code>napi_value</code>, or <code>napi_ref</code> must not be called from those
 threads.</p>
 <p>When an addon has additional threads and JavaScript functions need to be invoked
@@ -14957,7 +15552,7 @@ completes.</strong></p>
 <p>The <code>context</code> given during the call to <code>napi_create_threadsafe_function()</code> can
 be retrieved from any thread with a call to
 <code>napi_get_threadsafe_function_context()</code>.</p>
-<h3>Calling a thread-safe function<span><a class="mark" href="#n_api_calling_a_thread_safe_function" id="n_api_calling_a_thread_safe_function">#</a></span></h3>
+<h4>Calling a thread-safe function<span><a class="mark" href="#n_api_calling_a_thread_safe_function" id="n_api_calling_a_thread_safe_function">#</a></span></h4>
 <p><code>napi_call_threadsafe_function()</code> can be used for initiating a call into
 JavaScript. <code>napi_call_threadsafe_function()</code> accepts a parameter which controls
 whether the API behaves blockingly. If set to <code>napi_tsfn_nonblocking</code>, the API
@@ -14966,6 +15561,9 @@ preventing data from being successfully added to the queue. If set to
 <code>napi_tsfn_blocking</code>, the API blocks until space becomes available in the queue.
 <code>napi_call_threadsafe_function()</code> never blocks if the thread-safe function was
 created with a maximum queue size of 0.</p>
+<p><code>napi_call_threadsafe_function()</code> should not be called with <code>napi_tsfn_blocking</code>
+from a JavaScript thread, because, if the queue is full, it may cause the
+JavaScript thread to deadlock.</p>
 <p>The actual call into JavaScript is controlled by the callback given via the
 <code>call_js_cb</code> parameter. <code>call_js_cb</code> is invoked on the main thread once for each
 value that was placed into the queue by a successful call to
@@ -14981,8 +15579,8 @@ to indicate that calls into JavaScript are no longer possible, while items
 remain in the queue that may need to be freed. This normally occurs when the
 Node.js process exits while there is a thread-safe function still active.</p>
 <p>It is not necessary to call into JavaScript via <code>napi_make_callback()</code> because
-N-API runs <code>call_js_cb</code> in a context appropriate for callbacks.</p>
-<h3>Reference counting of thread-safe functions<span><a class="mark" href="#n_api_reference_counting_of_thread_safe_functions" id="n_api_reference_counting_of_thread_safe_functions">#</a></span></h3>
+Node-API runs <code>call_js_cb</code> in a context appropriate for callbacks.</p>
+<h4>Reference counting of thread-safe functions<span><a class="mark" href="#n_api_reference_counting_of_thread_safe_functions" id="n_api_reference_counting_of_thread_safe_functions">#</a></span></h4>
 <p>Threads can be added to and removed from a <code>napi_threadsafe_function</code> object
 during its existence. Thus, in addition to specifying an initial number of
 threads upon creation, <code>napi_acquire_threadsafe_function</code> can be called to
@@ -15021,7 +15619,7 @@ used as a criterion for terminating the thread. <strong>Upon receiving a return
 of <code>napi_closing</code> from <code>napi_call_threadsafe_function()</code> a thread must not use
 the thread-safe function anymore because it is no longer guaranteed to
 be allocated.</strong></p>
-<h3>Deciding whether to keep the process running<span><a class="mark" href="#n_api_deciding_whether_to_keep_the_process_running" id="n_api_deciding_whether_to_keep_the_process_running">#</a></span></h3>
+<h4>Deciding whether to keep the process running<span><a class="mark" href="#n_api_deciding_whether_to_keep_the_process_running" id="n_api_deciding_whether_to_keep_the_process_running">#</a></span></h4>
 <p>Similarly to libuv handles, thread-safe functions can be "referenced" and
 "unreferenced". A "referenced" thread-safe function will cause the event loop on
 the thread on which it is created to remain alive until the thread-safe function
@@ -15031,12 +15629,12 @@ prevent the event loop from exiting. The APIs <code>napi_ref_threadsafe_function
 <p>Neither does <code>napi_unref_threadsafe_function</code> mark the thread-safe functions as
 able to be destroyed nor does <code>napi_ref_threadsafe_function</code> prevent it from
 being destroyed.</p>
-<h3>napi_create_threadsafe_function<span><a class="mark" href="#n_api_napi_create_threadsafe_function" id="n_api_napi_create_threadsafe_function">#</a></span></h3>
+<h4>napi_create_threadsafe_function<span><a class="mark" href="#n_api_napi_create_threadsafe_function" id="n_api_napi_create_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.6.0</td>
+<tr><td>v12.6.0, v10.17.0</td>
 <td><p>Made <code>func</code> parameter optional with custom <code>call_js_cb</code>.</p></td></tr>
 <tr><td>v10.6.0</td>
 <td><p><span>Added in: v10.6.0</span></p></td></tr>
@@ -15044,18 +15642,18 @@ being destroyed.</p>
 </details>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_create_threadsafe_function</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_create_threadsafe_function</span><span class="hljs-params">(napi_env env,
                                 napi_value func,
                                 napi_value async_resource,
                                 napi_value async_resource_name,
-                                <span class="hljs-keyword">size_t</span> max_queue_size,
-                                <span class="hljs-keyword">size_t</span> initial_thread_count,
-                                <span class="hljs-keyword">void</span>* thread_finalize_data,
+                                <span class="hljs-type">size_t</span> max_queue_size,
+                                <span class="hljs-type">size_t</span> initial_thread_count,
+                                <span class="hljs-type">void</span>* thread_finalize_data,
                                 napi_finalize thread_finalize_cb,
-                                <span class="hljs-keyword">void</span>* context,
+                                <span class="hljs-type">void</span>* context,
                                 napi_threadsafe_function_call_js call_js_cb,
-                                napi_threadsafe_function* result)</span></span>;</code></pre>
+                                napi_threadsafe_function* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] func</code>: An optional JavaScript function to call from another thread. It
@@ -15081,28 +15679,38 @@ parameters and with <code>undefined</code> as its <code>this</code> value.
 <a href="#n_api_napi_threadsafe_function_call_js"><code>napi_threadsafe_function_call_js</code></a> provides more details.</li>
 <li><code>[out] result</code>: The asynchronous thread-safe JavaScript function.</li>
 </ul>
-<h3>napi_get_threadsafe_function_context<span><a class="mark" href="#n_api_napi_get_threadsafe_function_context" id="n_api_napi_get_threadsafe_function_context">#</a></span></h3>
+<h4>napi_get_threadsafe_function_context<span><a class="mark" href="#n_api_napi_get_threadsafe_function_context" id="n_api_napi_get_threadsafe_function_context">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_get_threadsafe_function_context</span><span class="hljs-params">(napi_threadsafe_function func,
-                                     <span class="hljs-keyword">void</span>** result)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_get_threadsafe_function_context</span><span class="hljs-params">(napi_threadsafe_function func,
+                                     <span class="hljs-type">void</span>** result)</span>;</code></pre>
 <ul>
 <li><code>[in] func</code>: The thread-safe function for which to retrieve the context.</li>
 <li><code>[out] result</code>: The location where to store the context.</li>
 </ul>
 <p>This API may be called from any thread which makes use of <code>func</code>.</p>
-<h3>napi_call_threadsafe_function<span><a class="mark" href="#n_api_napi_call_threadsafe_function" id="n_api_napi_call_threadsafe_function">#</a></span></h3>
+<h4>napi_call_threadsafe_function<span><a class="mark" href="#n_api_napi_call_threadsafe_function" id="n_api_napi_call_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.6.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.5.0</td>
+<td><p>Support for <code>napi_would_deadlock</code> has been reverted.</p></td></tr>
+<tr><td>v14.1.0</td>
+<td><p>Return <code>napi_would_deadlock</code> when called with <code>napi_tsfn_blocking</code> from the main thread or a worker thread and the queue is full.</p></td></tr>
+<tr><td>v10.6.0</td>
+<td><p><span>Added in: v10.6.0</span></p></td></tr>
+</tbody></table>
+</details>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_call_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func,
-                              <span class="hljs-keyword">void</span>* data,
-                              napi_threadsafe_function_call_mode is_blocking)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_call_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func,
+                              <span class="hljs-type">void</span>* data,
+                              napi_threadsafe_function_call_mode is_blocking)</span>;</code></pre>
 <ul>
 <li><code>[in] func</code>: The asynchronous thread-safe JavaScript function to invoke.</li>
 <li><code>[in] data</code>: Data to send into JavaScript via the callback <code>call_js_cb</code>
@@ -15112,17 +15720,20 @@ indicate that the call should block if the queue is full or
 <code>napi_tsfn_nonblocking</code> to indicate that the call should return immediately
 with a status of <code>napi_queue_full</code> whenever the queue is full.</li>
 </ul>
+<p>This API should not be called with <code>napi_tsfn_blocking</code> from a JavaScript
+thread, because, if the queue is full, it may cause the JavaScript thread to
+deadlock.</p>
 <p>This API will return <code>napi_closing</code> if <code>napi_release_threadsafe_function()</code> was
 called with <code>abort</code> set to <code>napi_tsfn_abort</code> from any thread. The value is only
 added to the queue if the API returns <code>napi_ok</code>.</p>
 <p>This API may be called from any thread which makes use of <code>func</code>.</p>
-<h3>napi_acquire_threadsafe_function<span><a class="mark" href="#n_api_napi_acquire_threadsafe_function" id="n_api_napi_acquire_threadsafe_function">#</a></span></h3>
+<h4>napi_acquire_threadsafe_function<span><a class="mark" href="#n_api_napi_acquire_threadsafe_function" id="n_api_napi_acquire_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_acquire_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_acquire_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func)</span>;</code></pre>
 <ul>
 <li><code>[in] func</code>: The asynchronous thread-safe JavaScript function to start making
 use of.</li>
@@ -15132,14 +15743,14 @@ function APIs to indicate that it will be making use of <code>func</code>. This
 <code>func</code> from being destroyed when all other threads have stopped making use of
 it.</p>
 <p>This API may be called from any thread which will start making use of <code>func</code>.</p>
-<h3>napi_release_threadsafe_function<span><a class="mark" href="#n_api_napi_release_threadsafe_function" id="n_api_napi_release_threadsafe_function">#</a></span></h3>
+<h4>napi_release_threadsafe_function<span><a class="mark" href="#n_api_napi_release_threadsafe_function" id="n_api_napi_release_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_release_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func,
-                                 napi_threadsafe_function_release_mode mode)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_release_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func,
+                                 napi_threadsafe_function_release_mode mode)</span>;</code></pre>
 <ul>
 <li><code>[in] func</code>: The asynchronous thread-safe JavaScript function whose reference
 count to decrement.</li>
@@ -15155,13 +15766,13 @@ values will be placed in the queue.</li>
 to any thread-safe APIs after having called this API has undefined results, as
 <code>func</code> may have been destroyed.</p>
 <p>This API may be called from any thread which will stop making use of <code>func</code>.</p>
-<h3>napi_ref_threadsafe_function<span><a class="mark" href="#n_api_napi_ref_threadsafe_function" id="n_api_napi_ref_threadsafe_function">#</a></span></h3>
+<h4>napi_ref_threadsafe_function<span><a class="mark" href="#n_api_napi_ref_threadsafe_function" id="n_api_napi_ref_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_ref_threadsafe_function</span><span class="hljs-params">(napi_env env, napi_threadsafe_function func)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_ref_threadsafe_function</span><span class="hljs-params">(napi_env env, napi_threadsafe_function func)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] func</code>: The thread-safe function to reference.</li>
@@ -15174,13 +15785,13 @@ able to be destroyed nor does <code>napi_ref_threadsafe_function</code> prevent
 being destroyed. <code>napi_acquire_threadsafe_function</code> and
 <code>napi_release_threadsafe_function</code> are available for that purpose.</p>
 <p>This API may only be called from the main thread.</p>
-<h3>napi_unref_threadsafe_function<span><a class="mark" href="#n_api_napi_unref_threadsafe_function" id="n_api_napi_unref_threadsafe_function">#</a></span></h3>
+<h4>napi_unref_threadsafe_function<span><a class="mark" href="#n_api_napi_unref_threadsafe_function" id="n_api_napi_unref_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_unref_threadsafe_function</span><span class="hljs-params">(napi_env env, napi_threadsafe_function func)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_unref_threadsafe_function</span><span class="hljs-params">(napi_env env, napi_threadsafe_function func)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] func</code>: The thread-safe function to unreference.</li>
@@ -15189,14 +15800,14 @@ being destroyed. <code>napi_acquire_threadsafe_function</code> and
 may exit before <code>func</code> is destroyed. Similar to <a href="https://docs.libuv.org/en/v1.x/handle.html#c.uv_unref"><code>uv_unref</code></a> it is also
 idempotent.</p>
 <p>This API may only be called from the main thread.</p>
-<h2>Miscellaneous utilities<span><a class="mark" href="#n_api_miscellaneous_utilities" id="n_api_miscellaneous_utilities">#</a></span></h2>
-<h2>node_api_get_module_file_name<span><a class="mark" href="#n_api_node_api_get_module_file_name" id="n_api_node_api_get_module_file_name">#</a></span></h2>
+</section><section><h3>Miscellaneous utilities<span><a class="mark" href="#n_api_miscellaneous_utilities" id="n_api_miscellaneous_utilities">#</a></span></h3>
+</section><section><h3>node_api_get_module_file_name<span><a class="mark" href="#n_api_node_api_get_module_file_name" id="n_api_node_api_get_module_file_name">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.22.0</span>
+<span>Added in: v14.18.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">node_api_get_module_file_name</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>** result)</span></span>;
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">node_api_get_module_file_name</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>** result)</span>;
 </code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
@@ -15206,25 +15817,26 @@ file system it will start with <code>file://</code>. The string is null-terminat
 owned by <code>env</code> and must thus not be modified or freed.</li>
 </ul>
 <p><code>result</code> may be an empty string if the add-on loading process fails to establish
-the add-on's file name during loading.</p>
-<h1>C++ Embedder API<span><a class="mark" href="#embedding_c_embedder_api" id="embedding_c_embedder_api">#</a></span></h1>
+the add-on's file name during loading.</p></section>
+        </section>
+<section><h2>C++ embedder API<span><a class="mark" href="#embedding_c_embedder_api" id="embedding_c_embedder_api">#</a></span></h2>
 
 <p>Node.js provides a number of C++ APIs that can be used to execute JavaScript
 in a Node.js environment from other C++ software.</p>
-<p>The documentation for these APIs can be found in <a href="https://github.com/nodejs/node/blob/master/src/node.h">src/node.h</a> in the Node.js
+<p>The documentation for these APIs can be found in <a href="https://github.com/nodejs/node/blob/HEAD/src/node.h">src/node.h</a> in the Node.js
 source tree. In addition to the APIs exposed by Node.js, some required concepts
 are provided by the V8 embedder API.</p>
 <p>Because using Node.js as an embedded library is different from writing code
 that is executed by Node.js, breaking changes do not follow typical Node.js
 <a href="deprecations.html">deprecation policy</a> and may occur on each semver-major release without prior
 warning.</p>
-<h2>Example embedding application<span><a class="mark" href="#embedding_example_embedding_application" id="embedding_example_embedding_application">#</a></span></h2>
+<section><h3>Example embedding application<span><a class="mark" href="#embedding_example_embedding_application" id="embedding_example_embedding_application">#</a></span></h3>
 <p>The following sections will provide an overview over how to use these APIs
 to create an application from scratch that will perform the equivalent of
 <code>node -e &#x3C;code></code>, i.e. that will take a piece of JavaScript and run it in
 a Node.js-specific environment.</p>
-<p>The full code can be found <a href="https://github.com/nodejs/node/blob/master/test/embedding/embedtest.cc">in the Node.js source tree</a>.</p>
-<h3>Setting up per-process state<span><a class="mark" href="#embedding_setting_up_per_process_state" id="embedding_setting_up_per_process_state">#</a></span></h3>
+<p>The full code can be found <a href="https://github.com/nodejs/node/blob/HEAD/test/embedding/embedtest.cc">in the Node.js source tree</a>.</p>
+<h4>Setting up per-process state<span><a class="mark" href="#embedding_setting_up_per_process_state" id="embedding_setting_up_per_process_state">#</a></span></h4>
 <p>Node.js requires some per-process state management in order to run:</p>
 <ul>
 <li>Arguments parsing for Node.js <a href="cli.html">CLI options</a>,</li>
@@ -15232,16 +15844,16 @@ a Node.js-specific environment.</p>
 </ul>
 <p>The following example shows how these can be set up. Some class names are from
 the <code>node</code> and <code>v8</code> C++ namespaces, respectively.</p>
-<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">main</span><span class="hljs-params">(<span class="hljs-keyword">int</span> argc, <span class="hljs-keyword">char</span>** argv)</span> </span>{
-  argv = uv_setup_args(argc, argv);
-  <span class="hljs-function"><span class="hljs-built_in">std</span>::<span class="hljs-built_in">vector</span>&#x3C;<span class="hljs-built_in">std</span>::<span class="hljs-built_in">string</span>> <span class="hljs-title">args</span><span class="hljs-params">(argv, argv + argc)</span></span>;
-  <span class="hljs-built_in">std</span>::<span class="hljs-built_in">vector</span>&#x3C;<span class="hljs-built_in">std</span>::<span class="hljs-built_in">string</span>> exec_args;
-  <span class="hljs-built_in">std</span>::<span class="hljs-built_in">vector</span>&#x3C;<span class="hljs-built_in">std</span>::<span class="hljs-built_in">string</span>> errors;
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">main</span><span class="hljs-params">(<span class="hljs-type">int</span> argc, <span class="hljs-type">char</span>** argv)</span> </span>{
+  argv = <span class="hljs-built_in">uv_setup_args</span>(argc, argv);
+  <span class="hljs-function">std::vector&#x3C;std::string> <span class="hljs-title">args</span><span class="hljs-params">(argv, argv + argc)</span></span>;
+  std::vector&#x3C;std::string> exec_args;
+  std::vector&#x3C;std::string> errors;
   <span class="hljs-comment">// Parse Node.js CLI options, and print any errors that have occurred while</span>
   <span class="hljs-comment">// trying to parse them.</span>
-  <span class="hljs-keyword">int</span> exit_code = node::InitializeNodeWithArgs(&#x26;args, &#x26;exec_args, &#x26;errors);
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> <span class="hljs-built_in">std</span>::<span class="hljs-built_in">string</span>&#x26; error : errors)
-    <span class="hljs-built_in">fprintf</span>(<span class="hljs-built_in">stderr</span>, <span class="hljs-string">"%s: %s\n"</span>, args[<span class="hljs-number">0</span>].c_str(), error.c_str());
+  <span class="hljs-type">int</span> exit_code = node::<span class="hljs-built_in">InitializeNodeWithArgs</span>(&#x26;args, &#x26;exec_args, &#x26;errors);
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> std::string&#x26; error : errors)
+    <span class="hljs-built_in">fprintf</span>(stderr, <span class="hljs-string">"%s: %s\n"</span>, args[<span class="hljs-number">0</span>].<span class="hljs-built_in">c_str</span>(), error.<span class="hljs-built_in">c_str</span>());
   <span class="hljs-keyword">if</span> (exit_code != <span class="hljs-number">0</span>) {
     <span class="hljs-keyword">return</span> exit_code;
   }
@@ -15250,19 +15862,19 @@ the <code>node</code> and <code>v8</code> C++ namespaces, respectively.</p>
   <span class="hljs-comment">// to create a v8::Platform instance that Node.js can use when creating</span>
   <span class="hljs-comment">// Worker threads. When no `MultiIsolatePlatform` instance is present,</span>
   <span class="hljs-comment">// Worker threads are disabled.</span>
-  <span class="hljs-built_in">std</span>::<span class="hljs-built_in">unique_ptr</span>&#x3C;MultiIsolatePlatform> platform =
-      MultiIsolatePlatform::Create(<span class="hljs-number">4</span>);
-  V8::InitializePlatform(platform.get());
-  V8::Initialize();
+  std::unique_ptr&#x3C;MultiIsolatePlatform> platform =
+      MultiIsolatePlatform::<span class="hljs-built_in">Create</span>(<span class="hljs-number">4</span>);
+  V8::<span class="hljs-built_in">InitializePlatform</span>(platform.<span class="hljs-built_in">get</span>());
+  V8::<span class="hljs-built_in">Initialize</span>();
 
   <span class="hljs-comment">// See below for the contents of this function.</span>
-  <span class="hljs-keyword">int</span> ret = RunNodeInstance(platform.get(), args, exec_args);
+  <span class="hljs-type">int</span> ret = <span class="hljs-built_in">RunNodeInstance</span>(platform.<span class="hljs-built_in">get</span>(), args, exec_args);
 
-  V8::Dispose();
-  V8::ShutdownPlatform();
+  V8::<span class="hljs-built_in">Dispose</span>();
+  V8::<span class="hljs-built_in">ShutdownPlatform</span>();
   <span class="hljs-keyword">return</span> ret;
 }</code></pre>
-<h3>Per-instance state<span><a class="mark" href="#embedding_per_instance_state" id="embedding_per_instance_state">#</a></span></h3>
+<h4>Per-instance state<span><a class="mark" href="#embedding_per_instance_state" id="embedding_per_instance_state">#</a></span></h4>
 <p>Node.js has a concept of a “Node.js instance”, that is commonly being referred
 to as <code>node::Environment</code>. Each <code>node::Environment</code> is associated with:</p>
 <ul>
@@ -15286,164 +15898,168 @@ for tasks scheduled by the <code>v8::Isolate</code>.</p>
 <p>The <code>node::NewIsolate()</code> helper function creates a <code>v8::Isolate</code>,
 sets it up with some Node.js-specific hooks (e.g. the Node.js error handler),
 and registers it with the platform automatically.</p>
-<pre><code class="language-cpp">int RunNodeInstance(MultiIsolatePlatform* platform,
-                    const std::vector&#x3C;std::string>&#x26; args,
-                    const std::vector&#x3C;std::string>&#x26; exec_args) {
-  int exit_code = 0;
-  // Set up a libuv event loop.
-  uv_loop_t loop;
-  int ret = uv_loop_init(&#x26;loop);
-  if (ret != 0) {
-    fprintf(stderr, "%s: Failed to initialize loop: %s\n",
-            args[0].c_str(),
-            uv_err_name(ret));
-    return 1;
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">RunNodeInstance</span><span class="hljs-params">(MultiIsolatePlatform* platform,
+                    <span class="hljs-keyword">const</span> std::vector&#x3C;std::string>&#x26; args,
+                    <span class="hljs-keyword">const</span> std::vector&#x3C;std::string>&#x26; exec_args)</span> </span>{
+  <span class="hljs-type">int</span> exit_code = <span class="hljs-number">0</span>;
+  <span class="hljs-comment">// Set up a libuv event loop.</span>
+  <span class="hljs-type">uv_loop_t</span> loop;
+  <span class="hljs-type">int</span> ret = <span class="hljs-built_in">uv_loop_init</span>(&#x26;loop);
+  <span class="hljs-keyword">if</span> (ret != <span class="hljs-number">0</span>) {
+    <span class="hljs-built_in">fprintf</span>(stderr, <span class="hljs-string">"%s: Failed to initialize loop: %s\n"</span>,
+            args[<span class="hljs-number">0</span>].<span class="hljs-built_in">c_str</span>(),
+            <span class="hljs-built_in">uv_err_name</span>(ret));
+    <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
   }
 
   std::shared_ptr&#x3C;ArrayBufferAllocator> allocator =
-      ArrayBufferAllocator::Create();
+      ArrayBufferAllocator::<span class="hljs-built_in">Create</span>();
 
-  Isolate* isolate = NewIsolate(allocator, &#x26;loop, platform);
-  if (isolate == nullptr) {
-    fprintf(stderr, "%s: Failed to initialize V8 Isolate\n", args[0].c_str());
-    return 1;
+  Isolate* isolate = <span class="hljs-built_in">NewIsolate</span>(allocator, &#x26;loop, platform);
+  <span class="hljs-keyword">if</span> (isolate == <span class="hljs-literal">nullptr</span>) {
+    <span class="hljs-built_in">fprintf</span>(stderr, <span class="hljs-string">"%s: Failed to initialize V8 Isolate\n"</span>, args[<span class="hljs-number">0</span>].<span class="hljs-built_in">c_str</span>());
+    <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
   }
 
   {
-    Locker locker(isolate);
-    Isolate::Scope isolate_scope(isolate);
+    <span class="hljs-function">Locker <span class="hljs-title">locker</span><span class="hljs-params">(isolate)</span></span>;
+    <span class="hljs-function">Isolate::Scope <span class="hljs-title">isolate_scope</span><span class="hljs-params">(isolate)</span></span>;
 
-    // Create a node::IsolateData instance that will later be released using
-    // node::FreeIsolateData().
-    std::unique_ptr&#x3C;IsolateData, decltype(&#x26;node::FreeIsolateData)> isolate_data(
+    <span class="hljs-comment">// Create a node::IsolateData instance that will later be released using</span>
+    <span class="hljs-comment">// node::FreeIsolateData().</span>
+    <span class="hljs-function">std::unique_ptr&#x3C;IsolateData, <span class="hljs-title">decltype</span><span class="hljs-params">(&#x26;node::FreeIsolateData)</span>> <span class="hljs-title">isolate_data</span><span class="hljs-params">(
         node::CreateIsolateData(isolate, &#x26;loop, platform, allocator.get()),
-        node::FreeIsolateData);
-
-    // Set up a new v8::Context.
-    HandleScope handle_scope(isolate);
-    Local&#x3C;Context> context = node::NewContext(isolate);
-    if (context.IsEmpty()) {
-      fprintf(stderr, "%s: Failed to initialize V8 Context\n", args[0].c_str());
-      return 1;
+        node::FreeIsolateData)</span></span>;
+
+    <span class="hljs-comment">// Set up a new v8::Context.</span>
+    <span class="hljs-function">HandleScope <span class="hljs-title">handle_scope</span><span class="hljs-params">(isolate)</span></span>;
+    Local&#x3C;Context> context = node::<span class="hljs-built_in">NewContext</span>(isolate);
+    <span class="hljs-keyword">if</span> (context.<span class="hljs-built_in">IsEmpty</span>()) {
+      <span class="hljs-built_in">fprintf</span>(stderr, <span class="hljs-string">"%s: Failed to initialize V8 Context\n"</span>, args[<span class="hljs-number">0</span>].<span class="hljs-built_in">c_str</span>());
+      <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
     }
 
-    // The v8::Context needs to be entered when node::CreateEnvironment() and
-    // node::LoadEnvironment() are being called.
-    Context::Scope context_scope(context);
+    <span class="hljs-comment">// The v8::Context needs to be entered when node::CreateEnvironment() and</span>
+    <span class="hljs-comment">// node::LoadEnvironment() are being called.</span>
+    <span class="hljs-function">Context::Scope <span class="hljs-title">context_scope</span><span class="hljs-params">(context)</span></span>;
 
-    // Create a node::Environment instance that will later be released using
-    // node::FreeEnvironment().
-    std::unique_ptr&#x3C;Environment, decltype(&#x26;node::FreeEnvironment)> env(
+    <span class="hljs-comment">// Create a node::Environment instance that will later be released using</span>
+    <span class="hljs-comment">// node::FreeEnvironment().</span>
+    <span class="hljs-function">std::unique_ptr&#x3C;Environment, <span class="hljs-title">decltype</span><span class="hljs-params">(&#x26;node::FreeEnvironment)</span>> <span class="hljs-title">env</span><span class="hljs-params">(
         node::CreateEnvironment(isolate_data.get(), context, args, exec_args),
-        node::FreeEnvironment);
-
-    // Set up the Node.js instance for execution, and run code inside of it.
-    // There is also a variant that takes a callback and provides it with
-    // the `require` and `process` objects, so that it can manually compile
-    // and run scripts as needed.
-    // The `require` function inside this script does *not* access the file
-    // system, and can only load built-in Node.js modules.
-    // `module.createRequire()` is being used to create one that is able to
-    // load files from the disk, and uses the standard CommonJS file loader
-    // instead of the internal-only `require` function.
-    MaybeLocal&#x3C;Value> loadenv_ret = node::LoadEnvironment(
-        env.get(),
-        "const publicRequire ="
-        "  require('module').createRequire(process.cwd() + '/');"
-        "globalThis.require = publicRequire;"
-        "require('vm').runInThisContext(process.argv[1]);");
-
-    if (loadenv_ret.IsEmpty())  // There has been a JS exception.
-      return 1;
+        node::FreeEnvironment)</span></span>;
+
+    <span class="hljs-comment">// Set up the Node.js instance for execution, and run code inside of it.</span>
+    <span class="hljs-comment">// There is also a variant that takes a callback and provides it with</span>
+    <span class="hljs-comment">// the `require` and `process` objects, so that it can manually compile</span>
+    <span class="hljs-comment">// and run scripts as needed.</span>
+    <span class="hljs-comment">// The `require` function inside this script does *not* access the file</span>
+    <span class="hljs-comment">// system, and can only load built-in Node.js modules.</span>
+    <span class="hljs-comment">// `module.createRequire()` is being used to create one that is able to</span>
+    <span class="hljs-comment">// load files from the disk, and uses the standard CommonJS file loader</span>
+    <span class="hljs-comment">// instead of the internal-only `require` function.</span>
+    MaybeLocal&#x3C;Value> loadenv_ret = node::<span class="hljs-built_in">LoadEnvironment</span>(
+        env.<span class="hljs-built_in">get</span>(),
+        <span class="hljs-string">"const publicRequire ="</span>
+        <span class="hljs-string">"  require('module').createRequire(process.cwd() + '/');"</span>
+        <span class="hljs-string">"globalThis.require = publicRequire;"</span>
+        <span class="hljs-string">"require('vm').runInThisContext(process.argv[1]);"</span>);
+
+    <span class="hljs-keyword">if</span> (loadenv_ret.<span class="hljs-built_in">IsEmpty</span>())  <span class="hljs-comment">// There has been a JS exception.</span>
+      <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
 
     {
-      // SealHandleScope protects against handle leaks from callbacks.
-      SealHandleScope seal(isolate);
-      bool more;
-      do {
-        uv_run(&#x26;loop, UV_RUN_DEFAULT);
-
-        // V8 tasks on background threads may end up scheduling new tasks in the
-        // foreground, which in turn can keep the event loop going. For example,
-        // WebAssembly.compile() may do so.
-        platform->DrainTasks(isolate);
-
-        // If there are new tasks, continue.
-        more = uv_loop_alive(&#x26;loop);
-        if (more) continue;
-
-        // node::EmitBeforeExit() is used to emit the 'beforeExit' event on
-        // the `process` object.
-        node::EmitBeforeExit(env.get());
-
-        // 'beforeExit' can also schedule new work that keeps the event loop
-        // running.
-        more = uv_loop_alive(&#x26;loop);
-      } while (more == true);
+      <span class="hljs-comment">// SealHandleScope protects against handle leaks from callbacks.</span>
+      <span class="hljs-function">SealHandleScope <span class="hljs-title">seal</span><span class="hljs-params">(isolate)</span></span>;
+      <span class="hljs-type">bool</span> more;
+      <span class="hljs-keyword">do</span> {
+        <span class="hljs-built_in">uv_run</span>(&#x26;loop, UV_RUN_DEFAULT);
+
+        <span class="hljs-comment">// V8 tasks on background threads may end up scheduling new tasks in the</span>
+        <span class="hljs-comment">// foreground, which in turn can keep the event loop going. For example,</span>
+        <span class="hljs-comment">// WebAssembly.compile() may do so.</span>
+        platform-><span class="hljs-built_in">DrainTasks</span>(isolate);
+
+        <span class="hljs-comment">// If there are new tasks, continue.</span>
+        more = <span class="hljs-built_in">uv_loop_alive</span>(&#x26;loop);
+        <span class="hljs-keyword">if</span> (more) <span class="hljs-keyword">continue</span>;
+
+        <span class="hljs-comment">// node::EmitProcessBeforeExit() is used to emit the 'beforeExit' event</span>
+        <span class="hljs-comment">// on the `process` object.</span>
+        <span class="hljs-keyword">if</span> (node::<span class="hljs-built_in">EmitProcessBeforeExit</span>(env.<span class="hljs-built_in">get</span>()).<span class="hljs-built_in">IsNothing</span>())
+          <span class="hljs-keyword">break</span>;
+
+        <span class="hljs-comment">// 'beforeExit' can also schedule new work that keeps the event loop</span>
+        <span class="hljs-comment">// running.</span>
+        more = <span class="hljs-built_in">uv_loop_alive</span>(&#x26;loop);
+      } <span class="hljs-keyword">while</span> (more == <span class="hljs-literal">true</span>);
     }
 
-    // node::EmitExit() returns the current exit code.
-    exit_code = node::EmitExit(env.get());
+    <span class="hljs-comment">// node::EmitProcessExit() returns the current exit code.</span>
+    exit_code = node::<span class="hljs-built_in">EmitProcessExit</span>(env.<span class="hljs-built_in">get</span>()).<span class="hljs-built_in">FromMaybe</span>(<span class="hljs-number">1</span>);
 
-    // node::Stop() can be used to explicitly stop the event loop and keep
-    // further JavaScript from running. It can be called from any thread,
-    // and will act like worker.terminate() if called from another thread.
-    node::Stop(env.get());
+    <span class="hljs-comment">// node::Stop() can be used to explicitly stop the event loop and keep</span>
+    <span class="hljs-comment">// further JavaScript from running. It can be called from any thread,</span>
+    <span class="hljs-comment">// and will act like worker.terminate() if called from another thread.</span>
+    node::<span class="hljs-built_in">Stop</span>(env.<span class="hljs-built_in">get</span>());
   }
 
-  // Unregister the Isolate with the platform and add a listener that is called
-  // when the Platform is done cleaning up any state it had associated with
-  // the Isolate.
-  bool platform_finished = false;
-  platform->AddIsolateFinishedCallback(isolate, [](void* data) {
-    *static_cast&#x3C;bool*>(data) = true;
+  <span class="hljs-comment">// Unregister the Isolate with the platform and add a listener that is called</span>
+  <span class="hljs-comment">// when the Platform is done cleaning up any state it had associated with</span>
+  <span class="hljs-comment">// the Isolate.</span>
+  <span class="hljs-type">bool</span> platform_finished = <span class="hljs-literal">false</span>;
+  platform-><span class="hljs-built_in">AddIsolateFinishedCallback</span>(isolate, [](<span class="hljs-type">void</span>* data) {
+    *<span class="hljs-built_in">static_cast</span>&#x3C;<span class="hljs-type">bool</span>*>(data) = <span class="hljs-literal">true</span>;
   }, &#x26;platform_finished);
-  platform->UnregisterIsolate(isolate);
-  isolate->Dispose();
+  platform-><span class="hljs-built_in">UnregisterIsolate</span>(isolate);
+  isolate-><span class="hljs-built_in">Dispose</span>();
 
-  // Wait until the platform has cleaned up all relevant resources.
-  while (!platform_finished)
-    uv_run(&#x26;loop, UV_RUN_ONCE);
-  int err = uv_loop_close(&#x26;loop);
-  assert(err == 0);
+  <span class="hljs-comment">// Wait until the platform has cleaned up all relevant resources.</span>
+  <span class="hljs-keyword">while</span> (!platform_finished)
+    <span class="hljs-built_in">uv_run</span>(&#x26;loop, UV_RUN_ONCE);
+  <span class="hljs-type">int</span> err = <span class="hljs-built_in">uv_loop_close</span>(&#x26;loop);
+  <span class="hljs-built_in">assert</span>(err == <span class="hljs-number">0</span>);
 
-  return exit_code;
-}</code></pre>
-<h1>Child process<span><a class="mark" href="#child_process_child_process" id="child_process_child_process">#</a></span></h1>
+  <span class="hljs-keyword">return</span> exit_code;
+}</code></pre></section>
+        </section>
+<section><h2>Child process<span><a class="mark" href="#child_process_child_process" id="child_process_child_process">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/child_process.js">lib/child_process.js</a></p>
-<p>The <code>child_process</code> module provides the ability to spawn child processes in
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/child_process.js">lib/child_process.js</a></p>
+<p>The <code>child_process</code> module provides the ability to spawn subprocesses in
 a manner that is similar, but not identical, to <a href="http://man7.org/linux/man-pages/man3/popen.3.html"><code>popen(3)</code></a>. This capability
 is primarily provided by the <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> function:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> ls = spawn(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
+<span class="hljs-keyword">const</span> ls = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
 
-ls.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`stderr: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`stderr: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
+ls.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
 <p>By default, pipes for <code>stdin</code>, <code>stdout</code>, and <code>stderr</code> are established between
-the parent Node.js process and the spawned child. These pipes have
-limited (and platform-specific) capacity. If the child process writes to
-stdout in excess of that limit without the output being captured, the child
-process will block waiting for the pipe buffer to accept more data. This is
+the parent Node.js process and the spawned subprocess. These pipes have
+limited (and platform-specific) capacity. If the subprocess writes to
+stdout in excess of that limit without the output being captured, the
+subprocess blocks waiting for the pipe buffer to accept more data. This is
 identical to the behavior of pipes in the shell. Use the <code>{ stdio: 'ignore' }</code>
 option if the output will not be consumed.</p>
-<p>The command lookup will be performed using <code>options.env.PATH</code> environment
-variable if passed in <code>options</code> object, otherwise <code>process.env.PATH</code> will be
-used. To account for the fact that Windows environment variables are
-case-insensitive Node.js will lexicographically sort all <code>env</code> keys and choose
-the first one case-insensitively matching <code>PATH</code> to perform command lookup.
-This may lead to issues on Windows when passing objects to <code>env</code> option that
-have multiple variants of <code>PATH</code> variable.</p>
+<p>The command lookup is performed using the <code>options.env.PATH</code> environment
+variable if it is in the <code>options</code> object. Otherwise, <code>process.env.PATH</code> is
+used.</p>
+<p>On Windows, environment variables are case-insensitive. Node.js
+lexicographically sorts the <code>env</code> keys and uses the first one that
+case-insensitively matches. Only first (in lexicographic order) entry will be
+passed to the subprocess. This might lead to issues on Windows when passing
+objects to the <code>env</code> option that have multiple variants of the same key, such as
+<code>PATH</code> and <code>Path</code>.</p>
 <p>The <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> method spawns the child process asynchronously,
 without blocking the Node.js event loop. The <a href="#child_process_child_process_spawnsync_command_args_options"><code>child_process.spawnSync()</code></a>
 function provides equivalent functionality in a synchronous manner that blocks
@@ -15471,18 +16087,18 @@ sending messages between parent and child.</li>
 <a href="#child_process_synchronous_process_creation">synchronous counterparts</a> may be more convenient. In many cases, however,
 the synchronous methods can have significant impact on performance due to
 stalling the event loop while spawned processes complete.</p>
-<h2>Asynchronous process creation<span><a class="mark" href="#child_process_asynchronous_process_creation" id="child_process_asynchronous_process_creation">#</a></span></h2>
+<section><h3>Asynchronous process creation<span><a class="mark" href="#child_process_asynchronous_process_creation" id="child_process_asynchronous_process_creation">#</a></span></h3>
 <p>The <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>, <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>, <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a>,
 and <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a> methods all follow the idiomatic asynchronous
 programming pattern typical of other Node.js APIs.</p>
-<p>Each of the methods returns a <a href="#child_process_child_process"><code>ChildProcess</code></a> instance. These objects
+<p>Each of the methods returns a <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> instance. These objects
 implement the Node.js <a href="#events_class_eventemitter"><code>EventEmitter</code></a> API, allowing the parent process to
 register listener functions that are called when certain events occur during
 the life cycle of the child process.</p>
 <p>The <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a> and <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a> methods
 additionally allow for an optional <code>callback</code> function to be specified that is
 invoked when the child process terminates.</p>
-<h3>Spawning <code>.bat</code> and <code>.cmd</code> files on Windows<span><a class="mark" href="#child_process_spawning_bat_and_cmd_files_on_windows" id="child_process_spawning_bat_and_cmd_files_on_windows">#</a></span></h3>
+<h4>Spawning <code>.bat</code> and <code>.cmd</code> files on Windows<span><a class="mark" href="#child_process_spawning_bat_and_cmd_files_on_windows" id="child_process_spawning_bat_and_cmd_files_on_windows">#</a></span></h4>
 <p>The importance of the distinction between <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a> and
 <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a> can vary based on platform. On Unix-type
 operating systems (Unix, Linux, macOS) <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a> can be
@@ -15497,40 +16113,44 @@ When running on Windows, <code>.bat</code> and <code>.cmd</code> files can be in
 spaces it needs to be quoted.</p>
 <pre><code class="language-js"><span class="hljs-comment">// On Windows Only...</span>
 <span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> bat = spawn(<span class="hljs-string">'cmd.exe'</span>, [<span class="hljs-string">'/c'</span>, <span class="hljs-string">'my.bat'</span>]);
+<span class="hljs-keyword">const</span> bat = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'cmd.exe'</span>, [<span class="hljs-string">'/c'</span>, <span class="hljs-string">'my.bat'</span>]);
 
-bat.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(data.toString());
+bat.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>());
 });
 
-bat.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(data.toString());
+bat.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(data.<span class="hljs-title function_">toString</span>());
 });
 
-bat.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Child exited with code <span class="hljs-subst">${code}</span>`</span>);
+bat.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Child exited with code <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// OR...</span>
 <span class="hljs-keyword">const</span> { exec, spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-exec(<span class="hljs-string">'my.bat'</span>, <span class="hljs-function">(<span class="hljs-params">err, stdout, stderr</span>) =></span> {
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'my.bat'</span>, <span class="hljs-function">(<span class="hljs-params">err, stdout, stderr</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
     <span class="hljs-keyword">return</span>;
   }
-  <span class="hljs-built_in">console</span>.log(stdout);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stdout);
 });
 
 <span class="hljs-comment">// Script with spaces in the filename:</span>
-<span class="hljs-keyword">const</span> bat = spawn(<span class="hljs-string">'"my script.cmd"'</span>, [<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>], { <span class="hljs-attr">shell</span>: <span class="hljs-literal">true</span> });
+<span class="hljs-keyword">const</span> bat = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'"my script.cmd"'</span>, [<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>], { <span class="hljs-attr">shell</span>: <span class="hljs-literal">true</span> });
 <span class="hljs-comment">// or:</span>
-exec(<span class="hljs-string">'"my script.cmd" a b'</span>, <span class="hljs-function">(<span class="hljs-params">err, stdout, stderr</span>) =></span> {
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'"my script.cmd" a b'</span>, <span class="hljs-function">(<span class="hljs-params">err, stdout, stderr</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
-<h3><code>child_process.exec(command[, options][, callback])</code><span><a class="mark" href="#child_process_child_process_exec_command_options_callback" id="child_process_child_process_exec_command_options_callback">#</a></span></h3>
+<h4><code>child_process.exec(command[, options][, callback])</code><span><a class="mark" href="#child_process_child_process_exec_command_options_callback" id="child_process_child_process_exec_command_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
 <tr><td>v8.8.0</td>
 <td><p>The <code>windowsHide</code> option is supported now.</p></td></tr>
 <tr><td>v0.1.90</td>
@@ -15542,13 +16162,15 @@ exec(<span class="hljs-string">'"my script.cmd" a b'</span>, <span class="hljs-f
 <li><code>command</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The command to run, with space-separated arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.
-<strong>Default:</strong> <code>null</code>.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.
+<strong>Default:</strong> <code>process.cwd()</code>.</li>
 <li><code>env</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Environment key-value pairs. <strong>Default:</strong> <code>process.env</code>.</li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 <li><code>shell</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Shell to execute the command with. See
 <a href="#child_process_shell_requirements">Shell requirements</a> and <a href="#child_process_default_windows_shell">Default Windows shell</a>. <strong>Default:</strong>
 <code>'/bin/sh'</code> on Unix, <code>process.env.ComSpec</code> on Windows.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting the child process using an
+AbortSignal.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>0</code></li>
 <li><code>maxBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Largest amount of data in bytes allowed on stdout or
 stderr. If exceeded, the child process is terminated and any output is
@@ -15575,11 +16197,13 @@ generated output. The <code>command</code> string passed to the exec function is
 directly by the shell and special characters (vary based on
 <a href="https://en.wikipedia.org/wiki/List_of_command-line_interpreters">shell</a>)
 need to be dealt with accordingly:</p>
-<pre><code class="language-js">exec(<span class="hljs-string">'"/path/to/test file/test.sh" arg1 arg2'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { exec } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'"/path/to/test file/test.sh" arg1 arg2'</span>);
 <span class="hljs-comment">// Double quotes are used so that the space in the path is not interpreted as</span>
 <span class="hljs-comment">// a delimiter of multiple arguments.</span>
 
-exec(<span class="hljs-string">'echo "The \\$HOME variable is $HOME"'</span>);
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'echo "The \\$HOME variable is $HOME"'</span>);
 <span class="hljs-comment">// The $HOME variable is escaped in the first instance, but not in the second.</span></code></pre>
 <p><strong>Never pass unsanitized user input to this function. Any input containing shell
 metacharacters may be used to trigger arbitrary command execution.</strong></p>
@@ -15596,13 +16220,13 @@ can be used to specify the character encoding used to decode the stdout and
 stderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character
 encoding, <code>Buffer</code> objects will be passed to the callback instead.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { exec } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-exec(<span class="hljs-string">'cat *.js missing_file | wc -l'</span>, <span class="hljs-function">(<span class="hljs-params">error, stdout, stderr</span>) =></span> {
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'cat *.js missing_file | wc -l'</span>, <span class="hljs-function">(<span class="hljs-params">error, stdout, stderr</span>) =></span> {
   <span class="hljs-keyword">if</span> (error) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`exec error: <span class="hljs-subst">${error}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`exec error: <span class="hljs-subst">${error}</span>`</span>);
     <span class="hljs-keyword">return</span>;
   }
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stdout: <span class="hljs-subst">${stdout}</span>`</span>);
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`stderr: <span class="hljs-subst">${stderr}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stdout: <span class="hljs-subst">${stdout}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`stderr: <span class="hljs-subst">${stderr}</span>`</span>);
 });</code></pre>
 <p>If <code>timeout</code> is greater than <code>0</code>, the parent will send the signal
 identified by the <code>killSignal</code> property (the default is <code>'SIGTERM'</code>) if the
@@ -15616,19 +16240,33 @@ case of an error (including any error resulting in an exit code other than 0), a
 rejected promise is returned, with the same <code>error</code> object given in the
 callback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> exec = util.promisify(<span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).exec);
+<span class="hljs-keyword">const</span> exec = util.<span class="hljs-title function_">promisify</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).<span class="hljs-property">exec</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">lsExample</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> { stdout, stderr } = <span class="hljs-keyword">await</span> exec(<span class="hljs-string">'ls'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'stdout:'</span>, stdout);
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'stderr:'</span>, stderr);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">lsExample</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> { stdout, stderr } = <span class="hljs-keyword">await</span> <span class="hljs-title function_">exec</span>(<span class="hljs-string">'ls'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'stdout:'</span>, stdout);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'stderr:'</span>, stderr);
 }
-lsExample();</code></pre>
-<h3><code>child_process.execFile(file[, args][, options][, callback])</code><span><a class="mark" href="#child_process_child_process_execfile_file_args_options_callback" id="child_process_child_process_execfile_file_args_options_callback">#</a></span></h3>
+<span class="hljs-title function_">lsExample</span>();</code></pre>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except
+the error passed to the callback will be an <code>AbortError</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { exec } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> child = <span class="hljs-title function_">exec</span>(<span class="hljs-string">'grep ssh'</span>, { signal }, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(error); <span class="hljs-comment">// an AbortError</span>
+});
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<h4><code>child_process.execFile(file[, args][, options][, callback])</code><span><a class="mark" href="#child_process_child_process_execfile_file_args_options_callback" id="child_process_child_process_execfile_file_args_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
 <tr><td>v8.8.0</td>
 <td><p>The <code>windowsHide</code> option is supported now.</p></td></tr>
 <tr><td>v0.1.91</td>
@@ -15641,7 +16279,7 @@ lsExample();</code></pre>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>env</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Environment key-value pairs. <strong>Default:</strong> <code>process.env</code>.</li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>0</code></li>
@@ -15660,6 +16298,8 @@ done on Windows. Ignored on Unix. <strong>Default:</strong> <code>false</code>.<
 <code>'/bin/sh'</code> on Unix, and <code>process.env.ComSpec</code> on Windows. A different
 shell can be specified as a string. See <a href="#child_process_shell_requirements">Shell requirements</a> and
 <a href="#child_process_default_windows_shell">Default Windows shell</a>. <strong>Default:</strong> <code>false</code> (no shell).</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting the child process using an
+AbortSignal.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called with the output when process terminates.
@@ -15679,11 +16319,11 @@ efficient than <a href="#child_process_child_process_exec_command_options_callba
 not spawned, behaviors such as I/O redirection and file globbing are not
 supported.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { execFile } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> child = execFile(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>], <span class="hljs-function">(<span class="hljs-params">error, stdout, stderr</span>) =></span> {
+<span class="hljs-keyword">const</span> child = <span class="hljs-title function_">execFile</span>(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>], <span class="hljs-function">(<span class="hljs-params">error, stdout, stderr</span>) =></span> {
   <span class="hljs-keyword">if</span> (error) {
     <span class="hljs-keyword">throw</span> error;
   }
-  <span class="hljs-built_in">console</span>.log(stdout);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stdout);
 });</code></pre>
 <p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the
 stdout and stderr output of the child process. By default, Node.js will decode
@@ -15698,21 +16338,39 @@ case of an error (including any error resulting in an exit code other than 0), a
 rejected promise is returned, with the same <code>error</code> object given in the
 callback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> execFile = util.promisify(<span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).execFile);
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getVersion</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> { stdout } = <span class="hljs-keyword">await</span> execFile(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>]);
-  <span class="hljs-built_in">console</span>.log(stdout);
+<span class="hljs-keyword">const</span> execFile = util.<span class="hljs-title function_">promisify</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).<span class="hljs-property">execFile</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getVersion</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> { stdout } = <span class="hljs-keyword">await</span> <span class="hljs-title function_">execFile</span>(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stdout);
 }
-getVersion();</code></pre>
+<span class="hljs-title function_">getVersion</span>();</code></pre>
 <p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this
 function. Any input containing shell metacharacters may be used to trigger
 arbitrary command execution.</strong></p>
-<h3><code>child_process.fork(modulePath[, args][, options])</code><span><a class="mark" href="#child_process_child_process_fork_modulepath_args_options" id="child_process_child_process_fork_modulepath_args_options">#</a></span></h3>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except
+the error passed to the callback will be an <code>AbortError</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { execFile } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> child = <span class="hljs-title function_">execFile</span>(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>], { signal }, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(error); <span class="hljs-comment">// an AbortError</span>
+});
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<h4><code>child_process.fork(modulePath[, args][, options])</code><span><a class="mark" href="#child_process_child_process_fork_modulepath_args_options" id="child_process_child_process_fork_modulepath_args_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>timeout was added.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>killSignal for AbortSignal was added.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
+<tr><td>v13.2.0, v12.16.0</td>
 <td><p>The <code>serialization</code> option is supported now.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>stdio</code> option can now be a string.</p></td></tr>
@@ -15728,7 +16386,7 @@ arbitrary command execution.</strong></p>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>detached</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Prepare child to run independently of its parent
 process. Specific behavior depends on the platform, see
 <a href="#child_process_options_detached"><code>options.detached</code></a>).</li>
@@ -15736,9 +16394,14 @@ process. Specific behavior depends on the platform, see
 <li><code>execPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Executable used to create the child process.</li>
 <li><code>execArgv</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments passed to the executable.
 <strong>Default:</strong> <code>process.execArgv</code>.</li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the group identity of the process (see <a href="http://man7.org/linux/man-pages/man2/setgid.2.html"><code>setgid(2)</code></a>).</li>
 <li><code>serialization</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Specify the kind of serialization used for sending
 messages between processes. Possible values are <code>'json'</code> and <code>'advanced'</code>.
 See <a href="#child_process_advanced_serialization">Advanced serialization</a> for more details. <strong>Default:</strong> <code>'json'</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Allows closing the child process using an
+AbortSignal.</li>
+<li><code>killSignal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The signal value to be used when the spawned
+process will be killed by timeout or abort signal. <strong>Default:</strong> <code>'SIGTERM'</code>.</li>
 <li><code>silent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, stdin, stdout, and stderr of the child will be
 piped to the parent, otherwise they will be inherited from the parent, see
 the <code>'pipe'</code> and <code>'inherit'</code> options for <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>'s
@@ -15747,18 +16410,19 @@ the <code>'pipe'</code> and <code>'inherit'</code> options for <a href="#child_p
 When this option is provided, it overrides <code>silent</code>. If the array variant
 is used, it must contain exactly one item with value <code>'ipc'</code> or an error
 will be thrown. For instance <code>[0, 1, 2, 'ipc']</code>.</li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the user identity of the process (see <a href="http://man7.org/linux/man-pages/man2/setuid.2.html"><code>setuid(2)</code></a>).</li>
 <li><code>windowsVerbatimArguments</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> No quoting or escaping of arguments is
 done on Windows. Ignored on Unix. <strong>Default:</strong> <code>false</code>.</li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the user identity of the process (see <a href="http://man7.org/linux/man-pages/man2/setuid.2.html"><code>setuid(2)</code></a>).</li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the group identity of the process (see <a href="http://man7.org/linux/man-pages/man2/setgid.2.html"><code>setgid(2)</code></a>).</li>
+<li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> In milliseconds the maximum amount of time the process
+is allowed to run. <strong>Default:</strong> <code>undefined</code>.</li>
 </ul>
 </li>
 <li>Returns: <a href="#child_process_class_childprocess" class="type">&#x3C;ChildProcess></a></li>
 </ul>
 <p>The <code>child_process.fork()</code> method is a special case of
 <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> used specifically to spawn new Node.js processes.
-Like <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>, a <a href="#child_process_child_process"><code>ChildProcess</code></a> object is returned. The
-returned <a href="#child_process_child_process"><code>ChildProcess</code></a> will have an additional communication channel
+Like <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>, a <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> object is returned. The
+returned <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> will have an additional communication channel
 built-in that allows messages to be passed back and forth between the parent and
 child. See <a href="#child_process_subprocess_send_message_sendhandle_options_callback"><code>subprocess.send()</code></a> for details.</p>
 <p>Keep in mind that spawned Node.js child processes are
@@ -15777,12 +16441,37 @@ environment variable <code>NODE_CHANNEL_FD</code> on the child process.</p>
 current process.</p>
 <p>The <code>shell</code> option available in <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> is not supported by
 <code>child_process.fork()</code> and will be ignored if set.</p>
-<h3><code>child_process.spawn(command[, args][, options])</code><span><a class="mark" href="#child_process_child_process_spawn_command_args_options" id="child_process_child_process_spawn_command_args_options">#</a></span></h3>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except
+the error passed to the callback will be an <code>AbortError</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">argv</span>[<span class="hljs-number">2</span>] === <span class="hljs-string">'child'</span>) {
+  <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Hello from <span class="hljs-subst">${process.argv[<span class="hljs-number">2</span>]}</span>!`</span>);
+  }, <span class="hljs-number">1_000</span>);
+} <span class="hljs-keyword">else</span> {
+  <span class="hljs-keyword">const</span> { fork } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+  <span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+  <span class="hljs-keyword">const</span> { signal } = controller;
+  <span class="hljs-keyword">const</span> child = <span class="hljs-title function_">fork</span>(__filename, [<span class="hljs-string">'child'</span>], { signal });
+  child.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-comment">// This will be called with err being an AbortError if the controller aborts</span>
+  });
+  controller.<span class="hljs-title function_">abort</span>(); <span class="hljs-comment">// Stops the child process</span>
+}</code></pre>
+<h4><code>child_process.spawn(command[, args][, options])</code><span><a class="mark" href="#child_process_child_process_spawn_command_args_options" id="child_process_child_process_spawn_command_args_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>timeout was added.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>killSignal for AbortSignal was added.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
+<tr><td>v13.2.0, v12.16.0</td>
 <td><p>The <code>serialization</code> option is supported now.</p></td></tr>
 <tr><td>v8.8.0</td>
 <td><p>The <code>windowsHide</code> option is supported now.</p></td></tr>
@@ -15796,11 +16485,16 @@ current process.</p>
 </details>
 </div>
 <ul>
-<li><code>command</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The command to run.</li>
-<li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li>
+<p><code>command</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The command to run.</p>
+</li>
+<li>
+<p><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</p>
+</li>
+<li>
+<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></p>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>env</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Environment key-value pairs. <strong>Default:</strong> <code>process.env</code>.</li>
 <li><code>argv0</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Explicitly set the value of <code>argv[0]</code> sent to the child
 process. This will be set to <code>command</code> if not specified.</li>
@@ -15823,12 +16517,20 @@ done on Windows. Ignored on Unix. This is set to <code>true</code> automatically
 when <code>shell</code> is specified and is CMD. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>windowsHide</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Hide the subprocess console window that would
 normally be created on Windows systems. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting the child process using an
+AbortSignal.</li>
+<li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> In milliseconds the maximum amount of time the process
+is allowed to run. <strong>Default:</strong> <code>undefined</code>.</li>
+<li><code>killSignal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The signal value to be used when the spawned
+process will be killed by timeout or abort signal. <strong>Default:</strong> <code>'SIGTERM'</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="#child_process_class_childprocess" class="type">&#x3C;ChildProcess></a></li>
+<li>
+<p>Returns: <a href="#child_process_class_childprocess" class="type">&#x3C;ChildProcess></a></p>
+</li>
 </ul>
 <p>The <code>child_process.spawn()</code> method spawns a new process using the given
-<code>command</code>, with command line arguments in <code>args</code>. If omitted, <code>args</code> defaults
+<code>command</code>, with command-line arguments in <code>args</code>. If omitted, <code>args</code> defaults
 to an empty array.</p>
 <p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this
 function. Any input containing shell metacharacters may be used to trigger
@@ -15836,68 +16538,71 @@ arbitrary command execution.</strong></p>
 <p>A third argument may be used to specify additional options, with these defaults:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> defaults = {
   <span class="hljs-attr">cwd</span>: <span class="hljs-literal">undefined</span>,
-  <span class="hljs-attr">env</span>: process.env
+  <span class="hljs-attr">env</span>: process.<span class="hljs-property">env</span>
 };</code></pre>
 <p>Use <code>cwd</code> to specify the working directory from which the process is spawned.
-If not given, the default is to inherit the current working directory.</p>
+If not given, the default is to inherit the current working directory. If given,
+but the path does not exist, the child process emits an <code>ENOENT</code> error
+and exits immediately. <code>ENOENT</code> is also emitted when the command
+does not exist.</p>
 <p>Use <code>env</code> to specify environment variables that will be visible to the new
 process, the default is <a href="#process_process_env"><code>process.env</code></a>.</p>
 <p><code>undefined</code> values in <code>env</code> will be ignored.</p>
 <p>Example of running <code>ls -lh /usr</code>, capturing <code>stdout</code>, <code>stderr</code>, and the
 exit code:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> ls = spawn(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
+<span class="hljs-keyword">const</span> ls = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
 
-ls.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`stderr: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`stderr: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
+ls.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
 <p>Example: A very elaborate way to run <code>ps ax | grep ssh</code></p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> ps = spawn(<span class="hljs-string">'ps'</span>, [<span class="hljs-string">'ax'</span>]);
-<span class="hljs-keyword">const</span> grep = spawn(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
+<span class="hljs-keyword">const</span> ps = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ps'</span>, [<span class="hljs-string">'ax'</span>]);
+<span class="hljs-keyword">const</span> grep = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
 
-ps.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  grep.stdin.write(data);
+ps.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  grep.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">write</span>(data);
 });
 
-ps.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`ps stderr: <span class="hljs-subst">${data}</span>`</span>);
+ps.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`ps stderr: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ps.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+ps.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
   <span class="hljs-keyword">if</span> (code !== <span class="hljs-number">0</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`ps process exited with code <span class="hljs-subst">${code}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`ps process exited with code <span class="hljs-subst">${code}</span>`</span>);
   }
-  grep.stdin.end();
+  grep.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">end</span>();
 });
 
-grep.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(data.toString());
+grep.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>());
 });
 
-grep.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`grep stderr: <span class="hljs-subst">${data}</span>`</span>);
+grep.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`grep stderr: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-grep.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+grep.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
   <span class="hljs-keyword">if</span> (code !== <span class="hljs-number">0</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`grep process exited with code <span class="hljs-subst">${code}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`grep process exited with code <span class="hljs-subst">${code}</span>`</span>);
   }
 });</code></pre>
 <p>Example of checking for failed <code>spawn</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> subprocess = spawn(<span class="hljs-string">'bad_command'</span>);
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'bad_command'</span>);
 
-subprocess.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Failed to start subprocess.'</span>);
+subprocess.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Failed to start subprocess.'</span>);
 });</code></pre>
 <p>Certain platforms (macOS, Linux) will use the value of <code>argv[0]</code> for the process
 title while others (Windows, SunOS) will use <code>command</code>.</p>
@@ -15905,7 +16610,18 @@ title while others (Windows, SunOS) will use <code>command</code>.</p>
 <code>process.argv[0]</code> in a Node.js child process will not match the <code>argv0</code>
 parameter passed to <code>spawn</code> from the parent, retrieve it with the
 <code>process.argv0</code> property instead.</p>
-<h4><code>options.detached</code><span><a class="mark" href="#child_process_options_detached" id="child_process_options_detached">#</a></span></h4>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except
+the error passed to the callback will be an <code>AbortError</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> grep = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>], { signal });
+grep.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-comment">// This will be called with err being an AbortError if the controller aborts</span>
+});
+controller.<span class="hljs-title function_">abort</span>(); <span class="hljs-comment">// Stops the child process</span></code></pre>
+<h5><code>options.detached</code><span><a class="mark" href="#child_process_options_detached" id="child_process_options_detached">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.7.10</span>
 </div>
@@ -15932,29 +16648,31 @@ controlling terminal.</p>
 <code>stdio</code> file descriptors, in order to ignore the parent's termination:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(process.argv[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(process.<span class="hljs-property">argv</span>[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
   <span class="hljs-attr">detached</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">stdio</span>: <span class="hljs-string">'ignore'</span>
 });
 
-subprocess.unref();</code></pre>
+subprocess.<span class="hljs-title function_">unref</span>();</code></pre>
 <p>Alternatively one can redirect the child process' output into files:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> out = fs.openSync(<span class="hljs-string">'./out.log'</span>, <span class="hljs-string">'a'</span>);
-<span class="hljs-keyword">const</span> err = fs.openSync(<span class="hljs-string">'./out.log'</span>, <span class="hljs-string">'a'</span>);
+<span class="hljs-keyword">const</span> out = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'./out.log'</span>, <span class="hljs-string">'a'</span>);
+<span class="hljs-keyword">const</span> err = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'./out.log'</span>, <span class="hljs-string">'a'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(<span class="hljs-string">'prg'</span>, [], {
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'prg'</span>, [], {
   <span class="hljs-attr">detached</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">stdio</span>: [ <span class="hljs-string">'ignore'</span>, out, err ]
 });
 
-subprocess.unref();</code></pre>
-<h4><code>options.stdio</code><span><a class="mark" href="#child_process_options_stdio" id="child_process_options_stdio">#</a></span></h4>
+subprocess.<span class="hljs-title function_">unref</span>();</code></pre>
+<h5><code>options.stdio</code><span><a class="mark" href="#child_process_options_stdio" id="child_process_options_stdio">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Added the <code>overlapped</code> stdio flag.</p></td></tr>
 <tr><td>v3.3.1</td>
 <td><p>The value <code>0</code> is now accepted as a file descriptor.</p></td></tr>
 <tr><td>v0.7.10</td>
@@ -15966,11 +16684,12 @@ subprocess.unref();</code></pre>
 between the parent and child process. By default, the child's stdin, stdout,
 and stderr are redirected to corresponding <a href="#child_process_subprocess_stdin"><code>subprocess.stdin</code></a>,
 <a href="#child_process_subprocess_stdout"><code>subprocess.stdout</code></a>, and <a href="#child_process_subprocess_stderr"><code>subprocess.stderr</code></a> streams on the
-<a href="#child_process_child_process"><code>ChildProcess</code></a> object. This is equivalent to setting the <code>options.stdio</code>
+<a href="#child_process_class_childprocess"><code>ChildProcess</code></a> object. This is equivalent to setting the <code>options.stdio</code>
 equal to <code>['pipe', 'pipe', 'pipe']</code>.</p>
 <p>For convenience, <code>options.stdio</code> may be one of the following strings:</p>
 <ul>
 <li><code>'pipe'</code>: equivalent to <code>['pipe', 'pipe', 'pipe']</code> (the default)</li>
+<li><code>'overlapped'</code>: equivalent to <code>['overlapped', 'overlapped', 'overlapped']</code></li>
 <li><code>'ignore'</code>: equivalent to <code>['ignore', 'ignore', 'ignore']</code></li>
 <li><code>'inherit'</code>: equivalent to <code>['inherit', 'inherit', 'inherit']</code> or <code>[0, 1, 2]</code></li>
 </ul>
@@ -15987,8 +16706,16 @@ created for fds 0, 1, and 2 are also available as <a href="#child_process_subpro
 <a href="#child_process_subprocess_stdout"><code>subprocess.stdout</code></a> and <a href="#child_process_subprocess_stderr"><code>subprocess.stderr</code></a>, respectively.</p>
 </li>
 <li>
+<p><code>'overlapped'</code>: Same as <code>'pipe'</code> except that the <code>FILE_FLAG_OVERLAPPED</code> flag
+is set on the handle. This is necessary for overlapped I/O on the child
+process's stdio handles. See the
+<a href="https://docs.microsoft.com/en-us/windows/win32/fileio/synchronous-and-asynchronous-i-o">docs</a>
+for more details. This is exactly the same as <code>'pipe'</code> on non-Windows
+systems.</p>
+</li>
+<li>
 <p><code>'ipc'</code>: Create an IPC channel for passing messages/file descriptors
-between parent and child. A <a href="#child_process_child_process"><code>ChildProcess</code></a> may have at most one IPC
+between parent and child. A <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> may have at most one IPC
 stdio file descriptor. Setting this option enables the
 <a href="#child_process_subprocess_send_message_sendhandle_options_callback"><code>subprocess.send()</code></a> method. If the child is a Node.js process, the
 presence of an IPC channel will enable <a href="#process_process_send_message_sendhandle_options_callback"><code>process.send()</code></a> and
@@ -16033,14 +16760,14 @@ default is <code>'ignore'</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
 <span class="hljs-comment">// Child will use parent's stdios.</span>
-spawn(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: <span class="hljs-string">'inherit'</span> });
+<span class="hljs-title function_">spawn</span>(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: <span class="hljs-string">'inherit'</span> });
 
 <span class="hljs-comment">// Spawn child sharing only stderr.</span>
-spawn(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'pipe'</span>, <span class="hljs-string">'pipe'</span>, process.stderr] });
+<span class="hljs-title function_">spawn</span>(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'pipe'</span>, <span class="hljs-string">'pipe'</span>, process.<span class="hljs-property">stderr</span>] });
 
 <span class="hljs-comment">// Open an extra fd=4, to interact with programs presenting a</span>
 <span class="hljs-comment">// startd-style interface.</span>
-spawn(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'pipe'</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>, <span class="hljs-string">'pipe'</span>] });</code></pre>
+<span class="hljs-title function_">spawn</span>(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'pipe'</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>, <span class="hljs-string">'pipe'</span>] });</code></pre>
 <p><em>It is worth noting that when an IPC channel is established between the
 parent and child processes, and the child is a Node.js process, the child
 is launched with the IPC channel unreferenced (using <code>unref()</code>) until the
@@ -16053,7 +16780,7 @@ from the child. Applications with a large memory footprint may find frequent
 <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> calls to be a bottleneck. For more information,
 see <a href="https://bugs.chromium.org/p/v8/issues/detail?id=7381">V8 issue 7381</a>.</p>
 <p>See also: <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a> and <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p>
-<h2>Synchronous process creation<span><a class="mark" href="#child_process_synchronous_process_creation" id="child_process_synchronous_process_creation">#</a></span></h2>
+</section><section><h3>Synchronous process creation<span><a class="mark" href="#child_process_synchronous_process_creation" id="child_process_synchronous_process_creation">#</a></span></h3>
 <p>The <a href="#child_process_child_process_spawnsync_command_args_options"><code>child_process.spawnSync()</code></a>, <a href="#child_process_child_process_execsync_command_options"><code>child_process.execSync()</code></a>, and
 <a href="#child_process_child_process_execfilesync_file_args_options"><code>child_process.execFileSync()</code></a> methods are synchronous and will block the
 Node.js event loop, pausing execution of any additional code until the spawned
@@ -16061,11 +16788,13 @@ process exits.</p>
 <p>Blocking calls like these are mostly useful for simplifying general-purpose
 scripting tasks and for simplifying the loading/processing of application
 configuration at startup.</p>
-<h3><code>child_process.execFileSync(file[, args][, options])</code><span><a class="mark" href="#child_process_child_process_execfilesync_file_args_options" id="child_process_child_process_execfilesync_file_args_options">#</a></span></h3>
+<h4><code>child_process.execFileSync(file[, args][, options])</code><span><a class="mark" href="#child_process_child_process_execfilesync_file_args_options" id="child_process_child_process_execfilesync_file_args_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>input</code> option can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v8.8.0</td>
@@ -16084,7 +16813,7 @@ configuration at startup.</p>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The value which will be passed
 as stdin to the spawned process. Supplying this value will override
 <code>stdio[0]</code>.</li>
@@ -16127,11 +16856,13 @@ exited.</p>
 <p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this
 function. Any input containing shell metacharacters may be used to trigger
 arbitrary command execution.</strong></p>
-<h3><code>child_process.execSync(command[, options])</code><span><a class="mark" href="#child_process_child_process_execsync_command_options" id="child_process_child_process_execsync_command_options">#</a></span></h3>
+<h4><code>child_process.execSync(command[, options])</code><span><a class="mark" href="#child_process_child_process_execsync_command_options" id="child_process_child_process_execsync_command_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>input</code> option can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v8.8.0</td>
@@ -16147,7 +16878,7 @@ arbitrary command execution.</strong></p>
 <li><code>command</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The command to run.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The value which will be passed
 as stdin to the spawned process. Supplying this value will override
 <code>stdio[0]</code>.</li>
@@ -16188,21 +16919,23 @@ The <a href="#errors_class_error"><code>Error</code></a> object will contain the
 <a href="#child_process_child_process_spawnsync_command_args_options"><code>child_process.spawnSync()</code></a>.</p>
 <p><strong>Never pass unsanitized user input to this function. Any input containing shell
 metacharacters may be used to trigger arbitrary command execution.</strong></p>
-<h3><code>child_process.spawnSync(command[, args][, options])</code><span><a class="mark" href="#child_process_child_process_spawnsync_command_args_options" id="child_process_child_process_spawnsync_command_args_options">#</a></span></h3>
+<h4><code>child_process.spawnSync(command[, args][, options])</code><span><a class="mark" href="#child_process_child_process_spawnsync_command_args_options" id="child_process_child_process_spawnsync_command_args_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>input</code> option can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v8.8.0</td>
 <td><p>The <code>windowsHide</code> option is supported now.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>input</code> option can now be a <code>Uint8Array</code>.</p></td></tr>
-<tr><td>v6.2.1, v4.5.0</td>
-<td><p>The <code>encoding</code> option can now explicitly be set to <code>buffer</code>.</p></td></tr>
 <tr><td>v5.7.0</td>
 <td><p>The <code>shell</code> option is supported now.</p></td></tr>
+<tr><td>v6.2.1, v4.5.0</td>
+<td><p>The <code>encoding</code> option can now explicitly be set to <code>buffer</code>.</p></td></tr>
 <tr><td>v0.11.12</td>
 <td><p><span>Added in: v0.11.12</span></p></td></tr>
 </tbody></table>
@@ -16213,7 +16946,7 @@ metacharacters may be used to trigger arbitrary command execution.</strong></p>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The value which will be passed
 as stdin to the spawned process. Supplying this value will override
 <code>stdio[0]</code>.</li>
@@ -16268,7 +17001,7 @@ exited.</p>
 <p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this
 function. Any input containing shell metacharacters may be used to trigger
 arbitrary command execution.</strong></p>
-<h2>Class: <code>ChildProcess</code><span><a class="mark" href="#child_process_class_childprocess" id="child_process_class_childprocess">#</a></span></h2>
+</section><section><h3>Class: <code>ChildProcess</code><span><a class="mark" href="#child_process_class_childprocess" id="child_process_class_childprocess">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.2.0</span>
 </div>
@@ -16280,7 +17013,7 @@ arbitrary command execution.</strong></p>
 use the <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>, <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a>,
 <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a>, or <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a> methods to create
 instances of <code>ChildProcess</code>.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#child_process_event_close" id="child_process_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#child_process_event_close" id="child_process_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -16288,24 +17021,26 @@ instances of <code>ChildProcess</code>.</p>
 <li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The exit code if the child exited on its own.</li>
 <li><code>signal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The signal by which the child process was terminated.</li>
 </ul>
-<p>The <code>'close'</code> event is emitted when the stdio streams of a child process have
-been closed. This is distinct from the <a href="#child_process_event_exit"><code>'exit'</code></a> event, since multiple
-processes might share the same stdio streams.</p>
+<p>The <code>'close'</code> event is emitted after a process has ended <em>and</em> the stdio
+streams of a child process have been closed. This is distinct from the
+<a href="#child_process_event_exit"><code>'exit'</code></a> event, since multiple processes might share the same stdio
+streams. The <code>'close'</code> event will always emit after <a href="#child_process_event_exit"><code>'exit'</code></a> was
+already emitted, or <a href="#child_process_event_error"><code>'error'</code></a> if the child failed to spawn.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> ls = spawn(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
+<span class="hljs-keyword">const</span> ls = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
 
-ls.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`child process close all stdio with code <span class="hljs-subst">${code}</span>`</span>);
+ls.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`child process close all stdio with code <span class="hljs-subst">${code}</span>`</span>);
 });
 
-ls.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
+ls.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
-<h3>Event: <code>'disconnect'</code><span><a class="mark" href="#child_process_event_disconnect" id="child_process_event_disconnect">#</a></span></h3>
+<h4>Event: <code>'disconnect'</code><span><a class="mark" href="#child_process_event_disconnect" id="child_process_event_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -16314,7 +17049,7 @@ ls.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<spa
 <a href="#process_process_disconnect"><code>process.disconnect()</code></a> in child process. After disconnecting it is no longer
 possible to send or receive messages, and the <a href="#child_process_subprocess_connected"><code>subprocess.connected</code></a>
 property is <code>false</code>.</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#child_process_event_error" id="child_process_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#child_process_event_error" id="child_process_event_error">#</a></span></h4>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> The error.</li>
 </ul>
@@ -16328,7 +17063,7 @@ property is <code>false</code>.</p>
 listening to both the <code>'exit'</code> and <code>'error'</code> events, guard
 against accidentally invoking handler functions multiple times.</p>
 <p>See also <a href="#child_process_subprocess_kill_signal"><code>subprocess.kill()</code></a> and <a href="#child_process_subprocess_send_message_sendhandle_options_callback"><code>subprocess.send()</code></a>.</p>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#child_process_event_exit" id="child_process_event_exit">#</a></span></h3>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#child_process_event_exit" id="child_process_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -16347,7 +17082,7 @@ processes will not terminate immediately due to receipt of those signals.
 Rather, Node.js will perform a sequence of cleanup actions and then will
 re-raise the handled signal.</p>
 <p>See <a href="http://man7.org/linux/man-pages/man2/waitpid.2.html"><code>waitpid(2)</code></a>.</p>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#child_process_event_message" id="child_process_event_message">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#child_process_event_message" id="child_process_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -16364,16 +17099,49 @@ message might not be the same as what is originally sent.</p>
 child process, the <code>message</code> argument can contain data that JSON is not able
 to represent.
 See <a href="#child_process_advanced_serialization">Advanced serialization</a> for more details.</p>
-<h3><code>subprocess.channel</code><span><a class="mark" href="#child_process_subprocess_channel" id="child_process_subprocess_channel">#</a></span></h3>
+<h4>Event: <code>'spawn'</code><span><a class="mark" href="#child_process_event_spawn" id="child_process_event_spawn">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v7.1.0</span>
+<span>Added in: v14.17.0</span>
+</div>
+<p>The <code>'spawn'</code> event is emitted once the child process has spawned successfully.
+If the child process does not spawn successfully, the <code>'spawn'</code> event is not
+emitted and the <code>'error'</code> event is emitted instead.</p>
+<p>If emitted, the <code>'spawn'</code> event comes before all other events and before any
+data is received via <code>stdout</code> or <code>stderr</code>.</p>
+<p>The <code>'spawn'</code> event will fire regardless of whether an error occurs <strong>within</strong>
+the spawned process. For example, if <code>bash some-command</code> spawns successfully,
+the <code>'spawn'</code> event will fire, though <code>bash</code> may fail to spawn <code>some-command</code>.
+This caveat also applies when using <code>{ shell: true }</code>.</p>
+<h4><code>subprocess.channel</code><span><a class="mark" href="#child_process_subprocess_channel" id="child_process_subprocess_channel">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The object no longer accidentally exposes native C++ bindings.</p></td></tr>
+<tr><td>v7.1.0</td>
+<td><p><span>Added in: v7.1.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> A pipe representing the IPC channel to the child process.</li>
 </ul>
 <p>The <code>subprocess.channel</code> property is a reference to the child's IPC channel. If
 no IPC channel currently exists, this property is <code>undefined</code>.</p>
-<h3><code>subprocess.connected</code><span><a class="mark" href="#child_process_subprocess_connected" id="child_process_subprocess_connected">#</a></span></h3>
+<h5><code>subprocess.channel.ref()</code><span><a class="mark" href="#child_process_subprocess_channel_ref" id="child_process_subprocess_channel_ref">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v7.1.0</span>
+</div>
+<p>This method makes the IPC channel keep the event loop of the parent process
+running if <code>.unref()</code> has been called before.</p>
+<h5><code>subprocess.channel.unref()</code><span><a class="mark" href="#child_process_subprocess_channel_unref" id="child_process_subprocess_channel_unref">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v7.1.0</span>
+</div>
+<p>This method makes the IPC channel not keep the event loop of the parent process
+running, and lets it finish even while the channel is open.</p>
+<h4><code>subprocess.connected</code><span><a class="mark" href="#child_process_subprocess_connected" id="child_process_subprocess_connected">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -16383,7 +17151,7 @@ no IPC channel currently exists, this property is <code>undefined</code>.</p>
 <p>The <code>subprocess.connected</code> property indicates whether it is still possible to
 send and receive messages from a child process. When <code>subprocess.connected</code> is
 <code>false</code>, it is no longer possible to send or receive messages.</p>
-<h3><code>subprocess.disconnect()</code><span><a class="mark" href="#child_process_subprocess_disconnect" id="child_process_subprocess_disconnect">#</a></span></h3>
+<h4><code>subprocess.disconnect()</code><span><a class="mark" href="#child_process_subprocess_disconnect" id="child_process_subprocess_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -16398,13 +17166,13 @@ calling <code>subprocess.disconnect()</code>.</p>
 <p>When the child process is a Node.js instance (e.g. spawned using
 <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>), the <code>process.disconnect()</code> method can be invoked
 within the child process to close the IPC channel as well.</p>
-<h3><code>subprocess.exitCode</code><span><a class="mark" href="#child_process_subprocess_exitcode" id="child_process_subprocess_exitcode">#</a></span></h3>
+<h4><code>subprocess.exitCode</code><span><a class="mark" href="#child_process_subprocess_exitcode" id="child_process_subprocess_exitcode">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The <code>subprocess.exitCode</code> property indicates the exit code of the child process.
 If the child process is still running, the field will be <code>null</code>.</p>
-<h3><code>subprocess.kill([signal])</code><span><a class="mark" href="#child_process_subprocess_kill_signal" id="child_process_subprocess_kill_signal">#</a></span></h3>
+<h4><code>subprocess.kill([signal])</code><span><a class="mark" href="#child_process_subprocess_kill_signal" id="child_process_subprocess_kill_signal">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -16417,16 +17185,16 @@ argument is given, the process will be sent the <code>'SIGTERM'</code> signal. S
 <a href="http://man7.org/linux/man-pages/man7/signal.7.html"><code>signal(7)</code></a> for a list of available signals. This function returns <code>true</code> if
 <a href="http://man7.org/linux/man-pages/man2/kill.2.html"><code>kill(2)</code></a> succeeds, and <code>false</code> otherwise.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> grep = spawn(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
+<span class="hljs-keyword">const</span> grep = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
 
-grep.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code, signal</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(
+grep.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code, signal</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
     <span class="hljs-string">`child process terminated due to receipt of signal <span class="hljs-subst">${signal}</span>`</span>);
 });
 
 <span class="hljs-comment">// Send SIGHUP to process.</span>
-grep.kill(<span class="hljs-string">'SIGHUP'</span>);</code></pre>
-<p>The <a href="#child_process_child_process"><code>ChildProcess</code></a> object may emit an <a href="#child_process_event_error"><code>'error'</code></a> event if the signal
+grep.<span class="hljs-title function_">kill</span>(<span class="hljs-string">'SIGHUP'</span>);</code></pre>
+<p>The <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> object may emit an <a href="#child_process_event_error"><code>'error'</code></a> event if the signal
 cannot be delivered. Sending a signal to a child process that has already exited
 is not an error but may have unforeseen consequences. Specifically, if the
 process identifier (PID) has been reassigned to another process, the signal will
@@ -16434,28 +17202,32 @@ be delivered to that process instead which can have unexpected results.</p>
 <p>While the function is called <code>kill</code>, the signal delivered to the child process
 may not actually terminate the process.</p>
 <p>See <a href="http://man7.org/linux/man-pages/man2/kill.2.html"><code>kill(2)</code></a> for reference.</p>
+<p>On Windows, where POSIX signals do not exist, the <code>signal</code> argument will be
+ignored, and the process will be killed forcefully and abruptly (similar to
+<code>'SIGKILL'</code>).
+See <a href="#process_signal_events">Signal Events</a> for more details.</p>
 <p>On Linux, child processes of child processes will not be terminated
 when attempting to kill their parent. This is likely to happen when running a
 new process in a shell or with the use of the <code>shell</code> option of <code>ChildProcess</code>:</p>
 <pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
 <span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(
   <span class="hljs-string">'sh'</span>,
   [
     <span class="hljs-string">'-c'</span>,
     <span class="hljs-string">`node -e "setInterval(() => {
       console.log(process.pid, 'is alive')
-    }, 500);"`</span>
+    }, 500);"`</span>,
   ], {
     <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'inherit'</span>, <span class="hljs-string">'inherit'</span>, <span class="hljs-string">'inherit'</span>]
   }
 );
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  subprocess.kill(); <span class="hljs-comment">// Does not terminate the Node.js process in the shell.</span>
+  subprocess.<span class="hljs-title function_">kill</span>(); <span class="hljs-comment">// Does not terminate the Node.js process in the shell.</span>
 }, <span class="hljs-number">2000</span>);</code></pre>
-<h3><code>subprocess.killed</code><span><a class="mark" href="#child_process_subprocess_killed" id="child_process_subprocess_killed">#</a></span></h3>
+<h4><code>subprocess.killed</code><span><a class="mark" href="#child_process_subprocess_killed" id="child_process_subprocess_killed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -16466,20 +17238,22 @@ send a signal to the child process.</li>
 <p>The <code>subprocess.killed</code> property indicates whether the child process
 successfully received a signal from <code>subprocess.kill()</code>. The <code>killed</code> property
 does not indicate that the child process has been terminated.</p>
-<h3><code>subprocess.pid</code><span><a class="mark" href="#child_process_subprocess_pid" id="child_process_subprocess_pid">#</a></span></h3>
+<h4><code>subprocess.pid</code><span><a class="mark" href="#child_process_subprocess_pid" id="child_process_subprocess_pid">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
 </ul>
-<p>Returns the process identifier (PID) of the child process.</p>
+<p>Returns the process identifier (PID) of the child process. If the child process
+fails to spawn due to errors, then the value is <code>undefined</code> and <code>error</code> is
+emitted.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> grep = spawn(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
+<span class="hljs-keyword">const</span> grep = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Spawned child pid: <span class="hljs-subst">${grep.pid}</span>`</span>);
-grep.stdin.end();</code></pre>
-<h3><code>subprocess.ref()</code><span><a class="mark" href="#child_process_subprocess_ref" id="child_process_subprocess_ref">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Spawned child pid: <span class="hljs-subst">${grep.pid}</span>`</span>);
+grep.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">end</span>();</code></pre>
+<h4><code>subprocess.ref()</code><span><a class="mark" href="#child_process_subprocess_ref" id="child_process_subprocess_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.10</span>
 </div>
@@ -16488,14 +17262,14 @@ restore the removed reference count for the child process, forcing the parent
 to wait for the child to exit before exiting itself.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(process.argv[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(process.<span class="hljs-property">argv</span>[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
   <span class="hljs-attr">detached</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">stdio</span>: <span class="hljs-string">'ignore'</span>
 });
 
-subprocess.unref();
-subprocess.ref();</code></pre>
-<h3><code>subprocess.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#child_process_subprocess_send_message_sendhandle_options_callback" id="child_process_subprocess_send_message_sendhandle_options_callback">#</a></span></h3>
+subprocess.<span class="hljs-title function_">unref</span>();
+subprocess.<span class="hljs-title function_">ref</span>();</code></pre>
+<h4><code>subprocess.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#child_process_subprocess_send_message_sendhandle_options_callback" id="child_process_subprocess_send_message_sendhandle_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -16534,21 +17308,21 @@ Node.js instance, these messages can be received via the <a href="#process_event
 message might not be the same as what is originally sent.</p>
 <p>For example, in the parent script:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cp = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> n = cp.fork(<span class="hljs-string">`<span class="hljs-subst">${__dirname}</span>/sub.js`</span>);
+<span class="hljs-keyword">const</span> n = cp.<span class="hljs-title function_">fork</span>(<span class="hljs-string">`<span class="hljs-subst">${__dirname}</span>/sub.js`</span>);
 
-n.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'PARENT got message:'</span>, m);
+n.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'PARENT got message:'</span>, m);
 });
 
 <span class="hljs-comment">// Causes the child to print: CHILD got message: { hello: 'world' }</span>
-n.send({ <span class="hljs-attr">hello</span>: <span class="hljs-string">'world'</span> });</code></pre>
+n.<span class="hljs-title function_">send</span>({ <span class="hljs-attr">hello</span>: <span class="hljs-string">'world'</span> });</code></pre>
 <p>And then the child script, <code>'sub.js'</code> might look like this:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'CHILD got message:'</span>, m);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'CHILD got message:'</span>, m);
 });
 
 <span class="hljs-comment">// Causes the parent to print: PARENT got message: { foo: 'bar', baz: null }</span>
-process.send({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: <span class="hljs-literal">NaN</span> });</code></pre>
+process.<span class="hljs-title function_">send</span>({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: <span class="hljs-title class_">Na</span>N });</code></pre>
 <p>Child Node.js processes will have a <a href="#process_process_send_message_sendhandle_options_callback"><code>process.send()</code></a> method of their own
 that allows the child to send messages back to the parent.</p>
 <p>There is a special case when sending a <code>{cmd: 'NODE_foo'}</code> message. Messages
@@ -16567,30 +17341,30 @@ and buffered in the socket will not be sent to the child.</p>
 sent but before the child may have received it. The function is called with a
 single argument: <code>null</code> on success, or an <a href="#errors_class_error"><code>Error</code></a> object on failure.</p>
 <p>If no <code>callback</code> function is provided and the message cannot be sent, an
-<code>'error'</code> event will be emitted by the <a href="#child_process_child_process"><code>ChildProcess</code></a> object. This can
+<code>'error'</code> event will be emitted by the <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> object. This can
 happen, for instance, when the child process has already exited.</p>
 <p><code>subprocess.send()</code> will return <code>false</code> if the channel has closed or when the
 backlog of unsent messages exceeds a threshold that makes it unwise to send
 more. Otherwise, the method returns <code>true</code>. The <code>callback</code> function can be
 used to implement flow control.</p>
-<h4>Example: sending a server object<span><a class="mark" href="#child_process_example_sending_a_server_object" id="child_process_example_sending_a_server_object">#</a></span></h4>
+<h5>Example: sending a server object<span><a class="mark" href="#child_process_example_sending_a_server_object" id="child_process_example_sending_a_server_object">#</a></span></h5>
 <p>The <code>sendHandle</code> argument can be used, for instance, to pass the handle of
 a TCP server object to the child process as illustrated in the example below:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> subprocess = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).fork(<span class="hljs-string">'subprocess.js'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> subprocess = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).<span class="hljs-title function_">fork</span>(<span class="hljs-string">'subprocess.js'</span>);
 
 <span class="hljs-comment">// Open up the server object and send the handle.</span>
-<span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer();
-server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  socket.end(<span class="hljs-string">'handled by parent'</span>);
+<span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'handled by parent'</span>);
 });
-server.listen(<span class="hljs-number">1337</span>, <span class="hljs-function">() =></span> {
-  subprocess.send(<span class="hljs-string">'server'</span>, server);
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>, <span class="hljs-function">() =></span> {
+  subprocess.<span class="hljs-title function_">send</span>(<span class="hljs-string">'server'</span>, server);
 });</code></pre>
 <p>The child would then receive the server object as:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m, server</span>) =></span> {
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m, server</span>) =></span> {
   <span class="hljs-keyword">if</span> (m === <span class="hljs-string">'server'</span>) {
-    server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-      socket.end(<span class="hljs-string">'handled by child'</span>);
+    server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+      socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'handled by child'</span>);
     });
   }
 });</code></pre>
@@ -16601,37 +17375,37 @@ module servers use exactly the same workflow with the exceptions of listening on
 a <code>'message'</code> event instead of <code>'connection'</code> and using <code>server.bind()</code> instead
 of <code>server.listen()</code>. This is, however, currently only supported on Unix
 platforms.</p>
-<h4>Example: sending a socket object<span><a class="mark" href="#child_process_example_sending_a_socket_object" id="child_process_example_sending_a_socket_object">#</a></span></h4>
+<h5>Example: sending a socket object<span><a class="mark" href="#child_process_example_sending_a_socket_object" id="child_process_example_sending_a_socket_object">#</a></span></h5>
 <p>Similarly, the <code>sendHandler</code> argument can be used to pass the handle of a
 socket to the child process. The example below spawns two children that each
 handle connections with "normal" or "special" priority:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { fork } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> normal = fork(<span class="hljs-string">'subprocess.js'</span>, [<span class="hljs-string">'normal'</span>]);
-<span class="hljs-keyword">const</span> special = fork(<span class="hljs-string">'subprocess.js'</span>, [<span class="hljs-string">'special'</span>]);
+<span class="hljs-keyword">const</span> normal = <span class="hljs-title function_">fork</span>(<span class="hljs-string">'subprocess.js'</span>, [<span class="hljs-string">'normal'</span>]);
+<span class="hljs-keyword">const</span> special = <span class="hljs-title function_">fork</span>(<span class="hljs-string">'subprocess.js'</span>, [<span class="hljs-string">'special'</span>]);
 
 <span class="hljs-comment">// Open up the server and send sockets to child. Use pauseOnConnect to prevent</span>
 <span class="hljs-comment">// the sockets from being read before they are sent to the child process.</span>
-<span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer({ <span class="hljs-attr">pauseOnConnect</span>: <span class="hljs-literal">true</span> });
-server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+<span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-title function_">createServer</span>({ <span class="hljs-attr">pauseOnConnect</span>: <span class="hljs-literal">true</span> });
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
 
   <span class="hljs-comment">// If this is special priority...</span>
-  <span class="hljs-keyword">if</span> (socket.remoteAddress === <span class="hljs-string">'74.125.127.100'</span>) {
-    special.send(<span class="hljs-string">'socket'</span>, socket);
+  <span class="hljs-keyword">if</span> (socket.<span class="hljs-property">remoteAddress</span> === <span class="hljs-string">'74.125.127.100'</span>) {
+    special.<span class="hljs-title function_">send</span>(<span class="hljs-string">'socket'</span>, socket);
     <span class="hljs-keyword">return</span>;
   }
   <span class="hljs-comment">// This is normal priority.</span>
-  normal.send(<span class="hljs-string">'socket'</span>, socket);
+  normal.<span class="hljs-title function_">send</span>(<span class="hljs-string">'socket'</span>, socket);
 });
-server.listen(<span class="hljs-number">1337</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
 <p>The <code>subprocess.js</code> would receive the socket handle as the second argument
 passed to the event callback function:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m, socket</span>) =></span> {
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m, socket</span>) =></span> {
   <span class="hljs-keyword">if</span> (m === <span class="hljs-string">'socket'</span>) {
     <span class="hljs-keyword">if</span> (socket) {
       <span class="hljs-comment">// Check that the client socket exists.</span>
       <span class="hljs-comment">// It is possible for the socket to be closed between the time it is</span>
       <span class="hljs-comment">// sent and the time it is received in the child process.</span>
-      socket.end(<span class="hljs-string">`Request handled with <span class="hljs-subst">${process.argv[<span class="hljs-number">2</span>]}</span> priority`</span>);
+      socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">`Request handled with <span class="hljs-subst">${process.argv[<span class="hljs-number">2</span>]}</span> priority`</span>);
     }
   }
 });</code></pre>
@@ -16640,19 +17414,19 @@ The parent cannot track when the socket is destroyed.</p>
 <p>Any <code>'message'</code> handlers in the subprocess should verify that <code>socket</code> exists,
 as the connection may have been closed during the time it takes to send the
 connection to the child.</p>
-<h3><code>subprocess.signalCode</code><span><a class="mark" href="#child_process_subprocess_signalcode" id="child_process_subprocess_signalcode">#</a></span></h3>
+<h4><code>subprocess.signalCode</code><span><a class="mark" href="#child_process_subprocess_signalcode" id="child_process_subprocess_signalcode">#</a></span></h4>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
 </ul>
-<p>The <code>subprocess.signalCode</code> property indicates the signal number received by
+<p>The <code>subprocess.signalCode</code> property indicates the signal received by
 the child process if any, else <code>null</code>.</p>
-<h3><code>subprocess.spawnargs</code><span><a class="mark" href="#child_process_subprocess_spawnargs" id="child_process_subprocess_spawnargs">#</a></span></h3>
+<h4><code>subprocess.spawnargs</code><span><a class="mark" href="#child_process_subprocess_spawnargs" id="child_process_subprocess_spawnargs">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
 </ul>
-<p>The <code>subprocess.spawnargs</code> property represents the full list of command line
+<p>The <code>subprocess.spawnargs</code> property represents the full list of command-line
 arguments the child process was launched with.</p>
-<h3><code>subprocess.spawnfile</code><span><a class="mark" href="#child_process_subprocess_spawnfile" id="child_process_subprocess_spawnfile">#</a></span></h3>
+<h4><code>subprocess.spawnfile</code><span><a class="mark" href="#child_process_subprocess_spawnfile" id="child_process_subprocess_spawnfile">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -16664,7 +17438,7 @@ For <a href="#child_process_child_process_spawn_command_args_options"><code>chil
 the executable file.
 For <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a>,  its value will be the name of the shell
 in which the child process is launched.</p>
-<h3><code>subprocess.stderr</code><span><a class="mark" href="#child_process_subprocess_stderr" id="child_process_subprocess_stderr">#</a></span></h3>
+<h4><code>subprocess.stderr</code><span><a class="mark" href="#child_process_subprocess_stderr" id="child_process_subprocess_stderr">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -16676,7 +17450,9 @@ in which the child process is launched.</p>
 then this will be <code>null</code>.</p>
 <p><code>subprocess.stderr</code> is an alias for <code>subprocess.stdio[2]</code>. Both properties will
 refer to the same value.</p>
-<h3><code>subprocess.stdin</code><span><a class="mark" href="#child_process_subprocess_stdin" id="child_process_subprocess_stdin">#</a></span></h3>
+<p>The <code>subprocess.stderr</code> property can be <code>null</code> if the child process could
+not be successfully spawned.</p>
+<h4><code>subprocess.stdin</code><span><a class="mark" href="#child_process_subprocess_stdin" id="child_process_subprocess_stdin">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -16690,7 +17466,9 @@ until this stream has been closed via <code>end()</code>.</p>
 then this will be <code>null</code>.</p>
 <p><code>subprocess.stdin</code> is an alias for <code>subprocess.stdio[0]</code>. Both properties will
 refer to the same value.</p>
-<h3><code>subprocess.stdio</code><span><a class="mark" href="#child_process_subprocess_stdio" id="child_process_subprocess_stdio">#</a></span></h3>
+<p>The <code>subprocess.stdin</code> property can be <code>undefined</code> if the child process could
+not be successfully spawned.</p>
+<h4><code>subprocess.stdio</code><span><a class="mark" href="#child_process_subprocess_stdio" id="child_process_subprocess_stdio">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.10</span>
 </div>
@@ -16709,23 +17487,25 @@ in the array are <code>null</code>.</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> child_process = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = child_process.spawn(<span class="hljs-string">'ls'</span>, {
+<span class="hljs-keyword">const</span> subprocess = child_process.<span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>, {
   <span class="hljs-attr">stdio</span>: [
     <span class="hljs-number">0</span>, <span class="hljs-comment">// Use parent's stdin for child.</span>
     <span class="hljs-string">'pipe'</span>, <span class="hljs-comment">// Pipe child's stdout to parent.</span>
-    fs.openSync(<span class="hljs-string">'err.out'</span>, <span class="hljs-string">'w'</span>) <span class="hljs-comment">// Direct child's stderr to a file.</span>
+    fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'err.out'</span>, <span class="hljs-string">'w'</span>), <span class="hljs-comment">// Direct child's stderr to a file.</span>
   ]
 });
 
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">0</span>], <span class="hljs-literal">null</span>);
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">0</span>], subprocess.stdin);
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">0</span>], <span class="hljs-literal">null</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">0</span>], subprocess.<span class="hljs-property">stdin</span>);
 
-assert(subprocess.stdout);
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">1</span>], subprocess.stdout);
+<span class="hljs-title function_">assert</span>(subprocess.<span class="hljs-property">stdout</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">1</span>], subprocess.<span class="hljs-property">stdout</span>);
 
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">2</span>], <span class="hljs-literal">null</span>);
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">2</span>], subprocess.stderr);</code></pre>
-<h3><code>subprocess.stdout</code><span><a class="mark" href="#child_process_subprocess_stdout" id="child_process_subprocess_stdout">#</a></span></h3>
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">2</span>], <span class="hljs-literal">null</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">2</span>], subprocess.<span class="hljs-property">stderr</span>);</code></pre>
+<p>The <code>subprocess.stdio</code> property can be <code>undefined</code> if the child process could
+not be successfully spawned.</p>
+<h4><code>subprocess.stdout</code><span><a class="mark" href="#child_process_subprocess_stdout" id="child_process_subprocess_stdout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -16739,12 +17519,14 @@ then this will be <code>null</code>.</p>
 refer to the same value.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(<span class="hljs-string">'ls'</span>);
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>);
 
-subprocess.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received chunk <span class="hljs-subst">${data}</span>`</span>);
+subprocess.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received chunk <span class="hljs-subst">${data}</span>`</span>);
 });</code></pre>
-<h3><code>subprocess.unref()</code><span><a class="mark" href="#child_process_subprocess_unref" id="child_process_subprocess_unref">#</a></span></h3>
+<p>The <code>subprocess.stdout</code> property can be <code>null</code> if the child process could
+not be successfully spawned.</p>
+<h4><code>subprocess.unref()</code><span><a class="mark" href="#child_process_subprocess_unref" id="child_process_subprocess_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.10</span>
 </div>
@@ -16756,31 +17538,31 @@ independently of the child, unless there is an established IPC channel between
 the child and the parent.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(process.argv[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(process.<span class="hljs-property">argv</span>[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
   <span class="hljs-attr">detached</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">stdio</span>: <span class="hljs-string">'ignore'</span>
 });
 
-subprocess.unref();</code></pre>
-<h2><code>maxBuffer</code> and Unicode<span><a class="mark" href="#child_process_maxbuffer_and_unicode" id="child_process_maxbuffer_and_unicode">#</a></span></h2>
+subprocess.<span class="hljs-title function_">unref</span>();</code></pre>
+</section><section><h3><code>maxBuffer</code> and Unicode<span><a class="mark" href="#child_process_maxbuffer_and_unicode" id="child_process_maxbuffer_and_unicode">#</a></span></h3>
 <p>The <code>maxBuffer</code> option specifies the largest number of bytes allowed on <code>stdout</code>
 or <code>stderr</code>. If this value is exceeded, then the child process is terminated.
 This impacts output that includes multibyte character encodings such as UTF-8 or
 UTF-16. For instance, <code>console.log('中文测试')</code> will send 13 UTF-8 encoded bytes
 to <code>stdout</code> although there are only 4 characters.</p>
-<h2>Shell requirements<span><a class="mark" href="#child_process_shell_requirements" id="child_process_shell_requirements">#</a></span></h2>
+</section><section><h3>Shell requirements<span><a class="mark" href="#child_process_shell_requirements" id="child_process_shell_requirements">#</a></span></h3>
 <p>The shell should understand the <code>-c</code> switch. If the shell is <code>'cmd.exe'</code>, it
-should understand the <code>/d /s /c</code> switches and command line parsing should be
+should understand the <code>/d /s /c</code> switches and command-line parsing should be
 compatible.</p>
-<h2>Default Windows shell<span><a class="mark" href="#child_process_default_windows_shell" id="child_process_default_windows_shell">#</a></span></h2>
+</section><section><h3>Default Windows shell<span><a class="mark" href="#child_process_default_windows_shell" id="child_process_default_windows_shell">#</a></span></h3>
 <p>Although Microsoft specifies <code>%COMSPEC%</code> must contain the path to
 <code>'cmd.exe'</code> in the root environment, child processes are not always subject to
 the same requirement. Thus, in <code>child_process</code> functions where a shell can be
 spawned, <code>'cmd.exe'</code> is used as a fallback if <code>process.env.ComSpec</code> is
 unavailable.</p>
-<h2>Advanced serialization<span><a class="mark" href="#child_process_advanced_serialization" id="child_process_advanced_serialization">#</a></span></h2>
+</section><section><h3>Advanced serialization<span><a class="mark" href="#child_process_advanced_serialization" id="child_process_advanced_serialization">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <p>Child processes support a serialization mechanism for IPC that is based on the
 <a href="#v8_serialization_api">serialization API of the <code>v8</code> module</a>, based on the
@@ -16793,11 +17575,12 @@ step. Additionally, performance may not be equivalent to that of JSON, depending
 on the structure of the passed data.
 Therefore, this feature requires opting in by setting the
 <code>serialization</code> option to <code>'advanced'</code> when calling <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>
-or <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p>
-<h1>Cluster<span><a class="mark" href="#cluster_cluster" id="cluster_cluster">#</a></span></h1>
+or <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p></section>
+        </section>
+<section><h2>Cluster<span><a class="mark" href="#cluster_cluster" id="cluster_cluster">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/cluster.js">lib/cluster.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/cluster.js">lib/cluster.js</a></p>
 <p>A single instance of Node.js runs in a single thread. To take advantage of
 multi-core systems, the user will sometimes want to launch a cluster of Node.js
 processes to handle the load.</p>
@@ -16805,38 +17588,38 @@ processes to handle the load.</p>
 server ports.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).cpus().length;
+<span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).<span class="hljs-title function_">cpus</span>().<span class="hljs-property">length</span>;
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Master <span class="hljs-subst">${process.pid}</span> is running`</span>);
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Master <span class="hljs-subst">${process.pid}</span> is running`</span>);
 
   <span class="hljs-comment">// Fork workers.</span>
   <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; numCPUs; i++) {
-    cluster.fork();
+    cluster.<span class="hljs-title function_">fork</span>();
   }
 
-  cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`worker <span class="hljs-subst">${worker.process.pid}</span> died`</span>);
+  cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`worker <span class="hljs-subst">${worker.process.pid}</span> died`</span>);
   });
 } <span class="hljs-keyword">else</span> {
   <span class="hljs-comment">// Workers can share any TCP connection</span>
   <span class="hljs-comment">// In this case it is an HTTP server</span>
-  http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    res.writeHead(<span class="hljs-number">200</span>);
-    res.end(<span class="hljs-string">'hello world\n'</span>);
-  }).listen(<span class="hljs-number">8000</span>);
+  http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+    res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'hello world\n'</span>);
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);
 
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Worker <span class="hljs-subst">${process.pid}</span> started`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Worker <span class="hljs-subst">${process.pid}</span> started`</span>);
 }</code></pre>
 <p>Running Node.js will now share port 8000 between the workers:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node server.js</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node server.js</span>
 Master 3596 is running
 Worker 4324 started
 Worker 4520 started
 Worker 6056 started
 Worker 5644 started</code></pre>
 <p>On Windows, it is not yet possible to set up a named pipe server in a worker.</p>
-<h2>How it works<span><a class="mark" href="#cluster_how_it_works" id="cluster_how_it_works">#</a></span></h2>
+<section><h3>How it works<span><a class="mark" href="#cluster_how_it_works" id="cluster_how_it_works">#</a></span></h3>
 
 <p>The worker processes are spawned using the <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a> method,
 so that they can communicate with the parent via IPC and pass server
@@ -16885,7 +17668,7 @@ automatically manage the number of workers, however. It is the application's
 responsibility to manage the worker pool based on its own needs.</p>
 <p>Although a primary use case for the <code>cluster</code> module is networking, it can
 also be used for other use cases requiring worker processes.</p>
-<h2>Class: <code>Worker</code><span><a class="mark" href="#cluster_class_worker" id="cluster_class_worker">#</a></span></h2>
+</section><section><h3>Class: <code>Worker</code><span><a class="mark" href="#cluster_class_worker" id="cluster_class_worker">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -16895,21 +17678,21 @@ also be used for other use cases requiring worker processes.</p>
 <p>A <code>Worker</code> object contains all public information and method about a worker.
 In the master it can be obtained using <code>cluster.workers</code>. In a worker
 it can be obtained using <code>cluster.worker</code>.</p>
-<h3>Event: <code>'disconnect'</code><span><a class="mark" href="#cluster_event_disconnect" id="cluster_event_disconnect">#</a></span></h3>
+<h4>Event: <code>'disconnect'</code><span><a class="mark" href="#cluster_event_disconnect" id="cluster_event_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>Similar to the <code>cluster.on('disconnect')</code> event, but specific to this worker.</p>
-<pre><code class="language-js">cluster.fork().on(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">cluster.<span class="hljs-title function_">fork</span>().<span class="hljs-title function_">on</span>(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Worker has disconnected</span>
 });</code></pre>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#cluster_event_error" id="cluster_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#cluster_event_error" id="cluster_event_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.3</span>
 </div>
 <p>This event is the same as the one provided by <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p>
 <p>Within a worker, <code>process.on('error')</code> may also be used.</p>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#cluster_event_exit" id="cluster_event_exit">#</a></span></h3>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#cluster_event_exit" id="cluster_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -16919,17 +17702,17 @@ it can be obtained using <code>cluster.worker</code>.</p>
 the process to be killed.</li>
 </ul>
 <p>Similar to the <code>cluster.on('exit')</code> event, but specific to this worker.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> worker = cluster.fork();
-worker.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code, signal</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> worker = cluster.<span class="hljs-title function_">fork</span>();
+worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code, signal</span>) =></span> {
   <span class="hljs-keyword">if</span> (signal) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`worker was killed by signal: <span class="hljs-subst">${signal}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`worker was killed by signal: <span class="hljs-subst">${signal}</span>`</span>);
   } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (code !== <span class="hljs-number">0</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`worker exited with error code: <span class="hljs-subst">${code}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`worker exited with error code: <span class="hljs-subst">${code}</span>`</span>);
   } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'worker success!'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'worker success!'</span>);
   }
 });</code></pre>
-<h3>Event: <code>'listening'</code><span><a class="mark" href="#cluster_event_listening" id="cluster_event_listening">#</a></span></h3>
+<h4>Event: <code>'listening'</code><span><a class="mark" href="#cluster_event_listening" id="cluster_event_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -16937,11 +17720,11 @@ worker.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(
 <li><code>address</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>Similar to the <code>cluster.on('listening')</code> event, but specific to this worker.</p>
-<pre><code class="language-js">cluster.fork().on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">address</span>) =></span> {
+<pre><code class="language-js">cluster.<span class="hljs-title function_">fork</span>().<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">address</span>) =></span> {
   <span class="hljs-comment">// Worker is listening</span>
 });</code></pre>
 <p>It is not emitted in the worker.</p>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#cluster_event_message" id="cluster_event_message">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#cluster_event_message" id="cluster_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -16957,52 +17740,52 @@ process of the number of HTTP requests received by the workers:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
 
   <span class="hljs-comment">// Keep track of http requests</span>
   <span class="hljs-keyword">let</span> numReqs = <span class="hljs-number">0</span>;
   <span class="hljs-built_in">setInterval</span>(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`numReqs = <span class="hljs-subst">${numReqs}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`numReqs = <span class="hljs-subst">${numReqs}</span>`</span>);
   }, <span class="hljs-number">1000</span>);
 
   <span class="hljs-comment">// Count requests</span>
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">messageHandler</span>(<span class="hljs-params">msg</span>) </span>{
-    <span class="hljs-keyword">if</span> (msg.cmd &#x26;&#x26; msg.cmd === <span class="hljs-string">'notifyRequest'</span>) {
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">messageHandler</span>(<span class="hljs-params">msg</span>) {
+    <span class="hljs-keyword">if</span> (msg.<span class="hljs-property">cmd</span> &#x26;&#x26; msg.<span class="hljs-property">cmd</span> === <span class="hljs-string">'notifyRequest'</span>) {
       numReqs += <span class="hljs-number">1</span>;
     }
   }
 
   <span class="hljs-comment">// Start workers and listen for messages containing notifyRequest</span>
-  <span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).cpus().length;
+  <span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).<span class="hljs-title function_">cpus</span>().<span class="hljs-property">length</span>;
   <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; numCPUs; i++) {
-    cluster.fork();
+    cluster.<span class="hljs-title function_">fork</span>();
   }
 
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> id <span class="hljs-keyword">in</span> cluster.workers) {
-    cluster.workers[id].on(<span class="hljs-string">'message'</span>, messageHandler);
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> id <span class="hljs-keyword">in</span> cluster.<span class="hljs-property">workers</span>) {
+    cluster.<span class="hljs-property">workers</span>[id].<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, messageHandler);
   }
 
 } <span class="hljs-keyword">else</span> {
 
   <span class="hljs-comment">// Worker processes have a http server.</span>
-  http.Server(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    res.writeHead(<span class="hljs-number">200</span>);
-    res.end(<span class="hljs-string">'hello world\n'</span>);
+  http.<span class="hljs-title class_">Server</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+    res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'hello world\n'</span>);
 
     <span class="hljs-comment">// Notify master about the request</span>
-    process.send({ <span class="hljs-attr">cmd</span>: <span class="hljs-string">'notifyRequest'</span> });
-  }).listen(<span class="hljs-number">8000</span>);
+    process.<span class="hljs-title function_">send</span>({ <span class="hljs-attr">cmd</span>: <span class="hljs-string">'notifyRequest'</span> });
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);
 }</code></pre>
-<h3>Event: <code>'online'</code><span><a class="mark" href="#cluster_event_online" id="cluster_event_online">#</a></span></h3>
+<h4>Event: <code>'online'</code><span><a class="mark" href="#cluster_event_online" id="cluster_event_online">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
 <p>Similar to the <code>cluster.on('online')</code> event, but specific to this worker.</p>
-<pre><code class="language-js">cluster.fork().on(<span class="hljs-string">'online'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">cluster.<span class="hljs-title function_">fork</span>().<span class="hljs-title function_">on</span>(<span class="hljs-string">'online'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Worker is online</span>
 });</code></pre>
 <p>It is not emitted in the worker.</p>
-<h3><code>worker.disconnect()</code><span><a class="mark" href="#cluster_worker_disconnect" id="cluster_worker_disconnect">#</a></span></h3>
+<h4><code>worker.disconnect()</code><span><a class="mark" href="#cluster_worker_disconnect" id="cluster_worker_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -17036,37 +17819,37 @@ it is <a href="#child_process_subprocess_disconnect"><code>disconnect()</code></
 may be useful to send a message, so application specific actions may be taken to
 close them. It also may be useful to implement a timeout, killing a worker if
 the <code>'disconnect'</code> event has not been emitted after some time.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-keyword">const</span> worker = cluster.fork();
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-keyword">const</span> worker = cluster.<span class="hljs-title function_">fork</span>();
   <span class="hljs-keyword">let</span> timeout;
 
-  worker.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">address</span>) =></span> {
-    worker.send(<span class="hljs-string">'shutdown'</span>);
-    worker.disconnect();
+  worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">address</span>) =></span> {
+    worker.<span class="hljs-title function_">send</span>(<span class="hljs-string">'shutdown'</span>);
+    worker.<span class="hljs-title function_">disconnect</span>();
     timeout = <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-      worker.kill();
+      worker.<span class="hljs-title function_">kill</span>();
     }, <span class="hljs-number">2000</span>);
   });
 
-  worker.on(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">() =></span> {
+  worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-built_in">clearTimeout</span>(timeout);
   });
 
-} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.isWorker) {
+} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isWorker</span>) {
   <span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-  <span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  <span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
     <span class="hljs-comment">// Connections never end</span>
   });
 
-  server.listen(<span class="hljs-number">8000</span>);
+  server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);
 
-  process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
+  process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
     <span class="hljs-keyword">if</span> (msg === <span class="hljs-string">'shutdown'</span>) {
       <span class="hljs-comment">// Initiate graceful close of any connections to server</span>
     }
   });
 }</code></pre>
-<h3><code>worker.exitedAfterDisconnect</code><span><a class="mark" href="#cluster_worker_exitedafterdisconnect" id="cluster_worker_exitedafterdisconnect">#</a></span></h3>
+<h4><code>worker.exitedAfterDisconnect</code><span><a class="mark" href="#cluster_worker_exitedafterdisconnect" id="cluster_worker_exitedafterdisconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -17079,15 +17862,15 @@ worker has not exited, it is <code>undefined</code>.</p>
 <p>The boolean <a href="#cluster_worker_exitedafterdisconnect"><code>worker.exitedAfterDisconnect</code></a> allows distinguishing between
 voluntary and accidental exit, the master may choose not to respawn a worker
 based on this value.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-  <span class="hljs-keyword">if</span> (worker.exitedAfterDisconnect === <span class="hljs-literal">true</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Oh, it was just voluntary – no need to worry'</span>);
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+  <span class="hljs-keyword">if</span> (worker.<span class="hljs-property">exitedAfterDisconnect</span> === <span class="hljs-literal">true</span>) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Oh, it was just voluntary – no need to worry'</span>);
   }
 });
 
 <span class="hljs-comment">// kill worker</span>
-worker.kill();</code></pre>
-<h3><code>worker.id</code><span><a class="mark" href="#cluster_worker_id" id="cluster_worker_id">#</a></span></h3>
+worker.<span class="hljs-title function_">kill</span>();</code></pre>
+<h4><code>worker.id</code><span><a class="mark" href="#cluster_worker_id" id="cluster_worker_id">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
@@ -17098,14 +17881,14 @@ worker.kill();</code></pre>
 <code>id</code>.</p>
 <p>While a worker is alive, this is the key that indexes it in
 <code>cluster.workers</code>.</p>
-<h3><code>worker.isConnected()</code><span><a class="mark" href="#cluster_worker_isconnected" id="cluster_worker_isconnected">#</a></span></h3>
+<h4><code>worker.isConnected()</code><span><a class="mark" href="#cluster_worker_isconnected" id="cluster_worker_isconnected">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
 <p>This function returns <code>true</code> if the worker is connected to its master via its
 IPC channel, <code>false</code> otherwise. A worker is connected to its master after it
 has been created. It is disconnected after the <code>'disconnect'</code> event is emitted.</p>
-<h3><code>worker.isDead()</code><span><a class="mark" href="#cluster_worker_isdead" id="cluster_worker_isdead">#</a></span></h3>
+<h4><code>worker.isDead()</code><span><a class="mark" href="#cluster_worker_isdead" id="cluster_worker_isdead">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -17113,32 +17896,32 @@ has been created. It is disconnected after the <code>'disconnect'</code> event i
 because of exiting or being signaled). Otherwise, it returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).cpus().length;
+<span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).<span class="hljs-title function_">cpus</span>().<span class="hljs-property">length</span>;
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Master <span class="hljs-subst">${process.pid}</span> is running`</span>);
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Master <span class="hljs-subst">${process.pid}</span> is running`</span>);
 
   <span class="hljs-comment">// Fork workers.</span>
   <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; numCPUs; i++) {
-    cluster.fork();
+    cluster.<span class="hljs-title function_">fork</span>();
   }
 
-  cluster.on(<span class="hljs-string">'fork'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'worker is dead:'</span>, worker.isDead());
+  cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'fork'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'worker is dead:'</span>, worker.<span class="hljs-title function_">isDead</span>());
   });
 
-  cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'worker is dead:'</span>, worker.isDead());
+  cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'worker is dead:'</span>, worker.<span class="hljs-title function_">isDead</span>());
   });
 } <span class="hljs-keyword">else</span> {
   <span class="hljs-comment">// Workers can share any TCP connection. In this case, it is an HTTP server.</span>
-  http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    res.writeHead(<span class="hljs-number">200</span>);
-    res.end(<span class="hljs-string">`Current process\n <span class="hljs-subst">${process.pid}</span>`</span>);
-    process.kill(process.pid);
-  }).listen(<span class="hljs-number">8000</span>);
+  http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+    res.<span class="hljs-title function_">end</span>(<span class="hljs-string">`Current process\n <span class="hljs-subst">${process.pid}</span>`</span>);
+    process.<span class="hljs-title function_">kill</span>(process.<span class="hljs-property">pid</span>);
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);
 }</code></pre>
-<h3><code>worker.kill([signal])</code><span><a class="mark" href="#cluster_worker_kill_signal" id="cluster_worker_kill_signal">#</a></span></h3>
+<h4><code>worker.kill([signal])</code><span><a class="mark" href="#cluster_worker_kill_signal" id="cluster_worker_kill_signal">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.12</span>
 </div>
@@ -17157,7 +17940,7 @@ If the graceful disconnect behavior is not needed, use <code>worker.process.kill
 <p>This method is aliased as <code>worker.destroy()</code> for backward compatibility.</p>
 <p>In a worker, <code>process.kill()</code> exists, but it is not this function;
 it is <a href="#process_process_kill_pid_signal"><code>kill()</code></a>.</p>
-<h3><code>worker.process</code><span><a class="mark" href="#cluster_worker_process" id="cluster_worker_process">#</a></span></h3>
+<h4><code>worker.process</code><span><a class="mark" href="#cluster_worker_process" id="cluster_worker_process">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -17171,7 +17954,7 @@ is stored.</p>
 <p>Workers will call <code>process.exit(0)</code> if the <code>'disconnect'</code> event occurs
 on <code>process</code> and <code>.exitedAfterDisconnect</code> is not <code>true</code>. This protects against
 accidental disconnection.</p>
-<h3><code>worker.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#cluster_worker_send_message_sendhandle_options_callback" id="cluster_worker_send_message_sendhandle_options_callback">#</a></span></h3>
+<h4><code>worker.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#cluster_worker_send_message_sendhandle_options_callback" id="cluster_worker_send_message_sendhandle_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -17204,16 +17987,16 @@ the following properties:
 <p>In a worker this sends a message to the master. It is identical to
 <code>process.send()</code>.</p>
 <p>This example will echo back all messages from the master:</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-keyword">const</span> worker = cluster.fork();
-  worker.send(<span class="hljs-string">'hi there'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-keyword">const</span> worker = cluster.<span class="hljs-title function_">fork</span>();
+  worker.<span class="hljs-title function_">send</span>(<span class="hljs-string">'hi there'</span>);
 
-} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.isWorker) {
-  process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
-    process.send(msg);
+} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isWorker</span>) {
+  process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
+    process.<span class="hljs-title function_">send</span>(msg);
   });
 }</code></pre>
-<h2>Event: <code>'disconnect'</code><span><a class="mark" href="#cluster_event_disconnect_1" id="cluster_event_disconnect_1">#</a></span></h2>
+</section><section><h3>Event: <code>'disconnect'</code><span><a class="mark" href="#cluster_event_disconnect_1" id="cluster_event_disconnect_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.9</span>
 </div>
@@ -17226,10 +18009,10 @@ worker exits gracefully, is killed, or is disconnected manually (such as with
 <p>There may be a delay between the <code>'disconnect'</code> and <code>'exit'</code> events. These
 events can be used to detect if the process is stuck in a cleanup or if there
 are long-living connections.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The worker #<span class="hljs-subst">${worker.id}</span> has disconnected`</span>);
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The worker #<span class="hljs-subst">${worker.id}</span> has disconnected`</span>);
 });</code></pre>
-<h2>Event: <code>'exit'</code><span><a class="mark" href="#cluster_event_exit_1" id="cluster_event_exit_1">#</a></span></h2>
+</section><section><h3>Event: <code>'exit'</code><span><a class="mark" href="#cluster_event_exit_1" id="cluster_event_exit_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.9</span>
 </div>
@@ -17241,13 +18024,13 @@ the process to be killed.</li>
 </ul>
 <p>When any of the workers die the cluster module will emit the <code>'exit'</code> event.</p>
 <p>This can be used to restart the worker by calling <a href="#cluster_cluster_fork_env"><code>.fork()</code></a> again.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'worker %d died (%s). restarting...'</span>,
-              worker.process.pid, signal || code);
-  cluster.fork();
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'worker %d died (%s). restarting...'</span>,
+              worker.<span class="hljs-property">process</span>.<span class="hljs-property">pid</span>, signal || code);
+  cluster.<span class="hljs-title function_">fork</span>();
 });</code></pre>
 <p>See <a href="#child_process_event_exit"><code>child_process</code> event: <code>'exit'</code></a>.</p>
-<h2>Event: <code>'fork'</code><span><a class="mark" href="#cluster_event_fork" id="cluster_event_fork">#</a></span></h2>
+</section><section><h3>Event: <code>'fork'</code><span><a class="mark" href="#cluster_event_fork" id="cluster_event_fork">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -17257,21 +18040,21 @@ the process to be killed.</li>
 <p>When a new worker is forked the cluster module will emit a <code>'fork'</code> event.
 This can be used to log worker activity, and create a custom timeout.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> timeouts = [];
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">errorMsg</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Something must be wrong with the connection ...'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">errorMsg</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Something must be wrong with the connection ...'</span>);
 }
 
-cluster.on(<span class="hljs-string">'fork'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-  timeouts[worker.id] = <span class="hljs-built_in">setTimeout</span>(errorMsg, <span class="hljs-number">2000</span>);
+cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'fork'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+  timeouts[worker.<span class="hljs-property">id</span>] = <span class="hljs-built_in">setTimeout</span>(errorMsg, <span class="hljs-number">2000</span>);
 });
-cluster.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">worker, address</span>) =></span> {
-  <span class="hljs-built_in">clearTimeout</span>(timeouts[worker.id]);
+cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">worker, address</span>) =></span> {
+  <span class="hljs-built_in">clearTimeout</span>(timeouts[worker.<span class="hljs-property">id</span>]);
 });
-cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-  <span class="hljs-built_in">clearTimeout</span>(timeouts[worker.id]);
-  errorMsg();
+cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+  <span class="hljs-built_in">clearTimeout</span>(timeouts[worker.<span class="hljs-property">id</span>]);
+  <span class="hljs-title function_">errorMsg</span>();
 });</code></pre>
-<h2>Event: <code>'listening'</code><span><a class="mark" href="#cluster_event_listening_1" id="cluster_event_listening_1">#</a></span></h2>
+</section><section><h3>Event: <code>'listening'</code><span><a class="mark" href="#cluster_event_listening_1" id="cluster_event_listening_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -17286,8 +18069,8 @@ master.</p>
 worker object and the <code>address</code> object contains the following connection
 properties: <code>address</code>, <code>port</code> and <code>addressType</code>. This is very useful if the
 worker is listening on more than one address.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">worker, address</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">worker, address</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
     <span class="hljs-string">`A worker is now connected to <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
 });</code></pre>
 <p>The <code>addressType</code> is one of:</p>
@@ -17297,7 +18080,7 @@ worker is listening on more than one address.</p>
 <li><code>-1</code> (Unix domain socket)</li>
 <li><code>'udp4'</code> or <code>'udp6'</code> (UDP v4 or v6)</li>
 </ul>
-<h2>Event: <code>'message'</code><span><a class="mark" href="#cluster_event_message_1" id="cluster_event_message_1">#</a></span></h2>
+</section><section><h3>Event: <code>'message'</code><span><a class="mark" href="#cluster_event_message_1" id="cluster_event_message_1">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -17316,7 +18099,7 @@ worker is listening on more than one address.</p>
 </ul>
 <p>Emitted when the cluster master receives a message from any worker.</p>
 <p>See <a href="#child_process_event_message"><code>child_process</code> event: <code>'message'</code></a>.</p>
-<h2>Event: <code>'online'</code><span><a class="mark" href="#cluster_event_online_1" id="cluster_event_online_1">#</a></span></h2>
+</section><section><h3>Event: <code>'online'</code><span><a class="mark" href="#cluster_event_online_1" id="cluster_event_online_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -17327,10 +18110,10 @@ worker is listening on more than one address.</p>
 When the master receives an online message it will emit this event.
 The difference between <code>'fork'</code> and <code>'online'</code> is that fork is emitted when the
 master forks a worker, and <code>'online'</code> is emitted when the worker is running.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'online'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Yay, the worker responded after it was forked'</span>);
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'online'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Yay, the worker responded after it was forked'</span>);
 });</code></pre>
-<h2>Event: <code>'setup'</code><span><a class="mark" href="#cluster_event_setup" id="cluster_event_setup">#</a></span></h2>
+</section><section><h3>Event: <code>'setup'</code><span><a class="mark" href="#cluster_event_setup" id="cluster_event_setup">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.1</span>
 </div>
@@ -17342,7 +18125,7 @@ master forks a worker, and <code>'online'</code> is emitted when the worker is r
 <a href="#cluster_cluster_setupmaster_settings"><code>.setupMaster()</code></a> was called and is advisory only, since multiple calls to
 <a href="#cluster_cluster_setupmaster_settings"><code>.setupMaster()</code></a> can be made in a single tick.</p>
 <p>If accuracy is important, use <code>cluster.settings</code>.</p>
-<h2><code>cluster.disconnect([callback])</code><span><a class="mark" href="#cluster_cluster_disconnect_callback" id="cluster_cluster_disconnect_callback">#</a></span></h2>
+</section><section><h3><code>cluster.disconnect([callback])</code><span><a class="mark" href="#cluster_cluster_disconnect_callback" id="cluster_cluster_disconnect_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -17356,7 +18139,7 @@ master process to die gracefully if no other event is waiting.</p>
 <p>The method takes an optional callback argument which will be called when
 finished.</p>
 <p>This can only be called from the master process.</p>
-<h2><code>cluster.fork([env])</code><span><a class="mark" href="#cluster_cluster_fork_env" id="cluster_cluster_fork_env">#</a></span></h2>
+</section><section><h3><code>cluster.fork([env])</code><span><a class="mark" href="#cluster_cluster_fork_env" id="cluster_cluster_fork_env">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span>
 </div>
@@ -17366,7 +18149,7 @@ finished.</p>
 </ul>
 <p>Spawn a new worker process.</p>
 <p>This can only be called from the master process.</p>
-<h2><code>cluster.isMaster</code><span><a class="mark" href="#cluster_cluster_ismaster" id="cluster_cluster_ismaster">#</a></span></h2>
+</section><section><h3><code>cluster.isMaster</code><span><a class="mark" href="#cluster_cluster_ismaster" id="cluster_cluster_ismaster">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.8.1</span>
 </div>
@@ -17376,7 +18159,7 @@ finished.</p>
 <p>True if the process is a master. This is determined
 by the <code>process.env.NODE_UNIQUE_ID</code>. If <code>process.env.NODE_UNIQUE_ID</code> is
 undefined, then <code>isMaster</code> is <code>true</code>.</p>
-<h2><code>cluster.isWorker</code><span><a class="mark" href="#cluster_cluster_isworker" id="cluster_cluster_isworker">#</a></span></h2>
+</section><section><h3><code>cluster.isWorker</code><span><a class="mark" href="#cluster_cluster_isworker" id="cluster_cluster_isworker">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span>
 </div>
@@ -17384,7 +18167,7 @@ undefined, then <code>isMaster</code> is <code>true</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>True if the process is not a master (it is the negation of <code>cluster.isMaster</code>).</p>
-<h2><code>cluster.schedulingPolicy</code><span><a class="mark" href="#cluster_cluster_schedulingpolicy" id="cluster_cluster_schedulingpolicy">#</a></span></h2>
+</section><section><h3><code>cluster.schedulingPolicy</code><span><a class="mark" href="#cluster_cluster_schedulingpolicy" id="cluster_cluster_schedulingpolicy">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -17398,12 +18181,12 @@ distribute IOCP handles without incurring a large performance hit.</p>
 <p><code>cluster.schedulingPolicy</code> can also be set through the
 <code>NODE_CLUSTER_SCHED_POLICY</code> environment variable. Valid
 values are <code>'rr'</code> and <code>'none'</code>.</p>
-<h2><code>cluster.settings</code><span><a class="mark" href="#cluster_cluster_settings" id="cluster_cluster_settings">#</a></span></h2>
+</section><section><h3><code>cluster.settings</code><span><a class="mark" href="#cluster_cluster_settings" id="cluster_cluster_settings">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.2.0, v12.16.0</td>
 <td><p>The <code>serialization</code> option is supported now.</p></td></tr>
 <tr><td>v9.5.0</td>
 <td><p>The <code>cwd</code> option is supported now.</p></td></tr>
@@ -17451,7 +18234,7 @@ normally be created on Windows systems. <strong>Default:</strong> <code>false</c
 <p>After calling <a href="#cluster_cluster_setupmaster_settings"><code>.setupMaster()</code></a> (or <a href="#cluster_cluster_fork_env"><code>.fork()</code></a>) this settings object will
 contain the settings, including the default values.</p>
 <p>This object is not intended to be changed or set manually.</p>
-<h2><code>cluster.setupMaster([settings])</code><span><a class="mark" href="#cluster_cluster_setupmaster_settings" id="cluster_cluster_setupmaster_settings">#</a></span></h2>
+</section><section><h3><code>cluster.setupMaster([settings])</code><span><a class="mark" href="#cluster_cluster_setupmaster_settings" id="cluster_cluster_setupmaster_settings">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -17475,19 +18258,19 @@ the <code>env</code> passed to <a href="#cluster_cluster_fork_env"><code>.fork()
 <p>The defaults above apply to the first call only; the defaults for later
 calls are the current values at the time of <code>cluster.setupMaster()</code> is called.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
-cluster.setupMaster({
+cluster.<span class="hljs-title function_">setupMaster</span>({
   <span class="hljs-attr">exec</span>: <span class="hljs-string">'worker.js'</span>,
   <span class="hljs-attr">args</span>: [<span class="hljs-string">'--use'</span>, <span class="hljs-string">'https'</span>],
   <span class="hljs-attr">silent</span>: <span class="hljs-literal">true</span>
 });
-cluster.fork(); <span class="hljs-comment">// https worker</span>
-cluster.setupMaster({
+cluster.<span class="hljs-title function_">fork</span>(); <span class="hljs-comment">// https worker</span>
+cluster.<span class="hljs-title function_">setupMaster</span>({
   <span class="hljs-attr">exec</span>: <span class="hljs-string">'worker.js'</span>,
   <span class="hljs-attr">args</span>: [<span class="hljs-string">'--use'</span>, <span class="hljs-string">'http'</span>]
 });
-cluster.fork(); <span class="hljs-comment">// http worker</span></code></pre>
+cluster.<span class="hljs-title function_">fork</span>(); <span class="hljs-comment">// http worker</span></code></pre>
 <p>This can only be called from the master process.</p>
-<h2><code>cluster.worker</code><span><a class="mark" href="#cluster_cluster_worker" id="cluster_cluster_worker">#</a></span></h2>
+</section><section><h3><code>cluster.worker</code><span><a class="mark" href="#cluster_cluster_worker" id="cluster_cluster_worker">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -17497,14 +18280,14 @@ cluster.fork(); <span class="hljs-comment">// http worker</span></code></pre>
 <p>A reference to the current worker object. Not available in the master process.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'I am master'</span>);
-  cluster.fork();
-  cluster.fork();
-} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.isWorker) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`I am worker #<span class="hljs-subst">${cluster.worker.id}</span>`</span>);
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'I am master'</span>);
+  cluster.<span class="hljs-title function_">fork</span>();
+  cluster.<span class="hljs-title function_">fork</span>();
+} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isWorker</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`I am worker #<span class="hljs-subst">${cluster.worker.id}</span>`</span>);
 }</code></pre>
-<h2><code>cluster.workers</code><span><a class="mark" href="#cluster_cluster_workers" id="cluster_cluster_workers">#</a></span></h2>
+</section><section><h3><code>cluster.workers</code><span><a class="mark" href="#cluster_cluster_workers" id="cluster_cluster_workers">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -17519,31 +18302,32 @@ process.</p>
 advance. However, it is guaranteed that the removal from the <code>cluster.workers</code>
 list happens before last <code>'disconnect'</code> or <code>'exit'</code> event is emitted.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Go through all workers</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">eachWorker</span>(<span class="hljs-params">callback</span>) </span>{
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> id <span class="hljs-keyword">in</span> cluster.workers) {
-    callback(cluster.workers[id]);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">eachWorker</span>(<span class="hljs-params">callback</span>) {
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> id <span class="hljs-keyword">in</span> cluster.<span class="hljs-property">workers</span>) {
+    <span class="hljs-title function_">callback</span>(cluster.<span class="hljs-property">workers</span>[id]);
   }
 }
-eachWorker(<span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-  worker.send(<span class="hljs-string">'big announcement to all workers'</span>);
+<span class="hljs-title function_">eachWorker</span>(<span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+  worker.<span class="hljs-title function_">send</span>(<span class="hljs-string">'big announcement to all workers'</span>);
 });</code></pre>
 <p>Using the worker's unique id is the easiest way to locate the worker.</p>
-<pre><code class="language-js">socket.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">id</span>) =></span> {
-  <span class="hljs-keyword">const</span> worker = cluster.workers[id];
-});</code></pre>
-<h1>Command line options<span><a class="mark" href="#cli_command_line_options" id="cli_command_line_options">#</a></span></h1>
+<pre><code class="language-js">socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">id</span>) =></span> {
+  <span class="hljs-keyword">const</span> worker = cluster.<span class="hljs-property">workers</span>[id];
+});</code></pre></section>
+        </section>
+<section><h2>Command-line options<span><a class="mark" href="#cli_command_line_options" id="cli_command_line_options">#</a></span></h2>
 
 
 <p>Node.js comes with a variety of CLI options. These options expose built-in
 debugging, multiple ways to execute scripts, and other helpful runtime options.</p>
 <p>To view this documentation as a manual page in a terminal, run <code>man node</code>.</p>
-<h2>Synopsis<span><a class="mark" href="#cli_synopsis" id="cli_synopsis">#</a></span></h2>
+<section><h3>Synopsis<span><a class="mark" href="#cli_synopsis" id="cli_synopsis">#</a></span></h3>
 <p><code>node [options] [V8 options] [script.js | -e "script" | -] [--] [arguments]</code></p>
 <p><code>node inspect [script.js | -e "script" | &#x3C;host>:&#x3C;port>] …</code></p>
 <p><code>node --v8-options</code></p>
 <p>Execute without arguments to start the <a href="repl.html">REPL</a>.</p>
-<p><em>For more info about <code>node inspect</code>, please see the <a href="debugger.html">debugger</a> documentation.</em></p>
-<h2>Options<span><a class="mark" href="#cli_options" id="cli_options">#</a></span></h2>
+<p>For more info about <code>node inspect</code>, see the <a href="debugger.html">debugger</a> documentation.</p>
+</section><section><h3>Options<span><a class="mark" href="#cli_options" id="cli_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -17554,27 +18338,27 @@ debugging, multiple ways to execute scripts, and other helpful runtime options.<
 </details>
 </div>
 <p>All options, including V8 options, allow words to be separated by both
-dashes (<code>-</code>) or underscores (<code>_</code>).</p>
-<p>For example, <code>--pending-deprecation</code> is equivalent to <code>--pending_deprecation</code>.</p>
-<p>If an option that takes a single value, for example <code>--max-http-header-size</code>,
-is passed more than once, then the last passed value will be used. Options
-from the command line take precedence over options passed through the
-<a href="#cli_node_options_options"><code>NODE_OPTIONS</code></a> environment variable.</p>
-<h3><code>-</code><span><a class="mark" href="#cli" id="cli">#</a></span></h3>
+dashes (<code>-</code>) or underscores (<code>_</code>). For example, <code>--pending-deprecation</code> is
+equivalent to <code>--pending_deprecation</code>.</p>
+<p>If an option that takes a single value (such as <code>--max-http-header-size</code>) is
+passed more than once, then the last passed value is used. Options from the
+command line take precedence over options passed through the <a href="#cli_node_options_options"><code>NODE_OPTIONS</code></a>
+environment variable.</p>
+<h4><code>-</code><span><a class="mark" href="#cli" id="cli">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
-<p>Alias for stdin. Analogous to the use of <code>-</code> in other command line utilities,
-meaning that the script will be read from stdin, and the rest of the options
+<p>Alias for stdin. Analogous to the use of <code>-</code> in other command-line utilities,
+meaning that the script is read from stdin, and the rest of the options
 are passed to that script.</p>
-<h3><code>--</code><span><a class="mark" href="#cli_1" id="cli_1">#</a></span></h3>
+<h4><code>--</code><span><a class="mark" href="#cli_1" id="cli_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.11.0</span>
 </div>
 <p>Indicate the end of node options. Pass the rest of the arguments to the script.
 If no script filename or eval/print script is supplied prior to this, then
-the next argument will be used as a script filename.</p>
-<h3><code>--abort-on-uncaught-exception</code><span><a class="mark" href="#cli_abort_on_uncaught_exception" id="cli_abort_on_uncaught_exception">#</a></span></h3>
+the next argument is used as a script filename.</p>
+<h4><code>--abort-on-uncaught-exception</code><span><a class="mark" href="#cli_abort_on_uncaught_exception" id="cli_abort_on_uncaught_exception">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.10.8</span>
 </div>
@@ -17583,38 +18367,40 @@ analysis using a debugger (such as <code>lldb</code>, <code>gdb</code>, and <cod
 <p>If this flag is passed, the behavior can still be set to not abort through
 <a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> (and through usage of the
 <code>domain</code> module that uses it).</p>
-<h3><code>--completion-bash</code><span><a class="mark" href="#cli_completion_bash" id="cli_completion_bash">#</a></span></h3>
+<h4><code>--completion-bash</code><span><a class="mark" href="#cli_completion_bash" id="cli_completion_bash">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
 <p>Print source-able bash completion script for Node.js.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --completion-bash > node_bash_completion</span>
-<span class="hljs-meta">$</span><span class="bash"> <span class="hljs-built_in">source</span> node_bash_completion</span></code></pre>
-<h3><code>--conditions=condition</code><span><a class="mark" href="#cli_conditions_condition" id="cli_conditions_condition">#</a></span></h3>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --completion-bash > node_bash_completion</span>
+<span class="hljs-meta">$ </span><span class="language-bash"><span class="hljs-built_in">source</span> node_bash_completion</span></code></pre>
+<h4><code>-C=condition</code>, <code>--conditions=condition</code><span><a class="mark" href="#cli_c_condition_conditions_condition" id="cli_c_condition_conditions_condition">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.9.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p>Enable experimental support for custom conditional exports resolution
+<p>Enable experimental support for custom <a href="#packages_conditional_exports">conditional exports</a> resolution
 conditions.</p>
 <p>Any number of custom string condition names are permitted.</p>
 <p>The default Node.js conditions of <code>"node"</code>, <code>"default"</code>, <code>"import"</code>, and
 <code>"require"</code> will always apply as defined.</p>
-<h3><code>--cpu-prof</code><span><a class="mark" href="#cli_cpu_prof" id="cli_cpu_prof">#</a></span></h3>
+<p>For example, to run a module with "development" resolutions:</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node -C=development app.js</span></code></pre>
+<h4><code>--cpu-prof</code><span><a class="mark" href="#cli_cpu_prof" id="cli_cpu_prof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Starts the V8 CPU profiler on start up, and writes the CPU profile to disk
 before exit.</p>
-<p>If <code>--cpu-prof-dir</code> is not specified, the generated profile will be placed
+<p>If <code>--cpu-prof-dir</code> is not specified, the generated profile is placed
 in the current working directory.</p>
-<p>If <code>--cpu-prof-name</code> is not specified, the generated profile will be
+<p>If <code>--cpu-prof-name</code> is not specified, the generated profile is
 named <code>CPU.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.cpuprofile</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --cpu-prof index.js</span>
-<span class="hljs-meta">$</span><span class="bash"> ls *.cpuprofile</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --cpu-prof index.js</span>
+<span class="hljs-meta">$ </span><span class="language-bash">ls *.cpuprofile</span>
 CPU.20190409.202950.15293.0.0.cpuprofile</code></pre>
-<h3><code>--cpu-prof-dir</code><span><a class="mark" href="#cli_cpu_prof_dir" id="cli_cpu_prof_dir">#</a></span></h3>
+<h4><code>--cpu-prof-dir</code><span><a class="mark" href="#cli_cpu_prof_dir" id="cli_cpu_prof_dir">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -17622,22 +18408,22 @@ CPU.20190409.202950.15293.0.0.cpuprofile</code></pre>
 <p>Specify the directory where the CPU profiles generated by <code>--cpu-prof</code> will
 be placed.</p>
 <p>The default value is controlled by the
-<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command line option.</p>
-<h3><code>--cpu-prof-interval</code><span><a class="mark" href="#cli_cpu_prof_interval" id="cli_cpu_prof_interval">#</a></span></h3>
+<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command-line option.</p>
+<h4><code>--cpu-prof-interval</code><span><a class="mark" href="#cli_cpu_prof_interval" id="cli_cpu_prof_interval">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.2.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Specify the sampling interval in microseconds for the CPU profiles generated
 by <code>--cpu-prof</code>. The default is 1000 microseconds.</p>
-<h3><code>--cpu-prof-name</code><span><a class="mark" href="#cli_cpu_prof_name" id="cli_cpu_prof_name">#</a></span></h3>
+<h4><code>--cpu-prof-name</code><span><a class="mark" href="#cli_cpu_prof_name" id="cli_cpu_prof_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Specify the file name of the CPU profile generated by <code>--cpu-prof</code>.</p>
-<h3><code>--diagnostic-dir=directory</code><span><a class="mark" href="#cli_diagnostic_dir_directory" id="cli_diagnostic_dir_directory">#</a></span></h3>
-<p>Set the directory to which all diagnostic output files will be written to.
+<h4><code>--diagnostic-dir=directory</code><span><a class="mark" href="#cli_diagnostic_dir_directory" id="cli_diagnostic_dir_directory">#</a></span></h4>
+<p>Set the directory to which all diagnostic output files are written.
 Defaults to current working directory.</p>
 <p>Affects the default output directory of:</p>
 <ul>
@@ -17645,102 +18431,138 @@ Defaults to current working directory.</p>
 <li><a href="#cli_heap_prof_dir">--heap-prof-dir</a></li>
 <li><a href="#cli_redirect_warnings_file">--redirect-warnings</a></li>
 </ul>
-<h3><code>--disable-proto=mode</code><span><a class="mark" href="#cli_disable_proto_mode" id="cli_disable_proto_mode">#</a></span></h3>
-<!--YAML
-added: v12.17.0
--->
+<h4><code>--disable-proto=mode</code><span><a class="mark" href="#cli_disable_proto_mode" id="cli_disable_proto_mode">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.12.0</span>
+</div>
 <p>Disable the <code>Object.prototype.__proto__</code> property. If <code>mode</code> is <code>delete</code>, the
-property will be removed entirely. If <code>mode</code> is <code>throw</code>, accesses to the
-property will throw an exception with the code <code>ERR_PROTO_ACCESS</code>.</p>
-<h3><code>--disallow-code-generation-from-strings</code><span><a class="mark" href="#cli_disallow_code_generation_from_strings" id="cli_disallow_code_generation_from_strings">#</a></span></h3>
+property is removed entirely. If <code>mode</code> is <code>throw</code>, accesses to the
+property throw an exception with the code <code>ERR_PROTO_ACCESS</code>.</p>
+<h4><code>--disallow-code-generation-from-strings</code><span><a class="mark" href="#cli_disallow_code_generation_from_strings" id="cli_disallow_code_generation_from_strings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.8.0</span>
 </div>
 <p>Make built-in language features like <code>eval</code> and <code>new Function</code> that generate
 code from strings throw an exception instead. This does not affect the Node.js
 <code>vm</code> module.</p>
-<h3><code>--enable-fips</code><span><a class="mark" href="#cli_enable_fips" id="cli_enable_fips">#</a></span></h3>
+<h4><code>--dns-result-order=order</code><span><a class="mark" href="#cli_dns_result_order_order" id="cli_dns_result_order_order">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>Set the default value of <code>verbatim</code> in <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> and
+<a href="#dns_dnspromises_lookup_hostname_options"><code>dnsPromises.lookup()</code></a>. The value could be:</p>
+<ul>
+<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>
+<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>
+</ul>
+<p>The default is <code>ipv4first</code> and <a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> have higher
+priority than <code>--dns-result-order</code>.</p>
+<h4><code>--enable-fips</code><span><a class="mark" href="#cli_enable_fips" id="cli_enable_fips">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Enable FIPS-compliant crypto at startup. (Requires Node.js to be built with
 <code>./configure --openssl-fips</code>.)</p>
-<h3><code>--enable-source-maps</code><span><a class="mark" href="#cli_enable_source_maps" id="cli_enable_source_maps">#</a></span></h3>
+<h4><code>--enable-source-maps</code><span><a class="mark" href="#cli_enable_source_maps" id="cli_enable_source_maps">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>This API is no longer experimental.</p></td></tr>
+<tr><td>v12.12.0</td>
+<td><p><span>Added in: v12.12.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p>Enable experimental Source Map v3 support for stack traces.</p>
-<p>Currently, overriding <code>Error.prepareStackTrace</code> is ignored when the
-<code>--enable-source-maps</code> flag is set.</p>
-<h3><code>--experimental-import-meta-resolve</code><span><a class="mark" href="#cli_experimental_import_meta_resolve" id="cli_experimental_import_meta_resolve">#</a></span></h3>
+<p>Enable <a href="https://sourcemaps.info/spec.html">Source Map v3</a> support for stack traces.</p>
+<p>When using a transpiler, such as TypeScript, strack traces thrown by an
+application reference the transpiled code, not the original source position.
+<code>--enable-source-maps</code> enables caching of Source Maps and makes a best
+effort to report stack traces relative to the original source file.</p>
+<p>Overriding <code>Error.prepareStackTrace</code> prevents <code>--enable-source-maps</code> from
+modifiying the stack trace.</p>
+<h4><code>--experimental-abortcontroller</code><span><a class="mark" href="#cli_experimental_abortcontroller" id="cli_experimental_abortcontroller">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>Enable experimental <code>AbortController</code> and <code>AbortSignal</code> support.</p>
+<h4><code>--experimental-import-meta-resolve</code><span><a class="mark" href="#cli_experimental_import_meta_resolve" id="cli_experimental_import_meta_resolve">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.2</span>
+<span>Added in: v13.9.0, v12.16.2</span>
 </div>
 <p>Enable experimental <code>import.meta.resolve()</code> support.</p>
-<h3><code>--experimental-json-modules</code><span><a class="mark" href="#cli_experimental_json_modules" id="cli_experimental_json_modules">#</a></span></h3>
+<h4><code>--experimental-json-modules</code><span><a class="mark" href="#cli_experimental_json_modules" id="cli_experimental_json_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
 <p>Enable experimental JSON support for the ES Module loader.</p>
-<h3><code>--experimental-loader=module</code><span><a class="mark" href="#cli_experimental_loader_module" id="cli_experimental_loader_module">#</a></span></h3>
+<h4><code>--experimental-loader=module</code><span><a class="mark" href="#cli_experimental_loader_module" id="cli_experimental_loader_module">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
-<p>Specify the <code>module</code> of a custom <a href="#esm_experimental_loaders">experimental ECMAScript Module loader</a>.
+<p>Specify the <code>module</code> of a custom experimental <a href="#esm_loaders">ECMAScript Module loader</a>.
 <code>module</code> may be either a path to a file, or an ECMAScript Module name.</p>
-<h3><code>--experimental-modules</code><span><a class="mark" href="#cli_experimental_modules" id="cli_experimental_modules">#</a></span></h3>
+<h4><code>--experimental-modules</code><span><a class="mark" href="#cli_experimental_modules" id="cli_experimental_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>Enable latest experimental modules features (deprecated).</p>
-<h3><code>--experimental-policy</code><span><a class="mark" href="#cli_experimental_policy" id="cli_experimental_policy">#</a></span></h3>
+<h4><code>--experimental-policy</code><span><a class="mark" href="#cli_experimental_policy" id="cli_experimental_policy">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.8.0</span>
 </div>
 <p>Use the specified file as a security policy.</p>
-<h3><code>--experimental-repl-await</code><span><a class="mark" href="#cli_experimental_repl_await" id="cli_experimental_repl_await">#</a></span></h3>
+<h4><code>--experimental-repl-await</code><span><a class="mark" href="#cli_experimental_repl_await" id="cli_experimental_repl_await">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 <p>Enable experimental top-level <code>await</code> keyword support in REPL.</p>
-<h3><code>--experimental-specifier-resolution=mode</code><span><a class="mark" href="#cli_experimental_specifier_resolution_mode" id="cli_experimental_specifier_resolution_mode">#</a></span></h3>
+<h4><code>--experimental-specifier-resolution=mode</code><span><a class="mark" href="#cli_experimental_specifier_resolution_mode" id="cli_experimental_specifier_resolution_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.4.0, v12.16.0</span>
 </div>
 <p>Sets the resolution algorithm for resolving ES module specifiers. Valid options
 are <code>explicit</code> and <code>node</code>.</p>
 <p>The default is <code>explicit</code>, which requires providing the full path to a
-module. The <code>node</code> mode will enable support for optional file extensions and
+module. The <code>node</code> mode enables support for optional file extensions and
 the ability to import a directory that has an index file.</p>
-<p>Please see <a href="#esm_customizing_esm_specifier_resolution_algorithm">customizing ESM specifier resolution</a> for example usage.</p>
-<h3><code>--experimental-vm-modules</code><span><a class="mark" href="#cli_experimental_vm_modules" id="cli_experimental_vm_modules">#</a></span></h3>
+<p>See <a href="#esm_customizing_esm_specifier_resolution_algorithm">customizing ESM specifier resolution</a> for example usage.</p>
+<h4><code>--experimental-vm-modules</code><span><a class="mark" href="#cli_experimental_vm_modules" id="cli_experimental_vm_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 </div>
 <p>Enable experimental ES Module support in the <code>vm</code> module.</p>
-<h3><code>--experimental-wasi-unstable-preview1</code><span><a class="mark" href="#cli_experimental_wasi_unstable_preview1" id="cli_experimental_wasi_unstable_preview1">#</a></span></h3>
+<h4><code>--experimental-wasi-unstable-preview1</code><span><a class="mark" href="#cli_experimental_wasi_unstable_preview1" id="cli_experimental_wasi_unstable_preview1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.6.0</td>
+<td><p>changed from <code>--experimental-wasi-unstable-preview0</code> to <code>--experimental-wasi-unstable-preview1</code>.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
+<td><p><span>Added in: v13.3.0, v12.16.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <p>Enable experimental WebAssembly System Interface (WASI) support.</p>
-<h3><code>--experimental-wasm-modules</code><span><a class="mark" href="#cli_experimental_wasm_modules" id="cli_experimental_wasm_modules">#</a></span></h3>
+<h4><code>--experimental-wasm-modules</code><span><a class="mark" href="#cli_experimental_wasm_modules" id="cli_experimental_wasm_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
-<h3><code>--force-context-aware</code><span><a class="mark" href="#cli_force_context_aware" id="cli_force_context_aware">#</a></span></h3>
+<p>Enable experimental WebAssembly module support.</p>
+<h4><code>--force-context-aware</code><span><a class="mark" href="#cli_force_context_aware" id="cli_force_context_aware">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.12.0</span>
 </div>
 <p>Disable loading native addons that are not <a href="#addons_context_aware_addons">context-aware</a>.</p>
-<p>Enable experimental WebAssembly module support.</p>
-<h3><code>--force-fips</code><span><a class="mark" href="#cli_force_fips" id="cli_force_fips">#</a></span></h3>
+<h4><code>--force-fips</code><span><a class="mark" href="#cli_force_fips" id="cli_force_fips">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Force FIPS-compliant crypto on startup. (Cannot be disabled from script code.)
 (Same requirements as <code>--enable-fips</code>.)</p>
-<h3><code>--frozen-intrinsics</code><span><a class="mark" href="#cli_frozen_intrinsics" id="cli_frozen_intrinsics">#</a></span></h3>
+<h4><code>--frozen-intrinsics</code><span><a class="mark" href="#cli_frozen_intrinsics" id="cli_frozen_intrinsics">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.12.0</span>
 </div>
@@ -17751,35 +18573,73 @@ currently provided that <code>global.Array</code> is indeed the default intrinsi
 reference. Code may break under this flag.</p>
 <p><code>--require</code> runs prior to freezing intrinsics in order to allow polyfills to
 be added.</p>
-<h3><code>--heapsnapshot-signal=signal</code><span><a class="mark" href="#cli_heapsnapshot_signal_signal" id="cli_heapsnapshot_signal_signal">#</a></span></h3>
+<h4><code>--heapsnapshot-near-heap-limit=max_count</code><span><a class="mark" href="#cli_heapsnapshot_near_heap_limit_max_count" id="cli_heapsnapshot_near_heap_limit_max_count">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>Writes a V8 heap snapshot to disk when the V8 heap usage is approaching the
+heap limit. <code>count</code> should be a non-negative integer (in which case
+Node.js will write no more than <code>max_count</code> snapshots to disk).</p>
+<p>When generating snapshots, garbage collection may be triggered and bring
+the heap usage down, therefore multiple snapshots may be written to disk
+before the Node.js instance finally runs out of memory. These heap snapshots
+can be compared to determine what objects are being allocated during the
+time consecutive snapshots are taken. It's not guaranteed that Node.js will
+write exactly <code>max_count</code> snapshots to disk, but it will try
+its best to generate at least one and up to <code>max_count</code> snapshots before the
+Node.js instance runs out of memory when <code>max_count</code> is greater than <code>0</code>.</p>
+<p>Generating V8 snapshots takes time and memory (both memory managed by the
+V8 heap and native memory outside the V8 heap). The bigger the heap is,
+the more resources it needs. Node.js will adjust the V8 heap to accommondate
+the additional V8 heap memory overhead, and try its best to avoid using up
+all the memory avialable to the process. When the process uses
+more memory than the system deems appropriate, the process may be terminated
+abruptly by the system, depending on the system configuration.</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --max-old-space-size=100 --heapsnapshot-near-heap-limit=3 index.js</span>
+Wrote snapshot to Heap.20200430.100036.49580.0.001.heapsnapshot
+Wrote snapshot to Heap.20200430.100037.49580.0.002.heapsnapshot
+Wrote snapshot to Heap.20200430.100038.49580.0.003.heapsnapshot
+
+&#x3C;--- Last few GCs --->
+
+[49580:0x110000000]     4826 ms: Mark-sweep 130.6 (147.8) -> 130.5 (147.8) MB, 27.4 / 0.0 ms  (average mu = 0.126, current mu = 0.034) allocation failure scavenge might not succeed
+[49580:0x110000000]     4845 ms: Mark-sweep 130.6 (147.8) -> 130.6 (147.8) MB, 18.8 / 0.0 ms  (average mu = 0.088, current mu = 0.031) allocation failure scavenge might not succeed
+
+
+&#x3C;--- JS stacktrace --->
+
+FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory
+....</code></pre>
+<h4><code>--heapsnapshot-signal=signal</code><span><a class="mark" href="#cli_heapsnapshot_signal_signal" id="cli_heapsnapshot_signal_signal">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>Enables a signal handler that causes the Node.js process to write a heap dump
 when the specified signal is received. <code>signal</code> must be a valid signal name.
 Disabled by default.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --heapsnapshot-signal=SIGUSR2 index.js &#x26;</span>
-<span class="hljs-meta">$</span><span class="bash"> ps aux</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --heapsnapshot-signal=SIGUSR2 index.js &#x26;</span>
+<span class="hljs-meta">$ </span><span class="language-bash">ps aux</span>
 USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
 node         1  5.5  6.1 787252 247004 ?       Ssl  16:43   0:02 node --heapsnapshot-signal=SIGUSR2 index.js
-<span class="hljs-meta">$</span><span class="bash"> <span class="hljs-built_in">kill</span> -USR2 1</span>
-<span class="hljs-meta">$</span><span class="bash"> ls</span>
+<span class="hljs-meta">$ </span><span class="language-bash"><span class="hljs-built_in">kill</span> -USR2 1</span>
+<span class="hljs-meta">$ </span><span class="language-bash">ls</span>
 Heap.20190718.133405.15554.0.001.heapsnapshot</code></pre>
-<h3><code>--heap-prof</code><span><a class="mark" href="#cli_heap_prof" id="cli_heap_prof">#</a></span></h3>
+<h4><code>--heap-prof</code><span><a class="mark" href="#cli_heap_prof" id="cli_heap_prof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.4.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Starts the V8 heap profiler on start up, and writes the heap profile to disk
 before exit.</p>
-<p>If <code>--heap-prof-dir</code> is not specified, the generated profile will be placed
+<p>If <code>--heap-prof-dir</code> is not specified, the generated profile is placed
 in the current working directory.</p>
-<p>If <code>--heap-prof-name</code> is not specified, the generated profile will be
+<p>If <code>--heap-prof-name</code> is not specified, the generated profile is
 named <code>Heap.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.heapprofile</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --heap-prof index.js</span>
-<span class="hljs-meta">$</span><span class="bash"> ls *.heapprofile</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --heap-prof index.js</span>
+<span class="hljs-meta">$ </span><span class="language-bash">ls *.heapprofile</span>
 Heap.20190409.202950.15293.0.001.heapprofile</code></pre>
-<h3><code>--heap-prof-dir</code><span><a class="mark" href="#cli_heap_prof_dir" id="cli_heap_prof_dir">#</a></span></h3>
+<h4><code>--heap-prof-dir</code><span><a class="mark" href="#cli_heap_prof_dir" id="cli_heap_prof_dir">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.4.0</span>
 </div>
@@ -17787,70 +18647,39 @@ Heap.20190409.202950.15293.0.001.heapprofile</code></pre>
 <p>Specify the directory where the heap profiles generated by <code>--heap-prof</code> will
 be placed.</p>
 <p>The default value is controlled by the
-<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command line option.</p>
-<h3><code>--heap-prof-interval</code><span><a class="mark" href="#cli_heap_prof_interval" id="cli_heap_prof_interval">#</a></span></h3>
+<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command-line option.</p>
+<h4><code>--heap-prof-interval</code><span><a class="mark" href="#cli_heap_prof_interval" id="cli_heap_prof_interval">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.4.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Specify the average sampling interval in bytes for the heap profiles generated
 by <code>--heap-prof</code>. The default is 512 * 1024 bytes.</p>
-<h3><code>--heap-prof-name</code><span><a class="mark" href="#cli_heap_prof_name" id="cli_heap_prof_name">#</a></span></h3>
+<h4><code>--heap-prof-name</code><span><a class="mark" href="#cli_heap_prof_name" id="cli_heap_prof_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.4.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Specify the file name of the heap profile generated by <code>--heap-prof</code>.</p>
-<h3><code>--http-parser=library</code><span><a class="mark" href="#cli_http_parser_library" id="cli_http_parser_library">#</a></span></h3>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.22.0</td>
-<td><p>The legacy HTTP parser will emit a deprecation warning.</p></td></tr>
-<tr><td>v11.4.0</td>
-<td><p><span>Added in: v11.4.0</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<p>Chooses an HTTP parser library. Available values are:</p>
-<ul>
-<li><code>llhttp</code> for <a href="https://llhttp.org/">https://llhttp.org/</a></li>
-<li><code>legacy</code> for <a href="https://github.com/nodejs/http-parser">https://github.com/nodejs/http-parser</a></li>
-</ul>
-<p>The default is <code>llhttp</code>, unless otherwise specified when building Node.js.</p>
-<p>The <code>legacy</code> HTTP parser is deprecated and will emit a deprecation warning.</p>
-<p>This flag exists to aid in experimentation with the internal implementation of
-the Node.js http parser.
-This flag is likely to become a no-op and removed at some point in the future.</p>
-<h3><code>--http-server-default-timeout=milliseconds</code><span><a class="mark" href="#cli_http_server_default_timeout_milliseconds" id="cli_http_server_default_timeout_milliseconds">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.4.0</span>
-</div>
-<p>Overrides the default value of <code>http</code>, <code>https</code> and <code>http2</code> server socket
-timeout. Setting the value to 0 disables server socket timeout. Unless
-provided, http server sockets timeout after 120s (2 minutes). Programmatic
-setting of the timeout takes precedence over the value set through this
-flag.</p>
-<h3><code>--icu-data-dir=file</code><span><a class="mark" href="#cli_icu_data_dir_file" id="cli_icu_data_dir_file">#</a></span></h3>
+<h4><code>--icu-data-dir=file</code><span><a class="mark" href="#cli_icu_data_dir_file" id="cli_icu_data_dir_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
 <p>Specify ICU data load path. (Overrides <code>NODE_ICU_DATA</code>.)</p>
-<h3><code>--input-type=type</code><span><a class="mark" href="#cli_input_type_type" id="cli_input_type_type">#</a></span></h3>
+<h4><code>--input-type=type</code><span><a class="mark" href="#cli_input_type_type" id="cli_input_type_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>This configures Node.js to interpret string input as CommonJS or as an ES
 module. String input is input via <code>--eval</code>, <code>--print</code>, or <code>STDIN</code>.</p>
 <p>Valid values are <code>"commonjs"</code> and <code>"module"</code>. The default is <code>"commonjs"</code>.</p>
-<h3><code>--inspect-brk[=[host:]port]</code><span><a class="mark" href="#cli_inspect_brk_host_port" id="cli_inspect_brk_host_port">#</a></span></h3>
+<h4><code>--inspect-brk[=[host:]port]</code><span><a class="mark" href="#cli_inspect_brk_host_port" id="cli_inspect_brk_host_port">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.6.0</span>
 </div>
 <p>Activate inspector on <code>host:port</code> and break at start of user script.
 Default <code>host:port</code> is <code>127.0.0.1:9229</code>.</p>
-<h3><code>--inspect-port=[host:]port</code><span><a class="mark" href="#cli_inspect_port_host_port" id="cli_inspect_port_host_port">#</a></span></h3>
+<h4><code>--inspect-port=[host:]port</code><span><a class="mark" href="#cli_inspect_port_host_port" id="cli_inspect_port_host_port">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.6.0</span>
 </div>
@@ -17859,7 +18688,7 @@ Useful when activating the inspector by sending the <code>SIGUSR1</code> signal.
 <p>Default host is <code>127.0.0.1</code>.</p>
 <p>See the <a href="#inspector_security">security warning</a> below regarding the <code>host</code>
 parameter usage.</p>
-<h3><code>--inspect[=[host:]port]</code><span><a class="mark" href="#cli_inspect_host_port" id="cli_inspect_host_port">#</a></span></h3>
+<h4><code>--inspect[=[host:]port]</code><span><a class="mark" href="#cli_inspect_host_port" id="cli_inspect_host_port">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -17868,7 +18697,7 @@ parameter usage.</p>
 and profile Node.js instances. The tools attach to Node.js instances via a
 tcp port and communicate using the <a href="https://chromedevtools.github.io/devtools-protocol/">Chrome DevTools Protocol</a>.</p>
 <p><a id="inspector_security"></a></p>
-<h4>Warning: binding inspector to a public IP:port combination is insecure<span><a class="mark" href="#cli_warning_binding_inspector_to_a_public_ip_port_combination_is_insecure" id="cli_warning_binding_inspector_to_a_public_ip_port_combination_is_insecure">#</a></span></h4>
+<h5>Warning: binding inspector to a public IP:port combination is insecure<span><a class="mark" href="#cli_warning_binding_inspector_to_a_public_ip_port_combination_is_insecure" id="cli_warning_binding_inspector_to_a_public_ip_port_combination_is_insecure">#</a></span></h5>
 <p>Binding the inspector to a public IP (including <code>0.0.0.0</code>) with an open port is
 insecure, as it allows external hosts to connect to the inspector and perform
 a <a href="https://www.owasp.org/index.php/Code_Injection">remote code execution</a> attack.</p>
@@ -17880,19 +18709,19 @@ a <a href="https://www.owasp.org/index.php/Code_Injection">remote code execution
 <p><strong>More specifically, <code>--inspect=0.0.0.0</code> is insecure if the port (<code>9229</code> by
 default) is not firewall-protected.</strong></p>
 <p>See the <a href="https://nodejs.org/en/docs/guides/debugging-getting-started/#security-implications">debugging security implications</a> section for more information.</p>
-<h3><code>--inspect-publish-uid=stderr,http</code><span><a class="mark" href="#cli_inspect_publish_uid_stderr_http" id="cli_inspect_publish_uid_stderr_http">#</a></span></h3>
+<h4><code>--inspect-publish-uid=stderr,http</code><span><a class="mark" href="#cli_inspect_publish_uid_stderr_http" id="cli_inspect_publish_uid_stderr_http">#</a></span></h4>
 <p>Specify ways of the inspector web socket url exposure.</p>
 <p>By default inspector websocket url is available in stderr and under <code>/json/list</code>
 endpoint on <code>http://host:port/json/list</code>.</p>
-<h3><code>--insecure-http-parser</code><span><a class="mark" href="#cli_insecure_http_parser" id="cli_insecure_http_parser">#</a></span></h3>
+<h4><code>--insecure-http-parser</code><span><a class="mark" href="#cli_insecure_http_parser" id="cli_insecure_http_parser">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.15.0</span>
+<span>Added in: v13.4.0, v12.15.0, v10.19.0</span>
 </div>
 <p>Use an insecure HTTP parser that accepts invalid HTTP headers. This may allow
 interoperability with non-conformant HTTP implementations. It may also allow
 request smuggling and other HTTP attacks that rely on invalid headers being
 accepted. Avoid using this option.</p>
-<h3><code>--jitless</code><span><a class="mark" href="#cli_jitless" id="cli_jitless">#</a></span></h3>
+<h4><code>--jitless</code><span><a class="mark" href="#cli_jitless" id="cli_jitless">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -17901,51 +18730,65 @@ required on some platforms for security reasons. It can also reduce attack
 surface on other platforms, but the performance impact may be severe.</p>
 <p>This flag is inherited from V8 and is subject to change upstream. It may
 disappear in a non-semver-major release.</p>
-<h3><code>--max-http-header-size=size</code><span><a class="mark" href="#cli_max_http_header_size_size" id="cli_max_http_header_size_size">#</a></span></h3>
+<h4><code>--max-http-header-size=size</code><span><a class="mark" href="#cli_max_http_header_size_size" id="cli_max_http_header_size_size">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.6.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Change maximum default size of HTTP headers from 8KB to 16KB.</p></td></tr>
+<tr><td>v11.6.0, v10.15.0</td>
+<td><p><span>Added in: v11.6.0, v10.15.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p>Specify the maximum size, in bytes, of HTTP headers. Defaults to 8KB.</p>
-<h3><code>--napi-modules</code><span><a class="mark" href="#cli_napi_modules" id="cli_napi_modules">#</a></span></h3>
+<p>Specify the maximum size, in bytes, of HTTP headers. Defaults to 16KB.</p>
+<h4><code>--napi-modules</code><span><a class="mark" href="#cli_napi_modules" id="cli_napi_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.10.0</span>
 </div>
 <p>This option is a no-op. It is kept for compatibility.</p>
-<h3><code>--no-deprecation</code><span><a class="mark" href="#cli_no_deprecation" id="cli_no_deprecation">#</a></span></h3>
+<h4><code>--no-deprecation</code><span><a class="mark" href="#cli_no_deprecation" id="cli_no_deprecation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
 <p>Silence deprecation warnings.</p>
-<h3><code>--no-force-async-hooks-checks</code><span><a class="mark" href="#cli_no_force_async_hooks_checks" id="cli_no_force_async_hooks_checks">#</a></span></h3>
+<h4><code>--no-force-async-hooks-checks</code><span><a class="mark" href="#cli_no_force_async_hooks_checks" id="cli_no_force_async_hooks_checks">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
 <p>Disables runtime checks for <code>async_hooks</code>. These will still be enabled
 dynamically when <code>async_hooks</code> is enabled.</p>
-<h3><code>--no-warnings</code><span><a class="mark" href="#cli_no_warnings" id="cli_no_warnings">#</a></span></h3>
+<h4><code>--no-warnings</code><span><a class="mark" href="#cli_no_warnings" id="cli_no_warnings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Silence all process warnings (including deprecations).</p>
-<h3><code>--openssl-config=file</code><span><a class="mark" href="#cli_openssl_config_file" id="cli_openssl_config_file">#</a></span></h3>
+<h4><code>--node-memory-debug</code><span><a class="mark" href="#cli_node_memory_debug" id="cli_node_memory_debug">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>Enable extra debug checks for memory leaks in Node.js internals. This is
+usually only useful for developers debugging Node.js itself.</p>
+<h4><code>--openssl-config=file</code><span><a class="mark" href="#cli_openssl_config_file" id="cli_openssl_config_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.9.0</span>
 </div>
 <p>Load an OpenSSL configuration file on startup. Among other uses, this can be
 used to enable FIPS-compliant crypto if Node.js is built with
 <code>./configure --openssl-fips</code>.</p>
-<h3><code>--pending-deprecation</code><span><a class="mark" href="#cli_pending_deprecation" id="cli_pending_deprecation">#</a></span></h3>
+<h4><code>--pending-deprecation</code><span><a class="mark" href="#cli_pending_deprecation" id="cli_pending_deprecation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>Emit pending deprecation warnings.</p>
 <p>Pending deprecations are generally identical to a runtime deprecation with the
 notable exception that they are turned <em>off</em> by default and will not be emitted
-unless either the <code>--pending-deprecation</code> command line flag, or the
+unless either the <code>--pending-deprecation</code> command-line flag, or the
 <code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations
 are used to provide a kind of selective "early warning" mechanism that
 developers may leverage to detect deprecated API usage.</p>
-<h3><code>--policy-integrity=sri</code><span><a class="mark" href="#cli_policy_integrity_sri" id="cli_policy_integrity_sri">#</a></span></h3>
+<h4><code>--policy-integrity=sri</code><span><a class="mark" href="#cli_policy_integrity_sri" id="cli_policy_integrity_sri">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
@@ -17953,7 +18796,7 @@ developers may leverage to detect deprecated API usage.</p>
 <p>Instructs Node.js to error prior to running any code if the policy does not have
 the specified integrity. It expects a <a href="https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity">Subresource Integrity</a> string as a
 parameter.</p>
-<h3><code>--preserve-symlinks</code><span><a class="mark" href="#cli_preserve_symlinks" id="cli_preserve_symlinks">#</a></span></h3>
+<h4><code>--preserve-symlinks</code><span><a class="mark" href="#cli_preserve_symlinks" id="cli_preserve_symlinks">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -17977,7 +18820,7 @@ be thrown if <code>moduleA</code> attempts to require <code>moduleB</code> as a
  └── moduleA
      ├── index.js
      └── package.json</code></pre>
-<p>The <code>--preserve-symlinks</code> command line flag instructs Node.js to use the
+<p>The <code>--preserve-symlinks</code> command-line flag instructs Node.js to use the
 symlink path for modules as opposed to the real path, allowing symbolically
 linked peer dependencies to be found.</p>
 <p>Note, however, that using <code>--preserve-symlinks</code> can have other side effects.
@@ -17988,7 +18831,7 @@ times, causing an exception to be thrown).</p>
 <p>The <code>--preserve-symlinks</code> flag does not apply to the main module, which allows
 <code>node --preserve-symlinks node_module/.bin/&#x3C;foo></code> to work. To apply the same
 behavior for the main module, also use <code>--preserve-symlinks-main</code>.</p>
-<h3><code>--preserve-symlinks-main</code><span><a class="mark" href="#cli_preserve_symlinks_main" id="cli_preserve_symlinks_main">#</a></span></h3>
+<h4><code>--preserve-symlinks-main</code><span><a class="mark" href="#cli_preserve_symlinks_main" id="cli_preserve_symlinks_main">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.2.0</span>
 </div>
@@ -17997,22 +18840,22 @@ caching the main module (<code>require.main</code>).</p>
 <p>This flag exists so that the main module can be opted-in to the same behavior
 that <code>--preserve-symlinks</code> gives to all other imports; they are separate flags,
 however, for backward compatibility with older Node.js versions.</p>
-<p><code>--preserve-symlinks-main</code> does not imply <code>--preserve-symlinks</code>; it
-is expected that <code>--preserve-symlinks-main</code> will be used in addition to
+<p><code>--preserve-symlinks-main</code> does not imply <code>--preserve-symlinks</code>; use
+<code>--preserve-symlinks-main</code> in addition to
 <code>--preserve-symlinks</code> when it is not desirable to follow symlinks before
 resolving relative paths.</p>
 <p>See <code>--preserve-symlinks</code> for more information.</p>
-<h3><code>--prof</code><span><a class="mark" href="#cli_prof" id="cli_prof">#</a></span></h3>
+<h4><code>--prof</code><span><a class="mark" href="#cli_prof" id="cli_prof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
 <p>Generate V8 profiler output.</p>
-<h3><code>--prof-process</code><span><a class="mark" href="#cli_prof_process" id="cli_prof_process">#</a></span></h3>
+<h4><code>--prof-process</code><span><a class="mark" href="#cli_prof_process" id="cli_prof_process">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.2.0</span>
 </div>
 <p>Process V8 profiler output generated using the V8 option <code>--prof</code>.</p>
-<h3><code>--redirect-warnings=file</code><span><a class="mark" href="#cli_redirect_warnings_file" id="cli_redirect_warnings_file">#</a></span></h3>
+<h4><code>--redirect-warnings=file</code><span><a class="mark" href="#cli_redirect_warnings_file" id="cli_redirect_warnings_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -18022,53 +18865,53 @@ If an error occurs while attempting to write the warning to the file, the
 warning will be written to stderr instead.</p>
 <p>The <code>file</code> name may be an absolute path. If it is not, the default directory it
 will be written to is controlled by the
-<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command line option.</p>
-<h3><code>--report-compact</code><span><a class="mark" href="#cli_report_compact" id="cli_report_compact">#</a></span></h3>
+<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command-line option.</p>
+<h4><code>--report-compact</code><span><a class="mark" href="#cli_report_compact" id="cli_report_compact">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.12.0</span>
 </div>
 <p>Write reports in a compact format, single-line JSON, more easily consumable
 by log processing systems than the default multi-line format designed for
 human consumption.</p>
-<h3><code>--report-dir=directory</code>, <code>report-directory=directory</code><span><a class="mark" href="#cli_report_dir_directory_report_directory_directory" id="cli_report_dir_directory_report_directory_directory">#</a></span></h3>
+<h4><code>--report-dir=directory</code>, <code>report-directory=directory</code><span><a class="mark" href="#cli_report_dir_directory_report_directory_directory" id="cli_report_dir_directory_report_directory_directory">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>Changed from <code>--diagnostic-report-directory</code> to <code>--report-directory</code></p></td></tr>
+<td><p>Changed from <code>--diagnostic-report-directory</code> to <code>--report-directory</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Location at which the report will be generated.</p>
-<h3><code>--report-filename=filename</code><span><a class="mark" href="#cli_report_filename_filename" id="cli_report_filename_filename">#</a></span></h3>
+<h4><code>--report-filename=filename</code><span><a class="mark" href="#cli_report_filename_filename" id="cli_report_filename_filename">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-filename</code> to <code>--report-filename</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-filename</code> to <code>--report-filename</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Name of the file to which the report will be written.</p>
-<h3><code>--report-on-fatalerror</code><span><a class="mark" href="#cli_report_on_fatalerror" id="cli_report_on_fatalerror">#</a></span></h3>
+<h4><code>--report-on-fatalerror</code><span><a class="mark" href="#cli_report_on_fatalerror" id="cli_report_on_fatalerror">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.0.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-on-fatalerror</code> to <code>--report-on-fatalerror</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-on-fatalerror</code> to <code>--report-on-fatalerror</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
@@ -18079,15 +18922,15 @@ the Node.js runtime such as out of memory) that lead to termination of the
 application. Useful to inspect various diagnostic data elements such as heap,
 stack, event loop state, resource consumption etc. to reason about the fatal
 error.</p>
-<h3><code>--report-on-signal</code><span><a class="mark" href="#cli_report_on_signal" id="cli_report_on_signal">#</a></span></h3>
+<h4><code>--report-on-signal</code><span><a class="mark" href="#cli_report_on_signal" id="cli_report_on_signal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-on-signal</code> to <code>--report-on-signal</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-on-signal</code> to <code>--report-on-signal</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
@@ -18096,15 +18939,15 @@ error.</p>
 <p>Enables report to be generated upon receiving the specified (or predefined)
 signal to the running Node.js process. The signal to trigger the report is
 specified through <code>--report-signal</code>.</p>
-<h3><code>--report-signal=signal</code><span><a class="mark" href="#cli_report_signal_signal" id="cli_report_signal_signal">#</a></span></h3>
+<h4><code>--report-signal=signal</code><span><a class="mark" href="#cli_report_signal_signal" id="cli_report_signal_signal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-signal</code> to <code>--report-signal</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-signal</code> to <code>--report-signal</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
@@ -18112,15 +18955,15 @@ specified through <code>--report-signal</code>.</p>
 </div>
 <p>Sets or resets the signal for report generation (not supported on Windows).
 Default signal is <code>SIGUSR2</code>.</p>
-<h3><code>--report-uncaught-exception</code><span><a class="mark" href="#cli_report_uncaught_exception" id="cli_report_uncaught_exception">#</a></span></h3>
+<h4><code>--report-uncaught-exception</code><span><a class="mark" href="#cli_report_uncaught_exception" id="cli_report_uncaught_exception">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-uncaught-exception</code> to <code>--report-uncaught-exception</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-uncaught-exception</code> to <code>--report-uncaught-exception</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
@@ -18129,146 +18972,172 @@ Default signal is <code>SIGUSR2</code>.</p>
 <p>Enables report to be generated on uncaught exceptions. Useful when inspecting
 the JavaScript stack in conjunction with native stack and other runtime
 environment data.</p>
-<h3><code>--throw-deprecation</code><span><a class="mark" href="#cli_throw_deprecation" id="cli_throw_deprecation">#</a></span></h3>
+<h4><code>--throw-deprecation</code><span><a class="mark" href="#cli_throw_deprecation" id="cli_throw_deprecation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
 <p>Throw errors for deprecations.</p>
-<h3><code>--title=title</code><span><a class="mark" href="#cli_title_title" id="cli_title_title">#</a></span></h3>
+<h4><code>--title=title</code><span><a class="mark" href="#cli_title_title" id="cli_title_title">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 </div>
 <p>Set <code>process.title</code> on startup.</p>
-<h3><code>--tls-cipher-list=list</code><span><a class="mark" href="#cli_tls_cipher_list_list" id="cli_tls_cipher_list_list">#</a></span></h3>
+<h4><code>--tls-cipher-list=list</code><span><a class="mark" href="#cli_tls_cipher_list_list" id="cli_tls_cipher_list_list">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v4.0.0</span>
 </div>
 <p>Specify an alternative default TLS cipher list. Requires Node.js to be built
 with crypto support (default).</p>
-<h3><code>--tls-keylog=file</code><span><a class="mark" href="#cli_tls_keylog_file" id="cli_tls_keylog_file">#</a></span></h3>
+<h4><code>--tls-keylog=file</code><span><a class="mark" href="#cli_tls_keylog_file" id="cli_tls_keylog_file">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <p>Log TLS key material to a file. The key material is in NSS <code>SSLKEYLOGFILE</code>
 format and can be used by software (such as Wireshark) to decrypt the TLS
 traffic.</p>
-<h3><code>--tls-max-v1.2</code><span><a class="mark" href="#cli_tls_max_v1_2" id="cli_tls_max_v1_2">#</a></span></h3>
+<h4><code>--tls-max-v1.2</code><span><a class="mark" href="#cli_tls_max_v1_2" id="cli_tls_max_v1_2">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <p>Set <a href="#tls_tls_default_max_version"><code>tls.DEFAULT_MAX_VERSION</code></a> to 'TLSv1.2'. Use to disable support for
 TLSv1.3.</p>
-<h3><code>--tls-max-v1.3</code><span><a class="mark" href="#cli_tls_max_v1_3" id="cli_tls_max_v1_3">#</a></span></h3>
+<h4><code>--tls-max-v1.3</code><span><a class="mark" href="#cli_tls_max_v1_3" id="cli_tls_max_v1_3">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>Set default <a href="#tls_tls_default_max_version"><code>tls.DEFAULT_MAX_VERSION</code></a> to 'TLSv1.3'. Use to enable support
 for TLSv1.3.</p>
-<h3><code>--tls-min-v1.0</code><span><a class="mark" href="#cli_tls_min_v1_0" id="cli_tls_min_v1_0">#</a></span></h3>
+<h4><code>--tls-min-v1.0</code><span><a class="mark" href="#cli_tls_min_v1_0" id="cli_tls_min_v1_0">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <p>Set default <a href="#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a> to 'TLSv1'. Use for compatibility with
 old TLS clients or servers.</p>
-<h3><code>--tls-min-v1.1</code><span><a class="mark" href="#cli_tls_min_v1_1" id="cli_tls_min_v1_1">#</a></span></h3>
+<h4><code>--tls-min-v1.1</code><span><a class="mark" href="#cli_tls_min_v1_1" id="cli_tls_min_v1_1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <p>Set default <a href="#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a> to 'TLSv1.1'. Use for compatibility
 with old TLS clients or servers.</p>
-<h3><code>--tls-min-v1.2</code><span><a class="mark" href="#cli_tls_min_v1_2" id="cli_tls_min_v1_2">#</a></span></h3>
+<h4><code>--tls-min-v1.2</code><span><a class="mark" href="#cli_tls_min_v1_2" id="cli_tls_min_v1_2">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.2.0</span>
+<span>Added in: v12.2.0, v10.20.0</span>
 </div>
 <p>Set default <a href="#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a> to 'TLSv1.2'. This is the default for
 12.x and later, but the option is supported for compatibility with older Node.js
 versions.</p>
-<h3><code>--tls-min-v1.3</code><span><a class="mark" href="#cli_tls_min_v1_3" id="cli_tls_min_v1_3">#</a></span></h3>
+<h4><code>--tls-min-v1.3</code><span><a class="mark" href="#cli_tls_min_v1_3" id="cli_tls_min_v1_3">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>Set default <a href="#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a> to 'TLSv1.3'. Use to disable support
 for TLSv1.2, which is not as secure as TLSv1.3.</p>
-<h3><code>--trace-deprecation</code><span><a class="mark" href="#cli_trace_deprecation" id="cli_trace_deprecation">#</a></span></h3>
+<h4><code>--trace-atomics-wait</code><span><a class="mark" href="#cli_trace_atomics_wait" id="cli_trace_atomics_wait">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.3.0</span>
+</div>
+<p>Print short summaries of calls to <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait"><code>Atomics.wait()</code></a> to stderr.
+The output could look like this:</p>
+<pre><code class="language-text">(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 1, inf) started
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 1, inf) did not wait because the values mismatched
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 0, 10) started
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 0, 10) timed out
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 4, 0, inf) started
+(node:15701) [Thread 1] Atomics.wait(&#x26;lt;address> + 4, -1, inf) started
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 4, 0, inf) was woken up by another thread
+(node:15701) [Thread 1] Atomics.wait(&#x26;lt;address> + 4, -1, inf) was woken up by another thread</code></pre>
+<p>The fields here correspond to:</p>
+<ul>
+<li>The thread id as given by <a href="#worker_threads_worker_threadid"><code>worker_threads.threadId</code></a></li>
+<li>The base address of the <code>SharedArrayBuffer</code> in question, as well as the
+byte offset corresponding to the index passed to <code>Atomics.wait()</code></li>
+<li>The expected value that was passed to <code>Atomics.wait()</code></li>
+<li>The timeout passed to <code>Atomics.wait</code></li>
+</ul>
+<h4><code>--trace-deprecation</code><span><a class="mark" href="#cli_trace_deprecation" id="cli_trace_deprecation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
 <p>Print stack traces for deprecations.</p>
-<h3><code>--trace-event-categories</code><span><a class="mark" href="#cli_trace_event_categories" id="cli_trace_event_categories">#</a></span></h3>
+<h4><code>--trace-event-categories</code><span><a class="mark" href="#cli_trace_event_categories" id="cli_trace_event_categories">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
 <p>A comma separated list of categories that should be traced when trace event
 tracing is enabled using <code>--trace-events-enabled</code>.</p>
-<h3><code>--trace-event-file-pattern</code><span><a class="mark" href="#cli_trace_event_file_pattern" id="cli_trace_event_file_pattern">#</a></span></h3>
+<h4><code>--trace-event-file-pattern</code><span><a class="mark" href="#cli_trace_event_file_pattern" id="cli_trace_event_file_pattern">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.8.0</span>
 </div>
 <p>Template string specifying the filepath for the trace event data, it
 supports <code>${rotation}</code> and <code>${pid}</code>.</p>
-<h3><code>--trace-events-enabled</code><span><a class="mark" href="#cli_trace_events_enabled" id="cli_trace_events_enabled">#</a></span></h3>
+<h4><code>--trace-events-enabled</code><span><a class="mark" href="#cli_trace_events_enabled" id="cli_trace_events_enabled">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
 <p>Enables the collection of trace event tracing information.</p>
-<h3><code>--trace-exit</code><span><a class="mark" href="#cli_trace_exit" id="cli_trace_exit">#</a></span></h3>
+<h4><code>--trace-exit</code><span><a class="mark" href="#cli_trace_exit" id="cli_trace_exit">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.5.0, v12.16.0</span>
 </div>
 <p>Prints a stack trace whenever an environment is exited proactively,
 i.e. invoking <code>process.exit()</code>.</p>
-<h3><code>--trace-sigint</code><span><a class="mark" href="#cli_trace_sigint" id="cli_trace_sigint">#</a></span></h3>
+<h4><code>--trace-sigint</code><span><a class="mark" href="#cli_trace_sigint" id="cli_trace_sigint">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.9.0</span>
 </div>
 <p>Prints a stack trace on SIGINT.</p>
-<h3><code>--trace-sync-io</code><span><a class="mark" href="#cli_trace_sync_io" id="cli_trace_sync_io">#</a></span></h3>
+<h4><code>--trace-sync-io</code><span><a class="mark" href="#cli_trace_sync_io" id="cli_trace_sync_io">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v2.1.0</span>
 </div>
 <p>Prints a stack trace whenever synchronous I/O is detected after the first turn
 of the event loop.</p>
-<h3><code>--trace-tls</code><span><a class="mark" href="#cli_trace_tls" id="cli_trace_tls">#</a></span></h3>
+<h4><code>--trace-tls</code><span><a class="mark" href="#cli_trace_tls" id="cli_trace_tls">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.2.0</span>
 </div>
 <p>Prints TLS packet trace information to <code>stderr</code>. This can be used to debug TLS
 connection problems.</p>
-<h3><code>--trace-uncaught</code><span><a class="mark" href="#cli_trace_uncaught" id="cli_trace_uncaught">#</a></span></h3>
+<h4><code>--trace-uncaught</code><span><a class="mark" href="#cli_trace_uncaught" id="cli_trace_uncaught">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.1.0</span>
 </div>
 <p>Print stack traces for uncaught exceptions; usually, the stack trace associated
 with the creation of an <code>Error</code> is printed, whereas this makes Node.js also
 print the stack trace associated with throwing the value (which does not need
 to be an <code>Error</code> instance).</p>
 <p>Enabling this option may affect garbage collection behavior negatively.</p>
-<h3><code>--trace-warnings</code><span><a class="mark" href="#cli_trace_warnings" id="cli_trace_warnings">#</a></span></h3>
+<h4><code>--trace-warnings</code><span><a class="mark" href="#cli_trace_warnings" id="cli_trace_warnings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Print stack traces for process warnings (including deprecations).</p>
-<h3><code>--track-heap-objects</code><span><a class="mark" href="#cli_track_heap_objects" id="cli_track_heap_objects">#</a></span></h3>
+<h4><code>--track-heap-objects</code><span><a class="mark" href="#cli_track_heap_objects" id="cli_track_heap_objects">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v2.4.0</span>
 </div>
 <p>Track heap object allocations for heap snapshots.</p>
-<h3><code>--unhandled-rejections=mode</code><span><a class="mark" href="#cli_unhandled_rejections_mode" id="cli_unhandled_rejections_mode">#</a></span></h3>
+<h4><code>--unhandled-rejections=mode</code><span><a class="mark" href="#cli_unhandled_rejections_mode" id="cli_unhandled_rejections_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.17.0</span>
 </div>
 <p>By default all unhandled rejections trigger a warning plus a deprecation warning
 for the very first unhandled rejection in case no <a href="#process_event_unhandledrejection"><code>unhandledRejection</code></a> hook
 is used.</p>
 <p>Using this flag allows to change what should happen when an unhandled rejection
-occurs. One of three modes can be chosen:</p>
+occurs. One of the following modes can be chosen:</p>
 <ul>
+<li><code>throw</code>: Emit <a href="#process_event_unhandledrejection"><code>unhandledRejection</code></a>. If this hook is not set, raise the
+unhandled rejection as an uncaught exception.</li>
 <li><code>strict</code>: Raise the unhandled rejection as an uncaught exception.</li>
 <li><code>warn</code>: Always trigger a warning, no matter if the <a href="#process_event_unhandledrejection"><code>unhandledRejection</code></a>
 hook is set or not but do not print the deprecation warning.</li>
+<li><code>warn-with-error-code</code>: Emit <a href="#process_event_unhandledrejection"><code>unhandledRejection</code></a>. If this hook is not
+set, trigger a warning, and set the process exit code to 1.</li>
 <li><code>none</code>: Silence all warnings.</li>
 </ul>
-<h3><code>--use-bundled-ca</code>, <code>--use-openssl-ca</code><span><a class="mark" href="#cli_use_bundled_ca_use_openssl_ca" id="cli_use_bundled_ca_use_openssl_ca">#</a></span></h3>
+<h4><code>--use-bundled-ca</code>, <code>--use-openssl-ca</code><span><a class="mark" href="#cli_use_bundled_ca_use_openssl_ca" id="cli_use_bundled_ca_use_openssl_ca">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.11.0</span>
 </div>
@@ -18283,9 +19152,9 @@ maintainers and system administrators. OpenSSL CA store location is dependent on
 configuration of the OpenSSL library but this can be altered at runtime using
 environment variables.</p>
 <p>See <code>SSL_CERT_DIR</code> and <code>SSL_CERT_FILE</code>.</p>
-<h3><code>--use-largepages=mode</code><span><a class="mark" href="#cli_use_largepages_mode" id="cli_use_largepages_mode">#</a></span></h3>
+<h4><code>--use-largepages=mode</code><span><a class="mark" href="#cli_use_largepages_mode" id="cli_use_largepages_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.6.0</span>
 </div>
 <p>Re-map the Node.js static code to large memory pages at startup. If supported on
 the target system, this will cause the Node.js static code to be moved onto 2
@@ -18298,12 +19167,12 @@ be ignored and a message will be printed to standard error.</li>
 <li><code>silent</code>: If supported by the OS, mapping will be attempted. Failure to map
 will be ignored and will not be reported.</li>
 </ul>
-<h3><code>--v8-options</code><span><a class="mark" href="#cli_v8_options" id="cli_v8_options">#</a></span></h3>
+<h4><code>--v8-options</code><span><a class="mark" href="#cli_v8_options" id="cli_v8_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.3</span>
 </div>
-<p>Print V8 command line options.</p>
-<h3><code>--v8-pool-size=num</code><span><a class="mark" href="#cli_v8_pool_size_num" id="cli_v8_pool_size_num">#</a></span></h3>
+<p>Print V8 command-line options.</p>
+<h4><code>--v8-pool-size=num</code><span><a class="mark" href="#cli_v8_pool_size_num" id="cli_v8_pool_size_num">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -18312,13 +19181,13 @@ will be ignored and will not be reported.</li>
 on the number of online processors.</p>
 <p>If the value provided is larger than V8's maximum, then the largest value
 will be chosen.</p>
-<h3><code>--zero-fill-buffers</code><span><a class="mark" href="#cli_zero_fill_buffers" id="cli_zero_fill_buffers">#</a></span></h3>
+<h4><code>--zero-fill-buffers</code><span><a class="mark" href="#cli_zero_fill_buffers" id="cli_zero_fill_buffers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Automatically zero-fills all newly allocated <a href="#buffer_class_buffer"><code>Buffer</code></a> and <a href="#buffer_class_slowbuffer"><code>SlowBuffer</code></a>
 instances.</p>
-<h3><code>-c</code>, <code>--check</code><span><a class="mark" href="#cli_c_check" id="cli_c_check">#</a></span></h3>
+<h4><code>-c</code>, <code>--check</code><span><a class="mark" href="#cli_c_check" id="cli_c_check">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -18331,7 +19200,7 @@ instances.</p>
 </details>
 </div>
 <p>Syntax check the script without executing.</p>
-<h3><code>-e</code>, <code>--eval "script"</code><span><a class="mark" href="#cli_e_eval_script" id="cli_e_eval_script">#</a></span></h3>
+<h4><code>-e</code>, <code>--eval "script"</code><span><a class="mark" href="#cli_e_eval_script" id="cli_e_eval_script">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -18348,18 +19217,18 @@ predefined in the REPL can also be used in <code>script</code>.</p>
 <p>On Windows, using <code>cmd.exe</code> a single quote will not work correctly because it
 only recognizes double <code>"</code> for quoting. In Powershell or Git bash, both <code>'</code>
 and <code>"</code> are usable.</p>
-<h3><code>-h</code>, <code>--help</code><span><a class="mark" href="#cli_h_help" id="cli_h_help">#</a></span></h3>
+<h4><code>-h</code>, <code>--help</code><span><a class="mark" href="#cli_h_help" id="cli_h_help">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.3</span>
 </div>
-<p>Print node command line options.
+<p>Print node command-line options.
 The output of this option is less detailed than this document.</p>
-<h3><code>-i</code>, <code>--interactive</code><span><a class="mark" href="#cli_i_interactive" id="cli_i_interactive">#</a></span></h3>
+<h4><code>-i</code>, <code>--interactive</code><span><a class="mark" href="#cli_i_interactive" id="cli_i_interactive">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>Opens the REPL even if stdin does not appear to be a terminal.</p>
-<h3><code>-p</code>, <code>--print "script"</code><span><a class="mark" href="#cli_p_print_script" id="cli_p_print_script">#</a></span></h3>
+<h4><code>-p</code>, <code>--print "script"</code><span><a class="mark" href="#cli_p_print_script" id="cli_p_print_script">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -18372,32 +19241,45 @@ The output of this option is less detailed than this document.</p>
 </details>
 </div>
 <p>Identical to <code>-e</code> but prints the result.</p>
-<h3><code>-r</code>, <code>--require module</code><span><a class="mark" href="#cli_r_require_module" id="cli_r_require_module">#</a></span></h3>
+<h4><code>-r</code>, <code>--require module</code><span><a class="mark" href="#cli_r_require_module" id="cli_r_require_module">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
 <p>Preload the specified module at startup.</p>
 <p>Follows <code>require()</code>'s module resolution
 rules. <code>module</code> may be either a path to a file, or a node module name.</p>
-<h3><code>-v</code>, <code>--version</code><span><a class="mark" href="#cli_v_version" id="cli_v_version">#</a></span></h3>
+<p>Only CommonJS modules are supported. Attempting to preload a
+ES6 Module using <code>--require</code> will fail with an error.</p>
+<h4><code>-v</code>, <code>--version</code><span><a class="mark" href="#cli_v_version" id="cli_v_version">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.3</span>
 </div>
 <p>Print node's version.</p>
-<h2>Environment variables<span><a class="mark" href="#cli_environment_variables" id="cli_environment_variables">#</a></span></h2>
-<h3><code>NODE_DEBUG=module[,…]</code><span><a class="mark" href="#cli_node_debug_module" id="cli_node_debug_module">#</a></span></h3>
+</section><section><h3>Environment variables<span><a class="mark" href="#cli_environment_variables" id="cli_environment_variables">#</a></span></h3>
+<h4><code>FORCE_COLOR=[1, 2, 3]</code><span><a class="mark" href="#cli_force_color_1_2_3" id="cli_force_color_1_2_3">#</a></span></h4>
+<p>The <code>FORCE_COLOR</code> environment variable is used to
+enable ANSI colorized output. The value may be:</p>
+<ul>
+<li><code>1</code>, <code>true</code>, or the empty string <code>''</code> indicate 16-color support,</li>
+<li><code>2</code> to indicate 256-color support, or</li>
+<li><code>3</code> to indicate 16 million-color support.</li>
+</ul>
+<p>When <code>FORCE_COLOR</code> is used and set to a supported value, both the <code>NO_COLOR</code>,
+and <code>NODE_DISABLE_COLORS</code> environment variables are ignored.</p>
+<p>Any other value will result in colorized output being disabled.</p>
+<h4><code>NODE_DEBUG=module[,…]</code><span><a class="mark" href="#cli_node_debug_module" id="cli_node_debug_module">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.32</span>
 </div>
 <p><code>','</code>-separated list of core modules that should print debug information.</p>
-<h3><code>NODE_DEBUG_NATIVE=module[,…]</code><span><a class="mark" href="#cli_node_debug_native_module" id="cli_node_debug_native_module">#</a></span></h3>
+<h4><code>NODE_DEBUG_NATIVE=module[,…]</code><span><a class="mark" href="#cli_node_debug_native_module" id="cli_node_debug_native_module">#</a></span></h4>
 <p><code>','</code>-separated list of core C++ modules that should print debug information.</p>
-<h3><code>NODE_DISABLE_COLORS=1</code><span><a class="mark" href="#cli_node_disable_colors_1" id="cli_node_disable_colors_1">#</a></span></h3>
+<h4><code>NODE_DISABLE_COLORS=1</code><span><a class="mark" href="#cli_node_disable_colors_1" id="cli_node_disable_colors_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
 <p>When set, colors will not be used in the REPL.</p>
-<h3><code>NODE_EXTRA_CA_CERTS=file</code><span><a class="mark" href="#cli_node_extra_ca_certs_file" id="cli_node_extra_ca_certs_file">#</a></span></h3>
+<h4><code>NODE_EXTRA_CA_CERTS=file</code><span><a class="mark" href="#cli_node_extra_ca_certs_file" id="cli_node_extra_ca_certs_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.3.0</span>
 </div>
@@ -18410,35 +19292,37 @@ malformed, but any errors are otherwise ignored.</p>
 options property is explicitly specified for a TLS or HTTPS client or server.</p>
 <p>This environment variable is ignored when <code>node</code> runs as setuid root or
 has Linux file capabilities set.</p>
-<h3><code>NODE_ICU_DATA=file</code><span><a class="mark" href="#cli_node_icu_data_file" id="cli_node_icu_data_file">#</a></span></h3>
+<p>The <code>NODE_EXTRA_CA_CERTS</code> environment variable is only read when the Node.js
+process is first launched. Changing the value at runtime using
+<code>process.env.NODE_EXTRA_CA_CERTS</code> has no effect on the current process.</p>
+<h4><code>NODE_ICU_DATA=file</code><span><a class="mark" href="#cli_node_icu_data_file" id="cli_node_icu_data_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
 <p>Data path for ICU (<code>Intl</code> object) data. Will extend linked-in data when compiled
 with small-icu support.</p>
-<h3><code>NODE_NO_WARNINGS=1</code><span><a class="mark" href="#cli_node_no_warnings_1" id="cli_node_no_warnings_1">#</a></span></h3>
+<h4><code>NODE_NO_WARNINGS=1</code><span><a class="mark" href="#cli_node_no_warnings_1" id="cli_node_no_warnings_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.11.0</span>
 </div>
 <p>When set to <code>1</code>, process warnings are silenced.</p>
-<h3><code>NODE_OPTIONS=options...</code><span><a class="mark" href="#cli_node_options_options" id="cli_node_options_options">#</a></span></h3>
+<h4><code>NODE_OPTIONS=options...</code><span><a class="mark" href="#cli_node_options_options" id="cli_node_options_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
-<p>A space-separated list of command line options. <code>options...</code> are interpreted
-before command line options, so command line options will override or
+<p>A space-separated list of command-line options. <code>options...</code> are interpreted
+before command-line options, so command-line options will override or
 compound after anything in <code>options...</code>. Node.js will exit with an error if
 an option that is not allowed in the environment is used, such as <code>-p</code> or a
 script file.</p>
-<p>In case an option value happens to contain a space (for example a path listed
-in <code>--require</code>), it must be escaped using double quotes. For example:</p>
+<p>If an option value contains a space, it can be escaped using double quotes:</p>
 <pre><code class="language-bash">NODE_OPTIONS=<span class="hljs-string">'--require "./my path/file.js"'</span></code></pre>
-<p>A singleton flag passed as a command line option will override the same flag
+<p>A singleton flag passed as a command-line option will override the same flag
 passed into <code>NODE_OPTIONS</code>:</p>
 <pre><code class="language-bash"><span class="hljs-comment"># The inspector will be available on port 5555</span>
 NODE_OPTIONS=<span class="hljs-string">'--inspect=localhost:4444'</span> node --inspect=localhost:5555</code></pre>
 <p>A flag that can be passed multiple times will be treated as if its
-<code>NODE_OPTIONS</code> instances were passed first, and then its command line
+<code>NODE_OPTIONS</code> instances were passed first, and then its command-line
 instances afterwards:</p>
 <pre><code class="language-bash">NODE_OPTIONS=<span class="hljs-string">'--require "./a.js"'</span> node --require <span class="hljs-string">"./b.js"</span>
 <span class="hljs-comment"># is equivalent to:</span>
@@ -18446,11 +19330,13 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <p>Node.js options that are allowed are:</p>
 <!-- node-options-node start -->
 <ul>
-<li><code>--conditions</code></li>
+<li><code>--conditions</code>, <code>-C</code></li>
 <li><code>--diagnostic-dir</code></li>
 <li><code>--disable-proto</code></li>
+<li><code>--dns-result-order</code></li>
 <li><code>--enable-fips</code></li>
 <li><code>--enable-source-maps</code></li>
+<li><code>--experimental-abortcontroller</code></li>
 <li><code>--experimental-import-meta-resolve</code></li>
 <li><code>--experimental-json-modules</code></li>
 <li><code>--experimental-loader</code></li>
@@ -18458,15 +19344,16 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--experimental-policy</code></li>
 <li><code>--experimental-repl-await</code></li>
 <li><code>--experimental-specifier-resolution</code></li>
+<li><code>--experimental-top-level-await</code></li>
 <li><code>--experimental-vm-modules</code></li>
 <li><code>--experimental-wasi-unstable-preview1</code></li>
 <li><code>--experimental-wasm-modules</code></li>
 <li><code>--force-context-aware</code></li>
 <li><code>--force-fips</code></li>
 <li><code>--frozen-intrinsics</code></li>
+<li><code>--heapsnapshot-near-heap-limit</code></li>
 <li><code>--heapsnapshot-signal</code></li>
 <li><code>--http-parser</code></li>
-<li><code>--http-server-default-timeout</code></li>
 <li><code>--icu-data-dir</code></li>
 <li><code>--input-type</code></li>
 <li><code>--insecure-http-parser</code></li>
@@ -18479,6 +19366,7 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--no-deprecation</code></li>
 <li><code>--no-force-async-hooks-checks</code></li>
 <li><code>--no-warnings</code></li>
+<li><code>--node-memory-debug</code></li>
 <li><code>--openssl-config</code></li>
 <li><code>--pending-deprecation</code></li>
 <li><code>--policy-integrity</code></li>
@@ -18504,6 +19392,7 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--tls-min-v1.1</code></li>
 <li><code>--tls-min-v1.2</code></li>
 <li><code>--tls-min-v1.3</code></li>
+<li><code>--trace-atomics-wait</code></li>
 <li><code>--trace-deprecation</code></li>
 <li><code>--trace-event-categories</code></li>
 <li><code>--trace-event-file-pattern</code></li>
@@ -18520,10 +19409,9 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--use-largepages</code></li>
 <li><code>--use-openssl-ca</code></li>
 <li><code>--v8-pool-size</code></li>
-<li><code>--zero-fill-buffers</code>
-<!-- node-options-node end -->
-</li>
+<li><code>--zero-fill-buffers</code></li>
 </ul>
+<!-- node-options-node end -->
 <p>V8 options that are allowed are:</p>
 <!-- node-options-v8 start -->
 <ul>
@@ -18537,39 +19425,38 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--perf-basic-prof</code></li>
 <li><code>--perf-prof-unwinding-info</code></li>
 <li><code>--perf-prof</code></li>
-<li><code>--stack-trace-limit</code>
-<!-- node-options-v8 end -->
-</li>
+<li><code>--stack-trace-limit</code></li>
 </ul>
+<!-- node-options-v8 end -->
 <p><code>--perf-basic-prof-only-functions</code>, <code>--perf-basic-prof</code>,
 <code>--perf-prof-unwinding-info</code>, and <code>--perf-prof</code> are only available on Linux.</p>
-<h3><code>NODE_PATH=path[:…]</code><span><a class="mark" href="#cli_node_path_path" id="cli_node_path_path">#</a></span></h3>
+<h4><code>NODE_PATH=path[:…]</code><span><a class="mark" href="#cli_node_path_path" id="cli_node_path_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.32</span>
 </div>
 <p><code>':'</code>-separated list of directories prefixed to the module search path.</p>
 <p>On Windows, this is a <code>';'</code>-separated list instead.</p>
-<h3><code>NODE_PENDING_DEPRECATION=1</code><span><a class="mark" href="#cli_node_pending_deprecation_1" id="cli_node_pending_deprecation_1">#</a></span></h3>
+<h4><code>NODE_PENDING_DEPRECATION=1</code><span><a class="mark" href="#cli_node_pending_deprecation_1" id="cli_node_pending_deprecation_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>When set to <code>1</code>, emit pending deprecation warnings.</p>
 <p>Pending deprecations are generally identical to a runtime deprecation with the
 notable exception that they are turned <em>off</em> by default and will not be emitted
-unless either the <code>--pending-deprecation</code> command line flag, or the
+unless either the <code>--pending-deprecation</code> command-line flag, or the
 <code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations
 are used to provide a kind of selective "early warning" mechanism that
 developers may leverage to detect deprecated API usage.</p>
-<h3><code>NODE_PENDING_PIPE_INSTANCES=instances</code><span><a class="mark" href="#cli_node_pending_pipe_instances_instances" id="cli_node_pending_pipe_instances_instances">#</a></span></h3>
+<h4><code>NODE_PENDING_PIPE_INSTANCES=instances</code><span><a class="mark" href="#cli_node_pending_pipe_instances_instances" id="cli_node_pending_pipe_instances_instances">#</a></span></h4>
 <p>Set the number of pending pipe instance handles when the pipe server is waiting
 for connections. This setting applies to Windows only.</p>
-<h3><code>NODE_PRESERVE_SYMLINKS=1</code><span><a class="mark" href="#cli_node_preserve_symlinks_1" id="cli_node_preserve_symlinks_1">#</a></span></h3>
+<h4><code>NODE_PRESERVE_SYMLINKS=1</code><span><a class="mark" href="#cli_node_preserve_symlinks_1" id="cli_node_preserve_symlinks_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.1.0</span>
 </div>
 <p>When set to <code>1</code>, instructs the module loader to preserve symbolic links when
 resolving and caching modules.</p>
-<h3><code>NODE_REDIRECT_WARNINGS=file</code><span><a class="mark" href="#cli_node_redirect_warnings_file" id="cli_node_redirect_warnings_file">#</a></span></h3>
+<h4><code>NODE_REDIRECT_WARNINGS=file</code><span><a class="mark" href="#cli_node_redirect_warnings_file" id="cli_node_redirect_warnings_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -18578,24 +19465,31 @@ printing to stderr. The file will be created if it does not exist, and will be
 appended to if it does. If an error occurs while attempting to write the
 warning to the file, the warning will be written to stderr instead. This is
 equivalent to using the <code>--redirect-warnings=file</code> command-line flag.</p>
-<h3><code>NODE_REPL_HISTORY=file</code><span><a class="mark" href="#cli_node_repl_history_file" id="cli_node_repl_history_file">#</a></span></h3>
+<h4><code>NODE_REPL_HISTORY=file</code><span><a class="mark" href="#cli_node_repl_history_file" id="cli_node_repl_history_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
 <p>Path to the file used to store the persistent REPL history. The default path is
 <code>~/.node_repl_history</code>, which is overridden by this variable. Setting the value
 to an empty string (<code>''</code> or <code>' '</code>) disables persistent REPL history.</p>
-<h3><code>NODE_REPL_EXTERNAL_MODULE=file</code><span><a class="mark" href="#cli_node_repl_external_module_file" id="cli_node_repl_external_module_file">#</a></span></h3>
+<h4><code>NODE_REPL_EXTERNAL_MODULE=file</code><span><a class="mark" href="#cli_node_repl_external_module_file" id="cli_node_repl_external_module_file">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <p>Path to a Node.js module which will be loaded in place of the built-in REPL.
 Overriding this value to an empty string (<code>''</code>) will use the built-in REPL.</p>
-<h3><code>NODE_TLS_REJECT_UNAUTHORIZED=value</code><span><a class="mark" href="#cli_node_tls_reject_unauthorized_value" id="cli_node_tls_reject_unauthorized_value">#</a></span></h3>
+<h4><code>NODE_SKIP_PLATFORM_CHECK=value</code><span><a class="mark" href="#cli_node_skip_platform_check_value" id="cli_node_skip_platform_check_value">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p>If <code>value</code> equals <code>'1'</code>, the check for a supported platform is skipped during
+Node.js startup. Node.js might not execute correctly. Any issues encountered
+on unsupported platforms will not be fixed.</p>
+<h4><code>NODE_TLS_REJECT_UNAUTHORIZED=value</code><span><a class="mark" href="#cli_node_tls_reject_unauthorized_value" id="cli_node_tls_reject_unauthorized_value">#</a></span></h4>
 <p>If <code>value</code> equals <code>'0'</code>, certificate validation is disabled for TLS connections.
 This makes TLS, and HTTPS by extension, insecure. The use of this environment
 variable is strongly discouraged.</p>
-<h3><code>NODE_V8_COVERAGE=dir</code><span><a class="mark" href="#cli_node_v8_coverage_dir" id="cli_node_v8_coverage_dir">#</a></span></h3>
+<h4><code>NODE_V8_COVERAGE=dir</code><span><a class="mark" href="#cli_node_v8_coverage_dir" id="cli_node_v8_coverage_dir">#</a></span></h4>
 <p>When set, Node.js will begin outputting <a href="https://v8project.blogspot.com/2017/12/javascript-code-coverage.html">V8 JavaScript code coverage</a> and
 <a href="https://sourcemaps.info/spec.html">Source Map</a> data to the directory provided as an argument (coverage
 information is written as JSON to files with a <code>coverage</code> prefix).</p>
@@ -18603,19 +19497,19 @@ information is written as JSON to files with a <code>coverage</code> prefix).</p
 easier to instrument applications that call the <code>child_process.spawn()</code> family
 of functions. <code>NODE_V8_COVERAGE</code> can be set to an empty string, to prevent
 propagation.</p>
-<h4>Coverage output<span><a class="mark" href="#cli_coverage_output" id="cli_coverage_output">#</a></span></h4>
+<h5>Coverage output<span><a class="mark" href="#cli_coverage_output" id="cli_coverage_output">#</a></span></h5>
 <p>Coverage is output as an array of <a href="https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-ScriptCoverage">ScriptCoverage</a> objects on the top-level
 key <code>result</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"result"</span>: [
-    {
-      <span class="hljs-attr">"scriptId"</span>: <span class="hljs-string">"67"</span>,
-      <span class="hljs-attr">"url"</span>: <span class="hljs-string">"internal/tty.js"</span>,
-      <span class="hljs-attr">"functions"</span>: []
-    }
-  ]
-}</code></pre>
-<h4>Source map cache<span><a class="mark" href="#cli_source_map_cache" id="cli_source_map_cache">#</a></span></h4>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"result"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"scriptId"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"67"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"url"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"internal/tty.js"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"functions"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span><span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h5>Source map cache<span><a class="mark" href="#cli_source_map_cache" id="cli_source_map_cache">#</a></span></h5>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>If found, source map data is appended to the top-level key <code>source-map-cache</code>
 on the JSON coverage object.</p>
@@ -18623,48 +19517,51 @@ on the JSON coverage object.</p>
 were extracted from, and values which include the raw source-map URL
 (in the key <code>url</code>), the parsed Source Map v3 information (in the key <code>data</code>),
 and the line lengths of the source file (in the key <code>lineLengths</code>).</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"result"</span>: [
-    {
-      <span class="hljs-attr">"scriptId"</span>: <span class="hljs-string">"68"</span>,
-      <span class="hljs-attr">"url"</span>: <span class="hljs-string">"file:///absolute/path/to/source.js"</span>,
-      <span class="hljs-attr">"functions"</span>: []
-    }
-  ],
-  <span class="hljs-attr">"source-map-cache"</span>: {
-    <span class="hljs-attr">"file:///absolute/path/to/source.js"</span>: {
-      <span class="hljs-attr">"url"</span>: <span class="hljs-string">"./path-to-map.json"</span>,
-      <span class="hljs-attr">"data"</span>: {
-        <span class="hljs-attr">"version"</span>: <span class="hljs-number">3</span>,
-        <span class="hljs-attr">"sources"</span>: [
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"result"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"scriptId"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"68"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"url"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"file:///absolute/path/to/source.js"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"functions"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span><span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"source-map-cache"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"file:///absolute/path/to/source.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"url"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./path-to-map.json"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"data"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"version"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">3</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
           <span class="hljs-string">"file:///absolute/path/to/original.js"</span>
-        ],
-        <span class="hljs-attr">"names"</span>: [
-          <span class="hljs-string">"Foo"</span>,
-          <span class="hljs-string">"console"</span>,
+        <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"names"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+          <span class="hljs-string">"Foo"</span><span class="hljs-punctuation">,</span>
+          <span class="hljs-string">"console"</span><span class="hljs-punctuation">,</span>
           <span class="hljs-string">"info"</span>
-        ],
-        <span class="hljs-attr">"mappings"</span>: <span class="hljs-string">"MAAMA,IACJC,YAAaC"</span>,
-        <span class="hljs-attr">"sourceRoot"</span>: <span class="hljs-string">"./"</span>
-      },
-      <span class="hljs-attr">"lineLengths"</span>: [
-        <span class="hljs-number">13</span>,
-        <span class="hljs-number">62</span>,
-        <span class="hljs-number">38</span>,
+        <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"mappings"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"MAAMA,IACJC,YAAaC"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"sourceRoot"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./"</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"lineLengths"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+        <span class="hljs-number">13</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-number">62</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-number">38</span><span class="hljs-punctuation">,</span>
         <span class="hljs-number">27</span>
-      ]
-    }
-  }
-}</code></pre>
-<h3><code>OPENSSL_CONF=file</code><span><a class="mark" href="#cli_openssl_conf_file" id="cli_openssl_conf_file">#</a></span></h3>
+      <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h4><code>NO_COLOR=&#x3C;any></code><span><a class="mark" href="#cli_no_color_any" id="cli_no_color_any">#</a></span></h4>
+<p><a href="https://no-color.org"><code>NO_COLOR</code></a>  is an alias for <code>NODE_DISABLE_COLORS</code>. The value of the
+environment variable is arbitrary.</p>
+<h4><code>OPENSSL_CONF=file</code><span><a class="mark" href="#cli_openssl_conf_file" id="cli_openssl_conf_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.11.0</span>
 </div>
 <p>Load an OpenSSL configuration file on startup. Among other uses, this can be
 used to enable FIPS-compliant crypto if Node.js is built with <code>./configure --openssl-fips</code>.</p>
-<p>If the <a href="#cli_openssl_config_file"><code>--openssl-config</code></a> command line option is used, the environment
+<p>If the <a href="#cli_openssl_config_file"><code>--openssl-config</code></a> command-line option is used, the environment
 variable is ignored.</p>
-<h3><code>SSL_CERT_DIR=dir</code><span><a class="mark" href="#cli_ssl_cert_dir_dir" id="cli_ssl_cert_dir_dir">#</a></span></h3>
+<h4><code>SSL_CERT_DIR=dir</code><span><a class="mark" href="#cli_ssl_cert_dir_dir" id="cli_ssl_cert_dir_dir">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -18673,7 +19570,7 @@ containing trusted certificates.</p>
 <p>Be aware that unless the child environment is explicitly set, this environment
 variable will be inherited by any child processes, and if they use OpenSSL, it
 may cause them to trust the same CAs as node.</p>
-<h3><code>SSL_CERT_FILE=file</code><span><a class="mark" href="#cli_ssl_cert_file_file" id="cli_ssl_cert_file_file">#</a></span></h3>
+<h4><code>SSL_CERT_FILE=file</code><span><a class="mark" href="#cli_ssl_cert_file_file" id="cli_ssl_cert_file_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -18682,7 +19579,7 @@ containing trusted certificates.</p>
 <p>Be aware that unless the child environment is explicitly set, this environment
 variable will be inherited by any child processes, and if they use OpenSSL, it
 may cause them to trust the same CAs as node.</p>
-<h3><code>UV_THREADPOOL_SIZE=size</code><span><a class="mark" href="#cli_uv_threadpool_size_size" id="cli_uv_threadpool_size_size">#</a></span></h3>
+<h4><code>UV_THREADPOOL_SIZE=size</code><span><a class="mark" href="#cli_uv_threadpool_size_size" id="cli_uv_threadpool_size_size">#</a></span></h4>
 <p>Set the number of threads used in libuv's threadpool to <code>size</code> threads.</p>
 <p>Asynchronous system APIs are used by Node.js whenever possible, but where they
 do not exist, libuv's threadpool is used to create asynchronous node APIs based
@@ -18702,7 +19599,7 @@ mitigate this issue, one potential solution is to increase the size of libuv's
 threadpool by setting the <code>'UV_THREADPOOL_SIZE'</code> environment variable to a value
 greater than <code>4</code> (its current default value). For more information, see the
 <a href="https://docs.libuv.org/en/latest/threadpool.html">libuv threadpool documentation</a>.</p>
-<h2>Useful V8 options<span><a class="mark" href="#cli_useful_v8_options" id="cli_useful_v8_options">#</a></span></h2>
+</section><section><h3>Useful V8 options<span><a class="mark" href="#cli_useful_v8_options" id="cli_useful_v8_options">#</a></span></h3>
 <p>V8 has its own set of CLI options. Any V8 CLI option that is provided to <code>node</code>
 will be passed on to V8 to handle. V8's options have <em>no stability guarantee</em>.
 The V8 team themselves don't consider them to be part of their formal API,
@@ -18711,17 +19608,18 @@ covered by the Node.js stability guarantees. Many of the V8
 options are of interest only to V8 developers. Despite this, there is a small
 set of V8 options that are widely applicable to Node.js, and they are
 documented here:</p>
-<h3><code>--max-old-space-size=SIZE</code> (in megabytes)<span><a class="mark" href="#cli_max_old_space_size_size_in_megabytes" id="cli_max_old_space_size_size_in_megabytes">#</a></span></h3>
+<h4><code>--max-old-space-size=SIZE</code> (in megabytes)<span><a class="mark" href="#cli_max_old_space_size_size_in_megabytes" id="cli_max_old_space_size_size_in_megabytes">#</a></span></h4>
 <p>Sets the max memory size of V8's old memory section. As memory
 consumption approaches the limit, V8 will spend more time on
 garbage collection in an effort to free unused memory.</p>
 <p>On a machine with 2GB of memory, consider setting this to
 1536 (1.5GB) to leave some memory for other uses and avoid swapping.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --max-old-space-size=1536 index.js</span></code></pre>
-<h1>Console<span><a class="mark" href="#console_console" id="console_console">#</a></span></h1>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --max-old-space-size=1536 index.js</span></code></pre></section>
+        </section>
+<section><h2>Console<span><a class="mark" href="#console_console" id="console_console">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/console.js">lib/console.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/console.js">lib/console.js</a></p>
 <p>The <code>console</code> module provides a simple debugging console that is similar to the
 JavaScript console mechanism provided by web browsers.</p>
 <p>The module exports two specific components:</p>
@@ -18732,37 +19630,45 @@ JavaScript console mechanism provided by web browsers.</p>
 <a href="#process_process_stderr"><code>process.stderr</code></a>. The global <code>console</code> can be used without calling
 <code>require('console')</code>.</li>
 </ul>
-<p><strong><em>Warning</em></strong>: The global console object's methods are neither consistently
+<p><em><strong>Warning</strong></em>: The global console object's methods are neither consistently
 synchronous like the browser APIs they resemble, nor are they consistently
 asynchronous like all other Node.js streams. See the <a href="#process_a_note_on_process_i_o">note on process I/O</a> for
 more information.</p>
 <p>Example using the global <code>console</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'hello world'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello world'</span>);
 <span class="hljs-comment">// Prints: hello world, to stdout</span>
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'hello %s'</span>, <span class="hljs-string">'world'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello %s'</span>, <span class="hljs-string">'world'</span>);
 <span class="hljs-comment">// Prints: hello world, to stdout</span>
-<span class="hljs-built_in">console</span>.error(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Whoops, something bad happened'</span>));
-<span class="hljs-comment">// Prints: [Error: Whoops, something bad happened], to stderr</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Whoops, something bad happened'</span>));
+<span class="hljs-comment">// Prints error message and stack trace to stderr:</span>
+<span class="hljs-comment">//   Error: Whoops, something bad happened</span>
+<span class="hljs-comment">//     at [eval]:5:15</span>
+<span class="hljs-comment">//     at Script.runInThisContext (node:vm:132:18)</span>
+<span class="hljs-comment">//     at Object.runInThisContext (node:vm:309:38)</span>
+<span class="hljs-comment">//     at node:internal/process/execution:77:19</span>
+<span class="hljs-comment">//     at [eval]-wrapper:6:22</span>
+<span class="hljs-comment">//     at evalScript (node:internal/process/execution:76:60)</span>
+<span class="hljs-comment">//     at node:internal/main/eval_string:23:3</span>
 
 <span class="hljs-keyword">const</span> name = <span class="hljs-string">'Will Robinson'</span>;
-<span class="hljs-built_in">console</span>.warn(<span class="hljs-string">`Danger <span class="hljs-subst">${name}</span>! Danger!`</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(<span class="hljs-string">`Danger <span class="hljs-subst">${name}</span>! Danger!`</span>);
 <span class="hljs-comment">// Prints: Danger Will Robinson! Danger!, to stderr</span></code></pre>
 <p>Example using the <code>Console</code> class:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> out = getStreamSomehow();
-<span class="hljs-keyword">const</span> err = getStreamSomehow();
-<span class="hljs-keyword">const</span> myConsole = <span class="hljs-keyword">new</span> <span class="hljs-built_in">console</span>.Console(out, err);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> out = <span class="hljs-title function_">getStreamSomehow</span>();
+<span class="hljs-keyword">const</span> err = <span class="hljs-title function_">getStreamSomehow</span>();
+<span class="hljs-keyword">const</span> myConsole = <span class="hljs-keyword">new</span> <span class="hljs-variable language_">console</span>.<span class="hljs-title class_">Console</span>(out, err);
 
-myConsole.log(<span class="hljs-string">'hello world'</span>);
+myConsole.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello world'</span>);
 <span class="hljs-comment">// Prints: hello world, to out</span>
-myConsole.log(<span class="hljs-string">'hello %s'</span>, <span class="hljs-string">'world'</span>);
+myConsole.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello %s'</span>, <span class="hljs-string">'world'</span>);
 <span class="hljs-comment">// Prints: hello world, to out</span>
-myConsole.error(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Whoops, something bad happened'</span>));
+myConsole.<span class="hljs-title function_">error</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Whoops, something bad happened'</span>));
 <span class="hljs-comment">// Prints: [Error: Whoops, something bad happened], to err</span>
 
 <span class="hljs-keyword">const</span> name = <span class="hljs-string">'Will Robinson'</span>;
-myConsole.warn(<span class="hljs-string">`Danger <span class="hljs-subst">${name}</span>! Danger!`</span>);
+myConsole.<span class="hljs-title function_">warn</span>(<span class="hljs-string">`Danger <span class="hljs-subst">${name}</span>! Danger!`</span>);
 <span class="hljs-comment">// Prints: Danger Will Robinson! Danger!, to err</span></code></pre>
-<h2>Class: <code>Console</code><span><a class="mark" href="#console_class_console" id="console_class_console">#</a></span></h2>
+<section><h3>Class: <code>Console</code><span><a class="mark" href="#console_class_console" id="console_class_console">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -18776,15 +19682,15 @@ myConsole.warn(<span class="hljs-string">`Danger <span class="hljs-subst">${name
 <p>The <code>Console</code> class can be used to create a simple logger with configurable
 output streams and can be accessed using either <code>require('console').Console</code>
 or <code>console.Console</code> (or their destructured counterparts):</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Console } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'console'</span>);</code></pre>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Console } = <span class="hljs-built_in">console</span>;</code></pre>
-<h3><code>new Console(stdout[, stderr][, ignoreErrors])</code><span><a class="mark" href="#console_new_console_stdout_stderr_ignoreerrors" id="console_new_console_stdout_stderr_ignoreerrors">#</a></span></h3>
-<h3><code>new Console(options)</code><span><a class="mark" href="#console_new_console_options" id="console_new_console_options">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Console</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'console'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Console</span> } = <span class="hljs-variable language_">console</span>;</code></pre>
+<h4><code>new Console(stdout[, stderr][, ignoreErrors])</code><span><a class="mark" href="#console_new_console_stdout_stderr_ignoreerrors" id="console_new_console_stdout_stderr_ignoreerrors">#</a></span></h4>
+<h4><code>new Console(options)</code><span><a class="mark" href="#console_new_console_options" id="console_new_console_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.2.0</td>
 <td><p>The <code>groupIndentation</code> option was introduced.</p></td></tr>
 <tr><td>v11.7.0</td>
 <td><p>The <code>inspectOptions</code> option is introduced.</p></td></tr>
@@ -18819,18 +19725,18 @@ option can not be used, if <code>inspectOptions.colors</code> is set as well.
 <p>Creates a new <code>Console</code> with one or two writable stream instances. <code>stdout</code> is a
 writable stream to print log or info output. <code>stderr</code> is used for warning or
 error output. If <code>stderr</code> is not provided, <code>stdout</code> is used for <code>stderr</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> output = fs.createWriteStream(<span class="hljs-string">'./stdout.log'</span>);
-<span class="hljs-keyword">const</span> errorOutput = fs.createWriteStream(<span class="hljs-string">'./stderr.log'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> output = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'./stdout.log'</span>);
+<span class="hljs-keyword">const</span> errorOutput = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'./stderr.log'</span>);
 <span class="hljs-comment">// Custom simple logger</span>
-<span class="hljs-keyword">const</span> logger = <span class="hljs-keyword">new</span> Console({ <span class="hljs-attr">stdout</span>: output, <span class="hljs-attr">stderr</span>: errorOutput });
+<span class="hljs-keyword">const</span> logger = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Console</span>({ <span class="hljs-attr">stdout</span>: output, <span class="hljs-attr">stderr</span>: errorOutput });
 <span class="hljs-comment">// use it like console</span>
 <span class="hljs-keyword">const</span> count = <span class="hljs-number">5</span>;
-logger.log(<span class="hljs-string">'count: %d'</span>, count);
+logger.<span class="hljs-title function_">log</span>(<span class="hljs-string">'count: %d'</span>, count);
 <span class="hljs-comment">// In stdout.log: count 5</span></code></pre>
 <p>The global <code>console</code> is a special <code>Console</code> whose output is sent to
 <a href="#process_process_stdout"><code>process.stdout</code></a> and <a href="#process_process_stderr"><code>process.stderr</code></a>. It is equivalent to calling:</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> Console({ <span class="hljs-attr">stdout</span>: process.stdout, <span class="hljs-attr">stderr</span>: process.stderr });</code></pre>
-<h3><code>console.assert(value[, ...message])</code><span><a class="mark" href="#console_console_assert_value_message" id="console_console_assert_value_message">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">new</span> <span class="hljs-title class_">Console</span>({ <span class="hljs-attr">stdout</span>: process.<span class="hljs-property">stdout</span>, <span class="hljs-attr">stderr</span>: process.<span class="hljs-property">stderr</span> });</code></pre>
+<h4><code>console.assert(value[, ...message])</code><span><a class="mark" href="#console_console_assert_value_message" id="console_console_assert_value_message">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -18851,14 +19757,14 @@ writes a message and does not otherwise affect execution. The output always
 starts with <code>"Assertion failed"</code>. If provided, <code>message</code> is formatted using
 <a href="#util_util_format_format_args"><code>util.format()</code></a>.</p>
 <p>If <code>value</code> is <a href="https://developer.mozilla.org/en-US/docs/Glossary/Truthy">truthy</a>, nothing happens.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.assert(<span class="hljs-literal">true</span>, <span class="hljs-string">'does nothing'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">assert</span>(<span class="hljs-literal">true</span>, <span class="hljs-string">'does nothing'</span>);
 
-<span class="hljs-built_in">console</span>.assert(<span class="hljs-literal">false</span>, <span class="hljs-string">'Whoops %s work'</span>, <span class="hljs-string">'didn\'t'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">assert</span>(<span class="hljs-literal">false</span>, <span class="hljs-string">'Whoops %s work'</span>, <span class="hljs-string">'didn\'t'</span>);
 <span class="hljs-comment">// Assertion failed: Whoops didn't work</span>
 
-<span class="hljs-built_in">console</span>.assert();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">assert</span>();
 <span class="hljs-comment">// Assertion failed</span></code></pre>
-<h3><code>console.clear()</code><span><a class="mark" href="#console_console_clear" id="console_console_clear">#</a></span></h3>
+<h4><code>console.clear()</code><span><a class="mark" href="#console_console_clear" id="console_console_clear">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
@@ -18869,7 +19775,7 @@ and terminal types. For most Linux operating systems, <code>console.clear()</cod
 operates similarly to the <code>clear</code> shell command. On Windows, <code>console.clear()</code>
 will clear only the output in the current terminal viewport for the Node.js
 binary.</p>
-<h3><code>console.count([label])</code><span><a class="mark" href="#console_console_count_label" id="console_console_count_label">#</a></span></h3>
+<h4><code>console.count([label])</code><span><a class="mark" href="#console_console_count_label" id="console_console_count_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
@@ -18879,26 +19785,26 @@ binary.</p>
 <p>Maintains an internal counter specific to <code>label</code> and outputs to <code>stdout</code> the
 number of times <code>console.count()</code> has been called with the given <code>label</code>.</p>
 <!-- eslint-skip -->
-<pre><code class="language-js">> <span class="hljs-built_in">console</span>.count()
+<pre><code class="language-js">> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>()
 <span class="hljs-attr">default</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'default'</span>)
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'default'</span>)
 <span class="hljs-attr">default</span>: <span class="hljs-number">2</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'abc'</span>)
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'abc'</span>)
 <span class="hljs-attr">abc</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'xyz'</span>)
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'xyz'</span>)
 <span class="hljs-attr">xyz</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'abc'</span>)
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'abc'</span>)
 <span class="hljs-attr">abc</span>: <span class="hljs-number">2</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count()
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>()
 <span class="hljs-attr">default</span>: <span class="hljs-number">3</span>
 <span class="hljs-literal">undefined</span>
 ></code></pre>
-<h3><code>console.countReset([label])</code><span><a class="mark" href="#console_console_countreset_label" id="console_console_countreset_label">#</a></span></h3>
+<h4><code>console.countReset([label])</code><span><a class="mark" href="#console_console_countreset_label" id="console_console_countreset_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
@@ -18907,16 +19813,16 @@ number of times <code>console.count()</code> has been called with the given <cod
 </ul>
 <p>Resets the internal counter specific to <code>label</code>.</p>
 <!-- eslint-skip -->
-<pre><code class="language-js">> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'abc'</span>);
-abc: <span class="hljs-number">1</span>
+<pre><code class="language-js">> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'abc'</span>);
+<span class="hljs-attr">abc</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.countReset(<span class="hljs-string">'abc'</span>);
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">countReset</span>(<span class="hljs-string">'abc'</span>);
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'abc'</span>);
-abc: <span class="hljs-number">1</span>
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'abc'</span>);
+<span class="hljs-attr">abc</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
 ></code></pre>
-<h3><code>console.debug(data[, ...args])</code><span><a class="mark" href="#console_console_debug_data_args" id="console_console_debug_data_args">#</a></span></h3>
+<h4><code>console.debug(data[, ...args])</code><span><a class="mark" href="#console_console_debug_data_args" id="console_console_debug_data_args">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -18933,7 +19839,7 @@ abc: <span class="hljs-number">1</span>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
 <p>The <code>console.debug()</code> function is an alias for <a href="#console_console_log_data_args"><code>console.log()</code></a>.</p>
-<h3><code>console.dir(obj[, options])</code><span><a class="mark" href="#console_console_dir_obj_options" id="console_console_dir_obj_options">#</a></span></h3>
+<h4><code>console.dir(obj[, options])</code><span><a class="mark" href="#console_console_dir_obj_options" id="console_console_dir_obj_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.101</span>
 </div>
@@ -18954,7 +19860,7 @@ see <a href="#util_customizing_util_inspect_colors">customizing <code>util.inspe
 </ul>
 <p>Uses <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a> on <code>obj</code> and prints the resulting string to <code>stdout</code>.
 This function bypasses any custom <code>inspect()</code> function defined on <code>obj</code>.</p>
-<h3><code>console.dirxml(...data)</code><span><a class="mark" href="#console_console_dirxml_data" id="console_console_dirxml_data">#</a></span></h3>
+<h4><code>console.dirxml(...data)</code><span><a class="mark" href="#console_console_dirxml_data" id="console_console_dirxml_data">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -18971,7 +19877,7 @@ This function bypasses any custom <code>inspect()</code> function defined on <co
 </ul>
 <p>This method calls <code>console.log()</code> passing it the arguments received.
 This method does not produce any XML formatting.</p>
-<h3><code>console.error([data][, ...args])</code><span><a class="mark" href="#console_console_error_data_args" id="console_console_error_data_args">#</a></span></h3>
+<h4><code>console.error([data][, ...args])</code><span><a class="mark" href="#console_console_error_data_args" id="console_console_error_data_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -18984,14 +19890,14 @@ first used as the primary message and all additional used as substitution
 values similar to <a href="http://man7.org/linux/man-pages/man3/printf.3.html"><code>printf(3)</code></a> (the arguments are all passed to
 <a href="#util_util_format_format_args"><code>util.format()</code></a>).</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> code = <span class="hljs-number">5</span>;
-<span class="hljs-built_in">console</span>.error(<span class="hljs-string">'error #%d'</span>, code);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'error #%d'</span>, code);
 <span class="hljs-comment">// Prints: error #5, to stderr</span>
-<span class="hljs-built_in">console</span>.error(<span class="hljs-string">'error'</span>, code);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'error'</span>, code);
 <span class="hljs-comment">// Prints: error 5, to stderr</span></code></pre>
 <p>If formatting elements (e.g. <code>%d</code>) are not found in the first string then
 <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a> is called on each argument and the resulting string
 values are concatenated. See <a href="#util_util_format_format_args"><code>util.format()</code></a> for more information.</p>
-<h3><code>console.group([...label])</code><span><a class="mark" href="#console_console_group_label" id="console_console_group_label">#</a></span></h3>
+<h4><code>console.group([...label])</code><span><a class="mark" href="#console_console_group_label" id="console_console_group_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -19002,18 +19908,18 @@ values are concatenated. See <a href="#util_util_format_format_args"><code>util.
 length.</p>
 <p>If one or more <code>label</code>s are provided, those are printed first without the
 additional indentation.</p>
-<h3><code>console.groupCollapsed()</code><span><a class="mark" href="#console_console_groupcollapsed" id="console_console_groupcollapsed">#</a></span></h3>
+<h4><code>console.groupCollapsed()</code><span><a class="mark" href="#console_console_groupcollapsed" id="console_console_groupcollapsed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>An alias for <a href="#console_console_group_label"><code>console.group()</code></a>.</p>
-<h3><code>console.groupEnd()</code><span><a class="mark" href="#console_console_groupend" id="console_console_groupend">#</a></span></h3>
+<h4><code>console.groupEnd()</code><span><a class="mark" href="#console_console_groupend" id="console_console_groupend">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>Decreases indentation of subsequent lines by spaces for <code>groupIndentation</code>
 length.</p>
-<h3><code>console.info([data][, ...args])</code><span><a class="mark" href="#console_console_info_data_args" id="console_console_info_data_args">#</a></span></h3>
+<h4><code>console.info([data][, ...args])</code><span><a class="mark" href="#console_console_info_data_args" id="console_console_info_data_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -19022,7 +19928,7 @@ length.</p>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
 <p>The <code>console.info()</code> function is an alias for <a href="#console_console_log_data_args"><code>console.log()</code></a>.</p>
-<h3><code>console.log([data][, ...args])</code><span><a class="mark" href="#console_console_log_data_args" id="console_console_log_data_args">#</a></span></h3>
+<h4><code>console.log([data][, ...args])</code><span><a class="mark" href="#console_console_log_data_args" id="console_console_log_data_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -19035,12 +19941,12 @@ first used as the primary message and all additional used as substitution
 values similar to <a href="http://man7.org/linux/man-pages/man3/printf.3.html"><code>printf(3)</code></a> (the arguments are all passed to
 <a href="#util_util_format_format_args"><code>util.format()</code></a>).</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> count = <span class="hljs-number">5</span>;
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'count: %d'</span>, count);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'count: %d'</span>, count);
 <span class="hljs-comment">// Prints: count: 5, to stdout</span>
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'count:'</span>, count);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'count:'</span>, count);
 <span class="hljs-comment">// Prints: count: 5, to stdout</span></code></pre>
 <p>See <a href="#util_util_format_format_args"><code>util.format()</code></a> for more information.</p>
-<h3><code>console.table(tabularData[, properties])</code><span><a class="mark" href="#console_console_table_tabulardata_properties" id="console_console_table_tabulardata_properties">#</a></span></h3>
+<h4><code>console.table(tabularData[, properties])</code><span><a class="mark" href="#console_console_table_tabulardata_properties" id="console_console_table_tabulardata_properties">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -19052,13 +19958,13 @@ values similar to <a href="http://man7.org/linux/man-pages/man3/printf.3.html"><
 (or use <code>properties</code>) and rows of <code>tabularData</code> and log it. Falls back to just
 logging the argument if it can’t be parsed as tabular.</p>
 <pre><code class="language-js"><span class="hljs-comment">// These can't be parsed as tabular data</span>
-<span class="hljs-built_in">console</span>.table(<span class="hljs-built_in">Symbol</span>());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">table</span>(<span class="hljs-title class_">Symbol</span>());
 <span class="hljs-comment">// Symbol()</span>
 
-<span class="hljs-built_in">console</span>.table(<span class="hljs-literal">undefined</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">table</span>(<span class="hljs-literal">undefined</span>);
 <span class="hljs-comment">// undefined</span>
 
-<span class="hljs-built_in">console</span>.table([{ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span>, <span class="hljs-attr">b</span>: <span class="hljs-string">'Y'</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'Z'</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> }]);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">table</span>([{ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span>, <span class="hljs-attr">b</span>: <span class="hljs-string">'Y'</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'Z'</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> }]);
 <span class="hljs-comment">// ┌─────────┬─────┬─────┐</span>
 <span class="hljs-comment">// │ (index) │  a  │  b  │</span>
 <span class="hljs-comment">// ├─────────┼─────┼─────┤</span>
@@ -19066,14 +19972,14 @@ logging the argument if it can’t be parsed as tabular.</p>
 <span class="hljs-comment">// │    1    │ 'Z' │  2  │</span>
 <span class="hljs-comment">// └─────────┴─────┴─────┘</span>
 
-<span class="hljs-built_in">console</span>.table([{ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span>, <span class="hljs-attr">b</span>: <span class="hljs-string">'Y'</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'Z'</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> }], [<span class="hljs-string">'a'</span>]);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">table</span>([{ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span>, <span class="hljs-attr">b</span>: <span class="hljs-string">'Y'</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'Z'</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> }], [<span class="hljs-string">'a'</span>]);
 <span class="hljs-comment">// ┌─────────┬─────┐</span>
 <span class="hljs-comment">// │ (index) │  a  │</span>
 <span class="hljs-comment">// ├─────────┼─────┤</span>
 <span class="hljs-comment">// │    0    │  1  │</span>
 <span class="hljs-comment">// │    1    │ 'Z' │</span>
 <span class="hljs-comment">// └─────────┴─────┘</span></code></pre>
-<h3><code>console.time([label])</code><span><a class="mark" href="#console_console_time_label" id="console_console_time_label">#</a></span></h3>
+<h4><code>console.time([label])</code><span><a class="mark" href="#console_console_time_label" id="console_console_time_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.104</span>
 </div>
@@ -19083,12 +19989,15 @@ logging the argument if it can’t be parsed as tabular.</p>
 <p>Starts a timer that can be used to compute the duration of an operation. Timers
 are identified by a unique <code>label</code>. Use the same <code>label</code> when calling
 <a href="#console_console_timeend_label"><code>console.timeEnd()</code></a> to stop the timer and output the elapsed time in
-milliseconds to <code>stdout</code>. Timer durations are accurate to the sub-millisecond.</p>
-<h3><code>console.timeEnd([label])</code><span><a class="mark" href="#console_console_timeend_label" id="console_console_timeend_label">#</a></span></h3>
+suitable time units to <code>stdout</code>. For example, if the elapsed
+time is 3869ms, <code>console.timeEnd()</code> displays "3.869s".</p>
+<h4><code>console.timeEnd([label])</code><span><a class="mark" href="#console_console_timeend_label" id="console_console_timeend_label">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The elapsed time is displayed with a suitable time unit.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>This method no longer supports multiple calls that don’t map to individual <code>console.time()</code> calls; see below for details.</p></td></tr>
 <tr><td>v0.1.104</td>
@@ -19101,11 +20010,11 @@ milliseconds to <code>stdout</code>. Timer durations are accurate to the sub-mil
 </ul>
 <p>Stops a timer that was previously started by calling <a href="#console_console_time_label"><code>console.time()</code></a> and
 prints the result to <code>stdout</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.time(<span class="hljs-string">'100-elements'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">time</span>(<span class="hljs-string">'100-elements'</span>);
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">100</span>; i++) {}
-<span class="hljs-built_in">console</span>.timeEnd(<span class="hljs-string">'100-elements'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">timeEnd</span>(<span class="hljs-string">'100-elements'</span>);
 <span class="hljs-comment">// prints 100-elements: 225.438ms</span></code></pre>
-<h3><code>console.timeLog([label][, ...data])</code><span><a class="mark" href="#console_console_timelog_label_data" id="console_console_timelog_label_data">#</a></span></h3>
+<h4><code>console.timeLog([label][, ...data])</code><span><a class="mark" href="#console_console_timelog_label_data" id="console_console_timelog_label_data">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 </div>
@@ -19115,13 +20024,13 @@ prints the result to <code>stdout</code>:</p>
 </ul>
 <p>For a timer that was previously started by calling <a href="#console_console_time_label"><code>console.time()</code></a>, prints
 the elapsed time and other <code>data</code> arguments to <code>stdout</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.time(<span class="hljs-string">'process'</span>);
-<span class="hljs-keyword">const</span> value = expensiveProcess1(); <span class="hljs-comment">// Returns 42</span>
-<span class="hljs-built_in">console</span>.timeLog(<span class="hljs-string">'process'</span>, value);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">time</span>(<span class="hljs-string">'process'</span>);
+<span class="hljs-keyword">const</span> value = <span class="hljs-title function_">expensiveProcess1</span>(); <span class="hljs-comment">// Returns 42</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">timeLog</span>(<span class="hljs-string">'process'</span>, value);
 <span class="hljs-comment">// Prints "process: 365.227ms 42".</span>
-doExpensiveProcess2(value);
-<span class="hljs-built_in">console</span>.timeEnd(<span class="hljs-string">'process'</span>);</code></pre>
-<h3><code>console.trace([message][, ...args])</code><span><a class="mark" href="#console_console_trace_message_args" id="console_console_trace_message_args">#</a></span></h3>
+<span class="hljs-title function_">doExpensiveProcess2</span>(value);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">timeEnd</span>(<span class="hljs-string">'process'</span>);</code></pre>
+<h4><code>console.trace([message][, ...args])</code><span><a class="mark" href="#console_console_trace_message_args" id="console_console_trace_message_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.104</span>
 </div>
@@ -19131,7 +20040,7 @@ doExpensiveProcess2(value);
 </ul>
 <p>Prints to <code>stderr</code> the string <code>'Trace: '</code>, followed by the <a href="#util_util_format_format_args"><code>util.format()</code></a>
 formatted message and stack trace to the current position in the code.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.trace(<span class="hljs-string">'Show me'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">trace</span>(<span class="hljs-string">'Show me'</span>);
 <span class="hljs-comment">// Prints: (stack trace will vary based on where trace is called)</span>
 <span class="hljs-comment">//  Trace: Show me</span>
 <span class="hljs-comment">//    at repl:2:9</span>
@@ -19144,7 +20053,7 @@ formatted message and stack trace to the current position in the code.</p>
 <span class="hljs-comment">//    at REPLServer.Interface._onLine (readline.js:210:10)</span>
 <span class="hljs-comment">//    at REPLServer.Interface._line (readline.js:549:8)</span>
 <span class="hljs-comment">//    at REPLServer.Interface._ttyWrite (readline.js:826:14)</span></code></pre>
-<h3><code>console.warn([data][, ...args])</code><span><a class="mark" href="#console_console_warn_data_args" id="console_console_warn_data_args">#</a></span></h3>
+<h4><code>console.warn([data][, ...args])</code><span><a class="mark" href="#console_console_warn_data_args" id="console_console_warn_data_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -19153,11 +20062,11 @@ formatted message and stack trace to the current position in the code.</p>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
 <p>The <code>console.warn()</code> function is an alias for <a href="#console_console_error_data_args"><code>console.error()</code></a>.</p>
-<h2>Inspector only methods<span><a class="mark" href="#console_inspector_only_methods" id="console_inspector_only_methods">#</a></span></h2>
+</section><section><h3>Inspector only methods<span><a class="mark" href="#console_inspector_only_methods" id="console_inspector_only_methods">#</a></span></h3>
 <p>The following methods are exposed by the V8 engine in the general API but do
 not display anything unless used in conjunction with the <a href="debugger.html">inspector</a>
 (<code>--inspect</code> flag).</p>
-<h3><code>console.profile([label])</code><span><a class="mark" href="#console_console_profile_label" id="console_console_profile_label">#</a></span></h3>
+<h4><code>console.profile([label])</code><span><a class="mark" href="#console_console_profile_label" id="console_console_profile_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -19168,11 +20077,11 @@ not display anything unless used in conjunction with the <a href="debugger.html"
 <code>console.profile()</code> method starts a JavaScript CPU profile with an optional
 label until <a href="#console_console_profileend_label"><code>console.profileEnd()</code></a> is called. The profile is then added to
 the <strong>Profile</strong> panel of the inspector.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.profile(<span class="hljs-string">'MyLabel'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">profile</span>(<span class="hljs-string">'MyLabel'</span>);
 <span class="hljs-comment">// Some code</span>
-<span class="hljs-built_in">console</span>.profileEnd(<span class="hljs-string">'MyLabel'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">profileEnd</span>(<span class="hljs-string">'MyLabel'</span>);
 <span class="hljs-comment">// Adds the profile 'MyLabel' to the Profiles panel of the inspector.</span></code></pre>
-<h3><code>console.profileEnd([label])</code><span><a class="mark" href="#console_console_profileend_label" id="console_console_profileend_label">#</a></span></h3>
+<h4><code>console.profileEnd([label])</code><span><a class="mark" href="#console_console_profileend_label" id="console_console_profileend_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -19185,7 +20094,7 @@ the report to the <strong>Profiles</strong> panel of the inspector. See
 <a href="#console_console_profile_label"><code>console.profile()</code></a> for an example.</p>
 <p>If this method is called without a label, the most recently started profile is
 stopped.</p>
-<h3><code>console.timeStamp([label])</code><span><a class="mark" href="#console_console_timestamp_label" id="console_console_timestamp_label">#</a></span></h3>
+<h4><code>console.timeStamp([label])</code><span><a class="mark" href="#console_console_timestamp_label" id="console_console_timestamp_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -19194,24 +20103,25 @@ stopped.</p>
 </ul>
 <p>This method does not display anything unless used in the inspector. The
 <code>console.timeStamp()</code> method adds an event with the label <code>'label'</code> to the
-<strong>Timeline</strong> panel of the inspector.</p>
-<h1>Crypto<span><a class="mark" href="#crypto_crypto" id="crypto_crypto">#</a></span></h1>
+<strong>Timeline</strong> panel of the inspector.</p></section>
+        </section>
+<section><h2>Crypto<span><a class="mark" href="#crypto_crypto" id="crypto_crypto">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/crypto.js">lib/crypto.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/crypto.js">lib/crypto.js</a></p>
 <p>The <code>crypto</code> module provides cryptographic functionality that includes a set of
 wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.</p>
 <p>Use <code>require('crypto')</code> to access this module.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
 <span class="hljs-keyword">const</span> secret = <span class="hljs-string">'abcdefg'</span>;
-<span class="hljs-keyword">const</span> hash = crypto.createHmac(<span class="hljs-string">'sha256'</span>, secret)
-                   .update(<span class="hljs-string">'I love cupcakes'</span>)
-                   .digest(<span class="hljs-string">'hex'</span>);
-<span class="hljs-built_in">console</span>.log(hash);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, secret)
+                   .<span class="hljs-title function_">update</span>(<span class="hljs-string">'I love cupcakes'</span>)
+                   .<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e</span></code></pre>
-<h2>Determining if crypto support is unavailable<span><a class="mark" href="#crypto_determining_if_crypto_support_is_unavailable" id="crypto_determining_if_crypto_support_is_unavailable">#</a></span></h2>
+<section><h3>Determining if crypto support is unavailable<span><a class="mark" href="#crypto_determining_if_crypto_support_is_unavailable" id="crypto_determining_if_crypto_support_is_unavailable">#</a></span></h3>
 <p>It is possible for Node.js to be built without including support for the
 <code>crypto</code> module. In such cases, calling <code>require('crypto')</code> will result in an
 error being thrown.</p>
@@ -19219,9 +20129,9 @@ error being thrown.</p>
 <span class="hljs-keyword">try</span> {
   crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'crypto support is disabled!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'crypto support is disabled!'</span>);
 }</code></pre>
-<h2>Class: <code>Certificate</code><span><a class="mark" href="#crypto_class_certificate" id="crypto_class_certificate">#</a></span></h2>
+</section><section><h3>Class: <code>Certificate</code><span><a class="mark" href="#crypto_class_certificate" id="crypto_class_certificate">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -19232,7 +20142,7 @@ should not use this element anymore.</p>
 <p>The <code>crypto</code> module provides the <code>Certificate</code> class for working with SPKAC
 data. The most common usage is handling output generated by the HTML5
 <code>&#x3C;keygen></code> element. Node.js uses <a href="https://www.openssl.org/docs/man1.1.0/apps/openssl-spkac.html">OpenSSL's SPKAC implementation</a> internally.</p>
-<h3><code>Certificate.exportChallenge(spkac)</code><span><a class="mark" href="#crypto_certificate_exportchallenge_spkac" id="crypto_certificate_exportchallenge_spkac">#</a></span></h3>
+<h4><code>Certificate.exportChallenge(spkac)</code><span><a class="mark" href="#crypto_certificate_exportchallenge_spkac" id="crypto_certificate_exportchallenge_spkac">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -19241,12 +20151,12 @@ data. The most common usage is handling output generated by the HTML5
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The challenge component of the <code>spkac</code> data structure, which
 includes a public key and a challenge.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Certificate } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-keyword">const</span> challenge = Certificate.exportChallenge(spkac);
-<span class="hljs-built_in">console</span>.log(challenge.toString(<span class="hljs-string">'utf8'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Certificate</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-keyword">const</span> challenge = <span class="hljs-title class_">Certificate</span>.<span class="hljs-title function_">exportChallenge</span>(spkac);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(challenge.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: the challenge as a UTF8 string</span></code></pre>
-<h3><code>Certificate.exportPublicKey(spkac[, encoding])</code><span><a class="mark" href="#crypto_certificate_exportpublickey_spkac_encoding" id="crypto_certificate_exportpublickey_spkac_encoding">#</a></span></h3>
+<h4><code>Certificate.exportPublicKey(spkac[, encoding])</code><span><a class="mark" href="#crypto_certificate_exportpublickey_spkac_encoding" id="crypto_certificate_exportpublickey_spkac_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -19256,12 +20166,12 @@ includes a public key and a challenge.</li>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The public key component of the <code>spkac</code> data structure,
 which includes a public key and a challenge.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Certificate } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-keyword">const</span> publicKey = Certificate.exportPublicKey(spkac);
-<span class="hljs-built_in">console</span>.log(publicKey);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Certificate</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-keyword">const</span> publicKey = <span class="hljs-title class_">Certificate</span>.<span class="hljs-title function_">exportPublicKey</span>(spkac);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(publicKey);
 <span class="hljs-comment">// Prints: the public key as &#x3C;Buffer ...></span></code></pre>
-<h3><code>Certificate.verifySpkac(spkac)</code><span><a class="mark" href="#crypto_certificate_verifyspkac_spkac" id="crypto_certificate_verifyspkac_spkac">#</a></span></h3>
+<h4><code>Certificate.verifySpkac(spkac)</code><span><a class="mark" href="#crypto_certificate_verifyspkac_spkac" id="crypto_certificate_verifyspkac_spkac">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -19270,21 +20180,22 @@ which includes a public key and a challenge.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the given <code>spkac</code> data structure is valid,
 <code>false</code> otherwise.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Certificate } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-built_in">console</span>.log(Certificate.verifySpkac(Buffer.from(spkac)));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Certificate</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Certificate</span>.<span class="hljs-title function_">verifySpkac</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(spkac)));
 <span class="hljs-comment">// Prints: true or false</span></code></pre>
-<h3>Legacy API<span><a class="mark" href="#crypto_legacy_api" id="crypto_legacy_api">#</a></span></h3>
-<p>As a still supported legacy interface, it is possible to create new instances of
+<h4>Legacy API<span><a class="mark" href="#crypto_legacy_api" id="crypto_legacy_api">#</a></span></h4>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated</div><p></p>
+<p>As a legacy interface, it is possible to create new instances of
 the <code>crypto.Certificate</code> class as illustrated in the examples below.</p>
-<h4><code>new crypto.Certificate()</code><span><a class="mark" href="#crypto_new_crypto_certificate" id="crypto_new_crypto_certificate">#</a></span></h4>
+<h5><code>new crypto.Certificate()</code><span><a class="mark" href="#crypto_new_crypto_certificate" id="crypto_new_crypto_certificate">#</a></span></h5>
 <p>Instances of the <code>Certificate</code> class can be created using the <code>new</code> keyword
 or by calling <code>crypto.Certificate()</code> as a function:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-keyword">const</span> cert1 = <span class="hljs-keyword">new</span> crypto.Certificate();
-<span class="hljs-keyword">const</span> cert2 = crypto.Certificate();</code></pre>
-<h4><code>certificate.exportChallenge(spkac)</code><span><a class="mark" href="#crypto_certificate_exportchallenge_spkac_1" id="crypto_certificate_exportchallenge_spkac_1">#</a></span></h4>
+<span class="hljs-keyword">const</span> cert1 = <span class="hljs-keyword">new</span> crypto.<span class="hljs-title class_">Certificate</span>();
+<span class="hljs-keyword">const</span> cert2 = crypto.<span class="hljs-title class_">Certificate</span>();</code></pre>
+<h5><code>certificate.exportChallenge(spkac)</code><span><a class="mark" href="#crypto_certificate_exportchallenge_spkac_1" id="crypto_certificate_exportchallenge_spkac_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -19293,12 +20204,12 @@ or by calling <code>crypto.Certificate()</code> as a function:</p>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The challenge component of the <code>spkac</code> data structure, which
 includes a public key and a challenge.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).Certificate();
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-keyword">const</span> challenge = cert.exportChallenge(spkac);
-<span class="hljs-built_in">console</span>.log(challenge.toString(<span class="hljs-string">'utf8'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).<span class="hljs-title class_">Certificate</span>();
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-keyword">const</span> challenge = cert.<span class="hljs-title function_">exportChallenge</span>(spkac);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(challenge.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: the challenge as a UTF8 string</span></code></pre>
-<h4><code>certificate.exportPublicKey(spkac)</code><span><a class="mark" href="#crypto_certificate_exportpublickey_spkac" id="crypto_certificate_exportpublickey_spkac">#</a></span></h4>
+<h5><code>certificate.exportPublicKey(spkac)</code><span><a class="mark" href="#crypto_certificate_exportpublickey_spkac" id="crypto_certificate_exportpublickey_spkac">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -19307,12 +20218,12 @@ includes a public key and a challenge.</li>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The public key component of the <code>spkac</code> data structure,
 which includes a public key and a challenge.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).Certificate();
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-keyword">const</span> publicKey = cert.exportPublicKey(spkac);
-<span class="hljs-built_in">console</span>.log(publicKey);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).<span class="hljs-title class_">Certificate</span>();
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-keyword">const</span> publicKey = cert.<span class="hljs-title function_">exportPublicKey</span>(spkac);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(publicKey);
 <span class="hljs-comment">// Prints: the public key as &#x3C;Buffer ...></span></code></pre>
-<h4><code>certificate.verifySpkac(spkac)</code><span><a class="mark" href="#crypto_certificate_verifyspkac_spkac_1" id="crypto_certificate_verifyspkac_spkac_1">#</a></span></h4>
+<h5><code>certificate.verifySpkac(spkac)</code><span><a class="mark" href="#crypto_certificate_verifyspkac_spkac_1" id="crypto_certificate_verifyspkac_spkac_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -19321,11 +20232,11 @@ which includes a public key and a challenge.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the given <code>spkac</code> data structure is valid,
 <code>false</code> otherwise.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).Certificate();
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-built_in">console</span>.log(cert.verifySpkac(Buffer.from(spkac)));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).<span class="hljs-title class_">Certificate</span>();
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(cert.<span class="hljs-title function_">verifySpkac</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(spkac)));
 <span class="hljs-comment">// Prints: true or false</span></code></pre>
-<h2>Class: <code>Cipher</code><span><a class="mark" href="#crypto_class_cipher" id="crypto_class_cipher">#</a></span></h2>
+</section><section><h3>Class: <code>Cipher</code><span><a class="mark" href="#crypto_class_cipher" id="crypto_class_cipher">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -19351,27 +20262,27 @@ directly using the <code>new</code> keyword.</p>
 <span class="hljs-comment">// Key length is dependent on the algorithm. In this case for aes192, it is</span>
 <span class="hljs-comment">// 24 bytes (192 bits).</span>
 <span class="hljs-comment">// Use async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// Use `crypto.randomBytes()` to generate a random iv instead of the static iv</span>
 <span class="hljs-comment">// shown here.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> cipher = crypto.createCipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> cipher = crypto.<span class="hljs-title function_">createCipheriv</span>(algorithm, key, iv);
 
 <span class="hljs-keyword">let</span> encrypted = <span class="hljs-string">''</span>;
-cipher.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+cipher.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-keyword">let</span> chunk;
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = cipher.read())) {
-    encrypted += chunk.toString(<span class="hljs-string">'hex'</span>);
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = cipher.<span class="hljs-title function_">read</span>())) {
+    encrypted += chunk.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>);
   }
 });
-cipher.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(encrypted);
+cipher.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(encrypted);
   <span class="hljs-comment">// Prints: e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa</span>
 });
 
-cipher.write(<span class="hljs-string">'some clear text data'</span>);
-cipher.end();</code></pre>
+cipher.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some clear text data'</span>);
+cipher.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example: Using <code>Cipher</code> and piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
@@ -19379,35 +20290,35 @@ cipher.end();</code></pre>
 <span class="hljs-keyword">const</span> algorithm = <span class="hljs-string">'aes-192-cbc'</span>;
 <span class="hljs-keyword">const</span> password = <span class="hljs-string">'Password used to generate key'</span>;
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// Use `crypto.randomBytes()` to generate a random iv instead of the static iv</span>
 <span class="hljs-comment">// shown here.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> cipher = crypto.createCipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> cipher = crypto.<span class="hljs-title function_">createCipheriv</span>(algorithm, key, iv);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(<span class="hljs-string">'test.js'</span>);
-<span class="hljs-keyword">const</span> output = fs.createWriteStream(<span class="hljs-string">'test.enc'</span>);
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'test.js'</span>);
+<span class="hljs-keyword">const</span> output = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'test.enc'</span>);
 
-input.pipe(cipher).pipe(output);</code></pre>
+input.<span class="hljs-title function_">pipe</span>(cipher).<span class="hljs-title function_">pipe</span>(output);</code></pre>
 <p>Example: Using the <a href="#crypto_cipher_update_data_inputencoding_outputencoding"><code>cipher.update()</code></a> and <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
 <span class="hljs-keyword">const</span> algorithm = <span class="hljs-string">'aes-192-cbc'</span>;
 <span class="hljs-keyword">const</span> password = <span class="hljs-string">'Password used to generate key'</span>;
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// Use `crypto.randomBytes` to generate a random iv instead of the static iv</span>
 <span class="hljs-comment">// shown here.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> cipher = crypto.createCipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> cipher = crypto.<span class="hljs-title function_">createCipheriv</span>(algorithm, key, iv);
 
-<span class="hljs-keyword">let</span> encrypted = cipher.update(<span class="hljs-string">'some clear text data'</span>, <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'hex'</span>);
-encrypted += cipher.final(<span class="hljs-string">'hex'</span>);
-<span class="hljs-built_in">console</span>.log(encrypted);
+<span class="hljs-keyword">let</span> encrypted = cipher.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some clear text data'</span>, <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'hex'</span>);
+encrypted += cipher.<span class="hljs-title function_">final</span>(<span class="hljs-string">'hex'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(encrypted);
 <span class="hljs-comment">// Prints: e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa</span></code></pre>
-<h3><code>cipher.final([outputEncoding])</code><span><a class="mark" href="#crypto_cipher_final_outputencoding" id="crypto_cipher_final_outputencoding">#</a></span></h3>
+<h4><code>cipher.final([outputEncoding])</code><span><a class="mark" href="#crypto_cipher_final_outputencoding" id="crypto_cipher_final_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -19420,7 +20331,19 @@ returned. If an <code>outputEncoding</code> is not provided, a <a href="buffer.h
 <p>Once the <code>cipher.final()</code> method has been called, the <code>Cipher</code> object can no
 longer be used to encrypt data. Attempts to call <code>cipher.final()</code> more than
 once will result in an error being thrown.</p>
-<h3><code>cipher.setAAD(buffer[, options])</code><span><a class="mark" href="#crypto_cipher_setaad_buffer_options" id="crypto_cipher_setaad_buffer_options">#</a></span></h3>
+<h4><code>cipher.getAuthTag()</code><span><a class="mark" href="#crypto_cipher_getauthtag" id="crypto_cipher_getauthtag">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v1.0.0</span>
+</div>
+<ul>
+<li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> When using an authenticated encryption mode (<code>GCM</code>, <code>CCM</code>
+and <code>OCB</code> are currently supported), the <code>cipher.getAuthTag()</code> method returns a
+<a href="buffer.html"><code>Buffer</code></a> containing the <em>authentication tag</em> that has been computed from
+the given data.</li>
+</ul>
+<p>The <code>cipher.getAuthTag()</code> method should only be called after encryption has
+been completed using the <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> method.</p>
+<h4><code>cipher.setAAD(buffer[, options])</code><span><a class="mark" href="#crypto_cipher_setaad_buffer_options" id="crypto_cipher_setaad_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.0.0</span>
 </div>
@@ -19440,19 +20363,7 @@ currently supported), the <code>cipher.setAAD()</code> method sets the value use
 <code>plaintextLength</code> option must be specified and its value must match the length
 of the plaintext in bytes. See <a href="#crypto_ccm_mode">CCM mode</a>.</p>
 <p>The <code>cipher.setAAD()</code> method must be called before <a href="#crypto_cipher_update_data_inputencoding_outputencoding"><code>cipher.update()</code></a>.</p>
-<h3><code>cipher.getAuthTag()</code><span><a class="mark" href="#crypto_cipher_getauthtag" id="crypto_cipher_getauthtag">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v1.0.0</span>
-</div>
-<ul>
-<li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> When using an authenticated encryption mode (<code>GCM</code>, <code>CCM</code>
-and <code>OCB</code> are currently supported), the <code>cipher.getAuthTag()</code> method returns a
-<a href="buffer.html"><code>Buffer</code></a> containing the <em>authentication tag</em> that has been computed from
-the given data.</li>
-</ul>
-<p>The <code>cipher.getAuthTag()</code> method should only be called after encryption has
-been completed using the <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> method.</p>
-<h3><code>cipher.setAutoPadding([autoPadding])</code><span><a class="mark" href="#crypto_cipher_setautopadding_autopadding" id="crypto_cipher_setautopadding_autopadding">#</a></span></h3>
+<h4><code>cipher.setAutoPadding([autoPadding])</code><span><a class="mark" href="#crypto_cipher_setautopadding_autopadding" id="crypto_cipher_setautopadding_autopadding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.1</span>
 </div>
@@ -19469,7 +20380,7 @@ Disabling automatic padding is useful for non-standard padding, for instance
 using <code>0x0</code> instead of PKCS padding.</p>
 <p>The <code>cipher.setAutoPadding()</code> method must be called before
 <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a>.</p>
-<h3><code>cipher.update(data[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_cipher_update_data_inputencoding_outputencoding" id="crypto_cipher_update_data_inputencoding_outputencoding">#</a></span></h3>
+<h4><code>cipher.update(data[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_cipher_update_data_inputencoding_outputencoding" id="crypto_cipher_update_data_inputencoding_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -19500,7 +20411,7 @@ is specified, a string using the specified encoding is returned. If no
 <p>The <code>cipher.update()</code> method can be called multiple times with new data until
 <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> is called. Calling <code>cipher.update()</code> after
 <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> will result in an error being thrown.</p>
-<h2>Class: <code>Decipher</code><span><a class="mark" href="#crypto_class_decipher" id="crypto_class_decipher">#</a></span></h2>
+</section><section><h3>Class: <code>Decipher</code><span><a class="mark" href="#crypto_class_decipher" id="crypto_class_decipher">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -19526,28 +20437,28 @@ directly using the <code>new</code> keyword.</p>
 <span class="hljs-comment">// Key length is dependent on the algorithm. In this case for aes192, it is</span>
 <span class="hljs-comment">// 24 bytes (192 bits).</span>
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// The IV is usually passed along with the ciphertext.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> decipher = crypto.createDecipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> decipher = crypto.<span class="hljs-title function_">createDecipheriv</span>(algorithm, key, iv);
 
 <span class="hljs-keyword">let</span> decrypted = <span class="hljs-string">''</span>;
-decipher.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = decipher.read())) {
-    decrypted += chunk.toString(<span class="hljs-string">'utf8'</span>);
+decipher.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = decipher.<span class="hljs-title function_">read</span>())) {
+    decrypted += chunk.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>);
   }
 });
-decipher.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(decrypted);
+decipher.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decrypted);
   <span class="hljs-comment">// Prints: some clear text data</span>
 });
 
 <span class="hljs-comment">// Encrypted with same algorithm, key and iv.</span>
 <span class="hljs-keyword">const</span> encrypted =
   <span class="hljs-string">'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'</span>;
-decipher.write(encrypted, <span class="hljs-string">'hex'</span>);
-decipher.end();</code></pre>
+decipher.<span class="hljs-title function_">write</span>(encrypted, <span class="hljs-string">'hex'</span>);
+decipher.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example: Using <code>Decipher</code> and piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
@@ -19555,36 +20466,36 @@ decipher.end();</code></pre>
 <span class="hljs-keyword">const</span> algorithm = <span class="hljs-string">'aes-192-cbc'</span>;
 <span class="hljs-keyword">const</span> password = <span class="hljs-string">'Password used to generate key'</span>;
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// The IV is usually passed along with the ciphertext.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> decipher = crypto.createDecipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> decipher = crypto.<span class="hljs-title function_">createDecipheriv</span>(algorithm, key, iv);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(<span class="hljs-string">'test.enc'</span>);
-<span class="hljs-keyword">const</span> output = fs.createWriteStream(<span class="hljs-string">'test.js'</span>);
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'test.enc'</span>);
+<span class="hljs-keyword">const</span> output = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'test.js'</span>);
 
-input.pipe(decipher).pipe(output);</code></pre>
+input.<span class="hljs-title function_">pipe</span>(decipher).<span class="hljs-title function_">pipe</span>(output);</code></pre>
 <p>Example: Using the <a href="#crypto_decipher_update_data_inputencoding_outputencoding"><code>decipher.update()</code></a> and <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
 <span class="hljs-keyword">const</span> algorithm = <span class="hljs-string">'aes-192-cbc'</span>;
 <span class="hljs-keyword">const</span> password = <span class="hljs-string">'Password used to generate key'</span>;
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// The IV is usually passed along with the ciphertext.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> decipher = crypto.createDecipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> decipher = crypto.<span class="hljs-title function_">createDecipheriv</span>(algorithm, key, iv);
 
 <span class="hljs-comment">// Encrypted using same algorithm, key and iv.</span>
 <span class="hljs-keyword">const</span> encrypted =
   <span class="hljs-string">'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'</span>;
-<span class="hljs-keyword">let</span> decrypted = decipher.update(encrypted, <span class="hljs-string">'hex'</span>, <span class="hljs-string">'utf8'</span>);
-decrypted += decipher.final(<span class="hljs-string">'utf8'</span>);
-<span class="hljs-built_in">console</span>.log(decrypted);
+<span class="hljs-keyword">let</span> decrypted = decipher.<span class="hljs-title function_">update</span>(encrypted, <span class="hljs-string">'hex'</span>, <span class="hljs-string">'utf8'</span>);
+decrypted += decipher.<span class="hljs-title function_">final</span>(<span class="hljs-string">'utf8'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decrypted);
 <span class="hljs-comment">// Prints: some clear text data</span></code></pre>
-<h3><code>decipher.final([outputEncoding])</code><span><a class="mark" href="#crypto_decipher_final_outputencoding" id="crypto_decipher_final_outputencoding">#</a></span></h3>
+<h4><code>decipher.final([outputEncoding])</code><span><a class="mark" href="#crypto_decipher_final_outputencoding" id="crypto_decipher_final_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -19597,7 +20508,7 @@ returned. If an <code>outputEncoding</code> is not provided, a <a href="buffer.h
 <p>Once the <code>decipher.final()</code> method has been called, the <code>Decipher</code> object can
 no longer be used to decrypt data. Attempts to call <code>decipher.final()</code> more
 than once will result in an error being thrown.</p>
-<h3><code>decipher.setAAD(buffer[, options])</code><span><a class="mark" href="#crypto_decipher_setaad_buffer_options" id="crypto_decipher_setaad_buffer_options">#</a></span></h3>
+<h4><code>decipher.setAAD(buffer[, options])</code><span><a class="mark" href="#crypto_decipher_setaad_buffer_options" id="crypto_decipher_setaad_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -19625,7 +20536,7 @@ currently supported), the <code>decipher.setAAD()</code> method sets the value u
 <code>plaintextLength</code> option must be specified and its value must match the length
 of the ciphertext in bytes. See <a href="#crypto_ccm_mode">CCM mode</a>.</p>
 <p>The <code>decipher.setAAD()</code> method must be called before <a href="#crypto_decipher_update_data_inputencoding_outputencoding"><code>decipher.update()</code></a>.</p>
-<h3><code>decipher.setAuthTag(buffer)</code><span><a class="mark" href="#crypto_decipher_setauthtag_buffer" id="crypto_decipher_setauthtag_buffer">#</a></span></h3>
+<h4><code>decipher.setAuthTag(buffer)</code><span><a class="mark" href="#crypto_decipher_setauthtag_buffer" id="crypto_decipher_setauthtag_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -19653,7 +20564,7 @@ is invalid according to <a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nis
 <p>The <code>decipher.setAuthTag()</code> method must be called before <a href="#crypto_decipher_update_data_inputencoding_outputencoding"><code>decipher.update()</code></a>
 for <code>CCM</code> mode or before <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> for <code>GCM</code> and <code>OCB</code> modes.
 <code>decipher.setAuthTag()</code> can only be called once.</p>
-<h3><code>decipher.setAutoPadding([autoPadding])</code><span><a class="mark" href="#crypto_decipher_setautopadding_autopadding" id="crypto_decipher_setautopadding_autopadding">#</a></span></h3>
+<h4><code>decipher.setAutoPadding([autoPadding])</code><span><a class="mark" href="#crypto_decipher_setautopadding_autopadding" id="crypto_decipher_setautopadding_autopadding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.1</span>
 </div>
@@ -19668,7 +20579,7 @@ for <code>CCM</code> mode or before <a href="#crypto_decipher_final_outputencodi
 multiple of the ciphers block size.</p>
 <p>The <code>decipher.setAutoPadding()</code> method must be called before
 <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a>.</p>
-<h3><code>decipher.update(data[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_decipher_update_data_inputencoding_outputencoding" id="crypto_decipher_update_data_inputencoding_outputencoding">#</a></span></h3>
+<h4><code>decipher.update(data[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_decipher_update_data_inputencoding_outputencoding" id="crypto_decipher_update_data_inputencoding_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -19698,7 +20609,7 @@ is specified, a string using the specified encoding is returned. If no
 <p>The <code>decipher.update()</code> method can be called multiple times with new data until
 <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> is called. Calling <code>decipher.update()</code> after
 <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> will result in an error being thrown.</p>
-<h2>Class: <code>DiffieHellman</code><span><a class="mark" href="#crypto_class_diffiehellman" id="crypto_class_diffiehellman">#</a></span></h2>
+</section><section><h3>Class: <code>DiffieHellman</code><span><a class="mark" href="#crypto_class_diffiehellman" id="crypto_class_diffiehellman">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19710,20 +20621,20 @@ exchanges.</p>
 <span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Generate Alice's keys...</span>
-<span class="hljs-keyword">const</span> alice = crypto.createDiffieHellman(<span class="hljs-number">2048</span>);
-<span class="hljs-keyword">const</span> aliceKey = alice.generateKeys();
+<span class="hljs-keyword">const</span> alice = crypto.<span class="hljs-title function_">createDiffieHellman</span>(<span class="hljs-number">2048</span>);
+<span class="hljs-keyword">const</span> aliceKey = alice.<span class="hljs-title function_">generateKeys</span>();
 
 <span class="hljs-comment">// Generate Bob's keys...</span>
-<span class="hljs-keyword">const</span> bob = crypto.createDiffieHellman(alice.getPrime(), alice.getGenerator());
-<span class="hljs-keyword">const</span> bobKey = bob.generateKeys();
+<span class="hljs-keyword">const</span> bob = crypto.<span class="hljs-title function_">createDiffieHellman</span>(alice.<span class="hljs-title function_">getPrime</span>(), alice.<span class="hljs-title function_">getGenerator</span>());
+<span class="hljs-keyword">const</span> bobKey = bob.<span class="hljs-title function_">generateKeys</span>();
 
 <span class="hljs-comment">// Exchange and generate the secret...</span>
-<span class="hljs-keyword">const</span> aliceSecret = alice.computeSecret(bobKey);
-<span class="hljs-keyword">const</span> bobSecret = bob.computeSecret(aliceKey);
+<span class="hljs-keyword">const</span> aliceSecret = alice.<span class="hljs-title function_">computeSecret</span>(bobKey);
+<span class="hljs-keyword">const</span> bobSecret = bob.<span class="hljs-title function_">computeSecret</span>(aliceKey);
 
 <span class="hljs-comment">// OK</span>
-assert.strictEqual(aliceSecret.toString(<span class="hljs-string">'hex'</span>), bobSecret.toString(<span class="hljs-string">'hex'</span>));</code></pre>
-<h3><code>diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_diffiehellman_computesecret_otherpublickey_inputencoding_outputencoding" id="crypto_diffiehellman_computesecret_otherpublickey_inputencoding_outputencoding">#</a></span></h3>
+assert.<span class="hljs-title function_">strictEqual</span>(aliceSecret.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>), bobSecret.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));</code></pre>
+<h4><code>diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_diffiehellman_computesecret_otherpublickey_inputencoding_outputencoding" id="crypto_diffiehellman_computesecret_otherpublickey_inputencoding_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19742,7 +20653,7 @@ provided, <code>otherPublicKey</code> is expected to be a <a href="buffer.html">
 <code>TypedArray</code>, or <code>DataView</code>.</p>
 <p>If <code>outputEncoding</code> is given a string is returned; otherwise, a
 <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.generateKeys([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_generatekeys_encoding" id="crypto_diffiehellman_generatekeys_encoding">#</a></span></h3>
+<h4><code>diffieHellman.generateKeys([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_generatekeys_encoding" id="crypto_diffiehellman_generatekeys_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19755,7 +20666,7 @@ the public key in the specified <code>encoding</code>. This key should be
 transferred to the other party.
 If <code>encoding</code> is provided a string is returned; otherwise a
 <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.getGenerator([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getgenerator_encoding" id="crypto_diffiehellman_getgenerator_encoding">#</a></span></h3>
+<h4><code>diffieHellman.getGenerator([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getgenerator_encoding" id="crypto_diffiehellman_getgenerator_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19766,7 +20677,7 @@ If <code>encoding</code> is provided a string is returned; otherwise a
 <p>Returns the Diffie-Hellman generator in the specified <code>encoding</code>.
 If <code>encoding</code> is provided a string is
 returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.getPrime([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getprime_encoding" id="crypto_diffiehellman_getprime_encoding">#</a></span></h3>
+<h4><code>diffieHellman.getPrime([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getprime_encoding" id="crypto_diffiehellman_getprime_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19777,7 +20688,7 @@ returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.
 <p>Returns the Diffie-Hellman prime in the specified <code>encoding</code>.
 If <code>encoding</code> is provided a string is
 returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.getPrivateKey([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getprivatekey_encoding" id="crypto_diffiehellman_getprivatekey_encoding">#</a></span></h3>
+<h4><code>diffieHellman.getPrivateKey([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getprivatekey_encoding" id="crypto_diffiehellman_getprivatekey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19788,7 +20699,7 @@ returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.
 <p>Returns the Diffie-Hellman private key in the specified <code>encoding</code>.
 If <code>encoding</code> is provided a
 string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.getPublicKey([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getpublickey_encoding" id="crypto_diffiehellman_getpublickey_encoding">#</a></span></h3>
+<h4><code>diffieHellman.getPublicKey([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getpublickey_encoding" id="crypto_diffiehellman_getpublickey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19799,7 +20710,7 @@ string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is
 <p>Returns the Diffie-Hellman public key in the specified <code>encoding</code>.
 If <code>encoding</code> is provided a
 string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.setPrivateKey(privateKey[, encoding])</code><span><a class="mark" href="#crypto_diffiehellman_setprivatekey_privatekey_encoding" id="crypto_diffiehellman_setprivatekey_privatekey_encoding">#</a></span></h3>
+<h4><code>diffieHellman.setPrivateKey(privateKey[, encoding])</code><span><a class="mark" href="#crypto_diffiehellman_setprivatekey_privatekey_encoding" id="crypto_diffiehellman_setprivatekey_privatekey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19811,7 +20722,7 @@ string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is
 <code>privateKey</code> is expected
 to be a string. If no <code>encoding</code> is provided, <code>privateKey</code> is expected
 to be a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or <code>DataView</code>.</p>
-<h3><code>diffieHellman.setPublicKey(publicKey[, encoding])</code><span><a class="mark" href="#crypto_diffiehellman_setpublickey_publickey_encoding" id="crypto_diffiehellman_setpublickey_publickey_encoding">#</a></span></h3>
+<h4><code>diffieHellman.setPublicKey(publicKey[, encoding])</code><span><a class="mark" href="#crypto_diffiehellman_setpublickey_publickey_encoding" id="crypto_diffiehellman_setpublickey_publickey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -19823,7 +20734,7 @@ to be a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>,
 <code>publicKey</code> is expected
 to be a string. If no <code>encoding</code> is provided, <code>publicKey</code> is expected
 to be a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or <code>DataView</code>.</p>
-<h3><code>diffieHellman.verifyError</code><span><a class="mark" href="#crypto_diffiehellman_verifyerror" id="crypto_diffiehellman_verifyerror">#</a></span></h3>
+<h4><code>diffieHellman.verifyError</code><span><a class="mark" href="#crypto_diffiehellman_verifyerror" id="crypto_diffiehellman_verifyerror">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.12</span>
 </div>
@@ -19837,16 +20748,18 @@ module):</p>
 <li><code>DH_UNABLE_TO_CHECK_GENERATOR</code></li>
 <li><code>DH_NOT_SUITABLE_GENERATOR</code></li>
 </ul>
-<h2>Class: <code>DiffieHellmanGroup</code><span><a class="mark" href="#crypto_class_diffiehellmangroup" id="crypto_class_diffiehellmangroup">#</a></span></h2>
+</section><section><h3>Class: <code>DiffieHellmanGroup</code><span><a class="mark" href="#crypto_class_diffiehellmangroup" id="crypto_class_diffiehellmangroup">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
-<p>The <code>DiffieHellmanGroup</code> class takes a well-known modp group as its argument but
-otherwise works the same as <code>DiffieHellman</code>.</p>
+<p>The <code>DiffieHellmanGroup</code> class takes a well-known modp group as its argument.
+It works the same as <code>DiffieHellman</code>, except that it does not allow changing
+its keys after creation. In other words, it does not implement <code>setPublicKey()</code>
+or <code>setPrivateKey()</code> methods.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> name = <span class="hljs-string">'modp1'</span>;
-<span class="hljs-keyword">const</span> dh = crypto.createDiffieHellmanGroup(name);</code></pre>
+<span class="hljs-keyword">const</span> dh = crypto.<span class="hljs-title function_">createDiffieHellmanGroup</span>(name);</code></pre>
 <p><code>name</code> is taken from <a href="https://www.rfc-editor.org/rfc/rfc2412.txt">RFC 2412</a> (modp1 and 2) and <a href="https://www.rfc-editor.org/rfc/rfc3526.txt">RFC 3526</a>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> perl -ne <span class="hljs-string">'print "$1\n" if /"(modp\d+)"/'</span> src/node_crypto_groups.h</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">perl -ne <span class="hljs-string">'print "$1\n" if /"(modp\d+)"/'</span> src/node_crypto_groups.h</span>
 modp1  #  768 bits
 modp2  # 1024 bits
 modp5  # 1536 bits
@@ -19855,7 +20768,7 @@ modp15 # etc.
 modp16
 modp17
 modp18</code></pre>
-<h2>Class: <code>ECDH</code><span><a class="mark" href="#crypto_class_ecdh" id="crypto_class_ecdh">#</a></span></h2>
+</section><section><h3>Class: <code>ECDH</code><span><a class="mark" href="#crypto_class_ecdh" id="crypto_class_ecdh">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -19867,20 +20780,20 @@ key exchanges.</p>
 <span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Generate Alice's keys...</span>
-<span class="hljs-keyword">const</span> alice = crypto.createECDH(<span class="hljs-string">'secp521r1'</span>);
-<span class="hljs-keyword">const</span> aliceKey = alice.generateKeys();
+<span class="hljs-keyword">const</span> alice = crypto.<span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp521r1'</span>);
+<span class="hljs-keyword">const</span> aliceKey = alice.<span class="hljs-title function_">generateKeys</span>();
 
 <span class="hljs-comment">// Generate Bob's keys...</span>
-<span class="hljs-keyword">const</span> bob = crypto.createECDH(<span class="hljs-string">'secp521r1'</span>);
-<span class="hljs-keyword">const</span> bobKey = bob.generateKeys();
+<span class="hljs-keyword">const</span> bob = crypto.<span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp521r1'</span>);
+<span class="hljs-keyword">const</span> bobKey = bob.<span class="hljs-title function_">generateKeys</span>();
 
 <span class="hljs-comment">// Exchange and generate the secret...</span>
-<span class="hljs-keyword">const</span> aliceSecret = alice.computeSecret(bobKey);
-<span class="hljs-keyword">const</span> bobSecret = bob.computeSecret(aliceKey);
+<span class="hljs-keyword">const</span> aliceSecret = alice.<span class="hljs-title function_">computeSecret</span>(bobKey);
+<span class="hljs-keyword">const</span> bobSecret = bob.<span class="hljs-title function_">computeSecret</span>(aliceKey);
 
-assert.strictEqual(aliceSecret.toString(<span class="hljs-string">'hex'</span>), bobSecret.toString(<span class="hljs-string">'hex'</span>));
+assert.<span class="hljs-title function_">strictEqual</span>(aliceSecret.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>), bobSecret.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// OK</span></code></pre>
-<h3>Static method: <code>ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])</code><span><a class="mark" href="#crypto_static_method_ecdh_convertkey_key_curve_inputencoding_outputencoding_format" id="crypto_static_method_ecdh_convertkey_key_curve_inputencoding_outputencoding_format">#</a></span></h3>
+<h4>Static method: <code>ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])</code><span><a class="mark" href="#crypto_static_method_ecdh_convertkey_key_curve_inputencoding_outputencoding_format" id="crypto_static_method_ecdh_convertkey_key_curve_inputencoding_outputencoding_format">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -19905,30 +20818,30 @@ format.</p>
 <p>If the <code>inputEncoding</code> is not provided, <code>key</code> is expected to be a <a href="buffer.html"><code>Buffer</code></a>,
 <code>TypedArray</code>, or <code>DataView</code>.</p>
 <p>Example (uncompressing a key):</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { createECDH, ECDH } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { createECDH, <span class="hljs-variable constant_">ECDH</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-keyword">const</span> ecdh = createECDH(<span class="hljs-string">'secp256k1'</span>);
-ecdh.generateKeys();
+<span class="hljs-keyword">const</span> ecdh = <span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp256k1'</span>);
+ecdh.<span class="hljs-title function_">generateKeys</span>();
 
-<span class="hljs-keyword">const</span> compressedKey = ecdh.getPublicKey(<span class="hljs-string">'hex'</span>, <span class="hljs-string">'compressed'</span>);
+<span class="hljs-keyword">const</span> compressedKey = ecdh.<span class="hljs-title function_">getPublicKey</span>(<span class="hljs-string">'hex'</span>, <span class="hljs-string">'compressed'</span>);
 
-<span class="hljs-keyword">const</span> uncompressedKey = ECDH.convertKey(compressedKey,
+<span class="hljs-keyword">const</span> uncompressedKey = <span class="hljs-variable constant_">ECDH</span>.<span class="hljs-title function_">convertKey</span>(compressedKey,
                                         <span class="hljs-string">'secp256k1'</span>,
                                         <span class="hljs-string">'hex'</span>,
                                         <span class="hljs-string">'hex'</span>,
                                         <span class="hljs-string">'uncompressed'</span>);
 
 <span class="hljs-comment">// The converted key and the uncompressed public key should be the same</span>
-<span class="hljs-built_in">console</span>.log(uncompressedKey === ecdh.getPublicKey(<span class="hljs-string">'hex'</span>));</code></pre>
-<h3><code>ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_ecdh_computesecret_otherpublickey_inputencoding_outputencoding" id="crypto_ecdh_computesecret_otherpublickey_inputencoding_outputencoding">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(uncompressedKey === ecdh.<span class="hljs-title function_">getPublicKey</span>(<span class="hljs-string">'hex'</span>));</code></pre>
+<h4><code>ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_ecdh_computesecret_otherpublickey_inputencoding_outputencoding" id="crypto_ecdh_computesecret_otherpublickey_inputencoding_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
-<td><p>Changed error format to better support invalid public key error</p></td></tr>
+<td><p>Changed error format to better support invalid public key error.</p></td></tr>
 <tr><td>v6.0.0</td>
-<td><p>The default <code>inputEncoding</code> changed from <code>binary</code> to <code>utf8</code></p></td></tr>
+<td><p>The default <code>inputEncoding</code> changed from <code>binary</code> to <code>utf8</code>.</p></td></tr>
 <tr><td>v0.11.14</td>
 <td><p><span>Added in: v0.11.14</span></p></td></tr>
 </tbody></table>
@@ -19954,7 +20867,7 @@ provided, <code>otherPublicKey</code> is expected to be a <a href="buffer.html">
 lies outside of the elliptic curve. Since <code>otherPublicKey</code> is
 usually supplied from a remote user over an insecure network,
 be sure to handle this exception accordingly.</p>
-<h3><code>ecdh.generateKeys([encoding[, format]])</code><span><a class="mark" href="#crypto_ecdh_generatekeys_encoding_format" id="crypto_ecdh_generatekeys_encoding_format">#</a></span></h3>
+<h4><code>ecdh.generateKeys([encoding[, format]])</code><span><a class="mark" href="#crypto_ecdh_generatekeys_encoding_format" id="crypto_ecdh_generatekeys_encoding_format">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -19971,7 +20884,7 @@ transferred to the other party.</p>
 <code>'uncompressed'</code> format.</p>
 <p>If <code>encoding</code> is provided a string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a>
 is returned.</p>
-<h3><code>ecdh.getPrivateKey([encoding])</code><span><a class="mark" href="#crypto_ecdh_getprivatekey_encoding" id="crypto_ecdh_getprivatekey_encoding">#</a></span></h3>
+<h4><code>ecdh.getPrivateKey([encoding])</code><span><a class="mark" href="#crypto_ecdh_getprivatekey_encoding" id="crypto_ecdh_getprivatekey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -19981,7 +20894,7 @@ is returned.</p>
 </ul>
 <p>If <code>encoding</code> is specified, a string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is
 returned.</p>
-<h3><code>ecdh.getPublicKey([encoding][, format])</code><span><a class="mark" href="#crypto_ecdh_getpublickey_encoding_format" id="crypto_ecdh_getpublickey_encoding_format">#</a></span></h3>
+<h4><code>ecdh.getPublicKey([encoding][, format])</code><span><a class="mark" href="#crypto_ecdh_getpublickey_encoding_format" id="crypto_ecdh_getpublickey_encoding_format">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -19996,7 +20909,7 @@ returned.</p>
 <code>'uncompressed'</code> format.</p>
 <p>If <code>encoding</code> is specified, a string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is
 returned.</p>
-<h3><code>ecdh.setPrivateKey(privateKey[, encoding])</code><span><a class="mark" href="#crypto_ecdh_setprivatekey_privatekey_encoding" id="crypto_ecdh_setprivatekey_privatekey_encoding">#</a></span></h3>
+<h4><code>ecdh.setPrivateKey(privateKey[, encoding])</code><span><a class="mark" href="#crypto_ecdh_setprivatekey_privatekey_encoding" id="crypto_ecdh_setprivatekey_privatekey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -20011,7 +20924,7 @@ to be a string; otherwise <code>privateKey</code> is expected to be a <a href="b
 <p>If <code>privateKey</code> is not valid for the curve specified when the <code>ECDH</code> object was
 created, an error is thrown. Upon setting the private key, the associated
 public point (key) is also generated and set in the <code>ECDH</code> object.</p>
-<h3><code>ecdh.setPublicKey(publicKey[, encoding])</code><span><a class="mark" href="#crypto_ecdh_setpublickey_publickey_encoding" id="crypto_ecdh_setpublickey_publickey_encoding">#</a></span></h3>
+<h4><code>ecdh.setPublicKey(publicKey[, encoding])</code><span><a class="mark" href="#crypto_ecdh_setpublickey_publickey_encoding" id="crypto_ecdh_setpublickey_publickey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span><span>Deprecated since: v5.2.0</span>
 </div>
@@ -20031,26 +20944,26 @@ attempts to generate the public point/key associated with the private key being
 set.</p>
 <p>Example (obtaining a shared secret):</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> alice = crypto.createECDH(<span class="hljs-string">'secp256k1'</span>);
-<span class="hljs-keyword">const</span> bob = crypto.createECDH(<span class="hljs-string">'secp256k1'</span>);
+<span class="hljs-keyword">const</span> alice = crypto.<span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp256k1'</span>);
+<span class="hljs-keyword">const</span> bob = crypto.<span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp256k1'</span>);
 
 <span class="hljs-comment">// This is a shortcut way of specifying one of Alice's previous private</span>
 <span class="hljs-comment">// keys. It would be unwise to use such a predictable private key in a real</span>
 <span class="hljs-comment">// application.</span>
-alice.setPrivateKey(
-  crypto.createHash(<span class="hljs-string">'sha256'</span>).update(<span class="hljs-string">'alice'</span>, <span class="hljs-string">'utf8'</span>).digest()
+alice.<span class="hljs-title function_">setPrivateKey</span>(
+  crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>).<span class="hljs-title function_">update</span>(<span class="hljs-string">'alice'</span>, <span class="hljs-string">'utf8'</span>).<span class="hljs-title function_">digest</span>()
 );
 
 <span class="hljs-comment">// Bob uses a newly generated cryptographically strong</span>
 <span class="hljs-comment">// pseudorandom key pair</span>
-bob.generateKeys();
+bob.<span class="hljs-title function_">generateKeys</span>();
 
-<span class="hljs-keyword">const</span> aliceSecret = alice.computeSecret(bob.getPublicKey(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
-<span class="hljs-keyword">const</span> bobSecret = bob.computeSecret(alice.getPublicKey(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> aliceSecret = alice.<span class="hljs-title function_">computeSecret</span>(bob.<span class="hljs-title function_">getPublicKey</span>(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> bobSecret = bob.<span class="hljs-title function_">computeSecret</span>(alice.<span class="hljs-title function_">getPublicKey</span>(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
 
 <span class="hljs-comment">// aliceSecret and bobSecret should be the same shared secret value</span>
-<span class="hljs-built_in">console</span>.log(aliceSecret === bobSecret);</code></pre>
-<h2>Class: <code>Hash</code><span><a class="mark" href="#crypto_class_hash" id="crypto_class_hash">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(aliceSecret === bobSecret);</code></pre>
+</section><section><h3>Class: <code>Hash</code><span><a class="mark" href="#crypto_class_hash" id="crypto_class_hash">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -20069,39 +20982,39 @@ computed hash.</li>
 objects are not to be created directly using the <code>new</code> keyword.</p>
 <p>Example: Using <code>Hash</code> objects as streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-hash.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+hash.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Only one element is going to be produced by the</span>
   <span class="hljs-comment">// hash stream.</span>
-  <span class="hljs-keyword">const</span> data = hash.read();
+  <span class="hljs-keyword">const</span> data = hash.<span class="hljs-title function_">read</span>();
   <span class="hljs-keyword">if</span> (data) {
-    <span class="hljs-built_in">console</span>.log(data.toString(<span class="hljs-string">'hex'</span>));
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
     <span class="hljs-comment">// Prints:</span>
     <span class="hljs-comment">//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50</span>
   }
 });
 
-hash.write(<span class="hljs-string">'some data to hash'</span>);
-hash.end();</code></pre>
+hash.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data to hash'</span>);
+hash.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example: Using <code>Hash</code> and piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(<span class="hljs-string">'test.js'</span>);
-input.pipe(hash).pipe(process.stdout);</code></pre>
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'test.js'</span>);
+input.<span class="hljs-title function_">pipe</span>(hash).<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'hex'</span>).<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
 <p>Example: Using the <a href="#crypto_hash_update_data_inputencoding"><code>hash.update()</code></a> and <a href="#crypto_hash_digest_encoding"><code>hash.digest()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-hash.update(<span class="hljs-string">'some data to hash'</span>);
-<span class="hljs-built_in">console</span>.log(hash.digest(<span class="hljs-string">'hex'</span>));
+hash.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some data to hash'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash.<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50</span></code></pre>
-<h3><code>hash.copy([options])</code><span><a class="mark" href="#crypto_hash_copy_options" id="crypto_hash_copy_options">#</a></span></h3>
+<h4><code>hash.copy([options])</code><span><a class="mark" href="#crypto_hash_copy_options" id="crypto_hash_copy_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.1.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> <a href="#stream_new_stream_transform_options"><code>stream.transform</code> options</a></li>
@@ -20116,19 +21029,19 @@ specify the desired output length in bytes.</p>
 its <a href="#crypto_hash_digest_encoding"><code>hash.digest()</code></a> method has been called.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Calculate a rolling hash.</span>
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-hash.update(<span class="hljs-string">'one'</span>);
-<span class="hljs-built_in">console</span>.log(hash.copy().digest(<span class="hljs-string">'hex'</span>));
+hash.<span class="hljs-title function_">update</span>(<span class="hljs-string">'one'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash.<span class="hljs-title function_">copy</span>().<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 
-hash.update(<span class="hljs-string">'two'</span>);
-<span class="hljs-built_in">console</span>.log(hash.copy().digest(<span class="hljs-string">'hex'</span>));
+hash.<span class="hljs-title function_">update</span>(<span class="hljs-string">'two'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash.<span class="hljs-title function_">copy</span>().<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 
-hash.update(<span class="hljs-string">'three'</span>);
-<span class="hljs-built_in">console</span>.log(hash.copy().digest(<span class="hljs-string">'hex'</span>));
+hash.<span class="hljs-title function_">update</span>(<span class="hljs-string">'three'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash.<span class="hljs-title function_">copy</span>().<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 
 <span class="hljs-comment">// Etc.</span></code></pre>
-<h3><code>hash.digest([encoding])</code><span><a class="mark" href="#crypto_hash_digest_encoding" id="crypto_hash_digest_encoding">#</a></span></h3>
+<h4><code>hash.digest([encoding])</code><span><a class="mark" href="#crypto_hash_digest_encoding" id="crypto_hash_digest_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -20142,7 +21055,7 @@ If <code>encoding</code> is provided a string will be returned; otherwise
 a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
 <p>The <code>Hash</code> object can not be used again after <code>hash.digest()</code> method has been
 called. Multiple calls will cause an error to be thrown.</p>
-<h3><code>hash.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_hash_update_data_inputencoding" id="crypto_hash_update_data_inputencoding">#</a></span></h3>
+<h4><code>hash.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_hash_update_data_inputencoding" id="crypto_hash_update_data_inputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20164,7 +21077,7 @@ If <code>encoding</code> is not provided, and the <code>data</code> is a string,
 encoding of <code>'utf8'</code> is enforced. If <code>data</code> is a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or
 <code>DataView</code>, then <code>inputEncoding</code> is ignored.</p>
 <p>This can be called many times with new data as it is streamed.</p>
-<h2>Class: <code>Hmac</code><span><a class="mark" href="#crypto_class_hmac" id="crypto_class_hmac">#</a></span></h2>
+</section><section><h3>Class: <code>Hmac</code><span><a class="mark" href="#crypto_class_hmac" id="crypto_class_hmac">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -20183,37 +21096,37 @@ computed HMAC digest.</li>
 objects are not to be created directly using the <code>new</code> keyword.</p>
 <p>Example: Using <code>Hmac</code> objects as streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hmac = crypto.createHmac(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
+<span class="hljs-keyword">const</span> hmac = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
 
-hmac.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+hmac.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Only one element is going to be produced by the</span>
   <span class="hljs-comment">// hash stream.</span>
-  <span class="hljs-keyword">const</span> data = hmac.read();
+  <span class="hljs-keyword">const</span> data = hmac.<span class="hljs-title function_">read</span>();
   <span class="hljs-keyword">if</span> (data) {
-    <span class="hljs-built_in">console</span>.log(data.toString(<span class="hljs-string">'hex'</span>));
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
     <span class="hljs-comment">// Prints:</span>
     <span class="hljs-comment">//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e</span>
   }
 });
 
-hmac.write(<span class="hljs-string">'some data to hash'</span>);
-hmac.end();</code></pre>
+hmac.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data to hash'</span>);
+hmac.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example: Using <code>Hmac</code> and piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> hmac = crypto.createHmac(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
+<span class="hljs-keyword">const</span> hmac = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(<span class="hljs-string">'test.js'</span>);
-input.pipe(hmac).pipe(process.stdout);</code></pre>
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'test.js'</span>);
+input.<span class="hljs-title function_">pipe</span>(hmac).<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
 <p>Example: Using the <a href="#crypto_hmac_update_data_inputencoding"><code>hmac.update()</code></a> and <a href="#crypto_hmac_digest_encoding"><code>hmac.digest()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hmac = crypto.createHmac(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
+<span class="hljs-keyword">const</span> hmac = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
 
-hmac.update(<span class="hljs-string">'some data to hash'</span>);
-<span class="hljs-built_in">console</span>.log(hmac.digest(<span class="hljs-string">'hex'</span>));
+hmac.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some data to hash'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hmac.<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e</span></code></pre>
-<h3><code>hmac.digest([encoding])</code><span><a class="mark" href="#crypto_hmac_digest_encoding" id="crypto_hmac_digest_encoding">#</a></span></h3>
+<h4><code>hmac.digest([encoding])</code><span><a class="mark" href="#crypto_hmac_digest_encoding" id="crypto_hmac_digest_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -20226,7 +21139,7 @@ If <code>encoding</code> is
 provided a string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned;</p>
 <p>The <code>Hmac</code> object can not be used again after <code>hmac.digest()</code> has been
 called. Multiple calls to <code>hmac.digest()</code> will result in an error being thrown.</p>
-<h3><code>hmac.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_hmac_update_data_inputencoding" id="crypto_hmac_update_data_inputencoding">#</a></span></h3>
+<h4><code>hmac.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_hmac_update_data_inputencoding" id="crypto_hmac_update_data_inputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20248,12 +21161,12 @@ If <code>encoding</code> is not provided, and the <code>data</code> is a string,
 encoding of <code>'utf8'</code> is enforced. If <code>data</code> is a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or
 <code>DataView</code>, then <code>inputEncoding</code> is ignored.</p>
 <p>This can be called many times with new data as it is streamed.</p>
-<h2>Class: <code>KeyObject</code><span><a class="mark" href="#crypto_class_keyobject" id="crypto_class_keyobject">#</a></span></h2>
+</section><section><h3>Class: <code>KeyObject</code><span><a class="mark" href="#crypto_class_keyobject" id="crypto_class_keyobject">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>Instances of this class can now be passed to worker threads using <code>postMessage</code>.</p></td></tr>
 <tr><td>v11.13.0</td>
 <td><p>This class is now exported.</p></td></tr>
@@ -20273,19 +21186,19 @@ passing keys as strings or <code>Buffer</code>s due to improved security feature
 <p><code>KeyObject</code> instances can be passed to other threads via <a href="#worker_threads_port_postmessage_value_transferlist"><code>postMessage()</code></a>.
 The receiver obtains a cloned <code>KeyObject</code>, and the <code>KeyObject</code> does not need to
 be listed in the <code>transferList</code> argument.</p>
-<h3><code>keyObject.asymmetricKeyType</code><span><a class="mark" href="#crypto_keyobject_asymmetrickeytype" id="crypto_keyobject_asymmetrickeytype">#</a></span></h3>
+<h4><code>keyObject.asymmetricKeyType</code><span><a class="mark" href="#crypto_keyobject_asymmetrickeytype" id="crypto_keyobject_asymmetrickeytype">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.9.0</td>
 <td><p>Added support for <code>'dh'</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>Added support for <code>'rsa-pss'</code></p></td></tr>
+<td><p>Added support for <code>'rsa-pss'</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>This property now returns <code>undefined</code> for KeyObject instances of unrecognized type instead of aborting.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>Added support for <code>'x25519'</code> and <code>'x448'</code></p></td></tr>
+<td><p>Added support for <code>'x25519'</code> and <code>'x448'</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Added support for <code>'ed25519'</code> and <code>'ed448'</code>.</p></td></tr>
 <tr><td>v11.6.0</td>
@@ -20311,7 +21224,7 @@ types are:</p>
 </ul>
 <p>This property is <code>undefined</code> for unrecognized <code>KeyObject</code> types and symmetric
 keys.</p>
-<h3><code>keyObject.export([options])</code><span><a class="mark" href="#crypto_keyobject_export_options" id="crypto_keyobject_export_options">#</a></span></h3>
+<h4><code>keyObject.export([options])</code><span><a class="mark" href="#crypto_keyobject_export_options" id="crypto_keyobject_export_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
@@ -20334,7 +21247,7 @@ format.</p>
 <code>'sec1'</code> (EC only).</li>
 <li><code>format</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Must be <code>'pem'</code> or <code>'der'</code>.</li>
 <li><code>cipher</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If specified, the private key will be encrypted with
- the given <code>cipher</code> and <code>passphrase</code> using PKCS#5 v2.0 password based
+the given <code>cipher</code> and <code>passphrase</code> using PKCS#5 v2.0 password based
 encryption.</li>
 <li><code>passphrase</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The passphrase to use for encryption, see
 <code>cipher</code>.</li>
@@ -20350,7 +21263,7 @@ encrypted private keys. Since PKCS#8 defines its own
 encryption mechanism, PEM-level encryption is not supported when encrypting
 a PKCS#8 key. See <a href="https://www.rfc-editor.org/rfc/rfc5208.txt">RFC 5208</a> for PKCS#8 encryption and <a href="https://www.rfc-editor.org/rfc/rfc1421.txt">RFC 1421</a> for
 PKCS#1 and SEC1 encryption.</p>
-<h3><code>keyObject.symmetricKeySize</code><span><a class="mark" href="#crypto_keyobject_symmetrickeysize" id="crypto_keyobject_symmetrickeysize">#</a></span></h3>
+<h4><code>keyObject.symmetricKeySize</code><span><a class="mark" href="#crypto_keyobject_symmetrickeysize" id="crypto_keyobject_symmetrickeysize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
@@ -20359,7 +21272,7 @@ PKCS#1 and SEC1 encryption.</p>
 </ul>
 <p>For secret keys, this property represents the size of the key in bytes. This
 property is <code>undefined</code> for asymmetric keys.</p>
-<h3><code>keyObject.type</code><span><a class="mark" href="#crypto_keyobject_type" id="crypto_keyobject_type">#</a></span></h3>
+<h4><code>keyObject.type</code><span><a class="mark" href="#crypto_keyobject_type" id="crypto_keyobject_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
@@ -20369,7 +21282,7 @@ property is <code>undefined</code> for asymmetric keys.</p>
 <p>Depending on the type of this <code>KeyObject</code>, this property is either
 <code>'secret'</code> for secret (symmetric) keys, <code>'public'</code> for public (asymmetric) keys
 or <code>'private'</code> for private (asymmetric) keys.</p>
-<h2>Class: <code>Sign</code><span><a class="mark" href="#crypto_class_sign" id="crypto_class_sign">#</a></span></h2>
+</section><section><h3>Class: <code>Sign</code><span><a class="mark" href="#crypto_class_sign" id="crypto_class_sign">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -20390,42 +21303,44 @@ to be created directly using the <code>new</code> keyword.</p>
 <p>Example: Using <code>Sign</code> and <a href="#crypto_class_verify"><code>Verify</code></a> objects as streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-keyword">const</span> { privateKey, publicKey } = crypto.generateKeyPairSync(<span class="hljs-string">'ec'</span>, {
+<span class="hljs-keyword">const</span> { privateKey, publicKey } = crypto.<span class="hljs-title function_">generateKeyPairSync</span>(<span class="hljs-string">'ec'</span>, {
   <span class="hljs-attr">namedCurve</span>: <span class="hljs-string">'sect239k1'</span>
 });
 
-<span class="hljs-keyword">const</span> sign = crypto.createSign(<span class="hljs-string">'SHA256'</span>);
-sign.write(<span class="hljs-string">'some data to sign'</span>);
-sign.end();
-<span class="hljs-keyword">const</span> signature = sign.sign(privateKey, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> sign = crypto.<span class="hljs-title function_">createSign</span>(<span class="hljs-string">'SHA256'</span>);
+sign.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data to sign'</span>);
+sign.<span class="hljs-title function_">end</span>();
+<span class="hljs-keyword">const</span> signature = sign.<span class="hljs-title function_">sign</span>(privateKey, <span class="hljs-string">'hex'</span>);
 
-<span class="hljs-keyword">const</span> verify = crypto.createVerify(<span class="hljs-string">'SHA256'</span>);
-verify.write(<span class="hljs-string">'some data to sign'</span>);
-verify.end();
-<span class="hljs-built_in">console</span>.log(verify.verify(publicKey, signature, <span class="hljs-string">'hex'</span>));
+<span class="hljs-keyword">const</span> verify = crypto.<span class="hljs-title function_">createVerify</span>(<span class="hljs-string">'SHA256'</span>);
+verify.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data to sign'</span>);
+verify.<span class="hljs-title function_">end</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(verify.<span class="hljs-title function_">verify</span>(publicKey, signature, <span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: true</span></code></pre>
 <p>Example: Using the <a href="#crypto_sign_update_data_inputencoding"><code>sign.update()</code></a> and <a href="#crypto_verify_update_data_inputencoding"><code>verify.update()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-keyword">const</span> { privateKey, publicKey } = crypto.generateKeyPairSync(<span class="hljs-string">'rsa'</span>, {
+<span class="hljs-keyword">const</span> { privateKey, publicKey } = crypto.<span class="hljs-title function_">generateKeyPairSync</span>(<span class="hljs-string">'rsa'</span>, {
   <span class="hljs-attr">modulusLength</span>: <span class="hljs-number">2048</span>,
 });
 
-<span class="hljs-keyword">const</span> sign = crypto.createSign(<span class="hljs-string">'SHA256'</span>);
-sign.update(<span class="hljs-string">'some data to sign'</span>);
-sign.end();
-<span class="hljs-keyword">const</span> signature = sign.sign(privateKey);
+<span class="hljs-keyword">const</span> sign = crypto.<span class="hljs-title function_">createSign</span>(<span class="hljs-string">'SHA256'</span>);
+sign.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some data to sign'</span>);
+sign.<span class="hljs-title function_">end</span>();
+<span class="hljs-keyword">const</span> signature = sign.<span class="hljs-title function_">sign</span>(privateKey);
 
-<span class="hljs-keyword">const</span> verify = crypto.createVerify(<span class="hljs-string">'SHA256'</span>);
-verify.update(<span class="hljs-string">'some data to sign'</span>);
-verify.end();
-<span class="hljs-built_in">console</span>.log(verify.verify(publicKey, signature));
+<span class="hljs-keyword">const</span> verify = crypto.<span class="hljs-title function_">createVerify</span>(<span class="hljs-string">'SHA256'</span>);
+verify.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some data to sign'</span>);
+verify.<span class="hljs-title function_">end</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(verify.<span class="hljs-title function_">verify</span>(publicKey, signature));
 <span class="hljs-comment">// Prints: true</span></code></pre>
-<h3><code>sign.sign(privateKey[, outputEncoding])</code><span><a class="mark" href="#crypto_sign_sign_privatekey_outputencoding" id="crypto_sign_sign_privatekey_outputencoding">#</a></span></h3>
+<h4><code>sign.sign(privateKey[, outputEncoding])</code><span><a class="mark" href="#crypto_sign_sign_privatekey_outputencoding" id="crypto_sign_sign_privatekey_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>This function now supports IEEE-P1363 DSA and ECDSA signatures.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>This function now supports RSA-PSS keys.</p></td></tr>
 <tr><td>v11.6.0</td>
@@ -20485,7 +21400,7 @@ maximum permissible value.</p>
 is returned.</p>
 <p>The <code>Sign</code> object can not be again used after <code>sign.sign()</code> method has been
 called. Multiple calls to <code>sign.sign()</code> will result in an error being thrown.</p>
-<h3><code>sign.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_sign_update_data_inputencoding" id="crypto_sign_update_data_inputencoding">#</a></span></h3>
+<h4><code>sign.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_sign_update_data_inputencoding" id="crypto_sign_update_data_inputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20507,7 +21422,7 @@ If <code>encoding</code> is not provided, and the <code>data</code> is a string,
 encoding of <code>'utf8'</code> is enforced. If <code>data</code> is a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or
 <code>DataView</code>, then <code>inputEncoding</code> is ignored.</p>
 <p>This can be called many times with new data as it is streamed.</p>
-<h2>Class: <code>Verify</code><span><a class="mark" href="#crypto_class_verify" id="crypto_class_verify">#</a></span></h2>
+</section><section><h3>Class: <code>Verify</code><span><a class="mark" href="#crypto_class_verify" id="crypto_class_verify">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -20525,7 +21440,7 @@ the signature.</li>
 <p>The <a href="#crypto_crypto_createverify_algorithm_options"><code>crypto.createVerify()</code></a> method is used to create <code>Verify</code> instances.
 <code>Verify</code> objects are not to be created directly using the <code>new</code> keyword.</p>
 <p>See <a href="#crypto_class_sign"><code>Sign</code></a> for examples.</p>
-<h3><code>verify.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_verify_update_data_inputencoding" id="crypto_verify_update_data_inputencoding">#</a></span></h3>
+<h4><code>verify.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_verify_update_data_inputencoding" id="crypto_verify_update_data_inputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20547,11 +21462,13 @@ If <code>inputEncoding</code> is not provided, and the <code>data</code> is a st
 encoding of <code>'utf8'</code> is enforced. If <code>data</code> is a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or
 <code>DataView</code>, then <code>inputEncoding</code> is ignored.</p>
 <p>This can be called many times with new data as it is streamed.</p>
-<h3><code>verify.verify(object, signature[, signatureEncoding])</code><span><a class="mark" href="#crypto_verify_verify_object_signature_signatureencoding" id="crypto_verify_verify_object_signature_signatureencoding">#</a></span></h3>
+<h4><code>verify.verify(object, signature[, signatureEncoding])</code><span><a class="mark" href="#crypto_verify_verify_object_signature_signatureencoding" id="crypto_verify_verify_object_signature_signatureencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>This function now supports IEEE-P1363 DSA and ECDSA signatures.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>This function now supports RSA-PSS keys.</p></td></tr>
 <tr><td>v11.7.0</td>
@@ -20583,7 +21500,7 @@ object, the following additional properties can be passed:</p>
 <ul>
 <li>
 <p><code>dsaEncoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> For DSA and ECDSA, this option specifies the
-format of the generated signature. It can be one of the following:</p>
+format of the signature. It can be one of the following:</p>
 <ul>
 <li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>
 <li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>
@@ -20618,8 +21535,8 @@ called. Multiple calls to <code>verify.verify()</code> will result in an error b
 thrown.</p>
 <p>Because public keys can be derived from private keys, a private key may
 be passed instead of a public key.</p>
-<h2><code>crypto</code> module methods and properties<span><a class="mark" href="#crypto_crypto_module_methods_and_properties" id="crypto_crypto_module_methods_and_properties">#</a></span></h2>
-<h3><code>crypto.constants</code><span><a class="mark" href="#crypto_crypto_constants" id="crypto_crypto_constants">#</a></span></h3>
+</section><section><h3><code>crypto</code> module methods and properties<span><a class="mark" href="#crypto_crypto_module_methods_and_properties" id="crypto_crypto_module_methods_and_properties">#</a></span></h3>
+<h4><code>crypto.constants</code><span><a class="mark" href="#crypto_crypto_constants" id="crypto_crypto_constants">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -20628,7 +21545,7 @@ be passed instead of a public key.</p>
 security related operations. The specific constants currently defined are
 described in <a href="#crypto_crypto_constants_1">Crypto constants</a>.</li>
 </ul>
-<h3><code>crypto.DEFAULT_ENCODING</code><span><a class="mark" href="#crypto_crypto_default_encoding" id="crypto_crypto_default_encoding">#</a></span></h3>
+<h4><code>crypto.DEFAULT_ENCODING</code><span><a class="mark" href="#crypto_crypto_default_encoding" id="crypto_crypto_default_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span><span>Deprecated since: v10.0.0</span>
 </div>
@@ -20640,7 +21557,7 @@ default to <a href="buffer.html"><code>Buffer</code></a> objects.</p>
 with legacy programs that expect <code>'latin1'</code> to be the default encoding.</p>
 <p>New applications should expect the default to be <code>'buffer'</code>.</p>
 <p>This property is deprecated.</p>
-<h3><code>crypto.fips</code><span><a class="mark" href="#crypto_crypto_fips" id="crypto_crypto_fips">#</a></span></h3>
+<h4><code>crypto.fips</code><span><a class="mark" href="#crypto_crypto_fips" id="crypto_crypto_fips">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span><span>Deprecated since: v10.0.0</span>
 </div>
@@ -20649,7 +21566,7 @@ with legacy programs that expect <code>'latin1'</code> to be the default encodin
 is currently in use. Setting to true requires a FIPS build of Node.js.</p>
 <p>This property is deprecated. Please use <code>crypto.setFips()</code> and
 <code>crypto.getFips()</code> instead.</p>
-<h3><code>crypto.createCipher(algorithm, password[, options])</code><span><a class="mark" href="#crypto_crypto_createcipher_algorithm_password_options" id="crypto_crypto_createcipher_algorithm_password_options">#</a></span></h3>
+<h4><code>crypto.createCipher(algorithm, password[, options])</code><span><a class="mark" href="#crypto_crypto_createcipher_algorithm_password_options" id="crypto_crypto_createcipher_algorithm_password_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20701,14 +21618,14 @@ to create the <code>Cipher</code> object. Users should not use ciphers with coun
 they are used in order to avoid the risk of IV reuse that causes
 vulnerabilities. For the case when IV is reused in GCM, see <a href="https://github.com/nonce-disrespect/nonce-disrespect">Nonce-Disrespecting
 Adversaries</a> for details.</p>
-<h3><code>crypto.createCipheriv(algorithm, key, iv[, options])</code><span><a class="mark" href="#crypto_crypto_createcipheriv_algorithm_key_iv_options" id="crypto_crypto_createcipheriv_algorithm_key_iv_options">#</a></span></h3>
+<h4><code>crypto.createCipheriv(algorithm, key, iv[, options])</code><span><a class="mark" href="#crypto_crypto_createcipheriv_algorithm_key_iv_options" id="crypto_crypto_createcipheriv_algorithm_key_iv_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v11.6.0</td>
 <td><p>The <code>key</code> argument can now be a <code>KeyObject</code>.</p></td></tr>
-<tr><td>v11.2.0</td>
+<tr><td>v11.2.0, v10.17.0</td>
 <td><p>The cipher <code>chacha20-poly1305</code> is now supported.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>Ciphers in OCB mode are now supported.</p></td></tr>
@@ -20751,7 +21668,7 @@ added to ciphertext messages unencrypted. It may sound contradictory that
 something has to be unpredictable and unique, but does not have to be secret;
 remember that an attacker must not be able to predict ahead of time what a
 given IV will be.</p>
-<h3><code>crypto.createDecipher(algorithm, password[, options])</code><span><a class="mark" href="#crypto_crypto_createdecipher_algorithm_password_options" id="crypto_crypto_createdecipher_algorithm_password_options">#</a></span></h3>
+<h4><code>crypto.createDecipher(algorithm, password[, options])</code><span><a class="mark" href="#crypto_crypto_createdecipher_algorithm_password_options" id="crypto_crypto_createdecipher_algorithm_password_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20788,14 +21705,14 @@ rapidly.</p>
 <a href="https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html"><code>EVP_BytesToKey</code></a> it is recommended that developers derive a key and IV on
 their own using <a href="#crypto_crypto_scrypt_password_salt_keylen_options_callback"><code>crypto.scrypt()</code></a> and to use <a href="#crypto_crypto_createdecipheriv_algorithm_key_iv_options"><code>crypto.createDecipheriv()</code></a>
 to create the <code>Decipher</code> object.</p>
-<h3><code>crypto.createDecipheriv(algorithm, key, iv[, options])</code><span><a class="mark" href="#crypto_crypto_createdecipheriv_algorithm_key_iv_options" id="crypto_crypto_createdecipheriv_algorithm_key_iv_options">#</a></span></h3>
+<h4><code>crypto.createDecipheriv(algorithm, key, iv[, options])</code><span><a class="mark" href="#crypto_crypto_createdecipheriv_algorithm_key_iv_options" id="crypto_crypto_createdecipheriv_algorithm_key_iv_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v11.6.0</td>
 <td><p>The <code>key</code> argument can now be a <code>KeyObject</code>.</p></td></tr>
-<tr><td>v11.2.0</td>
+<tr><td>v11.2.0, v10.17.0</td>
 <td><p>The cipher <code>chacha20-poly1305</code> is now supported.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>Ciphers in OCB mode are now supported.</p></td></tr>
@@ -20838,7 +21755,7 @@ added to ciphertext messages unencrypted. It may sound contradictory that
 something has to be unpredictable and unique, but does not have to be secret;
 remember that an attacker must not be able to predict ahead of time what a given
 IV will be.</p>
-<h3><code>crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])</code><span><a class="mark" href="#crypto_crypto_creatediffiehellman_prime_primeencoding_generator_generatorencoding" id="crypto_crypto_creatediffiehellman_prime_primeencoding_generator_generatorencoding">#</a></span></h3>
+<h4><code>crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])</code><span><a class="mark" href="#crypto_crypto_creatediffiehellman_prime_primeencoding_generator_generatorencoding" id="crypto_crypto_creatediffiehellman_prime_primeencoding_generator_generatorencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20870,7 +21787,7 @@ optional specific <code>generator</code>.</p>
 a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or <code>DataView</code> is expected.</p>
 <p>If <code>generatorEncoding</code> is specified, <code>generator</code> is expected to be a string;
 otherwise a number, <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or <code>DataView</code> is expected.</p>
-<h3><code>crypto.createDiffieHellman(primeLength[, generator])</code><span><a class="mark" href="#crypto_crypto_creatediffiehellman_primelength_generator" id="crypto_crypto_creatediffiehellman_primelength_generator">#</a></span></h3>
+<h4><code>crypto.createDiffieHellman(primeLength[, generator])</code><span><a class="mark" href="#crypto_crypto_creatediffiehellman_primelength_generator" id="crypto_crypto_creatediffiehellman_primelength_generator">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -20882,7 +21799,7 @@ otherwise a number, <a href="buffer.html"><code>Buffer</code></a>, <code>TypedAr
 <p>Creates a <code>DiffieHellman</code> key exchange object and generates a prime of
 <code>primeLength</code> bits using an optional specific numeric <code>generator</code>.
 If <code>generator</code> is not specified, the value <code>2</code> is used.</p>
-<h3><code>crypto.createDiffieHellmanGroup(name)</code><span><a class="mark" href="#crypto_crypto_creatediffiehellmangroup_name" id="crypto_crypto_creatediffiehellmangroup_name">#</a></span></h3>
+<h4><code>crypto.createDiffieHellmanGroup(name)</code><span><a class="mark" href="#crypto_crypto_creatediffiehellmangroup_name" id="crypto_crypto_creatediffiehellmangroup_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -20891,7 +21808,7 @@ If <code>generator</code> is not specified, the value <code>2</code> is used.</p
 <li>Returns: <a href="#crypto_class_diffiehellmangroup" class="type">&#x3C;DiffieHellmanGroup></a></li>
 </ul>
 <p>An alias for <a href="#crypto_crypto_getdiffiehellman_groupname"><code>crypto.getDiffieHellman()</code></a></p>
-<h3><code>crypto.createECDH(curveName)</code><span><a class="mark" href="#crypto_crypto_createecdh_curvename" id="crypto_crypto_createecdh_curvename">#</a></span></h3>
+<h4><code>crypto.createECDH(curveName)</code><span><a class="mark" href="#crypto_crypto_createecdh_curvename" id="crypto_crypto_createecdh_curvename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -20904,7 +21821,7 @@ predefined curve specified by the <code>curveName</code> string. Use
 <a href="#crypto_crypto_getcurves"><code>crypto.getCurves()</code></a> to obtain a list of available curve names. On recent
 OpenSSL releases, <code>openssl ecparam -list_curves</code> will also display the name
 and description of each available elliptic curve.</p>
-<h3><code>crypto.createHash(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createhash_algorithm_options" id="crypto_crypto_createhash_algorithm_options">#</a></span></h3>
+<h4><code>crypto.createHash(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createhash_algorithm_options" id="crypto_crypto_createhash_algorithm_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20931,24 +21848,24 @@ On recent releases of OpenSSL, <code>openssl list -digest-algorithms</code>
 (<code>openssl list-message-digest-algorithms</code> for older versions of OpenSSL) will
 display the available digest algorithms.</p>
 <p>Example: generating the sha256 sum of a file</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> filename = process.argv[<span class="hljs-number">2</span>];
+<pre><code class="language-js"><span class="hljs-keyword">const</span> filename = process.<span class="hljs-property">argv</span>[<span class="hljs-number">2</span>];
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(filename);
-input.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(filename);
+input.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Only one element is going to be produced by the</span>
   <span class="hljs-comment">// hash stream.</span>
-  <span class="hljs-keyword">const</span> data = input.read();
+  <span class="hljs-keyword">const</span> data = input.<span class="hljs-title function_">read</span>();
   <span class="hljs-keyword">if</span> (data)
-    hash.update(data);
+    hash.<span class="hljs-title function_">update</span>(data);
   <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${hash.digest(<span class="hljs-string">'hex'</span>)}</span> <span class="hljs-subst">${filename}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${hash.digest(<span class="hljs-string">'hex'</span>)}</span> <span class="hljs-subst">${filename}</span>`</span>);
   }
 });</code></pre>
-<h3><code>crypto.createHmac(algorithm, key[, options])</code><span><a class="mark" href="#crypto_crypto_createhmac_algorithm_key_options" id="crypto_crypto_createhmac_algorithm_key_options">#</a></span></h3>
+<h4><code>crypto.createHmac(algorithm, key[, options])</code><span><a class="mark" href="#crypto_crypto_createhmac_algorithm_key_options" id="crypto_crypto_createhmac_algorithm_key_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -20976,24 +21893,24 @@ display the available digest algorithms.</p>
 <p>The <code>key</code> is the HMAC key used to generate the cryptographic HMAC hash. If it is
 a <a href="#crypto_class_keyobject"><code>KeyObject</code></a>, its type must be <code>secret</code>.</p>
 <p>Example: generating the sha256 HMAC of a file</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> filename = process.argv[<span class="hljs-number">2</span>];
+<pre><code class="language-js"><span class="hljs-keyword">const</span> filename = process.<span class="hljs-property">argv</span>[<span class="hljs-number">2</span>];
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> hmac = crypto.createHmac(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
+<span class="hljs-keyword">const</span> hmac = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(filename);
-input.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(filename);
+input.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Only one element is going to be produced by the</span>
   <span class="hljs-comment">// hash stream.</span>
-  <span class="hljs-keyword">const</span> data = input.read();
+  <span class="hljs-keyword">const</span> data = input.<span class="hljs-title function_">read</span>();
   <span class="hljs-keyword">if</span> (data)
-    hmac.update(data);
+    hmac.<span class="hljs-title function_">update</span>(data);
   <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${hmac.digest(<span class="hljs-string">'hex'</span>)}</span> <span class="hljs-subst">${filename}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${hmac.digest(<span class="hljs-string">'hex'</span>)}</span> <span class="hljs-subst">${filename}</span>`</span>);
   }
 });</code></pre>
-<h3><code>crypto.createPrivateKey(key)</code><span><a class="mark" href="#crypto_crypto_createprivatekey_key" id="crypto_crypto_createprivatekey_key">#</a></span></h3>
+<h4><code>crypto.createPrivateKey(key)</code><span><a class="mark" href="#crypto_crypto_createprivatekey_key" id="crypto_crypto_createprivatekey_key">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
@@ -21014,7 +21931,7 @@ string or <code>Buffer</code>, <code>format</code> is assumed to be <code>'pem'<
 must be an object with the properties described above.</p>
 <p>If the private key is encrypted, a <code>passphrase</code> must be specified. The length
 of the passphrase is limited to 1024 bytes.</p>
-<h3><code>crypto.createPublicKey(key)</code><span><a class="mark" href="#crypto_crypto_createpublickey_key" id="crypto_crypto_createpublickey_key">#</a></span></h3>
+<h4><code>crypto.createPublicKey(key)</code><span><a class="mark" href="#crypto_crypto_createpublickey_key" id="crypto_crypto_createpublickey_key">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -21051,17 +21968,17 @@ returned <code>KeyObject</code> will be <code>'public'</code> and that the priva
 extracted from the returned <code>KeyObject</code>. Similarly, if a <code>KeyObject</code> with type
 <code>'private'</code> is given, a new <code>KeyObject</code> with type <code>'public'</code> will be returned
 and it will be impossible to extract the private key from the returned object.</p>
-<h3><code>crypto.createSecretKey(key)</code><span><a class="mark" href="#crypto_crypto_createsecretkey_key" id="crypto_crypto_createsecretkey_key">#</a></span></h3>
+<h4><code>crypto.createSecretKey(key)</code><span><a class="mark" href="#crypto_crypto_createsecretkey_key" id="crypto_crypto_createsecretkey_key">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
 <ul>
-<li><code>key</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>key</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
 <li>Returns: <a href="#crypto_class_keyobject" class="type">&#x3C;KeyObject></a></li>
 </ul>
 <p>Creates and returns a new key object containing a secret key for symmetric
 encryption or <code>Hmac</code>.</p>
-<h3><code>crypto.createSign(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createsign_algorithm_options" id="crypto_crypto_createsign_algorithm_options">#</a></span></h3>
+<h4><code>crypto.createSign(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createsign_algorithm_options" id="crypto_crypto_createsign_algorithm_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -21078,7 +21995,7 @@ algorithm, such as <code>'RSA-SHA256'</code>, instead of a digest algorithm. Thi
 the corresponding digest algorithm. This does not work for all signature
 algorithms, such as <code>'ecdsa-with-SHA256'</code>, so it is best to always use digest
 algorithm names.</p>
-<h3><code>crypto.createVerify(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createverify_algorithm_options" id="crypto_crypto_createverify_algorithm_options">#</a></span></h3>
+<h4><code>crypto.createVerify(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createverify_algorithm_options" id="crypto_crypto_createverify_algorithm_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -21096,9 +22013,9 @@ algorithm, such as <code>'RSA-SHA256'</code>, instead of a digest algorithm. Thi
 the corresponding digest algorithm. This does not work for all signature
 algorithms, such as <code>'ecdsa-with-SHA256'</code>, so it is best to always use digest
 algorithm names.</p>
-<h3><code>crypto.diffieHellman(options)</code><span><a class="mark" href="#crypto_crypto_diffiehellman_options" id="crypto_crypto_diffiehellman_options">#</a></span></h3>
+<h4><code>crypto.diffieHellman(options)</code><span><a class="mark" href="#crypto_crypto_diffiehellman_options" id="crypto_crypto_diffiehellman_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.9.0</span>
 </div>
 <ul>
 <li><code>options</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -21112,12 +22029,12 @@ algorithm names.</p>
 <p>Computes the Diffie-Hellman secret based on a <code>privateKey</code> and a <code>publicKey</code>.
 Both keys must have the same <code>asymmetricKeyType</code>, which must be one of <code>'dh'</code>
 (for Diffie-Hellman), <code>'ec'</code> (for ECDH), <code>'x448'</code>, or <code>'x25519'</code> (for ECDH-ES).</p>
-<h3><code>crypto.generateKeyPair(type, options, callback)</code><span><a class="mark" href="#crypto_crypto_generatekeypair_type_options_callback" id="crypto_crypto_generatekeypair_type_options_callback">#</a></span></h3>
+<h4><code>crypto.generateKeyPair(type, options, callback)</code><span><a class="mark" href="#crypto_crypto_generatekeypair_type_options_callback" id="crypto_crypto_generatekeypair_type_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.9.0</td>
 <td><p>Add support for Diffie-Hellman.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Add ability to generate X25519 and X448 key pairs.</p></td></tr>
@@ -21164,7 +22081,7 @@ the respective part of the key is returned as a <a href="#crypto_class_keyobject
 <p>It is recommended to encode public keys as <code>'spki'</code> and private keys as
 <code>'pkcs8'</code> with encryption for long-term storage:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { generateKeyPair } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-generateKeyPair(<span class="hljs-string">'rsa'</span>, {
+<span class="hljs-title function_">generateKeyPair</span>(<span class="hljs-string">'rsa'</span>, {
   <span class="hljs-attr">modulusLength</span>: <span class="hljs-number">4096</span>,
   <span class="hljs-attr">publicKeyEncoding</span>: {
     <span class="hljs-attr">type</span>: <span class="hljs-string">'spki'</span>,
@@ -21183,12 +22100,12 @@ generateKeyPair(<span class="hljs-string">'rsa'</span>, {
 <code>publicKey</code> / <code>privateKey</code> representing the generated key pair.</p>
 <p>If this method is invoked as its <a href="#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
 a <code>Promise</code> for an <code>Object</code> with <code>publicKey</code> and <code>privateKey</code> properties.</p>
-<h3><code>crypto.generateKeyPairSync(type, options)</code><span><a class="mark" href="#crypto_crypto_generatekeypairsync_type_options" id="crypto_crypto_generatekeypairsync_type_options">#</a></span></h3>
+<h4><code>crypto.generateKeyPairSync(type, options)</code><span><a class="mark" href="#crypto_crypto_generatekeypairsync_type_options" id="crypto_crypto_generatekeypairsync_type_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.9.0</td>
 <td><p>Add support for Diffie-Hellman.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Add ability to generate Ed25519 and Ed448 key pairs.</p></td></tr>
@@ -21233,7 +22150,7 @@ the respective part of the key is returned as a <a href="#crypto_class_keyobject
 private keys, it is recommended to use <code>'pkcs8'</code> with a strong passphrase,
 and to keep the passphrase confidential.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { generateKeyPairSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> { publicKey, privateKey } = generateKeyPairSync(<span class="hljs-string">'rsa'</span>, {
+<span class="hljs-keyword">const</span> { publicKey, privateKey } = <span class="hljs-title function_">generateKeyPairSync</span>(<span class="hljs-string">'rsa'</span>, {
   <span class="hljs-attr">modulusLength</span>: <span class="hljs-number">4096</span>,
   <span class="hljs-attr">publicKeyEncoding</span>: {
     <span class="hljs-attr">type</span>: <span class="hljs-string">'spki'</span>,
@@ -21249,7 +22166,7 @@ and to keep the passphrase confidential.</p>
 <p>The return value <code>{ publicKey, privateKey }</code> represents the generated key pair.
 When PEM encoding was selected, the respective key will be a string, otherwise
 it will be a buffer containing the data encoded as DER.</p>
-<h3><code>crypto.getCiphers()</code><span><a class="mark" href="#crypto_crypto_getciphers" id="crypto_crypto_getciphers">#</a></span></h3>
+<h4><code>crypto.getCiphers()</code><span><a class="mark" href="#crypto_crypto_getciphers" id="crypto_crypto_getciphers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -21257,18 +22174,18 @@ it will be a buffer containing the data encoded as DER.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> An array with the names of the supported cipher
 algorithms.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ciphers = crypto.getCiphers();
-<span class="hljs-built_in">console</span>.log(ciphers); <span class="hljs-comment">// ['aes-128-cbc', 'aes-128-ccm', ...]</span></code></pre>
-<h3><code>crypto.getCurves()</code><span><a class="mark" href="#crypto_crypto_getcurves" id="crypto_crypto_getcurves">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ciphers = crypto.<span class="hljs-title function_">getCiphers</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(ciphers); <span class="hljs-comment">// ['aes-128-cbc', 'aes-128-ccm', ...]</span></code></pre>
+<h4><code>crypto.getCurves()</code><span><a class="mark" href="#crypto_crypto_getcurves" id="crypto_crypto_getcurves">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v2.3.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> An array with the names of the supported elliptic curves.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> curves = crypto.getCurves();
-<span class="hljs-built_in">console</span>.log(curves); <span class="hljs-comment">// ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]</span></code></pre>
-<h3><code>crypto.getDiffieHellman(groupName)</code><span><a class="mark" href="#crypto_crypto_getdiffiehellman_groupname" id="crypto_crypto_getdiffiehellman_groupname">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> curves = crypto.<span class="hljs-title function_">getCurves</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(curves); <span class="hljs-comment">// ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]</span></code></pre>
+<h4><code>crypto.getDiffieHellman(groupName)</code><span><a class="mark" href="#crypto_crypto_getdiffiehellman_groupname" id="crypto_crypto_getdiffiehellman_groupname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
@@ -21288,18 +22205,18 @@ generate nor exchange a group modulus beforehand, saving both processor
 and communication time.</p>
 <p>Example (obtaining a shared secret):</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> alice = crypto.getDiffieHellman(<span class="hljs-string">'modp14'</span>);
-<span class="hljs-keyword">const</span> bob = crypto.getDiffieHellman(<span class="hljs-string">'modp14'</span>);
+<span class="hljs-keyword">const</span> alice = crypto.<span class="hljs-title function_">getDiffieHellman</span>(<span class="hljs-string">'modp14'</span>);
+<span class="hljs-keyword">const</span> bob = crypto.<span class="hljs-title function_">getDiffieHellman</span>(<span class="hljs-string">'modp14'</span>);
 
-alice.generateKeys();
-bob.generateKeys();
+alice.<span class="hljs-title function_">generateKeys</span>();
+bob.<span class="hljs-title function_">generateKeys</span>();
 
-<span class="hljs-keyword">const</span> aliceSecret = alice.computeSecret(bob.getPublicKey(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
-<span class="hljs-keyword">const</span> bobSecret = bob.computeSecret(alice.getPublicKey(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> aliceSecret = alice.<span class="hljs-title function_">computeSecret</span>(bob.<span class="hljs-title function_">getPublicKey</span>(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> bobSecret = bob.<span class="hljs-title function_">computeSecret</span>(alice.<span class="hljs-title function_">getPublicKey</span>(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
 
 <span class="hljs-comment">/* aliceSecret and bobSecret should be the same */</span>
-<span class="hljs-built_in">console</span>.log(aliceSecret === bobSecret);</code></pre>
-<h3><code>crypto.getFips()</code><span><a class="mark" href="#crypto_crypto_getfips" id="crypto_crypto_getfips">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(aliceSecret === bobSecret);</code></pre>
+<h4><code>crypto.getFips()</code><span><a class="mark" href="#crypto_crypto_getfips" id="crypto_crypto_getfips">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -21308,7 +22225,7 @@ bob.generateKeys();
 currently in use, <code>0</code> otherwise. A future semver-major release may change
 the return type of this API to a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a>.</li>
 </ul>
-<h3><code>crypto.getHashes()</code><span><a class="mark" href="#crypto_crypto_gethashes" id="crypto_crypto_gethashes">#</a></span></h3>
+<h4><code>crypto.getHashes()</code><span><a class="mark" href="#crypto_crypto_gethashes" id="crypto_crypto_gethashes">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -21316,13 +22233,15 @@ the return type of this API to a <a href="https://developer.mozilla.org/en-US/do
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> An array of the names of the supported hash algorithms,
 such as <code>'RSA-SHA256'</code>. Hash algorithms are also called "digest" algorithms.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hashes = crypto.getHashes();
-<span class="hljs-built_in">console</span>.log(hashes); <span class="hljs-comment">// ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]</span></code></pre>
-<h3><code>crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)</code><span><a class="mark" href="#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback" id="crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hashes = crypto.<span class="hljs-title function_">getHashes</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hashes); <span class="hljs-comment">// ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]</span></code></pre>
+<h4><code>crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)</code><span><a class="mark" href="#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback" id="crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>iterations</code> parameter is now restricted to positive values. Earlier releases treated other values as one.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>digest</code> parameter is always required now.</p></td></tr>
 <tr><td>v6.0.0</td>
@@ -21364,29 +22283,31 @@ but will take a longer amount of time to complete.</p>
 <p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is
 random and at least 16 bytes long. See <a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf">NIST SP 800-132</a> for details.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-crypto.pbkdf2(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'sha512'</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
+crypto.<span class="hljs-title function_">pbkdf2</span>(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'sha512'</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(derivedKey.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(derivedKey.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
 });</code></pre>
 <p>The <code>crypto.DEFAULT_ENCODING</code> property can be used to change the way the
 <code>derivedKey</code> is passed to the callback. This property, however, has been
 deprecated and use should be avoided.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-crypto.DEFAULT_ENCODING = <span class="hljs-string">'hex'</span>;
-crypto.pbkdf2(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">512</span>, <span class="hljs-string">'sha512'</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
+crypto.<span class="hljs-property">DEFAULT_ENCODING</span> = <span class="hljs-string">'hex'</span>;
+crypto.<span class="hljs-title function_">pbkdf2</span>(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">512</span>, <span class="hljs-string">'sha512'</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(derivedKey);  <span class="hljs-comment">// '3745e48...aa39b34'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(derivedKey);  <span class="hljs-comment">// '3745e48...aa39b34'</span>
 });</code></pre>
 <p>An array of supported digest functions can be retrieved using
 <a href="#crypto_crypto_gethashes"><code>crypto.getHashes()</code></a>.</p>
 <p>This API uses libuv's threadpool, which can have surprising and
 negative performance implications for some applications; see the
 <a href="#cli_uv_threadpool_size_size"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>
-<h3><code>crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)</code><span><a class="mark" href="#crypto_crypto_pbkdf2sync_password_salt_iterations_keylen_digest" id="crypto_crypto_pbkdf2sync_password_salt_iterations_keylen_digest">#</a></span></h3>
+<h4><code>crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)</code><span><a class="mark" href="#crypto_crypto_pbkdf2sync_password_salt_iterations_keylen_digest" id="crypto_crypto_pbkdf2sync_password_salt_iterations_keylen_digest">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>iterations</code> parameter is now restricted to positive values. Earlier releases treated other values as one.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>Calling this function without passing the <code>digest</code> parameter is deprecated now and will emit a warning.</p></td></tr>
 <tr><td>v6.0.0</td>
@@ -21418,18 +22339,18 @@ but will take a longer amount of time to complete.</p>
 <p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is
 random and at least 16 bytes long. See <a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf">NIST SP 800-132</a> for details.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> key = crypto.pbkdf2Sync(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'sha512'</span>);
-<span class="hljs-built_in">console</span>.log(key.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span></code></pre>
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">pbkdf2Sync</span>(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'sha512'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span></code></pre>
 <p>The <code>crypto.DEFAULT_ENCODING</code> property may be used to change the way the
 <code>derivedKey</code> is returned. This property, however, is deprecated and use
 should be avoided.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-crypto.DEFAULT_ENCODING = <span class="hljs-string">'hex'</span>;
-<span class="hljs-keyword">const</span> key = crypto.pbkdf2Sync(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">512</span>, <span class="hljs-string">'sha512'</span>);
-<span class="hljs-built_in">console</span>.log(key);  <span class="hljs-comment">// '3745e48...aa39b34'</span></code></pre>
+crypto.<span class="hljs-property">DEFAULT_ENCODING</span> = <span class="hljs-string">'hex'</span>;
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">pbkdf2Sync</span>(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">512</span>, <span class="hljs-string">'sha512'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key);  <span class="hljs-comment">// '3745e48...aa39b34'</span></code></pre>
 <p>An array of supported digest functions can be retrieved using
 <a href="#crypto_crypto_gethashes"><code>crypto.getHashes()</code></a>.</p>
-<h3><code>crypto.privateDecrypt(privateKey, buffer)</code><span><a class="mark" href="#crypto_crypto_privatedecrypt_privatekey_buffer" id="crypto_crypto_privatedecrypt_privatekey_buffer">#</a></span></h3>
+<h4><code>crypto.privateDecrypt(privateKey, buffer)</code><span><a class="mark" href="#crypto_crypto_privatedecrypt_privatekey_buffer" id="crypto_crypto_privatedecrypt_privatekey_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -21451,7 +22372,7 @@ crypto.DEFAULT_ENCODING = <span class="hljs-string">'hex'</span>;
 <li><code>oaepHash</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The hash function to use for OAEP padding and MGF1.
 <strong>Default:</strong> <code>'sha1'</code></li>
 <li><code>oaepLabel</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The label to use for OAEP
- padding. If not specified, no label is used.</li>
+padding. If not specified, no label is used.</li>
 <li><code>padding</code> <a href="#crypto_crypto_constants_1" class="type">&#x3C;crypto.constants></a> An optional padding value defined in
 <code>crypto.constants</code>, which may be: <code>crypto.constants.RSA_NO_PADDING</code>,
 <code>crypto.constants.RSA_PKCS1_PADDING</code>, or
@@ -21467,7 +22388,7 @@ the corresponding public key, for example using <a href="#crypto_crypto_publicen
 <code>privateKey</code> had been passed to <a href="#crypto_crypto_createprivatekey_key"><code>crypto.createPrivateKey()</code></a>. If it is an
 object, the <code>padding</code> property can be passed. Otherwise, this function uses
 <code>RSA_PKCS1_OAEP_PADDING</code>.</p>
-<h3><code>crypto.privateEncrypt(privateKey, buffer)</code><span><a class="mark" href="#crypto_crypto_privateencrypt_privatekey_buffer" id="crypto_crypto_privateencrypt_privatekey_buffer">#</a></span></h3>
+<h4><code>crypto.privateEncrypt(privateKey, buffer)</code><span><a class="mark" href="#crypto_crypto_privateencrypt_privatekey_buffer" id="crypto_crypto_privateencrypt_privatekey_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -21498,7 +22419,7 @@ the corresponding public key, for example using <a href="#crypto_crypto_publicde
 <code>privateKey</code> had been passed to <a href="#crypto_crypto_createprivatekey_key"><code>crypto.createPrivateKey()</code></a>. If it is an
 object, the <code>padding</code> property can be passed. Otherwise, this function uses
 <code>RSA_PKCS1_PADDING</code>.</p>
-<h3><code>crypto.publicDecrypt(key, buffer)</code><span><a class="mark" href="#crypto_crypto_publicdecrypt_key_buffer" id="crypto_crypto_publicdecrypt_key_buffer">#</a></span></h3>
+<h4><code>crypto.publicDecrypt(key, buffer)</code><span><a class="mark" href="#crypto_crypto_publicdecrypt_key_buffer" id="crypto_crypto_publicdecrypt_key_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -21530,7 +22451,7 @@ object, the <code>padding</code> property can be passed. Otherwise, this functio
 <code>RSA_PKCS1_PADDING</code>.</p>
 <p>Because RSA public keys can be derived from private keys, a private key may
 be passed instead of a public key.</p>
-<h3><code>crypto.publicEncrypt(key, buffer)</code><span><a class="mark" href="#crypto_crypto_publicencrypt_key_buffer" id="crypto_crypto_publicencrypt_key_buffer">#</a></span></h3>
+<h4><code>crypto.publicEncrypt(key, buffer)</code><span><a class="mark" href="#crypto_crypto_publicencrypt_key_buffer" id="crypto_crypto_publicencrypt_key_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -21553,7 +22474,7 @@ be passed instead of a public key.</p>
 <li><code>oaepHash</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The hash function to use for OAEP padding and MGF1.
 <strong>Default:</strong> <code>'sha1'</code></li>
 <li><code>oaepLabel</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The label to use for OAEP
- padding. If not specified, no label is used.</li>
+padding. If not specified, no label is used.</li>
 <li><code>passphrase</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> An optional passphrase for the private key.</li>
 <li><code>padding</code> <a href="#crypto_crypto_constants_1" class="type">&#x3C;crypto.constants></a> An optional padding value defined in
 <code>crypto.constants</code>, which may be: <code>crypto.constants.RSA_NO_PADDING</code>,
@@ -21573,7 +22494,7 @@ object, the <code>padding</code> property can be passed. Otherwise, this functio
 <code>RSA_PKCS1_OAEP_PADDING</code>.</p>
 <p>Because RSA public keys can be derived from private keys, a private key may
 be passed instead of a public key.</p>
-<h3><code>crypto.randomBytes(size[, callback])</code><span><a class="mark" href="#crypto_crypto_randombytes_size_callback" id="crypto_crypto_randombytes_size_callback">#</a></span></h3>
+<h4><code>crypto.randomBytes(size[, callback])</code><span><a class="mark" href="#crypto_crypto_randombytes_size_callback" id="crypto_crypto_randombytes_size_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -21603,16 +22524,16 @@ If an error occurs, <code>err</code> will be an <code>Error</code> object; other
 <code>buf</code> argument is a <a href="buffer.html"><code>Buffer</code></a> containing the generated bytes.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Asynchronous</span>
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-crypto.randomBytes(<span class="hljs-number">256</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+crypto.<span class="hljs-title function_">randomBytes</span>(<span class="hljs-number">256</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${buf.length}</span> bytes of random data: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'hex'</span>)}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${buf.length}</span> bytes of random data: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'hex'</span>)}</span>`</span>);
 });</code></pre>
 <p>If the <code>callback</code> function is not provided, the random bytes are generated
 synchronously and returned as a <a href="buffer.html"><code>Buffer</code></a>. An error will be thrown if
 there is a problem generating the bytes.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Synchronous</span>
-<span class="hljs-keyword">const</span> buf = crypto.randomBytes(<span class="hljs-number">256</span>);
-<span class="hljs-built_in">console</span>.log(
+<span class="hljs-keyword">const</span> buf = crypto.<span class="hljs-title function_">randomBytes</span>(<span class="hljs-number">256</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
   <span class="hljs-string">`<span class="hljs-subst">${buf.length}</span> bytes of random data: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'hex'</span>)}</span>`</span>);</code></pre>
 <p>The <code>crypto.randomBytes()</code> method will not complete until there is
 sufficient entropy available.
@@ -21626,7 +22547,7 @@ negative performance implications for some applications; see the
 threadpool request. To minimize threadpool task length variation, partition
 large <code>randomBytes</code> requests when doing so as part of fulfilling a client
 request.</p>
-<h3><code>crypto.randomFillSync(buffer[, offset][, size])</code><span><a class="mark" href="#crypto_crypto_randomfillsync_buffer_offset_size" id="crypto_crypto_randomfillsync_buffer_offset_size">#</a></span></h3>
+<h4><code>crypto.randomFillSync(buffer[, offset][, size])</code><span><a class="mark" href="#crypto_crypto_randomfillsync_buffer_offset_size" id="crypto_crypto_randomfillsync_buffer_offset_size">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -21645,28 +22566,28 @@ request.</p>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The object passed as <code>buffer</code> argument.</li>
 </ul>
 <p>Synchronous version of <a href="#crypto_crypto_randomfill_buffer_offset_size_callback"><code>crypto.randomFill()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(crypto.randomFillSync(buf).toString(<span class="hljs-string">'hex'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(crypto.<span class="hljs-title function_">randomFillSync</span>(buf).<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 
-crypto.randomFillSync(buf, <span class="hljs-number">5</span>);
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+crypto.<span class="hljs-title function_">randomFillSync</span>(buf, <span class="hljs-number">5</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 
 <span class="hljs-comment">// The above is equivalent to the following:</span>
-crypto.randomFillSync(buf, <span class="hljs-number">5</span>, <span class="hljs-number">5</span>);
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));</code></pre>
+crypto.<span class="hljs-title function_">randomFillSync</span>(buf, <span class="hljs-number">5</span>, <span class="hljs-number">5</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));</code></pre>
 <p>Any <code>TypedArray</code> or <code>DataView</code> instance may be passed as <code>buffer</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(Buffer.from(crypto.randomFillSync(a).buffer,
-                        a.byteOffset, a.byteLength).toString(<span class="hljs-string">'hex'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>32<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(crypto.<span class="hljs-title function_">randomFillSync</span>(a).<span class="hljs-property">buffer</span>,
+                        a.<span class="hljs-property">byteOffset</span>, a.<span class="hljs-property">byteLength</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 
-<span class="hljs-keyword">const</span> b = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(Buffer.from(crypto.randomFillSync(b).buffer,
-                        b.byteOffset, b.byteLength).toString(<span class="hljs-string">'hex'</span>));
+<span class="hljs-keyword">const</span> b = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(crypto.<span class="hljs-title function_">randomFillSync</span>(b).<span class="hljs-property">buffer</span>,
+                        b.<span class="hljs-property">byteOffset</span>, b.<span class="hljs-property">byteLength</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 
-<span class="hljs-keyword">const</span> c = <span class="hljs-keyword">new</span> <span class="hljs-built_in">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>));
-<span class="hljs-built_in">console</span>.log(Buffer.from(crypto.randomFillSync(c).buffer,
-                        c.byteOffset, c.byteLength).toString(<span class="hljs-string">'hex'</span>));</code></pre>
-<h3><code>crypto.randomFill(buffer[, offset][, size], callback)</code><span><a class="mark" href="#crypto_crypto_randomfill_buffer_offset_size_callback" id="crypto_crypto_randomfill_buffer_offset_size_callback">#</a></span></h3>
+<span class="hljs-keyword">const</span> c = <span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">10</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(crypto.<span class="hljs-title function_">randomFillSync</span>(c).<span class="hljs-property">buffer</span>,
+                        c.<span class="hljs-property">byteOffset</span>, c.<span class="hljs-property">byteLength</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));</code></pre>
+<h4><code>crypto.randomFill(buffer[, offset][, size], callback)</code><span><a class="mark" href="#crypto_crypto_randomfill_buffer_offset_size_callback" id="crypto_crypto_randomfill_buffer_offset_size_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -21688,42 +22609,42 @@ crypto.randomFillSync(buf, <span class="hljs-number">5</span>, <span class="hljs
 argument to be a <a href="buffer.html"><code>Buffer</code></a> that will be filled. It also
 requires that a callback is passed in.</p>
 <p>If the <code>callback</code> function is not provided, an error will be thrown.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">10</span>);
-crypto.randomFill(buf, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
+crypto.<span class="hljs-title function_">randomFill</span>(buf, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });
 
-crypto.randomFill(buf, <span class="hljs-number">5</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+crypto.<span class="hljs-title function_">randomFill</span>(buf, <span class="hljs-number">5</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });
 
 <span class="hljs-comment">// The above is equivalent to the following:</span>
-crypto.randomFill(buf, <span class="hljs-number">5</span>, <span class="hljs-number">5</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+crypto.<span class="hljs-title function_">randomFill</span>(buf, <span class="hljs-number">5</span>, <span class="hljs-number">5</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });</code></pre>
 <p>Any <code>TypedArray</code> or <code>DataView</code> instance may be passed as <code>buffer</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>(<span class="hljs-number">10</span>);
-crypto.randomFill(a, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>32<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+crypto.<span class="hljs-title function_">randomFill</span>(a, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
-    .toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(buf.<span class="hljs-property">buffer</span>, buf.<span class="hljs-property">byteOffset</span>, buf.<span class="hljs-property">byteLength</span>)
+    .<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });
 
-<span class="hljs-keyword">const</span> b = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>(<span class="hljs-number">10</span>);
-crypto.randomFill(b, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+<span class="hljs-keyword">const</span> b = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+crypto.<span class="hljs-title function_">randomFill</span>(b, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
-    .toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(buf.<span class="hljs-property">buffer</span>, buf.<span class="hljs-property">byteOffset</span>, buf.<span class="hljs-property">byteLength</span>)
+    .<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });
 
-<span class="hljs-keyword">const</span> c = <span class="hljs-keyword">new</span> <span class="hljs-built_in">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>));
-crypto.randomFill(c, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+<span class="hljs-keyword">const</span> c = <span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">10</span>));
+crypto.<span class="hljs-title function_">randomFill</span>(c, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
-    .toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(buf.<span class="hljs-property">buffer</span>, buf.<span class="hljs-property">byteOffset</span>, buf.<span class="hljs-property">byteLength</span>)
+    .<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });</code></pre>
 <p>This API uses libuv's threadpool, which can have surprising and
 negative performance implications for some applications; see the
@@ -21732,9 +22653,9 @@ negative performance implications for some applications; see the
 threadpool request. To minimize threadpool task length variation, partition
 large <code>randomFill</code> requests when doing so as part of fulfilling a client
 request.</p>
-<h3><code>crypto.randomInt([min, ]max[, callback])</code><span><a class="mark" href="#crypto_crypto_randomint_min_max_callback" id="crypto_crypto_randomint_min_max_callback">#</a></span></h3>
+<h4><code>crypto.randomInt([min, ]max[, callback])</code><span><a class="mark" href="#crypto_crypto_randomint_min_max_callback" id="crypto_crypto_randomint_min_max_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.10.0</span>
 </div>
 <ul>
 <li><code>min</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Start of random range (inclusive). <strong>Default</strong>: <code>0</code>.</li>
@@ -21748,22 +22669,39 @@ be <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Gl
 <p>If the <code>callback</code> function is not provided, the random integer is
 generated synchronously.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Asynchronous</span>
-crypto.randomInt(<span class="hljs-number">3</span>, <span class="hljs-function">(<span class="hljs-params">err, n</span>) =></span> {
+crypto.<span class="hljs-title function_">randomInt</span>(<span class="hljs-number">3</span>, <span class="hljs-function">(<span class="hljs-params">err, n</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Random number chosen from (0, 1, 2): <span class="hljs-subst">${n}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Random number chosen from (0, 1, 2): <span class="hljs-subst">${n}</span>`</span>);
 });</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// Synchronous</span>
-<span class="hljs-keyword">const</span> n = crypto.randomInt(<span class="hljs-number">3</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Random number chosen from (0, 1, 2): <span class="hljs-subst">${n}</span>`</span>);</code></pre>
+<span class="hljs-keyword">const</span> n = crypto.<span class="hljs-title function_">randomInt</span>(<span class="hljs-number">3</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Random number chosen from (0, 1, 2): <span class="hljs-subst">${n}</span>`</span>);</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// With `min` argument</span>
-<span class="hljs-keyword">const</span> n = crypto.randomInt(<span class="hljs-number">1</span>, <span class="hljs-number">7</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The dice rolled: <span class="hljs-subst">${n}</span>`</span>);</code></pre>
-<h3><code>crypto.scrypt(password, salt, keylen[, options], callback)</code><span><a class="mark" href="#crypto_crypto_scrypt_password_salt_keylen_options_callback" id="crypto_crypto_scrypt_password_salt_keylen_options_callback">#</a></span></h3>
+<span class="hljs-keyword">const</span> n = crypto.<span class="hljs-title function_">randomInt</span>(<span class="hljs-number">1</span>, <span class="hljs-number">7</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The dice rolled: <span class="hljs-subst">${n}</span>`</span>);</code></pre>
+<h4><code>crypto.randomUUID([options])</code><span><a class="mark" href="#crypto_crypto_randomuuid_options" id="crypto_crypto_randomuuid_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>disableEntropyCache</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> By default, to improve performance,
+Node.js generates and caches enough random data to generate up to
+128 random UUIDs. To generate a UUID without using the cache, set
+<code>disableEntropyCache</code> to <code>true</code>. <strong>Defaults</strong>: <code>false</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Generates a random <a href="https://www.rfc-editor.org/rfc/rfc4122.txt">RFC 4122</a> version 4 UUID. The UUID is generated using a
+cryptographic pseudorandom number generator.</p>
+<h4><code>crypto.scrypt(password, salt, keylen[, options], callback)</code><span><a class="mark" href="#crypto_crypto_scrypt_password_salt_keylen_options_callback" id="crypto_crypto_scrypt_password_salt_keylen_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.8.0</td>
+<tr><td>v12.8.0, v10.17.0</td>
 <td><p>The <code>maxmem</code> value can now be any safe integer.</p></td></tr>
 <tr><td>v10.9.0</td>
 <td><p>The <code>cost</code>, <code>blockSize</code> and <code>parallelization</code> option names have been added.</p></td></tr>
@@ -21808,21 +22746,21 @@ random and at least 16 bytes long. See <a href="https://nvlpubs.nist.gov/nistpub
 or types.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-comment">// Using the factory defaults.</span>
-crypto.scrypt(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
+crypto.<span class="hljs-title function_">scrypt</span>(<span class="hljs-string">'password'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(derivedKey.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(derivedKey.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
 });
 <span class="hljs-comment">// Using a custom N parameter. Must be a power of two.</span>
-crypto.scrypt(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, { <span class="hljs-attr">N</span>: <span class="hljs-number">1024</span> }, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
+crypto.<span class="hljs-title function_">scrypt</span>(<span class="hljs-string">'password'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, { <span class="hljs-attr">N</span>: <span class="hljs-number">1024</span> }, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(derivedKey.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...aa39b34'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(derivedKey.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...aa39b34'</span>
 });</code></pre>
-<h3><code>crypto.scryptSync(password, salt, keylen[, options])</code><span><a class="mark" href="#crypto_crypto_scryptsync_password_salt_keylen_options" id="crypto_crypto_scryptsync_password_salt_keylen_options">#</a></span></h3>
+<h4><code>crypto.scryptSync(password, salt, keylen[, options])</code><span><a class="mark" href="#crypto_crypto_scryptsync_password_salt_keylen_options" id="crypto_crypto_scryptsync_password_salt_keylen_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.8.0</td>
+<tr><td>v12.8.0, v10.17.0</td>
 <td><p>The <code>maxmem</code> value can now be any safe integer.</p></td></tr>
 <tr><td>v10.9.0</td>
 <td><p>The <code>cost</code>, <code>blockSize</code> and <code>parallelization</code> option names have been added.</p></td></tr>
@@ -21861,12 +22799,12 @@ returned as a <a href="buffer.html"><code>Buffer</code></a>.</p>
 or types.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-comment">// Using the factory defaults.</span>
-<span class="hljs-keyword">const</span> key1 = crypto.scryptSync(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>);
-<span class="hljs-built_in">console</span>.log(key1.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
+<span class="hljs-keyword">const</span> key1 = crypto.<span class="hljs-title function_">scryptSync</span>(<span class="hljs-string">'password'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key1.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
 <span class="hljs-comment">// Using a custom N parameter. Must be a power of two.</span>
-<span class="hljs-keyword">const</span> key2 = crypto.scryptSync(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, { <span class="hljs-attr">N</span>: <span class="hljs-number">1024</span> });
-<span class="hljs-built_in">console</span>.log(key2.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...aa39b34'</span></code></pre>
-<h3><code>crypto.setEngine(engine[, flags])</code><span><a class="mark" href="#crypto_crypto_setengine_engine_flags" id="crypto_crypto_setengine_engine_flags">#</a></span></h3>
+<span class="hljs-keyword">const</span> key2 = crypto.<span class="hljs-title function_">scryptSync</span>(<span class="hljs-string">'password'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, { <span class="hljs-attr">N</span>: <span class="hljs-number">1024</span> });
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...aa39b34'</span></code></pre>
+<h4><code>crypto.setEngine(engine[, flags])</code><span><a class="mark" href="#crypto_crypto_setengine_engine_flags" id="crypto_crypto_setengine_engine_flags">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.11</span>
 </div>
@@ -21898,7 +22836,7 @@ is a bit field taking one of or a mix of the following flags (defined in
 <li><code>crypto.constants.ENGINE_METHOD_ECDSA</code></li>
 <li><code>crypto.constants.ENGINE_METHOD_STORE</code></li>
 </ul>
-<h3><code>crypto.setFips(bool)</code><span><a class="mark" href="#crypto_crypto_setfips_bool" id="crypto_crypto_setfips_bool">#</a></span></h3>
+<h4><code>crypto.setFips(bool)</code><span><a class="mark" href="#crypto_crypto_setfips_bool" id="crypto_crypto_setfips_bool">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -21907,9 +22845,17 @@ is a bit field taking one of or a mix of the following flags (defined in
 </ul>
 <p>Enables the FIPS compliant crypto provider in a FIPS-enabled Node.js build.
 Throws an error if FIPS mode is not available.</p>
-<h3><code>crypto.sign(algorithm, data, key)</code><span><a class="mark" href="#crypto_crypto_sign_algorithm_data_key" id="crypto_crypto_sign_algorithm_data_key">#</a></span></h3>
+<h4><code>crypto.sign(algorithm, data, key)</code><span><a class="mark" href="#crypto_crypto_sign_algorithm_data_key" id="crypto_crypto_sign_algorithm_data_key">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>This function now supports IEEE-P1363 DSA and ECDSA signatures.</p></td></tr>
+<tr><td>v12.0.0</td>
+<td><p><span>Added in: v12.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>algorithm</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
@@ -21949,7 +22895,7 @@ size, <code>crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN</code> (default) sets it t
 maximum permissible value.</p>
 </li>
 </ul>
-<h3><code>crypto.timingSafeEqual(a, b)</code><span><a class="mark" href="#crypto_crypto_timingsafeequal_a_b" id="crypto_crypto_timingsafeequal_a_b">#</a></span></h3>
+<h4><code>crypto.timingSafeEqual(a, b)</code><span><a class="mark" href="#crypto_crypto_timingsafeequal_a_b" id="crypto_crypto_timingsafeequal_a_b">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.6.0</span>
 </div>
@@ -21964,13 +22910,24 @@ would allow an attacker to guess one of the values. This is suitable for
 comparing HMAC digests or secret values like authentication cookies or
 <a href="https://www.w3.org/TR/capability-urls/">capability urls</a>.</p>
 <p><code>a</code> and <code>b</code> must both be <code>Buffer</code>s, <code>TypedArray</code>s, or <code>DataView</code>s, and they
-must have the same length.</p>
+must have the same byte length.</p>
+<p>If at least one of <code>a</code> and <code>b</code> is a <code>TypedArray</code> with more than one byte per
+entry, such as <code>Uint16Array</code>, the result will be computed using the platform
+byte order.</p>
 <p>Use of <code>crypto.timingSafeEqual</code> does not guarantee that the <em>surrounding</em> code
 is timing-safe. Care should be taken to ensure that the surrounding code does
 not introduce timing vulnerabilities.</p>
-<h3><code>crypto.verify(algorithm, data, key, signature)</code><span><a class="mark" href="#crypto_crypto_verify_algorithm_data_key_signature" id="crypto_crypto_verify_algorithm_data_key_signature">#</a></span></h3>
+<h4><code>crypto.verify(algorithm, data, key, signature)</code><span><a class="mark" href="#crypto_crypto_verify_algorithm_data_key_signature" id="crypto_crypto_verify_algorithm_data_key_signature">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>This function now supports IEEE-P1363 DSA and ECDSA signatures.</p></td></tr>
+<tr><td>v12.0.0</td>
+<td><p><span>Added in: v12.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>algorithm</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
@@ -21988,7 +22945,7 @@ additional properties can be passed:</p>
 <ul>
 <li>
 <p><code>dsaEncoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> For DSA and ECDSA, this option specifies the
-format of the generated signature. It can be one of the following:</p>
+format of the signature. It can be one of the following:</p>
 <ul>
 <li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>
 <li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>
@@ -22014,8 +22971,8 @@ maximum permissible value.</p>
 <p>The <code>signature</code> argument is the previously calculated signature for the <code>data</code>.</p>
 <p>Because public keys can be derived from private keys, a private key or a public
 key may be passed for <code>key</code>.</p>
-<h2>Notes<span><a class="mark" href="#crypto_notes" id="crypto_notes">#</a></span></h2>
-<h3>Legacy Streams API (prior to Node.js 0.10)<span><a class="mark" href="#crypto_legacy_streams_api_prior_to_node_js_0_10" id="crypto_legacy_streams_api_prior_to_node_js_0_10">#</a></span></h3>
+</section><section><h3>Notes<span><a class="mark" href="#crypto_notes" id="crypto_notes">#</a></span></h3>
+<h4>Legacy streams API (prior to Node.js 0.10)<span><a class="mark" href="#crypto_legacy_streams_api_prior_to_node_js_0_10" id="crypto_legacy_streams_api_prior_to_node_js_0_10">#</a></span></h4>
 <p>The Crypto module was added to Node.js before there was the concept of a
 unified Stream API, and before there were <a href="buffer.html"><code>Buffer</code></a> objects for handling
 binary data. As such, the many of the <code>crypto</code> defined classes have methods not
@@ -22024,7 +22981,7 @@ API (e.g. <code>update()</code>, <code>final()</code>, or <code>digest()</code>)
 and returned <code>'latin1'</code> encoded strings by default rather than <code>Buffer</code>s. This
 default was changed after Node.js v0.8 to use <a href="buffer.html"><code>Buffer</code></a> objects by default
 instead.</p>
-<h3>Recent ECDH changes<span><a class="mark" href="#crypto_recent_ecdh_changes" id="crypto_recent_ecdh_changes">#</a></span></h3>
+<h4>Recent ECDH changes<span><a class="mark" href="#crypto_recent_ecdh_changes" id="crypto_recent_ecdh_changes">#</a></span></h4>
 <p>Usage of <code>ECDH</code> with non-dynamically generated key pairs has been simplified.
 Now, <a href="#crypto_ecdh_setprivatekey_privatekey_encoding"><code>ecdh.setPrivateKey()</code></a> can be called with a preselected private key
 and the associated public point (key) will be computed and stored in the object.
@@ -22036,7 +22993,7 @@ API is not useful. Either a previously stored private key should be set, which
 automatically generates the associated public key, or <a href="#crypto_ecdh_generatekeys_encoding_format"><code>ecdh.generateKeys()</code></a>
 should be called. The main drawback of using <a href="#crypto_ecdh_setpublickey_publickey_encoding"><code>ecdh.setPublicKey()</code></a> is that
 it can be used to put the ECDH key pair into an inconsistent state.</p>
-<h3>Support for weak or compromised algorithms<span><a class="mark" href="#crypto_support_for_weak_or_compromised_algorithms" id="crypto_support_for_weak_or_compromised_algorithms">#</a></span></h3>
+<h4>Support for weak or compromised algorithms<span><a class="mark" href="#crypto_support_for_weak_or_compromised_algorithms" id="crypto_support_for_weak_or_compromised_algorithms">#</a></span></h4>
 <p>The <code>crypto</code> module still supports some algorithms which are already
 compromised and are not currently recommended for use. The API also allows
 the use of ciphers and hashes with a small key size that are too weak for safe
@@ -22054,7 +23011,7 @@ at least 2048 bits and that of the curve of ECDSA and ECDH at least
 smaller than 2048 bits and are not recommended.</li>
 </ul>
 <p>See the reference for other recommendations and details.</p>
-<h3>CCM mode<span><a class="mark" href="#crypto_ccm_mode" id="crypto_ccm_mode">#</a></span></h3>
+<h4>CCM mode<span><a class="mark" href="#crypto_ccm_mode" id="crypto_ccm_mode">#</a></span></h4>
 <p>CCM is one of the supported <a href="https://en.wikipedia.org/wiki/Authenticated_encryption">AEAD algorithms</a>. Applications which use this
 mode must adhere to certain restrictions when using the cipher API:</p>
 <ul>
@@ -22087,44 +23044,44 @@ authentication tag.</li>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
 <span class="hljs-keyword">const</span> key = <span class="hljs-string">'keykeykeykeykeykeykeykey'</span>;
-<span class="hljs-keyword">const</span> nonce = crypto.randomBytes(<span class="hljs-number">12</span>);
+<span class="hljs-keyword">const</span> nonce = crypto.<span class="hljs-title function_">randomBytes</span>(<span class="hljs-number">12</span>);
 
-<span class="hljs-keyword">const</span> aad = Buffer.from(<span class="hljs-string">'0123456789'</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> aad = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'0123456789'</span>, <span class="hljs-string">'hex'</span>);
 
-<span class="hljs-keyword">const</span> cipher = crypto.createCipheriv(<span class="hljs-string">'aes-192-ccm'</span>, key, nonce, {
+<span class="hljs-keyword">const</span> cipher = crypto.<span class="hljs-title function_">createCipheriv</span>(<span class="hljs-string">'aes-192-ccm'</span>, key, nonce, {
   <span class="hljs-attr">authTagLength</span>: <span class="hljs-number">16</span>
 });
 <span class="hljs-keyword">const</span> plaintext = <span class="hljs-string">'Hello world'</span>;
-cipher.setAAD(aad, {
-  <span class="hljs-attr">plaintextLength</span>: Buffer.byteLength(plaintext)
+cipher.<span class="hljs-title function_">setAAD</span>(aad, {
+  <span class="hljs-attr">plaintextLength</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(plaintext)
 });
-<span class="hljs-keyword">const</span> ciphertext = cipher.update(plaintext, <span class="hljs-string">'utf8'</span>);
-cipher.final();
-<span class="hljs-keyword">const</span> tag = cipher.getAuthTag();
+<span class="hljs-keyword">const</span> ciphertext = cipher.<span class="hljs-title function_">update</span>(plaintext, <span class="hljs-string">'utf8'</span>);
+cipher.<span class="hljs-title function_">final</span>();
+<span class="hljs-keyword">const</span> tag = cipher.<span class="hljs-title function_">getAuthTag</span>();
 
 <span class="hljs-comment">// Now transmit { ciphertext, nonce, tag }.</span>
 
-<span class="hljs-keyword">const</span> decipher = crypto.createDecipheriv(<span class="hljs-string">'aes-192-ccm'</span>, key, nonce, {
+<span class="hljs-keyword">const</span> decipher = crypto.<span class="hljs-title function_">createDecipheriv</span>(<span class="hljs-string">'aes-192-ccm'</span>, key, nonce, {
   <span class="hljs-attr">authTagLength</span>: <span class="hljs-number">16</span>
 });
-decipher.setAuthTag(tag);
-decipher.setAAD(aad, {
-  <span class="hljs-attr">plaintextLength</span>: ciphertext.length
+decipher.<span class="hljs-title function_">setAuthTag</span>(tag);
+decipher.<span class="hljs-title function_">setAAD</span>(aad, {
+  <span class="hljs-attr">plaintextLength</span>: ciphertext.<span class="hljs-property">length</span>
 });
-<span class="hljs-keyword">const</span> receivedPlaintext = decipher.update(ciphertext, <span class="hljs-literal">null</span>, <span class="hljs-string">'utf8'</span>);
+<span class="hljs-keyword">const</span> receivedPlaintext = decipher.<span class="hljs-title function_">update</span>(ciphertext, <span class="hljs-literal">null</span>, <span class="hljs-string">'utf8'</span>);
 
 <span class="hljs-keyword">try</span> {
-  decipher.final();
+  decipher.<span class="hljs-title function_">final</span>();
 } <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Authentication failed!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Authentication failed!'</span>);
   <span class="hljs-keyword">return</span>;
 }
 
-<span class="hljs-built_in">console</span>.log(receivedPlaintext);</code></pre>
-<h2>Crypto constants<span><a class="mark" href="#crypto_crypto_constants_1" id="crypto_crypto_constants_1">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(receivedPlaintext);</code></pre>
+</section><section><h3>Crypto constants<span><a class="mark" href="#crypto_crypto_constants_1" id="crypto_crypto_constants_1">#</a></span></h3>
 <p>The following constants exported by <code>crypto.constants</code> apply to various uses of
 the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and are generally specific to OpenSSL.</p>
-<h3>OpenSSL options<span><a class="mark" href="#crypto_openssl_options" id="crypto_openssl_options">#</a></span></h3>
+<h4>OpenSSL options<span><a class="mark" href="#crypto_openssl_options" id="crypto_openssl_options">#</a></span></h4>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -22303,7 +23260,7 @@ the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and ar
     <td>Instructs OpenSSL to disable version rollback attack detection.</td>
   </tr>
 </tbody></table>
-<h3>OpenSSL engine constants<span><a class="mark" href="#crypto_openssl_engine_constants" id="crypto_openssl_engine_constants">#</a></span></h3>
+<h4>OpenSSL engine constants<span><a class="mark" href="#crypto_openssl_engine_constants" id="crypto_openssl_engine_constants">#</a></span></h4>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -22354,7 +23311,7 @@ the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and ar
     <td></td>
   </tr>
 </tbody></table>
-<h3>Other OpenSSL constants<span><a class="mark" href="#crypto_other_openssl_constants" id="crypto_other_openssl_constants">#</a></span></h3>
+<h4>Other OpenSSL constants<span><a class="mark" href="#crypto_other_openssl_constants" id="crypto_other_openssl_constants">#</a></span></h4>
 <p>See the <a href="https://wiki.openssl.org/index.php/List_of_SSL_OP_Flags#Table_of_Options">list of SSL OP Flags</a> for details.</p>
 <table>
   <tbody><tr>
@@ -22433,7 +23390,7 @@ the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and ar
     <td></td>
   </tr>
 </tbody></table>
-<h3>Node.js crypto constants<span><a class="mark" href="#crypto_node_js_crypto_constants" id="crypto_node_js_crypto_constants">#</a></span></h3>
+<h4>Node.js crypto constants<span><a class="mark" href="#crypto_node_js_crypto_constants" id="crypto_node_js_crypto_constants">#</a></span></h4>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -22448,23 +23405,26 @@ the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and ar
     <td>Specifies the active default cipher list used by the current Node.js
     process.</td>
   </tr>
-</tbody></table>
-<h1>Debugger<span><a class="mark" href="#debugger_debugger" id="debugger_debugger">#</a></span></h1>
+</tbody></table></section>
+        </section>
+<section><h2>Debugger<span><a class="mark" href="#debugger_debugger" id="debugger_debugger">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p>Node.js includes an out-of-process debugging utility accessible via a
-<a href="#debugger_v8_inspector_integration_for_node_js">V8 Inspector</a> and built-in debugging client. To use it, start Node.js
-with the <code>inspect</code> argument followed by the path to the script to debug; a
-prompt will be displayed indicating successful launch of the debugger:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node inspect myscript.js</span>
-&#x3C; Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba
+<p>Node.js includes a command-line debugging utility. To use it, start Node.js
+with the <code>inspect</code> argument followed by the path to the script to debug.</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node inspect myscript.js</span>
+&#x3C; Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8
 &#x3C; For help, see: https://nodejs.org/en/docs/inspector
+&#x3C;
 &#x3C; Debugger attached.
-Break on start in myscript.js:1
-<span class="hljs-meta">></span><span class="bash"> 1 (<span class="hljs-keyword">function</span> (exports, require, module, __filename, __dirname) { global.x = 5;</span>
-  2 setTimeout(() => {
-  3   console.log('world');
+&#x3C;
+ ok
+Break on start in myscript.js:2
+  1 // myscript.js
+<span class="hljs-meta">> </span><span class="language-bash">2 global.x = 5;</span>
+  3 setTimeout(() => {
+  4   debugger;
 <span class="hljs-meta">debug></span></code></pre>
 <p>The Node.js debugger client is not a full-featured debugger, but simple step and
 inspection are possible.</p>
@@ -22472,56 +23432,63 @@ inspection are possible.</p>
 enable a breakpoint at that position in the code:</p>
 <!-- eslint-disable no-debugger -->
 <pre><code class="language-js"><span class="hljs-comment">// myscript.js</span>
-<span class="hljs-built_in">global</span>.x = <span class="hljs-number">5</span>;
+<span class="hljs-variable language_">global</span>.<span class="hljs-property">x</span> = <span class="hljs-number">5</span>;
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-keyword">debugger</span>;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'world'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'world'</span>);
 }, <span class="hljs-number">1000</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'hello'</span>);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello'</span>);</code></pre>
 <p>Once the debugger is run, a breakpoint will occur at line 3:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node inspect myscript.js</span>
-&#x3C; Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node inspect myscript.js</span>
+&#x3C; Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8
 &#x3C; For help, see: https://nodejs.org/en/docs/inspector
+&#x3C;
 &#x3C; Debugger attached.
-Break on start in myscript.js:1
-<span class="hljs-meta">></span><span class="bash"> 1 (<span class="hljs-keyword">function</span> (exports, require, module, __filename, __dirname) { global.x = 5;</span>
-  2 setTimeout(() => {
-  3   debugger;
-<span class="hljs-meta">debug></span><span class="bash"> cont</span>
+&#x3C;
+ ok
+Break on start in myscript.js:2
+  1 // myscript.js
+<span class="hljs-meta">> </span><span class="language-bash">2 global.x = 5;</span>
+  3 setTimeout(() => {
+  4   debugger;
+<span class="hljs-meta">debug> </span><span class="language-bash">cont</span>
 &#x3C; hello
-break in myscript.js:3
-  1 (function (exports, require, module, __filename, __dirname) { global.x = 5;
-  2 setTimeout(() => {
-<span class="hljs-meta">></span><span class="bash"> 3   debugger;</span>
-  4   console.log('world');
-  5 }, 1000);
-<span class="hljs-meta">debug></span><span class="bash"> next</span>
+&#x3C;
 break in myscript.js:4
-  2 setTimeout(() => {
-  3   debugger;
-<span class="hljs-meta">></span><span class="bash"> 4   console.log(<span class="hljs-string">'world'</span>);</span>
-  5 }, 1000);
-  6 console.log('hello');
-<span class="hljs-meta">debug></span><span class="bash"> repl</span>
-Press Ctrl + C to leave debug repl
-<span class="hljs-meta">></span><span class="bash"> x</span>
+  2 global.x = 5;
+  3 setTimeout(() => {
+<span class="hljs-meta">> </span><span class="language-bash">4   debugger;</span>
+  5   console.log('world');
+  6 }, 1000);
+<span class="hljs-meta">debug> </span><span class="language-bash">next</span>
+break in myscript.js:5
+  3 setTimeout(() => {
+  4   debugger;
+<span class="hljs-meta">> </span><span class="language-bash">5   console.log(<span class="hljs-string">'world'</span>);</span>
+  6 }, 1000);
+  7 console.log('hello');
+<span class="hljs-meta">debug> </span><span class="language-bash">repl</span>
+Press Ctrl+C to leave debug repl
+<span class="hljs-meta">> </span><span class="language-bash">x</span>
 5
-<span class="hljs-meta">></span><span class="bash"> 2 + 2</span>
+<span class="hljs-meta">> </span><span class="language-bash">2 + 2</span>
 4
-<span class="hljs-meta">debug></span><span class="bash"> next</span>
+<span class="hljs-meta">debug> </span><span class="language-bash">next</span>
 &#x3C; world
-break in myscript.js:5
-  3   debugger;
-  4   console.log('world');
-<span class="hljs-meta">></span><span class="bash"> 5 }, 1000);</span>
-  6 console.log('hello');
-  7
-<span class="hljs-meta">debug></span><span class="bash"> .<span class="hljs-built_in">exit</span></span></code></pre>
+&#x3C;
+break in myscript.js:6
+  4   debugger;
+  5   console.log('world');
+<span class="hljs-meta">> </span><span class="language-bash">6 }, 1000);</span>
+  7 console.log('hello');
+  8
+<span class="hljs-meta">debug> </span><span class="language-bash">.<span class="hljs-built_in">exit</span></span>
+<span class="hljs-meta">$</span></code></pre>
 <p>The <code>repl</code> command allows code to be evaluated remotely. The <code>next</code> command
 steps to the next line. Type <code>help</code> to see what other commands are available.</p>
 <p>Pressing <code>enter</code> without typing a command will repeat the previous debugger
 command.</p>
-<h2>Watchers<span><a class="mark" href="#debugger_watchers" id="debugger_watchers">#</a></span></h2>
+<section><h3>Watchers<span><a class="mark" href="#debugger_watchers" id="debugger_watchers">#</a></span></h3>
 <p>It is possible to watch expression and variable values while debugging. On
 every breakpoint, each expression from the watchers list will be evaluated
 in the current context and displayed immediately before the breakpoint's
@@ -22529,8 +23496,8 @@ source code listing.</p>
 <p>To begin watching an expression, type <code>watch('my_expression')</code>. The command
 <code>watchers</code> will print the active watchers. To remove a watcher, type
 <code>unwatch('my_expression')</code>.</p>
-<h2>Command reference<span><a class="mark" href="#debugger_command_reference" id="debugger_command_reference">#</a></span></h2>
-<h3>Stepping<span><a class="mark" href="#debugger_stepping" id="debugger_stepping">#</a></span></h3>
+</section><section><h3>Command reference<span><a class="mark" href="#debugger_command_reference" id="debugger_command_reference">#</a></span></h3>
+<h4>Stepping<span><a class="mark" href="#debugger_stepping" id="debugger_stepping">#</a></span></h4>
 <ul>
 <li><code>cont</code>, <code>c</code>: Continue execution</li>
 <li><code>next</code>, <code>n</code>: Step next</li>
@@ -22538,38 +23505,76 @@ source code listing.</p>
 <li><code>out</code>, <code>o</code>: Step out</li>
 <li><code>pause</code>: Pause running code (like pause button in Developer Tools)</li>
 </ul>
-<h3>Breakpoints<span><a class="mark" href="#debugger_breakpoints" id="debugger_breakpoints">#</a></span></h3>
+<h4>Breakpoints<span><a class="mark" href="#debugger_breakpoints" id="debugger_breakpoints">#</a></span></h4>
 <ul>
 <li><code>setBreakpoint()</code>, <code>sb()</code>: Set breakpoint on current line</li>
 <li><code>setBreakpoint(line)</code>, <code>sb(line)</code>: Set breakpoint on specific line</li>
 <li><code>setBreakpoint('fn()')</code>, <code>sb(...)</code>: Set breakpoint on a first statement in
-functions body</li>
+function's body</li>
 <li><code>setBreakpoint('script.js', 1)</code>, <code>sb(...)</code>: Set breakpoint on first line of
 <code>script.js</code></li>
+<li><code>setBreakpoint('script.js', 1, 'num &#x3C; 4')</code>, <code>sb(...)</code>: Set conditional
+breakpoint on first line of <code>script.js</code> that only breaks when <code>num &#x3C; 4</code>
+evaluates to <code>true</code></li>
 <li><code>clearBreakpoint('script.js', 1)</code>, <code>cb(...)</code>: Clear breakpoint in <code>script.js</code>
 on line 1</li>
 </ul>
 <p>It is also possible to set a breakpoint in a file (module) that
 is not loaded yet:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node inspect main.js</span>
-&#x3C; Debugger listening on ws://127.0.0.1:9229/4e3db158-9791-4274-8909-914f7facf3bd
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node inspect main.js</span>
+&#x3C; Debugger listening on ws://127.0.0.1:9229/48a5b28a-550c-471b-b5e1-d13dd7165df9
 &#x3C; For help, see: https://nodejs.org/en/docs/inspector
+&#x3C;
 &#x3C; Debugger attached.
+&#x3C;
+ ok
 Break on start in main.js:1
-<span class="hljs-meta">></span><span class="bash"> 1 (<span class="hljs-keyword">function</span> (exports, require, module, __filename, __dirname) { const mod = require(<span class="hljs-string">'./mod.js'</span>);</span>
+<span class="hljs-meta">> </span><span class="language-bash">1 const mod = require(<span class="hljs-string">'./mod.js'</span>);</span>
   2 mod.hello();
   3 mod.hello();
-<span class="hljs-meta">debug></span><span class="bash"> setBreakpoint(<span class="hljs-string">'mod.js'</span>, 22)</span>
+<span class="hljs-meta">debug> </span><span class="language-bash">setBreakpoint(<span class="hljs-string">'mod.js'</span>, 22)</span>
 Warning: script 'mod.js' was not loaded yet.
-<span class="hljs-meta">debug></span><span class="bash"> c</span>
+<span class="hljs-meta">debug> </span><span class="language-bash">c</span>
 break in mod.js:22
  20 // USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
-<span class="hljs-meta">></span><span class="bash">22 exports.hello = <span class="hljs-function"><span class="hljs-title">function</span></span>() {</span>
+<span class="hljs-meta">></span><span class="language-bash">22 exports.hello = <span class="hljs-function"><span class="hljs-title">function</span></span>() {</span>
  23   return 'hello from module';
  24 };
 <span class="hljs-meta">debug></span></code></pre>
-<h3>Information<span><a class="mark" href="#debugger_information" id="debugger_information">#</a></span></h3>
+<p>It is also possible to set a conditional breakpoint that only breaks when a
+given expression evaluates to <code>true</code>:</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node inspect main.js</span>
+&#x3C; Debugger listening on ws://127.0.0.1:9229/ce24daa8-3816-44d4-b8ab-8273c8a66d35
+&#x3C; For help, see: https://nodejs.org/en/docs/inspector
+&#x3C; Debugger attached.
+Break on start in main.js:7
+  5 }
+  6
+<span class="hljs-meta">> </span><span class="language-bash">7 addOne(10);</span>
+  8 addOne(-1);
+  9
+<span class="hljs-meta">debug> </span><span class="language-bash">setBreakpoint(<span class="hljs-string">'main.js'</span>, 4, <span class="hljs-string">'num &#x3C; 0'</span>)</span>
+  1 'use strict';
+  2
+  3 function addOne(num) {
+<span class="hljs-meta">> </span><span class="language-bash">4   <span class="hljs-built_in">return</span> num + 1;</span>
+  5 }
+  6
+  7 addOne(10);
+  8 addOne(-1);
+  9
+<span class="hljs-meta">debug> </span><span class="language-bash">cont</span>
+break in main.js:4
+  2
+  3 function addOne(num) {
+<span class="hljs-meta">> </span><span class="language-bash">4   <span class="hljs-built_in">return</span> num + 1;</span>
+  5 }
+  6
+<span class="hljs-meta">debug> </span><span class="language-bash"><span class="hljs-built_in">exec</span>(<span class="hljs-string">'num'</span>)</span>
+-1
+<span class="hljs-meta">debug></span></code></pre>
+<h4>Information<span><a class="mark" href="#debugger_information" id="debugger_information">#</a></span></h4>
 <ul>
 <li><code>backtrace</code>, <code>bt</code>: Print backtrace of current execution frame</li>
 <li><code>list(5)</code>: List scripts source code with 5 line context (5 lines before and
@@ -22581,19 +23586,19 @@ breakpoint)</li>
 <li><code>repl</code>: Open debugger's repl for evaluation in debugging script's context</li>
 <li><code>exec expr</code>: Execute an expression in debugging script's context</li>
 </ul>
-<h3>Execution control<span><a class="mark" href="#debugger_execution_control" id="debugger_execution_control">#</a></span></h3>
+<h4>Execution control<span><a class="mark" href="#debugger_execution_control" id="debugger_execution_control">#</a></span></h4>
 <ul>
 <li><code>run</code>: Run script (automatically runs on debugger's start)</li>
 <li><code>restart</code>: Restart script</li>
 <li><code>kill</code>: Kill script</li>
 </ul>
-<h3>Various<span><a class="mark" href="#debugger_various" id="debugger_various">#</a></span></h3>
+<h4>Various<span><a class="mark" href="#debugger_various" id="debugger_various">#</a></span></h4>
 <ul>
 <li><code>scripts</code>: List all loaded scripts</li>
 <li><code>version</code>: Display V8's version</li>
 </ul>
-<h2>Advanced usage<span><a class="mark" href="#debugger_advanced_usage" id="debugger_advanced_usage">#</a></span></h2>
-<h3>V8 inspector integration for Node.js<span><a class="mark" href="#debugger_v8_inspector_integration_for_node_js" id="debugger_v8_inspector_integration_for_node_js">#</a></span></h3>
+</section><section><h3>Advanced usage<span><a class="mark" href="#debugger_advanced_usage" id="debugger_advanced_usage">#</a></span></h3>
+<h4>V8 inspector integration for Node.js<span><a class="mark" href="#debugger_v8_inspector_integration_for_node_js" id="debugger_v8_inspector_integration_for_node_js">#</a></span></h4>
 <p>V8 Inspector integration allows attaching Chrome DevTools to Node.js
 instances for debugging and profiling. It uses the
 <a href="https://chromedevtools.github.io/devtools-protocol/">Chrome DevTools Protocol</a>.</p>
@@ -22602,7 +23607,7 @@ Node.js application. It is also possible to supply a custom port with that flag,
 e.g. <code>--inspect=9222</code> will accept DevTools connections on port 9222.</p>
 <p>To break on the first line of the application code, pass the <code>--inspect-brk</code>
 flag instead of <code>--inspect</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --inspect index.js</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --inspect index.js</span>
 Debugger listening on ws://127.0.0.1:9229/dc9010dd-f8b8-4ac5-a510-c1a114ec7d29
 For help, see: https://nodejs.org/en/docs/inspector</code></pre>
 <p>(In the example above, the UUID dc9010dd-f8b8-4ac5-a510-c1a114ec7d29
@@ -22611,17 +23616,18 @@ debugging sessions.)</p>
 <p>If the Chrome browser is older than 66.0.3345.0,
 use <code>inspector.html</code> instead of <code>js_app.html</code> in the above URL.</p>
 <p>Chrome DevTools doesn't support debugging <a href="worker_threads.html">worker threads</a> yet.
-<a href="https://github.com/GoogleChromeLabs/ndb/">ndb</a> can be used to debug them.</p>
-<h1>Deprecated APIs<span><a class="mark" href="#deprecations_deprecated_apis" id="deprecations_deprecated_apis">#</a></span></h1>
+<a href="https://github.com/GoogleChromeLabs/ndb/">ndb</a> can be used to debug them.</p></section>
+        </section>
+<section><h2>Deprecated APIs<span><a class="mark" href="#deprecations_deprecated_apis" id="deprecations_deprecated_apis">#</a></span></h2>
 
 
-<p>Node.js may deprecate APIs for any of the following reasons:</p>
+<p>Node.js APIs might be deprecated for any of the following reasons:</p>
 <ul>
 <li>Use of the API is unsafe.</li>
 <li>An improved alternative API is available.</li>
 <li>Breaking changes to the API are expected in a future major release.</li>
 </ul>
-<p>Node.js utilizes three kinds of Deprecations:</p>
+<p>Node.js uses three kinds of Deprecations:</p>
 <ul>
 <li>Documentation-only</li>
 <li>Runtime</li>
@@ -22641,29 +23647,29 @@ be printed to <code>stderr</code> the first time the deprecated API is used. Whe
 cause an error to be thrown.</p>
 <p>An End-of-Life deprecation is used when functionality is or will soon be removed
 from Node.js.</p>
-<h2>Revoking deprecations<span><a class="mark" href="#deprecations_revoking_deprecations" id="deprecations_revoking_deprecations">#</a></span></h2>
-<p>Occasionally, the deprecation of an API may be reversed. In such situations,
+<section><h3>Revoking deprecations<span><a class="mark" href="#deprecations_revoking_deprecations" id="deprecations_revoking_deprecations">#</a></span></h3>
+<p>Occasionally, the deprecation of an API might be reversed. In such situations,
 this document will be updated with information relevant to the decision.
 However, the deprecation identifier will not be modified.</p>
-<h2>List of deprecated APIs<span><a class="mark" href="#deprecations_list_of_deprecated_apis" id="deprecations_list_of_deprecated_apis">#</a></span></h2>
-<p><a id="DEP0001"></a></p>
-<h3>DEP0001: <code>http.OutgoingMessage.prototype.flush</code><span><a class="mark" href="#deprecations_dep0001_http_outgoingmessage_prototype_flush" id="deprecations_dep0001_http_outgoingmessage_prototype_flush">#</a></span></h3>
+</section><section><h3>List of deprecated APIs<span><a class="mark" href="#deprecations_list_of_deprecated_apis" id="deprecations_list_of_deprecated_apis">#</a></span></h3>
+<h4 id="DEP0001">DEP0001: <code>http.OutgoingMessage.prototype.flush</code><span><a class="mark" href="#deprecations_dep0001_http_outgoingmessage_prototype_flush" id="deprecations_dep0001_http_outgoingmessage_prototype_flush">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.6.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
-<p>The <code>OutgoingMessage.prototype.flush()</code> method is deprecated. Use
+<p>Type: End-of-Life</p>
+<p><code>OutgoingMessage.prototype.flush()</code> has been removed. Use
 <code>OutgoingMessage.prototype.flushHeaders()</code> instead.</p>
-<p><a id="DEP0002"></a></p>
-<h3>DEP0002: <code>require('_linklist')</code><span><a class="mark" href="#deprecations_dep0002_require_linklist" id="deprecations_dep0002_require_linklist">#</a></span></h3>
+<h4 id="DEP0002">DEP0002: <code>require('_linklist')</code><span><a class="mark" href="#deprecations_dep0002_require_linklist" id="deprecations_dep0002_require_linklist">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22679,41 +23685,40 @@ However, the deprecation identifier will not be modified.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p>The <code>_linklist</code> module is deprecated. Please use a userland alternative.</p>
-<p><a id="DEP0003"></a></p>
-<h3>DEP0003: <code>_writableState.buffer</code><span><a class="mark" href="#deprecations_dep0003_writablestate_buffer" id="deprecations_dep0003_writablestate_buffer">#</a></span></h3>
+<h4 id="DEP0003">DEP0003: <code>_writableState.buffer</code><span><a class="mark" href="#deprecations_dep0003_writablestate_buffer" id="deprecations_dep0003_writablestate_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.15</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
-<p>The <code>_writableState.buffer</code> property is deprecated. Use the
-<code>_writableState.getBuffer()</code> method instead.</p>
-<p><a id="DEP0004"></a></p>
-<h3>DEP0004: <code>CryptoStream.prototype.readyState</code><span><a class="mark" href="#deprecations_dep0004_cryptostream_prototype_readystate" id="deprecations_dep0004_cryptostream_prototype_readystate">#</a></span></h3>
+<p>Type: End-of-Life</p>
+<p>The <code>_writableState.buffer</code> has been removed. Use <code>_writableState.getBuffer()</code>
+instead.</p>
+<h4 id="DEP0004">DEP0004: <code>CryptoStream.prototype.readyState</code><span><a class="mark" href="#deprecations_dep0004_cryptostream_prototype_readystate" id="deprecations_dep0004_cryptostream_prototype_readystate">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>0.4.0</td>
+<tr><td>v0.4.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: End-of-Life</p>
 <p>The <code>CryptoStream.prototype.readyState</code> property was removed.</p>
-<p><a id="DEP0005"></a></p>
-<h3>DEP0005: <code>Buffer()</code> constructor<span><a class="mark" href="#deprecations_dep0005_buffer_constructor" id="deprecations_dep0005_buffer_constructor">#</a></span></h3>
+<h4 id="DEP0005">DEP0005: <code>Buffer()</code> constructor<span><a class="mark" href="#deprecations_dep0005_buffer_constructor" id="deprecations_dep0005_buffer_constructor">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22750,19 +23755,18 @@ that copies <code>string</code>.</li>
 <code>node_modules</code>. This means there will not be deprecation warnings for
 <code>Buffer()</code> usage in dependencies. With <code>--pending-deprecation</code>, a runtime
 warning results no matter where the <code>Buffer()</code> usage occurs.</p>
-<p><a id="DEP0006"></a></p>
-<h3>DEP0006: <code>child_process</code> <code>options.customFds</code><span><a class="mark" href="#deprecations_dep0006_child_process_options_customfds" id="deprecations_dep0006_child_process_options_customfds">#</a></span></h3>
+<h4 id="DEP0006">DEP0006: <code>child_process</code> <code>options.customFds</code><span><a class="mark" href="#deprecations_dep0006_child_process_options_customfds" id="deprecations_dep0006_child_process_options_customfds">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.14</td>
 <td><p>Runtime deprecation.</p></td></tr>
-<tr><td>v0.5.11</td>
+<tr><td>v0.5.10</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -22771,8 +23775,7 @@ warning results no matter where the <code>Buffer()</code> usage occurs.</p>
 <p>Within the <a href="child_process.html"><code>child_process</code></a> module's <code>spawn()</code>, <code>fork()</code>, and <code>exec()</code>
 methods, the <code>options.customFds</code> option is deprecated. The <code>options.stdio</code>
 option should be used instead.</p>
-<p><a id="DEP0007"></a></p>
-<h3>DEP0007: Replace <code>cluster</code> <code>worker.suicide</code> with <code>worker.exitedAfterDisconnect</code><span><a class="mark" href="#deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect" id="deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect">#</a></span></h3>
+<h4 id="DEP0007">DEP0007: Replace <code>cluster</code> <code>worker.suicide</code> with <code>worker.exitedAfterDisconnect</code><span><a class="mark" href="#deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect" id="deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22795,8 +23798,7 @@ provide an indication of how and why the <code>Worker</code> instance exited. In
 6.0.0, the old property was deprecated and replaced with a new
 <a href="#cluster_worker_exitedafterdisconnect"><code>worker.exitedAfterDisconnect</code></a> property. The old property name did not
 precisely describe the actual semantics and was unnecessarily emotion-laden.</p>
-<p><a id="DEP0008"></a></p>
-<h3>DEP0008: <code>require('constants')</code><span><a class="mark" href="#deprecations_dep0008_require_constants" id="deprecations_dep0008_require_constants">#</a></span></h3>
+<h4 id="DEP0008">DEP0008: <code>require('constants')</code><span><a class="mark" href="#deprecations_dep0008_require_constants" id="deprecations_dep0008_require_constants">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22813,12 +23815,13 @@ precisely describe the actual semantics and was unnecessarily emotion-laden.</p>
 relevant to specific Node.js builtin modules, developers should instead refer
 to the <code>constants</code> property exposed by the relevant module. For instance,
 <code>require('fs').constants</code> and <code>require('os').constants</code>.</p>
-<p><a id="DEP0009"></a></p>
-<h3>DEP0009: <code>crypto.pbkdf2</code> without digest<span><a class="mark" href="#deprecations_dep0009_crypto_pbkdf2_without_digest" id="deprecations_dep0009_crypto_pbkdf2_without_digest">#</a></span></h3>
+<h4 id="DEP0009">DEP0009: <code>crypto.pbkdf2</code> without digest<span><a class="mark" href="#deprecations_dep0009_crypto_pbkdf2_without_digest" id="deprecations_dep0009_crypto_pbkdf2_without_digest">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life (for <code>digest === null</code>).</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>Runtime deprecation (for <code>digest === null</code>).</p></td></tr>
 <tr><td>v8.0.0</td>
@@ -22830,24 +23833,24 @@ to the <code>constants</code> property exposed by the relevant module. For insta
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
+<p>Type: End-of-Life</p>
 <p>Use of the <a href="#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback"><code>crypto.pbkdf2()</code></a> API without specifying a digest was deprecated
 in Node.js 6.0 because the method defaulted to using the non-recommended
 <code>'SHA1'</code> digest. Previously, a deprecation warning was printed. Starting in
 Node.js 8.0.0, calling <code>crypto.pbkdf2()</code> or <code>crypto.pbkdf2Sync()</code> with
 <code>digest</code> set to <code>undefined</code> will throw a <code>TypeError</code>.</p>
 <p>Beginning in Node.js v11.0.0, calling these functions with <code>digest</code> set to
-<code>null</code> will print a deprecation warning to align with the behavior when <code>digest</code>
+<code>null</code> would print a deprecation warning to align with the behavior when <code>digest</code>
 is <code>undefined</code>.</p>
-<p><a id="DEP0010"></a></p>
-<h3>DEP0010: <code>crypto.createCredentials</code><span><a class="mark" href="#deprecations_dep0010_crypto_createcredentials" id="deprecations_dep0010_crypto_createcredentials">#</a></span></h3>
+<p>Now, however, passing either <code>undefined</code> or <code>null</code> will throw a <code>TypeError</code>.</p>
+<h4 id="DEP0010">DEP0010: <code>crypto.createCredentials</code><span><a class="mark" href="#deprecations_dep0010_crypto_createcredentials" id="deprecations_dep0010_crypto_createcredentials">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v11.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.13</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -22857,15 +23860,14 @@ is <code>undefined</code>.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>crypto.createCredentials()</code> API was removed. Please use
 <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a> instead.</p>
-<p><a id="DEP0011"></a></p>
-<h3>DEP0011: <code>crypto.Credentials</code><span><a class="mark" href="#deprecations_dep0011_crypto_credentials" id="deprecations_dep0011_crypto_credentials">#</a></span></h3>
+<h4 id="DEP0011">DEP0011: <code>crypto.Credentials</code><span><a class="mark" href="#deprecations_dep0011_crypto_credentials" id="deprecations_dep0011_crypto_credentials">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v11.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.13</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -22875,15 +23877,14 @@ is <code>undefined</code>.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>crypto.Credentials</code> class was removed. Please use <a href="#tls_tls_createsecurecontext_options"><code>tls.SecureContext</code></a>
 instead.</p>
-<p><a id="DEP0012"></a></p>
-<h3>DEP0012: <code>Domain.dispose</code><span><a class="mark" href="#deprecations_dep0012_domain_dispose" id="deprecations_dep0012_domain_dispose">#</a></span></h3>
+<h4 id="DEP0012">DEP0012: <code>Domain.dispose</code><span><a class="mark" href="#deprecations_dep0012_domain_dispose" id="deprecations_dep0012_domain_dispose">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v9.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.7</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -22893,8 +23894,7 @@ instead.</p>
 <p>Type: End-of-Life</p>
 <p><code>Domain.dispose()</code> has been removed. Recover from failed I/O actions
 explicitly via error event handlers set on the domain instead.</p>
-<p><a id="DEP0013"></a></p>
-<h3>DEP0013: <code>fs</code> asynchronous function without callback<span><a class="mark" href="#deprecations_dep0013_fs_asynchronous_function_without_callback" id="deprecations_dep0013_fs_asynchronous_function_without_callback">#</a></span></h3>
+<h4 id="DEP0013">DEP0013: <code>fs</code> asynchronous function without callback<span><a class="mark" href="#deprecations_dep0013_fs_asynchronous_function_without_callback" id="deprecations_dep0013_fs_asynchronous_function_without_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22909,8 +23909,7 @@ explicitly via error event handlers set on the domain instead.</p>
 <p>Type: End-of-Life</p>
 <p>Calling an asynchronous function without a callback throws a <code>TypeError</code>
 in Node.js 10.0.0 onwards. See <a href="https://github.com/nodejs/node/pull/12562">https://github.com/nodejs/node/pull/12562</a>.</p>
-<p><a id="DEP0014"></a></p>
-<h3>DEP0014: <code>fs.read</code> legacy String interface<span><a class="mark" href="#deprecations_dep0014_fs_read_legacy_string_interface" id="deprecations_dep0014_fs_read_legacy_string_interface">#</a></span></h3>
+<h4 id="DEP0014">DEP0014: <code>fs.read</code> legacy String interface<span><a class="mark" href="#deprecations_dep0014_fs_read_legacy_string_interface" id="deprecations_dep0014_fs_read_legacy_string_interface">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22919,7 +23918,7 @@ in Node.js 10.0.0 onwards. See <a href="https://github.com/nodejs/node/pull/1256
 <td><p>End-of-Life.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.1.96</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -22929,8 +23928,7 @@ in Node.js 10.0.0 onwards. See <a href="https://github.com/nodejs/node/pull/1256
 <p>Type: End-of-Life</p>
 <p>The <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a> legacy <code>String</code> interface is deprecated. Use the <code>Buffer</code>
 API as mentioned in the documentation instead.</p>
-<p><a id="DEP0015"></a></p>
-<h3>DEP0015: <code>fs.readSync</code> legacy String interface<span><a class="mark" href="#deprecations_dep0015_fs_readsync_legacy_string_interface" id="deprecations_dep0015_fs_readsync_legacy_string_interface">#</a></span></h3>
+<h4 id="DEP0015">DEP0015: <code>fs.readSync</code> legacy String interface<span><a class="mark" href="#deprecations_dep0015_fs_readsync_legacy_string_interface" id="deprecations_dep0015_fs_readsync_legacy_string_interface">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22939,7 +23937,7 @@ API as mentioned in the documentation instead.</p>
 <td><p>End-of-Life.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.1.96</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -22949,12 +23947,13 @@ API as mentioned in the documentation instead.</p>
 <p>Type: End-of-Life</p>
 <p>The <a href="#fs_fs_readsync_fd_buffer_offset_length_position"><code>fs.readSync()</code></a> legacy <code>String</code> interface is deprecated. Use the
 <code>Buffer</code> API as mentioned in the documentation instead.</p>
-<p><a id="DEP0016"></a></p>
-<h3>DEP0016: <code>GLOBAL</code>/<code>root</code><span><a class="mark" href="#deprecations_dep0016_global_root" id="deprecations_dep0016_global_root">#</a></span></h3>
+<h4 id="DEP0016">DEP0016: <code>GLOBAL</code>/<code>root</code><span><a class="mark" href="#deprecations_dep0016_global_root" id="deprecations_dep0016_global_root">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
 <tr><td>v6.12.0</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v6.0.0</td>
@@ -22962,11 +23961,10 @@ API as mentioned in the documentation instead.</p>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
-<p>The <code>GLOBAL</code> and <code>root</code> aliases for the <code>global</code> property are deprecated
-and should no longer be used.</p>
-<p><a id="DEP0017"></a></p>
-<h3>DEP0017: <code>Intl.v8BreakIterator</code><span><a class="mark" href="#deprecations_dep0017_intl_v8breakiterator" id="deprecations_dep0017_intl_v8breakiterator">#</a></span></h3>
+<p>Type: End-of-Life</p>
+<p>The <code>GLOBAL</code> and <code>root</code> aliases for the <code>global</code> property were deprecated
+in Node.js 6.0.0 and have since been removed.</p>
+<h4 id="DEP0017">DEP0017: <code>Intl.v8BreakIterator</code><span><a class="mark" href="#deprecations_dep0017_intl_v8breakiterator" id="deprecations_dep0017_intl_v8breakiterator">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22981,8 +23979,7 @@ and should no longer be used.</p>
 <p>Type: End-of-Life</p>
 <p><code>Intl.v8BreakIterator</code> was a non-standard extension and has been removed.
 See <a href="https://github.com/tc39/proposal-intl-segmenter"><code>Intl.Segmenter</code></a>.</p>
-<p><a id="DEP0018"></a></p>
-<h3>DEP0018: Unhandled promise rejections<span><a class="mark" href="#deprecations_dep0018_unhandled_promise_rejections" id="deprecations_dep0018_unhandled_promise_rejections">#</a></span></h3>
+<h4 id="DEP0018">DEP0018: Unhandled promise rejections<span><a class="mark" href="#deprecations_dep0018_unhandled_promise_rejections" id="deprecations_dep0018_unhandled_promise_rejections">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -22996,15 +23993,14 @@ See <a href="https://github.com/tc39/proposal-intl-segmenter"><code>Intl.Segment
 <p>Unhandled promise rejections are deprecated. In the future, promise rejections
 that are not handled will terminate the Node.js process with a non-zero exit
 code.</p>
-<p><a id="DEP0019"></a></p>
-<h3>DEP0019: <code>require('.')</code> resolved outside directory<span><a class="mark" href="#deprecations_dep0019_require_resolved_outside_directory" id="deprecations_dep0019_require_resolved_outside_directory">#</a></span></h3>
+<h4 id="DEP0019">DEP0019: <code>require('.')</code> resolved outside directory<span><a class="mark" href="#deprecations_dep0019_require_resolved_outside_directory" id="deprecations_dep0019_require_resolved_outside_directory">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>Removed functionality.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.8.1</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23014,13 +24010,12 @@ code.</p>
 <p>Type: End-of-Life</p>
 <p>In certain cases, <code>require('.')</code> could resolve outside the package directory.
 This behavior has been removed.</p>
-<p><a id="DEP0020"></a></p>
-<h3>DEP0020: <code>Server.connections</code><span><a class="mark" href="#deprecations_dep0020_server_connections" id="deprecations_dep0020_server_connections">#</a></span></h3>
+<h4 id="DEP0020">DEP0020: <code>Server.connections</code><span><a class="mark" href="#deprecations_dep0020_server_connections" id="deprecations_dep0020_server_connections">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.9.7</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23030,15 +24025,14 @@ This behavior has been removed.</p>
 <p>Type: Runtime</p>
 <p>The <a href="#net_server_connections"><code>Server.connections</code></a> property is deprecated. Please use the
 <a href="#net_server_getconnections_callback"><code>Server.getConnections()</code></a> method instead.</p>
-<p><a id="DEP0021"></a></p>
-<h3>DEP0021: <code>Server.listenFD</code><span><a class="mark" href="#deprecations_dep0021_server_listenfd" id="deprecations_dep0021_server_listenfd">#</a></span></h3>
+<h4 id="DEP0021">DEP0021: <code>Server.listenFD</code><span><a class="mark" href="#deprecations_dep0021_server_listenfd" id="deprecations_dep0021_server_listenfd">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.7.12</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23048,28 +24042,29 @@ This behavior has been removed.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>Server.listenFD()</code> method was deprecated and removed. Please use
 <a href="#net_server_listen_handle_backlog_callback"><code>Server.listen({fd: &#x3C;number>})</code></a> instead.</p>
-<p><a id="DEP0022"></a></p>
-<h3>DEP0022: <code>os.tmpDir()</code><span><a class="mark" href="#deprecations_dep0022_os_tmpdir" id="deprecations_dep0022_os_tmpdir">#</a></span></h3>
+<h4 id="DEP0022">DEP0022: <code>os.tmpDir()</code><span><a class="mark" href="#deprecations_dep0022_os_tmpdir" id="deprecations_dep0022_os_tmpdir">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
-<p>The <code>os.tmpDir()</code> API is deprecated. Please use <a href="#os_os_tmpdir"><code>os.tmpdir()</code></a> instead.</p>
-<p><a id="DEP0023"></a></p>
-<h3>DEP0023: <code>os.getNetworkInterfaces()</code><span><a class="mark" href="#deprecations_dep0023_os_getnetworkinterfaces" id="deprecations_dep0023_os_getnetworkinterfaces">#</a></span></h3>
+<p>Type: End-of-Life</p>
+<p>The <code>os.tmpDir()</code> API was deprecated in Node.js 7.0.0 and has since been
+removed. Please use <a href="#os_os_tmpdir"><code>os.tmpdir()</code></a> instead.</p>
+<h4 id="DEP0023">DEP0023: <code>os.getNetworkInterfaces()</code><span><a class="mark" href="#deprecations_dep0023_os_getnetworkinterfaces" id="deprecations_dep0023_os_getnetworkinterfaces">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.6.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23079,8 +24074,7 @@ This behavior has been removed.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>os.getNetworkInterfaces()</code> method is deprecated. Please use the
 <a href="#os_os_networkinterfaces"><code>os.networkInterfaces()</code></a> method instead.</p>
-<p><a id="DEP0024"></a></p>
-<h3>DEP0024: <code>REPLServer.prototype.convertToContext()</code><span><a class="mark" href="#deprecations_dep0024_replserver_prototype_converttocontext" id="deprecations_dep0024_replserver_prototype_converttocontext">#</a></span></h3>
+<h4 id="DEP0024">DEP0024: <code>REPLServer.prototype.convertToContext()</code><span><a class="mark" href="#deprecations_dep0024_replserver_prototype_converttocontext" id="deprecations_dep0024_replserver_prototype_converttocontext">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23094,13 +24088,12 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p>The <code>REPLServer.prototype.convertToContext()</code> API has been removed.</p>
-<p><a id="DEP0025"></a></p>
-<h3>DEP0025: <code>require('sys')</code><span><a class="mark" href="#deprecations_dep0025_require_sys" id="deprecations_dep0025_require_sys">#</a></span></h3>
+<h4 id="DEP0025">DEP0025: <code>require('sys')</code><span><a class="mark" href="#deprecations_dep0025_require_sys" id="deprecations_dep0025_require_sys">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.0.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23109,15 +24102,14 @@ This behavior has been removed.</p>
 </div>
 <p>Type: Runtime</p>
 <p>The <code>sys</code> module is deprecated. Please use the <a href="util.html"><code>util</code></a> module instead.</p>
-<p><a id="DEP0026"></a></p>
-<h3>DEP0026: <code>util.print()</code><span><a class="mark" href="#deprecations_dep0026_util_print" id="deprecations_dep0026_util_print">#</a></span></h3>
+<h4 id="DEP0026">DEP0026: <code>util.print()</code><span><a class="mark" href="#deprecations_dep0026_util_print" id="deprecations_dep0026_util_print">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23126,15 +24118,14 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p><code>util.print()</code> has been removed. Please use <a href="#console_console_log_data_args"><code>console.log()</code></a> instead.</p>
-<p><a id="DEP0027"></a></p>
-<h3>DEP0027: <code>util.puts()</code><span><a class="mark" href="#deprecations_dep0027_util_puts" id="deprecations_dep0027_util_puts">#</a></span></h3>
+<h4 id="DEP0027">DEP0027: <code>util.puts()</code><span><a class="mark" href="#deprecations_dep0027_util_puts" id="deprecations_dep0027_util_puts">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23143,15 +24134,14 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p><code>util.puts()</code> has been removed. Please use <a href="#console_console_log_data_args"><code>console.log()</code></a> instead.</p>
-<p><a id="DEP0028"></a></p>
-<h3>DEP0028: <code>util.debug()</code><span><a class="mark" href="#deprecations_dep0028_util_debug" id="deprecations_dep0028_util_debug">#</a></span></h3>
+<h4 id="DEP0028">DEP0028: <code>util.debug()</code><span><a class="mark" href="#deprecations_dep0028_util_debug" id="deprecations_dep0028_util_debug">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23160,15 +24150,14 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p><code>util.debug()</code> has been removed. Please use <a href="#console_console_error_data_args"><code>console.error()</code></a> instead.</p>
-<p><a id="DEP0029"></a></p>
-<h3>DEP0029: <code>util.error()</code><span><a class="mark" href="#deprecations_dep0029_util_error" id="deprecations_dep0029_util_error">#</a></span></h3>
+<h4 id="DEP0029">DEP0029: <code>util.error()</code><span><a class="mark" href="#deprecations_dep0029_util_error" id="deprecations_dep0029_util_error">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -23177,8 +24166,7 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p><code>util.error()</code> has been removed. Please use <a href="#console_console_error_data_args"><code>console.error()</code></a> instead.</p>
-<p><a id="DEP0030"></a></p>
-<h3>DEP0030: <code>SlowBuffer</code><span><a class="mark" href="#deprecations_dep0030_slowbuffer" id="deprecations_dep0030_slowbuffer">#</a></span></h3>
+<h4 id="DEP0030">DEP0030: <code>SlowBuffer</code><span><a class="mark" href="#deprecations_dep0030_slowbuffer" id="deprecations_dep0030_slowbuffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23193,8 +24181,7 @@ This behavior has been removed.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="#buffer_class_slowbuffer"><code>SlowBuffer</code></a> class is deprecated. Please use
 <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow(size)</code></a> instead.</p>
-<p><a id="DEP0031"></a></p>
-<h3>DEP0031: <code>ecdh.setPublicKey()</code><span><a class="mark" href="#deprecations_dep0031_ecdh_setpublickey" id="deprecations_dep0031_ecdh_setpublickey">#</a></span></h3>
+<h4 id="DEP0031">DEP0031: <code>ecdh.setPublicKey()</code><span><a class="mark" href="#deprecations_dep0031_ecdh_setpublickey" id="deprecations_dep0031_ecdh_setpublickey">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23209,13 +24196,12 @@ This behavior has been removed.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="#crypto_ecdh_setpublickey_publickey_encoding"><code>ecdh.setPublicKey()</code></a> method is now deprecated as its inclusion in the
 API is not useful.</p>
-<p><a id="DEP0032"></a></p>
-<h3>DEP0032: <code>domain</code> module<span><a class="mark" href="#deprecations_dep0032_domain_module" id="deprecations_dep0032_domain_module">#</a></span></h3>
+<h4 id="DEP0032">DEP0032: <code>domain</code> module<span><a class="mark" href="#deprecations_dep0032_domain_module" id="deprecations_dep0032_domain_module">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.4.2</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23224,13 +24210,12 @@ API is not useful.</p>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="domain.html"><code>domain</code></a> module is deprecated and should not be used.</p>
-<p><a id="DEP0033"></a></p>
-<h3>DEP0033: <code>EventEmitter.listenerCount()</code><span><a class="mark" href="#deprecations_dep0033_eventemitter_listenercount" id="deprecations_dep0033_eventemitter_listenercount">#</a></span></h3>
+<h4 id="DEP0033">DEP0033: <code>EventEmitter.listenerCount()</code><span><a class="mark" href="#deprecations_dep0033_eventemitter_listenercount" id="deprecations_dep0033_eventemitter_listenercount">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v3.2.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23238,15 +24223,14 @@ API is not useful.</p>
 </details>
 </div>
 <p>Type: Documentation-only</p>
-<p>The <a href="#events_eventemitter_listenercount_emitter_eventname"><code>EventEmitter.listenerCount(emitter, eventName)</code></a> API is
+<p>The <a href="#events_events_listenercount_emitter_eventname"><code>events.listenerCount(emitter, eventName)</code></a> API is
 deprecated. Please use <a href="#events_emitter_listenercount_eventname"><code>emitter.listenerCount(eventName)</code></a> instead.</p>
-<p><a id="DEP0034"></a></p>
-<h3>DEP0034: <code>fs.exists(path, callback)</code><span><a class="mark" href="#deprecations_dep0034_fs_exists_path_callback" id="deprecations_dep0034_fs_exists_path_callback">#</a></span></h3>
+<h4 id="DEP0034">DEP0034: <code>fs.exists(path, callback)</code><span><a class="mark" href="#deprecations_dep0034_fs_exists_path_callback" id="deprecations_dep0034_fs_exists_path_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.0.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23256,13 +24240,12 @@ deprecated. Please use <a href="#events_emitter_listenercount_eventname"><code>e
 <p>Type: Documentation-only</p>
 <p>The <a href="#fs_fs_exists_path_callback"><code>fs.exists(path, callback)</code></a> API is deprecated. Please use
 <a href="#fs_fs_stat_path_options_callback"><code>fs.stat()</code></a> or <a href="#fs_fs_access_path_mode_callback"><code>fs.access()</code></a> instead.</p>
-<p><a id="DEP0035"></a></p>
-<h3>DEP0035: <code>fs.lchmod(path, mode, callback)</code><span><a class="mark" href="#deprecations_dep0035_fs_lchmod_path_mode_callback" id="deprecations_dep0035_fs_lchmod_path_mode_callback">#</a></span></h3>
+<h4 id="DEP0035">DEP0035: <code>fs.lchmod(path, mode, callback)</code><span><a class="mark" href="#deprecations_dep0035_fs_lchmod_path_mode_callback" id="deprecations_dep0035_fs_lchmod_path_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.4.7</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23271,13 +24254,12 @@ deprecated. Please use <a href="#events_emitter_listenercount_eventname"><code>e
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#fs_fs_lchmod_path_mode_callback"><code>fs.lchmod(path, mode, callback)</code></a> API is deprecated.</p>
-<p><a id="DEP0036"></a></p>
-<h3>DEP0036: <code>fs.lchmodSync(path, mode)</code><span><a class="mark" href="#deprecations_dep0036_fs_lchmodsync_path_mode" id="deprecations_dep0036_fs_lchmodsync_path_mode">#</a></span></h3>
+<h4 id="DEP0036">DEP0036: <code>fs.lchmodSync(path, mode)</code><span><a class="mark" href="#deprecations_dep0036_fs_lchmodsync_path_mode" id="deprecations_dep0036_fs_lchmodsync_path_mode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.4.7</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23286,15 +24268,14 @@ deprecated. Please use <a href="#events_emitter_listenercount_eventname"><code>e
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#fs_fs_lchmodsync_path_mode"><code>fs.lchmodSync(path, mode)</code></a> API is deprecated.</p>
-<p><a id="DEP0037"></a></p>
-<h3>DEP0037: <code>fs.lchown(path, uid, gid, callback)</code><span><a class="mark" href="#deprecations_dep0037_fs_lchown_path_uid_gid_callback" id="deprecations_dep0037_fs_lchown_path_uid_gid_callback">#</a></span></h3>
+<h4 id="DEP0037">DEP0037: <code>fs.lchown(path, uid, gid, callback)</code><span><a class="mark" href="#deprecations_dep0037_fs_lchown_path_uid_gid_callback" id="deprecations_dep0037_fs_lchown_path_uid_gid_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.6.0</td>
 <td><p>Deprecation revoked.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.4.7</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23305,15 +24286,14 @@ deprecated. Please use <a href="#events_emitter_listenercount_eventname"><code>e
 <p>The <a href="#fs_fs_lchown_path_uid_gid_callback"><code>fs.lchown(path, uid, gid, callback)</code></a> API was deprecated. The
 deprecation was revoked because the requisite supporting APIs were added in
 libuv.</p>
-<p><a id="DEP0038"></a></p>
-<h3>DEP0038: <code>fs.lchownSync(path, uid, gid)</code><span><a class="mark" href="#deprecations_dep0038_fs_lchownsync_path_uid_gid" id="deprecations_dep0038_fs_lchownsync_path_uid_gid">#</a></span></h3>
+<h4 id="DEP0038">DEP0038: <code>fs.lchownSync(path, uid, gid)</code><span><a class="mark" href="#deprecations_dep0038_fs_lchownsync_path_uid_gid" id="deprecations_dep0038_fs_lchownsync_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.6.0</td>
 <td><p>Deprecation revoked.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.4.7</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23323,13 +24303,12 @@ libuv.</p>
 <p>Type: Deprecation revoked</p>
 <p>The <a href="#fs_fs_lchownsync_path_uid_gid"><code>fs.lchownSync(path, uid, gid)</code></a> API was deprecated. The deprecation was
 revoked because the requisite supporting APIs were added in libuv.</p>
-<p><a id="DEP0039"></a></p>
-<h3>DEP0039: <code>require.extensions</code><span><a class="mark" href="#deprecations_dep0039_require_extensions" id="deprecations_dep0039_require_extensions">#</a></span></h3>
+<h4 id="DEP0039">DEP0039: <code>require.extensions</code><span><a class="mark" href="#deprecations_dep0039_require_extensions" id="deprecations_dep0039_require_extensions">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.10.6</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23338,8 +24317,7 @@ revoked because the requisite supporting APIs were added in libuv.</p>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#modules_require_extensions"><code>require.extensions</code></a> property is deprecated.</p>
-<p><a id="DEP0040"></a></p>
-<h3>DEP0040: <code>punycode</code> module<span><a class="mark" href="#deprecations_dep0040_punycode_module" id="deprecations_dep0040_punycode_module">#</a></span></h3>
+<h4 id="DEP0040">DEP0040: <code>punycode</code> module<span><a class="mark" href="#deprecations_dep0040_punycode_module" id="deprecations_dep0040_punycode_module">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23352,15 +24330,14 @@ revoked because the requisite supporting APIs were added in libuv.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="punycode.html"><code>punycode</code></a> module is deprecated. Please use a userland alternative
 instead.</p>
-<p><a id="DEP0041"></a></p>
-<h3>DEP0041: <code>NODE_REPL_HISTORY_FILE</code> environment variable<span><a class="mark" href="#deprecations_dep0041_node_repl_history_file_environment_variable" id="deprecations_dep0041_node_repl_history_file_environment_variable">#</a></span></h3>
+<h4 id="DEP0041">DEP0041: <code>NODE_REPL_HISTORY_FILE</code> environment variable<span><a class="mark" href="#deprecations_dep0041_node_repl_history_file_environment_variable" id="deprecations_dep0041_node_repl_history_file_environment_variable">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v3.0.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23370,15 +24347,14 @@ instead.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>NODE_REPL_HISTORY_FILE</code> environment variable was removed. Please use
 <code>NODE_REPL_HISTORY</code> instead.</p>
-<p><a id="DEP0042"></a></p>
-<h3>DEP0042: <code>tls.CryptoStream</code><span><a class="mark" href="#deprecations_dep0042_tls_cryptostream" id="deprecations_dep0042_tls_cryptostream">#</a></span></h3>
+<h4 id="DEP0042">DEP0042: <code>tls.CryptoStream</code><span><a class="mark" href="#deprecations_dep0042_tls_cryptostream" id="deprecations_dep0042_tls_cryptostream">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -23388,8 +24364,7 @@ instead.</p>
 <p>Type: End-of-Life</p>
 <p>The <a href="#tls_class_tls_cryptostream"><code>tls.CryptoStream</code></a> class was removed. Please use
 <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> instead.</p>
-<p><a id="DEP0043"></a></p>
-<h3>DEP0043: <code>tls.SecurePair</code><span><a class="mark" href="#deprecations_dep0043_tls_securepair" id="deprecations_dep0043_tls_securepair">#</a></span></h3>
+<h4 id="DEP0043">DEP0043: <code>tls.SecurePair</code><span><a class="mark" href="#deprecations_dep0043_tls_securepair" id="deprecations_dep0043_tls_securepair">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23410,15 +24385,14 @@ instead.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="#tls_class_tls_securepair"><code>tls.SecurePair</code></a> class is deprecated. Please use
 <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> instead.</p>
-<p><a id="DEP0044"></a></p>
-<h3>DEP0044: <code>util.isArray()</code><span><a class="mark" href="#deprecations_dep0044_util_isarray" id="deprecations_dep0044_util_isarray">#</a></span></h3>
+<h4 id="DEP0044">DEP0044: <code>util.isArray()</code><span><a class="mark" href="#deprecations_dep0044_util_isarray" id="deprecations_dep0044_util_isarray">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -23426,30 +24400,28 @@ instead.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isarray_object"><code>util.isArray()</code></a> API is deprecated. Please use <code>Array.isArray()</code>
 instead.</p>
-<p><a id="DEP0045"></a></p>
-<h3>DEP0045: <code>util.isBoolean()</code><span><a class="mark" href="#deprecations_dep0045_util_isboolean" id="deprecations_dep0045_util_isboolean">#</a></span></h3>
+<h4 id="DEP0045">DEP0045: <code>util.isBoolean()</code><span><a class="mark" href="#deprecations_dep0045_util_isboolean" id="deprecations_dep0045_util_isboolean">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isboolean_object"><code>util.isBoolean()</code></a> API is deprecated.</p>
-<p><a id="DEP0046"></a></p>
-<h3>DEP0046: <code>util.isBuffer()</code><span><a class="mark" href="#deprecations_dep0046_util_isbuffer" id="deprecations_dep0046_util_isbuffer">#</a></span></h3>
+<h4 id="DEP0046">DEP0046: <code>util.isBuffer()</code><span><a class="mark" href="#deprecations_dep0046_util_isbuffer" id="deprecations_dep0046_util_isbuffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -23457,188 +24429,175 @@ instead.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isbuffer_object"><code>util.isBuffer()</code></a> API is deprecated. Please use
 <a href="#buffer_static_method_buffer_isbuffer_obj"><code>Buffer.isBuffer()</code></a> instead.</p>
-<p><a id="DEP0047"></a></p>
-<h3>DEP0047: <code>util.isDate()</code><span><a class="mark" href="#deprecations_dep0047_util_isdate" id="deprecations_dep0047_util_isdate">#</a></span></h3>
+<h4 id="DEP0047">DEP0047: <code>util.isDate()</code><span><a class="mark" href="#deprecations_dep0047_util_isdate" id="deprecations_dep0047_util_isdate">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isdate_object"><code>util.isDate()</code></a> API is deprecated.</p>
-<p><a id="DEP0048"></a></p>
-<h3>DEP0048: <code>util.isError()</code><span><a class="mark" href="#deprecations_dep0048_util_iserror" id="deprecations_dep0048_util_iserror">#</a></span></h3>
+<h4 id="DEP0048">DEP0048: <code>util.isError()</code><span><a class="mark" href="#deprecations_dep0048_util_iserror" id="deprecations_dep0048_util_iserror">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_iserror_object"><code>util.isError()</code></a> API is deprecated.</p>
-<p><a id="DEP0049"></a></p>
-<h3>DEP0049: <code>util.isFunction()</code><span><a class="mark" href="#deprecations_dep0049_util_isfunction" id="deprecations_dep0049_util_isfunction">#</a></span></h3>
+<h4 id="DEP0049">DEP0049: <code>util.isFunction()</code><span><a class="mark" href="#deprecations_dep0049_util_isfunction" id="deprecations_dep0049_util_isfunction">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isfunction_object"><code>util.isFunction()</code></a> API is deprecated.</p>
-<p><a id="DEP0050"></a></p>
-<h3>DEP0050: <code>util.isNull()</code><span><a class="mark" href="#deprecations_dep0050_util_isnull" id="deprecations_dep0050_util_isnull">#</a></span></h3>
+<h4 id="DEP0050">DEP0050: <code>util.isNull()</code><span><a class="mark" href="#deprecations_dep0050_util_isnull" id="deprecations_dep0050_util_isnull">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isnull_object"><code>util.isNull()</code></a> API is deprecated.</p>
-<p><a id="DEP0051"></a></p>
-<h3>DEP0051: <code>util.isNullOrUndefined()</code><span><a class="mark" href="#deprecations_dep0051_util_isnullorundefined" id="deprecations_dep0051_util_isnullorundefined">#</a></span></h3>
+<h4 id="DEP0051">DEP0051: <code>util.isNullOrUndefined()</code><span><a class="mark" href="#deprecations_dep0051_util_isnullorundefined" id="deprecations_dep0051_util_isnullorundefined">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isnullorundefined_object"><code>util.isNullOrUndefined()</code></a> API is deprecated.</p>
-<p><a id="DEP0052"></a></p>
-<h3>DEP0052: <code>util.isNumber()</code><span><a class="mark" href="#deprecations_dep0052_util_isnumber" id="deprecations_dep0052_util_isnumber">#</a></span></h3>
+<h4 id="DEP0052">DEP0052: <code>util.isNumber()</code><span><a class="mark" href="#deprecations_dep0052_util_isnumber" id="deprecations_dep0052_util_isnumber">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isnumber_object"><code>util.isNumber()</code></a> API is deprecated.</p>
-<p><a id="DEP0053"></a></p>
-<h3>DEP0053 <code>util.isObject()</code><span><a class="mark" href="#deprecations_dep0053_util_isobject" id="deprecations_dep0053_util_isobject">#</a></span></h3>
+<h4 id="DEP0053">DEP0053: <code>util.isObject()</code><span><a class="mark" href="#deprecations_dep0053_util_isobject" id="deprecations_dep0053_util_isobject">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isobject_object"><code>util.isObject()</code></a> API is deprecated.</p>
-<p><a id="DEP0054"></a></p>
-<h3>DEP0054: <code>util.isPrimitive()</code><span><a class="mark" href="#deprecations_dep0054_util_isprimitive" id="deprecations_dep0054_util_isprimitive">#</a></span></h3>
+<h4 id="DEP0054">DEP0054: <code>util.isPrimitive()</code><span><a class="mark" href="#deprecations_dep0054_util_isprimitive" id="deprecations_dep0054_util_isprimitive">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isprimitive_object"><code>util.isPrimitive()</code></a> API is deprecated.</p>
-<p><a id="DEP0055"></a></p>
-<h3>DEP0055: <code>util.isRegExp()</code><span><a class="mark" href="#deprecations_dep0055_util_isregexp" id="deprecations_dep0055_util_isregexp">#</a></span></h3>
+<h4 id="DEP0055">DEP0055: <code>util.isRegExp()</code><span><a class="mark" href="#deprecations_dep0055_util_isregexp" id="deprecations_dep0055_util_isregexp">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isregexp_object"><code>util.isRegExp()</code></a> API is deprecated.</p>
-<p><a id="DEP0056"></a></p>
-<h3>DEP0056: <code>util.isString()</code><span><a class="mark" href="#deprecations_dep0056_util_isstring" id="deprecations_dep0056_util_isstring">#</a></span></h3>
+<h4 id="DEP0056">DEP0056: <code>util.isString()</code><span><a class="mark" href="#deprecations_dep0056_util_isstring" id="deprecations_dep0056_util_isstring">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isstring_object"><code>util.isString()</code></a> API is deprecated.</p>
-<p><a id="DEP0057"></a></p>
-<h3>DEP0057: <code>util.isSymbol()</code><span><a class="mark" href="#deprecations_dep0057_util_issymbol" id="deprecations_dep0057_util_issymbol">#</a></span></h3>
+<h4 id="DEP0057">DEP0057: <code>util.isSymbol()</code><span><a class="mark" href="#deprecations_dep0057_util_issymbol" id="deprecations_dep0057_util_issymbol">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_issymbol_object"><code>util.isSymbol()</code></a> API is deprecated.</p>
-<p><a id="DEP0058"></a></p>
-<h3>DEP0058: <code>util.isUndefined()</code><span><a class="mark" href="#deprecations_dep0058_util_isundefined" id="deprecations_dep0058_util_isundefined">#</a></span></h3>
+<h4 id="DEP0058">DEP0058: <code>util.isUndefined()</code><span><a class="mark" href="#deprecations_dep0058_util_isundefined" id="deprecations_dep0058_util_isundefined">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_isundefined_object"><code>util.isUndefined()</code></a> API is deprecated.</p>
-<p><a id="DEP0059"></a></p>
-<h3>DEP0059: <code>util.log()</code><span><a class="mark" href="#deprecations_dep0059_util_log" id="deprecations_dep0059_util_log">#</a></span></h3>
+<h4 id="DEP0059">DEP0059: <code>util.log()</code><span><a class="mark" href="#deprecations_dep0059_util_log" id="deprecations_dep0059_util_log">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23652,8 +24611,7 @@ instead.</p>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_log_string"><code>util.log()</code></a> API is deprecated.</p>
-<p><a id="DEP0060"></a></p>
-<h3>DEP0060: <code>util._extend()</code><span><a class="mark" href="#deprecations_dep0060_util_extend" id="deprecations_dep0060_util_extend">#</a></span></h3>
+<h4 id="DEP0060">DEP0060: <code>util._extend()</code><span><a class="mark" href="#deprecations_dep0060_util_extend" id="deprecations_dep0060_util_extend">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23667,8 +24625,7 @@ instead.</p>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="#util_util_extend_target_source"><code>util._extend()</code></a> API is deprecated.</p>
-<p><a id="DEP0061"></a></p>
-<h3>DEP0061: <code>fs.SyncWriteStream</code><span><a class="mark" href="#deprecations_dep0061_fs_syncwritestream" id="deprecations_dep0061_fs_syncwritestream">#</a></span></h3>
+<h4 id="DEP0061">DEP0061: <code>fs.SyncWriteStream</code><span><a class="mark" href="#deprecations_dep0061_fs_syncwritestream" id="deprecations_dep0061_fs_syncwritestream">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23686,8 +24643,7 @@ instead.</p>
 <p>The <code>fs.SyncWriteStream</code> class was never intended to be a publicly accessible
 API and has been removed. No alternative API is available. Please use a userland
 alternative.</p>
-<p><a id="DEP0062"></a></p>
-<h3>DEP0062: <code>node --debug</code><span><a class="mark" href="#deprecations_dep0062_node_debug" id="deprecations_dep0062_node_debug">#</a></span></h3>
+<h4 id="DEP0062">DEP0062: <code>node --debug</code><span><a class="mark" href="#deprecations_dep0062_node_debug" id="deprecations_dep0062_node_debug">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23703,8 +24659,7 @@ alternative.</p>
 <p><code>--debug</code> activates the legacy V8 debugger interface, which was removed as
 of V8 5.8. It is replaced by Inspector which is activated with <code>--inspect</code>
 instead.</p>
-<p><a id="DEP0063"></a></p>
-<h3>DEP0063: <code>ServerResponse.prototype.writeHeader()</code><span><a class="mark" href="#deprecations_dep0063_serverresponse_prototype_writeheader" id="deprecations_dep0063_serverresponse_prototype_writeheader">#</a></span></h3>
+<h4 id="DEP0063">DEP0063: <code>ServerResponse.prototype.writeHeader()</code><span><a class="mark" href="#deprecations_dep0063_serverresponse_prototype_writeheader" id="deprecations_dep0063_serverresponse_prototype_writeheader">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23719,8 +24674,7 @@ instead.</p>
 deprecated. Please use <code>ServerResponse.prototype.writeHead()</code> instead.</p>
 <p>The <code>ServerResponse.prototype.writeHeader()</code> method was never documented as an
 officially supported API.</p>
-<p><a id="DEP0064"></a></p>
-<h3>DEP0064: <code>tls.createSecurePair()</code><span><a class="mark" href="#deprecations_dep0064_tls_createsecurepair" id="deprecations_dep0064_tls_createsecurepair">#</a></span></h3>
+<h4 id="DEP0064">DEP0064: <code>tls.createSecurePair()</code><span><a class="mark" href="#deprecations_dep0064_tls_createsecurepair" id="deprecations_dep0064_tls_createsecurepair">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23741,8 +24695,7 @@ officially supported API.</p>
 <p>Type: Runtime</p>
 <p>The <code>tls.createSecurePair()</code> API was deprecated in documentation in Node.js
 0.11.3. Users should use <code>tls.Socket</code> instead.</p>
-<p><a id="DEP0065"></a></p>
-<h3>DEP0065: <code>repl.REPL_MODE_MAGIC</code> and <code>NODE_REPL_MODE=magic</code><span><a class="mark" href="#deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic" id="deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic">#</a></span></h3>
+<h4 id="DEP0065">DEP0065: <code>repl.REPL_MODE_MAGIC</code> and <code>NODE_REPL_MODE=magic</code><span><a class="mark" href="#deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic" id="deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23762,8 +24715,7 @@ been removed. Its behavior has been functionally identical to that of
 <p>The <code>NODE_REPL_MODE</code> environment variable is used to set the underlying
 <code>replMode</code> of an interactive <code>node</code> session. Its value, <code>magic</code>, is also
 removed. Please use <code>sloppy</code> instead.</p>
-<p><a id="DEP0066"></a></p>
-<h3>DEP0066: <code>OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames</code><span><a class="mark" href="#deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames" id="deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames">#</a></span></h3>
+<h4 id="DEP0066">DEP0066: <code>OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames</code><span><a class="mark" href="#deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames" id="deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23781,14 +24733,14 @@ removed. Please use <code>sloppy</code> instead.</p>
 the public methods (e.g. <code>OutgoingMessage.prototype.getHeader()</code>,
 <code>OutgoingMessage.prototype.getHeaders()</code>,
 <code>OutgoingMessage.prototype.getHeaderNames()</code>,
+<code>OutgoingMessage.prototype.getRawHeaderNames()</code>,
 <code>OutgoingMessage.prototype.hasHeader()</code>,
 <code>OutgoingMessage.prototype.removeHeader()</code>,
 <code>OutgoingMessage.prototype.setHeader()</code>) for working with outgoing headers.</p>
 <p>The <code>OutgoingMessage.prototype._headers</code> and
 <code>OutgoingMessage.prototype._headerNames</code> properties were never documented as
 officially supported properties.</p>
-<p><a id="DEP0067"></a></p>
-<h3>DEP0067: <code>OutgoingMessage.prototype._renderHeaders</code><span><a class="mark" href="#deprecations_dep0067_outgoingmessage_prototype_renderheaders" id="deprecations_dep0067_outgoingmessage_prototype_renderheaders">#</a></span></h3>
+<h4 id="DEP0067">DEP0067: <code>OutgoingMessage.prototype._renderHeaders</code><span><a class="mark" href="#deprecations_dep0067_outgoingmessage_prototype_renderheaders" id="deprecations_dep0067_outgoingmessage_prototype_renderheaders">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23803,8 +24755,7 @@ officially supported properties.</p>
 deprecated.</p>
 <p>The <code>OutgoingMessage.prototype._renderHeaders</code> property was never documented as
 an officially supported API.</p>
-<p><a id="DEP0068"></a></p>
-<h3>DEP0068: <code>node debug</code><span><a class="mark" href="#deprecations_dep0068_node_debug" id="deprecations_dep0068_node_debug">#</a></span></h3>
+<h4 id="DEP0068">DEP0068: <code>node debug</code><span><a class="mark" href="#deprecations_dep0068_node_debug" id="deprecations_dep0068_node_debug">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23817,8 +24768,7 @@ an officially supported API.</p>
 <p>Type: Runtime</p>
 <p><code>node debug</code> corresponds to the legacy CLI debugger which has been replaced with
 a V8-inspector based CLI debugger available through <code>node inspect</code>.</p>
-<p><a id="DEP0069"></a></p>
-<h3>DEP0069: <code>vm.runInDebugContext(string)</code><span><a class="mark" href="#deprecations_dep0069_vm_runindebugcontext_string" id="deprecations_dep0069_vm_runindebugcontext_string">#</a></span></h3>
+<h4 id="DEP0069">DEP0069: <code>vm.runInDebugContext(string)</code><span><a class="mark" href="#deprecations_dep0069_vm_runindebugcontext_string" id="deprecations_dep0069_vm_runindebugcontext_string">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23835,8 +24785,7 @@ a V8-inspector based CLI debugger available through <code>node inspect</code>.</
 <p>Type: End-of-Life</p>
 <p>DebugContext has been removed in V8 and is not available in Node.js 10+.</p>
 <p>DebugContext was an experimental API.</p>
-<p><a id="DEP0070"></a></p>
-<h3>DEP0070: <code>async_hooks.currentId()</code><span><a class="mark" href="#deprecations_dep0070_async_hooks_currentid" id="deprecations_dep0070_async_hooks_currentid">#</a></span></h3>
+<h4 id="DEP0070">DEP0070: <code>async_hooks.currentId()</code><span><a class="mark" href="#deprecations_dep0070_async_hooks_currentid" id="deprecations_dep0070_async_hooks_currentid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23852,8 +24801,7 @@ a V8-inspector based CLI debugger available through <code>node inspect</code>.</
 <p><code>async_hooks.currentId()</code> was renamed to <code>async_hooks.executionAsyncId()</code> for
 clarity.</p>
 <p>This change was made while <code>async_hooks</code> was an experimental API.</p>
-<p><a id="DEP0071"></a></p>
-<h3>DEP0071: <code>async_hooks.triggerId()</code><span><a class="mark" href="#deprecations_dep0071_async_hooks_triggerid" id="deprecations_dep0071_async_hooks_triggerid">#</a></span></h3>
+<h4 id="DEP0071">DEP0071: <code>async_hooks.triggerId()</code><span><a class="mark" href="#deprecations_dep0071_async_hooks_triggerid" id="deprecations_dep0071_async_hooks_triggerid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23869,8 +24817,7 @@ clarity.</p>
 <p><code>async_hooks.triggerId()</code> was renamed to <code>async_hooks.triggerAsyncId()</code> for
 clarity.</p>
 <p>This change was made while <code>async_hooks</code> was an experimental API.</p>
-<p><a id="DEP0072"></a></p>
-<h3>DEP0072: <code>async_hooks.AsyncResource.triggerId()</code><span><a class="mark" href="#deprecations_dep0072_async_hooks_asyncresource_triggerid" id="deprecations_dep0072_async_hooks_asyncresource_triggerid">#</a></span></h3>
+<h4 id="DEP0072">DEP0072: <code>async_hooks.AsyncResource.triggerId()</code><span><a class="mark" href="#deprecations_dep0072_async_hooks_asyncresource_triggerid" id="deprecations_dep0072_async_hooks_asyncresource_triggerid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23886,8 +24833,7 @@ clarity.</p>
 <p><code>async_hooks.AsyncResource.triggerId()</code> was renamed to
 <code>async_hooks.AsyncResource.triggerAsyncId()</code> for clarity.</p>
 <p>This change was made while <code>async_hooks</code> was an experimental API.</p>
-<p><a id="DEP0073"></a></p>
-<h3>DEP0073: Several internal properties of <code>net.Server</code><span><a class="mark" href="#deprecations_dep0073_several_internal_properties_of_net_server" id="deprecations_dep0073_several_internal_properties_of_net_server">#</a></span></h3>
+<h4 id="DEP0073">DEP0073: Several internal properties of <code>net.Server</code><span><a class="mark" href="#deprecations_dep0073_several_internal_properties_of_net_server" id="deprecations_dep0073_several_internal_properties_of_net_server">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23904,8 +24850,7 @@ clarity.</p>
 with inappropriate names is deprecated.</p>
 <p>As the original API was undocumented and not generally useful for non-internal
 code, no replacement API is provided.</p>
-<p><a id="DEP0074"></a></p>
-<h3>DEP0074: <code>REPLServer.bufferedCommand</code><span><a class="mark" href="#deprecations_dep0074_replserver_bufferedcommand" id="deprecations_dep0074_replserver_bufferedcommand">#</a></span></h3>
+<h4 id="DEP0074">DEP0074: <code>REPLServer.bufferedCommand</code><span><a class="mark" href="#deprecations_dep0074_replserver_bufferedcommand" id="deprecations_dep0074_replserver_bufferedcommand">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23918,8 +24863,7 @@ code, no replacement API is provided.</p>
 <p>Type: Runtime</p>
 <p>The <code>REPLServer.bufferedCommand</code> property was deprecated in favor of
 <a href="#repl_replserver_clearbufferedcommand"><code>REPLServer.clearBufferedCommand()</code></a>.</p>
-<p><a id="DEP0075"></a></p>
-<h3>DEP0075: <code>REPLServer.parseREPLKeyword()</code><span><a class="mark" href="#deprecations_dep0075_replserver_parsereplkeyword" id="deprecations_dep0075_replserver_parsereplkeyword">#</a></span></h3>
+<h4 id="DEP0075">DEP0075: <code>REPLServer.parseREPLKeyword()</code><span><a class="mark" href="#deprecations_dep0075_replserver_parsereplkeyword" id="deprecations_dep0075_replserver_parsereplkeyword">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23931,8 +24875,7 @@ code, no replacement API is provided.</p>
 </div>
 <p>Type: Runtime</p>
 <p><code>REPLServer.parseREPLKeyword()</code> was removed from userland visibility.</p>
-<p><a id="DEP0076"></a></p>
-<h3>DEP0076: <code>tls.parseCertString()</code><span><a class="mark" href="#deprecations_dep0076_tls_parsecertstring" id="deprecations_dep0076_tls_parsecertstring">#</a></span></h3>
+<h4 id="DEP0076">DEP0076: <code>tls.parseCertString()</code><span><a class="mark" href="#deprecations_dep0076_tls_parsecertstring" id="deprecations_dep0076_tls_parsecertstring">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23948,15 +24891,14 @@ code, no replacement API is provided.</p>
 <p><code>tls.parseCertString()</code> is a trivial parsing helper that was made public by
 mistake. This function can usually be replaced with:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> querystring = <span class="hljs-built_in">require</span>(<span class="hljs-string">'querystring'</span>);
-querystring.parse(str, <span class="hljs-string">'\n'</span>, <span class="hljs-string">'='</span>);</code></pre>
+querystring.<span class="hljs-title function_">parse</span>(str, <span class="hljs-string">'\n'</span>, <span class="hljs-string">'='</span>);</code></pre>
 <p>This function is not completely equivalent to <code>querystring.parse()</code>. One
 difference is that <code>querystring.parse()</code> does url decoding:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> querystring.parse(<span class="hljs-string">'%E5%A5%BD=1'</span>, <span class="hljs-string">'\n'</span>, <span class="hljs-string">'='</span>);</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">querystring.parse(<span class="hljs-string">'%E5%A5%BD=1'</span>, <span class="hljs-string">'\n'</span>, <span class="hljs-string">'='</span>);</span>
 { '好': '1' }
-<span class="hljs-meta">></span><span class="bash"> tls.parseCertString(<span class="hljs-string">'%E5%A5%BD=1'</span>);</span>
+<span class="hljs-meta">> </span><span class="language-bash">tls.parseCertString(<span class="hljs-string">'%E5%A5%BD=1'</span>);</span>
 { '%E5%A5%BD': '1' }</code></pre>
-<p><a id="DEP0077"></a></p>
-<h3>DEP0077: <code>Module._debug()</code><span><a class="mark" href="#deprecations_dep0077_module_debug" id="deprecations_dep0077_module_debug">#</a></span></h3>
+<h4 id="DEP0077">DEP0077: <code>Module._debug()</code><span><a class="mark" href="#deprecations_dep0077_module_debug" id="deprecations_dep0077_module_debug">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23970,8 +24912,7 @@ difference is that <code>querystring.parse()</code> does url decoding:</p>
 <p><code>Module._debug()</code> is deprecated.</p>
 <p>The <code>Module._debug()</code> function was never documented as an officially
 supported API.</p>
-<p><a id="DEP0078"></a></p>
-<h3>DEP0078: <code>REPLServer.turnOffEditorMode()</code><span><a class="mark" href="#deprecations_dep0078_replserver_turnoffeditormode" id="deprecations_dep0078_replserver_turnoffeditormode">#</a></span></h3>
+<h4 id="DEP0078">DEP0078: <code>REPLServer.turnOffEditorMode()</code><span><a class="mark" href="#deprecations_dep0078_replserver_turnoffeditormode" id="deprecations_dep0078_replserver_turnoffeditormode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -23983,8 +24924,7 @@ supported API.</p>
 </div>
 <p>Type: Runtime</p>
 <p><code>REPLServer.turnOffEditorMode()</code> was removed from userland visibility.</p>
-<p><a id="DEP0079"></a></p>
-<h3>DEP0079: Custom inspection function on objects via <code>.inspect()</code><span><a class="mark" href="#deprecations_dep0079_custom_inspection_function_on_objects_via_inspect" id="deprecations_dep0079_custom_inspection_function_on_objects_via_inspect">#</a></span></h3>
+<h4 id="DEP0079">DEP0079: Custom inspection function on objects via <code>.inspect()</code><span><a class="mark" href="#deprecations_dep0079_custom_inspection_function_on_objects_via_inspect" id="deprecations_dep0079_custom_inspection_function_on_objects_via_inspect">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24002,9 +24942,8 @@ supported API.</p>
 <p>Using a property named <code>inspect</code> on an object to specify a custom inspection
 function for <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a> is deprecated. Use <a href="#util_util_inspect_custom"><code>util.inspect.custom</code></a>
 instead. For backward compatibility with Node.js prior to version 6.4.0, both
-may be specified.</p>
-<p><a id="DEP0080"></a></p>
-<h3>DEP0080: <code>path._makeLong()</code><span><a class="mark" href="#deprecations_dep0080_path_makelong" id="deprecations_dep0080_path_makelong">#</a></span></h3>
+can be specified.</p>
+<h4 id="DEP0080">DEP0080: <code>path._makeLong()</code><span><a class="mark" href="#deprecations_dep0080_path_makelong" id="deprecations_dep0080_path_makelong">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24018,8 +24957,7 @@ may be specified.</p>
 <p>The internal <code>path._makeLong()</code> was not intended for public use. However,
 userland modules have found it useful. The internal API is deprecated
 and replaced with an identical, public <code>path.toNamespacedPath()</code> method.</p>
-<p><a id="DEP0081"></a></p>
-<h3>DEP0081: <code>fs.truncate()</code> using a file descriptor<span><a class="mark" href="#deprecations_dep0081_fs_truncate_using_a_file_descriptor" id="deprecations_dep0081_fs_truncate_using_a_file_descriptor">#</a></span></h3>
+<h4 id="DEP0081">DEP0081: <code>fs.truncate()</code> using a file descriptor<span><a class="mark" href="#deprecations_dep0081_fs_truncate_using_a_file_descriptor" id="deprecations_dep0081_fs_truncate_using_a_file_descriptor">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24033,8 +24971,7 @@ and replaced with an identical, public <code>path.toNamespacedPath()</code> meth
 <p><code>fs.truncate()</code> <code>fs.truncateSync()</code> usage with a file descriptor is
 deprecated. Please use <code>fs.ftruncate()</code> or <code>fs.ftruncateSync()</code> to work with
 file descriptors.</p>
-<p><a id="DEP0082"></a></p>
-<h3>DEP0082: <code>REPLServer.prototype.memory()</code><span><a class="mark" href="#deprecations_dep0082_replserver_prototype_memory" id="deprecations_dep0082_replserver_prototype_memory">#</a></span></h3>
+<h4 id="DEP0082">DEP0082: <code>REPLServer.prototype.memory()</code><span><a class="mark" href="#deprecations_dep0082_replserver_prototype_memory" id="deprecations_dep0082_replserver_prototype_memory">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24047,8 +24984,7 @@ file descriptors.</p>
 <p>Type: Runtime</p>
 <p><code>REPLServer.prototype.memory()</code> is only necessary for the internal mechanics of
 the <code>REPLServer</code> itself. Do not use this function.</p>
-<p><a id="DEP0083"></a></p>
-<h3>DEP0083: Disabling ECDH by setting <code>ecdhCurve</code> to <code>false</code><span><a class="mark" href="#deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false" id="deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false">#</a></span></h3>
+<h4 id="DEP0083">DEP0083: Disabling ECDH by setting <code>ecdhCurve</code> to <code>false</code><span><a class="mark" href="#deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false" id="deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24065,8 +25001,7 @@ the <code>REPLServer</code> itself. Do not use this function.</p>
 be set to <code>false</code> to disable ECDH entirely on the server only. This mode was
 deprecated in preparation for migrating to OpenSSL 1.1.0 and consistency with
 the client and is now unsupported. Use the <code>ciphers</code> parameter instead.</p>
-<p><a id="DEP0084"></a></p>
-<h3>DEP0084: requiring bundled internal dependencies<span><a class="mark" href="#deprecations_dep0084_requiring_bundled_internal_dependencies" id="deprecations_dep0084_requiring_bundled_internal_dependencies">#</a></span></h3>
+<h4 id="DEP0084">DEP0084: requiring bundled internal dependencies<span><a class="mark" href="#deprecations_dep0084_requiring_bundled_internal_dependencies" id="deprecations_dep0084_requiring_bundled_internal_dependencies">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24100,18 +25035,17 @@ modules were:</p>
 <p>The <code>v8/*</code> modules do not have any exports, and if not imported in a specific
 order would in fact throw errors. As such there are virtually no legitimate use
 cases for importing them through <code>require()</code>.</p>
-<p>On the other hand, <code>node-inspect</code> may be installed locally through a package
+<p>On the other hand, <code>node-inspect</code> can be installed locally through a package
 manager, as it is published on the npm registry under the same name. No source
 code modification is necessary if that is done.</p>
-<p><a id="DEP0085"></a></p>
-<h3>DEP0085: AsyncHooks sensitive API<span><a class="mark" href="#deprecations_dep0085_asynchooks_sensitive_api" id="deprecations_dep0085_asynchooks_sensitive_api">#</a></span></h3>
+<h4 id="DEP0085">DEP0085: AsyncHooks sensitive API<span><a class="mark" href="#deprecations_dep0085_asynchooks_sensitive_api" id="deprecations_dep0085_asynchooks_sensitive_api">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>10.0.0</td>
+<tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v8.10.0, v9.4.0</td>
+<tr><td>v9.4.0, v8.10.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -24120,15 +25054,14 @@ code modification is necessary if that is done.</p>
 <p>The AsyncHooks sensitive API was never documented and had various minor issues.
 Use the <code>AsyncResource</code> API instead. See
 <a href="https://github.com/nodejs/node/issues/15572">https://github.com/nodejs/node/issues/15572</a>.</p>
-<p><a id="DEP0086"></a></p>
-<h3>DEP0086: Remove <code>runInAsyncIdScope</code><span><a class="mark" href="#deprecations_dep0086_remove_runinasyncidscope" id="deprecations_dep0086_remove_runinasyncidscope">#</a></span></h3>
+<h4 id="DEP0086">DEP0086: Remove <code>runInAsyncIdScope</code><span><a class="mark" href="#deprecations_dep0086_remove_runinasyncidscope" id="deprecations_dep0086_remove_runinasyncidscope">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>10.0.0</td>
+<tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v8.10.0, v9.4.0</td>
+<tr><td>v9.4.0, v8.10.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -24136,15 +25069,14 @@ Use the <code>AsyncResource</code> API instead. See
 <p>Type: End-of-Life</p>
 <p><code>runInAsyncIdScope</code> doesn't emit the <code>'before'</code> or <code>'after'</code> event and can thus
 cause a lot of issues. See <a href="https://github.com/nodejs/node/issues/14328">https://github.com/nodejs/node/issues/14328</a>.</p>
-<p><a id="DEP0089"></a></p>
-<h3>DEP0089: <code>require('assert')</code><span><a class="mark" href="#deprecations_dep0089_require_assert" id="deprecations_dep0089_require_assert">#</a></span></h3>
+<h4 id="DEP0089">DEP0089: <code>require('assert')</code><span><a class="mark" href="#deprecations_dep0089_require_assert" id="deprecations_dep0089_require_assert">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.8.0</td>
 <td><p>Deprecation revoked.</p></td></tr>
-<tr><td>v9.9.0, v10.0.0</td>
+<tr><td>v9.9.0, v8.13.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -24153,8 +25085,7 @@ cause a lot of issues. See <a href="https://github.com/nodejs/node/issues/14328"
 <p>Importing assert directly was not recommended as the exposed functions use
 loose equality checks. The deprecation was revoked because use of the <code>assert</code>
 module is not discouraged, and the deprecation caused developer confusion.</p>
-<p><a id="DEP0090"></a></p>
-<h3>DEP0090: Invalid GCM authentication tag lengths<span><a class="mark" href="#deprecations_dep0090_invalid_gcm_authentication_tag_lengths" id="deprecations_dep0090_invalid_gcm_authentication_tag_lengths">#</a></span></h3>
+<h4 id="DEP0090">DEP0090: Invalid GCM authentication tag lengths<span><a class="mark" href="#deprecations_dep0090_invalid_gcm_authentication_tag_lengths" id="deprecations_dep0090_invalid_gcm_authentication_tag_lengths">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24172,8 +25103,7 @@ OpenSSL when calling <a href="#crypto_decipher_setauthtag_buffer"><code>decipher
 v11.0.0, only authentication tag lengths of 128, 120, 112, 104, 96, 64, and 32
 bits are allowed. Authentication tags of other lengths are invalid per
 <a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf">NIST SP 800-38D</a>.</p>
-<p><a id="DEP0091"></a></p>
-<h3>DEP0091: <code>crypto.DEFAULT_ENCODING</code><span><a class="mark" href="#deprecations_dep0091_crypto_default_encoding" id="deprecations_dep0091_crypto_default_encoding">#</a></span></h3>
+<h4 id="DEP0091">DEP0091: <code>crypto.DEFAULT_ENCODING</code><span><a class="mark" href="#deprecations_dep0091_crypto_default_encoding" id="deprecations_dep0091_crypto_default_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24185,8 +25115,7 @@ bits are allowed. Authentication tags of other lengths are invalid per
 </div>
 <p>Type: Runtime</p>
 <p>The <a href="#crypto_crypto_default_encoding"><code>crypto.DEFAULT_ENCODING</code></a> property is deprecated.</p>
-<p><a id="DEP0092"></a></p>
-<h3>DEP0092: Top-level <code>this</code> bound to <code>module.exports</code><span><a class="mark" href="#deprecations_dep0092_top_level_this_bound_to_module_exports" id="deprecations_dep0092_top_level_this_bound_to_module_exports">#</a></span></h3>
+<h4 id="DEP0092">DEP0092: Top-level <code>this</code> bound to <code>module.exports</code><span><a class="mark" href="#deprecations_dep0092_top_level_this_bound_to_module_exports" id="deprecations_dep0092_top_level_this_bound_to_module_exports">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24200,8 +25129,7 @@ bits are allowed. Authentication tags of other lengths are invalid per
 <p>Assigning properties to the top-level <code>this</code> as an alternative
 to <code>module.exports</code> is deprecated. Developers should use <code>exports</code>
 or <code>module.exports</code> instead.</p>
-<p><a id="DEP0093"></a></p>
-<h3>DEP0093: <code>crypto.fips</code> is deprecated and replaced.<span><a class="mark" href="#deprecations_dep0093_crypto_fips_is_deprecated_and_replaced" id="deprecations_dep0093_crypto_fips_is_deprecated_and_replaced">#</a></span></h3>
+<h4 id="DEP0093">DEP0093: <code>crypto.fips</code> is deprecated and replaced<span><a class="mark" href="#deprecations_dep0093_crypto_fips_is_deprecated_and_replaced" id="deprecations_dep0093_crypto_fips_is_deprecated_and_replaced">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24214,8 +25142,7 @@ or <code>module.exports</code> instead.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="#crypto_crypto_fips"><code>crypto.fips</code></a> property is deprecated. Please use <code>crypto.setFips()</code>
 and <code>crypto.getFips()</code> instead.</p>
-<p><a id="DEP0094"></a></p>
-<h3>DEP0094: Using <code>assert.fail()</code> with more than one argument.<span><a class="mark" href="#deprecations_dep0094_using_assert_fail_with_more_than_one_argument" id="deprecations_dep0094_using_assert_fail_with_more_than_one_argument">#</a></span></h3>
+<h4 id="DEP0094">DEP0094: Using <code>assert.fail()</code> with more than one argument<span><a class="mark" href="#deprecations_dep0094_using_assert_fail_with_more_than_one_argument" id="deprecations_dep0094_using_assert_fail_with_more_than_one_argument">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24229,8 +25156,7 @@ and <code>crypto.getFips()</code> instead.</p>
 <p>Using <code>assert.fail()</code> with more than one argument is deprecated. Use
 <code>assert.fail()</code> with only one argument or use a different <code>assert</code> module
 method.</p>
-<p><a id="DEP0095"></a></p>
-<h3>DEP0095: <code>timers.enroll()</code><span><a class="mark" href="#deprecations_dep0095_timers_enroll" id="deprecations_dep0095_timers_enroll">#</a></span></h3>
+<h4 id="DEP0095">DEP0095: <code>timers.enroll()</code><span><a class="mark" href="#deprecations_dep0095_timers_enroll" id="deprecations_dep0095_timers_enroll">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24243,8 +25169,7 @@ method.</p>
 <p>Type: Runtime</p>
 <p><code>timers.enroll()</code> is deprecated. Please use the publicly documented
 <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> or <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a> instead.</p>
-<p><a id="DEP0096"></a></p>
-<h3>DEP0096: <code>timers.unenroll()</code><span><a class="mark" href="#deprecations_dep0096_timers_unenroll" id="deprecations_dep0096_timers_unenroll">#</a></span></h3>
+<h4 id="DEP0096">DEP0096: <code>timers.unenroll()</code><span><a class="mark" href="#deprecations_dep0096_timers_unenroll" id="deprecations_dep0096_timers_unenroll">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24257,8 +25182,7 @@ method.</p>
 <p>Type: Runtime</p>
 <p><code>timers.unenroll()</code> is deprecated. Please use the publicly documented
 <a href="#timers_cleartimeout_timeout"><code>clearTimeout()</code></a> or <a href="#timers_clearinterval_timeout"><code>clearInterval()</code></a> instead.</p>
-<p><a id="DEP0097"></a></p>
-<h3>DEP0097: <code>MakeCallback</code> with <code>domain</code> property<span><a class="mark" href="#deprecations_dep0097_makecallback_with_domain_property" id="deprecations_dep0097_makecallback_with_domain_property">#</a></span></h3>
+<h4 id="DEP0097">DEP0097: <code>MakeCallback</code> with <code>domain</code> property<span><a class="mark" href="#deprecations_dep0097_makecallback_with_domain_property" id="deprecations_dep0097_makecallback_with_domain_property">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24272,15 +25196,14 @@ method.</p>
 <p>Users of <code>MakeCallback</code> that add the <code>domain</code> property to carry context,
 should start using the <code>async_context</code> variant of <code>MakeCallback</code> or
 <code>CallbackScope</code>, or the high-level <code>AsyncResource</code> class.</p>
-<p><a id="DEP0098"></a></p>
-<h3>DEP0098: AsyncHooks embedder <code>AsyncResource.emitBefore</code> and <code>AsyncResource.emitAfter</code> APIs<span><a class="mark" href="#deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis" id="deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis">#</a></span></h3>
+<h4 id="DEP0098">DEP0098: AsyncHooks embedder <code>AsyncResource.emitBefore</code> and <code>AsyncResource.emitAfter</code> APIs<span><a class="mark" href="#deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis" id="deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
-<td><p>End-of-Life</p></td></tr>
-<tr><td>v8.12.0, v9.6.0, v10.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
+<tr><td>v10.0.0, v9.6.0, v8.12.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -24292,8 +25215,7 @@ to unrecoverable errors.</p>
 <p>Use <a href="#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args"><code>asyncResource.runInAsyncScope()</code></a> API instead which provides a much
 safer, and more convenient, alternative. See
 <a href="https://github.com/nodejs/node/pull/18513">https://github.com/nodejs/node/pull/18513</a>.</p>
-<p><a id="DEP0099"></a></p>
-<h3>DEP0099: Async context-unaware <code>node::MakeCallback</code> C++ APIs<span><a class="mark" href="#deprecations_dep0099_async_context_unaware_node_makecallback_c_apis" id="deprecations_dep0099_async_context_unaware_node_makecallback_c_apis">#</a></span></h3>
+<h4 id="DEP0099">DEP0099: Async context-unaware <code>node::MakeCallback</code> C++ APIs<span><a class="mark" href="#deprecations_dep0099_async_context_unaware_node_makecallback_c_apis" id="deprecations_dep0099_async_context_unaware_node_makecallback_c_apis">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24307,8 +25229,7 @@ safer, and more convenient, alternative. See
 <p>Certain versions of <code>node::MakeCallback</code> APIs available to native modules are
 deprecated. Please use the versions of the API that accept an <code>async_context</code>
 parameter.</p>
-<p><a id="DEP0100"></a></p>
-<h3>DEP0100: <code>process.assert()</code><span><a class="mark" href="#deprecations_dep0100_process_assert" id="deprecations_dep0100_process_assert">#</a></span></h3>
+<h4 id="DEP0100">DEP0100: <code>process.assert()</code><span><a class="mark" href="#deprecations_dep0100_process_assert" id="deprecations_dep0100_process_assert">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24323,8 +25244,7 @@ parameter.</p>
 <p>Type: Runtime</p>
 <p><code>process.assert()</code> is deprecated. Please use the <a href="assert.html"><code>assert</code></a> module instead.</p>
 <p>This was never a documented feature.</p>
-<p><a id="DEP0101"></a></p>
-<h3>DEP0101: <code>--with-lttng</code><span><a class="mark" href="#deprecations_dep0101_with_lttng" id="deprecations_dep0101_with_lttng">#</a></span></h3>
+<h4 id="DEP0101">DEP0101: <code>--with-lttng</code><span><a class="mark" href="#deprecations_dep0101_with_lttng" id="deprecations_dep0101_with_lttng">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24336,8 +25256,7 @@ parameter.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p>The <code>--with-lttng</code> compile-time option has been removed.</p>
-<p><a id="DEP0102"></a></p>
-<h3>DEP0102: Using <code>noAssert</code> in <code>Buffer#(read|write)</code> operations.<span><a class="mark" href="#deprecations_dep0102_using_noassert_in_buffer_read_write_operations" id="deprecations_dep0102_using_noassert_in_buffer_read_write_operations">#</a></span></h3>
+<h4 id="DEP0102">DEP0102: Using <code>noAssert</code> in <code>Buffer#(read|write)</code> operations<span><a class="mark" href="#deprecations_dep0102_using_noassert_in_buffer_read_write_operations" id="deprecations_dep0102_using_noassert_in_buffer_read_write_operations">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24351,8 +25270,7 @@ parameter.</p>
 <p>Using the <code>noAssert</code> argument has no functionality anymore. All input is going
 to be verified, no matter if it is set to true or not. Skipping the verification
 could lead to hard to find errors and crashes.</p>
-<p><a id="DEP0103"></a></p>
-<h3>DEP0103: <code>process.binding('util').is[...]</code> typechecks<span><a class="mark" href="#deprecations_dep0103_process_binding_util_is_typechecks" id="deprecations_dep0103_process_binding_util_is_typechecks">#</a></span></h3>
+<h4 id="DEP0103">DEP0103: <code>process.binding('util').is[...]</code> typechecks<span><a class="mark" href="#deprecations_dep0103_process_binding_util_is_typechecks" id="deprecations_dep0103_process_binding_util_is_typechecks">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24369,8 +25287,7 @@ could lead to hard to find errors and crashes.</p>
 methods in particular can be replaced by using <a href="#util_util_types"><code>util.types</code></a>.</p>
 <p>This deprecation has been superseded by the deprecation of the
 <code>process.binding()</code> API (<a href="#DEP0111">DEP0111</a>).</p>
-<p><a id="DEP0104"></a></p>
-<h3>DEP0104: <code>process.env</code> string coercion<span><a class="mark" href="#deprecations_dep0104_process_env_string_coercion" id="deprecations_dep0104_process_env_string_coercion">#</a></span></h3>
+<h4 id="DEP0104">DEP0104: <code>process.env</code> string coercion<span><a class="mark" href="#deprecations_dep0104_process_env_string_coercion" id="deprecations_dep0104_process_env_string_coercion">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24383,11 +25300,10 @@ methods in particular can be replaced by using <a href="#util_util_types"><code>
 <p>Type: Documentation-only (supports <a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p>When assigning a non-string property to <a href="#process_process_env"><code>process.env</code></a>, the assigned value is
 implicitly converted to a string. This behavior is deprecated if the assigned
-value is not a string, boolean, or number. In the future, such assignment may
+value is not a string, boolean, or number. In the future, such assignment might
 result in a thrown error. Please convert the property to a string before
 assigning it to <code>process.env</code>.</p>
-<p><a id="DEP0105"></a></p>
-<h3>DEP0105: <code>decipher.finaltol</code><span><a class="mark" href="#deprecations_dep0105_decipher_finaltol" id="deprecations_dep0105_decipher_finaltol">#</a></span></h3>
+<h4 id="DEP0105">DEP0105: <code>decipher.finaltol</code><span><a class="mark" href="#deprecations_dep0105_decipher_finaltol" id="deprecations_dep0105_decipher_finaltol">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24403,8 +25319,7 @@ assigning it to <code>process.env</code>.</p>
 <p><code>decipher.finaltol()</code> has never been documented and was an alias for
 <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a>. This API has been removed, and it is recommended to use
 <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> instead.</p>
-<p><a id="DEP0106"></a></p>
-<h3>DEP0106: <code>crypto.createCipher</code> and <code>crypto.createDecipher</code><span><a class="mark" href="#deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher" id="deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher">#</a></span></h3>
+<h4 id="DEP0106">DEP0106: <code>crypto.createCipher</code> and <code>crypto.createDecipher</code><span><a class="mark" href="#deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher" id="deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24423,8 +25338,7 @@ initialization vectors. It is recommended to derive a key using
 <a href="#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback"><code>crypto.pbkdf2()</code></a> or <a href="#crypto_crypto_scrypt_password_salt_keylen_options_callback"><code>crypto.scrypt()</code></a> and to use
 <a href="#crypto_crypto_createcipheriv_algorithm_key_iv_options"><code>crypto.createCipheriv()</code></a> and <a href="#crypto_crypto_createdecipheriv_algorithm_key_iv_options"><code>crypto.createDecipheriv()</code></a> to obtain the
 <a href="#crypto_class_cipher"><code>Cipher</code></a> and <a href="#crypto_class_decipher"><code>Decipher</code></a> objects respectively.</p>
-<p><a id="DEP0107"></a></p>
-<h3>DEP0107: <code>tls.convertNPNProtocols()</code><span><a class="mark" href="#deprecations_dep0107_tls_convertnpnprotocols" id="deprecations_dep0107_tls_convertnpnprotocols">#</a></span></h3>
+<h4 id="DEP0107">DEP0107: <code>tls.convertNPNProtocols()</code><span><a class="mark" href="#deprecations_dep0107_tls_convertnpnprotocols" id="deprecations_dep0107_tls_convertnpnprotocols">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24439,8 +25353,7 @@ initialization vectors. It is recommended to derive a key using
 <p>Type: End-of-Life</p>
 <p>This was an undocumented helper function not intended for use outside Node.js
 core and obsoleted by the removal of NPN (Next Protocol Negotiation) support.</p>
-<p><a id="DEP0108"></a></p>
-<h3>DEP0108: <code>zlib.bytesRead</code><span><a class="mark" href="#deprecations_dep0108_zlib_bytesread" id="deprecations_dep0108_zlib_bytesread">#</a></span></h3>
+<h4 id="DEP0108">DEP0108: <code>zlib.bytesRead</code><span><a class="mark" href="#deprecations_dep0108_zlib_bytesread" id="deprecations_dep0108_zlib_bytesread">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24457,8 +25370,7 @@ core and obsoleted by the removal of NPN (Next Protocol Negotiation) support.</p
 because it also made sense to interpret the value as the number of bytes
 read by the engine, but is inconsistent with other streams in Node.js that
 expose values under these names.</p>
-<p><a id="DEP0109"></a></p>
-<h3>DEP0109: <code>http</code>, <code>https</code>, and <code>tls</code> support for invalid URLs<span><a class="mark" href="#deprecations_dep0109_http_https_and_tls_support_for_invalid_urls" id="deprecations_dep0109_http_https_and_tls_support_for_invalid_urls">#</a></span></h3>
+<h4 id="DEP0109">DEP0109: <code>http</code>, <code>https</code>, and <code>tls</code> support for invalid URLs<span><a class="mark" href="#deprecations_dep0109_http_https_and_tls_support_for_invalid_urls" id="deprecations_dep0109_http_https_and_tls_support_for_invalid_urls">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24475,8 +25387,7 @@ expose values under these names.</p>
 accepted by the legacy <code>url.parse()</code> API. The mentioned APIs now use the WHATWG
 URL parser that requires strictly valid URLs. Passing an invalid URL is
 deprecated and support will be removed in the future.</p>
-<p><a id="DEP0110"></a></p>
-<h3>DEP0110: <code>vm.Script</code> cached data<span><a class="mark" href="#deprecations_dep0110_vm_script_cached_data" id="deprecations_dep0110_vm_script_cached_data">#</a></span></h3>
+<h4 id="DEP0110">DEP0110: <code>vm.Script</code> cached data<span><a class="mark" href="#deprecations_dep0110_vm_script_cached_data" id="deprecations_dep0110_vm_script_cached_data">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24489,8 +25400,7 @@ deprecated and support will be removed in the future.</p>
 <p>Type: Documentation-only</p>
 <p>The <code>produceCachedData</code> option is deprecated. Use
 <a href="#vm_script_createcacheddata"><code>script.createCachedData()</code></a> instead.</p>
-<p><a id="DEP0111"></a></p>
-<h3>DEP0111: <code>process.binding()</code><span><a class="mark" href="#deprecations_dep0111_process_binding" id="deprecations_dep0111_process_binding">#</a></span></h3>
+<h4 id="DEP0111">DEP0111: <code>process.binding()</code><span><a class="mark" href="#deprecations_dep0111_process_binding" id="deprecations_dep0111_process_binding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24504,8 +25414,7 @@ deprecated and support will be removed in the future.</p>
 </div>
 <p>Type: Documentation-only (supports <a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p><code>process.binding()</code> is for use by Node.js internal code only.</p>
-<p><a id="DEP0112"></a></p>
-<h3>DEP0112: <code>dgram</code> private APIs<span><a class="mark" href="#deprecations_dep0112_dgram_private_apis" id="deprecations_dep0112_dgram_private_apis">#</a></span></h3>
+<h4 id="DEP0112">DEP0112: <code>dgram</code> private APIs<span><a class="mark" href="#deprecations_dep0112_dgram_private_apis" id="deprecations_dep0112_dgram_private_apis">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24522,8 +25431,7 @@ accessed outside of Node.js core: <code>Socket.prototype._handle</code>,
 <code>Socket.prototype._queue</code>, <code>Socket.prototype._reuseAddr</code>,
 <code>Socket.prototype._healthCheck()</code>, <code>Socket.prototype._stopReceiving()</code>, and
 <code>dgram._createSocketHandle()</code>.</p>
-<p><a id="DEP0113"></a></p>
-<h3>DEP0113: <code>Cipher.setAuthTag()</code>, <code>Decipher.getAuthTag()</code><span><a class="mark" href="#deprecations_dep0113_cipher_setauthtag_decipher_getauthtag" id="deprecations_dep0113_cipher_setauthtag_decipher_getauthtag">#</a></span></h3>
+<h4 id="DEP0113">DEP0113: <code>Cipher.setAuthTag()</code>, <code>Decipher.getAuthTag()</code><span><a class="mark" href="#deprecations_dep0113_cipher_setauthtag_decipher_getauthtag" id="deprecations_dep0113_cipher_setauthtag_decipher_getauthtag">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24538,8 +25446,7 @@ accessed outside of Node.js core: <code>Socket.prototype._handle</code>,
 <p>Type: End-of-Life</p>
 <p><code>Cipher.setAuthTag()</code> and <code>Decipher.getAuthTag()</code> are no longer available. They
 were never documented and would throw when called.</p>
-<p><a id="DEP0114"></a></p>
-<h3>DEP0114: <code>crypto._toBuf()</code><span><a class="mark" href="#deprecations_dep0114_crypto_tobuf" id="deprecations_dep0114_crypto_tobuf">#</a></span></h3>
+<h4 id="DEP0114">DEP0114: <code>crypto._toBuf()</code><span><a class="mark" href="#deprecations_dep0114_crypto_tobuf" id="deprecations_dep0114_crypto_tobuf">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24554,8 +25461,8 @@ were never documented and would throw when called.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>crypto._toBuf()</code> function was not designed to be used by modules outside
 of Node.js core and was removed.</p>
-<p><a id="DEP0115"></a></p>
-<h3>DEP0115: <code>crypto.prng()</code>, <code>crypto.pseudoRandomBytes()</code>, <code>crypto.rng()</code><span><a class="mark" href="#deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng" id="deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng">#</a></span></h3>
+<h4 id="DEP0115">DEP0115: <code>crypto.prng()</code>, <code>crypto.pseudoRandomBytes()</code>, <code>crypto.rng()</code><span><a class="mark" href="#deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng" id="deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng">#</a></span></h4>
+<!--lint disable nodejs-yaml-comments -->
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24565,29 +25472,30 @@ of Node.js core and was removed.</p>
 </tbody></table>
 </details>
 </div>
+<!--lint enable nodejs-yaml-comments -->
 <p>Type: Documentation-only (supports <a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p>In recent versions of Node.js, there is no difference between
 <a href="#crypto_crypto_randombytes_size_callback"><code>crypto.randomBytes()</code></a> and <code>crypto.pseudoRandomBytes()</code>. The latter is
 deprecated along with the undocumented aliases <code>crypto.prng()</code> and
-<code>crypto.rng()</code> in favor of <a href="#crypto_crypto_randombytes_size_callback"><code>crypto.randomBytes()</code></a> and may be removed in a
+<code>crypto.rng()</code> in favor of <a href="#crypto_crypto_randombytes_size_callback"><code>crypto.randomBytes()</code></a> and might be removed in a
 future release.</p>
-<p><a id="DEP0116"></a></p>
-<h3>DEP0116: Legacy URL API<span><a class="mark" href="#deprecations_dep0116_legacy_url_api" id="deprecations_dep0116_legacy_url_api">#</a></span></h3>
+<h4 id="DEP0116">DEP0116: Legacy URL API<span><a class="mark" href="#deprecations_dep0116_legacy_url_api" id="deprecations_dep0116_legacy_url_api">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Documentation-only</p>
+<p>Type: Deprecation revoked</p>
 <p>The <a href="#url_legacy_url_api">Legacy URL API</a> is deprecated. This includes <a href="#url_url_format_urlobject"><code>url.format()</code></a>,
 <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a>, <a href="#url_url_resolve_from_to"><code>url.resolve()</code></a>, and the <a href="#url_legacy_urlobject">legacy <code>urlObject</code></a>. Please
 use the <a href="#url_the_whatwg_url_api">WHATWG URL API</a> instead.</p>
-<p><a id="DEP0117"></a></p>
-<h3>DEP0117: Native crypto handles<span><a class="mark" href="#deprecations_dep0117_native_crypto_handles" id="deprecations_dep0117_native_crypto_handles">#</a></span></h3>
+<h4 id="DEP0117">DEP0117: Native crypto handles<span><a class="mark" href="#deprecations_dep0117_native_crypto_handles" id="deprecations_dep0117_native_crypto_handles">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24605,8 +25513,7 @@ the <code>_handle</code> property of the <code>Cipher</code>, <code>Decipher</co
 <code>DiffieHellmanGroup</code>, <code>ECDH</code>, <code>Hash</code>, <code>Hmac</code>, <code>Sign</code>, and <code>Verify</code> classes.
 The <code>_handle</code> property has been removed because improper use of the native
 object can lead to crashing the application.</p>
-<p><a id="DEP0118"></a></p>
-<h3>DEP0118: <code>dns.lookup()</code> support for a falsy host name<span><a class="mark" href="#deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name" id="deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name">#</a></span></h3>
+<h4 id="DEP0118">DEP0118: <code>dns.lookup()</code> support for a falsy host name<span><a class="mark" href="#deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name" id="deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24621,8 +25528,7 @@ object can lead to crashing the application.</p>
 like <code>dns.lookup(false)</code> due to backward compatibility.
 This behavior is undocumented and is thought to be unused in real world apps.
 It will become an error in future versions of Node.js.</p>
-<p><a id="DEP0119"></a></p>
-<h3>DEP0119: <code>process.binding('uv').errname()</code> private API<span><a class="mark" href="#deprecations_dep0119_process_binding_uv_errname_private_api" id="deprecations_dep0119_process_binding_uv_errname_private_api">#</a></span></h3>
+<h4 id="DEP0119">DEP0119: <code>process.binding('uv').errname()</code> private API<span><a class="mark" href="#deprecations_dep0119_process_binding_uv_errname_private_api" id="deprecations_dep0119_process_binding_uv_errname_private_api">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24635,8 +25541,7 @@ It will become an error in future versions of Node.js.</p>
 <p>Type: Documentation-only (supports <a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p><code>process.binding('uv').errname()</code> is deprecated. Please use
 <a href="#util_util_getsystemerrorname_err"><code>util.getSystemErrorName()</code></a> instead.</p>
-<p><a id="DEP0120"></a></p>
-<h3>DEP0120: Windows Performance Counter support<span><a class="mark" href="#deprecations_dep0120_windows_performance_counter_support" id="deprecations_dep0120_windows_performance_counter_support">#</a></span></h3>
+<h4 id="DEP0120">DEP0120: Windows Performance Counter support<span><a class="mark" href="#deprecations_dep0120_windows_performance_counter_support" id="deprecations_dep0120_windows_performance_counter_support">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24654,8 +25559,7 @@ undocumented <code>COUNTER_NET_SERVER_CONNECTION()</code>,
 <code>COUNTER_NET_SERVER_CONNECTION_CLOSE()</code>, <code>COUNTER_HTTP_SERVER_REQUEST()</code>,
 <code>COUNTER_HTTP_SERVER_RESPONSE()</code>, <code>COUNTER_HTTP_CLIENT_REQUEST()</code>, and
 <code>COUNTER_HTTP_CLIENT_RESPONSE()</code> functions have been deprecated.</p>
-<p><a id="DEP0121"></a></p>
-<h3>DEP0121: <code>net._setSimultaneousAccepts()</code><span><a class="mark" href="#deprecations_dep0121_net_setsimultaneousaccepts" id="deprecations_dep0121_net_setsimultaneousaccepts">#</a></span></h3>
+<h4 id="DEP0121">DEP0121: <code>net._setSimultaneousAccepts()</code><span><a class="mark" href="#deprecations_dep0121_net_setsimultaneousaccepts" id="deprecations_dep0121_net_setsimultaneousaccepts">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24671,8 +25575,7 @@ intended for debugging and performance tuning when using the <code>child_process
 and <code>cluster</code> modules on Windows. The function is not generally useful and
 is being removed. See discussion here:
 <a href="https://github.com/nodejs/node/issues/18391">https://github.com/nodejs/node/issues/18391</a></p>
-<p><a id="DEP0122"></a></p>
-<h3>DEP0122: <code>tls</code> <code>Server.prototype.setOptions()</code><span><a class="mark" href="#deprecations_dep0122_tls_server_prototype_setoptions" id="deprecations_dep0122_tls_server_prototype_setoptions">#</a></span></h3>
+<h4 id="DEP0122">DEP0122: <code>tls</code> <code>Server.prototype.setOptions()</code><span><a class="mark" href="#deprecations_dep0122_tls_server_prototype_setoptions" id="deprecations_dep0122_tls_server_prototype_setoptions">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24684,8 +25587,7 @@ is being removed. See discussion here:
 </div>
 <p>Type: Runtime</p>
 <p>Please use <code>Server.prototype.setSecureContext()</code> instead.</p>
-<p><a id="DEP0123"></a></p>
-<h3>DEP0123: setting the TLS ServerName to an IP address<span><a class="mark" href="#deprecations_dep0123_setting_the_tls_servername_to_an_ip_address" id="deprecations_dep0123_setting_the_tls_servername_to_an_ip_address">#</a></span></h3>
+<h4 id="DEP0123">DEP0123: setting the TLS ServerName to an IP address<span><a class="mark" href="#deprecations_dep0123_setting_the_tls_servername_to_an_ip_address" id="deprecations_dep0123_setting_the_tls_servername_to_an_ip_address">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24698,8 +25600,7 @@ is being removed. See discussion here:
 <p>Type: Runtime</p>
 <p>Setting the TLS ServerName to an IP address is not permitted by
 <a href="https://tools.ietf.org/html/rfc6066#section-3">RFC 6066</a>. This will be ignored in a future version.</p>
-<p><a id="DEP0124"></a></p>
-<h3>DEP0124: using <code>REPLServer.rli</code><span><a class="mark" href="#deprecations_dep0124_using_replserver_rli" id="deprecations_dep0124_using_replserver_rli">#</a></span></h3>
+<h4 id="DEP0124">DEP0124: using <code>REPLServer.rli</code><span><a class="mark" href="#deprecations_dep0124_using_replserver_rli" id="deprecations_dep0124_using_replserver_rli">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24711,8 +25612,7 @@ is being removed. See discussion here:
 </div>
 <p>Type: Runtime</p>
 <p>This property is a reference to the instance itself.</p>
-<p><a id="DEP0125"></a></p>
-<h3>DEP0125: <code>require('_stream_wrap')</code><span><a class="mark" href="#deprecations_dep0125_require_stream_wrap" id="deprecations_dep0125_require_stream_wrap">#</a></span></h3>
+<h4 id="DEP0125">DEP0125: <code>require('_stream_wrap')</code><span><a class="mark" href="#deprecations_dep0125_require_stream_wrap" id="deprecations_dep0125_require_stream_wrap">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24724,8 +25624,7 @@ is being removed. See discussion here:
 </div>
 <p>Type: Runtime</p>
 <p>The <code>_stream_wrap</code> module is deprecated.</p>
-<p><a id="DEP0126"></a></p>
-<h3>DEP0126: <code>timers.active()</code><span><a class="mark" href="#deprecations_dep0126_timers_active" id="deprecations_dep0126_timers_active">#</a></span></h3>
+<h4 id="DEP0126">DEP0126: <code>timers.active()</code><span><a class="mark" href="#deprecations_dep0126_timers_active" id="deprecations_dep0126_timers_active">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24740,8 +25639,7 @@ is being removed. See discussion here:
 Please use the publicly documented <a href="#timers_timeout_refresh"><code>timeout.refresh()</code></a> instead.
 If re-referencing the timeout is necessary, <a href="#timers_timeout_ref"><code>timeout.ref()</code></a> can be used
 with no performance impact since Node.js 10.</p>
-<p><a id="DEP0127"></a></p>
-<h3>DEP0127: <code>timers._unrefActive()</code><span><a class="mark" href="#deprecations_dep0127_timers_unrefactive" id="deprecations_dep0127_timers_unrefactive">#</a></span></h3>
+<h4 id="DEP0127">DEP0127: <code>timers._unrefActive()</code><span><a class="mark" href="#deprecations_dep0127_timers_unrefactive" id="deprecations_dep0127_timers_unrefactive">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24756,8 +25654,7 @@ with no performance impact since Node.js 10.</p>
 Please use the publicly documented <a href="#timers_timeout_refresh"><code>timeout.refresh()</code></a> instead.
 If unreferencing the timeout is necessary, <a href="#timers_timeout_unref"><code>timeout.unref()</code></a> can be used
 with no performance impact since Node.js 10.</p>
-<p><a id="DEP0128"></a></p>
-<h3>DEP0128: modules with an invalid <code>main</code> entry and an <code>index.js</code> file<span><a class="mark" href="#deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file" id="deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file">#</a></span></h3>
+<h4 id="DEP0128">DEP0128: modules with an invalid <code>main</code> entry and an <code>index.js</code> file<span><a class="mark" href="#deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file" id="deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24772,53 +25669,55 @@ with no performance impact since Node.js 10.</p>
 also have an <code>index.js</code> file in the top level directory will resolve the
 <code>index.js</code> file. That is deprecated and is going to throw an error in future
 Node.js versions.</p>
-<p><a id="DEP0129"></a></p>
-<h3>DEP0129: <code>ChildProcess._channel</code><span><a class="mark" href="#deprecations_dep0129_childprocess_channel" id="deprecations_dep0129_childprocess_channel">#</a></span></h3>
+<h4 id="DEP0129">DEP0129: <code>ChildProcess._channel</code><span><a class="mark" href="#deprecations_dep0129_childprocess_channel" id="deprecations_dep0129_childprocess_channel">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
 <tr><td>v11.14.0</td>
 <td><p>Documentation-only.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Documentation-only</p>
+<p>Type: Runtime</p>
 <p>The <code>_channel</code> property of child process objects returned by <code>spawn()</code> and
 similar functions is not intended for public use. Use <code>ChildProcess.channel</code>
 instead.</p>
-<p><a id="DEP0130"></a></p>
-<h3>DEP0130: <code>Module.createRequireFromPath()</code><span><a class="mark" href="#deprecations_dep0130_module_createrequirefrompath" id="deprecations_dep0130_module_createrequirefrompath">#</a></span></h3>
+<h4 id="DEP0130">DEP0130: <code>Module.createRequireFromPath()</code><span><a class="mark" href="#deprecations_dep0130_module_createrequirefrompath" id="deprecations_dep0130_module_createrequirefrompath">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
 <tr><td>v12.2.0</td>
 <td><p>Documentation-only.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Documentation-only</p>
-<p>Module.createRequireFromPath() is deprecated. Please use <a href="#module_module_createrequire_filename"><code>module.createRequire()</code></a> instead.</p>
-<p><a id="DEP0131"></a></p>
-<h3>DEP0131: Legacy HTTP parser<span><a class="mark" href="#deprecations_dep0131_legacy_http_parser" id="deprecations_dep0131_legacy_http_parser">#</a></span></h3>
+<p>Type: Runtime</p>
+<p>Module.createRequireFromPath() is deprecated. Please use
+<a href="#module_module_createrequire_filename"><code>module.createRequire()</code></a> instead.</p>
+<h4 id="DEP0131">DEP0131: Legacy HTTP parser<span><a class="mark" href="#deprecations_dep0131_legacy_http_parser" id="deprecations_dep0131_legacy_http_parser">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.22.0</td>
-<td><p>Runtime deprecation.</p></td></tr>
+<tr><td>v13.0.0</td>
+<td><p>This feature has been removed.</p></td></tr>
 <tr><td>v12.3.0</td>
 <td><p>Documentation-only.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
+<p>Type: End-of-Life</p>
 <p>The legacy HTTP parser, used by default in versions of Node.js prior to 12.0.0,
-is deprecated. This deprecation applies to users of the
-<a href="#cli_http_parser_library"><code>--http-parser=legacy</code></a> command-line flag.</p>
-<p><a id="DEP0132"></a></p>
-<h3>DEP0132: <code>worker.terminate()</code> with callback<span><a class="mark" href="#deprecations_dep0132_worker_terminate_with_callback" id="deprecations_dep0132_worker_terminate_with_callback">#</a></span></h3>
+is deprecated and has been removed in v13.0.0. Prior to v13.0.0, the
+<code>--http-parser=legacy</code> command-line flag could be used to revert to using the
+legacy parser.</p>
+<h4 id="DEP0132">DEP0132: <code>worker.terminate()</code> with callback<span><a class="mark" href="#deprecations_dep0132_worker_terminate_with_callback" id="deprecations_dep0132_worker_terminate_with_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24831,8 +25730,7 @@ is deprecated. This deprecation applies to users of the
 <p>Type: Runtime</p>
 <p>Passing a callback to <a href="#worker_threads_worker_terminate"><code>worker.terminate()</code></a> is deprecated. Use the returned
 <code>Promise</code> instead, or a listener to the worker’s <code>'exit'</code> event.</p>
-<p><a id="DEP0133"></a></p>
-<h3>DEP0133: <code>http</code> <code>connection</code><span><a class="mark" href="#deprecations_dep0133_http_connection" id="deprecations_dep0133_http_connection">#</a></span></h3>
+<h4 id="DEP0133">DEP0133: <code>http</code> <code>connection</code><span><a class="mark" href="#deprecations_dep0133_http_connection" id="deprecations_dep0133_http_connection">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24845,8 +25743,7 @@ is deprecated. This deprecation applies to users of the
 <p>Type: Documentation-only</p>
 <p>Prefer <a href="#http_response_socket"><code>response.socket</code></a> over <a href="#http_response_connection"><code>response.connection</code></a> and
 <a href="#http_request_socket"><code>request.socket</code></a> over <a href="#http_request_connection"><code>request.connection</code></a>.</p>
-<p><a id="DEP0134"></a></p>
-<h3>DEP0134: <code>process._tickCallback</code><span><a class="mark" href="#deprecations_dep0134_process_tickcallback" id="deprecations_dep0134_process_tickcallback">#</a></span></h3>
+<h4 id="DEP0134">DEP0134: <code>process._tickCallback</code><span><a class="mark" href="#deprecations_dep0134_process_tickcallback" id="deprecations_dep0134_process_tickcallback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -24859,13 +25756,27 @@ is deprecated. This deprecation applies to users of the
 <p>Type: Documentation-only (supports <a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p>The <code>process._tickCallback</code> property was never documented as
 an officially supported API.</p>
-<p><a id="DEP0136"></a></p>
-<h3>DEP0136: <code>http</code> <code>finished</code><span><a class="mark" href="#deprecations_dep0136_http_finished" id="deprecations_dep0136_http_finished">#</a></span></h3>
+<h4 id="DEP0135">DEP0135: <code>WriteStream.open()</code> and <code>ReadStream.open()</code> are internal<span><a class="mark" href="#deprecations_dep0135_writestream_open_and_readstream_open_are_internal" id="deprecations_dep0135_writestream_open_and_readstream_open_are_internal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.0.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Runtime</p>
+<p><a href="#fs_class_fs_writestream"><code>WriteStream.open()</code></a> and <a href="#fs_class_fs_readstream"><code>ReadStream.open()</code></a> are undocumented internal
+APIs that do not make sense to use in userland. File streams should always be
+opened through their corresponding factory methods <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>
+and <a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream()</code></a>) or by passing a file descriptor in options.</p>
+<h4 id="DEP0136">DEP0136: <code>http</code> <code>finished</code><span><a class="mark" href="#deprecations_dep0136_http_finished" id="deprecations_dep0136_http_finished">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.4.0, v12.16.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -24875,16 +25786,57 @@ an officially supported API.</p>
 called, not whether <code>'finish'</code> has been emitted and the underlying data
 is flushed.</p>
 <p>Use <a href="#http_response_writablefinished"><code>response.writableFinished</code></a> or <a href="#http_response_writableended"><code>response.writableEnded</code></a>
-accordingly instead to avoid the ambigiuty.</p>
+accordingly instead to avoid the ambiguity.</p>
 <p>To maintain existing behaviour <code>response.finished</code> should be replaced with
 <code>response.writableEnded</code>.</p>
-<p><a id="DEP0139"></a></p>
-<h3>DEP0139: <code>process.umask()</code> with no arguments<span><a class="mark" href="#deprecations_dep0139_process_umask_with_no_arguments" id="deprecations_dep0139_process_umask_with_no_arguments">#</a></span></h3>
+<h4 id="DEP0137">DEP0137: Closing fs.FileHandle on garbage collection<span><a class="mark" href="#deprecations_dep0137_closing_fs_filehandle_on_garbage_collection" id="deprecations_dep0137_closing_fs_filehandle_on_garbage_collection">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0, v14.0.0</td>
+<tr><td>v14.0.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Runtime</p>
+<p>Allowing a <a href="#fs_class_filehandle"><code>fs.FileHandle</code></a> object to be closed on garbage collection is
+deprecated. In the future, doing so might result in a thrown error that will
+terminate the process.</p>
+<p>Please ensure that all <code>fs.FileHandle</code> objects are explicitly closed using
+<code>FileHandle.prototype.close()</code> when the <code>fs.FileHandle</code> is no longer needed:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> fsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).<span class="hljs-property">promises</span>;
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">openAndClose</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">let</span> filehandle;
+  <span class="hljs-keyword">try</span> {
+    filehandle = <span class="hljs-keyword">await</span> fsPromises.<span class="hljs-title function_">open</span>(<span class="hljs-string">'thefile.txt'</span>, <span class="hljs-string">'r'</span>);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-keyword">if</span> (filehandle !== <span class="hljs-literal">undefined</span>)
+      <span class="hljs-keyword">await</span> filehandle.<span class="hljs-title function_">close</span>();
+  }
+}</code></pre>
+<h4 id="DEP0138">DEP0138: <code>process.mainModule</code><span><a class="mark" href="#deprecations_dep0138_process_mainmodule" id="deprecations_dep0138_process_mainmodule">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p><a href="#process_process_mainmodule"><code>process.mainModule</code></a> is a CommonJS-only feature while <code>process</code> global
+object is shared with non-CommonJS environment. Its use within ECMAScript
+modules is unsupported.</p>
+<p>It is deprecated in favor of <a href="#modules_accessing_the_main_module"><code>require.main</code></a>, because it serves the same
+purpose and is only available on CommonJS environment.</p>
+<h4 id="DEP0139">DEP0139: <code>process.umask()</code> with no arguments<span><a class="mark" href="#deprecations_dep0139_process_umask_with_no_arguments" id="deprecations_dep0139_process_umask_with_no_arguments">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0, v12.19.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -24894,13 +25846,64 @@ accordingly instead to avoid the ambigiuty.</p>
 written twice. This introduces a race condition between threads, and is a
 potential security vulnerability. There is no safe, cross-platform alternative
 API.</p>
-<p><a id="DEP0144"></a></p>
-<h3>DEP0144: <code>module.parent</code><span><a class="mark" href="#deprecations_dep0144_module_parent" id="deprecations_dep0144_module_parent">#</a></span></h3>
+<h4 id="DEP0140">DEP0140: Use <code>request.destroy()</code> instead of <code>request.abort()</code><span><a class="mark" href="#deprecations_dep0140_use_request_destroy_instead_of_request_abort" id="deprecations_dep0140_use_request_destroy_instead_of_request_abort">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0, v14.6.0</td>
+<tr><td>v14.1.0, v13.14.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p>Use <a href="#http_request_destroy_error"><code>request.destroy()</code></a> instead of <a href="#http_request_abort"><code>request.abort()</code></a>.</p>
+<h4 id="DEP0141">DEP0141: <code>repl.inputStream</code> and <code>repl.outputStream</code><span><a class="mark" href="#deprecations_dep0141_repl_inputstream_and_repl_outputstream" id="deprecations_dep0141_repl_inputstream_and_repl_outputstream">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.3.0</td>
+<td><p>Documentation-only (supports [<code>--pending-deprecation</code>][]).</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only (supports <a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
+<p>The <code>repl</code> module exported the input and output stream twice. Use <code>.input</code>
+instead of <code>.inputStream</code> and <code>.output</code> instead of <code>.outputStream</code>.</p>
+<h4 id="DEP0142">DEP0142: <code>repl._builtinLibs</code><span><a class="mark" href="#deprecations_dep0142_repl_builtinlibs" id="deprecations_dep0142_repl_builtinlibs">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.3.0</td>
+<td><p>Documentation-only (supports [<code>--pending-deprecation</code>][]).</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p>The <code>repl</code> module exports a <code>_builtinLibs</code> property that contains an array with
+native modules. It was incomplete so far and instead it's better to rely upon
+<code>require('module').builtinModules</code>.</p>
+<h4 id="DEP0143">DEP0143: <code>Transform._transformState</code><span><a class="mark" href="#deprecations_dep0143_transform_transformstate" id="deprecations_dep0143_transform_transformstate">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.5.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Runtime
+<code>Transform._transformState</code> will be removed in future versions where it is
+no longer required due to simplification of the implementation.</p>
+<h4 id="DEP0144">DEP0144: <code>module.parent</code><span><a class="mark" href="#deprecations_dep0144_module_parent" id="deprecations_dep0144_module_parent">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0, v12.19.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -24912,17 +25915,208 @@ consistently in the presence of ECMAScript modules and because it gives an
 inaccurate representation of the CommonJS module graph.</p>
 <p>Some modules use it to check if they are the entry point of the current process.
 Instead, it is recommended to compare <code>require.main</code> and <code>module</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (<span class="hljs-built_in">require</span>.main === <span class="hljs-built_in">module</span>) {
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (<span class="hljs-built_in">require</span>.<span class="hljs-property">main</span> === <span class="hljs-variable language_">module</span>) {
   <span class="hljs-comment">// Code section that will run only if current file is the entry point.</span>
 }</code></pre>
 <p>When looking for the CommonJS modules that have required the current one,
 <code>require.cache</code> and <code>module.children</code> can be used:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> moduleParents = <span class="hljs-built_in">Object</span>.values(<span class="hljs-built_in">require</span>.cache)
-  .filter(<span class="hljs-function">(<span class="hljs-params">m</span>) =></span> m.children.includes(<span class="hljs-built_in">module</span>));</code></pre>
-<h1>DNS<span><a class="mark" href="#dns_dns" id="dns_dns">#</a></span></h1>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> moduleParents = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">values</span>(<span class="hljs-built_in">require</span>.<span class="hljs-property">cache</span>)
+  .<span class="hljs-title function_">filter</span>(<span class="hljs-function">(<span class="hljs-params">m</span>) =></span> m.<span class="hljs-property">children</span>.<span class="hljs-title function_">includes</span>(<span class="hljs-variable language_">module</span>));</code></pre>
+<h4 id="DEP0145">DEP0145: <code>socket.bufferSize</code><span><a class="mark" href="#deprecations_dep0145_socket_buffersize" id="deprecations_dep0145_socket_buffersize">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p><a href="#net_socket_buffersize"><code>socket.bufferSize</code></a> is just an alias for <a href="#stream_writable_writablelength"><code>writable.writableLength</code></a>.</p>
+<h4 id="DEP0146">DEP0146: <code>new crypto.Certificate()</code><span><a class="mark" href="#deprecations_dep0146_new_crypto_certificate" id="deprecations_dep0146_new_crypto_certificate">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.9.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p>The <a href="#crypto_legacy_api"><code>crypto.Certificate()</code> constructor</a> is deprecated. Use
+<a href="#crypto_class_certificate">static methods of <code>crypto.Certificate()</code></a> instead.</p>
+<h4 id="DEP0147">DEP0147: <code>fs.rmdir(path, { recursive: true })</code><span><a class="mark" href="#deprecations_dep0147_fs_rmdir_path_recursive_true" id="deprecations_dep0147_fs_rmdir_path_recursive_true">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.14.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p>In future versions of Node.js, <code>fs.rmdir(path, { recursive: true })</code> will throw
+on nonexistent paths, or when given a file as a target.
+Use <code>fs.rm(path, { recursive: true, force: true })</code> instead.</p>
+<h4 id="DEP0151">DEP0151: Main index lookup and extension searching<span><a class="mark" href="#deprecations_dep0151_main_index_lookup_and_extension_searching" id="deprecations_dep0151_main_index_lookup_and_extension_searching">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Documentation-only deprecation with <code>--pending-deprecation</code> support.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only (supports <a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
+<p>Previously, <code>index.js</code> and extension searching lookups would apply to
+<code>import 'pkg'</code> main entry point resolution, even when resolving ES modules.</p>
+<p>With this deprecation, all ES module main entry point resolutions require
+an explicit <a href="#packages_main_entry_point_export"><code>"exports"</code> or <code>"main"</code> entry</a> with the exact file extension.</p></section>
+        </section>
+<section><h2>Diagnostics Channel<span><a class="mark" href="#diagnostics_channel_diagnostics_channel" id="diagnostics_channel_diagnostics_channel">#</a></span></h2>
+
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/diagnostics_channel.js">lib/diagnostics_channel.js</a></p>
+<p>The <code>diagnostics_channel</code> module provides an API to create named channels
+to report arbitrary message data for diagnostics purposes.</p>
+<p>It can be accessed using:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);</code></pre>
+<p>It is intended that a module writer wanting to report diagnostics messages
+will create one or many top-level channels to report messages through.
+Channels may also be acquired at runtime but it is not encouraged
+due to the additional overhead of doing so. Channels may be exported for
+convenience, but as long as the name is known it can be acquired anywhere.</p>
+<p>If you intend for your module to produce diagnostics data for others to
+consume it is recommended that you include documentation of what named
+channels are used along with the shape of the message data. Channel names
+should generally include the module name to avoid collisions with data from
+other modules.</p>
+<section><h3>Public API<span><a class="mark" href="#diagnostics_channel_public_api" id="diagnostics_channel_public_api">#</a></span></h3>
+<h4>Overview<span><a class="mark" href="#diagnostics_channel_overview" id="diagnostics_channel_overview">#</a></span></h4>
+<p>Following is a simple overview of the public API.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-comment">// Get a reusable channel object</span>
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+<span class="hljs-comment">// Subscribe to the channel</span>
+channel.<span class="hljs-title function_">subscribe</span>(<span class="hljs-function">(<span class="hljs-params">message, name</span>) =></span> {
+  <span class="hljs-comment">// Received data</span>
+});
+
+<span class="hljs-comment">// Check if the channel has an active subscriber</span>
+<span class="hljs-keyword">if</span> (channel.<span class="hljs-property">hasSubscribers</span>) {
+  <span class="hljs-comment">// Publish data to the channel</span>
+  channel.<span class="hljs-title function_">publish</span>({
+    <span class="hljs-attr">some</span>: <span class="hljs-string">'data'</span>
+  });
+}</code></pre>
+<h5><code>diagnostics_channel.hasSubscribers(name)</code><span><a class="mark" href="#diagnostics_channel_diagnostics_channel_hassubscribers_name" id="diagnostics_channel_diagnostics_channel_hassubscribers_name">#</a></span></h5>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The channel name</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If there are active subscribers</li>
+</ul>
+<p>Check if there are active subscribers to the named channel. This is helpful if
+the message you want to send might be expensive to prepare.</p>
+<p>This API is optional but helpful when trying to publish messages from very
+performance-sensitive code.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">if</span> (diagnostics_channel.<span class="hljs-title function_">hasSubscribers</span>(<span class="hljs-string">'my-channel'</span>)) {
+  <span class="hljs-comment">// There are subscribers, prepare and publish message</span>
+}</code></pre>
+<h5><code>diagnostics_channel.channel(name)</code><span><a class="mark" href="#diagnostics_channel_diagnostics_channel_channel_name" id="diagnostics_channel_diagnostics_channel_channel_name">#</a></span></h5>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The channel name</li>
+<li>Returns: <a href="#diagnostics_channel_class_channel" class="type">&#x3C;Channel></a> The named channel object</li>
+</ul>
+<p>This is the primary entry-point for anyone wanting to interact with a named
+channel. It produces a channel object which is optimized to reduce overhead at
+publish time as much as possible.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);</code></pre>
+<h4>Class: <code>Channel</code><span><a class="mark" href="#diagnostics_channel_class_channel" id="diagnostics_channel_class_channel">#</a></span></h4>
+<p>The class <code>Channel</code> represents an individual named channel within the data
+pipeline. It is use to track subscribers and to publish messages when there
+are subscribers present. It exists as a separate object to avoid channel
+lookups at publish time, enabling very fast publish speeds and allowing
+for heavy use while incurring very minimal cost. Channels are created with
+<a href="#diagnostics_channel_diagnostics_channel_channel_name"><code>diagnostics_channel.channel(name)</code></a>, constructing a channel directly
+with <code>new Channel(name)</code> is not supported.</p>
+<h5><code>channel.hasSubscribers</code><span><a class="mark" href="#diagnostics_channel_channel_hassubscribers" id="diagnostics_channel_channel_hassubscribers">#</a></span></h5>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If there are active subscribers</li>
+</ul>
+<p>Check if there are active subscribers to this channel. This is helpful if
+the message you want to send might be expensive to prepare.</p>
+<p>This API is optional but helpful when trying to publish messages from very
+performance-sensitive code.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+<span class="hljs-keyword">if</span> (channel.<span class="hljs-property">hasSubscribers</span>) {
+  <span class="hljs-comment">// There are subscribers, prepare and publish message</span>
+}</code></pre>
+<h5><code>channel.publish(message)</code><span><a class="mark" href="#diagnostics_channel_channel_publish_message" id="diagnostics_channel_channel_publish_message">#</a></span></h5>
+<ul>
+<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The message to send to the channel subscribers</li>
+</ul>
+<p>Publish a message to any subscribers to the channel. This will trigger
+message handlers synchronously so they will execute within the same context.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+channel.<span class="hljs-title function_">publish</span>({
+  <span class="hljs-attr">some</span>: <span class="hljs-string">'message'</span>
+});</code></pre>
+<h5><code>channel.subscribe(onMessage)</code><span><a class="mark" href="#diagnostics_channel_channel_subscribe_onmessage" id="diagnostics_channel_channel_subscribe_onmessage">#</a></span></h5>
+<ul>
+<li><code>onMessage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The handler to receive channel messages
+<ul>
+<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The message data</li>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the channel</li>
+</ul>
+</li>
+</ul>
+<p>Register a message handler to subscribe to this channel. This message handler
+will be run synchronously whenever a message is published to the channel. Any
+errors thrown in the message handler will trigger an <a href="#process_event_uncaughtexception"><code>'uncaughtException'</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+channel.<span class="hljs-title function_">subscribe</span>(<span class="hljs-function">(<span class="hljs-params">message, name</span>) =></span> {
+  <span class="hljs-comment">// Received data</span>
+});</code></pre>
+<h5><code>channel.unsubscribe(onMessage)</code><span><a class="mark" href="#diagnostics_channel_channel_unsubscribe_onmessage" id="diagnostics_channel_channel_unsubscribe_onmessage">#</a></span></h5>
+<ul>
+<li><code>onMessage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The previous subscribed handler to remove</li>
+</ul>
+<p>Remove a message handler previously registered to this channel with
+<a href="#diagnostics_channel_channel_subscribe_onmessage"><code>channel.subscribe(onMessage)</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">onMessage</span>(<span class="hljs-params">message, name</span>) {
+  <span class="hljs-comment">// Received data</span>
+}
+
+channel.<span class="hljs-title function_">subscribe</span>(onMessage);
+
+channel.<span class="hljs-title function_">unsubscribe</span>(onMessage);</code></pre></section>
+        </section>
+<section><h2>DNS<span><a class="mark" href="#dns_dns" id="dns_dns">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/dns.js">lib/dns.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/dns.js">lib/dns.js</a></p>
 <p>The <code>dns</code> module enables name resolution. For example, use it to look up IP
 addresses of host names.</p>
 <p>Although named for the <a href="https://en.wikipedia.org/wiki/Domain_Name_System">Domain Name System (DNS)</a>, it does not always use the
@@ -24932,8 +26126,8 @@ communication. To perform name resolution the way other applications on the same
 system do, use <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
 
-dns.lookup(<span class="hljs-string">'example.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, address, family</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'address: %j family: IPv%s'</span>, address, family);
+dns.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, address, family</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'address: %j family: IPv%s'</span>, address, family);
 });
 <span class="hljs-comment">// address: "93.184.216.34" family: IPv4</span></code></pre>
 <p>All other functions in the <code>dns</code> module connect to an actual DNS server to
@@ -24943,22 +26137,22 @@ queries. These functions do not use the same set of configuration files used by
 DNS queries, bypassing other name-resolution facilities.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
 
-dns.resolve4(<span class="hljs-string">'archive.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span> {
+dns.<span class="hljs-title function_">resolve4</span>(<span class="hljs-string">'archive.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
 
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`addresses: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(addresses)}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`addresses: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(addresses)}</span>`</span>);
 
-  addresses.forEach(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> {
-    dns.reverse(a, <span class="hljs-function">(<span class="hljs-params">err, hostnames</span>) =></span> {
+  addresses.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> {
+    dns.<span class="hljs-title function_">reverse</span>(a, <span class="hljs-function">(<span class="hljs-params">err, hostnames</span>) =></span> {
       <span class="hljs-keyword">if</span> (err) {
         <span class="hljs-keyword">throw</span> err;
       }
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`reverse for <span class="hljs-subst">${a}</span>: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(hostnames)}</span>`</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`reverse for <span class="hljs-subst">${a}</span>: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(hostnames)}</span>`</span>);
     });
   });
 });</code></pre>
 <p>See the <a href="#dns_implementation_considerations">Implementation considerations section</a> for more information.</p>
-<h2>Class: <code>dns.Resolver</code><span><a class="mark" href="#dns_class_dns_resolver" id="dns_class_dns_resolver">#</a></span></h2>
+<section><h3>Class: <code>dns.Resolver</code><span><a class="mark" href="#dns_class_dns_resolver" id="dns_class_dns_resolver">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
@@ -24967,12 +26161,12 @@ dns.resolve4(<span class="hljs-string">'archive.org'</span>, <span class="hljs-f
 the servers used for a resolver using
 <a href="#dns_dns_setservers_servers"><code>resolver.setServers()</code></a> does not affect
 other resolvers:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Resolver } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
-<span class="hljs-keyword">const</span> resolver = <span class="hljs-keyword">new</span> Resolver();
-resolver.setServers([<span class="hljs-string">'4.4.4.4'</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Resolver</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
+<span class="hljs-keyword">const</span> resolver = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Resolver</span>();
+resolver.<span class="hljs-title function_">setServers</span>([<span class="hljs-string">'4.4.4.4'</span>]);
 
 <span class="hljs-comment">// This request will use the server at 4.4.4.4, independent of global settings.</span>
-resolver.resolve4(<span class="hljs-string">'example.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span> {
+resolver.<span class="hljs-title function_">resolve4</span>(<span class="hljs-string">'example.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>The following methods from the <code>dns</code> module are available:</p>
@@ -24982,6 +26176,7 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>, <span class="h
 <li><a href="#dns_dns_resolve4_hostname_options_callback"><code>resolver.resolve4()</code></a></li>
 <li><a href="#dns_dns_resolve6_hostname_options_callback"><code>resolver.resolve6()</code></a></li>
 <li><a href="#dns_dns_resolveany_hostname_callback"><code>resolver.resolveAny()</code></a></li>
+<li><a href="#dns_dns_resolvecaa_hostname_callback"><code>resolver.resolveCaa()</code></a></li>
 <li><a href="#dns_dns_resolvecname_hostname_callback"><code>resolver.resolveCname()</code></a></li>
 <li><a href="#dns_dns_resolvemx_hostname_callback"><code>resolver.resolveMx()</code></a></li>
 <li><a href="#dns_dns_resolvenaptr_hostname_callback"><code>resolver.resolveNaptr()</code></a></li>
@@ -24993,12 +26188,14 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>, <span class="h
 <li><a href="#dns_dns_reverse_ip_callback"><code>resolver.reverse()</code></a></li>
 <li><a href="#dns_dns_setservers_servers"><code>resolver.setServers()</code></a></li>
 </ul>
-<h3><code>Resolver([options])</code><span><a class="mark" href="#dns_resolver_options" id="dns_resolver_options">#</a></span></h3>
+<h4><code>Resolver([options])</code><span><a class="mark" href="#dns_resolver_options" id="dns_resolver_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.18.3</td>
+<tr><td>v14.18.0</td>
+<td><p>The <code>options</code> object now accepts a <code>tries</code> option.</p></td></tr>
+<tr><td>v14.5.0</td>
 <td><p>The constructor now accepts an <code>options</code> object. The single supported option is <code>timeout</code>.</p></td></tr>
 <tr><td>v8.3.0</td>
 <td><p><span>Added in: v8.3.0</span></p></td></tr>
@@ -25011,16 +26208,36 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>, <span class="h
 <ul>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Query timeout in milliseconds, or <code>-1</code> to use the
 default timeout.</li>
+<li><code>tries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of tries the resolver will try contacting
+each name server before giving up. <strong>Default:</strong> <code>4</code></li>
 </ul>
 </li>
 </ul>
-<h3><code>resolver.cancel()</code><span><a class="mark" href="#dns_resolver_cancel" id="dns_resolver_cancel">#</a></span></h3>
+<h4><code>resolver.cancel()</code><span><a class="mark" href="#dns_resolver_cancel" id="dns_resolver_cancel">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
 <p>Cancel all outstanding DNS queries made by this resolver. The corresponding
 callbacks will be called with an error with code <code>ECANCELLED</code>.</p>
-<h2><code>dns.getServers()</code><span><a class="mark" href="#dns_dns_getservers" id="dns_dns_getservers">#</a></span></h2>
+<h4><code>resolver.setLocalAddress([ipv4][, ipv6])</code><span><a class="mark" href="#dns_resolver_setlocaladdress_ipv4_ipv6" id="dns_resolver_setlocaladdress_ipv4_ipv6">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>ipv4</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A string representation of an IPv4 address.
+<strong>Default:</strong> <code>'0.0.0.0'</code></li>
+<li><code>ipv6</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A string representation of an IPv6 address.
+<strong>Default:</strong> <code>'::0'</code></li>
+</ul>
+<p>The resolver instance will send its requests from the specified IP address.
+This allows programs to specify outbound interfaces when used on multi-homed
+systems.</p>
+<p>If a v4 or v6 address is not specified, it is set to the default, and the
+operating system will choose a local address automatically.</p>
+<p>The resolver will use the v4 local address when making requests to IPv4 DNS
+servers, and the v6 local address when making requests to IPv6 DNS servers.
+The <code>rrtype</code> of resolution requests has no impact on the local address used.</p>
+</section><section><h3><code>dns.getServers()</code><span><a class="mark" href="#dns_dns_getservers" id="dns_dns_getservers">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -25035,9 +26252,9 @@ section if a custom port is used.</p>
   <span class="hljs-string">'4.4.4.4'</span>,
   <span class="hljs-string">'2001:4860:4860::8888'</span>,
   <span class="hljs-string">'4.4.4.4:1053'</span>,
-  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>
+  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>,
 ]</code></pre>
-<h2><code>dns.lookup(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_lookup_hostname_options_callback" id="dns_dns_lookup_hostname_options_callback">#</a></span></h2>
+</section><section><h3><code>dns.lookup(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_lookup_hostname_options_callback" id="dns_dns_lookup_hostname_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -25066,8 +26283,9 @@ an array. Otherwise, returns a single address. <strong>Default:</strong> <code>f
 addresses in the order the DNS resolver returned them. When <code>false</code>,
 IPv4 addresses are placed before IPv6 addresses.
 <strong>Default:</strong> currently <code>false</code> (addresses are reordered) but this is
-expected to change in the not too distant future.
-New code should use <code>{ verbatim: true }</code>.</li>
+expected to change in the not too distant future. Default value is
+configurable using <a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> or
+<a href="#cli_dns_result_order_order"><code>--dns-result-order</code></a>. New code should use <code>{ verbatim: true }</code>.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -25101,26 +26319,26 @@ time to consult the <a href="#dns_implementation_considerations">Implementation
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">family</span>: <span class="hljs-number">6</span>,
-  <span class="hljs-attr">hints</span>: dns.ADDRCONFIG | dns.V4MAPPED,
+  <span class="hljs-attr">hints</span>: dns.<span class="hljs-property">ADDRCONFIG</span> | dns.<span class="hljs-property">V4MAPPED</span>,
 };
-dns.lookup(<span class="hljs-string">'example.com'</span>, options, <span class="hljs-function">(<span class="hljs-params">err, address, family</span>) =></span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'address: %j family: IPv%s'</span>, address, family));
+dns.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.com'</span>, options, <span class="hljs-function">(<span class="hljs-params">err, address, family</span>) =></span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'address: %j family: IPv%s'</span>, address, family));
 <span class="hljs-comment">// address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6</span>
 
 <span class="hljs-comment">// When options.all is true, the result will be an Array.</span>
-options.all = <span class="hljs-literal">true</span>;
-dns.lookup(<span class="hljs-string">'example.com'</span>, options, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'addresses: %j'</span>, addresses));
+options.<span class="hljs-property">all</span> = <span class="hljs-literal">true</span>;
+dns.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.com'</span>, options, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'addresses: %j'</span>, addresses));
 <span class="hljs-comment">// addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]</span></code></pre>
 <p>If this method is invoked as its <a href="#util_util_promisify_original"><code>util.promisify()</code></a>ed version, and <code>all</code>
 is not set to <code>true</code>, it returns a <code>Promise</code> for an <code>Object</code> with <code>address</code> and
 <code>family</code> properties.</p>
-<h3>Supported getaddrinfo flags<span><a class="mark" href="#dns_supported_getaddrinfo_flags" id="dns_supported_getaddrinfo_flags">#</a></span></h3>
+<h4>Supported getaddrinfo flags<span><a class="mark" href="#dns_supported_getaddrinfo_flags" id="dns_supported_getaddrinfo_flags">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.0.0</td>
 <td><p>Added support for the <code>dns.ALL</code> flag.</p></td></tr>
 </tbody></table>
 </details>
@@ -25136,7 +26354,7 @@ on some operating systems (e.g FreeBSD 10.1).</li>
 <li><code>dns.ALL</code>: If <code>dns.V4MAPPED</code> is specified, return resolved IPv6 addresses as
 well as IPv4 mapped IPv6 addresses.</li>
 </ul>
-<h2><code>dns.lookupService(address, port, callback)</code><span><a class="mark" href="#dns_dns_lookupservice_address_port_callback" id="dns_dns_lookupservice_address_port_callback">#</a></span></h2>
+</section><section><h3><code>dns.lookupService(address, port, callback)</code><span><a class="mark" href="#dns_dns_lookupservice_address_port_callback" id="dns_dns_lookupservice_address_port_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -25158,13 +26376,13 @@ The <code>port</code> will be coerced to a number. If it is not a legal port, a
 will be thrown.</p>
 <p>On an error, <code>err</code> is an <a href="#errors_class_error"><code>Error</code></a> object, where <code>err.code</code> is the error code.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
-dns.lookupService(<span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-number">22</span>, <span class="hljs-function">(<span class="hljs-params">err, hostname, service</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(hostname, service);
+dns.<span class="hljs-title function_">lookupService</span>(<span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-number">22</span>, <span class="hljs-function">(<span class="hljs-params">err, hostname, service</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hostname, service);
   <span class="hljs-comment">// Prints: localhost ssh</span>
 });</code></pre>
 <p>If this method is invoked as its <a href="#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns a
 <code>Promise</code> for an <code>Object</code> with <code>hostname</code> and <code>service</code> properties.</p>
-<h2><code>dns.resolve(hostname[, rrtype], callback)</code><span><a class="mark" href="#dns_dns_resolve_hostname_rrtype_callback" id="dns_dns_resolve_hostname_rrtype_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolve(hostname[, rrtype], callback)</code><span><a class="mark" href="#dns_dns_resolve_hostname_rrtype_callback" id="dns_dns_resolve_hostname_rrtype_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -25259,10 +26477,16 @@ records. The type and structure of individual results varies based on <code>rrty
 
 
 
-<table><thead><tr><th><code>rrtype</code></th><th><code>records</code> contains</th><th>Result type</th><th>Shorthand method</th></tr></thead><tbody><tr><td><code>'A'</code></td><td>IPv4 addresses (default)</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolve4_hostname_options_callback"><code>dns.resolve4()</code></a></td></tr><tr><td><code>'AAAA'</code></td><td>IPv6 addresses</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolve6_hostname_options_callback"><code>dns.resolve6()</code></a></td></tr><tr><td><code>'ANY'</code></td><td>any records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolveany_hostname_callback"><code>dns.resolveAny()</code></a></td></tr><tr><td><code>'CNAME'</code></td><td>canonical name records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolvecname_hostname_callback"><code>dns.resolveCname()</code></a></td></tr><tr><td><code>'MX'</code></td><td>mail exchange records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvemx_hostname_callback"><code>dns.resolveMx()</code></a></td></tr><tr><td><code>'NAPTR'</code></td><td>name authority pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvenaptr_hostname_callback"><code>dns.resolveNaptr()</code></a></td></tr><tr><td><code>'NS'</code></td><td>name server records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolvens_hostname_callback"><code>dns.resolveNs()</code></a></td></tr><tr><td><code>'PTR'</code></td><td>pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolveptr_hostname_callback"><code>dns.resolvePtr()</code></a></td></tr><tr><td><code>'SOA'</code></td><td>start of authority records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvesoa_hostname_callback"><code>dns.resolveSoa()</code></a></td></tr><tr><td><code>'SRV'</code></td><td>service records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvesrv_hostname_callback"><code>dns.resolveSrv()</code></a></td></tr><tr><td><code>'TXT'</code></td><td>text records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></td><td><a href="#dns_dns_resolvetxt_hostname_callback"><code>dns.resolveTxt()</code></a></td></tr></tbody></table>
+
+
+
+
+
+
+<table><thead><tr><th><code>rrtype</code></th><th><code>records</code> contains</th><th>Result type</th><th>Shorthand method</th></tr></thead><tbody><tr><td><code>'A'</code></td><td>IPv4 addresses (default)</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolve4_hostname_options_callback"><code>dns.resolve4()</code></a></td></tr><tr><td><code>'AAAA'</code></td><td>IPv6 addresses</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolve6_hostname_options_callback"><code>dns.resolve6()</code></a></td></tr><tr><td><code>'ANY'</code></td><td>any records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolveany_hostname_callback"><code>dns.resolveAny()</code></a></td></tr><tr><td><code>'CAA'</code></td><td>CA authorization records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvecaa_hostname_callback"><code>dns.resolveCaa()</code></a></td></tr><tr><td><code>'CNAME'</code></td><td>canonical name records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolvecname_hostname_callback"><code>dns.resolveCname()</code></a></td></tr><tr><td><code>'MX'</code></td><td>mail exchange records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvemx_hostname_callback"><code>dns.resolveMx()</code></a></td></tr><tr><td><code>'NAPTR'</code></td><td>name authority pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvenaptr_hostname_callback"><code>dns.resolveNaptr()</code></a></td></tr><tr><td><code>'NS'</code></td><td>name server records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolvens_hostname_callback"><code>dns.resolveNs()</code></a></td></tr><tr><td><code>'PTR'</code></td><td>pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolveptr_hostname_callback"><code>dns.resolvePtr()</code></a></td></tr><tr><td><code>'SOA'</code></td><td>start of authority records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvesoa_hostname_callback"><code>dns.resolveSoa()</code></a></td></tr><tr><td><code>'SRV'</code></td><td>service records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvesrv_hostname_callback"><code>dns.resolveSrv()</code></a></td></tr><tr><td><code>'TXT'</code></td><td>text records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></td><td><a href="#dns_dns_resolvetxt_hostname_callback"><code>dns.resolveTxt()</code></a></td></tr></tbody></table>
 <p>On error, <code>err</code> is an <a href="#errors_class_error"><code>Error</code></a> object, where <code>err.code</code> is one of the
 <a href="#dns_error_codes">DNS error codes</a>.</p>
-<h2><code>dns.resolve4(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_resolve4_hostname_options_callback" id="dns_dns_resolve4_hostname_options_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolve4(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_resolve4_hostname_options_callback" id="dns_dns_resolve4_hostname_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -25295,7 +26519,7 @@ with the TTL expressed in seconds.</li>
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function
 will contain an array of IPv4 addresses (e.g.
 <code>['74.125.79.104', '74.125.79.105', '74.125.79.106']</code>).</p>
-<h2><code>dns.resolve6(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_resolve6_hostname_options_callback" id="dns_dns_resolve6_hostname_options_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolve6(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_resolve6_hostname_options_callback" id="dns_dns_resolve6_hostname_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -25327,7 +26551,7 @@ strings, with the TTL expressed in seconds.</li>
 <p>Uses the DNS protocol to resolve a IPv6 addresses (<code>AAAA</code> records) for the
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function
 will contain an array of IPv6 addresses.</p>
-<h2><code>dns.resolveAny(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolveany_hostname_callback" id="dns_dns_resolveany_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveAny(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolveany_hostname_callback" id="dns_dns_resolveany_hostname_callback">#</a></span></h3>
 <ul>
 <li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -25410,7 +26634,7 @@ will be present on the object:</p>
 <p>DNS server operators may choose not to respond to <code>ANY</code>
 queries. It may be better to call individual methods like <a href="#dns_dns_resolve4_hostname_options_callback"><code>dns.resolve4()</code></a>,
 <a href="#dns_dns_resolvemx_hostname_callback"><code>dns.resolveMx()</code></a>, and so on. For more details, see <a href="https://tools.ietf.org/html/rfc8482">RFC 8482</a>.</p>
-<h2><code>dns.resolveCname(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvecname_hostname_callback" id="dns_dns_resolvecname_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveCname(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvecname_hostname_callback" id="dns_dns_resolvecname_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -25427,7 +26651,24 @@ queries. It may be better to call individual methods like <a href="#dns_dns_reso
 <code>addresses</code> argument passed to the <code>callback</code> function
 will contain an array of canonical name records available for the <code>hostname</code>
 (e.g. <code>['bar.example.com']</code>).</p>
-<h2><code>dns.resolveMx(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvemx_hostname_callback" id="dns_dns_resolvemx_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveCaa(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvecaa_hostname_callback" id="dns_dns_resolvecaa_hostname_callback">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>records</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object[]></a></li>
+</ul>
+</li>
+</ul>
+<p>Uses the DNS protocol to resolve <code>CAA</code> records for the <code>hostname</code>. The
+<code>addresses</code> argument passed to the <code>callback</code> function
+will contain an array of certification authority authorization records
+available for the <code>hostname</code> (e.g. <code>[{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]</code>).</p>
+</section><section><h3><code>dns.resolveMx(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvemx_hostname_callback" id="dns_dns_resolvemx_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -25444,7 +26685,7 @@ will contain an array of canonical name records available for the <code>hostname
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will
 contain an array of objects containing both a <code>priority</code> and <code>exchange</code>
 property (e.g. <code>[{priority: 10, exchange: 'mx.example.com'}, ...]</code>).</p>
-<h2><code>dns.resolveNaptr(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvenaptr_hostname_callback" id="dns_dns_resolvenaptr_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveNaptr(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvenaptr_hostname_callback" id="dns_dns_resolvenaptr_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.12</span>
 </div>
@@ -25477,7 +26718,7 @@ function will contain an array of objects with the following properties:</p>
   <span class="hljs-attr">order</span>: <span class="hljs-number">30</span>,
   <span class="hljs-attr">preference</span>: <span class="hljs-number">100</span>
 }</code></pre>
-<h2><code>dns.resolveNs(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvens_hostname_callback" id="dns_dns_resolvens_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveNs(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvens_hostname_callback" id="dns_dns_resolvens_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -25494,7 +26735,7 @@ function will contain an array of objects with the following properties:</p>
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will
 contain an array of name server records available for <code>hostname</code>
 (e.g. <code>['ns1.example.com', 'ns2.example.com']</code>).</p>
-<h2><code>dns.resolvePtr(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolveptr_hostname_callback" id="dns_dns_resolveptr_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolvePtr(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolveptr_hostname_callback" id="dns_dns_resolveptr_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -25510,7 +26751,7 @@ contain an array of name server records available for <code>hostname</code>
 <p>Uses the DNS protocol to resolve pointer records (<code>PTR</code> records) for the
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will
 be an array of strings containing the reply records.</p>
-<h2><code>dns.resolveSoa(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvesoa_hostname_callback" id="dns_dns_resolvesoa_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveSoa(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvesoa_hostname_callback" id="dns_dns_resolvesoa_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.10</span>
 </div>
@@ -25545,7 +26786,7 @@ be an object with the following properties:</p>
   <span class="hljs-attr">expire</span>: <span class="hljs-number">604800</span>,
   <span class="hljs-attr">minttl</span>: <span class="hljs-number">3600</span>
 }</code></pre>
-<h2><code>dns.resolveSrv(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvesrv_hostname_callback" id="dns_dns_resolvesrv_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveSrv(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvesrv_hostname_callback" id="dns_dns_resolvesrv_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -25574,10 +26815,11 @@ be an array of objects with the following properties:</p>
   <span class="hljs-attr">port</span>: <span class="hljs-number">21223</span>,
   <span class="hljs-attr">name</span>: <span class="hljs-string">'service.example.com'</span>
 }</code></pre>
-<h2><code>dns.resolveTxt(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvetxt_hostname_callback" id="dns_dns_resolvetxt_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveTxt(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvetxt_hostname_callback" id="dns_dns_resolvetxt_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
+<!--lint disable no-undefined-references list-item-bullet-indent-->
 <ul>
 <li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -25587,13 +26829,14 @@ be an array of objects with the following properties:</p>
 </ul>
 </li>
 </ul>
+<!--lint enable no-undefined-references list-item-bullet-indent-->
 <p>Uses the DNS protocol to resolve text queries (<code>TXT</code> records) for the
 <code>hostname</code>. The <code>records</code> argument passed to the <code>callback</code> function is a
 two-dimensional array of the text records available for <code>hostname</code> (e.g.
 <code>[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]</code>). Each sub-array contains TXT chunks of
 one record. Depending on the use case, these could be either joined together or
 treated separately.</p>
-<h2><code>dns.reverse(ip, callback)</code><span><a class="mark" href="#dns_dns_reverse_ip_callback" id="dns_dns_reverse_ip_callback">#</a></span></h2>
+</section><section><h3><code>dns.reverse(ip, callback)</code><span><a class="mark" href="#dns_dns_reverse_ip_callback" id="dns_dns_reverse_ip_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -25610,7 +26853,24 @@ treated separately.</p>
 array of host names.</p>
 <p>On error, <code>err</code> is an <a href="#errors_class_error"><code>Error</code></a> object, where <code>err.code</code> is
 one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
-<h2><code>dns.setServers(servers)</code><span><a class="mark" href="#dns_dns_setservers_servers" id="dns_dns_setservers_servers">#</a></span></h2>
+</section><section><h3><code>dns.setDefaultResultOrder(order)</code><span><a class="mark" href="#dns_dns_setdefaultresultorder_order" id="dns_dns_setdefaultresultorder_order">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>order</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> must be <code>'ipv4first'</code> or <code>'verbatim'</code>.</li>
+</ul>
+<p>Set the default value of <code>verbatim</code> in <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> and
+<a href="#dns_dnspromises_lookup_hostname_options"><code>dnsPromises.lookup()</code></a>. The value could be:</p>
+<ul>
+<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>
+<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>
+</ul>
+<p>The default is <code>ipv4first</code> and <a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> have higher
+priority than <a href="#cli_dns_result_order_order"><code>--dns-result-order</code></a>. When using <a href="worker_threads.html">worker threads</a>,
+<a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> from the main thread won't affect the default
+dns orders in workers.</p>
+</section><section><h3><code>dns.setServers(servers)</code><span><a class="mark" href="#dns_dns_setservers_servers" id="dns_dns_setservers_servers">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -25620,11 +26880,11 @@ one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
 <p>Sets the IP address and port of servers to be used when performing DNS
 resolution. The <code>servers</code> argument is an array of <a href="https://tools.ietf.org/html/rfc5952#section-6">RFC 5952</a> formatted
 addresses. If the port is the IANA default DNS port (53) it can be omitted.</p>
-<pre><code class="language-js">dns.setServers([
+<pre><code class="language-js">dns.<span class="hljs-title function_">setServers</span>([
   <span class="hljs-string">'4.4.4.4'</span>,
   <span class="hljs-string">'[2001:4860:4860::8888]'</span>,
   <span class="hljs-string">'4.4.4.4:1053'</span>,
-  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>
+  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>,
 ]);</code></pre>
 <p>An error will be thrown if an invalid address is provided.</p>
 <p>The <code>dns.setServers()</code> method must not be called while a DNS query is in
@@ -25638,11 +26898,22 @@ That is, if attempting to resolve with the first server provided results in a
 <code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with
 subsequent servers provided. Fallback DNS servers will only be used if the
 earlier ones time out or result in some other error.</p>
-<h2>DNS promises API<span><a class="mark" href="#dns_dns_promises_api" id="dns_dns_promises_api">#</a></span></h2>
+</section><section><h3>DNS promises API<span><a class="mark" href="#dns_dns_promises_api" id="dns_dns_promises_api">#</a></span></h3>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v11.14.0, v10.17.0</td>
+<td><p>This API is no longer experimental.</p></td></tr>
+<tr><td>v10.6.0</td>
+<td><p><span>Added in: v10.6.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
 <p>The <code>dns.promises</code> API provides an alternative set of asynchronous DNS methods
 that return <code>Promise</code> objects rather than using callbacks. The API is accessible
 via <code>require('dns').promises</code>.</p>
-<h3>Class: <code>dnsPromises.Resolver</code><span><a class="mark" href="#dns_class_dnspromises_resolver" id="dns_class_dnspromises_resolver">#</a></span></h3>
+<h4>Class: <code>dnsPromises.Resolver</code><span><a class="mark" href="#dns_class_dnspromises_resolver" id="dns_class_dnspromises_resolver">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25651,18 +26922,18 @@ via <code>require('dns').promises</code>.</p>
 the servers used for a resolver using
 <a href="#dns_dnspromises_setservers_servers"><code>resolver.setServers()</code></a> does not affect
 other resolvers:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Resolver } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>).promises;
-<span class="hljs-keyword">const</span> resolver = <span class="hljs-keyword">new</span> Resolver();
-resolver.setServers([<span class="hljs-string">'4.4.4.4'</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Resolver</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>).<span class="hljs-property">promises</span>;
+<span class="hljs-keyword">const</span> resolver = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Resolver</span>();
+resolver.<span class="hljs-title function_">setServers</span>([<span class="hljs-string">'4.4.4.4'</span>]);
 
 <span class="hljs-comment">// This request will use the server at 4.4.4.4, independent of global settings.</span>
-resolver.resolve4(<span class="hljs-string">'example.org'</span>).then(<span class="hljs-function">(<span class="hljs-params">addresses</span>) =></span> {
+resolver.<span class="hljs-title function_">resolve4</span>(<span class="hljs-string">'example.org'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">addresses</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });
 
 <span class="hljs-comment">// Alternatively, the same code can be written using async-await style.</span>
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> addresses = <span class="hljs-keyword">await</span> resolver.resolve4(<span class="hljs-string">'example.org'</span>);
+(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> addresses = <span class="hljs-keyword">await</span> resolver.<span class="hljs-title function_">resolve4</span>(<span class="hljs-string">'example.org'</span>);
 })();</code></pre>
 <p>The following methods from the <code>dnsPromises</code> API are available:</p>
 <ul>
@@ -25671,6 +26942,7 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>).then(<span cla
 <li><a href="#dns_dnspromises_resolve4_hostname_options"><code>resolver.resolve4()</code></a></li>
 <li><a href="#dns_dnspromises_resolve6_hostname_options"><code>resolver.resolve6()</code></a></li>
 <li><a href="#dns_dnspromises_resolveany_hostname"><code>resolver.resolveAny()</code></a></li>
+<li><a href="#dns_dnspromises_resolvecaa_hostname"><code>resolver.resolveCaa()</code></a></li>
 <li><a href="#dns_dnspromises_resolvecname_hostname"><code>resolver.resolveCname()</code></a></li>
 <li><a href="#dns_dnspromises_resolvemx_hostname"><code>resolver.resolveMx()</code></a></li>
 <li><a href="#dns_dnspromises_resolvenaptr_hostname"><code>resolver.resolveNaptr()</code></a></li>
@@ -25682,7 +26954,13 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>).then(<span cla
 <li><a href="#dns_dnspromises_reverse_ip"><code>resolver.reverse()</code></a></li>
 <li><a href="#dns_dnspromises_setservers_servers"><code>resolver.setServers()</code></a></li>
 </ul>
-<h3><code>dnsPromises.getServers()</code><span><a class="mark" href="#dns_dnspromises_getservers" id="dns_dnspromises_getservers">#</a></span></h3>
+<h4><code>resolver.cancel()</code><span><a class="mark" href="#dns_resolver_cancel_1" id="dns_resolver_cancel_1">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>Cancel all outstanding DNS queries made by this resolver. The corresponding
+promises will be rejected with an error with code <code>ECANCELLED</code>.</p>
+<h4><code>dnsPromises.getServers()</code><span><a class="mark" href="#dns_dnspromises_getservers" id="dns_dnspromises_getservers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25697,9 +26975,9 @@ section if a custom port is used.</p>
   <span class="hljs-string">'4.4.4.4'</span>,
   <span class="hljs-string">'2001:4860:4860::8888'</span>,
   <span class="hljs-string">'4.4.4.4:1053'</span>,
-  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>
+  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>,
 ]</code></pre>
-<h3><code>dnsPromises.lookup(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_lookup_hostname_options" id="dns_dnspromises_lookup_hostname_options">#</a></span></h3>
+<h4><code>dnsPromises.lookup(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_lookup_hostname_options" id="dns_dnspromises_lookup_hostname_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25718,8 +26996,9 @@ an array. Otherwise, returns a single address. <strong>Default:</strong> <code>f
 IPv6 addresses in the order the DNS resolver returned them. When <code>false</code>,
 IPv4 addresses are placed before IPv6 addresses.
 <strong>Default:</strong> currently <code>false</code> (addresses are reordered) but this is
-expected to change in the not too distant future.
-New code should use <code>{ verbatim: true }</code>.</li>
+expected to change in the not too distant future. Default value is
+configurable using <a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> or
+<a href="#cli_dns_result_order_order"><code>--dns-result-order</code></a>. New code should use <code>{ verbatim: true }</code>.</li>
 </ul>
 </li>
 </ul>
@@ -25742,24 +27021,24 @@ take some time to consult the <a href="#dns_implementation_considerations">Imple
 using <code>dnsPromises.lookup()</code>.</p>
 <p>Example usage:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
-<span class="hljs-keyword">const</span> dnsPromises = dns.promises;
+<span class="hljs-keyword">const</span> dnsPromises = dns.<span class="hljs-property">promises</span>;
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">family</span>: <span class="hljs-number">6</span>,
-  <span class="hljs-attr">hints</span>: dns.ADDRCONFIG | dns.V4MAPPED,
+  <span class="hljs-attr">hints</span>: dns.<span class="hljs-property">ADDRCONFIG</span> | dns.<span class="hljs-property">V4MAPPED</span>,
 };
 
-dnsPromises.lookup(<span class="hljs-string">'example.com'</span>, options).then(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'address: %j family: IPv%s'</span>, result.address, result.family);
+dnsPromises.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.com'</span>, options).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'address: %j family: IPv%s'</span>, result.<span class="hljs-property">address</span>, result.<span class="hljs-property">family</span>);
   <span class="hljs-comment">// address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6</span>
 });
 
 <span class="hljs-comment">// When options.all is true, the result will be an Array.</span>
-options.all = <span class="hljs-literal">true</span>;
-dnsPromises.lookup(<span class="hljs-string">'example.com'</span>, options).then(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'addresses: %j'</span>, result);
+options.<span class="hljs-property">all</span> = <span class="hljs-literal">true</span>;
+dnsPromises.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.com'</span>, options).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'addresses: %j'</span>, result);
   <span class="hljs-comment">// addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]</span>
 });</code></pre>
-<h3><code>dnsPromises.lookupService(address, port)</code><span><a class="mark" href="#dns_dnspromises_lookupservice_address_port" id="dns_dnspromises_lookupservice_address_port">#</a></span></h3>
+<h4><code>dnsPromises.lookupService(address, port)</code><span><a class="mark" href="#dns_dnspromises_lookupservice_address_port" id="dns_dnspromises_lookupservice_address_port">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25774,12 +27053,12 @@ The <code>port</code> will be coerced to a number. If it is not a legal port, a
 will be thrown.</p>
 <p>On error, the <code>Promise</code> is rejected with an <a href="#errors_class_error"><code>Error</code></a> object, where <code>err.code</code>
 is the error code.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> dnsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>).promises;
-dnsPromises.lookupService(<span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-number">22</span>).then(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(result.hostname, result.service);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> dnsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>).<span class="hljs-property">promises</span>;
+dnsPromises.<span class="hljs-title function_">lookupService</span>(<span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-number">22</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result.<span class="hljs-property">hostname</span>, result.<span class="hljs-property">service</span>);
   <span class="hljs-comment">// Prints: localhost ssh</span>
 });</code></pre>
-<h3><code>dnsPromises.resolve(hostname[, rrtype])</code><span><a class="mark" href="#dns_dnspromises_resolve_hostname_rrtype" id="dns_dnspromises_resolve_hostname_rrtype">#</a></span></h3>
+<h4><code>dnsPromises.resolve(hostname[, rrtype])</code><span><a class="mark" href="#dns_dnspromises_resolve_hostname_rrtype" id="dns_dnspromises_resolve_hostname_rrtype">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25868,10 +27147,16 @@ based on <code>rrtype</code>:</p>
 
 
 
-<table><thead><tr><th><code>rrtype</code></th><th><code>records</code> contains</th><th>Result type</th><th>Shorthand method</th></tr></thead><tbody><tr><td><code>'A'</code></td><td>IPv4 addresses (default)</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolve4_hostname_options"><code>dnsPromises.resolve4()</code></a></td></tr><tr><td><code>'AAAA'</code></td><td>IPv6 addresses</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolve6_hostname_options"><code>dnsPromises.resolve6()</code></a></td></tr><tr><td><code>'ANY'</code></td><td>any records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolveany_hostname"><code>dnsPromises.resolveAny()</code></a></td></tr><tr><td><code>'CNAME'</code></td><td>canonical name records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolvecname_hostname"><code>dnsPromises.resolveCname()</code></a></td></tr><tr><td><code>'MX'</code></td><td>mail exchange records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvemx_hostname"><code>dnsPromises.resolveMx()</code></a></td></tr><tr><td><code>'NAPTR'</code></td><td>name authority pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvenaptr_hostname"><code>dnsPromises.resolveNaptr()</code></a></td></tr><tr><td><code>'NS'</code></td><td>name server records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolvens_hostname"><code>dnsPromises.resolveNs()</code></a></td></tr><tr><td><code>'PTR'</code></td><td>pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolveptr_hostname"><code>dnsPromises.resolvePtr()</code></a></td></tr><tr><td><code>'SOA'</code></td><td>start of authority records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvesoa_hostname"><code>dnsPromises.resolveSoa()</code></a></td></tr><tr><td><code>'SRV'</code></td><td>service records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvesrv_hostname"><code>dnsPromises.resolveSrv()</code></a></td></tr><tr><td><code>'TXT'</code></td><td>text records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></td><td><a href="#dns_dnspromises_resolvetxt_hostname"><code>dnsPromises.resolveTxt()</code></a></td></tr></tbody></table>
+
+
+
+
+
+
+<table><thead><tr><th><code>rrtype</code></th><th><code>records</code> contains</th><th>Result type</th><th>Shorthand method</th></tr></thead><tbody><tr><td><code>'A'</code></td><td>IPv4 addresses (default)</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolve4_hostname_options"><code>dnsPromises.resolve4()</code></a></td></tr><tr><td><code>'AAAA'</code></td><td>IPv6 addresses</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolve6_hostname_options"><code>dnsPromises.resolve6()</code></a></td></tr><tr><td><code>'ANY'</code></td><td>any records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolveany_hostname"><code>dnsPromises.resolveAny()</code></a></td></tr><tr><td><code>'CAA'</code></td><td>CA authorization records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvecaa_hostname"><code>dnsPromises.resolveCaa()</code></a></td></tr><tr><td><code>'CNAME'</code></td><td>canonical name records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolvecname_hostname"><code>dnsPromises.resolveCname()</code></a></td></tr><tr><td><code>'MX'</code></td><td>mail exchange records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvemx_hostname"><code>dnsPromises.resolveMx()</code></a></td></tr><tr><td><code>'NAPTR'</code></td><td>name authority pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvenaptr_hostname"><code>dnsPromises.resolveNaptr()</code></a></td></tr><tr><td><code>'NS'</code></td><td>name server records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolvens_hostname"><code>dnsPromises.resolveNs()</code></a></td></tr><tr><td><code>'PTR'</code></td><td>pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolveptr_hostname"><code>dnsPromises.resolvePtr()</code></a></td></tr><tr><td><code>'SOA'</code></td><td>start of authority records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvesoa_hostname"><code>dnsPromises.resolveSoa()</code></a></td></tr><tr><td><code>'SRV'</code></td><td>service records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvesrv_hostname"><code>dnsPromises.resolveSrv()</code></a></td></tr><tr><td><code>'TXT'</code></td><td>text records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></td><td><a href="#dns_dnspromises_resolvetxt_hostname"><code>dnsPromises.resolveTxt()</code></a></td></tr></tbody></table>
 <p>On error, the <code>Promise</code> is rejected with an <a href="#errors_class_error"><code>Error</code></a> object, where <code>err.code</code>
 is one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
-<h3><code>dnsPromises.resolve4(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_resolve4_hostname_options" id="dns_dnspromises_resolve4_hostname_options">#</a></span></h3>
+<h4><code>dnsPromises.resolve4(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_resolve4_hostname_options" id="dns_dnspromises_resolve4_hostname_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25889,7 +27174,7 @@ with the TTL expressed in seconds.</li>
 <p>Uses the DNS protocol to resolve IPv4 addresses (<code>A</code> records) for the
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of IPv4
 addresses (e.g. <code>['74.125.79.104', '74.125.79.105', '74.125.79.106']</code>).</p>
-<h3><code>dnsPromises.resolve6(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_resolve6_hostname_options" id="dns_dnspromises_resolve6_hostname_options">#</a></span></h3>
+<h4><code>dnsPromises.resolve6(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_resolve6_hostname_options" id="dns_dnspromises_resolve6_hostname_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25907,7 +27192,7 @@ strings, with the TTL expressed in seconds.</li>
 <p>Uses the DNS protocol to resolve IPv6 addresses (<code>AAAA</code> records) for the
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of IPv6
 addresses.</p>
-<h3><code>dnsPromises.resolveAny(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolveany_hostname" id="dns_dnspromises_resolveany_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveAny(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolveany_hostname" id="dns_dnspromises_resolveany_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25984,7 +27269,18 @@ present on the object:</p>
     <span class="hljs-attr">retry</span>: <span class="hljs-number">900</span>,
     <span class="hljs-attr">expire</span>: <span class="hljs-number">1800</span>,
     <span class="hljs-attr">minttl</span>: <span class="hljs-number">60</span> } ]</code></pre>
-<h3><code>dnsPromises.resolveCname(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvecname_hostname" id="dns_dnspromises_resolvecname_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveCaa(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvecaa_hostname" id="dns_dnspromises_resolvecaa_hostname">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Uses the DNS protocol to resolve <code>CAA</code> records for the <code>hostname</code>. On success,
+the <code>Promise</code> is resolved with an array of objects containing available
+certification authority authorization records available for the <code>hostname</code>
+(e.g. <code>[{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue: 'pki.example.com'}]</code>).</p>
+<h4><code>dnsPromises.resolveCname(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvecname_hostname" id="dns_dnspromises_resolvecname_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -25994,7 +27290,7 @@ present on the object:</p>
 <p>Uses the DNS protocol to resolve <code>CNAME</code> records for the <code>hostname</code>. On success,
 the <code>Promise</code> is resolved with an array of canonical name records available for
 the <code>hostname</code> (e.g. <code>['bar.example.com']</code>).</p>
-<h3><code>dnsPromises.resolveMx(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvemx_hostname" id="dns_dnspromises_resolvemx_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveMx(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvemx_hostname" id="dns_dnspromises_resolvemx_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26005,7 +27301,7 @@ the <code>hostname</code> (e.g. <code>['bar.example.com']</code>).</p>
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of objects
 containing both a <code>priority</code> and <code>exchange</code> property (e.g.
 <code>[{priority: 10, exchange: 'mx.example.com'}, ...]</code>).</p>
-<h3><code>dnsPromises.resolveNaptr(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvenaptr_hostname" id="dns_dnspromises_resolvenaptr_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveNaptr(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvenaptr_hostname" id="dns_dnspromises_resolvenaptr_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26032,7 +27328,7 @@ of objects with the following properties:</p>
   <span class="hljs-attr">order</span>: <span class="hljs-number">30</span>,
   <span class="hljs-attr">preference</span>: <span class="hljs-number">100</span>
 }</code></pre>
-<h3><code>dnsPromises.resolveNs(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvens_hostname" id="dns_dnspromises_resolvens_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveNs(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvens_hostname" id="dns_dnspromises_resolvens_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26043,7 +27339,7 @@ of objects with the following properties:</p>
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of name server
 records available for <code>hostname</code> (e.g.
 <code>['ns1.example.com', 'ns2.example.com']</code>).</p>
-<h3><code>dnsPromises.resolvePtr(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolveptr_hostname" id="dns_dnspromises_resolveptr_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolvePtr(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolveptr_hostname" id="dns_dnspromises_resolveptr_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26053,7 +27349,7 @@ records available for <code>hostname</code> (e.g.
 <p>Uses the DNS protocol to resolve pointer records (<code>PTR</code> records) for the
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of strings
 containing the reply records.</p>
-<h3><code>dnsPromises.resolveSoa(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvesoa_hostname" id="dns_dnspromises_resolvesoa_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveSoa(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvesoa_hostname" id="dns_dnspromises_resolvesoa_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26082,7 +27378,7 @@ following properties:</p>
   <span class="hljs-attr">expire</span>: <span class="hljs-number">604800</span>,
   <span class="hljs-attr">minttl</span>: <span class="hljs-number">3600</span>
 }</code></pre>
-<h3><code>dnsPromises.resolveSrv(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvesrv_hostname" id="dns_dnspromises_resolvesrv_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveSrv(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvesrv_hostname" id="dns_dnspromises_resolvesrv_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26105,7 +27401,7 @@ the following properties:</p>
   <span class="hljs-attr">port</span>: <span class="hljs-number">21223</span>,
   <span class="hljs-attr">name</span>: <span class="hljs-string">'service.example.com'</span>
 }</code></pre>
-<h3><code>dnsPromises.resolveTxt(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvetxt_hostname" id="dns_dnspromises_resolvetxt_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveTxt(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvetxt_hostname" id="dns_dnspromises_resolvetxt_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26118,7 +27414,7 @@ of the text records available for <code>hostname</code> (e.g.
 <code>[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]</code>). Each sub-array contains TXT chunks of
 one record. Depending on the use case, these could be either joined together or
 treated separately.</p>
-<h3><code>dnsPromises.reverse(ip)</code><span><a class="mark" href="#dns_dnspromises_reverse_ip" id="dns_dnspromises_reverse_ip">#</a></span></h3>
+<h4><code>dnsPromises.reverse(ip)</code><span><a class="mark" href="#dns_dnspromises_reverse_ip" id="dns_dnspromises_reverse_ip">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26129,7 +27425,24 @@ treated separately.</p>
 array of host names.</p>
 <p>On error, the <code>Promise</code> is rejected with an <a href="#errors_class_error"><code>Error</code></a> object, where <code>err.code</code>
 is one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
-<h3><code>dnsPromises.setServers(servers)</code><span><a class="mark" href="#dns_dnspromises_setservers_servers" id="dns_dnspromises_setservers_servers">#</a></span></h3>
+<h4><code>dnsPromises.setDefaultResultOrder(order)</code><span><a class="mark" href="#dns_dnspromises_setdefaultresultorder_order" id="dns_dnspromises_setdefaultresultorder_order">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>order</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> must be <code>'ipv4first'</code> or <code>'verbatim'</code>.</li>
+</ul>
+<p>Set the default value of <code>verbatim</code> in <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> and
+<a href="#dns_dnspromises_lookup_hostname_options"><code>dnsPromises.lookup()</code></a>. The value could be:</p>
+<ul>
+<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>
+<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>
+</ul>
+<p>The default is <code>ipv4first</code> and <a href="#dns_dnspromises_setdefaultresultorder_order"><code>dnsPromises.setDefaultResultOrder()</code></a> have
+higher priority than <a href="#cli_dns_result_order_order"><code>--dns-result-order</code></a>. When using <a href="worker_threads.html">worker threads</a>,
+<a href="#dns_dnspromises_setdefaultresultorder_order"><code>dnsPromises.setDefaultResultOrder()</code></a> from the main thread won't affect the
+default dns orders in workers.</p>
+<h4><code>dnsPromises.setServers(servers)</code><span><a class="mark" href="#dns_dnspromises_setservers_servers" id="dns_dnspromises_setservers_servers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -26139,11 +27452,11 @@ is one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
 <p>Sets the IP address and port of servers to be used when performing DNS
 resolution. The <code>servers</code> argument is an array of <a href="https://tools.ietf.org/html/rfc5952#section-6">RFC 5952</a> formatted
 addresses. If the port is the IANA default DNS port (53) it can be omitted.</p>
-<pre><code class="language-js">dnsPromises.setServers([
+<pre><code class="language-js">dnsPromises.<span class="hljs-title function_">setServers</span>([
   <span class="hljs-string">'4.4.4.4'</span>,
   <span class="hljs-string">'[2001:4860:4860::8888]'</span>,
   <span class="hljs-string">'4.4.4.4:1053'</span>,
-  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>
+  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>,
 ]);</code></pre>
 <p>An error will be thrown if an invalid address is provided.</p>
 <p>The <code>dnsPromises.setServers()</code> method must not be called while a DNS query is in
@@ -26154,7 +27467,7 @@ That is, if attempting to resolve with the first server provided results in a
 <code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with
 subsequent servers provided. Fallback DNS servers will only be used if the
 earlier ones time out or result in some other error.</p>
-<h2>Error codes<span><a class="mark" href="#dns_error_codes" id="dns_error_codes">#</a></span></h2>
+</section><section><h3>Error codes<span><a class="mark" href="#dns_error_codes" id="dns_error_codes">#</a></span></h3>
 <p>Each DNS query can return one of the following error codes:</p>
 <ul>
 <li><code>dns.NODATA</code>: DNS server returned answer with no data.</li>
@@ -26182,13 +27495,13 @@ earlier ones time out or result in some other error.</p>
 <li><code>dns.ADDRGETNETWORKPARAMS</code>: Could not find <code>GetNetworkParams</code> function.</li>
 <li><code>dns.CANCELLED</code>: DNS query cancelled.</li>
 </ul>
-<h2>Implementation considerations<span><a class="mark" href="#dns_implementation_considerations" id="dns_implementation_considerations">#</a></span></h2>
+</section><section><h3>Implementation considerations<span><a class="mark" href="#dns_implementation_considerations" id="dns_implementation_considerations">#</a></span></h3>
 <p>Although <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> and the various <code>dns.resolve*()/dns.reverse()</code>
 functions have the same goal of associating a network name with a network
 address (or vice versa), their behavior is quite different. These differences
 can have subtle but significant consequences on the behavior of Node.js
 programs.</p>
-<h3><code>dns.lookup()</code><span><a class="mark" href="#dns_dns_lookup" id="dns_dns_lookup">#</a></span></h3>
+<h4><code>dns.lookup()</code><span><a class="mark" href="#dns_dns_lookup" id="dns_dns_lookup">#</a></span></h4>
 <p>Under the hood, <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> uses the same operating system facilities
 as most other programs. For instance, <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> will almost always
 resolve a given name the same way as the <code>ping</code> command. On most POSIX-like
@@ -26206,7 +27519,7 @@ host names. If that is an issue, consider resolving the host name to an address
 using <code>dns.resolve()</code> and using the address instead of a host name. Also, some
 networking APIs (such as <a href="#net_socket_connect_options_connectlistener"><code>socket.connect()</code></a> and <a href="#dgram_dgram_createsocket_options_callback"><code>dgram.createSocket()</code></a>)
 allow the default resolver, <code>dns.lookup()</code>, to be replaced.</p>
-<h3><code>dns.resolve()</code>, <code>dns.resolve*()</code> and <code>dns.reverse()</code><span><a class="mark" href="#dns_dns_resolve_dns_resolve_and_dns_reverse" id="dns_dns_resolve_dns_resolve_and_dns_reverse">#</a></span></h3>
+<h4><code>dns.resolve()</code>, <code>dns.resolve*()</code> and <code>dns.reverse()</code><span><a class="mark" href="#dns_dns_resolve_dns_resolve_and_dns_reverse" id="dns_dns_resolve_dns_resolve_and_dns_reverse">#</a></span></h4>
 <p>These functions are implemented quite differently than <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>. They
 do not use <a href="http://man7.org/linux/man-pages/man3/getaddrinfo.3.html"><code>getaddrinfo(3)</code></a> and they <em>always</em> perform a DNS query on the
 network. This network communication is always done asynchronously, and does not
@@ -26214,8 +27527,9 @@ use libuv's threadpool.</p>
 <p>As a result, these functions cannot have the same negative impact on other
 processing that happens on libuv's threadpool that <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> can have.</p>
 <p>They do not use the same set of configuration files than what <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>
-uses. For instance, <em>they do not use the configuration from <code>/etc/hosts</code></em>.</p>
-<h1>Domain<span><a class="mark" href="#domain_domain" id="domain_domain">#</a></span></h1>
+uses. For instance, <em>they do not use the configuration from <code>/etc/hosts</code></em>.</p></section>
+        </section>
+<section><h2>Domain<span><a class="mark" href="#domain_domain" id="domain_domain">#</a></span></h2>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -26231,7 +27545,7 @@ uses. For instance, <em>they do not use the configuration from <code>/etc/hosts<
 </div>
 
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/domain.js">lib/domain.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/domain.js">lib/domain.js</a></p>
 <p><strong>This module is pending deprecation</strong>. Once a replacement API has been
 finalized, this module will be fully deprecated. Most developers should
 <strong>not</strong> have cause to use this module. Users who absolutely must have
@@ -26244,7 +27558,7 @@ domain emit an <code>'error'</code> event, or throw an error, then the domain ob
 will be notified, rather than losing the context of the error in the
 <code>process.on('uncaughtException')</code> handler, or causing the program to
 exit immediately with an error code.</p>
-<h2>Warning: Don't ignore errors!<span><a class="mark" href="#domain_warning_don_t_ignore_errors" id="domain_warning_don_t_ignore_errors">#</a></span></h2>
+<section><h3>Warning: Don't ignore errors!<span><a class="mark" href="#domain_warning_don_t_ignore_errors" id="domain_warning_don_t_ignore_errors">#</a></span></h3>
 
 <p>Domain error handlers are not a substitute for closing down a
 process when an error occurs.</p>
@@ -26266,18 +27580,18 @@ the failure, and react accordingly.</p>
 <p>For example, this is not a good idea:</p>
 <pre><code class="language-js"><span class="hljs-comment">// XXX WARNING! BAD IDEA!</span>
 
-<span class="hljs-keyword">const</span> d = <span class="hljs-built_in">require</span>(<span class="hljs-string">'domain'</span>).create();
-d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+<span class="hljs-keyword">const</span> d = <span class="hljs-built_in">require</span>(<span class="hljs-string">'domain'</span>).<span class="hljs-title function_">create</span>();
+d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
   <span class="hljs-comment">// The error won't crash the process, but what it does is worse!</span>
   <span class="hljs-comment">// Though we've prevented abrupt process restarting, we are leaking</span>
-  <span class="hljs-comment">// resources like crazy if this ever happens.</span>
+  <span class="hljs-comment">// a lot of resources if this ever happens.</span>
   <span class="hljs-comment">// This is no better than process.on('uncaughtException')!</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`error, but oh well <span class="hljs-subst">${er.message}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`error, but oh well <span class="hljs-subst">${er.message}</span>`</span>);
 });
-d.run(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>).createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    handleRequest(req, res);
-  }).listen(PORT);
+d.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>).<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    <span class="hljs-title function_">handleRequest</span>(req, res);
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-variable constant_">PORT</span>);
 });</code></pre>
 <p>By using the context of a domain, and the resilience of separating our
 program into multiple worker processes, we can react more
@@ -26285,9 +27599,9 @@ appropriately, and handle errors with much greater safety.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Much better!</span>
 
 <span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
-<span class="hljs-keyword">const</span> PORT = +process.env.PORT || <span class="hljs-number">1337</span>;
+<span class="hljs-keyword">const</span> <span class="hljs-variable constant_">PORT</span> = +process.<span class="hljs-property">env</span>.<span class="hljs-property">PORT</span> || <span class="hljs-number">1337</span>;
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
   <span class="hljs-comment">// A more realistic scenario would have more than 2 workers,</span>
   <span class="hljs-comment">// and perhaps not put the master and worker in the same file.</span>
   <span class="hljs-comment">//</span>
@@ -26300,12 +27614,12 @@ appropriately, and handle errors with much greater safety.</p>
   <span class="hljs-comment">// The important thing is that the master does very little,</span>
   <span class="hljs-comment">// increasing our resilience to unexpected errors.</span>
 
-  cluster.fork();
-  cluster.fork();
+  cluster.<span class="hljs-title function_">fork</span>();
+  cluster.<span class="hljs-title function_">fork</span>();
 
-  cluster.on(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'disconnect!'</span>);
-    cluster.fork();
+  cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'disconnect!'</span>);
+    cluster.<span class="hljs-title function_">fork</span>();
   });
 
 } <span class="hljs-keyword">else</span> {
@@ -26318,10 +27632,10 @@ appropriately, and handle errors with much greater safety.</p>
   <span class="hljs-comment">// See the cluster documentation for more details about using</span>
   <span class="hljs-comment">// worker processes to serve requests. How it works, caveats, etc.</span>
 
-  <span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>).createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    <span class="hljs-keyword">const</span> d = domain.create();
-    d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`error <span class="hljs-subst">${er.stack}</span>`</span>);
+  <span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>).<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    <span class="hljs-keyword">const</span> d = domain.<span class="hljs-title function_">create</span>();
+    d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`error <span class="hljs-subst">${er.stack}</span>`</span>);
 
       <span class="hljs-comment">// We're in dangerous territory!</span>
       <span class="hljs-comment">// By definition, something unexpected occurred,</span>
@@ -26331,59 +27645,59 @@ appropriately, and handle errors with much greater safety.</p>
       <span class="hljs-keyword">try</span> {
         <span class="hljs-comment">// Make sure we close down within 30 seconds</span>
         <span class="hljs-keyword">const</span> killtimer = <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-          process.exit(<span class="hljs-number">1</span>);
+          process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">1</span>);
         }, <span class="hljs-number">30000</span>);
         <span class="hljs-comment">// But don't keep the process open just for that!</span>
-        killtimer.unref();
+        killtimer.<span class="hljs-title function_">unref</span>();
 
         <span class="hljs-comment">// Stop taking new requests.</span>
-        server.close();
+        server.<span class="hljs-title function_">close</span>();
 
         <span class="hljs-comment">// Let the master know we're dead. This will trigger a</span>
         <span class="hljs-comment">// 'disconnect' in the cluster master, and then it will fork</span>
         <span class="hljs-comment">// a new worker.</span>
-        cluster.worker.disconnect();
+        cluster.<span class="hljs-property">worker</span>.<span class="hljs-title function_">disconnect</span>();
 
         <span class="hljs-comment">// Try to send an error to the request that triggered the problem</span>
-        res.statusCode = <span class="hljs-number">500</span>;
-        res.setHeader(<span class="hljs-string">'content-type'</span>, <span class="hljs-string">'text/plain'</span>);
-        res.end(<span class="hljs-string">'Oops, there was a problem!\n'</span>);
+        res.<span class="hljs-property">statusCode</span> = <span class="hljs-number">500</span>;
+        res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'content-type'</span>, <span class="hljs-string">'text/plain'</span>);
+        res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Oops, there was a problem!\n'</span>);
       } <span class="hljs-keyword">catch</span> (er2) {
         <span class="hljs-comment">// Oh well, not much we can do at this point.</span>
-        <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`Error sending 500! <span class="hljs-subst">${er2.stack}</span>`</span>);
+        <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`Error sending 500! <span class="hljs-subst">${er2.stack}</span>`</span>);
       }
     });
 
     <span class="hljs-comment">// Because req and res were created before this domain existed,</span>
     <span class="hljs-comment">// we need to explicitly add them.</span>
     <span class="hljs-comment">// See the explanation of implicit vs explicit binding below.</span>
-    d.add(req);
-    d.add(res);
+    d.<span class="hljs-title function_">add</span>(req);
+    d.<span class="hljs-title function_">add</span>(res);
 
     <span class="hljs-comment">// Now run the handler function in the domain.</span>
-    d.run(<span class="hljs-function">() =></span> {
-      handleRequest(req, res);
+    d.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+      <span class="hljs-title function_">handleRequest</span>(req, res);
     });
   });
-  server.listen(PORT);
+  server.<span class="hljs-title function_">listen</span>(<span class="hljs-variable constant_">PORT</span>);
 }
 
 <span class="hljs-comment">// This part is not important. Just an example routing thing.</span>
 <span class="hljs-comment">// Put fancy application logic here.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">handleRequest</span>(<span class="hljs-params">req, res</span>) </span>{
-  <span class="hljs-keyword">switch</span> (req.url) {
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">handleRequest</span>(<span class="hljs-params">req, res</span>) {
+  <span class="hljs-keyword">switch</span> (req.<span class="hljs-property">url</span>) {
     <span class="hljs-keyword">case</span> <span class="hljs-string">'/error'</span>:
       <span class="hljs-comment">// We do some async stuff, and then...</span>
       <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
         <span class="hljs-comment">// Whoops!</span>
-        flerb.bark();
+        flerb.<span class="hljs-title function_">bark</span>();
       }, timeout);
       <span class="hljs-keyword">break</span>;
-    <span class="hljs-keyword">default</span>:
-      res.end(<span class="hljs-string">'ok'</span>);
+    <span class="hljs-attr">default</span>:
+      res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
   }
 }</code></pre>
-<h2>Additions to <code>Error</code> objects<span><a class="mark" href="#domain_additions_to_error_objects" id="domain_additions_to_error_objects">#</a></span></h2>
+</section><section><h3>Additions to <code>Error</code> objects<span><a class="mark" href="#domain_additions_to_error_objects" id="domain_additions_to_error_objects">#</a></span></h3>
 
 <p>Any time an <code>Error</code> object is routed through a domain, a few extra fields
 are added to it.</p>
@@ -26396,7 +27710,7 @@ domain, and passed an error as its first argument.</li>
 <li><code>error.domainThrown</code> A boolean indicating whether the error was
 thrown, emitted, or passed to a bound callback function.</li>
 </ul>
-<h2>Implicit binding<span><a class="mark" href="#domain_implicit_binding" id="domain_implicit_binding">#</a></span></h2>
+</section><section><h3>Implicit binding<span><a class="mark" href="#domain_implicit_binding" id="domain_implicit_binding">#</a></span></h3>
 
 <p>If domains are in use, then all <strong>new</strong> <code>EventEmitter</code> objects (including
 Stream objects, requests, responses, etc.) will be implicitly bound to
@@ -26415,7 +27729,7 @@ explicitly added.</p>
 <code>Domain</code>'s <code>'error'</code> event, but does not register the <code>EventEmitter</code> on the
 <code>Domain</code>.
 Implicit binding only takes care of thrown errors and <code>'error'</code> events.</p>
-<h2>Explicit binding<span><a class="mark" href="#domain_explicit_binding" id="domain_explicit_binding">#</a></span></h2>
+</section><section><h3>Explicit binding<span><a class="mark" href="#domain_explicit_binding" id="domain_explicit_binding">#</a></span></h3>
 
 <p>Sometimes, the domain in use is not the one that ought to be used for a
 specific event emitter. Or, the event emitter could have been created
@@ -26427,46 +27741,46 @@ perhaps we would like to have a separate domain to use for each request.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a top-level domain for the server</span>
 <span class="hljs-keyword">const</span> domain = <span class="hljs-built_in">require</span>(<span class="hljs-string">'domain'</span>);
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> serverDomain = domain.create();
+<span class="hljs-keyword">const</span> serverDomain = domain.<span class="hljs-title function_">create</span>();
 
-serverDomain.run(<span class="hljs-function">() =></span> {
+serverDomain.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Server is created in the scope of serverDomain</span>
-  http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
     <span class="hljs-comment">// Req and res are also created in the scope of serverDomain</span>
     <span class="hljs-comment">// however, we'd prefer to have a separate domain for each request.</span>
     <span class="hljs-comment">// create it first thing, and add req and res to it.</span>
-    <span class="hljs-keyword">const</span> reqd = domain.create();
-    reqd.add(req);
-    reqd.add(res);
-    reqd.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Error'</span>, er, req.url);
+    <span class="hljs-keyword">const</span> reqd = domain.<span class="hljs-title function_">create</span>();
+    reqd.<span class="hljs-title function_">add</span>(req);
+    reqd.<span class="hljs-title function_">add</span>(res);
+    reqd.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Error'</span>, er, req.<span class="hljs-property">url</span>);
       <span class="hljs-keyword">try</span> {
-        res.writeHead(<span class="hljs-number">500</span>);
-        res.end(<span class="hljs-string">'Error occurred, sorry.'</span>);
+        res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">500</span>);
+        res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Error occurred, sorry.'</span>);
       } <span class="hljs-keyword">catch</span> (er2) {
-        <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Error sending 500'</span>, er2, req.url);
+        <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Error sending 500'</span>, er2, req.<span class="hljs-property">url</span>);
       }
     });
-  }).listen(<span class="hljs-number">1337</span>);
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);
 });</code></pre>
-<h2><code>domain.create()</code><span><a class="mark" href="#domain_domain_create" id="domain_domain_create">#</a></span></h2>
+</section><section><h3><code>domain.create()</code><span><a class="mark" href="#domain_domain_create" id="domain_domain_create">#</a></span></h3>
 <ul>
 <li>Returns: <a href="#domain_class_domain" class="type">&#x3C;Domain></a></li>
 </ul>
-<h2>Class: <code>Domain</code><span><a class="mark" href="#domain_class_domain" id="domain_class_domain">#</a></span></h2>
+</section><section><h3>Class: <code>Domain</code><span><a class="mark" href="#domain_class_domain" id="domain_class_domain">#</a></span></h3>
 <ul>
 <li>Extends: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
 <p>The <code>Domain</code> class encapsulates the functionality of routing errors and
 uncaught exceptions to the active <code>Domain</code> object.</p>
 <p>To handle the errors that it catches, listen to its <code>'error'</code> event.</p>
-<h3><code>domain.members</code><span><a class="mark" href="#domain_domain_members" id="domain_domain_members">#</a></span></h3>
+<h4><code>domain.members</code><span><a class="mark" href="#domain_domain_members" id="domain_domain_members">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
 </ul>
 <p>An array of timers and event emitters that have been explicitly added
 to the domain.</p>
-<h3><code>domain.add(emitter)</code><span><a class="mark" href="#domain_domain_add_emitter" id="domain_domain_add_emitter">#</a></span></h3>
+<h4><code>domain.add(emitter)</code><span><a class="mark" href="#domain_domain_add_emitter" id="domain_domain_add_emitter">#</a></span></h4>
 <ul>
 <li><code>emitter</code> <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> | <a href="#timers_timers" class="type">&#x3C;Timer></a> emitter or timer to be added to the domain</li>
 </ul>
@@ -26479,7 +27793,7 @@ binding.</p>
 the domain <code>'error'</code> handler.</p>
 <p>If the Timer or <code>EventEmitter</code> was already bound to a domain, it is removed
 from that one, and bound to this one instead.</p>
-<h3><code>domain.bind(callback)</code><span><a class="mark" href="#domain_domain_bind_callback" id="domain_domain_bind_callback">#</a></span></h3>
+<h4><code>domain.bind(callback)</code><span><a class="mark" href="#domain_domain_bind_callback" id="domain_domain_bind_callback">#</a></span></h4>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The bound function</li>
@@ -26487,20 +27801,20 @@ from that one, and bound to this one instead.</p>
 <p>The returned function will be a wrapper around the supplied callback
 function. When the returned function is called, any errors that are
 thrown will be routed to the domain's <code>'error'</code> event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> d = domain.create();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> d = domain.<span class="hljs-title function_">create</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">readSomeFile</span>(<span class="hljs-params">filename, cb</span>) </span>{
-  fs.readFile(filename, <span class="hljs-string">'utf8'</span>, d.bind(<span class="hljs-function">(<span class="hljs-params">er, data</span>) =></span> {
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">readSomeFile</span>(<span class="hljs-params">filename, cb</span>) {
+  fs.<span class="hljs-title function_">readFile</span>(filename, <span class="hljs-string">'utf8'</span>, d.<span class="hljs-title function_">bind</span>(<span class="hljs-function">(<span class="hljs-params">er, data</span>) =></span> {
     <span class="hljs-comment">// If this throws, it will also be passed to the domain.</span>
-    <span class="hljs-keyword">return</span> cb(er, data ? <span class="hljs-built_in">JSON</span>.parse(data) : <span class="hljs-literal">null</span>);
+    <span class="hljs-keyword">return</span> <span class="hljs-title function_">cb</span>(er, data ? <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(data) : <span class="hljs-literal">null</span>);
   }));
 }
 
-d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
   <span class="hljs-comment">// An error occurred somewhere. If we throw it now, it will crash the program</span>
   <span class="hljs-comment">// with the normal line number and stack message.</span>
 });</code></pre>
-<h3><code>domain.enter()</code><span><a class="mark" href="#domain_domain_enter" id="domain_domain_enter">#</a></span></h3>
+<h4><code>domain.enter()</code><span><a class="mark" href="#domain_domain_enter" id="domain_domain_enter">#</a></span></h4>
 <p>The <code>enter()</code> method is plumbing used by the <code>run()</code>, <code>bind()</code>, and
 <code>intercept()</code> methods to set the active domain. It sets <code>domain.active</code> and
 <code>process.domain</code> to the domain, and implicitly pushes the domain onto the domain
@@ -26510,7 +27824,7 @@ asynchronous calls and I/O operations bound to a domain.</p>
 <p>Calling <code>enter()</code> changes only the active domain, and does not alter the domain
 itself. <code>enter()</code> and <code>exit()</code> can be called an arbitrary number of times on a
 single domain.</p>
-<h3><code>domain.exit()</code><span><a class="mark" href="#domain_domain_exit" id="domain_domain_exit">#</a></span></h3>
+<h4><code>domain.exit()</code><span><a class="mark" href="#domain_domain_exit" id="domain_domain_exit">#</a></span></h4>
 <p>The <code>exit()</code> method exits the current domain, popping it off the domain stack.
 Any time execution is going to switch to the context of a different chain of
 asynchronous calls, it's important to ensure that the current domain is exited.
@@ -26521,7 +27835,7 @@ of asynchronous calls and I/O operations bound to a domain.</p>
 <p>Calling <code>exit()</code> changes only the active domain, and does not alter the domain
 itself. <code>enter()</code> and <code>exit()</code> can be called an arbitrary number of times on a
 single domain.</p>
-<h3><code>domain.intercept(callback)</code><span><a class="mark" href="#domain_domain_intercept_callback" id="domain_domain_intercept_callback">#</a></span></h3>
+<h4><code>domain.intercept(callback)</code><span><a class="mark" href="#domain_domain_intercept_callback" id="domain_domain_intercept_callback">#</a></span></h4>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The intercepted function</li>
@@ -26531,10 +27845,10 @@ addition to catching thrown errors, it will also intercept <a href="#errors_clas
 objects sent as the first argument to the function.</p>
 <p>In this way, the common <code>if (err) return callback(err);</code> pattern can be replaced
 with a single error handler in a single place.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> d = domain.create();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> d = domain.<span class="hljs-title function_">create</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">readSomeFile</span>(<span class="hljs-params">filename, cb</span>) </span>{
-  fs.readFile(filename, <span class="hljs-string">'utf8'</span>, d.intercept(<span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">readSomeFile</span>(<span class="hljs-params">filename, cb</span>) {
+  fs.<span class="hljs-title function_">readFile</span>(filename, <span class="hljs-string">'utf8'</span>, d.<span class="hljs-title function_">intercept</span>(<span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
     <span class="hljs-comment">// Note, the first argument is never passed to the</span>
     <span class="hljs-comment">// callback since it is assumed to be the 'Error' argument</span>
     <span class="hljs-comment">// and thus intercepted by the domain.</span>
@@ -26543,21 +27857,21 @@ with a single error handler in a single place.</p>
     <span class="hljs-comment">// so the error-handling logic can be moved to the 'error'</span>
     <span class="hljs-comment">// event on the domain instead of being repeated throughout</span>
     <span class="hljs-comment">// the program.</span>
-    <span class="hljs-keyword">return</span> cb(<span class="hljs-literal">null</span>, <span class="hljs-built_in">JSON</span>.parse(data));
+    <span class="hljs-keyword">return</span> <span class="hljs-title function_">cb</span>(<span class="hljs-literal">null</span>, <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(data));
   }));
 }
 
-d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
   <span class="hljs-comment">// An error occurred somewhere. If we throw it now, it will crash the program</span>
   <span class="hljs-comment">// with the normal line number and stack message.</span>
 });</code></pre>
-<h3><code>domain.remove(emitter)</code><span><a class="mark" href="#domain_domain_remove_emitter" id="domain_domain_remove_emitter">#</a></span></h3>
+<h4><code>domain.remove(emitter)</code><span><a class="mark" href="#domain_domain_remove_emitter" id="domain_domain_remove_emitter">#</a></span></h4>
 <ul>
 <li><code>emitter</code> <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> | <a href="#timers_timers" class="type">&#x3C;Timer></a> emitter or timer to be removed from the domain</li>
 </ul>
 <p>The opposite of <a href="#domain_domain_add_emitter"><code>domain.add(emitter)</code></a>. Removes domain handling from the
 specified emitter.</p>
-<h3><code>domain.run(fn[, ...args])</code><span><a class="mark" href="#domain_domain_run_fn_args" id="domain_domain_run_fn_args">#</a></span></h3>
+<h4><code>domain.run(fn[, ...args])</code><span><a class="mark" href="#domain_domain_run_fn_args" id="domain_domain_run_fn_args">#</a></span></h4>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
@@ -26569,14 +27883,14 @@ the function.</p>
 <p>This is the most basic way to use a domain.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> domain = <span class="hljs-built_in">require</span>(<span class="hljs-string">'domain'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> d = domain.create();
-d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Caught error!'</span>, er);
+<span class="hljs-keyword">const</span> d = domain.<span class="hljs-title function_">create</span>();
+d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Caught error!'</span>, er);
 });
-d.run(<span class="hljs-function">() =></span> {
-  process.nextTick(<span class="hljs-function">() =></span> {
+d.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
     <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> { <span class="hljs-comment">// Simulating some various async stuff</span>
-      fs.open(<span class="hljs-string">'non-existent file'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">er, fd</span>) =></span> {
+      fs.<span class="hljs-title function_">open</span>(<span class="hljs-string">'non-existent file'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">er, fd</span>) =></span> {
         <span class="hljs-keyword">if</span> (er) <span class="hljs-keyword">throw</span> er;
         <span class="hljs-comment">// proceed...</span>
       });
@@ -26585,40 +27899,41 @@ d.run(<span class="hljs-function">() =></span> {
 });</code></pre>
 <p>In this example, the <code>d.on('error')</code> handler will be triggered, rather
 than crashing the program.</p>
-<h2>Domains and promises<span><a class="mark" href="#domain_domains_and_promises" id="domain_domains_and_promises">#</a></span></h2>
+</section><section><h3>Domains and promises<span><a class="mark" href="#domain_domains_and_promises" id="domain_domains_and_promises">#</a></span></h3>
 <p>As of Node.js 8.0.0, the handlers of promises are run inside the domain in
 which the call to <code>.then()</code> or <code>.catch()</code> itself was made:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> d1 = domain.create();
-<span class="hljs-keyword">const</span> d2 = domain.create();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> d1 = domain.<span class="hljs-title function_">create</span>();
+<span class="hljs-keyword">const</span> d2 = domain.<span class="hljs-title function_">create</span>();
 
 <span class="hljs-keyword">let</span> p;
-d1.run(<span class="hljs-function">() =></span> {
-  p = <span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">42</span>);
+d1.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  p = <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">42</span>);
 });
 
-d2.run(<span class="hljs-function">() =></span> {
-  p.then(<span class="hljs-function">(<span class="hljs-params">v</span>) =></span> {
+d2.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  p.<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">v</span>) =></span> {
     <span class="hljs-comment">// running in d2</span>
   });
 });</code></pre>
 <p>A callback may be bound to a specific domain using <a href="#domain_domain_bind_callback"><code>domain.bind(callback)</code></a>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> d1 = domain.create();
-<span class="hljs-keyword">const</span> d2 = domain.create();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> d1 = domain.<span class="hljs-title function_">create</span>();
+<span class="hljs-keyword">const</span> d2 = domain.<span class="hljs-title function_">create</span>();
 
 <span class="hljs-keyword">let</span> p;
-d1.run(<span class="hljs-function">() =></span> {
-  p = <span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">42</span>);
+d1.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  p = <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">42</span>);
 });
 
-d2.run(<span class="hljs-function">() =></span> {
-  p.then(p.domain.bind(<span class="hljs-function">(<span class="hljs-params">v</span>) =></span> {
+d2.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  p.<span class="hljs-title function_">then</span>(p.<span class="hljs-property">domain</span>.<span class="hljs-title function_">bind</span>(<span class="hljs-function">(<span class="hljs-params">v</span>) =></span> {
     <span class="hljs-comment">// running in d1</span>
   }));
 });</code></pre>
 <p>Domains will not interfere with the error handling mechanisms for
 promises. In other words, no <code>'error'</code> event will be emitted for unhandled
-<code>Promise</code> rejections.</p>
-<h1>Errors<span><a class="mark" href="#errors_errors" id="errors_errors">#</a></span></h1>
+<code>Promise</code> rejections.</p></section>
+        </section>
+<section><h2>Errors<span><a class="mark" href="#errors_errors" id="errors_errors">#</a></span></h2>
 
 
 <p>Applications running in Node.js will generally experience four categories of
@@ -26637,7 +27952,7 @@ are raised typically by the <code>assert</code> module.</li>
 <p>All JavaScript and system errors raised by Node.js inherit from, or are
 instances of, the standard JavaScript <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> class and are guaranteed
 to provide <em>at least</em> the properties available on that class.</p>
-<h2>Error propagation and interception<span><a class="mark" href="#errors_error_propagation_and_interception" id="errors_error_propagation_and_interception">#</a></span></h2>
+<section><h3>Error propagation and interception<span><a class="mark" href="#errors_error_propagation_and_interception" id="errors_error_propagation_and_interception">#</a></span></h3>
 
 <p>Node.js supports several mechanisms for propagating and handling errors that
 occur while an application is running. How these errors are reported and
@@ -26669,9 +27984,9 @@ that should be handled.</li>
 </ul>
 <!-- eslint-disable no-useless-return -->
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-fs.readFile(<span class="hljs-string">'a file that does not exist'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+fs.<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'a file that does not exist'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'There was an error reading the file!'</span>, err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'There was an error reading the file!'</span>, err);
     <span class="hljs-keyword">return</span>;
   }
   <span class="hljs-comment">// Otherwise handle the data</span>
@@ -26681,17 +27996,17 @@ fs.readFile(<span class="hljs-string">'a file that does not exist'</span>, <span
 <p>When an asynchronous method is called on an object that is an
 <a href="#events_class_eventemitter"><code>EventEmitter</code></a>, errors can be routed to that object's <code>'error'</code> event.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-<span class="hljs-keyword">const</span> connection = net.connect(<span class="hljs-string">'localhost'</span>);
+<span class="hljs-keyword">const</span> connection = net.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'localhost'</span>);
 
 <span class="hljs-comment">// Adding an 'error' event handler to a stream:</span>
-connection.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+connection.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-comment">// If the connection is reset by the server, or if it can't</span>
   <span class="hljs-comment">// connect at all, or on any sort of error encountered by</span>
   <span class="hljs-comment">// the connection, the error will be sent here.</span>
-  <span class="hljs-built_in">console</span>.error(err);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
 });
 
-connection.pipe(process.stdout);</code></pre>
+connection.<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
 </li>
 <li>
 <p>A handful of typically asynchronous methods in the Node.js API may still
@@ -26710,19 +28025,19 @@ provided, the error will be thrown, causing the Node.js process to report an
 uncaught exception and crash unless either: The <a href="domain.html"><code>domain</code></a> module is
 used appropriately or a handler has been registered for the
 <a href="#process_event_uncaughtexception"><code>'uncaughtException'</code></a> event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-setImmediate(<span class="hljs-function">() =></span> {
+<span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// This will crash the process because no 'error' event</span>
   <span class="hljs-comment">// handler has been added.</span>
-  ee.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'This will crash'</span>));
+  ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'This will crash'</span>));
 });</code></pre>
 <p>Errors generated in this way <em>cannot</em> be intercepted using <code>try…catch</code> as
 they are thrown <em>after</em> the calling code has already exited.</p>
 <p>Developers must refer to the documentation for each method to determine
 exactly how errors raised by those methods are propagated.</p>
-<h3>Error-first callbacks<span><a class="mark" href="#errors_error_first_callbacks" id="errors_error_first_callbacks">#</a></span></h3>
+<h4>Error-first callbacks<span><a class="mark" href="#errors_error_first_callbacks" id="errors_error_first_callbacks">#</a></span></h4>
 
 <p>Most asynchronous methods exposed by the Node.js core API follow an idiomatic
 pattern referred to as an <em>error-first callback</em>. With this pattern, a callback
@@ -26732,16 +28047,16 @@ completes or an error is raised, the callback function is called with the
 the first argument will be passed as <code>null</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">errorFirstCallback</span>(<span class="hljs-params">err, data</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">errorFirstCallback</span>(<span class="hljs-params">err, data</span>) {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'There was an error'</span>, err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'There was an error'</span>, err);
     <span class="hljs-keyword">return</span>;
   }
-  <span class="hljs-built_in">console</span>.log(data);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
 }
 
-fs.readFile(<span class="hljs-string">'/some/file/that/does-not-exist'</span>, errorFirstCallback);
-fs.readFile(<span class="hljs-string">'/some/file/that/does-exist'</span>, errorFirstCallback);</code></pre>
+fs.<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/some/file/that/does-not-exist'</span>, errorFirstCallback);
+fs.<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/some/file/that/does-exist'</span>, errorFirstCallback);</code></pre>
 <p>The JavaScript <code>try…catch</code> mechanism <strong>cannot</strong> be used to intercept errors
 generated by asynchronous APIs. A common mistake for beginners is to try to
 use <code>throw</code> inside an error-first callback:</p>
@@ -26749,7 +28064,7 @@ use <code>throw</code> inside an error-first callback:</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">try</span> {
-  fs.readFile(<span class="hljs-string">'/some/file/that/does-not-exist'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+  fs.<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/some/file/that/does-not-exist'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
     <span class="hljs-comment">// Mistaken assumption: throwing here...</span>
     <span class="hljs-keyword">if</span> (err) {
       <span class="hljs-keyword">throw</span> err;
@@ -26757,7 +28072,7 @@ use <code>throw</code> inside an error-first callback:</p>
   });
 } <span class="hljs-keyword">catch</span> (err) {
   <span class="hljs-comment">// This will not catch the throw!</span>
-  <span class="hljs-built_in">console</span>.error(err);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
 }</code></pre>
 <p>This will not work because the callback function passed to <code>fs.readFile()</code> is
 called asynchronously. By the time the callback has been called, the
@@ -26765,7 +28080,7 @@ surrounding code, including the <code>try…catch</code> block, will have alread
 Throwing an error inside the callback <strong>can crash the Node.js process</strong> in most
 cases. If <a href="domain.html">domains</a> are enabled, or a handler has been registered with
 <code>process.on('uncaughtException')</code>, such errors can be intercepted.</p>
-<h2>Class: <code>Error</code><span><a class="mark" href="#errors_class_error" id="errors_class_error">#</a></span></h2>
+</section><section><h3>Class: <code>Error</code><span><a class="mark" href="#errors_class_error" id="errors_class_error">#</a></span></h3>
 
 <p>A generic JavaScript <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> object that does not denote any specific
 circumstance of why the error occurred. <code>Error</code> objects capture a "stack trace"
@@ -26773,7 +28088,7 @@ detailing the point in the code at which the <code>Error</code> was instantiated
 provide a text description of the error.</p>
 <p>All errors generated by Node.js, including all system and JavaScript errors,
 will either be instances of, or inherit from, the <code>Error</code> class.</p>
-<h3><code>new Error(message)</code><span><a class="mark" href="#errors_new_error_message" id="errors_new_error_message">#</a></span></h3>
+<h4><code>new Error(message)</code><span><a class="mark" href="#errors_new_error_message" id="errors_new_error_message">#</a></span></h4>
 <ul>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -26784,7 +28099,7 @@ represent the point in the code at which <code>new Error()</code> was called. St
 are dependent on <a href="https://github.com/v8/v8/wiki/Stack-Trace-API">V8's stack trace API</a>. Stack traces extend only to either
 (a) the beginning of <em>synchronous code execution</em>, or (b) the number of frames
 given by the property <code>Error.stackTraceLimit</code>, whichever is smaller.</p>
-<h3><code>Error.captureStackTrace(targetObject[, constructorOpt])</code><span><a class="mark" href="#errors_error_capturestacktrace_targetobject_constructoropt" id="errors_error_capturestacktrace_targetobject_constructoropt">#</a></span></h3>
+<h4><code>Error.captureStackTrace(targetObject[, constructorOpt])</code><span><a class="mark" href="#errors_error_capturestacktrace_targetobject_constructoropt" id="errors_error_capturestacktrace_targetobject_constructoropt">#</a></span></h4>
 <ul>
 <li><code>targetObject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>constructorOpt</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
@@ -26793,8 +28108,8 @@ given by the property <code>Error.stackTraceLimit</code>, whichever is smaller.<
 a string representing the location in the code at which
 <code>Error.captureStackTrace()</code> was called.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> myObject = {};
-<span class="hljs-built_in">Error</span>.captureStackTrace(myObject);
-myObject.stack;  <span class="hljs-comment">// Similar to `new Error().stack`</span></code></pre>
+<span class="hljs-title class_">Error</span>.<span class="hljs-title function_">captureStackTrace</span>(myObject);
+myObject.<span class="hljs-property">stack</span>;  <span class="hljs-comment">// Similar to `new Error().stack`</span></code></pre>
 <p>The first line of the trace will be prefixed with
 <code>${myObject.name}: ${myObject.message}</code>.</p>
 <p>The optional <code>constructorOpt</code> argument accepts a function. If given, all frames
@@ -26802,15 +28117,15 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
 generated stack trace.</p>
 <p>The <code>constructorOpt</code> argument is useful for hiding implementation
 details of error generation from the user. For instance:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyError</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">Error</span>.captureStackTrace(<span class="hljs-built_in">this</span>, MyError);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">MyError</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-title class_">Error</span>.<span class="hljs-title function_">captureStackTrace</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-title class_">MyError</span>);
 }
 
 <span class="hljs-comment">// Without passing MyError to captureStackTrace, the MyError</span>
 <span class="hljs-comment">// frame would show up in the .stack property. By passing</span>
 <span class="hljs-comment">// the constructor, we omit that frame, and retain all frames below it.</span>
-<span class="hljs-keyword">new</span> MyError().stack;</code></pre>
-<h3><code>Error.stackTraceLimit</code><span><a class="mark" href="#errors_error_stacktracelimit" id="errors_error_stacktracelimit">#</a></span></h3>
+<span class="hljs-keyword">new</span> <span class="hljs-title class_">MyError</span>().<span class="hljs-property">stack</span>;</code></pre>
+<h4><code>Error.stackTraceLimit</code><span><a class="mark" href="#errors_error_stacktracelimit" id="errors_error_stacktracelimit">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
@@ -26821,7 +28136,7 @@ collected by a stack trace (whether generated by <code>new Error().stack</code>
 will affect any stack trace captured <em>after</em> the value has been changed.</p>
 <p>If set to a non-number value, or set to a negative number, stack traces will
 not capture any frames.</p>
-<h3><code>error.code</code><span><a class="mark" href="#errors_error_code" id="errors_error_code">#</a></span></h3>
+<h4><code>error.code</code><span><a class="mark" href="#errors_error_code" id="errors_error_code">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -26830,7 +28145,7 @@ not capture any frames.</p>
 between major versions of Node.js. In contrast, <code>error.message</code> strings may
 change between any versions of Node.js. See <a href="#nodejs-error-codes">Node.js error codes</a> for details
 about specific codes.</p>
-<h3><code>error.message</code><span><a class="mark" href="#errors_error_message" id="errors_error_message">#</a></span></h3>
+<h4><code>error.message</code><span><a class="mark" href="#errors_error_message" id="errors_error_message">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -26840,10 +28155,10 @@ appear in the first line of the stack trace of the <code>Error</code>, however c
 this property after the <code>Error</code> object is created <em>may not</em> change the first
 line of the stack trace (for example, when <code>error.stack</code> is read before this
 property is changed).</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'The message'</span>);
-<span class="hljs-built_in">console</span>.error(err.message);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'The message'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err.<span class="hljs-property">message</span>);
 <span class="hljs-comment">// Prints: The message</span></code></pre>
-<h3><code>error.stack</code><span><a class="mark" href="#errors_error_stack" id="errors_error_stack">#</a></span></h3>
+<h4><code>error.stack</code><span><a class="mark" href="#errors_error_stack" id="errors_error_stack">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -26869,14 +28184,14 @@ itself calls a JavaScript function, the frame representing the <code>cheetahify<
 will not be present in the stack traces:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cheetahify = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./native-binding.node'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">makeFaster</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">makeFaster</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// `cheetahify()` *synchronously* calls speedy.</span>
-  cheetahify(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">speedy</span>(<span class="hljs-params"></span>) </span>{
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'oh no!'</span>);
+  <span class="hljs-title function_">cheetahify</span>(<span class="hljs-keyword">function</span> <span class="hljs-title function_">speedy</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'oh no!'</span>);
   });
 }
 
-makeFaster();
+<span class="hljs-title function_">makeFaster</span>();
 <span class="hljs-comment">// will throw:</span>
 <span class="hljs-comment">//   /home/gbusey/file.js:6</span>
 <span class="hljs-comment">//       throw new Error('oh no!');</span>
@@ -26905,24 +28220,24 @@ a user program, or its dependencies.</li>
 <p>The number of frames captured by the stack trace is bounded by the smaller of
 <code>Error.stackTraceLimit</code> or the number of available frames on the current event
 loop tick.</p>
-<h2>Class: <code>AssertionError</code><span><a class="mark" href="#errors_class_assertionerror" id="errors_class_assertionerror">#</a></span></h2>
+</section><section><h3>Class: <code>AssertionError</code><span><a class="mark" href="#errors_class_assertionerror" id="errors_class_assertionerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
 <p>Indicates the failure of an assertion. For details, see
 <a href="#assert_class_assert_assertionerror"><code>Class: assert.AssertionError</code></a>.</p>
-<h2>Class: <code>RangeError</code><span><a class="mark" href="#errors_class_rangeerror" id="errors_class_rangeerror">#</a></span></h2>
+</section><section><h3>Class: <code>RangeError</code><span><a class="mark" href="#errors_class_rangeerror" id="errors_class_rangeerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
 <p>Indicates that a provided argument was not within the set or range of
 acceptable values for a function; whether that is a numeric range, or
 outside the set of options for a given function parameter.</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).connect(<span class="hljs-number">-1</span>);
+<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-title function_">connect</span>(-<span class="hljs-number">1</span>);
 <span class="hljs-comment">// Throws "RangeError: "port" option should be >= 0 and &#x3C; 65536: -1"</span></code></pre>
 <p>Node.js will generate and throw <code>RangeError</code> instances <em>immediately</em> as a form
 of argument validation.</p>
-<h2>Class: <code>ReferenceError</code><span><a class="mark" href="#errors_class_referenceerror" id="errors_class_referenceerror">#</a></span></h2>
+</section><section><h3>Class: <code>ReferenceError</code><span><a class="mark" href="#errors_class_referenceerror" id="errors_class_referenceerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
@@ -26935,7 +28250,7 @@ will do so.</p>
 <span class="hljs-comment">// Throws ReferenceError, doesNotExist is not a variable in this program.</span></code></pre>
 <p>Unless an application is dynamically generating and running code,
 <code>ReferenceError</code> instances indicate a bug in the code or its dependencies.</p>
-<h2>Class: <code>SyntaxError</code><span><a class="mark" href="#errors_class_syntaxerror" id="errors_class_syntaxerror">#</a></span></h2>
+</section><section><h3>Class: <code>SyntaxError</code><span><a class="mark" href="#errors_class_syntaxerror" id="errors_class_syntaxerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
@@ -26944,13 +28259,13 @@ generated and propagated as a result of code evaluation. Code evaluation may
 happen as a result of <code>eval</code>, <code>Function</code>, <code>require</code>, or <a href="vm.html">vm</a>. These errors
 are almost always indicative of a broken program.</p>
 <pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>).runInThisContext(<span class="hljs-string">'binary ! isNotOk'</span>);
+  <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>).<span class="hljs-title function_">runInThisContext</span>(<span class="hljs-string">'binary ! isNotOk'</span>);
 } <span class="hljs-keyword">catch</span> (err) {
   <span class="hljs-comment">// 'err' will be a SyntaxError.</span>
 }</code></pre>
 <p><code>SyntaxError</code> instances are unrecoverable in the context that created them –
 they may only be caught by other contexts.</p>
-<h2>Class: <code>SystemError</code><span><a class="mark" href="#errors_class_systemerror" id="errors_class_systemerror">#</a></span></h2>
+</section><section><h3>Class: <code>SystemError</code><span><a class="mark" href="#errors_class_systemerror" id="errors_class_systemerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
@@ -26964,65 +28279,65 @@ failed</li>
 <li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The string error code</li>
 <li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If present, the file path destination when reporting a file
 system error</li>
-<li><code>errno</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The system-provided error number</li>
+<li><code>errno</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The system-provided error number</li>
 <li><code>info</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> If present, extra details about the error condition</li>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A system-provided human-readable description of the error</li>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If present, the file path when reporting a file system error</li>
 <li><code>port</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> If present, the network connection port that is not available</li>
 <li><code>syscall</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The name of the system call that triggered the error</li>
 </ul>
-<h3><code>error.address</code><span><a class="mark" href="#errors_error_address" id="errors_error_address">#</a></span></h3>
+<h4><code>error.address</code><span><a class="mark" href="#errors_error_address" id="errors_error_address">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>If present, <code>error.address</code> is a string describing the address to which a
 network connection failed.</p>
-<h3><code>error.code</code><span><a class="mark" href="#errors_error_code_1" id="errors_error_code_1">#</a></span></h3>
+<h4><code>error.code</code><span><a class="mark" href="#errors_error_code_1" id="errors_error_code_1">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The <code>error.code</code> property is a string representing the error code.</p>
-<h3><code>error.dest</code><span><a class="mark" href="#errors_error_dest" id="errors_error_dest">#</a></span></h3>
+<h4><code>error.dest</code><span><a class="mark" href="#errors_error_dest" id="errors_error_dest">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>If present, <code>error.dest</code> is the file path destination when reporting a file
 system error.</p>
-<h3><code>error.errno</code><span><a class="mark" href="#errors_error_errno" id="errors_error_errno">#</a></span></h3>
+<h4><code>error.errno</code><span><a class="mark" href="#errors_error_errno" id="errors_error_errno">#</a></span></h4>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>The <code>error.errno</code> property is a number or a string. If it is a number, it is a
-negative value which corresponds to the error code defined in
-<a href="https://docs.libuv.org/en/v1.x/errors.html"><code>libuv Error handling</code></a>. See the libuv <code>errno.h</code> header file
-(<code>deps/uv/include/uv/errno.h</code> in the Node.js source tree) for details. In case
-of a string, it is the same as <code>error.code</code>.</p>
-<h3><code>error.info</code><span><a class="mark" href="#errors_error_info" id="errors_error_info">#</a></span></h3>
+<p>The <code>error.errno</code> property is a negative number which corresponds
+to the error code defined in <a href="https://docs.libuv.org/en/v1.x/errors.html"><code>libuv Error handling</code></a>.</p>
+<p>On Windows the error number provided by the system will be normalized by libuv.</p>
+<p>To get the string representation of the error code, use
+<a href="#util_util_getsystemerrorname_err"><code>util.getSystemErrorName(error.errno)</code></a>.</p>
+<h4><code>error.info</code><span><a class="mark" href="#errors_error_info" id="errors_error_info">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>If present, <code>error.info</code> is an object with details about the error condition.</p>
-<h3><code>error.message</code><span><a class="mark" href="#errors_error_message_1" id="errors_error_message_1">#</a></span></h3>
+<h4><code>error.message</code><span><a class="mark" href="#errors_error_message_1" id="errors_error_message_1">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p><code>error.message</code> is a system-provided human-readable description of the error.</p>
-<h3><code>error.path</code><span><a class="mark" href="#errors_error_path" id="errors_error_path">#</a></span></h3>
+<h4><code>error.path</code><span><a class="mark" href="#errors_error_path" id="errors_error_path">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>If present, <code>error.path</code> is a string containing a relevant invalid pathname.</p>
-<h3><code>error.port</code><span><a class="mark" href="#errors_error_port" id="errors_error_port">#</a></span></h3>
+<h4><code>error.port</code><span><a class="mark" href="#errors_error_port" id="errors_error_port">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>If present, <code>error.port</code> is the network connection port that is not available.</p>
-<h3><code>error.syscall</code><span><a class="mark" href="#errors_error_syscall" id="errors_error_syscall">#</a></span></h3>
+<h4><code>error.syscall</code><span><a class="mark" href="#errors_error_syscall" id="errors_error_syscall">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The <code>error.syscall</code> property is a string describing the <a href="https://man7.org/linux/man-pages/man2/syscalls.2.html">syscall</a> that failed.</p>
-<h3>Common system errors<span><a class="mark" href="#errors_common_system_errors" id="errors_common_system_errors">#</a></span></h3>
+<h4>Common system errors<span><a class="mark" href="#errors_common_system_errors" id="errors_common_system_errors">#</a></span></h4>
 <p>This is a list of system errors commonly-encountered when writing a Node.js
 program. For a comprehensive list, see the <a href="https://man7.org/linux/man-pages/man3/errno.3.html"><code>errno</code>(3) man page</a>.</p>
 <ul>
@@ -27097,17 +28412,17 @@ encountered by <a href="http.html"><code>http</code></a> or <a href="net.html"><
 was not properly called.</p>
 </li>
 </ul>
-<h2>Class: <code>TypeError</code><span><a class="mark" href="#errors_class_typeerror" id="errors_class_typeerror">#</a></span></h2>
+</section><section><h3>Class: <code>TypeError</code><span><a class="mark" href="#errors_class_typeerror" id="errors_class_typeerror">#</a></span></h3>
 <ul>
 <li>Extends <a href="#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
 <p>Indicates that a provided argument is not an allowable type. For example,
 passing a function to a parameter which expects a string would be a <code>TypeError</code>.</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>).parse(<span class="hljs-function">() =></span> { });
+<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>).<span class="hljs-title function_">parse</span>(<span class="hljs-function">() =></span> { });
 <span class="hljs-comment">// Throws TypeError, since it expected a string.</span></code></pre>
 <p>Node.js will generate and throw <code>TypeError</code> instances <em>immediately</em> as a form
 of argument validation.</p>
-<h2>Exceptions vs. errors<span><a class="mark" href="#errors_exceptions_vs_errors" id="errors_exceptions_vs_errors">#</a></span></h2>
+</section><section><h3>Exceptions vs. errors<span><a class="mark" href="#errors_exceptions_vs_errors" id="errors_exceptions_vs_errors">#</a></span></h3>
 
 <p>A JavaScript exception is a value that is thrown as a result of an invalid
 operation or as the target of a <code>throw</code> statement. While it is not required
@@ -27117,23 +28432,32 @@ instances of <code>Error</code>.</p>
 <p>Some exceptions are <em>unrecoverable</em> at the JavaScript layer. Such exceptions
 will <em>always</em> cause the Node.js process to crash. Examples include <code>assert()</code>
 checks or <code>abort()</code> calls in the C++ layer.</p>
-<h2>OpenSSL errors<span><a class="mark" href="#errors_openssl_errors" id="errors_openssl_errors">#</a></span></h2>
+</section><section><h3>OpenSSL errors<span><a class="mark" href="#errors_openssl_errors" id="errors_openssl_errors">#</a></span></h3>
 <p>Errors originating in <code>crypto</code> or <code>tls</code> are of class <code>Error</code>, and in addition to
 the standard <code>.code</code> and <code>.message</code> properties, may have some additional
 OpenSSL-specific properties.</p>
-<h3><code>error.opensslErrorStack</code><span><a class="mark" href="#errors_error_opensslerrorstack" id="errors_error_opensslerrorstack">#</a></span></h3>
+<h4><code>error.opensslErrorStack</code><span><a class="mark" href="#errors_error_opensslerrorstack" id="errors_error_opensslerrorstack">#</a></span></h4>
 <p>An array of errors that can give context to where in the OpenSSL library an
 error originates from.</p>
-<h3><code>error.function</code><span><a class="mark" href="#errors_error_function" id="errors_error_function">#</a></span></h3>
+<h4><code>error.function</code><span><a class="mark" href="#errors_error_function" id="errors_error_function">#</a></span></h4>
 <p>The OpenSSL function the error originates in.</p>
-<h3><code>error.library</code><span><a class="mark" href="#errors_error_library" id="errors_error_library">#</a></span></h3>
+<h4><code>error.library</code><span><a class="mark" href="#errors_error_library" id="errors_error_library">#</a></span></h4>
 <p>The OpenSSL library the error originates in.</p>
-<h3><code>error.reason</code><span><a class="mark" href="#errors_error_reason" id="errors_error_reason">#</a></span></h3>
+<h4><code>error.reason</code><span><a class="mark" href="#errors_error_reason" id="errors_error_reason">#</a></span></h4>
 <p>A human-readable string describing the reason for the error.</p>
 <p><a id="nodejs-error-codes"></a></p>
-<h2>Node.js error codes<span><a class="mark" href="#errors_node_js_error_codes" id="errors_node_js_error_codes">#</a></span></h2>
+</section><section><h3>Node.js error codes<span><a class="mark" href="#errors_node_js_error_codes" id="errors_node_js_error_codes">#</a></span></h3>
+<p><a id="ABORT_ERR"></a></p>
+<h4><code>ABORT_ERR</code><span><a class="mark" href="#errors_abort_err" id="errors_abort_err">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>Used when an operation has been aborted (typically using an <code>AbortController</code>).</p>
+<p>APIs <em>not</em> using <code>AbortSignal</code>s typically do not raise an error with this code.</p>
+<p>This code does not use the regular <code>ERR_*</code> convention Node.js errors use in
+order to be compatible with the web platform's <code>AbortError</code>.</p>
 <p><a id="ERR_AMBIGUOUS_ARGUMENT"></a></p>
-<h3><code>ERR_AMBIGUOUS_ARGUMENT</code><span><a class="mark" href="#errors_err_ambiguous_argument" id="errors_err_ambiguous_argument">#</a></span></h3>
+<h4><code>ERR_AMBIGUOUS_ARGUMENT</code><span><a class="mark" href="#errors_err_ambiguous_argument" id="errors_err_ambiguous_argument">#</a></span></h4>
 <p>A function argument is being used in a way that suggests that the function
 signature may be misunderstood. This is thrown by the <code>assert</code> module when the
 <code>message</code> parameter in <code>assert.throws(block, message)</code> matches the error message
@@ -27141,30 +28465,30 @@ thrown by <code>block</code> because that usage suggests that the user believes
 is the expected message rather than the message the <code>AssertionError</code> will
 display if <code>block</code> does not throw.</p>
 <p><a id="ERR_ARG_NOT_ITERABLE"></a></p>
-<h3><code>ERR_ARG_NOT_ITERABLE</code><span><a class="mark" href="#errors_err_arg_not_iterable" id="errors_err_arg_not_iterable">#</a></span></h3>
+<h4><code>ERR_ARG_NOT_ITERABLE</code><span><a class="mark" href="#errors_err_arg_not_iterable" id="errors_err_arg_not_iterable">#</a></span></h4>
 <p>An iterable argument (i.e. a value that works with <code>for...of</code> loops) was
 required, but not provided to a Node.js API.</p>
 <p><a id="ERR_ASSERTION"></a></p>
-<h3><code>ERR_ASSERTION</code><span><a class="mark" href="#errors_err_assertion" id="errors_err_assertion">#</a></span></h3>
+<h4><code>ERR_ASSERTION</code><span><a class="mark" href="#errors_err_assertion" id="errors_err_assertion">#</a></span></h4>
 <p>A special type of error that can be triggered whenever Node.js detects an
 exceptional logic violation that should never occur. These are raised typically
 by the <code>assert</code> module.</p>
 <p><a id="ERR_ASYNC_CALLBACK"></a></p>
-<h3><code>ERR_ASYNC_CALLBACK</code><span><a class="mark" href="#errors_err_async_callback" id="errors_err_async_callback">#</a></span></h3>
+<h4><code>ERR_ASYNC_CALLBACK</code><span><a class="mark" href="#errors_err_async_callback" id="errors_err_async_callback">#</a></span></h4>
 <p>An attempt was made to register something that is not a function as an
 <code>AsyncHooks</code> callback.</p>
 <p><a id="ERR_ASYNC_TYPE"></a></p>
-<h3><code>ERR_ASYNC_TYPE</code><span><a class="mark" href="#errors_err_async_type" id="errors_err_async_type">#</a></span></h3>
+<h4><code>ERR_ASYNC_TYPE</code><span><a class="mark" href="#errors_err_async_type" id="errors_err_async_type">#</a></span></h4>
 <p>The type of an asynchronous resource was invalid. Users are also able
 to define their own types if using the public embedder API.</p>
 <p><a id="ERR_BROTLI_COMPRESSION_FAILED"></a></p>
-<h3><code>ERR_BROTLI_COMPRESSION_FAILED</code><span><a class="mark" href="#errors_err_brotli_compression_failed" id="errors_err_brotli_compression_failed">#</a></span></h3>
+<h4><code>ERR_BROTLI_COMPRESSION_FAILED</code><span><a class="mark" href="#errors_err_brotli_compression_failed" id="errors_err_brotli_compression_failed">#</a></span></h4>
 <p>Data passed to a Brotli stream was not successfully compressed.</p>
 <p><a id="ERR_BROTLI_INVALID_PARAM"></a></p>
-<h3><code>ERR_BROTLI_INVALID_PARAM</code><span><a class="mark" href="#errors_err_brotli_invalid_param" id="errors_err_brotli_invalid_param">#</a></span></h3>
+<h4><code>ERR_BROTLI_INVALID_PARAM</code><span><a class="mark" href="#errors_err_brotli_invalid_param" id="errors_err_brotli_invalid_param">#</a></span></h4>
 <p>An invalid parameter key was passed during construction of a Brotli stream.</p>
 <p><a id="ERR_BUFFER_CONTEXT_NOT_AVAILABLE"></a></p>
-<h3><code>ERR_BUFFER_CONTEXT_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_buffer_context_not_available" id="errors_err_buffer_context_not_available">#</a></span></h3>
+<h4><code>ERR_BUFFER_CONTEXT_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_buffer_context_not_available" id="errors_err_buffer_context_not_available">#</a></span></h4>
 <p>An attempt was made to create a Node.js <code>Buffer</code> instance from addon or embedder
 code, while in a JS engine Context that is not associated with a Node.js
 instance. The data passed to the <code>Buffer</code> method will have been released
@@ -27174,920 +28498,988 @@ instance is to create a normal <code>Uint8Array</code>, which only differs in th
 prototype of the resulting object. <code>Uint8Array</code>s are generally accepted in all
 Node.js core APIs where <code>Buffer</code>s are; they are available in all Contexts.</p>
 <p><a id="ERR_BUFFER_OUT_OF_BOUNDS"></a></p>
-<h3><code>ERR_BUFFER_OUT_OF_BOUNDS</code><span><a class="mark" href="#errors_err_buffer_out_of_bounds" id="errors_err_buffer_out_of_bounds">#</a></span></h3>
+<h4><code>ERR_BUFFER_OUT_OF_BOUNDS</code><span><a class="mark" href="#errors_err_buffer_out_of_bounds" id="errors_err_buffer_out_of_bounds">#</a></span></h4>
 <p>An operation outside the bounds of a <code>Buffer</code> was attempted.</p>
 <p><a id="ERR_BUFFER_TOO_LARGE"></a></p>
-<h3><code>ERR_BUFFER_TOO_LARGE</code><span><a class="mark" href="#errors_err_buffer_too_large" id="errors_err_buffer_too_large">#</a></span></h3>
+<h4><code>ERR_BUFFER_TOO_LARGE</code><span><a class="mark" href="#errors_err_buffer_too_large" id="errors_err_buffer_too_large">#</a></span></h4>
 <p>An attempt has been made to create a <code>Buffer</code> larger than the maximum allowed
 size.</p>
 <p><a id="ERR_CANNOT_WATCH_SIGINT"></a></p>
-<h3><code>ERR_CANNOT_WATCH_SIGINT</code><span><a class="mark" href="#errors_err_cannot_watch_sigint" id="errors_err_cannot_watch_sigint">#</a></span></h3>
+<h4><code>ERR_CANNOT_WATCH_SIGINT</code><span><a class="mark" href="#errors_err_cannot_watch_sigint" id="errors_err_cannot_watch_sigint">#</a></span></h4>
 <p>Node.js was unable to watch for the <code>SIGINT</code> signal.</p>
 <p><a id="ERR_CHILD_CLOSED_BEFORE_REPLY"></a></p>
-<h3><code>ERR_CHILD_CLOSED_BEFORE_REPLY</code><span><a class="mark" href="#errors_err_child_closed_before_reply" id="errors_err_child_closed_before_reply">#</a></span></h3>
+<h4><code>ERR_CHILD_CLOSED_BEFORE_REPLY</code><span><a class="mark" href="#errors_err_child_closed_before_reply" id="errors_err_child_closed_before_reply">#</a></span></h4>
 <p>A child process was closed before the parent received a reply.</p>
 <p><a id="ERR_CHILD_PROCESS_IPC_REQUIRED"></a></p>
-<h3><code>ERR_CHILD_PROCESS_IPC_REQUIRED</code><span><a class="mark" href="#errors_err_child_process_ipc_required" id="errors_err_child_process_ipc_required">#</a></span></h3>
+<h4><code>ERR_CHILD_PROCESS_IPC_REQUIRED</code><span><a class="mark" href="#errors_err_child_process_ipc_required" id="errors_err_child_process_ipc_required">#</a></span></h4>
 <p>Used when a child process is being forked without specifying an IPC channel.</p>
 <p><a id="ERR_CHILD_PROCESS_STDIO_MAXBUFFER"></a></p>
-<h3><code>ERR_CHILD_PROCESS_STDIO_MAXBUFFER</code><span><a class="mark" href="#errors_err_child_process_stdio_maxbuffer" id="errors_err_child_process_stdio_maxbuffer">#</a></span></h3>
+<h4><code>ERR_CHILD_PROCESS_STDIO_MAXBUFFER</code><span><a class="mark" href="#errors_err_child_process_stdio_maxbuffer" id="errors_err_child_process_stdio_maxbuffer">#</a></span></h4>
 <p>Used when the main process is trying to read data from the child process's
 STDERR/STDOUT, and the data's length is longer than the <code>maxBuffer</code> option.</p>
+<p><a id="ERR_CLOSED_MESSAGE_PORT"></a></p>
+<h4><code>ERR_CLOSED_MESSAGE_PORT</code><span><a class="mark" href="#errors_err_closed_message_port" id="errors_err_closed_message_port">#</a></span></h4>
+<!--
+added: v14.17.1
+changes:
+  - version: 11.12.0
+    pr-url: https://github.com/nodejs/node/pull/26487
+    description: The error message was removed.
+  - version: v14.17.1
+    pr-url: https://github.com/nodejs/node/pull/38510
+    description: The error message was reintroduced.
+-->
+<p>There was an attempt to use a <code>MessagePort</code> instance in a closed
+state, usually after <code>.close()</code> has been called.</p>
 <p><a id="ERR_CONSOLE_WRITABLE_STREAM"></a></p>
-<h3><code>ERR_CONSOLE_WRITABLE_STREAM</code><span><a class="mark" href="#errors_err_console_writable_stream" id="errors_err_console_writable_stream">#</a></span></h3>
+<h4><code>ERR_CONSOLE_WRITABLE_STREAM</code><span><a class="mark" href="#errors_err_console_writable_stream" id="errors_err_console_writable_stream">#</a></span></h4>
 <p><code>Console</code> was instantiated without <code>stdout</code> stream, or <code>Console</code> has a
 non-writable <code>stdout</code> or <code>stderr</code> stream.</p>
-<p><a id="ERR_CONSTRUCT_CALL_REQUIRED"></a></p>
-<h3><code>ERR_CONSTRUCT_CALL_REQUIRED</code><span><a class="mark" href="#errors_err_construct_call_required" id="errors_err_construct_call_required">#</a></span></h3>
-<p>A constructor for a class was called without <code>new</code>.</p>
 <p><a id="ERR_CONSTRUCT_CALL_INVALID"></a></p>
-<h3><code>ERR_CONSTRUCT_CALL_INVALID</code><span><a class="mark" href="#errors_err_construct_call_invalid" id="errors_err_construct_call_invalid">#</a></span></h3>
+<h4><code>ERR_CONSTRUCT_CALL_INVALID</code><span><a class="mark" href="#errors_err_construct_call_invalid" id="errors_err_construct_call_invalid">#</a></span></h4>
 <!--
 added: v12.5.0
 -->
 <p>A class constructor was called that is not callable.</p>
+<p><a id="ERR_CONSTRUCT_CALL_REQUIRED"></a></p>
+<h4><code>ERR_CONSTRUCT_CALL_REQUIRED</code><span><a class="mark" href="#errors_err_construct_call_required" id="errors_err_construct_call_required">#</a></span></h4>
+<p>A constructor for a class was called without <code>new</code>.</p>
+<p><a id="ERR_CONTEXT_NOT_INITIALIZED"></a></p>
+<h4><code>ERR_CONTEXT_NOT_INITIALIZED</code><span><a class="mark" href="#errors_err_context_not_initialized" id="errors_err_context_not_initialized">#</a></span></h4>
+<p>The vm context passed into the API is not yet initialized. This could happen
+when an error occurs (and is caught) during the creation of the
+context, for example, when the allocation fails or the maximum call stack
+size is reached when the context is created.</p>
 <p><a id="ERR_CPU_USAGE"></a></p>
-<h3><code>ERR_CPU_USAGE</code><span><a class="mark" href="#errors_err_cpu_usage" id="errors_err_cpu_usage">#</a></span></h3>
+<h4><code>ERR_CPU_USAGE</code><span><a class="mark" href="#errors_err_cpu_usage" id="errors_err_cpu_usage">#</a></span></h4>
 <p>The native call from <code>process.cpuUsage</code> could not be processed.</p>
 <p><a id="ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED"></a></p>
-<h3><code>ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_crypto_custom_engine_not_supported" id="errors_err_crypto_custom_engine_not_supported">#</a></span></h3>
+<h4><code>ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_crypto_custom_engine_not_supported" id="errors_err_crypto_custom_engine_not_supported">#</a></span></h4>
 <p>A client certificate engine was requested that is not supported by the version
 of OpenSSL being used.</p>
 <p><a id="ERR_CRYPTO_ECDH_INVALID_FORMAT"></a></p>
-<h3><code>ERR_CRYPTO_ECDH_INVALID_FORMAT</code><span><a class="mark" href="#errors_err_crypto_ecdh_invalid_format" id="errors_err_crypto_ecdh_invalid_format">#</a></span></h3>
+<h4><code>ERR_CRYPTO_ECDH_INVALID_FORMAT</code><span><a class="mark" href="#errors_err_crypto_ecdh_invalid_format" id="errors_err_crypto_ecdh_invalid_format">#</a></span></h4>
 <p>An invalid value for the <code>format</code> argument was passed to the <code>crypto.ECDH()</code>
 class <code>getPublicKey()</code> method.</p>
 <p><a id="ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY"></a></p>
-<h3><code>ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY</code><span><a class="mark" href="#errors_err_crypto_ecdh_invalid_public_key" id="errors_err_crypto_ecdh_invalid_public_key">#</a></span></h3>
+<h4><code>ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY</code><span><a class="mark" href="#errors_err_crypto_ecdh_invalid_public_key" id="errors_err_crypto_ecdh_invalid_public_key">#</a></span></h4>
 <p>An invalid value for the <code>key</code> argument has been passed to the
 <code>crypto.ECDH()</code> class <code>computeSecret()</code> method. It means that the public
 key lies outside of the elliptic curve.</p>
 <p><a id="ERR_CRYPTO_ENGINE_UNKNOWN"></a></p>
-<h3><code>ERR_CRYPTO_ENGINE_UNKNOWN</code><span><a class="mark" href="#errors_err_crypto_engine_unknown" id="errors_err_crypto_engine_unknown">#</a></span></h3>
+<h4><code>ERR_CRYPTO_ENGINE_UNKNOWN</code><span><a class="mark" href="#errors_err_crypto_engine_unknown" id="errors_err_crypto_engine_unknown">#</a></span></h4>
 <p>An invalid crypto engine identifier was passed to
 <a href="#crypto_crypto_setengine_engine_flags"><code>require('crypto').setEngine()</code></a>.</p>
 <p><a id="ERR_CRYPTO_FIPS_FORCED"></a></p>
-<h3><code>ERR_CRYPTO_FIPS_FORCED</code><span><a class="mark" href="#errors_err_crypto_fips_forced" id="errors_err_crypto_fips_forced">#</a></span></h3>
+<h4><code>ERR_CRYPTO_FIPS_FORCED</code><span><a class="mark" href="#errors_err_crypto_fips_forced" id="errors_err_crypto_fips_forced">#</a></span></h4>
 <p>The <a href="#cli_force_fips"><code>--force-fips</code></a> command-line argument was used but there was an attempt
 to enable or disable FIPS mode in the <code>crypto</code> module.</p>
 <p><a id="ERR_CRYPTO_FIPS_UNAVAILABLE"></a></p>
-<h3><code>ERR_CRYPTO_FIPS_UNAVAILABLE</code><span><a class="mark" href="#errors_err_crypto_fips_unavailable" id="errors_err_crypto_fips_unavailable">#</a></span></h3>
+<h4><code>ERR_CRYPTO_FIPS_UNAVAILABLE</code><span><a class="mark" href="#errors_err_crypto_fips_unavailable" id="errors_err_crypto_fips_unavailable">#</a></span></h4>
 <p>An attempt was made to enable or disable FIPS mode, but FIPS mode was not
 available.</p>
 <p><a id="ERR_CRYPTO_HASH_FINALIZED"></a></p>
-<h3><code>ERR_CRYPTO_HASH_FINALIZED</code><span><a class="mark" href="#errors_err_crypto_hash_finalized" id="errors_err_crypto_hash_finalized">#</a></span></h3>
+<h4><code>ERR_CRYPTO_HASH_FINALIZED</code><span><a class="mark" href="#errors_err_crypto_hash_finalized" id="errors_err_crypto_hash_finalized">#</a></span></h4>
 <p><a href="#crypto_hash_digest_encoding"><code>hash.digest()</code></a> was called multiple times. The <code>hash.digest()</code> method must
 be called no more than one time per instance of a <code>Hash</code> object.</p>
 <p><a id="ERR_CRYPTO_HASH_UPDATE_FAILED"></a></p>
-<h3><code>ERR_CRYPTO_HASH_UPDATE_FAILED</code><span><a class="mark" href="#errors_err_crypto_hash_update_failed" id="errors_err_crypto_hash_update_failed">#</a></span></h3>
+<h4><code>ERR_CRYPTO_HASH_UPDATE_FAILED</code><span><a class="mark" href="#errors_err_crypto_hash_update_failed" id="errors_err_crypto_hash_update_failed">#</a></span></h4>
 <p><a href="#crypto_hash_update_data_inputencoding"><code>hash.update()</code></a> failed for any reason. This should rarely, if ever, happen.</p>
 <p><a id="ERR_CRYPTO_INCOMPATIBLE_KEY"></a></p>
-<h3><code>ERR_CRYPTO_INCOMPATIBLE_KEY</code><span><a class="mark" href="#errors_err_crypto_incompatible_key" id="errors_err_crypto_incompatible_key">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INCOMPATIBLE_KEY</code><span><a class="mark" href="#errors_err_crypto_incompatible_key" id="errors_err_crypto_incompatible_key">#</a></span></h4>
 <p>The given crypto keys are incompatible with the attempted operation.</p>
 <p><a id="ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS"></a></p>
-<h3><code>ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS</code><span><a class="mark" href="#errors_err_crypto_incompatible_key_options" id="errors_err_crypto_incompatible_key_options">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS</code><span><a class="mark" href="#errors_err_crypto_incompatible_key_options" id="errors_err_crypto_incompatible_key_options">#</a></span></h4>
 <p>The selected public or private key encoding is incompatible with other options.</p>
 <p><a id="ERR_CRYPTO_INVALID_DIGEST"></a></p>
-<h3><code>ERR_CRYPTO_INVALID_DIGEST</code><span><a class="mark" href="#errors_err_crypto_invalid_digest" id="errors_err_crypto_invalid_digest">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INVALID_DIGEST</code><span><a class="mark" href="#errors_err_crypto_invalid_digest" id="errors_err_crypto_invalid_digest">#</a></span></h4>
 <p>An invalid <a href="#crypto_crypto_gethashes">crypto digest algorithm</a> was specified.</p>
 <p><a id="ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE"></a></p>
-<h3><code>ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE</code><span><a class="mark" href="#errors_err_crypto_invalid_key_object_type" id="errors_err_crypto_invalid_key_object_type">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE</code><span><a class="mark" href="#errors_err_crypto_invalid_key_object_type" id="errors_err_crypto_invalid_key_object_type">#</a></span></h4>
 <p>The given crypto key object's type is invalid for the attempted operation.</p>
 <p><a id="ERR_CRYPTO_INVALID_STATE"></a></p>
-<h3><code>ERR_CRYPTO_INVALID_STATE</code><span><a class="mark" href="#errors_err_crypto_invalid_state" id="errors_err_crypto_invalid_state">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INVALID_STATE</code><span><a class="mark" href="#errors_err_crypto_invalid_state" id="errors_err_crypto_invalid_state">#</a></span></h4>
 <p>A crypto method was used on an object that was in an invalid state. For
 instance, calling <a href="#crypto_cipher_getauthtag"><code>cipher.getAuthTag()</code></a> before calling <code>cipher.final()</code>.</p>
 <p><a id="ERR_CRYPTO_PBKDF2_ERROR"></a></p>
-<h3><code>ERR_CRYPTO_PBKDF2_ERROR</code><span><a class="mark" href="#errors_err_crypto_pbkdf2_error" id="errors_err_crypto_pbkdf2_error">#</a></span></h3>
+<h4><code>ERR_CRYPTO_PBKDF2_ERROR</code><span><a class="mark" href="#errors_err_crypto_pbkdf2_error" id="errors_err_crypto_pbkdf2_error">#</a></span></h4>
 <p>The PBKDF2 algorithm failed for unspecified reasons. OpenSSL does not provide
 more details and therefore neither does Node.js.</p>
 <p><a id="ERR_CRYPTO_SCRYPT_INVALID_PARAMETER"></a></p>
-<h3><code>ERR_CRYPTO_SCRYPT_INVALID_PARAMETER</code><span><a class="mark" href="#errors_err_crypto_scrypt_invalid_parameter" id="errors_err_crypto_scrypt_invalid_parameter">#</a></span></h3>
+<h4><code>ERR_CRYPTO_SCRYPT_INVALID_PARAMETER</code><span><a class="mark" href="#errors_err_crypto_scrypt_invalid_parameter" id="errors_err_crypto_scrypt_invalid_parameter">#</a></span></h4>
 <p>One or more <a href="#crypto_crypto_scrypt_password_salt_keylen_options_callback"><code>crypto.scrypt()</code></a> or <a href="#crypto_crypto_scryptsync_password_salt_keylen_options"><code>crypto.scryptSync()</code></a> parameters are
 outside their legal range.</p>
 <p><a id="ERR_CRYPTO_SCRYPT_NOT_SUPPORTED"></a></p>
-<h3><code>ERR_CRYPTO_SCRYPT_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_crypto_scrypt_not_supported" id="errors_err_crypto_scrypt_not_supported">#</a></span></h3>
+<h4><code>ERR_CRYPTO_SCRYPT_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_crypto_scrypt_not_supported" id="errors_err_crypto_scrypt_not_supported">#</a></span></h4>
 <p>Node.js was compiled without <code>scrypt</code> support. Not possible with the official
 release binaries but can happen with custom builds, including distro builds.</p>
 <p><a id="ERR_CRYPTO_SIGN_KEY_REQUIRED"></a></p>
-<h3><code>ERR_CRYPTO_SIGN_KEY_REQUIRED</code><span><a class="mark" href="#errors_err_crypto_sign_key_required" id="errors_err_crypto_sign_key_required">#</a></span></h3>
+<h4><code>ERR_CRYPTO_SIGN_KEY_REQUIRED</code><span><a class="mark" href="#errors_err_crypto_sign_key_required" id="errors_err_crypto_sign_key_required">#</a></span></h4>
 <p>A signing <code>key</code> was not provided to the <a href="#crypto_sign_sign_privatekey_outputencoding"><code>sign.sign()</code></a> method.</p>
 <p><a id="ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH"></a></p>
-<h3><code>ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH</code><span><a class="mark" href="#errors_err_crypto_timing_safe_equal_length" id="errors_err_crypto_timing_safe_equal_length">#</a></span></h3>
+<h4><code>ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH</code><span><a class="mark" href="#errors_err_crypto_timing_safe_equal_length" id="errors_err_crypto_timing_safe_equal_length">#</a></span></h4>
 <p><a href="#crypto_crypto_timingsafeequal_a_b"><code>crypto.timingSafeEqual()</code></a> was called with <code>Buffer</code>, <code>TypedArray</code>, or
 <code>DataView</code> arguments of different lengths.</p>
 <p><a id="ERR_CRYPTO_UNKNOWN_CIPHER"></a></p>
-<h3><code>ERR_CRYPTO_UNKNOWN_CIPHER</code><span><a class="mark" href="#errors_err_crypto_unknown_cipher" id="errors_err_crypto_unknown_cipher">#</a></span></h3>
+<h4><code>ERR_CRYPTO_UNKNOWN_CIPHER</code><span><a class="mark" href="#errors_err_crypto_unknown_cipher" id="errors_err_crypto_unknown_cipher">#</a></span></h4>
 <p>An unknown cipher was specified.</p>
 <p><a id="ERR_CRYPTO_UNKNOWN_DH_GROUP"></a></p>
-<h3><code>ERR_CRYPTO_UNKNOWN_DH_GROUP</code><span><a class="mark" href="#errors_err_crypto_unknown_dh_group" id="errors_err_crypto_unknown_dh_group">#</a></span></h3>
+<h4><code>ERR_CRYPTO_UNKNOWN_DH_GROUP</code><span><a class="mark" href="#errors_err_crypto_unknown_dh_group" id="errors_err_crypto_unknown_dh_group">#</a></span></h4>
 <p>An unknown Diffie-Hellman group name was given. See
 <a href="#crypto_crypto_getdiffiehellman_groupname"><code>crypto.getDiffieHellman()</code></a> for a list of valid group names.</p>
+<p><a id="ERR_DLOPEN_FAILED"></a></p>
+<h4><code>ERR_DLOPEN_FAILED</code><span><a class="mark" href="#errors_err_dlopen_failed" id="errors_err_dlopen_failed">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>A call to <code>process.dlopen()</code> failed.</p>
+<p><a id="ERR_DEBUGGER_ERROR"></a></p>
+<h4><code>ERR_DEBUGGER_ERROR</code><span><a class="mark" href="#errors_err_debugger_error" id="errors_err_debugger_error">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.4</span>
+</div>
+<p>An error occurred with the <a href="debugger.html">debugger</a>.</p>
+<p><a id="ERR_DEBUGGER_STARTUP_ERROR"></a></p>
+<h4><code>ERR_DEBUGGER_STARTUP_ERROR</code><span><a class="mark" href="#errors_err_debugger_startup_error" id="errors_err_debugger_startup_error">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.4</span>
+</div>
+<p>The <a href="debugger.html">debugger</a> timed out waiting for the required host/port to be free.</p>
 <p><a id="ERR_DIR_CLOSED"></a></p>
-<h3><code>ERR_DIR_CLOSED</code><span><a class="mark" href="#errors_err_dir_closed" id="errors_err_dir_closed">#</a></span></h3>
+<h4><code>ERR_DIR_CLOSED</code><span><a class="mark" href="#errors_err_dir_closed" id="errors_err_dir_closed">#</a></span></h4>
 <p>The <a href="#fs_class_fs_dir"><code>fs.Dir</code></a> was previously closed.</p>
 <p><a id="ERR_DIR_CONCURRENT_OPERATION"></a></p>
-<h3><code>ERR_DIR_CONCURRENT_OPERATION</code><span><a class="mark" href="#errors_err_dir_concurrent_operation" id="errors_err_dir_concurrent_operation">#</a></span></h3>
+<h4><code>ERR_DIR_CONCURRENT_OPERATION</code><span><a class="mark" href="#errors_err_dir_concurrent_operation" id="errors_err_dir_concurrent_operation">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.18.1</span>
+<span>Added in: v14.3.0</span>
 </div>
 <p>A synchronous read or close call was attempted on an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a> which has
 ongoing asynchronous operations.</p>
 <p><a id="ERR_DNS_SET_SERVERS_FAILED"></a></p>
-<h3><code>ERR_DNS_SET_SERVERS_FAILED</code><span><a class="mark" href="#errors_err_dns_set_servers_failed" id="errors_err_dns_set_servers_failed">#</a></span></h3>
+<h4><code>ERR_DNS_SET_SERVERS_FAILED</code><span><a class="mark" href="#errors_err_dns_set_servers_failed" id="errors_err_dns_set_servers_failed">#</a></span></h4>
 <p><code>c-ares</code> failed to set the DNS server.</p>
 <p><a id="ERR_DOMAIN_CALLBACK_NOT_AVAILABLE"></a></p>
-<h3><code>ERR_DOMAIN_CALLBACK_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_domain_callback_not_available" id="errors_err_domain_callback_not_available">#</a></span></h3>
+<h4><code>ERR_DOMAIN_CALLBACK_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_domain_callback_not_available" id="errors_err_domain_callback_not_available">#</a></span></h4>
 <p>The <code>domain</code> module was not usable since it could not establish the required
 error handling hooks, because
 <a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> had been called at an
 earlier point in time.</p>
 <p><a id="ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE"></a></p>
-<h3><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code><span><a class="mark" href="#errors_err_domain_cannot_set_uncaught_exception_capture" id="errors_err_domain_cannot_set_uncaught_exception_capture">#</a></span></h3>
+<h4><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code><span><a class="mark" href="#errors_err_domain_cannot_set_uncaught_exception_capture" id="errors_err_domain_cannot_set_uncaught_exception_capture">#</a></span></h4>
 <p><a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> could not be called
 because the <code>domain</code> module has been loaded at an earlier point in time.</p>
 <p>The stack trace is extended to include the point in time at which the
 <code>domain</code> module had been loaded.</p>
 <p><a id="ERR_ENCODING_INVALID_ENCODED_DATA"></a></p>
-<h3><code>ERR_ENCODING_INVALID_ENCODED_DATA</code><span><a class="mark" href="#errors_err_encoding_invalid_encoded_data" id="errors_err_encoding_invalid_encoded_data">#</a></span></h3>
+<h4><code>ERR_ENCODING_INVALID_ENCODED_DATA</code><span><a class="mark" href="#errors_err_encoding_invalid_encoded_data" id="errors_err_encoding_invalid_encoded_data">#</a></span></h4>
 <p>Data provided to <code>TextDecoder()</code> API was invalid according to the encoding
 provided.</p>
 <p><a id="ERR_ENCODING_NOT_SUPPORTED"></a></p>
-<h3><code>ERR_ENCODING_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_encoding_not_supported" id="errors_err_encoding_not_supported">#</a></span></h3>
+<h4><code>ERR_ENCODING_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_encoding_not_supported" id="errors_err_encoding_not_supported">#</a></span></h4>
 <p>Encoding provided to <code>TextDecoder()</code> API was not one of the
 <a href="#util_whatwg_supported_encodings">WHATWG Supported Encodings</a>.</p>
+<p><a id="ERR_EVAL_ESM_CANNOT_PRINT"></a></p>
+<h4><code>ERR_EVAL_ESM_CANNOT_PRINT</code><span><a class="mark" href="#errors_err_eval_esm_cannot_print" id="errors_err_eval_esm_cannot_print">#</a></span></h4>
+<p><code>--print</code> cannot be used with ESM input.</p>
+<p><a id="ERR_EVENT_RECURSION"></a></p>
+<h4><code>ERR_EVENT_RECURSION</code><span><a class="mark" href="#errors_err_event_recursion" id="errors_err_event_recursion">#</a></span></h4>
+<p>Thrown when an attempt is made to recursively dispatch an event on <code>EventTarget</code>.</p>
 <p><a id="ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE"></a></p>
-<h3><code>ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_execution_environment_not_available" id="errors_err_execution_environment_not_available">#</a></span></h3>
+<h4><code>ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_execution_environment_not_available" id="errors_err_execution_environment_not_available">#</a></span></h4>
 <p>The JS execution context is not associated with a Node.js environment.
 This may occur when Node.js is used as an embedded library and some hooks
 for the JS engine are not set up properly.</p>
 <p><a id="ERR_FALSY_VALUE_REJECTION"></a></p>
-<h3><code>ERR_FALSY_VALUE_REJECTION</code><span><a class="mark" href="#errors_err_falsy_value_rejection" id="errors_err_falsy_value_rejection">#</a></span></h3>
+<h4><code>ERR_FALSY_VALUE_REJECTION</code><span><a class="mark" href="#errors_err_falsy_value_rejection" id="errors_err_falsy_value_rejection">#</a></span></h4>
 <p>A <code>Promise</code> that was callbackified via <code>util.callbackify()</code> was rejected with a
 falsy value.</p>
+<p><a id="ERR_FEATURE_UNAVAILABLE_ON_PLATFORM"></a></p>
+<h4><code>ERR_FEATURE_UNAVAILABLE_ON_PLATFORM</code><span><a class="mark" href="#errors_err_feature_unavailable_on_platform" id="errors_err_feature_unavailable_on_platform">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.0.0</span>
+</div>
+<p>Used when a feature that is not available
+to the current platform which is running Node.js is used.</p>
+<p><a id="ERR_FS_EISDIR"></a></p>
+<h4><code>ERR_FS_EISDIR</code><span><a class="mark" href="#errors_err_fs_eisdir" id="errors_err_fs_eisdir">#</a></span></h4>
+<p>Path is a directory.</p>
 <p><a id="ERR_FS_FILE_TOO_LARGE"></a></p>
-<h3><code>ERR_FS_FILE_TOO_LARGE</code><span><a class="mark" href="#errors_err_fs_file_too_large" id="errors_err_fs_file_too_large">#</a></span></h3>
+<h4><code>ERR_FS_FILE_TOO_LARGE</code><span><a class="mark" href="#errors_err_fs_file_too_large" id="errors_err_fs_file_too_large">#</a></span></h4>
 <p>An attempt has been made to read a file whose size is larger than the maximum
 allowed size for a <code>Buffer</code>.</p>
 <p><a id="ERR_FS_INVALID_SYMLINK_TYPE"></a></p>
-<h3><code>ERR_FS_INVALID_SYMLINK_TYPE</code><span><a class="mark" href="#errors_err_fs_invalid_symlink_type" id="errors_err_fs_invalid_symlink_type">#</a></span></h3>
+<h4><code>ERR_FS_INVALID_SYMLINK_TYPE</code><span><a class="mark" href="#errors_err_fs_invalid_symlink_type" id="errors_err_fs_invalid_symlink_type">#</a></span></h4>
 <p>An invalid symlink type was passed to the <a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink()</code></a> or
 <a href="#fs_fs_symlinksync_target_path_type"><code>fs.symlinkSync()</code></a> methods.</p>
 <p><a id="ERR_HTTP_HEADERS_SENT"></a></p>
-<h3><code>ERR_HTTP_HEADERS_SENT</code><span><a class="mark" href="#errors_err_http_headers_sent" id="errors_err_http_headers_sent">#</a></span></h3>
+<h4><code>ERR_HTTP_HEADERS_SENT</code><span><a class="mark" href="#errors_err_http_headers_sent" id="errors_err_http_headers_sent">#</a></span></h4>
 <p>An attempt was made to add more headers after the headers had already been sent.</p>
 <p><a id="ERR_HTTP_INVALID_HEADER_VALUE"></a></p>
-<h3><code>ERR_HTTP_INVALID_HEADER_VALUE</code><span><a class="mark" href="#errors_err_http_invalid_header_value" id="errors_err_http_invalid_header_value">#</a></span></h3>
+<h4><code>ERR_HTTP_INVALID_HEADER_VALUE</code><span><a class="mark" href="#errors_err_http_invalid_header_value" id="errors_err_http_invalid_header_value">#</a></span></h4>
 <p>An invalid HTTP header value was specified.</p>
 <p><a id="ERR_HTTP_INVALID_STATUS_CODE"></a></p>
-<h3><code>ERR_HTTP_INVALID_STATUS_CODE</code><span><a class="mark" href="#errors_err_http_invalid_status_code" id="errors_err_http_invalid_status_code">#</a></span></h3>
+<h4><code>ERR_HTTP_INVALID_STATUS_CODE</code><span><a class="mark" href="#errors_err_http_invalid_status_code" id="errors_err_http_invalid_status_code">#</a></span></h4>
 <p>Status code was outside the regular status code range (100-999).</p>
 <p><a id="ERR_HTTP_TRAILER_INVALID"></a></p>
-<h3><code>ERR_HTTP_TRAILER_INVALID</code><span><a class="mark" href="#errors_err_http_trailer_invalid" id="errors_err_http_trailer_invalid">#</a></span></h3>
+<h4><code>ERR_HTTP_TRAILER_INVALID</code><span><a class="mark" href="#errors_err_http_trailer_invalid" id="errors_err_http_trailer_invalid">#</a></span></h4>
 <p>The <code>Trailer</code> header was set even though the transfer encoding does not support
 that.</p>
 <p><a id="ERR_HTTP2_ALTSVC_INVALID_ORIGIN"></a></p>
-<h3><code>ERR_HTTP2_ALTSVC_INVALID_ORIGIN</code><span><a class="mark" href="#errors_err_http2_altsvc_invalid_origin" id="errors_err_http2_altsvc_invalid_origin">#</a></span></h3>
+<h4><code>ERR_HTTP2_ALTSVC_INVALID_ORIGIN</code><span><a class="mark" href="#errors_err_http2_altsvc_invalid_origin" id="errors_err_http2_altsvc_invalid_origin">#</a></span></h4>
 <p>HTTP/2 ALTSVC frames require a valid origin.</p>
 <p><a id="ERR_HTTP2_ALTSVC_LENGTH"></a></p>
-<h3><code>ERR_HTTP2_ALTSVC_LENGTH</code><span><a class="mark" href="#errors_err_http2_altsvc_length" id="errors_err_http2_altsvc_length">#</a></span></h3>
+<h4><code>ERR_HTTP2_ALTSVC_LENGTH</code><span><a class="mark" href="#errors_err_http2_altsvc_length" id="errors_err_http2_altsvc_length">#</a></span></h4>
 <p>HTTP/2 ALTSVC frames are limited to a maximum of 16,382 payload bytes.</p>
 <p><a id="ERR_HTTP2_CONNECT_AUTHORITY"></a></p>
-<h3><code>ERR_HTTP2_CONNECT_AUTHORITY</code><span><a class="mark" href="#errors_err_http2_connect_authority" id="errors_err_http2_connect_authority">#</a></span></h3>
+<h4><code>ERR_HTTP2_CONNECT_AUTHORITY</code><span><a class="mark" href="#errors_err_http2_connect_authority" id="errors_err_http2_connect_authority">#</a></span></h4>
 <p>For HTTP/2 requests using the <code>CONNECT</code> method, the <code>:authority</code> pseudo-header
 is required.</p>
 <p><a id="ERR_HTTP2_CONNECT_PATH"></a></p>
-<h3><code>ERR_HTTP2_CONNECT_PATH</code><span><a class="mark" href="#errors_err_http2_connect_path" id="errors_err_http2_connect_path">#</a></span></h3>
+<h4><code>ERR_HTTP2_CONNECT_PATH</code><span><a class="mark" href="#errors_err_http2_connect_path" id="errors_err_http2_connect_path">#</a></span></h4>
 <p>For HTTP/2 requests using the <code>CONNECT</code> method, the <code>:path</code> pseudo-header is
 forbidden.</p>
 <p><a id="ERR_HTTP2_CONNECT_SCHEME"></a></p>
-<h3><code>ERR_HTTP2_CONNECT_SCHEME</code><span><a class="mark" href="#errors_err_http2_connect_scheme" id="errors_err_http2_connect_scheme">#</a></span></h3>
+<h4><code>ERR_HTTP2_CONNECT_SCHEME</code><span><a class="mark" href="#errors_err_http2_connect_scheme" id="errors_err_http2_connect_scheme">#</a></span></h4>
 <p>For HTTP/2 requests using the <code>CONNECT</code> method, the <code>:scheme</code> pseudo-header is
 forbidden.</p>
 <p><a id="ERR_HTTP2_ERROR"></a></p>
-<h3><code>ERR_HTTP2_ERROR</code><span><a class="mark" href="#errors_err_http2_error" id="errors_err_http2_error">#</a></span></h3>
+<h4><code>ERR_HTTP2_ERROR</code><span><a class="mark" href="#errors_err_http2_error" id="errors_err_http2_error">#</a></span></h4>
 <p>A non-specific HTTP/2 error has occurred.</p>
 <p><a id="ERR_HTTP2_GOAWAY_SESSION"></a></p>
-<h3><code>ERR_HTTP2_GOAWAY_SESSION</code><span><a class="mark" href="#errors_err_http2_goaway_session" id="errors_err_http2_goaway_session">#</a></span></h3>
+<h4><code>ERR_HTTP2_GOAWAY_SESSION</code><span><a class="mark" href="#errors_err_http2_goaway_session" id="errors_err_http2_goaway_session">#</a></span></h4>
 <p>New HTTP/2 Streams may not be opened after the <code>Http2Session</code> has received a
 <code>GOAWAY</code> frame from the connected peer.</p>
+<p><a id="ERR_HTTP2_HEADER_SINGLE_VALUE"></a></p>
+<h4><code>ERR_HTTP2_HEADER_SINGLE_VALUE</code><span><a class="mark" href="#errors_err_http2_header_single_value" id="errors_err_http2_header_single_value">#</a></span></h4>
+<p>Multiple values were provided for an HTTP/2 header field that was required to
+have only a single value.</p>
 <p><a id="ERR_HTTP2_HEADERS_AFTER_RESPOND"></a></p>
-<h3><code>ERR_HTTP2_HEADERS_AFTER_RESPOND</code><span><a class="mark" href="#errors_err_http2_headers_after_respond" id="errors_err_http2_headers_after_respond">#</a></span></h3>
+<h4><code>ERR_HTTP2_HEADERS_AFTER_RESPOND</code><span><a class="mark" href="#errors_err_http2_headers_after_respond" id="errors_err_http2_headers_after_respond">#</a></span></h4>
 <p>An additional headers was specified after an HTTP/2 response was initiated.</p>
 <p><a id="ERR_HTTP2_HEADERS_SENT"></a></p>
-<h3><code>ERR_HTTP2_HEADERS_SENT</code><span><a class="mark" href="#errors_err_http2_headers_sent" id="errors_err_http2_headers_sent">#</a></span></h3>
+<h4><code>ERR_HTTP2_HEADERS_SENT</code><span><a class="mark" href="#errors_err_http2_headers_sent" id="errors_err_http2_headers_sent">#</a></span></h4>
 <p>An attempt was made to send multiple response headers.</p>
-<p><a id="ERR_HTTP2_HEADER_SINGLE_VALUE"></a></p>
-<h3><code>ERR_HTTP2_HEADER_SINGLE_VALUE</code><span><a class="mark" href="#errors_err_http2_header_single_value" id="errors_err_http2_header_single_value">#</a></span></h3>
-<p>Multiple values were provided for an HTTP/2 header field that was required to
-have only a single value.</p>
 <p><a id="ERR_HTTP2_INFO_STATUS_NOT_ALLOWED"></a></p>
-<h3><code>ERR_HTTP2_INFO_STATUS_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_http2_info_status_not_allowed" id="errors_err_http2_info_status_not_allowed">#</a></span></h3>
+<h4><code>ERR_HTTP2_INFO_STATUS_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_http2_info_status_not_allowed" id="errors_err_http2_info_status_not_allowed">#</a></span></h4>
 <p>Informational HTTP status codes (<code>1xx</code>) may not be set as the response status
 code on HTTP/2 responses.</p>
 <p><a id="ERR_HTTP2_INVALID_CONNECTION_HEADERS"></a></p>
-<h3><code>ERR_HTTP2_INVALID_CONNECTION_HEADERS</code><span><a class="mark" href="#errors_err_http2_invalid_connection_headers" id="errors_err_http2_invalid_connection_headers">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_CONNECTION_HEADERS</code><span><a class="mark" href="#errors_err_http2_invalid_connection_headers" id="errors_err_http2_invalid_connection_headers">#</a></span></h4>
 <p>HTTP/1 connection specific headers are forbidden to be used in HTTP/2
 requests and responses.</p>
 <p><a id="ERR_HTTP2_INVALID_HEADER_VALUE"></a></p>
-<h3><code>ERR_HTTP2_INVALID_HEADER_VALUE</code><span><a class="mark" href="#errors_err_http2_invalid_header_value" id="errors_err_http2_invalid_header_value">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_HEADER_VALUE</code><span><a class="mark" href="#errors_err_http2_invalid_header_value" id="errors_err_http2_invalid_header_value">#</a></span></h4>
 <p>An invalid HTTP/2 header value was specified.</p>
 <p><a id="ERR_HTTP2_INVALID_INFO_STATUS"></a></p>
-<h3><code>ERR_HTTP2_INVALID_INFO_STATUS</code><span><a class="mark" href="#errors_err_http2_invalid_info_status" id="errors_err_http2_invalid_info_status">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_INFO_STATUS</code><span><a class="mark" href="#errors_err_http2_invalid_info_status" id="errors_err_http2_invalid_info_status">#</a></span></h4>
 <p>An invalid HTTP informational status code has been specified. Informational
 status codes must be an integer between <code>100</code> and <code>199</code> (inclusive).</p>
 <p><a id="ERR_HTTP2_INVALID_ORIGIN"></a></p>
-<h3><code>ERR_HTTP2_INVALID_ORIGIN</code><span><a class="mark" href="#errors_err_http2_invalid_origin" id="errors_err_http2_invalid_origin">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_ORIGIN</code><span><a class="mark" href="#errors_err_http2_invalid_origin" id="errors_err_http2_invalid_origin">#</a></span></h4>
 <p>HTTP/2 <code>ORIGIN</code> frames require a valid origin.</p>
 <p><a id="ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH"></a></p>
-<h3><code>ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH</code><span><a class="mark" href="#errors_err_http2_invalid_packed_settings_length" id="errors_err_http2_invalid_packed_settings_length">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH</code><span><a class="mark" href="#errors_err_http2_invalid_packed_settings_length" id="errors_err_http2_invalid_packed_settings_length">#</a></span></h4>
 <p>Input <code>Buffer</code> and <code>Uint8Array</code> instances passed to the
 <code>http2.getUnpackedSettings()</code> API must have a length that is a multiple of
 six.</p>
 <p><a id="ERR_HTTP2_INVALID_PSEUDOHEADER"></a></p>
-<h3><code>ERR_HTTP2_INVALID_PSEUDOHEADER</code><span><a class="mark" href="#errors_err_http2_invalid_pseudoheader" id="errors_err_http2_invalid_pseudoheader">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_PSEUDOHEADER</code><span><a class="mark" href="#errors_err_http2_invalid_pseudoheader" id="errors_err_http2_invalid_pseudoheader">#</a></span></h4>
 <p>Only valid HTTP/2 pseudoheaders (<code>:status</code>, <code>:path</code>, <code>:authority</code>, <code>:scheme</code>,
 and <code>:method</code>) may be used.</p>
 <p><a id="ERR_HTTP2_INVALID_SESSION"></a></p>
-<h3><code>ERR_HTTP2_INVALID_SESSION</code><span><a class="mark" href="#errors_err_http2_invalid_session" id="errors_err_http2_invalid_session">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_SESSION</code><span><a class="mark" href="#errors_err_http2_invalid_session" id="errors_err_http2_invalid_session">#</a></span></h4>
 <p>An action was performed on an <code>Http2Session</code> object that had already been
 destroyed.</p>
 <p><a id="ERR_HTTP2_INVALID_SETTING_VALUE"></a></p>
-<h3><code>ERR_HTTP2_INVALID_SETTING_VALUE</code><span><a class="mark" href="#errors_err_http2_invalid_setting_value" id="errors_err_http2_invalid_setting_value">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_SETTING_VALUE</code><span><a class="mark" href="#errors_err_http2_invalid_setting_value" id="errors_err_http2_invalid_setting_value">#</a></span></h4>
 <p>An invalid value has been specified for an HTTP/2 setting.</p>
 <p><a id="ERR_HTTP2_INVALID_STREAM"></a></p>
-<h3><code>ERR_HTTP2_INVALID_STREAM</code><span><a class="mark" href="#errors_err_http2_invalid_stream" id="errors_err_http2_invalid_stream">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_STREAM</code><span><a class="mark" href="#errors_err_http2_invalid_stream" id="errors_err_http2_invalid_stream">#</a></span></h4>
 <p>An operation was performed on a stream that had already been destroyed.</p>
 <p><a id="ERR_HTTP2_MAX_PENDING_SETTINGS_ACK"></a></p>
-<h3><code>ERR_HTTP2_MAX_PENDING_SETTINGS_ACK</code><span><a class="mark" href="#errors_err_http2_max_pending_settings_ack" id="errors_err_http2_max_pending_settings_ack">#</a></span></h3>
+<h4><code>ERR_HTTP2_MAX_PENDING_SETTINGS_ACK</code><span><a class="mark" href="#errors_err_http2_max_pending_settings_ack" id="errors_err_http2_max_pending_settings_ack">#</a></span></h4>
 <p>Whenever an HTTP/2 <code>SETTINGS</code> frame is sent to a connected peer, the peer is
 required to send an acknowledgment that it has received and applied the new
 <code>SETTINGS</code>. By default, a maximum number of unacknowledged <code>SETTINGS</code> frames may
 be sent at any given time. This error code is used when that limit has been
 reached.</p>
 <p><a id="ERR_HTTP2_NESTED_PUSH"></a></p>
-<h3><code>ERR_HTTP2_NESTED_PUSH</code><span><a class="mark" href="#errors_err_http2_nested_push" id="errors_err_http2_nested_push">#</a></span></h3>
+<h4><code>ERR_HTTP2_NESTED_PUSH</code><span><a class="mark" href="#errors_err_http2_nested_push" id="errors_err_http2_nested_push">#</a></span></h4>
 <p>An attempt was made to initiate a new push stream from within a push stream.
 Nested push streams are not permitted.</p>
+<p><a id="ERR_HTTP2_NO_MEM"></a></p>
+<h4><code>ERR_HTTP2_NO_MEM</code><span><a class="mark" href="#errors_err_http2_no_mem" id="errors_err_http2_no_mem">#</a></span></h4>
+<p>Out of memory when using the <code>http2session.setLocalWindowSize(windowSize)</code> API.</p>
 <p><a id="ERR_HTTP2_NO_SOCKET_MANIPULATION"></a></p>
-<h3><code>ERR_HTTP2_NO_SOCKET_MANIPULATION</code><span><a class="mark" href="#errors_err_http2_no_socket_manipulation" id="errors_err_http2_no_socket_manipulation">#</a></span></h3>
+<h4><code>ERR_HTTP2_NO_SOCKET_MANIPULATION</code><span><a class="mark" href="#errors_err_http2_no_socket_manipulation" id="errors_err_http2_no_socket_manipulation">#</a></span></h4>
 <p>An attempt was made to directly manipulate (read, write, pause, resume, etc.) a
 socket attached to an <code>Http2Session</code>.</p>
 <p><a id="ERR_HTTP2_ORIGIN_LENGTH"></a></p>
-<h3><code>ERR_HTTP2_ORIGIN_LENGTH</code><span><a class="mark" href="#errors_err_http2_origin_length" id="errors_err_http2_origin_length">#</a></span></h3>
+<h4><code>ERR_HTTP2_ORIGIN_LENGTH</code><span><a class="mark" href="#errors_err_http2_origin_length" id="errors_err_http2_origin_length">#</a></span></h4>
 <p>HTTP/2 <code>ORIGIN</code> frames are limited to a length of 16382 bytes.</p>
 <p><a id="ERR_HTTP2_OUT_OF_STREAMS"></a></p>
-<h3><code>ERR_HTTP2_OUT_OF_STREAMS</code><span><a class="mark" href="#errors_err_http2_out_of_streams" id="errors_err_http2_out_of_streams">#</a></span></h3>
+<h4><code>ERR_HTTP2_OUT_OF_STREAMS</code><span><a class="mark" href="#errors_err_http2_out_of_streams" id="errors_err_http2_out_of_streams">#</a></span></h4>
 <p>The number of streams created on a single HTTP/2 session reached the maximum
 limit.</p>
 <p><a id="ERR_HTTP2_PAYLOAD_FORBIDDEN"></a></p>
-<h3><code>ERR_HTTP2_PAYLOAD_FORBIDDEN</code><span><a class="mark" href="#errors_err_http2_payload_forbidden" id="errors_err_http2_payload_forbidden">#</a></span></h3>
+<h4><code>ERR_HTTP2_PAYLOAD_FORBIDDEN</code><span><a class="mark" href="#errors_err_http2_payload_forbidden" id="errors_err_http2_payload_forbidden">#</a></span></h4>
 <p>A message payload was specified for an HTTP response code for which a payload is
 forbidden.</p>
 <p><a id="ERR_HTTP2_PING_CANCEL"></a></p>
-<h3><code>ERR_HTTP2_PING_CANCEL</code><span><a class="mark" href="#errors_err_http2_ping_cancel" id="errors_err_http2_ping_cancel">#</a></span></h3>
+<h4><code>ERR_HTTP2_PING_CANCEL</code><span><a class="mark" href="#errors_err_http2_ping_cancel" id="errors_err_http2_ping_cancel">#</a></span></h4>
 <p>An HTTP/2 ping was canceled.</p>
 <p><a id="ERR_HTTP2_PING_LENGTH"></a></p>
-<h3><code>ERR_HTTP2_PING_LENGTH</code><span><a class="mark" href="#errors_err_http2_ping_length" id="errors_err_http2_ping_length">#</a></span></h3>
+<h4><code>ERR_HTTP2_PING_LENGTH</code><span><a class="mark" href="#errors_err_http2_ping_length" id="errors_err_http2_ping_length">#</a></span></h4>
 <p>HTTP/2 ping payloads must be exactly 8 bytes in length.</p>
 <p><a id="ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED"></a></p>
-<h3><code>ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_http2_pseudoheader_not_allowed" id="errors_err_http2_pseudoheader_not_allowed">#</a></span></h3>
+<h4><code>ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_http2_pseudoheader_not_allowed" id="errors_err_http2_pseudoheader_not_allowed">#</a></span></h4>
 <p>An HTTP/2 pseudo-header has been used inappropriately. Pseudo-headers are header
 key names that begin with the <code>:</code> prefix.</p>
 <p><a id="ERR_HTTP2_PUSH_DISABLED"></a></p>
-<h3><code>ERR_HTTP2_PUSH_DISABLED</code><span><a class="mark" href="#errors_err_http2_push_disabled" id="errors_err_http2_push_disabled">#</a></span></h3>
+<h4><code>ERR_HTTP2_PUSH_DISABLED</code><span><a class="mark" href="#errors_err_http2_push_disabled" id="errors_err_http2_push_disabled">#</a></span></h4>
 <p>An attempt was made to create a push stream, which had been disabled by the
 client.</p>
 <p><a id="ERR_HTTP2_SEND_FILE"></a></p>
-<h3><code>ERR_HTTP2_SEND_FILE</code><span><a class="mark" href="#errors_err_http2_send_file" id="errors_err_http2_send_file">#</a></span></h3>
+<h4><code>ERR_HTTP2_SEND_FILE</code><span><a class="mark" href="#errors_err_http2_send_file" id="errors_err_http2_send_file">#</a></span></h4>
 <p>An attempt was made to use the <code>Http2Stream.prototype.responseWithFile()</code> API to
 send a directory.</p>
 <p><a id="ERR_HTTP2_SEND_FILE_NOSEEK"></a></p>
-<h3><code>ERR_HTTP2_SEND_FILE_NOSEEK</code><span><a class="mark" href="#errors_err_http2_send_file_noseek" id="errors_err_http2_send_file_noseek">#</a></span></h3>
+<h4><code>ERR_HTTP2_SEND_FILE_NOSEEK</code><span><a class="mark" href="#errors_err_http2_send_file_noseek" id="errors_err_http2_send_file_noseek">#</a></span></h4>
 <p>An attempt was made to use the <code>Http2Stream.prototype.responseWithFile()</code> API to
 send something other than a regular file, but <code>offset</code> or <code>length</code> options were
 provided.</p>
 <p><a id="ERR_HTTP2_SESSION_ERROR"></a></p>
-<h3><code>ERR_HTTP2_SESSION_ERROR</code><span><a class="mark" href="#errors_err_http2_session_error" id="errors_err_http2_session_error">#</a></span></h3>
+<h4><code>ERR_HTTP2_SESSION_ERROR</code><span><a class="mark" href="#errors_err_http2_session_error" id="errors_err_http2_session_error">#</a></span></h4>
 <p>The <code>Http2Session</code> closed with a non-zero error code.</p>
 <p><a id="ERR_HTTP2_SETTINGS_CANCEL"></a></p>
-<h3><code>ERR_HTTP2_SETTINGS_CANCEL</code><span><a class="mark" href="#errors_err_http2_settings_cancel" id="errors_err_http2_settings_cancel">#</a></span></h3>
+<h4><code>ERR_HTTP2_SETTINGS_CANCEL</code><span><a class="mark" href="#errors_err_http2_settings_cancel" id="errors_err_http2_settings_cancel">#</a></span></h4>
 <p>The <code>Http2Session</code> settings canceled.</p>
 <p><a id="ERR_HTTP2_SOCKET_BOUND"></a></p>
-<h3><code>ERR_HTTP2_SOCKET_BOUND</code><span><a class="mark" href="#errors_err_http2_socket_bound" id="errors_err_http2_socket_bound">#</a></span></h3>
+<h4><code>ERR_HTTP2_SOCKET_BOUND</code><span><a class="mark" href="#errors_err_http2_socket_bound" id="errors_err_http2_socket_bound">#</a></span></h4>
 <p>An attempt was made to connect a <code>Http2Session</code> object to a <code>net.Socket</code> or
 <code>tls.TLSSocket</code> that had already been bound to another <code>Http2Session</code> object.</p>
 <p><a id="ERR_HTTP2_SOCKET_UNBOUND"></a></p>
-<h3><code>ERR_HTTP2_SOCKET_UNBOUND</code><span><a class="mark" href="#errors_err_http2_socket_unbound" id="errors_err_http2_socket_unbound">#</a></span></h3>
+<h4><code>ERR_HTTP2_SOCKET_UNBOUND</code><span><a class="mark" href="#errors_err_http2_socket_unbound" id="errors_err_http2_socket_unbound">#</a></span></h4>
 <p>An attempt was made to use the <code>socket</code> property of an <code>Http2Session</code> that
 has already been closed.</p>
 <p><a id="ERR_HTTP2_STATUS_101"></a></p>
-<h3><code>ERR_HTTP2_STATUS_101</code><span><a class="mark" href="#errors_err_http2_status_101" id="errors_err_http2_status_101">#</a></span></h3>
+<h4><code>ERR_HTTP2_STATUS_101</code><span><a class="mark" href="#errors_err_http2_status_101" id="errors_err_http2_status_101">#</a></span></h4>
 <p>Use of the <code>101</code> Informational status code is forbidden in HTTP/2.</p>
 <p><a id="ERR_HTTP2_STATUS_INVALID"></a></p>
-<h3><code>ERR_HTTP2_STATUS_INVALID</code><span><a class="mark" href="#errors_err_http2_status_invalid" id="errors_err_http2_status_invalid">#</a></span></h3>
+<h4><code>ERR_HTTP2_STATUS_INVALID</code><span><a class="mark" href="#errors_err_http2_status_invalid" id="errors_err_http2_status_invalid">#</a></span></h4>
 <p>An invalid HTTP status code has been specified. Status codes must be an integer
 between <code>100</code> and <code>599</code> (inclusive).</p>
 <p><a id="ERR_HTTP2_STREAM_CANCEL"></a></p>
-<h3><code>ERR_HTTP2_STREAM_CANCEL</code><span><a class="mark" href="#errors_err_http2_stream_cancel" id="errors_err_http2_stream_cancel">#</a></span></h3>
+<h4><code>ERR_HTTP2_STREAM_CANCEL</code><span><a class="mark" href="#errors_err_http2_stream_cancel" id="errors_err_http2_stream_cancel">#</a></span></h4>
 <p>An <code>Http2Stream</code> was destroyed before any data was transmitted to the connected
 peer.</p>
 <p><a id="ERR_HTTP2_STREAM_ERROR"></a></p>
-<h3><code>ERR_HTTP2_STREAM_ERROR</code><span><a class="mark" href="#errors_err_http2_stream_error" id="errors_err_http2_stream_error">#</a></span></h3>
+<h4><code>ERR_HTTP2_STREAM_ERROR</code><span><a class="mark" href="#errors_err_http2_stream_error" id="errors_err_http2_stream_error">#</a></span></h4>
 <p>A non-zero error code was been specified in an <code>RST_STREAM</code> frame.</p>
 <p><a id="ERR_HTTP2_STREAM_SELF_DEPENDENCY"></a></p>
-<h3><code>ERR_HTTP2_STREAM_SELF_DEPENDENCY</code><span><a class="mark" href="#errors_err_http2_stream_self_dependency" id="errors_err_http2_stream_self_dependency">#</a></span></h3>
+<h4><code>ERR_HTTP2_STREAM_SELF_DEPENDENCY</code><span><a class="mark" href="#errors_err_http2_stream_self_dependency" id="errors_err_http2_stream_self_dependency">#</a></span></h4>
 <p>When setting the priority for an HTTP/2 stream, the stream may be marked as
 a dependency for a parent stream. This error code is used when an attempt is
 made to mark a stream and dependent of itself.</p>
 <p><a id="ERR_HTTP2_TRAILERS_ALREADY_SENT"></a></p>
-<h3><code>ERR_HTTP2_TRAILERS_ALREADY_SENT</code><span><a class="mark" href="#errors_err_http2_trailers_already_sent" id="errors_err_http2_trailers_already_sent">#</a></span></h3>
+<h4><code>ERR_HTTP2_TRAILERS_ALREADY_SENT</code><span><a class="mark" href="#errors_err_http2_trailers_already_sent" id="errors_err_http2_trailers_already_sent">#</a></span></h4>
 <p>Trailing headers have already been sent on the <code>Http2Stream</code>.</p>
 <p><a id="ERR_HTTP2_TRAILERS_NOT_READY"></a></p>
-<h3><code>ERR_HTTP2_TRAILERS_NOT_READY</code><span><a class="mark" href="#errors_err_http2_trailers_not_ready" id="errors_err_http2_trailers_not_ready">#</a></span></h3>
+<h4><code>ERR_HTTP2_TRAILERS_NOT_READY</code><span><a class="mark" href="#errors_err_http2_trailers_not_ready" id="errors_err_http2_trailers_not_ready">#</a></span></h4>
 <p>The <code>http2stream.sendTrailers()</code> method cannot be called until after the
 <code>'wantTrailers'</code> event is emitted on an <code>Http2Stream</code> object. The
 <code>'wantTrailers'</code> event will only be emitted if the <code>waitForTrailers</code> option
 is set for the <code>Http2Stream</code>.</p>
 <p><a id="ERR_HTTP2_UNSUPPORTED_PROTOCOL"></a></p>
-<h3><code>ERR_HTTP2_UNSUPPORTED_PROTOCOL</code><span><a class="mark" href="#errors_err_http2_unsupported_protocol" id="errors_err_http2_unsupported_protocol">#</a></span></h3>
+<h4><code>ERR_HTTP2_UNSUPPORTED_PROTOCOL</code><span><a class="mark" href="#errors_err_http2_unsupported_protocol" id="errors_err_http2_unsupported_protocol">#</a></span></h4>
 <p><code>http2.connect()</code> was passed a URL that uses any protocol other than <code>http:</code> or
 <code>https:</code>.</p>
-<p><a id="ERR_INTERNAL_ASSERTION"></a></p>
-<h3><code>ERR_INTERNAL_ASSERTION</code><span><a class="mark" href="#errors_err_internal_assertion" id="errors_err_internal_assertion">#</a></span></h3>
-<p>There was a bug in Node.js or incorrect usage of Node.js internals.
-To fix the error, open an issue at <a href="https://github.com/nodejs/node/issues">https://github.com/nodejs/node/issues</a>.</p>
 <p><a id="ERR_INCOMPATIBLE_OPTION_PAIR"></a></p>
-<h3><code>ERR_INCOMPATIBLE_OPTION_PAIR</code><span><a class="mark" href="#errors_err_incompatible_option_pair" id="errors_err_incompatible_option_pair">#</a></span></h3>
+<h4><code>ERR_INCOMPATIBLE_OPTION_PAIR</code><span><a class="mark" href="#errors_err_incompatible_option_pair" id="errors_err_incompatible_option_pair">#</a></span></h4>
 <p>An option pair is incompatible with each other and cannot be used at the same
 time.</p>
 <p><a id="ERR_INPUT_TYPE_NOT_ALLOWED"></a></p>
-<h3><code>ERR_INPUT_TYPE_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_input_type_not_allowed" id="errors_err_input_type_not_allowed">#</a></span></h3>
+<h4><code>ERR_INPUT_TYPE_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_input_type_not_allowed" id="errors_err_input_type_not_allowed">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>The <code>--input-type</code> flag was used to attempt to execute a file. This flag can
 only be used with input via <code>--eval</code>, <code>--print</code> or <code>STDIN</code>.</p>
 <p><a id="ERR_INSPECTOR_ALREADY_ACTIVATED"></a></p>
-<h3><code>ERR_INSPECTOR_ALREADY_ACTIVATED</code><span><a class="mark" href="#errors_err_inspector_already_activated" id="errors_err_inspector_already_activated">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_ALREADY_ACTIVATED</code><span><a class="mark" href="#errors_err_inspector_already_activated" id="errors_err_inspector_already_activated">#</a></span></h4>
 <p>While using the <code>inspector</code> module, an attempt was made to activate the
 inspector when it already started to listen on a port. Use <code>inspector.close()</code>
 before activating it on a different address.</p>
 <p><a id="ERR_INSPECTOR_ALREADY_CONNECTED"></a></p>
-<h3><code>ERR_INSPECTOR_ALREADY_CONNECTED</code><span><a class="mark" href="#errors_err_inspector_already_connected" id="errors_err_inspector_already_connected">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_ALREADY_CONNECTED</code><span><a class="mark" href="#errors_err_inspector_already_connected" id="errors_err_inspector_already_connected">#</a></span></h4>
 <p>While using the <code>inspector</code> module, an attempt was made to connect when the
 inspector was already connected.</p>
 <p><a id="ERR_INSPECTOR_CLOSED"></a></p>
-<h3><code>ERR_INSPECTOR_CLOSED</code><span><a class="mark" href="#errors_err_inspector_closed" id="errors_err_inspector_closed">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_CLOSED</code><span><a class="mark" href="#errors_err_inspector_closed" id="errors_err_inspector_closed">#</a></span></h4>
 <p>While using the <code>inspector</code> module, an attempt was made to use the inspector
 after the session had already closed.</p>
 <p><a id="ERR_INSPECTOR_COMMAND"></a></p>
-<h3><code>ERR_INSPECTOR_COMMAND</code><span><a class="mark" href="#errors_err_inspector_command" id="errors_err_inspector_command">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_COMMAND</code><span><a class="mark" href="#errors_err_inspector_command" id="errors_err_inspector_command">#</a></span></h4>
 <p>An error occurred while issuing a command via the <code>inspector</code> module.</p>
 <p><a id="ERR_INSPECTOR_NOT_ACTIVE"></a></p>
-<h3><code>ERR_INSPECTOR_NOT_ACTIVE</code><span><a class="mark" href="#errors_err_inspector_not_active" id="errors_err_inspector_not_active">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_NOT_ACTIVE</code><span><a class="mark" href="#errors_err_inspector_not_active" id="errors_err_inspector_not_active">#</a></span></h4>
 <p>The <code>inspector</code> is not active when <code>inspector.waitForDebugger()</code> is called.</p>
 <p><a id="ERR_INSPECTOR_NOT_AVAILABLE"></a></p>
-<h3><code>ERR_INSPECTOR_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_inspector_not_available" id="errors_err_inspector_not_available">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_inspector_not_available" id="errors_err_inspector_not_available">#</a></span></h4>
 <p>The <code>inspector</code> module is not available for use.</p>
 <p><a id="ERR_INSPECTOR_NOT_CONNECTED"></a></p>
-<h3><code>ERR_INSPECTOR_NOT_CONNECTED</code><span><a class="mark" href="#errors_err_inspector_not_connected" id="errors_err_inspector_not_connected">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_NOT_CONNECTED</code><span><a class="mark" href="#errors_err_inspector_not_connected" id="errors_err_inspector_not_connected">#</a></span></h4>
 <p>While using the <code>inspector</code> module, an attempt was made to use the inspector
 before it was connected.</p>
 <p><a id="ERR_INSPECTOR_NOT_WORKER"></a></p>
-<h3><code>ERR_INSPECTOR_NOT_WORKER</code><span><a class="mark" href="#errors_err_inspector_not_worker" id="errors_err_inspector_not_worker">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_NOT_WORKER</code><span><a class="mark" href="#errors_err_inspector_not_worker" id="errors_err_inspector_not_worker">#</a></span></h4>
 <p>An API was called on the main thread that can only be used from
 the worker thread.</p>
+<p><a id="ERR_INTERNAL_ASSERTION"></a></p>
+<h4><code>ERR_INTERNAL_ASSERTION</code><span><a class="mark" href="#errors_err_internal_assertion" id="errors_err_internal_assertion">#</a></span></h4>
+<p>There was a bug in Node.js or incorrect usage of Node.js internals.
+To fix the error, open an issue at <a href="https://github.com/nodejs/node/issues">https://github.com/nodejs/node/issues</a>.</p>
 <p><a id="ERR_INVALID_ADDRESS_FAMILY"></a></p>
-<h3><code>ERR_INVALID_ADDRESS_FAMILY</code><span><a class="mark" href="#errors_err_invalid_address_family" id="errors_err_invalid_address_family">#</a></span></h3>
+<h4><code>ERR_INVALID_ADDRESS_FAMILY</code><span><a class="mark" href="#errors_err_invalid_address_family" id="errors_err_invalid_address_family">#</a></span></h4>
 <p>The provided address family is not understood by the Node.js API.</p>
 <p><a id="ERR_INVALID_ARG_TYPE"></a></p>
-<h3><code>ERR_INVALID_ARG_TYPE</code><span><a class="mark" href="#errors_err_invalid_arg_type" id="errors_err_invalid_arg_type">#</a></span></h3>
+<h4><code>ERR_INVALID_ARG_TYPE</code><span><a class="mark" href="#errors_err_invalid_arg_type" id="errors_err_invalid_arg_type">#</a></span></h4>
 <p>An argument of the wrong type was passed to a Node.js API.</p>
 <p><a id="ERR_INVALID_ARG_VALUE"></a></p>
-<h3><code>ERR_INVALID_ARG_VALUE</code><span><a class="mark" href="#errors_err_invalid_arg_value" id="errors_err_invalid_arg_value">#</a></span></h3>
+<h4><code>ERR_INVALID_ARG_VALUE</code><span><a class="mark" href="#errors_err_invalid_arg_value" id="errors_err_invalid_arg_value">#</a></span></h4>
 <p>An invalid or unsupported value was passed for a given argument.</p>
 <p><a id="ERR_INVALID_ASYNC_ID"></a></p>
-<h3><code>ERR_INVALID_ASYNC_ID</code><span><a class="mark" href="#errors_err_invalid_async_id" id="errors_err_invalid_async_id">#</a></span></h3>
+<h4><code>ERR_INVALID_ASYNC_ID</code><span><a class="mark" href="#errors_err_invalid_async_id" id="errors_err_invalid_async_id">#</a></span></h4>
 <p>An invalid <code>asyncId</code> or <code>triggerAsyncId</code> was passed using <code>AsyncHooks</code>. An id
 less than -1 should never happen.</p>
 <p><a id="ERR_INVALID_BUFFER_SIZE"></a></p>
-<h3><code>ERR_INVALID_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_invalid_buffer_size" id="errors_err_invalid_buffer_size">#</a></span></h3>
+<h4><code>ERR_INVALID_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_invalid_buffer_size" id="errors_err_invalid_buffer_size">#</a></span></h4>
 <p>A swap was performed on a <code>Buffer</code> but its size was not compatible with the
 operation.</p>
 <p><a id="ERR_INVALID_CALLBACK"></a></p>
-<h3><code>ERR_INVALID_CALLBACK</code><span><a class="mark" href="#errors_err_invalid_callback" id="errors_err_invalid_callback">#</a></span></h3>
+<h4><code>ERR_INVALID_CALLBACK</code><span><a class="mark" href="#errors_err_invalid_callback" id="errors_err_invalid_callback">#</a></span></h4>
 <p>A callback function was required but was not been provided to a Node.js API.</p>
 <p><a id="ERR_INVALID_CHAR"></a></p>
-<h3><code>ERR_INVALID_CHAR</code><span><a class="mark" href="#errors_err_invalid_char" id="errors_err_invalid_char">#</a></span></h3>
+<h4><code>ERR_INVALID_CHAR</code><span><a class="mark" href="#errors_err_invalid_char" id="errors_err_invalid_char">#</a></span></h4>
 <p>Invalid characters were detected in headers.</p>
 <p><a id="ERR_INVALID_CURSOR_POS"></a></p>
-<h3><code>ERR_INVALID_CURSOR_POS</code><span><a class="mark" href="#errors_err_invalid_cursor_pos" id="errors_err_invalid_cursor_pos">#</a></span></h3>
+<h4><code>ERR_INVALID_CURSOR_POS</code><span><a class="mark" href="#errors_err_invalid_cursor_pos" id="errors_err_invalid_cursor_pos">#</a></span></h4>
 <p>A cursor on a given stream cannot be moved to a specified row without a
 specified column.</p>
 <p><a id="ERR_INVALID_FD"></a></p>
-<h3><code>ERR_INVALID_FD</code><span><a class="mark" href="#errors_err_invalid_fd" id="errors_err_invalid_fd">#</a></span></h3>
+<h4><code>ERR_INVALID_FD</code><span><a class="mark" href="#errors_err_invalid_fd" id="errors_err_invalid_fd">#</a></span></h4>
 <p>A file descriptor ('fd') was not valid (e.g. it was a negative value).</p>
 <p><a id="ERR_INVALID_FD_TYPE"></a></p>
-<h3><code>ERR_INVALID_FD_TYPE</code><span><a class="mark" href="#errors_err_invalid_fd_type" id="errors_err_invalid_fd_type">#</a></span></h3>
+<h4><code>ERR_INVALID_FD_TYPE</code><span><a class="mark" href="#errors_err_invalid_fd_type" id="errors_err_invalid_fd_type">#</a></span></h4>
 <p>A file descriptor ('fd') type was not valid.</p>
 <p><a id="ERR_INVALID_FILE_URL_HOST"></a></p>
-<h3><code>ERR_INVALID_FILE_URL_HOST</code><span><a class="mark" href="#errors_err_invalid_file_url_host" id="errors_err_invalid_file_url_host">#</a></span></h3>
+<h4><code>ERR_INVALID_FILE_URL_HOST</code><span><a class="mark" href="#errors_err_invalid_file_url_host" id="errors_err_invalid_file_url_host">#</a></span></h4>
 <p>A Node.js API that consumes <code>file:</code> URLs (such as certain functions in the
 <a href="fs.html"><code>fs</code></a> module) encountered a file URL with an incompatible host. This
 situation can only occur on Unix-like systems where only <code>localhost</code> or an empty
 host is supported.</p>
 <p><a id="ERR_INVALID_FILE_URL_PATH"></a></p>
-<h3><code>ERR_INVALID_FILE_URL_PATH</code><span><a class="mark" href="#errors_err_invalid_file_url_path" id="errors_err_invalid_file_url_path">#</a></span></h3>
+<h4><code>ERR_INVALID_FILE_URL_PATH</code><span><a class="mark" href="#errors_err_invalid_file_url_path" id="errors_err_invalid_file_url_path">#</a></span></h4>
 <p>A Node.js API that consumes <code>file:</code> URLs (such as certain functions in the
 <a href="fs.html"><code>fs</code></a> module) encountered a file URL with an incompatible path. The exact
 semantics for determining whether a path can be used is platform-dependent.</p>
 <p><a id="ERR_INVALID_HANDLE_TYPE"></a></p>
-<h3><code>ERR_INVALID_HANDLE_TYPE</code><span><a class="mark" href="#errors_err_invalid_handle_type" id="errors_err_invalid_handle_type">#</a></span></h3>
+<h4><code>ERR_INVALID_HANDLE_TYPE</code><span><a class="mark" href="#errors_err_invalid_handle_type" id="errors_err_invalid_handle_type">#</a></span></h4>
 <p>An attempt was made to send an unsupported "handle" over an IPC communication
 channel to a child process. See <a href="#child_process_subprocess_send_message_sendhandle_options_callback"><code>subprocess.send()</code></a> and <a href="#process_process_send_message_sendhandle_options_callback"><code>process.send()</code></a>
 for more information.</p>
 <p><a id="ERR_INVALID_HTTP_TOKEN"></a></p>
-<h3><code>ERR_INVALID_HTTP_TOKEN</code><span><a class="mark" href="#errors_err_invalid_http_token" id="errors_err_invalid_http_token">#</a></span></h3>
+<h4><code>ERR_INVALID_HTTP_TOKEN</code><span><a class="mark" href="#errors_err_invalid_http_token" id="errors_err_invalid_http_token">#</a></span></h4>
 <p>An invalid HTTP token was supplied.</p>
 <p><a id="ERR_INVALID_IP_ADDRESS"></a></p>
-<h3><code>ERR_INVALID_IP_ADDRESS</code><span><a class="mark" href="#errors_err_invalid_ip_address" id="errors_err_invalid_ip_address">#</a></span></h3>
+<h4><code>ERR_INVALID_IP_ADDRESS</code><span><a class="mark" href="#errors_err_invalid_ip_address" id="errors_err_invalid_ip_address">#</a></span></h4>
 <p>An IP address is not valid.</p>
+<p><a id="ERR_INVALID_MODULE"></a></p>
+<h4><code>ERR_INVALID_MODULE</code><span><a class="mark" href="#errors_err_invalid_module" id="errors_err_invalid_module">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>An attempt was made to load a module that does not exist or was otherwise not
+valid.</p>
 <p><a id="ERR_INVALID_MODULE_SPECIFIER"></a></p>
-<h3><code>ERR_INVALID_MODULE_SPECIFIER</code><span><a class="mark" href="#errors_err_invalid_module_specifier" id="errors_err_invalid_module_specifier">#</a></span></h3>
+<h4><code>ERR_INVALID_MODULE_SPECIFIER</code><span><a class="mark" href="#errors_err_invalid_module_specifier" id="errors_err_invalid_module_specifier">#</a></span></h4>
 <p>The imported module string is an invalid URL, package name, or package subpath
 specifier.</p>
 <p><a id="ERR_INVALID_OPT_VALUE"></a></p>
-<h3><code>ERR_INVALID_OPT_VALUE</code><span><a class="mark" href="#errors_err_invalid_opt_value" id="errors_err_invalid_opt_value">#</a></span></h3>
+<h4><code>ERR_INVALID_OPT_VALUE</code><span><a class="mark" href="#errors_err_invalid_opt_value" id="errors_err_invalid_opt_value">#</a></span></h4>
 <p>An invalid or unexpected value was passed in an options object.</p>
 <p><a id="ERR_INVALID_OPT_VALUE_ENCODING"></a></p>
-<h3><code>ERR_INVALID_OPT_VALUE_ENCODING</code><span><a class="mark" href="#errors_err_invalid_opt_value_encoding" id="errors_err_invalid_opt_value_encoding">#</a></span></h3>
+<h4><code>ERR_INVALID_OPT_VALUE_ENCODING</code><span><a class="mark" href="#errors_err_invalid_opt_value_encoding" id="errors_err_invalid_opt_value_encoding">#</a></span></h4>
 <p>An invalid or unknown file encoding was passed.</p>
 <p><a id="ERR_INVALID_PACKAGE_CONFIG"></a></p>
-<h3><code>ERR_INVALID_PACKAGE_CONFIG</code><span><a class="mark" href="#errors_err_invalid_package_config" id="errors_err_invalid_package_config">#</a></span></h3>
+<h4><code>ERR_INVALID_PACKAGE_CONFIG</code><span><a class="mark" href="#errors_err_invalid_package_config" id="errors_err_invalid_package_config">#</a></span></h4>
 <p>An invalid <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file was found which failed parsing.</p>
 <p><a id="ERR_INVALID_PACKAGE_TARGET"></a></p>
-<h3><code>ERR_INVALID_PACKAGE_TARGET</code><span><a class="mark" href="#errors_err_invalid_package_target" id="errors_err_invalid_package_target">#</a></span></h3>
+<h4><code>ERR_INVALID_PACKAGE_TARGET</code><span><a class="mark" href="#errors_err_invalid_package_target" id="errors_err_invalid_package_target">#</a></span></h4>
 <p>The <code>package.json</code> <a href="#packages_exports"><code>"exports"</code></a> field contains an invalid target mapping
 value for the attempted module resolution.</p>
 <p><a id="ERR_INVALID_PERFORMANCE_MARK"></a></p>
-<h3><code>ERR_INVALID_PERFORMANCE_MARK</code><span><a class="mark" href="#errors_err_invalid_performance_mark" id="errors_err_invalid_performance_mark">#</a></span></h3>
+<h4><code>ERR_INVALID_PERFORMANCE_MARK</code><span><a class="mark" href="#errors_err_invalid_performance_mark" id="errors_err_invalid_performance_mark">#</a></span></h4>
 <p>While using the Performance Timing API (<code>perf_hooks</code>), a performance mark is
 invalid.</p>
 <p><a id="ERR_INVALID_PROTOCOL"></a></p>
-<h3><code>ERR_INVALID_PROTOCOL</code><span><a class="mark" href="#errors_err_invalid_protocol" id="errors_err_invalid_protocol">#</a></span></h3>
+<h4><code>ERR_INVALID_PROTOCOL</code><span><a class="mark" href="#errors_err_invalid_protocol" id="errors_err_invalid_protocol">#</a></span></h4>
 <p>An invalid <code>options.protocol</code> was passed to <code>http.request()</code>.</p>
 <p><a id="ERR_INVALID_REPL_EVAL_CONFIG"></a></p>
-<h3><code>ERR_INVALID_REPL_EVAL_CONFIG</code><span><a class="mark" href="#errors_err_invalid_repl_eval_config" id="errors_err_invalid_repl_eval_config">#</a></span></h3>
+<h4><code>ERR_INVALID_REPL_EVAL_CONFIG</code><span><a class="mark" href="#errors_err_invalid_repl_eval_config" id="errors_err_invalid_repl_eval_config">#</a></span></h4>
 <p>Both <code>breakEvalOnSigint</code> and <code>eval</code> options were set in the <a href="repl.html"><code>REPL</code></a> config,
 which is not supported.</p>
 <p><a id="ERR_INVALID_REPL_INPUT"></a></p>
-<h3><code>ERR_INVALID_REPL_INPUT</code><span><a class="mark" href="#errors_err_invalid_repl_input" id="errors_err_invalid_repl_input">#</a></span></h3>
-<p>The input may not be used in the <a href="repl.html"><code>REPL</code></a>. All prohibited inputs are
-documented in the <a href="repl.html"><code>REPL</code></a>'s documentation.</p>
+<h4><code>ERR_INVALID_REPL_INPUT</code><span><a class="mark" href="#errors_err_invalid_repl_input" id="errors_err_invalid_repl_input">#</a></span></h4>
+<p>The input may not be used in the <a href="repl.html"><code>REPL</code></a>. The conditions under which this
+error is used are described in the <a href="repl.html"><code>REPL</code></a> documentation.</p>
 <p><a id="ERR_INVALID_RETURN_PROPERTY"></a></p>
-<h3><code>ERR_INVALID_RETURN_PROPERTY</code><span><a class="mark" href="#errors_err_invalid_return_property" id="errors_err_invalid_return_property">#</a></span></h3>
+<h4><code>ERR_INVALID_RETURN_PROPERTY</code><span><a class="mark" href="#errors_err_invalid_return_property" id="errors_err_invalid_return_property">#</a></span></h4>
 <p>Thrown in case a function option does not provide a valid value for one of its
 returned object properties on execution.</p>
 <p><a id="ERR_INVALID_RETURN_PROPERTY_VALUE"></a></p>
-<h3><code>ERR_INVALID_RETURN_PROPERTY_VALUE</code><span><a class="mark" href="#errors_err_invalid_return_property_value" id="errors_err_invalid_return_property_value">#</a></span></h3>
+<h4><code>ERR_INVALID_RETURN_PROPERTY_VALUE</code><span><a class="mark" href="#errors_err_invalid_return_property_value" id="errors_err_invalid_return_property_value">#</a></span></h4>
 <p>Thrown in case a function option does not provide an expected value
 type for one of its returned object properties on execution.</p>
 <p><a id="ERR_INVALID_RETURN_VALUE"></a></p>
-<h3><code>ERR_INVALID_RETURN_VALUE</code><span><a class="mark" href="#errors_err_invalid_return_value" id="errors_err_invalid_return_value">#</a></span></h3>
+<h4><code>ERR_INVALID_RETURN_VALUE</code><span><a class="mark" href="#errors_err_invalid_return_value" id="errors_err_invalid_return_value">#</a></span></h4>
 <p>Thrown in case a function option does not return an expected value
 type on execution, such as when a function is expected to return a promise.</p>
 <p><a id="ERR_INVALID_SYNC_FORK_INPUT"></a></p>
-<h3><code>ERR_INVALID_SYNC_FORK_INPUT</code><span><a class="mark" href="#errors_err_invalid_sync_fork_input" id="errors_err_invalid_sync_fork_input">#</a></span></h3>
+<h4><code>ERR_INVALID_SYNC_FORK_INPUT</code><span><a class="mark" href="#errors_err_invalid_sync_fork_input" id="errors_err_invalid_sync_fork_input">#</a></span></h4>
 <p>A <code>Buffer</code>, <code>TypedArray</code>, <code>DataView</code> or <code>string</code> was provided as stdio input to
 an asynchronous fork. See the documentation for the <a href="child_process.html"><code>child_process</code></a> module
 for more information.</p>
 <p><a id="ERR_INVALID_THIS"></a></p>
-<h3><code>ERR_INVALID_THIS</code><span><a class="mark" href="#errors_err_invalid_this" id="errors_err_invalid_this">#</a></span></h3>
+<h4><code>ERR_INVALID_THIS</code><span><a class="mark" href="#errors_err_invalid_this" id="errors_err_invalid_this">#</a></span></h4>
 <p>A Node.js API function was called with an incompatible <code>this</code> value.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> urlSearchParams = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'foo=bar&#x26;baz=new'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> urlSearchParams = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'foo=bar&#x26;baz=new'</span>);
 
-<span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">1</span>);
-urlSearchParams.has.call(buf, <span class="hljs-string">'foo'</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">1</span>);
+urlSearchParams.<span class="hljs-property">has</span>.<span class="hljs-title function_">call</span>(buf, <span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Throws a TypeError with code 'ERR_INVALID_THIS'</span></code></pre>
 <p><a id="ERR_INVALID_TRANSFER_OBJECT"></a></p>
-<h3><code>ERR_INVALID_TRANSFER_OBJECT</code><span><a class="mark" href="#errors_err_invalid_transfer_object" id="errors_err_invalid_transfer_object">#</a></span></h3>
+<h4><code>ERR_INVALID_TRANSFER_OBJECT</code><span><a class="mark" href="#errors_err_invalid_transfer_object" id="errors_err_invalid_transfer_object">#</a></span></h4>
 <p>An invalid transfer object was passed to <code>postMessage()</code>.</p>
 <p><a id="ERR_INVALID_TUPLE"></a></p>
-<h3><code>ERR_INVALID_TUPLE</code><span><a class="mark" href="#errors_err_invalid_tuple" id="errors_err_invalid_tuple">#</a></span></h3>
+<h4><code>ERR_INVALID_TUPLE</code><span><a class="mark" href="#errors_err_invalid_tuple" id="errors_err_invalid_tuple">#</a></span></h4>
 <p>An element in the <code>iterable</code> provided to the <a href="#url_the_whatwg_url_api">WHATWG</a>
 <a href="#url_new_urlsearchparams_iterable"><code>URLSearchParams</code> constructor</a> did not
 represent a <code>[name, value]</code> tuple – that is, if an element is not iterable, or
 does not consist of exactly two elements.</p>
 <p><a id="ERR_INVALID_URI"></a></p>
-<h3><code>ERR_INVALID_URI</code><span><a class="mark" href="#errors_err_invalid_uri" id="errors_err_invalid_uri">#</a></span></h3>
+<h4><code>ERR_INVALID_URI</code><span><a class="mark" href="#errors_err_invalid_uri" id="errors_err_invalid_uri">#</a></span></h4>
 <p>An invalid URI was passed.</p>
 <p><a id="ERR_INVALID_URL"></a></p>
-<h3><code>ERR_INVALID_URL</code><span><a class="mark" href="#errors_err_invalid_url" id="errors_err_invalid_url">#</a></span></h3>
+<h4><code>ERR_INVALID_URL</code><span><a class="mark" href="#errors_err_invalid_url" id="errors_err_invalid_url">#</a></span></h4>
 <p>An invalid URL was passed to the <a href="#url_the_whatwg_url_api">WHATWG</a>
 <a href="#url_new_url_input_base"><code>URL</code> constructor</a> to be parsed. The thrown error object
 typically has an additional property <code>'input'</code> that contains the URL that failed
 to parse.</p>
 <p><a id="ERR_INVALID_URL_SCHEME"></a></p>
-<h3><code>ERR_INVALID_URL_SCHEME</code><span><a class="mark" href="#errors_err_invalid_url_scheme" id="errors_err_invalid_url_scheme">#</a></span></h3>
+<h4><code>ERR_INVALID_URL_SCHEME</code><span><a class="mark" href="#errors_err_invalid_url_scheme" id="errors_err_invalid_url_scheme">#</a></span></h4>
 <p>An attempt was made to use a URL of an incompatible scheme (protocol) for a
 specific purpose. It is only used in the <a href="#url_the_whatwg_url_api">WHATWG URL API</a> support in the
 <a href="fs.html"><code>fs</code></a> module (which only accepts URLs with <code>'file'</code> scheme), but may be used
 in other Node.js APIs as well in the future.</p>
 <p><a id="ERR_IPC_CHANNEL_CLOSED"></a></p>
-<h3><code>ERR_IPC_CHANNEL_CLOSED</code><span><a class="mark" href="#errors_err_ipc_channel_closed" id="errors_err_ipc_channel_closed">#</a></span></h3>
+<h4><code>ERR_IPC_CHANNEL_CLOSED</code><span><a class="mark" href="#errors_err_ipc_channel_closed" id="errors_err_ipc_channel_closed">#</a></span></h4>
 <p>An attempt was made to use an IPC communication channel that was already closed.</p>
 <p><a id="ERR_IPC_DISCONNECTED"></a></p>
-<h3><code>ERR_IPC_DISCONNECTED</code><span><a class="mark" href="#errors_err_ipc_disconnected" id="errors_err_ipc_disconnected">#</a></span></h3>
+<h4><code>ERR_IPC_DISCONNECTED</code><span><a class="mark" href="#errors_err_ipc_disconnected" id="errors_err_ipc_disconnected">#</a></span></h4>
 <p>An attempt was made to disconnect an IPC communication channel that was already
 disconnected. See the documentation for the <a href="child_process.html"><code>child_process</code></a> module
 for more information.</p>
 <p><a id="ERR_IPC_ONE_PIPE"></a></p>
-<h3><code>ERR_IPC_ONE_PIPE</code><span><a class="mark" href="#errors_err_ipc_one_pipe" id="errors_err_ipc_one_pipe">#</a></span></h3>
+<h4><code>ERR_IPC_ONE_PIPE</code><span><a class="mark" href="#errors_err_ipc_one_pipe" id="errors_err_ipc_one_pipe">#</a></span></h4>
 <p>An attempt was made to create a child Node.js process using more than one IPC
 communication channel. See the documentation for the <a href="child_process.html"><code>child_process</code></a> module
 for more information.</p>
 <p><a id="ERR_IPC_SYNC_FORK"></a></p>
-<h3><code>ERR_IPC_SYNC_FORK</code><span><a class="mark" href="#errors_err_ipc_sync_fork" id="errors_err_ipc_sync_fork">#</a></span></h3>
+<h4><code>ERR_IPC_SYNC_FORK</code><span><a class="mark" href="#errors_err_ipc_sync_fork" id="errors_err_ipc_sync_fork">#</a></span></h4>
 <p>An attempt was made to open an IPC communication channel with a synchronously
 forked Node.js process. See the documentation for the <a href="child_process.html"><code>child_process</code></a> module
 for more information.</p>
 <p><a id="ERR_MANIFEST_ASSERT_INTEGRITY"></a></p>
-<h3><code>ERR_MANIFEST_ASSERT_INTEGRITY</code><span><a class="mark" href="#errors_err_manifest_assert_integrity" id="errors_err_manifest_assert_integrity">#</a></span></h3>
+<h4><code>ERR_MANIFEST_ASSERT_INTEGRITY</code><span><a class="mark" href="#errors_err_manifest_assert_integrity" id="errors_err_manifest_assert_integrity">#</a></span></h4>
 <p>An attempt was made to load a resource, but the resource did not match the
 integrity defined by the policy manifest. See the documentation for <a href="policy.html">policy</a>
 manifests for more information.</p>
 <p><a id="ERR_MANIFEST_DEPENDENCY_MISSING"></a></p>
-<h3><code>ERR_MANIFEST_DEPENDENCY_MISSING</code><span><a class="mark" href="#errors_err_manifest_dependency_missing" id="errors_err_manifest_dependency_missing">#</a></span></h3>
+<h4><code>ERR_MANIFEST_DEPENDENCY_MISSING</code><span><a class="mark" href="#errors_err_manifest_dependency_missing" id="errors_err_manifest_dependency_missing">#</a></span></h4>
 <p>An attempt was made to load a resource, but the resource was not listed as a
 dependency from the location that attempted to load it. See the documentation
 for <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MANIFEST_INTEGRITY_MISMATCH"></a></p>
-<h3><code>ERR_MANIFEST_INTEGRITY_MISMATCH</code><span><a class="mark" href="#errors_err_manifest_integrity_mismatch" id="errors_err_manifest_integrity_mismatch">#</a></span></h3>
+<h4><code>ERR_MANIFEST_INTEGRITY_MISMATCH</code><span><a class="mark" href="#errors_err_manifest_integrity_mismatch" id="errors_err_manifest_integrity_mismatch">#</a></span></h4>
 <p>An attempt was made to load a policy manifest, but the manifest had multiple
 entries for a resource which did not match each other. Update the manifest
 entries to match in order to resolve this error. See the documentation for
 <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MANIFEST_INVALID_RESOURCE_FIELD"></a></p>
-<h3><code>ERR_MANIFEST_INVALID_RESOURCE_FIELD</code><span><a class="mark" href="#errors_err_manifest_invalid_resource_field" id="errors_err_manifest_invalid_resource_field">#</a></span></h3>
+<h4><code>ERR_MANIFEST_INVALID_RESOURCE_FIELD</code><span><a class="mark" href="#errors_err_manifest_invalid_resource_field" id="errors_err_manifest_invalid_resource_field">#</a></span></h4>
 <p>A policy manifest resource had an invalid value for one of its fields. Update
 the manifest entry to match in order to resolve this error. See the
 documentation for <a href="policy.html">policy</a> manifests for more information.</p>
+<p><a id="ERR_MANIFEST_INVALID_SPECIFIER"></a></p>
+<h4><code>ERR_MANIFEST_INVALID_SPECIFIER</code><span><a class="mark" href="#errors_err_manifest_invalid_specifier" id="errors_err_manifest_invalid_specifier">#</a></span></h4>
+<p>A policy manifest resource had an invalid value for one of its dependency
+mappings. Update the manifest entry to match to resolve this error. See the
+documentation for <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MANIFEST_PARSE_POLICY"></a></p>
-<h3><code>ERR_MANIFEST_PARSE_POLICY</code><span><a class="mark" href="#errors_err_manifest_parse_policy" id="errors_err_manifest_parse_policy">#</a></span></h3>
+<h4><code>ERR_MANIFEST_PARSE_POLICY</code><span><a class="mark" href="#errors_err_manifest_parse_policy" id="errors_err_manifest_parse_policy">#</a></span></h4>
 <p>An attempt was made to load a policy manifest, but the manifest was unable to
 be parsed. See the documentation for <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MANIFEST_TDZ"></a></p>
-<h3><code>ERR_MANIFEST_TDZ</code><span><a class="mark" href="#errors_err_manifest_tdz" id="errors_err_manifest_tdz">#</a></span></h3>
+<h4><code>ERR_MANIFEST_TDZ</code><span><a class="mark" href="#errors_err_manifest_tdz" id="errors_err_manifest_tdz">#</a></span></h4>
 <p>An attempt was made to read from a policy manifest, but the manifest
 initialization has not yet taken place. This is likely a bug in Node.js.</p>
 <p><a id="ERR_MANIFEST_UNKNOWN_ONERROR"></a></p>
-<h3><code>ERR_MANIFEST_UNKNOWN_ONERROR</code><span><a class="mark" href="#errors_err_manifest_unknown_onerror" id="errors_err_manifest_unknown_onerror">#</a></span></h3>
+<h4><code>ERR_MANIFEST_UNKNOWN_ONERROR</code><span><a class="mark" href="#errors_err_manifest_unknown_onerror" id="errors_err_manifest_unknown_onerror">#</a></span></h4>
 <p>A policy manifest was loaded, but had an unknown value for its "onerror"
 behavior. See the documentation for <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MEMORY_ALLOCATION_FAILED"></a></p>
-<h3><code>ERR_MEMORY_ALLOCATION_FAILED</code><span><a class="mark" href="#errors_err_memory_allocation_failed" id="errors_err_memory_allocation_failed">#</a></span></h3>
+<h4><code>ERR_MEMORY_ALLOCATION_FAILED</code><span><a class="mark" href="#errors_err_memory_allocation_failed" id="errors_err_memory_allocation_failed">#</a></span></h4>
 <p>An attempt was made to allocate memory (usually in the C++ layer) but it
 failed.</p>
 <p><a id="ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE"></a></p>
-<h3><code>ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE</code><span><a class="mark" href="#errors_err_message_target_context_unavailable" id="errors_err_message_target_context_unavailable">#</a></span></h3>
+<h4><code>ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE</code><span><a class="mark" href="#errors_err_message_target_context_unavailable" id="errors_err_message_target_context_unavailable">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <p>A message posted to a <a href="#worker_threads_class_messageport"><code>MessagePort</code></a> could not be deserialized in the target
 <a href="vm.html">vm</a> <code>Context</code>. Not all Node.js objects can be successfully instantiated in
 any context at this time, and attempting to transfer them using <code>postMessage()</code>
 can fail on the receiving side in that case.</p>
 <p><a id="ERR_METHOD_NOT_IMPLEMENTED"></a></p>
-<h3><code>ERR_METHOD_NOT_IMPLEMENTED</code><span><a class="mark" href="#errors_err_method_not_implemented" id="errors_err_method_not_implemented">#</a></span></h3>
+<h4><code>ERR_METHOD_NOT_IMPLEMENTED</code><span><a class="mark" href="#errors_err_method_not_implemented" id="errors_err_method_not_implemented">#</a></span></h4>
 <p>A method is required but not implemented.</p>
 <p><a id="ERR_MISSING_ARGS"></a></p>
-<h3><code>ERR_MISSING_ARGS</code><span><a class="mark" href="#errors_err_missing_args" id="errors_err_missing_args">#</a></span></h3>
+<h4><code>ERR_MISSING_ARGS</code><span><a class="mark" href="#errors_err_missing_args" id="errors_err_missing_args">#</a></span></h4>
 <p>A required argument of a Node.js API was not passed. This is only used for
 strict compliance with the API specification (which in some cases may accept
 <code>func(undefined)</code> but not <code>func()</code>). In most native Node.js APIs,
 <code>func(undefined)</code> and <code>func()</code> are treated identically, and the
 <a href="#ERR_INVALID_ARG_TYPE"><code>ERR_INVALID_ARG_TYPE</code></a> error code may be used instead.</p>
-<p><a id="ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK"></a></p>
-<h3><code>ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK</code><span><a class="mark" href="#errors_err_missing_dynamic_instantiate_hook" id="errors_err_missing_dynamic_instantiate_hook">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p>An <a href="esm.html">ES Module</a> loader hook specified <code>format: 'dynamic'</code> but did not provide
-a <code>dynamicInstantiate</code> hook.</p>
+<p><a id="ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST"></a></p>
+<h4><code>ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST</code><span><a class="mark" href="#errors_err_missing_message_port_in_transfer_list" id="errors_err_missing_message_port_in_transfer_list">#</a></span></h4>
+<p>An object that needs to be explicitly listed in the <code>transferList</code> argument
+is in the object passed to a <code>postMessage()</code> call, but is not provided
+in the <code>transferList</code> for that call. Usually, this is a <code>MessagePort</code>.</p>
 <p><a id="ERR_MISSING_OPTION"></a></p>
-<h3><code>ERR_MISSING_OPTION</code><span><a class="mark" href="#errors_err_missing_option" id="errors_err_missing_option">#</a></span></h3>
+<h4><code>ERR_MISSING_OPTION</code><span><a class="mark" href="#errors_err_missing_option" id="errors_err_missing_option">#</a></span></h4>
 <p>For APIs that accept options objects, some options might be mandatory. This code
 is thrown if a required option is missing.</p>
-<p><a id="ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST"></a></p>
-<h3><code>ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST</code><span><a class="mark" href="#errors_err_missing_message_port_in_transfer_list" id="errors_err_missing_message_port_in_transfer_list">#</a></span></h3>
-<p>An object that needs to be explicitly listed in the <code>transferList</code> argument
-was found in the object passed to a <code>postMessage()</code> call, but not provided in
-the <code>transferList</code> for that call. Usually, this is a <code>MessagePort</code>.</p>
 <p><a id="ERR_MISSING_PASSPHRASE"></a></p>
-<h3><code>ERR_MISSING_PASSPHRASE</code><span><a class="mark" href="#errors_err_missing_passphrase" id="errors_err_missing_passphrase">#</a></span></h3>
+<h4><code>ERR_MISSING_PASSPHRASE</code><span><a class="mark" href="#errors_err_missing_passphrase" id="errors_err_missing_passphrase">#</a></span></h4>
 <p>An attempt was made to read an encrypted key without specifying a passphrase.</p>
 <p><a id="ERR_MISSING_PLATFORM_FOR_WORKER"></a></p>
-<h3><code>ERR_MISSING_PLATFORM_FOR_WORKER</code><span><a class="mark" href="#errors_err_missing_platform_for_worker" id="errors_err_missing_platform_for_worker">#</a></span></h3>
+<h4><code>ERR_MISSING_PLATFORM_FOR_WORKER</code><span><a class="mark" href="#errors_err_missing_platform_for_worker" id="errors_err_missing_platform_for_worker">#</a></span></h4>
 <p>The V8 platform used by this instance of Node.js does not support creating
 Workers. This is caused by lack of embedder support for Workers. In particular,
 this error will not occur with standard builds of Node.js.</p>
 <p><a id="ERR_MODULE_NOT_FOUND"></a></p>
-<h3><code>ERR_MODULE_NOT_FOUND</code><span><a class="mark" href="#errors_err_module_not_found" id="errors_err_module_not_found">#</a></span></h3>
+<h4><code>ERR_MODULE_NOT_FOUND</code><span><a class="mark" href="#errors_err_module_not_found" id="errors_err_module_not_found">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>An <a href="esm.html">ES Module</a> could not be resolved.</p>
 <p><a id="ERR_MULTIPLE_CALLBACK"></a></p>
-<h3><code>ERR_MULTIPLE_CALLBACK</code><span><a class="mark" href="#errors_err_multiple_callback" id="errors_err_multiple_callback">#</a></span></h3>
+<h4><code>ERR_MULTIPLE_CALLBACK</code><span><a class="mark" href="#errors_err_multiple_callback" id="errors_err_multiple_callback">#</a></span></h4>
 <p>A callback was called more than once.</p>
 <p>A callback is almost always meant to only be called once as the query
 can either be fulfilled or rejected but not both at the same time. The latter
 would be possible by calling a callback more than once.</p>
 <p><a id="ERR_NAPI_CONS_FUNCTION"></a></p>
-<h3><code>ERR_NAPI_CONS_FUNCTION</code><span><a class="mark" href="#errors_err_napi_cons_function" id="errors_err_napi_cons_function">#</a></span></h3>
-<p>While using <code>N-API</code>, a constructor passed was not a function.</p>
+<h4><code>ERR_NAPI_CONS_FUNCTION</code><span><a class="mark" href="#errors_err_napi_cons_function" id="errors_err_napi_cons_function">#</a></span></h4>
+<p>While using <code>Node-API</code>, a constructor passed was not a function.</p>
 <p><a id="ERR_NAPI_INVALID_DATAVIEW_ARGS"></a></p>
-<h3><code>ERR_NAPI_INVALID_DATAVIEW_ARGS</code><span><a class="mark" href="#errors_err_napi_invalid_dataview_args" id="errors_err_napi_invalid_dataview_args">#</a></span></h3>
+<h4><code>ERR_NAPI_INVALID_DATAVIEW_ARGS</code><span><a class="mark" href="#errors_err_napi_invalid_dataview_args" id="errors_err_napi_invalid_dataview_args">#</a></span></h4>
 <p>While calling <code>napi_create_dataview()</code>, a given <code>offset</code> was outside the bounds
 of the dataview or <code>offset + length</code> was larger than a length of given <code>buffer</code>.</p>
 <p><a id="ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT"></a></p>
-<h3><code>ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT</code><span><a class="mark" href="#errors_err_napi_invalid_typedarray_alignment" id="errors_err_napi_invalid_typedarray_alignment">#</a></span></h3>
+<h4><code>ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT</code><span><a class="mark" href="#errors_err_napi_invalid_typedarray_alignment" id="errors_err_napi_invalid_typedarray_alignment">#</a></span></h4>
 <p>While calling <code>napi_create_typedarray()</code>, the provided <code>offset</code> was not a
 multiple of the element size.</p>
 <p><a id="ERR_NAPI_INVALID_TYPEDARRAY_LENGTH"></a></p>
-<h3><code>ERR_NAPI_INVALID_TYPEDARRAY_LENGTH</code><span><a class="mark" href="#errors_err_napi_invalid_typedarray_length" id="errors_err_napi_invalid_typedarray_length">#</a></span></h3>
+<h4><code>ERR_NAPI_INVALID_TYPEDARRAY_LENGTH</code><span><a class="mark" href="#errors_err_napi_invalid_typedarray_length" id="errors_err_napi_invalid_typedarray_length">#</a></span></h4>
 <p>While calling <code>napi_create_typedarray()</code>, <code>(length * size_of_element) + byte_offset</code> was larger than the length of given <code>buffer</code>.</p>
 <p><a id="ERR_NAPI_TSFN_CALL_JS"></a></p>
-<h3><code>ERR_NAPI_TSFN_CALL_JS</code><span><a class="mark" href="#errors_err_napi_tsfn_call_js" id="errors_err_napi_tsfn_call_js">#</a></span></h3>
+<h4><code>ERR_NAPI_TSFN_CALL_JS</code><span><a class="mark" href="#errors_err_napi_tsfn_call_js" id="errors_err_napi_tsfn_call_js">#</a></span></h4>
 <p>An error occurred while invoking the JavaScript portion of the thread-safe
 function.</p>
 <p><a id="ERR_NAPI_TSFN_GET_UNDEFINED"></a></p>
-<h3><code>ERR_NAPI_TSFN_GET_UNDEFINED</code><span><a class="mark" href="#errors_err_napi_tsfn_get_undefined" id="errors_err_napi_tsfn_get_undefined">#</a></span></h3>
+<h4><code>ERR_NAPI_TSFN_GET_UNDEFINED</code><span><a class="mark" href="#errors_err_napi_tsfn_get_undefined" id="errors_err_napi_tsfn_get_undefined">#</a></span></h4>
 <p>An error occurred while attempting to retrieve the JavaScript <code>undefined</code>
 value.</p>
 <p><a id="ERR_NAPI_TSFN_START_IDLE_LOOP"></a></p>
-<h3><code>ERR_NAPI_TSFN_START_IDLE_LOOP</code><span><a class="mark" href="#errors_err_napi_tsfn_start_idle_loop" id="errors_err_napi_tsfn_start_idle_loop">#</a></span></h3>
+<h4><code>ERR_NAPI_TSFN_START_IDLE_LOOP</code><span><a class="mark" href="#errors_err_napi_tsfn_start_idle_loop" id="errors_err_napi_tsfn_start_idle_loop">#</a></span></h4>
 <p>On the main thread, values are removed from the queue associated with the
 thread-safe function in an idle loop. This error indicates that an error
 has occurred when attempting to start the loop.</p>
 <p><a id="ERR_NAPI_TSFN_STOP_IDLE_LOOP"></a></p>
-<h3><code>ERR_NAPI_TSFN_STOP_IDLE_LOOP</code><span><a class="mark" href="#errors_err_napi_tsfn_stop_idle_loop" id="errors_err_napi_tsfn_stop_idle_loop">#</a></span></h3>
+<h4><code>ERR_NAPI_TSFN_STOP_IDLE_LOOP</code><span><a class="mark" href="#errors_err_napi_tsfn_stop_idle_loop" id="errors_err_napi_tsfn_stop_idle_loop">#</a></span></h4>
 <p>Once no more items are left in the queue, the idle loop must be suspended. This
 error indicates that the idle loop has failed to stop.</p>
 <p><a id="ERR_NO_CRYPTO"></a></p>
-<h3><code>ERR_NO_CRYPTO</code><span><a class="mark" href="#errors_err_no_crypto" id="errors_err_no_crypto">#</a></span></h3>
+<h4><code>ERR_NO_CRYPTO</code><span><a class="mark" href="#errors_err_no_crypto" id="errors_err_no_crypto">#</a></span></h4>
 <p>An attempt was made to use crypto features while Node.js was not compiled with
 OpenSSL crypto support.</p>
 <p><a id="ERR_NO_ICU"></a></p>
-<h3><code>ERR_NO_ICU</code><span><a class="mark" href="#errors_err_no_icu" id="errors_err_no_icu">#</a></span></h3>
+<h4><code>ERR_NO_ICU</code><span><a class="mark" href="#errors_err_no_icu" id="errors_err_no_icu">#</a></span></h4>
 <p>An attempt was made to use features that require <a href="#intl_internationalization_support">ICU</a>, but Node.js was not
 compiled with ICU support.</p>
 <p><a id="ERR_NON_CONTEXT_AWARE_DISABLED"></a></p>
-<h3><code>ERR_NON_CONTEXT_AWARE_DISABLED</code><span><a class="mark" href="#errors_err_non_context_aware_disabled" id="errors_err_non_context_aware_disabled">#</a></span></h3>
+<h4><code>ERR_NON_CONTEXT_AWARE_DISABLED</code><span><a class="mark" href="#errors_err_non_context_aware_disabled" id="errors_err_non_context_aware_disabled">#</a></span></h4>
 <p>A non-context-aware native addon was loaded in a process that disallows them.</p>
+<p><a id="ERR_OPERATION_FAILED"></a></p>
+<h4><code>ERR_OPERATION_FAILED</code><span><a class="mark" href="#errors_err_operation_failed" id="errors_err_operation_failed">#</a></span></h4>
+<p>An operation failed. This is typically used to signal the general failure of an
+asynchronous operation.</p>
 <p><a id="ERR_OUT_OF_RANGE"></a></p>
-<h3><code>ERR_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_out_of_range" id="errors_err_out_of_range">#</a></span></h3>
+<h4><code>ERR_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_out_of_range" id="errors_err_out_of_range">#</a></span></h4>
 <p>A given value is out of the accepted range.</p>
 <p><a id="ERR_PACKAGE_IMPORT_NOT_DEFINED"></a></p>
-<h3><code>ERR_PACKAGE_IMPORT_NOT_DEFINED</code><span><a class="mark" href="#errors_err_package_import_not_defined" id="errors_err_package_import_not_defined">#</a></span></h3>
+<h4><code>ERR_PACKAGE_IMPORT_NOT_DEFINED</code><span><a class="mark" href="#errors_err_package_import_not_defined" id="errors_err_package_import_not_defined">#</a></span></h4>
 <p>The <code>package.json</code> <a href="#packages_imports"><code>"imports"</code></a> field does not define the given internal
 package specifier mapping.</p>
 <p><a id="ERR_PACKAGE_PATH_NOT_EXPORTED"></a></p>
-<h3><code>ERR_PACKAGE_PATH_NOT_EXPORTED</code><span><a class="mark" href="#errors_err_package_path_not_exported" id="errors_err_package_path_not_exported">#</a></span></h3>
+<h4><code>ERR_PACKAGE_PATH_NOT_EXPORTED</code><span><a class="mark" href="#errors_err_package_path_not_exported" id="errors_err_package_path_not_exported">#</a></span></h4>
 <p>The <code>package.json</code> <a href="#packages_exports"><code>"exports"</code></a> field does not export the requested subpath.
 Because exports are encapsulated, private internal modules that are not exported
 cannot be imported through the package resolution, unless using an absolute URL.</p>
 <p><a id="ERR_PROTO_ACCESS"></a></p>
-<h3><code>ERR_PROTO_ACCESS</code><span><a class="mark" href="#errors_err_proto_access" id="errors_err_proto_access">#</a></span></h3>
+<h4><code>ERR_PROTO_ACCESS</code><span><a class="mark" href="#errors_err_proto_access" id="errors_err_proto_access">#</a></span></h4>
 <p>Accessing <code>Object.prototype.__proto__</code> has been forbidden using
 <a href="#cli_disable_proto_mode"><code>--disable-proto=throw</code></a>. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf"><code>Object.getPrototypeOf</code></a> and
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf"><code>Object.setPrototypeOf</code></a> should be used to get and set the prototype of an
 object.</p>
 <p><a id="ERR_REQUIRE_ESM"></a></p>
-<h3><code>ERR_REQUIRE_ESM</code><span><a class="mark" href="#errors_err_require_esm" id="errors_err_require_esm">#</a></span></h3>
+<h4><code>ERR_REQUIRE_ESM</code><span><a class="mark" href="#errors_err_require_esm" id="errors_err_require_esm">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>An attempt was made to <code>require()</code> an <a href="esm.html">ES Module</a>.</p>
 <p><a id="ERR_SCRIPT_EXECUTION_INTERRUPTED"></a></p>
-<h3><code>ERR_SCRIPT_EXECUTION_INTERRUPTED</code><span><a class="mark" href="#errors_err_script_execution_interrupted" id="errors_err_script_execution_interrupted">#</a></span></h3>
+<h4><code>ERR_SCRIPT_EXECUTION_INTERRUPTED</code><span><a class="mark" href="#errors_err_script_execution_interrupted" id="errors_err_script_execution_interrupted">#</a></span></h4>
 <p>Script execution was interrupted by <code>SIGINT</code> (For example,
 <kbd>Ctrl</kbd>+<kbd>C</kbd> was pressed.)</p>
 <p><a id="ERR_SCRIPT_EXECUTION_TIMEOUT"></a></p>
-<h3><code>ERR_SCRIPT_EXECUTION_TIMEOUT</code><span><a class="mark" href="#errors_err_script_execution_timeout" id="errors_err_script_execution_timeout">#</a></span></h3>
+<h4><code>ERR_SCRIPT_EXECUTION_TIMEOUT</code><span><a class="mark" href="#errors_err_script_execution_timeout" id="errors_err_script_execution_timeout">#</a></span></h4>
 <p>Script execution timed out, possibly due to bugs in the script being executed.</p>
 <p><a id="ERR_SERVER_ALREADY_LISTEN"></a></p>
-<h3><code>ERR_SERVER_ALREADY_LISTEN</code><span><a class="mark" href="#errors_err_server_already_listen" id="errors_err_server_already_listen">#</a></span></h3>
+<h4><code>ERR_SERVER_ALREADY_LISTEN</code><span><a class="mark" href="#errors_err_server_already_listen" id="errors_err_server_already_listen">#</a></span></h4>
 <p>The <a href="#net_server_listen"><code>server.listen()</code></a> method was called while a <code>net.Server</code> was already
 listening. This applies to all instances of <code>net.Server</code>, including HTTP, HTTPS,
 and HTTP/2 <code>Server</code> instances.</p>
 <p><a id="ERR_SERVER_NOT_RUNNING"></a></p>
-<h3><code>ERR_SERVER_NOT_RUNNING</code><span><a class="mark" href="#errors_err_server_not_running" id="errors_err_server_not_running">#</a></span></h3>
+<h4><code>ERR_SERVER_NOT_RUNNING</code><span><a class="mark" href="#errors_err_server_not_running" id="errors_err_server_not_running">#</a></span></h4>
 <p>The <a href="#net_server_close_callback"><code>server.close()</code></a> method was called when a <code>net.Server</code> was not
 running. This applies to all instances of <code>net.Server</code>, including HTTP, HTTPS,
 and HTTP/2 <code>Server</code> instances.</p>
 <p><a id="ERR_SOCKET_ALREADY_BOUND"></a></p>
-<h3><code>ERR_SOCKET_ALREADY_BOUND</code><span><a class="mark" href="#errors_err_socket_already_bound" id="errors_err_socket_already_bound">#</a></span></h3>
+<h4><code>ERR_SOCKET_ALREADY_BOUND</code><span><a class="mark" href="#errors_err_socket_already_bound" id="errors_err_socket_already_bound">#</a></span></h4>
 <p>An attempt was made to bind a socket that has already been bound.</p>
 <p><a id="ERR_SOCKET_BAD_BUFFER_SIZE"></a></p>
-<h3><code>ERR_SOCKET_BAD_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_socket_bad_buffer_size" id="errors_err_socket_bad_buffer_size">#</a></span></h3>
+<h4><code>ERR_SOCKET_BAD_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_socket_bad_buffer_size" id="errors_err_socket_bad_buffer_size">#</a></span></h4>
 <p>An invalid (negative) size was passed for either the <code>recvBufferSize</code> or
 <code>sendBufferSize</code> options in <a href="#dgram_dgram_createsocket_options_callback"><code>dgram.createSocket()</code></a>.</p>
 <p><a id="ERR_SOCKET_BAD_PORT"></a></p>
-<h3><code>ERR_SOCKET_BAD_PORT</code><span><a class="mark" href="#errors_err_socket_bad_port" id="errors_err_socket_bad_port">#</a></span></h3>
+<h4><code>ERR_SOCKET_BAD_PORT</code><span><a class="mark" href="#errors_err_socket_bad_port" id="errors_err_socket_bad_port">#</a></span></h4>
 <p>An API function expecting a port >= 0 and &#x3C; 65536 received an invalid value.</p>
 <p><a id="ERR_SOCKET_BAD_TYPE"></a></p>
-<h3><code>ERR_SOCKET_BAD_TYPE</code><span><a class="mark" href="#errors_err_socket_bad_type" id="errors_err_socket_bad_type">#</a></span></h3>
+<h4><code>ERR_SOCKET_BAD_TYPE</code><span><a class="mark" href="#errors_err_socket_bad_type" id="errors_err_socket_bad_type">#</a></span></h4>
 <p>An API function expecting a socket type (<code>udp4</code> or <code>udp6</code>) received an invalid
 value.</p>
 <p><a id="ERR_SOCKET_BUFFER_SIZE"></a></p>
-<h3><code>ERR_SOCKET_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_socket_buffer_size" id="errors_err_socket_buffer_size">#</a></span></h3>
+<h4><code>ERR_SOCKET_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_socket_buffer_size" id="errors_err_socket_buffer_size">#</a></span></h4>
 <p>While using <a href="#dgram_dgram_createsocket_options_callback"><code>dgram.createSocket()</code></a>, the size of the receive or send <code>Buffer</code>
 could not be determined.</p>
-<p><a id="ERR_SOCKET_CANNOT_SEND"></a></p>
-<h3><code>ERR_SOCKET_CANNOT_SEND</code><span><a class="mark" href="#errors_err_socket_cannot_send" id="errors_err_socket_cannot_send">#</a></span></h3>
-<p>Data could be sent on a socket.</p>
 <p><a id="ERR_SOCKET_CLOSED"></a></p>
-<h3><code>ERR_SOCKET_CLOSED</code><span><a class="mark" href="#errors_err_socket_closed" id="errors_err_socket_closed">#</a></span></h3>
+<h4><code>ERR_SOCKET_CLOSED</code><span><a class="mark" href="#errors_err_socket_closed" id="errors_err_socket_closed">#</a></span></h4>
 <p>An attempt was made to operate on an already closed socket.</p>
 <p><a id="ERR_SOCKET_DGRAM_IS_CONNECTED"></a></p>
-<h3><code>ERR_SOCKET_DGRAM_IS_CONNECTED</code><span><a class="mark" href="#errors_err_socket_dgram_is_connected" id="errors_err_socket_dgram_is_connected">#</a></span></h3>
+<h4><code>ERR_SOCKET_DGRAM_IS_CONNECTED</code><span><a class="mark" href="#errors_err_socket_dgram_is_connected" id="errors_err_socket_dgram_is_connected">#</a></span></h4>
 <p>A <a href="#dgram_socket_connect_port_address_callback"><code>dgram.connect()</code></a> call was made on an already connected socket.</p>
 <p><a id="ERR_SOCKET_DGRAM_NOT_CONNECTED"></a></p>
-<h3><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code><span><a class="mark" href="#errors_err_socket_dgram_not_connected" id="errors_err_socket_dgram_not_connected">#</a></span></h3>
+<h4><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code><span><a class="mark" href="#errors_err_socket_dgram_not_connected" id="errors_err_socket_dgram_not_connected">#</a></span></h4>
 <p>A <a href="#dgram_socket_disconnect"><code>dgram.disconnect()</code></a> or <a href="#dgram_socket_remoteaddress"><code>dgram.remoteAddress()</code></a> call was made on a
 disconnected socket.</p>
 <p><a id="ERR_SOCKET_DGRAM_NOT_RUNNING"></a></p>
-<h3><code>ERR_SOCKET_DGRAM_NOT_RUNNING</code><span><a class="mark" href="#errors_err_socket_dgram_not_running" id="errors_err_socket_dgram_not_running">#</a></span></h3>
+<h4><code>ERR_SOCKET_DGRAM_NOT_RUNNING</code><span><a class="mark" href="#errors_err_socket_dgram_not_running" id="errors_err_socket_dgram_not_running">#</a></span></h4>
 <p>A call was made and the UDP subsystem was not running.</p>
 <p><a id="ERR_SRI_PARSE"></a></p>
-<h3><code>ERR_SRI_PARSE</code><span><a class="mark" href="#errors_err_sri_parse" id="errors_err_sri_parse">#</a></span></h3>
+<h4><code>ERR_SRI_PARSE</code><span><a class="mark" href="#errors_err_sri_parse" id="errors_err_sri_parse">#</a></span></h4>
 <p>A string was provided for a Subresource Integrity check, but was unable to be
 parsed. Check the format of integrity attributes by looking at the
 <a href="https://www.w3.org/TR/SRI/#the-integrity-attribute">Subresource Integrity specification</a>.</p>
+<p><a id="ERR_STREAM_ALREADY_FINISHED"></a></p>
+<h4><code>ERR_STREAM_ALREADY_FINISHED</code><span><a class="mark" href="#errors_err_stream_already_finished" id="errors_err_stream_already_finished">#</a></span></h4>
+<p>A stream method was called that cannot complete because the stream was
+finished.</p>
 <p><a id="ERR_STREAM_CANNOT_PIPE"></a></p>
-<h3><code>ERR_STREAM_CANNOT_PIPE</code><span><a class="mark" href="#errors_err_stream_cannot_pipe" id="errors_err_stream_cannot_pipe">#</a></span></h3>
+<h4><code>ERR_STREAM_CANNOT_PIPE</code><span><a class="mark" href="#errors_err_stream_cannot_pipe" id="errors_err_stream_cannot_pipe">#</a></span></h4>
 <p>An attempt was made to call <a href="#stream_readable_pipe_destination_options"><code>stream.pipe()</code></a> on a <a href="#stream_class_stream_writable"><code>Writable</code></a> stream.</p>
 <p><a id="ERR_STREAM_DESTROYED"></a></p>
-<h3><code>ERR_STREAM_DESTROYED</code><span><a class="mark" href="#errors_err_stream_destroyed" id="errors_err_stream_destroyed">#</a></span></h3>
+<h4><code>ERR_STREAM_DESTROYED</code><span><a class="mark" href="#errors_err_stream_destroyed" id="errors_err_stream_destroyed">#</a></span></h4>
 <p>A stream method was called that cannot complete because the stream was
 destroyed using <code>stream.destroy()</code>.</p>
 <p><a id="ERR_STREAM_NULL_VALUES"></a></p>
-<h3><code>ERR_STREAM_NULL_VALUES</code><span><a class="mark" href="#errors_err_stream_null_values" id="errors_err_stream_null_values">#</a></span></h3>
+<h4><code>ERR_STREAM_NULL_VALUES</code><span><a class="mark" href="#errors_err_stream_null_values" id="errors_err_stream_null_values">#</a></span></h4>
 <p>An attempt was made to call <a href="#stream_writable_write_chunk_encoding_callback"><code>stream.write()</code></a> with a <code>null</code> chunk.</p>
 <p><a id="ERR_STREAM_PREMATURE_CLOSE"></a></p>
-<h3><code>ERR_STREAM_PREMATURE_CLOSE</code><span><a class="mark" href="#errors_err_stream_premature_close" id="errors_err_stream_premature_close">#</a></span></h3>
+<h4><code>ERR_STREAM_PREMATURE_CLOSE</code><span><a class="mark" href="#errors_err_stream_premature_close" id="errors_err_stream_premature_close">#</a></span></h4>
 <p>An error returned by <code>stream.finished()</code> and <code>stream.pipeline()</code>, when a stream
 or a pipeline ends non gracefully with no explicit error.</p>
 <p><a id="ERR_STREAM_PUSH_AFTER_EOF"></a></p>
-<h3><code>ERR_STREAM_PUSH_AFTER_EOF</code><span><a class="mark" href="#errors_err_stream_push_after_eof" id="errors_err_stream_push_after_eof">#</a></span></h3>
+<h4><code>ERR_STREAM_PUSH_AFTER_EOF</code><span><a class="mark" href="#errors_err_stream_push_after_eof" id="errors_err_stream_push_after_eof">#</a></span></h4>
 <p>An attempt was made to call <a href="#stream_readable_push_chunk_encoding"><code>stream.push()</code></a> after a <code>null</code>(EOF) had been
 pushed to the stream.</p>
 <p><a id="ERR_STREAM_UNSHIFT_AFTER_END_EVENT"></a></p>
-<h3><code>ERR_STREAM_UNSHIFT_AFTER_END_EVENT</code><span><a class="mark" href="#errors_err_stream_unshift_after_end_event" id="errors_err_stream_unshift_after_end_event">#</a></span></h3>
+<h4><code>ERR_STREAM_UNSHIFT_AFTER_END_EVENT</code><span><a class="mark" href="#errors_err_stream_unshift_after_end_event" id="errors_err_stream_unshift_after_end_event">#</a></span></h4>
 <p>An attempt was made to call <a href="#stream_readable_unshift_chunk_encoding"><code>stream.unshift()</code></a> after the <code>'end'</code> event was
 emitted.</p>
 <p><a id="ERR_STREAM_WRAP"></a></p>
-<h3><code>ERR_STREAM_WRAP</code><span><a class="mark" href="#errors_err_stream_wrap" id="errors_err_stream_wrap">#</a></span></h3>
+<h4><code>ERR_STREAM_WRAP</code><span><a class="mark" href="#errors_err_stream_wrap" id="errors_err_stream_wrap">#</a></span></h4>
 <p>Prevents an abort if a string decoder was set on the Socket or if the decoder
 is in <code>objectMode</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> Socket = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).Socket;
-<span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">new</span> Socket();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">Socket</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-property">Socket</span>;
+<span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Socket</span>();
 
-instance.setEncoding(<span class="hljs-string">'utf8'</span>);</code></pre>
+instance.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);</code></pre>
 <p><a id="ERR_STREAM_WRITE_AFTER_END"></a></p>
-<h3><code>ERR_STREAM_WRITE_AFTER_END</code><span><a class="mark" href="#errors_err_stream_write_after_end" id="errors_err_stream_write_after_end">#</a></span></h3>
+<h4><code>ERR_STREAM_WRITE_AFTER_END</code><span><a class="mark" href="#errors_err_stream_write_after_end" id="errors_err_stream_write_after_end">#</a></span></h4>
 <p>An attempt was made to call <a href="#stream_writable_write_chunk_encoding_callback"><code>stream.write()</code></a> after <code>stream.end()</code> has been
 called.</p>
 <p><a id="ERR_STRING_TOO_LONG"></a></p>
-<h3><code>ERR_STRING_TOO_LONG</code><span><a class="mark" href="#errors_err_string_too_long" id="errors_err_string_too_long">#</a></span></h3>
+<h4><code>ERR_STRING_TOO_LONG</code><span><a class="mark" href="#errors_err_string_too_long" id="errors_err_string_too_long">#</a></span></h4>
 <p>An attempt has been made to create a string longer than the maximum allowed
 length.</p>
 <p><a id="ERR_SYNTHETIC"></a></p>
-<h3><code>ERR_SYNTHETIC</code><span><a class="mark" href="#errors_err_synthetic" id="errors_err_synthetic">#</a></span></h3>
+<h4><code>ERR_SYNTHETIC</code><span><a class="mark" href="#errors_err_synthetic" id="errors_err_synthetic">#</a></span></h4>
 <p>An artificial error object used to capture the call stack for diagnostic
 reports.</p>
 <p><a id="ERR_SYSTEM_ERROR"></a></p>
-<h3><code>ERR_SYSTEM_ERROR</code><span><a class="mark" href="#errors_err_system_error" id="errors_err_system_error">#</a></span></h3>
+<h4><code>ERR_SYSTEM_ERROR</code><span><a class="mark" href="#errors_err_system_error" id="errors_err_system_error">#</a></span></h4>
 <p>An unspecified or non-specific system error has occurred within the Node.js
 process. The error object will have an <code>err.info</code> object property with
 additional details.</p>
+<p><a id="ERR_TLS_CERT_ALTNAME_FORMAT"></a></p>
+<h4><code>ERR_TLS_CERT_ALTNAME_FORMAT</code><span><a class="mark" href="#errors_err_tls_cert_altname_format" id="errors_err_tls_cert_altname_format">#</a></span></h4>
+<p>This error is thrown by <code>checkServerIdentity</code> if a user-supplied
+<code>subjectaltname</code> property violates encoding rules. Certificate objects produced
+by Node.js itself always comply with encoding rules and will never cause
+this error.</p>
 <p><a id="ERR_TLS_CERT_ALTNAME_INVALID"></a></p>
-<h3><code>ERR_TLS_CERT_ALTNAME_INVALID</code><span><a class="mark" href="#errors_err_tls_cert_altname_invalid" id="errors_err_tls_cert_altname_invalid">#</a></span></h3>
+<h4><code>ERR_TLS_CERT_ALTNAME_INVALID</code><span><a class="mark" href="#errors_err_tls_cert_altname_invalid" id="errors_err_tls_cert_altname_invalid">#</a></span></h4>
 <p>While using TLS, the host name/IP of the peer did not match any of the
 <code>subjectAltNames</code> in its certificate.</p>
 <p><a id="ERR_TLS_DH_PARAM_SIZE"></a></p>
-<h3><code>ERR_TLS_DH_PARAM_SIZE</code><span><a class="mark" href="#errors_err_tls_dh_param_size" id="errors_err_tls_dh_param_size">#</a></span></h3>
+<h4><code>ERR_TLS_DH_PARAM_SIZE</code><span><a class="mark" href="#errors_err_tls_dh_param_size" id="errors_err_tls_dh_param_size">#</a></span></h4>
 <p>While using TLS, the parameter offered for the Diffie-Hellman (<code>DH</code>)
 key-agreement protocol is too small. By default, the key length must be greater
 than or equal to 1024 bits to avoid vulnerabilities, even though it is strongly
 recommended to use 2048 bits or larger for stronger security.</p>
 <p><a id="ERR_TLS_HANDSHAKE_TIMEOUT"></a></p>
-<h3><code>ERR_TLS_HANDSHAKE_TIMEOUT</code><span><a class="mark" href="#errors_err_tls_handshake_timeout" id="errors_err_tls_handshake_timeout">#</a></span></h3>
+<h4><code>ERR_TLS_HANDSHAKE_TIMEOUT</code><span><a class="mark" href="#errors_err_tls_handshake_timeout" id="errors_err_tls_handshake_timeout">#</a></span></h4>
 <p>A TLS/SSL handshake timed out. In this case, the server must also abort the
 connection.</p>
 <p><a id="ERR_TLS_INVALID_CONTEXT"></a></p>
-<h3><code>ERR_TLS_INVALID_CONTEXT</code><span><a class="mark" href="#errors_err_tls_invalid_context" id="errors_err_tls_invalid_context">#</a></span></h3>
+<h4><code>ERR_TLS_INVALID_CONTEXT</code><span><a class="mark" href="#errors_err_tls_invalid_context" id="errors_err_tls_invalid_context">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0</span>
 </div>
 <p>The context must be a <code>SecureContext</code>.</p>
-<p><a id="ERR_TLS_INVALID_STATE"></a></p>
-<h3><code>ERR_TLS_INVALID_STATE</code><span><a class="mark" href="#errors_err_tls_invalid_state" id="errors_err_tls_invalid_state">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.17.0</span>
-</div>
-<p>The TLS socket must be connected and securily established. Ensure the 'secure'
-event is emitted before continuing.</p>
 <p><a id="ERR_TLS_INVALID_PROTOCOL_METHOD"></a></p>
-<h3><code>ERR_TLS_INVALID_PROTOCOL_METHOD</code><span><a class="mark" href="#errors_err_tls_invalid_protocol_method" id="errors_err_tls_invalid_protocol_method">#</a></span></h3>
+<h4><code>ERR_TLS_INVALID_PROTOCOL_METHOD</code><span><a class="mark" href="#errors_err_tls_invalid_protocol_method" id="errors_err_tls_invalid_protocol_method">#</a></span></h4>
 <p>The specified  <code>secureProtocol</code> method is invalid. It is  either unknown, or
 disabled because it is insecure.</p>
 <p><a id="ERR_TLS_INVALID_PROTOCOL_VERSION"></a></p>
-<h3><code>ERR_TLS_INVALID_PROTOCOL_VERSION</code><span><a class="mark" href="#errors_err_tls_invalid_protocol_version" id="errors_err_tls_invalid_protocol_version">#</a></span></h3>
+<h4><code>ERR_TLS_INVALID_PROTOCOL_VERSION</code><span><a class="mark" href="#errors_err_tls_invalid_protocol_version" id="errors_err_tls_invalid_protocol_version">#</a></span></h4>
 <p>Valid TLS protocol versions are <code>'TLSv1'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1.2'</code>.</p>
+<p><a id="ERR_TLS_INVALID_STATE"></a></p>
+<h4><code>ERR_TLS_INVALID_STATE</code><span><a class="mark" href="#errors_err_tls_invalid_state" id="errors_err_tls_invalid_state">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.10.0, v12.17.0</span>
+</div>
+<p>The TLS socket must be connected and securily established. Ensure the 'secure'
+event is emitted before continuing.</p>
 <p><a id="ERR_TLS_PROTOCOL_VERSION_CONFLICT"></a></p>
-<h3><code>ERR_TLS_PROTOCOL_VERSION_CONFLICT</code><span><a class="mark" href="#errors_err_tls_protocol_version_conflict" id="errors_err_tls_protocol_version_conflict">#</a></span></h3>
+<h4><code>ERR_TLS_PROTOCOL_VERSION_CONFLICT</code><span><a class="mark" href="#errors_err_tls_protocol_version_conflict" id="errors_err_tls_protocol_version_conflict">#</a></span></h4>
 <p>Attempting to set a TLS protocol <code>minVersion</code> or <code>maxVersion</code> conflicts with an
 attempt to set the <code>secureProtocol</code> explicitly. Use one mechanism or the other.</p>
+<p><a id="ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED"></a></p>
+<h4><code>ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED</code><span><a class="mark" href="#errors_err_tls_psk_set_identiy_hint_failed" id="errors_err_tls_psk_set_identiy_hint_failed">#</a></span></h4>
+<p>Failed to set PSK identity hint. Hint may be too long.</p>
 <p><a id="ERR_TLS_RENEGOTIATION_DISABLED"></a></p>
-<h3><code>ERR_TLS_RENEGOTIATION_DISABLED</code><span><a class="mark" href="#errors_err_tls_renegotiation_disabled" id="errors_err_tls_renegotiation_disabled">#</a></span></h3>
+<h4><code>ERR_TLS_RENEGOTIATION_DISABLED</code><span><a class="mark" href="#errors_err_tls_renegotiation_disabled" id="errors_err_tls_renegotiation_disabled">#</a></span></h4>
 <p>An attempt was made to renegotiate TLS on a socket instance with TLS disabled.</p>
 <p><a id="ERR_TLS_REQUIRED_SERVER_NAME"></a></p>
-<h3><code>ERR_TLS_REQUIRED_SERVER_NAME</code><span><a class="mark" href="#errors_err_tls_required_server_name" id="errors_err_tls_required_server_name">#</a></span></h3>
+<h4><code>ERR_TLS_REQUIRED_SERVER_NAME</code><span><a class="mark" href="#errors_err_tls_required_server_name" id="errors_err_tls_required_server_name">#</a></span></h4>
 <p>While using TLS, the <code>server.addContext()</code> method was called without providing
 a host name in the first parameter.</p>
 <p><a id="ERR_TLS_SESSION_ATTACK"></a></p>
-<h3><code>ERR_TLS_SESSION_ATTACK</code><span><a class="mark" href="#errors_err_tls_session_attack" id="errors_err_tls_session_attack">#</a></span></h3>
+<h4><code>ERR_TLS_SESSION_ATTACK</code><span><a class="mark" href="#errors_err_tls_session_attack" id="errors_err_tls_session_attack">#</a></span></h4>
 <p>An excessive amount of TLS renegotiations is detected, which is a potential
 vector for denial-of-service attacks.</p>
 <p><a id="ERR_TLS_SNI_FROM_SERVER"></a></p>
-<h3><code>ERR_TLS_SNI_FROM_SERVER</code><span><a class="mark" href="#errors_err_tls_sni_from_server" id="errors_err_tls_sni_from_server">#</a></span></h3>
+<h4><code>ERR_TLS_SNI_FROM_SERVER</code><span><a class="mark" href="#errors_err_tls_sni_from_server" id="errors_err_tls_sni_from_server">#</a></span></h4>
 <p>An attempt was made to issue Server Name Indication from a TLS server-side
 socket, which is only valid from a client.</p>
-<p><a id="ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED"></a></p>
-<h3><code>ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED</code><span><a class="mark" href="#errors_err_tls_psk_set_identiy_hint_failed" id="errors_err_tls_psk_set_identiy_hint_failed">#</a></span></h3>
-<p>Failed to set PSK identity hint. Hint may be too long.</p>
 <p><a id="ERR_TRACE_EVENTS_CATEGORY_REQUIRED"></a></p>
-<h3><code>ERR_TRACE_EVENTS_CATEGORY_REQUIRED</code><span><a class="mark" href="#errors_err_trace_events_category_required" id="errors_err_trace_events_category_required">#</a></span></h3>
+<h4><code>ERR_TRACE_EVENTS_CATEGORY_REQUIRED</code><span><a class="mark" href="#errors_err_trace_events_category_required" id="errors_err_trace_events_category_required">#</a></span></h4>
 <p>The <code>trace_events.createTracing()</code> method requires at least one trace event
 category.</p>
 <p><a id="ERR_TRACE_EVENTS_UNAVAILABLE"></a></p>
-<h3><code>ERR_TRACE_EVENTS_UNAVAILABLE</code><span><a class="mark" href="#errors_err_trace_events_unavailable" id="errors_err_trace_events_unavailable">#</a></span></h3>
+<h4><code>ERR_TRACE_EVENTS_UNAVAILABLE</code><span><a class="mark" href="#errors_err_trace_events_unavailable" id="errors_err_trace_events_unavailable">#</a></span></h4>
 <p>The <code>trace_events</code> module could not be loaded because Node.js was compiled with
 the <code>--without-v8-platform</code> flag.</p>
-<p><a id="ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER"></a></p>
-<h3><code>ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER</code><span><a class="mark" href="#errors_err_transferring_externalized_sharedarraybuffer" id="errors_err_transferring_externalized_sharedarraybuffer">#</a></span></h3>
-<p>A <code>SharedArrayBuffer</code> whose memory is not managed by the JavaScript engine
-or by Node.js was encountered during serialization. Such a <code>SharedArrayBuffer</code>
-cannot be serialized.</p>
-<p>This can only happen when native addons create <code>SharedArrayBuffer</code>s in
-"externalized" mode, or put existing <code>SharedArrayBuffer</code> into externalized mode.</p>
 <p><a id="ERR_TRANSFORM_ALREADY_TRANSFORMING"></a></p>
-<h3><code>ERR_TRANSFORM_ALREADY_TRANSFORMING</code><span><a class="mark" href="#errors_err_transform_already_transforming" id="errors_err_transform_already_transforming">#</a></span></h3>
+<h4><code>ERR_TRANSFORM_ALREADY_TRANSFORMING</code><span><a class="mark" href="#errors_err_transform_already_transforming" id="errors_err_transform_already_transforming">#</a></span></h4>
 <p>A <code>Transform</code> stream finished while it was still transforming.</p>
 <p><a id="ERR_TRANSFORM_WITH_LENGTH_0"></a></p>
-<h3><code>ERR_TRANSFORM_WITH_LENGTH_0</code><span><a class="mark" href="#errors_err_transform_with_length_0" id="errors_err_transform_with_length_0">#</a></span></h3>
+<h4><code>ERR_TRANSFORM_WITH_LENGTH_0</code><span><a class="mark" href="#errors_err_transform_with_length_0" id="errors_err_transform_with_length_0">#</a></span></h4>
 <p>A <code>Transform</code> stream finished with data still in the write buffer.</p>
 <p><a id="ERR_TTY_INIT_FAILED"></a></p>
-<h3><code>ERR_TTY_INIT_FAILED</code><span><a class="mark" href="#errors_err_tty_init_failed" id="errors_err_tty_init_failed">#</a></span></h3>
+<h4><code>ERR_TTY_INIT_FAILED</code><span><a class="mark" href="#errors_err_tty_init_failed" id="errors_err_tty_init_failed">#</a></span></h4>
 <p>The initialization of a TTY failed due to a system error.</p>
 <p><a id="ERR_UNAVAILABLE_DURING_EXIT"></a></p>
-<h3><code>ERR_UNAVAILABLE_DURING_EXIT</code><span><a class="mark" href="#errors_err_unavailable_during_exit" id="errors_err_unavailable_during_exit">#</a></span></h3>
-<p>Function was called within a <a href="#Event:-%60&#x27;exit&#x27;%60"><code>process.on('exit')</code></a> handler that shouldn't be
-called within <a href="#Event:-%60&#x27;exit&#x27;%60"><code>process.on('exit')</code></a> handler.</p>
+<h4><code>ERR_UNAVAILABLE_DURING_EXIT</code><span><a class="mark" href="#errors_err_unavailable_during_exit" id="errors_err_unavailable_during_exit">#</a></span></h4>
+<p>Function was called within a <a href="#process_event_exit"><code>process.on('exit')</code></a> handler that shouldn't be
+called within <a href="#process_event_exit"><code>process.on('exit')</code></a> handler.</p>
 <p><a id="ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET"></a></p>
-<h3><code>ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET</code><span><a class="mark" href="#errors_err_uncaught_exception_capture_already_set" id="errors_err_uncaught_exception_capture_already_set">#</a></span></h3>
+<h4><code>ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET</code><span><a class="mark" href="#errors_err_uncaught_exception_capture_already_set" id="errors_err_uncaught_exception_capture_already_set">#</a></span></h4>
 <p><a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> was called twice,
 without first resetting the callback to <code>null</code>.</p>
 <p>This error is designed to prevent accidentally overwriting a callback registered
 from another module.</p>
 <p><a id="ERR_UNESCAPED_CHARACTERS"></a></p>
-<h3><code>ERR_UNESCAPED_CHARACTERS</code><span><a class="mark" href="#errors_err_unescaped_characters" id="errors_err_unescaped_characters">#</a></span></h3>
+<h4><code>ERR_UNESCAPED_CHARACTERS</code><span><a class="mark" href="#errors_err_unescaped_characters" id="errors_err_unescaped_characters">#</a></span></h4>
 <p>A string that contained unescaped characters was received.</p>
 <p><a id="ERR_UNHANDLED_ERROR"></a></p>
-<h3><code>ERR_UNHANDLED_ERROR</code><span><a class="mark" href="#errors_err_unhandled_error" id="errors_err_unhandled_error">#</a></span></h3>
+<h4><code>ERR_UNHANDLED_ERROR</code><span><a class="mark" href="#errors_err_unhandled_error" id="errors_err_unhandled_error">#</a></span></h4>
 <p>An unhandled error occurred (for instance, when an <code>'error'</code> event is emitted
 by an <a href="#events_class_eventemitter"><code>EventEmitter</code></a> but an <code>'error'</code> handler is not registered).</p>
 <p><a id="ERR_UNKNOWN_BUILTIN_MODULE"></a></p>
-<h3><code>ERR_UNKNOWN_BUILTIN_MODULE</code><span><a class="mark" href="#errors_err_unknown_builtin_module" id="errors_err_unknown_builtin_module">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_BUILTIN_MODULE</code><span><a class="mark" href="#errors_err_unknown_builtin_module" id="errors_err_unknown_builtin_module">#</a></span></h4>
 <p>Used to identify a specific kind of internal Node.js error that should not
 typically be triggered by user code. Instances of this error point to an
 internal bug within the Node.js binary itself.</p>
 <p><a id="ERR_UNKNOWN_CREDENTIAL"></a></p>
-<h3><code>ERR_UNKNOWN_CREDENTIAL</code><span><a class="mark" href="#errors_err_unknown_credential" id="errors_err_unknown_credential">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_CREDENTIAL</code><span><a class="mark" href="#errors_err_unknown_credential" id="errors_err_unknown_credential">#</a></span></h4>
 <p>A Unix group or user identifier that does not exist was passed.</p>
 <p><a id="ERR_UNKNOWN_ENCODING"></a></p>
-<h3><code>ERR_UNKNOWN_ENCODING</code><span><a class="mark" href="#errors_err_unknown_encoding" id="errors_err_unknown_encoding">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_ENCODING</code><span><a class="mark" href="#errors_err_unknown_encoding" id="errors_err_unknown_encoding">#</a></span></h4>
 <p>An invalid or unknown encoding option was passed to an API.</p>
 <p><a id="ERR_UNKNOWN_FILE_EXTENSION"></a></p>
-<h3><code>ERR_UNKNOWN_FILE_EXTENSION</code><span><a class="mark" href="#errors_err_unknown_file_extension" id="errors_err_unknown_file_extension">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_FILE_EXTENSION</code><span><a class="mark" href="#errors_err_unknown_file_extension" id="errors_err_unknown_file_extension">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>An attempt was made to load a module with an unknown or unsupported file
 extension.</p>
 <p><a id="ERR_UNKNOWN_MODULE_FORMAT"></a></p>
-<h3><code>ERR_UNKNOWN_MODULE_FORMAT</code><span><a class="mark" href="#errors_err_unknown_module_format" id="errors_err_unknown_module_format">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_MODULE_FORMAT</code><span><a class="mark" href="#errors_err_unknown_module_format" id="errors_err_unknown_module_format">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>An attempt was made to load a module with an unknown or unsupported format.</p>
 <p><a id="ERR_UNKNOWN_SIGNAL"></a></p>
-<h3><code>ERR_UNKNOWN_SIGNAL</code><span><a class="mark" href="#errors_err_unknown_signal" id="errors_err_unknown_signal">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_SIGNAL</code><span><a class="mark" href="#errors_err_unknown_signal" id="errors_err_unknown_signal">#</a></span></h4>
 <p>An invalid or unknown process signal was passed to an API expecting a valid
 signal (such as <a href="#child_process_subprocess_kill_signal"><code>subprocess.kill()</code></a>).</p>
 <p><a id="ERR_UNSUPPORTED_DIR_IMPORT"></a></p>
-<h3><code>ERR_UNSUPPORTED_DIR_IMPORT</code><span><a class="mark" href="#errors_err_unsupported_dir_import" id="errors_err_unsupported_dir_import">#</a></span></h3>
+<h4><code>ERR_UNSUPPORTED_DIR_IMPORT</code><span><a class="mark" href="#errors_err_unsupported_dir_import" id="errors_err_unsupported_dir_import">#</a></span></h4>
 <p><code>import</code> a directory URL is unsupported. Instead,
 <a href="#packages_self_referencing_a_package_using_its_name">self-reference a package using its name</a> and <a href="#packages_subpath_exports">define a custom subpath</a> in
 the <a href="#packages_exports"><code>"exports"</code></a> field of the <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file.</p>
@@ -28096,17 +29488,17 @@ the <a href="#packages_exports"><code>"exports"</code></a> field of the <a href=
 <span class="hljs-keyword">import</span> <span class="hljs-string">'./index.js'</span>; <span class="hljs-comment">// supported</span>
 <span class="hljs-keyword">import</span> <span class="hljs-string">'package-name'</span>; <span class="hljs-comment">// supported</span></code></pre>
 <p><a id="ERR_UNSUPPORTED_ESM_URL_SCHEME"></a></p>
-<h3><code>ERR_UNSUPPORTED_ESM_URL_SCHEME</code><span><a class="mark" href="#errors_err_unsupported_esm_url_scheme" id="errors_err_unsupported_esm_url_scheme">#</a></span></h3>
+<h4><code>ERR_UNSUPPORTED_ESM_URL_SCHEME</code><span><a class="mark" href="#errors_err_unsupported_esm_url_scheme" id="errors_err_unsupported_esm_url_scheme">#</a></span></h4>
 <p><code>import</code> with URL schemes other than <code>file</code> and <code>data</code> is unsupported.</p>
 <p><a id="ERR_VALID_PERFORMANCE_ENTRY_TYPE"></a></p>
-<h3><code>ERR_VALID_PERFORMANCE_ENTRY_TYPE</code><span><a class="mark" href="#errors_err_valid_performance_entry_type" id="errors_err_valid_performance_entry_type">#</a></span></h3>
+<h4><code>ERR_VALID_PERFORMANCE_ENTRY_TYPE</code><span><a class="mark" href="#errors_err_valid_performance_entry_type" id="errors_err_valid_performance_entry_type">#</a></span></h4>
 <p>While using the Performance Timing API (<code>perf_hooks</code>), no valid performance
-entry types were found.</p>
+entry types are found.</p>
 <p><a id="ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"></a></p>
-<h3><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code><span><a class="mark" href="#errors_err_vm_dynamic_import_callback_missing" id="errors_err_vm_dynamic_import_callback_missing">#</a></span></h3>
+<h4><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code><span><a class="mark" href="#errors_err_vm_dynamic_import_callback_missing" id="errors_err_vm_dynamic_import_callback_missing">#</a></span></h4>
 <p>A dynamic import callback was not specified.</p>
 <p><a id="ERR_VM_MODULE_ALREADY_LINKED"></a></p>
-<h3><code>ERR_VM_MODULE_ALREADY_LINKED</code><span><a class="mark" href="#errors_err_vm_module_already_linked" id="errors_err_vm_module_already_linked">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_ALREADY_LINKED</code><span><a class="mark" href="#errors_err_vm_module_already_linked" id="errors_err_vm_module_already_linked">#</a></span></h4>
 <p>The module attempted to be linked is not eligible for linking, because of one of
 the following reasons:</p>
 <ul>
@@ -28115,68 +29507,71 @@ the following reasons:</p>
 <li>Linking has failed for this module (<code>linkingStatus</code> is <code>'errored'</code>)</li>
 </ul>
 <p><a id="ERR_VM_MODULE_CACHED_DATA_REJECTED"></a></p>
-<h3><code>ERR_VM_MODULE_CACHED_DATA_REJECTED</code><span><a class="mark" href="#errors_err_vm_module_cached_data_rejected" id="errors_err_vm_module_cached_data_rejected">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_CACHED_DATA_REJECTED</code><span><a class="mark" href="#errors_err_vm_module_cached_data_rejected" id="errors_err_vm_module_cached_data_rejected">#</a></span></h4>
 <p>The <code>cachedData</code> option passed to a module constructor is invalid.</p>
 <p><a id="ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA"></a></p>
-<h3><code>ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA</code><span><a class="mark" href="#errors_err_vm_module_cannot_create_cached_data" id="errors_err_vm_module_cannot_create_cached_data">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA</code><span><a class="mark" href="#errors_err_vm_module_cannot_create_cached_data" id="errors_err_vm_module_cannot_create_cached_data">#</a></span></h4>
 <p>Cached data cannot be created for modules which have already been evaluated.</p>
 <p><a id="ERR_VM_MODULE_DIFFERENT_CONTEXT"></a></p>
-<h3><code>ERR_VM_MODULE_DIFFERENT_CONTEXT</code><span><a class="mark" href="#errors_err_vm_module_different_context" id="errors_err_vm_module_different_context">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_DIFFERENT_CONTEXT</code><span><a class="mark" href="#errors_err_vm_module_different_context" id="errors_err_vm_module_different_context">#</a></span></h4>
 <p>The module being returned from the linker function is from a different context
 than the parent module. Linked modules must share the same context.</p>
 <p><a id="ERR_VM_MODULE_LINKING_ERRORED"></a></p>
-<h3><code>ERR_VM_MODULE_LINKING_ERRORED</code><span><a class="mark" href="#errors_err_vm_module_linking_errored" id="errors_err_vm_module_linking_errored">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_LINKING_ERRORED</code><span><a class="mark" href="#errors_err_vm_module_linking_errored" id="errors_err_vm_module_linking_errored">#</a></span></h4>
 <p>The linker function returned a module for which linking has failed.</p>
+<p><a id="ERR_VM_MODULE_LINK_FAILURE"></a></p>
+<h4><code>ERR_VM_MODULE_LINK_FAILURE</code><span><a class="mark" href="#errors_err_vm_module_link_failure" id="errors_err_vm_module_link_failure">#</a></span></h4>
+<p>The module was unable to be linked due to a failure.</p>
 <p><a id="ERR_VM_MODULE_NOT_MODULE"></a></p>
-<h3><code>ERR_VM_MODULE_NOT_MODULE</code><span><a class="mark" href="#errors_err_vm_module_not_module" id="errors_err_vm_module_not_module">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_NOT_MODULE</code><span><a class="mark" href="#errors_err_vm_module_not_module" id="errors_err_vm_module_not_module">#</a></span></h4>
 <p>The fulfilled value of a linking promise is not a <code>vm.Module</code> object.</p>
 <p><a id="ERR_VM_MODULE_STATUS"></a></p>
-<h3><code>ERR_VM_MODULE_STATUS</code><span><a class="mark" href="#errors_err_vm_module_status" id="errors_err_vm_module_status">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_STATUS</code><span><a class="mark" href="#errors_err_vm_module_status" id="errors_err_vm_module_status">#</a></span></h4>
 <p>The current module's status does not allow for this operation. The specific
 meaning of the error depends on the specific function.</p>
 <p><a id="ERR_WASI_ALREADY_STARTED"></a></p>
-<h3><code>ERR_WASI_ALREADY_STARTED</code><span><a class="mark" href="#errors_err_wasi_already_started" id="errors_err_wasi_already_started">#</a></span></h3>
+<h4><code>ERR_WASI_ALREADY_STARTED</code><span><a class="mark" href="#errors_err_wasi_already_started" id="errors_err_wasi_already_started">#</a></span></h4>
 <p>The WASI instance has already started.</p>
 <p><a id="ERR_WASI_NOT_STARTED"></a></p>
-<h3><code>ERR_WASI_NOT_STARTED</code><span><a class="mark" href="#errors_err_wasi_not_started" id="errors_err_wasi_not_started">#</a></span></h3>
+<h4><code>ERR_WASI_NOT_STARTED</code><span><a class="mark" href="#errors_err_wasi_not_started" id="errors_err_wasi_not_started">#</a></span></h4>
 <p>The WASI instance has not been started.</p>
 <p><a id="ERR_WORKER_INIT_FAILED"></a></p>
-<h3><code>ERR_WORKER_INIT_FAILED</code><span><a class="mark" href="#errors_err_worker_init_failed" id="errors_err_worker_init_failed">#</a></span></h3>
+<h4><code>ERR_WORKER_INIT_FAILED</code><span><a class="mark" href="#errors_err_worker_init_failed" id="errors_err_worker_init_failed">#</a></span></h4>
 <p>The <code>Worker</code> initialization failed.</p>
 <p><a id="ERR_WORKER_INVALID_EXEC_ARGV"></a></p>
-<h3><code>ERR_WORKER_INVALID_EXEC_ARGV</code><span><a class="mark" href="#errors_err_worker_invalid_exec_argv" id="errors_err_worker_invalid_exec_argv">#</a></span></h3>
+<h4><code>ERR_WORKER_INVALID_EXEC_ARGV</code><span><a class="mark" href="#errors_err_worker_invalid_exec_argv" id="errors_err_worker_invalid_exec_argv">#</a></span></h4>
 <p>The <code>execArgv</code> option passed to the <code>Worker</code> constructor contains
 invalid flags.</p>
 <p><a id="ERR_WORKER_NOT_RUNNING"></a></p>
-<h3><code>ERR_WORKER_NOT_RUNNING</code><span><a class="mark" href="#errors_err_worker_not_running" id="errors_err_worker_not_running">#</a></span></h3>
+<h4><code>ERR_WORKER_NOT_RUNNING</code><span><a class="mark" href="#errors_err_worker_not_running" id="errors_err_worker_not_running">#</a></span></h4>
 <p>An operation failed because the <code>Worker</code> instance is not currently running.</p>
 <p><a id="ERR_WORKER_OUT_OF_MEMORY"></a></p>
-<h3><code>ERR_WORKER_OUT_OF_MEMORY</code><span><a class="mark" href="#errors_err_worker_out_of_memory" id="errors_err_worker_out_of_memory">#</a></span></h3>
+<h4><code>ERR_WORKER_OUT_OF_MEMORY</code><span><a class="mark" href="#errors_err_worker_out_of_memory" id="errors_err_worker_out_of_memory">#</a></span></h4>
 <p>The <code>Worker</code> instance terminated because it reached its memory limit.</p>
 <p><a id="ERR_WORKER_PATH"></a></p>
-<h3><code>ERR_WORKER_PATH</code><span><a class="mark" href="#errors_err_worker_path" id="errors_err_worker_path">#</a></span></h3>
+<h4><code>ERR_WORKER_PATH</code><span><a class="mark" href="#errors_err_worker_path" id="errors_err_worker_path">#</a></span></h4>
 <p>The path for the main script of a worker is neither an absolute path
 nor a relative path starting with <code>./</code> or <code>../</code>.</p>
 <p><a id="ERR_WORKER_UNSERIALIZABLE_ERROR"></a></p>
-<h3><code>ERR_WORKER_UNSERIALIZABLE_ERROR</code><span><a class="mark" href="#errors_err_worker_unserializable_error" id="errors_err_worker_unserializable_error">#</a></span></h3>
+<h4><code>ERR_WORKER_UNSERIALIZABLE_ERROR</code><span><a class="mark" href="#errors_err_worker_unserializable_error" id="errors_err_worker_unserializable_error">#</a></span></h4>
 <p>All attempts at serializing an uncaught exception from a worker thread failed.</p>
 <p><a id="ERR_WORKER_UNSUPPORTED_EXTENSION"></a></p>
-<h3><code>ERR_WORKER_UNSUPPORTED_EXTENSION</code><span><a class="mark" href="#errors_err_worker_unsupported_extension" id="errors_err_worker_unsupported_extension">#</a></span></h3>
+<h4><code>ERR_WORKER_UNSUPPORTED_EXTENSION</code><span><a class="mark" href="#errors_err_worker_unsupported_extension" id="errors_err_worker_unsupported_extension">#</a></span></h4>
 <p>The pathname used for the main script of a worker has an
 unknown file extension.</p>
 <p><a id="ERR_WORKER_UNSUPPORTED_OPERATION"></a></p>
-<h3><code>ERR_WORKER_UNSUPPORTED_OPERATION</code><span><a class="mark" href="#errors_err_worker_unsupported_operation" id="errors_err_worker_unsupported_operation">#</a></span></h3>
+<h4><code>ERR_WORKER_UNSUPPORTED_OPERATION</code><span><a class="mark" href="#errors_err_worker_unsupported_operation" id="errors_err_worker_unsupported_operation">#</a></span></h4>
 <p>The requested functionality is not supported in worker threads.</p>
 <p><a id="ERR_ZLIB_INITIALIZATION_FAILED"></a></p>
-<h3><code>ERR_ZLIB_INITIALIZATION_FAILED</code><span><a class="mark" href="#errors_err_zlib_initialization_failed" id="errors_err_zlib_initialization_failed">#</a></span></h3>
+<h4><code>ERR_ZLIB_INITIALIZATION_FAILED</code><span><a class="mark" href="#errors_err_zlib_initialization_failed" id="errors_err_zlib_initialization_failed">#</a></span></h4>
 <p>Creation of a <a href="zlib.html"><code>zlib</code></a> object failed due to incorrect configuration.</p>
 <p><a id="HPE_HEADER_OVERFLOW"></a></p>
-<h3><code>HPE_HEADER_OVERFLOW</code><span><a class="mark" href="#errors_hpe_header_overflow" id="errors_hpe_header_overflow">#</a></span></h3>
+<h4><code>HPE_HEADER_OVERFLOW</code><span><a class="mark" href="#errors_hpe_header_overflow" id="errors_hpe_header_overflow">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.4.0</td>
+<tr><td>v11.4.0, v10.15.0</td>
 <td><p>Max header size in <code>http_parser</code> was set to 8KB.</p></td></tr>
 </tbody></table>
 </details>
@@ -28186,14 +29581,14 @@ malconfigured clients, if more than 8KB of HTTP header data is received then
 HTTP parsing will abort without a request or response object being created, and
 an <code>Error</code> with this code will be emitted.</p>
 <p><a id="HPE_UNEXPECTED_CONTENT_LENGTH"></a></p>
-<h3><code>HPE_UNEXPECTED_CONTENT_LENGTH</code><span><a class="mark" href="#errors_hpe_unexpected_content_length" id="errors_hpe_unexpected_content_length">#</a></span></h3>
+<h4><code>HPE_UNEXPECTED_CONTENT_LENGTH</code><span><a class="mark" href="#errors_hpe_unexpected_content_length" id="errors_hpe_unexpected_content_length">#</a></span></h4>
 <p>Server is sending both a <code>Content-Length</code> header and <code>Transfer-Encoding: chunked</code>.</p>
 <p><code>Transfer-Encoding: chunked</code> allows the server to maintain an HTTP persistent
 connection for dynamically generated content.
 In this case, the <code>Content-Length</code> HTTP header cannot be used.</p>
 <p>Use <code>Content-Length</code> or <code>Transfer-Encoding: chunked</code>.</p>
 <p><a id="MODULE_NOT_FOUND"></a></p>
-<h3><code>MODULE_NOT_FOUND</code><span><a class="mark" href="#errors_module_not_found" id="errors_module_not_found">#</a></span></h3>
+<h4><code>MODULE_NOT_FOUND</code><span><a class="mark" href="#errors_module_not_found" id="errors_module_not_found">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -28205,26 +29600,19 @@ In this case, the <code>Content-Length</code> HTTP header cannot be used.</p>
 </div>
 <p>A module file could not be resolved while attempting a <a href="#modules_require_id"><code>require()</code></a> or
 <code>import</code> operation.</p>
-<h2>Legacy Node.js error codes<span><a class="mark" href="#errors_legacy_node_js_error_codes" id="errors_legacy_node_js_error_codes">#</a></span></h2>
+</section><section><h3>Legacy Node.js error codes<span><a class="mark" href="#errors_legacy_node_js_error_codes" id="errors_legacy_node_js_error_codes">#</a></span></h3>
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. These error codes are either inconsistent, or have
 been removed.</div><p></p>
 <p><a id="ERR_CANNOT_TRANSFER_OBJECT"></a></p>
-<h3><code>ERR_CANNOT_TRANSFER_OBJECT</code><span><a class="mark" href="#errors_err_cannot_transfer_object" id="errors_err_cannot_transfer_object">#</a></span></h3>
+<h4><code>ERR_CANNOT_TRANSFER_OBJECT</code><span><a class="mark" href="#errors_err_cannot_transfer_object" id="errors_err_cannot_transfer_object">#</a></span></h4>
 <!--
 added: v10.5.0
 removed: v12.5.0
 -->
 <p>The value passed to <code>postMessage()</code> contained an object that is not supported
 for transferring.</p>
-<p><a id="ERR_CLOSED_MESSAGE_PORT"></a></p>
-<h3><code>ERR_CLOSED_MESSAGE_PORT</code><span><a class="mark" href="#errors_err_closed_message_port" id="errors_err_closed_message_port">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.5.0</span><span>Removed in: v11.12.0</span>
-</div>
-<p>There was an attempt to use a <code>MessagePort</code> instance in a closed
-state, usually after <code>.close()</code> has been called.</p>
 <p><a id="ERR_CRYPTO_HASH_DIGEST_NO_UTF16"></a></p>
-<h3><code>ERR_CRYPTO_HASH_DIGEST_NO_UTF16</code><span><a class="mark" href="#errors_err_crypto_hash_digest_no_utf16" id="errors_err_crypto_hash_digest_no_utf16">#</a></span></h3>
+<h4><code>ERR_CRYPTO_HASH_DIGEST_NO_UTF16</code><span><a class="mark" href="#errors_err_crypto_hash_digest_no_utf16" id="errors_err_crypto_hash_digest_no_utf16">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v12.12.0</span>
 </div>
@@ -28233,76 +29621,85 @@ state, usually after <code>.close()</code> has been called.</p>
 causing the method to return a string rather than a <code>Buffer</code>, the UTF-16
 encoding (e.g. <code>ucs</code> or <code>utf16le</code>) is not supported.</p>
 <p><a id="ERR_HTTP2_FRAME_ERROR"></a></p>
-<h3><code>ERR_HTTP2_FRAME_ERROR</code><span><a class="mark" href="#errors_err_http2_frame_error" id="errors_err_http2_frame_error">#</a></span></h3>
+<h4><code>ERR_HTTP2_FRAME_ERROR</code><span><a class="mark" href="#errors_err_http2_frame_error" id="errors_err_http2_frame_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when a failure occurs sending an individual frame on the HTTP/2
 session.</p>
 <p><a id="ERR_HTTP2_HEADERS_OBJECT"></a></p>
-<h3><code>ERR_HTTP2_HEADERS_OBJECT</code><span><a class="mark" href="#errors_err_http2_headers_object" id="errors_err_http2_headers_object">#</a></span></h3>
+<h4><code>ERR_HTTP2_HEADERS_OBJECT</code><span><a class="mark" href="#errors_err_http2_headers_object" id="errors_err_http2_headers_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an HTTP/2 Headers Object is expected.</p>
 <p><a id="ERR_HTTP2_HEADER_REQUIRED"></a></p>
-<h3><code>ERR_HTTP2_HEADER_REQUIRED</code><span><a class="mark" href="#errors_err_http2_header_required" id="errors_err_http2_header_required">#</a></span></h3>
+<h4><code>ERR_HTTP2_HEADER_REQUIRED</code><span><a class="mark" href="#errors_err_http2_header_required" id="errors_err_http2_header_required">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when a required header is missing in an HTTP/2 message.</p>
 <p><a id="ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND"></a></p>
-<h3><code>ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND</code><span><a class="mark" href="#errors_err_http2_info_headers_after_respond" id="errors_err_http2_info_headers_after_respond">#</a></span></h3>
+<h4><code>ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND</code><span><a class="mark" href="#errors_err_http2_info_headers_after_respond" id="errors_err_http2_info_headers_after_respond">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>HTTP/2 informational headers must only be sent <em>prior</em> to calling the
 <code>Http2Stream.prototype.respond()</code> method.</p>
 <p><a id="ERR_HTTP2_STREAM_CLOSED"></a></p>
-<h3><code>ERR_HTTP2_STREAM_CLOSED</code><span><a class="mark" href="#errors_err_http2_stream_closed" id="errors_err_http2_stream_closed">#</a></span></h3>
+<h4><code>ERR_HTTP2_STREAM_CLOSED</code><span><a class="mark" href="#errors_err_http2_stream_closed" id="errors_err_http2_stream_closed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an action has been performed on an HTTP/2 Stream that has already
 been closed.</p>
 <p><a id="ERR_HTTP_INVALID_CHAR"></a></p>
-<h3><code>ERR_HTTP_INVALID_CHAR</code><span><a class="mark" href="#errors_err_http_invalid_char" id="errors_err_http_invalid_char">#</a></span></h3>
+<h4><code>ERR_HTTP_INVALID_CHAR</code><span><a class="mark" href="#errors_err_http_invalid_char" id="errors_err_http_invalid_char">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an invalid character is found in an HTTP response status message
 (reason phrase).</p>
+<p><a id="ERR_HTTP_REQUEST_TIMEOUT"></a></p>
+<h4><code>ERR_HTTP_REQUEST_TIMEOUT</code><span><a class="mark" href="#errors_err_http_request_timeout" id="errors_err_http_request_timeout">#</a></span></h4>
+<p>The client has not sent the entire request within the allowed time.</p>
 <p><a id="ERR_INDEX_OUT_OF_RANGE"></a></p>
-<h3><code>ERR_INDEX_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_index_out_of_range" id="errors_err_index_out_of_range">#</a></span></h3>
+<h4><code>ERR_INDEX_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_index_out_of_range" id="errors_err_index_out_of_range">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span><span>Removed in: v11.0.0</span>
 </div>
 <p>A given index was out of the accepted range (e.g. negative offsets).</p>
 <p><a id="ERR_NAPI_CONS_PROTOTYPE_OBJECT"></a></p>
-<h3><code>ERR_NAPI_CONS_PROTOTYPE_OBJECT</code><span><a class="mark" href="#errors_err_napi_cons_prototype_object" id="errors_err_napi_cons_prototype_object">#</a></span></h3>
+<h4><code>ERR_NAPI_CONS_PROTOTYPE_OBJECT</code><span><a class="mark" href="#errors_err_napi_cons_prototype_object" id="errors_err_napi_cons_prototype_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
-<p>Used by the <code>N-API</code> when <code>Constructor.prototype</code> is not an object.</p>
+<p>Used by the <code>Node-API</code> when <code>Constructor.prototype</code> is not an object.</p>
 <p><a id="ERR_NO_LONGER_SUPPORTED"></a></p>
-<h3><code>ERR_NO_LONGER_SUPPORTED</code><span><a class="mark" href="#errors_err_no_longer_supported" id="errors_err_no_longer_supported">#</a></span></h3>
+<h4><code>ERR_NO_LONGER_SUPPORTED</code><span><a class="mark" href="#errors_err_no_longer_supported" id="errors_err_no_longer_supported">#</a></span></h4>
 <p>A Node.js API was called in an unsupported manner, such as
 <code>Buffer.write(string, encoding, offset[, length])</code>.</p>
 <p><a id="ERR_OUTOFMEMORY"></a></p>
-<h3><code>ERR_OUTOFMEMORY</code><span><a class="mark" href="#errors_err_outofmemory" id="errors_err_outofmemory">#</a></span></h3>
+<h4><code>ERR_OUTOFMEMORY</code><span><a class="mark" href="#errors_err_outofmemory" id="errors_err_outofmemory">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used generically to identify that an operation caused an out of memory
 condition.</p>
 <p><a id="ERR_PARSE_HISTORY_DATA"></a></p>
-<h3><code>ERR_PARSE_HISTORY_DATA</code><span><a class="mark" href="#errors_err_parse_history_data" id="errors_err_parse_history_data">#</a></span></h3>
+<h4><code>ERR_PARSE_HISTORY_DATA</code><span><a class="mark" href="#errors_err_parse_history_data" id="errors_err_parse_history_data">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>The <code>repl</code> module was unable to parse data from the REPL history file.</p>
+<p><a id="ERR_SOCKET_CANNOT_SEND"></a></p>
+<h4><code>ERR_SOCKET_CANNOT_SEND</code><span><a class="mark" href="#errors_err_socket_cannot_send" id="errors_err_socket_cannot_send">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v9.0.0</span><span>Removed in: v14.0.0</span>
+</div>
+<p>Data could not be sent on a socket.</p>
 <p><a id="ERR_STDERR_CLOSE"></a></p>
-<h3><code>ERR_STDERR_CLOSE</code><span><a class="mark" href="#errors_err_stderr_close" id="errors_err_stderr_close">#</a></span></h3>
+<h4><code>ERR_STDERR_CLOSE</code><span><a class="mark" href="#errors_err_stderr_close" id="errors_err_stderr_close">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -28317,7 +29714,7 @@ condition.</p>
 <p>An attempt was made to close the <code>process.stderr</code> stream. By design, Node.js
 does not allow <code>stdout</code> or <code>stderr</code> streams to be closed by user code.</p>
 <p><a id="ERR_STDOUT_CLOSE"></a></p>
-<h3><code>ERR_STDOUT_CLOSE</code><span><a class="mark" href="#errors_err_stdout_close" id="errors_err_stdout_close">#</a></span></h3>
+<h4><code>ERR_STDOUT_CLOSE</code><span><a class="mark" href="#errors_err_stdout_close" id="errors_err_stdout_close">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -28332,29 +29729,30 @@ does not allow <code>stdout</code> or <code>stderr</code> streams to be closed b
 <p>An attempt was made to close the <code>process.stdout</code> stream. By design, Node.js
 does not allow <code>stdout</code> or <code>stderr</code> streams to be closed by user code.</p>
 <p><a id="ERR_STREAM_READ_NOT_IMPLEMENTED"></a></p>
-<h3><code>ERR_STREAM_READ_NOT_IMPLEMENTED</code><span><a class="mark" href="#errors_err_stream_read_not_implemented" id="errors_err_stream_read_not_implemented">#</a></span></h3>
+<h4><code>ERR_STREAM_READ_NOT_IMPLEMENTED</code><span><a class="mark" href="#errors_err_stream_read_not_implemented" id="errors_err_stream_read_not_implemented">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an attempt is made to use a readable stream that has not implemented
 <a href="#stream_readable_read_size_1"><code>readable._read()</code></a>.</p>
 <p><a id="ERR_TLS_RENEGOTIATION_FAILED"></a></p>
-<h3><code>ERR_TLS_RENEGOTIATION_FAILED</code><span><a class="mark" href="#errors_err_tls_renegotiation_failed" id="errors_err_tls_renegotiation_failed">#</a></span></h3>
+<h4><code>ERR_TLS_RENEGOTIATION_FAILED</code><span><a class="mark" href="#errors_err_tls_renegotiation_failed" id="errors_err_tls_renegotiation_failed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when a TLS renegotiation request has failed in a non-specific way.</p>
-<p><a id="ERR_UNKNOWN_BUILTIN_MODULE"></a></p>
-<h3><code>ERR_UNKNOWN_BUILTIN_MODULE</code><span><a class="mark" href="#errors_err_unknown_builtin_module_1" id="errors_err_unknown_builtin_module_1">#</a></span></h3>
+<p><a id="ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER"></a></p>
+<h4><code>ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER</code><span><a class="mark" href="#errors_err_transferring_externalized_sharedarraybuffer" id="errors_err_transferring_externalized_sharedarraybuffer">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v8.0.0</span><span>Removed in: v9.0.0</span>
+<span>Added in: v10.5.0</span><span>Removed in: v14.0.0</span>
 </div>
-<p>The <code>'ERR_UNKNOWN_BUILTIN_MODULE'</code> error code is used to identify a specific
-kind of internal Node.js error that should not typically be triggered by user
-code. Instances of this error point to an internal bug within the Node.js
-binary itself.</p>
+<p>A <code>SharedArrayBuffer</code> whose memory is not managed by the JavaScript engine
+or by Node.js was encountered during serialization. Such a <code>SharedArrayBuffer</code>
+cannot be serialized.</p>
+<p>This can only happen when native addons create <code>SharedArrayBuffer</code>s in
+"externalized" mode, or put existing <code>SharedArrayBuffer</code> into externalized mode.</p>
 <p><a id="ERR_UNKNOWN_STDIN_TYPE"></a></p>
-<h3><code>ERR_UNKNOWN_STDIN_TYPE</code><span><a class="mark" href="#errors_err_unknown_stdin_type" id="errors_err_unknown_stdin_type">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_STDIN_TYPE</code><span><a class="mark" href="#errors_err_unknown_stdin_type" id="errors_err_unknown_stdin_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span><span>Removed in: v11.7.0</span>
 </div>
@@ -28362,7 +29760,7 @@ binary itself.</p>
 type. This error is usually an indication of a bug within Node.js itself,
 although it is possible for user code to trigger it.</p>
 <p><a id="ERR_UNKNOWN_STREAM_TYPE"></a></p>
-<h3><code>ERR_UNKNOWN_STREAM_TYPE</code><span><a class="mark" href="#errors_err_unknown_stream_type" id="errors_err_unknown_stream_type">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_STREAM_TYPE</code><span><a class="mark" href="#errors_err_unknown_stream_type" id="errors_err_unknown_stream_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span><span>Removed in: v11.7.0</span>
 </div>
@@ -28370,29 +29768,30 @@ although it is possible for user code to trigger it.</p>
 <code>stderr</code> file type. This error is usually an indication of a bug within Node.js
 itself, although it is possible for user code to trigger it.</p>
 <p><a id="ERR_V8BREAKITERATOR"></a></p>
-<h3><code>ERR_V8BREAKITERATOR</code><span><a class="mark" href="#errors_err_v8breakiterator" id="errors_err_v8breakiterator">#</a></span></h3>
+<h4><code>ERR_V8BREAKITERATOR</code><span><a class="mark" href="#errors_err_v8breakiterator" id="errors_err_v8breakiterator">#</a></span></h4>
 <p>The V8 <code>BreakIterator</code> API was used but the full ICU data set is not installed.</p>
 <p><a id="ERR_VALUE_OUT_OF_RANGE"></a></p>
-<h3><code>ERR_VALUE_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_value_out_of_range" id="errors_err_value_out_of_range">#</a></span></h3>
+<h4><code>ERR_VALUE_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_value_out_of_range" id="errors_err_value_out_of_range">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when a given value is out of the accepted range.</p>
 <p><a id="ERR_VM_MODULE_NOT_LINKED"></a></p>
-<h3><code>ERR_VM_MODULE_NOT_LINKED</code><span><a class="mark" href="#errors_err_vm_module_not_linked" id="errors_err_vm_module_not_linked">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_NOT_LINKED</code><span><a class="mark" href="#errors_err_vm_module_not_linked" id="errors_err_vm_module_not_linked">#</a></span></h4>
 <p>The module must be successfully linked before instantiation.</p>
 <p><a id="ERR_ZLIB_BINDING_CLOSED"></a></p>
-<h3><code>ERR_ZLIB_BINDING_CLOSED</code><span><a class="mark" href="#errors_err_zlib_binding_closed" id="errors_err_zlib_binding_closed">#</a></span></h3>
+<h4><code>ERR_ZLIB_BINDING_CLOSED</code><span><a class="mark" href="#errors_err_zlib_binding_closed" id="errors_err_zlib_binding_closed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an attempt is made to use a <code>zlib</code> object after it has already been
-closed.</p>
-<h1>Events<span><a class="mark" href="#events_events" id="events_events">#</a></span></h1>
+closed.</p></section>
+        </section>
+<section><h2>Events<span><a class="mark" href="#events_events" id="events_events">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/events.js">lib/events.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/events.js">lib/events.js</a></p>
 <p>Much of the Node.js core API is built around an idiomatic asynchronous
 event-driven architecture in which certain kinds of objects (called "emitters")
 emit named events that cause <code>Function</code> objects ("listeners") to be called.</p>
@@ -28406,28 +29805,28 @@ event names are camel-cased strings but any valid JavaScript property key
 can be used.</p>
 <p>When the <code>EventEmitter</code> object emits an event, all of the functions attached
 to that specific event are called <em>synchronously</em>. Any values returned by the
-called listeners are <em>ignored</em> and will be discarded.</p>
+called listeners are <em>ignored</em> and discarded.</p>
 <p>The following example shows a simple <code>EventEmitter</code> instance with a single
 listener. The <code>eventEmitter.on()</code> method is used to register listeners, while
 the <code>eventEmitter.emit()</code> method is used to trigger the event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyEmitter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">EventEmitter</span> </span>{}
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyEmitter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {}
 
-<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'an event occurred!'</span>);
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'an event occurred!'</span>);
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>);</code></pre>
-<h2>Passing arguments and <code>this</code> to listeners<span><a class="mark" href="#events_passing_arguments_and_this_to_listeners" id="events_passing_arguments_and_this_to_listeners">#</a></span></h2>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);</code></pre>
+<section><h3>Passing arguments and <code>this</code> to listeners<span><a class="mark" href="#events_passing_arguments_and_this_to_listeners" id="events_passing_arguments_and_this_to_listeners">#</a></span></h3>
 <p>The <code>eventEmitter.emit()</code> method allows an arbitrary set of arguments to be
 passed to the listener functions. Keep in mind that when
 an ordinary listener function is called, the standard <code>this</code> keyword
 is intentionally set to reference the <code>EventEmitter</code> instance to which the
 listener is attached.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">a, b</span>) </span>{
-  <span class="hljs-built_in">console</span>.log(a, b, <span class="hljs-built_in">this</span>, <span class="hljs-built_in">this</span> === myEmitter);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-keyword">function</span>(<span class="hljs-params">a, b</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(a, b, <span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">this</span> === myEmitter);
   <span class="hljs-comment">// Prints:</span>
   <span class="hljs-comment">//   a b MyEmitter {</span>
   <span class="hljs-comment">//     domain: null,</span>
@@ -28435,123 +29834,126 @@ myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-functio
   <span class="hljs-comment">//     _eventsCount: 1,</span>
   <span class="hljs-comment">//     _maxListeners: undefined } true</span>
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
 <p>It is possible to use ES6 Arrow Functions as listeners, however, when doing so,
 the <code>this</code> keyword will no longer reference the <code>EventEmitter</code> instance:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(a, b, <span class="hljs-built_in">this</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(a, b, <span class="hljs-variable language_">this</span>);
   <span class="hljs-comment">// Prints: a b {}</span>
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
-<h2>Asynchronous vs. synchronous<span><a class="mark" href="#events_asynchronous_vs_synchronous" id="events_asynchronous_vs_synchronous">#</a></span></h2>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
+</section><section><h3>Asynchronous vs. synchronous<span><a class="mark" href="#events_asynchronous_vs_synchronous" id="events_asynchronous_vs_synchronous">#</a></span></h3>
 <p>The <code>EventEmitter</code> calls all listeners synchronously in the order in which
 they were registered. This ensures the proper sequencing of
 events and helps avoid race conditions and logic errors. When appropriate,
 listener functions can switch to an asynchronous mode of operation using
 the <code>setImmediate()</code> or <code>process.nextTick()</code> methods:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> {
-  setImmediate(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'this happens asynchronously'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> {
+  <span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'this happens asynchronously'</span>);
   });
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
-<h2>Handling events only once<span><a class="mark" href="#events_handling_events_only_once" id="events_handling_events_only_once">#</a></span></h2>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
+</section><section><h3>Handling events only once<span><a class="mark" href="#events_handling_events_only_once" id="events_handling_events_only_once">#</a></span></h3>
 <p>When a listener is registered using the <code>eventEmitter.on()</code> method, that
-listener will be invoked <em>every time</em> the named event is emitted.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
+listener is invoked <em>every time</em> the named event is emitted.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
 <span class="hljs-keyword">let</span> m = <span class="hljs-number">0</span>;
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(++m);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(++m);
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints: 1</span>
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints: 2</span></code></pre>
 <p>Using the <code>eventEmitter.once()</code> method, it is possible to register a listener
 that is called at most once for a particular event. Once the event is emitted,
 the listener is unregistered and <em>then</em> called.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
 <span class="hljs-keyword">let</span> m = <span class="hljs-number">0</span>;
-myEmitter.once(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(++m);
+myEmitter.<span class="hljs-title function_">once</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(++m);
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints: 1</span>
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Ignored</span></code></pre>
-<h2>Error events<span><a class="mark" href="#events_error_events" id="events_error_events">#</a></span></h2>
+</section><section><h3>Error events<span><a class="mark" href="#events_error_events" id="events_error_events">#</a></span></h3>
 <p>When an error occurs within an <code>EventEmitter</code> instance, the typical action is
 for an <code>'error'</code> event to be emitted. These are treated as special cases
 within Node.js.</p>
 <p>If an <code>EventEmitter</code> does <em>not</em> have at least one listener registered for the
 <code>'error'</code> event, and an <code>'error'</code> event is emitted, the error is thrown, a
 stack trace is printed, and the Node.js process exits.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'whoops!'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'whoops!'</span>));
 <span class="hljs-comment">// Throws and crashes Node.js</span></code></pre>
 <p>To guard against crashing the Node.js process the <a href="domain.html"><code>domain</code></a> module can be
 used. (Note, however, that the <code>domain</code> module is deprecated.)</p>
 <p>As a best practice, listeners should always be added for the <code>'error'</code> events.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'whoops! there was an error'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'whoops! there was an error'</span>);
 });
-myEmitter.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'whoops!'</span>));
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'whoops!'</span>));
 <span class="hljs-comment">// Prints: whoops! there was an error</span></code></pre>
 <p>It is possible to monitor <code>'error'</code> events without consuming the emitted error
-by installing a listener using the symbol <code>errorMonitor</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(EventEmitter.errorMonitor, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  MyMonitoringTool.log(err);
+by installing a listener using the symbol <code>events.errorMonitor</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, errorMonitor } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(errorMonitor, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-title class_">MyMonitoringTool</span>.<span class="hljs-title function_">log</span>(err);
 });
-myEmitter.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'whoops!'</span>));
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'whoops!'</span>));
 <span class="hljs-comment">// Still throws and crashes Node.js</span></code></pre>
-<h2>Capture rejections of promises<span><a class="mark" href="#events_capture_rejections_of_promises" id="events_capture_rejections_of_promises">#</a></span></h2>
+</section><section><h3>Capture rejections of promises<span><a class="mark" href="#events_capture_rejections_of_promises" id="events_capture_rejections_of_promises">#</a></span></h3>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
 <p>Using <code>async</code> functions with event handlers is problematic, because it
 can lead to an unhandled rejection in case of a thrown exception:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
-ee.on(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+ee.<span class="hljs-title function_">on</span>(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
 });</code></pre>
 <p>The <code>captureRejections</code> option in the <code>EventEmitter</code> constructor or the global
 setting change this behavior, installing a <code>.then(undefined, handler)</code>
 handler on the <code>Promise</code>. This handler routes the exception
 asynchronously to the <a href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args"><code>Symbol.for('nodejs.rejection')</code></a> method
 if there is one, or to <a href="#events_error_events"><code>'error'</code></a> event handler if there is none.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ee1 = <span class="hljs-keyword">new</span> EventEmitter({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
-ee1.on(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ee1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
+ee1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
 });
 
-ee1.on(<span class="hljs-string">'error'</span>, <span class="hljs-built_in">console</span>.log);
+ee1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>);
 
-<span class="hljs-keyword">const</span> ee2 = <span class="hljs-keyword">new</span> EventEmitter({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
-ee2.on(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
+<span class="hljs-keyword">const</span> ee2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
+ee2.<span class="hljs-title function_">on</span>(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
 });
 
-ee2[<span class="hljs-built_in">Symbol</span>.for(<span class="hljs-string">'nodejs.rejection'</span>)] = <span class="hljs-built_in">console</span>.log;</code></pre>
-<p>Setting <code>EventEmitter.captureRejections = true</code> will change the default for all
+ee2[<span class="hljs-title class_">Symbol</span>.<span class="hljs-title function_">for</span>(<span class="hljs-string">'nodejs.rejection'</span>)] = <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>;</code></pre>
+<p>Setting <code>events.captureRejections = true</code> will change the default for all
 new instances of <code>EventEmitter</code>.</p>
-<pre><code class="language-js">EventEmitter.captureRejections = <span class="hljs-literal">true</span>;
-<span class="hljs-keyword">const</span> ee1 = <span class="hljs-keyword">new</span> EventEmitter();
-ee1.on(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+events.<span class="hljs-property">captureRejections</span> = <span class="hljs-literal">true</span>;
+<span class="hljs-keyword">const</span> ee1 = <span class="hljs-keyword">new</span> events.<span class="hljs-title class_">EventEmitter</span>();
+ee1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
 });
 
-ee1.on(<span class="hljs-string">'error'</span>, <span class="hljs-built_in">console</span>.log);</code></pre>
+ee1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>);</code></pre>
 <p>The <code>'error'</code> events that are generated by the <code>captureRejections</code> behavior
 do not have a catch handler to avoid infinite error loops: the
 recommendation is to <strong>not use <code>async</code> functions as <code>'error'</code> event handlers</strong>.</p>
-<h2>Class: <code>EventEmitter</code><span><a class="mark" href="#events_class_eventemitter" id="events_class_eventemitter">#</a></span></h2>
+</section><section><h3>Class: <code>EventEmitter</code><span><a class="mark" href="#events_class_eventemitter" id="events_class_eventemitter">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.4.0, v12.16.0</td>
 <td><p>Added captureRejections option.</p></td></tr>
 <tr><td>v0.1.26</td>
 <td><p><span>Added in: v0.1.26</span></p></td></tr>
@@ -28559,16 +29961,16 @@ recommendation is to <strong>not use <code>async</code> functions as <code>'erro
 </details>
 </div>
 <p>The <code>EventEmitter</code> class is defined and exposed by the <code>events</code> module:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);</code></pre>
 <p>All <code>EventEmitter</code>s emit the event <code>'newListener'</code> when new listeners are
 added and <code>'removeListener'</code> when existing listeners are removed.</p>
 <p>It supports the following option:</p>
 <ul>
 <li><code>captureRejections</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> It enables
 <a href="#events_capture_rejections_of_promises">automatic capturing of promise rejection</a>.
-Default: <code>false</code>.</li>
+<strong>Default:</strong> <code>false</code>.</li>
 </ul>
-<h3>Event: 'newListener'<span><a class="mark" href="#events_event_newlistener" id="events_event_newlistener">#</a></span></h3>
+<h4>Event: <code>'newListener'</code><span><a class="mark" href="#events_event_newlistener" id="events_event_newlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.26</span>
 </div>
@@ -28578,30 +29980,32 @@ Default: <code>false</code>.</li>
 </ul>
 <p>The <code>EventEmitter</code> instance will emit its own <code>'newListener'</code> event <em>before</em>
 a listener is added to its internal array of listeners.</p>
-<p>Listeners registered for the <code>'newListener'</code> event will be passed the event
+<p>Listeners registered for the <code>'newListener'</code> event are passed the event
 name and a reference to the listener being added.</p>
 <p>The fact that the event is triggered before adding the listener has a subtle
 but important side effect: any <em>additional</em> listeners registered to the same
-<code>name</code> <em>within</em> the <code>'newListener'</code> callback will be inserted <em>before</em> the
+<code>name</code> <em>within</em> the <code>'newListener'</code> callback are inserted <em>before</em> the
 listener that is in the process of being added.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">MyEmitter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {}
+
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
 <span class="hljs-comment">// Only do this once so we don't loop forever</span>
-myEmitter.once(<span class="hljs-string">'newListener'</span>, <span class="hljs-function">(<span class="hljs-params">event, listener</span>) =></span> {
+myEmitter.<span class="hljs-title function_">once</span>(<span class="hljs-string">'newListener'</span>, <span class="hljs-function">(<span class="hljs-params">event, listener</span>) =></span> {
   <span class="hljs-keyword">if</span> (event === <span class="hljs-string">'event'</span>) {
     <span class="hljs-comment">// Insert a new listener in front</span>
-    myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'B'</span>);
+    myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'B'</span>);
     });
   }
 });
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'A'</span>);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'A'</span>);
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   B</span>
 <span class="hljs-comment">//   A</span></code></pre>
-<h3>Event: <code>'removeListener'</code><span><a class="mark" href="#events_event_removelistener" id="events_event_removelistener">#</a></span></h3>
+<h4>Event: <code>'removeListener'</code><span><a class="mark" href="#events_event_removelistener" id="events_event_removelistener">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -28618,56 +30022,413 @@ myEmitter.emit(<span class="hljs-string">'event'</span>);
 <li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The event handler function</li>
 </ul>
 <p>The <code>'removeListener'</code> event is emitted <em>after</em> the <code>listener</code> is removed.</p>
-<h3><code>EventEmitter.listenerCount(emitter, eventName)</code><span><a class="mark" href="#events_eventemitter_listenercount_emitter_eventname" id="events_eventemitter_listenercount_emitter_eventname">#</a></span></h3>
+<h4><code>emitter.addListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_addlistener_eventname_listener" id="events_emitter_addlistener_eventname_listener">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.9.12</span><span>Deprecated since: v3.2.0</span>
+<span>Added in: v0.1.26</span>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#events_emitter_listenercount_eventname"><code>emitter.listenerCount()</code></a> instead.</div><p></p>
 <ul>
-<li><code>emitter</code> <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> The emitter to query</li>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The event name</li>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<p>A class method that returns the number of listeners for the given <code>eventName</code>
-registered on the given <code>emitter</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {});
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {});
-<span class="hljs-built_in">console</span>.log(EventEmitter.listenerCount(myEmitter, <span class="hljs-string">'event'</span>));
-<span class="hljs-comment">// Prints: 2</span></code></pre>
-<h3><code>EventEmitter.defaultMaxListeners</code><span><a class="mark" href="#events_eventemitter_defaultmaxlisteners" id="events_eventemitter_defaultmaxlisteners">#</a></span></h3>
+<p>Alias for <code>emitter.on(eventName, listener)</code>.</p>
+<h4><code>emitter.emit(eventName[, ...args])</code><span><a class="mark" href="#events_emitter_emit_eventname_args" id="events_emitter_emit_eventname_args">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.26</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Synchronously calls each of the listeners registered for the event named
+<code>eventName</code>, in the order they were registered, passing the supplied arguments
+to each.</p>
+<p>Returns <code>true</code> if the event had listeners, <code>false</code> otherwise.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+
+<span class="hljs-comment">// First listener</span>
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">firstListener</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Helloooo! first listener'</span>);
+});
+<span class="hljs-comment">// Second listener</span>
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">secondListener</span>(<span class="hljs-params">arg1, arg2</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`event with parameters <span class="hljs-subst">${arg1}</span>, <span class="hljs-subst">${arg2}</span> in second listener`</span>);
+});
+<span class="hljs-comment">// Third listener</span>
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">thirdListener</span>(<span class="hljs-params">...args</span>) {
+  <span class="hljs-keyword">const</span> parameters = args.<span class="hljs-title function_">join</span>(<span class="hljs-string">', '</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`event with parameters <span class="hljs-subst">${parameters}</span> in third listener`</span>);
+});
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myEmitter.<span class="hljs-title function_">listeners</span>(<span class="hljs-string">'event'</span>));
+
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>);
+
+<span class="hljs-comment">// Prints:</span>
+<span class="hljs-comment">// [</span>
+<span class="hljs-comment">//   [Function: firstListener],</span>
+<span class="hljs-comment">//   [Function: secondListener],</span>
+<span class="hljs-comment">//   [Function: thirdListener]</span>
+<span class="hljs-comment">// ]</span>
+<span class="hljs-comment">// Helloooo! first listener</span>
+<span class="hljs-comment">// event with parameters 1, 2 in second listener</span>
+<span class="hljs-comment">// event with parameters 1, 2, 3, 4, 5 in third listener</span></code></pre>
+<h4><code>emitter.eventNames()</code><span><a class="mark" href="#events_emitter_eventnames" id="events_emitter_eventnames">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v6.0.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
+</ul>
+<p>Returns an array listing the events for which the emitter has registered
+listeners. The values in the array are strings or <code>Symbol</code>s.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEE.<span class="hljs-title function_">on</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> {});
+myEE.<span class="hljs-title function_">on</span>(<span class="hljs-string">'bar'</span>, <span class="hljs-function">() =></span> {});
+
+<span class="hljs-keyword">const</span> sym = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'symbol'</span>);
+myEE.<span class="hljs-title function_">on</span>(sym, <span class="hljs-function">() =></span> {});
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myEE.<span class="hljs-title function_">eventNames</span>());
+<span class="hljs-comment">// Prints: [ 'foo', 'bar', Symbol(symbol) ]</span></code></pre>
+<h4><code>emitter.getMaxListeners()</code><span><a class="mark" href="#events_emitter_getmaxlisteners" id="events_emitter_getmaxlisteners">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v1.0.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+</ul>
+<p>Returns the current max listener value for the <code>EventEmitter</code> which is either
+set by <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> or defaults to
+<a href="#events_events_defaultmaxlisteners"><code>events.defaultMaxListeners</code></a>.</p>
+<h4><code>emitter.listenerCount(eventName)</code><span><a class="mark" href="#events_emitter_listenercount_eventname" id="events_emitter_listenercount_eventname">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v3.2.0</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event being listened for</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+</ul>
+<p>Returns the number of listeners listening to the event named <code>eventName</code>.</p>
+<h4><code>emitter.listeners(eventName)</code><span><a class="mark" href="#events_emitter_listeners_eventname" id="events_emitter_listeners_eventname">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.0.0</td>
+<td><p>For listeners attached using <code>.once()</code> this returns the original listeners instead of wrapper functions now.</p></td></tr>
+<tr><td>v0.1.26</td>
+<td><p><span>Added in: v0.1.26</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
+</ul>
+<p>Returns a copy of the array of listeners for the event named <code>eventName</code>.</p>
+<pre><code class="language-js">server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'someone connected!'</span>);
+});
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(util.<span class="hljs-title function_">inspect</span>(server.<span class="hljs-title function_">listeners</span>(<span class="hljs-string">'connection'</span>)));
+<span class="hljs-comment">// Prints: [ [Function] ]</span></code></pre>
+<h4><code>emitter.off(eventName, listener)</code><span><a class="mark" href="#events_emitter_off_eventname_listener" id="events_emitter_off_eventname_listener">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>Alias for <a href="#events_emitter_removelistener_eventname_listener"><code>emitter.removeListener()</code></a>.</p>
+<h4><code>emitter.on(eventName, listener)</code><span><a class="mark" href="#events_emitter_on_eventname_listener" id="events_emitter_on_eventname_listener">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.101</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event.</li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
+<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>Adds the <code>listener</code> function to the end of the listeners array for the
+event named <code>eventName</code>. No checks are made to see if the <code>listener</code> has
+already been added. Multiple calls passing the same combination of <code>eventName</code>
+and <code>listener</code> will result in the <code>listener</code> being added, and called, multiple
+times.</p>
+<pre><code class="language-js">server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'someone connected!'</span>);
+});</code></pre>
+<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
+<p>By default, event listeners are invoked in the order they are added. The
+<code>emitter.prependListener()</code> method can be used as an alternative to add the
+event listener to the beginning of the listeners array.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEE.<span class="hljs-title function_">on</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a'</span>));
+myEE.<span class="hljs-title function_">prependListener</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'b'</span>));
+myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>);
+<span class="hljs-comment">// Prints:</span>
+<span class="hljs-comment">//   b</span>
+<span class="hljs-comment">//   a</span></code></pre>
+<h4><code>emitter.once(eventName, listener)</code><span><a class="mark" href="#events_emitter_once_eventname_listener" id="events_emitter_once_eventname_listener">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event.</li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
+<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>Adds a <strong>one-time</strong> <code>listener</code> function for the event named <code>eventName</code>. The
+next time <code>eventName</code> is triggered, this listener is removed and then invoked.</p>
+<pre><code class="language-js">server.<span class="hljs-title function_">once</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Ah, we have our first user!'</span>);
+});</code></pre>
+<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
+<p>By default, event listeners are invoked in the order they are added. The
+<code>emitter.prependOnceListener()</code> method can be used as an alternative to add the
+event listener to the beginning of the listeners array.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEE.<span class="hljs-title function_">once</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a'</span>));
+myEE.<span class="hljs-title function_">prependOnceListener</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'b'</span>));
+myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>);
+<span class="hljs-comment">// Prints:</span>
+<span class="hljs-comment">//   b</span>
+<span class="hljs-comment">//   a</span></code></pre>
+<h4><code>emitter.prependListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_prependlistener_eventname_listener" id="events_emitter_prependlistener_eventname_listener">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v6.0.0</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event.</li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
+<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>Adds the <code>listener</code> function to the <em>beginning</em> of the listeners array for the
+event named <code>eventName</code>. No checks are made to see if the <code>listener</code> has
+already been added. Multiple calls passing the same combination of <code>eventName</code>
+and <code>listener</code> will result in the <code>listener</code> being added, and called, multiple
+times.</p>
+<pre><code class="language-js">server.<span class="hljs-title function_">prependListener</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'someone connected!'</span>);
+});</code></pre>
+<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
+<h4><code>emitter.prependOnceListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_prependoncelistener_eventname_listener" id="events_emitter_prependoncelistener_eventname_listener">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v6.0.0</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event.</li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
+<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>Adds a <strong>one-time</strong> <code>listener</code> function for the event named <code>eventName</code> to the
+<em>beginning</em> of the listeners array. The next time <code>eventName</code> is triggered, this
+listener is removed, and then invoked.</p>
+<pre><code class="language-js">server.<span class="hljs-title function_">prependOnceListener</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Ah, we have our first user!'</span>);
+});</code></pre>
+<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
+<h4><code>emitter.removeAllListeners([eventName])</code><span><a class="mark" href="#events_emitter_removealllisteners_eventname" id="events_emitter_removealllisteners_eventname">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.26</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>Removes all listeners, or those of the specified <code>eventName</code>.</p>
+<p>It is bad practice to remove listeners added elsewhere in the code,
+particularly when the <code>EventEmitter</code> instance was created by some other
+component or module (e.g. sockets or file streams).</p>
+<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
+<h4><code>emitter.removeListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_removelistener_eventname_listener" id="events_emitter_removelistener_eventname_listener">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.26</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>Removes the specified <code>listener</code> from the listener array for the event named
+<code>eventName</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title function_">callback</span> = (<span class="hljs-params">stream</span>) => {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'someone connected!'</span>);
+};
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, callback);
+<span class="hljs-comment">// ...</span>
+server.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'connection'</span>, callback);</code></pre>
+<p><code>removeListener()</code> will remove, at most, one instance of a listener from the
+listener array. If any single listener has been added multiple times to the
+listener array for the specified <code>eventName</code>, then <code>removeListener()</code> must be
+called multiple times to remove each instance.</p>
+<p>Once an event is emitted, all listeners attached to it at the
+time of emitting are called in order. This implies that any
+<code>removeListener()</code> or <code>removeAllListeners()</code> calls <em>after</em> emitting and
+<em>before</em> the last listener finishes execution will not remove them from
+<code>emit()</code> in progress. Subsequent events behave as expected.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+
+<span class="hljs-keyword">const</span> <span class="hljs-title function_">callbackA</span> = (<span class="hljs-params"></span>) => {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'A'</span>);
+  myEmitter.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'event'</span>, callbackB);
+};
+
+<span class="hljs-keyword">const</span> <span class="hljs-title function_">callbackB</span> = (<span class="hljs-params"></span>) => {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'B'</span>);
+};
+
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, callbackA);
+
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, callbackB);
+
+<span class="hljs-comment">// callbackA removes listener callbackB but it will still be called.</span>
+<span class="hljs-comment">// Internal listener array at time of emit [callbackA, callbackB]</span>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
+<span class="hljs-comment">// Prints:</span>
+<span class="hljs-comment">//   A</span>
+<span class="hljs-comment">//   B</span>
+
+<span class="hljs-comment">// callbackB is now removed.</span>
+<span class="hljs-comment">// Internal listener array [callbackA]</span>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
+<span class="hljs-comment">// Prints:</span>
+<span class="hljs-comment">//   A</span></code></pre>
+<p>Because listeners are managed using an internal array, calling this will
+change the position indices of any listener registered <em>after</em> the listener
+being removed. This will not impact the order in which listeners are called,
+but it means that any copies of the listener array as returned by
+the <code>emitter.listeners()</code> method will need to be recreated.</p>
+<p>When a single function has been added as a handler multiple times for a single
+event (as in the example below), <code>removeListener()</code> will remove the most
+recently added instance. In the example the <code>once('ping')</code>
+listener is removed:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">pong</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'pong'</span>);
+}
+
+ee.<span class="hljs-title function_">on</span>(<span class="hljs-string">'ping'</span>, pong);
+ee.<span class="hljs-title function_">once</span>(<span class="hljs-string">'ping'</span>, pong);
+ee.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'ping'</span>, pong);
+
+ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'ping'</span>);
+ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'ping'</span>);</code></pre>
+<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
+<h4><code>emitter.setMaxListeners(n)</code><span><a class="mark" href="#events_emitter_setmaxlisteners_n" id="events_emitter_setmaxlisteners_n">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.5</span>
+</div>
+<ul>
+<li><code>n</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>By default <code>EventEmitter</code>s will print a warning if more than <code>10</code> listeners are
+added for a particular event. This is a useful default that helps finding
+memory leaks. The <code>emitter.setMaxListeners()</code> method allows the limit to be
+modified for this specific <code>EventEmitter</code> instance. The value can be set to
+<code>Infinity</code> (or <code>0</code>) to indicate an unlimited number of listeners.</p>
+<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
+<h4><code>emitter.rawListeners(eventName)</code><span><a class="mark" href="#events_emitter_rawlisteners_eventname" id="events_emitter_rawlisteners_eventname">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v9.4.0</span>
+</div>
+<ul>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
+</ul>
+<p>Returns a copy of the array of listeners for the event named <code>eventName</code>,
+including any wrappers (such as those created by <code>.once()</code>).</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> emitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+emitter.<span class="hljs-title function_">once</span>(<span class="hljs-string">'log'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'log once'</span>));
+
+<span class="hljs-comment">// Returns a new Array with a function `onceWrapper` which has a property</span>
+<span class="hljs-comment">// `listener` which contains the original listener bound above</span>
+<span class="hljs-keyword">const</span> listeners = emitter.<span class="hljs-title function_">rawListeners</span>(<span class="hljs-string">'log'</span>);
+<span class="hljs-keyword">const</span> logFnWrapper = listeners[<span class="hljs-number">0</span>];
+
+<span class="hljs-comment">// Logs "log once" to the console and does not unbind the `once` event</span>
+logFnWrapper.<span class="hljs-title function_">listener</span>();
+
+<span class="hljs-comment">// Logs "log once" to the console and removes the listener</span>
+<span class="hljs-title function_">logFnWrapper</span>();
+
+emitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'log'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'log persistently'</span>));
+<span class="hljs-comment">// Will return a new Array with a single function bound by `.on()` above</span>
+<span class="hljs-keyword">const</span> newListeners = emitter.<span class="hljs-title function_">rawListeners</span>(<span class="hljs-string">'log'</span>);
+
+<span class="hljs-comment">// Logs "log persistently" twice</span>
+newListeners[<span class="hljs-number">0</span>]();
+emitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'log'</span>);</code></pre>
+<h4><code>emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])</code><span><a class="mark" href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args" id="events_emitter_symbol_for_nodejs_rejection_err_eventname_args">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.4.0, v12.16.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
+<ul>
+<li><code>err</code> Error</li>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
+</ul>
+<p>The <code>Symbol.for('nodejs.rejection')</code> method is called in case a
+promise rejection happens when emitting an event and
+<a href="#events_capture_rejections_of_promises"><code>captureRejections</code></a> is enabled on the emitter.
+It is possible to use <a href="#events_events_capturerejectionsymbol"><code>events.captureRejectionSymbol</code></a> in
+place of <code>Symbol.for('nodejs.rejection')</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, captureRejectionSymbol } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyClass</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-variable language_">super</span>({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
+  }
+
+  [captureRejectionSymbol](err, event, ...args) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'rejection happened for'</span>, event, <span class="hljs-string">'with'</span>, err, ...args);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">destroy</span>(err);
+  }
+
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">err</span>) {
+    <span class="hljs-comment">// Tear the resource down here.</span>
+  }
+}</code></pre>
+</section><section><h3><code>events.defaultMaxListeners</code><span><a class="mark" href="#events_events_defaultmaxlisteners" id="events_events_defaultmaxlisteners">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
 <p>By default, a maximum of <code>10</code> listeners can be registered for any single
 event. This limit can be changed for individual <code>EventEmitter</code> instances
 using the <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> method. To change the default
-for <em>all</em> <code>EventEmitter</code> instances, the <code>EventEmitter.defaultMaxListeners</code>
-property can be used. If this value is not a positive number, a <code>TypeError</code>
-will be thrown.</p>
-<p>Take caution when setting the <code>EventEmitter.defaultMaxListeners</code> because the
+for <em>all</em> <code>EventEmitter</code> instances, the <code>events.defaultMaxListeners</code>
+property can be used. If this value is not a positive number, a <code>RangeError</code>
+is thrown.</p>
+<p>Take caution when setting the <code>events.defaultMaxListeners</code> because the
 change affects <em>all</em> <code>EventEmitter</code> instances, including those created before
 the change is made. However, calling <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> still has
-precedence over <code>EventEmitter.defaultMaxListeners</code>.</p>
+precedence over <code>events.defaultMaxListeners</code>.</p>
 <p>This is not a hard limit. The <code>EventEmitter</code> instance will allow
 more listeners to be added but will output a trace warning to stderr indicating
 that a "possible EventEmitter memory leak" has been detected. For any single
 <code>EventEmitter</code>, the <code>emitter.getMaxListeners()</code> and <code>emitter.setMaxListeners()</code>
 methods can be used to temporarily avoid this warning:</p>
-<pre><code class="language-js">emitter.setMaxListeners(emitter.getMaxListeners() + <span class="hljs-number">1</span>);
-emitter.once(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">emitter.<span class="hljs-title function_">setMaxListeners</span>(emitter.<span class="hljs-title function_">getMaxListeners</span>() + <span class="hljs-number">1</span>);
+emitter.<span class="hljs-title function_">once</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// do stuff</span>
-  emitter.setMaxListeners(<span class="hljs-built_in">Math</span>.max(emitter.getMaxListeners() - <span class="hljs-number">1</span>, <span class="hljs-number">0</span>));
+  emitter.<span class="hljs-title function_">setMaxListeners</span>(<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(emitter.<span class="hljs-title function_">getMaxListeners</span>() - <span class="hljs-number">1</span>, <span class="hljs-number">0</span>));
 });</code></pre>
-<p>The <a href="#cli_trace_warnings"><code>--trace-warnings</code></a> command line flag can be used to display the
+<p>The <a href="#cli_trace_warnings"><code>--trace-warnings</code></a> command-line flag can be used to display the
 stack trace for such warnings.</p>
 <p>The emitted warning can be inspected with <a href="#process_event_warning"><code>process.on('warning')</code></a> and will
 have the additional <code>emitter</code>, <code>type</code> and <code>count</code> properties, referring to
 the event emitter instance, the event’s name and the number of attached
 listeners, respectively.
 Its <code>name</code> property is set to <code>'MaxListenersExceededWarning'</code>.</p>
-<h3><code>EventEmitter.errorMonitor</code><span><a class="mark" href="#events_eventemitter_errormonitor" id="events_eventemitter_errormonitor">#</a></span></h3>
+</section><section><h3><code>events.errorMonitor</code><span><a class="mark" href="#events_events_errormonitor" id="events_events_errormonitor">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.6.0, v12.17.0</span>
 </div>
 <p>This symbol shall be used to install a listener for only monitoring <code>'error'</code>
 events. Listeners installed using this symbol are called before the regular
@@ -28675,386 +30436,54 @@ events. Listeners installed using this symbol are called before the regular
 <p>Installing a listener using this symbol does not change the behavior once an
 <code>'error'</code> event is emitted, therefore the process will still crash if no
 regular <code>'error'</code> listener is installed.</p>
-<h3><code>emitter.addListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_addlistener_eventname_listener" id="events_emitter_addlistener_eventname_listener">#</a></span></h3>
+</section><section><h3><code>events.getEventListeners(emitterOrTarget, eventName)</code><span><a class="mark" href="#events_events_geteventlisteners_emitterortarget_eventname" id="events_events_geteventlisteners_emitterortarget_eventname">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.1.26</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
-</ul>
-<p>Alias for <code>emitter.on(eventName, listener)</code>.</p>
-<h3><code>emitter.emit(eventName[, ...args])</code><span><a class="mark" href="#events_emitter_emit_eventname_args" id="events_emitter_emit_eventname_args">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.26</span>
+<span>Added in: v14.17.0</span>
 </div>
 <ul>
+<li><code>emitterOrTarget</code> <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> | <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a></li>
 <li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
-<li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Synchronously calls each of the listeners registered for the event named
-<code>eventName</code>, in the order they were registered, passing the supplied arguments
-to each.</p>
-<p>Returns <code>true</code> if the event had listeners, <code>false</code> otherwise.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> EventEmitter();
-
-<span class="hljs-comment">// First listener</span>
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">firstListener</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Helloooo! first listener'</span>);
-});
-<span class="hljs-comment">// Second listener</span>
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">secondListener</span>(<span class="hljs-params">arg1, arg2</span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`event with parameters <span class="hljs-subst">${arg1}</span>, <span class="hljs-subst">${arg2}</span> in second listener`</span>);
-});
-<span class="hljs-comment">// Third listener</span>
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">thirdListener</span>(<span class="hljs-params">...args</span>) </span>{
-  <span class="hljs-keyword">const</span> parameters = args.join(<span class="hljs-string">', '</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`event with parameters <span class="hljs-subst">${parameters}</span> in third listener`</span>);
-});
-
-<span class="hljs-built_in">console</span>.log(myEmitter.listeners(<span class="hljs-string">'event'</span>));
-
-myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>);
-
-<span class="hljs-comment">// Prints:</span>
-<span class="hljs-comment">// [</span>
-<span class="hljs-comment">//   [Function: firstListener],</span>
-<span class="hljs-comment">//   [Function: secondListener],</span>
-<span class="hljs-comment">//   [Function: thirdListener]</span>
-<span class="hljs-comment">// ]</span>
-<span class="hljs-comment">// Helloooo! first listener</span>
-<span class="hljs-comment">// event with parameters 1, 2 in second listener</span>
-<span class="hljs-comment">// event with parameters 1, 2, 3, 4, 5 in third listener</span></code></pre>
-<h3><code>emitter.eventNames()</code><span><a class="mark" href="#events_emitter_eventnames" id="events_emitter_eventnames">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v6.0.0</span>
-</div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
 </ul>
-<p>Returns an array listing the events for which the emitter has registered
-listeners. The values in the array will be strings or <code>Symbol</code>s.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
-myEE.on(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> {});
-myEE.on(<span class="hljs-string">'bar'</span>, <span class="hljs-function">() =></span> {});
-
-<span class="hljs-keyword">const</span> sym = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'symbol'</span>);
-myEE.on(sym, <span class="hljs-function">() =></span> {});
+<p>Returns a copy of the array of listeners for the event named <code>eventName</code>.</p>
+<p>For <code>EventEmitter</code>s this behaves exactly the same as calling <code>.listeners</code> on
+the emitter.</p>
+<p>For <code>EventTarget</code>s this is the only way to get the event listeners for the
+event target. This is useful for debugging and diagnostic purposes.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { getEventListeners, <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-built_in">console</span>.log(myEE.eventNames());
-<span class="hljs-comment">// Prints: [ 'foo', 'bar', Symbol(symbol) ]</span></code></pre>
-<h3><code>emitter.getMaxListeners()</code><span><a class="mark" href="#events_emitter_getmaxlisteners" id="events_emitter_getmaxlisteners">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v1.0.0</span>
-</div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Returns the current max listener value for the <code>EventEmitter</code> which is either
-set by <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> or defaults to
-<a href="#events_eventemitter_defaultmaxlisteners"><code>EventEmitter.defaultMaxListeners</code></a>.</p>
-<h3><code>emitter.listenerCount(eventName)</code><span><a class="mark" href="#events_emitter_listenercount_eventname" id="events_emitter_listenercount_eventname">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v3.2.0</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event being listened for</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Returns the number of listeners listening to the event named <code>eventName</code>.</p>
-<h3><code>emitter.listeners(eventName)</code><span><a class="mark" href="#events_emitter_listeners_eventname" id="events_emitter_listeners_eventname">#</a></span></h3>
+{
+  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+  <span class="hljs-keyword">const</span> <span class="hljs-title function_">listener</span> = (<span class="hljs-params"></span>) => <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Events are fun'</span>);
+  ee.<span class="hljs-title function_">on</span>(<span class="hljs-string">'foo'</span>, listener);
+  <span class="hljs-title function_">getEventListeners</span>(ee, <span class="hljs-string">'foo'</span>); <span class="hljs-comment">// [listener]</span>
+}
+{
+  <span class="hljs-keyword">const</span> et = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventTarget</span>();
+  <span class="hljs-keyword">const</span> <span class="hljs-title function_">listener</span> = (<span class="hljs-params"></span>) => <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Events are fun'</span>);
+  et.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, listener);
+  <span class="hljs-title function_">getEventListeners</span>(et, <span class="hljs-string">'foo'</span>); <span class="hljs-comment">// [listener]</span>
+}</code></pre>
+</section><section><h3><code>events.once(emitter, name[, options])</code><span><a class="mark" href="#events_events_once_emitter_name_options" id="events_events_once_emitter_name_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.0.0</td>
-<td><p>For listeners attached using <code>.once()</code> this returns the original listeners instead of wrapper functions now.</p></td></tr>
-<tr><td>v0.1.26</td>
-<td><p><span>Added in: v0.1.26</span></p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>The <code>signal</code> option is supported now.</p></td></tr>
+<tr><td>v11.13.0, v10.16.0</td>
+<td><p><span>Added in: v11.13.0, v10.16.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
-</ul>
-<p>Returns a copy of the array of listeners for the event named <code>eventName</code>.</p>
-<pre><code class="language-js">server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'someone connected!'</span>);
-});
-<span class="hljs-built_in">console</span>.log(util.inspect(server.listeners(<span class="hljs-string">'connection'</span>)));
-<span class="hljs-comment">// Prints: [ [Function] ]</span></code></pre>
-<h3><code>emitter.off(eventName, listener)</code><span><a class="mark" href="#events_emitter_off_eventname_listener" id="events_emitter_off_eventname_listener">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
-<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>Alias for <a href="#events_emitter_removelistener_eventname_listener"><code>emitter.removeListener()</code></a>.</p>
-<h3><code>emitter.on(eventName, listener)</code><span><a class="mark" href="#events_emitter_on_eventname_listener" id="events_emitter_on_eventname_listener">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.101</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event.</li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
-<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>Adds the <code>listener</code> function to the end of the listeners array for the
-event named <code>eventName</code>. No checks are made to see if the <code>listener</code> has
-already been added. Multiple calls passing the same combination of <code>eventName</code>
-and <code>listener</code> will result in the <code>listener</code> being added, and called, multiple
-times.</p>
-<pre><code class="language-js">server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'someone connected!'</span>);
-});</code></pre>
-<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<p>By default, event listeners are invoked in the order they are added. The
-<code>emitter.prependListener()</code> method can be used as an alternative to add the
-event listener to the beginning of the listeners array.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
-myEE.on(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'a'</span>));
-myEE.prependListener(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'b'</span>));
-myEE.emit(<span class="hljs-string">'foo'</span>);
-<span class="hljs-comment">// Prints:</span>
-<span class="hljs-comment">//   b</span>
-<span class="hljs-comment">//   a</span></code></pre>
-<h3><code>emitter.once(eventName, listener)</code><span><a class="mark" href="#events_emitter_once_eventname_listener" id="events_emitter_once_eventname_listener">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.3.0</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event.</li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
-<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>Adds a <strong>one-time</strong> <code>listener</code> function for the event named <code>eventName</code>. The
-next time <code>eventName</code> is triggered, this listener is removed and then invoked.</p>
-<pre><code class="language-js">server.once(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Ah, we have our first user!'</span>);
-});</code></pre>
-<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<p>By default, event listeners are invoked in the order they are added. The
-<code>emitter.prependOnceListener()</code> method can be used as an alternative to add the
-event listener to the beginning of the listeners array.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
-myEE.once(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'a'</span>));
-myEE.prependOnceListener(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'b'</span>));
-myEE.emit(<span class="hljs-string">'foo'</span>);
-<span class="hljs-comment">// Prints:</span>
-<span class="hljs-comment">//   b</span>
-<span class="hljs-comment">//   a</span></code></pre>
-<h3><code>emitter.prependListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_prependlistener_eventname_listener" id="events_emitter_prependlistener_eventname_listener">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v6.0.0</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event.</li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
-<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>Adds the <code>listener</code> function to the <em>beginning</em> of the listeners array for the
-event named <code>eventName</code>. No checks are made to see if the <code>listener</code> has
-already been added. Multiple calls passing the same combination of <code>eventName</code>
-and <code>listener</code> will result in the <code>listener</code> being added, and called, multiple
-times.</p>
-<pre><code class="language-js">server.prependListener(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'someone connected!'</span>);
-});</code></pre>
-<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.prependOnceListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_prependoncelistener_eventname_listener" id="events_emitter_prependoncelistener_eventname_listener">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v6.0.0</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event.</li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
-<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>Adds a <strong>one-time</strong> <code>listener</code> function for the event named <code>eventName</code> to the
-<em>beginning</em> of the listeners array. The next time <code>eventName</code> is triggered, this
-listener is removed, and then invoked.</p>
-<pre><code class="language-js">server.prependOnceListener(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Ah, we have our first user!'</span>);
-});</code></pre>
-<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.removeAllListeners([eventName])</code><span><a class="mark" href="#events_emitter_removealllisteners_eventname" id="events_emitter_removealllisteners_eventname">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.26</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
-<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>Removes all listeners, or those of the specified <code>eventName</code>.</p>
-<p>It is bad practice to remove listeners added elsewhere in the code,
-particularly when the <code>EventEmitter</code> instance was created by some other
-component or module (e.g. sockets or file streams).</p>
-<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.removeListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_removelistener_eventname_listener" id="events_emitter_removelistener_eventname_listener">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.26</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
-<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>Removes the specified <code>listener</code> from the listener array for the event named
-<code>eventName</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> callback = <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'someone connected!'</span>);
-};
-server.on(<span class="hljs-string">'connection'</span>, callback);
-<span class="hljs-comment">// ...</span>
-server.removeListener(<span class="hljs-string">'connection'</span>, callback);</code></pre>
-<p><code>removeListener()</code> will remove, at most, one instance of a listener from the
-listener array. If any single listener has been added multiple times to the
-listener array for the specified <code>eventName</code>, then <code>removeListener()</code> must be
-called multiple times to remove each instance.</p>
-<p>Once an event has been emitted, all listeners attached to it at the
-time of emitting will be called in order. This implies that any
-<code>removeListener()</code> or <code>removeAllListeners()</code> calls <em>after</em> emitting and
-<em>before</em> the last listener finishes execution will not remove them from
-<code>emit()</code> in progress. Subsequent events will behave as expected.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-
-<span class="hljs-keyword">const</span> callbackA = <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'A'</span>);
-  myEmitter.removeListener(<span class="hljs-string">'event'</span>, callbackB);
-};
-
-<span class="hljs-keyword">const</span> callbackB = <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'B'</span>);
-};
-
-myEmitter.on(<span class="hljs-string">'event'</span>, callbackA);
-
-myEmitter.on(<span class="hljs-string">'event'</span>, callbackB);
-
-<span class="hljs-comment">// callbackA removes listener callbackB but it will still be called.</span>
-<span class="hljs-comment">// Internal listener array at time of emit [callbackA, callbackB]</span>
-myEmitter.emit(<span class="hljs-string">'event'</span>);
-<span class="hljs-comment">// Prints:</span>
-<span class="hljs-comment">//   A</span>
-<span class="hljs-comment">//   B</span>
-
-<span class="hljs-comment">// callbackB is now removed.</span>
-<span class="hljs-comment">// Internal listener array [callbackA]</span>
-myEmitter.emit(<span class="hljs-string">'event'</span>);
-<span class="hljs-comment">// Prints:</span>
-<span class="hljs-comment">//   A</span></code></pre>
-<p>Because listeners are managed using an internal array, calling this will
-change the position indices of any listener registered <em>after</em> the listener
-being removed. This will not impact the order in which listeners are called,
-but it means that any copies of the listener array as returned by
-the <code>emitter.listeners()</code> method will need to be recreated.</p>
-<p>When a single function has been added as a handler multiple times for a single
-event (as in the example below), <code>removeListener()</code> will remove the most
-recently added instance. In the example the <code>once('ping')</code>
-listener is removed:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
-
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">pong</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'pong'</span>);
-}
-
-ee.on(<span class="hljs-string">'ping'</span>, pong);
-ee.once(<span class="hljs-string">'ping'</span>, pong);
-ee.removeListener(<span class="hljs-string">'ping'</span>, pong);
-
-ee.emit(<span class="hljs-string">'ping'</span>);
-ee.emit(<span class="hljs-string">'ping'</span>);</code></pre>
-<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.setMaxListeners(n)</code><span><a class="mark" href="#events_emitter_setmaxlisteners_n" id="events_emitter_setmaxlisteners_n">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.3.5</span>
-</div>
-<ul>
-<li><code>n</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>By default <code>EventEmitter</code>s will print a warning if more than <code>10</code> listeners are
-added for a particular event. This is a useful default that helps finding
-memory leaks. The <code>emitter.setMaxListeners()</code> method allows the limit to be
-modified for this specific <code>EventEmitter</code> instance. The value can be set to
-<code>Infinity</code> (or <code>0</code>) to indicate an unlimited number of listeners.</p>
-<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.rawListeners(eventName)</code><span><a class="mark" href="#events_emitter_rawlisteners_eventname" id="events_emitter_rawlisteners_eventname">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v9.4.0</span>
-</div>
-<ul>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
-</ul>
-<p>Returns a copy of the array of listeners for the event named <code>eventName</code>,
-including any wrappers (such as those created by <code>.once()</code>).</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> emitter = <span class="hljs-keyword">new</span> EventEmitter();
-emitter.once(<span class="hljs-string">'log'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'log once'</span>));
-
-<span class="hljs-comment">// Returns a new Array with a function `onceWrapper` which has a property</span>
-<span class="hljs-comment">// `listener` which contains the original listener bound above</span>
-<span class="hljs-keyword">const</span> listeners = emitter.rawListeners(<span class="hljs-string">'log'</span>);
-<span class="hljs-keyword">const</span> logFnWrapper = listeners[<span class="hljs-number">0</span>];
-
-<span class="hljs-comment">// Logs "log once" to the console and does not unbind the `once` event</span>
-logFnWrapper.listener();
-
-<span class="hljs-comment">// Logs "log once" to the console and removes the listener</span>
-logFnWrapper();
-
-emitter.on(<span class="hljs-string">'log'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'log persistently'</span>));
-<span class="hljs-comment">// Will return a new Array with a single function bound by `.on()` above</span>
-<span class="hljs-keyword">const</span> newListeners = emitter.rawListeners(<span class="hljs-string">'log'</span>);
-
-<span class="hljs-comment">// Logs "log persistently" twice</span>
-newListeners[<span class="hljs-number">0</span>]();
-emitter.emit(<span class="hljs-string">'log'</span>);</code></pre>
-<h3><code>emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])</code><span><a class="mark" href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args" id="events_emitter_symbol_for_nodejs_rejection_err_eventname_args">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.16.0</span>
-</div>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
-<ul>
-<li><code>err</code> Error</li>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
-<li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
-</ul>
-<p>The <code>Symbol.for('nodejs.rejection')</code> method is called in case a
-promise rejection happens when emitting an event and
-<a href="#events_capture_rejections_of_promises"><code>captureRejections</code></a> is enabled on the emitter.
-It is possible to use <a href="#events_events_capturerejectionsymbol"><code>events.captureRejectionSymbol</code></a> in
-place of <code>Symbol.for('nodejs.rejection')</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { EventEmitter, captureRejectionSymbol } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyClass</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">EventEmitter</span> </span>{
-  <span class="hljs-keyword">constructor</span>() {
-    <span class="hljs-built_in">super</span>({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
-  }
-
-  [captureRejectionSymbol](err, event, ...args) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'rejection happened for'</span>, event, <span class="hljs-string">'with'</span>, err, ...args);
-    <span class="hljs-built_in">this</span>.destroy(err);
-  }
-
-  destroy(err) {
-    <span class="hljs-comment">// Tear the resource down here.</span>
-  }
-}</code></pre>
-<h2><code>events.once(emitter, name)</code><span><a class="mark" href="#events_events_once_emitter_name" id="events_events_once_emitter_name">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v11.13.0</span>
-</div>
-<ul>
 <li><code>emitter</code> <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Can be used to cancel waiting for the event.</li>
+</ul>
+</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
 <p>Creates a <code>Promise</code> that is fulfilled when the <code>EventEmitter</code> emits the given
@@ -29064,130 +30493,174 @@ given event.</p>
 <p>This method is intentionally generic and works with the web platform
 <a href="https://dom.spec.whatwg.org/#interface-eventtarget">EventTarget</a> interface, which has no special
 <code>'error'</code> event semantics and does not listen to the <code>'error'</code> event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { once, EventEmitter } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { once, <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">run</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">run</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-  process.nextTick(<span class="hljs-function">() =></span> {
-    ee.emit(<span class="hljs-string">'myevent'</span>, <span class="hljs-number">42</span>);
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'myevent'</span>, <span class="hljs-number">42</span>);
   });
 
-  <span class="hljs-keyword">const</span> [value] = <span class="hljs-keyword">await</span> once(ee, <span class="hljs-string">'myevent'</span>);
-  <span class="hljs-built_in">console</span>.log(value);
+  <span class="hljs-keyword">const</span> [value] = <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(ee, <span class="hljs-string">'myevent'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value);
 
-  <span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
-  process.nextTick(<span class="hljs-function">() =></span> {
-    ee.emit(<span class="hljs-string">'error'</span>, err);
+  <span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, err);
   });
 
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">await</span> once(ee, <span class="hljs-string">'myevent'</span>);
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(ee, <span class="hljs-string">'myevent'</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'error happened'</span>, err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'error happened'</span>, err);
   }
 }
 
-run();</code></pre>
+<span class="hljs-title function_">run</span>();</code></pre>
 <p>The special handling of the <code>'error'</code> event is only used when <code>events.once()</code>
 is used to wait for another event. If <code>events.once()</code> is used to wait for the
 '<code>error'</code> event itself, then it is treated as any other kind of event without
 special handling:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { EventEmitter, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-once(ee, <span class="hljs-string">'error'</span>)
-  .then(<span class="hljs-function">(<span class="hljs-params">[err]</span>) =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'ok'</span>, err.message))
-  .catch(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'error'</span>, err.message));
+<span class="hljs-title function_">once</span>(ee, <span class="hljs-string">'error'</span>)
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">[err]</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'ok'</span>, err.<span class="hljs-property">message</span>))
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'error'</span>, err.<span class="hljs-property">message</span>));
 
-ee.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'boom'</span>));
+ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'boom'</span>));
 
 <span class="hljs-comment">// Prints: ok boom</span></code></pre>
-<h3>Awaiting multiple events emitted on <code>process.nextTick()</code><span><a class="mark" href="#events_awaiting_multiple_events_emitted_on_process_nexttick" id="events_awaiting_multiple_events_emitted_on_process_nexttick">#</a></span></h3>
+<p>An <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> can be used to cancel waiting for the event:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+
+<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params">emitter, event, signal</span>) {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(emitter, event, { signal });
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'event emitted!'</span>);
+  } <span class="hljs-keyword">catch</span> (error) {
+    <span class="hljs-keyword">if</span> (error.<span class="hljs-property">name</span> === <span class="hljs-string">'AbortError'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Waiting for the event was canceled!'</span>);
+    } <span class="hljs-keyword">else</span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'There was an error'</span>, error.<span class="hljs-property">message</span>);
+    }
+  }
+}
+
+<span class="hljs-title function_">foo</span>(ee, <span class="hljs-string">'foo'</span>, ac.<span class="hljs-property">signal</span>);
+ac.<span class="hljs-title function_">abort</span>(); <span class="hljs-comment">// Abort waiting for the event</span>
+ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>); <span class="hljs-comment">// Prints: Waiting for the event was canceled!</span></code></pre>
+<h4>Awaiting multiple events emitted on <code>process.nextTick()</code><span><a class="mark" href="#events_awaiting_multiple_events_emitted_on_process_nexttick" id="events_awaiting_multiple_events_emitted_on_process_nexttick">#</a></span></h4>
 <p>There is an edge case worth noting when using the <code>events.once()</code> function
 to await multiple events emitted on in the same batch of <code>process.nextTick()</code>
 operations, or whenever multiple events are emitted synchronously. Specifically,
 because the <code>process.nextTick()</code> queue is drained before the <code>Promise</code> microtask
 queue, and because <code>EventEmitter</code> emits all events synchronously, it is possible
 for <code>events.once()</code> to miss an event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { EventEmitter, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> once(myEE, <span class="hljs-string">'bar'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'bar'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(myEE, <span class="hljs-string">'bar'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'bar'</span>);
 
   <span class="hljs-comment">// This Promise will never resolve because the 'foo' event will</span>
   <span class="hljs-comment">// have already been emitted before the Promise is created.</span>
-  <span class="hljs-keyword">await</span> once(myEE, <span class="hljs-string">'foo'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'foo'</span>);
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(myEE, <span class="hljs-string">'foo'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo'</span>);
 }
 
-process.nextTick(<span class="hljs-function">() =></span> {
-  myEE.emit(<span class="hljs-string">'bar'</span>);
-  myEE.emit(<span class="hljs-string">'foo'</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+  myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'bar'</span>);
+  myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>);
 });
 
-foo().then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'done'</span>));</code></pre>
+<span class="hljs-title function_">foo</span>().<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'done'</span>));</code></pre>
 <p>To catch both events, create each of the Promises <em>before</em> awaiting either
 of them, then it becomes possible to use <code>Promise.all()</code>, <code>Promise.race()</code>,
 or <code>Promise.allSettled()</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { EventEmitter, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> <span class="hljs-built_in">Promise</span>.all([once(myEE, <span class="hljs-string">'bar'</span>), once(myEE, <span class="hljs-string">'foo'</span>)]);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">all</span>([<span class="hljs-title function_">once</span>(myEE, <span class="hljs-string">'bar'</span>), <span class="hljs-title function_">once</span>(myEE, <span class="hljs-string">'foo'</span>)]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
 }
 
-process.nextTick(<span class="hljs-function">() =></span> {
-  myEE.emit(<span class="hljs-string">'bar'</span>);
-  myEE.emit(<span class="hljs-string">'foo'</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+  myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'bar'</span>);
+  myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>);
 });
 
-foo().then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'done'</span>));</code></pre>
-<h2><code>events.captureRejections</code><span><a class="mark" href="#events_events_capturerejections" id="events_events_capturerejections">#</a></span></h2>
+<span class="hljs-title function_">foo</span>().<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'done'</span>));</code></pre>
+</section><section><h3><code>events.captureRejections</code><span><a class="mark" href="#events_events_capturerejections" id="events_events_capturerejections">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
 <p>Value: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></p>
 <p>Change the default <code>captureRejections</code> option on all new <code>EventEmitter</code> objects.</p>
-<h2>events.captureRejectionSymbol<span><a class="mark" href="#events_events_capturerejectionsymbol" id="events_events_capturerejectionsymbol">#</a></span></h2>
+</section><section><h3><code>events.captureRejectionSymbol</code><span><a class="mark" href="#events_events_capturerejectionsymbol" id="events_events_capturerejectionsymbol">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
 <p>Value: <code>Symbol.for('nodejs.rejection')</code></p>
 <p>See how to write a custom <a href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args">rejection handler</a>.</p>
-<h2>events.on(emitter, eventName)<a class="srclink" href="https://github.com/nodejs/node/blob/360a294f1f19cb8ccc9505d44a2e9efff414a5c7/lib/events.js#L674">[src]</a><span><a class="mark" href="#events_events_on_emitter_eventname" id="events_events_on_emitter_eventname">#</a></span></h2>
+</section><section><h3><code>events.listenerCount(emitter, eventName)</code><span><a class="mark" href="#events_events_listenercount_emitter_eventname" id="events_events_listenercount_emitter_eventname">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v0.9.12</span><span>Deprecated since: v3.2.0</span>
+</div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#events_emitter_listenercount_eventname"><code>emitter.listenerCount()</code></a> instead.</div><p></p>
+<ul>
+<li><code>emitter</code> <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> The emitter to query</li>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The event name</li>
+</ul>
+<p>A class method that returns the number of listeners for the given <code>eventName</code>
+registered on the given <code>emitter</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, listenerCount } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {});
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {});
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">listenerCount</span>(myEmitter, <span class="hljs-string">'event'</span>));
+<span class="hljs-comment">// Prints: 2</span></code></pre>
+</section><section><h3><code>events.on(emitter, eventName[, options])</code><span><a class="mark" href="#events_events_on_emitter_eventname_options" id="events_events_on_emitter_eventname_options">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.6.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>emitter</code> <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 <li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event being listened for</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Can be used to cancel awaiting events.</li>
+</ul>
+</li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterator-interface" class="type">&#x3C;AsyncIterator></a> that iterates <code>eventName</code> events emitted by the <code>emitter</code></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { on, EventEmitter } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { on, <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
 (<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
   <span class="hljs-comment">// Emit later on</span>
-  process.nextTick(<span class="hljs-function">() =></span> {
-    ee.emit(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
-    ee.emit(<span class="hljs-string">'foo'</span>, <span class="hljs-number">42</span>);
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-number">42</span>);
   });
 
-  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> event <span class="hljs-keyword">of</span> on(ee, <span class="hljs-string">'foo'</span>)) {
+  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> event <span class="hljs-keyword">of</span> <span class="hljs-title function_">on</span>(ee, <span class="hljs-string">'foo'</span>)) {
     <span class="hljs-comment">// The execution of this inner block is synchronous and it</span>
     <span class="hljs-comment">// processes one event at a time (even with await). Do not use</span>
     <span class="hljs-comment">// if concurrent execution is required.</span>
-    <span class="hljs-built_in">console</span>.log(event); <span class="hljs-comment">// prints ['bar'] [42]</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event); <span class="hljs-comment">// prints ['bar'] [42]</span>
   }
   <span class="hljs-comment">// Unreachable here</span>
 })();</code></pre>
@@ -29195,964 +30668,1750 @@ foo().then(<span class="hljs-function">() =></span> <span class="hljs-built_in">
 if the <code>EventEmitter</code> emits <code>'error'</code>. It removes all listeners when
 exiting the loop. The <code>value</code> returned by each iteration is an array
 composed of the emitted event arguments.</p>
-<h1>File system<span><a class="mark" href="#fs_file_system" id="fs_file_system">#</a></span></h1>
-
-<p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/fs.js">lib/fs.js</a></p>
-<p>The <code>fs</code> module enables interacting with the file system in a
-way modeled on standard POSIX functions.</p>
-<p>To use this module:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);</code></pre>
-<p>All file system operations have synchronous, callback, and promise-based
-forms.</p>
-<h2>Synchronous example<span><a class="mark" href="#fs_synchronous_example" id="fs_synchronous_example">#</a></span></h2>
-<p>The synchronous form blocks the Node.js event loop and further JavaScript
-execution until the operation is complete. Exceptions are thrown immediately
-and can be handled using <code>try…catch</code>, or can be allowed to bubble up.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-
-<span class="hljs-keyword">try</span> {
-  fs.unlinkSync(<span class="hljs-string">'/tmp/hello'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
-} <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-comment">// handle the error</span>
-}</code></pre>
-<h2>Callback example<span><a class="mark" href="#fs_callback_example" id="fs_callback_example">#</a></span></h2>
-<p>The callback form takes a completion callback function as its last
-argument and invokes the operation asynchronously. The arguments passed to
-the completion callback depend on the method, but the first argument is always
-reserved for an exception. If the operation is completed successfully, then
-the first argument is <code>null</code> or <code>undefined</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<p>An <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> can be used to cancel waiting on events:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { on, <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
 
-fs.unlink(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
-});</code></pre>
-<h2>Promise example<span><a class="mark" href="#fs_promise_example" id="fs_promise_example">#</a></span></h2>
-<p>Promise-based operations return a <code>Promise</code> that is resolved when the
-asynchronous operation is complete.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).promises;
+(<span class="hljs-keyword">async</span> () => {
+  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">path</span>) </span>{
-  <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">await</span> fs.unlink(path);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`successfully deleted <span class="hljs-subst">${path}</span>`</span>);
-  } <span class="hljs-keyword">catch</span> (error) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'there was an error:'</span>, error.message);
-  }
-})(<span class="hljs-string">'/tmp/hello'</span>);</code></pre>
-<h2>Ordering of callback and promise-based operations<span><a class="mark" href="#fs_ordering_of_callback_and_promise_based_operations" id="fs_ordering_of_callback_and_promise_based_operations">#</a></span></h2>
-<p>There is no guaranteed ordering when using either the callback or
-promise-based methods. For example, the following is prone to error
-because the <code>fs.stat()</code> operation might complete before the <code>fs.rename()</code>
-operation:</p>
-<pre><code class="language-js">fs.rename(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'renamed complete'</span>);
-});
-fs.stat(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
-});</code></pre>
-<p>To correctly order the operations, move the <code>fs.stat()</code> call into the callback
-of the <code>fs.rename()</code> operation:</p>
-<pre><code class="language-js">fs.rename(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.stat(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+  <span class="hljs-comment">// Emit later on</span>
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-number">42</span>);
   });
-});</code></pre>
-<p>Or, use the promise-based API:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).promises;
 
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">from, to</span>) </span>{
-  <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">await</span> fs.rename(<span class="hljs-keyword">from</span>, to);
-    <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> fs.stat(to);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
-  } <span class="hljs-keyword">catch</span> (error) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'there was an error:'</span>, error.message);
+  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> event <span class="hljs-keyword">of</span> <span class="hljs-title function_">on</span>(ee, <span class="hljs-string">'foo'</span>, { <span class="hljs-attr">signal</span>: ac.<span class="hljs-property">signal</span> })) {
+    <span class="hljs-comment">// The execution of this inner block is synchronous and it</span>
+    <span class="hljs-comment">// processes one event at a time (even with await). Do not use</span>
+    <span class="hljs-comment">// if concurrent execution is required.</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event); <span class="hljs-comment">// prints ['bar'] [42]</span>
   }
-})(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>);</code></pre>
-<h2>File paths<span><a class="mark" href="#fs_file_paths" id="fs_file_paths">#</a></span></h2>
-<p>Most <code>fs</code> operations accept filepaths that may be specified in the form of
-a string, a <a href="#buffer_buffer"><code>Buffer</code></a>, or a <a href="#url_the_whatwg_url_api"><code>URL</code></a> object using the <code>file:</code> protocol.</p>
-<p>String form paths are interpreted as UTF-8 character sequences identifying
-the absolute or relative filename. Relative paths will be resolved relative
-to the current working directory as determined by calling <code>process.cwd()</code>.</p>
-<p>Example using an absolute path on POSIX:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+  <span class="hljs-comment">// Unreachable here</span>
+})();
 
-fs.open(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  });
-});</code></pre>
-<p>Example using a relative path on POSIX (relative to <code>process.cwd()</code>):</p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'file.txt'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  });
-});</code></pre>
-<p>Paths specified using a <a href="#buffer_buffer"><code>Buffer</code></a> are useful primarily on certain POSIX
-operating systems that treat file paths as opaque byte sequences. On such
-systems, it is possible for a single file path to contain sub-sequences that
-use multiple character encodings. As with string paths, <code>Buffer</code> paths may
-be relative or absolute:</p>
-<p>Example using an absolute path on POSIX:</p>
-<pre><code class="language-js">fs.open(Buffer.from(<span class="hljs-string">'/open/some/file.txt'</span>), <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  });
-});</code></pre>
-<p>On Windows, Node.js follows the concept of per-drive working directory. This
-behavior can be observed when using a drive path without a backslash. For
-example <code>fs.readdirSync('C:\\')</code> can potentially return a different result than
-<code>fs.readdirSync('C:')</code>. For more information, see
-<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths">this MSDN page</a>.</p>
-<h3>URL object support<span><a class="mark" href="#fs_url_object_support" id="fs_url_object_support">#</a></span></h3>
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> ac.<span class="hljs-title function_">abort</span>());</code></pre>
+</section><section><h3><code>events.setMaxListeners(n[, ...eventTargets])</code><span><a class="mark" href="#events_events_setmaxlisteners_n_eventtargets" id="events_events_setmaxlisteners_n_eventtargets">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v7.6.0</span>
+<span>Added in: v14.17.0</span>
 </div>
-<p>For most <code>fs</code> module functions, the <code>path</code> or <code>filename</code> argument may be passed
-as a WHATWG <a href="#url_the_whatwg_url_api"><code>URL</code></a> object. Only <a href="#url_the_whatwg_url_api"><code>URL</code></a> objects using the <code>file:</code> protocol
-are supported.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fileUrl = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///tmp/hello'</span>);
-
-fs.readFileSync(fileUrl);</code></pre>
-<p><code>file:</code> URLs are always absolute paths.</p>
-<p>Using WHATWG <a href="#url_the_whatwg_url_api"><code>URL</code></a> objects might introduce platform-specific behaviors.</p>
-<p>On Windows, <code>file:</code> URLs with a host name convert to UNC paths, while <code>file:</code>
-URLs with drive letters convert to local absolute paths. <code>file:</code> URLs without a
-host name nor a drive letter will result in a throw:</p>
-<pre><code class="language-js"><span class="hljs-comment">// On Windows :</span>
+<ul>
+<li><code>n</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A non-negative number. The maximum number of listeners per
+<code>EventTarget</code> event.</li>
+<li><code>...eventsTargets</code> <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget[]></a> | <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter[]></a> Zero or more <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a>
+or <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> instances. If none are specified, <code>n</code> is set as the default
+max for all newly created <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> and <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> objects.</li>
+</ul>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  setMaxListeners,
+  <span class="hljs-title class_">EventEmitter</span>
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-comment">// - WHATWG file URLs with hostname convert to UNC path</span>
-<span class="hljs-comment">// file://hostname/p/a/t/h/file => \\hostname\p\a\t\h\file</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file://hostname/p/a/t/h/file'</span>));
+<span class="hljs-keyword">const</span> target = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventTarget</span>();
+<span class="hljs-keyword">const</span> emitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-<span class="hljs-comment">// - WHATWG file URLs with drive letters convert to absolute path</span>
-<span class="hljs-comment">// file:///C:/tmp/hello => C:\tmp\hello</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/tmp/hello'</span>));
+<span class="hljs-title function_">setMaxListeners</span>(<span class="hljs-number">5</span>, target, emitter);</code></pre>
+<p><a id="event-target-and-event-api"></a></p>
+</section><section><h3><code>EventTarget</code> and <code>Event</code> API<span><a class="mark" href="#events_eventtarget_and_event_api" id="events_eventtarget_and_event_api">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>The <code>EventTarget</code> and <code>Event</code> objects are a Node.js-specific implementation
+of the <a href="https://dom.spec.whatwg.org/#eventtarget"><code>EventTarget</code> Web API</a> that are exposed by some Node.js core APIs.
+Neither the <code>EventTarget</code> nor <code>Event</code> classes are available for end
+user code to create.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> target = <span class="hljs-title function_">getEventTargetSomehow</span>();
+
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">(<span class="hljs-params">event</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo event happened!'</span>);
+});</code></pre>
+<h4>Node.js <code>EventTarget</code> vs. DOM <code>EventTarget</code><span><a class="mark" href="#events_node_js_eventtarget_vs_dom_eventtarget" id="events_node_js_eventtarget_vs_dom_eventtarget">#</a></span></h4>
+<p>There are two key differences between the Node.js <code>EventTarget</code> and the
+<a href="https://dom.spec.whatwg.org/#eventtarget"><code>EventTarget</code> Web API</a>:</p>
+<ol>
+<li>Whereas DOM <code>EventTarget</code> instances <em>may</em> be hierarchical, there is no
+concept of hierarchy and event propagation in Node.js. That is, an event
+dispatched to an <code>EventTarget</code> does not propagate through a hierarchy of
+nested target objects that may each have their own set of handlers for the
+event.</li>
+<li>In the Node.js <code>EventTarget</code>, if an event listener is an async function
+or returns a <code>Promise</code>, and the returned <code>Promise</code> rejects, the rejection
+is automatically captured and handled the same way as a listener that
+throws synchronously (see <a href="#events_eventtarget_error_handling"><code>EventTarget</code> error handling</a> for details).</li>
+</ol>
+<h4><code>NodeEventTarget</code> vs. <code>EventEmitter</code><span><a class="mark" href="#events_nodeeventtarget_vs_eventemitter" id="events_nodeeventtarget_vs_eventemitter">#</a></span></h4>
+<p>The <code>NodeEventTarget</code> object implements a modified subset of the
+<code>EventEmitter</code> API that allows it to closely <em>emulate</em> an <code>EventEmitter</code> in
+certain situations. A <code>NodeEventTarget</code> is <em>not</em> an instance of <code>EventEmitter</code>
+and cannot be used in place of an <code>EventEmitter</code> in most cases.</p>
+<ol>
+<li>Unlike <code>EventEmitter</code>, any given <code>listener</code> can be registered at most once
+per event <code>type</code>. Attempts to register a <code>listener</code> multiple times are
+ignored.</li>
+<li>The <code>NodeEventTarget</code> does not emulate the full <code>EventEmitter</code> API.
+Specifically the <code>prependListener()</code>, <code>prependOnceListener()</code>,
+<code>rawListeners()</code>, <code>setMaxListeners()</code>, <code>getMaxListeners()</code>, and
+<code>errorMonitor</code> APIs are not emulated. The <code>'newListener'</code> and
+<code>'removeListener'</code> events will also not be emitted.</li>
+<li>The <code>NodeEventTarget</code> does not implement any special default behavior
+for events with type <code>'error'</code>.</li>
+<li>The <code>NodeEventTarget</code> supports <code>EventListener</code> objects as well as
+functions as handlers for all event types.</li>
+</ol>
+<h4>Event listener<span><a class="mark" href="#events_event_listener" id="events_event_listener">#</a></span></h4>
+<p>Event listeners registered for an event <code>type</code> may either be JavaScript
+functions or objects with a <code>handleEvent</code> property whose value is a function.</p>
+<p>In either case, the handler function is invoked with the <code>event</code> argument
+passed to the <code>eventTarget.dispatchEvent()</code> function.</p>
+<p>Async functions may be used as event listeners. If an async handler function
+rejects, the rejection is captured and handled as described in
+<a href="#events_eventtarget_error_handling"><code>EventTarget</code> error handling</a>.</p>
+<p>An error thrown by one handler function does not prevent the other handlers
+from being invoked.</p>
+<p>The return value of a handler function is ignored.</p>
+<p>Handlers are always invoked in the order they were added.</p>
+<p>Handler functions may mutate the <code>event</code> object.</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">handler1</span>(<span class="hljs-params">event</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'foo'</span>
+  event.<span class="hljs-property">a</span> = <span class="hljs-number">1</span>;
+}
 
-<span class="hljs-comment">// - WHATWG file URLs without hostname must have a drive letters</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///notdriveletter/p/a/t/h/file'</span>));
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///c/p/a/t/h/file'</span>));
-<span class="hljs-comment">// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute</span></code></pre>
-<p><code>file:</code> URLs with drive letters must use <code>:</code> as a separator just after
-the drive letter. Using another separator will result in a throw.</p>
-<p>On all other platforms, <code>file:</code> URLs with a host name are unsupported and will
-result in a throw:</p>
-<pre><code class="language-js"><span class="hljs-comment">// On other platforms:</span>
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">handler2</span>(<span class="hljs-params">event</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'foo'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">a</span>);  <span class="hljs-comment">// Prints 1</span>
+}
 
-<span class="hljs-comment">// - WHATWG file URLs with hostname are unsupported</span>
-<span class="hljs-comment">// file://hostname/p/a/t/h/file => throw!</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file://hostname/p/a/t/h/file'</span>));
-<span class="hljs-comment">// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute</span>
+<span class="hljs-keyword">const</span> handler3 = {
+  <span class="hljs-title function_">handleEvent</span>(<span class="hljs-params">event</span>) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'foo'</span>
+  }
+};
 
-<span class="hljs-comment">// - WHATWG file URLs convert to absolute path</span>
-<span class="hljs-comment">// file:///tmp/hello => /tmp/hello</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///tmp/hello'</span>));</code></pre>
-<p>A <code>file:</code> URL having encoded slash characters will result in a throw on all
-platforms:</p>
-<pre><code class="language-js"><span class="hljs-comment">// On Windows</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/p/a/t/h/%2F'</span>));
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/p/a/t/h/%2f'</span>));
-<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-\ or / characters */</span>
+<span class="hljs-keyword">const</span> handler4 = {
+  <span class="hljs-keyword">async</span> <span class="hljs-title function_">handleEvent</span>(<span class="hljs-params">event</span>) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'foo'</span>
+  }
+};
 
-<span class="hljs-comment">// On POSIX</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///p/a/t/h/%2F'</span>));
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///p/a/t/h/%2f'</span>));
-<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-/ characters */</span></code></pre>
-<p>On Windows, <code>file:</code> URLs having encoded backslash will result in a throw:</p>
-<pre><code class="language-js"><span class="hljs-comment">// On Windows</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/path/%5C'</span>));
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/path/%5c'</span>));
-<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-\ or / characters */</span></code></pre>
-<h2>File descriptors<span><a class="mark" href="#fs_file_descriptors" id="fs_file_descriptors">#</a></span></h2>
-<p>On POSIX systems, for every process, the kernel maintains a table of currently
-open files and resources. Each open file is assigned a simple numeric
-identifier called a <em>file descriptor</em>. At the system-level, all file system
-operations use these file descriptors to identify and track each specific
-file. Windows systems use a different but conceptually similar mechanism for
-tracking resources. To simplify things for users, Node.js abstracts away the
-specific differences between operating systems and assigns all open files a
-numeric file descriptor.</p>
-<p>The <code>fs.open()</code> method is used to allocate a new file descriptor. Once
-allocated, the file descriptor may be used to read data from, write data to,
-or request information about the file.</p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.fstat(fd, <span class="hljs-function">(<span class="hljs-params">err, stat</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    <span class="hljs-comment">// use stat</span>
+<span class="hljs-keyword">const</span> target = <span class="hljs-title function_">getEventTargetSomehow</span>();
 
-    <span class="hljs-comment">// always close the file descriptor!</span>
-    fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    });
-  });
-});</code></pre>
-<p>Most operating systems limit the number of file descriptors that may be open
-at any given time so it is critical to close the descriptor when operations
-are completed. Failure to do so will result in a memory leak that will
-eventually cause an application to crash.</p>
-<h2>Threadpool usage<span><a class="mark" href="#fs_threadpool_usage" id="fs_threadpool_usage">#</a></span></h2>
-<p>All file system APIs except <code>fs.FSWatcher()</code> and those that are explicitly
-synchronous use libuv's threadpool, which can have surprising and negative
-performance implications for some applications. See the
-<a href="#cli_uv_threadpool_size_size"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>
-<h2>Class: <code>fs.Dir</code><span><a class="mark" href="#fs_class_fs_dir" id="fs_class_fs_dir">#</a></span></h2>
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler1);
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler2);
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler3);
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler4, { <span class="hljs-attr">once</span>: <span class="hljs-literal">true</span> });</code></pre>
+<h4><code>EventTarget</code> error handling<span><a class="mark" href="#events_eventtarget_error_handling" id="events_eventtarget_error_handling">#</a></span></h4>
+<p>When a registered event listener throws (or returns a Promise that rejects),
+by default the error is treated as an uncaught exception on
+<code>process.nextTick()</code>. This means uncaught exceptions in <code>EventTarget</code>s will
+terminate the Node.js process by default.</p>
+<p>Throwing within an event listener will <em>not</em> stop the other registered handlers
+from being invoked.</p>
+<p>The <code>EventTarget</code> does not implement any special default handling for <code>'error'</code>
+type events like <code>EventEmitter</code>.</p>
+<p>Currently errors are first forwarded to the <code>process.on('error')</code> event
+before reaching <code>process.on('uncaughtException')</code>. This behavior is
+deprecated and will change in a future release to align <code>EventTarget</code> with
+other Node.js APIs. Any code relying on the <code>process.on('error')</code> event should
+be aligned with the new behavior.</p>
+<h4>Class: <code>Event</code><span><a class="mark" href="#events_class_event" id="events_class_event">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
 </div>
-<p>A class representing a directory stream.</p>
-<p>Created by <a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir()</code></a>, <a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync()</code></a>, or
-<a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">print</span>(<span class="hljs-params">path</span>) </span>{
-  <span class="hljs-keyword">const</span> dir = <span class="hljs-keyword">await</span> fs.promises.opendir(path);
-  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> dirent <span class="hljs-keyword">of</span> dir) {
-    <span class="hljs-built_in">console</span>.log(dirent.name);
-  }
-}
-print(<span class="hljs-string">'./'</span>).catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<h3><code>dir.close()</code><span><a class="mark" href="#fs_dir_close" id="fs_dir_close">#</a></span></h3>
+<p>The <code>Event</code> object is an adaptation of the <a href="https://dom.spec.whatwg.org/#event"><code>Event</code> Web API</a>. Instances
+are created internally by Node.js.</p>
+<h5><code>event.bubbles</code><span><a class="mark" href="#events_event_bubbles" id="events_event_bubbles">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Always returns <code>false</code>.</li>
 </ul>
-<p>Asynchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.</p>
-<p>A <code>Promise</code> is returned that will be resolved after the resource has been
-closed.</p>
-<h3><code>dir.close(callback)</code><span><a class="mark" href="#fs_dir_close_callback" id="fs_dir_close_callback">#</a></span></h3>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.cancelBubble()</code><span><a class="mark" href="#events_event_cancelbubble" id="events_event_cancelbubble">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
+</div>
+<p>Alias for <code>event.stopPropagation()</code>. This is not used in Node.js and is
+provided purely for completeness.</p>
+<h5><code>event.cancelable</code><span><a class="mark" href="#events_event_cancelable" id="events_event_cancelable">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> True if the event was created with the <code>cancelable</code> option.</li>
 </ul>
-</li>
+<h5><code>event.composed</code><span><a class="mark" href="#events_event_composed" id="events_event_composed">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Always returns <code>false</code>.</li>
 </ul>
-<p>Asynchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.</p>
-<p>The <code>callback</code> will be called after the resource handle has been closed.</p>
-<h3><code>dir.closeSync()</code><span><a class="mark" href="#fs_dir_closesync" id="fs_dir_closesync">#</a></span></h3>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.composedPath()</code><span><a class="mark" href="#events_event_composedpath" id="events_event_composedpath">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
 </div>
-<p>Synchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.</p>
-<h3><code>dir.path</code><span><a class="mark" href="#fs_dir_path" id="fs_dir_path">#</a></span></h3>
+<p>Returns an array containing the current <code>EventTarget</code> as the only entry or
+empty if the event is not being dispatched. This is not used in
+Node.js and is provided purely for completeness.</p>
+<h5><code>event.currentTarget</code><span><a class="mark" href="#events_event_currenttarget" id="events_event_currenttarget">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li>Type: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> The <code>EventTarget</code> dispatching the event.</li>
 </ul>
-<p>The read-only path of this directory as was provided to <a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir()</code></a>,
-<a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync()</code></a>, or <a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir()</code></a>.</p>
-<h3><code>dir.read()</code><span><a class="mark" href="#fs_dir_read" id="fs_dir_read">#</a></span></h3>
+<p>Alias for <code>event.target</code>.</p>
+<h5><code>event.defaultPrevented</code><span><a class="mark" href="#events_event_defaultprevented" id="events_event_defaultprevented">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> containing <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>.</p>
-<p>After the read is completed, a <code>Promise</code> is returned that will be resolved with
-an <a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>, or <code>null</code> if there are no more directory entries to read.</p>
-<p>Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.</p>
-<h3><code>dir.read(callback)</code><span><a class="mark" href="#fs_dir_read_callback" id="fs_dir_read_callback">#</a></span></h3>
+<p>Is <code>true</code> if <code>cancelable</code> is <code>true</code> and <code>event.preventDefault()</code> has been
+called.</p>
+<h5><code>event.eventPhase</code><span><a class="mark" href="#events_event_eventphase" id="events_event_eventphase">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>dirent</code> <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Returns <code>0</code> while an event is not being dispatched, <code>2</code> while
+it is being dispatched.</li>
 </ul>
-</li>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.isTrusted</code><span><a class="mark" href="#events_event_istrusted" id="events_event_istrusted">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>.</p>
-<p>After the read is completed, the <code>callback</code> will be called with an
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>, or <code>null</code> if there are no more directory entries to read.</p>
-<p>Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.</p>
-<h3><code>dir.readSync()</code><span><a class="mark" href="#fs_dir_readsync" id="fs_dir_readsync">#</a></span></h3>
+<p>The <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> <code>"abort"</code> event is emitted with <code>isTrusted</code> set to <code>true</code>. The
+value is <code>false</code> in all other cases.</p>
+<h5><code>event.preventDefault()</code><span><a class="mark" href="#events_event_preventdefault" id="events_event_preventdefault">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
+</div>
+<p>Sets the <code>defaultPrevented</code> property to <code>true</code> if <code>cancelable</code> is <code>true</code>.</p>
+<h5><code>event.returnValue</code><span><a class="mark" href="#events_event_returnvalue" id="events_event_returnvalue">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> True if the event has not been canceled.</li>
 </ul>
-<p>Synchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>.</p>
-<p>If there are no more directory entries to read, <code>null</code> will be returned.</p>
-<p>Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.</p>
-<h3><code>dir[Symbol.asyncIterator]()</code><span><a class="mark" href="#fs_dir_symbol_asynciterator" id="fs_dir_symbol_asynciterator">#</a></span></h3>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.srcElement</code><span><a class="mark" href="#events_event_srcelement" id="events_event_srcelement">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterator-interface" class="type">&#x3C;AsyncIterator></a> of <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a></li>
+<li>Type: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> The <code>EventTarget</code> dispatching the event.</li>
 </ul>
-<p>Asynchronously iterates over the directory via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> until all entries have
-been read.</p>
-<p>Entries returned by the async iterator are always an <a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>.
-The <code>null</code> case from <code>dir.read()</code> is handled internally.</p>
-<p>See <a href="#fs_class_fs_dir"><code>fs.Dir</code></a> for an example.</p>
-<p>Directory entries returned by this iterator are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.</p>
-<h2>Class: <code>fs.Dirent</code><span><a class="mark" href="#fs_class_fs_dirent" id="fs_class_fs_dirent">#</a></span></h2>
+<p>Alias for <code>event.target</code>.</p>
+<h5><code>event.stopImmediatePropagation()</code><span><a class="mark" href="#events_event_stopimmediatepropagation" id="events_event_stopimmediatepropagation">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v14.5.0</span>
 </div>
-<p>A representation of a directory entry, which can be a file or a subdirectory
-within the directory, as returned by reading from an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a>. The
-directory entry is a combination of the file name and file type pairs.</p>
-<p>Additionally, when <a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir()</code></a> or <a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync()</code></a> is called with
-the <code>withFileTypes</code> option set to <code>true</code>, the resulting array is filled with
-<code>fs.Dirent</code> objects, rather than strings or <code>Buffers</code>.</p>
-<h3><code>dirent.isBlockDevice()</code><span><a class="mark" href="#fs_dirent_isblockdevice" id="fs_dirent_isblockdevice">#</a></span></h3>
+<p>Stops the invocation of event listeners after the current one completes.</p>
+<h5><code>event.stopPropagation()</code><span><a class="mark" href="#events_event_stoppropagation" id="events_event_stoppropagation">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v14.5.0</span>
+</div>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.target</code><span><a class="mark" href="#events_event_target" id="events_event_target">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li>Type: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> The <code>EventTarget</code> dispatching the event.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a block device.</p>
-<h3><code>dirent.isCharacterDevice()</code><span><a class="mark" href="#fs_dirent_ischaracterdevice" id="fs_dirent_ischaracterdevice">#</a></span></h3>
+<h5><code>event.timeStamp</code><span><a class="mark" href="#events_event_timestamp" id="events_event_timestamp">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a character device.</p>
-<h3><code>dirent.isDirectory()</code><span><a class="mark" href="#fs_dirent_isdirectory" id="fs_dirent_isdirectory">#</a></span></h3>
+<p>The millisecond timestamp when the <code>Event</code> object was created.</p>
+<h5><code>event.type</code><span><a class="mark" href="#events_event_type" id="events_event_type">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a file system
-directory.</p>
-<h3><code>dirent.isFIFO()</code><span><a class="mark" href="#fs_dirent_isfifo" id="fs_dirent_isfifo">#</a></span></h3>
+<p>The event type identifier.</p>
+<h4>Class: <code>EventTarget</code><span><a class="mark" href="#events_class_eventtarget" id="events_class_eventtarget">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v14.5.0</span>
 </div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a first-in-first-out
-(FIFO) pipe.</p>
-<h3><code>dirent.isFile()</code><span><a class="mark" href="#fs_dirent_isfile" id="fs_dirent_isfile">#</a></span></h3>
+<h5><code>eventTarget.addEventListener(type, listener[, options])</code><span><a class="mark" href="#events_eventtarget_addeventlistener_type_listener_options" id="events_eventtarget_addeventlistener_type_listener_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a regular file.</p>
-<h3><code>dirent.isSocket()</code><span><a class="mark" href="#fs_dirent_issocket" id="fs_dirent_issocket">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.10.0</span>
-</div>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="#events_event_listener" class="type">&#x3C;EventListener></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>once</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, the listener is automatically removed
+when it is first invoked. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>passive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, serves as a hint that the listener will
+not call the <code>Event</code> object's <code>preventDefault()</code> method.
+<strong>Default:</strong> <code>false</code>.</li>
+<li><code>capture</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Not directly used by Node.js. Added for API
+completeness. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a socket.</p>
-<h3><code>dirent.isSymbolicLink()</code><span><a class="mark" href="#fs_dirent_issymboliclink" id="fs_dirent_issymboliclink">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.10.0</span>
-</div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a symbolic link.</p>
-<h3><code>dirent.name</code><span><a class="mark" href="#fs_dirent_name" id="fs_dirent_name">#</a></span></h3>
+<p>Adds a new handler for the <code>type</code> event. Any given <code>listener</code> is added
+only once per <code>type</code> and per <code>capture</code> option value.</p>
+<p>If the <code>once</code> option is <code>true</code>, the <code>listener</code> is removed after the
+next time a <code>type</code> event is dispatched.</p>
+<p>The <code>capture</code> option is not used by Node.js in any functional way other than
+tracking registered event listeners per the <code>EventTarget</code> specification.
+Specifically, the <code>capture</code> option is used as part of the key when registering
+a <code>listener</code>. Any individual <code>listener</code> may be added once with
+<code>capture = false</code>, and once with <code>capture = true</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">handler</span>(<span class="hljs-params">event</span>) {}
+
+<span class="hljs-keyword">const</span> target = <span class="hljs-title function_">getEventTargetSomehow</span>();
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler, { <span class="hljs-attr">capture</span>: <span class="hljs-literal">true</span> });  <span class="hljs-comment">// first</span>
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler, { <span class="hljs-attr">capture</span>: <span class="hljs-literal">false</span> }); <span class="hljs-comment">// second</span>
+
+<span class="hljs-comment">// Removes the second instance of handler</span>
+target.<span class="hljs-title function_">removeEventListener</span>(<span class="hljs-string">'foo'</span>, handler);
+
+<span class="hljs-comment">// Removes the first instance of handler</span>
+target.<span class="hljs-title function_">removeEventListener</span>(<span class="hljs-string">'foo'</span>, handler, { <span class="hljs-attr">capture</span>: <span class="hljs-literal">true</span> });</code></pre>
+<h5><code>eventTarget.dispatchEvent(event)</code><span><a class="mark" href="#events_eventtarget_dispatchevent_event" id="events_eventtarget_dispatchevent_event">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>event</code> <a href="#events_class_event" class="type">&#x3C;Event></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if either event’s <code>cancelable</code> attribute value is
+false or its <code>preventDefault()</code> method was not invoked, otherwise <code>false</code>.</li>
 </ul>
-<p>The file name that this <code>fs.Dirent</code> object refers to. The type of this
-value is determined by the <code>options.encoding</code> passed to <a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir()</code></a> or
-<a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync()</code></a>.</p>
-<h2>Class: <code>fs.FSWatcher</code><span><a class="mark" href="#fs_class_fs_fswatcher" id="fs_class_fs_fswatcher">#</a></span></h2>
+<p>Dispatches the <code>event</code> to the list of handlers for <code>event.type</code>.</p>
+<p>The registered event listeners is synchronously invoked in the order they
+were registered.</p>
+<h5><code>eventTarget.removeEventListener(type, listener)</code><span><a class="mark" href="#events_eventtarget_removeeventlistener_type_listener" id="events_eventtarget_removeeventlistener_type_listener">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.5.8</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Extends <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
-</ul>
-<p>A successful call to <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> method will return a new <code>fs.FSWatcher</code>
-object.</p>
-<p>All <code>fs.FSWatcher</code> objects emit a <code>'change'</code> event whenever a specific watched
-file is modified.</p>
-<h3>Event: <code>'change'</code><span><a class="mark" href="#fs_event_change" id="fs_event_change">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.5.8</span>
-</div>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="#events_event_listener" class="type">&#x3C;EventListener></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>eventType</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The type of change event that has occurred</li>
-<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The filename that changed (if relevant/available)</li>
+<li><code>capture</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Emitted when something changes in a watched directory or file.
-See more details in <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a>.</p>
-<p>The <code>filename</code> argument may not be provided depending on operating system
-support. If <code>filename</code> is provided, it will be provided as a <code>Buffer</code> if
-<code>fs.watch()</code> is called with its <code>encoding</code> option set to <code>'buffer'</code>, otherwise
-<code>filename</code> will be a UTF-8 string.</p>
-<pre><code class="language-js"><span class="hljs-comment">// Example when handled through fs.watch() listener</span>
-fs.watch(<span class="hljs-string">'./tmp'</span>, { <span class="hljs-attr">encoding</span>: <span class="hljs-string">'buffer'</span> }, <span class="hljs-function">(<span class="hljs-params">eventType, filename</span>) =></span> {
-  <span class="hljs-keyword">if</span> (filename) {
-    <span class="hljs-built_in">console</span>.log(filename);
-    <span class="hljs-comment">// Prints: &#x3C;Buffer ...></span>
-  }
-});</code></pre>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close" id="fs_event_close">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
-<p>Emitted when the watcher stops watching for changes. The closed
-<code>fs.FSWatcher</code> object is no longer usable in the event handler.</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#fs_event_error" id="fs_event_error">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.5.8</span>
-</div>
-<ul>
-<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+</li>
 </ul>
-<p>Emitted when an error occurs while watching the file. The errored
-<code>fs.FSWatcher</code> object is no longer usable in the event handler.</p>
-<h3><code>watcher.close()</code><span><a class="mark" href="#fs_watcher_close" id="fs_watcher_close">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.5.8</span>
-</div>
-<p>Stop watching for changes on the given <code>fs.FSWatcher</code>. Once stopped, the
-<code>fs.FSWatcher</code> object is no longer usable.</p>
-<h3><code>watcher.ref()</code><span><a class="mark" href="#fs_watcher_ref" id="fs_watcher_ref">#</a></span></h3>
+<p>Removes the <code>listener</code> from the list of handlers for event <code>type</code>.</p>
+<h4>Class: <code>NodeEventTarget</code><span><a class="mark" href="#events_class_nodeeventtarget" id="events_class_nodeeventtarget">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
+<li>Extends: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a></li>
 </ul>
-<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the
-<code>FSWatcher</code> is active. Calling <code>watcher.ref()</code> multiple times will have
-no effect.</p>
-<p>By default, all <code>FSWatcher</code> objects are "ref'ed", making it normally
-unnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been
-called previously.</p>
-<h3><code>watcher.unref()</code><span><a class="mark" href="#fs_watcher_unref" id="fs_watcher_unref">#</a></span></h3>
+<p>The <code>NodeEventTarget</code> is a Node.js-specific extension to <code>EventTarget</code>
+that emulates a subset of the <code>EventEmitter</code> API.</p>
+<h5><code>nodeEventTarget.addListener(type, listener[, options])</code><span><a class="mark" href="#events_nodeeventtarget_addlistener_type_listener_options" id="events_nodeeventtarget_addlistener_type_listener_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
-</ul>
-<p>When called, the active <code>FSWatcher</code> object will not require the Node.js
-event loop to remain active. If there is no other activity keeping the
-event loop running, the process may exit before the <code>FSWatcher</code> object's
-callback is invoked. Calling <code>watcher.unref()</code> multiple times will have
-no effect.</p>
-<h2>Class: <code>fs.StatWatcher</code><span><a class="mark" href="#fs_class_fs_statwatcher" id="fs_class_fs_statwatcher">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.20.0</span>
-</div>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></p>
 <ul>
-<li>Extends <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+<li><code>once</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>A successful call to <code>fs.watchFile()</code> method will return a new <code>fs.StatWatcher</code>
-object.</p>
-<h3><code>watcher.ref()</code><span><a class="mark" href="#fs_watcher_ref_1" id="fs_watcher_ref_1">#</a></span></h3>
+</li>
+<li>
+<p>Returns: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
+</ul>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that emulates the
+equivalent <code>EventEmitter</code> API. The only difference between <code>addListener()</code> and
+<code>addEventListener()</code> is that <code>addListener()</code> will return a reference to the
+<code>EventTarget</code>.</p>
+<h5><code>nodeEventTarget.eventNames()</code><span><a class="mark" href="#events_nodeeventtarget_eventnames" id="events_nodeeventtarget_eventnames">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
-<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the
-<code>StatWatcher</code> is active. Calling <code>watcher.ref()</code> multiple times will have
-no effect.</p>
-<p>By default, all <code>StatWatcher</code> objects are "ref'ed", making it normally
-unnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been
-called previously.</p>
-<h3><code>watcher.unref()</code><span><a class="mark" href="#fs_watcher_unref_1" id="fs_watcher_unref_1">#</a></span></h3>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that returns an array
+of event <code>type</code> names for which event listeners are registered.</p>
+<h5><code>nodeEventTarget.listenerCount(type)</code><span><a class="mark" href="#events_nodeeventtarget_listenercount_type" id="events_nodeeventtarget_listenercount_type">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Returns: <a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></p>
+</li>
 </ul>
-<p>When called, the active <code>StatWatcher</code> object will not require the Node.js
-event loop to remain active. If there is no other activity keeping the
-event loop running, the process may exit before the <code>StatWatcher</code> object's
-callback is invoked. Calling <code>watcher.unref()</code> multiple times will have
-no effect.</p>
-<h2>Class: <code>fs.ReadStream</code><span><a class="mark" href="#fs_class_fs_readstream" id="fs_class_fs_readstream">#</a></span></h2>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that returns the number
+of event listeners registered for the <code>type</code>.</p>
+<h5><code>nodeEventTarget.off(type, listener)</code><span><a class="mark" href="#events_nodeeventtarget_off_type_listener" id="events_nodeeventtarget_off_type_listener">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li>Extends: <a href="#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a></li>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p>Returns: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
 </ul>
-<p>Instances of <code>fs.ReadStream</code> are created and returned using the
-<a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream()</code></a> function.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close_1" id="fs_event_close_1">#</a></span></h3>
+<p>Node.js-specific alias for <code>eventTarget.removeListener()</code>.</p>
+<h5><code>nodeEventTarget.on(type, listener[, options])</code><span><a class="mark" href="#events_nodeeventtarget_on_type_listener_options" id="events_nodeeventtarget_on_type_listener_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
-</div>
-<p>Emitted when the <code>fs.ReadStream</code>'s underlying file descriptor has been closed.</p>
-<h3>Event: <code>'open'</code><span><a class="mark" href="#fs_event_open" id="fs_event_open">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Integer file descriptor used by the <code>ReadStream</code>.</li>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></p>
+<ul>
+<li><code>once</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Emitted when the <code>fs.ReadStream</code>'s file descriptor has been opened.</p>
-<h3>Event: <code>'ready'</code><span><a class="mark" href="#fs_event_ready" id="fs_event_ready">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v9.11.0</span>
-</div>
-<p>Emitted when the <code>fs.ReadStream</code> is ready to be used.</p>
-<p>Fires immediately after <code>'open'</code>.</p>
-<h3><code>readStream.bytesRead</code><span><a class="mark" href="#fs_readstream_bytesread" id="fs_readstream_bytesread">#</a></span></h3>
+</li>
+<li>
+<p>Returns: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
+</ul>
+<p>Node.js-specific alias for <code>eventTarget.addListener()</code>.</p>
+<h5><code>nodeEventTarget.once(type, listener[, options])</code><span><a class="mark" href="#events_nodeeventtarget_once_type_listener_options" id="events_nodeeventtarget_once_type_listener_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v6.4.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></p>
+</li>
+<li>
+<p>Returns: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
 </ul>
-<p>The number of bytes that have been read so far.</p>
-<h3><code>readStream.path</code><span><a class="mark" href="#fs_readstream_path" id="fs_readstream_path">#</a></span></h3>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that adds a <code>once</code>
+listener for the given event <code>type</code>. This is equivalent to calling <code>on</code>
+with the <code>once</code> option set to <code>true</code>.</p>
+<h5><code>nodeEventTarget.removeAllListeners([type])</code><span><a class="mark" href="#events_nodeeventtarget_removealllisteners_type" id="events_nodeeventtarget_removealllisteners_type">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p>Returns: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
 </ul>
-<p>The path to the file the stream is reading from as specified in the first
-argument to <code>fs.createReadStream()</code>. If <code>path</code> is passed as a string, then
-<code>readStream.path</code> will be a string. If <code>path</code> is passed as a <code>Buffer</code>, then
-<code>readStream.path</code> will be a <code>Buffer</code>.</p>
-<h3><code>readStream.pending</code><span><a class="mark" href="#fs_readstream_pending" id="fs_readstream_pending">#</a></span></h3>
+<p>Node.js-specific extension to the <code>EventTarget</code> class. If <code>type</code> is specified,
+removes all registered listeners for <code>type</code>, otherwise removes all registered
+listeners.</p>
+<h5><code>nodeEventTarget.removeListener(type, listener)</code><span><a class="mark" href="#events_nodeeventtarget_removelistener_type_listener" id="events_nodeeventtarget_removelistener_type_listener">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v11.2.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p>Returns: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
 </ul>
-<p>This property is <code>true</code> if the underlying file has not been opened yet,
-i.e. before the <code>'ready'</code> event is emitted.</p>
-<h2>Class: <code>fs.Stats</code><span><a class="mark" href="#fs_class_fs_stats" id="fs_class_fs_stats">#</a></span></h2>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that removes the
+<code>listener</code> for the given <code>type</code>. The only difference between <code>removeListener()</code>
+and <code>removeEventListener()</code> is that <code>removeListener()</code> will return a reference
+to the <code>EventTarget</code>.</p></section>
+        </section>
+<section><h2>File system<span><a class="mark" href="#fs_file_system" id="fs_file_system">#</a></span></h2>
+
+<p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
+
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/fs.js">lib/fs.js</a></p>
+<p>The <code>fs</code> module enables interacting with the file system in a
+way modeled on standard POSIX functions.</p>
+<p>To use the promise-based APIs:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;</code><code class="language-js cjs"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);</code></pre>
+<p>To use the callback and sync APIs:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;</code><code class="language-js cjs"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);</code></pre>
+<p>All file system operations have synchronous, callback, and promise-based
+forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).</p>
+<section><h3>Promise example<span><a class="mark" href="#fs_promise_example" id="fs_promise_example">#</a></span></h3>
+<p>Promise-based operations return a promise that is fulfilled when the
+asynchronous operation is complete.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { unlink } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">unlink</span>(<span class="hljs-string">'/tmp/hello'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+} <span class="hljs-keyword">catch</span> (error) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'there was an error:'</span>, error.<span class="hljs-property">message</span>);
+}</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { unlink } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);
+
+(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">path</span>) {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">unlink</span>(path);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`successfully deleted <span class="hljs-subst">${path}</span>`</span>);
+  } <span class="hljs-keyword">catch</span> (error) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'there was an error:'</span>, error.<span class="hljs-property">message</span>);
+  }
+})(<span class="hljs-string">'/tmp/hello'</span>);</code></pre>
+</section><section><h3>Callback example<span><a class="mark" href="#fs_callback_example" id="fs_callback_example">#</a></span></h3>
+<p>The callback form takes a completion callback function as its last
+argument and invokes the operation asynchronously. The arguments passed to
+the completion callback depend on the method, but the first argument is always
+reserved for an exception. If the operation is completed successfully, then
+the first argument is <code>null</code> or <code>undefined</code>.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { unlink } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">unlink</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+});</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { unlink } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+
+<span class="hljs-title function_">unlink</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+});</code></pre>
+<p>The callback-based versions of the <code>fs</code> module APIs are preferable over
+the use of the promise APIs when maximal performance (both in terms of
+execution time and memory allocation are required).</p>
+</section><section><h3>Synchronous example<span><a class="mark" href="#fs_synchronous_example" id="fs_synchronous_example">#</a></span></h3>
+<p>The synchronous APIs block the Node.js event loop and further JavaScript
+execution until the operation is complete. Exceptions are thrown immediately
+and can be handled using <code>try…catch</code>, or can be allowed to bubble up.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { unlinkSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">unlinkSync</span>(<span class="hljs-string">'/tmp/hello'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">// handle the error</span>
+}</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { unlinkSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">unlinkSync</span>(<span class="hljs-string">'/tmp/hello'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">// handle the error</span>
+}</code></pre>
+</section><section><h3>Promises API<span><a class="mark" href="#fs_promises_api" id="fs_promises_api">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v8.1.0</td>
-<td><p>Added times as numbers.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>Exposed as <code>require('fs/promises')</code>.</p></td></tr>
+<tr><td>v11.14.0, v10.17.0</td>
+<td><p>This API is no longer experimental.</p></td></tr>
+<tr><td>v10.1.0</td>
+<td><p>The API is accessible via <code>require('fs').promises</code> only.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>A <code>fs.Stats</code> object provides information about a file.</p>
-<p>Objects returned from <a href="#fs_fs_stat_path_options_callback"><code>fs.stat()</code></a>, <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a> and <a href="#fs_fs_fstat_fd_options_callback"><code>fs.fstat()</code></a> and
-their synchronous counterparts are of this type.
-If <code>bigint</code> in the <code>options</code> passed to those methods is true, the numeric values
-will be <code>bigint</code> instead of <code>number</code>, and the object will contain additional
-nanosecond-precision properties suffixed with <code>Ns</code>.</p>
-<pre><code class="language-console">Stats {
-  dev: 2114,
-  ino: 48064969,
-  mode: 33188,
-  nlink: 1,
-  uid: 85,
-  gid: 100,
-  rdev: 0,
-  size: 527,
-  blksize: 4096,
-  blocks: 8,
-  atimeMs: 1318289051000.1,
-  mtimeMs: 1318289051000.1,
-  ctimeMs: 1318289051000.1,
-  birthtimeMs: 1318289051000.1,
-  atime: Mon, 10 Oct 2011 23:24:11 GMT,
-  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
-  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
-  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }</code></pre>
-<p><code>bigint</code> version:</p>
-<pre><code class="language-console">BigIntStats {
-  dev: 2114n,
-  ino: 48064969n,
-  mode: 33188n,
-  nlink: 1n,
-  uid: 85n,
-  gid: 100n,
-  rdev: 0n,
-  size: 527n,
-  blksize: 4096n,
-  blocks: 8n,
-  atimeMs: 1318289051000n,
-  mtimeMs: 1318289051000n,
-  ctimeMs: 1318289051000n,
-  birthtimeMs: 1318289051000n,
-  atimeNs: 1318289051000000000n,
-  mtimeNs: 1318289051000000000n,
-  ctimeNs: 1318289051000000000n,
-  birthtimeNs: 1318289051000000000n,
-  atime: Mon, 10 Oct 2011 23:24:11 GMT,
-  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
-  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
-  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }</code></pre>
-<h3><code>stats.isBlockDevice()</code><span><a class="mark" href="#fs_stats_isblockdevice" id="fs_stats_isblockdevice">#</a></span></h3>
+<p>The <code>fs/promises</code> API provides asynchronous file system methods that return
+promises.</p>
+<p>The promise APIs use the underlying Node.js threadpool to perform file
+system operations off the event loop thread. These operations are not
+synchronized or threadsafe. Care must be taken when performing multiple
+concurrent modifications on the same file or data corruption may occur.</p>
+<h4>Class: <code>FileHandle</code><span><a class="mark" href="#fs_class_filehandle" id="fs_class_filehandle">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
+</div>
+<p>A <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object is an object wrapper for a numeric file descriptor.</p>
+<p>Instances of the <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object are created by the <code>fsPromises.open()</code>
+method.</p>
+<p>All <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> objects are <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a>s.</p>
+<p>If a <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> is not closed using the <code>filehandle.close()</code> method, it will
+try to automatically close the file descriptor and emit a process warning,
+helping to prevent memory leaks. Please do not rely on this behavior because
+it can be unreliable and the file may not be closed. Instead, always explicitly
+close <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a>s. Node.js may change this behavior in the future.</p>
+<h5><code>filehandle.appendFile(data[, options])</code><span><a class="mark" href="#fs_filehandle_appendfile_data_options" id="fs_filehandle_appendfile_data_options">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a block device.</p>
-<h3><code>stats.isCharacterDevice()</code><span><a class="mark" href="#fs_stats_ischaracterdevice" id="fs_stats_ischaracterdevice">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Alias of <a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile()</code></a>.</p>
+<p>When operating on file handles, the mode cannot be changed from what it was set
+to with <a href="#fs_fspromises_open_path_flags_mode"><code>fsPromises.open()</code></a>. Therefore, this is equivalent to
+<a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile()</code></a>.</p>
+<h5><code>filehandle.chmod(mode)</code><span><a class="mark" href="#fs_filehandle_chmod_mode" id="fs_filehandle_chmod_mode">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the file mode bit mask.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a character device.</p>
-<h3><code>stats.isDirectory()</code><span><a class="mark" href="#fs_stats_isdirectory" id="fs_stats_isdirectory">#</a></span></h3>
+<p>Modifies the permissions on the file. See <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>.</p>
+<h5><code>filehandle.chown(uid, gid)</code><span><a class="mark" href="#fs_filehandle_chown_uid_gid" id="fs_filehandle_chown_uid_gid">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new owner's user id.</li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new group's group id.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a file system directory.</p>
-<h3><code>stats.isFIFO()</code><span><a class="mark" href="#fs_stats_isfifo" id="fs_stats_isfifo">#</a></span></h3>
+<p>Changes the ownership of the file. A wrapper for <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>.</p>
+<h5><code>filehandle.close()</code><span><a class="mark" href="#fs_filehandle_close" id="fs_filehandle_close">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a first-in-first-out (FIFO)
-pipe.</p>
-<h3><code>stats.isFile()</code><span><a class="mark" href="#fs_stats_isfile" id="fs_stats_isfile">#</a></span></h3>
+<p>Closes the file handle after waiting for any pending operation on the handle to
+complete.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> filehandle;
+<span class="hljs-keyword">try</span> {
+  filehandle = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'thefile.txt'</span>, <span class="hljs-string">'r'</span>);
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> filehandle?.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<h5><code>filehandle.datasync()</code><span><a class="mark" href="#fs_filehandle_datasync" id="fs_filehandle_datasync">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a regular file.</p>
-<h3><code>stats.isSocket()</code><span><a class="mark" href="#fs_stats_issocket" id="fs_stats_issocket">#</a></span></h3>
+<p>Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+<a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a> documentation for details.</p>
+<p>Unlike <code>filehandle.sync</code> this method does not flush modified metadata.</p>
+<h5><code>filehandle.fd</code><span><a class="mark" href="#fs_filehandle_fd" id="fs_filehandle_fd">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The numeric file descriptor managed by the <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a socket.</p>
-<h3><code>stats.isSymbolicLink()</code><span><a class="mark" href="#fs_stats_issymboliclink" id="fs_stats_issymboliclink">#</a></span></h3>
+<h5><code>filehandle.read(buffer, offset, length, position)</code><span><a class="mark" href="#fs_filehandle_read_buffer_offset_length_position" id="fs_filehandle_read_buffer_offset_length_position">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A buffer that will be filled with the
+file data read.</li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The location in the buffer at which to start filling.
+<strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes to read. <strong>Default:</strong>
+<code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The location where to begin reading data from the
+file. If <code>null</code>, data will be read from the current file position, and
+the position will be updated. If <code>position</code> is an integer, the current
+file position will remain unchanged.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills upon success with an object with two properties:
+<ul>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes read</li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A reference to the passed in <code>buffer</code>
+argument.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a symbolic link.</p>
-<p>This method is only valid when using <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a>.</p>
-<h3><code>stats.dev</code><span><a class="mark" href="#fs_stats_dev" id="fs_stats_dev">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</li>
 </ul>
-<p>The numeric identifier of the device containing the file.</p>
-<h3><code>stats.ino</code><span><a class="mark" href="#fs_stats_ino" id="fs_stats_ino">#</a></span></h3>
+<p>Reads data from the file and stores that in the given buffer.</p>
+<p>If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.</p>
+<h5><code>filehandle.read([options])</code><span><a class="mark" href="#fs_filehandle_read_options" id="fs_filehandle_read_options">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v13.11.0, v12.17.0</span>
+</div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The file system specific "Inode" number for the file.</p>
-<h3><code>stats.mode</code><span><a class="mark" href="#fs_stats_mode" id="fs_stats_mode">#</a></span></h3>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A buffer that will be filled with the
+file data read. <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The location in the buffer at which to start filling.
+<strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes to read. <strong>Default:</strong>
+<code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The location where to begin reading data from the
+file. If <code>null</code>, data will be read from the current file position, and
+the position will be updated. If <code>position</code> is an integer, the current
+file position will remain unchanged. <strong>Default:</strong>: <code>null</code></li>
 </ul>
-<p>A bit-field describing the file type and mode.</p>
-<h3><code>stats.nlink</code><span><a class="mark" href="#fs_stats_nlink" id="fs_stats_nlink">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills upon success with an object with two properties:
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes read</li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A reference to the passed in <code>buffer</code>
+argument.</li>
 </ul>
-<p>The number of hard-links that exist for the file.</p>
-<h3><code>stats.uid</code><span><a class="mark" href="#fs_stats_uid" id="fs_stats_uid">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</li>
 </ul>
-<p>The numeric user identifier of the user that owns the file (POSIX).</p>
-<h3><code>stats.gid</code><span><a class="mark" href="#fs_stats_gid" id="fs_stats_gid">#</a></span></h3>
+<p>Reads data from the file and stores that in the given buffer.</p>
+<p>If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.</p>
+<h5><code>filehandle.readFile(options)</code><span><a class="mark" href="#fs_filehandle_readfile_options" id="fs_filehandle_readfile_options">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The numeric group identifier of the group that owns the file (POSIX).</p>
-<h3><code>stats.rdev</code><span><a class="mark" href="#fs_stats_rdev" id="fs_stats_rdev">#</a></span></h3>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress readFile</li>
 </ul>
-<p>A numeric device identifier if the file represents a device.</p>
-<h3><code>stats.size</code><span><a class="mark" href="#fs_stats_size" id="fs_stats_size">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills upon a successful read with the contents of the
+file. If no encoding is specified (using <code>options.encoding</code>), the data is
+returned as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object. Otherwise, the data will be a string.</li>
 </ul>
-<p>The size of the file in bytes.</p>
-<h3><code>stats.blksize</code><span><a class="mark" href="#fs_stats_blksize" id="fs_stats_blksize">#</a></span></h3>
+<p>Asynchronously reads the entire contents of a file.</p>
+<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>
+<p>The <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> has to support reading.</p>
+<p>If one or more <code>filehandle.read()</code> calls are made on a file handle and then a
+<code>filehandle.readFile()</code> call is made, the data will be read from the current
+position till the end of the file. It doesn't always read from the beginning
+of the file.</p>
+<h5><code>filehandle.readv(buffers[, position])</code><span><a class="mark" href="#fs_filehandle_readv_buffers_position" id="fs_filehandle_readv_buffers_position">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v13.13.0, v12.17.0</span>
+</div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The file system block size for i/o operations.</p>
-<h3><code>stats.blocks</code><span><a class="mark" href="#fs_stats_blocks" id="fs_stats_blocks">#</a></span></h3>
+<li><code>buffers</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The offset from the beginning of the file where the data
+should be read from. If <code>position</code> is not a <code>number</code>, the data will be read
+from the current position.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills upon success an object containing two properties:
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the number of bytes read</li>
+<li><code>buffers</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a> property containing
+a reference to the <code>buffers</code> input.</li>
 </ul>
-<p>The number of blocks allocated for this file.</p>
-<h3><code>stats.atimeMs</code><span><a class="mark" href="#fs_stats_atimems" id="fs_stats_atimems">#</a></span></h3>
+</li>
+</ul>
+<p>Read from a file and write to an array of <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView></a>s</p>
+<h5><code>filehandle.stat([options])</code><span><a class="mark" href="#fs_filehandle_stat_options" id="fs_filehandle_stat_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.1.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
-<p>The timestamp indicating the last time this file was accessed expressed in
-milliseconds since the POSIX Epoch.</p>
-<h3><code>stats.mtimeMs</code><span><a class="mark" href="#fs_stats_mtimems" id="fs_stats_mtimems">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with an <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the file.</li>
+</ul>
+<h5><code>filehandle.sync()</code><span><a class="mark" href="#fs_filehandle_sync" id="fs_filehandle_sync">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.1.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fufills with <code>undefined</code> upon success.</li>
 </ul>
-<p>The timestamp indicating the last time this file was modified expressed in
-milliseconds since the POSIX Epoch.</p>
-<h3><code>stats.ctimeMs</code><span><a class="mark" href="#fs_stats_ctimems" id="fs_stats_ctimems">#</a></span></h3>
+<p>Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a> documentation for more detail.</p>
+<h5><code>filehandle.truncate(len)</code><span><a class="mark" href="#fs_filehandle_truncate_len" id="fs_filehandle_truncate_len">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.1.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>The timestamp indicating the last time the file status was changed expressed
-in milliseconds since the POSIX Epoch.</p>
-<h3><code>stats.birthtimeMs</code><span><a class="mark" href="#fs_stats_birthtimems" id="fs_stats_birthtimems">#</a></span></h3>
+<p>Truncates the file.</p>
+<p>If the file was larger than <code>len</code> bytes, only the first <code>len</code> bytes will be
+retained in the file.</p>
+<p>The following example retains only the first four bytes of the file:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> filehandle = <span class="hljs-literal">null</span>;
+<span class="hljs-keyword">try</span> {
+  filehandle = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
+  <span class="hljs-keyword">await</span> filehandle.<span class="hljs-title function_">truncate</span>(<span class="hljs-number">4</span>);
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> filehandle?.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the
+extended part is filled with null bytes (<code>'\0'</code>):</p>
+<p>If <code>len</code> is negative then <code>0</code> will be used.</p>
+<h5><code>filehandle.utimes(atime, mtime)</code><span><a class="mark" href="#fs_filehandle_utimes_atime_mtime" id="fs_filehandle_utimes_atime_mtime">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.1.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>The timestamp indicating the creation time of this file expressed in
-milliseconds since the POSIX Epoch.</p>
-<h3><code>stats.atimeNs</code><span><a class="mark" href="#fs_stats_atimens" id="fs_stats_atimens">#</a></span></h3>
+<p>Change the file system timestamps of the object referenced by the <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a>
+then resolves the promise with no arguments upon success.</p>
+<p>This function does not work on AIX versions before 7.1, it will reject the
+promise with an error using code <code>UV_ENOSYS</code>.</p>
+<h5><code>filehandle.write(buffer[, offset[, length[, position]]])</code><span><a class="mark" href="#fs_filehandle_write_buffer_offset_length_position" id="fs_filehandle_write_buffer_offset_length_position">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.10.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>buffer</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>buffer</code> parameter won't coerce unsupported input to buffers anymore.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The start position from within <code>buffer</code> where the data
+to write begins. <strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes from <code>buffer</code> to write. <strong>Default:</strong>
+<code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The offset from the beginning of the file where the
+data from <code>buffer</code> should be written. If <code>position</code> is not a <code>number</code>,
+the data will be written at the current position. See the POSIX <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>
+documentation for more detail.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Only present when <code>bigint: true</code> is passed into the method that generates
-the object.
-The timestamp indicating the last time this file was accessed expressed in
-nanoseconds since the POSIX Epoch.</p>
-<h3><code>stats.mtimeNs</code><span><a class="mark" href="#fs_stats_mtimens" id="fs_stats_mtimens">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.10.0</span>
-</div>
+<p>Write <code>buffer</code> to the file.</p>
+<p>If <code>buffer</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
+<p>The promise is resolved with an object containing two properties:</p>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the number of bytes written</li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> a reference to the
+<code>buffer</code> written.</li>
 </ul>
-<p>Only present when <code>bigint: true</code> is passed into the method that generates
-the object.
-The timestamp indicating the last time this file was modified expressed in
-nanoseconds since the POSIX Epoch.</p>
-<h3><code>stats.ctimeNs</code><span><a class="mark" href="#fs_stats_ctimens" id="fs_stats_ctimens">#</a></span></h3>
+<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file
+without waiting for the promise to be resolved (or rejected). For this
+scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>On Linux, positional writes do not work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+<h5><code>filehandle.write(string[, position[, encoding]])</code><span><a class="mark" href="#fs_filehandle_write_string_position_encoding" id="fs_filehandle_write_string_position_encoding">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.10.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>string</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>string</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The offset from the beginning of the file where the
+data from <code>string</code> should be written. If <code>position</code> is not a <code>number</code> the
+data will be written at the current position. See the POSIX <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>
+documentation for more detail.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The expected string encoding. <strong>Default:</strong> <code>'utf8'</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Only present when <code>bigint: true</code> is passed into the method that generates
-the object.
-The timestamp indicating the last time the file status was changed expressed
-in nanoseconds since the POSIX Epoch.</p>
-<h3><code>stats.birthtimeNs</code><span><a class="mark" href="#fs_stats_birthtimens" id="fs_stats_birthtimens">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.10.0</span>
-</div>
+<p>Write <code>string</code> to the file. If <code>string</code> is not a string, or an object with an
+own <code>toString</code> function property, the promise is rejected with an error.</p>
+<p>The promise is resolved with an object containing two properties:</p>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the number of bytes written</li>
+<li><code>buffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> a reference to the <code>string</code> written.</li>
 </ul>
-<p>Only present when <code>bigint: true</code> is passed into the method that generates
-the object.
-The timestamp indicating the creation time of this file expressed in
-nanoseconds since the POSIX Epoch.</p>
-<h3><code>stats.atime</code><span><a class="mark" href="#fs_stats_atime" id="fs_stats_atime">#</a></span></h3>
+<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file
+without waiting for the promise to be resolved (or rejected). For this
+scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>On Linux, positional writes do not work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+<h5><code>filehandle.writeFile(data, options)</code><span><a class="mark" href="#fs_filehandle_writefile_data_options" id="fs_filehandle_writefile_data_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.11.13</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>data</code> argument supports <code>AsyncIterable</code>, <code>Iterable</code> and <code>Stream</code>.</p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>data</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>data</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> | <a href="#stream_stream" class="type">&#x3C;Stream></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> The expected character encoding when <code>data</code> is a
+string. <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>The timestamp indicating the last time this file was accessed.</p>
-<h3><code>stats.mtime</code><span><a class="mark" href="#fs_stats_mtime" id="fs_stats_mtime">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Asynchronously writes data to a file, replacing the file if it already exists.
+<code>data</code> can be a string, a buffer, an <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> object, or an
+object with an own <code>toString</code> function
+property. The promise is resolved with no arguments upon success.</p>
+<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>
+<p>The <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> has to support writing.</p>
+<p>It is unsafe to use <code>filehandle.writeFile()</code> multiple times on the same file
+without waiting for the promise to be resolved (or rejected).</p>
+<p>If one or more <code>filehandle.write()</code> calls are made on a file handle and then a
+<code>filehandle.writeFile()</code> call is made, the data will be written from the
+current position till the end of the file. It doesn't always write from the
+beginning of the file.</p>
+<h5><code>filehandle.writev(buffers[, position])</code><span><a class="mark" href="#fs_filehandle_writev_buffers_position" id="fs_filehandle_writev_buffers_position">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.11.13</span>
+<span>Added in: v12.9.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>buffers</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The offset from the beginning of the file where the
+data from <code>buffers</code> should be written. If <code>position</code> is not a <code>number</code>,
+the data will be written at the current position.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>The timestamp indicating the last time this file was modified.</p>
-<h3><code>stats.ctime</code><span><a class="mark" href="#fs_stats_ctime" id="fs_stats_ctime">#</a></span></h3>
+<p>Write an array of <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView></a>s to the file.</p>
+<p>The promise is resolved with an object containing a two properties:</p>
+<ul>
+<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the number of bytes written</li>
+<li><code>buffers</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a> a reference to the <code>buffers</code>
+input.</li>
+</ul>
+<p>It is unsafe to call <code>writev()</code> multiple times on the same file without waiting
+for the promise to be resolved (or rejected).</p>
+<p>On Linux, positional writes don't work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+<h4><code>fsPromises.access(path[, mode])</code><span><a class="mark" href="#fs_fspromises_access_path_mode" id="fs_fspromises_access_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.11.13</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>fs.constants.F_OK</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>The timestamp indicating the last time the file status was changed.</p>
-<h3><code>stats.birthtime</code><span><a class="mark" href="#fs_stats_birthtime" id="fs_stats_birthtime">#</a></span></h3>
+<p>Tests a user's permissions for the file or directory specified by <code>path</code>.
+The <code>mode</code> argument is an optional integer that specifies the accessibility
+checks to be performed. Check <a href="#fs_file_access_constants">File access constants</a> for possible values
+of <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of
+two or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>
+<p>If the accessibility check is successful, the promise is resolved with no
+value. If any of the accessibility checks fail, the promise is rejected
+with an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> object. The following example checks if the file
+<code>/etc/passwd</code> can be read and written by the current process.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { access } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+<span class="hljs-keyword">import</span> { constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">access</span>(<span class="hljs-string">'/etc/passwd'</span>, constants.<span class="hljs-property">R_OK</span> | constants.<span class="hljs-property">W_OK</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'can access'</span>);
+} <span class="hljs-keyword">catch</span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'cannot access'</span>);
+}</code></pre>
+<p>Using <code>fsPromises.access()</code> to check for the accessibility of a file before
+calling <code>fsPromises.open()</code> is not recommended. Doing so introduces a race
+condition, since other processes may change the file's state between the two
+calls. Instead, user code should open/read/write the file directly and handle
+the error raised if the file is not accessible.</p>
+<h4><code>fsPromises.appendFile(path, data[, options])</code><span><a class="mark" href="#fs_fspromises_appendfile_path_data_options" id="fs_fspromises_appendfile_path_data_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.11.13</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'a'</code>.</li>
 </ul>
-<p>The timestamp indicating the creation time of this file.</p>
-<h3>Stat time values<span><a class="mark" href="#fs_stat_time_values" id="fs_stat_time_values">#</a></span></h3>
-<p>The <code>atimeMs</code>, <code>mtimeMs</code>, <code>ctimeMs</code>, <code>birthtimeMs</code> properties are
-numeric values that hold the corresponding times in milliseconds. Their
-precision is platform specific. When <code>bigint: true</code> is passed into the
-method that generates the object, the properties will be <a href="https://tc39.github.io/proposal-bigint">bigints</a>,
-otherwise they will be <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type">numbers</a>.</p>
-<p>The <code>atimeNs</code>, <code>mtimeNs</code>, <code>ctimeNs</code>, <code>birthtimeNs</code> properties are
-<a href="https://tc39.github.io/proposal-bigint">bigints</a> that hold the corresponding times in nanoseconds. They are
-only present when <code>bigint: true</code> is passed into the method that generates
-the object. Their precision is platform specific.</p>
-<p><code>atime</code>, <code>mtime</code>, <code>ctime</code>, and <code>birthtime</code> are
-<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a> object alternate representations of the various times. The
-<code>Date</code> and number values are not connected. Assigning a new number value, or
-mutating the <code>Date</code> value, will not be reflected in the corresponding alternate
-representation.</p>
-<p>The times in the stat object have the following semantics:</p>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Asynchronously append data to a file, creating the file if it does not yet
+exist. <code>data</code> can be a string or a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<p>The <code>path</code> may be specified as a <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> that has been opened
+for appending (using <code>fsPromises.open()</code>).</p>
+<h4><code>fsPromises.chmod(path, mode)</code><span><a class="mark" href="#fs_fspromises_chmod_path_mode" id="fs_fspromises_chmod_path_mode">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
 <ul>
-<li><code>atime</code> "Access Time": Time when file data last accessed. Changed
-by the <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/read.2.html"><code>read(2)</code></a> system calls.</li>
-<li><code>mtime</code> "Modified Time": Time when file data last modified.
-Changed by the <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/write.2.html"><code>write(2)</code></a> system calls.</li>
-<li><code>ctime</code> "Change Time": Time when file status was last changed
-(inode data modification). Changed by the <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>,
-<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>,
-<a href="http://man7.org/linux/man-pages/man2/read.2.html"><code>read(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/write.2.html"><code>write(2)</code></a> system calls.</li>
-<li><code>birthtime</code> "Birth Time": Time of file creation. Set once when the
-file is created. On filesystems where birthtime is not available,
-this field may instead hold either the <code>ctime</code> or
-<code>1970-01-01T00:00Z</code> (ie, Unix epoch timestamp <code>0</code>). This value may be greater
-than <code>atime</code> or <code>mtime</code> in this case. On Darwin and other FreeBSD variants,
-also set if the <code>atime</code> is explicitly set to an earlier value than the current
-<code>birthtime</code> using the <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a> system call.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Prior to Node.js 0.12, the <code>ctime</code> held the <code>birthtime</code> on Windows systems. As
-of 0.12, <code>ctime</code> is not "creation time", and on Unix systems, it never was.</p>
-<h2>Class: <code>fs.WriteStream</code><span><a class="mark" href="#fs_class_fs_writestream" id="fs_class_fs_writestream">#</a></span></h2>
+<p>Changes the permissions of a file.</p>
+<h4><code>fsPromises.chown(path, uid, gid)</code><span><a class="mark" href="#fs_fspromises_chown_path_uid_gid" id="fs_fspromises_chown_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Extends <a href="#stream_class_stream_writable" class="type">&#x3C;stream.Writable></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Instances of <code>fs.WriteStream</code> are created and returned using the
-<a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> function.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close_2" id="fs_event_close_2">#</a></span></h3>
+<p>Changes the ownership of a file.</p>
+<h4><code>fsPromises.copyFile(src, dest[, mode])</code><span><a class="mark" href="#fs_fspromises_copyfile_src_dest_mode" id="fs_fspromises_copyfile_src_dest_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p>Emitted when the <code>WriteStream</code>'s underlying file descriptor has been closed.</p>
-<h3>Event: <code>'open'</code><span><a class="mark" href="#fs_event_open_1" id="fs_event_open_1">#</a></span></h3>
+<ul>
+<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
+<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Optional modifiers that specify the behavior of the copy
+operation. It is possible to create a mask consisting of the bitwise OR of
+two or more values (e.g.
+<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>)
+<strong>Default:</strong> <code>0</code>.
+<ul>
+<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code>
+already exists.</li>
+<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create
+a copy-on-write reflink. If the platform does not support copy-on-write,
+then a fallback copy mechanism is used.</li>
+<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
+create a copy-on-write reflink. If the platform does not support
+copy-on-write, then the operation will fail.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
+already exists.</p>
+<p>No guarantees are made about the atomicity of the copy operation. If an
+error occurs after the destination file has been opened for writing, an attempt
+will be made to remove the destination.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-keyword">import</span> { copyFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">copyFile</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
+} <span class="hljs-keyword">catch</span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The file could not be copied'</span>);
+}
+
+<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">copyFile</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, constants.<span class="hljs-property">COPYFILE_EXCL</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
+} <span class="hljs-keyword">catch</span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The file could not be copied'</span>);
+}</code></pre>
+<h4><code>fsPromises.lchmod(path, mode)</code><span><a class="mark" href="#fs_fspromises_lchmod_path_mode" id="fs_fspromises_lchmod_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Deprecated since: v10.0.0</span>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Integer file descriptor used by the <code>WriteStream</code>.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Emitted when the <code>WriteStream</code>'s file is opened.</p>
-<h3>Event: <code>'ready'</code><span><a class="mark" href="#fs_event_ready_1" id="fs_event_ready_1">#</a></span></h3>
+<p>Changes the permissions on a symbolic link.</p>
+<p>This method is only implemented on macOS.</p>
+<h4><code>fsPromises.lchown(path, uid, gid)</code><span><a class="mark" href="#fs_fspromises_lchown_path_uid_gid" id="fs_fspromises_lchown_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v9.11.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.6.0</td>
+<td><p>This API is no longer deprecated.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p>Emitted when the <code>fs.WriteStream</code> is ready to be used.</p>
-<p>Fires immediately after <code>'open'</code>.</p>
-<h3><code>writeStream.bytesWritten</code><span><a class="mark" href="#fs_writestream_byteswritten" id="fs_writestream_byteswritten">#</a></span></h3>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Changes the ownership on a symbolic link.</p>
+<h4><code>fsPromises.lutimes(path, atime, mtime)</code><span><a class="mark" href="#fs_fspromises_lutimes_path_atime_mtime" id="fs_fspromises_lutimes_path_atime_mtime">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.4.7</span>
+<span>Added in: v14.5.0, v12.19.0</span>
 </div>
-<p>The number of bytes written so far. Does not include data that is still queued
-for writing.</p>
-<h3><code>writeStream.path</code><span><a class="mark" href="#fs_writestream_path" id="fs_writestream_path">#</a></span></h3>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Changes the access and modification times of a file in the same way as
+<a href="#fs_fspromises_utimes_path_atime_mtime"><code>fsPromises.utimes()</code></a>, with the difference that if the path refers to a
+symbolic link, then the link is not dereferenced: instead, the timestamps of
+the symbolic link itself are changed.</p>
+<h4><code>fsPromises.link(existingPath, newPath)</code><span><a class="mark" href="#fs_fspromises_link_existingpath_newpath" id="fs_fspromises_link_existingpath_newpath">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v10.0.0</span>
 </div>
-<p>The path to the file the stream is writing to as specified in the first
-argument to <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>. If <code>path</code> is passed as a string, then
-<code>writeStream.path</code> will be a string. If <code>path</code> is passed as a <code>Buffer</code>, then
-<code>writeStream.path</code> will be a <code>Buffer</code>.</p>
-<h3><code>writeStream.pending</code><span><a class="mark" href="#fs_writestream_pending" id="fs_writestream_pending">#</a></span></h3>
+<ul>
+<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX
+<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a> documentation for more detail.</p>
+<h4><code>fsPromises.lstat(path[, options])</code><span><a class="mark" href="#fs_fspromises_lstat_path_options" id="fs_fspromises_lstat_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.2.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
-<p>This property is <code>true</code> if the underlying file has not been opened yet,
-i.e. before the <code>'ready'</code> event is emitted.</p>
-<h2><code>fs.access(path[, mode], callback)</code><span><a class="mark" href="#fs_fs_access_path_mode_callback" id="fs_fs_access_path_mode_callback">#</a></span></h2>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object for the given
+symbolic link <code>path</code>.</li>
+</ul>
+<p>Equivalent to <a href="#fs_fspromises_stat_path_options"><code>fsPromises.stat()</code></a> unless <code>path</code> refers to a symbolic link,
+in which case the link itself is stat-ed, not the file that it refers to.
+Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a> document for more detail.</p>
+<h4><code>fsPromises.mkdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_mkdir_path_options" id="fs_fspromises_mkdir_path_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
+<ul>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Upon success, fulfills with <code>undefined</code> if <code>recursive</code>
+is <code>false</code>, or the first directory path created if <code>recursive</code> is <code>true</code>.</li>
+</ul>
+<p>Asynchronously creates a directory.</p>
+<p>The optional <code>options</code> argument can be an integer specifying <code>mode</code> (permission
+and sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>
+property indicating whether parent directories should be created. Calling
+<code>fsPromises.mkdir()</code> when <code>path</code> is a directory that exists results in a
+rejection only when <code>recursive</code> is false.</p>
+<h4><code>fsPromises.mkdtemp(prefix[, options])</code><span><a class="mark" href="#fs_fspromises_mkdtemp_prefix_options" id="fs_fspromises_mkdtemp_prefix_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>prefix</code> parameter now accepts an empty string.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with a string containing the filesystem path
+of the newly created temporary directory.</li>
+</ul>
+<p>Creates a unique temporary directory. A unique directory name is generated by
+appending six random characters to the end of the provided <code>prefix</code>. Due to
+platform inconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some
+platforms, notably the BSDs, can return more than six random characters, and
+replace trailing <code>X</code> characters in <code>prefix</code> with random characters.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { mkdtemp } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">mkdtemp</span>(path.<span class="hljs-title function_">join</span>(os.<span class="hljs-title function_">tmpdir</span>(), <span class="hljs-string">'foo-'</span>));
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>The <code>fsPromises.mkdtemp()</code> method will append the six randomly selected
+characters directly to the <code>prefix</code> string. For instance, given a directory
+<code>/tmp</code>, if the intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the
+<code>prefix</code> must end with a trailing platform-specific path separator
+(<code>require('path').sep</code>).</p>
+<h4><code>fsPromises.open(path, flags[, mode])</code><span><a class="mark" href="#fs_fspromises_open_path_flags_mode" id="fs_fspromises_open_path_flags_mode">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v11.1.0</td>
+<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.
+<strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Sets the file mode (permission and sticky bits)
+if the file is created. <strong>Default:</strong> <code>0o666</code> (readable and writable)</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with a <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object.</li>
+</ul>
+<p>Opens a <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a>.</p>
+<p>Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a> documentation for more detail.</p>
+<p>Some characters (<code>&#x3C; > : " / \ | ? *</code>) are reserved under Windows as documented
+by <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains
+a colon, Node.js will open a file system stream, as described by
+<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams">this MSDN page</a>.</p>
+<h4><code>fsPromises.opendir(path[, options])</code><span><a class="mark" href="#fs_fspromises_opendir_path_options" id="fs_fspromises_opendir_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
+<tr><td>v12.12.0</td>
+<td><p><span>Added in: v12.12.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
+internally when reading from the directory. Higher values lead to better
+performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with an <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>.</li>
+</ul>
+<p>Asynchronously open a directory for iterative scanning. See the POSIX
+<a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a> documentation for more detail.</p>
+<p>Creates an <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>, which contains all further functions for reading from
+and cleaning up the directory.</p>
+<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
+directory and subsequent read operations.</p>
+<p>Example using async iteration:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { opendir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> dir = <span class="hljs-keyword">await</span> <span class="hljs-title function_">opendir</span>(<span class="hljs-string">'./'</span>);
+  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> dirent <span class="hljs-keyword">of</span> dir)
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(dirent.<span class="hljs-property">name</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>When using the async iterator, the <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a> object will be automatically
+closed after the iterator exits.</p>
+<h4><code>fsPromises.readdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_readdir_path_options" id="fs_fspromises_readdir_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.11.0</td>
+<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with an array of the names of the files in
+the directory excluding <code>'.'</code> and <code>'..'</code>.</li>
+</ul>
+<p>Reads the contents of a directory.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the filenames. If the <code>encoding</code> is set to <code>'buffer'</code>, the filenames returned
+will be passed as <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> objects.</p>
+<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the resolved array will contain
+<a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> objects.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readdir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> files = <span class="hljs-keyword">await</span> <span class="hljs-title function_">readdir</span>(path);
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> file <span class="hljs-keyword">of</span> files)
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(file);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<h4><code>fsPromises.readFile(path[, options])</code><span><a class="mark" href="#fs_fspromises_readfile_path_options" id="fs_fspromises_readfile_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>The options argument may include an AbortSignal to abort an ongoing readFile request.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress readFile</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with the contents of the file.</li>
+</ul>
+<p>Asynchronously reads the entire contents of a file.</p>
+<p>If no encoding is specified (using <code>options.encoding</code>), the data is returned
+as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object. Otherwise, the data will be a string.</p>
+<p>If <code>options</code> is a string, then it specifies the encoding.</p>
+<p>When the <code>path</code> is a directory, the behavior of <code>fsPromises.readFile()</code> is
+platform-specific. On macOS, Linux, and Windows, the promise will be rejected
+with an error. On FreeBSD, a representation of the directory's contents will be
+returned.</p>
+<p>It is possible to abort an ongoing <code>readFile</code> using an <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a>. If a
+request is aborted the promise returned is rejected with an <code>AbortError</code>:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+  <span class="hljs-keyword">const</span> { signal } = controller;
+  <span class="hljs-keyword">const</span> promise = <span class="hljs-title function_">readFile</span>(fileName, { signal });
+
+  <span class="hljs-comment">// Abort the request before the promise settles.</span>
+  controller.<span class="hljs-title function_">abort</span>();
+
+  <span class="hljs-keyword">await</span> promise;
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">// When a request is aborted - err is an AbortError</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering <code>fs.readFile</code> performs.</p>
+<p>Any specified <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> has to support reading.</p>
+<h4><code>fsPromises.readlink(path[, options])</code><span><a class="mark" href="#fs_fspromises_readlink_path_options" id="fs_fspromises_readlink_path_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with the <code>linkString</code> upon success.</li>
+</ul>
+<p>Reads the contents of the symbolic link referred to by <code>path</code>. See the POSIX
+<a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a> documentation for more detail. The promise is resolved with the
+<code>linkString</code> upon success.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>, the link path
+returned will be passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<h4><code>fsPromises.realpath(path[, options])</code><span><a class="mark" href="#fs_fspromises_realpath_path_options" id="fs_fspromises_realpath_path_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with the resolved path upon success.</li>
+</ul>
+<p>Determines the actual location of <code>path</code> using the same semantics as the
+<code>fs.realpath.native()</code> function.</p>
+<p>Only paths that can be converted to UTF8 strings are supported.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the path. If the <code>encoding</code> is set to <code>'buffer'</code>, the path returned will be
+passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
+be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
+this restriction.</p>
+<h4><code>fsPromises.rename(oldPath, newPath)</code><span><a class="mark" href="#fs_fspromises_rename_oldpath_newpath" id="fs_fspromises_rename_oldpath_newpath">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Renames <code>oldPath</code> to <code>newPath</code>.</p>
+<h4><code>fsPromises.rmdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_rmdir_path_options" id="fs_fspromises_rmdir_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.14.0</td>
+<td><p>The <code>recursive</code> option is deprecated, use <code>fsPromises.rm</code> instead.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
+<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
+<tr><td>v12.10.0</td>
+<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js retries the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode, errors are not reported if <code>path</code> does not exist, and
+operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Removes the directory identified by <code>path</code>.</p>
+<p>Using <code>fsPromises.rmdir()</code> on a file (not a directory) results in the
+promise being rejected with an <code>ENOENT</code> error on Windows and an <code>ENOTDIR</code>
+error on POSIX.</p>
+<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command
+<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in
+the future.</p>
+<h4><code>fsPromises.rm(path[, options])</code><span><a class="mark" href="#fs_fspromises_rm_path_options" id="fs_fspromises_rm_path_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.14.0</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>force</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, exceptions will be ignored if <code>path</code> does
+not exist. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Removes files and directories (modeled on the standard POSIX <code>rm</code> utility).</p>
+<h4><code>fsPromises.stat(path[, options])</code><span><a class="mark" href="#fs_fspromises_stat_path_options" id="fs_fspromises_stat_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object for the
+given <code>path</code>.</li>
+</ul>
+<h4><code>fsPromises.symlink(target, path[, type])</code><span><a class="mark" href="#fs_fspromises_symlink_target_path_type" id="fs_fspromises_symlink_target_path_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'file'</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Creates a symbolic link.</p>
+<p>The <code>type</code> argument is only used on Windows platforms and can be one of <code>'dir'</code>,
+<code>'file'</code>, or <code>'junction'</code>. Windows junction points require the destination path
+to be absolute. When using <code>'junction'</code>, the <code>target</code> argument will
+automatically be normalized to absolute path.</p>
+<h4><code>fsPromises.truncate(path[, len])</code><span><a class="mark" href="#fs_fspromises_truncate_path_len" id="fs_fspromises_truncate_path_len">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Truncates (shortens or extends the length) of the content at <code>path</code> to <code>len</code>
+bytes.</p>
+<h4><code>fsPromises.unlink(path)</code><span><a class="mark" href="#fs_fspromises_unlink_path" id="fs_fspromises_unlink_path">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>If <code>path</code> refers to a symbolic link, then the link is removed without affecting
+the file or directory to which that link refers. If the <code>path</code> refers to a file
+path that is not a symbolic link, the file is deleted. See the POSIX <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>
+documentation for more detail.</p>
+<h4><code>fsPromises.utimes(path, atime, mtime)</code><span><a class="mark" href="#fs_fspromises_utimes_path_atime_mtime" id="fs_fspromises_utimes_path_atime_mtime">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>
+<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>
+<ul>
+<li>Values can be either numbers representing Unix epoch time, <code>Date</code>s, or a
+numeric string like <code>'123456789.0'</code>.</li>
+<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or
+<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>
+</ul>
+<h4><code>fsPromises.watch(filename[, options])</code><span><a class="mark" href="#fs_fspromises_watch_filename_options" id="fs_fspromises_watch_filename_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>persistent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether the process should continue to run
+as long as files are being watched. <strong>Default:</strong> <code>true</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether all subdirectories should be
+watched, or only the current directory. This applies when a directory is
+specified, and only on supported platforms (See <a href="#fs_caveats">caveats</a>). <strong>Default:</strong>
+<code>false</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Specifies the character encoding to be used for the
+filename passed to the listener. <strong>Default:</strong> <code>'utf8'</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> An <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> used to signal when the watcher
+should stop.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterator-interface" class="type">&#x3C;AsyncIterator></a> of objects with the properties:
+<ul>
+<li><code>eventType</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The type of change</li>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The name of the file changed.</li>
+</ul>
+</li>
+</ul>
+<p>Returns an async iterator that watches for changes on <code>filename</code>, where <code>filename</code>
+is either a file or a directory.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { watch } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);
+
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = ac;
+<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> ac.<span class="hljs-title function_">abort</span>(), <span class="hljs-number">10000</span>);
+
+(<span class="hljs-keyword">async</span> () => {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">const</span> watcher = <span class="hljs-title function_">watch</span>(__filename, { signal });
+    <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> event <span class="hljs-keyword">of</span> watcher)
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event);
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">name</span> === <span class="hljs-string">'AbortError'</span>)
+      <span class="hljs-keyword">return</span>;
+    <span class="hljs-keyword">throw</span> err;
+  }
+})();</code></pre>
+<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or
+disappears in the directory.</p>
+<p>All the <a href="#fs_caveats">caveats</a> for <code>fs.watch()</code> also apply to <code>fsPromises.watch()</code>.</p>
+<h4><code>fsPromises.writeFile(file, data[, options])</code><span><a class="mark" href="#fs_fspromises_writefile_file_data_options" id="fs_fspromises_writefile_file_data_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>data</code> argument supports <code>AsyncIterable</code>, <code>Iterable</code> and <code>Stream</code>.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>The options argument may include an AbortSignal to abort an ongoing writeFile request.</p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>data</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>data</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> | <a href="#stream_stream" class="type">&#x3C;Stream></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress writeFile</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Asynchronously writes data to a file, replacing the file if it already exists.
+<code>data</code> can be a string, a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>, or, an object with an own (not inherited)
+<code>toString</code> function property.</p>
+<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
+<p>If <code>options</code> is a string, then it specifies the encoding.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<p>Any specified <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> has to support writing.</p>
+<p>It is unsafe to use <code>fsPromises.writeFile()</code> multiple times on the same file
+without waiting for the promise to be settled.</p>
+<p>Similarly to <code>fsPromises.readFile</code> - <code>fsPromises.writeFile</code> is a convenience
+method that performs multiple <code>write</code> calls internally to write the buffer
+passed to it. For performance sensitive code consider using
+<a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>It is possible to use an <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> to cancel an <code>fsPromises.writeFile()</code>.
+Cancelation is "best effort", and some amount of data is likely still
+to be written.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { writeFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+  <span class="hljs-keyword">const</span> { signal } = controller;
+  <span class="hljs-keyword">const</span> data = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Hello Node.js'</span>));
+  <span class="hljs-keyword">const</span> promise = <span class="hljs-title function_">writeFile</span>(<span class="hljs-string">'message.txt'</span>, data, { signal });
+
+  <span class="hljs-comment">// Abort the request before the promise settles.</span>
+  controller.<span class="hljs-title function_">abort</span>();
+
+  <span class="hljs-keyword">await</span> promise;
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">// When a request is aborted - err is an AbortError</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering <code>fs.writeFile</code> performs.</p>
+</section><section><h3>Callback API<span><a class="mark" href="#fs_callback_api" id="fs_callback_api">#</a></span></h3>
+<p>The callback APIs perform all operations asynchronously, without blocking the
+event loop, then invoke a callback function upon completion or error.</p>
+<p>The callback APIs use the underlying Node.js threadpool to perform file
+system operations off the event loop thread. These operations are not
+synchronized or threadsafe. Care must be taken when performing multiple
+concurrent modifications on the same file or data corruption may occur.</p>
+<h4><code>fs.access(path[, mode], callback)</code><span><a class="mark" href="#fs_fs_access_path_mode_callback" id="fs_fs_access_path_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v6.3.0</td>
 <td><p>The constants like <code>fs.R_OK</code>, etc which were present directly on <code>fs</code> were moved into <code>fs.constants</code> as a soft deprecation. Thus for Node.js <code>&#x3C; v6.3.0</code> use <code>fs</code> to access those constants, or do something like <code>(fs.constants || fs).R_OK</code> to work with all versions.</p></td></tr>
 <tr><td>v0.11.15</td>
@@ -30178,30 +32437,32 @@ two or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p
 a possible error argument. If any of the accessibility checks fail, the error
 argument will be an <code>Error</code> object. The following examples check if
 <code>package.json</code> exists, and if it is readable or writable.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> file = <span class="hljs-string">'package.json'</span>;
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { access, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">const</span> file = <span class="hljs-string">'package.json'</span>;
 
 <span class="hljs-comment">// Check if the file exists in the current directory.</span>
-fs.access(file, fs.constants.F_OK, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'does not exist'</span> : <span class="hljs-string">'exists'</span>}</span>`</span>);
+<span class="hljs-title function_">access</span>(file, constants.<span class="hljs-property">F_OK</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'does not exist'</span> : <span class="hljs-string">'exists'</span>}</span>`</span>);
 });
 
 <span class="hljs-comment">// Check if the file is readable.</span>
-fs.access(file, fs.constants.R_OK, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'is not readable'</span> : <span class="hljs-string">'is readable'</span>}</span>`</span>);
+<span class="hljs-title function_">access</span>(file, constants.<span class="hljs-property">R_OK</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'is not readable'</span> : <span class="hljs-string">'is readable'</span>}</span>`</span>);
 });
 
 <span class="hljs-comment">// Check if the file is writable.</span>
-fs.access(file, fs.constants.W_OK, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'is not writable'</span> : <span class="hljs-string">'is writable'</span>}</span>`</span>);
+<span class="hljs-title function_">access</span>(file, constants.<span class="hljs-property">W_OK</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'is not writable'</span> : <span class="hljs-string">'is writable'</span>}</span>`</span>);
 });
 
 <span class="hljs-comment">// Check if the file exists in the current directory, and if it is writable.</span>
-fs.access(file, fs.constants.F_OK | fs.constants.W_OK, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<span class="hljs-title function_">access</span>(file, constants.<span class="hljs-property">F_OK</span> | constants.<span class="hljs-property">W_OK</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(
       <span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err.code === <span class="hljs-string">'ENOENT'</span> ? <span class="hljs-string">'does not exist'</span> : <span class="hljs-string">'is read-only'</span>}</span>`</span>);
   } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${file}</span> exists, and it is writable`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${file}</span> exists, and it is writable`</span>);
   }
 });</code></pre>
 <p>Do not use <code>fs.access()</code> to check for the accessibility of a file before calling
@@ -30210,58 +32471,91 @@ so introduces a race condition, since other processes may change the file's
 state between the two calls. Instead, user code should open/read/write the
 file directly and handle the error raised if the file is not accessible.</p>
 <p><strong>write (NOT RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.access(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { access, open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">access</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (!err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile already exists'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile already exists'</span>);
     <span class="hljs-keyword">return</span>;
   }
 
-  fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    writeMyData(fd);
+
+    <span class="hljs-keyword">try</span> {
+      <span class="hljs-title function_">writeMyData</span>(fd);
+    } <span class="hljs-keyword">finally</span> {
+      <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+        <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+      });
+    }
   });
 });</code></pre>
 <p><strong>write (RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'EEXIST'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile already exists'</span>);
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'EEXIST'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile already exists'</span>);
       <span class="hljs-keyword">return</span>;
     }
 
     <span class="hljs-keyword">throw</span> err;
   }
 
-  writeMyData(fd);
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">writeMyData</span>(fd);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  }
 });</code></pre>
 <p><strong>read (NOT RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.access(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { access, open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-title function_">access</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ENOENT'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile does not exist'</span>);
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ENOENT'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile does not exist'</span>);
       <span class="hljs-keyword">return</span>;
     }
 
     <span class="hljs-keyword">throw</span> err;
   }
 
-  fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    readMyData(fd);
+
+    <span class="hljs-keyword">try</span> {
+      <span class="hljs-title function_">readMyData</span>(fd);
+    } <span class="hljs-keyword">finally</span> {
+      <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+        <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+      });
+    }
   });
 });</code></pre>
 <p><strong>read (RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ENOENT'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile does not exist'</span>);
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ENOENT'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile does not exist'</span>);
       <span class="hljs-keyword">return</span>;
     }
 
     <span class="hljs-keyword">throw</span> err;
   }
 
-  readMyData(fd);
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">readMyData</span>(fd);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  }
 });</code></pre>
 <p>The "not recommended" examples above check for accessibility and then use the
 file; the "recommended" examples are better because they use the file directly
@@ -30273,37 +32567,7 @@ process.</p>
 a file or directory. The <code>fs.access()</code> function, however, does not check the
 ACL and therefore may report that a path is accessible even if the ACL restricts
 the user from reading or writing to it.</p>
-<h2><code>fs.accessSync(path[, mode])</code><span><a class="mark" href="#fs_fs_accesssync_path_mode" id="fs_fs_accesssync_path_mode">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.11.15</td>
-<td><p><span>Added in: v0.11.15</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>fs.constants.F_OK</code></li>
-</ul>
-<p>Synchronously tests a user's permissions for the file or directory specified
-by <code>path</code>. The <code>mode</code> argument is an optional integer that specifies the
-accessibility checks to be performed. Check <a href="#fs_file_access_constants">File access constants</a> for
-possible values of <code>mode</code>. It is possible to create a mask consisting of
-the bitwise OR of two or more values
-(e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>
-<p>If any of the accessibility checks fail, an <code>Error</code> will be thrown. Otherwise,
-the method will return <code>undefined</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  fs.accessSync(<span class="hljs-string">'etc/passwd'</span>, fs.constants.R_OK | fs.constants.W_OK);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'can read/write'</span>);
-} <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'no access!'</span>);
-}</code></pre>
-<h2><code>fs.appendFile(path, data[, options], callback)</code><span><a class="mark" href="#fs_fs_appendfile_path_data_options_callback" id="fs_fs_appendfile_path_data_options_callback">#</a></span></h2>
+<h4><code>fs.appendFile(path, data[, options], callback)</code><span><a class="mark" href="#fs_fs_appendfile_path_data_options_callback" id="fs_fs_appendfile_path_data_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -30338,75 +32602,44 @@ the method will return <code>undefined</code>.</p>
 </li>
 </ul>
 <p>Asynchronously append data to a file, creating the file if it does not yet
-exist. <code>data</code> can be a string or a <a href="#buffer_buffer"><code>Buffer</code></a>.</p>
-<pre><code class="language-js">fs.appendFile(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+exist. <code>data</code> can be a string or a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { appendFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">appendFile</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The "data to append" was appended to file!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The "data to append" was appended to file!'</span>);
 });</code></pre>
 <p>If <code>options</code> is a string, then it specifies the encoding:</p>
-<pre><code class="language-js">fs.appendFile(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { appendFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">appendFile</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
 <p>The <code>path</code> may be specified as a numeric file descriptor that has been opened
 for appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will
 not be closed automatically.</p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close, appendFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">closeFd</span>(<span class="hljs-params">fd</span>) {
+  <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  });
+}
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.appendFile(fd, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">appendFile</span>(fd, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-title function_">closeFd</span>(fd);
       <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
     });
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  });
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-title function_">closeFd</span>(fd);
+    <span class="hljs-keyword">throw</span> err;
+  }
 });</code></pre>
-<h2><code>fs.appendFileSync(path, data[, options])</code><span><a class="mark" href="#fs_fs_appendfilesync_path_data_options" id="fs_fs_appendfilesync_path_data_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.0.0</td>
-<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
-<tr><td>v5.0.0</td>
-<td><p>The <code>file</code> parameter can be a file descriptor now.</p></td></tr>
-<tr><td>v0.6.7</td>
-<td><p><span>Added in: v0.6.7</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> filename or file descriptor</li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'a'</code>.</li>
-</ul>
-</li>
-</ul>
-<p>Synchronously append data to a file, creating the file if it does not yet
-exist. <code>data</code> can be a string or a <a href="#buffer_buffer"><code>Buffer</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  fs.appendFileSync(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The "data to append" was appended to file!'</span>);
-} <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-comment">/* Handle the error */</span>
-}</code></pre>
-<p>If <code>options</code> is a string, then it specifies the encoding:</p>
-<pre><code class="language-js">fs.appendFileSync(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>);</code></pre>
-<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened
-for appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will
-not be closed automatically.</p>
-<pre><code class="language-js"><span class="hljs-keyword">let</span> fd;
-
-<span class="hljs-keyword">try</span> {
-  fd = fs.openSync(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'a'</span>);
-  fs.appendFileSync(fd, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>);
-} <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-comment">/* Handle the error */</span>
-} <span class="hljs-keyword">finally</span> {
-  <span class="hljs-keyword">if</span> (fd !== <span class="hljs-literal">undefined</span>)
-    fs.closeSync(fd);
-}</code></pre>
-<h2><code>fs.chmod(path, mode, callback)</code><span><a class="mark" href="#fs_fs_chmod_path_mode_callback" id="fs_fs_chmod_path_mode_callback">#</a></span></h2>
+<h4><code>fs.chmod(path, mode, callback)</code><span><a class="mark" href="#fs_fs_chmod_path_mode_callback" id="fs_fs_chmod_path_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -30414,7 +32647,7 @@ not be closed automatically.</p>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.1.30</td>
@@ -30433,12 +32666,14 @@ not be closed automatically.</p>
 </ul>
 <p>Asynchronously changes the permissions of a file. No arguments other than a
 possible exception are given to the completion callback.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>.</p>
-<pre><code class="language-js">fs.chmod(<span class="hljs-string">'my_file.txt'</span>, <span class="hljs-number">0o775</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a> documentation for more detail.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { chmod } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">chmod</span>(<span class="hljs-string">'my_file.txt'</span>, <span class="hljs-number">0o775</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The permissions for file "my_file.txt" have been changed!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The permissions for file "my_file.txt" have been changed!'</span>);
 });</code></pre>
-<h3>File modes<span><a class="mark" href="#fs_file_modes" id="fs_file_modes">#</a></span></h3>
+<h5>File modes<span><a class="mark" href="#fs_file_modes" id="fs_file_modes">#</a></span></h5>
 <p>The <code>mode</code> argument used in both the <code>fs.chmod()</code> and <code>fs.chmodSync()</code>
 methods is a numeric bitmask created using a logical OR of the following
 constants:</p>
@@ -30558,26 +32793,7 @@ exposed in <code>fs.constants</code>.</p>
 <p>Caveats: on Windows only the write permission can be changed, and the
 distinction among the permissions of group, owner or others is not
 implemented.</p>
-<h2><code>fs.chmodSync(path, mode)</code><span><a class="mark" href="#fs_fs_chmodsync_path_mode" id="fs_fs_chmodsync_path_mode">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.6.7</td>
-<td><p><span>Added in: v0.6.7</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>.</p>
-<h2><code>fs.chown(path, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_chown_path_uid_gid_callback" id="fs_fs_chown_path_uid_gid_callback">#</a></span></h2>
+<h4><code>fs.chown(path, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_chown_path_uid_gid_callback" id="fs_fs_chown_path_uid_gid_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -30585,7 +32801,7 @@ this API: <a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.1.97</td>
@@ -30605,32 +32821,14 @@ this API: <a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.
 </ul>
 <p>Asynchronously changes owner and group of a file. No arguments other than a
 possible exception are given to the completion callback.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>.</p>
-<h2><code>fs.chownSync(path, uid, gid)</code><span><a class="mark" href="#fs_fs_chownsync_path_uid_gid" id="fs_fs_chownsync_path_uid_gid">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.97</td>
-<td><p><span>Added in: v0.1.97</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronously changes owner and group of a file. Returns <code>undefined</code>.
-This is the synchronous version of <a href="#fs_fs_chown_path_uid_gid_callback"><code>fs.chown()</code></a>.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>.</p>
-<h2><code>fs.close(fd, callback)</code><span><a class="mark" href="#fs_fs_close_fd_callback" id="fs_fs_close_fd_callback">#</a></span></h2>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.close(fd[, callback])</code><span><a class="mark" href="#fs_fs_close_fd_callback" id="fs_fs_close_fd_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>A default callback is now used if one is not provided.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.0.0</td>
@@ -30648,28 +32846,12 @@ This is the synchronous version of <a href="#fs_fs_chown_path_uid_gid_callback">
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/close.2.html"><code>close(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
+<p>Closes the file descriptor. No arguments other than a possible exception are
+given to the completion callback.</p>
 <p>Calling <code>fs.close()</code> on any file descriptor (<code>fd</code>) that is currently in use
 through any other <code>fs</code> operation may lead to undefined behavior.</p>
-<h2><code>fs.closeSync(fd)</code><span><a class="mark" href="#fs_fs_closesync_fd" id="fs_fs_closesync_fd">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.1.21</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/close.2.html"><code>close(2)</code></a>. Returns <code>undefined</code>.</p>
-<p>Calling <code>fs.closeSync()</code> on any file descriptor (<code>fd</code>) that is currently in use
-through any other <code>fs</code> operation may lead to undefined behavior.</p>
-<h2><code>fs.constants</code><span><a class="mark" href="#fs_fs_constants" id="fs_fs_constants">#</a></span></h2>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
-</ul>
-<p>Returns an object containing commonly used constants for file system
-operations. The specific constants currently defined are described in
-<a href="#fs_fs_constants_1">FS constants</a>.</p>
-<h2><code>fs.copyFile(src, dest[, flags], callback)</code><span><a class="mark" href="#fs_fs_copyfile_src_dest_flags_callback" id="fs_fs_copyfile_src_dest_flags_callback">#</a></span></h2>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/close.2.html"><code>close(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.copyFile(src, dest[, mode], callback)</code><span><a class="mark" href="#fs_fs_copyfile_src_dest_mode_callback" id="fs_fs_copyfile_src_dest_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -30684,7 +32866,7 @@ operations. The specific constants currently defined are described in
 <ul>
 <li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
 <li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
@@ -30692,7 +32874,7 @@ already exists. No arguments other than a possible exception are given to the
 callback function. Node.js makes no guarantees about the atomicity of the copy
 operation. If an error occurs after the destination file has been opened for
 writing, Node.js will attempt to remove the destination.</p>
-<p><code>flags</code> is an optional integer that specifies the behavior
+<p><code>mode</code> is an optional integer that specifies the behavior
 of the copy operation. It is possible to create a mask consisting of the bitwise
 OR of two or more values (e.g.
 <code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
@@ -30703,81 +32885,36 @@ exists.</li>
 copy-on-write reflink. If the platform does not support copy-on-write, then a
 fallback copy mechanism is used.</li>
 <li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.</li>
+create a copy-on-write reflink. If the platform does not support
+copy-on-write, then the operation will fail.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { copyFile, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
-fs.copyFile(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">callback</span>(<span class="hljs-params">err</span>) {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
-});</code></pre>
-<p>If the third argument is a number, then it specifies <code>flags</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> { COPYFILE_EXCL } = fs.constants;
-
-<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
-fs.copyFile(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, COPYFILE_EXCL, callback);</code></pre>
-<h2><code>fs.copyFileSync(src, dest[, flags])</code><span><a class="mark" href="#fs_fs_copyfilesync_src_dest_flags" id="fs_fs_copyfilesync_src_dest_flags">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v14.0.0</td>
-<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
-<tr><td>v8.5.0</td>
-<td><p><span>Added in: v8.5.0</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
-<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
-</ul>
-<p>Synchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
-already exists. Returns <code>undefined</code>. Node.js makes no guarantees about the
-atomicity of the copy operation. If an error occurs after the destination file
-has been opened for writing, Node.js will attempt to remove the destination.</p>
-<p><code>flags</code> is an optional integer that specifies the behavior
-of the copy operation. It is possible to create a mask consisting of the bitwise
-OR of two or more values (e.g.
-<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
-<ul>
-<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already
-exists.</li>
-<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a
-copy-on-write reflink. If the platform does not support copy-on-write, then a
-fallback copy mechanism is used.</li>
-<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.</li>
-</ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
+}
 
 <span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
-fs.copyFileSync(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);</code></pre>
-<p>If the third argument is a number, then it specifies <code>flags</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> { COPYFILE_EXCL } = fs.constants;
+<span class="hljs-title function_">copyFile</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, callback);
 
 <span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
-fs.copyFileSync(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, COPYFILE_EXCL);</code></pre>
-<h2><code>fs.createReadStream(path[, options])</code><span><a class="mark" href="#fs_fs_createreadstream_path_options" id="fs_fs_createreadstream_path_options">#</a></span></h2>
+<span class="hljs-title function_">copyFile</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, constants.<span class="hljs-property">COPYFILE_EXCL</span>, callback);</code></pre>
+<h4><code>fs.createReadStream(path[, options])</code><span><a class="mark" href="#fs_fs_createreadstream_path_options" id="fs_fs_createreadstream_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.0.0</td>
+<td><p>Change <code>emitClose</code> default to <code>true</code>.</p></td></tr>
+<tr><td>v13.6.0, v12.17.0</td>
 <td><p>The <code>fs</code> options allow overriding the used <code>fs</code> implementation.</p></td></tr>
 <tr><td>v12.10.0</td>
 <td><p>Enable <code>emitClose</code> option.</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>Impose new restrictions on <code>start</code> and <code>end</code>, throwing more appropriate errors in cases when we cannot reasonably handle the input values.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
 <tr><td>v2.3.0</td>
@@ -30797,7 +32934,7 @@ fs.copyFileSync(<span class="hljs-string">'source.txt'</span>, <span class="hljs
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
 <li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
 <li><code>autoClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
-<li><code>emitClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><code>emitClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
 <li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>Infinity</code></li>
 <li><code>highWaterMark</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>64 * 1024</code></li>
@@ -30814,33 +32951,34 @@ start counting at 0, allowed values are in the
 [0, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER"><code>Number.MAX_SAFE_INTEGER</code></a>] range. If <code>fd</code> is specified and <code>start</code> is
 omitted or <code>undefined</code>, <code>fs.createReadStream()</code> reads sequentially from the
 current file position. The <code>encoding</code> can be any one of those accepted by
-<a href="#buffer_buffer"><code>Buffer</code></a>.</p>
+<a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
 <p>If <code>fd</code> is specified, <code>ReadStream</code> will ignore the <code>path</code> argument and will use
 the specified file descriptor. This means that no <code>'open'</code> event will be
 emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s should be passed to
-<a href="#net_class_net_socket"><code>net.Socket</code></a>.</p>
+<a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
 <p>If <code>fd</code> points to a character device that only supports blocking reads
 (such as keyboard or sound card), read operations do not finish until data is
 available. This can prevent the process from exiting and the stream from
 closing naturally.</p>
-<p>By default, the stream will not emit a <code>'close'</code> event after it has been
-destroyed. This is the opposite of the default for other <code>Readable</code> streams.
-Set the <code>emitClose</code> option to <code>true</code> to change this behavior.</p>
+<p>By default, the stream will emit a <code>'close'</code> event after it has been
+destroyed, like most <code>Readable</code> streams.  Set the <code>emitClose</code> option to
+<code>false</code> to change this behavior.</p>
 <p>By providing the <code>fs</code> option, it is possible to override the corresponding <code>fs</code>
 implementations for <code>open</code>, <code>read</code>, and <code>close</code>. When providing the <code>fs</code> option,
 overrides for <code>open</code>, <code>read</code>, and <code>close</code> are required.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { createReadStream } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
 <span class="hljs-comment">// Create a stream from some character device.</span>
-<span class="hljs-keyword">const</span> stream = fs.createReadStream(<span class="hljs-string">'/dev/input/event0'</span>);
+<span class="hljs-keyword">const</span> stream = <span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'/dev/input/event0'</span>);
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  stream.close(); <span class="hljs-comment">// This may not close the stream.</span>
+  stream.<span class="hljs-title function_">close</span>(); <span class="hljs-comment">// This may not close the stream.</span>
   <span class="hljs-comment">// Artificially marking end-of-stream, as if the underlying resource had</span>
   <span class="hljs-comment">// indicated end-of-file by itself, allows the stream to close.</span>
   <span class="hljs-comment">// This does not cancel pending read operations, and if there is such an</span>
   <span class="hljs-comment">// operation, the process may still not be able to exit successfully</span>
   <span class="hljs-comment">// until it finishes.</span>
-  stream.push(<span class="hljs-literal">null</span>);
-  stream.read(<span class="hljs-number">0</span>);
+  stream.<span class="hljs-title function_">push</span>(<span class="hljs-literal">null</span>);
+  stream.<span class="hljs-title function_">read</span>(<span class="hljs-number">0</span>);
 }, <span class="hljs-number">100</span>);</code></pre>
 <p>If <code>autoClose</code> is false, then the file descriptor won't be closed, even if
 there's an error. It is the application's responsibility to close it and make
@@ -30850,19 +32988,23 @@ automatically.</p>
 <p><code>mode</code> sets the file mode (permission and sticky bits), but only if the
 file was created.</p>
 <p>An example to read the last 10 bytes of a file which is 100 bytes long:</p>
-<pre><code class="language-js">fs.createReadStream(<span class="hljs-string">'sample.txt'</span>, { <span class="hljs-attr">start</span>: <span class="hljs-number">90</span>, <span class="hljs-attr">end</span>: <span class="hljs-number">99</span> });</code></pre>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { createReadStream } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'sample.txt'</span>, { <span class="hljs-attr">start</span>: <span class="hljs-number">90</span>, <span class="hljs-attr">end</span>: <span class="hljs-number">99</span> });</code></pre>
 <p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<h2><code>fs.createWriteStream(path[, options])</code><span><a class="mark" href="#fs_fs_createwritestream_path_options" id="fs_fs_createwritestream_path_options">#</a></span></h2>
+<h4><code>fs.createWriteStream(path[, options])</code><span><a class="mark" href="#fs_fs_createwritestream_path_options" id="fs_fs_createwritestream_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.0.0</td>
+<td><p>Change <code>emitClose</code> default to <code>true</code>.</p></td></tr>
+<tr><td>v13.6.0, v12.17.0</td>
 <td><p>The <code>fs</code> options allow overriding the used <code>fs</code> implementation.</p></td></tr>
 <tr><td>v12.10.0</td>
 <td><p>Enable <code>emitClose</code> option.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
 <tr><td>v5.5.0</td>
@@ -30884,44 +33026,43 @@ file was created.</p>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
 <li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
 <li><code>autoClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
-<li><code>emitClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><code>emitClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
 <li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>fs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
 </ul>
 </li>
 <li>Returns: <a href="#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> See <a href="#stream_class_stream_writable">Writable Stream</a>.</li>
 </ul>
-<p><code>options</code> may also include a <code>start</code> option to allow writing data at
-some position past the beginning of the file, allowed values are in the
-[0, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER"><code>Number.MAX_SAFE_INTEGER</code></a>] range. Modifying a file rather
-than replacing it may require a <code>flags</code> mode of <code>r+</code> rather than the
-default mode <code>w</code>. The <code>encoding</code> can be any one of those accepted by
-<a href="#buffer_buffer"><code>Buffer</code></a>.</p>
+<p><code>options</code> may also include a <code>start</code> option to allow writing data at some
+position past the beginning of the file, allowed values are in the
+[0, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER"><code>Number.MAX_SAFE_INTEGER</code></a>] range. Modifying a file rather than replacing
+it may require the <code>flags</code> option to be set to <code>r+</code> rather than the default <code>w</code>.
+The <code>encoding</code> can be any one of those accepted by <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
 <p>If <code>autoClose</code> is set to true (default behavior) on <code>'error'</code> or <code>'finish'</code>
 the file descriptor will be closed automatically. If <code>autoClose</code> is false,
 then the file descriptor won't be closed, even if there's an error.
 It is the application's responsibility to close it and make sure there's no
 file descriptor leak.</p>
-<p>By default, the stream will not emit a <code>'close'</code> event after it has been
-destroyed. This is the opposite of the default for other <code>Writable</code> streams.
-Set the <code>emitClose</code> option to <code>true</code> to change this behavior.</p>
+<p>By default, the stream will emit a <code>'close'</code> event after it has been
+destroyed, like most <code>Writable</code> streams.  Set the <code>emitClose</code> option to
+<code>false</code> to change this behavior.</p>
 <p>By providing the <code>fs</code> option it is possible to override the corresponding <code>fs</code>
 implementations for <code>open</code>, <code>write</code>, <code>writev</code> and <code>close</code>. Overriding <code>write()</code>
 without <code>writev()</code> can reduce performance as some optimizations (<code>_writev()</code>)
 will be disabled. When providing the <code>fs</code> option,  overrides for <code>open</code>,
 <code>close</code>, and at least one of <code>write</code> and <code>writev</code> are required.</p>
-<p>Like <a href="#fs_class_fs_readstream"><code>ReadStream</code></a>, if <code>fd</code> is specified, <a href="#fs_class_fs_writestream"><code>WriteStream</code></a> will ignore the
+<p>Like <a href="#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a>, if <code>fd</code> is specified, <a href="#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> will ignore the
 <code>path</code> argument and will use the specified file descriptor. This means that no
 <code>'open'</code> event will be emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s
-should be passed to <a href="#net_class_net_socket"><code>net.Socket</code></a>.</p>
+should be passed to <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
 <p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<h2><code>fs.exists(path, callback)</code><span><a class="mark" href="#fs_fs_exists_path_callback" id="fs_fs_exists_path_callback">#</a></span></h2>
+<h4><code>fs.exists(path, callback)</code><span><a class="mark" href="#fs_fs_exists_path_callback" id="fs_fs_exists_path_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v1.0.0</td>
 <td><p><span>Deprecated since: v1.0.0</span></p></td></tr>
 <tr><td>v0.0.2</td>
@@ -30940,8 +33081,10 @@ should be passed to <a href="#net_class_net_socket"><code>net.Socket</code></a>.
 </ul>
 <p>Test whether or not the given path exists by checking with the file system.
 Then call the <code>callback</code> argument with either true or false:</p>
-<pre><code class="language-js">fs.exists(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-function">(<span class="hljs-params">exists</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(exists ? <span class="hljs-string">'it\'s there'</span> : <span class="hljs-string">'no passwd!'</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { exists } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">exists</span>(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(e ? <span class="hljs-string">'it exists'</span> : <span class="hljs-string">'no passwd!'</span>);
 });</code></pre>
 <p><strong>The parameters for this callback are not consistent with other Node.js
 callbacks.</strong> Normally, the first parameter to a Node.js callback is an <code>err</code>
@@ -30954,52 +33097,85 @@ so introduces a race condition, since other processes may change the file's
 state between the two calls. Instead, user code should open/read/write the
 file directly and handle the error raised if the file does not exist.</p>
 <p><strong>write (NOT RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.exists(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">exists</span>) =></span> {
-  <span class="hljs-keyword">if</span> (exists) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile already exists'</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { exists, open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">exists</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-keyword">if</span> (e) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile already exists'</span>);
   } <span class="hljs-keyword">else</span> {
-    fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+    <span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
       <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-      writeMyData(fd);
+
+      <span class="hljs-keyword">try</span> {
+        <span class="hljs-title function_">writeMyData</span>(fd);
+      } <span class="hljs-keyword">finally</span> {
+        <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+          <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+        });
+      }
     });
   }
 });</code></pre>
 <p><strong>write (RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'EEXIST'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile already exists'</span>);
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'EEXIST'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile already exists'</span>);
       <span class="hljs-keyword">return</span>;
     }
 
     <span class="hljs-keyword">throw</span> err;
   }
 
-  writeMyData(fd);
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">writeMyData</span>(fd);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  }
 });</code></pre>
 <p><strong>read (NOT RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.exists(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">exists</span>) =></span> {
-  <span class="hljs-keyword">if</span> (exists) {
-    fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close, exists } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">exists</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-keyword">if</span> (e) {
+    <span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
       <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-      readMyData(fd);
+
+      <span class="hljs-keyword">try</span> {
+        <span class="hljs-title function_">readMyData</span>(fd);
+      } <span class="hljs-keyword">finally</span> {
+        <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+          <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+        });
+      }
     });
   } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile does not exist'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile does not exist'</span>);
   }
 });</code></pre>
 <p><strong>read (RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ENOENT'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile does not exist'</span>);
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ENOENT'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile does not exist'</span>);
       <span class="hljs-keyword">return</span>;
     }
 
     <span class="hljs-keyword">throw</span> err;
   }
 
-  readMyData(fd);
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">readMyData</span>(fd);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  }
 });</code></pre>
 <p>The "not recommended" examples above check for existence and then use the
 file; the "recommended" examples are better because they use the file directly
@@ -31007,32 +33183,7 @@ and handle the error, if any.</p>
 <p>In general, check for the existence of a file only if the file won’t be
 used directly, for example when its existence is a signal from another
 process.</p>
-<h2><code>fs.existsSync(path)</code><span><a class="mark" href="#fs_fs_existssync_path" id="fs_fs_existssync_path">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Returns <code>true</code> if the path exists, <code>false</code> otherwise.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_exists_path_callback"><code>fs.exists()</code></a>.</p>
-<p><code>fs.exists()</code> is deprecated, but <code>fs.existsSync()</code> is not. The <code>callback</code>
-parameter to <code>fs.exists()</code> accepts parameters that are inconsistent with other
-Node.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (fs.existsSync(<span class="hljs-string">'/etc/passwd'</span>)) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The path exists.'</span>);
-}</code></pre>
-<h2><code>fs.fchmod(fd, mode, callback)</code><span><a class="mark" href="#fs_fs_fchmod_fd_mode_callback" id="fs_fs_fchmod_fd_mode_callback">#</a></span></h2>
+<h4><code>fs.fchmod(fd, mode, callback)</code><span><a class="mark" href="#fs_fs_fchmod_fd_mode_callback" id="fs_fs_fchmod_fd_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31055,18 +33206,10 @@ Node.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fchmod.2.html"><code>fchmod(2)</code></a>. No arguments other than a possible exception
+<p>Sets the permissions on the file. No arguments other than a possible exception
 are given to the completion callback.</p>
-<h2><code>fs.fchmodSync(fd, mode)</code><span><a class="mark" href="#fs_fs_fchmodsync_fd_mode" id="fs_fs_fchmodsync_fd_mode">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.4.7</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fchmod.2.html"><code>fchmod(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.fchown(fd, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_fchown_fd_uid_gid_callback" id="fs_fs_fchown_fd_uid_gid_callback">#</a></span></h2>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fchmod.2.html"><code>fchmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fchown(fd, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_fchown_fd_uid_gid_callback" id="fs_fs_fchown_fd_uid_gid_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31090,19 +33233,10 @@ are given to the completion callback.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fchown.2.html"><code>fchown(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
-<h2><code>fs.fchownSync(fd, uid, gid)</code><span><a class="mark" href="#fs_fs_fchownsync_fd_uid_gid" id="fs_fs_fchownsync_fd_uid_gid">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.4.7</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fchown.2.html"><code>fchown(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.fdatasync(fd, callback)</code><span><a class="mark" href="#fs_fs_fdatasync_fd_callback" id="fs_fs_fdatasync_fd_callback">#</a></span></h2>
+<p>Sets the owner of the file. No arguments other than a possible exception are
+given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fchown.2.html"><code>fchown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fdatasync(fd, callback)</code><span><a class="mark" href="#fs_fs_fdatasync_fd_callback" id="fs_fs_fdatasync_fd_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31124,17 +33258,11 @@ to the completion callback.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a>. No arguments other than a possible exception are
-given to the completion callback.</p>
-<h2><code>fs.fdatasyncSync(fd)</code><span><a class="mark" href="#fs_fs_fdatasyncsync_fd" id="fs_fs_fdatasyncsync_fd">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.1.96</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.fstat(fd[, options], callback)</code><span><a class="mark" href="#fs_fs_fstat_fd_options_callback" id="fs_fs_fstat_fd_options_callback">#</a></span></h2>
+<p>Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+<a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a> documentation for details. No arguments other than a possible
+exception are given to the completion callback.</p>
+<h4><code>fs.fstat(fd[, options], callback)</code><span><a class="mark" href="#fs_fs_fstat_fd_options_callback" id="fs_fs_fstat_fd_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31155,7 +33283,7 @@ given to the completion callback.</p>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -31165,33 +33293,9 @@ given to the completion callback.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fstat.2.html"><code>fstat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where
-<code>stats</code> is an <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object. <code>fstat()</code> is identical to <a href="#fs_fs_stat_path_options_callback"><code>stat()</code></a>,
-except that the file to be stat-ed is specified by the file descriptor <code>fd</code>.</p>
-<h2><code>fs.fstatSync(fd[, options])</code><span><a class="mark" href="#fs_fs_fstatsync_fd_options" id="fs_fs_fstatsync_fd_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v0.1.95</td>
-<td><p><span>Added in: v0.1.95</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
-</ul>
-</li>
-<li>Returns: <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fstat.2.html"><code>fstat(2)</code></a>.</p>
-<h2><code>fs.fsync(fd, callback)</code><span><a class="mark" href="#fs_fs_fsync_fd_callback" id="fs_fs_fsync_fd_callback">#</a></span></h2>
+<p>Invokes the callback with the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the file descriptor.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fstat.2.html"><code>fstat(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fsync(fd, callback)</code><span><a class="mark" href="#fs_fs_fsync_fd_callback" id="fs_fs_fsync_fd_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31213,17 +33317,11 @@ except that the file to be stat-ed is specified by the file descriptor <code>fd<
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
-<h2><code>fs.fsyncSync(fd)</code><span><a class="mark" href="#fs_fs_fsyncsync_fd" id="fs_fs_fsyncsync_fd">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.1.96</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.ftruncate(fd[, len], callback)</code><span><a class="mark" href="#fs_fs_ftruncate_fd_len_callback" id="fs_fs_ftruncate_fd_len_callback">#</a></span></h2>
+<p>Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a> documentation for more detail. No arguments other
+than a possible exception are given to the completion callback.</p>
+<h4><code>fs.ftruncate(fd[, len], callback)</code><span><a class="mark" href="#fs_fs_ftruncate_fd_len_callback" id="fs_fs_ftruncate_fd_len_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31246,52 +33344,38 @@ to the completion callback.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/ftruncate.2.html"><code>ftruncate(2)</code></a>. No arguments other than a possible exception are
+<p>Truncates the file descriptor. No arguments other than a possible exception are
 given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/ftruncate.2.html"><code>ftruncate(2)</code></a> documentation for more detail.</p>
 <p>If the file referred to by the file descriptor was larger than <code>len</code> bytes, only
 the first <code>len</code> bytes will be retained in the file.</p>
 <p>For example, the following program retains only the first four bytes of the
 file:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-<span class="hljs-comment">// Prints: Node.js</span>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close, ftruncate } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">// get the file descriptor of the file to be truncated</span>
-<span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">closeFd</span>(<span class="hljs-params">fd</span>) {
+  <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  });
+}
 
-<span class="hljs-comment">// Truncate the file to first four bytes</span>
-fs.ftruncate(fd, <span class="hljs-number">4</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  assert.ifError(err);
-  <span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-});
-<span class="hljs-comment">// Prints: Node</span></code></pre>
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">ftruncate</span>(fd, <span class="hljs-number">4</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-title function_">closeFd</span>(fd);
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-title function_">closeFd</span>(fd);
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  }
+});</code></pre>
 <p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the
 extended part is filled with null bytes (<code>'\0'</code>):</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-<span class="hljs-comment">// Prints: Node.js</span>
-
-<span class="hljs-comment">// get the file descriptor of the file to be truncated</span>
-<span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
-
-<span class="hljs-comment">// Truncate the file to 10 bytes, whereas the actual size is 7 bytes</span>
-fs.ftruncate(fd, <span class="hljs-number">10</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  assert.ifError(err);
-  <span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>));
-});
-<span class="hljs-comment">// Prints: &#x3C;Buffer 4e 6f 64 65 2e 6a 73 00 00 00></span>
-<span class="hljs-comment">// ('Node.js\0\0\0' in UTF8)</span></code></pre>
-<p>The last three bytes are null bytes (<code>'\0'</code>), to compensate the over-truncation.</p>
-<h2><code>fs.ftruncateSync(fd[, len])</code><span><a class="mark" href="#fs_fs_ftruncatesync_fd_len" id="fs_fs_ftruncatesync_fd_len">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.8.6</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-</ul>
-<p>Returns <code>undefined</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate()</code></a>.</p>
-<h2><code>fs.futimes(fd, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_futimes_fd_atime_mtime_callback" id="fs_fs_futimes_fd_atime_mtime_callback">#</a></span></h2>
+<p>If <code>len</code> is negative then <code>0</code> will be used.</p>
+<h4><code>fs.futimes(fd, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_futimes_fd_atime_mtime_callback" id="fs_fs_futimes_fd_atime_mtime_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31321,25 +33405,7 @@ this API: <a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate()</code>
 descriptor. See <a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>.</p>
 <p>This function does not work on AIX versions before 7.1, it will return the
 error <code>UV_ENOSYS</code>.</p>
-<h2><code>fs.futimesSync(fd, atime, mtime)</code><span><a class="mark" href="#fs_fs_futimessync_fd_atime_mtime" id="fs_fs_futimessync_fd_atime_mtime">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.1.0</td>
-<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
-<tr><td>v0.4.2</td>
-<td><p><span>Added in: v0.4.2</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-</ul>
-<p>Synchronous version of <a href="#fs_fs_futimes_fd_atime_mtime_callback"><code>fs.futimes()</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.lchmod(path, mode, callback)</code><span><a class="mark" href="#fs_fs_lchmod_path_mode_callback" id="fs_fs_lchmod_path_mode_callback">#</a></span></h2>
+<h4><code>fs.lchmod(path, mode, callback)</code><span><a class="mark" href="#fs_fs_lchmod_path_mode_callback" id="fs_fs_lchmod_path_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31362,19 +33428,11 @@ error <code>UV_ENOSYS</code>.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="https://www.freebsd.org/cgi/man.cgi?query=lchmod&#x26;sektion=2"><code>lchmod(2)</code></a>. No arguments other than a possible exception
-are given to the completion callback.</p>
-<p>Only available on macOS.</p>
-<h2><code>fs.lchmodSync(path, mode)</code><span><a class="mark" href="#fs_fs_lchmodsync_path_mode" id="fs_fs_lchmodsync_path_mode">#</a></span></h2>
-<div class="api_metadata">
-<span>Deprecated since: v0.4.7</span>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="https://www.freebsd.org/cgi/man.cgi?query=lchmod&#x26;sektion=2"><code>lchmod(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.lchown(path, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_lchown_path_uid_gid_callback" id="fs_fs_lchown_path_uid_gid_callback">#</a></span></h2>
+<p>Changes the permissions on a symbolic link. No arguments other than a possible
+exception are given to the completion callback.</p>
+<p>This method is only implemented on macOS.</p>
+<p>See the POSIX <a href="https://www.freebsd.org/cgi/man.cgi?query=lchmod&#x26;sektion=2"><code>lchmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.lchown(path, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_lchown_path_uid_gid_callback" id="fs_fs_lchown_path_uid_gid_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31400,29 +33458,12 @@ are given to the completion callback.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/lchown.2.html"><code>lchown(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
-<h2><code>fs.lchownSync(path, uid, gid)</code><span><a class="mark" href="#fs_fs_lchownsync_path_uid_gid" id="fs_fs_lchownsync_path_uid_gid">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.6.0</td>
-<td><p>This API is no longer deprecated.</p></td></tr>
-<tr><td>v0.4.7</td>
-<td><p>Documentation-only deprecation.</p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/lchown.2.html"><code>lchown(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.lutimes(path, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_lutimes_path_atime_mtime_callback" id="fs_fs_lutimes_path_atime_mtime_callback">#</a></span></h2>
+<p>Set the owner of the symbolic link. No arguments other than a possible
+exception are given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/lchown.2.html"><code>lchown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.lutimes(path, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_lutimes_path_atime_mtime_callback" id="fs_fs_lutimes_path_atime_mtime_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0, v12.19.0</span>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
@@ -31440,19 +33481,7 @@ link, then the link is not dereferenced: instead, the timestamps of the
 symbolic link itself are changed.</p>
 <p>No arguments other than a possible exception are given to the completion
 callback.</p>
-<h2><code>fs.lutimesSync(path, atime, mtime)</code><span><a class="mark" href="#fs_fs_lutimessync_path_atime_mtime" id="fs_fs_lutimessync_path_atime_mtime">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.19.0</span>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-</ul>
-<p>Change the file system timestamps of the symbolic link referenced by <code>path</code>.
-Returns <code>undefined</code>, or throws an exception when parameters are incorrect or
-the operation fails. This is the synchronous version of <a href="#fs_fs_lutimes_path_atime_mtime_callback"><code>fs.lutimes()</code></a>.</p>
-<h2><code>fs.link(existingPath, newPath, callback)</code><span><a class="mark" href="#fs_fs_link_existingpath_newpath_callback" id="fs_fs_link_existingpath_newpath_callback">#</a></span></h2>
+<h4><code>fs.link(existingPath, newPath, callback)</code><span><a class="mark" href="#fs_fs_link_existingpath_newpath_callback" id="fs_fs_link_existingpath_newpath_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31477,26 +33506,10 @@ the operation fails. This is the synchronous version of <a href="#fs_fs_lutimes_
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>. No arguments other than a possible exception are given to
-the completion callback.</p>
-<h2><code>fs.linkSync(existingPath, newPath)</code><span><a class="mark" href="#fs_fs_linksync_existingpath_newpath" id="fs_fs_linksync_existingpath_newpath">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>existingPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.lstat(path[, options], callback)</code><span><a class="mark" href="#fs_fs_lstat_path_options_callback" id="fs_fs_lstat_path_options_callback">#</a></span></h2>
+<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX
+<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a> documentation for more detail. No arguments other than a possible
+exception are given to the completion callback.</p>
+<h4><code>fs.lstat(path[, options], callback)</code><span><a class="mark" href="#fs_fs_lstat_path_options_callback" id="fs_fs_lstat_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31506,7 +33519,7 @@ the completion callback.</p>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.1.30</td>
@@ -31519,7 +33532,7 @@ the completion callback.</p>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -31529,48 +33542,24 @@ the completion callback.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where
-<code>stats</code> is a <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object. <code>lstat()</code> is identical to <code>stat()</code>,
-except that if <code>path</code> is a symbolic link, then the link itself is stat-ed,
-not the file that it refers to.</p>
-<h2><code>fs.lstatSync(path[, options])</code><span><a class="mark" href="#fs_fs_lstatsync_path_options" id="fs_fs_lstatsync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.30</td>
-<td><p><span>Added in: v0.1.30</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
-</ul>
-</li>
-<li>Returns: <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a>.</p>
-<h2><code>fs.mkdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_mkdir_path_options_callback" id="fs_fs_mkdir_path_options_callback">#</a></span></h2>
+<p>Retrieves the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the symbolic link referred to by the path.
+The callback gets two arguments <code>(err, stats)</code> where <code>stats</code> is a <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a>
+object. <code>lstat()</code> is identical to <code>stat()</code>, except that if <code>path</code> is a symbolic
+link, then the link itself is stat-ed, not the file that it refers to.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a> documentation for more details.</p>
+<h4><code>fs.mkdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_mkdir_path_options_callback" id="fs_fs_mkdir_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.11.0, v12.17.0</td>
 <td><p>In <code>recursive</code> mode, the callback now receives the first created path as an argument.</p></td></tr>
 <tr><td>v10.12.0</td>
 <td><p>The second argument can now be an <code>options</code> object with <code>recursive</code> and <code>mode</code> properties.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.1.8</td>
@@ -31594,57 +33583,35 @@ not the file that it refers to.</p>
 </ul>
 <p>Asynchronously creates a directory.</p>
 <p>The callback is given a possible exception and, if <code>recursive</code> is <code>true</code>, the
-first directory path created, <code>(err, [path])</code>.</p>
-<p>The optional <code>options</code> argument can be an integer specifying mode (permission
+first directory path created, <code>(err, [path])</code>.
+<code>path</code> can still be <code>undefined</code> when <code>recursive</code> is <code>true</code>, if no directory was
+created.</p>
+<p>The optional <code>options</code> argument can be an integer specifying <code>mode</code> (permission
 and sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>
 property indicating whether parent directories should be created. Calling
 <code>fs.mkdir()</code> when <code>path</code> is a directory that exists results in an error only
 when <code>recursive</code> is false.</p>
-<pre><code class="language-js"><span class="hljs-comment">// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.</span>
-fs.mkdir(<span class="hljs-string">'/tmp/a/apple'</span>, { <span class="hljs-attr">recursive</span>: <span class="hljs-literal">true</span> }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { mkdir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.</span>
+<span class="hljs-title function_">mkdir</span>(<span class="hljs-string">'/tmp/a/apple'</span>, { <span class="hljs-attr">recursive</span>: <span class="hljs-literal">true</span> }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
 });</code></pre>
 <p>On Windows, using <code>fs.mkdir()</code> on the root directory even with recursion will
 result in an error:</p>
-<pre><code class="language-js">fs.mkdir(<span class="hljs-string">'/'</span>, { <span class="hljs-attr">recursive</span>: <span class="hljs-literal">true</span> }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { mkdir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">mkdir</span>(<span class="hljs-string">'/'</span>, { <span class="hljs-attr">recursive</span>: <span class="hljs-literal">true</span> }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-comment">// => [Error: EPERM: operation not permitted, mkdir 'C:\']</span>
 });</code></pre>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/mkdir.2.html"><code>mkdir(2)</code></a>.</p>
-<h2><code>fs.mkdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_mkdirsync_path_options" id="fs_fs_mkdirsync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>In <code>recursive</code> mode, the first created path is returned now.</p></td></tr>
-<tr><td>v10.12.0</td>
-<td><p>The second argument can now be an <code>options</code> object with <code>recursive</code> and <code>mode</code> properties.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
-<ul>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
-</ul>
-<p>Synchronously creates a directory. Returns <code>undefined</code>, or if <code>recursive</code> is
-<code>true</code>, the first directory path created.
-This is the synchronous version of <a href="#fs_fs_mkdir_path_options_callback"><code>fs.mkdir()</code></a>.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/mkdir.2.html"><code>mkdir(2)</code></a>.</p>
-<h2><code>fs.mkdtemp(prefix[, options], callback)</code><span><a class="mark" href="#fs_fs_mkdtemp_prefix_options_callback" id="fs_fs_mkdtemp_prefix_options_callback">#</a></span></h2>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/mkdir.2.html"><code>mkdir(2)</code></a> documentation for more details.</p>
+<h4><code>fs.mkdtemp(prefix[, options], callback)</code><span><a class="mark" href="#fs_fs_mkdtemp_prefix_options_callback" id="fs_fs_mkdtemp_prefix_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>prefix</code> parameter now accepts an empty string.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.0.0</td>
@@ -31680,9 +33647,11 @@ trailing <code>X</code> characters in <code>prefix</code> with random characters
 parameter.</p>
 <p>The optional <code>options</code> argument can be a string specifying an encoding, or an
 object with an <code>encoding</code> property specifying the character encoding to use.</p>
-<pre><code class="language-js">fs.mkdtemp(path.join(os.tmpdir(), <span class="hljs-string">'foo-'</span>), <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { mkdtemp } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">mkdtemp</span>(path.<span class="hljs-title function_">join</span>(os.<span class="hljs-title function_">tmpdir</span>(), <span class="hljs-string">'foo-'</span>), <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(directory);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(directory);
   <span class="hljs-comment">// Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2</span>
 });</code></pre>
 <p>The <code>fs.mkdtemp()</code> method will append the six randomly selected characters
@@ -31690,46 +33659,31 @@ directly to the <code>prefix</code> string. For instance, given a directory <cod
 intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the <code>prefix</code>
 must end with a trailing platform-specific path separator
 (<code>require('path').sep</code>).</p>
-<pre><code class="language-js"><span class="hljs-comment">// The parent directory for the new temporary directory</span>
-<span class="hljs-keyword">const</span> tmpDir = os.tmpdir();
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { tmpdir } <span class="hljs-keyword">from</span> <span class="hljs-string">'os'</span>;
+<span class="hljs-keyword">import</span> { mkdtemp } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// The parent directory for the new temporary directory</span>
+<span class="hljs-keyword">const</span> tmpDir = <span class="hljs-title function_">tmpdir</span>();
 
 <span class="hljs-comment">// This method is *INCORRECT*:</span>
-fs.mkdtemp(tmpDir, <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
+<span class="hljs-title function_">mkdtemp</span>(tmpDir, <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(directory);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(directory);
   <span class="hljs-comment">// Will print something similar to `/tmpabc123`.</span>
   <span class="hljs-comment">// A new temporary directory is created at the file system root</span>
   <span class="hljs-comment">// rather than *within* the /tmp directory.</span>
 });
 
 <span class="hljs-comment">// This method is *CORRECT*:</span>
-<span class="hljs-keyword">const</span> { sep } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);
-fs.mkdtemp(<span class="hljs-string">`<span class="hljs-subst">${tmpDir}</span><span class="hljs-subst">${sep}</span>`</span>, <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
+<span class="hljs-keyword">import</span> { sep } <span class="hljs-keyword">from</span> <span class="hljs-string">'path'</span>;
+<span class="hljs-title function_">mkdtemp</span>(<span class="hljs-string">`<span class="hljs-subst">${tmpDir}</span><span class="hljs-subst">${sep}</span>`</span>, <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(directory);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(directory);
   <span class="hljs-comment">// Will print something similar to `/tmp/abc123`.</span>
   <span class="hljs-comment">// A new temporary directory is created within</span>
   <span class="hljs-comment">// the /tmp directory.</span>
 });</code></pre>
-<h2><code>fs.mkdtempSync(prefix[, options])</code><span><a class="mark" href="#fs_fs_mkdtempsync_prefix_options" id="fs_fs_mkdtempsync_prefix_options">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v5.10.0</span>
-</div>
-<ul>
-<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-</ul>
-<p>Returns the created directory path.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_mkdtemp_prefix_options_callback"><code>fs.mkdtemp()</code></a>.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use.</p>
-<h2><code>fs.open(path[, flags[, mode]], callback)</code><span><a class="mark" href="#fs_fs_open_path_flags_mode_callback" id="fs_fs_open_path_flags_mode_callback">#</a></span></h2>
+<h4><code>fs.open(path[, flags[, mode]], callback)</code><span><a class="mark" href="#fs_fs_open_path_flags_mode_callback" id="fs_fs_open_path_flags_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31737,9 +33691,9 @@ object with an <code>encoding</code> property specifying the character encoding
 <tr><td>v11.1.0</td>
 <td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
 <tr><td>v9.9.0</td>
-<td><p>The <code>as</code> and <code>as+</code> modes are supported now.</p></td></tr>
+<td><p>The <code>as</code> and <code>as+</code> flags are supported now.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v0.0.2</td>
 <td><p><span>Added in: v0.0.2</span></p></td></tr>
 </tbody></table>
@@ -31757,7 +33711,7 @@ object with an <code>encoding</code> property specifying the character encoding
 </ul>
 </li>
 </ul>
-<p>Asynchronous file open. See <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a>.</p>
+<p>Asynchronous file open. See the POSIX <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a> documentation for more details.</p>
 <p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was
 created. On Windows, only the write permission can be manipulated; see
 <a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.</p>
@@ -31768,12 +33722,12 @@ a colon, Node.js will open a file system stream, as described by
 <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams">this MSDN page</a>.</p>
 <p>Functions based on <code>fs.open()</code> exhibit this behavior as well:
 <code>fs.writeFile()</code>, <code>fs.readFile()</code>, etc.</p>
-<h2><code>fs.opendir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_opendir_path_options_callback" id="fs_fs_opendir_path_options_callback">#</a></span></h2>
+<h4><code>fs.opendir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_opendir_path_options_callback" id="fs_fs_opendir_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.1.0, v12.16.0</td>
 <td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
 <tr><td>v12.12.0</td>
 <td><p><span>Added in: v12.12.0</span></p></td></tr>
@@ -31797,67 +33751,13 @@ performance but higher memory usage. <strong>Default:</strong> <code>32</code></
 </ul>
 </li>
 </ul>
-<p>Asynchronously open a directory. See <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a>.</p>
-<p>Creates an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a>, which contains all further functions for reading from
-and cleaning up the directory.</p>
-<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
-directory and subsequent read operations.</p>
-<h2><code>fs.opendirSync(path[, options])</code><span><a class="mark" href="#fs_fs_opendirsync_path_options" id="fs_fs_opendirsync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
-<tr><td>v12.12.0</td>
-<td><p><span>Added in: v12.12.0</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
-internally when reading from the directory. Higher values lead to better
-performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
-</ul>
-</li>
-<li>Returns: <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a></li>
-</ul>
-<p>Synchronously open a directory. See <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a>.</p>
-<p>Creates an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a>, which contains all further functions for reading from
+<p>Asynchronously open a directory. See the POSIX <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a> documentation for
+more details.</p>
+<p>Creates an <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>, which contains all further functions for reading from
 and cleaning up the directory.</p>
 <p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
 directory and subsequent read operations.</p>
-<h2><code>fs.openSync(path[, flags, mode])</code><span><a class="mark" href="#fs_fs_opensync_path_flags_mode" id="fs_fs_opensync_path_flags_mode">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.1.0</td>
-<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
-<tr><td>v9.9.0</td>
-<td><p>The <code>as</code> and <code>as+</code> modes are supported now.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>'r'</code>.
-See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.</li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-<p>Returns an integer representing the file descriptor.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>.</p>
-<h2><code>fs.read(fd, buffer, offset, length, position, callback)</code><span><a class="mark" href="#fs_fs_read_fd_buffer_offset_length_position_callback" id="fs_fs_read_fd_buffer_offset_length_position_callback">#</a></span></h2>
+<h4><code>fs.read(fd, buffer, offset, length, position, callback)</code><span><a class="mark" href="#fs_fs_read_fd_buffer_offset_length_position_callback" id="fs_fs_read_fd_buffer_offset_length_position_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31875,10 +33775,16 @@ this API: <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code><
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The buffer that the data will be
+written to. <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The position in <code>buffer</code> to write the data to. <strong>Default:</strong>
+<code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes to read. <strong>Default:</strong>
+<code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> Specifies where to begin reading from in the
+file. If <code>position</code> is <code>null</code> or <code>-1 </code>, data will be read from the current
+file position, and the file position will be updated. If <code>position</code> is an
+integer, the file position will be unchanged.</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
@@ -31888,25 +33794,20 @@ this API: <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code><
 </li>
 </ul>
 <p>Read data from the file specified by <code>fd</code>.</p>
-<p><code>buffer</code> is the buffer that the data (read from the fd) will be written to.</p>
-<p><code>offset</code> is the offset in the buffer to start writing at.</p>
-<p><code>length</code> is an integer specifying the number of bytes to read.</p>
-<p><code>position</code> is an argument specifying where to begin reading from in the file.
-If <code>position</code> is <code>null</code>, data will be read from the current file position,
-and the file position will be updated.
-If <code>position</code> is an integer, the file position will remain unchanged.</p>
 <p>The callback is given the three arguments, <code>(err, bytesRead, buffer)</code>.</p>
+<p>If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.</p>
 <p>If this method is invoked as its <a href="#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
-a <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> and <code>buffer</code> properties.</p>
-<h2><code>fs.read(fd, [options,] callback)</code><span><a class="mark" href="#fs_fs_read_fd_options_callback" id="fs_fs_read_fd_options_callback">#</a></span></h2>
+a promise for an <code>Object</code> with <code>bytesRead</code> and <code>buffer</code> properties.</p>
+<h4><code>fs.read(fd, [options,] callback)</code><span><a class="mark" href="#fs_fs_read_fd_options_callback" id="fs_fs_read_fd_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>Options object can be passed in to make Buffer, offset, length and position optional</p></td></tr>
-<tr><td>v12.17.0</td>
-<td><p><span>Added in: v12.17.0</span></p></td></tr>
+<tr><td>v13.11.0, v12.17.0</td>
+<td><p><span>Added in: v13.11.0, v12.17.0</span></p></td></tr>
+<tr><td>v13.11.0, v12.17.0</td>
+<td><p>Options object can be passed in to make Buffer, offset, length and position optional.</p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -31916,8 +33817,8 @@ a <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> an
 <ul>
 <li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
 <li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.length</code></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> <strong>Default:</strong> <code>null</code></li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -31928,9 +33829,10 @@ a <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> an
 </ul>
 </li>
 </ul>
-<p>Similar to the above <code>fs.read</code> function, this version takes an optional <code>options</code> object.
-If no <code>options</code> object is specified, it will default with the above values.</p>
-<h2><code>fs.readdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readdir_path_options_callback" id="fs_fs_readdir_path_options_callback">#</a></span></h2>
+<p>Similar to the <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a> function, this version takes an optional
+<code>options</code> object. If no <code>options</code> object is specified, it will default with the
+above values.</p>
+<h4><code>fs.readdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readdir_path_options_callback" id="fs_fs_readdir_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -31940,7 +33842,7 @@ If no <code>options</code> object is specified, it will default with the above v
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v6.0.0</td>
@@ -31965,55 +33867,27 @@ If no <code>options</code> object is specified, it will default with the above v
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a>. Reads the contents of a directory.
-The callback gets two arguments <code>(err, files)</code> where <code>files</code> is an array of
-the names of the files in the directory excluding <code>'.'</code> and <code>'..'</code>.</p>
+<p>Reads the contents of a directory. The callback gets two arguments <code>(err, files)</code>
+where <code>files</code> is an array of the names of the files in the directory excluding
+<code>'.'</code> and <code>'..'</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> documentation for more details.</p>
 <p>The optional <code>options</code> argument can be a string specifying an encoding, or an
 object with an <code>encoding</code> property specifying the character encoding to use for
 the filenames passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the filenames returned will be passed as <code>Buffer</code> objects.</p>
+the filenames returned will be passed as <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> objects.</p>
 <p>If <code>options.withFileTypes</code> is set to <code>true</code>, the <code>files</code> array will contain
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a> objects.</p>
-<h2><code>fs.readdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_readdirsync_path_options" id="fs_fs_readdirsync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.10.0</td>
-<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent[]></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a>.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the filenames returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the filenames returned will be passed as <code>Buffer</code> objects.</p>
-<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the result will contain
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a> objects.</p>
-<h2><code>fs.readFile(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readfile_path_options_callback" id="fs_fs_readfile_path_options_callback">#</a></span></h2>
+<a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> objects.</p>
+<h4><code>fs.readFile(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readfile_path_options_callback" id="fs_fs_readfile_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>The options argument may include an AbortSignal to abort an ongoing readFile request.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v5.1.0</td>
@@ -32031,6 +33905,7 @@ the filenames returned will be passed as <code>Buffer</code> objects.</p>
 <ul>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
 <li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress readFile</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -32041,31 +33916,50 @@ the filenames returned will be passed as <code>Buffer</code> objects.</p>
 </li>
 </ul>
 <p>Asynchronously reads the entire contents of a file.</p>
-<pre><code class="language-js">fs.readFile(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(data);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
 });</code></pre>
 <p>The callback is passed two arguments <code>(err, data)</code>, where <code>data</code> is the
 contents of the file.</p>
 <p>If no encoding is specified, then the raw buffer is returned.</p>
 <p>If <code>options</code> is a string, then it specifies the encoding:</p>
-<pre><code class="language-js">fs.readFile(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
 <p>When the path is a directory, the behavior of <code>fs.readFile()</code> and
 <a href="#fs_fs_readfilesync_path_options"><code>fs.readFileSync()</code></a> is platform-specific. On macOS, Linux, and Windows, an
 error will be returned. On FreeBSD, a representation of the directory's contents
 will be returned.</p>
-<pre><code class="language-js"><span class="hljs-comment">// macOS, Linux, and Windows</span>
-fs.readFile(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// macOS, Linux, and Windows</span>
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
   <span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]</span>
 });
 
 <span class="hljs-comment">//  FreeBSD</span>
-fs.readFile(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
   <span class="hljs-comment">// => null, &#x3C;data></span>
 });</code></pre>
+<p>It is possible to abort an ongoing request using an <code>AbortSignal</code>. If a
+request is aborted the callback is called with an <code>AbortError</code>:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> signal = controller.<span class="hljs-property">signal</span>;
+<span class="hljs-title function_">readFile</span>(fileInfo[<span class="hljs-number">0</span>].<span class="hljs-property">name</span>, { signal }, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+  <span class="hljs-comment">// ...</span>
+});
+<span class="hljs-comment">// When you want to abort the request</span>
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
 <p>The <code>fs.readFile()</code> function buffers the entire file. To minimize memory costs,
 when possible prefer streaming via <code>fs.createReadStream()</code>.</p>
-<h3>File descriptors<span><a class="mark" href="#fs_file_descriptors_1" id="fs_file_descriptors_1">#</a></span></h3>
+<p>Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering <code>fs.readFile</code> performs.</p>
+<h5>File descriptors<span><a class="mark" href="#fs_file_descriptors" id="fs_file_descriptors">#</a></span></h5>
 <ol>
 <li>Any specified file descriptor has to support reading.</li>
 <li>If a file descriptor is specified as the <code>path</code>, it will not be closed
@@ -32075,44 +33969,24 @@ already had <code>'Hello World</code>' and six bytes are read with the file desc
 the call to <code>fs.readFile()</code> with the same file descriptor, would give
 <code>'World'</code>, rather than <code>'Hello World'</code>.</li>
 </ol>
-<h2><code>fs.readFileSync(path[, options])</code><span><a class="mark" href="#fs_fs_readfilesync_path_options" id="fs_fs_readfilesync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v5.0.0</td>
-<td><p>The <code>path</code> parameter can be a file descriptor now.</p></td></tr>
-<tr><td>v0.1.8</td>
-<td><p><span>Added in: v0.1.8</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-</ul>
-<p>Returns the contents of the <code>path</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile()</code></a>.</p>
-<p>If the <code>encoding</code> option is specified then this function returns a
-string. Otherwise it returns a buffer.</p>
-<p>Similar to <a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile()</code></a>, when the path is a directory, the behavior of
-<code>fs.readFileSync()</code> is platform-specific.</p>
-<pre><code class="language-js"><span class="hljs-comment">// macOS, Linux, and Windows</span>
-fs.readFileSync(<span class="hljs-string">'&#x3C;directory>'</span>);
-<span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]</span>
-
-<span class="hljs-comment">//  FreeBSD</span>
-fs.readFileSync(<span class="hljs-string">'&#x3C;directory>'</span>); <span class="hljs-comment">// => &#x3C;data></span></code></pre>
-<h2><code>fs.readlink(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readlink_path_options_callback" id="fs_fs_readlink_path_options_callback">#</a></span></h2>
+<h5>Performance Considerations<span><a class="mark" href="#fs_performance_considerations" id="fs_performance_considerations">#</a></span></h5>
+<p>The <code>fs.readFile()</code> method asynchronously reads the contents of a file into
+memory one chunk at a time, allowing the event loop to turn between each chunk.
+This allows the read operation to have less impact on other activity that may
+be using the underlying libuv thread pool but means that it will take longer
+to read a complete file into memory.</p>
+<p>The additional read overhead can vary broadly on different systems and depends
+on the type of file being read. If the file type is not a regular file (a pipe
+for instance) and Node.js is unable to determine an actual file size, each read
+operation will load on 64kb of data. For regular files, each read will process
+512kb of data.</p>
+<p>For applications that require as-fast-as-possible reading of file contents, it
+is better to use <code>fs.read()</code> directly and for application code to manage
+reading the full contents of the file itself.</p>
+<p>The Node.js GitHub issue <a href="https://github.com/nodejs/node/issues/25741">#25741</a> provides more information and a detailed
+analysis on the performance of <code>fs.readFile()</code> for multiple file sizes in
+different Node.js versions.</p>
+<h4><code>fs.readlink(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readlink_path_options_callback" id="fs_fs_readlink_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -32120,7 +33994,7 @@ fs.readFileSync(<span class="hljs-string">'&#x3C;directory>'</span>); <span clas
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.1.31</td>
@@ -32142,94 +34016,16 @@ fs.readFileSync(<span class="hljs-string">'&#x3C;directory>'</span>); <span clas
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a>. The callback gets two arguments <code>(err, linkString)</code>.</p>
+<p>Reads the contents of the symbolic link referred to by <code>path</code>. The callback gets
+two arguments <code>(err, linkString)</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a> documentation for more details.</p>
 <p>The optional <code>options</code> argument can be a string specifying an encoding, or an
 object with an <code>encoding</code> property specifying the character encoding to use for
 the link path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the link path returned will be passed as a <code>Buffer</code> object.</p>
-<h2><code>fs.readlinkSync(path[, options])</code><span><a class="mark" href="#fs_fs_readlinksync_path_options" id="fs_fs_readlinksync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a>. Returns the symbolic link's string value.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the link path returned will be passed as a <code>Buffer</code> object.</p>
-<h2><code>fs.readSync(fd, buffer, offset, length, position)</code><span><a class="mark" href="#fs_fs_readsync_fd_buffer_offset_length_position" id="fs_fs_readsync_fd_buffer_offset_length_position">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.10.0</td>
-<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
-<tr><td>v6.0.0</td>
-<td><p>The <code>length</code> parameter can now be <code>0</code>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-<p>Returns the number of <code>bytesRead</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a>.</p>
-<h2><code>fs.readSync(fd, buffer, [options])</code><span><a class="mark" href="#fs_fs_readsync_fd_buffer_options" id="fs_fs_readsync_fd_buffer_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>Options object can be passed in to make offset, length and position optional</p></td></tr>
-<tr><td>v12.17.0</td>
-<td><p><span>Added in: v12.17.0</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.length</code></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-<p>Returns the number of <code>bytesRead</code>.</p>
-<p>Similar to the above <code>fs.readSync</code> function, this version takes an optional <code>options</code> object.
-If no <code>options</code> object is specified, it will default with the above values.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a>.</p>
-<h2><code>fs.readv(fd, buffers[, position], callback)</code><span><a class="mark" href="#fs_fs_readv_fd_buffers_position_callback" id="fs_fs_readv_fd_buffers_position_callback">#</a></span></h2>
+the link path returned will be passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<h4><code>fs.readv(fd, buffers[, position], callback)</code><span><a class="mark" href="#fs_fs_readv_fd_buffers_position_callback" id="fs_fs_readv_fd_buffers_position_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.13.0, v12.17.0</span>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
@@ -32251,20 +34047,8 @@ from the current position.</p>
 <p>The callback will be given three arguments: <code>err</code>, <code>bytesRead</code>, and
 <code>buffers</code>. <code>bytesRead</code> is how many bytes were read from the file.</p>
 <p>If this method is invoked as its <a href="#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
-a <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> and <code>buffers</code> properties.</p>
-<h2><code>fs.readvSync(fd, buffers[, position])</code><span><a class="mark" href="#fs_fs_readvsync_fd_buffers_position" id="fs_fs_readvsync_fd_buffers_position">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.17.0</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes read.</li>
-</ul>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv()</code></a>.</p>
-<h2><code>fs.realpath(path[, options], callback)</code><span><a class="mark" href="#fs_fs_realpath_path_options_callback" id="fs_fs_realpath_path_options_callback">#</a></span></h2>
+a promise for an <code>Object</code> with <code>bytesRead</code> and <code>buffers</code> properties.</p>
+<h4><code>fs.realpath(path[, options], callback)</code><span><a class="mark" href="#fs_fs_realpath_path_options_callback" id="fs_fs_realpath_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -32274,7 +34058,7 @@ this API: <a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv()</
 <tr><td>v8.0.0</td>
 <td><p>Pipe/Socket resolve support was added.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v6.4.0</td>
@@ -32320,10 +34104,10 @@ to resolve relative paths.</p>
 <p>The optional <code>options</code> argument can be a string specifying an encoding, or an
 object with an <code>encoding</code> property specifying the character encoding to use for
 the path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the path returned will be passed as a <code>Buffer</code> object.</p>
+the path returned will be passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
 <p>If <code>path</code> resolves to a socket or a pipe, the function will return a system
 dependent name for that object.</p>
-<h2><code>fs.realpath.native(path[, options], callback)</code><span><a class="mark" href="#fs_fs_realpath_native_path_options_callback" id="fs_fs_realpath_native_path_options_callback">#</a></span></h2>
+<h4><code>fs.realpath.native(path[, options], callback)</code><span><a class="mark" href="#fs_fs_realpath_native_path_options_callback" id="fs_fs_realpath_native_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.2.0</span>
 </div>
@@ -32347,63 +34131,11 @@ dependent name for that object.</p>
 <p>The optional <code>options</code> argument can be a string specifying an encoding, or an
 object with an <code>encoding</code> property specifying the character encoding to use for
 the path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the path returned will be passed as a <code>Buffer</code> object.</p>
-<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
-be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
-this restriction.</p>
-<h2><code>fs.realpathSync(path[, options])</code><span><a class="mark" href="#fs_fs_realpathsync_path_options" id="fs_fs_realpathsync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v8.0.0</td>
-<td><p>Pipe/Socket resolve support was added.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v6.4.0</td>
-<td><p>Calling <code>realpathSync</code> now works again for various edge cases on Windows.</p></td></tr>
-<tr><td>v6.0.0</td>
-<td><p>The <code>cache</code> parameter was removed.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-</ul>
-<p>Returns the resolved pathname.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_realpath_path_options_callback"><code>fs.realpath()</code></a>.</p>
-<h2><code>fs.realpathSync.native(path[, options])</code><span><a class="mark" href="#fs_fs_realpathsync_native_path_options" id="fs_fs_realpathsync_native_path_options">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v9.2.0</span>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a>.</p>
-<p>Only paths that can be converted to UTF8 strings are supported.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the path returned will be passed as a <code>Buffer</code> object.</p>
+the path returned will be passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
 <p>On Linux, when Node.js is linked against musl libc, the procfs file system must
 be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
 this restriction.</p>
-<h2><code>fs.rename(oldPath, newPath, callback)</code><span><a class="mark" href="#fs_fs_rename_oldpath_newpath_callback" id="fs_fs_rename_oldpath_newpath_callback">#</a></span></h2>
+<h4><code>fs.rename(oldPath, newPath, callback)</code><span><a class="mark" href="#fs_fs_rename_oldpath_newpath_callback" id="fs_fs_rename_oldpath_newpath_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -32434,40 +34166,27 @@ be overwritten. If there is a directory at <code>newPath</code>, an error will
 be raised instead. No arguments other than a possible exception are
 given to the completion callback.</p>
 <p>See also: <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>.</p>
-<pre><code class="language-js">fs.rename(<span class="hljs-string">'oldFile.txt'</span>, <span class="hljs-string">'newFile.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { rename } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">rename</span>(<span class="hljs-string">'oldFile.txt'</span>, <span class="hljs-string">'newFile.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Rename complete!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Rename complete!'</span>);
 });</code></pre>
-<h2><code>fs.renameSync(oldPath, newPath)</code><span><a class="mark" href="#fs_fs_renamesync_oldpath_newpath" id="fs_fs_renamesync_oldpath_newpath">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>oldPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.rmdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_rmdir_path_options_callback" id="fs_fs_rmdir_path_options_callback">#</a></span></h2>
+<h4><code>fs.rmdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_rmdir_path_options_callback" id="fs_fs_rmdir_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v14.14.0</td>
+<td><p>The <code>recursive</code> option is deprecated, use <code>fs.rm</code> instead.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
 <tr><td>v12.10.0</td>
 <td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameters can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameters can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.0.2</td>
@@ -32475,16 +34194,15 @@ given to the completion callback.</p>
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Recursive removal is experimental.</div><p></p>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
-<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
-backoff wait of <code>retryDelay</code> ms longer on each try. This option represents the
-number of retries. This option is ignored if the <code>recursive</code> option is not
-<code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<code>EPERM</code> error is encountered, Node.js retries the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
 recursive mode, errors are not reported if <code>path</code> does not exist, and
 operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
@@ -32503,45 +34221,43 @@ retries. This option is ignored if the <code>recursive</code> option is not <cod
 to the completion callback.</p>
 <p>Using <code>fs.rmdir()</code> on a file (not a directory) results in an <code>ENOENT</code> error on
 Windows and an <code>ENOTDIR</code> error on POSIX.</p>
-<h2><code>fs.rmdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_rmdirsync_path_options" id="fs_fs_rmdirsync_path_options">#</a></span></h2>
+<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command
+<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in
+the future.</p>
+<h4><code>fs.rm(path[, options], callback)</code><span><a class="mark" href="#fs_fs_rm_path_options_callback" id="fs_fs_rm_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
-<tr><td>v12.10.0</td>
-<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameters can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v14.14.0</span>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Recursive removal is experimental.</div><p></p>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
+<li><code>force</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, exceptions will be ignored if <code>path</code> does
+not exist. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
 <code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
-backoff wait of <code>retryDelay</code> ms longer on each try. This option represents the
-number of retries. This option is ignored if the <code>recursive</code> option is not
-<code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
-recursive mode, errors are not reported if <code>path</code> does not exist, and
-operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive removal. In
+recursive mode operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
 retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
 <strong>Default:</strong> <code>100</code>.</li>
 </ul>
 </li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+</ul>
+</li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/rmdir.2.html"><code>rmdir(2)</code></a>. Returns <code>undefined</code>.</p>
-<p>Using <code>fs.rmdirSync()</code> on a file (not a directory) results in an <code>ENOENT</code> error
-on Windows and an <code>ENOTDIR</code> error on POSIX.</p>
-<h2><code>fs.stat(path[, options], callback)</code><span><a class="mark" href="#fs_fs_stat_path_options_callback" id="fs_fs_stat_path_options_callback">#</a></span></h2>
+<p>Asynchronously removes files and directories (modeled on the standard POSIX <code>rm</code>
+utility). No arguments other than a possible exception are given to the
+completion callback.</p>
+<h4><code>fs.stat(path[, options], callback)</code><span><a class="mark" href="#fs_fs_stat_path_options_callback" id="fs_fs_stat_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -32551,7 +34267,7 @@ on Windows and an <code>ENOTDIR</code> error on POSIX.</p>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.0.2</td>
@@ -32564,7 +34280,7 @@ on Windows and an <code>ENOTDIR</code> error on POSIX.</p>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -32575,7 +34291,7 @@ on Windows and an <code>ENOTDIR</code> error on POSIX.</p>
 </li>
 </ul>
 <p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/stat.2.html"><code>stat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where
-<code>stats</code> is an <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object.</p>
+<code>stats</code> is an <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object.</p>
 <p>In case of an error, the <code>err.code</code> will be one of <a href="#errors_common_system_errors">Common System Errors</a>.</p>
 <p>Using <code>fs.stat()</code> to check for the existence of a file before calling
 <code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended.
@@ -32588,14 +34304,14 @@ is recommended.</p>
 -- file.txt
 - app.js</code></pre>
 <p>The next program will check for the stats of the given paths:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { stat } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
 <span class="hljs-keyword">const</span> pathsToCheck = [<span class="hljs-string">'./txtDir'</span>, <span class="hljs-string">'./txtDir/file.txt'</span>];
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; pathsToCheck.length; i++) {
-  fs.stat(pathsToCheck[i], <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">err, stats</span>) </span>{
-    <span class="hljs-built_in">console</span>.log(stats.isDirectory());
-    <span class="hljs-built_in">console</span>.log(stats);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; pathsToCheck.<span class="hljs-property">length</span>; i++) {
+  <span class="hljs-title function_">stat</span>(pathsToCheck[i], <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stats.<span class="hljs-title function_">isDirectory</span>());
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stats);
   });
 }</code></pre>
 <p>The resulting output will resemble:</p>
@@ -32641,38 +34357,13 @@ Stats {
   ctime: 2019-06-22T03:36:54.584Z,
   birthtime: 2019-06-22T03:26:47.711Z
 }</code></pre>
-<h2><code>fs.statSync(path[, options])</code><span><a class="mark" href="#fs_fs_statsync_path_options" id="fs_fs_statsync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
-</ul>
-</li>
-<li>Returns: <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/stat.2.html"><code>stat(2)</code></a>.</p>
-<h2><code>fs.symlink(target, path[, type], callback)</code><span><a class="mark" href="#fs_fs_symlink_target_path_type_callback" id="fs_fs_symlink_target_path_type_callback">#</a></span></h2>
+<h4><code>fs.symlink(target, path[, type], callback)</code><span><a class="mark" href="#fs_fs_symlink_target_path_type_callback" id="fs_fs_symlink_target_path_type_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
-<td><p>If the <code>type</code> argument is left undefined, Node will autodetect <code>target</code> type and automatically select <code>dir</code> or <code>file</code></p></td></tr>
+<td><p>If the <code>type</code> argument is left undefined, Node will autodetect <code>target</code> type and automatically select <code>dir</code> or <code>file</code>.</p></td></tr>
 <tr><td>v7.6.0</td>
 <td><p>The <code>target</code> and <code>path</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
 <tr><td>v0.1.31</td>
@@ -32690,9 +34381,9 @@ Stats {
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/symlink.2.html"><code>symlink(2)</code></a> which creates the link called <code>path</code> pointing to
-<code>target</code>. No arguments other than a possible exception are given to the
-completion callback.</p>
+<p>Creates the link called <code>path</code> pointing to <code>target</code>. No arguments other than a
+possible exception are given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/symlink.2.html"><code>symlink(2)</code></a> documentation for more details.</p>
 <p>The <code>type</code> argument is only available on Windows and ignored on other platforms.
 It can be set to <code>'dir'</code>, <code>'file'</code>, or <code>'junction'</code>. If the <code>type</code> argument is
 not set, Node.js will autodetect <code>target</code> type and use <code>'file'</code> or <code>'dir'</code>. If
@@ -32700,36 +34391,16 @@ the <code>target</code> does not exist, <code>'file'</code> will be used. Window
 require the destination path to be absolute. When using <code>'junction'</code>, the
 <code>target</code> argument will automatically be normalized to absolute path.</p>
 <p>Relative targets are relative to the link’s parent directory.</p>
-<pre><code class="language-js">fs.symlink(<span class="hljs-string">'./mew'</span>, <span class="hljs-string">'./example/mewtwo'</span>, callback);</code></pre>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { symlink } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">symlink</span>(<span class="hljs-string">'./mew'</span>, <span class="hljs-string">'./example/mewtwo'</span>, callback);</code></pre>
 <p>The above example creates a symbolic link <code>mewtwo</code> in the <code>example</code> which points
 to <code>mew</code> in the same directory:</p>
 <pre><code class="language-bash">$ tree example/
 example/
 ├── mew
 └── mewtwo -> ./mew</code></pre>
-<h2><code>fs.symlinkSync(target, path[, type])</code><span><a class="mark" href="#fs_fs_symlinksync_target_path_type" id="fs_fs_symlinksync_target_path_type">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.0.0</td>
-<td><p>If the <code>type</code> argument is left undefined, Node will autodetect <code>target</code> type and automatically select <code>dir</code> or <code>file</code></p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>target</code> and <code>path</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-</ul>
-<p>Returns <code>undefined</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink()</code></a>.</p>
-<h2><code>fs.truncate(path[, len], callback)</code><span><a class="mark" href="#fs_fs_truncate_path_len_callback" id="fs_fs_truncate_path_len_callback">#</a></span></h2>
+<h4><code>fs.truncate(path[, len], callback)</code><span><a class="mark" href="#fs_fs_truncate_path_len_callback" id="fs_fs_truncate_path_len_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -32752,24 +34423,25 @@ this API: <a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink()<
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/truncate.2.html"><code>truncate(2)</code></a>. No arguments other than a possible exception are
+<p>Truncates the file. No arguments other than a possible exception are
 given to the completion callback. A file descriptor can also be passed as the
 first argument. In this case, <code>fs.ftruncate()</code> is called.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { truncate } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// Assuming that 'path/file.txt' is a regular file.</span>
+<span class="hljs-title function_">truncate</span>(<span class="hljs-string">'path/file.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'path/file.txt was truncated'</span>);
+});</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { truncate } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<span class="hljs-comment">// Assuming that 'path/file.txt' is a regular file.</span>
+<span class="hljs-title function_">truncate</span>(<span class="hljs-string">'path/file.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'path/file.txt was truncated'</span>);
+});</code></pre>
 <p>Passing a file descriptor is deprecated and may result in an error being thrown
 in the future.</p>
-<h2><code>fs.truncateSync(path[, len])</code><span><a class="mark" href="#fs_fs_truncatesync_path_len" id="fs_fs_truncatesync_path_len">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.8.6</span>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/truncate.2.html"><code>truncate(2)</code></a>. Returns <code>undefined</code>. A file descriptor can also be
-passed as the first argument. In this case, <code>fs.ftruncateSync()</code> is called.</p>
-<p>Passing a file descriptor is deprecated and may result in an error being thrown
-in the future.</p>
-<h2><code>fs.unlink(path, callback)</code><span><a class="mark" href="#fs_fs_unlink_path_callback" id="fs_fs_unlink_path_callback">#</a></span></h2>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/truncate.2.html"><code>truncate(2)</code></a> documentation for more details.</p>
+<h4><code>fs.unlink(path, callback)</code><span><a class="mark" href="#fs_fs_unlink_path_callback" id="fs_fs_unlink_path_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -32777,7 +34449,7 @@ in the future.</p>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.0.2</td>
@@ -32795,31 +34467,16 @@ in the future.</p>
 </ul>
 <p>Asynchronously removes a file or symbolic link. No arguments other than a
 possible exception are given to the completion callback.</p>
-<pre><code class="language-js"><span class="hljs-comment">// Assuming that 'path/file.txt' is a regular file.</span>
-fs.unlink(<span class="hljs-string">'path/file.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { unlink } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// Assuming that 'path/file.txt' is a regular file.</span>
+<span class="hljs-title function_">unlink</span>(<span class="hljs-string">'path/file.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'path/file.txt was deleted'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'path/file.txt was deleted'</span>);
 });</code></pre>
 <p><code>fs.unlink()</code> will not work on a directory, empty or otherwise. To remove a
 directory, use <a href="#fs_fs_rmdir_path_options_callback"><code>fs.rmdir()</code></a>.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>.</p>
-<h2><code>fs.unlinkSync(path)</code><span><a class="mark" href="#fs_fs_unlinksync_path" id="fs_fs_unlinksync_path">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.unwatchFile(filename[, listener])</code><span><a class="mark" href="#fs_fs_unwatchfile_filename_listener" id="fs_fs_unwatchfile_filename_listener">#</a></span></h2>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a> documentation for more details.</p>
+<h4><code>fs.unwatchFile(filename[, listener])</code><span><a class="mark" href="#fs_fs_unwatchfile_filename_listener" id="fs_fs_unwatchfile_filename_listener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.31</span>
 </div>
@@ -32836,7 +34493,7 @@ no-op, not an error.</p>
 <p>Using <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile()</code> and
 <code>fs.unwatchFile()</code>. <code>fs.watch()</code> should be used instead of <code>fs.watchFile()</code>
 and <code>fs.unwatchFile()</code> when possible.</p>
-<h2><code>fs.utimes(path, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_utimes_path_atime_mtime_callback" id="fs_fs_utimes_path_atime_mtime_callback">#</a></span></h2>
+<h4><code>fs.utimes(path, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_utimes_path_atime_mtime_callback" id="fs_fs_utimes_path_atime_mtime_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -32846,7 +34503,7 @@ and <code>fs.unwatchFile()</code> when possible.</p>
 <tr><td>v8.0.0</td>
 <td><p><code>NaN</code>, <code>Infinity</code>, and <code>-Infinity</code> are no longer valid time specifiers.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v4.1.0</td>
@@ -32874,37 +34531,15 @@ and <code>fs.unwatchFile()</code> when possible.</p>
 <li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or
 <code>-Infinity</code>, an <code>Error</code> will be thrown.</li>
 </ul>
-<h2><code>fs.utimesSync(path, atime, mtime)</code><span><a class="mark" href="#fs_fs_utimessync_path_atime_mtime" id="fs_fs_utimessync_path_atime_mtime">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v8.0.0</td>
-<td><p><code>NaN</code>, <code>Infinity</code>, and <code>-Infinity</code> are no longer valid time specifiers.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v4.1.0</td>
-<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
-<tr><td>v0.4.2</td>
-<td><p><span>Added in: v0.4.2</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-</ul>
-<p>Returns <code>undefined</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>.</p>
-<h2><code>fs.watch(filename[, options][, listener])</code><span><a class="mark" href="#fs_fs_watch_filename_options_listener" id="fs_fs_watch_filename_options_listener">#</a></span></h2>
+<h4><code>fs.watch(filename[, options][, listener])</code><span><a class="mark" href="#fs_fs_watch_filename_options_listener" id="fs_fs_watch_filename_options_listener">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Added support for closing the watcher with an AbortSignal.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
 <tr><td>v0.5.10</td>
@@ -32920,10 +34555,11 @@ this API: <a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</c
 as long as files are being watched. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether all subdirectories should be
 watched, or only the current directory. This applies when a directory is
-specified, and only on supported platforms (See <a href="#fs_caveats">Caveats</a>). <strong>Default:</strong>
+specified, and only on supported platforms (See <a href="#fs_caveats">caveats</a>). <strong>Default:</strong>
 <code>false</code>.</li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Specifies the character encoding to be used for the
- filename passed to the listener. <strong>Default:</strong> <code>'utf8'</code>.</li>
+filename passed to the listener. <strong>Default:</strong> <code>'utf8'</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows closing the watcher with an AbortSignal.</li>
 </ul>
 </li>
 <li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a> <strong>Default:</strong> <code>undefined</code>
@@ -32944,16 +34580,20 @@ which triggered the event.</p>
 <p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or
 disappears in the directory.</p>
 <p>The listener callback is attached to the <code>'change'</code> event fired by
-<a href="#fs_class_fs_fswatcher"><code>fs.FSWatcher</code></a>, but it is not the same thing as the <code>'change'</code> value of
+<a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a>, but it is not the same thing as the <code>'change'</code> value of
 <code>eventType</code>.</p>
-<h3>Caveats<span><a class="mark" href="#fs_caveats" id="fs_caveats">#</a></span></h3>
+<p>If a <code>signal</code> is passed, aborting the corresponding AbortController will close
+the returned <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a>.</p>
+<h5>Caveats<span><a class="mark" href="#fs_caveats" id="fs_caveats">#</a></span></h5>
 
 <p>The <code>fs.watch</code> API is not 100% consistent across platforms, and is
 unavailable in some situations.</p>
-<p>The recursive option is only supported on macOS and Windows.</p>
+<p>The recursive option is only supported on macOS and Windows.
+An <code>ERR_FEATURE_UNAVAILABLE_ON_PLATFORM</code> exception will be thrown
+when the option is used on a platform that does not support it.</p>
 <p>On Windows, no events will be emitted if the watched directory is moved or
 renamed. An <code>EPERM</code> error is reported when the watched directory is deleted.</p>
-<h4>Availability<span><a class="mark" href="#fs_availability" id="fs_availability">#</a></span></h4>
+<h6>Availability<span><a class="mark" href="#fs_availability" id="fs_availability">#</a></span></h6>
 
 <p>This feature depends on the underlying operating system providing a way
 to be notified of filesystem changes.</p>
@@ -32964,17 +34604,17 @@ to be notified of filesystem changes.</p>
 directories.</li>
 <li>On SunOS systems (including Solaris and SmartOS), this uses <a href="https://illumos.org/man/port_create"><code>event ports</code></a>.</li>
 <li>On Windows systems, this feature depends on <a href="https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw"><code>ReadDirectoryChangesW</code></a>.</li>
-<li>On Aix systems, this feature depends on <a href="https://www.ibm.com/developerworks/aix/library/au-aix_event_infrastructure/"><code>AHAFS</code></a>, which must be enabled.</li>
+<li>On AIX systems, this feature depends on <a href="https://developer.ibm.com/articles/au-aix_event_infrastructure/"><code>AHAFS</code></a>, which must be enabled.</li>
 <li>On IBM i systems, this feature is not supported.</li>
 </ul>
 <p>If the underlying functionality is not available for some reason, then
-<code>fs.watch()</code> will not be able to function and may thrown an exception.
+<code>fs.watch()</code> will not be able to function and may throw an exception.
 For example, watching files or directories can be unreliable, and in some
 cases impossible, on network file systems (NFS, SMB, etc) or host file systems
 when using virtualization software such as Vagrant or Docker.</p>
 <p>It is still possible to use <code>fs.watchFile()</code>, which uses stat polling, but
 this method is slower and less reliable.</p>
-<h4>Inodes<span><a class="mark" href="#fs_inodes" id="fs_inodes">#</a></span></h4>
+<h6>Inodes<span><a class="mark" href="#fs_inodes" id="fs_inodes">#</a></span></h6>
 
 <p>On Linux and macOS systems, <code>fs.watch()</code> resolves the path to an <a href="https://en.wikipedia.org/wiki/Inode">inode</a> and
 watches the inode. If the watched path is deleted and recreated, it is assigned
@@ -32984,21 +34624,22 @@ This is expected behavior.</p>
 <p>AIX files retain the same inode for the lifetime of a file. Saving and closing a
 watched file on AIX will result in two notifications (one for adding new
 content, and one for truncation).</p>
-<h4>Filename argument<span><a class="mark" href="#fs_filename_argument" id="fs_filename_argument">#</a></span></h4>
+<h6>Filename argument<span><a class="mark" href="#fs_filename_argument" id="fs_filename_argument">#</a></span></h6>
 
 <p>Providing <code>filename</code> argument in the callback is only supported on Linux,
 macOS, Windows, and AIX. Even on supported platforms, <code>filename</code> is not always
 guaranteed to be provided. Therefore, don't assume that <code>filename</code> argument is
 always provided in the callback, and have some fallback logic if it is <code>null</code>.</p>
-<pre><code class="language-js">fs.watch(<span class="hljs-string">'somedir'</span>, <span class="hljs-function">(<span class="hljs-params">eventType, filename</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`event type is: <span class="hljs-subst">${eventType}</span>`</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { watch } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-title function_">watch</span>(<span class="hljs-string">'somedir'</span>, <span class="hljs-function">(<span class="hljs-params">eventType, filename</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`event type is: <span class="hljs-subst">${eventType}</span>`</span>);
   <span class="hljs-keyword">if</span> (filename) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`filename provided: <span class="hljs-subst">${filename}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`filename provided: <span class="hljs-subst">${filename}</span>`</span>);
   } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'filename not provided'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'filename not provided'</span>);
   }
 });</code></pre>
-<h2><code>fs.watchFile(filename[, options], listener)</code><span><a class="mark" href="#fs_fs_watchfile_filename_options_listener" id="fs_fs_watchfile_filename_options_listener">#</a></span></h2>
+<h4><code>fs.watchFile(filename[, options], listener)</code><span><a class="mark" href="#fs_fs_watchfile_filename_options_listener" id="fs_fs_watchfile_filename_options_listener">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -33006,7 +34647,7 @@ always provided in the callback, and have some fallback logic if it is <code>nul
 <tr><td>v10.5.0</td>
 <td><p>The <code>bigint</code> option is now supported.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v0.1.31</td>
 <td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
@@ -33038,9 +34679,11 @@ The <code>options</code> object may specify an <code>interval</code> property in
 target should be polled in milliseconds.</p>
 <p>The <code>listener</code> gets two arguments the current stat object and the previous
 stat object:</p>
-<pre><code class="language-js">fs.watchFile(<span class="hljs-string">'message.text'</span>, <span class="hljs-function">(<span class="hljs-params">curr, prev</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`the current mtime is: <span class="hljs-subst">${curr.mtime}</span>`</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`the previous mtime was: <span class="hljs-subst">${prev.mtime}</span>`</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { watchFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">watchFile</span>(<span class="hljs-string">'message.text'</span>, <span class="hljs-function">(<span class="hljs-params">curr, prev</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`the current mtime is: <span class="hljs-subst">${curr.mtime}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`the previous mtime was: <span class="hljs-subst">${prev.mtime}</span>`</span>);
 });</code></pre>
 <p>These stat objects are instances of <code>fs.Stat</code>. If the <code>bigint</code> option is <code>true</code>,
 the numeric values in these objects are specified as <code>BigInt</code>s.</p>
@@ -33063,13 +34706,17 @@ callback event (its disappearance).</p>
 <li>the file is deleted, followed by a restore</li>
 <li>the file is renamed and then renamed a second time back to its original name</li>
 </ul>
-<h2><code>fs.write(fd, buffer[, offset[, length[, position]]], callback)</code><span><a class="mark" href="#fs_fs_write_fd_buffer_offset_length_position_callback" id="fs_fs_write_fd_buffer_offset_length_position_callback">#</a></span></h2>
+<h4><code>fs.write(fd, buffer[, offset[, length[, position]]], callback)</code><span><a class="mark" href="#fs_fs_write_fd_buffer_offset_length_position_callback" id="fs_fs_write_fd_buffer_offset_length_position_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>buffer</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>buffer</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v10.10.0</td>
-<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code></p></td></tr>
+<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.4.0</td>
@@ -33085,7 +34732,7 @@ callback event (its disappearance).</p>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
@@ -33097,7 +34744,8 @@ callback event (its disappearance).</p>
 </ul>
 </li>
 </ul>
-<p>Write <code>buffer</code> to the file specified by <code>fd</code>.</p>
+<p>Write <code>buffer</code> to the file specified by <code>fd</code>. If <code>buffer</code> is a normal object, it
+must have an own <code>toString</code> function property.</p>
 <p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is
 an integer specifying the number of bytes to write.</p>
 <p><code>position</code> refers to the offset from the beginning of the file where this data
@@ -33106,18 +34754,22 @@ at the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrit
 <p>The callback will be given three arguments <code>(err, bytesWritten, buffer)</code> where
 <code>bytesWritten</code> specifies how many <em>bytes</em> were written from <code>buffer</code>.</p>
 <p>If this method is invoked as its <a href="#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
-a <code>Promise</code> for an <code>Object</code> with <code>bytesWritten</code> and <code>buffer</code> properties.</p>
+a promise for an <code>Object</code> with <code>bytesWritten</code> and <code>buffer</code> properties.</p>
 <p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting
 for the callback. For this scenario, <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> is
 recommended.</p>
 <p>On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
 the end of the file.</p>
-<h2><code>fs.write(fd, string[, position[, encoding]], callback)</code><span><a class="mark" href="#fs_fs_write_fd_string_position_encoding_callback" id="fs_fs_write_fd_string_position_encoding_callback">#</a></span></h2>
+<h4><code>fs.write(fd, string[, position[, encoding]], callback)</code><span><a class="mark" href="#fs_fs_write_fd_string_position_encoding_callback" id="fs_fs_write_fd_string_position_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>string</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>string</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.2.0</td>
@@ -33131,7 +34783,7 @@ the end of the file.</p>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -33142,8 +34794,8 @@ the end of the file.</p>
 </ul>
 </li>
 </ul>
-<p>Write <code>string</code> to the file specified by <code>fd</code>. If <code>string</code> is not a string, then
-the value will be coerced to one.</p>
+<p>Write <code>string</code> to the file specified by <code>fd</code>. If <code>string</code> is not a string, or an
+object with an own <code>toString</code> function property, then an exception is thrown.</p>
 <p><code>position</code> refers to the offset from the beginning of the file where this data
 should be written. If <code>typeof position !== 'number'</code> the data will be written at
 the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
@@ -33164,11 +34816,17 @@ properly by default, regardless of the encoding used.
 It is possible to configure the console to render UTF-8 properly by changing the
 active codepage with the <code>chcp 65001</code> command. See the <a href="https://ss64.com/nt/chcp.html">chcp</a> docs for more
 details.</p>
-<h2><code>fs.writeFile(file, data[, options], callback)</code><span><a class="mark" href="#fs_fs_writefile_file_data_options_callback" id="fs_fs_writefile_file_data_options_callback">#</a></span></h2>
+<h4><code>fs.writeFile(file, data[, options], callback)</code><span><a class="mark" href="#fs_fs_writefile_file_data_options_callback" id="fs_fs_writefile_file_data_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>The options argument may include an AbortSignal to abort an ongoing writeFile request.</p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>data</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>data</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>data</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
@@ -33186,12 +34844,13 @@ details.</p>
 </div>
 <ul>
 <li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
 <li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
 <li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress writeFile</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -33201,28 +34860,56 @@ details.</p>
 </li>
 </ul>
 <p>When <code>file</code> is a filename, asynchronously writes data to the file, replacing the
-file if it already exists.  <code>data</code> can be a string or a buffer.</p>
+file if it already exists. <code>data</code> can be a string or a buffer.</p>
 <p>When <code>file</code> is a file descriptor, the behavior is similar to calling
 <code>fs.write()</code> directly (which is recommended). See the notes below on using
 a file descriptor.</p>
 <p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> data = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(Buffer.from(<span class="hljs-string">'Hello Node.js'</span>));
-fs.writeFile(<span class="hljs-string">'message.txt'</span>, data, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<p>If <code>data</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { writeFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">const</span> data = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Hello Node.js'</span>));
+<span class="hljs-title function_">writeFile</span>(<span class="hljs-string">'message.txt'</span>, data, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The file has been saved!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The file has been saved!'</span>);
 });</code></pre>
 <p>If <code>options</code> is a string, then it specifies the encoding:</p>
-<pre><code class="language-js">fs.writeFile(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'Hello Node.js'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { writeFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">writeFile</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'Hello Node.js'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
 <p>It is unsafe to use <code>fs.writeFile()</code> multiple times on the same file without
 waiting for the callback. For this scenario, <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> is
 recommended.</p>
-<h3>Using <code>fs.writeFile()</code> with file descriptors<span><a class="mark" href="#fs_using_fs_writefile_with_file_descriptors" id="fs_using_fs_writefile_with_file_descriptors">#</a></span></h3>
+<p>Similarly to <code>fs.readFile</code> - <code>fs.writeFile</code> is a convenience method that
+performs multiple <code>write</code> calls internally to write the buffer passed to it.
+For performance sensitive code consider using <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>It is possible to use an <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> to cancel an <code>fs.writeFile()</code>.
+Cancelation is "best effort", and some amount of data is likely still
+to be written.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { writeFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> data = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Hello Node.js'</span>));
+<span class="hljs-title function_">writeFile</span>(<span class="hljs-string">'message.txt'</span>, data, { signal }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-comment">// When a request is aborted - the callback is called with an AbortError</span>
+});
+<span class="hljs-comment">// When the request should be aborted</span>
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<p>Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering <code>fs.writeFile</code> performs.</p>
+<h5>Using <code>fs.writeFile()</code> with file descriptors<span><a class="mark" href="#fs_using_fs_writefile_with_file_descriptors" id="fs_using_fs_writefile_with_file_descriptors">#</a></span></h5>
 <p>When <code>file</code> is a file descriptor, the behavior is almost identical to directly
 calling <code>fs.write()</code> like:</p>
-<pre><code class="language-js">fs.write(fd, Buffer.from(data, options.encoding), callback);</code></pre>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { write } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">write</span>(fd, <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(data, options.<span class="hljs-property">encoding</span>), callback);</code></pre>
 <p>The difference from directly calling <code>fs.write()</code> is that under some unusual
-conditions, <code>fs.write()</code> may write only part of the buffer and will need to be
-retried to write the remaining data, whereas <code>fs.writeFile()</code> will retry until
+conditions, <code>fs.write()</code> might write only part of the buffer and need to be
+retried to write the remaining data, whereas <code>fs.writeFile()</code> retries until
 the data is entirely written (or an error occurs).</p>
 <p>The implications of this are a common source of confusion. In
 the file descriptor case, the file is not replaced! The data is not necessarily
@@ -33234,84 +34921,7 @@ string <code>'Hello'</code>, then to write the string <code>', World'</code>, th
 on the size of the original file, and the position of the file descriptor). If
 a file name had been used instead of a descriptor, the file would be guaranteed
 to contain only <code>', World'</code>.</p>
-<h2><code>fs.writeFileSync(file, data[, options])</code><span><a class="mark" href="#fs_fs_writefilesync_file_data_options" id="fs_fs_writefilesync_file_data_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.10.0</td>
-<td><p>The <code>data</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
-<tr><td>v7.4.0</td>
-<td><p>The <code>data</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
-<tr><td>v5.0.0</td>
-<td><p>The <code>file</code> parameter can be a file descriptor now.</p></td></tr>
-<tr><td>v0.1.29</td>
-<td><p><span>Added in: v0.1.29</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
-</ul>
-</li>
-</ul>
-<p>Returns <code>undefined</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_writefile_file_data_options_callback"><code>fs.writeFile()</code></a>.</p>
-<h2><code>fs.writeSync(fd, buffer[, offset[, length[, position]]])</code><span><a class="mark" href="#fs_fs_writesync_fd_buffer_offset_length_position" id="fs_fs_writesync_fd_buffer_offset_length_position">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.10.0</td>
-<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
-<tr><td>v7.4.0</td>
-<td><p>The <code>buffer</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
-<tr><td>v7.2.0</td>
-<td><p>The <code>offset</code> and <code>length</code> parameters are optional now.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes written.</li>
-</ul>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_write_fd_buffer_offset_length_position_callback"><code>fs.write(fd, buffer...)</code></a>.</p>
-<h2><code>fs.writeSync(fd, string[, position[, encoding]])</code><span><a class="mark" href="#fs_fs_writesync_fd_string_position_encoding" id="fs_fs_writesync_fd_string_position_encoding">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.2.0</td>
-<td><p>The <code>position</code> parameter is optional now.</p></td></tr>
-<tr><td>v0.11.5</td>
-<td><p><span>Added in: v0.11.5</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes written.</li>
-</ul>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_write_fd_string_position_encoding_callback"><code>fs.write(fd, string...)</code></a>.</p>
-<h2><code>fs.writev(fd, buffers[, position], callback)</code><span><a class="mark" href="#fs_fs_writev_fd_buffers_position_callback" id="fs_fs_writev_fd_buffers_position_callback">#</a></span></h2>
+<h4><code>fs.writev(fd, buffers[, position], callback)</code><span><a class="mark" href="#fs_fs_writev_fd_buffers_position_callback" id="fs_fs_writev_fd_buffers_position_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -33334,588 +34944,769 @@ should be written. If <code>typeof position !== 'number'</code>, the data will b
 at the current position.</p>
 <p>The callback will be given three arguments: <code>err</code>, <code>bytesWritten</code>, and
 <code>buffers</code>. <code>bytesWritten</code> is how many bytes were written from <code>buffers</code>.</p>
-<p>If this method is <a href="#util_util_promisify_original"><code>util.promisify()</code></a>ed, it returns a <code>Promise</code> for an
+<p>If this method is <a href="#util_util_promisify_original"><code>util.promisify()</code></a>ed, it returns a promise for an
 <code>Object</code> with <code>bytesWritten</code> and <code>buffers</code> properties.</p>
 <p>It is unsafe to use <code>fs.writev()</code> multiple times on the same file without
 waiting for the callback. For this scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
 <p>On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
 the end of the file.</p>
-<h2><code>fs.writevSync(fd, buffers[, position])</code><span><a class="mark" href="#fs_fs_writevsync_fd_buffers_position" id="fs_fs_writevsync_fd_buffers_position">#</a></span></h2>
+</section><section><h3>Synchronous API<span><a class="mark" href="#fs_synchronous_api" id="fs_synchronous_api">#</a></span></h3>
+<p>The synchronous APIs perform all operations synchronously, blocking the
+event loop until the operation completes or fails.</p>
+<h4><code>fs.accessSync(path[, mode])</code><span><a class="mark" href="#fs_fs_accesssync_path_mode" id="fs_fs_accesssync_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.9.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.11.15</td>
+<td><p><span>Added in: v0.11.15</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes written.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>fs.constants.F_OK</code></li>
 </ul>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_writev_fd_buffers_position_callback"><code>fs.writev()</code></a>.</p>
-<h2><code>fs</code> Promises API<span><a class="mark" href="#fs_fs_promises_api" id="fs_fs_promises_api">#</a></span></h2>
-<p>The <code>fs.promises</code> API provides an alternative set of asynchronous file system
-methods that return <code>Promise</code> objects rather than using callbacks. The
-API is accessible via <code>require('fs').promises</code>.</p>
-<h3>Class: <code>FileHandle</code><span><a class="mark" href="#fs_class_filehandle" id="fs_class_filehandle">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
-<p>A <code>FileHandle</code> object is a wrapper for a numeric file descriptor.
-Instances of <code>FileHandle</code> are distinct from numeric file descriptors
-in that they provide an object oriented API for working with files.</p>
-<p>If a <code>FileHandle</code> is not closed using the
-<code>filehandle.close()</code> method, it might automatically close the file descriptor
-and will emit a process warning, thereby helping to prevent memory leaks.
-Please do not rely on this behavior because it is unreliable and
-the file may not be closed. Instead, always explicitly close <code>FileHandle</code>s.
-Node.js may change this behavior in the future.</p>
-<p>Instances of the <code>FileHandle</code> object are created internally by the
-<code>fsPromises.open()</code> method.</p>
-<p>Unlike the callback-based API (<code>fs.fstat()</code>, <code>fs.fchown()</code>, <code>fs.fchmod()</code>, and
-so on), a numeric file descriptor is not used by the promise-based API. Instead,
-the promise-based API uses the <code>FileHandle</code> class in order to help avoid
-accidental leaking of unclosed file descriptors after a <code>Promise</code> is resolved or
-rejected.</p>
-<h4><code>filehandle.appendFile(data, options)</code><span><a class="mark" href="#fs_filehandle_appendfile_data_options" id="fs_filehandle_appendfile_data_options">#</a></span></h4>
+<p>Synchronously tests a user's permissions for the file or directory specified
+by <code>path</code>. The <code>mode</code> argument is an optional integer that specifies the
+accessibility checks to be performed. Check <a href="#fs_file_access_constants">File access constants</a> for
+possible values of <code>mode</code>. It is possible to create a mask consisting of
+the bitwise OR of two or more values
+(e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>
+<p>If any of the accessibility checks fail, an <code>Error</code> will be thrown. Otherwise,
+the method will return <code>undefined</code>.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { accessSync, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">accessSync</span>(<span class="hljs-string">'etc/passwd'</span>, constants.<span class="hljs-property">R_OK</span> | constants.<span class="hljs-property">W_OK</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'can read/write'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'no access!'</span>);
+}</code></pre>
+<h4><code>fs.appendFileSync(path, data[, options])</code><span><a class="mark" href="#fs_fs_appendfilesync_path_data_options" id="fs_fs_appendfilesync_path_data_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.0.0</td>
+<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
+<tr><td>v5.0.0</td>
+<td><p>The <code>file</code> parameter can be a file descriptor now.</p></td></tr>
+<tr><td>v0.6.7</td>
+<td><p><span>Added in: v0.6.7</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> filename or file descriptor</li>
 <li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'a'</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Alias of <a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile()</code></a>.</p>
-<p>When operating on file handles, the mode cannot be changed from what it was set
-to with <a href="#fs_fspromises_open_path_flags_mode"><code>fsPromises.open()</code></a>. Therefore, this is equivalent to
-<a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile()</code></a>.</p>
-<h4><code>filehandle.chmod(mode)</code><span><a class="mark" href="#fs_filehandle_chmod_mode" id="fs_filehandle_chmod_mode">#</a></span></h4>
+<p>Synchronously append data to a file, creating the file if it does not yet
+exist. <code>data</code> can be a string or a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { appendFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">appendFileSync</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The "data to append" was appended to file!'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">/* Handle the error */</span>
+}</code></pre>
+<p>If <code>options</code> is a string, then it specifies the encoding:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { appendFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">appendFileSync</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>);</code></pre>
+<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened
+for appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will
+not be closed automatically.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { openSync, closeSync, appendFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">let</span> fd;
+
+<span class="hljs-keyword">try</span> {
+  fd = <span class="hljs-title function_">openSync</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'a'</span>);
+  <span class="hljs-title function_">appendFileSync</span>(fd, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">/* Handle the error */</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">if</span> (fd !== <span class="hljs-literal">undefined</span>)
+    <span class="hljs-title function_">closeSync</span>(fd);
+}</code></pre>
+<h4><code>fs.chmodSync(path, mode)</code><span><a class="mark" href="#fs_fs_chmodsync_path_mode" id="fs_fs_chmodsync_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.6.7</td>
+<td><p><span>Added in: v0.6.7</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Modifies the permissions on the file. The <code>Promise</code> is resolved with no
-arguments upon success.</p>
-<h4><code>filehandle.chown(uid, gid)</code><span><a class="mark" href="#fs_filehandle_chown_uid_gid" id="fs_filehandle_chown_uid_gid">#</a></span></h4>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.chownSync(path, uid, gid)</code><span><a class="mark" href="#fs_fs_chownsync_path_uid_gid" id="fs_fs_chownsync_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.97</td>
+<td><p><span>Added in: v0.1.97</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Changes the ownership of the file then resolves the <code>Promise</code> with no arguments
-upon success.</p>
-<h4><code>filehandle.close()</code><span><a class="mark" href="#fs_filehandle_close" id="fs_filehandle_close">#</a></span></h4>
+<p>Synchronously changes owner and group of a file. Returns <code>undefined</code>.
+This is the synchronous version of <a href="#fs_fs_chown_path_uid_gid_callback"><code>fs.chown()</code></a>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.closeSync(fd)</code><span><a class="mark" href="#fs_fs_closesync_fd" id="fs_fs_closesync_fd">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.1.21</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> A <code>Promise</code> that will be resolved once the underlying
-file descriptor is closed, or will be rejected if an error occurs while
-closing.</li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Closes the file descriptor.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).promises;
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">openAndClose</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">let</span> filehandle;
-  <span class="hljs-keyword">try</span> {
-    filehandle = <span class="hljs-keyword">await</span> fsPromises.open(<span class="hljs-string">'thefile.txt'</span>, <span class="hljs-string">'r'</span>);
-  } <span class="hljs-keyword">finally</span> {
-    <span class="hljs-keyword">if</span> (filehandle !== <span class="hljs-literal">undefined</span>)
-      <span class="hljs-keyword">await</span> filehandle.close();
-  }
-}</code></pre>
-<h4><code>filehandle.datasync()</code><span><a class="mark" href="#fs_filehandle_datasync" id="fs_filehandle_datasync">#</a></span></h4>
+<p>Closes the file descriptor. Returns <code>undefined</code>.</p>
+<p>Calling <code>fs.closeSync()</code> on any file descriptor (<code>fd</code>) that is currently in use
+through any other <code>fs</code> operation may lead to undefined behavior.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/close.2.html"><code>close(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.copyFileSync(src, dest[, mode])</code><span><a class="mark" href="#fs_fs_copyfilesync_src_dest_mode" id="fs_fs_copyfilesync_src_dest_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
+<tr><td>v8.5.0</td>
+<td><p><span>Added in: v8.5.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
+<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon
-success.</p>
-<h4><code>filehandle.fd</code><span><a class="mark" href="#fs_filehandle_fd" id="fs_filehandle_fd">#</a></span></h4>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
+<p>Synchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
+already exists. Returns <code>undefined</code>. Node.js makes no guarantees about the
+atomicity of the copy operation. If an error occurs after the destination file
+has been opened for writing, Node.js will attempt to remove the destination.</p>
+<p><code>mode</code> is an optional integer that specifies the behavior
+of the copy operation. It is possible to create a mask consisting of the bitwise
+OR of two or more values (e.g.
+<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The numeric file descriptor managed by the <code>FileHandle</code> object.</li>
+<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already
+exists.</li>
+<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a
+copy-on-write reflink. If the platform does not support copy-on-write, then a
+fallback copy mechanism is used.</li>
+<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
+create a copy-on-write reflink. If the platform does not support
+copy-on-write, then the operation will fail.</li>
 </ul>
-<h4><code>filehandle.read(buffer, offset, length, position)</code><span><a class="mark" href="#fs_filehandle_read_buffer_offset_length_position" id="fs_filehandle_read_buffer_offset_length_position">#</a></span></h4>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { copyFileSync, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
+<span class="hljs-title function_">copyFileSync</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
+
+<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
+<span class="hljs-title function_">copyFileSync</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, constants.<span class="hljs-property">COPYFILE_EXCL</span>);</code></pre>
+<h4><code>fs.existsSync(path)</code><span><a class="mark" href="#fs_fs_existssync_path" id="fs_fs_existssync_path">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Read data from the file.</p>
-<p><code>buffer</code> is the buffer that the data will be written to.</p>
-<p><code>offset</code> is the offset in the buffer to start writing at.</p>
-<p><code>length</code> is an integer specifying the number of bytes to read.</p>
-<p><code>position</code> is an argument specifying where to begin reading from in the file.
-If <code>position</code> is <code>null</code>, data will be read from the current file position,
-and the file position will be updated.
-If <code>position</code> is an integer, the file position will remain unchanged.</p>
-<p>Following successful read, the <code>Promise</code> is resolved with an object with a
-<code>bytesRead</code> property specifying the number of bytes read, and a <code>buffer</code>
-property that is a reference to the passed in <code>buffer</code> argument.</p>
-<h4><code>filehandle.read(options)</code><span><a class="mark" href="#fs_filehandle_read_options" id="fs_filehandle_read_options">#</a></span></h4>
+<p>Returns <code>true</code> if the path exists, <code>false</code> otherwise.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_exists_path_callback"><code>fs.exists()</code></a>.</p>
+<p><code>fs.exists()</code> is deprecated, but <code>fs.existsSync()</code> is not. The <code>callback</code>
+parameter to <code>fs.exists()</code> accepts parameters that are inconsistent with other
+Node.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { existsSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">if</span> (<span class="hljs-title function_">existsSync</span>(<span class="hljs-string">'/etc/passwd'</span>))
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The path exists.'</span>);</code></pre>
+<h4><code>fs.fchmodSync(fd, mode)</code><span><a class="mark" href="#fs_fs_fchmodsync_fd_mode" id="fs_fs_fchmodsync_fd_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v0.4.7</span>
 </div>
 <ul>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a> <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.length</code></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<h4><code>filehandle.readFile(options)</code><span><a class="mark" href="#fs_filehandle_readfile_options" id="fs_filehandle_readfile_options">#</a></span></h4>
+<p>Sets the permissions on the file. Returns <code>undefined</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fchmod.2.html"><code>fchmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fchownSync(fd, uid, gid)</code><span><a class="mark" href="#fs_fs_fchownsync_fd_uid_gid" id="fs_fs_fchownsync_fd_uid_gid">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.4.7</span>
 </div>
 <ul>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new owner's user id.</li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new group's group id.</li>
 </ul>
-<p>Asynchronously reads the entire contents of a file.</p>
-<p>The <code>Promise</code> is resolved with the contents of the file. If no encoding is
-specified (using <code>options.encoding</code>), the data is returned as a <code>Buffer</code>
-object. Otherwise, the data will be a string.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>The <code>FileHandle</code> has to support reading.</p>
-<p>If one or more <code>filehandle.read()</code> calls are made on a file handle and then a
-<code>filehandle.readFile()</code> call is made, the data will be read from the current
-position till the end of the file. It doesn't always read from the beginning
-of the file.</p>
-<h4><code>filehandle.readv(buffers[, position])</code><span><a class="mark" href="#fs_filehandle_readv_buffers_position" id="fs_filehandle_readv_buffers_position">#</a></span></h4>
+<p>Sets the owner of the file. Returns <code>undefined</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fchown.2.html"><code>fchown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fdatasyncSync(fd)</code><span><a class="mark" href="#fs_fs_fdatasyncsync_fd" id="fs_fs_fdatasyncsync_fd">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v0.1.96</span>
 </div>
 <ul>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Read from a file and write to an array of <code>ArrayBufferView</code>s</p>
-<p>The <code>Promise</code> is resolved with an object containing a <code>bytesRead</code> property
-identifying the number of bytes read, and a <code>buffers</code> property containing
-a reference to the <code>buffers</code> input.</p>
-<p><code>position</code> is the offset from the beginning of the file where this data
-should be read from. If <code>typeof position !== 'number'</code>, the data will be read
-from the current position.</p>
-<h4><code>filehandle.stat([options])</code><span><a class="mark" href="#fs_filehandle_stat_options" id="fs_filehandle_stat_options">#</a></span></h4>
+<p>Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+<a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a> documentation for details. Returns <code>undefined</code>.</p>
+<h4><code>fs.fstatSync(fd[, options])</code><span><a class="mark" href="#fs_fs_fstatsync_fd_options" id="fs_fs_fstatsync_fd_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.5.0</td>
 <td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
+<tr><td>v0.1.95</td>
+<td><p><span>Added in: v0.1.95</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Retrieves the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> for the file.</p>
-<h4><code>filehandle.sync()</code><span><a class="mark" href="#fs_filehandle_sync" id="fs_filehandle_sync">#</a></span></h4>
+<p>Retrieves the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the file descriptor.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fstat.2.html"><code>fstat(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fsyncSync(fd)</code><span><a class="mark" href="#fs_fs_fsyncsync_fd" id="fs_fs_fsyncsync_fd">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.1.96</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon
-success.</p>
-<h4><code>filehandle.truncate(len)</code><span><a class="mark" href="#fs_filehandle_truncate_len" id="fs_filehandle_truncate_len">#</a></span></h4>
+<p>Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a> documentation for more detail. Returns <code>undefined</code>.</p>
+<h4><code>fs.ftruncateSync(fd[, len])</code><span><a class="mark" href="#fs_fs_ftruncatesync_fd_len" id="fs_fs_ftruncatesync_fd_len">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.8.6</span>
 </div>
 <ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Truncates the file then resolves the <code>Promise</code> with no arguments upon success.</p>
-<p>If the file was larger than <code>len</code> bytes, only the first <code>len</code> bytes will be
-retained in the file.</p>
-<p>For example, the following program retains only the first four bytes of the
-file:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fsPromises = fs.promises;
-
-<span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-<span class="hljs-comment">// Prints: Node.js</span>
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">doTruncate</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">let</span> filehandle = <span class="hljs-literal">null</span>;
-  <span class="hljs-keyword">try</span> {
-    filehandle = <span class="hljs-keyword">await</span> fsPromises.open(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
-    <span class="hljs-keyword">await</span> filehandle.truncate(<span class="hljs-number">4</span>);
-  } <span class="hljs-keyword">finally</span> {
-    <span class="hljs-keyword">if</span> (filehandle) {
-      <span class="hljs-comment">// Close the file if it is opened.</span>
-      <span class="hljs-keyword">await</span> filehandle.close();
-    }
-  }
-  <span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));  <span class="hljs-comment">// Prints: Node</span>
-}
-
-doTruncate().catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the
-extended part is filled with null bytes (<code>'\0'</code>):</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fsPromises = fs.promises;
-
-<span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-<span class="hljs-comment">// Prints: Node.js</span>
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">doTruncate</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">let</span> filehandle = <span class="hljs-literal">null</span>;
-  <span class="hljs-keyword">try</span> {
-    filehandle = <span class="hljs-keyword">await</span> fsPromises.open(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
-    <span class="hljs-keyword">await</span> filehandle.truncate(<span class="hljs-number">10</span>);
-  } <span class="hljs-keyword">finally</span> {
-    <span class="hljs-keyword">if</span> (filehandle) {
-      <span class="hljs-comment">// Close the file if it is opened.</span>
-      <span class="hljs-keyword">await</span> filehandle.close();
-    }
-  }
-  <span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));  <span class="hljs-comment">// Prints Node.js\0\0\0</span>
-}
-
-doTruncate().catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<p>The last three bytes are null bytes (<code>'\0'</code>), to compensate the over-truncation.</p>
-<h4><code>filehandle.utimes(atime, mtime)</code><span><a class="mark" href="#fs_filehandle_utimes_atime_mtime" id="fs_filehandle_utimes_atime_mtime">#</a></span></h4>
+<p>Truncates the file descriptor. Returns <code>undefined</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate()</code></a>.</p>
+<h4><code>fs.futimesSync(fd, atime, mtime)</code><span><a class="mark" href="#fs_fs_futimessync_fd_atime_mtime" id="fs_fs_futimessync_fd_atime_mtime">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v4.1.0</td>
+<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
+<tr><td>v0.4.2</td>
+<td><p><span>Added in: v0.4.2</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 <li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Change the file system timestamps of the object referenced by the <code>FileHandle</code>
-then resolves the <code>Promise</code> with no arguments upon success.</p>
-<p>This function does not work on AIX versions before 7.1, it will resolve the
-<code>Promise</code> with an error using code <code>UV_ENOSYS</code>.</p>
-<h4><code>filehandle.write(buffer[, offset[, length[, position]]])</code><span><a class="mark" href="#fs_filehandle_write_buffer_offset_length_position" id="fs_filehandle_write_buffer_offset_length_position">#</a></span></h4>
+<p>Synchronous version of <a href="#fs_fs_futimes_fd_atime_mtime_callback"><code>fs.futimes()</code></a>. Returns <code>undefined</code>.</p>
+<h4><code>fs.lchmodSync(path, mode)</code><span><a class="mark" href="#fs_fs_lchmodsync_path_mode" id="fs_fs_lchmodsync_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Deprecated since: v0.4.7</span>
 </div>
 <ul>
-<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Write <code>buffer</code> to the file.</p>
-<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property
-identifying the number of bytes written, and a <code>buffer</code> property containing
-a reference to the <code>buffer</code> written.</p>
-<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is
-an integer specifying the number of bytes to write.</p>
-<p><code>position</code> refers to the offset from the beginning of the file where this data
-should be written. If <code>typeof position !== 'number'</code>, the data will be written
-at the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
-<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file
-without waiting for the <code>Promise</code> to be resolved (or rejected). For this
-scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
-<p>On Linux, positional writes do not work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<h4><code>filehandle.write(string[, position[, encoding]])</code><span><a class="mark" href="#fs_filehandle_write_string_position_encoding" id="fs_filehandle_write_string_position_encoding">#</a></span></h4>
+<p>Changes the permissions on a symbolic link. Returns <code>undefined</code>.</p>
+<p>This method is only implemented on macOS.</p>
+<p>See the POSIX <a href="https://www.freebsd.org/cgi/man.cgi?query=lchmod&#x26;sektion=2"><code>lchmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.lchownSync(path, uid, gid)</code><span><a class="mark" href="#fs_fs_lchownsync_path_uid_gid" id="fs_fs_lchownsync_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.6.0</td>
+<td><p>This API is no longer deprecated.</p></td></tr>
+<tr><td>v0.4.7</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new owner's user id.</li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new group's group id.</li>
 </ul>
-<p>Write <code>string</code> to the file. If <code>string</code> is not a string, then
-the value will be coerced to one.</p>
-<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property
-identifying the number of bytes written, and a <code>buffer</code> property containing
-a reference to the <code>string</code> written.</p>
-<p><code>position</code> refers to the offset from the beginning of the file where this data
-should be written. If the type of <code>position</code> is not a <code>number</code> the data
-will be written at the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
-<p><code>encoding</code> is the expected string encoding.</p>
-<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file
-without waiting for the <code>Promise</code> to be resolved (or rejected). For this
-scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
-<p>On Linux, positional writes do not work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<h4><code>filehandle.writeFile(data, options)</code><span><a class="mark" href="#fs_filehandle_writefile_data_options" id="fs_filehandle_writefile_data_options">#</a></span></h4>
+<p>Set the owner for the path. Returns <code>undefined</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/lchown.2.html"><code>lchown(2)</code></a> documentation for more details.</p>
+<h4><code>fs.lutimesSync(path, atime, mtime)</code><span><a class="mark" href="#fs_fs_lutimessync_path_atime_mtime" id="fs_fs_lutimessync_path_atime_mtime">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v14.5.0, v12.19.0</span>
 </div>
 <ul>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>Asynchronously writes data to a file, replacing the file if it already exists.
-<code>data</code> can be a string or a buffer. The <code>Promise</code> will be resolved with no
-arguments upon success.</p>
-<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>The <code>FileHandle</code> has to support writing.</p>
-<p>It is unsafe to use <code>filehandle.writeFile()</code> multiple times on the same file
-without waiting for the <code>Promise</code> to be resolved (or rejected).</p>
-<p>If one or more <code>filehandle.write()</code> calls are made on a file handle and then a
-<code>filehandle.writeFile()</code> call is made, the data will be written from the
-current position till the end of the file. It doesn't always write from the
-beginning of the file.</p>
-<h4><code>filehandle.writev(buffers[, position])</code><span><a class="mark" href="#fs_filehandle_writev_buffers_position" id="fs_filehandle_writev_buffers_position">#</a></span></h4>
+<p>Change the file system timestamps of the symbolic link referenced by <code>path</code>.
+Returns <code>undefined</code>, or throws an exception when parameters are incorrect or
+the operation fails. This is the synchronous version of <a href="#fs_fs_lutimes_path_atime_mtime_callback"><code>fs.lutimes()</code></a>.</p>
+<h4><code>fs.linkSync(existingPath, newPath)</code><span><a class="mark" href="#fs_fs_linksync_existingpath_newpath" id="fs_fs_linksync_existingpath_newpath">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.9.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>existingPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 </ul>
-<p>Write an array of <code>ArrayBufferView</code>s to the file.</p>
-<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property
-identifying the number of bytes written, and a <code>buffers</code> property containing
-a reference to the <code>buffers</code> input.</p>
-<p><code>position</code> is the offset from the beginning of the file where this data
-should be written. If <code>typeof position !== 'number'</code>, the data will be written
-at the current position.</p>
-<p>It is unsafe to call <code>writev()</code> multiple times on the same file without waiting
-for the previous operation to complete.</p>
-<p>On Linux, positional writes don't work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<h3><code>fsPromises.access(path[, mode])</code><span><a class="mark" href="#fs_fspromises_access_path_mode" id="fs_fspromises_access_path_mode">#</a></span></h3>
+<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX
+<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a> documentation for more detail. Returns <code>undefined</code>.</p>
+<h4><code>fs.lstatSync(path[, options])</code><span><a class="mark" href="#fs_fs_lstatsync_path_options" id="fs_fs_lstatsync_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Accepts a <code>throwIfNoEntry</code> option to specify whether an exception should be thrown if the entry does not exist.</p></td></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.30</td>
+<td><p><span>Added in: v0.1.30</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>fs.constants.F_OK</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
-</ul>
-<p>Tests a user's permissions for the file or directory specified by <code>path</code>.
-The <code>mode</code> argument is an optional integer that specifies the accessibility
-checks to be performed. Check <a href="#fs_file_access_constants">File access constants</a> for possible values
-of <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of
-two or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>
-<p>If the accessibility check is successful, the <code>Promise</code> is resolved with no
-value. If any of the accessibility checks fail, the <code>Promise</code> is rejected
-with an <code>Error</code> object. The following example checks if the file
-<code>/etc/passwd</code> can be read and written by the current process.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fsPromises = fs.promises;
-
-fsPromises.access(<span class="hljs-string">'/etc/passwd'</span>, fs.constants.R_OK | fs.constants.W_OK)
-  .then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'can access'</span>))
-  .catch(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'cannot access'</span>));</code></pre>
-<p>Using <code>fsPromises.access()</code> to check for the accessibility of a file before
-calling <code>fsPromises.open()</code> is not recommended. Doing so introduces a race
-condition, since other processes may change the file's state between the two
-calls. Instead, user code should open/read/write the file directly and handle
-the error raised if the file is not accessible.</p>
-<h3><code>fsPromises.appendFile(path, data[, options])</code><span><a class="mark" href="#fs_fspromises_appendfile_path_data_options" id="fs_fspromises_appendfile_path_data_options">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'a'</code>.</li>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>throwIfNoEntry</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether an exception will be thrown
+if no file system entry exists, rather than returning <code>undefined</code>.
+<strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Asynchronously append data to a file, creating the file if it does not yet
-exist. <code>data</code> can be a string or a <a href="#buffer_buffer"><code>Buffer</code></a>. The <code>Promise</code> will be
-resolved with no arguments upon success.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>The <code>path</code> may be specified as a <code>FileHandle</code> that has been opened
-for appending (using <code>fsPromises.open()</code>).</p>
-<h3><code>fsPromises.chmod(path, mode)</code><span><a class="mark" href="#fs_fspromises_chmod_path_mode" id="fs_fspromises_chmod_path_mode">#</a></span></h3>
+<p>Retrieves the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the symbolic link referred to by <code>path</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a> documentation for more details.</p>
+<h4><code>fs.mkdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_mkdirsync_path_options" id="fs_fs_mkdirsync_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.11.0, v12.17.0</td>
+<td><p>In <code>recursive</code> mode, the first created path is returned now.</p></td></tr>
+<tr><td>v10.12.0</td>
+<td><p>The second argument can now be an <code>options</code> object with <code>recursive</code> and <code>mode</code> properties.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
-</ul>
-<p>Changes the permissions of a file then resolves the <code>Promise</code> with no
-arguments upon succces.</p>
-<h3><code>fsPromises.chown(path, uid, gid)</code><span><a class="mark" href="#fs_fspromises_chown_path_uid_gid" id="fs_fspromises_chown_path_uid_gid">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
+<ul>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
+</ul>
+<p>Synchronously creates a directory. Returns <code>undefined</code>, or if <code>recursive</code> is
+<code>true</code>, the first directory path created.
+This is the synchronous version of <a href="#fs_fs_mkdir_path_options_callback"><code>fs.mkdir()</code></a>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/mkdir.2.html"><code>mkdir(2)</code></a> documentation for more details.</p>
+<h4><code>fs.mkdtempSync(prefix[, options])</code><span><a class="mark" href="#fs_fs_mkdtempsync_prefix_options" id="fs_fs_mkdtempsync_prefix_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>prefix</code> parameter now accepts an empty string.</p></td></tr>
+<tr><td>v5.10.0</td>
+<td><p><span>Added in: v5.10.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Returns the created directory path.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_mkdtemp_prefix_options_callback"><code>fs.mkdtemp()</code></a>.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use.</p>
+<h4><code>fs.opendirSync(path[, options])</code><span><a class="mark" href="#fs_fs_opendirsync_path_options" id="fs_fs_opendirsync_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
+<tr><td>v12.12.0</td>
+<td><p><span>Added in: v12.12.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
+internally when reading from the directory. Higher values lead to better
+performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
 </ul>
-<p>Changes the ownership of a file then resolves the <code>Promise</code> with no arguments
-upon success.</p>
-<h3><code>fsPromises.copyFile(src, dest[, flags])</code><span><a class="mark" href="#fs_fspromises_copyfile_src_dest_flags" id="fs_fspromises_copyfile_src_dest_flags">#</a></span></h3>
+</li>
+<li>Returns: <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a></li>
+</ul>
+<p>Synchronously open a directory. See <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a>.</p>
+<p>Creates an <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>, which contains all further functions for reading from
+and cleaning up the directory.</p>
+<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
+directory and subsequent read operations.</p>
+<h4><code>fs.openSync(path[, flags[, mode]])</code><span><a class="mark" href="#fs_fs_opensync_path_flags_mode" id="fs_fs_opensync_path_flags_mode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v14.0.0</td>
-<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
+<tr><td>v11.1.0</td>
+<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
+<tr><td>v9.9.0</td>
+<td><p>The <code>as</code> and <code>as+</code> flags are supported now.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
-<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>'r'</code>.
+See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
-already exists. The <code>Promise</code> will be resolved with no arguments upon success.</p>
-<p>Node.js makes no guarantees about the atomicity of the copy operation. If an
-error occurs after the destination file has been opened for writing, Node.js
-will attempt to remove the destination.</p>
-<p><code>flags</code> is an optional integer that specifies the behavior
-of the copy operation. It is possible to create a mask consisting of the bitwise
-OR of two or more values (e.g.
-<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
+<p>Returns an integer representing the file descriptor.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>.</p>
+<h4><code>fs.readdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_readdirsync_path_options" id="fs_fs_readdirsync_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.10.0</td>
+<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
 <ul>
-<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already
-exists.</li>
-<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a
-copy-on-write reflink. If the platform does not support copy-on-write, then a
-fallback copy mechanism is used.</li>
-<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).promises;
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent[]></a></li>
+</ul>
+<p>Reads the contents of the directory.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> documentation for more details.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the filenames returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the filenames returned will be passed as <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> objects.</p>
+<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the result will contain
+<a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> objects.</p>
+<h4><code>fs.readFileSync(path[, options])</code><span><a class="mark" href="#fs_fs_readfilesync_path_options" id="fs_fs_readfilesync_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v5.0.0</td>
+<td><p>The <code>path</code> parameter can be a file descriptor now.</p></td></tr>
+<tr><td>v0.1.8</td>
+<td><p><span>Added in: v0.1.8</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+</ul>
+<p>Returns the contents of the <code>path</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile()</code></a>.</p>
+<p>If the <code>encoding</code> option is specified then this function returns a
+string. Otherwise it returns a buffer.</p>
+<p>Similar to <a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile()</code></a>, when the path is a directory, the behavior of
+<code>fs.readFileSync()</code> is platform-specific.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
-fsPromises.copyFile(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>)
-  .then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'source.txt was copied to destination.txt'</span>))
-  .catch(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The file could not be copied'</span>));</code></pre>
-<p>If the third argument is a number, then it specifies <code>flags</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fsPromises = fs.promises;
-<span class="hljs-keyword">const</span> { COPYFILE_EXCL } = fs.constants;
+<span class="hljs-comment">// macOS, Linux, and Windows</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'&#x3C;directory>'</span>);
+<span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]</span>
 
-<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
-fsPromises.copyFile(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, COPYFILE_EXCL)
-  .then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'source.txt was copied to destination.txt'</span>))
-  .catch(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The file could not be copied'</span>));</code></pre>
-<h3><code>fsPromises.lchmod(path, mode)</code><span><a class="mark" href="#fs_fspromises_lchmod_path_mode" id="fs_fspromises_lchmod_path_mode">#</a></span></h3>
+<span class="hljs-comment">//  FreeBSD</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'&#x3C;directory>'</span>); <span class="hljs-comment">// => &#x3C;data></span></code></pre>
+<h4><code>fs.readlinkSync(path[, options])</code><span><a class="mark" href="#fs_fs_readlinksync_path_options" id="fs_fs_readlinksync_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Deprecated since: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>Changes the permissions on a symbolic link then resolves the <code>Promise</code> with
-no arguments upon success. This method is only implemented on macOS.</p>
-<h3><code>fsPromises.lchown(path, uid, gid)</code><span><a class="mark" href="#fs_fspromises_lchown_path_uid_gid" id="fs_fspromises_lchown_path_uid_gid">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+</ul>
+<p>Returns the symbolic link's string value.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a> documentation for more details.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the link path returned will be passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<h4><code>fs.readSync(fd, buffer, offset, length, position)</code><span><a class="mark" href="#fs_fs_readsync_fd_buffer_offset_length_position" id="fs_fs_readsync_fd_buffer_offset_length_position">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.6.0</td>
-<td><p>This API is no longer deprecated.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
+<tr><td>v10.10.0</td>
+<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
+<tr><td>v6.0.0</td>
+<td><p>The <code>length</code> parameter can now be <code>0</code>.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>Returns the number of <code>bytesRead</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a>.</p>
+<h4><code>fs.readSync(fd, buffer, [options])</code><span><a class="mark" href="#fs_fs_readsync_fd_buffer_options" id="fs_fs_readsync_fd_buffer_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.13.0, v12.17.0</td>
+<td><p><span>Added in: v13.13.0, v12.17.0</span></p></td></tr>
+<tr><td>v13.13.0, v12.17.0</td>
+<td><p>Options object can be passed in to make offset, length and position optional.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> <strong>Default:</strong> <code>null</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>Returns the number of <code>bytesRead</code>.</p>
+<p>Similar to the above <code>fs.readSync</code> function, this version takes an optional <code>options</code> object.
+If no <code>options</code> object is specified, it will default with the above values.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a>.</p>
+<h4><code>fs.readvSync(fd, buffers[, position])</code><span><a class="mark" href="#fs_fs_readvsync_fd_buffers_position" id="fs_fs_readvsync_fd_buffers_position">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.13.0, v12.17.0</span>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes read.</li>
+</ul>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv()</code></a>.</p>
+<h4><code>fs.realpathSync(path[, options])</code><span><a class="mark" href="#fs_fs_realpathsync_path_options" id="fs_fs_realpathsync_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v8.0.0</td>
+<td><p>Pipe/Socket resolve support was added.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v6.4.0</td>
+<td><p>Calling <code>realpathSync</code> now works again for various edge cases on Windows.</p></td></tr>
+<tr><td>v6.0.0</td>
+<td><p>The <code>cache</code> parameter was removed.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>Changes the ownership on a symbolic link then resolves the <code>Promise</code> with
-no arguments upon success.</p>
-<h3><code>fsPromises.lutimes(path, atime, mtime)</code><span><a class="mark" href="#fs_fspromises_lutimes_path_atime_mtime" id="fs_fspromises_lutimes_path_atime_mtime">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+</ul>
+<p>Returns the resolved pathname.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_realpath_path_options_callback"><code>fs.realpath()</code></a>.</p>
+<h4><code>fs.realpathSync.native(path[, options])</code><span><a class="mark" href="#fs_fs_realpathsync_native_path_options" id="fs_fs_realpathsync_native_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v9.2.0</span>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>Changes the access and modification times of a file in the same way as
-<a href="#fs_fspromises_utimes_path_atime_mtime"><code>fsPromises.utimes()</code></a>, with the difference that if the path refers to a
-symbolic link, then the link is not dereferenced: instead, the timestamps of
-the symbolic link itself are changed.</p>
-<p>Upon success, the <code>Promise</code> is resolved without arguments.</p>
-<h3><code>fsPromises.link(existingPath, newPath)</code><span><a class="mark" href="#fs_fspromises_link_existingpath_newpath" id="fs_fspromises_link_existingpath_newpath">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+</ul>
+<p>Synchronous <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a>.</p>
+<p>Only paths that can be converted to UTF8 strings are supported.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the path returned will be passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
+be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
+this restriction.</p>
+<h4><code>fs.renameSync(oldPath, newPath)</code><span><a class="mark" href="#fs_fs_renamesync_oldpath_newpath" id="fs_fs_renamesync_oldpath_newpath">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>oldPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon success.</p>
-<h3><code>fsPromises.lstat(path[, options])</code><span><a class="mark" href="#fs_fspromises_lstat_path_options" id="fs_fspromises_lstat_path_options">#</a></span></h3>
+<p>Renames the file from <code>oldPath</code> to <code>newPath</code>. Returns <code>undefined</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a> documentation for more details.</p>
+<h4><code>fs.rmdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_rmdirsync_path_options" id="fs_fs_rmdirsync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
+<tr><td>v14.14.0</td>
+<td><p>The <code>recursive</code> option is deprecated, use <code>fs.rmSync</code> instead.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
+<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
+<tr><td>v12.10.0</td>
+<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameters can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -33923,405 +35714,1046 @@ the symbolic link itself are changed.</p>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js retries the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode, errors are not reported if <code>path</code> does not exist, and
+operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a>. The <code>Promise</code> is resolved with the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object
-for the given symbolic link <code>path</code>.</p>
-<h3><code>fsPromises.mkdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_mkdir_path_options" id="fs_fspromises_mkdir_path_options">#</a></span></h3>
+<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/rmdir.2.html"><code>rmdir(2)</code></a>. Returns <code>undefined</code>.</p>
+<p>Using <code>fs.rmdirSync()</code> on a file (not a directory) results in an <code>ENOENT</code> error
+on Windows and an <code>ENOTDIR</code> error on POSIX.</p>
+<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command
+<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in
+the future.</p>
+<h4><code>fs.rmSync(path[, options])</code><span><a class="mark" href="#fs_fs_rmsync_path_options" id="fs_fs_rmsync_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v14.14.0</span>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
+<li><code>force</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, exceptions will be ignored if <code>path</code> does
+not exist. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Asynchronously creates a directory then resolves the <code>Promise</code> with either no
-arguments, or the first directory path created if <code>recursive</code> is <code>true</code>.</p>
-<p>The optional <code>options</code> argument can be an integer specifying mode (permission
-and sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>
-property indicating whether parent directories should be created. Calling
-<code>fsPromises.mkdir()</code> when <code>path</code> is a directory that exists results in a
-rejection only when <code>recursive</code> is false.</p>
-<h3><code>fsPromises.mkdtemp(prefix[, options])</code><span><a class="mark" href="#fs_fspromises_mkdtemp_prefix_options" id="fs_fspromises_mkdtemp_prefix_options">#</a></span></h3>
+<p>Synchronously removes files and directories (modeled on the standard POSIX <code>rm</code>
+utility). Returns <code>undefined</code>.</p>
+<h4><code>fs.statSync(path[, options])</code><span><a class="mark" href="#fs_fs_statsync_path_options" id="fs_fs_statsync_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Accepts a <code>throwIfNoEntry</code> option to specify whether an exception should be thrown if the entry does not exist.</p></td></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>throwIfNoEntry</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether an exception will be thrown
+if no file system entry exists, rather than returning <code>undefined</code>.
+<strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Creates a unique temporary directory and resolves the <code>Promise</code> with the created
-directory path. A unique directory name is generated by appending six random
-characters to the end of the provided <code>prefix</code>. Due to platform
-inconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,
-notably the BSDs, can return more than six random characters, and replace
-trailing <code>X</code> characters in <code>prefix</code> with random characters.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use.</p>
-<pre><code class="language-js">fsPromises.mkdtemp(path.join(os.tmpdir(), <span class="hljs-string">'foo-'</span>))
-  .catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<p>The <code>fsPromises.mkdtemp()</code> method will append the six randomly selected
-characters directly to the <code>prefix</code> string. For instance, given a directory
-<code>/tmp</code>, if the intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the
-<code>prefix</code> must end with a trailing platform-specific path separator
-(<code>require('path').sep</code>).</p>
-<h3><code>fsPromises.open(path, flags[, mode])</code><span><a class="mark" href="#fs_fspromises_open_path_flags_mode" id="fs_fspromises_open_path_flags_mode">#</a></span></h3>
+<p>Retrieves the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the path.</p>
+<h4><code>fs.symlinkSync(target, path[, type])</code><span><a class="mark" href="#fs_fs_symlinksync_target_path_type" id="fs_fs_symlinksync_target_path_type">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.1.0</td>
-<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
+<tr><td>v12.0.0</td>
+<td><p>If the <code>type</code> argument is left undefined, Node will autodetect <code>target</code> type and automatically select <code>dir</code> or <code>file</code>.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>target</code> and <code>path</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
+<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.
-<strong>Default:</strong> <code>'r'</code>.</li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code> (readable and writable)</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>Asynchronous file open that returns a <code>Promise</code> that, when resolved, yields a
-<code>FileHandle</code> object. See <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a>.</p>
-<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was
-created.</p>
-<p>Some characters (<code>&#x3C; > : " / \ | ? *</code>) are reserved under Windows as documented
-by <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains
-a colon, Node.js will open a file system stream, as described by
-<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams">this MSDN page</a>.</p>
-<h3><code>fsPromises.opendir(path[, options])</code><span><a class="mark" href="#fs_fspromises_opendir_path_options" id="fs_fspromises_opendir_path_options">#</a></span></h3>
+<p>Returns <code>undefined</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink()</code></a>.</p>
+<h4><code>fs.truncateSync(path[, len])</code><span><a class="mark" href="#fs_fs_truncatesync_path_len" id="fs_fs_truncatesync_path_len">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.8.6</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+</ul>
+<p>Truncates the file. Returns <code>undefined</code>. A file descriptor can also be
+passed as the first argument. In this case, <code>fs.ftruncateSync()</code> is called.</p>
+<p>Passing a file descriptor is deprecated and may result in an error being thrown
+in the future.</p>
+<h4><code>fs.unlinkSync(path)</code><span><a class="mark" href="#fs_fs_unlinksync_path" id="fs_fs_unlinksync_path">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
-<tr><td>v12.12.0</td>
-<td><p><span>Added in: v12.12.0</span></p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+</ul>
+<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>. Returns <code>undefined</code>.</p>
+<h4><code>fs.utimesSync(path, atime, mtime)</code><span><a class="mark" href="#fs_fs_utimessync_path_atime_mtime" id="fs_fs_utimessync_path_atime_mtime">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v8.0.0</td>
+<td><p><code>NaN</code>, <code>Infinity</code>, and <code>-Infinity</code> are no longer valid time specifiers.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v4.1.0</td>
+<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
+<tr><td>v0.4.2</td>
+<td><p><span>Added in: v0.4.2</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+</ul>
+<p>Returns <code>undefined</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>.</p>
+<h4><code>fs.writeFileSync(file, data[, options])</code><span><a class="mark" href="#fs_fs_writefilesync_file_data_options" id="fs_fs_writefilesync_file_data_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>data</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>data</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v10.10.0</td>
+<td><p>The <code>data</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
+<tr><td>v7.4.0</td>
+<td><p>The <code>data</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
+<tr><td>v5.0.0</td>
+<td><p>The <code>file</code> parameter can be a file descriptor now.</p></td></tr>
+<tr><td>v0.1.29</td>
+<td><p><span>Added in: v0.1.29</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
-internally when reading from the directory. Higher values lead to better
-performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> containing <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a></li>
 </ul>
-<p>Asynchronously open a directory. See <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a>.</p>
-<p>Creates an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a>, which contains all further functions for reading from
-and cleaning up the directory.</p>
-<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
-directory and subsequent read operations.</p>
-<p>Example using async iteration:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<p>Returns <code>undefined</code>.</p>
+<p>If <code>data</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_writefile_file_data_options_callback"><code>fs.writeFile()</code></a>.</p>
+<h4><code>fs.writeSync(fd, buffer[, offset[, length[, position]]])</code><span><a class="mark" href="#fs_fs_writesync_fd_buffer_offset_length_position" id="fs_fs_writesync_fd_buffer_offset_length_position">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>buffer</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>buffer</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v10.10.0</td>
+<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
+<tr><td>v7.4.0</td>
+<td><p>The <code>buffer</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
+<tr><td>v7.2.0</td>
+<td><p>The <code>offset</code> and <code>length</code> parameters are optional now.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes written.</li>
+</ul>
+<p>If <code>buffer</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_write_fd_buffer_offset_length_position_callback"><code>fs.write(fd, buffer...)</code></a>.</p>
+<h4><code>fs.writeSync(fd, string[, position[, encoding]])</code><span><a class="mark" href="#fs_fs_writesync_fd_string_position_encoding" id="fs_fs_writesync_fd_string_position_encoding">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>string</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>string</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v7.2.0</td>
+<td><p>The <code>position</code> parameter is optional now.</p></td></tr>
+<tr><td>v0.11.5</td>
+<td><p><span>Added in: v0.11.5</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes written.</li>
+</ul>
+<p>If <code>string</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_write_fd_string_position_encoding_callback"><code>fs.write(fd, string...)</code></a>.</p>
+<h4><code>fs.writevSync(fd, buffers[, position])</code><span><a class="mark" href="#fs_fs_writevsync_fd_buffers_position" id="fs_fs_writevsync_fd_buffers_position">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.9.0</span>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes written.</li>
+</ul>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_writev_fd_buffers_position_callback"><code>fs.writev()</code></a>.</p>
+</section><section><h3>Common Objects<span><a class="mark" href="#fs_common_objects" id="fs_common_objects">#</a></span></h3>
+<p>The common objects are shared by all of the file system API variants
+(promise, callback, and synchronous).</p>
+<h4>Class: <code>fs.Dir</code><span><a class="mark" href="#fs_class_fs_dir" id="fs_class_fs_dir">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<p>A class representing a directory stream.</p>
+<p>Created by <a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir()</code></a>, <a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync()</code></a>, or
+<a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir()</code></a>.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { opendir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">print</span>(<span class="hljs-params">path</span>) </span>{
-  <span class="hljs-keyword">const</span> dir = <span class="hljs-keyword">await</span> fs.promises.opendir(path);
-  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> dirent <span class="hljs-keyword">of</span> dir) {
-    <span class="hljs-built_in">console</span>.log(dirent.name);
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> dir = <span class="hljs-keyword">await</span> <span class="hljs-title function_">opendir</span>(<span class="hljs-string">'./'</span>);
+  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> dirent <span class="hljs-keyword">of</span> dir)
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(dirent.<span class="hljs-property">name</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>When using the async iterator, the <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a> object will be automatically
+closed after the iterator exits.</p>
+<h5><code>dir.close()</code><span><a class="mark" href="#fs_dir_close" id="fs_dir_close">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Asynchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.</p>
+<p>A promise is returned that will be resolved after the resource has been
+closed.</p>
+<h5><code>dir.close(callback)</code><span><a class="mark" href="#fs_dir_close_callback" id="fs_dir_close_callback">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<ul>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+</ul>
+</li>
+</ul>
+<p>Asynchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.</p>
+<p>The <code>callback</code> will be called after the resource handle has been closed.</p>
+<h5><code>dir.closeSync()</code><span><a class="mark" href="#fs_dir_closesync" id="fs_dir_closesync">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<p>Synchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.</p>
+<h5><code>dir.path</code><span><a class="mark" href="#fs_dir_path" id="fs_dir_path">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>The read-only path of this directory as was provided to <a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir()</code></a>,
+<a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync()</code></a>, or <a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir()</code></a>.</p>
+<h5><code>dir.read()</code><span><a class="mark" href="#fs_dir_read" id="fs_dir_read">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> containing <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+</ul>
+<p>Asynchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
+<a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>.</p>
+<p>A promise is returned that will be resolved with an <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>, or <code>null</code>
+if there are no more directory entries to read.</p>
+<p>Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.</p>
+<h5><code>dir.read(callback)</code><span><a class="mark" href="#fs_dir_read_callback" id="fs_dir_read_callback">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<ul>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>dirent</code> <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+</ul>
+</li>
+</ul>
+<p>Asynchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
+<a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>.</p>
+<p>After the read is completed, the <code>callback</code> will be called with an
+<a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>, or <code>null</code> if there are no more directory entries to read.</p>
+<p>Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.</p>
+<h5><code>dir.readSync()</code><span><a class="mark" href="#fs_dir_readsync" id="fs_dir_readsync">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<ul>
+<li>Returns: <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+</ul>
+<p>Synchronously read the next directory entry as an <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>. See the
+POSIX <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> documentation for more detail.</p>
+<p>If there are no more directory entries to read, <code>null</code> will be returned.</p>
+<p>Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.</p>
+<h5><code>dir[Symbol.asyncIterator]()</code><span><a class="mark" href="#fs_dir_symbol_asynciterator" id="fs_dir_symbol_asynciterator">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.12.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterator-interface" class="type">&#x3C;AsyncIterator></a> of <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a></li>
+</ul>
+<p>Asynchronously iterates over the directory until all entries have
+been read. Refer to the POSIX <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> documentation for more detail.</p>
+<p>Entries returned by the async iterator are always an <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>.
+The <code>null</code> case from <code>dir.read()</code> is handled internally.</p>
+<p>See <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a> for an example.</p>
+<p>Directory entries returned by this iterator are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.</p>
+<h4>Class: <code>fs.Dirent</code><span><a class="mark" href="#fs_class_fs_dirent" id="fs_class_fs_dirent">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<p>A representation of a directory entry, which can be a file or a subdirectory
+within the directory, as returned by reading from an <a href="#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>. The
+directory entry is a combination of the file name and file type pairs.</p>
+<p>Additionally, when <a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir()</code></a> or <a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync()</code></a> is called with
+the <code>withFileTypes</code> option set to <code>true</code>, the resulting array is filled with
+<a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> objects, rather than strings or <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>s.</p>
+<h5><code>dirent.isBlockDevice()</code><span><a class="mark" href="#fs_dirent_isblockdevice" id="fs_dirent_isblockdevice">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a block device.</p>
+<h5><code>dirent.isCharacterDevice()</code><span><a class="mark" href="#fs_dirent_ischaracterdevice" id="fs_dirent_ischaracterdevice">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a character device.</p>
+<h5><code>dirent.isDirectory()</code><span><a class="mark" href="#fs_dirent_isdirectory" id="fs_dirent_isdirectory">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a file system
+directory.</p>
+<h5><code>dirent.isFIFO()</code><span><a class="mark" href="#fs_dirent_isfifo" id="fs_dirent_isfifo">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a first-in-first-out
+(FIFO) pipe.</p>
+<h5><code>dirent.isFile()</code><span><a class="mark" href="#fs_dirent_isfile" id="fs_dirent_isfile">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a regular file.</p>
+<h5><code>dirent.isSocket()</code><span><a class="mark" href="#fs_dirent_issocket" id="fs_dirent_issocket">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a socket.</p>
+<h5><code>dirent.isSymbolicLink()</code><span><a class="mark" href="#fs_dirent_issymboliclink" id="fs_dirent_issymboliclink">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a symbolic link.</p>
+<h5><code>dirent.name</code><span><a class="mark" href="#fs_dirent_name" id="fs_dirent_name">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+</ul>
+<p>The file name that this <a href="#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object refers to. The type of this
+value is determined by the <code>options.encoding</code> passed to <a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir()</code></a> or
+<a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync()</code></a>.</p>
+<h4>Class: <code>fs.FSWatcher</code><span><a class="mark" href="#fs_class_fs_fswatcher" id="fs_class_fs_fswatcher">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.5.8</span>
+</div>
+<ul>
+<li>Extends <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>A successful call to <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> method will return a new <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a>
+object.</p>
+<p>All <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> objects emit a <code>'change'</code> event whenever a specific watched
+file is modified.</p>
+<h5>Event: <code>'change'</code><span><a class="mark" href="#fs_event_change" id="fs_event_change">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.5.8</span>
+</div>
+<ul>
+<li><code>eventType</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The type of change event that has occurred</li>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The filename that changed (if relevant/available)</li>
+</ul>
+<p>Emitted when something changes in a watched directory or file.
+See more details in <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a>.</p>
+<p>The <code>filename</code> argument may not be provided depending on operating system
+support. If <code>filename</code> is provided, it will be provided as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> if
+<code>fs.watch()</code> is called with its <code>encoding</code> option set to <code>'buffer'</code>, otherwise
+<code>filename</code> will be a UTF-8 string.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { watch } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// Example when handled through fs.watch() listener</span>
+<span class="hljs-title function_">watch</span>(<span class="hljs-string">'./tmp'</span>, { <span class="hljs-attr">encoding</span>: <span class="hljs-string">'buffer'</span> }, <span class="hljs-function">(<span class="hljs-params">eventType, filename</span>) =></span> {
+  <span class="hljs-keyword">if</span> (filename) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(filename);
+    <span class="hljs-comment">// Prints: &#x3C;Buffer ...></span>
   }
-}
-print(<span class="hljs-string">'./'</span>).catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<h3><code>fsPromises.readdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_readdir_path_options" id="fs_fspromises_readdir_path_options">#</a></span></h3>
+});</code></pre>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close" id="fs_event_close">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<p>Emitted when the watcher stops watching for changes. The closed
+<a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object is no longer usable in the event handler.</p>
+<h5>Event: <code>'error'</code><span><a class="mark" href="#fs_event_error" id="fs_event_error">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.5.8</span>
+</div>
+<ul>
+<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+</ul>
+<p>Emitted when an error occurs while watching the file. The errored
+<a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object is no longer usable in the event handler.</p>
+<h5><code>watcher.close()</code><span><a class="mark" href="#fs_watcher_close" id="fs_watcher_close">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.5.8</span>
+</div>
+<p>Stop watching for changes on the given <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a>. Once stopped, the
+<a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object is no longer usable.</p>
+<h5><code>watcher.ref()</code><span><a class="mark" href="#fs_watcher_ref" id="fs_watcher_ref">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.3.0, v12.20.0</span>
+</div>
+<ul>
+<li>Returns: <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
+</ul>
+<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the
+<a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> is active. Calling <code>watcher.ref()</code> multiple times will have
+no effect.</p>
+<p>By default, all <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> objects are "ref'ed", making it normally
+unnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been
+called previously.</p>
+<h5><code>watcher.unref()</code><span><a class="mark" href="#fs_watcher_unref" id="fs_watcher_unref">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.3.0, v12.20.0</span>
+</div>
+<ul>
+<li>Returns: <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
+</ul>
+<p>When called, the active <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object will not require the Node.js
+event loop to remain active. If there is no other activity keeping the
+event loop running, the process may exit before the <a href="#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object's
+callback is invoked. Calling <code>watcher.unref()</code> multiple times will have
+no effect.</p>
+<h4>Class: <code>fs.StatWatcher</code><span><a class="mark" href="#fs_class_fs_statwatcher" id="fs_class_fs_statwatcher">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.3.0, v12.20.0</span>
+</div>
+<ul>
+<li>Extends <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+</ul>
+<p>A successful call to <code>fs.watchFile()</code> method will return a new <a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a>
+object.</p>
+<h5><code>watcher.ref()</code><span><a class="mark" href="#fs_watcher_ref_1" id="fs_watcher_ref_1">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.3.0, v12.20.0</span>
+</div>
+<ul>
+<li>Returns: <a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
+</ul>
+<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the
+<a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a> is active. Calling <code>watcher.ref()</code> multiple times will have
+no effect.</p>
+<p>By default, all <a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a> objects are "ref'ed", making it normally
+unnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been
+called previously.</p>
+<h5><code>watcher.unref()</code><span><a class="mark" href="#fs_watcher_unref_1" id="fs_watcher_unref_1">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.3.0, v12.20.0</span>
+</div>
+<ul>
+<li>Returns: <a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
+</ul>
+<p>When called, the active <a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a> object will not require the Node.js
+event loop to remain active. If there is no other activity keeping the
+event loop running, the process may exit before the <a href="#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a> object's
+callback is invoked. Calling <code>watcher.unref()</code> multiple times will have
+no effect.</p>
+<h4>Class: <code>fs.ReadStream</code><span><a class="mark" href="#fs_class_fs_readstream" id="fs_class_fs_readstream">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
+<ul>
+<li>Extends: <a href="#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a></li>
+</ul>
+<p>Instances of <a href="#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a> are created and returned using the
+<a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream()</code></a> function.</p>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close_1" id="fs_event_close_1">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
+<p>Emitted when the <a href="#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a>'s underlying file descriptor has been closed.</p>
+<h5>Event: <code>'open'</code><span><a class="mark" href="#fs_event_open" id="fs_event_open">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Integer file descriptor used by the <a href="#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a>.</li>
+</ul>
+<p>Emitted when the <a href="#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a>'s file descriptor has been opened.</p>
+<h5>Event: <code>'ready'</code><span><a class="mark" href="#fs_event_ready" id="fs_event_ready">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v9.11.0</span>
+</div>
+<p>Emitted when the <a href="#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a> is ready to be used.</p>
+<p>Fires immediately after <code>'open'</code>.</p>
+<h5><code>readStream.bytesRead</code><span><a class="mark" href="#fs_readstream_bytesread" id="fs_readstream_bytesread">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v6.4.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>The number of bytes that have been read so far.</p>
+<h5><code>readStream.path</code><span><a class="mark" href="#fs_readstream_path" id="fs_readstream_path">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+</ul>
+<p>The path to the file the stream is reading from as specified in the first
+argument to <code>fs.createReadStream()</code>. If <code>path</code> is passed as a string, then
+<code>readStream.path</code> will be a string. If <code>path</code> is passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>, then
+<code>readStream.path</code> will be a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<h5><code>readStream.pending</code><span><a class="mark" href="#fs_readstream_pending" id="fs_readstream_pending">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v11.2.0, v10.16.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>This property is <code>true</code> if the underlying file has not been opened yet,
+i.e. before the <code>'ready'</code> event is emitted.</p>
+<h4>Class: <code>fs.Stats</code><span><a class="mark" href="#fs_class_fs_stats" id="fs_class_fs_stats">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.11.0</td>
-<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
+<tr><td>v8.1.0</td>
+<td><p>Added times as numbers.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
+<p>A <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object provides information about a file.</p>
+<p>Objects returned from <a href="#fs_fs_stat_path_options_callback"><code>fs.stat()</code></a>, <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a> and <a href="#fs_fs_fstat_fd_options_callback"><code>fs.fstat()</code></a> and
+their synchronous counterparts are of this type.
+If <code>bigint</code> in the <code>options</code> passed to those methods is true, the numeric values
+will be <code>bigint</code> instead of <code>number</code>, and the object will contain additional
+nanosecond-precision properties suffixed with <code>Ns</code>.</p>
+<pre><code class="language-console">Stats {
+  dev: 2114,
+  ino: 48064969,
+  mode: 33188,
+  nlink: 1,
+  uid: 85,
+  gid: 100,
+  rdev: 0,
+  size: 527,
+  blksize: 4096,
+  blocks: 8,
+  atimeMs: 1318289051000.1,
+  mtimeMs: 1318289051000.1,
+  ctimeMs: 1318289051000.1,
+  birthtimeMs: 1318289051000.1,
+  atime: Mon, 10 Oct 2011 23:24:11 GMT,
+  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
+  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
+  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }</code></pre>
+<p><code>bigint</code> version:</p>
+<pre><code class="language-console">BigIntStats {
+  dev: 2114n,
+  ino: 48064969n,
+  mode: 33188n,
+  nlink: 1n,
+  uid: 85n,
+  gid: 100n,
+  rdev: 0n,
+  size: 527n,
+  blksize: 4096n,
+  blocks: 8n,
+  atimeMs: 1318289051000n,
+  mtimeMs: 1318289051000n,
+  ctimeMs: 1318289051000n,
+  birthtimeMs: 1318289051000n,
+  atimeNs: 1318289051000000000n,
+  mtimeNs: 1318289051000000000n,
+  ctimeNs: 1318289051000000000n,
+  birthtimeNs: 1318289051000000000n,
+  atime: Mon, 10 Oct 2011 23:24:11 GMT,
+  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
+  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
+  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }</code></pre>
+<h5><code>stats.isBlockDevice()</code><span><a class="mark" href="#fs_stats_isblockdevice" id="fs_stats_isblockdevice">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.10</span>
+</div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a block device.</p>
+<h5><code>stats.isCharacterDevice()</code><span><a class="mark" href="#fs_stats_ischaracterdevice" id="fs_stats_ischaracterdevice">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.10</span>
+</div>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a character device.</p>
+<h5><code>stats.isDirectory()</code><span><a class="mark" href="#fs_stats_isdirectory" id="fs_stats_isdirectory">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.10</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Reads the contents of a directory then resolves the <code>Promise</code> with an array
-of the names of the files in the directory excluding <code>'.'</code> and <code>'..'</code>.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the filenames. If the <code>encoding</code> is set to <code>'buffer'</code>, the filenames returned
-will be passed as <code>Buffer</code> objects.</p>
-<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the resolved array will contain
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a> objects.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">print</span>(<span class="hljs-params">path</span>) </span>{
-  <span class="hljs-keyword">const</span> files = <span class="hljs-keyword">await</span> fs.promises.readdir(path);
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> file <span class="hljs-keyword">of</span> files) {
-    <span class="hljs-built_in">console</span>.log(file);
-  }
-}
-print(<span class="hljs-string">'./'</span>).catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<h3><code>fsPromises.readFile(path[, options])</code><span><a class="mark" href="#fs_fspromises_readfile_path_options" id="fs_fspromises_readfile_path_options">#</a></span></h3>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a file system directory.</p>
+<p>If the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object was obtained from <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a>, this method will
+always return <code>false</code>. This is because <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a> returns information
+about a symbolic link itself and not the path it resolves to.</p>
+<h5><code>stats.isFIFO()</code><span><a class="mark" href="#fs_stats_isfifo" id="fs_stats_isfifo">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.1.10</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a first-in-first-out (FIFO)
+pipe.</p>
+<h5><code>stats.isFile()</code><span><a class="mark" href="#fs_stats_isfile" id="fs_stats_isfile">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.10</span>
+</div>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a regular file.</p>
+<h5><code>stats.isSocket()</code><span><a class="mark" href="#fs_stats_issocket" id="fs_stats_issocket">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.10</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronously reads the entire contents of a file.</p>
-<p>The <code>Promise</code> is resolved with the contents of the file. If no encoding is
-specified (using <code>options.encoding</code>), the data is returned as a <code>Buffer</code>
-object. Otherwise, the data will be a string.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>When the <code>path</code> is a directory, the behavior of <code>fsPromises.readFile()</code> is
-platform-specific. On macOS, Linux, and Windows, the promise will be rejected
-with an error. On FreeBSD, a representation of the directory's contents will be
-returned.</p>
-<p>Any specified <code>FileHandle</code> has to support reading.</p>
-<h3><code>fsPromises.readlink(path[, options])</code><span><a class="mark" href="#fs_fspromises_readlink_path_options" id="fs_fspromises_readlink_path_options">#</a></span></h3>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a socket.</p>
+<h5><code>stats.isSymbolicLink()</code><span><a class="mark" href="#fs_stats_issymboliclink" id="fs_stats_issymboliclink">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.1.10</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a symbolic link.</p>
+<p>This method is only valid when using <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a>.</p>
+<h5><code>stats.dev</code><span><a class="mark" href="#fs_stats_dev" id="fs_stats_dev">#</a></span></h5>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>The numeric identifier of the device containing the file.</p>
+<h5><code>stats.ino</code><span><a class="mark" href="#fs_stats_ino" id="fs_stats_ino">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a>. The <code>Promise</code> is resolved with the <code>linkString</code> upon
-success.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>, the link path
-returned will be passed as a <code>Buffer</code> object.</p>
-<h3><code>fsPromises.realpath(path[, options])</code><span><a class="mark" href="#fs_fspromises_realpath_path_options" id="fs_fspromises_realpath_path_options">#</a></span></h3>
+<p>The file system specific "Inode" number for the file.</p>
+<h5><code>stats.mode</code><span><a class="mark" href="#fs_stats_mode" id="fs_stats_mode">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>A bit-field describing the file type and mode.</p>
+<h5><code>stats.nlink</code><span><a class="mark" href="#fs_stats_nlink" id="fs_stats_nlink">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The number of hard-links that exist for the file.</p>
+<h5><code>stats.uid</code><span><a class="mark" href="#fs_stats_uid" id="fs_stats_uid">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The numeric user identifier of the user that owns the file (POSIX).</p>
+<h5><code>stats.gid</code><span><a class="mark" href="#fs_stats_gid" id="fs_stats_gid">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The numeric group identifier of the group that owns the file (POSIX).</p>
+<h5><code>stats.rdev</code><span><a class="mark" href="#fs_stats_rdev" id="fs_stats_rdev">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>A numeric device identifier if the file represents a device.</p>
+<h5><code>stats.size</code><span><a class="mark" href="#fs_stats_size" id="fs_stats_size">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The size of the file in bytes.</p>
+<h5><code>stats.blksize</code><span><a class="mark" href="#fs_stats_blksize" id="fs_stats_blksize">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The file system block size for i/o operations.</p>
+<h5><code>stats.blocks</code><span><a class="mark" href="#fs_stats_blocks" id="fs_stats_blocks">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The number of blocks allocated for this file.</p>
+<h5><code>stats.atimeMs</code><span><a class="mark" href="#fs_stats_atimems" id="fs_stats_atimems">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v8.1.0</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>The timestamp indicating the last time this file was accessed expressed in
+milliseconds since the POSIX Epoch.</p>
+<h5><code>stats.mtimeMs</code><span><a class="mark" href="#fs_stats_mtimems" id="fs_stats_mtimems">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v8.1.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Determines the actual location of <code>path</code> using the same semantics as the
-<code>fs.realpath.native()</code> function then resolves the <code>Promise</code> with the resolved
-path.</p>
-<p>Only paths that can be converted to UTF8 strings are supported.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the path. If the <code>encoding</code> is set to <code>'buffer'</code>, the path returned will be
-passed as a <code>Buffer</code> object.</p>
-<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
-be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
-this restriction.</p>
-<h3><code>fsPromises.rename(oldPath, newPath)</code><span><a class="mark" href="#fs_fspromises_rename_oldpath_newpath" id="fs_fspromises_rename_oldpath_newpath">#</a></span></h3>
+<p>The timestamp indicating the last time this file was modified expressed in
+milliseconds since the POSIX Epoch.</p>
+<h5><code>stats.ctimeMs</code><span><a class="mark" href="#fs_stats_ctimems" id="fs_stats_ctimems">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v8.1.0</span>
 </div>
 <ul>
-<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Renames <code>oldPath</code> to <code>newPath</code> and resolves the <code>Promise</code> with no arguments
-upon success.</p>
-<h3><code>fsPromises.rmdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_rmdir_path_options" id="fs_fspromises_rmdir_path_options">#</a></span></h3>
+<p>The timestamp indicating the last time the file status was changed expressed
+in milliseconds since the POSIX Epoch.</p>
+<h5><code>stats.birthtimeMs</code><span><a class="mark" href="#fs_stats_birthtimems" id="fs_stats_birthtimems">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
-<tr><td>v12.10.0</td>
-<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v8.1.0</span>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Recursive removal is experimental.</div><p></p>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The timestamp indicating the creation time of this file expressed in
+milliseconds since the POSIX Epoch.</p>
+<h5><code>stats.atimeNs</code><span><a class="mark" href="#fs_stats_atimens" id="fs_stats_atimens">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.10.0</span>
+</div>
 <ul>
-<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
-<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
-backoff wait of <code>retryDelay</code> ms longer on each try. This option represents the
-number of retries. This option is ignored if the <code>recursive</code> option is not
-<code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
-recursive mode, errors are not reported if <code>path</code> does not exist, and
-operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
-<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
-retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
-<strong>Default:</strong> <code>100</code>.</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>Only present when <code>bigint: true</code> is passed into the method that generates
+the object.
+The timestamp indicating the last time this file was accessed expressed in
+nanoseconds since the POSIX Epoch.</p>
+<h5><code>stats.mtimeNs</code><span><a class="mark" href="#fs_stats_mtimens" id="fs_stats_mtimens">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.10.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Removes the directory identified by <code>path</code> then resolves the <code>Promise</code> with
-no arguments upon success.</p>
-<p>Using <code>fsPromises.rmdir()</code> on a file (not a directory) results in the
-<code>Promise</code> being rejected with an <code>ENOENT</code> error on Windows and an <code>ENOTDIR</code>
-error on POSIX.</p>
-<h3><code>fsPromises.stat(path[, options])</code><span><a class="mark" href="#fs_fspromises_stat_path_options" id="fs_fspromises_stat_path_options">#</a></span></h3>
+<p>Only present when <code>bigint: true</code> is passed into the method that generates
+the object.
+The timestamp indicating the last time this file was modified expressed in
+nanoseconds since the POSIX Epoch.</p>
+<h5><code>stats.ctimeNs</code><span><a class="mark" href="#fs_stats_ctimens" id="fs_stats_ctimens">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v12.10.0</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>Only present when <code>bigint: true</code> is passed into the method that generates
+the object.
+The timestamp indicating the last time the file status was changed expressed
+in nanoseconds since the POSIX Epoch.</p>
+<h5><code>stats.birthtimeNs</code><span><a class="mark" href="#fs_stats_birthtimens" id="fs_stats_birthtimens">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.10.0</span>
+</div>
 <ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>Only present when <code>bigint: true</code> is passed into the method that generates
+the object.
+The timestamp indicating the creation time of this file expressed in
+nanoseconds since the POSIX Epoch.</p>
+<h5><code>stats.atime</code><span><a class="mark" href="#fs_stats_atime" id="fs_stats_atime">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.11.13</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>The <code>Promise</code> is resolved with the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object for the given <code>path</code>.</p>
-<h3><code>fsPromises.symlink(target, path[, type])</code><span><a class="mark" href="#fs_fspromises_symlink_target_path_type" id="fs_fspromises_symlink_target_path_type">#</a></span></h3>
+<p>The timestamp indicating the last time this file was accessed.</p>
+<h5><code>stats.mtime</code><span><a class="mark" href="#fs_stats_mtime" id="fs_stats_mtime">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.11.13</span>
 </div>
 <ul>
-<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'file'</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>Creates a symbolic link then resolves the <code>Promise</code> with no arguments upon
-success.</p>
-<p>The <code>type</code> argument is only used on Windows platforms and can be one of <code>'dir'</code>,
-<code>'file'</code>, or <code>'junction'</code>. Windows junction points require the destination path
-to be absolute. When using <code>'junction'</code>, the <code>target</code> argument will
-automatically be normalized to absolute path.</p>
-<h3><code>fsPromises.truncate(path[, len])</code><span><a class="mark" href="#fs_fspromises_truncate_path_len" id="fs_fspromises_truncate_path_len">#</a></span></h3>
+<p>The timestamp indicating the last time this file was modified.</p>
+<h5><code>stats.ctime</code><span><a class="mark" href="#fs_stats_ctime" id="fs_stats_ctime">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.11.13</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>Truncates the <code>path</code> then resolves the <code>Promise</code> with no arguments upon
-success. The <code>path</code> <em>must</em> be a string or <code>Buffer</code>.</p>
-<h3><code>fsPromises.unlink(path)</code><span><a class="mark" href="#fs_fspromises_unlink_path" id="fs_fspromises_unlink_path">#</a></span></h3>
+<p>The timestamp indicating the last time the file status was changed.</p>
+<h5><code>stats.birthtime</code><span><a class="mark" href="#fs_stats_birthtime" id="fs_stats_birthtime">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.11.13</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+</ul>
+<p>The timestamp indicating the creation time of this file.</p>
+<h5>Stat time values<span><a class="mark" href="#fs_stat_time_values" id="fs_stat_time_values">#</a></span></h5>
+<p>The <code>atimeMs</code>, <code>mtimeMs</code>, <code>ctimeMs</code>, <code>birthtimeMs</code> properties are
+numeric values that hold the corresponding times in milliseconds. Their
+precision is platform specific. When <code>bigint: true</code> is passed into the
+method that generates the object, the properties will be <a href="https://tc39.github.io/proposal-bigint">bigints</a>,
+otherwise they will be <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type">numbers</a>.</p>
+<p>The <code>atimeNs</code>, <code>mtimeNs</code>, <code>ctimeNs</code>, <code>birthtimeNs</code> properties are
+<a href="https://tc39.github.io/proposal-bigint">bigints</a> that hold the corresponding times in nanoseconds. They are
+only present when <code>bigint: true</code> is passed into the method that generates
+the object. Their precision is platform specific.</p>
+<p><code>atime</code>, <code>mtime</code>, <code>ctime</code>, and <code>birthtime</code> are
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a> object alternate representations of the various times. The
+<code>Date</code> and number values are not connected. Assigning a new number value, or
+mutating the <code>Date</code> value, will not be reflected in the corresponding alternate
+representation.</p>
+<p>The times in the stat object have the following semantics:</p>
+<ul>
+<li><code>atime</code> "Access Time": Time when file data last accessed. Changed
+by the <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/read.2.html"><code>read(2)</code></a> system calls.</li>
+<li><code>mtime</code> "Modified Time": Time when file data last modified.
+Changed by the <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/write.2.html"><code>write(2)</code></a> system calls.</li>
+<li><code>ctime</code> "Change Time": Time when file status was last changed
+(inode data modification). Changed by the <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>,
+<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>,
+<a href="http://man7.org/linux/man-pages/man2/read.2.html"><code>read(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/write.2.html"><code>write(2)</code></a> system calls.</li>
+<li><code>birthtime</code> "Birth Time": Time of file creation. Set once when the
+file is created. On filesystems where birthtime is not available,
+this field may instead hold either the <code>ctime</code> or
+<code>1970-01-01T00:00Z</code> (ie, Unix epoch timestamp <code>0</code>). This value may be greater
+than <code>atime</code> or <code>mtime</code> in this case. On Darwin and other FreeBSD variants,
+also set if the <code>atime</code> is explicitly set to an earlier value than the current
+<code>birthtime</code> using the <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a> system call.</li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon
-success.</p>
-<h3><code>fsPromises.utimes(path, atime, mtime)</code><span><a class="mark" href="#fs_fspromises_utimes_path_atime_mtime" id="fs_fspromises_utimes_path_atime_mtime">#</a></span></h3>
+<p>Prior to Node.js 0.12, the <code>ctime</code> held the <code>birthtime</code> on Windows systems. As
+of 0.12, <code>ctime</code> is not "creation time", and on Unix systems, it never was.</p>
+<h4>Class: <code>fs.WriteStream</code><span><a class="mark" href="#fs_class_fs_writestream" id="fs_class_fs_writestream">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.1.93</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Extends <a href="#stream_class_stream_writable" class="type">&#x3C;stream.Writable></a></li>
 </ul>
-<p>Change the file system timestamps of the object referenced by <code>path</code> then
-resolves the <code>Promise</code> with no arguments upon success.</p>
-<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>
+<p>Instances of <a href="#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> are created and returned using the
+<a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> function.</p>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close_2" id="fs_event_close_2">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
+<p>Emitted when the <a href="#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a>'s underlying file descriptor has been closed.</p>
+<h5>Event: <code>'open'</code><span><a class="mark" href="#fs_event_open_1" id="fs_event_open_1">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
 <ul>
-<li>Values can be either numbers representing Unix epoch time, <code>Date</code>s, or a
-numeric string like <code>'123456789.0'</code>.</li>
-<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or
-<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Integer file descriptor used by the <a href="#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a>.</li>
 </ul>
-<h3><code>fsPromises.writeFile(file, data[, options])</code><span><a class="mark" href="#fs_fspromises_writefile_file_data_options" id="fs_fspromises_writefile_file_data_options">#</a></span></h3>
+<p>Emitted when the <a href="#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a>'s file is opened.</p>
+<h5>Event: <code>'ready'</code><span><a class="mark" href="#fs_event_ready_1" id="fs_event_ready_1">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v9.11.0</span>
+</div>
+<p>Emitted when the <a href="#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> is ready to be used.</p>
+<p>Fires immediately after <code>'open'</code>.</p>
+<h5><code>writeStream.bytesWritten</code><span><a class="mark" href="#fs_writestream_byteswritten" id="fs_writestream_byteswritten">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.4.7</span>
+</div>
+<p>The number of bytes written so far. Does not include data that is still queued
+for writing.</p>
+<h5><code>writeStream.close([callback])</code><span><a class="mark" href="#fs_writestream_close_callback" id="fs_writestream_close_callback">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.9.4</span>
 </div>
 <ul>
-<li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Asynchronously writes data to a file, replacing the file if it already exists.
-<code>data</code> can be a string or a buffer. The <code>Promise</code> will be resolved with no
-arguments upon success.</p>
-<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>Any specified <code>FileHandle</code> has to support writing.</p>
-<p>It is unsafe to use <code>fsPromises.writeFile()</code> multiple times on the same file
-without waiting for the <code>Promise</code> to be resolved (or rejected).</p>
-<h2>FS constants<span><a class="mark" href="#fs_fs_constants_1" id="fs_fs_constants_1">#</a></span></h2>
+<p>Closes <code>writeStream</code>. Optionally accepts a
+callback that will be executed once the <code>writeStream</code>
+is closed.</p>
+<h5><code>writeStream.path</code><span><a class="mark" href="#fs_writestream_path" id="fs_writestream_path">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
+<p>The path to the file the stream is writing to as specified in the first
+argument to <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>. If <code>path</code> is passed as a string, then
+<code>writeStream.path</code> will be a string. If <code>path</code> is passed as a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>, then
+<code>writeStream.path</code> will be a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<h5><code>writeStream.pending</code><span><a class="mark" href="#fs_writestream_pending" id="fs_writestream_pending">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v11.2.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>This property is <code>true</code> if the underlying file has not been opened yet,
+i.e. before the <code>'ready'</code> event is emitted.</p>
+<h4><code>fs.constants</code><span><a class="mark" href="#fs_fs_constants" id="fs_fs_constants">#</a></span></h4>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+</ul>
+<p>Returns an object containing commonly used constants for file system
+operations.</p>
+<h5>FS constants<span><a class="mark" href="#fs_fs_constants_1" id="fs_fs_constants_1">#</a></span></h5>
 <p>The following constants are exported by <code>fs.constants</code>.</p>
 <p>Not every constant will be available on every operating system.</p>
 <p>To use more than one constant, use the bitwise OR <code>|</code> operator.</p>
 <p>Example:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
 <span class="hljs-keyword">const</span> {
-  O_RDWR,
-  O_CREAT,
-  O_EXCL
-} = fs.constants;
+  <span class="hljs-variable constant_">O_RDWR</span>,
+  <span class="hljs-variable constant_">O_CREAT</span>,
+  <span class="hljs-variable constant_">O_EXCL</span>
+} = constants;
 
-fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT | O_EXCL, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'/path/to/my/file'</span>, <span class="hljs-variable constant_">O_RDWR</span> | <span class="hljs-variable constant_">O_CREAT</span> | <span class="hljs-variable constant_">O_EXCL</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
-<h3>File access constants<span><a class="mark" href="#fs_file_access_constants" id="fs_file_access_constants">#</a></span></h3>
+<h6>File access constants<span><a class="mark" href="#fs_file_access_constants" id="fs_file_access_constants">#</a></span></h6>
 <p>The following constants are meant for use with <a href="#fs_fs_access_path_mode_callback"><code>fs.access()</code></a>.</p>
 <table>
   <tbody><tr>
@@ -34350,8 +36782,8 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     (will behave like <code>fs.constants.F_OK</code>).</td>
   </tr>
 </tbody></table>
-<h3>File copy constants<span><a class="mark" href="#fs_file_copy_constants" id="fs_file_copy_constants">#</a></span></h3>
-<p>The following constants are meant for use with <a href="#fs_fs_copyfile_src_dest_flags_callback"><code>fs.copyFile()</code></a>.</p>
+<h6>File copy constants<span><a class="mark" href="#fs_file_copy_constants" id="fs_file_copy_constants">#</a></span></h6>
+<p>The following constants are meant for use with <a href="#fs_fs_copyfile_src_dest_mode_callback"><code>fs.copyFile()</code></a>.</p>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -34375,7 +36807,7 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     copy-on-write, then the operation will fail with an error.</td>
   </tr>
 </tbody></table>
-<h3>File open constants<span><a class="mark" href="#fs_file_open_constants" id="fs_file_open_constants">#</a></span></h3>
+<h6>File open constants<span><a class="mark" href="#fs_file_open_constants" id="fs_file_open_constants">#</a></span></h6>
 <p>The following constants are meant for use with <code>fs.open()</code>.</p>
 <table>
   <tbody><tr>
@@ -34466,8 +36898,8 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     this flag is ignored.</td>
   </tr>
 </tbody></table>
-<h3>File type constants<span><a class="mark" href="#fs_file_type_constants" id="fs_file_type_constants">#</a></span></h3>
-<p>The following constants are meant for use with the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object's
+<h6>File type constants<span><a class="mark" href="#fs_file_type_constants" id="fs_file_type_constants">#</a></span></h6>
+<p>The following constants are meant for use with the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object's
 <code>mode</code> property for determining a file's type.</p>
 <table>
   <tbody><tr>
@@ -34507,8 +36939,8 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     <td>File type constant for a socket.</td>
   </tr>
 </tbody></table>
-<h3>File mode constants<span><a class="mark" href="#fs_file_mode_constants" id="fs_file_mode_constants">#</a></span></h3>
-<p>The following constants are meant for use with the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object's
+<h6>File mode constants<span><a class="mark" href="#fs_file_mode_constants" id="fs_file_mode_constants">#</a></span></h6>
+<p>The following constants are meant for use with the <a href="#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object's
 <code>mode</code> property for determining the access permissions for a file.</p>
 <table>
   <tbody><tr>
@@ -34564,7 +36996,244 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     <td>File mode indicating executable by others.</td>
   </tr>
 </tbody></table>
-<h2>File system flags<span><a class="mark" href="#fs_file_system_flags" id="fs_file_system_flags">#</a></span></h2>
+</section><section><h3>Notes<span><a class="mark" href="#fs_notes" id="fs_notes">#</a></span></h3>
+<h4>Ordering of callback and promise-based operations<span><a class="mark" href="#fs_ordering_of_callback_and_promise_based_operations" id="fs_ordering_of_callback_and_promise_based_operations">#</a></span></h4>
+<p>Because they are executed asynchronously by the underlying thread pool,
+there is no guaranteed ordering when using either the callback or
+promise-based methods.</p>
+<p>For example, the following is prone to error because the <code>fs.stat()</code>
+operation might complete before the <code>fs.rename()</code> operation:</p>
+<pre><code class="language-js">fs.<span class="hljs-title function_">rename</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'renamed complete'</span>);
+});
+fs.<span class="hljs-title function_">stat</span>(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+});</code></pre>
+<p>It is important to correctly order the operations by awaiting the results
+of one before invoking the other:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { rename, stat } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">const</span> <span class="hljs-keyword">from</span> = <span class="hljs-string">'/tmp/hello'</span>;
+<span class="hljs-keyword">const</span> to = <span class="hljs-string">'/tmp/world'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">rename</span>(<span class="hljs-keyword">from</span>, to);
+  <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> <span class="hljs-title function_">stat</span>(to);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+} <span class="hljs-keyword">catch</span> (error) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'there was an error:'</span>, error.<span class="hljs-property">message</span>);
+}</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { rename, stat } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);
+
+(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"><span class="hljs-keyword">from</span>, to</span>) {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">rename</span>(<span class="hljs-keyword">from</span>, to);
+    <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> <span class="hljs-title function_">stat</span>(to);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+  } <span class="hljs-keyword">catch</span> (error) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'there was an error:'</span>, error.<span class="hljs-property">message</span>);
+  }
+})(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>);</code></pre>
+<p>Or, when using the callback APIs, move the <code>fs.stat()</code> call into the callback
+of the <code>fs.rename()</code> operation:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { rename, stat } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">rename</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-title function_">stat</span>(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+  });
+});</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { rename, stat } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);
+
+<span class="hljs-title function_">rename</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-title function_">stat</span>(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+  });
+});</code></pre>
+<h4>File paths<span><a class="mark" href="#fs_file_paths" id="fs_file_paths">#</a></span></h4>
+<p>Most <code>fs</code> operations accept file paths that may be specified in the form of
+a string, a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a>, or a <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> object using the <code>file:</code> protocol.</p>
+<h5>String paths<span><a class="mark" href="#fs_string_paths" id="fs_string_paths">#</a></span></h5>
+<p>String form paths are interpreted as UTF-8 character sequences identifying
+the absolute or relative filename. Relative paths will be resolved relative
+to the current working directory as determined by calling <code>process.cwd()</code>.</p>
+<p>Example using an absolute path on POSIX:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> fd;
+<span class="hljs-keyword">try</span> {
+  fd = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>);
+  <span class="hljs-comment">// Do something with the file</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> fd.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<p>Example using a relative path on POSIX (relative to <code>process.cwd()</code>):</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> fd;
+<span class="hljs-keyword">try</span> {
+  fd = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'file.txt'</span>, <span class="hljs-string">'r'</span>);
+  <span class="hljs-comment">// Do something with the file</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> fd.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<h5>File URL paths<span><a class="mark" href="#fs_file_url_paths" id="fs_file_url_paths">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v7.6.0</span>
+</div>
+<p>For most <code>fs</code> module functions, the <code>path</code> or <code>filename</code> argument may be passed
+as a <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> object using the <code>file:</code> protocol.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///tmp/hello'</span>));</code></pre>
+<p><code>file:</code> URLs are always absolute paths.</p>
+<h6>Platform-specific considerations<span><a class="mark" href="#fs_platform_specific_considerations" id="fs_platform_specific_considerations">#</a></span></h6>
+<p>On Windows, <code>file:</code> <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s with a host name convert to UNC paths, while <code>file:</code>
+<a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s with drive letters convert to local absolute paths. <code>file:</code> <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s
+without a host name nor a drive letter will result in an error:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// On Windows :</span>
+
+<span class="hljs-comment">// - WHATWG file URLs with hostname convert to UNC path</span>
+<span class="hljs-comment">// file://hostname/p/a/t/h/file => \\hostname\p\a\t\h\file</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file://hostname/p/a/t/h/file'</span>));
+
+<span class="hljs-comment">// - WHATWG file URLs with drive letters convert to absolute path</span>
+<span class="hljs-comment">// file:///C:/tmp/hello => C:\tmp\hello</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/tmp/hello'</span>));
+
+<span class="hljs-comment">// - WHATWG file URLs without hostname must have a drive letters</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///notdriveletter/p/a/t/h/file'</span>));
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///c/p/a/t/h/file'</span>));
+<span class="hljs-comment">// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute</span></code></pre>
+<p><code>file:</code> <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s with drive letters must use <code>:</code> as a separator just after
+the drive letter. Using another separator will result in an error.</p>
+<p>On all other platforms, <code>file:</code> <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s with a host name are unsupported and
+will result in an error:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// On other platforms:</span>
+
+<span class="hljs-comment">// - WHATWG file URLs with hostname are unsupported</span>
+<span class="hljs-comment">// file://hostname/p/a/t/h/file => throw!</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file://hostname/p/a/t/h/file'</span>));
+<span class="hljs-comment">// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute</span>
+
+<span class="hljs-comment">// - WHATWG file URLs convert to absolute path</span>
+<span class="hljs-comment">// file:///tmp/hello => /tmp/hello</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///tmp/hello'</span>));</code></pre>
+<p>A <code>file:</code> <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> having encoded slash characters will result in an error on all
+platforms:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// On Windows</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/p/a/t/h/%2F'</span>));
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/p/a/t/h/%2f'</span>));
+<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+\ or / characters */</span>
+
+<span class="hljs-comment">// On POSIX</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///p/a/t/h/%2F'</span>));
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///p/a/t/h/%2f'</span>));
+<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+/ characters */</span></code></pre>
+<p>On Windows, <code>file:</code> <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s having encoded backslash will result in an error:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// On Windows</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/path/%5C'</span>));
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/path/%5c'</span>));
+<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+\ or / characters */</span></code></pre>
+<h5>Buffer paths<span><a class="mark" href="#fs_buffer_paths" id="fs_buffer_paths">#</a></span></h5>
+<p>Paths specified using a <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> are useful primarily on certain POSIX
+operating systems that treat file paths as opaque byte sequences. On such
+systems, it is possible for a single file path to contain sub-sequences that
+use multiple character encodings. As with string paths, <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> paths may
+be relative or absolute:</p>
+<p>Example using an absolute path on POSIX:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> fd;
+<span class="hljs-keyword">try</span> {
+  fd = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'/open/some/file.txt'</span>), <span class="hljs-string">'r'</span>);
+  <span class="hljs-comment">// Do something with the file</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> fd.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<h5>Per-drive working directories on Windows<span><a class="mark" href="#fs_per_drive_working_directories_on_windows" id="fs_per_drive_working_directories_on_windows">#</a></span></h5>
+<p>On Windows, Node.js follows the concept of per-drive working directory. This
+behavior can be observed when using a drive path without a backslash. For
+example <code>fs.readdirSync('C:\\')</code> can potentially return a different result than
+<code>fs.readdirSync('C:')</code>. For more information, see
+<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths">this MSDN page</a>.</p>
+<h4>File descriptors<span><a class="mark" href="#fs_file_descriptors_1" id="fs_file_descriptors_1">#</a></span></h4>
+<p>On POSIX systems, for every process, the kernel maintains a table of currently
+open files and resources. Each open file is assigned a simple numeric
+identifier called a <em>file descriptor</em>. At the system-level, all file system
+operations use these file descriptors to identify and track each specific
+file. Windows systems use a different but conceptually similar mechanism for
+tracking resources. To simplify things for users, Node.js abstracts away the
+differences between operating systems and assigns all open files a numeric file
+descriptor.</p>
+<p>The callback-based <code>fs.open()</code>, and synchronous <code>fs.openSync()</code> methods open a
+file and allocate a new file descriptor. Once allocated, the file descriptor may
+be used to read data from, write data to, or request information about the file.</p>
+<p>Operating systems limit the number of file descriptors that may be open
+at any given time so it is critical to close the descriptor when operations
+are completed. Failure to do so will result in a memory leak that will
+eventually cause an application to crash.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close, fstat } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">closeFd</span>(<span class="hljs-params">fd</span>) {
+  <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  });
+}
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">fstat</span>(fd, <span class="hljs-function">(<span class="hljs-params">err, stat</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) {
+        <span class="hljs-title function_">closeFd</span>(fd);
+        <span class="hljs-keyword">throw</span> err;
+      }
+
+      <span class="hljs-comment">// use stat</span>
+
+      <span class="hljs-title function_">closeFd</span>(fd);
+    });
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-title function_">closeFd</span>(fd);
+    <span class="hljs-keyword">throw</span> err;
+  }
+});</code></pre>
+<p>The promise-based APIs use a <a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object in place of the numeric
+file descriptor. These objects are better managed by the system to ensure
+that resources are not leaked. However, it is still required that they are
+closed when operations are completed:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> file;
+<span class="hljs-keyword">try</span> {
+  file = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>);
+  <span class="hljs-keyword">const</span> stat = <span class="hljs-keyword">await</span> file.<span class="hljs-title function_">stat</span>();
+  <span class="hljs-comment">// use stat</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> file.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<h4>Threadpool usage<span><a class="mark" href="#fs_threadpool_usage" id="fs_threadpool_usage">#</a></span></h4>
+<p>All callback and promise-based file system APIs ( with the exception of
+<code>fs.FSWatcher()</code>) use libuv's threadpool. This can have surprising and negative
+performance implications for some applications. See the
+<a href="#cli_uv_threadpool_size_size"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>
+<h4>File system flags<span><a class="mark" href="#fs_file_system_flags" id="fs_file_system_flags">#</a></span></h4>
 <p>The following flags are available wherever the <code>flag</code> option takes a
 string.</p>
 <ul>
@@ -34630,31 +37299,32 @@ or <code>O_EXCL|O_CREAT</code> to <code>CREATE_NEW</code>, as accepted by <code>
 <p>The exclusive flag <code>'x'</code> (<code>O_EXCL</code> flag in <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a>) causes the operation to
 return an error if the path already exists. On POSIX, if the path is a symbolic
 link, using <code>O_EXCL</code> returns an error even if the link is to a path that does
-not exist. The exclusive flag may or may not work with network file systems.</p>
+not exist. The exclusive flag might not work with network file systems.</p>
 <p>On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
 the end of the file.</p>
-<p>Modifying a file rather than replacing it may require a flags mode of <code>'r+'</code>
-rather than the default mode <code>'w'</code>.</p>
+<p>Modifying a file rather than replacing it may require the <code>flag</code> option to be
+set to <code>'r+'</code> rather than the default <code>'w'</code>.</p>
 <p>The behavior of some flags are platform-specific. As such, opening a directory
 on macOS and Linux with the <code>'a+'</code> flag, as in the example below, will return an
 error. In contrast, on Windows and FreeBSD, a file descriptor or a <code>FileHandle</code>
 will be returned.</p>
 <pre><code class="language-js"><span class="hljs-comment">// macOS and Linux</span>
-fs.open(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-string">'a+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+fs.<span class="hljs-title function_">open</span>(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-string">'a+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, open &#x3C;directory>]</span>
 });
 
 <span class="hljs-comment">// Windows and FreeBSD</span>
-fs.open(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-string">'a+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+fs.<span class="hljs-title function_">open</span>(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-string">'a+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-comment">// => null, &#x3C;fd></span>
 });</code></pre>
 <p>On Windows, opening an existing hidden file using the <code>'w'</code> flag (either
 through <code>fs.open()</code> or <code>fs.writeFile()</code> or <code>fsPromises.open()</code>) will fail with
 <code>EPERM</code>. Existing hidden files can be opened for writing with the <code>'r+'</code> flag.</p>
 <p>A call to <code>fs.ftruncate()</code> or <code>filehandle.truncate()</code> can be used to reset
-the file contents.</p>
-<h1>Global objects<span><a class="mark" href="#globals_global_objects" id="globals_global_objects">#</a></span></h1>
+the file contents.</p></section>
+        </section>
+<section><h2>Global objects<span><a class="mark" href="#globals_global_objects" id="globals_global_objects">#</a></span></h2>
 
 
 <p>These objects are available in all modules. The following variables may appear
@@ -34670,7 +37340,97 @@ to be global but are not. They exist only in the scope of modules, see the
 <p>The objects listed here are specific to Node.js. There are <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects">built-in objects</a>
 that are part of the JavaScript language itself, which are also globally
 accessible.</p>
-<h2>Class: <code>Buffer</code><span><a class="mark" href="#globals_class_buffer" id="globals_class_buffer">#</a></span></h2>
+<section><h3>Class: <code>AbortController</code><span><a class="mark" href="#globals_class_abortcontroller" id="globals_class_abortcontroller">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+
+<p>A utility class used to signal cancelation in selected <code>Promise</code>-based APIs.
+The API is based on the Web API <a href="https://developer.mozilla.org/en-US/docs/Web/API/AbortController"><code>AbortController</code></a>.</p>
+<p>To use, launch Node.js using the <code>--experimental-abortcontroller</code> flag.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+
+ac.<span class="hljs-property">signal</span>.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'abort'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Aborted!'</span>),
+                           { <span class="hljs-attr">once</span>: <span class="hljs-literal">true</span> });
+
+ac.<span class="hljs-title function_">abort</span>();
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(ac.<span class="hljs-property">signal</span>.<span class="hljs-property">aborted</span>);  <span class="hljs-comment">// Prints True</span></code></pre>
+<h4><code>abortController.abort()</code><span><a class="mark" href="#globals_abortcontroller_abort" id="globals_abortcontroller_abort">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>Triggers the abort signal, causing the <code>abortController.signal</code> to emit
+the <code>'abort'</code> event.</p>
+<h4><code>abortController.signal</code><span><a class="mark" href="#globals_abortcontroller_signal" id="globals_abortcontroller_signal">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Type: <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a></li>
+</ul>
+<h4>Class: <code>AbortSignal</code><span><a class="mark" href="#globals_class_abortsignal" id="globals_class_abortsignal">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Extends: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a></li>
+</ul>
+<p>The <code>AbortSignal</code> is used to notify observers when the
+<code>abortController.abort()</code> method is called.</p>
+<h5>Static method: <code>AbortSignal.abort()</code><span><a class="mark" href="#globals_static_method_abortsignal_abort" id="globals_static_method_abortsignal_abort">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Returns: <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a></li>
+</ul>
+<p>Returns a new already aborted <code>AbortSignal</code>.</p>
+<h5>Event: <code>'abort'</code><span><a class="mark" href="#globals_event_abort" id="globals_event_abort">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>The <code>'abort'</code> event is emitted when the <code>abortController.abort()</code> method
+is called. The callback is invoked with a single object argument with a
+single <code>type</code> property set to <code>'abort'</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+
+<span class="hljs-comment">// Use either the onabort property...</span>
+ac.<span class="hljs-property">signal</span>.<span class="hljs-property">onabort</span> = <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'aborted!'</span>);
+
+<span class="hljs-comment">// Or the EventTarget API...</span>
+ac.<span class="hljs-property">signal</span>.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'abort'</span>, <span class="hljs-function">(<span class="hljs-params">event</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'abort'</span>
+}, { <span class="hljs-attr">once</span>: <span class="hljs-literal">true</span> });
+
+ac.<span class="hljs-title function_">abort</span>();</code></pre>
+<p>The <code>AbortController</code> with which the <code>AbortSignal</code> is associated will only
+ever trigger the <code>'abort'</code> event once. We recommended that code check
+that the <code>abortSignal.aborted</code> attribute is <code>false</code> before adding an <code>'abort'</code>
+event listener.</p>
+<p>Any event listeners attached to the <code>AbortSignal</code> should use the
+<code>{ once: true }</code> option (or, if using the <code>EventEmitter</code> APIs to attach a
+listener, use the <code>once()</code> method) to ensure that the event listener is
+removed as soon as the <code>'abort'</code> event is handled. Failure to do so may
+result in memory leaks.</p>
+<h5><code>abortSignal.aborted</code><span><a class="mark" href="#globals_abortsignal_aborted" id="globals_abortsignal_aborted">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> True after the <code>AbortController</code> has been aborted.</li>
+</ul>
+<h5><code>abortSignal.onabort</code><span><a class="mark" href="#globals_abortsignal_onabort" id="globals_abortsignal_onabort">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+</ul>
+<p>An optional callback function that may be set by user code to be notified
+when the <code>abortController.abort()</code> function has been called.</p>
+</section><section><h3>Class: <code>Buffer</code><span><a class="mark" href="#globals_class_buffer" id="globals_class_buffer">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.103</span>
 </div>
@@ -34679,29 +37439,29 @@ accessible.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <p>Used to handle binary data. See the <a href="buffer.html">buffer section</a>.</p>
-<h2><code>__dirname</code><span><a class="mark" href="#globals_dirname" id="globals_dirname">#</a></span></h2>
+</section><section><h3><code>__dirname</code><span><a class="mark" href="#globals_dirname" id="globals_dirname">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="#modules_dirname"><code>__dirname</code></a>.</p>
-<h2><code>__filename</code><span><a class="mark" href="#globals_filename" id="globals_filename">#</a></span></h2>
+</section><section><h3><code>__filename</code><span><a class="mark" href="#globals_filename" id="globals_filename">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="#modules_filename"><code>__filename</code></a>.</p>
-<h2><code>clearImmediate(immediateObject)</code><span><a class="mark" href="#globals_clearimmediate_immediateobject" id="globals_clearimmediate_immediateobject">#</a></span></h2>
+</section><section><h3><code>clearImmediate(immediateObject)</code><span><a class="mark" href="#globals_clearimmediate_immediateobject" id="globals_clearimmediate_immediateobject">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
 
 <p><a href="#timers_clearimmediate_immediate"><code>clearImmediate</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>clearInterval(intervalObject)</code><span><a class="mark" href="#globals_clearinterval_intervalobject" id="globals_clearinterval_intervalobject">#</a></span></h2>
+</section><section><h3><code>clearInterval(intervalObject)</code><span><a class="mark" href="#globals_clearinterval_intervalobject" id="globals_clearinterval_intervalobject">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 
 <p><a href="#timers_clearinterval_timeout"><code>clearInterval</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>clearTimeout(timeoutObject)</code><span><a class="mark" href="#globals_cleartimeout_timeoutobject" id="globals_cleartimeout_timeoutobject">#</a></span></h2>
+</section><section><h3><code>clearTimeout(timeoutObject)</code><span><a class="mark" href="#globals_cleartimeout_timeoutobject" id="globals_cleartimeout_timeoutobject">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 
 <p><a href="#timers_cleartimeout_timeout"><code>clearTimeout</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>console</code><span><a class="mark" href="#globals_console" id="globals_console">#</a></span></h2>
+</section><section><h3><code>console</code><span><a class="mark" href="#globals_console" id="globals_console">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -34710,9 +37470,9 @@ accessible.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>Used to print to stdout and stderr. See the <a href="console.html"><code>console</code></a> section.</p>
-<h2><code>exports</code><span><a class="mark" href="#globals_exports" id="globals_exports">#</a></span></h2>
+</section><section><h3><code>exports</code><span><a class="mark" href="#globals_exports" id="globals_exports">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="#modules_exports"><code>exports</code></a>.</p>
-<h2><code>global</code><span><a class="mark" href="#globals_global" id="globals_global">#</a></span></h2>
+</section><section><h3><code>global</code><span><a class="mark" href="#globals_global" id="globals_global">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -34724,9 +37484,9 @@ accessible.</p>
 within the browser <code>var something</code> will define a new global variable. In
 Node.js this is different. The top-level scope is not the global scope;
 <code>var something</code> inside a Node.js module will be local to that module.</p>
-<h2><code>module</code><span><a class="mark" href="#globals_module" id="globals_module">#</a></span></h2>
+</section><section><h3><code>module</code><span><a class="mark" href="#globals_module" id="globals_module">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="#modules_module"><code>module</code></a>.</p>
-<h2><code>process</code><span><a class="mark" href="#globals_process" id="globals_process">#</a></span></h2>
+</section><section><h3><code>process</code><span><a class="mark" href="#globals_process" id="globals_process">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.7</span>
 </div>
@@ -34735,7 +37495,7 @@ Node.js this is different. The top-level scope is not the global scope;
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>The process object. See the <a href="#process_process"><code>process</code> object</a> section.</p>
-<h2><code>queueMicrotask(callback)</code><span><a class="mark" href="#globals_queuemicrotask_callback" id="globals_queuemicrotask_callback">#</a></span></h2>
+</section><section><h3><code>queueMicrotask(callback)</code><span><a class="mark" href="#globals_queuemicrotask_callback" id="globals_queuemicrotask_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
@@ -34755,64 +37515,64 @@ within each turn of the Node.js event loop.</p>
 <span class="hljs-comment">// `process.nextTick()` here would result in the 'load' event always emitting</span>
 <span class="hljs-comment">// before any other promise jobs.</span>
 
-DataHandler.prototype.load = <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">load</span>(<span class="hljs-params">key</span>) </span>{
-  <span class="hljs-keyword">const</span> hit = <span class="hljs-built_in">this</span>._cache.get(url);
+<span class="hljs-title class_">DataHandler</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">load</span> = <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">load</span>(<span class="hljs-params">key</span>) {
+  <span class="hljs-keyword">const</span> hit = <span class="hljs-variable language_">this</span>.<span class="hljs-property">_cache</span>.<span class="hljs-title function_">get</span>(key);
   <span class="hljs-keyword">if</span> (hit !== <span class="hljs-literal">undefined</span>) {
-    queueMicrotask(<span class="hljs-function">() =></span> {
-      <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'load'</span>, hit);
+    <span class="hljs-title function_">queueMicrotask</span>(<span class="hljs-function">() =></span> {
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'load'</span>, hit);
     });
     <span class="hljs-keyword">return</span>;
   }
 
-  <span class="hljs-keyword">const</span> data = <span class="hljs-keyword">await</span> fetchData(key);
-  <span class="hljs-built_in">this</span>._cache.set(url, data);
-  <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'load'</span>, data);
+  <span class="hljs-keyword">const</span> data = <span class="hljs-keyword">await</span> <span class="hljs-title function_">fetchData</span>(key);
+  <span class="hljs-variable language_">this</span>.<span class="hljs-property">_cache</span>.<span class="hljs-title function_">set</span>(key, data);
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'load'</span>, data);
 };</code></pre>
-<h2><code>require()</code><span><a class="mark" href="#globals_require" id="globals_require">#</a></span></h2>
+</section><section><h3><code>require()</code><span><a class="mark" href="#globals_require" id="globals_require">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="#modules_require_id"><code>require()</code></a>.</p>
-<h2><code>setImmediate(callback[, ...args])</code><span><a class="mark" href="#globals_setimmediate_callback_args" id="globals_setimmediate_callback_args">#</a></span></h2>
+</section><section><h3><code>setImmediate(callback[, ...args])</code><span><a class="mark" href="#globals_setimmediate_callback_args" id="globals_setimmediate_callback_args">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
 
 <p><a href="#timers_setimmediate_callback_args"><code>setImmediate</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>setInterval(callback, delay[, ...args])</code><span><a class="mark" href="#globals_setinterval_callback_delay_args" id="globals_setinterval_callback_delay_args">#</a></span></h2>
+</section><section><h3><code>setInterval(callback, delay[, ...args])</code><span><a class="mark" href="#globals_setinterval_callback_delay_args" id="globals_setinterval_callback_delay_args">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 
 <p><a href="#timers_setinterval_callback_delay_args"><code>setInterval</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>setTimeout(callback, delay[, ...args])</code><span><a class="mark" href="#globals_settimeout_callback_delay_args" id="globals_settimeout_callback_delay_args">#</a></span></h2>
+</section><section><h3><code>setTimeout(callback, delay[, ...args])</code><span><a class="mark" href="#globals_settimeout_callback_delay_args" id="globals_settimeout_callback_delay_args">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 
 <p><a href="#timers_settimeout_callback_delay_args"><code>setTimeout</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>TextDecoder</code><span><a class="mark" href="#globals_textdecoder" id="globals_textdecoder">#</a></span></h2>
+</section><section><h3><code>TextDecoder</code><span><a class="mark" href="#globals_textdecoder" id="globals_textdecoder">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
 
 <p>The WHATWG <code>TextDecoder</code> class. See the <a href="#util_class_util_textdecoder"><code>TextDecoder</code></a> section.</p>
-<h2><code>TextEncoder</code><span><a class="mark" href="#globals_textencoder" id="globals_textencoder">#</a></span></h2>
+</section><section><h3><code>TextEncoder</code><span><a class="mark" href="#globals_textencoder" id="globals_textencoder">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
 
 <p>The WHATWG <code>TextEncoder</code> class. See the <a href="#util_class_util_textencoder"><code>TextEncoder</code></a> section.</p>
-<h2><code>URL</code><span><a class="mark" href="#globals_url" id="globals_url">#</a></span></h2>
+</section><section><h3><code>URL</code><span><a class="mark" href="#globals_url" id="globals_url">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 
 <p>The WHATWG <code>URL</code> class. See the <a href="#url_class_url"><code>URL</code></a> section.</p>
-<h2><code>URLSearchParams</code><span><a class="mark" href="#globals_urlsearchparams" id="globals_urlsearchparams">#</a></span></h2>
+</section><section><h3><code>URLSearchParams</code><span><a class="mark" href="#globals_urlsearchparams" id="globals_urlsearchparams">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 
 <p>The WHATWG <code>URLSearchParams</code> class. See the <a href="#url_class_urlsearchparams"><code>URLSearchParams</code></a> section.</p>
-<h2><code>WebAssembly</code><span><a class="mark" href="#globals_webassembly" id="globals_webassembly">#</a></span></h2>
+</section><section><h3><code>WebAssembly</code><span><a class="mark" href="#globals_webassembly" id="globals_webassembly">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -34822,11 +37582,12 @@ DataHandler.prototype.load = <span class="hljs-keyword">async</span> <span class
 </ul>
 <p>The object that acts as the namespace for all W3C
 <a href="https://webassembly.org">WebAssembly</a> related functionality. See the
-<a href="https://developer.mozilla.org/en-US/docs/WebAssembly">Mozilla Developer Network</a> for usage and compatibility.</p>
-<h1>HTTP<span><a class="mark" href="#http_http" id="http_http">#</a></span></h1>
+<a href="https://developer.mozilla.org/en-US/docs/WebAssembly">Mozilla Developer Network</a> for usage and compatibility.</p></section>
+        </section>
+<section><h2>HTTP<span><a class="mark" href="#http_http" id="http_http">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/http.js">lib/http.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/http.js">lib/http.js</a></p>
 <p>To use the HTTP server and client one must <code>require('http')</code>.</p>
 <p>The HTTP interfaces in Node.js are designed to support many features
 of the protocol which have been traditionally difficult to use.
@@ -34857,7 +37618,7 @@ list like the following:</p>
   <span class="hljs-string">'CONNECTION'</span>, <span class="hljs-string">'keep-alive'</span>,
   <span class="hljs-string">'Host'</span>, <span class="hljs-string">'mysite.com'</span>,
   <span class="hljs-string">'accepT'</span>, <span class="hljs-string">'*/*'</span> ]</code></pre>
-<h2>Class: <code>http.Agent</code><span><a class="mark" href="#http_class_http_agent" id="http_class_http_agent">#</a></span></h2>
+<section><h3>Class: <code>http.Agent</code><span><a class="mark" href="#http_class_http_agent" id="http_class_http_agent">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -34885,17 +37646,17 @@ longer in use, because unused sockets consume OS resources.</p>
 a <code>'close'</code> event or an <code>'agentRemove'</code> event. When intending to keep one
 HTTP request open for a long time without keeping it in the agent, something
 like the following may be done:</p>
-<pre><code class="language-js">http.get(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<pre><code class="language-js">http.<span class="hljs-title function_">get</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// Do stuff</span>
-}).on(<span class="hljs-string">'socket'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  socket.emit(<span class="hljs-string">'agentRemove'</span>);
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'socket'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  socket.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'agentRemove'</span>);
 });</code></pre>
 <p>An agent may also be used for an individual request. By providing
 <code>{agent: false}</code> as an option to the <code>http.get()</code> or <code>http.request()</code>
 functions, a one-time use <code>Agent</code> with default options will be used
 for the client connection.</p>
 <p><code>agent:false</code>:</p>
-<pre><code class="language-js">http.get({
+<pre><code class="language-js">http.<span class="hljs-title function_">get</span>({
   <span class="hljs-attr">hostname</span>: <span class="hljs-string">'localhost'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">80</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
@@ -34903,15 +37664,17 @@ for the client connection.</p>
 }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// Do stuff with response</span>
 });</code></pre>
-<h3><code>new Agent([options])</code><span><a class="mark" href="#http_new_agent_options" id="http_new_agent_options">#</a></span></h3>
+<h4><code>new Agent([options])</code><span><a class="mark" href="#http_new_agent_options" id="http_new_agent_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.20.0</td>
-<td><p>Add <code>scheduling</code> option to specify the free socket scheduling strategy.</p></td></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.17.0</td>
+<td><p>Change the default scheduling from 'fifo' to 'lifo'.</p></td></tr>
+<tr><td>v14.5.0</td>
 <td><p>Add <code>maxTotalSockets</code> option to agent constructor.</p></td></tr>
+<tr><td>v14.5.0</td>
+<td><p>Add <code>scheduling</code> option to specify the free socket scheduling strategy.</p></td></tr>
 <tr><td>v0.3.4</td>
 <td><p><span>Added in: v0.3.4</span></p></td></tr>
 </tbody></table>
@@ -34933,8 +37696,14 @@ options are respectively set to <code>false</code> and <code>Infinity</code>, in
 the <a href="#net_socket_setkeepalive_enable_initialdelay">initial delay</a>
 for TCP Keep-Alive packets. Ignored when the
 <code>keepAlive</code> option is <code>false</code> or <code>undefined</code>. <strong>Default:</strong> <code>1000</code>.</li>
-<li><code>maxSockets</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Maximum number of sockets to allow per
-host. Each request will use a new socket until the maximum is reached.
+<li><code>maxSockets</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Maximum number of sockets to allow per host.
+If the same host opens multiple concurrent connections, each request
+will use new socket until the <code>maxSockets</code> value is reached.
+If the host attempts to open more connections than <code>maxSockets</code>,
+the additional requests will enter into a pending request queue, and
+will enter active connection state when an existing connection terminates.
+This makes sure there are at most <code>maxSockets</code> active connections at
+any point in time, from a given host.
 <strong>Default:</strong> <code>Infinity</code>.</li>
 <li><code>maxTotalSockets</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Maximum number of sockets allowed for
 all hosts in total. Each request will use a new socket
@@ -34954,7 +37723,7 @@ by the server due to inactivity.
 In case of a high rate of request per second,
 the <code>'fifo'</code> scheduling will maximize the number of open sockets,
 while the <code>'lifo'</code> scheduling will keep it as low as possible.
-<strong>Default:</strong> <code>'fifo'</code>.</li>
+<strong>Default:</strong> <code>'lifo'</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Socket timeout in milliseconds.
 This will set the timeout when the socket is created.</li>
 </ul>
@@ -34965,10 +37734,10 @@ This will set the timeout when the socket is created.</li>
 of these values set to their respective defaults.</p>
 <p>To configure any of them, a custom <a href="#http_class_http_agent"><code>http.Agent</code></a> instance must be created.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> keepAliveAgent = <span class="hljs-keyword">new</span> http.Agent({ <span class="hljs-attr">keepAlive</span>: <span class="hljs-literal">true</span> });
-options.agent = keepAliveAgent;
-http.request(options, onResponseCallback);</code></pre>
-<h3><code>agent.createConnection(options[, callback])</code><span><a class="mark" href="#http_agent_createconnection_options_callback" id="http_agent_createconnection_options_callback">#</a></span></h3>
+<span class="hljs-keyword">const</span> keepAliveAgent = <span class="hljs-keyword">new</span> http.<span class="hljs-title class_">Agent</span>({ <span class="hljs-attr">keepAlive</span>: <span class="hljs-literal">true</span> });
+options.<span class="hljs-property">agent</span> = keepAliveAgent;
+http.<span class="hljs-title function_">request</span>(options, onResponseCallback);</code></pre>
+<h4><code>agent.createConnection(options[, callback])</code><span><a class="mark" href="#http_agent_createconnection_options_callback" id="http_agent_createconnection_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -34987,7 +37756,7 @@ socket/stream from this function, or by passing the socket/stream to <code>callb
 a subclass of <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specifies a socket
 type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
 <p><code>callback</code> has a signature of <code>(err, stream)</code>.</p>
-<h3><code>agent.keepSocketAlive(socket)</code><span><a class="mark" href="#http_agent_keepsocketalive_socket" id="http_agent_keepsocketalive_socket">#</a></span></h3>
+<h4><code>agent.keepSocketAlive(socket)</code><span><a class="mark" href="#http_agent_keepsocketalive_socket" id="http_agent_keepsocketalive_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.1.0</span>
 </div>
@@ -34996,15 +37765,15 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 </ul>
 <p>Called when <code>socket</code> is detached from a request and could be persisted by the
 <code>Agent</code>. Default behavior is to:</p>
-<pre><code class="language-js">socket.setKeepAlive(<span class="hljs-literal">true</span>, <span class="hljs-built_in">this</span>.keepAliveMsecs);
-socket.unref();
+<pre><code class="language-js">socket.<span class="hljs-title function_">setKeepAlive</span>(<span class="hljs-literal">true</span>, <span class="hljs-variable language_">this</span>.<span class="hljs-property">keepAliveMsecs</span>);
+socket.<span class="hljs-title function_">unref</span>();
 <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;</code></pre>
 <p>This method can be overridden by a particular <code>Agent</code> subclass. If this
 method returns a falsy value, the socket will be destroyed instead of persisting
 it for use with the next request.</p>
 <p>The <code>socket</code> argument can be an instance of <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>, a subclass of
 <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>.</p>
-<h3><code>agent.reuseSocket(socket, request)</code><span><a class="mark" href="#http_agent_reusesocket_socket_request" id="http_agent_reusesocket_socket_request">#</a></span></h3>
+<h4><code>agent.reuseSocket(socket, request)</code><span><a class="mark" href="#http_agent_reusesocket_socket_request" id="http_agent_reusesocket_socket_request">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.1.0</span>
 </div>
@@ -35014,21 +37783,21 @@ it for use with the next request.</p>
 </ul>
 <p>Called when <code>socket</code> is attached to <code>request</code> after being persisted because of
 the keep-alive options. Default behavior is to:</p>
-<pre><code class="language-js">socket.ref();</code></pre>
+<pre><code class="language-js">socket.<span class="hljs-title function_">ref</span>();</code></pre>
 <p>This method can be overridden by a particular <code>Agent</code> subclass.</p>
 <p>The <code>socket</code> argument can be an instance of <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>, a subclass of
 <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>.</p>
-<h3><code>agent.destroy()</code><span><a class="mark" href="#http_agent_destroy" id="http_agent_destroy">#</a></span></h3>
+<h4><code>agent.destroy()</code><span><a class="mark" href="#http_agent_destroy" id="http_agent_destroy">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
 <p>Destroy any sockets that are currently in use by the agent.</p>
 <p>It is usually not necessary to do this. However, if using an
 agent with <code>keepAlive</code> enabled, then it is best to explicitly shut down
-the agent when it will no longer be used. Otherwise,
-sockets may hang open for quite a long time before the server
+the agent when it is no longer needed. Otherwise,
+sockets might stay open for quite a long time before the server
 terminates them.</p>
-<h3><code>agent.freeSockets</code><span><a class="mark" href="#http_agent_freesockets" id="http_agent_freesockets">#</a></span></h3>
+<h4><code>agent.freeSockets</code><span><a class="mark" href="#http_agent_freesockets" id="http_agent_freesockets">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -35039,7 +37808,7 @@ terminates them.</p>
 the agent when <code>keepAlive</code> is enabled. Do not modify.</p>
 <p>Sockets in the <code>freeSockets</code> list will be automatically destroyed and
 removed from the array on <code>'timeout'</code>.</p>
-<h3><code>agent.getName(options)</code><span><a class="mark" href="#http_agent_getname_options" id="http_agent_getname_options">#</a></span></h3>
+<h4><code>agent.getName(options)</code><span><a class="mark" href="#http_agent_getname_options" id="http_agent_getname_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -35061,7 +37830,7 @@ connection can be reused. For an HTTP agent, this returns
 <code>host:port:localAddress</code> or <code>host:port:localAddress:family</code>. For an HTTPS agent,
 the name includes the CA, cert, ciphers, and other HTTPS/TLS-specific options
 that determine socket reusability.</p>
-<h3><code>agent.maxFreeSockets</code><span><a class="mark" href="#http_agent_maxfreesockets" id="http_agent_maxfreesockets">#</a></span></h3>
+<h4><code>agent.maxFreeSockets</code><span><a class="mark" href="#http_agent_maxfreesockets" id="http_agent_maxfreesockets">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.7</span>
 </div>
@@ -35071,7 +37840,7 @@ that determine socket reusability.</p>
 <p>By default set to 256. For agents with <code>keepAlive</code> enabled, this
 sets the maximum number of sockets that will be left open in the free
 state.</p>
-<h3><code>agent.maxSockets</code><span><a class="mark" href="#http_agent_maxsockets" id="http_agent_maxsockets">#</a></span></h3>
+<h4><code>agent.maxSockets</code><span><a class="mark" href="#http_agent_maxsockets" id="http_agent_maxsockets">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.6</span>
 </div>
@@ -35080,16 +37849,16 @@ state.</p>
 </ul>
 <p>By default set to <code>Infinity</code>. Determines how many concurrent sockets the agent
 can have open per origin. Origin is the returned value of <a href="#http_agent_getname_options"><code>agent.getName()</code></a>.</p>
-<h3><code>agent.maxTotalSockets</code><span><a class="mark" href="#http_agent_maxtotalsockets" id="http_agent_maxtotalsockets">#</a></span></h3>
+<h4><code>agent.maxTotalSockets</code><span><a class="mark" href="#http_agent_maxtotalsockets" id="http_agent_maxtotalsockets">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>By default set to <code>Infinity</code>. Determines how many concurrent sockets the agent
 can have open. Unlike <code>maxSockets</code>, this parameter applies across all origins.</p>
-<h3><code>agent.requests</code><span><a class="mark" href="#http_agent_requests" id="http_agent_requests">#</a></span></h3>
+<h4><code>agent.requests</code><span><a class="mark" href="#http_agent_requests" id="http_agent_requests">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -35098,7 +37867,7 @@ can have open. Unlike <code>maxSockets</code>, this parameter applies across all
 </ul>
 <p>An object which contains queues of requests that have not yet been assigned to
 sockets. Do not modify.</p>
-<h3><code>agent.sockets</code><span><a class="mark" href="#http_agent_sockets" id="http_agent_sockets">#</a></span></h3>
+<h4><code>agent.sockets</code><span><a class="mark" href="#http_agent_sockets" id="http_agent_sockets">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.6</span>
 </div>
@@ -35107,7 +37876,7 @@ sockets. Do not modify.</p>
 </ul>
 <p>An object which contains arrays of sockets currently in use by the
 agent. Do not modify.</p>
-<h2>Class: <code>http.ClientRequest</code><span><a class="mark" href="#http_class_http_clientrequest" id="http_class_http_clientrequest">#</a></span></h2>
+</section><section><h3>Class: <code>http.ClientRequest</code><span><a class="mark" href="#http_class_http_clientrequest" id="http_class_http_clientrequest">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
@@ -35138,13 +37907,13 @@ the data is read it will consume memory that can eventually lead to a
 <code>'aborted'</code> event.</p>
 <p>Node.js does not check whether Content-Length and the length of the
 body which has been transmitted are equal or not.</p>
-<h3>Event: <code>'abort'</code><span><a class="mark" href="#http_event_abort" id="http_event_abort">#</a></span></h3>
+<h4>Event: <code>'abort'</code><span><a class="mark" href="#http_event_abort" id="http_event_abort">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.4.1</span>
 </div>
 <p>Emitted when the request has been aborted by the client. This event is only
 emitted on the first call to <code>abort()</code>.</p>
-<h3>Event: <code>'connect'</code><span><a class="mark" href="#http_event_connect" id="http_event_connect">#</a></span></h3>
+<h4>Event: <code>'connect'</code><span><a class="mark" href="#http_event_connect" id="http_event_connect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -35162,28 +37931,28 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 <p>A client and server pair demonstrating how to listen for the <code>'connect'</code> event:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 <span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-<span class="hljs-keyword">const</span> { URL } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-variable constant_">URL</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
 
 <span class="hljs-comment">// Create an HTTP tunneling proxy</span>
-<span class="hljs-keyword">const</span> proxy = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
-  res.end(<span class="hljs-string">'okay'</span>);
+<span class="hljs-keyword">const</span> proxy = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'okay'</span>);
 });
-proxy.on(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">req, clientSocket, head</span>) =></span> {
+proxy.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">req, clientSocket, head</span>) =></span> {
   <span class="hljs-comment">// Connect to an origin server</span>
-  <span class="hljs-keyword">const</span> { port, hostname } = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">`http://<span class="hljs-subst">${req.url}</span>`</span>);
-  <span class="hljs-keyword">const</span> serverSocket = net.connect(port || <span class="hljs-number">80</span>, hostname, <span class="hljs-function">() =></span> {
-    clientSocket.write(<span class="hljs-string">'HTTP/1.1 200 Connection Established\r\n'</span> +
+  <span class="hljs-keyword">const</span> { port, hostname } = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">`http://<span class="hljs-subst">${req.url}</span>`</span>);
+  <span class="hljs-keyword">const</span> serverSocket = net.<span class="hljs-title function_">connect</span>(port || <span class="hljs-number">80</span>, hostname, <span class="hljs-function">() =></span> {
+    clientSocket.<span class="hljs-title function_">write</span>(<span class="hljs-string">'HTTP/1.1 200 Connection Established\r\n'</span> +
                     <span class="hljs-string">'Proxy-agent: Node.js-Proxy\r\n'</span> +
                     <span class="hljs-string">'\r\n'</span>);
-    serverSocket.write(head);
-    serverSocket.pipe(clientSocket);
-    clientSocket.pipe(serverSocket);
+    serverSocket.<span class="hljs-title function_">write</span>(head);
+    serverSocket.<span class="hljs-title function_">pipe</span>(clientSocket);
+    clientSocket.<span class="hljs-title function_">pipe</span>(serverSocket);
   });
 });
 
 <span class="hljs-comment">// Now that proxy is running</span>
-proxy.listen(<span class="hljs-number">1337</span>, <span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-function">() =></span> {
+proxy.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>, <span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-function">() =></span> {
 
   <span class="hljs-comment">// Make a request to a tunneling proxy</span>
   <span class="hljs-keyword">const</span> options = {
@@ -35193,33 +37962,33 @@ proxy.listen(<span class="hljs-number">1337</span>, <span class="hljs-string">'1
     <span class="hljs-attr">path</span>: <span class="hljs-string">'www.google.com:80'</span>
   };
 
-  <span class="hljs-keyword">const</span> req = http.request(options);
-  req.end();
+  <span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options);
+  req.<span class="hljs-title function_">end</span>();
 
-  req.on(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">res, socket, head</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'got connected!'</span>);
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">res, socket, head</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'got connected!'</span>);
 
     <span class="hljs-comment">// Make a request over an HTTP tunnel</span>
-    socket.write(<span class="hljs-string">'GET / HTTP/1.1\r\n'</span> +
+    socket.<span class="hljs-title function_">write</span>(<span class="hljs-string">'GET / HTTP/1.1\r\n'</span> +
                  <span class="hljs-string">'Host: www.google.com:80\r\n'</span> +
                  <span class="hljs-string">'Connection: close\r\n'</span> +
                  <span class="hljs-string">'\r\n'</span>);
-    socket.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-      <span class="hljs-built_in">console</span>.log(chunk.toString());
+    socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk.<span class="hljs-title function_">toString</span>());
     });
-    socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-      proxy.close();
+    socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+      proxy.<span class="hljs-title function_">close</span>();
     });
   });
 });</code></pre>
-<h3>Event: <code>'continue'</code><span><a class="mark" href="#http_event_continue" id="http_event_continue">#</a></span></h3>
+<h4>Event: <code>'continue'</code><span><a class="mark" href="#http_event_continue" id="http_event_continue">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
 <p>Emitted when the server sends a '100 Continue' HTTP response, usually because
 the request contained 'Expect: 100-continue'. This is an instruction that
 the client should send the request body.</p>
-<h3>Event: <code>'information'</code><span><a class="mark" href="#http_event_information" id="http_event_information">#</a></span></h3>
+<h4>Event: <code>'information'</code><span><a class="mark" href="#http_event_information" id="http_event_information">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -35249,17 +38018,17 @@ and array with the raw header names followed by their respective values.</p>
 };
 
 <span class="hljs-comment">// Make a request</span>
-<span class="hljs-keyword">const</span> req = http.request(options);
-req.end();
+<span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options);
+req.<span class="hljs-title function_">end</span>();
 
-req.on(<span class="hljs-string">'information'</span>, <span class="hljs-function">(<span class="hljs-params">info</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Got information prior to main response: <span class="hljs-subst">${info.statusCode}</span>`</span>);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'information'</span>, <span class="hljs-function">(<span class="hljs-params">info</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Got information prior to main response: <span class="hljs-subst">${info.statusCode}</span>`</span>);
 });</code></pre>
 <p>101 Upgrade statuses do not fire this event due to their break from the
 traditional HTTP request/response chain, such as web sockets, in-place TLS
 upgrades, or HTTP 2.0. To be notified of 101 Upgrade notices, listen for the
 <a href="#http_event_upgrade"><code>'upgrade'</code></a> event instead.</p>
-<h3>Event: <code>'response'</code><span><a class="mark" href="#http_event_response" id="http_event_response">#</a></span></h3>
+<h4>Event: <code>'response'</code><span><a class="mark" href="#http_event_response" id="http_event_response">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.0</span>
 </div>
@@ -35268,7 +38037,7 @@ upgrades, or HTTP 2.0. To be notified of 101 Upgrade notices, listen for the
 </ul>
 <p>Emitted when a response is received to this request. This event is emitted only
 once.</p>
-<h3>Event: <code>'socket'</code><span><a class="mark" href="#http_event_socket" id="http_event_socket">#</a></span></h3>
+<h4>Event: <code>'socket'</code><span><a class="mark" href="#http_event_socket" id="http_event_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.3</span>
 </div>
@@ -35278,14 +38047,14 @@ once.</p>
 <p>This event is guaranteed to be passed an instance of the <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specifies a socket
 type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3>Event: <code>'timeout'</code><span><a class="mark" href="#http_event_timeout" id="http_event_timeout">#</a></span></h3>
+<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http_event_timeout" id="http_event_timeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.8</span>
 </div>
 <p>Emitted when the underlying socket times out from inactivity. This only notifies
 that the socket has been idle. The request must be aborted manually.</p>
 <p>See also: <a href="#http_request_settimeout_timeout_callback"><code>request.setTimeout()</code></a>.</p>
-<h3>Event: <code>'upgrade'</code><span><a class="mark" href="#http_event_upgrade" id="http_event_upgrade">#</a></span></h3>
+<h4>Event: <code>'upgrade'</code><span><a class="mark" href="#http_event_upgrade" id="http_event_upgrade">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -35305,21 +38074,21 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 
 <span class="hljs-comment">// Create an HTTP server</span>
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
-  res.end(<span class="hljs-string">'okay'</span>);
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'okay'</span>);
 });
-server.on(<span class="hljs-string">'upgrade'</span>, <span class="hljs-function">(<span class="hljs-params">req, socket, head</span>) =></span> {
-  socket.write(<span class="hljs-string">'HTTP/1.1 101 Web Socket Protocol Handshake\r\n'</span> +
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'upgrade'</span>, <span class="hljs-function">(<span class="hljs-params">req, socket, head</span>) =></span> {
+  socket.<span class="hljs-title function_">write</span>(<span class="hljs-string">'HTTP/1.1 101 Web Socket Protocol Handshake\r\n'</span> +
                <span class="hljs-string">'Upgrade: WebSocket\r\n'</span> +
                <span class="hljs-string">'Connection: Upgrade\r\n'</span> +
                <span class="hljs-string">'\r\n'</span>);
 
-  socket.pipe(socket); <span class="hljs-comment">// echo back</span>
+  socket.<span class="hljs-title function_">pipe</span>(socket); <span class="hljs-comment">// echo back</span>
 });
 
 <span class="hljs-comment">// Now that server is running</span>
-server.listen(<span class="hljs-number">1337</span>, <span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-function">() =></span> {
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>, <span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-function">() =></span> {
 
   <span class="hljs-comment">// make a request</span>
   <span class="hljs-keyword">const</span> options = {
@@ -35331,22 +38100,23 @@ server.listen(<span class="hljs-number">1337</span>, <span class="hljs-string">'
     }
   };
 
-  <span class="hljs-keyword">const</span> req = http.request(options);
-  req.end();
+  <span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options);
+  req.<span class="hljs-title function_">end</span>();
 
-  req.on(<span class="hljs-string">'upgrade'</span>, <span class="hljs-function">(<span class="hljs-params">res, socket, upgradeHead</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'got upgraded!'</span>);
-    socket.end();
-    process.exit(<span class="hljs-number">0</span>);
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'upgrade'</span>, <span class="hljs-function">(<span class="hljs-params">res, socket, upgradeHead</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'got upgraded!'</span>);
+    socket.<span class="hljs-title function_">end</span>();
+    process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">0</span>);
   });
 });</code></pre>
-<h3><code>request.abort()</code><span><a class="mark" href="#http_request_abort" id="http_request_abort">#</a></span></h3>
+<h4><code>request.abort()</code><span><a class="mark" href="#http_request_abort" id="http_request_abort">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.3.8</span>
+<span>Added in: v0.3.8</span><span>Deprecated since: v14.1.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#http_request_destroy_error"><code>request.destroy()</code></a> instead.</div><p></p>
 <p>Marks the request as aborting. Calling this will cause remaining data
 in the response to be dropped and the socket to be destroyed.</p>
-<h3><code>request.aborted</code><span><a class="mark" href="#http_request_aborted" id="http_request_aborted">#</a></span></h3>
+<h4><code>request.aborted</code><span><a class="mark" href="#http_request_aborted" id="http_request_aborted">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -35363,15 +38133,16 @@ in the response to be dropped and the socket to be destroyed.</p>
 </ul>
 <p>The <code>request.aborted</code> property will be <code>true</code> if the request has
 been aborted.</p>
-<h3><code>request.connection</code><span><a class="mark" href="#http_request_connection" id="http_request_connection">#</a></span></h3>
+<h4><code>request.connection</code><span><a class="mark" href="#http_request_connection" id="http_request_connection">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.3.0</span>
+<span>Added in: v0.3.0</span><span>Deprecated since: v13.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http_request_socket"><code>request.socket</code></a>.</div><p></p>
 <ul>
 <li><a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a></li>
 </ul>
 <p>See <a href="#http_request_socket"><code>request.socket</code></a>.</p>
-<h3><code>request.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http_request_end_data_encoding_callback" id="http_request_end_data_encoding_callback">#</a></span></h3>
+<h4><code>request.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http_request_end_data_encoding_callback" id="http_request_end_data_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -35396,9 +38167,38 @@ chunked, this will send the terminating <code>'0\r\n\r\n'</code>.</p>
 <a href="#http_request_write_chunk_encoding_callback"><code>request.write(data, encoding)</code></a> followed by <code>request.end(callback)</code>.</p>
 <p>If <code>callback</code> is specified, it will be called when the request stream
 is finished.</p>
-<h3><code>request.finished</code><span><a class="mark" href="#http_request_finished" id="http_request_finished">#</a></span></h3>
+<h4><code>request.destroy([error])</code><span><a class="mark" href="#http_request_destroy_error" id="http_request_destroy_error">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.5.0</td>
+<td><p>The function returns <code>this</code> for consistency with other Readable streams.</p></td></tr>
+<tr><td>v0.3.0</td>
+<td><p><span>Added in: v0.3.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Optional, an error to emit with <code>'error'</code> event.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Destroy the request. Optionally emit an <code>'error'</code> event,
+and emit a <code>'close'</code> event. Calling this will cause remaining data
+in the response to be dropped and the socket to be destroyed.</p>
+<p>See <a href="#stream_writable_destroy_error"><code>writable.destroy()</code></a> for further details.</p>
+<h5><code>request.destroyed</code><span><a class="mark" href="#http_request_destroyed" id="http_request_destroyed">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.1.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Is <code>true</code> after <a href="#http_request_destroy_error"><code>request.destroy()</code></a> has been called.</p>
+<p>See <a href="#stream_writable_destroyed"><code>writable.destroyed</code></a> for further details.</p>
+<h4><code>request.finished</code><span><a class="mark" href="#http_request_finished" id="http_request_finished">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.0.1</span><span>Deprecated since: v12.16.0</span>
+<span>Added in: v0.0.1</span><span>Deprecated since: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http_request_writableended"><code>request.writableEnded</code></a>.</div><p></p>
 <ul>
@@ -35407,7 +38207,7 @@ is finished.</p>
 <p>The <code>request.finished</code> property will be <code>true</code> if <a href="#http_request_end_data_encoding_callback"><code>request.end()</code></a>
 has been called. <code>request.end()</code> will automatically be called if the
 request was initiated via <a href="#http_http_get_options_callback"><code>http.get()</code></a>.</p>
-<h3><code>request.flushHeaders()</code><span><a class="mark" href="#http_request_flushheaders" id="http_request_flushheaders">#</a></span></h3>
+<h4><code>request.flushHeaders()</code><span><a class="mark" href="#http_request_flushheaders" id="http_request_flushheaders">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
@@ -35418,7 +38218,7 @@ then tries to pack the request headers and data into a single TCP packet.</p>
 <p>That's usually desired (it saves a TCP round-trip), but not when the first
 data is not sent until possibly much later. <code>request.flushHeaders()</code> bypasses
 the optimization and kickstarts the request.</p>
-<h3><code>request.getHeader(name)</code><span><a class="mark" href="#http_request_getheader_name" id="http_request_getheader_name">#</a></span></h3>
+<h4><code>request.getHeader(name)</code><span><a class="mark" href="#http_request_getheader_name" id="http_request_getheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
@@ -35429,49 +38229,63 @@ the optimization and kickstarts the request.</p>
 <p>Reads out a header on the request. The name is case-insensitive.
 The type of the return value depends on the arguments provided to
 <a href="#http_request_setheader_name_value"><code>request.setHeader()</code></a>.</p>
-<pre><code class="language-js">request.setHeader(<span class="hljs-string">'content-type'</span>, <span class="hljs-string">'text/html'</span>);
-request.setHeader(<span class="hljs-string">'Content-Length'</span>, Buffer.byteLength(body));
-request.setHeader(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);
-<span class="hljs-keyword">const</span> contentType = request.getHeader(<span class="hljs-string">'Content-Type'</span>);
+<pre><code class="language-js">request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'content-type'</span>, <span class="hljs-string">'text/html'</span>);
+request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Length'</span>, <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(body));
+request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);
+<span class="hljs-keyword">const</span> contentType = request.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'Content-Type'</span>);
 <span class="hljs-comment">// 'contentType' is 'text/html'</span>
-<span class="hljs-keyword">const</span> contentLength = request.getHeader(<span class="hljs-string">'Content-Length'</span>);
+<span class="hljs-keyword">const</span> contentLength = request.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'Content-Length'</span>);
 <span class="hljs-comment">// 'contentLength' is of type number</span>
-<span class="hljs-keyword">const</span> cookie = request.getHeader(<span class="hljs-string">'Cookie'</span>);
+<span class="hljs-keyword">const</span> cookie = request.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'Cookie'</span>);
 <span class="hljs-comment">// 'cookie' is of type string[]</span></code></pre>
-<h3><code>request.maxHeadersCount</code><span><a class="mark" href="#http_request_maxheaderscount" id="http_request_maxheaderscount">#</a></span></h3>
+<h4><code>request.getRawHeaderNames()</code><span><a class="mark" href="#http_request_getrawheadernames" id="http_request_getrawheadernames">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>Returns an array containing the unique names of the current outgoing raw
+headers. Header names are returned with their exact casing being set.</p>
+<pre><code class="language-js">request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+
+<span class="hljs-keyword">const</span> headerNames = request.<span class="hljs-title function_">getRawHeaderNames</span>();
+<span class="hljs-comment">// headerNames === ['Foo', 'Set-Cookie']</span></code></pre>
+<h4><code>request.maxHeadersCount</code><span><a class="mark" href="#http_request_maxheaderscount" id="http_request_maxheaderscount">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>2000</code></li>
 </ul>
 <p>Limits maximum response headers count. If set to 0, no limit will be applied.</p>
-<h3><code>request.path</code><span><a class="mark" href="#http_request_path" id="http_request_path">#</a></span></h3>
+<h4><code>request.path</code><span><a class="mark" href="#http_request_path" id="http_request_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The request path.</li>
 </ul>
-<h3><code>request.method</code><span><a class="mark" href="#http_request_method" id="http_request_method">#</a></span></h3>
+<h4><code>request.method</code><span><a class="mark" href="#http_request_method" id="http_request_method">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.97</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The request method.</li>
 </ul>
-<h3><code>request.host</code><span><a class="mark" href="#http_request_host" id="http_request_host">#</a></span></h3>
+<h4><code>request.host</code><span><a class="mark" href="#http_request_host" id="http_request_host">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The request host.</li>
 </ul>
-<h3><code>request.protocol</code><span><a class="mark" href="#http_request_protocol" id="http_request_protocol">#</a></span></h3>
+<h4><code>request.protocol</code><span><a class="mark" href="#http_request_protocol" id="http_request_protocol">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The request protocol.</li>
 </ul>
-<h3><code>request.removeHeader(name)</code><span><a class="mark" href="#http_request_removeheader_name" id="http_request_removeheader_name">#</a></span></h3>
+<h4><code>request.removeHeader(name)</code><span><a class="mark" href="#http_request_removeheader_name" id="http_request_removeheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
@@ -35479,10 +38293,10 @@ request.setHeader(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Removes a header that's already defined into headers object.</p>
-<pre><code class="language-js">request.removeHeader(<span class="hljs-string">'Content-Type'</span>);</code></pre>
-<h3><code>request.reusedSocket</code><span><a class="mark" href="#http_request_reusedsocket" id="http_request_reusedsocket">#</a></span></h3>
+<pre><code class="language-js">request.<span class="hljs-title function_">removeHeader</span>(<span class="hljs-string">'Content-Type'</span>);</code></pre>
+<h4><code>request.reusedSocket</code><span><a class="mark" href="#http_request_reusedsocket" id="http_request_reusedsocket">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the request is send through a reused socket.</li>
@@ -35494,16 +38308,16 @@ may run into a 'ECONNRESET' error.</p>
 
 <span class="hljs-comment">// Server has a 5 seconds keep-alive timeout by default</span>
 http
-  .createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    res.write(<span class="hljs-string">'hello\n'</span>);
-    res.end();
+  .<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    res.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello\n'</span>);
+    res.<span class="hljs-title function_">end</span>();
   })
-  .listen(<span class="hljs-number">3000</span>);
+  .<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);
 
 <span class="hljs-built_in">setInterval</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Adapting a keep-alive agent</span>
-  http.get(<span class="hljs-string">'http://localhost:3000'</span>, { agent }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-    res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  http.<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:3000'</span>, { agent }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+    res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
       <span class="hljs-comment">// Do nothing</span>
     });
   });
@@ -35511,23 +38325,23 @@ http
 <p>By marking a request whether it reused socket or not, we can do
 automatic error retry base on it.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> agent = <span class="hljs-keyword">new</span> http.Agent({ <span class="hljs-attr">keepAlive</span>: <span class="hljs-literal">true</span> });
+<span class="hljs-keyword">const</span> agent = <span class="hljs-keyword">new</span> http.<span class="hljs-title class_">Agent</span>({ <span class="hljs-attr">keepAlive</span>: <span class="hljs-literal">true</span> });
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">retriableRequest</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">retriableRequest</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">const</span> req = http
-    .get(<span class="hljs-string">'http://localhost:3000'</span>, { agent }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+    .<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:3000'</span>, { agent }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
       <span class="hljs-comment">// ...</span>
     })
-    .on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    .<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
       <span class="hljs-comment">// Check if retry is needed</span>
-      <span class="hljs-keyword">if</span> (req.reusedSocket &#x26;&#x26; err.code === <span class="hljs-string">'ECONNRESET'</span>) {
-        retriableRequest();
+      <span class="hljs-keyword">if</span> (req.<span class="hljs-property">reusedSocket</span> &#x26;&#x26; err.<span class="hljs-property">code</span> === <span class="hljs-string">'ECONNRESET'</span>) {
+        <span class="hljs-title function_">retriableRequest</span>();
       }
     });
 }
 
-retriableRequest();</code></pre>
-<h3><code>request.setHeader(name, value)</code><span><a class="mark" href="#http_request_setheader_name_value" id="http_request_setheader_name_value">#</a></span></h3>
+<span class="hljs-title function_">retriableRequest</span>();</code></pre>
+<h4><code>request.setHeader(name, value)</code><span><a class="mark" href="#http_request_setheader_name_value" id="http_request_setheader_name_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
@@ -35541,10 +38355,10 @@ here to send multiple headers with the same name. Non-string values will be
 stored without modification. Therefore, <a href="#http_request_getheader_name"><code>request.getHeader()</code></a> may return
 non-string values. However, the non-string values will be converted to strings
 for network transmission.</p>
-<pre><code class="language-js">request.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'application/json'</span>);</code></pre>
+<pre><code class="language-js">request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'application/json'</span>);</code></pre>
 <p>or</p>
-<pre><code class="language-js">request.setHeader(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
-<h3><code>request.setNoDelay([noDelay])</code><span><a class="mark" href="#http_request_setnodelay_nodelay" id="http_request_setnodelay_nodelay">#</a></span></h3>
+<pre><code class="language-js">request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
+<h4><code>request.setNoDelay([noDelay])</code><span><a class="mark" href="#http_request_setnodelay_nodelay" id="http_request_setnodelay_nodelay">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -35553,7 +38367,7 @@ for network transmission.</p>
 </ul>
 <p>Once a socket is assigned to this request and is connected
 <a href="#net_socket_setnodelay_nodelay"><code>socket.setNoDelay()</code></a> will be called.</p>
-<h3><code>request.setSocketKeepAlive([enable][, initialDelay])</code><span><a class="mark" href="#http_request_setsocketkeepalive_enable_initialdelay" id="http_request_setsocketkeepalive_enable_initialdelay">#</a></span></h3>
+<h4><code>request.setSocketKeepAlive([enable][, initialDelay])</code><span><a class="mark" href="#http_request_setsocketkeepalive_enable_initialdelay" id="http_request_setsocketkeepalive_enable_initialdelay">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -35563,7 +38377,7 @@ for network transmission.</p>
 </ul>
 <p>Once a socket is assigned to this request and is connected
 <a href="#net_socket_setkeepalive_enable_initialdelay"><code>socket.setKeepAlive()</code></a> will be called.</p>
-<h3><code>request.setTimeout(timeout[, callback])</code><span><a class="mark" href="#http_request_settimeout_timeout_callback" id="http_request_settimeout_timeout_callback">#</a></span></h3>
+<h4><code>request.setTimeout(timeout[, callback])</code><span><a class="mark" href="#http_request_settimeout_timeout_callback" id="http_request_settimeout_timeout_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -35583,7 +38397,7 @@ Same as binding to the <code>'timeout'</code> event.</li>
 </ul>
 <p>Once a socket is assigned to this request and is connected
 <a href="#net_socket_settimeout_timeout_callback"><code>socket.setTimeout()</code></a> will be called.</p>
-<h3><code>request.socket</code><span><a class="mark" href="#http_request_socket" id="http_request_socket">#</a></span></h3>
+<h4><code>request.socket</code><span><a class="mark" href="#http_request_socket" id="http_request_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -35592,24 +38406,23 @@ Same as binding to the <code>'timeout'</code> event.</li>
 </ul>
 <p>Reference to the underlying socket. Usually users will not want to access
 this property. In particular, the socket will not emit <code>'readable'</code> events
-because of how the protocol parser attaches to the socket. The <code>socket</code>
-may also be accessed via <code>request.connection</code>.</p>
+because of how the protocol parser attaches to the socket.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">host</span>: <span class="hljs-string">'www.google.com'</span>,
 };
-<span class="hljs-keyword">const</span> req = http.get(options);
-req.end();
-req.once(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-keyword">const</span> ip = req.socket.localAddress;
-  <span class="hljs-keyword">const</span> port = req.socket.localPort;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
+<span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">get</span>(options);
+req.<span class="hljs-title function_">end</span>();
+req.<span class="hljs-title function_">once</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-keyword">const</span> ip = req.<span class="hljs-property">socket</span>.<span class="hljs-property">localAddress</span>;
+  <span class="hljs-keyword">const</span> port = req.<span class="hljs-property">socket</span>.<span class="hljs-property">localPort</span>;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
   <span class="hljs-comment">// Consume response object</span>
 });</code></pre>
 <p>This property is guaranteed to be an instance of the <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specified a socket
 type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3><code>request.writableEnded</code><span><a class="mark" href="#http_request_writableended" id="http_request_writableended">#</a></span></h3>
+<h4><code>request.writableEnded</code><span><a class="mark" href="#http_request_writableended" id="http_request_writableended">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -35619,7 +38432,7 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 <p>Is <code>true</code> after <a href="#http_request_end_data_encoding_callback"><code>request.end()</code></a> has been called. This property
 does not indicate whether the data has been flushed, for this use
 <a href="#http_request_writablefinished"><code>request.writableFinished</code></a> instead.</p>
-<h3><code>request.writableFinished</code><span><a class="mark" href="#http_request_writablefinished" id="http_request_writablefinished">#</a></span></h3>
+<h4><code>request.writableFinished</code><span><a class="mark" href="#http_request_writablefinished" id="http_request_writablefinished">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
@@ -35628,7 +38441,7 @@ does not indicate whether the data has been flushed, for this use
 </ul>
 <p>Is <code>true</code> if all data has been flushed to the underlying system, immediately
 before the <a href="#http_event_finish"><code>'finish'</code></a> event is emitted.</p>
-<h3><code>request.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_request_write_chunk_encoding_callback" id="http_request_write_chunk_encoding_callback">#</a></span></h3>
+<h4><code>request.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_request_write_chunk_encoding_callback" id="http_request_write_chunk_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.29</span>
 </div>
@@ -35638,11 +38451,11 @@ before the <a href="#http_event_finish"><code>'finish'</code></a> event is emitt
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Sends a chunk of the body. By calling this method
-many times, a request body can be sent to a
-server. In that case, it is suggested to use the
-<code>['Transfer-Encoding', 'chunked']</code> header line when
-creating the request.</p>
+<p>Sends a chunk of the body. This method can be called multiple times. If no
+<code>Content-Length</code> is set, data will automatically be encoded in HTTP Chunked
+transfer encoding, so that server knows when the data ends. The
+<code>Transfer-Encoding: chunked</code> header is added. Calling <a href="#http_request_end_data_encoding_callback"><code>request.end()</code></a>
+is necessary to finish sending the request.</p>
 <p>The <code>encoding</code> argument is optional and only applies when <code>chunk</code> is a string.
 Defaults to <code>'utf8'</code>.</p>
 <p>The <code>callback</code> argument is optional and will be called when this chunk of data
@@ -35652,14 +38465,14 @@ buffer. Returns <code>false</code> if all or part of the data was queued in user
 <code>'drain'</code> will be emitted when the buffer is free again.</p>
 <p>When <code>write</code> function is called with empty string or buffer, it does
 nothing and waits for more input.</p>
-<h2>Class: <code>http.Server</code><span><a class="mark" href="#http_class_http_server" id="http_class_http_server">#</a></span></h2>
+</section><section><h3>Class: <code>http.Server</code><span><a class="mark" href="#http_class_http_server" id="http_class_http_server">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
 <ul>
 <li>Extends: <a href="#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
-<h3>Event: <code>'checkContinue'</code><span><a class="mark" href="#http_event_checkcontinue" id="http_event_checkcontinue">#</a></span></h3>
+<h4>Event: <code>'checkContinue'</code><span><a class="mark" href="#http_event_checkcontinue" id="http_event_checkcontinue">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -35676,7 +38489,7 @@ HTTP response (e.g. 400 Bad Request) if the client should not continue to send
 the request body.</p>
 <p>When this event is emitted and handled, the <a href="#http_event_request"><code>'request'</code></a> event will
 not be emitted.</p>
-<h3>Event: <code>'checkExpectation'</code><span><a class="mark" href="#http_event_checkexpectation" id="http_event_checkexpectation">#</a></span></h3>
+<h4>Event: <code>'checkExpectation'</code><span><a class="mark" href="#http_event_checkexpectation" id="http_event_checkexpectation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.5.0</span>
 </div>
@@ -35689,7 +38502,7 @@ value is not <code>100-continue</code>. If this event is not listened for, the s
 automatically respond with a <code>417 Expectation Failed</code> as appropriate.</p>
 <p>When this event is emitted and handled, the <a href="#http_event_request"><code>'request'</code></a> event will
 not be emitted.</p>
-<h3>Event: <code>'clientError'</code><span><a class="mark" href="#http_event_clienterror" id="http_event_clienterror">#</a></span></h3>
+<h4>Event: <code>'clientError'</code><span><a class="mark" href="#http_event_clienterror" id="http_event_clienterror">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -35723,13 +38536,13 @@ written data it is immediately destroyed.</p>
 <p><code>socket</code> is the <a href="#net_class_net_socket"><code>net.Socket</code></a> object that the error originated from.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.end();
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">end</span>();
 });
-server.on(<span class="hljs-string">'clientError'</span>, <span class="hljs-function">(<span class="hljs-params">err, socket</span>) =></span> {
-  socket.end(<span class="hljs-string">'HTTP/1.1 400 Bad Request\r\n\r\n'</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'clientError'</span>, <span class="hljs-function">(<span class="hljs-params">err, socket</span>) =></span> {
+  socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'HTTP/1.1 400 Bad Request\r\n\r\n'</span>);
 });
-server.listen(<span class="hljs-number">8000</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
 <p>When the <code>'clientError'</code> event occurs, there is no <code>request</code> or <code>response</code>
 object, so any HTTP response sent, including response headers and payload,
 <em>must</em> be written directly to the <code>socket</code> object. Care must be taken to
@@ -35744,19 +38557,19 @@ correctly;</li>
 has already been destroyed, like in case of <code>ECONNRESET</code> errors. Before
 trying to send data to the socket, it is better to check that it is still
 writable.</p>
-<pre><code class="language-js">server.on(<span class="hljs-string">'clientError'</span>, <span class="hljs-function">(<span class="hljs-params">err, socket</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ECONNRESET'</span> || !socket.writable) {
+<pre><code class="language-js">server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'clientError'</span>, <span class="hljs-function">(<span class="hljs-params">err, socket</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ECONNRESET'</span> || !socket.<span class="hljs-property">writable</span>) {
     <span class="hljs-keyword">return</span>;
   }
 
-  socket.end(<span class="hljs-string">'HTTP/1.1 400 Bad Request\r\n\r\n'</span>);
+  socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'HTTP/1.1 400 Bad Request\r\n\r\n'</span>);
 });</code></pre>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#http_event_close" id="http_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#http_event_close" id="http_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.4</span>
 </div>
 <p>Emitted when the server closes.</p>
-<h3>Event: <code>'connect'</code><span><a class="mark" href="#http_event_connect_1" id="http_event_connect_1">#</a></span></h3>
+<h4>Event: <code>'connect'</code><span><a class="mark" href="#http_event_connect_1" id="http_event_connect_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -35775,7 +38588,7 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 <p>After this event is emitted, the request's socket will not have a <code>'data'</code>
 event listener, meaning it will need to be bound in order to handle data
 sent to the server on that socket.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#http_event_connection" id="http_event_connection">#</a></span></h3>
+<h4>Event: <code>'connection'</code><span><a class="mark" href="#http_event_connection" id="http_event_connection">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.0</span>
 </div>
@@ -35786,7 +38599,7 @@ sent to the server on that socket.</p>
 typically an object of type <a href="#net_class_net_socket"><code>net.Socket</code></a>. Usually users will not want to
 access this event. In particular, the socket will not emit <code>'readable'</code> events
 because of how the protocol parser attaches to the socket. The <code>socket</code> can
-also be accessed at <code>request.connection</code>.</p>
+also be accessed at <code>request.socket</code>.</p>
 <p>This event can also be explicitly emitted by users to inject connections
 into the HTTP server. In that case, any <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream can be passed.</p>
 <p>If <code>socket.setTimeout()</code> is called here, the timeout will be replaced with
@@ -35795,7 +38608,7 @@ into the HTTP server. In that case, any <a href="#stream_class_stream_duplex"><c
 <p>This event is guaranteed to be passed an instance of the <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specifies a socket
 type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3>Event: <code>'request'</code><span><a class="mark" href="#http_event_request" id="http_event_request">#</a></span></h3>
+<h4>Event: <code>'request'</code><span><a class="mark" href="#http_event_request" id="http_event_request">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.0</span>
 </div>
@@ -35805,7 +38618,7 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 </ul>
 <p>Emitted each time there is a request. There may be multiple requests
 per connection (in the case of HTTP Keep-Alive connections).</p>
-<h3>Event: <code>'upgrade'</code><span><a class="mark" href="#http_event_upgrade_1" id="http_event_upgrade_1">#</a></span></h3>
+<h4>Event: <code>'upgrade'</code><span><a class="mark" href="#http_event_upgrade_1" id="http_event_upgrade_1">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -35831,7 +38644,7 @@ sent to the server on that socket.</p>
 <p>This event is guaranteed to be passed an instance of the <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specifies a socket
 type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3><code>server.close([callback])</code><span><a class="mark" href="#http_server_close_callback" id="http_server_close_callback">#</a></span></h3>
+<h4><code>server.close([callback])</code><span><a class="mark" href="#http_server_close_callback" id="http_server_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -35839,9 +38652,9 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <p>Stops the server from accepting new connections. See <a href="#net_server_close_callback"><code>net.Server.close()</code></a>.</p>
-<h3><code>server.headersTimeout</code><span><a class="mark" href="#http_server_headerstimeout" id="http_server_headerstimeout">#</a></span></h3>
+<h4><code>server.headersTimeout</code><span><a class="mark" href="#http_server_headerstimeout" id="http_server_headerstimeout">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.3.0</span>
+<span>Added in: v11.3.0, v10.14.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>60000</code></li>
@@ -35857,18 +38670,17 @@ passed since the connection was established. If the check fails, a <code>'timeou
 event is emitted on the server object, and (by default) the socket is destroyed.
 See <a href="#http_server_timeout"><code>server.timeout</code></a> for more information on how timeout behavior can be
 customized.</p>
-<p>A value of <code>0</code> will disable the HTTP headers timeout check.</p>
-<h3><code>server.listen()</code><span><a class="mark" href="#http_server_listen" id="http_server_listen">#</a></span></h3>
+<h4><code>server.listen()</code><span><a class="mark" href="#http_server_listen" id="http_server_listen">#</a></span></h4>
 <p>Starts the HTTP server listening for connections.
 This method is identical to <a href="#net_server_listen"><code>server.listen()</code></a> from <a href="#net_class_net_server"><code>net.Server</code></a>.</p>
-<h3><code>server.listening</code><span><a class="mark" href="#http_server_listening" id="http_server_listening">#</a></span></h3>
+<h4><code>server.listening</code><span><a class="mark" href="#http_server_listening" id="http_server_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.7.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether or not the server is listening for connections.</li>
 </ul>
-<h3><code>server.maxHeadersCount</code><span><a class="mark" href="#http_server_maxheaderscount" id="http_server_maxheaderscount">#</a></span></h3>
+<h4><code>server.maxHeadersCount</code><span><a class="mark" href="#http_server_maxheaderscount" id="http_server_maxheaderscount">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -35876,12 +38688,34 @@ This method is identical to <a href="#net_server_listen"><code>server.listen()</
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>2000</code></li>
 </ul>
 <p>Limits maximum incoming headers count. If set to 0, no limit will be applied.</p>
-<h3><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http_server_settimeout_msecs_callback" id="http_server_settimeout_msecs_callback">#</a></span></h3>
+<h4><code>server.requestTimeout</code><span><a class="mark" href="#http_server_requesttimeout" id="http_server_requesttimeout">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.9.12</span>
+<span>Added in: v14.11.0</span>
 </div>
 <ul>
-<li><code>msecs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>120000</code> (2 minutes)</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>0</code></li>
+</ul>
+<p>Sets the timeout value in milliseconds for receiving the entire request from
+the client.</p>
+<p>If the timeout expires, the server responds with status 408 without
+forwarding the request to the request listener and then closes the connection.</p>
+<p>It must be set to a non-zero value (e.g. 120 seconds) to protect against
+potential Denial-of-Service attacks in case the server is deployed without a
+reverse proxy in front.</p>
+<h4><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http_server_settimeout_msecs_callback" id="http_server_settimeout_msecs_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v0.9.12</td>
+<td><p><span>Added in: v0.9.12</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>msecs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> 0 (no timeout)</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li>Returns: <a href="#http_class_http_server" class="type">&#x3C;http.Server></a></li>
 </ul>
@@ -35890,26 +38724,30 @@ the Server object, passing the socket as an argument, if a timeout
 occurs.</p>
 <p>If there is a <code>'timeout'</code> event listener on the Server object, then it
 will be called with the timed-out socket as an argument.</p>
-<p>By default, the Server's timeout value is 2 minutes, and sockets are
-destroyed automatically if they time out. However, if a callback is assigned
-to the Server's <code>'timeout'</code> event, timeouts must be handled explicitly.</p>
-<p>To change the default timeout use the <a href="#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout</code></a>
-flag.</p>
-<h3><code>server.timeout</code><span><a class="mark" href="#http_server_timeout" id="http_server_timeout">#</a></span></h3>
+<p>By default, the Server does not timeout sockets. However, if a callback
+is assigned to the Server's <code>'timeout'</code> event, timeouts must be handled
+explicitly.</p>
+<h4><code>server.timeout</code><span><a class="mark" href="#http_server_timeout" id="http_server_timeout">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.9.12</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v0.9.12</td>
+<td><p><span>Added in: v0.9.12</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Timeout in milliseconds. <strong>Default:</strong> <code>120000</code> (2 minutes).</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Timeout in milliseconds. <strong>Default:</strong> 0 (no timeout)</li>
 </ul>
 <p>The number of milliseconds of inactivity before a socket is presumed
 to have timed out.</p>
 <p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>
 <p>The socket timeout logic is set up on connection, so changing this
 value only affects new connections to the server, not any existing connections.</p>
-<p>To change the default timeout use the <a href="#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout</code></a>
-flag.</p>
-<h3><code>server.keepAliveTimeout</code><span><a class="mark" href="#http_server_keepalivetimeout" id="http_server_keepalivetimeout">#</a></span></h3>
+<h4><code>server.keepAliveTimeout</code><span><a class="mark" href="#http_server_keepalivetimeout" id="http_server_keepalivetimeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -35927,7 +38765,7 @@ A value of <code>0</code> makes the http server behave similarly to Node.js vers
 to 8.0.0, which did not have a keep-alive timeout.</p>
 <p>The socket timeout logic is set up on connection, so changing this value only
 affects new connections to the server, not any existing connections.</p>
-<h2>Class: <code>http.ServerResponse</code><span><a class="mark" href="#http_class_http_serverresponse" id="http_class_http_serverresponse">#</a></span></h2>
+</section><section><h3>Class: <code>http.ServerResponse</code><span><a class="mark" href="#http_class_http_serverresponse" id="http_class_http_serverresponse">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
@@ -35936,13 +38774,13 @@ affects new connections to the server, not any existing connections.</p>
 </ul>
 <p>This object is created internally by an HTTP server, not by the user. It is
 passed as the second parameter to the <a href="#http_event_request"><code>'request'</code></a> event.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#http_event_close_1" id="http_event_close_1">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#http_event_close_1" id="http_event_close_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.7</span>
 </div>
-<p>Indicates that the the response is completed, or its underlying connection was
+<p>Indicates that the response is completed, or its underlying connection was
 terminated prematurely (before the response completion).</p>
-<h3>Event: <code>'finish'</code><span><a class="mark" href="#http_event_finish" id="http_event_finish">#</a></span></h3>
+<h4>Event: <code>'finish'</code><span><a class="mark" href="#http_event_finish" id="http_event_finish">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.6</span>
 </div>
@@ -35950,7 +38788,7 @@ terminated prematurely (before the response completion).</p>
 emitted when the last segment of the response headers and body have been
 handed off to the operating system for transmission over the network. It
 does not imply that the client has received anything yet.</p>
-<h3><code>response.addTrailers(headers)</code><span><a class="mark" href="#http_response_addtrailers_headers" id="http_response_addtrailers_headers">#</a></span></h3>
+<h4><code>response.addTrailers(headers)</code><span><a class="mark" href="#http_response_addtrailers_headers" id="http_response_addtrailers_headers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -35964,27 +38802,28 @@ response; if it is not (e.g. if the request was HTTP/1.0), they will
 be silently discarded.</p>
 <p>HTTP requires the <code>Trailer</code> header to be sent in order to
 emit trailers, with a list of the header fields in its value. E.g.,</p>
-<pre><code class="language-js">response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span>,
+<pre><code class="language-js">response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span>,
                           <span class="hljs-string">'Trailer'</span>: <span class="hljs-string">'Content-MD5'</span> });
-response.write(fileData);
-response.addTrailers({ <span class="hljs-string">'Content-MD5'</span>: <span class="hljs-string">'7895bf4b8828b55ceaf47747b4bca667'</span> });
-response.end();</code></pre>
+response.<span class="hljs-title function_">write</span>(fileData);
+response.<span class="hljs-title function_">addTrailers</span>({ <span class="hljs-string">'Content-MD5'</span>: <span class="hljs-string">'7895bf4b8828b55ceaf47747b4bca667'</span> });
+response.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
-<h3><code>response.connection</code><span><a class="mark" href="#http_response_connection" id="http_response_connection">#</a></span></h3>
+<h4><code>response.connection</code><span><a class="mark" href="#http_response_connection" id="http_response_connection">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.3.0</span>
+<span>Added in: v0.3.0</span><span>Deprecated since: v13.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http_response_socket"><code>response.socket</code></a>.</div><p></p>
 <ul>
 <li><a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a></li>
 </ul>
 <p>See <a href="#http_response_socket"><code>response.socket</code></a>.</p>
-<h3><code>response.cork()</code><span><a class="mark" href="#http_response_cork" id="http_response_cork">#</a></span></h3>
+<h4><code>response.cork()</code><span><a class="mark" href="#http_response_cork" id="http_response_cork">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <p>See <a href="#stream_writable_cork"><code>writable.cork()</code></a>.</p>
-<h3><code>response.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http_response_end_data_encoding_callback" id="http_response_end_data_encoding_callback">#</a></span></h3>
+<h4><code>response.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http_response_end_data_encoding_callback" id="http_response_end_data_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -36009,9 +38848,9 @@ The method, <code>response.end()</code>, MUST be called on each response.</p>
 <a href="#http_response_write_chunk_encoding_callback"><code>response.write(data, encoding)</code></a> followed by <code>response.end(callback)</code>.</p>
 <p>If <code>callback</code> is specified, it will be called when the response stream
 is finished.</p>
-<h3><code>response.finished</code><span><a class="mark" href="#http_response_finished" id="http_response_finished">#</a></span></h3>
+<h4><code>response.finished</code><span><a class="mark" href="#http_response_finished" id="http_response_finished">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.0.2</span><span>Deprecated since: v12.16.0</span>
+<span>Added in: v0.0.2</span><span>Deprecated since: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http_response_writableended"><code>response.writableEnded</code></a>.</div><p></p>
 <ul>
@@ -36019,12 +38858,12 @@ is finished.</p>
 </ul>
 <p>The <code>response.finished</code> property will be <code>true</code> if <a href="#http_response_end_data_encoding_callback"><code>response.end()</code></a>
 has been called.</p>
-<h3><code>response.flushHeaders()</code><span><a class="mark" href="#http_response_flushheaders" id="http_response_flushheaders">#</a></span></h3>
+<h4><code>response.flushHeaders()</code><span><a class="mark" href="#http_response_flushheaders" id="http_response_flushheaders">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
 <p>Flushes the response headers. See also: <a href="#http_request_flushheaders"><code>request.flushHeaders()</code></a>.</p>
-<h3><code>response.getHeader(name)</code><span><a class="mark" href="#http_response_getheader_name" id="http_response_getheader_name">#</a></span></h3>
+<h4><code>response.getHeader(name)</code><span><a class="mark" href="#http_response_getheader_name" id="http_response_getheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
@@ -36035,16 +38874,16 @@ has been called.</p>
 <p>Reads out a header that's already been queued but not sent to the client.
 The name is case-insensitive. The type of the return value depends
 on the arguments provided to <a href="#http_response_setheader_name_value"><code>response.setHeader()</code></a>.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
-response.setHeader(<span class="hljs-string">'Content-Length'</span>, Buffer.byteLength(body));
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);
-<span class="hljs-keyword">const</span> contentType = response.getHeader(<span class="hljs-string">'content-type'</span>);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Length'</span>, <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(body));
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);
+<span class="hljs-keyword">const</span> contentType = response.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'content-type'</span>);
 <span class="hljs-comment">// contentType is 'text/html'</span>
-<span class="hljs-keyword">const</span> contentLength = response.getHeader(<span class="hljs-string">'Content-Length'</span>);
+<span class="hljs-keyword">const</span> contentLength = response.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'Content-Length'</span>);
 <span class="hljs-comment">// contentLength is of type number</span>
-<span class="hljs-keyword">const</span> setCookie = response.getHeader(<span class="hljs-string">'set-cookie'</span>);
+<span class="hljs-keyword">const</span> setCookie = response.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'set-cookie'</span>);
 <span class="hljs-comment">// setCookie is of type string[]</span></code></pre>
-<h3><code>response.getHeaderNames()</code><span><a class="mark" href="#http_response_getheadernames" id="http_response_getheadernames">#</a></span></h3>
+<h4><code>response.getHeaderNames()</code><span><a class="mark" href="#http_response_getheadernames" id="http_response_getheadernames">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -36053,12 +38892,12 @@ response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="
 </ul>
 <p>Returns an array containing the unique names of the current outgoing headers.
 All header names are lowercase.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
 
-<span class="hljs-keyword">const</span> headerNames = response.getHeaderNames();
+<span class="hljs-keyword">const</span> headerNames = response.<span class="hljs-title function_">getHeaderNames</span>();
 <span class="hljs-comment">// headerNames === ['foo', 'set-cookie']</span></code></pre>
-<h3><code>response.getHeaders()</code><span><a class="mark" href="#http_response_getheaders" id="http_response_getheaders">#</a></span></h3>
+<h4><code>response.getHeaders()</code><span><a class="mark" href="#http_response_getheaders" id="http_response_getheaders">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -36074,12 +38913,12 @@ are lowercase.</p>
 prototypically inherit from the JavaScript <code>Object</code>. This means that typical
 <code>Object</code> methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>, and others
 are not defined and <em>will not work</em>.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
 
-<span class="hljs-keyword">const</span> headers = response.getHeaders();
+<span class="hljs-keyword">const</span> headers = response.<span class="hljs-title function_">getHeaders</span>();
 <span class="hljs-comment">// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }</span></code></pre>
-<h3><code>response.hasHeader(name)</code><span><a class="mark" href="#http_response_hasheader_name" id="http_response_hasheader_name">#</a></span></h3>
+<h4><code>response.hasHeader(name)</code><span><a class="mark" href="#http_response_hasheader_name" id="http_response_hasheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -36089,8 +38928,8 @@ response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="
 </ul>
 <p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the
 outgoing headers. The header name matching is case-insensitive.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = response.hasHeader(<span class="hljs-string">'content-type'</span>);</code></pre>
-<h3><code>response.headersSent</code><span><a class="mark" href="#http_response_headerssent" id="http_response_headerssent">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = response.<span class="hljs-title function_">hasHeader</span>(<span class="hljs-string">'content-type'</span>);</code></pre>
+<h4><code>response.headersSent</code><span><a class="mark" href="#http_response_headerssent" id="http_response_headerssent">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -36098,7 +38937,7 @@ outgoing headers. The header name matching is case-insensitive.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Boolean (read-only). True if headers were sent, false otherwise.</p>
-<h3><code>response.removeHeader(name)</code><span><a class="mark" href="#http_response_removeheader_name" id="http_response_removeheader_name">#</a></span></h3>
+<h4><code>response.removeHeader(name)</code><span><a class="mark" href="#http_response_removeheader_name" id="http_response_removeheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
@@ -36106,8 +38945,8 @@ outgoing headers. The header name matching is case-insensitive.</p>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Removes a header that's queued for implicit sending.</p>
-<pre><code class="language-js">response.removeHeader(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
-<h3><code>response.sendDate</code><span><a class="mark" href="#http_response_senddate" id="http_response_senddate">#</a></span></h3>
+<pre><code class="language-js">response.<span class="hljs-title function_">removeHeader</span>(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
+<h4><code>response.sendDate</code><span><a class="mark" href="#http_response_senddate" id="http_response_senddate">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
@@ -36118,34 +38957,37 @@ outgoing headers. The header name matching is case-insensitive.</p>
 the response if it is not already present in the headers. Defaults to true.</p>
 <p>This should only be disabled for testing; HTTP requires the Date header
 in responses.</p>
-<h3><code>response.setHeader(name, value)</code><span><a class="mark" href="#http_response_setheader_name_value" id="http_response_setheader_name_value">#</a></span></h3>
+<h4><code>response.setHeader(name, value)</code><span><a class="mark" href="#http_response_setheader_name_value" id="http_response_setheader_name_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
+<li>Returns: <a href="#http_class_http_serverresponse" class="type">&#x3C;http.ServerResponse></a></li>
 </ul>
+<p>Returns the response object.</p>
 <p>Sets a single header value for implicit headers. If this header already exists
 in the to-be-sent headers, its value will be replaced. Use an array of strings
 here to send multiple headers with the same name. Non-string values will be
 stored without modification. Therefore, <a href="#http_response_getheader_name"><code>response.getHeader()</code></a> may return
 non-string values. However, the non-string values will be converted to strings
-for network transmission.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);</code></pre>
+for network transmission. The same response object is returned to the caller,
+to enable call chaining.</p>
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);</code></pre>
 <p>or</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
 <p>When headers have been set with <a href="#http_response_setheader_name_value"><code>response.setHeader()</code></a>, they will be merged
 with any headers passed to <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a>, with the headers passed
 to <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> given precedence.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Returns content-type = text/plain</span>
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
 <p>If <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> method is called and this method has not been
 called, it will directly write the supplied header values onto the network
@@ -36153,7 +38995,7 @@ channel without caching internally, and the <a href="#http_response_getheader_na
 header will not yield the expected result. If progressive population of headers
 is desired with potential future retrieval and modification, use
 <a href="#http_response_setheader_name_value"><code>response.setHeader()</code></a> instead of <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a>.</p>
-<h3><code>response.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http_response_settimeout_msecs_callback" id="http_response_settimeout_msecs_callback">#</a></span></h3>
+<h4><code>response.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http_response_settimeout_msecs_callback" id="http_response_settimeout_msecs_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.12</span>
 </div>
@@ -36169,7 +39011,7 @@ the response object.</p>
 the server, then sockets are destroyed when they time out. If a handler is
 assigned to the request, the response, or the server's <code>'timeout'</code> events,
 timed out sockets must be handled explicitly.</p>
-<h3><code>response.socket</code><span><a class="mark" href="#http_response_socket" id="http_response_socket">#</a></span></h3>
+<h4><code>response.socket</code><span><a class="mark" href="#http_response_socket" id="http_response_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -36179,18 +39021,17 @@ timed out sockets must be handled explicitly.</p>
 <p>Reference to the underlying socket. Usually users will not want to access
 this property. In particular, the socket will not emit <code>'readable'</code> events
 because of how the protocol parser attaches to the socket. After
-<code>response.end()</code>, the property is nulled. The <code>socket</code> may also be accessed
-via <code>response.connection</code>.</p>
+<code>response.end()</code>, the property is nulled.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  <span class="hljs-keyword">const</span> ip = res.socket.remoteAddress;
-  <span class="hljs-keyword">const</span> port = res.socket.remotePort;
-  res.end(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
-}).listen(<span class="hljs-number">3000</span>);</code></pre>
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  <span class="hljs-keyword">const</span> ip = res.<span class="hljs-property">socket</span>.<span class="hljs-property">remoteAddress</span>;
+  <span class="hljs-keyword">const</span> port = res.<span class="hljs-property">socket</span>.<span class="hljs-property">remotePort</span>;
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);</code></pre>
 <p>This property is guaranteed to be an instance of the <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specified a socket
 type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3><code>response.statusCode</code><span><a class="mark" href="#http_response_statuscode" id="http_response_statuscode">#</a></span></h3>
+<h4><code>response.statusCode</code><span><a class="mark" href="#http_response_statuscode" id="http_response_statuscode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
@@ -36200,10 +39041,10 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 <p>When using implicit headers (not calling <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> explicitly),
 this property controls the status code that will be sent to the client when
 the headers get flushed.</p>
-<pre><code class="language-js">response.statusCode = <span class="hljs-number">404</span>;</code></pre>
+<pre><code class="language-js">response.<span class="hljs-property">statusCode</span> = <span class="hljs-number">404</span>;</code></pre>
 <p>After response header was sent to the client, this property indicates the
 status code which was sent out.</p>
-<h3><code>response.statusMessage</code><span><a class="mark" href="#http_response_statusmessage" id="http_response_statusmessage">#</a></span></h3>
+<h4><code>response.statusMessage</code><span><a class="mark" href="#http_response_statusmessage" id="http_response_statusmessage">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -36214,15 +39055,15 @@ status code which was sent out.</p>
 this property controls the status message that will be sent to the client when
 the headers get flushed. If this is left as <code>undefined</code> then the standard
 message for the status code will be used.</p>
-<pre><code class="language-js">response.statusMessage = <span class="hljs-string">'Not found'</span>;</code></pre>
+<pre><code class="language-js">response.<span class="hljs-property">statusMessage</span> = <span class="hljs-string">'Not found'</span>;</code></pre>
 <p>After response header was sent to the client, this property indicates the
 status message which was sent out.</p>
-<h3><code>response.uncork()</code><span><a class="mark" href="#http_response_uncork" id="http_response_uncork">#</a></span></h3>
+<h4><code>response.uncork()</code><span><a class="mark" href="#http_response_uncork" id="http_response_uncork">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <p>See <a href="#stream_writable_uncork"><code>writable.uncork()</code></a>.</p>
-<h3><code>response.writableEnded</code><span><a class="mark" href="#http_response_writableended" id="http_response_writableended">#</a></span></h3>
+<h4><code>response.writableEnded</code><span><a class="mark" href="#http_response_writableended" id="http_response_writableended">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -36232,7 +39073,7 @@ status message which was sent out.</p>
 <p>Is <code>true</code> after <a href="#http_response_end_data_encoding_callback"><code>response.end()</code></a> has been called. This property
 does not indicate whether the data has been flushed, for this use
 <a href="#http_response_writablefinished"><code>response.writableFinished</code></a> instead.</p>
-<h3><code>response.writableFinished</code><span><a class="mark" href="#http_response_writablefinished" id="http_response_writablefinished">#</a></span></h3>
+<h4><code>response.writableFinished</code><span><a class="mark" href="#http_response_writablefinished" id="http_response_writablefinished">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
@@ -36241,7 +39082,7 @@ does not indicate whether the data has been flushed, for this use
 </ul>
 <p>Is <code>true</code> if all data has been flushed to the underlying system, immediately
 before the <a href="#http_event_finish"><code>'finish'</code></a> event is emitted.</p>
-<h3><code>response.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_response_write_chunk_encoding_callback" id="http_response_write_chunk_encoding_callback">#</a></span></h3>
+<h4><code>response.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_response_write_chunk_encoding_callback" id="http_response_write_chunk_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.29</span>
 </div>
@@ -36271,19 +39112,21 @@ first chunk of the body.</p>
 <p>Returns <code>true</code> if the entire data was flushed successfully to the kernel
 buffer. Returns <code>false</code> if all or part of the data was queued in user memory.
 <code>'drain'</code> will be emitted when the buffer is free again.</p>
-<h3><code>response.writeContinue()</code><span><a class="mark" href="#http_response_writecontinue" id="http_response_writecontinue">#</a></span></h3>
+<h4><code>response.writeContinue()</code><span><a class="mark" href="#http_response_writecontinue" id="http_response_writecontinue">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
 <p>Sends a HTTP/1.1 100 Continue message to the client, indicating that
 the request body should be sent. See the <a href="#http_event_checkcontinue"><code>'checkContinue'</code></a> event on
 <code>Server</code>.</p>
-<h3><code>response.writeHead(statusCode[, statusMessage][, headers])</code><span><a class="mark" href="#http_response_writehead_statuscode_statusmessage_headers" id="http_response_writehead_statuscode_statusmessage_headers">#</a></span></h3>
+<h4><code>response.writeHead(statusCode[, statusMessage][, headers])</code><span><a class="mark" href="#http_response_writehead_statuscode_statusmessage_headers" id="http_response_writehead_statuscode_statusmessage_headers">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.10.0</td>
+<tr><td>v14.14.0</td>
+<td><p>Allow passing headers as an array.</p></td></tr>
+<tr><td>v11.10.0, v10.17.0</td>
 <td><p>Return <code>this</code> from <code>writeHead()</code> to allow chaining with <code>end()</code>.</p></td></tr>
 <tr><td>v5.11.0, v4.4.5</td>
 <td><p>A <code>RangeError</code> is thrown if <code>statusCode</code> is not a number in the range <code>[100, 999]</code>.</p></td></tr>
@@ -36295,21 +39138,25 @@ the request body should be sent. See the <a href="#http_event_checkcontinue"><co
 <ul>
 <li><code>statusCode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 <li><code>statusMessage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>headers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>headers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
 <li>Returns: <a href="#http_class_http_serverresponse" class="type">&#x3C;http.ServerResponse></a></li>
 </ul>
 <p>Sends a response header to the request. The status code is a 3-digit HTTP
 status code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.
 Optionally one can give a human-readable <code>statusMessage</code> as the second
 argument.</p>
+<p><code>headers</code> may be an <code>Array</code> where the keys and values are in the same list.
+It is <em>not</em> a list of tuples. So, the even-numbered offsets are key values,
+and the odd-numbered offsets are the associated values. The array is in the same
+format as <code>request.rawHeaders</code>.</p>
 <p>Returns a reference to the <code>ServerResponse</code>, so that calls can be chained.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> body = <span class="hljs-string">'hello world'</span>;
 response
-  .writeHead(<span class="hljs-number">200</span>, {
-    <span class="hljs-string">'Content-Length'</span>: Buffer.byteLength(body),
+  .<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, {
+    <span class="hljs-string">'Content-Length'</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(body),
     <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span>
   })
-  .end(body);</code></pre>
+  .<span class="hljs-title function_">end</span>(body);</code></pre>
 <p>This method must only be called once on a message and it must
 be called before <a href="#http_response_end_data_encoding_callback"><code>response.end()</code></a> is called.</p>
 <p>If <a href="#http_response_write_chunk_encoding_callback"><code>response.write()</code></a> or <a href="#http_response_end_data_encoding_callback"><code>response.end()</code></a> are called before calling
@@ -36324,11 +39171,11 @@ will not yield the expected result. If progressive population of headers is
 desired with potential future retrieval and modification, use
 <a href="#http_response_setheader_name_value"><code>response.setHeader()</code></a> instead.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Returns content-type = text/plain</span>
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
 <p><code>Content-Length</code> is given in bytes, not characters. Use
 <a href="#buffer_static_method_buffer_bytelength_string_encoding"><code>Buffer.byteLength()</code></a> to determine the length of the body in bytes. Node.js
@@ -36336,18 +39183,18 @@ does not check whether <code>Content-Length</code> and the length of the body wh
 been transmitted are equal or not.</p>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
-<h3><code>response.writeProcessing()</code><span><a class="mark" href="#http_response_writeprocessing" id="http_response_writeprocessing">#</a></span></h3>
+<h4><code>response.writeProcessing()</code><span><a class="mark" href="#http_response_writeprocessing" id="http_response_writeprocessing">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 <p>Sends a HTTP/1.1 102 Processing message to the client, indicating that
 the request body should be sent.</p>
-<h2>Class: <code>http.IncomingMessage</code><span><a class="mark" href="#http_class_http_incomingmessage" id="http_class_http_incomingmessage">#</a></span></h2>
+</section><section><h3>Class: <code>http.IncomingMessage</code><span><a class="mark" href="#http_class_http_incomingmessage" id="http_class_http_incomingmessage">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.1.0, v12.16.0</td>
 <td><p>The <code>readableHighWaterMark</code> value mirrors that of the socket.</p></td></tr>
 <tr><td>v0.1.17</td>
 <td><p><span>Added in: v0.1.17</span></p></td></tr>
@@ -36361,17 +39208,17 @@ the request body should be sent.</p>
 <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a> and passed as the first argument to the <a href="#http_event_request"><code>'request'</code></a>
 and <a href="#http_event_response"><code>'response'</code></a> event respectively. It may be used to access response
 status, headers and data.</p>
-<h3>Event: <code>'aborted'</code><span><a class="mark" href="#http_event_aborted" id="http_event_aborted">#</a></span></h3>
+<h4>Event: <code>'aborted'</code><span><a class="mark" href="#http_event_aborted" id="http_event_aborted">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.8</span>
 </div>
 <p>Emitted when the request has been aborted.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#http_event_close_2" id="http_event_close_2">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#http_event_close_2" id="http_event_close_2">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.2</span>
 </div>
 <p>Indicates that the underlying connection was closed.</p>
-<h3><code>message.aborted</code><span><a class="mark" href="#http_message_aborted" id="http_message_aborted">#</a></span></h3>
+<h4><code>message.aborted</code><span><a class="mark" href="#http_message_aborted" id="http_message_aborted">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.1.0</span>
 </div>
@@ -36380,7 +39227,7 @@ status, headers and data.</p>
 </ul>
 <p>The <code>message.aborted</code> property will be <code>true</code> if the request has
 been aborted.</p>
-<h3><code>message.complete</code><span><a class="mark" href="#http_message_complete" id="http_message_complete">#</a></span></h3>
+<h4><code>message.complete</code><span><a class="mark" href="#http_message_complete" id="http_message_complete">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -36391,24 +39238,24 @@ been aborted.</p>
 been received and successfully parsed.</p>
 <p>This property is particularly useful as a means of determining if a client or
 server fully transmitted a message before a connection was terminated:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> req = http.request({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>({
   <span class="hljs-attr">host</span>: <span class="hljs-string">'127.0.0.1'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">8080</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'POST'</span>
 }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  res.resume();
-  res.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">if</span> (!res.complete)
-      <span class="hljs-built_in">console</span>.error(
+  res.<span class="hljs-title function_">resume</span>();
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-keyword">if</span> (!res.<span class="hljs-property">complete</span>)
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(
         <span class="hljs-string">'The connection was terminated while the message was still being sent'</span>);
   });
 });</code></pre>
-<h3><code>message.destroy([error])</code><span><a class="mark" href="#http_message_destroy_error" id="http_message_destroy_error">#</a></span></h3>
+<h4><code>message.destroy([error])</code><span><a class="mark" href="#http_message_destroy_error" id="http_message_destroy_error">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>The function returns <code>this</code> for consistency with other Readable streams.</p></td></tr>
 <tr><td>v0.3.0</td>
 <td><p><span>Added in: v0.3.0</span></p></td></tr>
@@ -36422,7 +39269,7 @@ server fully transmitted a message before a connection was terminated:</p>
 <p>Calls <code>destroy()</code> on the socket that received the <code>IncomingMessage</code>. If <code>error</code>
 is provided, an <code>'error'</code> event is emitted on the socket and <code>error</code> is passed
 as an argument to any listeners on the event.</p>
-<h3><code>message.headers</code><span><a class="mark" href="#http_message_headers" id="http_message_headers">#</a></span></h3>
+<h4><code>message.headers</code><span><a class="mark" href="#http_message_headers" id="http_message_headers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.5</span>
 </div>
@@ -36436,7 +39283,7 @@ as an argument to any listeners on the event.</p>
 <span class="hljs-comment">// { 'user-agent': 'curl/7.22.0',</span>
 <span class="hljs-comment">//   host: '127.0.0.1:8000',</span>
 <span class="hljs-comment">//   accept: '*/*' }</span>
-<span class="hljs-built_in">console</span>.log(request.headers);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(request.<span class="hljs-property">headers</span>);</code></pre>
 <p>Duplicates in raw headers are handled in the following ways, depending on the
 header name:</p>
 <ul>
@@ -36448,7 +39295,7 @@ header name:</p>
 <li>For duplicate <code>cookie</code> headers, the values are joined together with '; '.</li>
 <li>For all other headers, the values are joined together with ', '.</li>
 </ul>
-<h3><code>message.httpVersion</code><span><a class="mark" href="#http_message_httpversion" id="http_message_httpversion">#</a></span></h3>
+<h4><code>message.httpVersion</code><span><a class="mark" href="#http_message_httpversion" id="http_message_httpversion">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.1</span>
 </div>
@@ -36460,7 +39307,7 @@ client response, the HTTP version of the connected-to server.
 Probably either <code>'1.1'</code> or <code>'1.0'</code>.</p>
 <p>Also <code>message.httpVersionMajor</code> is the first integer and
 <code>message.httpVersionMinor</code> is the second.</p>
-<h3><code>message.method</code><span><a class="mark" href="#http_message_method" id="http_message_method">#</a></span></h3>
+<h4><code>message.method</code><span><a class="mark" href="#http_message_method" id="http_message_method">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.1</span>
 </div>
@@ -36469,7 +39316,7 @@ Probably either <code>'1.1'</code> or <code>'1.0'</code>.</p>
 </ul>
 <p><strong>Only valid for request obtained from <a href="#http_class_http_server"><code>http.Server</code></a>.</strong></p>
 <p>The request method as a string. Read only. Examples: <code>'GET'</code>, <code>'DELETE'</code>.</p>
-<h3><code>message.rawHeaders</code><span><a class="mark" href="#http_message_rawheaders" id="http_message_rawheaders">#</a></span></h3>
+<h4><code>message.rawHeaders</code><span><a class="mark" href="#http_message_rawheaders" id="http_message_rawheaders">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.6</span>
 </div>
@@ -36491,8 +39338,8 @@ odd-numbered offsets are the associated values.</p>
 <span class="hljs-comment">//   '127.0.0.1:8000',</span>
 <span class="hljs-comment">//   'ACCEPT',</span>
 <span class="hljs-comment">//   '*/*' ]</span>
-<span class="hljs-built_in">console</span>.log(request.rawHeaders);</code></pre>
-<h3><code>message.rawTrailers</code><span><a class="mark" href="#http_message_rawtrailers" id="http_message_rawtrailers">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(request.<span class="hljs-property">rawHeaders</span>);</code></pre>
+<h4><code>message.rawTrailers</code><span><a class="mark" href="#http_message_rawtrailers" id="http_message_rawtrailers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.6</span>
 </div>
@@ -36501,7 +39348,7 @@ odd-numbered offsets are the associated values.</p>
 </ul>
 <p>The raw request/response trailer keys and values exactly as they were
 received. Only populated at the <code>'end'</code> event.</p>
-<h3><code>message.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http_message_settimeout_msecs_callback" id="http_message_settimeout_msecs_callback">#</a></span></h3>
+<h4><code>message.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http_message_settimeout_msecs_callback" id="http_message_settimeout_msecs_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -36510,8 +39357,8 @@ received. Only populated at the <code>'end'</code> event.</p>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li>Returns: <a href="#http_class_http_incomingmessage" class="type">&#x3C;http.IncomingMessage></a></li>
 </ul>
-<p>Calls <code>message.connection.setTimeout(msecs, callback)</code>.</p>
-<h3><code>message.socket</code><span><a class="mark" href="#http_message_socket" id="http_message_socket">#</a></span></h3>
+<p>Calls <code>message.socket.setTimeout(msecs, callback)</code>.</p>
+<h4><code>message.socket</code><span><a class="mark" href="#http_message_socket" id="http_message_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -36524,7 +39371,7 @@ client's authentication details.</p>
 <p>This property is guaranteed to be an instance of the <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specified a socket
 type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3><code>message.statusCode</code><span><a class="mark" href="#http_message_statuscode" id="http_message_statuscode">#</a></span></h3>
+<h4><code>message.statusCode</code><span><a class="mark" href="#http_message_statuscode" id="http_message_statuscode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.1</span>
 </div>
@@ -36533,7 +39380,7 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 </ul>
 <p><strong>Only valid for response obtained from <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>.</strong></p>
 <p>The 3-digit HTTP response status code. E.G. <code>404</code>.</p>
-<h3><code>message.statusMessage</code><span><a class="mark" href="#http_message_statusmessage" id="http_message_statusmessage">#</a></span></h3>
+<h4><code>message.statusMessage</code><span><a class="mark" href="#http_message_statusmessage" id="http_message_statusmessage">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.10</span>
 </div>
@@ -36542,7 +39389,7 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 </ul>
 <p><strong>Only valid for response obtained from <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>.</strong></p>
 <p>The HTTP response status message (reason phrase). E.G. <code>OK</code> or <code>Internal Server Error</code>.</p>
-<h3><code>message.trailers</code><span><a class="mark" href="#http_message_trailers" id="http_message_trailers">#</a></span></h3>
+<h4><code>message.trailers</code><span><a class="mark" href="#http_message_trailers" id="http_message_trailers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -36550,7 +39397,7 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>The request/response trailers object. Only populated at the <code>'end'</code> event.</p>
-<h3><code>message.url</code><span><a class="mark" href="#http_message_url" id="http_message_url">#</a></span></h3>
+<h4><code>message.url</code><span><a class="mark" href="#http_message_url" id="http_message_url">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -36560,14 +39407,14 @@ type other than <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></
 <p><strong>Only valid for request obtained from <a href="#http_class_http_server"><code>http.Server</code></a>.</strong></p>
 <p>Request URL string. This contains only the URL that is present in the actual
 HTTP request. Take the following request:</p>
-<pre><code class="language-http"><span class="hljs-keyword">GET</span> <span class="hljs-string">/status?name=ryan</span> HTTP/1.1
-<span class="hljs-attribute">Accept</span>: text/plain</code></pre>
+<pre><code class="language-http"><span class="hljs-keyword">GET</span> <span class="hljs-string">/status?name=ryan</span> <span class="hljs-meta">HTTP/1.1</span>
+<span class="hljs-attribute">Accept</span><span class="hljs-punctuation">: </span>text/plain</code></pre>
 <p>To parse the URL into its parts:</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> URL(request.url, <span class="hljs-string">`http://<span class="hljs-subst">${request.headers.host}</span>`</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(request.<span class="hljs-property">url</span>, <span class="hljs-string">`http://<span class="hljs-subst">${request.headers.host}</span>`</span>);</code></pre>
 <p>When <code>request.url</code> is <code>'/status?name=ryan'</code> and
 <code>request.headers.host</code> is <code>'localhost:3000'</code>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> new URL(request.url, `http://<span class="hljs-variable">${request.headers.host}</span>`)</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">new URL(request.url, `http://<span class="hljs-variable">${request.headers.host}</span>`)</span>
 URL {
   href: 'http://localhost:3000/status?name=ryan',
   origin: 'http://localhost:3000',
@@ -36582,7 +39429,323 @@ URL {
   searchParams: URLSearchParams { 'name' => 'ryan' },
   hash: ''
 }</code></pre>
-<h2><code>http.METHODS</code><span><a class="mark" href="#http_http_methods" id="http_http_methods">#</a></span></h2>
+</section><section><h3>Class: <code>http.OutgoingMessage</code><span><a class="mark" href="#http_class_http_outgoingmessage" id="http_class_http_outgoingmessage">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v0.1.17</span>
+</div>
+<ul>
+<li>Extends: <a href="#stream_stream" class="type">&#x3C;Stream></a></li>
+</ul>
+<p>This class serves as the parent class of <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>
+and <a href="#http_class_http_serverresponse"><code>http.ServerResponse</code></a>. It is an abstract of outgoing message from
+the perspective of the participants of HTTP transaction.</p>
+<h4>Event: <code>drain</code><span><a class="mark" href="#http_event_drain" id="http_event_drain">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.6</span>
+</div>
+<p>Emitted when the buffer of the message is free again.</p>
+<h4>Event: <code>finish</code><span><a class="mark" href="#http_event_finish_1" id="http_event_finish_1">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.17</span>
+</div>
+<p>Emitted when the transmission is finished successfully.</p>
+<h4>Event: <code>prefinish</code><span><a class="mark" href="#http_event_prefinish" id="http_event_prefinish">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.11.6</span>
+</div>
+<p>Emitted when <code>outgoingMessage.end</code> was called.
+When the event is emitted, all data has been processed but not necessarily
+completely flushed.</p>
+<h4><code>outgoingMessage.addTrailers(headers)</code><span><a class="mark" href="#http_outgoingmessage_addtrailers_headers" id="http_outgoingmessage_addtrailers_headers">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span>
+</div>
+<ul>
+<li><code>headers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+</ul>
+<p>Adds HTTP trailers (headers but at the end of the message) to the message.</p>
+<p>Trailers are <strong>only</strong> be emitted if the message is chunked encoded. If not,
+the trailer will be silently discarded.</p>
+<p>HTTP requires the  <code>Trailer</code> header to be sent to emit trailers,
+with a list of header fields in its value, e.g.</p>
+<pre><code class="language-js">message.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span>,
+                         <span class="hljs-string">'Trailer'</span>: <span class="hljs-string">'Content-MD5'</span> });
+message.<span class="hljs-title function_">write</span>(fileData);
+message.<span class="hljs-title function_">addTrailers</span>({ <span class="hljs-string">'Content-MD5'</span>: <span class="hljs-string">'7895bf4b8828b55ceaf47747b4bca667'</span> });
+message.<span class="hljs-title function_">end</span>();</code></pre>
+<p>Attempting to set a header field name or value that contains invalid characters
+will result in a <code>TypeError</code> being thrown.</p>
+<h4><code>outgoingMessage.connection</code><span><a class="mark" href="#http_outgoingmessage_connection" id="http_outgoingmessage_connection">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span><span>Deprecated since: v14.17.1</span>
+</div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#http_outgoingmessage_socket"><code>outgoingMessage.socket</code></a> instead.</div><p></p>
+<p>Aliases of <code>outgoingMessage.socket</code></p>
+<h4><code>outgoingMessage.cork()</code><span><a class="mark" href="#http_outgoingmessage_cork" id="http_outgoingmessage_cork">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.0.0</span>
+</div>
+<p>See <a href="#stream_writable_cork"><code>writable.cork()</code></a>.</p>
+<h4><code>outgoingMessage.destroy([error])</code><span><a class="mark" href="#http_outgoingmessage_destroy_error" id="http_outgoingmessage_destroy_error">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span>
+</div>
+<ul>
+<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Optional, an error to emit with <code>error</code> event</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Destroys the message. Once a socket is associated with the message
+and is connected, that socket will be destroyed as well.</p>
+<h4><code>outgoingMessage.end(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_outgoingmessage_end_chunk_encoding_callback" id="http_outgoingmessage_end_chunk_encoding_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v0.11.6</td>
+<td><p>add <code>callback</code> argument.</p></td></tr>
+<tr><td>v0.1.90</td>
+<td><p><span>Added in: v0.1.90</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>chunk</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Optional, <strong>Default</strong>: <code>utf-8</code></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Finishes the outgoing message. If any parts of the body are unsent, it will
+flush them to the underlying system. If the message is chunked, it will
+send the terminating chunk <code>0\r\n\r\n</code>, and send the trailer (if any).</p>
+<p>If <code>chunk</code> is specified, it is equivalent to call
+<code>outgoingMessage.write(chunk, encoding)</code>, followed by
+<code>outgoingMessage.end(callback)</code>.</p>
+<p>If <code>callback</code> is provided, it will be called when the message is finished.
+(equivalent to the callback to event <code>finish</code>)</p>
+<h4><code>outgoingMessage.flushHeaders()</code><span><a class="mark" href="#http_outgoingmessage_flushheaders" id="http_outgoingmessage_flushheaders">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v1.6.0</span>
+</div>
+<p>Compulsorily flushes the message headers</p>
+<p>For efficiency reason, Node.js normally buffers the message headers
+until <code>outgoingMessage.end()</code> is called or the first chunk of message data
+is written. It then tries to pack the headers and data into a single TCP
+packet.</p>
+<p>It is usually desired (it saves a TCP round-trip), but not when the first
+data is not sent until possibly much later. <code>outgoingMessage.flushHeaders()</code>
+bypasses the optimization and kickstarts the request.</p>
+<h4><code>outgoingMessage.getHeader(name)</code><span><a class="mark" href="#http_outgoingmessage_getheader_name" id="http_outgoingmessage_getheader_name">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Name of header</li>
+<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
+</ul>
+<p>Gets the value of HTTP header with the given name. If such a name doesn't
+exist in message, it will be <code>undefined</code>.</p>
+<h4><code>outgoingMessage.getHeaderNames()</code><span><a class="mark" href="#http_outgoingmessage_getheadernames" id="http_outgoingmessage_getheadernames">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v8.0.0</span>
+</div>
+<ul>
+<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>Returns an array of names of headers of the outgoing outgoingMessage. All
+names are lowercase.</p>
+<h4><code>outgoingMessage.getHeaders()</code><span><a class="mark" href="#http_outgoingmessage_getheaders" id="http_outgoingmessage_getheaders">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v8.0.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+</ul>
+<p>Returns a shallow copy of the current outgoing headers. Since a shallow
+copy is used, array values may be mutated without additional calls to
+various header-related HTTP module methods. The keys of the returned
+object are the header names and the values are the respective header
+values. All header names are lowercase.</p>
+<p>The object returned by the <code>outgoingMessage.getHeaders()</code> method does
+not prototypically inherit from the JavaScript Object. This means that
+typical Object methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>,
+and others are not defined and will not work.</p>
+<pre><code class="language-js">outgoingMessage.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+outgoingMessage.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+
+<span class="hljs-keyword">const</span> headers = outgoingMessage.<span class="hljs-title function_">getHeaders</span>();
+<span class="hljs-comment">// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }</span></code></pre>
+<h4><code>outgoingMessage.hasHeader(name)</code><span><a class="mark" href="#http_outgoingmessage_hasheader_name" id="http_outgoingmessage_hasheader_name">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v8.0.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the
+outgoing headers. The header name is case-insensitive.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = outgoingMessage.<span class="hljs-title function_">hasHeader</span>(<span class="hljs-string">'content-type'</span>);</code></pre>
+<h4><code>outgoingMessage.headersSent</code><span><a class="mark" href="#http_outgoingmessage_headerssent" id="http_outgoingmessage_headerssent">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.9.3</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Read-only. <code>true</code> if the headers were sent, otherwise <code>false</code>.</p>
+<h4><code>outgoingMessage.pipe()</code><span><a class="mark" href="#http_outgoingmessage_pipe" id="http_outgoingmessage_pipe">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v9.0.0</span>
+</div>
+<p>Overrides the pipe method of legacy <code>Stream</code> which is the parent class of
+<code>http.outgoingMessage</code>.</p>
+<p>Since <code>OutgoingMessage</code> should be a write-only stream,
+call this function will throw an <code>Error</code>. Thus, it disabled the pipe method
+it inherits from <code>Stream</code>.</p>
+<p>The User should not call this function directly.</p>
+<h4><code>outgoingMessage.removeHeader()</code><span><a class="mark" href="#http_outgoingmessage_removeheader" id="http_outgoingmessage_removeheader">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.0</span>
+</div>
+<p>Removes a header that is queued for implicit sending.</p>
+<pre><code class="language-js">outgoingMessage.<span class="hljs-title function_">removeHeader</span>(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
+<h4><code>outgoingMessage.setHeader(name, value)</code><span><a class="mark" href="#http_outgoingmessage_setheader_name_value" id="http_outgoingmessage_setheader_name_value">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Header name</li>
+<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Header value</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Sets a single header value for the header object.</p>
+<h4><code>outgoingMessage.setTimeout(msesc[, callback])</code><span><a class="mark" href="#http_outgoingmessage_settimeout_msesc_callback" id="http_outgoingmessage_settimeout_msesc_callback">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.9.12</span>
+</div>
+<ul>
+<li><code>msesc</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional function to be called when a timeout</li>
+</ul>
+<p>occurs, Same as binding to the <code>timeout</code> event.</p>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Once a socket is associated with the message and is connected,
+<a href="#net_socket_settimeout_timeout_callback"><code>socket.setTimeout()</code></a> will be called with <code>msecs</code> as the first parameter.</p>
+<h4><code>outgoingMessage.socket</code><span><a class="mark" href="#http_outgoingmessage_socket" id="http_outgoingmessage_socket">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span>
+</div>
+<ul>
+<li><a href="#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a></li>
+</ul>
+<p>Reference to the underlying socket. Usually, users will not want to access
+this property.</p>
+<p>After calling <code>outgoingMessage.end()</code>, this property will be nulled.</p>
+<h4><code>outgoingMessage.uncork()</code><span><a class="mark" href="#http_outgoingmessage_uncork" id="http_outgoingmessage_uncork">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.0.0</span>
+</div>
+<p>See <a href="#stream_writable_uncork"><code>writable.uncork()</code></a></p>
+<h4><code>outgoingMessage.writableCorked</code><span><a class="mark" href="#http_outgoingmessage_writablecorked" id="http_outgoingmessage_writablecorked">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>This <code>outgoingMessage.writableCorked</code> will return the time how many
+<code>outgoingMessage.cork()</code> have been called.</p>
+<h4><code>outgoingMessage.writableEnded</code><span><a class="mark" href="#http_outgoingmessage_writableended" id="http_outgoingmessage_writableended">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Readonly, <code>true</code> if <code>outgoingMessage.end()</code> has been called. Noted that
+this property does not reflect whether the data has been flush. For that
+purpose, use <code>message.writableFinished</code> instead.</p>
+<h4><code>outgoingMessage.writableFinished</code><span><a class="mark" href="#http_outgoingmessage_writablefinished" id="http_outgoingmessage_writablefinished">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Readonly. <code>true</code> if all data has been flushed to the underlying system.</p>
+<h4><code>outgoingMessage.writableHighWaterMark</code><span><a class="mark" href="#http_outgoingmessage_writablehighwatermark" id="http_outgoingmessage_writablehighwatermark">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>This <code>outgoingMessage.writableHighWaterMark</code> will be the <code>highWaterMark</code> of
+underlying socket if socket exists. Else, it would be the default
+<code>highWaterMark</code>.</p>
+<p><code>highWaterMark</code> is the maximum amount of data that can be potentially
+buffered by the socket.</p>
+<h4><code>outgoingMessage.writableLength</code><span><a class="mark" href="#http_outgoingmessage_writablelength" id="http_outgoingmessage_writablelength">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>Readonly, This <code>outgoingMessage.writableLength</code> contains the number of
+bytes (or objects) in the buffer ready to send.</p>
+<h4><code>outgoingMessage.writableObjectMode</code><span><a class="mark" href="#http_outgoingmessage_writableobjectmode" id="http_outgoingmessage_writableobjectmode">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Readonly, always returns <code>false</code>.</p>
+<h4><code>outgoingMessage.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_outgoingmessage_write_chunk_encoding_callback" id="http_outgoingmessage_write_chunk_encoding_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v0.11.6</td>
+<td><p>add <code>callback</code> argument.</p></td></tr>
+<tr><td>v0.1.29</td>
+<td><p><span>Added in: v0.1.29</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>chunk</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default</strong>: <code>utf-8</code></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>If this method is called and the header is not sent, it will call
+<code>this._implicitHeader</code> to flush implicit header.
+If the message should not have a body (indicated by <code>this._hasBody</code>),
+the call is ignored and <code>chunk</code> will not be sent. It could be useful
+when handling a particular message which must not include a body.
+e.g. response to <code>HEAD</code> request, <code>204</code> and <code>304</code> response.</p>
+<p><code>chunk</code> can be a string or a buffer. When <code>chunk</code> is a string, the
+<code>encoding</code> parameter specifies how to encode <code>chunk</code> into a byte stream.
+<code>callback</code> will be called when the <code>chunk</code> is flushed.</p>
+<p>If the message is transferred in chucked encoding
+(indicated by <code>this.chunkedEncoding</code>), <code>chunk</code> will be flushed as
+one chunk among a stream of chunks. Otherwise, it will be flushed as the
+body of message.</p>
+<p>This method handles the raw body of the HTTP message and has nothing to do
+with higher-level multi-part body encodings that may be used.</p>
+<p>If it is the first call to this method of a message, it will send the
+buffered header first, then flush the <code>chunk</code> as described above.</p>
+<p>The second and successive calls to this method will assume the data
+will be streamed and send the new data separately. It means that the response
+is buffered up to the first chunk of the body.</p>
+<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel
+buffer. Returns <code>false</code> if all or part of the data was queued in the user
+memory. Event <code>drain</code> will be emitted when the buffer is free again.</p>
+</section><section><h3><code>http.METHODS</code><span><a class="mark" href="#http_http_methods" id="http_http_methods">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -36590,7 +39753,7 @@ URL {
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
 <p>A list of the HTTP methods that are supported by the parser.</p>
-<h2><code>http.STATUS_CODES</code><span><a class="mark" href="#http_http_status_codes" id="http_http_status_codes">#</a></span></h2>
+</section><section><h3><code>http.STATUS_CODES</code><span><a class="mark" href="#http_http_status_codes" id="http_http_status_codes">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.22</span>
 </div>
@@ -36599,12 +39762,14 @@ URL {
 </ul>
 <p>A collection of all the standard HTTP response status codes, and the
 short description of each. For example, <code>http.STATUS_CODES[404] === 'Not Found'</code>.</p>
-<h2><code>http.createServer([options][, requestListener])</code><span><a class="mark" href="#http_http_createserver_options_requestlistener" id="http_http_createserver_options_requestlistener">#</a></span></h2>
+</section><section><h3><code>http.createServer([options][, requestListener])</code><span><a class="mark" href="#http_http_createserver_options_requestlistener" id="http_http_createserver_options_requestlistener">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.15.0</td>
+<tr><td>v13.3.0</td>
+<td><p>The <code>maxHeaderSize</code> option is supported now.</p></td></tr>
+<tr><td>v13.8.0, v12.15.0, v10.19.0</td>
 <td><p>The <code>insecureHTTPParser</code> option is supported now.</p></td></tr>
 <tr><td>v9.6.0, v8.12.0</td>
 <td><p>The <code>options</code> argument is supported now.</p></td></tr>
@@ -36627,6 +39792,10 @@ to be used. Useful for extending the original <code>ServerResponse</code>. <stro
 invalid HTTP headers when <code>true</code>. Using the insecure parser should be
 avoided. See <a href="#cli_insecure_http_parser"><code>--insecure-http-parser</code></a> for more information.
 <strong>Default:</strong> <code>false</code></li>
+<li><code>maxHeaderSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Optionally overrides the value of
+<a href="#cli_max_http_header_size_size"><code>--max-http-header-size</code></a> for requests received by this server, i.e.
+the maximum length of request headers in bytes.
+<strong>Default:</strong> 16384 (16KB).</li>
 </ul>
 </li>
 <li>
@@ -36639,8 +39808,33 @@ avoided. See <a href="#cli_insecure_http_parser"><code>--insecure-http-parser</c
 <p>Returns a new instance of <a href="#http_class_http_server"><code>http.Server</code></a>.</p>
 <p>The <code>requestListener</code> is a function which is automatically
 added to the <a href="#http_event_request"><code>'request'</code></a> event.</p>
-<h2><code>http.get(options[, callback])</code><span><a class="mark" href="#http_http_get_options_callback" id="http_http_get_options_callback">#</a></span></h2>
-<h2><code>http.get(url[, options][, callback])</code><span><a class="mark" href="#http_http_get_url_options_callback" id="http_http_get_url_options_callback">#</a></span></h2>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><pre><code class="language-js cjs"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-comment">// Create a local server to receive data from</span>
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
+    <span class="hljs-attr">data</span>: <span class="hljs-string">'Hello World!'</span>
+  }));
+});
+
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre><code class="language-js cjs"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-comment">// Create a local server to receive data from</span>
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>();
+
+<span class="hljs-comment">// Listen to the request event</span>
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'request'</span>, <span class="hljs-function">(<span class="hljs-params">request, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
+    <span class="hljs-attr">data</span>: <span class="hljs-string">'Hello World!'</span>
+  }));
+});
+
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
+</section><section><h3><code>http.get(options[, callback])</code><span><a class="mark" href="#http_http_get_options_callback" id="http_http_get_options_callback">#</a></span></h3>
+</section><section><h3><code>http.get(url[, options][, callback])</code><span><a class="mark" href="#http_http_get_url_options_callback" id="http_http_get_url_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -36670,42 +39864,52 @@ data for reasons stated in <a href="#http_class_http_clientrequest"><code>http.C
 <p>The <code>callback</code> is invoked with a single argument that is an instance of
 <a href="#http_class_http_incomingmessage"><code>http.IncomingMessage</code></a>.</p>
 <p>JSON fetching example:</p>
-<pre><code class="language-js">http.get(<span class="hljs-string">'http://nodejs.org/dist/index.json'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<pre><code class="language-js">http.<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:8000/'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-keyword">const</span> { statusCode } = res;
-  <span class="hljs-keyword">const</span> contentType = res.headers[<span class="hljs-string">'content-type'</span>];
+  <span class="hljs-keyword">const</span> contentType = res.<span class="hljs-property">headers</span>[<span class="hljs-string">'content-type'</span>];
 
   <span class="hljs-keyword">let</span> error;
   <span class="hljs-comment">// Any 2xx status code signals a successful response but</span>
   <span class="hljs-comment">// here we're only checking for 200.</span>
   <span class="hljs-keyword">if</span> (statusCode !== <span class="hljs-number">200</span>) {
-    error = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Request Failed.\n'</span> +
+    error = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Request Failed.\n'</span> +
                       <span class="hljs-string">`Status Code: <span class="hljs-subst">${statusCode}</span>`</span>);
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!<span class="hljs-regexp">/^application\/json/</span>.test(contentType)) {
-    error = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Invalid content-type.\n'</span> +
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!<span class="hljs-regexp">/^application\/json/</span>.<span class="hljs-title function_">test</span>(contentType)) {
+    error = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Invalid content-type.\n'</span> +
                       <span class="hljs-string">`Expected application/json but received <span class="hljs-subst">${contentType}</span>`</span>);
   }
   <span class="hljs-keyword">if</span> (error) {
-    <span class="hljs-built_in">console</span>.error(error.message);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(error.<span class="hljs-property">message</span>);
     <span class="hljs-comment">// Consume response data to free up memory</span>
-    res.resume();
+    res.<span class="hljs-title function_">resume</span>();
     <span class="hljs-keyword">return</span>;
   }
 
-  res.setEncoding(<span class="hljs-string">'utf8'</span>);
+  res.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
   <span class="hljs-keyword">let</span> rawData = <span class="hljs-string">''</span>;
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { rawData += chunk; });
-  res.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { rawData += chunk; });
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-keyword">try</span> {
-      <span class="hljs-keyword">const</span> parsedData = <span class="hljs-built_in">JSON</span>.parse(rawData);
-      <span class="hljs-built_in">console</span>.log(parsedData);
+      <span class="hljs-keyword">const</span> parsedData = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(rawData);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(parsedData);
     } <span class="hljs-keyword">catch</span> (e) {
-      <span class="hljs-built_in">console</span>.error(e.message);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(e.<span class="hljs-property">message</span>);
     }
   });
-}).on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`Got error: <span class="hljs-subst">${e.message}</span>`</span>);
-});</code></pre>
-<h2><code>http.globalAgent</code><span><a class="mark" href="#http_http_globalagent" id="http_http_globalagent">#</a></span></h2>
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`Got error: <span class="hljs-subst">${e.message}</span>`</span>);
+});
+
+<span class="hljs-comment">// Create a local server to receive data from</span>
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
+    <span class="hljs-attr">data</span>: <span class="hljs-string">'Hello World!'</span>
+  }));
+});
+
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
+</section><section><h3><code>http.globalAgent</code><span><a class="mark" href="#http_http_globalagent" id="http_http_globalagent">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -36714,22 +39918,30 @@ data for reasons stated in <a href="#http_class_http_clientrequest"><code>http.C
 </ul>
 <p>Global instance of <code>Agent</code> which is used as the default for all HTTP client
 requests.</p>
-<h2><code>http.maxHeaderSize</code><span><a class="mark" href="#http_http_maxheadersize" id="http_http_maxheadersize">#</a></span></h2>
+</section><section><h3><code>http.maxHeaderSize</code><span><a class="mark" href="#http_http_maxheadersize" id="http_http_maxheadersize">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.6.0</span>
+<span>Added in: v11.6.0, v10.15.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Read-only property specifying the maximum allowed size of HTTP headers in bytes.
 Defaults to 8KB. Configurable using the <a href="#cli_max_http_header_size_size"><code>--max-http-header-size</code></a> CLI option.</p>
-<h2><code>http.request(options[, callback])</code><span><a class="mark" href="#http_http_request_options_callback" id="http_http_request_options_callback">#</a></span></h2>
-<h2><code>http.request(url[, options][, callback])</code><span><a class="mark" href="#http_http_request_url_options_callback" id="http_http_request_url_options_callback">#</a></span></h2>
+<p>This can be overridden for servers and client requests by passing the
+<code>maxHeaderSize</code> option.</p>
+</section><section><h3><code>http.request(options[, callback])</code><span><a class="mark" href="#http_http_request_options_callback" id="http_http_request_options_callback">#</a></span></h3>
+</section><section><h3><code>http.request(url[, options][, callback])</code><span><a class="mark" href="#http_http_request_url_options_callback" id="http_http_request_url_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.15.0</td>
+<tr><td>v14.18.0</td>
+<td><p>When using a <code>URL</code> object parsed username and password will now be properly URI decoded.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>It is possible to abort a request with an AbortSignal.</p></td></tr>
+<tr><td>v13.3.0</td>
+<td><p>The <code>maxHeaderSize</code> option is supported now.</p></td></tr>
+<tr><td>v13.8.0, v12.15.0, v10.19.0</td>
 <td><p>The <code>insecureHTTPParser</code> option is supported now.</p></td></tr>
 <tr><td>v10.9.0</td>
 <td><p>The <code>url</code> parameter can now be passed along with a separate <code>options</code> object.</p></td></tr>
@@ -36765,6 +39977,7 @@ details. Any <a href="#stream_class_stream_duplex"><code>Duplex</code></a> strea
 <code>hostname</code>. Valid values are <code>4</code> or <code>6</code>. When unspecified, both IP v4 and
 v6 will be used.</li>
 <li><code>headers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> An object containing request headers.</li>
+<li><code>hints</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Optional <a href="#dns_supported_getaddrinfo_flags"><code>dns.lookup()</code> hints</a>.</li>
 <li><code>host</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A domain name or IP address of the server to issue the
 request to. <strong>Default:</strong> <code>'localhost'</code>.</li>
 <li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Alias for <code>host</code>. To support <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a>,
@@ -36774,7 +39987,12 @@ invalid HTTP headers when <code>true</code>. Using the insecure parser should be
 avoided. See <a href="#cli_insecure_http_parser"><code>--insecure-http-parser</code></a> for more information.
 <strong>Default:</strong> <code>false</code></li>
 <li><code>localAddress</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Local interface to bind for network connections.</li>
+<li><code>localPort</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Local port to connect from.</li>
 <li><code>lookup</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Custom lookup function. <strong>Default:</strong> <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>.</li>
+<li><code>maxHeaderSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Optionally overrides the value of
+<a href="#cli_max_http_header_size_size"><code>--max-http-header-size</code></a> for requests received from the server, i.e.
+the maximum length of response headers in bytes.
+<strong>Default:</strong> 16384 (16KB).</li>
 <li><code>method</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A string specifying the HTTP request method. <strong>Default:</strong>
 <code>'GET'</code>.</li>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Request path. Should include query string if any.
@@ -36790,6 +40008,8 @@ else <code>80</code>.</li>
 or <code>port</code> is specified, those specify a TCP Socket).</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a>: A number specifying the socket timeout in milliseconds.
 This will set the timeout before the socket is connected.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a>: An AbortSignal that may be used to abort an ongoing
+request.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
@@ -36807,7 +40027,9 @@ the <a href="#http_event_response"><code>'response'</code></a> event.</p>
 <p><code>http.request()</code> returns an instance of the <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>
 class. The <code>ClientRequest</code> instance is a writable stream. If one needs to
 upload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> postData = querystring.stringify({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-keyword">const</span> postData = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
   <span class="hljs-string">'msg'</span>: <span class="hljs-string">'Hello World!'</span>
 });
 
@@ -36817,30 +40039,30 @@ upload a file with a POST request, then write to the <code>ClientRequest</code>
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/upload'</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'POST'</span>,
   <span class="hljs-attr">headers</span>: {
-    <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/x-www-form-urlencoded'</span>,
-    <span class="hljs-string">'Content-Length'</span>: Buffer.byteLength(postData)
+    <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span>,
+    <span class="hljs-string">'Content-Length'</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(postData)
   }
 };
 
-<span class="hljs-keyword">const</span> req = http.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`STATUS: <span class="hljs-subst">${res.statusCode}</span>`</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`HEADERS: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(res.headers)}</span>`</span>);
-  res.setEncoding(<span class="hljs-string">'utf8'</span>);
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`BODY: <span class="hljs-subst">${chunk}</span>`</span>);
+<span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`STATUS: <span class="hljs-subst">${res.statusCode}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`HEADERS: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(res.headers)}</span>`</span>);
+  res.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`BODY: <span class="hljs-subst">${chunk}</span>`</span>);
   });
-  res.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'No more data in response.'</span>);
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'No more data in response.'</span>);
   });
 });
 
-req.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`problem with request: <span class="hljs-subst">${e.message}</span>`</span>);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`problem with request: <span class="hljs-subst">${e.message}</span>`</span>);
 });
 
 <span class="hljs-comment">// Write data to request body</span>
-req.write(postData);
-req.end();</code></pre>
+req.<span class="hljs-title function_">write</span>(postData);
+req.<span class="hljs-title function_">end</span>();</code></pre>
 <p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one
 must always call <code>req.end()</code> to signify the end of the request -
 even if there is no data being written to the request body.</p>
@@ -36869,9 +40091,9 @@ to compute basic authentication.</p>
 </li>
 </ul>
 <p>Example using a <a href="#url_the_whatwg_url_api"><code>URL</code></a> as <code>options</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> options = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http://abc:xyz@example.com'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> options = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http://abc:xyz@example.com'</span>);
 
-<span class="hljs-keyword">const</span> req = http.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>In a successful request, the following events will be emitted in the following
@@ -36894,8 +40116,68 @@ instance, in most redirects)</li>
 <li><code>'error'</code></li>
 <li><code>'close'</code></li>
 </ul>
-<p>If <code>req.abort()</code> is called before the connection succeeds, the following events
-will be emitted in the following order:</p>
+<p>In the case of a premature connection close before the response is received,
+the following events will be emitted in the following order:</p>
+<ul>
+<li><code>'socket'</code></li>
+<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code
+<code>'ECONNRESET'</code></li>
+<li><code>'close'</code></li>
+</ul>
+<p>In the case of a premature connection close after the response is received,
+the following events will be emitted in the following order:</p>
+<ul>
+<li><code>'socket'</code></li>
+<li><code>'response'</code>
+<ul>
+<li><code>'data'</code> any number of times, on the <code>res</code> object</li>
+</ul>
+</li>
+<li>(connection closed here)</li>
+<li><code>'aborted'</code> on the <code>res</code> object</li>
+<li><code>'close'</code></li>
+<li><code>'close'</code> on the <code>res</code> object</li>
+</ul>
+<p>If <code>req.destroy()</code> is called before a socket is assigned, the following
+events will be emitted in the following order:</p>
+<ul>
+<li>(<code>req.destroy()</code> called here)</li>
+<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code
+<code>'ECONNRESET'</code></li>
+<li><code>'close'</code></li>
+</ul>
+<p>If <code>req.destroy()</code> is called before the connection succeeds, the following
+events will be emitted in the following order:</p>
+<ul>
+<li><code>'socket'</code></li>
+<li>(<code>req.destroy()</code> called here)</li>
+<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code
+<code>'ECONNRESET'</code></li>
+<li><code>'close'</code></li>
+</ul>
+<p>If <code>req.destroy()</code> is called after the response is received, the following
+events will be emitted in the following order:</p>
+<ul>
+<li><code>'socket'</code></li>
+<li><code>'response'</code>
+<ul>
+<li><code>'data'</code> any number of times, on the <code>res</code> object</li>
+</ul>
+</li>
+<li>(<code>req.destroy()</code> called here)</li>
+<li><code>'aborted'</code> on the <code>res</code> object</li>
+<li><code>'close'</code></li>
+<li><code>'close'</code> on the <code>res</code> object</li>
+</ul>
+<p>If <code>req.abort()</code> is called before a socket is assigned, the following
+events will be emitted in the following order:</p>
+<ul>
+<li>(<code>req.abort()</code> called here)</li>
+<li><code>'abort'</code></li>
+<li><code>'close'</code></li>
+</ul>
+<p>If <code>req.abort()</code> is called before the connection succeeds, the following
+events will be emitted in the following order:</p>
 <ul>
 <li><code>'socket'</code></li>
 <li>(<code>req.abort()</code> called here)</li>
@@ -36904,8 +40186,8 @@ will be emitted in the following order:</p>
 <code>'ECONNRESET'</code></li>
 <li><code>'close'</code></li>
 </ul>
-<p>If <code>req.abort()</code> is called after the response is received, the following events
-will be emitted in the following order:</p>
+<p>If <code>req.abort()</code> is called after the response is received, the following
+events will be emitted in the following order:</p>
 <ul>
 <li><code>'socket'</code></li>
 <li><code>'response'</code>
@@ -36917,16 +40199,80 @@ will be emitted in the following order:</p>
 <li><code>'abort'</code></li>
 <li><code>'aborted'</code> on the <code>res</code> object</li>
 <li><code>'close'</code></li>
-<li><code>'end'</code> on the <code>res</code> object</li>
 <li><code>'close'</code> on the <code>res</code> object</li>
 </ul>
 <p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will
 not abort the request or do anything besides add a <code>'timeout'</code> event.</p>
-<h1>HTTP/2<span><a class="mark" href="#http2_http_2" id="http2_http_2">#</a></span></h1>
+<p>Passing an <code>AbortSignal</code> and then calling <code>abort</code> on the corresponding
+<code>AbortController</code> will behave the same way as calling <code>.destroy()</code> on the
+request itself.</p>
+</section><section><h3><code>http.validateHeaderName(name)</code><span><a class="mark" href="#http_http_validateheadername_name" id="http_http_validateheadername_name">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.3.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Performs the low-level validations on the provided <code>name</code> that are done when
+<code>res.setHeader(name, value)</code> is called.</p>
+<p>Passing illegal value as <code>name</code> will result in a <a href="#errors_class_typeerror"><code>TypeError</code></a> being thrown,
+identified by <code>code: 'ERR_INVALID_HTTP_TOKEN'</code>.</p>
+<p>It is not necessary to use this method before passing headers to an HTTP request
+or response. The HTTP module will automatically validate such headers.
+Examples:</p>
+<p>Example:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { validateHeaderName } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">validateHeaderName</span>(<span class="hljs-string">''</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  err <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">TypeError</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">code</span>; <span class="hljs-comment">// --> 'ERR_INVALID_HTTP_TOKEN'</span>
+  err.<span class="hljs-property">message</span>; <span class="hljs-comment">// --> 'Header name must be a valid HTTP token [""]'</span>
+}</code></pre>
+</section><section><h3><code>http.validateHeaderValue(name, value)</code><span><a class="mark" href="#http_http_validateheadervalue_name_value" id="http_http_validateheadervalue_name_value">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.3.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
+</ul>
+<p>Performs the low-level validations on the provided <code>value</code> that are done when
+<code>res.setHeader(name, value)</code> is called.</p>
+<p>Passing illegal value as <code>value</code> will result in a <a href="#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
+<ul>
+<li>Undefined value error is identified by <code>code: 'ERR_HTTP_INVALID_HEADER_VALUE'</code>.</li>
+<li>Invalid value character error is identified by <code>code: 'ERR_INVALID_CHAR'</code>.</li>
+</ul>
+<p>It is not necessary to use this method before passing headers to an HTTP request
+or response. The HTTP module will automatically validate such headers.</p>
+<p>Examples:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { validateHeaderValue } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">validateHeaderValue</span>(<span class="hljs-string">'x-my-header'</span>, <span class="hljs-literal">undefined</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  err <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">TypeError</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">code</span> === <span class="hljs-string">'ERR_HTTP_INVALID_HEADER_VALUE'</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">message</span>; <span class="hljs-comment">// --> 'Invalid value "undefined" for header "x-my-header"'</span>
+}
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">validateHeaderValue</span>(<span class="hljs-string">'x-my-header'</span>, <span class="hljs-string">'oʊmɪɡə'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  err <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">TypeError</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">code</span> === <span class="hljs-string">'ERR_INVALID_CHAR'</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">message</span>; <span class="hljs-comment">// --> 'Invalid character in header content ["x-my-header"]'</span>
+}</code></pre></section>
+        </section>
+<section><h2>HTTP/2<span><a class="mark" href="#http2_http_2" id="http2_http_2">#</a></span></h2>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>It is possible to abort a request with an AbortSignal.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>HTTP/2 is now Stable. Previously, it had been Experimental.</p></td></tr>
 <tr><td>v8.4.0</td>
@@ -36936,11 +40282,11 @@ not abort the request or do anything besides add a <code>'timeout'</code> event.
 </div>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/http2.js">lib/http2.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/http2.js">lib/http2.js</a></p>
 <p>The <code>http2</code> module provides an implementation of the <a href="https://tools.ietf.org/html/rfc7540">HTTP/2</a> protocol. It
 can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);</code></pre>
-<h2>Core API<span><a class="mark" href="#http2_core_api" id="http2_core_api">#</a></span></h2>
+<section><h3>Core API<span><a class="mark" href="#http2_core_api" id="http2_core_api">#</a></span></h3>
 <p>The Core API provides a low-level interface designed specifically around
 support for HTTP/2 protocol features. It is specifically <em>not</em> designed for
 compatibility with the existing <a href="http.html">HTTP/1</a> module API. However,
@@ -36948,7 +40294,7 @@ the <a href="#http2_compatibility_api">Compatibility API</a> is.</p>
 <p>The <code>http2</code> Core API is much more symmetric between client and server than the
 <code>http</code> API. For instance, most events, like <code>'error'</code>, <code>'connect'</code> and
 <code>'stream'</code>, can be emitted either by client-side code or server-side code.</p>
-<h3>Server-side example<span><a class="mark" href="#http2_server_side_example" id="http2_server_side_example">#</a></span></h3>
+<h4>Server-side example<span><a class="mark" href="#http2_server_side_example" id="http2_server_side_example">#</a></span></h4>
 <p>The following illustrates a simple HTTP/2 server using the Core API.
 Since there are no browsers known that support
 <a href="https://http2.github.io/faq/#does-http2-require-encryption">unencrypted HTTP/2</a>, the use of
@@ -36957,51 +40303,51 @@ with browser clients.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> server = http2.createSecureServer({
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'localhost-privkey.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'localhost-cert.pem'</span>)
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>({
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'localhost-privkey.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'localhost-cert.pem'</span>)
 });
-server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-built_in">console</span>.error(err));
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err));
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
   <span class="hljs-comment">// stream is a Duplex</span>
-  stream.respond({
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
   });
-  stream.end(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
 });
 
-server.listen(<span class="hljs-number">8443</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8443</span>);</code></pre>
 <p>To generate the certificate and key for this example, run:</p>
 <pre><code class="language-bash">openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj <span class="hljs-string">'/CN=localhost'</span> \
   -keyout localhost-privkey.pem -out localhost-cert.pem</code></pre>
-<h3>Client-side example<span><a class="mark" href="#http2_client_side_example" id="http2_client_side_example">#</a></span></h3>
+<h4>Client-side example<span><a class="mark" href="#http2_client_side_example" id="http2_client_side_example">#</a></span></h4>
 <p>The following illustrates an HTTP/2 client:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://localhost:8443'</span>, {
-  <span class="hljs-attr">ca</span>: fs.readFileSync(<span class="hljs-string">'localhost-cert.pem'</span>)
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://localhost:8443'</span>, {
+  <span class="hljs-attr">ca</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'localhost-cert.pem'</span>)
 });
-client.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-built_in">console</span>.error(err));
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err));
 
-<span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
 
-req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
   <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> name <span class="hljs-keyword">in</span> headers) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${name}</span>: <span class="hljs-subst">${headers[name]}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${name}</span>: <span class="hljs-subst">${headers[name]}</span>`</span>);
   }
 });
 
-req.setEncoding(<span class="hljs-string">'utf8'</span>);
+req.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
 <span class="hljs-keyword">let</span> data = <span class="hljs-string">''</span>;
-req.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { data += chunk; });
-req.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`\n<span class="hljs-subst">${data}</span>`</span>);
-  client.close();
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { data += chunk; });
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`\n<span class="hljs-subst">${data}</span>`</span>);
+  client.<span class="hljs-title function_">close</span>();
 });
-req.end();</code></pre>
-<h3>Class: <code>Http2Session</code><span><a class="mark" href="#http2_class_http2session" id="http2_class_http2session">#</a></span></h3>
+req.<span class="hljs-title function_">end</span>();</code></pre>
+<h4>Class: <code>Http2Session</code><span><a class="mark" href="#http2_class_http2session" id="http2_class_http2session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37022,7 +40368,7 @@ actions typically taken through interactions with either the <code>Http2Server</
 <code>Http2Session</code> instances are created by the <code>Http2Server</code> instance when a
 new HTTP/2 connection is received. Client-side <code>Http2Session</code> instances are
 created using the <code>http2.connect()</code> method.</p>
-<h4><code>Http2Session</code> and sockets<span><a class="mark" href="#http2_http2session_and_sockets" id="http2_http2session_and_sockets">#</a></span></h4>
+<h5><code>Http2Session</code> and sockets<span><a class="mark" href="#http2_http2session_and_sockets" id="http2_http2session_and_sockets">#</a></span></h5>
 <p>Every <code>Http2Session</code> instance is associated with exactly one <a href="#net_class_net_socket"><code>net.Socket</code></a> or
 <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> when it is created. When either the <code>Socket</code> or the
 <code>Http2Session</code> are destroyed, both will be destroyed.</p>
@@ -37033,13 +40379,13 @@ put the HTTP/2 session into an indeterminate state causing the session and
 the socket to become unusable.</p>
 <p>Once a <code>Socket</code> has been bound to an <code>Http2Session</code>, user code should rely
 solely on the API of the <code>Http2Session</code>.</p>
-<h4>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close" id="http2_event_close">#</a></span></h4>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close" id="http2_event_close">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'close'</code> event is emitted once the <code>Http2Session</code> has been destroyed. Its
 listener does not expect any arguments.</p>
-<h4>Event: <code>'connect'</code><span><a class="mark" href="#http2_event_connect" id="http2_event_connect">#</a></span></h4>
+<h5>Event: <code>'connect'</code><span><a class="mark" href="#http2_event_connect" id="http2_event_connect">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37050,7 +40396,7 @@ listener does not expect any arguments.</p>
 <p>The <code>'connect'</code> event is emitted once the <code>Http2Session</code> has been successfully
 connected to the remote peer and communication may begin.</p>
 <p>User code will typically not listen for this event directly.</p>
-<h4>Event: <code>'error'</code><span><a class="mark" href="#http2_event_error" id="http2_event_error">#</a></span></h4>
+<h5>Event: <code>'error'</code><span><a class="mark" href="#http2_event_error" id="http2_event_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37059,7 +40405,7 @@ connected to the remote peer and communication may begin.</p>
 </ul>
 <p>The <code>'error'</code> event is emitted when an error occurs during the processing of
 an <code>Http2Session</code>.</p>
-<h4>Event: <code>'frameError'</code><span><a class="mark" href="#http2_event_frameerror" id="http2_event_frameerror">#</a></span></h4>
+<h5>Event: <code>'frameError'</code><span><a class="mark" href="#http2_event_frameerror" id="http2_event_frameerror">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37077,7 +40423,7 @@ with a specific <code>Http2Stream</code>, an attempt to emit a <code>'frameError
 closed and destroyed immediately following the <code>'frameError'</code> event. If the
 event is not associated with a stream, the <code>Http2Session</code> will be shut down
 immediately following the <code>'frameError'</code> event.</p>
-<h4>Event: <code>'goaway'</code><span><a class="mark" href="#http2_event_goaway" id="http2_event_goaway">#</a></span></h4>
+<h5>Event: <code>'goaway'</code><span><a class="mark" href="#http2_event_goaway" id="http2_event_goaway">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37091,7 +40437,7 @@ frame, a <code>Buffer</code> instance will be passed containing that data.</li>
 <p>The <code>'goaway'</code> event is emitted when a <code>GOAWAY</code> frame is received.</p>
 <p>The <code>Http2Session</code> instance will be shut down automatically when the <code>'goaway'</code>
 event is emitted.</p>
-<h4>Event: <code>'localSettings'</code><span><a class="mark" href="#http2_event_localsettings" id="http2_event_localsettings">#</a></span></h4>
+<h5>Event: <code>'localSettings'</code><span><a class="mark" href="#http2_event_localsettings" id="http2_event_localsettings">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37102,12 +40448,12 @@ event is emitted.</p>
 has been received.</p>
 <p>When using <code>http2session.settings()</code> to submit new settings, the modified
 settings do not take effect until the <code>'localSettings'</code> event is emitted.</p>
-<pre><code class="language-js">session.settings({ <span class="hljs-attr">enablePush</span>: <span class="hljs-literal">false</span> });
+<pre><code class="language-js">session.<span class="hljs-title function_">settings</span>({ <span class="hljs-attr">enablePush</span>: <span class="hljs-literal">false</span> });
 
-session.on(<span class="hljs-string">'localSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
+session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'localSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
   <span class="hljs-comment">/* Use the new settings */</span>
 });</code></pre>
-<h4>Event: <code>'ping'</code><span><a class="mark" href="#http2_event_ping" id="http2_event_ping">#</a></span></h4>
+<h5>Event: <code>'ping'</code><span><a class="mark" href="#http2_event_ping" id="http2_event_ping">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -37116,7 +40462,7 @@ session.on(<span class="hljs-string">'localSettings'</span>, <span class="hljs-f
 </ul>
 <p>The <code>'ping'</code> event is emitted whenever a <code>PING</code> frame is received from the
 connected peer.</p>
-<h4>Event: <code>'remoteSettings'</code><span><a class="mark" href="#http2_event_remotesettings" id="http2_event_remotesettings">#</a></span></h4>
+<h5>Event: <code>'remoteSettings'</code><span><a class="mark" href="#http2_event_remotesettings" id="http2_event_remotesettings">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37125,10 +40471,10 @@ connected peer.</p>
 </ul>
 <p>The <code>'remoteSettings'</code> event is emitted when a new <code>SETTINGS</code> frame is received
 from the connected peer.</p>
-<pre><code class="language-js">session.on(<span class="hljs-string">'remoteSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
+<pre><code class="language-js">session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'remoteSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
   <span class="hljs-comment">/* Use the new settings */</span>
 });</code></pre>
-<h4>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream" id="http2_event_stream">#</a></span></h4>
+<h5>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream" id="http2_event_stream">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37141,16 +40487,16 @@ their respective values.</li>
 </ul>
 <p>The <code>'stream'</code> event is emitted when a new <code>Http2Stream</code> is created.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-session.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
+session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
   <span class="hljs-keyword">const</span> method = headers[<span class="hljs-string">':method'</span>];
   <span class="hljs-keyword">const</span> path = headers[<span class="hljs-string">':path'</span>];
   <span class="hljs-comment">// ...</span>
-  stream.respond({
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>,
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   });
-  stream.write(<span class="hljs-string">'hello '</span>);
-  stream.end(<span class="hljs-string">'world'</span>);
+  stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello '</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'world'</span>);
 });</code></pre>
 <p>On the server side, user code will typically not listen for this event directly,
 and would instead register a handler for the <code>'stream'</code> event emitted by the
@@ -37159,22 +40505,22 @@ and would instead register a handler for the <code>'stream'</code> event emitted
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
 <span class="hljs-comment">// Create an unencrypted HTTP/2 server</span>
-<span class="hljs-keyword">const</span> server = http2.createServer();
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
-  stream.respond({
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
   });
-  stream.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> <span class="hljs-built_in">console</span>.error(error));
-  stream.end(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(error));
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
 });
 
-server.listen(<span class="hljs-number">80</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">80</span>);</code></pre>
 <p>Even though HTTP/2 streams and network sockets are not in a 1:1 correspondence,
 a network error will destroy each individual stream and must be handled on the
 stream level, as shown above.</p>
-<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout" id="http2_event_timeout">#</a></span></h4>
+<h5>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout" id="http2_event_timeout">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37182,9 +40528,9 @@ stream level, as shown above.</p>
 for this <code>Http2Session</code>, the <code>'timeout'</code> event is emitted if there is no
 activity on the <code>Http2Session</code> after the configured number of milliseconds.
 Its listener does not expect any arguments.</p>
-<pre><code class="language-js">session.setTimeout(<span class="hljs-number">2000</span>);
-session.on(<span class="hljs-string">'timeout'</span>, <span class="hljs-function">() =></span> { <span class="hljs-comment">/* .. */</span> });</code></pre>
-<h4><code>http2session.alpnProtocol</code><span><a class="mark" href="#http2_http2session_alpnprotocol" id="http2_http2session_alpnprotocol">#</a></span></h4>
+<pre><code class="language-js">session.<span class="hljs-built_in">setTimeout</span>(<span class="hljs-number">2000</span>);
+session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'timeout'</span>, <span class="hljs-function">() =></span> { <span class="hljs-comment">/* .. */</span> });</code></pre>
+<h5><code>http2session.alpnProtocol</code><span><a class="mark" href="#http2_http2session_alpnprotocol" id="http2_http2session_alpnprotocol">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37195,7 +40541,7 @@ session.on(<span class="hljs-string">'timeout'</span>, <span class="hljs-functio
 socket, <code>h2c</code> if the <code>Http2Session</code> is not connected to a <code>TLSSocket</code>, or
 will return the value of the connected <code>TLSSocket</code>'s own <code>alpnProtocol</code>
 property.</p>
-<h4><code>http2session.close([callback])</code><span><a class="mark" href="#http2_http2session_close_callback" id="http2_http2session_close_callback">#</a></span></h4>
+<h5><code>http2session.close([callback])</code><span><a class="mark" href="#http2_http2session_close_callback" id="http2_http2session_close_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37208,7 +40554,7 @@ created. Once closed, <code>http2session.destroy()</code> <em>might</em> be call
 are no open <code>Http2Stream</code> instances.</p>
 <p>If specified, the <code>callback</code> function is registered as a handler for the
 <code>'close'</code> event.</p>
-<h4><code>http2session.closed</code><span><a class="mark" href="#http2_http2session_closed" id="http2_http2session_closed">#</a></span></h4>
+<h5><code>http2session.closed</code><span><a class="mark" href="#http2_http2session_closed" id="http2_http2session_closed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37217,7 +40563,7 @@ are no open <code>Http2Stream</code> instances.</p>
 </ul>
 <p>Will be <code>true</code> if this <code>Http2Session</code> instance has been closed, otherwise
 <code>false</code>.</p>
-<h4><code>http2session.connecting</code><span><a class="mark" href="#http2_http2session_connecting" id="http2_http2session_connecting">#</a></span></h4>
+<h5><code>http2session.connecting</code><span><a class="mark" href="#http2_http2session_connecting" id="http2_http2session_connecting">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -37227,7 +40573,7 @@ are no open <code>Http2Stream</code> instances.</p>
 <p>Will be <code>true</code> if this <code>Http2Session</code> instance is still connecting, will be set
 to <code>false</code> before emitting <code>connect</code> event and/or calling the <code>http2.connect</code>
 callback.</p>
-<h4><code>http2session.destroy([error][, code])</code><span><a class="mark" href="#http2_http2session_destroy_error_code" id="http2_http2session_destroy_error_code">#</a></span></h4>
+<h5><code>http2session.destroy([error][, code])</code><span><a class="mark" href="#http2_http2session_destroy_error_code" id="http2_http2session_destroy_error_code">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37245,7 +40591,7 @@ is not undefined, an <code>'error'</code> event will be emitted immediately befo
 <code>'close'</code> event.</p>
 <p>If there are any remaining open <code>Http2Streams</code> associated with the
 <code>Http2Session</code>, those will also be destroyed.</p>
-<h4><code>http2session.destroyed</code><span><a class="mark" href="#http2_http2session_destroyed" id="http2_http2session_destroyed">#</a></span></h4>
+<h5><code>http2session.destroyed</code><span><a class="mark" href="#http2_http2session_destroyed" id="http2_http2session_destroyed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37254,7 +40600,7 @@ is not undefined, an <code>'error'</code> event will be emitted immediately befo
 </ul>
 <p>Will be <code>true</code> if this <code>Http2Session</code> instance has been destroyed and must no
 longer be used, otherwise <code>false</code>.</p>
-<h4><code>http2session.encrypted</code><span><a class="mark" href="#http2_http2session_encrypted" id="http2_http2session_encrypted">#</a></span></h4>
+<h5><code>http2session.encrypted</code><span><a class="mark" href="#http2_http2session_encrypted" id="http2_http2session_encrypted">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37265,7 +40611,7 @@ longer be used, otherwise <code>false</code>.</p>
 connected, <code>true</code> if the <code>Http2Session</code> is connected with a <code>TLSSocket</code>,
 and <code>false</code> if the <code>Http2Session</code> is connected to any other kind of socket
 or stream.</p>
-<h4><code>http2session.goaway([code[, lastStreamID[, opaqueData]]])</code><span><a class="mark" href="#http2_http2session_goaway_code_laststreamid_opaquedata" id="http2_http2session_goaway_code_laststreamid_opaquedata">#</a></span></h4>
+<h5><code>http2session.goaway([code[, lastStreamID[, opaqueData]]])</code><span><a class="mark" href="#http2_http2session_goaway_code_laststreamid_opaquedata" id="http2_http2session_goaway_code_laststreamid_opaquedata">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37277,7 +40623,7 @@ instance containing additional data to be carried within the <code>GOAWAY</code>
 </ul>
 <p>Transmits a <code>GOAWAY</code> frame to the connected peer <em>without</em> shutting down the
 <code>Http2Session</code>.</p>
-<h4><code>http2session.localSettings</code><span><a class="mark" href="#http2_http2session_localsettings" id="http2_http2session_localsettings">#</a></span></h4>
+<h5><code>http2session.localSettings</code><span><a class="mark" href="#http2_http2session_localsettings" id="http2_http2session_localsettings">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37286,7 +40632,7 @@ instance containing additional data to be carried within the <code>GOAWAY</code>
 </ul>
 <p>A prototype-less object describing the current local settings of this
 <code>Http2Session</code>. The local settings are local to <em>this</em> <code>Http2Session</code> instance.</p>
-<h4><code>http2session.originSet</code><span><a class="mark" href="#http2_http2session_originset" id="http2_http2session_originset">#</a></span></h4>
+<h5><code>http2session.originSet</code><span><a class="mark" href="#http2_http2session_originset" id="http2_http2session_originset">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37297,7 +40643,7 @@ instance containing additional data to be carried within the <code>GOAWAY</code>
 will return an <code>Array</code> of origins for which the <code>Http2Session</code> may be
 considered authoritative.</p>
 <p>The <code>originSet</code> property is only available when using a secure TLS connection.</p>
-<h4><code>http2session.pendingSettingsAck</code><span><a class="mark" href="#http2_http2session_pendingsettingsack" id="http2_http2session_pendingsettingsack">#</a></span></h4>
+<h5><code>http2session.pendingSettingsAck</code><span><a class="mark" href="#http2_http2session_pendingsettingsack" id="http2_http2session_pendingsettingsack">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37308,7 +40654,7 @@ considered authoritative.</p>
 a sent <code>SETTINGS</code> frame. Will be <code>true</code> after calling the
 <code>http2session.settings()</code> method. Will be <code>false</code> once all sent <code>SETTINGS</code>
 frames have been acknowledged.</p>
-<h4><code>http2session.ping([payload, ]callback)</code><span><a class="mark" href="#http2_http2session_ping_payload_callback" id="http2_http2session_ping_payload_callback">#</a></span></h4>
+<h5><code>http2session.ping([payload, ]callback)</code><span><a class="mark" href="#http2_http2session_ping_payload_callback" id="http2_http2session_ping_payload_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.9.3</span>
 </div>
@@ -37330,21 +40676,21 @@ be <code>null</code> if the <code>PING</code> was successfully acknowledged, a <
 that reports the number of milliseconds elapsed since the ping was sent and the
 acknowledgment was received, and a <code>Buffer</code> containing the 8-byte <code>PING</code>
 payload.</p>
-<pre><code class="language-js">session.ping(Buffer.from(<span class="hljs-string">'abcdefgh'</span>), <span class="hljs-function">(<span class="hljs-params">err, duration, payload</span>) =></span> {
+<pre><code class="language-js">session.<span class="hljs-title function_">ping</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'abcdefgh'</span>), <span class="hljs-function">(<span class="hljs-params">err, duration, payload</span>) =></span> {
   <span class="hljs-keyword">if</span> (!err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Ping acknowledged in <span class="hljs-subst">${duration}</span> milliseconds`</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`With payload '<span class="hljs-subst">${payload.toString()}</span>'`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Ping acknowledged in <span class="hljs-subst">${duration}</span> milliseconds`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`With payload '<span class="hljs-subst">${payload.toString()}</span>'`</span>);
   }
 });</code></pre>
 <p>If the <code>payload</code> argument is not specified, the default payload will be the
 64-bit timestamp (little endian) marking the start of the <code>PING</code> duration.</p>
-<h4><code>http2session.ref()</code><span><a class="mark" href="#http2_http2session_ref" id="http2_http2session_ref">#</a></span></h4>
+<h5><code>http2session.ref()</code><span><a class="mark" href="#http2_http2session_ref" id="http2_http2session_ref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
 <p>Calls <a href="#net_socket_ref"><code>ref()</code></a> on this <code>Http2Session</code>
 instance's underlying <a href="#net_class_net_socket"><code>net.Socket</code></a>.</p>
-<h4><code>http2session.remoteSettings</code><span><a class="mark" href="#http2_http2session_remotesettings" id="http2_http2session_remotesettings">#</a></span></h4>
+<h5><code>http2session.remoteSettings</code><span><a class="mark" href="#http2_http2session_remotesettings" id="http2_http2session_remotesettings">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37353,7 +40699,26 @@ instance's underlying <a href="#net_class_net_socket"><code>net.Socket</code></a
 </ul>
 <p>A prototype-less object describing the current remote settings of this
 <code>Http2Session</code>. The remote settings are set by the <em>connected</em> HTTP/2 peer.</p>
-<h4><code>http2session.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_http2session_settimeout_msecs_callback" id="http2_http2session_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>http2session.setLocalWindowSize(windowSize)</code><span><a class="mark" href="#http2_http2session_setlocalwindowsize_windowsize" id="http2_http2session_setlocalwindowsize_windowsize">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>windowSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>Sets the local endpoint's window size.
+The <code>windowSize</code> is the total window size to set, not
+the delta.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
+
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+<span class="hljs-keyword">const</span> expectedWindowSize = <span class="hljs-number">2</span> ** <span class="hljs-number">20</span>;
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
+
+  <span class="hljs-comment">// Set local window size to be 2 ** 20</span>
+  session.<span class="hljs-title function_">setLocalWindowSize</span>(expectedWindowSize);
+});</code></pre>
+<h5><code>http2session.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_http2session_settimeout_msecs_callback" id="http2_http2session_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37364,7 +40729,7 @@ instance's underlying <a href="#net_class_net_socket"><code>net.Socket</code></a
 <p>Used to set a callback function that is called when there is no activity on
 the <code>Http2Session</code> after <code>msecs</code> milliseconds. The given <code>callback</code> is
 registered as a listener on the <code>'timeout'</code> event.</p>
-<h4><code>http2session.socket</code><span><a class="mark" href="#http2_http2session_socket" id="http2_http2session_socket">#</a></span></h4>
+<h5><code>http2session.socket</code><span><a class="mark" href="#http2_http2session_socket" id="http2_http2session_socket">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37378,7 +40743,7 @@ an error with code <code>ERR_HTTP2_NO_SOCKET_MANIPULATION</code>. See
 <a href="#http2_http2session_and_sockets"><code>Http2Session</code> and Sockets</a> for more information.</p>
 <p><code>setTimeout</code> method will be called on this <code>Http2Session</code>.</p>
 <p>All other interactions will be routed directly to the socket.</p>
-<h4><code>http2session.state</code><span><a class="mark" href="#http2_http2session_state" id="http2_http2session_state">#</a></span></h4>
+<h5><code>http2session.state</code><span><a class="mark" href="#http2_http2session_state" id="http2_http2session_state">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37409,7 +40774,7 @@ inbound header compression state table.</li>
 </li>
 </ul>
 <p>An object describing the current status of this <code>Http2Session</code>.</p>
-<h4><code>http2session.settings([settings][, callback])</code><span><a class="mark" href="#http2_http2session_settings_settings_callback" id="http2_http2session_settings_settings_callback">#</a></span></h4>
+<h5><code>http2session.settings([settings][, callback])</code><span><a class="mark" href="#http2_http2session_settings_settings_callback" id="http2_http2session_settings_settings_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37432,7 +40797,7 @@ settings.</p>
 <p>The new settings will not become effective until the <code>SETTINGS</code> acknowledgment
 is received and the <code>'localSettings'</code> event is emitted. It is possible to send
 multiple <code>SETTINGS</code> frames while acknowledgment is still pending.</p>
-<h4><code>http2session.type</code><span><a class="mark" href="#http2_http2session_type" id="http2_http2session_type">#</a></span></h4>
+<h5><code>http2session.type</code><span><a class="mark" href="#http2_http2session_type" id="http2_http2session_type">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37443,20 +40808,20 @@ multiple <code>SETTINGS</code> frames while acknowledgment is still pending.</p>
 <code>http2.constants.NGHTTP2_SESSION_SERVER</code> if this <code>Http2Session</code> instance is a
 server, and <code>http2.constants.NGHTTP2_SESSION_CLIENT</code> if the instance is a
 client.</p>
-<h4><code>http2session.unref()</code><span><a class="mark" href="#http2_http2session_unref" id="http2_http2session_unref">#</a></span></h4>
+<h5><code>http2session.unref()</code><span><a class="mark" href="#http2_http2session_unref" id="http2_http2session_unref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
 <p>Calls <a href="#net_socket_unref"><code>unref()</code></a> on this <code>Http2Session</code>
 instance's underlying <a href="#net_class_net_socket"><code>net.Socket</code></a>.</p>
-<h3>Class: <code>ServerHttp2Session</code><span><a class="mark" href="#http2_class_serverhttp2session" id="http2_class_serverhttp2session">#</a></span></h3>
+<h4>Class: <code>ServerHttp2Session</code><span><a class="mark" href="#http2_class_serverhttp2session" id="http2_class_serverhttp2session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <ul>
 <li>Extends: <a href="#http2_class_http2session" class="type">&#x3C;Http2Session></a></li>
 </ul>
-<h4><code>serverhttp2session.altsvc(alt, originOrStream)</code><span><a class="mark" href="#http2_serverhttp2session_altsvc_alt_originorstream" id="http2_serverhttp2session_altsvc_alt_originorstream">#</a></span></h4>
+<h5><code>serverhttp2session.altsvc(alt, originOrStream)</code><span><a class="mark" href="#http2_serverhttp2session_altsvc_alt_originorstream" id="http2_serverhttp2session_altsvc_alt_originorstream">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37471,15 +40836,15 @@ property.</li>
 <p>Submits an <code>ALTSVC</code> frame (as defined by <a href="https://tools.ietf.org/html/rfc7838">RFC 7838</a>) to the connected client.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
   <span class="hljs-comment">// Set altsvc for origin https://example.org:80</span>
-  session.altsvc(<span class="hljs-string">'h2=":8000"'</span>, <span class="hljs-string">'https://example.org:80'</span>);
+  session.<span class="hljs-title function_">altsvc</span>(<span class="hljs-string">'h2=":8000"'</span>, <span class="hljs-string">'https://example.org:80'</span>);
 });
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
   <span class="hljs-comment">// Set altsvc for a specific stream</span>
-  stream.session.altsvc(<span class="hljs-string">'h2=":8000"'</span>, stream.id);
+  stream.<span class="hljs-property">session</span>.<span class="hljs-title function_">altsvc</span>(<span class="hljs-string">'h2=":8000"'</span>, stream.<span class="hljs-property">id</span>);
 });</code></pre>
 <p>Sending an <code>ALTSVC</code> frame with a specific stream ID indicates that the alternate
 service is associated with the origin of the given <code>Http2Stream</code>.</p>
@@ -37496,7 +40861,7 @@ cannot be parsed as a URL or if a valid origin cannot be derived.</p>
 <code>originOrStream</code>, in which case the value of the <code>origin</code> property will be
 used. The value of the <code>origin</code> property <em>must</em> be a properly serialized
 ASCII origin.</p>
-<h4>Specifying alternative services<span><a class="mark" href="#http2_specifying_alternative_services" id="http2_specifying_alternative_services">#</a></span></h4>
+<h5>Specifying alternative services<span><a class="mark" href="#http2_specifying_alternative_services" id="http2_specifying_alternative_services">#</a></span></h5>
 <p>The format of the <code>alt</code> parameter is strictly defined by <a href="https://tools.ietf.org/html/rfc7838">RFC 7838</a> as an
 ASCII string containing a comma-delimited list of "alternative" protocols
 associated with a specific host and port.</p>
@@ -37508,7 +40873,7 @@ host and port <em>must</em> be contained within the quote (<code>"</code>) chara
 <a href="https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids">ALPN Protocol ID</a>.</p>
 <p>The syntax of these values is not validated by the Node.js implementation and
 are passed through as provided by the user or received from the peer.</p>
-<h4><code>serverhttp2session.origin(...origins)</code><span><a class="mark" href="#http2_serverhttp2session_origin_origins" id="http2_serverhttp2session_origin_origins">#</a></span></h4>
+<h5><code>serverhttp2session.origin(...origins)</code><span><a class="mark" href="#http2_serverhttp2session_origin_origins" id="http2_serverhttp2session_origin_origins">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -37520,14 +40885,14 @@ separate arguments.</li>
 to advertise the set of origins for which the server is capable of providing
 authoritative responses.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> options = getSecureOptionsSomehow();
-<span class="hljs-keyword">const</span> server = http2.createSecureServer(options);
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond();
-  stream.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> options = <span class="hljs-title function_">getSecureOptionsSomehow</span>();
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>(options);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>();
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });
-server.on(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
-  session.origin(<span class="hljs-string">'https://example.com'</span>, <span class="hljs-string">'https://example.org'</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
+  session.<span class="hljs-title function_">origin</span>(<span class="hljs-string">'https://example.com'</span>, <span class="hljs-string">'https://example.org'</span>);
 });</code></pre>
 <p>When a string is passed as an <code>origin</code>, it will be parsed as a URL and the
 origin will be derived. For instance, the origin for the HTTP URL
@@ -37541,21 +40906,21 @@ ASCII origin.</p>
 <p>Alternatively, the <code>origins</code> option may be used when creating a new HTTP/2
 server using the <code>http2.createSecureServer()</code> method:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> options = getSecureOptionsSomehow();
-options.origins = [<span class="hljs-string">'https://example.com'</span>, <span class="hljs-string">'https://example.org'</span>];
-<span class="hljs-keyword">const</span> server = http2.createSecureServer(options);
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond();
-  stream.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> options = <span class="hljs-title function_">getSecureOptionsSomehow</span>();
+options.<span class="hljs-property">origins</span> = [<span class="hljs-string">'https://example.com'</span>, <span class="hljs-string">'https://example.org'</span>];
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>(options);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>();
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
-<h3>Class: <code>ClientHttp2Session</code><span><a class="mark" href="#http2_class_clienthttp2session" id="http2_class_clienthttp2session">#</a></span></h3>
+<h4>Class: <code>ClientHttp2Session</code><span><a class="mark" href="#http2_class_clienthttp2session" id="http2_class_clienthttp2session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <ul>
 <li>Extends: <a href="#http2_class_http2session" class="type">&#x3C;Http2Session></a></li>
 </ul>
-<h4>Event: <code>'altsvc'</code><span><a class="mark" href="#http2_event_altsvc" id="http2_event_altsvc">#</a></span></h4>
+<h5>Event: <code>'altsvc'</code><span><a class="mark" href="#http2_event_altsvc" id="http2_event_altsvc">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37569,14 +40934,14 @@ the client. The event is emitted with the <code>ALTSVC</code> value, origin, and
 ID. If no <code>origin</code> is provided in the <code>ALTSVC</code> frame, <code>origin</code> will
 be an empty string.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://example.org'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://example.org'</span>);
 
-client.on(<span class="hljs-string">'altsvc'</span>, <span class="hljs-function">(<span class="hljs-params">alt, origin, streamId</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(alt);
-  <span class="hljs-built_in">console</span>.log(origin);
-  <span class="hljs-built_in">console</span>.log(streamId);
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'altsvc'</span>, <span class="hljs-function">(<span class="hljs-params">alt, origin, streamId</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(alt);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(origin);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(streamId);
 });</code></pre>
-<h4>Event: <code>'origin'</code><span><a class="mark" href="#http2_event_origin" id="http2_event_origin">#</a></span></h4>
+<h5>Event: <code>'origin'</code><span><a class="mark" href="#http2_event_origin" id="http2_event_origin">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -37588,14 +40953,14 @@ the client. The event is emitted with an array of <code>origin</code> strings. T
 <code>http2session.originSet</code> will be updated to include the received
 origins.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://example.org'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://example.org'</span>);
 
-client.on(<span class="hljs-string">'origin'</span>, <span class="hljs-function">(<span class="hljs-params">origins</span>) =></span> {
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; origins.length; n++)
-    <span class="hljs-built_in">console</span>.log(origins[n]);
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'origin'</span>, <span class="hljs-function">(<span class="hljs-params">origins</span>) =></span> {
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; origins.<span class="hljs-property">length</span>; n++)
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(origins[n]);
 });</code></pre>
 <p>The <code>'origin'</code> event is only emitted when using a secure TLS connection.</p>
-<h4><code>clienthttp2session.request(headers[, options])</code><span><a class="mark" href="#http2_clienthttp2session_request_headers_options" id="http2_clienthttp2session_request_headers_options">#</a></span></h4>
+<h5><code>clienthttp2session.request(headers[, options])</code><span><a class="mark" href="#http2_clienthttp2session_request_headers_options" id="http2_clienthttp2session_request_headers_options">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37620,6 +40985,8 @@ to other streams with the same <code>parent</code>. The value is a number betwee
 and <code>256</code> (inclusive).</li>
 <li><code>waitForTrailers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, the <code>Http2Stream</code> will emit the
 <code>'wantTrailers'</code> event after the final <code>DATA</code> frame has been sent.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> An AbortSignal that may be used to abort an ongoing
+request.</li>
 </ul>
 </li>
 <li>
@@ -37632,17 +40999,17 @@ HTTP/2 request to the connected server.</p>
 <p>This method is only available if <code>http2session.type</code> is equal to
 <code>http2.constants.NGHTTP2_SESSION_CLIENT</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> clientSession = http2.connect(<span class="hljs-string">'https://localhost:1234'</span>);
+<span class="hljs-keyword">const</span> clientSession = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://localhost:1234'</span>);
 <span class="hljs-keyword">const</span> {
   HTTP2_HEADER_PATH,
   HTTP2_HEADER_STATUS
-} = http2.constants;
+} = http2.<span class="hljs-property">constants</span>;
 
-<span class="hljs-keyword">const</span> req = clientSession.request({ [HTTP2_HEADER_PATH]: <span class="hljs-string">'/'</span> });
-req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers[HTTP2_HEADER_STATUS]);
-  req.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-comment">/* .. */</span> });
-  req.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> { <span class="hljs-comment">/* .. */</span> });
+<span class="hljs-keyword">const</span> req = clientSession.<span class="hljs-title function_">request</span>({ [HTTP2_HEADER_PATH]: <span class="hljs-string">'/'</span> });
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers[HTTP2_HEADER_STATUS]);
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-comment">/* .. */</span> });
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> { <span class="hljs-comment">/* .. */</span> });
 });</code></pre>
 <p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event
 is emitted immediately after queuing the last chunk of payload data to be sent.
@@ -37652,13 +41019,16 @@ headers to the peer.</p>
 close when the final <code>DATA</code> frame is transmitted. User code must call either
 <code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the
 <code>Http2Stream</code>.</p>
+<p>When <code>options.signal</code> is set with an <code>AbortSignal</code> and then <code>abort</code> on the
+corresponding <code>AbortController</code> is called, the request will emit an <code>'error'</code>
+event with an <code>AbortError</code> error.</p>
 <p>The <code>:method</code> and <code>:path</code> pseudo-headers are not specified within <code>headers</code>,
 they respectively default to:</p>
 <ul>
 <li><code>:method</code> = <code>'GET'</code></li>
 <li><code>:path</code> = <code>/</code></li>
 </ul>
-<h3>Class: <code>Http2Stream</code><span><a class="mark" href="#http2_class_http2stream" id="http2_class_http2stream">#</a></span></h3>
+<h4>Class: <code>Http2Stream</code><span><a class="mark" href="#http2_class_http2stream" id="http2_class_http2stream">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37686,12 +41056,12 @@ is used to receive data sent by the connected peer.</p>
 practice, it is recommended that when using an <code>Http2Stream</code> to send text,
 the <code>'content-type'</code> header should be set and should identify the character
 encoding used.</p>
-<pre><code class="language-js">stream.respond({
+<pre><code class="language-js">stream.<span class="hljs-title function_">respond</span>({
   <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
   <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
 });</code></pre>
-<h4><code>Http2Stream</code> Lifecycle<span><a class="mark" href="#http2_http2stream_lifecycle" id="http2_http2stream_lifecycle">#</a></span></h4>
-<h5>Creation<span><a class="mark" href="#http2_creation" id="http2_creation">#</a></span></h5>
+<h5><code>Http2Stream</code> Lifecycle<span><a class="mark" href="#http2_http2stream_lifecycle" id="http2_http2stream_lifecycle">#</a></span></h5>
+<h6>Creation<span><a class="mark" href="#http2_creation" id="http2_creation">#</a></span></h6>
 <p>On the server side, instances of <a href="#http2_class_serverhttp2stream"><code>ServerHttp2Stream</code></a> are created either
 when:</p>
 <ul>
@@ -37707,7 +41077,7 @@ will be buffered until the <code>'ready'</code> event is emitted. User code shou
 if ever, need to handle the <code>'ready'</code> event directly. The ready status of an
 <code>Http2Stream</code> can be determined by checking the value of <code>http2stream.id</code>. If
 the value is <code>undefined</code>, the stream is not yet ready for use.</p>
-<h5>Destruction<span><a class="mark" href="#http2_destruction" id="http2_destruction">#</a></span></h5>
+<h6>Destruction<span><a class="mark" href="#http2_destruction" id="http2_destruction">#</a></span></h6>
 <p>All <a href="#http2_class_http2stream"><code>Http2Stream</code></a> instances are destroyed either when:</p>
 <ul>
 <li>An <code>RST_STREAM</code> frame for the stream is received by the connected peer,
@@ -37727,7 +41097,7 @@ with an <code>Error</code> passed as the first argument.</p>
 property will be <code>true</code> and the <code>http2stream.rstCode</code> property will specify the
 <code>RST_STREAM</code> error code. The <code>Http2Stream</code> instance is no longer usable once
 destroyed.</p>
-<h4>Event: <code>'aborted'</code><span><a class="mark" href="#http2_event_aborted" id="http2_event_aborted">#</a></span></h4>
+<h5>Event: <code>'aborted'</code><span><a class="mark" href="#http2_event_aborted" id="http2_event_aborted">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37736,7 +41106,7 @@ abnormally aborted in mid-communication.
 Its listener does not expect any arguments.</p>
 <p>The <code>'aborted'</code> event will only be emitted if the <code>Http2Stream</code> writable side
 has not been ended.</p>
-<h4>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_1" id="http2_event_close_1">#</a></span></h4>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_1" id="http2_event_close_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37745,7 +41115,7 @@ this event is emitted, the <code>Http2Stream</code> instance is no longer usable
 <p>The HTTP/2 error code used when closing the stream can be retrieved using
 the <code>http2stream.rstCode</code> property. If the code is any value other than
 <code>NGHTTP2_NO_ERROR</code> (<code>0</code>), an <code>'error'</code> event will have also been emitted.</p>
-<h4>Event: <code>'error'</code><span><a class="mark" href="#http2_event_error_1" id="http2_event_error_1">#</a></span></h4>
+<h5>Event: <code>'error'</code><span><a class="mark" href="#http2_event_error_1" id="http2_event_error_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37754,7 +41124,7 @@ the <code>http2stream.rstCode</code> property. If the code is any value other th
 </ul>
 <p>The <code>'error'</code> event is emitted when an error occurs during the processing of
 an <code>Http2Stream</code>.</p>
-<h4>Event: <code>'frameError'</code><span><a class="mark" href="#http2_event_frameerror_1" id="http2_event_frameerror_1">#</a></span></h4>
+<h5>Event: <code>'frameError'</code><span><a class="mark" href="#http2_event_frameerror_1" id="http2_event_frameerror_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37769,14 +41139,14 @@ send a frame. When invoked, the handler function will receive an integer
 argument identifying the frame type, and an integer argument identifying the
 error code. The <code>Http2Stream</code> instance will be destroyed immediately after the
 <code>'frameError'</code> event is emitted.</p>
-<h4>Event: <code>'ready'</code><span><a class="mark" href="#http2_event_ready" id="http2_event_ready">#</a></span></h4>
+<h5>Event: <code>'ready'</code><span><a class="mark" href="#http2_event_ready" id="http2_event_ready">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'ready'</code> event is emitted when the <code>Http2Stream</code> has been opened, has
 been assigned an <code>id</code>, and can be used. The listener does not expect any
 arguments.</p>
-<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_1" id="http2_event_timeout_1">#</a></span></h4>
+<h5>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_1" id="http2_event_timeout_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37784,7 +41154,7 @@ arguments.</p>
 <code>Http2Stream</code> within the number of milliseconds set using
 <code>http2stream.setTimeout()</code>.
 Its listener does not expect any arguments.</p>
-<h4>Event: <code>'trailers'</code><span><a class="mark" href="#http2_event_trailers" id="http2_event_trailers">#</a></span></h4>
+<h5>Event: <code>'trailers'</code><span><a class="mark" href="#http2_event_trailers" id="http2_event_trailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37798,10 +41168,10 @@ trailing header fields is received. The listener callback is passed the
 <p>This event might not be emitted if <code>http2stream.end()</code> is called
 before trailers are received and the incoming data is not being read or
 listened for.</p>
-<pre><code class="language-js">stream.on(<span class="hljs-string">'trailers'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers);
+<pre><code class="language-js">stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'trailers'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers);
 });</code></pre>
-<h4>Event: <code>'wantTrailers'</code><span><a class="mark" href="#http2_event_wanttrailers" id="http2_event_wanttrailers">#</a></span></h4>
+<h5>Event: <code>'wantTrailers'</code><span><a class="mark" href="#http2_event_wanttrailers" id="http2_event_wanttrailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -37809,7 +41179,7 @@ listened for.</p>
 final <code>DATA</code> frame to be sent on a frame and the <code>Http2Stream</code> is ready to send
 trailing headers. When initiating a request or response, the <code>waitForTrailers</code>
 option must be set for this event to be emitted.</p>
-<h4><code>http2stream.aborted</code><span><a class="mark" href="#http2_http2stream_aborted" id="http2_http2stream_aborted">#</a></span></h4>
+<h5><code>http2stream.aborted</code><span><a class="mark" href="#http2_http2stream_aborted" id="http2_http2stream_aborted">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37818,16 +41188,16 @@ option must be set for this event to be emitted.</p>
 </ul>
 <p>Set to <code>true</code> if the <code>Http2Stream</code> instance was aborted abnormally. When set,
 the <code>'aborted'</code> event will have been emitted.</p>
-<h4><code>http2stream.bufferSize</code><span><a class="mark" href="#http2_http2stream_buffersize" id="http2_http2stream_buffersize">#</a></span></h4>
+<h5><code>http2stream.bufferSize</code><span><a class="mark" href="#http2_http2stream_buffersize" id="http2_http2stream_buffersize">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v11.2.0</span>
+<span>Added in: v11.2.0, v10.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>This property shows the number of characters currently buffered to be written.
 See <a href="#net_socket_buffersize"><code>net.Socket.bufferSize</code></a> for details.</p>
-<h4><code>http2stream.close(code[, callback])</code><span><a class="mark" href="#http2_http2stream_close_code_callback" id="http2_http2stream_close_code_callback">#</a></span></h4>
+<h5><code>http2stream.close(code[, callback])</code><span><a class="mark" href="#http2_http2stream_close_code_callback" id="http2_http2stream_close_code_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37839,7 +41209,7 @@ See <a href="#net_socket_buffersize"><code>net.Socket.bufferSize</code></a> for
 </ul>
 <p>Closes the <code>Http2Stream</code> instance by sending an <code>RST_STREAM</code> frame to the
 connected HTTP/2 peer.</p>
-<h4><code>http2stream.closed</code><span><a class="mark" href="#http2_http2stream_closed" id="http2_http2stream_closed">#</a></span></h4>
+<h5><code>http2stream.closed</code><span><a class="mark" href="#http2_http2stream_closed" id="http2_http2stream_closed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37847,7 +41217,7 @@ connected HTTP/2 peer.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Set to <code>true</code> if the <code>Http2Stream</code> instance has been closed.</p>
-<h4><code>http2stream.destroyed</code><span><a class="mark" href="#http2_http2stream_destroyed" id="http2_http2stream_destroyed">#</a></span></h4>
+<h5><code>http2stream.destroyed</code><span><a class="mark" href="#http2_http2stream_destroyed" id="http2_http2stream_destroyed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37856,7 +41226,7 @@ connected HTTP/2 peer.</p>
 </ul>
 <p>Set to <code>true</code> if the <code>Http2Stream</code> instance has been destroyed and is no longer
 usable.</p>
-<h4><code>http2stream.endAfterHeaders</code><span><a class="mark" href="#http2_http2stream_endafterheaders" id="http2_http2stream_endafterheaders">#</a></span></h4>
+<h5><code>http2stream.endAfterHeaders</code><span><a class="mark" href="#http2_http2stream_endafterheaders" id="http2_http2stream_endafterheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.11.0</span>
 </div>
@@ -37866,7 +41236,7 @@ usable.</p>
 <p>Set the <code>true</code> if the <code>END_STREAM</code> flag was set in the request or response
 HEADERS frame received, indicating that no additional data should be received
 and the readable side of the <code>Http2Stream</code> will be closed.</p>
-<h4><code>http2stream.id</code><span><a class="mark" href="#http2_http2stream_id" id="http2_http2stream_id">#</a></span></h4>
+<h5><code>http2stream.id</code><span><a class="mark" href="#http2_http2stream_id" id="http2_http2stream_id">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37875,7 +41245,7 @@ and the readable side of the <code>Http2Stream</code> will be closed.</p>
 </ul>
 <p>The numeric stream identifier of this <code>Http2Stream</code> instance. Set to <code>undefined</code>
 if the stream identifier has not yet been assigned.</p>
-<h4><code>http2stream.pending</code><span><a class="mark" href="#http2_http2stream_pending" id="http2_http2stream_pending">#</a></span></h4>
+<h5><code>http2stream.pending</code><span><a class="mark" href="#http2_http2stream_pending" id="http2_http2stream_pending">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -37884,7 +41254,7 @@ if the stream identifier has not yet been assigned.</p>
 </ul>
 <p>Set to <code>true</code> if the <code>Http2Stream</code> instance has not yet been assigned a
 numeric stream identifier.</p>
-<h4><code>http2stream.priority(options)</code><span><a class="mark" href="#http2_http2stream_priority_options" id="http2_http2stream_priority_options">#</a></span></h4>
+<h5><code>http2stream.priority(options)</code><span><a class="mark" href="#http2_http2stream_priority_options" id="http2_http2stream_priority_options">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37906,18 +41276,18 @@ sending a <code>PRIORITY</code> frame to the connected peer.</li>
 </li>
 </ul>
 <p>Updates the priority for this <code>Http2Stream</code> instance.</p>
-<h4><code>http2stream.rstCode</code><span><a class="mark" href="#http2_http2stream_rstcode" id="http2_http2stream_rstcode">#</a></span></h4>
+<h5><code>http2stream.rstCode</code><span><a class="mark" href="#http2_http2stream_rstcode" id="http2_http2stream_rstcode">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>Set to the <code>RST_STREAM</code> <a href="#error_codes">error code</a> reported when the <code>Http2Stream</code> is
+<p>Set to the <code>RST_STREAM</code> <a href="#http2_error_codes_for_rst_stream_and_goaway">error code</a> reported when the <code>Http2Stream</code> is
 destroyed after either receiving an <code>RST_STREAM</code> frame from the connected peer,
 calling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>. Will be
 <code>undefined</code> if the <code>Http2Stream</code> has not been closed.</p>
-<h4><code>http2stream.sentHeaders</code><span><a class="mark" href="#http2_http2stream_sentheaders" id="http2_http2stream_sentheaders">#</a></span></h4>
+<h5><code>http2stream.sentHeaders</code><span><a class="mark" href="#http2_http2stream_sentheaders" id="http2_http2stream_sentheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.5.0</span>
 </div>
@@ -37925,7 +41295,7 @@ calling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>.
 <li><a href="#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a></li>
 </ul>
 <p>An object containing the outbound headers sent for this <code>Http2Stream</code>.</p>
-<h4><code>http2stream.sentInfoHeaders</code><span><a class="mark" href="#http2_http2stream_sentinfoheaders" id="http2_http2stream_sentinfoheaders">#</a></span></h4>
+<h5><code>http2stream.sentInfoHeaders</code><span><a class="mark" href="#http2_http2stream_sentinfoheaders" id="http2_http2stream_sentinfoheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.5.0</span>
 </div>
@@ -37934,7 +41304,7 @@ calling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>.
 </ul>
 <p>An array of objects containing the outbound informational (additional) headers
 sent for this <code>Http2Stream</code>.</p>
-<h4><code>http2stream.sentTrailers</code><span><a class="mark" href="#http2_http2stream_senttrailers" id="http2_http2stream_senttrailers">#</a></span></h4>
+<h5><code>http2stream.sentTrailers</code><span><a class="mark" href="#http2_http2stream_senttrailers" id="http2_http2stream_senttrailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.5.0</span>
 </div>
@@ -37942,7 +41312,7 @@ sent for this <code>Http2Stream</code>.</p>
 <li><a href="#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a></li>
 </ul>
 <p>An object containing the outbound trailers sent for this <code>HttpStream</code>.</p>
-<h4><code>http2stream.session</code><span><a class="mark" href="#http2_http2stream_session" id="http2_http2stream_session">#</a></span></h4>
+<h5><code>http2stream.session</code><span><a class="mark" href="#http2_http2stream_session" id="http2_http2stream_session">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37951,7 +41321,7 @@ sent for this <code>Http2Stream</code>.</p>
 </ul>
 <p>A reference to the <code>Http2Session</code> instance that owns this <code>Http2Stream</code>. The
 value will be <code>undefined</code> after the <code>Http2Stream</code> instance is destroyed.</p>
-<h4><code>http2stream.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_http2stream_settimeout_msecs_callback" id="http2_http2stream_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>http2stream.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_http2stream_settimeout_msecs_callback" id="http2_http2stream_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37960,13 +41330,13 @@ value will be <code>undefined</code> after the <code>Http2Stream</code> instance
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'http://example.org:8000'</span>);
-<span class="hljs-keyword">const</span> { NGHTTP2_CANCEL } = http2.constants;
-<span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'http://example.org:8000'</span>);
+<span class="hljs-keyword">const</span> { NGHTTP2_CANCEL } = http2.<span class="hljs-property">constants</span>;
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
 
 <span class="hljs-comment">// Cancel the stream if there's no activity after 5 seconds</span>
-req.setTimeout(<span class="hljs-number">5000</span>, <span class="hljs-function">() =></span> req.close(NGHTTP2_CANCEL));</code></pre>
-<h4><code>http2stream.state</code><span><a class="mark" href="#http2_http2stream_state" id="http2_http2stream_state">#</a></span></h4>
+req.<span class="hljs-built_in">setTimeout</span>(<span class="hljs-number">5000</span>, <span class="hljs-function">() =></span> req.<span class="hljs-title function_">close</span>(NGHTTP2_CANCEL));</code></pre>
+<h5><code>http2stream.state</code><span><a class="mark" href="#http2_http2stream_state" id="http2_http2stream_state">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -37990,7 +41360,7 @@ instances that depend on this <code>Http2Stream</code> as specified using
 </li>
 </ul>
 <p>A current state of this <code>Http2Stream</code>.</p>
-<h4><code>http2stream.sendTrailers(headers)</code><span><a class="mark" href="#http2_http2stream_sendtrailers_headers" id="http2_http2stream_sendtrailers_headers">#</a></span></h4>
+<h5><code>http2stream.sendTrailers(headers)</code><span><a class="mark" href="#http2_http2stream_sendtrailers_headers" id="http2_http2stream_sendtrailers_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -38004,17 +41374,17 @@ request or sending a response, the <code>options.waitForTrailers</code> option m
 in order to keep the <code>Http2Stream</code> open after the final <code>DATA</code> frame so that
 trailers can be sent.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond(<span class="hljs-literal">undefined</span>, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
-  stream.on(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
-    stream.sendTrailers({ <span class="hljs-attr">xyz</span>: <span class="hljs-string">'abc'</span> });
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>(<span class="hljs-literal">undefined</span>, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">sendTrailers</span>({ <span class="hljs-attr">xyz</span>: <span class="hljs-string">'abc'</span> });
   });
-  stream.end(<span class="hljs-string">'Hello World'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Hello World'</span>);
 });</code></pre>
 <p>The HTTP/1 specification forbids trailers from containing HTTP/2 pseudo-header
 fields (e.g. <code>':method'</code>, <code>':path'</code>, etc).</p>
-<h3>Class: <code>ClientHttp2Stream</code><span><a class="mark" href="#http2_class_clienthttp2stream" id="http2_class_clienthttp2stream">#</a></span></h3>
+<h4>Class: <code>ClientHttp2Stream</code><span><a class="mark" href="#http2_class_clienthttp2stream" id="http2_class_clienthttp2stream">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38025,14 +41395,14 @@ fields (e.g. <code>':method'</code>, <code>':path'</code>, etc).</p>
 used exclusively on HTTP/2 Clients. <code>Http2Stream</code> instances on the client
 provide events such as <code>'response'</code> and <code>'push'</code> that are only relevant on
 the client.</p>
-<h4>Event: <code>'continue'</code><span><a class="mark" href="#http2_event_continue" id="http2_event_continue">#</a></span></h4>
+<h5>Event: <code>'continue'</code><span><a class="mark" href="#http2_event_continue" id="http2_event_continue">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>Emitted when the server sends a <code>100 Continue</code> status, usually because
 the request contained <code>Expect: 100-continue</code>. This is an instruction that
 the client should send the request body.</p>
-<h4>Event: <code>'headers'</code><span><a class="mark" href="#http2_event_headers" id="http2_event_headers">#</a></span></h4>
+<h5>Event: <code>'headers'</code><span><a class="mark" href="#http2_event_headers" id="http2_event_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38040,20 +41410,20 @@ the client should send the request body.</p>
 for a stream, such as when a block of <code>1xx</code> informational headers is received.
 The listener callback is passed the <a href="#http2_headers_object">HTTP/2 Headers Object</a> and flags
 associated with the headers.</p>
-<pre><code class="language-js">stream.on(<span class="hljs-string">'headers'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers);
+<pre><code class="language-js">stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'headers'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers);
 });</code></pre>
-<h4>Event: <code>'push'</code><span><a class="mark" href="#http2_event_push" id="http2_event_push">#</a></span></h4>
+<h5>Event: <code>'push'</code><span><a class="mark" href="#http2_event_push" id="http2_event_push">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'push'</code> event is emitted when response headers for a Server Push stream
 are received. The listener callback is passed the <a href="#http2_headers_object">HTTP/2 Headers Object</a> and
 flags associated with the headers.</p>
-<pre><code class="language-js">stream.on(<span class="hljs-string">'push'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers);
+<pre><code class="language-js">stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'push'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers);
 });</code></pre>
-<h4>Event: <code>'response'</code><span><a class="mark" href="#http2_event_response" id="http2_event_response">#</a></span></h4>
+<h5>Event: <code>'response'</code><span><a class="mark" href="#http2_event_response" id="http2_event_response">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38062,12 +41432,12 @@ received for this stream from the connected HTTP/2 server. The listener is
 invoked with two arguments: an <code>Object</code> containing the received
 <a href="#http2_headers_object">HTTP/2 Headers Object</a>, and flags associated with the headers.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://localhost'</span>);
-<span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
-req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers[<span class="hljs-string">':status'</span>]);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://localhost'</span>);
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers[<span class="hljs-string">':status'</span>]);
 });</code></pre>
-<h3>Class: <code>ServerHttp2Stream</code><span><a class="mark" href="#http2_class_serverhttp2stream" id="http2_class_serverhttp2stream">#</a></span></h3>
+<h4>Class: <code>ServerHttp2Stream</code><span><a class="mark" href="#http2_class_serverhttp2stream" id="http2_class_serverhttp2stream">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38078,7 +41448,7 @@ req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">
 used exclusively on HTTP/2 Servers. <code>Http2Stream</code> instances on the server
 provide additional methods such as <code>http2stream.pushStream()</code> and
 <code>http2stream.respond()</code> that are only relevant on the server.</p>
-<h4><code>http2stream.additionalHeaders(headers)</code><span><a class="mark" href="#http2_http2stream_additionalheaders_headers" id="http2_http2stream_additionalheaders_headers">#</a></span></h4>
+<h5><code>http2stream.additionalHeaders(headers)</code><span><a class="mark" href="#http2_http2stream_additionalheaders_headers" id="http2_http2stream_additionalheaders_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38086,7 +41456,7 @@ provide additional methods such as <code>http2stream.pushStream()</code> and
 <li><code>headers</code> <a href="#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a></li>
 </ul>
 <p>Sends an additional informational <code>HEADERS</code> frame to the connected HTTP/2 peer.</p>
-<h4><code>http2stream.headersSent</code><span><a class="mark" href="#http2_http2stream_headerssent" id="http2_http2stream_headerssent">#</a></span></h4>
+<h5><code>http2stream.headersSent</code><span><a class="mark" href="#http2_http2stream_headerssent" id="http2_http2stream_headerssent">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38094,7 +41464,7 @@ provide additional methods such as <code>http2stream.pushStream()</code> and
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>True if headers were sent, false otherwise (read-only).</p>
-<h4><code>http2stream.pushAllowed</code><span><a class="mark" href="#http2_http2stream_pushallowed" id="http2_http2stream_pushallowed">#</a></span></h4>
+<h5><code>http2stream.pushAllowed</code><span><a class="mark" href="#http2_http2stream_pushallowed" id="http2_http2stream_pushallowed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38105,7 +41475,7 @@ provide additional methods such as <code>http2stream.pushStream()</code> and
 client's most recent <code>SETTINGS</code> frame. Will be <code>true</code> if the remote peer
 accepts push streams, <code>false</code> otherwise. Settings are the same for every
 <code>Http2Stream</code> in the same <code>Http2Session</code>.</p>
-<h4><code>http2stream.pushStream(headers[, options], callback)</code><span><a class="mark" href="#http2_http2stream_pushstream_headers_options_callback" id="http2_http2stream_pushstream_headers_options_callback">#</a></span></h4>
+<h5><code>http2stream.pushStream(headers[, options], callback)</code><span><a class="mark" href="#http2_http2stream_pushstream_headers_options_callback" id="http2_http2stream_pushstream_headers_options_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38135,28 +41505,28 @@ initiated with.</li>
 instance created for the push stream passed as the second argument, or an
 <code>Error</code> passed as the first argument.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
-  stream.pushStream({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> }, <span class="hljs-function">(<span class="hljs-params">err, pushStream, headers</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
+  stream.<span class="hljs-title function_">pushStream</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> }, <span class="hljs-function">(<span class="hljs-params">err, pushStream, headers</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    pushStream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
-    pushStream.end(<span class="hljs-string">'some pushed data'</span>);
+    pushStream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
+    pushStream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'some pushed data'</span>);
   });
-  stream.end(<span class="hljs-string">'some data'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'some data'</span>);
 });</code></pre>
 <p>Setting the weight of a push stream is not allowed in the <code>HEADERS</code> frame. Pass
 a <code>weight</code> value to <code>http2stream.priority</code> with the <code>silent</code> option set to
 <code>true</code> to enable server-side bandwidth balancing between concurrent streams.</p>
 <p>Calling <code>http2stream.pushStream()</code> from within a pushed stream is not permitted
 and will throw an error.</p>
-<h4><code>http2stream.respond([headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respond_headers_options" id="http2_http2stream_respond_headers_options">#</a></span></h4>
+<h5><code>http2stream.respond([headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respond_headers_options" id="http2_http2stream_respond_headers_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
-<td><p>Allow explicity setting date headers.</p></td></tr>
+<tr><td>v14.5.0</td>
+<td><p>Allow explicitly setting date headers.</p></td></tr>
 <tr><td>v8.4.0</td>
 <td><p><span>Added in: v8.4.0</span></p></td></tr>
 </tbody></table>
@@ -38174,10 +41544,10 @@ include payload data.</li>
 </li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
-  stream.end(<span class="hljs-string">'some data'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'some data'</span>);
 });</code></pre>
 <p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event
 will be emitted immediately after queuing the last chunk of payload data to be
@@ -38188,21 +41558,21 @@ close when the final <code>DATA</code> frame is transmitted. User code must call
 <code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the
 <code>Http2Stream</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> }, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
-  stream.on(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
-    stream.sendTrailers({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> }, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">sendTrailers</span>({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
   });
-  stream.end(<span class="hljs-string">'some data'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'some data'</span>);
 });</code></pre>
-<h4><code>http2stream.respondWithFD(fd[, headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respondwithfd_fd_headers_options" id="http2_http2stream_respondwithfd_fd_headers_options">#</a></span></h4>
+<h5><code>http2stream.respondWithFD(fd[, headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respondwithfd_fd_headers_options" id="http2_http2stream_respondwithfd_fd_headers_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
-<td><p>Allow explicity setting date headers.</p></td></tr>
+<tr><td>v14.5.0</td>
+<td><p>Allow explicitly setting date headers.</p></td></tr>
 <tr><td>v12.12.0</td>
 <td><p>The <code>fd</code> option may now be a <code>FileHandle</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
@@ -38234,18 +41604,18 @@ automatically.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'/some/file'</span>, <span class="hljs-string">'r'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-keyword">const</span> fd = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'/some/file'</span>, <span class="hljs-string">'r'</span>);
 
-  <span class="hljs-keyword">const</span> stat = fs.fstatSync(fd);
+  <span class="hljs-keyword">const</span> stat = fs.<span class="hljs-title function_">fstatSync</span>(fd);
   <span class="hljs-keyword">const</span> headers = {
-    <span class="hljs-string">'content-length'</span>: stat.size,
-    <span class="hljs-string">'last-modified'</span>: stat.mtime.toUTCString(),
+    <span class="hljs-string">'content-length'</span>: stat.<span class="hljs-property">size</span>,
+    <span class="hljs-string">'last-modified'</span>: stat.<span class="hljs-property">mtime</span>.<span class="hljs-title function_">toUTCString</span>(),
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   };
-  stream.respondWithFD(fd, headers);
-  stream.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> fs.closeSync(fd));
+  stream.<span class="hljs-title function_">respondWithFD</span>(fd, headers);
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> fs.<span class="hljs-title function_">closeSync</span>(fd));
 });</code></pre>
 <p>The optional <code>options.statCheck</code> function may be specified to give user code
 an opportunity to set additional content headers based on the <code>fs.Stat</code> details
@@ -38271,30 +41641,30 @@ close when the final <code>DATA</code> frame is transmitted. User code <em>must<
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'/some/file'</span>, <span class="hljs-string">'r'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-keyword">const</span> fd = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'/some/file'</span>, <span class="hljs-string">'r'</span>);
 
-  <span class="hljs-keyword">const</span> stat = fs.fstatSync(fd);
+  <span class="hljs-keyword">const</span> stat = fs.<span class="hljs-title function_">fstatSync</span>(fd);
   <span class="hljs-keyword">const</span> headers = {
-    <span class="hljs-string">'content-length'</span>: stat.size,
-    <span class="hljs-string">'last-modified'</span>: stat.mtime.toUTCString(),
+    <span class="hljs-string">'content-length'</span>: stat.<span class="hljs-property">size</span>,
+    <span class="hljs-string">'last-modified'</span>: stat.<span class="hljs-property">mtime</span>.<span class="hljs-title function_">toUTCString</span>(),
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   };
-  stream.respondWithFD(fd, headers, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
-  stream.on(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
-    stream.sendTrailers({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
+  stream.<span class="hljs-title function_">respondWithFD</span>(fd, headers, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">sendTrailers</span>({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
   });
 
-  stream.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> fs.closeSync(fd));
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> fs.<span class="hljs-title function_">closeSync</span>(fd));
 });</code></pre>
-<h4><code>http2stream.respondWithFile(path[, headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respondwithfile_path_headers_options" id="http2_http2stream_respondwithfile_path_headers_options">#</a></span></h4>
+<h5><code>http2stream.respondWithFile(path[, headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respondwithfile_path_headers_options" id="http2_http2stream_respondwithfile_path_headers_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
-<td><p>Allow explicity setting date headers.</p></td></tr>
+<tr><td>v14.5.0</td>
+<td><p>Allow explicitly setting date headers.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Any readable file, not necessarily a regular file, is supported now.</p></td></tr>
 <tr><td>v8.4.0</td>
@@ -38330,22 +41700,29 @@ code. If the <code>onError</code> callback is defined, then it will be called. O
 the stream will be destroyed.</p>
 <p>Example using a file path:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">statCheck</span>(<span class="hljs-params">stat, headers</span>) </span>{
-    headers[<span class="hljs-string">'last-modified'</span>] = stat.mtime.toUTCString();
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">statCheck</span>(<span class="hljs-params">stat, headers</span>) {
+    headers[<span class="hljs-string">'last-modified'</span>] = stat.<span class="hljs-property">mtime</span>.<span class="hljs-title function_">toUTCString</span>();
   }
 
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">onError</span>(<span class="hljs-params">err</span>) </span>{
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ENOENT'</span>) {
-      stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">404</span> });
-    } <span class="hljs-keyword">else</span> {
-      stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">500</span> });
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">onError</span>(<span class="hljs-params">err</span>) {
+    <span class="hljs-comment">// stream.respond() can throw if the stream has been destroyed by</span>
+    <span class="hljs-comment">// the other side.</span>
+    <span class="hljs-keyword">try</span> {
+      <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ENOENT'</span>) {
+        stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">404</span> });
+      } <span class="hljs-keyword">else</span> {
+        stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">500</span> });
+      }
+    } <span class="hljs-keyword">catch</span> (err) {
+      <span class="hljs-comment">// Perform actual error handling.</span>
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(err);
     }
-    stream.end();
+    stream.<span class="hljs-title function_">end</span>();
   }
 
-  stream.respondWithFile(<span class="hljs-string">'/some/file'</span>,
+  stream.<span class="hljs-title function_">respondWithFile</span>(<span class="hljs-string">'/some/file'</span>,
                          { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> },
                          { statCheck, onError });
 });</code></pre>
@@ -38354,14 +41731,14 @@ by returning <code>false</code>. For instance, a conditional request may check t
 results to determine if the file has been modified to return an appropriate
 <code>304</code> response:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">statCheck</span>(<span class="hljs-params">stat, headers</span>) </span>{
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">statCheck</span>(<span class="hljs-params">stat, headers</span>) {
     <span class="hljs-comment">// Check the stat here...</span>
-    stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">304</span> });
+    stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">304</span> });
     <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>; <span class="hljs-comment">// Cancel the send operation</span>
   }
-  stream.respondWithFile(<span class="hljs-string">'/some/file'</span>,
+  stream.<span class="hljs-title function_">respondWithFile</span>(<span class="hljs-string">'/some/file'</span>,
                          { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> },
                          { statCheck });
 });</code></pre>
@@ -38381,16 +41758,16 @@ close when the final <code>DATA</code> frame is transmitted. User code must call
 <code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the
 <code>Http2Stream</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respondWithFile(<span class="hljs-string">'/some/file'</span>,
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respondWithFile</span>(<span class="hljs-string">'/some/file'</span>,
                          { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> },
                          { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
-  stream.on(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
-    stream.sendTrailers({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">sendTrailers</span>({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
   });
 });</code></pre>
-<h3>Class: <code>Http2Server</code><span><a class="mark" href="#http2_class_http2server" id="http2_class_http2server">#</a></span></h3>
+<h4>Class: <code>Http2Server</code><span><a class="mark" href="#http2_class_http2server" id="http2_class_http2server">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38400,7 +41777,7 @@ server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function"
 <p>Instances of <code>Http2Server</code> are created using the <code>http2.createServer()</code>
 function. The <code>Http2Server</code> class is not exported directly by the <code>http2</code>
 module.</p>
-<h4>Event: <code>'checkContinue'</code><span><a class="mark" href="#http2_event_checkcontinue" id="http2_event_checkcontinue">#</a></span></h4>
+<h5>Event: <code>'checkContinue'</code><span><a class="mark" href="#http2_event_checkcontinue" id="http2_event_checkcontinue">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -38419,7 +41796,7 @@ HTTP response (e.g. 400 Bad Request) if the client should not continue to send
 the request body.</p>
 <p>When this event is emitted and handled, the <a href="#http2_event_request"><code>'request'</code></a> event will
 not be emitted.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#http2_event_connection" id="http2_event_connection">#</a></span></h3>
+<h5>Event: <code>'connection'</code><span><a class="mark" href="#http2_event_connection" id="http2_event_connection">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38431,7 +41808,7 @@ typically an object of type <a href="#net_class_net_socket"><code>net.Socket</co
 access this event.</p>
 <p>This event can also be explicitly emitted by users to inject connections
 into the HTTP server. In that case, any <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream can be passed.</p>
-<h4>Event: <code>'request'</code><span><a class="mark" href="#http2_event_request" id="http2_event_request">#</a></span></h4>
+<h5>Event: <code>'request'</code><span><a class="mark" href="#http2_event_request" id="http2_event_request">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38441,54 +41818,68 @@ into the HTTP server. In that case, any <a href="#stream_class_stream_duplex"><c
 </ul>
 <p>Emitted each time there is a request. There may be multiple requests
 per session. See the <a href="#http2_compatibility_api">Compatibility API</a>.</p>
-<h4>Event: <code>'session'</code><span><a class="mark" href="#http2_event_session" id="http2_event_session">#</a></span></h4>
+<h5>Event: <code>'session'</code><span><a class="mark" href="#http2_event_session" id="http2_event_session">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'session'</code> event is emitted when a new <code>Http2Session</code> is created by the
 <code>Http2Server</code>.</p>
-<h4>Event: <code>'sessionError'</code><span><a class="mark" href="#http2_event_sessionerror" id="http2_event_sessionerror">#</a></span></h4>
+<h5>Event: <code>'sessionError'</code><span><a class="mark" href="#http2_event_sessionerror" id="http2_event_sessionerror">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'sessionError'</code> event is emitted when an <code>'error'</code> event is emitted by
 an <code>Http2Session</code> object associated with the <code>Http2Server</code>.</p>
-<h4>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream_1" id="http2_event_stream_1">#</a></span></h4>
+<h5>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream_1" id="http2_event_stream_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
+<ul>
+<li><code>stream</code> <a href="#http2_class_http2stream" class="type">&#x3C;Http2Stream></a> A reference to the stream</li>
+<li><code>headers</code> <a href="#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a> An object describing the headers</li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The associated numeric flags</li>
+<li><code>rawHeaders</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> An array containing the raw header names followed by
+their respective values.</li>
+</ul>
 <p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by
 an <code>Http2Session</code> associated with the server.</p>
+<p>See also <a href="#http2_event_stream"><code>Http2Session</code>'s <code>'stream'</code> event</a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> {
   HTTP2_HEADER_METHOD,
   HTTP2_HEADER_PATH,
   HTTP2_HEADER_STATUS,
   HTTP2_HEADER_CONTENT_TYPE
-} = http2.constants;
+} = http2.<span class="hljs-property">constants</span>;
 
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
   <span class="hljs-keyword">const</span> method = headers[HTTP2_HEADER_METHOD];
   <span class="hljs-keyword">const</span> path = headers[HTTP2_HEADER_PATH];
   <span class="hljs-comment">// ...</span>
-  stream.respond({
+  stream.<span class="hljs-title function_">respond</span>({
     [HTTP2_HEADER_STATUS]: <span class="hljs-number">200</span>,
     [HTTP2_HEADER_CONTENT_TYPE]: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   });
-  stream.write(<span class="hljs-string">'hello '</span>);
-  stream.end(<span class="hljs-string">'world'</span>);
+  stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello '</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'world'</span>);
 });</code></pre>
-<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_2" id="http2_event_timeout_2">#</a></span></h4>
+<h5>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_2" id="http2_event_timeout_2">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.4.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v8.4.0</td>
+<td><p><span>Added in: v8.4.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for
 a given number of milliseconds set using <code>http2server.setTimeout()</code>.
-<strong>Default:</strong> 2 minutes.</p>
-<p>To change the default timeout use the <a href="#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout</code></a>
-flag.</p>
-<h4><code>server.close([callback])</code><span><a class="mark" href="#http2_server_close_callback" id="http2_server_close_callback">#</a></span></h4>
+<strong>Default:</strong> 0 (no timeout)</p>
+<h5><code>server.close([callback])</code><span><a class="mark" href="#http2_server_close_callback" id="http2_server_close_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38502,12 +41893,20 @@ all active sessions.</p>
 <p>If <code>callback</code> is provided, it is not invoked until all active sessions have been
 closed, although the server has already stopped allowing new sessions. See
 <a href="#net_server_close_callback"><code>net.Server.close()</code></a> for more details.</p>
-<h4><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http2_server_settimeout_msecs_callback" id="http2_server_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http2_server_settimeout_msecs_callback" id="http2_server_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.4.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v8.4.0</td>
+<td><p><span>Added in: v8.4.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>msecs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>120000</code> (2 minutes)</li>
+<li><code>msecs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> 0 (no timeout)</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li>Returns: <a href="#http2_class_http2server" class="type">&#x3C;Http2Server></a></li>
 </ul>
@@ -38515,11 +41914,39 @@ closed, although the server has already stopped allowing new sessions. See
 and sets a callback function that is called when there is no activity
 on the <code>Http2Server</code> after <code>msecs</code> milliseconds.</p>
 <p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>
-<p>In case of no callback function were assigned, a new <code>ERR_INVALID_CALLBACK</code>
+<p>In case if <code>callback</code> is not a function, a new <code>ERR_INVALID_CALLBACK</code>
 error will be thrown.</p>
-<p>To change the default timeout use the <a href="#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout</code></a>
-flag.</p>
-<h3>Class: <code>Http2SecureServer</code><span><a class="mark" href="#http2_class_http2secureserver" id="http2_class_http2secureserver">#</a></span></h3>
+<h5><code>server.timeout</code><span><a class="mark" href="#http2_server_timeout" id="http2_server_timeout">#</a></span></h5>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v8.4.0</td>
+<td><p><span>Added in: v8.4.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Timeout in milliseconds. <strong>Default:</strong> 0 (no timeout)</li>
+</ul>
+<p>The number of milliseconds of inactivity before a socket is presumed
+to have timed out.</p>
+<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>
+<p>The socket timeout logic is set up on connection, so changing this
+value only affects new connections to the server, not any existing connections.</p>
+<h5><code>server.updateSettings([settings])</code><span><a class="mark" href="#http2_server_updatesettings_settings" id="http2_server_updatesettings_settings">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>settings</code> <a href="#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a></li>
+</ul>
+<p>Used to update the server with the provided settings.</p>
+<p>Throws <code>ERR_HTTP2_INVALID_SETTING_VALUE</code> for invalid <code>settings</code> values.</p>
+<p>Throws <code>ERR_INVALID_ARG_TYPE</code> for invalid <code>settings</code> argument.</p>
+<h4>Class: <code>Http2SecureServer</code><span><a class="mark" href="#http2_class_http2secureserver" id="http2_class_http2secureserver">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38529,7 +41956,7 @@ flag.</p>
 <p>Instances of <code>Http2SecureServer</code> are created using the
 <code>http2.createSecureServer()</code> function. The <code>Http2SecureServer</code> class is not
 exported directly by the <code>http2</code> module.</p>
-<h4>Event: <code>'checkContinue'</code><span><a class="mark" href="#http2_event_checkcontinue_1" id="http2_event_checkcontinue_1">#</a></span></h4>
+<h5>Event: <code>'checkContinue'</code><span><a class="mark" href="#http2_event_checkcontinue_1" id="http2_event_checkcontinue_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -38548,7 +41975,7 @@ HTTP response (e.g. 400 Bad Request) if the client should not continue to send
 the request body.</p>
 <p>When this event is emitted and handled, the <a href="#http2_event_request"><code>'request'</code></a> event will
 not be emitted.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#http2_event_connection_1" id="http2_event_connection_1">#</a></span></h3>
+<h5>Event: <code>'connection'</code><span><a class="mark" href="#http2_event_connection_1" id="http2_event_connection_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38560,7 +41987,7 @@ handshake begins. <code>socket</code> is typically an object of type <a href="#n
 Usually users will not want to access this event.</p>
 <p>This event can also be explicitly emitted by users to inject connections
 into the HTTP server. In that case, any <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream can be passed.</p>
-<h4>Event: <code>'request'</code><span><a class="mark" href="#http2_event_request_1" id="http2_event_request_1">#</a></span></h4>
+<h5>Event: <code>'request'</code><span><a class="mark" href="#http2_event_request_1" id="http2_event_request_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38570,54 +41997,62 @@ into the HTTP server. In that case, any <a href="#stream_class_stream_duplex"><c
 </ul>
 <p>Emitted each time there is a request. There may be multiple requests
 per session. See the <a href="#http2_compatibility_api">Compatibility API</a>.</p>
-<h4>Event: <code>'session'</code><span><a class="mark" href="#http2_event_session_1" id="http2_event_session_1">#</a></span></h4>
+<h5>Event: <code>'session'</code><span><a class="mark" href="#http2_event_session_1" id="http2_event_session_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'session'</code> event is emitted when a new <code>Http2Session</code> is created by the
 <code>Http2SecureServer</code>.</p>
-<h4>Event: <code>'sessionError'</code><span><a class="mark" href="#http2_event_sessionerror_1" id="http2_event_sessionerror_1">#</a></span></h4>
+<h5>Event: <code>'sessionError'</code><span><a class="mark" href="#http2_event_sessionerror_1" id="http2_event_sessionerror_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'sessionError'</code> event is emitted when an <code>'error'</code> event is emitted by
 an <code>Http2Session</code> object associated with the <code>Http2SecureServer</code>.</p>
-<h4>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream_2" id="http2_event_stream_2">#</a></span></h4>
+<h5>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream_2" id="http2_event_stream_2">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
+<ul>
+<li><code>stream</code> <a href="#http2_class_http2stream" class="type">&#x3C;Http2Stream></a> A reference to the stream</li>
+<li><code>headers</code> <a href="#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a> An object describing the headers</li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The associated numeric flags</li>
+<li><code>rawHeaders</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> An array containing the raw header names followed by
+their respective values.</li>
+</ul>
 <p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by
 an <code>Http2Session</code> associated with the server.</p>
+<p>See also <a href="#http2_event_stream"><code>Http2Session</code>'s <code>'stream'</code> event</a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> {
   HTTP2_HEADER_METHOD,
   HTTP2_HEADER_PATH,
   HTTP2_HEADER_STATUS,
   HTTP2_HEADER_CONTENT_TYPE
-} = http2.constants;
+} = http2.<span class="hljs-property">constants</span>;
 
-<span class="hljs-keyword">const</span> options = getOptionsSomehow();
+<span class="hljs-keyword">const</span> options = <span class="hljs-title function_">getOptionsSomehow</span>();
 
-<span class="hljs-keyword">const</span> server = http2.createSecureServer(options);
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>(options);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
   <span class="hljs-keyword">const</span> method = headers[HTTP2_HEADER_METHOD];
   <span class="hljs-keyword">const</span> path = headers[HTTP2_HEADER_PATH];
   <span class="hljs-comment">// ...</span>
-  stream.respond({
+  stream.<span class="hljs-title function_">respond</span>({
     [HTTP2_HEADER_STATUS]: <span class="hljs-number">200</span>,
     [HTTP2_HEADER_CONTENT_TYPE]: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   });
-  stream.write(<span class="hljs-string">'hello '</span>);
-  stream.end(<span class="hljs-string">'world'</span>);
+  stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello '</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'world'</span>);
 });</code></pre>
-<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_3" id="http2_event_timeout_3">#</a></span></h4>
+<h5>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_3" id="http2_event_timeout_3">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for
 a given number of milliseconds set using <code>http2secureServer.setTimeout()</code>.
 <strong>Default:</strong> 2 minutes.</p>
-<h4>Event: <code>'unknownProtocol'</code><span><a class="mark" href="#http2_event_unknownprotocol" id="http2_event_unknownprotocol">#</a></span></h4>
+<h5>Event: <code>'unknownProtocol'</code><span><a class="mark" href="#http2_event_unknownprotocol" id="http2_event_unknownprotocol">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38627,7 +42062,7 @@ receives the socket for handling. If no listener is registered for this event,
 the connection is terminated. A timeout may be specified using the
 <code>'unknownProtocolTimeout'</code> option passed to <a href="#http2_http2_createsecureserver_options_onrequesthandler"><code>http2.createSecureServer()</code></a>.
 See the <a href="#http2_compatibility_api">Compatibility API</a>.</p>
-<h4><code>server.close([callback])</code><span><a class="mark" href="#http2_server_close_callback_1" id="http2_server_close_callback_1">#</a></span></h4>
+<h5><code>server.close([callback])</code><span><a class="mark" href="#http2_server_close_callback_1" id="http2_server_close_callback_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38641,7 +42076,7 @@ all active sessions.</p>
 <p>If <code>callback</code> is provided, it is not invoked until all active sessions have been
 closed, although the server has already stopped allowing new sessions. See
 <a href="#tls_server_close_callback"><code>tls.Server.close()</code></a> for more details.</p>
-<h4><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http2_server_settimeout_msecs_callback_1" id="http2_server_settimeout_msecs_callback_1">#</a></span></h4>
+<h5><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http2_server_settimeout_msecs_callback_1" id="http2_server_settimeout_msecs_callback_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -38654,23 +42089,55 @@ closed, although the server has already stopped allowing new sessions. See
 and sets a callback function that is called when there is no activity
 on the <code>Http2SecureServer</code> after <code>msecs</code> milliseconds.</p>
 <p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>
-<p>In case of no callback function were assigned, a new <code>ERR_INVALID_CALLBACK</code>
+<p>In case if <code>callback</code> is not a function, a new <code>ERR_INVALID_CALLBACK</code>
 error will be thrown.</p>
-<h3><code>http2.createServer(options[, onRequestHandler])</code><span><a class="mark" href="#http2_http2_createserver_options_onrequesthandler" id="http2_http2_createserver_options_onrequesthandler">#</a></span></h3>
+<h5><code>server.timeout</code><span><a class="mark" href="#http2_server_timeout_1" id="http2_server_timeout_1">#</a></span></h5>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v8.4.0</td>
+<td><p><span>Added in: v8.4.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Timeout in milliseconds. <strong>Default:</strong> 0 (no timeout)</li>
+</ul>
+<p>The number of milliseconds of inactivity before a socket is presumed
+to have timed out.</p>
+<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>
+<p>The socket timeout logic is set up on connection, so changing this
+value only affects new connections to the server, not any existing connections.</p>
+<h5><code>server.updateSettings([settings])</code><span><a class="mark" href="#http2_server_updatesettings_settings_1" id="http2_server_updatesettings_settings_1">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>settings</code> <a href="#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a></li>
+</ul>
+<p>Used to update the server with the provided settings.</p>
+<p>Throws <code>ERR_HTTP2_INVALID_SETTING_VALUE</code> for invalid <code>settings</code> values.</p>
+<p>Throws <code>ERR_INVALID_ARG_TYPE</code> for invalid <code>settings</code> argument.</p>
+<h4><code>http2.createServer(options[, onRequestHandler])</code><span><a class="mark" href="#http2_http2_createserver_options_onrequesthandler" id="http2_http2_createserver_options_onrequesthandler">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.21.0</td>
+<tr><td>v14.16.0</td>
 <td><p>Added <code>unknownProtocolTimeout</code> option with a default of 10000.</p></td></tr>
-<tr><td>v12.18.0</td>
-<td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.0.0</td>
+<td><p>The <code>PADDING_STRATEGY_CALLBACK</code> has been made equivalent to providing <code>PADDING_STRATEGY_ALIGNED</code> and <code>selectPadding</code> has been removed.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>Added <code>maxSessionRejectedStreams</code> option with a default of 100.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>Added <code>maxSessionInvalidFrames</code> option with a default of 1000.</p></td></tr>
 <tr><td>v12.4.0</td>
 <td><p>The <code>options</code> parameter now supports <code>net.createServer()</code> options.</p></td></tr>
+<tr><td>v14.4.0, v12.18.0, v10.21.0</td>
+<td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
 <tr><td>v9.6.0</td>
 <td><p>Added the <code>Http1IncomingMessage</code> and <code>Http1ServerResponse</code> option.</p></td></tr>
 <tr><td>v8.9.3</td>
@@ -38712,21 +42179,16 @@ and the stream being closed and destroyed.</li>
 padding to use for <code>HEADERS</code> and <code>DATA</code> frames. <strong>Default:</strong>
 <code>http2.constants.PADDING_STRATEGY_NONE</code>. Value may be one of:
 <ul>
-<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: Specifies that no padding is
-to be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: Specifies that the maximum
-amount of padding, as determined by the internal implementation, is to
-be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_CALLBACK</code>: Specifies that the user
-provided <code>options.selectPadding()</code> callback is to be used to determine
-the amount of padding.</li>
-<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Will <em>attempt</em> to apply
-enough padding to ensure that the total frame length, including the
-9-byte header, is a multiple of 8. For each frame, however, there is a
-maximum allowed number of padding bytes that is determined by current
-flow control state and settings. If this maximum is less than the
-calculated amount needed to ensure alignment, the maximum will be used
-and the total frame length will <em>not</em> necessarily be aligned at 8 bytes.</li>
+<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: No padding is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: The maximum amount of padding,
+determined by the internal implementation, is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Attempts to apply enough
+padding to ensure that the total frame length, including the 9-byte
+header, is a multiple of 8. For each frame, there is a maximum allowed
+number of padding bytes that is determined by current flow control state
+and settings. If this maximum is less than the calculated amount needed to
+ensure alignment, the maximum is used and the total frame length is not
+necessarily aligned at 8 bytes.</li>
 </ul>
 </li>
 <li><code>peerMaxConcurrentStreams</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the maximum number of concurrent
@@ -38742,9 +42204,6 @@ Each rejection is associated with an <code>NGHTTP2_ENHANCE_YOUR_CALM</code>
 error that should tell the peer to not open any more streams, continuing
 to open streams is therefore regarded as a sign of a misbehaving peer.
 <strong>Default:</strong> <code>100</code>.</li>
-<li><code>selectPadding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> When <code>options.paddingStrategy</code> is equal to
-<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, provides the callback function
-used to determine the padding. See <a href="#http2_using_options_selectpadding">Using <code>options.selectPadding()</code></a>.</li>
 <li><code>settings</code> <a href="#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a> The initial settings to send to the
 remote peer upon connection.</li>
 <li><code>Http1IncomingMessage</code> <a href="#http_class_http_incomingmessage" class="type">&#x3C;http.IncomingMessage></a> Specifies the
@@ -38783,30 +42242,32 @@ with browser clients.</p>
 <span class="hljs-comment">// Since there are no browsers known that support</span>
 <span class="hljs-comment">// unencrypted HTTP/2, the use of `http2.createSecureServer()`</span>
 <span class="hljs-comment">// is necessary when communicating with browser clients.</span>
-<span class="hljs-keyword">const</span> server = http2.createServer();
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
-  stream.respond({
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
   });
-  stream.end(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
 });
 
-server.listen(<span class="hljs-number">80</span>);</code></pre>
-<h3><code>http2.createSecureServer(options[, onRequestHandler])</code><span><a class="mark" href="#http2_http2_createsecureserver_options_onrequesthandler" id="http2_http2_createsecureserver_options_onrequesthandler">#</a></span></h3>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">80</span>);</code></pre>
+<h4><code>http2.createSecureServer(options[, onRequestHandler])</code><span><a class="mark" href="#http2_http2_createsecureserver_options_onrequesthandler" id="http2_http2_createsecureserver_options_onrequesthandler">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.21.0</td>
+<tr><td>v14.16.0</td>
 <td><p>Added <code>unknownProtocolTimeout</code> option with a default of 10000.</p></td></tr>
-<tr><td>v12.18.0</td>
-<td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.0.0</td>
+<td><p>The <code>PADDING_STRATEGY_CALLBACK</code> has been made equivalent to providing <code>PADDING_STRATEGY_ALIGNED</code> and <code>selectPadding</code> has been removed.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>Added <code>maxSessionRejectedStreams</code> option with a default of 100.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>Added <code>maxSessionInvalidFrames</code> option with a default of 1000.</p></td></tr>
+<tr><td>v14.4.0, v12.18.0, v10.21.0</td>
+<td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
 <tr><td>v10.12.0</td>
 <td><p>Added the <code>origins</code> option to automatically send an <code>ORIGIN</code> frame on <code>Http2Session</code> startup.</p></td></tr>
 <tr><td>v8.9.3</td>
@@ -38852,21 +42313,16 @@ and the stream being closed and destroyed.</li>
 padding to use for <code>HEADERS</code> and <code>DATA</code> frames. <strong>Default:</strong>
 <code>http2.constants.PADDING_STRATEGY_NONE</code>. Value may be one of:
 <ul>
-<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: Specifies that no padding is
-to be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: Specifies that the maximum
-amount of padding, as determined by the internal implementation, is to
-be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_CALLBACK</code>: Specifies that the user
-provided <code>options.selectPadding()</code> callback is to be used to determine
-the amount of padding.</li>
-<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Will <em>attempt</em> to apply
-enough padding to ensure that the total frame length, including the
-9-byte header, is a multiple of 8. For each frame, however, there is a
-maximum allowed number of padding bytes that is determined by current
-flow control state and settings. If this maximum is less than the
-calculated amount needed to ensure alignment, the maximum will be used
-and the total frame length will <em>not</em> necessarily be aligned at 8 bytes.</li>
+<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: No padding is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: The maximum amount of padding,
+determined by the internal implementation, is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Attempts to apply enough
+padding to ensure that the total frame length, including the
+9-byte header, is a multiple of 8. For each frame, there is a maximum
+allowed number of padding bytes that is determined by current flow control
+state and settings. If this maximum is less than the calculated amount
+needed to ensure alignment, the maximum is used and the total frame length
+is not necessarily aligned at 8 bytes.</li>
 </ul>
 </li>
 <li><code>peerMaxConcurrentStreams</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the maximum number of concurrent
@@ -38882,9 +42338,6 @@ Each rejection is associated with an <code>NGHTTP2_ENHANCE_YOUR_CALM</code>
 error that should tell the peer to not open any more streams, continuing
 to open streams is therefore regarded as a sign of a misbehaving peer.
 <strong>Default:</strong> <code>100</code>.</li>
-<li><code>selectPadding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> When <code>options.paddingStrategy</code> is equal to
-<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, provides the callback function
-used to determine the padding. See <a href="#http2_using_options_selectpadding">Using <code>options.selectPadding()</code></a>.</li>
 <li><code>settings</code> <a href="#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a> The initial settings to send to the
 remote peer upon connection.</li>
 <li>...: Any <a href="#tls_tls_createserver_options_secureconnectionlistener"><code>tls.createServer()</code></a> options can be provided. For
@@ -38906,30 +42359,32 @@ instances.</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">const</span> options = {
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'server-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'server-cert.pem'</span>)
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-cert.pem'</span>)
 };
 
 <span class="hljs-comment">// Create a secure HTTP/2 server</span>
-<span class="hljs-keyword">const</span> server = http2.createSecureServer(options);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>(options);
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
-  stream.respond({
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
   });
-  stream.end(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
 });
 
-server.listen(<span class="hljs-number">80</span>);</code></pre>
-<h3><code>http2.connect(authority[, options][, listener])</code><span><a class="mark" href="#http2_http2_connect_authority_options_listener" id="http2_http2_connect_authority_options_listener">#</a></span></h3>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">80</span>);</code></pre>
+<h4><code>http2.connect(authority[, options][, listener])</code><span><a class="mark" href="#http2_http2_connect_authority_options_listener" id="http2_http2_connect_authority_options_listener">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.21.0</td>
+<tr><td>v14.16.0</td>
 <td><p>Added <code>unknownProtocolTimeout</code> option with a default of 10000.</p></td></tr>
-<tr><td>v12.18.0</td>
+<tr><td>v13.0.0</td>
+<td><p>The <code>PADDING_STRATEGY_CALLBACK</code> has been made equivalent to providing <code>PADDING_STRATEGY_ALIGNED</code> and <code>selectPadding</code> has been removed.</p></td></tr>
+<tr><td>v14.4.0, v12.18.0, v10.21.0</td>
 <td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
 <tr><td>v8.9.3</td>
 <td><p>Added the <code>maxOutstandingPings</code> option with a default limit of 10.</p></td></tr>
@@ -38971,7 +42426,7 @@ unacknowledged pings. <strong>Default:</strong> <code>10</code>.</li>
 streams the client will accept at any given time. Once the current number of
 currently reserved push streams exceeds reaches this limit, new push streams
 sent by the server will be automatically rejected. The minimum allowed value
-is 0. The maximum allowed value is 2<sup>32</sup>-1. A negative value sets
+is 0. The maximum allowed value is 22<sup>32</sup>-1. A negative value sets
 this option to the maximum allowed value. <strong>Default:</strong> <code>200</code>.</li>
 <li><code>maxSendHeaderBlockLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the maximum allowed size for a
 serialized, compressed block of headers. Attempts to send headers that
@@ -38981,30 +42436,22 @@ and the stream being closed and destroyed.</li>
 padding to use for <code>HEADERS</code> and <code>DATA</code> frames. <strong>Default:</strong>
 <code>http2.constants.PADDING_STRATEGY_NONE</code>. Value may be one of:
 <ul>
-<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: Specifies that no padding is
-to be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: Specifies that the maximum
-amount of padding, as determined by the internal implementation, is to
-be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_CALLBACK</code>: Specifies that the user
-provided <code>options.selectPadding()</code> callback is to be used to determine
-the amount of padding.</li>
-<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Will <em>attempt</em> to apply
-enough padding to ensure that the total frame length, including the
-9-byte header, is a multiple of 8. For each frame, however, there is a
-maximum allowed number of padding bytes that is determined by current
-flow control state and settings. If this maximum is less than the
-calculated amount needed to ensure alignment, the maximum will be used
-and the total frame length will <em>not</em> necessarily be aligned at 8 bytes.</li>
+<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: No padding is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: The maximum amount of padding,
+determined by the internal implementation, is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Attempts to apply enough
+padding to ensure that the total frame length, including the
+9-byte header, is a multiple of 8. For each frame, there is a maximum
+allowed number of padding bytes that is determined by current flow control
+state and settings. If this maximum is less than the calculated amount
+needed to ensure alignment, the maximum is used and the total frame length
+is not necessarily aligned at 8 bytes.</li>
 </ul>
 </li>
 <li><code>peerMaxConcurrentStreams</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the maximum number of concurrent
 streams for the remote peer as if a <code>SETTINGS</code> frame had been received. Will
 be overridden if the remote peer sets its own value for
 <code>maxConcurrentStreams</code>. <strong>Default:</strong> <code>100</code>.</li>
-<li><code>selectPadding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> When <code>options.paddingStrategy</code> is equal to
-<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, provides the callback function
-used to determine the padding. See <a href="#http2_using_options_selectpadding">Using <code>options.selectPadding()</code></a>.</li>
 <li><code>protocol</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The protocol to connect with, if not set in the
 <code>authority</code>. Value may be either <code>'http:'</code> or <code>'https:'</code>. <strong>Default:</strong>
 <code>'https:'</code></li>
@@ -39026,17 +42473,16 @@ the socket has not been destroyed by that time the server will destroy it.
 </ul>
 <p>Returns a <code>ClientHttp2Session</code> instance.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://localhost:1234'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://localhost:1234'</span>);
 
 <span class="hljs-comment">/* Use the client */</span>
 
-client.close();</code></pre>
-<h3><code>http2.constants</code><span><a class="mark" href="#http2_http2_constants" id="http2_http2_constants">#</a></span></h3>
+client.<span class="hljs-title function_">close</span>();</code></pre>
+<h4><code>http2.constants</code><span><a class="mark" href="#http2_http2_constants" id="http2_http2_constants">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
-<h4>Error codes for <code>RST_STREAM</code> and <code>GOAWAY</code><span><a class="mark" href="#http2_error_codes_for_rst_stream_and_goaway" id="http2_error_codes_for_rst_stream_and_goaway">#</a></span></h4>
-<p><a id="error_codes"></a></p>
+<h5>Error codes for <code>RST_STREAM</code> and <code>GOAWAY</code><span><a class="mark" href="#http2_error_codes_for_rst_stream_and_goaway" id="http2_error_codes_for_rst_stream_and_goaway">#</a></span></h5>
 
 
 
@@ -39120,7 +42566,7 @@ client.close();</code></pre>
 <table><thead><tr><th>Value</th><th>Name</th><th>Constant</th></tr></thead><tbody><tr><td><code>0x00</code></td><td>No Error</td><td><code>http2.constants.NGHTTP2_NO_ERROR</code></td></tr><tr><td><code>0x01</code></td><td>Protocol Error</td><td><code>http2.constants.NGHTTP2_PROTOCOL_ERROR</code></td></tr><tr><td><code>0x02</code></td><td>Internal Error</td><td><code>http2.constants.NGHTTP2_INTERNAL_ERROR</code></td></tr><tr><td><code>0x03</code></td><td>Flow Control Error</td><td><code>http2.constants.NGHTTP2_FLOW_CONTROL_ERROR</code></td></tr><tr><td><code>0x04</code></td><td>Settings Timeout</td><td><code>http2.constants.NGHTTP2_SETTINGS_TIMEOUT</code></td></tr><tr><td><code>0x05</code></td><td>Stream Closed</td><td><code>http2.constants.NGHTTP2_STREAM_CLOSED</code></td></tr><tr><td><code>0x06</code></td><td>Frame Size Error</td><td><code>http2.constants.NGHTTP2_FRAME_SIZE_ERROR</code></td></tr><tr><td><code>0x07</code></td><td>Refused Stream</td><td><code>http2.constants.NGHTTP2_REFUSED_STREAM</code></td></tr><tr><td><code>0x08</code></td><td>Cancel</td><td><code>http2.constants.NGHTTP2_CANCEL</code></td></tr><tr><td><code>0x09</code></td><td>Compression Error</td><td><code>http2.constants.NGHTTP2_COMPRESSION_ERROR</code></td></tr><tr><td><code>0x0a</code></td><td>Connect Error</td><td><code>http2.constants.NGHTTP2_CONNECT_ERROR</code></td></tr><tr><td><code>0x0b</code></td><td>Enhance Your Calm</td><td><code>http2.constants.NGHTTP2_ENHANCE_YOUR_CALM</code></td></tr><tr><td><code>0x0c</code></td><td>Inadequate Security</td><td><code>http2.constants.NGHTTP2_INADEQUATE_SECURITY</code></td></tr><tr><td><code>0x0d</code></td><td>HTTP/1.1 Required</td><td><code>http2.constants.NGHTTP2_HTTP_1_1_REQUIRED</code></td></tr></tbody></table>
 <p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for
 a given number of milliseconds set using <code>http2server.setTimeout()</code>.</p>
-<h3><code>http2.getDefaultSettings()</code><span><a class="mark" href="#http2_http2_getdefaultsettings" id="http2_http2_getdefaultsettings">#</a></span></h3>
+<h4><code>http2.getDefaultSettings()</code><span><a class="mark" href="#http2_http2_getdefaultsettings" id="http2_http2_getdefaultsettings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39130,7 +42576,7 @@ a given number of milliseconds set using <code>http2server.setTimeout()</code>.<
 <p>Returns an object containing the default settings for an <code>Http2Session</code>
 instance. This method returns a new object instance every time it is called
 so instances returned may be safely modified for use.</p>
-<h3><code>http2.getPackedSettings([settings])</code><span><a class="mark" href="#http2_http2_getpackedsettings_settings" id="http2_http2_getpackedsettings_settings">#</a></span></h3>
+<h4><code>http2.getPackedSettings([settings])</code><span><a class="mark" href="#http2_http2_getpackedsettings_settings" id="http2_http2_getpackedsettings_settings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39143,21 +42589,31 @@ HTTP/2 settings as specified in the <a href="https://tools.ietf.org/html/rfc7540
 for use with the <code>HTTP2-Settings</code> header field.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
-<span class="hljs-keyword">const</span> packed = http2.getPackedSettings({ <span class="hljs-attr">enablePush</span>: <span class="hljs-literal">false</span> });
+<span class="hljs-keyword">const</span> packed = http2.<span class="hljs-title function_">getPackedSettings</span>({ <span class="hljs-attr">enablePush</span>: <span class="hljs-literal">false</span> });
 
-<span class="hljs-built_in">console</span>.log(packed.toString(<span class="hljs-string">'base64'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(packed.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'base64'</span>));
 <span class="hljs-comment">// Prints: AAIAAAAA</span></code></pre>
-<h3><code>http2.getUnpackedSettings(buf)</code><span><a class="mark" href="#http2_http2_getunpackedsettings_buf" id="http2_http2_getunpackedsettings_buf">#</a></span></h3>
+<h4><code>http2.getUnpackedSettings(buf)</code><span><a class="mark" href="#http2_http2_getunpackedsettings_buf" id="http2_http2_getunpackedsettings_buf">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <ul>
-<li><code>buf</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a> The packed settings.</li>
+<li><code>buf</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> The packed settings.</li>
 <li>Returns: <a href="#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a></li>
 </ul>
 <p>Returns a <a href="#http2_settings_object">HTTP/2 Settings Object</a> containing the deserialized settings from
 the given <code>Buffer</code> as generated by <code>http2.getPackedSettings()</code>.</p>
-<h3>Headers object<span><a class="mark" href="#http2_headers_object" id="http2_headers_object">#</a></span></h3>
+<h4><code>http2.sensitiveHeaders</code><span><a class="mark" href="#http2_http2_sensitiveheaders" id="http2_http2_sensitiveheaders">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+</ul>
+<p>This symbol can be set as a property on the HTTP/2 headers object with an array
+value in order to provide a list of headers considered sensitive.
+See <a href="#http2_sensitive_headers">Sensitive headers</a> for more details.</p>
+<h4>Headers object<span><a class="mark" href="#http2_headers_object" id="http2_headers_object">#</a></span></h4>
 <p>Headers are represented as own-properties on JavaScript objects. The property
 keys will be serialized to lower-case. Property values should be strings (if
 they are not they will be coerced to strings) or an <code>Array</code> of strings (in order
@@ -39168,7 +42624,7 @@ to send more than one value per header field).</p>
   <span class="hljs-string">'ABC'</span>: [<span class="hljs-string">'has'</span>, <span class="hljs-string">'more'</span>, <span class="hljs-string">'than'</span>, <span class="hljs-string">'one'</span>, <span class="hljs-string">'value'</span>]
 };
 
-stream.respond(headers);</code></pre>
+stream.<span class="hljs-title function_">respond</span>(headers);</code></pre>
 <p>Header objects passed to callback functions will have a <code>null</code> prototype. This
 means that normal JavaScript object methods such as
 <code>Object.prototype.toString()</code> and <code>Object.prototype.hasOwnProperty()</code> will
@@ -39191,12 +42647,31 @@ discarded.</li>
 <li>For all other headers, the values are joined together with ', '.</li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers[<span class="hljs-string">':path'</span>]);
-  <span class="hljs-built_in">console</span>.log(headers.ABC);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers[<span class="hljs-string">':path'</span>]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers.<span class="hljs-property">ABC</span>);
 });</code></pre>
-<h3>Settings object<span><a class="mark" href="#http2_settings_object" id="http2_settings_object">#</a></span></h3>
+<h5>Sensitive headers<span><a class="mark" href="#http2_sensitive_headers" id="http2_sensitive_headers">#</a></span></h5>
+<p>HTTP2 headers can be marked as sensitive, which means that the HTTP/2
+header compression algorithm will never index them. This can make sense for
+header values with low entropy and that may be considered valuable to an
+attacker, for example <code>Cookie</code> or <code>Authorization</code>. To achieve this, add
+the header name to the <code>[http2.sensitiveHeaders]</code> property as an array:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> headers = {
+  <span class="hljs-string">':status'</span>: <span class="hljs-string">'200'</span>,
+  <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text-plain'</span>,
+  <span class="hljs-string">'cookie'</span>: <span class="hljs-string">'some-cookie'</span>,
+  <span class="hljs-string">'other-sensitive-header'</span>: <span class="hljs-string">'very secret data'</span>,
+  [http2.<span class="hljs-property">sensitiveHeaders</span>]: [<span class="hljs-string">'cookie'</span>, <span class="hljs-string">'other-sensitive-header'</span>]
+};
+
+stream.<span class="hljs-title function_">respond</span>(headers);</code></pre>
+<p>For some headers, such as <code>Authorization</code> and short <code>Cookie</code> headers,
+this flag is set automatically.</p>
+<p>This property is also set for received headers. It will contain the names of
+all headers marked as sensitive, including ones marked that way automatically.</p>
+<h4>Settings object<span><a class="mark" href="#http2_settings_object" id="http2_settings_object">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -39220,7 +42695,7 @@ properties.</p>
 <ul>
 <li><code>headerTableSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the maximum number of bytes used for
 header compression. The minimum allowed value is 0. The maximum allowed value
-is 2<sup>32</sup>-1. <strong>Default:</strong> <code>4096</code>.</li>
+is 22<sup>32</sup>-1. <strong>Default:</strong> <code>4096</code>.</li>
 <li><code>enablePush</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Specifies <code>true</code> if HTTP/2 Push Streams are to be
 permitted on the <code>Http2Session</code> instances. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>initialWindowSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the <em>sender's</em> initial window size in
@@ -39228,7 +42703,7 @@ bytes for stream-level flow control. The minimum allowed value is 0. The
 maximum allowed value is 2<sup>32</sup>-1. <strong>Default:</strong> <code>65535</code>.</li>
 <li><code>maxFrameSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the size in bytes of the largest frame
 payload. The minimum allowed value is 16,384. The maximum allowed value is
-2<sup>24</sup>-1. <strong>Default:</strong> <code>16384</code>.</li>
+22<sup>24</sup>-1. <strong>Default:</strong> <code>16384</code>.</li>
 <li><code>maxConcurrentStreams</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the maximum number of concurrent
 streams permitted on an <code>Http2Session</code>. There is no default value which
 implies, at least theoretically, 2<sup>32</sup>-1 streams may be open
@@ -39237,7 +42712,7 @@ is 0. The maximum allowed value is 2<sup>32</sup>-1. <strong>Default:</strong>
 <code>4294967295</code>.</li>
 <li><code>maxHeaderListSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the maximum size (uncompressed octets)
 of header list that will be accepted. The minimum allowed value is 0. The
-maximum allowed value is 2<sup>32</sup>-1. <strong>Default:</strong> <code>65535</code>.</li>
+maximum allowed value is 22<sup>32</sup>-1. <strong>Default:</strong> <code>65535</code>.</li>
 <li><code>maxHeaderSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Alias for <code>maxHeaderListSize</code>.</li>
 <li><code>enableConnectProtocol</code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Specifies <code>true</code> if the "Extended Connect
 Protocol" defined by <a href="https://tools.ietf.org/html/rfc8441">RFC 8441</a> is to be enabled. This setting is only
@@ -39246,24 +42721,7 @@ has been enabled for a given <code>Http2Session</code>, it cannot be disabled.
 <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 <p>All additional properties on the settings object are ignored.</p>
-<h3>Using <code>options.selectPadding()</code><span><a class="mark" href="#http2_using_options_selectpadding" id="http2_using_options_selectpadding">#</a></span></h3>
-<p>When <code>options.paddingStrategy</code> is equal to
-<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, the HTTP/2 implementation will
-consult the <code>options.selectPadding()</code> callback function, if provided, to
-determine the specific amount of padding to use per <code>HEADERS</code> and <code>DATA</code> frame.</p>
-<p>The <code>options.selectPadding()</code> function receives two numeric arguments,
-<code>frameLen</code> and <code>maxFrameLen</code> and must return a number <code>N</code> such that
-<code>frameLen &#x3C;= N &#x3C;= maxFrameLen</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer({
-  <span class="hljs-attr">paddingStrategy</span>: http2.constants.PADDING_STRATEGY_CALLBACK,
-  selectPadding(frameLen, maxFrameLen) {
-    <span class="hljs-keyword">return</span> maxFrameLen;
-  }
-});</code></pre>
-<p>The <code>options.selectPadding()</code> function is invoked once for <em>every</em> <code>HEADERS</code> and
-<code>DATA</code> frame. This has a definite noticeable impact on performance.</p>
-<h3>Error handling<span><a class="mark" href="#http2_error_handling" id="http2_error_handling">#</a></span></h3>
+<h4>Error handling<span><a class="mark" href="#http2_error_handling" id="http2_error_handling">#</a></span></h4>
 <p>There are several types of error conditions that may arise when using the
 <code>http2</code> module:</p>
 <p>Validation errors occur when an incorrect argument, option, or setting value is
@@ -39279,7 +42737,7 @@ reported via an <code>'error'</code> event on the <code>Http2Session</code> or H
 These will be reported using either a synchronous <code>throw</code> or via an <code>'error'</code>
 event on the <code>Http2Stream</code>, <code>Http2Session</code> or HTTP/2 Server objects, depending
 on where and when the error occurs.</p>
-<h3>Invalid character handling in header names and values<span><a class="mark" href="#http2_invalid_character_handling_in_header_names_and_values" id="http2_invalid_character_handling_in_header_names_and_values">#</a></span></h3>
+<h4>Invalid character handling in header names and values<span><a class="mark" href="#http2_invalid_character_handling_in_header_names_and_values" id="http2_invalid_character_handling_in_header_names_and_values">#</a></span></h4>
 <p>The HTTP/2 implementation applies stricter handling of invalid characters in
 HTTP header names and values than the HTTP/1 implementation.</p>
 <p>Header field names are <em>case-insensitive</em> and are transmitted over the wire
@@ -39294,85 +42752,85 @@ stream to be closed with a protocol error being reported.</p>
 <p>Header field values are handled with more leniency but <em>should</em> not contain
 new-line or carriage return characters and <em>should</em> be limited to US-ASCII
 characters, per the requirements of the HTTP specification.</p>
-<h3>Push streams on the client<span><a class="mark" href="#http2_push_streams_on_the_client" id="http2_push_streams_on_the_client">#</a></span></h3>
+<h4>Push streams on the client<span><a class="mark" href="#http2_push_streams_on_the_client" id="http2_push_streams_on_the_client">#</a></span></h4>
 <p>To receive pushed streams on the client, set a listener for the <code>'stream'</code>
 event on the <code>ClientHttp2Session</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'http://localhost'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'http://localhost'</span>);
 
-client.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">pushedStream, requestHeaders</span>) =></span> {
-  pushedStream.on(<span class="hljs-string">'push'</span>, <span class="hljs-function">(<span class="hljs-params">responseHeaders</span>) =></span> {
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">pushedStream, requestHeaders</span>) =></span> {
+  pushedStream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'push'</span>, <span class="hljs-function">(<span class="hljs-params">responseHeaders</span>) =></span> {
     <span class="hljs-comment">// Process response headers</span>
   });
-  pushedStream.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-comment">/* handle pushed data */</span> });
+  pushedStream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-comment">/* handle pushed data */</span> });
 });
 
-<span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });</code></pre>
-<h3>Supporting the <code>CONNECT</code> method<span><a class="mark" href="#http2_supporting_the_connect_method" id="http2_supporting_the_connect_method">#</a></span></h3>
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });</code></pre>
+<h4>Supporting the <code>CONNECT</code> method<span><a class="mark" href="#http2_supporting_the_connect_method" id="http2_supporting_the_connect_method">#</a></span></h4>
 <p>The <code>CONNECT</code> method is used to allow an HTTP/2 server to be used as a proxy
 for TCP/IP connections.</p>
 <p>A simple TCP Server:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
 
-<span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+<span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
   <span class="hljs-keyword">let</span> name = <span class="hljs-string">''</span>;
-  socket.setEncoding(<span class="hljs-string">'utf8'</span>);
-  socket.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> name += chunk);
-  socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> socket.end(<span class="hljs-string">`hello <span class="hljs-subst">${name}</span>`</span>));
+  socket.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> name += chunk);
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">`hello <span class="hljs-subst">${name}</span>`</span>));
 });
 
-server.listen(<span class="hljs-number">8000</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
 <p>An HTTP/2 CONNECT proxy:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> { NGHTTP2_REFUSED_STREAM } = http2.constants;
+<span class="hljs-keyword">const</span> { NGHTTP2_REFUSED_STREAM } = http2.<span class="hljs-property">constants</span>;
 <span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
 
-<span class="hljs-keyword">const</span> proxy = http2.createServer();
-proxy.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+<span class="hljs-keyword">const</span> proxy = http2.<span class="hljs-title function_">createServer</span>();
+proxy.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
   <span class="hljs-keyword">if</span> (headers[<span class="hljs-string">':method'</span>] !== <span class="hljs-string">'CONNECT'</span>) {
     <span class="hljs-comment">// Only accept CONNECT requests</span>
-    stream.close(NGHTTP2_REFUSED_STREAM);
+    stream.<span class="hljs-title function_">close</span>(NGHTTP2_REFUSED_STREAM);
     <span class="hljs-keyword">return</span>;
   }
-  <span class="hljs-keyword">const</span> auth = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">`tcp://<span class="hljs-subst">${headers[<span class="hljs-string">':authority'</span>]}</span>`</span>);
+  <span class="hljs-keyword">const</span> auth = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">`tcp://<span class="hljs-subst">${headers[<span class="hljs-string">':authority'</span>]}</span>`</span>);
   <span class="hljs-comment">// It's a very good idea to verify that hostname and port are</span>
   <span class="hljs-comment">// things this proxy should be connecting to.</span>
-  <span class="hljs-keyword">const</span> socket = net.connect(auth.port, auth.hostname, <span class="hljs-function">() =></span> {
-    stream.respond();
-    socket.pipe(stream);
-    stream.pipe(socket);
+  <span class="hljs-keyword">const</span> socket = net.<span class="hljs-title function_">connect</span>(auth.<span class="hljs-property">port</span>, auth.<span class="hljs-property">hostname</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">respond</span>();
+    socket.<span class="hljs-title function_">pipe</span>(stream);
+    stream.<span class="hljs-title function_">pipe</span>(socket);
   });
-  socket.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
-    stream.close(http2.constants.NGHTTP2_CONNECT_ERROR);
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
+    stream.<span class="hljs-title function_">close</span>(http2.<span class="hljs-property">constants</span>.<span class="hljs-property">NGHTTP2_CONNECT_ERROR</span>);
   });
 });
 
-proxy.listen(<span class="hljs-number">8001</span>);</code></pre>
+proxy.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8001</span>);</code></pre>
 <p>An HTTP/2 CONNECT client:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'http://localhost:8001'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'http://localhost:8001'</span>);
 
 <span class="hljs-comment">// Must not specify the ':path' and ':scheme' headers</span>
 <span class="hljs-comment">// for CONNECT requests or an error will be thrown.</span>
-<span class="hljs-keyword">const</span> req = client.request({
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({
   <span class="hljs-string">':method'</span>: <span class="hljs-string">'CONNECT'</span>,
   <span class="hljs-string">':authority'</span>: <span class="hljs-string">`localhost:<span class="hljs-subst">${port}</span>`</span>
 });
 
-req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers[http2.constants.HTTP2_HEADER_STATUS]);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers[http2.<span class="hljs-property">constants</span>.<span class="hljs-property">HTTP2_HEADER_STATUS</span>]);
 });
 <span class="hljs-keyword">let</span> data = <span class="hljs-string">''</span>;
-req.setEncoding(<span class="hljs-string">'utf8'</span>);
-req.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> data += chunk);
-req.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The server says: <span class="hljs-subst">${data}</span>`</span>);
-  client.close();
+req.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> data += chunk);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The server says: <span class="hljs-subst">${data}</span>`</span>);
+  client.<span class="hljs-title function_">close</span>();
 });
-req.end(<span class="hljs-string">'Jane'</span>);</code></pre>
-<h3>The extended <code>CONNECT</code> protocol<span><a class="mark" href="#http2_the_extended_connect_protocol" id="http2_the_extended_connect_protocol">#</a></span></h3>
+req.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Jane'</span>);</code></pre>
+<h4>The extended <code>CONNECT</code> protocol<span><a class="mark" href="#http2_the_extended_connect_protocol" id="http2_the_extended_connect_protocol">#</a></span></h4>
 <p><a href="https://tools.ietf.org/html/rfc8441">RFC 8441</a> defines an "Extended CONNECT Protocol" extension to HTTP/2 that
 may be used to bootstrap the use of an <code>Http2Stream</code> using the <code>CONNECT</code>
 method as a tunnel for other communication protocols (such as WebSockets).</p>
@@ -39380,19 +42838,19 @@ method as a tunnel for other communication protocols (such as WebSockets).</p>
 the <code>enableConnectProtocol</code> setting:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> settings = { <span class="hljs-attr">enableConnectProtocol</span>: <span class="hljs-literal">true</span> };
-<span class="hljs-keyword">const</span> server = http2.createServer({ settings });</code></pre>
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>({ settings });</code></pre>
 <p>Once the client receives the <code>SETTINGS</code> frame from the server indicating that
 the extended CONNECT may be used, it may send <code>CONNECT</code> requests that use the
 <code>':protocol'</code> HTTP/2 pseudo-header:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'http://localhost:8080'</span>);
-client.on(<span class="hljs-string">'remoteSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
-  <span class="hljs-keyword">if</span> (settings.enableConnectProtocol) {
-    <span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':method'</span>: <span class="hljs-string">'CONNECT'</span>, <span class="hljs-string">':protocol'</span>: <span class="hljs-string">'foo'</span> });
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'http://localhost:8080'</span>);
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'remoteSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
+  <span class="hljs-keyword">if</span> (settings.<span class="hljs-property">enableConnectProtocol</span>) {
+    <span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':method'</span>: <span class="hljs-string">'CONNECT'</span>, <span class="hljs-string">':protocol'</span>: <span class="hljs-string">'foo'</span> });
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h2>Compatibility API<span><a class="mark" href="#http2_compatibility_api" id="http2_compatibility_api">#</a></span></h2>
+</section><section><h3>Compatibility API<span><a class="mark" href="#http2_compatibility_api" id="http2_compatibility_api">#</a></span></h3>
 <p>The Compatibility API has the goal of providing a similar developer experience
 of HTTP/1 when using HTTP/2, making it possible to develop applications
 that support both <a href="http.html">HTTP/1</a> and HTTP/2. This API targets only the
@@ -39402,11 +42860,11 @@ different implementation.</p>
 <p>The following example creates an HTTP/2 server using the compatibility
 API:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
 <p>In order to create a mixed <a href="https.html">HTTPS</a> and HTTP/2 server, refer to the
 <a href="#http2_alpn_negotiation">ALPN negotiation</a> section.
@@ -39415,7 +42873,7 @@ Upgrading from non-tls HTTP/1 servers is not supported.</p>
 <a href="#http2_class_http2_http2serverresponse"><code>Http2ServerResponse</code></a>. They aim at API compatibility with HTTP/1, but
 they do not hide the differences between the protocols. As an example,
 the status message for HTTP codes is ignored.</p>
-<h3>ALPN negotiation<span><a class="mark" href="#http2_alpn_negotiation" id="http2_alpn_negotiation">#</a></span></h3>
+<h4>ALPN negotiation<span><a class="mark" href="#http2_alpn_negotiation" id="http2_alpn_negotiation">#</a></span></h4>
 <p>ALPN negotiation allows supporting both <a href="https.html">HTTPS</a> and HTTP/2 over
 the same socket. The <code>req</code> and <code>res</code> objects can be either HTTP/1 or
 HTTP/2, and an application <strong>must</strong> restrict itself to the public API of
@@ -39425,27 +42883,27 @@ features of HTTP/2.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { createSecureServer } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> { readFileSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> cert = readFileSync(<span class="hljs-string">'./cert.pem'</span>);
-<span class="hljs-keyword">const</span> key = readFileSync(<span class="hljs-string">'./key.pem'</span>);
+<span class="hljs-keyword">const</span> cert = <span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'./cert.pem'</span>);
+<span class="hljs-keyword">const</span> key = <span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'./key.pem'</span>);
 
-<span class="hljs-keyword">const</span> server = createSecureServer(
+<span class="hljs-keyword">const</span> server = <span class="hljs-title function_">createSecureServer</span>(
   { cert, key, <span class="hljs-attr">allowHTTP1</span>: <span class="hljs-literal">true</span> },
   onRequest
-).listen(<span class="hljs-number">4443</span>);
+).<span class="hljs-title function_">listen</span>(<span class="hljs-number">4443</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">onRequest</span>(<span class="hljs-params">req, res</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">onRequest</span>(<span class="hljs-params">req, res</span>) {
   <span class="hljs-comment">// Detects if it is a HTTPS request or HTTP/2</span>
-  <span class="hljs-keyword">const</span> { <span class="hljs-attr">socket</span>: { alpnProtocol } } = req.httpVersion === <span class="hljs-string">'2.0'</span> ?
-    req.stream.session : req;
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'application/json'</span> });
-  res.end(<span class="hljs-built_in">JSON</span>.stringify({
+  <span class="hljs-keyword">const</span> { <span class="hljs-attr">socket</span>: { alpnProtocol } } = req.<span class="hljs-property">httpVersion</span> === <span class="hljs-string">'2.0'</span> ?
+    req.<span class="hljs-property">stream</span>.<span class="hljs-property">session</span> : req;
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'application/json'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
     alpnProtocol,
-    <span class="hljs-attr">httpVersion</span>: req.httpVersion
+    <span class="hljs-attr">httpVersion</span>: req.<span class="hljs-property">httpVersion</span>
   }));
 }</code></pre>
 <p>The <code>'request'</code> event works identically on both <a href="https.html">HTTPS</a> and
 HTTP/2.</p>
-<h3>Class: <code>http2.Http2ServerRequest</code><span><a class="mark" href="#http2_class_http2_http2serverrequest" id="http2_class_http2_http2serverrequest">#</a></span></h3>
+<h4>Class: <code>http2.Http2ServerRequest</code><span><a class="mark" href="#http2_class_http2_http2serverrequest" id="http2_class_http2_http2serverrequest">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39456,7 +42914,7 @@ HTTP/2.</p>
 <a href="#http2_class_http2secureserver"><code>http2.SecureServer</code></a> and passed as the first argument to the
 <a href="#http2_event_request"><code>'request'</code></a> event. It may be used to access a request status, headers, and
 data.</p>
-<h4>Event: <code>'aborted'</code><span><a class="mark" href="#http2_event_aborted_1" id="http2_event_aborted_1">#</a></span></h4>
+<h5>Event: <code>'aborted'</code><span><a class="mark" href="#http2_event_aborted_1" id="http2_event_aborted_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39464,13 +42922,13 @@ data.</p>
 abnormally aborted in mid-communication.</p>
 <p>The <code>'aborted'</code> event will only be emitted if the <code>Http2ServerRequest</code> writable
 side has not been ended.</p>
-<h4>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_2" id="http2_event_close_2">#</a></span></h4>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_2" id="http2_event_close_2">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>Indicates that the underlying <a href="#http2_class_http2stream"><code>Http2Stream</code></a> was closed.
 Just like <code>'end'</code>, this event occurs only once per response.</p>
-<h4><code>request.aborted</code><span><a class="mark" href="#http2_request_aborted" id="http2_request_aborted">#</a></span></h4>
+<h5><code>request.aborted</code><span><a class="mark" href="#http2_request_aborted" id="http2_request_aborted">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.1.0</span>
 </div>
@@ -39479,7 +42937,7 @@ Just like <code>'end'</code>, this event occurs only once per response.</p>
 </ul>
 <p>The <code>request.aborted</code> property will be <code>true</code> if the request has
 been aborted.</p>
-<h4><code>request.authority</code><span><a class="mark" href="#http2_request_authority" id="http2_request_authority">#</a></span></h4>
+<h5><code>request.authority</code><span><a class="mark" href="#http2_request_authority" id="http2_request_authority">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39488,7 +42946,7 @@ been aborted.</p>
 </ul>
 <p>The request authority pseudo header field. It can also be accessed via
 <code>req.headers[':authority']</code>.</p>
-<h4><code>request.complete</code><span><a class="mark" href="#http2_request_complete" id="http2_request_complete">#</a></span></h4>
+<h5><code>request.complete</code><span><a class="mark" href="#http2_request_complete" id="http2_request_complete">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v12.10.0</span>
 </div>
@@ -39497,7 +42955,16 @@ been aborted.</p>
 </ul>
 <p>The <code>request.complete</code> property will be <code>true</code> if the request has
 been completed, aborted, or destroyed.</p>
-<h4><code>request.destroy([error])</code><span><a class="mark" href="#http2_request_destroy_error" id="http2_request_destroy_error">#</a></span></h4>
+<h5><code>request.connection</code><span><a class="mark" href="#http2_request_connection" id="http2_request_connection">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v8.4.0</span><span>Deprecated since: v13.0.0</span>
+</div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http2_request_socket"><code>request.socket</code></a>.</div><p></p>
+<ul>
+<li><a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> | <a href="#tls_class_tls_tlssocket" class="type">&#x3C;tls.TLSSocket></a></li>
+</ul>
+<p>See <a href="#http2_request_socket"><code>request.socket</code></a>.</p>
+<h5><code>request.destroy([error])</code><span><a class="mark" href="#http2_request_destroy_error" id="http2_request_destroy_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39508,7 +42975,7 @@ been completed, aborted, or destroyed.</p>
 the <a href="#http2_class_http2_http2serverrequest"><code>Http2ServerRequest</code></a>. If <code>error</code> is provided, an <code>'error'</code> event
 is emitted and <code>error</code> is passed as an argument to any listeners on the event.</p>
 <p>It does nothing if the stream was already destroyed.</p>
-<h4><code>request.headers</code><span><a class="mark" href="#http2_request_headers" id="http2_request_headers">#</a></span></h4>
+<h5><code>request.headers</code><span><a class="mark" href="#http2_request_headers" id="http2_request_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39522,16 +42989,16 @@ is emitted and <code>error</code> is passed as an argument to any listeners on t
 <span class="hljs-comment">// { 'user-agent': 'curl/7.22.0',</span>
 <span class="hljs-comment">//   host: '127.0.0.1:8000',</span>
 <span class="hljs-comment">//   accept: '*/*' }</span>
-<span class="hljs-built_in">console</span>.log(request.headers);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(request.<span class="hljs-property">headers</span>);</code></pre>
 <p>See <a href="#http2_headers_object">HTTP/2 Headers Object</a>.</p>
 <p>In HTTP/2, the request path, host name, protocol, and method are represented as
 special headers prefixed with the <code>:</code> character (e.g. <code>':path'</code>). These special
 headers will be included in the <code>request.headers</code> object. Care must be taken not
 to inadvertently modify these special headers or errors may occur. For instance,
 removing all headers from the request will cause errors to occur:</p>
-<pre><code class="language-js">removeAllHeaders(request.headers);
-assert(request.url);   <span class="hljs-comment">// Fails because the :path header has been removed</span></code></pre>
-<h4><code>request.httpVersion</code><span><a class="mark" href="#http2_request_httpversion" id="http2_request_httpversion">#</a></span></h4>
+<pre><code class="language-js"><span class="hljs-title function_">removeAllHeaders</span>(request.<span class="hljs-property">headers</span>);
+<span class="hljs-title function_">assert</span>(request.<span class="hljs-property">url</span>);   <span class="hljs-comment">// Fails because the :path header has been removed</span></code></pre>
+<h5><code>request.httpVersion</code><span><a class="mark" href="#http2_request_httpversion" id="http2_request_httpversion">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39543,7 +43010,7 @@ client response, the HTTP version of the connected-to server. Returns
 <code>'2.0'</code>.</p>
 <p>Also <code>message.httpVersionMajor</code> is the first integer and
 <code>message.httpVersionMinor</code> is the second.</p>
-<h4><code>request.method</code><span><a class="mark" href="#http2_request_method" id="http2_request_method">#</a></span></h4>
+<h5><code>request.method</code><span><a class="mark" href="#http2_request_method" id="http2_request_method">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39551,7 +43018,7 @@ client response, the HTTP version of the connected-to server. Returns
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The request method as a string. Read-only. Examples: <code>'GET'</code>, <code>'DELETE'</code>.</p>
-<h4><code>request.rawHeaders</code><span><a class="mark" href="#http2_request_rawheaders" id="http2_request_rawheaders">#</a></span></h4>
+<h5><code>request.rawHeaders</code><span><a class="mark" href="#http2_request_rawheaders" id="http2_request_rawheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39573,8 +43040,8 @@ odd-numbered offsets are the associated values.</p>
 <span class="hljs-comment">//   '127.0.0.1:8000',</span>
 <span class="hljs-comment">//   'ACCEPT',</span>
 <span class="hljs-comment">//   '*/*' ]</span>
-<span class="hljs-built_in">console</span>.log(request.rawHeaders);</code></pre>
-<h4><code>request.rawTrailers</code><span><a class="mark" href="#http2_request_rawtrailers" id="http2_request_rawtrailers">#</a></span></h4>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(request.<span class="hljs-property">rawHeaders</span>);</code></pre>
+<h5><code>request.rawTrailers</code><span><a class="mark" href="#http2_request_rawtrailers" id="http2_request_rawtrailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39583,7 +43050,7 @@ odd-numbered offsets are the associated values.</p>
 </ul>
 <p>The raw request/response trailer keys and values exactly as they were
 received. Only populated at the <code>'end'</code> event.</p>
-<h4><code>request.scheme</code><span><a class="mark" href="#http2_request_scheme" id="http2_request_scheme">#</a></span></h4>
+<h5><code>request.scheme</code><span><a class="mark" href="#http2_request_scheme" id="http2_request_scheme">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39592,7 +43059,7 @@ received. Only populated at the <code>'end'</code> event.</p>
 </ul>
 <p>The request scheme pseudo header field indicating the scheme
 portion of the target URL.</p>
-<h4><code>request.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_request_settimeout_msecs_callback" id="http2_request_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>request.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_request_settimeout_msecs_callback" id="http2_request_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39608,7 +43075,7 @@ the response object.</p>
 the server, then <a href="#http2_class_http2stream"><code>Http2Stream</code></a>s are destroyed when they time out. If a
 handler is assigned to the request, the response, or the server's <code>'timeout'</code>
 events, timed out sockets must be handled explicitly.</p>
-<h4><code>request.socket</code><span><a class="mark" href="#http2_request_socket" id="http2_request_socket">#</a></span></h4>
+<h5><code>request.socket</code><span><a class="mark" href="#http2_request_socket" id="http2_request_socket">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39628,7 +43095,7 @@ more information.</p>
 <p>All other interactions will be routed directly to the socket. With TLS support,
 use <a href="#tls_tlssocket_getpeercertificate_detailed"><code>request.socket.getPeerCertificate()</code></a> to obtain the client's
 authentication details.</p>
-<h4><code>request.stream</code><span><a class="mark" href="#http2_request_stream" id="http2_request_stream">#</a></span></h4>
+<h5><code>request.stream</code><span><a class="mark" href="#http2_request_stream" id="http2_request_stream">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39636,7 +43103,7 @@ authentication details.</p>
 <li><a href="#http2_class_http2stream" class="type">&#x3C;Http2Stream></a></li>
 </ul>
 <p>The <a href="#http2_class_http2stream"><code>Http2Stream</code></a> object backing the request.</p>
-<h4><code>request.trailers</code><span><a class="mark" href="#http2_request_trailers" id="http2_request_trailers">#</a></span></h4>
+<h5><code>request.trailers</code><span><a class="mark" href="#http2_request_trailers" id="http2_request_trailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39644,7 +43111,7 @@ authentication details.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>The request/response trailers object. Only populated at the <code>'end'</code> event.</p>
-<h4><code>request.url</code><span><a class="mark" href="#http2_request_url" id="http2_request_url">#</a></span></h4>
+<h5><code>request.url</code><span><a class="mark" href="#http2_request_url" id="http2_request_url">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39653,47 +43120,29 @@ authentication details.</p>
 </ul>
 <p>Request URL string. This contains only the URL that is present in the actual
 HTTP request. If the request is:</p>
-<pre><code class="language-http"><span class="hljs-keyword">GET</span> <span class="hljs-string">/status?name=ryan</span> HTTP/1.1
-<span class="hljs-attribute">Accept</span>: text/plain</code></pre>
+<pre><code class="language-http"><span class="hljs-keyword">GET</span> <span class="hljs-string">/status?name=ryan</span> <span class="hljs-meta">HTTP/1.1</span>
+<span class="hljs-attribute">Accept</span><span class="hljs-punctuation">: </span>text/plain</code></pre>
 <p>Then <code>request.url</code> will be:</p>
 <!-- eslint-disable semi -->
 <pre><code class="language-js"><span class="hljs-string">'/status?name=ryan'</span></code></pre>
-<p>To parse the url into its parts, <code>require('url').parse(request.url)</code>
-can be used:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> require(<span class="hljs-string">'url'</span>).parse(<span class="hljs-string">'/status?name=ryan'</span>)</span>
-Url {
-  protocol: null,
-  slashes: null,
-  auth: null,
-  host: null,
-  port: null,
-  hostname: null,
-  hash: null,
-  search: '?name=ryan',
-  query: 'name=ryan',
+<p>To parse the url into its parts, <code>new URL()</code> can be used:</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">new URL(<span class="hljs-string">'/status?name=ryan'</span>, <span class="hljs-string">'http://example.com'</span>)</span>
+URL {
+  href: 'http://example.com/status?name=ryan',
+  origin: 'http://example.com',
+  protocol: 'http:',
+  username: '',
+  password: '',
+  host: 'example.com',
+  hostname: 'example.com',
+  port: '',
   pathname: '/status',
-  path: '/status?name=ryan',
-  href: '/status?name=ryan' }</code></pre>
-<p>To obtain the parameters from the query string, use the
-<code>require('querystring').parse()</code> function or pass
-<code>true</code> as the second argument to <code>require('url').parse()</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> require(<span class="hljs-string">'url'</span>).parse(<span class="hljs-string">'/status?name=ryan'</span>, <span class="hljs-literal">true</span>)</span>
-Url {
-  protocol: null,
-  slashes: null,
-  auth: null,
-  host: null,
-  port: null,
-  hostname: null,
-  hash: null,
   search: '?name=ryan',
-  query: { name: 'ryan' },
-  pathname: '/status',
-  path: '/status?name=ryan',
-  href: '/status?name=ryan' }</code></pre>
-<h3>Class: <code>http2.Http2ServerResponse</code><span><a class="mark" href="#http2_class_http2_http2serverresponse" id="http2_class_http2_http2serverresponse">#</a></span></h3>
+  searchParams: URLSearchParams { 'name' => 'ryan' },
+  hash: ''
+}</code></pre>
+<h4>Class: <code>http2.Http2ServerResponse</code><span><a class="mark" href="#http2_class_http2_http2serverresponse" id="http2_class_http2_http2serverresponse">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39702,13 +43151,13 @@ Url {
 </ul>
 <p>This object is created internally by an HTTP server, not by the user. It is
 passed as the second parameter to the <a href="#http2_event_request"><code>'request'</code></a> event.</p>
-<h4>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_3" id="http2_event_close_3">#</a></span></h4>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_3" id="http2_event_close_3">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>Indicates that the underlying <a href="#http2_class_http2stream"><code>Http2Stream</code></a> was terminated before
 <a href="#http2_response_end_data_encoding_callback"><code>response.end()</code></a> was called or able to flush.</p>
-<h4>Event: <code>'finish'</code><span><a class="mark" href="#http2_event_finish" id="http2_event_finish">#</a></span></h4>
+<h5>Event: <code>'finish'</code><span><a class="mark" href="#http2_event_finish" id="http2_event_finish">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39717,7 +43166,7 @@ emitted when the last segment of the response headers and body have been
 handed off to the HTTP/2 multiplexing for transmission over the network. It
 does not imply that the client has received anything yet.</p>
 <p>After this event, no more events will be emitted on the response object.</p>
-<h4><code>response.addTrailers(headers)</code><span><a class="mark" href="#http2_response_addtrailers_headers" id="http2_response_addtrailers_headers">#</a></span></h4>
+<h5><code>response.addTrailers(headers)</code><span><a class="mark" href="#http2_response_addtrailers_headers" id="http2_response_addtrailers_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39728,15 +43177,37 @@ does not imply that the client has received anything yet.</p>
 message) to the response.</p>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
-<h4><code>response.connection</code><span><a class="mark" href="#http2_response_connection" id="http2_response_connection">#</a></span></h4>
+<h5><code>response.connection</code><span><a class="mark" href="#http2_response_connection" id="http2_response_connection">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.4.0</span>
+<span>Added in: v8.4.0</span><span>Deprecated since: v13.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http2_response_socket"><code>response.socket</code></a>.</div><p></p>
 <ul>
 <li><a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> | <a href="#tls_class_tls_tlssocket" class="type">&#x3C;tls.TLSSocket></a></li>
 </ul>
 <p>See <a href="#http2_response_socket"><code>response.socket</code></a>.</p>
-<h4><code>response.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http2_response_end_data_encoding_callback" id="http2_response_end_data_encoding_callback">#</a></span></h4>
+<h5><code>response.createPushResponse(headers, callback)</code><span><a class="mark" href="#http2_response_createpushresponse_headers_callback" id="http2_response_createpushresponse_headers_callback">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v8.4.0</span>
+</div>
+<ul>
+<li><code>headers</code> <a href="#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a> An object describing the headers</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called once <code>http2stream.pushStream()</code> is finished,
+or either when the attempt to create the pushed <code>Http2Stream</code> has failed or
+has been rejected, or the state of <code>Http2ServerRequest</code> is closed prior to
+calling the <code>http2stream.pushStream()</code> method
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>res</code> <a href="#http2_class_http2_http2serverresponse" class="type">&#x3C;http2.Http2ServerResponse></a> The newly-created <code>Http2ServerResponse</code>
+object</li>
+</ul>
+</li>
+</ul>
+<p>Call <a href="#http2_http2stream_pushstream_headers_options_callback"><code>http2stream.pushStream()</code></a> with the given headers, and wrap the
+given <a href="#http2_class_http2stream"><code>Http2Stream</code></a> on a newly created <code>Http2ServerResponse</code> as the callback
+parameter if successful. When <code>Http2ServerRequest</code> is closed, the callback is
+called with an error <code>ERR_HTTP2_INVALID_STREAM</code>.</p>
+<h5><code>response.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http2_response_end_data_encoding_callback" id="http2_response_end_data_encoding_callback">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -39761,9 +43232,9 @@ The method, <code>response.end()</code>, MUST be called on each response.</p>
 <a href="#http_response_write_chunk_encoding_callback"><code>response.write(data, encoding)</code></a> followed by <code>response.end(callback)</code>.</p>
 <p>If <code>callback</code> is specified, it will be called when the response stream
 is finished.</p>
-<h4><code>response.finished</code><span><a class="mark" href="#http2_response_finished" id="http2_response_finished">#</a></span></h4>
+<h5><code>response.finished</code><span><a class="mark" href="#http2_response_finished" id="http2_response_finished">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.4.0</span><span>Deprecated since: v12.16.0</span>
+<span>Added in: v8.4.0</span><span>Deprecated since: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http2_response_writableended"><code>response.writableEnded</code></a>.</div><p></p>
 <ul>
@@ -39771,7 +43242,7 @@ is finished.</p>
 </ul>
 <p>Boolean value that indicates whether the response has completed. Starts
 as <code>false</code>. After <a href="#http2_response_end_data_encoding_callback"><code>response.end()</code></a> executes, the value will be <code>true</code>.</p>
-<h4><code>response.getHeader(name)</code><span><a class="mark" href="#http2_response_getheader_name" id="http2_response_getheader_name">#</a></span></h4>
+<h5><code>response.getHeader(name)</code><span><a class="mark" href="#http2_response_getheader_name" id="http2_response_getheader_name">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39781,8 +43252,8 @@ as <code>false</code>. After <a href="#http2_response_end_data_encoding_callback
 </ul>
 <p>Reads out a header that has already been queued but not sent to the client.
 The name is case-insensitive.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> contentType = response.getHeader(<span class="hljs-string">'content-type'</span>);</code></pre>
-<h4><code>response.getHeaderNames()</code><span><a class="mark" href="#http2_response_getheadernames" id="http2_response_getheadernames">#</a></span></h4>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> contentType = response.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'content-type'</span>);</code></pre>
+<h5><code>response.getHeaderNames()</code><span><a class="mark" href="#http2_response_getheadernames" id="http2_response_getheadernames">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39791,12 +43262,12 @@ The name is case-insensitive.</p>
 </ul>
 <p>Returns an array containing the unique names of the current outgoing headers.
 All header names are lowercase.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
 
-<span class="hljs-keyword">const</span> headerNames = response.getHeaderNames();
+<span class="hljs-keyword">const</span> headerNames = response.<span class="hljs-title function_">getHeaderNames</span>();
 <span class="hljs-comment">// headerNames === ['foo', 'set-cookie']</span></code></pre>
-<h4><code>response.getHeaders()</code><span><a class="mark" href="#http2_response_getheaders" id="http2_response_getheaders">#</a></span></h4>
+<h5><code>response.getHeaders()</code><span><a class="mark" href="#http2_response_getheaders" id="http2_response_getheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39812,12 +43283,12 @@ are lowercase.</p>
 prototypically inherit from the JavaScript <code>Object</code>. This means that typical
 <code>Object</code> methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>, and others
 are not defined and <em>will not work</em>.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
 
-<span class="hljs-keyword">const</span> headers = response.getHeaders();
+<span class="hljs-keyword">const</span> headers = response.<span class="hljs-title function_">getHeaders</span>();
 <span class="hljs-comment">// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }</span></code></pre>
-<h4><code>response.hasHeader(name)</code><span><a class="mark" href="#http2_response_hasheader_name" id="http2_response_hasheader_name">#</a></span></h4>
+<h5><code>response.hasHeader(name)</code><span><a class="mark" href="#http2_response_hasheader_name" id="http2_response_hasheader_name">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39827,8 +43298,8 @@ response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="
 </ul>
 <p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the
 outgoing headers. The header name matching is case-insensitive.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = response.hasHeader(<span class="hljs-string">'content-type'</span>);</code></pre>
-<h4><code>response.headersSent</code><span><a class="mark" href="#http2_response_headerssent" id="http2_response_headerssent">#</a></span></h4>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = response.<span class="hljs-title function_">hasHeader</span>(<span class="hljs-string">'content-type'</span>);</code></pre>
+<h5><code>response.headersSent</code><span><a class="mark" href="#http2_response_headerssent" id="http2_response_headerssent">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39836,7 +43307,7 @@ outgoing headers. The header name matching is case-insensitive.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>True if headers were sent, false otherwise (read-only).</p>
-<h4><code>response.removeHeader(name)</code><span><a class="mark" href="#http2_response_removeheader_name" id="http2_response_removeheader_name">#</a></span></h4>
+<h5><code>response.removeHeader(name)</code><span><a class="mark" href="#http2_response_removeheader_name" id="http2_response_removeheader_name">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39844,8 +43315,8 @@ outgoing headers. The header name matching is case-insensitive.</p>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Removes a header that has been queued for implicit sending.</p>
-<pre><code class="language-js">response.removeHeader(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
-<h4><code>response.sendDate</code><span><a class="mark" href="#http2_response_senddate" id="http2_response_senddate">#</a></span></h4>
+<pre><code class="language-js">response.<span class="hljs-title function_">removeHeader</span>(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
+<h5><code>response.sendDate</code><span><a class="mark" href="#http2_response_senddate" id="http2_response_senddate">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39856,7 +43327,7 @@ outgoing headers. The header name matching is case-insensitive.</p>
 the response if it is not already present in the headers. Defaults to true.</p>
 <p>This should only be disabled for testing; HTTP requires the Date header
 in responses.</p>
-<h4><code>response.setHeader(name, value)</code><span><a class="mark" href="#http2_response_setheader_name_value" id="http2_response_setheader_name_value">#</a></span></h4>
+<h5><code>response.setHeader(name, value)</code><span><a class="mark" href="#http2_response_setheader_name_value" id="http2_response_setheader_name_value">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39867,22 +43338,22 @@ in responses.</p>
 <p>Sets a single header value for implicit headers. If this header already exists
 in the to-be-sent headers, its value will be replaced. Use an array of strings
 here to send multiple headers with the same name.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);</code></pre>
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);</code></pre>
 <p>or</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
 <p>When headers have been set with <a href="#http2_response_setheader_name_value"><code>response.setHeader()</code></a>, they will be merged
 with any headers passed to <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a>, with the headers passed
 to <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> given precedence.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Returns content-type = text/plain</span>
-<span class="hljs-keyword">const</span> server = http2.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
-<h4><code>response.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http2_response_settimeout_msecs_callback" id="http2_response_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>response.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http2_response_settimeout_msecs_callback" id="http2_response_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39898,7 +43369,7 @@ the response object.</p>
 the server, then <a href="#http2_class_http2stream"><code>Http2Stream</code></a>s are destroyed when they time out. If a
 handler is assigned to the request, the response, or the server's <code>'timeout'</code>
 events, timed out sockets must be handled explicitly.</p>
-<h4><code>response.socket</code><span><a class="mark" href="#http2_response_socket" id="http2_response_socket">#</a></span></h4>
+<h5><code>response.socket</code><span><a class="mark" href="#http2_response_socket" id="http2_response_socket">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39917,12 +43388,12 @@ set on <code>response.stream</code>.</p>
 more information.</p>
 <p>All other interactions will be routed directly to the socket.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  <span class="hljs-keyword">const</span> ip = req.socket.remoteAddress;
-  <span class="hljs-keyword">const</span> port = req.socket.remotePort;
-  res.end(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
-}).listen(<span class="hljs-number">3000</span>);</code></pre>
-<h4><code>response.statusCode</code><span><a class="mark" href="#http2_response_statuscode" id="http2_response_statuscode">#</a></span></h4>
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  <span class="hljs-keyword">const</span> ip = req.<span class="hljs-property">socket</span>.<span class="hljs-property">remoteAddress</span>;
+  <span class="hljs-keyword">const</span> port = req.<span class="hljs-property">socket</span>.<span class="hljs-property">remotePort</span>;
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);</code></pre>
+<h5><code>response.statusCode</code><span><a class="mark" href="#http2_response_statuscode" id="http2_response_statuscode">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39932,10 +43403,10 @@ more information.</p>
 <p>When using implicit headers (not calling <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> explicitly),
 this property controls the status code that will be sent to the client when
 the headers get flushed.</p>
-<pre><code class="language-js">response.statusCode = <span class="hljs-number">404</span>;</code></pre>
+<pre><code class="language-js">response.<span class="hljs-property">statusCode</span> = <span class="hljs-number">404</span>;</code></pre>
 <p>After response header was sent to the client, this property indicates the
 status code which was sent out.</p>
-<h4><code>response.statusMessage</code><span><a class="mark" href="#http2_response_statusmessage" id="http2_response_statusmessage">#</a></span></h4>
+<h5><code>response.statusMessage</code><span><a class="mark" href="#http2_response_statusmessage" id="http2_response_statusmessage">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39944,7 +43415,7 @@ status code which was sent out.</p>
 </ul>
 <p>Status message is not supported by HTTP/2 (RFC 7540 8.1.2.4). It returns
 an empty string.</p>
-<h4><code>response.stream</code><span><a class="mark" href="#http2_response_stream" id="http2_response_stream">#</a></span></h4>
+<h5><code>response.stream</code><span><a class="mark" href="#http2_response_stream" id="http2_response_stream">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39952,7 +43423,7 @@ an empty string.</p>
 <li><a href="#http2_class_http2stream" class="type">&#x3C;Http2Stream></a></li>
 </ul>
 <p>The <a href="#http2_class_http2stream"><code>Http2Stream</code></a> object backing the response.</p>
-<h4><code>response.writableEnded</code><span><a class="mark" href="#http2_response_writableended" id="http2_response_writableended">#</a></span></h4>
+<h5><code>response.writableEnded</code><span><a class="mark" href="#http2_response_writableended" id="http2_response_writableended">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -39962,7 +43433,7 @@ an empty string.</p>
 <p>Is <code>true</code> after <a href="#http2_response_end_data_encoding_callback"><code>response.end()</code></a> has been called. This property
 does not indicate whether the data has been flushed, for this use
 <a href="#stream_writable_writablefinished"><code>writable.writableFinished</code></a> instead.</p>
-<h4><code>response.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http2_response_write_chunk_encoding_callback" id="http2_response_write_chunk_encoding_callback">#</a></span></h4>
+<h5><code>response.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http2_response_write_chunk_encoding_callback" id="http2_response_write_chunk_encoding_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -39993,19 +43464,19 @@ first chunk of the body.</p>
 <p>Returns <code>true</code> if the entire data was flushed successfully to the kernel
 buffer. Returns <code>false</code> if all or part of the data was queued in user memory.
 <code>'drain'</code> will be emitted when the buffer is free again.</p>
-<h4><code>response.writeContinue()</code><span><a class="mark" href="#http2_response_writecontinue" id="http2_response_writecontinue">#</a></span></h4>
+<h5><code>response.writeContinue()</code><span><a class="mark" href="#http2_response_writecontinue" id="http2_response_writecontinue">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>Sends a status <code>100 Continue</code> to the client, indicating that the request body
 should be sent. See the <a href="#http2_event_checkcontinue"><code>'checkContinue'</code></a> event on <code>Http2Server</code> and
 <code>Http2SecureServer</code>.</p>
-<h4><code>response.writeHead(statusCode[, statusMessage][, headers])</code><span><a class="mark" href="#http2_response_writehead_statuscode_statusmessage_headers" id="http2_response_writehead_statuscode_statusmessage_headers">#</a></span></h4>
+<h5><code>response.writeHead(statusCode[, statusMessage][, headers])</code><span><a class="mark" href="#http2_response_writehead_statuscode_statusmessage_headers" id="http2_response_writehead_statuscode_statusmessage_headers">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.10.0</td>
+<tr><td>v11.10.0, v10.17.0</td>
 <td><p>Return <code>this</code> from <code>writeHead()</code> to allow chaining with <code>end()</code>.</p></td></tr>
 <tr><td>v8.4.0</td>
 <td><p><span>Added in: v8.4.0</span></p></td></tr>
@@ -40026,9 +43497,10 @@ passed as the second argument. However, because the <code>statusMessage</code> h
 meaning within HTTP/2, the argument will have no effect and a process warning
 will be emitted.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> body = <span class="hljs-string">'hello world'</span>;
-response.writeHead(<span class="hljs-number">200</span>, {
-  <span class="hljs-string">'Content-Length'</span>: Buffer.byteLength(body),
-  <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });</code></pre>
+response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, {
+  <span class="hljs-string">'Content-Length'</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(body),
+  <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span>,
+});</code></pre>
 <p><code>Content-Length</code> is given in bytes not characters. The
 <code>Buffer.byteLength()</code> API may be used to determine the number of bytes in a
 given encoding. On outbound messages, Node.js does not check if Content-Length
@@ -40043,49 +43515,29 @@ this, the implicit/mutable headers will be calculated and call this function.</p
 with any headers passed to <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a>, with the headers passed
 to <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> given precedence.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Returns content-type = text/plain</span>
-<span class="hljs-keyword">const</span> server = http2.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
-<h4><code>response.createPushResponse(headers, callback)</code><span><a class="mark" href="#http2_response_createpushresponse_headers_callback" id="http2_response_createpushresponse_headers_callback">#</a></span></h4>
-<div class="api_metadata">
-<span>Added in: v8.4.0</span>
-</div>
-<ul>
-<li><code>headers</code> <a href="#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a> An object describing the headers</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called once <code>http2stream.pushStream()</code> is finished,
-or either when the attempt to create the pushed <code>Http2Stream</code> has failed or
-has been rejected, or the state of <code>Http2ServerRequest</code> is closed prior to
-calling the <code>http2stream.pushStream()</code> method
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>stream</code> <a href="#http2_class_serverhttp2stream" class="type">&#x3C;ServerHttp2Stream></a> The newly-created <code>ServerHttp2Stream</code> object</li>
-</ul>
-</li>
-</ul>
-<p>Call <a href="#http2_http2stream_pushstream_headers_options_callback"><code>http2stream.pushStream()</code></a> with the given headers, and wrap the
-given <a href="#http2_class_http2stream"><code>Http2Stream</code></a> on a newly created <code>Http2ServerResponse</code> as the callback
-parameter if successful. When <code>Http2ServerRequest</code> is closed, the callback is
-called with an error <code>ERR_HTTP2_INVALID_STREAM</code>.</p>
-<h2>Collecting HTTP/2 performance metrics<span><a class="mark" href="#http2_collecting_http_2_performance_metrics" id="http2_collecting_http_2_performance_metrics">#</a></span></h2>
+</section><section><h3>Collecting HTTP/2 performance metrics<span><a class="mark" href="#http2_collecting_http_2_performance_metrics" id="http2_collecting_http_2_performance_metrics">#</a></span></h3>
 <p>The <a href="perf_hooks.html">Performance Observer</a> API can be used to collect basic performance
 metrics for each <code>Http2Session</code> and <code>Http2Stream</code> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { PerformanceObserver } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">PerformanceObserver</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">items</span>) =></span> {
-  <span class="hljs-keyword">const</span> entry = items.getEntries()[<span class="hljs-number">0</span>];
-  <span class="hljs-built_in">console</span>.log(entry.entryType);  <span class="hljs-comment">// prints 'http2'</span>
-  <span class="hljs-keyword">if</span> (entry.name === <span class="hljs-string">'Http2Session'</span>) {
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">items</span>) =></span> {
+  <span class="hljs-keyword">const</span> entry = items.<span class="hljs-title function_">getEntries</span>()[<span class="hljs-number">0</span>];
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(entry.<span class="hljs-property">entryType</span>);  <span class="hljs-comment">// prints 'http2'</span>
+  <span class="hljs-keyword">if</span> (entry.<span class="hljs-property">name</span> === <span class="hljs-string">'Http2Session'</span>) {
     <span class="hljs-comment">// Entry contains statistics about the Http2Session</span>
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (entry.name === <span class="hljs-string">'Http2Stream'</span>) {
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (entry.<span class="hljs-property">name</span> === <span class="hljs-string">'Http2Stream'</span>) {
     <span class="hljs-comment">// Entry contains statistics about the Http2Stream</span>
   }
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'http2'</span>] });</code></pre>
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'http2'</span>] });</code></pre>
 <p>The <code>entryType</code> property of the <code>PerformanceEntry</code> will be equal to <code>'http2'</code>.</p>
 <p>The <code>name</code> property of the <code>PerformanceEntry</code> will be equal to either
 <code>'Http2Stream'</code> or <code>'Http2Session'</code>.</p>
@@ -40123,14 +43575,15 @@ all <code>Http2Stream</code> instances.</li>
 the <code>Http2Session</code>.</li>
 <li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'server'</code> or <code>'client'</code> to identify the type of
 <code>Http2Session</code>.</li>
-</ul>
-<h1>HTTPS<span><a class="mark" href="#https_https" id="https_https">#</a></span></h1>
+</ul></section>
+        </section>
+<section><h2>HTTPS<span><a class="mark" href="#https_https" id="https_https">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/https.js">lib/https.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/https.js">lib/https.js</a></p>
 <p>HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
 separate module.</p>
-<h2>Class: <code>https.Agent</code><span><a class="mark" href="#https_class_https_agent" id="https_class_https_agent">#</a></span></h2>
+<section><h3>Class: <code>https.Agent</code><span><a class="mark" href="#https_class_https_agent" id="https_class_https_agent">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -40146,7 +43599,7 @@ separate module.</p>
 </div>
 <p>An <a href="#https_class_https_agent"><code>Agent</code></a> object for HTTPS similar to <a href="#http_class_http_agent"><code>http.Agent</code></a>. See
 <a href="#https_https_request_options_callback"><code>https.request()</code></a> for more information.</p>
-<h3><code>new Agent([options])</code><span><a class="mark" href="#https_new_agent_options" id="https_new_agent_options">#</a></span></h3>
+<h4><code>new Agent([options])</code><span><a class="mark" href="#https_new_agent_options" id="https_new_agent_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -40157,9 +43610,8 @@ separate module.</p>
 </details>
 </div>
 <ul>
-<li>
-<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Set of configurable options to set on the agent.
-Can have the same fields as for <a href="#http_new_agent_options"><code>http.Agent(options)</code></a>, and</p>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Set of configurable options to set on the agent.
+Can have the same fields as for <a href="#http_new_agent_options"><code>http.Agent(options)</code></a>, and
 <ul>
 <li>
 <p><code>maxCachedSessions</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> maximum number of TLS cached sessions.
@@ -40177,9 +43629,9 @@ extension).</p>
 </ul>
 </li>
 </ul>
-<h4>Event: <code>'keylog'</code><span><a class="mark" href="#https_event_keylog" id="https_event_keylog">#</a></span></h4>
+<h5>Event: <code>'keylog'</code><span><a class="mark" href="#https_event_keylog" id="https_event_keylog">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>line</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> Line of ASCII text, in NSS <code>SSLKEYLOGFILE</code> format.</li>
@@ -40194,10 +43646,10 @@ for each socket.</p>
 <p>A typical use case is to append received lines to a common text file, which is
 later used by software (such as Wireshark) to decrypt the traffic:</p>
 <pre><code class="language-js"><span class="hljs-comment">// ...</span>
-https.globalAgent.on(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line, tlsSocket</span>) =></span> {
-  fs.appendFileSync(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, line, { <span class="hljs-attr">mode</span>: <span class="hljs-number">0o600</span> });
+https.<span class="hljs-property">globalAgent</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line, tlsSocket</span>) =></span> {
+  fs.<span class="hljs-title function_">appendFileSync</span>(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, line, { <span class="hljs-attr">mode</span>: <span class="hljs-number">0o600</span> });
 });</code></pre>
-<h2>Class: <code>https.Server</code><span><a class="mark" href="#https_class_https_server" id="https_class_https_server">#</a></span></h2>
+</section><section><h3>Class: <code>https.Server</code><span><a class="mark" href="#https_class_https_server" id="https_class_https_server">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -40205,7 +43657,7 @@ https.globalAgent.on(<span class="hljs-string">'keylog'</span>, <span class="hlj
 <li>Extends: <a href="#tls_class_tls_server" class="type">&#x3C;tls.Server></a></li>
 </ul>
 <p>See <a href="#http_class_http_server"><code>http.Server</code></a> for more information.</p>
-<h3><code>server.close([callback])</code><span><a class="mark" href="#https_server_close_callback" id="https_server_close_callback">#</a></span></h3>
+<h4><code>server.close([callback])</code><span><a class="mark" href="#https_server_close_callback" id="https_server_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -40214,7 +43666,7 @@ https.globalAgent.on(<span class="hljs-string">'keylog'</span>, <span class="hlj
 <li>Returns: <a href="#https_class_https_server" class="type">&#x3C;https.Server></a></li>
 </ul>
 <p>See <a href="#http_server_close_callback"><code>server.close()</code></a> from the HTTP module for details.</p>
-<h3><code>server.headersTimeout</code><span><a class="mark" href="#https_server_headerstimeout" id="https_server_headerstimeout">#</a></span></h3>
+<h4><code>server.headersTimeout</code><span><a class="mark" href="#https_server_headerstimeout" id="https_server_headerstimeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.3.0</span>
 </div>
@@ -40222,15 +43674,23 @@ https.globalAgent.on(<span class="hljs-string">'keylog'</span>, <span class="hlj
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>60000</code></li>
 </ul>
 <p>See <a href="#http_server_headerstimeout"><code>http.Server#headersTimeout</code></a>.</p>
-<h3><code>server.listen()</code><span><a class="mark" href="#https_server_listen" id="https_server_listen">#</a></span></h3>
+<h4><code>server.listen()</code><span><a class="mark" href="#https_server_listen" id="https_server_listen">#</a></span></h4>
 <p>Starts the HTTPS server listening for encrypted connections.
 This method is identical to <a href="#net_server_listen"><code>server.listen()</code></a> from <a href="#net_class_net_server"><code>net.Server</code></a>.</p>
-<h3><code>server.maxHeadersCount</code><span><a class="mark" href="#https_server_maxheaderscount" id="https_server_maxheaderscount">#</a></span></h3>
+<h4><code>server.maxHeadersCount</code><span><a class="mark" href="#https_server_maxheaderscount" id="https_server_maxheaderscount">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>2000</code></li>
 </ul>
 <p>See <a href="#http_server_maxheaderscount"><code>http.Server#maxHeadersCount</code></a>.</p>
-<h3><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#https_server_settimeout_msecs_callback" id="https_server_settimeout_msecs_callback">#</a></span></h3>
+<h4><code>server.requestTimeout</code><span><a class="mark" href="#https_server_requesttimeout" id="https_server_requesttimeout">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.11.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>0</code></li>
+</ul>
+<p>See <a href="#http_server_requesttimeout"><code>http.Server#requestTimeout</code></a>.</p>
+<h4><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#https_server_settimeout_msecs_callback" id="https_server_settimeout_msecs_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -40240,15 +43700,23 @@ This method is identical to <a href="#net_server_listen"><code>server.listen()</
 <li>Returns: <a href="#https_class_https_server" class="type">&#x3C;https.Server></a></li>
 </ul>
 <p>See <a href="#http_server_settimeout_msecs_callback"><code>http.Server#setTimeout()</code></a>.</p>
-<h3><code>server.timeout</code><span><a class="mark" href="#https_server_timeout" id="https_server_timeout">#</a></span></h3>
+<h4><code>server.timeout</code><span><a class="mark" href="#https_server_timeout" id="https_server_timeout">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.11.2</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v0.11.2</td>
+<td><p><span>Added in: v0.11.2</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>120000</code> (2 minutes)</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> 0 (no timeout)</li>
 </ul>
 <p>See <a href="#http_server_timeout"><code>http.Server#timeout</code></a>.</p>
-<h3><code>server.keepAliveTimeout</code><span><a class="mark" href="#https_server_keepalivetimeout" id="https_server_keepalivetimeout">#</a></span></h3>
+<h4><code>server.keepAliveTimeout</code><span><a class="mark" href="#https_server_keepalivetimeout" id="https_server_keepalivetimeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -40256,7 +43724,7 @@ This method is identical to <a href="#net_server_listen"><code>server.listen()</
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>5000</code> (5 seconds)</li>
 </ul>
 <p>See <a href="#http_server_keepalivetimeout"><code>http.Server#keepAliveTimeout</code></a>.</p>
-<h2><code>https.createServer([options][, requestListener])</code><span><a class="mark" href="#https_https_createserver_options_requestlistener" id="https_https_createserver_options_requestlistener">#</a></span></h2>
+</section><section><h3><code>https.createServer([options][, requestListener])</code><span><a class="mark" href="#https_https_createserver_options_requestlistener" id="https_https_createserver_options_requestlistener">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -40271,29 +43739,29 @@ This method is identical to <a href="#net_server_listen"><code>server.listen()</
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">const</span> options = {
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>)
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>)
 };
 
-https.createServer(options, <span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.writeHead(<span class="hljs-number">200</span>);
-  res.end(<span class="hljs-string">'hello world\n'</span>);
-}).listen(<span class="hljs-number">8000</span>);</code></pre>
+https.<span class="hljs-title function_">createServer</span>(options, <span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'hello world\n'</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
 <p>Or</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> https = <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">const</span> options = {
-  <span class="hljs-attr">pfx</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/test_cert.pfx'</span>),
+  <span class="hljs-attr">pfx</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/test_cert.pfx'</span>),
   <span class="hljs-attr">passphrase</span>: <span class="hljs-string">'sample'</span>
 };
 
-https.createServer(options, <span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.writeHead(<span class="hljs-number">200</span>);
-  res.end(<span class="hljs-string">'hello world\n'</span>);
-}).listen(<span class="hljs-number">8000</span>);</code></pre>
-<h2><code>https.get(options[, callback])</code><span><a class="mark" href="#https_https_get_options_callback" id="https_https_get_options_callback">#</a></span></h2>
-<h2><code>https.get(url[, options][, callback])</code><span><a class="mark" href="#https_https_get_url_options_callback" id="https_https_get_url_options_callback">#</a></span></h2>
+https.<span class="hljs-title function_">createServer</span>(options, <span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'hello world\n'</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
+</section><section><h3><code>https.get(options[, callback])</code><span><a class="mark" href="#https_https_get_options_callback" id="https_https_get_options_callback">#</a></span></h3>
+</section><section><h3><code>https.get(url[, options][, callback])</code><span><a class="mark" href="#https_https_get_url_options_callback" id="https_https_get_url_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -40319,28 +43787,32 @@ string, it is automatically parsed with <a href="#url_new_url_input_base"><code>
 object, it will be automatically converted to an ordinary <code>options</code> object.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> https = <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);
 
-https.get(<span class="hljs-string">'https://encrypted.google.com/'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'statusCode:'</span>, res.statusCode);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'headers:'</span>, res.headers);
+https.<span class="hljs-title function_">get</span>(<span class="hljs-string">'https://encrypted.google.com/'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'statusCode:'</span>, res.<span class="hljs-property">statusCode</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'headers:'</span>, res.<span class="hljs-property">headers</span>);
 
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {
-    process.stdout.write(d);
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {
+    process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">write</span>(d);
   });
 
-}).on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(e);
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(e);
 });</code></pre>
-<h2><code>https.globalAgent</code><span><a class="mark" href="#https_https_globalagent" id="https_https_globalagent">#</a></span></h2>
+</section><section><h3><code>https.globalAgent</code><span><a class="mark" href="#https_https_globalagent" id="https_https_globalagent">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
 <p>Global instance of <a href="#https_class_https_agent"><code>https.Agent</code></a> for all HTTPS client requests.</p>
-<h2><code>https.request(options[, callback])</code><span><a class="mark" href="#https_https_request_options_callback" id="https_https_request_options_callback">#</a></span></h2>
-<h2><code>https.request(url[, options][, callback])</code><span><a class="mark" href="#https_https_request_url_options_callback" id="https_https_request_url_options_callback">#</a></span></h2>
+</section><section><h3><code>https.request(options[, callback])</code><span><a class="mark" href="#https_https_request_options_callback" id="https_https_request_options_callback">#</a></span></h3>
+</section><section><h3><code>https.request(url[, options][, callback])</code><span><a class="mark" href="#https_https_request_url_options_callback" id="https_https_request_url_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>When using a <code>URL</code> object parsed username and password will now be properly URI decoded.</p></td></tr>
+<tr><td>v14.1.0</td>
+<td><p>The <code>highWaterMark</code> option is accepted now.</p></td></tr>
 <tr><td>v10.9.0</td>
 <td><p>The <code>url</code> parameter can now be passed along with a separate <code>options</code> object.</p></td></tr>
 <tr><td>v9.3.0</td>
@@ -40363,15 +43835,20 @@ https.get(<span class="hljs-string">'https://encrypted.google.com/'</span>, <spa
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+<li>Returns: <a href="#http_class_http_clientrequest" class="type">&#x3C;http.ClientRequest></a></li>
 </ul>
 <p>Makes a request to a secure web server.</p>
 <p>The following additional <code>options</code> from <a href="#tls_tls_connect_options_callback"><code>tls.connect()</code></a> are also accepted:
 <code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,
 <code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,
-<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>.</p>
+<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>,
+<code>highWaterMark</code>.</p>
 <p><code>options</code> can be an object, a string, or a <a href="#url_the_whatwg_url_api"><code>URL</code></a> object. If <code>options</code> is a
 string, it is automatically parsed with <a href="#url_new_url_input_base"><code>new URL()</code></a>. If it is a <a href="#url_the_whatwg_url_api"><code>URL</code></a>
 object, it will be automatically converted to an ordinary <code>options</code> object.</p>
+<p><code>https.request()</code> returns an instance of the <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>
+class. The <code>ClientRequest</code> instance is a writable stream. If one needs to
+upload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> https = <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);
 
 <span class="hljs-keyword">const</span> options = {
@@ -40381,31 +43858,31 @@ object, it will be automatically converted to an ordinary <code>options</code> o
   <span class="hljs-attr">method</span>: <span class="hljs-string">'GET'</span>
 };
 
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'statusCode:'</span>, res.statusCode);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'headers:'</span>, res.headers);
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'statusCode:'</span>, res.<span class="hljs-property">statusCode</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'headers:'</span>, res.<span class="hljs-property">headers</span>);
 
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {
-    process.stdout.write(d);
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {
+    process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">write</span>(d);
   });
 });
 
-req.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(e);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(e);
 });
-req.end();</code></pre>
+req.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example using options from <a href="#tls_tls_connect_options_callback"><code>tls.connect()</code></a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">hostname</span>: <span class="hljs-string">'encrypted.google.com'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">443</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'GET'</span>,
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>)
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>)
 };
-options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
+options.<span class="hljs-property">agent</span> = <span class="hljs-keyword">new</span> https.<span class="hljs-title class_">Agent</span>(options);
 
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>Alternatively, opt out of connection pooling by not using an <a href="#https_class_https_agent"><code>Agent</code></a>.</p>
@@ -40414,18 +43891,18 @@ options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
   <span class="hljs-attr">port</span>: <span class="hljs-number">443</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'GET'</span>,
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>),
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>),
   <span class="hljs-attr">agent</span>: <span class="hljs-literal">false</span>
 };
 
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>Example using a <a href="#url_the_whatwg_url_api"><code>URL</code></a> as <code>options</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> options = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> options = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
 
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>Example pinning on certificate fingerprint, or the public key (similar to
@@ -40434,38 +43911,38 @@ options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
 <span class="hljs-keyword">const</span> https = <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">sha256</span>(<span class="hljs-params">s</span>) </span>{
-  <span class="hljs-keyword">return</span> crypto.createHash(<span class="hljs-string">'sha256'</span>).update(s).digest(<span class="hljs-string">'base64'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">sha256</span>(<span class="hljs-params">s</span>) {
+  <span class="hljs-keyword">return</span> crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>).<span class="hljs-title function_">update</span>(s).<span class="hljs-title function_">digest</span>(<span class="hljs-string">'base64'</span>);
 }
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">hostname</span>: <span class="hljs-string">'github.com'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">443</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'GET'</span>,
-  <span class="hljs-attr">checkServerIdentity</span>: <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">host, cert</span>) </span>{
+  <span class="hljs-attr">checkServerIdentity</span>: <span class="hljs-keyword">function</span>(<span class="hljs-params">host, cert</span>) {
     <span class="hljs-comment">// Make sure the certificate is issued to the host we are connected to</span>
-    <span class="hljs-keyword">const</span> err = tls.checkServerIdentity(host, cert);
+    <span class="hljs-keyword">const</span> err = tls.<span class="hljs-title function_">checkServerIdentity</span>(host, cert);
     <span class="hljs-keyword">if</span> (err) {
       <span class="hljs-keyword">return</span> err;
     }
 
     <span class="hljs-comment">// Pin the public key, similar to HPKP pin-sha25 pinning</span>
     <span class="hljs-keyword">const</span> pubkey256 = <span class="hljs-string">'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU='</span>;
-    <span class="hljs-keyword">if</span> (sha256(cert.pubkey) !== pubkey256) {
+    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">sha256</span>(cert.<span class="hljs-property">pubkey</span>) !== pubkey256) {
       <span class="hljs-keyword">const</span> msg = <span class="hljs-string">'Certificate verification error: '</span> +
         <span class="hljs-string">`The public key of '<span class="hljs-subst">${cert.subject.CN}</span>' `</span> +
         <span class="hljs-string">'does not match our pinned fingerprint'</span>;
-      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(msg);
+      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(msg);
     }
 
     <span class="hljs-comment">// Pin the exact certificate, rather than the pub key</span>
     <span class="hljs-keyword">const</span> cert256 = <span class="hljs-string">'25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:'</span> +
       <span class="hljs-string">'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16'</span>;
-    <span class="hljs-keyword">if</span> (cert.fingerprint256 !== cert256) {
+    <span class="hljs-keyword">if</span> (cert.<span class="hljs-property">fingerprint256</span> !== cert256) {
       <span class="hljs-keyword">const</span> msg = <span class="hljs-string">'Certificate verification error: '</span> +
         <span class="hljs-string">`The certificate of '<span class="hljs-subst">${cert.subject.CN}</span>' `</span> +
         <span class="hljs-string">'does not match our pinned fingerprint'</span>;
-      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(msg);
+      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(msg);
     }
 
     <span class="hljs-comment">// This loop is informational only.</span>
@@ -40474,33 +43951,33 @@ options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
     <span class="hljs-comment">// internet, while pinning the public key of the service in sensitive</span>
     <span class="hljs-comment">// environments.</span>
     <span class="hljs-keyword">do</span> {
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Subject Common Name:'</span>, cert.subject.CN);
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'  Certificate SHA256 fingerprint:'</span>, cert.fingerprint256);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Subject Common Name:'</span>, cert.<span class="hljs-property">subject</span>.<span class="hljs-property">CN</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'  Certificate SHA256 fingerprint:'</span>, cert.<span class="hljs-property">fingerprint256</span>);
 
-      hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'  Public key ping-sha256:'</span>, sha256(cert.pubkey));
+      hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'  Public key ping-sha256:'</span>, <span class="hljs-title function_">sha256</span>(cert.<span class="hljs-property">pubkey</span>));
 
-      lastprint256 = cert.fingerprint256;
-      cert = cert.issuerCertificate;
-    } <span class="hljs-keyword">while</span> (cert.fingerprint256 !== lastprint256);
+      lastprint256 = cert.<span class="hljs-property">fingerprint256</span>;
+      cert = cert.<span class="hljs-property">issuerCertificate</span>;
+    } <span class="hljs-keyword">while</span> (cert.<span class="hljs-property">fingerprint256</span> !== lastprint256);
 
   },
 };
 
-options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'All OK. Server matched our pinned cert or public key'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'statusCode:'</span>, res.statusCode);
+options.<span class="hljs-property">agent</span> = <span class="hljs-keyword">new</span> https.<span class="hljs-title class_">Agent</span>(options);
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'All OK. Server matched our pinned cert or public key'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'statusCode:'</span>, res.<span class="hljs-property">statusCode</span>);
   <span class="hljs-comment">// Print the HPKP values</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'headers:'</span>, res.headers[<span class="hljs-string">'public-key-pins'</span>]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'headers:'</span>, res.<span class="hljs-property">headers</span>[<span class="hljs-string">'public-key-pins'</span>]);
 
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {});
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {});
 });
 
-req.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(e.message);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(e.<span class="hljs-property">message</span>);
 });
-req.end();</code></pre>
+req.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Outputs for example:</p>
 <pre><code class="language-text">Subject Common Name: github.com
   Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16
@@ -40513,24 +43990,25 @@ Subject Common Name: DigiCert High Assurance EV Root CA
   Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=
 All OK. Server matched our pinned cert or public key
 statusCode: 200
-headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho="; pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4="; pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains</code></pre>
-<h1>Inspector<span><a class="mark" href="#inspector_inspector" id="inspector_inspector">#</a></span></h1>
+headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho="; pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4="; pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains</code></pre></section>
+        </section>
+<section><h2>Inspector<span><a class="mark" href="#inspector_inspector" id="inspector_inspector">#</a></span></h2>
 
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/inspector.js">lib/inspector.js</a></p>
+<p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/inspector.js">lib/inspector.js</a></p>
 <p>The <code>inspector</code> module provides an API for interacting with the V8 inspector.</p>
 <p>It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> inspector = <span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>);</code></pre>
-<h2><code>inspector.close()</code><span><a class="mark" href="#inspector_inspector_close" id="inspector_inspector_close">#</a></span></h2>
+<section><h3><code>inspector.close()</code><span><a class="mark" href="#inspector_inspector_close" id="inspector_inspector_close">#</a></span></h3>
 <p>Deactivate the inspector. Blocks until there are no active connections.</p>
-<h2><code>inspector.console</code><span><a class="mark" href="#inspector_inspector_console" id="inspector_inspector_console">#</a></span></h2>
+</section><section><h3><code>inspector.console</code><span><a class="mark" href="#inspector_inspector_console" id="inspector_inspector_console">#</a></span></h3>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> An object to send messages to the remote inspector console.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>).console.log(<span class="hljs-string">'a message'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>).<span class="hljs-property">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a message'</span>);</code></pre>
 <p>The inspector console does not have API parity with Node.js
 console.</p>
-<h2><code>inspector.open([port[, host[, wait]]])</code><span><a class="mark" href="#inspector_inspector_open_port_host_wait" id="inspector_inspector_open_port_host_wait">#</a></span></h2>
+</section><section><h3><code>inspector.open([port[, host[, wait]]])</code><span><a class="mark" href="#inspector_inspector_open_port_host_wait" id="inspector_inspector_open_port_host_wait">#</a></span></h3>
 <ul>
 <li><code>port</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Port to listen on for inspector connections. Optional.
 <strong>Default:</strong> what was specified on the CLI.</li>
@@ -40545,44 +44023,44 @@ started.</p>
 and flow control has been passed to the debugger client.</p>
 <p>See the <a href="#inspector_security">security warning</a> regarding the <code>host</code>
 parameter usage.</p>
-<h2><code>inspector.url()</code><span><a class="mark" href="#inspector_inspector_url" id="inspector_inspector_url">#</a></span></h2>
+</section><section><h3><code>inspector.url()</code><span><a class="mark" href="#inspector_inspector_url" id="inspector_inspector_url">#</a></span></h3>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
 </ul>
 <p>Return the URL of the active inspector, or <code>undefined</code> if there is none.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --inspect -p <span class="hljs-string">'inspector.url()'</span></span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --inspect -p <span class="hljs-string">'inspector.url()'</span></span>
 Debugger listening on ws://127.0.0.1:9229/166e272e-7a30-4d09-97ce-f1c012b43c34
 For help see https://nodejs.org/en/docs/inspector
 ws://127.0.0.1:9229/166e272e-7a30-4d09-97ce-f1c012b43c34
 <span class="hljs-meta">
-$</span><span class="bash"> node --inspect=localhost:3000 -p <span class="hljs-string">'inspector.url()'</span></span>
+$ </span><span class="language-bash">node --inspect=localhost:3000 -p <span class="hljs-string">'inspector.url()'</span></span>
 Debugger listening on ws://localhost:3000/51cf8d0e-3c36-4c59-8efd-54519839e56a
 For help see https://nodejs.org/en/docs/inspector
 ws://localhost:3000/51cf8d0e-3c36-4c59-8efd-54519839e56a
 <span class="hljs-meta">
-$</span><span class="bash"> node -p <span class="hljs-string">'inspector.url()'</span></span>
+$ </span><span class="language-bash">node -p <span class="hljs-string">'inspector.url()'</span></span>
 undefined</code></pre>
-<h2><code>inspector.waitForDebugger()</code><span><a class="mark" href="#inspector_inspector_waitfordebugger" id="inspector_inspector_waitfordebugger">#</a></span></h2>
+</section><section><h3><code>inspector.waitForDebugger()</code><span><a class="mark" href="#inspector_inspector_waitfordebugger" id="inspector_inspector_waitfordebugger">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
 <p>Blocks until a client (existing or connected later) has sent
 <code>Runtime.runIfWaitingForDebugger</code> command.</p>
 <p>An exception will be thrown if there is no active inspector.</p>
-<h2>Class: <code>inspector.Session</code><span><a class="mark" href="#inspector_class_inspector_session" id="inspector_class_inspector_session">#</a></span></h2>
+</section><section><h3>Class: <code>inspector.Session</code><span><a class="mark" href="#inspector_class_inspector_session" id="inspector_class_inspector_session">#</a></span></h3>
 <ul>
 <li>Extends: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
 <p>The <code>inspector.Session</code> is used for dispatching messages to the V8 inspector
 back-end and receiving message responses and notifications.</p>
-<h3><code>new inspector.Session()</code><span><a class="mark" href="#inspector_new_inspector_session" id="inspector_new_inspector_session">#</a></span></h3>
+<h4><code>new inspector.Session()</code><span><a class="mark" href="#inspector_new_inspector_session" id="inspector_new_inspector_session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>Create a new instance of the <code>inspector.Session</code> class. The inspector session
 needs to be connected through <a href="#inspector_session_connect"><code>session.connect()</code></a> before the messages
 can be dispatched to the inspector backend.</p>
-<h3>Event: <code>'inspectorNotification'</code><span><a class="mark" href="#inspector_event_inspectornotification" id="inspector_event_inspectornotification">#</a></span></h3>
+<h4>Event: <code>'inspectorNotification'</code><span><a class="mark" href="#inspector_event_inspectornotification" id="inspector_event_inspectornotification">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -40590,11 +44068,11 @@ can be dispatched to the inspector backend.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The notification message object</li>
 </ul>
 <p>Emitted when any notification from the V8 Inspector is received.</p>
-<pre><code class="language-js">session.on(<span class="hljs-string">'inspectorNotification'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(message.method));
+<pre><code class="language-js">session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'inspectorNotification'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message.<span class="hljs-property">method</span>));
 <span class="hljs-comment">// Debugger.paused</span>
 <span class="hljs-comment">// Debugger.resumed</span></code></pre>
 <p>It is also possible to subscribe only to notifications with specific method:</p>
-<h3>Event: <code>&#x3C;inspector-protocol-method></code>;<span><a class="mark" href="#inspector_event_inspector_protocol_method" id="inspector_event_inspector_protocol_method">#</a></span></h3>
+<h4>Event: <code>&#x3C;inspector-protocol-method></code>;<span><a class="mark" href="#inspector_event_inspector_protocol_method" id="inspector_event_inspector_protocol_method">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -40606,22 +44084,22 @@ to the <code>&#x3C;inspector-protocol-method></code> value.</p>
 <p>The following snippet installs a listener on the <a href="https://chromedevtools.github.io/devtools-protocol/v8/Debugger#event-paused"><code>'Debugger.paused'</code></a>
 event, and prints the reason for program suspension whenever program
 execution is suspended (through breakpoints, for example):</p>
-<pre><code class="language-js">session.on(<span class="hljs-string">'Debugger.paused'</span>, <span class="hljs-function">(<span class="hljs-params">{ params }</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(params.hitBreakpoints);
+<pre><code class="language-js">session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'Debugger.paused'</span>, <span class="hljs-function">(<span class="hljs-params">{ params }</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-property">hitBreakpoints</span>);
 });
 <span class="hljs-comment">// [ '/the/file/that/has/the/breakpoint.js:11:0' ]</span></code></pre>
-<h3><code>session.connect()</code><span><a class="mark" href="#inspector_session_connect" id="inspector_session_connect">#</a></span></h3>
+<h4><code>session.connect()</code><span><a class="mark" href="#inspector_session_connect" id="inspector_session_connect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>Connects a session to the inspector back-end.</p>
-<h3><code>session.connectToMainThread()</code><span><a class="mark" href="#inspector_session_connecttomainthread" id="inspector_session_connecttomainthread">#</a></span></h3>
+<h4><code>session.connectToMainThread()</code><span><a class="mark" href="#inspector_session_connecttomainthread" id="inspector_session_connecttomainthread">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.11.0</span>
 </div>
 <p>Connects a session to the main thread inspector back-end. An exception will
 be thrown if this API was not called on a Worker thread.</p>
-<h3><code>session.disconnect()</code><span><a class="mark" href="#inspector_session_disconnect" id="inspector_session_disconnect">#</a></span></h3>
+<h4><code>session.disconnect()</code><span><a class="mark" href="#inspector_session_disconnect" id="inspector_session_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -40629,7 +44107,7 @@ be thrown if this API was not called on a Worker thread.</p>
 with an error. <a href="#inspector_session_connect"><code>session.connect()</code></a> will need to be called to be able to send
 messages again. Reconnected session will lose all inspector state, such as
 enabled agents or configured breakpoints.</p>
-<h3><code>session.post(method[, params][, callback])</code><span><a class="mark" href="#inspector_session_post_method_params_callback" id="inspector_session_post_method_params_callback">#</a></span></h3>
+<h4><code>session.post(method[, params][, callback])</code><span><a class="mark" href="#inspector_session_post_method_params_callback" id="inspector_session_post_method_params_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -40641,8 +44119,8 @@ enabled agents or configured breakpoints.</p>
 <p>Posts a message to the inspector back-end. <code>callback</code> will be notified when
 a response is received. <code>callback</code> is a function that accepts two optional
 arguments: error and message-specific result.</p>
-<pre><code class="language-js">session.post(<span class="hljs-string">'Runtime.evaluate'</span>, { <span class="hljs-attr">expression</span>: <span class="hljs-string">'2 + 2'</span> },
-             <span class="hljs-function">(<span class="hljs-params">error, { result }</span>) =></span> <span class="hljs-built_in">console</span>.log(result));
+<pre><code class="language-js">session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'Runtime.evaluate'</span>, { <span class="hljs-attr">expression</span>: <span class="hljs-string">'2 + 2'</span> },
+             <span class="hljs-function">(<span class="hljs-params">error, { result }</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result));
 <span class="hljs-comment">// Output: { type: 'number', value: 4, description: '4' }</span></code></pre>
 <p>The latest version of the V8 inspector protocol is published on the
 <a href="https://chromedevtools.github.io/devtools-protocol/v8/">Chrome DevTools Protocol Viewer</a>.</p>
@@ -40650,49 +44128,50 @@ arguments: error and message-specific result.</p>
 by V8. Chrome DevTools Protocol domain provides an interface for interacting
 with one of the runtime agents used to inspect the application state and listen
 to the run-time events.</p>
-<h2>Example usage<span><a class="mark" href="#inspector_example_usage" id="inspector_example_usage">#</a></span></h2>
+</section><section><h3>Example usage<span><a class="mark" href="#inspector_example_usage" id="inspector_example_usage">#</a></span></h3>
 <p>Apart from the debugger, various V8 Profilers are available through the DevTools
 protocol.</p>
-<h3>CPU profiler<span><a class="mark" href="#inspector_cpu_profiler" id="inspector_cpu_profiler">#</a></span></h3>
+<h4>CPU profiler<span><a class="mark" href="#inspector_cpu_profiler" id="inspector_cpu_profiler">#</a></span></h4>
 <p>Here's an example showing how to use the <a href="https://chromedevtools.github.io/devtools-protocol/v8/Profiler">CPU Profiler</a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> inspector = <span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> session = <span class="hljs-keyword">new</span> inspector.Session();
-session.connect();
+<span class="hljs-keyword">const</span> session = <span class="hljs-keyword">new</span> inspector.<span class="hljs-title class_">Session</span>();
+session.<span class="hljs-title function_">connect</span>();
 
-session.post(<span class="hljs-string">'Profiler.enable'</span>, <span class="hljs-function">() =></span> {
-  session.post(<span class="hljs-string">'Profiler.start'</span>, <span class="hljs-function">() =></span> {
+session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'Profiler.enable'</span>, <span class="hljs-function">() =></span> {
+  session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'Profiler.start'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-comment">// Invoke business logic under measurement here...</span>
 
     <span class="hljs-comment">// some time later...</span>
-    session.post(<span class="hljs-string">'Profiler.stop'</span>, <span class="hljs-function">(<span class="hljs-params">err, { profile }</span>) =></span> {
+    session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'Profiler.stop'</span>, <span class="hljs-function">(<span class="hljs-params">err, { profile }</span>) =></span> {
       <span class="hljs-comment">// Write profile to disk, upload, etc.</span>
       <span class="hljs-keyword">if</span> (!err) {
-        fs.writeFileSync(<span class="hljs-string">'./profile.cpuprofile'</span>, <span class="hljs-built_in">JSON</span>.stringify(profile));
+        fs.<span class="hljs-title function_">writeFileSync</span>(<span class="hljs-string">'./profile.cpuprofile'</span>, <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(profile));
       }
     });
   });
 });</code></pre>
-<h3>Heap profiler<span><a class="mark" href="#inspector_heap_profiler" id="inspector_heap_profiler">#</a></span></h3>
+<h4>Heap profiler<span><a class="mark" href="#inspector_heap_profiler" id="inspector_heap_profiler">#</a></span></h4>
 <p>Here's an example showing how to use the <a href="https://chromedevtools.github.io/devtools-protocol/v8/HeapProfiler">Heap Profiler</a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> inspector = <span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> session = <span class="hljs-keyword">new</span> inspector.Session();
+<span class="hljs-keyword">const</span> session = <span class="hljs-keyword">new</span> inspector.<span class="hljs-title class_">Session</span>();
 
-<span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'profile.heapsnapshot'</span>, <span class="hljs-string">'w'</span>);
+<span class="hljs-keyword">const</span> fd = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'profile.heapsnapshot'</span>, <span class="hljs-string">'w'</span>);
 
-session.connect();
+session.<span class="hljs-title function_">connect</span>();
 
-session.on(<span class="hljs-string">'HeapProfiler.addHeapSnapshotChunk'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
-  fs.writeSync(fd, m.params.chunk);
+session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'HeapProfiler.addHeapSnapshotChunk'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
+  fs.<span class="hljs-title function_">writeSync</span>(fd, m.<span class="hljs-property">params</span>.<span class="hljs-property">chunk</span>);
 });
 
-session.post(<span class="hljs-string">'HeapProfiler.takeHeapSnapshot'</span>, <span class="hljs-literal">null</span>, <span class="hljs-function">(<span class="hljs-params">err, r</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'HeapProfiler.takeHeapSnapshot done:'</span>, err, r);
-  session.disconnect();
-  fs.closeSync(fd);
-});</code></pre>
-<h1>Internationalization support<span><a class="mark" href="#intl_internationalization_support" id="intl_internationalization_support">#</a></span></h1>
+session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'HeapProfiler.takeHeapSnapshot'</span>, <span class="hljs-literal">null</span>, <span class="hljs-function">(<span class="hljs-params">err, r</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'HeapProfiler.takeHeapSnapshot done:'</span>, err, r);
+  session.<span class="hljs-title function_">disconnect</span>();
+  fs.<span class="hljs-title function_">closeSync</span>(fd);
+});</code></pre></section>
+        </section>
+<section><h2>Internationalization support<span><a class="mark" href="#intl_internationalization_support" id="intl_internationalization_support">#</a></span></h2>
 
 
 <p>Node.js has many features that make it easier to write internationalized
@@ -40720,22 +44199,21 @@ Specification</a> (aka ECMA-402):
 <li><a href="#util_class_util_textdecoder"><code>require('util').TextDecoder</code></a></li>
 <li><a href="https://github.com/tc39/proposal-regexp-unicode-property-escapes"><code>RegExp</code> Unicode Property Escapes</a></li>
 </ul>
-<p>Node.js (and its underlying V8 engine) uses <a href="http://site.icu-project.org/">ICU</a> to implement these features
-in native C/C++ code. However, some of them require a very large ICU data file
-in order to support all locales of the world. Because it is expected that most
-Node.js users will make use of only a small portion of ICU functionality, only
-a subset of the full ICU data set is provided by Node.js by default. Several
-options are provided for customizing and expanding the ICU data set either when
+<p>Node.js and the underlying V8 engine use
+<a href="http://site.icu-project.org/">International Components for Unicode (ICU)</a> to implement these features
+in native C/C++ code. The full ICU data set is provided by Node.js by default.
+However, due to the size of the ICU data file, several
+options are provided for customizing the ICU data set either when
 building or running Node.js.</p>
-<h2>Options for building Node.js<span><a class="mark" href="#intl_options_for_building_node_js" id="intl_options_for_building_node_js">#</a></span></h2>
+<section><h3>Options for building Node.js<span><a class="mark" href="#intl_options_for_building_node_js" id="intl_options_for_building_node_js">#</a></span></h3>
 <p>To control how ICU is used in Node.js, four <code>configure</code> options are available
 during compilation. Additional details on how to compile Node.js are documented
-in <a href="https://github.com/nodejs/node/blob/master/BUILDING.md">BUILDING.md</a>.</p>
+in <a href="https://github.com/nodejs/node/blob/HEAD/BUILDING.md">BUILDING.md</a>.</p>
 <ul>
 <li><code>--with-intl=none</code>/<code>--without-intl</code></li>
 <li><code>--with-intl=system-icu</code></li>
-<li><code>--with-intl=small-icu</code> (default)</li>
-<li><code>--with-intl=full-icu</code></li>
+<li><code>--with-intl=small-icu</code></li>
+<li><code>--with-intl=full-icu</code> (default)</li>
 </ul>
 <p>An overview of available Node.js and JavaScript features for each <code>configure</code>
 option:</p>
@@ -40835,15 +44313,15 @@ option:</p>
 
 
 
-<table><thead><tr><th></th><th><code>none</code></th><th><code>system-icu</code></th><th><code>small-icu</code></th><th><code>full-icu</code></th></tr></thead><tbody><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize"><code>String.prototype.normalize()</code></a></td><td>none (function is no-op)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><code>String.prototype.to*Case()</code></td><td>full</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl"><code>Intl</code></a></td><td>none (object does not exist)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare"><code>String.prototype.localeCompare()</code></a></td><td>partial (not locale-aware)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><code>String.prototype.toLocale*Case()</code></td><td>partial (not locale-aware)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString"><code>Number.prototype.toLocaleString()</code></a></td><td>partial (not locale-aware)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><code>Date.prototype.toLocale*String()</code></td><td>partial (not locale-aware)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><a href="#url_the_whatwg_url_api">WHATWG URL Parser</a></td><td>partial (no IDN support)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="#buffer_buffer_transcode_source_fromenc_toenc"><code>require('buffer').transcode()</code></a></td><td>none (function does not exist)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="#repl_repl">REPL</a></td><td>partial (inaccurate line editing)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="#util_class_util_textdecoder"><code>require('util').TextDecoder</code></a></td><td>partial (basic encodings support)</td><td>partial/full (depends on OS)</td><td>partial (Unicode-only)</td><td>full</td></tr><tr><td><a href="https://github.com/tc39/proposal-regexp-unicode-property-escapes"><code>RegExp</code> Unicode Property Escapes</a></td><td>none (invalid <code>RegExp</code> error)</td><td>full</td><td>full</td><td>full</td></tr></tbody></table>
+<table><thead><tr><th>Feature</th><th><code>none</code></th><th><code>system-icu</code></th><th><code>small-icu</code></th><th><code>full-icu</code></th></tr></thead><tbody><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize"><code>String.prototype.normalize()</code></a></td><td>none (function is no-op)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><code>String.prototype.to*Case()</code></td><td>full</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl"><code>Intl</code></a></td><td>none (object does not exist)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare"><code>String.prototype.localeCompare()</code></a></td><td>partial (not locale-aware)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><code>String.prototype.toLocale*Case()</code></td><td>partial (not locale-aware)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString"><code>Number.prototype.toLocaleString()</code></a></td><td>partial (not locale-aware)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><code>Date.prototype.toLocale*String()</code></td><td>partial (not locale-aware)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><a href="#url_the_whatwg_url_api">WHATWG URL Parser</a></td><td>partial (no IDN support)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="#buffer_buffer_transcode_source_fromenc_toenc"><code>require('buffer').transcode()</code></a></td><td>none (function does not exist)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="#repl_repl">REPL</a></td><td>partial (inaccurate line editing)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="#util_class_util_textdecoder"><code>require('util').TextDecoder</code></a></td><td>partial (basic encodings support)</td><td>partial/full (depends on OS)</td><td>partial (Unicode-only)</td><td>full</td></tr><tr><td><a href="https://github.com/tc39/proposal-regexp-unicode-property-escapes"><code>RegExp</code> Unicode Property Escapes</a></td><td>none (invalid <code>RegExp</code> error)</td><td>full</td><td>full</td><td>full</td></tr></tbody></table>
 <p>The "(not locale-aware)" designation denotes that the function carries out its
 operation just like the non-<code>Locale</code> version of the function, if one
 exists. For example, under <code>none</code> mode, <code>Date.prototype.toLocaleString()</code>'s
 operation is identical to that of <code>Date.prototype.toString()</code>.</p>
-<h3>Disable all internationalization features (<code>none</code>)<span><a class="mark" href="#intl_disable_all_internationalization_features_none" id="intl_disable_all_internationalization_features_none">#</a></span></h3>
-<p>If this option is chosen, most internationalization features mentioned above
-will be <strong>unavailable</strong> in the resulting <code>node</code> binary.</p>
-<h3>Build with a pre-installed ICU (<code>system-icu</code>)<span><a class="mark" href="#intl_build_with_a_pre_installed_icu_system_icu" id="intl_build_with_a_pre_installed_icu_system_icu">#</a></span></h3>
+<h4>Disable all internationalization features (<code>none</code>)<span><a class="mark" href="#intl_disable_all_internationalization_features_none" id="intl_disable_all_internationalization_features_none">#</a></span></h4>
+<p>If this option is chosen, ICU is disabled and most internationalization
+features mentioned above will be <strong>unavailable</strong> in the resulting <code>node</code> binary.</p>
+<h4>Build with a pre-installed ICU (<code>system-icu</code>)<span><a class="mark" href="#intl_build_with_a_pre_installed_icu_system_icu" id="intl_build_with_a_pre_installed_icu_system_icu">#</a></span></h4>
 <p>Node.js can link against an ICU build already installed on the system. In fact,
 most Linux distributions already come with ICU installed, and this option would
 make it possible to reuse the same set of data used by other components in the
@@ -40854,7 +44332,7 @@ supported under <code>system-icu</code>. Features that require ICU locale data i
 addition, such as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat"><code>Intl.DateTimeFormat</code></a> <em>may</em> be fully or partially
 supported, depending on the completeness of the ICU data installed on the
 system.</p>
-<h3>Embed a limited set of ICU data (<code>small-icu</code>)<span><a class="mark" href="#intl_embed_a_limited_set_of_icu_data_small_icu" id="intl_embed_a_limited_set_of_icu_data_small_icu">#</a></span></h3>
+<h4>Embed a limited set of ICU data (<code>small-icu</code>)<span><a class="mark" href="#intl_embed_a_limited_set_of_icu_data_small_icu" id="intl_embed_a_limited_set_of_icu_data_small_icu">#</a></span></h4>
 <p>This option makes the resulting binary link against the ICU library statically,
 and includes a subset of ICU data (typically only the English locale) within
 the <code>node</code> executable.</p>
@@ -40862,19 +44340,17 @@ the <code>node</code> executable.</p>
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize"><code>String.prototype.normalize()</code></a> and the <a href="#url_the_whatwg_url_api">WHATWG URL parser</a>, are fully
 supported under <code>small-icu</code>. Features that require ICU locale data in addition,
 such as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat"><code>Intl.DateTimeFormat</code></a>, generally only work with the English locale:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> january = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>(<span class="hljs-number">9e8</span>);
-<span class="hljs-keyword">const</span> english = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Intl</span>.DateTimeFormat(<span class="hljs-string">'en'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
-<span class="hljs-keyword">const</span> spanish = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Intl</span>.DateTimeFormat(<span class="hljs-string">'es'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> january = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>(<span class="hljs-number">9e8</span>);
+<span class="hljs-keyword">const</span> english = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Intl</span>.<span class="hljs-title class_">DateTimeFormat</span>(<span class="hljs-string">'en'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
+<span class="hljs-keyword">const</span> spanish = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Intl</span>.<span class="hljs-title class_">DateTimeFormat</span>(<span class="hljs-string">'es'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
 
-<span class="hljs-built_in">console</span>.log(english.format(january));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(english.<span class="hljs-title function_">format</span>(january));
 <span class="hljs-comment">// Prints "January"</span>
-<span class="hljs-built_in">console</span>.log(spanish.format(january));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(spanish.<span class="hljs-title function_">format</span>(january));
 <span class="hljs-comment">// Prints "M01" on small-icu</span>
 <span class="hljs-comment">// Should print "enero"</span></code></pre>
-<p>This mode provides a good balance between features and binary size, and it is
-the default behavior if no <code>--with-intl</code> flag is passed. The official binaries
-are also built in this mode.</p>
-<h4>Providing ICU data at runtime<span><a class="mark" href="#intl_providing_icu_data_at_runtime" id="intl_providing_icu_data_at_runtime">#</a></span></h4>
+<p>This mode provides a balance between features and binary size.</p>
+<h5>Providing ICU data at runtime<span><a class="mark" href="#intl_providing_icu_data_at_runtime" id="intl_providing_icu_data_at_runtime">#</a></span></h5>
 <p>If the <code>small-icu</code> option is used, one can still provide additional locale data
 at runtime so that the JS methods would work for all ICU locales. Assuming the
 data file is stored at <code>/some/directory</code>, it can be made available to ICU
@@ -40902,25 +44378,26 @@ appropriate data file. After installing the module through <code>npm i full-icu<
 the data file will be available at <code>./node_modules/full-icu</code>. This path can be
 then passed either to <code>NODE_ICU_DATA</code> or <code>--icu-data-dir</code> as shown above to
 enable full <code>Intl</code> support.</p>
-<h3>Embed the entire ICU (<code>full-icu</code>)<span><a class="mark" href="#intl_embed_the_entire_icu_full_icu" id="intl_embed_the_entire_icu_full_icu">#</a></span></h3>
+<h4>Embed the entire ICU (<code>full-icu</code>)<span><a class="mark" href="#intl_embed_the_entire_icu_full_icu" id="intl_embed_the_entire_icu_full_icu">#</a></span></h4>
 <p>This option makes the resulting binary link against ICU statically and include
 a full set of ICU data. A binary created this way has no further external
-dependencies and supports all locales, but might be rather large. See
-<a href="https://github.com/nodejs/node/blob/master/BUILDING.md#build-with-full-icu-support-all-locales-supported-by-icu">BUILDING.md</a> on how to compile a binary using this mode.</p>
-<h2>Detecting internationalization support<span><a class="mark" href="#intl_detecting_internationalization_support" id="intl_detecting_internationalization_support">#</a></span></h2>
+dependencies and supports all locales, but might be rather large. This is
+the default behavior if no <code>--with-intl</code> flag is passed. The official binaries
+are also built in this mode.</p>
+</section><section><h3>Detecting internationalization support<span><a class="mark" href="#intl_detecting_internationalization_support" id="intl_detecting_internationalization_support">#</a></span></h3>
 <p>To verify that ICU is enabled at all (<code>system-icu</code>, <code>small-icu</code>, or
 <code>full-icu</code>), simply checking the existence of <code>Intl</code> should suffice:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hasICU = <span class="hljs-keyword">typeof</span> <span class="hljs-built_in">Intl</span> === <span class="hljs-string">'object'</span>;</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasICU = <span class="hljs-keyword">typeof</span> <span class="hljs-title class_">Intl</span> === <span class="hljs-string">'object'</span>;</code></pre>
 <p>Alternatively, checking for <code>process.versions.icu</code>, a property defined only
 when ICU is enabled, works too:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hasICU = <span class="hljs-keyword">typeof</span> process.versions.icu === <span class="hljs-string">'string'</span>;</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasICU = <span class="hljs-keyword">typeof</span> process.<span class="hljs-property">versions</span>.<span class="hljs-property">icu</span> === <span class="hljs-string">'string'</span>;</code></pre>
 <p>To check for support for a non-English locale (i.e. <code>full-icu</code> or
 <code>system-icu</code>), <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat"><code>Intl.DateTimeFormat</code></a> can be a good distinguishing factor:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> hasFullICU = (<span class="hljs-function">() =></span> {
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">const</span> january = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>(<span class="hljs-number">9e8</span>);
-    <span class="hljs-keyword">const</span> spanish = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Intl</span>.DateTimeFormat(<span class="hljs-string">'es'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
-    <span class="hljs-keyword">return</span> spanish.format(january) === <span class="hljs-string">'enero'</span>;
+    <span class="hljs-keyword">const</span> january = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>(<span class="hljs-number">9e8</span>);
+    <span class="hljs-keyword">const</span> spanish = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Intl</span>.<span class="hljs-title class_">DateTimeFormat</span>(<span class="hljs-string">'es'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
+    <span class="hljs-keyword">return</span> spanish.<span class="hljs-title function_">format</span>(january) === <span class="hljs-string">'enero'</span>;
   } <span class="hljs-keyword">catch</span> (err) {
     <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
   }
@@ -40930,25 +44407,26 @@ to be helpful:</p>
 <ul>
 <li><a href="https://github.com/srl295/btest402">btest402</a>: Generally used to check whether Node.js with <code>Intl</code> support is
 built correctly.</li>
-<li><a href="https://github.com/tc39/test262/tree/master/test/intl402">Test262</a>: ECMAScript's official conformance test suite includes a section
+<li><a href="https://github.com/tc39/test262/tree/HEAD/test/intl402">Test262</a>: ECMAScript's official conformance test suite includes a section
 dedicated to ECMA-402.</li>
-</ul>
-<h1>Modules: CommonJS modules<span><a class="mark" href="#modules_modules_commonjs_modules" id="modules_modules_commonjs_modules">#</a></span></h1>
+</ul></section>
+        </section>
+<section><h2>Modules: CommonJS modules<span><a class="mark" href="#modules_modules_commonjs_modules" id="modules_modules_commonjs_modules">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
 <p>In the Node.js module system, each file is treated as a separate module. For
 example, consider a file named <code>foo.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> circle = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./circle.js'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The area of a circle of radius 4 is <span class="hljs-subst">${circle.area(<span class="hljs-number">4</span>)}</span>`</span>);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The area of a circle of radius 4 is <span class="hljs-subst">${circle.area(<span class="hljs-number">4</span>)}</span>`</span>);</code></pre>
 <p>On the first line, <code>foo.js</code> loads the module <code>circle.js</code> that is in the same
 directory as <code>foo.js</code>.</p>
 <p>Here are the contents of <code>circle.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { PI } = <span class="hljs-built_in">Math</span>;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-variable constant_">PI</span> } = <span class="hljs-title class_">Math</span>;
 
-<span class="hljs-built_in">exports</span>.area = <span class="hljs-function">(<span class="hljs-params">r</span>) =></span> PI * r ** <span class="hljs-number">2</span>;
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">area</span> = <span class="hljs-function">(<span class="hljs-params">r</span>) =></span> <span class="hljs-variable constant_">PI</span> * r ** <span class="hljs-number">2</span>;
 
-<span class="hljs-built_in">exports</span>.circumference = <span class="hljs-function">(<span class="hljs-params">r</span>) =></span> <span class="hljs-number">2</span> * PI * r;</code></pre>
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">circumference</span> = <span class="hljs-function">(<span class="hljs-params">r</span>) =></span> <span class="hljs-number">2</span> * <span class="hljs-variable constant_">PI</span> * r;</code></pre>
 <p>The module <code>circle.js</code> has exported the functions <code>area()</code> and
 <code>circumference()</code>. Functions and objects are added to the root of a module
 by specifying additional properties on the special <code>exports</code> object.</p>
@@ -40958,22 +44436,22 @@ In this example, the variable <code>PI</code> is private to <code>circle.js</cod
 <p>The <code>module.exports</code> property can be assigned a new value (such as a function
 or object).</p>
 <p>Below, <code>bar.js</code> makes use of the <code>square</code> module, which exports a Square class:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> Square = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./square.js'</span>);
-<span class="hljs-keyword">const</span> mySquare = <span class="hljs-keyword">new</span> Square(<span class="hljs-number">2</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The area of mySquare is <span class="hljs-subst">${mySquare.area()}</span>`</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">Square</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./square.js'</span>);
+<span class="hljs-keyword">const</span> mySquare = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Square</span>(<span class="hljs-number">2</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The area of mySquare is <span class="hljs-subst">${mySquare.area()}</span>`</span>);</code></pre>
 <p>The <code>square</code> module is defined in <code>square.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Assigning to exports will not modify module, must use module.exports</span>
-<span class="hljs-built_in">module</span>.exports = <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Square</span> </span>{
-  <span class="hljs-keyword">constructor</span>(width) {
-    <span class="hljs-built_in">this</span>.width = width;
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-keyword">class</span> <span class="hljs-title class_">Square</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">width</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">width</span> = width;
   }
 
-  area() {
-    <span class="hljs-keyword">return</span> <span class="hljs-built_in">this</span>.width ** <span class="hljs-number">2</span>;
+  <span class="hljs-title function_">area</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">width</span> ** <span class="hljs-number">2</span>;
   }
 };</code></pre>
 <p>The module system is implemented in the <code>require('module')</code> module.</p>
-<h2>Accessing the main module<span><a class="mark" href="#modules_accessing_the_main_module" id="modules_accessing_the_main_module">#</a></span></h2>
+<section><h3>Accessing the main module<span><a class="mark" href="#modules_accessing_the_main_module" id="modules_accessing_the_main_module">#</a></span></h3>
 
 <p>When a file is run directly from Node.js, <code>require.main</code> is set to its
 <code>module</code>. That means that it is possible to determine whether a file has been
@@ -40983,7 +44461,7 @@ run directly by testing <code>require.main === module</code>.</p>
 <p>Because <code>module</code> provides a <code>filename</code> property (normally equivalent to
 <code>__filename</code>), the entry point of the current application can be obtained
 by checking <code>require.main.filename</code>.</p>
-<h2>Addenda: Package manager tips<span><a class="mark" href="#modules_addenda_package_manager_tips" id="modules_addenda_package_manager_tips">#</a></span></h2>
+</section><section><h3>Package manager tips<span><a class="mark" href="#modules_package_manager_tips" id="modules_package_manager_tips">#</a></span></h3>
 
 <p>The semantics of the Node.js <code>require()</code> function were designed to be general
 enough to support reasonable directory structures. Package manager programs
@@ -41026,18 +44504,18 @@ also add the <code>/usr/lib/node_modules</code> folder to the <code>$NODE_PATH</
 variable. Since the module lookups using <code>node_modules</code> folders are all
 relative, and based on the real path of the files making the calls to
 <code>require()</code>, the packages themselves can be anywhere.</p>
-<h2>Addenda: The <code>.mjs</code> extension<span><a class="mark" href="#modules_addenda_the_mjs_extension" id="modules_addenda_the_mjs_extension">#</a></span></h2>
+</section><section><h3>The <code>.mjs</code> extension<span><a class="mark" href="#modules_the_mjs_extension" id="modules_the_mjs_extension">#</a></span></h3>
 <p>It is not possible to <code>require()</code> files that have the <code>.mjs</code> extension.
 Attempting to do so will throw <a href="#errors_err_require_esm">an error</a>. The <code>.mjs</code> extension is
 reserved for <a href="esm.html">ECMAScript Modules</a> which cannot be loaded via <code>require()</code>.
 See <a href="esm.html">ECMAScript Modules</a> for more details.</p>
-<h2>All together...<span><a class="mark" href="#modules_all_together" id="modules_all_together">#</a></span></h2>
+</section><section><h3>All together...<span><a class="mark" href="#modules_all_together" id="modules_all_together">#</a></span></h3>
 
 <p>To get the exact filename that will be loaded when <code>require()</code> is called, use
 the <code>require.resolve()</code> function.</p>
 <p>Putting together all of the above, here is the high-level algorithm
 in pseudocode of what <code>require()</code> does:</p>
-<pre><code class="language-text">require(X) from module at path Y
+<pre>require(X) from module at path Y
 1. If X is a core module,
    a. return the core module
    b. STOP
@@ -41098,7 +44576,7 @@ LOAD_PACKAGE_IMPORTS(X, DIR)
 2. If no scope was found, return.
 3. If the SCOPE/package.json "imports" is null or undefined, return.
 4. let MATCH = PACKAGE_IMPORTS_RESOLVE(X, pathToFileURL(SCOPE),
-  ["node", "require"]) defined in the ESM resolver.
+  ["node", "require"]) <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 5. RESOLVE_ESM_MATCH(MATCH).
 
 LOAD_PACKAGE_EXPORTS(X, DIR)
@@ -41109,7 +44587,7 @@ LOAD_PACKAGE_EXPORTS(X, DIR)
 3. Parse DIR/NAME/package.json, and look for "exports" field.
 4. If "exports" is null or undefined, return.
 5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(DIR/NAME), "." + SUBPATH,
-   `package.json` "exports", ["node", "require"]) defined in the ESM resolver.
+   `package.json` "exports", ["node", "require"]) <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 6. RESOLVE_ESM_MATCH(MATCH)
 
 LOAD_PACKAGE_SELF(X, DIR)
@@ -41119,7 +44597,7 @@ LOAD_PACKAGE_SELF(X, DIR)
 4. If the SCOPE/package.json "name" is not the first segment of X, return.
 5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(SCOPE),
    "." + X.slice("name".length), `package.json` "exports", ["node", "require"])
-   defined in the ESM resolver.
+   <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 6. RESOLVE_ESM_MATCH(MATCH)
 
 RESOLVE_ESM_MATCH(MATCH)
@@ -41131,8 +44609,9 @@ RESOLVE_ESM_MATCH(MATCH)
 4. Otherwise, if EXACT is false,
    a. LOAD_AS_FILE(RESOLVED_PATH)
    b. LOAD_AS_DIRECTORY(RESOLVED_PATH)
-5. THROW "not found"</code></pre>
-<h2>Caching<span><a class="mark" href="#modules_caching" id="modules_caching">#</a></span></h2>
+5. THROW "not found"
+</pre>
+</section><section><h3>Caching<span><a class="mark" href="#modules_caching" id="modules_caching">#</a></span></h3>
 
 <p>Modules are cached after the first time they are loaded. This means (among other
 things) that every call to <code>require('foo')</code> will get exactly the same object
@@ -41143,7 +44622,7 @@ important feature. With it, "partially done" objects can be returned, thus
 allowing transitive dependencies to be loaded even when they would cause cycles.</p>
 <p>To have a module execute code multiple times, export a function, and call that
 function.</p>
-<h3>Module caching caveats<span><a class="mark" href="#modules_module_caching_caveats" id="modules_module_caching_caveats">#</a></span></h3>
+<h4>Module caching caveats<span><a class="mark" href="#modules_module_caching_caveats" id="modules_module_caching_caveats">#</a></span></h4>
 
 <p>Modules are cached based on their resolved filename. Since modules may resolve
 to a different filename based on the location of the calling module (loading
@@ -41154,8 +44633,17 @@ resolved filenames can point to the same file, but the cache will still treat
 them as different modules and will reload the file multiple times. For example,
 <code>require('./foo')</code> and <code>require('./FOO')</code> return two different objects,
 irrespective of whether or not <code>./foo</code> and <code>./FOO</code> are the same file.</p>
-<h2>Core modules<span><a class="mark" href="#modules_core_modules" id="modules_core_modules">#</a></span></h2>
+</section><section><h3>Core modules<span><a class="mark" href="#modules_core_modules" id="modules_core_modules">#</a></span></h3>
 
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Added <code>node:</code> import support to <code>require(...)</code>.</p></td></tr>
+</tbody></table>
+</details>
+</div>
 <p>Node.js has several modules compiled into the binary. These modules are
 described in greater detail elsewhere in this documentation.</p>
 <p>The core modules are defined within the Node.js source and are located in the
@@ -41163,30 +44651,34 @@ described in greater detail elsewhere in this documentation.</p>
 <p>Core modules are always preferentially loaded if their identifier is
 passed to <code>require()</code>. For instance, <code>require('http')</code> will always
 return the built in HTTP module, even if there is a file by that name.</p>
-<h2>Cycles<span><a class="mark" href="#modules_cycles" id="modules_cycles">#</a></span></h2>
+<p>Core modules can also be identified using the <code>node:</code> prefix, in which case
+it bypasses the <code>require</code> cache. For instance, <code>require('node:http')</code> will
+always return the built in HTTP module, even if there is <code>require.cache</code> entry
+by that name.</p>
+</section><section><h3>Cycles<span><a class="mark" href="#modules_cycles" id="modules_cycles">#</a></span></h3>
 
 <p>When there are circular <code>require()</code> calls, a module might not have finished
 executing when it is returned.</p>
 <p>Consider this situation:</p>
 <p><code>a.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'a starting'</span>);
-<span class="hljs-built_in">exports</span>.done = <span class="hljs-literal">false</span>;
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a starting'</span>);
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">done</span> = <span class="hljs-literal">false</span>;
 <span class="hljs-keyword">const</span> b = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./b.js'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'in a, b.done = %j'</span>, b.done);
-<span class="hljs-built_in">exports</span>.done = <span class="hljs-literal">true</span>;
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'a done'</span>);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'in a, b.done = %j'</span>, b.<span class="hljs-property">done</span>);
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">done</span> = <span class="hljs-literal">true</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a done'</span>);</code></pre>
 <p><code>b.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'b starting'</span>);
-<span class="hljs-built_in">exports</span>.done = <span class="hljs-literal">false</span>;
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'b starting'</span>);
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">done</span> = <span class="hljs-literal">false</span>;
 <span class="hljs-keyword">const</span> a = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./a.js'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'in b, a.done = %j'</span>, a.done);
-<span class="hljs-built_in">exports</span>.done = <span class="hljs-literal">true</span>;
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'b done'</span>);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'in b, a.done = %j'</span>, a.<span class="hljs-property">done</span>);
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">done</span> = <span class="hljs-literal">true</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'b done'</span>);</code></pre>
 <p><code>main.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'main starting'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'main starting'</span>);
 <span class="hljs-keyword">const</span> a = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./a.js'</span>);
 <span class="hljs-keyword">const</span> b = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./b.js'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'in main, a.done = %j, b.done = %j'</span>, a.done, b.done);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'in main, a.done = %j, b.done = %j'</span>, a.<span class="hljs-property">done</span>, b.<span class="hljs-property">done</span>);</code></pre>
 <p>When <code>main.js</code> loads <code>a.js</code>, then <code>a.js</code> in turn loads <code>b.js</code>. At that
 point, <code>b.js</code> tries to load <code>a.js</code>. In order to prevent an infinite
 loop, an <strong>unfinished copy</strong> of the <code>a.js</code> exports object is returned to the
@@ -41194,7 +44686,7 @@ loop, an <strong>unfinished copy</strong> of the <code>a.js</code> exports objec
 provided to the <code>a.js</code> module.</p>
 <p>By the time <code>main.js</code> has loaded both modules, they're both finished.
 The output of this program would thus be:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node main.js</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node main.js</span>
 main starting
 a starting
 b starting
@@ -41205,7 +44697,7 @@ a done
 in main, a.done = true, b.done = true</code></pre>
 <p>Careful planning is required to allow cyclic module dependencies to work
 correctly within an application.</p>
-<h2>File modules<span><a class="mark" href="#modules_file_modules" id="modules_file_modules">#</a></span></h2>
+</section><section><h3>File modules<span><a class="mark" href="#modules_file_modules" id="modules_file_modules">#</a></span></h3>
 
 <p>If the exact filename is not found, then Node.js will attempt to load the
 required filename with the added extensions: <code>.js</code>, <code>.json</code>, and finally
@@ -41223,7 +44715,7 @@ example, <code>require('/home/marco/foo.js')</code> will load the file at
 either be a core module or is loaded from a <code>node_modules</code> folder.</p>
 <p>If the given path does not exist, <code>require()</code> will throw an <a href="#errors_class_error"><code>Error</code></a> with its
 <code>code</code> property set to <code>'MODULE_NOT_FOUND'</code>.</p>
-<h2>Folders as modules<span><a class="mark" href="#modules_folders_as_modules" id="modules_folders_as_modules">#</a></span></h2>
+</section><section><h3>Folders as modules<span><a class="mark" href="#modules_folders_as_modules" id="modules_folders_as_modules">#</a></span></h3>
 
 <p>It is convenient to organize programs and libraries into self-contained
 directories, and then provide a single entry point to those directories.
@@ -41232,8 +44724,8 @@ an argument.</p>
 <p>The first is to create a <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file in the root of the folder,
 which specifies a <code>main</code> module. An example <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file might
 look like this:</p>
-<pre><code class="language-json">{ <span class="hljs-attr">"name"</span> : <span class="hljs-string">"some-library"</span>,
-  <span class="hljs-attr">"main"</span> : <span class="hljs-string">"./lib/some-library.js"</span> }</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span> <span class="hljs-attr">"name"</span> <span class="hljs-punctuation">:</span> <span class="hljs-string">"some-library"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span> <span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/some-library.js"</span> <span class="hljs-punctuation">}</span></code></pre>
 <p>If this was in a folder at <code>./some-library</code>, then
 <code>require('./some-library')</code> would attempt to load
 <code>./some-library/lib/some-library.js</code>.</p>
@@ -41250,7 +44742,7 @@ example, then <code>require('./some-library')</code> would attempt to load:</p>
 <p>If these attempts fail, then Node.js will report the entire module as missing
 with the default error:</p>
 <pre><code class="language-console">Error: Cannot find module 'some-library'</code></pre>
-<h2>Loading from <code>node_modules</code> folders<span><a class="mark" href="#modules_loading_from_node_modules_folders" id="modules_loading_from_node_modules_folders">#</a></span></h2>
+</section><section><h3>Loading from <code>node_modules</code> folders<span><a class="mark" href="#modules_loading_from_node_modules_folders" id="modules_loading_from_node_modules_folders">#</a></span></h3>
 
 <p>If the module identifier passed to <code>require()</code> is not a
 <a href="#modules_core_modules">core</a> module, and does not begin with <code>'/'</code>, <code>'../'</code>, or
@@ -41276,7 +44768,7 @@ module by including a path suffix after the module name. For instance
 <code>require('example-module/path/to/file')</code> would resolve <code>path/to/file</code>
 relative to where <code>example-module</code> is located. The suffixed path follows the
 same module resolution semantics.</p>
-<h2>Loading from the global folders<span><a class="mark" href="#modules_loading_from_the_global_folders" id="modules_loading_from_the_global_folders">#</a></span></h2>
+</section><section><h3>Loading from the global folders<span><a class="mark" href="#modules_loading_from_the_global_folders" id="modules_loading_from_the_global_folders">#</a></span></h3>
 
 <p>If the <code>NODE_PATH</code> environment variable is set to a colon-delimited list
 of absolute paths, then Node.js will search those paths for modules if they
@@ -41301,11 +44793,11 @@ configured <code>node_prefix</code>.</p>
 <p>These are mostly for historic reasons.</p>
 <p>It is strongly encouraged to place dependencies in the local <code>node_modules</code>
 folder. These will be loaded faster, and more reliably.</p>
-<h2>The module wrapper<span><a class="mark" href="#modules_the_module_wrapper" id="modules_the_module_wrapper">#</a></span></h2>
+</section><section><h3>The module wrapper<span><a class="mark" href="#modules_the_module_wrapper" id="modules_the_module_wrapper">#</a></span></h3>
 
 <p>Before a module's code is executed, Node.js will wrap it with a function
 wrapper that looks like the following:</p>
-<pre><code class="language-js">(<span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">exports, require, module, __filename, __dirname</span>) </span>{
+<pre><code class="language-js">(<span class="hljs-keyword">function</span>(<span class="hljs-params"><span class="hljs-built_in">exports</span>, <span class="hljs-built_in">require</span>, <span class="hljs-variable language_">module</span>, __filename, __dirname</span>) {
 <span class="hljs-comment">// Module code actually lives in here</span>
 });</code></pre>
 <p>By doing this, Node.js achieves a few things:</p>
@@ -41322,8 +44814,8 @@ module's absolute filename and directory path.</li>
 </ul>
 </li>
 </ul>
-<h2>The module scope<span><a class="mark" href="#modules_the_module_scope" id="modules_the_module_scope">#</a></span></h2>
-<h3><code>__dirname</code><span><a class="mark" href="#modules_dirname" id="modules_dirname">#</a></span></h3>
+</section><section><h3>The module scope<span><a class="mark" href="#modules_the_module_scope" id="modules_the_module_scope">#</a></span></h3>
+<h4><code>__dirname</code><span><a class="mark" href="#modules_dirname" id="modules_dirname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -41334,11 +44826,11 @@ module's absolute filename and directory path.</li>
 <p>The directory name of the current module. This is the same as the
 <a href="#path_path_dirname_path"><code>path.dirname()</code></a> of the <a href="#modules_filename"><code>__filename</code></a>.</p>
 <p>Example: running <code>node example.js</code> from <code>/Users/mjr</code></p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(__dirname);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(__dirname);
 <span class="hljs-comment">// Prints: /Users/mjr</span>
-<span class="hljs-built_in">console</span>.log(path.dirname(__filename));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(path.<span class="hljs-title function_">dirname</span>(__filename));
 <span class="hljs-comment">// Prints: /Users/mjr</span></code></pre>
-<h3><code>__filename</code><span><a class="mark" href="#modules_filename" id="modules_filename">#</a></span></h3>
+<h4><code>__filename</code><span><a class="mark" href="#modules_filename" id="modules_filename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
@@ -41353,9 +44845,9 @@ command line.</p>
 <p>See <a href="#modules_dirname"><code>__dirname</code></a> for the directory name of the current module.</p>
 <p>Examples:</p>
 <p>Running <code>node example.js</code> from <code>/Users/mjr</code></p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(__filename);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(__filename);
 <span class="hljs-comment">// Prints: /Users/mjr/example.js</span>
-<span class="hljs-built_in">console</span>.log(__dirname);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(__dirname);
 <span class="hljs-comment">// Prints: /Users/mjr</span></code></pre>
 <p>Given two modules: <code>a</code> and <code>b</code>, where <code>b</code> is a dependency of
 <code>a</code> and there is a directory structure of:</p>
@@ -41366,7 +44858,7 @@ command line.</p>
 <p>References to <code>__filename</code> within <code>b.js</code> will return
 <code>/Users/mjr/app/node_modules/b/b.js</code> while references to <code>__filename</code> within
 <code>a.js</code> will return <code>/Users/mjr/app/a.js</code>.</p>
-<h3><code>exports</code><span><a class="mark" href="#modules_exports" id="modules_exports">#</a></span></h3>
+<h4><code>exports</code><span><a class="mark" href="#modules_exports" id="modules_exports">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.12</span>
 </div>
@@ -41377,7 +44869,7 @@ command line.</p>
 <p>A reference to the <code>module.exports</code> that is shorter to type.
 See the section about the <a href="#modules_exports_shortcut">exports shortcut</a> for details on when to use
 <code>exports</code> and when to use <code>module.exports</code>.</p>
-<h3><code>module</code><span><a class="mark" href="#modules_module" id="modules_module">#</a></span></h3>
+<h4><code>module</code><span><a class="mark" href="#modules_module" id="modules_module">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -41388,7 +44880,7 @@ See the section about the <a href="#modules_exports_shortcut">exports shortcut</
 <p>A reference to the current module, see the section about the
 <a href="#modules_the_module_object"><code>module</code> object</a>. In particular, <code>module.exports</code> is used for defining what
 a module exports and makes available through <code>require()</code>.</p>
-<h3><code>require(id)</code><span><a class="mark" href="#modules_require_id" id="modules_require_id">#</a></span></h3>
+<h4><code>require(id)</code><span><a class="mark" href="#modules_require_id" id="modules_require_id">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.13</span>
 </div>
@@ -41413,7 +44905,7 @@ Windows in the same way they would on Unix systems.</p>
 
 <span class="hljs-comment">// Importing a module from node_modules or Node.js built-in module:</span>
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);</code></pre>
-<h4><code>require.cache</code><span><a class="mark" href="#modules_require_cache" id="modules_require_cache">#</a></span></h4>
+<h5><code>require.cache</code><span><a class="mark" href="#modules_require_cache" id="modules_require_cache">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -41426,9 +44918,18 @@ This does not apply to <a href="addons.html">native addons</a>, for which reload
 error.</p>
 <p>Adding or replacing entries is also possible. This cache is checked before
 native modules and if a name matching a native module is added to the cache,
-no require call is
-going to receive the native module anymore. Use with care!</p>
-<h4><code>require.extensions</code><span><a class="mark" href="#modules_require_extensions" id="modules_require_extensions">#</a></span></h4>
+only <code>node:</code>-prefixed require calls are going to receive the native module.
+Use with care!</p>
+<!-- eslint-disable node-core/no-duplicate-requires -->
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
+<span class="hljs-keyword">const</span> realFs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+
+<span class="hljs-keyword">const</span> fakeFs = {};
+<span class="hljs-built_in">require</span>.<span class="hljs-property">cache</span>.<span class="hljs-property">fs</span> = { <span class="hljs-attr">exports</span>: fakeFs };
+
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>), fakeFs);
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'node:fs'</span>), realFs);</code></pre>
+<h5><code>require.extensions</code><span><a class="mark" href="#modules_require_extensions" id="modules_require_extensions">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span><span>Deprecated since: v0.10.6</span>
 </div>
@@ -41438,14 +44939,14 @@ going to receive the native module anymore. Use with care!</p>
 </ul>
 <p>Instruct <code>require</code> on how to handle certain file extensions.</p>
 <p>Process files with the extension <code>.sjs</code> as <code>.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>.extensions[<span class="hljs-string">'.sjs'</span>] = <span class="hljs-built_in">require</span>.extensions[<span class="hljs-string">'.js'</span>];</code></pre>
+<pre><code class="language-js"><span class="hljs-built_in">require</span>.<span class="hljs-property">extensions</span>[<span class="hljs-string">'.sjs'</span>] = <span class="hljs-built_in">require</span>.<span class="hljs-property">extensions</span>[<span class="hljs-string">'.js'</span>];</code></pre>
 <p><strong>Deprecated.</strong> In the past, this list has been used to load non-JavaScript
 modules into Node.js by compiling them on-demand. However, in practice, there
 are much better ways to do this, such as loading modules via some other Node.js
 program, or compiling them to JavaScript ahead of time.</p>
 <p>Avoid using <code>require.extensions</code>. Use could cause subtle bugs and resolving the
 extensions gets slower with each registered extension.</p>
-<h4><code>require.main</code><span><a class="mark" href="#modules_require_main" id="modules_require_main">#</a></span></h4>
+<h5><code>require.main</code><span><a class="mark" href="#modules_require_main" id="modules_require_main">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
@@ -41456,10 +44957,10 @@ extensions gets slower with each registered extension.</p>
 process launched.
 See <a href="#modules_accessing_the_main_module">"Accessing the main module"</a>.</p>
 <p>In <code>entry.js</code> script:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">require</span>.main);</code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-built_in">require</span>.<span class="hljs-property">main</span>);</code></pre>
 <pre><code class="language-bash">node entry.js</code></pre>
 <!-- eslint-skip -->
-<pre><code class="language-js">Module {
+<pre><code class="language-js"><span class="hljs-title class_">Module</span> {
   <span class="hljs-attr">id</span>: <span class="hljs-string">'.'</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/absolute/path/to'</span>,
   <span class="hljs-attr">exports</span>: {},
@@ -41472,7 +44973,7 @@ See <a href="#modules_accessing_the_main_module">"Accessing the main module"</a>
      <span class="hljs-string">'/absolute/path/node_modules'</span>,
      <span class="hljs-string">'/absolute/node_modules'</span>,
      <span class="hljs-string">'/node_modules'</span> ] }</code></pre>
-<h4><code>require.resolve(request[, options])</code><span><a class="mark" href="#modules_require_resolve_request_options" id="modules_require_resolve_request_options">#</a></span></h4>
+<h5><code>require.resolve(request[, options])</code><span><a class="mark" href="#modules_require_resolve_request_options" id="modules_require_resolve_request_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -41501,7 +45002,7 @@ is checked from this location.</li>
 <p>Use the internal <code>require()</code> machinery to look up the location of a module,
 but rather than loading the module, just return the resolved filename.</p>
 <p>If the module can not be found, a <code>MODULE_NOT_FOUND</code> error is thrown.</p>
-<h5><code>require.resolve.paths(request)</code><span><a class="mark" href="#modules_require_resolve_paths_request" id="modules_require_resolve_paths_request">#</a></span></h5>
+<h6><code>require.resolve.paths(request)</code><span><a class="mark" href="#modules_require_resolve_paths_request" id="modules_require_resolve_paths_request">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v8.9.0</span>
 </div>
@@ -41512,7 +45013,7 @@ but rather than loading the module, just return the resolved filename.</p>
 <p>Returns an array containing the paths searched during resolution of <code>request</code> or
 <code>null</code> if the <code>request</code> string references a core module, for example <code>http</code> or
 <code>fs</code>.</p>
-<h2>The <code>module</code> object<span><a class="mark" href="#modules_the_module_object" id="modules_the_module_object">#</a></span></h2>
+</section><section><h3>The <code>module</code> object<span><a class="mark" href="#modules_the_module_object" id="modules_the_module_object">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -41525,7 +45026,7 @@ but rather than loading the module, just return the resolved filename.</p>
 representing the current module. For convenience, <code>module.exports</code> is
 also accessible via the <code>exports</code> module-global. <code>module</code> is not actually
 a global but rather local to each module.</p>
-<h3><code>module.children</code><span><a class="mark" href="#modules_module_children" id="modules_module_children">#</a></span></h3>
+<h4><code>module.children</code><span><a class="mark" href="#modules_module_children" id="modules_module_children">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -41533,7 +45034,7 @@ a global but rather local to each module.</p>
 <li><a href="#modules_the_module_object" class="type">&#x3C;module[]></a></li>
 </ul>
 <p>The module objects required for the first time by this one.</p>
-<h3><code>module.exports</code><span><a class="mark" href="#modules_module_exports" id="modules_module_exports">#</a></span></h3>
+<h4><code>module.exports</code><span><a class="mark" href="#modules_module_exports" id="modules_module_exports">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -41546,30 +45047,30 @@ this, assign the desired export object to <code>module.exports</code>. Assigning
 the desired object to <code>exports</code> will simply rebind the local <code>exports</code> variable,
 which is probably not what is desired.</p>
 <p>For example, suppose we were making a module called <code>a.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-built_in">module</span>.exports = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
 <span class="hljs-comment">// Do some work, and after some time emit</span>
 <span class="hljs-comment">// the 'ready' event from the module itself.</span>
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">module</span>.exports.emit(<span class="hljs-string">'ready'</span>);
+  <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'ready'</span>);
 }, <span class="hljs-number">1000</span>);</code></pre>
 <p>Then in another file we could do:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./a'</span>);
-a.on(<span class="hljs-string">'ready'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'module "a" is ready'</span>);
+a.<span class="hljs-title function_">on</span>(<span class="hljs-string">'ready'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'module "a" is ready'</span>);
 });</code></pre>
 <p>Assignment to <code>module.exports</code> must be done immediately. It cannot be
 done in any callbacks. This does not work:</p>
 <p><code>x.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">module</span>.exports = { <span class="hljs-attr">a</span>: <span class="hljs-string">'hello'</span> };
+  <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = { <span class="hljs-attr">a</span>: <span class="hljs-string">'hello'</span> };
 }, <span class="hljs-number">0</span>);</code></pre>
 <p><code>y.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> x = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./x'</span>);
-<span class="hljs-built_in">console</span>.log(x.a);</code></pre>
-<h4><code>exports</code> shortcut<span><a class="mark" href="#modules_exports_shortcut" id="modules_exports_shortcut">#</a></span></h4>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(x.<span class="hljs-property">a</span>);</code></pre>
+<h5><code>exports</code> shortcut<span><a class="mark" href="#modules_exports_shortcut" id="modules_exports_shortcut">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -41578,31 +45079,31 @@ assigned the value of <code>module.exports</code> before the module is evaluated
 <p>It allows a shortcut, so that <code>module.exports.f = ...</code> can be written more
 succinctly as <code>exports.f = ...</code>. However, be aware that like any variable, if a
 new value is assigned to <code>exports</code>, it is no longer bound to <code>module.exports</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">module</span>.exports.hello = <span class="hljs-literal">true</span>; <span class="hljs-comment">// Exported from require of module</span>
+<pre><code class="language-js"><span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-property">hello</span> = <span class="hljs-literal">true</span>; <span class="hljs-comment">// Exported from require of module</span>
 <span class="hljs-built_in">exports</span> = { <span class="hljs-attr">hello</span>: <span class="hljs-literal">false</span> };  <span class="hljs-comment">// Not exported, only available in the module</span></code></pre>
 <p>When the <code>module.exports</code> property is being completely replaced by a new
 object, it is common to also reassign <code>exports</code>:</p>
 <!-- eslint-disable func-name-matching -->
-<pre><code class="language-js"><span class="hljs-built_in">module</span>.exports = <span class="hljs-built_in">exports</span> = <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">Constructor</span>(<span class="hljs-params"></span>) </span>{
+<pre><code class="language-js"><span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-built_in">exports</span> = <span class="hljs-keyword">function</span> <span class="hljs-title function_">Constructor</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// ... etc.</span>
 };</code></pre>
 <p>To illustrate the behavior, imagine this hypothetical implementation of
 <code>require()</code>, which is quite similar to what is actually done by <code>require()</code>:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">require</span>(<span class="hljs-params"><span class="hljs-regexp">/* ... */</span></span>) </span>{
-  <span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = { <span class="hljs-attr">exports</span>: {} };
-  (<span class="hljs-function">(<span class="hljs-params"><span class="hljs-built_in">module</span>, <span class="hljs-built_in">exports</span></span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">require</span>(<span class="hljs-params"><span class="hljs-comment">/* ... */</span></span>) {
+  <span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = { <span class="hljs-attr">exports</span>: {} };
+  (<span class="hljs-function">(<span class="hljs-params"><span class="hljs-variable language_">module</span>, <span class="hljs-built_in">exports</span></span>) =></span> {
     <span class="hljs-comment">// Module code here. In this example, define a function.</span>
-    <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">someFunc</span>(<span class="hljs-params"></span>) </span>{}
+    <span class="hljs-keyword">function</span> <span class="hljs-title function_">someFunc</span>(<span class="hljs-params"></span>) {}
     <span class="hljs-built_in">exports</span> = someFunc;
     <span class="hljs-comment">// At this point, exports is no longer a shortcut to module.exports, and</span>
     <span class="hljs-comment">// this module will still export an empty default object.</span>
-    <span class="hljs-built_in">module</span>.exports = someFunc;
+    <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = someFunc;
     <span class="hljs-comment">// At this point, the module will now export someFunc, instead of the</span>
     <span class="hljs-comment">// default object.</span>
-  })(<span class="hljs-built_in">module</span>, <span class="hljs-built_in">module</span>.exports);
-  <span class="hljs-keyword">return</span> <span class="hljs-built_in">module</span>.exports;
+  })(<span class="hljs-variable language_">module</span>, <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>);
+  <span class="hljs-keyword">return</span> <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>;
 }</code></pre>
-<h3><code>module.filename</code><span><a class="mark" href="#modules_module_filename" id="modules_module_filename">#</a></span></h3>
+<h4><code>module.filename</code><span><a class="mark" href="#modules_module_filename" id="modules_module_filename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -41610,7 +45111,7 @@ object, it is common to also reassign <code>exports</code>:</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The fully resolved filename of the module.</p>
-<h3><code>module.id</code><span><a class="mark" href="#modules_module_id" id="modules_module_id">#</a></span></h3>
+<h4><code>module.id</code><span><a class="mark" href="#modules_module_id" id="modules_module_id">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -41619,7 +45120,15 @@ object, it is common to also reassign <code>exports</code>:</p>
 </ul>
 <p>The identifier for the module. Typically this is the fully resolved
 filename.</p>
-<h3><code>module.loaded</code><span><a class="mark" href="#modules_module_loaded" id="modules_module_loaded">#</a></span></h3>
+<h4><code>module.isPreloading</code><span><a class="mark" href="#modules_module_ispreloading" id="modules_module_ispreloading">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the module is running during the Node.js preload
+phase.</li>
+</ul>
+<h4><code>module.loaded</code><span><a class="mark" href="#modules_module_loaded" id="modules_module_loaded">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -41628,9 +45137,9 @@ filename.</p>
 </ul>
 <p>Whether or not the module is done loading, or is in the process of
 loading.</p>
-<h3><code>module.parent</code><span><a class="mark" href="#modules_module_parent" id="modules_module_parent">#</a></span></h3>
+<h4><code>module.parent</code><span><a class="mark" href="#modules_module_parent" id="modules_module_parent">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.16</span><span>Deprecated since: v12.19.0, v14.6.0</span>
+<span>Added in: v0.1.16</span><span>Deprecated since: v14.6.0, v12.19.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Please use <a href="#modules_require_main"><code>require.main</code></a> and
 <a href="#modules_module_children"><code>module.children</code></a> instead.</div><p></p>
@@ -41640,7 +45149,7 @@ loading.</p>
 <p>The module that first required this one, or <code>null</code> if the current module is the
 entry point of the current process, or <code>undefined</code> if the module was loaded by
 something that is not a CommonJS module (E.G.: REPL or <code>import</code>).</p>
-<h3><code>module.path</code><span><a class="mark" href="#modules_module_path" id="modules_module_path">#</a></span></h3>
+<h4><code>module.path</code><span><a class="mark" href="#modules_module_path" id="modules_module_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.14.0</span>
 </div>
@@ -41649,7 +45158,7 @@ something that is not a CommonJS module (E.G.: REPL or <code>import</code>).</p>
 </ul>
 <p>The directory name of the module. This is usually the same as the
 <a href="#path_path_dirname_path"><code>path.dirname()</code></a> of the <a href="#modules_module_id"><code>module.id</code></a>.</p>
-<h3><code>module.paths</code><span><a class="mark" href="#modules_module_paths" id="modules_module_paths">#</a></span></h3>
+<h4><code>module.paths</code><span><a class="mark" href="#modules_module_paths" id="modules_module_paths">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
@@ -41657,7 +45166,7 @@ something that is not a CommonJS module (E.G.: REPL or <code>import</code>).</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
 <p>The search paths for the module.</p>
-<h3><code>module.require(id)</code><span><a class="mark" href="#modules_module_require_id" id="modules_module_require_id">#</a></span></h3>
+<h4><code>module.require(id)</code><span><a class="mark" href="#modules_module_require_id" id="modules_module_require_id">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.1</span>
 </div>
@@ -41671,7 +45180,7 @@ something that is not a CommonJS module (E.G.: REPL or <code>import</code>).</p>
 Since <code>require()</code> returns the <code>module.exports</code>, and the <code>module</code> is typically
 <em>only</em> available within a specific module's code, it must be explicitly exported
 in order to be used.</p>
-<h2>The <code>Module</code> object<span><a class="mark" href="#modules_the_module_object_1" id="modules_the_module_object_1">#</a></span></h2>
+</section><section><h3>The <code>Module</code> object<span><a class="mark" href="#modules_the_module_object_1" id="modules_the_module_object_1">#</a></span></h3>
 <p>This section was moved to
 <a href="#module_the_module_object">Modules: <code>module</code> core module</a>.</p>
 <!-- Anchors to make sure old links find a target -->
@@ -41681,12 +45190,12 @@ in order to be used.</p>
 <li><a id="modules_module_createrequirefrompath_filename" href="module.html#module_module_createrequirefrompath_filename"><code>module.createRequireFromPath(filename)</code></a></li>
 <li><a id="modules_module_syncbuiltinesmexports" href="module.html#module_module_syncbuiltinesmexports"><code>module.syncBuiltinESMExports()</code></a></li>
 </ul>
-<h2>Source map v3 support<span><a class="mark" href="#modules_source_map_v3_support" id="modules_source_map_v3_support">#</a></span></h2>
+</section><section><h3>Source map v3 support<span><a class="mark" href="#modules_source_map_v3_support" id="modules_source_map_v3_support">#</a></span></h3>
 <p>This section was moved to
 <a href="#module_source_map_v3_support">Modules: <code>module</code> core module</a>.</p>
 <!-- Anchors to make sure old links find a target -->
 <ul>
-<li><a id="modules_module_findsourcemap_path_error" href="module.html#module_module_findsourcemap_path_error"><code>module.findSourceMap(path[, error])</code></a></li>
+<li><a id="modules_module_findsourcemap_path_error" href="module.html#module_module_findsourcemap_path"><code>module.findSourceMap(path)</code></a></li>
 <li><a id="modules_class_module_sourcemap" href="module.html#module_class_module_sourcemap">Class: <code>module.SourceMap</code></a>
 <ul>
 <li><a id="modules_new_sourcemap_payload" href="module.html#module_new_sourcemap_payload"><code>new SourceMap(payload)</code></a></li>
@@ -41694,21 +45203,24 @@ in order to be used.</p>
 <li><a id="modules_sourcemap_findentry_linenumber_columnnumber" href="module.html#module_sourcemap_findentry_linenumber_columnnumber"><code>sourceMap.findEntry(lineNumber, columnNumber)</code></a></li>
 </ul>
 </li>
-</ul>
-<h1>Modules: ECMAScript modules<span><a class="mark" href="#esm_modules_ecmascript_modules" id="esm_modules_ecmascript_modules">#</a></span></h1>
+</ul></section>
+        </section>
+<section><h2>Modules: ECMAScript modules<span><a class="mark" href="#esm_modules_ecmascript_modules" id="esm_modules_ecmascript_modules">#</a></span></h2>
 
 
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.22.0</td>
+<tr><td>v14.17.0</td>
 <td><p>Stabilize modules implementation.</p></td></tr>
-<tr><td>v12.20.0</td>
+<tr><td>v14.13.0</td>
 <td><p>Support for detection of CommonJS named exports.</p></td></tr>
-<tr><td>v12.20.0</td>
+<tr><td>v14.8.0</td>
+<td><p>Unflag Top-Level Await.</p></td></tr>
+<tr><td>v14.0.0, v13.14.0</td>
 <td><p>Remove experimental modules warning.</p></td></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.2.0, v12.17.0</td>
 <td><p>Loading ECMAScript modules no longer requires a command-line flag.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Add support for ES modules using <code>.js</code> file extension via <code>package.json</code> <code>"type"</code> field.</p></td></tr>
@@ -41718,14 +45230,14 @@ in order to be used.</p>
 </details>
 </div>
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<h2>Introduction<span><a class="mark" href="#esm_introduction" id="esm_introduction">#</a></span></h2>
+<section><h3>Introduction<span><a class="mark" href="#esm_introduction" id="esm_introduction">#</a></span></h3>
 
 <p>ECMAScript modules are <a href="https://tc39.github.io/ecma262/#sec-modules">the official standard format</a> to package JavaScript
 code for reuse. Modules are defined using a variety of <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import"><code>import</code></a> and
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export"><code>export</code></a> statements.</p>
 <p>The following example of an ES module exports a function:</p>
 <pre><code class="language-js"><span class="hljs-comment">// addTwo.mjs</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">addTwo</span>(<span class="hljs-params">num</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">addTwo</span>(<span class="hljs-params">num</span>) {
   <span class="hljs-keyword">return</span> num + <span class="hljs-number">2</span>;
 }
 
@@ -41735,15 +45247,15 @@ code for reuse. Modules are defined using a variety of <a href="https://develope
 <span class="hljs-keyword">import</span> { addTwo } <span class="hljs-keyword">from</span> <span class="hljs-string">'./addTwo.mjs'</span>;
 
 <span class="hljs-comment">// Prints: 6</span>
-<span class="hljs-built_in">console</span>.log(addTwo(<span class="hljs-number">4</span>));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">addTwo</span>(<span class="hljs-number">4</span>));</code></pre>
 <p>Node.js fully supports ECMAScript modules as they are currently specified and
 provides interoperability between them and its original module format,
 <a href="modules.html">CommonJS</a>.</p>
 <!-- Anchors to make sure old links find a target -->
-<p><i id="#esm_package_json_type_field"></i>
-<i id="#esm_package_scope_and_file_extensions"></i>
-<i id="#esm_input_type_flag"></i></p>
-<h2>Enabling<span><a class="mark" href="#esm_enabling" id="esm_enabling">#</a></span></h2>
+<p><i id="esm_package_json_type_field"></i>
+<i id="esm_package_scope_and_file_extensions"></i>
+<i id="esm_input_type_flag"></i></p>
+</section><section><h3>Enabling<span><a class="mark" href="#esm_enabling" id="esm_enabling">#</a></span></h3>
 
 <p>Node.js treats JavaScript code as CommonJS modules by default.
 Authors can tell Node.js to treat JavaScript code as ECMAScript modules
@@ -41766,48 +45278,62 @@ details.</p>
 <i id="esm_writing_dual_packages_while_avoiding_or_minimizing_hazards"></i>
 <i id="esm_approach_1_use_an_es_module_wrapper"></i>
 <i id="esm_approach_2_isolate_state"></i></p>
-<h2>Packages<span><a class="mark" href="#esm_packages" id="esm_packages">#</a></span></h2>
+</section><section><h3>Packages<span><a class="mark" href="#esm_packages" id="esm_packages">#</a></span></h3>
 <p>This section was moved to <a href="packages.html">Modules: Packages</a>.</p>
-<h2><code>import</code> Specifiers<span><a class="mark" href="#esm_import_specifiers" id="esm_import_specifiers">#</a></span></h2>
-<h3>Terminology<span><a class="mark" href="#esm_terminology" id="esm_terminology">#</a></span></h3>
+</section><section><h3><code>import</code> Specifiers<span><a class="mark" href="#esm_import_specifiers" id="esm_import_specifiers">#</a></span></h3>
+<h4>Terminology<span><a class="mark" href="#esm_terminology" id="esm_terminology">#</a></span></h4>
 <p>The <em>specifier</em> of an <code>import</code> statement is the string after the <code>from</code> keyword,
 e.g. <code>'path'</code> in <code>import { sep } from 'path'</code>. Specifiers are also used in
 <code>export from</code> statements, and as the argument to an <code>import()</code> expression.</p>
-<p>There are four types of specifiers:</p>
+<p>There are three types of specifiers:</p>
 <ul>
 <li>
-<p><em>Bare specifiers</em> like <code>'some-package'</code>. They refer to an entry point of a
-package by the package name.</p>
-</li>
-<li>
-<p><em>Deep import specifiers</em> like <code>'some-package/lib/shuffle.mjs'</code>. They refer to
-a path within a package prefixed by the package name.</p>
+<p><em>Relative specifiers</em> like <code>'./startup.js'</code> or <code>'../config.mjs'</code>. They refer
+to a path relative to the location of the importing file. <em>The file extension
+is always necessary for these.</em></p>
 </li>
 <li>
-<p><em>Relative specifiers</em> like <code>'./startup.js'</code> or <code>'../config.mjs'</code>. They refer
-to a path relative to the location of the importing file.</p>
+<p><em>Bare specifiers</em> like <code>'some-package'</code> or <code>'some-package/shuffle'</code>. They can
+refer to the main entry point of a package by the package name, or a
+specific feature module within a package prefixed by the package name as per
+the examples respectively. <em>Including the file extension is only necessary
+for packages without an <a href="#packages_exports"><code>"exports"</code></a> field.</em></p>
 </li>
 <li>
 <p><em>Absolute specifiers</em> like <code>'file:///opt/nodejs/config.js'</code>. They refer
 directly and explicitly to a full path.</p>
 </li>
 </ul>
-<p>Bare specifiers, and the bare specifier portion of deep import specifiers, are
-strings; but everything else in a specifier is a URL.</p>
-<p><code>file:</code>, <code>node:</code>, and <code>data:</code> URLs are supported. A specifier like
-<code>'https://example.com/app.js'</code> may be supported by browsers but it is not
-supported in Node.js.</p>
-<p>Specifiers may not begin with <code>/</code> or <code>//</code>. These are reserved for potential
-future use. The root of the current volume may be referenced via <code>file:///</code>.</p>
-<h4><code>node:</code> Imports<span><a class="mark" href="#esm_node_imports" id="esm_node_imports">#</a></span></h4>
-<div class="api_metadata">
-<span>Added in: v12.20.0</span>
-</div>
-<p><code>node:</code> URLs are supported as a means to load Node.js builtin modules. This
-URL scheme allows for builtin modules to be referenced by valid absolute URL
-strings.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'node:fs/promises'</span>;</code></pre>
-<h4><code>data:</code> Imports<span><a class="mark" href="#esm_data_imports" id="esm_data_imports">#</a></span></h4>
+<p>Bare specifier resolutions are handled by the <a href="#esm_resolver_algorithm_specification">Node.js module resolution
+algorithm</a>. All other specifier resolutions are always only resolved with
+the standard relative <a href="https://url.spec.whatwg.org/">URL</a> resolution semantics.</p>
+<p>Like in CommonJS, module files within packages can be accessed by appending a
+path to the package name unless the package’s <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> contains an
+<a href="#packages_exports"><code>"exports"</code></a> field, in which case files within packages can only be accessed
+via the paths defined in <a href="#packages_exports"><code>"exports"</code></a>.</p>
+<p>For details on these package resolution rules that apply to bare specifiers in
+the Node.js module resolution, see the <a href="packages.html">packages documentation</a>.</p>
+<h4>Mandatory file extensions<span><a class="mark" href="#esm_mandatory_file_extensions" id="esm_mandatory_file_extensions">#</a></span></h4>
+<p>A file extension must be provided when using the <code>import</code> keyword to resolve
+relative or absolute specifiers. Directory indexes (e.g. <code>'./startup/index.js'</code>)
+must also be fully specified.</p>
+<p>This behavior matches how <code>import</code> behaves in browser environments, assuming a
+typically configured server.</p>
+<h4>URLs<span><a class="mark" href="#esm_urls" id="esm_urls">#</a></span></h4>
+<p>ES modules are resolved and cached as URLs. This means that files containing
+special characters such as <code>#</code> and <code>?</code> need to be escaped.</p>
+<p><code>file:</code>, <code>node:</code>, and <code>data:</code> URL schemes are supported. A specifier like
+<code>'https://example.com/app.js'</code> is not supported natively in Node.js unless using
+a <a href="#esm_https_loader">custom HTTPS loader</a>.</p>
+<h5><code>file:</code> URLs<span><a class="mark" href="#esm_file_urls" id="esm_file_urls">#</a></span></h5>
+<p>Modules are loaded multiple times if the <code>import</code> specifier used to resolve
+them has a different query or fragment.</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-string">'./foo.mjs?query=1'</span>; <span class="hljs-comment">// loads ./foo.mjs with query of "?query=1"</span>
+<span class="hljs-keyword">import</span> <span class="hljs-string">'./foo.mjs?query=2'</span>; <span class="hljs-comment">// loads ./foo.mjs with query of "?query=2"</span></code></pre>
+<p>The volume root may be referenced via <code>/</code>, <code>//</code> or <code>file:///</code>. Given the
+differences between <a href="https://url.spec.whatwg.org/">URL</a> and path resolution (such as percent encoding
+details), it is recommended to use <a href="#url_url_pathtofileurl_path">url.pathToFileURL</a> when importing a path.</p>
+<h5><code>data:</code> Imports<span><a class="mark" href="#esm_data_imports" id="esm_data_imports">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v12.10.0</span>
 </div>
@@ -41826,94 +45352,107 @@ is no concept of relative resolution for <code>data:</code> URLs. An example of
 URLs being used is:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-string">'data:text/javascript,console.log("hello!");'</span>;
 <span class="hljs-keyword">import</span> _ <span class="hljs-keyword">from</span> <span class="hljs-string">'data:application/json,"world!"'</span>;</code></pre>
-<h2><code>import.meta</code><span><a class="mark" href="#esm_import_meta" id="esm_import_meta">#</a></span></h2>
+<h5><code>node:</code> Imports<span><a class="mark" href="#esm_node_imports" id="esm_node_imports">#</a></span></h5>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Added <code>node:</code> import support to <code>require(...)</code>.</p></td></tr>
+<tr><td>v14.13.1, v12.20.0</td>
+<td><p><span>Added in: v14.13.1, v12.20.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p><code>node:</code> URLs are supported as an alternative means to load Node.js builtin
+modules. This URL scheme allows for builtin modules to be referenced by valid
+absolute URL strings.</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'node:fs/promises'</span>;</code></pre>
+</section><section><h3>Builtin modules<span><a class="mark" href="#esm_builtin_modules" id="esm_builtin_modules">#</a></span></h3>
+<p><a href="#modules_core_modules">Core modules</a> provide named exports of their public API. A
+default export is also provided which is the value of the CommonJS exports.
+The default export can be used for, among other things, modifying the named
+exports. Named exports of builtin modules are updated only by calling
+<a href="#module_module_syncbuiltinesmexports"><code>module.syncBuiltinESMExports()</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-title class_">EventEmitter</span> <span class="hljs-keyword">from</span> <span class="hljs-string">'events'</span>;
+<span class="hljs-keyword">const</span> e = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'./foo.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err, source</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+  } <span class="hljs-keyword">else</span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(source);
+  }
+});</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> fs, { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-keyword">import</span> { syncBuiltinESMExports } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
+
+fs.<span class="hljs-property">readFileSync</span> = <span class="hljs-function">() =></span> <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Hello, ESM'</span>);
+<span class="hljs-title function_">syncBuiltinESMExports</span>();
+
+fs.<span class="hljs-property">readFileSync</span> === readFileSync;</code></pre>
+</section><section><h3><code>import()</code> expressions<span><a class="mark" href="#esm_import_expressions" id="esm_import_expressions">#</a></span></h3>
+<p><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports">Dynamic <code>import()</code></a> is supported in both CommonJS and ES modules. In CommonJS
+modules it can be used to load ES modules.</p>
+</section><section><h3><code>import.meta</code><span><a class="mark" href="#esm_import_meta" id="esm_import_meta">#</a></span></h3>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
-<p>The <code>import.meta</code> metaproperty is an <code>Object</code> that contains the following
-property:</p>
+<p>The <code>import.meta</code> meta property is an <code>Object</code> that contains the following
+properties.</p>
+<h4><code>import.meta.url</code><span><a class="mark" href="#esm_import_meta_url" id="esm_import_meta_url">#</a></span></h4>
 <ul>
-<li><code>url</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The absolute <code>file:</code> URL of the module.</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The absolute <code>file:</code> URL of the module.</li>
 </ul>
-<h2>Differences between ES modules and CommonJS<span><a class="mark" href="#esm_differences_between_es_modules_and_commonjs" id="esm_differences_between_es_modules_and_commonjs">#</a></span></h2>
-<h3>Mandatory file extensions<span><a class="mark" href="#esm_mandatory_file_extensions" id="esm_mandatory_file_extensions">#</a></span></h3>
-<p>A file extension must be provided when using the <code>import</code> keyword. Directory
-indexes (e.g. <code>'./startup/index.js'</code>) must also be fully specified.</p>
-<p>This behavior matches how <code>import</code> behaves in browser environments, assuming a
-typically configured server.</p>
-<h3>No <code>NODE_PATH</code><span><a class="mark" href="#esm_no_node_path" id="esm_no_node_path">#</a></span></h3>
-<p><code>NODE_PATH</code> is not part of resolving <code>import</code> specifiers. Please use symlinks
-if this behavior is desired.</p>
-<h3>No <code>require</code>, <code>exports</code>, <code>module.exports</code>, <code>__filename</code>, <code>__dirname</code><span><a class="mark" href="#esm_no_require_exports_module_exports_filename_dirname" id="esm_no_require_exports_module_exports_filename_dirname">#</a></span></h3>
-<p>These CommonJS variables are not available in ES modules.</p>
-<p><code>require</code> can be imported into an ES module using <a href="#module_module_createrequire_filename"><code>module.createRequire()</code></a>.</p>
-<p>Equivalents of <code>__filename</code> and <code>__dirname</code> can be created inside of each file
-via <a href="#esm_import_meta"><code>import.meta.url</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> { fileURLToPath } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
-<span class="hljs-keyword">import</span> { dirname } <span class="hljs-keyword">from</span> <span class="hljs-string">'path'</span>;
-
-<span class="hljs-keyword">const</span> __filename = fileURLToPath(<span class="hljs-keyword">import</span>.meta.url);
-<span class="hljs-keyword">const</span> __dirname = dirname(__filename);</code></pre>
-<h3>No <code>require.resolve</code><span><a class="mark" href="#esm_no_require_resolve" id="esm_no_require_resolve">#</a></span></h3>
-<p>Former use cases relying on <code>require.resolve</code> to determine the resolved path
-of a module can be supported via <code>import.meta.resolve</code>, which is experimental
-and supported via the <code>--experimental-import-meta-resolve</code> flag:</p>
-<pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> dependencyAsset = <span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>.meta.resolve(<span class="hljs-string">'component-lib/asset.css'</span>);
-})();</code></pre>
+<p>This is defined exactly the same as it is in browsers providing the URL of the
+current module file.</p>
+<p>This enables useful patterns such as relative file loading:</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'./data.proto'</span>, <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>));</code></pre>
+<h4><code>import.meta.resolve(specifier[, parent])</code><span><a class="mark" href="#esm_import_meta_resolve_specifier_parent" id="esm_import_meta_resolve_specifier_parent">#</a></span></h4>
+<!--
+added:
+  - v13.9.0
+  - v12.16.2
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38587
+    description: Add support for WHATWG `URL` object to `parentURL` parameter.
+-->
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>This feature is only available with the <code>--experimental-import-meta-resolve</code>
+command flag enabled.</p>
+<ul>
+<li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The module specifier to resolve relative to <code>parent</code>.</li>
+<li><code>parent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The absolute parent module URL to resolve from. If none
+is specified, the value of <code>import.meta.url</code> is used as the default.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Provides a module-relative resolution function scoped to each module, returning
+the URL string.</p>
+<!-- eslint-skip -->
+<pre><code class="language-js"><span class="hljs-keyword">const</span> dependencyAsset = <span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'component-lib/asset.css'</span>);</code></pre>
 <p><code>import.meta.resolve</code> also accepts a second argument which is the parent module
 from which to resolve from:</p>
-<pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-comment">// Equivalent to import.meta.resolve('./dep')</span>
-  <span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>.meta.resolve(<span class="hljs-string">'./dep'</span>, <span class="hljs-keyword">import</span>.meta.url);
-})();</code></pre>
+<!-- eslint-skip -->
+<pre><code class="language-js"><span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'./dep'</span>, <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>);</code></pre>
 <p>This function is asynchronous because the ES module resolver in Node.js is
-asynchronous. With the introduction of <a href="https://github.com/tc39/proposal-top-level-await">Top-Level Await</a>, these use cases
-will be easier as they won't require an async function wrapper.</p>
-<h3>No <code>require.extensions</code><span><a class="mark" href="#esm_no_require_extensions" id="esm_no_require_extensions">#</a></span></h3>
-<p><code>require.extensions</code> is not used by <code>import</code>. The expectation is that loader
-hooks can provide this workflow in the future.</p>
-<h3>No <code>require.cache</code><span><a class="mark" href="#esm_no_require_cache" id="esm_no_require_cache">#</a></span></h3>
-<p><code>require.cache</code> is not used by <code>import</code>. It has a separate cache.</p>
-<h3>URL-based paths<span><a class="mark" href="#esm_url_based_paths" id="esm_url_based_paths">#</a></span></h3>
-<p>ES modules are resolved and cached based upon
-<a href="https://url.spec.whatwg.org/">URL</a> semantics. This means that files containing
-special characters such as <code>#</code> and <code>?</code> need to be escaped.</p>
-<p>Modules are loaded multiple times if the <code>import</code> specifier used to resolve
-them has a different query or fragment.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-string">'./foo.mjs?query=1'</span>; <span class="hljs-comment">// loads ./foo.mjs with query of "?query=1"</span>
-<span class="hljs-keyword">import</span> <span class="hljs-string">'./foo.mjs?query=2'</span>; <span class="hljs-comment">// loads ./foo.mjs with query of "?query=2"</span></code></pre>
-<p>For now, only modules using the <code>file:</code> protocol can be loaded.</p>
-<h2>Interoperability with CommonJS<span><a class="mark" href="#esm_interoperability_with_commonjs" id="esm_interoperability_with_commonjs">#</a></span></h2>
-<h3><code>require</code><span><a class="mark" href="#esm_require" id="esm_require">#</a></span></h3>
-<p><code>require</code> always treats the files it references as CommonJS. This applies
-whether <code>require</code> is used the traditional way within a CommonJS environment, or
-in an ES module environment using <a href="#module_module_createrequire_filename"><code>module.createRequire()</code></a>.</p>
-<p>To include an ES module into CommonJS, use <a href="#esm_import_expressions"><code>import()</code></a>.</p>
-<h3><code>import</code> statements<span><a class="mark" href="#esm_import_statements" id="esm_import_statements">#</a></span></h3>
+allowed to be asynchronous.</p>
+</section><section><h3>Interoperability with CommonJS<span><a class="mark" href="#esm_interoperability_with_commonjs" id="esm_interoperability_with_commonjs">#</a></span></h3>
+<h4><code>import</code> statements<span><a class="mark" href="#esm_import_statements" id="esm_import_statements">#</a></span></h4>
 <p>An <code>import</code> statement can reference an ES module or a CommonJS module.
-<code>import</code> statements are permitted only in ES modules. For similar functionality
-in CommonJS, see <a href="#esm_import_expressions"><code>import()</code></a>.</p>
+<code>import</code> statements are permitted only in ES modules, but dynamic <a href="#esm_import_expressions"><code>import()</code></a>
+expressions are supported in CommonJS for loading ES modules.</p>
 <p>When importing <a href="#esm_commonjs_namespaces">CommonJS modules</a>, the
 <code>module.exports</code> object is provided as the default export. Named exports may be
 available, provided by static analysis as a convenience for better ecosystem
 compatibility.</p>
-<p>Additional experimental flags are available for importing
-<a href="#esm_experimental_wasm_modules">Wasm modules</a> or
-<a href="#esm_experimental_json_modules">JSON modules</a>. For importing native modules or
-JSON modules unflagged, see <a href="#module_module_createrequire_filename"><code>module.createRequire()</code></a>.</p>
-<p>The <em>specifier</em> of an <code>import</code> statement (the string after the <code>from</code> keyword)
-can either be an URL-style relative path like <code>'./file.mjs'</code> or a package name
-like <code>'fs'</code>.</p>
-<p>Like in CommonJS, files within packages can be accessed by appending a path to
-the package name; unless the package’s <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> contains an
-<a href="#packages_exports"><code>"exports"</code></a> field, in which case files within packages need to be accessed
-via the path defined in <a href="#packages_exports"><code>"exports"</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> { sin, cos } <span class="hljs-keyword">from</span> <span class="hljs-string">'geometry/trigonometry-functions.mjs'</span>;</code></pre>
-<h3><code>import()</code> expressions<span><a class="mark" href="#esm_import_expressions" id="esm_import_expressions">#</a></span></h3>
-<p><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports">Dynamic <code>import()</code></a> is supported in both CommonJS and ES modules. It can be
-used to include ES module files from CommonJS code.</p>
-<h2>CommonJS Namespaces<span><a class="mark" href="#esm_commonjs_namespaces" id="esm_commonjs_namespaces">#</a></span></h2>
+<h4><code>require</code><span><a class="mark" href="#esm_require" id="esm_require">#</a></span></h4>
+<p>The CommonJS module <code>require</code> always treats the files it references as CommonJS.</p>
+<p>Using <code>require</code> to load an ES module is not supported because ES modules have
+asynchronous execution. Instead, use <a href="#esm_import_expressions"><code>import()</code></a> to load an ES module
+from a CommonJS module.</p>
+<h4>CommonJS Namespaces<span><a class="mark" href="#esm_commonjs_namespaces" id="esm_commonjs_namespaces">#</a></span></h4>
 <p>CommonJS modules consist of a <code>module.exports</code> object which can be of any type.</p>
 <p>When importing a CommonJS module, it can be reliably imported using the ES
 module default import or its corresponding sugar syntax:</p>
@@ -41924,8 +45463,8 @@ module default import or its corresponding sugar syntax:</p>
 <span class="hljs-comment">// for `{ default as cjsSugar }` in the above import statement:</span>
 <span class="hljs-keyword">import</span> cjsSugar <span class="hljs-keyword">from</span> <span class="hljs-string">'cjs'</span>;
 
-<span class="hljs-built_in">console</span>.log(cjs);
-<span class="hljs-built_in">console</span>.log(cjs === cjsSugar);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(cjs);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(cjs === cjsSugar);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   &#x3C;module.exports></span>
 <span class="hljs-comment">//   true</span></code></pre>
@@ -41936,8 +45475,8 @@ a namespace with a <code>default</code> export key pointing to the CommonJS
 <code>import * as m from 'cjs'</code> or a dynamic import:</p>
 <!-- eslint-skip -->
 <pre><code class="language-js"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> m <span class="hljs-keyword">from</span> <span class="hljs-string">'cjs'</span>;
-<span class="hljs-built_in">console</span>.log(m);
-<span class="hljs-built_in">console</span>.log(m === <span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>(<span class="hljs-string">'cjs'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(m);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(m === <span class="hljs-keyword">await</span> <span class="hljs-title function_">import</span>(<span class="hljs-string">'cjs'</span>));
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   [Module] { default: &#x3C;module.exports> }</span>
 <span class="hljs-comment">//   true</span></code></pre>
@@ -41946,20 +45485,20 @@ in addition attempts to determine the CommonJS named exports of every imported
 CommonJS module to provide them as separate ES module exports using a static
 analysis process.</p>
 <p>For example, consider a CommonJS module written:</p>
-<pre><code class="language-js"><span class="hljs-comment">// cjs.cjs</span>
-<span class="hljs-built_in">exports</span>.name = <span class="hljs-string">'exported'</span>;</code></pre>
+<pre><code class="language-js cjs"><span class="hljs-comment">// cjs.cjs</span>
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">name</span> = <span class="hljs-string">'exported'</span>;</code></pre>
 <p>The preceding module supports named imports in ES modules:</p>
 <!-- eslint-disable no-duplicate-imports -->
 <pre><code class="language-js"><span class="hljs-keyword">import</span> { name } <span class="hljs-keyword">from</span> <span class="hljs-string">'./cjs.cjs'</span>;
-<span class="hljs-built_in">console</span>.log(name);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(name);
 <span class="hljs-comment">// Prints: 'exported'</span>
 
 <span class="hljs-keyword">import</span> cjs <span class="hljs-keyword">from</span> <span class="hljs-string">'./cjs.cjs'</span>;
-<span class="hljs-built_in">console</span>.log(cjs);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(cjs);
 <span class="hljs-comment">// Prints: { name: 'exported' }</span>
 
 <span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> m <span class="hljs-keyword">from</span> <span class="hljs-string">'./cjs.cjs'</span>;
-<span class="hljs-built_in">console</span>.log(m);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(m);
 <span class="hljs-comment">// Prints: [Module] { default: { name: 'exported' }, name: 'exported' }</span></code></pre>
 <p>As can be seen from the last example of the Module Namespace Exotic Object being
 logged, the <code>name</code> export is copied off of the <code>module.exports</code> object and set
@@ -41970,45 +45509,46 @@ for these named exports.</p>
 always correctly detect named exports. In these cases, using the default
 import form described above can be a better option.</p>
 <p>Named exports detection covers many common export patterns, reexport patterns
-and build tool and transpiler outputs. See <a href="https://github.com/guybedford/cjs-module-lexer/tree/1.2.1">cjs-module-lexer</a> for the exact
+and build tool and transpiler outputs. See <a href="https://github.com/guybedford/cjs-module-lexer/tree/1.2.2">cjs-module-lexer</a> for the exact
 semantics implemented.</p>
-<h2>Builtin modules<span><a class="mark" href="#esm_builtin_modules" id="esm_builtin_modules">#</a></span></h2>
-<p><a href="#modules_core_modules">Core modules</a> provide named exports of their public API. A
-default export is also provided which is the value of the CommonJS exports.
-The default export can be used for, among other things, modifying the named
-exports. Named exports of builtin modules are updated only by calling
-<a href="#module_module_syncbuiltinesmexports"><code>module.syncBuiltinESMExports()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> EventEmitter <span class="hljs-keyword">from</span> <span class="hljs-string">'events'</span>;
-<span class="hljs-keyword">const</span> e = <span class="hljs-keyword">new</span> EventEmitter();</code></pre>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
-readFile(<span class="hljs-string">'./foo.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err, source</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(err);
-  } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(source);
-  }
-});</code></pre>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> fs, { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
-<span class="hljs-keyword">import</span> { syncBuiltinESMExports } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
-
-fs.readFileSync = <span class="hljs-function">() =></span> Buffer.from(<span class="hljs-string">'Hello, ESM'</span>);
-syncBuiltinESMExports();
-
-fs.readFileSync === readFileSync;</code></pre>
-<h2>CommonJS, JSON, and native modules<span><a class="mark" href="#esm_commonjs_json_and_native_modules" id="esm_commonjs_json_and_native_modules">#</a></span></h2>
-<p>CommonJS, JSON, and native modules can be used with
+<h4>Differences between ES modules and CommonJS<span><a class="mark" href="#esm_differences_between_es_modules_and_commonjs" id="esm_differences_between_es_modules_and_commonjs">#</a></span></h4>
+<h5>No <code>require</code>, <code>exports</code> or <code>module.exports</code><span><a class="mark" href="#esm_no_require_exports_or_module_exports" id="esm_no_require_exports_or_module_exports">#</a></span></h5>
+<p>In most cases, the ES module <code>import</code> can be used to load CommonJS modules.</p>
+<p>If needed, a <code>require</code> function can be constructed within an ES module using
 <a href="#module_module_createrequire_filename"><code>module.createRequire()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-comment">// cjs.cjs</span>
-<span class="hljs-built_in">module</span>.exports = <span class="hljs-string">'cjs'</span>;
-
-<span class="hljs-comment">// esm.mjs</span>
-<span class="hljs-keyword">import</span> { createRequire } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
-
-<span class="hljs-keyword">const</span> <span class="hljs-built_in">require</span> = createRequire(<span class="hljs-keyword">import</span>.meta.url);
-
-<span class="hljs-keyword">const</span> cjs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./cjs.cjs'</span>);
-cjs === <span class="hljs-string">'cjs'</span>; <span class="hljs-comment">// true</span></code></pre>
-<h2>Experimental JSON modules<span><a class="mark" href="#esm_experimental_json_modules" id="esm_experimental_json_modules">#</a></span></h2>
+<h5>No <code>__filename</code> or <code>__dirname</code><span><a class="mark" href="#esm_no_filename_or_dirname" id="esm_no_filename_or_dirname">#</a></span></h5>
+<p>These CommonJS variables are not available in ES modules.</p>
+<p><code>__filename</code> and <code>__dirname</code> use cases can be replicated via
+<a href="#esm_import_meta_url"><code>import.meta.url</code></a>.</p>
+<h5>No JSON Module Loading<span><a class="mark" href="#esm_no_json_module_loading" id="esm_no_json_module_loading">#</a></span></h5>
+<p>JSON imports are still experimental and only supported via the
+<code>--experimental-json-modules</code> flag.</p>
+<p>Local JSON files can be loaded relative to <code>import.meta.url</code> with <code>fs</code> directly:</p>
+<!-- eslint-skip -->
+<pre><code class="language-js"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+<span class="hljs-keyword">const</span> json = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(<span class="hljs-keyword">await</span> <span class="hljs-title function_">readFile</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'./dat.json'</span>, <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>)));</code></pre>
+<p>Alternatively <code>module.createRequire()</code> can be used.</p>
+<h5>No Native Module Loading<span><a class="mark" href="#esm_no_native_module_loading" id="esm_no_native_module_loading">#</a></span></h5>
+<p>Native modules are not currently supported with ES module imports.</p>
+<p>They can instead be loaded with <a href="#module_module_createrequire_filename"><code>module.createRequire()</code></a> or
+<a href="#process_process_dlopen_module_filename_flags"><code>process.dlopen</code></a>.</p>
+<h5>No <code>require.resolve</code><span><a class="mark" href="#esm_no_require_resolve" id="esm_no_require_resolve">#</a></span></h5>
+<p>Relative resolution can be handled via <code>new URL('./local', import.meta.url)</code>.</p>
+<p>For a complete <code>require.resolve</code> replacement, there is a flagged experimental
+<a href="#esm_import_meta_resolve_specifier_parent"><code>import.meta.resolve</code></a> API.</p>
+<p>Alternatively <code>module.createRequire()</code> can be used.</p>
+<h5>No <code>NODE_PATH</code><span><a class="mark" href="#esm_no_node_path" id="esm_no_node_path">#</a></span></h5>
+<p><code>NODE_PATH</code> is not part of resolving <code>import</code> specifiers. Please use symlinks
+if this behavior is desired.</p>
+<h5>No <code>require.extensions</code><span><a class="mark" href="#esm_no_require_extensions" id="esm_no_require_extensions">#</a></span></h5>
+<p><code>require.extensions</code> is not used by <code>import</code>. The expectation is that loader
+hooks can provide this workflow in the future.</p>
+<h5>No <code>require.cache</code><span><a class="mark" href="#esm_no_require_cache" id="esm_no_require_cache">#</a></span></h5>
+<p><code>require.cache</code> is not used by <code>import</code> as the ES module loader has its own
+separate cache.</p>
+<p><i id="esm_experimental_json_modules"></i></p>
+</section><section><h3>JSON modules<span><a class="mark" href="#esm_json_modules" id="esm_json_modules">#</a></span></h3>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Currently importing JSON modules are only supported in the <code>commonjs</code> mode
 and are loaded using the CJS loader. <a href="https://html.spec.whatwg.org/#creating-a-json-module-script">WHATWG JSON modules specification</a> are
 still being standardized, and are experimentally supported by including the
@@ -42027,7 +45567,9 @@ same path.</p>
 to work.</p>
 <pre><code class="language-bash">node index.mjs <span class="hljs-comment"># fails</span>
 node --experimental-json-modules index.mjs <span class="hljs-comment"># works</span></code></pre>
-<h2>Experimental Wasm modules<span><a class="mark" href="#esm_experimental_wasm_modules" id="esm_experimental_wasm_modules">#</a></span></h2>
+<p><i id="esm_experimental_wasm_modules"></i></p>
+</section><section><h3>Wasm modules<span><a class="mark" href="#esm_wasm_modules" id="esm_wasm_modules">#</a></span></h3>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Importing Web Assembly modules is supported under the
 <code>--experimental-wasm-modules</code> flag, allowing any <code>.wasm</code> files to be
 imported as normal modules while also supporting their module imports.</p>
@@ -42035,19 +45577,34 @@ imported as normal modules while also supporting their module imports.</p>
 <a href="https://github.com/webassembly/esm-integration">ES Module Integration Proposal for Web Assembly</a>.</p>
 <p>For example, an <code>index.mjs</code> containing:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> M <span class="hljs-keyword">from</span> <span class="hljs-string">'./module.wasm'</span>;
-<span class="hljs-built_in">console</span>.log(M);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(M);</code></pre>
 <p>executed under:</p>
 <pre><code class="language-bash">node --experimental-wasm-modules index.mjs</code></pre>
 <p>would provide the exports interface for the instantiation of <code>module.wasm</code>.</p>
-<h2>Experimental loaders<span><a class="mark" href="#esm_experimental_loaders" id="esm_experimental_loaders">#</a></span></h2>
+<p><i id="esm_experimental_top_level_await"></i></p>
+</section><section><h3>Top-level <code>await</code><span><a class="mark" href="#esm_top_level_await" id="esm_top_level_await">#</a></span></h3>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>The <code>await</code> keyword may be used in the top level (outside of async functions)
+within modules as per the <a href="https://github.com/tc39/proposal-top-level-await/">ECMAScript Top-Level <code>await</code> proposal</a>.</p>
+<p>Assuming an <code>a.mjs</code> with</p>
+<!-- eslint-skip -->
+<pre><code class="language-js"><span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> five = <span class="hljs-keyword">await</span> <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">5</span>);</code></pre>
+<p>And a <code>b.mjs</code> with</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> { five } <span class="hljs-keyword">from</span> <span class="hljs-string">'./a.mjs'</span>;
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(five); <span class="hljs-comment">// Logs `5`</span></code></pre>
+<pre><code class="language-bash">node b.mjs <span class="hljs-comment"># works</span></code></pre>
+<p><i id="esm_experimental_loaders"></i></p>
+</section><section><h3>Loaders<span><a class="mark" href="#esm_loaders" id="esm_loaders">#</a></span></h3>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p><strong>Note: This API is currently being redesigned and will still change.</strong></p>
 
 <p>To customize the default module resolution, loader hooks can optionally be
 provided via a <code>--experimental-loader ./loader-name.mjs</code> argument to Node.js.</p>
 <p>When hooks are used they only apply to ES module loading and not to any
 CommonJS modules loaded.</p>
-<h3>Hooks<span><a class="mark" href="#esm_hooks" id="esm_hooks">#</a></span></h3>
-<h4><code>resolve(specifier, context, defaultResolve)</code><span><a class="mark" href="#esm_resolve_specifier_context_defaultresolve" id="esm_resolve_specifier_context_defaultresolve">#</a></span></h4>
+<h4>Hooks<span><a class="mark" href="#esm_hooks" id="esm_hooks">#</a></span></h4>
+<h5><code>resolve(specifier, context, defaultResolve)</code><span><a class="mark" href="#esm_resolve_specifier_context_defaultresolve" id="esm_resolve_specifier_context_defaultresolve">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -42081,37 +45638,37 @@ Node.js module specifier resolution behavior</em> when calling <code>defaultReso
 <code>context.conditions</code> array passed to it <em>must</em> include <em>all</em> elements of the
 <code>context.conditions</code> array originally passed into the <code>resolve</code> hook.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{string}</span> <span class="hljs-variable">specifier</span></span>
- * <span class="hljs-doctag">@param <span class="hljs-type">{{
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">string</span>} <span class="hljs-variable">specifier</span>
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">{
  *   conditions: !Array&#x3C;string>,
  *   parentURL: !(string | undefined),
- * }</span></span>} context
- * <span class="hljs-doctag">@param <span class="hljs-type">{Function}</span> <span class="hljs-variable">defaultResolve</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{Promise&#x3C;{ url: string }</span></span>>}
+ * </span>}} context
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Function</span>} <span class="hljs-variable">defaultResolve</span>
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">Promise&#x3C;{ url: string </span>}>}
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) {
   <span class="hljs-keyword">const</span> { parentURL = <span class="hljs-literal">null</span> } = context;
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
     <span class="hljs-comment">// For some or all specifiers, do some custom logic for resolving.</span>
     <span class="hljs-comment">// Always return an object of the form {url: &#x3C;string>}.</span>
     <span class="hljs-keyword">return</span> {
       <span class="hljs-attr">url</span>: parentURL ?
-        <span class="hljs-keyword">new</span> URL(specifier, parentURL).href :
-        <span class="hljs-keyword">new</span> URL(specifier).href,
+        <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(specifier, parentURL).<span class="hljs-property">href</span> :
+        <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(specifier).<span class="hljs-property">href</span>,
     };
   }
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() &#x3C; <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Another condition.</span>
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() &#x3C; <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Another condition.</span>
     <span class="hljs-comment">// When calling `defaultResolve`, the arguments can be modified. In this</span>
     <span class="hljs-comment">// case it's adding another value for matching conditional exports.</span>
-    <span class="hljs-keyword">return</span> defaultResolve(specifier, {
+    <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultResolve</span>(specifier, {
       ...context,
-      <span class="hljs-attr">conditions</span>: [...context.conditions, <span class="hljs-string">'another-condition'</span>],
+      <span class="hljs-attr">conditions</span>: [...context.<span class="hljs-property">conditions</span>, <span class="hljs-string">'another-condition'</span>],
     });
   }
   <span class="hljs-comment">// Defer to Node.js for all other specifiers.</span>
-  <span class="hljs-keyword">return</span> defaultResolve(specifier, context, defaultResolve);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultResolve</span>(specifier, context, defaultResolve);
 }</code></pre>
-<h4><code>getFormat(url, context, defaultGetFormat)</code><span><a class="mark" href="#esm_getformat_url_context_defaultgetformat" id="esm_getformat_url_context_defaultgetformat">#</a></span></h4>
+<h5><code>getFormat(url, context, defaultGetFormat)</code><span><a class="mark" href="#esm_getformat_url_context_defaultgetformat" id="esm_getformat_url_context_defaultgetformat">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -42165,27 +45722,22 @@ of the following:</p>
 
 
 
-
-
-
-
-
-<table><thead><tr><th><code>format</code></th><th>Description</th><th>Acceptable Types For <code>source</code> Returned by <code>getSource</code> or <code>transformSource</code></th></tr></thead><tbody><tr><td><code>'builtin'</code></td><td>Load a Node.js builtin module</td><td>Not applicable</td></tr><tr><td><code>'dynamic'</code></td><td>Use a <a href="#esm_code_dynamicinstantiate_code_hook">dynamic instantiate hook</a></td><td>Not applicable</td></tr><tr><td><code>'commonjs'</code></td><td>Load a Node.js CommonJS module</td><td>Not applicable</td></tr><tr><td><code>'json'</code></td><td>Load a JSON file</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"><code>string</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr><tr><td><code>'module'</code></td><td>Load an ES module</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"><code>string</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr><tr><td><code>'wasm'</code></td><td>Load a WebAssembly module</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr></tbody></table>
+<table><thead><tr><th><code>format</code></th><th>Description</th><th>Acceptable Types For <code>source</code> Returned by <code>getSource</code> or <code>transformSource</code></th></tr></thead><tbody><tr><td><code>'builtin'</code></td><td>Load a Node.js builtin module</td><td>Not applicable</td></tr><tr><td><code>'commonjs'</code></td><td>Load a Node.js CommonJS module</td><td>Not applicable</td></tr><tr><td><code>'json'</code></td><td>Load a JSON file</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"><code>string</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr><tr><td><code>'module'</code></td><td>Load an ES module</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"><code>string</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr><tr><td><code>'wasm'</code></td><td>Load a WebAssembly module</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr></tbody></table>
 <p>Note: These types all correspond to classes defined in ECMAScript.</p>
 <ul>
 <li>The specific <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> object is a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a>.</li>
 <li>The specific <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> object is a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a>.</li>
 </ul>
 <p>Note: If the source value of a text-based format (i.e., <code>'json'</code>, <code>'module'</code>) is
-not a string, it is converted to a string using <a href="util.md#util_class_util_textdecoder"><code>util.TextDecoder</code></a>.</p>
+not a string, it is converted to a string using <a href="#util_class_util_textdecoder"><code>util.TextDecoder</code></a>.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{string}</span> <span class="hljs-variable">url</span></span>
- * <span class="hljs-doctag">@param <span class="hljs-type">{Object}</span> </span>context (currently empty)
- * <span class="hljs-doctag">@param <span class="hljs-type">{Function}</span> <span class="hljs-variable">defaultGetFormat</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{Promise&#x3C;{ format: string }</span></span>>}
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">string</span>} <span class="hljs-variable">url</span>
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Object</span>} context (currently empty)
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Function</span>} <span class="hljs-variable">defaultGetFormat</span>
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">Promise&#x3C;{ format: string </span>}>}
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) </span>{
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) {
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
     <span class="hljs-comment">// For some or all URLs, do some custom logic for determining format.</span>
     <span class="hljs-comment">// Always return an object of the form {format: &#x3C;string>}, where the</span>
     <span class="hljs-comment">// format is one of the strings in the preceding table.</span>
@@ -42194,9 +45746,9 @@ not a string, it is converted to a string using <a href="util.md#util_class_util
     };
   }
   <span class="hljs-comment">// Defer to Node.js for all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetFormat(url, context, defaultGetFormat);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetFormat</span>(url, context, defaultGetFormat);
 }</code></pre>
-<h4><code>getSource(url, context, defaultGetSource)</code><span><a class="mark" href="#esm_getsource_url_context_defaultgetsource" id="esm_getsource_url_context_defaultgetsource">#</a></span></h4>
+<h5><code>getSource(url, context, defaultGetSource)</code><span><a class="mark" href="#esm_getsource_url_context_defaultgetsource" id="esm_getsource_url_context_defaultgetsource">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -42219,14 +45771,14 @@ signature may change. Do not rely on the API described below.</p>
 the source code of an ES module specifier. This would allow a loader to
 potentially avoid reading files from disk.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{string}</span> <span class="hljs-variable">url</span></span>
- * <span class="hljs-doctag">@param <span class="hljs-type">{{ format: string }</span></span>} context
- * <span class="hljs-doctag">@param <span class="hljs-type">{Function}</span> <span class="hljs-variable">defaultGetSource</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) }</span></span>>}
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">string</span>} <span class="hljs-variable">url</span>
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">{ format: string </span>}} context
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Function</span>} <span class="hljs-variable">defaultGetSource</span>
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) </span>}>}
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getSource</span>(<span class="hljs-params">url, context, defaultGetSource</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getSource</span>(<span class="hljs-params">url, context, defaultGetSource</span>) {
   <span class="hljs-keyword">const</span> { format } = context;
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
     <span class="hljs-comment">// For some or all URLs, do some custom logic for retrieving the source.</span>
     <span class="hljs-comment">// Always return an object of the form {source: &#x3C;string|buffer>}.</span>
     <span class="hljs-keyword">return</span> {
@@ -42234,10 +45786,9 @@ potentially avoid reading files from disk.</p>
     };
   }
   <span class="hljs-comment">// Defer to Node.js for all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetSource(url, context, defaultGetSource);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetSource</span>(url, context, defaultGetSource);
 }</code></pre>
-<h4><code>transformSource(source, context, defaultTransformSource)</code><span><a class="mark" href="#esm_transformsource_source_context_defaulttransformsource" id="esm_transformsource_source_context_defaulttransformsource">#</a></span></h4>
-<pre><code class="language-console">NODE_OPTIONS='--experimental-loader ./custom-loader.mjs' node x.js</code></pre>
+<h5><code>transformSource(source, context, defaultTransformSource)</code><span><a class="mark" href="#esm_transformsource_source_context_defaulttransformsource" id="esm_transformsource_source_context_defaulttransformsource">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -42263,17 +45814,17 @@ done anything with it.</p>
 JavaScript, a resolve hook is also necessary in order to register any
 unknown-to-Node.js file extensions. See the <a href="#esm_transpiler_loader">transpiler loader example</a> below.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{!(string | SharedArrayBuffer | Uint8Array)}</span> <span class="hljs-variable">source</span></span>
- * <span class="hljs-doctag">@param <span class="hljs-type">{{
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">!(string | SharedArrayBuffer | Uint8Array)</span>} <span class="hljs-variable">source</span>
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">{
  *   format: string,
  *   url: string,
- * }</span></span>} context
- * <span class="hljs-doctag">@param <span class="hljs-type">{Function}</span> <span class="hljs-variable">defaultTransformSource</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) }</span></span>>}
+ * </span>}} context
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Function</span>} <span class="hljs-variable">defaultTransformSource</span>
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) </span>}>}
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">transformSource</span>(<span class="hljs-params">source, context, defaultTransformSource</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">transformSource</span>(<span class="hljs-params">source, context, defaultTransformSource</span>) {
   <span class="hljs-keyword">const</span> { url, format } = context;
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
     <span class="hljs-comment">// For some or all URLs, do some custom logic for modifying the source.</span>
     <span class="hljs-comment">// Always return an object of the form {source: &#x3C;string|buffer>}.</span>
     <span class="hljs-keyword">return</span> {
@@ -42281,9 +45832,9 @@ unknown-to-Node.js file extensions. See the <a href="#esm_transpiler_loader">tra
     };
   }
   <span class="hljs-comment">// Defer to Node.js for all other sources.</span>
-  <span class="hljs-keyword">return</span> defaultTransformSource(source, context, defaultTransformSource);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultTransformSource</span>(source, context, defaultTransformSource);
 }</code></pre>
-<h4><code>getGlobalPreloadCode()</code><span><a class="mark" href="#esm_getglobalpreloadcode" id="esm_getglobalpreloadcode">#</a></span></h4>
+<h5><code>getGlobalPreloadCode()</code><span><a class="mark" href="#esm_getglobalpreloadcode" id="esm_getglobalpreloadcode">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -42300,9 +45851,9 @@ builtins like "fs": <code>getBuiltin(request: string)</code>.</p>
 <p>If the code needs more advanced <code>require</code> features, it has to construct
 its own <code>require</code> using  <code>module.createRequire()</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@returns <span class="hljs-type">{string}</span> </span>Code to run before application startup
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">string</span>} Code to run before application startup
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getGlobalPreloadCode</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getGlobalPreloadCode</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">return</span> <span class="hljs-string">`\
 globalThis.someInjectedProperty = 42;
 console.log('I just set some globals!');
@@ -42313,37 +45864,10 @@ const require = createRequire(process.cwd() + '/&#x3C;preload>');
 // [...]
 `</span>;
 }</code></pre>
-<h4><code>dynamicInstantiate</code> hook<span><a class="mark" href="#esm_code_dynamicinstantiate_code_hook" id="esm_code_dynamicinstantiate_code_hook">#</a></span></h4>
-<blockquote>
-<p>Note: The loaders API is being redesigned. This hook may disappear or its
-signature may change. Do not rely on the API described below.</p>
-</blockquote>
-<p>To create a custom dynamic module that doesn't correspond to one of the
-existing <code>format</code> interpretations, the <code>dynamicInstantiate</code> hook can be used.
-This hook is called only for modules that return <code>format: 'dynamic'</code> from
-the <code>getFormat</code> hook.</p>
-<pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{string}</span> <span class="hljs-variable">url</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{object}</span> <span class="hljs-variable">response</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{array}</span> </span>response.exports
- * <span class="hljs-doctag">@returns <span class="hljs-type">{function}</span> </span>response.execute
- */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">dynamicInstantiate</span>(<span class="hljs-params">url</span>) </span>{
-  <span class="hljs-keyword">return</span> {
-    <span class="hljs-attr">exports</span>: [<span class="hljs-string">'customExportName'</span>],
-    <span class="hljs-attr">execute</span>: <span class="hljs-function">(<span class="hljs-params"><span class="hljs-built_in">exports</span></span>) =></span> {
-      <span class="hljs-comment">// Get and set functions provided for pre-allocated export names</span>
-      <span class="hljs-built_in">exports</span>.customExportName.set(<span class="hljs-string">'value'</span>);
-    }
-  };
-}</code></pre>
-<p>With the list of module exports provided upfront, the <code>execute</code> function will
-then be called at the exact point of module evaluation order for that module
-in the import tree.</p>
-<h3>Examples<span><a class="mark" href="#esm_examples" id="esm_examples">#</a></span></h3>
+<h4>Examples<span><a class="mark" href="#esm_examples" id="esm_examples">#</a></span></h4>
 <p>The various loader hooks can be used together to accomplish wide-ranging
 customizations of Node.js’ code loading and evaluation behaviors.</p>
-<h4>HTTPS loader<span><a class="mark" href="#esm_https_loader" id="esm_https_loader">#</a></span></h4>
+<h5>HTTPS loader<span><a class="mark" href="#esm_https_loader" id="esm_https_loader">#</a></span></h5>
 <p>In current Node.js, specifiers starting with <code>https://</code> are unsupported. The
 loader below registers hooks to enable rudimentary support for such specifiers.
 While this may seem like a significant improvement to Node.js core
@@ -42353,63 +45877,63 @@ and there is no security.</p>
 <pre><code class="language-js"><span class="hljs-comment">// https-loader.mjs</span>
 <span class="hljs-keyword">import</span> { get } <span class="hljs-keyword">from</span> <span class="hljs-string">'https'</span>;
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) {
   <span class="hljs-keyword">const</span> { parentURL = <span class="hljs-literal">null</span> } = context;
 
   <span class="hljs-comment">// Normally Node.js would error on specifiers starting with 'https://', so</span>
   <span class="hljs-comment">// this hook intercepts them and converts them into absolute URLs to be</span>
   <span class="hljs-comment">// passed along to the later hooks below.</span>
-  <span class="hljs-keyword">if</span> (specifier.startsWith(<span class="hljs-string">'https://'</span>)) {
+  <span class="hljs-keyword">if</span> (specifier.<span class="hljs-title function_">startsWith</span>(<span class="hljs-string">'https://'</span>)) {
     <span class="hljs-keyword">return</span> {
       <span class="hljs-attr">url</span>: specifier
     };
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (parentURL &#x26;&#x26; parentURL.startsWith(<span class="hljs-string">'https://'</span>)) {
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (parentURL &#x26;&#x26; parentURL.<span class="hljs-title function_">startsWith</span>(<span class="hljs-string">'https://'</span>)) {
     <span class="hljs-keyword">return</span> {
-      <span class="hljs-attr">url</span>: <span class="hljs-keyword">new</span> URL(specifier, parentURL).href
+      <span class="hljs-attr">url</span>: <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(specifier, parentURL).<span class="hljs-property">href</span>
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other specifiers.</span>
-  <span class="hljs-keyword">return</span> defaultResolve(specifier, context, defaultResolve);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultResolve</span>(specifier, context, defaultResolve);
 }
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) {
   <span class="hljs-comment">// This loader assumes all network-provided JavaScript is ES module code.</span>
-  <span class="hljs-keyword">if</span> (url.startsWith(<span class="hljs-string">'https://'</span>)) {
+  <span class="hljs-keyword">if</span> (url.<span class="hljs-title function_">startsWith</span>(<span class="hljs-string">'https://'</span>)) {
     <span class="hljs-keyword">return</span> {
       <span class="hljs-attr">format</span>: <span class="hljs-string">'module'</span>
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetFormat(url, context, defaultGetFormat);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetFormat</span>(url, context, defaultGetFormat);
 }
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getSource</span>(<span class="hljs-params">url, context, defaultGetSource</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getSource</span>(<span class="hljs-params">url, context, defaultGetSource</span>) {
   <span class="hljs-comment">// For JavaScript to be loaded over the network, we need to fetch and</span>
   <span class="hljs-comment">// return it.</span>
-  <span class="hljs-keyword">if</span> (url.startsWith(<span class="hljs-string">'https://'</span>)) {
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-      get(url, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-keyword">if</span> (url.<span class="hljs-title function_">startsWith</span>(<span class="hljs-string">'https://'</span>)) {
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+      <span class="hljs-title function_">get</span>(url, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
         <span class="hljs-keyword">let</span> data = <span class="hljs-string">''</span>;
-        res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> data += chunk);
-        res.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> resolve({ <span class="hljs-attr">source</span>: data }));
-      }).on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> reject(err));
+        res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> data += chunk);
+        res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> <span class="hljs-title function_">resolve</span>({ <span class="hljs-attr">source</span>: data }));
+      }).<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-title function_">reject</span>(err));
     });
   }
 
   <span class="hljs-comment">// Let Node.js handle all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetSource(url, context, defaultGetSource);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetSource</span>(url, context, defaultGetSource);
 }</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// main.mjs</span>
-<span class="hljs-keyword">import</span> { VERSION } <span class="hljs-keyword">from</span> <span class="hljs-string">'https://coffeescript.org/browser-compiler-modern/coffeescript.js'</span>;
+<span class="hljs-keyword">import</span> { <span class="hljs-variable constant_">VERSION</span> } <span class="hljs-keyword">from</span> <span class="hljs-string">'https://coffeescript.org/browser-compiler-modern/coffeescript.js'</span>;
 
-<span class="hljs-built_in">console</span>.log(VERSION);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable constant_">VERSION</span>);</code></pre>
 <p>With the preceding loader, running
 <code>node --experimental-loader ./https-loader.mjs ./main.mjs</code>
 prints the current version of CoffeeScript per the module at the URL in
 <code>main.mjs</code>.</p>
-<h4>Transpiler loader<span><a class="mark" href="#esm_transpiler_loader" id="esm_transpiler_loader">#</a></span></h4>
+<h5>Transpiler loader<span><a class="mark" href="#esm_transpiler_loader" id="esm_transpiler_loader">#</a></span></h5>
 <p>Sources that are in formats Node.js doesn’t understand can be converted into
 JavaScript using the <a href="#esm_transformsource_source_context_defaulttransformsource"><code>transformSource</code> hook</a>. Before that hook gets called,
 however, other hooks need to tell Node.js not to throw an error on unknown file
@@ -42418,61 +45942,61 @@ types; and to tell Node.js how to load this new file type.</p>
 Node.js; a transpiler loader should only be used for development and testing
 purposes.</p>
 <pre><code class="language-js"><span class="hljs-comment">// coffeescript-loader.mjs</span>
-<span class="hljs-keyword">import</span> { URL, pathToFileURL } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
-<span class="hljs-keyword">import</span> CoffeeScript <span class="hljs-keyword">from</span> <span class="hljs-string">'coffeescript'</span>;
+<span class="hljs-keyword">import</span> { <span class="hljs-variable constant_">URL</span>, pathToFileURL } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
+<span class="hljs-keyword">import</span> <span class="hljs-title class_">CoffeeScript</span> <span class="hljs-keyword">from</span> <span class="hljs-string">'coffeescript'</span>;
 
-<span class="hljs-keyword">const</span> baseURL = pathToFileURL(<span class="hljs-string">`<span class="hljs-subst">${process.cwd()}</span>/`</span>).href;
+<span class="hljs-keyword">const</span> baseURL = <span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">`<span class="hljs-subst">${process.cwd()}</span>/`</span>).<span class="hljs-property">href</span>;
 
 <span class="hljs-comment">// CoffeeScript files end in .coffee, .litcoffee or .coffee.md.</span>
 <span class="hljs-keyword">const</span> extensionsRegex = <span class="hljs-regexp">/\.coffee$|\.litcoffee$|\.coffee\.md$/</span>;
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) {
   <span class="hljs-keyword">const</span> { parentURL = baseURL } = context;
 
   <span class="hljs-comment">// Node.js normally errors on unknown file extensions, so return a URL for</span>
   <span class="hljs-comment">// specifiers ending in the CoffeeScript file extensions.</span>
-  <span class="hljs-keyword">if</span> (extensionsRegex.test(specifier)) {
+  <span class="hljs-keyword">if</span> (extensionsRegex.<span class="hljs-title function_">test</span>(specifier)) {
     <span class="hljs-keyword">return</span> {
-      <span class="hljs-attr">url</span>: <span class="hljs-keyword">new</span> URL(specifier, parentURL).href
+      <span class="hljs-attr">url</span>: <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(specifier, parentURL).<span class="hljs-property">href</span>
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other specifiers.</span>
-  <span class="hljs-keyword">return</span> defaultResolve(specifier, context, defaultResolve);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultResolve</span>(specifier, context, defaultResolve);
 }
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) {
   <span class="hljs-comment">// Now that we patched resolve to let CoffeeScript URLs through, we need to</span>
   <span class="hljs-comment">// tell Node.js what format such URLs should be interpreted as. For the</span>
   <span class="hljs-comment">// purposes of this loader, all CoffeeScript URLs are ES modules.</span>
-  <span class="hljs-keyword">if</span> (extensionsRegex.test(url)) {
+  <span class="hljs-keyword">if</span> (extensionsRegex.<span class="hljs-title function_">test</span>(url)) {
     <span class="hljs-keyword">return</span> {
       <span class="hljs-attr">format</span>: <span class="hljs-string">'module'</span>
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetFormat(url, context, defaultGetFormat);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetFormat</span>(url, context, defaultGetFormat);
 }
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">transformSource</span>(<span class="hljs-params">source, context, defaultTransformSource</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">transformSource</span>(<span class="hljs-params">source, context, defaultTransformSource</span>) {
   <span class="hljs-keyword">const</span> { url, format } = context;
 
-  <span class="hljs-keyword">if</span> (extensionsRegex.test(url)) {
+  <span class="hljs-keyword">if</span> (extensionsRegex.<span class="hljs-title function_">test</span>(url)) {
     <span class="hljs-keyword">return</span> {
-      <span class="hljs-attr">source</span>: CoffeeScript.compile(source, { <span class="hljs-attr">bare</span>: <span class="hljs-literal">true</span> })
+      <span class="hljs-attr">source</span>: <span class="hljs-title class_">CoffeeScript</span>.<span class="hljs-title function_">compile</span>(source, { <span class="hljs-attr">bare</span>: <span class="hljs-literal">true</span> })
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other sources.</span>
-  <span class="hljs-keyword">return</span> defaultTransformSource(source, context, defaultTransformSource);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultTransformSource</span>(source, context, defaultTransformSource);
 }</code></pre>
 <pre><code class="language-coffee"><span class="hljs-comment"># main.coffee</span>
 <span class="hljs-keyword">import</span> { scream } <span class="hljs-keyword">from</span> <span class="hljs-string">'./scream.coffee'</span>
-<span class="hljs-built_in">console</span>.log scream <span class="hljs-string">'hello, world'</span>
+console.log scream <span class="hljs-string">'hello, world'</span>
 
 <span class="hljs-keyword">import</span> { version } <span class="hljs-keyword">from</span> <span class="hljs-string">'process'</span>
-<span class="hljs-built_in">console</span>.log <span class="hljs-string">"Brought to you by Node.js version <span class="hljs-subst">#{version}</span>"</span></code></pre>
+console.log <span class="hljs-string">"Brought to you by Node.js version <span class="hljs-subst">#{version}</span>"</span></code></pre>
 <pre><code class="language-coffee"><span class="hljs-comment"># scream.coffee</span>
 <span class="hljs-keyword">export</span> scream = <span class="hljs-function"><span class="hljs-params">(str)</span> -></span> str.toUpperCase()</code></pre>
 <p>With the preceding loader, running
@@ -42481,8 +46005,8 @@ causes <code>main.coffee</code> to be turned into JavaScript after its source co
 loaded from disk but before Node.js executes it; and so on for any <code>.coffee</code>,
 <code>.litcoffee</code> or <code>.coffee.md</code> files referenced via <code>import</code> statements of any
 loaded file.</p>
-<h2>Resolution algorithm<span><a class="mark" href="#esm_resolution_algorithm" id="esm_resolution_algorithm">#</a></span></h2>
-<h3>Features<span><a class="mark" href="#esm_features" id="esm_features">#</a></span></h3>
+</section><section><h3>Resolution algorithm<span><a class="mark" href="#esm_resolution_algorithm" id="esm_resolution_algorithm">#</a></span></h3>
+<h4>Features<span><a class="mark" href="#esm_features" id="esm_features">#</a></span></h4>
 <p>The resolver has the following properties:</p>
 <ul>
 <li>FileURL-based resolution as is used by ES modules</li>
@@ -42492,7 +46016,7 @@ loaded file.</p>
 <li>No folder mains</li>
 <li>Bare specifier package resolution lookup through node_modules</li>
 </ul>
-<h3>Resolver algorithm<span><a class="mark" href="#esm_resolver_algorithm" id="esm_resolver_algorithm">#</a></span></h3>
+<h4>Resolver algorithm<span><a class="mark" href="#esm_resolver_algorithm" id="esm_resolver_algorithm">#</a></span></h4>
 <p>The algorithm to load an ES module specifier is given through the
 <strong>ESM_RESOLVE</strong> method below. It returns the resolved URL for a
 module specifier relative to a parentURL.</p>
@@ -42518,8 +46042,10 @@ for the package that is an invalid type or string target.</li>
 subpath in the package for the given module.</li>
 <li><em>Package Import Not Defined</em>: Package imports do not define the specifier.</li>
 <li><em>Module Not Found</em>: The package or module requested does not exist.</li>
+<li><em>Unsupported Directory Import</em>: The resolved path corresponds to a directory,
+which is not a supported target for module imports.</li>
 </ul>
-<h3>Resolver Algorithm Specification<span><a class="mark" href="#esm_resolver_algorithm_specification" id="esm_resolver_algorithm_specification">#</a></span></h3>
+<h4>Resolver Algorithm Specification<span><a class="mark" href="#esm_resolver_algorithm_specification" id="esm_resolver_algorithm_specification">#</a></span></h4>
 <p><strong>ESM_RESOLVE</strong>(<em>specifier</em>, <em>parentURL</em>)</p>
 <blockquote>
 <ol>
@@ -42960,7 +46486,8 @@ error.</li>
 <li>Return the parsed JSON source of the file at <em>pjsonURL</em>.</li>
 </ol>
 </blockquote>
-<h3>Customizing ESM specifier resolution algorithm<span><a class="mark" href="#esm_customizing_esm_specifier_resolution_algorithm" id="esm_customizing_esm_specifier_resolution_algorithm">#</a></span></h3>
+<h4>Customizing ESM specifier resolution algorithm<span><a class="mark" href="#esm_customizing_esm_specifier_resolution_algorithm" id="esm_customizing_esm_specifier_resolution_algorithm">#</a></span></h4>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>The current specifier resolution does not support all default behavior of
 the CommonJS loader. One of the behavior differences is automatic resolution
 of file extensions and the ability to import directories that have an index
@@ -42970,23 +46497,27 @@ the extension resolution algorithm. The default mode is <code>explicit</code>, w
 requires the full path to a module be provided to the loader. To enable the
 automatic extension resolution and importing from directories that include an
 index file use the <code>node</code> mode.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node index.mjs</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node index.mjs</span>
 success!
-<span class="hljs-meta">$</span><span class="bash"> node index <span class="hljs-comment"># Failure!</span></span>
+<span class="hljs-meta">$ </span><span class="language-bash">node index <span class="hljs-comment"># Failure!</span></span>
 Error: Cannot find module
-<span class="hljs-meta">$</span><span class="bash"> node --experimental-specifier-resolution=node index</span>
+<span class="hljs-meta">$ </span><span class="language-bash">node --experimental-specifier-resolution=node index</span>
 success!</code></pre>
-<!-- Note: The cjs-module-lexer link should be kept in-sync with the deps version -->
-<h1>Modules: <code>module</code> API<span><a class="mark" href="#module_modules_module_api" id="module_modules_module_api">#</a></span></h1>
+<!-- Note: The cjs-module-lexer link should be kept in-sync with the deps version --></section>
+        </section>
+<section><h2>Modules: <code>module</code> API<span><a class="mark" href="#module_modules_module_api" id="module_modules_module_api">#</a></span></h2>
 
-<h2>The <code>Module</code> object<span><a class="mark" href="#module_the_module_object" id="module_the_module_object">#</a></span></h2>
+<div class="api_metadata">
+<span>Added in: v0.3.7</span>
+</div>
+<section><h3>The <code>Module</code> object<span><a class="mark" href="#module_the_module_object" id="module_the_module_object">#</a></span></h3>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>Provides general utility methods when interacting with instances of
 <code>Module</code>, the <a href="#modules_the_module_object"><code>module</code></a> variable often seen in <a href="modules.html">CommonJS</a> modules. Accessed
 via <code>import 'module'</code> or <code>require('module')</code>.</p>
-<h3><code>module.builtinModules</code><span><a class="mark" href="#module_module_builtinmodules" id="module_module_builtinmodules">#</a></span></h3>
+<h4><code>module.builtinModules</code><span><a class="mark" href="#module_module_builtinmodules" id="module_module_builtinmodules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.3.0, v8.10.0, v6.13.0</span>
 </div>
@@ -42996,14 +46527,14 @@ via <code>import 'module'</code> or <code>require('module')</code>.</p>
 <p>A list of the names of all modules provided by Node.js. Can be used to verify
 if a module is maintained by a third party or not.</p>
 <p><code>module</code> in this context isn't the same object that's provided
-by the <a href="modules_cjs.html#modules_cjs_the_module_wrapper">module wrapper</a>. To access it, require the <code>Module</code> module:</p>
-<pre><code class="language-js"><span class="hljs-comment">// module.mjs</span>
+by the <a href="#modules_the_module_wrapper">module wrapper</a>. To access it, require the <code>Module</code> module:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-comment">// module.mjs</span>
 <span class="hljs-comment">// In an ECMAScript module</span>
-<span class="hljs-keyword">import</span> { builtinModules <span class="hljs-keyword">as</span> builtin } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;</code></pre>
-<pre><code class="language-js"><span class="hljs-comment">// module.cjs</span>
+<span class="hljs-keyword">import</span> { builtinModules <span class="hljs-keyword">as</span> builtin } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;</code><code class="language-js cjs"><span class="hljs-comment">// module.cjs</span>
 <span class="hljs-comment">// In a CommonJS module</span>
-<span class="hljs-keyword">const</span> builtin = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>).builtinModules;</code></pre>
-<h3><code>module.createRequire(filename)</code><span><a class="mark" href="#module_module_createrequire_filename" id="module_module_createrequire_filename">#</a></span></h3>
+<span class="hljs-keyword">const</span> builtin = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>).<span class="hljs-property">builtinModules</span>;</code></pre>
+<h4><code>module.createRequire(filename)</code><span><a class="mark" href="#module_module_createrequire_filename" id="module_module_createrequire_filename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.2.0</span>
 </div>
@@ -43013,12 +46544,12 @@ function. Must be a file URL object, file URL string, or absolute path
 string.</li>
 <li>Returns: <a href="#modules_require_id" class="type">&#x3C;require></a> Require function</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> { createRequire } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
-<span class="hljs-keyword">const</span> <span class="hljs-built_in">require</span> = createRequire(<span class="hljs-keyword">import</span>.meta.url);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { createRequire } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
+<span class="hljs-keyword">const</span> <span class="hljs-built_in">require</span> = <span class="hljs-title function_">createRequire</span>(<span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>);
 
 <span class="hljs-comment">// sibling-module.js is a CommonJS module.</span>
 <span class="hljs-keyword">const</span> siblingModule = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./sibling-module'</span>);</code></pre>
-<h3><code>module.createRequireFromPath(filename)</code><span><a class="mark" href="#module_module_createrequirefrompath_filename" id="module_module_createrequirefrompath_filename">#</a></span></h3>
+<h4><code>module.createRequireFromPath(filename)</code><span><a class="mark" href="#module_module_createrequirefrompath_filename" id="module_module_createrequirefrompath_filename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span><span>Deprecated since: v12.2.0</span>
 </div>
@@ -43029,11 +46560,11 @@ function.</li>
 <li>Returns: <a href="#modules_require_id" class="type">&#x3C;require></a> Require function</li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { createRequireFromPath } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);
-<span class="hljs-keyword">const</span> requireUtil = createRequireFromPath(<span class="hljs-string">'../src/utils/'</span>);
+<span class="hljs-keyword">const</span> requireUtil = <span class="hljs-title function_">createRequireFromPath</span>(<span class="hljs-string">'../src/utils/'</span>);
 
 <span class="hljs-comment">// Require `../src/utils/some-tool`</span>
 requireUtil(<span class="hljs-string">'./some-tool'</span>);</code></pre>
-<h3><code>module.syncBuiltinESMExports()</code><span><a class="mark" href="#module_module_syncbuiltinesmexports" id="module_module_syncbuiltinesmexports">#</a></span></h3>
+<h4><code>module.syncBuiltinESMExports()</code><span><a class="mark" href="#module_module_syncbuiltinesmexports" id="module_module_syncbuiltinesmexports">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.12.0</span>
 </div>
@@ -43041,24 +46572,32 @@ requireUtil(<span class="hljs-string">'./some-tool'</span>);</code></pre>
 builtin <a href="esm.html">ES Modules</a> to match the properties of the <a href="modules.html">CommonJS</a> exports. It
 does not add or remove exported names from the <a href="esm.html">ES Modules</a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 <span class="hljs-keyword">const</span> { syncBuiltinESMExports } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);
 
-fs.readFile = <span class="hljs-literal">null</span>;
+fs.<span class="hljs-property">readFile</span> = newAPI;
 
-<span class="hljs-keyword">delete</span> fs.readFileSync;
+<span class="hljs-keyword">delete</span> fs.<span class="hljs-property">readFileSync</span>;
 
-fs.newAPI = <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">newAPI</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">newAPI</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// ...</span>
-};
+}
 
-syncBuiltinESMExports();
+fs.<span class="hljs-property">newAPI</span> = newAPI;
 
-<span class="hljs-keyword">import</span>(<span class="hljs-string">'fs'</span>).then(<span class="hljs-function">(<span class="hljs-params">esmFS</span>) =></span> {
-  assert.strictEqual(esmFS.readFile, <span class="hljs-literal">null</span>);
-  assert.strictEqual(<span class="hljs-string">'readFileSync'</span> <span class="hljs-keyword">in</span> fs, <span class="hljs-literal">true</span>);
-  assert.strictEqual(esmFS.newAPI, <span class="hljs-literal">undefined</span>);
+<span class="hljs-title function_">syncBuiltinESMExports</span>();
+
+<span class="hljs-title function_">import</span>(<span class="hljs-string">'fs'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">esmFS</span>) =></span> {
+  <span class="hljs-comment">// It syncs the existing readFile property with the new value</span>
+  assert.<span class="hljs-title function_">strictEqual</span>(esmFS.<span class="hljs-property">readFile</span>, newAPI);
+  <span class="hljs-comment">// readFileSync has been deleted from the required fs</span>
+  assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-string">'readFileSync'</span> <span class="hljs-keyword">in</span> fs, <span class="hljs-literal">false</span>);
+  <span class="hljs-comment">// syncBuiltinESMExports() does not remove readFileSync from esmFS</span>
+  assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-string">'readFileSync'</span> <span class="hljs-keyword">in</span> esmFS, <span class="hljs-literal">true</span>);
+  <span class="hljs-comment">// syncBuiltinESMExports() does not add names</span>
+  assert.<span class="hljs-title function_">strictEqual</span>(esmFS.<span class="hljs-property">newAPI</span>, <span class="hljs-literal">undefined</span>);
 });</code></pre>
-<h2>Source map v3 support<span><a class="mark" href="#module_source_map_v3_support" id="module_source_map_v3_support">#</a></span></h2>
+</section><section><h3>Source map v3 support<span><a class="mark" href="#module_source_map_v3_support" id="module_source_map_v3_support">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v13.7.0, v12.17.0</span>
 </div>
@@ -43069,33 +46608,29 @@ populated when source map parsing is enabled and
 <p>To enable source map parsing, Node.js must be run with the flag
 <a href="#cli_enable_source_maps"><code>--enable-source-maps</code></a>, or with code coverage enabled by setting
 <a href="#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE=dir</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-comment">// module.mjs</span>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-comment">// module.mjs</span>
 <span class="hljs-comment">// In an ECMAScript module</span>
-<span class="hljs-keyword">import</span> { findSourceMap, SourceMap } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;</code></pre>
-<pre><code class="language-js"><span class="hljs-comment">// module.cjs</span>
+<span class="hljs-keyword">import</span> { findSourceMap, <span class="hljs-title class_">SourceMap</span> } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;</code><code class="language-js cjs"><span class="hljs-comment">// module.cjs</span>
 <span class="hljs-comment">// In a CommonJS module</span>
-<span class="hljs-keyword">const</span> { findSourceMap, SourceMap } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);</code></pre>
-<h3><code>module.findSourceMap(path[, error])</code><span><a class="mark" href="#module_module_findsourcemap_path_error" id="module_module_findsourcemap_path_error">#</a></span></h3>
+<span class="hljs-keyword">const</span> { findSourceMap, <span class="hljs-title class_">SourceMap</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);</code></pre>
+<!-- Anchors to make sure old links find a target -->
+<p><a id="module_module_findsourcemap_path_error"></a></p>
+<h4><code>module.findSourceMap(path)</code><span><a class="mark" href="#module_module_findsourcemap_path" id="module_module_findsourcemap_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v13.7.0, v12.17.0</span>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li>Returns: <a href="modules_module.html#modules_module_class_module_sourcemap" class="type">&#x3C;module.SourceMap></a></li>
+<li>Returns: <a href="#module_class_module_sourcemap" class="type">&#x3C;module.SourceMap></a></li>
 </ul>
 <p><code>path</code> is the resolved path for the file for which a corresponding source map
 should be fetched.</p>
-<p>The <code>error</code> instance should be passed as the second parameter to <code>findSourceMap</code>
-in exceptional flows, such as when an overridden
-<a href="https://v8.dev/docs/stack-trace-api#customizing-stack-traces"><code>Error.prepareStackTrace(error, trace)</code></a> is invoked. Modules are not added to
-the module cache until they are successfully loaded. In these cases, source maps
-are associated with the <code>error</code> instance along with the <code>path</code>.</p>
-<h3>Class: <code>module.SourceMap</code><span><a class="mark" href="#module_class_module_sourcemap" id="module_class_module_sourcemap">#</a></span></h3>
+<h4>Class: <code>module.SourceMap</code><span><a class="mark" href="#module_class_module_sourcemap" id="module_class_module_sourcemap">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v13.7.0, v12.17.0</span>
 </div>
-<h4><code>new SourceMap(payload)</code><span><a class="mark" href="#module_new_sourcemap_payload" id="module_new_sourcemap_payload">#</a></span></h4>
+<h5><code>new SourceMap(payload)</code><span><a class="mark" href="#module_new_sourcemap_payload" id="module_new_sourcemap_payload">#</a></span></h5>
 <ul>
 <li><code>payload</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
@@ -43110,12 +46645,12 @@ are associated with the <code>error</code> instance along with the <code>path</c
 <li><code>mappings</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>sourceRoot</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<h4><code>sourceMap.payload</code><span><a class="mark" href="#module_sourcemap_payload" id="module_sourcemap_payload">#</a></span></h4>
+<h5><code>sourceMap.payload</code><span><a class="mark" href="#module_sourcemap_payload" id="module_sourcemap_payload">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>Getter for the payload used to construct the <a href="#module_class_module_sourcemap"><code>SourceMap</code></a> instance.</p>
-<h4><code>sourceMap.findEntry(lineNumber, columnNumber)</code><span><a class="mark" href="#module_sourcemap_findentry_linenumber_columnnumber" id="module_sourcemap_findentry_linenumber_columnnumber">#</a></span></h4>
+<h5><code>sourceMap.findEntry(lineNumber, columnNumber)</code><span><a class="mark" href="#module_sourcemap_findentry_linenumber_columnnumber" id="module_sourcemap_findentry_linenumber_columnnumber">#</a></span></h5>
 <ul>
 <li><code>lineNumber</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 <li><code>columnNumber</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
@@ -43130,20 +46665,23 @@ consists of the following keys:</p>
 <li>originalSource: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>originalLine: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 <li>originalColumn: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-<h1>Modules: Packages<span><a class="mark" href="#packages_modules_packages" id="packages_modules_packages">#</a></span></h1>
+<li>name: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul></section>
+        </section>
+<section><h2>Modules: Packages<span><a class="mark" href="#packages_modules_packages" id="packages_modules_packages">#</a></span></h2>
+
 
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.20.0</td>
+<tr><td>v14.13.0</td>
 <td><p>Add support for <code>"exports"</code> patterns.</p></td></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.6.0, v12.19.0</td>
 <td><p>Add package <code>"imports"</code> field.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.7.0, v12.16.0</td>
 <td><p>Unflag conditional exports.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.6.0, v12.16.0</td>
 <td><p>Unflag self-referencing a package using its name.</p></td></tr>
 <tr><td>v12.7.0</td>
 <td><p>Introduce <code>"exports"</code> <code>package.json</code> field as a more powerful alternative to the classic <code>"main"</code> field.</p></td></tr>
@@ -43152,14 +46690,14 @@ consists of the following keys:</p>
 </tbody></table>
 </details>
 </div>
-<h2>Introduction<span><a class="mark" href="#packages_introduction" id="packages_introduction">#</a></span></h2>
+<section><h3>Introduction<span><a class="mark" href="#packages_introduction" id="packages_introduction">#</a></span></h3>
 <p>A package is a folder tree described by a <code>package.json</code> file. The package
 consists of the folder containing the <code>package.json</code> file and all subfolders
 until the next folder containing another <code>package.json</code> file, or a folder
 named <code>node_modules</code>.</p>
 <p>This page provides guidance for package authors writing <code>package.json</code> files
 along with a reference for the <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> fields defined by Node.js.</p>
-<h2>Determining module system<span><a class="mark" href="#packages_determining_module_system" id="packages_determining_module_system">#</a></span></h2>
+</section><section><h3>Determining module system<span><a class="mark" href="#packages_determining_module_system" id="packages_determining_module_system">#</a></span></h3>
 <p>Node.js will treat the following as <a href="esm.html">ES modules</a> when passed to <code>node</code> as the
 initial input, or when referenced by <code>import</code> statements within ES module code:</p>
 <ul>
@@ -43200,7 +46738,7 @@ all sources are CommonJS. Being explicit about the <code>type</code> of the pack
 future-proof the package in case the default type of Node.js ever changes, and
 it will also make things easier for build tools and loaders to determine how the
 files in the package should be interpreted.</p>
-<h3><code>package.json</code> and file extensions<span><a class="mark" href="#packages_package_json_and_file_extensions" id="packages_package_json_and_file_extensions">#</a></span></h3>
+<h4><code>package.json</code> and file extensions<span><a class="mark" href="#packages_package_json_and_file_extensions" id="packages_package_json_and_file_extensions">#</a></span></h4>
 <p>Within a package, the <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> <a href="#packages_type"><code>"type"</code></a> field defines how
 Node.js should interpret <code>.js</code> files. If a <code>package.json</code> file does not have a
 <code>"type"</code> field, <code>.js</code> files are treated as <a href="modules.html">CommonJS</a>.</p>
@@ -43247,7 +46785,10 @@ extension (since both <code>.js</code> and <code>.cjs</code> files are treated a
 <code>"commonjs"</code> package).</p>
 </li>
 </ul>
-<h3><code>--input-type</code> flag<span><a class="mark" href="#packages_input_type_flag" id="packages_input_type_flag">#</a></span></h3>
+<h4><code>--input-type</code> flag<span><a class="mark" href="#packages_input_type_flag" id="packages_input_type_flag">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.0.0</span>
+</div>
 <p>Strings passed in as an argument to <code>--eval</code> (or <code>-e</code>), or piped to <code>node</code> via
 <code>STDIN</code>, are treated as <a href="esm.html">ES modules</a> when the <code>--input-type=module</code> flag
 is set.</p>
@@ -43257,7 +46798,7 @@ is set.</p>
 <p>For completeness there is also <code>--input-type=commonjs</code>, for explicitly running
 string input as CommonJS. This is the default behavior if <code>--input-type</code> is
 unspecified.</p>
-<h2>Package entry points<span><a class="mark" href="#packages_package_entry_points" id="packages_package_entry_points">#</a></span></h2>
+</section><section><h3>Package entry points<span><a class="mark" href="#packages_package_entry_points" id="packages_package_entry_points">#</a></span></h3>
 <p>In a package’s <code>package.json</code> file, two fields can define entry points for a
 package: <a href="#packages_main"><code>"main"</code></a> and <a href="#packages_exports"><code>"exports"</code></a>. The <a href="#packages_main"><code>"main"</code></a> field is supported
 in all versions of Node.js, but its capabilities are limited: it only defines
@@ -43287,46 +46828,46 @@ previously supported entry point is exported. It is best to explicitly specify
 entry points so that the package’s public API is well-defined. For example,
 a project that previous exported <code>main</code>, <code>lib</code>,
 <code>feature</code>, and the <code>package.json</code> could use the following <code>package.exports</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"name"</span>: <span class="hljs-string">"my-mod"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib"</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib/index"</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib/index.js"</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./feature"</span>: <span class="hljs-string">"./feature/index.js"</span>,
-    <span class="hljs-attr">"./feature/index.js"</span>: <span class="hljs-string">"./feature/index.js"</span>,
-    <span class="hljs-attr">"./package.json"</span>: <span class="hljs-string">"./package.json"</span>
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"my-mod"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib/index"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib/index.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature/index.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./package.json"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./package.json"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Alternatively a project could choose to export entire folders:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"name"</span>: <span class="hljs-string">"my-mod"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib"</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib/*"</span>: <span class="hljs-string">"./lib/*.js"</span>,
-    <span class="hljs-attr">"./feature"</span>: <span class="hljs-string">"./feature/index.js"</span>,
-    <span class="hljs-attr">"./feature/*"</span>: <span class="hljs-string">"./feature/*.js"</span>,
-    <span class="hljs-attr">"./package.json"</span>: <span class="hljs-string">"./package.json"</span>
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"my-mod"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/*.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature/*.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./package.json"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./package.json"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>As a last resort, package encapsulation can be disabled entirely by creating an
 export for the root of the package <code>"./*": "./*"</code>. This exposes every file
 in the package at the cost of disabling the encapsulation and potential tooling
 benefits this provides. As the ES Module loader in Node.js enforces the use of
-<a href="esm.md#esm_mandatory_file_extensions">the full specifier path</a>, exporting the root rather than being explicit
+<a href="#esm_mandatory_file_extensions">the full specifier path</a>, exporting the root rather than being explicit
 about entry is less expressive than either of the prior examples. Not only
 is encapsulation lost but module consumers are unable to
 <code>import feature from 'my-mod/feature'</code> as they need to provide the full
 path <code>import feature from 'my-mod/feature/index.js</code>.</p>
-<h3>Main entry point export<span><a class="mark" href="#packages_main_entry_point_export" id="packages_main_entry_point_export">#</a></span></h3>
+<h4>Main entry point export<span><a class="mark" href="#packages_main_entry_point_export" id="packages_main_entry_point_export">#</a></span></h4>
 <p>To set the main entry point for a package, it is advisable to define both
 <a href="#packages_exports"><code>"exports"</code></a> and <a href="#packages_main"><code>"main"</code></a> in the package’s <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>,
-  <span class="hljs-attr">"exports"</span>: <span class="hljs-string">"./main.js"</span>
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>When the <a href="#packages_exports"><code>"exports"</code></a> field is defined, all subpaths of the package are
 encapsulated and no longer available to importers. For example,
 <code>require('pkg/subpath.js')</code> throws an <a href="#errors_err_package_path_not_exported"><code>ERR_PACKAGE_PATH_NOT_EXPORTED</code></a>
@@ -43336,26 +46877,30 @@ about package interfaces for tools and when handling semver upgrades for a
 package. It is not a strong encapsulation since a direct require of any
 absolute subpath of the package such as
 <code>require('/path/to/node_modules/pkg/subpath.js')</code> will still load <code>subpath.js</code>.</p>
-<h3>Subpath exports<span><a class="mark" href="#packages_subpath_exports" id="packages_subpath_exports">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<h4>Subpath exports<span><a class="mark" href="#packages_subpath_exports" id="packages_subpath_exports">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.7.0</span>
+</div>
 <p>When using the <a href="#packages_exports"><code>"exports"</code></a> field, custom subpaths can be defined along
 with the main entry point by treating the main entry point as the
 <code>"."</code> subpath:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./main.js"</span>,
-    <span class="hljs-attr">"./submodule"</span>: <span class="hljs-string">"./src/submodule.js"</span>
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./submodule"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./src/submodule.js"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Now only the defined subpath in <a href="#packages_exports"><code>"exports"</code></a> can be imported by a consumer:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> submodule <span class="hljs-keyword">from</span> <span class="hljs-string">'es-module-package/submodule'</span>;
 <span class="hljs-comment">// Loads ./node_modules/es-module-package/src/submodule.js</span></code></pre>
 <p>While other subpaths will error:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> submodule <span class="hljs-keyword">from</span> <span class="hljs-string">'es-module-package/private-module.js'</span>;
 <span class="hljs-comment">// Throws ERR_PACKAGE_PATH_NOT_EXPORTED</span></code></pre>
-<h3>Subpath imports<span><a class="mark" href="#packages_subpath_imports" id="packages_subpath_imports">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<h4>Subpath imports<span><a class="mark" href="#packages_subpath_imports" id="packages_subpath_imports">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.6.0, v12.19.0</span>
+</div>
 <p>In addition to the <a href="#packages_exports"><code>"exports"</code></a> field, it is possible to define internal
 package import maps that only apply to import specifiers from within the package
 itself.</p>
@@ -43364,17 +46909,17 @@ disambiguated from package specifiers.</p>
 <p>For example, the imports field can be used to gain the benefits of conditional
 exports for internal modules:</p>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"imports"</span>: {
-    <span class="hljs-attr">"#dep"</span>: {
-      <span class="hljs-attr">"node"</span>: <span class="hljs-string">"dep-node-native"</span>,
-      <span class="hljs-attr">"default"</span>: <span class="hljs-string">"./dep-polyfill.js"</span>
-    }
-  },
-  <span class="hljs-attr">"dependencies"</span>: {
-    <span class="hljs-attr">"dep-node-native"</span>: <span class="hljs-string">"^1.0.0"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"imports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"#dep"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"dep-node-native"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"default"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./dep-polyfill.js"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"dep-node-native"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"^1.0.0"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>where <code>import '#dep'</code> does not get the resolution of the external package
 <code>dep-node-native</code> (including its exports in turn), and instead gets the local
 file <code>./dep-polyfill.js</code> relative to the package in other environments.</p>
@@ -43382,22 +46927,26 @@ file <code>./dep-polyfill.js</code> relative to the package in other environment
 packages.</p>
 <p>The resolution rules for the imports field are otherwise
 analogous to the exports field.</p>
-<h3>Subpath patterns<span><a class="mark" href="#packages_subpath_patterns" id="packages_subpath_patterns">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<h4>Subpath patterns<span><a class="mark" href="#packages_subpath_patterns" id="packages_subpath_patterns">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.13.0, v12.20.0</span>
+</div>
 <p>For packages with a small number of exports or imports, we recommend
 explicitly listing each exports subpath entry. But for packages that have
 large numbers of subpaths, this might cause <code>package.json</code> bloat and
 maintenance issues.</p>
 <p>For these use cases, subpath export patterns can be used instead:</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/es-module-package/package.json</span>
-{
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"./features/*"</span>: <span class="hljs-string">"./src/features/*.js"</span>
-  },
-  <span class="hljs-attr">"imports"</span>: {
-    <span class="hljs-attr">"#internal/*"</span>: <span class="hljs-string">"./src/internal/*.js"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./features/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./src/features/*.js"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"imports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"#internal/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./src/internal/*.js"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p><strong><code>*</code> maps expose nested subpaths as it is a string replacement syntax
+only.</strong></p>
 <p>The left hand matching pattern must always end in <code>*</code>. All instances of <code>*</code> on
 the right hand side will then be replaced with this value, including if it
 contains any <code>/</code> separators.</p>
@@ -43417,37 +46966,62 @@ patterns since the individual exports for a package can be determined by
 treating the right hand side target pattern as a <code>**</code> glob against the list of
 files within the package. Because <code>node_modules</code> paths are forbidden in exports
 targets, this expansion is dependent on only the files of the package itself.</p>
-<h3>Exports sugar<span><a class="mark" href="#packages_exports_sugar" id="packages_exports_sugar">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>To exclude private subfolders from patterns, <code>null</code> targets can be used:</p>
+<pre><code class="language-json"><span class="hljs-comment">// ./node_modules/es-module-package/package.json</span>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./features/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./src/features/*.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./features/private-internal/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">null</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> featureInternal <span class="hljs-keyword">from</span> <span class="hljs-string">'es-module-package/features/private-internal/m'</span>;
+<span class="hljs-comment">// Throws: ERR_PACKAGE_PATH_NOT_EXPORTED</span>
+
+<span class="hljs-keyword">import</span> featureX <span class="hljs-keyword">from</span> <span class="hljs-string">'es-module-package/features/x'</span>;
+<span class="hljs-comment">// Loads ./node_modules/es-module-package/src/features/x.js</span></code></pre>
+<h4>Exports sugar<span><a class="mark" href="#packages_exports_sugar" id="packages_exports_sugar">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.11.0</span>
+</div>
 <p>If the <code>"."</code> export is the only export, the <a href="#packages_exports"><code>"exports"</code></a> field provides sugar
 for this case being the direct <a href="#packages_exports"><code>"exports"</code></a> field value.</p>
 <p>If the <code>"."</code> export has a fallback array or string value, then the
 <a href="#packages_exports"><code>"exports"</code></a> field can be set to this value directly.</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./main.js"</span>
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>can be written:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"exports"</span>: <span class="hljs-string">"./main.js"</span>
-}</code></pre>
-<h3>Conditional exports<span><a class="mark" href="#packages_conditional_exports" id="packages_conditional_exports">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h4>Conditional exports<span><a class="mark" href="#packages_conditional_exports" id="packages_conditional_exports">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p><span>Added in: v13.2.0, v12.16.0</span></p></td></tr>
+<tr><td>v13.7.0, v12.16.0</td>
+<td><p>Unflag conditional exports.</p></td></tr>
+</tbody></table>
+</details>
+</div>
 <p>Conditional exports provide a way to map to different paths depending on
 certain conditions. They are supported for both CommonJS and ES module imports.</p>
 <p>For example, a package that wants to provide different ES module exports for
 <code>require()</code> and <code>import</code> can be written:</p>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main-require.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"import"</span>: <span class="hljs-string">"./main-module.js"</span>,
-    <span class="hljs-attr">"require"</span>: <span class="hljs-string">"./main-require.cjs"</span>
-  },
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>
-}</code></pre>
-<p>Node.js supports the following conditions out of the box:</p>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main-require.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main-module.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"require"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main-require.cjs"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>Node.js implements the following conditions:</p>
 <ul>
 <li><code>"import"</code> - matches when the package is loaded via <code>import</code> or
 <code>import()</code>, or via any top-level import or resolve operation by the
@@ -43469,23 +47043,19 @@ or ES module file. <em>This condition should always come last.</em></li>
 matching, earlier entries have higher priority and take precedence over later
 entries. <em>The general rule is that conditions should be from most specific to
 least specific in object order</em>.</p>
-<p>Other conditions such as <code>"browser"</code>, <code>"electron"</code>, <code>"deno"</code>, <code>"react-native"</code>,
-etc., are unknown to Node.js, and thus ignored. Runtimes or tools other than
-Node.js can use them at their discretion. Further restrictions, definitions, or
-guidance on condition names might occur in the future.</p>
 <p>Using the <code>"import"</code> and <code>"require"</code> conditions can lead to some hazards,
 which are further explained in <a href="#packages_dual_commonjs_es_module_packages">the dual CommonJS/ES module packages section</a>.</p>
 <p>Conditional exports can also be extended to exports subpaths, for example:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./main.js"</span>,
-    <span class="hljs-attr">"./feature"</span>: {
-      <span class="hljs-attr">"node"</span>: <span class="hljs-string">"./feature-node.js"</span>,
-      <span class="hljs-attr">"default"</span>: <span class="hljs-string">"./feature.js"</span>
-    }
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature-node.js"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"default"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature.js"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Defines a package where <code>require('pkg/feature')</code> and <code>import 'pkg/feature'</code>
 could provide different implementations between Node.js and other JS
 environments.</p>
@@ -43496,26 +47066,28 @@ these JS environments from having to pretend to be existing environments in
 order to support packages with conditional exports. For this reason, using
 <code>"node"</code> and <code>"default"</code> condition branches is usually preferable to using
 <code>"node"</code> and <code>"browser"</code> condition branches.</p>
-<h3>Nested conditions<span><a class="mark" href="#packages_nested_conditions" id="packages_nested_conditions">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<h4>Nested conditions<span><a class="mark" href="#packages_nested_conditions" id="packages_nested_conditions">#</a></span></h4>
 <p>In addition to direct mappings, Node.js also supports nested condition objects.</p>
 <p>For example, to define a package that only has dual mode entry points for
 use in Node.js but not the browser:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"node"</span>: {
-      <span class="hljs-attr">"import"</span>: <span class="hljs-string">"./feature-node.mjs"</span>,
-      <span class="hljs-attr">"require"</span>: <span class="hljs-string">"./feature-node.cjs"</span>
-    },
-    <span class="hljs-attr">"default"</span>: <span class="hljs-string">"./feature.mjs"</span>,
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature-node.mjs"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"require"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature-node.cjs"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"default"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature.mjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Conditions continue to be matched in order as with flat conditions. If
 a nested conditional does not have any mapping it will continue checking
 the remaining conditions of the parent condition. In this way nested
 conditions behave analogously to nested JavaScript <code>if</code> statements.</p>
-<h3>Resolving user conditions<span><a class="mark" href="#packages_resolving_user_conditions" id="packages_resolving_user_conditions">#</a></span></h3>
+<h4>Resolving user conditions<span><a class="mark" href="#packages_resolving_user_conditions" id="packages_resolving_user_conditions">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.9.0, v12.19.0</span>
+</div>
 <p>When running Node.js, custom user conditions can be added with the
 <code>--conditions</code> flag:</p>
 <pre><code class="language-bash">node --conditions=development main.js</code></pre>
@@ -43523,18 +47095,68 @@ conditions behave analogously to nested JavaScript <code>if</code> statements.</
 exports, while resolving the existing <code>"node"</code>, <code>"default"</code>, <code>"import"</code>, and
 <code>"require"</code> conditions as appropriate.</p>
 <p>Any number of custom conditions can be set with repeat flags.</p>
-<h3>Self-referencing a package using its name<span><a class="mark" href="#packages_self_referencing_a_package_using_its_name" id="packages_self_referencing_a_package_using_its_name">#</a></span></h3>
+<h4>Conditions Definitions<span><a class="mark" href="#packages_conditions_definitions" id="packages_conditions_definitions">#</a></span></h4>
+<p>The <code>"import"</code>, <code>"require"</code>, <code>"node"</code> and <code>"default"</code> conditions are defined
+and implemented in Node.js core,
+<a href="#packages_conditional_exports">as specified above</a>.</p>
+<p>Other condition strings are unknown to Node.js and thus ignored by default.
+Runtimes or tools other than Node.js can use them at their discretion.</p>
+<p>These user conditions can be enabled in Node.js via the <a href="#packages_resolving_user_conditions"><code>--conditions</code>
+flag</a>.</p>
+<p>The following condition definitions are currently endorsed by Node.js:</p>
+<ul>
+<li><code>"browser"</code> - any environment which implements a standard subset of global
+browser APIs available from JavaScript in web browsers, including the DOM
+APIs.</li>
+<li><code>"development"</code> - can be used to define a development-only environment
+entry point. <em>Must always be mutually exclusive with <code>"production"</code>.</em></li>
+<li><code>"production"</code> - can be used to define a production environment entry
+point. <em>Must always be mutually exclusive with <code>"development"</code>.</em></li>
+</ul>
+<p>The above user conditions can be enabled in Node.js via the <a href="#packages_resolving_user_conditions"><code>--conditions</code>
+flag</a>.</p>
+<p>Platform specific conditions such as <code>"deno"</code>, <code>"electron"</code>, or <code>"react-native"</code>
+may be used, but while there remain no implementation or integration intent
+from these platforms, the above are not explicitly endorsed by Node.js.</p>
+<p>New conditions definitions may be added to this list by creating a pull request
+to the <a href="https://github.com/nodejs/node/blob/HEAD/doc/api/packages.md#conditions-definitions">Node.js documentation for this section</a>. The requirements for listing
+a new condition definition here are that:</p>
+<ul>
+<li>The definition should be clear and unambiguous for all implementers.</li>
+<li>The use case for why the condition is needed should be clearly justified.</li>
+<li>There should exist sufficient existing implementation usage.</li>
+<li>The condition name should not conflict with another condition definition or
+condition in wide usage.</li>
+<li>The listing of the condition definition should provide a coordination
+benefit to the ecosystem that wouldn't otherwise be possible. For example,
+this would not necessarily be the case for company-specific or
+application-specific conditions.</li>
+</ul>
+<p>The above definitions may be moved to a dedicated conditions registry in due
+course.</p>
+<h4>Self-referencing a package using its name<span><a class="mark" href="#packages_self_referencing_a_package_using_its_name" id="packages_self_referencing_a_package_using_its_name">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p><span>Added in: v13.1.0, v12.16.0</span></p></td></tr>
+<tr><td>v13.6.0, v12.16.0</td>
+<td><p>Unflag self-referencing a package using its name.</p></td></tr>
+</tbody></table>
+</details>
+</div>
 <p>Within a package, the values defined in the package’s
 <code>package.json</code> <a href="#packages_exports"><code>"exports"</code></a> field can be referenced via the package’s name.
 For example, assuming the <code>package.json</code> is:</p>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"name"</span>: <span class="hljs-string">"a-package"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./main.mjs"</span>,
-    <span class="hljs-attr">"./foo"</span>: <span class="hljs-string">"./foo.js"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"a-package"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.mjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./foo"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./foo.js"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Then any module <em>in that package</em> can reference an export in the package itself:</p>
 <pre><code class="language-js"><span class="hljs-comment">// ./a-module.mjs</span>
 <span class="hljs-keyword">import</span> { something } <span class="hljs-keyword">from</span> <span class="hljs-string">'a-package'</span>; <span class="hljs-comment">// Imports "something" from ./main.mjs.</span></code></pre>
@@ -43550,9 +47172,22 @@ error:</p>
 <span class="hljs-keyword">import</span> { another } <span class="hljs-keyword">from</span> <span class="hljs-string">'a-package/m.mjs'</span>;</code></pre>
 <p>Self-referencing is also available when using <code>require</code>, both in an ES module,
 and in a CommonJS one. For example, this code will also work:</p>
-<pre><code class="language-js"><span class="hljs-comment">// ./a-module.js</span>
+<pre><code class="language-js cjs"><span class="hljs-comment">// ./a-module.js</span>
 <span class="hljs-keyword">const</span> { something } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'a-package/foo'</span>); <span class="hljs-comment">// Loads from ./foo.js.</span></code></pre>
-<h2>Dual CommonJS/ES module packages<span><a class="mark" href="#packages_dual_commonjs_es_module_packages" id="packages_dual_commonjs_es_module_packages">#</a></span></h2>
+<p>Finally, self-referencing also works with scoped packages. For example, this
+code will also work:</p>
+<pre><code class="language-json"><span class="hljs-comment">// package.json</span>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"@my/package"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><pre><code class="language-js cjs"><span class="hljs-comment">// ./index.js</span>
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-number">42</span>;</code></pre><code class="language-js cjs"><span class="hljs-comment">// ./other.js</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'@my/package'</span>));</code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node other.js</span>
+42</code></pre>
+</section><section><h3>Dual CommonJS/ES module packages<span><a class="mark" href="#packages_dual_commonjs_es_module_packages" id="packages_dual_commonjs_es_module_packages">#</a></span></h3>
 <p>Prior to the introduction of support for ES modules in Node.js, it was a common
 pattern for package authors to include both CommonJS and ES module JavaScript
 sources in their package, with <code>package.json</code> <a href="#packages_main"><code>"main"</code></a> specifying the
@@ -43568,7 +47203,7 @@ exports</a>). Unlike in the scenario where <code>"module"</code> is only used by
 or ES module files are transpiled into CommonJS on the fly before evaluation by
 Node.js, the files referenced by the ES module entry point are evaluated as ES
 modules.</p>
-<h3>Dual package hazard<span><a class="mark" href="#packages_dual_package_hazard" id="packages_dual_package_hazard">#</a></span></h3>
+<h4>Dual package hazard<span><a class="mark" href="#packages_dual_package_hazard" id="packages_dual_package_hazard">#</a></span></h4>
 <p>When an application is using a package that provides both CommonJS and ES module
 sources, there is a risk of certain bugs if both versions of the package get
 loaded. This potential comes from the fact that the <code>pkgInstance</code> created by
@@ -43588,7 +47223,7 @@ the other. This differs from how <code>import</code> and <code>require</code> st
 all-CommonJS or all-ES module environments, respectively, and therefore is
 surprising to users. It also differs from the behavior users are familiar with
 when using transpilation via tools like <a href="https://babeljs.io/">Babel</a> or <a href="https://github.com/standard-things/esm#readme"><code>esm</code></a>.</p>
-<h3>Writing dual packages while avoiding or minimizing hazards<span><a class="mark" href="#packages_writing_dual_packages_while_avoiding_or_minimizing_hazards" id="packages_writing_dual_packages_while_avoiding_or_minimizing_hazards">#</a></span></h3>
+<h4>Writing dual packages while avoiding or minimizing hazards<span><a class="mark" href="#packages_writing_dual_packages_while_avoiding_or_minimizing_hazards" id="packages_writing_dual_packages_while_avoiding_or_minimizing_hazards">#</a></span></h4>
 <p>First, the hazard described in the previous section occurs when a package
 contains both CommonJS and ES module sources and both sources are provided for
 use in Node.js, either via separate main entry points or exported paths. A
@@ -43616,30 +47251,30 @@ than <code>import pkg from 'pkg'; pkg.name</code>.</li>
 browsers.</li>
 <li>The hazards described in the previous section are avoided or minimized.</li>
 </ol>
-<h4>Approach #1: Use an ES module wrapper<span><a class="mark" href="#packages_approach_1_use_an_es_module_wrapper" id="packages_approach_1_use_an_es_module_wrapper">#</a></span></h4>
+<h5>Approach #1: Use an ES module wrapper<span><a class="mark" href="#packages_approach_1_use_an_es_module_wrapper" id="packages_approach_1_use_an_es_module_wrapper">#</a></span></h5>
 <p>Write the package in CommonJS or transpile ES module sources into CommonJS, and
 create an ES module wrapper file that defines the named exports. Using
 <a href="#packages_conditional_exports">Conditional exports</a>, the ES module wrapper is used for <code>import</code> and the
 CommonJS entry point for <code>require</code>.</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/pkg/package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>,
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./index.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"import"</span>: <span class="hljs-string">"./wrapper.mjs"</span>,
-    <span class="hljs-attr">"require"</span>: <span class="hljs-string">"./index.cjs"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./wrapper.mjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"require"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>The preceding example uses explicit extensions <code>.mjs</code> and <code>.cjs</code>.
 If your files use the <code>.js</code> extension, <code>"type": "module"</code> will cause such files
 to be treated as ES modules, just as <code>"type": "commonjs"</code> would cause them
 to be treated as CommonJS.
 See <a href="#esm_enabling">Enabling</a>.</p>
-<pre><code class="language-js"><span class="hljs-comment">// ./node_modules/pkg/index.cjs</span>
-<span class="hljs-built_in">exports</span>.name = <span class="hljs-string">'value'</span>;</code></pre>
+<pre><code class="language-js cjs"><span class="hljs-comment">// ./node_modules/pkg/index.cjs</span>
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">name</span> = <span class="hljs-string">'value'</span>;</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// ./node_modules/pkg/wrapper.mjs</span>
 <span class="hljs-keyword">import</span> cjsModule <span class="hljs-keyword">from</span> <span class="hljs-string">'./index.cjs'</span>;
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> name = cjsModule.name;</code></pre>
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> name = cjsModule.<span class="hljs-property">name</span>;</code></pre>
 <p>In this example, the <code>name</code> from <code>import { name } from 'pkg'</code> is the same
 singleton as the <code>name</code> from <code>const { name } = require('pkg')</code>. Therefore <code>===</code>
 returns <code>true</code> when comparing the two <code>name</code>s and the divergent specifier hazard
@@ -43650,7 +47285,7 @@ or if support in the wrapper for the <code>import pkg from 'pkg'</code> pattern
 then the wrapper would instead be written to export the default optionally
 along with any named exports as well:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> cjsModule <span class="hljs-keyword">from</span> <span class="hljs-string">'./index.cjs'</span>;
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> name = cjsModule.name;
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> name = cjsModule.<span class="hljs-property">name</span>;
 <span class="hljs-keyword">export</span> <span class="hljs-keyword">default</span> cjsModule;</code></pre>
 <p>This approach is appropriate for any of the following use cases:</p>
 <ul>
@@ -43674,26 +47309,26 @@ application, such as by dependencies; or if the CommonJS version can be loaded
 but doesn’t affect the ES module version (for example, because the package is
 stateless):</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/pkg/package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>,
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./index.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./index.cjs"</span>,
-    <span class="hljs-attr">"./module"</span>: <span class="hljs-string">"./wrapper.mjs"</span>
-  }
-}</code></pre>
-<h4>Approach #2: Isolate state<span><a class="mark" href="#packages_approach_2_isolate_state" id="packages_approach_2_isolate_state">#</a></span></h4>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./module"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./wrapper.mjs"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h5>Approach #2: Isolate state<span><a class="mark" href="#packages_approach_2_isolate_state" id="packages_approach_2_isolate_state">#</a></span></h5>
 <p>A <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file can define the separate CommonJS and ES module entry
 points directly:</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/pkg/package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>,
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./index.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"import"</span>: <span class="hljs-string">"./index.mjs"</span>,
-    <span class="hljs-attr">"require"</span>: <span class="hljs-string">"./index.cjs"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.mjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"require"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>This can be done if both the CommonJS and ES module versions of the package are
 equivalent, for example because one is the transpiled output of the other; and
 the package’s management of state is carefully isolated (or the package is
@@ -43713,8 +47348,8 @@ CommonJS and ES module instances of the package:</p>
 <p>If possible, contain all state within an instantiated object. JavaScript’s
 <code>Date</code>, for example, needs to be instantiated to contain state; if it were a
 package, it would be used like this:</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-built_in">Date</span> <span class="hljs-keyword">from</span> <span class="hljs-string">'date'</span>;
-<span class="hljs-keyword">const</span> someDate = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>();
+<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-title class_">Date</span> <span class="hljs-keyword">from</span> <span class="hljs-string">'date'</span>;
+<span class="hljs-keyword">const</span> someDate = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>();
 <span class="hljs-comment">// someDate contains state; Date does not</span></code></pre>
 <p>The <code>new</code> keyword isn’t required; a package’s function can return a new
 object, or modify a passed-in object, to keep the state external to the
@@ -43724,9 +47359,9 @@ package.</p>
 <p>Isolate the state in one or more CommonJS files that are shared between the
 CommonJS and ES module versions of the package. For example, if the CommonJS
 and ES module entry points are <code>index.cjs</code> and <code>index.mjs</code>, respectively:</p>
-<pre><code class="language-js"><span class="hljs-comment">// ./node_modules/pkg/index.cjs</span>
+<pre><code class="language-js cjs"><span class="hljs-comment">// ./node_modules/pkg/index.cjs</span>
 <span class="hljs-keyword">const</span> state = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./state.cjs'</span>);
-<span class="hljs-built_in">module</span>.exports.state = state;</code></pre>
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-property">state</span> = state;</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// ./node_modules/pkg/index.mjs</span>
 <span class="hljs-keyword">import</span> state <span class="hljs-keyword">from</span> <span class="hljs-string">'./state.cjs'</span>;
 <span class="hljs-keyword">export</span> {
@@ -43756,15 +47391,15 @@ execution between the CommonJS and ES module versions of a package.</p>
 conditional exports for consumers could be to add an export, e.g.
 <code>"./module"</code>, to point to an all-ES module-syntax version of the package:</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/pkg/package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>,
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./index.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./index.cjs"</span>,
-    <span class="hljs-attr">"./module"</span>: <span class="hljs-string">"./index.mjs"</span>
-  }
-}</code></pre>
-<h2>Node.js <code>package.json</code> field definitions<span><a class="mark" href="#packages_node_js_package_json_field_definitions" id="packages_node_js_package_json_field_definitions">#</a></span></h2>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./module"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.mjs"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+</section><section><h3>Node.js <code>package.json</code> field definitions<span><a class="mark" href="#packages_node_js_package_json_field_definitions" id="packages_node_js_package_json_field_definitions">#</a></span></h3>
 <p>This section describes the fields used by the Node.js runtime. Other tools (such
 as <a href="https://docs.npmjs.com/creating-a-package-json-file">npm</a>) use
 additional fields which are ignored by Node.js and not documented here.</p>
@@ -43772,44 +47407,60 @@ additional fields which are ignored by Node.js and not documented here.</p>
 <ul>
 <li><a href="#packages_name"><code>"name"</code></a> - Relevant when using named imports within a package. Also used
 by package managers as the name of the package.</li>
+<li><a href="#packages_main"><code>"main"</code></a> - The default module when loading the package, if exports is not
+specified, and in versions of Node.js prior to the introduction of exports.</li>
 <li><a href="#packages_type"><code>"type"</code></a> - The package type determining whether to load <code>.js</code> files as
 CommonJS or ES modules.</li>
 <li><a href="#packages_exports"><code>"exports"</code></a> - Package exports and conditional exports. When present,
 limits which submodules can be loaded from within the package.</li>
-<li><a href="#packages_main"><code>"main"</code></a> - The default module when loading the package, if exports is not
-specified, and in versions of Node.js prior to the introduction of exports.</li>
 <li><a href="#packages_imports"><code>"imports"</code></a> - Package imports, for use by modules within the package
 itself.</li>
 </ul>
-<h3><code>"name"</code><span><a class="mark" href="#packages_name" id="packages_name">#</a></span></h3>
+<h4><code>"name"</code><span><a class="mark" href="#packages_name" id="packages_name">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p><span>Added in: v13.1.0, v12.16.0</span></p></td></tr>
+<tr><td>v13.6.0, v12.16.0</td>
 <td><p>Remove the <code>--experimental-resolve-self</code> option.</p></td></tr>
-<tr><td>v12.16.0</td>
-<td><p><span>Added in: v12.16.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"name"</span>: <span class="hljs-string">"package-name"</span>
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"package-name"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>The <code>"name"</code> field defines your package’s name. Publishing to the
 <em>npm</em> registry requires a name that satisfies
 <a href="https://docs.npmjs.com/files/package.json#name">certain requirements</a>.</p>
 <p>The <code>"name"</code> field can be used in addition to the <a href="#packages_exports"><code>"exports"</code></a> field to
 <a href="#packages_self_referencing_a_package_using_its_name">self-reference</a> a package using its name.</p>
-<h3><code>"type"</code><span><a class="mark" href="#packages_type" id="packages_type">#</a></span></h3>
+<h4><code>"main"</code><span><a class="mark" href="#packages_main" id="packages_main">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>The <code>"main"</code> field defines the script that is used when the <a href="#modules_folders_as_modules">package directory
+is loaded via <code>require()</code></a>. Its value
+is a path.</p>
+<pre><code class="language-js cjs"><span class="hljs-built_in">require</span>(<span class="hljs-string">'./path/to/directory'</span>); <span class="hljs-comment">// This resolves to ./path/to/directory/main.js.</span></code></pre>
+<p>When a package has an <a href="#packages_exports"><code>"exports"</code></a> field, this will take precedence over the
+<code>"main"</code> field when importing the package by name.</p>
+<h4><code>"type"</code><span><a class="mark" href="#packages_type" id="packages_type">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.2.0, v12.17.0</td>
 <td><p>Unflag <code>--experimental-modules</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p><span>Added in: v12.0.0</span></p></td></tr>
@@ -43828,9 +47479,9 @@ itself.</li>
 when searching in the current folder, that folder’s parent, and so on up
 until a node_modules folder or the volume root is reached.</p>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <pre><code class="language-bash"><span class="hljs-comment"># In same folder as preceding package.json</span>
 node my-app.js <span class="hljs-comment"># Runs as ES module</span></code></pre>
 <p>If the nearest parent <code>package.json</code> lacks a <code>"type"</code> field, or contains
@@ -43843,19 +47494,19 @@ parent <code>package.json</code> contains <code>"type": "module"</code>.</p>
 <span class="hljs-keyword">import</span> <span class="hljs-string">'./startup.js'</span>; <span class="hljs-comment">// Loaded as ES module because of package.json</span></code></pre>
 <p>Regardless of the value of the <code>"type"</code> field, <code>.mjs</code> files are always treated
 as ES modules and <code>.cjs</code> files are always treated as CommonJS.</p>
-<h3><code>"exports"</code><span><a class="mark" href="#packages_exports" id="packages_exports">#</a></span></h3>
+<h4><code>"exports"</code><span><a class="mark" href="#packages_exports" id="packages_exports">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.20.0</td>
+<tr><td>v14.13.0, v12.20.0</td>
 <td><p>Add support for <code>"exports"</code> patterns.</p></td></tr>
-<tr><td>v12.16.0</td>
-<td><p>Implement conditional exports.</p></td></tr>
-<tr><td>v12.16.0</td>
-<td><p>Remove the <code>--experimental-conditional-exports</code> option.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.7.0, v12.16.0</td>
 <td><p>Implement logical conditional exports ordering.</p></td></tr>
+<tr><td>v13.7.0, v12.16.0</td>
+<td><p>Remove the <code>--experimental-conditional-exports</code> option.</p></td></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>Implement conditional exports.</p></td></tr>
 <tr><td>v12.7.0</td>
 <td><p><span>Added in: v12.7.0</span></p></td></tr>
 </tbody></table>
@@ -43864,9 +47515,9 @@ as ES modules and <code>.cjs</code> files are always treated as CommonJS.</p>
 <ul>
 <li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"exports"</span>: <span class="hljs-string">"./index.js"</span>
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>The <code>"exports"</code> field allows defining the <a href="#packages_package_entry_points">entry points</a> of a package when
 imported by name loaded either via a <code>node_modules</code> lookup or a
 <a href="#packages_self_referencing_a_package_using_its_name">self-reference</a> to its own name. It is supported in Node.js 12+ as an
@@ -43877,59 +47528,43 @@ package entry points per environment, including whether the package is
 referenced via <code>require</code> or via <code>import</code>.</p>
 <p>All paths defined in the <code>"exports"</code> must be relative file URLs starting with
 <code>./</code>.</p>
-<h3><code>"main"</code><span><a class="mark" href="#packages_main" id="packages_main">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.4.0</span>
-</div>
-<ul>
-<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-</ul>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>
-}</code></pre>
-<p>The <code>"main"</code> field defines the script that is used when the <a href="#modules_folders_as_modules">package directory
-is loaded via <code>require()</code></a>. Its value
-is interpreted as a path.</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'./path/to/directory'</span>); <span class="hljs-comment">// This resolves to ./path/to/directory/main.js.</span></code></pre>
-<p>When a package has an <a href="#packages_exports"><code>"exports"</code></a> field, this will take precedence over the
-<code>"main"</code> field when importing the package by name.</p>
-<h3><code>"imports"</code><span><a class="mark" href="#packages_imports" id="packages_imports">#</a></span></h3>
+<h4><code>"imports"</code><span><a class="mark" href="#packages_imports" id="packages_imports">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.6.0, v12.19.0</span>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <ul>
 <li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"imports"</span>: {
-    <span class="hljs-attr">"#dep"</span>: {
-      <span class="hljs-attr">"node"</span>: <span class="hljs-string">"dep-node-native"</span>,
-      <span class="hljs-attr">"default"</span>: <span class="hljs-string">"./dep-polyfill.js"</span>
-    }
-  },
-  <span class="hljs-attr">"dependencies"</span>: {
-    <span class="hljs-attr">"dep-node-native"</span>: <span class="hljs-string">"^1.0.0"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"imports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"#dep"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"dep-node-native"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"default"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./dep-polyfill.js"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"dep-node-native"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"^1.0.0"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Entries in the imports field must be strings starting with <code>#</code>.</p>
 <p>Import maps permit mapping to external packages.</p>
-<p>This field defines <a href="#packages_subpath_imports">subpath imports</a> for the current package.</p>
-<h1>Net<span><a class="mark" href="#net_net" id="net_net">#</a></span></h1>
+<p>This field defines <a href="#packages_subpath_imports">subpath imports</a> for the current package.</p></section>
+        </section>
+<section><h2>Net<span><a class="mark" href="#net_net" id="net_net">#</a></span></h2>
 
 <!--lint disable maximum-line-length-->
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/net.js">lib/net.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/net.js">lib/net.js</a></p>
 <p>The <code>net</code> module provides an asynchronous network API for creating stream-based
 TCP or <a href="#net_ipc_support">IPC</a> servers (<a href="#net_net_createserver_options_connectionlistener"><code>net.createServer()</code></a>) and clients
 (<a href="#net_net_createconnection"><code>net.createConnection()</code></a>).</p>
 <p>It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);</code></pre>
-<h2>IPC support<span><a class="mark" href="#net_ipc_support" id="net_ipc_support">#</a></span></h2>
+<section><h3>IPC support<span><a class="mark" href="#net_ipc_support" id="net_ipc_support">#</a></span></h3>
 <p>The <code>net</code> module supports IPC with named pipes on Windows, and Unix domain
 sockets on other operating systems.</p>
-<h3>Identifying paths for IPC connections<span><a class="mark" href="#net_identifying_paths_for_ipc_connections" id="net_identifying_paths_for_ipc_connections">#</a></span></h3>
+<h4>Identifying paths for IPC connections<span><a class="mark" href="#net_identifying_paths_for_ipc_connections" id="net_identifying_paths_for_ipc_connections">#</a></span></h4>
 <p><a href="#net_net_connect"><code>net.connect()</code></a>, <a href="#net_net_createconnection"><code>net.createConnection()</code></a>, <a href="#net_server_listen"><code>server.listen()</code></a> and
 <a href="#net_socket_connect"><code>socket.connect()</code></a> take a <code>path</code> parameter to identify IPC endpoints.</p>
 <p>On Unix, the local domain is also known as the Unix domain. The path is a
@@ -43952,9 +47587,128 @@ Unlike Unix domain sockets, Windows will close and remove the pipe when the
 owning process exits.</p>
 <p>JavaScript string escaping requires paths to be specified with extra backslash
 escaping such as:</p>
-<pre><code class="language-js">net.createServer().listen(
-  path.join(<span class="hljs-string">'\\\\?\\pipe'</span>, process.cwd(), <span class="hljs-string">'myctl'</span>));</code></pre>
-<h2>Class: <code>net.Server</code><span><a class="mark" href="#net_class_net_server" id="net_class_net_server">#</a></span></h2>
+<pre><code class="language-js">net.<span class="hljs-title function_">createServer</span>().<span class="hljs-title function_">listen</span>(
+  path.<span class="hljs-title function_">join</span>(<span class="hljs-string">'\\\\?\\pipe'</span>, process.<span class="hljs-title function_">cwd</span>(), <span class="hljs-string">'myctl'</span>));</code></pre>
+</section><section><h3>Class: <code>net.BlockList</code><span><a class="mark" href="#net_class_net_blocklist" id="net_class_net_blocklist">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>The <code>BlockList</code> object can be used with some network APIs to specify rules for
+disabling inbound or outbound access to specific IP addresses, IP ranges, or
+IP subnets.</p>
+<h4><code>blockList.addAddress(address[, type])</code><span><a class="mark" href="#net_blocklist_addaddress_address_type" id="net_blocklist_addaddress_address_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>address</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> An IPv4 or IPv6 address.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>. <strong>Default:</strong> <code>'ipv4'</code>.</li>
+</ul>
+<p>Adds a rule to block the given IP address.</p>
+<h4><code>blockList.addRange(start, end[, type])</code><span><a class="mark" href="#net_blocklist_addrange_start_end_type" id="net_blocklist_addrange_start_end_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> The starting IPv4 or IPv6 address in the
+range.</li>
+<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> The ending IPv4 or IPv6 address in the range.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>. <strong>Default:</strong> <code>'ipv4'</code>.</li>
+</ul>
+<p>Adds a rule to block a range of IP addresses from <code>start</code> (inclusive) to
+<code>end</code> (inclusive).</p>
+<h4><code>blockList.addSubnet(net, prefix[, type])</code><span><a class="mark" href="#net_blocklist_addsubnet_net_prefix_type" id="net_blocklist_addsubnet_net_prefix_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>net</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> The network IPv4 or IPv6 address.</li>
+<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of CIDR prefix bits. For IPv4, this
+must be a value between <code>0</code> and <code>32</code>. For IPv6, this must be between
+<code>0</code> and <code>128</code>.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>. <strong>Default</strong>: <code>'ipv4'</code>.</li>
+</ul>
+<p>Adds a rule to block a range of IP addresses specified as a subnet mask.</p>
+<h4><code>blockList.check(address[, type])</code><span><a class="mark" href="#net_blocklist_check_address_type" id="net_blocklist_check_address_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>address</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> The IP address to check</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>. <strong>Default:</strong> <code>'ipv4'</code>.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the given IP address matches any of the rules added to the
+<code>BlockList</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> blockList = <span class="hljs-keyword">new</span> net.<span class="hljs-title class_">BlockList</span>();
+blockList.<span class="hljs-title function_">addAddress</span>(<span class="hljs-string">'123.123.123.123'</span>);
+blockList.<span class="hljs-title function_">addRange</span>(<span class="hljs-string">'10.0.0.1'</span>, <span class="hljs-string">'10.0.0.10'</span>);
+blockList.<span class="hljs-title function_">addSubnet</span>(<span class="hljs-string">'8592:757c:efae:4e45::'</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'ipv6'</span>);
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'123.123.123.123'</span>));  <span class="hljs-comment">// Prints: true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'10.0.0.3'</span>));  <span class="hljs-comment">// Prints: true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'222.111.111.222'</span>));  <span class="hljs-comment">// Prints: false</span>
+
+<span class="hljs-comment">// IPv6 notation for IPv4 addresses works:</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'::ffff:7b7b:7b7b'</span>, <span class="hljs-string">'ipv6'</span>)); <span class="hljs-comment">// Prints: true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'::ffff:123.123.123.123'</span>, <span class="hljs-string">'ipv6'</span>)); <span class="hljs-comment">// Prints: true</span></code></pre>
+<h4><code>blockList.rules</code><span><a class="mark" href="#net_blocklist_rules" id="net_blocklist_rules">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>The list of rules added to the blocklist.</p>
+</section><section><h3>Class: <code>net.SocketAddress</code><span><a class="mark" href="#net_class_net_socketaddress" id="net_class_net_socketaddress">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<h4><code>new net.SocketAddress([options])</code><span><a class="mark" href="#net_new_net_socketaddress_options" id="net_new_net_socketaddress_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>address</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The network address as either an IPv4 or IPv6 string.
+<strong>Default</strong>: <code>'127.0.0.1'</code> if <code>family</code> is <code>'ipv4'</code>; <code>'::'</code> if <code>family</code> is
+<code>'ipv6'</code>.</li>
+<li><code>family</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> One of either <code>'ipv4'</code> or 'ipv6'<code>. **Default**: </code>'ipv4'`.</li>
+<li><code>flowlabel</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> An IPv6 flow-label used only if <code>family</code> is <code>'ipv6'</code>.</li>
+<li><code>port</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> An IP port.</li>
+</ul>
+</li>
+</ul>
+<h4><code>socketaddress.address</code><span><a class="mark" href="#net_socketaddress_address" id="net_socketaddress_address">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<h4><code>socketaddress.family</code><span><a class="mark" href="#net_socketaddress_family" id="net_socketaddress_family">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>.</li>
+</ul>
+<h4><code>socketaddress.flowlabel</code><span><a class="mark" href="#net_socketaddress_flowlabel" id="net_socketaddress_flowlabel">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<h4><code>socketaddress.port</code><span><a class="mark" href="#net_socketaddress_port" id="net_socketaddress_port">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+</section><section><h3>Class: <code>net.Server</code><span><a class="mark" href="#net_class_net_server" id="net_class_net_server">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -43962,7 +47716,7 @@ escaping such as:</p>
 <li>Extends: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
 <p>This class is used to create a TCP or <a href="#net_ipc_support">IPC</a> server.</p>
-<h3><code>new net.Server([options][, connectionListener])</code><span><a class="mark" href="#net_new_net_server_options_connectionlistener" id="net_new_net_server_options_connectionlistener">#</a></span></h3>
+<h4><code>new net.Server([options][, connectionListener])</code><span><a class="mark" href="#net_new_net_server_options_connectionlistener" id="net_new_net_server_options_connectionlistener">#</a></span></h4>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> See
 <a href="#net_net_createserver_options_connectionlistener"><code>net.createServer([options][, connectionListener])</code></a>.</li>
@@ -43971,13 +47725,13 @@ escaping such as:</p>
 <li>Returns: <a href="#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
 <p><code>net.Server</code> is an <a href="#events_class_eventemitter"><code>EventEmitter</code></a> with the following events:</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#net_event_close" id="net_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#net_event_close" id="net_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
 <p>Emitted when the server closes. If connections exist, this
 event is not emitted until all connections are ended.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#net_event_connection" id="net_event_connection">#</a></span></h3>
+<h4>Event: <code>'connection'</code><span><a class="mark" href="#net_event_connection" id="net_event_connection">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -43986,7 +47740,7 @@ event is not emitted until all connections are ended.</p>
 </ul>
 <p>Emitted when a new connection is made. <code>socket</code> is an instance of
 <code>net.Socket</code>.</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#net_event_error" id="net_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#net_event_error" id="net_event_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -43997,12 +47751,12 @@ event is not emitted until all connections are ended.</p>
 event will <strong>not</strong> be emitted directly following this event unless
 <a href="#net_server_close_callback"><code>server.close()</code></a> is manually called. See the example in discussion of
 <a href="#net_server_listen"><code>server.listen()</code></a>.</p>
-<h3>Event: <code>'listening'</code><span><a class="mark" href="#net_event_listening" id="net_event_listening">#</a></span></h3>
+<h4>Event: <code>'listening'</code><span><a class="mark" href="#net_event_listening" id="net_event_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <p>Emitted when the server has been bound after calling <a href="#net_server_listen"><code>server.listen()</code></a>.</p>
-<h3><code>server.address()</code><span><a class="mark" href="#net_server_address" id="net_server_address">#</a></span></h3>
+<h4><code>server.address()</code><span><a class="mark" href="#net_server_address" id="net_server_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44015,20 +47769,20 @@ as reported by the operating system if listening on an IP socket
 <code>{ port: 12346, family: 'IPv4', address: '127.0.0.1' }</code>.</p>
 <p>For a server listening on a pipe or Unix domain socket, the name is returned
 as a string.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  socket.end(<span class="hljs-string">'goodbye\n'</span>);
-}).on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'goodbye\n'</span>);
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-comment">// Handle errors here.</span>
   <span class="hljs-keyword">throw</span> err;
 });
 
 <span class="hljs-comment">// Grab an arbitrary unused port.</span>
-server.listen(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'opened server on'</span>, server.address());
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'opened server on'</span>, server.<span class="hljs-title function_">address</span>());
 });</code></pre>
 <p><code>server.address()</code> returns <code>null</code> before the <code>'listening'</code> event has been
 emitted or after calling <code>server.close()</code>.</p>
-<h3><code>server.close([callback])</code><span><a class="mark" href="#net_server_close_callback" id="net_server_close_callback">#</a></span></h3>
+<h4><code>server.close([callback])</code><span><a class="mark" href="#net_server_close_callback" id="net_server_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44042,7 +47796,7 @@ when all connections are ended and the server emits a <a href="#net_event_close"
 The optional <code>callback</code> will be called once the <code>'close'</code> event occurs. Unlike
 that event, it will be called with an <code>Error</code> as its only argument if the server
 was not open when it was closed.</p>
-<h3><code>server.connections</code><span><a class="mark" href="#net_server_connections" id="net_server_connections">#</a></span></h3>
+<h4><code>server.connections</code><span><a class="mark" href="#net_server_connections" id="net_server_connections">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.2.0</span><span>Deprecated since: v0.9.7</span>
 </div>
@@ -44054,7 +47808,7 @@ was not open when it was closed.</p>
 <p>This becomes <code>null</code> when sending a socket to a child with
 <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>. To poll forks and get current number of active
 connections, use asynchronous <a href="#net_server_getconnections_callback"><code>server.getConnections()</code></a> instead.</p>
-<h3><code>server.getConnections(callback)</code><span><a class="mark" href="#net_server_getconnections_callback" id="net_server_getconnections_callback">#</a></span></h3>
+<h4><code>server.getConnections(callback)</code><span><a class="mark" href="#net_server_getconnections_callback" id="net_server_getconnections_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.7</span>
 </div>
@@ -44065,10 +47819,11 @@ connections, use asynchronous <a href="#net_server_getconnections_callback"><cod
 <p>Asynchronously get the number of concurrent connections on the server. Works
 when sockets were sent to forks.</p>
 <p>Callback should take two arguments <code>err</code> and <code>count</code>.</p>
-<h3><code>server.listen()</code><span><a class="mark" href="#net_server_listen" id="net_server_listen">#</a></span></h3>
+<h4><code>server.listen()</code><span><a class="mark" href="#net_server_listen" id="net_server_listen">#</a></span></h4>
 <p>Start a server listening for connections. A <code>net.Server</code> can be a TCP or
 an <a href="#net_ipc_support">IPC</a> server depending on what it listens to.</p>
 <p>Possible signatures:</p>
+<!--lint disable no-undefined-references-->
 <ul>
 <li><a href="#net_server_listen_handle_backlog_callback"><code>server.listen(handle[, backlog][, callback])</code></a></li>
 <li><a href="#net_server_listen_options_callback"><code>server.listen(options[, callback])</code></a></li>
@@ -44080,6 +47835,7 @@ for <a href="#net_ipc_support">IPC</a> servers</li>
 for TCP servers
 </li>
 </ul>
+<!--lint enable no-undefined-references-->
 <p>This function is asynchronous. When the server starts listening, the
 <a href="#net_event_listening"><code>'listening'</code></a> event will be emitted. The last parameter <code>callback</code>
 will be added as a listener for the <a href="#net_event_listening"><code>'listening'</code></a> event.</p>
@@ -44096,16 +47852,16 @@ called. Otherwise, an <code>ERR_SERVER_ALREADY_LISTEN</code> error will be throw
 This happens when another server is already listening on the requested
 <code>port</code>/<code>path</code>/<code>handle</code>. One way to handle this would be to retry
 after a certain amount of time:</p>
-<pre><code class="language-js">server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-keyword">if</span> (e.code === <span class="hljs-string">'EADDRINUSE'</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Address in use, retrying...'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-keyword">if</span> (e.<span class="hljs-property">code</span> === <span class="hljs-string">'EADDRINUSE'</span>) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Address in use, retrying...'</span>);
     <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-      server.close();
-      server.listen(PORT, HOST);
+      server.<span class="hljs-title function_">close</span>();
+      server.<span class="hljs-title function_">listen</span>(<span class="hljs-variable constant_">PORT</span>, <span class="hljs-variable constant_">HOST</span>);
     }, <span class="hljs-number">1000</span>);
   }
 });</code></pre>
-<h4><code>server.listen(handle[, backlog][, callback])</code><span><a class="mark" href="#net_server_listen_handle_backlog_callback" id="net_server_listen_handle_backlog_callback">#</a></span></h4>
+<h5><code>server.listen(handle[, backlog][, callback])</code><span><a class="mark" href="#net_server_listen_handle_backlog_callback" id="net_server_listen_handle_backlog_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -44121,7 +47877,7 @@ already been bound to a port, a Unix domain socket, or a Windows named pipe.</p>
 underlying <code>_handle</code> member), or an object with an <code>fd</code> member that is a
 valid file descriptor.</p>
 <p>Listening on a file descriptor is not supported on Windows.</p>
-<h4><code>server.listen(options[, callback])</code><span><a class="mark" href="#net_server_listen_options_callback" id="net_server_listen_options_callback">#</a></span></h4>
+<h5><code>server.listen(options[, callback])</code><span><a class="mark" href="#net_server_listen_options_callback" id="net_server_listen_options_callback">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -44156,18 +47912,20 @@ disable dual-stack support, i.e., binding to host <code>::</code> won't make
 functions.</li>
 <li>Returns: <a href="#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
+<!--lint disable no-undefined-references-->
 <p>If <code>port</code> is specified, it behaves the same as
 <a href="#net_server_listen_port_host_backlog_callback">
 <code>server.listen([port[, host[, backlog]]][, callback])</code></a>.
 Otherwise, if <code>path</code> is specified, it behaves the same as
 <a href="#net_server_listen_path_backlog_callback"><code>server.listen(path[, backlog][, callback])</code></a>.
 If none of them is specified, an error will be thrown.</p>
+<!--lint enable no-undefined-references-->
 <p>If <code>exclusive</code> is <code>false</code> (default), then cluster workers will use the same
 underlying handle, allowing connection handling duties to be shared. When
 <code>exclusive</code> is <code>true</code>, the handle is not shared, and attempted port sharing
 results in an error. An example which listens on an exclusive port is
 shown below.</p>
-<pre><code class="language-js">server.listen({
+<pre><code class="language-js">server.<span class="hljs-title function_">listen</span>({
   <span class="hljs-attr">host</span>: <span class="hljs-string">'localhost'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">80</span>,
   <span class="hljs-attr">exclusive</span>: <span class="hljs-literal">true</span>
@@ -44175,7 +47933,7 @@ shown below.</p>
 <p>Starting an IPC server as root may cause the server path to be inaccessible for
 unprivileged users. Using <code>readableAll</code> and <code>writableAll</code> will make the server
 accessible for all users.</p>
-<h4><code>server.listen(path[, backlog][, callback])</code><span><a class="mark" href="#net_server_listen_path_backlog_callback" id="net_server_listen_path_backlog_callback">#</a></span></h4>
+<h5><code>server.listen(path[, backlog][, callback])</code><span><a class="mark" href="#net_server_listen_path_backlog_callback" id="net_server_listen_path_backlog_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44187,7 +47945,7 @@ accessible for all users.</p>
 <li>Returns: <a href="#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
 <p>Start an <a href="#net_ipc_support">IPC</a> server listening for connections on the given <code>path</code>.</p>
-<h4><code>server.listen([port[, host[, backlog]]][, callback])</code><span><a class="mark" href="#net_server_listen_port_host_backlog_callback" id="net_server_listen_port_host_backlog_callback">#</a></span></h4>
+<h5><code>server.listen([port[, host[, backlog]]][, callback])</code><span><a class="mark" href="#net_server_listen_port_host_backlog_callback" id="net_server_listen_port_host_backlog_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44208,14 +47966,14 @@ after the <a href="#net_event_listening"><code>'listening'</code></a> event has
 <p>In most operating systems, listening to the <a href="https://en.wikipedia.org/wiki/IPv6_address#Unspecified_address">unspecified IPv6 address</a> (<code>::</code>)
 may cause the <code>net.Server</code> to also listen on the <a href="https://en.wikipedia.org/wiki/0.0.0.0">unspecified IPv4 address</a>
 (<code>0.0.0.0</code>).</p>
-<h3><code>server.listening</code><span><a class="mark" href="#net_server_listening" id="net_server_listening">#</a></span></h3>
+<h4><code>server.listening</code><span><a class="mark" href="#net_server_listening" id="net_server_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.7.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether or not the server is listening for connections.</li>
 </ul>
-<h3><code>server.maxConnections</code><span><a class="mark" href="#net_server_maxconnections" id="net_server_maxconnections">#</a></span></h3>
+<h4><code>server.maxConnections</code><span><a class="mark" href="#net_server_maxconnections" id="net_server_maxconnections">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.2.0</span>
 </div>
@@ -44226,7 +47984,7 @@ may cause the <code>net.Server</code> to also listen on the <a href="https://en.
 high.</p>
 <p>It is not recommended to use this option once a socket has been sent to a child
 with <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p>
-<h3><code>server.ref()</code><span><a class="mark" href="#net_server_ref" id="net_server_ref">#</a></span></h3>
+<h4><code>server.ref()</code><span><a class="mark" href="#net_server_ref" id="net_server_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -44236,7 +47994,7 @@ with <a href="#child_process_child_process_fork_modulepath_args_options"><code>c
 <p>Opposite of <code>unref()</code>, calling <code>ref()</code> on a previously <code>unref</code>ed server will
 <em>not</em> let the program exit if it's the only server left (the default behavior).
 If the server is <code>ref</code>ed calling <code>ref()</code> again will have no effect.</p>
-<h3><code>server.unref()</code><span><a class="mark" href="#net_server_unref" id="net_server_unref">#</a></span></h3>
+<h4><code>server.unref()</code><span><a class="mark" href="#net_server_unref" id="net_server_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -44246,7 +48004,7 @@ If the server is <code>ref</code>ed calling <code>ref()</code> again will have n
 <p>Calling <code>unref()</code> on a server will allow the program to exit if this is the only
 active server in the event system. If the server is already <code>unref</code>ed calling
 <code>unref()</code> again will have no effect.</p>
-<h2>Class: <code>net.Socket</code><span><a class="mark" href="#net_class_net_socket" id="net_class_net_socket">#</a></span></h2>
+</section><section><h3>Class: <code>net.Socket</code><span><a class="mark" href="#net_class_net_socket" id="net_class_net_socket">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -44263,7 +48021,7 @@ so the user can use it to talk to the server.</p>
 is received. For example, it is passed to the listeners of a
 <a href="#net_event_connection"><code>'connection'</code></a> event emitted on a <a href="#net_class_net_server"><code>net.Server</code></a>, so the user can use
 it to interact with the client.</p>
-<h3><code>new net.Socket([options])</code><span><a class="mark" href="#net_new_net_socket_options" id="net_new_net_socket_options">#</a></span></h3>
+<h4><code>new net.Socket([options])</code><span><a class="mark" href="#net_new_net_socket_options" id="net_new_net_socket_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -44272,9 +48030,10 @@ it to interact with the client.</p>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> If specified, wrap around an existing socket with
 the given file descriptor, otherwise a new socket will be created.</li>
-<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether half-opened TCP connections
-are allowed. See <a href="#net_net_createserver_options_connectionlistener"><code>net.createServer()</code></a> and the <a href="#net_event_end"><code>'end'</code></a> event
-for details. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If set to <code>false</code>, then the socket will
+automatically end the writable side when the readable side ends. See
+<a href="#net_net_createserver_options_connectionlistener"><code>net.createServer()</code></a> and the <a href="#net_event_end"><code>'end'</code></a> event for details. <strong>Default:</strong>
+<code>false</code>.</li>
 <li><code>readable</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Allow reads on the socket when an <code>fd</code> is passed,
 otherwise ignored. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>writable</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Allow writes on the socket when an <code>fd</code> is passed,
@@ -44286,7 +48045,7 @@ otherwise ignored. <strong>Default:</strong> <code>false</code>.</li>
 <p>Creates a new socket object.</p>
 <p>The newly created socket can be either a TCP socket or a streaming <a href="#net_ipc_support">IPC</a>
 endpoint, depending on what it <a href="#net_socket_connect"><code>connect()</code></a> to.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#net_event_close_1" id="net_event_close_1">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#net_event_close_1" id="net_event_close_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44295,13 +48054,13 @@ endpoint, depending on what it <a href="#net_socket_connect"><code>connect()</co
 </ul>
 <p>Emitted once the socket is fully closed. The argument <code>hadError</code> is a boolean
 which says if the socket was closed due to a transmission error.</p>
-<h3>Event: <code>'connect'</code><span><a class="mark" href="#net_event_connect" id="net_event_connect">#</a></span></h3>
+<h4>Event: <code>'connect'</code><span><a class="mark" href="#net_event_connect" id="net_event_connect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <p>Emitted when a socket connection is successfully established.
 See <a href="#net_net_createconnection"><code>net.createConnection()</code></a>.</p>
-<h3>Event: <code>'data'</code><span><a class="mark" href="#net_event_data" id="net_event_data">#</a></span></h3>
+<h4>Event: <code>'data'</code><span><a class="mark" href="#net_event_data" id="net_event_data">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44312,26 +48071,26 @@ See <a href="#net_net_createconnection"><code>net.createConnection()</code></a>.
 <code>String</code>. Encoding of data is set by <a href="#net_socket_setencoding_encoding"><code>socket.setEncoding()</code></a>.</p>
 <p>The data will be lost if there is no listener when a <code>Socket</code>
 emits a <code>'data'</code> event.</p>
-<h3>Event: <code>'drain'</code><span><a class="mark" href="#net_event_drain" id="net_event_drain">#</a></span></h3>
+<h4>Event: <code>'drain'</code><span><a class="mark" href="#net_event_drain" id="net_event_drain">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <p>Emitted when the write buffer becomes empty. Can be used to throttle uploads.</p>
 <p>See also: the return values of <code>socket.write()</code>.</p>
-<h3>Event: <code>'end'</code><span><a class="mark" href="#net_event_end" id="net_event_end">#</a></span></h3>
+<h4>Event: <code>'end'</code><span><a class="mark" href="#net_event_end" id="net_event_end">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
-<p>Emitted when the other end of the socket sends a FIN packet, thus ending the
-readable side of the socket.</p>
-<p>By default (<code>allowHalfOpen</code> is <code>false</code>) the socket will send a FIN packet
-back and destroy its file descriptor once it has written out its pending
-write queue. However, if <code>allowHalfOpen</code> is set to <code>true</code>, the socket will
-not automatically <a href="#net_socket_end_data_encoding_callback"><code>end()</code></a> its writable side, allowing the
-user to write arbitrary amounts of data. The user must call
+<p>Emitted when the other end of the socket signals the end of transmission, thus
+ending the readable side of the socket.</p>
+<p>By default (<code>allowHalfOpen</code> is <code>false</code>) the socket will send an end of
+transmission packet back and destroy its file descriptor once it has written out
+its pending write queue. However, if <code>allowHalfOpen</code> is set to <code>true</code>, the
+socket will not automatically <a href="#net_socket_end_data_encoding_callback"><code>end()</code></a> its writable side,
+allowing the user to write arbitrary amounts of data. The user must call
 <a href="#net_socket_end_data_encoding_callback"><code>end()</code></a> explicitly to close the connection (i.e. sending a
 FIN packet back).</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#net_event_error_1" id="net_event_error_1">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#net_event_error_1" id="net_event_error_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44340,7 +48099,7 @@ FIN packet back).</p>
 </ul>
 <p>Emitted when an error occurs. The <code>'close'</code> event will be called directly
 following this event.</p>
-<h3>Event: <code>'lookup'</code><span><a class="mark" href="#net_event_lookup" id="net_event_lookup">#</a></span></h3>
+<h4>Event: <code>'lookup'</code><span><a class="mark" href="#net_event_lookup" id="net_event_lookup">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -44360,20 +48119,20 @@ Not applicable to Unix sockets.</p>
 <li><code>family</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> The address type. See <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>.</li>
 <li><code>host</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The host name.</li>
 </ul>
-<h3>Event: <code>'ready'</code><span><a class="mark" href="#net_event_ready" id="net_event_ready">#</a></span></h3>
+<h4>Event: <code>'ready'</code><span><a class="mark" href="#net_event_ready" id="net_event_ready">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.11.0</span>
 </div>
 <p>Emitted when a socket is ready to be used.</p>
 <p>Triggered immediately after <code>'connect'</code>.</p>
-<h3>Event: <code>'timeout'</code><span><a class="mark" href="#net_event_timeout" id="net_event_timeout">#</a></span></h3>
+<h4>Event: <code>'timeout'</code><span><a class="mark" href="#net_event_timeout" id="net_event_timeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <p>Emitted if the socket times out from inactivity. This is only to notify that
 the socket has been idle. The user must manually close the connection.</p>
 <p>See also: <a href="#net_socket_settimeout_timeout_callback"><code>socket.setTimeout()</code></a>.</p>
-<h3><code>socket.address()</code><span><a class="mark" href="#net_socket_address" id="net_socket_address">#</a></span></h3>
+<h4><code>socket.address()</code><span><a class="mark" href="#net_socket_address" id="net_socket_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44383,10 +48142,11 @@ the socket has been idle. The user must manually close the connection.</p>
 <p>Returns the bound <code>address</code>, the address <code>family</code> name and <code>port</code> of the
 socket as reported by the operating system:
 <code>{ port: 12346, family: 'IPv4', address: '127.0.0.1' }</code></p>
-<h3><code>socket.bufferSize</code><span><a class="mark" href="#net_socket_buffersize" id="net_socket_buffersize">#</a></span></h3>
+<h4><code>socket.bufferSize</code><span><a class="mark" href="#net_socket_buffersize" id="net_socket_buffersize">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.3.8</span>
+<span>Added in: v0.3.8</span><span>Deprecated since: v14.6.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#stream_writable_writablelength"><code>writable.writableLength</code></a> instead.</div><p></p>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
@@ -44402,7 +48162,7 @@ socket and send it out over the wire when it is possible.</p>
 Users who experience large or growing <code>bufferSize</code> should attempt to
 "throttle" the data flows in their program with
 <a href="#net_socket_pause"><code>socket.pause()</code></a> and <a href="#net_socket_resume"><code>socket.resume()</code></a>.</p>
-<h3><code>socket.bytesRead</code><span><a class="mark" href="#net_socket_bytesread" id="net_socket_bytesread">#</a></span></h3>
+<h4><code>socket.bytesRead</code><span><a class="mark" href="#net_socket_bytesread" id="net_socket_bytesread">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.3</span>
 </div>
@@ -44410,7 +48170,7 @@ Users who experience large or growing <code>bufferSize</code> should attempt to
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The amount of received bytes.</p>
-<h3><code>socket.bytesWritten</code><span><a class="mark" href="#net_socket_byteswritten" id="net_socket_byteswritten">#</a></span></h3>
+<h4><code>socket.bytesWritten</code><span><a class="mark" href="#net_socket_byteswritten" id="net_socket_byteswritten">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.3</span>
 </div>
@@ -44418,7 +48178,7 @@ Users who experience large or growing <code>bufferSize</code> should attempt to
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The amount of bytes sent.</p>
-<h3><code>socket.connect()</code><span><a class="mark" href="#net_socket_connect" id="net_socket_connect">#</a></span></h3>
+<h4><code>socket.connect()</code><span><a class="mark" href="#net_socket_connect" id="net_socket_connect">#</a></span></h4>
 <p>Initiate a connection on a given socket.</p>
 <p>Possible signatures:</p>
 <ul>
@@ -44438,7 +48198,7 @@ for the <a href="#net_event_connect"><code>'connect'</code></a> event <strong>on
 <p>This function should only be used for reconnecting a socket after
 <code>'close'</code> has been emitted or otherwise it may lead to undefined
 behavior.</p>
-<h4><code>socket.connect(options[, connectListener])</code><span><a class="mark" href="#net_socket_connect_options_connectlistener" id="net_socket_connect_options_connectlistener">#</a></span></h4>
+<h5><code>socket.connect(options[, connectListener])</code><span><a class="mark" href="#net_socket_connect_options_connectlistener" id="net_socket_connect_options_connectlistener">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -44501,18 +48261,18 @@ global context.</li>
 </ul>
 <p>Following is an example of a client using the <code>onread</code> option:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-net.connect({
+net.<span class="hljs-title function_">connect</span>({
   <span class="hljs-attr">port</span>: <span class="hljs-number">80</span>,
   <span class="hljs-attr">onread</span>: {
     <span class="hljs-comment">// Reuses a 4KiB Buffer for every read from the socket.</span>
-    <span class="hljs-attr">buffer</span>: Buffer.alloc(<span class="hljs-number">4</span> * <span class="hljs-number">1024</span>),
-    <span class="hljs-attr">callback</span>: <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">nread, buf</span>) </span>{
+    <span class="hljs-attr">buffer</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">4</span> * <span class="hljs-number">1024</span>),
+    <span class="hljs-attr">callback</span>: <span class="hljs-keyword">function</span>(<span class="hljs-params">nread, buf</span>) {
       <span class="hljs-comment">// Received data is available in `buf` from 0 to `nread`.</span>
-      <span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, nread));
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, nread));
     }
   }
 });</code></pre>
-<h4><code>socket.connect(path[, connectListener])</code><span><a class="mark" href="#net_socket_connect_path_connectlistener" id="net_socket_connect_path_connectlistener">#</a></span></h4>
+<h5><code>socket.connect(path[, connectListener])</code><span><a class="mark" href="#net_socket_connect_path_connectlistener" id="net_socket_connect_path_connectlistener">#</a></span></h5>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Path the client should connect to. See
 <a href="#net_identifying_paths_for_ipc_connections">Identifying paths for IPC connections</a>.</li>
@@ -44524,7 +48284,7 @@ methods. Will be added as a listener for the <a href="#net_event_connect"><code>
 <p>Alias to
 <a href="#net_socket_connect_options_connectlistener"><code>socket.connect(options[, connectListener])</code></a>
 called with <code>{ path: path }</code> as <code>options</code>.</p>
-<h4><code>socket.connect(port[, host][, connectListener])</code><span><a class="mark" href="#net_socket_connect_port_host_connectlistener" id="net_socket_connect_port_host_connectlistener">#</a></span></h4>
+<h5><code>socket.connect(port[, host][, connectListener])</code><span><a class="mark" href="#net_socket_connect_port_host_connectlistener" id="net_socket_connect_port_host_connectlistener">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44539,7 +48299,7 @@ methods. Will be added as a listener for the <a href="#net_event_connect"><code>
 <p>Alias to
 <a href="#net_socket_connect_options_connectlistener"><code>socket.connect(options[, connectListener])</code></a>
 called with <code>{port: port, host: host}</code> as <code>options</code>.</p>
-<h3><code>socket.connecting</code><span><a class="mark" href="#net_socket_connecting" id="net_socket_connecting">#</a></span></h3>
+<h4><code>socket.connecting</code><span><a class="mark" href="#net_socket_connecting" id="net_socket_connecting">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.1.0</span>
 </div>
@@ -44553,7 +48313,7 @@ connected, then it is set to <code>false</code> and the <code>'connect'</code> e
 that the
 <a href="#net_socket_connect_options_connectlistener"><code>socket.connect(options[, connectListener])</code></a>
 callback is a listener for the <code>'connect'</code> event.</p>
-<h3><code>socket.destroy([error])</code><span><a class="mark" href="#net_socket_destroy_error" id="net_socket_destroy_error">#</a></span></h3>
+<h4><code>socket.destroy([error])</code><span><a class="mark" href="#net_socket_destroy_error" id="net_socket_destroy_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44564,13 +48324,13 @@ callback is a listener for the <code>'connect'</code> event.</p>
 <p>Ensures that no more I/O activity happens on this socket.
 Destroys the stream and closes the connection.</p>
 <p>See <a href="#stream_writable_destroy_error"><code>writable.destroy()</code></a> for further details.</p>
-<h3><code>socket.destroyed</code><span><a class="mark" href="#net_socket_destroyed" id="net_socket_destroyed">#</a></span></h3>
+<h4><code>socket.destroyed</code><span><a class="mark" href="#net_socket_destroyed" id="net_socket_destroyed">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates if the connection is destroyed or not. Once a
 connection is destroyed no further data can be transferred using it.</li>
 </ul>
 <p>See <a href="#stream_writable_destroyed"><code>writable.destroyed</code></a> for further details.</p>
-<h3><code>socket.end([data[, encoding]][, callback])</code><span><a class="mark" href="#net_socket_end_data_encoding_callback" id="net_socket_end_data_encoding_callback">#</a></span></h3>
+<h4><code>socket.end([data[, encoding]][, callback])</code><span><a class="mark" href="#net_socket_end_data_encoding_callback" id="net_socket_end_data_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44583,7 +48343,7 @@ connection is destroyed no further data can be transferred using it.</li>
 <p>Half-closes the socket. i.e., it sends a FIN packet. It is possible the
 server will still send some data.</p>
 <p>See <a href="#stream_writable_end_chunk_encoding_callback"><code>writable.end()</code></a> for further details.</p>
-<h3><code>socket.localAddress</code><span><a class="mark" href="#net_socket_localaddress" id="net_socket_localaddress">#</a></span></h3>
+<h4><code>socket.localAddress</code><span><a class="mark" href="#net_socket_localaddress" id="net_socket_localaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.6</span>
 </div>
@@ -44594,7 +48354,7 @@ server will still send some data.</p>
 connecting on. For example, in a server listening on <code>'0.0.0.0'</code>, if a client
 connects on <code>'192.168.1.1'</code>, the value of <code>socket.localAddress</code> would be
 <code>'192.168.1.1'</code>.</p>
-<h3><code>socket.localPort</code><span><a class="mark" href="#net_socket_localport" id="net_socket_localport">#</a></span></h3>
+<h4><code>socket.localPort</code><span><a class="mark" href="#net_socket_localport" id="net_socket_localport">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.6</span>
 </div>
@@ -44602,15 +48362,15 @@ connects on <code>'192.168.1.1'</code>, the value of <code>socket.localAddress</
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The numeric representation of the local port. For example, <code>80</code> or <code>21</code>.</p>
-<h3><code>socket.pause()</code><span><a class="mark" href="#net_socket_pause" id="net_socket_pause">#</a></span></h3>
+<h4><code>socket.pause()</code><span><a class="mark" href="#net_socket_pause" id="net_socket_pause">#</a></span></h4>
 <ul>
 <li>Returns: <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> The socket itself.</li>
 </ul>
 <p>Pauses the reading of data. That is, <a href="#net_event_data"><code>'data'</code></a> events will not be emitted.
 Useful to throttle back an upload.</p>
-<h3><code>socket.pending</code><span><a class="mark" href="#net_socket_pending" id="net_socket_pending">#</a></span></h3>
+<h4><code>socket.pending</code><span><a class="mark" href="#net_socket_pending" id="net_socket_pending">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.2.0</span>
+<span>Added in: v11.2.0, v10.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
@@ -44618,7 +48378,7 @@ Useful to throttle back an upload.</p>
 <p>This is <code>true</code> if the socket is not connected yet, either because <code>.connect()</code>
 has not yet been called or because it is still in the process of connecting
 (see <a href="#net_socket_connecting"><code>socket.connecting</code></a>).</p>
-<h3><code>socket.ref()</code><span><a class="mark" href="#net_socket_ref" id="net_socket_ref">#</a></span></h3>
+<h4><code>socket.ref()</code><span><a class="mark" href="#net_socket_ref" id="net_socket_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -44628,7 +48388,7 @@ has not yet been called or because it is still in the process of connecting
 <p>Opposite of <code>unref()</code>, calling <code>ref()</code> on a previously <code>unref</code>ed socket will
 <em>not</em> let the program exit if it's the only socket left (the default behavior).
 If the socket is <code>ref</code>ed calling <code>ref</code> again will have no effect.</p>
-<h3><code>socket.remoteAddress</code><span><a class="mark" href="#net_socket_remoteaddress" id="net_socket_remoteaddress">#</a></span></h3>
+<h4><code>socket.remoteAddress</code><span><a class="mark" href="#net_socket_remoteaddress" id="net_socket_remoteaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -44638,7 +48398,7 @@ If the socket is <code>ref</code>ed calling <code>ref</code> again will have no
 <p>The string representation of the remote IP address. For example,
 <code>'74.125.127.100'</code> or <code>'2001:4860:a005::68'</code>. Value may be <code>undefined</code> if
 the socket is destroyed (for example, if the client disconnected).</p>
-<h3><code>socket.remoteFamily</code><span><a class="mark" href="#net_socket_remotefamily" id="net_socket_remotefamily">#</a></span></h3>
+<h4><code>socket.remoteFamily</code><span><a class="mark" href="#net_socket_remotefamily" id="net_socket_remotefamily">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -44646,7 +48406,7 @@ the socket is destroyed (for example, if the client disconnected).</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The string representation of the remote IP family. <code>'IPv4'</code> or <code>'IPv6'</code>.</p>
-<h3><code>socket.remotePort</code><span><a class="mark" href="#net_socket_remoteport" id="net_socket_remoteport">#</a></span></h3>
+<h4><code>socket.remotePort</code><span><a class="mark" href="#net_socket_remoteport" id="net_socket_remoteport">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -44654,12 +48414,12 @@ the socket is destroyed (for example, if the client disconnected).</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The numeric representation of the remote port. For example, <code>80</code> or <code>21</code>.</p>
-<h3><code>socket.resume()</code><span><a class="mark" href="#net_socket_resume" id="net_socket_resume">#</a></span></h3>
+<h4><code>socket.resume()</code><span><a class="mark" href="#net_socket_resume" id="net_socket_resume">#</a></span></h4>
 <ul>
 <li>Returns: <a href="#net_class_net_socket" class="type">&#x3C;net.Socket></a> The socket itself.</li>
 </ul>
 <p>Resumes reading after a call to <a href="#net_socket_pause"><code>socket.pause()</code></a>.</p>
-<h3><code>socket.setEncoding([encoding])</code><span><a class="mark" href="#net_socket_setencoding_encoding" id="net_socket_setencoding_encoding">#</a></span></h3>
+<h4><code>socket.setEncoding([encoding])</code><span><a class="mark" href="#net_socket_setencoding_encoding" id="net_socket_setencoding_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44669,9 +48429,17 @@ the socket is destroyed (for example, if the client disconnected).</p>
 </ul>
 <p>Set the encoding for the socket as a <a href="#stream_class_stream_readable">Readable Stream</a>. See
 <a href="#stream_readable_setencoding_encoding"><code>readable.setEncoding()</code></a> for more information.</p>
-<h3><code>socket.setKeepAlive([enable][, initialDelay])</code><span><a class="mark" href="#net_socket_setkeepalive_enable_initialdelay" id="net_socket_setkeepalive_enable_initialdelay">#</a></span></h3>
+<h4><code>socket.setKeepAlive([enable][, initialDelay])</code><span><a class="mark" href="#net_socket_setkeepalive_enable_initialdelay" id="net_socket_setkeepalive_enable_initialdelay">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.92</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.12.0, v12.17.0</td>
+<td><p>New defaults for <code>TCP_KEEPCNT</code> and <code>TCP_KEEPINTVL</code> socket options were added.</p></td></tr>
+<tr><td>v0.1.92</td>
+<td><p><span>Added in: v0.1.92</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>enable</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
@@ -44684,7 +48452,14 @@ delay before the first keepalive probe is sent on an idle socket.</p>
 data packet received and the first keepalive probe. Setting <code>0</code> for
 <code>initialDelay</code> will leave the value unchanged from the default
 (or previous) setting.</p>
-<h3><code>socket.setNoDelay([noDelay])</code><span><a class="mark" href="#net_socket_setnodelay_nodelay" id="net_socket_setnodelay_nodelay">#</a></span></h3>
+<p>Enabling the keep-alive functionality will set the following socket options:</p>
+<ul>
+<li><code>SO_KEEPALIVE=1</code></li>
+<li><code>TCP_KEEPIDLE=initialDelay</code></li>
+<li><code>TCP_KEEPCNT=10</code></li>
+<li><code>TCP_KEEPINTVL=1</code></li>
+</ul>
+<h4><code>socket.setNoDelay([noDelay])</code><span><a class="mark" href="#net_socket_setnodelay_nodelay" id="net_socket_setnodelay_nodelay">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44699,7 +48474,7 @@ to optimize throughput at the expense of latency.</p>
 <p>Passing <code>true</code> for <code>noDelay</code> or not passing an argument will disable Nagle's
 algorithm for the socket. Passing <code>false</code> for <code>noDelay</code> will enable Nagle's
 algorithm.</p>
-<h3><code>socket.setTimeout(timeout[, callback])</code><span><a class="mark" href="#net_socket_settimeout_timeout_callback" id="net_socket_settimeout_timeout_callback">#</a></span></h3>
+<h4><code>socket.setTimeout(timeout[, callback])</code><span><a class="mark" href="#net_socket_settimeout_timeout_callback" id="net_socket_settimeout_timeout_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44713,15 +48488,24 @@ the socket. By default <code>net.Socket</code> do not have a timeout.</p>
 <p>When an idle timeout is triggered the socket will receive a <a href="#net_event_timeout"><code>'timeout'</code></a>
 event but the connection will not be severed. The user must manually call
 <a href="#net_socket_end_data_encoding_callback"><code>socket.end()</code></a> or <a href="#net_socket_destroy_error"><code>socket.destroy()</code></a> to end the connection.</p>
-<pre><code class="language-js">socket.setTimeout(<span class="hljs-number">3000</span>);
-socket.on(<span class="hljs-string">'timeout'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'socket timeout'</span>);
-  socket.end();
+<pre><code class="language-js">socket.<span class="hljs-built_in">setTimeout</span>(<span class="hljs-number">3000</span>);
+socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'timeout'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'socket timeout'</span>);
+  socket.<span class="hljs-title function_">end</span>();
 });</code></pre>
 <p>If <code>timeout</code> is 0, then the existing idle timeout is disabled.</p>
 <p>The optional <code>callback</code> parameter will be added as a one-time listener for the
 <a href="#net_event_timeout"><code>'timeout'</code></a> event.</p>
-<h3><code>socket.unref()</code><span><a class="mark" href="#net_socket_unref" id="net_socket_unref">#</a></span></h3>
+<h4><code>socket.timeout</code><span><a class="mark" href="#net_socket_timeout" id="net_socket_timeout">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.7.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
+</ul>
+<p>The socket timeout in milliseconds as set by <a href="#net_socket_settimeout_timeout_callback"><code>socket.setTimeout()</code></a>.
+It is <code>undefined</code> if a timeout has not been set.</p>
+<h4><code>socket.unref()</code><span><a class="mark" href="#net_socket_unref" id="net_socket_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -44731,7 +48515,7 @@ socket.on(<span class="hljs-string">'timeout'</span>, <span class="hljs-function
 <p>Calling <code>unref()</code> on a socket will allow the program to exit if this is the only
 active socket in the event system. If the socket is already <code>unref</code>ed calling
 <code>unref()</code> again will have no effect.</p>
-<h3><code>socket.write(data[, encoding][, callback])</code><span><a class="mark" href="#net_socket_write_data_encoding_callback" id="net_socket_write_data_encoding_callback">#</a></span></h3>
+<h4><code>socket.write(data[, encoding][, callback])</code><span><a class="mark" href="#net_socket_write_data_encoding_callback" id="net_socket_write_data_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44750,7 +48534,21 @@ buffer. Returns <code>false</code> if all or part of the data was queued in user
 written out, which may not be immediately.</p>
 <p>See <code>Writable</code> stream <a href="#stream_writable_write_chunk_encoding_callback"><code>write()</code></a> method for more
 information.</p>
-<h2><code>net.connect()</code><span><a class="mark" href="#net_net_connect" id="net_net_connect">#</a></span></h2>
+<h4><code>socket.readyState</code><span><a class="mark" href="#net_socket_readystate" id="net_socket_readystate">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.5.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>This property represents the state of the connection as a string.</p>
+<ul>
+<li>If the stream is connecting <code>socket.readyState</code> is <code>opening</code>.</li>
+<li>If the stream is readable and writable, it is <code>open</code>.</li>
+<li>If the stream is readable and not writable, it is <code>readOnly</code>.</li>
+<li>If the stream is not readable and writable, it is <code>writeOnly</code>.</li>
+</ul>
+</section><section><h3><code>net.connect()</code><span><a class="mark" href="#net_net_connect" id="net_net_connect">#</a></span></h3>
 <p>Aliases to
 <a href="#net_net_createconnection"><code>net.createConnection()</code></a>.</p>
 <p>Possible signatures:</p>
@@ -44761,7 +48559,7 @@ connections.</li>
 <li><a href="#net_net_connect_port_host_connectlistener"><code>net.connect(port[, host][, connectListener])</code></a>
 for TCP connections.</li>
 </ul>
-<h3><code>net.connect(options[, connectListener])</code><span><a class="mark" href="#net_net_connect_options_connectlistener" id="net_net_connect_options_connectlistener">#</a></span></h3>
+<h4><code>net.connect(options[, connectListener])</code><span><a class="mark" href="#net_net_connect_options_connectlistener" id="net_net_connect_options_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -44772,7 +48570,7 @@ for TCP connections.</li>
 </ul>
 <p>Alias to
 <a href="#net_net_createconnection_options_connectlistener"><code>net.createConnection(options[, connectListener])</code></a>.</p>
-<h3><code>net.connect(path[, connectListener])</code><span><a class="mark" href="#net_net_connect_path_connectlistener" id="net_net_connect_path_connectlistener">#</a></span></h3>
+<h4><code>net.connect(path[, connectListener])</code><span><a class="mark" href="#net_net_connect_path_connectlistener" id="net_net_connect_path_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44783,7 +48581,7 @@ for TCP connections.</li>
 </ul>
 <p>Alias to
 <a href="#net_net_createconnection_path_connectlistener"><code>net.createConnection(path[, connectListener])</code></a>.</p>
-<h3><code>net.connect(port[, host][, connectListener])</code><span><a class="mark" href="#net_net_connect_port_host_connectlistener" id="net_net_connect_port_host_connectlistener">#</a></span></h3>
+<h4><code>net.connect(port[, host][, connectListener])</code><span><a class="mark" href="#net_net_connect_port_host_connectlistener" id="net_net_connect_port_host_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44795,7 +48593,7 @@ for TCP connections.</li>
 </ul>
 <p>Alias to
 <a href="#net_net_createconnection_port_host_connectlistener"><code>net.createConnection(port[, host][, connectListener])</code></a>.</p>
-<h2><code>net.createConnection()</code><span><a class="mark" href="#net_net_createconnection" id="net_net_createconnection">#</a></span></h2>
+</section><section><h3><code>net.createConnection()</code><span><a class="mark" href="#net_net_createconnection" id="net_net_createconnection">#</a></span></h3>
 <p>A factory function, which creates a new <a href="#net_class_net_socket"><code>net.Socket</code></a>,
 immediately initiates connection with <a href="#net_socket_connect"><code>socket.connect()</code></a>,
 then returns the <code>net.Socket</code> that starts the connection.</p>
@@ -44811,7 +48609,7 @@ for <a href="#net_ipc_support">IPC</a> connections.</li>
 for TCP connections.</li>
 </ul>
 <p>The <a href="#net_net_connect"><code>net.connect()</code></a> function is an alias to this function.</p>
-<h3><code>net.createConnection(options[, connectListener])</code><span><a class="mark" href="#net_net_createconnection_options_connectlistener" id="net_net_createconnection_options_connectlistener">#</a></span></h3>
+<h4><code>net.createConnection(options[, connectListener])</code><span><a class="mark" href="#net_net_createconnection_options_connectlistener" id="net_net_createconnection_options_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44837,21 +48635,21 @@ it starts the connection.</li>
 <p>Following is an example of a client of the echo server described
 in the <a href="#net_net_createserver_options_connectionlistener"><code>net.createServer()</code></a> section:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-<span class="hljs-keyword">const</span> client = net.createConnection({ <span class="hljs-attr">port</span>: <span class="hljs-number">8124</span> }, <span class="hljs-function">() =></span> {
+<span class="hljs-keyword">const</span> client = net.<span class="hljs-title function_">createConnection</span>({ <span class="hljs-attr">port</span>: <span class="hljs-number">8124</span> }, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// 'connect' listener.</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'connected to server!'</span>);
-  client.write(<span class="hljs-string">'world!\r\n'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'connected to server!'</span>);
+  client.<span class="hljs-title function_">write</span>(<span class="hljs-string">'world!\r\n'</span>);
 });
-client.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(data.toString());
-  client.end();
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>());
+  client.<span class="hljs-title function_">end</span>();
 });
-client.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'disconnected from server'</span>);
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'disconnected from server'</span>);
 });</code></pre>
 <p>To connect on the socket <code>/tmp/echo.sock</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> client = net.createConnection({ <span class="hljs-attr">path</span>: <span class="hljs-string">'/tmp/echo.sock'</span> });</code></pre>
-<h3><code>net.createConnection(path[, connectListener])</code><span><a class="mark" href="#net_net_createconnection_path_connectlistener" id="net_net_createconnection_path_connectlistener">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> client = net.<span class="hljs-title function_">createConnection</span>({ <span class="hljs-attr">path</span>: <span class="hljs-string">'/tmp/echo.sock'</span> });</code></pre>
+<h4><code>net.createConnection(path[, connectListener])</code><span><a class="mark" href="#net_net_createconnection_path_connectlistener" id="net_net_createconnection_path_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44870,7 +48668,7 @@ See <a href="#net_identifying_paths_for_ipc_connections">Identifying paths for I
 immediately initiates connection with
 <a href="#net_socket_connect_path_connectlistener"><code>socket.connect(path[, connectListener])</code></a>,
 then returns the <code>net.Socket</code> that starts the connection.</p>
-<h3><code>net.createConnection(port[, host][, connectListener])</code><span><a class="mark" href="#net_net_createconnection_port_host_connectlistener" id="net_net_createconnection_port_host_connectlistener">#</a></span></h3>
+<h4><code>net.createConnection(port[, host][, connectListener])</code><span><a class="mark" href="#net_net_createconnection_port_host_connectlistener" id="net_net_createconnection_port_host_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -44891,15 +48689,16 @@ then returns the <code>net.Socket</code> that starts the connection.</p>
 immediately initiates connection with
 <a href="#net_socket_connect_port_host_connectlistener"><code>socket.connect(port[, host][, connectListener])</code></a>,
 then returns the <code>net.Socket</code> that starts the connection.</p>
-<h2><code>net.createServer([options][, connectionListener])</code><span><a class="mark" href="#net_net_createserver_options_connectionlistener" id="net_net_createserver_options_connectionlistener">#</a></span></h2>
+</section><section><h3><code>net.createServer([options][, connectionListener])</code><span><a class="mark" href="#net_net_createserver_options_connectionlistener" id="net_net_createserver_options_connectionlistener">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether half-opened TCP
-connections are allowed. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If set to <code>false</code>, then the socket will
+automatically end the writable side when the readable side ends.
+<strong>Default:</strong> <code>false</code>.</li>
 <li><code>pauseOnConnect</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether the socket should be
 paused on incoming connections. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
@@ -44910,10 +48709,12 @@ paused on incoming connections. <strong>Default:</strong> <code>false</code>.</l
 </ul>
 <p>Creates a new TCP or <a href="#net_ipc_support">IPC</a> server.</p>
 <p>If <code>allowHalfOpen</code> is set to <code>true</code>, when the other end of the socket
-sends a FIN packet, the server will only send a FIN packet back when
-<a href="#net_socket_end_data_encoding_callback"><code>socket.end()</code></a> is explicitly called, until then the connection is
-half-closed (non-readable but still writable). See <a href="#net_event_end"><code>'end'</code></a> event
-and <a href="https://tools.ietf.org/html/rfc1122">RFC 1122</a> (section 4.2.2.13) for more information.</p>
+signals the end of transmission, the server will only send back the end of
+transmission when <a href="#net_socket_end_data_encoding_callback"><code>socket.end()</code></a> is explicitly called. For example, in the
+context of TCP, when a FIN packed is received, a FIN packed is sent
+back only when <a href="#net_socket_end_data_encoding_callback"><code>socket.end()</code></a> is explicitly called. Until then the
+connection is half-closed (non-readable but still writable). See <a href="#net_event_end"><code>'end'</code></a>
+event and <a href="https://tools.ietf.org/html/rfc1122">RFC 1122</a> (section 4.2.2.13) for more information.</p>
 <p>If <code>pauseOnConnect</code> is set to <code>true</code>, then the socket associated with each
 incoming connection will be paused, and no data will be read from its handle.
 This allows connections to be passed between processes without any data being
@@ -44924,30 +48725,30 @@ read by the original process. To begin reading data from a paused socket, call
 <p>Here is an example of an TCP echo server which listens for connections
 on port 8124:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-<span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">c</span>) =></span> {
+<span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">c</span>) =></span> {
   <span class="hljs-comment">// 'connection' listener.</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'client connected'</span>);
-  c.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'client disconnected'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'client connected'</span>);
+  c.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'client disconnected'</span>);
   });
-  c.write(<span class="hljs-string">'hello\r\n'</span>);
-  c.pipe(c);
+  c.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello\r\n'</span>);
+  c.<span class="hljs-title function_">pipe</span>(c);
 });
-server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">throw</span> err;
 });
-server.listen(<span class="hljs-number">8124</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server bound'</span>);
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8124</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server bound'</span>);
 });</code></pre>
 <p>Test this by using <code>telnet</code>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> telnet localhost 8124</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">telnet localhost 8124</span></code></pre>
 <p>To listen on the socket <code>/tmp/echo.sock</code>:</p>
-<pre><code class="language-js">server.listen(<span class="hljs-string">'/tmp/echo.sock'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server bound'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">listen</span>(<span class="hljs-string">'/tmp/echo.sock'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server bound'</span>);
 });</code></pre>
 <p>Use <code>nc</code> to connect to a Unix domain socket server:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> nc -U /tmp/echo.sock</span></code></pre>
-<h2><code>net.isIP(input)</code><span><a class="mark" href="#net_net_isip_input" id="net_net_isip_input">#</a></span></h2>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">nc -U /tmp/echo.sock</span></code></pre>
+</section><section><h3><code>net.isIP(input)</code><span><a class="mark" href="#net_net_isip_input" id="net_net_isip_input">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -44958,7 +48759,7 @@ server.listen(<span class="hljs-number">8124</span>, <span class="hljs-function"
 <p>Tests if input is an IP address. Returns <code>0</code> for invalid strings,
 returns <code>4</code> for IP version 4 addresses, and returns <code>6</code> for IP version 6
 addresses.</p>
-<h2><code>net.isIPv4(input)</code><span><a class="mark" href="#net_net_isipv4_input" id="net_net_isipv4_input">#</a></span></h2>
+</section><section><h3><code>net.isIPv4(input)</code><span><a class="mark" href="#net_net_isipv4_input" id="net_net_isipv4_input">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -44967,7 +48768,7 @@ addresses.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if input is a version 4 IP address, otherwise returns <code>false</code>.</p>
-<h2><code>net.isIPv6(input)</code><span><a class="mark" href="#net_net_isipv6_input" id="net_net_isipv6_input">#</a></span></h2>
+</section><section><h3><code>net.isIPv6(input)</code><span><a class="mark" href="#net_net_isipv6_input" id="net_net_isipv6_input">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -44975,15 +48776,16 @@ addresses.</p>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Returns <code>true</code> if input is a version 6 IP address, otherwise returns <code>false</code>.</p>
-<h1>OS<span><a class="mark" href="#os_os" id="os_os">#</a></span></h1>
+<p>Returns <code>true</code> if input is a version 6 IP address, otherwise returns <code>false</code>.</p></section>
+        </section>
+<section><h2>OS<span><a class="mark" href="#os_os" id="os_os">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/os.js">lib/os.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/os.js">lib/os.js</a></p>
 <p>The <code>os</code> module provides operating system-related utility methods and
 properties. It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> os = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>);</code></pre>
-<h2><code>os.EOL</code><span><a class="mark" href="#os_os_eol" id="os_os_eol">#</a></span></h2>
+<section><h3><code>os.EOL</code><span><a class="mark" href="#os_os_eol" id="os_os_eol">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.8</span>
 </div>
@@ -44995,7 +48797,7 @@ properties. It can be accessed using:</p>
 <li><code>\n</code> on POSIX</li>
 <li><code>\r\n</code> on Windows</li>
 </ul>
-<h2><code>os.arch()</code><span><a class="mark" href="#os_os_arch" id="os_os_arch">#</a></span></h2>
+</section><section><h3><code>os.arch()</code><span><a class="mark" href="#os_os_arch" id="os_os_arch">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -45006,7 +48808,7 @@ properties. It can be accessed using:</p>
 compiled. Possible values are <code>'arm'</code>, <code>'arm64'</code>, <code>'ia32'</code>, <code>'mips'</code>,
 <code>'mipsel'</code>, <code>'ppc'</code>, <code>'ppc64'</code>, <code>'s390'</code>, <code>'s390x'</code>, <code>'x32'</code>, and <code>'x64'</code>.</p>
 <p>The return value is equivalent to <a href="#process_process_arch"><code>process.arch</code></a>.</p>
-<h2><code>os.constants</code><span><a class="mark" href="#os_os_constants" id="os_os_constants">#</a></span></h2>
+</section><section><h3><code>os.constants</code><span><a class="mark" href="#os_os_constants" id="os_os_constants">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -45016,7 +48818,7 @@ compiled. Possible values are <code>'arm'</code>, <code>'arm64'</code>, <code>'i
 <p>Contains commonly used operating system-specific constants for error codes,
 process signals, and so on. The specific constants defined are described in
 <a href="#os_os_constants_1">OS constants</a>.</p>
-<h2><code>os.cpus()</code><span><a class="mark" href="#os_os_cpus" id="os_os_cpus">#</a></span></h2>
+</section><section><h3><code>os.cpus()</code><span><a class="mark" href="#os_os_cpus" id="os_os_cpus">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -45083,11 +48885,23 @@ process signals, and so on. The specific constants defined are described in
       <span class="hljs-attr">idle</span>: <span class="hljs-number">1070905480</span>,
       <span class="hljs-attr">irq</span>: <span class="hljs-number">20</span>
     }
-  }
+  },
 ]</code></pre>
 <p><code>nice</code> values are POSIX-only. On Windows, the <code>nice</code> values of all processors
 are always 0.</p>
-<h2><code>os.endianness()</code><span><a class="mark" href="#os_os_endianness" id="os_os_endianness">#</a></span></h2>
+</section><section><h3><code>os.devNull</code><span><a class="mark" href="#os_os_devnull" id="os_os_devnull">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>The platform-specific file path of the null device.</p>
+<ul>
+<li><code>\\.\nul</code> on Windows</li>
+<li><code>/dev/null</code> on POSIX</li>
+</ul>
+</section><section><h3><code>os.endianness()</code><span><a class="mark" href="#os_os_endianness" id="os_os_endianness">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -45097,7 +48911,7 @@ are always 0.</p>
 <p>Returns a string identifying the endianness of the CPU for which the Node.js
 binary was compiled.</p>
 <p>Possible values are <code>'BE'</code> for big endian and <code>'LE'</code> for little endian.</p>
-<h2><code>os.freemem()</code><span><a class="mark" href="#os_os_freemem" id="os_os_freemem">#</a></span></h2>
+</section><section><h3><code>os.freemem()</code><span><a class="mark" href="#os_os_freemem" id="os_os_freemem">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -45105,7 +48919,7 @@ binary was compiled.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Returns the amount of free system memory in bytes as an integer.</p>
-<h2><code>os.getPriority([pid])</code><span><a class="mark" href="#os_os_getpriority_pid" id="os_os_getpriority_pid">#</a></span></h2>
+</section><section><h3><code>os.getPriority([pid])</code><span><a class="mark" href="#os_os_getpriority_pid" id="os_os_getpriority_pid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.10.0</span>
 </div>
@@ -45116,7 +48930,7 @@ binary was compiled.</p>
 </ul>
 <p>Returns the scheduling priority for the process specified by <code>pid</code>. If <code>pid</code> is
 not provided or is <code>0</code>, the priority of the current process is returned.</p>
-<h2><code>os.homedir()</code><span><a class="mark" href="#os_os_homedir" id="os_os_homedir">#</a></span></h2>
+</section><section><h3><code>os.homedir()</code><span><a class="mark" href="#os_os_homedir" id="os_os_homedir">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.3.0</span>
 </div>
@@ -45128,7 +48942,7 @@ not provided or is <code>0</code>, the priority of the current process is return
 uses the <a href="https://en.wikipedia.org/wiki/User_identifier#Effective_user_ID">effective UID</a> to look up the user's home directory.</p>
 <p>On Windows, it uses the <code>USERPROFILE</code> environment variable if defined.
 Otherwise it uses the path to the profile directory of the current user.</p>
-<h2><code>os.hostname()</code><span><a class="mark" href="#os_os_hostname" id="os_os_hostname">#</a></span></h2>
+</section><section><h3><code>os.hostname()</code><span><a class="mark" href="#os_os_hostname" id="os_os_hostname">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -45136,7 +48950,7 @@ Otherwise it uses the path to the profile directory of the current user.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Returns the host name of the operating system as a string.</p>
-<h2><code>os.loadavg()</code><span><a class="mark" href="#os_os_loadavg" id="os_os_loadavg">#</a></span></h2>
+</section><section><h3><code>os.loadavg()</code><span><a class="mark" href="#os_os_loadavg" id="os_os_loadavg">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -45148,7 +48962,7 @@ Otherwise it uses the path to the profile directory of the current user.</p>
 system and expressed as a fractional number.</p>
 <p>The load average is a Unix-specific concept. On Windows, the return value is
 always <code>[0, 0, 0]</code>.</p>
-<h2><code>os.networkInterfaces()</code><span><a class="mark" href="#os_os_networkinterfaces" id="os_os_networkinterfaces">#</a></span></h2>
+</section><section><h3><code>os.networkInterfaces()</code><span><a class="mark" href="#os_os_networkinterfaces" id="os_os_networkinterfaces">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span>
 </div>
@@ -45214,7 +49028,7 @@ to <code>null</code>.</li>
     }
   ]
 }</code></pre>
-<h2><code>os.platform()</code><span><a class="mark" href="#os_os_platform" id="os_os_platform">#</a></span></h2>
+</section><section><h3><code>os.platform()</code><span><a class="mark" href="#os_os_platform" id="os_os_platform">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -45226,8 +49040,8 @@ at compile time. Possible values are <code>'aix'</code>, <code>'darwin'</code>,
 <code>'linux'</code>, <code>'openbsd'</code>, <code>'sunos'</code>, and <code>'win32'</code>.</p>
 <p>The return value is equivalent to <a href="#process_process_platform"><code>process.platform</code></a>.</p>
 <p>The value <code>'android'</code> may also be returned if Node.js is built on the Android
-operating system. <a href="https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os">Android support is experimental</a>.</p>
-<h2><code>os.release()</code><span><a class="mark" href="#os_os_release" id="os_os_release">#</a></span></h2>
+operating system. <a href="https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os">Android support is experimental</a>.</p>
+</section><section><h3><code>os.release()</code><span><a class="mark" href="#os_os_release" id="os_os_release">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -45238,7 +49052,7 @@ operating system. <a href="https://github.com/nodejs/node/blob/master/BUILDING.m
 <p>On POSIX systems, the operating system release is determined by calling
 <a href="https://linux.die.net/man/3/uname"><code>uname(3)</code></a>. On Windows, <code>GetVersionExW()</code> is used. See
 <a href="https://en.wikipedia.org/wiki/Uname#Examples">https://en.wikipedia.org/wiki/Uname#Examples</a> for more information.</p>
-<h2><code>os.setPriority([pid, ]priority)</code><span><a class="mark" href="#os_os_setpriority_pid_priority" id="os_os_setpriority_pid_priority">#</a></span></h2>
+</section><section><h3><code>os.setPriority([pid, ]priority)</code><span><a class="mark" href="#os_os_setpriority_pid_priority" id="os_os_setpriority_pid_priority">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.10.0</span>
 </div>
@@ -45258,13 +49072,13 @@ confusion, set <code>priority</code> to one of the priority constants.</p>
 <p>On Windows, setting priority to <code>PRIORITY_HIGHEST</code> requires elevated user
 privileges. Otherwise the set priority will be silently reduced to
 <code>PRIORITY_HIGH</code>.</p>
-<h2><code>os.tmpdir()</code><span><a class="mark" href="#os_os_tmpdir" id="os_os_tmpdir">#</a></span></h2>
+</section><section><h3><code>os.tmpdir()</code><span><a class="mark" href="#os_os_tmpdir" id="os_os_tmpdir">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v2.0.0</td>
-<td><p>This function is now cross-platform consistent and no longer returns a path with a trailing slash on any platform</p></td></tr>
+<td><p>This function is now cross-platform consistent and no longer returns a path with a trailing slash on any platform.</p></td></tr>
 <tr><td>v0.9.9</td>
 <td><p><span>Added in: v0.9.9</span></p></td></tr>
 </tbody></table>
@@ -45275,7 +49089,7 @@ privileges. Otherwise the set priority will be silently reduced to
 </ul>
 <p>Returns the operating system's default directory for temporary files as a
 string.</p>
-<h2><code>os.totalmem()</code><span><a class="mark" href="#os_os_totalmem" id="os_os_totalmem">#</a></span></h2>
+</section><section><h3><code>os.totalmem()</code><span><a class="mark" href="#os_os_totalmem" id="os_os_totalmem">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -45283,7 +49097,7 @@ string.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Returns the total amount of system memory in bytes as an integer.</p>
-<h2><code>os.type()</code><span><a class="mark" href="#os_os_type" id="os_os_type">#</a></span></h2>
+</section><section><h3><code>os.type()</code><span><a class="mark" href="#os_os_type" id="os_os_type">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -45294,7 +49108,7 @@ string.</p>
 returns <code>'Linux'</code> on Linux, <code>'Darwin'</code> on macOS, and <code>'Windows_NT'</code> on Windows.</p>
 <p>See <a href="https://en.wikipedia.org/wiki/Uname#Examples">https://en.wikipedia.org/wiki/Uname#Examples</a> for additional information
 about the output of running <a href="https://linux.die.net/man/3/uname"><code>uname(3)</code></a> on various operating systems.</p>
-<h2><code>os.uptime()</code><span><a class="mark" href="#os_os_uptime" id="os_os_uptime">#</a></span></h2>
+</section><section><h3><code>os.uptime()</code><span><a class="mark" href="#os_os_uptime" id="os_os_uptime">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -45310,7 +49124,7 @@ about the output of running <a href="https://linux.die.net/man/3/uname"><code>un
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Returns the system uptime in number of seconds.</p>
-<h2><code>os.userInfo([options])</code><span><a class="mark" href="#os_os_userinfo_options" id="os_os_userinfo_options">#</a></span></h2>
+</section><section><h3><code>os.userInfo([options])</code><span><a class="mark" href="#os_os_userinfo_options" id="os_os_userinfo_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -45333,9 +49147,9 @@ system. This differs from the result of <code>os.homedir()</code>, which queries
 environment variables for the home directory before falling back to the
 operating system response.</p>
 <p>Throws a <a href="#errors_class_systemerror"><code>SystemError</code></a> if a user has no <code>username</code> or <code>homedir</code>.</p>
-<h2><code>os.version()</code><span><a class="mark" href="#os_os_version" id="os_os_version">#</a></span></h2>
+</section><section><h3><code>os.version()</code><span><a class="mark" href="#os_os_version" id="os_os_version">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.11.0</span>
 </div>
 <ul>
 <li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -45345,10 +49159,10 @@ operating system response.</p>
 <a href="https://linux.die.net/man/3/uname"><code>uname(3)</code></a>. On Windows, <code>RtlGetVersion()</code> is used, and if it is not
 available, <code>GetVersionExW()</code> will be used. See
 <a href="https://en.wikipedia.org/wiki/Uname#Examples">https://en.wikipedia.org/wiki/Uname#Examples</a> for more information.</p>
-<h2>OS constants<span><a class="mark" href="#os_os_constants_1" id="os_os_constants_1">#</a></span></h2>
+</section><section><h3>OS constants<span><a class="mark" href="#os_os_constants_1" id="os_os_constants_1">#</a></span></h3>
 <p>The following constants are exported by <code>os.constants</code>.</p>
 <p>Not all constants will be available on every operating system.</p>
-<h3>Signal constants<span><a class="mark" href="#os_signal_constants" id="os_signal_constants">#</a></span></h3>
+<h4>Signal constants<span><a class="mark" href="#os_signal_constants" id="os_signal_constants">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -45372,7 +49186,7 @@ available, <code>GetVersionExW()</code> will be used. See
   <tr>
     <td><code>SIGINT</code></td>
     <td>Sent to indicate when a user wishes to interrupt a process
-    (<code>(Ctrl+C)</code>).</td>
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>).</td>
   </tr>
   <tr>
     <td><code>SIGQUIT</code></td>
@@ -45519,9 +49333,9 @@ available, <code>GetVersionExW()</code> will be used. See
     <td>Synonym for <code>SIGSYS</code></td>
   </tr>
 </tbody></table>
-<h3>Error constants<span><a class="mark" href="#os_error_constants" id="os_error_constants">#</a></span></h3>
+<h4>Error constants<span><a class="mark" href="#os_error_constants" id="os_error_constants">#</a></span></h4>
 <p>The following error constants are exported by <code>os.constants.errno</code>.</p>
-<h4>POSIX error constants<span><a class="mark" href="#os_posix_error_constants" id="os_posix_error_constants">#</a></span></h4>
+<h5>POSIX error constants<span><a class="mark" href="#os_posix_error_constants" id="os_posix_error_constants">#</a></span></h5>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -45851,7 +49665,7 @@ available, <code>GetVersionExW()</code> will be used. See
     <td>Indicates an improper link.
   </td></tr>
 </tbody></table>
-<h4>Windows-specific error constants<span><a class="mark" href="#os_windows_specific_error_constants" id="os_windows_specific_error_constants">#</a></span></h4>
+<h5>Windows-specific error constants<span><a class="mark" href="#os_windows_specific_error_constants" id="os_windows_specific_error_constants">#</a></span></h5>
 <p>The following error codes are specific to the Windows operating system.</p>
 <table>
   <tbody><tr>
@@ -46093,7 +49907,7 @@ available, <code>GetVersionExW()</code> will be used. See
     <td>Indicates that a database query was refused.</td>
   </tr>
 </tbody></table>
-<h3>dlopen constants<span><a class="mark" href="#os_dlopen_constants" id="os_dlopen_constants">#</a></span></h3>
+<h4>dlopen constants<span><a class="mark" href="#os_dlopen_constants" id="os_dlopen_constants">#</a></span></h4>
 <p>If available on the operating system, the following constants
 are exported in <code>os.constants.dlopen</code>. See <a href="http://man7.org/linux/man-pages/man3/dlopen.3.html"><code>dlopen(3)</code></a> for detailed
 information.</p>
@@ -46127,7 +49941,7 @@ information.</p>
     symbols from previously loaded libraries.</td>
   </tr>
 </tbody></table>
-<h3>Priority constants<span><a class="mark" href="#os_priority_constants" id="os_priority_constants">#</a></span></h3>
+<h4>Priority constants<span><a class="mark" href="#os_priority_constants" id="os_priority_constants">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.10.0</span>
 </div>
@@ -46178,7 +49992,7 @@ information.</p>
     <code>-20</code> on all other platforms.</td>
   </tr>
 </tbody></table>
-<h3>libuv constants<span><a class="mark" href="#os_libuv_constants" id="os_libuv_constants">#</a></span></h3>
+<h4>libuv constants<span><a class="mark" href="#os_libuv_constants" id="os_libuv_constants">#</a></span></h4>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -46188,42 +50002,43 @@ information.</p>
     <td><code>UV_UDP_REUSEADDR</code></td>
     <td></td>
   </tr>
-</tbody></table>
-<h1>Path<span><a class="mark" href="#path_path" id="path_path">#</a></span></h1>
+</tbody></table></section>
+        </section>
+<section><h2>Path<span><a class="mark" href="#path_path" id="path_path">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/path.js">lib/path.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/path.js">lib/path.js</a></p>
 <p>The <code>path</code> module provides utilities for working with file and directory paths.
 It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> path = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);</code></pre>
-<h2>Windows vs. POSIX<span><a class="mark" href="#path_windows_vs_posix" id="path_windows_vs_posix">#</a></span></h2>
+<section><h3>Windows vs. POSIX<span><a class="mark" href="#path_windows_vs_posix" id="path_windows_vs_posix">#</a></span></h3>
 <p>The default operation of the <code>path</code> module varies based on the operating system
 on which a Node.js application is running. Specifically, when running on a
 Windows operating system, the <code>path</code> module will assume that Windows-style
 paths are being used.</p>
 <p>So using <code>path.basename()</code> might yield different results on POSIX and Windows:</p>
 <p>On POSIX:</p>
-<pre><code class="language-js">path.basename(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
 <span class="hljs-comment">// Returns: 'C:\\temp\\myfile.html'</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.basename(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
 <span class="hljs-comment">// Returns: 'myfile.html'</span></code></pre>
 <p>To achieve consistent results when working with Windows file paths on any
 operating system, use <a href="#path_path_win32"><code>path.win32</code></a>:</p>
 <p>On POSIX and Windows:</p>
-<pre><code class="language-js">path.win32.basename(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-property">win32</span>.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
 <span class="hljs-comment">// Returns: 'myfile.html'</span></code></pre>
 <p>To achieve consistent results when working with POSIX file paths on any
 operating system, use <a href="#path_path_posix"><code>path.posix</code></a>:</p>
 <p>On POSIX and Windows:</p>
-<pre><code class="language-js">path.posix.basename(<span class="hljs-string">'/tmp/myfile.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-property">posix</span>.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'/tmp/myfile.html'</span>);
 <span class="hljs-comment">// Returns: 'myfile.html'</span></code></pre>
 <p>On Windows Node.js follows the concept of per-drive working directory.
 This behavior can be observed when using a drive path without a backslash. For
 example, <code>path.resolve('C:\\')</code> can potentially return a different result than
 <code>path.resolve('C:')</code>. For more information, see
 <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths">this MSDN page</a>.</p>
-<h2><code>path.basename(path[, ext])</code><span><a class="mark" href="#path_path_basename_path_ext" id="path_path_basename_path_ext">#</a></span></h2>
+</section><section><h3><code>path.basename(path[, ext])</code><span><a class="mark" href="#path_path_basename_path_ext" id="path_path_basename_path_ext">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -46243,23 +50058,23 @@ example, <code>path.resolve('C:\\')</code> can potentially return a different re
 <p>The <code>path.basename()</code> method returns the last portion of a <code>path</code>, similar to
 the Unix <code>basename</code> command. Trailing directory separators are ignored, see
 <a href="#path_path_sep"><code>path.sep</code></a>.</p>
-<pre><code class="language-js">path.basename(<span class="hljs-string">'/foo/bar/baz/asdf/quux.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'/foo/bar/baz/asdf/quux.html'</span>);
 <span class="hljs-comment">// Returns: 'quux.html'</span>
 
-path.basename(<span class="hljs-string">'/foo/bar/baz/asdf/quux.html'</span>, <span class="hljs-string">'.html'</span>);
+path.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'/foo/bar/baz/asdf/quux.html'</span>, <span class="hljs-string">'.html'</span>);
 <span class="hljs-comment">// Returns: 'quux'</span></code></pre>
 <p>Although Windows usually treats file names, including file extensions, in a
 case-insensitive manner, this function does not. For example, <code>C:\\foo.html</code> and
 <code>C:\\foo.HTML</code> refer to the same file, but <code>basename</code> treats the extension as a
 case-sensitive string:</p>
-<pre><code class="language-js">path.win32.basename(<span class="hljs-string">'C:\\foo.html'</span>, <span class="hljs-string">'.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-property">win32</span>.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\foo.html'</span>, <span class="hljs-string">'.html'</span>);
 <span class="hljs-comment">// Returns: 'foo'</span>
 
-path.win32.basename(<span class="hljs-string">'C:\\foo.HTML'</span>, <span class="hljs-string">'.html'</span>);
+path.<span class="hljs-property">win32</span>.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\foo.HTML'</span>, <span class="hljs-string">'.html'</span>);
 <span class="hljs-comment">// Returns: 'foo.HTML'</span></code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string or if <code>ext</code> is given
 and is not a string.</p>
-<h2><code>path.delimiter</code><span><a class="mark" href="#path_path_delimiter" id="path_path_delimiter">#</a></span></h2>
+</section><section><h3><code>path.delimiter</code><span><a class="mark" href="#path_path_delimiter" id="path_path_delimiter">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -46272,18 +50087,18 @@ and is not a string.</p>
 <li><code>:</code> for POSIX</li>
 </ul>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.env.PATH);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">PATH</span>);
 <span class="hljs-comment">// Prints: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin'</span>
 
-process.env.PATH.split(path.delimiter);
+process.<span class="hljs-property">env</span>.<span class="hljs-property">PATH</span>.<span class="hljs-title function_">split</span>(path.<span class="hljs-property">delimiter</span>);
 <span class="hljs-comment">// Returns: ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.env.PATH);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">PATH</span>);
 <span class="hljs-comment">// Prints: 'C:\Windows\system32;C:\Windows;C:\Program Files\node\'</span>
 
-process.env.PATH.split(path.delimiter);
+process.<span class="hljs-property">env</span>.<span class="hljs-property">PATH</span>.<span class="hljs-title function_">split</span>(path.<span class="hljs-property">delimiter</span>);
 <span class="hljs-comment">// Returns ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\\node\\']</span></code></pre>
-<h2><code>path.dirname(path)</code><span><a class="mark" href="#path_path_dirname_path" id="path_path_dirname_path">#</a></span></h2>
+</section><section><h3><code>path.dirname(path)</code><span><a class="mark" href="#path_path_dirname_path" id="path_path_dirname_path">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -46302,10 +50117,10 @@ process.env.PATH.split(path.delimiter);
 <p>The <code>path.dirname()</code> method returns the directory name of a <code>path</code>, similar to
 the Unix <code>dirname</code> command. Trailing directory separators are ignored, see
 <a href="#path_path_sep"><code>path.sep</code></a>.</p>
-<pre><code class="language-js">path.dirname(<span class="hljs-string">'/foo/bar/baz/asdf/quux'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">dirname</span>(<span class="hljs-string">'/foo/bar/baz/asdf/quux'</span>);
 <span class="hljs-comment">// Returns: '/foo/bar/baz/asdf'</span></code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.extname(path)</code><span><a class="mark" href="#path_path_extname_path" id="path_path_extname_path">#</a></span></h2>
+</section><section><h3><code>path.extname(path)</code><span><a class="mark" href="#path_path_extname_path" id="path_path_extname_path">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -46326,30 +50141,30 @@ occurrence of the <code>.</code> (period) character to end of string in the last
 the <code>path</code>. If there is no <code>.</code> in the last portion of the <code>path</code>, or if
 there are no <code>.</code> characters other than the first character of
 the basename of <code>path</code> (see <code>path.basename()</code>) , an empty string is returned.</p>
-<pre><code class="language-js">path.extname(<span class="hljs-string">'index.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'index.html'</span>);
 <span class="hljs-comment">// Returns: '.html'</span>
 
-path.extname(<span class="hljs-string">'index.coffee.md'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'index.coffee.md'</span>);
 <span class="hljs-comment">// Returns: '.md'</span>
 
-path.extname(<span class="hljs-string">'index.'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'index.'</span>);
 <span class="hljs-comment">// Returns: '.'</span>
 
-path.extname(<span class="hljs-string">'index'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'index'</span>);
 <span class="hljs-comment">// Returns: ''</span>
 
-path.extname(<span class="hljs-string">'.index'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'.index'</span>);
 <span class="hljs-comment">// Returns: ''</span>
 
-path.extname(<span class="hljs-string">'.index.md'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'.index.md'</span>);
 <span class="hljs-comment">// Returns: '.md'</span></code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.format(pathObject)</code><span><a class="mark" href="#path_path_format_pathobject" id="path_path_format_pathobject">#</a></span></h2>
+</section><section><h3><code>path.format(pathObject)</code><span><a class="mark" href="#path_path_format_pathobject" id="path_path_format_pathobject">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
 <ul>
-<li><code>pathObject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>pathObject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Any JavaScript object having the following properties:
 <ul>
 <li><code>dir</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>root</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -46372,7 +50187,7 @@ combinations where one property has priority over another:</p>
 <pre><code class="language-js"><span class="hljs-comment">// If `dir`, `root` and `base` are provided,</span>
 <span class="hljs-comment">// `${dir}${path.sep}${base}`</span>
 <span class="hljs-comment">// will be returned. `root` is ignored.</span>
-path.format({
+path.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">root</span>: <span class="hljs-string">'/ignored'</span>,
   <span class="hljs-attr">dir</span>: <span class="hljs-string">'/home/user/dir'</span>,
   <span class="hljs-attr">base</span>: <span class="hljs-string">'file.txt'</span>
@@ -46382,7 +50197,7 @@ path.format({
 <span class="hljs-comment">// `root` will be used if `dir` is not specified.</span>
 <span class="hljs-comment">// If only `root` is provided or `dir` is equal to `root` then the</span>
 <span class="hljs-comment">// platform separator will not be included. `ext` will be ignored.</span>
-path.format({
+path.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">root</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">base</span>: <span class="hljs-string">'file.txt'</span>,
   <span class="hljs-attr">ext</span>: <span class="hljs-string">'ignored'</span>
@@ -46390,19 +50205,19 @@ path.format({
 <span class="hljs-comment">// Returns: '/file.txt'</span>
 
 <span class="hljs-comment">// `name` + `ext` will be used if `base` is not specified.</span>
-path.format({
+path.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">root</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">name</span>: <span class="hljs-string">'file'</span>,
   <span class="hljs-attr">ext</span>: <span class="hljs-string">'.txt'</span>
 });
 <span class="hljs-comment">// Returns: '/file.txt'</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.format({
+<pre><code class="language-js">path.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">dir</span>: <span class="hljs-string">'C:\\path\\dir'</span>,
   <span class="hljs-attr">base</span>: <span class="hljs-string">'file.txt'</span>
 });
 <span class="hljs-comment">// Returns: 'C:\\path\\dir\\file.txt'</span></code></pre>
-<h2><code>path.isAbsolute(path)</code><span><a class="mark" href="#path_path_isabsolute_path" id="path_path_isabsolute_path">#</a></span></h2>
+</section><section><h3><code>path.isAbsolute(path)</code><span><a class="mark" href="#path_path_isabsolute_path" id="path_path_isabsolute_path">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -46413,20 +50228,20 @@ path.format({
 <p>The <code>path.isAbsolute()</code> method determines if <code>path</code> is an absolute path.</p>
 <p>If the given <code>path</code> is a zero-length string, <code>false</code> will be returned.</p>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js">path.isAbsolute(<span class="hljs-string">'/foo/bar'</span>); <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'/baz/..'</span>);  <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'qux/'</span>);     <span class="hljs-comment">// false</span>
-path.isAbsolute(<span class="hljs-string">'.'</span>);        <span class="hljs-comment">// false</span></code></pre>
+<pre><code class="language-js">path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'/foo/bar'</span>); <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'/baz/..'</span>);  <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'qux/'</span>);     <span class="hljs-comment">// false</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'.'</span>);        <span class="hljs-comment">// false</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.isAbsolute(<span class="hljs-string">'//server'</span>);    <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'\\\\server'</span>);  <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'C:/foo/..'</span>);   <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'C:\\foo\\..'</span>); <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'bar\\baz'</span>);    <span class="hljs-comment">// false</span>
-path.isAbsolute(<span class="hljs-string">'bar/baz'</span>);     <span class="hljs-comment">// false</span>
-path.isAbsolute(<span class="hljs-string">'.'</span>);           <span class="hljs-comment">// false</span></code></pre>
+<pre><code class="language-js">path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'//server'</span>);    <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'\\\\server'</span>);  <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'C:/foo/..'</span>);   <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'C:\\foo\\..'</span>); <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'bar\\baz'</span>);    <span class="hljs-comment">// false</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'bar/baz'</span>);     <span class="hljs-comment">// false</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'.'</span>);           <span class="hljs-comment">// false</span></code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.join([...paths])</code><span><a class="mark" href="#path_path_join_paths" id="path_path_join_paths">#</a></span></h2>
+</section><section><h3><code>path.join([...paths])</code><span><a class="mark" href="#path_path_join_paths" id="path_path_join_paths">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -46439,13 +50254,13 @@ platform-specific separator as a delimiter, then normalizes the resulting path.<
 <p>Zero-length <code>path</code> segments are ignored. If the joined path string is a
 zero-length string then <code>'.'</code> will be returned, representing the current
 working directory.</p>
-<pre><code class="language-js">path.join(<span class="hljs-string">'/foo'</span>, <span class="hljs-string">'bar'</span>, <span class="hljs-string">'baz/asdf'</span>, <span class="hljs-string">'quux'</span>, <span class="hljs-string">'..'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">join</span>(<span class="hljs-string">'/foo'</span>, <span class="hljs-string">'bar'</span>, <span class="hljs-string">'baz/asdf'</span>, <span class="hljs-string">'quux'</span>, <span class="hljs-string">'..'</span>);
 <span class="hljs-comment">// Returns: '/foo/bar/baz/asdf'</span>
 
-path.join(<span class="hljs-string">'foo'</span>, {}, <span class="hljs-string">'bar'</span>);
+path.<span class="hljs-title function_">join</span>(<span class="hljs-string">'foo'</span>, {}, <span class="hljs-string">'bar'</span>);
 <span class="hljs-comment">// Throws 'TypeError: Path must be a string. Received {}'</span></code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if any of the path segments is not a string.</p>
-<h2><code>path.normalize(path)</code><span><a class="mark" href="#path_path_normalize_path" id="path_path_normalize_path">#</a></span></h2>
+</section><section><h3><code>path.normalize(path)</code><span><a class="mark" href="#path_path_normalize_path" id="path_path_normalize_path">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.23</span>
 </div>
@@ -46462,17 +50277,17 @@ instance of the platform-specific path segment separator (<code>/</code> on POSI
 <p>If the <code>path</code> is a zero-length string, <code>'.'</code> is returned, representing the
 current working directory.</p>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js">path.normalize(<span class="hljs-string">'/foo/bar//baz/asdf/quux/..'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">normalize</span>(<span class="hljs-string">'/foo/bar//baz/asdf/quux/..'</span>);
 <span class="hljs-comment">// Returns: '/foo/bar/baz/asdf'</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.normalize(<span class="hljs-string">'C:\\temp\\\\foo\\bar\\..\\'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">normalize</span>(<span class="hljs-string">'C:\\temp\\\\foo\\bar\\..\\'</span>);
 <span class="hljs-comment">// Returns: 'C:\\temp\\foo\\'</span></code></pre>
 <p>Since Windows recognizes multiple path separators, both separators will be
 replaced by instances of the Windows preferred separator (<code>\</code>):</p>
-<pre><code class="language-js">path.win32.normalize(<span class="hljs-string">'C:////temp\\\\/\\/\\/foo/bar'</span>);
+<pre><code class="language-js">path.<span class="hljs-property">win32</span>.<span class="hljs-title function_">normalize</span>(<span class="hljs-string">'C:////temp\\\\/\\/\\/foo/bar'</span>);
 <span class="hljs-comment">// Returns: 'C:\\temp\\foo\\bar'</span></code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.parse(path)</code><span><a class="mark" href="#path_path_parse_path" id="path_path_parse_path">#</a></span></h2>
+</section><section><h3><code>path.parse(path)</code><span><a class="mark" href="#path_path_parse_path" id="path_path_parse_path">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
@@ -46492,7 +50307,7 @@ see <a href="#path_path_sep"><code>path.sep</code></a>.</p>
 <li><code>ext</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js">path.parse(<span class="hljs-string">'/home/user/dir/file.txt'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">parse</span>(<span class="hljs-string">'/home/user/dir/file.txt'</span>);
 <span class="hljs-comment">// Returns:</span>
 <span class="hljs-comment">// { root: '/',</span>
 <span class="hljs-comment">//   dir: '/home/user/dir',</span>
@@ -46507,7 +50322,7 @@ see <a href="#path_path_sep"><code>path.sep</code></a>.</p>
 └──────┴──────────────┴──────┴─────┘
 (All spaces in the "" line should be ignored. They are purely for formatting.)</code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.parse(<span class="hljs-string">'C:\\path\\dir\\file.txt'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">parse</span>(<span class="hljs-string">'C:\\path\\dir\\file.txt'</span>);
 <span class="hljs-comment">// Returns:</span>
 <span class="hljs-comment">// { root: 'C:\\',</span>
 <span class="hljs-comment">//   dir: 'C:\\path\\dir',</span>
@@ -46522,7 +50337,7 @@ see <a href="#path_path_sep"><code>path.sep</code></a>.</p>
 └──────┴──────────────┴──────┴─────┘
 (All spaces in the "" line should be ignored. They are purely for formatting.)</code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.posix</code><span><a class="mark" href="#path_path_posix" id="path_path_posix">#</a></span></h2>
+</section><section><h3><code>path.posix</code><span><a class="mark" href="#path_path_posix" id="path_path_posix">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
@@ -46531,7 +50346,7 @@ see <a href="#path_path_sep"><code>path.sep</code></a>.</p>
 </ul>
 <p>The <code>path.posix</code> property provides access to POSIX specific implementations
 of the <code>path</code> methods.</p>
-<h2><code>path.relative(from, to)</code><span><a class="mark" href="#path_path_relative_from_to" id="path_path_relative_from_to">#</a></span></h2>
+</section><section><h3><code>path.relative(from, to)</code><span><a class="mark" href="#path_path_relative_from_to" id="path_path_relative_from_to">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -46554,13 +50369,13 @@ path (after calling <code>path.resolve()</code> on each), a zero-length string i
 <p>If a zero-length string is passed as <code>from</code> or <code>to</code>, the current working
 directory will be used instead of the zero-length strings.</p>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js">path.relative(<span class="hljs-string">'/data/orandea/test/aaa'</span>, <span class="hljs-string">'/data/orandea/impl/bbb'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">relative</span>(<span class="hljs-string">'/data/orandea/test/aaa'</span>, <span class="hljs-string">'/data/orandea/impl/bbb'</span>);
 <span class="hljs-comment">// Returns: '../../impl/bbb'</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.relative(<span class="hljs-string">'C:\\orandea\\test\\aaa'</span>, <span class="hljs-string">'C:\\orandea\\impl\\bbb'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">relative</span>(<span class="hljs-string">'C:\\orandea\\test\\aaa'</span>, <span class="hljs-string">'C:\\orandea\\impl\\bbb'</span>);
 <span class="hljs-comment">// Returns: '..\\..\\impl\\bbb'</span></code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if either <code>from</code> or <code>to</code> is not a string.</p>
-<h2><code>path.resolve([...paths])</code><span><a class="mark" href="#path_path_resolve_paths" id="path_path_resolve_paths">#</a></span></h2>
+</section><section><h3><code>path.resolve([...paths])</code><span><a class="mark" href="#path_path_resolve_paths" id="path_path_resolve_paths">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -46582,17 +50397,17 @@ path is resolved to the root directory.</p>
 <p>Zero-length <code>path</code> segments are ignored.</p>
 <p>If no <code>path</code> segments are passed, <code>path.resolve()</code> will return the absolute path
 of the current working directory.</p>
-<pre><code class="language-js">path.resolve(<span class="hljs-string">'/foo/bar'</span>, <span class="hljs-string">'./baz'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'/foo/bar'</span>, <span class="hljs-string">'./baz'</span>);
 <span class="hljs-comment">// Returns: '/foo/bar/baz'</span>
 
-path.resolve(<span class="hljs-string">'/foo/bar'</span>, <span class="hljs-string">'/tmp/file/'</span>);
+path.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'/foo/bar'</span>, <span class="hljs-string">'/tmp/file/'</span>);
 <span class="hljs-comment">// Returns: '/tmp/file'</span>
 
-path.resolve(<span class="hljs-string">'wwwroot'</span>, <span class="hljs-string">'static_files/png/'</span>, <span class="hljs-string">'../gif/image.gif'</span>);
+path.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'wwwroot'</span>, <span class="hljs-string">'static_files/png/'</span>, <span class="hljs-string">'../gif/image.gif'</span>);
 <span class="hljs-comment">// If the current working directory is /home/myself/node,</span>
 <span class="hljs-comment">// this returns '/home/myself/node/wwwroot/static_files/gif/image.gif'</span></code></pre>
 <p>A <a href="#errors_class_typeerror"><code>TypeError</code></a> is thrown if any of the arguments is not a string.</p>
-<h2><code>path.sep</code><span><a class="mark" href="#path_path_sep" id="path_path_sep">#</a></span></h2>
+</section><section><h3><code>path.sep</code><span><a class="mark" href="#path_path_sep" id="path_path_sep">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.9</span>
 </div>
@@ -46605,15 +50420,15 @@ path.resolve(<span class="hljs-string">'wwwroot'</span>, <span class="hljs-strin
 <li><code>/</code> on POSIX</li>
 </ul>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js"><span class="hljs-string">'foo/bar/baz'</span>.split(path.sep);
+<pre><code class="language-js"><span class="hljs-string">'foo/bar/baz'</span>.<span class="hljs-title function_">split</span>(path.<span class="hljs-property">sep</span>);
 <span class="hljs-comment">// Returns: ['foo', 'bar', 'baz']</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js"><span class="hljs-string">'foo\\bar\\baz'</span>.split(path.sep);
+<pre><code class="language-js"><span class="hljs-string">'foo\\bar\\baz'</span>.<span class="hljs-title function_">split</span>(path.<span class="hljs-property">sep</span>);
 <span class="hljs-comment">// Returns: ['foo', 'bar', 'baz']</span></code></pre>
 <p>On Windows, both the forward slash (<code>/</code>) and backward slash (<code>\</code>) are accepted
 as path segment separators; however, the <code>path</code> methods only add backward
 slashes (<code>\</code>).</p>
-<h2><code>path.toNamespacedPath(path)</code><span><a class="mark" href="#path_path_tonamespacedpath_path" id="path_path_tonamespacedpath_path">#</a></span></h2>
+</section><section><h3><code>path.toNamespacedPath(path)</code><span><a class="mark" href="#path_path_tonamespacedpath_path" id="path_path_tonamespacedpath_path">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -46626,7 +50441,7 @@ the given <code>path</code>. If <code>path</code> is not a string, <code>path</c
 modifications.</p>
 <p>This method is meaningful only on Windows systems. On POSIX systems, the
 method is non-operational and always returns <code>path</code> without modifications.</p>
-<h2><code>path.win32</code><span><a class="mark" href="#path_path_win32" id="path_path_win32">#</a></span></h2>
+</section><section><h3><code>path.win32</code><span><a class="mark" href="#path_path_win32" id="path_path_win32">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
@@ -46634,11 +50449,12 @@ method is non-operational and always returns <code>path</code> without modificat
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>The <code>path.win32</code> property provides access to Windows-specific implementations
-of the <code>path</code> methods.</p>
-<h1>Performance measurement APIs<span><a class="mark" href="#perf_hooks_performance_measurement_apis" id="perf_hooks_performance_measurement_apis">#</a></span></h1>
+of the <code>path</code> methods.</p></section>
+        </section>
+<section><h2>Performance measurement APIs<span><a class="mark" href="#perf_hooks_performance_measurement_apis" id="perf_hooks_performance_measurement_apis">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/perf_hooks.js">lib/perf_hooks.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/perf_hooks.js">lib/perf_hooks.js</a></p>
 <p>This module provides an implementation of a subset of the W3C
 <a href="https://w3c.github.io/perf-timing-primer/">Web Performance APIs</a> as well as additional APIs for
 Node.js-specific performance measurements.</p>
@@ -46648,29 +50464,29 @@ Node.js-specific performance measurements.</p>
 <li><a href="https://w3c.github.io/performance-timeline/">Performance Timeline</a></li>
 <li><a href="https://www.w3.org/TR/user-timing/">User Timing</a></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { PerformanceObserver, performance } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">PerformanceObserver</span>, performance } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">items</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(items.getEntries()[<span class="hljs-number">0</span>].duration);
-  performance.clearMarks();
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">items</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(items.<span class="hljs-title function_">getEntries</span>()[<span class="hljs-number">0</span>].<span class="hljs-property">duration</span>);
+  performance.<span class="hljs-title function_">clearMarks</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'measure'</span>] });
-performance.measure(<span class="hljs-string">'Start to Now'</span>);
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'measure'</span>] });
+performance.<span class="hljs-title function_">measure</span>(<span class="hljs-string">'Start to Now'</span>);
 
-performance.mark(<span class="hljs-string">'A'</span>);
-doSomeLongRunningProcess(<span class="hljs-function">() =></span> {
-  performance.measure(<span class="hljs-string">'A to Now'</span>, <span class="hljs-string">'A'</span>);
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'A'</span>);
+<span class="hljs-title function_">doSomeLongRunningProcess</span>(<span class="hljs-function">() =></span> {
+  performance.<span class="hljs-title function_">measure</span>(<span class="hljs-string">'A to Now'</span>, <span class="hljs-string">'A'</span>);
 
-  performance.mark(<span class="hljs-string">'B'</span>);
-  performance.measure(<span class="hljs-string">'A to B'</span>, <span class="hljs-string">'A'</span>, <span class="hljs-string">'B'</span>);
+  performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'B'</span>);
+  performance.<span class="hljs-title function_">measure</span>(<span class="hljs-string">'A to B'</span>, <span class="hljs-string">'A'</span>, <span class="hljs-string">'B'</span>);
 });</code></pre>
-<h2><code>perf_hooks.performance</code><span><a class="mark" href="#perf_hooks_perf_hooks_performance" id="perf_hooks_perf_hooks_performance">#</a></span></h2>
+<section><h3><code>perf_hooks.performance</code><span><a class="mark" href="#perf_hooks_perf_hooks_performance" id="perf_hooks_perf_hooks_performance">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>An object that can be used to collect performance metrics from the current
 Node.js instance. It is similar to <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/performance"><code>window.performance</code></a> in browsers.</p>
-<h3><code>performance.clearMarks([name])</code><span><a class="mark" href="#perf_hooks_performance_clearmarks_name" id="perf_hooks_performance_clearmarks_name">#</a></span></h3>
+<h4><code>performance.clearMarks([name])</code><span><a class="mark" href="#perf_hooks_performance_clearmarks_name" id="perf_hooks_performance_clearmarks_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46679,15 +50495,15 @@ Node.js instance. It is similar to <a href="https://developer.mozilla.org/en-US/
 </ul>
 <p>If <code>name</code> is not provided, removes all <code>PerformanceMark</code> objects from the
 Performance Timeline. If <code>name</code> is provided, removes only the named mark.</p>
-<h3><code>performance.eventLoopUtilization([utilization1[, utilization2]])</code><span><a class="mark" href="#perf_hooks_performance_eventlooputilization_utilization1_utilization2" id="perf_hooks_performance_eventlooputilization_utilization1_utilization2">#</a></span></h3>
+<h4><code>performance.eventLoopUtilization([utilization1[, utilization2]])</code><span><a class="mark" href="#perf_hooks_performance_eventlooputilization_utilization1_utilization2" id="perf_hooks_performance_eventlooputilization_utilization1_utilization2">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v14.10.0, v12.19.0</span>
 </div>
 <ul>
 <li><code>utilization1</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to
-  <code>eventLoopUtilization()</code>.</li>
+<code>eventLoopUtilization()</code>.</li>
 <li><code>utilization2</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to
-  <code>eventLoopUtilization()</code> prior to <code>utilization1</code>.</li>
+<code>eventLoopUtilization()</code> prior to <code>utilization1</code>.</li>
 <li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>idle</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
@@ -46701,7 +50517,7 @@ cumulative duration of time the event loop has been both idle and active as a
 high resolution milliseconds timer. The <code>utilization</code> value is the calculated
 Event Loop Utilization (ELU).</p>
 <p>If bootstrapping has not yet finished on the main thread the properties have
-the value of <code>0</code>. The ELU is immediately available on <a href="worker_threads.md#worker_threads_worker_threads">Worker threads</a> since
+the value of <code>0</code>. The ELU is immediately available on <a href="#worker_threads_worker_threads">Worker threads</a> since
 bootstrap happens within the event loop.</p>
 <p>Both <code>utilization1</code> and <code>utilization2</code> are optional parameters.</p>
 <p>If <code>utilization1</code> is passed, then the delta between the current call's <code>active</code>
@@ -46717,13 +50533,13 @@ loop has spent outside the event loop's event provider (e.g. <code>epoll_wait</c
 No other CPU idle time is taken into consideration. The following is an example
 of how a mostly idle process will have a high ELU.</p>
 <pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
-<span class="hljs-keyword">const</span> { eventLoopUtilization } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>).performance;
+<span class="hljs-keyword">const</span> { eventLoopUtilization } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>).<span class="hljs-property">performance</span>;
 <span class="hljs-keyword">const</span> { spawnSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-setImmediate(<span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> elu = eventLoopUtilization();
-  spawnSync(<span class="hljs-string">'sleep'</span>, [<span class="hljs-string">'5'</span>]);
-  <span class="hljs-built_in">console</span>.log(eventLoopUtilization(elu).utilization);
+<span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">const</span> elu = <span class="hljs-title function_">eventLoopUtilization</span>();
+  <span class="hljs-title function_">spawnSync</span>(<span class="hljs-string">'sleep'</span>, [<span class="hljs-string">'5'</span>]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">eventLoopUtilization</span>(elu).<span class="hljs-property">utilization</span>);
 });</code></pre>
 <p>Although the CPU is mostly idle while running this script, the value of
 <code>utilization</code> is <code>1</code>. This is because the call to
@@ -46731,7 +50547,7 @@ setImmediate(<span class="hljs-function">() =></span> {
 <p>Passing in a user-defined object instead of the result of a previous call to
 <code>eventLoopUtilization()</code> will lead to undefined behavior. The return values
 are not guaranteed to reflect any correct state of the event loop.</p>
-<h3><code>performance.mark([name])</code><span><a class="mark" href="#perf_hooks_performance_mark_name" id="perf_hooks_performance_mark_name">#</a></span></h3>
+<h4><code>performance.mark([name])</code><span><a class="mark" href="#perf_hooks_performance_mark_name" id="perf_hooks_performance_mark_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46743,12 +50559,12 @@ are not guaranteed to reflect any correct state of the event loop.</p>
 <code>performanceEntry.entryType</code> is always <code>'mark'</code>, and whose
 <code>performanceEntry.duration</code> is always <code>0</code>. Performance marks are used
 to mark specific significant moments in the Performance Timeline.</p>
-<h3><code>performance.measure(name[, startMark[, endMark]])</code><span><a class="mark" href="#perf_hooks_performance_measure_name_startmark_endmark" id="perf_hooks_performance_measure_name_startmark_endmark">#</a></span></h3>
+<h4><code>performance.measure(name[, startMark[, endMark]])</code><span><a class="mark" href="#perf_hooks_performance_measure_name_startmark_endmark" id="perf_hooks_performance_measure_name_startmark_endmark">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.3</td>
+<tr><td>v14.0.0</td>
 <td><p>Make <code>startMark</code> and <code>endMark</code> parameters optional.</p></td></tr>
 <tr><td>v8.5.0</td>
 <td><p><span>Added in: v8.5.0</span></p></td></tr>
@@ -46774,17 +50590,17 @@ in the Performance Timeline or any of the timestamp properties provided by the
 <code>PerformanceNodeTiming</code> class. <code>endMark</code> will be <code>performance.now()</code>
 if no parameter is passed, otherwise if the named <code>endMark</code> does not exist, an
 error will be thrown.</p>
-<h3><code>performance.nodeTiming</code><span><a class="mark" href="#perf_hooks_performance_nodetiming" id="perf_hooks_performance_nodetiming">#</a></span></h3>
+<h4><code>performance.nodeTiming</code><span><a class="mark" href="#perf_hooks_performance_nodetiming" id="perf_hooks_performance_nodetiming">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <ul>
-<li><a href="#perf_hooks_class_performancenodetiming_extends_performanceentry" class="type">&#x3C;PerformanceNodeTiming></a></li>
+<li><a href="#perf_hooks_class_performancenodetiming" class="type">&#x3C;PerformanceNodeTiming></a></li>
 </ul>
 <p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
 <p>An instance of the <code>PerformanceNodeTiming</code> class that provides performance
 metrics for specific Node.js operational milestones.</p>
-<h3><code>performance.now()</code><span><a class="mark" href="#perf_hooks_performance_now" id="perf_hooks_performance_now">#</a></span></h3>
+<h4><code>performance.now()</code><span><a class="mark" href="#perf_hooks_performance_now" id="perf_hooks_performance_now">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46793,7 +50609,7 @@ metrics for specific Node.js operational milestones.</p>
 </ul>
 <p>Returns the current high resolution millisecond timestamp, where 0 represents
 the start of the current <code>node</code> process.</p>
-<h3><code>performance.timeOrigin</code><span><a class="mark" href="#perf_hooks_performance_timeorigin" id="perf_hooks_performance_timeorigin">#</a></span></h3>
+<h4><code>performance.timeOrigin</code><span><a class="mark" href="#perf_hooks_performance_timeorigin" id="perf_hooks_performance_timeorigin">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46802,7 +50618,7 @@ the start of the current <code>node</code> process.</p>
 </ul>
 <p>The <a href="https://w3c.github.io/hr-time/#dom-performance-timeorigin"><code>timeOrigin</code></a> specifies the high resolution millisecond timestamp at
 which the current <code>node</code> process began, measured in Unix time.</p>
-<h3><code>performance.timerify(fn)</code><span><a class="mark" href="#perf_hooks_performance_timerify_fn" id="perf_hooks_performance_timerify_fn">#</a></span></h3>
+<h4><code>performance.timerify(fn)</code><span><a class="mark" href="#perf_hooks_performance_timerify_fn" id="perf_hooks_performance_timerify_fn">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46815,77 +50631,28 @@ wrapped function. A <code>PerformanceObserver</code> must be subscribed to the <
 event type in order for the timing details to be accessed.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">someFunction</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'hello world'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">someFunction</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello world'</span>);
 }
 
-<span class="hljs-keyword">const</span> wrapped = performance.timerify(someFunction);
+<span class="hljs-keyword">const</span> wrapped = performance.<span class="hljs-title function_">timerify</span>(someFunction);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(list.getEntries()[<span class="hljs-number">0</span>].duration);
-  obs.disconnect();
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(list.<span class="hljs-title function_">getEntries</span>()[<span class="hljs-number">0</span>].<span class="hljs-property">duration</span>);
+  obs.<span class="hljs-title function_">disconnect</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'function'</span>] });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'function'</span>] });
 
 <span class="hljs-comment">// A performance timeline entry will be created</span>
-wrapped();</code></pre>
-<h3><code>performance.eventLoopUtilization([util1][,util2])</code><span><a class="mark" href="#perf_hooks_performance_eventlooputilization_util1_util2" id="perf_hooks_performance_eventlooputilization_util1_util2">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.19.0</span>
-</div>
-<ul>
-<li><code>util1</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to <code>eventLoopUtilization()</code></li>
-<li><code>util2</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to <code>eventLoopUtilization()</code>
-prior to <code>util1</code></li>
-<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>idle</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-<li><code>active</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-<li><code>utilization</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-</li>
-</ul>
-<p>The <code>eventLoopUtilization()</code> method returns an object that contains the
-cumulative duration of time the event loop has been both idle and active as a
-high resolution milliseconds timer. The <code>utilization</code> value is the calculated
-Event Loop Utilization (ELU). If bootstrapping has not yet finished, the
-properties have the value of 0.</p>
-<p><code>util1</code> and <code>util2</code> are optional parameters.</p>
-<p>If <code>util1</code> is passed then the delta between the current call's <code>active</code> and
-<code>idle</code> times are calculated and returned (similar to <a href="#process_process_hrtime_time"><code>process.hrtime()</code></a>).
-Likewise the adjusted <code>utilization</code> value is calculated.</p>
-<p>If <code>util1</code> and <code>util2</code> are both passed then the calculation adjustments are
-done between the two arguments. This is a convenience option because unlike
-<a href="#process_process_hrtime_time"><code>process.hrtime()</code></a> additional work is done to calculate the ELU.</p>
-<p>ELU is similar to CPU utilization except that it is calculated using high
-precision wall-clock time. It represents the percentage of time the event loop
-has spent outside the event loop's event provider (e.g. <code>epoll_wait</code>). No other
-CPU idle time is taken into consideration. The following is an example of how
-a mostly idle process will have a high ELU.</p>
-<!-- eslint-skip -->
-<pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
-<span class="hljs-keyword">const</span> { eventLoopUtilization } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>).performance;
-<span class="hljs-keyword">const</span> { spawnSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-
-setImmediate(<span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> elu = eventLoopUtilization();
-  spawnSync(<span class="hljs-string">'sleep'</span>, [<span class="hljs-string">'5'</span>]);
-  <span class="hljs-built_in">console</span>.log(eventLoopUtilization(elu).utilization);
-});</code></pre>
-<p>Although the CPU is mostly idle while running this script, the value of
-<code>utilization</code> is 1. This is because the call to <a href="#child_process_child_process_spawnsync_command_args_options"><code>child_process.spawnSync()</code></a>
-blocks the event loop from proceeding.</p>
-<p>Passing in a user-defined object instead of the result of a previous call to
-<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values
-are not guaranteed to reflect any correct state of the event loop.</p>
-<h2>Class: <code>PerformanceEntry</code><span><a class="mark" href="#perf_hooks_class_performanceentry" id="perf_hooks_class_performanceentry">#</a></span></h2>
+<span class="hljs-title function_">wrapped</span>();</code></pre>
+</section><section><h3>Class: <code>PerformanceEntry</code><span><a class="mark" href="#perf_hooks_class_performanceentry" id="perf_hooks_class_performanceentry">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
-<h3><code>performanceEntry.duration</code><span><a class="mark" href="#perf_hooks_performanceentry_duration" id="perf_hooks_performanceentry_duration">#</a></span></h3>
+<h4><code>performanceEntry.duration</code><span><a class="mark" href="#perf_hooks_performanceentry_duration" id="perf_hooks_performanceentry_duration">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46894,41 +50661,52 @@ are not guaranteed to reflect any correct state of the event loop.</p>
 </ul>
 <p>The total number of milliseconds elapsed for this entry. This value will not
 be meaningful for all Performance Entry types.</p>
-<h3><code>performanceEntry.name</code><span><a class="mark" href="#perf_hooks_performanceentry_name" id="perf_hooks_performanceentry_name">#</a></span></h3>
+<h4><code>performanceEntry.entryType</code><span><a class="mark" href="#perf_hooks_performanceentry_entrytype" id="perf_hooks_performanceentry_entrytype">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>The name of the performance entry.</p>
-<h3><code>performanceEntry.startTime</code><span><a class="mark" href="#perf_hooks_performanceentry_starttime" id="perf_hooks_performanceentry_starttime">#</a></span></h3>
+<p>The type of the performance entry. It may be one of:</p>
+<ul>
+<li><code>'node'</code> (Node.js only)</li>
+<li><code>'mark'</code> (available on the Web)</li>
+<li><code>'measure'</code> (available on the Web)</li>
+<li><code>'gc'</code> (Node.js only)</li>
+<li><code>'function'</code> (Node.js only)</li>
+<li><code>'http2'</code> (Node.js only)</li>
+<li><code>'http'</code> (Node.js only)</li>
+</ul>
+<h4><code>performanceEntry.flags</code><span><a class="mark" href="#perf_hooks_performanceentry_flags" id="perf_hooks_performanceentry_flags">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v8.5.0</span>
+<span>Added in: v13.9.0, v12.17.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>The high resolution millisecond timestamp marking the starting time of the
-Performance Entry.</p>
-<h3><code>performanceEntry.entryType</code><span><a class="mark" href="#perf_hooks_performanceentry_entrytype" id="perf_hooks_performanceentry_entrytype">#</a></span></h3>
+<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
+<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>
+property contains additional information about garbage collection operation.
+The value may be one of:</p>
+<ul>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>
+</ul>
+<h4><code>performanceEntry.name</code><span><a class="mark" href="#perf_hooks_performanceentry_name" id="perf_hooks_performanceentry_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>The type of the performance entry. It may be one of:</p>
-<ul>
-<li><code>'node'</code> (Node.js only)</li>
-<li><code>'mark'</code> (available on the Web)</li>
-<li><code>'measure'</code> (available on the Web)</li>
-<li><code>'gc'</code> (Node.js only)</li>
-<li><code>'function'</code> (Node.js only)</li>
-<li><code>'http2'</code> (Node.js only)</li>
-<li><code>'http'</code> (Node.js only)</li>
-</ul>
-<h3><code>performanceEntry.kind</code><span><a class="mark" href="#perf_hooks_performanceentry_kind" id="perf_hooks_performanceentry_kind">#</a></span></h3>
+<p>The name of the performance entry.</p>
+<h4><code>performanceEntry.kind</code><span><a class="mark" href="#perf_hooks_performanceentry_kind" id="perf_hooks_performanceentry_kind">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46945,34 +50723,26 @@ The value may be one of:</p>
 <li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL</code></li>
 <li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB</code></li>
 </ul>
-<h3>performanceEntry.flags<span><a class="mark" href="#perf_hooks_performanceentry_flags" id="perf_hooks_performanceentry_flags">#</a></span></h3>
+<h4><code>performanceEntry.startTime</code><span><a class="mark" href="#perf_hooks_performanceentry_starttime" id="perf_hooks_performanceentry_starttime">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v8.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
-<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>
-property contains additional information about garbage collection operation.
-The value may be one of:</p>
-<ul>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>
-</ul>
-<h2>Class: <code>PerformanceNodeTiming extends PerformanceEntry</code><span><a class="mark" href="#perf_hooks_class_performancenodetiming_extends_performanceentry" id="perf_hooks_class_performancenodetiming_extends_performanceentry">#</a></span></h2>
+<p>The high resolution millisecond timestamp marking the starting time of the
+Performance Entry.</p>
+</section><section><h3>Class: <code>PerformanceNodeTiming</code><span><a class="mark" href="#perf_hooks_class_performancenodetiming" id="perf_hooks_class_performancenodetiming">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
+<ul>
+<li>Extends: <a href="#perf_hooks_class_performanceentry" class="type">&#x3C;PerformanceEntry></a></li>
+</ul>
 <p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
 <p>Provides timing details for Node.js itself. The constructor of this class
 is not exposed to users.</p>
-<h3><code>performanceNodeTiming.bootstrapComplete</code><span><a class="mark" href="#perf_hooks_performancenodetiming_bootstrapcomplete" id="perf_hooks_performancenodetiming_bootstrapcomplete">#</a></span></h3>
+<h4><code>performanceNodeTiming.bootstrapComplete</code><span><a class="mark" href="#perf_hooks_performancenodetiming_bootstrapcomplete" id="perf_hooks_performancenodetiming_bootstrapcomplete">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46982,7 +50752,7 @@ is not exposed to users.</p>
 <p>The high resolution millisecond timestamp at which the Node.js process
 completed bootstrapping. If bootstrapping has not yet finished, the property
 has the value of -1.</p>
-<h3><code>performanceNodeTiming.environment</code><span><a class="mark" href="#perf_hooks_performancenodetiming_environment" id="perf_hooks_performancenodetiming_environment">#</a></span></h3>
+<h4><code>performanceNodeTiming.environment</code><span><a class="mark" href="#perf_hooks_performancenodetiming_environment" id="perf_hooks_performancenodetiming_environment">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -46991,7 +50761,19 @@ has the value of -1.</p>
 </ul>
 <p>The high resolution millisecond timestamp at which the Node.js environment was
 initialized.</p>
-<h3><code>performanceNodeTiming.loopExit</code><span><a class="mark" href="#perf_hooks_performancenodetiming_loopexit" id="perf_hooks_performancenodetiming_loopexit">#</a></span></h3>
+<h4><code>performanceNodeTiming.idleTime</code><span><a class="mark" href="#perf_hooks_performancenodetiming_idletime" id="perf_hooks_performancenodetiming_idletime">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.10.0, v12.19.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>The high resolution millisecond timestamp of the amount of time the event loop
+has been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This
+does not take CPU usage into consideration. If the event loop has not yet
+started (e.g., in the first tick of the main script), the property has the
+value of 0.</p>
+<h4><code>performanceNodeTiming.loopExit</code><span><a class="mark" href="#perf_hooks_performancenodetiming_loopexit" id="perf_hooks_performancenodetiming_loopexit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47001,7 +50783,7 @@ initialized.</p>
 <p>The high resolution millisecond timestamp at which the Node.js event loop
 exited. If the event loop has not yet exited, the property has the value of -1.
 It can only have a value of not -1 in a handler of the <a href="#process_event_exit"><code>'exit'</code></a> event.</p>
-<h3><code>performanceNodeTiming.loopStart</code><span><a class="mark" href="#perf_hooks_performancenodetiming_loopstart" id="perf_hooks_performancenodetiming_loopstart">#</a></span></h3>
+<h4><code>performanceNodeTiming.loopStart</code><span><a class="mark" href="#perf_hooks_performancenodetiming_loopstart" id="perf_hooks_performancenodetiming_loopstart">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47011,7 +50793,7 @@ It can only have a value of not -1 in a handler of the <a href="#process_event_e
 <p>The high resolution millisecond timestamp at which the Node.js event loop
 started. If the event loop has not yet started (e.g., in the first tick of the
 main script), the property has the value of -1.</p>
-<h3><code>performanceNodeTiming.nodeStart</code><span><a class="mark" href="#perf_hooks_performancenodetiming_nodestart" id="perf_hooks_performancenodetiming_nodestart">#</a></span></h3>
+<h4><code>performanceNodeTiming.nodeStart</code><span><a class="mark" href="#perf_hooks_performancenodetiming_nodestart" id="perf_hooks_performancenodetiming_nodestart">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47020,7 +50802,7 @@ main script), the property has the value of -1.</p>
 </ul>
 <p>The high resolution millisecond timestamp at which the Node.js process was
 initialized.</p>
-<h3><code>performanceNodeTiming.v8Start</code><span><a class="mark" href="#perf_hooks_performancenodetiming_v8start" id="perf_hooks_performancenodetiming_v8start">#</a></span></h3>
+<h4><code>performanceNodeTiming.v8Start</code><span><a class="mark" href="#perf_hooks_performancenodetiming_v8start" id="perf_hooks_performancenodetiming_v8start">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47029,20 +50811,8 @@ initialized.</p>
 </ul>
 <p>The high resolution millisecond timestamp at which the V8 platform was
 initialized.</p>
-<h3><code>performanceNodeTiming.idleTime</code><span><a class="mark" href="#perf_hooks_performancenodetiming_idletime" id="perf_hooks_performancenodetiming_idletime">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.19.0</span>
-</div>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-<p>The high resolution millisecond timestamp of the amount of time the event loop
-has been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This
-does not take CPU usage into consideration. If the event loop has not yet
-started (e.g., in the first tick of the main script), the property has the
-value of 0.</p>
-<h2>Class: <code>perf_hooks.PerformanceObserver</code><span><a class="mark" href="#perf_hooks_class_perf_hooks_performanceobserver" id="perf_hooks_class_perf_hooks_performanceobserver">#</a></span></h2>
-<h3><code>new PerformanceObserver(callback)</code><span><a class="mark" href="#perf_hooks_new_performanceobserver_callback" id="perf_hooks_new_performanceobserver_callback">#</a></span></h3>
+</section><section><h3>Class: <code>perf_hooks.PerformanceObserver</code><span><a class="mark" href="#perf_hooks_class_perf_hooks_performanceobserver" id="perf_hooks_class_perf_hooks_performanceobserver">#</a></span></h3>
+<h4><code>new PerformanceObserver(callback)</code><span><a class="mark" href="#perf_hooks_new_performanceobserver_callback" id="perf_hooks_new_performanceobserver_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47058,16 +50828,16 @@ value of 0.</p>
 <code>PerformanceEntry</code> instances have been added to the Performance Timeline.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(list.getEntries());
-  observer.disconnect();
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(list.<span class="hljs-title function_">getEntries</span>());
+  observer.<span class="hljs-title function_">disconnect</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
 
-performance.mark(<span class="hljs-string">'test'</span>);</code></pre>
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'test'</span>);</code></pre>
 <p>Because <code>PerformanceObserver</code> instances introduce their own additional
 performance overhead, instances should not be left subscribed to notifications
 indefinitely. Users should disconnect observers as soon as they are no
@@ -47076,12 +50846,12 @@ longer needed.</p>
 notified about new <code>PerformanceEntry</code> instances. The callback receives a
 <code>PerformanceObserverEntryList</code> instance and a reference to the
 <code>PerformanceObserver</code>.</p>
-<h3><code>performanceObserver.disconnect()</code><span><a class="mark" href="#perf_hooks_performanceobserver_disconnect" id="perf_hooks_performanceobserver_disconnect">#</a></span></h3>
+<h4><code>performanceObserver.disconnect()</code><span><a class="mark" href="#perf_hooks_performanceobserver_disconnect" id="perf_hooks_performanceobserver_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>Disconnects the <code>PerformanceObserver</code> instance from all notifications.</p>
-<h3><code>performanceObserver.observe(options)</code><span><a class="mark" href="#perf_hooks_performanceobserver_observe_options" id="perf_hooks_performanceobserver_observe_options">#</a></span></h3>
+<h4><code>performanceObserver.observe(options)</code><span><a class="mark" href="#perf_hooks_performanceobserver_observe_options" id="perf_hooks_performanceobserver_observe_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47104,36 +50874,36 @@ be immediate and synchronous. <strong>Default:</strong> <code>false</code>.</li>
 every <code>PerformanceEntry</code> instance:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
   <span class="hljs-comment">// Called three times synchronously. `list` contains one item.</span>
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>] });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>] });
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; <span class="hljs-number">3</span>; n++)
-  performance.mark(<span class="hljs-string">`test<span class="hljs-subst">${n}</span>`</span>);</code></pre>
+  performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">`test<span class="hljs-subst">${n}</span>`</span>);</code></pre>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
   <span class="hljs-comment">// Called once. `list` contains three items.</span>
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; <span class="hljs-number">3</span>; n++)
-  performance.mark(<span class="hljs-string">`test<span class="hljs-subst">${n}</span>`</span>);</code></pre>
-<h2>Class: <code>PerformanceObserverEntryList</code><span><a class="mark" href="#perf_hooks_class_performanceobserverentrylist" id="perf_hooks_class_performanceobserverentrylist">#</a></span></h2>
+  performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">`test<span class="hljs-subst">${n}</span>`</span>);</code></pre>
+</section><section><h3>Class: <code>PerformanceObserverEntryList</code><span><a class="mark" href="#perf_hooks_class_performanceobserverentrylist" id="perf_hooks_class_performanceobserverentrylist">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>The <code>PerformanceObserverEntryList</code> class is used to provide access to the
 <code>PerformanceEntry</code> instances passed to a <code>PerformanceObserver</code>.
 The constructor of this class is not exposed to users.</p>
-<h3><code>performanceObserverEntryList.getEntries()</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentries" id="perf_hooks_performanceobserverentrylist_getentries">#</a></span></h3>
+<h4><code>performanceObserverEntryList.getEntries()</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentries" id="perf_hooks_performanceobserverentrylist_getentries">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47142,7 +50912,36 @@ The constructor of this class is not exposed to users.</p>
 </ul>
 <p>Returns a list of <code>PerformanceEntry</code> objects in chronological order
 with respect to <code>performanceEntry.startTime</code>.</p>
-<h3><code>performanceObserverEntryList.getEntriesByName(name[, type])</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentriesbyname_name_type" id="perf_hooks_performanceobserverentrylist_getentriesbyname_name_type">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  performance,
+  <span class="hljs-title class_">PerformanceObserver</span>
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">perfObserverList, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntries</span>());
+  <span class="hljs-comment">/**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 81.465639,
+   *     duration: 0
+   *   },
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 81.860064,
+   *     duration: 0
+   *   }
+   * ]
+   */</span>
+  observer.<span class="hljs-title function_">disconnect</span>();
+});
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'test'</span>);
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'meow'</span>);</code></pre>
+<h4><code>performanceObserverEntryList.getEntriesByName(name[, type])</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentriesbyname_name_type" id="perf_hooks_performanceobserverentrylist_getentriesbyname_name_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47155,7 +50954,44 @@ with respect to <code>performanceEntry.startTime</code>.</p>
 with respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.name</code> is
 equal to <code>name</code>, and optionally, whose <code>performanceEntry.entryType</code> is equal to
 <code>type</code>.</p>
-<h3><code>performanceObserverEntryList.getEntriesByType(type)</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentriesbytype_type" id="perf_hooks_performanceobserverentrylist_getentriesbytype_type">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  performance,
+  <span class="hljs-title class_">PerformanceObserver</span>
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">perfObserverList, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByName</span>(<span class="hljs-string">'meow'</span>));
+  <span class="hljs-comment">/**
+   * [
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 98.545991,
+   *     duration: 0
+   *   }
+   * ]
+   */</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByName</span>(<span class="hljs-string">'nope'</span>)); <span class="hljs-comment">// []</span>
+
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByName</span>(<span class="hljs-string">'test'</span>, <span class="hljs-string">'mark'</span>));
+  <span class="hljs-comment">/**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 63.518931,
+   *     duration: 0
+   *   }
+   * ]
+   */</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByName</span>(<span class="hljs-string">'test'</span>, <span class="hljs-string">'measure'</span>)); <span class="hljs-comment">// []</span>
+  observer.<span class="hljs-title function_">disconnect</span>();
+});
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>, <span class="hljs-string">'measure'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'test'</span>);
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'meow'</span>);</code></pre>
+<h4><code>performanceObserverEntryList.getEntriesByType(type)</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentriesbytype_type" id="perf_hooks_performanceobserverentrylist_getentriesbytype_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -47166,7 +51002,54 @@ equal to <code>name</code>, and optionally, whose <code>performanceEntry.entryTy
 <p>Returns a list of <code>PerformanceEntry</code> objects in chronological order
 with respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.entryType</code>
 is equal to <code>type</code>.</p>
-<h2><code>perf_hooks.monitorEventLoopDelay([options])</code><span><a class="mark" href="#perf_hooks_perf_hooks_monitoreventloopdelay_options" id="perf_hooks_perf_hooks_monitoreventloopdelay_options">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  performance,
+  <span class="hljs-title class_">PerformanceObserver</span>
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">perfObserverList, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByType</span>(<span class="hljs-string">'mark'</span>));
+  <span class="hljs-comment">/**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 55.897834,
+   *     duration: 0
+   *   },
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 56.350146,
+   *     duration: 0
+   *   }
+   * ]
+   */</span>
+  observer.<span class="hljs-title function_">disconnect</span>();
+});
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'test'</span>);
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'meow'</span>);</code></pre>
+</section><section><h3><code>perf_hooks.createHistogram([options])</code><span><a class="mark" href="#perf_hooks_perf_hooks_createhistogram_options" id="perf_hooks_perf_hooks_createhistogram_options">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>min</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> The minimum recordable value. Must be an integer
+value greater than 0. <strong>Defaults</strong>: <code>1</code>.</li>
+<li><code>max</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> The maximum recordable value. Must be an integer
+value greater than <code>min</code>. <strong>Defaults</strong>: <code>Number.MAX_SAFE_INTEGER</code>.</li>
+<li><code>figures</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of accuracy digits. Must be a number between
+<code>1</code> and <code>5</code>. <strong>Defaults</strong>: <code>3</code>.</li>
+</ul>
+</li>
+<li>Returns <a href="#perf_hooks_class_recordablehistogram_extends_histogram" class="type">&#x3C;RecordableHistogram></a></li>
+</ul>
+<p>Returns a <a href="#perf_hooks_class_recordablehistogram_extends_histogram" class="type">&#x3C;RecordableHistogram></a>.</p>
+</section><section><h3><code>perf_hooks.monitorEventLoopDelay([options])</code><span><a class="mark" href="#perf_hooks_perf_hooks_monitoreventloopdelay_options" id="perf_hooks_perf_hooks_monitoreventloopdelay_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
 </div>
@@ -47177,53 +51060,32 @@ is equal to <code>type</code>.</p>
 than zero. <strong>Default:</strong> <code>10</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="#perf_hooks_class_histogram" class="type">&#x3C;Histogram></a></li>
+<li>Returns: <a href="#perf_hooks_class_intervalhistogram_extends_histogram" class="type">&#x3C;IntervalHistogram></a></li>
 </ul>
 <p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
-<p>Creates a <code>Histogram</code> object that samples and reports the event loop delay
-over time. The delays will be reported in nanoseconds.</p>
+<p>Creates an <code>IntervalHistogram</code> object that samples and reports the event loop
+delay over time. The delays will be reported in nanoseconds.</p>
 <p>Using a timer to detect approximate event loop delay works because the
 execution of timers is tied specifically to the lifecycle of the libuv
 event loop. That is, a delay in the loop will cause a delay in the execution
 of the timer, and those delays are specifically what this API is intended to
 detect.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { monitorEventLoopDelay } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
-<span class="hljs-keyword">const</span> h = monitorEventLoopDelay({ <span class="hljs-attr">resolution</span>: <span class="hljs-number">20</span> });
-h.enable();
+<span class="hljs-keyword">const</span> h = <span class="hljs-title function_">monitorEventLoopDelay</span>({ <span class="hljs-attr">resolution</span>: <span class="hljs-number">20</span> });
+h.<span class="hljs-title function_">enable</span>();
 <span class="hljs-comment">// Do something.</span>
-h.disable();
-<span class="hljs-built_in">console</span>.log(h.min);
-<span class="hljs-built_in">console</span>.log(h.max);
-<span class="hljs-built_in">console</span>.log(h.mean);
-<span class="hljs-built_in">console</span>.log(h.stddev);
-<span class="hljs-built_in">console</span>.log(h.percentiles);
-<span class="hljs-built_in">console</span>.log(h.percentile(<span class="hljs-number">50</span>));
-<span class="hljs-built_in">console</span>.log(h.percentile(<span class="hljs-number">99</span>));</code></pre>
-<h3>Class: <code>Histogram</code><span><a class="mark" href="#perf_hooks_class_histogram" id="perf_hooks_class_histogram">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v11.10.0</span>
-</div>
-<p>Tracks the event loop delay at a given sampling rate. The constructor of
-this class not exposed to users.</p>
-<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
-<h4><code>histogram.disable()</code><span><a class="mark" href="#perf_hooks_histogram_disable" id="perf_hooks_histogram_disable">#</a></span></h4>
-<div class="api_metadata">
-<span>Added in: v11.10.0</span>
-</div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Disables the event loop delay sample timer. Returns <code>true</code> if the timer was
-stopped, <code>false</code> if it was already stopped.</p>
-<h4><code>histogram.enable()</code><span><a class="mark" href="#perf_hooks_histogram_enable" id="perf_hooks_histogram_enable">#</a></span></h4>
+h.<span class="hljs-title function_">disable</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">min</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">max</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">mean</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">stddev</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">percentiles</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-title function_">percentile</span>(<span class="hljs-number">50</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-title function_">percentile</span>(<span class="hljs-number">99</span>));</code></pre>
+</section><section><h3>Class: <code>Histogram</code><span><a class="mark" href="#perf_hooks_class_histogram" id="perf_hooks_class_histogram">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
 </div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Enables the event loop delay sample timer. Returns <code>true</code> if the timer was
-started, <code>false</code> if it was already started.</p>
 <h4><code>histogram.exceeds</code><span><a class="mark" href="#perf_hooks_histogram_exceeds" id="perf_hooks_histogram_exceeds">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
@@ -47262,7 +51124,7 @@ loop delay threshold.</p>
 <span>Added in: v11.10.0</span>
 </div>
 <ul>
-<li><code>percentile</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A percentile value between 1 and 100.</li>
+<li><code>percentile</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A percentile value in the range (0, 100].</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Returns the value at the given percentile.</p>
@@ -47287,8 +51149,49 @@ loop delay threshold.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>The standard deviation of the recorded event loop delays.</p>
-<h2>Examples<span><a class="mark" href="#perf_hooks_examples" id="perf_hooks_examples">#</a></span></h2>
-<h3>Measuring the duration of async operations<span><a class="mark" href="#perf_hooks_measuring_the_duration_of_async_operations" id="perf_hooks_measuring_the_duration_of_async_operations">#</a></span></h3>
+</section><section><h3>Class: <code>IntervalHistogram extends Histogram</code><span><a class="mark" href="#perf_hooks_class_intervalhistogram_extends_histogram" id="perf_hooks_class_intervalhistogram_extends_histogram">#</a></span></h3>
+<p>A <code>Histogram</code> that is periodically updated on a given interval.</p>
+<h4><code>histogram.disable()</code><span><a class="mark" href="#perf_hooks_histogram_disable" id="perf_hooks_histogram_disable">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v11.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Disables the update interval timer. Returns <code>true</code> if the timer was
+stopped, <code>false</code> if it was already stopped.</p>
+<h4><code>histogram.enable()</code><span><a class="mark" href="#perf_hooks_histogram_enable" id="perf_hooks_histogram_enable">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v11.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Enables the update interval timer. Returns <code>true</code> if the timer was
+started, <code>false</code> if it was already started.</p>
+<h4>Cloning an <code>IntervalHistogram</code><span><a class="mark" href="#perf_hooks_cloning_an_intervalhistogram" id="perf_hooks_cloning_an_intervalhistogram">#</a></span></h4>
+<p><a href="#perf_hooks_class_intervalhistogram_extends_histogram" class="type">&#x3C;IntervalHistogram></a> instances can be cloned via <a href="#worker_threads_class_messageport" class="type">&#x3C;MessagePort></a>. On the receiving
+end, the histogram is cloned as a plain <a href="#perf_hooks_class_histogram" class="type">&#x3C;Histogram></a> object that does not
+implement the <code>enable()</code> and <code>disable()</code> methods.</p>
+</section><section><h3>Class: <code>RecordableHistogram extends Histogram</code><span><a class="mark" href="#perf_hooks_class_recordablehistogram_extends_histogram" id="perf_hooks_class_recordablehistogram_extends_histogram">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<h4><code>histogram.record(val)</code><span><a class="mark" href="#perf_hooks_histogram_record_val" id="perf_hooks_histogram_record_val">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>val</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> The amount to record in the histogram.</li>
+</ul>
+<h4><code>histogram.recordDelta()</code><span><a class="mark" href="#perf_hooks_histogram_recorddelta" id="perf_hooks_histogram_recorddelta">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>Calculates the amount of time (in nanoseconds) that has passed since the
+previous call to <code>recordDelta()</code> and records that amount in the histogram.</p>
+</section><section><h3>Examples<span><a class="mark" href="#perf_hooks_examples" id="perf_hooks_examples">#</a></span></h3>
+<h4>Measuring the duration of async operations<span><a class="mark" href="#perf_hooks_measuring_the_duration_of_async_operations" id="perf_hooks_measuring_the_duration_of_async_operations">#</a></span></h4>
 <p>The following example uses the <a href="async_hooks.html">Async Hooks</a> and Performance APIs to measure
 the actual duration of a Timeout operation (including the amount of time it took
 to execute the callback).</p>
@@ -47296,65 +51199,66 @@ to execute the callback).</p>
 <span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 <span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> set = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>();
-<span class="hljs-keyword">const</span> hook = async_hooks.createHook({
-  init(id, type) {
+<span class="hljs-keyword">const</span> set = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>();
+<span class="hljs-keyword">const</span> hook = async_hooks.<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">id, type</span>) {
     <span class="hljs-keyword">if</span> (type === <span class="hljs-string">'Timeout'</span>) {
-      performance.mark(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Init`</span>);
-      set.add(id);
+      performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Init`</span>);
+      set.<span class="hljs-title function_">add</span>(id);
     }
   },
-  destroy(id) {
-    <span class="hljs-keyword">if</span> (set.has(id)) {
-      set.delete(id);
-      performance.mark(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Destroy`</span>);
-      performance.measure(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>`</span>,
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">id</span>) {
+    <span class="hljs-keyword">if</span> (set.<span class="hljs-title function_">has</span>(id)) {
+      set.<span class="hljs-title function_">delete</span>(id);
+      performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Destroy`</span>);
+      performance.<span class="hljs-title function_">measure</span>(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>`</span>,
                           <span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Init`</span>,
                           <span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Destroy`</span>);
     }
   }
 });
-hook.enable();
+hook.<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(list.getEntries()[<span class="hljs-number">0</span>]);
-  performance.clearMarks();
-  observer.disconnect();
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(list.<span class="hljs-title function_">getEntries</span>()[<span class="hljs-number">0</span>]);
+  performance.<span class="hljs-title function_">clearMarks</span>();
+  observer.<span class="hljs-title function_">disconnect</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'measure'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'measure'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {}, <span class="hljs-number">1000</span>);</code></pre>
-<h3>Measuring how long it takes to load dependencies<span><a class="mark" href="#perf_hooks_measuring_how_long_it_takes_to_load_dependencies" id="perf_hooks_measuring_how_long_it_takes_to_load_dependencies">#</a></span></h3>
+<h4>Measuring how long it takes to load dependencies<span><a class="mark" href="#perf_hooks_measuring_how_long_it_takes_to_load_dependencies" id="perf_hooks_measuring_how_long_it_takes_to_load_dependencies">#</a></span></h4>
 <p>The following example measures the duration of <code>require()</code> operations to load
 dependencies:</p>
 <!-- eslint-disable no-global-assign -->
 <pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
 <span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 <span class="hljs-keyword">const</span> mod = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);
 
 <span class="hljs-comment">// Monkey patch the require function</span>
-mod.Module.prototype.require =
-  performance.timerify(mod.Module.prototype.require);
-<span class="hljs-built_in">require</span> = performance.timerify(<span class="hljs-built_in">require</span>);
+mod.<span class="hljs-property">Module</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">require</span> =
+  performance.<span class="hljs-title function_">timerify</span>(mod.<span class="hljs-property">Module</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">require</span>);
+<span class="hljs-built_in">require</span> = performance.<span class="hljs-title function_">timerify</span>(<span class="hljs-built_in">require</span>);
 
 <span class="hljs-comment">// Activate the observer</span>
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list</span>) =></span> {
-  <span class="hljs-keyword">const</span> entries = list.getEntries();
-  entries.forEach(<span class="hljs-function">(<span class="hljs-params">entry</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`require('<span class="hljs-subst">${entry[<span class="hljs-number">0</span>]}</span>')`</span>, entry.duration);
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list</span>) =></span> {
+  <span class="hljs-keyword">const</span> entries = list.<span class="hljs-title function_">getEntries</span>();
+  entries.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">entry</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`require('<span class="hljs-subst">${entry[<span class="hljs-number">0</span>]}</span>')`</span>, entry.<span class="hljs-property">duration</span>);
   });
-  obs.disconnect();
+  obs.<span class="hljs-title function_">disconnect</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'function'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'function'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
 
-<span class="hljs-built_in">require</span>(<span class="hljs-string">'some-module'</span>);</code></pre>
-<h1>Policies<span><a class="mark" href="#policy_policies" id="policy_policies">#</a></span></h1>
+<span class="hljs-built_in">require</span>(<span class="hljs-string">'some-module'</span>);</code></pre></section>
+        </section>
+<section><h2>Policies<span><a class="mark" href="#policy_policies" id="policy_policies">#</a></span></h2>
 
 
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
@@ -47365,12 +51269,12 @@ about what code Node.js is able to load. The use of policies assumes
 safe practices for the policy files such as ensuring that policy
 files cannot be overwritten by the Node.js application by using
 file permissions.</p>
-<p>A best practice would be to ensure that the policy manifest is read only for
-the running Node.js application, and that the file cannot be changed
+<p>A best practice would be to ensure that the policy manifest is read-only for
+the running Node.js application and that the file cannot be changed
 by the running Node.js application in any way. A typical setup would be to
 create the policy file as a different user id than the one running Node.js
 and granting read permissions to the user id running Node.js.</p>
-<h2>Enabling<span><a class="mark" href="#policy_enabling" id="policy_enabling">#</a></span></h2>
+<section><h3>Enabling<span><a class="mark" href="#policy_enabling" id="policy_enabling">#</a></span></h3>
 
 <p>The <code>--experimental-policy</code> flag can be used to enable features for policies
 when loading modules.</p>
@@ -47384,8 +51288,8 @@ the policy file itself may be provided via <code>--policy-integrity</code>.
 This allows running <code>node</code> and asserting the policy file contents
 even if the file is changed on disk.</p>
 <pre><code class="language-bash">node --experimental-policy=policy.json --policy-integrity=<span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span> app.js</code></pre>
-<h2>Features<span><a class="mark" href="#policy_features" id="policy_features">#</a></span></h2>
-<h3>Error behavior<span><a class="mark" href="#policy_error_behavior" id="policy_error_behavior">#</a></span></h3>
+</section><section><h3>Features<span><a class="mark" href="#policy_features" id="policy_features">#</a></span></h3>
+<h4>Error behavior<span><a class="mark" href="#policy_error_behavior" id="policy_error_behavior">#</a></span></h4>
 <p>When a policy check fails, Node.js by default will throw an error.
 It is possible to change the error behavior to one of a few possibilities
 by defining an "onerror" field in a policy manifest. The following values are
@@ -47397,110 +51301,303 @@ No cleanup code will be allowed to run.</li>
 <li><code>"throw"</code>: will throw a JS error at the site of the failure. This is the
 default.</li>
 </ul>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"onerror"</span>: <span class="hljs-string">"log"</span>,
-  <span class="hljs-attr">"resources"</span>: {
-    <span class="hljs-attr">"./app/checked.js"</span>: {
-      <span class="hljs-attr">"integrity"</span>: <span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span>
-    }
-  }
-}</code></pre>
-<h3>Integrity checks<span><a class="mark" href="#policy_integrity_checks" id="policy_integrity_checks">#</a></span></h3>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"onerror"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"log"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/checked.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h4>Integrity checks<span><a class="mark" href="#policy_integrity_checks" id="policy_integrity_checks">#</a></span></h4>
 <p>Policy files must use integrity checks with Subresource Integrity strings
 compatible with the browser
 <a href="https://www.w3.org/TR/SRI/#the-integrity-attribute">integrity attribute</a>
 associated with absolute URLs.</p>
-<p>When using <code>require()</code> all resources involved in loading are checked for
-integrity if a policy manifest has been specified. If a resource does not match
-the integrity listed in the manifest, an error will be thrown.</p>
+<p>When using <code>require()</code> or <code>import</code> all resources involved in loading are checked
+for integrity if a policy manifest has been specified. If a resource does not
+match the integrity listed in the manifest, an error will be thrown.</p>
 <p>An example policy file that would allow loading a file <code>checked.js</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"resources"</span>: {
-    <span class="hljs-attr">"./app/checked.js"</span>: {
-      <span class="hljs-attr">"integrity"</span>: <span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span>
-    }
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/checked.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Each resource listed in the policy manifest can be of one the following
 formats to determine its location:</p>
 <ol>
-<li>A <a href="https://url.spec.whatwg.org/#relative-url-with-fragment-string">relative url string</a> to a resource from the manifest such as <code>./resource.js</code>, <code>../resource.js</code>, or <code>/resource.js</code>.</li>
-<li>A complete url string to a resource such as <code>file:///resource.js</code>.</li>
+<li>A <a href="https://url.spec.whatwg.org/#relative-url-with-fragment-string">relative-URL string</a> to a resource from the manifest such as <code>./resource.js</code>, <code>../resource.js</code>, or <code>/resource.js</code>.</li>
+<li>A complete URL string to a resource such as <code>file:///resource.js</code>.</li>
 </ol>
 <p>When loading resources the entire URL must match including search parameters
 and hash fragment. <code>./a.js?b</code> will not be used when attempting to load
 <code>./a.js</code> and vice versa.</p>
 <p>To generate integrity strings, a script such as
-<code>printf "sha384-$(cat checked.js | openssl dgst -sha384 -binary | base64)"</code>
+<code>node -e 'process.stdout.write("sha256-");process.stdin.pipe(crypto.createHash("sha256").setEncoding("base64")).pipe(process.stdout)' &#x3C; FILE</code>
 can be used.</p>
 <p>Integrity can be specified as the boolean value <code>true</code> to accept any
 body for the resource which can be useful for local development. It is not
 recommended in production since it would allow unexpected alteration of
 resources to be considered valid.</p>
-<h3>Dependency redirection<span><a class="mark" href="#policy_dependency_redirection" id="policy_dependency_redirection">#</a></span></h3>
+<h4>Dependency redirection<span><a class="mark" href="#policy_dependency_redirection" id="policy_dependency_redirection">#</a></span></h4>
 <p>An application may need to ship patched versions of modules or to prevent
 modules from allowing all modules access to all other modules. Redirection
 can be used by intercepting attempts to load the modules wishing to be
 replaced.</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"builtins"</span>: [],
-  <span class="hljs-attr">"resources"</span>: {
-    <span class="hljs-attr">"./app/checked.js"</span>: {
-      <span class="hljs-attr">"dependencies"</span>: {
-        <span class="hljs-attr">"fs"</span>: <span class="hljs-literal">true</span>,
-        <span class="hljs-attr">"os"</span>: <span class="hljs-string">"./app/node_modules/alt-os"</span>
-      }
-    }
-  }
-}</code></pre>
-<p>The dependencies are keyed by the requested string specifier and have values
-of either <code>true</code> or a string pointing to a module that will be resolved.</p>
-<p>The specifier string does not perform any searching and must match exactly
-what is provided to the <code>require()</code>. Therefore, multiple specifiers may be
-needed in the policy if <code>require()</code> uses multiple different strings to point
-to the same module (such as excluding the extension).</p>
-<p>If the value of the redirection is <code>true</code> the default searching algorithms will
-be used to find the module.</p>
-<p>If the value of the redirection is a string, it will be resolved relative to
-the manifest and then immediately be used without searching.</p>
-<p>Any specifier string that is <code>require()</code>ed and not listed in the dependencies
-will result in an error according to the policy.</p>
-<p>Redirection will not prevent access to APIs through means such as direct access
-to <code>require.cache</code> and/or through <code>module.constructor</code> which allow access to
-loading modules. Policy redirection only affect specifiers to <code>require()</code>.
-Other means such as to prevent undesired access to APIs through variables are
-necessary to lock down that path of loading modules.</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/checked.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"fs"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"os"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/alt-os"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"http"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span> <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span> <span class="hljs-punctuation">}</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>The dependencies are keyed by the requested specifier string and have values
+of either <code>true</code>, <code>null</code>, a string pointing to a module to be resolved,
+or a conditions object.</p>
+<p>The specifier string does not perform any searching and must match exactly what
+is provided to the <code>require()</code> or <code>import</code> except for a canonicalization step.
+Therefore, multiple specifiers may be needed in the policy if it uses multiple
+different strings to point to the same module (such as excluding the extension).</p>
+<p>Specifier strings are canonicalized but not resolved prior to be used for
+matching in order to have some compatibility with import maps, for example if a
+resource <code>file:///C:/app/server.js</code> was given the following redirection from a
+policy located at <code>file:///C:/app/policy.json</code>:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"file:///C:/app/utils.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"./utils.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./utils-v2.js"</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>Any specifier used to load <code>file:///C:/app/utils.js</code> would then be intercepted
+and redirected to <code>file:///C:/app/utils-v2.js</code> instead regardless of using an
+absolute or relative specifier. However, if a specifier that is not an absolute
+or relative URL string is used, it would not be intercepted. So, if an import
+such as <code>import('#utils')</code> was used, it would not be intercepted.</p>
+<p>If the value of the redirection is <code>true</code>, a "dependencies" field at the top of
+the policy file will be used. If that field at the top of the policy file is
+<code>true</code> the default node searching algorithms are used to find the module.</p>
+<p>If the value of the redirection is a string, it is resolved relative to
+the manifest and then immediately used without searching.</p>
+<p>Any specifier string for which resolution is attempted and that is not listed in
+the dependencies results in an error according to the policy.</p>
+<p>Redirection does not prevent access to APIs through means such as direct access
+to <code>require.cache</code> or through <code>module.constructor</code> which allow access to
+loading modules. Policy redirection only affects specifiers to <code>require()</code> and
+<code>import</code>. Other means, such as to prevent undesired access to APIs through
+variables, are necessary to lock down that path of loading modules.</p>
 <p>A boolean value of <code>true</code> for the dependencies map can be specified to allow a
 module to load any specifier without redirection. This can be useful for local
 development and may have some valid usage in production, but should be used
 only with care after auditing a module to ensure its behavior is valid.</p>
-<h4>Example: Patched dependency<span><a class="mark" href="#policy_example_patched_dependency" id="policy_example_patched_dependency">#</a></span></h4>
+<p>Similar to <code>"exports"</code> in <code>package.json</code>, dependencies can also be specified to
+be objects containing conditions which branch how dependencies are loaded. In
+the preceding example, <code>"http"</code> is allowed when the <code>"import"</code> condition is
+part of loading it.</p>
+<p>A value of <code>null</code> for the resolved value causes the resolution to fail. This
+can be used to ensure some kinds of dynamic access are explicitly prevented.</p>
+<p>Unknown values for the resolved module location cause failures but are
+not guaranteed to be forward compatible.</p>
+<h5>Example: Patched dependency<span><a class="mark" href="#policy_example_patched_dependency" id="policy_example_patched_dependency">#</a></span></h5>
 <p>Redirected dependencies can provide attenuated or modified functionality as fits
 the application. For example, log data about timing of function durations by
 wrapping the original:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> original = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fn'</span>);
-<span class="hljs-built_in">module</span>.exports = <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">fn</span>(<span class="hljs-params">...args</span>) </span>{
-  <span class="hljs-built_in">console</span>.time();
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-keyword">function</span> <span class="hljs-title function_">fn</span>(<span class="hljs-params">...args</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">time</span>();
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span>.target ?
-      <span class="hljs-built_in">Reflect</span>.construct(original, args) :
-      <span class="hljs-built_in">Reflect</span>.apply(original, <span class="hljs-built_in">this</span>, args);
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span>.<span class="hljs-property">target</span> ?
+      <span class="hljs-title class_">Reflect</span>.<span class="hljs-title function_">construct</span>(original, args) :
+      <span class="hljs-title class_">Reflect</span>.<span class="hljs-title function_">apply</span>(original, <span class="hljs-variable language_">this</span>, args);
   } <span class="hljs-keyword">finally</span> {
-    <span class="hljs-built_in">console</span>.timeEnd();
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">timeEnd</span>();
   }
 };</code></pre>
-<h1>Process<span><a class="mark" href="#process_process" id="process_process">#</a></span></h1>
-
-
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/process.js">lib/process.js</a></p>
+<h4>Scopes<span><a class="mark" href="#policy_scopes" id="policy_scopes">#</a></span></h4>
+<p>Use the <code>"scopes"</code> field of a manifest to set configuration for many resources
+at once. The <code>"scopes"</code> field works by matching resources by their segments.
+If a scope or resource includes <code>"cascade": true</code>, unknown specifiers will
+be searched for in their containing scope. The containing scope for cascading
+is found by recursively reducing the resource URL by removing segments for
+<a href="https://url.spec.whatwg.org/#special-scheme">special schemes</a>, keeping trailing <code>"/"</code> suffixes, and removing the query and
+hash fragment. This leads to the eventual reduction of the URL to its origin.
+If the URL is non-special the scope will be located by the URL's origin. If no
+scope is found for the origin or in the case of opaque origins, a protocol
+string can be used as a scope. If no scope is found for the URL's protocol, a
+final empty string <code>""</code> scope will be used.</p>
+<p>Note, <code>blob:</code> URLs adopt their origin from the path they contain, and so a scope
+of <code>"blob:https://nodejs.org"</code> will have no effect since no URL can have an
+origin of <code>blob:https://nodejs.org</code>; URLs starting with
+<code>blob:https://nodejs.org/</code> will use <code>https://nodejs.org</code> for its origin and
+thus <code>https:</code> for its protocol scope. For opaque origin <code>blob:</code> URLs they will
+have <code>blob:</code> for their protocol scope since they do not adopt origins.</p>
+<h5>Example<span><a class="mark" href="#policy_example" id="policy_example">#</a></span></h5>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"file:///C:/app/"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span><span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"file:"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span><span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">""</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span><span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>Given a file located at <code>file:///C:/app/bin/main.js</code>, the following scopes would
+be checked in order:</p>
+<ol>
+<li><code>"file:///C:/app/bin/"</code></li>
+</ol>
+<p>This determines the policy for all file based resources within
+<code>"file:///C:/app/bin/"</code>. This is not in the <code>"scopes"</code> field of the policy and
+would be skipped. Adding this scope to the policy would cause it to be used
+prior to the <code>"file:///C:/app/"</code> scope.</p>
+<ol start="2">
+<li><code>"file:///C:/app/"</code></li>
+</ol>
+<p>This determines the policy for all file based resources within
+<code>"file:///C:/app/"</code>. This is in the <code>"scopes"</code> field of the policy and it would
+determine the policy for the resource at <code>file:///C:/app/bin/main.js</code>. If the
+scope has <code>"cascade": true</code>, any unsatisfied queries about the resource would
+delegate to the next relevant scope for <code>file:///C:/app/bin/main.js</code>, <code>"file:"</code>.</p>
+<ol start="3">
+<li><code>"file:///C:/"</code></li>
+</ol>
+<p>This determines the policy for all file based resources within <code>"file:///C:/"</code>.
+This is not in the <code>"scopes"</code> field of the policy and would be skipped. It would
+not be used for <code>file:///C:/app/bin/main.js</code> unless <code>"file:///"</code> is set to
+cascade or is not in the <code>"scopes"</code> of the policy.</p>
+<ol start="4">
+<li><code>"file:///"</code></li>
+</ol>
+<p>This determines the policy for all file based resources on the <code>localhost</code>. This
+is not in the <code>"scopes"</code> field of the policy and would be skipped. It would not
+be used for <code>file:///C:/app/bin/main.js</code> unless <code>"file:///"</code> is set to cascade
+or is not in the <code>"scopes"</code> of the policy.</p>
+<ol start="5">
+<li><code>"file:"</code></li>
+</ol>
+<p>This determines the policy for all file based resources. It would not be used
+for <code>file:///C:/app/bin/main.js</code> unless <code>"file:///"</code> is set to cascade or is not
+in the <code>"scopes"</code> of the policy.</p>
+<ol start="6">
+<li><code>""</code></li>
+</ol>
+<p>This determines the policy for all resources. It would not be used for
+<code>file:///C:/app/bin/main.js</code> unless <code>"file:"</code> is set to cascade.</p>
+<h5>Integrity using scopes<span><a class="mark" href="#policy_integrity_using_scopes" id="policy_integrity_using_scopes">#</a></span></h5>
+<p>Setting an integrity to <code>true</code> on a scope will set the integrity for any
+resource not found in the manifest to <code>true</code>.</p>
+<p>Setting an integrity to <code>null</code> on a scope will set the integrity for any
+resource not found in the manifest to fail matching.</p>
+<p>Not including an integrity is the same as setting the integrity to <code>null</code>.</p>
+<p><code>"cascade"</code> for integrity checks will be ignored if <code>"integrity"</code> is explicitly
+set.</p>
+<p>The following example allows loading any file:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"file:"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h5>Dependency redirection using scopes<span><a class="mark" href="#policy_dependency_redirection_using_scopes" id="policy_dependency_redirection_using_scopes">#</a></span></h5>
+<p>The following example, would allow access to <code>fs</code> for all resources within
+<code>./app/</code>:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/checked.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"cascade"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"fs"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>The following example, would allow access to <code>fs</code> for all <code>data:</code> resources:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"data:text/javascript,import('fs');"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"cascade"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"data:"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"fs"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h5>Example: <a href="https://url.spec.whatwg.org/#relative-url-with-fragment-string">import maps</a> emulation<span><a class="mark" href="#policy_example_import_maps_emulation" id="policy_example_import_maps_emulation">#</a></span></h5>
+<p>Given an import map:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"imports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"react"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/react/index.js"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./ssr/"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"react"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/server-side-react/index.js"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">""</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"cascade"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"react"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/react/index.js"</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./ssr/"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"cascade"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"react"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/server-side-react/index.js"</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>Import maps assume you can get any resource by default. This means
+<code>"dependencies"</code> at the top level of the policy should be set to <code>true</code>.
+Policies require this to be opt-in since it enables all resources of the
+application cross linkage which doesn't make sense for many scenarios. They also
+assume any given scope has access to any scope above its allowed dependencies;
+all scopes emulating import maps must set <code>"cascade": true</code>.</p>
+<p>Import maps only have a single top level scope for their "imports". So for
+emulating <code>"imports"</code> use the <code>""</code> scope. For emulating <code>"scopes"</code> use the
+<code>"scopes"</code> in a similar manner to how <code>"scopes"</code> works in import maps.</p>
+<p>Caveats: Policies do not use string matching for various finding of scope. They
+do URL traversals. This means things like <code>blob:</code> and <code>data:</code> URLs might not be
+entirely interoperable between the two systems. For example import maps can
+partially match a <code>data:</code> or <code>blob:</code> URL by partitioning the URL on a <code>/</code>
+character, policies intentionally cannot. For <code>blob:</code> URLs import map scopes do
+not adopt the origin of the <code>blob:</code> URL.</p>
+<p>Additionally, import maps only work on <code>import</code> so it may be desirable to add a
+<code>"import"</code> condition to all dependency mappings.</p></section>
+        </section>
+<section><h2>Process<span><a class="mark" href="#process_process" id="process_process">#</a></span></h2>
+
+
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/process.js">lib/process.js</a></p>
 <p>The <code>process</code> object is a <code>global</code> that provides information about, and control
 over, the current Node.js process. As a global, it is always available to
 Node.js applications without using <code>require()</code>. It can also be explicitly
 accessed using <code>require()</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> process = <span class="hljs-built_in">require</span>(<span class="hljs-string">'process'</span>);</code></pre>
-<h2>Process events<span><a class="mark" href="#process_process_events" id="process_process_events">#</a></span></h2>
+<section><h3>Process events<span><a class="mark" href="#process_process_events" id="process_process_events">#</a></span></h3>
 <p>The <code>process</code> object is an instance of <a href="#events_class_eventemitter"><code>EventEmitter</code></a>.</p>
-<h3>Event: <code>'beforeExit'</code><span><a class="mark" href="#process_event_beforeexit" id="process_event_beforeexit">#</a></span></h3>
+<h4>Event: <code>'beforeExit'</code><span><a class="mark" href="#process_event_beforeexit" id="process_event_beforeexit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.12</span>
 </div>
@@ -47515,28 +51612,28 @@ continue.</p>
 termination, such as calling <a href="#process_process_exit_code"><code>process.exit()</code></a> or uncaught exceptions.</p>
 <p>The <code>'beforeExit'</code> should <em>not</em> be used as an alternative to the <code>'exit'</code> event
 unless the intention is to schedule additional work.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'beforeExit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Process beforeExit event with code: '</span>, code);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'beforeExit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Process beforeExit event with code: '</span>, code);
 });
 
-process.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Process exit event with code: '</span>, code);
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Process exit event with code: '</span>, code);
 });
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This message is displayed first.'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This message is displayed first.'</span>);
 
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">// This message is displayed first.</span>
 <span class="hljs-comment">// Process beforeExit event with code: 0</span>
 <span class="hljs-comment">// Process exit event with code: 0</span></code></pre>
-<h3>Event: <code>'disconnect'</code><span><a class="mark" href="#process_event_disconnect" id="process_event_disconnect">#</a></span></h3>
+<h4>Event: <code>'disconnect'</code><span><a class="mark" href="#process_event_disconnect" id="process_event_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>If the Node.js process is spawned with an IPC channel (see the <a href="child_process.html">Child Process</a>
 and <a href="cluster.html">Cluster</a> documentation), the <code>'disconnect'</code> event will be emitted when
 the IPC channel is closed.</p>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#process_event_exit" id="process_event_exit">#</a></span></h3>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#process_event_exit" id="process_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.7</span>
 </div>
@@ -47554,19 +51651,19 @@ all <code>'exit'</code> listeners have finished running the Node.js process will
 <p>The listener callback function is invoked with the exit code specified either
 by the <a href="#process_process_exitcode"><code>process.exitCode</code></a> property, or the <code>exitCode</code> argument passed to the
 <a href="#process_process_exit_code"><code>process.exit()</code></a> method.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`About to exit with code: <span class="hljs-subst">${code}</span>`</span>);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`About to exit with code: <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
 <p>Listener functions <strong>must</strong> only perform <strong>synchronous</strong> operations. The Node.js
 process will exit immediately after calling the <code>'exit'</code> event listeners
 causing any additional work still queued in the event loop to be abandoned.
 In the following example, for instance, the timeout will never occur:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
   <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This will not run'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This will not run'</span>);
   }, <span class="hljs-number">0</span>);
 });</code></pre>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#process_event_message" id="process_event_message">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#process_event_message" id="process_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -47586,7 +51683,7 @@ not be the same as what is originally sent.</p>
 process, the <code>message</code> argument can contain data that JSON is not able
 to represent.
 See <a href="#child_process_advanced_serialization">Advanced serialization for <code>child_process</code></a> for more details.</p>
-<h3>Event: <code>'multipleResolves'</code><span><a class="mark" href="#process_event_multipleresolves" id="process_event_multipleresolves">#</a></span></h3>
+<h4>Event: <code>'multipleResolves'</code><span><a class="mark" href="#process_event_multipleresolves" id="process_event_multipleresolves">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -47607,31 +51704,31 @@ rejected after the original resolve.</li>
 <code>Promise</code> constructor, as multiple resolutions are silently swallowed. However,
 the occurrence of this event does not necessarily indicate an error. For
 example, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race"><code>Promise.race()</code></a> can trigger a <code>'multipleResolves'</code> event.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'multipleResolves'</span>, <span class="hljs-function">(<span class="hljs-params">type, promise, reason</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(type, promise, reason);
-  setImmediate(<span class="hljs-function">() =></span> process.exit(<span class="hljs-number">1</span>));
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'multipleResolves'</span>, <span class="hljs-function">(<span class="hljs-params">type, promise, reason</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(type, promise, reason);
+  <span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">1</span>));
 });
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">main</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">main</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">await</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-      resolve(<span class="hljs-string">'First call'</span>);
-      resolve(<span class="hljs-string">'Swallowed resolve'</span>);
-      reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Swallowed reject'</span>));
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">await</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+      <span class="hljs-title function_">resolve</span>(<span class="hljs-string">'First call'</span>);
+      <span class="hljs-title function_">resolve</span>(<span class="hljs-string">'Swallowed resolve'</span>);
+      <span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Swallowed reject'</span>));
     });
   } <span class="hljs-keyword">catch</span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Failed'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Failed'</span>);
   }
 }
 
-main().then(<span class="hljs-built_in">console</span>.log);
+<span class="hljs-title function_">main</span>().<span class="hljs-title function_">then</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>);
 <span class="hljs-comment">// resolve: Promise { 'First call' } 'Swallowed resolve'</span>
 <span class="hljs-comment">// reject: Promise { 'First call' } Error: Swallowed reject</span>
 <span class="hljs-comment">//     at Promise (*)</span>
 <span class="hljs-comment">//     at new Promise (&#x3C;anonymous>)</span>
 <span class="hljs-comment">//     at main (*)</span>
 <span class="hljs-comment">// First call</span></code></pre>
-<h3>Event: <code>'rejectionHandled'</code><span><a class="mark" href="#process_event_rejectionhandled" id="process_event_rejectionhandled">#</a></span></h3>
+<h4>Event: <code>'rejectionHandled'</code><span><a class="mark" href="#process_event_rejectionhandled" id="process_event_rejectionhandled">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.4.1</span>
 </div>
@@ -47656,24 +51753,24 @@ unhandled exceptions grows.</p>
 <p>In asynchronous code, the <code>'unhandledRejection'</code> event is emitted when the list
 of unhandled rejections grows, and the <code>'rejectionHandled'</code> event is emitted
 when the list of unhandled rejections shrinks.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> unhandledRejections = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>();
-process.on(<span class="hljs-string">'unhandledRejection'</span>, <span class="hljs-function">(<span class="hljs-params">reason, promise</span>) =></span> {
-  unhandledRejections.set(promise, reason);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> unhandledRejections = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>();
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'unhandledRejection'</span>, <span class="hljs-function">(<span class="hljs-params">reason, promise</span>) =></span> {
+  unhandledRejections.<span class="hljs-title function_">set</span>(promise, reason);
 });
-process.on(<span class="hljs-string">'rejectionHandled'</span>, <span class="hljs-function">(<span class="hljs-params">promise</span>) =></span> {
-  unhandledRejections.delete(promise);
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'rejectionHandled'</span>, <span class="hljs-function">(<span class="hljs-params">promise</span>) =></span> {
+  unhandledRejections.<span class="hljs-title function_">delete</span>(promise);
 });</code></pre>
 <p>In this example, the <code>unhandledRejections</code> <code>Map</code> will grow and shrink over time,
 reflecting rejections that start unhandled and then become handled. It is
 possible to record such errors in an error log, either periodically (which is
 likely best for long-running application) or upon process exit (which is likely
 most convenient for scripts).</p>
-<h3>Event: <code>'uncaughtException'</code><span><a class="mark" href="#process_event_uncaughtexception" id="process_event_uncaughtexception">#</a></span></h3>
+<h4>Event: <code>'uncaughtException'</code><span><a class="mark" href="#process_event_uncaughtexception" id="process_event_uncaughtexception">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.0.0</td>
+<tr><td>v12.0.0, v10.17.0</td>
 <td><p>Added the <code>origin</code> argument.</p></td></tr>
 <tr><td>v0.1.18</td>
 <td><p><span>Added in: v0.1.18</span></p></td></tr>
@@ -47685,7 +51782,8 @@ most convenient for scripts).</p>
 <li><code>origin</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Indicates if the exception originates from an unhandled
 rejection or from an synchronous error. Can either be <code>'uncaughtException'</code> or
 <code>'unhandledRejection'</code>. The latter is only used in conjunction with the
-<a href="#cli_unhandled_rejections_mode"><code>--unhandled-rejections</code></a> flag set to <code>strict</code> and an unhandled rejection.</li>
+<a href="#cli_unhandled_rejections_mode"><code>--unhandled-rejections</code></a> flag set to <code>strict</code> or <code>throw</code> and
+an unhandled rejection.</li>
 </ul>
 <p>The <code>'uncaughtException'</code> event is emitted when an uncaught JavaScript
 exception bubbles all the way back to the event loop. By default, Node.js
@@ -47696,25 +51794,25 @@ behavior. Alternatively, change the <a href="#process_process_exitcode"><code>pr
 <code>'uncaughtException'</code> handler which will result in the process exiting with the
 provided exit code. Otherwise, in the presence of such handler the process will
 exit with 0.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'uncaughtException'</span>, <span class="hljs-function">(<span class="hljs-params">err, origin</span>) =></span> {
-  fs.writeSync(
-    process.stderr.fd,
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'uncaughtException'</span>, <span class="hljs-function">(<span class="hljs-params">err, origin</span>) =></span> {
+  fs.<span class="hljs-title function_">writeSync</span>(
+    process.<span class="hljs-property">stderr</span>.<span class="hljs-property">fd</span>,
     <span class="hljs-string">`Caught exception: <span class="hljs-subst">${err}</span>\n`</span> +
     <span class="hljs-string">`Exception origin: <span class="hljs-subst">${origin}</span>`</span>
   );
 });
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This will still run.'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This will still run.'</span>);
 }, <span class="hljs-number">500</span>);
 
 <span class="hljs-comment">// Intentionally cause an exception, but don't catch it.</span>
-nonexistentFunc();
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This will not run.'</span>);</code></pre>
+<span class="hljs-title function_">nonexistentFunc</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This will not run.'</span>);</code></pre>
 <p>It is possible to monitor <code>'uncaughtException'</code> events without overriding the
 default behavior to exit the process by installing a
 <code>'uncaughtExceptionMonitor'</code> listener.</p>
-<h4>Warning: Using <code>'uncaughtException'</code> correctly<span><a class="mark" href="#process_warning_using_uncaughtexception_correctly" id="process_warning_using_uncaughtexception_correctly">#</a></span></h4>
+<h5>Warning: Using <code>'uncaughtException'</code> correctly<span><a class="mark" href="#process_warning_using_uncaughtexception_correctly" id="process_warning_using_uncaughtexception_correctly">#</a></span></h5>
 <p><code>'uncaughtException'</code> is a crude mechanism for exception handling
 intended to be used only as a last resort. The event <em>should not</em> be used as
 an equivalent to <code>On Error Resume Next</code>. Unhandled exceptions inherently mean
@@ -47735,15 +51833,17 @@ down the process. <strong>It is not safe to resume normal operation after
 <code>'uncaughtException'</code> is emitted or not, an external monitor should be employed
 in a separate process to detect application failures and recover or restart as
 needed.</p>
-<h3>Event: <code>'uncaughtExceptionMonitor'</code><span><a class="mark" href="#process_event_uncaughtexceptionmonitor" id="process_event_uncaughtexceptionmonitor">#</a></span></h3>
+<h4>Event: <code>'uncaughtExceptionMonitor'</code><span><a class="mark" href="#process_event_uncaughtexceptionmonitor" id="process_event_uncaughtexceptionmonitor">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0</span>
 </div>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> The uncaught exception.</li>
 <li><code>origin</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Indicates if the exception originates from an unhandled
 rejection or from synchronous errors. Can either be <code>'uncaughtException'</code> or
-<code>'unhandledRejection'</code>.</li>
+<code>'unhandledRejection'</code>. The latter is only used in conjunction with the
+<a href="#cli_unhandled_rejections_mode"><code>--unhandled-rejections</code></a> flag set to <code>strict</code> or <code>throw</code> and
+an unhandled rejection.</li>
 </ul>
 <p>The <code>'uncaughtExceptionMonitor'</code> event is emitted before an
 <code>'uncaughtException'</code> event is emitted or a hook installed via
@@ -47751,14 +51851,14 @@ rejection or from synchronous errors. Can either be <code>'uncaughtException'</c
 <p>Installing an <code>'uncaughtExceptionMonitor'</code> listener does not change the behavior
 once an <code>'uncaughtException'</code> event is emitted. The process will
 still crash if no <code>'uncaughtException'</code> listener is installed.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'uncaughtExceptionMonitor'</span>, <span class="hljs-function">(<span class="hljs-params">err, origin</span>) =></span> {
-  MyMonitoringTool.logSync(err, origin);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'uncaughtExceptionMonitor'</span>, <span class="hljs-function">(<span class="hljs-params">err, origin</span>) =></span> {
+  <span class="hljs-title class_">MyMonitoringTool</span>.<span class="hljs-title function_">logSync</span>(err, origin);
 });
 
 <span class="hljs-comment">// Intentionally cause an exception, but don't catch it.</span>
-nonexistentFunc();
+<span class="hljs-title function_">nonexistentFunc</span>();
 <span class="hljs-comment">// Still crashes Node.js</span></code></pre>
-<h3>Event: <code>'unhandledRejection'</code><span><a class="mark" href="#process_event_unhandledrejection" id="process_event_unhandledrejection">#</a></span></h3>
+<h4>Event: <code>'unhandledRejection'</code><span><a class="mark" href="#process_event_unhandledrejection" id="process_event_unhandledrejection">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -47784,22 +51884,22 @@ promises". Rejections can be caught and handled using <a href="https://developer
 are propagated through a <code>Promise</code> chain. The <code>'unhandledRejection'</code> event is
 useful for detecting and keeping track of promises that were rejected whose
 rejections have not yet been handled.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'unhandledRejection'</span>, <span class="hljs-function">(<span class="hljs-params">reason, promise</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Unhandled Rejection at:'</span>, promise, <span class="hljs-string">'reason:'</span>, reason);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'unhandledRejection'</span>, <span class="hljs-function">(<span class="hljs-params">reason, promise</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Unhandled Rejection at:'</span>, promise, <span class="hljs-string">'reason:'</span>, reason);
   <span class="hljs-comment">// Application specific logging, throwing an error, or other logic here</span>
 });
 
-somePromise.then(<span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-keyword">return</span> reportToUser(<span class="hljs-built_in">JSON</span>.pasre(res)); <span class="hljs-comment">// Note the typo (`pasre`)</span>
+somePromise.<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">reportToUser</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">pasre</span>(res)); <span class="hljs-comment">// Note the typo (`pasre`)</span>
 }); <span class="hljs-comment">// No `.catch()` or `.then()`</span></code></pre>
 <p>The following will also trigger the <code>'unhandledRejection'</code> event to be
 emitted:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">SomeResource</span>(<span class="hljs-params"></span>) </span>{
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">SomeResource</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// Initially set the loaded status to a rejected promise</span>
-  <span class="hljs-built_in">this</span>.loaded = <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Resource not yet loaded!'</span>));
+  <span class="hljs-variable language_">this</span>.<span class="hljs-property">loaded</span> = <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Resource not yet loaded!'</span>));
 }
 
-<span class="hljs-keyword">const</span> resource = <span class="hljs-keyword">new</span> SomeResource();
+<span class="hljs-keyword">const</span> resource = <span class="hljs-keyword">new</span> <span class="hljs-title class_">SomeResource</span>();
 <span class="hljs-comment">// no .catch or .then on resource.loaded for at least a turn</span></code></pre>
 <p>In this example case, it is possible to track the rejection as a developer error
 as would typically be the case for other <code>'unhandledRejection'</code> events. To
@@ -47807,7 +51907,7 @@ address such failures, a non-operational
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch"><code>.catch(() => { })</code></a> handler may be attached to
 <code>resource.loaded</code>, which would prevent the <code>'unhandledRejection'</code> event from
 being emitted.</p>
-<h3>Event: <code>'warning'</code><span><a class="mark" href="#process_event_warning" id="process_event_warning">#</a></span></h3>
+<h4>Event: <code>'warning'</code><span><a class="mark" href="#process_event_warning" id="process_event_warning">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -47827,44 +51927,74 @@ conditions that are being brought to the user's attention. However, warnings
 are not part of the normal Node.js and JavaScript error handling flow.
 Node.js can emit warnings whenever it detects bad coding practices that could
 lead to sub-optimal application performance, bugs, or security vulnerabilities.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
-  <span class="hljs-built_in">console</span>.warn(warning.name);    <span class="hljs-comment">// Print the warning name</span>
-  <span class="hljs-built_in">console</span>.warn(warning.message); <span class="hljs-comment">// Print the warning message</span>
-  <span class="hljs-built_in">console</span>.warn(warning.stack);   <span class="hljs-comment">// Print the stack trace</span>
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">name</span>);    <span class="hljs-comment">// Print the warning name</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">message</span>); <span class="hljs-comment">// Print the warning message</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">stack</span>);   <span class="hljs-comment">// Print the stack trace</span>
 });</code></pre>
 <p>By default, Node.js will print process warnings to <code>stderr</code>. The <code>--no-warnings</code>
 command-line option can be used to suppress the default console output but the
 <code>'warning'</code> event will still be emitted by the <code>process</code> object.</p>
 <p>The following example illustrates the warning that is printed to <code>stderr</code> when
 too many listeners have been added to an event:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> events.defaultMaxListeners = 1;</span>
-<span class="hljs-meta">></span><span class="bash"> process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
-<span class="hljs-meta">></span><span class="bash"> process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
-<span class="hljs-meta">></span><span class="bash"> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">events.defaultMaxListeners = 1;</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
+<span class="hljs-meta">> </span><span class="language-bash">(node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak</span>
 detected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit</code></pre>
 <p>In contrast, the following example turns off the default warning output and
 adds a custom handler to the <code>'warning'</code> event:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --no-warnings</span>
-<span class="hljs-meta">></span><span class="bash"> const p = process.on(<span class="hljs-string">'warning'</span>, (warning) => console.warn(<span class="hljs-string">'Do not do that!'</span>));</span>
-<span class="hljs-meta">></span><span class="bash"> events.defaultMaxListeners = 1;</span>
-<span class="hljs-meta">></span><span class="bash"> process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
-<span class="hljs-meta">></span><span class="bash"> process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
-<span class="hljs-meta">></span><span class="bash"> Do not <span class="hljs-keyword">do</span> that!</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --no-warnings</span>
+<span class="hljs-meta">> </span><span class="language-bash">const p = process.on(<span class="hljs-string">'warning'</span>, (warning) => console.warn(<span class="hljs-string">'Do not do that!'</span>));</span>
+<span class="hljs-meta">> </span><span class="language-bash">events.defaultMaxListeners = 1;</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
+<span class="hljs-meta">> </span><span class="language-bash">Do not <span class="hljs-keyword">do</span> that!</span></code></pre>
 <p>The <code>--trace-warnings</code> command-line option can be used to have the default
 console output for warnings include the full stack trace of the warning.</p>
-<p>Launching Node.js using the <code>--throw-deprecation</code> command line flag will
+<p>Launching Node.js using the <code>--throw-deprecation</code> command-line flag will
 cause custom deprecation warnings to be thrown as exceptions.</p>
-<p>Using the <code>--trace-deprecation</code> command line flag will cause the custom
+<p>Using the <code>--trace-deprecation</code> command-line flag will cause the custom
 deprecation to be printed to <code>stderr</code> along with the stack trace.</p>
-<p>Using the <code>--no-deprecation</code> command line flag will suppress all reporting
+<p>Using the <code>--no-deprecation</code> command-line flag will suppress all reporting
 of the custom deprecation.</p>
-<p>The <code>*-deprecation</code> command line flags only affect warnings that use the name
+<p>The <code>*-deprecation</code> command-line flags only affect warnings that use the name
 <code>'DeprecationWarning'</code>.</p>
-<h4>Emitting custom warnings<span><a class="mark" href="#process_emitting_custom_warnings" id="process_emitting_custom_warnings">#</a></span></h4>
+<h4>Event: <code>'worker'</code><span><a class="mark" href="#process_event_worker" id="process_event_worker">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>worker</code> <a href="#worker_threads_class_worker" class="type">&#x3C;Worker></a> The <a href="#worker_threads_class_worker" class="type">&#x3C;Worker></a> that was created.</li>
+</ul>
+<p>The <code>'worker'</code> event is emitted after a new <a href="#worker_threads_class_worker" class="type">&#x3C;Worker></a> thread has been created.</p>
+<h5>Emitting custom warnings<span><a class="mark" href="#process_emitting_custom_warnings" id="process_emitting_custom_warnings">#</a></span></h5>
 <p>See the <a href="#process_process_emitwarning_warning_type_code_ctor"><code>process.emitWarning()</code></a> method for issuing
 custom or application-specific warnings.</p>
-<h3>Signal events<span><a class="mark" href="#process_signal_events" id="process_signal_events">#</a></span></h3>
+<h5>Node.js warning names<span><a class="mark" href="#process_node_js_warning_names" id="process_node_js_warning_names">#</a></span></h5>
+<p>There are no strict guidelines for warning types (as identified by the <code>name</code>
+property) emitted by Node.js. New types of warnings can be added at any time.
+A few of the warning types that are most common include:</p>
+<ul>
+<li><code>'DeprecationWarning'</code> - Indicates use of a deprecated Node.js API or feature.
+Such warnings must include a <code>'code'</code> property identifying the
+<a href="deprecations.html">deprecation code</a>.</li>
+<li><code>'ExperimentalWarning'</code> - Indicates use of an experimental Node.js API or
+feature. Such features must be used with caution as they may change at any
+time and are not subject to the same strict semantic-versioning and long-term
+support policies as supported features.</li>
+<li><code>'MaxListenersExceededWarning'</code> - Indicates that too many listeners for a
+given event have been registered on either an <code>EventEmitter</code> or <code>EventTarget</code>.
+This is often an indication of a memory leak.</li>
+<li><code>'TimeoutOverflowWarning'</code> - Indicates that a numeric value that cannot fit
+within a 32-bit signed integer has been provided to either the <code>setTimeout()</code>
+or <code>setInterval()</code> functions.</li>
+<li><code>'UnsupportedWarning'</code> - Indicates use of an unsupported option or feature
+that will be ignored rather than treated as an error. One example is use of
+the HTTP response status message when using the HTTP/2 compatibility API.</li>
+</ul>
+<h4>Signal events<span><a class="mark" href="#process_signal_events" id="process_signal_events">#</a></span></h4>
 
 
 <p>Signal events will be emitted when the Node.js process receives a signal. Please
@@ -47876,19 +52006,19 @@ refer to <a href="http://man7.org/linux/man-pages/man7/signal.7.html"><code>sign
 <p>The name of each event will be the uppercase common name for the signal (e.g.
 <code>'SIGINT'</code> for <code>SIGINT</code> signals).</p>
 <pre><code class="language-js"><span class="hljs-comment">// Begin reading from stdin so the process does not exit.</span>
-process.stdin.resume();
+process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">resume</span>();
 
-process.on(<span class="hljs-string">'SIGINT'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Received SIGINT. Press Control-D to exit.'</span>);
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGINT'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Received SIGINT. Press Control-D to exit.'</span>);
 });
 
 <span class="hljs-comment">// Using a single function to handle multiple signals</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">handle</span>(<span class="hljs-params">signal</span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received <span class="hljs-subst">${signal}</span>`</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">handle</span>(<span class="hljs-params">signal</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received <span class="hljs-subst">${signal}</span>`</span>);
 }
 
-process.on(<span class="hljs-string">'SIGINT'</span>, handle);
-process.on(<span class="hljs-string">'SIGTERM'</span>, handle);</code></pre>
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGINT'</span>, handle);
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGTERM'</span>, handle);</code></pre>
 <ul>
 <li><code>'SIGUSR1'</code> is reserved by Node.js to start the <a href="debugger.html">debugger</a>. It's possible to
 install a listener but doing so might interfere with the debugger.</li>
@@ -47918,11 +52048,9 @@ when a readable tty is used in raw mode.</li>
 terminate Node.js on all platforms.</li>
 <li><code>'SIGSTOP'</code> cannot have a listener installed.</li>
 <li><code>'SIGBUS'</code>, <code>'SIGFPE'</code>, <code>'SIGSEGV'</code> and <code>'SIGILL'</code>, when not raised
- artificially using <a href="http://man7.org/linux/man-pages/man2/kill.2.html"><code>kill(2)</code></a>, inherently leave the process in a state from
- which it is not safe to attempt to call JS listeners. Doing so might lead to
- the process hanging in an endless loop, since listeners attached using
- <code>process.on()</code> are called asynchronously and therefore unable to correct the
-underlying problem.</li>
+artificially using <a href="http://man7.org/linux/man-pages/man2/kill.2.html"><code>kill(2)</code></a>, inherently leave the process in a state from
+which it is not safe to call JS listeners. Doing so might cause the process
+to stop responding.</li>
 <li><code>0</code> can be sent to test for the existence of a process, it has no effect if
 the process exists, but will throw an error if the process does not exist.</li>
 </ul>
@@ -47936,14 +52064,14 @@ the process was terminated by signal.</li>
 <li>Sending signal <code>0</code> can be used as a platform independent way to test for the
 existence of a process.</li>
 </ul>
-<h2><code>process.abort()</code><span><a class="mark" href="#process_process_abort" id="process_process_abort">#</a></span></h2>
+</section><section><h3><code>process.abort()</code><span><a class="mark" href="#process_process_abort" id="process_process_abort">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
 <p>The <code>process.abort()</code> method causes the Node.js process to exit immediately and
 generate a core file.</p>
 <p>This feature is not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.allowedNodeEnvironmentFlags</code><span><a class="mark" href="#process_process_allowednodeenvironmentflags" id="process_process_allowednodeenvironmentflags">#</a></span></h2>
+</section><section><h3><code>process.allowedNodeEnvironmentFlags</code><span><a class="mark" href="#process_process_allowednodeenvironmentflags" id="process_process_allowednodeenvironmentflags">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.10.0</span>
 </div>
@@ -47973,7 +52101,7 @@ e.g., <code>--stack-trace-limit=100</code>.</li>
 appear only <em>once</em>; each will begin with one or more dashes. Flags
 passed through to V8 will contain underscores instead of non-leading
 dashes:</p>
-<pre><code class="language-js">process.allowedNodeEnvironmentFlags.forEach(<span class="hljs-function">(<span class="hljs-params">flag</span>) =></span> {
+<pre><code class="language-js">process.<span class="hljs-property">allowedNodeEnvironmentFlags</span>.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">flag</span>) =></span> {
   <span class="hljs-comment">// -r</span>
   <span class="hljs-comment">// --inspect-brk</span>
   <span class="hljs-comment">// --abort_on_uncaught_exception</span>
@@ -47985,7 +52113,7 @@ silently.</p>
 <p>If Node.js was compiled <em>without</em> <a href="#cli_node_options_options"><code>NODE_OPTIONS</code></a> support (shown in
 <a href="#process_process_config"><code>process.config</code></a>), <code>process.allowedNodeEnvironmentFlags</code> will
 contain what <em>would have</em> been allowable.</p>
-<h2><code>process.arch</code><span><a class="mark" href="#process_process_arch" id="process_process_arch">#</a></span></h2>
+</section><section><h3><code>process.arch</code><span><a class="mark" href="#process_process_arch" id="process_process_arch">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -47995,34 +52123,34 @@ contain what <em>would have</em> been allowable.</p>
 <p>The operating system CPU architecture for which the Node.js binary was compiled.
 Possible values are: <code>'arm'</code>, <code>'arm64'</code>, <code>'ia32'</code>, <code>'mips'</code>,<code>'mipsel'</code>, <code>'ppc'</code>,
 <code>'ppc64'</code>, <code>'s390'</code>, <code>'s390x'</code>, <code>'x32'</code>, and <code>'x64'</code>.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`This processor architecture is <span class="hljs-subst">${process.arch}</span>`</span>);</code></pre>
-<h2><code>process.argv</code><span><a class="mark" href="#process_process_argv" id="process_process_argv">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`This processor architecture is <span class="hljs-subst">${process.arch}</span>`</span>);</code></pre>
+</section><section><h3><code>process.argv</code><span><a class="mark" href="#process_process_argv" id="process_process_argv">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
-<p>The <code>process.argv</code> property returns an array containing the command line
+<p>The <code>process.argv</code> property returns an array containing the command-line
 arguments passed when the Node.js process was launched. The first element will
 be <a href="#process_process_execpath"><code>process.execPath</code></a>. See <code>process.argv0</code> if access to the original value
 of <code>argv[0]</code> is needed. The second element will be the path to the JavaScript
-file being executed. The remaining elements will be any additional command line
+file being executed. The remaining elements will be any additional command-line
 arguments.</p>
 <p>For example, assuming the following script for <code>process-args.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-comment">// print process.argv</span>
-process.argv.forEach(<span class="hljs-function">(<span class="hljs-params">val, index</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${index}</span>: <span class="hljs-subst">${val}</span>`</span>);
+process.<span class="hljs-property">argv</span>.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">val, index</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${index}</span>: <span class="hljs-subst">${val}</span>`</span>);
 });</code></pre>
 <p>Launching the Node.js process as:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node process-args.js one two=three four</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node process-args.js one two=three four</span></code></pre>
 <p>Would generate the output:</p>
 <pre><code class="language-text">0: /usr/local/bin/node
 1: /Users/mjr/work/node/process-args.js
 2: one
 3: two=three
 4: four</code></pre>
-<h2><code>process.argv0</code><span><a class="mark" href="#process_process_argv0" id="process_process_argv0">#</a></span></h2>
+</section><section><h3><code>process.argv0</code><span><a class="mark" href="#process_process_argv0" id="process_process_argv0">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.4.0</span>
 </div>
@@ -48031,14 +52159,22 @@ process.argv.forEach(<span class="hljs-function">(<span class="hljs-params">val,
 </ul>
 <p>The <code>process.argv0</code> property stores a read-only copy of the original value of
 <code>argv[0]</code> passed when Node.js starts.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> bash -c <span class="hljs-string">'exec -a customArgv0 ./node'</span></span>
-<span class="hljs-meta">></span><span class="bash"> process.argv[0]</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">bash -c <span class="hljs-string">'exec -a customArgv0 ./node'</span></span>
+<span class="hljs-meta">> </span><span class="language-bash">process.argv[0]</span>
 '/Volumes/code/external/node/out/Release/node'
-<span class="hljs-meta">></span><span class="bash"> process.argv0</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.argv0</span>
 'customArgv0'</code></pre>
-<h2><code>process.channel</code><span><a class="mark" href="#process_process_channel" id="process_process_channel">#</a></span></h2>
+</section><section><h3><code>process.channel</code><span><a class="mark" href="#process_process_channel" id="process_process_channel">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v7.1.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The object no longer accidentally exposes native C++ bindings.</p></td></tr>
+<tr><td>v7.1.0</td>
+<td><p><span>Added in: v7.1.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
@@ -48047,7 +52183,25 @@ process.argv.forEach(<span class="hljs-function">(<span class="hljs-params">val,
 <a href="child_process.html">Child Process</a> documentation), the <code>process.channel</code>
 property is a reference to the IPC channel. If no IPC channel exists, this
 property is <code>undefined</code>.</p>
-<h2><code>process.chdir(directory)</code><span><a class="mark" href="#process_process_chdir_directory" id="process_process_chdir_directory">#</a></span></h2>
+<h4><code>process.channel.ref()</code><span><a class="mark" href="#process_process_channel_ref" id="process_process_channel_ref">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v7.1.0</span>
+</div>
+<p>This method makes the IPC channel keep the event loop of the process
+running if <code>.unref()</code> has been called before.</p>
+<p>Typically, this is managed through the number of <code>'disconnect'</code> and <code>'message'</code>
+listeners on the <code>process</code> object. However, this method can be used to
+explicitly request a specific behavior.</p>
+<h4><code>process.channel.unref()</code><span><a class="mark" href="#process_process_channel_unref" id="process_process_channel_unref">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v7.1.0</span>
+</div>
+<p>This method makes the IPC channel not keep the event loop of the process
+running, and lets it finish even while the channel is open.</p>
+<p>Typically, this is managed through the number of <code>'disconnect'</code> and <code>'message'</code>
+listeners on the <code>process</code> object. However, this method can be used to
+explicitly request a specific behavior.</p>
+</section><section><h3><code>process.chdir(directory)</code><span><a class="mark" href="#process_process_chdir_directory" id="process_process_chdir_directory">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
@@ -48057,15 +52211,15 @@ property is <code>undefined</code>.</p>
 <p>The <code>process.chdir()</code> method changes the current working directory of the
 Node.js process or throws an exception if doing so fails (for instance, if
 the specified <code>directory</code> does not exist).</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Starting directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Starting directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);
 <span class="hljs-keyword">try</span> {
-  process.chdir(<span class="hljs-string">'/tmp'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);
+  process.<span class="hljs-title function_">chdir</span>(<span class="hljs-string">'/tmp'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`chdir: <span class="hljs-subst">${err}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`chdir: <span class="hljs-subst">${err}</span>`</span>);
 }</code></pre>
 <p>This feature is not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.config</code><span><a class="mark" href="#process_process_config" id="process_process_config">#</a></span></h2>
+</section><section><h3><code>process.config</code><span><a class="mark" href="#process_process_config" id="process_process_config">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -48106,7 +52260,7 @@ running the <code>./configure</code> script.</p>
 <p>The <code>process.config</code> property is <strong>not</strong> read-only and there are existing
 modules in the ecosystem that are known to extend, modify, or entirely replace
 the value of <code>process.config</code>.</p>
-<h2><code>process.connected</code><span><a class="mark" href="#process_process_connected" id="process_process_connected">#</a></span></h2>
+</section><section><h3><code>process.connected</code><span><a class="mark" href="#process_process_connected" id="process_process_connected">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -48119,7 +52273,7 @@ and <a href="cluster.html">Cluster</a> documentation), the <code>process.connect
 <code>process.disconnect()</code> is called.</p>
 <p>Once <code>process.connected</code> is <code>false</code>, it is no longer possible to send messages
 over the IPC channel using <code>process.send()</code>.</p>
-<h2><code>process.cpuUsage([previousValue])</code><span><a class="mark" href="#process_process_cpuusage_previousvalue" id="process_process_cpuusage_previousvalue">#</a></span></h2>
+</section><section><h3><code>process.cpuUsage([previousValue])</code><span><a class="mark" href="#process_process_cpuusage_previousvalue" id="process_process_cpuusage_previousvalue">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.1.0</span>
 </div>
@@ -48140,16 +52294,16 @@ spent in user and system code respectively, and may end up being greater than
 actual elapsed time if multiple CPU cores are performing work for this process.</p>
 <p>The result of a previous call to <code>process.cpuUsage()</code> can be passed as the
 argument to the function, to get a diff reading.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> startUsage = process.cpuUsage();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> startUsage = process.<span class="hljs-title function_">cpuUsage</span>();
 <span class="hljs-comment">// { user: 38579, system: 6986 }</span>
 
 <span class="hljs-comment">// spin the CPU for 500 milliseconds</span>
-<span class="hljs-keyword">const</span> now = <span class="hljs-built_in">Date</span>.now();
-<span class="hljs-keyword">while</span> (<span class="hljs-built_in">Date</span>.now() - now &#x3C; <span class="hljs-number">500</span>);
+<span class="hljs-keyword">const</span> now = <span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>();
+<span class="hljs-keyword">while</span> (<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>() - now &#x3C; <span class="hljs-number">500</span>);
 
-<span class="hljs-built_in">console</span>.log(process.cpuUsage(startUsage));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">cpuUsage</span>(startUsage));
 <span class="hljs-comment">// { user: 514883, system: 11226 }</span></code></pre>
-<h2><code>process.cwd()</code><span><a class="mark" href="#process_process_cwd" id="process_process_cwd">#</a></span></h2>
+</section><section><h3><code>process.cwd()</code><span><a class="mark" href="#process_process_cwd" id="process_process_cwd">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.8</span>
 </div>
@@ -48158,8 +52312,8 @@ argument to the function, to get a diff reading.</p>
 </ul>
 <p>The <code>process.cwd()</code> method returns the current working directory of the Node.js
 process.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);</code></pre>
-<h2><code>process.debugPort</code><span><a class="mark" href="#process_process_debugport" id="process_process_debugport">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);</code></pre>
+</section><section><h3><code>process.debugPort</code><span><a class="mark" href="#process_process_debugport" id="process_process_debugport">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -48167,8 +52321,8 @@ process.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>The port used by the Node.js debugger when enabled.</p>
-<pre><code class="language-js">process.debugPort = <span class="hljs-number">5858</span>;</code></pre>
-<h2><code>process.disconnect()</code><span><a class="mark" href="#process_process_disconnect" id="process_process_disconnect">#</a></span></h2>
+<pre><code class="language-js">process.<span class="hljs-property">debugPort</span> = <span class="hljs-number">5858</span>;</code></pre>
+</section><section><h3><code>process.disconnect()</code><span><a class="mark" href="#process_process_disconnect" id="process_process_disconnect">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -48180,7 +52334,7 @@ once there are no other connections keeping it alive.</p>
 <a href="#child_process_subprocess_disconnect"><code>ChildProcess.disconnect()</code></a> from the parent process.</p>
 <p>If the Node.js process was not spawned with an IPC channel,
 <code>process.disconnect()</code> will be <code>undefined</code>.</p>
-<h2><code>process.dlopen(module, filename[, flags])</code><span><a class="mark" href="#process_process_dlopen_module_filename_flags" id="process_process_dlopen_module_filename_flags">#</a></span></h2>
+</section><section><h3><code>process.dlopen(module, filename[, flags])</code><span><a class="mark" href="#process_process_dlopen_module_filename_flags" id="process_process_dlopen_module_filename_flags">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -48197,28 +52351,27 @@ once there are no other connections keeping it alive.</p>
 <li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>flags</code> <a href="#os_dlopen_constants" class="type">&#x3C;os.constants.dlopen></a> <strong>Default:</strong> <code>os.constants.dlopen.RTLD_LAZY</code></li>
 </ul>
-<p>The <code>process.dlopen()</code> method allows to dynamically load shared
-objects. It is primarily used by <code>require()</code> to load
-C++ Addons, and should not be used directly, except in special
-cases. In other words, <a href="#globals_require"><code>require()</code></a> should be preferred over
-<code>process.dlopen()</code>, unless there are specific reasons.</p>
+<p>The <code>process.dlopen()</code> method allows dynamically loading shared objects. It is
+primarily used by <code>require()</code> to load C++ Addons, and should not be used
+directly, except in special cases. In other words, <a href="#globals_require"><code>require()</code></a> should be
+preferred over <code>process.dlopen()</code> unless there are specific reasons such as
+custom dlopen flags or loading from ES modules.</p>
 <p>The <code>flags</code> argument is an integer that allows to specify dlopen
 behavior. See the <a href="#os_dlopen_constants"><code>os.constants.dlopen</code></a> documentation for details.</p>
-<p>If there are specific reasons to use <code>process.dlopen()</code> (for instance,
-to specify dlopen flags), it's often useful to use <a href="#modules_require_resolve_request_options"><code>require.resolve()</code></a>
-to look up the module's path.</p>
-<p>An important drawback when calling <code>process.dlopen()</code> is that the <code>module</code>
-instance must be passed. Functions exported by the C++ Addon will be accessible
-via <code>module.exports</code>.</p>
-<p>The example below shows how to load a C++ Addon, named as <code>binding</code>,
-that exports a <code>foo</code> function. All the symbols will be loaded before
+<p>An important requirement when calling <code>process.dlopen()</code> is that the <code>module</code>
+instance must be passed. Functions exported by the C++ Addon are then
+accessible via <code>module.exports</code>.</p>
+<p>The example below shows how to load a C++ Addon, named <code>local.node</code>,
+that exports a <code>foo</code> function. All the symbols are loaded before
 the call returns, by passing the <code>RTLD_NOW</code> constant. In this example
 the constant is assumed to be available.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> os = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>);
-process.dlopen(<span class="hljs-built_in">module</span>, <span class="hljs-built_in">require</span>.resolve(<span class="hljs-string">'binding'</span>),
-               os.constants.dlopen.RTLD_NOW);
-<span class="hljs-built_in">module</span>.exports.foo();</code></pre>
-<h2><code>process.emitWarning(warning[, options])</code><span><a class="mark" href="#process_process_emitwarning_warning_options" id="process_process_emitwarning_warning_options">#</a></span></h2>
+<span class="hljs-keyword">const</span> path = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);
+<span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = { <span class="hljs-attr">exports</span>: {} };
+process.<span class="hljs-title function_">dlopen</span>(<span class="hljs-variable language_">module</span>, path.<span class="hljs-title function_">join</span>(__dirname, <span class="hljs-string">'local.node'</span>),
+               os.<span class="hljs-property">constants</span>.<span class="hljs-property">dlopen</span>.<span class="hljs-property">RTLD_NOW</span>);
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-title function_">foo</span>();</code></pre>
+</section><section><h3><code>process.emitWarning(warning[, options])</code><span><a class="mark" href="#process_process_emitwarning_warning_options" id="process_process_emitwarning_warning_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -48240,7 +52393,7 @@ function used to limit the generated stack trace. <strong>Default:</strong>
 specific process warnings. These can be listened for by adding a handler to the
 <a href="#process_event_warning"><code>'warning'</code></a> event.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Emit a warning with a code and additional detail.</span>
-process.emitWarning(<span class="hljs-string">'Something happened!'</span>, {
+process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Something happened!'</span>, {
   <span class="hljs-attr">code</span>: <span class="hljs-string">'MY_WARNING'</span>,
   <span class="hljs-attr">detail</span>: <span class="hljs-string">'This is some additional information'</span>
 });
@@ -48250,15 +52403,15 @@ process.emitWarning(<span class="hljs-string">'Something happened!'</span>, {
 <p>In this example, an <code>Error</code> object is generated internally by
 <code>process.emitWarning()</code> and passed through to the
 <a href="#process_event_warning"><code>'warning'</code></a> handler.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
-  <span class="hljs-built_in">console</span>.warn(warning.name);    <span class="hljs-comment">// 'Warning'</span>
-  <span class="hljs-built_in">console</span>.warn(warning.message); <span class="hljs-comment">// 'Something happened!'</span>
-  <span class="hljs-built_in">console</span>.warn(warning.code);    <span class="hljs-comment">// 'MY_WARNING'</span>
-  <span class="hljs-built_in">console</span>.warn(warning.stack);   <span class="hljs-comment">// Stack trace</span>
-  <span class="hljs-built_in">console</span>.warn(warning.detail);  <span class="hljs-comment">// 'This is some additional information'</span>
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">name</span>);    <span class="hljs-comment">// 'Warning'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">message</span>); <span class="hljs-comment">// 'Something happened!'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">code</span>);    <span class="hljs-comment">// 'MY_WARNING'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">stack</span>);   <span class="hljs-comment">// Stack trace</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">detail</span>);  <span class="hljs-comment">// 'This is some additional information'</span>
 });</code></pre>
 <p>If <code>warning</code> is passed as an <code>Error</code> object, the <code>options</code> argument is ignored.</p>
-<h2><code>process.emitWarning(warning[, type[, code]][, ctor])</code><span><a class="mark" href="#process_process_emitwarning_warning_type_code_ctor" id="process_process_emitwarning_warning_type_code_ctor">#</a></span></h2>
+</section><section><h3><code>process.emitWarning(warning[, type[, code]][, ctor])</code><span><a class="mark" href="#process_process_emitwarning_warning_type_code_ctor" id="process_process_emitwarning_warning_type_code_ctor">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -48275,32 +52428,32 @@ function used to limit the generated stack trace. <strong>Default:</strong>
 specific process warnings. These can be listened for by adding a handler to the
 <a href="#process_event_warning"><code>'warning'</code></a> event.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Emit a warning using a string.</span>
-process.emitWarning(<span class="hljs-string">'Something happened!'</span>);
+process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Something happened!'</span>);
 <span class="hljs-comment">// Emits: (node: 56338) Warning: Something happened!</span></code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// Emit a warning using a string and a type.</span>
-process.emitWarning(<span class="hljs-string">'Something Happened!'</span>, <span class="hljs-string">'CustomWarning'</span>);
+process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Something Happened!'</span>, <span class="hljs-string">'CustomWarning'</span>);
 <span class="hljs-comment">// Emits: (node:56338) CustomWarning: Something Happened!</span></code></pre>
-<pre><code class="language-js">process.emitWarning(<span class="hljs-string">'Something happened!'</span>, <span class="hljs-string">'CustomWarning'</span>, <span class="hljs-string">'WARN001'</span>);
+<pre><code class="language-js">process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Something happened!'</span>, <span class="hljs-string">'CustomWarning'</span>, <span class="hljs-string">'WARN001'</span>);
 <span class="hljs-comment">// Emits: (node:56338) [WARN001] CustomWarning: Something happened!</span></code></pre>
 <p>In each of the previous examples, an <code>Error</code> object is generated internally by
 <code>process.emitWarning()</code> and passed through to the <a href="#process_event_warning"><code>'warning'</code></a>
 handler.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
-  <span class="hljs-built_in">console</span>.warn(warning.name);
-  <span class="hljs-built_in">console</span>.warn(warning.message);
-  <span class="hljs-built_in">console</span>.warn(warning.code);
-  <span class="hljs-built_in">console</span>.warn(warning.stack);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">name</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">message</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">code</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">stack</span>);
 });</code></pre>
 <p>If <code>warning</code> is passed as an <code>Error</code> object, it will be passed through to the
 <code>'warning'</code> event handler unmodified (and the optional <code>type</code>,
 <code>code</code> and <code>ctor</code> arguments will be ignored):</p>
 <pre><code class="language-js"><span class="hljs-comment">// Emit a warning using an Error object.</span>
-<span class="hljs-keyword">const</span> myWarning = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Something happened!'</span>);
+<span class="hljs-keyword">const</span> myWarning = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Something happened!'</span>);
 <span class="hljs-comment">// Use the Error name property to specify the type name</span>
-myWarning.name = <span class="hljs-string">'CustomWarning'</span>;
-myWarning.code = <span class="hljs-string">'WARN001'</span>;
+myWarning.<span class="hljs-property">name</span> = <span class="hljs-string">'CustomWarning'</span>;
+myWarning.<span class="hljs-property">code</span> = <span class="hljs-string">'WARN001'</span>;
 
-process.emitWarning(myWarning);
+process.<span class="hljs-title function_">emitWarning</span>(myWarning);
 <span class="hljs-comment">// Emits: (node:56338) [WARN001] CustomWarning: Something happened!</span></code></pre>
 <p>A <code>TypeError</code> is thrown if <code>warning</code> is anything other than a string or <code>Error</code>
 object.</p>
@@ -48316,21 +52469,21 @@ warning is suppressed.</li>
 <li>If the <code>--trace-deprecation</code> command-line flag is used, the deprecation
 warning is printed to <code>stderr</code> along with the full stack trace.</li>
 </ul>
-<h3>Avoiding duplicate warnings<span><a class="mark" href="#process_avoiding_duplicate_warnings" id="process_avoiding_duplicate_warnings">#</a></span></h3>
+<h4>Avoiding duplicate warnings<span><a class="mark" href="#process_avoiding_duplicate_warnings" id="process_avoiding_duplicate_warnings">#</a></span></h4>
 <p>As a best practice, warnings should be emitted only once per process. To do
 so, it is recommended to place the <code>emitWarning()</code> behind a simple boolean
 flag as illustrated in the example below:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">emitMyWarning</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">if</span> (!emitMyWarning.warned) {
-    emitMyWarning.warned = <span class="hljs-literal">true</span>;
-    process.emitWarning(<span class="hljs-string">'Only warn once!'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">emitMyWarning</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">if</span> (!emitMyWarning.<span class="hljs-property">warned</span>) {
+    emitMyWarning.<span class="hljs-property">warned</span> = <span class="hljs-literal">true</span>;
+    process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Only warn once!'</span>);
   }
 }
-emitMyWarning();
+<span class="hljs-title function_">emitMyWarning</span>();
 <span class="hljs-comment">// Emits: (node: 56339) Warning: Only warn once!</span>
-emitMyWarning();
+<span class="hljs-title function_">emitMyWarning</span>();
 <span class="hljs-comment">// Emits nothing</span></code></pre>
-<h2><code>process.env</code><span><a class="mark" href="#process_process_env" id="process_process_env">#</a></span></h2>
+</section><section><h3><code>process.env</code><span><a class="mark" href="#process_process_env" id="process_process_env">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -48367,27 +52520,27 @@ See <a href="http://man7.org/linux/man-pages/man7/environ.7.html"><code>environ(
 reflected outside the Node.js process, or (unless explicitly requested)
 to other <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.
 In other words, the following example would not work:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node -e <span class="hljs-string">'process.env.foo = "bar"'</span> &#x26;&#x26; <span class="hljs-built_in">echo</span> <span class="hljs-variable">$foo</span></span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node -e <span class="hljs-string">'process.env.foo = "bar"'</span> &#x26;&#x26; <span class="hljs-built_in">echo</span> <span class="hljs-variable">$foo</span></span></code></pre>
 <p>While the following will:</p>
-<pre><code class="language-js">process.env.foo = <span class="hljs-string">'bar'</span>;
-<span class="hljs-built_in">console</span>.log(process.env.foo);</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">env</span>.<span class="hljs-property">foo</span> = <span class="hljs-string">'bar'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">foo</span>);</code></pre>
 <p>Assigning a property on <code>process.env</code> will implicitly convert the value
 to a string. <strong>This behavior is deprecated.</strong> Future versions of Node.js may
 throw an error when the value is not a string, number, or boolean.</p>
-<pre><code class="language-js">process.env.test = <span class="hljs-literal">null</span>;
-<span class="hljs-built_in">console</span>.log(process.env.test);
+<pre><code class="language-js">process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span> = <span class="hljs-literal">null</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span>);
 <span class="hljs-comment">// => 'null'</span>
-process.env.test = <span class="hljs-literal">undefined</span>;
-<span class="hljs-built_in">console</span>.log(process.env.test);
+process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span> = <span class="hljs-literal">undefined</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span>);
 <span class="hljs-comment">// => 'undefined'</span></code></pre>
 <p>Use <code>delete</code> to delete a property from <code>process.env</code>.</p>
-<pre><code class="language-js">process.env.TEST = <span class="hljs-number">1</span>;
-<span class="hljs-keyword">delete</span> process.env.TEST;
-<span class="hljs-built_in">console</span>.log(process.env.TEST);
+<pre><code class="language-js">process.<span class="hljs-property">env</span>.<span class="hljs-property">TEST</span> = <span class="hljs-number">1</span>;
+<span class="hljs-keyword">delete</span> process.<span class="hljs-property">env</span>.<span class="hljs-property">TEST</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">TEST</span>);
 <span class="hljs-comment">// => undefined</span></code></pre>
 <p>On Windows operating systems, environment variables are case-insensitive.</p>
-<pre><code class="language-js">process.env.TEST = <span class="hljs-number">1</span>;
-<span class="hljs-built_in">console</span>.log(process.env.test);
+<pre><code class="language-js">process.<span class="hljs-property">env</span>.<span class="hljs-property">TEST</span> = <span class="hljs-number">1</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span>);
 <span class="hljs-comment">// => 1</span></code></pre>
 <p>Unless explicitly specified when creating a <a href="#worker_threads_class_worker"><code>Worker</code></a> instance,
 each <a href="#worker_threads_class_worker"><code>Worker</code></a> thread has its own copy of <code>process.env</code>, based on its
@@ -48395,7 +52548,7 @@ parent thread’s <code>process.env</code>, or whatever was specified as the <co
 to the <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor. Changes to <code>process.env</code> will not be visible
 across <a href="#worker_threads_class_worker"><code>Worker</code></a> threads, and only the main thread can make changes that
 are visible to the operating system or to native add-ons.</p>
-<h2><code>process.execArgv</code><span><a class="mark" href="#process_process_execargv" id="process_process_execargv">#</a></span></h2>
+</section><section><h3><code>process.execArgv</code><span><a class="mark" href="#process_process_execargv" id="process_process_execargv">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -48408,14 +52561,16 @@ appear in the array returned by the <a href="#process_process_argv"><code>proces
 include the Node.js executable, the name of the script, or any options following
 the script name. These options are useful in order to spawn child processes with
 the same execution environment as the parent.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --harmony script.js --version</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --harmony script.js --version</span></code></pre>
 <p>Results in <code>process.execArgv</code>:</p>
 <!-- eslint-disable semi -->
 <pre><code class="language-js">[<span class="hljs-string">'--harmony'</span>]</code></pre>
 <p>And <code>process.argv</code>:</p>
 <!-- eslint-disable semi -->
 <pre><code class="language-js">[<span class="hljs-string">'/usr/local/bin/node'</span>, <span class="hljs-string">'script.js'</span>, <span class="hljs-string">'--version'</span>]</code></pre>
-<h2><code>process.execPath</code><span><a class="mark" href="#process_process_execpath" id="process_process_execpath">#</a></span></h2>
+<p>Refer to <a href="#worker_threads_new_worker_filename_options"><code>Worker</code> constructor</a> for the detailed behavior of worker
+threads with this property.</p>
+</section><section><h3><code>process.execPath</code><span><a class="mark" href="#process_process_execpath" id="process_process_execpath">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -48426,7 +52581,7 @@ the same execution environment as the parent.</p>
 that started the Node.js process. Symbolic links, if any, are resolved.</p>
 <!-- eslint-disable semi -->
 <pre><code class="language-js"><span class="hljs-string">'/usr/local/bin/node'</span></code></pre>
-<h2><code>process.exit([code])</code><span><a class="mark" href="#process_process_exit_code" id="process_process_exit_code">#</a></span></h2>
+</section><section><h3><code>process.exit([code])</code><span><a class="mark" href="#process_process_exit_code" id="process_process_exit_code">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.13</span>
 </div>
@@ -48439,7 +52594,7 @@ either the 'success' code <code>0</code> or the value of <code>process.exitCode<
 set. Node.js will not terminate until all the <a href="#process_event_exit"><code>'exit'</code></a> event listeners are
 called.</p>
 <p>To exit with a 'failure' code:</p>
-<pre><code class="language-js">process.exit(<span class="hljs-number">1</span>);</code></pre>
+<pre><code class="language-js">process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">1</span>);</code></pre>
 <p>The shell that executed Node.js should see the exit code as <code>1</code>.</p>
 <p>Calling <code>process.exit()</code> will force the process to exit as quickly as possible
 even if there are still asynchronous operations pending that have not yet
@@ -48453,9 +52608,9 @@ tell the process which exit code to use when the process exits gracefully.</p>
 <code>process.exit()</code> method that could lead to data printed to stdout being
 truncated and lost:</p>
 <pre><code class="language-js"><span class="hljs-comment">// This is an example of what *not* to do:</span>
-<span class="hljs-keyword">if</span> (someConditionNotMet()) {
-  printUsageToStdout();
-  process.exit(<span class="hljs-number">1</span>);
+<span class="hljs-keyword">if</span> (<span class="hljs-title function_">someConditionNotMet</span>()) {
+  <span class="hljs-title function_">printUsageToStdout</span>();
+  process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">1</span>);
 }</code></pre>
 <p>The reason this is problematic is because writes to <code>process.stdout</code> in Node.js
 are sometimes <em>asynchronous</em> and may occur over multiple ticks of the Node.js
@@ -48466,16 +52621,16 @@ event loop. Calling <code>process.exit()</code>, however, forces the process to
 scheduling any additional work for the event loop:</p>
 <pre><code class="language-js"><span class="hljs-comment">// How to properly set the exit code while letting</span>
 <span class="hljs-comment">// the process exit gracefully.</span>
-<span class="hljs-keyword">if</span> (someConditionNotMet()) {
-  printUsageToStdout();
-  process.exitCode = <span class="hljs-number">1</span>;
+<span class="hljs-keyword">if</span> (<span class="hljs-title function_">someConditionNotMet</span>()) {
+  <span class="hljs-title function_">printUsageToStdout</span>();
+  process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
 }</code></pre>
 <p>If it is necessary to terminate the Node.js process due to an error condition,
 throwing an <em>uncaught</em> error and allowing the process to terminate accordingly
 is safer than calling <code>process.exit()</code>.</p>
 <p>In <a href="#worker_threads_class_worker"><code>Worker</code></a> threads, this function stops the current thread rather
 than the current process.</p>
-<h2><code>process.exitCode</code><span><a class="mark" href="#process_process_exitcode" id="process_process_exitcode">#</a></span></h2>
+</section><section><h3><code>process.exitCode</code><span><a class="mark" href="#process_process_exitcode" id="process_process_exitcode">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -48487,18 +52642,18 @@ exits gracefully, or is exited via <a href="#process_process_exit_code"><code>pr
 a code.</p>
 <p>Specifying a code to <a href="#process_process_exit_code"><code>process.exit(code)</code></a> will override any
 previous setting of <code>process.exitCode</code>.</p>
-<h2><code>process.getegid()</code><span><a class="mark" href="#process_process_getegid" id="process_process_getegid">#</a></span></h2>
+</section><section><h3><code>process.getegid()</code><span><a class="mark" href="#process_process_getegid" id="process_process_getegid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
 <p>The <code>process.getegid()</code> method returns the numerical effective group identity
 of the Node.js process. (See <a href="http://man7.org/linux/man-pages/man2/getegid.2.html"><code>getegid(2)</code></a>.)</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getegid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getegid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.geteuid()</code><span><a class="mark" href="#process_process_geteuid" id="process_process_geteuid">#</a></span></h2>
+</section><section><h3><code>process.geteuid()</code><span><a class="mark" href="#process_process_geteuid" id="process_process_geteuid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
@@ -48507,12 +52662,12 @@ Android).</p>
 </ul>
 <p>The <code>process.geteuid()</code> method returns the numerical effective user identity of
 the process. (See <a href="http://man7.org/linux/man-pages/man2/geteuid.2.html"><code>geteuid(2)</code></a>.)</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.geteuid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">geteuid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.getgid()</code><span><a class="mark" href="#process_process_getgid" id="process_process_getgid">#</a></span></h2>
+</section><section><h3><code>process.getgid()</code><span><a class="mark" href="#process_process_getgid" id="process_process_getgid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.31</span>
 </div>
@@ -48521,12 +52676,12 @@ Android).</p>
 </ul>
 <p>The <code>process.getgid()</code> method returns the numerical group identity of the
 process. (See <a href="http://man7.org/linux/man-pages/man2/getgid.2.html"><code>getgid(2)</code></a>.)</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getgid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getgid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.getgroups()</code><span><a class="mark" href="#process_process_getgroups" id="process_process_getgroups">#</a></span></h2>
+</section><section><h3><code>process.getgroups()</code><span><a class="mark" href="#process_process_getgroups" id="process_process_getgroups">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -48536,9 +52691,12 @@ Android).</p>
 <p>The <code>process.getgroups()</code> method returns an array with the supplementary group
 IDs. POSIX leaves it unspecified if the effective group ID is included but
 Node.js ensures it always is.</p>
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getgroups</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>()); <span class="hljs-comment">// [ 16, 21, 297 ]</span>
+}</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.getuid()</code><span><a class="mark" href="#process_process_getuid" id="process_process_getuid">#</a></span></h2>
+</section><section><h3><code>process.getuid()</code><span><a class="mark" href="#process_process_getuid" id="process_process_getuid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.28</span>
 </div>
@@ -48547,12 +52705,12 @@ Android).</p>
 </ul>
 <p>The <code>process.getuid()</code> method returns the numeric user identity of the process.
 (See <a href="http://man7.org/linux/man-pages/man2/getuid.2.html"><code>getuid(2)</code></a>.)</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getuid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getuid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.hasUncaughtExceptionCaptureCallback()</code><span><a class="mark" href="#process_process_hasuncaughtexceptioncapturecallback" id="process_process_hasuncaughtexceptioncapturecallback">#</a></span></h2>
+</section><section><h3><code>process.hasUncaughtExceptionCaptureCallback()</code><span><a class="mark" href="#process_process_hasuncaughtexceptioncapturecallback" id="process_process_hasuncaughtexceptioncapturecallback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.3.0</span>
 </div>
@@ -48561,10 +52719,11 @@ Android).</p>
 </ul>
 <p>Indicates whether a callback has been set using
 <a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a>.</p>
-<h2><code>process.hrtime([time])</code><span><a class="mark" href="#process_process_hrtime_time" id="process_process_hrtime_time">#</a></span></h2>
+</section><section><h3><code>process.hrtime([time])</code><span><a class="mark" href="#process_process_hrtime_time" id="process_process_hrtime_time">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.6</span>
 </div>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy. Use <a href="#process_process_hrtime_bigint"><code>process.hrtime.bigint()</code></a> instead.</div><p></p>
 <ul>
 <li><code>time</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer[]></a> The result of a previous call to <code>process.hrtime()</code></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer[]></a></li>
@@ -48582,18 +52741,18 @@ user-defined array instead of the result of a previous call to
 <p>These times are relative to an arbitrary time in the
 past, and not related to the time of day and therefore not subject to clock
 drift. The primary use is for measuring performance between intervals:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> NS_PER_SEC = <span class="hljs-number">1e9</span>;
-<span class="hljs-keyword">const</span> time = process.hrtime();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-variable constant_">NS_PER_SEC</span> = <span class="hljs-number">1e9</span>;
+<span class="hljs-keyword">const</span> time = process.<span class="hljs-title function_">hrtime</span>();
 <span class="hljs-comment">// [ 1800216, 25 ]</span>
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> diff = process.hrtime(time);
+  <span class="hljs-keyword">const</span> diff = process.<span class="hljs-title function_">hrtime</span>(time);
   <span class="hljs-comment">// [ 1, 552 ]</span>
 
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Benchmark took <span class="hljs-subst">${diff[<span class="hljs-number">0</span>] * NS_PER_SEC + diff[<span class="hljs-number">1</span>]}</span> nanoseconds`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Benchmark took <span class="hljs-subst">${diff[<span class="hljs-number">0</span>] * NS_PER_SEC + diff[<span class="hljs-number">1</span>]}</span> nanoseconds`</span>);
   <span class="hljs-comment">// Benchmark took 1000000552 nanoseconds</span>
 }, <span class="hljs-number">1000</span>);</code></pre>
-<h2><code>process.hrtime.bigint()</code><span><a class="mark" href="#process_process_hrtime_bigint" id="process_process_hrtime_bigint">#</a></span></h2>
+</section><section><h3><code>process.hrtime.bigint()</code><span><a class="mark" href="#process_process_hrtime_bigint" id="process_process_hrtime_bigint">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 </div>
@@ -48605,17 +52764,17 @@ current high-resolution real time in nanoseconds as a <code>bigint</code>.</p>
 <p>Unlike <a href="#process_process_hrtime_time"><code>process.hrtime()</code></a>, it does not support an additional <code>time</code>
 argument since the difference can just be computed directly
 by subtraction of the two <code>bigint</code>s.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> start = process.hrtime.bigint();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> start = process.<span class="hljs-property">hrtime</span>.<span class="hljs-title function_">bigint</span>();
 <span class="hljs-comment">// 191051479007711n</span>
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> end = process.hrtime.bigint();
+  <span class="hljs-keyword">const</span> end = process.<span class="hljs-property">hrtime</span>.<span class="hljs-title function_">bigint</span>();
   <span class="hljs-comment">// 191052633396993n</span>
 
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Benchmark took <span class="hljs-subst">${end - start}</span> nanoseconds`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Benchmark took <span class="hljs-subst">${end - start}</span> nanoseconds`</span>);
   <span class="hljs-comment">// Benchmark took 1154389282 nanoseconds</span>
 }, <span class="hljs-number">1000</span>);</code></pre>
-<h2><code>process.initgroups(user, extraGroup)</code><span><a class="mark" href="#process_process_initgroups_user_extragroup" id="process_process_initgroups_user_extragroup">#</a></span></h2>
+</section><section><h3><code>process.initgroups(user, extraGroup)</code><span><a class="mark" href="#process_process_initgroups_user_extragroup" id="process_process_initgroups_user_extragroup">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -48628,15 +52787,15 @@ the group access list, using all groups of which the user is a member. This is
 a privileged operation that requires that the Node.js process either have <code>root</code>
 access or the <code>CAP_SETGID</code> capability.</p>
 <p>Use care when dropping privileges:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.getgroups());         <span class="hljs-comment">// [ 0 ]</span>
-process.initgroups(<span class="hljs-string">'nodeuser'</span>, <span class="hljs-number">1000</span>);     <span class="hljs-comment">// switch user</span>
-<span class="hljs-built_in">console</span>.log(process.getgroups());         <span class="hljs-comment">// [ 27, 30, 46, 1000, 0 ]</span>
-process.setgid(<span class="hljs-number">1000</span>);                     <span class="hljs-comment">// drop root gid</span>
-<span class="hljs-built_in">console</span>.log(process.getgroups());         <span class="hljs-comment">// [ 27, 30, 46, 1000 ]</span></code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>());         <span class="hljs-comment">// [ 0 ]</span>
+process.<span class="hljs-title function_">initgroups</span>(<span class="hljs-string">'nodeuser'</span>, <span class="hljs-number">1000</span>);     <span class="hljs-comment">// switch user</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>());         <span class="hljs-comment">// [ 27, 30, 46, 1000, 0 ]</span>
+process.<span class="hljs-title function_">setgid</span>(<span class="hljs-number">1000</span>);                     <span class="hljs-comment">// drop root gid</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>());         <span class="hljs-comment">// [ 27, 30, 46, 1000 ]</span></code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.kill(pid[, signal])</code><span><a class="mark" href="#process_process_kill_pid_signal" id="process_process_kill_pid_signal">#</a></span></h2>
+</section><section><h3><code>process.kill(pid[, signal])</code><span><a class="mark" href="#process_process_kill_pid_signal" id="process_process_kill_pid_signal">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.6</span>
 </div>
@@ -48656,22 +52815,23 @@ group.</p>
 <p>Even though the name of this function is <code>process.kill()</code>, it is really just a
 signal sender, like the <code>kill</code> system call. The signal sent may do something
 other than kill the target process.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'SIGHUP'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Got SIGHUP signal.'</span>);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGHUP'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Got SIGHUP signal.'</span>);
 });
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Exiting.'</span>);
-  process.exit(<span class="hljs-number">0</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Exiting.'</span>);
+  process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">0</span>);
 }, <span class="hljs-number">100</span>);
 
-process.kill(process.pid, <span class="hljs-string">'SIGHUP'</span>);</code></pre>
+process.<span class="hljs-title function_">kill</span>(process.<span class="hljs-property">pid</span>, <span class="hljs-string">'SIGHUP'</span>);</code></pre>
 <p>When <code>SIGUSR1</code> is received by a Node.js process, Node.js will start the
 debugger. See <a href="#process_signal_events">Signal Events</a>.</p>
-<h2><code>process.mainModule</code><span><a class="mark" href="#process_process_mainmodule" id="process_process_mainmodule">#</a></span></h2>
+</section><section><h3><code>process.mainModule</code><span><a class="mark" href="#process_process_mainmodule" id="process_process_mainmodule">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.1.17</span>
+<span>Added in: v0.1.17</span><span>Deprecated since: v14.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#modules_accessing_the_main_module"><code>require.main</code></a> instead.</div><p></p>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
@@ -48682,12 +52842,12 @@ modules that were required before the change occurred. Generally, it's
 safe to assume that the two refer to the same module.</p>
 <p>As with <a href="#modules_accessing_the_main_module"><code>require.main</code></a>, <code>process.mainModule</code> will be <code>undefined</code> if there
 is no entry script.</p>
-<h2><code>process.memoryUsage()</code><span><a class="mark" href="#process_process_memoryusage" id="process_process_memoryusage">#</a></span></h2>
+</section><section><h3><code>process.memoryUsage()</code><span><a class="mark" href="#process_process_memoryusage" id="process_process_memoryusage">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.9.0</td>
 <td><p>Added <code>arrayBuffers</code> to the returned object.</p></td></tr>
 <tr><td>v7.2.0</td>
 <td><p>Added <code>external</code> to the returned object.</p></td></tr>
@@ -48707,19 +52867,17 @@ is no entry script.</p>
 </ul>
 </li>
 </ul>
-<p>The <code>process.memoryUsage()</code> method returns an object describing the memory usage
-of the Node.js process measured in bytes.</p>
-<p>For example, the code:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.memoryUsage());</code></pre>
-<p>Will generate:</p>
-<!-- eslint-skip -->
-<pre><code class="language-js">{
-  <span class="hljs-attr">rss</span>: <span class="hljs-number">4935680</span>,
-  <span class="hljs-attr">heapTotal</span>: <span class="hljs-number">1826816</span>,
-  <span class="hljs-attr">heapUsed</span>: <span class="hljs-number">650472</span>,
-  <span class="hljs-attr">external</span>: <span class="hljs-number">49879</span>,
-  <span class="hljs-attr">arrayBuffers</span>: <span class="hljs-number">9386</span>
-}</code></pre>
+<p>Returns an object describing the memory usage of the Node.js process measured in
+bytes.</p>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">memoryUsage</span>());
+<span class="hljs-comment">// Prints:</span>
+<span class="hljs-comment">// {</span>
+<span class="hljs-comment">//  rss: 4935680,</span>
+<span class="hljs-comment">//  heapTotal: 1826816,</span>
+<span class="hljs-comment">//  heapUsed: 650472,</span>
+<span class="hljs-comment">//  external: 49879,</span>
+<span class="hljs-comment">//  arrayBuffers: 9386</span>
+<span class="hljs-comment">// }</span></code></pre>
 <ul>
 <li><code>heapTotal</code> and <code>heapUsed</code> refer to V8's memory usage.</li>
 <li><code>external</code> refers to the memory usage of C++ objects bound to JavaScript
@@ -48735,7 +52893,26 @@ may not be tracked in that case.</li>
 </ul>
 <p>When using <a href="#worker_threads_class_worker"><code>Worker</code></a> threads, <code>rss</code> will be a value that is valid for the
 entire process, while the other fields will only refer to the current thread.</p>
-<h2><code>process.nextTick(callback[, ...args])</code><span><a class="mark" href="#process_process_nexttick_callback_args" id="process_process_nexttick_callback_args">#</a></span></h2>
+<p>The <code>process.memoryUsage()</code> method iterates over each page to gather
+information about memory usage which might be slow depending on the
+program memory allocations.</p>
+</section><section><h3><code>process.memoryUsage.rss()</code><span><a class="mark" href="#process_process_memoryusage_rss" id="process_process_memoryusage_rss">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+</ul>
+<p>The <code>process.memoryUsage.rss()</code> method returns an integer representing the
+Resident Set Size (RSS) in bytes.</p>
+<p>The Resident Set Size, is the amount of space occupied in the main
+memory device (that is a subset of the total allocated memory) for the
+process, including all C++ and JavaScript objects and code.</p>
+<p>This is the same value as the <code>rss</code> property provided by <code>process.memoryUsage()</code>
+but <code>process.memoryUsage.rss()</code> is faster.</p>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">memoryUsage</span>.<span class="hljs-title function_">rss</span>());
+<span class="hljs-comment">// 35655680</span></code></pre>
+</section><section><h3><code>process.nextTick(callback[, ...args])</code><span><a class="mark" href="#process_process_nexttick_callback_args" id="process_process_nexttick_callback_args">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -48756,11 +52933,11 @@ fully drained after the current operation on the JavaScript stack runs to
 completion and before the event loop is allowed to continue. It's possible to
 create an infinite loop if one were to recursively call <code>process.nextTick()</code>.
 See the <a href="https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick">Event Loop</a> guide for more background.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'start'</span>);
-process.nextTick(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'nextTick callback'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'start'</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'nextTick callback'</span>);
 });
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'scheduled'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'scheduled'</span>);
 <span class="hljs-comment">// Output:</span>
 <span class="hljs-comment">// start</span>
 <span class="hljs-comment">// scheduled</span>
@@ -48768,48 +52945,97 @@ process.nextTick(<span class="hljs-function">() =></span> {
 <p>This is important when developing APIs in order to give users the opportunity
 to assign event handlers <em>after</em> an object has been constructed but before any
 I/O has occurred:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyThing</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-built_in">this</span>.setupOptions(options);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">MyThing</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">setupOptions</span>(options);
 
-  process.nextTick(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">this</span>.startDoingStuff();
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">startDoingStuff</span>();
   });
 }
 
-<span class="hljs-keyword">const</span> thing = <span class="hljs-keyword">new</span> MyThing();
-thing.getReadyForStuff();
+<span class="hljs-keyword">const</span> thing = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyThing</span>();
+thing.<span class="hljs-title function_">getReadyForStuff</span>();
 
 <span class="hljs-comment">// thing.startDoingStuff() gets called now, not before.</span></code></pre>
 <p>It is very important for APIs to be either 100% synchronous or 100%
 asynchronous. Consider this example:</p>
 <pre><code class="language-js"><span class="hljs-comment">// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">maybeSync</span>(<span class="hljs-params">arg, cb</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">maybeSync</span>(<span class="hljs-params">arg, cb</span>) {
   <span class="hljs-keyword">if</span> (arg) {
-    cb();
+    <span class="hljs-title function_">cb</span>();
     <span class="hljs-keyword">return</span>;
   }
 
-  fs.stat(<span class="hljs-string">'file'</span>, cb);
+  fs.<span class="hljs-title function_">stat</span>(<span class="hljs-string">'file'</span>, cb);
 }</code></pre>
 <p>This API is hazardous because in the following case:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> maybeTrue = <span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> maybeTrue = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>;
 
-maybeSync(maybeTrue, <span class="hljs-function">() =></span> {
-  foo();
+<span class="hljs-title function_">maybeSync</span>(maybeTrue, <span class="hljs-function">() =></span> {
+  <span class="hljs-title function_">foo</span>();
 });
 
-bar();</code></pre>
+<span class="hljs-title function_">bar</span>();</code></pre>
 <p>It is not clear whether <code>foo()</code> or <code>bar()</code> will be called first.</p>
 <p>The following approach is much better:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">definitelyAsync</span>(<span class="hljs-params">arg, cb</span>) </span>{
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">definitelyAsync</span>(<span class="hljs-params">arg, cb</span>) {
   <span class="hljs-keyword">if</span> (arg) {
-    process.nextTick(cb);
+    process.<span class="hljs-title function_">nextTick</span>(cb);
     <span class="hljs-keyword">return</span>;
   }
 
-  fs.stat(<span class="hljs-string">'file'</span>, cb);
+  fs.<span class="hljs-title function_">stat</span>(<span class="hljs-string">'file'</span>, cb);
 }</code></pre>
-<h2><code>process.noDeprecation</code><span><a class="mark" href="#process_process_nodeprecation" id="process_process_nodeprecation">#</a></span></h2>
+<h4>When to use <code>queueMicrotask()</code> vs. <code>process.nextTick()</code><span><a class="mark" href="#process_when_to_use_queuemicrotask_vs_process_nexttick" id="process_when_to_use_queuemicrotask_vs_process_nexttick">#</a></span></h4>
+<p>The <a href="#globals_queuemicrotask_callback"><code>queueMicrotask()</code></a> API is an alternative to <code>process.nextTick()</code> that
+also defers execution of a function using the same microtask queue used to
+execute the then, catch, and finally handlers of resolved promises. Within
+Node.js, every time the "next tick queue" is drained, the microtask queue
+is drained immediately after.</p>
+<pre><code class="language-js"><span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>().<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-number">2</span>));
+<span class="hljs-title function_">queueMicrotask</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-number">3</span>));
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-number">1</span>));
+<span class="hljs-comment">// Output:</span>
+<span class="hljs-comment">// 1</span>
+<span class="hljs-comment">// 2</span>
+<span class="hljs-comment">// 3</span></code></pre>
+<p>For <em>most</em> userland use cases, the <code>queueMicrotask()</code> API provides a portable
+and reliable mechanism for deferring execution that works across multiple
+JavaScript platform environments and should be favored over <code>process.nextTick()</code>.
+In simple scenarios, <code>queueMicrotask()</code> can be a drop-in replacement for
+<code>process.nextTick()</code>.</p>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'start'</span>);
+<span class="hljs-title function_">queueMicrotask</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'microtask callback'</span>);
+});
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'scheduled'</span>);
+<span class="hljs-comment">// Output:</span>
+<span class="hljs-comment">// start</span>
+<span class="hljs-comment">// scheduled</span>
+<span class="hljs-comment">// microtask callback</span></code></pre>
+<p>One note-worthy difference between the two APIs is that <code>process.nextTick()</code>
+allows specifying additional values that will be passed as arguments to the
+deferred function when it is called. Achieving the same result with
+<code>queueMicrotask()</code> requires using either a closure or a bound function:</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">deferred</span>(<span class="hljs-params">a, b</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'microtask'</span>, a + b);
+}
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'start'</span>);
+<span class="hljs-title function_">queueMicrotask</span>(deferred.<span class="hljs-title function_">bind</span>(<span class="hljs-literal">undefined</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'scheduled'</span>);
+<span class="hljs-comment">// Output:</span>
+<span class="hljs-comment">// start</span>
+<span class="hljs-comment">// scheduled</span>
+<span class="hljs-comment">// microtask 3</span></code></pre>
+<p>There are minor differences in the way errors raised from within the next tick
+queue and microtask queue are handled. Errors thrown within a queued microtask
+callback should be handled within the queued callback when possible. If they are
+not, the <code>process.on('uncaughtException')</code> event handler can be used to capture
+and handle the errors.</p>
+<p>When in doubt, unless the specific capabilities of <code>process.nextTick()</code> are
+needed, use <code>queueMicrotask()</code>.</p>
+</section><section><h3><code>process.noDeprecation</code><span><a class="mark" href="#process_process_nodeprecation" id="process_process_nodeprecation">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
@@ -48821,7 +53047,7 @@ flag is set on the current Node.js process. See the documentation for
 the <a href="#process_event_warning"><code>'warning'</code> event</a> and the
 <a href="#process_process_emitwarning_warning_type_code_ctor"><code>emitWarning()</code> method</a> for more information about this
 flag's behavior.</p>
-<h2><code>process.pid</code><span><a class="mark" href="#process_process_pid" id="process_process_pid">#</a></span></h2>
+</section><section><h3><code>process.pid</code><span><a class="mark" href="#process_process_pid" id="process_process_pid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.15</span>
 </div>
@@ -48829,8 +53055,8 @@ flag's behavior.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The <code>process.pid</code> property returns the PID of the process.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`This process is pid <span class="hljs-subst">${process.pid}</span>`</span>);</code></pre>
-<h2><code>process.platform</code><span><a class="mark" href="#process_process_platform" id="process_process_platform">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`This process is pid <span class="hljs-subst">${process.pid}</span>`</span>);</code></pre>
+</section><section><h3><code>process.platform</code><span><a class="mark" href="#process_process_platform" id="process_process_platform">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -48849,11 +53075,11 @@ system platform on which the Node.js process is running.</p>
 <li><code>'sunos'</code></li>
 <li><code>'win32'</code></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`This platform is <span class="hljs-subst">${process.platform}</span>`</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`This platform is <span class="hljs-subst">${process.platform}</span>`</span>);</code></pre>
 <p>The value <code>'android'</code> may also be returned if the Node.js is built on the
 Android operating system. However, Android support in Node.js
-<a href="https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os">is experimental</a>.</p>
-<h2><code>process.ppid</code><span><a class="mark" href="#process_process_ppid" id="process_process_ppid">#</a></span></h2>
+<a href="https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os">is experimental</a>.</p>
+</section><section><h3><code>process.ppid</code><span><a class="mark" href="#process_process_ppid" id="process_process_ppid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.2.0, v8.10.0, v6.13.0</span>
 </div>
@@ -48862,8 +53088,8 @@ Android operating system. However, Android support in Node.js
 </ul>
 <p>The <code>process.ppid</code> property returns the PID of the parent of the
 current process.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The parent process is pid <span class="hljs-subst">${process.ppid}</span>`</span>);</code></pre>
-<h2><code>process.release</code><span><a class="mark" href="#process_process_release" id="process_process_release">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The parent process is pid <span class="hljs-subst">${process.ppid}</span>`</span>);</code></pre>
+</section><section><h3><code>process.release</code><span><a class="mark" href="#process_process_release" id="process_process_release">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -48883,8 +53109,7 @@ to the current release, including URLs for the source tarball and headers-only
 tarball.</p>
 <p><code>process.release</code> contains the following properties:</p>
 <ul>
-<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A value that will always be <code>'node'</code> for Node.js. For
-legacy io.js releases, this will be <code>'io.js'</code>.</li>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A value that will always be <code>'node'</code>.</li>
 <li><code>sourceUrl</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing
 the source code of the current release.</li>
 <li><code>headersUrl</code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing
@@ -48898,15 +53123,13 @@ builds of Node.js and will be missing on all other platforms.</em></li>
 <li><code>lts</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> a string label identifying the <a href="https://github.com/nodejs/Release">LTS</a> label for this release.
 This property only exists for LTS releases and is <code>undefined</code> for all other
 release types, including <em>Current</em> releases.
-Valid values include the LTS Release Codenames (including those
-that are no longer supported). A non-exhaustive example of
-these codenames includes:
+Valid values include the LTS Release code names (including those
+that are no longer supported).
 <ul>
 <li><code>'Dubnium'</code> for the 10.x LTS line beginning with 10.13.0.</li>
-<li><code>'Erbium'</code> for the 12.x LTS line beginning with 12.13.0.
-For other LTS Release Codenames, see <a href="https://github.com/nodejs/node/blob/master/doc/changelogs/CHANGELOG_ARCHIVE.md">Node.js Changelog Archive</a></li>
+<li><code>'Erbium'</code> for the 12.x LTS line beginning with 12.13.0.</li>
 </ul>
-</li>
+For other LTS Release code names, see <a href="https://github.com/nodejs/node/blob/HEAD/doc/changelogs/CHANGELOG_ARCHIVE.md">Node.js Changelog Archive</a></li>
 </ul>
 <!-- eslint-skip -->
 <pre><code class="language-js">{
@@ -48919,12 +53142,12 @@ For other LTS Release Codenames, see <a href="https://github.com/nodejs/node/blo
 <p>In custom builds from non-release versions of the source tree, only the
 <code>name</code> property may be present. The additional properties should not be
 relied upon to exist.</p>
-<h2><code>process.report</code><span><a class="mark" href="#process_process_report" id="process_process_report">#</a></span></h2>
+</section><section><h3><code>process.report</code><span><a class="mark" href="#process_process_report" id="process_process_report">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
@@ -48937,9 +53160,9 @@ relied upon to exist.</p>
 <p><code>process.report</code> is an object whose methods are used to generate diagnostic
 reports for the current process. Additional documentation is available in the
 <a href="report.html">report documentation</a>.</p>
-<h3><code>process.report.compact</code><span><a class="mark" href="#process_process_report_compact" id="process_process_report_compact">#</a></span></h3>
+<h4><code>process.report.compact</code><span><a class="mark" href="#process_process_report_compact" id="process_process_report_compact">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.12.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
@@ -48947,13 +53170,13 @@ reports for the current process. Additional documentation is available in the
 <p>Write reports in a compact format, single-line JSON, more easily consumable
 by log processing systems than the default multi-line format designed for
 human consumption.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Reports are compact? <span class="hljs-subst">${process.report.compact}</span>`</span>);</code></pre>
-<h3><code>process.report.directory</code><span><a class="mark" href="#process_process_report_directory" id="process_process_report_directory">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Reports are compact? <span class="hljs-subst">${process.report.compact}</span>`</span>);</code></pre>
+<h4><code>process.report.directory</code><span><a class="mark" href="#process_process_report_directory" id="process_process_report_directory">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -48966,13 +53189,13 @@ human consumption.</p>
 <p>Directory where the report is written. The default value is the empty string,
 indicating that reports are written to the current working directory of the
 Node.js process.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report directory is <span class="hljs-subst">${process.report.directory}</span>`</span>);</code></pre>
-<h3><code>process.report.filename</code><span><a class="mark" href="#process_process_report_filename" id="process_process_report_filename">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report directory is <span class="hljs-subst">${process.report.directory}</span>`</span>);</code></pre>
+<h4><code>process.report.filename</code><span><a class="mark" href="#process_process_report_filename" id="process_process_report_filename">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -48985,13 +53208,13 @@ Node.js process.</p>
 <p>Filename where the report is written. If set to the empty string, the output
 filename will be comprised of a timestamp, PID, and sequence number. The default
 value is the empty string.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report filename is <span class="hljs-subst">${process.report.filename}</span>`</span>);</code></pre>
-<h3><code>process.report.getReport([err])</code><span><a class="mark" href="#process_process_report_getreport_err" id="process_process_report_getreport_err">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report filename is <span class="hljs-subst">${process.report.filename}</span>`</span>);</code></pre>
+<h4><code>process.report.getReport([err])</code><span><a class="mark" href="#process_process_report_getreport_err" id="process_process_report_getreport_err">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
@@ -49005,30 +53228,37 @@ value is the empty string.</p>
 <p>Returns a JavaScript Object representation of a diagnostic report for the
 running process. The report's JavaScript stack trace is taken from <code>err</code>, if
 present.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> data = process.report.getReport();
-<span class="hljs-built_in">console</span>.log(data.header.nodeJsVersion);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> data = process.<span class="hljs-property">report</span>.<span class="hljs-title function_">getReport</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-property">header</span>.<span class="hljs-property">nodejsVersion</span>);
 
 <span class="hljs-comment">// Similar to process.report.writeReport()</span>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-fs.writeFileSync(util.inspect(data), <span class="hljs-string">'my-report.log'</span>, <span class="hljs-string">'utf8'</span>);</code></pre>
+fs.<span class="hljs-title function_">writeFileSync</span>(<span class="hljs-string">'my-report.log'</span>, util.<span class="hljs-title function_">inspect</span>(data), <span class="hljs-string">'utf8'</span>);</code></pre>
 <p>Additional documentation is available in the <a href="report.html">report documentation</a>.</p>
-<h3><code>process.report.reportOnFatalError</code><span><a class="mark" href="#process_process_report_reportonfatalerror" id="process_process_report_reportonfatalerror">#</a></span></h3>
+<h4><code>process.report.reportOnFatalError</code><span><a class="mark" href="#process_process_report_reportonfatalerror" id="process_process_report_reportonfatalerror">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.12.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>This API is no longer experimental.</p></td></tr>
+<tr><td>v11.12.0</td>
+<td><p><span>Added in: v11.12.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>If <code>true</code>, a diagnostic report is generated on fatal errors, such as out of
 memory errors or failed C++ assertions.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report on fatal error: <span class="hljs-subst">${process.report.reportOnFatalError}</span>`</span>);</code></pre>
-<h3><code>process.report.reportOnSignal</code><span><a class="mark" href="#process_process_report_reportonsignal" id="process_process_report_reportonsignal">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report on fatal error: <span class="hljs-subst">${process.report.reportOnFatalError}</span>`</span>);</code></pre>
+<h4><code>process.report.reportOnSignal</code><span><a class="mark" href="#process_process_report_reportonsignal" id="process_process_report_reportonsignal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -49040,13 +53270,13 @@ memory errors or failed C++ assertions.</p>
 </ul>
 <p>If <code>true</code>, a diagnostic report is generated when the process receives the
 signal specified by <code>process.report.signal</code>.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report on signal: <span class="hljs-subst">${process.report.reportOnSignal}</span>`</span>);</code></pre>
-<h3><code>process.report.reportOnUncaughtException</code><span><a class="mark" href="#process_process_report_reportonuncaughtexception" id="process_process_report_reportonuncaughtexception">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report on signal: <span class="hljs-subst">${process.report.reportOnSignal}</span>`</span>);</code></pre>
+<h4><code>process.report.reportOnUncaughtException</code><span><a class="mark" href="#process_process_report_reportonuncaughtexception" id="process_process_report_reportonuncaughtexception">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -49057,13 +53287,13 @@ signal specified by <code>process.report.signal</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>If <code>true</code>, a diagnostic report is generated on uncaught exception.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report on exception: <span class="hljs-subst">${process.report.reportOnUncaughtException}</span>`</span>);</code></pre>
-<h3><code>process.report.signal</code><span><a class="mark" href="#process_process_report_signal" id="process_process_report_signal">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report on exception: <span class="hljs-subst">${process.report.reportOnUncaughtException}</span>`</span>);</code></pre>
+<h4><code>process.report.signal</code><span><a class="mark" href="#process_process_report_signal" id="process_process_report_signal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -49075,13 +53305,13 @@ signal specified by <code>process.report.signal</code>.</p>
 </ul>
 <p>The signal used to trigger the creation of a diagnostic report. Defaults to
 <code>'SIGUSR2'</code>.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report signal: <span class="hljs-subst">${process.report.signal}</span>`</span>);</code></pre>
-<h3><code>process.report.writeReport([filename][, err])</code><span><a class="mark" href="#process_process_report_writereport_filename_err" id="process_process_report_writereport_filename_err">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report signal: <span class="hljs-subst">${process.report.signal}</span>`</span>);</code></pre>
+<h4><code>process.report.writeReport([filename][, err])</code><span><a class="mark" href="#process_process_report_writereport_filename_err" id="process_process_report_writereport_filename_err">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
@@ -49105,9 +53335,9 @@ process, if unspecified.</p>
 <p>Writes a diagnostic report to a file. If <code>filename</code> is not provided, the default
 filename includes the date, time, PID, and a sequence number. The report's
 JavaScript stack trace is taken from <code>err</code>, if present.</p>
-<pre><code class="language-js">process.report.writeReport();</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>();</code></pre>
 <p>Additional documentation is available in the <a href="report.html">report documentation</a>.</p>
-<h2><code>process.resourceUsage()</code><span><a class="mark" href="#process_process_resourceusage" id="process_process_resourceusage">#</a></span></h2>
+</section><section><h3><code>process.resourceUsage()</code><span><a class="mark" href="#process_process_resourceusage" id="process_process_resourceusage">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v12.6.0</span>
 </div>
@@ -49158,7 +53388,7 @@ time slice. This field is not supported on Windows.</li>
 </ul>
 </li>
 </ul>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.resourceUsage());
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">resourceUsage</span>());
 <span class="hljs-comment">/*
   Will output:
   {
@@ -49180,7 +53410,7 @@ time slice. This field is not supported on Windows.</li>
     involuntaryContextSwitches: 1
   }
 */</span></code></pre>
-<h2><code>process.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#process_process_send_message_sendhandle_options_callback" id="process_process_send_message_sendhandle_options_callback">#</a></span></h2>
+</section><section><h3><code>process.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#process_process_send_message_sendhandle_options_callback" id="process_process_send_message_sendhandle_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -49205,7 +53435,7 @@ used to send messages to the parent process. Messages will be received as a
 <code>undefined</code>.</p>
 <p>The message goes through serialization and parsing. The resulting message might
 not be the same as what is originally sent.</p>
-<h2><code>process.setegid(id)</code><span><a class="mark" href="#process_process_setegid_id" id="process_process_setegid_id">#</a></span></h2>
+</section><section><h3><code>process.setegid(id)</code><span><a class="mark" href="#process_process_setegid_id" id="process_process_setegid_id">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
@@ -49216,19 +53446,19 @@ not be the same as what is originally sent.</p>
 (See <a href="http://man7.org/linux/man-pages/man2/setegid.2.html"><code>setegid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a group
 name string. If a group name is specified, this method blocks while resolving
 the associated a numeric ID.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getegid &#x26;&#x26; process.setegid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getegid</span> &#x26;&#x26; process.<span class="hljs-property">setegid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
   <span class="hljs-keyword">try</span> {
-    process.setegid(<span class="hljs-number">501</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
+    process.<span class="hljs-title function_">setegid</span>(<span class="hljs-number">501</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Failed to set gid: <span class="hljs-subst">${err}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set gid: <span class="hljs-subst">${err}</span>`</span>);
   }
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.seteuid(id)</code><span><a class="mark" href="#process_process_seteuid_id" id="process_process_seteuid_id">#</a></span></h2>
+</section><section><h3><code>process.seteuid(id)</code><span><a class="mark" href="#process_process_seteuid_id" id="process_process_seteuid_id">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
@@ -49239,19 +53469,19 @@ This feature is not available in <a href="#worker_threads_class_worker"><code>Wo
 (See <a href="http://man7.org/linux/man-pages/man2/seteuid.2.html"><code>seteuid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a username
 string. If a username is specified, the method blocks while resolving the
 associated numeric ID.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.geteuid &#x26;&#x26; process.seteuid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">geteuid</span> &#x26;&#x26; process.<span class="hljs-property">seteuid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
   <span class="hljs-keyword">try</span> {
-    process.seteuid(<span class="hljs-number">501</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
+    process.<span class="hljs-title function_">seteuid</span>(<span class="hljs-number">501</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Failed to set uid: <span class="hljs-subst">${err}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set uid: <span class="hljs-subst">${err}</span>`</span>);
   }
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.setgid(id)</code><span><a class="mark" href="#process_process_setgid_id" id="process_process_setgid_id">#</a></span></h2>
+</section><section><h3><code>process.setgid(id)</code><span><a class="mark" href="#process_process_setgid_id" id="process_process_setgid_id">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.31</span>
 </div>
@@ -49262,19 +53492,19 @@ This feature is not available in <a href="#worker_threads_class_worker"><code>Wo
 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html"><code>setgid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a group name
 string. If a group name is specified, this method blocks while resolving the
 associated numeric ID.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getgid &#x26;&#x26; process.setgid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getgid</span> &#x26;&#x26; process.<span class="hljs-property">setgid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
   <span class="hljs-keyword">try</span> {
-    process.setgid(<span class="hljs-number">501</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
+    process.<span class="hljs-title function_">setgid</span>(<span class="hljs-number">501</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Failed to set gid: <span class="hljs-subst">${err}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set gid: <span class="hljs-subst">${err}</span>`</span>);
   }
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.setgroups(groups)</code><span><a class="mark" href="#process_process_setgroups_groups" id="process_process_setgroups_groups">#</a></span></h2>
+</section><section><h3><code>process.setgroups(groups)</code><span><a class="mark" href="#process_process_setgroups_groups" id="process_process_setgroups_groups">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -49284,11 +53514,19 @@ This feature is not available in <a href="#worker_threads_class_worker"><code>Wo
 <p>The <code>process.setgroups()</code> method sets the supplementary group IDs for the
 Node.js process. This is a privileged operation that requires the Node.js
 process to have <code>root</code> or the <code>CAP_SETGID</code> capability.</p>
-<p>The <code>groups</code> array can contain numeric group IDs, group names or both.</p>
+<p>The <code>groups</code> array can contain numeric group IDs, group names, or both.</p>
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getgroups</span> &#x26;&#x26; process.<span class="hljs-property">setgroups</span>) {
+  <span class="hljs-keyword">try</span> {
+    process.<span class="hljs-title function_">setgroups</span>([<span class="hljs-number">501</span>]);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>()); <span class="hljs-comment">// new groups</span>
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set groups: <span class="hljs-subst">${err}</span>`</span>);
+  }
+}</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.setuid(id)</code><span><a class="mark" href="#process_process_setuid_id" id="process_process_setuid_id">#</a></span></h2>
+</section><section><h3><code>process.setuid(id)</code><span><a class="mark" href="#process_process_setuid_id" id="process_process_setuid_id">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.28</span>
 </div>
@@ -49299,19 +53537,33 @@ This feature is not available in <a href="#worker_threads_class_worker"><code>Wo
 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html"><code>setuid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a username string.
 If a username is specified, the method blocks while resolving the associated
 numeric ID.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getuid &#x26;&#x26; process.setuid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getuid</span> &#x26;&#x26; process.<span class="hljs-property">setuid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
   <span class="hljs-keyword">try</span> {
-    process.setuid(<span class="hljs-number">501</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
+    process.<span class="hljs-title function_">setuid</span>(<span class="hljs-number">501</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Failed to set uid: <span class="hljs-subst">${err}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set uid: <span class="hljs-subst">${err}</span>`</span>);
   }
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.setUncaughtExceptionCaptureCallback(fn)</code><span><a class="mark" href="#process_process_setuncaughtexceptioncapturecallback_fn" id="process_process_setuncaughtexceptioncapturecallback_fn">#</a></span></h2>
+</section><section><h3><code>process.setSourceMapsEnabled(val)</code><span><a class="mark" href="#process_process_setsourcemapsenabled_val" id="process_process_setsourcemapsenabled_val">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<ul>
+<li><code>val</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>This function enables or disables the <a href="https://sourcemaps.info/spec.html">Source Map v3</a> support for
+stack traces.</p>
+<p>It provides same features as launching Node.js process with commandline options
+<code>--enable-source-maps</code>.</p>
+<p>Only source maps in JavaScript files that are loaded after source maps has been
+enabled will be parsed and loaded.</p>
+</section><section><h3><code>process.setUncaughtExceptionCaptureCallback(fn)</code><span><a class="mark" href="#process_process_setuncaughtexceptioncapturecallback_fn" id="process_process_setuncaughtexceptioncapturecallback_fn">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.3.0</span>
 </div>
@@ -49324,14 +53576,15 @@ exception value itself as its first argument.</p>
 <p>If such a function is set, the <a href="#process_event_uncaughtexception"><code>'uncaughtException'</code></a> event will
 not be emitted. If <code>--abort-on-uncaught-exception</code> was passed from the
 command line or set through <a href="#v8_v8_setflagsfromstring_flags"><code>v8.setFlagsFromString()</code></a>, the process will
-not abort.</p>
+not abort. Actions configured to take place on exceptions such as report
+generations will be affected too</p>
 <p>To unset the capture function,
 <code>process.setUncaughtExceptionCaptureCallback(null)</code> may be used. Calling this
 method with a non-<code>null</code> argument while another capture function is set will
 throw an error.</p>
 <p>Using this function is mutually exclusive with using the deprecated
 <a href="domain.html"><code>domain</code></a> built-in module.</p>
-<h2><code>process.stderr</code><span><a class="mark" href="#process_process_stderr" id="process_process_stderr">#</a></span></h2>
+</section><section><h3><code>process.stderr</code><span><a class="mark" href="#process_process_stderr" id="process_process_stderr">#</a></span></h3>
 <ul>
 <li><a href="#stream_stream" class="type">&#x3C;Stream></a></li>
 </ul>
@@ -49341,14 +53594,14 @@ stream) unless fd <code>2</code> refers to a file, in which case it is
 a <a href="#stream_writable_streams">Writable</a> stream.</p>
 <p><code>process.stderr</code> differs from other Node.js streams in important ways. See
 <a href="#process_a_note_on_process_i_o">note on process I/O</a> for more information.</p>
-<h3><code>process.stderr.fd</code><span><a class="mark" href="#process_process_stderr_fd" id="process_process_stderr_fd">#</a></span></h3>
+<h4><code>process.stderr.fd</code><span><a class="mark" href="#process_process_stderr_fd" id="process_process_stderr_fd">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>This property refers to the value of underlying file descriptor of
 <code>process.stderr</code>. The value is fixed at <code>2</code>. In <a href="#worker_threads_class_worker"><code>Worker</code></a> threads,
 this field does not exist.</p>
-<h2><code>process.stdin</code><span><a class="mark" href="#process_process_stdin" id="process_process_stdin">#</a></span></h2>
+</section><section><h3><code>process.stdin</code><span><a class="mark" href="#process_process_stdin" id="process_process_stdin">#</a></span></h3>
 <ul>
 <li><a href="#stream_stream" class="type">&#x3C;Stream></a></li>
 </ul>
@@ -49363,14 +53616,14 @@ For more information see <a href="#stream_compatibility_with_older_node_js_versi
 <p>In "old" streams mode the <code>stdin</code> stream is paused by default, so one
 must call <code>process.stdin.resume()</code> to read from it. Note also that calling
 <code>process.stdin.resume()</code> itself would switch stream to "old" mode.</p>
-<h3><code>process.stdin.fd</code><span><a class="mark" href="#process_process_stdin_fd" id="process_process_stdin_fd">#</a></span></h3>
+<h4><code>process.stdin.fd</code><span><a class="mark" href="#process_process_stdin_fd" id="process_process_stdin_fd">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>This property refers to the value of underlying file descriptor of
 <code>process.stdin</code>. The value is fixed at <code>0</code>. In <a href="#worker_threads_class_worker"><code>Worker</code></a> threads,
 this field does not exist.</p>
-<h2><code>process.stdout</code><span><a class="mark" href="#process_process_stdout" id="process_process_stdout">#</a></span></h2>
+</section><section><h3><code>process.stdout</code><span><a class="mark" href="#process_process_stdout" id="process_process_stdout">#</a></span></h3>
 <ul>
 <li><a href="#stream_stream" class="type">&#x3C;Stream></a></li>
 </ul>
@@ -49379,17 +53632,17 @@ this field does not exist.</p>
 stream) unless fd <code>1</code> refers to a file, in which case it is
 a <a href="#stream_writable_streams">Writable</a> stream.</p>
 <p>For example, to copy <code>process.stdin</code> to <code>process.stdout</code>:</p>
-<pre><code class="language-js">process.stdin.pipe(process.stdout);</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
 <p><code>process.stdout</code> differs from other Node.js streams in important ways. See
 <a href="#process_a_note_on_process_i_o">note on process I/O</a> for more information.</p>
-<h3><code>process.stdout.fd</code><span><a class="mark" href="#process_process_stdout_fd" id="process_process_stdout_fd">#</a></span></h3>
+<h4><code>process.stdout.fd</code><span><a class="mark" href="#process_process_stdout_fd" id="process_process_stdout_fd">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>This property refers to the value of underlying file descriptor of
 <code>process.stdout</code>. The value is fixed at <code>1</code>. In <a href="#worker_threads_class_worker"><code>Worker</code></a> threads,
 this field does not exist.</p>
-<h3>A note on process I/O<span><a class="mark" href="#process_a_note_on_process_i_o" id="process_a_note_on_process_i_o">#</a></span></h3>
+<h4>A note on process I/O<span><a class="mark" href="#process_a_note_on_process_i_o" id="process_a_note_on_process_i_o">#</a></span></h4>
 <p><code>process.stdout</code> and <code>process.stderr</code> differ from other Node.js streams in
 important ways:</p>
 <ol>
@@ -49410,7 +53663,7 @@ create backward incompatibility, but they are also expected by some users.</p>
 <code>console.error()</code> being unexpectedly interleaved, or not written at all if
 <code>process.exit()</code> is called before an asynchronous write completes. See
 <a href="#process_process_exit_code"><code>process.exit()</code></a> for more information.</p>
-<p><strong><em>Warning</em></strong>: Synchronous writes block the event loop until the write has
+<p><em><strong>Warning</strong></em>: Synchronous writes block the event loop until the write has
 completed. This can be near instantaneous in the case of output to a file, but
 under high system load, pipes that are not being read at the receiving end, or
 with slow terminals or file systems, its possible for the event loop to be
@@ -49421,16 +53674,16 @@ the process output streams.</p>
 <p>To check if a stream is connected to a <a href="#tty_tty">TTY</a> context, check the <code>isTTY</code>
 property.</p>
 <p>For instance:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node -p <span class="hljs-string">"Boolean(process.stdin.isTTY)"</span></span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node -p <span class="hljs-string">"Boolean(process.stdin.isTTY)"</span></span>
 true
-<span class="hljs-meta">$</span><span class="bash"> <span class="hljs-built_in">echo</span> <span class="hljs-string">"foo"</span> | node -p <span class="hljs-string">"Boolean(process.stdin.isTTY)"</span></span>
+<span class="hljs-meta">$ </span><span class="language-bash"><span class="hljs-built_in">echo</span> <span class="hljs-string">"foo"</span> | node -p <span class="hljs-string">"Boolean(process.stdin.isTTY)"</span></span>
 false
-<span class="hljs-meta">$</span><span class="bash"> node -p <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span></span>
+<span class="hljs-meta">$ </span><span class="language-bash">node -p <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span></span>
 true
-<span class="hljs-meta">$</span><span class="bash"> node -p <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span> | cat</span>
+<span class="hljs-meta">$ </span><span class="language-bash">node -p <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span> | cat</span>
 false</code></pre>
 <p>See the <a href="#tty_tty">TTY</a> documentation for more information.</p>
-<h2><code>process.throwDeprecation</code><span><a class="mark" href="#process_process_throwdeprecation" id="process_process_throwdeprecation">#</a></span></h2>
+</section><section><h3><code>process.throwDeprecation</code><span><a class="mark" href="#process_process_throwdeprecation" id="process_process_throwdeprecation">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.12</span>
 </div>
@@ -49443,20 +53696,20 @@ false</code></pre>
 warnings result in errors may be altered at runtime. See the
 documentation for the <a href="#process_event_warning"><code>'warning'</code> event</a> and the
 <a href="#process_process_emitwarning_warning_type_code_ctor"><code>emitWarning()</code> method</a> for more information.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --throw-deprecation -p <span class="hljs-string">"process.throwDeprecation"</span></span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --throw-deprecation -p <span class="hljs-string">"process.throwDeprecation"</span></span>
 true
-<span class="hljs-meta">$</span><span class="bash"> node -p <span class="hljs-string">"process.throwDeprecation"</span></span>
+<span class="hljs-meta">$ </span><span class="language-bash">node -p <span class="hljs-string">"process.throwDeprecation"</span></span>
 undefined
-<span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> process.emitWarning(<span class="hljs-string">'test'</span>, <span class="hljs-string">'DeprecationWarning'</span>);</span>
+<span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.emitWarning(<span class="hljs-string">'test'</span>, <span class="hljs-string">'DeprecationWarning'</span>);</span>
 undefined
-<span class="hljs-meta">></span><span class="bash"> (node:26598) DeprecationWarning: <span class="hljs-built_in">test</span></span>
-<span class="hljs-meta">></span><span class="bash"> process.throwDeprecation = <span class="hljs-literal">true</span>;</span>
+<span class="hljs-meta">> </span><span class="language-bash">(node:26598) DeprecationWarning: <span class="hljs-built_in">test</span></span>
+<span class="hljs-meta">> </span><span class="language-bash">process.throwDeprecation = <span class="hljs-literal">true</span>;</span>
 true
-<span class="hljs-meta">></span><span class="bash"> process.emitWarning(<span class="hljs-string">'test'</span>, <span class="hljs-string">'DeprecationWarning'</span>);</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.emitWarning(<span class="hljs-string">'test'</span>, <span class="hljs-string">'DeprecationWarning'</span>);</span>
 Thrown:
 [DeprecationWarning: test] { name: 'DeprecationWarning' }</code></pre>
-<h2><code>process.title</code><span><a class="mark" href="#process_process_title" id="process_process_title">#</a></span></h2>
+</section><section><h3><code>process.title</code><span><a class="mark" href="#process_process_title" id="process_process_title">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.104</span>
 </div>
@@ -49469,7 +53722,7 @@ the current value of <code>ps</code>.</p>
 <p>When a new value is assigned, different platforms will impose different maximum
 length restrictions on the title. Usually such restrictions are quite limited.
 For instance, on Linux and macOS, <code>process.title</code> is limited to the size of the
-binary name plus the length of the command line arguments because setting the
+binary name plus the length of the command-line arguments because setting the
 <code>process.title</code> overwrites the <code>argv</code> memory of the process. Node.js v0.8
 allowed for longer process title strings by also overwriting the <code>environ</code>
 memory but that was potentially insecure and confusing in some (rather obscure)
@@ -49477,7 +53730,7 @@ cases.</p>
 <p>Assigning a value to <code>process.title</code> might not result in an accurate label
 within process manager applications such as macOS Activity Monitor or Windows
 Services Manager.</p>
-<h2><code>process.traceDeprecation</code><span><a class="mark" href="#process_process_tracedeprecation" id="process_process_tracedeprecation">#</a></span></h2>
+</section><section><h3><code>process.traceDeprecation</code><span><a class="mark" href="#process_process_tracedeprecation" id="process_process_tracedeprecation">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
@@ -49489,12 +53742,12 @@ Services Manager.</p>
 documentation for the <a href="#process_event_warning"><code>'warning'</code> event</a> and the
 <a href="#process_process_emitwarning_warning_type_code_ctor"><code>emitWarning()</code> method</a> for more information about this
 flag's behavior.</p>
-<h2><code>process.umask()</code><span><a class="mark" href="#process_process_umask" id="process_process_umask">#</a></span></h2>
+</section><section><h3><code>process.umask()</code><span><a class="mark" href="#process_process_umask" id="process_process_umask">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0, v14.0.0</td>
+<tr><td>v14.0.0, v12.19.0</td>
 <td><p>Calling <code>process.umask()</code> with no arguments is deprecated.</p></td></tr>
 <tr><td>v0.1.19</td>
 <td><p><span>Added in: v0.1.19</span></p></td></tr>
@@ -49507,7 +53760,7 @@ between threads, and is a potential security vulnerability. There is no safe,
 cross-platform alternative API.</div><p></p>
 <p><code>process.umask()</code> returns the Node.js process's file mode creation mask. Child
 processes inherit the mask from the parent process.</p>
-<h2><code>process.umask(mask)</code><span><a class="mark" href="#process_process_umask_mask" id="process_process_umask_mask">#</a></span></h2>
+</section><section><h3><code>process.umask(mask)</code><span><a class="mark" href="#process_process_umask_mask" id="process_process_umask_mask">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.19</span>
 </div>
@@ -49517,12 +53770,12 @@ processes inherit the mask from the parent process.</p>
 <p><code>process.umask(mask)</code> sets the Node.js process's file mode creation mask. Child
 processes inherit the mask from the parent process. Returns the previous mask.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> newmask = <span class="hljs-number">0o022</span>;
-<span class="hljs-keyword">const</span> oldmask = process.umask(newmask);
-<span class="hljs-built_in">console</span>.log(
+<span class="hljs-keyword">const</span> oldmask = process.<span class="hljs-title function_">umask</span>(newmask);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
   <span class="hljs-string">`Changed umask from <span class="hljs-subst">${oldmask.toString(<span class="hljs-number">8</span>)}</span> to <span class="hljs-subst">${newmask.toString(<span class="hljs-number">8</span>)}</span>`</span>
 );</code></pre>
 <p>In <a href="#worker_threads_class_worker"><code>Worker</code></a> threads, <code>process.umask(mask)</code> will throw an exception.</p>
-<h2><code>process.uptime()</code><span><a class="mark" href="#process_process_uptime" id="process_process_uptime">#</a></span></h2>
+</section><section><h3><code>process.uptime()</code><span><a class="mark" href="#process_process_uptime" id="process_process_uptime">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -49533,7 +53786,7 @@ processes inherit the mask from the parent process. Returns the previous mask.</
 process has been running.</p>
 <p>The return value includes fractions of a second. Use <code>Math.floor()</code> to get whole
 seconds.</p>
-<h2><code>process.version</code><span><a class="mark" href="#process_process_version" id="process_process_version">#</a></span></h2>
+</section><section><h3><code>process.version</code><span><a class="mark" href="#process_process_version" id="process_process_version">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.3</span>
 </div>
@@ -49541,11 +53794,11 @@ seconds.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The <code>process.version</code> property contains the Node.js version string.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Version: <span class="hljs-subst">${process.version}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Version: <span class="hljs-subst">${process.version}</span>`</span>);
 <span class="hljs-comment">// Version: v14.8.0</span></code></pre>
 <p>To get the version string without the prepended <em>v</em>, use
 <code>process.versions.node</code>.</p>
-<h2><code>process.versions</code><span><a class="mark" href="#process_process_versions" id="process_process_versions">#</a></span></h2>
+</section><section><h3><code>process.versions</code><span><a class="mark" href="#process_process_versions" id="process_process_versions">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -49566,7 +53819,7 @@ seconds.</p>
 Node.js and its dependencies. <code>process.versions.modules</code> indicates the current
 ABI version, which is increased whenever a C++ API changes. Node.js will refuse
 to load modules that were compiled against a different module ABI version.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.versions);</code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">versions</span>);</code></pre>
 <p>Will generate an object similar to:</p>
 <pre><code class="language-console">{ node: '11.13.0',
   v8: '7.0.276.38-node.18',
@@ -49578,13 +53831,12 @@ to load modules that were compiled against a different module ABI version.</p>
   nghttp2: '1.34.0',
   napi: '4',
   llhttp: '1.1.1',
-  http_parser: '2.8.0',
   openssl: '1.1.1b',
   cldr: '34.0',
   icu: '63.1',
   tz: '2018e',
   unicode: '11.0' }</code></pre>
-<h2>Exit codes<span><a class="mark" href="#process_exit_codes" id="process_exit_codes">#</a></span></h2>
+</section><section><h3>Exit codes<span><a class="mark" href="#process_exit_codes" id="process_exit_codes">#</a></span></h3>
 <p>Node.js will normally exit with a <code>0</code> status code when no more async
 operations are pending. The following status codes are used in other
 cases:</p>
@@ -49621,6 +53873,8 @@ when the bootstrapping function was called. This is extremely rare,
 and generally can only happen during development of Node.js itself.</li>
 <li><code>12</code> <strong>Invalid Debug Argument</strong>: The <code>--inspect</code> and/or <code>--inspect-brk</code>
 options were set, but the port number chosen was invalid or unavailable.</li>
+<li><code>13</code> <strong>Unfinished Top-Level Await</strong>: <code>await</code> was used outside of a function
+in the top-level code, but the passed <code>Promise</code> never resolved.</li>
 <li><code>>128</code> <strong>Signal Exits</strong>: If Node.js receives a fatal signal such as
 <code>SIGKILL</code> or <code>SIGHUP</code>, then its exit code will be <code>128</code> plus the
 value of the signal code. This is a standard POSIX practice, since
@@ -49628,18 +53882,21 @@ exit codes are defined to be 7-bit integers, and signal exits set
 the high-order bit, and then contain the value of the signal code.
 For example, signal <code>SIGABRT</code> has value <code>6</code>, so the expected exit
 code will be <code>128</code> + <code>6</code>, or <code>134</code>.</li>
-</ul>
-<h1>Punycode<span><a class="mark" href="#punycode_punycode" id="punycode_punycode">#</a></span></h1>
+</ul></section>
+        </section>
+<section><h2>Punycode<span><a class="mark" href="#punycode_punycode" id="punycode_punycode">#</a></span></h2>
 <div class="api_metadata">
 <span>Deprecated since: v7.0.0</span>
 </div>
 
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/punycode.js">lib/punycode.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/punycode.js">lib/punycode.js</a></p>
 <p><strong>The version of the punycode module bundled in Node.js is being deprecated</strong>.
 In a future major version of Node.js this module will be removed. Users
 currently depending on the <code>punycode</code> module should switch to using the
-userland-provided <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> module instead.</p>
+userland-provided <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> module instead. For punycode-based URL
+encoding, see <a href="#url_url_domaintoascii_domain"><code>url.domainToASCII</code></a> or, more generally, the
+<a href="#url_the_whatwg_url_api">WHATWG URL API</a>.</p>
 <p>The <code>punycode</code> module is a bundled version of the <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> module. It
 can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> punycode = <span class="hljs-built_in">require</span>(<span class="hljs-string">'punycode'</span>);</code></pre>
@@ -49655,7 +53912,7 @@ to <code>'example.com'</code>) is represented by Punycode as the ASCII string
 <p>The <code>punycode</code> module is a third-party dependency used by Node.js and
 made available to developers as a convenience. Fixes or other modifications to
 the module must be directed to the <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> project.</p>
-<h2><code>punycode.decode(string)</code><span><a class="mark" href="#punycode_punycode_decode_string" id="punycode_punycode_decode_string">#</a></span></h2>
+<section><h3><code>punycode.decode(string)</code><span><a class="mark" href="#punycode_punycode_decode_string" id="punycode_punycode_decode_string">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.1</span>
 </div>
@@ -49664,9 +53921,9 @@ the module must be directed to the <a href="https://github.com/bestiejs/punycode
 </ul>
 <p>The <code>punycode.decode()</code> method converts a <a href="https://tools.ietf.org/html/rfc3492">Punycode</a> string of ASCII-only
 characters to the equivalent string of Unicode codepoints.</p>
-<pre><code class="language-js">punycode.decode(<span class="hljs-string">'maana-pta'</span>); <span class="hljs-comment">// 'mañana'</span>
-punycode.decode(<span class="hljs-string">'--dqo34k'</span>); <span class="hljs-comment">// '☃-⌘'</span></code></pre>
-<h2><code>punycode.encode(string)</code><span><a class="mark" href="#punycode_punycode_encode_string" id="punycode_punycode_encode_string">#</a></span></h2>
+<pre><code class="language-js">punycode.<span class="hljs-title function_">decode</span>(<span class="hljs-string">'maana-pta'</span>); <span class="hljs-comment">// 'mañana'</span>
+punycode.<span class="hljs-title function_">decode</span>(<span class="hljs-string">'--dqo34k'</span>); <span class="hljs-comment">// '☃-⌘'</span></code></pre>
+</section><section><h3><code>punycode.encode(string)</code><span><a class="mark" href="#punycode_punycode_encode_string" id="punycode_punycode_encode_string">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.1</span>
 </div>
@@ -49675,9 +53932,9 @@ punycode.decode(<span class="hljs-string">'--dqo34k'</span>); <span class="hljs-
 </ul>
 <p>The <code>punycode.encode()</code> method converts a string of Unicode codepoints to a
 <a href="https://tools.ietf.org/html/rfc3492">Punycode</a> string of ASCII-only characters.</p>
-<pre><code class="language-js">punycode.encode(<span class="hljs-string">'mañana'</span>); <span class="hljs-comment">// 'maana-pta'</span>
-punycode.encode(<span class="hljs-string">'☃-⌘'</span>); <span class="hljs-comment">// '--dqo34k'</span></code></pre>
-<h2><code>punycode.toASCII(domain)</code><span><a class="mark" href="#punycode_punycode_toascii_domain" id="punycode_punycode_toascii_domain">#</a></span></h2>
+<pre><code class="language-js">punycode.<span class="hljs-title function_">encode</span>(<span class="hljs-string">'mañana'</span>); <span class="hljs-comment">// 'maana-pta'</span>
+punycode.<span class="hljs-title function_">encode</span>(<span class="hljs-string">'☃-⌘'</span>); <span class="hljs-comment">// '--dqo34k'</span></code></pre>
+</section><section><h3><code>punycode.toASCII(domain)</code><span><a class="mark" href="#punycode_punycode_toascii_domain" id="punycode_punycode_toascii_domain">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.1</span>
 </div>
@@ -49689,10 +53946,10 @@ Internationalized Domain Name to <a href="https://tools.ietf.org/html/rfc3492">P
 domain name will be converted. Calling <code>punycode.toASCII()</code> on a string that
 already only contains ASCII characters will have no effect.</p>
 <pre><code class="language-js"><span class="hljs-comment">// encode domain names</span>
-punycode.toASCII(<span class="hljs-string">'mañana.com'</span>);  <span class="hljs-comment">// 'xn--maana-pta.com'</span>
-punycode.toASCII(<span class="hljs-string">'☃-⌘.com'</span>);   <span class="hljs-comment">// 'xn----dqo34k.com'</span>
-punycode.toASCII(<span class="hljs-string">'example.com'</span>); <span class="hljs-comment">// 'example.com'</span></code></pre>
-<h2><code>punycode.toUnicode(domain)</code><span><a class="mark" href="#punycode_punycode_tounicode_domain" id="punycode_punycode_tounicode_domain">#</a></span></h2>
+punycode.<span class="hljs-title function_">toASCII</span>(<span class="hljs-string">'mañana.com'</span>);  <span class="hljs-comment">// 'xn--maana-pta.com'</span>
+punycode.<span class="hljs-title function_">toASCII</span>(<span class="hljs-string">'☃-⌘.com'</span>);   <span class="hljs-comment">// 'xn----dqo34k.com'</span>
+punycode.<span class="hljs-title function_">toASCII</span>(<span class="hljs-string">'example.com'</span>); <span class="hljs-comment">// 'example.com'</span></code></pre>
+</section><section><h3><code>punycode.toUnicode(domain)</code><span><a class="mark" href="#punycode_punycode_tounicode_domain" id="punycode_punycode_tounicode_domain">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.1</span>
 </div>
@@ -49703,14 +53960,14 @@ punycode.toASCII(<span class="hljs-string">'example.com'</span>); <span class="h
 containing <a href="https://tools.ietf.org/html/rfc3492">Punycode</a> encoded characters into Unicode. Only the <a href="https://tools.ietf.org/html/rfc3492">Punycode</a>
 encoded parts of the domain name are be converted.</p>
 <pre><code class="language-js"><span class="hljs-comment">// decode domain names</span>
-punycode.toUnicode(<span class="hljs-string">'xn--maana-pta.com'</span>); <span class="hljs-comment">// 'mañana.com'</span>
-punycode.toUnicode(<span class="hljs-string">'xn----dqo34k.com'</span>);  <span class="hljs-comment">// '☃-⌘.com'</span>
-punycode.toUnicode(<span class="hljs-string">'example.com'</span>);       <span class="hljs-comment">// 'example.com'</span></code></pre>
-<h2><code>punycode.ucs2</code><span><a class="mark" href="#punycode_punycode_ucs2" id="punycode_punycode_ucs2">#</a></span></h2>
+punycode.<span class="hljs-title function_">toUnicode</span>(<span class="hljs-string">'xn--maana-pta.com'</span>); <span class="hljs-comment">// 'mañana.com'</span>
+punycode.<span class="hljs-title function_">toUnicode</span>(<span class="hljs-string">'xn----dqo34k.com'</span>);  <span class="hljs-comment">// '☃-⌘.com'</span>
+punycode.<span class="hljs-title function_">toUnicode</span>(<span class="hljs-string">'example.com'</span>);       <span class="hljs-comment">// 'example.com'</span></code></pre>
+</section><section><h3><code>punycode.ucs2</code><span><a class="mark" href="#punycode_punycode_ucs2" id="punycode_punycode_ucs2">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
-<h3><code>punycode.ucs2.decode(string)</code><span><a class="mark" href="#punycode_punycode_ucs2_decode_string" id="punycode_punycode_ucs2_decode_string">#</a></span></h3>
+<h4><code>punycode.ucs2.decode(string)</code><span><a class="mark" href="#punycode_punycode_ucs2_decode_string" id="punycode_punycode_ucs2_decode_string">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -49719,10 +53976,10 @@ punycode.toUnicode(<span class="hljs-string">'example.com'</span>);       <span
 </ul>
 <p>The <code>punycode.ucs2.decode()</code> method returns an array containing the numeric
 codepoint values of each Unicode symbol in the string.</p>
-<pre><code class="language-js">punycode.ucs2.decode(<span class="hljs-string">'abc'</span>); <span class="hljs-comment">// [0x61, 0x62, 0x63]</span>
+<pre><code class="language-js">punycode.<span class="hljs-property">ucs2</span>.<span class="hljs-title function_">decode</span>(<span class="hljs-string">'abc'</span>); <span class="hljs-comment">// [0x61, 0x62, 0x63]</span>
 <span class="hljs-comment">// surrogate pair for U+1D306 tetragram for centre:</span>
-punycode.ucs2.decode(<span class="hljs-string">'\uD834\uDF06'</span>); <span class="hljs-comment">// [0x1D306]</span></code></pre>
-<h3><code>punycode.ucs2.encode(codePoints)</code><span><a class="mark" href="#punycode_punycode_ucs2_encode_codepoints" id="punycode_punycode_ucs2_encode_codepoints">#</a></span></h3>
+punycode.<span class="hljs-property">ucs2</span>.<span class="hljs-title function_">decode</span>(<span class="hljs-string">'\uD834\uDF06'</span>); <span class="hljs-comment">// [0x1D306]</span></code></pre>
+<h4><code>punycode.ucs2.encode(codePoints)</code><span><a class="mark" href="#punycode_punycode_ucs2_encode_codepoints" id="punycode_punycode_ucs2_encode_codepoints">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -49731,35 +53988,38 @@ punycode.ucs2.decode(<span class="hljs-string">'\uD834\uDF06'</span>); <span cla
 </ul>
 <p>The <code>punycode.ucs2.encode()</code> method returns a string based on an array of
 numeric code point values.</p>
-<pre><code class="language-js">punycode.ucs2.encode([<span class="hljs-number">0x61</span>, <span class="hljs-number">0x62</span>, <span class="hljs-number">0x63</span>]); <span class="hljs-comment">// 'abc'</span>
-punycode.ucs2.encode([<span class="hljs-number">0x1D306</span>]); <span class="hljs-comment">// '\uD834\uDF06'</span></code></pre>
-<h2><code>punycode.version</code><span><a class="mark" href="#punycode_punycode_version" id="punycode_punycode_version">#</a></span></h2>
+<pre><code class="language-js">punycode.<span class="hljs-property">ucs2</span>.<span class="hljs-title function_">encode</span>([<span class="hljs-number">0x61</span>, <span class="hljs-number">0x62</span>, <span class="hljs-number">0x63</span>]); <span class="hljs-comment">// 'abc'</span>
+punycode.<span class="hljs-property">ucs2</span>.<span class="hljs-title function_">encode</span>([<span class="hljs-number">0x1D306</span>]); <span class="hljs-comment">// '\uD834\uDF06'</span></code></pre>
+</section><section><h3><code>punycode.version</code><span><a class="mark" href="#punycode_punycode_version" id="punycode_punycode_version">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.1</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>Returns a string identifying the current <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> version number.</p>
-<h1>Query string<span><a class="mark" href="#querystring_query_string" id="querystring_query_string">#</a></span></h1>
+<p>Returns a string identifying the current <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> version number.</p></section>
+        </section>
+<section><h2>Query string<span><a class="mark" href="#querystring_query_string" id="querystring_query_string">#</a></span></h2>
 
-<p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/querystring.js">lib/querystring.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/querystring.js">lib/querystring.js</a></p>
 <p>The <code>querystring</code> module provides utilities for parsing and formatting URL
 query strings. It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> querystring = <span class="hljs-built_in">require</span>(<span class="hljs-string">'querystring'</span>);</code></pre>
-<h2><code>querystring.decode()</code><span><a class="mark" href="#querystring_querystring_decode" id="querystring_querystring_decode">#</a></span></h2>
+<p>The <code>querystring</code> API is considered Legacy. While it is still maintained,
+new code should use the <a href="#url_class_urlsearchparams" class="type">&#x3C;URLSearchParams></a> API instead.</p>
+<section><h3><code>querystring.decode()</code><span><a class="mark" href="#querystring_querystring_decode" id="querystring_querystring_decode">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
 <p>The <code>querystring.decode()</code> function is an alias for <code>querystring.parse()</code>.</p>
-<h2><code>querystring.encode()</code><span><a class="mark" href="#querystring_querystring_encode" id="querystring_querystring_encode">#</a></span></h2>
+</section><section><h3><code>querystring.encode()</code><span><a class="mark" href="#querystring_querystring_encode" id="querystring_querystring_encode">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
 <p>The <code>querystring.encode()</code> function is an alias for <code>querystring.stringify()</code>.</p>
-<h2><code>querystring.escape(str)</code><span><a class="mark" href="#querystring_querystring_escape_str" id="querystring_querystring_escape_str">#</a></span></h2>
+</section><section><h3><code>querystring.escape(str)</code><span><a class="mark" href="#querystring_querystring_escape_str" id="querystring_querystring_escape_str">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.25</span>
 </div>
@@ -49773,7 +54033,7 @@ query strings.</p>
 generally not expected to be used directly. It is exported primarily to allow
 application code to provide a replacement percent-encoding implementation if
 necessary by assigning <code>querystring.escape</code> to an alternative function.</p>
-<h2><code>querystring.parse(str[, sep[, eq[, options]]])</code><span><a class="mark" href="#querystring_querystring_parse_str_sep_eq_options" id="querystring_querystring_parse_str_sep_eq_options">#</a></span></h2>
+</section><section><h3><code>querystring.parse(str[, sep[, eq[, options]]])</code><span><a class="mark" href="#querystring_querystring_parse_str_sep_eq_options" id="querystring_querystring_parse_str_sep_eq_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -49822,9 +54082,9 @@ to use UTF-8 encoding. If an alternative character encoding is used, then an
 alternative <code>decodeURIComponent</code> option will need to be specified:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Assuming gbkDecodeURIComponent function already exists...</span>
 
-querystring.parse(<span class="hljs-string">'w=%D6%D0%CE%C4&#x26;foo=bar'</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>,
+querystring.<span class="hljs-title function_">parse</span>(<span class="hljs-string">'w=%D6%D0%CE%C4&#x26;foo=bar'</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>,
                   { <span class="hljs-attr">decodeURIComponent</span>: gbkDecodeURIComponent });</code></pre>
-<h2><code>querystring.stringify(obj[, sep[, eq[, options]]])</code><span><a class="mark" href="#querystring_querystring_stringify_obj_sep_eq_options" id="querystring_querystring_stringify_obj_sep_eq_options">#</a></span></h2>
+</section><section><h3><code>querystring.stringify(obj[, sep[, eq[, options]]])</code><span><a class="mark" href="#querystring_querystring_stringify_obj_sep_eq_options" id="querystring_querystring_stringify_obj_sep_eq_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.25</span>
 </div>
@@ -49845,21 +54105,22 @@ URL-unsafe characters to percent-encoding in the query string. <strong>Default:<
 <p>The <code>querystring.stringify()</code> method produces a URL query string from a
 given <code>obj</code> by iterating through the object's "own properties".</p>
 <p>It serializes the following types of values passed in <code>obj</code>:
-<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean[]></a>
-Any other input values will be coerced to empty strings.</p>
-<pre><code class="language-js">querystring.stringify({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: [<span class="hljs-string">'qux'</span>, <span class="hljs-string">'quux'</span>], <span class="hljs-attr">corge</span>: <span class="hljs-string">''</span> });
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean[]></a>
+The numeric values must be finite. Any other input values will be coerced to
+empty strings.</p>
+<pre><code class="language-js">querystring.<span class="hljs-title function_">stringify</span>({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: [<span class="hljs-string">'qux'</span>, <span class="hljs-string">'quux'</span>], <span class="hljs-attr">corge</span>: <span class="hljs-string">''</span> });
 <span class="hljs-comment">// Returns 'foo=bar&#x26;baz=qux&#x26;baz=quux&#x26;corge='</span>
 
-querystring.stringify({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: <span class="hljs-string">'qux'</span> }, <span class="hljs-string">';'</span>, <span class="hljs-string">':'</span>);
+querystring.<span class="hljs-title function_">stringify</span>({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: <span class="hljs-string">'qux'</span> }, <span class="hljs-string">';'</span>, <span class="hljs-string">':'</span>);
 <span class="hljs-comment">// Returns 'foo:bar;baz:qux'</span></code></pre>
 <p>By default, characters requiring percent-encoding within the query string will
 be encoded as UTF-8. If an alternative encoding is required, then an alternative
 <code>encodeURIComponent</code> option will need to be specified:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Assuming gbkEncodeURIComponent function already exists,</span>
 
-querystring.stringify({ <span class="hljs-attr">w</span>: <span class="hljs-string">'中文'</span>, <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span> }, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>,
+querystring.<span class="hljs-title function_">stringify</span>({ <span class="hljs-attr">w</span>: <span class="hljs-string">'中文'</span>, <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span> }, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>,
                       { <span class="hljs-attr">encodeURIComponent</span>: gbkEncodeURIComponent });</code></pre>
-<h2><code>querystring.unescape(str)</code><span><a class="mark" href="#querystring_querystring_unescape_str" id="querystring_querystring_unescape_str">#</a></span></h2>
+</section><section><h3><code>querystring.unescape(str)</code><span><a class="mark" href="#querystring_querystring_unescape_str" id="querystring_querystring_unescape_str">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.25</span>
 </div>
@@ -49874,11 +54135,12 @@ application code to provide a replacement decoding implementation if
 necessary by assigning <code>querystring.unescape</code> to an alternative function.</p>
 <p>By default, the <code>querystring.unescape()</code> method will attempt to use the
 JavaScript built-in <code>decodeURIComponent()</code> method to decode. If that fails,
-a safer equivalent that does not throw on malformed URLs will be used.</p>
-<h1>Readline<span><a class="mark" href="#readline_readline" id="readline_readline">#</a></span></h1>
+a safer equivalent that does not throw on malformed URLs will be used.</p></section>
+        </section>
+<section><h2>Readline<span><a class="mark" href="#readline_readline" id="readline_readline">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/readline.js">lib/readline.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/readline.js">lib/readline.js</a></p>
 <p>The <code>readline</code> module provides an interface for reading data from a <a href="#stream_readable_streams">Readable</a>
 stream (such as <a href="#process_process_stdin"><code>process.stdin</code></a>) one line at a time. It can be accessed
 using:</p>
@@ -49886,21 +54148,21 @@ using:</p>
 <p>The following simple example illustrates the basic use of the <code>readline</code> module.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
 
-<span class="hljs-keyword">const</span> rl = readline.createInterface({
-  <span class="hljs-attr">input</span>: process.stdin,
-  <span class="hljs-attr">output</span>: process.stdout
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
+  <span class="hljs-attr">input</span>: process.<span class="hljs-property">stdin</span>,
+  <span class="hljs-attr">output</span>: process.<span class="hljs-property">stdout</span>
 });
 
-rl.question(<span class="hljs-string">'What do you think of Node.js? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
+rl.<span class="hljs-title function_">question</span>(<span class="hljs-string">'What do you think of Node.js? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
   <span class="hljs-comment">// <span class="hljs-doctag">TODO:</span> Log the answer in a database</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Thank you for your valuable feedback: <span class="hljs-subst">${answer}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Thank you for your valuable feedback: <span class="hljs-subst">${answer}</span>`</span>);
 
-  rl.close();
+  rl.<span class="hljs-title function_">close</span>();
 });</code></pre>
 <p>Once this code is invoked, the Node.js application will not terminate until the
 <code>readline.Interface</code> is closed because the interface waits for data to be
 received on the <code>input</code> stream.</p>
-<h2>Class: <code>Interface</code><span><a class="mark" href="#readline_class_interface" id="readline_class_interface">#</a></span></h2>
+<section><h3>Class: <code>Interface</code><span><a class="mark" href="#readline_class_interface" id="readline_class_interface">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.104</span>
 </div>
@@ -49912,7 +54174,7 @@ received on the <code>input</code> stream.</p>
 single <code>input</code> <a href="#stream_readable_streams">Readable</a> stream and a single <code>output</code> <a href="#stream_writable_streams">Writable</a> stream.
 The <code>output</code> stream is used to print prompts for user input that arrives on,
 and is read from, the <code>input</code> stream.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#readline_event_close" id="readline_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#readline_event_close" id="readline_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -49921,26 +54183,43 @@ and is read from, the <code>input</code> stream.</p>
 <li>The <code>rl.close()</code> method is called and the <code>readline.Interface</code> instance has
 relinquished control over the <code>input</code> and <code>output</code> streams;</li>
 <li>The <code>input</code> stream receives its <code>'end'</code> event;</li>
-<li>The <code>input</code> stream receives <code>&#x3C;ctrl>-D</code> to signal end-of-transmission (EOT);</li>
-<li>The <code>input</code> stream receives <code>&#x3C;ctrl>-C</code> to signal <code>SIGINT</code> and there is no
-<code>'SIGINT'</code> event listener registered on the <code>readline.Interface</code> instance.</li>
+<li>The <code>input</code> stream receives <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal
+end-of-transmission (EOT);</li>
+<li>The <code>input</code> stream receives <kbd>Ctrl</kbd>+<kbd>C</kbd> to signal <code>SIGINT</code>
+and there is no <code>'SIGINT'</code> event listener registered on the
+<code>readline.Interface</code> instance.</li>
 </ul>
 <p>The listener function is called without passing any arguments.</p>
 <p>The <code>readline.Interface</code> instance is finished once the <code>'close'</code> event is
 emitted.</p>
-<h3>Event: <code>'line'</code><span><a class="mark" href="#readline_event_line" id="readline_event_line">#</a></span></h3>
+<h4>Event: <code>'line'</code><span><a class="mark" href="#readline_event_line" id="readline_event_line">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
 <p>The <code>'line'</code> event is emitted whenever the <code>input</code> stream receives an
 end-of-line input (<code>\n</code>, <code>\r</code>, or <code>\r\n</code>). This usually occurs when the user
-presses the <code>&#x3C;Enter></code>, or <code>&#x3C;Return></code> keys.</p>
+presses <kbd>Enter</kbd> or <kbd>Return</kbd>.</p>
 <p>The listener function is called with a string containing the single line of
 received input.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">input</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received: <span class="hljs-subst">${input}</span>`</span>);
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">input</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received: <span class="hljs-subst">${input}</span>`</span>);
+});</code></pre>
+<h4>Event: <code>'history'</code><span><a class="mark" href="#readline_event_history" id="readline_event_history">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>The <code>'history'</code> event is emitted whenever the history array has changed.</p>
+<p>The listener function is called with an array containing the history array.
+It will reflect all changes, added lines and removed lines due to
+<code>historySize</code> and <code>removeHistoryDuplicates</code>.</p>
+<p>The primary purpose is to allow a listener to persist the history.
+It is also possible for the listener to change the history object. This
+could be useful to prevent certain lines to be added to the history, like
+a password.</p>
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'history'</span>, <span class="hljs-function">(<span class="hljs-params">history</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received: <span class="hljs-subst">${history}</span>`</span>);
 });</code></pre>
-<h3>Event: <code>'pause'</code><span><a class="mark" href="#readline_event_pause" id="readline_event_pause">#</a></span></h3>
+<h4>Event: <code>'pause'</code><span><a class="mark" href="#readline_event_pause" id="readline_event_pause">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
@@ -49951,67 +54230,67 @@ received input.</p>
 events <a href="#readline_event_sigtstp"><code>'SIGTSTP'</code></a> and <a href="#readline_event_sigcont"><code>'SIGCONT'</code></a>.)</li>
 </ul>
 <p>The listener function is called without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'pause'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Readline paused.'</span>);
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'pause'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Readline paused.'</span>);
 });</code></pre>
-<h3>Event: <code>'resume'</code><span><a class="mark" href="#readline_event_resume" id="readline_event_resume">#</a></span></h3>
+<h4>Event: <code>'resume'</code><span><a class="mark" href="#readline_event_resume" id="readline_event_resume">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
 <p>The <code>'resume'</code> event is emitted whenever the <code>input</code> stream is resumed.</p>
 <p>The listener function is called without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'resume'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Readline resumed.'</span>);
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'resume'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Readline resumed.'</span>);
 });</code></pre>
-<h3>Event: <code>'SIGCONT'</code><span><a class="mark" href="#readline_event_sigcont" id="readline_event_sigcont">#</a></span></h3>
+<h4>Event: <code>'SIGCONT'</code><span><a class="mark" href="#readline_event_sigcont" id="readline_event_sigcont">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
 <p>The <code>'SIGCONT'</code> event is emitted when a Node.js process previously moved into
-the background using <code>&#x3C;ctrl>-Z</code> (i.e. <code>SIGTSTP</code>) is then brought back to the
-foreground using <a href="http://man7.org/linux/man-pages/man1/fg.1p.html"><code>fg(1p)</code></a>.</p>
+the background using <kbd>Ctrl</kbd>+<kbd>Z</kbd> (i.e. <code>SIGTSTP</code>) is then
+brought back to the foreground using <a href="http://man7.org/linux/man-pages/man1/fg.1p.html"><code>fg(1p)</code></a>.</p>
 <p>If the <code>input</code> stream was paused <em>before</em> the <code>SIGTSTP</code> request, this event will
 not be emitted.</p>
 <p>The listener function is invoked without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'SIGCONT'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGCONT'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// `prompt` will automatically resume the stream</span>
-  rl.prompt();
+  rl.<span class="hljs-title function_">prompt</span>();
 });</code></pre>
 <p>The <code>'SIGCONT'</code> event is <em>not</em> supported on Windows.</p>
-<h3>Event: <code>'SIGINT'</code><span><a class="mark" href="#readline_event_sigint" id="readline_event_sigint">#</a></span></h3>
+<h4>Event: <code>'SIGINT'</code><span><a class="mark" href="#readline_event_sigint" id="readline_event_sigint">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
 <p>The <code>'SIGINT'</code> event is emitted whenever the <code>input</code> stream receives a
-<code>&#x3C;ctrl>-C</code> input, known typically as <code>SIGINT</code>. If there are no <code>'SIGINT'</code> event
-listeners registered when the <code>input</code> stream receives a <code>SIGINT</code>, the <code>'pause'</code>
-event will be emitted.</p>
+<kbd>Ctrl+C</kbd> input, known typically as <code>SIGINT</code>. If there are no <code>'SIGINT'</code>
+event listeners registered when the <code>input</code> stream receives a <code>SIGINT</code>, the
+<code>'pause'</code> event will be emitted.</p>
 <p>The listener function is invoked without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'SIGINT'</span>, <span class="hljs-function">() =></span> {
-  rl.question(<span class="hljs-string">'Are you sure you want to exit? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
-    <span class="hljs-keyword">if</span> (answer.match(<span class="hljs-regexp">/^y(es)?$/i</span>)) rl.pause();
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGINT'</span>, <span class="hljs-function">() =></span> {
+  rl.<span class="hljs-title function_">question</span>(<span class="hljs-string">'Are you sure you want to exit? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
+    <span class="hljs-keyword">if</span> (answer.<span class="hljs-title function_">match</span>(<span class="hljs-regexp">/^y(es)?$/i</span>)) rl.<span class="hljs-title function_">pause</span>();
   });
 });</code></pre>
-<h3>Event: <code>'SIGTSTP'</code><span><a class="mark" href="#readline_event_sigtstp" id="readline_event_sigtstp">#</a></span></h3>
+<h4>Event: <code>'SIGTSTP'</code><span><a class="mark" href="#readline_event_sigtstp" id="readline_event_sigtstp">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
-<p>The <code>'SIGTSTP'</code> event is emitted when the <code>input</code> stream receives a <code>&#x3C;ctrl>-Z</code>
-input, typically known as <code>SIGTSTP</code>. If there are no <code>'SIGTSTP'</code> event listeners
-registered when the <code>input</code> stream receives a <code>SIGTSTP</code>, the Node.js process
-will be sent to the background.</p>
+<p>The <code>'SIGTSTP'</code> event is emitted when the <code>input</code> stream receives a
+<kbd>Ctrl</kbd>+<kbd>Z</kbd> input, typically known as <code>SIGTSTP</code>. If there are
+no <code>'SIGTSTP'</code> event listeners registered when the <code>input</code> stream receives a
+<code>SIGTSTP</code>, the Node.js process will be sent to the background.</p>
 <p>When the program is resumed using <a href="http://man7.org/linux/man-pages/man1/fg.1p.html"><code>fg(1p)</code></a>, the <code>'pause'</code> and <code>'SIGCONT'</code> events
 will be emitted. These can be used to resume the <code>input</code> stream.</p>
 <p>The <code>'pause'</code> and <code>'SIGCONT'</code> events will not be emitted if the <code>input</code> was
 paused before the process was sent to the background.</p>
 <p>The listener function is invoked without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'SIGTSTP'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGTSTP'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// This will override SIGTSTP and prevent the program from going to the</span>
   <span class="hljs-comment">// background.</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Caught SIGTSTP.'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Caught SIGTSTP.'</span>);
 });</code></pre>
 <p>The <code>'SIGTSTP'</code> event is <em>not</em> supported on Windows.</p>
-<h3><code>rl.close()</code><span><a class="mark" href="#readline_rl_close" id="readline_rl_close">#</a></span></h3>
+<h4><code>rl.close()</code><span><a class="mark" href="#readline_rl_close" id="readline_rl_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -50020,7 +54299,7 @@ relinquishes control over the <code>input</code> and <code>output</code> streams
 the <code>'close'</code> event will be emitted.</p>
 <p>Calling <code>rl.close()</code> does not immediately stop other events (including <code>'line'</code>)
 from being emitted by the <code>readline.Interface</code> instance.</p>
-<h3><code>rl.pause()</code><span><a class="mark" href="#readline_rl_pause" id="readline_rl_pause">#</a></span></h3>
+<h4><code>rl.pause()</code><span><a class="mark" href="#readline_rl_pause" id="readline_rl_pause">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -50028,7 +54307,7 @@ from being emitted by the <code>readline.Interface</code> instance.</p>
 later if necessary.</p>
 <p>Calling <code>rl.pause()</code> does not immediately pause other events (including
 <code>'line'</code>) from being emitted by the <code>readline.Interface</code> instance.</p>
-<h3><code>rl.prompt([preserveCursor])</code><span><a class="mark" href="#readline_rl_prompt_preservecursor" id="readline_rl_prompt_preservecursor">#</a></span></h3>
+<h4><code>rl.prompt([preserveCursor])</code><span><a class="mark" href="#readline_rl_prompt_preservecursor" id="readline_rl_prompt_preservecursor">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -50043,13 +54322,19 @@ location at which to provide input.</p>
 paused.</p>
 <p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or
 <code>undefined</code> the prompt is not written.</p>
-<h3><code>rl.question(query, callback)</code><span><a class="mark" href="#readline_rl_question_query_callback" id="readline_rl_question_query_callback">#</a></span></h3>
+<h4><code>rl.question(query[, options], callback)</code><span><a class="mark" href="#readline_rl_question_query_options_callback" id="readline_rl_question_query_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
 <ul>
 <li><code>query</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A statement or query to write to <code>output</code>, prepended to the
 prompt.</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Optionally allows the <code>question()</code> to be canceled
+using an <code>AbortController</code>.</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> A callback function that is invoked with the user's
 input in response to the <code>query</code>.</li>
 </ul>
@@ -50060,19 +54345,47 @@ function passing the provided input as the first argument.</p>
 paused.</p>
 <p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or
 <code>undefined</code> the <code>query</code> is not written.</p>
-<p>Example usage:</p>
-<pre><code class="language-js">rl.question(<span class="hljs-string">'What is your favorite food? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Oh, so your favorite food is <span class="hljs-subst">${answer}</span>`</span>);
-});</code></pre>
 <p>The <code>callback</code> function passed to <code>rl.question()</code> does not follow the typical
 pattern of accepting an <code>Error</code> object or <code>null</code> as the first argument.
 The <code>callback</code> is called with the provided answer as the only argument.</p>
-<h3><code>rl.resume()</code><span><a class="mark" href="#readline_rl_resume" id="readline_rl_resume">#</a></span></h3>
+<p>Example usage:</p>
+<pre><code class="language-js">rl.<span class="hljs-title function_">question</span>(<span class="hljs-string">'What is your favorite food? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Oh, so your favorite food is <span class="hljs-subst">${answer}</span>`</span>);
+});</code></pre>
+<p>Using an <code>AbortController</code> to cancel a question.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> signal = ac.<span class="hljs-property">signal</span>;
+
+rl.<span class="hljs-title function_">question</span>(<span class="hljs-string">'What is your favorite food? '</span>, { signal }, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Oh, so your favorite food is <span class="hljs-subst">${answer}</span>`</span>);
+});
+
+signal.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'abort'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The food question timed out'</span>);
+}, { <span class="hljs-attr">once</span>: <span class="hljs-literal">true</span> });
+
+<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> ac.<span class="hljs-title function_">abort</span>(), <span class="hljs-number">10000</span>);</code></pre>
+<p>If this method is invoked as it's util.promisify()ed version, it returns a
+Promise that fulfills with the answer. If the question is canceled using
+an <code>AbortController</code> it will reject with an <code>AbortError</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> question = util.<span class="hljs-title function_">promisify</span>(rl.<span class="hljs-property">question</span>).<span class="hljs-title function_">bind</span>(rl);
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">questionExample</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">const</span> answer = <span class="hljs-keyword">await</span> <span class="hljs-title function_">question</span>(<span class="hljs-string">'What is you favorite food? '</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Oh, so your favorite food is <span class="hljs-subst">${answer}</span>`</span>);
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Question rejected'</span>, err);
+  }
+}
+<span class="hljs-title function_">questionExample</span>();</code></pre>
+<h4><code>rl.resume()</code><span><a class="mark" href="#readline_rl_resume" id="readline_rl_resume">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
 <p>The <code>rl.resume()</code> method resumes the <code>input</code> stream if it has been paused.</p>
-<h3><code>rl.setPrompt(prompt)</code><span><a class="mark" href="#readline_rl_setprompt_prompt" id="readline_rl_setprompt_prompt">#</a></span></h3>
+<h4><code>rl.setPrompt(prompt)</code><span><a class="mark" href="#readline_rl_setprompt_prompt" id="readline_rl_setprompt_prompt">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -50081,7 +54394,15 @@ The <code>callback</code> is called with the provided answer as the only argumen
 </ul>
 <p>The <code>rl.setPrompt()</code> method sets the prompt that will be written to <code>output</code>
 whenever <code>rl.prompt()</code> is called.</p>
-<h3><code>rl.write(data[, key])</code><span><a class="mark" href="#readline_rl_write_data_key" id="readline_rl_write_data_key">#</a></span></h3>
+<h4><code>rl.getPrompt()</code><span><a class="mark" href="#readline_rl_getprompt" id="readline_rl_getprompt">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> the current prompt string</li>
+</ul>
+<p>The <code>rl.getPrompt()</code> method returns the current prompt used by <code>rl.prompt()</code>.</p>
+<h4><code>rl.write(data[, key])</code><span><a class="mark" href="#readline_rl_write_data_key" id="readline_rl_write_data_key">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -50089,9 +54410,9 @@ whenever <code>rl.prompt()</code> is called.</p>
 <li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>key</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>ctrl</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <code>&#x3C;ctrl></code> key.</li>
-<li><code>meta</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <code>&#x3C;Meta></code> key.</li>
-<li><code>shift</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <code>&#x3C;Shift></code> key.</li>
+<li><code>ctrl</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <kbd>Ctrl</kbd> key.</li>
+<li><code>meta</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <kbd>Meta</kbd> key.</li>
+<li><code>shift</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <kbd>Shift</kbd> key.</li>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The name of the a key.</li>
 </ul>
 </li>
@@ -50105,20 +54426,20 @@ combinations.</p>
 paused.</p>
 <p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or
 <code>undefined</code> the <code>data</code> and <code>key</code> are not written.</p>
-<pre><code class="language-js">rl.write(<span class="hljs-string">'Delete this!'</span>);
-<span class="hljs-comment">// Simulate Ctrl+u to delete the line written previously</span>
-rl.write(<span class="hljs-literal">null</span>, { <span class="hljs-attr">ctrl</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">name</span>: <span class="hljs-string">'u'</span> });</code></pre>
+<pre><code class="language-js">rl.<span class="hljs-title function_">write</span>(<span class="hljs-string">'Delete this!'</span>);
+<span class="hljs-comment">// Simulate Ctrl+U to delete the line written previously</span>
+rl.<span class="hljs-title function_">write</span>(<span class="hljs-literal">null</span>, { <span class="hljs-attr">ctrl</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">name</span>: <span class="hljs-string">'u'</span> });</code></pre>
 <p>The <code>rl.write()</code> method will write the data to the <code>readline</code> <code>Interface</code>'s
 <code>input</code> <em>as if it were provided by the user</em>.</p>
-<h3><code>rl[Symbol.asyncIterator]()</code><span><a class="mark" href="#readline_rl_symbol_asynciterator" id="readline_rl_symbol_asynciterator">#</a></span></h3>
+<h4><code>rl[Symbol.asyncIterator]()</code><span><a class="mark" href="#readline_rl_symbol_asynciterator" id="readline_rl_symbol_asynciterator">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.14.0</td>
+<tr><td>v11.4.0, v10.16.0</td>
+<td><p><span>Added in: v11.4.0, v10.16.0</span></p></td></tr>
+<tr><td>v11.14.0, v10.17.0</td>
 <td><p>Symbol.asyncIterator support is no longer experimental.</p></td></tr>
-<tr><td>v11.4.0</td>
-<td><p><span>Added in: v11.4.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -50134,8 +54455,8 @@ stream as a string. This method allows asynchronous iteration of
 <code>readline.Interface</code> will always consume the input stream fully.</p>
 <p>Performance is not on par with the traditional <code>'line'</code> event API. Use <code>'line'</code>
 instead for performance-sensitive applications.</p>
-<pre><code class="language-js"><span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">processLineByLine</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> rl = readline.createInterface({
+<pre><code class="language-js"><span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">processLineByLine</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
     <span class="hljs-comment">// ...</span>
   });
 
@@ -50144,12 +54465,23 @@ instead for performance-sensitive applications.</p>
     <span class="hljs-comment">// `line`.</span>
   }
 }</code></pre>
-<h3>rl.line<span><a class="mark" href="#readline_rl_line" id="readline_rl_line">#</a></span></h3>
+<p><code>readline.createInterface()</code> will start to consume the input stream once
+invoked. Having asynchronous operations between interface creation and
+asynchronous iteration may result in missed lines.</p>
+<h4><code>rl.line</code><span><a class="mark" href="#readline_rl_line" id="readline_rl_line">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.98</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Value will always be a string, never undefined.</p></td></tr>
+<tr><td>v0.1.98</td>
+<td><p><span>Added in: v0.1.98</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The current input data being processed by node.</p>
 <p>This can be used when collecting input from a TTY stream to retrieve the
@@ -50161,17 +54493,17 @@ unintended consequences if <code>rl.cursor</code> is not also controlled.</p>
 <p><strong>If not using a TTY stream for input, use the <a href="#readline_event_line"><code>'line'</code></a> event.</strong></p>
 <p>One possible use case would be as follows:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> values = [<span class="hljs-string">'lorem ipsum'</span>, <span class="hljs-string">'dolor sit amet'</span>];
-<span class="hljs-keyword">const</span> rl = readline.createInterface(process.stdin);
-<span class="hljs-keyword">const</span> showResults = debounce(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>(process.<span class="hljs-property">stdin</span>);
+<span class="hljs-keyword">const</span> showResults = <span class="hljs-title function_">debounce</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
     <span class="hljs-string">'\n'</span>,
-    values.filter(<span class="hljs-function">(<span class="hljs-params">val</span>) =></span> val.startsWith(rl.line)).join(<span class="hljs-string">' '</span>)
+    values.<span class="hljs-title function_">filter</span>(<span class="hljs-function">(<span class="hljs-params">val</span>) =></span> val.<span class="hljs-title function_">startsWith</span>(rl.<span class="hljs-property">line</span>)).<span class="hljs-title function_">join</span>(<span class="hljs-string">' '</span>)
   );
 }, <span class="hljs-number">300</span>);
-process.stdin.on(<span class="hljs-string">'keypress'</span>, <span class="hljs-function">(<span class="hljs-params">c, k</span>) =></span> {
-  showResults();
+process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'keypress'</span>, <span class="hljs-function">(<span class="hljs-params">c, k</span>) =></span> {
+  <span class="hljs-title function_">showResults</span>();
 });</code></pre>
-<h3>rl.cursor<span><a class="mark" href="#readline_rl_cursor" id="readline_rl_cursor">#</a></span></h3>
+<h4><code>rl.cursor</code><span><a class="mark" href="#readline_rl_cursor" id="readline_rl_cursor">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -50183,9 +54515,9 @@ process.stdin.on(<span class="hljs-string">'keypress'</span>, <span class="hljs-
 reading input from a TTY stream. The position of cursor determines the
 portion of the input string that will be modified as input is processed,
 as well as the column where the terminal caret will be rendered.</p>
-<h3><code>rl.getCursorPos()</code><span><a class="mark" href="#readline_rl_getcursorpos" id="readline_rl_getcursorpos">#</a></span></h3>
+<h4><code>rl.getCursorPos()</code><span><a class="mark" href="#readline_rl_getcursorpos" id="readline_rl_getcursorpos">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.5.0, v12.16.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -50198,7 +54530,7 @@ as well as the column where the terminal caret will be rendered.</p>
 <p>Returns the real position of the cursor in relation to the input
 prompt + string. Long input (wrapping) strings, as well as multiple
 line prompts are included in the calculations.</p>
-<h2><code>readline.clearLine(stream, dir[, callback])</code><span><a class="mark" href="#readline_readline_clearline_stream_dir_callback" id="readline_readline_clearline_stream_dir_callback">#</a></span></h2>
+</section><section><h3><code>readline.clearLine(stream, dir[, callback])</code><span><a class="mark" href="#readline_readline_clearline_stream_dir_callback" id="readline_readline_clearline_stream_dir_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -50226,7 +54558,7 @@ otherwise <code>true</code>.</li>
 </ul>
 <p>The <code>readline.clearLine()</code> method clears current line of given <a href="tty.html">TTY</a> stream
 in a specified direction identified by <code>dir</code>.</p>
-<h2><code>readline.clearScreenDown(stream[, callback])</code><span><a class="mark" href="#readline_readline_clearscreendown_stream_callback" id="readline_readline_clearscreendown_stream_callback">#</a></span></h2>
+</section><section><h3><code>readline.clearScreenDown(stream[, callback])</code><span><a class="mark" href="#readline_readline_clearscreendown_stream_callback" id="readline_readline_clearscreendown_stream_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -50247,12 +54579,18 @@ otherwise <code>true</code>.</li>
 </ul>
 <p>The <code>readline.clearScreenDown()</code> method clears the given <a href="tty.html">TTY</a> stream from
 the current position of the cursor down.</p>
-<h2><code>readline.createInterface(options)</code><span><a class="mark" href="#readline_readline_createinterface_options" id="readline_readline_createinterface_options">#</a></span></h2>
+</section><section><h3><code>readline.createInterface(options)</code><span><a class="mark" href="#readline_readline_createinterface_options" id="readline_readline_createinterface_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v8.3.0, 6.11.4</td>
+<tr><td>v14.18.0</td>
+<td><p>The <code>signal</code> option is supported now.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>history</code> option is supported now.</p></td></tr>
+<tr><td>v13.9.0</td>
+<td><p>The <code>tabSize</code> option is supported now.</p></td></tr>
+<tr><td>v8.3.0, v6.11.4</td>
 <td><p>Remove max limit of <code>crlfDelay</code> option.</p></td></tr>
 <tr><td>v6.6.0</td>
 <td><p>The <code>crlfDelay</code> option is supported now.</p></td></tr>
@@ -50276,11 +54614,18 @@ to.</li>
 <li><code>terminal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the <code>input</code> and <code>output</code> streams should be
 treated like a TTY, and have ANSI/VT100 escape codes written to it.
 <strong>Default:</strong> checking <code>isTTY</code> on the <code>output</code> stream upon instantiation.</li>
+<li><code>history</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> Initial list of history lines. This option makes sense
+only if <code>terminal</code> is set to <code>true</code> by the user or by an internal <code>output</code>
+check, otherwise the history caching mechanism is not initialized at all.
+<strong>Default:</strong> <code>[]</code>.</li>
 <li><code>historySize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Maximum number of history lines retained. To disable
 the history set this value to <code>0</code>. This option makes sense only if
 <code>terminal</code> is set to <code>true</code> by the user or by an internal <code>output</code> check,
 otherwise the history caching mechanism is not initialized at all.
 <strong>Default:</strong> <code>30</code>.</li>
+<li><code>removeHistoryDuplicates</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, when a new input line added
+to the history list duplicates an older one, this removes the older line
+from the list. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>prompt</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The prompt string to use. <strong>Default:</strong> <code>'> '</code>.</li>
 <li><code>crlfDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> If the delay between <code>\r</code> and <code>\n</code> exceeds
 <code>crlfDelay</code> milliseconds, both <code>\r</code> and <code>\n</code> will be treated as separate
@@ -50288,34 +54633,43 @@ end-of-line input. <code>crlfDelay</code> will be coerced to a number no less th
 <code>100</code>. It can be set to <code>Infinity</code>, in which case <code>\r</code> followed by <code>\n</code>
 will always be considered a single newline (which may be reasonable for
 <a href="#readline_example_read_file_stream_line_by_line">reading files</a> with <code>\r\n</code> line delimiter). <strong>Default:</strong> <code>100</code>.</li>
-<li><code>removeHistoryDuplicates</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, when a new input line added
-to the history list duplicates an older one, this removes the older line
-from the list. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>escapeCodeTimeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The duration <code>readline</code> will wait for a
 character (when reading an ambiguous key sequence in milliseconds one that
 can both form a complete key sequence using the input read so far and can
 take additional input to complete a longer key sequence).
 <strong>Default:</strong> <code>500</code>.</li>
+<li><code>tabSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of spaces a tab is equal to (minimum 1).
+<strong>Default:</strong> <code>8</code>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Allows closing the interface using an AbortSignal.
+Aborting the signal will internally call <code>close</code> on the interface.</li>
 </ul>
 </li>
+<li>Returns: <a href="#readline_class_interface" class="type">&#x3C;readline.Interface></a></li>
 </ul>
 <p>The <code>readline.createInterface()</code> method creates a new <code>readline.Interface</code>
 instance.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
-<span class="hljs-keyword">const</span> rl = readline.createInterface({
-  <span class="hljs-attr">input</span>: process.stdin,
-  <span class="hljs-attr">output</span>: process.stdout
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
+  <span class="hljs-attr">input</span>: process.<span class="hljs-property">stdin</span>,
+  <span class="hljs-attr">output</span>: process.<span class="hljs-property">stdout</span>
 });</code></pre>
 <p>Once the <code>readline.Interface</code> instance is created, the most common case is to
 listen for the <code>'line'</code> event:</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received: <span class="hljs-subst">${line}</span>`</span>);
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received: <span class="hljs-subst">${line}</span>`</span>);
 });</code></pre>
 <p>If <code>terminal</code> is <code>true</code> for this instance then the <code>output</code> stream will get
 the best compatibility if it defines an <code>output.columns</code> property and emits
 a <code>'resize'</code> event on the <code>output</code> if or when the columns ever change
 (<a href="#process_process_stdout"><code>process.stdout</code></a> does this automatically when it is a TTY).</p>
-<h3>Use of the <code>completer</code> function<span><a class="mark" href="#readline_use_of_the_completer_function" id="readline_use_of_the_completer_function">#</a></span></h3>
+<p>When creating a <code>readline.Interface</code> using <code>stdin</code> as input, the program
+will not terminate until it receives <code>EOF</code> (<kbd>Ctrl</kbd>+<kbd>D</kbd> on
+Linux/macOS, <kbd>Ctrl</kbd>+<kbd>Z</kbd> followed by <kbd>Return</kbd> on
+Windows).
+If you want your application to exit without waiting for user input, you can
+<a href="#net_socket_unref"><code>unref()</code></a> the standard input stream:</p>
+<pre><code class="language-js">process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">unref</span>();</code></pre>
+<h4>Use of the <code>completer</code> function<span><a class="mark" href="#readline_use_of_the_completer_function" id="readline_use_of_the_completer_function">#</a></span></h4>
 <p>The <code>completer</code> function takes the current line entered by the user
 as an argument, and returns an <code>Array</code> with 2 entries:</p>
 <ul>
@@ -50323,18 +54677,18 @@ as an argument, and returns an <code>Array</code> with 2 entries:</p>
 <li>The substring that was used for the matching.</li>
 </ul>
 <p>For instance: <code>[[substr1, substr2, ...], originalsubstring]</code>.</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">completer</span>(<span class="hljs-params">line</span>) </span>{
-  <span class="hljs-keyword">const</span> completions = <span class="hljs-string">'.help .error .exit .quit .q'</span>.split(<span class="hljs-string">' '</span>);
-  <span class="hljs-keyword">const</span> hits = completions.filter(<span class="hljs-function">(<span class="hljs-params">c</span>) =></span> c.startsWith(line));
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">completer</span>(<span class="hljs-params">line</span>) {
+  <span class="hljs-keyword">const</span> completions = <span class="hljs-string">'.help .error .exit .quit .q'</span>.<span class="hljs-title function_">split</span>(<span class="hljs-string">' '</span>);
+  <span class="hljs-keyword">const</span> hits = completions.<span class="hljs-title function_">filter</span>(<span class="hljs-function">(<span class="hljs-params">c</span>) =></span> c.<span class="hljs-title function_">startsWith</span>(line));
   <span class="hljs-comment">// Show all completions if none found</span>
-  <span class="hljs-keyword">return</span> [hits.length ? hits : completions, line];
+  <span class="hljs-keyword">return</span> [hits.<span class="hljs-property">length</span> ? hits : completions, line];
 }</code></pre>
 <p>The <code>completer</code> function can be called asynchronously if it accepts two
 arguments:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">completer</span>(<span class="hljs-params">linePartial, callback</span>) </span>{
-  callback(<span class="hljs-literal">null</span>, [[<span class="hljs-string">'123'</span>], linePartial]);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">completer</span>(<span class="hljs-params">linePartial, callback</span>) {
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, [[<span class="hljs-string">'123'</span>], linePartial]);
 }</code></pre>
-<h2><code>readline.cursorTo(stream, x[, y][, callback])</code><span><a class="mark" href="#readline_readline_cursorto_stream_x_y_callback" id="readline_readline_cursorto_stream_x_y_callback">#</a></span></h2>
+</section><section><h3><code>readline.cursorTo(stream, x[, y][, callback])</code><span><a class="mark" href="#readline_readline_cursorto_stream_x_y_callback" id="readline_readline_cursorto_stream_x_y_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -50357,7 +54711,7 @@ otherwise <code>true</code>.</li>
 </ul>
 <p>The <code>readline.cursorTo()</code> method moves cursor to the specified position in a
 given <a href="tty.html">TTY</a> <code>stream</code>.</p>
-<h2><code>readline.emitKeypressEvents(stream[, interface])</code><span><a class="mark" href="#readline_readline_emitkeypressevents_stream_interface" id="readline_readline_emitkeypressevents_stream_interface">#</a></span></h2>
+</section><section><h3><code>readline.emitKeypressEvents(stream[, interface])</code><span><a class="mark" href="#readline_readline_emitkeypressevents_stream_interface" id="readline_readline_emitkeypressevents_stream_interface">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -50373,10 +54727,10 @@ autocompletion is disabled when copy-pasted input is detected.</p>
 <p>This is automatically called by any readline instance on its <code>input</code> if the
 <code>input</code> is a terminal. Closing the <code>readline</code> instance does not stop
 the <code>input</code> from emitting <code>'keypress'</code> events.</p>
-<pre><code class="language-js">readline.emitKeypressEvents(process.stdin);
-<span class="hljs-keyword">if</span> (process.stdin.isTTY)
-  process.stdin.setRawMode(<span class="hljs-literal">true</span>);</code></pre>
-<h2><code>readline.moveCursor(stream, dx, dy[, callback])</code><span><a class="mark" href="#readline_readline_movecursor_stream_dx_dy_callback" id="readline_readline_movecursor_stream_dx_dy_callback">#</a></span></h2>
+<pre><code class="language-js">readline.<span class="hljs-title function_">emitKeypressEvents</span>(process.<span class="hljs-property">stdin</span>);
+<span class="hljs-keyword">if</span> (process.<span class="hljs-property">stdin</span>.<span class="hljs-property">isTTY</span>)
+  process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">setRawMode</span>(<span class="hljs-literal">true</span>);</code></pre>
+</section><section><h3><code>readline.moveCursor(stream, dx, dy[, callback])</code><span><a class="mark" href="#readline_readline_movecursor_stream_dx_dy_callback" id="readline_readline_movecursor_stream_dx_dy_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -50399,67 +54753,67 @@ otherwise <code>true</code>.</li>
 </ul>
 <p>The <code>readline.moveCursor()</code> method moves the cursor <em>relative</em> to its current
 position in a given <a href="tty.html">TTY</a> <code>stream</code>.</p>
-<h2>Example: Tiny CLI<span><a class="mark" href="#readline_example_tiny_cli" id="readline_example_tiny_cli">#</a></span></h2>
+</section><section><h3>Example: Tiny CLI<span><a class="mark" href="#readline_example_tiny_cli" id="readline_example_tiny_cli">#</a></span></h3>
 <p>The following example illustrates the use of <code>readline.Interface</code> class to
 implement a small command-line interface:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
-<span class="hljs-keyword">const</span> rl = readline.createInterface({
-  <span class="hljs-attr">input</span>: process.stdin,
-  <span class="hljs-attr">output</span>: process.stdout,
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
+  <span class="hljs-attr">input</span>: process.<span class="hljs-property">stdin</span>,
+  <span class="hljs-attr">output</span>: process.<span class="hljs-property">stdout</span>,
   <span class="hljs-attr">prompt</span>: <span class="hljs-string">'OHAI> '</span>
 });
 
-rl.prompt();
+rl.<span class="hljs-title function_">prompt</span>();
 
-rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
-  <span class="hljs-keyword">switch</span> (line.trim()) {
+rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
+  <span class="hljs-keyword">switch</span> (line.<span class="hljs-title function_">trim</span>()) {
     <span class="hljs-keyword">case</span> <span class="hljs-string">'hello'</span>:
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'world!'</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'world!'</span>);
       <span class="hljs-keyword">break</span>;
-    <span class="hljs-keyword">default</span>:
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Say what? I might have heard '<span class="hljs-subst">${line.trim()}</span>'`</span>);
+    <span class="hljs-attr">default</span>:
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Say what? I might have heard '<span class="hljs-subst">${line.trim()}</span>'`</span>);
       <span class="hljs-keyword">break</span>;
   }
-  rl.prompt();
-}).on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Have a great day!'</span>);
-  process.exit(<span class="hljs-number">0</span>);
+  rl.<span class="hljs-title function_">prompt</span>();
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Have a great day!'</span>);
+  process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">0</span>);
 });</code></pre>
-<h2>Example: Read file stream line-by-Line<span><a class="mark" href="#readline_example_read_file_stream_line_by_line" id="readline_example_read_file_stream_line_by_line">#</a></span></h2>
+</section><section><h3>Example: Read file stream line-by-Line<span><a class="mark" href="#readline_example_read_file_stream_line_by_line" id="readline_example_read_file_stream_line_by_line">#</a></span></h3>
 <p>A common use case for <code>readline</code> is to consume an input file one line at a
 time. The easiest way to do so is leveraging the <a href="#fs_class_fs_readstream"><code>fs.ReadStream</code></a> API as
 well as a <code>for await...of</code> loop:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">processLineByLine</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> fileStream = fs.createReadStream(<span class="hljs-string">'input.txt'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">processLineByLine</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> fileStream = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'input.txt'</span>);
 
-  <span class="hljs-keyword">const</span> rl = readline.createInterface({
+  <span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
     <span class="hljs-attr">input</span>: fileStream,
-    <span class="hljs-attr">crlfDelay</span>: <span class="hljs-literal">Infinity</span>
+    <span class="hljs-attr">crlfDelay</span>: <span class="hljs-title class_">Infinity</span>
   });
   <span class="hljs-comment">// Note: we use the crlfDelay option to recognize all instances of CR LF</span>
   <span class="hljs-comment">// ('\r\n') in input.txt as a single line break.</span>
 
   <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> line <span class="hljs-keyword">of</span> rl) {
     <span class="hljs-comment">// Each line in input.txt will be successively available here as `line`.</span>
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Line from file: <span class="hljs-subst">${line}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Line from file: <span class="hljs-subst">${line}</span>`</span>);
   }
 }
 
-processLineByLine();</code></pre>
+<span class="hljs-title function_">processLineByLine</span>();</code></pre>
 <p>Alternatively, one could use the <a href="#readline_event_line"><code>'line'</code></a> event:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
 
-<span class="hljs-keyword">const</span> rl = readline.createInterface({
-  <span class="hljs-attr">input</span>: fs.createReadStream(<span class="hljs-string">'sample.txt'</span>),
-  <span class="hljs-attr">crlfDelay</span>: <span class="hljs-literal">Infinity</span>
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
+  <span class="hljs-attr">input</span>: fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'sample.txt'</span>),
+  <span class="hljs-attr">crlfDelay</span>: <span class="hljs-title class_">Infinity</span>
 });
 
-rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Line from file: <span class="hljs-subst">${line}</span>`</span>);
+rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Line from file: <span class="hljs-subst">${line}</span>`</span>);
 });</code></pre>
 <p>Currently, <code>for await...of</code> loop can be a bit slower. If <code>async</code> / <code>await</code>
 flow and speed are both essential, a mixed approach can be applied:</p>
@@ -50467,25 +54821,25 @@ flow and speed are both essential, a mixed approach can be applied:</p>
 <span class="hljs-keyword">const</span> { createReadStream } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { createInterface } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
 
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">processLineByLine</span>(<span class="hljs-params"></span>) </span>{
+(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">processLineByLine</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">const</span> rl = createInterface({
-      <span class="hljs-attr">input</span>: createReadStream(<span class="hljs-string">'big-file.txt'</span>),
-      <span class="hljs-attr">crlfDelay</span>: <span class="hljs-literal">Infinity</span>
+    <span class="hljs-keyword">const</span> rl = <span class="hljs-title function_">createInterface</span>({
+      <span class="hljs-attr">input</span>: <span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'big-file.txt'</span>),
+      <span class="hljs-attr">crlfDelay</span>: <span class="hljs-title class_">Infinity</span>
     });
 
-    rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
+    rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
       <span class="hljs-comment">// Process the line.</span>
     });
 
-    <span class="hljs-keyword">await</span> once(rl, <span class="hljs-string">'close'</span>);
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(rl, <span class="hljs-string">'close'</span>);
 
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'File processed.'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'File processed.'</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.error(err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
   }
 })();</code></pre>
-<h2>TTY keybindings<span><a class="mark" href="#readline_tty_keybindings" id="readline_tty_keybindings">#</a></span></h2>
+</section><section><h3>TTY keybindings<span><a class="mark" href="#readline_tty_keybindings" id="readline_tty_keybindings">#</a></span></h3>
 <table>
   <tbody><tr>
     <th>Keybindings</th>
@@ -50493,130 +54847,131 @@ flow and speed are both essential, a mixed approach can be applied:</p>
     <th>Notes</th>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>shift</code> + <code>backspace</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Backspace</kbd></td>
     <td>Delete line left</td>
     <td>Doesn't work on Linux, Mac and Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>shift</code> + <code>delete</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Delete</kbd></td>
     <td>Delete line right</td>
     <td>Doesn't work on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>c</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>C</kbd></td>
     <td>Emit <code>SIGINT</code> or close the readline instance</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>h</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>H</kbd></td>
     <td>Delete left</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>d</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>D</kbd></td>
     <td>Delete right or close the readline instance in case the current line is empty / EOF</td>
     <td>Doesn't work on Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>u</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>U</kbd></td>
     <td>Delete from the current position to the line start</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>k</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>K</kbd></td>
     <td>Delete from the current position to the end of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>a</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>A</kbd></td>
     <td>Go to start of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>e</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>E</kbd></td>
     <td>Go to to end of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>b</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>B</kbd></td>
     <td>Back one character</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>f</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>F</kbd></td>
     <td>Forward one character</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>l</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>L</kbd></td>
     <td>Clear screen</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>n</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>N</kbd></td>
     <td>Next history item</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>p</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>P</kbd></td>
     <td>Previous history item</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>z</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Z</kbd></td>
     <td>Moves running process into background. Type
-    <code>fg</code> and press <code>enter</code>
+    <code>fg</code> and press <kbd>Enter</kbd>
     to return.</td>
     <td>Doesn't work on Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>w</code> or <code>ctrl</code>
-    + <code>backspace</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>W</kbd> or <kbd>Ctrl</kbd>
+   +<kbd>Backspace</kbd></td>
     <td>Delete backward to a word boundary</td>
-    <td><code>ctrl</code> + <code>backspace</code> Doesn't
+    <td><kbd>Ctrl</kbd>+<kbd>Backspace</kbd> Doesn't
     work on Linux, Mac and Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>delete</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Delete</kbd></td>
     <td>Delete forward to a word boundary</td>
     <td>Doesn't work on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>left</code> or
-    <code>meta</code> + <code>b</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> or
+    <kbd>Meta</kbd>+<kbd>B</kbd></td>
     <td>Word left</td>
-    <td><code>ctrl</code> + <code>left</code> Doesn't work
+    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> Doesn't work
     on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>right</code> or
-    <code>meta</code> + <code>f</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> or
+    <kbd>Meta</kbd>+<kbd>F</kbd></td>
     <td>Word right</td>
-    <td><code>ctrl</code> + <code>right</code> Doesn't work
+    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> Doesn't work
     on Mac</td>
   </tr>
   <tr>
-    <td><code>meta</code> + <code>d</code> or <code>meta</code>
-    + <code>delete</code></td>
+    <td><kbd>Meta</kbd>+<kbd>D</kbd> or <kbd>Meta</kbd>
+   +<kbd>Delete</kbd></td>
     <td>Delete word right</td>
-    <td><code>meta</code> + <code>delete</code> Doesn't work
+    <td><kbd>Meta</kbd>+<kbd>Delete</kbd> Doesn't work
     on windows</td>
   </tr>
   <tr>
-    <td><code>meta</code> + <code>backspace</code></td>
+    <td><kbd>Meta</kbd>+<kbd>Backspace</kbd></td>
     <td>Delete word left</td>
     <td>Doesn't work on Mac</td>
   </tr>
-</tbody></table>
-<h1>REPL<span><a class="mark" href="#repl_repl" id="repl_repl">#</a></span></h1>
+</tbody></table></section>
+        </section>
+<section><h2>REPL<span><a class="mark" href="#repl_repl" id="repl_repl">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/repl.js">lib/repl.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/repl.js">lib/repl.js</a></p>
 <p>The <code>repl</code> module provides a Read-Eval-Print-Loop (REPL) implementation that
 is available both as a standalone program or includible in other applications.
 It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);</code></pre>
-<h2>Design and features<span><a class="mark" href="#repl_design_and_features" id="repl_design_and_features">#</a></span></h2>
+<section><h3>Design and features<span><a class="mark" href="#repl_design_and_features" id="repl_design_and_features">#</a></span></h3>
 <p>The <code>repl</code> module exports the <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> class. While running,
 instances of <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> will accept individual lines of user input,
 evaluate those according to a user-defined evaluation function, then output the
@@ -50629,11 +54984,11 @@ ANSI-styled output, saving and restoring current REPL session state, error
 recovery, and customizable evaluation functions. Terminals that do not support
 ANSI styles and Emacs-style line editing automatically fall back to a limited
 feature set.</p>
-<h3>Commands and special keys<span><a class="mark" href="#repl_commands_and_special_keys" id="repl_commands_and_special_keys">#</a></span></h3>
+<h4>Commands and special keys<span><a class="mark" href="#repl_commands_and_special_keys" id="repl_commands_and_special_keys">#</a></span></h4>
 <p>The following special commands are supported by all REPL instances:</p>
 <ul>
-<li><code>.break</code>: When in the process of inputting a multi-line expression, entering
-the <code>.break</code> command (or pressing the <code>&#x3C;ctrl>-C</code> key combination) will abort
+<li><code>.break</code>: When in the process of inputting a multi-line expression, enter
+the <code>.break</code> command (or press <kbd>Ctrl</kbd>+<kbd>C</kbd>) to abort
 further input or processing of that expression.</li>
 <li><code>.clear</code>: Resets the REPL <code>context</code> to an empty object and clears any
 multi-line expression being input.</li>
@@ -50643,9 +54998,10 @@ multi-line expression being input.</li>
 <code>> .save ./file/to/save.js</code></li>
 <li><code>.load</code>: Load a file into the current REPL session.
 <code>> .load ./file/to/load.js</code></li>
-<li><code>.editor</code>: Enter editor mode (<code>&#x3C;ctrl>-D</code> to finish, <code>&#x3C;ctrl>-C</code> to cancel).</li>
+<li><code>.editor</code>: Enter editor mode (<kbd>Ctrl</kbd>+<kbd>D</kbd> to finish,
+<kbd>Ctrl</kbd>+<kbd>C</kbd> to cancel).</li>
 </ul>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> .editor</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">.editor</span>
 // Entering editor mode (^D to finish, ^C to cancel)
 function welcome(name) {
   return `Hello ${name}!`;
@@ -50658,62 +55014,63 @@ welcome('Node.js User');
 <span class="hljs-meta">></span></code></pre>
 <p>The following key combinations in the REPL have these special effects:</p>
 <ul>
-<li><code>&#x3C;ctrl>-C</code>: When pressed once, has the same effect as the <code>.break</code> command.
+<li><kbd>Ctrl</kbd>+<kbd>C</kbd>: When pressed once, has the same effect as the
+<code>.break</code> command.
 When pressed twice on a blank line, has the same effect as the <code>.exit</code>
 command.</li>
-<li><code>&#x3C;ctrl>-D</code>: Has the same effect as the <code>.exit</code> command.</li>
-<li><code>&#x3C;tab></code>: When pressed on a blank line, displays global and local (scope)
+<li><kbd>Ctrl</kbd>+<kbd>D</kbd>: Has the same effect as the <code>.exit</code> command.</li>
+<li><kbd>Tab</kbd>: When pressed on a blank line, displays global and local (scope)
 variables. When pressed while entering other input, displays relevant
 autocompletion options.</li>
 </ul>
 <p>For key bindings related to the reverse-i-search, see <a href="#repl_reverse_i_search"><code>reverse-i-search</code></a>.
 For all other key bindings, see <a href="#readline_tty_keybindings">TTY keybindings</a>.</p>
-<h3>Default evaluation<span><a class="mark" href="#repl_default_evaluation" id="repl_default_evaluation">#</a></span></h3>
+<h4>Default evaluation<span><a class="mark" href="#repl_default_evaluation" id="repl_default_evaluation">#</a></span></h4>
 <p>By default, all instances of <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> use an evaluation function
 that evaluates JavaScript expressions and provides access to Node.js built-in
 modules. This default behavior can be overridden by passing in an alternative
 evaluation function when the <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> instance is created.</p>
-<h4>JavaScript expressions<span><a class="mark" href="#repl_javascript_expressions" id="repl_javascript_expressions">#</a></span></h4>
+<h5>JavaScript expressions<span><a class="mark" href="#repl_javascript_expressions" id="repl_javascript_expressions">#</a></span></h5>
 <p>The default evaluator supports direct evaluation of JavaScript expressions:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> 1 + 1</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">1 + 1</span>
 2
-<span class="hljs-meta">></span><span class="bash"> const m = 2</span>
+<span class="hljs-meta">> </span><span class="language-bash">const m = 2</span>
 undefined
-<span class="hljs-meta">></span><span class="bash"> m + 1</span>
+<span class="hljs-meta">> </span><span class="language-bash">m + 1</span>
 3</code></pre>
 <p>Unless otherwise scoped within blocks or functions, variables declared
 either implicitly or using the <code>const</code>, <code>let</code>, or <code>var</code> keywords
 are declared at the global scope.</p>
-<h4>Global and local scope<span><a class="mark" href="#repl_global_and_local_scope" id="repl_global_and_local_scope">#</a></span></h4>
+<h5>Global and local scope<span><a class="mark" href="#repl_global_and_local_scope" id="repl_global_and_local_scope">#</a></span></h5>
 <p>The default evaluator provides access to any variables that exist in the global
 scope. It is possible to expose a variable to the REPL explicitly by assigning
 it to the <code>context</code> object associated with each <code>REPLServer</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 <span class="hljs-keyword">const</span> msg = <span class="hljs-string">'message'</span>;
 
-repl.start(<span class="hljs-string">'> '</span>).context.m = msg;</code></pre>
+repl.<span class="hljs-title function_">start</span>(<span class="hljs-string">'> '</span>).<span class="hljs-property">context</span>.<span class="hljs-property">m</span> = msg;</code></pre>
 <p>Properties in the <code>context</code> object appear as local within the REPL:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node repl_test.js</span>
-<span class="hljs-meta">></span><span class="bash"> m</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node repl_test.js</span>
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
 'message'</code></pre>
 <p>Context properties are not read-only by default. To specify read-only globals,
 context properties must be defined using <code>Object.defineProperty()</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 <span class="hljs-keyword">const</span> msg = <span class="hljs-string">'message'</span>;
 
-<span class="hljs-keyword">const</span> r = repl.start(<span class="hljs-string">'> '</span>);
-<span class="hljs-built_in">Object</span>.defineProperty(r.context, <span class="hljs-string">'m'</span>, {
+<span class="hljs-keyword">const</span> r = repl.<span class="hljs-title function_">start</span>(<span class="hljs-string">'> '</span>);
+<span class="hljs-title class_">Object</span>.<span class="hljs-title function_">defineProperty</span>(r.<span class="hljs-property">context</span>, <span class="hljs-string">'m'</span>, {
   <span class="hljs-attr">configurable</span>: <span class="hljs-literal">false</span>,
   <span class="hljs-attr">enumerable</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">value</span>: msg
 });</code></pre>
-<h4>Accessing core Node.js modules<span><a class="mark" href="#repl_accessing_core_node_js_modules" id="repl_accessing_core_node_js_modules">#</a></span></h4>
+<h5>Accessing core Node.js modules<span><a class="mark" href="#repl_accessing_core_node_js_modules" id="repl_accessing_core_node_js_modules">#</a></span></h5>
 <p>The default evaluator will automatically load Node.js core modules into the
 REPL environment when used. For instance, unless otherwise declared as a
 global or scoped variable, the input <code>fs</code> will be evaluated on-demand as
 <code>global.fs = require('fs')</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> fs.createReadStream(<span class="hljs-string">'./some/file'</span>);</span></code></pre>
-<h4>Global uncaught exceptions<span><a class="mark" href="#repl_global_uncaught_exceptions" id="repl_global_uncaught_exceptions">#</a></span></h4>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">fs.createReadStream(<span class="hljs-string">'./some/file'</span>);</span></code></pre>
+<h5>Global uncaught exceptions<span><a class="mark" href="#repl_global_uncaught_exceptions" id="repl_global_uncaught_exceptions">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -50727,26 +55084,25 @@ global or scoped variable, the input <code>fs</code> will be evaluated on-demand
 REPL session.</p>
 <p>This use of the <a href="domain.html"><code>domain</code></a> module in the REPL has these side effects:</p>
 <ul>
-<li>Uncaught exceptions only emit the <a href="#process_event_uncaughtexception"><code>'uncaughtException'</code></a> event in the
+<li>
+<p>Uncaught exceptions only emit the <a href="#process_event_uncaughtexception"><code>'uncaughtException'</code></a> event in the
 standalone REPL. Adding a listener for this event in a REPL within
-another Node.js program throws <a href="#errors_err_invalid_repl_input"><code>ERR_INVALID_REPL_INPUT</code></a>.</li>
-<li>Trying to use <a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> throws
-an <a href="#errors_err_domain_cannot_set_uncaught_exception_capture"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a> error.</li>
-</ul>
-<p>As standalone program:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'uncaughtException'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Uncaught'</span>));
+another Node.js program results in <a href="#errors_err_invalid_repl_input"><code>ERR_INVALID_REPL_INPUT</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> r = repl.<span class="hljs-title function_">start</span>();
 
-<span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'foobar'</span>);
-<span class="hljs-comment">// Uncaught</span></code></pre>
-<p>When used in another application:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'uncaughtException'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Uncaught'</span>));
-<span class="hljs-comment">// TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`</span>
-<span class="hljs-comment">// cannot be used in the REPL</span>
+r.<span class="hljs-title function_">write</span>(<span class="hljs-string">'process.on("uncaughtException", () => console.log("Foobar"));\n'</span>);
+<span class="hljs-comment">// Output stream includes:</span>
+<span class="hljs-comment">//   TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`</span>
+<span class="hljs-comment">//   cannot be used in the REPL</span>
 
-<span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'foobar'</span>);
-<span class="hljs-comment">// Thrown:</span>
-<span class="hljs-comment">// Error: foobar</span></code></pre>
-<h4>Assignment of the <code>_</code> (underscore) variable<span><a class="mark" href="#repl_assignment_of_the_underscore_variable" id="repl_assignment_of_the_underscore_variable">#</a></span></h4>
+r.<span class="hljs-title function_">close</span>();</code></pre>
+</li>
+<li>
+<p>Trying to use <a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> throws
+an <a href="#errors_err_domain_cannot_set_uncaught_exception_capture"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a> error.</p>
+</li>
+</ul>
+<h5>Assignment of the <code>_</code> (underscore) variable<span><a class="mark" href="#repl_assignment_of_the_underscore_variable" id="repl_assignment_of_the_underscore_variable">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -50759,89 +55115,101 @@ an <a href="#errors_err_domain_cannot_set_uncaught_exception_capture"><code>ERR_
 <p>The default evaluator will, by default, assign the result of the most recently
 evaluated expression to the special variable <code>_</code> (underscore).
 Explicitly setting <code>_</code> to a value will disable this behavior.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> [ <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-string">'c'</span> ]</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">[ <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-string">'c'</span> ]</span>
 [ 'a', 'b', 'c' ]
-<span class="hljs-meta">></span><span class="bash"> _.length</span>
+<span class="hljs-meta">> </span><span class="language-bash">_.length</span>
 3
-<span class="hljs-meta">></span><span class="bash"> _ += 1</span>
+<span class="hljs-meta">> </span><span class="language-bash">_ += 1</span>
 Expression assignment to _ now disabled.
 4
-<span class="hljs-meta">></span><span class="bash"> 1 + 1</span>
+<span class="hljs-meta">> </span><span class="language-bash">1 + 1</span>
 2
-<span class="hljs-meta">></span><span class="bash"> _</span>
+<span class="hljs-meta">> </span><span class="language-bash">_</span>
 4</code></pre>
 <p>Similarly, <code>_error</code> will refer to the last seen error, if there was any.
 Explicitly setting <code>_error</code> to a value will disable this behavior.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> throw new Error(<span class="hljs-string">'foo'</span>);</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">throw new Error(<span class="hljs-string">'foo'</span>);</span>
 Error: foo
-<span class="hljs-meta">></span><span class="bash"> _error.message</span>
+<span class="hljs-meta">> </span><span class="language-bash">_error.message</span>
 'foo'</code></pre>
-<h4><code>await</code> keyword<span><a class="mark" href="#repl_await_keyword" id="repl_await_keyword">#</a></span></h4>
-<p>With the <a href="#cli_experimental_repl_await"><code>--experimental-repl-await</code></a> command line option specified,
+<h5><code>await</code> keyword<span><a class="mark" href="#repl_await_keyword" id="repl_await_keyword">#</a></span></h5>
+<p>With the <a href="#cli_experimental_repl_await"><code>--experimental-repl-await</code></a> command-line option specified,
 experimental support for the <code>await</code> keyword is enabled.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> await Promise.resolve(123)</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">await Promise.resolve(123)</span>
 123
-<span class="hljs-meta">></span><span class="bash"> await Promise.reject(new Error(<span class="hljs-string">'REPL await'</span>))</span>
+<span class="hljs-meta">> </span><span class="language-bash">await Promise.reject(new Error(<span class="hljs-string">'REPL await'</span>))</span>
 Error: REPL await
     at repl:1:45
-<span class="hljs-meta">></span><span class="bash"> const timeout = util.promisify(setTimeout);</span>
+<span class="hljs-meta">> </span><span class="language-bash">const timeout = util.promisify(setTimeout);</span>
 undefined
-<span class="hljs-meta">></span><span class="bash"> const old = Date.now(); await timeout(1000); console.log(Date.now() - old);</span>
+<span class="hljs-meta">> </span><span class="language-bash">const old = Date.now(); await timeout(1000); console.log(Date.now() - old);</span>
 1002
 undefined</code></pre>
-<h3>Reverse-i-search<span><a class="mark" href="#repl_reverse_i_search" id="repl_reverse_i_search">#</a></span></h3>
+<p>One known limitation of using the <code>await</code> keyword in the REPL is that
+it will invalidate the lexical scoping of the <code>const</code> and <code>let</code>
+keywords.</p>
+<p>For example:</p>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">const m = await Promise.resolve(123)</span>
+undefined
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
+123
+<span class="hljs-meta">> </span><span class="language-bash">const m = await Promise.resolve(234)</span>
+undefined
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
+234</code></pre>
+<h4>Reverse-i-search<span><a class="mark" href="#repl_reverse_i_search" id="repl_reverse_i_search">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.6.0</span>
 </div>
 <p>The REPL supports bi-directional reverse-i-search similar to <a href="https://en.wikipedia.org/wiki/Z_shell">ZSH</a>. It is
-triggered with <code>&#x3C;ctrl> + R</code> to search backward and <code>&#x3C;ctrl> + S</code> to search
-forward.</p>
-<p>Duplicated history entires will be skipped.</p>
-<p>Entries are accepted as soon as any button is pressed that doesn't correspond
-with the reverse search. Cancelling is possible by pressing <code>escape</code> or
-<code>&#x3C;ctrl> + C</code>.</p>
+triggered with <kbd>Ctrl</kbd>+<kbd>R</kbd> to search backward and
+<kbd>Ctrl</kbd>+<kbd>S</kbd> to search
+forwards.</p>
+<p>Duplicated history entries will be skipped.</p>
+<p>Entries are accepted as soon as any key is pressed that doesn't correspond
+with the reverse search. Cancelling is possible by pressing <kbd>Esc</kbd> or
+<kbd>Ctrl</kbd>+<kbd>C</kbd>.</p>
 <p>Changing the direction immediately searches for the next entry in the expected
 direction from the current position on.</p>
-<h3>Custom evaluation functions<span><a class="mark" href="#repl_custom_evaluation_functions" id="repl_custom_evaluation_functions">#</a></span></h3>
+<h4>Custom evaluation functions<span><a class="mark" href="#repl_custom_evaluation_functions" id="repl_custom_evaluation_functions">#</a></span></h4>
 <p>When a new <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> is created, a custom evaluation function may be
 provided. This can be used, for instance, to implement fully customized REPL
 applications.</p>
 <p>The following illustrates a hypothetical example of a REPL that performs
 translation of text from one language to another:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
-<span class="hljs-keyword">const</span> { Translator } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'translator'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">Translator</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'translator'</span>);
 
-<span class="hljs-keyword">const</span> myTranslator = <span class="hljs-keyword">new</span> Translator(<span class="hljs-string">'en'</span>, <span class="hljs-string">'fr'</span>);
+<span class="hljs-keyword">const</span> myTranslator = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Translator</span>(<span class="hljs-string">'en'</span>, <span class="hljs-string">'fr'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) </span>{
-  callback(<span class="hljs-literal">null</span>, myTranslator.translate(cmd));
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) {
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, myTranslator.<span class="hljs-title function_">translate</span>(cmd));
 }
 
-repl.start({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span>, <span class="hljs-attr">eval</span>: myEval });</code></pre>
-<h4>Recoverable errors<span><a class="mark" href="#repl_recoverable_errors" id="repl_recoverable_errors">#</a></span></h4>
-<p>As a user is typing input into the REPL prompt, pressing the <code>&#x3C;enter></code> key will
-send the current line of input to the <code>eval</code> function. In order to support
-multi-line input, the eval function can return an instance of <code>repl.Recoverable</code>
-to the provided callback function:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) </span>{
+repl.<span class="hljs-title function_">start</span>({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span>, <span class="hljs-attr">eval</span>: myEval });</code></pre>
+<h5>Recoverable errors<span><a class="mark" href="#repl_recoverable_errors" id="repl_recoverable_errors">#</a></span></h5>
+<p>At the REPL prompt, pressing <kbd>Enter</kbd> sends the current line of input to
+the <code>eval</code> function. In order to support multi-line input, the <code>eval</code> function
+can return an instance of <code>repl.Recoverable</code> to the provided callback function:</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) {
   <span class="hljs-keyword">let</span> result;
   <span class="hljs-keyword">try</span> {
-    result = vm.runInThisContext(cmd);
+    result = vm.<span class="hljs-title function_">runInThisContext</span>(cmd);
   } <span class="hljs-keyword">catch</span> (e) {
-    <span class="hljs-keyword">if</span> (isRecoverableError(e)) {
-      <span class="hljs-keyword">return</span> callback(<span class="hljs-keyword">new</span> repl.Recoverable(e));
+    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isRecoverableError</span>(e)) {
+      <span class="hljs-keyword">return</span> <span class="hljs-title function_">callback</span>(<span class="hljs-keyword">new</span> repl.<span class="hljs-title class_">Recoverable</span>(e));
     }
   }
-  callback(<span class="hljs-literal">null</span>, result);
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, result);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">isRecoverableError</span>(<span class="hljs-params">error</span>) </span>{
-  <span class="hljs-keyword">if</span> (error.name === <span class="hljs-string">'SyntaxError'</span>) {
-    <span class="hljs-keyword">return</span> <span class="hljs-regexp">/^(Unexpected end of input|Unexpected token)/</span>.test(error.message);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">isRecoverableError</span>(<span class="hljs-params">error</span>) {
+  <span class="hljs-keyword">if</span> (error.<span class="hljs-property">name</span> === <span class="hljs-string">'SyntaxError'</span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-regexp">/^(Unexpected end of input|Unexpected token)/</span>.<span class="hljs-title function_">test</span>(error.<span class="hljs-property">message</span>);
   }
   <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
 }</code></pre>
-<h3>Customizing REPL output<span><a class="mark" href="#repl_customizing_repl_output" id="repl_customizing_repl_output">#</a></span></h3>
+<h4>Customizing REPL output<span><a class="mark" href="#repl_customizing_repl_output" id="repl_customizing_repl_output">#</a></span></h4>
 <p>By default, <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> instances format output using the
 <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a> method before writing the output to the provided <code>Writable</code>
 stream (<code>process.stdout</code> by default). The <code>showProxy</code> inspection option is set
@@ -50854,9 +55222,9 @@ default writer to use ANSI style codes to colorize the output from the
 REPL's <a href="#util_util_inspect_object_options">inspection defaults</a> from inside the REPL by using the
 <code>inspect.replDefaults</code> property which mirrors the <code>defaultOptions</code> from
 <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a>.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> util.inspect.replDefaults.compact = <span class="hljs-literal">false</span>;</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">util.inspect.replDefaults.compact = <span class="hljs-literal">false</span>;</span>
 false
-<span class="hljs-meta">></span><span class="bash"> [1]</span>
+<span class="hljs-meta">> </span><span class="language-bash">[1]</span>
 [
   1
 ]
@@ -50866,16 +55234,16 @@ function for the <code>writer</code> option on construction. The following examp
 instance, simply converts any input text to upper case:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 
-<span class="hljs-keyword">const</span> r = repl.start({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span>, <span class="hljs-attr">eval</span>: myEval, <span class="hljs-attr">writer</span>: myWriter });
+<span class="hljs-keyword">const</span> r = repl.<span class="hljs-title function_">start</span>({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span>, <span class="hljs-attr">eval</span>: myEval, <span class="hljs-attr">writer</span>: myWriter });
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) </span>{
-  callback(<span class="hljs-literal">null</span>, cmd);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) {
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, cmd);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">myWriter</span>(<span class="hljs-params">output</span>) </span>{
-  <span class="hljs-keyword">return</span> output.toUpperCase();
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">myWriter</span>(<span class="hljs-params">output</span>) {
+  <span class="hljs-keyword">return</span> output.<span class="hljs-title function_">toUpperCase</span>();
 }</code></pre>
-<h2>Class: <code>REPLServer</code><span><a class="mark" href="#repl_class_replserver" id="repl_class_replserver">#</a></span></h2>
+</section><section><h3>Class: <code>REPLServer</code><span><a class="mark" href="#repl_class_replserver" id="repl_class_replserver">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.91</span>
 </div>
@@ -50889,21 +55257,23 @@ or directly using the JavaScript <code>new</code> keyword.</p>
 
 <span class="hljs-keyword">const</span> options = { <span class="hljs-attr">useColors</span>: <span class="hljs-literal">true</span> };
 
-<span class="hljs-keyword">const</span> firstInstance = repl.start(options);
-<span class="hljs-keyword">const</span> secondInstance = <span class="hljs-keyword">new</span> repl.REPLServer(options);</code></pre>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#repl_event_exit" id="repl_event_exit">#</a></span></h3>
+<span class="hljs-keyword">const</span> firstInstance = repl.<span class="hljs-title function_">start</span>(options);
+<span class="hljs-keyword">const</span> secondInstance = <span class="hljs-keyword">new</span> repl.<span class="hljs-title function_">REPLServer</span>(options);</code></pre>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#repl_event_exit" id="repl_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>The <code>'exit'</code> event is emitted when the REPL is exited either by receiving the
-<code>.exit</code> command as input, the user pressing <code>&#x3C;ctrl>-C</code> twice to signal <code>SIGINT</code>,
-or by pressing <code>&#x3C;ctrl>-D</code> to signal <code>'end'</code> on the input stream. The listener
+<code>.exit</code> command as input, the user pressing <kbd>Ctrl</kbd>+<kbd>C</kbd> twice
+to signal <code>SIGINT</code>,
+or by pressing <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal <code>'end'</code> on the input
+stream. The listener
 callback is invoked without any arguments.</p>
-<pre><code class="language-js">replServer.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Received "exit" event from repl!'</span>);
-  process.exit();
+<pre><code class="language-js">replServer.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Received "exit" event from repl!'</span>);
+  process.<span class="hljs-title function_">exit</span>();
 });</code></pre>
-<h3>Event: <code>'reset'</code><span><a class="mark" href="#repl_event_reset" id="repl_event_reset">#</a></span></h3>
+<h4>Event: <code>'reset'</code><span><a class="mark" href="#repl_event_reset" id="repl_event_reset">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.0</span>
 </div>
@@ -50916,29 +55286,29 @@ reference to the <code>context</code> object as the only argument.</p>
 state:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">initializeContext</span>(<span class="hljs-params">context</span>) </span>{
-  context.m = <span class="hljs-string">'test'</span>;
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">initializeContext</span>(<span class="hljs-params">context</span>) {
+  context.<span class="hljs-property">m</span> = <span class="hljs-string">'test'</span>;
 }
 
-<span class="hljs-keyword">const</span> r = repl.start({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span> });
-initializeContext(r.context);
+<span class="hljs-keyword">const</span> r = repl.<span class="hljs-title function_">start</span>({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span> });
+<span class="hljs-title function_">initializeContext</span>(r.<span class="hljs-property">context</span>);
 
-r.on(<span class="hljs-string">'reset'</span>, initializeContext);</code></pre>
+r.<span class="hljs-title function_">on</span>(<span class="hljs-string">'reset'</span>, initializeContext);</code></pre>
 <p>When this code is executed, the global <code>'m'</code> variable can be modified but then
 reset to its initial value using the <code>.clear</code> command:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> ./node example.js</span>
-<span class="hljs-meta">></span><span class="bash"> m</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">./node example.js</span>
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
 'test'
-<span class="hljs-meta">></span><span class="bash"> m = 1</span>
+<span class="hljs-meta">> </span><span class="language-bash">m = 1</span>
 1
-<span class="hljs-meta">></span><span class="bash"> m</span>
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
 1
-<span class="hljs-meta">></span><span class="bash"> .clear</span>
+<span class="hljs-meta">> </span><span class="language-bash">.clear</span>
 Clearing context...
-<span class="hljs-meta">></span><span class="bash"> m</span>
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
 'test'
 <span class="hljs-meta">></span></code></pre>
-<h3><code>replServer.defineCommand(keyword, cmd)</code><span><a class="mark" href="#repl_replserver_definecommand_keyword_cmd" id="repl_replserver_definecommand_keyword_cmd">#</a></span></h3>
+<h4><code>replServer.defineCommand(keyword, cmd)</code><span><a class="mark" href="#repl_replserver_definecommand_keyword_cmd" id="repl_replserver_definecommand_keyword_cmd">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -50958,25 +55328,25 @@ string argument.</li>
 <p>The following example shows two new commands added to the REPL instance:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 
-<span class="hljs-keyword">const</span> replServer = repl.start({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span> });
-replServer.defineCommand(<span class="hljs-string">'sayhello'</span>, {
+<span class="hljs-keyword">const</span> replServer = repl.<span class="hljs-title function_">start</span>({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span> });
+replServer.<span class="hljs-title function_">defineCommand</span>(<span class="hljs-string">'sayhello'</span>, {
   <span class="hljs-attr">help</span>: <span class="hljs-string">'Say hello'</span>,
-  action(name) {
-    <span class="hljs-built_in">this</span>.clearBufferedCommand();
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Hello, <span class="hljs-subst">${name}</span>!`</span>);
-    <span class="hljs-built_in">this</span>.displayPrompt();
+  <span class="hljs-title function_">action</span>(<span class="hljs-params">name</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">clearBufferedCommand</span>();
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Hello, <span class="hljs-subst">${name}</span>!`</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">displayPrompt</span>();
   }
 });
-replServer.defineCommand(<span class="hljs-string">'saybye'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">saybye</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Goodbye!'</span>);
-  <span class="hljs-built_in">this</span>.close();
+replServer.<span class="hljs-title function_">defineCommand</span>(<span class="hljs-string">'saybye'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">saybye</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Goodbye!'</span>);
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">close</span>();
 });</code></pre>
 <p>The new commands can then be used from within the REPL instance:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> .sayhello Node.js User</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">.sayhello Node.js User</span>
 Hello, Node.js User!
-<span class="hljs-meta">></span><span class="bash"> .saybye</span>
+<span class="hljs-meta">> </span><span class="language-bash">.saybye</span>
 Goodbye!</code></pre>
-<h3><code>replServer.displayPrompt([preserveCursor])</code><span><a class="mark" href="#repl_replserver_displayprompt_preservecursor" id="repl_replserver_displayprompt_preservecursor">#</a></span></h3>
+<h4><code>replServer.displayPrompt([preserveCursor])</code><span><a class="mark" href="#repl_replserver_displayprompt_preservecursor" id="repl_replserver_displayprompt_preservecursor">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.91</span>
 </div>
@@ -50992,7 +55362,7 @@ and resuming the <code>input</code> to accept new input.</p>
 <p>The <code>replServer.displayPrompt</code> method is primarily intended to be called from
 within the action function for commands registered using the
 <code>replServer.defineCommand()</code> method.</p>
-<h3><code>replServer.clearBufferedCommand()</code><span><a class="mark" href="#repl_replserver_clearbufferedcommand" id="repl_replserver_clearbufferedcommand">#</a></span></h3>
+<h4><code>replServer.clearBufferedCommand()</code><span><a class="mark" href="#repl_replserver_clearbufferedcommand" id="repl_replserver_clearbufferedcommand">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -51000,7 +55370,7 @@ within the action function for commands registered using the
 buffered but not yet executed. This method is primarily intended to be
 called from within the action function for commands registered using the
 <code>replServer.defineCommand()</code> method.</p>
-<h3><code>replServer.parseREPLKeyword(keyword[, rest])</code><span><a class="mark" href="#repl_replserver_parsereplkeyword_keyword_rest" id="repl_replserver_parsereplkeyword_keyword_rest">#</a></span></h3>
+<h4><code>replServer.parseREPLKeyword(keyword[, rest])</code><span><a class="mark" href="#repl_replserver_parsereplkeyword_keyword_rest" id="repl_replserver_parsereplkeyword_keyword_rest">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.8.9</span><span>Deprecated since: v9.0.0</span>
 </div>
@@ -51012,7 +55382,7 @@ called from within the action function for commands registered using the
 </ul>
 <p>An internal method used to parse and execute <code>REPLServer</code> keywords.
 Returns <code>true</code> if <code>keyword</code> is a valid keyword, otherwise <code>false</code>.</p>
-<h3><code>replServer.setupHistory(historyPath, callback)</code><span><a class="mark" href="#repl_replserver_setuphistory_historypath_callback" id="repl_replserver_setuphistory_historypath_callback">#</a></span></h3>
+<h4><code>replServer.setupHistory(historyPath, callback)</code><span><a class="mark" href="#repl_replserver_setuphistory_historypath_callback" id="repl_replserver_setuphistory_historypath_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
 </div>
@@ -51026,16 +55396,24 @@ Returns <code>true</code> if <code>keyword</code> is a valid keyword, otherwise
 </li>
 </ul>
 <p>Initializes a history log file for the REPL instance. When executing the
-Node.js binary and using the command line REPL, a history file is initialized
+Node.js binary and using the command-line REPL, a history file is initialized
 by default. However, this is not the case when creating a REPL
 programmatically. Use this method to initialize a history log file when working
 with REPL instances programmatically.</p>
-<h2><code>repl.start([options])</code><span><a class="mark" href="#repl_repl_start_options" id="repl_repl_start_options">#</a></span></h2>
+</section><section><h3><code>repl.builtinModules</code><span><a class="mark" href="#repl_repl_builtinmodules" id="repl_repl_builtinmodules">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>A list of the names of all Node.js modules, e.g., <code>'http'</code>.</p>
+</section><section><h3><code>repl.start([options])</code><span><a class="mark" href="#repl_repl_start_options" id="repl_repl_start_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.4.0</td>
 <td><p>The <code>preview</code> option is now available.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>The <code>terminal</code> option now follows the default description in all cases and <code>useColors</code> checks <code>hasColors()</code> if available.</p></td></tr>
@@ -51080,9 +55458,9 @@ sets this value to <code>true</code>. <strong>Default:</strong> <code>false</cod
 will not output the return value of a command if it evaluates to
 <code>undefined</code>. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>writer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to invoke to format the output of each
- command before writing to <code>output</code>. <strong>Default:</strong> <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a>.</li>
+command before writing to <code>output</code>. <strong>Default:</strong> <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a>.</li>
 <li><code>completer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> An optional function used for custom Tab auto
- completion. See <a href="#readline_use_of_the_completer_function"><code>readline.InterfaceCompleter</code></a> for an example.</li>
+completion. See <a href="#readline_use_of_the_completer_function"><code>readline.InterfaceCompleter</code></a> for an example.</li>
 <li><code>replMode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> A flag that specifies whether the default evaluator
 executes all JavaScript commands in strict mode or default (sloppy) mode.
 Acceptable values are:
@@ -51093,7 +55471,8 @@ equivalent to prefacing every repl statement with <code>'use strict'</code>.</li
 </ul>
 </li>
 <li><code>breakEvalOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Stop evaluating the current piece of code when
-<code>SIGINT</code> is received, such as when <code>Ctrl+C</code> is pressed. This cannot be used
+<code>SIGINT</code> is received, such as when <kbd>Ctrl</kbd>+<kbd>C</kbd> is pressed.
+This cannot be used
 together with a custom <code>eval</code> function. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>preview</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Defines if the repl prints autocomplete and output
 previews or not. <strong>Default:</strong> <code>true</code> with the default eval function and
@@ -51108,23 +55487,23 @@ there are no previews and the value of <code>preview</code> has no effect.</li>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 
 <span class="hljs-comment">// a Unix style prompt</span>
-repl.start(<span class="hljs-string">'$ '</span>);</code></pre>
-<h2>The Node.js REPL<span><a class="mark" href="#repl_the_node_js_repl" id="repl_the_node_js_repl">#</a></span></h2>
+repl.<span class="hljs-title function_">start</span>(<span class="hljs-string">'$ '</span>);</code></pre>
+</section><section><h3>The Node.js REPL<span><a class="mark" href="#repl_the_node_js_repl" id="repl_the_node_js_repl">#</a></span></h3>
 <p>Node.js itself uses the <code>repl</code> module to provide its own interactive interface
 for executing JavaScript. This can be used by executing the Node.js binary
 without passing any arguments (or by passing the <code>-i</code> argument):</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> const a = [1, 2, 3];</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">const a = [1, 2, 3];</span>
 undefined
-<span class="hljs-meta">></span><span class="bash"> a</span>
+<span class="hljs-meta">> </span><span class="language-bash">a</span>
 [ 1, 2, 3 ]
-<span class="hljs-meta">></span><span class="bash"> a.forEach((v) => {</span>
+<span class="hljs-meta">> </span><span class="language-bash">a.forEach((v) => {</span>
 ...   console.log(v);
 ...   });
 1
 2
 3</code></pre>
-<h3>Environment variable options<span><a class="mark" href="#repl_environment_variable_options" id="repl_environment_variable_options">#</a></span></h3>
+<h4>Environment variable options<span><a class="mark" href="#repl_environment_variable_options" id="repl_environment_variable_options">#</a></span></h4>
 <p>Various behaviors of the Node.js REPL can be customized using the following
 environment variables:</p>
 <ul>
@@ -51140,18 +55519,18 @@ persisted if history is available. Must be a positive number.
 <li><code>NODE_REPL_MODE</code>: May be either <code>'sloppy'</code> or <code>'strict'</code>. <strong>Default:</strong>
 <code>'sloppy'</code>, which will allow non-strict mode code to be run.</li>
 </ul>
-<h3>Persistent history<span><a class="mark" href="#repl_persistent_history" id="repl_persistent_history">#</a></span></h3>
+<h4>Persistent history<span><a class="mark" href="#repl_persistent_history" id="repl_persistent_history">#</a></span></h4>
 <p>By default, the Node.js REPL will persist history between <code>node</code> REPL sessions
 by saving inputs to a <code>.node_repl_history</code> file located in the user's home
 directory. This can be disabled by setting the environment variable
 <code>NODE_REPL_HISTORY=''</code>.</p>
-<h3>Using the Node.js REPL with advanced line-editors<span><a class="mark" href="#repl_using_the_node_js_repl_with_advanced_line_editors" id="repl_using_the_node_js_repl_with_advanced_line_editors">#</a></span></h3>
+<h4>Using the Node.js REPL with advanced line-editors<span><a class="mark" href="#repl_using_the_node_js_repl_with_advanced_line_editors" id="repl_using_the_node_js_repl_with_advanced_line_editors">#</a></span></h4>
 <p>For advanced line-editors, start Node.js with the environment variable
 <code>NODE_NO_READLINE=1</code>. This will start the main and debugger REPL in canonical
 terminal settings, which will allow use with <code>rlwrap</code>.</p>
 <p>For example, the following can be added to a <code>.bashrc</code> file:</p>
 <pre><code class="language-text">alias node="env NODE_NO_READLINE=1 rlwrap node"</code></pre>
-<h3>Starting multiple REPL instances against a single running instance<span><a class="mark" href="#repl_starting_multiple_repl_instances_against_a_single_running_instance" id="repl_starting_multiple_repl_instances_against_a_single_running_instance">#</a></span></h3>
+<h4>Starting multiple REPL instances against a single running instance<span><a class="mark" href="#repl_starting_multiple_repl_instances_against_a_single_running_instance" id="repl_starting_multiple_repl_instances_against_a_single_running_instance">#</a></span></h4>
 <p>It is possible to create and run multiple REPL instances against a single
 running instance of Node.js that share a single <code>global</code> object but have
 separate I/O interfaces.</p>
@@ -51161,33 +55540,33 @@ socket, and a TCP socket:</p>
 <span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 <span class="hljs-keyword">let</span> connections = <span class="hljs-number">0</span>;
 
-repl.start({
+repl.<span class="hljs-title function_">start</span>({
   <span class="hljs-attr">prompt</span>: <span class="hljs-string">'Node.js via stdin> '</span>,
-  <span class="hljs-attr">input</span>: process.stdin,
-  <span class="hljs-attr">output</span>: process.stdout
+  <span class="hljs-attr">input</span>: process.<span class="hljs-property">stdin</span>,
+  <span class="hljs-attr">output</span>: process.<span class="hljs-property">stdout</span>
 });
 
-net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
   connections += <span class="hljs-number">1</span>;
-  repl.start({
+  repl.<span class="hljs-title function_">start</span>({
     <span class="hljs-attr">prompt</span>: <span class="hljs-string">'Node.js via Unix socket> '</span>,
     <span class="hljs-attr">input</span>: socket,
     <span class="hljs-attr">output</span>: socket
-  }).on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-    socket.end();
+  }).<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+    socket.<span class="hljs-title function_">end</span>();
   });
-}).listen(<span class="hljs-string">'/tmp/node-repl-sock'</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-string">'/tmp/node-repl-sock'</span>);
 
-net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
   connections += <span class="hljs-number">1</span>;
-  repl.start({
+  repl.<span class="hljs-title function_">start</span>({
     <span class="hljs-attr">prompt</span>: <span class="hljs-string">'Node.js via TCP socket> '</span>,
     <span class="hljs-attr">input</span>: socket,
     <span class="hljs-attr">output</span>: socket
-  }).on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-    socket.end();
+  }).<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+    socket.<span class="hljs-title function_">end</span>();
   });
-}).listen(<span class="hljs-number">5001</span>);</code></pre>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">5001</span>);</code></pre>
 <p>Running this application from the command line will start a REPL on stdin.
 Other REPL clients may connect through the Unix socket or TCP socket. <code>telnet</code>,
 for instance, is useful for connecting to TCP sockets, while <code>socat</code> can be used
@@ -51198,8 +55577,9 @@ possible to connect to a long-running Node.js process without restarting it.</p>
 a <code>net.Server</code> and <code>net.Socket</code> instance, see:
 <a href="https://gist.github.com/TooTallNate/2209310">https://gist.github.com/TooTallNate/2209310</a>.</p>
 <p>For an example of running a REPL instance over <a href="https://curl.haxx.se/docs/manpage.html"><code>curl(1)</code></a>, see:
-<a href="https://gist.github.com/TooTallNate/2053342">https://gist.github.com/TooTallNate/2053342</a>.</p>
-<h1>Diagnostic report<span><a class="mark" href="#report_diagnostic_report" id="report_diagnostic_report">#</a></span></h1>
+<a href="https://gist.github.com/TooTallNate/2053342">https://gist.github.com/TooTallNate/2053342</a>.</p></section>
+        </section>
+<section><h2>Diagnostic report<span><a class="mark" href="#report_diagnostic_report" id="report_diagnostic_report">#</a></span></h2>
 
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
@@ -51213,374 +55593,374 @@ on unhandled exceptions, fatal errors and user signals, in addition to
 triggering programmatically through API calls.</p>
 <p>A complete example report that was generated on an uncaught exception
 is provided below for reference.</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"header"</span>: {
-    <span class="hljs-attr">"reportVersion"</span>: <span class="hljs-number">1</span>,
-    <span class="hljs-attr">"event"</span>: <span class="hljs-string">"exception"</span>,
-    <span class="hljs-attr">"trigger"</span>: <span class="hljs-string">"Exception"</span>,
-    <span class="hljs-attr">"filename"</span>: <span class="hljs-string">"report.20181221.005011.8974.0.001.json"</span>,
-    <span class="hljs-attr">"dumpEventTime"</span>: <span class="hljs-string">"2018-12-21T00:50:11Z"</span>,
-    <span class="hljs-attr">"dumpEventTimeStamp"</span>: <span class="hljs-string">"1545371411331"</span>,
-    <span class="hljs-attr">"processId"</span>: <span class="hljs-number">8974</span>,
-    <span class="hljs-attr">"cwd"</span>: <span class="hljs-string">"/home/nodeuser/project/node"</span>,
-    <span class="hljs-attr">"commandLine"</span>: [
-      <span class="hljs-string">"/home/nodeuser/project/node/out/Release/node"</span>,
-      <span class="hljs-string">"--report-uncaught-exception"</span>,
-      <span class="hljs-string">"/home/nodeuser/project/node/test/report/test-exception.js"</span>,
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"header"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"reportVersion"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"event"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"exception"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"trigger"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Exception"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"filename"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"report.20181221.005011.8974.0.001.json"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"dumpEventTime"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"2018-12-21T00:50:11Z"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"dumpEventTimeStamp"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1545371411331"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"processId"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">8974</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cwd"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser/project/node"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"commandLine"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+      <span class="hljs-string">"/home/nodeuser/project/node/out/Release/node"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"--report-uncaught-exception"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"/home/nodeuser/project/node/test/report/test-exception.js"</span><span class="hljs-punctuation">,</span>
       <span class="hljs-string">"child"</span>
-    ],
-    <span class="hljs-attr">"nodejsVersion"</span>: <span class="hljs-string">"v12.0.0-pre"</span>,
-    <span class="hljs-attr">"glibcVersionRuntime"</span>: <span class="hljs-string">"2.17"</span>,
-    <span class="hljs-attr">"glibcVersionCompiler"</span>: <span class="hljs-string">"2.17"</span>,
-    <span class="hljs-attr">"wordSize"</span>: <span class="hljs-string">"64 bit"</span>,
-    <span class="hljs-attr">"arch"</span>: <span class="hljs-string">"x64"</span>,
-    <span class="hljs-attr">"platform"</span>: <span class="hljs-string">"linux"</span>,
-    <span class="hljs-attr">"componentVersions"</span>: {
-      <span class="hljs-attr">"node"</span>: <span class="hljs-string">"12.0.0-pre"</span>,
-      <span class="hljs-attr">"v8"</span>: <span class="hljs-string">"7.1.302.28-node.5"</span>,
-      <span class="hljs-attr">"uv"</span>: <span class="hljs-string">"1.24.1"</span>,
-      <span class="hljs-attr">"zlib"</span>: <span class="hljs-string">"1.2.11"</span>,
-      <span class="hljs-attr">"ares"</span>: <span class="hljs-string">"1.15.0"</span>,
-      <span class="hljs-attr">"modules"</span>: <span class="hljs-string">"68"</span>,
-      <span class="hljs-attr">"nghttp2"</span>: <span class="hljs-string">"1.34.0"</span>,
-      <span class="hljs-attr">"napi"</span>: <span class="hljs-string">"3"</span>,
-      <span class="hljs-attr">"llhttp"</span>: <span class="hljs-string">"1.0.1"</span>,
-      <span class="hljs-attr">"http_parser"</span>: <span class="hljs-string">"2.8.0"</span>,
-      <span class="hljs-attr">"openssl"</span>: <span class="hljs-string">"1.1.0j"</span>
-    },
-    <span class="hljs-attr">"release"</span>: {
-      <span class="hljs-attr">"name"</span>: <span class="hljs-string">"node"</span>
-    },
-    <span class="hljs-attr">"osName"</span>: <span class="hljs-string">"Linux"</span>,
-    <span class="hljs-attr">"osRelease"</span>: <span class="hljs-string">"3.10.0-862.el7.x86_64"</span>,
-    <span class="hljs-attr">"osVersion"</span>: <span class="hljs-string">"#1 SMP Wed Mar 21 18:14:51 EDT 2018"</span>,
-    <span class="hljs-attr">"osMachine"</span>: <span class="hljs-string">"x86_64"</span>,
-    <span class="hljs-attr">"cpus"</span>: [
-      {
-        <span class="hljs-attr">"model"</span>: <span class="hljs-string">"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz"</span>,
-        <span class="hljs-attr">"speed"</span>: <span class="hljs-number">2700</span>,
-        <span class="hljs-attr">"user"</span>: <span class="hljs-number">88902660</span>,
-        <span class="hljs-attr">"nice"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"sys"</span>: <span class="hljs-number">50902570</span>,
-        <span class="hljs-attr">"idle"</span>: <span class="hljs-number">241732220</span>,
-        <span class="hljs-attr">"irq"</span>: <span class="hljs-number">0</span>
-      },
-      {
-        <span class="hljs-attr">"model"</span>: <span class="hljs-string">"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz"</span>,
-        <span class="hljs-attr">"speed"</span>: <span class="hljs-number">2700</span>,
-        <span class="hljs-attr">"user"</span>: <span class="hljs-number">88902660</span>,
-        <span class="hljs-attr">"nice"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"sys"</span>: <span class="hljs-number">50902570</span>,
-        <span class="hljs-attr">"idle"</span>: <span class="hljs-number">241732220</span>,
-        <span class="hljs-attr">"irq"</span>: <span class="hljs-number">0</span>
-      }
-    ],
-    <span class="hljs-attr">"networkInterfaces"</span>: [
-      {
-        <span class="hljs-attr">"name"</span>: <span class="hljs-string">"en0"</span>,
-        <span class="hljs-attr">"internal"</span>: <span class="hljs-literal">false</span>,
-        <span class="hljs-attr">"mac"</span>: <span class="hljs-string">"13:10:de:ad:be:ef"</span>,
-        <span class="hljs-attr">"address"</span>: <span class="hljs-string">"10.0.0.37"</span>,
-        <span class="hljs-attr">"netmask"</span>: <span class="hljs-string">"255.255.255.0"</span>,
-        <span class="hljs-attr">"family"</span>: <span class="hljs-string">"IPv4"</span>
-      }
-    ],
-    <span class="hljs-attr">"host"</span>: <span class="hljs-string">"test_machine"</span>
-  },
-  <span class="hljs-attr">"javascriptStack"</span>: {
-    <span class="hljs-attr">"message"</span>: <span class="hljs-string">"Error: *** test-exception.js: throwing uncaught Error"</span>,
-    <span class="hljs-attr">"stack"</span>: [
-      <span class="hljs-string">"at myException (/home/nodeuser/project/node/test/report/test-exception.js:9:11)"</span>,
-      <span class="hljs-string">"at Object.&#x3C;anonymous> (/home/nodeuser/project/node/test/report/test-exception.js:12:3)"</span>,
-      <span class="hljs-string">"at Module._compile (internal/modules/cjs/loader.js:718:30)"</span>,
-      <span class="hljs-string">"at Object.Module._extensions..js (internal/modules/cjs/loader.js:729:10)"</span>,
-      <span class="hljs-string">"at Module.load (internal/modules/cjs/loader.js:617:32)"</span>,
-      <span class="hljs-string">"at tryModuleLoad (internal/modules/cjs/loader.js:560:12)"</span>,
-      <span class="hljs-string">"at Function.Module._load (internal/modules/cjs/loader.js:552:3)"</span>,
-      <span class="hljs-string">"at Function.Module.runMain (internal/modules/cjs/loader.js:771:12)"</span>,
+    <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"nodejsVersion"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"v12.0.0-pre"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"glibcVersionRuntime"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"2.17"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"glibcVersionCompiler"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"2.17"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"wordSize"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"64 bit"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"arch"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"x64"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"platform"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"linux"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"componentVersions"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"12.0.0-pre"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"v8"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"7.1.302.28-node.5"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"uv"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.24.1"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"zlib"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.2.11"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"ares"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.15.0"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"modules"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"68"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"nghttp2"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.34.0"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"napi"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"3"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"llhttp"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.0.1"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"openssl"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.1.0j"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"release"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"node"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"osName"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Linux"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"osRelease"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"3.10.0-862.el7.x86_64"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"osVersion"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"#1 SMP Wed Mar 21 18:14:51 EDT 2018"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"osMachine"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"x86_64"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cpus"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+      <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"model"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"speed"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2700</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"user"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">88902660</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"nice"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"sys"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">50902570</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"idle"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">241732220</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"irq"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"model"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"speed"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2700</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"user"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">88902660</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"nice"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"sys"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">50902570</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"idle"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">241732220</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"irq"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"networkInterfaces"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+      <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"en0"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"internal"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"mac"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"13:10:de:ad:be:ef"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"10.0.0.37"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"netmask"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"255.255.255.0"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"family"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"IPv4"</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"host"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"test_machine"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"javascriptStack"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"message"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Error: *** test-exception.js: throwing uncaught Error"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"stack"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+      <span class="hljs-string">"at myException (/home/nodeuser/project/node/test/report/test-exception.js:9:11)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Object.&#x3C;anonymous> (/home/nodeuser/project/node/test/report/test-exception.js:12:3)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Module._compile (internal/modules/cjs/loader.js:718:30)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Object.Module._extensions..js (internal/modules/cjs/loader.js:729:10)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Module.load (internal/modules/cjs/loader.js:617:32)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at tryModuleLoad (internal/modules/cjs/loader.js:560:12)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Function.Module._load (internal/modules/cjs/loader.js:552:3)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Function.Module.runMain (internal/modules/cjs/loader.js:771:12)"</span><span class="hljs-punctuation">,</span>
       <span class="hljs-string">"at executeUserCode (internal/bootstrap/node.js:332:15)"</span>
-    ]
-  },
-  <span class="hljs-attr">"nativeStack"</span>: [
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57f07a9ef"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">"report::GetNodeReport(v8::Isolate*, node::Environment*, char const*, char const*, v8::Local&#x3C;v8::String>, std::ostream&#x26;) [./node]"</span>
-    },
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57f07cf03"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">"report::GetReport(v8::FunctionCallbackInfo&#x3C;v8::Value> const&#x26;) [./node]"</span>
-    },
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57f1bccfd"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">" [./node]"</span>
-    },
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57f1be048"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">"v8::internal::Builtin_HandleApiCall(int, v8::internal::Object**, v8::internal::Isolate*) [./node]"</span>
-    },
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57feeda0e"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">" [./node]"</span>
-    }
-  ],
-  <span class="hljs-attr">"javascriptHeap"</span>: {
-    <span class="hljs-attr">"totalMemory"</span>: <span class="hljs-number">6127616</span>,
-    <span class="hljs-attr">"totalCommittedMemory"</span>: <span class="hljs-number">4357352</span>,
-    <span class="hljs-attr">"usedMemory"</span>: <span class="hljs-number">3221136</span>,
-    <span class="hljs-attr">"availableMemory"</span>: <span class="hljs-number">1521370240</span>,
-    <span class="hljs-attr">"memoryLimit"</span>: <span class="hljs-number">1526909922</span>,
-    <span class="hljs-attr">"heapSpaces"</span>: {
-      <span class="hljs-attr">"read_only_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">524288</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">39208</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">515584</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">30504</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">485080</span>
-      },
-      <span class="hljs-attr">"new_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">2097152</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">2019312</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">1031168</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">985496</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">45672</span>
-      },
-      <span class="hljs-attr">"old_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">2273280</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">1769008</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">1974640</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">1725488</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">249152</span>
-      },
-      <span class="hljs-attr">"code_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">696320</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">184896</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">152128</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">152128</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">0</span>
-      },
-      <span class="hljs-attr">"map_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">536576</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">344928</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">327520</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">327520</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">0</span>
-      },
-      <span class="hljs-attr">"large_object_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">1520590336</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">1520590336</span>
-      },
-      <span class="hljs-attr">"new_large_object_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">0</span>
-      }
-    }
-  },
-  <span class="hljs-attr">"resourceUsage"</span>: {
-    <span class="hljs-attr">"userCpuSeconds"</span>: <span class="hljs-number">0.069595</span>,
-    <span class="hljs-attr">"kernelCpuSeconds"</span>: <span class="hljs-number">0.019163</span>,
-    <span class="hljs-attr">"cpuConsumptionPercent"</span>: <span class="hljs-number">0.000000</span>,
-    <span class="hljs-attr">"maxRss"</span>: <span class="hljs-number">18079744</span>,
-    <span class="hljs-attr">"pageFaults"</span>: {
-      <span class="hljs-attr">"IORequired"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"IONotRequired"</span>: <span class="hljs-number">4610</span>
-    },
-    <span class="hljs-attr">"fsActivity"</span>: {
-      <span class="hljs-attr">"reads"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"writes"</span>: <span class="hljs-number">0</span>
-    }
-  },
-  <span class="hljs-attr">"uvthreadResourceUsage"</span>: {
-    <span class="hljs-attr">"userCpuSeconds"</span>: <span class="hljs-number">0.068457</span>,
-    <span class="hljs-attr">"kernelCpuSeconds"</span>: <span class="hljs-number">0.019127</span>,
-    <span class="hljs-attr">"cpuConsumptionPercent"</span>: <span class="hljs-number">0.000000</span>,
-    <span class="hljs-attr">"fsActivity"</span>: {
-      <span class="hljs-attr">"reads"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"writes"</span>: <span class="hljs-number">0</span>
-    }
-  },
-  <span class="hljs-attr">"libuv"</span>: [
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"async"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x0000000102910900"</span>,
-      <span class="hljs-attr">"details"</span>: <span class="hljs-string">""</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"timer"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfeab0"</span>,
-      <span class="hljs-attr">"repeat"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"firesInMsFromNow"</span>: <span class="hljs-number">94403548320796</span>,
-      <span class="hljs-attr">"expired"</span>: <span class="hljs-literal">true</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"check"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfeb48"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"idle"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfebc0"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"prepare"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfec38"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"check"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfecb0"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"async"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000000010188f2e0"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"tty"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000055b581db0e18"</span>,
-      <span class="hljs-attr">"width"</span>: <span class="hljs-number">204</span>,
-      <span class="hljs-attr">"height"</span>: <span class="hljs-number">55</span>,
-      <span class="hljs-attr">"fd"</span>: <span class="hljs-number">17</span>,
-      <span class="hljs-attr">"writeQueueSize"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"readable"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"writable"</span>: <span class="hljs-literal">true</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"signal"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000055b581d80010"</span>,
-      <span class="hljs-attr">"signum"</span>: <span class="hljs-number">28</span>,
-      <span class="hljs-attr">"signal"</span>: <span class="hljs-string">"SIGWINCH"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"tty"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000055b581df59f8"</span>,
-      <span class="hljs-attr">"width"</span>: <span class="hljs-number">204</span>,
-      <span class="hljs-attr">"height"</span>: <span class="hljs-number">55</span>,
-      <span class="hljs-attr">"fd"</span>: <span class="hljs-number">19</span>,
-      <span class="hljs-attr">"writeQueueSize"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"readable"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"writable"</span>: <span class="hljs-literal">true</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"loop"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000055fc7b2cb180"</span>
-    }
-  ],
-  <span class="hljs-attr">"workers"</span>: [],
-  <span class="hljs-attr">"environmentVariables"</span>: {
-    <span class="hljs-attr">"REMOTEHOST"</span>: <span class="hljs-string">"REMOVED"</span>,
-    <span class="hljs-attr">"MANPATH"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share/man:"</span>,
-    <span class="hljs-attr">"XDG_SESSION_ID"</span>: <span class="hljs-string">"66126"</span>,
-    <span class="hljs-attr">"HOSTNAME"</span>: <span class="hljs-string">"test_machine"</span>,
-    <span class="hljs-attr">"HOST"</span>: <span class="hljs-string">"test_machine"</span>,
-    <span class="hljs-attr">"TERM"</span>: <span class="hljs-string">"xterm-256color"</span>,
-    <span class="hljs-attr">"SHELL"</span>: <span class="hljs-string">"/bin/csh"</span>,
-    <span class="hljs-attr">"SSH_CLIENT"</span>: <span class="hljs-string">"REMOVED"</span>,
-    <span class="hljs-attr">"PERL5LIB"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root//usr/lib64/perl5/vendor_perl:/opt/rh/devtoolset-3/root/usr/lib/perl5:/opt/rh/devtoolset-3/root//usr/share/perl5/vendor_perl"</span>,
-    <span class="hljs-attr">"OLDPWD"</span>: <span class="hljs-string">"/home/nodeuser/project/node/src"</span>,
-    <span class="hljs-attr">"JAVACONFDIRS"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/etc/java:/etc/java"</span>,
-    <span class="hljs-attr">"SSH_TTY"</span>: <span class="hljs-string">"/dev/pts/0"</span>,
-    <span class="hljs-attr">"PCP_DIR"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root"</span>,
-    <span class="hljs-attr">"GROUP"</span>: <span class="hljs-string">"normaluser"</span>,
-    <span class="hljs-attr">"USER"</span>: <span class="hljs-string">"nodeuser"</span>,
-    <span class="hljs-attr">"LD_LIBRARY_PATH"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/lib64:/opt/rh/devtoolset-3/root/usr/lib"</span>,
-    <span class="hljs-attr">"HOSTTYPE"</span>: <span class="hljs-string">"x86_64-linux"</span>,
-    <span class="hljs-attr">"XDG_CONFIG_DIRS"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/etc/xdg:/etc/xdg"</span>,
-    <span class="hljs-attr">"MAIL"</span>: <span class="hljs-string">"/var/spool/mail/nodeuser"</span>,
-    <span class="hljs-attr">"PATH"</span>: <span class="hljs-string">"/home/nodeuser/project/node:/opt/rh/devtoolset-3/root/usr/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin"</span>,
-    <span class="hljs-attr">"PWD"</span>: <span class="hljs-string">"/home/nodeuser/project/node"</span>,
-    <span class="hljs-attr">"LANG"</span>: <span class="hljs-string">"en_US.UTF-8"</span>,
-    <span class="hljs-attr">"PS1"</span>: <span class="hljs-string">"\\u@\\h : \\[\\e[31m\\]\\w\\[\\e[m\\] >  "</span>,
-    <span class="hljs-attr">"SHLVL"</span>: <span class="hljs-string">"2"</span>,
-    <span class="hljs-attr">"HOME"</span>: <span class="hljs-string">"/home/nodeuser"</span>,
-    <span class="hljs-attr">"OSTYPE"</span>: <span class="hljs-string">"linux"</span>,
-    <span class="hljs-attr">"VENDOR"</span>: <span class="hljs-string">"unknown"</span>,
-    <span class="hljs-attr">"PYTHONPATH"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/lib64/python2.7/site-packages:/opt/rh/devtoolset-3/root/usr/lib/python2.7/site-packages"</span>,
-    <span class="hljs-attr">"MACHTYPE"</span>: <span class="hljs-string">"x86_64"</span>,
-    <span class="hljs-attr">"LOGNAME"</span>: <span class="hljs-string">"nodeuser"</span>,
-    <span class="hljs-attr">"XDG_DATA_DIRS"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share:/usr/local/share:/usr/share"</span>,
-    <span class="hljs-attr">"LESSOPEN"</span>: <span class="hljs-string">"||/usr/bin/lesspipe.sh %s"</span>,
-    <span class="hljs-attr">"INFOPATH"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share/info"</span>,
-    <span class="hljs-attr">"XDG_RUNTIME_DIR"</span>: <span class="hljs-string">"/run/user/50141"</span>,
-    <span class="hljs-attr">"_"</span>: <span class="hljs-string">"./node"</span>
-  },
-  <span class="hljs-attr">"userLimits"</span>: {
-    <span class="hljs-attr">"core_file_size_blocks"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">""</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"data_seg_size_kbytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"file_size_blocks"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"max_locked_memory_bytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-number">65536</span>
-    },
-    <span class="hljs-attr">"max_memory_size_kbytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"open_files"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-number">4096</span>
-    },
-    <span class="hljs-attr">"stack_size_bytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"cpu_time_seconds"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"max_user_processes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-number">4127290</span>
-    },
-    <span class="hljs-attr">"virtual_memory_kbytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    }
-  },
-  <span class="hljs-attr">"sharedObjects"</span>: [
-    <span class="hljs-string">"/lib64/libdl.so.2"</span>,
-    <span class="hljs-string">"/lib64/librt.so.1"</span>,
-    <span class="hljs-string">"/lib64/libstdc++.so.6"</span>,
-    <span class="hljs-string">"/lib64/libm.so.6"</span>,
-    <span class="hljs-string">"/lib64/libgcc_s.so.1"</span>,
-    <span class="hljs-string">"/lib64/libpthread.so.0"</span>,
-    <span class="hljs-string">"/lib64/libc.so.6"</span>,
+    <span class="hljs-punctuation">]</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"nativeStack"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57f07a9ef"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"report::GetNodeReport(v8::Isolate*, node::Environment*, char const*, char const*, v8::Local&#x3C;v8::String>, std::ostream&#x26;) [./node]"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57f07cf03"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"report::GetReport(v8::FunctionCallbackInfo&#x3C;v8::Value> const&#x26;) [./node]"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57f1bccfd"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">" [./node]"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57f1be048"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"v8::internal::Builtin_HandleApiCall(int, v8::internal::Object**, v8::internal::Isolate*) [./node]"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57feeda0e"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">" [./node]"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"javascriptHeap"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"totalMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">6127616</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"totalCommittedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">4357352</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"usedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">3221136</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"availableMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1521370240</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"memoryLimit"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1526909922</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"heapSpaces"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"read_only_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">524288</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">39208</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">515584</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">30504</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">485080</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"new_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2097152</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2019312</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1031168</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">985496</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">45672</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"old_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2273280</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1769008</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1974640</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1725488</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">249152</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"code_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">696320</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">184896</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">152128</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">152128</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"map_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">536576</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">344928</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">327520</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">327520</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"large_object_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1520590336</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1520590336</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"new_large_object_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"resourceUsage"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"userCpuSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.069595</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"kernelCpuSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.019163</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cpuConsumptionPercent"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.000000</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"maxRss"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">18079744</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"pageFaults"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"IORequired"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"IONotRequired"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">4610</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"fsActivity"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"reads"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writes"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"uvthreadResourceUsage"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"userCpuSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.068457</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"kernelCpuSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.019127</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cpuConsumptionPercent"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.000000</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"fsActivity"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"reads"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writes"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"libuv"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"async"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x0000000102910900"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"details"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">""</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"timer"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfeab0"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"repeat"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"firesInMsFromNow"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">94403548320796</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"expired"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"check"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfeb48"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"idle"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfebc0"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"prepare"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfec38"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"check"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfecb0"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"async"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000000010188f2e0"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"tty"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b581db0e18"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"width"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">204</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"height"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">55</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"fd"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">17</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writeQueueSize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"readable"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writable"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"signal"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b581d80010"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"signum"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">28</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"signal"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"SIGWINCH"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"tty"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b581df59f8"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"width"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">204</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"height"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">55</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"fd"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">19</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writeQueueSize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"readable"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writable"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"loop"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055fc7b2cb180"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"loopIdleTimeSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">22644.8</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"workers"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span><span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"environmentVariables"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"REMOTEHOST"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"REMOVED"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"MANPATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share/man:"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"XDG_SESSION_ID"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"66126"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"HOSTNAME"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"test_machine"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"HOST"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"test_machine"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"TERM"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"xterm-256color"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"SHELL"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/bin/csh"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"SSH_CLIENT"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"REMOVED"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PERL5LIB"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root//usr/lib64/perl5/vendor_perl:/opt/rh/devtoolset-3/root/usr/lib/perl5:/opt/rh/devtoolset-3/root//usr/share/perl5/vendor_perl"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"OLDPWD"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser/project/node/src"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"JAVACONFDIRS"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/etc/java:/etc/java"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"SSH_TTY"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/dev/pts/0"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PCP_DIR"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"GROUP"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"normaluser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"USER"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"nodeuser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"LD_LIBRARY_PATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/lib64:/opt/rh/devtoolset-3/root/usr/lib"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"HOSTTYPE"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"x86_64-linux"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"XDG_CONFIG_DIRS"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/etc/xdg:/etc/xdg"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"MAIL"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/var/spool/mail/nodeuser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser/project/node:/opt/rh/devtoolset-3/root/usr/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PWD"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser/project/node"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"LANG"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"en_US.UTF-8"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PS1"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"\\u@\\h : \\[\\e[31m\\]\\w\\[\\e[m\\] >  "</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"SHLVL"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"2"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"HOME"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"OSTYPE"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"linux"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"VENDOR"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unknown"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PYTHONPATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/lib64/python2.7/site-packages:/opt/rh/devtoolset-3/root/usr/lib/python2.7/site-packages"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"MACHTYPE"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"x86_64"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"LOGNAME"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"nodeuser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"XDG_DATA_DIRS"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share:/usr/local/share:/usr/share"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"LESSOPEN"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"||/usr/bin/lesspipe.sh %s"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"INFOPATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share/info"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"XDG_RUNTIME_DIR"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/run/user/50141"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"_"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./node"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"userLimits"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"core_file_size_blocks"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">""</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"data_seg_size_kbytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"file_size_blocks"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"max_locked_memory_bytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">65536</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"max_memory_size_kbytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"open_files"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">4096</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"stack_size_bytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cpu_time_seconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"max_user_processes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">4127290</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"virtual_memory_kbytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"sharedObjects"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-string">"/lib64/libdl.so.2"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/librt.so.1"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libstdc++.so.6"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libm.so.6"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libgcc_s.so.1"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libpthread.so.0"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libc.so.6"</span><span class="hljs-punctuation">,</span>
     <span class="hljs-string">"/lib64/ld-linux-x86-64.so.2"</span>
-  ]
-}</code></pre>
-<h2>Usage<span><a class="mark" href="#report_usage" id="report_usage">#</a></span></h2>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<section><h3>Usage<span><a class="mark" href="#report_usage" id="report_usage">#</a></span></h3>
 <pre><code class="language-bash">node --report-uncaught-exception --report-on-signal \
 --report-on-fatalerror app.js</code></pre>
 <ul>
@@ -51591,9 +55971,9 @@ with native stack and other runtime environment data.</p>
 </li>
 <li>
 <p><code>--report-on-signal</code> Enables report to be generated upon receiving
-the specified (or predefined) signal to the running Node.js process. (See below
-on how to modify the signal that triggers the report.) Default signal is <code>SIGUSR2</code>.
-Useful when a report needs to be triggered from another program.
+the specified (or predefined) signal to the running Node.js process. (See
+below on how to modify the signal that triggers the report.) Default signal is
+<code>SIGUSR2</code>. Useful when a report needs to be triggered from another program.
 Application monitors may leverage this feature to collect report at regular
 intervals and plot rich set of internal runtime data to their views.</p>
 </li>
@@ -51605,8 +55985,8 @@ flag helps to change the signal for report generation and preserve the original
 meaning of <code>SIGUSR2</code> for the said purposes.</p>
 <ul>
 <li>
-<p><code>--report-on-fatalerror</code> Enables the report to be triggered on
-fatal errors (internal errors within the Node.js runtime, such as out of memory)
+<p><code>--report-on-fatalerror</code> Enables the report to be triggered on fatal errors
+(internal errors within the Node.js runtime, such as out of memory)
 that leads to termination of the application. Useful to inspect various
 diagnostic data elements such as heap, stack, event loop state, resource
 consumption etc. to reason about the fatal error.</p>
@@ -51630,41 +56010,41 @@ written.</p>
 </li>
 </ul>
 <p>A report can also be triggered via an API call from a JavaScript application:</p>
-<pre><code class="language-js">process.report.writeReport();</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>();</code></pre>
 <p>This function takes an optional additional argument <code>filename</code>, which is
 the name of a file into which the report is written.</p>
-<pre><code class="language-js">process.report.writeReport(<span class="hljs-string">'./foo.json'</span>);</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>(<span class="hljs-string">'./foo.json'</span>);</code></pre>
 <p>This function takes an optional additional argument <code>err</code> which is an <code>Error</code>
 object that will be used as the context for the JavaScript stack printed in the
 report. When using report to handle errors in a callback or an exception
 handler, this allows the report to include the location of the original error as
 well as where it was handled.</p>
 <pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  process.chdir(<span class="hljs-string">'/non-existent-path'</span>);
+  process.<span class="hljs-title function_">chdir</span>(<span class="hljs-string">'/non-existent-path'</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  process.report.writeReport(err);
+  process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>(err);
 }
 <span class="hljs-comment">// Any other code</span></code></pre>
 <p>If both filename and error object are passed to <code>writeReport()</code> the
 error object must be the second parameter.</p>
 <pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  process.chdir(<span class="hljs-string">'/non-existent-path'</span>);
+  process.<span class="hljs-title function_">chdir</span>(<span class="hljs-string">'/non-existent-path'</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  process.report.writeReport(filename, err);
+  process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>(filename, err);
 }
 <span class="hljs-comment">// Any other code</span></code></pre>
 <p>The content of the diagnostic report can be returned as a JavaScript Object
 via an API call from a JavaScript application:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> report = process.report.getReport();
-<span class="hljs-built_in">console</span>.log(<span class="hljs-keyword">typeof</span> report === <span class="hljs-string">'object'</span>); <span class="hljs-comment">// true</span>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> report = process.<span class="hljs-property">report</span>.<span class="hljs-title function_">getReport</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-keyword">typeof</span> report === <span class="hljs-string">'object'</span>); <span class="hljs-comment">// true</span>
 
 <span class="hljs-comment">// Similar to process.report.writeReport() output</span>
-<span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">JSON</span>.stringify(report, <span class="hljs-literal">null</span>, <span class="hljs-number">2</span>));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(report, <span class="hljs-literal">null</span>, <span class="hljs-number">2</span>));</code></pre>
 <p>This function takes an optional additional argument <code>err</code>, which is an <code>Error</code>
 object that will be used as the context for the JavaScript stack printed in the
 report.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> report = process.report.getReport(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'custom error'</span>));
-<span class="hljs-built_in">console</span>.log(<span class="hljs-keyword">typeof</span> report === <span class="hljs-string">'object'</span>); <span class="hljs-comment">// true</span></code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> report = process.<span class="hljs-property">report</span>.<span class="hljs-title function_">getReport</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'custom error'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-keyword">typeof</span> report === <span class="hljs-string">'object'</span>); <span class="hljs-comment">// true</span></code></pre>
 <p>The API versions are useful when inspecting the runtime state from within
 the application, in expectation of self-adjusting the resource consumption,
 load balancing, monitoring etc.</p>
@@ -51674,8 +56054,8 @@ native stack traces, a section containing V8 heap information, a section
 containing <code>libuv</code> handle information and an OS platform information section
 showing CPU and memory usage and system limits. An example report can be
 triggered using the Node.js REPL:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> process.report.writeReport();</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.report.writeReport();</span>
 Writing Node.js report to file: report.20181126.091102.8480.0.001.json
 Node.js report completed
 <span class="hljs-meta">></span></code></pre>
@@ -51684,7 +56064,7 @@ and the filename of the report is returned to the caller. The default filename
 includes the date, time, PID and a sequence number. The sequence number helps
 in associating the report dump with the runtime state if generated multiple
 times for the same Node.js process.</p>
-<h2>Configuration<span><a class="mark" href="#report_configuration" id="report_configuration">#</a></span></h2>
+</section><section><h3>Configuration<span><a class="mark" href="#report_configuration" id="report_configuration">#</a></span></h3>
 <p>Additional runtime configuration of report generation is available via
 the following properties of <code>process.report</code>:</p>
 <p><code>reportOnFatalError</code> triggers diagnostic reporting on fatal errors when <code>true</code>.
@@ -51706,20 +56086,20 @@ timestamp, PID and sequence number.</p>
 URLs are not supported. Defaults to the current working directory of the
 Node.js process.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Trigger report only on uncaught exceptions.</span>
-process.report.reportOnFatalError = <span class="hljs-literal">false</span>;
-process.report.reportOnSignal = <span class="hljs-literal">false</span>;
-process.report.reportOnUncaughtException = <span class="hljs-literal">true</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnFatalError</span> = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnSignal</span> = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnUncaughtException</span> = <span class="hljs-literal">true</span>;
 
 <span class="hljs-comment">// Trigger report for both internal errors as well as external signal.</span>
-process.report.reportOnFatalError = <span class="hljs-literal">true</span>;
-process.report.reportOnSignal = <span class="hljs-literal">true</span>;
-process.report.reportOnUncaughtException = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnFatalError</span> = <span class="hljs-literal">true</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnSignal</span> = <span class="hljs-literal">true</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnUncaughtException</span> = <span class="hljs-literal">false</span>;
 
 <span class="hljs-comment">// Change the default signal to 'SIGQUIT' and enable it.</span>
-process.report.reportOnFatalError = <span class="hljs-literal">false</span>;
-process.report.reportOnUncaughtException = <span class="hljs-literal">false</span>;
-process.report.reportOnSignal = <span class="hljs-literal">true</span>;
-process.report.signal = <span class="hljs-string">'SIGQUIT'</span>;</code></pre>
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnFatalError</span> = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnUncaughtException</span> = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnSignal</span> = <span class="hljs-literal">true</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">signal</span> = <span class="hljs-string">'SIGQUIT'</span>;</code></pre>
 <p>Configuration on module initialization is also available via
 environment variables:</p>
 <pre><code class="language-bash">NODE_OPTIONS=<span class="hljs-string">"--report-uncaught-exception \
@@ -51728,12 +56108,12 @@ environment variables:</p>
   --report-directory=/home/nodeuser"</span></code></pre>
 <p>Specific API documentation can be found under
 <a href="process.html"><code>process API documentation</code></a> section.</p>
-<h2>Interaction with workers<span><a class="mark" href="#report_interaction_with_workers" id="report_interaction_with_workers">#</a></span></h2>
+</section><section><h3>Interaction with workers<span><a class="mark" href="#report_interaction_with_workers" id="report_interaction_with_workers">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.2</td>
+<tr><td>v13.9.0, v12.16.2</td>
 <td><p>Workers are now included in the report.</p></td></tr>
 </tbody></table>
 </details>
@@ -51745,11 +56125,12 @@ thread as part of the <code>workers</code> section, with each Worker generating
 in the standard report format.</p>
 <p>The thread which is generating the report will wait for the reports from Worker
 threads to finish. However, the latency for this will usually be low, as both
-running JavaScript and the event loop are interrupted to generate the report.</p>
-<h1>Stream<a class="srclink" href="https://github.com/nodejs/node/blob/360a294f1f19cb8ccc9505d44a2e9efff414a5c7/lib/stream.js#L30">[src]</a><span><a class="mark" href="#stream_stream" id="stream_stream">#</a></span></h1>
+running JavaScript and the event loop are interrupted to generate the report.</p></section>
+        </section>
+<section><h2>Stream<a class="srclink" href="https://github.com/nodejs/node/blob/92df3d654b366aa115fb672756cb051d480d8acc/lib/stream.js#L28">[src]</a><span><a class="mark" href="#stream_stream" id="stream_stream">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/stream.js">lib/stream.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/stream.js">lib/stream.js</a></p>
 <p>A stream is an abstract interface for working with streaming data in Node.js.
 The <code>stream</code> module provides an API for implementing the stream interface.</p>
 <p>There are many stream objects provided by Node.js. For instance, a
@@ -51761,11 +56142,11 @@ are both stream instances.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> stream = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);</code></pre>
 <p>The <code>stream</code> module is useful for creating new types of stream instances. It is
 usually not necessary to use the <code>stream</code> module to consume streams.</p>
-<h2>Organization of this document<span><a class="mark" href="#stream_organization_of_this_document" id="stream_organization_of_this_document">#</a></span></h2>
+<section><h3>Organization of this document<span><a class="mark" href="#stream_organization_of_this_document" id="stream_organization_of_this_document">#</a></span></h3>
 <p>This document contains two primary sections and a third section for notes. The
 first section explains how to use existing streams within an application. The
 second section explains how to create new types of streams.</p>
-<h2>Types of streams<span><a class="mark" href="#stream_types_of_streams" id="stream_types_of_streams">#</a></span></h2>
+</section><section><h3>Types of streams<span><a class="mark" href="#stream_types_of_streams" id="stream_types_of_streams">#</a></span></h3>
 <p>There are four fundamental stream types within Node.js:</p>
 <ul>
 <li><a href="#stream_class_stream_writable"><code>Writable</code></a>: streams to which data can be written (for example,
@@ -51778,9 +56159,9 @@ second section explains how to create new types of streams.</p>
 is written and read (for example, <a href="#zlib_zlib_createdeflate_options"><code>zlib.createDeflate()</code></a>).</li>
 </ul>
 <p>Additionally, this module includes the utility functions
-<a href="#stream_stream_pipeline_streams_callback"><code>stream.pipeline()</code></a>, <a href="#stream_stream_finished_stream_options_callback"><code>stream.finished()</code></a> and
+<a href="#stream_stream_pipeline_source_transforms_destination_callback"><code>stream.pipeline()</code></a>, <a href="#stream_stream_finished_stream_options_callback"><code>stream.finished()</code></a> and
 <a href="#stream_stream_readable_from_iterable_options"><code>stream.Readable.from()</code></a>.</p>
-<h3>Object mode<span><a class="mark" href="#stream_object_mode" id="stream_object_mode">#</a></span></h3>
+<h4>Object mode<span><a class="mark" href="#stream_object_mode" id="stream_object_mode">#</a></span></h4>
 <p>All streams created by Node.js APIs operate exclusively on strings and <code>Buffer</code>
 (or <code>Uint8Array</code>) objects. It is possible, however, for stream implementations
 to work with other types of JavaScript values (with the exception of <code>null</code>,
@@ -51789,11 +56170,10 @@ operate in "object mode".</p>
 <p>Stream instances are switched into object mode using the <code>objectMode</code> option
 when the stream is created. Attempting to switch an existing stream into
 object mode is not safe.</p>
-<h3>Buffering<span><a class="mark" href="#stream_buffering" id="stream_buffering">#</a></span></h3>
+<h4>Buffering<span><a class="mark" href="#stream_buffering" id="stream_buffering">#</a></span></h4>
 
 <p>Both <a href="#stream_class_stream_writable"><code>Writable</code></a> and <a href="#stream_class_stream_readable"><code>Readable</code></a> streams will store data in an internal
-buffer that can be retrieved using <code>writable.writableBuffer</code> or
-<code>readable.readableBuffer</code>, respectively.</p>
+buffer.</p>
 <p>The amount of data potentially buffered depends on the <code>highWaterMark</code> option
 passed into the stream's constructor. For normal streams, the <code>highWaterMark</code>
 option specifies a <a href="#stream_highwatermark_discrepancy_after_calling_readable_setencoding">total number of bytes</a>. For streams operating
@@ -51829,43 +56209,47 @@ consumption of data received <em>from</em> the socket and whose <code>Writable</
 writing data <em>to</em> the socket. Because data may be written to the socket at a
 faster or slower rate than data is received, each side should
 operate (and buffer) independently of the other.</p>
-<h2>API for stream consumers<span><a class="mark" href="#stream_api_for_stream_consumers" id="stream_api_for_stream_consumers">#</a></span></h2>
+<p>The mechanics of the internal buffering are an internal implementation detail
+and may be changed at any time. However, for certain advanced implementations,
+the internal buffers can be retrieved using <code>writable.writableBuffer</code> or
+<code>readable.readableBuffer</code>. Use of these undocumented properties is discouraged.</p>
+</section><section><h3>API for stream consumers<span><a class="mark" href="#stream_api_for_stream_consumers" id="stream_api_for_stream_consumers">#</a></span></h3>
 
 <p>Almost all Node.js applications, no matter how simple, use streams in some
 manner. The following is an example of using streams in a Node.js application
 that implements an HTTP server:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
   <span class="hljs-comment">// `req` is an http.IncomingMessage, which is a readable stream.</span>
   <span class="hljs-comment">// `res` is an http.ServerResponse, which is a writable stream.</span>
 
   <span class="hljs-keyword">let</span> body = <span class="hljs-string">''</span>;
   <span class="hljs-comment">// Get the data as utf8 strings.</span>
   <span class="hljs-comment">// If an encoding is not set, Buffer objects will be received.</span>
-  req.setEncoding(<span class="hljs-string">'utf8'</span>);
+  req.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
 
   <span class="hljs-comment">// Readable streams emit 'data' events once a listener is added.</span>
-  req.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
     body += chunk;
   });
 
   <span class="hljs-comment">// The 'end' event indicates that the entire body has been received.</span>
-  req.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-keyword">try</span> {
-      <span class="hljs-keyword">const</span> data = <span class="hljs-built_in">JSON</span>.parse(body);
+      <span class="hljs-keyword">const</span> data = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(body);
       <span class="hljs-comment">// Write back something interesting to the user:</span>
-      res.write(<span class="hljs-keyword">typeof</span> data);
-      res.end();
+      res.<span class="hljs-title function_">write</span>(<span class="hljs-keyword">typeof</span> data);
+      res.<span class="hljs-title function_">end</span>();
     } <span class="hljs-keyword">catch</span> (er) {
       <span class="hljs-comment">// uh oh! bad json!</span>
-      res.statusCode = <span class="hljs-number">400</span>;
-      <span class="hljs-keyword">return</span> res.end(<span class="hljs-string">`error: <span class="hljs-subst">${er.message}</span>`</span>);
+      res.<span class="hljs-property">statusCode</span> = <span class="hljs-number">400</span>;
+      <span class="hljs-keyword">return</span> res.<span class="hljs-title function_">end</span>(<span class="hljs-string">`error: <span class="hljs-subst">${er.message}</span>`</span>);
     }
   });
 });
 
-server.listen(<span class="hljs-number">1337</span>);
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);
 
 <span class="hljs-comment">// $ curl localhost:1337 -d "{}"</span>
 <span class="hljs-comment">// object</span>
@@ -51887,7 +56271,7 @@ are not required to implement the stream interfaces directly and will generally
 have no reason to call <code>require('stream')</code>.</p>
 <p>Developers wishing to implement new types of streams should refer to the
 section <a href="#stream_api_for_stream_implementers">API for stream implementers</a>.</p>
-<h3>Writable streams<span><a class="mark" href="#stream_writable_streams" id="stream_writable_streams">#</a></span></h3>
+<h4>Writable streams<span><a class="mark" href="#stream_writable_streams" id="stream_writable_streams">#</a></span></h4>
 <p>Writable streams are an abstraction for a <em>destination</em> to which data is
 written.</p>
 <p>Examples of <a href="#stream_class_stream_writable"><code>Writable</code></a> streams include:</p>
@@ -51908,16 +56292,16 @@ written.</p>
 <p>While specific instances of <a href="#stream_class_stream_writable"><code>Writable</code></a> streams may differ in various ways,
 all <code>Writable</code> streams follow the same fundamental usage pattern as illustrated
 in the example below:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myStream = getWritableStreamSomehow();
-myStream.write(<span class="hljs-string">'some data'</span>);
-myStream.write(<span class="hljs-string">'some more data'</span>);
-myStream.end(<span class="hljs-string">'done writing data'</span>);</code></pre>
-<h4>Class: <code>stream.Writable</code><span><a class="mark" href="#stream_class_stream_writable" id="stream_class_stream_writable">#</a></span></h4>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myStream = <span class="hljs-title function_">getWritableStreamSomehow</span>();
+myStream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data'</span>);
+myStream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some more data'</span>);
+myStream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'done writing data'</span>);</code></pre>
+<h5>Class: <code>stream.Writable</code><span><a class="mark" href="#stream_class_stream_writable" id="stream_class_stream_writable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 
-<h5>Event: <code>'close'</code><span><a class="mark" href="#stream_event_close" id="stream_event_close">#</a></span></h5>
+<h6>Event: <code>'close'</code><span><a class="mark" href="#stream_event_close" id="stream_event_close">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -51934,7 +56318,7 @@ resources (a file descriptor, for example) have been closed. The event indicates
 that no more events will be emitted, and no further computation will occur.</p>
 <p>A <a href="#stream_class_stream_writable"><code>Writable</code></a> stream will always emit the <code>'close'</code> event if it is
 created with the <code>emitClose</code> option.</p>
-<h5>Event: <code>'drain'</code><span><a class="mark" href="#stream_event_drain" id="stream_event_drain">#</a></span></h5>
+<h6>Event: <code>'drain'</code><span><a class="mark" href="#stream_event_drain" id="stream_event_drain">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -51943,30 +56327,30 @@ created with the <code>emitClose</code> option.</p>
 to the stream.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Write the data to the supplied writable stream one million times.</span>
 <span class="hljs-comment">// Be attentive to back-pressure.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">writeOneMillionTimes</span>(<span class="hljs-params">writer, data, encoding, callback</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">writeOneMillionTimes</span>(<span class="hljs-params">writer, data, encoding, callback</span>) {
   <span class="hljs-keyword">let</span> i = <span class="hljs-number">1000000</span>;
-  write();
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">write</span>(<span class="hljs-params"></span>) </span>{
+  <span class="hljs-title function_">write</span>();
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">write</span>(<span class="hljs-params"></span>) {
     <span class="hljs-keyword">let</span> ok = <span class="hljs-literal">true</span>;
     <span class="hljs-keyword">do</span> {
       i--;
       <span class="hljs-keyword">if</span> (i === <span class="hljs-number">0</span>) {
         <span class="hljs-comment">// Last time!</span>
-        writer.write(data, encoding, callback);
+        writer.<span class="hljs-title function_">write</span>(data, encoding, callback);
       } <span class="hljs-keyword">else</span> {
         <span class="hljs-comment">// See if we should continue, or wait.</span>
         <span class="hljs-comment">// Don't pass the callback, because we're not done yet.</span>
-        ok = writer.write(data, encoding);
+        ok = writer.<span class="hljs-title function_">write</span>(data, encoding);
       }
     } <span class="hljs-keyword">while</span> (i > <span class="hljs-number">0</span> &#x26;&#x26; ok);
     <span class="hljs-keyword">if</span> (i > <span class="hljs-number">0</span>) {
       <span class="hljs-comment">// Had to stop early!</span>
       <span class="hljs-comment">// Write some more once it drains.</span>
-      writer.once(<span class="hljs-string">'drain'</span>, write);
+      writer.<span class="hljs-title function_">once</span>(<span class="hljs-string">'drain'</span>, write);
     }
   }
 }</code></pre>
-<h5>Event: <code>'error'</code><span><a class="mark" href="#stream_event_error" id="stream_event_error">#</a></span></h5>
+<h6>Event: <code>'error'</code><span><a class="mark" href="#stream_event_error" id="stream_event_error">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -51975,24 +56359,26 @@ to the stream.</p>
 </ul>
 <p>The <code>'error'</code> event is emitted if an error occurred while writing or piping
 data. The listener callback is passed a single <code>Error</code> argument when called.</p>
-<p>The stream is not closed when the <code>'error'</code> event is emitted unless the
-<a href="#stream_new_stream_writable_options"><code>autoDestroy</code></a> option was set to <code>true</code> when creating the
+<p>The stream is closed when the <code>'error'</code> event is emitted unless the
+<a href="#stream_new_stream_writable_options"><code>autoDestroy</code></a> option was set to <code>false</code> when creating the
 stream.</p>
-<h5>Event: <code>'finish'</code><span><a class="mark" href="#stream_event_finish" id="stream_event_finish">#</a></span></h5>
+<p>After <code>'error'</code>, no further events other than <code>'close'</code> <em>should</em> be emitted
+(including <code>'error'</code> events).</p>
+<h6>Event: <code>'finish'</code><span><a class="mark" href="#stream_event_finish" id="stream_event_finish">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 <p>The <code>'finish'</code> event is emitted after the <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> method
 has been called, and all data has been flushed to the underlying system.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = getWritableStreamSomehow();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = <span class="hljs-title function_">getWritableStreamSomehow</span>();
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">100</span>; i++) {
-  writer.write(<span class="hljs-string">`hello, #<span class="hljs-subst">${i}</span>!\n`</span>);
+  writer.<span class="hljs-title function_">write</span>(<span class="hljs-string">`hello, #<span class="hljs-subst">${i}</span>!\n`</span>);
 }
-writer.on(<span class="hljs-string">'finish'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'All writes are now complete.'</span>);
+writer.<span class="hljs-title function_">on</span>(<span class="hljs-string">'finish'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'All writes are now complete.'</span>);
 });
-writer.end(<span class="hljs-string">'This is the end\n'</span>);</code></pre>
-<h5>Event: <code>'pipe'</code><span><a class="mark" href="#stream_event_pipe" id="stream_event_pipe">#</a></span></h5>
+writer.<span class="hljs-title function_">end</span>(<span class="hljs-string">'This is the end\n'</span>);</code></pre>
+<h6>Event: <code>'pipe'</code><span><a class="mark" href="#stream_event_pipe" id="stream_event_pipe">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52001,14 +56387,14 @@ writer.end(<span class="hljs-string">'This is the end\n'</span>);</code></pre>
 </ul>
 <p>The <code>'pipe'</code> event is emitted when the <a href="#stream_readable_pipe_destination_options"><code>stream.pipe()</code></a> method is called on
 a readable stream, adding this writable to its set of destinations.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = getWritableStreamSomehow();
-<span class="hljs-keyword">const</span> reader = getReadableStreamSomehow();
-writer.on(<span class="hljs-string">'pipe'</span>, <span class="hljs-function">(<span class="hljs-params">src</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Something is piping into the writer.'</span>);
-  assert.equal(src, reader);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = <span class="hljs-title function_">getWritableStreamSomehow</span>();
+<span class="hljs-keyword">const</span> reader = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+writer.<span class="hljs-title function_">on</span>(<span class="hljs-string">'pipe'</span>, <span class="hljs-function">(<span class="hljs-params">src</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Something is piping into the writer.'</span>);
+  assert.<span class="hljs-title function_">equal</span>(src, reader);
 });
-reader.pipe(writer);</code></pre>
-<h5>Event: <code>'unpipe'</code><span><a class="mark" href="#stream_event_unpipe" id="stream_event_unpipe">#</a></span></h5>
+reader.<span class="hljs-title function_">pipe</span>(writer);</code></pre>
+<h6>Event: <code>'unpipe'</code><span><a class="mark" href="#stream_event_unpipe" id="stream_event_unpipe">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52021,15 +56407,15 @@ on a <a href="#stream_class_stream_readable"><code>Readable</code></a> stream, r
 destinations.</p>
 <p>This is also emitted in case this <a href="#stream_class_stream_writable"><code>Writable</code></a> stream emits an error when a
 <a href="#stream_class_stream_readable"><code>Readable</code></a> stream pipes into it.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = getWritableStreamSomehow();
-<span class="hljs-keyword">const</span> reader = getReadableStreamSomehow();
-writer.on(<span class="hljs-string">'unpipe'</span>, <span class="hljs-function">(<span class="hljs-params">src</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Something has stopped piping into the writer.'</span>);
-  assert.equal(src, reader);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = <span class="hljs-title function_">getWritableStreamSomehow</span>();
+<span class="hljs-keyword">const</span> reader = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+writer.<span class="hljs-title function_">on</span>(<span class="hljs-string">'unpipe'</span>, <span class="hljs-function">(<span class="hljs-params">src</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Something has stopped piping into the writer.'</span>);
+  assert.<span class="hljs-title function_">equal</span>(src, reader);
 });
-reader.pipe(writer);
-reader.unpipe(writer);</code></pre>
-<h5><code>writable.cork()</code><span><a class="mark" href="#stream_writable_cork" id="stream_writable_cork">#</a></span></h5>
+reader.<span class="hljs-title function_">pipe</span>(writer);
+reader.<span class="hljs-title function_">unpipe</span>(writer);</code></pre>
+<h6><code>writable.cork()</code><span><a class="mark" href="#stream_writable_cork" id="stream_writable_cork">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -52045,9 +56431,17 @@ situation where data is being buffered while waiting for the first small chunk
 to be processed. However, use of <code>writable.cork()</code> without implementing
 <code>writable._writev()</code> may have an adverse effect on throughput.</p>
 <p>See also: <a href="#stream_writable_uncork"><code>writable.uncork()</code></a>, <a href="#stream_writable_writev_chunks_callback"><code>writable._writev()</code></a>.</p>
-<h5><code>writable.destroy([error])</code><span><a class="mark" href="#stream_writable_destroy_error" id="stream_writable_destroy_error">#</a></span></h5>
+<h6><code>writable.destroy([error])</code><span><a class="mark" href="#stream_writable_destroy_error" id="stream_writable_destroy_error">#</a></span></h6>
 <div class="api_metadata">
-<span>Added in: v8.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Work as a no-op on a stream that has already been destroyed.</p></td></tr>
+<tr><td>v8.0.0</td>
+<td><p><span>Added in: v8.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Optional, an error to emit with <code>'error'</code> event.</li>
@@ -52060,10 +56454,32 @@ an <code>ERR_STREAM_DESTROYED</code> error.
 This is a destructive and immediate way to destroy a stream. Previous calls to
 <code>write()</code> may not have drained, and may trigger an <code>ERR_STREAM_DESTROYED</code> error.
 Use <code>end()</code> instead of destroy if data should flush before close, or wait for
-the <code>'drain'</code> event before destroying the stream.
-Implementors should not override this method,
+the <code>'drain'</code> event before destroying the stream.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><pre><code class="language-js cjs"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">const</span> myStream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
+
+<span class="hljs-keyword">const</span> fooErr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'foo error'</span>);
+myStream.<span class="hljs-title function_">destroy</span>(fooErr);
+myStream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">fooErr</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(fooErr.<span class="hljs-property">message</span>)); <span class="hljs-comment">// foo error</span></code></pre><code class="language-js cjs"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">const</span> myStream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
+
+myStream.<span class="hljs-title function_">destroy</span>();
+myStream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">wontHappen</span>(<span class="hljs-params"></span>) {});</code></pre>
+<pre><code class="language-js cjs"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">const</span> myStream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
+myStream.<span class="hljs-title function_">destroy</span>();
+
+myStream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(error.<span class="hljs-property">code</span>));
+<span class="hljs-comment">// ERR_STREAM_DESTROYED</span></code></pre>
+<p>Once <code>destroy()</code> has been called any further calls will be a no-op and no
+further errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>
+<p>Implementors should not override this method,
 but instead implement <a href="#stream_writable_destroy_err_callback"><code>writable._destroy()</code></a>.</p>
-<h5><code>writable.destroyed</code><span><a class="mark" href="#stream_writable_destroyed" id="stream_writable_destroyed">#</a></span></h5>
+<h6><code>writable.destroyed</code><span><a class="mark" href="#stream_writable_destroyed" id="stream_writable_destroyed">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -52071,11 +56487,20 @@ but instead implement <a href="#stream_writable_destroy_err_callback"><code>writ
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Is <code>true</code> after <a href="#stream_writable_destroy_error"><code>writable.destroy()</code></a> has been called.</p>
-<h5><code>writable.end([chunk[, encoding]][, callback])</code><span><a class="mark" href="#stream_writable_end_chunk_encoding_callback" id="stream_writable_end_chunk_encoding_callback">#</a></span></h5>
+<pre><code class="language-js cjs"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">const</span> myStream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myStream.<span class="hljs-property">destroyed</span>); <span class="hljs-comment">// false</span>
+myStream.<span class="hljs-title function_">destroy</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myStream.<span class="hljs-property">destroyed</span>); <span class="hljs-comment">// true</span></code></pre>
+<h6><code>writable.end([chunk[, encoding]][, callback])</code><span><a class="mark" href="#stream_writable_end_chunk_encoding_callback" id="stream_writable_end_chunk_encoding_callback">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>callback</code> is invoked if 'finish' or 'error' is emitted.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>This method now returns a reference to <code>writable</code>.</p></td></tr>
 <tr><td>v8.0.0</td>
@@ -52091,23 +56516,24 @@ not operating in object mode, <code>chunk</code> must be a string, <code>Buffer<
 <code>Uint8Array</code>. For object mode streams, <code>chunk</code> may be any JavaScript value
 other than <code>null</code>.</li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The encoding if <code>chunk</code> is a string</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional callback for when the stream is finished</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional callback for when the stream finishes
+or errors</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
 </ul>
 <p>Calling the <code>writable.end()</code> method signals that no more data will be written
 to the <a href="#stream_class_stream_writable"><code>Writable</code></a>. The optional <code>chunk</code> and <code>encoding</code> arguments allow one
 final additional chunk of data to be written immediately before closing the
 stream. If provided, the optional <code>callback</code> function is attached as a listener
-for the <a href="#stream_event_finish"><code>'finish'</code></a> event.</p>
+for the <a href="#stream_event_finish"><code>'finish'</code></a> and the <code>'error'</code> event.</p>
 <p>Calling the <a href="#stream_writable_write_chunk_encoding_callback"><code>stream.write()</code></a> method after calling
 <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> will raise an error.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Write 'hello, ' and then end with 'world!'.</span>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> file = fs.createWriteStream(<span class="hljs-string">'example.txt'</span>);
-file.write(<span class="hljs-string">'hello, '</span>);
-file.end(<span class="hljs-string">'world!'</span>);
+<span class="hljs-keyword">const</span> file = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'example.txt'</span>);
+file.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello, '</span>);
+file.<span class="hljs-title function_">end</span>(<span class="hljs-string">'world!'</span>);
 <span class="hljs-comment">// Writing more now is not allowed!</span></code></pre>
-<h5><code>writable.setDefaultEncoding(encoding)</code><span><a class="mark" href="#stream_writable_setdefaultencoding_encoding" id="stream_writable_setdefaultencoding_encoding">#</a></span></h5>
+<h6><code>writable.setDefaultEncoding(encoding)</code><span><a class="mark" href="#stream_writable_setdefaultencoding_encoding" id="stream_writable_setdefaultencoding_encoding">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -52125,7 +56551,7 @@ file.end(<span class="hljs-string">'world!'</span>);
 </ul>
 <p>The <code>writable.setDefaultEncoding()</code> method sets the default <code>encoding</code> for a
 <a href="#stream_class_stream_writable"><code>Writable</code></a> stream.</p>
-<h5><code>writable.uncork()</code><span><a class="mark" href="#stream_writable_uncork" id="stream_writable_uncork">#</a></span></h5>
+<h6><code>writable.uncork()</code><span><a class="mark" href="#stream_writable_uncork" id="stream_writable_uncork">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -52135,32 +56561,33 @@ file.end(<span class="hljs-string">'world!'</span>);
 of writes to a stream, it is recommended that calls to <code>writable.uncork()</code> be
 deferred using <code>process.nextTick()</code>. Doing so allows batching of all
 <code>writable.write()</code> calls that occur within a given Node.js event loop phase.</p>
-<pre><code class="language-js">stream.cork();
-stream.write(<span class="hljs-string">'some '</span>);
-stream.write(<span class="hljs-string">'data '</span>);
-process.nextTick(<span class="hljs-function">() =></span> stream.uncork());</code></pre>
+<pre><code class="language-js">stream.<span class="hljs-title function_">cork</span>();
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some '</span>);
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'data '</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> stream.<span class="hljs-title function_">uncork</span>());</code></pre>
 <p>If the <a href="#stream_writable_cork"><code>writable.cork()</code></a> method is called multiple times on a stream, the
 same number of calls to <code>writable.uncork()</code> must be called to flush the buffered
 data.</p>
-<pre><code class="language-js">stream.cork();
-stream.write(<span class="hljs-string">'some '</span>);
-stream.cork();
-stream.write(<span class="hljs-string">'data '</span>);
-process.nextTick(<span class="hljs-function">() =></span> {
-  stream.uncork();
+<pre><code class="language-js">stream.<span class="hljs-title function_">cork</span>();
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some '</span>);
+stream.<span class="hljs-title function_">cork</span>();
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'data '</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+  stream.<span class="hljs-title function_">uncork</span>();
   <span class="hljs-comment">// The data will not be flushed until uncork() is called a second time.</span>
-  stream.uncork();
+  stream.<span class="hljs-title function_">uncork</span>();
 });</code></pre>
 <p>See also: <a href="#stream_writable_cork"><code>writable.cork()</code></a>.</p>
-<h5><code>writable.writable</code><span><a class="mark" href="#stream_writable_writable" id="stream_writable_writable">#</a></span></h5>
+<h6><code>writable.writable</code><span><a class="mark" href="#stream_writable_writable" id="stream_writable_writable">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v11.4.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Is <code>true</code> if it is safe to call <a href="#stream_writable_write_chunk_encoding_callback"><code>writable.write()</code></a>.</p>
-<h5><code>writable.writableEnded</code><span><a class="mark" href="#stream_writable_writableended" id="stream_writable_writableended">#</a></span></h5>
+<p>Is <code>true</code> if it is safe to call <a href="#stream_writable_write_chunk_encoding_callback"><code>writable.write()</code></a>, which means
+the stream has not been destroyed, errored or ended.</p>
+<h6><code>writable.writableEnded</code><span><a class="mark" href="#stream_writable_writableended" id="stream_writable_writableended">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -52170,16 +56597,16 @@ process.nextTick(<span class="hljs-function">() =></span> {
 <p>Is <code>true</code> after <a href="#stream_writable_end_chunk_encoding_callback"><code>writable.end()</code></a> has been called. This property
 does not indicate whether the data has been flushed, for this use
 <a href="#stream_writable_writablefinished"><code>writable.writableFinished</code></a> instead.</p>
-<h5><code>writable.writableCorked</code><span><a class="mark" href="#stream_writable_writablecorked" id="stream_writable_writablecorked">#</a></span></h5>
+<h6><code>writable.writableCorked</code><span><a class="mark" href="#stream_writable_writablecorked" id="stream_writable_writablecorked">#</a></span></h6>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Number of times <a href="#stream_writable_uncork"><code>writable.uncork()</code></a> needs to be
 called in order to fully uncork the stream.</p>
-<h5><code>writable.writableFinished</code><span><a class="mark" href="#stream_writable_writablefinished" id="stream_writable_writablefinished">#</a></span></h5>
+<h6><code>writable.writableFinished</code><span><a class="mark" href="#stream_writable_writablefinished" id="stream_writable_writablefinished">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.6.0</span>
 </div>
@@ -52187,7 +56614,7 @@ called in order to fully uncork the stream.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Is set to <code>true</code> immediately before the <a href="#stream_event_finish"><code>'finish'</code></a> event is emitted.</p>
-<h5><code>writable.writableHighWaterMark</code><span><a class="mark" href="#stream_writable_writablehighwatermark" id="stream_writable_writablehighwatermark">#</a></span></h5>
+<h6><code>writable.writableHighWaterMark</code><span><a class="mark" href="#stream_writable_writablehighwatermark" id="stream_writable_writablehighwatermark">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.3.0</span>
 </div>
@@ -52196,7 +56623,7 @@ called in order to fully uncork the stream.</p>
 </ul>
 <p>Return the value of <code>highWaterMark</code> passed when constructing this
 <code>Writable</code>.</p>
-<h5><code>writable.writableLength</code><span><a class="mark" href="#stream_writable_writablelength" id="stream_writable_writablelength">#</a></span></h5>
+<h6><code>writable.writableLength</code><span><a class="mark" href="#stream_writable_writablelength" id="stream_writable_writablelength">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -52206,7 +56633,15 @@ called in order to fully uncork the stream.</p>
 <p>This property contains the number of bytes (or objects) in the queue
 ready to be written. The value provides introspection data regarding
 the status of the <code>highWaterMark</code>.</p>
-<h5><code>writable.writableObjectMode</code><span><a class="mark" href="#stream_writable_writableobjectmode" id="stream_writable_writableobjectmode">#</a></span></h5>
+<h6><code>writable.writableNeedDrain</code><span><a class="mark" href="#stream_writable_writableneeddrain" id="stream_writable_writableneeddrain">#</a></span></h6>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Is <code>true</code> if the stream's buffer has been full and stream will emit <code>'drain'</code>.</p>
+<h6><code>writable.writableObjectMode</code><span><a class="mark" href="#stream_writable_writableobjectmode" id="stream_writable_writableobjectmode">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
@@ -52214,7 +56649,7 @@ the status of the <code>highWaterMark</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Getter for the property <code>objectMode</code> of a given <code>Writable</code> stream.</p>
-<h5><code>writable.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#stream_writable_write_chunk_encoding_callback" id="stream_writable_write_chunk_encoding_callback">#</a></span></h5>
+<h6><code>writable.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#stream_writable_write_chunk_encoding_callback" id="stream_writable_write_chunk_encoding_callback">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -52233,8 +56668,8 @@ the status of the <code>highWaterMark</code>.</p>
 not operating in object mode, <code>chunk</code> must be a string, <code>Buffer</code> or
 <code>Uint8Array</code>. For object mode streams, <code>chunk</code> may be any JavaScript value
 other than <code>null</code>.</li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The encoding, if <code>chunk</code> is a string. <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Callback for when this chunk of data is flushed</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> The encoding, if <code>chunk</code> is a string. <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Callback for when this chunk of data is flushed.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>false</code> if the stream wishes for the calling code to
 wait for the <code>'drain'</code> event to be emitted before continuing to write
 additional data; otherwise <code>true</code>.</li>
@@ -52243,7 +56678,8 @@ additional data; otherwise <code>true</code>.</li>
 supplied <code>callback</code> once the data has been fully handled. If an error
 occurs, the <code>callback</code> <em>may or may not</em> be called with the error as its
 first argument. To reliably detect write errors, add a listener for the
-<code>'error'</code> event.</p>
+<code>'error'</code> event. The <code>callback</code> is called asynchronously and before <code>'error'</code> is
+emitted.</p>
 <p>The return value is <code>true</code> if the internal buffer is less than the
 <code>highWaterMark</code> configured when the stream was created after admitting <code>chunk</code>.
 If <code>false</code> is returned, further attempts to write data to the stream should
@@ -52269,20 +56705,20 @@ recommended to encapsulate the logic into a <a href="#stream_class_stream_readab
 <a href="#stream_readable_pipe_destination_options"><code>stream.pipe()</code></a>. However, if calling <code>write()</code> is preferred, it is
 possible to respect backpressure and avoid memory issues using the
 <a href="#stream_event_drain"><code>'drain'</code></a> event:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">write</span>(<span class="hljs-params">data, cb</span>) </span>{
-  <span class="hljs-keyword">if</span> (!stream.write(data)) {
-    stream.once(<span class="hljs-string">'drain'</span>, cb);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">write</span>(<span class="hljs-params">data, cb</span>) {
+  <span class="hljs-keyword">if</span> (!stream.<span class="hljs-title function_">write</span>(data)) {
+    stream.<span class="hljs-title function_">once</span>(<span class="hljs-string">'drain'</span>, cb);
   } <span class="hljs-keyword">else</span> {
-    process.nextTick(cb);
+    process.<span class="hljs-title function_">nextTick</span>(cb);
   }
 }
 
 <span class="hljs-comment">// Wait for cb to be called before doing any other write.</span>
-write(<span class="hljs-string">'hello'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Write completed, do more writes now.'</span>);
+<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Write completed, do more writes now.'</span>);
 });</code></pre>
 <p>A <code>Writable</code> stream in object mode will always ignore the <code>encoding</code> argument.</p>
-<h3>Readable streams<span><a class="mark" href="#stream_readable_streams" id="stream_readable_streams">#</a></span></h3>
+<h4>Readable streams<span><a class="mark" href="#stream_readable_streams" id="stream_readable_streams">#</a></span></h4>
 <p>Readable streams are an abstraction for a <em>source</em> from which data is
 consumed.</p>
 <p>Examples of <code>Readable</code> streams include:</p>
@@ -52298,7 +56734,7 @@ consumed.</p>
 </ul>
 <p>All <a href="#stream_class_stream_readable"><code>Readable</code></a> streams implement the interface defined by the
 <code>stream.Readable</code> class.</p>
-<h4>Two reading modes<span><a class="mark" href="#stream_two_reading_modes" id="stream_two_reading_modes">#</a></span></h4>
+<h5>Two reading modes<span><a class="mark" href="#stream_two_reading_modes" id="stream_two_reading_modes">#</a></span></h5>
 <p><code>Readable</code> streams effectively operate in one of two modes: flowing and
 paused. These modes are separate from <a href="#stream_object_mode">object mode</a>.
 A <a href="#stream_class_stream_readable"><code>Readable</code></a> stream can be in object mode or not, regardless of whether
@@ -52347,7 +56783,7 @@ stop flowing, and the data has to be consumed via
 <a href="#stream_readable_read_size"><code>readable.read()</code></a>. If the <a href="#stream_event_readable"><code>'readable'</code></a> event handler is
 removed, then the stream will start flowing again if there is a
 <a href="#stream_event_data"><code>'data'</code></a> event handler.</p>
-<h4>Three states<span><a class="mark" href="#stream_three_states" id="stream_three_states">#</a></span></h4>
+<h5>Three states<span><a class="mark" href="#stream_three_states" id="stream_three_states">#</a></span></h5>
 <p>The "two modes" of operation for a <code>Readable</code> stream are a simplified
 abstraction for the more complicated internal state management that is happening
 within the <code>Readable</code> stream implementation.</p>
@@ -52369,20 +56805,20 @@ will cause the <code>readable.readableFlowing</code> to be set as <code>false</c
 temporarily halting the flowing of events but <em>not</em> halting the generation of
 data. While in this state, attaching a listener for the <code>'data'</code> event
 will not switch <code>readable.readableFlowing</code> to <code>true</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { PassThrough, Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-<span class="hljs-keyword">const</span> pass = <span class="hljs-keyword">new</span> PassThrough();
-<span class="hljs-keyword">const</span> writable = <span class="hljs-keyword">new</span> Writable();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">PassThrough</span>, <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> pass = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PassThrough</span>();
+<span class="hljs-keyword">const</span> writable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
 
-pass.pipe(writable);
-pass.unpipe(writable);
+pass.<span class="hljs-title function_">pipe</span>(writable);
+pass.<span class="hljs-title function_">unpipe</span>(writable);
 <span class="hljs-comment">// readableFlowing is now false.</span>
 
-pass.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-built_in">console</span>.log(chunk.toString()); });
-pass.write(<span class="hljs-string">'ok'</span>);  <span class="hljs-comment">// Will not emit 'data'.</span>
-pass.resume();     <span class="hljs-comment">// Must be called to make stream emit 'data'.</span></code></pre>
+pass.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk.<span class="hljs-title function_">toString</span>()); });
+pass.<span class="hljs-title function_">write</span>(<span class="hljs-string">'ok'</span>);  <span class="hljs-comment">// Will not emit 'data'.</span>
+pass.<span class="hljs-title function_">resume</span>();     <span class="hljs-comment">// Must be called to make stream emit 'data'.</span></code></pre>
 <p>While <code>readable.readableFlowing</code> is <code>false</code>, data may be accumulating
 within the stream's internal buffer.</p>
-<h4>Choose one API style<span><a class="mark" href="#stream_choose_one_api_style" id="stream_choose_one_api_style">#</a></span></h4>
+<h5>Choose one API style<span><a class="mark" href="#stream_choose_one_api_style" id="stream_choose_one_api_style">#</a></span></h5>
 <p>The <code>Readable</code> stream API evolved across multiple Node.js versions and provides
 multiple methods of consuming stream data. In general, developers should choose
 <em>one</em> of the methods of consuming data and <em>should never</em> use multiple methods
@@ -52394,12 +56830,12 @@ implemented to provide the easiest way of consuming stream data. Developers that
 require more fine-grained control over the transfer and generation of data can
 use the <a href="#events_class_eventemitter"><code>EventEmitter</code></a> and <code>readable.on('readable')</code>/<code>readable.read()</code>
 or the <code>readable.pause()</code>/<code>readable.resume()</code> APIs.</p>
-<h4>Class: <code>stream.Readable</code><span><a class="mark" href="#stream_class_stream_readable" id="stream_class_stream_readable">#</a></span></h4>
+<h5>Class: <code>stream.Readable</code><span><a class="mark" href="#stream_class_stream_readable" id="stream_class_stream_readable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 
-<h5>Event: <code>'close'</code><span><a class="mark" href="#stream_event_close_1" id="stream_event_close_1">#</a></span></h5>
+<h6>Event: <code>'close'</code><span><a class="mark" href="#stream_event_close_1" id="stream_event_close_1">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -52416,7 +56852,7 @@ resources (a file descriptor, for example) have been closed. The event indicates
 that no more events will be emitted, and no further computation will occur.</p>
 <p>A <a href="#stream_class_stream_readable"><code>Readable</code></a> stream will always emit the <code>'close'</code> event if it is
 created with the <code>emitClose</code> option.</p>
-<h5>Event: <code>'data'</code><span><a class="mark" href="#stream_event_data" id="stream_event_data">#</a></span></h5>
+<h6>Event: <code>'data'</code><span><a class="mark" href="#stream_event_data" id="stream_event_data">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52439,11 +56875,11 @@ soon as it is available.</p>
 encoding has been specified for the stream using the
 <code>readable.setEncoding()</code> method; otherwise the data will be passed as a
 <code>Buffer</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
 });</code></pre>
-<h5>Event: <code>'end'</code><span><a class="mark" href="#stream_event_end" id="stream_event_end">#</a></span></h5>
+<h6>Event: <code>'end'</code><span><a class="mark" href="#stream_event_end" id="stream_event_end">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52453,14 +56889,14 @@ the stream.</p>
 consumed. This can be accomplished by switching the stream into flowing mode,
 or by calling <a href="#stream_readable_read_size"><code>stream.read()</code></a> repeatedly until all data has been
 consumed.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
 });
-readable.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'There will be no more data.'</span>);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'There will be no more data.'</span>);
 });</code></pre>
-<h5>Event: <code>'error'</code><span><a class="mark" href="#stream_event_error_1" id="stream_event_error_1">#</a></span></h5>
+<h6>Event: <code>'error'</code><span><a class="mark" href="#stream_event_error_1" id="stream_event_error_1">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52472,13 +56908,13 @@ Typically, this may occur if the underlying stream is unable to generate data
 due to an underlying internal failure, or when a stream implementation attempts
 to push an invalid chunk of data.</p>
 <p>The listener callback will be passed a single <code>Error</code> object.</p>
-<h5>Event: <code>'pause'</code><span><a class="mark" href="#stream_event_pause" id="stream_event_pause">#</a></span></h5>
+<h6>Event: <code>'pause'</code><span><a class="mark" href="#stream_event_pause" id="stream_event_pause">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 <p>The <code>'pause'</code> event is emitted when <a href="#stream_readable_pause"><code>stream.pause()</code></a> is called
 and <code>readableFlowing</code> is not <code>false</code>.</p>
-<h5>Event: <code>'readable'</code><span><a class="mark" href="#stream_event_readable" id="stream_event_readable">#</a></span></h5>
+<h6>Event: <code>'readable'</code><span><a class="mark" href="#stream_event_readable" id="stream_event_readable">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -52495,13 +56931,13 @@ and <code>readableFlowing</code> is not <code>false</code>.</p>
 <p>The <code>'readable'</code> event is emitted when there is data available to be read from
 the stream. In some cases, attaching a listener for the <code>'readable'</code> event will
 cause some amount of data to be read into an internal buffer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// There is some data to read now.</span>
   <span class="hljs-keyword">let</span> data;
 
-  <span class="hljs-keyword">while</span> (data = <span class="hljs-built_in">this</span>.read()) {
-    <span class="hljs-built_in">console</span>.log(data);
+  <span class="hljs-keyword">while</span> (data = <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">read</span>()) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
   }
 });</code></pre>
 <p>The <code>'readable'</code> event will also be emitted once the end of the stream data
@@ -52512,15 +56948,15 @@ reached. In the former case, <a href="#stream_readable_read_size"><code>stream.r
 available data. In the latter case, <a href="#stream_readable_read_size"><code>stream.read()</code></a> will return
 <code>null</code>. For instance, in the following example, <code>foo.txt</code> is an empty file:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> rr = fs.createReadStream(<span class="hljs-string">'foo.txt'</span>);
-rr.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`readable: <span class="hljs-subst">${rr.read()}</span>`</span>);
+<span class="hljs-keyword">const</span> rr = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'foo.txt'</span>);
+rr.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`readable: <span class="hljs-subst">${rr.read()}</span>`</span>);
 });
-rr.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'end'</span>);
+rr.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'end'</span>);
 });</code></pre>
 <p>The output of running this script is:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node test.js</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node test.js</span>
 readable: null
 end</code></pre>
 <p>In general, the <code>readable.pipe()</code> and <code>'data'</code> event mechanisms are easier to
@@ -52533,15 +56969,23 @@ only when <a href="#stream_readable_read_size"><code>stream.read()</code></a> is
 If there are <code>'data'</code> listeners when <code>'readable'</code> is removed, the stream
 will start flowing, i.e. <code>'data'</code> events will be emitted without calling
 <code>.resume()</code>.</p>
-<h5>Event: <code>'resume'</code><span><a class="mark" href="#stream_event_resume" id="stream_event_resume">#</a></span></h5>
+<h6>Event: <code>'resume'</code><span><a class="mark" href="#stream_event_resume" id="stream_event_resume">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 <p>The <code>'resume'</code> event is emitted when <a href="#stream_readable_resume"><code>stream.resume()</code></a> is
 called and <code>readableFlowing</code> is not <code>true</code>.</p>
-<h5><code>readable.destroy([error])</code><span><a class="mark" href="#stream_readable_destroy_error" id="stream_readable_destroy_error">#</a></span></h5>
+<h6><code>readable.destroy([error])</code><span><a class="mark" href="#stream_readable_destroy_error" id="stream_readable_destroy_error">#</a></span></h6>
 <div class="api_metadata">
-<span>Added in: v8.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Work as a no-op on a stream that has already been destroyed.</p></td></tr>
+<tr><td>v8.0.0</td>
+<td><p><span>Added in: v8.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Error which will be passed as payload in <code>'error'</code> event</li>
@@ -52550,10 +56994,12 @@ called and <code>readableFlowing</code> is not <code>true</code>.</p>
 <p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>
 event (unless <code>emitClose</code> is set to <code>false</code>). After this call, the readable
 stream will release any internal resources and subsequent calls to <code>push()</code>
-will be ignored.
-Implementors should not override this method, but instead implement
+will be ignored.</p>
+<p>Once <code>destroy()</code> has been called any further calls will be a no-op and no
+further errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>
+<p>Implementors should not override this method, but instead implement
 <a href="#stream_readable_destroy_err_callback"><code>readable._destroy()</code></a>.</p>
-<h5><code>readable.destroyed</code><span><a class="mark" href="#stream_readable_destroyed" id="stream_readable_destroyed">#</a></span></h5>
+<h6><code>readable.destroyed</code><span><a class="mark" href="#stream_readable_destroyed" id="stream_readable_destroyed">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -52561,7 +57007,7 @@ Implementors should not override this method, but instead implement
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Is <code>true</code> after <a href="#stream_readable_destroy_error"><code>readable.destroy()</code></a> has been called.</p>
-<h5><code>readable.isPaused()</code><span><a class="mark" href="#stream_readable_ispaused" id="stream_readable_ispaused">#</a></span></h5>
+<h6><code>readable.isPaused()</code><span><a class="mark" href="#stream_readable_ispaused" id="stream_readable_ispaused">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -52572,14 +57018,14 @@ Implementors should not override this method, but instead implement
 <code>Readable</code>. This is used primarily by the mechanism that underlies the
 <code>readable.pipe()</code> method. In most typical cases, there will be no reason to
 use this method directly.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-keyword">new</span> stream.Readable();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-keyword">new</span> stream.<span class="hljs-title class_">Readable</span>();
 
-readable.isPaused(); <span class="hljs-comment">// === false</span>
-readable.pause();
-readable.isPaused(); <span class="hljs-comment">// === true</span>
-readable.resume();
-readable.isPaused(); <span class="hljs-comment">// === false</span></code></pre>
-<h5><code>readable.pause()</code><span><a class="mark" href="#stream_readable_pause" id="stream_readable_pause">#</a></span></h5>
+readable.<span class="hljs-title function_">isPaused</span>(); <span class="hljs-comment">// === false</span>
+readable.<span class="hljs-title function_">pause</span>();
+readable.<span class="hljs-title function_">isPaused</span>(); <span class="hljs-comment">// === true</span>
+readable.<span class="hljs-title function_">resume</span>();
+readable.<span class="hljs-title function_">isPaused</span>(); <span class="hljs-comment">// === false</span></code></pre>
+<h6><code>readable.pause()</code><span><a class="mark" href="#stream_readable_pause" id="stream_readable_pause">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52589,19 +57035,19 @@ readable.isPaused(); <span class="hljs-comment">// === false</span></code></pre>
 <p>The <code>readable.pause()</code> method will cause a stream in flowing mode to stop
 emitting <a href="#stream_event_data"><code>'data'</code></a> events, switching out of flowing mode. Any data that
 becomes available will remain in the internal buffer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
-  readable.pause();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'There will be no additional data for 1 second.'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
+  readable.<span class="hljs-title function_">pause</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'There will be no additional data for 1 second.'</span>);
   <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Now data will start flowing again.'</span>);
-    readable.resume();
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Now data will start flowing again.'</span>);
+    readable.<span class="hljs-title function_">resume</span>();
   }, <span class="hljs-number">1000</span>);
 });</code></pre>
 <p>The <code>readable.pause()</code> method has no effect if there is a <code>'readable'</code>
 event listener.</p>
-<h5><code>readable.pipe(destination[, options])</code><span><a class="mark" href="#stream_readable_pipe_destination_options" id="stream_readable_pipe_destination_options">#</a></span></h5>
+<h6><code>readable.pipe(destination[, options])</code><span><a class="mark" href="#stream_readable_pipe_destination_options" id="stream_readable_pipe_destination_options">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52623,26 +57069,26 @@ so that the destination <code>Writable</code> stream is not overwhelmed by a fas
 <p>The following example pipes all of the data from the <code>readable</code> into a file
 named <code>file.txt</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'file.txt'</span>);
+<span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+<span class="hljs-keyword">const</span> writable = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'file.txt'</span>);
 <span class="hljs-comment">// All the data from readable goes into 'file.txt'.</span>
-readable.pipe(writable);</code></pre>
+readable.<span class="hljs-title function_">pipe</span>(writable);</code></pre>
 <p>It is possible to attach multiple <code>Writable</code> streams to a single <code>Readable</code>
 stream.</p>
 <p>The <code>readable.pipe()</code> method returns a reference to the <em>destination</em> stream
 making it possible to set up chains of piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> r = fs.createReadStream(<span class="hljs-string">'file.txt'</span>);
-<span class="hljs-keyword">const</span> z = zlib.createGzip();
-<span class="hljs-keyword">const</span> w = fs.createWriteStream(<span class="hljs-string">'file.txt.gz'</span>);
-r.pipe(z).pipe(w);</code></pre>
+<span class="hljs-keyword">const</span> r = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'file.txt'</span>);
+<span class="hljs-keyword">const</span> z = zlib.<span class="hljs-title function_">createGzip</span>();
+<span class="hljs-keyword">const</span> w = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'file.txt.gz'</span>);
+r.<span class="hljs-title function_">pipe</span>(z).<span class="hljs-title function_">pipe</span>(w);</code></pre>
 <p>By default, <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> is called on the destination <code>Writable</code>
 stream when the source <code>Readable</code> stream emits <a href="#stream_event_end"><code>'end'</code></a>, so that the
 destination is no longer writable. To disable this default behavior, the <code>end</code>
 option can be passed as <code>false</code>, causing the destination stream to remain open:</p>
-<pre><code class="language-js">reader.pipe(writer, { <span class="hljs-attr">end</span>: <span class="hljs-literal">false</span> });
-reader.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  writer.end(<span class="hljs-string">'Goodbye\n'</span>);
+<pre><code class="language-js">reader.<span class="hljs-title function_">pipe</span>(writer, { <span class="hljs-attr">end</span>: <span class="hljs-literal">false</span> });
+reader.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  writer.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Goodbye\n'</span>);
 });</code></pre>
 <p>One important caveat is that if the <code>Readable</code> stream emits an error during
 processing, the <code>Writable</code> destination <em>is not closed</em> automatically. If an
@@ -52650,7 +57096,7 @@ error occurs, it will be necessary to <em>manually</em> close each stream in ord
 to prevent memory leaks.</p>
 <p>The <a href="#process_process_stderr"><code>process.stderr</code></a> and <a href="#process_process_stdout"><code>process.stdout</code></a> <code>Writable</code> streams are never
 closed until the Node.js process exits, regardless of the specified options.</p>
-<h5><code>readable.read([size])</code><span><a class="mark" href="#stream_readable_read_size" id="stream_readable_read_size">#</a></span></h5>
+<h6><code>readable.read([size])</code><span><a class="mark" href="#stream_readable_read_size" id="stream_readable_read_size">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52669,25 +57115,25 @@ the stream has ended, in which case all of the data remaining in the internal
 buffer will be returned.</p>
 <p>If the <code>size</code> argument is not specified, all of the data contained in the
 internal buffer will be returned.</p>
-<p>The <code>size</code> argument must be less than or equal to 1 GB.</p>
+<p>The <code>size</code> argument must be less than or equal to 1 GiB.</p>
 <p>The <code>readable.read()</code> method should only be called on <code>Readable</code> streams
 operating in paused mode. In flowing mode, <code>readable.read()</code> is called
 automatically until the internal buffer is fully drained.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
 
 <span class="hljs-comment">// 'readable' may be triggered multiple times as data is buffered in</span>
-readable.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-keyword">let</span> chunk;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Stream is readable (new data received in buffer)'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Stream is readable (new data received in buffer)'</span>);
   <span class="hljs-comment">// Use a loop to make sure we read all currently available data</span>
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = readable.read())) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Read <span class="hljs-subst">${chunk.length}</span> bytes of data...`</span>);
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = readable.<span class="hljs-title function_">read</span>())) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Read <span class="hljs-subst">${chunk.length}</span> bytes of data...`</span>);
   }
 });
 
 <span class="hljs-comment">// 'end' will be triggered once when there is no more data available</span>
-readable.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Reached end of stream.'</span>);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Reached end of stream.'</span>);
 });</code></pre>
 <p>Each call to <code>readable.read()</code> returns a chunk of data, or <code>null</code>. The chunks
 are not concatenated. A <code>while</code> loop is necessary to consume all data
@@ -52700,15 +57146,15 @@ emitted when there is no more data to come.</p>
 to collect chunks across multiple <code>'readable'</code> events:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> chunks = [];
 
-readable.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-keyword">let</span> chunk;
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = readable.read())) {
-    chunks.push(chunk);
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = readable.<span class="hljs-title function_">read</span>())) {
+    chunks.<span class="hljs-title function_">push</span>(chunk);
   }
 });
 
-readable.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> content = chunks.join(<span class="hljs-string">''</span>);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">const</span> content = chunks.<span class="hljs-title function_">join</span>(<span class="hljs-string">''</span>);
 });</code></pre>
 <p>A <code>Readable</code> stream in object mode will always return a single item from
 a call to <a href="#stream_readable_read_size"><code>readable.read(size)</code></a>, regardless of the value of the
@@ -52717,15 +57163,26 @@ a call to <a href="#stream_readable_read_size"><code>readable.read(size)</code><
 also be emitted.</p>
 <p>Calling <a href="#stream_readable_read_size"><code>stream.read([size])</code></a> after the <a href="#stream_event_end"><code>'end'</code></a> event has
 been emitted will return <code>null</code>. No runtime error will be raised.</p>
-<h5><code>readable.readable</code><span><a class="mark" href="#stream_readable_readable" id="stream_readable_readable">#</a></span></h5>
+<h6><code>readable.readable</code><span><a class="mark" href="#stream_readable_readable" id="stream_readable_readable">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v11.4.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Is <code>true</code> if it is safe to call <a href="#stream_readable_read_size"><code>readable.read()</code></a>.</p>
-<h5><code>readable.readableEncoding</code><span><a class="mark" href="#stream_readable_readableencoding" id="stream_readable_readableencoding">#</a></span></h5>
+<p>Is <code>true</code> if it is safe to call <a href="#stream_readable_read_size"><code>readable.read()</code></a>, which means
+the stream has not been destroyed or emitted <code>'error'</code> or <code>'end'</code>.</p>
+<h6><code>readable.readableDidRead</code><span><a class="mark" href="#stream_readable_readabledidread" id="stream_readable_readabledidread">#</a></span></h6>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Allows determining if the stream has been or is about to be read.
+Returns true if <code>'data'</code>, <code>'end'</code>, <code>'error'</code> or <code>'close'</code> has been
+emitted.</p>
+<h6><code>readable.readableEncoding</code><span><a class="mark" href="#stream_readable_readableencoding" id="stream_readable_readableencoding">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
@@ -52734,7 +57191,7 @@ been emitted will return <code>null</code>. No runtime error will be raised.</p>
 </ul>
 <p>Getter for the property <code>encoding</code> of a given <code>Readable</code> stream. The <code>encoding</code>
 property can be set using the <a href="#stream_readable_setencoding_encoding"><code>readable.setEncoding()</code></a> method.</p>
-<h5><code>readable.readableEnded</code><span><a class="mark" href="#stream_readable_readableended" id="stream_readable_readableended">#</a></span></h5>
+<h6><code>readable.readableEnded</code><span><a class="mark" href="#stream_readable_readableended" id="stream_readable_readableended">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -52742,7 +57199,7 @@ property can be set using the <a href="#stream_readable_setencoding_encoding"><c
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Becomes <code>true</code> when <a href="#stream_event_end"><code>'end'</code></a> event is emitted.</p>
-<h5><code>readable.readableFlowing</code><span><a class="mark" href="#stream_readable_readableflowing" id="stream_readable_readableflowing">#</a></span></h5>
+<h6><code>readable.readableFlowing</code><span><a class="mark" href="#stream_readable_readableflowing" id="stream_readable_readableflowing">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -52751,7 +57208,7 @@ property can be set using the <a href="#stream_readable_setencoding_encoding"><c
 </ul>
 <p>This property reflects the current state of a <code>Readable</code> stream as described
 in the <a href="#stream_three_states">Three states</a> section.</p>
-<h5><code>readable.readableHighWaterMark</code><span><a class="mark" href="#stream_readable_readablehighwatermark" id="stream_readable_readablehighwatermark">#</a></span></h5>
+<h6><code>readable.readableHighWaterMark</code><span><a class="mark" href="#stream_readable_readablehighwatermark" id="stream_readable_readablehighwatermark">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.3.0</span>
 </div>
@@ -52760,7 +57217,7 @@ in the <a href="#stream_three_states">Three states</a> section.</p>
 </ul>
 <p>Returns the value of <code>highWaterMark</code> passed when constructing this
 <code>Readable</code>.</p>
-<h5><code>readable.readableLength</code><span><a class="mark" href="#stream_readable_readablelength" id="stream_readable_readablelength">#</a></span></h5>
+<h6><code>readable.readableLength</code><span><a class="mark" href="#stream_readable_readablelength" id="stream_readable_readablelength">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -52770,7 +57227,7 @@ in the <a href="#stream_three_states">Three states</a> section.</p>
 <p>This property contains the number of bytes (or objects) in the queue
 ready to be read. The value provides introspection data regarding
 the status of the <code>highWaterMark</code>.</p>
-<h5><code>readable.readableObjectMode</code><span><a class="mark" href="#stream_readable_readableobjectmode" id="stream_readable_readableobjectmode">#</a></span></h5>
+<h6><code>readable.readableObjectMode</code><span><a class="mark" href="#stream_readable_readableobjectmode" id="stream_readable_readableobjectmode">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
@@ -52778,7 +57235,7 @@ the status of the <code>highWaterMark</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Getter for the property <code>objectMode</code> of a given <code>Readable</code> stream.</p>
-<h5><code>readable.resume()</code><span><a class="mark" href="#stream_readable_resume" id="stream_readable_resume">#</a></span></h5>
+<h6><code>readable.resume()</code><span><a class="mark" href="#stream_readable_resume" id="stream_readable_resume">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -52797,14 +57254,14 @@ the status of the <code>highWaterMark</code>.</p>
 resume emitting <a href="#stream_event_data"><code>'data'</code></a> events, switching the stream into flowing mode.</p>
 <p>The <code>readable.resume()</code> method can be used to fully consume the data from a
 stream without actually processing any of that data:</p>
-<pre><code class="language-js">getReadableStreamSomehow()
-  .resume()
-  .on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Reached the end, but did not read anything.'</span>);
+<pre><code class="language-js"><span class="hljs-title function_">getReadableStreamSomehow</span>()
+  .<span class="hljs-title function_">resume</span>()
+  .<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Reached the end, but did not read anything.'</span>);
   });</code></pre>
 <p>The <code>readable.resume()</code> method has no effect if there is a <code>'readable'</code>
 event listener.</p>
-<h5><code>readable.setEncoding(encoding)</code><span><a class="mark" href="#stream_readable_setencoding_encoding" id="stream_readable_setencoding_encoding">#</a></span></h5>
+<h6><code>readable.setEncoding(encoding)</code><span><a class="mark" href="#stream_readable_setencoding_encoding" id="stream_readable_setencoding_encoding">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52824,13 +57281,13 @@ string format.</p>
 <p>The <code>Readable</code> stream will properly handle multi-byte characters delivered
 through the stream that would otherwise become improperly decoded if simply
 pulled from the stream as <code>Buffer</code> objects.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.setEncoding(<span class="hljs-string">'utf8'</span>);
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  assert.equal(<span class="hljs-keyword">typeof</span> chunk, <span class="hljs-string">'string'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Got %d characters of string data:'</span>, chunk.length);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  assert.<span class="hljs-title function_">equal</span>(<span class="hljs-keyword">typeof</span> chunk, <span class="hljs-string">'string'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Got %d characters of string data:'</span>, chunk.<span class="hljs-property">length</span>);
 });</code></pre>
-<h5><code>readable.unpipe([destination])</code><span><a class="mark" href="#stream_readable_unpipe_destination" id="stream_readable_unpipe_destination">#</a></span></h5>
+<h6><code>readable.unpipe([destination])</code><span><a class="mark" href="#stream_readable_unpipe_destination" id="stream_readable_unpipe_destination">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52844,18 +57301,18 @@ using the <a href="#stream_readable_pipe_destination_options"><code>stream.pipe(
 <p>If the <code>destination</code> is specified, but no pipe is set up for it, then
 the method does nothing.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'file.txt'</span>);
+<span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+<span class="hljs-keyword">const</span> writable = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'file.txt'</span>);
 <span class="hljs-comment">// All the data from readable goes into 'file.txt',</span>
 <span class="hljs-comment">// but only for the first second.</span>
-readable.pipe(writable);
+readable.<span class="hljs-title function_">pipe</span>(writable);
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Stop writing to file.txt.'</span>);
-  readable.unpipe(writable);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Manually close the file stream.'</span>);
-  writable.end();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Stop writing to file.txt.'</span>);
+  readable.<span class="hljs-title function_">unpipe</span>(writable);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Manually close the file stream.'</span>);
+  writable.<span class="hljs-title function_">end</span>();
 }, <span class="hljs-number">1000</span>);</code></pre>
-<h5><code>readable.unshift(chunk[, encoding])</code><span><a class="mark" href="#stream_readable_unshift_chunk_encoding" id="stream_readable_unshift_chunk_encoding">#</a></span></h5>
+<h6><code>readable.unshift(chunk[, encoding])</code><span><a class="mark" href="#stream_readable_unshift_chunk_encoding" id="stream_readable_unshift_chunk_encoding">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -52891,29 +57348,29 @@ section for more information.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Pull off a header delimited by \n\n.</span>
 <span class="hljs-comment">// Use unshift() if we get too much.</span>
 <span class="hljs-comment">// Call the callback with (error, header, stream).</span>
-<span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">parseHeader</span>(<span class="hljs-params">stream, callback</span>) </span>{
-  stream.on(<span class="hljs-string">'error'</span>, callback);
-  stream.on(<span class="hljs-string">'readable'</span>, onReadable);
-  <span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> StringDecoder(<span class="hljs-string">'utf8'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">parseHeader</span>(<span class="hljs-params">stream, callback</span>) {
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, callback);
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, onReadable);
+  <span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringDecoder</span>(<span class="hljs-string">'utf8'</span>);
   <span class="hljs-keyword">let</span> header = <span class="hljs-string">''</span>;
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">onReadable</span>(<span class="hljs-params"></span>) </span>{
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">onReadable</span>(<span class="hljs-params"></span>) {
     <span class="hljs-keyword">let</span> chunk;
-    <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = stream.read())) {
-      <span class="hljs-keyword">const</span> str = decoder.write(chunk);
-      <span class="hljs-keyword">if</span> (str.match(<span class="hljs-regexp">/\n\n/</span>)) {
+    <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = stream.<span class="hljs-title function_">read</span>())) {
+      <span class="hljs-keyword">const</span> str = decoder.<span class="hljs-title function_">write</span>(chunk);
+      <span class="hljs-keyword">if</span> (str.<span class="hljs-title function_">match</span>(<span class="hljs-regexp">/\n\n/</span>)) {
         <span class="hljs-comment">// Found the header boundary.</span>
-        <span class="hljs-keyword">const</span> split = str.split(<span class="hljs-regexp">/\n\n/</span>);
-        header += split.shift();
-        <span class="hljs-keyword">const</span> remaining = split.join(<span class="hljs-string">'\n\n'</span>);
-        <span class="hljs-keyword">const</span> buf = Buffer.from(remaining, <span class="hljs-string">'utf8'</span>);
-        stream.removeListener(<span class="hljs-string">'error'</span>, callback);
+        <span class="hljs-keyword">const</span> split = str.<span class="hljs-title function_">split</span>(<span class="hljs-regexp">/\n\n/</span>);
+        header += split.<span class="hljs-title function_">shift</span>();
+        <span class="hljs-keyword">const</span> remaining = split.<span class="hljs-title function_">join</span>(<span class="hljs-string">'\n\n'</span>);
+        <span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(remaining, <span class="hljs-string">'utf8'</span>);
+        stream.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'error'</span>, callback);
         <span class="hljs-comment">// Remove the 'readable' listener before unshifting.</span>
-        stream.removeListener(<span class="hljs-string">'readable'</span>, onReadable);
-        <span class="hljs-keyword">if</span> (buf.length)
-          stream.unshift(buf);
+        stream.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'readable'</span>, onReadable);
+        <span class="hljs-keyword">if</span> (buf.<span class="hljs-property">length</span>)
+          stream.<span class="hljs-title function_">unshift</span>(buf);
         <span class="hljs-comment">// Now the body of the message can be read from the stream.</span>
-        callback(<span class="hljs-literal">null</span>, header, stream);
+        <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, header, stream);
       } <span class="hljs-keyword">else</span> {
         <span class="hljs-comment">// Still reading the header.</span>
         header += str;
@@ -52929,7 +57386,7 @@ custom stream). Following the call to <code>readable.unshift()</code> with an im
 <a href="#stream_readable_push_chunk_encoding"><code>stream.push('')</code></a> will reset the reading state appropriately,
 however it is best to simply avoid calling <code>readable.unshift()</code> while in the
 process of performing a read.</p>
-<h5><code>readable.wrap(stream)</code><span><a class="mark" href="#stream_readable_wrap_stream" id="stream_readable_wrap_stream">#</a></span></h5>
+<h6><code>readable.wrap(stream)</code><span><a class="mark" href="#stream_readable_wrap_stream" id="stream_readable_wrap_stream">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -52946,15 +57403,15 @@ the old stream as its data source.</p>
 <p>It will rarely be necessary to use <code>readable.wrap()</code> but the method has been
 provided as a convenience for interacting with older Node.js applications and
 libraries.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { OldReader } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./old-api-module.js'</span>);
-<span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-<span class="hljs-keyword">const</span> oreader = <span class="hljs-keyword">new</span> OldReader();
-<span class="hljs-keyword">const</span> myReader = <span class="hljs-keyword">new</span> Readable().wrap(oreader);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">OldReader</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./old-api-module.js'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> oreader = <span class="hljs-keyword">new</span> <span class="hljs-title class_">OldReader</span>();
+<span class="hljs-keyword">const</span> myReader = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Readable</span>().<span class="hljs-title function_">wrap</span>(oreader);
 
-myReader.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
-  myReader.read(); <span class="hljs-comment">// etc.</span>
+myReader.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+  myReader.<span class="hljs-title function_">read</span>(); <span class="hljs-comment">// etc.</span>
 });</code></pre>
-<h5><code>readable[Symbol.asyncIterator]()</code><span><a class="mark" href="#stream_readable_symbol_asynciterator" id="stream_readable_symbol_asynciterator">#</a></span></h5>
+<h6><code>readable[Symbol.asyncIterator]()</code><span><a class="mark" href="#stream_readable_symbol_asynciterator" id="stream_readable_symbol_asynciterator">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -52971,24 +57428,24 @@ myReader.on(<span class="hljs-string">'readable'</span>, <span class="hljs-funct
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">print</span>(<span class="hljs-params">readable</span>) </span>{
-  readable.setEncoding(<span class="hljs-string">'utf8'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">print</span>(<span class="hljs-params">readable</span>) {
+  readable.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
   <span class="hljs-keyword">let</span> data = <span class="hljs-string">''</span>;
   <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> chunk <span class="hljs-keyword">of</span> readable) {
     data += chunk;
   }
-  <span class="hljs-built_in">console</span>.log(data);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
 }
 
-print(fs.createReadStream(<span class="hljs-string">'file'</span>)).catch(<span class="hljs-built_in">console</span>.error);</code></pre>
+<span class="hljs-title function_">print</span>(fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'file'</span>)).<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);</code></pre>
 <p>If the loop terminates with a <code>break</code> or a <code>throw</code>, the stream will be
 destroyed. In other terms, iterating over a stream will consume the stream
 fully. The stream will be read in chunks of size equal to the <code>highWaterMark</code>
 option. In the code example above, data will be in a single chunk if the file
 has less then 64KB of data because no <code>highWaterMark</code> option is provided to
 <a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream()</code></a>.</p>
-<h3>Duplex and transform streams<span><a class="mark" href="#stream_duplex_and_transform_streams" id="stream_duplex_and_transform_streams">#</a></span></h3>
-<h4>Class: <code>stream.Duplex</code><span><a class="mark" href="#stream_class_stream_duplex" id="stream_class_stream_duplex">#</a></span></h4>
+<h4>Duplex and transform streams<span><a class="mark" href="#stream_duplex_and_transform_streams" id="stream_duplex_and_transform_streams">#</a></span></h4>
+<h5>Class: <code>stream.Duplex</code><span><a class="mark" href="#stream_class_stream_duplex" id="stream_class_stream_duplex">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -53009,7 +57466,7 @@ has less then 64KB of data because no <code>highWaterMark</code> option is provi
 <li><a href="zlib.html">zlib streams</a></li>
 <li><a href="crypto.html">crypto streams</a></li>
 </ul>
-<h4>Class: <code>stream.Transform</code><span><a class="mark" href="#stream_class_stream_transform" id="stream_class_stream_transform">#</a></span></h4>
+<h5>Class: <code>stream.Transform</code><span><a class="mark" href="#stream_class_stream_transform" id="stream_class_stream_transform">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -53022,9 +57479,17 @@ implement both the <a href="#stream_class_stream_readable"><code>Readable</code>
 <li><a href="zlib.html">zlib streams</a></li>
 <li><a href="crypto.html">crypto streams</a></li>
 </ul>
-<h5><code>transform.destroy([error])</code><span><a class="mark" href="#stream_transform_destroy_error" id="stream_transform_destroy_error">#</a></span></h5>
+<h6><code>transform.destroy([error])</code><span><a class="mark" href="#stream_transform_destroy_error" id="stream_transform_destroy_error">#</a></span></h6>
 <div class="api_metadata">
-<span>Added in: v8.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Work as a no-op on a stream that has already been destroyed.</p></td></tr>
+<tr><td>v8.0.0</td>
+<td><p><span>Added in: v8.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
@@ -53036,9 +57501,23 @@ Implementors should not override this method, but instead implement
 <a href="#stream_readable_destroy_err_callback"><code>readable._destroy()</code></a>.
 The default implementation of <code>_destroy()</code> for <code>Transform</code> also emit <code>'close'</code>
 unless <code>emitClose</code> is set in false.</p>
-<h3><code>stream.finished(stream[, options], callback)</code><span><a class="mark" href="#stream_stream_finished_stream_options_callback" id="stream_stream_finished_stream_options_callback">#</a></span></h3>
+<p>Once <code>destroy()</code> has been called, any further calls will be a no-op and no
+further errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>
+<h4><code>stream.finished(stream[, options], callback)</code><span><a class="mark" href="#stream_stream_finished_stream_options_callback" id="stream_stream_finished_stream_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>finished(stream, cb)</code> will wait for the <code>'close'</code> event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit <code>'close'</code>.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>Emitting <code>'close'</code> before <code>'end'</code> on a <code>Readable</code> stream will cause an <code>ERR_STREAM_PREMATURE_CLOSE</code> error.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>Callback will be invoked on streams which have already finished before the call to <code>finished(stream, cb)</code>.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>stream</code> <a href="#stream_stream" class="type">&#x3C;Stream></a> A readable and/or writable stream.</li>
@@ -53063,56 +57542,86 @@ listeners.</li>
 or has experienced an error or a premature close event.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { finished } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> rs = fs.createReadStream(<span class="hljs-string">'archive.tar'</span>);
+<span class="hljs-keyword">const</span> rs = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'archive.tar'</span>);
 
-finished(rs, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<span class="hljs-title function_">finished</span>(rs, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Stream failed.'</span>, err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Stream failed.'</span>, err);
   } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Stream is done reading.'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Stream is done reading.'</span>);
   }
 });
 
-rs.resume(); <span class="hljs-comment">// Drain the stream.</span></code></pre>
+rs.<span class="hljs-title function_">resume</span>(); <span class="hljs-comment">// Drain the stream.</span></code></pre>
 <p>Especially useful in error handling scenarios where a stream is destroyed
 prematurely (like an aborted HTTP request), and will not emit <code>'end'</code>
 or <code>'finish'</code>.</p>
 <p>The <code>finished</code> API is promisify-able as well;</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> finished = util.promisify(stream.finished);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> finished = util.<span class="hljs-title function_">promisify</span>(stream.<span class="hljs-property">finished</span>);
 
-<span class="hljs-keyword">const</span> rs = fs.createReadStream(<span class="hljs-string">'archive.tar'</span>);
+<span class="hljs-keyword">const</span> rs = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'archive.tar'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">run</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> finished(rs);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Stream is done reading.'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">run</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">finished</span>(rs);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Stream is done reading.'</span>);
 }
 
-run().catch(<span class="hljs-built_in">console</span>.error);
-rs.resume(); <span class="hljs-comment">// Drain the stream.</span></code></pre>
+<span class="hljs-title function_">run</span>().<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);
+rs.<span class="hljs-title function_">resume</span>(); <span class="hljs-comment">// Drain the stream.</span></code></pre>
 <p><code>stream.finished()</code> leaves dangling event listeners (in particular
 <code>'error'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code>) after <code>callback</code> has been
 invoked. The reason for this is so that unexpected <code>'error'</code> events (due to
 incorrect stream implementations) do not cause unexpected crashes.
 If this is unwanted behavior then the returned cleanup function needs to be
 invoked in the callback:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> cleanup = finished(rs, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  cleanup();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> cleanup = <span class="hljs-title function_">finished</span>(rs, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-title function_">cleanup</span>();
   <span class="hljs-comment">// ...</span>
 });</code></pre>
-<h3><code>stream.pipeline(...streams, callback)</code><span><a class="mark" href="#stream_stream_pipeline_streams_callback" id="stream_stream_pipeline_streams_callback">#</a></span></h3>
+<h4><code>stream.pipeline(source[, ...transforms], destination, callback)</code><span><a class="mark" href="#stream_stream_pipeline_source_transforms_destination_callback" id="stream_stream_pipeline_source_transforms_destination_callback">#</a></span></h4>
+<h4><code>stream.pipeline(streams, callback)</code><span><a class="mark" href="#stream_stream_pipeline_streams_callback" id="stream_stream_pipeline_streams_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>pipeline(..., cb)</code> will wait for the <code>'close'</code> event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit <code>'close'</code>.</p></td></tr>
+<tr><td>v13.10.0</td>
+<td><p>Add support for async generators.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>...streams</code> <a href="#stream_stream" class="type">&#x3C;Stream></a> Two or more streams to pipe between.</li>
+<li><code>streams</code> <a href="#stream_stream" class="type">&#x3C;Stream[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable[]></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
+<li><code>source</code> <a href="#stream_stream" class="type">&#x3C;Stream></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a></li>
+</ul>
+</li>
+<li><code>...transforms</code> <a href="#stream_stream" class="type">&#x3C;Stream></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>source</code> <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a></li>
+<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a></li>
+</ul>
+</li>
+<li><code>destination</code> <a href="#stream_stream" class="type">&#x3C;Stream></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>source</code> <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a></li>
+<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called when the pipeline is fully done.
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>val</code> Resolved value of <code>Promise</code> returned by <code>destination</code>.</li>
 </ul>
 </li>
+<li>Returns: <a href="#stream_stream" class="type">&#x3C;Stream></a></li>
 </ul>
-<p>A module method to pipe between streams forwarding errors and properly cleaning
-up and provide a callback when the pipeline is complete.</p>
+<p>A module method to pipe between streams and generators forwarding errors and
+properly cleaning up and provide a callback when the pipeline is complete.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> zlib = <span class="hljs-built_in">require</span>(<span class="hljs-string">'zlib'</span>);
@@ -53122,31 +57631,50 @@ up and provide a callback when the pipeline is complete.</p>
 
 <span class="hljs-comment">// A pipeline to gzip a potentially huge tar file efficiently:</span>
 
-pipeline(
-  fs.createReadStream(<span class="hljs-string">'archive.tar'</span>),
-  zlib.createGzip(),
-  fs.createWriteStream(<span class="hljs-string">'archive.tar.gz'</span>),
+<span class="hljs-title function_">pipeline</span>(
+  fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'archive.tar'</span>),
+  zlib.<span class="hljs-title function_">createGzip</span>(),
+  fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'archive.tar.gz'</span>),
   <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Pipeline failed.'</span>, err);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Pipeline failed.'</span>, err);
     } <span class="hljs-keyword">else</span> {
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Pipeline succeeded.'</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Pipeline succeeded.'</span>);
     }
   }
 );</code></pre>
 <p>The <code>pipeline</code> API is promisify-able as well:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> pipeline = util.promisify(stream.pipeline);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> pipeline = util.<span class="hljs-title function_">promisify</span>(stream.<span class="hljs-property">pipeline</span>);
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">run</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">pipeline</span>(
+    fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'archive.tar'</span>),
+    zlib.<span class="hljs-title function_">createGzip</span>(),
+    fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'archive.tar.gz'</span>)
+  );
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Pipeline succeeded.'</span>);
+}
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">run</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> pipeline(
-    fs.createReadStream(<span class="hljs-string">'archive.tar'</span>),
-    zlib.createGzip(),
-    fs.createWriteStream(<span class="hljs-string">'archive.tar.gz'</span>)
+<span class="hljs-title function_">run</span>().<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);</code></pre>
+<p>The <code>pipeline</code> API also supports async generators:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> pipeline = util.<span class="hljs-title function_">promisify</span>(stream.<span class="hljs-property">pipeline</span>);
+<span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">run</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">pipeline</span>(
+    fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'lowercase.txt'</span>),
+    <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>* (source) {
+      source.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);  <span class="hljs-comment">// Work with strings rather than `Buffer`s.</span>
+      <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> chunk <span class="hljs-keyword">of</span> source) {
+        <span class="hljs-keyword">yield</span> chunk.<span class="hljs-title function_">toUpperCase</span>();
+      }
+    },
+    fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'uppercase.txt'</span>)
   );
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Pipeline succeeded.'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Pipeline succeeded.'</span>);
 }
 
-run().catch(<span class="hljs-built_in">console</span>.error);</code></pre>
+<span class="hljs-title function_">run</span>().<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);</code></pre>
 <p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>
 <ul>
 <li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>
@@ -53155,7 +57683,7 @@ run().catch(<span class="hljs-built_in">console</span>.error);</code></pre>
 <p><code>stream.pipeline()</code> leaves dangling event listeners on the streams
 after the <code>callback</code> has been invoked. In the case of reuse of streams after
 failure, this can cause event listener leaks and swallowed errors.</p>
-<h3><code>stream.Readable.from(iterable, [options])</code><span><a class="mark" href="#stream_stream_readable_from_iterable_options" id="stream_stream_readable_from_iterable_options">#</a></span></h3>
+<h4><code>stream.Readable.from(iterable, [options])</code><span><a class="mark" href="#stream_stream_readable_from_iterable_options" id="stream_stream_readable_from_iterable_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.3.0, v10.17.0</span>
 </div>
@@ -53169,22 +57697,22 @@ this is explicitly opted out by setting <code>options.objectMode</code> to <code
 <li>Returns: <a href="#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a></li>
 </ul>
 <p>A utility method for creating readable streams out of iterators.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> * <span class="hljs-title">generate</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> * <span class="hljs-title function_">generate</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'hello'</span>;
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'streams'</span>;
 }
 
-<span class="hljs-keyword">const</span> readable = Readable.from(generate());
+<span class="hljs-keyword">const</span> readable = <span class="hljs-title class_">Readable</span>.<span class="hljs-title function_">from</span>(<span class="hljs-title function_">generate</span>());
 
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(chunk);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk);
 });</code></pre>
 <p>Calling <code>Readable.from(string)</code> or <code>Readable.from(buffer)</code> will not have
 the strings or buffers be iterated to match the other streams semantics
 for performance reasons.</p>
-<h2>API for stream implementers<span><a class="mark" href="#stream_api_for_stream_implementers" id="stream_api_for_stream_implementers">#</a></span></h2>
+</section><section><h3>API for stream implementers<span><a class="mark" href="#stream_api_for_stream_implementers" id="stream_api_for_stream_implementers">#</a></span></h3>
 
 <p>The <code>stream</code> module API has been designed to make it possible to easily
 implement streams using JavaScript's prototypal inheritance model.</p>
@@ -53193,15 +57721,11 @@ of the four basic stream classes (<code>stream.Writable</code>, <code>stream.Rea
 <code>stream.Duplex</code>, or <code>stream.Transform</code>), making sure they call the appropriate
 parent class constructor:</p>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Writable</span> </span>{
-  <span class="hljs-keyword">constructor</span>({ highWaterMark, ...options }) {
-    <span class="hljs-built_in">super</span>({
-      highWaterMark,
-      <span class="hljs-attr">autoDestroy</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">emitClose</span>: <span class="hljs-literal">true</span>
-    });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Writable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">{ highWaterMark, ...options }</span>) {
+    <span class="hljs-variable language_">super</span>({ highWaterMark });
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
@@ -53254,7 +57778,7 @@ as <code>'error'</code>, <code>'data'</code>, <code>'end'</code>, <code>'finish'
 Doing so can break current and future stream invariants leading to behavior
 and/or compatibility issues with other streams, stream utilities, and user
 expectations.</p>
-<h3>Simplified construction<span><a class="mark" href="#stream_simplified_construction" id="stream_simplified_construction">#</a></span></h3>
+<h4>Simplified construction<span><a class="mark" href="#stream_simplified_construction" id="stream_simplified_construction">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.2.0</span>
 </div>
@@ -53262,24 +57786,26 @@ expectations.</p>
 inheritance. This can be accomplished by directly creating instances of the
 <code>stream.Writable</code>, <code>stream.Readable</code>, <code>stream.Duplex</code> or <code>stream.Transform</code>
 objects and passing appropriate methods as constructor options.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> Writable({
-  write(chunk, encoding, callback) {
+<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>({
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h3>Implementing a writable stream<span><a class="mark" href="#stream_implementing_a_writable_stream" id="stream_implementing_a_writable_stream">#</a></span></h3>
+<h4>Implementing a writable stream<span><a class="mark" href="#stream_implementing_a_writable_stream" id="stream_implementing_a_writable_stream">#</a></span></h4>
 <p>The <code>stream.Writable</code> class is extended to implement a <a href="#stream_class_stream_writable"><code>Writable</code></a> stream.</p>
 <p>Custom <code>Writable</code> streams <em>must</em> call the <code>new stream.Writable([options])</code>
 constructor and implement the <code>writable._write()</code> and/or <code>writable._writev()</code>
 method.</p>
-<h4><code>new stream.Writable([options])</code><span><a class="mark" href="#stream_new_stream_writable_options" id="stream_new_stream_writable_options">#</a></span></h4>
+<h5><code>new stream.Writable([options])</code><span><a class="mark" href="#stream_new_stream_writable_options" id="stream_new_stream_writable_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.2.0</td>
+<tr><td>v14.0.0</td>
+<td><p>Change <code>autoDestroy</code> option default to <code>true</code>.</p></td></tr>
+<tr><td>v11.2.0, v10.16.0</td>
 <td><p>Add <code>autoDestroy</code> option to automatically <code>destroy()</code> the stream when it emits <code>'finish'</code> or errors.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Add <code>emitClose</code> option to specify if <code>'close'</code> is emitted on destroy.</p></td></tr>
@@ -53317,42 +57843,42 @@ after it has been destroyed. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>final</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Implementation for the
 <a href="#stream_writable_final_callback"><code>stream._final()</code></a> method.</li>
 <li><code>autoDestroy</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether this stream should automatically call
-<code>.destroy()</code> on itself after ending. <strong>Default:</strong> <code>false</code>.</li>
+<code>.destroy()</code> on itself after ending. <strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
 </ul>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Writable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Writable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
     <span class="hljs-comment">// Calls the stream.Writable() constructor.</span>
-    <span class="hljs-built_in">super</span>(options);
+    <span class="hljs-variable language_">super</span>(options);
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
 <p>Or, when using pre-ES6 style constructors:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyWritable</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-keyword">if</span> (!(<span class="hljs-built_in">this</span> <span class="hljs-keyword">instanceof</span> MyWritable))
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> MyWritable(options);
-  Writable.call(<span class="hljs-built_in">this</span>, options);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyWritable</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MyWritable</span>))
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyWritable</span>(options);
+  <span class="hljs-title class_">Writable</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, options);
 }
-util.inherits(MyWritable, Writable);</code></pre>
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyWritable</span>, <span class="hljs-title class_">Writable</span>);</code></pre>
 <p>Or, using the simplified constructor approach:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> Writable({
-  write(chunk, encoding, callback) {
+<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>({
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// ...</span>
   },
-  writev(chunks, callback) {
+  <span class="hljs-title function_">writev</span>(<span class="hljs-params">chunks, callback</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h4><code>writable._write(chunk, encoding, callback)</code><span><a class="mark" href="#stream_writable_write_chunk_encoding_callback_1" id="stream_writable_write_chunk_encoding_callback_1">#</a></span></h4>
+<h5><code>writable._write(chunk, encoding, callback)</code><span><a class="mark" href="#stream_writable_write_chunk_encoding_callback_1" id="stream_writable_write_chunk_encoding_callback_1">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -53383,10 +57909,11 @@ resource.</p>
 <p>This function MUST NOT be called by application code directly. It should be
 implemented by child classes, and called by the internal <code>Writable</code> class
 methods only.</p>
-<p>The <code>callback</code> method must be called to signal either that the write completed
-successfully or failed with an error. The first argument passed to the
-<code>callback</code> must be the <code>Error</code> object if the call failed or <code>null</code> if the
-write succeeded.</p>
+<p>The <code>callback</code> function must be called synchronously inside of
+<code>writable._write()</code> or asynchronously (i.e. different tick) to signal either
+that the write completed successfully or failed with an error.
+The first argument passed to the <code>callback</code> must be the <code>Error</code> object if the
+call failed or <code>null</code> if the write succeeded.</p>
 <p>All calls to <code>writable.write()</code> that occur between the time <code>writable._write()</code>
 is called and the <code>callback</code> is called will cause the written data to be
 buffered. When the <code>callback</code> is invoked, the stream might emit a <a href="#stream_event_drain"><code>'drain'</code></a>
@@ -53401,10 +57928,19 @@ Otherwise, the <code>encoding</code> argument can be safely ignored.</p>
 <p>The <code>writable._write()</code> method is prefixed with an underscore because it is
 internal to the class that defines it, and should never be called directly by
 user programs.</p>
-<h4><code>writable._writev(chunks, callback)</code><span><a class="mark" href="#stream_writable_writev_chunks_callback" id="stream_writable_writev_chunks_callback">#</a></span></h4>
+<h5><code>writable._writev(chunks, callback)</code><span><a class="mark" href="#stream_writable_writev_chunks_callback" id="stream_writable_writev_chunks_callback">#</a></span></h5>
+<ul>
+<li><code>chunks</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object[]></a> The data to be written. The value is an array of <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+that each represent a discrete chunk of data to write. The properties of
+these objects are:
 <ul>
-<li><code>chunks</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object[]></a> The chunks to be written. Each chunk has following
-format: <code>{ chunk: ..., encoding: ... }</code>.</li>
+<li><code>chunk</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A buffer instance or string containing the data to
+be written. The <code>chunk</code> will be a string if the <code>Writable</code> was created with
+the <code>decodeStrings</code> option set to <code>false</code> and a string was passed to <code>write()</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The character encoding of the <code>chunk</code>. If <code>chunk</code> is
+a <code>Buffer</code>, the <code>encoding</code> will be <code>'buffer'</code>.</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> A callback function (optionally with an error
 argument) to be invoked when processing is complete for the supplied chunks.</li>
 </ul>
@@ -53418,7 +57954,7 @@ from previous writes, <code>_writev()</code> will be called instead of <code>_wr
 <p>The <code>writable._writev()</code> method is prefixed with an underscore because it is
 internal to the class that defines it, and should never be called directly by
 user programs.</p>
-<h4><code>writable._destroy(err, callback)</code><span><a class="mark" href="#stream_writable_destroy_err_callback" id="stream_writable_destroy_err_callback">#</a></span></h4>
+<h5><code>writable._destroy(err, callback)</code><span><a class="mark" href="#stream_writable_destroy_err_callback" id="stream_writable_destroy_err_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -53429,7 +57965,7 @@ argument.</li>
 </ul>
 <p>The <code>_destroy()</code> method is called by <a href="#stream_writable_destroy_error"><code>writable.destroy()</code></a>.
 It can be overridden by child classes but it <strong>must not</strong> be called directly.</p>
-<h4><code>writable._final(callback)</code><span><a class="mark" href="#stream_writable_final_callback" id="stream_writable_final_callback">#</a></span></h4>
+<h5><code>writable._final(callback)</code><span><a class="mark" href="#stream_writable_final_callback" id="stream_writable_final_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -53443,7 +57979,7 @@ class methods only.</p>
 <p>This optional function will be called before the stream closes, delaying the
 <code>'finish'</code> event until <code>callback</code> is called. This is useful to close resources
 or write buffered data before a stream ends.</p>
-<h4>Errors while writing<span><a class="mark" href="#stream_errors_while_writing" id="stream_errors_while_writing">#</a></span></h4>
+<h5>Errors while writing<span><a class="mark" href="#stream_errors_while_writing" id="stream_errors_while_writing">#</a></span></h5>
 <p>Errors occurring during the processing of the <a href="#stream_writable_write_chunk_encoding_callback_1"><code>writable._write()</code></a>,
 <a href="#stream_writable_writev_chunks_callback"><code>writable._writev()</code></a> and <a href="#stream_writable_final_callback"><code>writable._final()</code></a> methods must be propagated
 by invoking the callback and passing the error as the first argument.
@@ -53451,78 +57987,80 @@ Throwing an <code>Error</code> from within these methods or manually emitting an
 event results in undefined behavior.</p>
 <p>If a <code>Readable</code> stream pipes into a <code>Writable</code> stream when <code>Writable</code> emits an
 error, the <code>Readable</code> stream will be unpiped.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> Writable({
-  write(chunk, encoding, callback) {
-    <span class="hljs-keyword">if</span> (chunk.toString().indexOf(<span class="hljs-string">'a'</span>) >= <span class="hljs-number">0</span>) {
-      callback(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'chunk is invalid'</span>));
+<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>({
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
+    <span class="hljs-keyword">if</span> (chunk.<span class="hljs-title function_">toString</span>().<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'a'</span>) >= <span class="hljs-number">0</span>) {
+      <span class="hljs-title function_">callback</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'chunk is invalid'</span>));
     } <span class="hljs-keyword">else</span> {
-      callback();
+      <span class="hljs-title function_">callback</span>();
     }
   }
 });</code></pre>
-<h4>An example writable stream<span><a class="mark" href="#stream_an_example_writable_stream" id="stream_an_example_writable_stream">#</a></span></h4>
+<h5>An example writable stream<span><a class="mark" href="#stream_an_example_writable_stream" id="stream_an_example_writable_stream">#</a></span></h5>
 <p>The following illustrates a rather simplistic (and somewhat pointless) custom
 <code>Writable</code> stream implementation. While this specific <code>Writable</code> stream instance
 is not of any real particular usefulness, the example illustrates each of the
 required elements of a custom <a href="#stream_class_stream_writable"><code>Writable</code></a> stream instance:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Writable</span> </span>{
-  _write(chunk, encoding, callback) {
-    <span class="hljs-keyword">if</span> (chunk.toString().indexOf(<span class="hljs-string">'a'</span>) >= <span class="hljs-number">0</span>) {
-      callback(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'chunk is invalid'</span>));
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Writable</span> {
+  <span class="hljs-title function_">_write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
+    <span class="hljs-keyword">if</span> (chunk.<span class="hljs-title function_">toString</span>().<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'a'</span>) >= <span class="hljs-number">0</span>) {
+      <span class="hljs-title function_">callback</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'chunk is invalid'</span>));
     } <span class="hljs-keyword">else</span> {
-      callback();
+      <span class="hljs-title function_">callback</span>();
     }
   }
 }</code></pre>
-<h4>Decoding buffers in a writable stream<span><a class="mark" href="#stream_decoding_buffers_in_a_writable_stream" id="stream_decoding_buffers_in_a_writable_stream">#</a></span></h4>
+<h5>Decoding buffers in a writable stream<span><a class="mark" href="#stream_decoding_buffers_in_a_writable_stream" id="stream_decoding_buffers_in_a_writable_stream">#</a></span></h5>
 <p>Decoding buffers is a common task, for instance, when using transformers whose
 input is a string. This is not a trivial process when using multi-byte
 characters encoding, such as UTF-8. The following example shows how to decode
 multi-byte strings using <code>StringDecoder</code> and <a href="#stream_class_stream_writable"><code>Writable</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-<span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
-
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">StringWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Writable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
-    <span class="hljs-built_in">super</span>(options);
-    <span class="hljs-built_in">this</span>._decoder = <span class="hljs-keyword">new</span> StringDecoder(options &#x26;&#x26; options.defaultEncoding);
-    <span class="hljs-built_in">this</span>.data = <span class="hljs-string">''</span>;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
+
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">StringWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Writable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_decoder</span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringDecoder</span>(options &#x26;&#x26; options.<span class="hljs-property">defaultEncoding</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">data</span> = <span class="hljs-string">''</span>;
   }
-  _write(chunk, encoding, callback) {
+  <span class="hljs-title function_">_write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-keyword">if</span> (encoding === <span class="hljs-string">'buffer'</span>) {
-      chunk = <span class="hljs-built_in">this</span>._decoder.write(chunk);
+      chunk = <span class="hljs-variable language_">this</span>.<span class="hljs-property">_decoder</span>.<span class="hljs-title function_">write</span>(chunk);
     }
-    <span class="hljs-built_in">this</span>.data += chunk;
-    callback();
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">data</span> += chunk;
+    <span class="hljs-title function_">callback</span>();
   }
-  _final(callback) {
-    <span class="hljs-built_in">this</span>.data += <span class="hljs-built_in">this</span>._decoder.end();
-    callback();
+  <span class="hljs-title function_">_final</span>(<span class="hljs-params">callback</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">data</span> += <span class="hljs-variable language_">this</span>.<span class="hljs-property">_decoder</span>.<span class="hljs-title function_">end</span>();
+    <span class="hljs-title function_">callback</span>();
   }
 }
 
-<span class="hljs-keyword">const</span> euro = [[<span class="hljs-number">0xE2</span>, <span class="hljs-number">0x82</span>], [<span class="hljs-number">0xAC</span>]].map(Buffer.from);
-<span class="hljs-keyword">const</span> w = <span class="hljs-keyword">new</span> StringWritable();
+<span class="hljs-keyword">const</span> euro = [[<span class="hljs-number">0xE2</span>, <span class="hljs-number">0x82</span>], [<span class="hljs-number">0xAC</span>]].<span class="hljs-title function_">map</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-property">from</span>);
+<span class="hljs-keyword">const</span> w = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringWritable</span>();
 
-w.write(<span class="hljs-string">'currency: '</span>);
-w.write(euro[<span class="hljs-number">0</span>]);
-w.end(euro[<span class="hljs-number">1</span>]);
+w.<span class="hljs-title function_">write</span>(<span class="hljs-string">'currency: '</span>);
+w.<span class="hljs-title function_">write</span>(euro[<span class="hljs-number">0</span>]);
+w.<span class="hljs-title function_">end</span>(euro[<span class="hljs-number">1</span>]);
 
-<span class="hljs-built_in">console</span>.log(w.data); <span class="hljs-comment">// currency: €</span></code></pre>
-<h3>Implementing a readable stream<span><a class="mark" href="#stream_implementing_a_readable_stream" id="stream_implementing_a_readable_stream">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(w.<span class="hljs-property">data</span>); <span class="hljs-comment">// currency: €</span></code></pre>
+<h4>Implementing a readable stream<span><a class="mark" href="#stream_implementing_a_readable_stream" id="stream_implementing_a_readable_stream">#</a></span></h4>
 <p>The <code>stream.Readable</code> class is extended to implement a <a href="#stream_class_stream_readable"><code>Readable</code></a> stream.</p>
 <p>Custom <code>Readable</code> streams <em>must</em> call the <code>new stream.Readable([options])</code>
 constructor and implement the <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> method.</p>
-<h4><code>new stream.Readable([options])</code><span><a class="mark" href="#stream_new_stream_readable_options" id="stream_new_stream_readable_options">#</a></span></h4>
+<h5><code>new stream.Readable([options])</code><span><a class="mark" href="#stream_new_stream_readable_options" id="stream_new_stream_readable_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.2.0</td>
+<tr><td>v14.0.0</td>
+<td><p>Change <code>autoDestroy</code> option default to <code>true</code>.</p></td></tr>
+<tr><td>v11.2.0, v10.16.0</td>
 <td><p>Add <code>autoDestroy</code> option to automatically <code>destroy()</code> the stream when it emits <code>'end'</code> or errors.</p></td></tr>
 </tbody></table>
 </details>
@@ -53545,39 +58083,39 @@ method.</li>
 <li><code>destroy</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Implementation for the
 <a href="#stream_readable_destroy_err_callback"><code>stream._destroy()</code></a> method.</li>
 <li><code>autoDestroy</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether this stream should automatically call
-<code>.destroy()</code> on itself after ending. <strong>Default:</strong> <code>false</code>.</li>
+<code>.destroy()</code> on itself after ending. <strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
 </ul>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyReadable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Readable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyReadable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Readable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
     <span class="hljs-comment">// Calls the stream.Readable(options) constructor.</span>
-    <span class="hljs-built_in">super</span>(options);
+    <span class="hljs-variable language_">super</span>(options);
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
 <p>Or, when using pre-ES6 style constructors:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyReadable</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-keyword">if</span> (!(<span class="hljs-built_in">this</span> <span class="hljs-keyword">instanceof</span> MyReadable))
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> MyReadable(options);
-  Readable.call(<span class="hljs-built_in">this</span>, options);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyReadable</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MyReadable</span>))
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyReadable</span>(options);
+  <span class="hljs-title class_">Readable</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, options);
 }
-util.inherits(MyReadable, Readable);</code></pre>
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyReadable</span>, <span class="hljs-title class_">Readable</span>);</code></pre>
 <p>Or, using the simplified constructor approach:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myReadable = <span class="hljs-keyword">new</span> Readable({
-  read(size) {
+<span class="hljs-keyword">const</span> myReadable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Readable</span>({
+  <span class="hljs-title function_">read</span>(<span class="hljs-params">size</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h4><code>readable._read(size)</code><span><a class="mark" href="#stream_readable_read_size_1" id="stream_readable_read_size_1">#</a></span></h4>
+<h5><code>readable._read(size)</code><span><a class="mark" href="#stream_readable_read_size_1" id="stream_readable_read_size_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -53591,10 +58129,12 @@ methods only.</p>
 <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> method to fetch data from the underlying resource.</p>
 <p>When <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> is called, if data is available from the resource,
 the implementation should begin pushing that data into the read queue using the
-<a href="#stream_readable_push_chunk_encoding"><code>this.push(dataChunk)</code></a> method. <code>_read()</code> should continue reading
-from the resource and pushing data until <code>readable.push()</code> returns <code>false</code>. Only
-when <code>_read()</code> is called again after it has stopped should it resume pushing
-additional data onto the queue.</p>
+<a href="#stream_readable_push_chunk_encoding"><code>this.push(dataChunk)</code></a> method. <code>_read()</code> will be called again
+after each call to <a href="#stream_readable_push_chunk_encoding"><code>this.push(dataChunk)</code></a> once the stream is
+ready to accept more data. <code>_read()</code> may continue reading from the resource and
+pushing data until <code>readable.push()</code> returns <code>false</code>. Only when <code>_read()</code> is
+called again after it has stopped should it resume pushing additional data into
+the queue.</p>
 <p>Once the <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> method has been called, it will not be called
 again until more data is pushed through the <a href="#stream_readable_push_chunk_encoding"><code>readable.push()</code></a>
 method. Empty data such as empty buffers and strings will not cause
@@ -53607,7 +58147,7 @@ provide data whenever it becomes available. There is no need to "wait" until
 <p>The <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> method is prefixed with an underscore because it is
 internal to the class that defines it, and should never be called directly by
 user programs.</p>
-<h4><code>readable._destroy(err, callback)</code><span><a class="mark" href="#stream_readable_destroy_err_callback" id="stream_readable_destroy_err_callback">#</a></span></h4>
+<h5><code>readable._destroy(err, callback)</code><span><a class="mark" href="#stream_readable_destroy_err_callback" id="stream_readable_destroy_err_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -53618,7 +58158,7 @@ argument.</li>
 </ul>
 <p>The <code>_destroy()</code> method is called by <a href="#stream_readable_destroy_error"><code>readable.destroy()</code></a>.
 It can be overridden by child classes but it <strong>must not</strong> be called directly.</p>
-<h4><code>readable.push(chunk[, encoding])</code><span><a class="mark" href="#stream_readable_push_chunk_encoding" id="stream_readable_push_chunk_encoding">#</a></span></h4>
+<h5><code>readable.push(chunk[, encoding])</code><span><a class="mark" href="#stream_readable_push_chunk_encoding" id="stream_readable_push_chunk_encoding">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -53656,28 +58196,28 @@ by the custom <code>Readable</code> instance:</p>
 <span class="hljs-comment">// and an `ondata` member that gets called when it has data, and</span>
 <span class="hljs-comment">// an `onend` member that gets called when the data is over.</span>
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">SourceWrapper</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Readable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
-    <span class="hljs-built_in">super</span>(options);
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">SourceWrapper</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Readable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
 
-    <span class="hljs-built_in">this</span>._source = getLowLevelSourceObject();
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span> = <span class="hljs-title function_">getLowLevelSourceObject</span>();
 
     <span class="hljs-comment">// Every time there's data, push it into the internal buffer.</span>
-    <span class="hljs-built_in">this</span>._source.ondata = <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span>.<span class="hljs-property">ondata</span> = <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
       <span class="hljs-comment">// If push() returns false, then stop reading from source.</span>
-      <span class="hljs-keyword">if</span> (!<span class="hljs-built_in">this</span>.push(chunk))
-        <span class="hljs-built_in">this</span>._source.readStop();
+      <span class="hljs-keyword">if</span> (!<span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(chunk))
+        <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span>.<span class="hljs-title function_">readStop</span>();
     };
 
     <span class="hljs-comment">// When the source ends, push the EOF-signaling `null` chunk.</span>
-    <span class="hljs-built_in">this</span>._source.onend = <span class="hljs-function">() =></span> {
-      <span class="hljs-built_in">this</span>.push(<span class="hljs-literal">null</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span>.<span class="hljs-property">onend</span> = <span class="hljs-function">() =></span> {
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(<span class="hljs-literal">null</span>);
     };
   }
   <span class="hljs-comment">// _read() will be called when the stream wants to pull more data in.</span>
   <span class="hljs-comment">// The advisory size argument is ignored in this case.</span>
-  _read(size) {
-    <span class="hljs-built_in">this</span>._source.readStart();
+  <span class="hljs-title function_">_read</span>(<span class="hljs-params">size</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span>.<span class="hljs-title function_">readStart</span>();
   }
 }</code></pre>
 <p>The <code>readable.push()</code> method is used to push the content
@@ -53685,48 +58225,48 @@ into the internal buffer. It can be driven by the <a href="#stream_readable_read
 <p>For streams not operating in object mode, if the <code>chunk</code> parameter of
 <code>readable.push()</code> is <code>undefined</code>, it will be treated as empty string or
 buffer. See <a href="#stream_readable_push"><code>readable.push('')</code></a> for more information.</p>
-<h4>Errors while reading<span><a class="mark" href="#stream_errors_while_reading" id="stream_errors_while_reading">#</a></span></h4>
+<h5>Errors while reading<span><a class="mark" href="#stream_errors_while_reading" id="stream_errors_while_reading">#</a></span></h5>
 <p>Errors occurring during processing of the <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> must be
 propagated through the <a href="#stream_readable_destroy_err_callback"><code>readable.destroy(err)</code></a> method.
 Throwing an <code>Error</code> from within <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> or manually emitting an
 <code>'error'</code> event results in undefined behavior.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myReadable = <span class="hljs-keyword">new</span> Readable({
-  read(size) {
-    <span class="hljs-keyword">const</span> err = checkSomeErrorCondition();
+<span class="hljs-keyword">const</span> myReadable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Readable</span>({
+  <span class="hljs-title function_">read</span>(<span class="hljs-params">size</span>) {
+    <span class="hljs-keyword">const</span> err = <span class="hljs-title function_">checkSomeErrorCondition</span>();
     <span class="hljs-keyword">if</span> (err) {
-      <span class="hljs-built_in">this</span>.destroy(err);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">destroy</span>(err);
     } <span class="hljs-keyword">else</span> {
       <span class="hljs-comment">// Do some work.</span>
     }
   }
 });</code></pre>
-<h4>An example counting stream<span><a class="mark" href="#stream_an_example_counting_stream" id="stream_an_example_counting_stream">#</a></span></h4>
+<h5>An example counting stream<span><a class="mark" href="#stream_an_example_counting_stream" id="stream_an_example_counting_stream">#</a></span></h5>
 
 <p>The following is a basic example of a <code>Readable</code> stream that emits the numerals
 from 1 to 1,000,000 in ascending order, and then ends.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Counter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Readable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(opt) {
-    <span class="hljs-built_in">super</span>(opt);
-    <span class="hljs-built_in">this</span>._max = <span class="hljs-number">1000000</span>;
-    <span class="hljs-built_in">this</span>._index = <span class="hljs-number">1</span>;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Counter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Readable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">opt</span>) {
+    <span class="hljs-variable language_">super</span>(opt);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_max</span> = <span class="hljs-number">1000000</span>;
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_index</span> = <span class="hljs-number">1</span>;
   }
 
-  _read() {
-    <span class="hljs-keyword">const</span> i = <span class="hljs-built_in">this</span>._index++;
-    <span class="hljs-keyword">if</span> (i > <span class="hljs-built_in">this</span>._max)
-      <span class="hljs-built_in">this</span>.push(<span class="hljs-literal">null</span>);
+  <span class="hljs-title function_">_read</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">const</span> i = <span class="hljs-variable language_">this</span>.<span class="hljs-property">_index</span>++;
+    <span class="hljs-keyword">if</span> (i > <span class="hljs-variable language_">this</span>.<span class="hljs-property">_max</span>)
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(<span class="hljs-literal">null</span>);
     <span class="hljs-keyword">else</span> {
-      <span class="hljs-keyword">const</span> str = <span class="hljs-built_in">String</span>(i);
-      <span class="hljs-keyword">const</span> buf = Buffer.from(str, <span class="hljs-string">'ascii'</span>);
-      <span class="hljs-built_in">this</span>.push(buf);
+      <span class="hljs-keyword">const</span> str = <span class="hljs-title class_">String</span>(i);
+      <span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(str, <span class="hljs-string">'ascii'</span>);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(buf);
     }
   }
 }</code></pre>
-<h3>Implementing a duplex stream<span><a class="mark" href="#stream_implementing_a_duplex_stream" id="stream_implementing_a_duplex_stream">#</a></span></h3>
+<h4>Implementing a duplex stream<span><a class="mark" href="#stream_implementing_a_duplex_stream" id="stream_implementing_a_duplex_stream">#</a></span></h4>
 <p>A <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream is one that implements both <a href="#stream_class_stream_readable"><code>Readable</code></a> and
 <a href="#stream_class_stream_writable"><code>Writable</code></a>, such as a TCP socket connection.</p>
 <p>Because JavaScript does not have support for multiple inheritance, the
@@ -53739,7 +58279,7 @@ both base classes due to overriding <a href="https://developer.mozilla.org/en-US
 <p>Custom <code>Duplex</code> streams <em>must</em> call the <code>new stream.Duplex([options])</code>
 constructor and implement <em>both</em> the <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> and
 <code>writable._write()</code> methods.</p>
-<h4><code>new stream.Duplex(options)</code><span><a class="mark" href="#stream_new_stream_duplex_options" id="stream_new_stream_duplex_options">#</a></span></h4>
+<h5><code>new stream.Duplex(options)</code><span><a class="mark" href="#stream_new_stream_duplex_options" id="stream_new_stream_duplex_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -53772,36 +58312,36 @@ of the stream. Has no effect if <code>highWaterMark</code> is provided.</li>
 </li>
 </ul>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Duplex } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Duplex</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyDuplex</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Duplex</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
-    <span class="hljs-built_in">super</span>(options);
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyDuplex</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Duplex</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
 <p>Or, when using pre-ES6 style constructors:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Duplex } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Duplex</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyDuplex</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-keyword">if</span> (!(<span class="hljs-built_in">this</span> <span class="hljs-keyword">instanceof</span> MyDuplex))
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> MyDuplex(options);
-  Duplex.call(<span class="hljs-built_in">this</span>, options);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyDuplex</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MyDuplex</span>))
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyDuplex</span>(options);
+  <span class="hljs-title class_">Duplex</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, options);
 }
-util.inherits(MyDuplex, Duplex);</code></pre>
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyDuplex</span>, <span class="hljs-title class_">Duplex</span>);</code></pre>
 <p>Or, using the simplified constructor approach:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Duplex } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Duplex</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myDuplex = <span class="hljs-keyword">new</span> Duplex({
-  read(size) {
+<span class="hljs-keyword">const</span> myDuplex = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Duplex</span>({
+  <span class="hljs-title function_">read</span>(<span class="hljs-params">size</span>) {
     <span class="hljs-comment">// ...</span>
   },
-  write(chunk, encoding, callback) {
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h4>An example duplex stream<span><a class="mark" href="#stream_an_example_duplex_stream" id="stream_an_example_duplex_stream">#</a></span></h4>
+<h5>An example duplex stream<span><a class="mark" href="#stream_an_example_duplex_stream" id="stream_an_example_duplex_stream">#</a></span></h5>
 <p>The following illustrates a simple example of a <code>Duplex</code> stream that wraps a
 hypothetical lower-level source object to which data can be written, and
 from which data can be read, albeit using an API that is not compatible with
@@ -53809,33 +58349,33 @@ Node.js streams.
 The following illustrates a simple example of a <code>Duplex</code> stream that buffers
 incoming written data via the <a href="#stream_class_stream_writable"><code>Writable</code></a> interface that is read back out
 via the <a href="#stream_class_stream_readable"><code>Readable</code></a> interface.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Duplex } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-<span class="hljs-keyword">const</span> kSource = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'source'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Duplex</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> kSource = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'source'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyDuplex</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Duplex</span> </span>{
-  <span class="hljs-keyword">constructor</span>(source, options) {
-    <span class="hljs-built_in">super</span>(options);
-    <span class="hljs-built_in">this</span>[kSource] = source;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyDuplex</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Duplex</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">source, options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
+    <span class="hljs-variable language_">this</span>[kSource] = source;
   }
 
-  _write(chunk, encoding, callback) {
+  <span class="hljs-title function_">_write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// The underlying source only deals with strings.</span>
-    <span class="hljs-keyword">if</span> (Buffer.isBuffer(chunk))
-      chunk = chunk.toString();
-    <span class="hljs-built_in">this</span>[kSource].writeSomeData(chunk);
-    callback();
+    <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(chunk))
+      chunk = chunk.<span class="hljs-title function_">toString</span>();
+    <span class="hljs-variable language_">this</span>[kSource].<span class="hljs-title function_">writeSomeData</span>(chunk);
+    <span class="hljs-title function_">callback</span>();
   }
 
-  _read(size) {
-    <span class="hljs-built_in">this</span>[kSource].fetchSomeData(size, <span class="hljs-function">(<span class="hljs-params">data, encoding</span>) =></span> {
-      <span class="hljs-built_in">this</span>.push(Buffer.from(data, encoding));
+  <span class="hljs-title function_">_read</span>(<span class="hljs-params">size</span>) {
+    <span class="hljs-variable language_">this</span>[kSource].<span class="hljs-title function_">fetchSomeData</span>(size, <span class="hljs-function">(<span class="hljs-params">data, encoding</span>) =></span> {
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(data, encoding));
     });
   }
 }</code></pre>
 <p>The most important aspect of a <code>Duplex</code> stream is that the <code>Readable</code> and
 <code>Writable</code> sides operate independently of one another despite co-existing within
 a single object instance.</p>
-<h4>Object mode duplex streams<span><a class="mark" href="#stream_object_mode_duplex_streams" id="stream_object_mode_duplex_streams">#</a></span></h4>
+<h5>Object mode duplex streams<span><a class="mark" href="#stream_object_mode_duplex_streams" id="stream_object_mode_duplex_streams">#</a></span></h5>
 <p>For <code>Duplex</code> streams, <code>objectMode</code> can be set exclusively for either the
 <code>Readable</code> or <code>Writable</code> side using the <code>readableObjectMode</code> and
 <code>writableObjectMode</code> options respectively.</p>
@@ -53843,34 +58383,34 @@ a single object instance.</p>
 type of <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream) is created that has an object mode <code>Writable</code> side
 that accepts JavaScript numbers that are converted to hexadecimal strings on
 the <code>Readable</code> side.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Transform } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Transform</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
 <span class="hljs-comment">// All Transform streams are also Duplex Streams.</span>
-<span class="hljs-keyword">const</span> myTransform = <span class="hljs-keyword">new</span> Transform({
+<span class="hljs-keyword">const</span> myTransform = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Transform</span>({
   <span class="hljs-attr">writableObjectMode</span>: <span class="hljs-literal">true</span>,
 
-  transform(chunk, encoding, callback) {
+  <span class="hljs-title function_">transform</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// Coerce the chunk to a number if necessary.</span>
     chunk |= <span class="hljs-number">0</span>;
 
     <span class="hljs-comment">// Transform the chunk into something else.</span>
-    <span class="hljs-keyword">const</span> data = chunk.toString(<span class="hljs-number">16</span>);
+    <span class="hljs-keyword">const</span> data = chunk.<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>);
 
     <span class="hljs-comment">// Push the data onto the readable queue.</span>
-    callback(<span class="hljs-literal">null</span>, <span class="hljs-string">'0'</span>.repeat(data.length % <span class="hljs-number">2</span>) + data);
+    <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, <span class="hljs-string">'0'</span>.<span class="hljs-title function_">repeat</span>(data.<span class="hljs-property">length</span> % <span class="hljs-number">2</span>) + data);
   }
 });
 
-myTransform.setEncoding(<span class="hljs-string">'ascii'</span>);
-myTransform.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> <span class="hljs-built_in">console</span>.log(chunk));
+myTransform.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'ascii'</span>);
+myTransform.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk));
 
-myTransform.write(<span class="hljs-number">1</span>);
+myTransform.<span class="hljs-title function_">write</span>(<span class="hljs-number">1</span>);
 <span class="hljs-comment">// Prints: 01</span>
-myTransform.write(<span class="hljs-number">10</span>);
+myTransform.<span class="hljs-title function_">write</span>(<span class="hljs-number">10</span>);
 <span class="hljs-comment">// Prints: 0a</span>
-myTransform.write(<span class="hljs-number">100</span>);
+myTransform.<span class="hljs-title function_">write</span>(<span class="hljs-number">100</span>);
 <span class="hljs-comment">// Prints: 64</span></code></pre>
-<h3>Implementing a transform stream<span><a class="mark" href="#stream_implementing_a_transform_stream" id="stream_implementing_a_transform_stream">#</a></span></h3>
+<h4>Implementing a transform stream<span><a class="mark" href="#stream_implementing_a_transform_stream" id="stream_implementing_a_transform_stream">#</a></span></h4>
 <p>A <a href="#stream_class_stream_transform"><code>Transform</code></a> stream is a <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream where the output is computed
 in some way from the input. Examples include <a href="zlib.html">zlib</a> streams or <a href="crypto.html">crypto</a>
 streams that compress, encrypt, or decrypt data.</p>
@@ -53888,7 +58428,7 @@ also implement the <a href="#stream_transform_flush_callback"><code>transform._f
 <p>Care must be taken when using <code>Transform</code> streams in that data written to the
 stream can cause the <code>Writable</code> side of the stream to become paused if the
 output on the <code>Readable</code> side is not consumed.</p>
-<h4><code>new stream.Transform([options])</code><span><a class="mark" href="#stream_new_stream_transform_options" id="stream_new_stream_transform_options">#</a></span></h4>
+<h5><code>new stream.Transform([options])</code><span><a class="mark" href="#stream_new_stream_transform_options" id="stream_new_stream_transform_options">#</a></span></h5>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Passed to both <code>Writable</code> and <code>Readable</code>
 constructors. Also has the following fields:
@@ -53901,40 +58441,43 @@ method.</li>
 </li>
 </ul>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Transform } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Transform</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyTransform</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Transform</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
-    <span class="hljs-built_in">super</span>(options);
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyTransform</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Transform</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
 <p>Or, when using pre-ES6 style constructors:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Transform } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Transform</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyTransform</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-keyword">if</span> (!(<span class="hljs-built_in">this</span> <span class="hljs-keyword">instanceof</span> MyTransform))
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> MyTransform(options);
-  Transform.call(<span class="hljs-built_in">this</span>, options);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyTransform</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MyTransform</span>))
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyTransform</span>(options);
+  <span class="hljs-title class_">Transform</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, options);
 }
-util.inherits(MyTransform, Transform);</code></pre>
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyTransform</span>, <span class="hljs-title class_">Transform</span>);</code></pre>
 <p>Or, using the simplified constructor approach:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Transform } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Transform</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myTransform = <span class="hljs-keyword">new</span> Transform({
-  transform(chunk, encoding, callback) {
+<span class="hljs-keyword">const</span> myTransform = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Transform</span>({
+  <span class="hljs-title function_">transform</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h4>Events: <code>'finish'</code> and <code>'end'</code><span><a class="mark" href="#stream_events_finish_and_end" id="stream_events_finish_and_end">#</a></span></h4>
-<p>The <a href="#stream_event_finish"><code>'finish'</code></a> and <a href="#stream_event_end"><code>'end'</code></a> events are from the <code>stream.Writable</code>
-and <code>stream.Readable</code> classes, respectively. The <code>'finish'</code> event is emitted
-after <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> is called and all chunks have been processed
-by <a href="#stream_transform_transform_chunk_encoding_callback"><code>stream._transform()</code></a>. The <code>'end'</code> event is emitted
-after all data has been output, which occurs after the callback in
-<a href="#stream_transform_flush_callback"><code>transform._flush()</code></a> has been called.</p>
-<h4><code>transform._flush(callback)</code><span><a class="mark" href="#stream_transform_flush_callback" id="stream_transform_flush_callback">#</a></span></h4>
+<h5>Event: <code>'end'</code><span><a class="mark" href="#stream_event_end_1" id="stream_event_end_1">#</a></span></h5>
+<p>The <a href="#stream_event_end"><code>'end'</code></a> event is from the <code>stream.Readable</code> class. The <code>'end'</code> event is
+emitted after all data has been output, which occurs after the callback in
+<a href="#stream_transform_flush_callback"><code>transform._flush()</code></a> has been called. In the case of an error,
+<code>'end'</code> should not be emitted.</p>
+<h5>Event: <code>'finish'</code><span><a class="mark" href="#stream_event_finish_1" id="stream_event_finish_1">#</a></span></h5>
+<p>The <a href="#stream_event_finish"><code>'finish'</code></a> event is from the <code>stream.Writable</code> class. The <code>'finish'</code>
+event is emitted after <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> is called and all chunks
+have been processed by <a href="#stream_transform_transform_chunk_encoding_callback"><code>stream._transform()</code></a>. In the case
+of an error, <code>'finish'</code> should not be emitted.</p>
+<h5><code>transform._flush(callback)</code><span><a class="mark" href="#stream_transform_flush_callback" id="stream_transform_flush_callback">#</a></span></h5>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> A callback function (optionally with an error
 argument and data) to be called when remaining data has been flushed.</li>
@@ -53957,7 +58500,7 @@ be called when the flush operation is complete.</p>
 <p>The <code>transform._flush()</code> method is prefixed with an underscore because it is
 internal to the class that defines it, and should never be called directly by
 user programs.</p>
-<h4><code>transform._transform(chunk, encoding, callback)</code><span><a class="mark" href="#stream_transform_transform_chunk_encoding_callback" id="stream_transform_transform_chunk_encoding_callback">#</a></span></h4>
+<h5><code>transform._transform(chunk, encoding, callback)</code><span><a class="mark" href="#stream_transform_transform_chunk_encoding_callback" id="stream_transform_transform_chunk_encoding_callback">#</a></span></h5>
 <ul>
 <li><code>chunk</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The <code>Buffer</code> to be transformed, converted from
 the <code>string</code> passed to <a href="#stream_writable_write_chunk_encoding_callback"><code>stream.write()</code></a>. If the stream's
@@ -53987,13 +58530,13 @@ consumed. The first argument passed to the <code>callback</code> must be an <cod
 if an error occurred while processing the input or <code>null</code> otherwise. If a second
 argument is passed to the <code>callback</code>, it will be forwarded on to the
 <code>transform.push()</code> method. In other words, the following are equivalent:</p>
-<pre><code class="language-js">transform.prototype._transform = <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">data, encoding, callback</span>) </span>{
-  <span class="hljs-built_in">this</span>.push(data);
-  callback();
+<pre><code class="language-js">transform.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">_transform</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">data, encoding, callback</span>) {
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(data);
+  <span class="hljs-title function_">callback</span>();
 };
 
-transform.prototype._transform = <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">data, encoding, callback</span>) </span>{
-  callback(<span class="hljs-literal">null</span>, data);
+transform.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">_transform</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">data, encoding, callback</span>) {
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, data);
 };</code></pre>
 <p>The <code>transform._transform()</code> method is prefixed with an underscore because it
 is internal to the class that defines it, and should never be called directly by
@@ -54001,110 +58544,71 @@ user programs.</p>
 <p><code>transform._transform()</code> is never called in parallel; streams implement a
 queue mechanism, and to receive the next chunk, <code>callback</code> must be
 called, either synchronously or asynchronously.</p>
-<h4>Class: <code>stream.PassThrough</code><span><a class="mark" href="#stream_class_stream_passthrough" id="stream_class_stream_passthrough">#</a></span></h4>
+<h5>Class: <code>stream.PassThrough</code><span><a class="mark" href="#stream_class_stream_passthrough" id="stream_class_stream_passthrough">#</a></span></h5>
 <p>The <code>stream.PassThrough</code> class is a trivial implementation of a <a href="#stream_class_stream_transform"><code>Transform</code></a>
 stream that simply passes the input bytes across to the output. Its purpose is
 primarily for examples and testing, but there are some use cases where
 <code>stream.PassThrough</code> is useful as a building block for novel sorts of streams.</p>
-<h2>Additional notes<span><a class="mark" href="#stream_additional_notes" id="stream_additional_notes">#</a></span></h2>
+</section><section><h3>Additional notes<span><a class="mark" href="#stream_additional_notes" id="stream_additional_notes">#</a></span></h3>
 
-<h3>Streams compatibility with async generators and async iterators<span><a class="mark" href="#stream_streams_compatibility_with_async_generators_and_async_iterators" id="stream_streams_compatibility_with_async_generators_and_async_iterators">#</a></span></h3>
+<h4>Streams compatibility with async generators and async iterators<span><a class="mark" href="#stream_streams_compatibility_with_async_generators_and_async_iterators" id="stream_streams_compatibility_with_async_generators_and_async_iterators">#</a></span></h4>
 <p>With the support of async generators and iterators in JavaScript, async
 generators are effectively a first-class language-level stream construct at
 this point.</p>
 <p>Some common interop cases of using Node.js streams with async generators
 and async iterators are provided below.</p>
-<h4>Consuming readable streams with async iterators<span><a class="mark" href="#stream_consuming_readable_streams_with_async_iterators" id="stream_consuming_readable_streams_with_async_iterators">#</a></span></h4>
-<pre><code class="language-js">(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
+<h5>Consuming readable streams with async iterators<span><a class="mark" href="#stream_consuming_readable_streams_with_async_iterators" id="stream_consuming_readable_streams_with_async_iterators">#</a></span></h5>
+<pre><code class="language-js">(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> chunk <span class="hljs-keyword">of</span> readable) {
-    <span class="hljs-built_in">console</span>.log(chunk);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk);
   }
 })();</code></pre>
 <p>Async iterators register a permanent error handler on the stream to prevent any
 unhandled post-destroy errors.</p>
-<h4>Creating readable streams with async generators<span><a class="mark" href="#stream_creating_readable_streams_with_async_generators" id="stream_creating_readable_streams_with_async_generators">#</a></span></h4>
+<h5>Creating readable streams with async generators<span><a class="mark" href="#stream_creating_readable_streams_with_async_generators" id="stream_creating_readable_streams_with_async_generators">#</a></span></h5>
 <p>We can construct a Node.js readable stream from an asynchronous generator
 using the <code>Readable.from()</code> utility method:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> * <span class="hljs-title">generate</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> * <span class="hljs-title function_">generate</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'a'</span>;
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'b'</span>;
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'c'</span>;
 }
 
-<span class="hljs-keyword">const</span> readable = Readable.from(generate());
+<span class="hljs-keyword">const</span> readable = <span class="hljs-title class_">Readable</span>.<span class="hljs-title function_">from</span>(<span class="hljs-title function_">generate</span>());
 
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(chunk);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk);
 });</code></pre>
-<h4>Piping to writable streams from async iterators<span><a class="mark" href="#stream_piping_to_writable_streams_from_async_iterators" id="stream_piping_to_writable_streams_from_async_iterators">#</a></span></h4>
-<p>In the scenario of writing to a writable stream from an async iterator, ensure
-the correct handling of backpressure and errors.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-<span class="hljs-keyword">const</span> finished = util.promisify(stream.finished);
-
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'./file'</span>);
+<h5>Piping to writable streams from async iterators<span><a class="mark" href="#stream_piping_to_writable_streams_from_async_iterators" id="stream_piping_to_writable_streams_from_async_iterators">#</a></span></h5>
+<p>When writing to a writable stream from an async iterator, ensure correct
+handling of backpressure and errors. <a href="#stream_stream_pipeline_source_transforms_destination_callback"><code>stream.pipeline()</code></a> abstracts away
+the handling of backpressure and backpressure-related errors:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">drain</span>(<span class="hljs-params">writable</span>) </span>{
-  <span class="hljs-keyword">if</span> (writable.destroyed) {
-    <span class="hljs-keyword">return</span> <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'premature close'</span>));
-  }
-  <span class="hljs-keyword">return</span> <span class="hljs-built_in">Promise</span>.race([
-    once(writable, <span class="hljs-string">'drain'</span>),
-    once(writable, <span class="hljs-string">'close'</span>)
-      .then(<span class="hljs-function">() =></span> <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'premature close'</span>)))
-  ]);
-}
+<span class="hljs-keyword">const</span> writable = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'./file'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">pump</span>(<span class="hljs-params">iterable, writable</span>) </span>{
-  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> chunk <span class="hljs-keyword">of</span> iterable) {
-    <span class="hljs-comment">// Handle backpressure on write().</span>
-    <span class="hljs-keyword">if</span> (!writable.write(chunk)) {
-      <span class="hljs-keyword">await</span> drain(writable);
-    }
+<span class="hljs-comment">// Callback Pattern</span>
+<span class="hljs-title function_">pipeline</span>(iterator, writable, <span class="hljs-function">(<span class="hljs-params">err, value</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+  } <span class="hljs-keyword">else</span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value, <span class="hljs-string">'value returned'</span>);
   }
-  writable.end();
-}
-
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-comment">// Ensure completion without errors.</span>
-  <span class="hljs-keyword">await</span> <span class="hljs-built_in">Promise</span>.all([
-    pump(iterable, writable),
-    finished(writable)
-  ]);
-})();</code></pre>
-<p>In the above, errors on <code>write()</code> would be caught and thrown by the
-<code>once()</code> listener for the <code>'drain'</code> event, since <code>once()</code> will also handle the
-<code>'error'</code> event. To ensure completion of the write stream without errors,
-it is safer to use the <code>finished()</code> method as above, instead of using the
-<code>once()</code> listener for the <code>'finish'</code> event. Under certain cases, an <code>'error'</code>
-event could be emitted by the writable stream after <code>'finish'</code> and as <code>once()</code>
-will release the <code>'error'</code> handler on handling the <code>'finish'</code> event, it could
-result in an unhandled error.</p>
-<p>Alternatively, the readable stream could be wrapped with <code>Readable.from()</code> and
-then piped via <code>.pipe()</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> finished = util.promisify(stream.finished);
-
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'./file'</span>);
-
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> readable = Readable.from(iterable);
-  readable.pipe(writable);
-  <span class="hljs-comment">// Ensure completion without errors.</span>
-  <span class="hljs-keyword">await</span> finished(writable);
-})();</code></pre>
-<p>Or, using <code>stream.pipeline()</code> to pipe streams:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> pipeline = util.promisify(stream.pipeline);
-
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'./file'</span>);
+});
 
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> readable = Readable.from(iterable);
-  <span class="hljs-keyword">await</span> pipeline(readable, writable);
-})();</code></pre>
+<span class="hljs-comment">// Promise Pattern</span>
+<span class="hljs-keyword">const</span> pipelinePromise = util.<span class="hljs-title function_">promisify</span>(pipeline);
+<span class="hljs-title function_">pipelinePromise</span>(iterator, writable)
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value, <span class="hljs-string">'value returned'</span>);
+  })
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);</code></pre>
 
-<h3>Compatibility with older Node.js versions<span><a class="mark" href="#stream_compatibility_with_older_node_js_versions" id="stream_compatibility_with_older_node_js_versions">#</a></span></h3>
+<h4>Compatibility with older Node.js versions<span><a class="mark" href="#stream_compatibility_with_older_node_js_versions" id="stream_compatibility_with_older_node_js_versions">#</a></span></h4>
 
 <p>Prior to Node.js 0.10, the <code>Readable</code> stream interface was simpler, but also
 less powerful and less useful.</p>
@@ -54133,32 +58637,32 @@ edge case in the following conditions:</p>
 </ul>
 <p>For example, consider the following code:</p>
 <pre><code class="language-js"><span class="hljs-comment">// WARNING!  BROKEN!</span>
-net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
 
   <span class="hljs-comment">// We add an 'end' listener, but never consume the data.</span>
-  socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-comment">// It will never get here.</span>
-    socket.end(<span class="hljs-string">'The message was received but was not processed.\n'</span>);
+    socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'The message was received but was not processed.\n'</span>);
   });
 
-}).listen(<span class="hljs-number">1337</span>);</code></pre>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
 <p>Prior to Node.js 0.10, the incoming message data would be simply discarded.
 However, in Node.js 0.10 and beyond, the socket remains paused forever.</p>
 <p>The workaround in this situation is to call the
 <a href="#stream_readable_resume"><code>stream.resume()</code></a> method to begin the flow of data:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Workaround.</span>
-net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    socket.end(<span class="hljs-string">'The message was received but was not processed.\n'</span>);
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'The message was received but was not processed.\n'</span>);
   });
 
   <span class="hljs-comment">// Start the flow of data, discarding it.</span>
-  socket.resume();
-}).listen(<span class="hljs-number">1337</span>);</code></pre>
+  socket.<span class="hljs-title function_">resume</span>();
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
 <p>In addition to new <code>Readable</code> streams switching into flowing mode,
 pre-0.10 style streams can be wrapped in a <code>Readable</code> class using the
 <a href="#stream_readable_wrap_stream"><code>readable.wrap()</code></a> method.</p>
-<h3><code>readable.read(0)</code><span><a class="mark" href="#stream_readable_read_0" id="stream_readable_read_0">#</a></span></h3>
+<h4><code>readable.read(0)</code><span><a class="mark" href="#stream_readable_read_0" id="stream_readable_read_0">#</a></span></h4>
 <p>There are some cases where it is necessary to trigger a refresh of the
 underlying readable stream mechanisms, without actually consuming any
 data. In such cases, it is possible to call <code>readable.read(0)</code>, which will
@@ -54169,14 +58673,14 @@ a low-level <a href="#stream_readable_read_size_1"><code>stream._read()</code></
 <p>While most applications will almost never need to do this, there are
 situations within Node.js where this is done, particularly in the
 <code>Readable</code> stream class internals.</p>
-<h3><code>readable.push('')</code><span><a class="mark" href="#stream_readable_push" id="stream_readable_push">#</a></span></h3>
+<h4><code>readable.push('')</code><span><a class="mark" href="#stream_readable_push" id="stream_readable_push">#</a></span></h4>
 <p>Use of <code>readable.push('')</code> is not recommended.</p>
 <p>Pushing a zero-byte string, <code>Buffer</code> or <code>Uint8Array</code> to a stream that is not in
 object mode has an interesting side effect. Because it <em>is</em> a call to
 <a href="#stream_readable_push_chunk_encoding"><code>readable.push()</code></a>, the call will end the reading process.
 However, because the argument is an empty string, no data is added to the
 readable buffer so there is nothing for a user to consume.</p>
-<h3><code>highWaterMark</code> discrepancy after calling <code>readable.setEncoding()</code><span><a class="mark" href="#stream_highwatermark_discrepancy_after_calling_readable_setencoding" id="stream_highwatermark_discrepancy_after_calling_readable_setencoding">#</a></span></h3>
+<h4><code>highWaterMark</code> discrepancy after calling <code>readable.setEncoding()</code><span><a class="mark" href="#stream_highwatermark_discrepancy_after_calling_readable_setencoding" id="stream_highwatermark_discrepancy_after_calling_readable_setencoding">#</a></span></h4>
 <p>The use of <code>readable.setEncoding()</code> will change the behavior of how the
 <code>highWaterMark</code> operates in non-object mode.</p>
 <p>Typically, the size of the current buffer is measured against the
@@ -54184,38 +58688,39 @@ readable buffer so there is nothing for a user to consume.</p>
 comparison function will begin to measure the buffer's size in <em>characters</em>.</p>
 <p>This is not a problem in common cases with <code>latin1</code> or <code>ascii</code>. But it is
 advised to be mindful about this behavior when working with strings that could
-contain multi-byte characters.</p>
-<h1>String decoder<span><a class="mark" href="#string_decoder_string_decoder" id="string_decoder_string_decoder">#</a></span></h1>
+contain multi-byte characters.</p></section>
+        </section>
+<section><h2>String decoder<span><a class="mark" href="#string_decoder_string_decoder" id="string_decoder_string_decoder">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/string_decoder.js">lib/string_decoder.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/string_decoder.js">lib/string_decoder.js</a></p>
 <p>The <code>string_decoder</code> module provides an API for decoding <code>Buffer</code> objects into
 strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
 characters. It can be accessed using:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);</code></pre>
 <p>The following example shows the basic use of the <code>StringDecoder</code> class.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
-<span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> StringDecoder(<span class="hljs-string">'utf8'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
+<span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringDecoder</span>(<span class="hljs-string">'utf8'</span>);
 
-<span class="hljs-keyword">const</span> cent = Buffer.from([<span class="hljs-number">0xC2</span>, <span class="hljs-number">0xA2</span>]);
-<span class="hljs-built_in">console</span>.log(decoder.write(cent));
+<span class="hljs-keyword">const</span> cent = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0xC2</span>, <span class="hljs-number">0xA2</span>]);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decoder.<span class="hljs-title function_">write</span>(cent));
 
-<span class="hljs-keyword">const</span> euro = Buffer.from([<span class="hljs-number">0xE2</span>, <span class="hljs-number">0x82</span>, <span class="hljs-number">0xAC</span>]);
-<span class="hljs-built_in">console</span>.log(decoder.write(euro));</code></pre>
+<span class="hljs-keyword">const</span> euro = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0xE2</span>, <span class="hljs-number">0x82</span>, <span class="hljs-number">0xAC</span>]);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decoder.<span class="hljs-title function_">write</span>(euro));</code></pre>
 <p>When a <code>Buffer</code> instance is written to the <code>StringDecoder</code> instance, an
 internal buffer is used to ensure that the decoded string does not contain
 any incomplete multibyte characters. These are held in the buffer until the
 next call to <code>stringDecoder.write()</code> or until <code>stringDecoder.end()</code> is called.</p>
 <p>In the following example, the three UTF-8 encoded bytes of the European Euro
 symbol (<code>€</code>) are written over three separate operations:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
-<span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> StringDecoder(<span class="hljs-string">'utf8'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
+<span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringDecoder</span>(<span class="hljs-string">'utf8'</span>);
 
-decoder.write(Buffer.from([<span class="hljs-number">0xE2</span>]));
-decoder.write(Buffer.from([<span class="hljs-number">0x82</span>]));
-<span class="hljs-built_in">console</span>.log(decoder.end(Buffer.from([<span class="hljs-number">0xAC</span>])));</code></pre>
-<h2>Class: <code>StringDecoder</code><span><a class="mark" href="#string_decoder_class_stringdecoder" id="string_decoder_class_stringdecoder">#</a></span></h2>
-<h3><code>new StringDecoder([encoding])</code><span><a class="mark" href="#string_decoder_new_stringdecoder_encoding" id="string_decoder_new_stringdecoder_encoding">#</a></span></h3>
+decoder.<span class="hljs-title function_">write</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0xE2</span>]));
+decoder.<span class="hljs-title function_">write</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x82</span>]));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decoder.<span class="hljs-title function_">end</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0xAC</span>])));</code></pre>
+<section><h3>Class: <code>StringDecoder</code><span><a class="mark" href="#string_decoder_class_stringdecoder" id="string_decoder_class_stringdecoder">#</a></span></h3>
+<h4><code>new StringDecoder([encoding])</code><span><a class="mark" href="#string_decoder_new_stringdecoder_encoding" id="string_decoder_new_stringdecoder_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -54224,7 +58729,7 @@ decoder.write(Buffer.from([<span class="hljs-number">0x82</span>]));
 <strong>Default:</strong> <code>'utf8'</code>.</li>
 </ul>
 <p>Creates a new <code>StringDecoder</code> instance.</p>
-<h3><code>stringDecoder.end([buffer])</code><span><a class="mark" href="#string_decoder_stringdecoder_end_buffer" id="string_decoder_stringdecoder_end_buffer">#</a></span></h3>
+<h4><code>stringDecoder.end([buffer])</code><span><a class="mark" href="#string_decoder_stringdecoder_end_buffer" id="string_decoder_stringdecoder_end_buffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -54237,8 +58742,9 @@ decoder.write(Buffer.from([<span class="hljs-number">0x82</span>]));
 representing incomplete UTF-8 and UTF-16 characters will be replaced with
 substitution characters appropriate for the character encoding.</p>
 <p>If the <code>buffer</code> argument is provided, one final call to <code>stringDecoder.write()</code>
-is performed before returning the remaining input.</p>
-<h3><code>stringDecoder.write(buffer)</code><span><a class="mark" href="#string_decoder_stringdecoder_write_buffer" id="string_decoder_stringdecoder_write_buffer">#</a></span></h3>
+is performed before returning the remaining input.
+After <code>end()</code> is called, the <code>stringDecoder</code> object can be reused for new input.</p>
+<h4><code>stringDecoder.write(buffer)</code><span><a class="mark" href="#string_decoder_stringdecoder_write_buffer" id="string_decoder_stringdecoder_write_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -54258,18 +58764,19 @@ is performed before returning the remaining input.</p>
 <p>Returns a decoded string, ensuring that any incomplete multibyte characters at
 the end of the <code>Buffer</code>, or <code>TypedArray</code>, or <code>DataView</code> are omitted from the
 returned string and stored in an internal buffer for the next call to
-<code>stringDecoder.write()</code> or <code>stringDecoder.end()</code>.</p>
-<h1>Timers<span><a class="mark" href="#timers_timers" id="timers_timers">#</a></span></h1>
+<code>stringDecoder.write()</code> or <code>stringDecoder.end()</code>.</p></section>
+        </section>
+<section><h2>Timers<span><a class="mark" href="#timers_timers" id="timers_timers">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/timers.js">lib/timers.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/timers.js">lib/timers.js</a></p>
 <p>The <code>timer</code> module exposes a global API for scheduling functions to
 be called at some future period of time. Because the timer functions are
 globals, there is no need to call <code>require('timers')</code> to use the API.</p>
 <p>The timer functions within Node.js implement a similar API as the timers API
 provided by Web Browsers but use a different internal implementation that is
 built around the Node.js <a href="https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout">Event Loop</a>.</p>
-<h2>Class: <code>Immediate</code><span><a class="mark" href="#timers_class_immediate" id="timers_class_immediate">#</a></span></h2>
+<section><h3>Class: <code>Immediate</code><span><a class="mark" href="#timers_class_immediate" id="timers_class_immediate">#</a></span></h3>
 <p>This object is created internally and is returned from <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>. It
 can be passed to <a href="#timers_clearimmediate_immediate"><code>clearImmediate()</code></a> in order to cancel the scheduled
 actions.</p>
@@ -54277,7 +58784,7 @@ actions.</p>
 running as long as the immediate is active. The <code>Immediate</code> object returned by
 <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a> exports both <code>immediate.ref()</code> and <code>immediate.unref()</code>
 functions that can be used to control this default behavior.</p>
-<h3><code>immediate.hasRef()</code><span><a class="mark" href="#timers_immediate_hasref" id="timers_immediate_hasref">#</a></span></h3>
+<h4><code>immediate.hasRef()</code><span><a class="mark" href="#timers_immediate_hasref" id="timers_immediate_hasref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
@@ -54285,7 +58792,7 @@ functions that can be used to control this default behavior.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>If true, the <code>Immediate</code> object will keep the Node.js event loop active.</p>
-<h3><code>immediate.ref()</code><span><a class="mark" href="#timers_immediate_ref" id="timers_immediate_ref">#</a></span></h3>
+<h4><code>immediate.ref()</code><span><a class="mark" href="#timers_immediate_ref" id="timers_immediate_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.7.0</span>
 </div>
@@ -54297,7 +58804,7 @@ functions that can be used to control this default behavior.</p>
 effect.</p>
 <p>By default, all <code>Immediate</code> objects are "ref'ed", making it normally unnecessary
 to call <code>immediate.ref()</code> unless <code>immediate.unref()</code> had been called previously.</p>
-<h3><code>immediate.unref()</code><span><a class="mark" href="#timers_immediate_unref" id="timers_immediate_unref">#</a></span></h3>
+<h4><code>immediate.unref()</code><span><a class="mark" href="#timers_immediate_unref" id="timers_immediate_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.7.0</span>
 </div>
@@ -54308,7 +58815,7 @@ to call <code>immediate.ref()</code> unless <code>immediate.unref()</code> had b
 loop to remain active. If there is no other activity keeping the event loop
 running, the process may exit before the <code>Immediate</code> object's callback is
 invoked. Calling <code>immediate.unref()</code> multiple times will have no effect.</p>
-<h2>Class: <code>Timeout</code><span><a class="mark" href="#timers_class_timeout" id="timers_class_timeout">#</a></span></h2>
+</section><section><h3>Class: <code>Timeout</code><span><a class="mark" href="#timers_class_timeout" id="timers_class_timeout">#</a></span></h3>
 <p>This object is created internally and is returned from <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> and
 <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>. It can be passed to either <a href="#timers_cleartimeout_timeout"><code>clearTimeout()</code></a> or
 <a href="#timers_clearinterval_timeout"><code>clearInterval()</code></a> in order to cancel the scheduled actions.</p>
@@ -54317,7 +58824,7 @@ invoked. Calling <code>immediate.unref()</code> multiple times will have no effe
 timer is active. Each of the <code>Timeout</code> objects returned by these functions
 export both <code>timeout.ref()</code> and <code>timeout.unref()</code> functions that can be used to
 control this default behavior.</p>
-<h3><code>timeout.hasRef()</code><span><a class="mark" href="#timers_timeout_hasref" id="timers_timeout_hasref">#</a></span></h3>
+<h4><code>timeout.hasRef()</code><span><a class="mark" href="#timers_timeout_hasref" id="timers_timeout_hasref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
@@ -54325,7 +58832,7 @@ control this default behavior.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>If true, the <code>Timeout</code> object will keep the Node.js event loop active.</p>
-<h3><code>timeout.ref()</code><span><a class="mark" href="#timers_timeout_ref" id="timers_timeout_ref">#</a></span></h3>
+<h4><code>timeout.ref()</code><span><a class="mark" href="#timers_timeout_ref" id="timers_timeout_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -54336,7 +58843,7 @@ control this default behavior.</p>
 <code>Timeout</code> is active. Calling <code>timeout.ref()</code> multiple times will have no effect.</p>
 <p>By default, all <code>Timeout</code> objects are "ref'ed", making it normally unnecessary
 to call <code>timeout.ref()</code> unless <code>timeout.unref()</code> had been called previously.</p>
-<h3><code>timeout.refresh()</code><span><a class="mark" href="#timers_timeout_refresh" id="timers_timeout_refresh">#</a></span></h3>
+<h4><code>timeout.refresh()</code><span><a class="mark" href="#timers_timeout_refresh" id="timers_timeout_refresh">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.2.0</span>
 </div>
@@ -54349,7 +58856,7 @@ time. This is useful for refreshing a timer without allocating a new
 JavaScript object.</p>
 <p>Using this on a timer that has already called its callback will reactivate the
 timer.</p>
-<h3><code>timeout.unref()</code><span><a class="mark" href="#timers_timeout_unref" id="timers_timeout_unref">#</a></span></h3>
+<h4><code>timeout.unref()</code><span><a class="mark" href="#timers_timeout_unref" id="timers_timeout_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -54363,9 +58870,9 @@ the process may exit before the <code>Timeout</code> object's callback is invoke
 <p>Calling <code>timeout.unref()</code> creates an internal timer that will wake the Node.js
 event loop. Creating too many of these can adversely impact performance
 of the Node.js application.</p>
-<h3><code>timeout[Symbol.toPrimitive]()</code><span><a class="mark" href="#timers_timeout_symbol_toprimitive" id="timers_timeout_symbol_toprimitive">#</a></span></h3>
+<h4><code>timeout[Symbol.toPrimitive]()</code><span><a class="mark" href="#timers_timeout_symbol_toprimitive" id="timers_timeout_symbol_toprimitive">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.9.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> a number that can be used to reference this <code>timeout</code></li>
@@ -54376,12 +58883,12 @@ same thread where the timeout was created. Therefore, to use it
 across <a href="worker_threads.html"><code>worker_threads</code></a> it must first be passed to the correct
 thread. This allows enhanced compatibility with browser
 <code>setTimeout()</code> and <code>setInterval()</code> implementations.</p>
-<h2>Scheduling timers<span><a class="mark" href="#timers_scheduling_timers" id="timers_scheduling_timers">#</a></span></h2>
+</section><section><h3>Scheduling timers<span><a class="mark" href="#timers_scheduling_timers" id="timers_scheduling_timers">#</a></span></h3>
 <p>A timer in Node.js is an internal construct that calls a given function after
 a certain period of time. When a timer's function is called varies depending on
 which method was used to create the timer and what other work the Node.js
 event loop is doing.</p>
-<h3><code>setImmediate(callback[, ...args])</code><span><a class="mark" href="#timers_setimmediate_callback_args" id="timers_setimmediate_callback_args">#</a></span></h3>
+<h4><code>setImmediate(callback[, ...args])</code><span><a class="mark" href="#timers_setimmediate_callback_args" id="timers_setimmediate_callback_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -54402,28 +58909,28 @@ next event loop iteration.</p>
 <p>This method has a custom variant for promises that is available using
 <a href="#util_util_promisify_original"><code>util.promisify()</code></a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> setImmediatePromise = util.promisify(setImmediate);
+<span class="hljs-keyword">const</span> setImmediatePromise = util.<span class="hljs-title function_">promisify</span>(setImmediate);
 
-setImmediatePromise(<span class="hljs-string">'foobar'</span>).then(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+<span class="hljs-title function_">setImmediatePromise</span>(<span class="hljs-string">'foobar'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
   <span class="hljs-comment">// value === 'foobar' (passing values is optional)</span>
   <span class="hljs-comment">// This is executed after all I/O callbacks.</span>
 });
 
 <span class="hljs-comment">// Or with async function</span>
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">timerExample</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Before I/O callbacks'</span>);
-  <span class="hljs-keyword">await</span> setImmediatePromise();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'After I/O callbacks'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">timerExample</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Before I/O callbacks'</span>);
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">setImmediatePromise</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'After I/O callbacks'</span>);
 }
-timerExample();</code></pre>
-<h3><code>setInterval(callback, delay[, ...args])</code><span><a class="mark" href="#timers_setinterval_callback_delay_args" id="timers_setinterval_callback_delay_args">#</a></span></h3>
+<span class="hljs-title function_">timerExample</span>();</code></pre>
+<h4><code>setInterval(callback[, delay[, ...args]])</code><span><a class="mark" href="#timers_setinterval_callback_delay_args" id="timers_setinterval_callback_delay_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to call when the timer elapses.</li>
 <li><code>delay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of milliseconds to wait before calling the
-<code>callback</code>.</li>
+<code>callback</code>. <strong>Default</strong>: <code>1</code>.</li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Optional arguments to pass when the <code>callback</code> is called.</li>
 <li>Returns: <a href="#timers_class_timeout" class="type">&#x3C;Timeout></a> for use with <a href="#timers_clearinterval_timeout"><code>clearInterval()</code></a></li>
 </ul>
@@ -54431,14 +58938,14 @@ timerExample();</code></pre>
 <p>When <code>delay</code> is larger than <code>2147483647</code> or less than <code>1</code>, the <code>delay</code> will be
 set to <code>1</code>. Non-integer delays are truncated to an integer.</p>
 <p>If <code>callback</code> is not a function, a <a href="#errors_class_typeerror"><code>TypeError</code></a> will be thrown.</p>
-<h3><code>setTimeout(callback, delay[, ...args])</code><span><a class="mark" href="#timers_settimeout_callback_delay_args" id="timers_settimeout_callback_delay_args">#</a></span></h3>
+<h4><code>setTimeout(callback[, delay[, ...args]])</code><span><a class="mark" href="#timers_settimeout_callback_delay_args" id="timers_settimeout_callback_delay_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to call when the timer elapses.</li>
 <li><code>delay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of milliseconds to wait before calling the
-<code>callback</code>.</li>
+<code>callback</code>. <strong>Default</strong>: <code>1</code>.</li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Optional arguments to pass when the <code>callback</code> is called.</li>
 <li>Returns: <a href="#timers_class_timeout" class="type">&#x3C;Timeout></a> for use with <a href="#timers_cleartimeout_timeout"><code>clearTimeout()</code></a></li>
 </ul>
@@ -54453,19 +58960,50 @@ will be set to <code>1</code>. Non-integer delays are truncated to an integer.</
 <p>This method has a custom variant for promises that is available using
 <a href="#util_util_promisify_original"><code>util.promisify()</code></a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> setTimeoutPromise = util.promisify(<span class="hljs-built_in">setTimeout</span>);
+<span class="hljs-keyword">const</span> setTimeoutPromise = util.<span class="hljs-title function_">promisify</span>(<span class="hljs-built_in">setTimeout</span>);
 
-setTimeoutPromise(<span class="hljs-number">40</span>, <span class="hljs-string">'foobar'</span>).then(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+setTimeoutPromise(<span class="hljs-number">40</span>, <span class="hljs-string">'foobar'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
   <span class="hljs-comment">// value === 'foobar' (passing values is optional)</span>
   <span class="hljs-comment">// This is executed after about 40 milliseconds.</span>
 });</code></pre>
-<h2>Cancelling timers<span><a class="mark" href="#timers_cancelling_timers" id="timers_cancelling_timers">#</a></span></h2>
+</section><section><h3>Cancelling timers<span><a class="mark" href="#timers_cancelling_timers" id="timers_cancelling_timers">#</a></span></h3>
 <p>The <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>, <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>, and <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> methods
 each return objects that represent the scheduled timers. These can be used to
 cancel the timer and prevent it from triggering.</p>
-<p>It is not possible to cancel timers that were created using the promisified
-variants of <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>, <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>.</p>
-<h3><code>clearImmediate(immediate)</code><span><a class="mark" href="#timers_clearimmediate_immediate" id="timers_clearimmediate_immediate">#</a></span></h3>
+<p>For the promisified variants of <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a> and <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>,
+an <a href="#globals_class_abortcontroller"><code>AbortController</code></a> may be used to cancel the timer. When canceled, the
+returned Promises will be rejected with an <code>'AbortError'</code>.</p>
+<p>For <code>setImmediate()</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> setImmediatePromise = util.<span class="hljs-title function_">promisify</span>(setImmediate);
+
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> signal = ac.<span class="hljs-property">signal</span>;
+
+<span class="hljs-title function_">setImmediatePromise</span>(<span class="hljs-string">'foobar'</span>, { signal })
+  .<span class="hljs-title function_">then</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>)
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">name</span> === <span class="hljs-string">'AbortError'</span>)
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The immediate was aborted'</span>);
+  });
+
+ac.<span class="hljs-title function_">abort</span>();</code></pre>
+<p>For <code>setTimeout()</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> setTimeoutPromise = util.<span class="hljs-title function_">promisify</span>(<span class="hljs-built_in">setTimeout</span>);
+
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> signal = ac.<span class="hljs-property">signal</span>;
+
+setTimeoutPromise(<span class="hljs-number">1000</span>, <span class="hljs-string">'foobar'</span>, { signal })
+  .<span class="hljs-title function_">then</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>)
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">name</span> === <span class="hljs-string">'AbortError'</span>)
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The timeout was aborted'</span>);
+  });
+
+ac.<span class="hljs-title function_">abort</span>();</code></pre>
+<h4><code>clearImmediate(immediate)</code><span><a class="mark" href="#timers_clearimmediate_immediate" id="timers_clearimmediate_immediate">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -54474,31 +59012,34 @@ variants of <a href="#timers_setimmediate_callback_args"><code>setImmediate()</c
 <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>.</li>
 </ul>
 <p>Cancels an <code>Immediate</code> object created by <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>.</p>
-<h3><code>clearInterval(timeout)</code><span><a class="mark" href="#timers_clearinterval_timeout" id="timers_clearinterval_timeout">#</a></span></h3>
+<h4><code>clearInterval(timeout)</code><span><a class="mark" href="#timers_clearinterval_timeout" id="timers_clearinterval_timeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 <ul>
-<li><code>timeout</code> <a href="#timers_class_timeout" class="type">&#x3C;Timeout></a> A <code>Timeout</code> object as returned by <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>.</li>
+<li><code>timeout</code> <a href="#timers_class_timeout" class="type">&#x3C;Timeout></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A <code>Timeout</code> object as returned by <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>
+or the <a href="#timers_timeout_symbol_toprimitive">primitive</a> of the <code>Timeout</code> object as a string or a number.</li>
 </ul>
 <p>Cancels a <code>Timeout</code> object created by <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>.</p>
-<h3><code>clearTimeout(timeout)</code><span><a class="mark" href="#timers_cleartimeout_timeout" id="timers_cleartimeout_timeout">#</a></span></h3>
+<h4><code>clearTimeout(timeout)</code><span><a class="mark" href="#timers_cleartimeout_timeout" id="timers_cleartimeout_timeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 <ul>
-<li><code>timeout</code> <a href="#timers_class_timeout" class="type">&#x3C;Timeout></a> A <code>Timeout</code> object as returned by <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>.</li>
+<li><code>timeout</code> <a href="#timers_class_timeout" class="type">&#x3C;Timeout></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A <code>Timeout</code> object as returned by <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>
+or the <a href="#timers_timeout_symbol_toprimitive">primitive</a> of the <code>Timeout</code> object as a string or a number.</li>
 </ul>
-<p>Cancels a <code>Timeout</code> object created by <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>.</p>
-<h1>TLS (SSL)<span><a class="mark" href="#tls_tls_ssl" id="tls_tls_ssl">#</a></span></h1>
+<p>Cancels a <code>Timeout</code> object created by <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>.</p></section>
+        </section>
+<section><h2>TLS (SSL)<span><a class="mark" href="#tls_tls_ssl" id="tls_tls_ssl">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/tls.js">lib/tls.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/tls.js">lib/tls.js</a></p>
 <p>The <code>tls</code> module provides an implementation of the Transport Layer Security
 (TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.
 The module can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> tls = <span class="hljs-built_in">require</span>(<span class="hljs-string">'tls'</span>);</code></pre>
-<h2>TLS/SSL concepts<span><a class="mark" href="#tls_tls_ssl_concepts" id="tls_tls_ssl_concepts">#</a></span></h2>
+<section><h3>TLS/SSL concepts<span><a class="mark" href="#tls_tls_ssl_concepts" id="tls_tls_ssl_concepts">#</a></span></h3>
 <p>The TLS/SSL is a public/private key infrastructure (PKI). For most common
 cases, each client and server must have a <em>private key</em>.</p>
 <p>Private keys can be generated in multiple ways. The example below illustrates
@@ -54530,7 +59071,7 @@ is illustrated in the example below:</p>
 <li><code>certfile</code>: is a concatenation of all Certificate Authority (CA) certs into
 a single file, e.g. <code>cat ca1-cert.pem ca2-cert.pem > ca-cert.pem</code></li>
 </ul>
-<h3>Perfect forward secrecy<span><a class="mark" href="#tls_perfect_forward_secrecy" id="tls_perfect_forward_secrecy">#</a></span></h3>
+<h4>Perfect forward secrecy<span><a class="mark" href="#tls_perfect_forward_secrecy" id="tls_perfect_forward_secrecy">#</a></span></h4>
 
 <p>The term <em><a href="https://en.wikipedia.org/wiki/Perfect_forward_secrecy">forward secrecy</a></em> or <em>perfect forward secrecy</em> describes a feature
 of key-agreement (i.e., key-exchange) methods. That is, the server and client
@@ -54562,7 +59103,7 @@ can be used when creating a TLS Server to specify the list of names of supported
 curves to use, see <a href="#tls_tls_createserver_options_secureconnectionlistener"><code>tls.createServer()</code></a> for more info.</p>
 <p>Perfect forward secrecy was optional up to TLSv1.2, but it is not optional for
 TLSv1.3, because all TLSv1.3 cipher suites use ECDHE.</p>
-<h3>ALPN and SNI<span><a class="mark" href="#tls_alpn_and_sni" id="tls_alpn_and_sni">#</a></span></h3>
+<h4>ALPN and SNI<span><a class="mark" href="#tls_alpn_and_sni" id="tls_alpn_and_sni">#</a></span></h4>
 
 <p>ALPN (Application-Layer Protocol Negotiation Extension) and
 SNI (Server Name Indication) are TLS handshake extensions:</p>
@@ -54571,7 +59112,7 @@ SNI (Server Name Indication) are TLS handshake extensions:</p>
 <li>SNI: Allows the use of one TLS server for multiple hostnames with different
 SSL certificates.</li>
 </ul>
-<h3>Pre-shared keys<span><a class="mark" href="#tls_pre_shared_keys" id="tls_pre_shared_keys">#</a></span></h3>
+<h4>Pre-shared keys<span><a class="mark" href="#tls_pre_shared_keys" id="tls_pre_shared_keys">#</a></span></h4>
 
 <p>TLS-PSK support is available as an alternative to normal certificate-based
 authentication. It uses a pre-shared key instead of certificates to
@@ -54598,7 +59139,7 @@ PSKs up to 64 bytes in length must be supported. As of OpenSSL 1.1.0
 maximum identity size is 128 bytes, and maximum PSK length is 256 bytes.</p>
 <p>The current implementation doesn't support asynchronous PSK callbacks due to the
 limitations of the underlying OpenSSL API.</p>
-<h3>Client-initiated renegotiation attack mitigation<span><a class="mark" href="#tls_client_initiated_renegotiation_attack_mitigation" id="tls_client_initiated_renegotiation_attack_mitigation">#</a></span></h3>
+<h4>Client-initiated renegotiation attack mitigation<span><a class="mark" href="#tls_client_initiated_renegotiation_attack_mitigation" id="tls_client_initiated_renegotiation_attack_mitigation">#</a></span></h4>
 
 <p>The TLS protocol allows clients to renegotiate certain aspects of the TLS
 session. Unfortunately, session renegotiation requires a disproportionate amount
@@ -54616,11 +59157,11 @@ in seconds. <strong>Default:</strong> <code>600</code> (10 minutes).</li>
 <p>The default renegotiation limits should not be modified without a full
 understanding of the implications and risks.</p>
 <p>TLSv1.3 does not support renegotiation.</p>
-<h3>Session resumption<span><a class="mark" href="#tls_session_resumption" id="tls_session_resumption">#</a></span></h3>
+<h4>Session resumption<span><a class="mark" href="#tls_session_resumption" id="tls_session_resumption">#</a></span></h4>
 <p>Establishing a TLS session can be relatively slow. The process can be sped
 up by saving and later reusing the session state. There are several mechanisms
 to do so, discussed here from oldest to newest (and preferred).</p>
-<h4>Session identifiers<span><a class="mark" href="#tls_session_identifiers" id="tls_session_identifiers">#</a></span></h4>
+<h5>Session identifiers<span><a class="mark" href="#tls_session_identifiers" id="tls_session_identifiers">#</a></span></h5>
 <p>Servers generate a unique ID for new connections and
 send it to the client. Clients and servers save the session state. When
 reconnecting, clients send the ID of their saved session state and if the server
@@ -54637,7 +59178,7 @@ to save and restore the session data using the session ID as the lookup key to
 reuse sessions. To reuse sessions across load balancers or cluster workers,
 servers must use a shared session cache (such as Redis) in their session
 handlers.</p>
-<h4>Session tickets<span><a class="mark" href="#tls_session_tickets" id="tls_session_tickets">#</a></span></h4>
+<h5>Session tickets<span><a class="mark" href="#tls_session_tickets" id="tls_session_tickets">#</a></span></h5>
 <p>The servers encrypt the entire session state and send it
 to the client as a "ticket". When reconnecting, the state is sent to the server
 in the initial connection. This mechanism avoids the need for server-side
@@ -54663,8 +59204,8 @@ securely generate 48 bytes of secure random data and set them with the
 <code>ticketKeys</code> option of <a href="#tls_tls_createserver_options_secureconnectionlistener"><code>tls.createServer()</code></a>. The keys should be regularly
 regenerated and server's keys can be reset with
 <a href="#tls_server_setticketkeys_keys"><code>server.setTicketKeys()</code></a>.</p>
-<p>Session ticket keys are cryptographic keys, and they <strong><em>must be stored
-securely</em></strong>. With TLS 1.2 and below, if they are compromised all sessions that
+<p>Session ticket keys are cryptographic keys, and they <em><strong>must be stored
+securely</strong></em>. With TLS 1.2 and below, if they are compromised all sessions that
 used tickets encrypted with them can be decrypted. They should not be stored
 on disk, and they should be regenerated regularly.</p>
 <p>If clients advertise support for tickets, the server will send them. The
@@ -54678,13 +59219,13 @@ Since failing to resume the session does not cause TLS/HTTPS connection
 failures, it is easy to not notice unnecessarily poor TLS performance. The
 OpenSSL CLI can be used to verify that servers are resuming sessions. Use the
 <code>-reconnect</code> option to <code>openssl s_client</code>, for example:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> openssl s_client -connect localhost:443 -reconnect</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">openssl s_client -connect localhost:443 -reconnect</span></code></pre>
 <p>Read through the debug output. The first connection should say "New", for
 example:</p>
 <pre><code class="language-text">New, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256</code></pre>
 <p>Subsequent connections should say "Reused", for example:</p>
 <pre><code class="language-text">Reused, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256</code></pre>
-<h2>Modifying the default TLS cipher suite<span><a class="mark" href="#tls_modifying_the_default_tls_cipher_suite" id="tls_modifying_the_default_tls_cipher_suite">#</a></span></h2>
+</section><section><h3>Modifying the default TLS cipher suite<span><a class="mark" href="#tls_modifying_the_default_tls_cipher_suite" id="tls_modifying_the_default_tls_cipher_suite">#</a></span></h3>
 <p>Node.js is built with a default suite of enabled and disabled TLS ciphers. This
 default cipher list can be configured when building Node.js to allow
 distributions to provide their own default list.</p>
@@ -54714,10 +59255,10 @@ HIGH
 !PSK
 !SRP
 !CAMELLIA</code></pre>
-<p>This default can be replaced entirely using the <a href="#cli_tls_cipher_list_list"><code>--tls-cipher-list</code></a> command
-line switch (directly, or via the <a href="#cli_node_options_options"><code>NODE_OPTIONS</code></a> environment variable). For
-instance, the following makes <code>ECDHE-RSA-AES128-GCM-SHA256:!RC4</code> the default TLS
-cipher suite:</p>
+<p>This default can be replaced entirely using the <a href="#cli_tls_cipher_list_list"><code>--tls-cipher-list</code></a>
+command-line switch (directly, or via the <a href="#cli_node_options_options"><code>NODE_OPTIONS</code></a> environment
+variable). For instance, the following makes <code>ECDHE-RSA-AES128-GCM-SHA256:!RC4</code>
+the default TLS cipher suite:</p>
 <pre><code class="language-bash">node --tls-cipher-list=<span class="hljs-string">'ECDHE-RSA-AES128-GCM-SHA256:!RC4'</span> server.js
 
 <span class="hljs-built_in">export</span> NODE_OPTIONS=--tls-cipher-list=<span class="hljs-string">'ECDHE-RSA-AES128-GCM-SHA256:!RC4'</span>
@@ -54764,27 +59305,27 @@ on the format, see the OpenSSL <a href="https://www.openssl.org/docs/man1.1.1/ma
 <p>The first 3 are enabled by default. The last 2 <code>CCM</code>-based suites are supported
 by TLSv1.3 because they may be more performant on constrained systems, but they
 are not enabled by default since they offer less security.</p>
-<h2>Class: <code>tls.CryptoStream</code><span><a class="mark" href="#tls_class_tls_cryptostream" id="tls_class_tls_cryptostream">#</a></span></h2>
+</section><section><h3>Class: <code>tls.CryptoStream</code><span><a class="mark" href="#tls_class_tls_cryptostream" id="tls_class_tls_cryptostream">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span><span>Deprecated since: v0.11.3</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> instead.</div><p></p>
 <p>The <code>tls.CryptoStream</code> class represents a stream of encrypted data. This class
 is deprecated and should no longer be used.</p>
-<h3><code>cryptoStream.bytesWritten</code><span><a class="mark" href="#tls_cryptostream_byteswritten" id="tls_cryptostream_byteswritten">#</a></span></h3>
+<h4><code>cryptoStream.bytesWritten</code><span><a class="mark" href="#tls_cryptostream_byteswritten" id="tls_cryptostream_byteswritten">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span><span>Deprecated since: v0.11.3</span>
 </div>
 <p>The <code>cryptoStream.bytesWritten</code> property returns the total number of bytes
 written to the underlying socket <em>including</em> the bytes required for the
 implementation of the TLS protocol.</p>
-<h2>Class: <code>tls.SecurePair</code><span><a class="mark" href="#tls_class_tls_securepair" id="tls_class_tls_securepair">#</a></span></h2>
+</section><section><h3>Class: <code>tls.SecurePair</code><span><a class="mark" href="#tls_class_tls_securepair" id="tls_class_tls_securepair">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span><span>Deprecated since: v0.11.3</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> instead.</div><p></p>
 <p>Returned by <a href="#tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options"><code>tls.createSecurePair()</code></a>.</p>
-<h3>Event: <code>'secure'</code><span><a class="mark" href="#tls_event_secure" id="tls_event_secure">#</a></span></h3>
+<h4>Event: <code>'secure'</code><span><a class="mark" href="#tls_event_secure" id="tls_event_secure">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span><span>Deprecated since: v0.11.3</span>
 </div>
@@ -54794,7 +59335,7 @@ connection has been established.</p>
 <a href="#tls_event_secureconnection"><code>'secureConnection'</code></a>
 event, <code>pair.cleartext.authorized</code> should be inspected to confirm whether the
 certificate used is properly authorized.</p>
-<h2>Class: <code>tls.Server</code><span><a class="mark" href="#tls_class_tls_server" id="tls_class_tls_server">#</a></span></h2>
+</section><section><h3>Class: <code>tls.Server</code><span><a class="mark" href="#tls_class_tls_server" id="tls_class_tls_server">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -54802,7 +59343,7 @@ certificate used is properly authorized.</p>
 <li>Extends: <a href="#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
 <p>Accepts encrypted connections using TLS or SSL.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#tls_event_connection" id="tls_event_connection">#</a></span></h3>
+<h4>Event: <code>'connection'</code><span><a class="mark" href="#tls_event_connection" id="tls_event_connection">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -54814,9 +59355,9 @@ handshake begins. <code>socket</code> is typically an object of type <a href="#n
 Usually users will not want to access this event.</p>
 <p>This event can also be explicitly emitted by users to inject connections
 into the TLS server. In that case, any <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream can be passed.</p>
-<h3>Event: <code>'keylog'</code><span><a class="mark" href="#tls_event_keylog" id="tls_event_keylog">#</a></span></h3>
+<h4>Event: <code>'keylog'</code><span><a class="mark" href="#tls_event_keylog" id="tls_event_keylog">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.3.0</span>
+<span>Added in: v12.3.0, v10.20.0</span>
 </div>
 <ul>
 <li><code>line</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> Line of ASCII text, in NSS <code>SSLKEYLOGFILE</code> format.</li>
@@ -54830,14 +59371,14 @@ captured TLS traffic to be decrypted. It may be emitted multiple times for
 each socket.</p>
 <p>A typical use case is to append received lines to a common text file, which
 is later used by software (such as Wireshark) to decrypt the traffic:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> logFile = fs.createWriteStream(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, { <span class="hljs-attr">flags</span>: <span class="hljs-string">'a'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> logFile = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, { <span class="hljs-attr">flags</span>: <span class="hljs-string">'a'</span> });
 <span class="hljs-comment">// ...</span>
-server.on(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line, tlsSocket</span>) =></span> {
-  <span class="hljs-keyword">if</span> (tlsSocket.remoteAddress !== <span class="hljs-string">'...'</span>)
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line, tlsSocket</span>) =></span> {
+  <span class="hljs-keyword">if</span> (tlsSocket.<span class="hljs-property">remoteAddress</span> !== <span class="hljs-string">'...'</span>)
     <span class="hljs-keyword">return</span>; <span class="hljs-comment">// Only log keys for a particular IP</span>
-  logFile.write(line);
+  logFile.<span class="hljs-title function_">write</span>(line);
 });</code></pre>
-<h3>Event: <code>'newSession'</code><span><a class="mark" href="#tls_event_newsession" id="tls_event_newsession">#</a></span></h3>
+<h4>Event: <code>'newSession'</code><span><a class="mark" href="#tls_event_newsession" id="tls_event_newsession">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -54861,7 +59402,7 @@ invoked in order for data to be sent or received over the secure connection.</li
 </ul>
 <p>Listening for this event will have an effect only on connections established
 after the addition of the event listener.</p>
-<h3>Event: <code>'OCSPRequest'</code><span><a class="mark" href="#tls_event_ocsprequest" id="tls_event_ocsprequest">#</a></span></h3>
+<h4>Event: <code>'OCSPRequest'</code><span><a class="mark" href="#tls_event_ocsprequest" id="tls_event_ocsprequest">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.13</span>
 </div>
@@ -54901,7 +59442,7 @@ via the <code>ca</code> option when establishing the TLS connection.)</p>
 <p>Listening for this event will have an effect only on connections established
 after the addition of the event listener.</p>
 <p>An npm module like <a href="https://www.npmjs.com/package/asn1.js">asn1.js</a> may be used to parse the certificates.</p>
-<h3>Event: <code>'resumeSession'</code><span><a class="mark" href="#tls_event_resumesession" id="tls_event_resumesession">#</a></span></h3>
+<h4>Event: <code>'resumeSession'</code><span><a class="mark" href="#tls_event_resumesession" id="tls_event_resumesession">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.2</span>
 </div>
@@ -54929,14 +59470,14 @@ connection and destroy the socket.</p>
 after the addition of the event listener.</p>
 <p>The following illustrates resuming a TLS session:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> tlsSessionStore = {};
-server.on(<span class="hljs-string">'newSession'</span>, <span class="hljs-function">(<span class="hljs-params">id, data, cb</span>) =></span> {
-  tlsSessionStore[id.toString(<span class="hljs-string">'hex'</span>)] = data;
-  cb();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'newSession'</span>, <span class="hljs-function">(<span class="hljs-params">id, data, cb</span>) =></span> {
+  tlsSessionStore[id.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>)] = data;
+  <span class="hljs-title function_">cb</span>();
 });
-server.on(<span class="hljs-string">'resumeSession'</span>, <span class="hljs-function">(<span class="hljs-params">id, cb</span>) =></span> {
-  cb(<span class="hljs-literal">null</span>, tlsSessionStore[id.toString(<span class="hljs-string">'hex'</span>)] || <span class="hljs-literal">null</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'resumeSession'</span>, <span class="hljs-function">(<span class="hljs-params">id, cb</span>) =></span> {
+  <span class="hljs-title function_">cb</span>(<span class="hljs-literal">null</span>, tlsSessionStore[id.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>)] || <span class="hljs-literal">null</span>);
 });</code></pre>
-<h3>Event: <code>'secureConnection'</code><span><a class="mark" href="#tls_event_secureconnection" id="tls_event_secureconnection">#</a></span></h3>
+<h4>Event: <code>'secureConnection'</code><span><a class="mark" href="#tls_event_secureconnection" id="tls_event_secureconnection">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -54956,7 +59497,7 @@ ALPN protocol. When ALPN has no selected protocol, <code>tlsSocket.alpnProtocol<
 equals <code>false</code>.</p>
 <p>The <code>tlsSocket.servername</code> property is a string containing the server name
 requested via SNI.</p>
-<h3>Event: <code>'tlsClientError'</code><span><a class="mark" href="#tls_event_tlsclienterror" id="tls_event_tlsclienterror">#</a></span></h3>
+<h4>Event: <code>'tlsClientError'</code><span><a class="mark" href="#tls_event_tlsclienterror" id="tls_event_tlsclienterror">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -54968,7 +59509,7 @@ called:</p>
 <li><code>tlsSocket</code> <a href="#tls_class_tls_tlssocket" class="type">&#x3C;tls.TLSSocket></a> The <code>tls.TLSSocket</code> instance from which the
 error originated.</li>
 </ul>
-<h3><code>server.addContext(hostname, context)</code><span><a class="mark" href="#tls_server_addcontext_hostname_context" id="tls_server_addcontext_hostname_context">#</a></span></h3>
+<h4><code>server.addContext(hostname, context)</code><span><a class="mark" href="#tls_server_addcontext_hostname_context" id="tls_server_addcontext_hostname_context">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.3</span>
 </div>
@@ -54980,7 +59521,7 @@ from the <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureCo
 </ul>
 <p>The <code>server.addContext()</code> method adds a secure context that will be used if
 the client request's SNI name matches the supplied <code>hostname</code> (or wildcard).</p>
-<h3><code>server.address()</code><span><a class="mark" href="#tls_server_address" id="tls_server_address">#</a></span></h3>
+<h4><code>server.address()</code><span><a class="mark" href="#tls_server_address" id="tls_server_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span>
 </div>
@@ -54990,7 +59531,7 @@ the client request's SNI name matches the supplied <code>hostname</code> (or wil
 <p>Returns the bound address, the address family name, and port of the
 server as reported by the operating system. See <a href="#net_server_address"><code>net.Server.address()</code></a> for
 more information.</p>
-<h3><code>server.close([callback])</code><span><a class="mark" href="#tls_server_close_callback" id="tls_server_close_callback">#</a></span></h3>
+<h4><code>server.close([callback])</code><span><a class="mark" href="#tls_server_close_callback" id="tls_server_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -55002,7 +59543,7 @@ for the server instance's <code>'close'</code> event.</li>
 <p>The <code>server.close()</code> method stops the server from accepting new connections.</p>
 <p>This function operates asynchronously. The <code>'close'</code> event will be emitted
 when the server has no more open connections.</p>
-<h3><code>server.connections</code><span><a class="mark" href="#tls_server_connections" id="tls_server_connections">#</a></span></h3>
+<h4><code>server.connections</code><span><a class="mark" href="#tls_server_connections" id="tls_server_connections">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span><span>Deprecated since: v0.9.7</span>
 </div>
@@ -55011,7 +59552,7 @@ when the server has no more open connections.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Returns the current number of concurrent connections on the server.</p>
-<h3><code>server.getTicketKeys()</code><span><a class="mark" href="#tls_server_getticketkeys" id="tls_server_getticketkeys">#</a></span></h3>
+<h4><code>server.getTicketKeys()</code><span><a class="mark" href="#tls_server_getticketkeys" id="tls_server_getticketkeys">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
@@ -55020,10 +59561,10 @@ when the server has no more open connections.</p>
 </ul>
 <p>Returns the session ticket keys.</p>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
-<h3><code>server.listen()</code><span><a class="mark" href="#tls_server_listen" id="tls_server_listen">#</a></span></h3>
+<h4><code>server.listen()</code><span><a class="mark" href="#tls_server_listen" id="tls_server_listen">#</a></span></h4>
 <p>Starts the server listening for encrypted connections.
 This method is identical to <a href="#net_server_listen"><code>server.listen()</code></a> from <a href="#net_class_net_server"><code>net.Server</code></a>.</p>
-<h3><code>server.setSecureContext(options)</code><span><a class="mark" href="#tls_server_setsecurecontext_options" id="tls_server_setsecurecontext_options">#</a></span></h3>
+<h4><code>server.setSecureContext(options)</code><span><a class="mark" href="#tls_server_setsecurecontext_options" id="tls_server_setsecurecontext_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
@@ -55034,18 +59575,19 @@ the <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext
 </ul>
 <p>The <code>server.setSecureContext()</code> method replaces the secure context of an
 existing server. Existing connections to the server are not interrupted.</p>
-<h3><code>server.setTicketKeys(keys)</code><span><a class="mark" href="#tls_server_setticketkeys_keys" id="tls_server_setticketkeys_keys">#</a></span></h3>
+<h4><code>server.setTicketKeys(keys)</code><span><a class="mark" href="#tls_server_setticketkeys_keys" id="tls_server_setticketkeys_keys">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
 <ul>
-<li><code>keys</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> A 48-byte buffer containing the session ticket keys.</li>
+<li><code>keys</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A 48-byte buffer containing the session
+ticket keys.</li>
 </ul>
 <p>Sets the session ticket keys.</p>
 <p>Changes to the ticket keys are effective only for future server connections.
 Existing or currently pending server connections will use the previous keys.</p>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
-<h2>Class: <code>tls.TLSSocket</code><span><a class="mark" href="#tls_class_tls_tlssocket" id="tls_class_tls_tlssocket">#</a></span></h2>
+</section><section><h3>Class: <code>tls.TLSSocket</code><span><a class="mark" href="#tls_class_tls_tlssocket" id="tls_class_tls_tlssocket">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55058,7 +59600,7 @@ negotiation.</p>
 <p>Methods that return TLS connection metadata (e.g.
 <a href="#tls_tlssocket_getpeercertificate_detailed"><code>tls.TLSSocket.getPeerCertificate()</code></a> will only return data while the
 connection is open.</p>
-<h3><code>new tls.TLSSocket(socket[, options])</code><span><a class="mark" href="#tls_new_tls_tlssocket_socket_options" id="tls_new_tls_tlssocket_socket_options">#</a></span></h3>
+<h4><code>new tls.TLSSocket(socket[, options])</code><span><a class="mark" href="#tls_new_tls_tlssocket_socket_options" id="tls_new_tls_tlssocket_socket_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -55105,9 +59647,9 @@ will be created by passing the entire <code>options</code> object to
 </li>
 </ul>
 <p>Construct a new <code>tls.TLSSocket</code> object from an existing TCP socket.</p>
-<h3>Event: <code>'keylog'</code><span><a class="mark" href="#tls_event_keylog_1" id="tls_event_keylog_1">#</a></span></h3>
+<h4>Event: <code>'keylog'</code><span><a class="mark" href="#tls_event_keylog_1" id="tls_event_keylog_1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.3.0</span>
+<span>Added in: v12.3.0, v10.20.0</span>
 </div>
 <ul>
 <li><code>line</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> Line of ASCII text, in NSS <code>SSLKEYLOGFILE</code> format.</li>
@@ -55118,10 +59660,10 @@ for debugging, as it allows captured TLS traffic to be decrypted. It may
 be emitted multiple times, before or after the handshake completes.</p>
 <p>A typical use case is to append received lines to a common text file, which
 is later used by software (such as Wireshark) to decrypt the traffic:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> logFile = fs.createWriteStream(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, { <span class="hljs-attr">flags</span>: <span class="hljs-string">'a'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> logFile = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, { <span class="hljs-attr">flags</span>: <span class="hljs-string">'a'</span> });
 <span class="hljs-comment">// ...</span>
-tlsSocket.on(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> logFile.write(line));</code></pre>
-<h3>Event: <code>'OCSPResponse'</code><span><a class="mark" href="#tls_event_ocspresponse" id="tls_event_ocspresponse">#</a></span></h3>
+tlsSocket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> logFile.<span class="hljs-title function_">write</span>(line));</code></pre>
+<h4>Event: <code>'OCSPResponse'</code><span><a class="mark" href="#tls_event_ocspresponse" id="tls_event_ocspresponse">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.13</span>
 </div>
@@ -55133,7 +59675,7 @@ The listener callback is passed a single argument when called:</p>
 </ul>
 <p>Typically, the <code>response</code> is a digitally signed object from the server's CA that
 contains information about server's certificate revocation status.</p>
-<h3>Event: <code>'secureConnect'</code><span><a class="mark" href="#tls_event_secureconnect" id="tls_event_secureconnect">#</a></span></h3>
+<h4>Event: <code>'secureConnect'</code><span><a class="mark" href="#tls_event_secureconnect" id="tls_event_secureconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55146,7 +59688,9 @@ determine if the server certificate was signed by one of the specified CAs. If
 <code>tlsSocket.authorizationError</code> property. If ALPN was used, the
 <code>tlsSocket.alpnProtocol</code> property can be checked to determine the negotiated
 protocol.</p>
-<h3>Event: <code>'session'</code><span><a class="mark" href="#tls_event_session" id="tls_event_session">#</a></span></h3>
+<p>The <code>'secureConnect'</code> event is not emitted when a <a href="#tls_class_tls_tlssocket" class="type">&#x3C;tls.TLSSocket></a> is created
+using the <code>new tls.TLSSocket()</code> constructor.</p>
+<h4>Event: <code>'session'</code><span><a class="mark" href="#tls_event_session" id="tls_event_session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
 </div>
@@ -55171,14 +59715,14 @@ after the handshake completes. So it is necessary to wait for the
 should use the <code>'session'</code> event instead of <code>getSession()</code> to ensure
 they will work for all TLS versions. Applications that only expect to
 get or use one session should listen for this event only once:</p>
-<pre><code class="language-js">tlsSocket.once(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
+<pre><code class="language-js">tlsSocket.<span class="hljs-title function_">once</span>(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
   <span class="hljs-comment">// The session can be used immediately or later.</span>
-  tls.connect({
+  tls.<span class="hljs-title function_">connect</span>({
     <span class="hljs-attr">session</span>: session,
     <span class="hljs-comment">// Other connect options...</span>
   });
 });</code></pre>
-<h3><code>tlsSocket.address()</code><span><a class="mark" href="#tls_tlssocket_address" id="tls_tlssocket_address">#</a></span></h3>
+<h4><code>tlsSocket.address()</code><span><a class="mark" href="#tls_tlssocket_address" id="tls_tlssocket_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55188,13 +59732,13 @@ get or use one session should listen for this event only once:</p>
 <p>Returns the bound <code>address</code>, the address <code>family</code> name, and <code>port</code> of the
 underlying socket as reported by the operating system:
 <code>{ port: 12346, family: 'IPv4', address: '127.0.0.1' }</code>.</p>
-<h3><code>tlsSocket.authorizationError</code><span><a class="mark" href="#tls_tlssocket_authorizationerror" id="tls_tlssocket_authorizationerror">#</a></span></h3>
+<h4><code>tlsSocket.authorizationError</code><span><a class="mark" href="#tls_tlssocket_authorizationerror" id="tls_tlssocket_authorizationerror">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
 <p>Returns the reason why the peer's certificate was not been verified. This
 property is set only when <code>tlsSocket.authorized === false</code>.</p>
-<h3><code>tlsSocket.authorized</code><span><a class="mark" href="#tls_tlssocket_authorized" id="tls_tlssocket_authorized">#</a></span></h3>
+<h4><code>tlsSocket.authorized</code><span><a class="mark" href="#tls_tlssocket_authorized" id="tls_tlssocket_authorized">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55203,13 +59747,13 @@ property is set only when <code>tlsSocket.authorized === false</code>.</p>
 </ul>
 <p>Returns <code>true</code> if the peer certificate was signed by one of the CAs specified
 when creating the <code>tls.TLSSocket</code> instance, otherwise <code>false</code>.</p>
-<h3><code>tlsSocket.disableRenegotiation()</code><span><a class="mark" href="#tls_tlssocket_disablerenegotiation" id="tls_tlssocket_disablerenegotiation">#</a></span></h3>
+<h4><code>tlsSocket.disableRenegotiation()</code><span><a class="mark" href="#tls_tlssocket_disablerenegotiation" id="tls_tlssocket_disablerenegotiation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>Disables TLS renegotiation for this <code>TLSSocket</code> instance. Once called, attempts
 to renegotiate will trigger an <code>'error'</code> event on the <code>TLSSocket</code>.</p>
-<h3><code>tlsSocket.enableTrace()</code><span><a class="mark" href="#tls_tlssocket_enabletrace" id="tls_tlssocket_enabletrace">#</a></span></h3>
+<h4><code>tlsSocket.enableTrace()</code><span><a class="mark" href="#tls_tlssocket_enabletrace" id="tls_tlssocket_enabletrace">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.2.0</span>
 </div>
@@ -55218,13 +59762,13 @@ used to debug TLS connection problems.</p>
 <p>Note: The format of the output is identical to the output of <code>openssl s_client -trace</code> or <code>openssl s_server -trace</code>. While it is produced by OpenSSL's
 <code>SSL_trace()</code> function, the format is undocumented, can change without notice,
 and should not be relied on.</p>
-<h3><code>tlsSocket.encrypted</code><span><a class="mark" href="#tls_tlssocket_encrypted" id="tls_tlssocket_encrypted">#</a></span></h3>
+<h4><code>tlsSocket.encrypted</code><span><a class="mark" href="#tls_tlssocket_encrypted" id="tls_tlssocket_encrypted">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
 <p>Always returns <code>true</code>. This may be used to distinguish TLS sockets from regular
 <code>net.Socket</code> instances.</p>
-<h3><code>tlsSocket.getCertificate()</code><span><a class="mark" href="#tls_tlssocket_getcertificate" id="tls_tlssocket_getcertificate">#</a></span></h3>
+<h4><code>tlsSocket.getCertificate()</code><span><a class="mark" href="#tls_tlssocket_getcertificate" id="tls_tlssocket_getcertificate">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.2.0</span>
 </div>
@@ -55237,12 +59781,12 @@ some properties corresponding to the fields of the certificate.</p>
 structure.</p>
 <p>If there is no local certificate, an empty object will be returned. If the
 socket has been destroyed, <code>null</code> will be returned.</p>
-<h3><code>tlsSocket.getCipher()</code><span><a class="mark" href="#tls_tlssocket_getcipher" id="tls_tlssocket_getcipher">#</a></span></h3>
+<h4><code>tlsSocket.getCipher()</code><span><a class="mark" href="#tls_tlssocket_getcipher" id="tls_tlssocket_getcipher">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.4.0, v12.16.0</td>
 <td><p>Return the IETF cipher name as <code>standardName</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Return the minimum cipher version, instead of a fixed string (<code>'TLSv1/SSLv3'</code>).</p></td></tr>
@@ -55263,15 +59807,15 @@ suite.</li>
 </ul>
 <p>Returns an object containing information on the negotiated cipher suite.</p>
 <p>For example:</p>
-<pre><code class="language-json">{
-    <span class="hljs-attr">"name"</span>: <span class="hljs-string">"AES128-SHA256"</span>,
-    <span class="hljs-attr">"standardName"</span>: <span class="hljs-string">"TLS_RSA_WITH_AES_128_CBC_SHA256"</span>,
-    <span class="hljs-attr">"version"</span>: <span class="hljs-string">"TLSv1.2"</span>
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"AES128-SHA256"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"standardName"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"TLS_RSA_WITH_AES_128_CBC_SHA256"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"version"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"TLSv1.2"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>See
 <a href="https://www.openssl.org/docs/man1.1.1/man3/SSL_CIPHER_get_name.html">SSL_CIPHER_get_name</a>
 for more information.</p>
-<h3><code>tlsSocket.getEphemeralKeyInfo()</code><span><a class="mark" href="#tls_tlssocket_getephemeralkeyinfo" id="tls_tlssocket_getephemeralkeyinfo">#</a></span></h3>
+<h4><code>tlsSocket.getEphemeralKeyInfo()</code><span><a class="mark" href="#tls_tlssocket_getephemeralkeyinfo" id="tls_tlssocket_getephemeralkeyinfo">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.0.0</span>
 </div>
@@ -55285,7 +59829,7 @@ ephemeral. As this is only supported on a client socket; <code>null</code> is re
 if called on a server socket. The supported types are <code>'DH'</code> and <code>'ECDH'</code>. The
 <code>name</code> property is available only when type is <code>'ECDH'</code>.</p>
 <p>For example: <code>{ type: 'ECDH', name: 'prime256v1', size: 256 }</code>.</p>
-<h3><code>tlsSocket.getFinished()</code><span><a class="mark" href="#tls_tlssocket_getfinished" id="tls_tlssocket_getfinished">#</a></span></h3>
+<h4><code>tlsSocket.getFinished()</code><span><a class="mark" href="#tls_tlssocket_getfinished" id="tls_tlssocket_getfinished">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.9.0</span>
 </div>
@@ -55300,7 +59844,7 @@ be used for external authentication procedures when the authentication
 provided by SSL/TLS is not desired or is not enough.</p>
 <p>Corresponds to the <code>SSL_get_finished</code> routine in OpenSSL and may be used
 to implement the <code>tls-unique</code> channel binding from <a href="https://tools.ietf.org/html/rfc5929">RFC 5929</a>.</p>
-<h3><code>tlsSocket.getPeerCertificate([detailed])</code><span><a class="mark" href="#tls_tlssocket_getpeercertificate_detailed" id="tls_tlssocket_getpeercertificate_detailed">#</a></span></h3>
+<h4><code>tlsSocket.getPeerCertificate([detailed])</code><span><a class="mark" href="#tls_tlssocket_getpeercertificate_detailed" id="tls_tlssocket_getpeercertificate_detailed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55315,7 +59859,7 @@ destroyed, <code>null</code> will be returned.</p>
 <p>If the full certificate chain was requested, each certificate will include an
 <code>issuerCertificate</code> property containing an object representing its issuer's
 certificate.</p>
-<h4>Certificate object<span><a class="mark" href="#tls_certificate_object" id="tls_certificate_object">#</a></span></h4>
+<h5>Certificate object<span><a class="mark" href="#tls_certificate_object" id="tls_certificate_object">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -55330,28 +59874,28 @@ certificate.</p>
 <ul>
 <li><code>raw</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The DER encoded X.509 certificate data.</li>
 <li><code>subject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The certificate subject, described in terms of
- Country (<code>C:</code>), StateOrProvince (<code>ST</code>), Locality (<code>L</code>), Organization (<code>O</code>),
+Country (<code>C:</code>), StateOrProvince (<code>ST</code>), Locality (<code>L</code>), Organization (<code>O</code>),
 OrganizationalUnit (<code>OU</code>), and CommonName (<code>CN</code>). The CommonName is typically
 a DNS name with TLS certificates. Example:
 <code>{C: 'UK', ST: 'BC', L: 'Metro', O: 'Node Fans', OU: 'Docs', CN: 'example.com'}</code>.</li>
 <li><code>issuer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The certificate issuer, described in the same terms as the
- <code>subject</code>.</li>
+<code>subject</code>.</li>
 <li><code>valid_from</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The date-time the certificate is valid from.</li>
 <li><code>valid_to</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The date-time the certificate is valid to.</li>
 <li><code>serialNumber</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The certificate serial number, as a hex string.
- Example: <code>'B9B0D332A1AA5635'</code>.</li>
+Example: <code>'B9B0D332A1AA5635'</code>.</li>
 <li><code>fingerprint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The SHA-1 digest of the DER encoded certificate. It is
 returned as a <code>:</code> separated hexadecimal string. Example: <code>'2A:7A:C2:DD:...'</code>.</li>
 <li><code>fingerprint256</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The SHA-256 digest of the DER encoded certificate.
- It is returned as a <code>:</code> separated hexadecimal string. Example:
+It is returned as a <code>:</code> separated hexadecimal string. Example:
 <code>'2A:7A:C2:DD:...'</code>.</li>
 <li><code>ext_key_usage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> (Optional) The extended key usage, a set of OIDs.</li>
 <li><code>subjectaltname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> (Optional) A string containing concatenated names
 for the subject, an alternative to the <code>subject</code> names.</li>
 <li><code>infoAccess</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> (Optional) An array describing the AuthorityInfoAccess,
- used with OCSP.</li>
+used with OCSP.</li>
 <li><code>issuerCertificate</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> (Optional) The issuer certificate object. For
- self-signed certificates, this may be a circular reference.</li>
+self-signed certificates, this may be a circular reference.</li>
 </ul>
 <p>The certificate may contain information about the public key, depending on
 the key type.</p>
@@ -55361,7 +59905,7 @@ the key type.</p>
 <li><code>exponent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The RSA exponent, as a string in hexadecimal number
 notation. Example: <code>'0x010001'</code>.</li>
 <li><code>modulus</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The RSA modulus, as a hexadecimal string. Example:
- <code>'B56CE45CB7...'</code>.</li>
+<code>'B56CE45CB7...'</code>.</li>
 <li><code>pubkey</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> The public key.</li>
 </ul>
 <p>For EC keys, the following properties may be defined:</p>
@@ -55402,7 +59946,7 @@ has one (not all well-known curves have been assigned names by NIST). Example:
   ext_key_usage: [ '1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2' ],
   serialNumber: '66593D57F20CBC573E433381B5FEC280',
   raw: &#x3C;Buffer ... > }</code></pre>
-<h3><code>tlsSocket.getPeerFinished()</code><span><a class="mark" href="#tls_tlssocket_getpeerfinished" id="tls_tlssocket_getpeerfinished">#</a></span></h3>
+<h4><code>tlsSocket.getPeerFinished()</code><span><a class="mark" href="#tls_tlssocket_getpeerfinished" id="tls_tlssocket_getpeerfinished">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.9.0</span>
 </div>
@@ -55417,7 +59961,7 @@ be used for external authentication procedures when the authentication
 provided by SSL/TLS is not desired or is not enough.</p>
 <p>Corresponds to the <code>SSL_get_peer_finished</code> routine in OpenSSL and may be used
 to implement the <code>tls-unique</code> channel binding from <a href="https://tools.ietf.org/html/rfc5929">RFC 5929</a>.</p>
-<h3><code>tlsSocket.getProtocol()</code><span><a class="mark" href="#tls_tlssocket_getprotocol" id="tls_tlssocket_getprotocol">#</a></span></h3>
+<h4><code>tlsSocket.getProtocol()</code><span><a class="mark" href="#tls_tlssocket_getprotocol" id="tls_tlssocket_getprotocol">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.7.0</span>
 </div>
@@ -55437,7 +59981,7 @@ be returned for server sockets or disconnected client sockets.</p>
 <li><code>'TLSv1.3'</code></li>
 </ul>
 <p>See the OpenSSL <a href="https://www.openssl.org/docs/man1.1.1/man3/SSL_get_version.html"><code>SSL_get_version</code></a> documentation for more information.</p>
-<h3><code>tlsSocket.getSession()</code><span><a class="mark" href="#tls_tlssocket_getsession" id="tls_tlssocket_getsession">#</a></span></h3>
+<h4><code>tlsSocket.getSession()</code><span><a class="mark" href="#tls_tlssocket_getsession" id="tls_tlssocket_getsession">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55451,7 +59995,7 @@ for debugging.</p>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
 <p>Note: <code>getSession()</code> works only for TLSv1.2 and below. For TLSv1.3, applications
 must use the <a href="#tls_event_session"><code>'session'</code></a> event (it also works for TLSv1.2 and below).</p>
-<h3><code>tlsSocket.getSharedSigalgs()</code><span><a class="mark" href="#tls_tlssocket_getsharedsigalgs" id="tls_tlssocket_getsharedsigalgs">#</a></span></h3>
+<h4><code>tlsSocket.getSharedSigalgs()</code><span><a class="mark" href="#tls_tlssocket_getsharedsigalgs" id="tls_tlssocket_getsharedsigalgs">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.11.0</span>
 </div>
@@ -55462,9 +60006,9 @@ the client in the order of decreasing preference.</li>
 <p>See
 <a href="https://www.openssl.org/docs/man1.1.1/man3/SSL_get_shared_sigalgs.html">SSL_get_shared_sigalgs</a>
 for more information.</p>
-<h3><code>tlsSocket.exportKeyingMaterial(length, label[, context])</code><span><a class="mark" href="#tls_tlssocket_exportkeyingmaterial_length_label_context" id="tls_tlssocket_exportkeyingmaterial_length_label_context">#</a></span></h3>
+<h4><code>tlsSocket.exportKeyingMaterial(length, label[, context])</code><span><a class="mark" href="#tls_tlssocket_exportkeyingmaterial_length_label_context" id="tls_tlssocket_exportkeyingmaterial_length_label_context">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <ul>
 <li>
@@ -55485,7 +60029,7 @@ value from the
 <p>Keying material is used for validations to prevent different kind of attacks in
 network protocols, for example in the specifications of IEEE 802.1X.</p>
 <p>Example</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> keyingMaterial = tlsSocket.exportKeyingMaterial(
+<pre><code class="language-js"><span class="hljs-keyword">const</span> keyingMaterial = tlsSocket.<span class="hljs-title function_">exportKeyingMaterial</span>(
   <span class="hljs-number">128</span>,
   <span class="hljs-string">'client finished'</span>);
 
@@ -55497,7 +60041,7 @@ network protocols, for example in the specifications of IEEE 802.1X.</p>
 */</span></code></pre>
 <p>See the OpenSSL <a href="https://www.openssl.org/docs/man1.1.1/man3/SSL_export_keying_material.html"><code>SSL_export_keying_material</code></a> documentation for more
 information.</p>
-<h3><code>tlsSocket.getTLSTicket()</code><span><a class="mark" href="#tls_tlssocket_gettlsticket" id="tls_tlssocket_gettlsticket">#</a></span></h3>
+<h4><code>tlsSocket.getTLSTicket()</code><span><a class="mark" href="#tls_tlssocket_gettlsticket" id="tls_tlssocket_gettlsticket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55508,7 +60052,7 @@ information.</p>
 <code>undefined</code>. For a server, always returns <code>undefined</code>.</p>
 <p>It may be useful for debugging.</p>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
-<h3><code>tlsSocket.isSessionReused()</code><span><a class="mark" href="#tls_tlssocket_issessionreused" id="tls_tlssocket_issessionreused">#</a></span></h3>
+<h4><code>tlsSocket.isSessionReused()</code><span><a class="mark" href="#tls_tlssocket_issessionreused" id="tls_tlssocket_issessionreused">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.6</span>
 </div>
@@ -55516,7 +60060,7 @@ information.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the session was reused, <code>false</code> otherwise.</li>
 </ul>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
-<h3><code>tlsSocket.localAddress</code><span><a class="mark" href="#tls_tlssocket_localaddress" id="tls_tlssocket_localaddress">#</a></span></h3>
+<h4><code>tlsSocket.localAddress</code><span><a class="mark" href="#tls_tlssocket_localaddress" id="tls_tlssocket_localaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55524,7 +60068,7 @@ information.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Returns the string representation of the local IP address.</p>
-<h3><code>tlsSocket.localPort</code><span><a class="mark" href="#tls_tlssocket_localport" id="tls_tlssocket_localport">#</a></span></h3>
+<h4><code>tlsSocket.localPort</code><span><a class="mark" href="#tls_tlssocket_localport" id="tls_tlssocket_localport">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55532,7 +60076,7 @@ information.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Returns the numeric representation of the local port.</p>
-<h3><code>tlsSocket.remoteAddress</code><span><a class="mark" href="#tls_tlssocket_remoteaddress" id="tls_tlssocket_remoteaddress">#</a></span></h3>
+<h4><code>tlsSocket.remoteAddress</code><span><a class="mark" href="#tls_tlssocket_remoteaddress" id="tls_tlssocket_remoteaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55541,7 +60085,7 @@ information.</p>
 </ul>
 <p>Returns the string representation of the remote IP address. For example,
 <code>'74.125.127.100'</code> or <code>'2001:4860:a005::68'</code>.</p>
-<h3><code>tlsSocket.remoteFamily</code><span><a class="mark" href="#tls_tlssocket_remotefamily" id="tls_tlssocket_remotefamily">#</a></span></h3>
+<h4><code>tlsSocket.remoteFamily</code><span><a class="mark" href="#tls_tlssocket_remotefamily" id="tls_tlssocket_remotefamily">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55549,7 +60093,7 @@ information.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Returns the string representation of the remote IP family. <code>'IPv4'</code> or <code>'IPv6'</code>.</p>
-<h3><code>tlsSocket.remotePort</code><span><a class="mark" href="#tls_tlssocket_remoteport" id="tls_tlssocket_remoteport">#</a></span></h3>
+<h4><code>tlsSocket.remotePort</code><span><a class="mark" href="#tls_tlssocket_remoteport" id="tls_tlssocket_remoteport">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -55557,7 +60101,7 @@ information.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Returns the numeric representation of the remote port. For example, <code>443</code>.</p>
-<h3><code>tlsSocket.renegotiate(options, callback)</code><span><a class="mark" href="#tls_tlssocket_renegotiate_options_callback" id="tls_tlssocket_renegotiate_options_callback">#</a></span></h3>
+<h4><code>tlsSocket.renegotiate(options, callback)</code><span><a class="mark" href="#tls_tlssocket_renegotiate_options_callback" id="tls_tlssocket_renegotiate_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -55592,7 +60136,7 @@ connection has been established.</p>
 <code>handshakeTimeout</code> timeout.</p>
 <p>For TLSv1.3, renegotiation cannot be initiated, it is not supported by the
 protocol.</p>
-<h3><code>tlsSocket.setMaxSendFragment(size)</code><span><a class="mark" href="#tls_tlssocket_setmaxsendfragment_size" id="tls_tlssocket_setmaxsendfragment_size">#</a></span></h3>
+<h4><code>tlsSocket.setMaxSendFragment(size)</code><span><a class="mark" href="#tls_tlssocket_setmaxsendfragment_size" id="tls_tlssocket_setmaxsendfragment_size">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.11</span>
 </div>
@@ -55609,9 +60153,17 @@ and its integrity is verified; large fragments can span multiple roundtrips
 and their processing can be delayed due to packet loss or reordering. However,
 smaller fragments add extra TLS framing bytes and CPU overhead, which may
 decrease overall server throughput.</p>
-<h2><code>tls.checkServerIdentity(hostname, cert)</code><span><a class="mark" href="#tls_tls_checkserveridentity_hostname_cert" id="tls_tls_checkserveridentity_hostname_cert">#</a></span></h2>
+</section><section><h3><code>tls.checkServerIdentity(hostname, cert)</code><span><a class="mark" href="#tls_tls_checkserveridentity_hostname_cert" id="tls_tls_checkserveridentity_hostname_cert">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.8.4</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.3</td>
+<td><p>Support for <code>uniformResourceIdentifier</code> subject alternative names has been disabled in response to CVE-2021-44531.</p></td></tr>
+<tr><td>v0.8.4</td>
+<td><p><span>Added in: v0.8.4</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The host name or IP address to verify the certificate
@@ -55628,12 +60180,21 @@ overwriting function can call <code>tls.checkServerIdentity()</code> of course,
 the checks done with additional verification.</p>
 <p>This function is only called if the certificate passed all other checks, such as
 being issued by trusted CA (<code>options.ca</code>).</p>
-<h2><code>tls.connect(options[, callback])</code><span><a class="mark" href="#tls_tls_connect_options_callback" id="tls_tls_connect_options_callback">#</a></span></h2>
+<p>Earlier versions of Node.js incorrectly accepted certificates for a given
+<code>hostname</code> if a matching <code>uniformResourceIdentifier</code> subject alternative name
+was present (see <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531">CVE-2021-44531</a>). Applications that wish to accept
+<code>uniformResourceIdentifier</code> subject alternative names can use a custom
+<code>options.checkServerIdentity</code> function that implements the desired behavior.</p>
+</section><section><h3><code>tls.connect(options[, callback])</code><span><a class="mark" href="#tls_tls_connect_options_callback" id="tls_tls_connect_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v14.18.0</td>
+<td><p>Added <code>onread</code> option.</p></td></tr>
+<tr><td>v14.1.0</td>
+<td><p>The <code>highWaterMark</code> option is accepted now.</p></td></tr>
+<tr><td>v13.6.0, v12.16.0</td>
 <td><p>The <code>pskCallback</code> option is now supported.</p></td></tr>
 <tr><td>v12.9.0</td>
 <td><p>Support the <code>allowHalfOpen</code> option.</p></td></tr>
@@ -55641,16 +60202,16 @@ being issued by trusted CA (<code>options.ca</code>).</p>
 <td><p>The <code>hints</code> option is now supported.</p></td></tr>
 <tr><td>v12.2.0</td>
 <td><p>The <code>enableTrace</code> option is now supported.</p></td></tr>
-<tr><td>v11.8.0</td>
+<tr><td>v11.8.0, v10.16.0</td>
 <td><p>The <code>timeout</code> option is supported now.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>lookup</code> option is supported now.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>ALPNProtocols</code> option can be a <code>TypedArray</code> or <code>DataView</code> now.</p></td></tr>
-<tr><td>v5.3.0, v4.7.0</td>
-<td><p>The <code>secureContext</code> option is supported now.</p></td></tr>
 <tr><td>v5.0.0</td>
 <td><p>ALPN options are supported now.</p></td></tr>
+<tr><td>v5.3.0, v4.7.0</td>
+<td><p>The <code>secureContext</code> option is supported now.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p><span>Added in: v0.11.3</span></p></td></tr>
 </tbody></table>
@@ -55674,10 +60235,10 @@ when passed to <code>tls.connect()</code>, but it can be connected later.
 Connection/disconnection/destruction of <code>socket</code> is the user's
 responsibility; calling <code>tls.connect()</code> will not cause <code>net.connect()</code> to be
 called.</li>
-<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If the <code>socket</code> option is missing, indicates
-whether or not to allow the internally created socket to be half-open,
-otherwise the option is ignored. See the <code>allowHalfOpen</code> option of
-<a href="#net_class_net_socket"><code>net.Socket</code></a> for details. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If set to <code>false</code>, then the socket will
+automatically end the writable side when the readable side ends. If the
+<code>socket</code> option is set, this option has no effect. See the <code>allowHalfOpen</code>
+option of <a href="#net_class_net_socket"><code>net.Socket</code></a> for details. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>rejectUnauthorized</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If not <code>false</code>, the server certificate is
 verified against the list of supplied CAs. An <code>'error'</code> event is emitted if
 verification fails; <code>err.code</code> contains the OpenSSL error code. <strong>Default:</strong>
@@ -55688,10 +60249,11 @@ verification fails; <code>err.code</code> contains the OpenSSL error code. <stro
 decide which identity to use during negotiation.
 Always <code>null</code> if TLS 1.3 is used.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> in the form
-  <code>{ psk: &#x3C;Buffer|TypedArray|DataView>, identity: &#x3C;string> }</code>
+<code>{ psk: &#x3C;Buffer|TypedArray|DataView>, identity: &#x3C;string> }</code>
 or <code>null</code> to stop the negotiation process. <code>psk</code> must be
 compatible with the selected cipher's digest.
-<code>identity</code> must use UTF-8 encoding.
+<code>identity</code> must use UTF-8 encoding.</li>
+</ul>
 When negotiating TLS-PSK (pre-shared keys), this function is called
 with optional identity <code>hint</code> provided by the server or <code>null</code>
 in case of TLS 1.3 where <code>hint</code> was removed.
@@ -55700,8 +60262,6 @@ for the connection as the default one will try to check host name/IP
 of the server against the certificate but that's not applicable for PSK
 because there won't be a certificate present.
 More information can be found in the <a href="https://tools.ietf.org/html/rfc4279">RFC 4279</a>.</li>
-</ul>
-</li>
 <li><code>ALPNProtocols</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a> | <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a>
 An array of strings, <code>Buffer</code>s or <code>TypedArray</code>s or <code>DataView</code>s, or a
 single <code>Buffer</code> or <code>TypedArray</code> or <code>DataView</code> containing the supported ALPN
@@ -55726,10 +60286,16 @@ and <code>cert</code> are verified.</li>
 TLS connection. When a server offers a DH parameter with a size less
 than <code>minDHSize</code>, the TLS connection is destroyed and an error is thrown.
 <strong>Default:</strong> <code>1024</code>.</li>
+<li><code>highWaterMark</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Consistent with the readable stream <code>highWaterMark</code> parameter.
+<strong>Default:</strong> <code>16 * 1024</code>.</li>
 <li><code>secureContext</code>: TLS context object created with
 <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a>. If a <code>secureContext</code> is <em>not</em> provided, one
 will be created by passing the entire <code>options</code> object to
 <code>tls.createSecureContext()</code>.</li>
+<li><code>onread</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> If the <code>socket</code> option is missing, incoming data is
+stored in a single <code>buffer</code> and passed to the supplied <code>callback</code> when
+data arrives on the socket, otherwise the option is ignored. See the
+<code>onread</code> option of <a href="#net_class_net_socket"><code>net.Socket</code></a> for details.</li>
 <li>...: <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a> options that are used if the
 <code>secureContext</code> option is missing, otherwise they are ignored.</li>
 <li>...: Any <a href="#net_socket_connect_options_connectlistener"><code>socket.connect()</code></a> option not already listed.</li>
@@ -55754,30 +60320,30 @@ to <code>host</code>.</p>
 
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-comment">// Necessary only if the server requires client certificate authentication.</span>
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'client-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'client-cert.pem'</span>),
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'client-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'client-cert.pem'</span>),
 
   <span class="hljs-comment">// Necessary only if the server uses a self-signed certificate.</span>
-  <span class="hljs-attr">ca</span>: [ fs.readFileSync(<span class="hljs-string">'server-cert.pem'</span>) ],
+  <span class="hljs-attr">ca</span>: [ fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-cert.pem'</span>) ],
 
   <span class="hljs-comment">// Necessary only if the server's cert isn't for "localhost".</span>
   <span class="hljs-attr">checkServerIdentity</span>: <span class="hljs-function">() =></span> { <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>; },
 };
 
-<span class="hljs-keyword">const</span> socket = tls.connect(<span class="hljs-number">8000</span>, options, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'client connected'</span>,
-              socket.authorized ? <span class="hljs-string">'authorized'</span> : <span class="hljs-string">'unauthorized'</span>);
-  process.stdin.pipe(socket);
-  process.stdin.resume();
+<span class="hljs-keyword">const</span> socket = tls.<span class="hljs-title function_">connect</span>(<span class="hljs-number">8000</span>, options, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'client connected'</span>,
+              socket.<span class="hljs-property">authorized</span> ? <span class="hljs-string">'authorized'</span> : <span class="hljs-string">'unauthorized'</span>);
+  process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">pipe</span>(socket);
+  process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">resume</span>();
 });
-socket.setEncoding(<span class="hljs-string">'utf8'</span>);
-socket.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(data);
+socket.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
 });
-socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server ends connection'</span>);
+socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server ends connection'</span>);
 });</code></pre>
-<h2><code>tls.connect(path[, options][, callback])</code><span><a class="mark" href="#tls_tls_connect_path_options_callback" id="tls_tls_connect_path_options_callback">#</a></span></h2>
+</section><section><h3><code>tls.connect(path[, options][, callback])</code><span><a class="mark" href="#tls_tls_connect_path_options_callback" id="tls_tls_connect_path_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -55790,7 +60356,7 @@ socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">()
 <p>Same as <a href="#tls_tls_connect_options_callback"><code>tls.connect()</code></a> except that <code>path</code> can be provided
 as an argument instead of an option.</p>
 <p>A path option, if specified, will take precedence over the path argument.</p>
-<h2><code>tls.connect(port[, host][, options][, callback])</code><span><a class="mark" href="#tls_tls_connect_port_host_options_callback" id="tls_tls_connect_port_host_options_callback">#</a></span></h2>
+</section><section><h3><code>tls.connect(port[, host][, options][, callback])</code><span><a class="mark" href="#tls_tls_connect_port_host_options_callback" id="tls_tls_connect_port_host_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -55805,7 +60371,7 @@ as an argument instead of an option.</p>
 as arguments instead of options.</p>
 <p>A port or host option, if specified, will take precedence over any port or host
 argument.</p>
-<h2><code>tls.createSecureContext([options])</code><span><a class="mark" href="#tls_tls_createsecurecontext_options" id="tls_tls_createsecurecontext_options">#</a></span></h2>
+</section><section><h3><code>tls.createSecureContext([options])</code><span><a class="mark" href="#tls_tls_createsecurecontext_options" id="tls_tls_createsecurecontext_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -55818,7 +60384,7 @@ argument.</p>
 <td><p>TLSv1.3 support added.</p></td></tr>
 <tr><td>v11.5.0</td>
 <td><p>The <code>ca:</code> option now supports <code>BEGIN TRUSTED CERTIFICATE</code>.</p></td></tr>
-<tr><td>v11.4.0</td>
+<tr><td>v11.4.0, v10.16.0</td>
 <td><p>The <code>minVersion</code> and <code>maxVersion</code> can be used to restrict the allowed TLS protocol versions.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>ecdhCurve</code> cannot be set to <code>false</code> anymore due to a change in OpenSSL.</p></td></tr>
@@ -55913,12 +60479,12 @@ Should not be set together with <code>key</code>, because both options define a
 private key in different ways.</li>
 <li><code>maxVersion</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Optionally set the maximum TLS version to allow. One
 of <code>'TLSv1.3'</code>, <code>'TLSv1.2'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1'</code>. Cannot be specified
-along with the <code>secureProtocol</code> option, use one or the other.
+along with the <code>secureProtocol</code> option; use one or the other.
 <strong>Default:</strong> <a href="#tls_tls_default_max_version"><code>tls.DEFAULT_MAX_VERSION</code></a>.</li>
 <li><code>minVersion</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Optionally set the minimum TLS version to allow. One
 of <code>'TLSv1.3'</code>, <code>'TLSv1.2'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1'</code>. Cannot be specified
-along with the <code>secureProtocol</code> option, use one or the other. It is not
-recommended to use less than TLSv1.2, but it may be required for
+along with the <code>secureProtocol</code> option; use one or the other. Avoid
+setting to less than TLSv1.2, but it may be required for
 interoperability.
 <strong>Default:</strong> <a href="#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a>.</li>
 <li><code>passphrase</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Shared passphrase used for a single private key and/or
@@ -55967,7 +60533,7 @@ and <a href="#tls_server_addcontext_hostname_context"><code>server.addContext()<
 <code>pfx</code> can be used to provide it.</p>
 <p>If the <code>ca</code> option is not given, then Node.js will default to using
 <a href="https://hg.mozilla.org/mozilla-central/raw-file/tip/security/nss/lib/ckfw/builtins/certdata.txt">Mozilla's publicly trusted list of CAs</a>.</p>
-<h2><code>tls.createSecurePair([context][, isServer][, requestCert][, rejectUnauthorized][, options])</code><span><a class="mark" href="#tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options" id="tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options">#</a></span></h2>
+</section><section><h3><code>tls.createSecurePair([context][, isServer][, requestCert][, rejectUnauthorized][, options])</code><span><a class="mark" href="#tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options" id="tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -56019,13 +60585,13 @@ stream.</p>
 <p>Using <code>cleartext</code> has the same API as <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a>.</p>
 <p>The <code>tls.createSecurePair()</code> method is now deprecated in favor of
 <code>tls.TLSSocket()</code>. For example, the code:</p>
-<pre><code class="language-js">pair = tls.createSecurePair(<span class="hljs-comment">/* ... */</span>);
-pair.encrypted.pipe(socket);
-socket.pipe(pair.encrypted);</code></pre>
+<pre><code class="language-js">pair = tls.<span class="hljs-title function_">createSecurePair</span>(<span class="hljs-comment">/* ... */</span>);
+pair.<span class="hljs-property">encrypted</span>.<span class="hljs-title function_">pipe</span>(socket);
+socket.<span class="hljs-title function_">pipe</span>(pair.<span class="hljs-property">encrypted</span>);</code></pre>
 <p>can be replaced by:</p>
-<pre><code class="language-js">secureSocket = tls.TLSSocket(socket, options);</code></pre>
+<pre><code class="language-js">secureSocket = tls.<span class="hljs-title function_">TLSSocket</span>(socket, options);</code></pre>
 <p>where <code>secureSocket</code> has the same API as <code>pair.cleartext</code>.</p>
-<h2><code>tls.createServer([options][, secureConnectionListener])</code><span><a class="mark" href="#tls_tls_createserver_options_secureconnectionlistener" id="tls_tls_createserver_options_secureconnectionlistener">#</a></span></h2>
+</section><section><h3><code>tls.createServer([options][, secureConnectionListener])</code><span><a class="mark" href="#tls_tls_createserver_options_secureconnectionlistener" id="tls_tls_createserver_options_secureconnectionlistener">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -56089,8 +60655,9 @@ data. See <a href="#tls_session_resumption">Session Resumption</a> for more info
 this connection.</li>
 <li>identity: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> identity parameter sent from the client.</li>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> pre-shared key that must either be
-  a buffer or <code>null</code> to stop the negotiation process. Returned PSK must be
-compatible with the selected cipher's digest.
+a buffer or <code>null</code> to stop the negotiation process. Returned PSK must be
+compatible with the selected cipher's digest.</li>
+</ul>
 When negotiating TLS-PSK (pre-shared keys), this function is called
 with the identity provided by the client.
 If the return value is <code>null</code> the negotiation process will stop and an
@@ -56101,8 +60668,6 @@ fail with "decrypt_error" before negotiation is finished.
 PSK ciphers are disabled by default, and using TLS-PSK thus
 requires explicitly specifying a cipher suite with the <code>ciphers</code> option.
 More information can be found in the <a href="https://tools.ietf.org/html/rfc4279">RFC 4279</a>.</li>
-</ul>
-</li>
 <li><code>pskIdentityHint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> optional hint to send to a client to help
 with selecting the identity during TLS-PSK negotiation. Will be ignored
 in TLS 1.3. Upon failing to set pskIdentityHint <code>'tlsClientError'</code> will be
@@ -56125,29 +60690,29 @@ workers.</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">const</span> options = {
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'server-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'server-cert.pem'</span>),
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-cert.pem'</span>),
 
   <span class="hljs-comment">// This is necessary only if using client certificate authentication.</span>
   <span class="hljs-attr">requestCert</span>: <span class="hljs-literal">true</span>,
 
   <span class="hljs-comment">// This is necessary only if the client uses a self-signed certificate.</span>
-  <span class="hljs-attr">ca</span>: [ fs.readFileSync(<span class="hljs-string">'client-cert.pem'</span>) ]
+  <span class="hljs-attr">ca</span>: [ fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'client-cert.pem'</span>) ]
 };
 
-<span class="hljs-keyword">const</span> server = tls.createServer(options, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server connected'</span>,
-              socket.authorized ? <span class="hljs-string">'authorized'</span> : <span class="hljs-string">'unauthorized'</span>);
-  socket.write(<span class="hljs-string">'welcome!\n'</span>);
-  socket.setEncoding(<span class="hljs-string">'utf8'</span>);
-  socket.pipe(socket);
+<span class="hljs-keyword">const</span> server = tls.<span class="hljs-title function_">createServer</span>(options, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server connected'</span>,
+              socket.<span class="hljs-property">authorized</span> ? <span class="hljs-string">'authorized'</span> : <span class="hljs-string">'unauthorized'</span>);
+  socket.<span class="hljs-title function_">write</span>(<span class="hljs-string">'welcome!\n'</span>);
+  socket.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+  socket.<span class="hljs-title function_">pipe</span>(socket);
 });
-server.listen(<span class="hljs-number">8000</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server bound'</span>);
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server bound'</span>);
 });</code></pre>
 <p>The server can be tested by connecting to it using the example client from
 <a href="#tls_tls_connect_options_callback"><code>tls.connect()</code></a>.</p>
-<h2><code>tls.getCiphers()</code><span><a class="mark" href="#tls_tls_getciphers" id="tls_tls_getciphers">#</a></span></h2>
+</section><section><h3><code>tls.getCiphers()</code><span><a class="mark" href="#tls_tls_getciphers" id="tls_tls_getciphers">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.10.2</span>
 </div>
@@ -56159,8 +60724,8 @@ lower-case for historical reasons, but must be uppercased to be used in
 the <code>ciphers</code> option of <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a>.</p>
 <p>Cipher names that start with <code>'tls_'</code> are for TLSv1.3, all the others are for
 TLSv1.2 and below.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(tls.getCiphers()); <span class="hljs-comment">// ['aes128-gcm-sha256', 'aes128-sha', ...]</span></code></pre>
-<h2><code>tls.rootCertificates</code><span><a class="mark" href="#tls_tls_rootcertificates" id="tls_tls_rootcertificates">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(tls.<span class="hljs-title function_">getCiphers</span>()); <span class="hljs-comment">// ['aes128-gcm-sha256', 'aes128-sha', ...]</span></code></pre>
+</section><section><h3><code>tls.rootCertificates</code><span><a class="mark" href="#tls_tls_rootcertificates" id="tls_tls_rootcertificates">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
@@ -56171,7 +60736,7 @@ TLSv1.2 and below.</p>
 from the bundled Mozilla CA store as supplied by current Node.js version.</p>
 <p>The bundled CA store, as supplied by Node.js, is a snapshot of Mozilla CA store
 that is fixed at release time. It is identical on all supported platforms.</p>
-<h2><code>tls.DEFAULT_ECDH_CURVE</code><span><a class="mark" href="#tls_tls_default_ecdh_curve" id="tls_tls_default_ecdh_curve">#</a></span></h2>
+</section><section><h3><code>tls.DEFAULT_ECDH_CURVE</code><span><a class="mark" href="#tls_tls_default_ecdh_curve" id="tls_tls_default_ecdh_curve">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -56186,7 +60751,7 @@ that is fixed at release time. It is identical on all supported platforms.</p>
 <p>The default curve name to use for ECDH key agreement in a tls server. The
 default value is <code>'auto'</code>. See <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a> for further
 information.</p>
-<h2><code>tls.DEFAULT_MAX_VERSION</code><span><a class="mark" href="#tls_tls_default_max_version" id="tls_tls_default_max_version">#</a></span></h2>
+</section><section><h3><code>tls.DEFAULT_MAX_VERSION</code><span><a class="mark" href="#tls_tls_default_max_version" id="tls_tls_default_max_version">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.4.0</span>
 </div>
@@ -56199,7 +60764,7 @@ protocol versions, <code>'TLSv1.3'</code>, <code>'TLSv1.2'</code>, <code>'TLSv1.
 the default to <code>'TLSv1.3'</code>. If multiple of the options are provided, the
 highest maximum is used.</li>
 </ul>
-<h2><code>tls.DEFAULT_MIN_VERSION</code><span><a class="mark" href="#tls_tls_default_min_version" id="tls_tls_default_min_version">#</a></span></h2>
+</section><section><h3><code>tls.DEFAULT_MIN_VERSION</code><span><a class="mark" href="#tls_tls_default_min_version" id="tls_tls_default_min_version">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.4.0</span>
 </div>
@@ -56212,11 +60777,12 @@ protocol versions, <code>'TLSv1.3'</code>, <code>'TLSv1.2'</code>, <code>'TLSv1.
 the default to <code>'TLSv1.1'</code>. Using <code>--tls-min-v1.3</code> sets the default to
 <code>'TLSv1.3'</code>. If multiple of the options are provided, the lowest minimum is
 used.</li>
-</ul>
-<h1>Trace events<span><a class="mark" href="#tracing_trace_events" id="tracing_trace_events">#</a></span></h1>
+</ul></section>
+        </section>
+<section><h2>Trace events<span><a class="mark" href="#tracing_trace_events" id="tracing_trace_events">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/trace_events.js">lib/trace_events.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/trace_events.js">lib/trace_events.js</a></p>
 <p>The <code>trace_events</code> module provides a mechanism to centralize tracing information
 generated by V8, Node.js core, and userspace code.</p>
 <p>Tracing can be enabled with the <code>--trace-event-categories</code> command-line flag
@@ -56261,12 +60827,12 @@ flag to enable trace events. This requirement has been removed. However, the
 node --trace-event-categories v8,node,node.async_hooks</code></pre>
 <p>Alternatively, trace events may be enabled using the <code>trace_events</code> module:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> trace_events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'trace_events'</span>);
-<span class="hljs-keyword">const</span> tracing = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>] });
-tracing.enable();  <span class="hljs-comment">// Enable trace event capture for the 'node.perf' category</span>
+<span class="hljs-keyword">const</span> tracing = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>] });
+tracing.<span class="hljs-title function_">enable</span>();  <span class="hljs-comment">// Enable trace event capture for the 'node.perf' category</span>
 
 <span class="hljs-comment">// do work</span>
 
-tracing.disable();  <span class="hljs-comment">// Disable trace event capture for the 'node.perf' category</span></code></pre>
+tracing.<span class="hljs-title function_">disable</span>();  <span class="hljs-comment">// Disable trace event capture for the 'node.perf' category</span></code></pre>
 <p>Running Node.js with tracing enabled will produce log files that can be opened
 in the <a href="https://www.chromium.org/developers/how-tos/trace-event-profiling-tool"><code>chrome://tracing</code></a>
 tab of Chrome.</p>
@@ -56280,11 +60846,11 @@ as the one used by <code>process.hrtime()</code>.
 However the trace-event timestamps are expressed in microseconds,
 unlike <code>process.hrtime()</code> which returns nanoseconds.</p>
 <p>The features from this module are not available in <a href="#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2>The <code>trace_events</code> module<span><a class="mark" href="#tracing_the_trace_events_module" id="tracing_the_trace_events_module">#</a></span></h2>
+<section><h3>The <code>trace_events</code> module<span><a class="mark" href="#tracing_the_trace_events_module" id="tracing_the_trace_events_module">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
-<h3><code>Tracing</code> object<span><a class="mark" href="#tracing_tracing_object" id="tracing_tracing_object">#</a></span></h3>
+<h4><code>Tracing</code> object<span><a class="mark" href="#tracing_tracing_object" id="tracing_tracing_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -56295,7 +60861,7 @@ method.</p>
 <code>tracing.enable()</code> method adds the categories to the set of enabled trace event
 categories. Calling <code>tracing.disable()</code> will remove the categories from the
 set of enabled trace event categories.</p>
-<h4><code>tracing.categories</code><span><a class="mark" href="#tracing_tracing_categories" id="tracing_tracing_categories">#</a></span></h4>
+<h5><code>tracing.categories</code><span><a class="mark" href="#tracing_tracing_categories" id="tracing_tracing_categories">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -56304,7 +60870,7 @@ set of enabled trace event categories.</p>
 </ul>
 <p>A comma-separated list of the trace event categories covered by this
 <code>Tracing</code> object.</p>
-<h4><code>tracing.disable()</code><span><a class="mark" href="#tracing_tracing_disable" id="tracing_tracing_disable">#</a></span></h4>
+<h5><code>tracing.disable()</code><span><a class="mark" href="#tracing_tracing_disable" id="tracing_tracing_disable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -56312,32 +60878,32 @@ set of enabled trace event categories.</p>
 <p>Only trace event categories <em>not</em> covered by other enabled <code>Tracing</code> objects
 and <em>not</em> specified by the <code>--trace-event-categories</code> flag will be disabled.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> trace_events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'trace_events'</span>);
-<span class="hljs-keyword">const</span> t1 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node'</span>, <span class="hljs-string">'v8'</span>] });
-<span class="hljs-keyword">const</span> t2 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>, <span class="hljs-string">'node'</span>] });
-t1.enable();
-t2.enable();
+<span class="hljs-keyword">const</span> t1 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node'</span>, <span class="hljs-string">'v8'</span>] });
+<span class="hljs-keyword">const</span> t2 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>, <span class="hljs-string">'node'</span>] });
+t1.<span class="hljs-title function_">enable</span>();
+t2.<span class="hljs-title function_">enable</span>();
 
 <span class="hljs-comment">// Prints 'node,node.perf,v8'</span>
-<span class="hljs-built_in">console</span>.log(trace_events.getEnabledCategories());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(trace_events.<span class="hljs-title function_">getEnabledCategories</span>());
 
-t2.disable(); <span class="hljs-comment">// Will only disable emission of the 'node.perf' category</span>
+t2.<span class="hljs-title function_">disable</span>(); <span class="hljs-comment">// Will only disable emission of the 'node.perf' category</span>
 
 <span class="hljs-comment">// Prints 'node,v8'</span>
-<span class="hljs-built_in">console</span>.log(trace_events.getEnabledCategories());</code></pre>
-<h4><code>tracing.enable()</code><span><a class="mark" href="#tracing_tracing_enable" id="tracing_tracing_enable">#</a></span></h4>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(trace_events.<span class="hljs-title function_">getEnabledCategories</span>());</code></pre>
+<h5><code>tracing.enable()</code><span><a class="mark" href="#tracing_tracing_enable" id="tracing_tracing_enable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 <p>Enables this <code>Tracing</code> object for the set of categories covered by the
 <code>Tracing</code> object.</p>
-<h4><code>tracing.enabled</code><span><a class="mark" href="#tracing_tracing_enabled" id="tracing_tracing_enabled">#</a></span></h4>
+<h5><code>tracing.enabled</code><span><a class="mark" href="#tracing_tracing_enabled" id="tracing_tracing_enabled">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> only if the <code>Tracing</code> object has been enabled.</li>
 </ul>
-<h3><code>trace_events.createTracing(options)</code><span><a class="mark" href="#tracing_trace_events_createtracing_options" id="tracing_trace_events_createtracing_options">#</a></span></h3>
+<h4><code>trace_events.createTracing(options)</code><span><a class="mark" href="#tracing_trace_events_createtracing_options" id="tracing_trace_events_createtracing_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -56354,11 +60920,11 @@ thrown if the value cannot be coerced.</li>
 <p>Creates and returns a <code>Tracing</code> object for the given set of <code>categories</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> trace_events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'trace_events'</span>);
 <span class="hljs-keyword">const</span> categories = [<span class="hljs-string">'node.perf'</span>, <span class="hljs-string">'node.async_hooks'</span>];
-<span class="hljs-keyword">const</span> tracing = trace_events.createTracing({ categories });
-tracing.enable();
+<span class="hljs-keyword">const</span> tracing = trace_events.<span class="hljs-title function_">createTracing</span>({ categories });
+tracing.<span class="hljs-title function_">enable</span>();
 <span class="hljs-comment">// do stuff</span>
-tracing.disable();</code></pre>
-<h3><code>trace_events.getEnabledCategories()</code><span><a class="mark" href="#tracing_trace_events_getenabledcategories" id="tracing_trace_events_getenabledcategories">#</a></span></h3>
+tracing.<span class="hljs-title function_">disable</span>();</code></pre>
+<h4><code>trace_events.getEnabledCategories()</code><span><a class="mark" href="#tracing_trace_events_getenabledcategories" id="tracing_trace_events_getenabledcategories">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -56373,18 +60939,19 @@ enabled using the <code>--trace-event-categories</code> flag.</p>
 <code>node --trace-event-categories node.perf test.js</code> will print
 <code>'node.async_hooks,node.perf'</code> to the console.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> trace_events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'trace_events'</span>);
-<span class="hljs-keyword">const</span> t1 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.async_hooks'</span>] });
-<span class="hljs-keyword">const</span> t2 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>] });
-<span class="hljs-keyword">const</span> t3 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'v8'</span>] });
+<span class="hljs-keyword">const</span> t1 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.async_hooks'</span>] });
+<span class="hljs-keyword">const</span> t2 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>] });
+<span class="hljs-keyword">const</span> t3 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'v8'</span>] });
 
-t1.enable();
-t2.enable();
+t1.<span class="hljs-title function_">enable</span>();
+t2.<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-built_in">console</span>.log(trace_events.getEnabledCategories());</code></pre>
-<h1>TTY<span><a class="mark" href="#tty_tty" id="tty_tty">#</a></span></h1>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(trace_events.<span class="hljs-title function_">getEnabledCategories</span>());</code></pre></section>
+        </section>
+<section><h2>TTY<span><a class="mark" href="#tty_tty" id="tty_tty">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/tty.js">lib/tty.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/tty.js">lib/tty.js</a></p>
 <p>The <code>tty</code> module provides the <code>tty.ReadStream</code> and <code>tty.WriteStream</code> classes.
 In most cases, it will not be necessary or possible to use this module directly.
 However, it can be accessed using:</p>
@@ -56392,17 +60959,17 @@ However, it can be accessed using:</p>
 <p>When Node.js detects that it is being run with a text terminal ("TTY")
 attached, <a href="#process_process_stdin"><code>process.stdin</code></a> will, by default, be initialized as an instance of
 <code>tty.ReadStream</code> and both <a href="#process_process_stdout"><code>process.stdout</code></a> and <a href="#process_process_stderr"><code>process.stderr</code></a> will, by
-default be instances of <code>tty.WriteStream</code>. The preferred method of determining
+default, be instances of <code>tty.WriteStream</code>. The preferred method of determining
 whether Node.js is being run within a TTY context is to check that the value of
 the <code>process.stdout.isTTY</code> property is <code>true</code>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node -p -e <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span></span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node -p -e <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span></span>
 true
-<span class="hljs-meta">$</span><span class="bash"> node -p -e <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span> | cat</span>
+<span class="hljs-meta">$ </span><span class="language-bash">node -p -e <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span> | cat</span>
 false</code></pre>
 <p>In most cases, there should be little to no reason for an application to
 manually create instances of the <code>tty.ReadStream</code> and <code>tty.WriteStream</code>
 classes.</p>
-<h2>Class: <code>tty.ReadStream</code><span><a class="mark" href="#tty_class_tty_readstream" id="tty_class_tty_readstream">#</a></span></h2>
+<section><h3>Class: <code>tty.ReadStream</code><span><a class="mark" href="#tty_class_tty_readstream" id="tty_class_tty_readstream">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -56412,18 +60979,18 @@ classes.</p>
 <p>Represents the readable side of a TTY. In normal circumstances
 <a href="#process_process_stdin"><code>process.stdin</code></a> will be the only <code>tty.ReadStream</code> instance in a Node.js
 process and there should be no reason to create additional instances.</p>
-<h3><code>readStream.isRaw</code><span><a class="mark" href="#tty_readstream_israw" id="tty_readstream_israw">#</a></span></h3>
+<h4><code>readStream.isRaw</code><span><a class="mark" href="#tty_readstream_israw" id="tty_readstream_israw">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>A <code>boolean</code> that is <code>true</code> if the TTY is currently configured to operate as a
 raw device. Defaults to <code>false</code>.</p>
-<h3><code>readStream.isTTY</code><span><a class="mark" href="#tty_readstream_istty" id="tty_readstream_istty">#</a></span></h3>
+<h4><code>readStream.isTTY</code><span><a class="mark" href="#tty_readstream_istty" id="tty_readstream_istty">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>A <code>boolean</code> that is always <code>true</code> for <code>tty.ReadStream</code> instances.</p>
-<h3><code>readStream.setRawMode(mode)</code><span><a class="mark" href="#tty_readstream_setrawmode_mode" id="tty_readstream_setrawmode_mode">#</a></span></h3>
+<h4><code>readStream.setRawMode(mode)</code><span><a class="mark" href="#tty_readstream_setrawmode_mode" id="tty_readstream_setrawmode_mode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -56438,8 +61005,8 @@ mode.</li>
 <p>When in raw mode, input is always available character-by-character, not
 including modifiers. Additionally, all special processing of characters by the
 terminal is disabled, including echoing input characters.
-<code>CTRL</code>+<code>C</code> will no longer cause a <code>SIGINT</code> when in this mode.</p>
-<h2>Class: <code>tty.WriteStream</code><span><a class="mark" href="#tty_class_tty_writestream" id="tty_class_tty_writestream">#</a></span></h2>
+<kbd>Ctrl</kbd>+<kbd>C</kbd> will no longer cause a <code>SIGINT</code> when in this mode.</p>
+</section><section><h3>Class: <code>tty.WriteStream</code><span><a class="mark" href="#tty_class_tty_writestream" id="tty_class_tty_writestream">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -56450,18 +61017,18 @@ terminal is disabled, including echoing input characters.
 <a href="#process_process_stdout"><code>process.stdout</code></a> and <a href="#process_process_stderr"><code>process.stderr</code></a> will be the only
 <code>tty.WriteStream</code> instances created for a Node.js process and there
 should be no reason to create additional instances.</p>
-<h3>Event: <code>'resize'</code><span><a class="mark" href="#tty_event_resize" id="tty_event_resize">#</a></span></h3>
+<h4>Event: <code>'resize'</code><span><a class="mark" href="#tty_event_resize" id="tty_event_resize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>The <code>'resize'</code> event is emitted whenever either of the <code>writeStream.columns</code>
 or <code>writeStream.rows</code> properties have changed. No arguments are passed to the
 listener callback when called.</p>
-<pre><code class="language-js">process.stdout.on(<span class="hljs-string">'resize'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'screen size has changed!'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${process.stdout.columns}</span>x<span class="hljs-subst">${process.stdout.rows}</span>`</span>);
+<pre><code class="language-js">process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'resize'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'screen size has changed!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${process.stdout.columns}</span>x<span class="hljs-subst">${process.stdout.rows}</span>`</span>);
 });</code></pre>
-<h3><code>writeStream.clearLine(dir[, callback])</code><span><a class="mark" href="#tty_writestream_clearline_dir_callback" id="tty_writestream_clearline_dir_callback">#</a></span></h3>
+<h4><code>writeStream.clearLine(dir[, callback])</code><span><a class="mark" href="#tty_writestream_clearline_dir_callback" id="tty_writestream_clearline_dir_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -56488,7 +61055,7 @@ data; otherwise <code>true</code>.</li>
 </ul>
 <p><code>writeStream.clearLine()</code> clears the current line of this <code>WriteStream</code> in a
 direction identified by <code>dir</code>.</p>
-<h3><code>writeStream.clearScreenDown([callback])</code><span><a class="mark" href="#tty_writestream_clearscreendown_callback" id="tty_writestream_clearscreendown_callback">#</a></span></h3>
+<h4><code>writeStream.clearScreenDown([callback])</code><span><a class="mark" href="#tty_writestream_clearscreendown_callback" id="tty_writestream_clearscreendown_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -56508,13 +61075,13 @@ data; otherwise <code>true</code>.</li>
 </ul>
 <p><code>writeStream.clearScreenDown()</code> clears this <code>WriteStream</code> from the current
 cursor down.</p>
-<h3><code>writeStream.columns</code><span><a class="mark" href="#tty_writestream_columns" id="tty_writestream_columns">#</a></span></h3>
+<h4><code>writeStream.columns</code><span><a class="mark" href="#tty_writestream_columns" id="tty_writestream_columns">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>A <code>number</code> specifying the number of columns the TTY currently has. This property
 is updated whenever the <code>'resize'</code> event is emitted.</p>
-<h3><code>writeStream.cursorTo(x[, y][, callback])</code><span><a class="mark" href="#tty_writestream_cursorto_x_y_callback" id="tty_writestream_cursorto_x_y_callback">#</a></span></h3>
+<h4><code>writeStream.cursorTo(x[, y][, callback])</code><span><a class="mark" href="#tty_writestream_cursorto_x_y_callback" id="tty_writestream_cursorto_x_y_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -56536,7 +61103,7 @@ data; otherwise <code>true</code>.</li>
 </ul>
 <p><code>writeStream.cursorTo()</code> moves this <code>WriteStream</code>'s cursor to the specified
 position.</p>
-<h3><code>writeStream.getColorDepth([env])</code><span><a class="mark" href="#tty_writestream_getcolordepth_env" id="tty_writestream_getcolordepth_env">#</a></span></h3>
+<h4><code>writeStream.getColorDepth([env])</code><span><a class="mark" href="#tty_writestream_getcolordepth_env" id="tty_writestream_getcolordepth_env">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.9.0</span>
 </div>
@@ -56551,9 +61118,9 @@ enables simulating the usage of a specific terminal. <strong>Default:</strong>
 <li><code>1</code> for 2,</li>
 <li><code>4</code> for 16,</li>
 <li><code>8</code> for 256,</li>
-<li><code>24</code> for 16,777,216
-colors supported.</li>
+<li><code>24</code> for 16,777,216</li>
 </ul>
+<p>colors supported.</p>
 <p>Use this to determine what colors the terminal supports. Due to the nature of
 colors in terminals it is possible to either have false positives or false
 negatives. It depends on process information and the environment variables that
@@ -56569,20 +61136,20 @@ terminal. This can be useful to check how specific environment settings behave.<
 </ul>
 <p>Disabling color support is also possible by using the <code>NO_COLOR</code> and
 <code>NODE_DISABLE_COLORS</code> environment variables.</p>
-<h3><code>writeStream.getWindowSize()</code><span><a class="mark" href="#tty_writestream_getwindowsize" id="tty_writestream_getwindowsize">#</a></span></h3>
+<h4><code>writeStream.getWindowSize()</code><span><a class="mark" href="#tty_writestream_getwindowsize" id="tty_writestream_getwindowsize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number[]></a></li>
 </ul>
-<p><code>writeStream.getWindowSize()</code> returns the size of the <a href="tty.html">TTY</a>
+<p><code>writeStream.getWindowSize()</code> returns the size of the TTY
 corresponding to this <code>WriteStream</code>. The array is of the type
 <code>[numColumns, numRows]</code> where <code>numColumns</code> and <code>numRows</code> represent the number
-of columns and rows in the corresponding <a href="tty.html">TTY</a>.</p>
-<h3><code>writeStream.hasColors([count][, env])</code><span><a class="mark" href="#tty_writestream_hascolors_count_env" id="tty_writestream_hascolors_count_env">#</a></span></h3>
+of columns and rows in the corresponding TTY.</p>
+<h4><code>writeStream.hasColors([count][, env])</code><span><a class="mark" href="#tty_writestream_hascolors_count_env" id="tty_writestream_hascolors_count_env">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.13.0</span>
+<span>Added in: v11.13.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>count</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of colors that are requested (minimum 2).
@@ -56596,20 +61163,20 @@ enables simulating the usage of a specific terminal. <strong>Default:</strong>
 in <code>count</code>. Minimum support is 2 (black and white).</p>
 <p>This has the same false positives and negatives as described in
 <a href="#tty_writestream_getcolordepth_env"><code>writeStream.getColorDepth()</code></a>.</p>
-<pre><code class="language-js">process.stdout.hasColors();
+<pre><code class="language-js">process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">hasColors</span>();
 <span class="hljs-comment">// Returns true or false depending on if `stdout` supports at least 16 colors.</span>
-process.stdout.hasColors(<span class="hljs-number">256</span>);
+process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">hasColors</span>(<span class="hljs-number">256</span>);
 <span class="hljs-comment">// Returns true or false depending on if `stdout` supports at least 256 colors.</span>
-process.stdout.hasColors({ <span class="hljs-attr">TMUX</span>: <span class="hljs-string">'1'</span> });
+process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">hasColors</span>({ <span class="hljs-attr">TMUX</span>: <span class="hljs-string">'1'</span> });
 <span class="hljs-comment">// Returns true.</span>
-process.stdout.hasColors(<span class="hljs-number">2</span> ** <span class="hljs-number">24</span>, { <span class="hljs-attr">TMUX</span>: <span class="hljs-string">'1'</span> });
+process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">hasColors</span>(<span class="hljs-number">2</span> ** <span class="hljs-number">24</span>, { <span class="hljs-attr">TMUX</span>: <span class="hljs-string">'1'</span> });
 <span class="hljs-comment">// Returns false (the environment setting pretends to support 2 ** 8 colors).</span></code></pre>
-<h3><code>writeStream.isTTY</code><span><a class="mark" href="#tty_writestream_istty" id="tty_writestream_istty">#</a></span></h3>
+<h4><code>writeStream.isTTY</code><span><a class="mark" href="#tty_writestream_istty" id="tty_writestream_istty">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>A <code>boolean</code> that is always <code>true</code>.</p>
-<h3><code>writeStream.moveCursor(dx, dy[, callback])</code><span><a class="mark" href="#tty_writestream_movecursor_dx_dy_callback" id="tty_writestream_movecursor_dx_dy_callback">#</a></span></h3>
+<h4><code>writeStream.moveCursor(dx, dy[, callback])</code><span><a class="mark" href="#tty_writestream_movecursor_dx_dy_callback" id="tty_writestream_movecursor_dx_dy_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -56631,13 +61198,13 @@ data; otherwise <code>true</code>.</li>
 </ul>
 <p><code>writeStream.moveCursor()</code> moves this <code>WriteStream</code>'s cursor <em>relative</em> to its
 current position.</p>
-<h3><code>writeStream.rows</code><span><a class="mark" href="#tty_writestream_rows" id="tty_writestream_rows">#</a></span></h3>
+<h4><code>writeStream.rows</code><span><a class="mark" href="#tty_writestream_rows" id="tty_writestream_rows">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>A <code>number</code> specifying the number of rows the TTY currently has. This property
 is updated whenever the <code>'resize'</code> event is emitted.</p>
-<h2><code>tty.isatty(fd)</code><span><a class="mark" href="#tty_tty_isatty_fd" id="tty_tty_isatty_fd">#</a></span></h2>
+</section><section><h3><code>tty.isatty(fd)</code><span><a class="mark" href="#tty_tty_isatty_fd" id="tty_tty_isatty_fd">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -56647,33 +61214,34 @@ is updated whenever the <code>'resize'</code> event is emitted.</p>
 </ul>
 <p>The <code>tty.isatty()</code> method returns <code>true</code> if the given <code>fd</code> is associated with
 a TTY and <code>false</code> if it is not, including whenever <code>fd</code> is not a non-negative
-integer.</p>
-<h1>UDP/datagram sockets<span><a class="mark" href="#dgram_udp_datagram_sockets" id="dgram_udp_datagram_sockets">#</a></span></h1>
+integer.</p></section>
+        </section>
+<section><h2>UDP/datagram sockets<span><a class="mark" href="#dgram_udp_datagram_sockets" id="dgram_udp_datagram_sockets">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/dgram.js">lib/dgram.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/dgram.js">lib/dgram.js</a></p>
 <p>The <code>dgram</code> module provides an implementation of UDP datagram sockets.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> server = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
+<span class="hljs-keyword">const</span> server = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
 
-server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server error:\n<span class="hljs-subst">${err.stack}</span>`</span>);
-  server.close();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server error:\n<span class="hljs-subst">${err.stack}</span>`</span>);
+  server.<span class="hljs-title function_">close</span>();
 });
 
-server.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
 });
 
-server.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> address = server.address();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server listening <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">const</span> address = server.<span class="hljs-title function_">address</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server listening <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
 });
 
-server.bind(<span class="hljs-number">41234</span>);
+server.<span class="hljs-title function_">bind</span>(<span class="hljs-number">41234</span>);
 <span class="hljs-comment">// Prints: server listening 0.0.0.0:41234</span></code></pre>
-<h2>Class: <code>dgram.Socket</code><span><a class="mark" href="#dgram_class_dgram_socket" id="dgram_class_dgram_socket">#</a></span></h2>
+<section><h3>Class: <code>dgram.Socket</code><span><a class="mark" href="#dgram_class_dgram_socket" id="dgram_class_dgram_socket">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -56683,19 +61251,19 @@ server.bind(<span class="hljs-number">41234</span>);
 <p>Encapsulates the datagram functionality.</p>
 <p>New instances of <code>dgram.Socket</code> are created using <a href="#dgram_dgram_createsocket_options_callback"><code>dgram.createSocket()</code></a>.
 The <code>new</code> keyword is not to be used to create <code>dgram.Socket</code> instances.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#dgram_event_close" id="dgram_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#dgram_event_close" id="dgram_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
 <p>The <code>'close'</code> event is emitted after a socket is closed with <a href="#dgram_socket_close_callback"><code>close()</code></a>.
 Once triggered, no new <code>'message'</code> events will be emitted on this socket.</p>
-<h3>Event: <code>'connect'</code><span><a class="mark" href="#dgram_event_connect" id="dgram_event_connect">#</a></span></h3>
+<h4>Event: <code>'connect'</code><span><a class="mark" href="#dgram_event_connect" id="dgram_event_connect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>The <code>'connect'</code> event is emitted after a socket is associated to a remote
 address as a result of a successful <a href="#dgram_socket_connect_port_address_callback"><code>connect()</code></a> call.</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#dgram_event_error" id="dgram_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#dgram_event_error" id="dgram_event_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -56704,7 +61272,7 @@ address as a result of a successful <a href="#dgram_socket_connect_port_address_
 </ul>
 <p>The <code>'error'</code> event is emitted whenever any error occurs. The event handler
 function is passed a single <code>Error</code> object.</p>
-<h3>Event: <code>'listening'</code><span><a class="mark" href="#dgram_event_listening" id="dgram_event_listening">#</a></span></h3>
+<h4>Event: <code>'listening'</code><span><a class="mark" href="#dgram_event_listening" id="dgram_event_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -56713,7 +61281,7 @@ can receive data. This happens either explicitly with <code>socket.bind()</code>
 implicitly the first time data is sent using <code>socket.send()</code>.
 Until the <code>dgram.Socket</code> is listening, the underlying system resources do not
 exist and calls such as <code>socket.address()</code> and <code>socket.setTTL()</code> will fail.</p>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#dgram_event_message" id="dgram_event_message">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#dgram_event_message" id="dgram_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -56735,7 +61303,7 @@ address, the interface name is added to the <code>address</code>. For
 example, a packet received on the <code>en0</code> interface might have the
 address field set to <code>'fe80::2618:1234:ab11:3b9c%en0'</code>, where <code>'%en0'</code>
 is the interface name as a zone ID suffix.</p>
-<h3><code>socket.addMembership(multicastAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_addmembership_multicastaddress_multicastinterface" id="dgram_socket_addmembership_multicastaddress_multicastinterface">#</a></span></h3>
+<h4><code>socket.addMembership(multicastAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_addmembership_multicastaddress_multicastinterface" id="dgram_socket_addmembership_multicastaddress_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.9</span>
 </div>
@@ -56755,18 +61323,18 @@ port, listening on all interfaces.</p>
 <code>EADDRINUSE</code> error will occur:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 <span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
-  cluster.fork(); <span class="hljs-comment">// Works ok.</span>
-  cluster.fork(); <span class="hljs-comment">// Fails with EADDRINUSE.</span>
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  cluster.<span class="hljs-title function_">fork</span>(); <span class="hljs-comment">// Works ok.</span>
+  cluster.<span class="hljs-title function_">fork</span>(); <span class="hljs-comment">// Fails with EADDRINUSE.</span>
 } <span class="hljs-keyword">else</span> {
-  <span class="hljs-keyword">const</span> s = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
-  s.bind(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
-    s.addMembership(<span class="hljs-string">'224.0.0.114'</span>);
+  <span class="hljs-keyword">const</span> s = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
+  s.<span class="hljs-title function_">bind</span>(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
+    s.<span class="hljs-title function_">addMembership</span>(<span class="hljs-string">'224.0.0.114'</span>);
   });
 }</code></pre>
-<h3><code>socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_addsourcespecificmembership_sourceaddress_groupaddress_multicastinterface" id="dgram_socket_addsourcespecificmembership_sourceaddress_groupaddress_multicastinterface">#</a></span></h3>
+<h4><code>socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_addsourcespecificmembership_sourceaddress_groupaddress_multicastinterface" id="dgram_socket_addsourcespecificmembership_sourceaddress_groupaddress_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.1.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>sourceAddress</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -56781,7 +61349,7 @@ membership to it. To add membership to every available interface, call
 <code>socket.addSourceSpecificMembership()</code> multiple times, once per interface.</p>
 <p>When called on an unbound socket, this method will implicitly bind to a random
 port, listening on all interfaces.</p>
-<h3><code>socket.address()</code><span><a class="mark" href="#dgram_socket_address" id="dgram_socket_address">#</a></span></h3>
+<h4><code>socket.address()</code><span><a class="mark" href="#dgram_socket_address" id="dgram_socket_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -56792,12 +61360,12 @@ port, listening on all interfaces.</p>
 For UDP sockets, this object will contain <code>address</code>, <code>family</code> and <code>port</code>
 properties.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.bind([port][, address][, callback])</code><span><a class="mark" href="#dgram_socket_bind_port_address_callback" id="dgram_socket_bind_port_address_callback">#</a></span></h3>
+<h4><code>socket.bind([port][, address][, callback])</code><span><a class="mark" href="#dgram_socket_bind_port_address_callback" id="dgram_socket_bind_port_address_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v0.10</td>
+<tr><td>v0.9.1</td>
 <td><p>The method was changed to an asynchronous execution model. Legacy code would need to be changed to pass a callback function to the method call.</p></td></tr>
 <tr><td>v0.1.99</td>
 <td><p><span>Added in: v0.1.99</span></p></td></tr>
@@ -56825,25 +61393,25 @@ datagram messages.</p>
 attempting to bind with a closed socket), an <a href="#errors_class_error"><code>Error</code></a> may be thrown.</p>
 <p>Example of a UDP server listening on port 41234:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> server = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
+<span class="hljs-keyword">const</span> server = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
 
-server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server error:\n<span class="hljs-subst">${err.stack}</span>`</span>);
-  server.close();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server error:\n<span class="hljs-subst">${err.stack}</span>`</span>);
+  server.<span class="hljs-title function_">close</span>();
 });
 
-server.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
 });
 
-server.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> address = server.address();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server listening <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">const</span> address = server.<span class="hljs-title function_">address</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server listening <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
 });
 
-server.bind(<span class="hljs-number">41234</span>);
+server.<span class="hljs-title function_">bind</span>(<span class="hljs-number">41234</span>);
 <span class="hljs-comment">// Prints: server listening 0.0.0.0:41234</span></code></pre>
-<h3><code>socket.bind(options[, callback])</code><span><a class="mark" href="#dgram_socket_bind_options_callback" id="dgram_socket_bind_options_callback">#</a></span></h3>
+<h4><code>socket.bind(options[, callback])</code><span><a class="mark" href="#dgram_socket_bind_options_callback" id="dgram_socket_bind_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -56884,12 +61452,12 @@ datagram messages.</p>
 <p>If binding fails, an <code>'error'</code> event is generated. In rare case (e.g.
 attempting to bind with a closed socket), an <a href="#errors_class_error"><code>Error</code></a> may be thrown.</p>
 <p>An example socket listening on an exclusive port is shown below.</p>
-<pre><code class="language-js">socket.bind({
+<pre><code class="language-js">socket.<span class="hljs-title function_">bind</span>({
   <span class="hljs-attr">address</span>: <span class="hljs-string">'localhost'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">8000</span>,
   <span class="hljs-attr">exclusive</span>: <span class="hljs-literal">true</span>
 });</code></pre>
-<h3><code>socket.close([callback])</code><span><a class="mark" href="#dgram_socket_close_callback" id="dgram_socket_close_callback">#</a></span></h3>
+<h4><code>socket.close([callback])</code><span><a class="mark" href="#dgram_socket_close_callback" id="dgram_socket_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -56898,7 +61466,7 @@ attempting to bind with a closed socket), an <a href="#errors_class_error"><code
 </ul>
 <p>Close the underlying socket and stop listening for data on it. If a callback is
 provided, it is added as a listener for the <a href="#dgram_event_close"><code>'close'</code></a> event.</p>
-<h3><code>socket.connect(port[, address][, callback])</code><span><a class="mark" href="#dgram_socket_connect_port_address_callback" id="dgram_socket_connect_port_address_callback">#</a></span></h3>
+<h4><code>socket.connect(port[, address][, callback])</code><span><a class="mark" href="#dgram_socket_connect_port_address_callback" id="dgram_socket_connect_port_address_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -56916,7 +61484,7 @@ provided, <code>'127.0.0.1'</code> (for <code>udp4</code> sockets) or <code>'::1
 will be used by default. Once the connection is complete, a <code>'connect'</code> event
 is emitted and the optional <code>callback</code> function is called. In case of failure,
 the <code>callback</code> is called or, failing this, an <code>'error'</code> event is emitted.</p>
-<h3><code>socket.disconnect()</code><span><a class="mark" href="#dgram_socket_disconnect" id="dgram_socket_disconnect">#</a></span></h3>
+<h4><code>socket.disconnect()</code><span><a class="mark" href="#dgram_socket_disconnect" id="dgram_socket_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -56924,7 +61492,7 @@ the <code>callback</code> is called or, failing this, an <code>'error'</code> ev
 its remote address. Trying to call <code>disconnect()</code> on an unbound or already
 disconnected socket will result in an <a href="#errors_err_socket_dgram_not_connected"><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code></a>
 exception.</p>
-<h3><code>socket.dropMembership(multicastAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_dropmembership_multicastaddress_multicastinterface" id="dgram_socket_dropmembership_multicastaddress_multicastinterface">#</a></span></h3>
+<h4><code>socket.dropMembership(multicastAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_dropmembership_multicastaddress_multicastinterface" id="dgram_socket_dropmembership_multicastaddress_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.9</span>
 </div>
@@ -56938,9 +61506,9 @@ kernel when the socket is closed or the process terminates, so most apps will
 never have reason to call this.</p>
 <p>If <code>multicastInterface</code> is not specified, the operating system will attempt to
 drop membership on all valid interfaces.</p>
-<h3><code>socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_dropsourcespecificmembership_sourceaddress_groupaddress_multicastinterface" id="dgram_socket_dropsourcespecificmembership_sourceaddress_groupaddress_multicastinterface">#</a></span></h3>
+<h4><code>socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_dropsourcespecificmembership_sourceaddress_groupaddress_multicastinterface" id="dgram_socket_dropsourcespecificmembership_sourceaddress_groupaddress_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.1.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>sourceAddress</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -56954,7 +61522,7 @@ socket is closed or the process terminates, so most apps will never have
 reason to call this.</p>
 <p>If <code>multicastInterface</code> is not specified, the operating system will attempt to
 drop membership on all valid interfaces.</p>
-<h3><code>socket.getRecvBufferSize()</code><span><a class="mark" href="#dgram_socket_getrecvbuffersize" id="dgram_socket_getrecvbuffersize">#</a></span></h3>
+<h4><code>socket.getRecvBufferSize()</code><span><a class="mark" href="#dgram_socket_getrecvbuffersize" id="dgram_socket_getrecvbuffersize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.7.0</span>
 </div>
@@ -56962,7 +61530,7 @@ drop membership on all valid interfaces.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> the <code>SO_RCVBUF</code> socket receive buffer size in bytes.</li>
 </ul>
 <p>This method throws <a href="#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a> if called on an unbound socket.</p>
-<h3><code>socket.getSendBufferSize()</code><span><a class="mark" href="#dgram_socket_getsendbuffersize" id="dgram_socket_getsendbuffersize">#</a></span></h3>
+<h4><code>socket.getSendBufferSize()</code><span><a class="mark" href="#dgram_socket_getsendbuffersize" id="dgram_socket_getsendbuffersize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.7.0</span>
 </div>
@@ -56970,7 +61538,7 @@ drop membership on all valid interfaces.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> the <code>SO_SNDBUF</code> socket send buffer size in bytes.</li>
 </ul>
 <p>This method throws <a href="#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a> if called on an unbound socket.</p>
-<h3><code>socket.ref()</code><span><a class="mark" href="#dgram_socket_ref" id="dgram_socket_ref">#</a></span></h3>
+<h4><code>socket.ref()</code><span><a class="mark" href="#dgram_socket_ref" id="dgram_socket_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -56985,7 +61553,7 @@ counting and restores the default behavior.</p>
 <p>Calling <code>socket.ref()</code> multiples times will have no additional effect.</p>
 <p>The <code>socket.ref()</code> method returns a reference to the socket so calls can be
 chained.</p>
-<h3><code>socket.remoteAddress()</code><span><a class="mark" href="#dgram_socket_remoteaddress" id="dgram_socket_remoteaddress">#</a></span></h3>
+<h4><code>socket.remoteAddress()</code><span><a class="mark" href="#dgram_socket_remoteaddress" id="dgram_socket_remoteaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -56995,12 +61563,12 @@ chained.</p>
 <p>Returns an object containing the <code>address</code>, <code>family</code>, and <code>port</code> of the remote
 endpoint. This method throws an <a href="#errors_err_socket_dgram_not_connected"><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code></a> exception
 if the socket is not connected.</p>
-<h3><code>socket.send(msg[, offset, length][, port][, address][, callback])</code><span><a class="mark" href="#dgram_socket_send_msg_offset_length_port_address_callback" id="dgram_socket_send_msg_offset_length_port_address_callback">#</a></span></h3>
+<h4><code>socket.send(msg[, offset, length][, port][, address][, callback])</code><span><a class="mark" href="#dgram_socket_send_msg_offset_length_port_address_callback" id="dgram_socket_send_msg_offset_length_port_address_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>The <code>msg</code> parameter can now be any <code>TypedArray</code> or <code>DataView</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Added support for sending data on connected sockets.</p></td></tr>
@@ -57060,19 +61628,19 @@ or a <code>DataView</code>.</p>
 <p>This method throws <a href="#errors_err_socket_bad_port"><code>ERR_SOCKET_BAD_PORT</code></a> if called on an unbound socket.</p>
 <p>Example of sending a UDP packet to a port on <code>localhost</code>;</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> message = Buffer.from(<span class="hljs-string">'Some bytes'</span>);
-<span class="hljs-keyword">const</span> client = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
-client.send(message, <span class="hljs-number">41234</span>, <span class="hljs-string">'localhost'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  client.close();
+<span class="hljs-keyword">const</span> message = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Some bytes'</span>);
+<span class="hljs-keyword">const</span> client = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
+client.<span class="hljs-title function_">send</span>(message, <span class="hljs-number">41234</span>, <span class="hljs-string">'localhost'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  client.<span class="hljs-title function_">close</span>();
 });</code></pre>
 <p>Example of sending a UDP packet composed of multiple buffers to a port on
 <code>127.0.0.1</code>;</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'Some '</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'bytes'</span>);
-<span class="hljs-keyword">const</span> client = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
-client.send([buf1, buf2], <span class="hljs-number">41234</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  client.close();
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Some '</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'bytes'</span>);
+<span class="hljs-keyword">const</span> client = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
+client.<span class="hljs-title function_">send</span>([buf1, buf2], <span class="hljs-number">41234</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  client.<span class="hljs-title function_">close</span>();
 });</code></pre>
 <p>Sending multiple buffers might be faster or slower depending on the
 application and operating system. Run benchmarks to
@@ -57081,14 +61649,14 @@ however, sending multiple buffers is faster.</p>
 <p>Example of sending a UDP packet using a socket connected to a port on
 <code>localhost</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> message = Buffer.from(<span class="hljs-string">'Some bytes'</span>);
-<span class="hljs-keyword">const</span> client = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
-client.connect(<span class="hljs-number">41234</span>, <span class="hljs-string">'localhost'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  client.send(message, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    client.close();
+<span class="hljs-keyword">const</span> message = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Some bytes'</span>);
+<span class="hljs-keyword">const</span> client = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
+client.<span class="hljs-title function_">connect</span>(<span class="hljs-number">41234</span>, <span class="hljs-string">'localhost'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  client.<span class="hljs-title function_">send</span>(message, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    client.<span class="hljs-title function_">close</span>();
   });
 });</code></pre>
-<h4>Note about UDP datagram size<span><a class="mark" href="#dgram_note_about_udp_datagram_size" id="dgram_note_about_udp_datagram_size">#</a></span></h4>
+<h5>Note about UDP datagram size<span><a class="mark" href="#dgram_note_about_udp_datagram_size" id="dgram_note_about_udp_datagram_size">#</a></span></h5>
 <p>The maximum size of an IPv4/v6 datagram depends on the <code>MTU</code>
 (Maximum Transmission Unit) and on the <code>Payload Length</code> field size.</p>
 <ul>
@@ -57115,7 +61683,7 @@ minimum <code>MTU</code> of 1500.</p>
 a packet might travel. Sending a datagram greater than the receiver <code>MTU</code> will
 not work because the packet will get silently dropped without informing the
 source that the data did not reach its intended recipient.</p>
-<h3><code>socket.setBroadcast(flag)</code><span><a class="mark" href="#dgram_socket_setbroadcast_flag" id="dgram_socket_setbroadcast_flag">#</a></span></h3>
+<h4><code>socket.setBroadcast(flag)</code><span><a class="mark" href="#dgram_socket_setbroadcast_flag" id="dgram_socket_setbroadcast_flag">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.9</span>
 </div>
@@ -57125,7 +61693,7 @@ source that the data did not reach its intended recipient.</p>
 <p>Sets or clears the <code>SO_BROADCAST</code> socket option. When set to <code>true</code>, UDP
 packets may be sent to a local interface's broadcast address.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.setMulticastInterface(multicastInterface)</code><span><a class="mark" href="#dgram_socket_setmulticastinterface_multicastinterface" id="dgram_socket_setmulticastinterface_multicastinterface">#</a></span></h3>
+<h4><code>socket.setMulticastInterface(multicastInterface)</code><span><a class="mark" href="#dgram_socket_setmulticastinterface_multicastinterface" id="dgram_socket_setmulticastinterface_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.6.0</span>
 </div>
@@ -57148,27 +61716,27 @@ also use explicit scope in addresses, so only packets sent to a multicast
 address without specifying an explicit scope are affected by the most recent
 successful use of this call.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h4>Example: IPv6 outgoing multicast interface<span><a class="mark" href="#dgram_example_ipv6_outgoing_multicast_interface" id="dgram_example_ipv6_outgoing_multicast_interface">#</a></span></h4>
+<h5>Example: IPv6 outgoing multicast interface<span><a class="mark" href="#dgram_example_ipv6_outgoing_multicast_interface" id="dgram_example_ipv6_outgoing_multicast_interface">#</a></span></h5>
 <p>On most systems, where scope format uses the interface name:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.createSocket(<span class="hljs-string">'udp6'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp6'</span>);
 
-socket.bind(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
-  socket.setMulticastInterface(<span class="hljs-string">'::%eth1'</span>);
+socket.<span class="hljs-title function_">bind</span>(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
+  socket.<span class="hljs-title function_">setMulticastInterface</span>(<span class="hljs-string">'::%eth1'</span>);
 });</code></pre>
 <p>On Windows, where scope format uses an interface number:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.createSocket(<span class="hljs-string">'udp6'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp6'</span>);
 
-socket.bind(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
-  socket.setMulticastInterface(<span class="hljs-string">'::%2'</span>);
+socket.<span class="hljs-title function_">bind</span>(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
+  socket.<span class="hljs-title function_">setMulticastInterface</span>(<span class="hljs-string">'::%2'</span>);
 });</code></pre>
-<h4>Example: IPv4 outgoing multicast interface<span><a class="mark" href="#dgram_example_ipv4_outgoing_multicast_interface" id="dgram_example_ipv4_outgoing_multicast_interface">#</a></span></h4>
+<h5>Example: IPv4 outgoing multicast interface<span><a class="mark" href="#dgram_example_ipv4_outgoing_multicast_interface" id="dgram_example_ipv4_outgoing_multicast_interface">#</a></span></h5>
 <p>All systems use an IP of the host on the desired physical interface:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
 
-socket.bind(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
-  socket.setMulticastInterface(<span class="hljs-string">'10.0.0.2'</span>);
+socket.<span class="hljs-title function_">bind</span>(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
+  socket.<span class="hljs-title function_">setMulticastInterface</span>(<span class="hljs-string">'10.0.0.2'</span>);
 });</code></pre>
-<h4>Call results<span><a class="mark" href="#dgram_call_results" id="dgram_call_results">#</a></span></h4>
+<h5>Call results<span><a class="mark" href="#dgram_call_results" id="dgram_call_results">#</a></span></h5>
 <p>A call on a socket that is not ready to send or no longer open may throw a <em>Not
 running</em> <a href="#errors_class_error"><code>Error</code></a>.</p>
 <p>If <code>multicastInterface</code> can not be parsed into an IP then an <em>EINVAL</em>
@@ -57181,7 +61749,7 @@ continuing to use (or returning to) the system's default interface selection.</p
 <p>A socket's address family's ANY address (IPv4 <code>'0.0.0.0'</code> or IPv6 <code>'::'</code>) can be
 used to return control of the sockets default outgoing interface to the system
 for future multicast packets.</p>
-<h3><code>socket.setMulticastLoopback(flag)</code><span><a class="mark" href="#dgram_socket_setmulticastloopback_flag" id="dgram_socket_setmulticastloopback_flag">#</a></span></h3>
+<h4><code>socket.setMulticastLoopback(flag)</code><span><a class="mark" href="#dgram_socket_setmulticastloopback_flag" id="dgram_socket_setmulticastloopback_flag">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.8</span>
 </div>
@@ -57191,7 +61759,7 @@ for future multicast packets.</p>
 <p>Sets or clears the <code>IP_MULTICAST_LOOP</code> socket option. When set to <code>true</code>,
 multicast packets will also be received on the local interface.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.setMulticastTTL(ttl)</code><span><a class="mark" href="#dgram_socket_setmulticastttl_ttl" id="dgram_socket_setmulticastttl_ttl">#</a></span></h3>
+<h4><code>socket.setMulticastTTL(ttl)</code><span><a class="mark" href="#dgram_socket_setmulticastttl_ttl" id="dgram_socket_setmulticastttl_ttl">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.8</span>
 </div>
@@ -57205,7 +61773,7 @@ router or gateway that forwards a packet decrements the TTL. If the TTL is
 decremented to 0 by a router, it will not be forwarded.</p>
 <p>The <code>ttl</code> argument may be between 0 and 255. The default on most systems is <code>1</code>.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.setRecvBufferSize(size)</code><span><a class="mark" href="#dgram_socket_setrecvbuffersize_size" id="dgram_socket_setrecvbuffersize_size">#</a></span></h3>
+<h4><code>socket.setRecvBufferSize(size)</code><span><a class="mark" href="#dgram_socket_setrecvbuffersize_size" id="dgram_socket_setrecvbuffersize_size">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.7.0</span>
 </div>
@@ -57215,7 +61783,7 @@ decremented to 0 by a router, it will not be forwarded.</p>
 <p>Sets the <code>SO_RCVBUF</code> socket option. Sets the maximum socket receive buffer
 in bytes.</p>
 <p>This method throws <a href="#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a> if called on an unbound socket.</p>
-<h3><code>socket.setSendBufferSize(size)</code><span><a class="mark" href="#dgram_socket_setsendbuffersize_size" id="dgram_socket_setsendbuffersize_size">#</a></span></h3>
+<h4><code>socket.setSendBufferSize(size)</code><span><a class="mark" href="#dgram_socket_setsendbuffersize_size" id="dgram_socket_setsendbuffersize_size">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.7.0</span>
 </div>
@@ -57225,7 +61793,7 @@ in bytes.</p>
 <p>Sets the <code>SO_SNDBUF</code> socket option. Sets the maximum socket send buffer
 in bytes.</p>
 <p>This method throws <a href="#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a> if called on an unbound socket.</p>
-<h3><code>socket.setTTL(ttl)</code><span><a class="mark" href="#dgram_socket_setttl_ttl" id="dgram_socket_setttl_ttl">#</a></span></h3>
+<h4><code>socket.setTTL(ttl)</code><span><a class="mark" href="#dgram_socket_setttl_ttl" id="dgram_socket_setttl_ttl">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.101</span>
 </div>
@@ -57240,7 +61808,7 @@ Changing TTL values is typically done for network probes or when multicasting.</
 <p>The <code>ttl</code> argument may be between between 1 and 255. The default on most systems
 is 64.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.unref()</code><span><a class="mark" href="#dgram_socket_unref" id="dgram_socket_unref">#</a></span></h3>
+<h4><code>socket.unref()</code><span><a class="mark" href="#dgram_socket_unref" id="dgram_socket_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -57255,12 +61823,14 @@ listening.</p>
 <p>Calling <code>socket.unref()</code> multiple times will have no addition effect.</p>
 <p>The <code>socket.unref()</code> method returns a reference to the socket so calls can be
 chained.</p>
-<h2><code>dgram</code> module functions<span><a class="mark" href="#dgram_dgram_module_functions" id="dgram_dgram_module_functions">#</a></span></h2>
-<h3><code>dgram.createSocket(options[, callback])</code><span><a class="mark" href="#dgram_dgram_createsocket_options_callback" id="dgram_dgram_createsocket_options_callback">#</a></span></h3>
+</section><section><h3><code>dgram</code> module functions<span><a class="mark" href="#dgram_dgram_module_functions" id="dgram_dgram_module_functions">#</a></span></h3>
+<h4><code>dgram.createSocket(options[, callback])</code><span><a class="mark" href="#dgram_dgram_createsocket_options_callback" id="dgram_dgram_createsocket_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
 <tr><td>v11.4.0</td>
 <td><p>The <code>ipv6Only</code> option is supported.</p></td></tr>
 <tr><td>v8.7.0</td>
@@ -57286,6 +61856,7 @@ disable dual-stack support, i.e., binding to address <code>::</code> won't make
 <li><code>recvBufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the <code>SO_RCVBUF</code> socket value.</li>
 <li><code>sendBufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the <code>SO_SNDBUF</code> socket value.</li>
 <li><code>lookup</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Custom lookup function. <strong>Default:</strong> <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>.</li>
+<li><code>signal</code> <a href="#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> An AbortSignal that may be used to close a socket.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Attached as a listener for <code>'message'</code> events. Optional.</li>
@@ -57298,7 +61869,17 @@ method will bind the socket to the "all interfaces" address on a random port
 (it does the right thing for both <code>udp4</code> and <code>udp6</code> sockets). The bound address
 and port can be retrieved using <a href="#dgram_socket_address"><code>socket.address().address</code></a> and
 <a href="#dgram_socket_address"><code>socket.address().port</code></a>.</p>
-<h3><code>dgram.createSocket(type[, callback])</code><span><a class="mark" href="#dgram_dgram_createsocket_type_callback" id="dgram_dgram_createsocket_type_callback">#</a></span></h3>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.close()</code> on the socket:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> server = dgram.<span class="hljs-title function_">createSocket</span>({ <span class="hljs-attr">type</span>: <span class="hljs-string">'udp4'</span>, signal });
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
+});
+<span class="hljs-comment">// Later, when you want to close the server.</span>
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<h4><code>dgram.createSocket(type[, callback])</code><span><a class="mark" href="#dgram_dgram_createsocket_type_callback" id="dgram_dgram_createsocket_type_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -57313,15 +61894,16 @@ socket to begin listening for datagram messages. When <code>address</code> and <
 not passed to <a href="#dgram_socket_bind_port_address_callback"><code>socket.bind()</code></a> the method will bind the socket to the "all
 interfaces" address on a random port (it does the right thing for both <code>udp4</code>
 and <code>udp6</code> sockets). The bound address and port can be retrieved using
-<a href="#dgram_socket_address"><code>socket.address().address</code></a> and <a href="#dgram_socket_address"><code>socket.address().port</code></a>.</p>
-<h1>URL<span><a class="mark" href="#url_url" id="url_url">#</a></span></h1>
+<a href="#dgram_socket_address"><code>socket.address().address</code></a> and <a href="#dgram_socket_address"><code>socket.address().port</code></a>.</p></section>
+        </section>
+<section><h2>URL<span><a class="mark" href="#url_url" id="url_url">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/url.js">lib/url.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/url.js">lib/url.js</a></p>
 <p>The <code>url</code> module provides utilities for URL resolution and parsing. It can be
 accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);</code></pre>
-<h2>URL strings and URL objects<span><a class="mark" href="#url_url_strings_and_url_objects" id="url_url_strings_and_url_objects">#</a></span></h2>
+<section><h3>URL strings and URL objects<span><a class="mark" href="#url_url_strings_and_url_objects" id="url_url_strings_and_url_objects">#</a></span></h3>
 <p>A URL string is a structured string containing multiple meaningful components.
 When parsed, a URL object is returned containing properties for each of these
 components.</p>
@@ -57329,7 +61911,7 @@ components.</p>
 Node.js specific, and a newer API that implements the same
 <a href="https://url.spec.whatwg.org/">WHATWG URL Standard</a> used by web browsers.</p>
 <p>A comparison between the WHATWG and Legacy APIs is provided below. Above the URL
-<code>'http://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>, properties
+<code>'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>, properties
 of an object returned by the legacy <code>url.parse()</code> are shown. Below it are
 properties of a WHATWG <code>URL</code> object.</p>
 <p>WHATWG URL's <code>origin</code> property includes <code>protocol</code> and <code>host</code>, but not
@@ -57354,13 +61936,26 @@ properties of a WHATWG <code>URL</code> object.</p>
 (All spaces in the "" line should be ignored. They are purely for formatting.)</code></pre>
 <p>Parsing the URL string using the WHATWG API:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> myURL =
-  <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</span>);</code></pre>
+  <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</span>);</code></pre>
 <p>Parsing the URL string using the Legacy API:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
 <span class="hljs-keyword">const</span> myURL =
-  url.parse(<span class="hljs-string">'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</span>);</code></pre>
-<h2>The WHATWG URL API<span><a class="mark" href="#url_the_whatwg_url_api" id="url_the_whatwg_url_api">#</a></span></h2>
-<h3>Class: <code>URL</code><span><a class="mark" href="#url_class_url" id="url_class_url">#</a></span></h3>
+  url.<span class="hljs-title function_">parse</span>(<span class="hljs-string">'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</span>);</code></pre>
+<h4>Constructing a URL from component parts and getting the constructed string<span><a class="mark" href="#url_constructing_a_url_from_component_parts_and_getting_the_constructed_string" id="url_constructing_a_url_from_component_parts_and_getting_the_constructed_string">#</a></span></h4>
+<p>It is possible to construct a WHATWG URL from component parts using either the
+property setters or a template literal string:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org'</span>);
+myURL.<span class="hljs-property">pathname</span> = <span class="hljs-string">'/a/b/c'</span>;
+myURL.<span class="hljs-property">search</span> = <span class="hljs-string">'?d=e'</span>;
+myURL.<span class="hljs-property">hash</span> = <span class="hljs-string">'#fgh'</span>;</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> pathname = <span class="hljs-string">'/a/b/c'</span>;
+<span class="hljs-keyword">const</span> search = <span class="hljs-string">'?d=e'</span>;
+<span class="hljs-keyword">const</span> hash = <span class="hljs-string">'#fgh'</span>;
+<span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">`https://example.org<span class="hljs-subst">${pathname}</span><span class="hljs-subst">${search}</span><span class="hljs-subst">${hash}</span>`</span>);</code></pre>
+<p>To get the constructed URL string, use the <code>href</code> property accessor:</p>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);</code></pre>
+</section><section><h3>The WHATWG URL API<span><a class="mark" href="#url_the_whatwg_url_api" id="url_the_whatwg_url_api">#</a></span></h3>
+<h4>Class: <code>URL</code><span><a class="mark" href="#url_class_url" id="url_class_url">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -57380,7 +61975,7 @@ are implemented as getters and setters on the class prototype, rather than as
 data properties on the object itself. Thus, unlike <a href="#url_legacy_urlobject">legacy <code>urlObject</code></a>s,
 using the <code>delete</code> keyword on any properties of <code>URL</code> objects (e.g. <code>delete myURL.protocol</code>, <code>delete myURL.pathname</code>, etc) has no effect but will still
 return <code>true</code>.</p>
-<h4><code>new URL(input[, base])</code><span><a class="mark" href="#url_new_url_input_base" id="url_new_url_input_base">#</a></span></h4>
+<h5><code>new URL(input[, base])</code><span><a class="mark" href="#url_new_url_input_base" id="url_new_url_input_base">#</a></span></h5>
 <ul>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The absolute or relative input URL to parse. If <code>input</code>
 is relative, then <code>base</code> is required. If <code>input</code> is absolute, the <code>base</code>
@@ -57390,97 +61985,103 @@ absolute.</li>
 </ul>
 <p>Creates a new <code>URL</code> object by parsing the <code>input</code> relative to the <code>base</code>. If
 <code>base</code> is passed as a string, it will be parsed equivalent to <code>new URL(base)</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'/foo'</span>, <span class="hljs-string">'https://example.org/'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/foo'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// https://example.org/foo</span></code></pre>
 <p>The URL constructor is accessible as a property on the global object.
 It can also be imported from the built-in url module:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(URL === <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>).URL); <span class="hljs-comment">// Prints 'true'.</span></code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable constant_">URL</span> === <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>).<span class="hljs-property">URL</span>); <span class="hljs-comment">// Prints 'true'.</span></code></pre>
 <p>A <code>TypeError</code> will be thrown if the <code>input</code> or <code>base</code> are not valid URLs. Note
 that an effort will be made to coerce the given values into strings. For
 instance:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL({ <span class="hljs-attr">toString</span>: <span class="hljs-function">() =></span> <span class="hljs-string">'https://example.org/'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>({ <span class="hljs-attr">toString</span>: <span class="hljs-function">() =></span> <span class="hljs-string">'https://example.org/'</span> });
 <span class="hljs-comment">// https://example.org/</span></code></pre>
 <p>Unicode characters appearing within the host name of <code>input</code> will be
 automatically converted to ASCII using the <a href="https://tools.ietf.org/html/rfc5891#section-4.4">Punycode</a> algorithm.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://測試'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://測試'</span>);
 <span class="hljs-comment">// https://xn--g6w251d/</span></code></pre>
 <p>This feature is only available if the <code>node</code> executable was compiled with
 <a href="#intl_options_for_building_node_js">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>
 <p>In cases where it is not known in advance if <code>input</code> is an absolute URL
 and a <code>base</code> is provided, it is advised to validate that the <code>origin</code> of
 the <code>URL</code> object is what is expected.</p>
-<pre><code class="language-js"><span class="hljs-keyword">let</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">let</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// http://example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// https://example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'foo://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'foo://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// foo://Example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// http://example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// https://example.org/Example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'foo:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'foo:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// foo:Example.com/</span></code></pre>
-<h4><code>url.hash</code><span><a class="mark" href="#url_url_hash" id="url_url_hash">#</a></span></h4>
+<h5><code>url.hash</code><span><a class="mark" href="#url_url_hash" id="url_url_hash">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the fragment portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/foo#bar'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.hash);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/foo#bar'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">hash</span>);
 <span class="hljs-comment">// Prints #bar</span>
 
-myURL.hash = <span class="hljs-string">'baz'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">hash</span> = <span class="hljs-string">'baz'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/foo#baz</span></code></pre>
 <p>Invalid URL characters included in the value assigned to the <code>hash</code> property
 are <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which characters to
 percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a> and
 <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.host</code><span><a class="mark" href="#url_url_host" id="url_url_host">#</a></span></h4>
+<h5><code>url.host</code><span><a class="mark" href="#url_url_host" id="url_url_host">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the host portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org:81/foo'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.host);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org:81/foo'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">host</span>);
 <span class="hljs-comment">// Prints example.org:81</span>
 
-myURL.host = <span class="hljs-string">'example.com:82'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">host</span> = <span class="hljs-string">'example.com:82'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.com:82/foo</span></code></pre>
 <p>Invalid host values assigned to the <code>host</code> property are ignored.</p>
-<h4><code>url.hostname</code><span><a class="mark" href="#url_url_hostname" id="url_url_hostname">#</a></span></h4>
+<h5><code>url.hostname</code><span><a class="mark" href="#url_url_hostname" id="url_url_hostname">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the host name portion of the URL. The key difference between
 <code>url.host</code> and <code>url.hostname</code> is that <code>url.hostname</code> does <em>not</em> include the
 port.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org:81/foo'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.hostname);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org:81/foo'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">hostname</span>);
 <span class="hljs-comment">// Prints example.org</span>
 
-myURL.hostname = <span class="hljs-string">'example.com:82'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
-<span class="hljs-comment">// Prints https://example.com:81/foo</span></code></pre>
+<span class="hljs-comment">// Setting the hostname does not change the port</span>
+myURL.<span class="hljs-property">hostname</span> = <span class="hljs-string">'example.com:82'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
+<span class="hljs-comment">// Prints https://example.com:81/foo</span>
+
+<span class="hljs-comment">// Use myURL.host to change the hostname and port</span>
+myURL.<span class="hljs-property">host</span> = <span class="hljs-string">'example.org:82'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
+<span class="hljs-comment">// Prints https://example.org:82/foo</span></code></pre>
 <p>Invalid host name values assigned to the <code>hostname</code> property are ignored.</p>
-<h4><code>url.href</code><span><a class="mark" href="#url_url_href" id="url_url_href">#</a></span></h4>
+<h5><code>url.href</code><span><a class="mark" href="#url_url_href" id="url_url_href">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the serialized URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/foo'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/foo'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/foo</span>
 
-myURL.href = <span class="hljs-string">'https://example.com/bar'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">href</span> = <span class="hljs-string">'https://example.com/bar'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.com/bar</span></code></pre>
 <p>Getting the value of the <code>href</code> property is equivalent to calling
 <a href="#url_url_tostring"><code>url.toString()</code></a>.</p>
@@ -57489,53 +62090,53 @@ new <code>URL</code> object using <a href="#url_new_url_input_base"><code>new UR
 object's properties will be modified.</p>
 <p>If the value assigned to the <code>href</code> property is not a valid URL, a <code>TypeError</code>
 will be thrown.</p>
-<h4><code>url.origin</code><span><a class="mark" href="#url_url_origin" id="url_url_origin">#</a></span></h4>
+<h5><code>url.origin</code><span><a class="mark" href="#url_url_origin" id="url_url_origin">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets the read-only serialization of the URL's origin.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/foo/bar?baz'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.origin);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/foo/bar?baz'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">origin</span>);
 <span class="hljs-comment">// Prints https://example.org</span></code></pre>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> idnURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://測試'</span>);
-<span class="hljs-built_in">console</span>.log(idnURL.origin);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> idnURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://測試'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(idnURL.<span class="hljs-property">origin</span>);
 <span class="hljs-comment">// Prints https://xn--g6w251d</span>
 
-<span class="hljs-built_in">console</span>.log(idnURL.hostname);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(idnURL.<span class="hljs-property">hostname</span>);
 <span class="hljs-comment">// Prints xn--g6w251d</span></code></pre>
-<h4><code>url.password</code><span><a class="mark" href="#url_url_password" id="url_url_password">#</a></span></h4>
+<h5><code>url.password</code><span><a class="mark" href="#url_url_password" id="url_url_password">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the password portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.password);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">password</span>);
 <span class="hljs-comment">// Prints xyz</span>
 
-myURL.password = <span class="hljs-string">'123'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">password</span> = <span class="hljs-string">'123'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://abc:123@example.com</span></code></pre>
 <p>Invalid URL characters included in the value assigned to the <code>password</code> property
 are <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which characters to
 percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a> and
 <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.pathname</code><span><a class="mark" href="#url_url_pathname" id="url_url_pathname">#</a></span></h4>
+<h5><code>url.pathname</code><span><a class="mark" href="#url_url_pathname" id="url_url_pathname">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the path portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/abc/xyz?123'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.pathname);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/abc/xyz?123'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">pathname</span>);
 <span class="hljs-comment">// Prints /abc/xyz</span>
 
-myURL.pathname = <span class="hljs-string">'/abcdef'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">pathname</span> = <span class="hljs-string">'/abcdef'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/abcdef?123</span></code></pre>
 <p>Invalid URL characters included in the value assigned to the <code>pathname</code>
 property are <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which characters
 to percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a> and
 <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.port</code><span><a class="mark" href="#url_url_port" id="url_url_port">#</a></span></h4>
+<h5><code>url.port</code><span><a class="mark" href="#url_url_port" id="url_url_port">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -57589,107 +62190,107 @@ string using <code>.toString()</code>.</p>
 <p>If that string is invalid but it begins with a number, the leading number is
 assigned to <code>port</code>.
 If the number lies outside the range denoted above, it is ignored.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org:8888'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.port);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org:8888'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 8888</span>
 
 <span class="hljs-comment">// Default ports are automatically transformed to the empty string</span>
 <span class="hljs-comment">// (HTTPS protocol's default port is 443)</span>
-myURL.port = <span class="hljs-string">'443'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-string">'443'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints the empty string</span>
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/</span>
 
-myURL.port = <span class="hljs-number">1234</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-number">1234</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 1234</span>
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org:1234/</span>
 
 <span class="hljs-comment">// Completely invalid port strings are ignored</span>
-myURL.port = <span class="hljs-string">'abcd'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-string">'abcd'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 1234</span>
 
 <span class="hljs-comment">// Leading numbers are treated as a port number</span>
-myURL.port = <span class="hljs-string">'5678abcd'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-string">'5678abcd'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 5678</span>
 
 <span class="hljs-comment">// Non-integers are truncated</span>
-myURL.port = <span class="hljs-number">1234.5678</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-number">1234.5678</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 1234</span>
 
 <span class="hljs-comment">// Out-of-range numbers which are not represented in scientific notation</span>
 <span class="hljs-comment">// will be ignored.</span>
-myURL.port = <span class="hljs-number">1e10</span>; <span class="hljs-comment">// 10000000000, will be range-checked as described below</span>
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-number">1e10</span>; <span class="hljs-comment">// 10000000000, will be range-checked as described below</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 1234</span></code></pre>
 <p>Numbers which contain a decimal point,
 such as floating-point numbers or numbers in scientific notation,
 are not an exception to this rule.
 Leading numbers up to the decimal point will be set as the URL's port,
 assuming they are valid:</p>
-<pre><code class="language-js">myURL.port = <span class="hljs-number">4.567e21</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+<pre><code class="language-js">myURL.<span class="hljs-property">port</span> = <span class="hljs-number">4.567e21</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 4 (because it is the leading number in the string '4.567e21')</span></code></pre>
-<h4><code>url.protocol</code><span><a class="mark" href="#url_url_protocol" id="url_url_protocol">#</a></span></h4>
+<h5><code>url.protocol</code><span><a class="mark" href="#url_url_protocol" id="url_url_protocol">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the protocol portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.protocol);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">protocol</span>);
 <span class="hljs-comment">// Prints https:</span>
 
-myURL.protocol = <span class="hljs-string">'ftp'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">protocol</span> = <span class="hljs-string">'ftp'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints ftp://example.org/</span></code></pre>
 <p>Invalid URL protocol values assigned to the <code>protocol</code> property are ignored.</p>
-<h5>Special schemes<span><a class="mark" href="#url_special_schemes" id="url_special_schemes">#</a></span></h5>
+<h6>Special schemes<span><a class="mark" href="#url_special_schemes" id="url_special_schemes">#</a></span></h6>
 <p>The <a href="https://url.spec.whatwg.org/">WHATWG URL Standard</a> considers a handful of URL protocol schemes to be
 <em>special</em> in terms of how they are parsed and serialized. When a URL is
 parsed using one of these special protocols, the <code>url.protocol</code> property
 may be changed to another special protocol but cannot be changed to a
 non-special protocol, and vice versa.</p>
 <p>For instance, changing from <code>http</code> to <code>https</code> works:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http://example.org'</span>);
-u.protocol = <span class="hljs-string">'https'</span>;
-<span class="hljs-built_in">console</span>.log(u.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http://example.org'</span>);
+u.<span class="hljs-property">protocol</span> = <span class="hljs-string">'https'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// https://example.org</span></code></pre>
 <p>However, changing from <code>http</code> to a hypothetical <code>fish</code> protocol does not
 because the new protocol is not special.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http://example.org'</span>);
-u.protocol = <span class="hljs-string">'fish'</span>;
-<span class="hljs-built_in">console</span>.log(u.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http://example.org'</span>);
+u.<span class="hljs-property">protocol</span> = <span class="hljs-string">'fish'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// http://example.org</span></code></pre>
 <p>Likewise, changing from a non-special protocol to a special protocol is also
 not permitted:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'fish://example.org'</span>);
-u.protocol = <span class="hljs-string">'http'</span>;
-<span class="hljs-built_in">console</span>.log(u.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'fish://example.org'</span>);
+u.<span class="hljs-property">protocol</span> = <span class="hljs-string">'http'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// fish://example.org</span></code></pre>
 <p>According to the WHATWG URL Standard, special protocol schemes are <code>ftp</code>,
 <code>file</code>, <code>gopher</code>, <code>http</code>, <code>https</code>, <code>ws</code>, and <code>wss</code>.</p>
-<h4><code>url.search</code><span><a class="mark" href="#url_url_search" id="url_url_search">#</a></span></h4>
+<h5><code>url.search</code><span><a class="mark" href="#url_url_search" id="url_url_search">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the serialized query portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/abc?123'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.search);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/abc?123'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">search</span>);
 <span class="hljs-comment">// Prints ?123</span>
 
-myURL.search = <span class="hljs-string">'abc=xyz'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">search</span> = <span class="hljs-string">'abc=xyz'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/abc?abc=xyz</span></code></pre>
 <p>Any invalid URL characters appearing in the value assigned the <code>search</code>
 property will be <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which
 characters to percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a>
 and <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.searchParams</code><span><a class="mark" href="#url_url_searchparams" id="url_url_searchparams">#</a></span></h4>
+<h5><code>url.searchParams</code><span><a class="mark" href="#url_url_searchparams" id="url_url_searchparams">#</a></span></h5>
 <ul>
 <li><a href="#url_class_urlsearchparams" class="type">&#x3C;URLSearchParams></a></li>
 </ul>
@@ -57703,31 +62304,31 @@ per the WHATWG specification, the <code>URLSearchParams</code> object uses
 different rules to determine which characters to percent-encode. For
 instance, the <code>URL</code> object will not percent encode the ASCII tilde (<code>~</code>)
 character, while <code>URLSearchParams</code> will always encode it:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myUrl = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/abc?foo=~bar'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myUrl = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/abc?foo=~bar'</span>);
 
-<span class="hljs-built_in">console</span>.log(myUrl.search);  <span class="hljs-comment">// prints ?foo=~bar</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myUrl.<span class="hljs-property">search</span>);  <span class="hljs-comment">// prints ?foo=~bar</span>
 
 <span class="hljs-comment">// Modify the URL via searchParams...</span>
-myUrl.searchParams.sort();
+myUrl.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">sort</span>();
 
-<span class="hljs-built_in">console</span>.log(myUrl.search);  <span class="hljs-comment">// prints ?foo=%7Ebar</span></code></pre>
-<h4><code>url.username</code><span><a class="mark" href="#url_url_username" id="url_url_username">#</a></span></h4>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myUrl.<span class="hljs-property">search</span>);  <span class="hljs-comment">// prints ?foo=%7Ebar</span></code></pre>
+<h5><code>url.username</code><span><a class="mark" href="#url_url_username" id="url_url_username">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the username portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.username);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">username</span>);
 <span class="hljs-comment">// Prints abc</span>
 
-myURL.username = <span class="hljs-string">'123'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">username</span> = <span class="hljs-string">'123'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://123:xyz@example.com/</span></code></pre>
 <p>Any invalid URL characters appearing in the value assigned the <code>username</code>
 property will be <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which
 characters to percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a>
 and <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.toString()</code><span><a class="mark" href="#url_url_tostring" id="url_url_tostring">#</a></span></h4>
+<h5><code>url.toString()</code><span><a class="mark" href="#url_url_tostring" id="url_url_tostring">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -57736,7 +62337,7 @@ value returned is equivalent to that of <a href="#url_url_href"><code>url.href</
 <p>Because of the need for standard compliance, this method does not allow users
 to customize the serialization process of the URL. For more flexibility,
 <a href="#url_url_format_url_options"><code>require('url').format()</code></a> method might be of interest.</p>
-<h4><code>url.toJSON()</code><span><a class="mark" href="#url_url_tojson" id="url_url_tojson">#</a></span></h4>
+<h5><code>url.toJSON()</code><span><a class="mark" href="#url_url_tojson" id="url_url_tojson">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -57746,12 +62347,12 @@ value returned is equivalent to that of <a href="#url_url_href"><code>url.href</
 <p>This method is automatically called when an <code>URL</code> object is serialized
 with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify"><code>JSON.stringify()</code></a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> myURLs = [
-  <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://www.example.com'</span>),
-  <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://test.example.org'</span>)
+  <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://www.example.com'</span>),
+  <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://test.example.org'</span>),
 ];
-<span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">JSON</span>.stringify(myURLs));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(myURLs));
 <span class="hljs-comment">// Prints ["https://www.example.com/","https://test.example.org/"]</span></code></pre>
-<h3>Class: <code>URLSearchParams</code><span><a class="mark" href="#url_class_urlsearchparams" id="url_class_urlsearchparams">#</a></span></h3>
+<h4>Class: <code>URLSearchParams</code><span><a class="mark" href="#url_class_urlsearchparams" id="url_class_urlsearchparams">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -57771,39 +62372,39 @@ The <code>URLSearchParams</code> class is also available on the global object.</
 similar purpose, but the purpose of the <a href="querystring.html"><code>querystring</code></a> module is more
 general, as it allows the customization of delimiter characters (<code>&#x26;</code> and <code>=</code>).
 On the other hand, this API is designed purely for URL query strings.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/?abc=123'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.searchParams.get(<span class="hljs-string">'abc'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/?abc=123'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">get</span>(<span class="hljs-string">'abc'</span>));
 <span class="hljs-comment">// Prints 123</span>
 
-myURL.searchParams.append(<span class="hljs-string">'abc'</span>, <span class="hljs-string">'xyz'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">append</span>(<span class="hljs-string">'abc'</span>, <span class="hljs-string">'xyz'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?abc=123&#x26;abc=xyz</span>
 
-myURL.searchParams.delete(<span class="hljs-string">'abc'</span>);
-myURL.searchParams.set(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">delete</span>(<span class="hljs-string">'abc'</span>);
+myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">set</span>(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?a=b</span>
 
-<span class="hljs-keyword">const</span> newSearchParams = <span class="hljs-keyword">new</span> URLSearchParams(myURL.searchParams);
+<span class="hljs-keyword">const</span> newSearchParams = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(myURL.<span class="hljs-property">searchParams</span>);
 <span class="hljs-comment">// The above is equivalent to</span>
 <span class="hljs-comment">// const newSearchParams = new URLSearchParams(myURL.search);</span>
 
-newSearchParams.append(<span class="hljs-string">'a'</span>, <span class="hljs-string">'c'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+newSearchParams.<span class="hljs-title function_">append</span>(<span class="hljs-string">'a'</span>, <span class="hljs-string">'c'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?a=b</span>
-<span class="hljs-built_in">console</span>.log(newSearchParams.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(newSearchParams.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints a=b&#x26;a=c</span>
 
 <span class="hljs-comment">// newSearchParams.toString() is implicitly called</span>
-myURL.search = newSearchParams;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">search</span> = newSearchParams;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?a=b&#x26;a=c</span>
-newSearchParams.delete(<span class="hljs-string">'a'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+newSearchParams.<span class="hljs-title function_">delete</span>(<span class="hljs-string">'a'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?a=b&#x26;a=c</span></code></pre>
-<h4><code>new URLSearchParams()</code><span><a class="mark" href="#url_new_urlsearchparams" id="url_new_urlsearchparams">#</a></span></h4>
+<h5><code>new URLSearchParams()</code><span><a class="mark" href="#url_new_urlsearchparams" id="url_new_urlsearchparams">#</a></span></h5>
 <p>Instantiate a new empty <code>URLSearchParams</code> object.</p>
-<h4><code>new URLSearchParams(string)</code><span><a class="mark" href="#url_new_urlsearchparams_string" id="url_new_urlsearchparams_string">#</a></span></h4>
+<h5><code>new URLSearchParams(string)</code><span><a class="mark" href="#url_new_urlsearchparams_string" id="url_new_urlsearchparams_string">#</a></span></h5>
 <ul>
 <li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A query string</li>
 </ul>
@@ -57811,16 +62412,16 @@ newSearchParams.delete(<span class="hljs-string">'a'</span>);
 <code>URLSearchParams</code> object. A leading <code>'?'</code>, if present, is ignored.</p>
 <pre><code class="language-js"><span class="hljs-keyword">let</span> params;
 
-params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'user=abc&#x26;query=xyz'</span>);
-<span class="hljs-built_in">console</span>.log(params.get(<span class="hljs-string">'user'</span>));
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'user=abc&#x26;query=xyz'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">get</span>(<span class="hljs-string">'user'</span>));
 <span class="hljs-comment">// Prints 'abc'</span>
-<span class="hljs-built_in">console</span>.log(params.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=xyz'</span>
 
-params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'?user=abc&#x26;query=xyz'</span>);
-<span class="hljs-built_in">console</span>.log(params.toString());
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'?user=abc&#x26;query=xyz'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=xyz'</span></code></pre>
-<h4><code>new URLSearchParams(obj)</code><span><a class="mark" href="#url_new_urlsearchparams_obj" id="url_new_urlsearchparams_obj">#</a></span></h4>
+<h5><code>new URLSearchParams(obj)</code><span><a class="mark" href="#url_new_urlsearchparams_obj" id="url_new_urlsearchparams_obj">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v7.10.0, v6.13.0</span>
 </div>
@@ -57832,15 +62433,15 @@ value of each property of <code>obj</code> are always coerced to strings.</p>
 <p>Unlike <a href="querystring.html"><code>querystring</code></a> module, duplicate keys in the form of array values are
 not allowed. Arrays are stringified using <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString"><code>array.toString()</code></a>, which simply
 joins all array elements with commas.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>({
   <span class="hljs-attr">user</span>: <span class="hljs-string">'abc'</span>,
   <span class="hljs-attr">query</span>: [<span class="hljs-string">'first'</span>, <span class="hljs-string">'second'</span>]
 });
-<span class="hljs-built_in">console</span>.log(params.getAll(<span class="hljs-string">'query'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">getAll</span>(<span class="hljs-string">'query'</span>));
 <span class="hljs-comment">// Prints [ 'first,second' ]</span>
-<span class="hljs-built_in">console</span>.log(params.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=first%2Csecond'</span></code></pre>
-<h4><code>new URLSearchParams(iterable)</code><span><a class="mark" href="#url_new_urlsearchparams_iterable" id="url_new_urlsearchparams_iterable">#</a></span></h4>
+<h5><code>new URLSearchParams(iterable)</code><span><a class="mark" href="#url_new_urlsearchparams_iterable" id="url_new_urlsearchparams_iterable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v7.10.0, v6.13.0</span>
 </div>
@@ -57857,50 +62458,50 @@ themselves be any iterable object.</p>
 <pre><code class="language-js"><span class="hljs-keyword">let</span> params;
 
 <span class="hljs-comment">// Using an array</span>
-params = <span class="hljs-keyword">new</span> URLSearchParams([
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>([
   [<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>],
   [<span class="hljs-string">'query'</span>, <span class="hljs-string">'first'</span>],
-  [<span class="hljs-string">'query'</span>, <span class="hljs-string">'second'</span>]
+  [<span class="hljs-string">'query'</span>, <span class="hljs-string">'second'</span>],
 ]);
-<span class="hljs-built_in">console</span>.log(params.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=first&#x26;query=second'</span>
 
 <span class="hljs-comment">// Using a Map object</span>
-<span class="hljs-keyword">const</span> map = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>();
-map.set(<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>);
-map.set(<span class="hljs-string">'query'</span>, <span class="hljs-string">'xyz'</span>);
-params = <span class="hljs-keyword">new</span> URLSearchParams(map);
-<span class="hljs-built_in">console</span>.log(params.toString());
+<span class="hljs-keyword">const</span> map = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>();
+map.<span class="hljs-title function_">set</span>(<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>);
+map.<span class="hljs-title function_">set</span>(<span class="hljs-string">'query'</span>, <span class="hljs-string">'xyz'</span>);
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(map);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=xyz'</span>
 
 <span class="hljs-comment">// Using a generator function</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span>* <span class="hljs-title">getQueryPairs</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">function</span>* <span class="hljs-title function_">getQueryPairs</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">yield</span> [<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>];
   <span class="hljs-keyword">yield</span> [<span class="hljs-string">'query'</span>, <span class="hljs-string">'first'</span>];
   <span class="hljs-keyword">yield</span> [<span class="hljs-string">'query'</span>, <span class="hljs-string">'second'</span>];
 }
-params = <span class="hljs-keyword">new</span> URLSearchParams(getQueryPairs());
-<span class="hljs-built_in">console</span>.log(params.toString());
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-title function_">getQueryPairs</span>());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=first&#x26;query=second'</span>
 
 <span class="hljs-comment">// Each key-value pair must have exactly two elements</span>
-<span class="hljs-keyword">new</span> URLSearchParams([
-  [<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>, <span class="hljs-string">'error'</span>]
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>([
+  [<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>, <span class="hljs-string">'error'</span>],
 ]);
 <span class="hljs-comment">// Throws TypeError [ERR_INVALID_TUPLE]:</span>
 <span class="hljs-comment">//        Each query pair must be an iterable [name, value] tuple</span></code></pre>
-<h4><code>urlSearchParams.append(name, value)</code><span><a class="mark" href="#url_urlsearchparams_append_name_value" id="url_urlsearchparams_append_name_value">#</a></span></h4>
+<h5><code>urlSearchParams.append(name, value)</code><span><a class="mark" href="#url_urlsearchparams_append_name_value" id="url_urlsearchparams_append_name_value">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Append a new name-value pair to the query string.</p>
-<h4><code>urlSearchParams.delete(name)</code><span><a class="mark" href="#url_urlsearchparams_delete_name" id="url_urlsearchparams_delete_name">#</a></span></h4>
+<h5><code>urlSearchParams.delete(name)</code><span><a class="mark" href="#url_urlsearchparams_delete_name" id="url_urlsearchparams_delete_name">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Remove all name-value pairs whose name is <code>name</code>.</p>
-<h4><code>urlSearchParams.entries()</code><span><a class="mark" href="#url_urlsearchparams_entries" id="url_urlsearchparams_entries">#</a></span></h4>
+<h5><code>urlSearchParams.entries()</code><span><a class="mark" href="#url_urlsearchparams_entries" id="url_urlsearchparams_entries">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
@@ -57908,20 +62509,20 @@ params = <span class="hljs-keyword">new</span> URLSearchParams(getQueryPairs());
 Each item of the iterator is a JavaScript <code>Array</code>. The first item of the <code>Array</code>
 is the <code>name</code>, the second item of the <code>Array</code> is the <code>value</code>.</p>
 <p>Alias for <a href="#url_urlsearchparams_symbol_iterator"><code>urlSearchParams[@@iterator]()</code></a>.</p>
-<h4><code>urlSearchParams.forEach(fn[, thisArg])</code><span><a class="mark" href="#url_urlsearchparams_foreach_fn_thisarg" id="url_urlsearchparams_foreach_fn_thisarg">#</a></span></h4>
+<h5><code>urlSearchParams.forEach(fn[, thisArg])</code><span><a class="mark" href="#url_urlsearchparams_foreach_fn_thisarg" id="url_urlsearchparams_foreach_fn_thisarg">#</a></span></h5>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Invoked for each name-value pair in the query</li>
 <li><code>thisArg</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> To be used as <code>this</code> value for when <code>fn</code> is called</li>
 </ul>
 <p>Iterates over each name-value pair in the query and invokes the given function.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/?a=b&#x26;c=d'</span>);
-myURL.searchParams.forEach(<span class="hljs-function">(<span class="hljs-params">value, name, searchParams</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(name, value, myURL.searchParams === searchParams);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/?a=b&#x26;c=d'</span>);
+myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">value, name, searchParams</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(name, value, myURL.<span class="hljs-property">searchParams</span> === searchParams);
 });
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   a b true</span>
 <span class="hljs-comment">//   c d true</span></code></pre>
-<h4><code>urlSearchParams.get(name)</code><span><a class="mark" href="#url_urlsearchparams_get_name" id="url_urlsearchparams_get_name">#</a></span></h4>
+<h5><code>urlSearchParams.get(name)</code><span><a class="mark" href="#url_urlsearchparams_get_name" id="url_urlsearchparams_get_name">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> or <code>null</code> if there is no name-value pair with the given
@@ -57929,32 +62530,32 @@ myURL.searchParams.forEach(<span class="hljs-function">(<span class="hljs-params
 </ul>
 <p>Returns the value of the first name-value pair whose name is <code>name</code>. If there
 are no such pairs, <code>null</code> is returned.</p>
-<h4><code>urlSearchParams.getAll(name)</code><span><a class="mark" href="#url_urlsearchparams_getall_name" id="url_urlsearchparams_getall_name">#</a></span></h4>
+<h5><code>urlSearchParams.getAll(name)</code><span><a class="mark" href="#url_urlsearchparams_getall_name" id="url_urlsearchparams_getall_name">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
 <p>Returns the values of all name-value pairs whose name is <code>name</code>. If there are
 no such pairs, an empty array is returned.</p>
-<h4><code>urlSearchParams.has(name)</code><span><a class="mark" href="#url_urlsearchparams_has_name" id="url_urlsearchparams_has_name">#</a></span></h4>
+<h5><code>urlSearchParams.has(name)</code><span><a class="mark" href="#url_urlsearchparams_has_name" id="url_urlsearchparams_has_name">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if there is at least one name-value pair whose name is <code>name</code>.</p>
-<h4><code>urlSearchParams.keys()</code><span><a class="mark" href="#url_urlsearchparams_keys" id="url_urlsearchparams_keys">#</a></span></h4>
+<h5><code>urlSearchParams.keys()</code><span><a class="mark" href="#url_urlsearchparams_keys" id="url_urlsearchparams_keys">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
 <p>Returns an ES6 <code>Iterator</code> over the names of each name-value pair.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'foo=bar&#x26;foo=baz'</span>);
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> name <span class="hljs-keyword">of</span> params.keys()) {
-  <span class="hljs-built_in">console</span>.log(name);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'foo=bar&#x26;foo=baz'</span>);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> name <span class="hljs-keyword">of</span> params.<span class="hljs-title function_">keys</span>()) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(name);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   foo</span>
 <span class="hljs-comment">//   foo</span></code></pre>
-<h4><code>urlSearchParams.set(name, value)</code><span><a class="mark" href="#url_urlsearchparams_set_name_value" id="url_urlsearchparams_set_name_value">#</a></span></h4>
+<h5><code>urlSearchParams.set(name, value)</code><span><a class="mark" href="#url_urlsearchparams_set_name_value" id="url_urlsearchparams_set_name_value">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -57963,18 +62564,18 @@ no such pairs, an empty array is returned.</p>
 <code>value</code>. If there are any pre-existing name-value pairs whose names are <code>name</code>,
 set the first such pair's value to <code>value</code> and remove all others. If not,
 append the name-value pair to the query string.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams();
-params.append(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
-params.append(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'baz'</span>);
-params.append(<span class="hljs-string">'abc'</span>, <span class="hljs-string">'def'</span>);
-<span class="hljs-built_in">console</span>.log(params.toString());
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>();
+params.<span class="hljs-title function_">append</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
+params.<span class="hljs-title function_">append</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'baz'</span>);
+params.<span class="hljs-title function_">append</span>(<span class="hljs-string">'abc'</span>, <span class="hljs-string">'def'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints foo=bar&#x26;foo=baz&#x26;abc=def</span>
 
-params.set(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'def'</span>);
-params.set(<span class="hljs-string">'xyz'</span>, <span class="hljs-string">'opq'</span>);
-<span class="hljs-built_in">console</span>.log(params.toString());
+params.<span class="hljs-title function_">set</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'def'</span>);
+params.<span class="hljs-title function_">set</span>(<span class="hljs-string">'xyz'</span>, <span class="hljs-string">'opq'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints foo=def&#x26;abc=def&#x26;xyz=opq</span></code></pre>
-<h4><code>urlSearchParams.sort()</code><span><a class="mark" href="#url_urlsearchparams_sort" id="url_urlsearchparams_sort">#</a></span></h4>
+<h5><code>urlSearchParams.sort()</code><span><a class="mark" href="#url_urlsearchparams_sort" id="url_urlsearchparams_sort">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v7.7.0, v6.13.0</span>
 </div>
@@ -57982,22 +62583,22 @@ params.set(<span class="hljs-string">'xyz'</span>, <span class="hljs-string">'op
 with a <a href="https://en.wikipedia.org/wiki/Sorting_algorithm#Stability">stable sorting algorithm</a>, so relative order between name-value pairs
 with the same name is preserved.</p>
 <p>This method can be used, in particular, to increase cache hits.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'query[]=abc&#x26;type=search&#x26;query[]=123'</span>);
-params.sort();
-<span class="hljs-built_in">console</span>.log(params.toString());
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'query[]=abc&#x26;type=search&#x26;query[]=123'</span>);
+params.<span class="hljs-title function_">sort</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints query%5B%5D=abc&#x26;query%5B%5D=123&#x26;type=search</span></code></pre>
-<h4><code>urlSearchParams.toString()</code><span><a class="mark" href="#url_urlsearchparams_tostring" id="url_urlsearchparams_tostring">#</a></span></h4>
+<h5><code>urlSearchParams.toString()</code><span><a class="mark" href="#url_urlsearchparams_tostring" id="url_urlsearchparams_tostring">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Returns the search parameters serialized as a string, with characters
 percent-encoded where necessary.</p>
-<h4><code>urlSearchParams.values()</code><span><a class="mark" href="#url_urlsearchparams_values" id="url_urlsearchparams_values">#</a></span></h4>
+<h5><code>urlSearchParams.values()</code><span><a class="mark" href="#url_urlsearchparams_values" id="url_urlsearchparams_values">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
 <p>Returns an ES6 <code>Iterator</code> over the values of each name-value pair.</p>
-<h4><code>urlSearchParams[Symbol.iterator]()</code><span><a class="mark" href="#url_urlsearchparams_symbol_iterator" id="url_urlsearchparams_symbol_iterator">#</a></span></h4>
+<h5><code>urlSearchParams[Symbol.iterator]()</code><span><a class="mark" href="#url_urlsearchparams_symbol_iterator" id="url_urlsearchparams_symbol_iterator">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
@@ -58005,14 +62606,14 @@ percent-encoded where necessary.</p>
 Each item of the iterator is a JavaScript <code>Array</code>. The first item of the <code>Array</code>
 is the <code>name</code>, the second item of the <code>Array</code> is the <code>value</code>.</p>
 <p>Alias for <a href="#url_urlsearchparams_entries"><code>urlSearchParams.entries()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'foo=bar&#x26;xyz=baz'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'foo=bar&#x26;xyz=baz'</span>);
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> [name, value] <span class="hljs-keyword">of</span> params) {
-  <span class="hljs-built_in">console</span>.log(name, value);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(name, value);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   foo bar</span>
 <span class="hljs-comment">//   xyz baz</span></code></pre>
-<h3><code>url.domainToASCII(domain)</code><span><a class="mark" href="#url_url_domaintoascii_domain" id="url_url_domaintoascii_domain">#</a></span></h3>
+<h4><code>url.domainToASCII(domain)</code><span><a class="mark" href="#url_url_domaintoascii_domain" id="url_url_domaintoascii_domain">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.4.0, v6.13.0</span>
 </div>
@@ -58023,14 +62624,16 @@ is the <code>name</code>, the second item of the <code>Array</code> is the <code
 <p>Returns the <a href="https://tools.ietf.org/html/rfc5891#section-4.4">Punycode</a> ASCII serialization of the <code>domain</code>. If <code>domain</code> is an
 invalid domain, the empty string is returned.</p>
 <p>It performs the inverse operation to <a href="#url_url_domaintounicode_domain"><code>url.domainToUnicode()</code></a>.</p>
+<p>This feature is only available if the <code>node</code> executable was compiled with
+<a href="#intl_options_for_building_node_js">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
-<span class="hljs-built_in">console</span>.log(url.domainToASCII(<span class="hljs-string">'español.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToASCII</span>(<span class="hljs-string">'español.com'</span>));
 <span class="hljs-comment">// Prints xn--espaol-zwa.com</span>
-<span class="hljs-built_in">console</span>.log(url.domainToASCII(<span class="hljs-string">'中文.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToASCII</span>(<span class="hljs-string">'中文.com'</span>));
 <span class="hljs-comment">// Prints xn--fiq228c.com</span>
-<span class="hljs-built_in">console</span>.log(url.domainToASCII(<span class="hljs-string">'xn--iñvalid.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToASCII</span>(<span class="hljs-string">'xn--iñvalid.com'</span>));
 <span class="hljs-comment">// Prints an empty string</span></code></pre>
-<h3><code>url.domainToUnicode(domain)</code><span><a class="mark" href="#url_url_domaintounicode_domain" id="url_url_domaintounicode_domain">#</a></span></h3>
+<h4><code>url.domainToUnicode(domain)</code><span><a class="mark" href="#url_url_domaintounicode_domain" id="url_url_domaintounicode_domain">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.4.0, v6.13.0</span>
 </div>
@@ -58041,14 +62644,16 @@ invalid domain, the empty string is returned.</p>
 <p>Returns the Unicode serialization of the <code>domain</code>. If <code>domain</code> is an invalid
 domain, the empty string is returned.</p>
 <p>It performs the inverse operation to <a href="#url_url_domaintoascii_domain"><code>url.domainToASCII()</code></a>.</p>
+<p>This feature is only available if the <code>node</code> executable was compiled with
+<a href="#intl_options_for_building_node_js">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
-<span class="hljs-built_in">console</span>.log(url.domainToUnicode(<span class="hljs-string">'xn--espaol-zwa.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToUnicode</span>(<span class="hljs-string">'xn--espaol-zwa.com'</span>));
 <span class="hljs-comment">// Prints español.com</span>
-<span class="hljs-built_in">console</span>.log(url.domainToUnicode(<span class="hljs-string">'xn--fiq228c.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToUnicode</span>(<span class="hljs-string">'xn--fiq228c.com'</span>));
 <span class="hljs-comment">// Prints 中文.com</span>
-<span class="hljs-built_in">console</span>.log(url.domainToUnicode(<span class="hljs-string">'xn--iñvalid.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToUnicode</span>(<span class="hljs-string">'xn--iñvalid.com'</span>));
 <span class="hljs-comment">// Prints an empty string</span></code></pre>
-<h3><code>url.fileURLToPath(url)</code><span><a class="mark" href="#url_url_fileurltopath_url" id="url_url_fileurltopath_url">#</a></span></h3>
+<h4><code>url.fileURLToPath(url)</code><span><a class="mark" href="#url_url_fileurltopath_url" id="url_url_fileurltopath_url">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -58058,18 +62663,34 @@ domain, the empty string is returned.</p>
 </ul>
 <p>This function ensures the correct decodings of percent-encoded characters as
 well as ensuring a cross-platform valid absolute path string.</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/path/'</span>).pathname;    <span class="hljs-comment">// Incorrect: /C:/path/</span>
-fileURLToPath(<span class="hljs-string">'file:///C:/path/'</span>);       <span class="hljs-comment">// Correct:   C:\path\ (Windows)</span>
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file://nas/foo.txt'</span>).pathname;  <span class="hljs-comment">// Incorrect: /foo.txt</span>
-fileURLToPath(<span class="hljs-string">'file://nas/foo.txt'</span>);     <span class="hljs-comment">// Correct:   \\nas\foo.txt (Windows)</span>
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { fileURLToPath } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
+
+<span class="hljs-keyword">const</span> __filename = <span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>);
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/path/'</span>).<span class="hljs-property">pathname</span>;      <span class="hljs-comment">// Incorrect: /C:/path/</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///C:/path/'</span>);         <span class="hljs-comment">// Correct:   C:\path\ (Windows)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file://nas/foo.txt'</span>).<span class="hljs-property">pathname</span>;    <span class="hljs-comment">// Incorrect: /foo.txt</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file://nas/foo.txt'</span>);       <span class="hljs-comment">// Correct:   \\nas\foo.txt (Windows)</span>
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///你好.txt'</span>).pathname;    <span class="hljs-comment">// Incorrect: /%E4%BD%A0%E5%A5%BD.txt</span>
-fileURLToPath(<span class="hljs-string">'file:///你好.txt'</span>);       <span class="hljs-comment">// Correct:   /你好.txt (POSIX)</span>
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///你好.txt'</span>).<span class="hljs-property">pathname</span>;      <span class="hljs-comment">// Incorrect: /%E4%BD%A0%E5%A5%BD.txt</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///你好.txt'</span>);         <span class="hljs-comment">// Correct:   /你好.txt (POSIX)</span>
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///hello world'</span>).pathname; <span class="hljs-comment">// Incorrect: /hello%20world</span>
-fileURLToPath(<span class="hljs-string">'file:///hello world'</span>);    <span class="hljs-comment">// Correct:   /hello world (POSIX)</span></code></pre>
-<h3><code>url.format(URL[, options])</code><span><a class="mark" href="#url_url_format_url_options" id="url_url_format_url_options">#</a></span></h3>
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///hello world'</span>).<span class="hljs-property">pathname</span>;   <span class="hljs-comment">// Incorrect: /hello%20world</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///hello world'</span>);      <span class="hljs-comment">// Correct:   /hello world (POSIX)</span></code><code class="language-js cjs"><span class="hljs-keyword">const</span> { fileURLToPath } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/path/'</span>).<span class="hljs-property">pathname</span>;      <span class="hljs-comment">// Incorrect: /C:/path/</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///C:/path/'</span>);         <span class="hljs-comment">// Correct:   C:\path\ (Windows)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file://nas/foo.txt'</span>).<span class="hljs-property">pathname</span>;    <span class="hljs-comment">// Incorrect: /foo.txt</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file://nas/foo.txt'</span>);       <span class="hljs-comment">// Correct:   \\nas\foo.txt (Windows)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///你好.txt'</span>).<span class="hljs-property">pathname</span>;      <span class="hljs-comment">// Incorrect: /%E4%BD%A0%E5%A5%BD.txt</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///你好.txt'</span>);         <span class="hljs-comment">// Correct:   /你好.txt (POSIX)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///hello world'</span>).<span class="hljs-property">pathname</span>;   <span class="hljs-comment">// Incorrect: /hello%20world</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///hello world'</span>);      <span class="hljs-comment">// Correct:   /hello world (POSIX)</span></code></pre>
+<h4><code>url.format(URL[, options])</code><span><a class="mark" href="#url_url_format_url_options" id="url_url_format_url_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.6.0</span>
 </div>
@@ -58096,17 +62717,29 @@ Punycode encoded. <strong>Default:</strong> <code>false</code>.</li>
 string serializations of the URL. These are not, however, customizable in
 any way. The <code>url.format(URL[, options])</code> method allows for basic customization
 of the output.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://a:b@測試?abc#foo'</span>);
 
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> url <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
+<span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://a:b@測試?abc#foo'</span>);
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://a:b@xn--g6w251d/?abc#foo</span>
 
-<span class="hljs-built_in">console</span>.log(myURL.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints https://a:b@xn--g6w251d/?abc#foo</span>
 
-<span class="hljs-built_in">console</span>.log(url.format(myURL, { <span class="hljs-attr">fragment</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">unicode</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">auth</span>: <span class="hljs-literal">false</span> }));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">format</span>(myURL, { <span class="hljs-attr">fragment</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">unicode</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">auth</span>: <span class="hljs-literal">false</span> }));
+<span class="hljs-comment">// Prints 'https://測試/?abc'</span></code><code class="language-js cjs"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://a:b@測試?abc#foo'</span>);
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
+<span class="hljs-comment">// Prints https://a:b@xn--g6w251d/?abc#foo</span>
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-title function_">toString</span>());
+<span class="hljs-comment">// Prints https://a:b@xn--g6w251d/?abc#foo</span>
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">format</span>(myURL, { <span class="hljs-attr">fragment</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">unicode</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">auth</span>: <span class="hljs-literal">false</span> }));
 <span class="hljs-comment">// Prints 'https://測試/?abc'</span></code></pre>
-<h3><code>url.pathToFileURL(path)</code><span><a class="mark" href="#url_url_pathtofileurl_path" id="url_url_pathtofileurl_path">#</a></span></h3>
+<h4><code>url.pathToFileURL(path)</code><span><a class="mark" href="#url_url_pathtofileurl_path" id="url_url_pathtofileurl_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -58116,75 +62749,137 @@ of the output.</p>
 </ul>
 <p>This function ensures that <code>path</code> is resolved absolutely, and that the URL
 control characters are correctly encoded when converting into a File URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> URL(__filename);                <span class="hljs-comment">// Incorrect: throws (POSIX)</span>
-<span class="hljs-keyword">new</span> URL(__filename);                <span class="hljs-comment">// Incorrect: C:\... (Windows)</span>
-pathToFileURL(__filename);          <span class="hljs-comment">// Correct:   file:///... (POSIX)</span>
-pathToFileURL(__filename);          <span class="hljs-comment">// Correct:   file:///C:/... (Windows)</span>
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'/foo#1'</span>, <span class="hljs-string">'file:'</span>);         <span class="hljs-comment">// Incorrect: file:///foo#1</span>
-pathToFileURL(<span class="hljs-string">'/foo#1'</span>);            <span class="hljs-comment">// Correct:   file:///foo%231 (POSIX)</span>
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { pathToFileURL } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/foo#1'</span>, <span class="hljs-string">'file:'</span>);           <span class="hljs-comment">// Incorrect: file:///foo#1</span>
+<span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">'/foo#1'</span>);              <span class="hljs-comment">// Correct:   file:///foo%231 (POSIX)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/some/path%.c'</span>, <span class="hljs-string">'file:'</span>);    <span class="hljs-comment">// Incorrect: file:///some/path%.c</span>
+<span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">'/some/path%.c'</span>);       <span class="hljs-comment">// Correct:   file:///some/path%25.c (POSIX)</span></code><code class="language-js cjs"><span class="hljs-keyword">const</span> { pathToFileURL } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(__filename);                  <span class="hljs-comment">// Incorrect: throws (POSIX)</span>
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(__filename);                  <span class="hljs-comment">// Incorrect: C:\... (Windows)</span>
+<span class="hljs-title function_">pathToFileURL</span>(__filename);            <span class="hljs-comment">// Correct:   file:///... (POSIX)</span>
+<span class="hljs-title function_">pathToFileURL</span>(__filename);            <span class="hljs-comment">// Correct:   file:///C:/... (Windows)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/foo#1'</span>, <span class="hljs-string">'file:'</span>);           <span class="hljs-comment">// Incorrect: file:///foo#1</span>
+<span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">'/foo#1'</span>);              <span class="hljs-comment">// Correct:   file:///foo%231 (POSIX)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/some/path%.c'</span>, <span class="hljs-string">'file:'</span>);    <span class="hljs-comment">// Incorrect: file:///some/path%.c</span>
+<span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">'/some/path%.c'</span>);       <span class="hljs-comment">// Correct:   file:///some/path%25.c (POSIX)</span></code></pre>
+<h4><code>url.urlToHttpOptions(url)</code><span><a class="mark" href="#url_url_urltohttpoptions_url" id="url_url_urltohttpoptions_url">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>url</code> <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> The <a href="#url_the_whatwg_url_api">WHATWG URL</a> object to convert to an options object.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Options object
+<ul>
+<li><code>protocol</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Protocol to use.</li>
+<li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A domain name or IP address of the server to issue the
+request to.</li>
+<li><code>hash</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The fragment portion of the URL.</li>
+<li><code>search</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The serialized query portion of the URL.</li>
+<li><code>pathname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The path portion of the URL.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Request path. Should include query string if any.
+E.G. <code>'/index.html?page=12'</code>. An exception is thrown when the request path
+contains illegal characters. Currently, only spaces are rejected but that
+may change in the future.</li>
+<li><code>href</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The serialized URL.</li>
+<li><code>port</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Port of remote server.</li>
+<li><code>auth</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Basic authentication i.e. <code>'user:password'</code> to compute an
+Authorization header.</li>
+</ul>
+</li>
+</ul>
+<p>This utility function converts a URL object into an ordinary options object as
+expected by the <a href="#http_http_request_options_callback"><code>http.request()</code></a> and <a href="#https_https_request_options_callback"><code>https.request()</code></a> APIs.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { urlToHttpOptions } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://a:b@測試?abc#foo'</span>);
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'/some/path%.c'</span>, <span class="hljs-string">'file:'</span>); <span class="hljs-comment">// Incorrect: file:///some/path%.c</span>
-pathToFileURL(<span class="hljs-string">'/some/path%.c'</span>);    <span class="hljs-comment">// Correct:   file:///some/path%25.c (POSIX)</span></code></pre>
-<h2>Legacy URL API<span><a class="mark" href="#url_legacy_url_api" id="url_legacy_url_api">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">urlToHttpOptions</span>(myUrl));
+<span class="hljs-comment">/**
+{
+  protocol: 'https:',
+  hostname: 'xn--g6w251d',
+  hash: '#foo',
+  search: '?abc',
+  pathname: '/',
+  path: '/?abc',
+  href: 'https://a:b<span class="hljs-doctag">@xn</span>--g6w251d/?abc#foo',
+  auth: 'a:b'
+}
+*/</span></code></pre>
+</section><section><h3>Legacy URL API<span><a class="mark" href="#url_legacy_url_api" id="url_legacy_url_api">#</a></span></h3>
 <div class="api_metadata">
-<span>Deprecated since: v11.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
+<tr><td>v11.0.0</td>
+<td><p>This API is deprecated.</p></td></tr>
+</tbody></table>
+</details>
 </div>
-<h3>Legacy <code>urlObject</code><span><a class="mark" href="#url_legacy_urlobject" id="url_legacy_urlobject">#</a></span></h3>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
+<h4>Legacy <code>urlObject</code><span><a class="mark" href="#url_legacy_urlobject" id="url_legacy_urlobject">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>The Legacy URL API is deprecated. Use the WHATWG URL API.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use the WHATWG URL API instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
 <p>The legacy <code>urlObject</code> (<code>require('url').Url</code>) is created and returned by the
 <code>url.parse()</code> function.</p>
-<h4><code>urlObject.auth</code><span><a class="mark" href="#url_urlobject_auth" id="url_urlobject_auth">#</a></span></h4>
+<h5><code>urlObject.auth</code><span><a class="mark" href="#url_urlobject_auth" id="url_urlobject_auth">#</a></span></h5>
 <p>The <code>auth</code> property is the username and password portion of the URL, also
 referred to as <em>userinfo</em>. This string subset follows the <code>protocol</code> and
 double slashes (if present) and precedes the <code>host</code> component, delimited by <code>@</code>.
 The string is either the username, or it is the username and password separated
 by <code>:</code>.</p>
 <p>For example: <code>'user:pass'</code>.</p>
-<h4><code>urlObject.hash</code><span><a class="mark" href="#url_urlobject_hash" id="url_urlobject_hash">#</a></span></h4>
+<h5><code>urlObject.hash</code><span><a class="mark" href="#url_urlobject_hash" id="url_urlobject_hash">#</a></span></h5>
 <p>The <code>hash</code> property is the fragment identifier portion of the URL including the
 leading <code>#</code> character.</p>
 <p>For example: <code>'#hash'</code>.</p>
-<h4><code>urlObject.host</code><span><a class="mark" href="#url_urlobject_host" id="url_urlobject_host">#</a></span></h4>
+<h5><code>urlObject.host</code><span><a class="mark" href="#url_urlobject_host" id="url_urlobject_host">#</a></span></h5>
 <p>The <code>host</code> property is the full lower-cased host portion of the URL, including
 the <code>port</code> if specified.</p>
 <p>For example: <code>'sub.example.com:8080'</code>.</p>
-<h4><code>urlObject.hostname</code><span><a class="mark" href="#url_urlobject_hostname" id="url_urlobject_hostname">#</a></span></h4>
+<h5><code>urlObject.hostname</code><span><a class="mark" href="#url_urlobject_hostname" id="url_urlobject_hostname">#</a></span></h5>
 <p>The <code>hostname</code> property is the lower-cased host name portion of the <code>host</code>
 component <em>without</em> the <code>port</code> included.</p>
 <p>For example: <code>'sub.example.com'</code>.</p>
-<h4><code>urlObject.href</code><span><a class="mark" href="#url_urlobject_href" id="url_urlobject_href">#</a></span></h4>
+<h5><code>urlObject.href</code><span><a class="mark" href="#url_urlobject_href" id="url_urlobject_href">#</a></span></h5>
 <p>The <code>href</code> property is the full URL string that was parsed with both the
 <code>protocol</code> and <code>host</code> components converted to lower-case.</p>
 <p>For example: <code>'http://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>.</p>
-<h4><code>urlObject.path</code><span><a class="mark" href="#url_urlobject_path" id="url_urlobject_path">#</a></span></h4>
+<h5><code>urlObject.path</code><span><a class="mark" href="#url_urlobject_path" id="url_urlobject_path">#</a></span></h5>
 <p>The <code>path</code> property is a concatenation of the <code>pathname</code> and <code>search</code>
 components.</p>
 <p>For example: <code>'/p/a/t/h?query=string'</code>.</p>
 <p>No decoding of the <code>path</code> is performed.</p>
-<h4><code>urlObject.pathname</code><span><a class="mark" href="#url_urlobject_pathname" id="url_urlobject_pathname">#</a></span></h4>
+<h5><code>urlObject.pathname</code><span><a class="mark" href="#url_urlobject_pathname" id="url_urlobject_pathname">#</a></span></h5>
 <p>The <code>pathname</code> property consists of the entire path section of the URL. This
 is everything following the <code>host</code> (including the <code>port</code>) and before the start
 of the <code>query</code> or <code>hash</code> components, delimited by either the ASCII question
 mark (<code>?</code>) or hash (<code>#</code>) characters.</p>
 <p>For example: <code>'/p/a/t/h'</code>.</p>
 <p>No decoding of the path string is performed.</p>
-<h4><code>urlObject.port</code><span><a class="mark" href="#url_urlobject_port" id="url_urlobject_port">#</a></span></h4>
+<h5><code>urlObject.port</code><span><a class="mark" href="#url_urlobject_port" id="url_urlobject_port">#</a></span></h5>
 <p>The <code>port</code> property is the numeric port portion of the <code>host</code> component.</p>
 <p>For example: <code>'8080'</code>.</p>
-<h4><code>urlObject.protocol</code><span><a class="mark" href="#url_urlobject_protocol" id="url_urlobject_protocol">#</a></span></h4>
+<h5><code>urlObject.protocol</code><span><a class="mark" href="#url_urlobject_protocol" id="url_urlobject_protocol">#</a></span></h5>
 <p>The <code>protocol</code> property identifies the URL's lower-cased protocol scheme.</p>
 <p>For example: <code>'http:'</code>.</p>
-<h4><code>urlObject.query</code><span><a class="mark" href="#url_urlobject_query" id="url_urlobject_query">#</a></span></h4>
+<h5><code>urlObject.query</code><span><a class="mark" href="#url_urlobject_query" id="url_urlobject_query">#</a></span></h5>
 <p>The <code>query</code> property is either the query string without the leading ASCII
 question mark (<code>?</code>), or an object returned by the <a href="querystring.html"><code>querystring</code></a> module's
 <code>parse()</code> method. Whether the <code>query</code> property is a string or object is
@@ -58192,20 +62887,22 @@ determined by the <code>parseQueryString</code> argument passed to <code>url.par
 <p>For example: <code>'query=string'</code> or <code>{'query': 'string'}</code>.</p>
 <p>If returned as a string, no decoding of the query string is performed. If
 returned as an object, both keys and values are decoded.</p>
-<h4><code>urlObject.search</code><span><a class="mark" href="#url_urlobject_search" id="url_urlobject_search">#</a></span></h4>
+<h5><code>urlObject.search</code><span><a class="mark" href="#url_urlobject_search" id="url_urlobject_search">#</a></span></h5>
 <p>The <code>search</code> property consists of the entire "query string" portion of the
 URL, including the leading ASCII question mark (<code>?</code>) character.</p>
 <p>For example: <code>'?query=string'</code>.</p>
 <p>No decoding of the query string is performed.</p>
-<h4><code>urlObject.slashes</code><span><a class="mark" href="#url_urlobject_slashes" id="url_urlobject_slashes">#</a></span></h4>
+<h5><code>urlObject.slashes</code><span><a class="mark" href="#url_urlobject_slashes" id="url_urlobject_slashes">#</a></span></h5>
 <p>The <code>slashes</code> property is a <code>boolean</code> with a value of <code>true</code> if two ASCII
 forward-slash characters (<code>/</code>) are required following the colon in the
 <code>protocol</code>.</p>
-<h3><code>url.format(urlObject)</code><span><a class="mark" href="#url_url_format_urlobject" id="url_url_format_urlobject">#</a></span></h3>
+<h4><code>url.format(urlObject)</code><span><a class="mark" href="#url_url_format_urlobject" id="url_url_format_urlobject">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>The Legacy URL API is deprecated. Use the WHATWG URL API.</p></td></tr>
 <tr><td>v7.0.0</td>
@@ -58215,7 +62912,7 @@ forward-slash characters (<code>/</code>) are required following the colon in th
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use the WHATWG URL API instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
 <ul>
 <li><code>urlObject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A URL object (as returned by <code>url.parse()</code> or
 constructed otherwise). If a string, it is converted to an object by passing
@@ -58223,7 +62920,8 @@ it to <code>url.parse()</code>.</li>
 </ul>
 <p>The <code>url.format()</code> method returns a formatted URL string derived from
 <code>urlObject</code>.</p>
-<pre><code class="language-js">url.format({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+url.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">protocol</span>: <span class="hljs-string">'https'</span>,
   <span class="hljs-attr">hostname</span>: <span class="hljs-string">'example.com'</span>,
   <span class="hljs-attr">pathname</span>: <span class="hljs-string">'/some/path'</span>,
@@ -58306,11 +63004,13 @@ character, the literal string <code>#</code> is appended to <code>result</code>.
 string, an <a href="#errors_class_error"><code>Error</code></a> is thrown.</li>
 <li><code>result</code> is returned.</li>
 </ul>
-<h3><code>url.parse(urlString[, parseQueryString[, slashesDenoteHost]])</code><span><a class="mark" href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost" id="url_url_parse_urlstring_parsequerystring_slashesdenotehost">#</a></span></h3>
+<h4><code>url.parse(urlString[, parseQueryString[, slashesDenoteHost]])</code><span><a class="mark" href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost" id="url_url_parse_urlstring_parsequerystring_slashesdenotehost">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.14.0</td>
 <td><p>The <code>pathname</code> property on the returned URL object is now <code>/</code> when there is no path and the protocol scheme is <code>ws:</code> or <code>wss:</code>.</p></td></tr>
 <tr><td>v11.0.0</td>
@@ -58322,7 +63022,7 @@ string, an <a href="#errors_class_error"><code>Error</code></a> is thrown.</li>
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use the WHATWG URL API instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
 <ul>
 <li><code>urlString</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The URL string to parse.</li>
 <li><code>parseQueryString</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the <code>query</code> property will always
@@ -58344,25 +63044,27 @@ use the WHATWG <code>URL</code> API. Because the <code>url.parse()</code> method
 lenient, non-standard algorithm for parsing URL strings, security
 issues can be introduced. Specifically, issues with <a href="https://hackerone.com/reports/678487">host name spoofing</a> and
 incorrect handling of usernames and passwords have been identified.</p>
-<h3><code>url.resolve(from, to)</code><span><a class="mark" href="#url_url_resolve_from_to" id="url_url_resolve_from_to">#</a></span></h3>
+<h4><code>url.resolve(from, to)</code><span><a class="mark" href="#url_url_resolve_from_to" id="url_url_resolve_from_to">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>The Legacy URL API is deprecated. Use the WHATWG URL API.</p></td></tr>
 <tr><td>v6.6.0</td>
 <td><p>The <code>auth</code> fields are now kept intact when <code>from</code> and <code>to</code> refer to the same host.</p></td></tr>
-<tr><td>v6.5.0, v4.6.2</td>
-<td><p>The <code>port</code> field is copied correctly now.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>The <code>auth</code> fields is cleared now the <code>to</code> parameter contains a hostname.</p></td></tr>
+<tr><td>v6.5.0, v4.6.2</td>
+<td><p>The <code>port</code> field is copied correctly now.</p></td></tr>
 <tr><td>v0.1.25</td>
 <td><p><span>Added in: v0.1.25</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use the WHATWG URL API instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
 <ul>
 <li><code>from</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The Base URL being resolved against.</li>
 <li><code>to</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The HREF URL being resolved.</li>
@@ -58370,22 +63072,36 @@ incorrect handling of usernames and passwords have been identified.</p>
 <p>The <code>url.resolve()</code> method resolves a target URL relative to a base URL in a
 manner similar to that of a Web browser resolving an anchor tag HREF.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
-url.resolve(<span class="hljs-string">'/one/two/three'</span>, <span class="hljs-string">'four'</span>);         <span class="hljs-comment">// '/one/two/four'</span>
-url.resolve(<span class="hljs-string">'http://example.com/'</span>, <span class="hljs-string">'/one'</span>);    <span class="hljs-comment">// 'http://example.com/one'</span>
-url.resolve(<span class="hljs-string">'http://example.com/one'</span>, <span class="hljs-string">'/two'</span>); <span class="hljs-comment">// 'http://example.com/two'</span></code></pre>
+url.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'/one/two/three'</span>, <span class="hljs-string">'four'</span>);         <span class="hljs-comment">// '/one/two/four'</span>
+url.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'http://example.com/'</span>, <span class="hljs-string">'/one'</span>);    <span class="hljs-comment">// 'http://example.com/one'</span>
+url.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'http://example.com/one'</span>, <span class="hljs-string">'/two'</span>); <span class="hljs-comment">// 'http://example.com/two'</span></code></pre>
+<p>You can achieve the same result using the WHATWG URL API:</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">resolve</span>(<span class="hljs-params"><span class="hljs-keyword">from</span>, to</span>) {
+  <span class="hljs-keyword">const</span> resolvedUrl = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(to, <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-keyword">from</span>, <span class="hljs-string">'resolve://'</span>));
+  <span class="hljs-keyword">if</span> (resolvedUrl.<span class="hljs-property">protocol</span> === <span class="hljs-string">'resolve:'</span>) {
+    <span class="hljs-comment">// `from` is a relative URL.</span>
+    <span class="hljs-keyword">const</span> { pathname, search, hash } = resolvedUrl;
+    <span class="hljs-keyword">return</span> pathname + search + hash;
+  }
+  <span class="hljs-keyword">return</span> resolvedUrl.<span class="hljs-title function_">toString</span>();
+}
+
+<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'/one/two/three'</span>, <span class="hljs-string">'four'</span>);         <span class="hljs-comment">// '/one/two/four'</span>
+<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'http://example.com/'</span>, <span class="hljs-string">'/one'</span>);    <span class="hljs-comment">// 'http://example.com/one'</span>
+<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'http://example.com/one'</span>, <span class="hljs-string">'/two'</span>); <span class="hljs-comment">// 'http://example.com/two'</span></code></pre>
 <p><a id="whatwg-percent-encoding"></a></p>
-<h2>Percent-encoding in URLs<span><a class="mark" href="#url_percent_encoding_in_urls" id="url_percent_encoding_in_urls">#</a></span></h2>
+</section><section><h3>Percent-encoding in URLs<span><a class="mark" href="#url_percent_encoding_in_urls" id="url_percent_encoding_in_urls">#</a></span></h3>
 <p>URLs are permitted to only contain a certain range of characters. Any character
 falling outside of that range must be encoded. How such characters are encoded,
 and which characters to encode depends entirely on where the character is
 located within the structure of the URL.</p>
-<h3>Legacy API<span><a class="mark" href="#url_legacy_api" id="url_legacy_api">#</a></span></h3>
+<h4>Legacy API<span><a class="mark" href="#url_legacy_api" id="url_legacy_api">#</a></span></h4>
 <p>Within the Legacy API, spaces (<code>' '</code>) and the following characters will be
 automatically escaped in the properties of URL objects:</p>
 <pre><code class="language-text">&#x3C; > " ` \r \n \t { } | \ ^ '</code></pre>
 <p>For example, the ASCII space character (<code>' '</code>) is encoded as <code>%20</code>. The ASCII
 forward slash (<code>/</code>) character is encoded as <code>%3C</code>.</p>
-<h3>WHATWG API<span><a class="mark" href="#url_whatwg_api" id="url_whatwg_api">#</a></span></h3>
+<h4>WHATWG API<span><a class="mark" href="#url_whatwg_api" id="url_whatwg_api">#</a></span></h4>
 <p>The <a href="https://url.spec.whatwg.org/">WHATWG URL Standard</a> uses a more selective and fine grained approach to
 selecting encoded characters than that used by the Legacy API.</p>
 <p>The WHATWG algorithm defines four "percent-encode sets" that describe ranges
@@ -58418,20 +63134,21 @@ specific conditions, in addition to all other cases.</p>
 <p>When non-ASCII characters appear within a host name, the host name is encoded
 using the <a href="https://tools.ietf.org/html/rfc5891#section-4.4">Punycode</a> algorithm. Note, however, that a host name <em>may</em> contain
 <em>both</em> Punycode encoded and percent-encoded characters:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://%CF%80.example.com/foo'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://%CF%80.example.com/foo'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://xn--1xa.example.com/foo</span>
-<span class="hljs-built_in">console</span>.log(myURL.origin);
-<span class="hljs-comment">// Prints https://xn--1xa.example.com</span></code></pre>
-<h1>Util<span><a class="mark" href="#util_util" id="util_util">#</a></span></h1>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">origin</span>);
+<span class="hljs-comment">// Prints https://xn--1xa.example.com</span></code></pre></section>
+        </section>
+<section><h2>Util<span><a class="mark" href="#util_util" id="util_util">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/util.js">lib/util.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/util.js">lib/util.js</a></p>
 <p>The <code>util</code> module supports the needs of Node.js internal APIs. Many of the
 utilities are useful for application and module developers as well. To access
 it:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);</code></pre>
-<h2><code>util.callbackify(original)</code><span><a class="mark" href="#util_util_callbackify_original" id="util_util_callbackify_original">#</a></span></h2>
+<section><h3><code>util.callbackify(original)</code><span><a class="mark" href="#util_util_callbackify_original" id="util_util_callbackify_original">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 </div>
@@ -58446,14 +63163,14 @@ first argument will be the rejection reason (or <code>null</code> if the <code>P
 resolved), and the second argument will be the resolved value.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">fn</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">fn</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">return</span> <span class="hljs-string">'hello world'</span>;
 }
-<span class="hljs-keyword">const</span> callbackFunction = util.callbackify(fn);
+<span class="hljs-keyword">const</span> callbackFunction = util.<span class="hljs-title function_">callbackify</span>(fn);
 
-callbackFunction(<span class="hljs-function">(<span class="hljs-params">err, ret</span>) =></span> {
+<span class="hljs-title function_">callbackFunction</span>(<span class="hljs-function">(<span class="hljs-params">err, ret</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(ret);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(ret);
 });</code></pre>
 <p>Will print:</p>
 <pre><code class="language-text">hello world</code></pre>
@@ -58464,17 +63181,17 @@ event, and if not handled will exit.</p>
 wrapped function rejects a <code>Promise</code> with a falsy value as a reason, the value
 is wrapped in an <code>Error</code> with the original value stored in a field named
 <code>reason</code>.</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">fn</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">return</span> <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-literal">null</span>);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">fn</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">return</span> <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">reject</span>(<span class="hljs-literal">null</span>);
 }
-<span class="hljs-keyword">const</span> callbackFunction = util.callbackify(fn);
+<span class="hljs-keyword">const</span> callbackFunction = util.<span class="hljs-title function_">callbackify</span>(fn);
 
-callbackFunction(<span class="hljs-function">(<span class="hljs-params">err, ret</span>) =></span> {
+<span class="hljs-title function_">callbackFunction</span>(<span class="hljs-function">(<span class="hljs-params">err, ret</span>) =></span> {
   <span class="hljs-comment">// When the Promise was rejected with `null` it is wrapped with an Error and</span>
   <span class="hljs-comment">// the original value is stored in `reason`.</span>
-  err &#x26;&#x26; err.hasOwnProperty(<span class="hljs-string">'reason'</span>) &#x26;&#x26; err.reason === <span class="hljs-literal">null</span>;  <span class="hljs-comment">// true</span>
+  err &#x26;&#x26; err.<span class="hljs-title function_">hasOwnProperty</span>(<span class="hljs-string">'reason'</span>) &#x26;&#x26; err.<span class="hljs-property">reason</span> === <span class="hljs-literal">null</span>;  <span class="hljs-comment">// true</span>
 });</code></pre>
-<h2><code>util.debuglog(section[, callback])</code><span><a class="mark" href="#util_util_debuglog_section_callback" id="util_util_debuglog_section_callback">#</a></span></h2>
+</section><section><h3><code>util.debuglog(section[, callback])</code><span><a class="mark" href="#util_util_debuglog_section_callback" id="util_util_debuglog_section_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -58491,9 +63208,9 @@ environment variable. If the <code>section</code> name appears within the value
 environment variable, then the returned function operates similar to
 <a href="#console_console_error_data_args"><code>console.error()</code></a>. If not, then the returned function is a no-op.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> debuglog = util.debuglog(<span class="hljs-string">'foo'</span>);
+<span class="hljs-keyword">const</span> debuglog = util.<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'foo'</span>);
 
-debuglog(<span class="hljs-string">'hello from foo [%d]'</span>, <span class="hljs-number">123</span>);</code></pre>
+<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'hello from foo [%d]'</span>, <span class="hljs-number">123</span>);</code></pre>
 <p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then
 it will output something like:</p>
 <pre><code class="language-console">FOO 3245: hello from foo [123]</code></pre>
@@ -58501,9 +63218,9 @@ it will output something like:</p>
 environment variable set, then it will not print anything.</p>
 <p>The <code>section</code> supports wildcard also:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> debuglog = util.debuglog(<span class="hljs-string">'foo-bar'</span>);
+<span class="hljs-keyword">const</span> debuglog = util.<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'foo-bar'</span>);
 
-debuglog(<span class="hljs-string">'hi there, it\'s foo-bar [%d]'</span>, <span class="hljs-number">2333</span>);</code></pre>
+<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'hi there, it\'s foo-bar [%d]'</span>, <span class="hljs-number">2333</span>);</code></pre>
 <p>if it is run with <code>NODE_DEBUG=foo*</code> in the environment, then it will output
 something like:</p>
 <pre><code class="language-console">FOO-BAR 3257: hi there, it's foo-bar [2333]</code></pre>
@@ -58513,12 +63230,38 @@ environment variable: <code>NODE_DEBUG=fs,net,tls</code>.</p>
 with a different function that doesn't have any initialization or
 unnecessary wrapping.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">let</span> debuglog = util.debuglog(<span class="hljs-string">'internals'</span>, <span class="hljs-function">(<span class="hljs-params">debug</span>) =></span> {
+<span class="hljs-keyword">let</span> debuglog = util.<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'internals'</span>, <span class="hljs-function">(<span class="hljs-params">debug</span>) =></span> {
   <span class="hljs-comment">// Replace with a logging function that optimizes out</span>
   <span class="hljs-comment">// testing if the section is enabled</span>
   debuglog = debug;
 });</code></pre>
-<h2><code>util.deprecate(fn, msg[, code])</code><span><a class="mark" href="#util_util_deprecate_fn_msg_code" id="util_util_deprecate_fn_msg_code">#</a></span></h2>
+<h4><code>debuglog().enabled</code><span><a class="mark" href="#util_debuglog_enabled" id="util_debuglog_enabled">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.9.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>The <code>util.debuglog().enabled</code> getter is used to create a test that can be used
+in conditionals based on the existence of the <code>NODE_DEBUG</code> environment variable.
+If the <code>section</code> name appears within the value of that environment variable,
+then the returned value will be <code>true</code>. If not, then the returned value will be
+<code>false</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> enabled = util.<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'foo'</span>).<span class="hljs-property">enabled</span>;
+<span class="hljs-keyword">if</span> (enabled) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello from foo [%d]'</span>, <span class="hljs-number">123</span>);
+}</code></pre>
+<p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then it will
+output something like:</p>
+<pre><code class="language-console">hello from foo [123]</code></pre>
+</section><section><h3><code>util.debug(section)</code><span><a class="mark" href="#util_util_debug_section" id="util_util_debug_section">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.9.0</span>
+</div>
+<p>Alias for <code>util.debuglog</code>. Usage allows for readability of that doesn't imply
+logging when only using <code>util.debuglog().enabled</code>.</p>
+</section><section><h3><code>util.deprecate(fn, msg[, code])</code><span><a class="mark" href="#util_util_deprecate_fn_msg_code" id="util_util_deprecate_fn_msg_code">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -58542,7 +63285,7 @@ list of codes.</li>
 such a way that it is marked as deprecated.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-built_in">exports</span>.obsoleteFunction = util.deprecate(<span class="hljs-function">() =></span> {
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">obsoleteFunction</span> = util.<span class="hljs-title function_">deprecate</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Do something here.</span>
 }, <span class="hljs-string">'obsoleteFunction() is deprecated. Use newShinyFunction() instead.'</span>);</code></pre>
 <p>When called, <code>util.deprecate()</code> will return a function that will emit a
@@ -58554,24 +63297,24 @@ emitting a warning.</p>
 the warning will be emitted only once for that <code>code</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-keyword">const</span> fn1 = util.deprecate(someFunction, someMessage, <span class="hljs-string">'DEP0001'</span>);
-<span class="hljs-keyword">const</span> fn2 = util.deprecate(someOtherFunction, someOtherMessage, <span class="hljs-string">'DEP0001'</span>);
-fn1(); <span class="hljs-comment">// Emits a deprecation warning with code DEP0001</span>
-fn2(); <span class="hljs-comment">// Does not emit a deprecation warning because it has the same code</span></code></pre>
-<p>If either the <code>--no-deprecation</code> or <code>--no-warnings</code> command line flags are
+<span class="hljs-keyword">const</span> fn1 = util.<span class="hljs-title function_">deprecate</span>(someFunction, someMessage, <span class="hljs-string">'DEP0001'</span>);
+<span class="hljs-keyword">const</span> fn2 = util.<span class="hljs-title function_">deprecate</span>(someOtherFunction, someOtherMessage, <span class="hljs-string">'DEP0001'</span>);
+<span class="hljs-title function_">fn1</span>(); <span class="hljs-comment">// Emits a deprecation warning with code DEP0001</span>
+<span class="hljs-title function_">fn2</span>(); <span class="hljs-comment">// Does not emit a deprecation warning because it has the same code</span></code></pre>
+<p>If either the <code>--no-deprecation</code> or <code>--no-warnings</code> command-line flags are
 used, or if the <code>process.noDeprecation</code> property is set to <code>true</code> <em>prior</em> to
 the first deprecation warning, the <code>util.deprecate()</code> method does nothing.</p>
-<p>If the <code>--trace-deprecation</code> or <code>--trace-warnings</code> command line flags are set,
+<p>If the <code>--trace-deprecation</code> or <code>--trace-warnings</code> command-line flags are set,
 or the <code>process.traceDeprecation</code> property is set to <code>true</code>, a warning and a
 stack trace are printed to <code>stderr</code> the first time the deprecated function is
 called.</p>
-<p>If the <code>--throw-deprecation</code> command line flag is set, or the
+<p>If the <code>--throw-deprecation</code> command-line flag is set, or the
 <code>process.throwDeprecation</code> property is set to <code>true</code>, then an exception will be
 thrown when the deprecated function is called.</p>
-<p>The <code>--throw-deprecation</code> command line flag and <code>process.throwDeprecation</code>
+<p>The <code>--throw-deprecation</code> command-line flag and <code>process.throwDeprecation</code>
 property take precedence over <code>--trace-deprecation</code> and
 <code>process.traceDeprecation</code>.</p>
-<h2><code>util.format(format[, ...args])</code><span><a class="mark" href="#util_util_format_format_args" id="util_util_format_format_args">#</a></span></h2>
+</section><section><h3><code>util.format(format[, ...args])</code><span><a class="mark" href="#util_util_format_format_args" id="util_util_format_format_args">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -58628,27 +63371,27 @@ the full object not including non-enumerable properties and proxies.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The formatted string</li>
 </ul>
 <p>If a specifier does not have a corresponding argument, it is not replaced:</p>
-<pre><code class="language-js">util.format(<span class="hljs-string">'%s:%s'</span>, <span class="hljs-string">'foo'</span>);
+<pre><code class="language-js">util.<span class="hljs-title function_">format</span>(<span class="hljs-string">'%s:%s'</span>, <span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Returns: 'foo:%s'</span></code></pre>
 <p>Values that are not part of the format string are formatted using
 <code>util.inspect()</code> if their type is not <code>string</code>.</p>
 <p>If there are more arguments passed to the <code>util.format()</code> method than the
 number of specifiers, the extra arguments are concatenated to the returned
 string, separated by spaces:</p>
-<pre><code class="language-js">util.format(<span class="hljs-string">'%s:%s'</span>, <span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>, <span class="hljs-string">'baz'</span>);
+<pre><code class="language-js">util.<span class="hljs-title function_">format</span>(<span class="hljs-string">'%s:%s'</span>, <span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>, <span class="hljs-string">'baz'</span>);
 <span class="hljs-comment">// Returns: 'foo:bar baz'</span></code></pre>
 <p>If the first argument does not contain a valid format specifier, <code>util.format()</code>
 returns a string that is the concatenation of all arguments separated by spaces:</p>
-<pre><code class="language-js">util.format(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>);
+<pre><code class="language-js">util.<span class="hljs-title function_">format</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>);
 <span class="hljs-comment">// Returns: '1 2 3'</span></code></pre>
 <p>If only one argument is passed to <code>util.format()</code>, it is returned as it is
 without any formatting:</p>
-<pre><code class="language-js">util.format(<span class="hljs-string">'%% %s'</span>);
+<pre><code class="language-js">util.<span class="hljs-title function_">format</span>(<span class="hljs-string">'%% %s'</span>);
 <span class="hljs-comment">// Returns: '%% %s'</span></code></pre>
 <p><code>util.format()</code> is a synchronous method that is intended as a debugging tool.
 Some input values can have a significant performance overhead that can block the
 event loop. Use this function with care and never in a hot code path.</p>
-<h2><code>util.formatWithOptions(inspectOptions, format[, ...args])</code><span><a class="mark" href="#util_util_formatwithoptions_inspectoptions_format_args" id="util_util_formatwithoptions_inspectoptions_format_args">#</a></span></h2>
+</section><section><h3><code>util.formatWithOptions(inspectOptions, format[, ...args])</code><span><a class="mark" href="#util_util_formatwithoptions_inspectoptions_format_args" id="util_util_formatwithoptions_inspectoptions_format_args">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -58659,10 +63402,10 @@ event loop. Use this function with care and never in a hot code path.</p>
 <p>This function is identical to <a href="#util_util_format_format_args"><code>util.format()</code></a>, except in that it takes
 an <code>inspectOptions</code> argument which specifies options that are passed along to
 <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a>.</p>
-<pre><code class="language-js">util.formatWithOptions({ <span class="hljs-attr">colors</span>: <span class="hljs-literal">true</span> }, <span class="hljs-string">'See object %O'</span>, { <span class="hljs-attr">foo</span>: <span class="hljs-number">42</span> });
+<pre><code class="language-js">util.<span class="hljs-title function_">formatWithOptions</span>({ <span class="hljs-attr">colors</span>: <span class="hljs-literal">true</span> }, <span class="hljs-string">'See object %O'</span>, { <span class="hljs-attr">foo</span>: <span class="hljs-number">42</span> });
 <span class="hljs-comment">// Returns 'See object { foo: 42 }', where `42` is colored as a number</span>
 <span class="hljs-comment">// when printed to a terminal.</span></code></pre>
-<h2><code>util.getSystemErrorName(err)</code><span><a class="mark" href="#util_util_getsystemerrorname_err" id="util_util_getsystemerrorname_err">#</a></span></h2>
+</section><section><h3><code>util.getSystemErrorName(err)</code><span><a class="mark" href="#util_util_getsystemerrorname_err" id="util_util_getsystemerrorname_err">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.7.0</span>
 </div>
@@ -58673,11 +63416,26 @@ an <code>inspectOptions</code> argument which specifies options that are passed
 <p>Returns the string name for a numeric error code that comes from a Node.js API.
 The mapping between error codes and error names is platform-dependent.
 See <a href="#errors_common_system_errors">Common System Errors</a> for the names of common errors.</p>
-<pre><code class="language-js">fs.access(<span class="hljs-string">'file/that/does/not/exist'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">const</span> name = util.getSystemErrorName(err.errno);
-  <span class="hljs-built_in">console</span>.error(name);  <span class="hljs-comment">// ENOENT</span>
+<pre><code class="language-js">fs.<span class="hljs-title function_">access</span>(<span class="hljs-string">'file/that/does/not/exist'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">const</span> name = util.<span class="hljs-title function_">getSystemErrorName</span>(err.<span class="hljs-property">errno</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(name);  <span class="hljs-comment">// ENOENT</span>
 });</code></pre>
-<h2><code>util.inherits(constructor, superConstructor)</code><span><a class="mark" href="#util_util_inherits_constructor_superconstructor" id="util_util_inherits_constructor_superconstructor">#</a></span></h2>
+</section><section><h3><code>util.getSystemErrorMap()</code><span><a class="mark" href="#util_util_getsystemerrormap" id="util_util_getsystemerrormap">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" class="type">&#x3C;Map></a></li>
+</ul>
+<p>Returns a Map of all system error codes available from the Node.js API.
+The mapping between error codes and error names is platform-dependent.
+See <a href="#errors_common_system_errors">Common System Errors</a> for the names of common errors.</p>
+<pre><code class="language-js">fs.<span class="hljs-title function_">access</span>(<span class="hljs-string">'file/that/does/not/exist'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">const</span> errorMap = util.<span class="hljs-title function_">getSystemErrorMap</span>();
+  <span class="hljs-keyword">const</span> name = errorMap.<span class="hljs-title function_">get</span>(err.<span class="hljs-property">errno</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(name);  <span class="hljs-comment">// ENOENT</span>
+});</code></pre>
+</section><section><h3><code>util.inherits(constructor, superConstructor)</code><span><a class="mark" href="#util_util_inherits_constructor_superconstructor" id="util_util_inherits_constructor_superconstructor">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -58689,6 +63447,7 @@ See <a href="#errors_common_system_errors">Common System Errors</a> for the name
 </tbody></table>
 </details>
 </div>
+<p></p><div class="api_stability api_stability_3"><a href="#documentation_stability_index">Stability: 3</a> - Legacy: Use ES2015 class syntax and <code>extends</code> keyword instead.</div><p></p>
 <ul>
 <li><code>constructor</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li><code>superConstructor</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
@@ -58704,53 +63463,55 @@ prototype of <code>constructor</code> will be set to a new object created from
 As an additional convenience, <code>superConstructor</code> will be accessible
 through the <code>constructor.super_</code> property.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyStream</span>(<span class="hljs-params"></span>) </span>{
-  EventEmitter.call(<span class="hljs-built_in">this</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyStream</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-title class_">EventEmitter</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>);
 }
 
-util.inherits(MyStream, EventEmitter);
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyStream</span>, <span class="hljs-title class_">EventEmitter</span>);
 
-MyStream.prototype.write = <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">data</span>) </span>{
-  <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'data'</span>, data);
+<span class="hljs-title class_">MyStream</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">write</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">data</span>) {
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'data'</span>, data);
 };
 
-<span class="hljs-keyword">const</span> stream = <span class="hljs-keyword">new</span> MyStream();
+<span class="hljs-keyword">const</span> stream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyStream</span>();
 
-<span class="hljs-built_in">console</span>.log(stream <span class="hljs-keyword">instanceof</span> EventEmitter); <span class="hljs-comment">// true</span>
-<span class="hljs-built_in">console</span>.log(MyStream.super_ === EventEmitter); <span class="hljs-comment">// true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stream <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">EventEmitter</span>); <span class="hljs-comment">// true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">MyStream</span>.<span class="hljs-property">super_</span> === <span class="hljs-title class_">EventEmitter</span>); <span class="hljs-comment">// true</span>
 
-stream.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received data: "<span class="hljs-subst">${data}</span>"`</span>);
+stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received data: "<span class="hljs-subst">${data}</span>"`</span>);
 });
-stream.write(<span class="hljs-string">'It works!'</span>); <span class="hljs-comment">// Received data: "It works!"</span></code></pre>
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'It works!'</span>); <span class="hljs-comment">// Received data: "It works!"</span></code></pre>
 <p>ES6 example using <code>class</code> and <code>extends</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyStream</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">EventEmitter</span> </span>{
-  write(data) {
-    <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'data'</span>, data);
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyStream</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">data</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'data'</span>, data);
   }
 }
 
-<span class="hljs-keyword">const</span> stream = <span class="hljs-keyword">new</span> MyStream();
+<span class="hljs-keyword">const</span> stream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyStream</span>();
 
-stream.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received data: "<span class="hljs-subst">${data}</span>"`</span>);
+stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received data: "<span class="hljs-subst">${data}</span>"`</span>);
 });
-stream.write(<span class="hljs-string">'With ES6'</span>);</code></pre>
-<h2><code>util.inspect(object[, options])</code><span><a class="mark" href="#util_util_inspect_object_options" id="util_util_inspect_object_options">#</a></span></h2>
-<h2><code>util.inspect(object[, showHidden[, depth[, colors]]])</code><span><a class="mark" href="#util_util_inspect_object_showhidden_depth_colors" id="util_util_inspect_object_showhidden_depth_colors">#</a></span></h2>
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'With ES6'</span>);</code></pre>
+</section><section><h3><code>util.inspect(object[, options])</code><span><a class="mark" href="#util_util_inspect_object_options" id="util_util_inspect_object_options">#</a></span></h3>
+</section><section><h3><code>util.inspect(object[, showHidden[, depth[, colors]]])</code><span><a class="mark" href="#util_util_inspect_object_showhidden_depth_colors" id="util_util_inspect_object_showhidden_depth_colors">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>Circular references now include a marker to the reference.</p></td></tr>
 <tr><td>v14.6.0, v12.19.0</td>
 <td><p>If <code>object</code> is from a different <code>vm.Context</code> now, a custom inspection function on it will not receive context-specific arguments anymore.</p></td></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.13.0, v12.17.0</td>
 <td><p>The <code>maxStringLength</code> option is supported now.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.5.0, v12.16.0</td>
 <td><p>User defined prototype properties are inspected in case <code>showHidden</code> is <code>true</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>The <code>compact</code> options default is changed to <code>3</code> and the <code>breakLength</code> options default is changed to <code>80</code>.</p></td></tr>
@@ -58846,37 +63607,37 @@ and should not be depended upon programmatically. Additional <code>options</code
 passed that alter the result.
 <code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make
 an identifiable tag for an inspected value.</p>
-<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Foo</span> </span>{
-  get [<span class="hljs-built_in">Symbol</span>.toStringTag]() {
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Foo</span> {
+  get [<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">toStringTag</span>]() {
     <span class="hljs-keyword">return</span> <span class="hljs-string">'bar'</span>;
   }
 }
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Bar</span> </span>{}
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Bar</span> {}
 
-<span class="hljs-keyword">const</span> baz = <span class="hljs-built_in">Object</span>.create(<span class="hljs-literal">null</span>, { [<span class="hljs-built_in">Symbol</span>.toStringTag]: { <span class="hljs-attr">value</span>: <span class="hljs-string">'foo'</span> } });
+<span class="hljs-keyword">const</span> baz = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(<span class="hljs-literal">null</span>, { [<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">toStringTag</span>]: { <span class="hljs-attr">value</span>: <span class="hljs-string">'foo'</span> } });
 
-util.inspect(<span class="hljs-keyword">new</span> Foo()); <span class="hljs-comment">// 'Foo [bar] {}'</span>
-util.inspect(<span class="hljs-keyword">new</span> Bar()); <span class="hljs-comment">// 'Bar {}'</span>
-util.inspect(baz);       <span class="hljs-comment">// '[foo] {}'</span></code></pre>
-<p>Circular references are marked as <code>'[Circular]'</code>:</p>
+util.<span class="hljs-title function_">inspect</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Foo</span>()); <span class="hljs-comment">// 'Foo [bar] {}'</span>
+util.<span class="hljs-title function_">inspect</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Bar</span>()); <span class="hljs-comment">// 'Bar {}'</span>
+util.<span class="hljs-title function_">inspect</span>(baz);       <span class="hljs-comment">// '[foo] {}'</span></code></pre>
+<p>Circular references point to their anchor by using a reference index:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { inspect } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
 <span class="hljs-keyword">const</span> obj = {};
-obj.a = [obj];
-obj.b = {};
-obj.b.inner = obj.b;
-obj.b.obj = obj;
-
-<span class="hljs-built_in">console</span>.log(inspect(obj));
-<span class="hljs-comment">// {</span>
-<span class="hljs-comment">//   a: [ [Circular] ],</span>
-<span class="hljs-comment">//   b: { inner: [Circular], obj: [Circular] }</span>
+obj.<span class="hljs-property">a</span> = [obj];
+obj.<span class="hljs-property">b</span> = {};
+obj.<span class="hljs-property">b</span>.<span class="hljs-property">inner</span> = obj.<span class="hljs-property">b</span>;
+obj.<span class="hljs-property">b</span>.<span class="hljs-property">obj</span> = obj;
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">inspect</span>(obj));
+<span class="hljs-comment">// &#x3C;ref *1> {</span>
+<span class="hljs-comment">//   a: [ [Circular *1] ],</span>
+<span class="hljs-comment">//   b: &#x3C;ref *2> { inner: [Circular *2], obj: [Circular *1] }</span>
 <span class="hljs-comment">// }</span></code></pre>
 <p>The following example inspects all properties of the <code>util</code> object:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-built_in">console</span>.log(util.inspect(util, { <span class="hljs-attr">showHidden</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">depth</span>: <span class="hljs-literal">null</span> }));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(util.<span class="hljs-title function_">inspect</span>(util, { <span class="hljs-attr">showHidden</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">depth</span>: <span class="hljs-literal">null</span> }));</code></pre>
 <p>The following example highlights the effect of the <code>compact</code> option:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
@@ -58886,9 +63647,9 @@ obj.b.obj = obj;
       <span class="hljs-string">'eiusmod tempor incididunt ut labore et dolore magna aliqua.'</span>,
     <span class="hljs-string">'test'</span>,
     <span class="hljs-string">'foo'</span>]], <span class="hljs-number">4</span>],
-  <span class="hljs-attr">b</span>: <span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>([[<span class="hljs-string">'za'</span>, <span class="hljs-number">1</span>], [<span class="hljs-string">'zb'</span>, <span class="hljs-string">'test'</span>]])
+  <span class="hljs-attr">b</span>: <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>([[<span class="hljs-string">'za'</span>, <span class="hljs-number">1</span>], [<span class="hljs-string">'zb'</span>, <span class="hljs-string">'test'</span>]])
 };
-<span class="hljs-built_in">console</span>.log(util.inspect(o, { <span class="hljs-attr">compact</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">depth</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">breakLength</span>: <span class="hljs-number">80</span> }));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(util.<span class="hljs-title function_">inspect</span>(o, { <span class="hljs-attr">compact</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">depth</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">breakLength</span>: <span class="hljs-number">80</span> }));
 
 <span class="hljs-comment">// { a:</span>
 <span class="hljs-comment">//   [ 1,</span>
@@ -58897,10 +63658,10 @@ obj.b.obj = obj;
 <span class="hljs-comment">//           'test',</span>
 <span class="hljs-comment">//           'foo' ] ],</span>
 <span class="hljs-comment">//     4 ],</span>
-<span class="hljs-comment">//   b: Map { 'za' => 1, 'zb' => 'test' } }</span>
+<span class="hljs-comment">//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }</span>
 
 <span class="hljs-comment">// Setting `compact` to false changes the output to be more reader friendly.</span>
-<span class="hljs-built_in">console</span>.log(util.inspect(o, { <span class="hljs-attr">compact</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">depth</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">breakLength</span>: <span class="hljs-number">80</span> }));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(util.<span class="hljs-title function_">inspect</span>(o, { <span class="hljs-attr">compact</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">depth</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">breakLength</span>: <span class="hljs-number">80</span> }));
 
 <span class="hljs-comment">// {</span>
 <span class="hljs-comment">//   a: [</span>
@@ -58918,7 +63679,7 @@ obj.b.obj = obj;
 <span class="hljs-comment">//     ],</span>
 <span class="hljs-comment">//     4</span>
 <span class="hljs-comment">//   ],</span>
-<span class="hljs-comment">//   b: Map {</span>
+<span class="hljs-comment">//   b: Map(2) {</span>
 <span class="hljs-comment">//     'za' => 1,</span>
 <span class="hljs-comment">//     'zb' => 'test'</span>
 <span class="hljs-comment">//   }</span>
@@ -58937,9 +63698,9 @@ with no remaining strong references may be garbage collected at any time.</p>
 
 <span class="hljs-keyword">const</span> obj = { <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> };
 <span class="hljs-keyword">const</span> obj2 = { <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> };
-<span class="hljs-keyword">const</span> weakSet = <span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakSet</span>([obj, obj2]);
+<span class="hljs-keyword">const</span> weakSet = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakSet</span>([obj, obj2]);
 
-<span class="hljs-built_in">console</span>.log(inspect(weakSet, { <span class="hljs-attr">showHidden</span>: <span class="hljs-literal">true</span> }));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">inspect</span>(weakSet, { <span class="hljs-attr">showHidden</span>: <span class="hljs-literal">true</span> }));
 <span class="hljs-comment">// WeakSet { { a: 1 }, { b: 2 } }</span></code></pre>
 <p>The <code>sorted</code> option ensures that an object's property insertion order does not
 impact the result of <code>util.inspect()</code>.</p>
@@ -58949,26 +63710,26 @@ impact the result of <code>util.inspect()</code>.</p>
 <span class="hljs-keyword">const</span> o1 = {
   <span class="hljs-attr">b</span>: [<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>],
   <span class="hljs-attr">a</span>: <span class="hljs-string">'`a` comes before `b`'</span>,
-  <span class="hljs-attr">c</span>: <span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>([<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>])
+  <span class="hljs-attr">c</span>: <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>([<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>])
 };
-<span class="hljs-built_in">console</span>.log(inspect(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> }));
-<span class="hljs-comment">// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set { 1, 2, 3 } }</span>
-<span class="hljs-built_in">console</span>.log(inspect(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> b.localeCompare(a) }));
-<span class="hljs-comment">// { c: Set { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">inspect</span>(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> }));
+<span class="hljs-comment">// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">inspect</span>(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> b.<span class="hljs-title function_">localeCompare</span>(a) }));
+<span class="hljs-comment">// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }</span>
 
 <span class="hljs-keyword">const</span> o2 = {
-  <span class="hljs-attr">c</span>: <span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>([<span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">3</span>]),
+  <span class="hljs-attr">c</span>: <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>([<span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">3</span>]),
   <span class="hljs-attr">a</span>: <span class="hljs-string">'`a` comes before `b`'</span>,
   <span class="hljs-attr">b</span>: [<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>]
 };
-assert.strict.equal(
-  inspect(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> }),
-  inspect(o2, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> })
+assert.<span class="hljs-property">strict</span>.<span class="hljs-title function_">equal</span>(
+  <span class="hljs-title function_">inspect</span>(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> }),
+  <span class="hljs-title function_">inspect</span>(o2, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> })
 );</code></pre>
 <p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum
 output length is approximately 128 MB. Inputs that result in longer output will
 be truncated.</p>
-<h3>Customizing <code>util.inspect</code> colors<span><a class="mark" href="#util_customizing_util_inspect_colors" id="util_customizing_util_inspect_colors">#</a></span></h3>
+<h4>Customizing <code>util.inspect</code> colors<span><a class="mark" href="#util_customizing_util_inspect_colors" id="util_customizing_util_inspect_colors">#</a></span></h4>
 
 <p>Color output (if enabled) of <code>util.inspect</code> is customizable globally
 via the <code>util.inspect.styles</code> and <code>util.inspect.colors</code> properties.</p>
@@ -58993,7 +63754,7 @@ via the <code>util.inspect.styles</code> and <code>util.inspect.colors</code> pr
 terminals. To verify color support use <a href="#tty_writestream_hascolors_count_env"><code>tty.hasColors()</code></a>.</p>
 <p>Predefined control codes are listed below (grouped as "Modifiers", "Foreground
 colors", and "Background colors").</p>
-<h4>Modifiers<span><a class="mark" href="#util_modifiers" id="util_modifiers">#</a></span></h4>
+<h5>Modifiers<span><a class="mark" href="#util_modifiers" id="util_modifiers">#</a></span></h5>
 <p>Modifier support varies throughout different terminals. They will mostly be
 ignored, if not supported.</p>
 <ul>
@@ -59014,7 +63775,7 @@ background colors (Alias: <code>swapcolors</code>, <code>swapColors</code>)</li>
 double underlined (Alias: <code>doubleUnderline</code>)</li>
 <li><span style="border: 1px">framed</span> - Draw a frame around the text</li>
 </ul>
-<h4>Foreground colors<span><a class="mark" href="#util_foreground_colors" id="util_foreground_colors">#</a></span></h4>
+<h5>Foreground colors<span><a class="mark" href="#util_foreground_colors" id="util_foreground_colors">#</a></span></h5>
 <ul>
 <li><code>black</code></li>
 <li><code>red</code></li>
@@ -59033,7 +63794,7 @@ double underlined (Alias: <code>doubleUnderline</code>)</li>
 <li><code>cyanBright</code></li>
 <li><code>whiteBright</code></li>
 </ul>
-<h4>Background colors<span><a class="mark" href="#util_background_colors" id="util_background_colors">#</a></span></h4>
+<h5>Background colors<span><a class="mark" href="#util_background_colors" id="util_background_colors">#</a></span></h5>
 <ul>
 <li><code>bgBlack</code></li>
 <li><code>bgRed</code></li>
@@ -59052,7 +63813,7 @@ double underlined (Alias: <code>doubleUnderline</code>)</li>
 <li><code>bgCyanBright</code></li>
 <li><code>bgWhiteBright</code></li>
 </ul>
-<h3>Custom inspection functions on objects<span><a class="mark" href="#util_custom_inspection_functions_on_objects" id="util_custom_inspection_functions_on_objects">#</a></span></h3>
+<h4>Custom inspection functions on objects<span><a class="mark" href="#util_custom_inspection_functions_on_objects" id="util_custom_inspection_functions_on_objects">#</a></span></h4>
 
 <p>Objects may also define their own
 <a href="#util_util_inspect_custom"><code>[util.inspect.custom](depth, opts)</code></a> function,
@@ -59060,31 +63821,31 @@ which <code>util.inspect()</code> will invoke and use the result of when inspect
 the object:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Box</span> </span>{
-  <span class="hljs-keyword">constructor</span>(value) {
-    <span class="hljs-built_in">this</span>.value = value;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Box</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">value</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">value</span> = value;
   }
 
-  [util.inspect.custom](depth, options) {
+  [util.<span class="hljs-property">inspect</span>.<span class="hljs-property">custom</span>](depth, options) {
     <span class="hljs-keyword">if</span> (depth &#x3C; <span class="hljs-number">0</span>) {
-      <span class="hljs-keyword">return</span> options.stylize(<span class="hljs-string">'[Box]'</span>, <span class="hljs-string">'special'</span>);
+      <span class="hljs-keyword">return</span> options.<span class="hljs-title function_">stylize</span>(<span class="hljs-string">'[Box]'</span>, <span class="hljs-string">'special'</span>);
     }
 
-    <span class="hljs-keyword">const</span> newOptions = <span class="hljs-built_in">Object</span>.assign({}, options, {
-      <span class="hljs-attr">depth</span>: options.depth === <span class="hljs-literal">null</span> ? <span class="hljs-literal">null</span> : options.depth - <span class="hljs-number">1</span>
+    <span class="hljs-keyword">const</span> newOptions = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">assign</span>({}, options, {
+      <span class="hljs-attr">depth</span>: options.<span class="hljs-property">depth</span> === <span class="hljs-literal">null</span> ? <span class="hljs-literal">null</span> : options.<span class="hljs-property">depth</span> - <span class="hljs-number">1</span>
     });
 
     <span class="hljs-comment">// Five space padding because that's the size of "Box&#x3C; ".</span>
-    <span class="hljs-keyword">const</span> padding = <span class="hljs-string">' '</span>.repeat(<span class="hljs-number">5</span>);
-    <span class="hljs-keyword">const</span> inner = util.inspect(<span class="hljs-built_in">this</span>.value, newOptions)
-                      .replace(<span class="hljs-regexp">/\n/g</span>, <span class="hljs-string">`\n<span class="hljs-subst">${padding}</span>`</span>);
+    <span class="hljs-keyword">const</span> padding = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(<span class="hljs-number">5</span>);
+    <span class="hljs-keyword">const</span> inner = util.<span class="hljs-title function_">inspect</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">value</span>, newOptions)
+                      .<span class="hljs-title function_">replace</span>(<span class="hljs-regexp">/\n/g</span>, <span class="hljs-string">`\n<span class="hljs-subst">${padding}</span>`</span>);
     <span class="hljs-keyword">return</span> <span class="hljs-string">`<span class="hljs-subst">${options.stylize(<span class="hljs-string">'Box'</span>, <span class="hljs-string">'special'</span>)}</span>&#x3C; <span class="hljs-subst">${inner}</span> >`</span>;
   }
 }
 
-<span class="hljs-keyword">const</span> box = <span class="hljs-keyword">new</span> Box(<span class="hljs-literal">true</span>);
+<span class="hljs-keyword">const</span> box = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Box</span>(<span class="hljs-literal">true</span>);
 
-util.inspect(box);
+util.<span class="hljs-title function_">inspect</span>(box);
 <span class="hljs-comment">// Returns: "Box&#x3C; true >"</span></code></pre>
 <p>Custom <code>[util.inspect.custom](depth, opts)</code> functions typically return a string
 but may return a value of any type that will be formatted accordingly by
@@ -59092,13 +63853,13 @@ but may return a value of any type that will be formatted accordingly by
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
 <span class="hljs-keyword">const</span> obj = { <span class="hljs-attr">foo</span>: <span class="hljs-string">'this will not show up in the inspect() output'</span> };
-obj[util.inspect.custom] = <span class="hljs-function">(<span class="hljs-params">depth</span>) =></span> {
+obj[util.<span class="hljs-property">inspect</span>.<span class="hljs-property">custom</span>] = <span class="hljs-function">(<span class="hljs-params">depth</span>) =></span> {
   <span class="hljs-keyword">return</span> { <span class="hljs-attr">bar</span>: <span class="hljs-string">'baz'</span> };
 };
 
-util.inspect(obj);
+util.<span class="hljs-title function_">inspect</span>(obj);
 <span class="hljs-comment">// Returns: "{ bar: 'baz' }"</span></code></pre>
-<h3><code>util.inspect.custom</code><span><a class="mark" href="#util_util_inspect_custom" id="util_util_inspect_custom">#</a></span></h3>
+<h4><code>util.inspect.custom</code><span><a class="mark" href="#util_util_inspect_custom" id="util_util_inspect_custom">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -59116,27 +63877,27 @@ util.inspect(obj);
 <p>In addition to being accessible through <code>util.inspect.custom</code>, this
 symbol is <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for">registered globally</a> and can be
 accessed in any environment as <code>Symbol.for('nodejs.util.inspect.custom')</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> inspect = <span class="hljs-built_in">Symbol</span>.for(<span class="hljs-string">'nodejs.util.inspect.custom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> inspect = <span class="hljs-title class_">Symbol</span>.<span class="hljs-title function_">for</span>(<span class="hljs-string">'nodejs.util.inspect.custom'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Password</span> </span>{
-  <span class="hljs-keyword">constructor</span>(value) {
-    <span class="hljs-built_in">this</span>.value = value;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Password</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">value</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">value</span> = value;
   }
 
-  toString() {
+  <span class="hljs-title function_">toString</span>(<span class="hljs-params"></span>) {
     <span class="hljs-keyword">return</span> <span class="hljs-string">'xxxxxxxx'</span>;
   }
 
   [inspect]() {
-    <span class="hljs-keyword">return</span> <span class="hljs-string">`Password &#x3C;<span class="hljs-subst">${<span class="hljs-built_in">this</span>.toString()}</span>>`</span>;
+    <span class="hljs-keyword">return</span> <span class="hljs-string">`Password &#x3C;<span class="hljs-subst">${<span class="hljs-variable language_">this</span>.toString()}</span>>`</span>;
   }
 }
 
-<span class="hljs-keyword">const</span> password = <span class="hljs-keyword">new</span> Password(<span class="hljs-string">'r0sebud'</span>);
-<span class="hljs-built_in">console</span>.log(password);
+<span class="hljs-keyword">const</span> password = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Password</span>(<span class="hljs-string">'r0sebud'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(password);
 <span class="hljs-comment">// Prints Password &#x3C;xxxxxxxx></span></code></pre>
 <p>See <a href="#util_custom_inspection_functions_on_objects">Custom inspection functions on Objects</a> for more details.</p>
-<h3><code>util.inspect.defaultOptions</code><span><a class="mark" href="#util_util_inspect_defaultoptions" id="util_util_inspect_defaultoptions">#</a></span></h3>
+<h4><code>util.inspect.defaultOptions</code><span><a class="mark" href="#util_util_inspect_defaultoptions" id="util_util_inspect_defaultoptions">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.4.0</span>
 </div>
@@ -59146,12 +63907,12 @@ accessed in any environment as <code>Symbol.for('nodejs.util.inspect.custom')</c
 object containing one or more valid <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a> options. Setting
 option properties directly is also supported.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> arr = <span class="hljs-built_in">Array</span>(<span class="hljs-number">101</span>).fill(<span class="hljs-number">0</span>);
+<span class="hljs-keyword">const</span> arr = <span class="hljs-title class_">Array</span>(<span class="hljs-number">101</span>).<span class="hljs-title function_">fill</span>(<span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(arr); <span class="hljs-comment">// Logs the truncated array</span>
-util.inspect.defaultOptions.maxArrayLength = <span class="hljs-literal">null</span>;
-<span class="hljs-built_in">console</span>.log(arr); <span class="hljs-comment">// logs the full array</span></code></pre>
-<h2><code>util.isDeepStrictEqual(val1, val2)</code><span><a class="mark" href="#util_util_isdeepstrictequal_val1_val2" id="util_util_isdeepstrictequal_val1_val2">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arr); <span class="hljs-comment">// Logs the truncated array</span>
+util.<span class="hljs-property">inspect</span>.<span class="hljs-property">defaultOptions</span>.<span class="hljs-property">maxArrayLength</span> = <span class="hljs-literal">null</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arr); <span class="hljs-comment">// logs the full array</span></code></pre>
+</section><section><h3><code>util.isDeepStrictEqual(val1, val2)</code><span><a class="mark" href="#util_util_isdeepstrictequal_val1_val2" id="util_util_isdeepstrictequal_val1_val2">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -59164,7 +63925,7 @@ util.inspect.defaultOptions.maxArrayLength = <span class="hljs-literal">null</sp
 Otherwise, returns <code>false</code>.</p>
 <p>See <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> for more information about deep strict
 equality.</p>
-<h2><code>util.promisify(original)</code><span><a class="mark" href="#util_util_promisify_original" id="util_util_promisify_original">#</a></span></h2>
+</section><section><h3><code>util.promisify(original)</code><span><a class="mark" href="#util_util_promisify_original" id="util_util_promisify_original">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -59178,21 +63939,21 @@ that returns promises.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> stat = util.promisify(fs.stat);
-stat(<span class="hljs-string">'.'</span>).then(<span class="hljs-function">(<span class="hljs-params">stats</span>) =></span> {
+<span class="hljs-keyword">const</span> stat = util.<span class="hljs-title function_">promisify</span>(fs.<span class="hljs-property">stat</span>);
+<span class="hljs-title function_">stat</span>(<span class="hljs-string">'.'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">stats</span>) =></span> {
   <span class="hljs-comment">// Do something with `stats`</span>
-}).catch(<span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
+}).<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
   <span class="hljs-comment">// Handle the error.</span>
 });</code></pre>
 <p>Or, equivalently using <code>async function</code>s:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> stat = util.promisify(fs.stat);
+<span class="hljs-keyword">const</span> stat = util.<span class="hljs-title function_">promisify</span>(fs.<span class="hljs-property">stat</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">callStat</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> stat(<span class="hljs-string">'.'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`This directory is owned by <span class="hljs-subst">${stats.uid}</span>`</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">callStat</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> <span class="hljs-title function_">stat</span>(<span class="hljs-string">'.'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`This directory is owned by <span class="hljs-subst">${stats.uid}</span>`</span>);
 }</code></pre>
 <p>If there is an <code>original[util.promisify.custom]</code> property present, <code>promisify</code>
 will return its value, see <a href="#util_custom_promisified_functions">Custom promisified functions</a>.</p>
@@ -59205,59 +63966,59 @@ callback as its last argument.</p>
 work as expected unless handled specially:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Foo</span> </span>{
-  <span class="hljs-keyword">constructor</span>() {
-    <span class="hljs-built_in">this</span>.a = <span class="hljs-number">42</span>;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Foo</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">a</span> = <span class="hljs-number">42</span>;
   }
 
-  bar(callback) {
-    callback(<span class="hljs-literal">null</span>, <span class="hljs-built_in">this</span>.a);
+  <span class="hljs-title function_">bar</span>(<span class="hljs-params">callback</span>) {
+    <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, <span class="hljs-variable language_">this</span>.<span class="hljs-property">a</span>);
   }
 }
 
-<span class="hljs-keyword">const</span> foo = <span class="hljs-keyword">new</span> Foo();
+<span class="hljs-keyword">const</span> foo = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Foo</span>();
 
-<span class="hljs-keyword">const</span> naiveBar = util.promisify(foo.bar);
+<span class="hljs-keyword">const</span> naiveBar = util.<span class="hljs-title function_">promisify</span>(foo.<span class="hljs-property">bar</span>);
 <span class="hljs-comment">// TypeError: Cannot read property 'a' of undefined</span>
 <span class="hljs-comment">// naiveBar().then(a => console.log(a));</span>
 
-naiveBar.call(foo).then(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> <span class="hljs-built_in">console</span>.log(a)); <span class="hljs-comment">// '42'</span>
+naiveBar.<span class="hljs-title function_">call</span>(foo).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(a)); <span class="hljs-comment">// '42'</span>
 
-<span class="hljs-keyword">const</span> bindBar = naiveBar.bind(foo);
-bindBar().then(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> <span class="hljs-built_in">console</span>.log(a)); <span class="hljs-comment">// '42'</span></code></pre>
-<h3>Custom promisified functions<span><a class="mark" href="#util_custom_promisified_functions" id="util_custom_promisified_functions">#</a></span></h3>
+<span class="hljs-keyword">const</span> bindBar = naiveBar.<span class="hljs-title function_">bind</span>(foo);
+<span class="hljs-title function_">bindBar</span>().<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(a)); <span class="hljs-comment">// '42'</span></code></pre>
+<h4>Custom promisified functions<span><a class="mark" href="#util_custom_promisified_functions" id="util_custom_promisified_functions">#</a></span></h4>
 <p>Using the <code>util.promisify.custom</code> symbol one can override the return value of
 <a href="#util_util_promisify_original"><code>util.promisify()</code></a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">doSomething</span>(<span class="hljs-params">foo, callback</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">doSomething</span>(<span class="hljs-params">foo, callback</span>) {
   <span class="hljs-comment">// ...</span>
 }
 
-doSomething[util.promisify.custom] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
-  <span class="hljs-keyword">return</span> getPromiseSomehow();
+doSomething[util.<span class="hljs-property">promisify</span>.<span class="hljs-property">custom</span>] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">getPromiseSomehow</span>();
 };
 
-<span class="hljs-keyword">const</span> promisified = util.promisify(doSomething);
-<span class="hljs-built_in">console</span>.log(promisified === doSomething[util.promisify.custom]);
+<span class="hljs-keyword">const</span> promisified = util.<span class="hljs-title function_">promisify</span>(doSomething);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(promisified === doSomething[util.<span class="hljs-property">promisify</span>.<span class="hljs-property">custom</span>]);
 <span class="hljs-comment">// prints 'true'</span></code></pre>
 <p>This can be useful for cases where the original function does not follow the
 standard format of taking an error-first callback as the last argument.</p>
 <p>For example, with a function that takes in
 <code>(foo, onSuccessCallback, onErrorCallback)</code>:</p>
-<pre><code class="language-js">doSomething[util.promisify.custom] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
-  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-    doSomething(foo, resolve, reject);
+<pre><code class="language-js">doSomething[util.<span class="hljs-property">promisify</span>.<span class="hljs-property">custom</span>] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
+  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+    <span class="hljs-title function_">doSomething</span>(foo, resolve, reject);
   });
 };</code></pre>
 <p>If <code>promisify.custom</code> is defined but is not a function, <code>promisify()</code> will
 throw an error.</p>
-<h3><code>util.promisify.custom</code><span><a class="mark" href="#util_util_promisify_custom" id="util_util_promisify_custom">#</a></span></h3>
+<h4><code>util.promisify.custom</code><span><a class="mark" href="#util_util_promisify_custom" id="util_util_promisify_custom">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.2</td>
+<tr><td>v13.12.0, v12.16.2</td>
 <td><p>This is now defined as a shared symbol.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p><span>Added in: v8.0.0</span></p></td></tr>
@@ -59273,34 +64034,32 @@ symbol is <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refer
 accessed in any environment as <code>Symbol.for('nodejs.util.promisify.custom')</code>.</p>
 <p>For example, with a function that takes in
 <code>(foo, onSuccessCallback, onErrorCallback)</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> kCustomPromisifiedSymbol = <span class="hljs-built_in">Symbol</span>.for(<span class="hljs-string">'nodejs.util.promisify.custom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> kCustomPromisifiedSymbol = <span class="hljs-title class_">Symbol</span>.<span class="hljs-title function_">for</span>(<span class="hljs-string">'nodejs.util.promisify.custom'</span>);
 
 doSomething[kCustomPromisifiedSymbol] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
-  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-    doSomething(foo, resolve, reject);
+  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+    <span class="hljs-title function_">doSomething</span>(foo, resolve, reject);
   });
 };</code></pre>
-<h2>Class: <code>util.TextDecoder</code><span><a class="mark" href="#util_class_util_textdecoder" id="util_class_util_textdecoder">#</a></span></h2>
+</section><section><h3>Class: <code>util.TextDecoder</code><span><a class="mark" href="#util_class_util_textdecoder" id="util_class_util_textdecoder">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
 <p>An implementation of the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a> <code>TextDecoder</code> API.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> TextDecoder(<span class="hljs-string">'shift_jis'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">TextDecoder</span>(<span class="hljs-string">'shift_jis'</span>);
 <span class="hljs-keyword">let</span> string = <span class="hljs-string">''</span>;
 <span class="hljs-keyword">let</span> buffer;
-<span class="hljs-keyword">while</span> (buffer = getNextChunkSomehow()) {
-  string += decoder.decode(buffer, { <span class="hljs-attr">stream</span>: <span class="hljs-literal">true</span> });
+<span class="hljs-keyword">while</span> (buffer = <span class="hljs-title function_">getNextChunkSomehow</span>()) {
+  string += decoder.<span class="hljs-title function_">decode</span>(buffer, { <span class="hljs-attr">stream</span>: <span class="hljs-literal">true</span> });
 }
-string += decoder.decode(); <span class="hljs-comment">// end-of-stream</span></code></pre>
-<h3>WHATWG supported encodings<span><a class="mark" href="#util_whatwg_supported_encodings" id="util_whatwg_supported_encodings">#</a></span></h3>
+string += decoder.<span class="hljs-title function_">decode</span>(); <span class="hljs-comment">// end-of-stream</span></code></pre>
+<h4>WHATWG supported encodings<span><a class="mark" href="#util_whatwg_supported_encodings" id="util_whatwg_supported_encodings">#</a></span></h4>
 <p>Per the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a>, the encodings supported by the
 <code>TextDecoder</code> API are outlined in the tables below. For each encoding,
 one or more aliases may be used.</p>
 <p>Different Node.js build configurations support different sets of encodings.
-While a very basic set of encodings is supported even on Node.js builds without
-ICU enabled, support for some encodings is provided only when Node.js is built
-with ICU and using the full ICU data (see <a href="intl.html">Internationalization</a>).</p>
-<h4>Encodings Supported Without ICU<span><a class="mark" href="#util_encodings_supported_without_icu" id="util_encodings_supported_without_icu">#</a></span></h4>
+(see <a href="intl.html">Internationalization</a>)</p>
+<h5>Encodings supported by default (with full ICU data)<span><a class="mark" href="#util_encodings_supported_by_default_with_full_icu_data" id="util_encodings_supported_by_default_with_full_icu_data">#</a></span></h5>
 
 
 
@@ -59318,8 +64077,6 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
-<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'utf-8'</code></td><td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td></tr><tr><td><code>'utf-16le'</code></td><td><code>'utf-16'</code></td></tr></tbody></table>
-<h4>Encodings Supported by Default (With ICU)<span><a class="mark" href="#util_encodings_supported_by_default_with_icu" id="util_encodings_supported_by_default_with_icu">#</a></span></h4>
 
 
 
@@ -59341,8 +64098,6 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
-<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'utf-8'</code></td><td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td></tr><tr><td><code>'utf-16le'</code></td><td><code>'utf-16'</code></td></tr><tr><td><code>'utf-16be'</code></td><td></td></tr></tbody></table>
-<h4>Encodings requiring full ICU data<span><a class="mark" href="#util_encodings_requiring_full_icu_data" id="util_encodings_requiring_full_icu_data">#</a></span></h4>
 
 
 
@@ -59450,6 +64205,8 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
+<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'ibm866'</code></td><td><code>'866'</code>, <code>'cp866'</code>, <code>'csibm866'</code></td></tr><tr><td><code>'iso-8859-2'</code></td><td><code>'csisolatin2'</code>, <code>'iso-ir-101'</code>, <code>'iso8859-2'</code>, <code>'iso88592'</code>, <code>'iso_8859-2'</code>, <code>'iso_8859-2:1987'</code>, <code>'l2'</code>, <code>'latin2'</code></td></tr><tr><td><code>'iso-8859-3'</code></td><td><code>'csisolatin3'</code>, <code>'iso-ir-109'</code>, <code>'iso8859-3'</code>, <code>'iso88593'</code>, <code>'iso_8859-3'</code>, <code>'iso_8859-3:1988'</code>, <code>'l3'</code>, <code>'latin3'</code></td></tr><tr><td><code>'iso-8859-4'</code></td><td><code>'csisolatin4'</code>, <code>'iso-ir-110'</code>, <code>'iso8859-4'</code>, <code>'iso88594'</code>, <code>'iso_8859-4'</code>, <code>'iso_8859-4:1988'</code>, <code>'l4'</code>, <code>'latin4'</code></td></tr><tr><td><code>'iso-8859-5'</code></td><td><code>'csisolatincyrillic'</code>, <code>'cyrillic'</code>, <code>'iso-ir-144'</code>, <code>'iso8859-5'</code>, <code>'iso88595'</code>, <code>'iso_8859-5'</code>, <code>'iso_8859-5:1988'</code></td></tr><tr><td><code>'iso-8859-6'</code></td><td><code>'arabic'</code>, <code>'asmo-708'</code>, <code>'csiso88596e'</code>, <code>'csiso88596i'</code>, <code>'csisolatinarabic'</code>, <code>'ecma-114'</code>, <code>'iso-8859-6-e'</code>, <code>'iso-8859-6-i'</code>, <code>'iso-ir-127'</code>, <code>'iso8859-6'</code>, <code>'iso88596'</code>, <code>'iso_8859-6'</code>, <code>'iso_8859-6:1987'</code></td></tr><tr><td><code>'iso-8859-7'</code></td><td><code>'csisolatingreek'</code>, <code>'ecma-118'</code>, <code>'elot_928'</code>, <code>'greek'</code>, <code>'greek8'</code>, <code>'iso-ir-126'</code>, <code>'iso8859-7'</code>, <code>'iso88597'</code>, <code>'iso_8859-7'</code>, <code>'iso_8859-7:1987'</code>, <code>'sun_eu_greek'</code></td></tr><tr><td><code>'iso-8859-8'</code></td><td><code>'csiso88598e'</code>, <code>'csisolatinhebrew'</code>, <code>'hebrew'</code>, <code>'iso-8859-8-e'</code>, <code>'iso-ir-138'</code>, <code>'iso8859-8'</code>, <code>'iso88598'</code>, <code>'iso_8859-8'</code>, <code>'iso_8859-8:1988'</code>, <code>'visual'</code></td></tr><tr><td><code>'iso-8859-8-i'</code></td><td><code>'csiso88598i'</code>, <code>'logical'</code></td></tr><tr><td><code>'iso-8859-10'</code></td><td><code>'csisolatin6'</code>, <code>'iso-ir-157'</code>, <code>'iso8859-10'</code>, <code>'iso885910'</code>, <code>'l6'</code>, <code>'latin6'</code></td></tr><tr><td><code>'iso-8859-13'</code></td><td><code>'iso8859-13'</code>, <code>'iso885913'</code></td></tr><tr><td><code>'iso-8859-14'</code></td><td><code>'iso8859-14'</code>, <code>'iso885914'</code></td></tr><tr><td><code>'iso-8859-15'</code></td><td><code>'csisolatin9'</code>, <code>'iso8859-15'</code>, <code>'iso885915'</code>, <code>'iso_8859-15'</code>, <code>'l9'</code></td></tr><tr><td><code>'koi8-r'</code></td><td><code>'cskoi8r'</code>, <code>'koi'</code>, <code>'koi8'</code>, <code>'koi8_r'</code></td></tr><tr><td><code>'koi8-u'</code></td><td><code>'koi8-ru'</code></td></tr><tr><td><code>'macintosh'</code></td><td><code>'csmacintosh'</code>, <code>'mac'</code>, <code>'x-mac-roman'</code></td></tr><tr><td><code>'windows-874'</code></td><td><code>'dos-874'</code>, <code>'iso-8859-11'</code>, <code>'iso8859-11'</code>, <code>'iso885911'</code>, <code>'tis-620'</code></td></tr><tr><td><code>'windows-1250'</code></td><td><code>'cp1250'</code>, <code>'x-cp1250'</code></td></tr><tr><td><code>'windows-1251'</code></td><td><code>'cp1251'</code>, <code>'x-cp1251'</code></td></tr><tr><td><code>'windows-1252'</code></td><td><code>'ansi_x3.4-1968'</code>, <code>'ascii'</code>, <code>'cp1252'</code>, <code>'cp819'</code>, <code>'csisolatin1'</code>, <code>'ibm819'</code>, <code>'iso-8859-1'</code>, <code>'iso-ir-100'</code>, <code>'iso8859-1'</code>, <code>'iso88591'</code>, <code>'iso_8859-1'</code>, <code>'iso_8859-1:1987'</code>, <code>'l1'</code>, <code>'latin1'</code>, <code>'us-ascii'</code>, <code>'x-cp1252'</code></td></tr><tr><td><code>'windows-1253'</code></td><td><code>'cp1253'</code>, <code>'x-cp1253'</code></td></tr><tr><td><code>'windows-1254'</code></td><td><code>'cp1254'</code>, <code>'csisolatin5'</code>, <code>'iso-8859-9'</code>, <code>'iso-ir-148'</code>, <code>'iso8859-9'</code>, <code>'iso88599'</code>, <code>'iso_8859-9'</code>, <code>'iso_8859-9:1989'</code>, <code>'l5'</code>, <code>'latin5'</code>, <code>'x-cp1254'</code></td></tr><tr><td><code>'windows-1255'</code></td><td><code>'cp1255'</code>, <code>'x-cp1255'</code></td></tr><tr><td><code>'windows-1256'</code></td><td><code>'cp1256'</code>, <code>'x-cp1256'</code></td></tr><tr><td><code>'windows-1257'</code></td><td><code>'cp1257'</code>, <code>'x-cp1257'</code></td></tr><tr><td><code>'windows-1258'</code></td><td><code>'cp1258'</code>, <code>'x-cp1258'</code></td></tr><tr><td><code>'x-mac-cyrillic'</code></td><td><code>'x-mac-ukrainian'</code></td></tr><tr><td><code>'gbk'</code></td><td><code>'chinese'</code>, <code>'csgb2312'</code>, <code>'csiso58gb231280'</code>, <code>'gb2312'</code>, <code>'gb_2312'</code>, <code>'gb_2312-80'</code>, <code>'iso-ir-58'</code>, <code>'x-gbk'</code></td></tr><tr><td><code>'gb18030'</code></td><td></td></tr><tr><td><code>'big5'</code></td><td><code>'big5-hkscs'</code>, <code>'cn-big5'</code>, <code>'csbig5'</code>, <code>'x-x-big5'</code></td></tr><tr><td><code>'euc-jp'</code></td><td><code>'cseucpkdfmtjapanese'</code>, <code>'x-euc-jp'</code></td></tr><tr><td><code>'iso-2022-jp'</code></td><td><code>'csiso2022jp'</code></td></tr><tr><td><code>'shift_jis'</code></td><td><code>'csshiftjis'</code>, <code>'ms932'</code>, <code>'ms_kanji'</code>, <code>'shift-jis'</code>, <code>'sjis'</code>, <code>'windows-31j'</code>, <code>'x-sjis'</code></td></tr><tr><td><code>'euc-kr'</code></td><td><code>'cseuckr'</code>, <code>'csksc56011987'</code>, <code>'iso-ir-149'</code>, <code>'korean'</code>, <code>'ks_c_5601-1987'</code>, <code>'ks_c_5601-1989'</code>, <code>'ksc5601'</code>, <code>'ksc_5601'</code>, <code>'windows-949'</code></td></tr></tbody></table>
+<h5>Encodings supported when Node.js is built with the <code>small-icu</code> option<span><a class="mark" href="#util_encodings_supported_when_node_js_is_built_with_the_small_icu_option" id="util_encodings_supported_when_node_js_is_built_with_the_small_icu_option">#</a></span></h5>
 
 
 
@@ -59471,6 +64228,8 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
+<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'utf-8'</code></td><td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td></tr><tr><td><code>'utf-16le'</code></td><td><code>'utf-16'</code></td></tr><tr><td><code>'utf-16be'</code></td><td></td></tr></tbody></table>
+<h5>Encodings supported when ICU is disabled<span><a class="mark" href="#util_encodings_supported_when_icu_is_disabled" id="util_encodings_supported_when_icu_is_disabled">#</a></span></h5>
 
 
 
@@ -59488,10 +64247,10 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
-<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'ibm866'</code></td><td><code>'866'</code>, <code>'cp866'</code>, <code>'csibm866'</code></td></tr><tr><td><code>'iso-8859-2'</code></td><td><code>'csisolatin2'</code>, <code>'iso-ir-101'</code>, <code>'iso8859-2'</code>, <code>'iso88592'</code>, <code>'iso_8859-2'</code>, <code>'iso_8859-2:1987'</code>, <code>'l2'</code>, <code>'latin2'</code></td></tr><tr><td><code>'iso-8859-3'</code></td><td><code>'csisolatin3'</code>, <code>'iso-ir-109'</code>, <code>'iso8859-3'</code>, <code>'iso88593'</code>, <code>'iso_8859-3'</code>, <code>'iso_8859-3:1988'</code>, <code>'l3'</code>, <code>'latin3'</code></td></tr><tr><td><code>'iso-8859-4'</code></td><td><code>'csisolatin4'</code>, <code>'iso-ir-110'</code>, <code>'iso8859-4'</code>, <code>'iso88594'</code>, <code>'iso_8859-4'</code>, <code>'iso_8859-4:1988'</code>, <code>'l4'</code>, <code>'latin4'</code></td></tr><tr><td><code>'iso-8859-5'</code></td><td><code>'csisolatincyrillic'</code>, <code>'cyrillic'</code>, <code>'iso-ir-144'</code>, <code>'iso8859-5'</code>, <code>'iso88595'</code>, <code>'iso_8859-5'</code>, <code>'iso_8859-5:1988'</code></td></tr><tr><td><code>'iso-8859-6'</code></td><td><code>'arabic'</code>, <code>'asmo-708'</code>, <code>'csiso88596e'</code>, <code>'csiso88596i'</code>, <code>'csisolatinarabic'</code>, <code>'ecma-114'</code>, <code>'iso-8859-6-e'</code>, <code>'iso-8859-6-i'</code>, <code>'iso-ir-127'</code>, <code>'iso8859-6'</code>, <code>'iso88596'</code>, <code>'iso_8859-6'</code>, <code>'iso_8859-6:1987'</code></td></tr><tr><td><code>'iso-8859-7'</code></td><td><code>'csisolatingreek'</code>, <code>'ecma-118'</code>, <code>'elot_928'</code>, <code>'greek'</code>, <code>'greek8'</code>, <code>'iso-ir-126'</code>, <code>'iso8859-7'</code>, <code>'iso88597'</code>, <code>'iso_8859-7'</code>, <code>'iso_8859-7:1987'</code>, <code>'sun_eu_greek'</code></td></tr><tr><td><code>'iso-8859-8'</code></td><td><code>'csiso88598e'</code>, <code>'csisolatinhebrew'</code>, <code>'hebrew'</code>, <code>'iso-8859-8-e'</code>, <code>'iso-ir-138'</code>, <code>'iso8859-8'</code>, <code>'iso88598'</code>, <code>'iso_8859-8'</code>, <code>'iso_8859-8:1988'</code>, <code>'visual'</code></td></tr><tr><td><code>'iso-8859-8-i'</code></td><td><code>'csiso88598i'</code>, <code>'logical'</code></td></tr><tr><td><code>'iso-8859-10'</code></td><td><code>'csisolatin6'</code>, <code>'iso-ir-157'</code>, <code>'iso8859-10'</code>, <code>'iso885910'</code>, <code>'l6'</code>, <code>'latin6'</code></td></tr><tr><td><code>'iso-8859-13'</code></td><td><code>'iso8859-13'</code>, <code>'iso885913'</code></td></tr><tr><td><code>'iso-8859-14'</code></td><td><code>'iso8859-14'</code>, <code>'iso885914'</code></td></tr><tr><td><code>'iso-8859-15'</code></td><td><code>'csisolatin9'</code>, <code>'iso8859-15'</code>, <code>'iso885915'</code>, <code>'iso_8859-15'</code>, <code>'l9'</code></td></tr><tr><td><code>'koi8-r'</code></td><td><code>'cskoi8r'</code>, <code>'koi'</code>, <code>'koi8'</code>, <code>'koi8_r'</code></td></tr><tr><td><code>'koi8-u'</code></td><td><code>'koi8-ru'</code></td></tr><tr><td><code>'macintosh'</code></td><td><code>'csmacintosh'</code>, <code>'mac'</code>, <code>'x-mac-roman'</code></td></tr><tr><td><code>'windows-874'</code></td><td><code>'dos-874'</code>, <code>'iso-8859-11'</code>, <code>'iso8859-11'</code>, <code>'iso885911'</code>, <code>'tis-620'</code></td></tr><tr><td><code>'windows-1250'</code></td><td><code>'cp1250'</code>, <code>'x-cp1250'</code></td></tr><tr><td><code>'windows-1251'</code></td><td><code>'cp1251'</code>, <code>'x-cp1251'</code></td></tr><tr><td><code>'windows-1252'</code></td><td><code>'ansi_x3.4-1968'</code>, <code>'ascii'</code>, <code>'cp1252'</code>, <code>'cp819'</code>, <code>'csisolatin1'</code>, <code>'ibm819'</code>, <code>'iso-8859-1'</code>, <code>'iso-ir-100'</code>, <code>'iso8859-1'</code>, <code>'iso88591'</code>, <code>'iso_8859-1'</code>, <code>'iso_8859-1:1987'</code>, <code>'l1'</code>, <code>'latin1'</code>, <code>'us-ascii'</code>, <code>'x-cp1252'</code></td></tr><tr><td><code>'windows-1253'</code></td><td><code>'cp1253'</code>, <code>'x-cp1253'</code></td></tr><tr><td><code>'windows-1254'</code></td><td><code>'cp1254'</code>, <code>'csisolatin5'</code>, <code>'iso-8859-9'</code>, <code>'iso-ir-148'</code>, <code>'iso8859-9'</code>, <code>'iso88599'</code>, <code>'iso_8859-9'</code>, <code>'iso_8859-9:1989'</code>, <code>'l5'</code>, <code>'latin5'</code>, <code>'x-cp1254'</code></td></tr><tr><td><code>'windows-1255'</code></td><td><code>'cp1255'</code>, <code>'x-cp1255'</code></td></tr><tr><td><code>'windows-1256'</code></td><td><code>'cp1256'</code>, <code>'x-cp1256'</code></td></tr><tr><td><code>'windows-1257'</code></td><td><code>'cp1257'</code>, <code>'x-cp1257'</code></td></tr><tr><td><code>'windows-1258'</code></td><td><code>'cp1258'</code>, <code>'x-cp1258'</code></td></tr><tr><td><code>'x-mac-cyrillic'</code></td><td><code>'x-mac-ukrainian'</code></td></tr><tr><td><code>'gbk'</code></td><td><code>'chinese'</code>, <code>'csgb2312'</code>, <code>'csiso58gb231280'</code>, <code>'gb2312'</code>, <code>'gb_2312'</code>, <code>'gb_2312-80'</code>, <code>'iso-ir-58'</code>, <code>'x-gbk'</code></td></tr><tr><td><code>'gb18030'</code></td><td></td></tr><tr><td><code>'big5'</code></td><td><code>'big5-hkscs'</code>, <code>'cn-big5'</code>, <code>'csbig5'</code>, <code>'x-x-big5'</code></td></tr><tr><td><code>'euc-jp'</code></td><td><code>'cseucpkdfmtjapanese'</code>, <code>'x-euc-jp'</code></td></tr><tr><td><code>'iso-2022-jp'</code></td><td><code>'csiso2022jp'</code></td></tr><tr><td><code>'shift_jis'</code></td><td><code>'csshiftjis'</code>, <code>'ms932'</code>, <code>'ms_kanji'</code>, <code>'shift-jis'</code>, <code>'sjis'</code>, <code>'windows-31j'</code>, <code>'x-sjis'</code></td></tr><tr><td><code>'euc-kr'</code></td><td><code>'cseuckr'</code>, <code>'csksc56011987'</code>, <code>'iso-ir-149'</code>, <code>'korean'</code>, <code>'ks_c_5601-1987'</code>, <code>'ks_c_5601-1989'</code>, <code>'ksc5601'</code>, <code>'ksc_5601'</code>, <code>'windows-949'</code></td></tr></tbody></table>
+<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'utf-8'</code></td><td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td></tr><tr><td><code>'utf-16le'</code></td><td><code>'utf-16'</code></td></tr></tbody></table>
 <p>The <code>'iso-8859-16'</code> encoding listed in the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a>
 is not supported.</p>
-<h3><code>new TextDecoder([encoding[, options]])</code><span><a class="mark" href="#util_new_textdecoder_encoding_options" id="util_new_textdecoder_encoding_options">#</a></span></h3>
+<h4><code>new TextDecoder([encoding[, options]])</code><span><a class="mark" href="#util_new_textdecoder_encoding_options" id="util_new_textdecoder_encoding_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -59508,9 +64267,9 @@ is not supported.</p>
 supports. <strong>Default:</strong> <code>'utf-8'</code>.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>fatal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if decoding failures are fatal. This option is only
-supported when ICU is enabled (see <a href="intl.html">Internationalization</a>). <strong>Default:</strong>
-<code>false</code>.</li>
+<li><code>fatal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if decoding failures are fatal.
+This option is not supported when ICU is disabled
+(see <a href="intl.html">Internationalization</a>). <strong>Default:</strong> <code>false</code>.</li>
 <li><code>ignoreBOM</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, the <code>TextDecoder</code> will include the byte
 order mark in the decoded result. When <code>false</code>, the byte order mark will
 be removed from the output. This option is only used when <code>encoding</code> is
@@ -59521,7 +64280,7 @@ be removed from the output. This option is only used when <code>encoding</code>
 <p>Creates an new <code>TextDecoder</code> instance. The <code>encoding</code> may specify one of the
 supported encodings or an alias.</p>
 <p>The <code>TextDecoder</code> class is also available on the global object.</p>
-<h3><code>textDecoder.decode([input[, options]])</code><span><a class="mark" href="#util_textdecoder_decode_input_options" id="util_textdecoder_decode_input_options">#</a></span></h3>
+<h4><code>textDecoder.decode([input[, options]])</code><span><a class="mark" href="#util_textdecoder_decode_input_options" id="util_textdecoder_decode_input_options">#</a></span></h4>
 <ul>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> An <code>ArrayBuffer</code>, <code>DataView</code> or
 <code>TypedArray</code> instance containing the encoded data.</li>
@@ -59538,24 +64297,24 @@ incomplete byte sequences occurring at the end of the <code>input</code> are buf
 internally and emitted after the next call to <code>textDecoder.decode()</code>.</p>
 <p>If <code>textDecoder.fatal</code> is <code>true</code>, decoding errors that occur will result in a
 <code>TypeError</code> being thrown.</p>
-<h3><code>textDecoder.encoding</code><span><a class="mark" href="#util_textdecoder_encoding" id="util_textdecoder_encoding">#</a></span></h3>
+<h4><code>textDecoder.encoding</code><span><a class="mark" href="#util_textdecoder_encoding" id="util_textdecoder_encoding">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The encoding supported by the <code>TextDecoder</code> instance.</p>
-<h3><code>textDecoder.fatal</code><span><a class="mark" href="#util_textdecoder_fatal" id="util_textdecoder_fatal">#</a></span></h3>
+<h4><code>textDecoder.fatal</code><span><a class="mark" href="#util_textdecoder_fatal" id="util_textdecoder_fatal">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>The value will be <code>true</code> if decoding errors result in a <code>TypeError</code> being
 thrown.</p>
-<h3><code>textDecoder.ignoreBOM</code><span><a class="mark" href="#util_textdecoder_ignorebom" id="util_textdecoder_ignorebom">#</a></span></h3>
+<h4><code>textDecoder.ignoreBOM</code><span><a class="mark" href="#util_textdecoder_ignorebom" id="util_textdecoder_ignorebom">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>The value will be <code>true</code> if the decoding result will include the byte order
 mark.</p>
-<h2>Class: <code>util.TextEncoder</code><span><a class="mark" href="#util_class_util_textencoder" id="util_class_util_textencoder">#</a></span></h2>
+</section><section><h3>Class: <code>util.TextEncoder</code><span><a class="mark" href="#util_class_util_textencoder" id="util_class_util_textencoder">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -59569,17 +64328,17 @@ mark.</p>
 </div>
 <p>An implementation of the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a> <code>TextEncoder</code> API. All
 instances of <code>TextEncoder</code> only support UTF-8 encoding.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> encoder = <span class="hljs-keyword">new</span> TextEncoder();
-<span class="hljs-keyword">const</span> uint8array = encoder.encode(<span class="hljs-string">'this is some data'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> encoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">TextEncoder</span>();
+<span class="hljs-keyword">const</span> uint8array = encoder.<span class="hljs-title function_">encode</span>(<span class="hljs-string">'this is some data'</span>);</code></pre>
 <p>The <code>TextEncoder</code> class is also available on the global object.</p>
-<h3><code>textEncoder.encode([input])</code><span><a class="mark" href="#util_textencoder_encode_input" id="util_textencoder_encode_input">#</a></span></h3>
+<h4><code>textEncoder.encode([input])</code><span><a class="mark" href="#util_textencoder_encode_input" id="util_textencoder_encode_input">#</a></span></h4>
 <ul>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The text to encode. <strong>Default:</strong> an empty string.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
 </ul>
 <p>UTF-8 encodes the <code>input</code> string and returns a <code>Uint8Array</code> containing the
 encoded bytes.</p>
-<h3><code>textEncoder.encodeInto(src, dest)</code><span><a class="mark" href="#util_textencoder_encodeinto_src_dest" id="util_textencoder_encodeinto_src_dest">#</a></span></h3>
+<h4><code>textEncoder.encodeInto(src, dest)</code><span><a class="mark" href="#util_textencoder_encodeinto_src_dest" id="util_textencoder_encodeinto_src_dest">#</a></span></h4>
 <ul>
 <li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The text to encode.</li>
 <li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a> The array to hold the encode result.</li>
@@ -59592,16 +64351,26 @@ encoded bytes.</p>
 </ul>
 <p>UTF-8 encodes the <code>src</code> string to the <code>dest</code> Uint8Array and returns an object
 containing the read Unicode code units and written UTF-8 bytes.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> encoder = <span class="hljs-keyword">new</span> TextEncoder();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> encoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">TextEncoder</span>();
 <span class="hljs-keyword">const</span> src = <span class="hljs-string">'this is some data'</span>;
-<span class="hljs-keyword">const</span> dest = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(<span class="hljs-number">10</span>);
-<span class="hljs-keyword">const</span> { read, written } = encoder.encodeInto(src, dest);</code></pre>
-<h3><code>textEncoder.encoding</code><span><a class="mark" href="#util_textencoder_encoding" id="util_textencoder_encoding">#</a></span></h3>
+<span class="hljs-keyword">const</span> dest = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> { read, written } = encoder.<span class="hljs-title function_">encodeInto</span>(src, dest);</code></pre>
+<h4><code>textEncoder.encoding</code><span><a class="mark" href="#util_textencoder_encoding" id="util_textencoder_encoding">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The encoding supported by the <code>TextEncoder</code> instance. Always set to <code>'utf-8'</code>.</p>
-<h2><code>util.types</code><span><a class="mark" href="#util_util_types" id="util_util_types">#</a></span></h2>
+</section><section><h3><code>util.toUSVString(string)</code><span><a class="mark" href="#util_util_tousvstring_string" id="util_util_tousvstring_string">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Returns the <code>string</code> after replacing any surrogate code points
+(or equivalently, any unpaired surrogate code units) with the
+Unicode "replacement character" U+FFFD.</p>
+</section><section><h3><code>util.types</code><span><a class="mark" href="#util_util_types" id="util_util_types">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59612,7 +64381,7 @@ their prototype), and usually have the overhead of calling into C++.</p>
 <p>The result generally does not make any guarantees about what kinds of
 properties or behavior a value exposes in JavaScript. They are primarily
 useful for addon developers who prefer to do type checking in JavaScript.</p>
-<h3><code>util.types.isAnyArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_isanyarraybuffer_value" id="util_util_types_isanyarraybuffer_value">#</a></span></h3>
+<h4><code>util.types.isAnyArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_isanyarraybuffer_value" id="util_util_types_isanyarraybuffer_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59624,9 +64393,9 @@ useful for addon developers who prefer to do type checking in JavaScript.</p>
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> instance.</p>
 <p>See also <a href="#util_util_types_isarraybuffer_value"><code>util.types.isArrayBuffer()</code></a> and
 <a href="#util_util_types_issharedarraybuffer_value"><code>util.types.isSharedArrayBuffer()</code></a>.</p>
-<pre><code class="language-js">util.types.isAnyArrayBuffer(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isAnyArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuffer());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isArrayBufferView(value)</code><span><a class="mark" href="#util_util_types_isarraybufferview_value" id="util_util_types_isarraybufferview_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isAnyArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isAnyArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">SharedArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isArrayBufferView(value)</code><span><a class="mark" href="#util_util_types_isarraybufferview_value" id="util_util_types_isarraybufferview_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59637,11 +64406,11 @@ util.types.isAnyArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuf
 <p>Returns <code>true</code> if the value is an instance of one of the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>
 views, such as typed array objects or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a>. Equivalent to
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView"><code>ArrayBuffer.isView()</code></a>.</p>
-<pre><code class="language-js">util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int8Array</span>());  <span class="hljs-comment">// true</span>
-util.types.isArrayBufferView(Buffer.from(<span class="hljs-string">'hello world'</span>)); <span class="hljs-comment">// true</span>
-util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">16</span>)));  <span class="hljs-comment">// true</span>
-util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// false</span></code></pre>
-<h3><code>util.types.isArgumentsObject(value)</code><span><a class="mark" href="#util_util_types_isargumentsobject_value" id="util_util_types_isargumentsobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBufferView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBufferView</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'hello world'</span>)); <span class="hljs-comment">// true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBufferView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">16</span>)));  <span class="hljs-comment">// true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBufferView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// false</span></code></pre>
+<h4><code>util.types.isArgumentsObject(value)</code><span><a class="mark" href="#util_util_types_isargumentsobject_value" id="util_util_types_isargumentsobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59651,10 +64420,10 @@ util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="
 </ul>
 <p>Returns <code>true</code> if the value is an <code>arguments</code> object.</p>
 <!-- eslint-disable prefer-rest-params -->
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{
-  util.types.isArgumentsObject(<span class="hljs-built_in">arguments</span>);  <span class="hljs-comment">// Returns true</span>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {
+  util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArgumentsObject</span>(<span class="hljs-variable language_">arguments</span>);  <span class="hljs-comment">// Returns true</span>
 }</code></pre>
-<h3><code>util.types.isArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_isarraybuffer_value" id="util_util_types_isarraybuffer_value">#</a></span></h3>
+<h4><code>util.types.isArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_isarraybuffer_value" id="util_util_types_isarraybuffer_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59665,9 +64434,9 @@ util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> instance.
 This does <em>not</em> include <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> instances. Usually, it is
 desirable to test for both; See <a href="#util_util_types_isanyarraybuffer_value"><code>util.types.isAnyArrayBuffer()</code></a> for that.</p>
-<pre><code class="language-js">util.types.isArrayBuffer(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuffer());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isAsyncFunction(value)</code><span><a class="mark" href="#util_util_types_isasyncfunction_value" id="util_util_types_isasyncfunction_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">SharedArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isAsyncFunction(value)</code><span><a class="mark" href="#util_util_types_isasyncfunction_value" id="util_util_types_isasyncfunction_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59679,9 +64448,9 @@ util.types.isArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuffer
 This only reports back what the JavaScript engine is seeing;
 in particular, the return value may not match the original source code if
 a transpilation tool was used.</p>
-<pre><code class="language-js">util.types.isAsyncFunction(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{});  <span class="hljs-comment">// Returns false</span>
-util.types.isAsyncFunction(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{});  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isBigInt64Array(value)</code><span><a class="mark" href="#util_util_types_isbigint64array_value" id="util_util_types_isbigint64array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isAsyncFunction</span>(<span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {});  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isAsyncFunction</span>(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {});  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isBigInt64Array(value)</code><span><a class="mark" href="#util_util_types_isbigint64array_value" id="util_util_types_isbigint64array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59690,9 +64459,9 @@ util.types.isAsyncFunction(<span class="hljs-keyword">async</span> <span class="
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a <code>BigInt64Array</code> instance.</p>
-<pre><code class="language-js">util.types.isBigInt64Array(<span class="hljs-keyword">new</span> BigInt64Array());   <span class="hljs-comment">// Returns true</span>
-util.types.isBigInt64Array(<span class="hljs-keyword">new</span> BigUint64Array());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isBigUint64Array(value)</code><span><a class="mark" href="#util_util_types_isbiguint64array_value" id="util_util_types_isbiguint64array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBigInt64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">BigInt</span>64<span class="hljs-built_in">Array</span>());   <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBigInt64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">BigUint</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isBigUint64Array(value)</code><span><a class="mark" href="#util_util_types_isbiguint64array_value" id="util_util_types_isbiguint64array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59701,9 +64470,9 @@ util.types.isBigInt64Array(<span class="hljs-keyword">new</span> BigUint64Array(
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a <code>BigUint64Array</code> instance.</p>
-<pre><code class="language-js">util.types.isBigUint64Array(<span class="hljs-keyword">new</span> BigInt64Array());   <span class="hljs-comment">// Returns false</span>
-util.types.isBigUint64Array(<span class="hljs-keyword">new</span> BigUint64Array());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isBooleanObject(value)</code><span><a class="mark" href="#util_util_types_isbooleanobject_value" id="util_util_types_isbooleanobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBigUint64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">BigInt</span>64<span class="hljs-built_in">Array</span>());   <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBigUint64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">BigUint</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isBooleanObject(value)</code><span><a class="mark" href="#util_util_types_isbooleanobject_value" id="util_util_types_isbooleanobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59713,13 +64482,13 @@ util.types.isBigUint64Array(<span class="hljs-keyword">new</span> BigUint64Array
 </ul>
 <p>Returns <code>true</code> if the value is a boolean object, e.g. created
 by <code>new Boolean()</code>.</p>
-<pre><code class="language-js">util.types.isBooleanObject(<span class="hljs-literal">false</span>);  <span class="hljs-comment">// Returns false</span>
-util.types.isBooleanObject(<span class="hljs-literal">true</span>);   <span class="hljs-comment">// Returns false</span>
-util.types.isBooleanObject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns true</span>
-util.types.isBooleanObject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">true</span>));  <span class="hljs-comment">// Returns true</span>
-util.types.isBooleanObject(<span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns false</span>
-util.types.isBooleanObject(<span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">true</span>));  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isBoxedPrimitive(value)</code><span><a class="mark" href="#util_util_types_isboxedprimitive_value" id="util_util_types_isboxedprimitive_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-literal">false</span>);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-literal">true</span>);   <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">true</span>));  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">true</span>));  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isBoxedPrimitive(value)</code><span><a class="mark" href="#util_util_types_isboxedprimitive_value" id="util_util_types_isboxedprimitive_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.11.0</span>
 </div>
@@ -59730,12 +64499,12 @@ util.types.isBooleanObject(<span class="hljs-built_in">Boolean</span>(<span clas
 <p>Returns <code>true</code> if the value is any boxed primitive object, e.g. created
 by <code>new Boolean()</code>, <code>new String()</code> or <code>Object(Symbol())</code>.</p>
 <p>For example:</p>
-<pre><code class="language-js">util.types.isBoxedPrimitive(<span class="hljs-literal">false</span>); <span class="hljs-comment">// Returns false</span>
-util.types.isBoxedPrimitive(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns true</span>
-util.types.isBoxedPrimitive(<span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// Returns false</span>
-util.types.isBoxedPrimitive(<span class="hljs-built_in">Object</span>(<span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'foo'</span>))); <span class="hljs-comment">// Returns true</span>
-util.types.isBoxedPrimitive(<span class="hljs-built_in">Object</span>(BigInt(<span class="hljs-number">5</span>))); <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isDataView(value)</code><span><a class="mark" href="#util_util_types_isdataview_value" id="util_util_types_isdataview_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-literal">false</span>); <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-title class_">Object</span>(<span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'foo'</span>))); <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-title class_">Object</span>(<span class="hljs-title class_">BigInt</span>(<span class="hljs-number">5</span>))); <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isDataView(value)</code><span><a class="mark" href="#util_util_types_isdataview_value" id="util_util_types_isdataview_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59744,11 +64513,11 @@ util.types.isBoxedPrimitive(<span class="hljs-built_in">Object</span>(BigInt(<sp
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">20</span>);
-util.types.isDataView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">DataView</span>(ab));  <span class="hljs-comment">// Returns true</span>
-util.types.isDataView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">20</span>);
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isDataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(ab));  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isDataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
 <p>See also <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView"><code>ArrayBuffer.isView()</code></a>.</p>
-<h3><code>util.types.isDate(value)</code><span><a class="mark" href="#util_util_types_isdate_value" id="util_util_types_isdate_value">#</a></span></h3>
+<h4><code>util.types.isDate(value)</code><span><a class="mark" href="#util_util_types_isdate_value" id="util_util_types_isdate_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59757,8 +64526,8 @@ util.types.isDataView(<span class="hljs-keyword">new</span> <span class="hljs-bu
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a> instance.</p>
-<pre><code class="language-js">util.types.isDate(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isExternal(value)</code><span><a class="mark" href="#util_util_types_isexternal_value" id="util_util_types_isexternal_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isDate</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isExternal(value)</code><span><a class="mark" href="#util_util_types_isexternal_value" id="util_util_types_isexternal_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59772,12 +64541,12 @@ raw C++ pointer (<code>void*</code>) for access from native code, and has no oth
 properties. Such objects are created either by Node.js internals or native
 addons. In JavaScript, they are <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze">frozen</a> objects with a
 <code>null</code> prototype.</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;js_native_api.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;stdlib.h></span></span>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;js_native_api.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;stdlib.h></span></span>
 napi_value result;
-<span class="hljs-function"><span class="hljs-keyword">static</span> napi_value <span class="hljs-title">MyNapi</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
-  <span class="hljs-keyword">int</span>* raw = (<span class="hljs-keyword">int</span>*) <span class="hljs-built_in">malloc</span>(<span class="hljs-number">1024</span>);
-  napi_status status = napi_create_external(env, (<span class="hljs-keyword">void</span>*) raw, <span class="hljs-literal">NULL</span>, <span class="hljs-literal">NULL</span>, &#x26;result);
+<span class="hljs-keyword">static</span> napi_value <span class="hljs-title function_">MyNapi</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
+  <span class="hljs-type">int</span>* raw = (<span class="hljs-type">int</span>*) <span class="hljs-built_in">malloc</span>(<span class="hljs-number">1024</span>);
+  napi_status status = napi_create_external(env, (<span class="hljs-type">void</span>*) raw, <span class="hljs-literal">NULL</span>, <span class="hljs-literal">NULL</span>, &#x26;result);
   <span class="hljs-keyword">if</span> (status != napi_ok) {
     napi_throw_error(env, <span class="hljs-literal">NULL</span>, <span class="hljs-string">"napi_create_external failed"</span>);
     <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
@@ -59788,13 +64557,13 @@ napi_value result;
 DECLARE_NAPI_PROPERTY(<span class="hljs-string">"myNapi"</span>, MyNapi)
 ...</code></pre>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> native = <span class="hljs-built_in">require</span>(<span class="hljs-string">'napi_addon.node'</span>);
-<span class="hljs-keyword">const</span> data = native.myNapi();
-util.types.isExternal(data); <span class="hljs-comment">// returns true</span>
-util.types.isExternal(<span class="hljs-number">0</span>); <span class="hljs-comment">// returns false</span>
-util.types.isExternal(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// returns false</span></code></pre>
+<span class="hljs-keyword">const</span> data = native.<span class="hljs-title function_">myNapi</span>();
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isExternal</span>(data); <span class="hljs-comment">// returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isExternal</span>(<span class="hljs-number">0</span>); <span class="hljs-comment">// returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isExternal</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// returns false</span></code></pre>
 <p>For further information on <code>napi_create_external</code>, refer to
 <a href="#n_api_napi_create_external"><code>napi_create_external()</code></a>.</p>
-<h3><code>util.types.isFloat32Array(value)</code><span><a class="mark" href="#util_util_types_isfloat32array_value" id="util_util_types_isfloat32array_value">#</a></span></h3>
+<h4><code>util.types.isFloat32Array(value)</code><span><a class="mark" href="#util_util_types_isfloat32array_value" id="util_util_types_isfloat32array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59803,10 +64572,10 @@ util.types.isExternal(<span class="hljs-keyword">new</span> <span class="hljs-bu
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array"><code>Float32Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isFloat32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isFloat32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float32Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isFloat32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isFloat64Array(value)</code><span><a class="mark" href="#util_util_types_isfloat64array_value" id="util_util_types_isfloat64array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>32<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isFloat64Array(value)</code><span><a class="mark" href="#util_util_types_isfloat64array_value" id="util_util_types_isfloat64array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59815,10 +64584,10 @@ util.types.isFloat32Array(<span class="hljs-keyword">new</span> <span class="hlj
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array"><code>Float64Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isFloat64Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isFloat64Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isFloat64Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isGeneratorFunction(value)</code><span><a class="mark" href="#util_util_types_isgeneratorfunction_value" id="util_util_types_isgeneratorfunction_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isGeneratorFunction(value)</code><span><a class="mark" href="#util_util_types_isgeneratorfunction_value" id="util_util_types_isgeneratorfunction_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59830,9 +64599,9 @@ util.types.isFloat64Array(<span class="hljs-keyword">new</span> <span class="hlj
 This only reports back what the JavaScript engine is seeing;
 in particular, the return value may not match the original source code if
 a transpilation tool was used.</p>
-<pre><code class="language-js">util.types.isGeneratorFunction(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{});  <span class="hljs-comment">// Returns false</span>
-util.types.isGeneratorFunction(<span class="hljs-function"><span class="hljs-keyword">function</span>* <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{});  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isGeneratorObject(value)</code><span><a class="mark" href="#util_util_types_isgeneratorobject_value" id="util_util_types_isgeneratorobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isGeneratorFunction</span>(<span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {});  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isGeneratorFunction</span>(<span class="hljs-keyword">function</span>* <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {});  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isGeneratorObject(value)</code><span><a class="mark" href="#util_util_types_isgeneratorobject_value" id="util_util_types_isgeneratorobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59845,10 +64614,10 @@ built-in generator function.
 This only reports back what the JavaScript engine is seeing;
 in particular, the return value may not match the original source code if
 a transpilation tool was used.</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span>* <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{}
-<span class="hljs-keyword">const</span> generator = foo();
-util.types.isGeneratorObject(generator);  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isInt8Array(value)</code><span><a class="mark" href="#util_util_types_isint8array_value" id="util_util_types_isint8array_value">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">function</span>* <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {}
+<span class="hljs-keyword">const</span> generator = <span class="hljs-title function_">foo</span>();
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isGeneratorObject</span>(generator);  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isInt8Array(value)</code><span><a class="mark" href="#util_util_types_isint8array_value" id="util_util_types_isint8array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59857,10 +64626,10 @@ util.types.isGeneratorObject(generator);  <span class="hljs-comment">// Returns
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int8Array"><code>Int8Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isInt8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isInt8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int8Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isInt8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isInt16Array(value)</code><span><a class="mark" href="#util_util_types_isint16array_value" id="util_util_types_isint16array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isInt16Array(value)</code><span><a class="mark" href="#util_util_types_isint16array_value" id="util_util_types_isint16array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59869,10 +64638,10 @@ util.types.isInt8Array(<span class="hljs-keyword">new</span> <span class="hljs-b
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int16Array"><code>Int16Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isInt16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isInt16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int16Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isInt16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isInt32Array(value)</code><span><a class="mark" href="#util_util_types_isint32array_value" id="util_util_types_isint32array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>16<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isInt32Array(value)</code><span><a class="mark" href="#util_util_types_isint32array_value" id="util_util_types_isint32array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59881,10 +64650,10 @@ util.types.isInt16Array(<span class="hljs-keyword">new</span> <span class="hljs-
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array"><code>Int32Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int32Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isMap(value)</code><span><a class="mark" href="#util_util_types_ismap_value" id="util_util_types_ismap_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>32<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isMap(value)</code><span><a class="mark" href="#util_util_types_ismap_value" id="util_util_types_ismap_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59893,8 +64662,8 @@ util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map"><code>Map</code></a> instance.</p>
-<pre><code class="language-js">util.types.isMap(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isMapIterator(value)</code><span><a class="mark" href="#util_util_types_ismapiterator_value" id="util_util_types_ismapiterator_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMap</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isMapIterator(value)</code><span><a class="mark" href="#util_util_types_ismapiterator_value" id="util_util_types_ismapiterator_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59904,12 +64673,12 @@ util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-
 </ul>
 <p>Returns <code>true</code> if the value is an iterator returned for a built-in
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map"><code>Map</code></a> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> map = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>();
-util.types.isMapIterator(map.keys());  <span class="hljs-comment">// Returns true</span>
-util.types.isMapIterator(map.values());  <span class="hljs-comment">// Returns true</span>
-util.types.isMapIterator(map.entries());  <span class="hljs-comment">// Returns true</span>
-util.types.isMapIterator(map[<span class="hljs-built_in">Symbol</span>.iterator]());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isModuleNamespaceObject(value)</code><span><a class="mark" href="#util_util_types_ismodulenamespaceobject_value" id="util_util_types_ismodulenamespaceobject_value">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> map = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>();
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMapIterator</span>(map.<span class="hljs-title function_">keys</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMapIterator</span>(map.<span class="hljs-title function_">values</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMapIterator</span>(map.<span class="hljs-title function_">entries</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMapIterator</span>(map[<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">iterator</span>]());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isModuleNamespaceObject(value)</code><span><a class="mark" href="#util_util_types_ismodulenamespaceobject_value" id="util_util_types_ismodulenamespaceobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59921,8 +64690,8 @@ util.types.isMapIterator(map[<span class="hljs-built_in">Symbol</span>.iterator]
 <!-- eslint-skip -->
 <pre><code class="language-js"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> ns <span class="hljs-keyword">from</span> <span class="hljs-string">'./a.js'</span>;
 
-util.types.isModuleNamespaceObject(ns);  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isNativeError(value)</code><span><a class="mark" href="#util_util_types_isnativeerror_value" id="util_util_types_isnativeerror_value">#</a></span></h3>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isModuleNamespaceObject</span>(ns);  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isNativeError(value)</code><span><a class="mark" href="#util_util_types_isnativeerror_value" id="util_util_types_isnativeerror_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59931,10 +64700,10 @@ util.types.isModuleNamespaceObject(ns);  <span class="hljs-comment">// Returns t
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is an instance of a built-in <a href="#errors_class_error"><code>Error</code></a> type.</p>
-<pre><code class="language-js">util.types.isNativeError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isNativeError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isNativeError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">RangeError</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isNumberObject(value)</code><span><a class="mark" href="#util_util_types_isnumberobject_value" id="util_util_types_isnumberobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNativeError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNativeError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNativeError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">RangeError</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isNumberObject(value)</code><span><a class="mark" href="#util_util_types_isnumberobject_value" id="util_util_types_isnumberobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59944,9 +64713,9 @@ util.types.isNativeError(<span class="hljs-keyword">new</span> <span class="hljs
 </ul>
 <p>Returns <code>true</code> if the value is a number object, e.g. created
 by <code>new Number()</code>.</p>
-<pre><code class="language-js">util.types.isNumberObject(<span class="hljs-number">0</span>);  <span class="hljs-comment">// Returns false</span>
-util.types.isNumberObject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Number</span>(<span class="hljs-number">0</span>));   <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isPromise(value)</code><span><a class="mark" href="#util_util_types_ispromise_value" id="util_util_types_ispromise_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNumberObject</span>(<span class="hljs-number">0</span>);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNumberObject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Number</span>(<span class="hljs-number">0</span>));   <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isPromise(value)</code><span><a class="mark" href="#util_util_types_ispromise_value" id="util_util_types_ispromise_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59955,8 +64724,8 @@ util.types.isNumberObject(<span class="hljs-keyword">new</span> <span class="hlj
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise"><code>Promise</code></a>.</p>
-<pre><code class="language-js">util.types.isPromise(<span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">42</span>));  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isProxy(value)</code><span><a class="mark" href="#util_util_types_isproxy_value" id="util_util_types_isproxy_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isPromise</span>(<span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">42</span>));  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isProxy(value)</code><span><a class="mark" href="#util_util_types_isproxy_value" id="util_util_types_isproxy_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59966,10 +64735,10 @@ util.types.isNumberObject(<span class="hljs-keyword">new</span> <span class="hlj
 </ul>
 <p>Returns <code>true</code> if the value is a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy"><code>Proxy</code></a> instance.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> target = {};
-<span class="hljs-keyword">const</span> proxy = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Proxy</span>(target, {});
-util.types.isProxy(target);  <span class="hljs-comment">// Returns false</span>
-util.types.isProxy(proxy);  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isRegExp(value)</code><span><a class="mark" href="#util_util_types_isregexp_value" id="util_util_types_isregexp_value">#</a></span></h3>
+<span class="hljs-keyword">const</span> proxy = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Proxy</span>(target, {});
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isProxy</span>(target);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isProxy</span>(proxy);  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isRegExp(value)</code><span><a class="mark" href="#util_util_types_isregexp_value" id="util_util_types_isregexp_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59978,9 +64747,9 @@ util.types.isProxy(proxy);  <span class="hljs-comment">// Returns true</span></c
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a regular expression object.</p>
-<pre><code class="language-js">util.types.isRegExp(<span class="hljs-regexp">/abc/</span>);  <span class="hljs-comment">// Returns true</span>
-util.types.isRegExp(<span class="hljs-keyword">new</span> <span class="hljs-built_in">RegExp</span>(<span class="hljs-string">'abc'</span>));  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isSet(value)</code><span><a class="mark" href="#util_util_types_isset_value" id="util_util_types_isset_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isRegExp</span>(<span class="hljs-regexp">/abc/</span>);  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isRegExp</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">RegExp</span>(<span class="hljs-string">'abc'</span>));  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isSet(value)</code><span><a class="mark" href="#util_util_types_isset_value" id="util_util_types_isset_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -59989,8 +64758,8 @@ util.types.isRegExp(<span class="hljs-keyword">new</span> <span class="hljs-buil
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set"><code>Set</code></a> instance.</p>
-<pre><code class="language-js">util.types.isSet(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isSetIterator(value)</code><span><a class="mark" href="#util_util_types_issetiterator_value" id="util_util_types_issetiterator_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSet</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isSetIterator(value)</code><span><a class="mark" href="#util_util_types_issetiterator_value" id="util_util_types_issetiterator_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60000,12 +64769,12 @@ util.types.isRegExp(<span class="hljs-keyword">new</span> <span class="hljs-buil
 </ul>
 <p>Returns <code>true</code> if the value is an iterator returned for a built-in
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set"><code>Set</code></a> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> set = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>();
-util.types.isSetIterator(set.keys());  <span class="hljs-comment">// Returns true</span>
-util.types.isSetIterator(set.values());  <span class="hljs-comment">// Returns true</span>
-util.types.isSetIterator(set.entries());  <span class="hljs-comment">// Returns true</span>
-util.types.isSetIterator(set[<span class="hljs-built_in">Symbol</span>.iterator]());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isSharedArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_issharedarraybuffer_value" id="util_util_types_issharedarraybuffer_value">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> set = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>();
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSetIterator</span>(set.<span class="hljs-title function_">keys</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSetIterator</span>(set.<span class="hljs-title function_">values</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSetIterator</span>(set.<span class="hljs-title function_">entries</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSetIterator</span>(set[<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">iterator</span>]());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isSharedArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_issharedarraybuffer_value" id="util_util_types_issharedarraybuffer_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60016,9 +64785,9 @@ util.types.isSetIterator(set[<span class="hljs-built_in">Symbol</span>.iterator]
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> instance.
 This does <em>not</em> include <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> instances. Usually, it is
 desirable to test for both; See <a href="#util_util_types_isanyarraybuffer_value"><code>util.types.isAnyArrayBuffer()</code></a> for that.</p>
-<pre><code class="language-js">util.types.isSharedArrayBuffer(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isSharedArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuffer());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isStringObject(value)</code><span><a class="mark" href="#util_util_types_isstringobject_value" id="util_util_types_isstringobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSharedArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSharedArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">SharedArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isStringObject(value)</code><span><a class="mark" href="#util_util_types_isstringobject_value" id="util_util_types_isstringobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60028,9 +64797,9 @@ util.types.isSharedArrayBuffer(<span class="hljs-keyword">new</span> SharedArray
 </ul>
 <p>Returns <code>true</code> if the value is a string object, e.g. created
 by <code>new String()</code>.</p>
-<pre><code class="language-js">util.types.isStringObject(<span class="hljs-string">'foo'</span>);  <span class="hljs-comment">// Returns false</span>
-util.types.isStringObject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'foo'</span>));   <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isSymbolObject(value)</code><span><a class="mark" href="#util_util_types_issymbolobject_value" id="util_util_types_issymbolobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isStringObject</span>(<span class="hljs-string">'foo'</span>);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isStringObject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(<span class="hljs-string">'foo'</span>));   <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isSymbolObject(value)</code><span><a class="mark" href="#util_util_types_issymbolobject_value" id="util_util_types_issymbolobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60040,10 +64809,10 @@ util.types.isStringObject(<span class="hljs-keyword">new</span> <span class="hlj
 </ul>
 <p>Returns <code>true</code> if the value is a symbol object, created
 by calling <code>Object()</code> on a <code>Symbol</code> primitive.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> symbol = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'foo'</span>);
-util.types.isSymbolObject(symbol);  <span class="hljs-comment">// Returns false</span>
-util.types.isSymbolObject(<span class="hljs-built_in">Object</span>(symbol));   <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isTypedArray(value)</code><span><a class="mark" href="#util_util_types_istypedarray_value" id="util_util_types_istypedarray_value">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> symbol = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'foo'</span>);
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSymbolObject</span>(symbol);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSymbolObject</span>(<span class="hljs-title class_">Object</span>(symbol));   <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isTypedArray(value)</code><span><a class="mark" href="#util_util_types_istypedarray_value" id="util_util_types_istypedarray_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60052,11 +64821,11 @@ util.types.isSymbolObject(<span class="hljs-built_in">Object</span>(symbol));
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instance.</p>
-<pre><code class="language-js">util.types.isTypedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isTypedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isTypedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isTypedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isTypedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isTypedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
 <p>See also <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView"><code>ArrayBuffer.isView()</code></a>.</p>
-<h3><code>util.types.isUint8Array(value)</code><span><a class="mark" href="#util_util_types_isuint8array_value" id="util_util_types_isuint8array_value">#</a></span></h3>
+<h4><code>util.types.isUint8Array(value)</code><span><a class="mark" href="#util_util_types_isuint8array_value" id="util_util_types_isuint8array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60065,10 +64834,10 @@ util.types.isTypedArray(<span class="hljs-keyword">new</span> <span class="hljs-
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isUint8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isUint8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isUint8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isUint8ClampedArray(value)</code><span><a class="mark" href="#util_util_types_isuint8clampedarray_value" id="util_util_types_isuint8clampedarray_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isUint8ClampedArray(value)</code><span><a class="mark" href="#util_util_types_isuint8clampedarray_value" id="util_util_types_isuint8clampedarray_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60077,10 +64846,10 @@ util.types.isUint8Array(<span class="hljs-keyword">new</span> <span class="hljs-
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray"><code>Uint8ClampedArray</code></a> instance.</p>
-<pre><code class="language-js">util.types.isUint8ClampedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isUint8ClampedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8ClampedArray</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isUint8ClampedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isUint16Array(value)</code><span><a class="mark" href="#util_util_types_isuint16array_value" id="util_util_types_isuint16array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8ClampedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8ClampedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8ClampedArray());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8ClampedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isUint16Array(value)</code><span><a class="mark" href="#util_util_types_isuint16array_value" id="util_util_types_isuint16array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60089,10 +64858,10 @@ util.types.isUint8ClampedArray(<span class="hljs-keyword">new</span> <span class
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array"><code>Uint16Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isUint16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isUint16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isUint16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isUint32Array(value)</code><span><a class="mark" href="#util_util_types_isuint32array_value" id="util_util_types_isuint32array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isUint32Array(value)</code><span><a class="mark" href="#util_util_types_isuint32array_value" id="util_util_types_isuint32array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60101,10 +64870,10 @@ util.types.isUint16Array(<span class="hljs-keyword">new</span> <span class="hljs
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array"><code>Uint32Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isWeakMap(value)</code><span><a class="mark" href="#util_util_types_isweakmap_value" id="util_util_types_isweakmap_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>32<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isWeakMap(value)</code><span><a class="mark" href="#util_util_types_isweakmap_value" id="util_util_types_isweakmap_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60113,8 +64882,8 @@ util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap"><code>WeakMap</code></a> instance.</p>
-<pre><code class="language-js">util.types.isWeakMap(<span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakMap</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isWeakSet(value)</code><span><a class="mark" href="#util_util_types_isweakset_value" id="util_util_types_isweakset_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isWeakMap</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakMap</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isWeakSet(value)</code><span><a class="mark" href="#util_util_types_isweakset_value" id="util_util_types_isweakset_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -60123,22 +64892,23 @@ util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet"><code>WeakSet</code></a> instance.</p>
-<pre><code class="language-js">util.types.isWeakSet(<span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakSet</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isWebAssemblyCompiledModule(value)</code><span><a class="mark" href="#util_util_types_iswebassemblycompiledmodule_value" id="util_util_types_iswebassemblycompiledmodule_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isWeakSet</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakSet</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isWebAssemblyCompiledModule(value)</code><span><a class="mark" href="#util_util_types_iswebassemblycompiledmodule_value" id="util_util_types_iswebassemblycompiledmodule_value">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v10.0.0</span><span>Deprecated since: v14.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="#documentation_stability_index">Stability: 0</a> - Deprecated: Use <code>value instanceof WebAssembly.Module</code> instead.</div><p></p>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module"><code>WebAssembly.Module</code></a> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = <span class="hljs-keyword">new</span> WebAssembly.Module(wasmBuffer);
-util.types.isWebAssemblyCompiledModule(<span class="hljs-built_in">module</span>);  <span class="hljs-comment">// Returns true</span></code></pre>
-<h2>Deprecated APIs<span><a class="mark" href="#util_deprecated_apis" id="util_deprecated_apis">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title class_">Module</span>(wasmBuffer);
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isWebAssemblyCompiledModule</span>(<span class="hljs-variable language_">module</span>);  <span class="hljs-comment">// Returns true</span></code></pre>
+</section><section><h3>Deprecated APIs<span><a class="mark" href="#util_deprecated_apis" id="util_deprecated_apis">#</a></span></h3>
 <p>The following APIs are deprecated and should no longer be used. Existing
 applications and modules should be updated to find alternative approaches.</p>
-<h3><code>util._extend(target, source)</code><span><a class="mark" href="#util_util_extend_target_source" id="util_util_extend_target_source">#</a></span></h3>
+<h4><code>util._extend(target, source)</code><span><a class="mark" href="#util_util_extend_target_source" id="util_util_extend_target_source">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span><span>Deprecated since: v6.0.0</span>
 </div>
@@ -60151,7 +64921,7 @@ applications and modules should be updated to find alternative approaches.</p>
 Node.js modules. The community found and used it anyway.</p>
 <p>It is deprecated and should not be used in new code. JavaScript comes with very
 similar built-in functionality through <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign"><code>Object.assign()</code></a>.</p>
-<h3><code>util.isArray(object)</code><span><a class="mark" href="#util_util_isarray_object" id="util_util_isarray_object">#</a></span></h3>
+<h4><code>util.isArray(object)</code><span><a class="mark" href="#util_util_isarray_object" id="util_util_isarray_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60164,13 +64934,13 @@ similar built-in functionality through <a href="https://developer.mozilla.org/en
 <p>Returns <code>true</code> if the given <code>object</code> is an <code>Array</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isArray([]);
+util.<span class="hljs-title function_">isArray</span>([]);
 <span class="hljs-comment">// Returns: true</span>
-util.isArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Array</span>());
+util.<span class="hljs-title function_">isArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Array</span>());
 <span class="hljs-comment">// Returns: true</span>
-util.isArray({});
+util.<span class="hljs-title function_">isArray</span>({});
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isBoolean(object)</code><span><a class="mark" href="#util_util_isboolean_object" id="util_util_isboolean_object">#</a></span></h3>
+<h4><code>util.isBoolean(object)</code><span><a class="mark" href="#util_util_isboolean_object" id="util_util_isboolean_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60182,13 +64952,13 @@ util.isArray({});
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Boolean</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isBoolean(<span class="hljs-number">1</span>);
+util.<span class="hljs-title function_">isBoolean</span>(<span class="hljs-number">1</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isBoolean(<span class="hljs-number">0</span>);
+util.<span class="hljs-title function_">isBoolean</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isBoolean(<span class="hljs-literal">false</span>);
+util.<span class="hljs-title function_">isBoolean</span>(<span class="hljs-literal">false</span>);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isBuffer(object)</code><span><a class="mark" href="#util_util_isbuffer_object" id="util_util_isbuffer_object">#</a></span></h3>
+<h4><code>util.isBuffer(object)</code><span><a class="mark" href="#util_util_isbuffer_object" id="util_util_isbuffer_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60200,13 +64970,13 @@ util.isBoolean(<span class="hljs-literal">false</span>);
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Buffer</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isBuffer({ <span class="hljs-attr">length</span>: <span class="hljs-number">0</span> });
+util.<span class="hljs-title function_">isBuffer</span>({ <span class="hljs-attr">length</span>: <span class="hljs-number">0</span> });
 <span class="hljs-comment">// Returns: false</span>
-util.isBuffer([]);
+util.<span class="hljs-title function_">isBuffer</span>([]);
 <span class="hljs-comment">// Returns: false</span>
-util.isBuffer(Buffer.from(<span class="hljs-string">'hello world'</span>));
+util.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'hello world'</span>));
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isDate(object)</code><span><a class="mark" href="#util_util_isdate_object" id="util_util_isdate_object">#</a></span></h3>
+<h4><code>util.isDate(object)</code><span><a class="mark" href="#util_util_isdate_object" id="util_util_isdate_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60218,13 +64988,13 @@ util.isBuffer(Buffer.from(<span class="hljs-string">'hello world'</span>));
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Date</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isDate(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>());
+util.<span class="hljs-title function_">isDate</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>());
 <span class="hljs-comment">// Returns: true</span>
-util.isDate(<span class="hljs-built_in">Date</span>());
+util.<span class="hljs-title function_">isDate</span>(<span class="hljs-title class_">Date</span>());
 <span class="hljs-comment">// false (without 'new' returns a String)</span>
-util.isDate({});
+util.<span class="hljs-title function_">isDate</span>({});
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isError(object)</code><span><a class="mark" href="#util_util_iserror_object" id="util_util_iserror_object">#</a></span></h3>
+<h4><code>util.isError(object)</code><span><a class="mark" href="#util_util_iserror_object" id="util_util_iserror_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60237,11 +65007,11 @@ util.isDate({});
 <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>());
+util.<span class="hljs-title function_">isError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>());
 <span class="hljs-comment">// Returns: true</span>
-util.isError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>());
+util.<span class="hljs-title function_">isError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>());
 <span class="hljs-comment">// Returns: true</span>
-util.isError({ <span class="hljs-attr">name</span>: <span class="hljs-string">'Error'</span>, <span class="hljs-attr">message</span>: <span class="hljs-string">'an error occurred'</span> });
+util.<span class="hljs-title function_">isError</span>({ <span class="hljs-attr">name</span>: <span class="hljs-string">'Error'</span>, <span class="hljs-attr">message</span>: <span class="hljs-string">'an error occurred'</span> });
 <span class="hljs-comment">// Returns: false</span></code></pre>
 <p>This method relies on <code>Object.prototype.toString()</code> behavior. It is
 possible to obtain an incorrect result when the <code>object</code> argument manipulates
@@ -60249,12 +65019,12 @@ possible to obtain an incorrect result when the <code>object</code> argument man
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 <span class="hljs-keyword">const</span> obj = { <span class="hljs-attr">name</span>: <span class="hljs-string">'Error'</span>, <span class="hljs-attr">message</span>: <span class="hljs-string">'an error occurred'</span> };
 
-util.isError(obj);
+util.<span class="hljs-title function_">isError</span>(obj);
 <span class="hljs-comment">// Returns: false</span>
-obj[<span class="hljs-built_in">Symbol</span>.toStringTag] = <span class="hljs-string">'Error'</span>;
-util.isError(obj);
+obj[<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">toStringTag</span>] = <span class="hljs-string">'Error'</span>;
+util.<span class="hljs-title function_">isError</span>(obj);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isFunction(object)</code><span><a class="mark" href="#util_util_isfunction_object" id="util_util_isfunction_object">#</a></span></h3>
+<h4><code>util.isFunction(object)</code><span><a class="mark" href="#util_util_isfunction_object" id="util_util_isfunction_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60267,16 +65037,16 @@ util.isError(obj);
 <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">Foo</span>(<span class="hljs-params"></span>) </span>{}
-<span class="hljs-keyword">const</span> Bar = <span class="hljs-function">() =></span> {};
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">Foo</span>(<span class="hljs-params"></span>) {}
+<span class="hljs-keyword">const</span> <span class="hljs-title function_">Bar</span> = (<span class="hljs-params"></span>) => {};
 
-util.isFunction({});
+util.<span class="hljs-title function_">isFunction</span>({});
 <span class="hljs-comment">// Returns: false</span>
-util.isFunction(Foo);
+util.<span class="hljs-title function_">isFunction</span>(<span class="hljs-title class_">Foo</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isFunction(Bar);
+util.<span class="hljs-title function_">isFunction</span>(<span class="hljs-title class_">Bar</span>);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isNull(object)</code><span><a class="mark" href="#util_util_isnull_object" id="util_util_isnull_object">#</a></span></h3>
+<h4><code>util.isNull(object)</code><span><a class="mark" href="#util_util_isnull_object" id="util_util_isnull_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60289,13 +65059,13 @@ util.isFunction(Bar);
 <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isNull(<span class="hljs-number">0</span>);
+util.<span class="hljs-title function_">isNull</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isNull(<span class="hljs-literal">undefined</span>);
+util.<span class="hljs-title function_">isNull</span>(<span class="hljs-literal">undefined</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isNull(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isNull</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isNullOrUndefined(object)</code><span><a class="mark" href="#util_util_isnullorundefined_object" id="util_util_isnullorundefined_object">#</a></span></h3>
+<h4><code>util.isNullOrUndefined(object)</code><span><a class="mark" href="#util_util_isnullorundefined_object" id="util_util_isnullorundefined_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60309,13 +65079,13 @@ util.isNull(<span class="hljs-literal">null</span>);
 returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isNullOrUndefined(<span class="hljs-number">0</span>);
+util.<span class="hljs-title function_">isNullOrUndefined</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isNullOrUndefined(<span class="hljs-literal">undefined</span>);
+util.<span class="hljs-title function_">isNullOrUndefined</span>(<span class="hljs-literal">undefined</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isNullOrUndefined(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isNullOrUndefined</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isNumber(object)</code><span><a class="mark" href="#util_util_isnumber_object" id="util_util_isnumber_object">#</a></span></h3>
+<h4><code>util.isNumber(object)</code><span><a class="mark" href="#util_util_isnumber_object" id="util_util_isnumber_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60327,15 +65097,15 @@ util.isNullOrUndefined(<span class="hljs-literal">null</span>);
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Number</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isNumber(<span class="hljs-literal">false</span>);
+util.<span class="hljs-title function_">isNumber</span>(<span class="hljs-literal">false</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isNumber(<span class="hljs-literal">Infinity</span>);
+util.<span class="hljs-title function_">isNumber</span>(<span class="hljs-title class_">Infinity</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isNumber(<span class="hljs-number">0</span>);
+util.<span class="hljs-title function_">isNumber</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isNumber(<span class="hljs-literal">NaN</span>);
+util.<span class="hljs-title function_">isNumber</span>(<span class="hljs-title class_">Na</span>N);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isObject(object)</code><span><a class="mark" href="#util_util_isobject_object" id="util_util_isobject_object">#</a></span></h3>
+<h4><code>util.isObject(object)</code><span><a class="mark" href="#util_util_isobject_object" id="util_util_isobject_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60350,15 +65120,15 @@ Use <code>value !== null &#x26;&#x26; typeof value === 'object'</code> instead.<
 Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isObject(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isObject</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isObject(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isObject</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isObject({});
+util.<span class="hljs-title function_">isObject</span>({});
 <span class="hljs-comment">// Returns: true</span>
-util.isObject(<span class="hljs-function">() =></span> {});
+util.<span class="hljs-title function_">isObject</span>(<span class="hljs-function">() =></span> {});
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isPrimitive(object)</code><span><a class="mark" href="#util_util_isprimitive_object" id="util_util_isprimitive_object">#</a></span></h3>
+<h4><code>util.isPrimitive(object)</code><span><a class="mark" href="#util_util_isprimitive_object" id="util_util_isprimitive_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60373,25 +65143,25 @@ instead.</div><p></p>
 <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isPrimitive(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive(<span class="hljs-string">'foo'</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive(<span class="hljs-literal">false</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-literal">false</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive(<span class="hljs-literal">undefined</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-literal">undefined</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive({});
+util.<span class="hljs-title function_">isPrimitive</span>({});
 <span class="hljs-comment">// Returns: false</span>
-util.isPrimitive(<span class="hljs-function">() =></span> {});
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-function">() =></span> {});
 <span class="hljs-comment">// Returns: false</span>
-util.isPrimitive(<span class="hljs-regexp">/^$/</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-regexp">/^$/</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isPrimitive(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>());
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>());
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isRegExp(object)</code><span><a class="mark" href="#util_util_isregexp_object" id="util_util_isregexp_object">#</a></span></h3>
+<h4><code>util.isRegExp(object)</code><span><a class="mark" href="#util_util_isregexp_object" id="util_util_isregexp_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60403,13 +65173,13 @@ util.isPrimitive(<span class="hljs-keyword">new</span> <span class="hljs-built_i
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>RegExp</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isRegExp(<span class="hljs-regexp">/some regexp/</span>);
+util.<span class="hljs-title function_">isRegExp</span>(<span class="hljs-regexp">/some regexp/</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isRegExp(<span class="hljs-keyword">new</span> <span class="hljs-built_in">RegExp</span>(<span class="hljs-string">'another regexp'</span>));
+util.<span class="hljs-title function_">isRegExp</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">RegExp</span>(<span class="hljs-string">'another regexp'</span>));
 <span class="hljs-comment">// Returns: true</span>
-util.isRegExp({});
+util.<span class="hljs-title function_">isRegExp</span>({});
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isString(object)</code><span><a class="mark" href="#util_util_isstring_object" id="util_util_isstring_object">#</a></span></h3>
+<h4><code>util.isString(object)</code><span><a class="mark" href="#util_util_isstring_object" id="util_util_isstring_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60421,15 +65191,15 @@ util.isRegExp({});
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>string</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isString(<span class="hljs-string">''</span>);
+util.<span class="hljs-title function_">isString</span>(<span class="hljs-string">''</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isString(<span class="hljs-string">'foo'</span>);
+util.<span class="hljs-title function_">isString</span>(<span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isString(<span class="hljs-built_in">String</span>(<span class="hljs-string">'foo'</span>));
+util.<span class="hljs-title function_">isString</span>(<span class="hljs-title class_">String</span>(<span class="hljs-string">'foo'</span>));
 <span class="hljs-comment">// Returns: true</span>
-util.isString(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isString</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isSymbol(object)</code><span><a class="mark" href="#util_util_issymbol_object" id="util_util_issymbol_object">#</a></span></h3>
+<h4><code>util.isSymbol(object)</code><span><a class="mark" href="#util_util_issymbol_object" id="util_util_issymbol_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60441,13 +65211,13 @@ util.isString(<span class="hljs-number">5</span>);
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Symbol</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isSymbol(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isSymbol</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isSymbol(<span class="hljs-string">'foo'</span>);
+util.<span class="hljs-title function_">isSymbol</span>(<span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isSymbol(<span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'foo'</span>));
+util.<span class="hljs-title function_">isSymbol</span>(<span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'foo'</span>));
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isUndefined(object)</code><span><a class="mark" href="#util_util_isundefined_object" id="util_util_isundefined_object">#</a></span></h3>
+<h4><code>util.isUndefined(object)</code><span><a class="mark" href="#util_util_isundefined_object" id="util_util_isundefined_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -60460,13 +65230,13 @@ util.isSymbol(<span class="hljs-built_in">Symbol</span>(<span class="hljs-string
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
 <span class="hljs-keyword">const</span> foo = <span class="hljs-literal">undefined</span>;
-util.isUndefined(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isUndefined</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isUndefined(foo);
+util.<span class="hljs-title function_">isUndefined</span>(foo);
 <span class="hljs-comment">// Returns: true</span>
-util.isUndefined(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isUndefined</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.log(string)</code><span><a class="mark" href="#util_util_log_string" id="util_util_log_string">#</a></span></h3>
+<h4><code>util.log(string)</code><span><a class="mark" href="#util_util_log_string" id="util_util_log_string">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span><span>Deprecated since: v6.0.0</span>
 </div>
@@ -60478,26 +65248,67 @@ util.isUndefined(<span class="hljs-literal">null</span>);
 timestamp.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.log(<span class="hljs-string">'Timestamped message.'</span>);</code></pre>
-<h1>V8<span><a class="mark" href="#v8_v8" id="v8_v8">#</a></span></h1>
+util.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Timestamped message.'</span>);</code></pre></section>
+        </section>
+<section><h2>V8<span><a class="mark" href="#v8_v8" id="v8_v8">#</a></span></h2>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/v8.js">lib/v8.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/v8.js">lib/v8.js</a></p>
 <p>The <code>v8</code> module exposes APIs that are specific to the version of <a href="https://developers.google.com/v8/">V8</a>
 built into the Node.js binary. It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> v8 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'v8'</span>);</code></pre>
-<p>The APIs and implementation are subject to change at any time.</p>
-<h2><code>v8.cachedDataVersionTag()</code><span><a class="mark" href="#v8_v8_cacheddataversiontag" id="v8_v8_cacheddataversiontag">#</a></span></h2>
+<section><h3><code>v8.cachedDataVersionTag()</code><span><a class="mark" href="#v8_v8_cacheddataversiontag" id="v8_v8_cacheddataversiontag">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Returns an integer representing a "version tag" derived from the V8 version,
-command line flags and detected CPU features. This is useful for determining
+<p>Returns an integer representing a version tag derived from the V8 version,
+command-line flags, and detected CPU features. This is useful for determining
 whether a <a href="#vm_new_vm_script_code_options"><code>vm.Script</code></a> <code>cachedData</code> buffer is compatible with this instance
 of V8.</p>
-<h2><code>v8.getHeapSpaceStatistics()</code><span><a class="mark" href="#v8_v8_getheapspacestatistics" id="v8_v8_getheapspacestatistics">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(v8.<span class="hljs-title function_">cachedDataVersionTag</span>()); <span class="hljs-comment">// 3947234607</span>
+<span class="hljs-comment">// The value returned by v8.cachedDataVersionTag() is derived from the V8</span>
+<span class="hljs-comment">// version, command-line flags, and detected CPU features. Test that the value</span>
+<span class="hljs-comment">// does indeed update when flags are toggled.</span>
+v8.<span class="hljs-title function_">setFlagsFromString</span>(<span class="hljs-string">'--allow_natives_syntax'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(v8.<span class="hljs-title function_">cachedDataVersionTag</span>()); <span class="hljs-comment">// 183726201</span></code></pre>
+</section><section><h3><code>v8.getHeapCodeStatistics()</code><span><a class="mark" href="#v8_v8_getheapcodestatistics" id="v8_v8_getheapcodestatistics">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v12.8.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+</ul>
+<p>Returns an object with the following properties:</p>
+<ul>
+<li><code>code_and_metadata_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>bytecode_and_metadata_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>external_script_source_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<!-- eslint-skip -->
+<pre><code class="language-js">{
+  <span class="hljs-attr">code_and_metadata_size</span>: <span class="hljs-number">212208</span>,
+  <span class="hljs-attr">bytecode_and_metadata_size</span>: <span class="hljs-number">161368</span>,
+  <span class="hljs-attr">external_script_source_size</span>: <span class="hljs-number">1410794</span>
+}</code></pre>
+</section><section><h3><code>v8.getHeapSnapshot()</code><span><a class="mark" href="#v8_v8_getheapsnapshot" id="v8_v8_getheapsnapshot">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v11.13.0</span>
+</div>
+<ul>
+<li>Returns: <a href="#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a> A Readable Stream containing the V8 heap snapshot</li>
+</ul>
+<p>Generates a snapshot of the current V8 heap and returns a Readable
+Stream that may be used to read the JSON serialized representation.
+This JSON stream format is intended to be used with tools such as
+Chrome DevTools. The JSON schema is undocumented and specific to the
+V8 engine. Therefore, the schema may change from one version of V8 to the next.</p>
+<pre><code class="language-js"><span class="hljs-comment">// Print heap snapshot to the console</span>
+<span class="hljs-keyword">const</span> v8 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'v8'</span>);
+<span class="hljs-keyword">const</span> stream = v8.<span class="hljs-title function_">getHeapSnapshot</span>();
+stream.<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
+</section><section><h3><code>v8.getHeapSpaceStatistics()</code><span><a class="mark" href="#v8_v8_getheapspacestatistics" id="v8_v8_getheapspacestatistics">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -60525,58 +65336,44 @@ next.</p>
 <li><code>space_available_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 <li><code>physical_space_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<pre><code class="language-json">[
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"new_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">2063872</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">951112</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">80824</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">2063872</span>
-  },
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"old_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">3090560</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">2493792</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">0</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">3090560</span>
-  },
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"code_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">1260160</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">644256</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">960</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">1260160</span>
-  },
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"map_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">1094160</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">201608</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">0</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">1094160</span>
-  },
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"large_object_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">0</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">0</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">1490980608</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">0</span>
-  }
-]</code></pre>
-<h2><code>v8.getHeapSnapshot()</code><span><a class="mark" href="#v8_v8_getheapsnapshot" id="v8_v8_getheapsnapshot">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v11.13.0</span>
-</div>
-<ul>
-<li>Returns: <a href="#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a> A Readable Stream containing the V8 heap snapshot</li>
-</ul>
-<p>Generates a snapshot of the current V8 heap and returns a Readable
-Stream that may be used to read the JSON serialized representation.
-This JSON stream format is intended to be used with tools such as
-Chrome DevTools. The JSON schema is undocumented and specific to the
-V8 engine, and may change from one version of V8 to the next.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> stream = v8.getHeapSnapshot();
-stream.pipe(process.stdout);</code></pre>
-<h2><code>v8.getHeapStatistics()</code><span><a class="mark" href="#v8_v8_getheapstatistics" id="v8_v8_getheapstatistics">#</a></span></h2>
+<pre><code class="language-json"><span class="hljs-punctuation">[</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"new_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2063872</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">951112</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">80824</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2063872</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"old_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">3090560</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2493792</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">3090560</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"code_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1260160</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">644256</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">960</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1260160</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"map_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1094160</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">201608</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1094160</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"large_object_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1490980608</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">]</span></code></pre>
+</section><section><h3><code>v8.getHeapStatistics()</code><span><a class="mark" href="#v8_v8_getheapstatistics" id="v8_v8_getheapstatistics">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -60609,7 +65406,7 @@ stream.pipe(process.stdout);</code></pre>
 </ul>
 <p><code>does_zap_garbage</code> is a 0/1 boolean, which signifies whether the
 <code>--zap_code_space</code> option is enabled or not. This makes V8 overwrite heap
-garbage with a bit pattern. The RSS footprint (resident memory set) gets bigger
+garbage with a bit pattern. The RSS footprint (resident set size) gets bigger
 because it continuously touches all heap pages and that makes them less likely
 to get swapped out by the operating system.</p>
 <p><code>number_of_native_contexts</code> The value of native_context is the number of the
@@ -60632,26 +65429,7 @@ being non-zero indicates a potential memory leak.</p>
   <span class="hljs-attr">number_of_native_contexts</span>: <span class="hljs-number">1</span>,
   <span class="hljs-attr">number_of_detached_contexts</span>: <span class="hljs-number">0</span>
 }</code></pre>
-<h2><code>v8.getHeapCodeStatistics()</code><span><a class="mark" href="#v8_v8_getheapcodestatistics" id="v8_v8_getheapcodestatistics">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.8.0</span>
-</div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
-</ul>
-<p>Returns an object with the following properties:</p>
-<ul>
-<li><code>code_and_metadata_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-<li><code>bytecode_and_metadata_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-<li><code>external_script_source_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-<!-- eslint-skip -->
-<pre><code class="language-js">{
-  <span class="hljs-attr">code_and_metadata_size</span>: <span class="hljs-number">212208</span>,
-  <span class="hljs-attr">bytecode_and_metadata_size</span>: <span class="hljs-number">161368</span>,
-  <span class="hljs-attr">external_script_source_size</span>: <span class="hljs-number">1410794</span>
-}</code></pre>
-<h2><code>v8.setFlagsFromString(flags)</code><span><a class="mark" href="#v8_v8_setflagsfromstring_flags" id="v8_v8_setflagsfromstring_flags">#</a></span></h2>
+</section><section><h3><code>v8.setFlagsFromString(flags)</code><span><a class="mark" href="#v8_v8_setflagsfromstring_flags" id="v8_v8_setflagsfromstring_flags">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v1.0.0</span>
 </div>
@@ -60659,7 +65437,7 @@ being non-zero indicates a potential memory leak.</p>
 <li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The <code>v8.setFlagsFromString()</code> method can be used to programmatically set
-V8 command line flags. This method should be used with care. Changing settings
+V8 command-line flags. This method should be used with care. Changing settings
 after the VM has started may result in unpredictable behavior, including
 crashes and data loss; or it may simply do nothing.</p>
 <p>The V8 options available for a version of Node.js may be determined by running
@@ -60667,28 +65445,28 @@ crashes and data loss; or it may simply do nothing.</p>
 <p>Usage:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Print GC events to stdout for one minute.</span>
 <span class="hljs-keyword">const</span> v8 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'v8'</span>);
-v8.setFlagsFromString(<span class="hljs-string">'--trace_gc'</span>);
-<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> { v8.setFlagsFromString(<span class="hljs-string">'--notrace_gc'</span>); }, <span class="hljs-number">60e3</span>);</code></pre>
-<h2><code>v8.takeCoverage()</code><span><a class="mark" href="#v8_v8_takecoverage" id="v8_v8_takecoverage">#</a></span></h2>
+v8.<span class="hljs-title function_">setFlagsFromString</span>(<span class="hljs-string">'--trace_gc'</span>);
+<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> { v8.<span class="hljs-title function_">setFlagsFromString</span>(<span class="hljs-string">'--notrace_gc'</span>); }, <span class="hljs-number">60e3</span>);</code></pre>
+</section><section><h3><code>v8.stopCoverage()</code><span><a class="mark" href="#v8_v8_stopcoverage" id="v8_v8_stopcoverage">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.22.0</span>
+<span>Added in: v14.18.0</span>
+</div>
+<p>The <code>v8.stopCoverage()</code> method allows the user to stop the coverage collection
+started by <a href="#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a>, so that V8 can release the execution count
+records and optimize code. This can be used in conjunction with
+<a href="#v8_v8_takecoverage"><code>v8.takeCoverage()</code></a> if the user wants to collect the coverage on demand.</p>
+</section><section><h3><code>v8.takeCoverage()</code><span><a class="mark" href="#v8_v8_takecoverage" id="v8_v8_takecoverage">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
 </div>
 <p>The <code>v8.takeCoverage()</code> method allows the user to write the coverage started by
-<a href="cli.md#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a> to disk on demand. This method can be invoked multiple
-times during the lifetime of the process, each time the execution counter will
+<a href="#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a> to disk on demand. This method can be invoked multiple
+times during the lifetime of the process. Each time the execution counter will
 be reset and a new coverage report will be written to the directory specified
-by <a href="cli.md#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a>.</p>
+by <a href="#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a>.</p>
 <p>When the process is about to exit, one last coverage will still be written to
-disk, unless <a href="#v8_v8_stopcoverage"><code>v8.stopCoverage()</code></a> is invoked before the process exits.</p>
-<h2><code>v8.stopCoverage()</code><span><a class="mark" href="#v8_v8_stopcoverage" id="v8_v8_stopcoverage">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.22.0</span>
-</div>
-<p>The <code>v8.stopCoverage()</code> method allows the user to stop the coverage collection
-started by <a href="cli.md#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a>, so that V8 can release the execution count
-records and optimize code. This can be used in conjunction with
-<code>v8.takeCoverage()</code> if the user wants to collect the coverage on demand.</p>
-<h2><code>v8.writeHeapSnapshot([filename])</code><span><a class="mark" href="#v8_v8_writeheapsnapshot_filename" id="v8_v8_writeheapsnapshot_filename">#</a></span></h2>
+disk unless <a href="#v8_v8_stopcoverage"><code>v8.stopCoverage()</code></a> is invoked before the process exits.</p>
+</section><section><h3><code>v8.writeHeapSnapshot([filename])</code><span><a class="mark" href="#v8_v8_writeheapsnapshot_filename" id="v8_v8_writeheapsnapshot_filename">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.13.0</span>
 </div>
@@ -60710,37 +65488,37 @@ engine, and may change from one version of V8 to the next.</p>
 not contain any information about the workers, and vice versa.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { writeHeapSnapshot } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'v8'</span>);
 <span class="hljs-keyword">const</span> {
-  Worker,
+  <span class="hljs-title class_">Worker</span>,
   isMainThread,
   parentPort
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename);
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
 
-  worker.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">filename</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`worker heapdump: <span class="hljs-subst">${filename}</span>`</span>);
+  worker.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">filename</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`worker heapdump: <span class="hljs-subst">${filename}</span>`</span>);
     <span class="hljs-comment">// Now get a heapdump for the main thread.</span>
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`main thread heapdump: <span class="hljs-subst">${writeHeapSnapshot()}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`main thread heapdump: <span class="hljs-subst">${writeHeapSnapshot()}</span>`</span>);
   });
 
   <span class="hljs-comment">// Tell the worker to create a heapdump.</span>
-  worker.postMessage(<span class="hljs-string">'heapdump'</span>);
+  worker.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'heapdump'</span>);
 } <span class="hljs-keyword">else</span> {
-  parentPort.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
+  parentPort.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
     <span class="hljs-keyword">if</span> (message === <span class="hljs-string">'heapdump'</span>) {
       <span class="hljs-comment">// Generate a heapdump for the worker</span>
       <span class="hljs-comment">// and return the filename to the parent.</span>
-      parentPort.postMessage(writeHeapSnapshot());
+      parentPort.<span class="hljs-title function_">postMessage</span>(<span class="hljs-title function_">writeHeapSnapshot</span>());
     }
   });
 }</code></pre>
-<h2>Serialization API<span><a class="mark" href="#v8_serialization_api" id="v8_serialization_api">#</a></span></h2>
+</section><section><h3>Serialization API<span><a class="mark" href="#v8_serialization_api" id="v8_serialization_api">#</a></span></h3>
 <p>The serialization API provides means of serializing JavaScript values in a way
 that is compatible with the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm">HTML structured clone algorithm</a>.</p>
 <p>The format is backward-compatible (i.e. safe to store to disk).
 Equal JavaScript values may result in different serialized output.</p>
-<h3><code>v8.serialize(value)</code><span><a class="mark" href="#v8_v8_serialize_value" id="v8_v8_serialize_value">#</a></span></h3>
+<h4><code>v8.serialize(value)</code><span><a class="mark" href="#v8_v8_serialize_value" id="v8_v8_serialize_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -60749,7 +65527,7 @@ Equal JavaScript values may result in different serialized output.</p>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 <p>Uses a <a href="#v8_class_v8_defaultserializer"><code>DefaultSerializer</code></a> to serialize <code>value</code> into a buffer.</p>
-<h3><code>v8.deserialize(buffer)</code><span><a class="mark" href="#v8_v8_deserialize_buffer" id="v8_v8_deserialize_buffer">#</a></span></h3>
+<h4><code>v8.deserialize(buffer)</code><span><a class="mark" href="#v8_v8_deserialize_buffer" id="v8_v8_deserialize_buffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -60758,29 +65536,29 @@ Equal JavaScript values may result in different serialized output.</p>
 </ul>
 <p>Uses a <a href="#v8_class_v8_defaultdeserializer"><code>DefaultDeserializer</code></a> with default options to read a JS value
 from a buffer.</p>
-<h3>Class: <code>v8.Serializer</code><span><a class="mark" href="#v8_class_v8_serializer" id="v8_class_v8_serializer">#</a></span></h3>
+<h4>Class: <code>v8.Serializer</code><span><a class="mark" href="#v8_class_v8_serializer" id="v8_class_v8_serializer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
-<h4><code>new Serializer()</code><span><a class="mark" href="#v8_new_serializer" id="v8_new_serializer">#</a></span></h4>
+<h5><code>new Serializer()</code><span><a class="mark" href="#v8_new_serializer" id="v8_new_serializer">#</a></span></h5>
 <p>Creates a new <code>Serializer</code> object.</p>
-<h4><code>serializer.writeHeader()</code><span><a class="mark" href="#v8_serializer_writeheader" id="v8_serializer_writeheader">#</a></span></h4>
+<h5><code>serializer.writeHeader()</code><span><a class="mark" href="#v8_serializer_writeheader" id="v8_serializer_writeheader">#</a></span></h5>
 <p>Writes out a header, which includes the serialization format version.</p>
-<h4><code>serializer.writeValue(value)</code><span><a class="mark" href="#v8_serializer_writevalue_value" id="v8_serializer_writevalue_value">#</a></span></h4>
+<h5><code>serializer.writeValue(value)</code><span><a class="mark" href="#v8_serializer_writevalue_value" id="v8_serializer_writevalue_value">#</a></span></h5>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
 <p>Serializes a JavaScript value and adds the serialized representation to the
 internal buffer.</p>
 <p>This throws an error if <code>value</code> cannot be serialized.</p>
-<h4><code>serializer.releaseBuffer()</code><span><a class="mark" href="#v8_serializer_releasebuffer" id="v8_serializer_releasebuffer">#</a></span></h4>
+<h5><code>serializer.releaseBuffer()</code><span><a class="mark" href="#v8_serializer_releasebuffer" id="v8_serializer_releasebuffer">#</a></span></h5>
 <ul>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 <p>Returns the stored internal buffer. This serializer should not be used once
 the buffer is released. Calling this method results in undefined behavior
 if a previous write has failed.</p>
-<h4><code>serializer.transferArrayBuffer(id, arrayBuffer)</code><span><a class="mark" href="#v8_serializer_transferarraybuffer_id_arraybuffer" id="v8_serializer_transferarraybuffer_id_arraybuffer">#</a></span></h4>
+<h5><code>serializer.transferArrayBuffer(id, arrayBuffer)</code><span><a class="mark" href="#v8_serializer_transferarraybuffer_id_arraybuffer" id="v8_serializer_transferarraybuffer_id_arraybuffer">#</a></span></h5>
 <ul>
 <li><code>id</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> A 32-bit unsigned integer.</li>
 <li><code>arrayBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> An <code>ArrayBuffer</code> instance.</li>
@@ -60788,33 +65566,33 @@ if a previous write has failed.</p>
 <p>Marks an <code>ArrayBuffer</code> as having its contents transferred out of band.
 Pass the corresponding <code>ArrayBuffer</code> in the deserializing context to
 <a href="#v8_deserializer_transferarraybuffer_id_arraybuffer"><code>deserializer.transferArrayBuffer()</code></a>.</p>
-<h4><code>serializer.writeUint32(value)</code><span><a class="mark" href="#v8_serializer_writeuint32_value" id="v8_serializer_writeuint32_value">#</a></span></h4>
+<h5><code>serializer.writeUint32(value)</code><span><a class="mark" href="#v8_serializer_writeuint32_value" id="v8_serializer_writeuint32_value">#</a></span></h5>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Write a raw 32-bit unsigned integer.
 For use inside of a custom <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h4><code>serializer.writeUint64(hi, lo)</code><span><a class="mark" href="#v8_serializer_writeuint64_hi_lo" id="v8_serializer_writeuint64_hi_lo">#</a></span></h4>
+<h5><code>serializer.writeUint64(hi, lo)</code><span><a class="mark" href="#v8_serializer_writeuint64_hi_lo" id="v8_serializer_writeuint64_hi_lo">#</a></span></h5>
 <ul>
 <li><code>hi</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>lo</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Write a raw 64-bit unsigned integer, split into high and low 32-bit parts.
 For use inside of a custom <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h4><code>serializer.writeDouble(value)</code><span><a class="mark" href="#v8_serializer_writedouble_value" id="v8_serializer_writedouble_value">#</a></span></h4>
+<h5><code>serializer.writeDouble(value)</code><span><a class="mark" href="#v8_serializer_writedouble_value" id="v8_serializer_writedouble_value">#</a></span></h5>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Write a JS <code>number</code> value.
 For use inside of a custom <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h4><code>serializer.writeRawBytes(buffer)</code><span><a class="mark" href="#v8_serializer_writerawbytes_buffer" id="v8_serializer_writerawbytes_buffer">#</a></span></h4>
+<h5><code>serializer.writeRawBytes(buffer)</code><span><a class="mark" href="#v8_serializer_writerawbytes_buffer" id="v8_serializer_writerawbytes_buffer">#</a></span></h5>
 <ul>
 <li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
 </ul>
 <p>Write raw bytes into the serializer’s internal buffer. The deserializer
 will require a way to compute the length of the buffer.
 For use inside of a custom <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h4><code>serializer._writeHostObject(object)</code><span><a class="mark" href="#v8_serializer_writehostobject_object" id="v8_serializer_writehostobject_object">#</a></span></h4>
+<h5><code>serializer._writeHostObject(object)</code><span><a class="mark" href="#v8_serializer_writehostobject_object" id="v8_serializer_writehostobject_object">#</a></span></h5>
 <ul>
 <li><code>object</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
@@ -60823,7 +65601,7 @@ by native C++ bindings. If it is not possible to serialize <code>object</code>,
 exception should be thrown.</p>
 <p>This method is not present on the <code>Serializer</code> class itself but can be provided
 by subclasses.</p>
-<h4><code>serializer._getDataCloneError(message)</code><span><a class="mark" href="#v8_serializer_getdatacloneerror_message" id="v8_serializer_getdatacloneerror_message">#</a></span></h4>
+<h5><code>serializer._getDataCloneError(message)</code><span><a class="mark" href="#v8_serializer_getdatacloneerror_message" id="v8_serializer_getdatacloneerror_message">#</a></span></h5>
 <ul>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -60831,7 +65609,7 @@ by subclasses.</p>
 object can not be cloned.</p>
 <p>This method defaults to the <a href="#errors_class_error"><code>Error</code></a> constructor and can be overridden on
 subclasses.</p>
-<h4><code>serializer._getSharedArrayBufferId(sharedArrayBuffer)</code><span><a class="mark" href="#v8_serializer_getsharedarraybufferid_sharedarraybuffer" id="v8_serializer_getsharedarraybufferid_sharedarraybuffer">#</a></span></h4>
+<h5><code>serializer._getSharedArrayBufferId(sharedArrayBuffer)</code><span><a class="mark" href="#v8_serializer_getsharedarraybufferid_sharedarraybuffer" id="v8_serializer_getsharedarraybufferid_sharedarraybuffer">#</a></span></h5>
 <ul>
 <li><code>sharedArrayBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer" class="type">&#x3C;SharedArrayBuffer></a></li>
 </ul>
@@ -60843,29 +65621,29 @@ serialized. When deserializing, this ID will be passed to
 <p>If the object cannot be serialized, an exception should be thrown.</p>
 <p>This method is not present on the <code>Serializer</code> class itself but can be provided
 by subclasses.</p>
-<h4><code>serializer._setTreatArrayBufferViewsAsHostObjects(flag)</code><span><a class="mark" href="#v8_serializer_settreatarraybufferviewsashostobjects_flag" id="v8_serializer_settreatarraybufferviewsashostobjects_flag">#</a></span></h4>
+<h5><code>serializer._setTreatArrayBufferViewsAsHostObjects(flag)</code><span><a class="mark" href="#v8_serializer_settreatarraybufferviewsashostobjects_flag" id="v8_serializer_settreatarraybufferviewsashostobjects_flag">#</a></span></h5>
 <ul>
 <li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
 </ul>
 <p>Indicate whether to treat <code>TypedArray</code> and <code>DataView</code> objects as
 host objects, i.e. pass them to <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h3>Class: <code>v8.Deserializer</code><span><a class="mark" href="#v8_class_v8_deserializer" id="v8_class_v8_deserializer">#</a></span></h3>
+<h4>Class: <code>v8.Deserializer</code><span><a class="mark" href="#v8_class_v8_deserializer" id="v8_class_v8_deserializer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
-<h4><code>new Deserializer(buffer)</code><span><a class="mark" href="#v8_new_deserializer_buffer" id="v8_new_deserializer_buffer">#</a></span></h4>
+<h5><code>new Deserializer(buffer)</code><span><a class="mark" href="#v8_new_deserializer_buffer" id="v8_new_deserializer_buffer">#</a></span></h5>
 <ul>
 <li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A buffer returned by
 <a href="#v8_serializer_releasebuffer"><code>serializer.releaseBuffer()</code></a>.</li>
 </ul>
 <p>Creates a new <code>Deserializer</code> object.</p>
-<h4><code>deserializer.readHeader()</code><span><a class="mark" href="#v8_deserializer_readheader" id="v8_deserializer_readheader">#</a></span></h4>
+<h5><code>deserializer.readHeader()</code><span><a class="mark" href="#v8_deserializer_readheader" id="v8_deserializer_readheader">#</a></span></h5>
 <p>Reads and validates a header (including the format version).
 May, for example, reject an invalid or unsupported wire format. In that case,
 an <code>Error</code> is thrown.</p>
-<h4><code>deserializer.readValue()</code><span><a class="mark" href="#v8_deserializer_readvalue" id="v8_deserializer_readvalue">#</a></span></h4>
+<h5><code>deserializer.readValue()</code><span><a class="mark" href="#v8_deserializer_readvalue" id="v8_deserializer_readvalue">#</a></span></h5>
 <p>Deserializes a JavaScript value from the buffer and returns it.</p>
-<h4><code>deserializer.transferArrayBuffer(id, arrayBuffer)</code><span><a class="mark" href="#v8_deserializer_transferarraybuffer_id_arraybuffer" id="v8_deserializer_transferarraybuffer_id_arraybuffer">#</a></span></h4>
+<h5><code>deserializer.transferArrayBuffer(id, arrayBuffer)</code><span><a class="mark" href="#v8_deserializer_transferarraybuffer_id_arraybuffer" id="v8_deserializer_transferarraybuffer_id_arraybuffer">#</a></span></h5>
 <ul>
 <li><code>id</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> A 32-bit unsigned integer.</li>
 <li><code>arrayBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer" class="type">&#x3C;SharedArrayBuffer></a> An <code>ArrayBuffer</code> instance.</li>
@@ -60874,33 +65652,33 @@ an <code>Error</code> is thrown.</p>
 Pass the corresponding <code>ArrayBuffer</code> in the serializing context to
 <a href="#v8_serializer_transferarraybuffer_id_arraybuffer"><code>serializer.transferArrayBuffer()</code></a> (or return the <code>id</code> from
 <a href="#v8_serializer_getsharedarraybufferid_sharedarraybuffer"><code>serializer._getSharedArrayBufferId()</code></a> in the case of <code>SharedArrayBuffer</code>s).</p>
-<h4><code>deserializer.getWireFormatVersion()</code><span><a class="mark" href="#v8_deserializer_getwireformatversion" id="v8_deserializer_getwireformatversion">#</a></span></h4>
+<h5><code>deserializer.getWireFormatVersion()</code><span><a class="mark" href="#v8_deserializer_getwireformatversion" id="v8_deserializer_getwireformatversion">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Reads the underlying wire format version. Likely mostly to be useful to
 legacy code reading old wire format versions. May not be called before
 <code>.readHeader()</code>.</p>
-<h4><code>deserializer.readUint32()</code><span><a class="mark" href="#v8_deserializer_readuint32" id="v8_deserializer_readuint32">#</a></span></h4>
+<h5><code>deserializer.readUint32()</code><span><a class="mark" href="#v8_deserializer_readuint32" id="v8_deserializer_readuint32">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Read a raw 32-bit unsigned integer and return it.
 For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deserializer._readHostObject()</code></a>.</p>
-<h4><code>deserializer.readUint64()</code><span><a class="mark" href="#v8_deserializer_readuint64" id="v8_deserializer_readuint64">#</a></span></h4>
+<h5><code>deserializer.readUint64()</code><span><a class="mark" href="#v8_deserializer_readuint64" id="v8_deserializer_readuint64">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer[]></a></li>
 </ul>
 <p>Read a raw 64-bit unsigned integer and return it as an array <code>[hi, lo]</code>
 with two 32-bit unsigned integer entries.
 For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deserializer._readHostObject()</code></a>.</p>
-<h4><code>deserializer.readDouble()</code><span><a class="mark" href="#v8_deserializer_readdouble" id="v8_deserializer_readdouble">#</a></span></h4>
+<h5><code>deserializer.readDouble()</code><span><a class="mark" href="#v8_deserializer_readdouble" id="v8_deserializer_readdouble">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Read a JS <code>number</code> value.
 For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deserializer._readHostObject()</code></a>.</p>
-<h4><code>deserializer.readRawBytes(length)</code><span><a class="mark" href="#v8_deserializer_readrawbytes_length" id="v8_deserializer_readrawbytes_length">#</a></span></h4>
+<h5><code>deserializer.readRawBytes(length)</code><span><a class="mark" href="#v8_deserializer_readrawbytes_length" id="v8_deserializer_readrawbytes_length">#</a></span></h5>
 <ul>
 <li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
@@ -60909,30 +65687,31 @@ For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deser
 must correspond to the length of the buffer that was passed to
 <a href="#v8_serializer_writerawbytes_buffer"><code>serializer.writeRawBytes()</code></a>.
 For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deserializer._readHostObject()</code></a>.</p>
-<h4><code>deserializer._readHostObject()</code><span><a class="mark" href="#v8_deserializer_readhostobject" id="v8_deserializer_readhostobject">#</a></span></h4>
+<h5><code>deserializer._readHostObject()</code><span><a class="mark" href="#v8_deserializer_readhostobject" id="v8_deserializer_readhostobject">#</a></span></h5>
 <p>This method is called to read some kind of host object, i.e. an object that is
 created by native C++ bindings. If it is not possible to deserialize the data,
 a suitable exception should be thrown.</p>
 <p>This method is not present on the <code>Deserializer</code> class itself but can be
 provided by subclasses.</p>
-<h3>Class: <code>v8.DefaultSerializer</code><span><a class="mark" href="#v8_class_v8_defaultserializer" id="v8_class_v8_defaultserializer">#</a></span></h3>
+<h4>Class: <code>v8.DefaultSerializer</code><span><a class="mark" href="#v8_class_v8_defaultserializer" id="v8_class_v8_defaultserializer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>A subclass of <a href="#v8_class_v8_serializer"><code>Serializer</code></a> that serializes <code>TypedArray</code>
 (in particular <a href="buffer.html"><code>Buffer</code></a>) and <code>DataView</code> objects as host objects, and only
 stores the part of their underlying <code>ArrayBuffer</code>s that they are referring to.</p>
-<h3>Class: <code>v8.DefaultDeserializer</code><span><a class="mark" href="#v8_class_v8_defaultdeserializer" id="v8_class_v8_defaultdeserializer">#</a></span></h3>
+<h4>Class: <code>v8.DefaultDeserializer</code><span><a class="mark" href="#v8_class_v8_defaultdeserializer" id="v8_class_v8_defaultdeserializer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>A subclass of <a href="#v8_class_v8_deserializer"><code>Deserializer</code></a> corresponding to the format written by
-<a href="#v8_class_v8_defaultserializer"><code>DefaultSerializer</code></a>.</p>
-<h1>VM (executing JavaScript)<span><a class="mark" href="#vm_vm_executing_javascript" id="vm_vm_executing_javascript">#</a></span></h1>
+<a href="#v8_class_v8_defaultserializer"><code>DefaultSerializer</code></a>.</p></section>
+        </section>
+<section><h2>VM (executing JavaScript)<span><a class="mark" href="#vm_vm_executing_javascript" id="vm_vm_executing_javascript">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/vm.js">lib/vm.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/vm.js">lib/vm.js</a></p>
 <p>The <code>vm</code> module enables compiling and running code within V8 Virtual
 Machine contexts. <strong>The <code>vm</code> module is not a security mechanism. Do
 not use it to run untrusted code</strong>.</p>
@@ -60949,30 +65728,30 @@ code are reflected in the context object.</p>
 <span class="hljs-keyword">const</span> x = <span class="hljs-number">1</span>;
 
 <span class="hljs-keyword">const</span> context = { <span class="hljs-attr">x</span>: <span class="hljs-number">2</span> };
-vm.createContext(context); <span class="hljs-comment">// Contextify the object.</span>
+vm.<span class="hljs-title function_">createContext</span>(context); <span class="hljs-comment">// Contextify the object.</span>
 
 <span class="hljs-keyword">const</span> code = <span class="hljs-string">'x += 40; var y = 17;'</span>;
 <span class="hljs-comment">// `x` and `y` are global variables in the context.</span>
 <span class="hljs-comment">// Initially, x has the value 2 because that is the value of context.x.</span>
-vm.runInContext(code, context);
+vm.<span class="hljs-title function_">runInContext</span>(code, context);
 
-<span class="hljs-built_in">console</span>.log(context.x); <span class="hljs-comment">// 42</span>
-<span class="hljs-built_in">console</span>.log(context.y); <span class="hljs-comment">// 17</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context.<span class="hljs-property">x</span>); <span class="hljs-comment">// 42</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context.<span class="hljs-property">y</span>); <span class="hljs-comment">// 17</span>
 
-<span class="hljs-built_in">console</span>.log(x); <span class="hljs-comment">// 1; y is not defined.</span></code></pre>
-<h2>Class: <code>vm.Script</code><span><a class="mark" href="#vm_class_vm_script" id="vm_class_vm_script">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(x); <span class="hljs-comment">// 1; y is not defined.</span></code></pre>
+<section><h3>Class: <code>vm.Script</code><span><a class="mark" href="#vm_class_vm_script" id="vm_class_vm_script">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.1</span>
 </div>
 <p>Instances of the <code>vm.Script</code> class contain precompiled scripts that can be
 executed in specific contexts.</p>
-<h3><code>new vm.Script(code[, options])</code><span><a class="mark" href="#vm_new_vm_script_code_options" id="vm_new_vm_script_code_options">#</a></span></h3>
+<h4><code>new vm.Script(code[, options])</code><span><a class="mark" href="#vm_new_vm_script_code_options" id="vm_new_vm_script_code_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.6.0</td>
-<td><p>The <code>produceCachedData</code> is deprecated in favour of <code>script.createCachedData()</code></p></td></tr>
+<td><p>The <code>produceCachedData</code> is deprecated in favour of <code>script.createCachedData()</code>.</p></td></tr>
 <tr><td>v5.7.0</td>
 <td><p>The <code>cachedData</code> and <code>produceCachedData</code> options are supported now.</p></td></tr>
 <tr><td>v0.3.1</td>
@@ -60988,8 +65767,8 @@ executed in specific contexts.</p>
 by this script. <strong>Default:</strong> <code>'evalmachine.&#x3C;anonymous>'</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>cachedData</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> Provides an optional <code>Buffer</code> or
 <code>TypedArray</code>, or <code>DataView</code> with V8's code cache data for the supplied
 source. When supplied, the <code>cachedDataRejected</code> value will be set to
@@ -61005,11 +65784,11 @@ This option is <strong>deprecated</strong> in favor of <code>script.createCached
 <li><code>importModuleDynamically</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this module
 when <code>import()</code> is called. If this option is not specified, calls to
 <code>import()</code> will reject with <a href="#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code></a>.
-This option is part of the experimental modules API, and should not be
-considered stable.
+This option is part of the experimental modules API. We do not recommend
+using it in a production environment.
 <ul>
 <li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> specifier passed to <code>import()</code></li>
-<li><code>module</code> <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
+<li><code>script</code> <a href="#vm_class_vm_script" class="type">&#x3C;vm.Script></a></li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects" class="type">&#x3C;Module Namespace Object></a> | <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a> Returning a <code>vm.Module</code> is
 recommended in order to take advantage of error tracking, and to avoid
 issues with namespaces that contain <code>then</code> function exports.</li>
@@ -61022,17 +65801,17 @@ issues with namespaces that contain <code>then</code> function exports.</li>
 <p>Creating a new <code>vm.Script</code> object compiles <code>code</code> but does not run it. The
 compiled <code>vm.Script</code> can be run later multiple times. The <code>code</code> is not bound to
 any global object; rather, it is bound before each run, just for that run.</p>
-<h3><code>script.createCachedData()</code><span><a class="mark" href="#vm_script_createcacheddata" id="vm_script_createcacheddata">#</a></span></h3>
+<h4><code>script.createCachedData()</code><span><a class="mark" href="#vm_script_createcacheddata" id="vm_script_createcacheddata">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
 <ul>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Creates a code cache that can be used with the Script constructor's
-<code>cachedData</code> option. Returns a Buffer. This method may be called at any
+<p>Creates a code cache that can be used with the <code>Script</code> constructor's
+<code>cachedData</code> option. Returns a <code>Buffer</code>. This method may be called at any
 time and any number of times.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.Script(<span class="hljs-string">`
+<pre><code class="language-js"><span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">Script</span>(<span class="hljs-string">`
 function add(a, b) {
   return a + b;
 }
@@ -61040,12 +65819,12 @@ function add(a, b) {
 const x = add(1, 2);
 `</span>);
 
-<span class="hljs-keyword">const</span> cacheWithoutX = script.createCachedData();
+<span class="hljs-keyword">const</span> cacheWithoutX = script.<span class="hljs-title function_">createCachedData</span>();
 
-script.runInThisContext();
+script.<span class="hljs-title function_">runInThisContext</span>();
 
-<span class="hljs-keyword">const</span> cacheWithX = script.createCachedData();</code></pre>
-<h3><code>script.runInContext(contextifiedObject[, options])</code><span><a class="mark" href="#vm_script_runincontext_contextifiedobject_options" id="vm_script_runincontext_contextifiedobject_options">#</a></span></h3>
+<span class="hljs-keyword">const</span> cacheWithX = script.<span class="hljs-title function_">createCachedData</span>();</code></pre>
+<h4><code>script.runInContext(contextifiedObject[, options])</code><span><a class="mark" href="#vm_script_runincontext_contextifiedobject_options" id="vm_script_runincontext_contextifiedobject_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -61068,11 +65847,11 @@ to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> the result of the very last statement executed in the script.</li>
@@ -61090,23 +65869,25 @@ The globals are contained in the <code>context</code> object.</p>
   <span class="hljs-attr">count</span>: <span class="hljs-number">2</span>
 };
 
-<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.Script(<span class="hljs-string">'count += 1; name = "kitty";'</span>);
+<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">Script</span>(<span class="hljs-string">'count += 1; name = "kitty";'</span>);
 
-vm.createContext(context);
+vm.<span class="hljs-title function_">createContext</span>(context);
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">10</span>; ++i) {
-  script.runInContext(context);
+  script.<span class="hljs-title function_">runInContext</span>(context);
 }
 
-<span class="hljs-built_in">console</span>.log(context);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context);
 <span class="hljs-comment">// Prints: { animal: 'cat', count: 12, name: 'kitty' }</span></code></pre>
 <p>Using the <code>timeout</code> or <code>breakOnSigint</code> options will result in new event loops
 and corresponding threads being started, which have a non-zero performance
 overhead.</p>
-<h3><code>script.runInNewContext([contextObject[, options]])</code><span><a class="mark" href="#vm_script_runinnewcontext_contextobject_options" id="vm_script_runinnewcontext_contextobject_options">#</a></span></h3>
+<h4><code>script.runInNewContext([contextObject[, options]])</code><span><a class="mark" href="#vm_script_runinnewcontext_contextobject_options" id="vm_script_runinnewcontext_contextobject_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0</td>
+<td><p>The <code>microtaskMode</code> option is supported now.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>contextCodeGeneration</code> option is supported now.</p></td></tr>
 <tr><td>v6.3.0</td>
@@ -61127,11 +65908,11 @@ to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>contextName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Human-readable name of the newly created context.
 <strong>Default:</strong> <code>'VM Context i'</code>, where <code>i</code> is an ascending numerical index of
 the created context.</li>
@@ -61150,6 +65931,10 @@ constructors (<code>Function</code>, <code>GeneratorFunction</code>, etc) will t
 module will throw a <code>WebAssembly.CompileError</code>. <strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
+<li><code>microtaskMode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If set to <code>afterEvaluate</code>, microtasks (tasks
+scheduled through <code>Promise</code>s and <code>async function</code>s) will be run immediately
+after the script has run. They are included in the <code>timeout</code> and
+<code>breakOnSigint</code> scopes in that case.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> the result of the very last statement executed in the script.</li>
@@ -61162,16 +65947,16 @@ the code multiple times in different contexts. The globals are set on and
 contained within each individual <code>context</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.Script(<span class="hljs-string">'globalVar = "set"'</span>);
+<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">Script</span>(<span class="hljs-string">'globalVar = "set"'</span>);
 
 <span class="hljs-keyword">const</span> contexts = [{}, {}, {}];
-contexts.forEach(<span class="hljs-function">(<span class="hljs-params">context</span>) =></span> {
-  script.runInNewContext(context);
+contexts.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">context</span>) =></span> {
+  script.<span class="hljs-title function_">runInNewContext</span>(context);
 });
 
-<span class="hljs-built_in">console</span>.log(contexts);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(contexts);
 <span class="hljs-comment">// Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]</span></code></pre>
-<h3><code>script.runInThisContext([options])</code><span><a class="mark" href="#vm_script_runinthiscontext_options" id="vm_script_runinthiscontext_options">#</a></span></h3>
+<h4><code>script.runInThisContext([options])</code><span><a class="mark" href="#vm_script_runinthiscontext_options" id="vm_script_runinthiscontext_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -61192,11 +65977,11 @@ to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> the result of the very last statement executed in the script.</li>
@@ -61208,24 +65993,24 @@ current <code>global</code> object. Running code does not have access to local s
 executes that code multiple times:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-built_in">global</span>.globalVar = <span class="hljs-number">0</span>;
+<span class="hljs-variable language_">global</span>.<span class="hljs-property">globalVar</span> = <span class="hljs-number">0</span>;
 
-<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.Script(<span class="hljs-string">'globalVar += 1'</span>, { <span class="hljs-attr">filename</span>: <span class="hljs-string">'myfile.vm'</span> });
+<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">Script</span>(<span class="hljs-string">'globalVar += 1'</span>, { <span class="hljs-attr">filename</span>: <span class="hljs-string">'myfile.vm'</span> });
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000</span>; ++i) {
-  script.runInThisContext();
+  script.<span class="hljs-title function_">runInThisContext</span>();
 }
 
-<span class="hljs-built_in">console</span>.log(globalVar);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(globalVar);
 
 <span class="hljs-comment">// 1000</span></code></pre>
-<h2>Class: <code>vm.Module</code><span><a class="mark" href="#vm_class_vm_module" id="vm_class_vm_module">#</a></span></h2>
+</section><section><h3>Class: <code>vm.Module</code><span><a class="mark" href="#vm_class_vm_module" id="vm_class_vm_module">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command
-flag enabled.</em></p>
+<p>This feature is only available with the <code>--experimental-vm-modules</code> command
+flag enabled.</p>
 <p>The <code>vm.Module</code> class provides a low-level interface for using
 ECMAScript modules in VM contexts. It is the counterpart of the <code>vm.Script</code>
 class that closely mirrors <a href="https://www.ecma-international.org/ecma-262/#sec-abstract-module-records">Module Record</a>s as defined in the ECMAScript
@@ -61240,9 +66025,80 @@ example.</p>
 <p>This implementation lies at a lower level than the <a href="#esm_modules_ecmascript_modules">ECMAScript Module
 loader</a>. There is also no way to interact with the Loader yet, though
 support is planned.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-keyword">const</span> contextifiedObject = vm.createContext({ <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span> });
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> vm <span class="hljs-keyword">from</span> <span class="hljs-string">'vm'</span>;
+
+<span class="hljs-keyword">const</span> contextifiedObject = vm.<span class="hljs-title function_">createContext</span>({
+  <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span>,
+  <span class="hljs-attr">print</span>: <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>,
+});
+
+<span class="hljs-comment">// Step 1</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Create a Module by constructing a new `vm.SourceTextModule` object. This</span>
+<span class="hljs-comment">// parses the provided source text, throwing a `SyntaxError` if anything goes</span>
+<span class="hljs-comment">// wrong. By default, a Module is created in the top context. But here, we</span>
+<span class="hljs-comment">// specify `contextifiedObject` as the context this Module belongs to.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Here, we attempt to obtain the default export from the module "foo", and</span>
+<span class="hljs-comment">// put it into local binding "secret".</span>
+
+<span class="hljs-keyword">const</span> bar = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">`
+  import s from 'foo';
+  s;
+  print(s);
+`</span>, { <span class="hljs-attr">context</span>: contextifiedObject });
+
+<span class="hljs-comment">// Step 2</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// "Link" the imported dependencies of this Module to it.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// The provided linking callback (the "linker") accepts two arguments: the</span>
+<span class="hljs-comment">// parent module (`bar` in this case) and the string that is the specifier of</span>
+<span class="hljs-comment">// the imported module. The callback is expected to return a Module that</span>
+<span class="hljs-comment">// corresponds to the provided specifier, with certain requirements documented</span>
+<span class="hljs-comment">// in `module.link()`.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// If linking has not started for the returned Module, the same linker</span>
+<span class="hljs-comment">// callback will be called on the returned Module.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Even top-level Modules without dependencies must be explicitly linked. The</span>
+<span class="hljs-comment">// callback provided would never be called, however.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// The link() method returns a Promise that will be resolved when all the</span>
+<span class="hljs-comment">// Promises returned by the linker resolve.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Note: This is a contrived example in that the linker function creates a new</span>
+<span class="hljs-comment">// "foo" module every time it is called. In a full-fledged module system, a</span>
+<span class="hljs-comment">// cache would probably be used to avoid duplicated modules.</span>
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">linker</span>(<span class="hljs-params">specifier, referencingModule</span>) {
+  <span class="hljs-keyword">if</span> (specifier === <span class="hljs-string">'foo'</span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">`
+      // The "secret" variable refers to the global variable we added to
+      // "contextifiedObject" when creating the context.
+      export default secret;
+    `</span>, { <span class="hljs-attr">context</span>: referencingModule.<span class="hljs-property">context</span> });
+
+    <span class="hljs-comment">// Using `contextifiedObject` instead of `referencingModule.context`</span>
+    <span class="hljs-comment">// here would work as well.</span>
+  }
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">`Unable to resolve dependency: <span class="hljs-subst">${specifier}</span>`</span>);
+}
+<span class="hljs-keyword">await</span> bar.<span class="hljs-title function_">link</span>(linker);
+
+<span class="hljs-comment">// Step 3</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Evaluate the Module. The evaluate() method returns a promise which will</span>
+<span class="hljs-comment">// resolve after the module has finished evaluating.</span>
+
+<span class="hljs-comment">// Prints 42.</span>
+<span class="hljs-keyword">await</span> bar.evaluate();</code><code class="language-js cjs"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
+
+<span class="hljs-keyword">const</span> contextifiedObject = vm.<span class="hljs-title function_">createContext</span>({
+  <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span>,
+  <span class="hljs-attr">print</span>: <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>,
+});
 
 (<span class="hljs-keyword">async</span> () => {
   <span class="hljs-comment">// Step 1</span>
@@ -61255,9 +66111,10 @@ support is planned.</p>
   <span class="hljs-comment">// Here, we attempt to obtain the default export from the module "foo", and</span>
   <span class="hljs-comment">// put it into local binding "secret".</span>
 
-  <span class="hljs-keyword">const</span> bar = <span class="hljs-keyword">new</span> vm.SourceTextModule(<span class="hljs-string">`
+  <span class="hljs-keyword">const</span> bar = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">`
     import s from 'foo';
     s;
+    print(s);
   `</span>, { <span class="hljs-attr">context</span>: contextifiedObject });
 
   <span class="hljs-comment">// Step 2</span>
@@ -61283,35 +66140,30 @@ support is planned.</p>
   <span class="hljs-comment">// "foo" module every time it is called. In a full-fledged module system, a</span>
   <span class="hljs-comment">// cache would probably be used to avoid duplicated modules.</span>
 
-  <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">linker</span>(<span class="hljs-params">specifier, referencingModule</span>) </span>{
+  <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">linker</span>(<span class="hljs-params">specifier, referencingModule</span>) {
     <span class="hljs-keyword">if</span> (specifier === <span class="hljs-string">'foo'</span>) {
-      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> vm.SourceTextModule(<span class="hljs-string">`
+      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">`
         // The "secret" variable refers to the global variable we added to
         // "contextifiedObject" when creating the context.
         export default secret;
-      `</span>, { <span class="hljs-attr">context</span>: referencingModule.context });
+      `</span>, { <span class="hljs-attr">context</span>: referencingModule.<span class="hljs-property">context</span> });
 
       <span class="hljs-comment">// Using `contextifiedObject` instead of `referencingModule.context`</span>
       <span class="hljs-comment">// here would work as well.</span>
     }
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">`Unable to resolve dependency: <span class="hljs-subst">${specifier}</span>`</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">`Unable to resolve dependency: <span class="hljs-subst">${specifier}</span>`</span>);
   }
-  <span class="hljs-keyword">await</span> bar.link(linker);
+  <span class="hljs-keyword">await</span> bar.<span class="hljs-title function_">link</span>(linker);
 
   <span class="hljs-comment">// Step 3</span>
   <span class="hljs-comment">//</span>
-  <span class="hljs-comment">// Evaluate the Module. The evaluate() method returns a Promise with a single</span>
-  <span class="hljs-comment">// property "result" that contains the result of the very last statement</span>
-  <span class="hljs-comment">// executed in the Module. In the case of `bar`, it is `s;`, which refers to</span>
-  <span class="hljs-comment">// the default export of the `foo` module, the `secret` we set in the</span>
-  <span class="hljs-comment">// beginning to 42.</span>
+  <span class="hljs-comment">// Evaluate the Module. The evaluate() method returns a promise which will</span>
+  <span class="hljs-comment">// resolve after the module has finished evaluating.</span>
 
-  <span class="hljs-keyword">const</span> { result } = <span class="hljs-keyword">await</span> bar.evaluate();
-
-  <span class="hljs-built_in">console</span>.log(result);
   <span class="hljs-comment">// Prints 42.</span>
+  <span class="hljs-keyword">await</span> bar.evaluate();
 })();</code></pre>
-<h3><code>module.dependencySpecifiers</code><span><a class="mark" href="#vm_module_dependencyspecifiers" id="vm_module_dependencyspecifiers">#</a></span></h3>
+<h4><code>module.dependencySpecifiers</code><span><a class="mark" href="#vm_module_dependencyspecifiers" id="vm_module_dependencyspecifiers">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
@@ -61319,7 +66171,7 @@ support is planned.</p>
 to disallow any changes to it.</p>
 <p>Corresponds to the <code>[[RequestedModules]]</code> field of <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module Record</a>s in
 the ECMAScript specification.</p>
-<h3><code>module.error</code><span><a class="mark" href="#vm_module_error" id="vm_module_error">#</a></span></h3>
+<h4><code>module.error</code><span><a class="mark" href="#vm_module_error" id="vm_module_error">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
@@ -61330,45 +66182,44 @@ accessing this property will result in a thrown exception.</p>
 exception due to possible ambiguity with <code>throw undefined;</code>.</p>
 <p>Corresponds to the <code>[[EvaluationError]]</code> field of <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module Record</a>s
 in the ECMAScript specification.</p>
-<h3><code>module.evaluate([options])</code><span><a class="mark" href="#vm_module_evaluate_options" id="vm_module_evaluate_options">#</a></span></h3>
+<h4><code>module.evaluate([options])</code><span><a class="mark" href="#vm_module_evaluate_options" id="vm_module_evaluate_options">#</a></span></h4>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to evaluate
 before terminating execution. If execution is interrupted, an <a href="#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the event that have
-been attached via <code>process.on('SIGINT')</code> will be disabled during script
-execution, but will continue to work after that. If execution is
-interrupted, an <a href="#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
 <p>Evaluate the module.</p>
-<p>This must be called after the module has been linked; otherwise it will
-throw an error. It could be called also when the module has already been
-evaluated, in which case it will do one of the following two things:</p>
-<ul>
-<li>return <code>undefined</code> if the initial evaluation ended in success (<code>module.status</code>
-is <code>'evaluated'</code>)</li>
-<li>rethrow the same exception the initial evaluation threw if the initial
-evaluation ended in an error (<code>module.status</code> is <code>'errored'</code>)</li>
-</ul>
+<p>This must be called after the module has been linked; otherwise it will reject.
+It could be called also when the module has already been evaluated, in which
+case it will either do nothing if the initial evaluation ended in success
+(<code>module.status</code> is <code>'evaluated'</code>) or it will re-throw the exception that the
+initial evaluation resulted in (<code>module.status</code> is <code>'errored'</code>).</p>
 <p>This method cannot be called while the module is being evaluated
-(<code>module.status</code> is <code>'evaluating'</code>) to prevent infinite recursion.</p>
+(<code>module.status</code> is <code>'evaluating'</code>).</p>
 <p>Corresponds to the <a href="https://tc39.es/ecma262/#sec-moduleevaluation">Evaluate() concrete method</a> field of <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module
 Record</a>s in the ECMAScript specification.</p>
-<h3><code>module.link(linker)</code><span><a class="mark" href="#vm_module_link_linker" id="vm_module_link_linker">#</a></span></h3>
+<h4><code>module.identifier</code><span><a class="mark" href="#vm_module_identifier" id="vm_module_identifier">#</a></span></h4>
 <ul>
-<li>
-<p><code>linker</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></p>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>The identifier of the current module, as set in the constructor.</p>
+<h4><code>module.link(linker)</code><span><a class="mark" href="#vm_module_link_linker" id="vm_module_link_linker">#</a></span></h4>
+<ul>
+<li><code>linker</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li>
 <p><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The specifier of the requested module:</p>
-<!-- eslint-skip -->
-<pre><code class="language-js"><span class="hljs-keyword">import</span> foo <span class="hljs-keyword">from</span> <span class="hljs-string">'foo'</span>;
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> foo <span class="hljs-keyword">from</span> <span class="hljs-string">'foo'</span>;
 <span class="hljs-comment">//              ^^^^^ the module specifier</span></code></pre>
 </li>
 <li>
@@ -61379,9 +66230,7 @@ Record</a>s in the ECMAScript specification.</p>
 </li>
 </ul>
 </li>
-<li>
-<p>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></p>
-</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
 <p>Link module dependencies. This method must be called before evaluation, and
 can only be called once per module.</p>
@@ -61412,7 +66261,7 @@ that point all modules would have been fully linked already, the
 specification.</p>
 <p>Corresponds to the <a href="https://tc39.es/ecma262/#sec-moduledeclarationlinking">Link() concrete method</a> field of <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module
 Record</a>s in the ECMAScript specification.</p>
-<h3><code>module.namespace</code><span><a class="mark" href="#vm_module_namespace" id="vm_module_namespace">#</a></span></h3>
+<h4><code>module.namespace</code><span><a class="mark" href="#vm_module_namespace" id="vm_module_namespace">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
@@ -61420,7 +66269,7 @@ Record</a>s in the ECMAScript specification.</p>
 (<code>module.link()</code>) has completed.</p>
 <p>Corresponds to the <a href="https://tc39.es/ecma262/#sec-getmodulenamespace">GetModuleNamespace</a> abstract operation in the ECMAScript
 specification.</p>
-<h3><code>module.status</code><span><a class="mark" href="#vm_module_status" id="vm_module_status">#</a></span></h3>
+<h4><code>module.status</code><span><a class="mark" href="#vm_module_status" id="vm_module_status">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -61452,24 +66301,19 @@ itself or a parent module.</p>
 <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module Record</a>'s <code>[[Status]]</code> field. <code>'errored'</code> corresponds to
 <code>'evaluated'</code> in the specification, but with <code>[[EvaluationError]]</code> set to a
 value that is not <code>undefined</code>.</p>
-<h3><code>module.identifier</code><span><a class="mark" href="#vm_module_identifier" id="vm_module_identifier">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-</ul>
-<p>The identifier of the current module, as set in the constructor.</p>
-<h2>Class: <code>vm.SourceTextModule</code><span><a class="mark" href="#vm_class_vm_sourcetextmodule" id="vm_class_vm_sourcetextmodule">#</a></span></h2>
+</section><section><h3>Class: <code>vm.SourceTextModule</code><span><a class="mark" href="#vm_class_vm_sourcetextmodule" id="vm_class_vm_sourcetextmodule">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command
-flag enabled.</em></p>
+<p>This feature is only available with the <code>--experimental-vm-modules</code> command
+flag enabled.</p>
 <ul>
 <li>Extends: <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
 </ul>
 <p>The <code>vm.SourceTextModule</code> class provides the <a href="https://tc39.es/ecma262/#sec-source-text-module-records">Source Text Module Record</a> as
 defined in the ECMAScript specification.</p>
-<h3><code>new vm.SourceTextModule(code[, options])</code><span><a class="mark" href="#vm_new_vm_sourcetextmodule_code_options" id="vm_new_vm_sourcetextmodule_code_options">#</a></span></h3>
+<h4><code>new vm.SourceTextModule(code[, options])</code><span><a class="mark" href="#vm_new_vm_sourcetextmodule_code_options" id="vm_new_vm_sourcetextmodule_code_options">#</a></span></h4>
 <ul>
 <li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> JavaScript Module code to parse</li>
 <li><code>options</code>
@@ -61485,8 +66329,8 @@ source. The <code>code</code> must be the same as the module from which this
 <code>vm.createContext()</code> method, to compile and evaluate this <code>Module</code> in.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the line number offset that is displayed
 in stack traces produced by this <code>Module</code>. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the column number offset that is
-displayed in stack traces produced by this <code>Module</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this <code>Module</code>. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>initializeImportMeta</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this <code>Module</code>
 to initialize the <code>import.meta</code>.
 <ul>
@@ -61512,26 +66356,48 @@ issues with namespaces that contain <code>then</code> function exports.</li>
 <p>Properties assigned to the <code>import.meta</code> object that are objects may
 allow the module to access information outside the specified <code>context</code>. Use
 <code>vm.runInContext()</code> to create objects in a specific context.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-keyword">const</span> contextifiedObject = vm.createContext({ <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span> });
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> vm <span class="hljs-keyword">from</span> <span class="hljs-string">'vm'</span>;
 
+<span class="hljs-keyword">const</span> contextifiedObject = vm.<span class="hljs-title function_">createContext</span>({ <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span> });
+
+<span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(
+  <span class="hljs-string">'Object.getPrototypeOf(import.meta.prop).secret = secret;'</span>,
+  {
+    <span class="hljs-title function_">initializeImportMeta</span>(<span class="hljs-params">meta</span>) {
+      <span class="hljs-comment">// Note: this object is created in the top context. As such,</span>
+      <span class="hljs-comment">// Object.getPrototypeOf(import.meta.prop) points to the</span>
+      <span class="hljs-comment">// Object.prototype in the top context rather than that in</span>
+      <span class="hljs-comment">// the contextified object.</span>
+      meta.<span class="hljs-property">prop</span> = {};
+    }
+  });
+<span class="hljs-comment">// Since module has no dependencies, the linker function will never be called.</span>
+<span class="hljs-keyword">await</span> <span class="hljs-variable language_">module</span>.<span class="hljs-title function_">link</span>(<span class="hljs-function">() =></span> {});
+<span class="hljs-keyword">await</span> <span class="hljs-variable language_">module</span>.evaluate();
+
+<span class="hljs-comment">// Now, Object.prototype.secret will be equal to 42.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// To fix this problem, replace</span>
+<span class="hljs-comment">//     meta.prop = {};</span>
+<span class="hljs-comment">// above with</span>
+<span class="hljs-comment">//     meta.prop = vm.runInContext('{}', contextifiedObject);</span></code><code class="language-js cjs"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
+<span class="hljs-keyword">const</span> contextifiedObject = vm.<span class="hljs-title function_">createContext</span>({ <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span> });
 (<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = <span class="hljs-keyword">new</span> vm.SourceTextModule(
+  <span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(
     <span class="hljs-string">'Object.getPrototypeOf(import.meta.prop).secret = secret;'</span>,
     {
-      initializeImportMeta(meta) {
+      <span class="hljs-title function_">initializeImportMeta</span>(<span class="hljs-params">meta</span>) {
         <span class="hljs-comment">// Note: this object is created in the top context. As such,</span>
         <span class="hljs-comment">// Object.getPrototypeOf(import.meta.prop) points to the</span>
         <span class="hljs-comment">// Object.prototype in the top context rather than that in</span>
         <span class="hljs-comment">// the contextified object.</span>
-        meta.prop = {};
+        meta.<span class="hljs-property">prop</span> = {};
       }
     });
   <span class="hljs-comment">// Since module has no dependencies, the linker function will never be called.</span>
-  <span class="hljs-keyword">await</span> <span class="hljs-built_in">module</span>.link(<span class="hljs-function">() =></span> {});
-  <span class="hljs-keyword">await</span> <span class="hljs-built_in">module</span>.evaluate();
-
+  <span class="hljs-keyword">await</span> <span class="hljs-variable language_">module</span>.<span class="hljs-title function_">link</span>(<span class="hljs-function">() =></span> {});
+  <span class="hljs-keyword">await</span> <span class="hljs-variable language_">module</span>.evaluate();
   <span class="hljs-comment">// Now, Object.prototype.secret will be equal to 42.</span>
   <span class="hljs-comment">//</span>
   <span class="hljs-comment">// To fix this problem, replace</span>
@@ -61539,31 +66405,31 @@ allow the module to access information outside the specified <code>context</code
   <span class="hljs-comment">// above with</span>
   <span class="hljs-comment">//     meta.prop = vm.runInContext('{}', contextifiedObject);</span>
 })();</code></pre>
-<h3><code>sourceTextModule.createCachedData()</code><span><a class="mark" href="#vm_sourcetextmodule_createcacheddata" id="vm_sourcetextmodule_createcacheddata">#</a></span></h3>
+<h4><code>sourceTextModule.createCachedData()</code><span><a class="mark" href="#vm_sourcetextmodule_createcacheddata" id="vm_sourcetextmodule_createcacheddata">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0</span>
 </div>
 <ul>
 <li>Returns: <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Creates a code cache that can be used with the SourceTextModule constructor's
-<code>cachedData</code> option. Returns a Buffer. This method may be called any number
+<p>Creates a code cache that can be used with the <code>SourceTextModule</code> constructor's
+<code>cachedData</code> option. Returns a <code>Buffer</code>. This method may be called any number
 of times before the module has been evaluated.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create an initial module</span>
-<span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = <span class="hljs-keyword">new</span> vm.SourceTextModule(<span class="hljs-string">'const a = 1;'</span>);
+<span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">'const a = 1;'</span>);
 
 <span class="hljs-comment">// Create cached data from this module</span>
-<span class="hljs-keyword">const</span> cachedData = <span class="hljs-built_in">module</span>.createCachedData();
+<span class="hljs-keyword">const</span> cachedData = <span class="hljs-variable language_">module</span>.<span class="hljs-title function_">createCachedData</span>();
 
 <span class="hljs-comment">// Create a new module using the cached data. The code must be the same.</span>
-<span class="hljs-keyword">const</span> module2 = <span class="hljs-keyword">new</span> vm.SourceTextModule(<span class="hljs-string">'const a = 1;'</span>, { cachedData });</code></pre>
-<h2>Class: <code>vm.SyntheticModule</code><span><a class="mark" href="#vm_class_vm_syntheticmodule" id="vm_class_vm_syntheticmodule">#</a></span></h2>
+<span class="hljs-keyword">const</span> module2 = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">'const a = 1;'</span>, { cachedData });</code></pre>
+</section><section><h3>Class: <code>vm.SyntheticModule</code><span><a class="mark" href="#vm_class_vm_syntheticmodule" id="vm_class_vm_syntheticmodule">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command
-flag enabled.</em></p>
+<p>This feature is only available with the <code>--experimental-vm-modules</code> command
+flag enabled.</p>
 <ul>
 <li>Extends: <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
 </ul>
@@ -61574,24 +66440,26 @@ module graphs.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
 <span class="hljs-keyword">const</span> source = <span class="hljs-string">'{ "a": 1 }'</span>;
-<span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = <span class="hljs-keyword">new</span> vm.SyntheticModule([<span class="hljs-string">'default'</span>], <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> obj = <span class="hljs-built_in">JSON</span>.parse(source);
-  <span class="hljs-built_in">this</span>.setExport(<span class="hljs-string">'default'</span>, obj);
+<span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SyntheticModule</span>([<span class="hljs-string">'default'</span>], <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> obj = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(source);
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">setExport</span>(<span class="hljs-string">'default'</span>, obj);
 });
 
 <span class="hljs-comment">// Use `module` in linking...</span></code></pre>
-<h3><code>new vm.SyntheticModule(exportNames, evaluateCallback[, options])</code><span><a class="mark" href="#vm_new_vm_syntheticmodule_exportnames_evaluatecallback_options" id="vm_new_vm_syntheticmodule_exportnames_evaluatecallback_options">#</a></span></h3>
+<h4><code>new vm.SyntheticModule(exportNames, evaluateCallback[, options])</code><span><a class="mark" href="#vm_new_vm_syntheticmodule_exportnames_evaluatecallback_options" id="vm_new_vm_syntheticmodule_exportnames_evaluatecallback_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>exportNames</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> Array of names that will be exported from the module.</li>
 <li><code>evaluateCallback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called when the module is evaluated.</li>
 <li><code>options</code>
 <ul>
-<li><code>identifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> String used in stack traces.
+<li><code>identifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> String used in stack traces.</li>
+</ul>
 <strong>Default:</strong> <code>'vm:module(i)'</code> where <code>i</code> is a context-specific ascending
-index.</li>
+index.
+<ul>
 <li><code>context</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified</a> object as returned by the
 <code>vm.createContext()</code> method, to compile and evaluate this <code>Module</code> in.</li>
 </ul>
@@ -61601,9 +66469,9 @@ index.</li>
 <p>Objects assigned to the exports of this instance may allow importers of
 the module to access information outside the specified <code>context</code>. Use
 <code>vm.runInContext()</code> to create objects in a specific context.</p>
-<h3><code>syntheticModule.setExport(name, value)</code><span><a class="mark" href="#vm_syntheticmodule_setexport_name_value" id="vm_syntheticmodule_setexport_name_value">#</a></span></h3>
+<h4><code>syntheticModule.setExport(name, value)</code><span><a class="mark" href="#vm_syntheticmodule_setexport_name_value" id="vm_syntheticmodule_setexport_name_value">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Name of the export to set.</li>
@@ -61612,21 +66480,38 @@ the module to access information outside the specified <code>context</code>. Use
 <p>This method is used after the module is linked to set the values of exports. If
 it is called before the module is linked, an <a href="#ERR_VM_MODULE_STATUS"><code>ERR_VM_MODULE_STATUS</code></a> error
 will be thrown.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> vm <span class="hljs-keyword">from</span> <span class="hljs-string">'vm'</span>;
+
+<span class="hljs-keyword">const</span> m = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SyntheticModule</span>([<span class="hljs-string">'x'</span>], <span class="hljs-function">() =></span> {
+  m.<span class="hljs-title function_">setExport</span>(<span class="hljs-string">'x'</span>, <span class="hljs-number">1</span>);
+});
+
+<span class="hljs-keyword">await</span> m.<span class="hljs-title function_">link</span>(<span class="hljs-function">() =></span> {});
+<span class="hljs-keyword">await</span> m.evaluate();
+
+assert.<span class="hljs-title function_">strictEqual</span>(m.<span class="hljs-property">namespace</span>.<span class="hljs-property">x</span>, <span class="hljs-number">1</span>);</code><code class="language-js cjs"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 (<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> m = <span class="hljs-keyword">new</span> vm.SyntheticModule([<span class="hljs-string">'x'</span>], <span class="hljs-function">() =></span> {
-    m.setExport(<span class="hljs-string">'x'</span>, <span class="hljs-number">1</span>);
+  <span class="hljs-keyword">const</span> m = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SyntheticModule</span>([<span class="hljs-string">'x'</span>], <span class="hljs-function">() =></span> {
+    m.<span class="hljs-title function_">setExport</span>(<span class="hljs-string">'x'</span>, <span class="hljs-number">1</span>);
   });
-
-  <span class="hljs-keyword">await</span> m.link(<span class="hljs-function">() =></span> {});
+  <span class="hljs-keyword">await</span> m.<span class="hljs-title function_">link</span>(<span class="hljs-function">() =></span> {});
   <span class="hljs-keyword">await</span> m.evaluate();
-
-  assert.strictEqual(m.namespace.x, <span class="hljs-number">1</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(m.<span class="hljs-property">namespace</span>.<span class="hljs-property">x</span>, <span class="hljs-number">1</span>);
 })();</code></pre>
-<h2><code>vm.compileFunction(code[, params[, options]])</code><span><a class="mark" href="#vm_vm_compilefunction_code_params_options" id="vm_vm_compilefunction_code_params_options">#</a></span></h2>
+</section><section><h3><code>vm.compileFunction(code[, params[, options]])</code><span><a class="mark" href="#vm_vm_compilefunction_code_params_options" id="vm_vm_compilefunction_code_params_options">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.3.0</td>
+<td><p>Removal of <code>importModuleDynamically</code> due to compatibility issues.</p></td></tr>
+<tr><td>v14.1.0, v13.14.0</td>
+<td><p>The <code>importModuleDynamically</code> option is now supported.</p></td></tr>
+<tr><td>v10.10.0</td>
+<td><p><span>Added in: v10.10.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The body of the function to compile.</li>
@@ -61638,8 +66523,8 @@ function.</li>
 by this script. <strong>Default:</strong> <code>''</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>cachedData</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> Provides an optional <code>Buffer</code> or
 <code>TypedArray</code>, or <code>DataView</code> with V8's code cache data for the supplied
 source.</li>
@@ -61657,11 +66542,13 @@ compiling. <strong>Default:</strong> <code>[]</code>.</li>
 <p>Compiles the given code into the provided context (if no context is
 supplied, the current context is used), and returns it wrapped inside a
 function with the given <code>params</code>.</p>
-<h2><code>vm.createContext([contextObject[, options]])</code><span><a class="mark" href="#vm_vm_createcontext_contextobject_options" id="vm_vm_createcontext_contextobject_options">#</a></span></h2>
+</section><section><h3><code>vm.createContext([contextObject[, options]])</code><span><a class="mark" href="#vm_vm_createcontext_contextobject_options" id="vm_vm_createcontext_contextobject_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0</td>
+<td><p>The <code>microtaskMode</code> option is supported now.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The first argument can no longer be a function.</p></td></tr>
 <tr><td>v10.0.0</td>
@@ -61693,6 +66580,10 @@ constructors (<code>Function</code>, <code>GeneratorFunction</code>, etc) will t
 module will throw a <code>WebAssembly.CompileError</code>. <strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
+<li><code>microtaskMode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If set to <code>afterEvaluate</code>, microtasks (tasks
+scheduled through <code>Promise</code>s and <code>async function</code>s) will be run immediately
+after a script has run through <a href="#vm_script_runincontext_contextifiedobject_options"><code>script.runInContext()</code></a>.
+They are included in the <code>timeout</code> and <code>breakOnSigint</code> scopes in that case.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> contextified object.</li>
@@ -61706,17 +66597,17 @@ properties but also having the built-in objects and functions any standard
 will remain unchanged.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-built_in">global</span>.globalVar = <span class="hljs-number">3</span>;
+<span class="hljs-variable language_">global</span>.<span class="hljs-property">globalVar</span> = <span class="hljs-number">3</span>;
 
 <span class="hljs-keyword">const</span> context = { <span class="hljs-attr">globalVar</span>: <span class="hljs-number">1</span> };
-vm.createContext(context);
+vm.<span class="hljs-title function_">createContext</span>(context);
 
-vm.runInContext(<span class="hljs-string">'globalVar *= 2;'</span>, context);
+vm.<span class="hljs-title function_">runInContext</span>(<span class="hljs-string">'globalVar *= 2;'</span>, context);
 
-<span class="hljs-built_in">console</span>.log(context);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context);
 <span class="hljs-comment">// Prints: { globalVar: 2 }</span>
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">global</span>.globalVar);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable language_">global</span>.<span class="hljs-property">globalVar</span>);
 <span class="hljs-comment">// Prints: 3</span></code></pre>
 <p>If <code>contextObject</code> is omitted (or passed explicitly as <code>undefined</code>), a new,
 empty <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified</a> object will be returned.</p>
@@ -61727,7 +66618,7 @@ window's global object, then run all <code>&#x3C;script></code> tags together wi
 context.</p>
 <p>The provided <code>name</code> and <code>origin</code> of the context are made visible through the
 Inspector API.</p>
-<h2><code>vm.isContext(object)</code><span><a class="mark" href="#vm_vm_iscontext_object" id="vm_vm_iscontext_object">#</a></span></h2>
+</section><section><h3><code>vm.isContext(object)</code><span><a class="mark" href="#vm_vm_iscontext_object" id="vm_vm_iscontext_object">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.7</span>
 </div>
@@ -61735,9 +66626,80 @@ Inspector API.</p>
 <li><code>object</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Returns <code>true</code> if the given <code>oject</code> object has been <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified</a> using
+<p>Returns <code>true</code> if the given <code>object</code> object has been <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified</a> using
 <a href="#vm_vm_createcontext_contextobject_options"><code>vm.createContext()</code></a>.</p>
-<h2><code>vm.runInContext(code, contextifiedObject[, options])</code><span><a class="mark" href="#vm_vm_runincontext_code_contextifiedobject_options" id="vm_vm_runincontext_code_contextifiedobject_options">#</a></span></h2>
+</section><section><h3><code>vm.measureMemory([options])</code><span><a class="mark" href="#vm_vm_measurememory_options" id="vm_vm_measurememory_options">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v13.10.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>Measure the memory known to V8 and used by all contexts known to the
+current V8 isolate, or the main context.</p>
+<ul>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Optional.
+<ul>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'summary'</code> or <code>'detailed'</code>. In summary mode,
+only the memory measured for the main context will be returned. In
+detailed mode, the measure measured for all contexts known to the
+current V8 isolate will be returned.
+<strong>Default:</strong> <code>'summary'</code></li>
+<li><code>execution</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'default'</code> or <code>'eager'</code>. With default
+execution, the promise will not resolve until after the next scheduled
+garbage collection starts, which may take a while (or never if the program
+exits before the next GC). With eager execution, the GC will be started
+right away to measure the memory.
+<strong>Default:</strong> <code>'default'</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> If the memory is successfully measured the promise will
+resolve with an object containing information about the memory usage.</li>
+</ul>
+<p>The format of the object that the returned Promise may resolve with is
+specific to the V8 engine and may change from one version of V8 to the next.</p>
+<p>The returned result is different from the statistics returned by
+<code>v8.getHeapSpaceStatistics()</code> in that <code>vm.measureMemory()</code> measure the
+memory reachable by each V8 specific contexts in the current instance of
+the V8 engine, while the result of <code>v8.getHeapSpaceStatistics()</code> measure
+the memory occupied by each heap space in the current V8 instance.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
+<span class="hljs-comment">// Measure the memory used by the main context.</span>
+vm.<span class="hljs-title function_">measureMemory</span>({ <span class="hljs-attr">mode</span>: <span class="hljs-string">'summary'</span> })
+  <span class="hljs-comment">// This is the same as vm.measureMemory()</span>
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+    <span class="hljs-comment">// The current format is:</span>
+    <span class="hljs-comment">// {</span>
+    <span class="hljs-comment">//   total: {</span>
+    <span class="hljs-comment">//      jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]</span>
+    <span class="hljs-comment">//    }</span>
+    <span class="hljs-comment">// }</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result);
+  });
+
+<span class="hljs-keyword">const</span> context = vm.<span class="hljs-title function_">createContext</span>({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> });
+vm.<span class="hljs-title function_">measureMemory</span>({ <span class="hljs-attr">mode</span>: <span class="hljs-string">'detailed'</span>, <span class="hljs-attr">execution</span>: <span class="hljs-string">'eager'</span> })
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+    <span class="hljs-comment">// Reference the context here so that it won't be GC'ed</span>
+    <span class="hljs-comment">// until the measurement is complete.</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context.<span class="hljs-property">a</span>);
+    <span class="hljs-comment">// {</span>
+    <span class="hljs-comment">//   total: {</span>
+    <span class="hljs-comment">//     jsMemoryEstimate: 2574732,</span>
+    <span class="hljs-comment">//     jsMemoryRange: [ 2574732, 2904372 ]</span>
+    <span class="hljs-comment">//   },</span>
+    <span class="hljs-comment">//   current: {</span>
+    <span class="hljs-comment">//     jsMemoryEstimate: 2438996,</span>
+    <span class="hljs-comment">//     jsMemoryRange: [ 2438996, 2768636 ]</span>
+    <span class="hljs-comment">//   },</span>
+    <span class="hljs-comment">//   other: [</span>
+    <span class="hljs-comment">//     {</span>
+    <span class="hljs-comment">//       jsMemoryEstimate: 135736,</span>
+    <span class="hljs-comment">//       jsMemoryRange: [ 135736, 465376 ]</span>
+    <span class="hljs-comment">//     }</span>
+    <span class="hljs-comment">//   ]</span>
+    <span class="hljs-comment">// }</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result);
+  });</code></pre>
+</section><section><h3><code>vm.runInContext(code, contextifiedObject[, options])</code><span><a class="mark" href="#vm_vm_runincontext_code_contextifiedobject_options" id="vm_vm_runincontext_code_contextifiedobject_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -61759,19 +66721,19 @@ as the <code>global</code> when the <code>code</code> is compiled and run.</li>
 by this script. <strong>Default:</strong> <code>'evalmachine.&#x3C;anonymous>'</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>displayErrors</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, if an <a href="#errors_class_error"><code>Error</code></a> occurs
 while compiling the <code>code</code>, the line of code causing the error is attached
 to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>cachedData</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> Provides an optional <code>Buffer</code> or
 <code>TypedArray</code>, or <code>DataView</code> with V8's code cache data for the supplied
 source. When supplied, the <code>cachedDataRejected</code> value will be set to
@@ -61787,11 +66749,11 @@ This option is <strong>deprecated</strong> in favor of <code>script.createCached
 <li><code>importModuleDynamically</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this module
 when <code>import()</code> is called. If this option is not specified, calls to
 <code>import()</code> will reject with <a href="#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code></a>.
-This option is part of the experimental modules API, and should not be
-considered stable.
+This option is part of the experimental modules API. We do not recommend
+using it in a production environment.
 <ul>
 <li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> specifier passed to <code>import()</code></li>
-<li><code>module</code> <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
+<li><code>script</code> <a href="#vm_class_vm_script" class="type">&#x3C;vm.Script></a></li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects" class="type">&#x3C;Module Namespace Object></a> | <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a> Returning a <code>vm.Module</code> is
 recommended in order to take advantage of error tracking, and to avoid
 issues with namespaces that contain <code>then</code> function exports.</li>
@@ -61811,18 +66773,20 @@ previously <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified<
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
 <span class="hljs-keyword">const</span> contextObject = { <span class="hljs-attr">globalVar</span>: <span class="hljs-number">1</span> };
-vm.createContext(contextObject);
+vm.<span class="hljs-title function_">createContext</span>(contextObject);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">10</span>; ++i) {
-  vm.runInContext(<span class="hljs-string">'globalVar *= 2;'</span>, contextObject);
+  vm.<span class="hljs-title function_">runInContext</span>(<span class="hljs-string">'globalVar *= 2;'</span>, contextObject);
 }
-<span class="hljs-built_in">console</span>.log(contextObject);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(contextObject);
 <span class="hljs-comment">// Prints: { globalVar: 1024 }</span></code></pre>
-<h2><code>vm.runInNewContext(code[, contextObject[, options]])</code><span><a class="mark" href="#vm_vm_runinnewcontext_code_contextobject_options" id="vm_vm_runinnewcontext_code_contextobject_options">#</a></span></h2>
+</section><section><h3><code>vm.runInNewContext(code[, contextObject[, options]])</code><span><a class="mark" href="#vm_vm_runinnewcontext_code_contextobject_options" id="vm_vm_runinnewcontext_code_contextobject_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0</td>
+<td><p>The <code>microtaskMode</code> option is supported now.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>contextCodeGeneration</code> option is supported now.</p></td></tr>
 <tr><td>v6.3.0</td>
@@ -61842,19 +66806,19 @@ vm.createContext(contextObject);
 by this script. <strong>Default:</strong> <code>'evalmachine.&#x3C;anonymous>'</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>displayErrors</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, if an <a href="#errors_class_error"><code>Error</code></a> occurs
 while compiling the <code>code</code>, the line of code causing the error is attached
 to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>contextName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Human-readable name of the newly created context.
 <strong>Default:</strong> <code>'VM Context i'</code>, where <code>i</code> is an ascending numerical index of
 the created context.</li>
@@ -61888,16 +66852,20 @@ This option is <strong>deprecated</strong> in favor of <code>script.createCached
 <li><code>importModuleDynamically</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this module
 when <code>import()</code> is called. If this option is not specified, calls to
 <code>import()</code> will reject with <a href="#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code></a>.
-This option is part of the experimental modules API, and should not be
-considered stable.
+This option is part of the experimental modules API. We do not recommend
+using it in a production environment.
 <ul>
 <li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> specifier passed to <code>import()</code></li>
-<li><code>module</code> <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
+<li><code>script</code> <a href="#vm_class_vm_script" class="type">&#x3C;vm.Script></a></li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects" class="type">&#x3C;Module Namespace Object></a> | <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a> Returning a <code>vm.Module</code> is
 recommended in order to take advantage of error tracking, and to avoid
 issues with namespaces that contain <code>then</code> function exports.</li>
 </ul>
 </li>
+<li><code>microtaskMode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If set to <code>afterEvaluate</code>, microtasks (tasks
+scheduled through <code>Promise</code>s and <code>async function</code>s) will be run immediately
+after the script has run. They are included in the <code>timeout</code> and
+<code>breakOnSigint</code> scopes in that case.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> the result of the very last statement executed in the script.</li>
@@ -61916,10 +66884,10 @@ variable and sets a new one. These globals are contained in the <code>contextObj
   <span class="hljs-attr">count</span>: <span class="hljs-number">2</span>
 };
 
-vm.runInNewContext(<span class="hljs-string">'count += 1; name = "kitty"'</span>, contextObject);
-<span class="hljs-built_in">console</span>.log(contextObject);
+vm.<span class="hljs-title function_">runInNewContext</span>(<span class="hljs-string">'count += 1; name = "kitty"'</span>, contextObject);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(contextObject);
 <span class="hljs-comment">// Prints: { animal: 'cat', count: 3, name: 'kitty' }</span></code></pre>
-<h2><code>vm.runInThisContext(code[, options])</code><span><a class="mark" href="#vm_vm_runinthiscontext_code_options" id="vm_vm_runinthiscontext_code_options">#</a></span></h2>
+</section><section><h3><code>vm.runInThisContext(code[, options])</code><span><a class="mark" href="#vm_vm_runinthiscontext_code_options" id="vm_vm_runinthiscontext_code_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -61939,19 +66907,19 @@ vm.runInNewContext(<span class="hljs-string">'count += 1; name = "kitty"'</span>
 by this script. <strong>Default:</strong> <code>'evalmachine.&#x3C;anonymous>'</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>displayErrors</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, if an <a href="#errors_class_error"><code>Error</code></a> occurs
 while compiling the <code>code</code>, the line of code causing the error is attached
 to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>cachedData</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> Provides an optional <code>Buffer</code> or
 <code>TypedArray</code>, or <code>DataView</code> with V8's code cache data for the supplied
 source. When supplied, the <code>cachedDataRejected</code> value will be set to
@@ -61967,11 +66935,11 @@ This option is <strong>deprecated</strong> in favor of <code>script.createCached
 <li><code>importModuleDynamically</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this module
 when <code>import()</code> is called. If this option is not specified, calls to
 <code>import()</code> will reject with <a href="#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code></a>.
-This option is part of the experimental modules API, and should not be
-considered stable.
+This option is part of the experimental modules API. We do not recommend
+using it in a production environment.
 <ul>
 <li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> specifier passed to <code>import()</code></li>
-<li><code>module</code> <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
+<li><code>script</code> <a href="#vm_class_vm_script" class="type">&#x3C;vm.Script></a></li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects" class="type">&#x3C;Module Namespace Object></a> | <a href="#vm_class_vm_module" class="type">&#x3C;vm.Module></a> Returning a <code>vm.Module</code> is
 recommended in order to take advantage of error tracking, and to avoid
 issues with namespaces that contain <code>then</code> function exports.</li>
@@ -61991,19 +66959,19 @@ the JavaScript <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 <span class="hljs-keyword">let</span> localVar = <span class="hljs-string">'initial value'</span>;
 
-<span class="hljs-keyword">const</span> vmResult = vm.runInThisContext(<span class="hljs-string">'localVar = "vm";'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`vmResult: '<span class="hljs-subst">${vmResult}</span>', localVar: '<span class="hljs-subst">${localVar}</span>'`</span>);
+<span class="hljs-keyword">const</span> vmResult = vm.<span class="hljs-title function_">runInThisContext</span>(<span class="hljs-string">'localVar = "vm";'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`vmResult: '<span class="hljs-subst">${vmResult}</span>', localVar: '<span class="hljs-subst">${localVar}</span>'`</span>);
 <span class="hljs-comment">// Prints: vmResult: 'vm', localVar: 'initial value'</span>
 
 <span class="hljs-keyword">const</span> evalResult = <span class="hljs-built_in">eval</span>(<span class="hljs-string">'localVar = "eval";'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`evalResult: '<span class="hljs-subst">${evalResult}</span>', localVar: '<span class="hljs-subst">${localVar}</span>'`</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`evalResult: '<span class="hljs-subst">${evalResult}</span>', localVar: '<span class="hljs-subst">${localVar}</span>'`</span>);
 <span class="hljs-comment">// Prints: evalResult: 'eval', localVar: 'eval'</span></code></pre>
 <p>Because <code>vm.runInThisContext()</code> does not have access to the local scope,
 <code>localVar</code> is unchanged. In contrast, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval"><code>eval()</code></a> <em>does</em> have access to the
 local scope, so the value <code>localVar</code> is changed. In this way
 <code>vm.runInThisContext()</code> is much like an <a href="https://es5.github.io/#x10.4.2">indirect <code>eval()</code> call</a>, e.g.
 <code>(0,eval)('code')</code>.</p>
-<h2>Example: Running an HTTP server within a VM<span><a class="mark" href="#vm_example_running_an_http_server_within_a_vm" id="vm_example_running_an_http_server_within_a_vm">#</a></span></h2>
+</section><section><h3>Example: Running an HTTP server within a VM<span><a class="mark" href="#vm_example_running_an_http_server_within_a_vm" id="vm_example_running_an_http_server_within_a_vm">#</a></span></h3>
 <p>When using either <a href="#vm_script_runinthiscontext_options"><code>script.runInThisContext()</code></a> or
 <a href="#vm_vm_runinthiscontext_code_options"><code>vm.runInThisContext()</code></a>, the code is executed within the current V8 global
 context. The code passed to this VM context will have its own isolated scope.</p>
@@ -62025,11 +66993,11 @@ to the <code>http</code> module passed to it. For instance:</p>
   console.log('Server running at http://127.0.0.1:8124/');
 })`</span>;
 
-vm.runInThisContext(code)(<span class="hljs-built_in">require</span>);</code></pre>
+vm.<span class="hljs-title function_">runInThisContext</span>(code)(<span class="hljs-built_in">require</span>);</code></pre>
 <p>The <code>require()</code> in the above case shares the state with the context it is
 passed from. This may introduce risks when untrusted code is executed, e.g.
 altering objects in the context in unwanted ways.</p>
-<h2>What does it mean to "contextify" an object?<span><a class="mark" href="#vm_what_does_it_mean_to_contextify_an_object" id="vm_what_does_it_mean_to_contextify_an_object">#</a></span></h2>
+</section><section><h3>What does it mean to "contextify" an object?<span><a class="mark" href="#vm_what_does_it_mean_to_contextify_an_object" id="vm_what_does_it_mean_to_contextify_an_object">#</a></span></h3>
 <p>All JavaScript executed within Node.js runs within the scope of a "context".
 According to the <a href="https://v8.dev/docs/embed#contexts">V8 Embedder's Guide</a>:</p>
 <blockquote>
@@ -62044,54 +67012,97 @@ internally with a new instance of a V8 Context. This V8 Context provides the
 within which it can operate. The process of creating the V8 Context and
 associating it with the <code>contextObject</code> is what this document refers to as
 "contextifying" the object.</p>
-<h2>Timeout limitations when using <code>process.nextTick()</code>, promises, and <code>queueMicrotask()</code><span><a class="mark" href="#vm_timeout_limitations_when_using_process_nexttick_promises_and_queuemicrotask" id="vm_timeout_limitations_when_using_process_nexttick_promises_and_queuemicrotask">#</a></span></h2>
-<p>Because of the internal mechanics of how the <code>process.nextTick()</code> queue and
-the microtask queue that underlies Promises are implemented within V8 and
-Node.js, it is possible for code running within a context to "escape" the
-<code>timeout</code> set using <code>vm.runInContext()</code>, <code>vm.runInNewContext()</code>, and
-<code>vm.runInThisContext()</code>.</p>
+</section><section><h3>Timeout interactions with asynchronous tasks and Promises<span><a class="mark" href="#vm_timeout_interactions_with_asynchronous_tasks_and_promises" id="vm_timeout_interactions_with_asynchronous_tasks_and_promises">#</a></span></h3>
+<p><code>Promise</code>s and <code>async function</code>s can schedule tasks run by the JavaScript
+engine asynchronously. By default, these tasks are run after all JavaScript
+functions on the current stack are done executing.
+This allows escaping the functionality of the <code>timeout</code> and
+<code>breakOnSigint</code> options.</p>
 <p>For example, the following code executed by <code>vm.runInNewContext()</code> with a
 timeout of 5 milliseconds schedules an infinite loop to run after a promise
 resolves. The scheduled loop is never interrupted by the timeout:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">loop</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">while</span> (<span class="hljs-number">1</span>) <span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">Date</span>.now());
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">loop</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'entering loop'</span>);
+  <span class="hljs-keyword">while</span> (<span class="hljs-number">1</span>) <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>());
 }
 
-vm.runInNewContext(
-  <span class="hljs-string">'Promise.resolve().then(loop);'</span>,
-  { loop, <span class="hljs-built_in">console</span> },
+vm.<span class="hljs-title function_">runInNewContext</span>(
+  <span class="hljs-string">'Promise.resolve().then(() => loop());'</span>,
+  { loop, <span class="hljs-variable language_">console</span> },
   { <span class="hljs-attr">timeout</span>: <span class="hljs-number">5</span> }
+);
+<span class="hljs-comment">// This is printed *before* 'entering loop' (!)</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'done executing'</span>);</code></pre>
+<p>This can be addressed by passing <code>microtaskMode: 'afterEvaluate'</code> to the code
+that creates the <code>Context</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">loop</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">while</span> (<span class="hljs-number">1</span>) <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>());
+}
+
+vm.<span class="hljs-title function_">runInNewContext</span>(
+  <span class="hljs-string">'Promise.resolve().then(() => loop());'</span>,
+  { loop, <span class="hljs-variable language_">console</span> },
+  { <span class="hljs-attr">timeout</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">microtaskMode</span>: <span class="hljs-string">'afterEvaluate'</span> }
 );</code></pre>
-<p>This issue also occurs when the <code>loop()</code> call is scheduled using
-the <code>process.nextTick()</code> and <code>queueMicrotask()</code> functions.</p>
-<p>This issue occurs because all contexts share the same microtask and nextTick
-queues.</p>
-<h1>WebAssembly System Interface (WASI)<span><a class="mark" href="#wasi_webassembly_system_interface_wasi" id="wasi_webassembly_system_interface_wasi">#</a></span></h1>
+<p>In this case, the microtask scheduled through <code>promise.then()</code> will be run
+before returning from <code>vm.runInNewContext()</code>, and will be interrupted
+by the <code>timeout</code> functionality. This applies only to code running in a
+<code>vm.Context</code>, so e.g. <a href="#vm_vm_runinthiscontext_code_options"><code>vm.runInThisContext()</code></a> does not take this option.</p>
+<p>Promise callbacks are entered into the microtask queue of the context in which
+they were created. For example, if <code>() => loop()</code> is replaced with just <code>loop</code>
+in the above example, then <code>loop</code> will be pushed into the global microtask
+queue, because it is a function from the outer (main) context, and thus will
+also be able to escape the timeout.</p>
+<p>If asynchronous scheduling functions such as <code>process.nextTick()</code>,
+<code>queueMicrotask()</code>, <code>setTimeout()</code>, <code>setImmediate()</code>, etc. are made available
+inside a <code>vm.Context</code>, functions passed to them will be added to global queues,
+which are shared by all contexts. Therefore, callbacks passed to those functions
+are not controllable through the timeout either.</p></section>
+        </section>
+<section><h2>WebAssembly System Interface (WASI)<span><a class="mark" href="#wasi_webassembly_system_interface_wasi" id="wasi_webassembly_system_interface_wasi">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/wasi.js">lib/wasi.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/wasi.js">lib/wasi.js</a></p>
 <p>The WASI API provides an implementation of the <a href="https://wasi.dev/">WebAssembly System Interface</a>
 specification. WASI gives sandboxed WebAssembly applications access to the
 underlying operating system via a collection of POSIX-like functions.</p>
-<pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-keyword">import</span> { <span class="hljs-variable constant_">WASI</span> } <span class="hljs-keyword">from</span> <span class="hljs-string">'wasi'</span>;
+
+<span class="hljs-keyword">const</span> wasi = <span class="hljs-keyword">new</span> <span class="hljs-title function_">WASI</span>({
+  <span class="hljs-attr">args</span>: process.<span class="hljs-property">argv</span>,
+  <span class="hljs-attr">env</span>: process.<span class="hljs-property">env</span>,
+  <span class="hljs-attr">preopens</span>: {
+    <span class="hljs-string">'/sandbox'</span>: <span class="hljs-string">'/some/real/path/that/wasm/can/access'</span>
+  }
+});
+<span class="hljs-keyword">const</span> importObject = { <span class="hljs-attr">wasi_snapshot_preview1</span>: wasi.<span class="hljs-property">wasiImport</span> };
+
+<span class="hljs-keyword">const</span> wasm = <span class="hljs-keyword">await</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title function_">compile</span>(fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'./demo.wasm'</span>));
+<span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">await</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title function_">instantiate</span>(wasm, importObject);
+
+wasi.<span class="hljs-title function_">start</span>(instance);</code><code class="language-js cjs"><span class="hljs-meta">'use strict'</span>;
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> { WASI } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'wasi'</span>);
-<span class="hljs-keyword">const</span> wasi = <span class="hljs-keyword">new</span> WASI({
-  <span class="hljs-attr">args</span>: process.argv,
-  <span class="hljs-attr">env</span>: process.env,
+<span class="hljs-keyword">const</span> { <span class="hljs-variable constant_">WASI</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'wasi'</span>);
+<span class="hljs-keyword">const</span> wasi = <span class="hljs-keyword">new</span> <span class="hljs-title function_">WASI</span>({
+  <span class="hljs-attr">args</span>: process.<span class="hljs-property">argv</span>,
+  <span class="hljs-attr">env</span>: process.<span class="hljs-property">env</span>,
   <span class="hljs-attr">preopens</span>: {
     <span class="hljs-string">'/sandbox'</span>: <span class="hljs-string">'/some/real/path/that/wasm/can/access'</span>
   }
 });
-<span class="hljs-keyword">const</span> importObject = { <span class="hljs-attr">wasi_snapshot_preview1</span>: wasi.wasiImport };
+<span class="hljs-keyword">const</span> importObject = { <span class="hljs-attr">wasi_snapshot_preview1</span>: wasi.<span class="hljs-property">wasiImport</span> };
 
 (<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> wasm = <span class="hljs-keyword">await</span> WebAssembly.compile(fs.readFileSync(<span class="hljs-string">'./demo.wasm'</span>));
-  <span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">await</span> WebAssembly.instantiate(wasm, importObject);
+  <span class="hljs-keyword">const</span> wasm = <span class="hljs-keyword">await</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title function_">compile</span>(fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'./demo.wasm'</span>));
+  <span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">await</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title function_">instantiate</span>(wasm, importObject);
 
-  wasi.start(instance);
+  wasi.<span class="hljs-title function_">start</span>(instance);
 })();</code></pre>
 <p>To run the above example, create a new WebAssembly text format file named
 <code>demo.wat</code>:</p>
@@ -62123,27 +67134,27 @@ underlying operating system via a collection of POSIX-like functions.</p>
     )
 )</code></pre>
 <p>Use <a href="https://github.com/WebAssembly/wabt">wabt</a> to compile <code>.wat</code> to <code>.wasm</code></p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> wat2wasm demo.wat</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">wat2wasm demo.wat</span></code></pre>
 <p>The <code>--experimental-wasi-unstable-preview1</code> and <code>--experimental-wasm-bigint</code>
 CLI arguments are needed for this example to run.</p>
-<h2>Class: <code>WASI</code><span><a class="mark" href="#wasi_class_wasi" id="wasi_class_wasi">#</a></span></h2>
+<section><h3>Class: <code>WASI</code><span><a class="mark" href="#wasi_class_wasi" id="wasi_class_wasi">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0</span>
 </div>
 <p>The <code>WASI</code> class provides the WASI system call API and additional convenience
 methods for working with WASI-based applications. Each <code>WASI</code> instance
 represents a distinct sandbox environment. For security purposes, each <code>WASI</code>
-instance must have its command line arguments, environment variables, and
+instance must have its command-line arguments, environment variables, and
 sandbox directory structure configured explicitly.</p>
-<h3><code>new WASI([options])</code><span><a class="mark" href="#wasi_new_wasi_options" id="wasi_new_wasi_options">#</a></span></h3>
+<h4><code>new WASI([options])</code><span><a class="mark" href="#wasi_new_wasi_options" id="wasi_new_wasi_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> An array of strings that the WebAssembly application will
-see as command line arguments. The first argument is the virtual path to the
+see as command-line arguments. The first argument is the virtual path to the
 WASI command itself. <strong>Default:</strong> <code>[]</code>.</li>
 <li><code>env</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> An object similar to <code>process.env</code> that the WebAssembly
 application will see as its environment. <strong>Default:</strong> <code>{}</code>.</li>
@@ -62164,9 +67175,9 @@ WebAssembly application. <strong>Default:</strong> <code>2</code>.</li>
 </ul>
 </li>
 </ul>
-<h3><code>wasi.start(instance)</code><span><a class="mark" href="#wasi_wasi_start_instance" id="wasi_wasi_start_instance">#</a></span></h3>
+<h4><code>wasi.start(instance)</code><span><a class="mark" href="#wasi_wasi_start_instance" id="wasi_wasi_start_instance">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>instance</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance" class="type">&#x3C;WebAssembly.Instance></a></li>
@@ -62177,9 +67188,9 @@ WebAssembly application. <strong>Default:</strong> <code>2</code>.</li>
 <p><code>start()</code> requires that <code>instance</code> exports a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory"><code>WebAssembly.Memory</code></a> named
 <code>memory</code>. If <code>instance</code> does not have a <code>memory</code> export an exception is thrown.</p>
 <p>If <code>start()</code> is called more than once, an exception is thrown.</p>
-<h3><code>wasi.initialize(instance)</code><span><a class="mark" href="#wasi_wasi_initialize_instance" id="wasi_wasi_initialize_instance">#</a></span></h3>
+<h4><code>wasi.initialize(instance)</code><span><a class="mark" href="#wasi_wasi_initialize_instance" id="wasi_wasi_initialize_instance">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.6.0</span>
 </div>
 <ul>
 <li><code>instance</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance" class="type">&#x3C;WebAssembly.Instance></a></li>
@@ -62190,20 +67201,21 @@ export, then an exception is thrown.</p>
 <p><code>initialize()</code> requires that <code>instance</code> exports a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory"><code>WebAssembly.Memory</code></a> named
 <code>memory</code>. If <code>instance</code> does not have a <code>memory</code> export an exception is thrown.</p>
 <p>If <code>initialize()</code> is called more than once, an exception is thrown.</p>
-<h3><code>wasi.wasiImport</code><span><a class="mark" href="#wasi_wasi_wasiimport" id="wasi_wasi_wasiimport">#</a></span></h3>
+<h4><code>wasi.wasiImport</code><span><a class="mark" href="#wasi_wasi_wasiimport" id="wasi_wasi_wasiimport">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p><code>wasiImport</code> is an object that implements the WASI system call API. This object
 should be passed as the <code>wasi_snapshot_preview1</code> import during the instantiation
-of a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance"><code>WebAssembly.Instance</code></a>.</p>
-<h1>Worker threads<span><a class="mark" href="#worker_threads_worker_threads" id="worker_threads_worker_threads">#</a></span></h1>
+of a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance"><code>WebAssembly.Instance</code></a>.</p></section>
+        </section>
+<section><h2>Worker threads<span><a class="mark" href="#worker_threads_worker_threads" id="worker_threads_worker_threads">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/worker_threads.js">lib/worker_threads.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/worker_threads.js">lib/worker_threads.js</a></p>
 <p>The <code>worker_threads</code> module enables the use of threads that execute JavaScript
 in parallel. To access it:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> worker = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);</code></pre>
@@ -62214,27 +67226,27 @@ I/O operations are more efficient than Workers can be.</p>
 so by transferring <code>ArrayBuffer</code> instances or sharing <code>SharedArrayBuffer</code>
 instances.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
-  Worker, isMainThread, parentPort, workerData
+  <span class="hljs-title class_">Worker</span>, isMainThread, parentPort, workerData
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-built_in">module</span>.exports = <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">parseJSAsync</span>(<span class="hljs-params">script</span>) </span>{
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-      <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename, {
+  <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-keyword">function</span> <span class="hljs-title function_">parseJSAsync</span>(<span class="hljs-params">script</span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+      <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename, {
         <span class="hljs-attr">workerData</span>: script
       });
-      worker.on(<span class="hljs-string">'message'</span>, resolve);
-      worker.on(<span class="hljs-string">'error'</span>, reject);
-      worker.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+      worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, resolve);
+      worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, reject);
+      worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
         <span class="hljs-keyword">if</span> (code !== <span class="hljs-number">0</span>)
-          reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">`Worker stopped with exit code <span class="hljs-subst">${code}</span>`</span>));
+          <span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">`Worker stopped with exit code <span class="hljs-subst">${code}</span>`</span>));
       });
     });
   };
 } <span class="hljs-keyword">else</span> {
   <span class="hljs-keyword">const</span> { parse } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'some-js-parsing-library'</span>);
   <span class="hljs-keyword">const</span> script = workerData;
-  parentPort.postMessage(parse(script));
+  parentPort.<span class="hljs-title function_">postMessage</span>(<span class="hljs-title function_">parse</span>(script));
 }</code></pre>
 <p>The above example spawns a Worker thread for each <code>parse()</code> call. In actual
 practice, use a pool of Workers instead for these kinds of tasks. Otherwise, the
@@ -62247,7 +67259,34 @@ in the <code>async_hooks</code> documentation for an example implementation.</p>
 <p>Worker threads inherit non-process-specific options by default. Refer to
 <a href="#worker_threads_new_worker_filename_options"><code>Worker constructor options</code></a> to know how to customize worker thread options,
 specifically <code>argv</code> and <code>execArgv</code> options.</p>
-<h2><code>worker.isMainThread</code><span><a class="mark" href="#worker_threads_worker_ismainthread" id="worker_threads_worker_ismainthread">#</a></span></h2>
+<section><h3><code>worker.getEnvironmentData(key)</code><span><a class="mark" href="#worker_threads_worker_getenvironmentdata_key" id="worker_threads_worker_getenvironmentdata_key">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<ul>
+<li><code>key</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Any arbitrary, cloneable JavaScript value that can be used as a
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" class="type">&#x3C;Map></a> key.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
+</ul>
+<p>Within a worker thread, <code>worker.getEnvironmentData()</code> returns a clone
+of data passed to the spawning thread's <code>worker.setEnvironmentData()</code>.
+Every new <code>Worker</code> receives its own copy of the environment data
+automatically.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  <span class="hljs-title class_">Worker</span>,
+  isMainThread,
+  setEnvironmentData,
+  getEnvironmentData,
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+
+<span class="hljs-keyword">if</span> (isMainThread) {
+  <span class="hljs-title function_">setEnvironmentData</span>(<span class="hljs-string">'Hello'</span>, <span class="hljs-string">'World!'</span>);
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
+} <span class="hljs-keyword">else</span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">getEnvironmentData</span>(<span class="hljs-string">'Hello'</span>));  <span class="hljs-comment">// Prints 'World!'.</span>
+}</code></pre>
+</section><section><h3><code>worker.isMainThread</code><span><a class="mark" href="#worker_threads_worker_ismainthread" id="worker_threads_worker_ismainthread">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62255,18 +67294,18 @@ specifically <code>argv</code> and <code>execArgv</code> options.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Is <code>true</code> if this code is not running inside of a <a href="#worker_threads_class_worker"><code>Worker</code></a> thread.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, isMainThread } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, isMainThread } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
   <span class="hljs-comment">// This re-loads the current file inside a Worker instance.</span>
-  <span class="hljs-keyword">new</span> Worker(__filename);
+  <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
 } <span class="hljs-keyword">else</span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Inside Worker!'</span>);
-  <span class="hljs-built_in">console</span>.log(isMainThread);  <span class="hljs-comment">// Prints 'false'.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Inside Worker!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(isMainThread);  <span class="hljs-comment">// Prints 'false'.</span>
 }</code></pre>
-<h2><code>worker.markAsUntransferable(object)</code><span><a class="mark" href="#worker_threads_worker_markasuntransferable_object" id="worker_threads_worker_markasuntransferable_object">#</a></span></h2>
+</section><section><h3><code>worker.markAsUntransferable(object)</code><span><a class="mark" href="#worker_threads_worker_markasuntransferable_object" id="worker_threads_worker_markasuntransferable_object">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <p>Mark an object as not transferable. If <code>object</code> occurs in the transfer list of
 a <a href="#worker_threads_port_postmessage_value_transferlist"><code>port.postMessage()</code></a> call, it will be ignored.</p>
@@ -62275,25 +67314,25 @@ transferred, and which are used by other objects on the sending side.
 For example, Node.js marks the <code>ArrayBuffer</code>s it uses for its
 <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer</code> pool</a> with this.</p>
 <p>This operation cannot be undone.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel, markAsUntransferable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span>, markAsUntransferable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
-<span class="hljs-keyword">const</span> pooledBuffer = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">8</span>);
-<span class="hljs-keyword">const</span> typedArray1 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(pooledBuffer);
-<span class="hljs-keyword">const</span> typedArray2 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>(pooledBuffer);
+<span class="hljs-keyword">const</span> pooledBuffer = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">8</span>);
+<span class="hljs-keyword">const</span> typedArray1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(pooledBuffer);
+<span class="hljs-keyword">const</span> typedArray2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>(pooledBuffer);
 
-markAsUntransferable(pooledBuffer);
+<span class="hljs-title function_">markAsUntransferable</span>(pooledBuffer);
 
-<span class="hljs-keyword">const</span> { port1 } = <span class="hljs-keyword">new</span> MessageChannel();
-port1.postMessage(typedArray1, [ typedArray1.buffer ]);
+<span class="hljs-keyword">const</span> { port1 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+port1.<span class="hljs-title function_">postMessage</span>(typedArray1, [ typedArray1.<span class="hljs-property">buffer</span> ]);
 
 <span class="hljs-comment">// The following line prints the contents of typedArray1 -- it still owns</span>
 <span class="hljs-comment">// its memory and has been cloned, not transferred. Without</span>
 <span class="hljs-comment">// `markAsUntransferable()`, this would print an empty Uint8Array.</span>
 <span class="hljs-comment">// typedArray2 is intact as well.</span>
-<span class="hljs-built_in">console</span>.log(typedArray1);
-<span class="hljs-built_in">console</span>.log(typedArray2);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(typedArray1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(typedArray2);</code></pre>
 <p>There is no equivalent to this API in browsers.</p>
-<h2><code>worker.moveMessagePortToContext(port, contextifiedSandbox)</code><span><a class="mark" href="#worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox" id="worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox">#</a></span></h2>
+</section><section><h3><code>worker.moveMessagePortToContext(port, contextifiedSandbox)</code><span><a class="mark" href="#worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox" id="worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.13.0</span>
 </div>
@@ -62317,9 +67356,9 @@ inherit from its global <code>Object</code> class. Objects passed to the
 <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage"><code>port.onmessage()</code></a> listener will also be created in the target context
 and inherit from its global <code>Object</code> class.</p>
 <p>However, the created <code>MessagePort</code> will no longer inherit from
-<a href="events.html"><code>EventEmitter</code></a>, and only <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage"><code>port.onmessage()</code></a> can be used to receive
+<a href="https://developer.mozilla.org/en-US/docs/Web/API/EventTarget"><code>EventTarget</code></a>, and only <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage"><code>port.onmessage()</code></a> can be used to receive
 events using it.</p>
-<h2><code>worker.parentPort</code><span><a class="mark" href="#worker_threads_worker_parentport" id="worker_threads_worker_parentport">#</a></span></h2>
+</section><section><h3><code>worker.parentPort</code><span><a class="mark" href="#worker_threads_worker_parentport" id="worker_threads_worker_parentport">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62332,21 +67371,21 @@ allowing communication with the parent thread. Messages sent using
 using <code>worker.on('message')</code>, and messages sent from the parent thread
 using <code>worker.postMessage()</code> will be available in this thread using
 <code>parentPort.on('message')</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, isMainThread, parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, isMainThread, parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename);
-  worker.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(message);  <span class="hljs-comment">// Prints 'Hello, world!'.</span>
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
+  worker.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message);  <span class="hljs-comment">// Prints 'Hello, world!'.</span>
   });
-  worker.postMessage(<span class="hljs-string">'Hello, world!'</span>);
+  worker.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'Hello, world!'</span>);
 } <span class="hljs-keyword">else</span> {
   <span class="hljs-comment">// When a message from the parent thread is received, send it back:</span>
-  parentPort.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
-    parentPort.postMessage(message);
+  parentPort.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
+    parentPort.<span class="hljs-title function_">postMessage</span>(message);
   });
 }</code></pre>
-<h2><code>worker.receiveMessageOnPort(port)</code><span><a class="mark" href="#worker_threads_worker_receivemessageonport_port" id="worker_threads_worker_receivemessageonport_port">#</a></span></h2>
+</section><section><h3><code>worker.receiveMessageOnPort(port)</code><span><a class="mark" href="#worker_threads_worker_receivemessageonport_port" id="worker_threads_worker_receivemessageonport_port">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
@@ -62362,19 +67401,19 @@ using <code>worker.postMessage()</code> will be available in this thread using
 <code>undefined</code> is returned, otherwise an object with a single <code>message</code> property
 that contains the message payload, corresponding to the oldest message in the
 <code>MessagePort</code>’s queue.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel, receiveMessageOnPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
-port1.postMessage({ <span class="hljs-attr">hello</span>: <span class="hljs-string">'world'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span>, receiveMessageOnPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+port1.<span class="hljs-title function_">postMessage</span>({ <span class="hljs-attr">hello</span>: <span class="hljs-string">'world'</span> });
 
-<span class="hljs-built_in">console</span>.log(receiveMessageOnPort(port2));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">receiveMessageOnPort</span>(port2));
 <span class="hljs-comment">// Prints: { message: { hello: 'world' } }</span>
-<span class="hljs-built_in">console</span>.log(receiveMessageOnPort(port2));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">receiveMessageOnPort</span>(port2));
 <span class="hljs-comment">// Prints: undefined</span></code></pre>
 <p>When this function is used, no <code>'message'</code> event will be emitted and the
 <code>onmessage</code> listener will not be invoked.</p>
-<h2><code>worker.resourceLimits</code><span><a class="mark" href="#worker_threads_worker_resourcelimits" id="worker_threads_worker_resourcelimits">#</a></span></h2>
+</section><section><h3><code>worker.resourceLimits</code><span><a class="mark" href="#worker_threads_worker_resourcelimits" id="worker_threads_worker_resourcelimits">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -62390,7 +67429,7 @@ port1.postMessage({ <span class="hljs-attr">hello</span>: <span class="hljs-stri
 If the <code>resourceLimits</code> option was passed to the <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor,
 this matches its values.</p>
 <p>If this is used in the main thread, its value is an empty object.</p>
-<h2><code>worker.SHARE_ENV</code><span><a class="mark" href="#worker_threads_worker_share_env" id="worker_threads_worker_share_env">#</a></span></h2>
+</section><section><h3><code>worker.SHARE_ENV</code><span><a class="mark" href="#worker_threads_worker_share_env" id="worker_threads_worker_share_env">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.14.0</span>
 </div>
@@ -62400,12 +67439,27 @@ this matches its values.</p>
 <p>A special value that can be passed as the <code>env</code> option of the <a href="#worker_threads_class_worker"><code>Worker</code></a>
 constructor, to indicate that the current thread and the Worker thread should
 share read and write access to the same set of environment variables.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, SHARE_ENV } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">new</span> Worker(<span class="hljs-string">'process.env.SET_IN_WORKER = "foo"'</span>, { <span class="hljs-attr">eval</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">env</span>: SHARE_ENV })
-  .on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(process.env.SET_IN_WORKER);  <span class="hljs-comment">// Prints 'foo'.</span>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, <span class="hljs-variable constant_">SHARE_ENV</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(<span class="hljs-string">'process.env.SET_IN_WORKER = "foo"'</span>, { <span class="hljs-attr">eval</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">env</span>: <span class="hljs-variable constant_">SHARE_ENV</span> })
+  .<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">SET_IN_WORKER</span>);  <span class="hljs-comment">// Prints 'foo'.</span>
   });</code></pre>
-<h2><code>worker.threadId</code><span><a class="mark" href="#worker_threads_worker_threadid" id="worker_threads_worker_threadid">#</a></span></h2>
+</section><section><h3><code>worker.setEnvironmentData(key[, value])</code><span><a class="mark" href="#worker_threads_worker_setenvironmentdata_key_value" id="worker_threads_worker_setenvironmentdata_key_value">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<ul>
+<li><code>key</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Any arbitrary, cloneable JavaScript value that can be used as a
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" class="type">&#x3C;Map></a> key.</li>
+<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Any arbitrary, cloneable JavaScript value that will be cloned
+and passed automatically to all new <code>Worker</code> instances. If <code>value</code> is passed
+as <code>undefined</code>, any previously set value for the <code>key</code> will be deleted.</li>
+</ul>
+<p>The <code>worker.setEnvironmentData()</code> API sets the content of
+<code>worker.getEnvironmentData()</code> in the current thread and all new <code>Worker</code>
+instances spawned from the current context.</p>
+</section><section><h3><code>worker.threadId</code><span><a class="mark" href="#worker_threads_worker_threadid" id="worker_threads_worker_threadid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62415,7 +67469,7 @@ share read and write access to the same set of environment variables.</p>
 <p>An integer identifier for the current thread. On the corresponding worker object
 (if there is any), it is available as <a href="#worker_threads_worker_threadid_1"><code>worker.threadId</code></a>.
 This value is unique for each <a href="#worker_threads_class_worker"><code>Worker</code></a> instance inside a single process.</p>
-<h2><code>worker.workerData</code><span><a class="mark" href="#worker_threads_worker_workerdata" id="worker_threads_worker_workerdata">#</a></span></h2>
+</section><section><h3><code>worker.workerData</code><span><a class="mark" href="#worker_threads_worker_workerdata" id="worker_threads_worker_workerdata">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62423,14 +67477,14 @@ This value is unique for each <a href="#worker_threads_class_worker"><code>Worke
 to this thread’s <code>Worker</code> constructor.</p>
 <p>The data is cloned as if using <a href="#worker_threads_port_postmessage_value_transferlist"><code>postMessage()</code></a>,
 according to the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm">HTML structured clone algorithm</a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, isMainThread, workerData } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, isMainThread, workerData } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename, { <span class="hljs-attr">workerData</span>: <span class="hljs-string">'Hello, world!'</span> });
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename, { <span class="hljs-attr">workerData</span>: <span class="hljs-string">'Hello, world!'</span> });
 } <span class="hljs-keyword">else</span> {
-  <span class="hljs-built_in">console</span>.log(workerData);  <span class="hljs-comment">// Prints 'Hello, world!'.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(workerData);  <span class="hljs-comment">// Prints 'Hello, world!'.</span>
 }</code></pre>
-<h2>Class: <code>MessageChannel</code><span><a class="mark" href="#worker_threads_class_messagechannel" id="worker_threads_class_messagechannel">#</a></span></h2>
+</section><section><h3>Class: <code>MessageChannel</code><span><a class="mark" href="#worker_threads_class_messagechannel" id="worker_threads_class_messagechannel">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62439,43 +67493,50 @@ two-way communications channel.
 The <code>MessageChannel</code> has no methods of its own. <code>new MessageChannel()</code>
 yields an object with <code>port1</code> and <code>port2</code> properties, which refer to linked
 <a href="#worker_threads_class_messageport"><code>MessagePort</code></a> instances.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
-port1.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'received'</span>, message));
-port2.postMessage({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span> });
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+port1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'received'</span>, message));
+port2.<span class="hljs-title function_">postMessage</span>({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span> });
 <span class="hljs-comment">// Prints: received { foo: 'bar' } from the `port1.on('message')` listener</span></code></pre>
-<h2>Class: <code>MessagePort</code><span><a class="mark" href="#worker_threads_class_messageport" id="worker_threads_class_messageport">#</a></span></h2>
+</section><section><h3>Class: <code>MessagePort</code><span><a class="mark" href="#worker_threads_class_messageport" id="worker_threads_class_messageport">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v10.5.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.7.0</td>
+<td><p>This class now inherits from <code>EventTarget</code> rather than from <code>EventEmitter</code>.</p></td></tr>
+<tr><td>v10.5.0</td>
+<td><p><span>Added in: v10.5.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li>Extends: <a href="#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+<li>Extends: <a href="#events_class_eventtarget" class="type">&#x3C;EventTarget></a></li>
 </ul>
 <p>Instances of the <code>worker.MessagePort</code> class represent one end of an
 asynchronous, two-way communications channel. It can be used to transfer
 structured data, memory regions and other <code>MessagePort</code>s between different
 <a href="#worker_threads_class_worker"><code>Worker</code></a>s.</p>
-<p>With the exception of <code>MessagePort</code>s being <a href="events.html"><code>EventEmitter</code></a>s rather
-than <a href="https://developer.mozilla.org/en-US/docs/Web/API/EventTarget"><code>EventTarget</code></a>s, this implementation matches <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort">browser <code>MessagePort</code></a>s.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#worker_threads_event_close" id="worker_threads_event_close">#</a></span></h3>
+<p>This implementation matches <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort">browser <code>MessagePort</code></a>s.</p>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#worker_threads_event_close" id="worker_threads_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
 <p>The <code>'close'</code> event is emitted once either side of the channel has been
 disconnected.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
 
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   foobar</span>
 <span class="hljs-comment">//   closed!</span>
-port2.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(message));
-port2.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'closed!'</span>));
+port2.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message));
+port2.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'closed!'</span>));
 
-port1.postMessage(<span class="hljs-string">'foobar'</span>);
-port1.close();</code></pre>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#worker_threads_event_message" id="worker_threads_event_message">#</a></span></h3>
+port1.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'foobar'</span>);
+port1.<span class="hljs-title function_">close</span>();</code></pre>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#worker_threads_event_message" id="worker_threads_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62486,15 +67547,20 @@ port1.close();</code></pre>
 input of <a href="#worker_threads_port_postmessage_value_transferlist"><code>port.postMessage()</code></a>.</p>
 <p>Listeners on this event will receive a clone of the <code>value</code> parameter as passed
 to <code>postMessage()</code> and no further arguments.</p>
-<h3>Event: <code>'messageerror'</code><span><a class="mark" href="#worker_threads_event_messageerror" id="worker_threads_event_messageerror">#</a></span></h3>
+<h4>Event: <code>'messageerror'</code><span><a class="mark" href="#worker_threads_event_messageerror" id="worker_threads_event_messageerror">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> An Error object</li>
 </ul>
 <p>The <code>'messageerror'</code> event is emitted when deserializing a message failed.</p>
-<h3><code>port.close()</code><span><a class="mark" href="#worker_threads_port_close" id="worker_threads_port_close">#</a></span></h3>
+<p>Currently, this event is emitted when there is an error occurring while
+instantiating the posted JS object on the receiving end. Such situations
+are rare, but can happen, for instance, when certain Node.js API objects
+are received in a <code>vm.Context</code> (where Node.js APIs are currently
+unavailable).</p>
+<h4><code>port.close()</code><span><a class="mark" href="#worker_threads_port_close" id="worker_threads_port_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62503,14 +67569,18 @@ This method can be called when no further communication will happen over this
 <code>MessagePort</code>.</p>
 <p>The <a href="#worker_threads_event_close"><code>'close'</code> event</a> will be emitted on both <code>MessagePort</code> instances that
 are part of the channel.</p>
-<h3><code>port.postMessage(value[, transferList])</code><span><a class="mark" href="#worker_threads_port_postmessage_value_transferlist" id="worker_threads_port_postmessage_value_transferlist">#</a></span></h3>
+<h4><code>port.postMessage(value[, transferList])</code><span><a class="mark" href="#worker_threads_port_postmessage_value_transferlist" id="worker_threads_port_postmessage_value_transferlist">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.18.0</td>
+<td><p>Add 'BlockList' to the list of cloneable types.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>Add 'Histogram' types to the list of cloneable types.</p></td></tr>
+<tr><td>v14.5.0</td>
 <td><p>Added <code>KeyObject</code> to the list of cloneable types.</p></td></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>Added <code>FileHandle</code> to the list of transferable types.</p></td></tr>
 <tr><td>v10.5.0</td>
 <td><p><span>Added in: v10.5.0</span></p></td></tr>
@@ -62532,18 +67602,26 @@ the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/St
 <li><code>value</code> may contain typed arrays, both using <code>ArrayBuffer</code>s
 and <code>SharedArrayBuffer</code>s.</li>
 <li><code>value</code> may contain <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module"><code>WebAssembly.Module</code></a> instances.</li>
-<li><code>value</code> may not contain native (C++-backed) objects other than <code>MessagePort</code>s,
-<a href="#fs_class_filehandle"><code>FileHandle</code></a>s, and <a href="#crypto_class_keyobject"><code>KeyObject</code></a>s.</li>
+<li><code>value</code> may not contain native (C++-backed) objects other than:
+<ul>
+<li><a href="#fs_class_filehandle" class="type">&#x3C;FileHandle></a>s,</li>
+<li><a href="#perf_hooks_class_histogram" class="type">&#x3C;Histogram></a>s,</li>
+<li><a href="#crypto_class_keyobject" class="type">&#x3C;KeyObject></a>s,</li>
+<li><a href="#worker_threads_class_messageport" class="type">&#x3C;MessagePort></a>s,</li>
+<li><a href="#net_class_net_blocklist" class="type">&#x3C;net.BlockList></a>s,</li>
+<li><a href="#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a>es,</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
+</li>
+</ul>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
 
-port1.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(message));
+port1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message));
 
 <span class="hljs-keyword">const</span> circularData = {};
-circularData.foo = circularData;
+circularData.<span class="hljs-property">foo</span> = circularData;
 <span class="hljs-comment">// Prints: { foo: [Circular] }</span>
-port2.postMessage(circularData);</code></pre>
+port2.<span class="hljs-title function_">postMessage</span>(circularData);</code></pre>
 <p><code>transferList</code> may be a list of <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="#worker_threads_class_messageport"><code>MessagePort</code></a> and
 <a href="#fs_class_filehandle"><code>FileHandle</code></a> objects.
 After transferring, they will not be usable on the sending side of the channel
@@ -62554,27 +67632,27 @@ not supported.</p>
 from either thread. They cannot be listed in <code>transferList</code>.</p>
 <p><code>value</code> may still contain <code>ArrayBuffer</code> instances that are not in
 <code>transferList</code>; in that case, the underlying memory is copied rather than moved.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
 
-port1.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(message));
+port1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message));
 
-<span class="hljs-keyword">const</span> uint8Array = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>([ <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span> ]);
+<span class="hljs-keyword">const</span> uint8Array = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>([ <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span> ]);
 <span class="hljs-comment">// This posts a copy of `uint8Array`:</span>
-port2.postMessage(uint8Array);
+port2.<span class="hljs-title function_">postMessage</span>(uint8Array);
 <span class="hljs-comment">// This does not copy data, but renders `uint8Array` unusable:</span>
-port2.postMessage(uint8Array, [ uint8Array.buffer ]);
+port2.<span class="hljs-title function_">postMessage</span>(uint8Array, [ uint8Array.<span class="hljs-property">buffer</span> ]);
 
 <span class="hljs-comment">// The memory for the `sharedUint8Array` will be accessible from both the</span>
 <span class="hljs-comment">// original and the copy received by `.on('message')`:</span>
-<span class="hljs-keyword">const</span> sharedUint8Array = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(<span class="hljs-keyword">new</span> SharedArrayBuffer(<span class="hljs-number">4</span>));
-port2.postMessage(sharedUint8Array);
+<span class="hljs-keyword">const</span> sharedUint8Array = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">SharedArrayBuffer</span>(<span class="hljs-number">4</span>));
+port2.<span class="hljs-title function_">postMessage</span>(sharedUint8Array);
 
 <span class="hljs-comment">// This transfers a freshly created message port to the receiver.</span>
 <span class="hljs-comment">// This can be used, for example, to create communication channels between</span>
 <span class="hljs-comment">// multiple `Worker` threads that are children of the same parent thread.</span>
-<span class="hljs-keyword">const</span> otherChannel = <span class="hljs-keyword">new</span> MessageChannel();
-port2.postMessage({ <span class="hljs-attr">port</span>: otherChannel.port1 }, [ otherChannel.port1 ]);</code></pre>
+<span class="hljs-keyword">const</span> otherChannel = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+port2.<span class="hljs-title function_">postMessage</span>({ <span class="hljs-attr">port</span>: otherChannel.<span class="hljs-property">port1</span> }, [ otherChannel.<span class="hljs-property">port1</span> ]);</code></pre>
 <p>Because the object cloning uses the structured clone algorithm,
 non-enumerable properties, property accessors, and object prototypes are
 not preserved. In particular, <a href="buffer.html"><code>Buffer</code></a> objects will be read as
@@ -62583,7 +67661,7 @@ plain <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference
 posting without having side effects.</p>
 <p>For more information on the serialization and deserialization mechanisms
 behind this API, see the <a href="#v8_serialization_api">serialization API of the <code>v8</code> module</a>.</p>
-<h4>Considerations when transferring TypedArrays and Buffers<span><a class="mark" href="#worker_threads_considerations_when_transferring_typedarrays_and_buffers" id="worker_threads_considerations_when_transferring_typedarrays_and_buffers">#</a></span></h4>
+<h5>Considerations when transferring TypedArrays and Buffers<span><a class="mark" href="#worker_threads_considerations_when_transferring_typedarrays_and_buffers" id="worker_threads_considerations_when_transferring_typedarrays_and_buffers">#</a></span></h5>
 <p>All <code>TypedArray</code> and <code>Buffer</code> instances are views over an underlying
 <code>ArrayBuffer</code>. That is, it is the <code>ArrayBuffer</code> that actually stores
 the raw data while the <code>TypedArray</code> and <code>Buffer</code> objects provide a
@@ -62592,16 +67670,16 @@ for multiple views to be created over the same <code>ArrayBuffer</code> instance
 Great care must be taken when using a transfer list to transfer an
 <code>ArrayBuffer</code> as doing so will cause all <code>TypedArray</code> and <code>Buffer</code>
 instances that share that same <code>ArrayBuffer</code> to become unusable.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">10</span>);
 
-<span class="hljs-keyword">const</span> u1 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(ab);
-<span class="hljs-keyword">const</span> u2 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(ab);
+<span class="hljs-keyword">const</span> u1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(ab);
+<span class="hljs-keyword">const</span> u2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(ab);
 
-<span class="hljs-built_in">console</span>.log(u2.length);  <span class="hljs-comment">// prints 5</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u2.<span class="hljs-property">length</span>);  <span class="hljs-comment">// prints 5</span>
 
-port.postMessage(u1, [u1.buffer]);
+port.<span class="hljs-title function_">postMessage</span>(u1, [u1.<span class="hljs-property">buffer</span>]);
 
-<span class="hljs-built_in">console</span>.log(u2.length);  <span class="hljs-comment">// prints 0</span></code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u2.<span class="hljs-property">length</span>);  <span class="hljs-comment">// prints 0</span></code></pre>
 <p>For <code>Buffer</code> instances, specifically, whether the underlying
 <code>ArrayBuffer</code> can be transferred or cloned depends entirely on how
 instances were created, which often cannot be reliably determined.</p>
@@ -62621,7 +67699,7 @@ usage and possible security concerns.</p>
 <code>Buffer.alloc()</code> or <code>Buffer.allocUnsafeSlow()</code> can always be
 transferred but doing so will render all other existing views of
 those <code>ArrayBuffer</code>s unusable.</p>
-<h3><code>port.ref()</code><span><a class="mark" href="#worker_threads_port_ref" id="worker_threads_port_ref">#</a></span></h3>
+<h4><code>port.ref()</code><span><a class="mark" href="#worker_threads_port_ref" id="worker_threads_port_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62631,7 +67709,7 @@ behavior). If the port is <code>ref()</code>ed, calling <code>ref()</code> again
 <p>If listeners are attached or removed using <code>.on('message')</code>, the port will
 be <code>ref()</code>ed and <code>unref()</code>ed automatically depending on whether
 listeners for the event exist.</p>
-<h3><code>port.start()</code><span><a class="mark" href="#worker_threads_port_start" id="worker_threads_port_start">#</a></span></h3>
+<h4><code>port.start()</code><span><a class="mark" href="#worker_threads_port_start" id="worker_threads_port_start">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62643,7 +67721,7 @@ it is only useful for ignoring messages when no event listener is present.
 Node.js also diverges in its handling of <code>.onmessage</code>. Setting it will
 automatically call <code>.start()</code>, but unsetting it will let messages queue up
 until a new handler is set or the port is discarded.</p>
-<h3><code>port.unref()</code><span><a class="mark" href="#worker_threads_port_unref" id="worker_threads_port_unref">#</a></span></h3>
+<h4><code>port.unref()</code><span><a class="mark" href="#worker_threads_port_unref" id="worker_threads_port_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62653,7 +67731,7 @@ active handle in the event system. If the port is already <code>unref()</code>ed
 <p>If listeners are attached or removed using <code>.on('message')</code>, the port will
 be <code>ref()</code>ed and <code>unref()</code>ed automatically depending on whether
 listeners for the event exist.</p>
-<h2>Class: <code>Worker</code><span><a class="mark" href="#worker_threads_class_worker" id="worker_threads_class_worker">#</a></span></h2>
+</section><section><h3>Class: <code>Worker</code><span><a class="mark" href="#worker_threads_class_worker" id="worker_threads_class_worker">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62704,37 +67782,41 @@ and what kind of JavaScript values can be successfully transported through
 the thread barrier.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 <span class="hljs-keyword">const</span> {
-  Worker, MessageChannel, MessagePort, isMainThread, parentPort
+  <span class="hljs-title class_">Worker</span>, <span class="hljs-title class_">MessageChannel</span>, <span class="hljs-title class_">MessagePort</span>, isMainThread, parentPort
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename);
-  <span class="hljs-keyword">const</span> subChannel = <span class="hljs-keyword">new</span> MessageChannel();
-  worker.postMessage({ <span class="hljs-attr">hereIsYourPort</span>: subChannel.port1 }, [subChannel.port1]);
-  subChannel.port2.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'received:'</span>, value);
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
+  <span class="hljs-keyword">const</span> subChannel = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+  worker.<span class="hljs-title function_">postMessage</span>({ <span class="hljs-attr">hereIsYourPort</span>: subChannel.<span class="hljs-property">port1</span> }, [subChannel.<span class="hljs-property">port1</span>]);
+  subChannel.<span class="hljs-property">port2</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'received:'</span>, value);
   });
 } <span class="hljs-keyword">else</span> {
-  parentPort.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
-    assert(value.hereIsYourPort <span class="hljs-keyword">instanceof</span> MessagePort);
-    value.hereIsYourPort.postMessage(<span class="hljs-string">'the worker is sending this'</span>);
-    value.hereIsYourPort.close();
+  parentPort.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+    <span class="hljs-title function_">assert</span>(value.<span class="hljs-property">hereIsYourPort</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MessagePort</span>);
+    value.<span class="hljs-property">hereIsYourPort</span>.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'the worker is sending this'</span>);
+    value.<span class="hljs-property">hereIsYourPort</span>.<span class="hljs-title function_">close</span>();
   });
 }</code></pre>
-<h3><code>new Worker(filename[, options])</code><span><a class="mark" href="#worker_threads_new_worker_filename_options" id="worker_threads_new_worker_filename_options">#</a></span></h3>
+<h4><code>new Worker(filename[, options])</code><span><a class="mark" href="#worker_threads_new_worker_filename_options" id="worker_threads_new_worker_filename_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
+<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>data:</code> protocol.</p></td></tr>
+<tr><td>v14.9.0</td>
+<td><p>The <code>trackUnmanagedFds</code> option was set to <code>true</code> by default.</p></td></tr>
+<tr><td>v14.6.0</td>
 <td><p>The <code>trackUnmanagedFds</code> option was introduced.</p></td></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.0.0</td>
 <td><p>The <code>transferList</code> option was introduced.</p></td></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>resourceLimits</code> option was introduced.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.4.0, v12.16.0</td>
 <td><p>The <code>argv</code> option was introduced.</p></td></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>The <code>resourceLimits</code> option was introduced.</p></td></tr>
 <tr><td>v10.5.0</td>
 <td><p><span>Added in: v10.5.0</span></p></td></tr>
 </tbody></table>
@@ -62744,7 +67826,9 @@ the thread barrier.</p>
 <li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="#url_the_whatwg_url_api" class="type">&#x3C;URL></a> The path to the Worker’s main script or module. Must
 be either an absolute path or a relative path (i.e. relative to the
 current working directory) starting with <code>./</code> or <code>../</code>, or a WHATWG <code>URL</code>
-object using <code>file:</code> protocol.
+object using <code>file:</code> or <code>data:</code> protocol.
+When using a <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs"><code>data:</code> URL</a>, the data is interpreted based on MIME type using
+the <a href="#esm_data_imports">ECMAScript module loader</a>.
 If <code>options.eval</code> is <code>true</code>, this is a string containing JavaScript code
 rather than a path.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -62806,7 +67890,7 @@ Small values may lead to unusable Worker instances. <strong>Default:</strong> <c
 </ul>
 </li>
 </ul>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#worker_threads_event_error" id="worker_threads_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#worker_threads_event_error" id="worker_threads_event_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62815,7 +67899,7 @@ Small values may lead to unusable Worker instances. <strong>Default:</strong> <c
 </ul>
 <p>The <code>'error'</code> event is emitted if the worker thread throws an uncaught
 exception. In that case, the worker will be terminated.</p>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#worker_threads_event_exit" id="worker_threads_event_exit">#</a></span></h3>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#worker_threads_event_exit" id="worker_threads_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62827,7 +67911,7 @@ exited by calling <a href="#process_process_exit_code"><code>process.exit()</cod
 passed exit code. If the worker was terminated, the <code>exitCode</code> parameter will
 be <code>1</code>.</p>
 <p>This is the final event emitted by any <code>Worker</code> instance.</p>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#worker_threads_event_message_1" id="worker_threads_event_message_1">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#worker_threads_event_message_1" id="worker_threads_event_message_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62839,23 +67923,23 @@ be <code>1</code>.</p>
 See the <a href="#worker_threads_event_message"><code>port.on('message')</code></a> event for more details.</p>
 <p>All messages sent from the worker thread will be emitted before the
 <a href="#worker_threads_event_exit"><code>'exit'</code> event</a> is emitted on the <code>Worker</code> object.</p>
-<h3>Event: <code>'messageerror'</code><span><a class="mark" href="#worker_threads_event_messageerror_1" id="worker_threads_event_messageerror_1">#</a></span></h3>
+<h4>Event: <code>'messageerror'</code><span><a class="mark" href="#worker_threads_event_messageerror_1" id="worker_threads_event_messageerror_1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> An Error object</li>
 </ul>
 <p>The <code>'messageerror'</code> event is emitted when deserializing a message failed.</p>
-<h3>Event: <code>'online'</code><span><a class="mark" href="#worker_threads_event_online" id="worker_threads_event_online">#</a></span></h3>
+<h4>Event: <code>'online'</code><span><a class="mark" href="#worker_threads_event_online" id="worker_threads_event_online">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
 <p>The <code>'online'</code> event is emitted when the worker thread has started executing
 JavaScript code.</p>
-<h3><code>worker.getHeapSnapshot()</code><span><a class="mark" href="#worker_threads_worker_getheapsnapshot" id="worker_threads_worker_getheapsnapshot">#</a></span></h3>
+<h4><code>worker.getHeapSnapshot()</code><span><a class="mark" href="#worker_threads_worker_getheapsnapshot" id="worker_threads_worker_getheapsnapshot">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.9.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> A promise for a Readable Stream containing
@@ -62866,21 +67950,21 @@ See <a href="#v8_v8_getheapsnapshot"><code>v8.getHeapSnapshot()</code></a> for m
 <p>If the Worker thread is no longer running, which may occur before the
 <a href="#worker_threads_event_exit"><code>'exit'</code> event</a> is emitted, the returned <code>Promise</code> will be rejected
 immediately with an <a href="#ERR_WORKER_NOT_RUNNING"><code>ERR_WORKER_NOT_RUNNING</code></a> error.</p>
-<h3><code>worker.performance</code><span><a class="mark" href="#worker_threads_worker_performance" id="worker_threads_worker_performance">#</a></span></h3>
+<h4><code>worker.performance</code><span><a class="mark" href="#worker_threads_worker_performance" id="worker_threads_worker_performance">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.22.0</span>
+<span>Added in: v14.17.0</span>
 </div>
 <p>An object that can be used to query performance information from a worker
-instance. Similar to <a href="#perf_hooks.md#perf_hooks_perf_hooks_performance"><code>perf_hooks.performance</code></a>.</p>
-<h4><code>performance.eventLoopUtilization([utilization1[, utilization2]])</code><span><a class="mark" href="#worker_threads_performance_eventlooputilization_utilization1_utilization2" id="worker_threads_performance_eventlooputilization_utilization1_utilization2">#</a></span></h4>
+instance. Similar to <a href="#perf_hooks_perf_hooks_performance"><code>perf_hooks.performance</code></a>.</p>
+<h5><code>performance.eventLoopUtilization([utilization1[, utilization2]])</code><span><a class="mark" href="#worker_threads_performance_eventlooputilization_utilization1_utilization2" id="worker_threads_performance_eventlooputilization_utilization1_utilization2">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.22.0</span>
+<span>Added in: v14.17.0</span>
 </div>
 <ul>
 <li><code>utilization1</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to
-  <code>eventLoopUtilization()</code>.</li>
+<code>eventLoopUtilization()</code>.</li>
 <li><code>utilization2</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to
-  <code>eventLoopUtilization()</code> prior to <code>utilization1</code>.</li>
+<code>eventLoopUtilization()</code> prior to <code>utilization1</code>.</li>
 <li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>idle</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
@@ -62889,7 +67973,7 @@ instance. Similar to <a href="#perf_hooks.md#perf_hooks_perf_hooks_performance">
 </ul>
 </li>
 </ul>
-<p>The same call as <a href="perf_hooks.md#perf_hooks_performance_eventlooputilization_utilization1_utilization2"><code>perf_hooks</code> <code>eventLoopUtilization()</code></a>, except the values
+<p>The same call as <a href="#perf_hooks_performance_eventlooputilization_utilization1_utilization2"><code>perf_hooks</code> <code>eventLoopUtilization()</code></a>, except the values
 of the worker instance are returned.</p>
 <p>One difference is that, unlike the main thread, bootstrapping within a worker
 is done within the event loop. So the event loop utilization will be
@@ -62898,28 +67982,28 @@ immediately available once the worker's script begins execution.</p>
 stuck in bootstrap. The following examples shows how the worker's entire
 lifetime will never accumulate any <code>idle</code> time, but is still be able to process
 messages.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, isMainThread, parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, isMainThread, parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename);
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
   <span class="hljs-built_in">setInterval</span>(<span class="hljs-function">() =></span> {
-    worker.postMessage(<span class="hljs-string">'hi'</span>);
-    <span class="hljs-built_in">console</span>.log(worker.performance.eventLoopUtilization());
-  }, <span class="hljs-number">100</span>).unref();
+    worker.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'hi'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(worker.<span class="hljs-property">performance</span>.<span class="hljs-title function_">eventLoopUtilization</span>());
+  }, <span class="hljs-number">100</span>).<span class="hljs-title function_">unref</span>();
   <span class="hljs-keyword">return</span>;
 }
 
-parentPort.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'msg'</span>)).unref();
-(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">r</span>(<span class="hljs-params">n</span>) </span>{
+parentPort.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'msg'</span>)).<span class="hljs-title function_">unref</span>();
+(<span class="hljs-keyword">function</span> <span class="hljs-title function_">r</span>(<span class="hljs-params">n</span>) {
   <span class="hljs-keyword">if</span> (--n &#x3C; <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span>;
-  <span class="hljs-keyword">const</span> t = <span class="hljs-built_in">Date</span>.now();
-  <span class="hljs-keyword">while</span> (<span class="hljs-built_in">Date</span>.now() - t &#x3C; <span class="hljs-number">300</span>);
-  setImmediate(r, n);
+  <span class="hljs-keyword">const</span> t = <span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>();
+  <span class="hljs-keyword">while</span> (<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>() - t &#x3C; <span class="hljs-number">300</span>);
+  <span class="hljs-title function_">setImmediate</span>(r, n);
 })(<span class="hljs-number">10</span>);</code></pre>
 <p>The event loop utilization of a worker is available only after the <a href="#worker_threads_event_online"><code>'online'</code>
 event</a> emitted, and if called before this, or after the <a href="#worker_threads_event_exit"><code>'exit'</code>
 event</a>, then all properties have the value of <code>0</code>.</p>
-<h3><code>worker.postMessage(value[, transferList])</code><span><a class="mark" href="#worker_threads_worker_postmessage_value_transferlist" id="worker_threads_worker_postmessage_value_transferlist">#</a></span></h3>
+<h4><code>worker.postMessage(value[, transferList])</code><span><a class="mark" href="#worker_threads_worker_postmessage_value_transferlist" id="worker_threads_worker_postmessage_value_transferlist">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62930,7 +68014,7 @@ event</a>, then all properties have the value of <code>0</code>.</p>
 <p>Send a message to the worker that will be received via
 <a href="#worker_threads_event_message"><code>require('worker_threads').parentPort.on('message')</code></a>.
 See <a href="#worker_threads_port_postmessage_value_transferlist"><code>port.postMessage()</code></a> for more details.</p>
-<h3><code>worker.ref()</code><span><a class="mark" href="#worker_threads_worker_ref" id="worker_threads_worker_ref">#</a></span></h3>
+<h4><code>worker.ref()</code><span><a class="mark" href="#worker_threads_worker_ref" id="worker_threads_worker_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62938,9 +68022,9 @@ See <a href="#worker_threads_port_postmessage_value_transferlist"><code>port.pos
 <em>not</em> let the program exit if it's the only active handle left (the default
 behavior). If the worker is <code>ref()</code>ed, calling <code>ref()</code> again will have
 no effect.</p>
-<h3><code>worker.resourceLimits</code><span><a class="mark" href="#worker_threads_worker_resourcelimits_1" id="worker_threads_worker_resourcelimits_1">#</a></span></h3>
+<h4><code>worker.resourceLimits</code><span><a class="mark" href="#worker_threads_worker_resourcelimits_1" id="worker_threads_worker_resourcelimits_1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -62956,7 +68040,7 @@ no effect.</p>
 If the <code>resourceLimits</code> option was passed to the <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor,
 this matches its values.</p>
 <p>If the worker has stopped, the return value is an empty object.</p>
-<h3><code>worker.stderr</code><span><a class="mark" href="#worker_threads_worker_stderr" id="worker_threads_worker_stderr">#</a></span></h3>
+<h4><code>worker.stderr</code><span><a class="mark" href="#worker_threads_worker_stderr" id="worker_threads_worker_stderr">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62967,7 +68051,7 @@ this matches its values.</p>
 inside the worker thread. If <code>stderr: true</code> was not passed to the
 <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor, then data will be piped to the parent thread's
 <a href="#process_process_stderr"><code>process.stderr</code></a> stream.</p>
-<h3><code>worker.stdin</code><span><a class="mark" href="#worker_threads_worker_stdin" id="worker_threads_worker_stdin">#</a></span></h3>
+<h4><code>worker.stdin</code><span><a class="mark" href="#worker_threads_worker_stdin" id="worker_threads_worker_stdin">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62977,7 +68061,7 @@ inside the worker thread. If <code>stderr: true</code> was not passed to the
 <p>If <code>stdin: true</code> was passed to the <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor, this is a
 writable stream. The data written to this stream will be made available in
 the worker thread as <a href="#process_process_stdin"><code>process.stdin</code></a>.</p>
-<h3><code>worker.stdout</code><span><a class="mark" href="#worker_threads_worker_stdout" id="worker_threads_worker_stdout">#</a></span></h3>
+<h4><code>worker.stdout</code><span><a class="mark" href="#worker_threads_worker_stdout" id="worker_threads_worker_stdout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -62988,7 +68072,7 @@ the worker thread as <a href="#process_process_stdin"><code>process.stdin</code>
 inside the worker thread. If <code>stdout: true</code> was not passed to the
 <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor, then data will be piped to the parent thread's
 <a href="#process_process_stdout"><code>process.stdout</code></a> stream.</p>
-<h3><code>worker.terminate()</code><span><a class="mark" href="#worker_threads_worker_terminate" id="worker_threads_worker_terminate">#</a></span></h3>
+<h4><code>worker.terminate()</code><span><a class="mark" href="#worker_threads_worker_terminate" id="worker_threads_worker_terminate">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63006,7 +68090,7 @@ inside the worker thread. If <code>stdout: true</code> was not passed to the
 <p>Stop all JavaScript execution in the worker thread as soon as possible.
 Returns a Promise for the exit code that is fulfilled when the
 <a href="#worker_threads_event_exit"><code>'exit'</code> event</a> is emitted.</p>
-<h3><code>worker.threadId</code><span><a class="mark" href="#worker_threads_worker_threadid_1" id="worker_threads_worker_threadid_1">#</a></span></h3>
+<h4><code>worker.threadId</code><span><a class="mark" href="#worker_threads_worker_threadid_1" id="worker_threads_worker_threadid_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -63016,22 +68100,62 @@ Returns a Promise for the exit code that is fulfilled when the
 <p>An integer identifier for the referenced thread. Inside the worker thread,
 it is available as <a href="#worker_threads_worker_threadid"><code>require('worker_threads').threadId</code></a>.
 This value is unique for each <code>Worker</code> instance inside a single process.</p>
-<h3><code>worker.unref()</code><span><a class="mark" href="#worker_threads_worker_unref" id="worker_threads_worker_unref">#</a></span></h3>
+<h4><code>worker.unref()</code><span><a class="mark" href="#worker_threads_worker_unref" id="worker_threads_worker_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
 <p>Calling <code>unref()</code> on a worker will allow the thread to exit if this is the only
 active handle in the event system. If the worker is already <code>unref()</code>ed calling
 <code>unref()</code> again will have no effect.</p>
-<h1>Zlib<span><a class="mark" href="#zlib_zlib" id="zlib_zlib">#</a></span></h1>
+</section><section><h3>Notes<span><a class="mark" href="#worker_threads_notes" id="worker_threads_notes">#</a></span></h3>
+<h4>Synchronous blocking of stdio<span><a class="mark" href="#worker_threads_synchronous_blocking_of_stdio" id="worker_threads_synchronous_blocking_of_stdio">#</a></span></h4>
+<p><code>Worker</code>s utilize message passing via <a href="#worker_threads_class_messageport" class="type">&#x3C;MessagePort></a> to implement interactions
+with <code>stdio</code>. This means that <code>stdio</code> output originating from a <code>Worker</code> can
+get blocked by synchronous code on the receiving end that is blocking the
+Node.js event loop.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> {
+  <span class="hljs-title class_">Worker</span>,
+  isMainThread,
+} <span class="hljs-keyword">from</span> <span class="hljs-string">'worker_threads'</span>;
+
+<span class="hljs-keyword">if</span> (isMainThread) {
+  <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>));
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; <span class="hljs-number">1e10</span>; n++) {}
+} <span class="hljs-keyword">else</span> {
+  <span class="hljs-comment">// This output will be blocked by the for loop in the main thread.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo'</span>);
+}</code><code class="language-js cjs"><span class="hljs-meta">'use strict'</span>;
+
+<span class="hljs-keyword">const</span> {
+  <span class="hljs-title class_">Worker</span>,
+  isMainThread,
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+
+<span class="hljs-keyword">if</span> (isMainThread) {
+  <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; <span class="hljs-number">1e10</span>; n++) {}
+} <span class="hljs-keyword">else</span> {
+  <span class="hljs-comment">// This output will be blocked by the for loop in the main thread.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo'</span>);
+}</code></pre>
+<h4>Launching worker threads from preload scripts<span><a class="mark" href="#worker_threads_launching_worker_threads_from_preload_scripts" id="worker_threads_launching_worker_threads_from_preload_scripts">#</a></span></h4>
+<p>Take care when launching worker threads from preload scripts (scripts loaded
+and run using the <code>-r</code> command line flag). Unless the <code>execArgv</code> option is
+explicitly set, new Worker threads automatically inherit the command line flags
+from the running process and will preload the same preload scripts as the main
+thread. If the preload script unconditionally launches a worker thread, every
+thread spawned will spawn another until the application crashes.</p></section>
+        </section>
+<section><h2>Zlib<span><a class="mark" href="#zlib_zlib" id="zlib_zlib">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/zlib.js">lib/zlib.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/zlib.js">lib/zlib.js</a></p>
 <p>The <code>zlib</code> module provides compression functionality implemented using Gzip,
 Deflate/Inflate, and Brotli.</p>
 <p>To access it:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> zlib = <span class="hljs-built_in">require</span>(<span class="hljs-string">'zlib'</span>);</code></pre>
-<p>Compression and decompression are built around the Node.js <a href="stream.md">Streams API</a>.</p>
+<p>Compression and decompression are built around the Node.js <a href="stream.html">Streams API</a>.</p>
 <p>Compressing or decompressing a stream (such as a file) can be accomplished by
 piping the source stream through a <code>zlib</code> <code>Transform</code> stream into a destination
 stream:</p>
@@ -63042,67 +68166,67 @@ stream:</p>
   createWriteStream
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> gzip = createGzip();
-<span class="hljs-keyword">const</span> source = createReadStream(<span class="hljs-string">'input.txt'</span>);
-<span class="hljs-keyword">const</span> destination = createWriteStream(<span class="hljs-string">'input.txt.gz'</span>);
+<span class="hljs-keyword">const</span> gzip = <span class="hljs-title function_">createGzip</span>();
+<span class="hljs-keyword">const</span> source = <span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'input.txt'</span>);
+<span class="hljs-keyword">const</span> destination = <span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'input.txt.gz'</span>);
 
-pipeline(source, gzip, destination, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<span class="hljs-title function_">pipeline</span>(source, gzip, destination, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   }
 });
 
 <span class="hljs-comment">// Or, Promisified</span>
 
 <span class="hljs-keyword">const</span> { promisify } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> pipe = promisify(pipeline);
+<span class="hljs-keyword">const</span> pipe = <span class="hljs-title function_">promisify</span>(pipeline);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">do_gzip</span>(<span class="hljs-params">input, output</span>) </span>{
-  <span class="hljs-keyword">const</span> gzip = createGzip();
-  <span class="hljs-keyword">const</span> source = createReadStream(input);
-  <span class="hljs-keyword">const</span> destination = createWriteStream(output);
-  <span class="hljs-keyword">await</span> pipe(source, gzip, destination);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">do_gzip</span>(<span class="hljs-params">input, output</span>) {
+  <span class="hljs-keyword">const</span> gzip = <span class="hljs-title function_">createGzip</span>();
+  <span class="hljs-keyword">const</span> source = <span class="hljs-title function_">createReadStream</span>(input);
+  <span class="hljs-keyword">const</span> destination = <span class="hljs-title function_">createWriteStream</span>(output);
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">pipe</span>(source, gzip, destination);
 }
 
-do_gzip(<span class="hljs-string">'input.txt'</span>, <span class="hljs-string">'input.txt.gz'</span>)
-  .catch(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+<span class="hljs-title function_">do_gzip</span>(<span class="hljs-string">'input.txt'</span>, <span class="hljs-string">'input.txt.gz'</span>)
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   });</code></pre>
 <p>It is also possible to compress or decompress data in a single step:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { deflate, unzip } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'zlib'</span>);
 
 <span class="hljs-keyword">const</span> input = <span class="hljs-string">'.................................'</span>;
-deflate(input, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
+<span class="hljs-title function_">deflate</span>(input, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   }
-  <span class="hljs-built_in">console</span>.log(buffer.toString(<span class="hljs-string">'base64'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buffer.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'base64'</span>));
 });
 
-<span class="hljs-keyword">const</span> buffer = Buffer.from(<span class="hljs-string">'eJzT0yMAAGTvBe8='</span>, <span class="hljs-string">'base64'</span>);
-unzip(buffer, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'eJzT0yMAAGTvBe8='</span>, <span class="hljs-string">'base64'</span>);
+<span class="hljs-title function_">unzip</span>(buffer, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   }
-  <span class="hljs-built_in">console</span>.log(buffer.toString());
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buffer.<span class="hljs-title function_">toString</span>());
 });
 
 <span class="hljs-comment">// Or, Promisified</span>
 
 <span class="hljs-keyword">const</span> { promisify } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> do_unzip = promisify(unzip);
+<span class="hljs-keyword">const</span> do_unzip = <span class="hljs-title function_">promisify</span>(unzip);
 
-do_unzip(buffer)
-  .then(<span class="hljs-function">(<span class="hljs-params">buf</span>) =></span> <span class="hljs-built_in">console</span>.log(buf.toString()))
-  .catch(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+<span class="hljs-title function_">do_unzip</span>(buffer)
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">buf</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>()))
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   });</code></pre>
-<h2>Threadpool usage and performance considerations<span><a class="mark" href="#zlib_threadpool_usage_and_performance_considerations" id="zlib_threadpool_usage_and_performance_considerations">#</a></span></h2>
+<section><h3>Threadpool usage and performance considerations<span><a class="mark" href="#zlib_threadpool_usage_and_performance_considerations" id="zlib_threadpool_usage_and_performance_considerations">#</a></span></h3>
 <p>All <code>zlib</code> APIs, except those that are explicitly synchronous, use the Node.js
 internal threadpool. This can lead to surprising effects and performance
 limitations in some applications.</p>
@@ -63110,18 +68234,18 @@ limitations in some applications.</p>
 significant memory fragmentation.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> zlib = <span class="hljs-built_in">require</span>(<span class="hljs-string">'zlib'</span>);
 
-<span class="hljs-keyword">const</span> payload = Buffer.from(<span class="hljs-string">'This is some data'</span>);
+<span class="hljs-keyword">const</span> payload = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'This is some data'</span>);
 
 <span class="hljs-comment">// WARNING: DO NOT DO THIS!</span>
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">30000</span>; ++i) {
-  zlib.deflate(payload, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {});
+  zlib.<span class="hljs-title function_">deflate</span>(payload, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {});
 }</code></pre>
 <p>In the preceding example, 30,000 deflate instances are created concurrently.
 Because of how some operating systems handle memory allocation and
 deallocation, this may lead to to significant memory fragmentation.</p>
 <p>It is strongly recommended that the results of compression
 operations be cached to avoid duplication of effort.</p>
-<h2>Compressing HTTP requests and responses<span><a class="mark" href="#zlib_compressing_http_requests_and_responses" id="zlib_compressing_http_requests_and_responses">#</a></span></h2>
+</section><section><h3>Compressing HTTP requests and responses<span><a class="mark" href="#zlib_compressing_http_requests_and_responses" id="zlib_compressing_http_requests_and_responses">#</a></span></h3>
 <p>The <code>zlib</code> module can be used to implement support for the <code>gzip</code>, <code>deflate</code>
 and <code>br</code> content-encoding mechanisms defined by
 <a href="https://tools.ietf.org/html/rfc7230#section-4.2">HTTP</a>.</p>
@@ -63139,33 +68263,33 @@ tradeoffs involved in <code>zlib</code> usage.</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> request = http.get({ <span class="hljs-attr">host</span>: <span class="hljs-string">'example.com'</span>,
+<span class="hljs-keyword">const</span> request = http.<span class="hljs-title function_">get</span>({ <span class="hljs-attr">host</span>: <span class="hljs-string">'example.com'</span>,
                            <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
                            <span class="hljs-attr">port</span>: <span class="hljs-number">80</span>,
                            <span class="hljs-attr">headers</span>: { <span class="hljs-string">'Accept-Encoding'</span>: <span class="hljs-string">'br,gzip,deflate'</span> } });
-request.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">response</span>) =></span> {
-  <span class="hljs-keyword">const</span> output = fs.createWriteStream(<span class="hljs-string">'example.com_index.html'</span>);
+request.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">response</span>) =></span> {
+  <span class="hljs-keyword">const</span> output = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'example.com_index.html'</span>);
 
-  <span class="hljs-keyword">const</span> onError = <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">const</span> <span class="hljs-title function_">onError</span> = (<span class="hljs-params">err</span>) => {
     <span class="hljs-keyword">if</span> (err) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-      process.exitCode = <span class="hljs-number">1</span>;
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+      process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
     }
   };
 
-  <span class="hljs-keyword">switch</span> (response.headers[<span class="hljs-string">'content-encoding'</span>]) {
+  <span class="hljs-keyword">switch</span> (response.<span class="hljs-property">headers</span>[<span class="hljs-string">'content-encoding'</span>]) {
     <span class="hljs-keyword">case</span> <span class="hljs-string">'br'</span>:
-      pipeline(response, zlib.createBrotliDecompress(), output, onError);
+      <span class="hljs-title function_">pipeline</span>(response, zlib.<span class="hljs-title function_">createBrotliDecompress</span>(), output, onError);
       <span class="hljs-keyword">break</span>;
     <span class="hljs-comment">// Or, just use zlib.createUnzip() to handle both of the following cases:</span>
     <span class="hljs-keyword">case</span> <span class="hljs-string">'gzip'</span>:
-      pipeline(response, zlib.createGunzip(), output, onError);
+      <span class="hljs-title function_">pipeline</span>(response, zlib.<span class="hljs-title function_">createGunzip</span>(), output, onError);
       <span class="hljs-keyword">break</span>;
     <span class="hljs-keyword">case</span> <span class="hljs-string">'deflate'</span>:
-      pipeline(response, zlib.createInflate(), output, onError);
+      <span class="hljs-title function_">pipeline</span>(response, zlib.<span class="hljs-title function_">createInflate</span>(), output, onError);
       <span class="hljs-keyword">break</span>;
-    <span class="hljs-keyword">default</span>:
-      pipeline(response, output, onError);
+    <span class="hljs-attr">default</span>:
+      <span class="hljs-title function_">pipeline</span>(response, output, onError);
       <span class="hljs-keyword">break</span>;
   }
 });</code></pre>
@@ -63177,70 +68301,70 @@ request.on(<span class="hljs-string">'response'</span>, <span class="hljs-functi
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-http.createServer(<span class="hljs-function">(<span class="hljs-params">request, response</span>) =></span> {
-  <span class="hljs-keyword">const</span> raw = fs.createReadStream(<span class="hljs-string">'index.html'</span>);
+http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">request, response</span>) =></span> {
+  <span class="hljs-keyword">const</span> raw = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'index.html'</span>);
   <span class="hljs-comment">// Store both a compressed and an uncompressed version of the resource.</span>
-  response.setHeader(<span class="hljs-string">'Vary'</span>, <span class="hljs-string">'Accept-Encoding'</span>);
-  <span class="hljs-keyword">let</span> acceptEncoding = request.headers[<span class="hljs-string">'accept-encoding'</span>];
+  response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Vary'</span>, <span class="hljs-string">'Accept-Encoding'</span>);
+  <span class="hljs-keyword">let</span> acceptEncoding = request.<span class="hljs-property">headers</span>[<span class="hljs-string">'accept-encoding'</span>];
   <span class="hljs-keyword">if</span> (!acceptEncoding) {
     acceptEncoding = <span class="hljs-string">''</span>;
   }
 
-  <span class="hljs-keyword">const</span> onError = <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">const</span> <span class="hljs-title function_">onError</span> = (<span class="hljs-params">err</span>) => {
     <span class="hljs-keyword">if</span> (err) {
       <span class="hljs-comment">// If an error occurs, there's not much we can do because</span>
       <span class="hljs-comment">// the server has already sent the 200 response code and</span>
       <span class="hljs-comment">// some amount of data has already been sent to the client.</span>
       <span class="hljs-comment">// The best we can do is terminate the response immediately</span>
       <span class="hljs-comment">// and log the error.</span>
-      response.end();
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
+      response.<span class="hljs-title function_">end</span>();
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
     }
   };
 
   <span class="hljs-comment">// Note: This is not a conformant accept-encoding parser.</span>
   <span class="hljs-comment">// See https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3</span>
-  <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bdeflate\b/</span>.test(acceptEncoding)) {
-    response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'deflate'</span> });
-    pipeline(raw, zlib.createDeflate(), response, onError);
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bgzip\b/</span>.test(acceptEncoding)) {
-    response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'gzip'</span> });
-    pipeline(raw, zlib.createGzip(), response, onError);
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bbr\b/</span>.test(acceptEncoding)) {
-    response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'br'</span> });
-    pipeline(raw, zlib.createBrotliCompress(), response, onError);
+  <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bdeflate\b/</span>.<span class="hljs-title function_">test</span>(acceptEncoding)) {
+    response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'deflate'</span> });
+    <span class="hljs-title function_">pipeline</span>(raw, zlib.<span class="hljs-title function_">createDeflate</span>(), response, onError);
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bgzip\b/</span>.<span class="hljs-title function_">test</span>(acceptEncoding)) {
+    response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'gzip'</span> });
+    <span class="hljs-title function_">pipeline</span>(raw, zlib.<span class="hljs-title function_">createGzip</span>(), response, onError);
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bbr\b/</span>.<span class="hljs-title function_">test</span>(acceptEncoding)) {
+    response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'br'</span> });
+    <span class="hljs-title function_">pipeline</span>(raw, zlib.<span class="hljs-title function_">createBrotliCompress</span>(), response, onError);
   } <span class="hljs-keyword">else</span> {
-    response.writeHead(<span class="hljs-number">200</span>, {});
-    pipeline(raw, response, onError);
+    response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, {});
+    <span class="hljs-title function_">pipeline</span>(raw, response, onError);
   }
-}).listen(<span class="hljs-number">1337</span>);</code></pre>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
 <p>By default, the <code>zlib</code> methods will throw an error when decompressing
 truncated data. However, if it is known that the data is incomplete, or
 the desire is to inspect only the beginning of a compressed file, it is
 possible to suppress the default error handling by changing the flushing
 method that is used to decompress the last chunk of input data:</p>
 <pre><code class="language-js"><span class="hljs-comment">// This is a truncated version of the buffer from the above examples</span>
-<span class="hljs-keyword">const</span> buffer = Buffer.from(<span class="hljs-string">'eJzT0yMA'</span>, <span class="hljs-string">'base64'</span>);
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'eJzT0yMA'</span>, <span class="hljs-string">'base64'</span>);
 
-zlib.unzip(
+zlib.<span class="hljs-title function_">unzip</span>(
   buffer,
   <span class="hljs-comment">// For Brotli, the equivalent is zlib.constants.BROTLI_OPERATION_FLUSH.</span>
-  { <span class="hljs-attr">finishFlush</span>: zlib.constants.Z_SYNC_FLUSH },
+  { <span class="hljs-attr">finishFlush</span>: zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">Z_SYNC_FLUSH</span> },
   <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-      process.exitCode = <span class="hljs-number">1</span>;
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+      process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
     }
-    <span class="hljs-built_in">console</span>.log(buffer.toString());
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buffer.<span class="hljs-title function_">toString</span>());
   });</code></pre>
 <p>This will not change the behavior in other error-throwing situations, e.g.
 when the input data has an invalid format. Using this method, it will not be
 possible to determine whether the input ended prematurely or lacks the
 integrity checks, making it necessary to manually check that the
 decompressed result is valid.</p>
-<h2>Memory usage tuning<span><a class="mark" href="#zlib_memory_usage_tuning" id="zlib_memory_usage_tuning">#</a></span></h2>
+</section><section><h3>Memory usage tuning<span><a class="mark" href="#zlib_memory_usage_tuning" id="zlib_memory_usage_tuning">#</a></span></h3>
 
-<h3>For zlib-based streams<span><a class="mark" href="#zlib_for_zlib_based_streams" id="zlib_for_zlib_based_streams">#</a></span></h3>
+<h4>For zlib-based streams<span><a class="mark" href="#zlib_for_zlib_based_streams" id="zlib_for_zlib_based_streams">#</a></span></h4>
 <p>From <code>zlib/zconf.h</code>, modified for Node.js usage:</p>
 <p>The memory requirements for deflate are (in bytes):</p>
 <!-- eslint-disable semi -->
@@ -63264,7 +68388,7 @@ compression, but will be much faster.</p>
 fewer calls to <code>zlib</code> because it will be able to process more data on
 each <code>write</code> operation. So, this is another factor that affects the
 speed, at the cost of memory usage.</p>
-<h3>For Brotli-based streams<span><a class="mark" href="#zlib_for_brotli_based_streams" id="zlib_for_brotli_based_streams">#</a></span></h3>
+<h4>For Brotli-based streams<span><a class="mark" href="#zlib_for_brotli_based_streams" id="zlib_for_brotli_based_streams">#</a></span></h4>
 <p>There are equivalents to the zlib options for Brotli-based streams, although
 these options have different ranges than the zlib ones:</p>
 <ul>
@@ -63272,7 +68396,7 @@ these options have different ranges than the zlib ones:</p>
 <li>zlib’s <code>windowBits</code> option matches Brotli’s <code>BROTLI_PARAM_LGWIN</code> option.</li>
 </ul>
 <p>See <a href="#zlib_brotli_constants">below</a> for more details on Brotli-specific options.</p>
-<h2>Flushing<span><a class="mark" href="#zlib_flushing" id="zlib_flushing">#</a></span></h2>
+</section><section><h3>Flushing<span><a class="mark" href="#zlib_flushing" id="zlib_flushing">#</a></span></h3>
 <p>Calling <a href="#zlib_zlib_flush_kind_callback"><code>.flush()</code></a> on a compression stream will make <code>zlib</code> return as much
 output as currently possible. This may come at the cost of degraded compression
 quality, but can be useful when data needs to be available as soon as possible.</p>
@@ -63282,13 +68406,13 @@ HTTP response to the client:</p>
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 <span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-http.createServer(<span class="hljs-function">(<span class="hljs-params">request, response</span>) =></span> {
+http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">request, response</span>) =></span> {
   <span class="hljs-comment">// For the sake of simplicity, the Accept-Encoding checks are omitted.</span>
-  response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'content-encoding'</span>: <span class="hljs-string">'gzip'</span> });
-  <span class="hljs-keyword">const</span> output = zlib.createGzip();
+  response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'content-encoding'</span>: <span class="hljs-string">'gzip'</span> });
+  <span class="hljs-keyword">const</span> output = zlib.<span class="hljs-title function_">createGzip</span>();
   <span class="hljs-keyword">let</span> i;
 
-  pipeline(output, response, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-title function_">pipeline</span>(output, response, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) {
       <span class="hljs-comment">// If an error occurs, there's not much we can do because</span>
       <span class="hljs-comment">// the server has already sent the 200 response code and</span>
@@ -63296,27 +68420,27 @@ http.createServer(<span class="hljs-function">(<span class="hljs-params">request
       <span class="hljs-comment">// The best we can do is terminate the response immediately</span>
       <span class="hljs-comment">// and log the error.</span>
       <span class="hljs-built_in">clearInterval</span>(i);
-      response.end();
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
+      response.<span class="hljs-title function_">end</span>();
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
     }
   });
 
   i = <span class="hljs-built_in">setInterval</span>(<span class="hljs-function">() =></span> {
-    output.write(<span class="hljs-string">`The current time is <span class="hljs-subst">${<span class="hljs-built_in">Date</span>()}</span>\n`</span>, <span class="hljs-function">() =></span> {
+    output.<span class="hljs-title function_">write</span>(<span class="hljs-string">`The current time is <span class="hljs-subst">${<span class="hljs-built_in">Date</span>()}</span>\n`</span>, <span class="hljs-function">() =></span> {
       <span class="hljs-comment">// The data has been passed to zlib, but the compression algorithm may</span>
       <span class="hljs-comment">// have decided to buffer the data for more efficient compression.</span>
       <span class="hljs-comment">// Calling .flush() will make the data available as soon as the client</span>
       <span class="hljs-comment">// is ready to receive it.</span>
-      output.flush();
+      output.<span class="hljs-title function_">flush</span>();
     });
   }, <span class="hljs-number">1000</span>);
-}).listen(<span class="hljs-number">1337</span>);</code></pre>
-<h2>Constants<span><a class="mark" href="#zlib_constants" id="zlib_constants">#</a></span></h2>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
+</section><section><h3>Constants<span><a class="mark" href="#zlib_constants" id="zlib_constants">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 
-<h3>zlib constants<span><a class="mark" href="#zlib_zlib_constants" id="zlib_zlib_constants">#</a></span></h3>
+<h4>zlib constants<span><a class="mark" href="#zlib_zlib_constants" id="zlib_zlib_constants">#</a></span></h4>
 <p>All of the constants defined in <code>zlib.h</code> are also defined on
 <code>require('zlib').constants</code>. In the normal course of operations, it will not be
 necessary to use these constants. They are documented so that their presence is
@@ -63364,13 +68488,13 @@ events.</p>
 <li><code>zlib.constants.Z_FIXED</code></li>
 <li><code>zlib.constants.Z_DEFAULT_STRATEGY</code></li>
 </ul>
-<h3>Brotli constants<span><a class="mark" href="#zlib_brotli_constants" id="zlib_brotli_constants">#</a></span></h3>
+<h4>Brotli constants<span><a class="mark" href="#zlib_brotli_constants" id="zlib_brotli_constants">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <p>There are several options and other constants available for Brotli-based
 streams:</p>
-<h4>Flush operations<span><a class="mark" href="#zlib_flush_operations" id="zlib_flush_operations">#</a></span></h4>
+<h5>Flush operations<span><a class="mark" href="#zlib_flush_operations" id="zlib_flush_operations">#</a></span></h5>
 <p>The following values are valid flush operations for Brotli-based streams:</p>
 <ul>
 <li><code>zlib.constants.BROTLI_OPERATION_PROCESS</code> (default for all operations)</li>
@@ -63385,7 +68509,7 @@ the Node.js API.</li>
 </ul>
 </li>
 </ul>
-<h4>Compressor options<span><a class="mark" href="#zlib_compressor_options" id="zlib_compressor_options">#</a></span></h4>
+<h5>Compressor options<span><a class="mark" href="#zlib_compressor_options" id="zlib_compressor_options">#</a></span></h5>
 <p>There are several options that can be set on Brotli encoders, affecting
 compression efficiency and speed. Both the keys and the values can be accessed
 as properties of the <code>zlib.constants</code> object.</p>
@@ -63450,7 +68574,7 @@ Brotli format as standardized in <a href="https://www.rfc-editor.org/rfc/rfc7932
 </ul>
 </li>
 </ul>
-<h4>Decompressor options<span><a class="mark" href="#zlib_decompressor_options" id="zlib_decompressor_options">#</a></span></h4>
+<h5>Decompressor options<span><a class="mark" href="#zlib_decompressor_options" id="zlib_decompressor_options">#</a></span></h5>
 <p>These advanced options are available for controlling decompression:</p>
 <ul>
 <li><code>BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION</code>
@@ -63465,12 +68589,12 @@ Brotli format as standardized in <a href="https://www.rfc-editor.org/rfc/rfc7932
 </ul>
 </li>
 </ul>
-<h2>Class: <code>Options</code><span><a class="mark" href="#zlib_class_options" id="zlib_class_options">#</a></span></h2>
+</section><section><h3>Class: <code>Options</code><span><a class="mark" href="#zlib_class_options" id="zlib_class_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0, v12.19.0</td>
 <td><p>The <code>maxOutputLength</code> option is supported now.</p></td></tr>
 <tr><td>v9.4.0</td>
 <td><p>The <code>dictionary</code> option can be an <code>ArrayBuffer</code>.</p></td></tr>
@@ -63503,12 +68627,12 @@ empty dictionary by default)</li>
 </ul>
 <p>See the <a href="https://zlib.net/manual.html#Advanced"><code>deflateInit2</code> and <code>inflateInit2</code></a> documentation for more
 information.</p>
-<h2>Class: <code>BrotliOptions</code><span><a class="mark" href="#zlib_class_brotlioptions" id="zlib_class_brotlioptions">#</a></span></h2>
+</section><section><h3>Class: <code>BrotliOptions</code><span><a class="mark" href="#zlib_class_brotlioptions" id="zlib_class_brotlioptions">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>The <code>maxOutputLength</code> option is supported now.</p></td></tr>
 <tr><td>v11.7.0</td>
 <td><p><span>Added in: v11.7.0</span></p></td></tr>
@@ -63526,35 +68650,35 @@ information.</p>
 <a href="#zlib_convenience_methods">convenience methods</a>. <strong>Default:</strong> <a href="#buffer_buffer_kmaxlength"><code>buffer.kMaxLength</code></a></li>
 </ul>
 <p>For example:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> stream = zlib.createBrotliCompress({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> stream = zlib.<span class="hljs-title function_">createBrotliCompress</span>({
   <span class="hljs-attr">chunkSize</span>: <span class="hljs-number">32</span> * <span class="hljs-number">1024</span>,
   <span class="hljs-attr">params</span>: {
-    [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
-    [zlib.constants.BROTLI_PARAM_QUALITY]: <span class="hljs-number">4</span>,
-    [zlib.constants.BROTLI_PARAM_SIZE_HINT]: fs.statSync(inputFile).size
+    [zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">BROTLI_PARAM_MODE</span>]: zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">BROTLI_MODE_TEXT</span>,
+    [zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">BROTLI_PARAM_QUALITY</span>]: <span class="hljs-number">4</span>,
+    [zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">BROTLI_PARAM_SIZE_HINT</span>]: fs.<span class="hljs-title function_">statSync</span>(inputFile).<span class="hljs-property">size</span>
   }
 });</code></pre>
-<h2>Class: <code>zlib.BrotliCompress</code><span><a class="mark" href="#zlib_class_zlib_brotlicompress" id="zlib_class_zlib_brotlicompress">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.BrotliCompress</code><span><a class="mark" href="#zlib_class_zlib_brotlicompress" id="zlib_class_zlib_brotlicompress">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <p>Compress data using the Brotli algorithm.</p>
-<h2>Class: <code>zlib.BrotliDecompress</code><span><a class="mark" href="#zlib_class_zlib_brotlidecompress" id="zlib_class_zlib_brotlidecompress">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.BrotliDecompress</code><span><a class="mark" href="#zlib_class_zlib_brotlidecompress" id="zlib_class_zlib_brotlidecompress">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <p>Decompress data using the Brotli algorithm.</p>
-<h2>Class: <code>zlib.Deflate</code><span><a class="mark" href="#zlib_class_zlib_deflate" id="zlib_class_zlib_deflate">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Deflate</code><span><a class="mark" href="#zlib_class_zlib_deflate" id="zlib_class_zlib_deflate">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>Compress data using deflate.</p>
-<h2>Class: <code>zlib.DeflateRaw</code><span><a class="mark" href="#zlib_class_zlib_deflateraw" id="zlib_class_zlib_deflateraw">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.DeflateRaw</code><span><a class="mark" href="#zlib_class_zlib_deflateraw" id="zlib_class_zlib_deflateraw">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>Compress data using deflate, and do not append a <code>zlib</code> header.</p>
-<h2>Class: <code>zlib.Gunzip</code><span><a class="mark" href="#zlib_class_zlib_gunzip" id="zlib_class_zlib_gunzip">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Gunzip</code><span><a class="mark" href="#zlib_class_zlib_gunzip" id="zlib_class_zlib_gunzip">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63571,12 +68695,12 @@ information.</p>
 </details>
 </div>
 <p>Decompress a gzip stream.</p>
-<h2>Class: <code>zlib.Gzip</code><span><a class="mark" href="#zlib_class_zlib_gzip" id="zlib_class_zlib_gzip">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Gzip</code><span><a class="mark" href="#zlib_class_zlib_gzip" id="zlib_class_zlib_gzip">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>Compress data using gzip.</p>
-<h2>Class: <code>zlib.Inflate</code><span><a class="mark" href="#zlib_class_zlib_inflate" id="zlib_class_zlib_inflate">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Inflate</code><span><a class="mark" href="#zlib_class_zlib_inflate" id="zlib_class_zlib_inflate">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63589,7 +68713,7 @@ information.</p>
 </details>
 </div>
 <p>Decompress a deflate stream.</p>
-<h2>Class: <code>zlib.InflateRaw</code><span><a class="mark" href="#zlib_class_zlib_inflateraw" id="zlib_class_zlib_inflateraw">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.InflateRaw</code><span><a class="mark" href="#zlib_class_zlib_inflateraw" id="zlib_class_zlib_inflateraw">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63604,18 +68728,18 @@ information.</p>
 </details>
 </div>
 <p>Decompress a raw deflate stream.</p>
-<h2>Class: <code>zlib.Unzip</code><span><a class="mark" href="#zlib_class_zlib_unzip" id="zlib_class_zlib_unzip">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Unzip</code><span><a class="mark" href="#zlib_class_zlib_unzip" id="zlib_class_zlib_unzip">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>Decompress either a Gzip- or Deflate-compressed stream by auto-detecting
 the header.</p>
-<h2>Class: <code>zlib.ZlibBase</code><span><a class="mark" href="#zlib_class_zlib_zlibbase" id="zlib_class_zlib_zlibbase">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.ZlibBase</code><span><a class="mark" href="#zlib_class_zlib_zlibbase" id="zlib_class_zlib_zlibbase">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.7.0</td>
+<tr><td>v11.7.0, v10.16.0</td>
 <td><p>This class was renamed from <code>Zlib</code> to <code>ZlibBase</code>.</p></td></tr>
 <tr><td>v0.5.8</td>
 <td><p><span>Added in: v0.5.8</span></p></td></tr>
@@ -63626,7 +68750,7 @@ the header.</p>
 class of the compressor/decompressor classes.</p>
 <p>This class inherits from <a href="#stream_class_stream_transform"><code>stream.Transform</code></a>, allowing <code>zlib</code> objects to be
 used in pipes and similar stream operations.</p>
-<h3><code>zlib.bytesRead</code><span><a class="mark" href="#zlib_zlib_bytesread" id="zlib_zlib_bytesread">#</a></span></h3>
+<h4><code>zlib.bytesRead</code><span><a class="mark" href="#zlib_zlib_bytesread" id="zlib_zlib_bytesread">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.1.0</span><span>Deprecated since: v10.0.0</span>
 </div>
@@ -63638,7 +68762,7 @@ used in pipes and similar stream operations.</p>
 because it also made sense to interpret the value as the number of bytes
 read by the engine, but is inconsistent with other streams in Node.js that
 expose values under these names.</p>
-<h3><code>zlib.bytesWritten</code><span><a class="mark" href="#zlib_zlib_byteswritten" id="zlib_zlib_byteswritten">#</a></span></h3>
+<h4><code>zlib.bytesWritten</code><span><a class="mark" href="#zlib_zlib_byteswritten" id="zlib_zlib_byteswritten">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -63648,7 +68772,7 @@ expose values under these names.</p>
 <p>The <code>zlib.bytesWritten</code> property specifies the number of bytes written to
 the engine, before the bytes are processed (compressed or decompressed,
 as appropriate for the derived class).</p>
-<h3><code>zlib.close([callback])</code><span><a class="mark" href="#zlib_zlib_close_callback" id="zlib_zlib_close_callback">#</a></span></h3>
+<h4><code>zlib.close([callback])</code><span><a class="mark" href="#zlib_zlib_close_callback" id="zlib_zlib_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -63656,7 +68780,7 @@ as appropriate for the derived class).</p>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <p>Close the underlying handle.</p>
-<h3><code>zlib.flush([kind, ]callback)</code><span><a class="mark" href="#zlib_zlib_flush_kind_callback" id="zlib_zlib_flush_kind_callback">#</a></span></h3>
+<h4><code>zlib.flush([kind, ]callback)</code><span><a class="mark" href="#zlib_zlib_flush_kind_callback" id="zlib_zlib_flush_kind_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -63671,7 +68795,7 @@ impact the effectiveness of the compression algorithm.</p>
 perform flushing of any kind on the streams level. Rather, it behaves like a
 normal call to <code>.write()</code>, i.e. it will be queued up behind other pending
 writes and will only produce output when data is being read from the stream.</p>
-<h3><code>zlib.params(level, strategy, callback)</code><span><a class="mark" href="#zlib_zlib_params_level_strategy_callback" id="zlib_zlib_params_level_strategy_callback">#</a></span></h3>
+<h4><code>zlib.params(level, strategy, callback)</code><span><a class="mark" href="#zlib_zlib_params_level_strategy_callback" id="zlib_zlib_params_level_strategy_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -63683,34 +68807,34 @@ writes and will only produce output when data is being read from the stream.</p>
 <p>This function is only available for zlib-based streams, i.e. not Brotli.</p>
 <p>Dynamically update the compression level and compression strategy.
 Only applicable to deflate algorithm.</p>
-<h3><code>zlib.reset()</code><span><a class="mark" href="#zlib_zlib_reset" id="zlib_zlib_reset">#</a></span></h3>
+<h4><code>zlib.reset()</code><span><a class="mark" href="#zlib_zlib_reset" id="zlib_zlib_reset">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
 <p>Reset the compressor/decompressor to factory defaults. Only applicable to
 the inflate and deflate algorithms.</p>
-<h2><code>zlib.constants</code><span><a class="mark" href="#zlib_zlib_constants_1" id="zlib_zlib_constants_1">#</a></span></h2>
+</section><section><h3><code>zlib.constants</code><span><a class="mark" href="#zlib_zlib_constants_1" id="zlib_zlib_constants_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v7.0.0</span>
 </div>
 <p>Provides an object enumerating Zlib-related constants.</p>
-<h2><code>zlib.createBrotliCompress([options])</code><span><a class="mark" href="#zlib_zlib_createbrotlicompress_options" id="zlib_zlib_createbrotlicompress_options">#</a></span></h2>
+</section><section><h3><code>zlib.createBrotliCompress([options])</code><span><a class="mark" href="#zlib_zlib_createbrotlicompress_options" id="zlib_zlib_createbrotlicompress_options">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_brotlicompress"><code>BrotliCompress</code></a> object.</p>
-<h2><code>zlib.createBrotliDecompress([options])</code><span><a class="mark" href="#zlib_zlib_createbrotlidecompress_options" id="zlib_zlib_createbrotlidecompress_options">#</a></span></h2>
+</section><section><h3><code>zlib.createBrotliDecompress([options])</code><span><a class="mark" href="#zlib_zlib_createbrotlidecompress_options" id="zlib_zlib_createbrotlidecompress_options">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_brotlidecompress"><code>BrotliDecompress</code></a> object.</p>
-<h2><code>zlib.createDeflate([options])</code><span><a class="mark" href="#zlib_zlib_createdeflate_options" id="zlib_zlib_createdeflate_options">#</a></span></h2>
+</section><section><h3><code>zlib.createDeflate([options])</code><span><a class="mark" href="#zlib_zlib_createdeflate_options" id="zlib_zlib_createdeflate_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -63718,7 +68842,7 @@ the inflate and deflate algorithms.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_deflate"><code>Deflate</code></a> object.</p>
-<h2><code>zlib.createDeflateRaw([options])</code><span><a class="mark" href="#zlib_zlib_createdeflateraw_options" id="zlib_zlib_createdeflateraw_options">#</a></span></h2>
+</section><section><h3><code>zlib.createDeflateRaw([options])</code><span><a class="mark" href="#zlib_zlib_createdeflateraw_options" id="zlib_zlib_createdeflateraw_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -63732,7 +68856,7 @@ to 9 if was initially set to 8. Newer versions of zlib will throw an exception,
 so Node.js restored the original behavior of upgrading a value of 8 to 9,
 since passing <code>windowBits = 9</code> to zlib actually results in a compressed stream
 that effectively uses an 8-bit window only.</p>
-<h2><code>zlib.createGunzip([options])</code><span><a class="mark" href="#zlib_zlib_creategunzip_options" id="zlib_zlib_creategunzip_options">#</a></span></h2>
+</section><section><h3><code>zlib.createGunzip([options])</code><span><a class="mark" href="#zlib_zlib_creategunzip_options" id="zlib_zlib_creategunzip_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -63740,7 +68864,7 @@ that effectively uses an 8-bit window only.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_gunzip"><code>Gunzip</code></a> object.</p>
-<h2><code>zlib.createGzip([options])</code><span><a class="mark" href="#zlib_zlib_creategzip_options" id="zlib_zlib_creategzip_options">#</a></span></h2>
+</section><section><h3><code>zlib.createGzip([options])</code><span><a class="mark" href="#zlib_zlib_creategzip_options" id="zlib_zlib_creategzip_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -63749,7 +68873,7 @@ that effectively uses an 8-bit window only.</p>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_gzip"><code>Gzip</code></a> object.
 See <a href="#zlib_zlib">example</a>.</p>
-<h2><code>zlib.createInflate([options])</code><span><a class="mark" href="#zlib_zlib_createinflate_options" id="zlib_zlib_createinflate_options">#</a></span></h2>
+</section><section><h3><code>zlib.createInflate([options])</code><span><a class="mark" href="#zlib_zlib_createinflate_options" id="zlib_zlib_createinflate_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -63757,7 +68881,7 @@ See <a href="#zlib_zlib">example</a>.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_inflate"><code>Inflate</code></a> object.</p>
-<h2><code>zlib.createInflateRaw([options])</code><span><a class="mark" href="#zlib_zlib_createinflateraw_options" id="zlib_zlib_createinflateraw_options">#</a></span></h2>
+</section><section><h3><code>zlib.createInflateRaw([options])</code><span><a class="mark" href="#zlib_zlib_createinflateraw_options" id="zlib_zlib_createinflateraw_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -63765,7 +68889,7 @@ See <a href="#zlib_zlib">example</a>.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_inflateraw"><code>InflateRaw</code></a> object.</p>
-<h2><code>zlib.createUnzip([options])</code><span><a class="mark" href="#zlib_zlib_createunzip_options" id="zlib_zlib_createunzip_options">#</a></span></h2>
+</section><section><h3><code>zlib.createUnzip([options])</code><span><a class="mark" href="#zlib_zlib_createunzip_options" id="zlib_zlib_createunzip_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -63773,7 +68897,7 @@ See <a href="#zlib_zlib">example</a>.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_unzip"><code>Unzip</code></a> object.</p>
-<h2>Convenience methods<span><a class="mark" href="#zlib_convenience_methods" id="zlib_convenience_methods">#</a></span></h2>
+</section><section><h3>Convenience methods<span><a class="mark" href="#zlib_convenience_methods" id="zlib_convenience_methods">#</a></span></h3>
 
 <p>All of these take a <a href="#buffer_class_buffer"><code>Buffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a>,
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> or string as the first argument, an optional second argument
@@ -63781,43 +68905,43 @@ to supply options to the <code>zlib</code> classes and will call the supplied ca
 with <code>callback(error, result)</code>.</p>
 <p>Every method has a <code>*Sync</code> counterpart, which accept the same arguments, but
 without a callback.</p>
-<h3><code>zlib.brotliCompress(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_brotlicompress_buffer_options_callback" id="zlib_zlib_brotlicompress_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.brotliCompress(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_brotlicompress_buffer_options_callback" id="zlib_zlib_brotlicompress_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.brotliCompressSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_brotlicompresssync_buffer_options" id="zlib_zlib_brotlicompresssync_buffer_options">#</a></span></h3>
+<h4><code>zlib.brotliCompressSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_brotlicompresssync_buffer_options" id="zlib_zlib_brotlicompresssync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 </ul>
 <p>Compress a chunk of data with <a href="#zlib_class_zlib_brotlicompress"><code>BrotliCompress</code></a>.</p>
-<h3><code>zlib.brotliDecompress(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_brotlidecompress_buffer_options_callback" id="zlib_zlib_brotlidecompress_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.brotliDecompress(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_brotlidecompress_buffer_options_callback" id="zlib_zlib_brotlidecompress_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.brotliDecompressSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_brotlidecompresssync_buffer_options" id="zlib_zlib_brotlidecompresssync_buffer_options">#</a></span></h3>
+<h4><code>zlib.brotliDecompressSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_brotlidecompresssync_buffer_options" id="zlib_zlib_brotlidecompresssync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 </ul>
 <p>Decompress a chunk of data with <a href="#zlib_class_zlib_brotlidecompress"><code>BrotliDecompress</code></a>.</p>
-<h3><code>zlib.deflate(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_deflate_buffer_options_callback" id="zlib_zlib_deflate_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.deflate(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_deflate_buffer_options_callback" id="zlib_zlib_deflate_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63838,7 +68962,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.deflateSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_deflatesync_buffer_options" id="zlib_zlib_deflatesync_buffer_options">#</a></span></h3>
+<h4><code>zlib.deflateSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_deflatesync_buffer_options" id="zlib_zlib_deflatesync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63859,7 +68983,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Compress a chunk of data with <a href="#zlib_class_zlib_deflate"><code>Deflate</code></a>.</p>
-<h3><code>zlib.deflateRaw(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_deflateraw_buffer_options_callback" id="zlib_zlib_deflateraw_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.deflateRaw(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_deflateraw_buffer_options_callback" id="zlib_zlib_deflateraw_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63878,7 +69002,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.deflateRawSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_deflaterawsync_buffer_options" id="zlib_zlib_deflaterawsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.deflateRawSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_deflaterawsync_buffer_options" id="zlib_zlib_deflaterawsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63899,7 +69023,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Compress a chunk of data with <a href="#zlib_class_zlib_deflateraw"><code>DeflateRaw</code></a>.</p>
-<h3><code>zlib.gunzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_gunzip_buffer_options_callback" id="zlib_zlib_gunzip_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.gunzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_gunzip_buffer_options_callback" id="zlib_zlib_gunzip_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63920,7 +69044,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.gunzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_gunzipsync_buffer_options" id="zlib_zlib_gunzipsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.gunzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_gunzipsync_buffer_options" id="zlib_zlib_gunzipsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63941,7 +69065,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Decompress a chunk of data with <a href="#zlib_class_zlib_gunzip"><code>Gunzip</code></a>.</p>
-<h3><code>zlib.gzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_gzip_buffer_options_callback" id="zlib_zlib_gzip_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.gzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_gzip_buffer_options_callback" id="zlib_zlib_gzip_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63962,7 +69086,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.gzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_gzipsync_buffer_options" id="zlib_zlib_gzipsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.gzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_gzipsync_buffer_options" id="zlib_zlib_gzipsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -63983,7 +69107,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Compress a chunk of data with <a href="#zlib_class_zlib_gzip"><code>Gzip</code></a>.</p>
-<h3><code>zlib.inflate(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_inflate_buffer_options_callback" id="zlib_zlib_inflate_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.inflate(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_inflate_buffer_options_callback" id="zlib_zlib_inflate_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -64004,7 +69128,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.inflateSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_inflatesync_buffer_options" id="zlib_zlib_inflatesync_buffer_options">#</a></span></h3>
+<h4><code>zlib.inflateSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_inflatesync_buffer_options" id="zlib_zlib_inflatesync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -64025,7 +69149,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Decompress a chunk of data with <a href="#zlib_class_zlib_inflate"><code>Inflate</code></a>.</p>
-<h3><code>zlib.inflateRaw(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_inflateraw_buffer_options_callback" id="zlib_zlib_inflateraw_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.inflateRaw(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_inflateraw_buffer_options_callback" id="zlib_zlib_inflateraw_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -64046,7 +69170,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.inflateRawSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_inflaterawsync_buffer_options" id="zlib_zlib_inflaterawsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.inflateRawSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_inflaterawsync_buffer_options" id="zlib_zlib_inflaterawsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -64067,7 +69191,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Decompress a chunk of data with <a href="#zlib_class_zlib_inflateraw"><code>InflateRaw</code></a>.</p>
-<h3><code>zlib.unzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_unzip_buffer_options_callback" id="zlib_zlib_unzip_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.unzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_unzip_buffer_options_callback" id="zlib_zlib_unzip_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -64088,7 +69212,7 @@ without a callback.</p>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.unzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_unzipsync_buffer_options" id="zlib_zlib_unzipsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.unzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_unzipsync_buffer_options" id="zlib_zlib_unzipsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -64108,10 +69232,47 @@ without a callback.</p>
 <li><code>buffer</code> <a href="#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
-<p>Decompress a chunk of data with <a href="#zlib_class_zlib_unzip"><code>Unzip</code></a>.</p>
+<p>Decompress a chunk of data with <a href="#zlib_class_zlib_unzip"><code>Unzip</code></a>.</p></section>
+        </section>
 <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/all.json b/doc/api/all.json
index 46c3fc0dcd6d2548af0eea12768a376dbf446b5b..e81a5479a1d7f86a26bcc2a6e55cb3826b3e5664 100644
--- a/doc/api/all.json
+++ b/doc/api/all.json
@@ -10,7 +10,7 @@
         {
           "textRaw": "Contributing",
           "name": "contributing",
-          "desc": "<p>Report errors in this documentation in <a href=\"https://github.com/nodejs/node/issues/new\">the issue tracker</a>. See\n<a href=\"https://github.com/nodejs/node/blob/master/CONTRIBUTING.md\">the contributing guide</a> for directions on how to submit pull requests.</p>",
+          "desc": "<p>Report errors in this documentation in <a href=\"https://github.com/nodejs/node/issues/new\">the issue tracker</a>. See\n<a href=\"https://github.com/nodejs/node/blob/HEAD/CONTRIBUTING.md\">the contributing guide</a> for directions on how to submit pull requests.</p>",
           "type": "misc",
           "displayName": "Contributing"
         },
@@ -18,7 +18,14 @@
           "textRaw": "Stability index",
           "name": "Stability index",
           "type": "misc",
-          "desc": "<p>Throughout the documentation are indications of a section's stability. Some APIs\nare so proven and so relied upon that they are unlikely to ever change at all.\nOthers are brand new and experimental, or known to be hazardous.</p>\n<p>The stability indices are as follows:</p>\n<blockquote>\n<p>Stability: 0 - Deprecated. The feature may emit warnings. Backward\ncompatibility is not guaranteed.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 1 - Experimental. The feature is not subject to\n<a href=\"https://semver.org/\">Semantic Versioning</a> rules. Non-backward compatible changes or removal may\noccur in any future release. Use of the feature is not recommended in\nproduction environments.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 2 - Stable. Compatibility with the npm ecosystem is a high\npriority.</p>\n</blockquote>\n<p>Use caution when making use of Experimental features, particularly within\nmodules. Users may not be aware that experimental features are being used.\nBugs or behavior changes may surprise users when Experimental API\nmodifications occur. To avoid surprises, use of an Experimental feature may need\na command-line flag. Experimental features may also emit a <a href=\"process.html#process_event_warning\">warning</a>.</p>"
+          "desc": "<p>Throughout the documentation are indications of a section's stability. Some APIs\nare so proven and so relied upon that they are unlikely to ever change at all.\nOthers are brand new and experimental, or known to be hazardous.</p>\n<p>The stability indices are as follows:</p>\n<blockquote>\n<p>Stability: 0 - Deprecated. The feature may emit warnings. Backward\ncompatibility is not guaranteed.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 1 - Experimental. The feature is not subject to\n<a href=\"https://semver.org/\">Semantic Versioning</a> rules. Non-backward compatible changes or removal may\noccur in any future release. Use of the feature is not recommended in\nproduction environments.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 2 - Stable. Compatibility with the npm ecosystem is a high\npriority.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 3 - Legacy. The feature is no longer recommended for use. While it\nlikely will not be removed, and is still covered by semantic-versioning\nguarantees, use of the feature should be avoided.</p>\n</blockquote>\n<p>Use caution when making use of Experimental features, particularly within\nmodules. Users may not be aware that experimental features are being used.\nBugs or behavior changes may surprise users when Experimental API\nmodifications occur. To avoid surprises, use of an Experimental feature may need\na command-line flag. Experimental features may also emit a <a href=\"process.html#process_event_warning\">warning</a>.</p>"
+        },
+        {
+          "textRaw": "Stability overview",
+          "name": "stability_overview",
+          "desc": "<!-- STABILITY_OVERVIEW_SLOT_BEGIN -->\n<!-- STABILITY_OVERVIEW_SLOT_END -->",
+          "type": "misc",
+          "displayName": "Stability overview"
         },
         {
           "textRaw": "JSON output",
@@ -40,24 +47,25 @@
           "type": "misc",
           "displayName": "System calls and man pages"
         }
-      ]
+      ],
+      "source": "doc/api/documentation.md"
     },
     {
       "textRaw": "C++ addons",
       "name": "C++ addons",
       "introduced_in": "v0.10.0",
       "type": "misc",
-      "desc": "<p><em>Addons</em> are dynamically-linked shared objects written in C++. The\n<a href=\"modules.html#modules_require_id\"><code>require()</code></a> function can load addons as ordinary Node.js modules.\nAddons provide an interface between JavaScript and C/C++ libraries.</p>\n<p>There are three options for implementing addons: N-API, nan, or direct\nuse of internal V8, libuv and Node.js libraries. Unless there is a need for\ndirect access to functionality which is not exposed by N-API, use N-API.\nRefer to <a href=\"n-api.html\">C/C++ addons with N-API</a> for more information on N-API.</p>\n<p>When not using N-API, implementing addons is complicated,\ninvolving knowledge of several components and APIs:</p>\n<ul>\n<li>\n<p>V8: the C++ library Node.js uses to provide the\nJavaScript implementation. V8 provides the mechanisms for creating objects,\ncalling functions, etc. V8's API is documented mostly in the\n<code>v8.h</code> header file (<code>deps/v8/include/v8.h</code> in the Node.js source\ntree), which is also available <a href=\"https://v8docs.nodesource.com/\">online</a>.</p>\n</li>\n<li>\n<p><a href=\"https://github.com/libuv/libuv\">libuv</a>: The C library that implements the Node.js event loop, its worker\nthreads and all of the asynchronous behaviors of the platform. It also\nserves as a cross-platform abstraction library, giving easy, POSIX-like\naccess across all major operating systems to many common system tasks, such\nas interacting with the filesystem, sockets, timers, and system events. libuv\nalso provides a pthreads-like threading abstraction that may be used to\npower more sophisticated asynchronous addons that need to move beyond the\nstandard event loop. Addon authors are encouraged to think about how to\navoid blocking the event loop with I/O or other time-intensive tasks by\noff-loading work via libuv to non-blocking system operations, worker threads\nor a custom use of libuv's threads.</p>\n</li>\n<li>\n<p>Internal Node.js libraries. Node.js itself exports C++ APIs that addons can\nuse, the most important of which is the <code>node::ObjectWrap</code> class.</p>\n</li>\n<li>\n<p>Node.js includes other statically linked libraries including OpenSSL. These\nother libraries are located in the <code>deps/</code> directory in the Node.js source\ntree. Only the libuv, OpenSSL, V8 and zlib symbols are purposefully\nre-exported by Node.js and may be used to various extents by addons. See\n<a href=\"addons.html#addons_linking_to_libraries_included_with_node_js\">Linking to libraries included with Node.js</a> for additional information.</p>\n</li>\n</ul>\n<p>All of the following examples are available for <a href=\"https://github.com/nodejs/node-addon-examples\">download</a> and may\nbe used as the starting-point for an addon.</p>",
+      "desc": "<p><em>Addons</em> are dynamically-linked shared objects written in C++. The\n<a href=\"modules.html#modules_require_id\"><code>require()</code></a> function can load addons as ordinary Node.js modules.\nAddons provide an interface between JavaScript and C/C++ libraries.</p>\n<p>There are three options for implementing addons: Node-API, nan, or direct\nuse of internal V8, libuv and Node.js libraries. Unless there is a need for\ndirect access to functionality which is not exposed by Node-API, use Node-API.\nRefer to <a href=\"n-api.html\">C/C++ addons with Node-API</a> for more information on\nNode-API.</p>\n<p>When not using Node-API, implementing addons is complicated,\ninvolving knowledge of several components and APIs:</p>\n<ul>\n<li>\n<p><a href=\"https://v8.dev/\">V8</a>: the C++ library Node.js uses to provide the\nJavaScript implementation. V8 provides the mechanisms for creating objects,\ncalling functions, etc. V8's API is documented mostly in the\n<code>v8.h</code> header file (<code>deps/v8/include/v8.h</code> in the Node.js source\ntree), which is also available <a href=\"https://v8docs.nodesource.com/\">online</a>.</p>\n</li>\n<li>\n<p><a href=\"https://github.com/libuv/libuv\">libuv</a>: The C library that implements the Node.js event loop, its worker\nthreads and all of the asynchronous behaviors of the platform. It also\nserves as a cross-platform abstraction library, giving easy, POSIX-like\naccess across all major operating systems to many common system tasks, such\nas interacting with the filesystem, sockets, timers, and system events. libuv\nalso provides a threading abstraction similar to POSIX threads for\nmore sophisticated asynchronous addons that need to move beyond the\nstandard event loop. Addon authors should\navoid blocking the event loop with I/O or other time-intensive tasks by\noffloading work via libuv to non-blocking system operations, worker threads,\nor a custom use of libuv threads.</p>\n</li>\n<li>\n<p>Internal Node.js libraries. Node.js itself exports C++ APIs that addons can\nuse, the most important of which is the <code>node::ObjectWrap</code> class.</p>\n</li>\n<li>\n<p>Node.js includes other statically linked libraries including OpenSSL. These\nother libraries are located in the <code>deps/</code> directory in the Node.js source\ntree. Only the libuv, OpenSSL, V8 and zlib symbols are purposefully\nre-exported by Node.js and may be used to various extents by addons. See\n<a href=\"addons.html#addons_linking_to_libraries_included_with_node_js\">Linking to libraries included with Node.js</a> for additional information.</p>\n</li>\n</ul>\n<p>All of the following examples are available for <a href=\"https://github.com/nodejs/node-addon-examples\">download</a> and may\nbe used as the starting-point for an addon.</p>",
       "miscs": [
         {
           "textRaw": "Hello world",
           "name": "hello_world",
-          "desc": "<p>This \"Hello world\" example is a simple addon, written in C++, that is the\nequivalent of the following JavaScript code:</p>\n<pre><code class=\"language-js\">module.exports.hello = () => 'world';\n</code></pre>\n<p>First, create the file <code>hello.cc</code>:</p>\n<pre><code class=\"language-cpp\">// hello.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid Method(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  args.GetReturnValue().Set(String::NewFromUtf8(\n      isolate, \"world\", NewStringType::kNormal).ToLocalChecked());\n}\n\nvoid Initialize(Local&#x3C;Object> exports) {\n  NODE_SET_METHOD(exports, \"hello\", Method);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)\n\n}  // namespace demo\n</code></pre>\n<p>All Node.js addons must export an initialization function following\nthe pattern:</p>\n<pre><code class=\"language-cpp\">void Initialize(Local&#x3C;Object> exports);\nNODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)\n</code></pre>\n<p>There is no semi-colon after <code>NODE_MODULE</code> as it's not a function (see\n<code>node.h</code>).</p>\n<p>The <code>module_name</code> must match the filename of the final binary (excluding\nthe <code>.node</code> suffix).</p>\n<p>In the <code>hello.cc</code> example, then, the initialization function is <code>Initialize</code>\nand the addon module name is <code>addon</code>.</p>\n<p>When building addons with <code>node-gyp</code>, using the macro <code>NODE_GYP_MODULE_NAME</code> as\nthe first parameter of <code>NODE_MODULE()</code> will ensure that the name of the final\nbinary will be passed to <code>NODE_MODULE()</code>.</p>",
+          "desc": "<p>This \"Hello world\" example is a simple addon, written in C++, that is the\nequivalent of the following JavaScript code:</p>\n<pre><code class=\"language-js\">module.exports.hello = () => 'world';\n</code></pre>\n<p>First, create the file <code>hello.cc</code>:</p>\n<pre><code class=\"language-cpp\">// hello.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid Method(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  args.GetReturnValue().Set(String::NewFromUtf8(\n      isolate, \"world\").ToLocalChecked());\n}\n\nvoid Initialize(Local&#x3C;Object> exports) {\n  NODE_SET_METHOD(exports, \"hello\", Method);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)\n\n}  // namespace demo\n</code></pre>\n<p>All Node.js addons must export an initialization function following\nthe pattern:</p>\n<pre><code class=\"language-cpp\">void Initialize(Local&#x3C;Object> exports);\nNODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)\n</code></pre>\n<p>There is no semi-colon after <code>NODE_MODULE</code> as it's not a function (see\n<code>node.h</code>).</p>\n<p>The <code>module_name</code> must match the filename of the final binary (excluding\nthe <code>.node</code> suffix).</p>\n<p>In the <code>hello.cc</code> example, then, the initialization function is <code>Initialize</code>\nand the addon module name is <code>addon</code>.</p>\n<p>When building addons with <code>node-gyp</code>, using the macro <code>NODE_GYP_MODULE_NAME</code> as\nthe first parameter of <code>NODE_MODULE()</code> will ensure that the name of the final\nbinary will be passed to <code>NODE_MODULE()</code>.</p>",
           "modules": [
             {
               "textRaw": "Context-aware addons",
               "name": "context-aware_addons",
-              "desc": "<p>There are environments in which Node.js addons may need to be loaded multiple\ntimes in multiple contexts. For example, the <a href=\"https://electronjs.org/\">Electron</a> runtime runs multiple\ninstances of Node.js in a single process. Each instance will have its own\n<code>require()</code> cache, and thus each instance will need a native addon to behave\ncorrectly when loaded via <code>require()</code>. From the addon's perspective, this means\nthat it must support multiple initializations.</p>\n<p>A context-aware addon can be constructed by using the macro\n<code>NODE_MODULE_INITIALIZER</code>, which expands to the name of a function which Node.js\nwill expect to find when it loads an addon. An addon can thus be initialized as\nin the following example:</p>\n<pre><code class=\"language-cpp\">using namespace v8;\n\nextern \"C\" NODE_MODULE_EXPORT void\nNODE_MODULE_INITIALIZER(Local&#x3C;Object> exports,\n                        Local&#x3C;Value> module,\n                        Local&#x3C;Context> context) {\n  /* Perform addon initialization steps here. */\n}\n</code></pre>\n<p>Another option is to use the macro <code>NODE_MODULE_INIT()</code>, which will also\nconstruct a context-aware addon. Unlike <code>NODE_MODULE()</code>, which is used to\nconstruct an addon around a given addon initializer function,\n<code>NODE_MODULE_INIT()</code> serves as the declaration of such an initializer to be\nfollowed by a function body.</p>\n<p>The following three variables may be used inside the function body following an\ninvocation of <code>NODE_MODULE_INIT()</code>:</p>\n<ul>\n<li><code>Local&#x3C;Object> exports</code>,</li>\n<li><code>Local&#x3C;Value> module</code>, and</li>\n<li><code>Local&#x3C;Context> context</code></li>\n</ul>\n<p>The choice to build a context-aware addon carries with it the responsibility of\ncarefully managing global static data. Since the addon may be loaded multiple\ntimes, potentially even from different threads, any global static data stored\nin the addon must be properly protected, and must not contain any persistent\nreferences to JavaScript objects. The reason for this is that JavaScript\nobjects are only valid in one context, and will likely cause a crash when\naccessed from the wrong context or from a different thread than the one on which\nthey were created.</p>\n<p>The context-aware addon can be structured to avoid global static data by\nperforming the following steps:</p>\n<ul>\n<li>Define a class which will hold per-addon-instance data and which has a static\nmember of the form\n<pre><code class=\"language-cpp\">static void DeleteInstance(void* data) {\n  // Cast `data` to an instance of the class and delete it.\n}\n</code></pre>\n</li>\n<li>Heap-allocate an instance of this class in the addon initializer. This can be\naccomplished using the <code>new</code> keyword.</li>\n<li>Call <code>node::AddEnvironmentCleanupHook()</code>, passing it the above-created\ninstance and a pointer to <code>DeleteInstance()</code>. This will ensure the instance is\ndeleted when the environment is torn down.</li>\n<li>Store the instance of the class in a <code>v8::External</code>, and</li>\n<li>Pass the <code>v8::External</code> to all methods exposed to JavaScript by passing it\nto <code>v8::FunctionTemplate::New()</code> or <code>v8::Function::New()</code> which creates the\nnative-backed JavaScript functions. The third parameter of\n<code>v8::FunctionTemplate::New()</code> or <code>v8::Function::New()</code>  accepts the\n<code>v8::External</code> and makes it available in the native callback using the\n<code>v8::FunctionCallbackInfo::Data()</code> method.</li>\n</ul>\n<p>This will ensure that the per-addon-instance data reaches each binding that can\nbe called from JavaScript. The per-addon-instance data must also be passed into\nany asynchronous callbacks the addon may create.</p>\n<p>The following example illustrates the implementation of a context-aware addon:</p>\n<pre><code class=\"language-cpp\">#include &#x3C;node.h>\n\nusing namespace v8;\n\nclass AddonData {\n public:\n  explicit AddonData(Isolate* isolate):\n      call_count(0) {\n    // Ensure this per-addon-instance data is deleted at environment cleanup.\n    node::AddEnvironmentCleanupHook(isolate, DeleteInstance, this);\n  }\n\n  // Per-addon data.\n  int call_count;\n\n  static void DeleteInstance(void* data) {\n    delete static_cast&#x3C;AddonData*>(data);\n  }\n};\n\nstatic void Method(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; info) {\n  // Retrieve the per-addon-instance data.\n  AddonData* data =\n      reinterpret_cast&#x3C;AddonData*>(info.Data().As&#x3C;External>()->Value());\n  data->call_count++;\n  info.GetReturnValue().Set((double)data->call_count);\n}\n\n// Initialize this addon to be context-aware.\nNODE_MODULE_INIT(/* exports, module, context */) {\n  Isolate* isolate = context->GetIsolate();\n\n  // Create a new instance of `AddonData` for this instance of the addon and\n  // tie its life cycle to that of the Node.js environment.\n  AddonData* data = new AddonData(isolate);\n\n  // Wrap the data in a `v8::External` so we can pass it to the method we\n  // expose.\n  Local&#x3C;External> external = External::New(isolate, data);\n\n  // Expose the method `Method` to JavaScript, and make sure it receives the\n  // per-addon-instance data we created above by passing `external` as the\n  // third parameter to the `FunctionTemplate` constructor.\n  exports->Set(context,\n               String::NewFromUtf8(isolate, \"method\", NewStringType::kNormal)\n                  .ToLocalChecked(),\n               FunctionTemplate::New(isolate, Method, external)\n                  ->GetFunction(context).ToLocalChecked()).FromJust();\n}\n</code></pre>",
+              "desc": "<p>There are environments in which Node.js addons may need to be loaded multiple\ntimes in multiple contexts. For example, the <a href=\"https://electronjs.org/\">Electron</a> runtime runs multiple\ninstances of Node.js in a single process. Each instance will have its own\n<code>require()</code> cache, and thus each instance will need a native addon to behave\ncorrectly when loaded via <code>require()</code>. This means that the addon\nmust support multiple initializations.</p>\n<p>A context-aware addon can be constructed by using the macro\n<code>NODE_MODULE_INITIALIZER</code>, which expands to the name of a function which Node.js\nwill expect to find when it loads an addon. An addon can thus be initialized as\nin the following example:</p>\n<pre><code class=\"language-cpp\">using namespace v8;\n\nextern \"C\" NODE_MODULE_EXPORT void\nNODE_MODULE_INITIALIZER(Local&#x3C;Object> exports,\n                        Local&#x3C;Value> module,\n                        Local&#x3C;Context> context) {\n  /* Perform addon initialization steps here. */\n}\n</code></pre>\n<p>Another option is to use the macro <code>NODE_MODULE_INIT()</code>, which will also\nconstruct a context-aware addon. Unlike <code>NODE_MODULE()</code>, which is used to\nconstruct an addon around a given addon initializer function,\n<code>NODE_MODULE_INIT()</code> serves as the declaration of such an initializer to be\nfollowed by a function body.</p>\n<p>The following three variables may be used inside the function body following an\ninvocation of <code>NODE_MODULE_INIT()</code>:</p>\n<ul>\n<li><code>Local&#x3C;Object> exports</code>,</li>\n<li><code>Local&#x3C;Value> module</code>, and</li>\n<li><code>Local&#x3C;Context> context</code></li>\n</ul>\n<p>The choice to build a context-aware addon carries with it the responsibility of\ncarefully managing global static data. Since the addon may be loaded multiple\ntimes, potentially even from different threads, any global static data stored\nin the addon must be properly protected, and must not contain any persistent\nreferences to JavaScript objects. The reason for this is that JavaScript\nobjects are only valid in one context, and will likely cause a crash when\naccessed from the wrong context or from a different thread than the one on which\nthey were created.</p>\n<p>The context-aware addon can be structured to avoid global static data by\nperforming the following steps:</p>\n<ul>\n<li>Define a class which will hold per-addon-instance data and which has a static\nmember of the form\n<pre><code class=\"language-cpp\">static void DeleteInstance(void* data) {\n  // Cast `data` to an instance of the class and delete it.\n}\n</code></pre>\n</li>\n<li>Heap-allocate an instance of this class in the addon initializer. This can be\naccomplished using the <code>new</code> keyword.</li>\n<li>Call <code>node::AddEnvironmentCleanupHook()</code>, passing it the above-created\ninstance and a pointer to <code>DeleteInstance()</code>. This will ensure the instance is\ndeleted when the environment is torn down.</li>\n<li>Store the instance of the class in a <code>v8::External</code>, and</li>\n<li>Pass the <code>v8::External</code> to all methods exposed to JavaScript by passing it\nto <code>v8::FunctionTemplate::New()</code> or <code>v8::Function::New()</code> which creates the\nnative-backed JavaScript functions. The third parameter of\n<code>v8::FunctionTemplate::New()</code> or <code>v8::Function::New()</code>  accepts the\n<code>v8::External</code> and makes it available in the native callback using the\n<code>v8::FunctionCallbackInfo::Data()</code> method.</li>\n</ul>\n<p>This will ensure that the per-addon-instance data reaches each binding that can\nbe called from JavaScript. The per-addon-instance data must also be passed into\nany asynchronous callbacks the addon may create.</p>\n<p>The following example illustrates the implementation of a context-aware addon:</p>\n<pre><code class=\"language-cpp\">#include &#x3C;node.h>\n\nusing namespace v8;\n\nclass AddonData {\n public:\n  explicit AddonData(Isolate* isolate):\n      call_count(0) {\n    // Ensure this per-addon-instance data is deleted at environment cleanup.\n    node::AddEnvironmentCleanupHook(isolate, DeleteInstance, this);\n  }\n\n  // Per-addon data.\n  int call_count;\n\n  static void DeleteInstance(void* data) {\n    delete static_cast&#x3C;AddonData*>(data);\n  }\n};\n\nstatic void Method(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; info) {\n  // Retrieve the per-addon-instance data.\n  AddonData* data =\n      reinterpret_cast&#x3C;AddonData*>(info.Data().As&#x3C;External>()->Value());\n  data->call_count++;\n  info.GetReturnValue().Set((double)data->call_count);\n}\n\n// Initialize this addon to be context-aware.\nNODE_MODULE_INIT(/* exports, module, context */) {\n  Isolate* isolate = context->GetIsolate();\n\n  // Create a new instance of `AddonData` for this instance of the addon and\n  // tie its life cycle to that of the Node.js environment.\n  AddonData* data = new AddonData(isolate);\n\n  // Wrap the data in a `v8::External` so we can pass it to the method we\n  // expose.\n  Local&#x3C;External> external = External::New(isolate, data);\n\n  // Expose the method `Method` to JavaScript, and make sure it receives the\n  // per-addon-instance data we created above by passing `external` as the\n  // third parameter to the `FunctionTemplate` constructor.\n  exports->Set(context,\n               String::NewFromUtf8(isolate, \"method\").ToLocalChecked(),\n               FunctionTemplate::New(isolate, Method, external)\n                  ->GetFunction(context).ToLocalChecked()).FromJust();\n}\n</code></pre>",
               "modules": [
                 {
                   "textRaw": "Worker support",
@@ -65,13 +73,13 @@
                   "meta": {
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.8.0",
                         "pr-url": "https://github.com/nodejs/node/pull/34572",
                         "description": "Cleanup hooks may now be asynchronous."
                       }
                     ]
                   },
-                  "desc": "<p>In order to be loaded from multiple Node.js environments,\nsuch as a main thread and a Worker thread, an add-on needs to either:</p>\n<ul>\n<li>Be an N-API addon, or</li>\n<li>Be declared as context-aware using <code>NODE_MODULE_INIT()</code> as described above</li>\n</ul>\n<p>In order to support <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads, addons need to clean up any resources\nthey may have allocated when such a thread exists. This can be achieved through\nthe usage of the <code>AddEnvironmentCleanupHook()</code> function:</p>\n<pre><code class=\"language-cpp\">void AddEnvironmentCleanupHook(v8::Isolate* isolate,\n                               void (*fun)(void* arg),\n                               void* arg);\n</code></pre>\n<p>This function adds a hook that will run before a given Node.js instance shuts\ndown. If necessary, such hooks can be removed before they are run using\n<code>RemoveEnvironmentCleanupHook()</code>, which has the same signature. Callbacks are\nrun in last-in first-out order.</p>\n<p>If necessary, there is an additional pair of <code>AddEnvironmentCleanupHook()</code>\nand <code>RemoveEnvironmentCleanupHook()</code> overloads, where the cleanup hook takes a\ncallback function. This can be used for shutting down asynchronous resources,\nsuch as any libuv handles registered by the addon.</p>\n<p>The following <code>addon.cc</code> uses <code>AddEnvironmentCleanupHook</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;assert.h>\n#include &#x3C;stdlib.h>\n#include &#x3C;node.h>\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::HandleScope;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\n\n// Note: In a real-world application, do not rely on static/global data.\nstatic char cookie[] = \"yum yum\";\nstatic int cleanup_cb1_called = 0;\nstatic int cleanup_cb2_called = 0;\n\nstatic void cleanup_cb1(void* arg) {\n  Isolate* isolate = static_cast&#x3C;Isolate*>(arg);\n  HandleScope scope(isolate);\n  Local&#x3C;Object> obj = Object::New(isolate);\n  assert(!obj.IsEmpty());  // assert VM is still alive\n  assert(obj->IsObject());\n  cleanup_cb1_called++;\n}\n\nstatic void cleanup_cb2(void* arg) {\n  assert(arg == static_cast&#x3C;void*>(cookie));\n  cleanup_cb2_called++;\n}\n\nstatic void sanity_check(void*) {\n  assert(cleanup_cb1_called == 1);\n  assert(cleanup_cb2_called == 1);\n}\n\n// Initialize this addon to be context-aware.\nNODE_MODULE_INIT(/* exports, module, context */) {\n  Isolate* isolate = context->GetIsolate();\n\n  AddEnvironmentCleanupHook(isolate, sanity_check, nullptr);\n  AddEnvironmentCleanupHook(isolate, cleanup_cb2, cookie);\n  AddEnvironmentCleanupHook(isolate, cleanup_cb1, isolate);\n}\n</code></pre>\n<p>Test in JavaScript by running:</p>\n<pre><code class=\"language-js\">// test.js\nrequire('./build/Release/addon');\n</code></pre>",
+                  "desc": "<p>In order to be loaded from multiple Node.js environments,\nsuch as a main thread and a Worker thread, an add-on needs to either:</p>\n<ul>\n<li>Be an Node-API addon, or</li>\n<li>Be declared as context-aware using <code>NODE_MODULE_INIT()</code> as described above</li>\n</ul>\n<p>In order to support <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads, addons need to clean up any resources\nthey may have allocated when such a thread exists. This can be achieved through\nthe usage of the <code>AddEnvironmentCleanupHook()</code> function:</p>\n<pre><code class=\"language-cpp\">void AddEnvironmentCleanupHook(v8::Isolate* isolate,\n                               void (*fun)(void* arg),\n                               void* arg);\n</code></pre>\n<p>This function adds a hook that will run before a given Node.js instance shuts\ndown. If necessary, such hooks can be removed before they are run using\n<code>RemoveEnvironmentCleanupHook()</code>, which has the same signature. Callbacks are\nrun in last-in first-out order.</p>\n<p>If necessary, there is an additional pair of <code>AddEnvironmentCleanupHook()</code>\nand <code>RemoveEnvironmentCleanupHook()</code> overloads, where the cleanup hook takes a\ncallback function. This can be used for shutting down asynchronous resources,\nsuch as any libuv handles registered by the addon.</p>\n<p>The following <code>addon.cc</code> uses <code>AddEnvironmentCleanupHook</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include &#x3C;assert.h>\n#include &#x3C;stdlib.h>\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::HandleScope;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\n\n// Note: In a real-world application, do not rely on static/global data.\nstatic char cookie[] = \"yum yum\";\nstatic int cleanup_cb1_called = 0;\nstatic int cleanup_cb2_called = 0;\n\nstatic void cleanup_cb1(void* arg) {\n  Isolate* isolate = static_cast&#x3C;Isolate*>(arg);\n  HandleScope scope(isolate);\n  Local&#x3C;Object> obj = Object::New(isolate);\n  assert(!obj.IsEmpty());  // assert VM is still alive\n  assert(obj->IsObject());\n  cleanup_cb1_called++;\n}\n\nstatic void cleanup_cb2(void* arg) {\n  assert(arg == static_cast&#x3C;void*>(cookie));\n  cleanup_cb2_called++;\n}\n\nstatic void sanity_check(void*) {\n  assert(cleanup_cb1_called == 1);\n  assert(cleanup_cb2_called == 1);\n}\n\n// Initialize this addon to be context-aware.\nNODE_MODULE_INIT(/* exports, module, context */) {\n  Isolate* isolate = context->GetIsolate();\n\n  AddEnvironmentCleanupHook(isolate, sanity_check, nullptr);\n  AddEnvironmentCleanupHook(isolate, cleanup_cb2, cookie);\n  AddEnvironmentCleanupHook(isolate, cleanup_cb1, isolate);\n}\n</code></pre>\n<p>Test in JavaScript by running:</p>\n<pre><code class=\"language-js\">// test.js\nrequire('./build/Release/addon');\n</code></pre>",
                   "type": "module",
                   "displayName": "Worker support"
                 }
@@ -89,7 +97,7 @@
             {
               "textRaw": "Linking to libraries included with Node.js",
               "name": "linking_to_libraries_included_with_node.js",
-              "desc": "<p>Node.js uses statically linked libraries such as V8, libuv and OpenSSL. All\naddons are required to link to V8 and may link to any of the other dependencies\nas well. Typically, this is as simple as including the appropriate\n<code>#include &#x3C;...></code> statements (e.g. <code>#include &#x3C;v8.h></code>) and <code>node-gyp</code> will locate\nthe appropriate headers automatically. However, there are a few caveats to be\naware of:</p>\n<ul>\n<li>\n<p>When <code>node-gyp</code> runs, it will detect the specific release version of Node.js\nand download either the full source tarball or just the headers. If the full\nsource is downloaded, addons will have complete access to the full set of\nNode.js dependencies. However, if only the Node.js headers are downloaded, then\nonly the symbols exported by Node.js will be available.</p>\n</li>\n<li>\n<p><code>node-gyp</code> can be run using the <code>--nodedir</code> flag pointing at a local Node.js\nsource image. Using this option, the addon will have access to the full set of\ndependencies.</p>\n</li>\n</ul>",
+              "desc": "<p>Node.js uses statically linked libraries such as V8, libuv and OpenSSL. All\naddons are required to link to V8 and may link to any of the other dependencies\nas well. Typically, this is as simple as including the appropriate\n<code>#include &#x3C;...></code> statements (e.g. <code>#include &#x3C;v8.h></code>) and <code>node-gyp</code> will locate\nthe appropriate headers automatically. However, there are a few caveats to be\naware of:</p>\n<ul>\n<li>\n<p>When <code>node-gyp</code> runs, it will detect the specific release version of Node.js\nand download either the full source tarball or just the headers. If the full\nsource is downloaded, addons will have complete access to the full set of\nNode.js dependencies. However, if only the Node.js headers are downloaded,\nthen only the symbols exported by Node.js will be available.</p>\n</li>\n<li>\n<p><code>node-gyp</code> can be run using the <code>--nodedir</code> flag pointing at a local Node.js\nsource image. Using this option, the addon will have access to the full set of\ndependencies.</p>\n</li>\n</ul>",
               "type": "module",
               "displayName": "Linking to libraries included with Node.js"
             },
@@ -107,18 +115,18 @@
         {
           "textRaw": "Native abstractions for Node.js",
           "name": "native_abstractions_for_node.js",
-          "desc": "<p>Each of the examples illustrated in this document directly use the\nNode.js and V8 APIs for implementing addons. The V8 API can, and has, changed\ndramatically from one V8 release to the next (and one major Node.js release to\nthe next). With each change, addons may need to be updated and recompiled in\norder to continue functioning. The Node.js release schedule is designed to\nminimize the frequency and impact of such changes but there is little that\nNode.js can do to ensure stability of the V8 APIs.</p>\n<p>The <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a> (or <code>nan</code>) provide a set of tools that\naddon developers are recommended to use to keep compatibility between past and\nfuture releases of V8 and Node.js. See the <code>nan</code> <a href=\"https://github.com/nodejs/nan/tree/master/examples/\">examples</a> for an\nillustration of how it can be used.</p>",
+          "desc": "<p>Each of the examples illustrated in this document directly use the\nNode.js and V8 APIs for implementing addons. The V8 API can, and has, changed\ndramatically from one V8 release to the next (and one major Node.js release to\nthe next). With each change, addons may need to be updated and recompiled in\norder to continue functioning. The Node.js release schedule is designed to\nminimize the frequency and impact of such changes but there is little that\nNode.js can do to ensure stability of the V8 APIs.</p>\n<p>The <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a> (or <code>nan</code>) provide a set of tools that\naddon developers are recommended to use to keep compatibility between past and\nfuture releases of V8 and Node.js. See the <code>nan</code> <a href=\"https://github.com/nodejs/nan/tree/HEAD/examples/\">examples</a> for an\nillustration of how it can be used.</p>",
           "type": "misc",
           "displayName": "Native abstractions for Node.js"
         },
         {
-          "textRaw": "N-API",
-          "name": "n-api",
+          "textRaw": "Node-API",
+          "name": "node-api",
           "stability": 2,
           "stabilityText": "Stable",
-          "desc": "<p>N-API is an API for building native addons. It is independent from\nthe underlying JavaScript runtime (e.g. V8) and is maintained as part of\nNode.js itself. This API will be Application Binary Interface (ABI) stable\nacross versions of Node.js. It is intended to insulate addons from\nchanges in the underlying JavaScript engine and allow modules\ncompiled for one version to run on later versions of Node.js without\nrecompilation. Addons are built/packaged with the same approach/tools\noutlined in this document (node-gyp, etc.). The only difference is the\nset of APIs that are used by the native code. Instead of using the V8\nor <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a> APIs, the functions available\nin the N-API are used.</p>\n<p>Creating and maintaining an addon that benefits from the ABI stability\nprovided by N-API carries with it certain\n<a href=\"n-api.html#n_api_implications_of_abi_stability\">implementation considerations</a>.</p>\n<p>To use N-API in the above \"Hello world\" example, replace the content of\n<code>hello.cc</code> with the following. All other instructions remain the same.</p>\n<pre><code class=\"language-cpp\">// hello.cc using N-API\n#include &#x3C;node_api.h>\n\nnamespace demo {\n\nnapi_value Method(napi_env env, napi_callback_info args) {\n  napi_value greeting;\n  napi_status status;\n\n  status = napi_create_string_utf8(env, \"world\", NAPI_AUTO_LENGTH, &#x26;greeting);\n  if (status != napi_ok) return nullptr;\n  return greeting;\n}\n\nnapi_value init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_value fn;\n\n  status = napi_create_function(env, nullptr, 0, Method, nullptr, &#x26;fn);\n  if (status != napi_ok) return nullptr;\n\n  status = napi_set_named_property(env, exports, \"hello\", fn);\n  if (status != napi_ok) return nullptr;\n  return exports;\n}\n\nNAPI_MODULE(NODE_GYP_MODULE_NAME, init)\n\n}  // namespace demo\n</code></pre>\n<p>The functions available and how to use them are documented in\n<a href=\"n-api.html\">C/C++ addons with N-API</a>.</p>",
+          "desc": "<p>Node-API is an API for building native addons. It is independent from\nthe underlying JavaScript runtime (e.g. V8) and is maintained as part of\nNode.js itself. This API will be Application Binary Interface (ABI) stable\nacross versions of Node.js. It is intended to insulate addons from\nchanges in the underlying JavaScript engine and allow modules\ncompiled for one version to run on later versions of Node.js without\nrecompilation. Addons are built/packaged with the same approach/tools\noutlined in this document (node-gyp, etc.). The only difference is the\nset of APIs that are used by the native code. Instead of using the V8\nor <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a> APIs, the functions available\nin the Node-API are used.</p>\n<p>Creating and maintaining an addon that benefits from the ABI stability\nprovided by Node-API carries with it certain\n<a href=\"n-api.html#n_api_implications_of_abi_stability\">implementation considerations</a>.</p>\n<p>To use Node-API in the above \"Hello world\" example, replace the content of\n<code>hello.cc</code> with the following. All other instructions remain the same.</p>\n<pre><code class=\"language-cpp\">// hello.cc using Node-API\n#include &#x3C;node_api.h>\n\nnamespace demo {\n\nnapi_value Method(napi_env env, napi_callback_info args) {\n  napi_value greeting;\n  napi_status status;\n\n  status = napi_create_string_utf8(env, \"world\", NAPI_AUTO_LENGTH, &#x26;greeting);\n  if (status != napi_ok) return nullptr;\n  return greeting;\n}\n\nnapi_value init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_value fn;\n\n  status = napi_create_function(env, nullptr, 0, Method, nullptr, &#x26;fn);\n  if (status != napi_ok) return nullptr;\n\n  status = napi_set_named_property(env, exports, \"hello\", fn);\n  if (status != napi_ok) return nullptr;\n  return exports;\n}\n\nNAPI_MODULE(NODE_GYP_MODULE_NAME, init)\n\n}  // namespace demo\n</code></pre>\n<p>The functions available and how to use them are documented in\n<a href=\"n-api.html\">C/C++ addons with Node-API</a>.</p>",
           "type": "misc",
-          "displayName": "N-API"
+          "displayName": "Node-API"
         },
         {
           "textRaw": "Addon examples",
@@ -128,49 +136,49 @@
             {
               "textRaw": "Function arguments",
               "name": "function_arguments",
-              "desc": "<p>Addons will typically expose objects and functions that can be accessed from\nJavaScript running within Node.js. When functions are invoked from JavaScript,\nthe input arguments and return value must be mapped to and from the C/C++\ncode.</p>\n<p>The following example illustrates how to read function arguments passed from\nJavaScript and how to return a result:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Exception;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// This is the implementation of the \"add\" method\n// Input arguments are passed using the\n// const FunctionCallbackInfo&#x3C;Value>&#x26; args struct\nvoid Add(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  // Check the number of arguments passed.\n  if (args.Length() &#x3C; 2) {\n    // Throw an Error that is passed back to JavaScript\n    isolate->ThrowException(Exception::TypeError(\n        String::NewFromUtf8(isolate,\n                            \"Wrong number of arguments\",\n                            NewStringType::kNormal).ToLocalChecked()));\n    return;\n  }\n\n  // Check the argument types\n  if (!args[0]->IsNumber() || !args[1]->IsNumber()) {\n    isolate->ThrowException(Exception::TypeError(\n        String::NewFromUtf8(isolate,\n                            \"Wrong arguments\",\n                            NewStringType::kNormal).ToLocalChecked()));\n    return;\n  }\n\n  // Perform the operation\n  double value =\n      args[0].As&#x3C;Number>()->Value() + args[1].As&#x3C;Number>()->Value();\n  Local&#x3C;Number> num = Number::New(isolate, value);\n\n  // Set the return value (using the passed in\n  // FunctionCallbackInfo&#x3C;Value>&#x26;)\n  args.GetReturnValue().Set(num);\n}\n\nvoid Init(Local&#x3C;Object> exports) {\n  NODE_SET_METHOD(exports, \"add\", Add);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>Once compiled, the example addon can be required and used from within Node.js:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconsole.log('This should be eight:', addon.add(3, 5));\n</code></pre>",
+              "desc": "<p>Addons will typically expose objects and functions that can be accessed from\nJavaScript running within Node.js. When functions are invoked from JavaScript,\nthe input arguments and return value must be mapped to and from the C/C++\ncode.</p>\n<p>The following example illustrates how to read function arguments passed from\nJavaScript and how to return a result:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Exception;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// This is the implementation of the \"add\" method\n// Input arguments are passed using the\n// const FunctionCallbackInfo&#x3C;Value>&#x26; args struct\nvoid Add(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  // Check the number of arguments passed.\n  if (args.Length() &#x3C; 2) {\n    // Throw an Error that is passed back to JavaScript\n    isolate->ThrowException(Exception::TypeError(\n        String::NewFromUtf8(isolate,\n                            \"Wrong number of arguments\").ToLocalChecked()));\n    return;\n  }\n\n  // Check the argument types\n  if (!args[0]->IsNumber() || !args[1]->IsNumber()) {\n    isolate->ThrowException(Exception::TypeError(\n        String::NewFromUtf8(isolate,\n                            \"Wrong arguments\").ToLocalChecked()));\n    return;\n  }\n\n  // Perform the operation\n  double value =\n      args[0].As&#x3C;Number>()->Value() + args[1].As&#x3C;Number>()->Value();\n  Local&#x3C;Number> num = Number::New(isolate, value);\n\n  // Set the return value (using the passed in\n  // FunctionCallbackInfo&#x3C;Value>&#x26;)\n  args.GetReturnValue().Set(num);\n}\n\nvoid Init(Local&#x3C;Object> exports) {\n  NODE_SET_METHOD(exports, \"add\", Add);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>Once compiled, the example addon can be required and used from within Node.js:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconsole.log('This should be eight:', addon.add(3, 5));\n</code></pre>",
               "type": "module",
               "displayName": "Function arguments"
             },
             {
               "textRaw": "Callbacks",
               "name": "callbacks",
-              "desc": "<p>It is common practice within addons to pass JavaScript functions to a C++\nfunction and execute them from there. The following example illustrates how\nto invoke such callbacks:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Null;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid RunCallback(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Function> cb = Local&#x3C;Function>::Cast(args[0]);\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = {\n      String::NewFromUtf8(isolate,\n                          \"hello world\",\n                          NewStringType::kNormal).ToLocalChecked() };\n  cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", RunCallback);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>This example uses a two-argument form of <code>Init()</code> that receives the full\n<code>module</code> object as the second argument. This allows the addon to completely\noverwrite <code>exports</code> with a single function instead of adding the function as a\nproperty of <code>exports</code>.</p>\n<p>To test it, run the following JavaScript:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\naddon((msg) => {\n  console.log(msg);\n// Prints: 'hello world'\n});\n</code></pre>\n<p>In this example, the callback function is invoked synchronously.</p>",
+              "desc": "<p>It is common practice within addons to pass JavaScript functions to a C++\nfunction and execute them from there. The following example illustrates how\nto invoke such callbacks:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Null;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid RunCallback(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Function> cb = Local&#x3C;Function>::Cast(args[0]);\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = {\n      String::NewFromUtf8(isolate,\n                          \"hello world\").ToLocalChecked() };\n  cb->Call(context, Null(isolate), argc, argv).ToLocalChecked();\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", RunCallback);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>This example uses a two-argument form of <code>Init()</code> that receives the full\n<code>module</code> object as the second argument. This allows the addon to completely\noverwrite <code>exports</code> with a single function instead of adding the function as a\nproperty of <code>exports</code>.</p>\n<p>To test it, run the following JavaScript:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\naddon((msg) => {\n  console.log(msg);\n// Prints: 'hello world'\n});\n</code></pre>\n<p>In this example, the callback function is invoked synchronously.</p>",
               "type": "module",
               "displayName": "Callbacks"
             },
             {
               "textRaw": "Object factory",
               "name": "object_factory",
-              "desc": "<p>Addons can create and return new objects from within a C++ function as\nillustrated in the following example. An object is created and returned with a\nproperty <code>msg</code> that echoes the string passed to <code>createObject()</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  Local&#x3C;Object> obj = Object::New(isolate);\n  obj->Set(context,\n           String::NewFromUtf8(isolate,\n                               \"msg\",\n                               NewStringType::kNormal).ToLocalChecked(),\n                               args[0]->ToString(context).ToLocalChecked())\n           .FromJust();\n\n  args.GetReturnValue().Set(obj);\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", CreateObject);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>To test it in JavaScript:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj1 = addon('hello');\nconst obj2 = addon('world');\nconsole.log(obj1.msg, obj2.msg);\n// Prints: 'hello world'\n</code></pre>",
+              "desc": "<p>Addons can create and return new objects from within a C++ function as\nillustrated in the following example. An object is created and returned with a\nproperty <code>msg</code> that echoes the string passed to <code>createObject()</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  Local&#x3C;Object> obj = Object::New(isolate);\n  obj->Set(context,\n           String::NewFromUtf8(isolate,\n                               \"msg\").ToLocalChecked(),\n                               args[0]->ToString(context).ToLocalChecked())\n           .FromJust();\n\n  args.GetReturnValue().Set(obj);\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", CreateObject);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>To test it in JavaScript:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj1 = addon('hello');\nconst obj2 = addon('world');\nconsole.log(obj1.msg, obj2.msg);\n// Prints: 'hello world'\n</code></pre>",
               "type": "module",
               "displayName": "Object factory"
             },
             {
               "textRaw": "Function factory",
               "name": "function_factory",
-              "desc": "<p>Another common scenario is creating JavaScript functions that wrap C++\nfunctions and returning those back to JavaScript:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid MyFunction(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  args.GetReturnValue().Set(String::NewFromUtf8(\n      isolate, \"hello world\", NewStringType::kNormal).ToLocalChecked());\n}\n\nvoid CreateFunction(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, MyFunction);\n  Local&#x3C;Function> fn = tpl->GetFunction(context).ToLocalChecked();\n\n  // omit this to make it anonymous\n  fn->SetName(String::NewFromUtf8(\n      isolate, \"theFunction\", NewStringType::kNormal).ToLocalChecked());\n\n  args.GetReturnValue().Set(fn);\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", CreateFunction);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>To test:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst fn = addon();\nconsole.log(fn());\n// Prints: 'hello world'\n</code></pre>",
+              "desc": "<p>Another common scenario is creating JavaScript functions that wrap C++\nfunctions and returning those back to JavaScript:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid MyFunction(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  args.GetReturnValue().Set(String::NewFromUtf8(\n      isolate, \"hello world\").ToLocalChecked());\n}\n\nvoid CreateFunction(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, MyFunction);\n  Local&#x3C;Function> fn = tpl->GetFunction(context).ToLocalChecked();\n\n  // omit this to make it anonymous\n  fn->SetName(String::NewFromUtf8(\n      isolate, \"theFunction\").ToLocalChecked());\n\n  args.GetReturnValue().Set(fn);\n}\n\nvoid Init(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  NODE_SET_METHOD(module, \"exports\", CreateFunction);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, Init)\n\n}  // namespace demo\n</code></pre>\n<p>To test:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst fn = addon();\nconsole.log(fn());\n// Prints: 'hello world'\n</code></pre>",
               "type": "module",
               "displayName": "Function factory"
             },
             {
               "textRaw": "Wrapping C++ objects",
               "name": "wrapping_c++_objects",
-              "desc": "<p>It is also possible to wrap C++ objects/classes in a way that allows new\ninstances to be created using the JavaScript <code>new</code> operator:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Local;\nusing v8::Object;\n\nvoid InitAll(Local&#x3C;Object> exports) {\n  MyObject::Init(exports);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>Then, in <code>myobject.h</code>, the wrapper class inherits from <code>node::ObjectWrap</code>:</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Local&#x3C;v8::Object> exports);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static void PlusOne(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>In <code>myobject.cc</code>, implement the various methods that are to be exposed.\nBelow, the method <code>plusOne()</code> is exposed by adding it to the constructor's\nprototype:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Number;\nusing v8::Object;\nusing v8::ObjectTemplate;\nusing v8::String;\nusing v8::Value;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Local&#x3C;Object> exports) {\n  Isolate* isolate = exports->GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  Local&#x3C;ObjectTemplate> addon_data_tpl = ObjectTemplate::New(isolate);\n  addon_data_tpl->SetInternalFieldCount(1);  // 1 field for the MyObject::New()\n  Local&#x3C;Object> addon_data =\n      addon_data_tpl->NewInstance(context).ToLocalChecked();\n\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);\n  tpl->SetClassName(String::NewFromUtf8(\n      isolate, \"MyObject\", NewStringType::kNormal).ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  // Prototype\n  NODE_SET_PROTOTYPE_METHOD(tpl, \"plusOne\", PlusOne);\n\n  Local&#x3C;Function> constructor = tpl->GetFunction(context).ToLocalChecked();\n  addon_data->SetInternalField(0, constructor);\n  exports->Set(context, String::NewFromUtf8(\n      isolate, \"MyObject\", NewStringType::kNormal).ToLocalChecked(),\n               constructor).FromJust();\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons =\n        args.Data().As&#x3C;Object>()->GetInternalField(0).As&#x3C;Function>();\n    Local&#x3C;Object> result =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(result);\n  }\n}\n\nvoid MyObject::PlusOne(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());\n  obj->value_ += 1;\n\n  args.GetReturnValue().Set(Number::New(isolate, obj->value_));\n}\n\n}  // namespace demo\n</code></pre>\n<p>To build this example, the <code>myobject.cc</code> file must be added to the\n<code>binding.gyp</code>:</p>\n<pre><code class=\"language-json\">{\n  \"targets\": [\n    {\n      \"target_name\": \"addon\",\n      \"sources\": [\n        \"addon.cc\",\n        \"myobject.cc\"\n      ]\n    }\n  ]\n}\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj = new addon.MyObject(10);\nconsole.log(obj.plusOne());\n// Prints: 11\nconsole.log(obj.plusOne());\n// Prints: 12\nconsole.log(obj.plusOne());\n// Prints: 13\n</code></pre>\n<p>The destructor for a wrapper object will run when the object is\ngarbage-collected. For destructor testing, there are command-line flags that\ncan be used to make it possible to force garbage collection. These flags are\nprovided by the underlying V8 JavaScript engine. They are subject to change\nor removal at any time. They are not documented by Node.js or V8, and they\nshould never be used outside of testing.</p>",
+              "desc": "<p>It is also possible to wrap C++ objects/classes in a way that allows new\ninstances to be created using the JavaScript <code>new</code> operator:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Local;\nusing v8::Object;\n\nvoid InitAll(Local&#x3C;Object> exports) {\n  MyObject::Init(exports);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>Then, in <code>myobject.h</code>, the wrapper class inherits from <code>node::ObjectWrap</code>:</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Local&#x3C;v8::Object> exports);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static void PlusOne(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>In <code>myobject.cc</code>, implement the various methods that are to be exposed.\nBelow, the method <code>plusOne()</code> is exposed by adding it to the constructor's\nprototype:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::ObjectTemplate;\nusing v8::String;\nusing v8::Value;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Local&#x3C;Object> exports) {\n  Isolate* isolate = exports->GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  Local&#x3C;ObjectTemplate> addon_data_tpl = ObjectTemplate::New(isolate);\n  addon_data_tpl->SetInternalFieldCount(1);  // 1 field for the MyObject::New()\n  Local&#x3C;Object> addon_data =\n      addon_data_tpl->NewInstance(context).ToLocalChecked();\n\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);\n  tpl->SetClassName(String::NewFromUtf8(isolate, \"MyObject\").ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  // Prototype\n  NODE_SET_PROTOTYPE_METHOD(tpl, \"plusOne\", PlusOne);\n\n  Local&#x3C;Function> constructor = tpl->GetFunction(context).ToLocalChecked();\n  addon_data->SetInternalField(0, constructor);\n  exports->Set(context, String::NewFromUtf8(\n      isolate, \"MyObject\").ToLocalChecked(),\n      constructor).FromJust();\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons =\n        args.Data().As&#x3C;Object>()->GetInternalField(0).As&#x3C;Function>();\n    Local&#x3C;Object> result =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(result);\n  }\n}\n\nvoid MyObject::PlusOne(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());\n  obj->value_ += 1;\n\n  args.GetReturnValue().Set(Number::New(isolate, obj->value_));\n}\n\n}  // namespace demo\n</code></pre>\n<p>To build this example, the <code>myobject.cc</code> file must be added to the\n<code>binding.gyp</code>:</p>\n<pre><code class=\"language-json\">{\n  \"targets\": [\n    {\n      \"target_name\": \"addon\",\n      \"sources\": [\n        \"addon.cc\",\n        \"myobject.cc\"\n      ]\n    }\n  ]\n}\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj = new addon.MyObject(10);\nconsole.log(obj.plusOne());\n// Prints: 11\nconsole.log(obj.plusOne());\n// Prints: 12\nconsole.log(obj.plusOne());\n// Prints: 13\n</code></pre>\n<p>The destructor for a wrapper object will run when the object is\ngarbage-collected. For destructor testing, there are command-line flags that\ncan be used to make it possible to force garbage collection. These flags are\nprovided by the underlying V8 JavaScript engine. They are subject to change\nor removal at any time. They are not documented by Node.js or V8, and they\nshould never be used outside of testing.</p>",
               "type": "module",
               "displayName": "Wrapping C++ objects"
             },
             {
               "textRaw": "Factory of wrapped objects",
               "name": "factory_of_wrapped_objects",
-              "desc": "<p>Alternatively, it is possible to use a factory pattern to avoid explicitly\ncreating object instances using the JavaScript <code>new</code> operator:</p>\n<pre><code class=\"language-js\">const obj = addon.createObject();\n// instead of:\n// const obj = new addon.Object();\n</code></pre>\n<p>First, the <code>createObject()</code> method is implemented in <code>addon.cc</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  MyObject::NewInstance(args);\n}\n\nvoid InitAll(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  MyObject::Init(exports->GetIsolate());\n\n  NODE_SET_METHOD(module, \"exports\", CreateObject);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>In <code>myobject.h</code>, the static method <code>NewInstance()</code> is added to handle\ninstantiating the object. This method takes the place of using <code>new</code> in\nJavaScript:</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Isolate* isolate);\n  static void NewInstance(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static void PlusOne(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static v8::Global&#x3C;v8::Function> constructor;\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>The implementation in <code>myobject.cc</code> is similar to the previous example:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Global;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// Warning! This is not thread-safe, this addon cannot be used for worker\n// threads.\nGlobal&#x3C;Function> MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Isolate* isolate) {\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);\n  tpl->SetClassName(String::NewFromUtf8(\n      isolate, \"MyObject\", NewStringType::kNormal).ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  // Prototype\n  NODE_SET_PROTOTYPE_METHOD(tpl, \"plusOne\", PlusOne);\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());\n\n  AddEnvironmentCleanupHook(isolate, [](void*) {\n    constructor.Reset();\n  }, nullptr);\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n    Local&#x3C;Object> instance =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(instance);\n  }\n}\n\nvoid MyObject::NewInstance(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = { args[0] };\n  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Object> instance =\n      cons->NewInstance(context, argc, argv).ToLocalChecked();\n\n  args.GetReturnValue().Set(instance);\n}\n\nvoid MyObject::PlusOne(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());\n  obj->value_ += 1;\n\n  args.GetReturnValue().Set(Number::New(isolate, obj->value_));\n}\n\n}  // namespace demo\n</code></pre>\n<p>Once again, to build this example, the <code>myobject.cc</code> file must be added to the\n<code>binding.gyp</code>:</p>\n<pre><code class=\"language-json\">{\n  \"targets\": [\n    {\n      \"target_name\": \"addon\",\n      \"sources\": [\n        \"addon.cc\",\n        \"myobject.cc\"\n      ]\n    }\n  ]\n}\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst createObject = require('./build/Release/addon');\n\nconst obj = createObject(10);\nconsole.log(obj.plusOne());\n// Prints: 11\nconsole.log(obj.plusOne());\n// Prints: 12\nconsole.log(obj.plusOne());\n// Prints: 13\n\nconst obj2 = createObject(20);\nconsole.log(obj2.plusOne());\n// Prints: 21\nconsole.log(obj2.plusOne());\n// Prints: 22\nconsole.log(obj2.plusOne());\n// Prints: 23\n</code></pre>",
+              "desc": "<p>Alternatively, it is possible to use a factory pattern to avoid explicitly\ncreating object instances using the JavaScript <code>new</code> operator:</p>\n<pre><code class=\"language-js\">const obj = addon.createObject();\n// instead of:\n// const obj = new addon.Object();\n</code></pre>\n<p>First, the <code>createObject()</code> method is implemented in <code>addon.cc</code>:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  MyObject::NewInstance(args);\n}\n\nvoid InitAll(Local&#x3C;Object> exports, Local&#x3C;Object> module) {\n  MyObject::Init(exports->GetIsolate());\n\n  NODE_SET_METHOD(module, \"exports\", CreateObject);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>In <code>myobject.h</code>, the static method <code>NewInstance()</code> is added to handle\ninstantiating the object. This method takes the place of using <code>new</code> in\nJavaScript:</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Isolate* isolate);\n  static void NewInstance(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static void PlusOne(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static v8::Global&#x3C;v8::Function> constructor;\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>The implementation in <code>myobject.cc</code> is similar to the previous example:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Global;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// Warning! This is not thread-safe, this addon cannot be used for worker\n// threads.\nGlobal&#x3C;Function> MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Isolate* isolate) {\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);\n  tpl->SetClassName(String::NewFromUtf8(isolate, \"MyObject\").ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  // Prototype\n  NODE_SET_PROTOTYPE_METHOD(tpl, \"plusOne\", PlusOne);\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());\n\n  AddEnvironmentCleanupHook(isolate, [](void*) {\n    constructor.Reset();\n  }, nullptr);\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n    Local&#x3C;Object> instance =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(instance);\n  }\n}\n\nvoid MyObject::NewInstance(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = { args[0] };\n  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Object> instance =\n      cons->NewInstance(context, argc, argv).ToLocalChecked();\n\n  args.GetReturnValue().Set(instance);\n}\n\nvoid MyObject::PlusOne(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  MyObject* obj = ObjectWrap::Unwrap&#x3C;MyObject>(args.Holder());\n  obj->value_ += 1;\n\n  args.GetReturnValue().Set(Number::New(isolate, obj->value_));\n}\n\n}  // namespace demo\n</code></pre>\n<p>Once again, to build this example, the <code>myobject.cc</code> file must be added to the\n<code>binding.gyp</code>:</p>\n<pre><code class=\"language-json\">{\n  \"targets\": [\n    {\n      \"target_name\": \"addon\",\n      \"sources\": [\n        \"addon.cc\",\n        \"myobject.cc\"\n      ]\n    }\n  ]\n}\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst createObject = require('./build/Release/addon');\n\nconst obj = createObject(10);\nconsole.log(obj.plusOne());\n// Prints: 11\nconsole.log(obj.plusOne());\n// Prints: 12\nconsole.log(obj.plusOne());\n// Prints: 13\n\nconst obj2 = createObject(20);\nconsole.log(obj2.plusOne());\n// Prints: 21\nconsole.log(obj2.plusOne());\n// Prints: 22\nconsole.log(obj2.plusOne());\n// Prints: 23\n</code></pre>",
               "type": "module",
               "displayName": "Factory of wrapped objects"
             },
             {
               "textRaw": "Passing wrapped objects around",
               "name": "passing_wrapped_objects_around",
-              "desc": "<p>In addition to wrapping and returning C++ objects, it is possible to pass\nwrapped objects around by unwrapping them with the Node.js helper function\n<code>node::ObjectWrap::Unwrap</code>. The following examples shows a function <code>add()</code>\nthat can take two <code>MyObject</code> objects as input arguments:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  MyObject::NewInstance(args);\n}\n\nvoid Add(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  MyObject* obj1 = node::ObjectWrap::Unwrap&#x3C;MyObject>(\n      args[0]->ToObject(context).ToLocalChecked());\n  MyObject* obj2 = node::ObjectWrap::Unwrap&#x3C;MyObject>(\n      args[1]->ToObject(context).ToLocalChecked());\n\n  double sum = obj1->value() + obj2->value();\n  args.GetReturnValue().Set(Number::New(isolate, sum));\n}\n\nvoid InitAll(Local&#x3C;Object> exports) {\n  MyObject::Init(exports->GetIsolate());\n\n  NODE_SET_METHOD(exports, \"createObject\", CreateObject);\n  NODE_SET_METHOD(exports, \"add\", Add);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>In <code>myobject.h</code>, a new public method is added to allow access to private values\nafter unwrapping the object.</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Isolate* isolate);\n  static void NewInstance(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  inline double value() const { return value_; }\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static v8::Global&#x3C;v8::Function> constructor;\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>The implementation of <code>myobject.cc</code> is similar to before:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Global;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::NewStringType;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// Warning! This is not thread-safe, this addon cannot be used for worker\n// threads.\nGlobal&#x3C;Function> MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Isolate* isolate) {\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);\n  tpl->SetClassName(String::NewFromUtf8(\n      isolate, \"MyObject\", NewStringType::kNormal).ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());\n\n  AddEnvironmentCleanupHook(isolate, [](void*) {\n    constructor.Reset();\n  }, nullptr);\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n    Local&#x3C;Object> instance =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(instance);\n  }\n}\n\nvoid MyObject::NewInstance(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = { args[0] };\n  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Object> instance =\n      cons->NewInstance(context, argc, argv).ToLocalChecked();\n\n  args.GetReturnValue().Set(instance);\n}\n\n}  // namespace demo\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj1 = addon.createObject(10);\nconst obj2 = addon.createObject(20);\nconst result = addon.add(obj1, obj2);\n\nconsole.log(result);\n// Prints: 30\n</code></pre>",
+              "desc": "<p>In addition to wrapping and returning C++ objects, it is possible to pass\nwrapped objects around by unwrapping them with the Node.js helper function\n<code>node::ObjectWrap::Unwrap</code>. The following examples shows a function <code>add()</code>\nthat can take two <code>MyObject</code> objects as input arguments:</p>\n<pre><code class=\"language-cpp\">// addon.cc\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing v8::Context;\nusing v8::FunctionCallbackInfo;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Number;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\nvoid CreateObject(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  MyObject::NewInstance(args);\n}\n\nvoid Add(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  MyObject* obj1 = node::ObjectWrap::Unwrap&#x3C;MyObject>(\n      args[0]->ToObject(context).ToLocalChecked());\n  MyObject* obj2 = node::ObjectWrap::Unwrap&#x3C;MyObject>(\n      args[1]->ToObject(context).ToLocalChecked());\n\n  double sum = obj1->value() + obj2->value();\n  args.GetReturnValue().Set(Number::New(isolate, sum));\n}\n\nvoid InitAll(Local&#x3C;Object> exports) {\n  MyObject::Init(exports->GetIsolate());\n\n  NODE_SET_METHOD(exports, \"createObject\", CreateObject);\n  NODE_SET_METHOD(exports, \"add\", Add);\n}\n\nNODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)\n\n}  // namespace demo\n</code></pre>\n<p>In <code>myobject.h</code>, a new public method is added to allow access to private values\nafter unwrapping the object.</p>\n<pre><code class=\"language-cpp\">// myobject.h\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &#x3C;node.h>\n#include &#x3C;node_object_wrap.h>\n\nnamespace demo {\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Isolate* isolate);\n  static void NewInstance(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  inline double value() const { return value_; }\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static void New(const v8::FunctionCallbackInfo&#x3C;v8::Value>&#x26; args);\n  static v8::Global&#x3C;v8::Function> constructor;\n  double value_;\n};\n\n}  // namespace demo\n\n#endif\n</code></pre>\n<p>The implementation of <code>myobject.cc</code> is similar to before:</p>\n<pre><code class=\"language-cpp\">// myobject.cc\n#include &#x3C;node.h>\n#include \"myobject.h\"\n\nnamespace demo {\n\nusing node::AddEnvironmentCleanupHook;\nusing v8::Context;\nusing v8::Function;\nusing v8::FunctionCallbackInfo;\nusing v8::FunctionTemplate;\nusing v8::Global;\nusing v8::Isolate;\nusing v8::Local;\nusing v8::Object;\nusing v8::String;\nusing v8::Value;\n\n// Warning! This is not thread-safe, this addon cannot be used for worker\n// threads.\nGlobal&#x3C;Function> MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Isolate* isolate) {\n  // Prepare constructor template\n  Local&#x3C;FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);\n  tpl->SetClassName(String::NewFromUtf8(isolate, \"MyObject\").ToLocalChecked());\n  tpl->InstanceTemplate()->SetInternalFieldCount(1);\n\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());\n\n  AddEnvironmentCleanupHook(isolate, [](void*) {\n    constructor.Reset();\n  }, nullptr);\n}\n\nvoid MyObject::New(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]->IsUndefined() ?\n        0 : args[0]->NumberValue(context).FromMaybe(0);\n    MyObject* obj = new MyObject(value);\n    obj->Wrap(args.This());\n    args.GetReturnValue().Set(args.This());\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&#x3C;Value> argv[argc] = { args[0] };\n    Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n    Local&#x3C;Object> instance =\n        cons->NewInstance(context, argc, argv).ToLocalChecked();\n    args.GetReturnValue().Set(instance);\n  }\n}\n\nvoid MyObject::NewInstance(const FunctionCallbackInfo&#x3C;Value>&#x26; args) {\n  Isolate* isolate = args.GetIsolate();\n\n  const unsigned argc = 1;\n  Local&#x3C;Value> argv[argc] = { args[0] };\n  Local&#x3C;Function> cons = Local&#x3C;Function>::New(isolate, constructor);\n  Local&#x3C;Context> context = isolate->GetCurrentContext();\n  Local&#x3C;Object> instance =\n      cons->NewInstance(context, argc, argv).ToLocalChecked();\n\n  args.GetReturnValue().Set(instance);\n}\n\n}  // namespace demo\n</code></pre>\n<p>Test it with:</p>\n<pre><code class=\"language-js\">// test.js\nconst addon = require('./build/Release/addon');\n\nconst obj1 = addon.createObject(10);\nconst obj2 = addon.createObject(20);\nconst result = addon.add(obj1, obj2);\n\nconsole.log(result);\n// Prints: 30\n</code></pre>",
               "type": "module",
               "displayName": "Passing wrapped objects around"
             }
@@ -178,28 +186,29 @@
           "type": "misc",
           "displayName": "Addon examples"
         }
-      ]
+      ],
+      "source": "doc/api/addons.md"
     },
     {
-      "textRaw": "N-API",
-      "name": "N-API",
+      "textRaw": "Node-API",
+      "name": "Node-API",
       "introduced_in": "v8.0.0",
       "type": "misc",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p>N-API (pronounced N as in the letter, followed by API)\nis an API for building native Addons. It is independent from\nthe underlying JavaScript runtime (for example, V8) and is maintained as part of\nNode.js itself. This API will be Application Binary Interface (ABI) stable\nacross versions of Node.js. It is intended to insulate Addons from\nchanges in the underlying JavaScript engine and allow modules\ncompiled for one major version to run on later major versions of Node.js without\nrecompilation. The <a href=\"https://nodejs.org/en/docs/guides/abi-stability/\">ABI Stability</a> guide provides a more in-depth explanation.</p>\n<p>Addons are built/packaged with the same approach/tools outlined in the section\ntitled <a href=\"addons.html\">C++ Addons</a>. The only difference is the set of APIs that are used by\nthe native code. Instead of using the V8 or <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a>\nAPIs, the functions available in the N-API are used.</p>\n<p>APIs exposed by N-API are generally used to create and manipulate\nJavaScript values. Concepts and operations generally map to ideas specified\nin the ECMA-262 Language Specification. The APIs have the following\nproperties:</p>\n<ul>\n<li>All N-API calls return a status code of type <code>napi_status</code>. This\nstatus indicates whether the API call succeeded or failed.</li>\n<li>The API's return value is passed via an out parameter.</li>\n<li>All JavaScript values are abstracted behind an opaque type named\n<code>napi_value</code>.</li>\n<li>In case of an error status code, additional information can be obtained\nusing <code>napi_get_last_error_info</code>. More information can be found in the error\nhandling section <a href=\"n-api.html#n_api_error_handling\">Error handling</a>.</li>\n</ul>\n<p>The N-API is a C API that ensures ABI stability across Node.js versions\nand different compiler levels. A C++ API can be easier to use.\nTo support using C++, the project maintains a\nC++ wrapper module called <a href=\"https://github.com/nodejs/node-addon-api\"><code>node-addon-api</code></a>.\nThis wrapper provides an inlineable C++ API. Binaries built\nwith <code>node-addon-api</code> will depend on the symbols for the N-API C-based\nfunctions exported by Node.js. <code>node-addon-api</code> is a more\nefficient way to write code that calls N-API. Take, for example, the\nfollowing <code>node-addon-api</code> code. The first section shows the\n<code>node-addon-api</code> code and the second section shows what actually gets\nused in the addon.</p>\n<pre><code class=\"language-cpp\">Object obj = Object::New(env);\nobj[\"foo\"] = String::New(env, \"bar\");\n</code></pre>\n<pre><code class=\"language-cpp\">napi_status status;\nnapi_value object, string;\nstatus = napi_create_object(env, &#x26;object);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n\nstatus = napi_create_string_utf8(env, \"bar\", NAPI_AUTO_LENGTH, &#x26;string);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n\nstatus = napi_set_named_property(env, object, \"foo\", string);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n</code></pre>\n<p>The end result is that the addon only uses the exported C APIs. As a result,\nit still gets the benefits of the ABI stability provided by the C API.</p>\n<p>When using <code>node-addon-api</code> instead of the C APIs, start with the API <a href=\"https://github.com/nodejs/node-addon-api#api-documentation\">docs</a>\nfor <code>node-addon-api</code>.</p>\n<p>The <a href=\"https://nodejs.github.io/node-addon-examples/\">N-API Resource</a> offers an\nexcellent orientation and tips for developers just getting started with N-API\nand <code>node-addon-api</code>.</p>",
+      "desc": "<p>Node-API (formerly N-API) is an API for building native Addons. It is\nindependent from the underlying JavaScript runtime (for example, V8) and is\nmaintained as part of Node.js itself. This API will be Application Binary\nInterface (ABI) stable across versions of Node.js. It is intended to insulate\naddons from changes in the underlying JavaScript engine and allow modules\ncompiled for one major version to run on later major versions of Node.js without\nrecompilation. The <a href=\"https://nodejs.org/en/docs/guides/abi-stability/\">ABI Stability</a> guide provides a more in-depth explanation.</p>\n<p>Addons are built/packaged with the same approach/tools outlined in the section\ntitled <a href=\"addons.html\">C++ Addons</a>. The only difference is the set of APIs that are used by\nthe native code. Instead of using the V8 or <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a>\nAPIs, the functions available in Node-API are used.</p>\n<p>APIs exposed by Node-API are generally used to create and manipulate\nJavaScript values. Concepts and operations generally map to ideas specified\nin the ECMA-262 Language Specification. The APIs have the following\nproperties:</p>\n<ul>\n<li>All Node-API calls return a status code of type <code>napi_status</code>. This\nstatus indicates whether the API call succeeded or failed.</li>\n<li>The API's return value is passed via an out parameter.</li>\n<li>All JavaScript values are abstracted behind an opaque type named\n<code>napi_value</code>.</li>\n<li>In case of an error status code, additional information can be obtained\nusing <code>napi_get_last_error_info</code>. More information can be found in the error\nhandling section <a href=\"n-api.html#n_api_error_handling\">Error handling</a>.</li>\n</ul>\n<p>Node-API is a C API that ensures ABI stability across Node.js versions\nand different compiler levels. A C++ API can be easier to use.\nTo support using C++, the project maintains a\nC++ wrapper module called <a href=\"https://github.com/nodejs/node-addon-api\"><code>node-addon-api</code></a>.\nThis wrapper provides an inlineable C++ API. Binaries built\nwith <code>node-addon-api</code> will depend on the symbols for the Node-API C-based\nfunctions exported by Node.js. <code>node-addon-api</code> is a more\nefficient way to write code that calls Node-API. Take, for example, the\nfollowing <code>node-addon-api</code> code. The first section shows the\n<code>node-addon-api</code> code and the second section shows what actually gets\nused in the addon.</p>\n<pre><code class=\"language-cpp\">Object obj = Object::New(env);\nobj[\"foo\"] = String::New(env, \"bar\");\n</code></pre>\n<pre><code class=\"language-cpp\">napi_status status;\nnapi_value object, string;\nstatus = napi_create_object(env, &#x26;object);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n\nstatus = napi_create_string_utf8(env, \"bar\", NAPI_AUTO_LENGTH, &#x26;string);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n\nstatus = napi_set_named_property(env, object, \"foo\", string);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n</code></pre>\n<p>The end result is that the addon only uses the exported C APIs. As a result,\nit still gets the benefits of the ABI stability provided by the C API.</p>\n<p>When using <code>node-addon-api</code> instead of the C APIs, start with the API <a href=\"https://github.com/nodejs/node-addon-api#api-documentation\">docs</a>\nfor <code>node-addon-api</code>.</p>\n<p>The <a href=\"https://nodejs.github.io/node-addon-examples/\">Node-API Resource</a> offers\nan excellent orientation and tips for developers just getting started with\nNode-API and <code>node-addon-api</code>.</p>",
       "miscs": [
         {
           "textRaw": "Implications of ABI stability",
           "name": "implications_of_abi_stability",
-          "desc": "<p>Although N-API provides an ABI stability guarantee, other parts of Node.js do\nnot, and any external libraries used from the addon may not. In particular,\nnone of the following APIs provide an ABI stability guarantee across major\nversions:</p>\n<ul>\n<li>\n<p>the Node.js C++ APIs available via any of</p>\n<pre><code class=\"language-cpp\">#include &#x3C;node.h>\n#include &#x3C;node_buffer.h>\n#include &#x3C;node_version.h>\n#include &#x3C;node_object_wrap.h>\n</code></pre>\n</li>\n<li>\n<p>the libuv APIs which are also included with Node.js and available via</p>\n<pre><code class=\"language-cpp\">#include &#x3C;uv.h>\n</code></pre>\n</li>\n<li>\n<p>the V8 API available via</p>\n<pre><code class=\"language-cpp\">#include &#x3C;v8.h>\n</code></pre>\n</li>\n</ul>\n<p>Thus, for an addon to remain ABI-compatible across Node.js major versions, it\nmust use N-API exclusively by restricting itself to using</p>\n<pre><code class=\"language-c\">#include &#x3C;node_api.h>\n</code></pre>\n<p>and by checking, for all external libraries that it uses, that the external\nlibrary makes ABI stability guarantees similar to N-API.</p>",
+          "desc": "<p>Although Node-API provides an ABI stability guarantee, other parts of Node.js do\nnot, and any external libraries used from the addon may not. In particular,\nnone of the following APIs provide an ABI stability guarantee across major\nversions:</p>\n<ul>\n<li>\n<p>the Node.js C++ APIs available via any of</p>\n<pre><code class=\"language-cpp\">#include &#x3C;node.h>\n#include &#x3C;node_buffer.h>\n#include &#x3C;node_version.h>\n#include &#x3C;node_object_wrap.h>\n</code></pre>\n</li>\n<li>\n<p>the libuv APIs which are also included with Node.js and available via</p>\n<pre><code class=\"language-cpp\">#include &#x3C;uv.h>\n</code></pre>\n</li>\n<li>\n<p>the V8 API available via</p>\n<pre><code class=\"language-cpp\">#include &#x3C;v8.h>\n</code></pre>\n</li>\n</ul>\n<p>Thus, for an addon to remain ABI-compatible across Node.js major versions, it\nmust use Node-API exclusively by restricting itself to using</p>\n<pre><code class=\"language-c\">#include &#x3C;node_api.h>\n</code></pre>\n<p>and by checking, for all external libraries that it uses, that the external\nlibrary makes ABI stability guarantees similar to Node-API.</p>",
           "type": "misc",
           "displayName": "Implications of ABI stability"
         },
         {
           "textRaw": "Building",
           "name": "building",
-          "desc": "<p>Unlike modules written in JavaScript, developing and deploying Node.js\nnative addons using N-API requires an additional set of tools. Besides the\nbasic tools required to develop for Node.js, the native addon developer\nrequires a toolchain that can compile C and C++ code into a binary. In\naddition, depending upon how the native addon is deployed, the <em>user</em> of\nthe native addon will also need to have a C/C++ toolchain installed.</p>\n<p>For Linux developers, the necessary C/C++ toolchain packages are readily\navailable. <a href=\"https://gcc.gnu.org\">GCC</a> is widely used in the Node.js community to build and\ntest across a variety of platforms. For many developers, the <a href=\"https://llvm.org\">LLVM</a>\ncompiler infrastructure is also a good choice.</p>\n<p>For Mac developers, <a href=\"https://developer.apple.com/xcode/\">Xcode</a> offers all the required compiler tools.\nHowever, it is not necessary to install the entire Xcode IDE. The following\ncommand installs the necessary toolchain:</p>\n<pre><code class=\"language-bash\">xcode-select --install\n</code></pre>\n<p>For Windows developers, <a href=\"https://visualstudio.microsoft.com\">Visual Studio</a> offers all the required compiler\ntools. However, it is not necessary to install the entire Visual Studio\nIDE. The following command installs the necessary toolchain:</p>\n<pre><code class=\"language-bash\">npm install --global windows-build-tools\n</code></pre>\n<p>The sections below describe the additional tools available for developing\nand deploying Node.js native addons.</p>",
+          "desc": "<p>Unlike modules written in JavaScript, developing and deploying Node.js\nnative addons using Node-API requires an additional set of tools. Besides the\nbasic tools required to develop for Node.js, the native addon developer\nrequires a toolchain that can compile C and C++ code into a binary. In\naddition, depending upon how the native addon is deployed, the <em>user</em> of\nthe native addon will also need to have a C/C++ toolchain installed.</p>\n<p>For Linux developers, the necessary C/C++ toolchain packages are readily\navailable. <a href=\"https://gcc.gnu.org\">GCC</a> is widely used in the Node.js community to build and\ntest across a variety of platforms. For many developers, the <a href=\"https://llvm.org\">LLVM</a>\ncompiler infrastructure is also a good choice.</p>\n<p>For Mac developers, <a href=\"https://developer.apple.com/xcode/\">Xcode</a> offers all the required compiler tools.\nHowever, it is not necessary to install the entire Xcode IDE. The following\ncommand installs the necessary toolchain:</p>\n<pre><code class=\"language-bash\">xcode-select --install\n</code></pre>\n<p>For Windows developers, <a href=\"https://visualstudio.microsoft.com\">Visual Studio</a> offers all the required compiler\ntools. However, it is not necessary to install the entire Visual Studio\nIDE. The following command installs the necessary toolchain:</p>\n<pre><code class=\"language-bash\">npm install --global windows-build-tools\n</code></pre>\n<p>The sections below describe the additional tools available for developing\nand deploying Node.js native addons.</p>",
           "modules": [
             {
               "textRaw": "Build tools",
@@ -209,7 +218,7 @@
                 {
                   "textRaw": "node-gyp",
                   "name": "node-gyp",
-                  "desc": "<p><a href=\"https://github.com/nodejs/node-gyp\">node-gyp</a> is a build system based on Google's <a href=\"https://gyp.gsrc.io\">GYP</a> tool and comes\nbundled with npm. GYP, and therefore node-gyp, requires that Python be\ninstalled.</p>\n<p>Historically, node-gyp has been the tool of choice for building native\naddons. It has widespread adoption and documentation. However, some\ndevelopers have run into limitations in node-gyp.</p>",
+                  "desc": "<p><a href=\"https://github.com/nodejs/node-gyp\">node-gyp</a> is a build system based on the <a href=\"https://github.com/nodejs/gyp-next\">gyp-next</a> fork of\nGoogle's <a href=\"https://gyp.gsrc.io\">GYP</a> tool and comes bundled with npm. GYP, and therefore node-gyp,\nrequires that Python be installed.</p>\n<p>Historically, node-gyp has been the tool of choice for building native\naddons. It has widespread adoption and documentation. However, some\ndevelopers have run into limitations in node-gyp.</p>",
                   "type": "module",
                   "displayName": "node-gyp"
                 }
@@ -261,35 +270,36 @@
         {
           "textRaw": "Usage",
           "name": "usage",
-          "desc": "<p>In order to use the N-API functions, include the file <a href=\"https://github.com/nodejs/node/blob/master/src/node_api.h\"><code>node_api.h</code></a> which is\nlocated in the src directory in the node development tree:</p>\n<pre><code class=\"language-c\">#include &#x3C;node_api.h>\n</code></pre>\n<p>This will opt into the default <code>NAPI_VERSION</code> for the given release of Node.js.\nIn order to ensure compatibility with specific versions of N-API, the version\ncan be specified explicitly when including the header:</p>\n<pre><code class=\"language-c\">#define NAPI_VERSION 3\n#include &#x3C;node_api.h>\n</code></pre>\n<p>This restricts the N-API surface to just the functionality that was available in\nthe specified (and earlier) versions.</p>\n<p>Some of the N-API surface is experimental and requires explicit opt-in:</p>\n<pre><code class=\"language-c\">#define NAPI_EXPERIMENTAL\n#include &#x3C;node_api.h>\n</code></pre>\n<p>In this case the entire API surface, including any experimental APIs, will be\navailable to the module code.</p>",
+          "desc": "<p>In order to use the Node-API functions, include the file <a href=\"https://github.com/nodejs/node/blob/HEAD/src/node_api.h\"><code>node_api.h</code></a> which\nis located in the src directory in the node development tree:</p>\n<pre><code class=\"language-c\">#include &#x3C;node_api.h>\n</code></pre>\n<p>This will opt into the default <code>NAPI_VERSION</code> for the given release of Node.js.\nIn order to ensure compatibility with specific versions of Node-API, the version\ncan be specified explicitly when including the header:</p>\n<pre><code class=\"language-c\">#define NAPI_VERSION 3\n#include &#x3C;node_api.h>\n</code></pre>\n<p>This restricts the Node-API surface to just the functionality that was available\nin the specified (and earlier) versions.</p>\n<p>Some of the Node-API surface is experimental and requires explicit opt-in:</p>\n<pre><code class=\"language-c\">#define NAPI_EXPERIMENTAL\n#include &#x3C;node_api.h>\n</code></pre>\n<p>In this case the entire API surface, including any experimental APIs, will be\navailable to the module code.</p>",
           "type": "misc",
           "displayName": "Usage"
         },
         {
-          "textRaw": "N-API version matrix",
-          "name": "n-api_version_matrix",
-          "desc": "<p>N-API versions are additive and versioned independently from Node.js.\nVersion 4 is an extension to version 3 in that it has all of the APIs\nfrom version 3 with some additions. This means that it is not necessary\nto recompile for new versions of Node.js which are\nlisted as supporting a later version.</p>\n<table>\n<thead>\n<tr>\n<th></th>\n<th>1</th>\n<th>2</th>\n<th>3</th>\n<th>4</th>\n<th>5</th>\n<th>6</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>v6.x</td>\n<td></td>\n<td></td>\n<td>v6.14.2*</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>v8.x</td>\n<td>v8.0.0*</td>\n<td>v8.10.0*</td>\n<td>v8.11.2</td>\n<td>v8.16.0</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>v9.x</td>\n<td>v9.0.0*</td>\n<td>v9.3.0*</td>\n<td>v9.11.0*</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>v10.x</td>\n<td>v10.0.0</td>\n<td>v10.0.0</td>\n<td>v10.0.0</td>\n<td>v10.16.0</td>\n<td>v10.17.0</td>\n<td>v10.20.0</td>\n</tr>\n<tr>\n<td>v11.x</td>\n<td>v11.0.0</td>\n<td>v11.0.0</td>\n<td>v11.0.0</td>\n<td>v11.8.0</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>v12.x</td>\n<td>v12.0.0</td>\n<td>v12.0.0</td>\n<td>v12.0.0</td>\n<td>v12.0.0</td>\n<td>v12.11.0</td>\n<td>v12.17.0</td>\n</tr>\n<tr>\n<td>v13.x</td>\n<td>v13.0.0</td>\n<td>v13.0.0</td>\n<td>v13.0.0</td>\n<td>v13.0.0</td>\n<td>v13.0.0</td>\n<td></td>\n</tr>\n<tr>\n<td>v14.x</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n</tr>\n</tbody>\n</table>\n<p>* Indicates that the N-API version was released as experimental</p>\n<p>Each API documented for N-API will have a header named <code>added in:</code>, and APIs\nwhich are stable will have the additional header <code>N-API version:</code>.\nAPIs are directly usable when using a Node.js version which supports\nthe N-API version shown in <code>N-API version:</code> or higher.\nWhen using a Node.js version that does not support the\n<code>N-API version:</code> listed or if there is no <code>N-API version:</code> listed,\nthen the API will only be available if\n<code>#define NAPI_EXPERIMENTAL</code> precedes the inclusion of <code>node_api.h</code>\nor <code>js_native_api.h</code>. If an API appears not to be available on\na version of Node.js which is later than the one shown in <code>added in:</code> then\nthis is most likely the reason for the apparent absence.</p>\n<p>The N-APIs associated strictly with accessing ECMAScript features from native\ncode can be found separately in <code>js_native_api.h</code> and <code>js_native_api_types.h</code>.\nThe APIs defined in these headers are included in <code>node_api.h</code> and\n<code>node_api_types.h</code>. The headers are structured in this way in order to allow\nimplementations of N-API outside of Node.js. For those implementations the\nNode.js specific APIs may not be applicable.</p>\n<p>The Node.js-specific parts of an addon can be separated from the code that\nexposes the actual functionality to the JavaScript environment so that the\nlatter may be used with multiple implementations of N-API. In the example below,\n<code>addon.c</code> and <code>addon.h</code> refer only to <code>js_native_api.h</code>. This ensures that\n<code>addon.c</code> can be reused to compile against either the Node.js implementation of\nN-API or any implementation of N-API outside of Node.js.</p>\n<p><code>addon_node.c</code> is a separate file that contains the Node.js specific entry point\nto the addon and which instantiates the addon by calling into <code>addon.c</code> when the\naddon is loaded into a Node.js environment.</p>\n<pre><code class=\"language-c\">// addon.h\n#ifndef _ADDON_H_\n#define _ADDON_H_\n#include &#x3C;js_native_api.h>\nnapi_value create_addon(napi_env env);\n#endif  // _ADDON_H_\n</code></pre>\n<pre><code class=\"language-c\">// addon.c\n#include \"addon.h\"\n\n#define NAPI_CALL(env, call)                                      \\\n  do {                                                            \\\n    napi_status status = (call);                                  \\\n    if (status != napi_ok) {                                      \\\n      const napi_extended_error_info* error_info = NULL;          \\\n      napi_get_last_error_info((env), &#x26;error_info);               \\\n      bool is_pending;                                            \\\n      napi_is_exception_pending((env), &#x26;is_pending);              \\\n      if (!is_pending) {                                          \\\n        const char* message = (error_info->error_message == NULL) \\\n            ? \"empty error message\"                               \\\n            : error_info->error_message;                          \\\n        napi_throw_error((env), NULL, message);                   \\\n        return NULL;                                              \\\n      }                                                           \\\n    }                                                             \\\n  } while(0)\n\nstatic napi_value\nDoSomethingUseful(napi_env env, napi_callback_info info) {\n  // Do something useful.\n  return NULL;\n}\n\nnapi_value create_addon(napi_env env) {\n  napi_value result;\n  NAPI_CALL(env, napi_create_object(env, &#x26;result));\n\n  napi_value exported_function;\n  NAPI_CALL(env, napi_create_function(env,\n                                      \"doSomethingUseful\",\n                                      NAPI_AUTO_LENGTH,\n                                      DoSomethingUseful,\n                                      NULL,\n                                      &#x26;exported_function));\n\n  NAPI_CALL(env, napi_set_named_property(env,\n                                         result,\n                                         \"doSomethingUseful\",\n                                         exported_function));\n\n  return result;\n}\n</code></pre>\n<pre><code class=\"language-c\">// addon_node.c\n#include &#x3C;node_api.h>\n#include \"addon.h\"\n\nNAPI_MODULE_INIT() {\n  // This function body is expected to return a `napi_value`.\n  // The variables `napi_env env` and `napi_value exports` may be used within\n  // the body, as they are provided by the definition of `NAPI_MODULE_INIT()`.\n  return create_addon(env);\n}\n</code></pre>",
+          "textRaw": "Node-API version matrix",
+          "name": "node-api_version_matrix",
+          "desc": "<p>Node-API versions are additive and versioned independently from Node.js.\nVersion 4 is an extension to version 3 in that it has all of the APIs\nfrom version 3 with some additions. This means that it is not necessary\nto recompile for new versions of Node.js which are\nlisted as supporting a later version.</p>\n<!-- For accessibility purposes, this table needs row headers. That means we\n     can't do it in markdown. Hence, the raw HTML. -->\n<table>\n  <tr>\n    <td></td>\n    <th scope=\"col\">1</th>\n    <th scope=\"col\">2</th>\n    <th scope=\"col\">3</th>\n  </tr>\n  <tr>\n    <th scope=\"row\">v6.x</th>\n    <td></td>\n    <td></td>\n    <td>v6.14.2*</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v8.x</th>\n    <td>v8.6.0**</td>\n    <td>v8.10.0*</td>\n    <td>v8.11.2</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v9.x</th>\n    <td>v9.0.0*</td>\n    <td>v9.3.0*</td>\n    <td>v9.11.0*</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">≥ v10.x</th>\n    <td>all releases</td>\n    <td>all releases</td>\n    <td>all releases</td>\n  </tr>\n</table>\n<table>\n  <tr>\n    <td></td>\n    <th scope=\"col\">4</th>\n    <th scope=\"col\">5</th>\n    <th scope=\"col\">6</th>\n    <th scope=\"col\">7</th>\n    <th scope=\"col\">8</th>\n  </tr>\n  <tr>\n    <th scope=\"row\">v10.x</th>\n    <td>v10.16.0</td>\n    <td>v10.17.0</td>\n    <td>v10.20.0</td>\n    <td>v10.23.0</td>\n    <td></td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v11.x</th>\n    <td>v11.8.0</td>\n    <td></td>\n    <td></td>\n    <td></td>\n    <td></td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v12.x</th>\n    <td>v12.0.0</td>\n    <td>v12.11.0</td>\n    <td>v12.17.0</td>\n    <td>v12.19.0</td>\n    <td>v12.22.0</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v13.x</th>\n    <td>v13.0.0</td>\n    <td>v13.0.0</td>\n    <td></td>\n    <td></td>\n    <td></td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v14.x</th>\n    <td>v14.0.0</td>\n    <td>v14.0.0</td>\n    <td>v14.0.0</td>\n    <td>v14.12.0</td>\n    <td>v14.17.0</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v15.x</th>\n    <td>v15.0.0</td>\n    <td>v15.0.0</td>\n    <td>v15.0.0</td>\n    <td>v15.0.0</td>\n    <td>v15.12.0</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v16.x</th>\n    <td>v16.0.0</td>\n    <td>v16.0.0</td>\n    <td>v16.0.0</td>\n    <td>v16.0.0</td>\n    <td>v16.0.0</td>\n  </tr>\n</table>\n<p>* Node-API was experimental.</p>\n<p>** Node.js 8.0.0 included Node-API as experimental. It was released as\nNode-API version 1 but continued to evolve until Node.js 8.6.0. The API is\ndifferent in versions prior to Node.js 8.6.0. We recommend Node-API version 3 or\nlater.</p>\n<p>Each API documented for Node-API will have a header named <code>added in:</code>, and APIs\nwhich are stable will have the additional header <code>Node-API version:</code>.\nAPIs are directly usable when using a Node.js version which supports\nthe Node-API version shown in <code>Node-API version:</code> or higher.\nWhen using a Node.js version that does not support the\n<code>Node-API version:</code> listed or if there is no <code>Node-API version:</code> listed,\nthen the API will only be available if\n<code>#define NAPI_EXPERIMENTAL</code> precedes the inclusion of <code>node_api.h</code>\nor <code>js_native_api.h</code>. If an API appears not to be available on\na version of Node.js which is later than the one shown in <code>added in:</code> then\nthis is most likely the reason for the apparent absence.</p>\n<p>The Node-APIs associated strictly with accessing ECMAScript features from native\ncode can be found separately in <code>js_native_api.h</code> and <code>js_native_api_types.h</code>.\nThe APIs defined in these headers are included in <code>node_api.h</code> and\n<code>node_api_types.h</code>. The headers are structured in this way in order to allow\nimplementations of Node-API outside of Node.js. For those implementations the\nNode.js specific APIs may not be applicable.</p>\n<p>The Node.js-specific parts of an addon can be separated from the code that\nexposes the actual functionality to the JavaScript environment so that the\nlatter may be used with multiple implementations of Node-API. In the example\nbelow, <code>addon.c</code> and <code>addon.h</code> refer only to <code>js_native_api.h</code>. This ensures\nthat <code>addon.c</code> can be reused to compile against either the Node.js\nimplementation of Node-API or any implementation of Node-API outside of Node.js.</p>\n<p><code>addon_node.c</code> is a separate file that contains the Node.js specific entry point\nto the addon and which instantiates the addon by calling into <code>addon.c</code> when the\naddon is loaded into a Node.js environment.</p>\n<pre><code class=\"language-c\">// addon.h\n#ifndef _ADDON_H_\n#define _ADDON_H_\n#include &#x3C;js_native_api.h>\nnapi_value create_addon(napi_env env);\n#endif  // _ADDON_H_\n</code></pre>\n<pre><code class=\"language-c\">// addon.c\n#include \"addon.h\"\n\n#define NAPI_CALL(env, call)                                      \\\n  do {                                                            \\\n    napi_status status = (call);                                  \\\n    if (status != napi_ok) {                                      \\\n      const napi_extended_error_info* error_info = NULL;          \\\n      napi_get_last_error_info((env), &#x26;error_info);               \\\n      bool is_pending;                                            \\\n      napi_is_exception_pending((env), &#x26;is_pending);              \\\n      if (!is_pending) {                                          \\\n        const char* message = (error_info->error_message == NULL) \\\n            ? \"empty error message\"                               \\\n            : error_info->error_message;                          \\\n        napi_throw_error((env), NULL, message);                   \\\n        return NULL;                                              \\\n      }                                                           \\\n    }                                                             \\\n  } while(0)\n\nstatic napi_value\nDoSomethingUseful(napi_env env, napi_callback_info info) {\n  // Do something useful.\n  return NULL;\n}\n\nnapi_value create_addon(napi_env env) {\n  napi_value result;\n  NAPI_CALL(env, napi_create_object(env, &#x26;result));\n\n  napi_value exported_function;\n  NAPI_CALL(env, napi_create_function(env,\n                                      \"doSomethingUseful\",\n                                      NAPI_AUTO_LENGTH,\n                                      DoSomethingUseful,\n                                      NULL,\n                                      &#x26;exported_function));\n\n  NAPI_CALL(env, napi_set_named_property(env,\n                                         result,\n                                         \"doSomethingUseful\",\n                                         exported_function));\n\n  return result;\n}\n</code></pre>\n<pre><code class=\"language-c\">// addon_node.c\n#include &#x3C;node_api.h>\n#include \"addon.h\"\n\nNAPI_MODULE_INIT() {\n  // This function body is expected to return a `napi_value`.\n  // The variables `napi_env env` and `napi_value exports` may be used within\n  // the body, as they are provided by the definition of `NAPI_MODULE_INIT()`.\n  return create_addon(env);\n}\n</code></pre>",
           "type": "misc",
-          "displayName": "N-API version matrix"
+          "displayName": "Node-API version matrix"
         },
         {
           "textRaw": "Environment life cycle APIs",
           "name": "environment_life_cycle_apis",
-          "desc": "<p><a href=\"https://tc39.es/ecma262/#sec-agents\">Section 8.7</a> of the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a> defines the concept\nof an \"Agent\" as a self-contained environment in which JavaScript code runs.\nMultiple such Agents may be started and terminated either concurrently or in\nsequence by the process.</p>\n<p>A Node.js environment corresponds to an ECMAScript Agent. In the main process,\nan environment is created at startup, and additional environments can be created\non separate threads to serve as <a href=\"https://nodejs.org/api/worker_threads.html\">worker threads</a>. When Node.js is embedded in\nanother application, the main thread of the application may also construct and\ndestroy a Node.js environment multiple times during the life cycle of the\napplication process such that each Node.js environment created by the\napplication may, in turn, during its life cycle create and destroy additional\nenvironments as worker threads.</p>\n<p>From the perspective of a native addon this means that the bindings it provides\nmay be called multiple times, from multiple contexts, and even concurrently from\nmultiple threads.</p>\n<p>Native addons may need to allocate global state which they use during\ntheir entire life cycle such that the state must be unique to each instance of\nthe addon.</p>\n<p>To this end, N-API provides a way to allocate data such that its life cycle is\ntied to the life cycle of the Agent.</p>",
+          "desc": "<p><a href=\"https://tc39.es/ecma262/#sec-agents\">Section 8.7</a> of the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a> defines the concept\nof an \"Agent\" as a self-contained environment in which JavaScript code runs.\nMultiple such Agents may be started and terminated either concurrently or in\nsequence by the process.</p>\n<p>A Node.js environment corresponds to an ECMAScript Agent. In the main process,\nan environment is created at startup, and additional environments can be created\non separate threads to serve as <a href=\"https://nodejs.org/api/worker_threads.html\">worker threads</a>. When Node.js is embedded in\nanother application, the main thread of the application may also construct and\ndestroy a Node.js environment multiple times during the life cycle of the\napplication process such that each Node.js environment created by the\napplication may, in turn, during its life cycle create and destroy additional\nenvironments as worker threads.</p>\n<p>From the perspective of a native addon this means that the bindings it provides\nmay be called multiple times, from multiple contexts, and even concurrently from\nmultiple threads.</p>\n<p>Native addons may need to allocate global state which they use during\ntheir entire life cycle such that the state must be unique to each instance of\nthe addon.</p>\n<p>To this end, Node-API provides a way to allocate data such that its life cycle\nis tied to the life cycle of the Agent.</p>",
           "modules": [
             {
               "textRaw": "napi_set_instance_data",
               "name": "napi_set_instance_data",
               "meta": {
                 "added": [
-                  "v12.8.0"
+                  "v12.8.0",
+                  "v10.20.0"
                 ],
                 "napiVersion": [
                   6
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_set_instance_data(napi_env env,\n                                   void* data,\n                                   napi_finalize finalize_cb,\n                                   void* finalize_hint);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] data</code>: The data item to make available to bindings of this instance.</li>\n<li><code>[in] finalize_cb</code>: The function to call when the environment is being torn\ndown. The function receives <code>data</code> so that it might free it.\n<a href=\"n-api.html#n_api_napi_finalize\"><code>napi_finalize</code></a> provides more details.</li>\n<li><code>[in] finalize_hint</code>: Optional hint to pass to the finalize callback during\ncollection.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API associates <code>data</code> with the currently running Agent. <code>data</code> can later\nbe retrieved using <code>napi_get_instance_data()</code>. Any existing data associated with\nthe currently running Agent which was set by means of a previous call to\n<code>napi_set_instance_data()</code> will be overwritten. If a <code>finalize_cb</code> was provided\nby the previous call, it will not be called.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_set_instance_data(napi_env env,\n                                   void* data,\n                                   napi_finalize finalize_cb,\n                                   void* finalize_hint);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] data</code>: The data item to make available to bindings of this instance.</li>\n<li><code>[in] finalize_cb</code>: The function to call when the environment is being torn\ndown. The function receives <code>data</code> so that it might free it.\n<a href=\"n-api.html#n_api_napi_finalize\"><code>napi_finalize</code></a> provides more details.</li>\n<li><code>[in] finalize_hint</code>: Optional hint to pass to the finalize callback during\ncollection.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API associates <code>data</code> with the currently running Agent. <code>data</code> can later\nbe retrieved using <code>napi_get_instance_data()</code>. Any existing data associated with\nthe currently running Agent which was set by means of a previous call to\n<code>napi_set_instance_data()</code> will be overwritten. If a <code>finalize_cb</code> was provided\nby the previous call, it will not be called.</p>",
               "type": "module",
               "displayName": "napi_set_instance_data"
             },
@@ -298,14 +308,15 @@
               "name": "napi_get_instance_data",
               "meta": {
                 "added": [
-                  "v12.8.0"
+                  "v12.8.0",
+                  "v10.20.0"
                 ],
                 "napiVersion": [
                   6
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_get_instance_data(napi_env env,\n                                   void** data);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[out] data</code>: The data item that was previously associated with the currently\nrunning Agent by a call to <code>napi_set_instance_data()</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API retrieves data that was previously associated with the currently\nrunning Agent via <code>napi_set_instance_data()</code>. If no data is set, the call will\nsucceed and <code>data</code> will be set to <code>NULL</code>.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_get_instance_data(napi_env env,\n                                   void** data);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[out] data</code>: The data item that was previously associated with the currently\nrunning Agent by a call to <code>napi_set_instance_data()</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API retrieves data that was previously associated with the currently\nrunning Agent via <code>napi_set_instance_data()</code>. If no data is set, the call will\nsucceed and <code>data</code> will be set to <code>NULL</code>.</p>",
               "type": "module",
               "displayName": "napi_get_instance_data"
             }
@@ -314,9 +325,9 @@
           "displayName": "Environment life cycle APIs"
         },
         {
-          "textRaw": "Basic N-API data types",
-          "name": "basic_n-api_data_types",
-          "desc": "<p>N-API exposes the following fundamental datatypes as abstractions that are\nconsumed by the various APIs. These APIs should be treated as opaque,\nintrospectable only with other N-API calls.</p>",
+          "textRaw": "Basic Node-API data types",
+          "name": "basic_node-api_data_types",
+          "desc": "<p>Node-API exposes the following fundamental datatypes as abstractions that are\nconsumed by the various APIs. These APIs should be treated as opaque,\nintrospectable only with other Node-API calls.</p>",
           "modules": [
             {
               "textRaw": "napi_status",
@@ -330,7 +341,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Integral status code indicating the success or failure of a N-API call.\nCurrently, the following status codes are supported.</p>\n<pre><code class=\"language-c\">typedef enum {\n  napi_ok,\n  napi_invalid_arg,\n  napi_object_expected,\n  napi_string_expected,\n  napi_name_expected,\n  napi_function_expected,\n  napi_number_expected,\n  napi_boolean_expected,\n  napi_array_expected,\n  napi_generic_failure,\n  napi_pending_exception,\n  napi_cancelled,\n  napi_escape_called_twice,\n  napi_handle_scope_mismatch,\n  napi_callback_scope_mismatch,\n  napi_queue_full,\n  napi_closing,\n  napi_bigint_expected,\n  napi_date_expected,\n  napi_arraybuffer_expected,\n  napi_detachable_arraybuffer_expected,\n} napi_status;\n</code></pre>\n<p>If additional information is required upon an API returning a failed status,\nit can be obtained by calling <code>napi_get_last_error_info</code>.</p>",
+              "desc": "<p>Integral status code indicating the success or failure of a Node-API call.\nCurrently, the following status codes are supported.</p>\n<pre><code class=\"language-c\">typedef enum {\n  napi_ok,\n  napi_invalid_arg,\n  napi_object_expected,\n  napi_string_expected,\n  napi_name_expected,\n  napi_function_expected,\n  napi_number_expected,\n  napi_boolean_expected,\n  napi_array_expected,\n  napi_generic_failure,\n  napi_pending_exception,\n  napi_cancelled,\n  napi_escape_called_twice,\n  napi_handle_scope_mismatch,\n  napi_callback_scope_mismatch,\n  napi_queue_full,\n  napi_closing,\n  napi_bigint_expected,\n  napi_date_expected,\n  napi_arraybuffer_expected,\n  napi_detachable_arraybuffer_expected,\n  napi_would_deadlock,  /* unused */\n} napi_status;\n</code></pre>\n<p>If additional information is required upon an API returning a failed status,\nit can be obtained by calling <code>napi_get_last_error_info</code>.</p>",
               "type": "module",
               "displayName": "napi_status"
             },
@@ -346,14 +357,14 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">typedef struct {\n  const char* error_message;\n  void* engine_reserved;\n  uint32_t engine_error_code;\n  napi_status error_code;\n} napi_extended_error_info;\n</code></pre>\n<ul>\n<li><code>error_message</code>: UTF8-encoded string containing a VM-neutral description of\nthe error.</li>\n<li><code>engine_reserved</code>: Reserved for VM-specific error details. This is currently\nnot implemented for any VM.</li>\n<li><code>engine_error_code</code>: VM-specific error code. This is currently\nnot implemented for any VM.</li>\n<li><code>error_code</code>: The N-API status code that originated with the last error.</li>\n</ul>\n<p>See the <a href=\"n-api.html#n_api_error_handling\">Error handling</a> section for additional information.</p>",
+              "desc": "<pre><code class=\"language-c\">typedef struct {\n  const char* error_message;\n  void* engine_reserved;\n  uint32_t engine_error_code;\n  napi_status error_code;\n} napi_extended_error_info;\n</code></pre>\n<ul>\n<li><code>error_message</code>: UTF8-encoded string containing a VM-neutral description of\nthe error.</li>\n<li><code>engine_reserved</code>: Reserved for VM-specific error details. This is currently\nnot implemented for any VM.</li>\n<li><code>engine_error_code</code>: VM-specific error code. This is currently\nnot implemented for any VM.</li>\n<li><code>error_code</code>: The Node-API status code that originated with the last error.</li>\n</ul>\n<p>See the <a href=\"n-api.html#n_api_error_handling\">Error handling</a> section for additional information.</p>",
               "type": "module",
               "displayName": "napi_extended_error_info"
             },
             {
               "textRaw": "napi_env",
               "name": "napi_env",
-              "desc": "<p><code>napi_env</code> is used to represent a context that the underlying N-API\nimplementation can use to persist VM-specific state. This structure is passed\nto native functions when they're invoked, and it must be passed back when\nmaking N-API calls. Specifically, the same <code>napi_env</code> that was passed in when\nthe initial native function was called must be passed to any subsequent\nnested N-API calls. Caching the <code>napi_env</code> for the purpose of general reuse,\nand passing the <code>napi_env</code> between instances of the same addon running on\ndifferent <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads is not allowed. The <code>napi_env</code> becomes invalid\nwhen an instance of a native addon is unloaded. Notification of this event is\ndelivered through the callbacks given to <a href=\"n-api.html#n_api_napi_add_env_cleanup_hook\"><code>napi_add_env_cleanup_hook</code></a> and\n<a href=\"n-api.html#n_api_napi_set_instance_data\"><code>napi_set_instance_data</code></a>.</p>",
+              "desc": "<p><code>napi_env</code> is used to represent a context that the underlying Node-API\nimplementation can use to persist VM-specific state. This structure is passed\nto native functions when they're invoked, and it must be passed back when\nmaking Node-API calls. Specifically, the same <code>napi_env</code> that was passed in when\nthe initial native function was called must be passed to any subsequent\nnested Node-API calls. Caching the <code>napi_env</code> for the purpose of general reuse,\nand passing the <code>napi_env</code> between instances of the same addon running on\ndifferent <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads is not allowed. The <code>napi_env</code> becomes invalid\nwhen an instance of a native addon is unloaded. Notification of this event is\ndelivered through the callbacks given to <a href=\"n-api.html#n_api_napi_add_env_cleanup_hook\"><code>napi_add_env_cleanup_hook</code></a> and\n<a href=\"n-api.html#n_api_napi_set_instance_data\"><code>napi_set_instance_data</code></a>.</p>",
               "type": "module",
               "displayName": "napi_env"
             },
@@ -413,13 +424,13 @@
               "displayName": "napi_threadsafe_function_call_mode"
             },
             {
-              "textRaw": "N-API memory management types",
-              "name": "n-api_memory_management_types",
+              "textRaw": "Node-API memory management types",
+              "name": "node-api_memory_management_types",
               "modules": [
                 {
                   "textRaw": "napi_handle_scope",
                   "name": "napi_handle_scope",
-                  "desc": "<p>This is an abstraction used to control and modify the lifetime of objects\ncreated within a particular scope. In general, N-API values are created within\nthe context of a handle scope. When a native method is called from\nJavaScript, a default handle scope will exist. If the user does not explicitly\ncreate a new handle scope, N-API values will be created in the default handle\nscope. For any invocations of code outside the execution of a native method\n(for instance, during a libuv callback invocation), the module is required to\ncreate a scope before invoking any functions that can result in the creation\nof JavaScript values.</p>\n<p>Handle scopes are created using <a href=\"n-api.html#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and are destroyed\nusing <a href=\"n-api.html#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a>. Closing the scope can indicate to the GC\nthat all <code>napi_value</code>s created during the lifetime of the handle scope are no\nlonger referenced from the current stack frame.</p>\n<p>For more details, review the <a href=\"n-api.html#n_api_object_lifetime_management\">Object lifetime management</a>.</p>",
+                  "desc": "<p>This is an abstraction used to control and modify the lifetime of objects\ncreated within a particular scope. In general, Node-API values are created\nwithin the context of a handle scope. When a native method is called from\nJavaScript, a default handle scope will exist. If the user does not explicitly\ncreate a new handle scope, Node-API values will be created in the default handle\nscope. For any invocations of code outside the execution of a native method\n(for instance, during a libuv callback invocation), the module is required to\ncreate a scope before invoking any functions that can result in the creation\nof JavaScript values.</p>\n<p>Handle scopes are created using <a href=\"n-api.html#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and are destroyed\nusing <a href=\"n-api.html#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a>. Closing the scope can indicate to the GC\nthat all <code>napi_value</code>s created during the lifetime of the handle scope are no\nlonger referenced from the current stack frame.</p>\n<p>For more details, review the <a href=\"n-api.html#n_api_object_lifetime_management\">Object lifetime management</a>.</p>",
                   "type": "module",
                   "displayName": "napi_handle_scope"
                 },
@@ -460,6 +471,7 @@
                   "name": "napi_type_tag",
                   "meta": {
                     "added": [
+                      "v14.8.0",
                       "v12.19.0"
                     ],
                     "napiVersion": [
@@ -476,7 +488,7 @@
                   "name": "napi_async_cleanup_hook_handle",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.10.0"
                     ],
                     "changes": []
                   },
@@ -486,11 +498,11 @@
                 }
               ],
               "type": "module",
-              "displayName": "N-API memory management types"
+              "displayName": "Node-API memory management types"
             },
             {
-              "textRaw": "N-API callback types",
-              "name": "n-api_callback_types",
+              "textRaw": "Node-API callback types",
+              "name": "node-api_callback_types",
               "modules": [
                 {
                   "textRaw": "napi_callback_info",
@@ -520,7 +532,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Function pointer type for user-provided native functions which are to be\nexposed to JavaScript via N-API. Callback functions should satisfy the\nfollowing signature:</p>\n<pre><code class=\"language-c\">typedef napi_value (*napi_callback)(napi_env, napi_callback_info);\n</code></pre>\n<p>Unless for reasons discussed in <a href=\"n-api.html#n_api_object_lifetime_management\">Object Lifetime Management</a>, creating a\nhandle and/or callback scope inside a <code>napi_callback</code> is not necessary.</p>",
+                  "desc": "<p>Function pointer type for user-provided native functions which are to be\nexposed to JavaScript via Node-API. Callback functions should satisfy the\nfollowing signature:</p>\n<pre><code class=\"language-c\">typedef napi_value (*napi_callback)(napi_env, napi_callback_info);\n</code></pre>\n<p>Unless for reasons discussed in <a href=\"n-api.html#n_api_object_lifetime_management\">Object Lifetime Management</a>, creating a\nhandle and/or callback scope inside a <code>napi_callback</code> is not necessary.</p>",
                   "type": "module",
                   "displayName": "napi_callback"
                 },
@@ -552,7 +564,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Function pointer used with functions that support asynchronous\noperations. Callback functions must satisfy the following signature:</p>\n<pre><code class=\"language-c\">typedef void (*napi_async_execute_callback)(napi_env env, void* data);\n</code></pre>\n<p>Implementations of this function must avoid making N-API calls that execute\nJavaScript or interact with JavaScript objects. N-API calls should be in the\n<code>napi_async_complete_callback</code> instead. Do not use the <code>napi_env</code> parameter as\nit will likely result in execution of JavaScript.</p>",
+                  "desc": "<p>Function pointer used with functions that support asynchronous\noperations. Callback functions must satisfy the following signature:</p>\n<pre><code class=\"language-c\">typedef void (*napi_async_execute_callback)(napi_env env, void* data);\n</code></pre>\n<p>Implementations of this function must avoid making Node-API calls that execute\nJavaScript or interact with JavaScript objects. Node-API calls should be in the\n<code>napi_async_complete_callback</code> instead. Do not use the <code>napi_env</code> parameter as\nit will likely result in execution of JavaScript.</p>",
                   "type": "module",
                   "displayName": "napi_async_execute_callback"
                 },
@@ -584,7 +596,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Function pointer used with asynchronous thread-safe function calls. The callback\nwill be called on the main thread. Its purpose is to use a data item arriving\nvia the queue from one of the secondary threads to construct the parameters\nnecessary for a call into JavaScript, usually via <code>napi_call_function</code>, and then\nmake the call into JavaScript.</p>\n<p>The data arriving from the secondary thread via the queue is given in the <code>data</code>\nparameter and the JavaScript function to call is given in the <code>js_callback</code>\nparameter.</p>\n<p>N-API sets up the environment prior to calling this callback, so it is\nsufficient to call the JavaScript function via <code>napi_call_function</code> rather than\nvia <code>napi_make_callback</code>.</p>\n<p>Callback functions must satisfy the following signature:</p>\n<pre><code class=\"language-c\">typedef void (*napi_threadsafe_function_call_js)(napi_env env,\n                                                 napi_value js_callback,\n                                                 void* context,\n                                                 void* data);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment to use for API calls, or <code>NULL</code> if the thread-safe\nfunction is being torn down and <code>data</code> may need to be freed.</li>\n<li><code>[in] js_callback</code>: The JavaScript function to call, or <code>NULL</code> if the\nthread-safe function is being torn down and <code>data</code> may need to be freed. It\nmay also be <code>NULL</code> if the thread-safe function was created without\n<code>js_callback</code>.</li>\n<li><code>[in] context</code>: The optional data with which the thread-safe function was\ncreated.</li>\n<li><code>[in] data</code>: Data created by the secondary thread. It is the responsibility of\nthe callback to convert this native data to JavaScript values (with N-API\nfunctions) that can be passed as parameters when <code>js_callback</code> is invoked.\nThis pointer is managed entirely by the threads and this callback. Thus this\ncallback should free the data.</li>\n</ul>\n<p>Unless for reasons discussed in <a href=\"n-api.html#n_api_object_lifetime_management\">Object Lifetime Management</a>, creating a\nhandle and/or callback scope inside the function body is not necessary.</p>",
+                  "desc": "<p>Function pointer used with asynchronous thread-safe function calls. The callback\nwill be called on the main thread. Its purpose is to use a data item arriving\nvia the queue from one of the secondary threads to construct the parameters\nnecessary for a call into JavaScript, usually via <code>napi_call_function</code>, and then\nmake the call into JavaScript.</p>\n<p>The data arriving from the secondary thread via the queue is given in the <code>data</code>\nparameter and the JavaScript function to call is given in the <code>js_callback</code>\nparameter.</p>\n<p>Node-API sets up the environment prior to calling this callback, so it is\nsufficient to call the JavaScript function via <code>napi_call_function</code> rather than\nvia <code>napi_make_callback</code>.</p>\n<p>Callback functions must satisfy the following signature:</p>\n<pre><code class=\"language-c\">typedef void (*napi_threadsafe_function_call_js)(napi_env env,\n                                                 napi_value js_callback,\n                                                 void* context,\n                                                 void* data);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment to use for API calls, or <code>NULL</code> if the thread-safe\nfunction is being torn down and <code>data</code> may need to be freed.</li>\n<li><code>[in] js_callback</code>: The JavaScript function to call, or <code>NULL</code> if the\nthread-safe function is being torn down and <code>data</code> may need to be freed. It\nmay also be <code>NULL</code> if the thread-safe function was created without\n<code>js_callback</code>.</li>\n<li><code>[in] context</code>: The optional data with which the thread-safe function was\ncreated.</li>\n<li><code>[in] data</code>: Data created by the secondary thread. It is the responsibility of\nthe callback to convert this native data to JavaScript values (with Node-API\nfunctions) that can be passed as parameters when <code>js_callback</code> is invoked.\nThis pointer is managed entirely by the threads and this callback. Thus this\ncallback should free the data.</li>\n</ul>\n<p>Unless for reasons discussed in <a href=\"n-api.html#n_api_object_lifetime_management\">Object Lifetime Management</a>, creating a\nhandle and/or callback scope inside the function body is not necessary.</p>",
                   "type": "module",
                   "displayName": "napi_threadsafe_function_call_js"
                 },
@@ -593,7 +605,7 @@
                   "name": "napi_async_cleanup_hook",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.10.0"
                     ],
                     "changes": []
                   },
@@ -603,16 +615,16 @@
                 }
               ],
               "type": "module",
-              "displayName": "N-API callback types"
+              "displayName": "Node-API callback types"
             }
           ],
           "type": "misc",
-          "displayName": "Basic N-API data types"
+          "displayName": "Basic Node-API data types"
         },
         {
           "textRaw": "Error handling",
           "name": "error_handling",
-          "desc": "<p>N-API uses both return values and JavaScript exceptions for error handling.\nThe following sections explain the approach for each case.</p>",
+          "desc": "<p>Node-API uses both return values and JavaScript exceptions for error handling.\nThe following sections explain the approach for each case.</p>",
           "modules": [
             {
               "textRaw": "Return values",
@@ -626,7 +638,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>All of the N-API functions share the same error handling pattern. The\nreturn type of all API functions is <code>napi_status</code>.</p>\n<p>The return value will be <code>napi_ok</code> if the request was successful and\nno uncaught JavaScript exception was thrown. If an error occurred AND\nan exception was thrown, the <code>napi_status</code> value for the error\nwill be returned. If an exception was thrown, and no error occurred,\n<code>napi_pending_exception</code> will be returned.</p>\n<p>In cases where a return value other than <code>napi_ok</code> or\n<code>napi_pending_exception</code> is returned, <a href=\"n-api.html#n_api_napi_is_exception_pending\"><code>napi_is_exception_pending</code></a>\nmust be called to check if an exception is pending.\nSee the section on exceptions for more details.</p>\n<p>The full set of possible <code>napi_status</code> values is defined\nin <code>napi_api_types.h</code>.</p>\n<p>The <code>napi_status</code> return value provides a VM-independent representation of\nthe error which occurred. In some cases it is useful to be able to get\nmore detailed information, including a string representing the error as well as\nVM (engine)-specific information.</p>\n<p>In order to retrieve this information <a href=\"n-api.html#n_api_napi_get_last_error_info\"><code>napi_get_last_error_info</code></a>\nis provided which returns a <code>napi_extended_error_info</code> structure.\nThe format of the <code>napi_extended_error_info</code> structure is as follows:</p>\n<pre><code class=\"language-c\">typedef struct napi_extended_error_info {\n  const char* error_message;\n  void* engine_reserved;\n  uint32_t engine_error_code;\n  napi_status error_code;\n};\n</code></pre>\n<ul>\n<li><code>error_message</code>: Textual representation of the error that occurred.</li>\n<li><code>engine_reserved</code>: Opaque handle reserved for engine use only.</li>\n<li><code>engine_error_code</code>: VM specific error code.</li>\n<li><code>error_code</code>: n-api status code for the last error.</li>\n</ul>\n<p><a href=\"n-api.html#n_api_napi_get_last_error_info\"><code>napi_get_last_error_info</code></a> returns the information for the last\nN-API call that was made.</p>\n<p>Do not rely on the content or format of any of the extended information as it\nis not subject to SemVer and may change at any time. It is intended only for\nlogging purposes.</p>",
+              "desc": "<p>All of the Node-API functions share the same error handling pattern. The\nreturn type of all API functions is <code>napi_status</code>.</p>\n<p>The return value will be <code>napi_ok</code> if the request was successful and\nno uncaught JavaScript exception was thrown. If an error occurred AND\nan exception was thrown, the <code>napi_status</code> value for the error\nwill be returned. If an exception was thrown, and no error occurred,\n<code>napi_pending_exception</code> will be returned.</p>\n<p>In cases where a return value other than <code>napi_ok</code> or\n<code>napi_pending_exception</code> is returned, <a href=\"n-api.html#n_api_napi_is_exception_pending\"><code>napi_is_exception_pending</code></a>\nmust be called to check if an exception is pending.\nSee the section on exceptions for more details.</p>\n<p>The full set of possible <code>napi_status</code> values is defined\nin <code>napi_api_types.h</code>.</p>\n<p>The <code>napi_status</code> return value provides a VM-independent representation of\nthe error which occurred. In some cases it is useful to be able to get\nmore detailed information, including a string representing the error as well as\nVM (engine)-specific information.</p>\n<p>In order to retrieve this information <a href=\"n-api.html#n_api_napi_get_last_error_info\"><code>napi_get_last_error_info</code></a>\nis provided which returns a <code>napi_extended_error_info</code> structure.\nThe format of the <code>napi_extended_error_info</code> structure is as follows:</p>\n<pre><code class=\"language-c\">typedef struct napi_extended_error_info {\n  const char* error_message;\n  void* engine_reserved;\n  uint32_t engine_error_code;\n  napi_status error_code;\n};\n</code></pre>\n<ul>\n<li><code>error_message</code>: Textual representation of the error that occurred.</li>\n<li><code>engine_reserved</code>: Opaque handle reserved for engine use only.</li>\n<li><code>engine_error_code</code>: VM specific error code.</li>\n<li><code>error_code</code>: Node-API status code for the last error.</li>\n</ul>\n<p><a href=\"n-api.html#n_api_napi_get_last_error_info\"><code>napi_get_last_error_info</code></a> returns the information for the last\nNode-API call that was made.</p>\n<p>Do not rely on the content or format of any of the extended information as it\nis not subject to SemVer and may change at any time. It is intended only for\nlogging purposes.</p>",
               "modules": [
                 {
                   "textRaw": "napi_get_last_error_info",
@@ -640,7 +652,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status\nnapi_get_last_error_info(napi_env env,\n                         const napi_extended_error_info** result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[out] result</code>: The <code>napi_extended_error_info</code> structure with more\ninformation about the error.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API retrieves a <code>napi_extended_error_info</code> structure with information\nabout the last error that occurred.</p>\n<p>The content of the <code>napi_extended_error_info</code> returned is only valid up until\nan n-api function is called on the same <code>env</code>.</p>\n<p>Do not rely on the content or format of any of the extended information as it\nis not subject to SemVer and may change at any time. It is intended only for\nlogging purposes.</p>\n<p>This API can be called even if there is a pending JavaScript exception.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status\nnapi_get_last_error_info(napi_env env,\n                         const napi_extended_error_info** result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[out] result</code>: The <code>napi_extended_error_info</code> structure with more\ninformation about the error.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API retrieves a <code>napi_extended_error_info</code> structure with information\nabout the last error that occurred.</p>\n<p>The content of the <code>napi_extended_error_info</code> returned is only valid up until\na Node-API function is called on the same <code>env</code>.</p>\n<p>Do not rely on the content or format of any of the extended information as it\nis not subject to SemVer and may change at any time. It is intended only for\nlogging purposes.</p>\n<p>This API can be called even if there is a pending JavaScript exception.</p>",
                   "type": "module",
                   "displayName": "napi_get_last_error_info"
                 }
@@ -651,7 +663,7 @@
             {
               "textRaw": "Exceptions",
               "name": "exceptions",
-              "desc": "<p>Any N-API function call may result in a pending JavaScript exception. This is\nthe case for any of the API functions, even those that may not cause the\nexecution of JavaScript.</p>\n<p>If the <code>napi_status</code> returned by a function is <code>napi_ok</code> then no\nexception is pending and no additional action is required. If the\n<code>napi_status</code> returned is anything other than <code>napi_ok</code> or\n<code>napi_pending_exception</code>, in order to try to recover and continue\ninstead of simply returning immediately, <a href=\"n-api.html#n_api_napi_is_exception_pending\"><code>napi_is_exception_pending</code></a>\nmust be called in order to determine if an exception is pending or not.</p>\n<p>In many cases when an N-API function is called and an exception is\nalready pending, the function will return immediately with a\n<code>napi_status</code> of <code>napi_pending_exception</code>. However, this is not the case\nfor all functions. N-API allows a subset of the functions to be\ncalled to allow for some minimal cleanup before returning to JavaScript.\nIn that case, <code>napi_status</code> will reflect the status for the function. It\nwill not reflect previous pending exceptions. To avoid confusion, check\nthe error status after every function call.</p>\n<p>When an exception is pending one of two approaches can be employed.</p>\n<p>The first approach is to do any appropriate cleanup and then return so that\nexecution will return to JavaScript. As part of the transition back to\nJavaScript, the exception will be thrown at the point in the JavaScript\ncode where the native method was invoked. The behavior of most N-API calls\nis unspecified while an exception is pending, and many will simply return\n<code>napi_pending_exception</code>, so do as little as possible and then return to\nJavaScript where the exception can be handled.</p>\n<p>The second approach is to try to handle the exception. There will be cases\nwhere the native code can catch the exception, take the appropriate action,\nand then continue. This is only recommended in specific cases\nwhere it is known that the exception can be safely handled. In these\ncases <a href=\"n-api.html#n_api_napi_get_and_clear_last_exception\"><code>napi_get_and_clear_last_exception</code></a> can be used to get and\nclear the exception. On success, result will contain the handle to\nthe last JavaScript <code>Object</code> thrown. If it is determined, after\nretrieving the exception, the exception cannot be handled after all\nit can be re-thrown it with <a href=\"n-api.html#n_api_napi_throw\"><code>napi_throw</code></a> where error is the\nJavaScript <code>Error</code> object to be thrown.</p>\n<p>The following utility functions are also available in case native code\nneeds to throw an exception or determine if a <code>napi_value</code> is an instance\nof a JavaScript <code>Error</code> object: <a href=\"n-api.html#n_api_napi_throw_error\"><code>napi_throw_error</code></a>,\n<a href=\"n-api.html#n_api_napi_throw_type_error\"><code>napi_throw_type_error</code></a>, <a href=\"n-api.html#n_api_napi_throw_range_error\"><code>napi_throw_range_error</code></a> and\n<a href=\"n-api.html#n_api_napi_is_error\"><code>napi_is_error</code></a>.</p>\n<p>The following utility functions are also available in case native\ncode needs to create an <code>Error</code> object: <a href=\"n-api.html#n_api_napi_create_error\"><code>napi_create_error</code></a>,\n<a href=\"n-api.html#n_api_napi_create_type_error\"><code>napi_create_type_error</code></a>, and <a href=\"n-api.html#n_api_napi_create_range_error\"><code>napi_create_range_error</code></a>,\nwhere result is the <code>napi_value</code> that refers to the newly created\nJavaScript <code>Error</code> object.</p>\n<p>The Node.js project is adding error codes to all of the errors\ngenerated internally. The goal is for applications to use these\nerror codes for all error checking. The associated error messages\nwill remain, but will only be meant to be used for logging and\ndisplay with the expectation that the message can change without\nSemVer applying. In order to support this model with N-API, both\nin internal functionality and for module specific functionality\n(as its good practice), the <code>throw_</code> and <code>create_</code> functions\ntake an optional code parameter which is the string for the code\nto be added to the error object. If the optional parameter is <code>NULL</code>\nthen no code will be associated with the error. If a code is provided,\nthe name associated with the error is also updated to be:</p>\n<pre><code class=\"language-text\">originalName [code]\n</code></pre>\n<p>where <code>originalName</code> is the original name associated with the error\nand <code>code</code> is the code that was provided. For example, if the code\nis <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the name will be:</p>\n<pre><code class=\"language-text\">TypeError [ERR_ERROR_1]\n</code></pre>",
+              "desc": "<p>Any Node-API function call may result in a pending JavaScript exception. This is\nthe case for any of the API functions, even those that may not cause the\nexecution of JavaScript.</p>\n<p>If the <code>napi_status</code> returned by a function is <code>napi_ok</code> then no\nexception is pending and no additional action is required. If the\n<code>napi_status</code> returned is anything other than <code>napi_ok</code> or\n<code>napi_pending_exception</code>, in order to try to recover and continue\ninstead of simply returning immediately, <a href=\"n-api.html#n_api_napi_is_exception_pending\"><code>napi_is_exception_pending</code></a>\nmust be called in order to determine if an exception is pending or not.</p>\n<p>In many cases when a Node-API function is called and an exception is\nalready pending, the function will return immediately with a\n<code>napi_status</code> of <code>napi_pending_exception</code>. However, this is not the case\nfor all functions. Node-API allows a subset of the functions to be\ncalled to allow for some minimal cleanup before returning to JavaScript.\nIn that case, <code>napi_status</code> will reflect the status for the function. It\nwill not reflect previous pending exceptions. To avoid confusion, check\nthe error status after every function call.</p>\n<p>When an exception is pending one of two approaches can be employed.</p>\n<p>The first approach is to do any appropriate cleanup and then return so that\nexecution will return to JavaScript. As part of the transition back to\nJavaScript, the exception will be thrown at the point in the JavaScript\ncode where the native method was invoked. The behavior of most Node-API calls\nis unspecified while an exception is pending, and many will simply return\n<code>napi_pending_exception</code>, so do as little as possible and then return to\nJavaScript where the exception can be handled.</p>\n<p>The second approach is to try to handle the exception. There will be cases\nwhere the native code can catch the exception, take the appropriate action,\nand then continue. This is only recommended in specific cases\nwhere it is known that the exception can be safely handled. In these\ncases <a href=\"n-api.html#n_api_napi_get_and_clear_last_exception\"><code>napi_get_and_clear_last_exception</code></a> can be used to get and\nclear the exception. On success, result will contain the handle to\nthe last JavaScript <code>Object</code> thrown. If it is determined, after\nretrieving the exception, the exception cannot be handled after all\nit can be re-thrown it with <a href=\"n-api.html#n_api_napi_throw\"><code>napi_throw</code></a> where error is the\nJavaScript value to be thrown.</p>\n<p>The following utility functions are also available in case native code\nneeds to throw an exception or determine if a <code>napi_value</code> is an instance\nof a JavaScript <code>Error</code> object: <a href=\"n-api.html#n_api_napi_throw_error\"><code>napi_throw_error</code></a>,\n<a href=\"n-api.html#n_api_napi_throw_type_error\"><code>napi_throw_type_error</code></a>, <a href=\"n-api.html#n_api_napi_throw_range_error\"><code>napi_throw_range_error</code></a> and\n<a href=\"n-api.html#n_api_napi_is_error\"><code>napi_is_error</code></a>.</p>\n<p>The following utility functions are also available in case native\ncode needs to create an <code>Error</code> object: <a href=\"n-api.html#n_api_napi_create_error\"><code>napi_create_error</code></a>,\n<a href=\"n-api.html#n_api_napi_create_type_error\"><code>napi_create_type_error</code></a>, and <a href=\"n-api.html#n_api_napi_create_range_error\"><code>napi_create_range_error</code></a>,\nwhere result is the <code>napi_value</code> that refers to the newly created\nJavaScript <code>Error</code> object.</p>\n<p>The Node.js project is adding error codes to all of the errors\ngenerated internally. The goal is for applications to use these\nerror codes for all error checking. The associated error messages\nwill remain, but will only be meant to be used for logging and\ndisplay with the expectation that the message can change without\nSemVer applying. In order to support this model with Node-API, both\nin internal functionality and for module specific functionality\n(as its good practice), the <code>throw_</code> and <code>create_</code> functions\ntake an optional code parameter which is the string for the code\nto be added to the error object. If the optional parameter is <code>NULL</code>\nthen no code will be associated with the error. If a code is provided,\nthe name associated with the error is also updated to be:</p>\n<pre><code class=\"language-text\">originalName [code]\n</code></pre>\n<p>where <code>originalName</code> is the original name associated with the error\nand <code>code</code> is the code that was provided. For example, if the code\nis <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the name will be:</p>\n<pre><code class=\"language-text\">TypeError [ERR_ERROR_1]\n</code></pre>",
               "modules": [
                 {
                   "textRaw": "napi_throw",
@@ -745,7 +757,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_error(napi_env env,\n                                          napi_value code,\n                                          napi_value msg,\n                                          napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>Error</code> with the text provided.</p>",
+                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_error(napi_env env,\n                                          napi_value code,\n                                          napi_value msg,\n                                          napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>Error</code> with the text provided.</p>",
                   "type": "module",
                   "displayName": "napi_create_error"
                 },
@@ -761,7 +773,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_type_error(napi_env env,\n                                               napi_value code,\n                                               napi_value msg,\n                                               napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>TypeError</code> with the text provided.</p>",
+                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_type_error(napi_env env,\n                                               napi_value code,\n                                               napi_value msg,\n                                               napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>TypeError</code> with the text provided.</p>",
                   "type": "module",
                   "displayName": "napi_create_type_error"
                 },
@@ -777,7 +789,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_range_error(napi_env env,\n                                                napi_value code,\n                                                napi_value msg,\n                                                napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>RangeError</code> with the text provided.</p>",
+                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_range_error(napi_env env,\n                                                napi_value code,\n                                                napi_value msg,\n                                                napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>RangeError</code> with the text provided.</p>",
                   "type": "module",
                   "displayName": "napi_create_range_error"
                 },
@@ -850,7 +862,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">NAPI_NO_RETURN void napi_fatal_error(const char* location,\n                                                 size_t location_len,\n                                                 const char* message,\n                                                 size_t message_len);\n</code></pre>\n<ul>\n<li><code>[in] location</code>: Optional location at which the error occurred.</li>\n<li><code>[in] location_len</code>: The length of the location in bytes, or\n<code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>\n<li><code>[in] message</code>: The message associated with the error.</li>\n<li><code>[in] message_len</code>: The length of the message in bytes, or <code>NAPI_AUTO_LENGTH</code>\nif it is null-terminated.</li>\n</ul>\n<p>The function call does not return, the process will be terminated.</p>\n<p>This API can be called even if there is a pending JavaScript exception.</p>",
+                  "desc": "<pre><code class=\"language-c\">NAPI_NO_RETURN void napi_fatal_error(const char* location,\n                                     size_t location_len,\n                                     const char* message,\n                                     size_t message_len);\n</code></pre>\n<ul>\n<li><code>[in] location</code>: Optional location at which the error occurred.</li>\n<li><code>[in] location_len</code>: The length of the location in bytes, or\n<code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>\n<li><code>[in] message</code>: The message associated with the error.</li>\n<li><code>[in] message_len</code>: The length of the message in bytes, or <code>NAPI_AUTO_LENGTH</code>\nif it is null-terminated.</li>\n</ul>\n<p>The function call does not return, the process will be terminated.</p>\n<p>This API can be called even if there is a pending JavaScript exception.</p>",
                   "type": "module",
                   "displayName": "napi_fatal_error"
                 }
@@ -865,12 +877,12 @@
         {
           "textRaw": "Object lifetime management",
           "name": "object_lifetime_management",
-          "desc": "<p>As N-API calls are made, handles to objects in the heap for the underlying\nVM may be returned as <code>napi_values</code>. These handles must hold the\nobjects 'live' until they are no longer required by the native code,\notherwise the objects could be collected before the native code was\nfinished using them.</p>\n<p>As object handles are returned they are associated with a\n'scope'. The lifespan for the default scope is tied to the lifespan\nof the native method call. The result is that, by default, handles\nremain valid and the objects associated with these handles will be\nheld live for the lifespan of the native method call.</p>\n<p>In many cases, however, it is necessary that the handles remain valid for\neither a shorter or longer lifespan than that of the native method.\nThe sections which follow describe the N-API functions that can be used\nto change the handle lifespan from the default.</p>",
+          "desc": "<p>As Node-API calls are made, handles to objects in the heap for the underlying\nVM may be returned as <code>napi_values</code>. These handles must hold the\nobjects 'live' until they are no longer required by the native code,\notherwise the objects could be collected before the native code was\nfinished using them.</p>\n<p>As object handles are returned they are associated with a\n'scope'. The lifespan for the default scope is tied to the lifespan\nof the native method call. The result is that, by default, handles\nremain valid and the objects associated with these handles will be\nheld live for the lifespan of the native method call.</p>\n<p>In many cases, however, it is necessary that the handles remain valid for\neither a shorter or longer lifespan than that of the native method.\nThe sections which follow describe the Node-API functions that can be used\nto change the handle lifespan from the default.</p>",
           "modules": [
             {
               "textRaw": "Making handle lifespan shorter than that of the native method",
               "name": "making_handle_lifespan_shorter_than_that_of_the_native_method",
-              "desc": "<p>It is often necessary to make the lifespan of handles shorter than\nthe lifespan of a native method. For example, consider a native method\nthat has a loop which iterates through the elements in a large array:</p>\n<pre><code class=\"language-c\">for (int i = 0; i &#x3C; 1000000; i++) {\n  napi_value result;\n  napi_status status = napi_get_element(env, object, i, &#x26;result);\n  if (status != napi_ok) {\n    break;\n  }\n  // do something with element\n}\n</code></pre>\n<p>This would result in a large number of handles being created, consuming\nsubstantial resources. In addition, even though the native code could only\nuse the most recent handle, all of the associated objects would also be\nkept alive since they all share the same scope.</p>\n<p>To handle this case, N-API provides the ability to establish a new 'scope' to\nwhich newly created handles will be associated. Once those handles\nare no longer required, the scope can be 'closed' and any handles associated\nwith the scope are invalidated. The methods available to open/close scopes are\n<a href=\"n-api.html#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and <a href=\"n-api.html#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a>.</p>\n<p>N-API only supports a single nested hierarchy of scopes. There is only one\nactive scope at any time, and all new handles will be associated with that\nscope while it is active. Scopes must be closed in the reverse order from\nwhich they are opened. In addition, all scopes created within a native method\nmust be closed before returning from that method.</p>\n<p>Taking the earlier example, adding calls to <a href=\"n-api.html#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and\n<a href=\"n-api.html#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a> would ensure that at most a single handle\nis valid throughout the execution of the loop:</p>\n<pre><code class=\"language-c\">for (int i = 0; i &#x3C; 1000000; i++) {\n  napi_handle_scope scope;\n  napi_status status = napi_open_handle_scope(env, &#x26;scope);\n  if (status != napi_ok) {\n    break;\n  }\n  napi_value result;\n  status = napi_get_element(env, object, i, &#x26;result);\n  if (status != napi_ok) {\n    break;\n  }\n  // do something with element\n  status = napi_close_handle_scope(env, scope);\n  if (status != napi_ok) {\n    break;\n  }\n}\n</code></pre>\n<p>When nesting scopes, there are cases where a handle from an\ninner scope needs to live beyond the lifespan of that scope. N-API supports an\n'escapable scope' in order to support this case. An escapable scope\nallows one handle to be 'promoted' so that it 'escapes' the\ncurrent scope and the lifespan of the handle changes from the current\nscope to that of the outer scope.</p>\n<p>The methods available to open/close escapable scopes are\n<a href=\"n-api.html#n_api_napi_open_escapable_handle_scope\"><code>napi_open_escapable_handle_scope</code></a> and\n<a href=\"n-api.html#n_api_napi_close_escapable_handle_scope\"><code>napi_close_escapable_handle_scope</code></a>.</p>\n<p>The request to promote a handle is made through <a href=\"n-api.html#n_api_napi_escape_handle\"><code>napi_escape_handle</code></a> which\ncan only be called once.</p>",
+              "desc": "<p>It is often necessary to make the lifespan of handles shorter than\nthe lifespan of a native method. For example, consider a native method\nthat has a loop which iterates through the elements in a large array:</p>\n<pre><code class=\"language-c\">for (int i = 0; i &#x3C; 1000000; i++) {\n  napi_value result;\n  napi_status status = napi_get_element(env, object, i, &#x26;result);\n  if (status != napi_ok) {\n    break;\n  }\n  // do something with element\n}\n</code></pre>\n<p>This would result in a large number of handles being created, consuming\nsubstantial resources. In addition, even though the native code could only\nuse the most recent handle, all of the associated objects would also be\nkept alive since they all share the same scope.</p>\n<p>To handle this case, Node-API provides the ability to establish a new 'scope' to\nwhich newly created handles will be associated. Once those handles\nare no longer required, the scope can be 'closed' and any handles associated\nwith the scope are invalidated. The methods available to open/close scopes are\n<a href=\"n-api.html#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and <a href=\"n-api.html#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a>.</p>\n<p>Node-API only supports a single nested hierarchy of scopes. There is only one\nactive scope at any time, and all new handles will be associated with that\nscope while it is active. Scopes must be closed in the reverse order from\nwhich they are opened. In addition, all scopes created within a native method\nmust be closed before returning from that method.</p>\n<p>Taking the earlier example, adding calls to <a href=\"n-api.html#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and\n<a href=\"n-api.html#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a> would ensure that at most a single handle\nis valid throughout the execution of the loop:</p>\n<pre><code class=\"language-c\">for (int i = 0; i &#x3C; 1000000; i++) {\n  napi_handle_scope scope;\n  napi_status status = napi_open_handle_scope(env, &#x26;scope);\n  if (status != napi_ok) {\n    break;\n  }\n  napi_value result;\n  status = napi_get_element(env, object, i, &#x26;result);\n  if (status != napi_ok) {\n    break;\n  }\n  // do something with element\n  status = napi_close_handle_scope(env, scope);\n  if (status != napi_ok) {\n    break;\n  }\n}\n</code></pre>\n<p>When nesting scopes, there are cases where a handle from an\ninner scope needs to live beyond the lifespan of that scope. Node-API supports\nan 'escapable scope' in order to support this case. An escapable scope\nallows one handle to be 'promoted' so that it 'escapes' the\ncurrent scope and the lifespan of the handle changes from the current\nscope to that of the outer scope.</p>\n<p>The methods available to open/close escapable scopes are\n<a href=\"n-api.html#n_api_napi_open_escapable_handle_scope\"><code>napi_open_escapable_handle_scope</code></a> and\n<a href=\"n-api.html#n_api_napi_close_escapable_handle_scope\"><code>napi_close_escapable_handle_scope</code></a>.</p>\n<p>The request to promote a handle is made through <a href=\"n-api.html#n_api_napi_escape_handle\"><code>napi_escape_handle</code></a> which\ncan only be called once.</p>",
               "modules": [
                 {
                   "textRaw": "napi_open_handle_scope",
@@ -959,7 +971,7 @@
             {
               "textRaw": "References to objects with a lifespan longer than that of the native method",
               "name": "references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method",
-              "desc": "<p>In some cases an addon will need to be able to create and reference objects\nwith a lifespan longer than that of a single native method invocation. For\nexample, to create a constructor and later use that constructor\nin a request to creates instances, it must be possible to reference\nthe constructor object across many different instance creation requests. This\nwould not be possible with a normal handle returned as a <code>napi_value</code> as\ndescribed in the earlier section. The lifespan of a normal handle is\nmanaged by scopes and all scopes must be closed before the end of a native\nmethod.</p>\n<p>N-API provides methods to create persistent references to an object.\nEach persistent reference has an associated count with a value of 0\nor higher. The count determines if the reference will keep\nthe corresponding object live. References with a count of 0 do not\nprevent the object from being collected and are often called 'weak'\nreferences. Any count greater than 0 will prevent the object\nfrom being collected.</p>\n<p>References can be created with an initial reference count. The count can\nthen be modified through <a href=\"n-api.html#n_api_napi_reference_ref\"><code>napi_reference_ref</code></a> and\n<a href=\"n-api.html#n_api_napi_reference_unref\"><code>napi_reference_unref</code></a>. If an object is collected while the count\nfor a reference is 0, all subsequent calls to\nget the object associated with the reference <a href=\"n-api.html#n_api_napi_get_reference_value\"><code>napi_get_reference_value</code></a>\nwill return <code>NULL</code> for the returned <code>napi_value</code>. An attempt to call\n<a href=\"n-api.html#n_api_napi_reference_ref\"><code>napi_reference_ref</code></a> for a reference whose object has been collected\nwill result in an error.</p>\n<p>References must be deleted once they are no longer required by the addon. When\na reference is deleted it will no longer prevent the corresponding object from\nbeing collected. Failure to delete a persistent reference will result in\na 'memory leak' with both the native memory for the persistent reference and\nthe corresponding object on the heap being retained forever.</p>\n<p>There can be multiple persistent references created which refer to the same\nobject, each of which will either keep the object live or not based on its\nindividual count.</p>",
+              "desc": "<p>In some cases an addon will need to be able to create and reference objects\nwith a lifespan longer than that of a single native method invocation. For\nexample, to create a constructor and later use that constructor\nin a request to creates instances, it must be possible to reference\nthe constructor object across many different instance creation requests. This\nwould not be possible with a normal handle returned as a <code>napi_value</code> as\ndescribed in the earlier section. The lifespan of a normal handle is\nmanaged by scopes and all scopes must be closed before the end of a native\nmethod.</p>\n<p>Node-API provides methods to create persistent references to an object.\nEach persistent reference has an associated count with a value of 0\nor higher. The count determines if the reference will keep\nthe corresponding object live. References with a count of 0 do not\nprevent the object from being collected and are often called 'weak'\nreferences. Any count greater than 0 will prevent the object\nfrom being collected.</p>\n<p>References can be created with an initial reference count. The count can\nthen be modified through <a href=\"n-api.html#n_api_napi_reference_ref\"><code>napi_reference_ref</code></a> and\n<a href=\"n-api.html#n_api_napi_reference_unref\"><code>napi_reference_unref</code></a>. If an object is collected while the count\nfor a reference is 0, all subsequent calls to\nget the object associated with the reference <a href=\"n-api.html#n_api_napi_get_reference_value\"><code>napi_get_reference_value</code></a>\nwill return <code>NULL</code> for the returned <code>napi_value</code>. An attempt to call\n<a href=\"n-api.html#n_api_napi_reference_ref\"><code>napi_reference_ref</code></a> for a reference whose object has been collected\nresults in an error.</p>\n<p>References must be deleted once they are no longer required by the addon. When\na reference is deleted, it will no longer prevent the corresponding object from\nbeing collected. Failure to delete a persistent reference results in\na 'memory leak' with both the native memory for the persistent reference and\nthe corresponding object on the heap being retained forever.</p>\n<p>There can be multiple persistent references created which refer to the same\nobject, each of which will either keep the object live or not based on its\nindividual count.</p>",
               "modules": [
                 {
                   "textRaw": "napi_create_reference",
@@ -1048,7 +1060,7 @@
             {
               "textRaw": "Cleanup on exit of the current Node.js instance",
               "name": "cleanup_on_exit_of_the_current_node.js_instance",
-              "desc": "<p>While a Node.js process typically releases all its resources when exiting,\nembedders of Node.js, or future Worker support, may require addons to register\nclean-up hooks that will be run once the current Node.js instance exits.</p>\n<p>N-API provides functions for registering and un-registering such callbacks.\nWhen those callbacks are run, all resources that are being held by the addon\nshould be freed up.</p>",
+              "desc": "<p>While a Node.js process typically releases all its resources when exiting,\nembedders of Node.js, or future Worker support, may require addons to register\nclean-up hooks that will be run once the current Node.js instance exits.</p>\n<p>Node-API provides functions for registering and un-registering such callbacks.\nWhen those callbacks are run, all resources that are being held by the addon\nshould be freed up.</p>",
               "modules": [
                 {
                   "textRaw": "napi_add_env_cleanup_hook",
@@ -1087,17 +1099,18 @@
                   "name": "napi_add_async_cleanup_hook",
                   "meta": {
                     "added": [
+                      "v14.8.0",
                       "v12.19.0"
                     ],
+                    "napiVersion": [
+                      8
+                    ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.10.0",
                         "pr-url": "https://github.com/nodejs/node/pull/34819",
                         "description": "Changed signature of the `hook` callback."
                       }
-                    ],
-                    "napiVersion": [
-                      8
                     ]
                   },
                   "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_add_async_cleanup_hook(\n    napi_env env,\n    napi_async_cleanup_hook hook,\n    void* arg,\n    napi_async_cleanup_hook_handle* remove_handle);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] hook</code>: The function pointer to call at environment teardown.</li>\n<li><code>[in] arg</code>: The pointer to pass to <code>hook</code> when it gets called.</li>\n<li><code>[out] remove_handle</code>: Optional handle that refers to the asynchronous cleanup\nhook.</li>\n</ul>\n<p>Registers <code>hook</code>, which is a function of type <a href=\"n-api.html#n_api_napi_async_cleanup_hook\"><code>napi_async_cleanup_hook</code></a>, as\na function to be run with the <code>remove_handle</code> and <code>arg</code> parameters once the\ncurrent Node.js environment exits.</p>\n<p>Unlike <a href=\"n-api.html#n_api_napi_add_env_cleanup_hook\"><code>napi_add_env_cleanup_hook</code></a>, the hook is allowed to be asynchronous.</p>\n<p>Otherwise, behavior generally matches that of <a href=\"n-api.html#n_api_napi_add_env_cleanup_hook\"><code>napi_add_env_cleanup_hook</code></a>.</p>\n<p>If <code>remove_handle</code> is not <code>NULL</code>, an opaque value will be stored in it\nthat must later be passed to <a href=\"n-api.html#n_api_napi_remove_async_cleanup_hook\"><code>napi_remove_async_cleanup_hook</code></a>,\nregardless of whether the hook has already been invoked.\nTypically, that happens when the resource for which this hook was added\nis being torn down anyway.</p>",
@@ -1109,11 +1122,11 @@
                   "name": "napi_remove_async_cleanup_hook",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.8.0"
                     ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.10.0",
                         "pr-url": "https://github.com/nodejs/node/pull/34819",
                         "description": "Removed `env` parameter."
                       }
@@ -1134,14 +1147,14 @@
         {
           "textRaw": "Module registration",
           "name": "module_registration",
-          "desc": "<p>N-API modules are registered in a manner similar to other modules\nexcept that instead of using the <code>NODE_MODULE</code> macro the following\nis used:</p>\n<pre><code class=\"language-c\">NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)\n</code></pre>\n<p>The next difference is the signature for the <code>Init</code> method. For a N-API\nmodule it is as follows:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports);\n</code></pre>\n<p>The return value from <code>Init</code> is treated as the <code>exports</code> object for the module.\nThe <code>Init</code> method is passed an empty object via the <code>exports</code> parameter as a\nconvenience. If <code>Init</code> returns <code>NULL</code>, the parameter passed as <code>exports</code> is\nexported by the module. N-API modules cannot modify the <code>module</code> object but can\nspecify anything as the <code>exports</code> property of the module.</p>\n<p>To add the method <code>hello</code> as a function so that it can be called as a method\nprovided by the addon:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_property_descriptor desc = {\n    \"hello\",\n    NULL,\n    Method,\n    NULL,\n    NULL,\n    NULL,\n    napi_writable | napi_enumerable | napi_configurable,\n    NULL\n  };\n  status = napi_define_properties(env, exports, 1, &#x26;desc);\n  if (status != napi_ok) return NULL;\n  return exports;\n}\n</code></pre>\n<p>To set a function to be returned by the <code>require()</code> for the addon:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports) {\n  napi_value method;\n  napi_status status;\n  status = napi_create_function(env, \"exports\", NAPI_AUTO_LENGTH, Method, NULL, &#x26;method);\n  if (status != napi_ok) return NULL;\n  return method;\n}\n</code></pre>\n<p>To define a class so that new instances can be created (often used with\n<a href=\"n-api.html#n_api_object_wrap\">Object wrap</a>):</p>\n<pre><code class=\"language-c\">// NOTE: partial example, not all referenced code is included\nnapi_value Init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_property_descriptor properties[] = {\n    { \"value\", NULL, NULL, GetValue, SetValue, NULL, napi_writable | napi_configurable, NULL },\n    DECLARE_NAPI_METHOD(\"plusOne\", PlusOne),\n    DECLARE_NAPI_METHOD(\"multiply\", Multiply),\n  };\n\n  napi_value cons;\n  status =\n      napi_define_class(env, \"MyObject\", New, NULL, 3, properties, &#x26;cons);\n  if (status != napi_ok) return NULL;\n\n  status = napi_create_reference(env, cons, 1, &#x26;constructor);\n  if (status != napi_ok) return NULL;\n\n  status = napi_set_named_property(env, exports, \"MyObject\", cons);\n  if (status != napi_ok) return NULL;\n\n  return exports;\n}\n</code></pre>\n<p>If the module will be loaded multiple times during the lifetime of the Node.js\nprocess, use the <code>NAPI_MODULE_INIT</code> macro to initialize the module:</p>\n<pre><code class=\"language-c\">NAPI_MODULE_INIT() {\n  napi_value answer;\n  napi_status result;\n\n  status = napi_create_int64(env, 42, &#x26;answer);\n  if (status != napi_ok) return NULL;\n\n  status = napi_set_named_property(env, exports, \"answer\", answer);\n  if (status != napi_ok) return NULL;\n\n  return exports;\n}\n</code></pre>\n<p>This macro includes <code>NAPI_MODULE</code>, and declares an <code>Init</code> function with a\nspecial name and with visibility beyond the addon. This will allow Node.js to\ninitialize the module even if it is loaded multiple times.</p>\n<p>There are a few design considerations when declaring a module that may be loaded\nmultiple times. The documentation of <a href=\"addons.html#addons_context_aware_addons\">context-aware addons</a> provides more\ndetails.</p>\n<p>The variables <code>env</code> and <code>exports</code> will be available inside the function body\nfollowing the macro invocation.</p>\n<p>For more details on setting properties on objects, see the section on\n<a href=\"n-api.html#n_api_working_with_javascript_properties\">Working with JavaScript properties</a>.</p>\n<p>For more details on building addon modules in general, refer to the existing\nAPI.</p>",
+          "desc": "<p>Node-API modules are registered in a manner similar to other modules\nexcept that instead of using the <code>NODE_MODULE</code> macro the following\nis used:</p>\n<pre><code class=\"language-c\">NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)\n</code></pre>\n<p>The next difference is the signature for the <code>Init</code> method. For a Node-API\nmodule it is as follows:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports);\n</code></pre>\n<p>The return value from <code>Init</code> is treated as the <code>exports</code> object for the module.\nThe <code>Init</code> method is passed an empty object via the <code>exports</code> parameter as a\nconvenience. If <code>Init</code> returns <code>NULL</code>, the parameter passed as <code>exports</code> is\nexported by the module. Node-API modules cannot modify the <code>module</code> object but\ncan specify anything as the <code>exports</code> property of the module.</p>\n<p>To add the method <code>hello</code> as a function so that it can be called as a method\nprovided by the addon:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_property_descriptor desc = {\n    \"hello\",\n    NULL,\n    Method,\n    NULL,\n    NULL,\n    NULL,\n    napi_writable | napi_enumerable | napi_configurable,\n    NULL\n  };\n  status = napi_define_properties(env, exports, 1, &#x26;desc);\n  if (status != napi_ok) return NULL;\n  return exports;\n}\n</code></pre>\n<p>To set a function to be returned by the <code>require()</code> for the addon:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports) {\n  napi_value method;\n  napi_status status;\n  status = napi_create_function(env, \"exports\", NAPI_AUTO_LENGTH, Method, NULL, &#x26;method);\n  if (status != napi_ok) return NULL;\n  return method;\n}\n</code></pre>\n<p>To define a class so that new instances can be created (often used with\n<a href=\"n-api.html#n_api_object_wrap\">Object wrap</a>):</p>\n<pre><code class=\"language-c\">// NOTE: partial example, not all referenced code is included\nnapi_value Init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_property_descriptor properties[] = {\n    { \"value\", NULL, NULL, GetValue, SetValue, NULL, napi_writable | napi_configurable, NULL },\n    DECLARE_NAPI_METHOD(\"plusOne\", PlusOne),\n    DECLARE_NAPI_METHOD(\"multiply\", Multiply),\n  };\n\n  napi_value cons;\n  status =\n      napi_define_class(env, \"MyObject\", New, NULL, 3, properties, &#x26;cons);\n  if (status != napi_ok) return NULL;\n\n  status = napi_create_reference(env, cons, 1, &#x26;constructor);\n  if (status != napi_ok) return NULL;\n\n  status = napi_set_named_property(env, exports, \"MyObject\", cons);\n  if (status != napi_ok) return NULL;\n\n  return exports;\n}\n</code></pre>\n<p>You can also use the <code>NAPI_MODULE_INIT</code> macro, which acts as a shorthand\nfor <code>NAPI_MODULE</code> and defining an <code>Init</code> function:</p>\n<pre><code class=\"language-c\">NAPI_MODULE_INIT() {\n  napi_value answer;\n  napi_status result;\n\n  status = napi_create_int64(env, 42, &#x26;answer);\n  if (status != napi_ok) return NULL;\n\n  status = napi_set_named_property(env, exports, \"answer\", answer);\n  if (status != napi_ok) return NULL;\n\n  return exports;\n}\n</code></pre>\n<p>All Node-API addons are context-aware, meaning they may be loaded multiple\ntimes. There are a few design considerations when declaring such a module.\nThe documentation on <a href=\"addons.html#addons_context_aware_addons\">context-aware addons</a> provides more details.</p>\n<p>The variables <code>env</code> and <code>exports</code> will be available inside the function body\nfollowing the macro invocation.</p>\n<p>For more details on setting properties on objects, see the section on\n<a href=\"n-api.html#n_api_working_with_javascript_properties\">Working with JavaScript properties</a>.</p>\n<p>For more details on building addon modules in general, refer to the existing\nAPI.</p>",
           "type": "misc",
           "displayName": "Module registration"
         },
         {
           "textRaw": "Working with JavaScript values",
           "name": "working_with_javascript_values",
-          "desc": "<p>N-API exposes a set of APIs to create all types of JavaScript values.\nSome of these types are documented under <a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\">Section 6</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>Fundamentally, these APIs are used to do one of the following:</p>\n<ol>\n<li>Create a new JavaScript object</li>\n<li>Convert from a primitive C type to an N-API value</li>\n<li>Convert from N-API value to a primitive C type</li>\n<li>Get global instances including <code>undefined</code> and <code>null</code></li>\n</ol>\n<p>N-API values are represented by the type <code>napi_value</code>.\nAny N-API call that requires a JavaScript value takes in a <code>napi_value</code>.\nIn some cases, the API does check the type of the <code>napi_value</code> up-front.\nHowever, for better performance, it's better for the caller to make sure that\nthe <code>napi_value</code> in question is of the JavaScript type expected by the API.</p>",
+          "desc": "<p>Node-API exposes a set of APIs to create all types of JavaScript values.\nSome of these types are documented under <a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\">Section 6</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>Fundamentally, these APIs are used to do one of the following:</p>\n<ol>\n<li>Create a new JavaScript object</li>\n<li>Convert from a primitive C type to a Node-API value</li>\n<li>Convert from Node-API value to a primitive C type</li>\n<li>Get global instances including <code>undefined</code> and <code>null</code></li>\n</ol>\n<p>Node-API values are represented by the type <code>napi_value</code>.\nAny Node-API call that requires a JavaScript value takes in a <code>napi_value</code>.\nIn some cases, the API does check the type of the <code>napi_value</code> up-front.\nHowever, for better performance, it's better for the caller to make sure that\nthe <code>napi_value</code> in question is of the JavaScript type expected by the API.</p>",
           "modules": [
             {
               "textRaw": "Enum types",
@@ -1152,7 +1165,8 @@
                   "name": "napi_key_collection_mode",
                   "meta": {
                     "added": [
-                      "v12.17.0"
+                      "v13.7.0",
+                      "v10.20.0"
                     ],
                     "napiVersion": [
                       6
@@ -1168,7 +1182,8 @@
                   "name": "napi_key_filter",
                   "meta": {
                     "added": [
-                      "v12.17.0"
+                      "v13.7.0",
+                      "v10.20.0"
                     ],
                     "napiVersion": [
                       6
@@ -1184,7 +1199,8 @@
                   "name": "napi_key_conversion",
                   "meta": {
                     "added": [
-                      "v12.17.0"
+                      "v13.7.0",
+                      "v10.20.0"
                     ],
                     "napiVersion": [
                       6
@@ -1229,7 +1245,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_array(napi_env env, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an N-API value corresponding to a JavaScript <code>Array</code> type.\nJavaScript arrays are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-array-objects\">Section 22.1</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_array(napi_env env, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a Node-API value corresponding to a JavaScript <code>Array</code> type.\nJavaScript arrays are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-array-objects\">Section 22.1</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_array"
                 },
@@ -1245,7 +1261,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_array_with_length(napi_env env,\n                                          size_t length,\n                                          napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] length</code>: The initial length of the <code>Array</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an N-API value corresponding to a JavaScript <code>Array</code> type.\nThe <code>Array</code>'s length property is set to the passed-in length parameter.\nHowever, the underlying buffer is not guaranteed to be pre-allocated by the VM\nwhen the array is created. That behavior is left to the underlying VM\nimplementation. If the buffer must be a contiguous block of memory that can be\ndirectly read and/or written via C, consider using\n<a href=\"n-api.html#n_api_napi_create_external_arraybuffer\"><code>napi_create_external_arraybuffer</code></a>.</p>\n<p>JavaScript arrays are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-array-objects\">Section 22.1</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_array_with_length(napi_env env,\n                                          size_t length,\n                                          napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] length</code>: The initial length of the <code>Array</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a Node-API value corresponding to a JavaScript <code>Array</code> type.\nThe <code>Array</code>'s length property is set to the passed-in length parameter.\nHowever, the underlying buffer is not guaranteed to be pre-allocated by the VM\nwhen the array is created. That behavior is left to the underlying VM\nimplementation. If the buffer must be a contiguous block of memory that can be\ndirectly read and/or written via C, consider using\n<a href=\"n-api.html#n_api_napi_create_external_arraybuffer\"><code>napi_create_external_arraybuffer</code></a>.</p>\n<p>JavaScript arrays are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-array-objects\">Section 22.1</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_array_with_length"
                 },
@@ -1261,7 +1277,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_arraybuffer(napi_env env,\n                                    size_t byte_length,\n                                    void** data,\n                                    napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] length</code>: The length in bytes of the array buffer to create.</li>\n<li><code>[out] data</code>: Pointer to the underlying byte buffer of the <code>ArrayBuffer</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an N-API value corresponding to a JavaScript <code>ArrayBuffer</code>.\n<code>ArrayBuffer</code>s are used to represent fixed-length binary data buffers. They are\nnormally used as a backing-buffer for <code>TypedArray</code> objects.\nThe <code>ArrayBuffer</code> allocated will have an underlying byte buffer whose size is\ndetermined by the <code>length</code> parameter that's passed in.\nThe underlying buffer is optionally returned back to the caller in case the\ncaller wants to directly manipulate the buffer. This buffer can only be\nwritten to directly from native code. To write to this buffer from JavaScript,\na typed array or <code>DataView</code> object would need to be created.</p>\n<p>JavaScript <code>ArrayBuffer</code> objects are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-arraybuffer-objects\">Section 24.1</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_arraybuffer(napi_env env,\n                                    size_t byte_length,\n                                    void** data,\n                                    napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] length</code>: The length in bytes of the array buffer to create.</li>\n<li><code>[out] data</code>: Pointer to the underlying byte buffer of the <code>ArrayBuffer</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a Node-API value corresponding to a JavaScript <code>ArrayBuffer</code>.\n<code>ArrayBuffer</code>s are used to represent fixed-length binary data buffers. They are\nnormally used as a backing-buffer for <code>TypedArray</code> objects.\nThe <code>ArrayBuffer</code> allocated will have an underlying byte buffer whose size is\ndetermined by the <code>length</code> parameter that's passed in.\nThe underlying buffer is optionally returned back to the caller in case the\ncaller wants to directly manipulate the buffer. This buffer can only be\nwritten to directly from native code. To write to this buffer from JavaScript,\na typed array or <code>DataView</code> object would need to be created.</p>\n<p>JavaScript <code>ArrayBuffer</code> objects are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-arraybuffer-objects\">Section 24.1</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_arraybuffer"
                 },
@@ -1302,7 +1318,8 @@
                   "name": "napi_create_date",
                   "meta": {
                     "added": [
-                      "v11.11.0"
+                      "v11.11.0",
+                      "v10.17.0"
                     ],
                     "napiVersion": [
                       5
@@ -1341,7 +1358,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status\nnapi_create_external_arraybuffer(napi_env env,\n                                 void* external_data,\n                                 size_t byte_length,\n                                 napi_finalize finalize_cb,\n                                 void* finalize_hint,\n                                 napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] external_data</code>: Pointer to the underlying byte buffer of the\n<code>ArrayBuffer</code>.</li>\n<li><code>[in] byte_length</code>: The length in bytes of the underlying buffer.</li>\n<li><code>[in] finalize_cb</code>: Optional callback to call when the <code>ArrayBuffer</code> is being\ncollected. <a href=\"n-api.html#n_api_napi_finalize\"><code>napi_finalize</code></a> provides more details.</li>\n<li><code>[in] finalize_hint</code>: Optional hint to pass to the finalize callback during\ncollection.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an N-API value corresponding to a JavaScript <code>ArrayBuffer</code>.\nThe underlying byte buffer of the <code>ArrayBuffer</code> is externally allocated and\nmanaged. The caller must ensure that the byte buffer remains valid until the\nfinalize callback is called.</p>\n<p>The API adds a <code>napi_finalize</code> callback which will be called when the JavaScript\nobject just created is ready for garbage collection. It is similar to\n<code>napi_wrap()</code> except that:</p>\n<ul>\n<li>the native data cannot be retrieved later using <code>napi_unwrap()</code>,</li>\n<li>nor can it be removed later using <code>napi_remove_wrap()</code>, and</li>\n<li>the object created by the API can be used with <code>napi_wrap()</code>.</li>\n</ul>\n<p>JavaScript <code>ArrayBuffer</code>s are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-arraybuffer-objects\">Section 24.1</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status\nnapi_create_external_arraybuffer(napi_env env,\n                                 void* external_data,\n                                 size_t byte_length,\n                                 napi_finalize finalize_cb,\n                                 void* finalize_hint,\n                                 napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] external_data</code>: Pointer to the underlying byte buffer of the\n<code>ArrayBuffer</code>.</li>\n<li><code>[in] byte_length</code>: The length in bytes of the underlying buffer.</li>\n<li><code>[in] finalize_cb</code>: Optional callback to call when the <code>ArrayBuffer</code> is being\ncollected. <a href=\"n-api.html#n_api_napi_finalize\"><code>napi_finalize</code></a> provides more details.</li>\n<li><code>[in] finalize_hint</code>: Optional hint to pass to the finalize callback during\ncollection.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a Node-API value corresponding to a JavaScript <code>ArrayBuffer</code>.\nThe underlying byte buffer of the <code>ArrayBuffer</code> is externally allocated and\nmanaged. The caller must ensure that the byte buffer remains valid until the\nfinalize callback is called.</p>\n<p>The API adds a <code>napi_finalize</code> callback which will be called when the JavaScript\nobject just created is ready for garbage collection. It is similar to\n<code>napi_wrap()</code> except that:</p>\n<ul>\n<li>the native data cannot be retrieved later using <code>napi_unwrap()</code>,</li>\n<li>nor can it be removed later using <code>napi_remove_wrap()</code>, and</li>\n<li>the object created by the API can be used with <code>napi_wrap()</code>.</li>\n</ul>\n<p>JavaScript <code>ArrayBuffer</code>s are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-arraybuffer-objects\">Section 24.1</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_external_arraybuffer"
                 },
@@ -1389,7 +1406,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_symbol(napi_env env,\n                               napi_value description,\n                               napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] description</code>: Optional <code>napi_value</code> which refers to a JavaScript\n<code>String</code> to be set as the description for the symbol.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Symbol</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>Symbol</code> object from a UTF8-encoded C string.</p>\n<p>The JavaScript <code>Symbol</code> type is described in <a href=\"https://tc39.github.io/ecma262/#sec-symbol-objects\">Section 19.4</a>\nof the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_symbol(napi_env env,\n                               napi_value description,\n                               napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] description</code>: Optional <code>napi_value</code> which refers to a JavaScript\n<code>string</code> to be set as the description for the symbol.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>symbol</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>symbol</code> value from a UTF8-encoded C string.</p>\n<p>The JavaScript <code>symbol</code> type is described in <a href=\"https://tc39.github.io/ecma262/#sec-symbol-objects\">Section 19.4</a>\nof the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_symbol"
                 },
@@ -1430,8 +1447,8 @@
               "displayName": "Object creation functions"
             },
             {
-              "textRaw": "Functions to convert from C types to N-API",
-              "name": "functions_to_convert_from_c_types_to_n-api",
+              "textRaw": "Functions to convert from C types to Node-API",
+              "name": "functions_to_convert_from_c_types_to_node-api",
               "modules": [
                 {
                   "textRaw": "napi_create_int32",
@@ -1445,7 +1462,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>int32_t</code> type to the JavaScript\n<code>Number</code> type.</p>\n<p>The JavaScript <code>Number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>int32_t</code> type to the JavaScript\n<code>number</code> type.</p>\n<p>The JavaScript <code>number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_int32"
                 },
@@ -1461,7 +1478,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Unsigned integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>uint32_t</code> type to the JavaScript\n<code>Number</code> type.</p>\n<p>The JavaScript <code>Number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Unsigned integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>uint32_t</code> type to the JavaScript\n<code>number</code> type.</p>\n<p>The JavaScript <code>number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_uint32"
                 },
@@ -1477,7 +1494,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>int64_t</code> type to the JavaScript\n<code>Number</code> type.</p>\n<p>The JavaScript <code>Number</code> type is described in <a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a>\nof the ECMAScript Language Specification. Note the complete range of <code>int64_t</code>\ncannot be represented with full precision in JavaScript. Integer values\noutside the range of <a href=\"https://tc39.github.io/ecma262/#sec-number.min_safe_integer\"><code>Number.MIN_SAFE_INTEGER</code></a> <code>-(2**53 - 1)</code> -\n<a href=\"https://tc39.github.io/ecma262/#sec-number.max_safe_integer\"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose precision.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>int64_t</code> type to the JavaScript\n<code>number</code> type.</p>\n<p>The JavaScript <code>number</code> type is described in <a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a>\nof the ECMAScript Language Specification. Note the complete range of <code>int64_t</code>\ncannot be represented with full precision in JavaScript. Integer values\noutside the range of <a href=\"https://tc39.github.io/ecma262/#sec-number.min_safe_integer\"><code>Number.MIN_SAFE_INTEGER</code></a> <code>-(2**53 - 1)</code> -\n<a href=\"https://tc39.github.io/ecma262/#sec-number.max_safe_integer\"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose precision.</p>",
                   "type": "module",
                   "displayName": "napi_create_int64"
                 },
@@ -1493,7 +1510,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_double(napi_env env, double value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Double-precision value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>double</code> type to the JavaScript\n<code>Number</code> type.</p>\n<p>The JavaScript <code>Number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_double(napi_env env, double value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Double-precision value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>double</code> type to the JavaScript\n<code>number</code> type.</p>\n<p>The JavaScript <code>number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_double"
                 },
@@ -1557,7 +1574,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_latin1(napi_env env,\n                                      const char* str,\n                                      size_t length,\n                                      napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing an ISO-8859-1-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it\nis null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>String</code> object from an ISO-8859-1-encoded C\nstring. The native string is copied.</p>\n<p>The JavaScript <code>String</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_latin1(napi_env env,\n                                      const char* str,\n                                      size_t length,\n                                      napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing an ISO-8859-1-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it\nis null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>string</code> value from an ISO-8859-1-encoded C\nstring. The native string is copied.</p>\n<p>The JavaScript <code>string</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_string_latin1"
                 },
@@ -1573,7 +1590,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_utf16(napi_env env,\n                                     const char16_t* str,\n                                     size_t length,\n                                     napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing a UTF16-LE-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in two-byte code units, or\n<code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>String</code> object from a UTF16-LE-encoded C string.\nThe native string is copied.</p>\n<p>The JavaScript <code>String</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_utf16(napi_env env,\n                                     const char16_t* str,\n                                     size_t length,\n                                     napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing a UTF16-LE-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in two-byte code units, or\n<code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>string</code> value from a UTF16-LE-encoded C string.\nThe native string is copied.</p>\n<p>The JavaScript <code>string</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_string_utf16"
                 },
@@ -1589,17 +1606,17 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_utf8(napi_env env,\n                                    const char* str,\n                                    size_t length,\n                                    napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing a UTF8-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it\nis null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>String</code> object from a UTF8-encoded C string.\nThe native string is copied.</p>\n<p>The JavaScript <code>String</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_utf8(napi_env env,\n                                    const char* str,\n                                    size_t length,\n                                    napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing a UTF8-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it\nis null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>string</code> value from a UTF8-encoded C string.\nThe native string is copied.</p>\n<p>The JavaScript <code>string</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_string_utf8"
                 }
               ],
               "type": "module",
-              "displayName": "Functions to convert from C types to N-API"
+              "displayName": "Functions to convert from C types to Node-API"
             },
             {
-              "textRaw": "Functions to convert from N-API to C types",
-              "name": "functions_to_convert_from_n-api_to_c_types",
+              "textRaw": "Functions to convert from Node-API to C types",
+              "name": "functions_to_convert_from_node-api_to_c_types",
               "modules": [
                 {
                   "textRaw": "napi_get_array_length",
@@ -1693,7 +1710,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_dataview_info(napi_env env,\n                                   napi_value dataview,\n                                   size_t* byte_length,\n                                   void** data,\n                                   napi_value* arraybuffer,\n                                   size_t* byte_offset)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] dataview</code>: <code>napi_value</code> representing the <code>DataView</code> whose\nproperties to query.</li>\n<li><code>[out] byte_length</code>: <code>Number</code> of bytes in the <code>DataView</code>.</li>\n<li><code>[out] data</code>: The data buffer underlying the <code>DataView</code>.\nIf byte_length is <code>0</code>, this may be <code>NULL</code> or any other pointer value.</li>\n<li><code>[out] arraybuffer</code>: <code>ArrayBuffer</code> underlying the <code>DataView</code>.</li>\n<li><code>[out] byte_offset</code>: The byte offset within the data buffer from which\nto start projecting the <code>DataView</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns various properties of a <code>DataView</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_dataview_info(napi_env env,\n                                   napi_value dataview,\n                                   size_t* byte_length,\n                                   void** data,\n                                   napi_value* arraybuffer,\n                                   size_t* byte_offset)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] dataview</code>: <code>napi_value</code> representing the <code>DataView</code> whose\nproperties to query.</li>\n<li><code>[out] byte_length</code>: Number of bytes in the <code>DataView</code>.</li>\n<li><code>[out] data</code>: The data buffer underlying the <code>DataView</code>.\nIf byte_length is <code>0</code>, this may be <code>NULL</code> or any other pointer value.</li>\n<li><code>[out] arraybuffer</code>: <code>ArrayBuffer</code> underlying the <code>DataView</code>.</li>\n<li><code>[out] byte_offset</code>: The byte offset within the data buffer from which\nto start projecting the <code>DataView</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns various properties of a <code>DataView</code>.</p>",
                   "type": "module",
                   "displayName": "napi_get_dataview_info"
                 },
@@ -1702,7 +1719,8 @@
                   "name": "napi_get_date_value",
                   "meta": {
                     "added": [
-                      "v11.11.0"
+                      "v11.11.0",
+                      "v10.17.0"
                     ],
                     "napiVersion": [
                       5
@@ -1741,7 +1759,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_double(napi_env env,\n                                  napi_value value,\n                                  double* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>\n<li><code>[out] result</code>: C double primitive equivalent of the given JavaScript\n<code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code> is passed\nin it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C double primitive equivalent of the given JavaScript\n<code>Number</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_double(napi_env env,\n                                  napi_value value,\n                                  double* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>\n<li><code>[out] result</code>: C double primitive equivalent of the given JavaScript\n<code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code> is passed\nin it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C double primitive equivalent of the given JavaScript\n<code>number</code>.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_double"
                 },
@@ -1821,7 +1839,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_int32(napi_env env,\n                                 napi_value value,\n                                 int32_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>\n<li><code>[out] result</code>: C <code>int32</code> primitive equivalent of the given JavaScript\n<code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in <code>napi_number_expected</code>.</p>\n<p>This API returns the C <code>int32</code> primitive equivalent\nof the given JavaScript <code>Number</code>.</p>\n<p>If the number exceeds the range of the 32 bit integer, then the result is\ntruncated to the equivalent of the bottom 32 bits. This can result in a large\npositive number becoming a negative number if the value is > 2<sup>31</sup> - 1.</p>\n<p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the\nresult to zero.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_int32(napi_env env,\n                                 napi_value value,\n                                 int32_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>\n<li><code>[out] result</code>: C <code>int32</code> primitive equivalent of the given JavaScript\n<code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in <code>napi_number_expected</code>.</p>\n<p>This API returns the C <code>int32</code> primitive equivalent\nof the given JavaScript <code>number</code>.</p>\n<p>If the number exceeds the range of the 32 bit integer, then the result is\ntruncated to the equivalent of the bottom 32 bits. This can result in a large\npositive number becoming a negative number if the value is > 2<sup>31</sup> - 1.</p>\n<p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the\nresult to zero.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_int32"
                 },
@@ -1837,7 +1855,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_int64(napi_env env,\n                                 napi_value value,\n                                 int64_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>\n<li><code>[out] result</code>: C <code>int64</code> primitive equivalent of the given JavaScript\n<code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C <code>int64</code> primitive equivalent of the given JavaScript\n<code>Number</code>.</p>\n<p><code>Number</code> values outside the range of <a href=\"https://tc39.github.io/ecma262/#sec-number.min_safe_integer\"><code>Number.MIN_SAFE_INTEGER</code></a>\n<code>-(2**53 - 1)</code> - <a href=\"https://tc39.github.io/ecma262/#sec-number.max_safe_integer\"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose\nprecision.</p>\n<p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the\nresult to zero.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_int64(napi_env env,\n                                 napi_value value,\n                                 int64_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>\n<li><code>[out] result</code>: C <code>int64</code> primitive equivalent of the given JavaScript\n<code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C <code>int64</code> primitive equivalent of the given JavaScript\n<code>number</code>.</p>\n<p><code>number</code> values outside the range of <a href=\"https://tc39.github.io/ecma262/#sec-number.min_safe_integer\"><code>Number.MIN_SAFE_INTEGER</code></a>\n<code>-(2**53 - 1)</code> - <a href=\"https://tc39.github.io/ecma262/#sec-number.max_safe_integer\"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose\nprecision.</p>\n<p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the\nresult to zero.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_int64"
                 },
@@ -1853,7 +1871,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_latin1(napi_env env,\n                                         napi_value value,\n                                         char* buf,\n                                         size_t bufsize,\n                                         size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the ISO-8859-1-encoded string into. If <code>NULL</code> is\npassed in, the length of the string (in bytes) is returned.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string will be truncated.</li>\n<li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null\nterminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the ISO-8859-1-encoded string corresponding the value passed\nin.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_latin1(napi_env env,\n                                         napi_value value,\n                                         char* buf,\n                                         size_t bufsize,\n                                         size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the ISO-8859-1-encoded string into. If <code>NULL</code> is\npassed in, the length of the string in bytes and excluding the null terminator\nis returned in <code>result</code>.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string is truncated and null-terminated.</li>\n<li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null\nterminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the ISO-8859-1-encoded string corresponding the value passed\nin.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_string_latin1"
                 },
@@ -1869,7 +1887,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_utf8(napi_env env,\n                                       napi_value value,\n                                       char* buf,\n                                       size_t bufsize,\n                                       size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the UTF8-encoded string into. If <code>NULL</code> is passed\nin, the length of the string (in bytes) is returned.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string will be truncated.</li>\n<li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null\nterminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the UTF8-encoded string corresponding the value passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_utf8(napi_env env,\n                                       napi_value value,\n                                       char* buf,\n                                       size_t bufsize,\n                                       size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the UTF8-encoded string into. If <code>NULL</code> is passed\nin, the length of the string in bytes and excluding the null terminator is\nreturned in <code>result</code>.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string is truncated and null-terminated.</li>\n<li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null\nterminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the UTF8-encoded string corresponding the value passed in.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_string_utf8"
                 },
@@ -1885,7 +1903,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_utf16(napi_env env,\n                                        napi_value value,\n                                        char16_t* buf,\n                                        size_t bufsize,\n                                        size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the UTF16-LE-encoded string into. If <code>NULL</code> is\npassed in, the length of the string (in 2-byte code units) is returned.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string will be truncated.</li>\n<li><code>[out] result</code>: Number of 2-byte code units copied into the buffer, excluding\nthe null terminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the UTF16-encoded string corresponding the value passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_utf16(napi_env env,\n                                        napi_value value,\n                                        char16_t* buf,\n                                        size_t bufsize,\n                                        size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the UTF16-LE-encoded string into. If <code>NULL</code> is\npassed in, the length of the string in 2-byte code units and excluding the\nnull terminator is returned.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string is truncated and null-terminated.</li>\n<li><code>[out] result</code>: Number of 2-byte code units copied into the buffer, excluding\nthe null terminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the UTF16-encoded string corresponding the value passed in.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_string_utf16"
                 },
@@ -1901,13 +1919,13 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_uint32(napi_env env,\n                                  napi_value value,\n                                  uint32_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>\n<li><code>[out] result</code>: C primitive equivalent of the given <code>napi_value</code> as a\n<code>uint32_t</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C primitive equivalent of the given <code>napi_value</code> as a\n<code>uint32_t</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_uint32(napi_env env,\n                                  napi_value value,\n                                  uint32_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>\n<li><code>[out] result</code>: C primitive equivalent of the given <code>napi_value</code> as a\n<code>uint32_t</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C primitive equivalent of the given <code>napi_value</code> as a\n<code>uint32_t</code>.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_uint32"
                 }
               ],
               "type": "module",
-              "displayName": "Functions to convert from N-API to C types"
+              "displayName": "Functions to convert from Node-API to C types"
             },
             {
               "textRaw": "Functions to get global instances",
@@ -1988,7 +2006,7 @@
         {
           "textRaw": "Working with JavaScript values and abstract operations",
           "name": "working_with_javascript_values_and_abstract_operations",
-          "desc": "<p>N-API exposes a set of APIs to perform some abstract operations on JavaScript\nvalues. Some of these operations are documented under <a href=\"https://tc39.github.io/ecma262/#sec-abstract-operations\">Section 7</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>These APIs support doing one of the following:</p>\n<ol>\n<li>Coerce JavaScript values to specific JavaScript types (such as <code>Number</code> or\n<code>String</code>).</li>\n<li>Check the type of a JavaScript value.</li>\n<li>Check for equality between two JavaScript values.</li>\n</ol>",
+          "desc": "<p>Node-API exposes a set of APIs to perform some abstract operations on JavaScript\nvalues. Some of these operations are documented under <a href=\"https://tc39.github.io/ecma262/#sec-abstract-operations\">Section 7</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>These APIs support doing one of the following:</p>\n<ol>\n<li>Coerce JavaScript values to specific JavaScript types (such as <code>number</code> or\n<code>string</code>).</li>\n<li>Check the type of a JavaScript value.</li>\n<li>Check for equality between two JavaScript values.</li>\n</ol>",
           "modules": [
             {
               "textRaw": "napi_coerce_to_bool",
@@ -2018,7 +2036,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_coerce_to_number(napi_env env,\n                                  napi_value value,\n                                  napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: The JavaScript value to coerce.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API implements the abstract operation <code>ToNumber()</code> as defined in\n<a href=\"https://tc39.github.io/ecma262/#sec-tonumber\">Section 7.1.3</a> of the ECMAScript Language Specification.\nThis API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_coerce_to_number(napi_env env,\n                                  napi_value value,\n                                  napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: The JavaScript value to coerce.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API implements the abstract operation <code>ToNumber()</code> as defined in\n<a href=\"https://tc39.github.io/ecma262/#sec-tonumber\">Section 7.1.3</a> of the ECMAScript Language Specification.\nThis API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>",
               "type": "module",
               "displayName": "napi_coerce_to_number"
             },
@@ -2050,7 +2068,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_coerce_to_string(napi_env env,\n                                  napi_value value,\n                                  napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: The JavaScript value to coerce.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>String</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API implements the abstract operation <code>ToString()</code> as defined in\n<a href=\"https://tc39.github.io/ecma262/#sec-toobject\">Section 7.1.13</a> of the ECMAScript Language Specification.\nThis API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_coerce_to_string(napi_env env,\n                                  napi_value value,\n                                  napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: The JavaScript value to coerce.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>string</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API implements the abstract operation <code>ToString()</code> as defined in\n<a href=\"https://tc39.github.io/ecma262/#sec-toobject\">Section 7.1.13</a> of the ECMAScript Language Specification.\nThis API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>",
               "type": "module",
               "displayName": "napi_coerce_to_string"
             },
@@ -2139,7 +2157,8 @@
               "name": "napi_is_date",
               "meta": {
                 "added": [
-                  "v11.11.0"
+                  "v11.11.0",
+                  "v10.17.0"
                 ],
                 "napiVersion": [
                   5
@@ -2219,7 +2238,9 @@
               "name": "napi_detach_arraybuffer",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.0.0",
+                  "v12.16.0",
+                  "v10.22.0"
                 ],
                 "napiVersion": [
                   7
@@ -2235,7 +2256,9 @@
               "name": "napi_is_detached_arraybuffer",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.3.0",
+                  "v12.16.0",
+                  "v10.22.0"
                 ],
                 "napiVersion": [
                   7
@@ -2253,7 +2276,7 @@
         {
           "textRaw": "Working with JavaScript properties",
           "name": "working_with_javascript_properties",
-          "desc": "<p>N-API exposes a set of APIs to get and set properties on JavaScript\nobjects. Some of these types are documented under <a href=\"https://tc39.github.io/ecma262/#sec-abstract-operations\">Section 7</a> of the\n<a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>Properties in JavaScript are represented as a tuple of a key and a value.\nFundamentally, all property keys in N-API can be represented in one of the\nfollowing forms:</p>\n<ul>\n<li>Named: a simple UTF8-encoded string</li>\n<li>Integer-Indexed: an index value represented by <code>uint32_t</code></li>\n<li>JavaScript value: these are represented in N-API by <code>napi_value</code>. This can\nbe a <code>napi_value</code> representing a <code>String</code>, <code>Number</code>, or <code>Symbol</code>.</li>\n</ul>\n<p>N-API values are represented by the type <code>napi_value</code>.\nAny N-API call that requires a JavaScript value takes in a <code>napi_value</code>.\nHowever, it's the caller's responsibility to make sure that the\n<code>napi_value</code> in question is of the JavaScript type expected by the API.</p>\n<p>The APIs documented in this section provide a simple interface to\nget and set properties on arbitrary JavaScript objects represented by\n<code>napi_value</code>.</p>\n<p>For instance, consider the following JavaScript code snippet:</p>\n<pre><code class=\"language-js\">const obj = {};\nobj.myProp = 123;\n</code></pre>\n<p>The equivalent can be done using N-API values with the following snippet:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const obj = {}\nnapi_value obj, value;\nstatus = napi_create_object(env, &#x26;obj);\nif (status != napi_ok) return status;\n\n// Create a napi_value for 123\nstatus = napi_create_int32(env, 123, &#x26;value);\nif (status != napi_ok) return status;\n\n// obj.myProp = 123\nstatus = napi_set_named_property(env, obj, \"myProp\", value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Indexed properties can be set in a similar manner. Consider the following\nJavaScript snippet:</p>\n<pre><code class=\"language-js\">const arr = [];\narr[123] = 'hello';\n</code></pre>\n<p>The equivalent can be done using N-API values with the following snippet:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const arr = [];\nnapi_value arr, value;\nstatus = napi_create_array(env, &#x26;arr);\nif (status != napi_ok) return status;\n\n// Create a napi_value for 'hello'\nstatus = napi_create_string_utf8(env, \"hello\", NAPI_AUTO_LENGTH, &#x26;value);\nif (status != napi_ok) return status;\n\n// arr[123] = 'hello';\nstatus = napi_set_element(env, arr, 123, value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Properties can be retrieved using the APIs described in this section.\nConsider the following JavaScript snippet:</p>\n<pre><code class=\"language-js\">const arr = [];\nconst value = arr[123];\n</code></pre>\n<p>The following is the approximate equivalent of the N-API counterpart:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const arr = []\nnapi_value arr, value;\nstatus = napi_create_array(env, &#x26;arr);\nif (status != napi_ok) return status;\n\n// const value = arr[123]\nstatus = napi_get_element(env, arr, 123, &#x26;value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Finally, multiple properties can also be defined on an object for performance\nreasons. Consider the following JavaScript:</p>\n<pre><code class=\"language-js\">const obj = {};\nObject.defineProperties(obj, {\n  'foo': { value: 123, writable: true, configurable: true, enumerable: true },\n  'bar': { value: 456, writable: true, configurable: true, enumerable: true }\n});\n</code></pre>\n<p>The following is the approximate equivalent of the N-API counterpart:</p>\n<pre><code class=\"language-c\">napi_status status = napi_status_generic_failure;\n\n// const obj = {};\nnapi_value obj;\nstatus = napi_create_object(env, &#x26;obj);\nif (status != napi_ok) return status;\n\n// Create napi_values for 123 and 456\nnapi_value fooValue, barValue;\nstatus = napi_create_int32(env, 123, &#x26;fooValue);\nif (status != napi_ok) return status;\nstatus = napi_create_int32(env, 456, &#x26;barValue);\nif (status != napi_ok) return status;\n\n// Set the properties\nnapi_property_descriptor descriptors[] = {\n  { \"foo\", NULL, NULL, NULL, NULL, fooValue, napi_writable | napi_configurable, NULL },\n  { \"bar\", NULL, NULL, NULL, NULL, barValue, napi_writable | napi_configurable, NULL }\n}\nstatus = napi_define_properties(env,\n                                obj,\n                                sizeof(descriptors) / sizeof(descriptors[0]),\n                                descriptors);\nif (status != napi_ok) return status;\n</code></pre>",
+          "desc": "<p>Node-API exposes a set of APIs to get and set properties on JavaScript\nobjects. Some of these types are documented under <a href=\"https://tc39.github.io/ecma262/#sec-abstract-operations\">Section 7</a> of the\n<a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>Properties in JavaScript are represented as a tuple of a key and a value.\nFundamentally, all property keys in Node-API can be represented in one of the\nfollowing forms:</p>\n<ul>\n<li>Named: a simple UTF8-encoded string</li>\n<li>Integer-Indexed: an index value represented by <code>uint32_t</code></li>\n<li>JavaScript value: these are represented in Node-API by <code>napi_value</code>. This can\nbe a <code>napi_value</code> representing a <code>string</code>, <code>number</code>, or <code>symbol</code>.</li>\n</ul>\n<p>Node-API values are represented by the type <code>napi_value</code>.\nAny Node-API call that requires a JavaScript value takes in a <code>napi_value</code>.\nHowever, it's the caller's responsibility to make sure that the\n<code>napi_value</code> in question is of the JavaScript type expected by the API.</p>\n<p>The APIs documented in this section provide a simple interface to\nget and set properties on arbitrary JavaScript objects represented by\n<code>napi_value</code>.</p>\n<p>For instance, consider the following JavaScript code snippet:</p>\n<pre><code class=\"language-js\">const obj = {};\nobj.myProp = 123;\n</code></pre>\n<p>The equivalent can be done using Node-API values with the following snippet:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const obj = {}\nnapi_value obj, value;\nstatus = napi_create_object(env, &#x26;obj);\nif (status != napi_ok) return status;\n\n// Create a napi_value for 123\nstatus = napi_create_int32(env, 123, &#x26;value);\nif (status != napi_ok) return status;\n\n// obj.myProp = 123\nstatus = napi_set_named_property(env, obj, \"myProp\", value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Indexed properties can be set in a similar manner. Consider the following\nJavaScript snippet:</p>\n<pre><code class=\"language-js\">const arr = [];\narr[123] = 'hello';\n</code></pre>\n<p>The equivalent can be done using Node-API values with the following snippet:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const arr = [];\nnapi_value arr, value;\nstatus = napi_create_array(env, &#x26;arr);\nif (status != napi_ok) return status;\n\n// Create a napi_value for 'hello'\nstatus = napi_create_string_utf8(env, \"hello\", NAPI_AUTO_LENGTH, &#x26;value);\nif (status != napi_ok) return status;\n\n// arr[123] = 'hello';\nstatus = napi_set_element(env, arr, 123, value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Properties can be retrieved using the APIs described in this section.\nConsider the following JavaScript snippet:</p>\n<pre><code class=\"language-js\">const arr = [];\nconst value = arr[123];\n</code></pre>\n<p>The following is the approximate equivalent of the Node-API counterpart:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const arr = []\nnapi_value arr, value;\nstatus = napi_create_array(env, &#x26;arr);\nif (status != napi_ok) return status;\n\n// const value = arr[123]\nstatus = napi_get_element(env, arr, 123, &#x26;value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Finally, multiple properties can also be defined on an object for performance\nreasons. Consider the following JavaScript:</p>\n<pre><code class=\"language-js\">const obj = {};\nObject.defineProperties(obj, {\n  'foo': { value: 123, writable: true, configurable: true, enumerable: true },\n  'bar': { value: 456, writable: true, configurable: true, enumerable: true }\n});\n</code></pre>\n<p>The following is the approximate equivalent of the Node-API counterpart:</p>\n<pre><code class=\"language-c\">napi_status status = napi_status_generic_failure;\n\n// const obj = {};\nnapi_value obj;\nstatus = napi_create_object(env, &#x26;obj);\nif (status != napi_ok) return status;\n\n// Create napi_values for 123 and 456\nnapi_value fooValue, barValue;\nstatus = napi_create_int32(env, 123, &#x26;fooValue);\nif (status != napi_ok) return status;\nstatus = napi_create_int32(env, 456, &#x26;barValue);\nif (status != napi_ok) return status;\n\n// Set the properties\nnapi_property_descriptor descriptors[] = {\n  { \"foo\", NULL, NULL, NULL, NULL, fooValue, napi_writable | napi_configurable, NULL },\n  { \"bar\", NULL, NULL, NULL, NULL, barValue, napi_writable | napi_configurable, NULL }\n}\nstatus = napi_define_properties(env,\n                                obj,\n                                sizeof(descriptors) / sizeof(descriptors[0]),\n                                descriptors);\nif (status != napi_ok) return status;\n</code></pre>",
           "modules": [
             {
               "textRaw": "Structures",
@@ -2265,20 +2288,20 @@
                   "meta": {
                     "changes": [
                       {
-                        "version": "v12.20.0",
+                        "version": "v14.12.0",
                         "pr-url": "https://github.com/nodejs/node/pull/35214",
-                        "description": "added `napi_default_method` and `napi_default_property`"
+                        "description": "added `napi_default_method` and `napi_default_property`."
                       }
                     ]
                   },
-                  "desc": "<pre><code class=\"language-c\">typedef enum {\n  napi_default = 0,\n  napi_writable = 1 &#x3C;&#x3C; 0,\n  napi_enumerable = 1 &#x3C;&#x3C; 1,\n  napi_configurable = 1 &#x3C;&#x3C; 2,\n\n  // Used with napi_define_class to distinguish static properties\n  // from instance properties. Ignored by napi_define_properties.\n  napi_static = 1 &#x3C;&#x3C; 10,\n\n  // Default for class methods.\n  napi_default_method = napi_writable | napi_configurable,\n\n  // Default for object properties, like in JS obj[prop].\n  napi_default_property = napi_writable |\n                          napi_enumerable |\n                          napi_configurable,\n} napi_property_attributes;\n</code></pre>\n<p><code>napi_property_attributes</code> are flags used to control the behavior of properties\nset on a JavaScript object. Other than <code>napi_static</code> they correspond to the\nattributes listed in <a href=\"https://tc39.github.io/ecma262/#table-2\">Section 6.1.7.1</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.\nThey can be one or more of the following bitflags:</p>\n<ul>\n<li><code>napi_default</code>: No explicit attributes are set on the property. By default, a\nproperty is read only, not enumerable and not configurable.</li>\n<li><code>napi_writable</code>: The property is writable.</li>\n<li><code>napi_enumerable</code>: The property is enumerable.</li>\n<li><code>napi_configurable</code>: The property is configurable as defined in\n<a href=\"https://tc39.github.io/ecma262/#table-2\">Section 6.1.7.1</a> of the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</li>\n<li><code>napi_static</code>: The property will be defined as a static property on a class as\nopposed to an instance property, which is the default. This is used only by\n<a href=\"n-api.html#n_api_napi_define_class\"><code>napi_define_class</code></a>. It is ignored by <code>napi_define_properties</code>.</li>\n<li><code>napi_default_method</code>: The property is configureable, writeable but not\nenumerable like a method in a JS class.</li>\n<li><code>napi_default_property</code>: The property is writable, enumerable and configurable\nlike a property set via JS code <code>obj.key = value</code>.</li>\n</ul>",
+                  "desc": "<pre><code class=\"language-c\">typedef enum {\n  napi_default = 0,\n  napi_writable = 1 &#x3C;&#x3C; 0,\n  napi_enumerable = 1 &#x3C;&#x3C; 1,\n  napi_configurable = 1 &#x3C;&#x3C; 2,\n\n  // Used with napi_define_class to distinguish static properties\n  // from instance properties. Ignored by napi_define_properties.\n  napi_static = 1 &#x3C;&#x3C; 10,\n\n  // Default for class methods.\n  napi_default_method = napi_writable | napi_configurable,\n\n  // Default for object properties, like in JS obj[prop].\n  napi_default_jsproperty = napi_writable |\n                          napi_enumerable |\n                          napi_configurable,\n} napi_property_attributes;\n</code></pre>\n<p><code>napi_property_attributes</code> are flags used to control the behavior of properties\nset on a JavaScript object. Other than <code>napi_static</code> they correspond to the\nattributes listed in <a href=\"https://tc39.github.io/ecma262/#table-2\">Section 6.1.7.1</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.\nThey can be one or more of the following bitflags:</p>\n<ul>\n<li><code>napi_default</code>: No explicit attributes are set on the property. By default, a\nproperty is read only, not enumerable and not configurable.</li>\n<li><code>napi_writable</code>: The property is writable.</li>\n<li><code>napi_enumerable</code>: The property is enumerable.</li>\n<li><code>napi_configurable</code>: The property is configurable as defined in\n<a href=\"https://tc39.github.io/ecma262/#table-2\">Section 6.1.7.1</a> of the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</li>\n<li><code>napi_static</code>: The property will be defined as a static property on a class as\nopposed to an instance property, which is the default. This is used only by\n<a href=\"n-api.html#n_api_napi_define_class\"><code>napi_define_class</code></a>. It is ignored by <code>napi_define_properties</code>.</li>\n<li><code>napi_default_method</code>: Like a method in a JS class, the property is\nconfigurable and writeable, but not enumerable.</li>\n<li><code>napi_default_jsproperty</code>: Like a property set via assignment in JavaScript,\nthe property is writable, enumerable, and configurable.</li>\n</ul>",
                   "type": "module",
                   "displayName": "napi_property_attributes"
                 },
                 {
                   "textRaw": "napi_property_descriptor",
                   "name": "napi_property_descriptor",
-                  "desc": "<pre><code class=\"language-c\">typedef struct {\n  // One of utf8name or name should be NULL.\n  const char* utf8name;\n  napi_value name;\n\n  napi_callback method;\n  napi_callback getter;\n  napi_callback setter;\n  napi_value value;\n\n  napi_property_attributes attributes;\n  void* data;\n} napi_property_descriptor;\n</code></pre>\n<ul>\n<li><code>utf8name</code>: Optional <code>String</code> describing the key for the property,\nencoded as UTF8. One of <code>utf8name</code> or <code>name</code> must be provided for the\nproperty.</li>\n<li><code>name</code>: Optional <code>napi_value</code> that points to a JavaScript string or symbol\nto be used as the key for the property. One of <code>utf8name</code> or <code>name</code> must\nbe provided for the property.</li>\n<li><code>value</code>: The value that's retrieved by a get access of the property if the\nproperty is a data property. If this is passed in, set <code>getter</code>, <code>setter</code>,\n<code>method</code> and <code>data</code> to <code>NULL</code> (since these members won't be used).</li>\n<li><code>getter</code>: A function to call when a get access of the property is performed.\nIf this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members\nwon't be used). The given function is called implicitly by the runtime when\nthe property is accessed from JavaScript code (or if a get on the property is\nperformed using a N-API call). <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>setter</code>: A function to call when a set access of the property is performed.\nIf this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members\nwon't be used). The given function is called implicitly by the runtime when\nthe property is set from JavaScript code (or if a set on the property is\nperformed using a N-API call). <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>method</code>: Set this to make the property descriptor object's <code>value</code>\nproperty to be a JavaScript function represented by <code>method</code>. If this is\npassed in, set <code>value</code>, <code>getter</code> and <code>setter</code> to <code>NULL</code> (since these members\nwon't be used). <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>attributes</code>: The attributes associated with the particular property. See\n<a href=\"n-api.html#n_api_napi_property_attributes\"><code>napi_property_attributes</code></a>.</li>\n<li><code>data</code>: The callback data passed into <code>method</code>, <code>getter</code> and <code>setter</code> if this\nfunction is invoked.</li>\n</ul>",
+                  "desc": "<pre><code class=\"language-c\">typedef struct {\n  // One of utf8name or name should be NULL.\n  const char* utf8name;\n  napi_value name;\n\n  napi_callback method;\n  napi_callback getter;\n  napi_callback setter;\n  napi_value value;\n\n  napi_property_attributes attributes;\n  void* data;\n} napi_property_descriptor;\n</code></pre>\n<ul>\n<li><code>utf8name</code>: Optional string describing the key for the property,\nencoded as UTF8. One of <code>utf8name</code> or <code>name</code> must be provided for the\nproperty.</li>\n<li><code>name</code>: Optional <code>napi_value</code> that points to a JavaScript string or symbol\nto be used as the key for the property. One of <code>utf8name</code> or <code>name</code> must\nbe provided for the property.</li>\n<li><code>value</code>: The value that's retrieved by a get access of the property if the\nproperty is a data property. If this is passed in, set <code>getter</code>, <code>setter</code>,\n<code>method</code> and <code>data</code> to <code>NULL</code> (since these members won't be used).</li>\n<li><code>getter</code>: A function to call when a get access of the property is performed.\nIf this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members\nwon't be used). The given function is called implicitly by the runtime when\nthe property is accessed from JavaScript code (or if a get on the property is\nperformed using a Node-API call). <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>setter</code>: A function to call when a set access of the property is performed.\nIf this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members\nwon't be used). The given function is called implicitly by the runtime when\nthe property is set from JavaScript code (or if a set on the property is\nperformed using a Node-API call). <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>method</code>: Set this to make the property descriptor object's <code>value</code>\nproperty to be a JavaScript function represented by <code>method</code>. If this is\npassed in, set <code>value</code>, <code>getter</code> and <code>setter</code> to <code>NULL</code> (since these members\nwon't be used). <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>attributes</code>: The attributes associated with the particular property. See\n<a href=\"n-api.html#n_api_napi_property_attributes\"><code>napi_property_attributes</code></a>.</li>\n<li><code>data</code>: The callback data passed into <code>method</code>, <code>getter</code> and <code>setter</code> if this\nfunction is invoked.</li>\n</ul>",
                   "type": "module",
                   "displayName": "napi_property_descriptor"
                 }
@@ -2302,7 +2325,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_property_names(napi_env env,\n                                    napi_value object,\n                                    napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values\nthat represent the property names of the object. The API can be used to\niterate over <code>result</code> using <a href=\"n-api.html#n_api_napi_get_array_length\"><code>napi_get_array_length</code></a>\nand <a href=\"n-api.html#n_api_napi_get_element\"><code>napi_get_element</code></a>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns the names of the enumerable properties of <code>object</code> as an array\nof strings. The properties of <code>object</code> whose key is a symbol will not be\nincluded.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_property_names(napi_env env,\n                                    napi_value object,\n                                    napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values\nthat represent the property names of the object. The API can be used to\niterate over <code>result</code> using <a href=\"n-api.html#n_api_napi_get_array_length\"><code>napi_get_array_length</code></a>\nand <a href=\"n-api.html#n_api_napi_get_element\"><code>napi_get_element</code></a>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns the names of the enumerable properties of <code>object</code> as an array\nof strings. The properties of <code>object</code> whose key is a symbol will not be\nincluded.</p>",
                   "type": "module",
                   "displayName": "napi_get_property_names"
                 },
@@ -2311,14 +2334,15 @@
                   "name": "napi_get_all_property_names",
                   "meta": {
                     "added": [
-                      "v12.17.0"
+                      "v13.7.0",
+                      "v10.20.0"
                     ],
                     "napiVersion": [
                       6
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_get_all_property_names(napi_env env,\n                            napi_value object,\n                            napi_key_collection_mode key_mode,\n                            napi_key_filter key_filter,\n                            napi_key_conversion key_conversion,\n                            napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[in] key_mode</code>: Whether to retrieve prototype properties as well.</li>\n<li><code>[in] key_filter</code>: Which properties to retrieve\n(enumerable/readable/writable).</li>\n<li><code>[in] key_conversion</code>: Whether to convert numbered property keys to strings.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values\nthat represent the property names of the object. <a href=\"n-api.html#n_api_napi_get_array_length\"><code>napi_get_array_length</code></a> and\n<a href=\"n-api.html#n_api_napi_get_element\"><code>napi_get_element</code></a> can be used to iterate over <code>result</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an array containing the names of the available properties\nof this object.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_get_all_property_names(napi_env env,\n                            napi_value object,\n                            napi_key_collection_mode key_mode,\n                            napi_key_filter key_filter,\n                            napi_key_conversion key_conversion,\n                            napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[in] key_mode</code>: Whether to retrieve prototype properties as well.</li>\n<li><code>[in] key_filter</code>: Which properties to retrieve\n(enumerable/readable/writable).</li>\n<li><code>[in] key_conversion</code>: Whether to convert numbered property keys to strings.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values\nthat represent the property names of the object. <a href=\"n-api.html#n_api_napi_get_array_length\"><code>napi_get_array_length</code></a>\nand <a href=\"n-api.html#n_api_napi_get_element\"><code>napi_get_element</code></a> can be used to iterate over <code>result</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an array containing the names of the available properties\nof this object.</p>",
                   "type": "module",
                   "displayName": "napi_get_all_property_names"
                 },
@@ -2334,7 +2358,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object on which to set the property.</li>\n<li><code>[in] key</code>: The name of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API set a property on the <code>Object</code> passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object on which to set the property.</li>\n<li><code>[in] key</code>: The name of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API set a property on the <code>Object</code> passed in.</p>",
                   "type": "module",
                   "displayName": "napi_set_property"
                 },
@@ -2350,7 +2374,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] key</code>: The name of the property to retrieve.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API gets the requested property from the <code>Object</code> passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] key</code>: The name of the property to retrieve.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API gets the requested property from the <code>Object</code> passed in.</p>",
                   "type": "module",
                   "displayName": "napi_get_property"
                 },
@@ -2366,7 +2390,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API checks if the <code>Object</code> passed in has the named property.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API checks if the <code>Object</code> passed in has the named property.</p>",
                   "type": "module",
                   "displayName": "napi_has_property"
                 },
@@ -2382,7 +2406,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_delete_property(napi_env env,\n                                 napi_value object,\n                                 napi_value key,\n                                 bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the property to delete.</li>\n<li><code>[out] result</code>: Whether the property deletion succeeded or not. <code>result</code> can\noptionally be ignored by passing <code>NULL</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API attempts to delete the <code>key</code> own property from <code>object</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_delete_property(napi_env env,\n                                 napi_value object,\n                                 napi_value key,\n                                 bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the property to delete.</li>\n<li><code>[out] result</code>: Whether the property deletion succeeded or not. <code>result</code> can\noptionally be ignored by passing <code>NULL</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API attempts to delete the <code>key</code> own property from <code>object</code>.</p>",
                   "type": "module",
                   "displayName": "napi_delete_property"
                 },
@@ -2398,7 +2422,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_own_property(napi_env env,\n                                  napi_value object,\n                                  napi_value key,\n                                  bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the own property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the own property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API checks if the <code>Object</code> passed in has the named own property. <code>key</code> must\nbe a string or a <code>Symbol</code>, or an error will be thrown. N-API will not perform\nany conversion between data types.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_own_property(napi_env env,\n                                  napi_value object,\n                                  napi_value key,\n                                  bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the own property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the own property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API checks if the <code>Object</code> passed in has the named own property. <code>key</code> must\nbe a <code>string</code> or a <code>symbol</code>, or an error will be thrown. Node-API will not\nperform any conversion between data types.</p>",
                   "type": "module",
                   "displayName": "napi_has_own_property"
                 },
@@ -2414,7 +2438,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object on which to set the property.</li>\n<li><code>[in] utf8Name</code>: The name of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"n-api.html#n_api_napi_set_property\"><code>napi_set_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object on which to set the property.</li>\n<li><code>[in] utf8Name</code>: The name of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"n-api.html#n_api_napi_set_property\"><code>napi_set_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
                   "type": "module",
                   "displayName": "napi_set_named_property"
                 },
@@ -2430,7 +2454,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] utf8Name</code>: The name of the property to get.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"n-api.html#n_api_napi_get_property\"><code>napi_get_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] utf8Name</code>: The name of the property to get.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"n-api.html#n_api_napi_get_property\"><code>napi_get_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
                   "type": "module",
                   "displayName": "napi_get_named_property"
                 },
@@ -2446,7 +2470,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] utf8Name</code>: The name of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"n-api.html#n_api_napi_has_property\"><code>napi_has_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] utf8Name</code>: The name of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"n-api.html#n_api_napi_has_property\"><code>napi_has_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
                   "type": "module",
                   "displayName": "napi_has_named_property"
                 },
@@ -2462,7 +2486,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to set the properties.</li>\n<li><code>[in] index</code>: The index of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API sets and element on the <code>Object</code> passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to set the properties.</li>\n<li><code>[in] index</code>: The index of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API sets and element on the <code>Object</code> passed in.</p>",
                   "type": "module",
                   "displayName": "napi_set_element"
                 },
@@ -2478,7 +2502,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] index</code>: The index of the property to get.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API gets the element at the requested index.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] index</code>: The index of the property to get.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API gets the element at the requested index.</p>",
                   "type": "module",
                   "displayName": "napi_get_element"
                 },
@@ -2494,7 +2518,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] index</code>: The index of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns if the <code>Object</code> passed in has an element at the\nrequested index.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] index</code>: The index of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns if the <code>Object</code> passed in has an element at the\nrequested index.</p>",
                   "type": "module",
                   "displayName": "napi_has_element"
                 },
@@ -2510,7 +2534,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_delete_element(napi_env env,\n                                napi_value object,\n                                uint32_t index,\n                                bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] index</code>: The index of the property to delete.</li>\n<li><code>[out] result</code>: Whether the element deletion succeeded or not. <code>result</code> can\noptionally be ignored by passing <code>NULL</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API attempts to delete the specified <code>index</code> from <code>object</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_delete_element(napi_env env,\n                                napi_value object,\n                                uint32_t index,\n                                bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] index</code>: The index of the property to delete.</li>\n<li><code>[out] result</code>: Whether the element deletion succeeded or not. <code>result</code> can\noptionally be ignored by passing <code>NULL</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API attempts to delete the specified <code>index</code> from <code>object</code>.</p>",
                   "type": "module",
                   "displayName": "napi_delete_element"
                 },
@@ -2526,7 +2550,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_define_properties(napi_env env,\n                                   napi_value object,\n                                   size_t property_count,\n                                   const napi_property_descriptor* properties);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[in] property_count</code>: The number of elements in the <code>properties</code> array.</li>\n<li><code>[in] properties</code>: The array of property descriptors.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows the efficient definition of multiple properties on a given\nobject. The properties are defined using property descriptors (see\n<a href=\"n-api.html#n_api_napi_property_descriptor\"><code>napi_property_descriptor</code></a>). Given an array of such property descriptors,\nthis API will set the properties on the object one at a time, as defined by\n<code>DefineOwnProperty()</code> (described in <a href=\"https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc\">Section 9.1.6</a> of the ECMA-262\nspecification).</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_define_properties(napi_env env,\n                                   napi_value object,\n                                   size_t property_count,\n                                   const napi_property_descriptor* properties);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[in] property_count</code>: The number of elements in the <code>properties</code> array.</li>\n<li><code>[in] properties</code>: The array of property descriptors.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows the efficient definition of multiple properties on a given\nobject. The properties are defined using property descriptors (see\n<a href=\"n-api.html#n_api_napi_property_descriptor\"><code>napi_property_descriptor</code></a>). Given an array of such property descriptors,\nthis API will set the properties on the object one at a time, as defined by\n<code>DefineOwnProperty()</code> (described in <a href=\"https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc\">Section 9.1.6</a> of the ECMA-262\nspecification).</p>",
                   "type": "module",
                   "displayName": "napi_define_properties"
                 },
@@ -2535,6 +2559,7 @@
                   "name": "napi_object_freeze",
                   "meta": {
                     "added": [
+                      "v14.14.0",
                       "v12.20.0"
                     ],
                     "napiVersion": [
@@ -2542,7 +2567,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_object_freeze(napi_env env,\n                               napi_value object);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to freeze.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method freezes a given object. This prevents new properties from\nbeing added to it, existing properties from being removed, prevents\nchanging the enumerability, configurability, or writability of existing\nproperties, and prevents the values of existing properties from being changed.\nIt also prevents the object's prototype from being changed. This is described\nin <a href=\"https://tc39.es/ecma262/#sec-object.freeze\">Section 19.1.2.6</a> of the\nECMA-262 specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_object_freeze(napi_env env,\n                               napi_value object);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to freeze.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method freezes a given object. This prevents new properties from\nbeing added to it, existing properties from being removed, prevents\nchanging the enumerability, configurability, or writability of existing\nproperties, and prevents the values of existing properties from being changed.\nIt also prevents the object's prototype from being changed. This is described\nin <a href=\"https://tc39.es/ecma262/#sec-object.freeze\">Section 19.1.2.6</a> of the\nECMA-262 specification.</p>",
                   "type": "module",
                   "displayName": "napi_object_freeze"
                 },
@@ -2551,6 +2576,7 @@
                   "name": "napi_object_seal",
                   "meta": {
                     "added": [
+                      "v14.14.0",
                       "v12.20.0"
                     ],
                     "napiVersion": [
@@ -2558,7 +2584,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_object_seal(napi_env env,\n                             napi_value object);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to seal.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method seals a given object. This prevents new properties from being\nadded to it, as well as marking all existing properties as non-configurable.\nThis is described in <a href=\"https://tc39.es/ecma262/#sec-object.seal\">Section 19.1.2.20</a>\nof the ECMA-262 specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_object_seal(napi_env env,\n                             napi_value object);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to seal.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method seals a given object. This prevents new properties from being\nadded to it, as well as marking all existing properties as non-configurable.\nThis is described in <a href=\"https://tc39.es/ecma262/#sec-object.seal\">Section 19.1.2.20</a>\nof the ECMA-262 specification.</p>",
                   "type": "module",
                   "displayName": "napi_object_seal"
                 }
@@ -2573,7 +2599,7 @@
         {
           "textRaw": "Working with JavaScript functions",
           "name": "working_with_javascript_functions",
-          "desc": "<p>N-API provides a set of APIs that allow JavaScript code to\ncall back into native code. N-API APIs that support calling back\ninto native code take in a callback functions represented by\nthe <code>napi_callback</code> type. When the JavaScript VM calls back to\nnative code, the <code>napi_callback</code> function provided is invoked. The APIs\ndocumented in this section allow the callback function to do the\nfollowing:</p>\n<ul>\n<li>Get information about the context in which the callback was invoked.</li>\n<li>Get the arguments passed into the callback.</li>\n<li>Return a <code>napi_value</code> back from the callback.</li>\n</ul>\n<p>Additionally, N-API provides a set of functions which allow calling\nJavaScript functions from native code. One can either call a function\nlike a regular JavaScript function call, or as a constructor\nfunction.</p>\n<p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> field of the\n<code>napi_property_descriptor</code> items can be associated with <code>object</code> and freed\nwhenever <code>object</code> is garbage-collected by passing both <code>object</code> and the data to\n<a href=\"n-api.html#n_api_napi_add_finalizer\"><code>napi_add_finalizer</code></a>.</p>",
+          "desc": "<p>Node-API provides a set of APIs that allow JavaScript code to\ncall back into native code. Node-APIs that support calling back\ninto native code take in a callback functions represented by\nthe <code>napi_callback</code> type. When the JavaScript VM calls back to\nnative code, the <code>napi_callback</code> function provided is invoked. The APIs\ndocumented in this section allow the callback function to do the\nfollowing:</p>\n<ul>\n<li>Get information about the context in which the callback was invoked.</li>\n<li>Get the arguments passed into the callback.</li>\n<li>Return a <code>napi_value</code> back from the callback.</li>\n</ul>\n<p>Additionally, Node-API provides a set of functions which allow calling\nJavaScript functions from native code. One can either call a function\nlike a regular JavaScript function call, or as a constructor\nfunction.</p>\n<p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> field of the\n<code>napi_property_descriptor</code> items can be associated with <code>object</code> and freed\nwhenever <code>object</code> is garbage-collected by passing both <code>object</code> and the data to\n<a href=\"n-api.html#n_api_napi_add_finalizer\"><code>napi_add_finalizer</code></a>.</p>",
           "modules": [
             {
               "textRaw": "napi_call_function",
@@ -2587,7 +2613,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_call_function(napi_env env,\n                                           napi_value recv,\n                                           napi_value func,\n                                           size_t argc,\n                                           const napi_value* argv,\n                                           napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] recv</code>: The <code>this</code> object passed to the called function.</li>\n<li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of <code>napi_values</code> representing JavaScript values passed in\nas arguments to the function.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows a JavaScript function object to be called from a native\nadd-on. This is the primary mechanism of calling back <em>from</em> the add-on's\nnative code <em>into</em> JavaScript. For the special case of calling into JavaScript\nafter an async operation, see <a href=\"n-api.html#n_api_napi_make_callback\"><code>napi_make_callback</code></a>.</p>\n<p>A sample use case might look as follows. Consider the following JavaScript\nsnippet:</p>\n<pre><code class=\"language-js\">function AddTwo(num) {\n  return num + 2;\n}\n</code></pre>\n<p>Then, the above function can be invoked from a native add-on using the\nfollowing code:</p>\n<pre><code class=\"language-c\">// Get the function named \"AddTwo\" on the global object\nnapi_value global, add_two, arg;\nnapi_status status = napi_get_global(env, &#x26;global);\nif (status != napi_ok) return;\n\nstatus = napi_get_named_property(env, global, \"AddTwo\", &#x26;add_two);\nif (status != napi_ok) return;\n\n// const arg = 1337\nstatus = napi_create_int32(env, 1337, &#x26;arg);\nif (status != napi_ok) return;\n\nnapi_value* argv = &#x26;arg;\nsize_t argc = 1;\n\n// AddTwo(arg);\nnapi_value return_val;\nstatus = napi_call_function(env, global, add_two, argc, argv, &#x26;return_val);\nif (status != napi_ok) return;\n\n// Convert the result back to a native type\nint32_t result;\nstatus = napi_get_value_int32(env, return_val, &#x26;result);\nif (status != napi_ok) return;\n</code></pre>",
+              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_call_function(napi_env env,\n                                           napi_value recv,\n                                           napi_value func,\n                                           size_t argc,\n                                           const napi_value* argv,\n                                           napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] recv</code>: The <code>this</code> value passed to the called function.</li>\n<li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of <code>napi_values</code> representing JavaScript values passed in\nas arguments to the function.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows a JavaScript function object to be called from a native\nadd-on. This is the primary mechanism of calling back <em>from</em> the add-on's\nnative code <em>into</em> JavaScript. For the special case of calling into JavaScript\nafter an async operation, see <a href=\"n-api.html#n_api_napi_make_callback\"><code>napi_make_callback</code></a>.</p>\n<p>A sample use case might look as follows. Consider the following JavaScript\nsnippet:</p>\n<pre><code class=\"language-js\">function AddTwo(num) {\n  return num + 2;\n}\n</code></pre>\n<p>Then, the above function can be invoked from a native add-on using the\nfollowing code:</p>\n<pre><code class=\"language-c\">// Get the function named \"AddTwo\" on the global object\nnapi_value global, add_two, arg;\nnapi_status status = napi_get_global(env, &#x26;global);\nif (status != napi_ok) return;\n\nstatus = napi_get_named_property(env, global, \"AddTwo\", &#x26;add_two);\nif (status != napi_ok) return;\n\n// const arg = 1337\nstatus = napi_create_int32(env, 1337, &#x26;arg);\nif (status != napi_ok) return;\n\nnapi_value* argv = &#x26;arg;\nsize_t argc = 1;\n\n// AddTwo(arg);\nnapi_value return_val;\nstatus = napi_call_function(env, global, add_two, argc, argv, &#x26;return_val);\nif (status != napi_ok) return;\n\n// Convert the result back to a native type\nint32_t result;\nstatus = napi_get_value_int32(env, return_val, &#x26;result);\nif (status != napi_ok) return;\n</code></pre>",
               "type": "module",
               "displayName": "napi_call_function"
             },
@@ -2619,7 +2645,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_get_cb_info(napi_env env,\n                             napi_callback_info cbinfo,\n                             size_t* argc,\n                             napi_value* argv,\n                             napi_value* thisArg,\n                             void** data)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] cbinfo</code>: The callback info passed into the callback function.</li>\n<li><code>[in-out] argc</code>: Specifies the size of the provided <code>argv</code> array and receives\nthe actual count of arguments.</li>\n<li><code>[out] argv</code>: Buffer to which the <code>napi_value</code> representing the arguments are\ncopied. If there are more arguments than the provided count, only the\nrequested number of arguments are copied. If there are fewer arguments\nprovided than claimed, the rest of <code>argv</code> is filled with <code>napi_value</code> values\nthat represent <code>undefined</code>.</li>\n<li><code>[out] this</code>: Receives the JavaScript <code>this</code> argument for the call.</li>\n<li><code>[out] data</code>: Receives the data pointer for the callback.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is used within a callback function to retrieve details about the\ncall like the arguments and the <code>this</code> pointer from a given callback info.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_get_cb_info(napi_env env,\n                             napi_callback_info cbinfo,\n                             size_t* argc,\n                             napi_value* argv,\n                             napi_value* thisArg,\n                             void** data)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] cbinfo</code>: The callback info passed into the callback function.</li>\n<li><code>[in-out] argc</code>: Specifies the length of the provided <code>argv</code> array and\nreceives the actual count of arguments.</li>\n<li><code>[out] argv</code>: Buffer to which the <code>napi_value</code> representing the arguments are\ncopied. If there are more arguments than the provided count, only the\nrequested number of arguments are copied. If there are fewer arguments\nprovided than claimed, the rest of <code>argv</code> is filled with <code>napi_value</code> values\nthat represent <code>undefined</code>.</li>\n<li><code>[out] this</code>: Receives the JavaScript <code>this</code> argument for the call.</li>\n<li><code>[out] data</code>: Receives the data pointer for the callback.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is used within a callback function to retrieve details about the\ncall like the arguments and the <code>this</code> pointer from a given callback info.</p>",
               "type": "module",
               "displayName": "napi_get_cb_info"
             },
@@ -2651,7 +2677,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_new_instance(napi_env env,\n                              napi_value cons,\n                              size_t argc,\n                              napi_value* argv,\n                              napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] cons</code>: <code>napi_value</code> representing the JavaScript function to be invoked\nas a constructor.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the\narguments to the constructor.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned,\nwhich in this case is the constructed object.</li>\n</ul>\n<p>This method is used to instantiate a new JavaScript value using a given\n<code>napi_value</code> that represents the constructor for the object. For example,\nconsider the following snippet:</p>\n<pre><code class=\"language-js\">function MyObject(param) {\n  this.param = param;\n}\n\nconst arg = 'hello';\nconst value = new MyObject(arg);\n</code></pre>\n<p>The following can be approximated in N-API using the following snippet:</p>\n<pre><code class=\"language-c\">// Get the constructor function MyObject\nnapi_value global, constructor, arg, value;\nnapi_status status = napi_get_global(env, &#x26;global);\nif (status != napi_ok) return;\n\nstatus = napi_get_named_property(env, global, \"MyObject\", &#x26;constructor);\nif (status != napi_ok) return;\n\n// const arg = \"hello\"\nstatus = napi_create_string_utf8(env, \"hello\", NAPI_AUTO_LENGTH, &#x26;arg);\nif (status != napi_ok) return;\n\nnapi_value* argv = &#x26;arg;\nsize_t argc = 1;\n\n// const value = new MyObject(arg)\nstatus = napi_new_instance(env, constructor, argc, argv, &#x26;value);\n</code></pre>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_new_instance(napi_env env,\n                              napi_value cons,\n                              size_t argc,\n                              napi_value* argv,\n                              napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] cons</code>: <code>napi_value</code> representing the JavaScript function to be invoked\nas a constructor.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the\narguments to the constructor.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned,\nwhich in this case is the constructed object.</li>\n</ul>\n<p>This method is used to instantiate a new JavaScript value using a given\n<code>napi_value</code> that represents the constructor for the object. For example,\nconsider the following snippet:</p>\n<pre><code class=\"language-js\">function MyObject(param) {\n  this.param = param;\n}\n\nconst arg = 'hello';\nconst value = new MyObject(arg);\n</code></pre>\n<p>The following can be approximated in Node-API using the following snippet:</p>\n<pre><code class=\"language-c\">// Get the constructor function MyObject\nnapi_value global, constructor, arg, value;\nnapi_status status = napi_get_global(env, &#x26;global);\nif (status != napi_ok) return;\n\nstatus = napi_get_named_property(env, global, \"MyObject\", &#x26;constructor);\nif (status != napi_ok) return;\n\n// const arg = \"hello\"\nstatus = napi_create_string_utf8(env, \"hello\", NAPI_AUTO_LENGTH, &#x26;arg);\nif (status != napi_ok) return;\n\nnapi_value* argv = &#x26;arg;\nsize_t argc = 1;\n\n// const value = new MyObject(arg)\nstatus = napi_new_instance(env, constructor, argc, argv, &#x26;value);\n</code></pre>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>",
               "type": "module",
               "displayName": "napi_new_instance"
             }
@@ -2662,7 +2688,7 @@
         {
           "textRaw": "Object wrap",
           "name": "object_wrap",
-          "desc": "<p>N-API offers a way to \"wrap\" C++ classes and instances so that the class\nconstructor and methods can be called from JavaScript.</p>\n<ol>\n<li>The <a href=\"n-api.html#n_api_napi_define_class\"><code>napi_define_class</code></a> API defines a JavaScript class with constructor,\nstatic properties and methods, and instance properties and methods that\ncorrespond to the C++ class.</li>\n<li>When JavaScript code invokes the constructor, the constructor callback\nuses <a href=\"n-api.html#n_api_napi_wrap\"><code>napi_wrap</code></a> to wrap a new C++ instance in a JavaScript object,\nthen returns the wrapper object.</li>\n<li>When JavaScript code invokes a method or property accessor on the class,\nthe corresponding <code>napi_callback</code> C++ function is invoked. For an instance\ncallback, <a href=\"n-api.html#n_api_napi_unwrap\"><code>napi_unwrap</code></a> obtains the C++ instance that is the target of\nthe call.</li>\n</ol>\n<p>For wrapped objects it may be difficult to distinguish between a function\ncalled on a class prototype and a function called on an instance of a class.\nA common pattern used to address this problem is to save a persistent\nreference to the class constructor for later <code>instanceof</code> checks.</p>\n<pre><code class=\"language-c\">napi_value MyClass_constructor = NULL;\nstatus = napi_get_reference_value(env, MyClass::es_constructor, &#x26;MyClass_constructor);\nassert(napi_ok == status);\nbool is_instance = false;\nstatus = napi_instanceof(env, es_this, MyClass_constructor, &#x26;is_instance);\nassert(napi_ok == status);\nif (is_instance) {\n  // napi_unwrap() ...\n} else {\n  // otherwise...\n}\n</code></pre>\n<p>The reference must be freed once it is no longer needed.</p>\n<p>There are occasions where <code>napi_instanceof()</code> is insufficient for ensuring that\na JavaScript object is a wrapper for a certain native type. This is the case\nespecially when wrapped JavaScript objects are passed back into the addon via\nstatic methods rather than as the <code>this</code> value of prototype methods. In such\ncases there is a chance that they may be unwrapped incorrectly.</p>\n<pre><code class=\"language-js\">const myAddon = require('./build/Release/my_addon.node');\n\n// `openDatabase()` returns a JavaScript object that wraps a native database\n// handle.\nconst dbHandle = myAddon.openDatabase();\n\n// `query()` returns a JavaScript object that wraps a native query handle.\nconst queryHandle = myAddon.query(dbHandle, 'Gimme ALL the things!');\n\n// There is an accidental error in the line below. The first parameter to\n// `myAddon.queryHasRecords()` should be the database handle (`dbHandle`), not\n// the query handle (`query`), so the correct condition for the while-loop\n// should be\n//\n// myAddon.queryHasRecords(dbHandle, queryHandle)\n//\nwhile (myAddon.queryHasRecords(queryHandle, dbHandle)) {\n  // retrieve records\n}\n</code></pre>\n<p>In the above example <code>myAddon.queryHasRecords()</code> is a method that accepts two\narguments. The first is a database handle and the second is a query handle.\nInternally, it unwraps the first argument and casts the resulting pointer to a\nnative database handle. It then unwraps the second argument and casts the\nresulting pointer to a query handle. If the arguments are passed in the wrong\norder, the casts will work, however, there is a good chance that the underlying\ndatabase operation will fail, or will even cause an invalid memory access.</p>\n<p>To ensure that the pointer retrieved from the first argument is indeed a pointer\nto a database handle and, similarly, that the pointer retrieved from the second\nargument is indeed a pointer to a query handle, the implementation of\n<code>queryHasRecords()</code> has to perform a type validation. Retaining the JavaScript\nclass constructor from which the database handle was instantiated and the\nconstructor from which the query handle was instantiated in <code>napi_ref</code>s can\nhelp, because <code>napi_instanceof()</code> can then be used to ensure that the instances\npassed into <code>queryHashRecords()</code> are indeed of the correct type.</p>\n<p>Unfortunately, <code>napi_instanceof()</code> does not protect against prototype\nmanipulation. For example, the prototype of the database handle instance can be\nset to the prototype of the constructor for query handle instances. In this\ncase, the database handle instance can appear as a query handle instance, and it\nwill pass the <code>napi_instanceof()</code> test for a query handle instance, while still\ncontaining a pointer to a database handle.</p>\n<p>To this end, N-API provides type-tagging capabilities.</p>\n<p>A type tag is a 128-bit integer unique to the addon. N-API provides the\n<code>napi_type_tag</code> structure for storing a type tag. When such a value is passed\nalong with a JavaScript object stored in a <code>napi_value</code> to\n<code>napi_type_tag_object()</code>, the JavaScript object will be \"marked\" with the\ntype tag. The \"mark\" is invisible on the JavaScript side. When a JavaScript\nobject arrives into a native binding, <code>napi_check_object_type_tag()</code> can be used\nalong with the original type tag to determine whether the JavaScript object was\npreviously \"marked\" with the type tag. This creates a type-checking capability\nof a higher fidelity than <code>napi_instanceof()</code> can provide, because such type-\ntagging survives prototype manipulation and addon unloading/reloading.</p>\n<p>Continuing the above example, the following skeleton addon implementation\nillustrates the use of <code>napi_type_tag_object()</code> and\n<code>napi_check_object_type_tag()</code>.</p>\n<pre><code class=\"language-c\">// This value is the type tag for a database handle. The command\n//\n//   uuidgen | sed -r -e 's/-//g' -e 's/(.{16})(.*)/0x\\1, 0x\\2/'\n//\n// can be used to obtain the two values with which to initialize the structure.\nstatic const napi_type_tag DatabaseHandleTypeTag = {\n  0x1edf75a38336451d, 0xa5ed9ce2e4c00c38\n};\n\n// This value is the type tag for a query handle.\nstatic const napi_type_tag QueryHandleTypeTag = {\n  0x9c73317f9fad44a3, 0x93c3920bf3b0ad6a\n};\n\nstatic napi_value\nopenDatabase(napi_env env, napi_callback_info info) {\n  napi_status status;\n  napi_value result;\n\n  // Perform the underlying action which results in a database handle.\n  DatabaseHandle* dbHandle = open_database();\n\n  // Create a new, empty JS object.\n  status = napi_create_object(env, &#x26;result);\n  if (status != napi_ok) return NULL;\n\n  // Tag the object to indicate that it holds a pointer to a `DatabaseHandle`.\n  status = napi_type_tag_object(env, result, &#x26;DatabaseHandleTypeTag);\n  if (status != napi_ok) return NULL;\n\n  // Store the pointer to the `DatabaseHandle` structure inside the JS object.\n  status = napi_wrap(env, result, dbHandle, NULL, NULL, NULL);\n  if (status != napi_ok) return NULL;\n\n  return result;\n}\n\n// Later when we receive a JavaScript object purporting to be a database handle\n// we can use `napi_check_object_type_tag()` to ensure that it is indeed such a\n// handle.\n\nstatic napi_value\nquery(napi_env env, napi_callback_info info) {\n  napi_status status;\n  size_t argc = 2;\n  napi_value argv[2];\n  bool is_db_handle;\n\n  status = napi_get_cb_info(env, info, &#x26;argc, argv, NULL, NULL);\n  if (status != napi_ok) return NULL;\n\n  // Check that the object passed as the first parameter has the previously\n  // applied tag.\n  status = napi_check_object_type_tag(env,\n                                      argv[0],\n                                      &#x26;DatabaseHandleTypeTag,\n                                      &#x26;is_db_handle);\n  if (status != napi_ok) return NULL;\n\n  // Throw a `TypeError` if it doesn't.\n  if (!is_db_handle) {\n    // Throw a TypeError.\n    return NULL;\n  }\n}\n</code></pre>",
+          "desc": "<p>Node-API offers a way to \"wrap\" C++ classes and instances so that the class\nconstructor and methods can be called from JavaScript.</p>\n<ol>\n<li>The <a href=\"n-api.html#n_api_napi_define_class\"><code>napi_define_class</code></a> API defines a JavaScript class with constructor,\nstatic properties and methods, and instance properties and methods that\ncorrespond to the C++ class.</li>\n<li>When JavaScript code invokes the constructor, the constructor callback\nuses <a href=\"n-api.html#n_api_napi_wrap\"><code>napi_wrap</code></a> to wrap a new C++ instance in a JavaScript object,\nthen returns the wrapper object.</li>\n<li>When JavaScript code invokes a method or property accessor on the class,\nthe corresponding <code>napi_callback</code> C++ function is invoked. For an instance\ncallback, <a href=\"n-api.html#n_api_napi_unwrap\"><code>napi_unwrap</code></a> obtains the C++ instance that is the target of\nthe call.</li>\n</ol>\n<p>For wrapped objects it may be difficult to distinguish between a function\ncalled on a class prototype and a function called on an instance of a class.\nA common pattern used to address this problem is to save a persistent\nreference to the class constructor for later <code>instanceof</code> checks.</p>\n<pre><code class=\"language-c\">napi_value MyClass_constructor = NULL;\nstatus = napi_get_reference_value(env, MyClass::es_constructor, &#x26;MyClass_constructor);\nassert(napi_ok == status);\nbool is_instance = false;\nstatus = napi_instanceof(env, es_this, MyClass_constructor, &#x26;is_instance);\nassert(napi_ok == status);\nif (is_instance) {\n  // napi_unwrap() ...\n} else {\n  // otherwise...\n}\n</code></pre>\n<p>The reference must be freed once it is no longer needed.</p>\n<p>There are occasions where <code>napi_instanceof()</code> is insufficient for ensuring that\na JavaScript object is a wrapper for a certain native type. This is the case\nespecially when wrapped JavaScript objects are passed back into the addon via\nstatic methods rather than as the <code>this</code> value of prototype methods. In such\ncases there is a chance that they may be unwrapped incorrectly.</p>\n<pre><code class=\"language-js\">const myAddon = require('./build/Release/my_addon.node');\n\n// `openDatabase()` returns a JavaScript object that wraps a native database\n// handle.\nconst dbHandle = myAddon.openDatabase();\n\n// `query()` returns a JavaScript object that wraps a native query handle.\nconst queryHandle = myAddon.query(dbHandle, 'Gimme ALL the things!');\n\n// There is an accidental error in the line below. The first parameter to\n// `myAddon.queryHasRecords()` should be the database handle (`dbHandle`), not\n// the query handle (`query`), so the correct condition for the while-loop\n// should be\n//\n// myAddon.queryHasRecords(dbHandle, queryHandle)\n//\nwhile (myAddon.queryHasRecords(queryHandle, dbHandle)) {\n  // retrieve records\n}\n</code></pre>\n<p>In the above example <code>myAddon.queryHasRecords()</code> is a method that accepts two\narguments. The first is a database handle and the second is a query handle.\nInternally, it unwraps the first argument and casts the resulting pointer to a\nnative database handle. It then unwraps the second argument and casts the\nresulting pointer to a query handle. If the arguments are passed in the wrong\norder, the casts will work, however, there is a good chance that the underlying\ndatabase operation will fail, or will even cause an invalid memory access.</p>\n<p>To ensure that the pointer retrieved from the first argument is indeed a pointer\nto a database handle and, similarly, that the pointer retrieved from the second\nargument is indeed a pointer to a query handle, the implementation of\n<code>queryHasRecords()</code> has to perform a type validation. Retaining the JavaScript\nclass constructor from which the database handle was instantiated and the\nconstructor from which the query handle was instantiated in <code>napi_ref</code>s can\nhelp, because <code>napi_instanceof()</code> can then be used to ensure that the instances\npassed into <code>queryHashRecords()</code> are indeed of the correct type.</p>\n<p>Unfortunately, <code>napi_instanceof()</code> does not protect against prototype\nmanipulation. For example, the prototype of the database handle instance can be\nset to the prototype of the constructor for query handle instances. In this\ncase, the database handle instance can appear as a query handle instance, and it\nwill pass the <code>napi_instanceof()</code> test for a query handle instance, while still\ncontaining a pointer to a database handle.</p>\n<p>To this end, Node-API provides type-tagging capabilities.</p>\n<p>A type tag is a 128-bit integer unique to the addon. Node-API provides the\n<code>napi_type_tag</code> structure for storing a type tag. When such a value is passed\nalong with a JavaScript object stored in a <code>napi_value</code> to\n<code>napi_type_tag_object()</code>, the JavaScript object will be \"marked\" with the\ntype tag. The \"mark\" is invisible on the JavaScript side. When a JavaScript\nobject arrives into a native binding, <code>napi_check_object_type_tag()</code> can be used\nalong with the original type tag to determine whether the JavaScript object was\npreviously \"marked\" with the type tag. This creates a type-checking capability\nof a higher fidelity than <code>napi_instanceof()</code> can provide, because such type-\ntagging survives prototype manipulation and addon unloading/reloading.</p>\n<p>Continuing the above example, the following skeleton addon implementation\nillustrates the use of <code>napi_type_tag_object()</code> and\n<code>napi_check_object_type_tag()</code>.</p>\n<pre><code class=\"language-c\">// This value is the type tag for a database handle. The command\n//\n//   uuidgen | sed -r -e 's/-//g' -e 's/(.{16})(.*)/0x\\1, 0x\\2/'\n//\n// can be used to obtain the two values with which to initialize the structure.\nstatic const napi_type_tag DatabaseHandleTypeTag = {\n  0x1edf75a38336451d, 0xa5ed9ce2e4c00c38\n};\n\n// This value is the type tag for a query handle.\nstatic const napi_type_tag QueryHandleTypeTag = {\n  0x9c73317f9fad44a3, 0x93c3920bf3b0ad6a\n};\n\nstatic napi_value\nopenDatabase(napi_env env, napi_callback_info info) {\n  napi_status status;\n  napi_value result;\n\n  // Perform the underlying action which results in a database handle.\n  DatabaseHandle* dbHandle = open_database();\n\n  // Create a new, empty JS object.\n  status = napi_create_object(env, &#x26;result);\n  if (status != napi_ok) return NULL;\n\n  // Tag the object to indicate that it holds a pointer to a `DatabaseHandle`.\n  status = napi_type_tag_object(env, result, &#x26;DatabaseHandleTypeTag);\n  if (status != napi_ok) return NULL;\n\n  // Store the pointer to the `DatabaseHandle` structure inside the JS object.\n  status = napi_wrap(env, result, dbHandle, NULL, NULL, NULL);\n  if (status != napi_ok) return NULL;\n\n  return result;\n}\n\n// Later when we receive a JavaScript object purporting to be a database handle\n// we can use `napi_check_object_type_tag()` to ensure that it is indeed such a\n// handle.\n\nstatic napi_value\nquery(napi_env env, napi_callback_info info) {\n  napi_status status;\n  size_t argc = 2;\n  napi_value argv[2];\n  bool is_db_handle;\n\n  status = napi_get_cb_info(env, info, &#x26;argc, argv, NULL, NULL);\n  if (status != napi_ok) return NULL;\n\n  // Check that the object passed as the first parameter has the previously\n  // applied tag.\n  status = napi_check_object_type_tag(env,\n                                      argv[0],\n                                      &#x26;DatabaseHandleTypeTag,\n                                      &#x26;is_db_handle);\n  if (status != napi_ok) return NULL;\n\n  // Throw a `TypeError` if it doesn't.\n  if (!is_db_handle) {\n    // Throw a TypeError.\n    return NULL;\n  }\n}\n</code></pre>",
           "modules": [
             {
               "textRaw": "napi_define_class",
@@ -2676,7 +2702,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_define_class(napi_env env,\n                              const char* utf8name,\n                              size_t length,\n                              napi_callback constructor,\n                              void* data,\n                              size_t property_count,\n                              const napi_property_descriptor* properties,\n                              napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] utf8name</code>: Name of the JavaScript constructor function; this is\nnot required to be the same as the C++ class name, though it is recommended\nfor clarity.</li>\n<li><code>[in] length</code>: The length of the <code>utf8name</code> in bytes, or <code>NAPI_AUTO_LENGTH</code>\nif it is null-terminated.</li>\n<li><code>[in] constructor</code>: Callback function that handles constructing instances\nof the class. This should be a static method on the class, not an actual\nC++ constructor function. <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>[in] data</code>: Optional data to be passed to the constructor callback as\nthe <code>data</code> property of the callback info.</li>\n<li><code>[in] property_count</code>: Number of items in the <code>properties</code> array argument.</li>\n<li><code>[in] properties</code>: Array of property descriptors describing static and\ninstance data properties, accessors, and methods on the class\nSee <code>napi_property_descriptor</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing the constructor function for\nthe class.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>Defines a JavaScript class that corresponds to a C++ class, including:</p>\n<ul>\n<li>A JavaScript constructor function that has the class name and invokes the\nprovided C++ constructor callback.</li>\n<li>Properties on the constructor function corresponding to <em>static</em> data\nproperties, accessors, and methods of the C++ class (defined by\nproperty descriptors with the <code>napi_static</code> attribute).</li>\n<li>Properties on the constructor function's <code>prototype</code> object corresponding to\n<em>non-static</em> data properties, accessors, and methods of the C++ class\n(defined by property descriptors without the <code>napi_static</code> attribute).</li>\n</ul>\n<p>The C++ constructor callback should be a static method on the class that calls\nthe actual class constructor, then wraps the new C++ instance in a JavaScript\nobject, and returns the wrapper object. See <code>napi_wrap()</code> for details.</p>\n<p>The JavaScript constructor function returned from <a href=\"n-api.html#n_api_napi_define_class\"><code>napi_define_class</code></a> is\noften saved and used later, to construct new instances of the class from native\ncode, and/or check whether provided values are instances of the class. In that\ncase, to prevent the function value from being garbage-collected, create a\npersistent reference to it using <a href=\"n-api.html#n_api_napi_create_reference\"><code>napi_create_reference</code></a> and ensure the\nreference count is kept >= 1.</p>\n<p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> parameter or via\nthe <code>data</code> field of the <code>napi_property_descriptor</code> array items can be associated\nwith the resulting JavaScript constructor (which is returned in the <code>result</code>\nparameter) and freed whenever the class is garbage-collected by passing both\nthe JavaScript function and the data to <a href=\"n-api.html#n_api_napi_add_finalizer\"><code>napi_add_finalizer</code></a>.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_define_class(napi_env env,\n                              const char* utf8name,\n                              size_t length,\n                              napi_callback constructor,\n                              void* data,\n                              size_t property_count,\n                              const napi_property_descriptor* properties,\n                              napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] utf8name</code>: Name of the JavaScript constructor function; When wrapping a\nC++ class, we recommend for clarity that this name be the same as that of\nthe C++ class.</li>\n<li><code>[in] length</code>: The length of the <code>utf8name</code> in bytes, or <code>NAPI_AUTO_LENGTH</code>\nif it is null-terminated.</li>\n<li><code>[in] constructor</code>: Callback function that handles constructing instances\nof the class. When wrapping a C++ class, this method must be a static member\nwith the <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> signature. A C++ class constructor cannot be\nused. <a href=\"n-api.html#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>[in] data</code>: Optional data to be passed to the constructor callback as\nthe <code>data</code> property of the callback info.</li>\n<li><code>[in] property_count</code>: Number of items in the <code>properties</code> array argument.</li>\n<li><code>[in] properties</code>: Array of property descriptors describing static and\ninstance data properties, accessors, and methods on the class\nSee <code>napi_property_descriptor</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing the constructor function for\nthe class.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>Defines a JavaScript class, including:</p>\n<ul>\n<li>A JavaScript constructor function that has the class name. When wrapping a\ncorresponding C++ class, the callback passed via <code>constructor</code> can be used to\ninstantiate a new C++ class instance, which can then be placed inside the\nJavaScript object instance being constructed using <a href=\"n-api.html#n_api_napi_wrap\"><code>napi_wrap</code></a>.</li>\n<li>Properties on the constructor function whose implementation can call\ncorresponding <em>static</em> data properties, accessors, and methods of the C++\nclass (defined by property descriptors with the <code>napi_static</code> attribute).</li>\n<li>Properties on the constructor function's <code>prototype</code> object. When wrapping a\nC++ class, <em>non-static</em> data properties, accessors, and methods of the C++\nclass can be called from the static functions given in the property\ndescriptors without the <code>napi_static</code> attribute after retrieving the C++ class\ninstance placed inside the JavaScript object instance by using\n<a href=\"n-api.html#n_api_napi_unwrap\"><code>napi_unwrap</code></a>.</li>\n</ul>\n<p>When wrapping a C++ class, the C++ constructor callback passed via <code>constructor</code>\nshould be a static method on the class that calls the actual class constructor,\nthen wraps the new C++ instance in a JavaScript object, and returns the wrapper\nobject. See <a href=\"n-api.html#n_api_napi_wrap\"><code>napi_wrap</code></a> for details.</p>\n<p>The JavaScript constructor function returned from <a href=\"n-api.html#n_api_napi_define_class\"><code>napi_define_class</code></a> is\noften saved and used later to construct new instances of the class from native\ncode, and/or to check whether provided values are instances of the class. In\nthat case, to prevent the function value from being garbage-collected, a\nstrong persistent reference to it can be created using\n<a href=\"n-api.html#n_api_napi_create_reference\"><code>napi_create_reference</code></a>, ensuring that the reference count is kept >= 1.</p>\n<p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> parameter or via\nthe <code>data</code> field of the <code>napi_property_descriptor</code> array items can be associated\nwith the resulting JavaScript constructor (which is returned in the <code>result</code>\nparameter) and freed whenever the class is garbage-collected by passing both\nthe JavaScript function and the data to <a href=\"n-api.html#n_api_napi_add_finalizer\"><code>napi_add_finalizer</code></a>.</p>",
               "type": "module",
               "displayName": "napi_define_class"
             },
@@ -2733,6 +2759,7 @@
               "name": "napi_type_tag_object",
               "meta": {
                 "added": [
+                  "v14.8.0",
                   "v12.19.0"
                 ],
                 "napiVersion": [
@@ -2749,6 +2776,7 @@
               "name": "napi_check_object_type_tag",
               "meta": {
                 "added": [
+                  "v14.8.0",
                   "v12.19.0"
                 ],
                 "napiVersion": [
@@ -2783,7 +2811,7 @@
         {
           "textRaw": "Simple asynchronous operations",
           "name": "simple_asynchronous_operations",
-          "desc": "<p>Addon modules often need to leverage async helpers from libuv as part of their\nimplementation. This allows them to schedule work to be executed asynchronously\nso that their methods can return in advance of the work being completed. This\nallows them to avoid blocking overall execution of the Node.js application.</p>\n<p>N-API provides an ABI-stable interface for these\nsupporting functions which covers the most common asynchronous use cases.</p>\n<p>N-API defines the <code>napi_async_work</code> structure which is used to manage\nasynchronous workers. Instances are created/deleted with\n<a href=\"n-api.html#n_api_napi_create_async_work\"><code>napi_create_async_work</code></a> and <a href=\"n-api.html#n_api_napi_delete_async_work\"><code>napi_delete_async_work</code></a>.</p>\n<p>The <code>execute</code> and <code>complete</code> callbacks are functions that will be\ninvoked when the executor is ready to execute and when it completes its\ntask respectively.</p>\n<p>The <code>execute</code> function should avoid making any N-API calls\nthat could result in the execution of JavaScript or interaction with\nJavaScript objects. Most often, any code that needs to make N-API\ncalls should be made in <code>complete</code> callback instead.\nAvoid using the <code>napi_env</code> parameter in the execute callback as\nit will likely execute JavaScript.</p>\n<p>These functions implement the following interfaces:</p>\n<pre><code class=\"language-c\">typedef void (*napi_async_execute_callback)(napi_env env,\n                                            void* data);\ntypedef void (*napi_async_complete_callback)(napi_env env,\n                                             napi_status status,\n                                             void* data);\n</code></pre>\n<p>When these methods are invoked, the <code>data</code> parameter passed will be the\naddon-provided <code>void*</code> data that was passed into the\n<code>napi_create_async_work</code> call.</p>\n<p>Once created the async worker can be queued\nfor execution using the <a href=\"n-api.html#n_api_napi_queue_async_work\"><code>napi_queue_async_work</code></a> function:</p>\n<pre><code class=\"language-c\">napi_status napi_queue_async_work(napi_env env,\n                                  napi_async_work work);\n</code></pre>\n<p><a href=\"n-api.html#n_api_napi_cancel_async_work\"><code>napi_cancel_async_work</code></a> can be used if the work needs\nto be cancelled before the work has started execution.</p>\n<p>After calling <a href=\"n-api.html#n_api_napi_cancel_async_work\"><code>napi_cancel_async_work</code></a>, the <code>complete</code> callback\nwill be invoked with a status value of <code>napi_cancelled</code>.\nThe work should not be deleted before the <code>complete</code>\ncallback invocation, even when it was cancelled.</p>",
+          "desc": "<p>Addon modules often need to leverage async helpers from libuv as part of their\nimplementation. This allows them to schedule work to be executed asynchronously\nso that their methods can return in advance of the work being completed. This\nallows them to avoid blocking overall execution of the Node.js application.</p>\n<p>Node-API provides an ABI-stable interface for these\nsupporting functions which covers the most common asynchronous use cases.</p>\n<p>Node-API defines the <code>napi_async_work</code> structure which is used to manage\nasynchronous workers. Instances are created/deleted with\n<a href=\"n-api.html#n_api_napi_create_async_work\"><code>napi_create_async_work</code></a> and <a href=\"n-api.html#n_api_napi_delete_async_work\"><code>napi_delete_async_work</code></a>.</p>\n<p>The <code>execute</code> and <code>complete</code> callbacks are functions that will be\ninvoked when the executor is ready to execute and when it completes its\ntask respectively.</p>\n<p>The <code>execute</code> function should avoid making any Node-API calls\nthat could result in the execution of JavaScript or interaction with\nJavaScript objects. Most often, any code that needs to make Node-API\ncalls should be made in <code>complete</code> callback instead.\nAvoid using the <code>napi_env</code> parameter in the execute callback as\nit will likely execute JavaScript.</p>\n<p>These functions implement the following interfaces:</p>\n<pre><code class=\"language-c\">typedef void (*napi_async_execute_callback)(napi_env env,\n                                            void* data);\ntypedef void (*napi_async_complete_callback)(napi_env env,\n                                             napi_status status,\n                                             void* data);\n</code></pre>\n<p>When these methods are invoked, the <code>data</code> parameter passed will be the\naddon-provided <code>void*</code> data that was passed into the\n<code>napi_create_async_work</code> call.</p>\n<p>Once created the async worker can be queued\nfor execution using the <a href=\"n-api.html#n_api_napi_queue_async_work\"><code>napi_queue_async_work</code></a> function:</p>\n<pre><code class=\"language-c\">napi_status napi_queue_async_work(napi_env env,\n                                  napi_async_work work);\n</code></pre>\n<p><a href=\"n-api.html#n_api_napi_cancel_async_work\"><code>napi_cancel_async_work</code></a> can be used if the work needs\nto be cancelled before the work has started execution.</p>\n<p>After calling <a href=\"n-api.html#n_api_napi_cancel_async_work\"><code>napi_cancel_async_work</code></a>, the <code>complete</code> callback\nwill be invoked with a status value of <code>napi_cancelled</code>.\nThe work should not be deleted before the <code>complete</code>\ncallback invocation, even when it was cancelled.</p>",
           "modules": [
             {
               "textRaw": "napi_create_async_work",
@@ -2876,7 +2904,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_async_init(napi_env env,\n                            napi_value async_resource,\n                            napi_value async_resource_name,\n                            napi_async_context* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] async_resource</code>: Object associated with the async work\nthat will be passed to possible <code>async_hooks</code> <a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a>.\nIn order to retain ABI compatibility with previous versions,\npassing <code>NULL</code> for <code>async_resource</code> will not result in an error, however,\nthis will result incorrect operation of async hooks for the\nnapi_async_context created. Potential issues include\nloss of async context when using the AsyncLocalStorage API.</li>\n<li><code>[in] async_resource_name</code>: Identifier for the kind of resource\nthat is being provided for diagnostic information exposed by the\n<code>async_hooks</code> API.</li>\n<li><code>[out] result</code>: The initialized async context.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_async_init(napi_env env,\n                            napi_value async_resource,\n                            napi_value async_resource_name,\n                            napi_async_context* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] async_resource</code>: Object associated with the async work\nthat will be passed to possible <code>async_hooks</code> <a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a> and can be\naccessed by <a href=\"async_hooks.html#async_hooks_async_hooks_executionasyncresource\"><code>async_hooks.executionAsyncResource()</code></a>.</li>\n<li><code>[in] async_resource_name</code>: Identifier for the kind of resource that is being\nprovided for diagnostic information exposed by the <code>async_hooks</code> API.</li>\n<li><code>[out] result</code>: The initialized async context.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>The <code>async_resource</code> object needs to be kept alive until\n<a href=\"n-api.html#n_api_napi_async_destroy\"><code>napi_async_destroy</code></a> to keep <code>async_hooks</code> related API acts correctly. In\norder to retain ABI compatibility with previous versions, <code>napi_async_context</code>s\nare not maintaining the strong reference to the <code>async_resource</code> objects to\navoid introducing causing memory leaks. However, if the <code>async_resource</code> is\ngarbage collected by JavaScript engine before the <code>napi_async_context</code> was\ndestroyed by <code>napi_async_destroy</code>, calling <code>napi_async_context</code> related APIs\nlike <a href=\"n-api.html#n_api_napi_open_callback_scope\"><code>napi_open_callback_scope</code></a> and <a href=\"n-api.html#n_api_napi_make_callback\"><code>napi_make_callback</code></a> can cause\nproblems like loss of async context when using the <code>AsyncLocalStoage</code> API.</p>\n<p>In order to retain ABI compatibility with previous versions, passing <code>NULL</code>\nfor <code>async_resource</code> does not result in an error. However, this is not\nrecommended as this will result poor results with  <code>async_hooks</code>\n<a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a> and <code>async_hooks.executionAsyncResource()</code> as the resource is\nnow required by the underlying <code>async_hooks</code> implementation in order to provide\nthe linkage between async callbacks.</p>",
               "type": "module",
               "displayName": "napi_async_init"
             },
@@ -2909,11 +2937,12 @@
                 "changes": [
                   {
                     "version": "v8.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/15189",
                     "description": "Added `async_context` parameter."
                   }
                 ]
               },
-              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_make_callback(napi_env env,\n                                           napi_async_context async_context,\n                                           napi_value recv,\n                                           napi_value func,\n                                           size_t argc,\n                                           const napi_value* argv,\n                                           napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] async_context</code>: Context for the async operation that is\ninvoking the callback. This should normally be a value previously\nobtained from <a href=\"n-api.html#n_api_napi_async_init\"><code>napi_async_init</code></a>. However <code>NULL</code> is also allowed,\nwhich indicates the current async context (if any) is to be used\nfor the callback.</li>\n<li><code>[in] recv</code>: The <code>this</code> object passed to the called function.</li>\n<li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the\narguments to the function.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows a JavaScript function object to be called from a native\nadd-on. This API is similar to <code>napi_call_function</code>. However, it is used to call\n<em>from</em> native code back <em>into</em> JavaScript <em>after</em> returning from an async\noperation (when there is no other script on the stack). It is a fairly simple\nwrapper around <code>node::MakeCallback</code>.</p>\n<p>Note it is <em>not</em> necessary to use <code>napi_make_callback</code> from within a\n<code>napi_async_complete_callback</code>; in that situation the callback's async\ncontext has already been set up, so a direct call to <code>napi_call_function</code>\nis sufficient and appropriate. Use of the <code>napi_make_callback</code> function\nmay be required when implementing custom async behavior that does not use\n<code>napi_create_async_work</code>.</p>\n<p>Any <code>process.nextTick</code>s or Promises scheduled on the microtask queue by\nJavaScript during the callback are ran before returning back to C/C++.</p>",
+              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_make_callback(napi_env env,\n                                           napi_async_context async_context,\n                                           napi_value recv,\n                                           napi_value func,\n                                           size_t argc,\n                                           const napi_value* argv,\n                                           napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] async_context</code>: Context for the async operation that is\ninvoking the callback. This should normally be a value previously\nobtained from <a href=\"n-api.html#n_api_napi_async_init\"><code>napi_async_init</code></a>.\nIn order to retain ABI compatibility with previous versions, passing <code>NULL</code>\nfor <code>async_context</code> does not result in an error. However, this results\nin incorrect operation of async hooks. Potential issues include loss of\nasync context when using the <code>AsyncLocalStorage</code> API.</li>\n<li><code>[in] recv</code>: The <code>this</code> value passed to the called function.</li>\n<li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the\narguments to the function.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows a JavaScript function object to be called from a native\nadd-on. This API is similar to <code>napi_call_function</code>. However, it is used to call\n<em>from</em> native code back <em>into</em> JavaScript <em>after</em> returning from an async\noperation (when there is no other script on the stack). It is a fairly simple\nwrapper around <code>node::MakeCallback</code>.</p>\n<p>Note it is <em>not</em> necessary to use <code>napi_make_callback</code> from within a\n<code>napi_async_complete_callback</code>; in that situation the callback's async\ncontext has already been set up, so a direct call to <code>napi_call_function</code>\nis sufficient and appropriate. Use of the <code>napi_make_callback</code> function\nmay be required when implementing custom async behavior that does not use\n<code>napi_create_async_work</code>.</p>\n<p>Any <code>process.nextTick</code>s or Promises scheduled on the microtask queue by\nJavaScript during the callback are ran before returning back to C/C++.</p>",
               "type": "module",
               "displayName": "napi_make_callback"
             },
@@ -2929,7 +2958,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,\n                                                 napi_value resource_object,\n                                                 napi_async_context context,\n                                                 napi_callback_scope* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] resource_object</code>: An object associated with the async work\nthat will be passed to possible <code>async_hooks</code> <a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a>.</li>\n<li><code>[in] context</code>: Context for the async operation that is invoking the callback.\nThis should be a value previously obtained from <a href=\"n-api.html#n_api_napi_async_init\"><code>napi_async_init</code></a>.</li>\n<li><code>[out] result</code>: The newly created scope.</li>\n</ul>\n<p>There are cases (for example, resolving promises) where it is\nnecessary to have the equivalent of the scope associated with a callback\nin place when making certain N-API calls. If there is no other script on\nthe stack the <a href=\"n-api.html#n_api_napi_open_callback_scope\"><code>napi_open_callback_scope</code></a> and\n<a href=\"n-api.html#n_api_napi_close_callback_scope\"><code>napi_close_callback_scope</code></a> functions can be used to open/close\nthe required scope.</p>",
+              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,\n                                                 napi_value resource_object,\n                                                 napi_async_context context,\n                                                 napi_callback_scope* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] resource_object</code>: An object associated with the async work\nthat will be passed to possible <code>async_hooks</code> <a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a>. This\nparameter has been deprecated and is ignored at runtime. Use the\n<code>async_resource</code> parameter in <a href=\"n-api.html#n_api_napi_async_init\"><code>napi_async_init</code></a> instead.</li>\n<li><code>[in] context</code>: Context for the async operation that is invoking the callback.\nThis should be a value previously obtained from <a href=\"n-api.html#n_api_napi_async_init\"><code>napi_async_init</code></a>.</li>\n<li><code>[out] result</code>: The newly created scope.</li>\n</ul>\n<p>There are cases (for example, resolving promises) where it is\nnecessary to have the equivalent of the scope associated with a callback\nin place when making certain Node-API calls. If there is no other script on\nthe stack the <a href=\"n-api.html#n_api_napi_open_callback_scope\"><code>napi_open_callback_scope</code></a> and\n<a href=\"n-api.html#n_api_napi_close_callback_scope\"><code>napi_close_callback_scope</code></a> functions can be used to open/close\nthe required scope.</p>",
               "type": "module",
               "displayName": "napi_open_callback_scope"
             },
@@ -2985,7 +3014,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_get_version(napi_env env,\n                             uint32_t* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[out] result</code>: The highest version of N-API supported.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns the highest N-API version supported by the\nNode.js runtime. N-API is planned to be additive such that\nnewer releases of Node.js may support additional API functions.\nIn order to allow an addon to use a newer function when running with\nversions of Node.js that support it, while providing\nfallback behavior when running with Node.js versions that don't\nsupport it:</p>\n<ul>\n<li>Call <code>napi_get_version()</code> to determine if the API is available.</li>\n<li>If available, dynamically load a pointer to the function using <code>uv_dlsym()</code>.</li>\n<li>Use the dynamically loaded pointer to invoke the function.</li>\n<li>If the function is not available, provide an alternate implementation\nthat does not use the function.</li>\n</ul>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_get_version(napi_env env,\n                             uint32_t* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[out] result</code>: The highest version of Node-API supported.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns the highest Node-API version supported by the\nNode.js runtime. Node-API is planned to be additive such that\nnewer releases of Node.js may support additional API functions.\nIn order to allow an addon to use a newer function when running with\nversions of Node.js that support it, while providing\nfallback behavior when running with Node.js versions that don't\nsupport it:</p>\n<ul>\n<li>Call <code>napi_get_version()</code> to determine if the API is available.</li>\n<li>If available, dynamically load a pointer to the function using <code>uv_dlsym()</code>.</li>\n<li>Use the dynamically loaded pointer to invoke the function.</li>\n<li>If the function is not available, provide an alternate implementation\nthat does not use the function.</li>\n</ul>",
               "type": "module",
               "displayName": "napi_get_version"
             }
@@ -3020,7 +3049,7 @@
         {
           "textRaw": "Promises",
           "name": "promises",
-          "desc": "<p>N-API provides facilities for creating <code>Promise</code> objects as described in\n<a href=\"https://tc39.github.io/ecma262/#sec-promise-objects\">Section 25.4</a> of the ECMA specification. It implements promises as a pair of\nobjects. When a promise is created by <code>napi_create_promise()</code>, a \"deferred\"\nobject is created and returned alongside the <code>Promise</code>. The deferred object is\nbound to the created <code>Promise</code> and is the only means to resolve or reject the\n<code>Promise</code> using <code>napi_resolve_deferred()</code> or <code>napi_reject_deferred()</code>. The\ndeferred object that is created by <code>napi_create_promise()</code> is freed by\n<code>napi_resolve_deferred()</code> or <code>napi_reject_deferred()</code>. The <code>Promise</code> object may\nbe returned to JavaScript where it can be used in the usual fashion.</p>\n<p>For example, to create a promise and pass it to an asynchronous worker:</p>\n<pre><code class=\"language-c\">napi_deferred deferred;\nnapi_value promise;\nnapi_status status;\n\n// Create the promise.\nstatus = napi_create_promise(env, &#x26;deferred, &#x26;promise);\nif (status != napi_ok) return NULL;\n\n// Pass the deferred to a function that performs an asynchronous action.\ndo_something_asynchronous(deferred);\n\n// Return the promise to JS\nreturn promise;\n</code></pre>\n<p>The above function <code>do_something_asynchronous()</code> would perform its asynchronous\naction and then it would resolve or reject the deferred, thereby concluding the\npromise and freeing the deferred:</p>\n<pre><code class=\"language-c\">napi_deferred deferred;\nnapi_value undefined;\nnapi_status status;\n\n// Create a value with which to conclude the deferred.\nstatus = napi_get_undefined(env, &#x26;undefined);\nif (status != napi_ok) return NULL;\n\n// Resolve or reject the promise associated with the deferred depending on\n// whether the asynchronous action succeeded.\nif (asynchronous_action_succeeded) {\n  status = napi_resolve_deferred(env, deferred, undefined);\n} else {\n  status = napi_reject_deferred(env, deferred, undefined);\n}\nif (status != napi_ok) return NULL;\n\n// At this point the deferred has been freed, so we should assign NULL to it.\ndeferred = NULL;\n</code></pre>",
+          "desc": "<p>Node-API provides facilities for creating <code>Promise</code> objects as described in\n<a href=\"https://tc39.github.io/ecma262/#sec-promise-objects\">Section 25.4</a> of the ECMA specification. It implements promises as a pair of\nobjects. When a promise is created by <code>napi_create_promise()</code>, a \"deferred\"\nobject is created and returned alongside the <code>Promise</code>. The deferred object is\nbound to the created <code>Promise</code> and is the only means to resolve or reject the\n<code>Promise</code> using <code>napi_resolve_deferred()</code> or <code>napi_reject_deferred()</code>. The\ndeferred object that is created by <code>napi_create_promise()</code> is freed by\n<code>napi_resolve_deferred()</code> or <code>napi_reject_deferred()</code>. The <code>Promise</code> object may\nbe returned to JavaScript where it can be used in the usual fashion.</p>\n<p>For example, to create a promise and pass it to an asynchronous worker:</p>\n<pre><code class=\"language-c\">napi_deferred deferred;\nnapi_value promise;\nnapi_status status;\n\n// Create the promise.\nstatus = napi_create_promise(env, &#x26;deferred, &#x26;promise);\nif (status != napi_ok) return NULL;\n\n// Pass the deferred to a function that performs an asynchronous action.\ndo_something_asynchronous(deferred);\n\n// Return the promise to JS\nreturn promise;\n</code></pre>\n<p>The above function <code>do_something_asynchronous()</code> would perform its asynchronous\naction and then it would resolve or reject the deferred, thereby concluding the\npromise and freeing the deferred:</p>\n<pre><code class=\"language-c\">napi_deferred deferred;\nnapi_value undefined;\nnapi_status status;\n\n// Create a value with which to conclude the deferred.\nstatus = napi_get_undefined(env, &#x26;undefined);\nif (status != napi_ok) return NULL;\n\n// Resolve or reject the promise associated with the deferred depending on\n// whether the asynchronous action succeeded.\nif (asynchronous_action_succeeded) {\n  status = napi_resolve_deferred(env, deferred, undefined);\n} else {\n  status = napi_reject_deferred(env, deferred, undefined);\n}\nif (status != napi_ok) return NULL;\n\n// At this point the deferred has been freed, so we should assign NULL to it.\ndeferred = NULL;\n</code></pre>",
           "modules": [
             {
               "textRaw": "napi_create_promise",
@@ -3093,7 +3122,7 @@
         {
           "textRaw": "Script execution",
           "name": "script_execution",
-          "desc": "<p>N-API provides an API for executing a string containing JavaScript using the\nunderlying JavaScript engine.</p>",
+          "desc": "<p>Node-API provides an API for executing a string containing JavaScript using the\nunderlying JavaScript engine.</p>",
           "modules": [
             {
               "textRaw": "napi_run_script",
@@ -3118,15 +3147,15 @@
         {
           "textRaw": "libuv event loop",
           "name": "libuv_event_loop",
-          "desc": "<p>N-API provides a function for getting the current event loop associated with\na specific <code>napi_env</code>.</p>",
+          "desc": "<p>Node-API provides a function for getting the current event loop associated with\na specific <code>napi_env</code>.</p>",
           "modules": [
             {
               "textRaw": "napi_get_uv_event_loop",
               "name": "napi_get_uv_event_loop",
               "meta": {
                 "added": [
-                  "v8.10.0",
-                  "v9.3.0"
+                  "v9.3.0",
+                  "v8.10.0"
                 ],
                 "napiVersion": [
                   2
@@ -3144,12 +3173,12 @@
         {
           "textRaw": "Asynchronous thread-safe function calls",
           "name": "asynchronous_thread-safe_function_calls",
-          "desc": "<p>JavaScript functions can normally only be called from a native addon's main\nthread. If an addon creates additional threads, then N-API functions that\nrequire a <code>napi_env</code>, <code>napi_value</code>, or <code>napi_ref</code> must not be called from those\nthreads.</p>\n<p>When an addon has additional threads and JavaScript functions need to be invoked\nbased on the processing completed by those threads, those threads must\ncommunicate with the addon's main thread so that the main thread can invoke the\nJavaScript function on their behalf. The thread-safe function APIs provide an\neasy way to do this.</p>\n<p>These APIs provide the type <code>napi_threadsafe_function</code> as well as APIs to\ncreate, destroy, and call objects of this type.\n<code>napi_create_threadsafe_function()</code> creates a persistent reference to a\n<code>napi_value</code> that holds a JavaScript function which can be called from multiple\nthreads. The calls happen asynchronously. This means that values with which the\nJavaScript callback is to be called will be placed in a queue, and, for each\nvalue in the queue, a call will eventually be made to the JavaScript function.</p>\n<p>Upon creation of a <code>napi_threadsafe_function</code> a <code>napi_finalize</code> callback can be\nprovided. This callback will be invoked on the main thread when the thread-safe\nfunction is about to be destroyed. It receives the context and the finalize data\ngiven during construction, and provides an opportunity for cleaning up after the\nthreads e.g. by calling <code>uv_thread_join()</code>. <strong>Aside from the main loop thread,\nno threads should be using the thread-safe function after the finalize callback\ncompletes.</strong></p>\n<p>The <code>context</code> given during the call to <code>napi_create_threadsafe_function()</code> can\nbe retrieved from any thread with a call to\n<code>napi_get_threadsafe_function_context()</code>.</p>",
+          "desc": "<p>JavaScript functions can normally only be called from a native addon's main\nthread. If an addon creates additional threads, then Node-API functions that\nrequire a <code>napi_env</code>, <code>napi_value</code>, or <code>napi_ref</code> must not be called from those\nthreads.</p>\n<p>When an addon has additional threads and JavaScript functions need to be invoked\nbased on the processing completed by those threads, those threads must\ncommunicate with the addon's main thread so that the main thread can invoke the\nJavaScript function on their behalf. The thread-safe function APIs provide an\neasy way to do this.</p>\n<p>These APIs provide the type <code>napi_threadsafe_function</code> as well as APIs to\ncreate, destroy, and call objects of this type.\n<code>napi_create_threadsafe_function()</code> creates a persistent reference to a\n<code>napi_value</code> that holds a JavaScript function which can be called from multiple\nthreads. The calls happen asynchronously. This means that values with which the\nJavaScript callback is to be called will be placed in a queue, and, for each\nvalue in the queue, a call will eventually be made to the JavaScript function.</p>\n<p>Upon creation of a <code>napi_threadsafe_function</code> a <code>napi_finalize</code> callback can be\nprovided. This callback will be invoked on the main thread when the thread-safe\nfunction is about to be destroyed. It receives the context and the finalize data\ngiven during construction, and provides an opportunity for cleaning up after the\nthreads e.g. by calling <code>uv_thread_join()</code>. <strong>Aside from the main loop thread,\nno threads should be using the thread-safe function after the finalize callback\ncompletes.</strong></p>\n<p>The <code>context</code> given during the call to <code>napi_create_threadsafe_function()</code> can\nbe retrieved from any thread with a call to\n<code>napi_get_threadsafe_function_context()</code>.</p>",
           "modules": [
             {
               "textRaw": "Calling a thread-safe function",
               "name": "calling_a_thread-safe_function",
-              "desc": "<p><code>napi_call_threadsafe_function()</code> can be used for initiating a call into\nJavaScript. <code>napi_call_threadsafe_function()</code> accepts a parameter which controls\nwhether the API behaves blockingly. If set to <code>napi_tsfn_nonblocking</code>, the API\nbehaves non-blockingly, returning <code>napi_queue_full</code> if the queue was full,\npreventing data from being successfully added to the queue. If set to\n<code>napi_tsfn_blocking</code>, the API blocks until space becomes available in the queue.\n<code>napi_call_threadsafe_function()</code> never blocks if the thread-safe function was\ncreated with a maximum queue size of 0.</p>\n<p>The actual call into JavaScript is controlled by the callback given via the\n<code>call_js_cb</code> parameter. <code>call_js_cb</code> is invoked on the main thread once for each\nvalue that was placed into the queue by a successful call to\n<code>napi_call_threadsafe_function()</code>. If such a callback is not given, a default\ncallback will be used, and the resulting JavaScript call will have no arguments.\nThe <code>call_js_cb</code> callback receives the JavaScript function to call as a\n<code>napi_value</code> in its parameters, as well as the <code>void*</code> context pointer used when\ncreating the <code>napi_threadsafe_function</code>, and the next data pointer that was\ncreated by one of the secondary threads. The callback can then use an API such\nas <code>napi_call_function()</code> to call into JavaScript.</p>\n<p>The callback may also be invoked with <code>env</code> and <code>call_js_cb</code> both set to <code>NULL</code>\nto indicate that calls into JavaScript are no longer possible, while items\nremain in the queue that may need to be freed. This normally occurs when the\nNode.js process exits while there is a thread-safe function still active.</p>\n<p>It is not necessary to call into JavaScript via <code>napi_make_callback()</code> because\nN-API runs <code>call_js_cb</code> in a context appropriate for callbacks.</p>",
+              "desc": "<p><code>napi_call_threadsafe_function()</code> can be used for initiating a call into\nJavaScript. <code>napi_call_threadsafe_function()</code> accepts a parameter which controls\nwhether the API behaves blockingly. If set to <code>napi_tsfn_nonblocking</code>, the API\nbehaves non-blockingly, returning <code>napi_queue_full</code> if the queue was full,\npreventing data from being successfully added to the queue. If set to\n<code>napi_tsfn_blocking</code>, the API blocks until space becomes available in the queue.\n<code>napi_call_threadsafe_function()</code> never blocks if the thread-safe function was\ncreated with a maximum queue size of 0.</p>\n<p><code>napi_call_threadsafe_function()</code> should not be called with <code>napi_tsfn_blocking</code>\nfrom a JavaScript thread, because, if the queue is full, it may cause the\nJavaScript thread to deadlock.</p>\n<p>The actual call into JavaScript is controlled by the callback given via the\n<code>call_js_cb</code> parameter. <code>call_js_cb</code> is invoked on the main thread once for each\nvalue that was placed into the queue by a successful call to\n<code>napi_call_threadsafe_function()</code>. If such a callback is not given, a default\ncallback will be used, and the resulting JavaScript call will have no arguments.\nThe <code>call_js_cb</code> callback receives the JavaScript function to call as a\n<code>napi_value</code> in its parameters, as well as the <code>void*</code> context pointer used when\ncreating the <code>napi_threadsafe_function</code>, and the next data pointer that was\ncreated by one of the secondary threads. The callback can then use an API such\nas <code>napi_call_function()</code> to call into JavaScript.</p>\n<p>The callback may also be invoked with <code>env</code> and <code>call_js_cb</code> both set to <code>NULL</code>\nto indicate that calls into JavaScript are no longer possible, while items\nremain in the queue that may need to be freed. This normally occurs when the\nNode.js process exits while there is a thread-safe function still active.</p>\n<p>It is not necessary to call into JavaScript via <code>napi_make_callback()</code> because\nNode-API runs <code>call_js_cb</code> in a context appropriate for callbacks.</p>",
               "type": "module",
               "displayName": "Calling a thread-safe function"
             },
@@ -3179,7 +3208,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.6.0",
+                    "version": [
+                      "v12.6.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/27791",
                     "description": "Made `func` parameter optional with custom `call_js_cb`."
                   }
@@ -3215,9 +3247,20 @@
                 "napiVersion": [
                   4
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33453",
+                    "description": "Support for `napi_would_deadlock` has been reverted."
+                  },
+                  {
+                    "version": "v14.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32689",
+                    "description": "Return `napi_would_deadlock` when called with `napi_tsfn_blocking` from the main thread or a worker thread and the queue is full."
+                  }
+                ]
               },
-              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status\nnapi_call_threadsafe_function(napi_threadsafe_function func,\n                              void* data,\n                              napi_threadsafe_function_call_mode is_blocking);\n</code></pre>\n<ul>\n<li><code>[in] func</code>: The asynchronous thread-safe JavaScript function to invoke.</li>\n<li><code>[in] data</code>: Data to send into JavaScript via the callback <code>call_js_cb</code>\nprovided during the creation of the thread-safe JavaScript function.</li>\n<li><code>[in] is_blocking</code>: Flag whose value can be either <code>napi_tsfn_blocking</code> to\nindicate that the call should block if the queue is full or\n<code>napi_tsfn_nonblocking</code> to indicate that the call should return immediately\nwith a status of <code>napi_queue_full</code> whenever the queue is full.</li>\n</ul>\n<p>This API will return <code>napi_closing</code> if <code>napi_release_threadsafe_function()</code> was\ncalled with <code>abort</code> set to <code>napi_tsfn_abort</code> from any thread. The value is only\nadded to the queue if the API returns <code>napi_ok</code>.</p>\n<p>This API may be called from any thread which makes use of <code>func</code>.</p>",
+              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status\nnapi_call_threadsafe_function(napi_threadsafe_function func,\n                              void* data,\n                              napi_threadsafe_function_call_mode is_blocking);\n</code></pre>\n<ul>\n<li><code>[in] func</code>: The asynchronous thread-safe JavaScript function to invoke.</li>\n<li><code>[in] data</code>: Data to send into JavaScript via the callback <code>call_js_cb</code>\nprovided during the creation of the thread-safe JavaScript function.</li>\n<li><code>[in] is_blocking</code>: Flag whose value can be either <code>napi_tsfn_blocking</code> to\nindicate that the call should block if the queue is full or\n<code>napi_tsfn_nonblocking</code> to indicate that the call should return immediately\nwith a status of <code>napi_queue_full</code> whenever the queue is full.</li>\n</ul>\n<p>This API should not be called with <code>napi_tsfn_blocking</code> from a JavaScript\nthread, because, if the queue is full, it may cause the JavaScript thread to\ndeadlock.</p>\n<p>This API will return <code>napi_closing</code> if <code>napi_release_threadsafe_function()</code> was\ncalled with <code>abort</code> set to <code>napi_tsfn_abort</code> from any thread. The value is only\nadded to the queue if the API returns <code>napi_ok</code>.</p>\n<p>This API may be called from any thread which makes use of <code>func</code>.</p>",
               "type": "module",
               "displayName": "napi_call_threadsafe_function"
             },
@@ -3294,7 +3337,7 @@
           "name": "miscellaneous_utilities",
           "meta": {
             "added": [
-              "v12.22.0"
+              "v14.18.0"
             ],
             "changes": []
           },
@@ -3309,7 +3352,7 @@
           "name": "node_api_get_module_file_name",
           "meta": {
             "added": [
-              "v12.22.0"
+              "v14.18.0"
             ],
             "changes": []
           },
@@ -3319,11 +3362,12 @@
           "type": "misc",
           "displayName": "node_api_get_module_file_name"
         }
-      ]
+      ],
+      "source": "doc/api/n-api.md"
     },
     {
-      "textRaw": "Command line options",
-      "name": "Command line options",
+      "textRaw": "Command-line options",
+      "name": "Command-line options",
       "introduced_in": "v5.9.1",
       "type": "misc",
       "desc": "<p>Node.js comes with a variety of CLI options. These options expose built-in\ndebugging, multiple ways to execute scripts, and other helpful runtime options.</p>\n<p>To view this documentation as a manual page in a terminal, run <code>man node</code>.</p>",
@@ -3331,7 +3375,7 @@
         {
           "textRaw": "Synopsis",
           "name": "synopsis",
-          "desc": "<p><code>node [options] [V8 options] [script.js | -e \"script\" | -] [--] [arguments]</code></p>\n<p><code>node inspect [script.js | -e \"script\" | &#x3C;host>:&#x3C;port>] …</code></p>\n<p><code>node --v8-options</code></p>\n<p>Execute without arguments to start the <a href=\"repl.html\">REPL</a>.</p>\n<p><em>For more info about <code>node inspect</code>, please see the <a href=\"debugger.html\">debugger</a> documentation.</em></p>",
+          "desc": "<p><code>node [options] [V8 options] [script.js | -e \"script\" | -] [--] [arguments]</code></p>\n<p><code>node inspect [script.js | -e \"script\" | &#x3C;host>:&#x3C;port>] …</code></p>\n<p><code>node --v8-options</code></p>\n<p>Execute without arguments to start the <a href=\"repl.html\">REPL</a>.</p>\n<p>For more info about <code>node inspect</code>, see the <a href=\"debugger.html\">debugger</a> documentation.</p>",
           "type": "misc",
           "displayName": "Synopsis"
         },
@@ -3347,7 +3391,7 @@
               }
             ]
           },
-          "desc": "<p>All options, including V8 options, allow words to be separated by both\ndashes (<code>-</code>) or underscores (<code>_</code>).</p>\n<p>For example, <code>--pending-deprecation</code> is equivalent to <code>--pending_deprecation</code>.</p>\n<p>If an option that takes a single value, for example <code>--max-http-header-size</code>,\nis passed more than once, then the last passed value will be used. Options\nfrom the command line take precedence over options passed through the\n<a href=\"cli.html#cli_node_options_options\"><code>NODE_OPTIONS</code></a> environment variable.</p>",
+          "desc": "<p>All options, including V8 options, allow words to be separated by both\ndashes (<code>-</code>) or underscores (<code>_</code>). For example, <code>--pending-deprecation</code> is\nequivalent to <code>--pending_deprecation</code>.</p>\n<p>If an option that takes a single value (such as <code>--max-http-header-size</code>) is\npassed more than once, then the last passed value is used. Options from the\ncommand line take precedence over options passed through the <a href=\"cli.html#cli_node_options_options\"><code>NODE_OPTIONS</code></a>\nenvironment variable.</p>",
           "modules": [
             {
               "textRaw": "`-`",
@@ -3358,7 +3402,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Alias for stdin. Analogous to the use of <code>-</code> in other command line utilities,\nmeaning that the script will be read from stdin, and the rest of the options\nare passed to that script.</p>",
+              "desc": "<p>Alias for stdin. Analogous to the use of <code>-</code> in other command-line utilities,\nmeaning that the script is read from stdin, and the rest of the options\nare passed to that script.</p>",
               "type": "module",
               "displayName": "`-`"
             },
@@ -3371,7 +3415,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Indicate the end of node options. Pass the rest of the arguments to the script.\nIf no script filename or eval/print script is supplied prior to this, then\nthe next argument will be used as a script filename.</p>",
+              "desc": "<p>Indicate the end of node options. Pass the rest of the arguments to the script.\nIf no script filename or eval/print script is supplied prior to this, then\nthe next argument is used as a script filename.</p>",
               "type": "module",
               "displayName": "`--`"
             },
@@ -3402,19 +3446,19 @@
               "displayName": "`--completion-bash`"
             },
             {
-              "textRaw": "`--conditions=condition`",
-              "name": "`--conditions=condition`",
+              "textRaw": "`-C=condition`, `--conditions=condition`",
+              "name": "`-c=condition`,_`--conditions=condition`",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.9.0"
                 ],
                 "changes": []
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Enable experimental support for custom conditional exports resolution\nconditions.</p>\n<p>Any number of custom string condition names are permitted.</p>\n<p>The default Node.js conditions of <code>\"node\"</code>, <code>\"default\"</code>, <code>\"import\"</code>, and\n<code>\"require\"</code> will always apply as defined.</p>",
+              "desc": "<p>Enable experimental support for custom <a href=\"packages.html#packages_conditional_exports\">conditional exports</a> resolution\nconditions.</p>\n<p>Any number of custom string condition names are permitted.</p>\n<p>The default Node.js conditions of <code>\"node\"</code>, <code>\"default\"</code>, <code>\"import\"</code>, and\n<code>\"require\"</code> will always apply as defined.</p>\n<p>For example, to run a module with \"development\" resolutions:</p>\n<pre><code class=\"language-console\">$ node -C=development app.js\n</code></pre>",
               "type": "module",
-              "displayName": "`--conditions=condition`"
+              "displayName": "`-C=condition`, `--conditions=condition`"
             },
             {
               "textRaw": "`--cpu-prof`",
@@ -3427,7 +3471,7 @@
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Starts the V8 CPU profiler on start up, and writes the CPU profile to disk\nbefore exit.</p>\n<p>If <code>--cpu-prof-dir</code> is not specified, the generated profile will be placed\nin the current working directory.</p>\n<p>If <code>--cpu-prof-name</code> is not specified, the generated profile will be\nnamed <code>CPU.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.cpuprofile</code>.</p>\n<pre><code class=\"language-console\">$ node --cpu-prof index.js\n$ ls *.cpuprofile\nCPU.20190409.202950.15293.0.0.cpuprofile\n</code></pre>",
+              "desc": "<p>Starts the V8 CPU profiler on start up, and writes the CPU profile to disk\nbefore exit.</p>\n<p>If <code>--cpu-prof-dir</code> is not specified, the generated profile is placed\nin the current working directory.</p>\n<p>If <code>--cpu-prof-name</code> is not specified, the generated profile is\nnamed <code>CPU.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.cpuprofile</code>.</p>\n<pre><code class=\"language-console\">$ node --cpu-prof index.js\n$ ls *.cpuprofile\nCPU.20190409.202950.15293.0.0.cpuprofile\n</code></pre>",
               "type": "module",
               "displayName": "`--cpu-prof`"
             },
@@ -3442,7 +3486,7 @@
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Specify the directory where the CPU profiles generated by <code>--cpu-prof</code> will\nbe placed.</p>\n<p>The default value is controlled by the\n<a href=\"cli.html#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command line option.</p>",
+              "desc": "<p>Specify the directory where the CPU profiles generated by <code>--cpu-prof</code> will\nbe placed.</p>\n<p>The default value is controlled by the\n<a href=\"cli.html#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command-line option.</p>",
               "type": "module",
               "displayName": "`--cpu-prof-dir`"
             },
@@ -3479,14 +3523,20 @@
             {
               "textRaw": "`--diagnostic-dir=directory`",
               "name": "`--diagnostic-dir=directory`",
-              "desc": "<p>Set the directory to which all diagnostic output files will be written to.\nDefaults to current working directory.</p>\n<p>Affects the default output directory of:</p>\n<ul>\n<li><a href=\"cli.html#cli_cpu_prof_dir\">--cpu-prof-dir</a></li>\n<li><a href=\"cli.html#cli_heap_prof_dir\">--heap-prof-dir</a></li>\n<li><a href=\"cli.html#cli_redirect_warnings_file\">--redirect-warnings</a></li>\n</ul>",
+              "desc": "<p>Set the directory to which all diagnostic output files are written.\nDefaults to current working directory.</p>\n<p>Affects the default output directory of:</p>\n<ul>\n<li><a href=\"cli.html#cli_cpu_prof_dir\">--cpu-prof-dir</a></li>\n<li><a href=\"cli.html#cli_heap_prof_dir\">--heap-prof-dir</a></li>\n<li><a href=\"cli.html#cli_redirect_warnings_file\">--redirect-warnings</a></li>\n</ul>",
               "type": "module",
               "displayName": "`--diagnostic-dir=directory`"
             },
             {
               "textRaw": "`--disable-proto=mode`",
               "name": "`--disable-proto=mode`",
-              "desc": "<!--YAML\nadded: v12.17.0\n-->\n<p>Disable the <code>Object.prototype.__proto__</code> property. If <code>mode</code> is <code>delete</code>, the\nproperty will be removed entirely. If <code>mode</code> is <code>throw</code>, accesses to the\nproperty will throw an exception with the code <code>ERR_PROTO_ACCESS</code>.</p>",
+              "meta": {
+                "added": [
+                  "v13.12.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Disable the <code>Object.prototype.__proto__</code> property. If <code>mode</code> is <code>delete</code>, the\nproperty is removed entirely. If <code>mode</code> is <code>throw</code>, accesses to the\nproperty throw an exception with the code <code>ERR_PROTO_ACCESS</code>.</p>",
               "type": "module",
               "displayName": "`--disable-proto=mode`"
             },
@@ -3503,6 +3553,19 @@
               "type": "module",
               "displayName": "`--disallow-code-generation-from-strings`"
             },
+            {
+              "textRaw": "`--dns-result-order=order`",
+              "name": "`--dns-result-order=order`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Set the default value of <code>verbatim</code> in <a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> and\n<a href=\"dns.html#dns_dnspromises_lookup_hostname_options\"><code>dnsPromises.lookup()</code></a>. The value could be:</p>\n<ul>\n<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>\n<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>\n</ul>\n<p>The default is <code>ipv4first</code> and <a href=\"dns.html#dns_dns_setdefaultresultorder_order\"><code>dns.setDefaultResultOrder()</code></a> have higher\npriority than <code>--dns-result-order</code>.</p>",
+              "type": "module",
+              "displayName": "`--dns-result-order=order`"
+            },
             {
               "textRaw": "`--enable-fips`",
               "name": "`--enable-fips`",
@@ -3523,19 +3586,37 @@
                 "added": [
                   "v12.12.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37362",
+                    "description": "This API is no longer experimental."
+                  }
+                ]
               },
-              "stability": 1,
-              "stabilityText": "Experimental",
-              "desc": "<p>Enable experimental Source Map v3 support for stack traces.</p>\n<p>Currently, overriding <code>Error.prepareStackTrace</code> is ignored when the\n<code>--enable-source-maps</code> flag is set.</p>",
+              "desc": "<p>Enable <a href=\"https://sourcemaps.info/spec.html\">Source Map v3</a> support for stack traces.</p>\n<p>When using a transpiler, such as TypeScript, strack traces thrown by an\napplication reference the transpiled code, not the original source position.\n<code>--enable-source-maps</code> enables caching of Source Maps and makes a best\neffort to report stack traces relative to the original source file.</p>\n<p>Overriding <code>Error.prepareStackTrace</code> prevents <code>--enable-source-maps</code> from\nmodifiying the stack trace.</p>",
               "type": "module",
               "displayName": "`--enable-source-maps`"
             },
+            {
+              "textRaw": "`--experimental-abortcontroller`",
+              "name": "`--experimental-abortcontroller`",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Enable experimental <code>AbortController</code> and <code>AbortSignal</code> support.</p>",
+              "type": "module",
+              "displayName": "`--experimental-abortcontroller`"
+            },
             {
               "textRaw": "`--experimental-import-meta-resolve`",
               "name": "`--experimental-import-meta-resolve`",
               "meta": {
                 "added": [
+                  "v13.9.0",
                   "v12.16.2"
                 ],
                 "changes": []
@@ -3566,7 +3647,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Specify the <code>module</code> of a custom <a href=\"esm.html#esm_experimental_loaders\">experimental ECMAScript Module loader</a>.\n<code>module</code> may be either a path to a file, or an ECMAScript Module name.</p>",
+              "desc": "<p>Specify the <code>module</code> of a custom experimental <a href=\"esm.html#esm_loaders\">ECMAScript Module loader</a>.\n<code>module</code> may be either a path to a file, or an ECMAScript Module name.</p>",
               "type": "module",
               "displayName": "`--experimental-loader=module`"
             },
@@ -3614,11 +3695,12 @@
               "name": "`--experimental-specifier-resolution=mode`",
               "meta": {
                 "added": [
+                  "v13.4.0",
                   "v12.16.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>Sets the resolution algorithm for resolving ES module specifiers. Valid options\nare <code>explicit</code> and <code>node</code>.</p>\n<p>The default is <code>explicit</code>, which requires providing the full path to a\nmodule. The <code>node</code> mode will enable support for optional file extensions and\nthe ability to import a directory that has an index file.</p>\n<p>Please see <a href=\"esm.html#esm_customizing_esm_specifier_resolution_algorithm\">customizing ESM specifier resolution</a> for example usage.</p>",
+              "desc": "<p>Sets the resolution algorithm for resolving ES module specifiers. Valid options\nare <code>explicit</code> and <code>node</code>.</p>\n<p>The default is <code>explicit</code>, which requires providing the full path to a\nmodule. The <code>node</code> mode enables support for optional file extensions and\nthe ability to import a directory that has an index file.</p>\n<p>See <a href=\"esm.html#esm_customizing_esm_specifier_resolution_algorithm\">customizing ESM specifier resolution</a> for example usage.</p>",
               "type": "module",
               "displayName": "`--experimental-specifier-resolution=mode`"
             },
@@ -3640,9 +3722,16 @@
               "name": "`--experimental-wasi-unstable-preview1`",
               "meta": {
                 "added": [
+                  "v13.3.0",
                   "v12.16.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v13.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/30980",
+                    "description": "changed from `--experimental-wasi-unstable-preview0` to `--experimental-wasi-unstable-preview1`."
+                  }
+                ]
               },
               "desc": "<p>Enable experimental WebAssembly System Interface (WASI) support.</p>",
               "type": "module",
@@ -3657,6 +3746,7 @@
                 ],
                 "changes": []
               },
+              "desc": "<p>Enable experimental WebAssembly module support.</p>",
               "type": "module",
               "displayName": "`--experimental-wasm-modules`"
             },
@@ -3669,7 +3759,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Disable loading native addons that are not <a href=\"addons.html#addons_context_aware_addons\">context-aware</a>.</p>\n<p>Enable experimental WebAssembly module support.</p>",
+              "desc": "<p>Disable loading native addons that are not <a href=\"addons.html#addons_context_aware_addons\">context-aware</a>.</p>",
               "type": "module",
               "displayName": "`--force-context-aware`"
             },
@@ -3701,6 +3791,21 @@
               "type": "module",
               "displayName": "`--frozen-intrinsics`"
             },
+            {
+              "textRaw": "`--heapsnapshot-near-heap-limit=max_count`",
+              "name": "`--heapsnapshot-near-heap-limit=max_count`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "stability": 1,
+              "stabilityText": "Experimental",
+              "desc": "<p>Writes a V8 heap snapshot to disk when the V8 heap usage is approaching the\nheap limit. <code>count</code> should be a non-negative integer (in which case\nNode.js will write no more than <code>max_count</code> snapshots to disk).</p>\n<p>When generating snapshots, garbage collection may be triggered and bring\nthe heap usage down, therefore multiple snapshots may be written to disk\nbefore the Node.js instance finally runs out of memory. These heap snapshots\ncan be compared to determine what objects are being allocated during the\ntime consecutive snapshots are taken. It's not guaranteed that Node.js will\nwrite exactly <code>max_count</code> snapshots to disk, but it will try\nits best to generate at least one and up to <code>max_count</code> snapshots before the\nNode.js instance runs out of memory when <code>max_count</code> is greater than <code>0</code>.</p>\n<p>Generating V8 snapshots takes time and memory (both memory managed by the\nV8 heap and native memory outside the V8 heap). The bigger the heap is,\nthe more resources it needs. Node.js will adjust the V8 heap to accommondate\nthe additional V8 heap memory overhead, and try its best to avoid using up\nall the memory avialable to the process. When the process uses\nmore memory than the system deems appropriate, the process may be terminated\nabruptly by the system, depending on the system configuration.</p>\n<pre><code class=\"language-console\">$ node --max-old-space-size=100 --heapsnapshot-near-heap-limit=3 index.js\nWrote snapshot to Heap.20200430.100036.49580.0.001.heapsnapshot\nWrote snapshot to Heap.20200430.100037.49580.0.002.heapsnapshot\nWrote snapshot to Heap.20200430.100038.49580.0.003.heapsnapshot\n\n&#x3C;--- Last few GCs --->\n\n[49580:0x110000000]     4826 ms: Mark-sweep 130.6 (147.8) -> 130.5 (147.8) MB, 27.4 / 0.0 ms  (average mu = 0.126, current mu = 0.034) allocation failure scavenge might not succeed\n[49580:0x110000000]     4845 ms: Mark-sweep 130.6 (147.8) -> 130.6 (147.8) MB, 18.8 / 0.0 ms  (average mu = 0.088, current mu = 0.031) allocation failure scavenge might not succeed\n\n\n&#x3C;--- JS stacktrace --->\n\nFATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory\n....\n</code></pre>",
+              "type": "module",
+              "displayName": "`--heapsnapshot-near-heap-limit=max_count`"
+            },
             {
               "textRaw": "`--heapsnapshot-signal=signal`",
               "name": "`--heapsnapshot-signal=signal`",
@@ -3725,7 +3830,7 @@
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Starts the V8 heap profiler on start up, and writes the heap profile to disk\nbefore exit.</p>\n<p>If <code>--heap-prof-dir</code> is not specified, the generated profile will be placed\nin the current working directory.</p>\n<p>If <code>--heap-prof-name</code> is not specified, the generated profile will be\nnamed <code>Heap.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.heapprofile</code>.</p>\n<pre><code class=\"language-console\">$ node --heap-prof index.js\n$ ls *.heapprofile\nHeap.20190409.202950.15293.0.001.heapprofile\n</code></pre>",
+              "desc": "<p>Starts the V8 heap profiler on start up, and writes the heap profile to disk\nbefore exit.</p>\n<p>If <code>--heap-prof-dir</code> is not specified, the generated profile is placed\nin the current working directory.</p>\n<p>If <code>--heap-prof-name</code> is not specified, the generated profile is\nnamed <code>Heap.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.heapprofile</code>.</p>\n<pre><code class=\"language-console\">$ node --heap-prof index.js\n$ ls *.heapprofile\nHeap.20190409.202950.15293.0.001.heapprofile\n</code></pre>",
               "type": "module",
               "displayName": "`--heap-prof`"
             },
@@ -3740,7 +3845,7 @@
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Specify the directory where the heap profiles generated by <code>--heap-prof</code> will\nbe placed.</p>\n<p>The default value is controlled by the\n<a href=\"cli.html#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command line option.</p>",
+              "desc": "<p>Specify the directory where the heap profiles generated by <code>--heap-prof</code> will\nbe placed.</p>\n<p>The default value is controlled by the\n<a href=\"cli.html#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command-line option.</p>",
               "type": "module",
               "displayName": "`--heap-prof-dir`"
             },
@@ -3774,38 +3879,6 @@
               "type": "module",
               "displayName": "`--heap-prof-name`"
             },
-            {
-              "textRaw": "`--http-parser=library`",
-              "name": "`--http-parser=library`",
-              "meta": {
-                "added": [
-                  "v11.4.0"
-                ],
-                "changes": [
-                  {
-                    "version": "v12.22.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/37603",
-                    "description": "The legacy HTTP parser will emit a deprecation warning."
-                  }
-                ]
-              },
-              "desc": "<p>Chooses an HTTP parser library. Available values are:</p>\n<ul>\n<li><code>llhttp</code> for <a href=\"https://llhttp.org/\">https://llhttp.org/</a></li>\n<li><code>legacy</code> for <a href=\"https://github.com/nodejs/http-parser\">https://github.com/nodejs/http-parser</a></li>\n</ul>\n<p>The default is <code>llhttp</code>, unless otherwise specified when building Node.js.</p>\n<p>The <code>legacy</code> HTTP parser is deprecated and will emit a deprecation warning.</p>\n<p>This flag exists to aid in experimentation with the internal implementation of\nthe Node.js http parser.\nThis flag is likely to become a no-op and removed at some point in the future.</p>",
-              "type": "module",
-              "displayName": "`--http-parser=library`"
-            },
-            {
-              "textRaw": "`--http-server-default-timeout=milliseconds`",
-              "name": "`--http-server-default-timeout=milliseconds`",
-              "meta": {
-                "added": [
-                  "v12.4.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>Overrides the default value of <code>http</code>, <code>https</code> and <code>http2</code> server socket\ntimeout. Setting the value to 0 disables server socket timeout. Unless\nprovided, http server sockets timeout after 120s (2 minutes). Programmatic\nsetting of the timeout takes precedence over the value set through this\nflag.</p>",
-              "type": "module",
-              "displayName": "`--http-server-default-timeout=milliseconds`"
-            },
             {
               "textRaw": "`--icu-data-dir=file`",
               "name": "`--icu-data-dir=file`",
@@ -3892,7 +3965,9 @@
               "name": "`--insecure-http-parser`",
               "meta": {
                 "added": [
-                  "v12.15.0"
+                  "v13.4.0",
+                  "v12.15.0",
+                  "v10.19.0"
                 ],
                 "changes": []
               },
@@ -3918,11 +3993,18 @@
               "name": "`--max-http-header-size=size`",
               "meta": {
                 "added": [
-                  "v11.6.0"
+                  "v11.6.0",
+                  "v10.15.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32520",
+                    "description": "Change maximum default size of HTTP headers from 8KB to 16KB."
+                  }
+                ]
               },
-              "desc": "<p>Specify the maximum size, in bytes, of HTTP headers. Defaults to 8KB.</p>",
+              "desc": "<p>Specify the maximum size, in bytes, of HTTP headers. Defaults to 16KB.</p>",
               "type": "module",
               "displayName": "`--max-http-header-size=size`"
             },
@@ -3978,6 +4060,19 @@
               "type": "module",
               "displayName": "`--no-warnings`"
             },
+            {
+              "textRaw": "`--node-memory-debug`",
+              "name": "`--node-memory-debug`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Enable extra debug checks for memory leaks in Node.js internals. This is\nusually only useful for developers debugging Node.js itself.</p>",
+              "type": "module",
+              "displayName": "`--node-memory-debug`"
+            },
             {
               "textRaw": "`--openssl-config=file`",
               "name": "`--openssl-config=file`",
@@ -4000,7 +4095,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Emit pending deprecation warnings.</p>\n<p>Pending deprecations are generally identical to a runtime deprecation with the\nnotable exception that they are turned <em>off</em> by default and will not be emitted\nunless either the <code>--pending-deprecation</code> command line flag, or the\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations\nare used to provide a kind of selective \"early warning\" mechanism that\ndevelopers may leverage to detect deprecated API usage.</p>",
+              "desc": "<p>Emit pending deprecation warnings.</p>\n<p>Pending deprecations are generally identical to a runtime deprecation with the\nnotable exception that they are turned <em>off</em> by default and will not be emitted\nunless either the <code>--pending-deprecation</code> command-line flag, or the\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations\nare used to provide a kind of selective \"early warning\" mechanism that\ndevelopers may leverage to detect deprecated API usage.</p>",
               "type": "module",
               "displayName": "`--pending-deprecation`"
             },
@@ -4028,7 +4123,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Instructs the module loader to preserve symbolic links when resolving and\ncaching modules.</p>\n<p>By default, when Node.js loads a module from a path that is symbolically linked\nto a different on-disk location, Node.js will dereference the link and use the\nactual on-disk \"real path\" of the module as both an identifier and as a root\npath to locate other dependency modules. In most cases, this default behavior\nis acceptable. However, when using symbolically linked peer dependencies, as\nillustrated in the example below, the default behavior causes an exception to\nbe thrown if <code>moduleA</code> attempts to require <code>moduleB</code> as a peer dependency:</p>\n<pre><code class=\"language-text\">{appDir}\n ├── app\n │   ├── index.js\n │   └── node_modules\n │       ├── moduleA -> {appDir}/moduleA\n │       └── moduleB\n │           ├── index.js\n │           └── package.json\n └── moduleA\n     ├── index.js\n     └── package.json\n</code></pre>\n<p>The <code>--preserve-symlinks</code> command line flag instructs Node.js to use the\nsymlink path for modules as opposed to the real path, allowing symbolically\nlinked peer dependencies to be found.</p>\n<p>Note, however, that using <code>--preserve-symlinks</code> can have other side effects.\nSpecifically, symbolically linked <em>native</em> modules can fail to load if those\nare linked from more than one location in the dependency tree (Node.js would\nsee those as two separate modules and would attempt to load the module multiple\ntimes, causing an exception to be thrown).</p>\n<p>The <code>--preserve-symlinks</code> flag does not apply to the main module, which allows\n<code>node --preserve-symlinks node_module/.bin/&#x3C;foo></code> to work. To apply the same\nbehavior for the main module, also use <code>--preserve-symlinks-main</code>.</p>",
+              "desc": "<p>Instructs the module loader to preserve symbolic links when resolving and\ncaching modules.</p>\n<p>By default, when Node.js loads a module from a path that is symbolically linked\nto a different on-disk location, Node.js will dereference the link and use the\nactual on-disk \"real path\" of the module as both an identifier and as a root\npath to locate other dependency modules. In most cases, this default behavior\nis acceptable. However, when using symbolically linked peer dependencies, as\nillustrated in the example below, the default behavior causes an exception to\nbe thrown if <code>moduleA</code> attempts to require <code>moduleB</code> as a peer dependency:</p>\n<pre><code class=\"language-text\">{appDir}\n ├── app\n │   ├── index.js\n │   └── node_modules\n │       ├── moduleA -> {appDir}/moduleA\n │       └── moduleB\n │           ├── index.js\n │           └── package.json\n └── moduleA\n     ├── index.js\n     └── package.json\n</code></pre>\n<p>The <code>--preserve-symlinks</code> command-line flag instructs Node.js to use the\nsymlink path for modules as opposed to the real path, allowing symbolically\nlinked peer dependencies to be found.</p>\n<p>Note, however, that using <code>--preserve-symlinks</code> can have other side effects.\nSpecifically, symbolically linked <em>native</em> modules can fail to load if those\nare linked from more than one location in the dependency tree (Node.js would\nsee those as two separate modules and would attempt to load the module multiple\ntimes, causing an exception to be thrown).</p>\n<p>The <code>--preserve-symlinks</code> flag does not apply to the main module, which allows\n<code>node --preserve-symlinks node_module/.bin/&#x3C;foo></code> to work. To apply the same\nbehavior for the main module, also use <code>--preserve-symlinks-main</code>.</p>",
               "type": "module",
               "displayName": "`--preserve-symlinks`"
             },
@@ -4041,7 +4136,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Instructs the module loader to preserve symbolic links when resolving and\ncaching the main module (<code>require.main</code>).</p>\n<p>This flag exists so that the main module can be opted-in to the same behavior\nthat <code>--preserve-symlinks</code> gives to all other imports; they are separate flags,\nhowever, for backward compatibility with older Node.js versions.</p>\n<p><code>--preserve-symlinks-main</code> does not imply <code>--preserve-symlinks</code>; it\nis expected that <code>--preserve-symlinks-main</code> will be used in addition to\n<code>--preserve-symlinks</code> when it is not desirable to follow symlinks before\nresolving relative paths.</p>\n<p>See <code>--preserve-symlinks</code> for more information.</p>",
+              "desc": "<p>Instructs the module loader to preserve symbolic links when resolving and\ncaching the main module (<code>require.main</code>).</p>\n<p>This flag exists so that the main module can be opted-in to the same behavior\nthat <code>--preserve-symlinks</code> gives to all other imports; they are separate flags,\nhowever, for backward compatibility with older Node.js versions.</p>\n<p><code>--preserve-symlinks-main</code> does not imply <code>--preserve-symlinks</code>; use\n<code>--preserve-symlinks-main</code> in addition to\n<code>--preserve-symlinks</code> when it is not desirable to follow symlinks before\nresolving relative paths.</p>\n<p>See <code>--preserve-symlinks</code> for more information.</p>",
               "type": "module",
               "displayName": "`--preserve-symlinks-main`"
             },
@@ -4080,7 +4175,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Write process warnings to the given file instead of printing to stderr. The\nfile will be created if it does not exist, and will be appended to if it does.\nIf an error occurs while attempting to write the warning to the file, the\nwarning will be written to stderr instead.</p>\n<p>The <code>file</code> name may be an absolute path. If it is not, the default directory it\nwill be written to is controlled by the\n<a href=\"cli.html#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command line option.</p>",
+              "desc": "<p>Write process warnings to the given file instead of printing to stderr. The\nfile will be created if it does not exist, and will be appended to if it does.\nIf an error occurs while attempting to write the warning to the file, the\nwarning will be written to stderr instead.</p>\n<p>The <code>file</code> name may be an absolute path. If it is not, the default directory it\nwill be written to is controlled by the\n<a href=\"cli.html#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command-line option.</p>",
               "type": "module",
               "displayName": "`--redirect-warnings=file`"
             },
@@ -4089,7 +4184,7 @@
               "name": "`--report-compact`",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.12.0"
                 ],
                 "changes": []
               },
@@ -4106,14 +4201,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "Changed from `--diagnostic-report-directory` to `--report-directory`"
+                    "description": "Changed from `--diagnostic-report-directory` to `--report-directory`."
                   }
                 ]
               },
@@ -4130,14 +4225,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-filename` to `--report-filename`"
+                    "description": "changed from `--diagnostic-report-filename` to `--report-filename`."
                   }
                 ]
               },
@@ -4154,14 +4249,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v14.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32496",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-on-fatalerror` to `--report-on-fatalerror`"
+                    "description": "changed from `--diagnostic-report-on-fatalerror` to `--report-on-fatalerror`."
                   }
                 ]
               },
@@ -4178,14 +4273,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-on-signal` to `--report-on-signal`"
+                    "description": "changed from `--diagnostic-report-on-signal` to `--report-on-signal`."
                   }
                 ]
               },
@@ -4202,14 +4297,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-signal` to `--report-signal`"
+                    "description": "changed from `--diagnostic-report-signal` to `--report-signal`."
                   }
                 ]
               },
@@ -4226,14 +4321,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-uncaught-exception` to `--report-uncaught-exception`"
+                    "description": "changed from `--diagnostic-report-uncaught-exception` to `--report-uncaught-exception`."
                   }
                 ]
               },
@@ -4285,6 +4380,7 @@
               "name": "`--tls-keylog=file`",
               "meta": {
                 "added": [
+                  "v13.2.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -4298,7 +4394,8 @@
               "name": "`--tls-max-v1.2`",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -4324,7 +4421,8 @@
               "name": "`--tls-min-v1.0`",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -4337,7 +4435,8 @@
               "name": "`--tls-min-v1.1`",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -4350,7 +4449,8 @@
               "name": "`--tls-min-v1.2`",
               "meta": {
                 "added": [
-                  "v12.2.0"
+                  "v12.2.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -4371,6 +4471,19 @@
               "type": "module",
               "displayName": "`--tls-min-v1.3`"
             },
+            {
+              "textRaw": "`--trace-atomics-wait`",
+              "name": "`--trace-atomics-wait`",
+              "meta": {
+                "added": [
+                  "v14.3.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Print short summaries of calls to <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait\"><code>Atomics.wait()</code></a> to stderr.\nThe output could look like this:</p>\n<pre><code class=\"language-text\">(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 1, inf) started\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 1, inf) did not wait because the values mismatched\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 0, 10) started\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 0, 10) timed out\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 4, 0, inf) started\n(node:15701) [Thread 1] Atomics.wait(&#x26;lt;address> + 4, -1, inf) started\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 4, 0, inf) was woken up by another thread\n(node:15701) [Thread 1] Atomics.wait(&#x26;lt;address> + 4, -1, inf) was woken up by another thread\n</code></pre>\n<p>The fields here correspond to:</p>\n<ul>\n<li>The thread id as given by <a href=\"worker_threads.html#worker_threads_worker_threadid\"><code>worker_threads.threadId</code></a></li>\n<li>The base address of the <code>SharedArrayBuffer</code> in question, as well as the\nbyte offset corresponding to the index passed to <code>Atomics.wait()</code></li>\n<li>The expected value that was passed to <code>Atomics.wait()</code></li>\n<li>The timeout passed to <code>Atomics.wait</code></li>\n</ul>",
+              "type": "module",
+              "displayName": "`--trace-atomics-wait`"
+            },
             {
               "textRaw": "`--trace-deprecation`",
               "name": "`--trace-deprecation`",
@@ -4428,6 +4541,7 @@
               "name": "`--trace-exit`",
               "meta": {
                 "added": [
+                  "v13.5.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -4441,7 +4555,7 @@
               "name": "`--trace-sigint`",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.9.0"
                 ],
                 "changes": []
               },
@@ -4480,7 +4594,7 @@
               "name": "`--trace-uncaught`",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.1.0"
                 ],
                 "changes": []
               },
@@ -4519,11 +4633,12 @@
               "name": "`--unhandled-rejections=mode`",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>By default all unhandled rejections trigger a warning plus a deprecation warning\nfor the very first unhandled rejection in case no <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a> hook\nis used.</p>\n<p>Using this flag allows to change what should happen when an unhandled rejection\noccurs. One of three modes can be chosen:</p>\n<ul>\n<li><code>strict</code>: Raise the unhandled rejection as an uncaught exception.</li>\n<li><code>warn</code>: Always trigger a warning, no matter if the <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a>\nhook is set or not but do not print the deprecation warning.</li>\n<li><code>none</code>: Silence all warnings.</li>\n</ul>",
+              "desc": "<p>By default all unhandled rejections trigger a warning plus a deprecation warning\nfor the very first unhandled rejection in case no <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a> hook\nis used.</p>\n<p>Using this flag allows to change what should happen when an unhandled rejection\noccurs. One of the following modes can be chosen:</p>\n<ul>\n<li><code>throw</code>: Emit <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a>. If this hook is not set, raise the\nunhandled rejection as an uncaught exception.</li>\n<li><code>strict</code>: Raise the unhandled rejection as an uncaught exception.</li>\n<li><code>warn</code>: Always trigger a warning, no matter if the <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a>\nhook is set or not but do not print the deprecation warning.</li>\n<li><code>warn-with-error-code</code>: Emit <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a>. If this hook is not\nset, trigger a warning, and set the process exit code to 1.</li>\n<li><code>none</code>: Silence all warnings.</li>\n</ul>",
               "type": "module",
               "displayName": "`--unhandled-rejections=mode`"
             },
@@ -4545,7 +4660,7 @@
               "name": "`--use-largepages=mode`",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.6.0"
                 ],
                 "changes": []
               },
@@ -4562,7 +4677,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Print V8 command line options.</p>",
+              "desc": "<p>Print V8 command-line options.</p>",
               "type": "module",
               "displayName": "`--v8-options`"
             },
@@ -4640,7 +4755,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Print node command line options.\nThe output of this option is less detailed than this document.</p>",
+              "desc": "<p>Print node command-line options.\nThe output of this option is less detailed than this document.</p>",
               "type": "module",
               "displayName": "`-h`, `--help`"
             },
@@ -4685,7 +4800,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Preload the specified module at startup.</p>\n<p>Follows <code>require()</code>'s module resolution\nrules. <code>module</code> may be either a path to a file, or a node module name.</p>",
+              "desc": "<p>Preload the specified module at startup.</p>\n<p>Follows <code>require()</code>'s module resolution\nrules. <code>module</code> may be either a path to a file, or a node module name.</p>\n<p>Only CommonJS modules are supported. Attempting to preload a\nES6 Module using <code>--require</code> will fail with an error.</p>",
               "type": "module",
               "displayName": "`-r`, `--require module`"
             },
@@ -4710,6 +4825,13 @@
           "textRaw": "Environment variables",
           "name": "environment_variables",
           "modules": [
+            {
+              "textRaw": "`FORCE_COLOR=[1, 2, 3]`",
+              "name": "`force_color=[1,_2,_3]`",
+              "desc": "<p>The <code>FORCE_COLOR</code> environment variable is used to\nenable ANSI colorized output. The value may be:</p>\n<ul>\n<li><code>1</code>, <code>true</code>, or the empty string <code>''</code> indicate 16-color support,</li>\n<li><code>2</code> to indicate 256-color support, or</li>\n<li><code>3</code> to indicate 16 million-color support.</li>\n</ul>\n<p>When <code>FORCE_COLOR</code> is used and set to a supported value, both the <code>NO_COLOR</code>,\nand <code>NODE_DISABLE_COLORS</code> environment variables are ignored.</p>\n<p>Any other value will result in colorized output being disabled.</p>",
+              "type": "module",
+              "displayName": "`FORCE_COLOR=[1, 2, 3]`"
+            },
             {
               "textRaw": "`NODE_DEBUG=module[,…]`",
               "name": "`node_debug=module[,…]`",
@@ -4752,7 +4874,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>When set, the well known \"root\" CAs (like VeriSign) will be extended with the\nextra certificates in <code>file</code>. The file should consist of one or more trusted\ncertificates in PEM format. A message will be emitted (once) with\n<a href=\"process.html#process_process_emitwarning_warning_type_code_ctor\"><code>process.emitWarning()</code></a> if the file is missing or\nmalformed, but any errors are otherwise ignored.</p>\n<p>Neither the well known nor extra certificates are used when the <code>ca</code>\noptions property is explicitly specified for a TLS or HTTPS client or server.</p>\n<p>This environment variable is ignored when <code>node</code> runs as setuid root or\nhas Linux file capabilities set.</p>",
+              "desc": "<p>When set, the well known \"root\" CAs (like VeriSign) will be extended with the\nextra certificates in <code>file</code>. The file should consist of one or more trusted\ncertificates in PEM format. A message will be emitted (once) with\n<a href=\"process.html#process_process_emitwarning_warning_type_code_ctor\"><code>process.emitWarning()</code></a> if the file is missing or\nmalformed, but any errors are otherwise ignored.</p>\n<p>Neither the well known nor extra certificates are used when the <code>ca</code>\noptions property is explicitly specified for a TLS or HTTPS client or server.</p>\n<p>This environment variable is ignored when <code>node</code> runs as setuid root or\nhas Linux file capabilities set.</p>\n<p>The <code>NODE_EXTRA_CA_CERTS</code> environment variable is only read when the Node.js\nprocess is first launched. Changing the value at runtime using\n<code>process.env.NODE_EXTRA_CA_CERTS</code> has no effect on the current process.</p>",
               "type": "module",
               "displayName": "`NODE_EXTRA_CA_CERTS=file`"
             },
@@ -4791,7 +4913,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A space-separated list of command line options. <code>options...</code> are interpreted\nbefore command line options, so command line options will override or\ncompound after anything in <code>options...</code>. Node.js will exit with an error if\nan option that is not allowed in the environment is used, such as <code>-p</code> or a\nscript file.</p>\n<p>In case an option value happens to contain a space (for example a path listed\nin <code>--require</code>), it must be escaped using double quotes. For example:</p>\n<pre><code class=\"language-bash\">NODE_OPTIONS='--require \"./my path/file.js\"'\n</code></pre>\n<p>A singleton flag passed as a command line option will override the same flag\npassed into <code>NODE_OPTIONS</code>:</p>\n<pre><code class=\"language-bash\"># The inspector will be available on port 5555\nNODE_OPTIONS='--inspect=localhost:4444' node --inspect=localhost:5555\n</code></pre>\n<p>A flag that can be passed multiple times will be treated as if its\n<code>NODE_OPTIONS</code> instances were passed first, and then its command line\ninstances afterwards:</p>\n<pre><code class=\"language-bash\">NODE_OPTIONS='--require \"./a.js\"' node --require \"./b.js\"\n# is equivalent to:\nnode --require \"./a.js\" --require \"./b.js\"\n</code></pre>\n<p>Node.js options that are allowed are:</p>\n<!-- node-options-node start -->\n<ul>\n<li><code>--conditions</code></li>\n<li><code>--diagnostic-dir</code></li>\n<li><code>--disable-proto</code></li>\n<li><code>--enable-fips</code></li>\n<li><code>--enable-source-maps</code></li>\n<li><code>--experimental-import-meta-resolve</code></li>\n<li><code>--experimental-json-modules</code></li>\n<li><code>--experimental-loader</code></li>\n<li><code>--experimental-modules</code></li>\n<li><code>--experimental-policy</code></li>\n<li><code>--experimental-repl-await</code></li>\n<li><code>--experimental-specifier-resolution</code></li>\n<li><code>--experimental-vm-modules</code></li>\n<li><code>--experimental-wasi-unstable-preview1</code></li>\n<li><code>--experimental-wasm-modules</code></li>\n<li><code>--force-context-aware</code></li>\n<li><code>--force-fips</code></li>\n<li><code>--frozen-intrinsics</code></li>\n<li><code>--heapsnapshot-signal</code></li>\n<li><code>--http-parser</code></li>\n<li><code>--http-server-default-timeout</code></li>\n<li><code>--icu-data-dir</code></li>\n<li><code>--input-type</code></li>\n<li><code>--insecure-http-parser</code></li>\n<li><code>--inspect-brk</code></li>\n<li><code>--inspect-port</code>, <code>--debug-port</code></li>\n<li><code>--inspect-publish-uid</code></li>\n<li><code>--inspect</code></li>\n<li><code>--max-http-header-size</code></li>\n<li><code>--napi-modules</code></li>\n<li><code>--no-deprecation</code></li>\n<li><code>--no-force-async-hooks-checks</code></li>\n<li><code>--no-warnings</code></li>\n<li><code>--openssl-config</code></li>\n<li><code>--pending-deprecation</code></li>\n<li><code>--policy-integrity</code></li>\n<li><code>--preserve-symlinks-main</code></li>\n<li><code>--preserve-symlinks</code></li>\n<li><code>--prof-process</code></li>\n<li><code>--redirect-warnings</code></li>\n<li><code>--report-compact</code></li>\n<li><code>--report-dir</code>, <code>--report-directory</code></li>\n<li><code>--report-filename</code></li>\n<li><code>--report-on-fatalerror</code></li>\n<li><code>--report-on-signal</code></li>\n<li><code>--report-signal</code></li>\n<li><code>--report-uncaught-exception</code></li>\n<li><code>--require</code>, <code>-r</code></li>\n<li><code>--throw-deprecation</code></li>\n<li><code>--title</code></li>\n<li><code>--tls-cipher-list</code></li>\n<li><code>--tls-keylog</code></li>\n<li><code>--tls-max-v1.2</code></li>\n<li><code>--tls-max-v1.3</code></li>\n<li><code>--tls-min-v1.0</code></li>\n<li><code>--tls-min-v1.1</code></li>\n<li><code>--tls-min-v1.2</code></li>\n<li><code>--tls-min-v1.3</code></li>\n<li><code>--trace-deprecation</code></li>\n<li><code>--trace-event-categories</code></li>\n<li><code>--trace-event-file-pattern</code></li>\n<li><code>--trace-events-enabled</code></li>\n<li><code>--trace-exit</code></li>\n<li><code>--trace-sigint</code></li>\n<li><code>--trace-sync-io</code></li>\n<li><code>--trace-tls</code></li>\n<li><code>--trace-uncaught</code></li>\n<li><code>--trace-warnings</code></li>\n<li><code>--track-heap-objects</code></li>\n<li><code>--unhandled-rejections</code></li>\n<li><code>--use-bundled-ca</code></li>\n<li><code>--use-largepages</code></li>\n<li><code>--use-openssl-ca</code></li>\n<li><code>--v8-pool-size</code></li>\n<li><code>--zero-fill-buffers</code>\n<!-- node-options-node end -->\n</li>\n</ul>\n<p>V8 options that are allowed are:</p>\n<!-- node-options-v8 start -->\n<ul>\n<li><code>--abort-on-uncaught-exception</code></li>\n<li><code>--disallow-code-generation-from-strings</code></li>\n<li><code>--huge-max-old-generation-size</code></li>\n<li><code>--interpreted-frames-native-stack</code></li>\n<li><code>--jitless</code></li>\n<li><code>--max-old-space-size</code></li>\n<li><code>--perf-basic-prof-only-functions</code></li>\n<li><code>--perf-basic-prof</code></li>\n<li><code>--perf-prof-unwinding-info</code></li>\n<li><code>--perf-prof</code></li>\n<li><code>--stack-trace-limit</code>\n<!-- node-options-v8 end -->\n</li>\n</ul>\n<p><code>--perf-basic-prof-only-functions</code>, <code>--perf-basic-prof</code>,\n<code>--perf-prof-unwinding-info</code>, and <code>--perf-prof</code> are only available on Linux.</p>",
+              "desc": "<p>A space-separated list of command-line options. <code>options...</code> are interpreted\nbefore command-line options, so command-line options will override or\ncompound after anything in <code>options...</code>. Node.js will exit with an error if\nan option that is not allowed in the environment is used, such as <code>-p</code> or a\nscript file.</p>\n<p>If an option value contains a space, it can be escaped using double quotes:</p>\n<pre><code class=\"language-bash\">NODE_OPTIONS='--require \"./my path/file.js\"'\n</code></pre>\n<p>A singleton flag passed as a command-line option will override the same flag\npassed into <code>NODE_OPTIONS</code>:</p>\n<pre><code class=\"language-bash\"># The inspector will be available on port 5555\nNODE_OPTIONS='--inspect=localhost:4444' node --inspect=localhost:5555\n</code></pre>\n<p>A flag that can be passed multiple times will be treated as if its\n<code>NODE_OPTIONS</code> instances were passed first, and then its command-line\ninstances afterwards:</p>\n<pre><code class=\"language-bash\">NODE_OPTIONS='--require \"./a.js\"' node --require \"./b.js\"\n# is equivalent to:\nnode --require \"./a.js\" --require \"./b.js\"\n</code></pre>\n<p>Node.js options that are allowed are:</p>\n<!-- node-options-node start -->\n<ul>\n<li><code>--conditions</code>, <code>-C</code></li>\n<li><code>--diagnostic-dir</code></li>\n<li><code>--disable-proto</code></li>\n<li><code>--dns-result-order</code></li>\n<li><code>--enable-fips</code></li>\n<li><code>--enable-source-maps</code></li>\n<li><code>--experimental-abortcontroller</code></li>\n<li><code>--experimental-import-meta-resolve</code></li>\n<li><code>--experimental-json-modules</code></li>\n<li><code>--experimental-loader</code></li>\n<li><code>--experimental-modules</code></li>\n<li><code>--experimental-policy</code></li>\n<li><code>--experimental-repl-await</code></li>\n<li><code>--experimental-specifier-resolution</code></li>\n<li><code>--experimental-top-level-await</code></li>\n<li><code>--experimental-vm-modules</code></li>\n<li><code>--experimental-wasi-unstable-preview1</code></li>\n<li><code>--experimental-wasm-modules</code></li>\n<li><code>--force-context-aware</code></li>\n<li><code>--force-fips</code></li>\n<li><code>--frozen-intrinsics</code></li>\n<li><code>--heapsnapshot-near-heap-limit</code></li>\n<li><code>--heapsnapshot-signal</code></li>\n<li><code>--http-parser</code></li>\n<li><code>--icu-data-dir</code></li>\n<li><code>--input-type</code></li>\n<li><code>--insecure-http-parser</code></li>\n<li><code>--inspect-brk</code></li>\n<li><code>--inspect-port</code>, <code>--debug-port</code></li>\n<li><code>--inspect-publish-uid</code></li>\n<li><code>--inspect</code></li>\n<li><code>--max-http-header-size</code></li>\n<li><code>--napi-modules</code></li>\n<li><code>--no-deprecation</code></li>\n<li><code>--no-force-async-hooks-checks</code></li>\n<li><code>--no-warnings</code></li>\n<li><code>--node-memory-debug</code></li>\n<li><code>--openssl-config</code></li>\n<li><code>--pending-deprecation</code></li>\n<li><code>--policy-integrity</code></li>\n<li><code>--preserve-symlinks-main</code></li>\n<li><code>--preserve-symlinks</code></li>\n<li><code>--prof-process</code></li>\n<li><code>--redirect-warnings</code></li>\n<li><code>--report-compact</code></li>\n<li><code>--report-dir</code>, <code>--report-directory</code></li>\n<li><code>--report-filename</code></li>\n<li><code>--report-on-fatalerror</code></li>\n<li><code>--report-on-signal</code></li>\n<li><code>--report-signal</code></li>\n<li><code>--report-uncaught-exception</code></li>\n<li><code>--require</code>, <code>-r</code></li>\n<li><code>--throw-deprecation</code></li>\n<li><code>--title</code></li>\n<li><code>--tls-cipher-list</code></li>\n<li><code>--tls-keylog</code></li>\n<li><code>--tls-max-v1.2</code></li>\n<li><code>--tls-max-v1.3</code></li>\n<li><code>--tls-min-v1.0</code></li>\n<li><code>--tls-min-v1.1</code></li>\n<li><code>--tls-min-v1.2</code></li>\n<li><code>--tls-min-v1.3</code></li>\n<li><code>--trace-atomics-wait</code></li>\n<li><code>--trace-deprecation</code></li>\n<li><code>--trace-event-categories</code></li>\n<li><code>--trace-event-file-pattern</code></li>\n<li><code>--trace-events-enabled</code></li>\n<li><code>--trace-exit</code></li>\n<li><code>--trace-sigint</code></li>\n<li><code>--trace-sync-io</code></li>\n<li><code>--trace-tls</code></li>\n<li><code>--trace-uncaught</code></li>\n<li><code>--trace-warnings</code></li>\n<li><code>--track-heap-objects</code></li>\n<li><code>--unhandled-rejections</code></li>\n<li><code>--use-bundled-ca</code></li>\n<li><code>--use-largepages</code></li>\n<li><code>--use-openssl-ca</code></li>\n<li><code>--v8-pool-size</code></li>\n<li><code>--zero-fill-buffers</code></li>\n</ul>\n<!-- node-options-node end -->\n<p>V8 options that are allowed are:</p>\n<!-- node-options-v8 start -->\n<ul>\n<li><code>--abort-on-uncaught-exception</code></li>\n<li><code>--disallow-code-generation-from-strings</code></li>\n<li><code>--huge-max-old-generation-size</code></li>\n<li><code>--interpreted-frames-native-stack</code></li>\n<li><code>--jitless</code></li>\n<li><code>--max-old-space-size</code></li>\n<li><code>--perf-basic-prof-only-functions</code></li>\n<li><code>--perf-basic-prof</code></li>\n<li><code>--perf-prof-unwinding-info</code></li>\n<li><code>--perf-prof</code></li>\n<li><code>--stack-trace-limit</code></li>\n</ul>\n<!-- node-options-v8 end -->\n<p><code>--perf-basic-prof-only-functions</code>, <code>--perf-basic-prof</code>,\n<code>--perf-prof-unwinding-info</code>, and <code>--perf-prof</code> are only available on Linux.</p>",
               "type": "module",
               "displayName": "`NODE_OPTIONS=options...`"
             },
@@ -4817,7 +4939,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>When set to <code>1</code>, emit pending deprecation warnings.</p>\n<p>Pending deprecations are generally identical to a runtime deprecation with the\nnotable exception that they are turned <em>off</em> by default and will not be emitted\nunless either the <code>--pending-deprecation</code> command line flag, or the\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations\nare used to provide a kind of selective \"early warning\" mechanism that\ndevelopers may leverage to detect deprecated API usage.</p>",
+              "desc": "<p>When set to <code>1</code>, emit pending deprecation warnings.</p>\n<p>Pending deprecations are generally identical to a runtime deprecation with the\nnotable exception that they are turned <em>off</em> by default and will not be emitted\nunless either the <code>--pending-deprecation</code> command-line flag, or the\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations\nare used to provide a kind of selective \"early warning\" mechanism that\ndevelopers may leverage to detect deprecated API usage.</p>",
               "type": "module",
               "displayName": "`NODE_PENDING_DEPRECATION=1`"
             },
@@ -4872,6 +4994,7 @@
               "name": "`node_repl_external_module=file`",
               "meta": {
                 "added": [
+                  "v13.0.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -4880,6 +5003,19 @@
               "type": "module",
               "displayName": "`NODE_REPL_EXTERNAL_MODULE=file`"
             },
+            {
+              "textRaw": "`NODE_SKIP_PLATFORM_CHECK=value`",
+              "name": "`node_skip_platform_check=value`",
+              "meta": {
+                "added": [
+                  "v14.5.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>If <code>value</code> equals <code>'1'</code>, the check for a supported platform is skipped during\nNode.js startup. Node.js might not execute correctly. Any issues encountered\non unsupported platforms will not be fixed.</p>",
+              "type": "module",
+              "displayName": "`NODE_SKIP_PLATFORM_CHECK=value`"
+            },
             {
               "textRaw": "`NODE_TLS_REJECT_UNAUTHORIZED=value`",
               "name": "`node_tls_reject_unauthorized=value`",
@@ -4912,6 +5048,13 @@
               "type": "module",
               "displayName": "`NODE_V8_COVERAGE=dir`"
             },
+            {
+              "textRaw": "`NO_COLOR=<any>`",
+              "name": "`no_color=<any>`",
+              "desc": "<p><a href=\"https://no-color.org\"><code>NO_COLOR</code></a>  is an alias for <code>NODE_DISABLE_COLORS</code>. The value of the\nenvironment variable is arbitrary.</p>",
+              "type": "module",
+              "displayName": "`NO_COLOR=<any>`"
+            },
             {
               "textRaw": "`OPENSSL_CONF=file`",
               "name": "`openssl_conf=file`",
@@ -4921,7 +5064,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Load an OpenSSL configuration file on startup. Among other uses, this can be\nused to enable FIPS-compliant crypto if Node.js is built with <code>./configure --openssl-fips</code>.</p>\n<p>If the <a href=\"cli.html#cli_openssl_config_file\"><code>--openssl-config</code></a> command line option is used, the environment\nvariable is ignored.</p>",
+              "desc": "<p>Load an OpenSSL configuration file on startup. Among other uses, this can be\nused to enable FIPS-compliant crypto if Node.js is built with <code>./configure --openssl-fips</code>.</p>\n<p>If the <a href=\"cli.html#cli_openssl_config_file\"><code>--openssl-config</code></a> command-line option is used, the environment\nvariable is ignored.</p>",
               "type": "module",
               "displayName": "`OPENSSL_CONF=file`"
             },
@@ -4978,7 +5121,8 @@
           "type": "misc",
           "displayName": "Useful V8 options"
         }
-      ]
+      ],
+      "source": "doc/api/cli.md"
     },
     {
       "textRaw": "Debugger",
@@ -4987,7 +5131,7 @@
       "stability": 2,
       "stabilityText": "Stable",
       "type": "misc",
-      "desc": "<p>Node.js includes an out-of-process debugging utility accessible via a\n<a href=\"debugger.html#debugger_v8_inspector_integration_for_node_js\">V8 Inspector</a> and built-in debugging client. To use it, start Node.js\nwith the <code>inspect</code> argument followed by the path to the script to debug; a\nprompt will be displayed indicating successful launch of the debugger:</p>\n<pre><code class=\"language-console\">$ node inspect myscript.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C; Debugger attached.\nBreak on start in myscript.js:1\n> 1 (function (exports, require, module, __filename, __dirname) { global.x = 5;\n  2 setTimeout(() => {\n  3   console.log('world');\ndebug>\n</code></pre>\n<p>The Node.js debugger client is not a full-featured debugger, but simple step and\ninspection are possible.</p>\n<p>Inserting the statement <code>debugger;</code> into the source code of a script will\nenable a breakpoint at that position in the code:</p>\n<!-- eslint-disable no-debugger -->\n<pre><code class=\"language-js\">// myscript.js\nglobal.x = 5;\nsetTimeout(() => {\n  debugger;\n  console.log('world');\n}, 1000);\nconsole.log('hello');\n</code></pre>\n<p>Once the debugger is run, a breakpoint will occur at line 3:</p>\n<pre><code class=\"language-console\">$ node inspect myscript.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C; Debugger attached.\nBreak on start in myscript.js:1\n> 1 (function (exports, require, module, __filename, __dirname) { global.x = 5;\n  2 setTimeout(() => {\n  3   debugger;\ndebug> cont\n&#x3C; hello\nbreak in myscript.js:3\n  1 (function (exports, require, module, __filename, __dirname) { global.x = 5;\n  2 setTimeout(() => {\n> 3   debugger;\n  4   console.log('world');\n  5 }, 1000);\ndebug> next\nbreak in myscript.js:4\n  2 setTimeout(() => {\n  3   debugger;\n> 4   console.log('world');\n  5 }, 1000);\n  6 console.log('hello');\ndebug> repl\nPress Ctrl + C to leave debug repl\n> x\n5\n> 2 + 2\n4\ndebug> next\n&#x3C; world\nbreak in myscript.js:5\n  3   debugger;\n  4   console.log('world');\n> 5 }, 1000);\n  6 console.log('hello');\n  7\ndebug> .exit\n</code></pre>\n<p>The <code>repl</code> command allows code to be evaluated remotely. The <code>next</code> command\nsteps to the next line. Type <code>help</code> to see what other commands are available.</p>\n<p>Pressing <code>enter</code> without typing a command will repeat the previous debugger\ncommand.</p>",
+      "desc": "<p>Node.js includes a command-line debugging utility. To use it, start Node.js\nwith the <code>inspect</code> argument followed by the path to the script to debug.</p>\n<pre><code class=\"language-console\">$ node inspect myscript.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C;\n&#x3C; Debugger attached.\n&#x3C;\n ok\nBreak on start in myscript.js:2\n  1 // myscript.js\n> 2 global.x = 5;\n  3 setTimeout(() => {\n  4   debugger;\ndebug>\n</code></pre>\n<p>The Node.js debugger client is not a full-featured debugger, but simple step and\ninspection are possible.</p>\n<p>Inserting the statement <code>debugger;</code> into the source code of a script will\nenable a breakpoint at that position in the code:</p>\n<!-- eslint-disable no-debugger -->\n<pre><code class=\"language-js\">// myscript.js\nglobal.x = 5;\nsetTimeout(() => {\n  debugger;\n  console.log('world');\n}, 1000);\nconsole.log('hello');\n</code></pre>\n<p>Once the debugger is run, a breakpoint will occur at line 3:</p>\n<pre><code class=\"language-console\">$ node inspect myscript.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C;\n&#x3C; Debugger attached.\n&#x3C;\n ok\nBreak on start in myscript.js:2\n  1 // myscript.js\n> 2 global.x = 5;\n  3 setTimeout(() => {\n  4   debugger;\ndebug> cont\n&#x3C; hello\n&#x3C;\nbreak in myscript.js:4\n  2 global.x = 5;\n  3 setTimeout(() => {\n> 4   debugger;\n  5   console.log('world');\n  6 }, 1000);\ndebug> next\nbreak in myscript.js:5\n  3 setTimeout(() => {\n  4   debugger;\n> 5   console.log('world');\n  6 }, 1000);\n  7 console.log('hello');\ndebug> repl\nPress Ctrl+C to leave debug repl\n> x\n5\n> 2 + 2\n4\ndebug> next\n&#x3C; world\n&#x3C;\nbreak in myscript.js:6\n  4   debugger;\n  5   console.log('world');\n> 6 }, 1000);\n  7 console.log('hello');\n  8\ndebug> .exit\n$\n</code></pre>\n<p>The <code>repl</code> command allows code to be evaluated remotely. The <code>next</code> command\nsteps to the next line. Type <code>help</code> to see what other commands are available.</p>\n<p>Pressing <code>enter</code> without typing a command will repeat the previous debugger\ncommand.</p>",
       "miscs": [
         {
           "textRaw": "Watchers",
@@ -5010,7 +5154,7 @@
             {
               "textRaw": "Breakpoints",
               "name": "breakpoints",
-              "desc": "<ul>\n<li><code>setBreakpoint()</code>, <code>sb()</code>: Set breakpoint on current line</li>\n<li><code>setBreakpoint(line)</code>, <code>sb(line)</code>: Set breakpoint on specific line</li>\n<li><code>setBreakpoint('fn()')</code>, <code>sb(...)</code>: Set breakpoint on a first statement in\nfunctions body</li>\n<li><code>setBreakpoint('script.js', 1)</code>, <code>sb(...)</code>: Set breakpoint on first line of\n<code>script.js</code></li>\n<li><code>clearBreakpoint('script.js', 1)</code>, <code>cb(...)</code>: Clear breakpoint in <code>script.js</code>\non line 1</li>\n</ul>\n<p>It is also possible to set a breakpoint in a file (module) that\nis not loaded yet:</p>\n<pre><code class=\"language-console\">$ node inspect main.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/4e3db158-9791-4274-8909-914f7facf3bd\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C; Debugger attached.\nBreak on start in main.js:1\n> 1 (function (exports, require, module, __filename, __dirname) { const mod = require('./mod.js');\n  2 mod.hello();\n  3 mod.hello();\ndebug> setBreakpoint('mod.js', 22)\nWarning: script 'mod.js' was not loaded yet.\ndebug> c\nbreak in mod.js:22\n 20 // USE OR OTHER DEALINGS IN THE SOFTWARE.\n 21\n>22 exports.hello = function() {\n 23   return 'hello from module';\n 24 };\ndebug>\n</code></pre>",
+              "desc": "<ul>\n<li><code>setBreakpoint()</code>, <code>sb()</code>: Set breakpoint on current line</li>\n<li><code>setBreakpoint(line)</code>, <code>sb(line)</code>: Set breakpoint on specific line</li>\n<li><code>setBreakpoint('fn()')</code>, <code>sb(...)</code>: Set breakpoint on a first statement in\nfunction's body</li>\n<li><code>setBreakpoint('script.js', 1)</code>, <code>sb(...)</code>: Set breakpoint on first line of\n<code>script.js</code></li>\n<li><code>setBreakpoint('script.js', 1, 'num &#x3C; 4')</code>, <code>sb(...)</code>: Set conditional\nbreakpoint on first line of <code>script.js</code> that only breaks when <code>num &#x3C; 4</code>\nevaluates to <code>true</code></li>\n<li><code>clearBreakpoint('script.js', 1)</code>, <code>cb(...)</code>: Clear breakpoint in <code>script.js</code>\non line 1</li>\n</ul>\n<p>It is also possible to set a breakpoint in a file (module) that\nis not loaded yet:</p>\n<pre><code class=\"language-console\">$ node inspect main.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/48a5b28a-550c-471b-b5e1-d13dd7165df9\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C;\n&#x3C; Debugger attached.\n&#x3C;\n ok\nBreak on start in main.js:1\n> 1 const mod = require('./mod.js');\n  2 mod.hello();\n  3 mod.hello();\ndebug> setBreakpoint('mod.js', 22)\nWarning: script 'mod.js' was not loaded yet.\ndebug> c\nbreak in mod.js:22\n 20 // USE OR OTHER DEALINGS IN THE SOFTWARE.\n 21\n>22 exports.hello = function() {\n 23   return 'hello from module';\n 24 };\ndebug>\n</code></pre>\n<p>It is also possible to set a conditional breakpoint that only breaks when a\ngiven expression evaluates to <code>true</code>:</p>\n<pre><code class=\"language-console\">$ node inspect main.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/ce24daa8-3816-44d4-b8ab-8273c8a66d35\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C; Debugger attached.\nBreak on start in main.js:7\n  5 }\n  6\n> 7 addOne(10);\n  8 addOne(-1);\n  9\ndebug> setBreakpoint('main.js', 4, 'num &#x3C; 0')\n  1 'use strict';\n  2\n  3 function addOne(num) {\n> 4   return num + 1;\n  5 }\n  6\n  7 addOne(10);\n  8 addOne(-1);\n  9\ndebug> cont\nbreak in main.js:4\n  2\n  3 function addOne(num) {\n> 4   return num + 1;\n  5 }\n  6\ndebug> exec('num')\n-1\ndebug>\n</code></pre>",
               "type": "module",
               "displayName": "Breakpoints"
             },
@@ -5054,36 +5198,41 @@
           "type": "misc",
           "displayName": "Advanced usage"
         }
-      ]
+      ],
+      "source": "doc/api/debugger.md"
     },
     {
       "textRaw": "Deprecated APIs",
       "name": "Deprecated APIs",
       "introduced_in": "v7.7.0",
       "type": "misc",
-      "desc": "<p>Node.js may deprecate APIs for any of the following reasons:</p>\n<ul>\n<li>Use of the API is unsafe.</li>\n<li>An improved alternative API is available.</li>\n<li>Breaking changes to the API are expected in a future major release.</li>\n</ul>\n<p>Node.js utilizes three kinds of Deprecations:</p>\n<ul>\n<li>Documentation-only</li>\n<li>Runtime</li>\n<li>End-of-Life</li>\n</ul>\n<p>A Documentation-only deprecation is one that is expressed only within the\nNode.js API docs. These generate no side-effects while running Node.js.\nSome Documentation-only deprecations trigger a runtime warning when launched\nwith <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a> flag (or its alternative,\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable), similarly to Runtime\ndeprecations below. Documentation-only deprecations that support that flag\nare explicitly labeled as such in the\n<a href=\"deprecations.html#deprecations_list_of_deprecated_apis\">list of Deprecated APIs</a>.</p>\n<p>A Runtime deprecation will, by default, generate a process warning that will\nbe printed to <code>stderr</code> the first time the deprecated API is used. When the\n<a href=\"cli.html#cli_throw_deprecation\"><code>--throw-deprecation</code></a> command-line flag is used, a Runtime deprecation will\ncause an error to be thrown.</p>\n<p>An End-of-Life deprecation is used when functionality is or will soon be removed\nfrom Node.js.</p>",
+      "desc": "<p>Node.js APIs might be deprecated for any of the following reasons:</p>\n<ul>\n<li>Use of the API is unsafe.</li>\n<li>An improved alternative API is available.</li>\n<li>Breaking changes to the API are expected in a future major release.</li>\n</ul>\n<p>Node.js uses three kinds of Deprecations:</p>\n<ul>\n<li>Documentation-only</li>\n<li>Runtime</li>\n<li>End-of-Life</li>\n</ul>\n<p>A Documentation-only deprecation is one that is expressed only within the\nNode.js API docs. These generate no side-effects while running Node.js.\nSome Documentation-only deprecations trigger a runtime warning when launched\nwith <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a> flag (or its alternative,\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable), similarly to Runtime\ndeprecations below. Documentation-only deprecations that support that flag\nare explicitly labeled as such in the\n<a href=\"deprecations.html#deprecations_list_of_deprecated_apis\">list of Deprecated APIs</a>.</p>\n<p>A Runtime deprecation will, by default, generate a process warning that will\nbe printed to <code>stderr</code> the first time the deprecated API is used. When the\n<a href=\"cli.html#cli_throw_deprecation\"><code>--throw-deprecation</code></a> command-line flag is used, a Runtime deprecation will\ncause an error to be thrown.</p>\n<p>An End-of-Life deprecation is used when functionality is or will soon be removed\nfrom Node.js.</p>",
       "miscs": [
         {
           "textRaw": "Revoking deprecations",
           "name": "revoking_deprecations",
-          "desc": "<p>Occasionally, the deprecation of an API may be reversed. In such situations,\nthis document will be updated with information relevant to the decision.\nHowever, the deprecation identifier will not be modified.</p>",
+          "desc": "<p>Occasionally, the deprecation of an API might be reversed. In such situations,\nthis document will be updated with information relevant to the decision.\nHowever, the deprecation identifier will not be modified.</p>",
           "type": "misc",
           "displayName": "Revoking deprecations"
         },
         {
           "textRaw": "List of deprecated APIs",
           "name": "list_of_deprecated_apis",
-          "desc": "<p><a id=\"DEP0001\"></a></p>",
           "modules": [
             {
               "textRaw": "DEP0001: `http.OutgoingMessage.prototype.flush`",
               "name": "dep0001:_`http.outgoingmessage.prototype.flush`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31164",
+                    "description": "End-of-Life."
+                  },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5095,7 +5244,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>OutgoingMessage.prototype.flush()</code> method is deprecated. Use\n<code>OutgoingMessage.prototype.flushHeaders()</code> instead.</p>\n<p><a id=\"DEP0002\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>OutgoingMessage.prototype.flush()</code> has been removed. Use\n<code>OutgoingMessage.prototype.flushHeaders()</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0001: `http.OutgoingMessage.prototype.flush`"
             },
@@ -5121,7 +5270,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>_linklist</code> module is deprecated. Please use a userland alternative.</p>\n<p><a id=\"DEP0003\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>_linklist</code> module is deprecated. Please use a userland alternative.</p>",
               "type": "module",
               "displayName": "DEP0002: `require('_linklist')`"
             },
@@ -5130,10 +5279,15 @@
               "name": "dep0003:_`_writablestate.buffer`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31165",
+                    "description": "End-of-Life."
+                  },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5145,7 +5299,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>_writableState.buffer</code> property is deprecated. Use the\n<code>_writableState.getBuffer()</code> method instead.</p>\n<p><a id=\"DEP0004\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>_writableState.buffer</code> has been removed. Use <code>_writableState.getBuffer()</code>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0003: `_writableState.buffer`"
             },
@@ -5161,20 +5315,20 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
-                    "version": "0.4.0",
+                    "version": "v0.4.0",
                     "commit": "9c7f89bf56abd37a796fea621ad2e47dd33d2b82",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>CryptoStream.prototype.readyState</code> property was removed.</p>\n<p><a id=\"DEP0005\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>CryptoStream.prototype.readyState</code> property was removed.</p>",
               "type": "module",
               "displayName": "DEP0004: `CryptoStream.prototype.readyState`"
             },
@@ -5200,7 +5354,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>Buffer()</code> function and <code>new Buffer()</code> constructor are deprecated due to\nAPI usability issues that can lead to accidental security issues.</p>\n<p>As an alternative, use one of the following methods of constructing <code>Buffer</code>\nobjects:</p>\n<ul>\n<li><a href=\"buffer.html#buffer_static_method_buffer_alloc_size_fill_encoding\"><code>Buffer.alloc(size[, fill[, encoding]])</code></a>: Create a <code>Buffer</code> with\n<em>initialized</em> memory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe(size)</code></a>: Create a <code>Buffer</code> with\n<em>uninitialized</em> memory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a>: Create a <code>Buffer</code> with <em>uninitialized</em>\nmemory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a>: Create a <code>Buffer</code> with a copy of <code>array</code></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a> -\nCreate a <code>Buffer</code> that wraps the given <code>arrayBuffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a>: Create a <code>Buffer</code> that copies <code>buffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a>: Create a <code>Buffer</code>\nthat copies <code>string</code>.</li>\n</ul>\n<p>Without <code>--pending-deprecation</code>, runtime warnings occur only for code not in\n<code>node_modules</code>. This means there will not be deprecation warnings for\n<code>Buffer()</code> usage in dependencies. With <code>--pending-deprecation</code>, a runtime\nwarning results no matter where the <code>Buffer()</code> usage occurs.</p>\n<p><a id=\"DEP0006\"></a></p>",
+              "desc": "<p>Type: Runtime (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>Buffer()</code> function and <code>new Buffer()</code> constructor are deprecated due to\nAPI usability issues that can lead to accidental security issues.</p>\n<p>As an alternative, use one of the following methods of constructing <code>Buffer</code>\nobjects:</p>\n<ul>\n<li><a href=\"buffer.html#buffer_static_method_buffer_alloc_size_fill_encoding\"><code>Buffer.alloc(size[, fill[, encoding]])</code></a>: Create a <code>Buffer</code> with\n<em>initialized</em> memory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe(size)</code></a>: Create a <code>Buffer</code> with\n<em>uninitialized</em> memory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a>: Create a <code>Buffer</code> with <em>uninitialized</em>\nmemory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a>: Create a <code>Buffer</code> with a copy of <code>array</code></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a> -\nCreate a <code>Buffer</code> that wraps the given <code>arrayBuffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a>: Create a <code>Buffer</code> that copies <code>buffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a>: Create a <code>Buffer</code>\nthat copies <code>string</code>.</li>\n</ul>\n<p>Without <code>--pending-deprecation</code>, runtime warnings occur only for code not in\n<code>node_modules</code>. This means there will not be deprecation warnings for\n<code>Buffer()</code> usage in dependencies. With <code>--pending-deprecation</code>, a runtime\nwarning results no matter where the <code>Buffer()</code> usage occurs.</p>",
               "type": "module",
               "displayName": "DEP0005: `Buffer()` constructor"
             },
@@ -5216,8 +5370,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5227,12 +5381,12 @@
                     "description": "Runtime deprecation."
                   },
                   {
-                    "version": "v0.5.11",
+                    "version": "v0.5.10",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Within the <a href=\"child_process.html\"><code>child_process</code></a> module's <code>spawn()</code>, <code>fork()</code>, and <code>exec()</code>\nmethods, the <code>options.customFds</code> option is deprecated. The <code>options.stdio</code>\noption should be used instead.</p>\n<p><a id=\"DEP0007\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Within the <a href=\"child_process.html\"><code>child_process</code></a> module's <code>spawn()</code>, <code>fork()</code>, and <code>exec()</code>\nmethods, the <code>options.customFds</code> option is deprecated. The <code>options.stdio</code>\noption should be used instead.</p>",
               "type": "module",
               "displayName": "DEP0006: `child_process` `options.customFds`"
             },
@@ -5263,7 +5417,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>In an earlier version of the Node.js <code>cluster</code>, a boolean property with the name\n<code>suicide</code> was added to the <code>Worker</code> object. The intent of this property was to\nprovide an indication of how and why the <code>Worker</code> instance exited. In Node.js\n6.0.0, the old property was deprecated and replaced with a new\n<a href=\"cluster.html#cluster_worker_exitedafterdisconnect\"><code>worker.exitedAfterDisconnect</code></a> property. The old property name did not\nprecisely describe the actual semantics and was unnecessarily emotion-laden.</p>\n<p><a id=\"DEP0008\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>In an earlier version of the Node.js <code>cluster</code>, a boolean property with the name\n<code>suicide</code> was added to the <code>Worker</code> object. The intent of this property was to\nprovide an indication of how and why the <code>Worker</code> instance exited. In Node.js\n6.0.0, the old property was deprecated and replaced with a new\n<a href=\"cluster.html#cluster_worker_exitedafterdisconnect\"><code>worker.exitedAfterDisconnect</code></a> property. The old property name did not\nprecisely describe the actual semantics and was unnecessarily emotion-laden.</p>",
               "type": "module",
               "displayName": "DEP0007: Replace `cluster` `worker.suicide` with `worker.exitedAfterDisconnect`"
             },
@@ -5284,7 +5438,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>constants</code> module is deprecated. When requiring access to constants\nrelevant to specific Node.js builtin modules, developers should instead refer\nto the <code>constants</code> property exposed by the relevant module. For instance,\n<code>require('fs').constants</code> and <code>require('os').constants</code>.</p>\n<p><a id=\"DEP0009\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>constants</code> module is deprecated. When requiring access to constants\nrelevant to specific Node.js builtin modules, developers should instead refer\nto the <code>constants</code> property exposed by the relevant module. For instance,\n<code>require('fs').constants</code> and <code>require('os').constants</code>.</p>",
               "type": "module",
               "displayName": "DEP0008: `require('constants')`"
             },
@@ -5293,6 +5447,11 @@
               "name": "dep0009:_`crypto.pbkdf2`_without_digest",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31166",
+                    "description": "End-of-Life (for `digest === null`)."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22861",
@@ -5315,7 +5474,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Use of the <a href=\"crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback\"><code>crypto.pbkdf2()</code></a> API without specifying a digest was deprecated\nin Node.js 6.0 because the method defaulted to using the non-recommended\n<code>'SHA1'</code> digest. Previously, a deprecation warning was printed. Starting in\nNode.js 8.0.0, calling <code>crypto.pbkdf2()</code> or <code>crypto.pbkdf2Sync()</code> with\n<code>digest</code> set to <code>undefined</code> will throw a <code>TypeError</code>.</p>\n<p>Beginning in Node.js v11.0.0, calling these functions with <code>digest</code> set to\n<code>null</code> will print a deprecation warning to align with the behavior when <code>digest</code>\nis <code>undefined</code>.</p>\n<p><a id=\"DEP0010\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Use of the <a href=\"crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback\"><code>crypto.pbkdf2()</code></a> API without specifying a digest was deprecated\nin Node.js 6.0 because the method defaulted to using the non-recommended\n<code>'SHA1'</code> digest. Previously, a deprecation warning was printed. Starting in\nNode.js 8.0.0, calling <code>crypto.pbkdf2()</code> or <code>crypto.pbkdf2Sync()</code> with\n<code>digest</code> set to <code>undefined</code> will throw a <code>TypeError</code>.</p>\n<p>Beginning in Node.js v11.0.0, calling these functions with <code>digest</code> set to\n<code>null</code> would print a deprecation warning to align with the behavior when <code>digest</code>\nis <code>undefined</code>.</p>\n<p>Now, however, passing either <code>undefined</code> or <code>null</code> will throw a <code>TypeError</code>.</p>",
               "type": "module",
               "displayName": "DEP0009: `crypto.pbkdf2` without digest"
             },
@@ -5331,8 +5490,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5344,7 +5503,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto.createCredentials()</code> API was removed. Please use\n<a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.createSecureContext()</code></a> instead.</p>\n<p><a id=\"DEP0011\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto.createCredentials()</code> API was removed. Please use\n<a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.createSecureContext()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0010: `crypto.createCredentials`"
             },
@@ -5360,8 +5519,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5373,7 +5532,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto.Credentials</code> class was removed. Please use <a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.SecureContext</code></a>\ninstead.</p>\n<p><a id=\"DEP0012\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto.Credentials</code> class was removed. Please use <a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.SecureContext</code></a>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0011: `crypto.Credentials`"
             },
@@ -5389,8 +5548,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5402,7 +5561,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>Domain.dispose()</code> has been removed. Recover from failed I/O actions\nexplicitly via error event handlers set on the domain instead.</p>\n<p><a id=\"DEP0013\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>Domain.dispose()</code> has been removed. Recover from failed I/O actions\nexplicitly via error event handlers set on the domain instead.</p>",
               "type": "module",
               "displayName": "DEP0012: `Domain.dispose`"
             },
@@ -5423,7 +5582,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Calling an asynchronous function without a callback throws a <code>TypeError</code>\nin Node.js 10.0.0 onwards. See <a href=\"https://github.com/nodejs/node/pull/12562\">https://github.com/nodejs/node/pull/12562</a>.</p>\n<p><a id=\"DEP0014\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Calling an asynchronous function without a callback throws a <code>TypeError</code>\nin Node.js 10.0.0 onwards. See <a href=\"https://github.com/nodejs/node/pull/12562\">https://github.com/nodejs/node/pull/12562</a>.</p>",
               "type": "module",
               "displayName": "DEP0013: `fs` asynchronous function without callback"
             },
@@ -5437,19 +5596,19 @@
                     "pr-url": "https://github.com/nodejs/node/pull/9683",
                     "description": "End-of-Life."
                   },
-                  {
-                    "version": "v6.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/4525",
-                    "description": "Runtime deprecation."
-                  },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4525",
+                    "description": "Runtime deprecation."
+                  },
                   {
                     "version": "v0.1.96",
                     "commit": "c93e0aaf062081db3ec40ac45b3e2c979d5759d6",
@@ -5457,7 +5616,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a> legacy <code>String</code> interface is deprecated. Use the <code>Buffer</code>\nAPI as mentioned in the documentation instead.</p>\n<p><a id=\"DEP0015\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a> legacy <code>String</code> interface is deprecated. Use the <code>Buffer</code>\nAPI as mentioned in the documentation instead.</p>",
               "type": "module",
               "displayName": "DEP0014: `fs.read` legacy String interface"
             },
@@ -5471,19 +5630,19 @@
                     "pr-url": "https://github.com/nodejs/node/pull/9683",
                     "description": "End-of-Life."
                   },
-                  {
-                    "version": "v6.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/4525",
-                    "description": "Runtime deprecation."
-                  },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4525",
+                    "description": "Runtime deprecation."
+                  },
                   {
                     "version": "v0.1.96",
                     "commit": "c93e0aaf062081db3ec40ac45b3e2c979d5759d6",
@@ -5491,7 +5650,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"fs.html#fs_fs_readsync_fd_buffer_offset_length_position\"><code>fs.readSync()</code></a> legacy <code>String</code> interface is deprecated. Use the\n<code>Buffer</code> API as mentioned in the documentation instead.</p>\n<p><a id=\"DEP0016\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"fs.html#fs_fs_readsync_fd_buffer_offset_length_position\"><code>fs.readSync()</code></a> legacy <code>String</code> interface is deprecated. Use the\n<code>Buffer</code> API as mentioned in the documentation instead.</p>",
               "type": "module",
               "displayName": "DEP0015: `fs.readSync` legacy String interface"
             },
@@ -5500,6 +5659,11 @@
               "name": "dep0016:_`global`/`root`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31167",
+                    "description": "End-of-Life."
+                  },
                   {
                     "version": "v6.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
@@ -5512,7 +5676,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>GLOBAL</code> and <code>root</code> aliases for the <code>global</code> property are deprecated\nand should no longer be used.</p>\n<p><a id=\"DEP0017\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>GLOBAL</code> and <code>root</code> aliases for the <code>global</code> property were deprecated\nin Node.js 6.0.0 and have since been removed.</p>",
               "type": "module",
               "displayName": "DEP0016: `GLOBAL`/`root`"
             },
@@ -5533,7 +5697,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>Intl.v8BreakIterator</code> was a non-standard extension and has been removed.\nSee <a href=\"https://github.com/tc39/proposal-intl-segmenter\"><code>Intl.Segmenter</code></a>.</p>\n<p><a id=\"DEP0018\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>Intl.v8BreakIterator</code> was a non-standard extension and has been removed.\nSee <a href=\"https://github.com/tc39/proposal-intl-segmenter\"><code>Intl.Segmenter</code></a>.</p>",
               "type": "module",
               "displayName": "DEP0017: `Intl.v8BreakIterator`"
             },
@@ -5549,7 +5713,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Unhandled promise rejections are deprecated. In the future, promise rejections\nthat are not handled will terminate the Node.js process with a non-zero exit\ncode.</p>\n<p><a id=\"DEP0019\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Unhandled promise rejections are deprecated. In the future, promise rejections\nthat are not handled will terminate the Node.js process with a non-zero exit\ncode.</p>",
               "type": "module",
               "displayName": "DEP0018: Unhandled promise rejections"
             },
@@ -5565,8 +5729,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5578,7 +5742,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>In certain cases, <code>require('.')</code> could resolve outside the package directory.\nThis behavior has been removed.</p>\n<p><a id=\"DEP0020\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>In certain cases, <code>require('.')</code> could resolve outside the package directory.\nThis behavior has been removed.</p>",
               "type": "module",
               "displayName": "DEP0019: `require('.')` resolved outside directory"
             },
@@ -5589,8 +5753,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5602,7 +5766,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <a href=\"net.html#net_server_connections\"><code>Server.connections</code></a> property is deprecated. Please use the\n<a href=\"net.html#net_server_getconnections_callback\"><code>Server.getConnections()</code></a> method instead.</p>\n<p><a id=\"DEP0021\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <a href=\"net.html#net_server_connections\"><code>Server.connections</code></a> property is deprecated. Please use the\n<a href=\"net.html#net_server_getconnections_callback\"><code>Server.getConnections()</code></a> method instead.</p>",
               "type": "module",
               "displayName": "DEP0020: `Server.connections`"
             },
@@ -5618,8 +5782,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5631,7 +5795,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>Server.listenFD()</code> method was deprecated and removed. Please use\n<a href=\"net.html#net_server_listen_handle_backlog_callback\"><code>Server.listen({fd: &#x3C;number>})</code></a> instead.</p>\n<p><a id=\"DEP0022\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>Server.listenFD()</code> method was deprecated and removed. Please use\n<a href=\"net.html#net_server_listen_handle_backlog_callback\"><code>Server.listen({fd: &#x3C;number>})</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0021: `Server.listenFD`"
             },
@@ -5640,6 +5804,11 @@
               "name": "dep0022:_`os.tmpdir()`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31169",
+                    "description": "End-of-Life."
+                  },
                   {
                     "version": "v7.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/6739",
@@ -5647,7 +5816,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>os.tmpDir()</code> API is deprecated. Please use <a href=\"os.html#os_os_tmpdir\"><code>os.tmpdir()</code></a> instead.</p>\n<p><a id=\"DEP0023\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>os.tmpDir()</code> API was deprecated in Node.js 7.0.0 and has since been\nremoved. Please use <a href=\"os.html#os_os_tmpdir\"><code>os.tmpdir()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0022: `os.tmpDir()`"
             },
@@ -5663,8 +5832,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5676,7 +5845,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>os.getNetworkInterfaces()</code> method is deprecated. Please use the\n<a href=\"os.html#os_os_networkinterfaces\"><code>os.networkInterfaces()</code></a> method instead.</p>\n<p><a id=\"DEP0024\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>os.getNetworkInterfaces()</code> method is deprecated. Please use the\n<a href=\"os.html#os_os_networkinterfaces\"><code>os.networkInterfaces()</code></a> method instead.</p>",
               "type": "module",
               "displayName": "DEP0023: `os.getNetworkInterfaces()`"
             },
@@ -5697,7 +5866,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>REPLServer.prototype.convertToContext()</code> API has been removed.</p>\n<p><a id=\"DEP0025\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>REPLServer.prototype.convertToContext()</code> API has been removed.</p>",
               "type": "module",
               "displayName": "DEP0024: `REPLServer.prototype.convertToContext()`"
             },
@@ -5708,8 +5877,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5721,7 +5890,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>sys</code> module is deprecated. Please use the <a href=\"util.html\"><code>util</code></a> module instead.</p>\n<p><a id=\"DEP0026\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>sys</code> module is deprecated. Please use the <a href=\"util.html\"><code>util</code></a> module instead.</p>",
               "type": "module",
               "displayName": "DEP0025: `require('sys')`"
             },
@@ -5737,8 +5906,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5750,7 +5919,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.print()</code> has been removed. Please use <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> instead.</p>\n<p><a id=\"DEP0027\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.print()</code> has been removed. Please use <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0026: `util.print()`"
             },
@@ -5766,8 +5935,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5779,7 +5948,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.puts()</code> has been removed. Please use <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> instead.</p>\n<p><a id=\"DEP0028\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.puts()</code> has been removed. Please use <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0027: `util.puts()`"
             },
@@ -5795,8 +5964,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5808,7 +5977,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.debug()</code> has been removed. Please use <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a> instead.</p>\n<p><a id=\"DEP0029\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.debug()</code> has been removed. Please use <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0028: `util.debug()`"
             },
@@ -5824,8 +5993,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5837,7 +6006,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.error()</code> has been removed. Please use <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a> instead.</p>\n<p><a id=\"DEP0030\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.error()</code> has been removed. Please use <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0029: `util.error()`"
             },
@@ -5858,7 +6027,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"buffer.html#buffer_class_slowbuffer\"><code>SlowBuffer</code></a> class is deprecated. Please use\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a> instead.</p>\n<p><a id=\"DEP0031\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"buffer.html#buffer_class_slowbuffer\"><code>SlowBuffer</code></a> class is deprecated. Please use\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0030: `SlowBuffer`"
             },
@@ -5879,7 +6048,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_ecdh_setpublickey_publickey_encoding\"><code>ecdh.setPublicKey()</code></a> method is now deprecated as its inclusion in the\nAPI is not useful.</p>\n<p><a id=\"DEP0032\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_ecdh_setpublickey_publickey_encoding\"><code>ecdh.setPublicKey()</code></a> method is now deprecated as its inclusion in the\nAPI is not useful.</p>",
               "type": "module",
               "displayName": "DEP0031: `ecdh.setPublicKey()`"
             },
@@ -5890,8 +6059,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5903,7 +6072,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"domain.html\"><code>domain</code></a> module is deprecated and should not be used.</p>\n<p><a id=\"DEP0033\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"domain.html\"><code>domain</code></a> module is deprecated and should not be used.</p>",
               "type": "module",
               "displayName": "DEP0032: `domain` module"
             },
@@ -5914,8 +6083,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5927,7 +6096,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"events.html#events_eventemitter_listenercount_emitter_eventname\"><code>EventEmitter.listenerCount(emitter, eventName)</code></a> API is\ndeprecated. Please use <a href=\"events.html#events_emitter_listenercount_eventname\"><code>emitter.listenerCount(eventName)</code></a> instead.</p>\n<p><a id=\"DEP0034\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"events.html#events_events_listenercount_emitter_eventname\"><code>events.listenerCount(emitter, eventName)</code></a> API is\ndeprecated. Please use <a href=\"events.html#events_emitter_listenercount_eventname\"><code>emitter.listenerCount(eventName)</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0033: `EventEmitter.listenerCount()`"
             },
@@ -5938,20 +6107,20 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": "v1.0.0",
-                    "pr-url": "https://github.com/iojs/io.js/pull/166",
+                    "pr-url": "https://github.com/nodejs/node/pull/166",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_exists_path_callback\"><code>fs.exists(path, callback)</code></a> API is deprecated. Please use\n<a href=\"fs.html#fs_fs_stat_path_options_callback\"><code>fs.stat()</code></a> or <a href=\"fs.html#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a> instead.</p>\n<p><a id=\"DEP0035\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_exists_path_callback\"><code>fs.exists(path, callback)</code></a> API is deprecated. Please use\n<a href=\"fs.html#fs_fs_stat_path_options_callback\"><code>fs.stat()</code></a> or <a href=\"fs.html#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0034: `fs.exists(path, callback)`"
             },
@@ -5962,8 +6131,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5974,7 +6143,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_lchmod_path_mode_callback\"><code>fs.lchmod(path, mode, callback)</code></a> API is deprecated.</p>\n<p><a id=\"DEP0036\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_lchmod_path_mode_callback\"><code>fs.lchmod(path, mode, callback)</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0035: `fs.lchmod(path, mode, callback)`"
             },
@@ -5985,8 +6154,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -5997,7 +6166,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_lchmodsync_path_mode\"><code>fs.lchmodSync(path, mode)</code></a> API is deprecated.</p>\n<p><a id=\"DEP0037\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_lchmodsync_path_mode\"><code>fs.lchmodSync(path, mode)</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0036: `fs.lchmodSync(path, mode)`"
             },
@@ -6013,8 +6182,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -6025,7 +6194,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"fs.html#fs_fs_lchown_path_uid_gid_callback\"><code>fs.lchown(path, uid, gid, callback)</code></a> API was deprecated. The\ndeprecation was revoked because the requisite supporting APIs were added in\nlibuv.</p>\n<p><a id=\"DEP0038\"></a></p>",
+              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"fs.html#fs_fs_lchown_path_uid_gid_callback\"><code>fs.lchown(path, uid, gid, callback)</code></a> API was deprecated. The\ndeprecation was revoked because the requisite supporting APIs were added in\nlibuv.</p>",
               "type": "module",
               "displayName": "DEP0037: `fs.lchown(path, uid, gid, callback)`"
             },
@@ -6041,8 +6210,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -6053,7 +6222,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"fs.html#fs_fs_lchownsync_path_uid_gid\"><code>fs.lchownSync(path, uid, gid)</code></a> API was deprecated. The deprecation was\nrevoked because the requisite supporting APIs were added in libuv.</p>\n<p><a id=\"DEP0039\"></a></p>",
+              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"fs.html#fs_fs_lchownsync_path_uid_gid\"><code>fs.lchownSync(path, uid, gid)</code></a> API was deprecated. The deprecation was\nrevoked because the requisite supporting APIs were added in libuv.</p>",
               "type": "module",
               "displayName": "DEP0038: `fs.lchownSync(path, uid, gid)`"
             },
@@ -6064,8 +6233,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -6077,7 +6246,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"modules.html#modules_require_extensions\"><code>require.extensions</code></a> property is deprecated.</p>\n<p><a id=\"DEP0040\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"modules.html#modules_require_extensions\"><code>require.extensions</code></a> property is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0039: `require.extensions`"
             },
@@ -6093,7 +6262,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"punycode.html\"><code>punycode</code></a> module is deprecated. Please use a userland alternative\ninstead.</p>\n<p><a id=\"DEP0041\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"punycode.html\"><code>punycode</code></a> module is deprecated. Please use a userland alternative\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0040: `punycode` module"
             },
@@ -6109,8 +6278,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -6122,7 +6291,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>NODE_REPL_HISTORY_FILE</code> environment variable was removed. Please use\n<code>NODE_REPL_HISTORY</code> instead.</p>\n<p><a id=\"DEP0042\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>NODE_REPL_HISTORY_FILE</code> environment variable was removed. Please use\n<code>NODE_REPL_HISTORY</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0041: `NODE_REPL_HISTORY_FILE` environment variable"
             },
@@ -6138,8 +6307,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -6151,7 +6320,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"tls.html#tls_class_tls_cryptostream\"><code>tls.CryptoStream</code></a> class was removed. Please use\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a> instead.</p>\n<p><a id=\"DEP0043\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"tls.html#tls_class_tls_cryptostream\"><code>tls.CryptoStream</code></a> class was removed. Please use\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0042: `tls.CryptoStream`"
             },
@@ -6190,7 +6359,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"tls.html#tls_class_tls_securepair\"><code>tls.SecurePair</code></a> class is deprecated. Please use\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a> instead.</p>\n<p><a id=\"DEP0044\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"tls.html#tls_class_tls_securepair\"><code>tls.SecurePair</code></a> class is deprecated. Please use\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0043: `tls.SecurePair`"
             },
@@ -6201,23 +6370,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isarray_object\"><code>util.isArray()</code></a> API is deprecated. Please use <code>Array.isArray()</code>\ninstead.</p>\n<p><a id=\"DEP0045\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isarray_object\"><code>util.isArray()</code></a> API is deprecated. Please use <code>Array.isArray()</code>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0044: `util.isArray()`"
             },
@@ -6228,23 +6397,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isboolean_object\"><code>util.isBoolean()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0046\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isboolean_object\"><code>util.isBoolean()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0045: `util.isBoolean()`"
             },
@@ -6255,23 +6424,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isbuffer_object\"><code>util.isBuffer()</code></a> API is deprecated. Please use\n<a href=\"buffer.html#buffer_static_method_buffer_isbuffer_obj\"><code>Buffer.isBuffer()</code></a> instead.</p>\n<p><a id=\"DEP0047\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isbuffer_object\"><code>util.isBuffer()</code></a> API is deprecated. Please use\n<a href=\"buffer.html#buffer_static_method_buffer_isbuffer_obj\"><code>Buffer.isBuffer()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0046: `util.isBuffer()`"
             },
@@ -6282,23 +6451,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isdate_object\"><code>util.isDate()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0048\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isdate_object\"><code>util.isDate()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0047: `util.isDate()`"
             },
@@ -6309,23 +6478,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_iserror_object\"><code>util.isError()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0049\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_iserror_object\"><code>util.isError()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0048: `util.isError()`"
             },
@@ -6336,23 +6505,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isfunction_object\"><code>util.isFunction()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0050\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isfunction_object\"><code>util.isFunction()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0049: `util.isFunction()`"
             },
@@ -6363,23 +6532,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnull_object\"><code>util.isNull()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0051\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnull_object\"><code>util.isNull()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0050: `util.isNull()`"
             },
@@ -6390,23 +6559,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnullorundefined_object\"><code>util.isNullOrUndefined()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0052\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnullorundefined_object\"><code>util.isNullOrUndefined()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0051: `util.isNullOrUndefined()`"
             },
@@ -6417,52 +6586,52 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnumber_object\"><code>util.isNumber()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0053\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnumber_object\"><code>util.isNumber()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0052: `util.isNumber()`"
             },
             {
-              "textRaw": "DEP0053 `util.isObject()`",
-              "name": "dep0053_`util.isobject()`",
+              "textRaw": "DEP0053: `util.isObject()`",
+              "name": "dep0053:_`util.isobject()`",
               "meta": {
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isobject_object\"><code>util.isObject()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0054\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isobject_object\"><code>util.isObject()</code></a> API is deprecated.</p>",
               "type": "module",
-              "displayName": "DEP0053 `util.isObject()`"
+              "displayName": "DEP0053: `util.isObject()`"
             },
             {
               "textRaw": "DEP0054: `util.isPrimitive()`",
@@ -6471,23 +6640,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isprimitive_object\"><code>util.isPrimitive()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0055\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isprimitive_object\"><code>util.isPrimitive()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0054: `util.isPrimitive()`"
             },
@@ -6498,23 +6667,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isregexp_object\"><code>util.isRegExp()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0056\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isregexp_object\"><code>util.isRegExp()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0055: `util.isRegExp()`"
             },
@@ -6525,23 +6694,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isstring_object\"><code>util.isString()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0057\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isstring_object\"><code>util.isString()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0056: `util.isString()`"
             },
@@ -6552,23 +6721,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_issymbol_object\"><code>util.isSymbol()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0058\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_issymbol_object\"><code>util.isSymbol()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0057: `util.isSymbol()`"
             },
@@ -6579,23 +6748,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isundefined_object\"><code>util.isUndefined()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0059\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isundefined_object\"><code>util.isUndefined()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0058: `util.isUndefined()`"
             },
@@ -6616,7 +6785,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_log_string\"><code>util.log()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0060\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_log_string\"><code>util.log()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0059: `util.log()`"
             },
@@ -6637,7 +6806,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_extend_target_source\"><code>util._extend()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0061\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_extend_target_source\"><code>util._extend()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0060: `util._extend()`"
             },
@@ -6663,7 +6832,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>fs.SyncWriteStream</code> class was never intended to be a publicly accessible\nAPI and has been removed. No alternative API is available. Please use a userland\nalternative.</p>\n<p><a id=\"DEP0062\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>fs.SyncWriteStream</code> class was never intended to be a publicly accessible\nAPI and has been removed. No alternative API is available. Please use a userland\nalternative.</p>",
               "type": "module",
               "displayName": "DEP0061: `fs.SyncWriteStream`"
             },
@@ -6672,19 +6841,19 @@
               "name": "dep0062:_`node_--debug`",
               "meta": {
                 "changes": [
-                  {
-                    "version": "v8.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/10970",
-                    "description": "Runtime deprecation."
-                  },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/25828",
                     "description": "End-of-Life."
+                  },
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10970",
+                    "description": "Runtime deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>--debug</code> activates the legacy V8 debugger interface, which was removed as\nof V8 5.8. It is replaced by Inspector which is activated with <code>--inspect</code>\ninstead.</p>\n<p><a id=\"DEP0063\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>--debug</code> activates the legacy V8 debugger interface, which was removed as\nof V8 5.8. It is replaced by Inspector which is activated with <code>--inspect</code>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0062: `node --debug`"
             },
@@ -6700,7 +6869,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>http</code> module <code>ServerResponse.prototype.writeHeader()</code> API is\ndeprecated. Please use <code>ServerResponse.prototype.writeHead()</code> instead.</p>\n<p>The <code>ServerResponse.prototype.writeHeader()</code> method was never documented as an\nofficially supported API.</p>\n<p><a id=\"DEP0064\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>http</code> module <code>ServerResponse.prototype.writeHeader()</code> API is\ndeprecated. Please use <code>ServerResponse.prototype.writeHead()</code> instead.</p>\n<p>The <code>ServerResponse.prototype.writeHeader()</code> method was never documented as an\nofficially supported API.</p>",
               "type": "module",
               "displayName": "DEP0063: `ServerResponse.prototype.writeHeader()`"
             },
@@ -6739,7 +6908,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>tls.createSecurePair()</code> API was deprecated in documentation in Node.js\n0.11.3. Users should use <code>tls.Socket</code> instead.</p>\n<p><a id=\"DEP0065\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>tls.createSecurePair()</code> API was deprecated in documentation in Node.js\n0.11.3. Users should use <code>tls.Socket</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0064: `tls.createSecurePair()`"
             },
@@ -6760,7 +6929,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>repl</code> module's <code>REPL_MODE_MAGIC</code> constant, used for <code>replMode</code> option, has\nbeen removed. Its behavior has been functionally identical to that of\n<code>REPL_MODE_SLOPPY</code> since Node.js 6.0.0, when V8 5.0 was imported. Please use\n<code>REPL_MODE_SLOPPY</code> instead.</p>\n<p>The <code>NODE_REPL_MODE</code> environment variable is used to set the underlying\n<code>replMode</code> of an interactive <code>node</code> session. Its value, <code>magic</code>, is also\nremoved. Please use <code>sloppy</code> instead.</p>\n<p><a id=\"DEP0066\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>repl</code> module's <code>REPL_MODE_MAGIC</code> constant, used for <code>replMode</code> option, has\nbeen removed. Its behavior has been functionally identical to that of\n<code>REPL_MODE_SLOPPY</code> since Node.js 6.0.0, when V8 5.0 was imported. Please use\n<code>REPL_MODE_SLOPPY</code> instead.</p>\n<p>The <code>NODE_REPL_MODE</code> environment variable is used to set the underlying\n<code>replMode</code> of an interactive <code>node</code> session. Its value, <code>magic</code>, is also\nremoved. Please use <code>sloppy</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0065: `repl.REPL_MODE_MAGIC` and `NODE_REPL_MODE=magic`"
             },
@@ -6781,7 +6950,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>http</code> module <code>OutgoingMessage.prototype._headers</code> and\n<code>OutgoingMessage.prototype._headerNames</code> properties are deprecated. Use one of\nthe public methods (e.g. <code>OutgoingMessage.prototype.getHeader()</code>,\n<code>OutgoingMessage.prototype.getHeaders()</code>,\n<code>OutgoingMessage.prototype.getHeaderNames()</code>,\n<code>OutgoingMessage.prototype.hasHeader()</code>,\n<code>OutgoingMessage.prototype.removeHeader()</code>,\n<code>OutgoingMessage.prototype.setHeader()</code>) for working with outgoing headers.</p>\n<p>The <code>OutgoingMessage.prototype._headers</code> and\n<code>OutgoingMessage.prototype._headerNames</code> properties were never documented as\nofficially supported properties.</p>\n<p><a id=\"DEP0067\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>http</code> module <code>OutgoingMessage.prototype._headers</code> and\n<code>OutgoingMessage.prototype._headerNames</code> properties are deprecated. Use one of\nthe public methods (e.g. <code>OutgoingMessage.prototype.getHeader()</code>,\n<code>OutgoingMessage.prototype.getHeaders()</code>,\n<code>OutgoingMessage.prototype.getHeaderNames()</code>,\n<code>OutgoingMessage.prototype.getRawHeaderNames()</code>,\n<code>OutgoingMessage.prototype.hasHeader()</code>,\n<code>OutgoingMessage.prototype.removeHeader()</code>,\n<code>OutgoingMessage.prototype.setHeader()</code>) for working with outgoing headers.</p>\n<p>The <code>OutgoingMessage.prototype._headers</code> and\n<code>OutgoingMessage.prototype._headerNames</code> properties were never documented as\nofficially supported properties.</p>",
               "type": "module",
               "displayName": "DEP0066: `OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames`"
             },
@@ -6797,7 +6966,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>http</code> module <code>OutgoingMessage.prototype._renderHeaders()</code> API is\ndeprecated.</p>\n<p>The <code>OutgoingMessage.prototype._renderHeaders</code> property was never documented as\nan officially supported API.</p>\n<p><a id=\"DEP0068\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>http</code> module <code>OutgoingMessage.prototype._renderHeaders()</code> API is\ndeprecated.</p>\n<p>The <code>OutgoingMessage.prototype._renderHeaders</code> property was never documented as\nan officially supported API.</p>",
               "type": "module",
               "displayName": "DEP0067: `OutgoingMessage.prototype._renderHeaders`"
             },
@@ -6813,7 +6982,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>node debug</code> corresponds to the legacy CLI debugger which has been replaced with\na V8-inspector based CLI debugger available through <code>node inspect</code>.</p>\n<p><a id=\"DEP0069\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>node debug</code> corresponds to the legacy CLI debugger which has been replaced with\na V8-inspector based CLI debugger available through <code>node inspect</code>.</p>",
               "type": "module",
               "displayName": "DEP0068: `node debug`"
             },
@@ -6839,7 +7008,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>DebugContext has been removed in V8 and is not available in Node.js 10+.</p>\n<p>DebugContext was an experimental API.</p>\n<p><a id=\"DEP0070\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>DebugContext has been removed in V8 and is not available in Node.js 10+.</p>\n<p>DebugContext was an experimental API.</p>",
               "type": "module",
               "displayName": "DEP0069: `vm.runInDebugContext(string)`"
             },
@@ -6860,7 +7029,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.currentId()</code> was renamed to <code>async_hooks.executionAsyncId()</code> for\nclarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>\n<p><a id=\"DEP0071\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.currentId()</code> was renamed to <code>async_hooks.executionAsyncId()</code> for\nclarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>",
               "type": "module",
               "displayName": "DEP0070: `async_hooks.currentId()`"
             },
@@ -6881,7 +7050,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.triggerId()</code> was renamed to <code>async_hooks.triggerAsyncId()</code> for\nclarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>\n<p><a id=\"DEP0072\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.triggerId()</code> was renamed to <code>async_hooks.triggerAsyncId()</code> for\nclarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>",
               "type": "module",
               "displayName": "DEP0071: `async_hooks.triggerId()`"
             },
@@ -6902,7 +7071,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.AsyncResource.triggerId()</code> was renamed to\n<code>async_hooks.AsyncResource.triggerAsyncId()</code> for clarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>\n<p><a id=\"DEP0073\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.AsyncResource.triggerId()</code> was renamed to\n<code>async_hooks.AsyncResource.triggerAsyncId()</code> for clarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>",
               "type": "module",
               "displayName": "DEP0072: `async_hooks.AsyncResource.triggerId()`"
             },
@@ -6923,7 +7092,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Accessing several internal, undocumented properties of <code>net.Server</code> instances\nwith inappropriate names is deprecated.</p>\n<p>As the original API was undocumented and not generally useful for non-internal\ncode, no replacement API is provided.</p>\n<p><a id=\"DEP0074\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Accessing several internal, undocumented properties of <code>net.Server</code> instances\nwith inappropriate names is deprecated.</p>\n<p>As the original API was undocumented and not generally useful for non-internal\ncode, no replacement API is provided.</p>",
               "type": "module",
               "displayName": "DEP0073: Several internal properties of `net.Server`"
             },
@@ -6939,7 +7108,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>REPLServer.bufferedCommand</code> property was deprecated in favor of\n<a href=\"repl.html#repl_replserver_clearbufferedcommand\"><code>REPLServer.clearBufferedCommand()</code></a>.</p>\n<p><a id=\"DEP0075\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>REPLServer.bufferedCommand</code> property was deprecated in favor of\n<a href=\"repl.html#repl_replserver_clearbufferedcommand\"><code>REPLServer.clearBufferedCommand()</code></a>.</p>",
               "type": "module",
               "displayName": "DEP0074: `REPLServer.bufferedCommand`"
             },
@@ -6955,7 +7124,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.parseREPLKeyword()</code> was removed from userland visibility.</p>\n<p><a id=\"DEP0076\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.parseREPLKeyword()</code> was removed from userland visibility.</p>",
               "type": "module",
               "displayName": "DEP0075: `REPLServer.parseREPLKeyword()`"
             },
@@ -6976,7 +7145,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>tls.parseCertString()</code> is a trivial parsing helper that was made public by\nmistake. This function can usually be replaced with:</p>\n<pre><code class=\"language-js\">const querystring = require('querystring');\nquerystring.parse(str, '\\n', '=');\n</code></pre>\n<p>This function is not completely equivalent to <code>querystring.parse()</code>. One\ndifference is that <code>querystring.parse()</code> does url decoding:</p>\n<pre><code class=\"language-console\">> querystring.parse('%E5%A5%BD=1', '\\n', '=');\n{ '好': '1' }\n> tls.parseCertString('%E5%A5%BD=1');\n{ '%E5%A5%BD': '1' }\n</code></pre>\n<p><a id=\"DEP0077\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>tls.parseCertString()</code> is a trivial parsing helper that was made public by\nmistake. This function can usually be replaced with:</p>\n<pre><code class=\"language-js\">const querystring = require('querystring');\nquerystring.parse(str, '\\n', '=');\n</code></pre>\n<p>This function is not completely equivalent to <code>querystring.parse()</code>. One\ndifference is that <code>querystring.parse()</code> does url decoding:</p>\n<pre><code class=\"language-console\">> querystring.parse('%E5%A5%BD=1', '\\n', '=');\n{ '好': '1' }\n> tls.parseCertString('%E5%A5%BD=1');\n{ '%E5%A5%BD': '1' }\n</code></pre>",
               "type": "module",
               "displayName": "DEP0076: `tls.parseCertString()`"
             },
@@ -6992,7 +7161,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>Module._debug()</code> is deprecated.</p>\n<p>The <code>Module._debug()</code> function was never documented as an officially\nsupported API.</p>\n<p><a id=\"DEP0078\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>Module._debug()</code> is deprecated.</p>\n<p>The <code>Module._debug()</code> function was never documented as an officially\nsupported API.</p>",
               "type": "module",
               "displayName": "DEP0077: `Module._debug()`"
             },
@@ -7008,7 +7177,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.turnOffEditorMode()</code> was removed from userland visibility.</p>\n<p><a id=\"DEP0079\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.turnOffEditorMode()</code> was removed from userland visibility.</p>",
               "type": "module",
               "displayName": "DEP0078: `REPLServer.turnOffEditorMode()`"
             },
@@ -7034,7 +7203,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Using a property named <code>inspect</code> on an object to specify a custom inspection\nfunction for <a href=\"util.html#util_util_inspect_object_options\"><code>util.inspect()</code></a> is deprecated. Use <a href=\"util.html#util_util_inspect_custom\"><code>util.inspect.custom</code></a>\ninstead. For backward compatibility with Node.js prior to version 6.4.0, both\nmay be specified.</p>\n<p><a id=\"DEP0080\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Using a property named <code>inspect</code> on an object to specify a custom inspection\nfunction for <a href=\"util.html#util_util_inspect_object_options\"><code>util.inspect()</code></a> is deprecated. Use <a href=\"util.html#util_util_inspect_custom\"><code>util.inspect.custom</code></a>\ninstead. For backward compatibility with Node.js prior to version 6.4.0, both\ncan be specified.</p>",
               "type": "module",
               "displayName": "DEP0079: Custom inspection function on objects via `.inspect()`"
             },
@@ -7050,7 +7219,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The internal <code>path._makeLong()</code> was not intended for public use. However,\nuserland modules have found it useful. The internal API is deprecated\nand replaced with an identical, public <code>path.toNamespacedPath()</code> method.</p>\n<p><a id=\"DEP0081\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The internal <code>path._makeLong()</code> was not intended for public use. However,\nuserland modules have found it useful. The internal API is deprecated\nand replaced with an identical, public <code>path.toNamespacedPath()</code> method.</p>",
               "type": "module",
               "displayName": "DEP0080: `path._makeLong()`"
             },
@@ -7066,7 +7235,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>fs.truncate()</code> <code>fs.truncateSync()</code> usage with a file descriptor is\ndeprecated. Please use <code>fs.ftruncate()</code> or <code>fs.ftruncateSync()</code> to work with\nfile descriptors.</p>\n<p><a id=\"DEP0082\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>fs.truncate()</code> <code>fs.truncateSync()</code> usage with a file descriptor is\ndeprecated. Please use <code>fs.ftruncate()</code> or <code>fs.ftruncateSync()</code> to work with\nfile descriptors.</p>",
               "type": "module",
               "displayName": "DEP0081: `fs.truncate()` using a file descriptor"
             },
@@ -7082,7 +7251,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.prototype.memory()</code> is only necessary for the internal mechanics of\nthe <code>REPLServer</code> itself. Do not use this function.</p>\n<p><a id=\"DEP0083\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.prototype.memory()</code> is only necessary for the internal mechanics of\nthe <code>REPLServer</code> itself. Do not use this function.</p>",
               "type": "module",
               "displayName": "DEP0082: `REPLServer.prototype.memory()`"
             },
@@ -7103,7 +7272,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life.</p>\n<p>The <code>ecdhCurve</code> option to <code>tls.createSecureContext()</code> and <code>tls.TLSSocket</code> could\nbe set to <code>false</code> to disable ECDH entirely on the server only. This mode was\ndeprecated in preparation for migrating to OpenSSL 1.1.0 and consistency with\nthe client and is now unsupported. Use the <code>ciphers</code> parameter instead.</p>\n<p><a id=\"DEP0084\"></a></p>",
+              "desc": "<p>Type: End-of-Life.</p>\n<p>The <code>ecdhCurve</code> option to <code>tls.createSecureContext()</code> and <code>tls.TLSSocket</code> could\nbe set to <code>false</code> to disable ECDH entirely on the server only. This mode was\ndeprecated in preparation for migrating to OpenSSL 1.1.0 and consistency with\nthe client and is now unsupported. Use the <code>ciphers</code> parameter instead.</p>",
               "type": "module",
               "displayName": "DEP0083: Disabling ECDH by setting `ecdhCurve` to `false`"
             },
@@ -7124,7 +7293,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Since Node.js versions 4.4.0 and 5.2.0, several modules only intended for\ninternal usage were mistakenly exposed to user code through <code>require()</code>. These\nmodules were:</p>\n<ul>\n<li><code>v8/tools/codemap</code></li>\n<li><code>v8/tools/consarray</code></li>\n<li><code>v8/tools/csvparser</code></li>\n<li><code>v8/tools/logreader</code></li>\n<li><code>v8/tools/profile_view</code></li>\n<li><code>v8/tools/profile</code></li>\n<li><code>v8/tools/SourceMap</code></li>\n<li><code>v8/tools/splaytree</code></li>\n<li><code>v8/tools/tickprocessor-driver</code></li>\n<li><code>v8/tools/tickprocessor</code></li>\n<li><code>node-inspect/lib/_inspect</code> (from 7.6.0)</li>\n<li><code>node-inspect/lib/internal/inspect_client</code> (from 7.6.0)</li>\n<li><code>node-inspect/lib/internal/inspect_repl</code> (from 7.6.0)</li>\n</ul>\n<p>The <code>v8/*</code> modules do not have any exports, and if not imported in a specific\norder would in fact throw errors. As such there are virtually no legitimate use\ncases for importing them through <code>require()</code>.</p>\n<p>On the other hand, <code>node-inspect</code> may be installed locally through a package\nmanager, as it is published on the npm registry under the same name. No source\ncode modification is necessary if that is done.</p>\n<p><a id=\"DEP0085\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Since Node.js versions 4.4.0 and 5.2.0, several modules only intended for\ninternal usage were mistakenly exposed to user code through <code>require()</code>. These\nmodules were:</p>\n<ul>\n<li><code>v8/tools/codemap</code></li>\n<li><code>v8/tools/consarray</code></li>\n<li><code>v8/tools/csvparser</code></li>\n<li><code>v8/tools/logreader</code></li>\n<li><code>v8/tools/profile_view</code></li>\n<li><code>v8/tools/profile</code></li>\n<li><code>v8/tools/SourceMap</code></li>\n<li><code>v8/tools/splaytree</code></li>\n<li><code>v8/tools/tickprocessor-driver</code></li>\n<li><code>v8/tools/tickprocessor</code></li>\n<li><code>node-inspect/lib/_inspect</code> (from 7.6.0)</li>\n<li><code>node-inspect/lib/internal/inspect_client</code> (from 7.6.0)</li>\n<li><code>node-inspect/lib/internal/inspect_repl</code> (from 7.6.0)</li>\n</ul>\n<p>The <code>v8/*</code> modules do not have any exports, and if not imported in a specific\norder would in fact throw errors. As such there are virtually no legitimate use\ncases for importing them through <code>require()</code>.</p>\n<p>On the other hand, <code>node-inspect</code> can be installed locally through a package\nmanager, as it is published on the npm registry under the same name. No source\ncode modification is necessary if that is done.</p>",
               "type": "module",
               "displayName": "DEP0084: requiring bundled internal dependencies"
             },
@@ -7134,21 +7303,21 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "10.0.0",
+                    "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/17147",
                     "description": "End-of-Life."
                   },
                   {
                     "version": [
-                      "v8.10.0",
-                      "v9.4.0"
+                      "v9.4.0",
+                      "v8.10.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/16972",
                     "description": "Runtime deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The AsyncHooks sensitive API was never documented and had various minor issues.\nUse the <code>AsyncResource</code> API instead. See\n<a href=\"https://github.com/nodejs/node/issues/15572\">https://github.com/nodejs/node/issues/15572</a>.</p>\n<p><a id=\"DEP0086\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The AsyncHooks sensitive API was never documented and had various minor issues.\nUse the <code>AsyncResource</code> API instead. See\n<a href=\"https://github.com/nodejs/node/issues/15572\">https://github.com/nodejs/node/issues/15572</a>.</p>",
               "type": "module",
               "displayName": "DEP0085: AsyncHooks sensitive API"
             },
@@ -7158,21 +7327,21 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "10.0.0",
+                    "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/17147",
                     "description": "End-of-Life."
                   },
                   {
                     "version": [
-                      "v8.10.0",
-                      "v9.4.0"
+                      "v9.4.0",
+                      "v8.10.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/16972",
                     "description": "Runtime deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>runInAsyncIdScope</code> doesn't emit the <code>'before'</code> or <code>'after'</code> event and can thus\ncause a lot of issues. See <a href=\"https://github.com/nodejs/node/issues/14328\">https://github.com/nodejs/node/issues/14328</a>.</p>\n<p><a id=\"DEP0089\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>runInAsyncIdScope</code> doesn't emit the <code>'before'</code> or <code>'after'</code> event and can thus\ncause a lot of issues. See <a href=\"https://github.com/nodejs/node/issues/14328\">https://github.com/nodejs/node/issues/14328</a>.</p>",
               "type": "module",
               "displayName": "DEP0086: Remove `runInAsyncIdScope`"
             },
@@ -7189,14 +7358,14 @@
                   {
                     "version": [
                       "v9.9.0",
-                      "v10.0.0"
+                      "v8.13.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/17002",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Deprecation revoked</p>\n<p>Importing assert directly was not recommended as the exposed functions use\nloose equality checks. The deprecation was revoked because use of the <code>assert</code>\nmodule is not discouraged, and the deprecation caused developer confusion.</p>\n<p><a id=\"DEP0090\"></a></p>",
+              "desc": "<p>Type: Deprecation revoked</p>\n<p>Importing assert directly was not recommended as the exposed functions use\nloose equality checks. The deprecation was revoked because use of the <code>assert</code>\nmodule is not discouraged, and the deprecation caused developer confusion.</p>",
               "type": "module",
               "displayName": "DEP0089: `require('assert')`"
             },
@@ -7217,7 +7386,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Node.js used to support all GCM authentication tag lengths which are accepted by\nOpenSSL when calling <a href=\"crypto.html#crypto_decipher_setauthtag_buffer\"><code>decipher.setAuthTag()</code></a>. Beginning with Node.js\nv11.0.0, only authentication tag lengths of 128, 120, 112, 104, 96, 64, and 32\nbits are allowed. Authentication tags of other lengths are invalid per\n<a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf\">NIST SP 800-38D</a>.</p>\n<p><a id=\"DEP0091\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Node.js used to support all GCM authentication tag lengths which are accepted by\nOpenSSL when calling <a href=\"crypto.html#crypto_decipher_setauthtag_buffer\"><code>decipher.setAuthTag()</code></a>. Beginning with Node.js\nv11.0.0, only authentication tag lengths of 128, 120, 112, 104, 96, 64, and 32\nbits are allowed. Authentication tags of other lengths are invalid per\n<a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf\">NIST SP 800-38D</a>.</p>",
               "type": "module",
               "displayName": "DEP0090: Invalid GCM authentication tag lengths"
             },
@@ -7233,7 +7402,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <a href=\"crypto.html#crypto_crypto_default_encoding\"><code>crypto.DEFAULT_ENCODING</code></a> property is deprecated.</p>\n<p><a id=\"DEP0092\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <a href=\"crypto.html#crypto_crypto_default_encoding\"><code>crypto.DEFAULT_ENCODING</code></a> property is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0091: `crypto.DEFAULT_ENCODING`"
             },
@@ -7249,13 +7418,13 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>Assigning properties to the top-level <code>this</code> as an alternative\nto <code>module.exports</code> is deprecated. Developers should use <code>exports</code>\nor <code>module.exports</code> instead.</p>\n<p><a id=\"DEP0093\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>Assigning properties to the top-level <code>this</code> as an alternative\nto <code>module.exports</code> is deprecated. Developers should use <code>exports</code>\nor <code>module.exports</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0092: Top-level `this` bound to `module.exports`"
             },
             {
-              "textRaw": "DEP0093: `crypto.fips` is deprecated and replaced.",
-              "name": "dep0093:_`crypto.fips`_is_deprecated_and_replaced.",
+              "textRaw": "DEP0093: `crypto.fips` is deprecated and replaced",
+              "name": "dep0093:_`crypto.fips`_is_deprecated_and_replaced",
               "meta": {
                 "changes": [
                   {
@@ -7265,13 +7434,13 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_crypto_fips\"><code>crypto.fips</code></a> property is deprecated. Please use <code>crypto.setFips()</code>\nand <code>crypto.getFips()</code> instead.</p>\n<p><a id=\"DEP0094\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_crypto_fips\"><code>crypto.fips</code></a> property is deprecated. Please use <code>crypto.setFips()</code>\nand <code>crypto.getFips()</code> instead.</p>",
               "type": "module",
-              "displayName": "DEP0093: `crypto.fips` is deprecated and replaced."
+              "displayName": "DEP0093: `crypto.fips` is deprecated and replaced"
             },
             {
-              "textRaw": "DEP0094: Using `assert.fail()` with more than one argument.",
-              "name": "dep0094:_using_`assert.fail()`_with_more_than_one_argument.",
+              "textRaw": "DEP0094: Using `assert.fail()` with more than one argument",
+              "name": "dep0094:_using_`assert.fail()`_with_more_than_one_argument",
               "meta": {
                 "changes": [
                   {
@@ -7281,9 +7450,9 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Using <code>assert.fail()</code> with more than one argument is deprecated. Use\n<code>assert.fail()</code> with only one argument or use a different <code>assert</code> module\nmethod.</p>\n<p><a id=\"DEP0095\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Using <code>assert.fail()</code> with more than one argument is deprecated. Use\n<code>assert.fail()</code> with only one argument or use a different <code>assert</code> module\nmethod.</p>",
               "type": "module",
-              "displayName": "DEP0094: Using `assert.fail()` with more than one argument."
+              "displayName": "DEP0094: Using `assert.fail()` with more than one argument"
             },
             {
               "textRaw": "DEP0095: `timers.enroll()`",
@@ -7297,7 +7466,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>timers.enroll()</code> is deprecated. Please use the publicly documented\n<a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> or <a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a> instead.</p>\n<p><a id=\"DEP0096\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>timers.enroll()</code> is deprecated. Please use the publicly documented\n<a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> or <a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0095: `timers.enroll()`"
             },
@@ -7313,7 +7482,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>timers.unenroll()</code> is deprecated. Please use the publicly documented\n<a href=\"timers.html#timers_cleartimeout_timeout\"><code>clearTimeout()</code></a> or <a href=\"timers.html#timers_clearinterval_timeout\"><code>clearInterval()</code></a> instead.</p>\n<p><a id=\"DEP0097\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>timers.unenroll()</code> is deprecated. Please use the publicly documented\n<a href=\"timers.html#timers_cleartimeout_timeout\"><code>clearTimeout()</code></a> or <a href=\"timers.html#timers_clearinterval_timeout\"><code>clearInterval()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0096: `timers.unenroll()`"
             },
@@ -7329,7 +7498,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Users of <code>MakeCallback</code> that add the <code>domain</code> property to carry context,\nshould start using the <code>async_context</code> variant of <code>MakeCallback</code> or\n<code>CallbackScope</code>, or the high-level <code>AsyncResource</code> class.</p>\n<p><a id=\"DEP0098\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Users of <code>MakeCallback</code> that add the <code>domain</code> property to carry context,\nshould start using the <code>async_context</code> variant of <code>MakeCallback</code> or\n<code>CallbackScope</code>, or the high-level <code>AsyncResource</code> class.</p>",
               "type": "module",
               "displayName": "DEP0097: `MakeCallback` with `domain` property"
             },
@@ -7341,20 +7510,20 @@
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26530",
-                    "description": "End-of-Life"
+                    "description": "End-of-Life."
                   },
                   {
                     "version": [
-                      "v8.12.0",
+                      "v10.0.0",
                       "v9.6.0",
-                      "v10.0.0"
+                      "v8.12.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/18632",
                     "description": "Runtime deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The embedded API provided by AsyncHooks exposes <code>.emitBefore()</code> and\n<code>.emitAfter()</code> methods which are very easy to use incorrectly which can lead\nto unrecoverable errors.</p>\n<p>Use <a href=\"async_hooks.html#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args\"><code>asyncResource.runInAsyncScope()</code></a> API instead which provides a much\nsafer, and more convenient, alternative. See\n<a href=\"https://github.com/nodejs/node/pull/18513\">https://github.com/nodejs/node/pull/18513</a>.</p>\n<p><a id=\"DEP0099\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The embedded API provided by AsyncHooks exposes <code>.emitBefore()</code> and\n<code>.emitAfter()</code> methods which are very easy to use incorrectly which can lead\nto unrecoverable errors.</p>\n<p>Use <a href=\"async_hooks.html#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args\"><code>asyncResource.runInAsyncScope()</code></a> API instead which provides a much\nsafer, and more convenient, alternative. See\n<a href=\"https://github.com/nodejs/node/pull/18513\">https://github.com/nodejs/node/pull/18513</a>.</p>",
               "type": "module",
               "displayName": "DEP0098: AsyncHooks embedder `AsyncResource.emitBefore` and `AsyncResource.emitAfter` APIs"
             },
@@ -7370,7 +7539,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Compile-time</p>\n<p>Certain versions of <code>node::MakeCallback</code> APIs available to native modules are\ndeprecated. Please use the versions of the API that accept an <code>async_context</code>\nparameter.</p>\n<p><a id=\"DEP0100\"></a></p>",
+              "desc": "<p>Type: Compile-time</p>\n<p>Certain versions of <code>node::MakeCallback</code> APIs available to native modules are\ndeprecated. Please use the versions of the API that accept an <code>async_context</code>\nparameter.</p>",
               "type": "module",
               "displayName": "DEP0099: Async context-unaware `node::MakeCallback` C++ APIs"
             },
@@ -7390,7 +7559,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>process.assert()</code> is deprecated. Please use the <a href=\"assert.html\"><code>assert</code></a> module instead.</p>\n<p>This was never a documented feature.</p>\n<p><a id=\"DEP0101\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>process.assert()</code> is deprecated. Please use the <a href=\"assert.html\"><code>assert</code></a> module instead.</p>\n<p>This was never a documented feature.</p>",
               "type": "module",
               "displayName": "DEP0100: `process.assert()`"
             },
@@ -7406,13 +7575,13 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>--with-lttng</code> compile-time option has been removed.</p>\n<p><a id=\"DEP0102\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>--with-lttng</code> compile-time option has been removed.</p>",
               "type": "module",
               "displayName": "DEP0101: `--with-lttng`"
             },
             {
-              "textRaw": "DEP0102: Using `noAssert` in `Buffer#(read|write)` operations.",
-              "name": "dep0102:_using_`noassert`_in_`buffer#(read|write)`_operations.",
+              "textRaw": "DEP0102: Using `noAssert` in `Buffer#(read|write)` operations",
+              "name": "dep0102:_using_`noassert`_in_`buffer#(read|write)`_operations",
               "meta": {
                 "changes": [
                   {
@@ -7422,9 +7591,9 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Using the <code>noAssert</code> argument has no functionality anymore. All input is going\nto be verified, no matter if it is set to true or not. Skipping the verification\ncould lead to hard to find errors and crashes.</p>\n<p><a id=\"DEP0103\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Using the <code>noAssert</code> argument has no functionality anymore. All input is going\nto be verified, no matter if it is set to true or not. Skipping the verification\ncould lead to hard to find errors and crashes.</p>",
               "type": "module",
-              "displayName": "DEP0102: Using `noAssert` in `Buffer#(read|write)` operations."
+              "displayName": "DEP0102: Using `noAssert` in `Buffer#(read|write)` operations"
             },
             {
               "textRaw": "DEP0103: `process.binding('util').is[...]` typechecks",
@@ -7443,7 +7612,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Using <code>process.binding()</code> in general should be avoided. The type checking\nmethods in particular can be replaced by using <a href=\"util.html#util_util_types\"><code>util.types</code></a>.</p>\n<p>This deprecation has been superseded by the deprecation of the\n<code>process.binding()</code> API (<a href=\"deprecations.html#DEP0111\">DEP0111</a>).</p>\n<p><a id=\"DEP0104\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Using <code>process.binding()</code> in general should be avoided. The type checking\nmethods in particular can be replaced by using <a href=\"util.html#util_util_types\"><code>util.types</code></a>.</p>\n<p>This deprecation has been superseded by the deprecation of the\n<code>process.binding()</code> API (<a href=\"deprecations.html#DEP0111\">DEP0111</a>).</p>",
               "type": "module",
               "displayName": "DEP0103: `process.binding('util').is[...]` typechecks"
             },
@@ -7459,7 +7628,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>When assigning a non-string property to <a href=\"process.html#process_process_env\"><code>process.env</code></a>, the assigned value is\nimplicitly converted to a string. This behavior is deprecated if the assigned\nvalue is not a string, boolean, or number. In the future, such assignment may\nresult in a thrown error. Please convert the property to a string before\nassigning it to <code>process.env</code>.</p>\n<p><a id=\"DEP0105\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>When assigning a non-string property to <a href=\"process.html#process_process_env\"><code>process.env</code></a>, the assigned value is\nimplicitly converted to a string. This behavior is deprecated if the assigned\nvalue is not a string, boolean, or number. In the future, such assignment might\nresult in a thrown error. Please convert the property to a string before\nassigning it to <code>process.env</code>.</p>",
               "type": "module",
               "displayName": "DEP0104: `process.env` string coercion"
             },
@@ -7480,7 +7649,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>decipher.finaltol()</code> has never been documented and was an alias for\n<a href=\"crypto.html#crypto_decipher_final_outputencoding\"><code>decipher.final()</code></a>. This API has been removed, and it is recommended to use\n<a href=\"crypto.html#crypto_decipher_final_outputencoding\"><code>decipher.final()</code></a> instead.</p>\n<p><a id=\"DEP0106\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>decipher.finaltol()</code> has never been documented and was an alias for\n<a href=\"crypto.html#crypto_decipher_final_outputencoding\"><code>decipher.final()</code></a>. This API has been removed, and it is recommended to use\n<a href=\"crypto.html#crypto_decipher_final_outputencoding\"><code>decipher.final()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0105: `decipher.finaltol`"
             },
@@ -7501,7 +7670,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Using <a href=\"crypto.html#crypto_crypto_createcipher_algorithm_password_options\"><code>crypto.createCipher()</code></a> and <a href=\"crypto.html#crypto_crypto_createdecipher_algorithm_password_options\"><code>crypto.createDecipher()</code></a> should be\navoided as they use a weak key derivation function (MD5 with no salt) and static\ninitialization vectors. It is recommended to derive a key using\n<a href=\"crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback\"><code>crypto.pbkdf2()</code></a> or <a href=\"crypto.html#crypto_crypto_scrypt_password_salt_keylen_options_callback\"><code>crypto.scrypt()</code></a> and to use\n<a href=\"crypto.html#crypto_crypto_createcipheriv_algorithm_key_iv_options\"><code>crypto.createCipheriv()</code></a> and <a href=\"crypto.html#crypto_crypto_createdecipheriv_algorithm_key_iv_options\"><code>crypto.createDecipheriv()</code></a> to obtain the\n<a href=\"crypto.html#crypto_class_cipher\"><code>Cipher</code></a> and <a href=\"crypto.html#crypto_class_decipher\"><code>Decipher</code></a> objects respectively.</p>\n<p><a id=\"DEP0107\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Using <a href=\"crypto.html#crypto_crypto_createcipher_algorithm_password_options\"><code>crypto.createCipher()</code></a> and <a href=\"crypto.html#crypto_crypto_createdecipher_algorithm_password_options\"><code>crypto.createDecipher()</code></a> should be\navoided as they use a weak key derivation function (MD5 with no salt) and static\ninitialization vectors. It is recommended to derive a key using\n<a href=\"crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback\"><code>crypto.pbkdf2()</code></a> or <a href=\"crypto.html#crypto_crypto_scrypt_password_salt_keylen_options_callback\"><code>crypto.scrypt()</code></a> and to use\n<a href=\"crypto.html#crypto_crypto_createcipheriv_algorithm_key_iv_options\"><code>crypto.createCipheriv()</code></a> and <a href=\"crypto.html#crypto_crypto_createdecipheriv_algorithm_key_iv_options\"><code>crypto.createDecipheriv()</code></a> to obtain the\n<a href=\"crypto.html#crypto_class_cipher\"><code>Cipher</code></a> and <a href=\"crypto.html#crypto_class_decipher\"><code>Decipher</code></a> objects respectively.</p>",
               "type": "module",
               "displayName": "DEP0106: `crypto.createCipher` and `crypto.createDecipher`"
             },
@@ -7522,7 +7691,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>This was an undocumented helper function not intended for use outside Node.js\ncore and obsoleted by the removal of NPN (Next Protocol Negotiation) support.</p>\n<p><a id=\"DEP0108\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>This was an undocumented helper function not intended for use outside Node.js\ncore and obsoleted by the removal of NPN (Next Protocol Negotiation) support.</p>",
               "type": "module",
               "displayName": "DEP0107: `tls.convertNPNProtocols()`"
             },
@@ -7543,7 +7712,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Deprecated alias for <a href=\"zlib.html#zlib_zlib_byteswritten\"><code>zlib.bytesWritten</code></a>. This original name was chosen\nbecause it also made sense to interpret the value as the number of bytes\nread by the engine, but is inconsistent with other streams in Node.js that\nexpose values under these names.</p>\n<p><a id=\"DEP0109\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Deprecated alias for <a href=\"zlib.html#zlib_zlib_byteswritten\"><code>zlib.bytesWritten</code></a>. This original name was chosen\nbecause it also made sense to interpret the value as the number of bytes\nread by the engine, but is inconsistent with other streams in Node.js that\nexpose values under these names.</p>",
               "type": "module",
               "displayName": "DEP0108: `zlib.bytesRead`"
             },
@@ -7559,7 +7728,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Some previously supported (but strictly invalid) URLs were accepted through the\n<a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a>, <a href=\"http.html#http_http_get_options_callback\"><code>http.get()</code></a>, <a href=\"https.html#https_https_request_options_callback\"><code>https.request()</code></a>,\n<a href=\"https.html#https_https_get_options_callback\"><code>https.get()</code></a>, and <a href=\"tls.html#tls_tls_checkserveridentity_hostname_cert\"><code>tls.checkServerIdentity()</code></a> APIs because those were\naccepted by the legacy <code>url.parse()</code> API. The mentioned APIs now use the WHATWG\nURL parser that requires strictly valid URLs. Passing an invalid URL is\ndeprecated and support will be removed in the future.</p>\n<p><a id=\"DEP0110\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Some previously supported (but strictly invalid) URLs were accepted through the\n<a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a>, <a href=\"http.html#http_http_get_options_callback\"><code>http.get()</code></a>, <a href=\"https.html#https_https_request_options_callback\"><code>https.request()</code></a>,\n<a href=\"https.html#https_https_get_options_callback\"><code>https.get()</code></a>, and <a href=\"tls.html#tls_tls_checkserveridentity_hostname_cert\"><code>tls.checkServerIdentity()</code></a> APIs because those were\naccepted by the legacy <code>url.parse()</code> API. The mentioned APIs now use the WHATWG\nURL parser that requires strictly valid URLs. Passing an invalid URL is\ndeprecated and support will be removed in the future.</p>",
               "type": "module",
               "displayName": "DEP0109: `http`, `https`, and `tls` support for invalid URLs"
             },
@@ -7575,7 +7744,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>produceCachedData</code> option is deprecated. Use\n<a href=\"vm.html#vm_script_createcacheddata\"><code>script.createCachedData()</code></a> instead.</p>\n<p><a id=\"DEP0111\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>produceCachedData</code> option is deprecated. Use\n<a href=\"vm.html#vm_script_createcacheddata\"><code>script.createCachedData()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0110: `vm.Script` cached data"
             },
@@ -7584,19 +7753,19 @@
               "name": "dep0111:_`process.binding()`",
               "meta": {
                 "changes": [
-                  {
-                    "version": "v10.9.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/22004",
-                    "description": "Documentation-only deprecation."
-                  },
                   {
                     "version": "v11.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26500",
                     "description": "Added support for `--pending-deprecation`."
+                  },
+                  {
+                    "version": "v10.9.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22004",
+                    "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p><code>process.binding()</code> is for use by Node.js internal code only.</p>\n<p><a id=\"DEP0112\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p><code>process.binding()</code> is for use by Node.js internal code only.</p>",
               "type": "module",
               "displayName": "DEP0111: `process.binding()`"
             },
@@ -7612,7 +7781,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>dgram</code> module previously contained several APIs that were never meant to\naccessed outside of Node.js core: <code>Socket.prototype._handle</code>,\n<code>Socket.prototype._receiving</code>, <code>Socket.prototype._bindState</code>,\n<code>Socket.prototype._queue</code>, <code>Socket.prototype._reuseAddr</code>,\n<code>Socket.prototype._healthCheck()</code>, <code>Socket.prototype._stopReceiving()</code>, and\n<code>dgram._createSocketHandle()</code>.</p>\n<p><a id=\"DEP0113\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>dgram</code> module previously contained several APIs that were never meant to\naccessed outside of Node.js core: <code>Socket.prototype._handle</code>,\n<code>Socket.prototype._receiving</code>, <code>Socket.prototype._bindState</code>,\n<code>Socket.prototype._queue</code>, <code>Socket.prototype._reuseAddr</code>,\n<code>Socket.prototype._healthCheck()</code>, <code>Socket.prototype._stopReceiving()</code>, and\n<code>dgram._createSocketHandle()</code>.</p>",
               "type": "module",
               "displayName": "DEP0112: `dgram` private APIs"
             },
@@ -7633,7 +7802,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>Cipher.setAuthTag()</code> and <code>Decipher.getAuthTag()</code> are no longer available. They\nwere never documented and would throw when called.</p>\n<p><a id=\"DEP0114\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>Cipher.setAuthTag()</code> and <code>Decipher.getAuthTag()</code> are no longer available. They\nwere never documented and would throw when called.</p>",
               "type": "module",
               "displayName": "DEP0113: `Cipher.setAuthTag()`, `Decipher.getAuthTag()`"
             },
@@ -7654,7 +7823,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto._toBuf()</code> function was not designed to be used by modules outside\nof Node.js core and was removed.</p>\n<p><a id=\"DEP0115\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto._toBuf()</code> function was not designed to be used by modules outside\nof Node.js core and was removed.</p>",
               "type": "module",
               "displayName": "DEP0114: `crypto._toBuf()`"
             },
@@ -7673,7 +7842,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>In recent versions of Node.js, there is no difference between\n<a href=\"crypto.html#crypto_crypto_randombytes_size_callback\"><code>crypto.randomBytes()</code></a> and <code>crypto.pseudoRandomBytes()</code>. The latter is\ndeprecated along with the undocumented aliases <code>crypto.prng()</code> and\n<code>crypto.rng()</code> in favor of <a href=\"crypto.html#crypto_crypto_randombytes_size_callback\"><code>crypto.randomBytes()</code></a> and may be removed in a\nfuture release.</p>\n<p><a id=\"DEP0116\"></a></p>",
+              "desc": "<!--lint disable nodejs-yaml-comments -->\n<!--lint enable nodejs-yaml-comments -->\n<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>In recent versions of Node.js, there is no difference between\n<a href=\"crypto.html#crypto_crypto_randombytes_size_callback\"><code>crypto.randomBytes()</code></a> and <code>crypto.pseudoRandomBytes()</code>. The latter is\ndeprecated along with the undocumented aliases <code>crypto.prng()</code> and\n<code>crypto.rng()</code> in favor of <a href=\"crypto.html#crypto_crypto_randombytes_size_callback\"><code>crypto.randomBytes()</code></a> and might be removed in a\nfuture release.</p>",
               "type": "module",
               "displayName": "DEP0115: `crypto.prng()`, `crypto.pseudoRandomBytes()`, `crypto.rng()`"
             },
@@ -7682,6 +7851,11 @@
               "name": "dep0116:_legacy_url_api",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22715",
@@ -7689,7 +7863,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"url.html#url_legacy_url_api\">Legacy URL API</a> is deprecated. This includes <a href=\"url.html#url_url_format_urlobject\"><code>url.format()</code></a>,\n<a href=\"url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost\"><code>url.parse()</code></a>, <a href=\"url.html#url_url_resolve_from_to\"><code>url.resolve()</code></a>, and the <a href=\"url.html#url_legacy_urlobject\">legacy <code>urlObject</code></a>. Please\nuse the <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL API</a> instead.</p>\n<p><a id=\"DEP0117\"></a></p>",
+              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"url.html#url_legacy_url_api\">Legacy URL API</a> is deprecated. This includes <a href=\"url.html#url_url_format_urlobject\"><code>url.format()</code></a>,\n<a href=\"url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost\"><code>url.parse()</code></a>, <a href=\"url.html#url_url_resolve_from_to\"><code>url.resolve()</code></a>, and the <a href=\"url.html#url_legacy_urlobject\">legacy <code>urlObject</code></a>. Please\nuse the <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL API</a> instead.</p>",
               "type": "module",
               "displayName": "DEP0116: Legacy URL API"
             },
@@ -7710,7 +7884,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Previous versions of Node.js exposed handles to internal native objects through\nthe <code>_handle</code> property of the <code>Cipher</code>, <code>Decipher</code>, <code>DiffieHellman</code>,\n<code>DiffieHellmanGroup</code>, <code>ECDH</code>, <code>Hash</code>, <code>Hmac</code>, <code>Sign</code>, and <code>Verify</code> classes.\nThe <code>_handle</code> property has been removed because improper use of the native\nobject can lead to crashing the application.</p>\n<p><a id=\"DEP0118\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Previous versions of Node.js exposed handles to internal native objects through\nthe <code>_handle</code> property of the <code>Cipher</code>, <code>Decipher</code>, <code>DiffieHellman</code>,\n<code>DiffieHellmanGroup</code>, <code>ECDH</code>, <code>Hash</code>, <code>Hmac</code>, <code>Sign</code>, and <code>Verify</code> classes.\nThe <code>_handle</code> property has been removed because improper use of the native\nobject can lead to crashing the application.</p>",
               "type": "module",
               "displayName": "DEP0117: Native crypto handles"
             },
@@ -7726,7 +7900,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Previous versions of Node.js supported <code>dns.lookup()</code> with a falsy host name\nlike <code>dns.lookup(false)</code> due to backward compatibility.\nThis behavior is undocumented and is thought to be unused in real world apps.\nIt will become an error in future versions of Node.js.</p>\n<p><a id=\"DEP0119\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Previous versions of Node.js supported <code>dns.lookup()</code> with a falsy host name\nlike <code>dns.lookup(false)</code> due to backward compatibility.\nThis behavior is undocumented and is thought to be unused in real world apps.\nIt will become an error in future versions of Node.js.</p>",
               "type": "module",
               "displayName": "DEP0118: `dns.lookup()` support for a falsy host name"
             },
@@ -7742,7 +7916,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p><code>process.binding('uv').errname()</code> is deprecated. Please use\n<a href=\"util.html#util_util_getsystemerrorname_err\"><code>util.getSystemErrorName()</code></a> instead.</p>\n<p><a id=\"DEP0120\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p><code>process.binding('uv').errname()</code> is deprecated. Please use\n<a href=\"util.html#util_util_getsystemerrorname_err\"><code>util.getSystemErrorName()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0119: `process.binding('uv').errname()` private API"
             },
@@ -7763,7 +7937,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Windows Performance Counter support has been removed from Node.js. The\nundocumented <code>COUNTER_NET_SERVER_CONNECTION()</code>,\n<code>COUNTER_NET_SERVER_CONNECTION_CLOSE()</code>, <code>COUNTER_HTTP_SERVER_REQUEST()</code>,\n<code>COUNTER_HTTP_SERVER_RESPONSE()</code>, <code>COUNTER_HTTP_CLIENT_REQUEST()</code>, and\n<code>COUNTER_HTTP_CLIENT_RESPONSE()</code> functions have been deprecated.</p>\n<p><a id=\"DEP0121\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Windows Performance Counter support has been removed from Node.js. The\nundocumented <code>COUNTER_NET_SERVER_CONNECTION()</code>,\n<code>COUNTER_NET_SERVER_CONNECTION_CLOSE()</code>, <code>COUNTER_HTTP_SERVER_REQUEST()</code>,\n<code>COUNTER_HTTP_SERVER_RESPONSE()</code>, <code>COUNTER_HTTP_CLIENT_REQUEST()</code>, and\n<code>COUNTER_HTTP_CLIENT_RESPONSE()</code> functions have been deprecated.</p>",
               "type": "module",
               "displayName": "DEP0120: Windows Performance Counter support"
             },
@@ -7779,7 +7953,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The undocumented <code>net._setSimultaneousAccepts()</code> function was originally\nintended for debugging and performance tuning when using the <code>child_process</code>\nand <code>cluster</code> modules on Windows. The function is not generally useful and\nis being removed. See discussion here:\n<a href=\"https://github.com/nodejs/node/issues/18391\">https://github.com/nodejs/node/issues/18391</a></p>\n<p><a id=\"DEP0122\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The undocumented <code>net._setSimultaneousAccepts()</code> function was originally\nintended for debugging and performance tuning when using the <code>child_process</code>\nand <code>cluster</code> modules on Windows. The function is not generally useful and\nis being removed. See discussion here:\n<a href=\"https://github.com/nodejs/node/issues/18391\">https://github.com/nodejs/node/issues/18391</a></p>",
               "type": "module",
               "displayName": "DEP0121: `net._setSimultaneousAccepts()`"
             },
@@ -7795,7 +7969,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Please use <code>Server.prototype.setSecureContext()</code> instead.</p>\n<p><a id=\"DEP0123\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Please use <code>Server.prototype.setSecureContext()</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0122: `tls` `Server.prototype.setOptions()`"
             },
@@ -7811,7 +7985,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Setting the TLS ServerName to an IP address is not permitted by\n<a href=\"https://tools.ietf.org/html/rfc6066#section-3\">RFC 6066</a>. This will be ignored in a future version.</p>\n<p><a id=\"DEP0124\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Setting the TLS ServerName to an IP address is not permitted by\n<a href=\"https://tools.ietf.org/html/rfc6066#section-3\">RFC 6066</a>. This will be ignored in a future version.</p>",
               "type": "module",
               "displayName": "DEP0123: setting the TLS ServerName to an IP address"
             },
@@ -7827,7 +8001,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>This property is a reference to the instance itself.</p>\n<p><a id=\"DEP0125\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>This property is a reference to the instance itself.</p>",
               "type": "module",
               "displayName": "DEP0124: using `REPLServer.rli`"
             },
@@ -7843,7 +8017,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>_stream_wrap</code> module is deprecated.</p>\n<p><a id=\"DEP0126\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>_stream_wrap</code> module is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0125: `require('_stream_wrap')`"
             },
@@ -7859,7 +8033,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The previously undocumented <code>timers.active()</code> is deprecated.\nPlease use the publicly documented <a href=\"timers.html#timers_timeout_refresh\"><code>timeout.refresh()</code></a> instead.\nIf re-referencing the timeout is necessary, <a href=\"timers.html#timers_timeout_ref\"><code>timeout.ref()</code></a> can be used\nwith no performance impact since Node.js 10.</p>\n<p><a id=\"DEP0127\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The previously undocumented <code>timers.active()</code> is deprecated.\nPlease use the publicly documented <a href=\"timers.html#timers_timeout_refresh\"><code>timeout.refresh()</code></a> instead.\nIf re-referencing the timeout is necessary, <a href=\"timers.html#timers_timeout_ref\"><code>timeout.ref()</code></a> can be used\nwith no performance impact since Node.js 10.</p>",
               "type": "module",
               "displayName": "DEP0126: `timers.active()`"
             },
@@ -7875,7 +8049,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The previously undocumented and \"private\" <code>timers._unrefActive()</code> is deprecated.\nPlease use the publicly documented <a href=\"timers.html#timers_timeout_refresh\"><code>timeout.refresh()</code></a> instead.\nIf unreferencing the timeout is necessary, <a href=\"timers.html#timers_timeout_unref\"><code>timeout.unref()</code></a> can be used\nwith no performance impact since Node.js 10.</p>\n<p><a id=\"DEP0128\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The previously undocumented and \"private\" <code>timers._unrefActive()</code> is deprecated.\nPlease use the publicly documented <a href=\"timers.html#timers_timeout_refresh\"><code>timeout.refresh()</code></a> instead.\nIf unreferencing the timeout is necessary, <a href=\"timers.html#timers_timeout_unref\"><code>timeout.unref()</code></a> can be used\nwith no performance impact since Node.js 10.</p>",
               "type": "module",
               "displayName": "DEP0127: `timers._unrefActive()`"
             },
@@ -7891,7 +8065,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Modules that have an invalid <code>main</code> entry (e.g., <code>./does-not-exist.js</code>) and\nalso have an <code>index.js</code> file in the top level directory will resolve the\n<code>index.js</code> file. That is deprecated and is going to throw an error in future\nNode.js versions.</p>\n<p><a id=\"DEP0129\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Modules that have an invalid <code>main</code> entry (e.g., <code>./does-not-exist.js</code>) and\nalso have an <code>index.js</code> file in the top level directory will resolve the\n<code>index.js</code> file. That is deprecated and is going to throw an error in future\nNode.js versions.</p>",
               "type": "module",
               "displayName": "DEP0128: modules with an invalid `main` entry and an `index.js` file"
             },
@@ -7900,6 +8074,11 @@
               "name": "dep0129:_`childprocess._channel`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27949",
+                    "description": "Runtime deprecation."
+                  },
                   {
                     "version": "v11.14.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26982",
@@ -7907,7 +8086,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>_channel</code> property of child process objects returned by <code>spawn()</code> and\nsimilar functions is not intended for public use. Use <code>ChildProcess.channel</code>\ninstead.</p>\n<p><a id=\"DEP0130\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>_channel</code> property of child process objects returned by <code>spawn()</code> and\nsimilar functions is not intended for public use. Use <code>ChildProcess.channel</code>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0129: `ChildProcess._channel`"
             },
@@ -7916,6 +8095,11 @@
               "name": "dep0130:_`module.createrequirefrompath()`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27951",
+                    "description": "Runtime deprecation."
+                  },
                   {
                     "version": "v12.2.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27405",
@@ -7923,7 +8107,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>Module.createRequireFromPath() is deprecated. Please use <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a> instead.</p>\n<p><a id=\"DEP0131\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Module.createRequireFromPath() is deprecated. Please use\n<a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0130: `Module.createRequireFromPath()`"
             },
@@ -7933,9 +8117,9 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "v12.22.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/37603",
-                    "description": "Runtime deprecation."
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29589",
+                    "description": "This feature has been removed."
                   },
                   {
                     "version": "v12.3.0",
@@ -7944,7 +8128,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The legacy HTTP parser, used by default in versions of Node.js prior to 12.0.0,\nis deprecated. This deprecation applies to users of the\n<a href=\"cli.html#cli_http_parser_library\"><code>--http-parser=legacy</code></a> command-line flag.</p>\n<p><a id=\"DEP0132\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The legacy HTTP parser, used by default in versions of Node.js prior to 12.0.0,\nis deprecated and has been removed in v13.0.0. Prior to v13.0.0, the\n<code>--http-parser=legacy</code> command-line flag could be used to revert to using the\nlegacy parser.</p>",
               "type": "module",
               "displayName": "DEP0131: Legacy HTTP parser"
             },
@@ -7960,7 +8144,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Passing a callback to <a href=\"worker_threads.html#worker_threads_worker_terminate\"><code>worker.terminate()</code></a> is deprecated. Use the returned\n<code>Promise</code> instead, or a listener to the worker’s <code>'exit'</code> event.</p>\n<p><a id=\"DEP0133\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Passing a callback to <a href=\"worker_threads.html#worker_threads_worker_terminate\"><code>worker.terminate()</code></a> is deprecated. Use the returned\n<code>Promise</code> instead, or a listener to the worker’s <code>'exit'</code> event.</p>",
               "type": "module",
               "displayName": "DEP0132: `worker.terminate()` with callback"
             },
@@ -7976,7 +8160,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>Prefer <a href=\"http.html#http_response_socket\"><code>response.socket</code></a> over <a href=\"http.html#http_response_connection\"><code>response.connection</code></a> and\n<a href=\"http.html#http_request_socket\"><code>request.socket</code></a> over <a href=\"http.html#http_request_connection\"><code>request.connection</code></a>.</p>\n<p><a id=\"DEP0134\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>Prefer <a href=\"http.html#http_response_socket\"><code>response.socket</code></a> over <a href=\"http.html#http_response_connection\"><code>response.connection</code></a> and\n<a href=\"http.html#http_request_socket\"><code>request.socket</code></a> over <a href=\"http.html#http_request_connection\"><code>request.connection</code></a>.</p>",
               "type": "module",
               "displayName": "DEP0133: `http` `connection`"
             },
@@ -7992,26 +8176,77 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>process._tickCallback</code> property was never documented as\nan officially supported API.</p>\n<p><a id=\"DEP0136\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>process._tickCallback</code> property was never documented as\nan officially supported API.</p>",
               "type": "module",
               "displayName": "DEP0134: `process._tickCallback`"
             },
+            {
+              "textRaw": "DEP0135: `WriteStream.open()` and `ReadStream.open()` are internal",
+              "name": "dep0135:_`writestream.open()`_and_`readstream.open()`_are_internal",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29061",
+                    "description": "Runtime deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Runtime</p>\n<p><a href=\"fs.html#fs_class_fs_writestream\"><code>WriteStream.open()</code></a> and <a href=\"fs.html#fs_class_fs_readstream\"><code>ReadStream.open()</code></a> are undocumented internal\nAPIs that do not make sense to use in userland. File streams should always be\nopened through their corresponding factory methods <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>\nand <a href=\"fs.html#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a>) or by passing a file descriptor in options.</p>",
+              "type": "module",
+              "displayName": "DEP0135: `WriteStream.open()` and `ReadStream.open()` are internal"
+            },
             {
               "textRaw": "DEP0136: `http` `finished`",
               "name": "dep0136:_`http`_`finished`",
               "meta": {
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.4.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/28679",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p><a href=\"http.html#http_response_finished\"><code>response.finished</code></a> indicates whether <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> has been\ncalled, not whether <code>'finish'</code> has been emitted and the underlying data\nis flushed.</p>\n<p>Use <a href=\"http.html#http_response_writablefinished\"><code>response.writableFinished</code></a> or <a href=\"http.html#http_response_writableended\"><code>response.writableEnded</code></a>\naccordingly instead to avoid the ambigiuty.</p>\n<p>To maintain existing behaviour <code>response.finished</code> should be replaced with\n<code>response.writableEnded</code>.</p>\n<p><a id=\"DEP0139\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p><a href=\"http.html#http_response_finished\"><code>response.finished</code></a> indicates whether <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> has been\ncalled, not whether <code>'finish'</code> has been emitted and the underlying data\nis flushed.</p>\n<p>Use <a href=\"http.html#http_response_writablefinished\"><code>response.writableFinished</code></a> or <a href=\"http.html#http_response_writableended\"><code>response.writableEnded</code></a>\naccordingly instead to avoid the ambiguity.</p>\n<p>To maintain existing behaviour <code>response.finished</code> should be replaced with\n<code>response.writableEnded</code>.</p>",
               "type": "module",
               "displayName": "DEP0136: `http` `finished`"
             },
+            {
+              "textRaw": "DEP0137: Closing fs.FileHandle on garbage collection",
+              "name": "dep0137:_closing_fs.filehandle_on_garbage_collection",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/28396",
+                    "description": "Runtime deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Runtime</p>\n<p>Allowing a <a href=\"fs.html#fs_class_filehandle\"><code>fs.FileHandle</code></a> object to be closed on garbage collection is\ndeprecated. In the future, doing so might result in a thrown error that will\nterminate the process.</p>\n<p>Please ensure that all <code>fs.FileHandle</code> objects are explicitly closed using\n<code>FileHandle.prototype.close()</code> when the <code>fs.FileHandle</code> is no longer needed:</p>\n<pre><code class=\"language-js\">const fsPromises = require('fs').promises;\nasync function openAndClose() {\n  let filehandle;\n  try {\n    filehandle = await fsPromises.open('thefile.txt', 'r');\n  } finally {\n    if (filehandle !== undefined)\n      await filehandle.close();\n  }\n}\n</code></pre>",
+              "type": "module",
+              "displayName": "DEP0137: Closing fs.FileHandle on garbage collection"
+            },
+            {
+              "textRaw": "DEP0138: `process.mainModule`",
+              "name": "dep0138:_`process.mainmodule`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32232",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p><a href=\"process.html#process_process_mainmodule\"><code>process.mainModule</code></a> is a CommonJS-only feature while <code>process</code> global\nobject is shared with non-CommonJS environment. Its use within ECMAScript\nmodules is unsupported.</p>\n<p>It is deprecated in favor of <a href=\"modules.html#modules_accessing_the_main_module\"><code>require.main</code></a>, because it serves the same\npurpose and is only available on CommonJS environment.</p>",
+              "type": "module",
+              "displayName": "DEP0138: `process.mainModule`"
+            },
             {
               "textRaw": "DEP0139: `process.umask()` with no arguments",
               "name": "dep0139:_`process.umask()`_with_no_arguments",
@@ -8019,18 +8254,85 @@
                 "changes": [
                   {
                     "version": [
-                      "v12.19.0",
-                      "v14.0.0"
+                      "v14.0.0",
+                      "v12.19.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/32499",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>Calling <code>process.umask()</code> with no argument causes the process-wide umask to be\nwritten twice. This introduces a race condition between threads, and is a\npotential security vulnerability. There is no safe, cross-platform alternative\nAPI.</p>\n<p><a id=\"DEP0144\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>Calling <code>process.umask()</code> with no argument causes the process-wide umask to be\nwritten twice. This introduces a race condition between threads, and is a\npotential security vulnerability. There is no safe, cross-platform alternative\nAPI.</p>",
               "type": "module",
               "displayName": "DEP0139: `process.umask()` with no arguments"
             },
+            {
+              "textRaw": "DEP0140: Use `request.destroy()` instead of `request.abort()`",
+              "name": "dep0140:_use_`request.destroy()`_instead_of_`request.abort()`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": [
+                      "v14.1.0",
+                      "v13.14.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/32807",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p>Use <a href=\"http.html#http_request_destroy_error\"><code>request.destroy()</code></a> instead of <a href=\"http.html#http_request_abort\"><code>request.abort()</code></a>.</p>",
+              "type": "module",
+              "displayName": "DEP0140: Use `request.destroy()` instead of `request.abort()`"
+            },
+            {
+              "textRaw": "DEP0141: `repl.inputStream` and `repl.outputStream`",
+              "name": "dep0141:_`repl.inputstream`_and_`repl.outputstream`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33294",
+                    "description": "Documentation-only (supports [`--pending-deprecation`][])."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>repl</code> module exported the input and output stream twice. Use <code>.input</code>\ninstead of <code>.inputStream</code> and <code>.output</code> instead of <code>.outputStream</code>.</p>",
+              "type": "module",
+              "displayName": "DEP0141: `repl.inputStream` and `repl.outputStream`"
+            },
+            {
+              "textRaw": "DEP0142: `repl._builtinLibs`",
+              "name": "dep0142:_`repl._builtinlibs`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33294",
+                    "description": "Documentation-only (supports [`--pending-deprecation`][])."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>repl</code> module exports a <code>_builtinLibs</code> property that contains an array with\nnative modules. It was incomplete so far and instead it's better to rely upon\n<code>require('module').builtinModules</code>.</p>",
+              "type": "module",
+              "displayName": "DEP0142: `repl._builtinLibs`"
+            },
+            {
+              "textRaw": "DEP0143: `Transform._transformState`",
+              "name": "dep0143:_`transform._transformstate`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33126",
+                    "description": "Runtime deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Runtime\n<code>Transform._transformState</code> will be removed in future versions where it is\nno longer required due to simplification of the implementation.</p>",
+              "type": "module",
+              "displayName": "DEP0143: `Transform._transformState`"
+            },
             {
               "textRaw": "DEP0144: `module.parent`",
               "name": "dep0144:_`module.parent`",
@@ -8038,8 +8340,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v12.19.0",
-                      "v14.6.0"
+                      "v14.6.0",
+                      "v12.19.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/32217",
                     "description": "Documentation-only deprecation."
@@ -8049,12 +8351,77 @@
               "desc": "<p>Type: Documentation-only</p>\n<p>A CommonJS module can access the first module that required it using\n<code>module.parent</code>. This feature is deprecated because it does not work\nconsistently in the presence of ECMAScript modules and because it gives an\ninaccurate representation of the CommonJS module graph.</p>\n<p>Some modules use it to check if they are the entry point of the current process.\nInstead, it is recommended to compare <code>require.main</code> and <code>module</code>:</p>\n<pre><code class=\"language-js\">if (require.main === module) {\n  // Code section that will run only if current file is the entry point.\n}\n</code></pre>\n<p>When looking for the CommonJS modules that have required the current one,\n<code>require.cache</code> and <code>module.children</code> can be used:</p>\n<pre><code class=\"language-js\">const moduleParents = Object.values(require.cache)\n  .filter((m) => m.children.includes(module));\n</code></pre>",
               "type": "module",
               "displayName": "DEP0144: `module.parent`"
+            },
+            {
+              "textRaw": "DEP0145: `socket.bufferSize`",
+              "name": "dep0145:_`socket.buffersize`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34088",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p><a href=\"net.html#net_socket_buffersize\"><code>socket.bufferSize</code></a> is just an alias for <a href=\"stream.html#stream_writable_writablelength\"><code>writable.writableLength</code></a>.</p>",
+              "type": "module",
+              "displayName": "DEP0145: `socket.bufferSize`"
+            },
+            {
+              "textRaw": "DEP0146: `new crypto.Certificate()`",
+              "name": "dep0146:_`new_crypto.certificate()`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.9.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34697",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_legacy_api\"><code>crypto.Certificate()</code> constructor</a> is deprecated. Use\n<a href=\"crypto.html#crypto_class_certificate\">static methods of <code>crypto.Certificate()</code></a> instead.</p>",
+              "type": "module",
+              "displayName": "DEP0146: `new crypto.Certificate()`"
+            },
+            {
+              "textRaw": "DEP0147: `fs.rmdir(path, { recursive: true })`",
+              "name": "dep0147:_`fs.rmdir(path,_{_recursive:_true_})`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35579",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p>In future versions of Node.js, <code>fs.rmdir(path, { recursive: true })</code> will throw\non nonexistent paths, or when given a file as a target.\nUse <code>fs.rm(path, { recursive: true, force: true })</code> instead.</p>",
+              "type": "module",
+              "displayName": "DEP0147: `fs.rmdir(path, { recursive: true })`"
+            },
+            {
+              "textRaw": "DEP0151: Main index lookup and extension searching",
+              "name": "dep0151:_main_index_lookup_and_extension_searching",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36918",
+                    "description": "Documentation-only deprecation with `--pending-deprecation` support."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Previously, <code>index.js</code> and extension searching lookups would apply to\n<code>import 'pkg'</code> main entry point resolution, even when resolving ES modules.</p>\n<p>With this deprecation, all ES module main entry point resolutions require\nan explicit <a href=\"packages.html#packages_main_entry_point_export\"><code>\"exports\"</code> or <code>\"main\"</code> entry</a> with the exact file extension.</p>",
+              "type": "module",
+              "displayName": "DEP0151: Main index lookup and extension searching"
             }
           ],
           "type": "misc",
           "displayName": "List of deprecated APIs"
         }
-      ]
+      ],
+      "source": "doc/api/deprecations.md"
     },
     {
       "textRaw": "Errors",
@@ -8115,8 +8482,21 @@
         {
           "textRaw": "Node.js error codes",
           "name": "node.js_error_codes",
-          "desc": "<p><a id=\"ERR_AMBIGUOUS_ARGUMENT\"></a></p>",
+          "desc": "<p><a id=\"ABORT_ERR\"></a></p>",
           "modules": [
+            {
+              "textRaw": "`ABORT_ERR`",
+              "name": "`abort_err`",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Used when an operation has been aborted (typically using an <code>AbortController</code>).</p>\n<p>APIs <em>not</em> using <code>AbortSignal</code>s typically do not raise an error with this code.</p>\n<p>This code does not use the regular <code>ERR_*</code> convention Node.js errors use in\norder to be compatible with the web platform's <code>AbortError</code>.</p>\n<p><a id=\"ERR_AMBIGUOUS_ARGUMENT\"></a></p>",
+              "type": "module",
+              "displayName": "`ABORT_ERR`"
+            },
             {
               "textRaw": "`ERR_AMBIGUOUS_ARGUMENT`",
               "name": "`err_ambiguous_argument`",
@@ -8211,30 +8591,44 @@
             {
               "textRaw": "`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`",
               "name": "`err_child_process_stdio_maxbuffer`",
-              "desc": "<p>Used when the main process is trying to read data from the child process's\nSTDERR/STDOUT, and the data's length is longer than the <code>maxBuffer</code> option.</p>\n<p><a id=\"ERR_CONSOLE_WRITABLE_STREAM\"></a></p>",
+              "desc": "<p>Used when the main process is trying to read data from the child process's\nSTDERR/STDOUT, and the data's length is longer than the <code>maxBuffer</code> option.</p>\n<p><a id=\"ERR_CLOSED_MESSAGE_PORT\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`"
             },
+            {
+              "textRaw": "`ERR_CLOSED_MESSAGE_PORT`",
+              "name": "`err_closed_message_port`",
+              "desc": "<!--\nadded: v14.17.1\nchanges:\n  - version: 11.12.0\n    pr-url: https://github.com/nodejs/node/pull/26487\n    description: The error message was removed.\n  - version: v14.17.1\n    pr-url: https://github.com/nodejs/node/pull/38510\n    description: The error message was reintroduced.\n-->\n<p>There was an attempt to use a <code>MessagePort</code> instance in a closed\nstate, usually after <code>.close()</code> has been called.</p>\n<p><a id=\"ERR_CONSOLE_WRITABLE_STREAM\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_CLOSED_MESSAGE_PORT`"
+            },
             {
               "textRaw": "`ERR_CONSOLE_WRITABLE_STREAM`",
               "name": "`err_console_writable_stream`",
-              "desc": "<p><code>Console</code> was instantiated without <code>stdout</code> stream, or <code>Console</code> has a\nnon-writable <code>stdout</code> or <code>stderr</code> stream.</p>\n<p><a id=\"ERR_CONSTRUCT_CALL_REQUIRED\"></a></p>",
+              "desc": "<p><code>Console</code> was instantiated without <code>stdout</code> stream, or <code>Console</code> has a\nnon-writable <code>stdout</code> or <code>stderr</code> stream.</p>\n<p><a id=\"ERR_CONSTRUCT_CALL_INVALID\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CONSOLE_WRITABLE_STREAM`"
             },
+            {
+              "textRaw": "`ERR_CONSTRUCT_CALL_INVALID`",
+              "name": "`err_construct_call_invalid`",
+              "desc": "<!--\nadded: v12.5.0\n-->\n<p>A class constructor was called that is not callable.</p>\n<p><a id=\"ERR_CONSTRUCT_CALL_REQUIRED\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_CONSTRUCT_CALL_INVALID`"
+            },
             {
               "textRaw": "`ERR_CONSTRUCT_CALL_REQUIRED`",
               "name": "`err_construct_call_required`",
-              "desc": "<p>A constructor for a class was called without <code>new</code>.</p>\n<p><a id=\"ERR_CONSTRUCT_CALL_INVALID\"></a></p>",
+              "desc": "<p>A constructor for a class was called without <code>new</code>.</p>\n<p><a id=\"ERR_CONTEXT_NOT_INITIALIZED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CONSTRUCT_CALL_REQUIRED`"
             },
             {
-              "textRaw": "`ERR_CONSTRUCT_CALL_INVALID`",
-              "name": "`err_construct_call_invalid`",
-              "desc": "<!--\nadded: v12.5.0\n-->\n<p>A class constructor was called that is not callable.</p>\n<p><a id=\"ERR_CPU_USAGE\"></a></p>",
+              "textRaw": "`ERR_CONTEXT_NOT_INITIALIZED`",
+              "name": "`err_context_not_initialized`",
+              "desc": "<p>The vm context passed into the API is not yet initialized. This could happen\nwhen an error occurs (and is caught) during the creation of the\ncontext, for example, when the allocation fails or the maximum call stack\nsize is reached when the context is created.</p>\n<p><a id=\"ERR_CPU_USAGE\"></a></p>",
               "type": "module",
-              "displayName": "`ERR_CONSTRUCT_CALL_INVALID`"
+              "displayName": "`ERR_CONTEXT_NOT_INITIALIZED`"
             },
             {
               "textRaw": "`ERR_CPU_USAGE`",
@@ -8379,10 +8773,49 @@
             {
               "textRaw": "`ERR_CRYPTO_UNKNOWN_DH_GROUP`",
               "name": "`err_crypto_unknown_dh_group`",
-              "desc": "<p>An unknown Diffie-Hellman group name was given. See\n<a href=\"crypto.html#crypto_crypto_getdiffiehellman_groupname\"><code>crypto.getDiffieHellman()</code></a> for a list of valid group names.</p>\n<p><a id=\"ERR_DIR_CLOSED\"></a></p>",
+              "desc": "<p>An unknown Diffie-Hellman group name was given. See\n<a href=\"crypto.html#crypto_crypto_getdiffiehellman_groupname\"><code>crypto.getDiffieHellman()</code></a> for a list of valid group names.</p>\n<p><a id=\"ERR_DLOPEN_FAILED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CRYPTO_UNKNOWN_DH_GROUP`"
             },
+            {
+              "textRaw": "`ERR_DLOPEN_FAILED`",
+              "name": "`err_dlopen_failed`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>A call to <code>process.dlopen()</code> failed.</p>\n<p><a id=\"ERR_DEBUGGER_ERROR\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_DLOPEN_FAILED`"
+            },
+            {
+              "textRaw": "`ERR_DEBUGGER_ERROR`",
+              "name": "`err_debugger_error`",
+              "meta": {
+                "added": [
+                  "v14.17.4"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An error occurred with the <a href=\"debugger.html\">debugger</a>.</p>\n<p><a id=\"ERR_DEBUGGER_STARTUP_ERROR\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_DEBUGGER_ERROR`"
+            },
+            {
+              "textRaw": "`ERR_DEBUGGER_STARTUP_ERROR`",
+              "name": "`err_debugger_startup_error`",
+              "meta": {
+                "added": [
+                  "v14.17.4"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The <a href=\"debugger.html\">debugger</a> timed out waiting for the required host/port to be free.</p>\n<p><a id=\"ERR_DIR_CLOSED\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_DEBUGGER_STARTUP_ERROR`"
+            },
             {
               "textRaw": "`ERR_DIR_CLOSED`",
               "name": "`err_dir_closed`",
@@ -8395,7 +8828,7 @@
               "name": "`err_dir_concurrent_operation`",
               "meta": {
                 "added": [
-                  "v12.18.1"
+                  "v14.3.0"
                 ],
                 "changes": []
               },
@@ -8434,10 +8867,24 @@
             {
               "textRaw": "`ERR_ENCODING_NOT_SUPPORTED`",
               "name": "`err_encoding_not_supported`",
-              "desc": "<p>Encoding provided to <code>TextDecoder()</code> API was not one of the\n<a href=\"util.html#util_whatwg_supported_encodings\">WHATWG Supported Encodings</a>.</p>\n<p><a id=\"ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE\"></a></p>",
+              "desc": "<p>Encoding provided to <code>TextDecoder()</code> API was not one of the\n<a href=\"util.html#util_whatwg_supported_encodings\">WHATWG Supported Encodings</a>.</p>\n<p><a id=\"ERR_EVAL_ESM_CANNOT_PRINT\"></a></p>",
               "type": "module",
               "displayName": "`ERR_ENCODING_NOT_SUPPORTED`"
             },
+            {
+              "textRaw": "`ERR_EVAL_ESM_CANNOT_PRINT`",
+              "name": "`err_eval_esm_cannot_print`",
+              "desc": "<p><code>--print</code> cannot be used with ESM input.</p>\n<p><a id=\"ERR_EVENT_RECURSION\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_EVAL_ESM_CANNOT_PRINT`"
+            },
+            {
+              "textRaw": "`ERR_EVENT_RECURSION`",
+              "name": "`err_event_recursion`",
+              "desc": "<p>Thrown when an attempt is made to recursively dispatch an event on <code>EventTarget</code>.</p>\n<p><a id=\"ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_EVENT_RECURSION`"
+            },
             {
               "textRaw": "`ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`",
               "name": "`err_execution_environment_not_available`",
@@ -8448,10 +8895,30 @@
             {
               "textRaw": "`ERR_FALSY_VALUE_REJECTION`",
               "name": "`err_falsy_value_rejection`",
-              "desc": "<p>A <code>Promise</code> that was callbackified via <code>util.callbackify()</code> was rejected with a\nfalsy value.</p>\n<p><a id=\"ERR_FS_FILE_TOO_LARGE\"></a></p>",
+              "desc": "<p>A <code>Promise</code> that was callbackified via <code>util.callbackify()</code> was rejected with a\nfalsy value.</p>\n<p><a id=\"ERR_FEATURE_UNAVAILABLE_ON_PLATFORM\"></a></p>",
               "type": "module",
               "displayName": "`ERR_FALSY_VALUE_REJECTION`"
             },
+            {
+              "textRaw": "`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`",
+              "name": "`err_feature_unavailable_on_platform`",
+              "meta": {
+                "added": [
+                  "v14.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Used when a feature that is not available\nto the current platform which is running Node.js is used.</p>\n<p><a id=\"ERR_FS_EISDIR\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`"
+            },
+            {
+              "textRaw": "`ERR_FS_EISDIR`",
+              "name": "`err_fs_eisdir`",
+              "desc": "<p>Path is a directory.</p>\n<p><a id=\"ERR_FS_FILE_TOO_LARGE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_FS_EISDIR`"
+            },
             {
               "textRaw": "`ERR_FS_FILE_TOO_LARGE`",
               "name": "`err_fs_file_too_large`",
@@ -8539,10 +9006,17 @@
             {
               "textRaw": "`ERR_HTTP2_GOAWAY_SESSION`",
               "name": "`err_http2_goaway_session`",
-              "desc": "<p>New HTTP/2 Streams may not be opened after the <code>Http2Session</code> has received a\n<code>GOAWAY</code> frame from the connected peer.</p>\n<p><a id=\"ERR_HTTP2_HEADERS_AFTER_RESPOND\"></a></p>",
+              "desc": "<p>New HTTP/2 Streams may not be opened after the <code>Http2Session</code> has received a\n<code>GOAWAY</code> frame from the connected peer.</p>\n<p><a id=\"ERR_HTTP2_HEADER_SINGLE_VALUE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP2_GOAWAY_SESSION`"
             },
+            {
+              "textRaw": "`ERR_HTTP2_HEADER_SINGLE_VALUE`",
+              "name": "`err_http2_header_single_value`",
+              "desc": "<p>Multiple values were provided for an HTTP/2 header field that was required to\nhave only a single value.</p>\n<p><a id=\"ERR_HTTP2_HEADERS_AFTER_RESPOND\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_HTTP2_HEADER_SINGLE_VALUE`"
+            },
             {
               "textRaw": "`ERR_HTTP2_HEADERS_AFTER_RESPOND`",
               "name": "`err_http2_headers_after_respond`",
@@ -8553,17 +9027,10 @@
             {
               "textRaw": "`ERR_HTTP2_HEADERS_SENT`",
               "name": "`err_http2_headers_sent`",
-              "desc": "<p>An attempt was made to send multiple response headers.</p>\n<p><a id=\"ERR_HTTP2_HEADER_SINGLE_VALUE\"></a></p>",
+              "desc": "<p>An attempt was made to send multiple response headers.</p>\n<p><a id=\"ERR_HTTP2_INFO_STATUS_NOT_ALLOWED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP2_HEADERS_SENT`"
             },
-            {
-              "textRaw": "`ERR_HTTP2_HEADER_SINGLE_VALUE`",
-              "name": "`err_http2_header_single_value`",
-              "desc": "<p>Multiple values were provided for an HTTP/2 header field that was required to\nhave only a single value.</p>\n<p><a id=\"ERR_HTTP2_INFO_STATUS_NOT_ALLOWED\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_HTTP2_HEADER_SINGLE_VALUE`"
-            },
             {
               "textRaw": "`ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`",
               "name": "`err_http2_info_status_not_allowed`",
@@ -8644,10 +9111,17 @@
             {
               "textRaw": "`ERR_HTTP2_NESTED_PUSH`",
               "name": "`err_http2_nested_push`",
-              "desc": "<p>An attempt was made to initiate a new push stream from within a push stream.\nNested push streams are not permitted.</p>\n<p><a id=\"ERR_HTTP2_NO_SOCKET_MANIPULATION\"></a></p>",
+              "desc": "<p>An attempt was made to initiate a new push stream from within a push stream.\nNested push streams are not permitted.</p>\n<p><a id=\"ERR_HTTP2_NO_MEM\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP2_NESTED_PUSH`"
             },
+            {
+              "textRaw": "`ERR_HTTP2_NO_MEM`",
+              "name": "`err_http2_no_mem`",
+              "desc": "<p>Out of memory when using the <code>http2session.setLocalWindowSize(windowSize)</code> API.</p>\n<p><a id=\"ERR_HTTP2_NO_SOCKET_MANIPULATION\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_HTTP2_NO_MEM`"
+            },
             {
               "textRaw": "`ERR_HTTP2_NO_SOCKET_MANIPULATION`",
               "name": "`err_http2_no_socket_manipulation`",
@@ -8798,17 +9272,10 @@
             {
               "textRaw": "`ERR_HTTP2_UNSUPPORTED_PROTOCOL`",
               "name": "`err_http2_unsupported_protocol`",
-              "desc": "<p><code>http2.connect()</code> was passed a URL that uses any protocol other than <code>http:</code> or\n<code>https:</code>.</p>\n<p><a id=\"ERR_INTERNAL_ASSERTION\"></a></p>",
+              "desc": "<p><code>http2.connect()</code> was passed a URL that uses any protocol other than <code>http:</code> or\n<code>https:</code>.</p>\n<p><a id=\"ERR_INCOMPATIBLE_OPTION_PAIR\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP2_UNSUPPORTED_PROTOCOL`"
             },
-            {
-              "textRaw": "`ERR_INTERNAL_ASSERTION`",
-              "name": "`err_internal_assertion`",
-              "desc": "<p>There was a bug in Node.js or incorrect usage of Node.js internals.\nTo fix the error, open an issue at <a href=\"https://github.com/nodejs/node/issues\">https://github.com/nodejs/node/issues</a>.</p>\n<p><a id=\"ERR_INCOMPATIBLE_OPTION_PAIR\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_INTERNAL_ASSERTION`"
-            },
             {
               "textRaw": "`ERR_INCOMPATIBLE_OPTION_PAIR`",
               "name": "`err_incompatible_option_pair`",
@@ -8877,10 +9344,17 @@
             {
               "textRaw": "`ERR_INSPECTOR_NOT_WORKER`",
               "name": "`err_inspector_not_worker`",
-              "desc": "<p>An API was called on the main thread that can only be used from\nthe worker thread.</p>\n<p><a id=\"ERR_INVALID_ADDRESS_FAMILY\"></a></p>",
+              "desc": "<p>An API was called on the main thread that can only be used from\nthe worker thread.</p>\n<p><a id=\"ERR_INTERNAL_ASSERTION\"></a></p>",
               "type": "module",
               "displayName": "`ERR_INSPECTOR_NOT_WORKER`"
             },
+            {
+              "textRaw": "`ERR_INTERNAL_ASSERTION`",
+              "name": "`err_internal_assertion`",
+              "desc": "<p>There was a bug in Node.js or incorrect usage of Node.js internals.\nTo fix the error, open an issue at <a href=\"https://github.com/nodejs/node/issues\">https://github.com/nodejs/node/issues</a>.</p>\n<p><a id=\"ERR_INVALID_ADDRESS_FAMILY\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_INTERNAL_ASSERTION`"
+            },
             {
               "textRaw": "`ERR_INVALID_ADDRESS_FAMILY`",
               "name": "`err_invalid_address_family`",
@@ -8982,10 +9456,23 @@
             {
               "textRaw": "`ERR_INVALID_IP_ADDRESS`",
               "name": "`err_invalid_ip_address`",
-              "desc": "<p>An IP address is not valid.</p>\n<p><a id=\"ERR_INVALID_MODULE_SPECIFIER\"></a></p>",
+              "desc": "<p>An IP address is not valid.</p>\n<p><a id=\"ERR_INVALID_MODULE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_INVALID_IP_ADDRESS`"
             },
+            {
+              "textRaw": "`ERR_INVALID_MODULE`",
+              "name": "`err_invalid_module`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An attempt was made to load a module that does not exist or was otherwise not\nvalid.</p>\n<p><a id=\"ERR_INVALID_MODULE_SPECIFIER\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_INVALID_MODULE`"
+            },
             {
               "textRaw": "`ERR_INVALID_MODULE_SPECIFIER`",
               "name": "`err_invalid_module_specifier`",
@@ -9045,7 +9532,7 @@
             {
               "textRaw": "`ERR_INVALID_REPL_INPUT`",
               "name": "`err_invalid_repl_input`",
-              "desc": "<p>The input may not be used in the <a href=\"repl.html\"><code>REPL</code></a>. All prohibited inputs are\ndocumented in the <a href=\"repl.html\"><code>REPL</code></a>'s documentation.</p>\n<p><a id=\"ERR_INVALID_RETURN_PROPERTY\"></a></p>",
+              "desc": "<p>The input may not be used in the <a href=\"repl.html\"><code>REPL</code></a>. The conditions under which this\nerror is used are described in the <a href=\"repl.html\"><code>REPL</code></a> documentation.</p>\n<p><a id=\"ERR_INVALID_RETURN_PROPERTY\"></a></p>",
               "type": "module",
               "displayName": "`ERR_INVALID_REPL_INPUT`"
             },
@@ -9171,10 +9658,17 @@
             {
               "textRaw": "`ERR_MANIFEST_INVALID_RESOURCE_FIELD`",
               "name": "`err_manifest_invalid_resource_field`",
-              "desc": "<p>A policy manifest resource had an invalid value for one of its fields. Update\nthe manifest entry to match in order to resolve this error. See the\ndocumentation for <a href=\"policy.html\">policy</a> manifests for more information.</p>\n<p><a id=\"ERR_MANIFEST_PARSE_POLICY\"></a></p>",
+              "desc": "<p>A policy manifest resource had an invalid value for one of its fields. Update\nthe manifest entry to match in order to resolve this error. See the\ndocumentation for <a href=\"policy.html\">policy</a> manifests for more information.</p>\n<p><a id=\"ERR_MANIFEST_INVALID_SPECIFIER\"></a></p>",
               "type": "module",
               "displayName": "`ERR_MANIFEST_INVALID_RESOURCE_FIELD`"
             },
+            {
+              "textRaw": "`ERR_MANIFEST_INVALID_SPECIFIER`",
+              "name": "`err_manifest_invalid_specifier`",
+              "desc": "<p>A policy manifest resource had an invalid value for one of its dependency\nmappings. Update the manifest entry to match to resolve this error. See the\ndocumentation for <a href=\"policy.html\">policy</a> manifests for more information.</p>\n<p><a id=\"ERR_MANIFEST_PARSE_POLICY\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_MANIFEST_INVALID_SPECIFIER`"
+            },
             {
               "textRaw": "`ERR_MANIFEST_PARSE_POLICY`",
               "name": "`err_manifest_parse_policy`",
@@ -9208,7 +9702,7 @@
               "name": "`err_message_target_context_unavailable`",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -9226,33 +9720,24 @@
             {
               "textRaw": "`ERR_MISSING_ARGS`",
               "name": "`err_missing_args`",
-              "desc": "<p>A required argument of a Node.js API was not passed. This is only used for\nstrict compliance with the API specification (which in some cases may accept\n<code>func(undefined)</code> but not <code>func()</code>). In most native Node.js APIs,\n<code>func(undefined)</code> and <code>func()</code> are treated identically, and the\n<a href=\"errors.html#ERR_INVALID_ARG_TYPE\"><code>ERR_INVALID_ARG_TYPE</code></a> error code may be used instead.</p>\n<p><a id=\"ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK\"></a></p>",
+              "desc": "<p>A required argument of a Node.js API was not passed. This is only used for\nstrict compliance with the API specification (which in some cases may accept\n<code>func(undefined)</code> but not <code>func()</code>). In most native Node.js APIs,\n<code>func(undefined)</code> and <code>func()</code> are treated identically, and the\n<a href=\"errors.html#ERR_INVALID_ARG_TYPE\"><code>ERR_INVALID_ARG_TYPE</code></a> error code may be used instead.</p>\n<p><a id=\"ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST\"></a></p>",
               "type": "module",
               "displayName": "`ERR_MISSING_ARGS`"
             },
             {
-              "textRaw": "`ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK`",
-              "name": "`err_missing_dynamic_instantiate_hook`",
-              "stability": 1,
-              "stabilityText": "Experimental",
-              "desc": "<p>An <a href=\"esm.html\">ES Module</a> loader hook specified <code>format: 'dynamic'</code> but did not provide\na <code>dynamicInstantiate</code> hook.</p>\n<p><a id=\"ERR_MISSING_OPTION\"></a></p>",
+              "textRaw": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`",
+              "name": "`err_missing_message_port_in_transfer_list`",
+              "desc": "<p>An object that needs to be explicitly listed in the <code>transferList</code> argument\nis in the object passed to a <code>postMessage()</code> call, but is not provided\nin the <code>transferList</code> for that call. Usually, this is a <code>MessagePort</code>.</p>\n<p><a id=\"ERR_MISSING_OPTION\"></a></p>",
               "type": "module",
-              "displayName": "`ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK`"
+              "displayName": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`"
             },
             {
               "textRaw": "`ERR_MISSING_OPTION`",
               "name": "`err_missing_option`",
-              "desc": "<p>For APIs that accept options objects, some options might be mandatory. This code\nis thrown if a required option is missing.</p>\n<p><a id=\"ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST\"></a></p>",
+              "desc": "<p>For APIs that accept options objects, some options might be mandatory. This code\nis thrown if a required option is missing.</p>\n<p><a id=\"ERR_MISSING_PASSPHRASE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_MISSING_OPTION`"
             },
-            {
-              "textRaw": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`",
-              "name": "`err_missing_message_port_in_transfer_list`",
-              "desc": "<p>An object that needs to be explicitly listed in the <code>transferList</code> argument\nwas found in the object passed to a <code>postMessage()</code> call, but not provided in\nthe <code>transferList</code> for that call. Usually, this is a <code>MessagePort</code>.</p>\n<p><a id=\"ERR_MISSING_PASSPHRASE\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`"
-            },
             {
               "textRaw": "`ERR_MISSING_PASSPHRASE`",
               "name": "`err_missing_passphrase`",
@@ -9286,7 +9771,7 @@
             {
               "textRaw": "`ERR_NAPI_CONS_FUNCTION`",
               "name": "`err_napi_cons_function`",
-              "desc": "<p>While using <code>N-API</code>, a constructor passed was not a function.</p>\n<p><a id=\"ERR_NAPI_INVALID_DATAVIEW_ARGS\"></a></p>",
+              "desc": "<p>While using <code>Node-API</code>, a constructor passed was not a function.</p>\n<p><a id=\"ERR_NAPI_INVALID_DATAVIEW_ARGS\"></a></p>",
               "type": "module",
               "displayName": "`ERR_NAPI_CONS_FUNCTION`"
             },
@@ -9356,10 +9841,17 @@
             {
               "textRaw": "`ERR_NON_CONTEXT_AWARE_DISABLED`",
               "name": "`err_non_context_aware_disabled`",
-              "desc": "<p>A non-context-aware native addon was loaded in a process that disallows them.</p>\n<p><a id=\"ERR_OUT_OF_RANGE\"></a></p>",
+              "desc": "<p>A non-context-aware native addon was loaded in a process that disallows them.</p>\n<p><a id=\"ERR_OPERATION_FAILED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_NON_CONTEXT_AWARE_DISABLED`"
             },
+            {
+              "textRaw": "`ERR_OPERATION_FAILED`",
+              "name": "`err_operation_failed`",
+              "desc": "<p>An operation failed. This is typically used to signal the general failure of an\nasynchronous operation.</p>\n<p><a id=\"ERR_OUT_OF_RANGE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_OPERATION_FAILED`"
+            },
             {
               "textRaw": "`ERR_OUT_OF_RANGE`",
               "name": "`err_out_of_range`",
@@ -9456,17 +9948,10 @@
             {
               "textRaw": "`ERR_SOCKET_BUFFER_SIZE`",
               "name": "`err_socket_buffer_size`",
-              "desc": "<p>While using <a href=\"dgram.html#dgram_dgram_createsocket_options_callback\"><code>dgram.createSocket()</code></a>, the size of the receive or send <code>Buffer</code>\ncould not be determined.</p>\n<p><a id=\"ERR_SOCKET_CANNOT_SEND\"></a></p>",
+              "desc": "<p>While using <a href=\"dgram.html#dgram_dgram_createsocket_options_callback\"><code>dgram.createSocket()</code></a>, the size of the receive or send <code>Buffer</code>\ncould not be determined.</p>\n<p><a id=\"ERR_SOCKET_CLOSED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_SOCKET_BUFFER_SIZE`"
             },
-            {
-              "textRaw": "`ERR_SOCKET_CANNOT_SEND`",
-              "name": "`err_socket_cannot_send`",
-              "desc": "<p>Data could be sent on a socket.</p>\n<p><a id=\"ERR_SOCKET_CLOSED\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_SOCKET_CANNOT_SEND`"
-            },
             {
               "textRaw": "`ERR_SOCKET_CLOSED`",
               "name": "`err_socket_closed`",
@@ -9498,10 +9983,17 @@
             {
               "textRaw": "`ERR_SRI_PARSE`",
               "name": "`err_sri_parse`",
-              "desc": "<p>A string was provided for a Subresource Integrity check, but was unable to be\nparsed. Check the format of integrity attributes by looking at the\n<a href=\"https://www.w3.org/TR/SRI/#the-integrity-attribute\">Subresource Integrity specification</a>.</p>\n<p><a id=\"ERR_STREAM_CANNOT_PIPE\"></a></p>",
+              "desc": "<p>A string was provided for a Subresource Integrity check, but was unable to be\nparsed. Check the format of integrity attributes by looking at the\n<a href=\"https://www.w3.org/TR/SRI/#the-integrity-attribute\">Subresource Integrity specification</a>.</p>\n<p><a id=\"ERR_STREAM_ALREADY_FINISHED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_SRI_PARSE`"
             },
+            {
+              "textRaw": "`ERR_STREAM_ALREADY_FINISHED`",
+              "name": "`err_stream_already_finished`",
+              "desc": "<p>A stream method was called that cannot complete because the stream was\nfinished.</p>\n<p><a id=\"ERR_STREAM_CANNOT_PIPE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_STREAM_ALREADY_FINISHED`"
+            },
             {
               "textRaw": "`ERR_STREAM_CANNOT_PIPE`",
               "name": "`err_stream_cannot_pipe`",
@@ -9575,10 +10067,17 @@
             {
               "textRaw": "`ERR_SYSTEM_ERROR`",
               "name": "`err_system_error`",
-              "desc": "<p>An unspecified or non-specific system error has occurred within the Node.js\nprocess. The error object will have an <code>err.info</code> object property with\nadditional details.</p>\n<p><a id=\"ERR_TLS_CERT_ALTNAME_INVALID\"></a></p>",
+              "desc": "<p>An unspecified or non-specific system error has occurred within the Node.js\nprocess. The error object will have an <code>err.info</code> object property with\nadditional details.</p>\n<p><a id=\"ERR_TLS_CERT_ALTNAME_FORMAT\"></a></p>",
               "type": "module",
               "displayName": "`ERR_SYSTEM_ERROR`"
             },
+            {
+              "textRaw": "`ERR_TLS_CERT_ALTNAME_FORMAT`",
+              "name": "`err_tls_cert_altname_format`",
+              "desc": "<p>This error is thrown by <code>checkServerIdentity</code> if a user-supplied\n<code>subjectaltname</code> property violates encoding rules. Certificate objects produced\nby Node.js itself always comply with encoding rules and will never cause\nthis error.</p>\n<p><a id=\"ERR_TLS_CERT_ALTNAME_INVALID\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_TLS_CERT_ALTNAME_FORMAT`"
+            },
             {
               "textRaw": "`ERR_TLS_CERT_ALTNAME_INVALID`",
               "name": "`err_tls_cert_altname_invalid`",
@@ -9605,27 +10104,14 @@
               "name": "`err_tls_invalid_context`",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.3.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The context must be a <code>SecureContext</code>.</p>\n<p><a id=\"ERR_TLS_INVALID_STATE\"></a></p>",
+              "desc": "<p>The context must be a <code>SecureContext</code>.</p>\n<p><a id=\"ERR_TLS_INVALID_PROTOCOL_METHOD\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_INVALID_CONTEXT`"
             },
-            {
-              "textRaw": "`ERR_TLS_INVALID_STATE`",
-              "name": "`err_tls_invalid_state`",
-              "meta": {
-                "added": [
-                  "v12.17.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The TLS socket must be connected and securily established. Ensure the 'secure'\nevent is emitted before continuing.</p>\n<p><a id=\"ERR_TLS_INVALID_PROTOCOL_METHOD\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_TLS_INVALID_STATE`"
-            },
             {
               "textRaw": "`ERR_TLS_INVALID_PROTOCOL_METHOD`",
               "name": "`err_tls_invalid_protocol_method`",
@@ -9636,17 +10122,38 @@
             {
               "textRaw": "`ERR_TLS_INVALID_PROTOCOL_VERSION`",
               "name": "`err_tls_invalid_protocol_version`",
-              "desc": "<p>Valid TLS protocol versions are <code>'TLSv1'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1.2'</code>.</p>\n<p><a id=\"ERR_TLS_PROTOCOL_VERSION_CONFLICT\"></a></p>",
+              "desc": "<p>Valid TLS protocol versions are <code>'TLSv1'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1.2'</code>.</p>\n<p><a id=\"ERR_TLS_INVALID_STATE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_INVALID_PROTOCOL_VERSION`"
             },
+            {
+              "textRaw": "`ERR_TLS_INVALID_STATE`",
+              "name": "`err_tls_invalid_state`",
+              "meta": {
+                "added": [
+                  "v13.10.0",
+                  "v12.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The TLS socket must be connected and securily established. Ensure the 'secure'\nevent is emitted before continuing.</p>\n<p><a id=\"ERR_TLS_PROTOCOL_VERSION_CONFLICT\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_TLS_INVALID_STATE`"
+            },
             {
               "textRaw": "`ERR_TLS_PROTOCOL_VERSION_CONFLICT`",
               "name": "`err_tls_protocol_version_conflict`",
-              "desc": "<p>Attempting to set a TLS protocol <code>minVersion</code> or <code>maxVersion</code> conflicts with an\nattempt to set the <code>secureProtocol</code> explicitly. Use one mechanism or the other.</p>\n<p><a id=\"ERR_TLS_RENEGOTIATION_DISABLED\"></a></p>",
+              "desc": "<p>Attempting to set a TLS protocol <code>minVersion</code> or <code>maxVersion</code> conflicts with an\nattempt to set the <code>secureProtocol</code> explicitly. Use one mechanism or the other.</p>\n<p><a id=\"ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_PROTOCOL_VERSION_CONFLICT`"
             },
+            {
+              "textRaw": "`ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`",
+              "name": "`err_tls_psk_set_identiy_hint_failed`",
+              "desc": "<p>Failed to set PSK identity hint. Hint may be too long.</p>\n<p><a id=\"ERR_TLS_RENEGOTIATION_DISABLED\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`"
+            },
             {
               "textRaw": "`ERR_TLS_RENEGOTIATION_DISABLED`",
               "name": "`err_tls_renegotiation_disabled`",
@@ -9671,17 +10178,10 @@
             {
               "textRaw": "`ERR_TLS_SNI_FROM_SERVER`",
               "name": "`err_tls_sni_from_server`",
-              "desc": "<p>An attempt was made to issue Server Name Indication from a TLS server-side\nsocket, which is only valid from a client.</p>\n<p><a id=\"ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED\"></a></p>",
+              "desc": "<p>An attempt was made to issue Server Name Indication from a TLS server-side\nsocket, which is only valid from a client.</p>\n<p><a id=\"ERR_TRACE_EVENTS_CATEGORY_REQUIRED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_SNI_FROM_SERVER`"
             },
-            {
-              "textRaw": "`ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`",
-              "name": "`err_tls_psk_set_identiy_hint_failed`",
-              "desc": "<p>Failed to set PSK identity hint. Hint may be too long.</p>\n<p><a id=\"ERR_TRACE_EVENTS_CATEGORY_REQUIRED\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`"
-            },
             {
               "textRaw": "`ERR_TRACE_EVENTS_CATEGORY_REQUIRED`",
               "name": "`err_trace_events_category_required`",
@@ -9692,17 +10192,10 @@
             {
               "textRaw": "`ERR_TRACE_EVENTS_UNAVAILABLE`",
               "name": "`err_trace_events_unavailable`",
-              "desc": "<p>The <code>trace_events</code> module could not be loaded because Node.js was compiled with\nthe <code>--without-v8-platform</code> flag.</p>\n<p><a id=\"ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER\"></a></p>",
+              "desc": "<p>The <code>trace_events</code> module could not be loaded because Node.js was compiled with\nthe <code>--without-v8-platform</code> flag.</p>\n<p><a id=\"ERR_TRANSFORM_ALREADY_TRANSFORMING\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TRACE_EVENTS_UNAVAILABLE`"
             },
-            {
-              "textRaw": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`",
-              "name": "`err_transferring_externalized_sharedarraybuffer`",
-              "desc": "<p>A <code>SharedArrayBuffer</code> whose memory is not managed by the JavaScript engine\nor by Node.js was encountered during serialization. Such a <code>SharedArrayBuffer</code>\ncannot be serialized.</p>\n<p>This can only happen when native addons create <code>SharedArrayBuffer</code>s in\n\"externalized\" mode, or put existing <code>SharedArrayBuffer</code> into externalized mode.</p>\n<p><a id=\"ERR_TRANSFORM_ALREADY_TRANSFORMING\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`"
-            },
             {
               "textRaw": "`ERR_TRANSFORM_ALREADY_TRANSFORMING`",
               "name": "`err_transform_already_transforming`",
@@ -9727,7 +10220,7 @@
             {
               "textRaw": "`ERR_UNAVAILABLE_DURING_EXIT`",
               "name": "`err_unavailable_during_exit`",
-              "desc": "<p>Function was called within a <a href=\"process.html#Event:-%60&#x27;exit&#x27;%60\"><code>process.on('exit')</code></a> handler that shouldn't be\ncalled within <a href=\"process.html#Event:-%60&#x27;exit&#x27;%60\"><code>process.on('exit')</code></a> handler.</p>\n<p><a id=\"ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET\"></a></p>",
+              "desc": "<p>Function was called within a <a href=\"process.html#process_event_exit\"><code>process.on('exit')</code></a> handler that shouldn't be\ncalled within <a href=\"process.html#process_event_exit\"><code>process.on('exit')</code></a> handler.</p>\n<p><a id=\"ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET\"></a></p>",
               "type": "module",
               "displayName": "`ERR_UNAVAILABLE_DURING_EXIT`"
             },
@@ -9815,7 +10308,7 @@
             {
               "textRaw": "`ERR_VALID_PERFORMANCE_ENTRY_TYPE`",
               "name": "`err_valid_performance_entry_type`",
-              "desc": "<p>While using the Performance Timing API (<code>perf_hooks</code>), no valid performance\nentry types were found.</p>\n<p><a id=\"ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING\"></a></p>",
+              "desc": "<p>While using the Performance Timing API (<code>perf_hooks</code>), no valid performance\nentry types are found.</p>\n<p><a id=\"ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING\"></a></p>",
               "type": "module",
               "displayName": "`ERR_VALID_PERFORMANCE_ENTRY_TYPE`"
             },
@@ -9857,10 +10350,17 @@
             {
               "textRaw": "`ERR_VM_MODULE_LINKING_ERRORED`",
               "name": "`err_vm_module_linking_errored`",
-              "desc": "<p>The linker function returned a module for which linking has failed.</p>\n<p><a id=\"ERR_VM_MODULE_NOT_MODULE\"></a></p>",
+              "desc": "<p>The linker function returned a module for which linking has failed.</p>\n<p><a id=\"ERR_VM_MODULE_LINK_FAILURE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_VM_MODULE_LINKING_ERRORED`"
             },
+            {
+              "textRaw": "`ERR_VM_MODULE_LINK_FAILURE`",
+              "name": "`err_vm_module_link_failure`",
+              "desc": "<p>The module was unable to be linked due to a failure.</p>\n<p><a id=\"ERR_VM_MODULE_NOT_MODULE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_VM_MODULE_LINK_FAILURE`"
+            },
             {
               "textRaw": "`ERR_VM_MODULE_NOT_MODULE`",
               "name": "`err_vm_module_not_module`",
@@ -9958,8 +10458,12 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "v11.4.0",
-                    "pr-url": "https://github.com/nodejs/node/commit/186035243fad247e3955f",
+                    "version": [
+                      "v11.4.0",
+                      "v10.15.0"
+                    ],
+                    "commit": "186035243fad247e3955f",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/143",
                     "description": "Max header size in `http_parser` was set to 8KB."
                   }
                 ]
@@ -10005,26 +10509,10 @@
             {
               "textRaw": "`ERR_CANNOT_TRANSFER_OBJECT`",
               "name": "`err_cannot_transfer_object`",
-              "desc": "<!--\nadded: v10.5.0\nremoved: v12.5.0\n-->\n<p>The value passed to <code>postMessage()</code> contained an object that is not supported\nfor transferring.</p>\n<p><a id=\"ERR_CLOSED_MESSAGE_PORT\"></a></p>",
+              "desc": "<!--\nadded: v10.5.0\nremoved: v12.5.0\n-->\n<p>The value passed to <code>postMessage()</code> contained an object that is not supported\nfor transferring.</p>\n<p><a id=\"ERR_CRYPTO_HASH_DIGEST_NO_UTF16\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CANNOT_TRANSFER_OBJECT`"
             },
-            {
-              "textRaw": "`ERR_CLOSED_MESSAGE_PORT`",
-              "name": "`err_closed_message_port`",
-              "meta": {
-                "added": [
-                  "v10.5.0"
-                ],
-                "removed": [
-                  "v11.12.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>There was an attempt to use a <code>MessagePort</code> instance in a closed\nstate, usually after <code>.close()</code> has been called.</p>\n<p><a id=\"ERR_CRYPTO_HASH_DIGEST_NO_UTF16\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_CLOSED_MESSAGE_PORT`"
-            },
             {
               "textRaw": "`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`",
               "name": "`err_crypto_hash_digest_no_utf16`",
@@ -10133,10 +10621,17 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Used when an invalid character is found in an HTTP response status message\n(reason phrase).</p>\n<p><a id=\"ERR_INDEX_OUT_OF_RANGE\"></a></p>",
+              "desc": "<p>Used when an invalid character is found in an HTTP response status message\n(reason phrase).</p>\n<p><a id=\"ERR_HTTP_REQUEST_TIMEOUT\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP_INVALID_CHAR`"
             },
+            {
+              "textRaw": "`ERR_HTTP_REQUEST_TIMEOUT`",
+              "name": "`err_http_request_timeout`",
+              "desc": "<p>The client has not sent the entire request within the allowed time.</p>\n<p><a id=\"ERR_INDEX_OUT_OF_RANGE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_HTTP_REQUEST_TIMEOUT`"
+            },
             {
               "textRaw": "`ERR_INDEX_OUT_OF_RANGE`",
               "name": "`err_index_out_of_range`",
@@ -10165,7 +10660,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Used by the <code>N-API</code> when <code>Constructor.prototype</code> is not an object.</p>\n<p><a id=\"ERR_NO_LONGER_SUPPORTED\"></a></p>",
+              "desc": "<p>Used by the <code>Node-API</code> when <code>Constructor.prototype</code> is not an object.</p>\n<p><a id=\"ERR_NO_LONGER_SUPPORTED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_NAPI_CONS_PROTOTYPE_OBJECT`"
             },
@@ -10204,10 +10699,26 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>The <code>repl</code> module was unable to parse data from the REPL history file.</p>\n<p><a id=\"ERR_STDERR_CLOSE\"></a></p>",
+              "desc": "<p>The <code>repl</code> module was unable to parse data from the REPL history file.</p>\n<p><a id=\"ERR_SOCKET_CANNOT_SEND\"></a></p>",
               "type": "module",
               "displayName": "`ERR_PARSE_HISTORY_DATA`"
             },
+            {
+              "textRaw": "`ERR_SOCKET_CANNOT_SEND`",
+              "name": "`err_socket_cannot_send`",
+              "meta": {
+                "added": [
+                  "v9.0.0"
+                ],
+                "removed": [
+                  "v14.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Data could not be sent on a socket.</p>\n<p><a id=\"ERR_STDERR_CLOSE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_SOCKET_CANNOT_SEND`"
+            },
             {
               "textRaw": "`ERR_STDERR_CLOSE`",
               "name": "`err_stderr_close`",
@@ -10274,25 +10785,25 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Used when a TLS renegotiation request has failed in a non-specific way.</p>\n<p><a id=\"ERR_UNKNOWN_BUILTIN_MODULE\"></a></p>",
+              "desc": "<p>Used when a TLS renegotiation request has failed in a non-specific way.</p>\n<p><a id=\"ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_RENEGOTIATION_FAILED`"
             },
             {
-              "textRaw": "`ERR_UNKNOWN_BUILTIN_MODULE`",
-              "name": "`err_unknown_builtin_module`",
+              "textRaw": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`",
+              "name": "`err_transferring_externalized_sharedarraybuffer`",
               "meta": {
                 "added": [
-                  "v8.0.0"
+                  "v10.5.0"
                 ],
                 "removed": [
-                  "v9.0.0"
+                  "v14.0.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The <code>'ERR_UNKNOWN_BUILTIN_MODULE'</code> error code is used to identify a specific\nkind of internal Node.js error that should not typically be triggered by user\ncode. Instances of this error point to an internal bug within the Node.js\nbinary itself.</p>\n<p><a id=\"ERR_UNKNOWN_STDIN_TYPE\"></a></p>",
+              "desc": "<p>A <code>SharedArrayBuffer</code> whose memory is not managed by the JavaScript engine\nor by Node.js was encountered during serialization. Such a <code>SharedArrayBuffer</code>\ncannot be serialized.</p>\n<p>This can only happen when native addons create <code>SharedArrayBuffer</code>s in\n\"externalized\" mode, or put existing <code>SharedArrayBuffer</code> into externalized mode.</p>\n<p><a id=\"ERR_UNKNOWN_STDIN_TYPE\"></a></p>",
               "type": "module",
-              "displayName": "`ERR_UNKNOWN_BUILTIN_MODULE`"
+              "displayName": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`"
             },
             {
               "textRaw": "`ERR_UNKNOWN_STDIN_TYPE`",
@@ -10474,7 +10985,7 @@
           "textRaw": "Class: `SystemError`",
           "type": "class",
           "name": "SystemError",
-          "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Node.js generates system errors when exceptions occur within its runtime\nenvironment. These usually occur when an application violates an operating\nsystem constraint. For example, a system error will occur if an application\nattempts to read a file that does not exist.</p>\n<ul>\n<li><code>address</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the address to which a network connection\nfailed</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> The string error code</li>\n<li><code>dest</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path destination when reporting a file\nsystem error</li>\n<li><code>errno</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The system-provided error number</li>\n<li><code>info</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> If present, extra details about the error condition</li>\n<li><code>message</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A system-provided human-readable description of the error</li>\n<li><code>path</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path when reporting a file system error</li>\n<li><code>port</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> If present, the network connection port that is not available</li>\n<li><code>syscall</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The name of the system call that triggered the error</li>\n</ul>",
+          "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Node.js generates system errors when exceptions occur within its runtime\nenvironment. These usually occur when an application violates an operating\nsystem constraint. For example, a system error will occur if an application\nattempts to read a file that does not exist.</p>\n<ul>\n<li><code>address</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the address to which a network connection\nfailed</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> The string error code</li>\n<li><code>dest</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path destination when reporting a file\nsystem error</li>\n<li><code>errno</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The system-provided error number</li>\n<li><code>info</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> If present, extra details about the error condition</li>\n<li><code>message</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A system-provided human-readable description of the error</li>\n<li><code>path</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path when reporting a file system error</li>\n<li><code>port</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> If present, the network connection port that is not available</li>\n<li><code>syscall</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The name of the system call that triggered the error</li>\n</ul>",
           "properties": [
             {
               "textRaw": "`address` {string}",
@@ -10495,10 +11006,10 @@
               "desc": "<p>If present, <code>error.dest</code> is the file path destination when reporting a file\nsystem error.</p>"
             },
             {
-              "textRaw": "`errno` {string|number}",
-              "type": "string|number",
+              "textRaw": "`errno` {number}",
+              "type": "number",
               "name": "errno",
-              "desc": "<p>The <code>error.errno</code> property is a number or a string. If it is a number, it is a\nnegative value which corresponds to the error code defined in\n<a href=\"https://docs.libuv.org/en/v1.x/errors.html\"><code>libuv Error handling</code></a>. See the libuv <code>errno.h</code> header file\n(<code>deps/uv/include/uv/errno.h</code> in the Node.js source tree) for details. In case\nof a string, it is the same as <code>error.code</code>.</p>"
+              "desc": "<p>The <code>error.errno</code> property is a negative number which corresponds\nto the error code defined in <a href=\"https://docs.libuv.org/en/v1.x/errors.html\"><code>libuv Error handling</code></a>.</p>\n<p>On Windows the error number provided by the system will be normalized by libuv.</p>\n<p>To get the string representation of the error code, use\n<a href=\"util.html#util_util_getsystemerrorname_err\"><code>util.getSystemErrorName(error.errno)</code></a>.</p>"
             },
             {
               "textRaw": "`info` {Object}",
@@ -10547,7 +11058,8 @@
           "name": "TypeError",
           "desc": "<ul>\n<li>Extends <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that a provided argument is not an allowable type. For example,\npassing a function to a parameter which expects a string would be a <code>TypeError</code>.</p>\n<pre><code class=\"language-js\">require('url').parse(() => { });\n// Throws TypeError, since it expected a string.\n</code></pre>\n<p>Node.js will generate and throw <code>TypeError</code> instances <em>immediately</em> as a form\nof argument validation.</p>"
         }
-      ]
+      ],
+      "source": "doc/api/errors.md"
     },
     {
       "textRaw": "Global objects",
@@ -10556,6 +11068,131 @@
       "type": "misc",
       "desc": "<p>These objects are available in all modules. The following variables may appear\nto be global but are not. They exist only in the scope of modules, see the\n<a href=\"modules.html\">module system documentation</a>:</p>\n<ul>\n<li><a href=\"modules.html#modules_dirname\"><code>__dirname</code></a></li>\n<li><a href=\"modules.html#modules_filename\"><code>__filename</code></a></li>\n<li><a href=\"modules.html#modules_exports\"><code>exports</code></a></li>\n<li><a href=\"modules.html#modules_module\"><code>module</code></a></li>\n<li><a href=\"modules.html#modules_require_id\"><code>require()</code></a></li>\n</ul>\n<p>The objects listed here are specific to Node.js. There are <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects\">built-in objects</a>\nthat are part of the JavaScript language itself, which are also globally\naccessible.</p>",
       "globals": [
+        {
+          "textRaw": "Class: `AbortController`",
+          "type": "global",
+          "name": "AbortController",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>A utility class used to signal cancelation in selected <code>Promise</code>-based APIs.\nThe API is based on the Web API <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/AbortController\"><code>AbortController</code></a>.</p>\n<p>To use, launch Node.js using the <code>--experimental-abortcontroller</code> flag.</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\n\nac.signal.addEventListener('abort', () => console.log('Aborted!'),\n                           { once: true });\n\nac.abort();\n\nconsole.log(ac.signal.aborted);  // Prints True\n</code></pre>",
+          "methods": [
+            {
+              "textRaw": "`abortController.abort()`",
+              "type": "method",
+              "name": "abort",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Triggers the abort signal, causing the <code>abortController.signal</code> to emit\nthe <code>'abort'</code> event.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`signal` Type: {AbortSignal}",
+              "type": "AbortSignal",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              }
+            }
+          ],
+          "classes": [
+            {
+              "textRaw": "Class: `AbortSignal`",
+              "type": "class",
+              "name": "AbortSignal",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventtarget\" class=\"type\">&lt;EventTarget&gt;</a></li>\n</ul>\n<p>The <code>AbortSignal</code> is used to notify observers when the\n<code>abortController.abort()</code> method is called.</p>",
+              "classMethods": [
+                {
+                  "textRaw": "Static method: `AbortSignal.abort()`",
+                  "type": "classMethod",
+                  "name": "abort",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {AbortSignal}",
+                        "name": "return",
+                        "type": "AbortSignal"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns a new already aborted <code>AbortSignal</code>.</p>"
+                }
+              ],
+              "events": [
+                {
+                  "textRaw": "Event: `'abort'`",
+                  "type": "event",
+                  "name": "abort",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>The <code>'abort'</code> event is emitted when the <code>abortController.abort()</code> method\nis called. The callback is invoked with a single object argument with a\nsingle <code>type</code> property set to <code>'abort'</code>:</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\n\n// Use either the onabort property...\nac.signal.onabort = () => console.log('aborted!');\n\n// Or the EventTarget API...\nac.signal.addEventListener('abort', (event) => {\n  console.log(event.type);  // Prints 'abort'\n}, { once: true });\n\nac.abort();\n</code></pre>\n<p>The <code>AbortController</code> with which the <code>AbortSignal</code> is associated will only\never trigger the <code>'abort'</code> event once. We recommended that code check\nthat the <code>abortSignal.aborted</code> attribute is <code>false</code> before adding an <code>'abort'</code>\nevent listener.</p>\n<p>Any event listeners attached to the <code>AbortSignal</code> should use the\n<code>{ once: true }</code> option (or, if using the <code>EventEmitter</code> APIs to attach a\nlistener, use the <code>once()</code> method) to ensure that the event listener is\nremoved as soon as the <code>'abort'</code> event is handled. Failure to do so may\nresult in memory leaks.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`aborted` Type: {boolean} True after the `AbortController` has been aborted.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "True after the `AbortController` has been aborted."
+                },
+                {
+                  "textRaw": "`onabort` Type: {Function}",
+                  "type": "Function",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>An optional callback function that may be set by user code to be notified\nwhen the <code>abortController.abort()</code> function has been called.</p>"
+                }
+              ]
+            }
+          ]
+        },
         {
           "textRaw": "Class: `Buffer`",
           "type": "global",
@@ -10650,7 +11287,7 @@
             ],
             "changes": []
           },
-          "desc": "<ul>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a> Function to be queued.</li>\n</ul>\n<p>The <code>queueMicrotask()</code> method queues a microtask to invoke <code>callback</code>. If\n<code>callback</code> throws an exception, the <a href=\"process.html#process_process\"><code>process</code> object</a> <code>'uncaughtException'</code>\nevent will be emitted.</p>\n<p>The microtask queue is managed by V8 and may be used in a similar manner to\nthe <a href=\"process.html#process_process_nexttick_callback_args\"><code>process.nextTick()</code></a> queue, which is managed by Node.js. The\n<code>process.nextTick()</code> queue is always processed before the microtask queue\nwithin each turn of the Node.js event loop.</p>\n<pre><code class=\"language-js\">// Here, `queueMicrotask()` is used to ensure the 'load' event is always\n// emitted asynchronously, and therefore consistently. Using\n// `process.nextTick()` here would result in the 'load' event always emitting\n// before any other promise jobs.\n\nDataHandler.prototype.load = async function load(key) {\n  const hit = this._cache.get(url);\n  if (hit !== undefined) {\n    queueMicrotask(() => {\n      this.emit('load', hit);\n    });\n    return;\n  }\n\n  const data = await fetchData(key);\n  this._cache.set(url, data);\n  this.emit('load', data);\n};\n</code></pre>"
+          "desc": "<ul>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a> Function to be queued.</li>\n</ul>\n<p>The <code>queueMicrotask()</code> method queues a microtask to invoke <code>callback</code>. If\n<code>callback</code> throws an exception, the <a href=\"process.html#process_process\"><code>process</code> object</a> <code>'uncaughtException'</code>\nevent will be emitted.</p>\n<p>The microtask queue is managed by V8 and may be used in a similar manner to\nthe <a href=\"process.html#process_process_nexttick_callback_args\"><code>process.nextTick()</code></a> queue, which is managed by Node.js. The\n<code>process.nextTick()</code> queue is always processed before the microtask queue\nwithin each turn of the Node.js event loop.</p>\n<pre><code class=\"language-js\">// Here, `queueMicrotask()` is used to ensure the 'load' event is always\n// emitted asynchronously, and therefore consistently. Using\n// `process.nextTick()` here would result in the 'load' event always emitting\n// before any other promise jobs.\n\nDataHandler.prototype.load = async function load(key) {\n  const hit = this._cache.get(key);\n  if (hit !== undefined) {\n    queueMicrotask(() => {\n      this.emit('load', hit);\n    });\n    return;\n  }\n\n  const data = await fetchData(key);\n  this._cache.set(key, data);\n  this.emit('load', data);\n};\n</code></pre>"
         },
         {
           "textRaw": "`setImmediate(callback[, ...args])`",
@@ -10791,24 +11428,25 @@
           ],
           "desc": "<p>This variable may appear to be global but is not. See <a href=\"modules.html#modules_require_id\"><code>require()</code></a>.</p>"
         }
-      ]
+      ],
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "Internationalization support",
       "name": "Internationalization support",
       "introduced_in": "v8.2.0",
       "type": "misc",
-      "desc": "<p>Node.js has many features that make it easier to write internationalized\nprograms. Some of them are:</p>\n<ul>\n<li>Locale-sensitive or Unicode-aware functions in the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language\nSpecification</a>:\n<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a></li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase\"><code>String.prototype.toLowerCase()</code></a></li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase\"><code>String.prototype.toUpperCase()</code></a></li>\n</ul>\n</li>\n<li>All functionality described in the <a href=\"https://tc39.github.io/ecma402/\">ECMAScript Internationalization API\nSpecification</a> (aka ECMA-402):\n<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\"><code>Intl</code></a> object</li>\n<li>Locale-sensitive methods like <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\"><code>String.prototype.localeCompare()</code></a> and\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString\"><code>Date.prototype.toLocaleString()</code></a></li>\n</ul>\n</li>\n<li>The <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL parser</a>'s <a href=\"https://en.wikipedia.org/wiki/Internationalized_domain_name\">internationalized domain names</a> (IDNs) support</li>\n<li><a href=\"buffer.html#buffer_buffer_transcode_source_fromenc_toenc\"><code>require('buffer').transcode()</code></a></li>\n<li>More accurate <a href=\"repl.html#repl_repl\">REPL</a> line editing</li>\n<li><a href=\"util.html#util_class_util_textdecoder\"><code>require('util').TextDecoder</code></a></li>\n<li><a href=\"https://github.com/tc39/proposal-regexp-unicode-property-escapes\"><code>RegExp</code> Unicode Property Escapes</a></li>\n</ul>\n<p>Node.js (and its underlying V8 engine) uses <a href=\"http://site.icu-project.org/\">ICU</a> to implement these features\nin native C/C++ code. However, some of them require a very large ICU data file\nin order to support all locales of the world. Because it is expected that most\nNode.js users will make use of only a small portion of ICU functionality, only\na subset of the full ICU data set is provided by Node.js by default. Several\noptions are provided for customizing and expanding the ICU data set either when\nbuilding or running Node.js.</p>",
+      "desc": "<p>Node.js has many features that make it easier to write internationalized\nprograms. Some of them are:</p>\n<ul>\n<li>Locale-sensitive or Unicode-aware functions in the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language\nSpecification</a>:\n<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a></li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase\"><code>String.prototype.toLowerCase()</code></a></li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase\"><code>String.prototype.toUpperCase()</code></a></li>\n</ul>\n</li>\n<li>All functionality described in the <a href=\"https://tc39.github.io/ecma402/\">ECMAScript Internationalization API\nSpecification</a> (aka ECMA-402):\n<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\"><code>Intl</code></a> object</li>\n<li>Locale-sensitive methods like <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\"><code>String.prototype.localeCompare()</code></a> and\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString\"><code>Date.prototype.toLocaleString()</code></a></li>\n</ul>\n</li>\n<li>The <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL parser</a>'s <a href=\"https://en.wikipedia.org/wiki/Internationalized_domain_name\">internationalized domain names</a> (IDNs) support</li>\n<li><a href=\"buffer.html#buffer_buffer_transcode_source_fromenc_toenc\"><code>require('buffer').transcode()</code></a></li>\n<li>More accurate <a href=\"repl.html#repl_repl\">REPL</a> line editing</li>\n<li><a href=\"util.html#util_class_util_textdecoder\"><code>require('util').TextDecoder</code></a></li>\n<li><a href=\"https://github.com/tc39/proposal-regexp-unicode-property-escapes\"><code>RegExp</code> Unicode Property Escapes</a></li>\n</ul>\n<p>Node.js and the underlying V8 engine use\n<a href=\"http://site.icu-project.org/\">International Components for Unicode (ICU)</a> to implement these features\nin native C/C++ code. The full ICU data set is provided by Node.js by default.\nHowever, due to the size of the ICU data file, several\noptions are provided for customizing the ICU data set either when\nbuilding or running Node.js.</p>",
       "miscs": [
         {
           "textRaw": "Options for building Node.js",
           "name": "options_for_building_node.js",
-          "desc": "<p>To control how ICU is used in Node.js, four <code>configure</code> options are available\nduring compilation. Additional details on how to compile Node.js are documented\nin <a href=\"https://github.com/nodejs/node/blob/master/BUILDING.md\">BUILDING.md</a>.</p>\n<ul>\n<li><code>--with-intl=none</code>/<code>--without-intl</code></li>\n<li><code>--with-intl=system-icu</code></li>\n<li><code>--with-intl=small-icu</code> (default)</li>\n<li><code>--with-intl=full-icu</code></li>\n</ul>\n<p>An overview of available Node.js and JavaScript features for each <code>configure</code>\noption:</p>\n<table>\n<thead>\n<tr>\n<th></th>\n<th><code>none</code></th>\n<th><code>system-icu</code></th>\n<th><code>small-icu</code></th>\n<th><code>full-icu</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a></td>\n<td>none (function is no-op)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>String.prototype.to*Case()</code></td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\"><code>Intl</code></a></td>\n<td>none (object does not exist)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\"><code>String.prototype.localeCompare()</code></a></td>\n<td>partial (not locale-aware)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>String.prototype.toLocale*Case()</code></td>\n<td>partial (not locale-aware)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString\"><code>Number.prototype.toLocaleString()</code></a></td>\n<td>partial (not locale-aware)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>Date.prototype.toLocale*String()</code></td>\n<td>partial (not locale-aware)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL Parser</a></td>\n<td>partial (no IDN support)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"buffer.html#buffer_buffer_transcode_source_fromenc_toenc\"><code>require('buffer').transcode()</code></a></td>\n<td>none (function does not exist)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"repl.html#repl_repl\">REPL</a></td>\n<td>partial (inaccurate line editing)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"util.html#util_class_util_textdecoder\"><code>require('util').TextDecoder</code></a></td>\n<td>partial (basic encodings support)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (Unicode-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://github.com/tc39/proposal-regexp-unicode-property-escapes\"><code>RegExp</code> Unicode Property Escapes</a></td>\n<td>none (invalid <code>RegExp</code> error)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n</tbody>\n</table>\n<p>The \"(not locale-aware)\" designation denotes that the function carries out its\noperation just like the non-<code>Locale</code> version of the function, if one\nexists. For example, under <code>none</code> mode, <code>Date.prototype.toLocaleString()</code>'s\noperation is identical to that of <code>Date.prototype.toString()</code>.</p>",
+          "desc": "<p>To control how ICU is used in Node.js, four <code>configure</code> options are available\nduring compilation. Additional details on how to compile Node.js are documented\nin <a href=\"https://github.com/nodejs/node/blob/HEAD/BUILDING.md\">BUILDING.md</a>.</p>\n<ul>\n<li><code>--with-intl=none</code>/<code>--without-intl</code></li>\n<li><code>--with-intl=system-icu</code></li>\n<li><code>--with-intl=small-icu</code></li>\n<li><code>--with-intl=full-icu</code> (default)</li>\n</ul>\n<p>An overview of available Node.js and JavaScript features for each <code>configure</code>\noption:</p>\n<table>\n<thead>\n<tr>\n<th>Feature</th>\n<th><code>none</code></th>\n<th><code>system-icu</code></th>\n<th><code>small-icu</code></th>\n<th><code>full-icu</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a></td>\n<td>none (function is no-op)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>String.prototype.to*Case()</code></td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\"><code>Intl</code></a></td>\n<td>none (object does not exist)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\"><code>String.prototype.localeCompare()</code></a></td>\n<td>partial (not locale-aware)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>String.prototype.toLocale*Case()</code></td>\n<td>partial (not locale-aware)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString\"><code>Number.prototype.toLocaleString()</code></a></td>\n<td>partial (not locale-aware)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>Date.prototype.toLocale*String()</code></td>\n<td>partial (not locale-aware)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL Parser</a></td>\n<td>partial (no IDN support)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"buffer.html#buffer_buffer_transcode_source_fromenc_toenc\"><code>require('buffer').transcode()</code></a></td>\n<td>none (function does not exist)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"repl.html#repl_repl\">REPL</a></td>\n<td>partial (inaccurate line editing)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"util.html#util_class_util_textdecoder\"><code>require('util').TextDecoder</code></a></td>\n<td>partial (basic encodings support)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (Unicode-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://github.com/tc39/proposal-regexp-unicode-property-escapes\"><code>RegExp</code> Unicode Property Escapes</a></td>\n<td>none (invalid <code>RegExp</code> error)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n</tbody>\n</table>\n<p>The \"(not locale-aware)\" designation denotes that the function carries out its\noperation just like the non-<code>Locale</code> version of the function, if one\nexists. For example, under <code>none</code> mode, <code>Date.prototype.toLocaleString()</code>'s\noperation is identical to that of <code>Date.prototype.toString()</code>.</p>",
           "modules": [
             {
               "textRaw": "Disable all internationalization features (`none`)",
               "name": "disable_all_internationalization_features_(`none`)",
-              "desc": "<p>If this option is chosen, most internationalization features mentioned above\nwill be <strong>unavailable</strong> in the resulting <code>node</code> binary.</p>",
+              "desc": "<p>If this option is chosen, ICU is disabled and most internationalization\nfeatures mentioned above will be <strong>unavailable</strong> in the resulting <code>node</code> binary.</p>",
               "type": "module",
               "displayName": "Disable all internationalization features (`none`)"
             },
@@ -10822,7 +11460,7 @@
             {
               "textRaw": "Embed a limited set of ICU data (`small-icu`)",
               "name": "embed_a_limited_set_of_icu_data_(`small-icu`)",
-              "desc": "<p>This option makes the resulting binary link against the ICU library statically,\nand includes a subset of ICU data (typically only the English locale) within\nthe <code>node</code> executable.</p>\n<p>Functionalities that only require the ICU library itself, such as\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a> and the <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL parser</a>, are fully\nsupported under <code>small-icu</code>. Features that require ICU locale data in addition,\nsuch as <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\"><code>Intl.DateTimeFormat</code></a>, generally only work with the English locale:</p>\n<pre><code class=\"language-js\">const january = new Date(9e8);\nconst english = new Intl.DateTimeFormat('en', { month: 'long' });\nconst spanish = new Intl.DateTimeFormat('es', { month: 'long' });\n\nconsole.log(english.format(january));\n// Prints \"January\"\nconsole.log(spanish.format(january));\n// Prints \"M01\" on small-icu\n// Should print \"enero\"\n</code></pre>\n<p>This mode provides a good balance between features and binary size, and it is\nthe default behavior if no <code>--with-intl</code> flag is passed. The official binaries\nare also built in this mode.</p>",
+              "desc": "<p>This option makes the resulting binary link against the ICU library statically,\nand includes a subset of ICU data (typically only the English locale) within\nthe <code>node</code> executable.</p>\n<p>Functionalities that only require the ICU library itself, such as\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a> and the <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL parser</a>, are fully\nsupported under <code>small-icu</code>. Features that require ICU locale data in addition,\nsuch as <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\"><code>Intl.DateTimeFormat</code></a>, generally only work with the English locale:</p>\n<pre><code class=\"language-js\">const january = new Date(9e8);\nconst english = new Intl.DateTimeFormat('en', { month: 'long' });\nconst spanish = new Intl.DateTimeFormat('es', { month: 'long' });\n\nconsole.log(english.format(january));\n// Prints \"January\"\nconsole.log(spanish.format(january));\n// Prints \"M01\" on small-icu\n// Should print \"enero\"\n</code></pre>\n<p>This mode provides a balance between features and binary size.</p>",
               "modules": [
                 {
                   "textRaw": "Providing ICU data at runtime",
@@ -10838,7 +11476,7 @@
             {
               "textRaw": "Embed the entire ICU (`full-icu`)",
               "name": "embed_the_entire_icu_(`full-icu`)",
-              "desc": "<p>This option makes the resulting binary link against ICU statically and include\na full set of ICU data. A binary created this way has no further external\ndependencies and supports all locales, but might be rather large. See\n<a href=\"https://github.com/nodejs/node/blob/master/BUILDING.md#build-with-full-icu-support-all-locales-supported-by-icu\">BUILDING.md</a> on how to compile a binary using this mode.</p>",
+              "desc": "<p>This option makes the resulting binary link against ICU statically and include\na full set of ICU data. A binary created this way has no further external\ndependencies and supports all locales, but might be rather large. This is\nthe default behavior if no <code>--with-intl</code> flag is passed. The official binaries\nare also built in this mode.</p>",
               "type": "module",
               "displayName": "Embed the entire ICU (`full-icu`)"
             }
@@ -10849,11 +11487,12 @@
         {
           "textRaw": "Detecting internationalization support",
           "name": "detecting_internationalization_support",
-          "desc": "<p>To verify that ICU is enabled at all (<code>system-icu</code>, <code>small-icu</code>, or\n<code>full-icu</code>), simply checking the existence of <code>Intl</code> should suffice:</p>\n<pre><code class=\"language-js\">const hasICU = typeof Intl === 'object';\n</code></pre>\n<p>Alternatively, checking for <code>process.versions.icu</code>, a property defined only\nwhen ICU is enabled, works too:</p>\n<pre><code class=\"language-js\">const hasICU = typeof process.versions.icu === 'string';\n</code></pre>\n<p>To check for support for a non-English locale (i.e. <code>full-icu</code> or\n<code>system-icu</code>), <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\"><code>Intl.DateTimeFormat</code></a> can be a good distinguishing factor:</p>\n<pre><code class=\"language-js\">const hasFullICU = (() => {\n  try {\n    const january = new Date(9e8);\n    const spanish = new Intl.DateTimeFormat('es', { month: 'long' });\n    return spanish.format(january) === 'enero';\n  } catch (err) {\n    return false;\n  }\n})();\n</code></pre>\n<p>For more verbose tests for <code>Intl</code> support, the following resources may be found\nto be helpful:</p>\n<ul>\n<li><a href=\"https://github.com/srl295/btest402\">btest402</a>: Generally used to check whether Node.js with <code>Intl</code> support is\nbuilt correctly.</li>\n<li><a href=\"https://github.com/tc39/test262/tree/master/test/intl402\">Test262</a>: ECMAScript's official conformance test suite includes a section\ndedicated to ECMA-402.</li>\n</ul>",
+          "desc": "<p>To verify that ICU is enabled at all (<code>system-icu</code>, <code>small-icu</code>, or\n<code>full-icu</code>), simply checking the existence of <code>Intl</code> should suffice:</p>\n<pre><code class=\"language-js\">const hasICU = typeof Intl === 'object';\n</code></pre>\n<p>Alternatively, checking for <code>process.versions.icu</code>, a property defined only\nwhen ICU is enabled, works too:</p>\n<pre><code class=\"language-js\">const hasICU = typeof process.versions.icu === 'string';\n</code></pre>\n<p>To check for support for a non-English locale (i.e. <code>full-icu</code> or\n<code>system-icu</code>), <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\"><code>Intl.DateTimeFormat</code></a> can be a good distinguishing factor:</p>\n<pre><code class=\"language-js\">const hasFullICU = (() => {\n  try {\n    const january = new Date(9e8);\n    const spanish = new Intl.DateTimeFormat('es', { month: 'long' });\n    return spanish.format(january) === 'enero';\n  } catch (err) {\n    return false;\n  }\n})();\n</code></pre>\n<p>For more verbose tests for <code>Intl</code> support, the following resources may be found\nto be helpful:</p>\n<ul>\n<li><a href=\"https://github.com/srl295/btest402\">btest402</a>: Generally used to check whether Node.js with <code>Intl</code> support is\nbuilt correctly.</li>\n<li><a href=\"https://github.com/tc39/test262/tree/HEAD/test/intl402\">Test262</a>: ECMAScript's official conformance test suite includes a section\ndedicated to ECMA-402.</li>\n</ul>",
           "type": "misc",
           "displayName": "Detecting internationalization support"
         }
-      ]
+      ],
+      "source": "doc/api/intl.md"
     },
     {
       "textRaw": "Modules: ECMAScript modules",
@@ -10867,25 +11506,34 @@
         "changes": [
           {
             "version": [
-              "v12.22.0"
+              "v14.17.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/35781",
             "description": "Stabilize modules implementation."
           },
           {
             "version": [
-              "v12.20.0"
+              "v14.13.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/35249",
             "description": "Support for detection of CommonJS named exports."
           },
           {
-            "version": "v12.20.0",
+            "version": "v14.8.0",
+            "pr-url": "https://github.com/nodejs/node/pull/34558",
+            "description": "Unflag Top-Level Await."
+          },
+          {
+            "version": [
+              "v14.0.0",
+              "v13.14.0"
+            ],
             "pr-url": "https://github.com/nodejs/node/pull/31974",
             "description": "Remove experimental modules warning."
           },
           {
             "version": [
+              "v13.2.0",
               "v12.17.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/29866",
@@ -10904,7 +11552,7 @@
         {
           "textRaw": "Introduction",
           "name": "esm",
-          "desc": "<p>ECMAScript modules are <a href=\"https://tc39.github.io/ecma262/#sec-modules\">the official standard format</a> to package JavaScript\ncode for reuse. Modules are defined using a variety of <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import\"><code>import</code></a> and\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export\"><code>export</code></a> statements.</p>\n<p>The following example of an ES module exports a function:</p>\n<pre><code class=\"language-js\">// addTwo.mjs\nfunction addTwo(num) {\n  return num + 2;\n}\n\nexport { addTwo };\n</code></pre>\n<p>The following example of an ES module imports the function from <code>addTwo.mjs</code>:</p>\n<pre><code class=\"language-js\">// app.mjs\nimport { addTwo } from './addTwo.mjs';\n\n// Prints: 6\nconsole.log(addTwo(4));\n</code></pre>\n<p>Node.js fully supports ECMAScript modules as they are currently specified and\nprovides interoperability between them and its original module format,\n<a href=\"modules.html\">CommonJS</a>.</p>\n<!-- Anchors to make sure old links find a target -->\n<p><i id=\"#esm_package_json_type_field\"></i>\n<i id=\"#esm_package_scope_and_file_extensions\"></i>\n<i id=\"#esm_input_type_flag\"></i></p>",
+          "desc": "<p>ECMAScript modules are <a href=\"https://tc39.github.io/ecma262/#sec-modules\">the official standard format</a> to package JavaScript\ncode for reuse. Modules are defined using a variety of <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import\"><code>import</code></a> and\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export\"><code>export</code></a> statements.</p>\n<p>The following example of an ES module exports a function:</p>\n<pre><code class=\"language-js\">// addTwo.mjs\nfunction addTwo(num) {\n  return num + 2;\n}\n\nexport { addTwo };\n</code></pre>\n<p>The following example of an ES module imports the function from <code>addTwo.mjs</code>:</p>\n<pre><code class=\"language-js\">// app.mjs\nimport { addTwo } from './addTwo.mjs';\n\n// Prints: 6\nconsole.log(addTwo(4));\n</code></pre>\n<p>Node.js fully supports ECMAScript modules as they are currently specified and\nprovides interoperability between them and its original module format,\n<a href=\"modules.html\">CommonJS</a>.</p>\n<!-- Anchors to make sure old links find a target -->\n<p><i id=\"esm_package_json_type_field\"></i>\n<i id=\"esm_package_scope_and_file_extensions\"></i>\n<i id=\"esm_input_type_flag\"></i></p>",
           "type": "misc",
           "displayName": "esm"
         },
@@ -10928,20 +11576,28 @@
             {
               "textRaw": "Terminology",
               "name": "terminology",
-              "desc": "<p>The <em>specifier</em> of an <code>import</code> statement is the string after the <code>from</code> keyword,\ne.g. <code>'path'</code> in <code>import { sep } from 'path'</code>. Specifiers are also used in\n<code>export from</code> statements, and as the argument to an <code>import()</code> expression.</p>\n<p>There are four types of specifiers:</p>\n<ul>\n<li>\n<p><em>Bare specifiers</em> like <code>'some-package'</code>. They refer to an entry point of a\npackage by the package name.</p>\n</li>\n<li>\n<p><em>Deep import specifiers</em> like <code>'some-package/lib/shuffle.mjs'</code>. They refer to\na path within a package prefixed by the package name.</p>\n</li>\n<li>\n<p><em>Relative specifiers</em> like <code>'./startup.js'</code> or <code>'../config.mjs'</code>. They refer\nto a path relative to the location of the importing file.</p>\n</li>\n<li>\n<p><em>Absolute specifiers</em> like <code>'file:///opt/nodejs/config.js'</code>. They refer\ndirectly and explicitly to a full path.</p>\n</li>\n</ul>\n<p>Bare specifiers, and the bare specifier portion of deep import specifiers, are\nstrings; but everything else in a specifier is a URL.</p>\n<p><code>file:</code>, <code>node:</code>, and <code>data:</code> URLs are supported. A specifier like\n<code>'https://example.com/app.js'</code> may be supported by browsers but it is not\nsupported in Node.js.</p>\n<p>Specifiers may not begin with <code>/</code> or <code>//</code>. These are reserved for potential\nfuture use. The root of the current volume may be referenced via <code>file:///</code>.</p>",
+              "desc": "<p>The <em>specifier</em> of an <code>import</code> statement is the string after the <code>from</code> keyword,\ne.g. <code>'path'</code> in <code>import { sep } from 'path'</code>. Specifiers are also used in\n<code>export from</code> statements, and as the argument to an <code>import()</code> expression.</p>\n<p>There are three types of specifiers:</p>\n<ul>\n<li>\n<p><em>Relative specifiers</em> like <code>'./startup.js'</code> or <code>'../config.mjs'</code>. They refer\nto a path relative to the location of the importing file. <em>The file extension\nis always necessary for these.</em></p>\n</li>\n<li>\n<p><em>Bare specifiers</em> like <code>'some-package'</code> or <code>'some-package/shuffle'</code>. They can\nrefer to the main entry point of a package by the package name, or a\nspecific feature module within a package prefixed by the package name as per\nthe examples respectively. <em>Including the file extension is only necessary\nfor packages without an <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field.</em></p>\n</li>\n<li>\n<p><em>Absolute specifiers</em> like <code>'file:///opt/nodejs/config.js'</code>. They refer\ndirectly and explicitly to a full path.</p>\n</li>\n</ul>\n<p>Bare specifier resolutions are handled by the <a href=\"esm.html#esm_resolver_algorithm_specification\">Node.js module resolution\nalgorithm</a>. All other specifier resolutions are always only resolved with\nthe standard relative <a href=\"https://url.spec.whatwg.org/\">URL</a> resolution semantics.</p>\n<p>Like in CommonJS, module files within packages can be accessed by appending a\npath to the package name unless the package’s <a href=\"packages.html#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> contains an\n<a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field, in which case files within packages can only be accessed\nvia the paths defined in <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a>.</p>\n<p>For details on these package resolution rules that apply to bare specifiers in\nthe Node.js module resolution, see the <a href=\"packages.html\">packages documentation</a>.</p>",
+              "type": "module",
+              "displayName": "Terminology"
+            },
+            {
+              "textRaw": "Mandatory file extensions",
+              "name": "mandatory_file_extensions",
+              "desc": "<p>A file extension must be provided when using the <code>import</code> keyword to resolve\nrelative or absolute specifiers. Directory indexes (e.g. <code>'./startup/index.js'</code>)\nmust also be fully specified.</p>\n<p>This behavior matches how <code>import</code> behaves in browser environments, assuming a\ntypically configured server.</p>",
+              "type": "module",
+              "displayName": "Mandatory file extensions"
+            },
+            {
+              "textRaw": "URLs",
+              "name": "urls",
+              "desc": "<p>ES modules are resolved and cached as URLs. This means that files containing\nspecial characters such as <code>#</code> and <code>?</code> need to be escaped.</p>\n<p><code>file:</code>, <code>node:</code>, and <code>data:</code> URL schemes are supported. A specifier like\n<code>'https://example.com/app.js'</code> is not supported natively in Node.js unless using\na <a href=\"esm.html#esm_https_loader\">custom HTTPS loader</a>.</p>",
               "modules": [
                 {
-                  "textRaw": "`node:` Imports",
-                  "name": "`node:`_imports",
-                  "meta": {
-                    "added": [
-                      "v12.20.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p><code>node:</code> URLs are supported as a means to load Node.js builtin modules. This\nURL scheme allows for builtin modules to be referenced by valid absolute URL\nstrings.</p>\n<pre><code class=\"language-js\">import fs from 'node:fs/promises';\n</code></pre>",
+                  "textRaw": "`file:` URLs",
+                  "name": "`file:`_urls",
+                  "desc": "<p>Modules are loaded multiple times if the <code>import</code> specifier used to resolve\nthem has a different query or fragment.</p>\n<pre><code class=\"language-js\">import './foo.mjs?query=1'; // loads ./foo.mjs with query of \"?query=1\"\nimport './foo.mjs?query=2'; // loads ./foo.mjs with query of \"?query=2\"\n</code></pre>\n<p>The volume root may be referenced via <code>/</code>, <code>//</code> or <code>file:///</code>. Given the\ndifferences between <a href=\"https://url.spec.whatwg.org/\">URL</a> and path resolution (such as percent encoding\ndetails), it is recommended to use <a href=\"url.html#url_url_pathtofileurl_path\">url.pathToFileURL</a> when importing a path.</p>",
                   "type": "module",
-                  "displayName": "`node:` Imports"
+                  "displayName": "`file:` URLs"
                 },
                 {
                   "textRaw": "`data:` Imports",
@@ -10955,139 +11611,174 @@
                   "desc": "<p><a href=\"https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs\"><code>data:</code> URLs</a> are supported for importing with the following MIME types:</p>\n<ul>\n<li><code>text/javascript</code> for ES Modules</li>\n<li><code>application/json</code> for JSON</li>\n<li><code>application/wasm</code> for Wasm</li>\n</ul>\n<p><code>data:</code> URLs only resolve <a href=\"esm.html#esm_terminology\"><em>Bare specifiers</em></a> for builtin modules\nand <a href=\"esm.html#esm_terminology\"><em>Absolute specifiers</em></a>. Resolving\n<a href=\"esm.html#esm_terminology\"><em>Relative specifiers</em></a> does not work because <code>data:</code> is not a\n<a href=\"https://url.spec.whatwg.org/#special-scheme\">special scheme</a>. For example, attempting to load <code>./foo</code>\nfrom <code>data:text/javascript,import \"./foo\";</code> fails to resolve because there\nis no concept of relative resolution for <code>data:</code> URLs. An example of a <code>data:</code>\nURLs being used is:</p>\n<pre><code class=\"language-js\">import 'data:text/javascript,console.log(\"hello!\");';\nimport _ from 'data:application/json,\"world!\"';\n</code></pre>",
                   "type": "module",
                   "displayName": "`data:` Imports"
+                },
+                {
+                  "textRaw": "`node:` Imports",
+                  "name": "`node:`_imports",
+                  "meta": {
+                    "added": [
+                      "v14.13.1",
+                      "v12.20.0"
+                    ],
+                    "changes": [
+                      {
+                        "version": "v14.18.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/37246",
+                        "description": "Added `node:` import support to `require(...)`."
+                      }
+                    ]
+                  },
+                  "desc": "<p><code>node:</code> URLs are supported as an alternative means to load Node.js builtin\nmodules. This URL scheme allows for builtin modules to be referenced by valid\nabsolute URL strings.</p>\n<pre><code class=\"language-js\">import fs from 'node:fs/promises';\n</code></pre>",
+                  "type": "module",
+                  "displayName": "`node:` Imports"
                 }
               ],
               "type": "module",
-              "displayName": "Terminology"
+              "displayName": "URLs"
             }
           ],
           "type": "misc",
           "displayName": "`import` Specifiers"
         },
         {
-          "textRaw": "Differences between ES modules and CommonJS",
-          "name": "differences_between_es_modules_and_commonjs",
-          "modules": [
-            {
-              "textRaw": "Mandatory file extensions",
-              "name": "mandatory_file_extensions",
-              "desc": "<p>A file extension must be provided when using the <code>import</code> keyword. Directory\nindexes (e.g. <code>'./startup/index.js'</code>) must also be fully specified.</p>\n<p>This behavior matches how <code>import</code> behaves in browser environments, assuming a\ntypically configured server.</p>",
-              "type": "module",
-              "displayName": "Mandatory file extensions"
-            },
-            {
-              "textRaw": "No `NODE_PATH`",
-              "name": "no_`node_path`",
-              "desc": "<p><code>NODE_PATH</code> is not part of resolving <code>import</code> specifiers. Please use symlinks\nif this behavior is desired.</p>",
-              "type": "module",
-              "displayName": "No `NODE_PATH`"
-            },
-            {
-              "textRaw": "No `require`, `exports`, `module.exports`, `__filename`, `__dirname`",
-              "name": "no_`require`,_`exports`,_`module.exports`,_`__filename`,_`__dirname`",
-              "desc": "<p>These CommonJS variables are not available in ES modules.</p>\n<p><code>require</code> can be imported into an ES module using <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>\n<p>Equivalents of <code>__filename</code> and <code>__dirname</code> can be created inside of each file\nvia <a href=\"esm.html#esm_import_meta\"><code>import.meta.url</code></a>.</p>\n<pre><code class=\"language-js\">import { fileURLToPath } from 'url';\nimport { dirname } from 'path';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n</code></pre>",
-              "type": "module",
-              "displayName": "No `require`, `exports`, `module.exports`, `__filename`, `__dirname`"
-            },
-            {
-              "textRaw": "No `require.resolve`",
-              "name": "no_`require.resolve`",
-              "desc": "<p>Former use cases relying on <code>require.resolve</code> to determine the resolved path\nof a module can be supported via <code>import.meta.resolve</code>, which is experimental\nand supported via the <code>--experimental-import-meta-resolve</code> flag:</p>\n<pre><code class=\"language-js\">(async () => {\n  const dependencyAsset = await import.meta.resolve('component-lib/asset.css');\n})();\n</code></pre>\n<p><code>import.meta.resolve</code> also accepts a second argument which is the parent module\nfrom which to resolve from:</p>\n<pre><code class=\"language-js\">(async () => {\n  // Equivalent to import.meta.resolve('./dep')\n  await import.meta.resolve('./dep', import.meta.url);\n})();\n</code></pre>\n<p>This function is asynchronous because the ES module resolver in Node.js is\nasynchronous. With the introduction of <a href=\"https://github.com/tc39/proposal-top-level-await\">Top-Level Await</a>, these use cases\nwill be easier as they won't require an async function wrapper.</p>",
-              "type": "module",
-              "displayName": "No `require.resolve`"
-            },
-            {
-              "textRaw": "No `require.extensions`",
-              "name": "no_`require.extensions`",
-              "desc": "<p><code>require.extensions</code> is not used by <code>import</code>. The expectation is that loader\nhooks can provide this workflow in the future.</p>",
-              "type": "module",
-              "displayName": "No `require.extensions`"
-            },
-            {
-              "textRaw": "No `require.cache`",
-              "name": "no_`require.cache`",
-              "desc": "<p><code>require.cache</code> is not used by <code>import</code>. It has a separate cache.</p>",
-              "type": "module",
-              "displayName": "No `require.cache`"
-            },
-            {
-              "textRaw": "URL-based paths",
-              "name": "url-based_paths",
-              "desc": "<p>ES modules are resolved and cached based upon\n<a href=\"https://url.spec.whatwg.org/\">URL</a> semantics. This means that files containing\nspecial characters such as <code>#</code> and <code>?</code> need to be escaped.</p>\n<p>Modules are loaded multiple times if the <code>import</code> specifier used to resolve\nthem has a different query or fragment.</p>\n<pre><code class=\"language-js\">import './foo.mjs?query=1'; // loads ./foo.mjs with query of \"?query=1\"\nimport './foo.mjs?query=2'; // loads ./foo.mjs with query of \"?query=2\"\n</code></pre>\n<p>For now, only modules using the <code>file:</code> protocol can be loaded.</p>",
-              "type": "module",
-              "displayName": "URL-based paths"
-            }
-          ],
+          "textRaw": "Builtin modules",
+          "name": "builtin_modules",
+          "desc": "<p><a href=\"modules.html#modules_core_modules\">Core modules</a> provide named exports of their public API. A\ndefault export is also provided which is the value of the CommonJS exports.\nThe default export can be used for, among other things, modifying the named\nexports. Named exports of builtin modules are updated only by calling\n<a href=\"module.html#module_module_syncbuiltinesmexports\"><code>module.syncBuiltinESMExports()</code></a>.</p>\n<pre><code class=\"language-js\">import EventEmitter from 'events';\nconst e = new EventEmitter();\n</code></pre>\n<pre><code class=\"language-js\">import { readFile } from 'fs';\nreadFile('./foo.txt', (err, source) => {\n  if (err) {\n    console.error(err);\n  } else {\n    console.log(source);\n  }\n});\n</code></pre>\n<pre><code class=\"language-js\">import fs, { readFileSync } from 'fs';\nimport { syncBuiltinESMExports } from 'module';\n\nfs.readFileSync = () => Buffer.from('Hello, ESM');\nsyncBuiltinESMExports();\n\nfs.readFileSync === readFileSync;\n</code></pre>",
           "type": "misc",
-          "displayName": "Differences between ES modules and CommonJS"
+          "displayName": "Builtin modules"
+        },
+        {
+          "textRaw": "`import()` expressions",
+          "name": "`import()`_expressions",
+          "desc": "<p><a href=\"https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports\">Dynamic <code>import()</code></a> is supported in both CommonJS and ES modules. In CommonJS\nmodules it can be used to load ES modules.</p>",
+          "type": "misc",
+          "displayName": "`import()` expressions"
         },
         {
           "textRaw": "Interoperability with CommonJS",
           "name": "interoperability_with_commonjs",
           "modules": [
+            {
+              "textRaw": "`import` statements",
+              "name": "`import`_statements",
+              "desc": "<p>An <code>import</code> statement can reference an ES module or a CommonJS module.\n<code>import</code> statements are permitted only in ES modules, but dynamic <a href=\"esm.html#esm_import_expressions\"><code>import()</code></a>\nexpressions are supported in CommonJS for loading ES modules.</p>\n<p>When importing <a href=\"esm.html#esm_commonjs_namespaces\">CommonJS modules</a>, the\n<code>module.exports</code> object is provided as the default export. Named exports may be\navailable, provided by static analysis as a convenience for better ecosystem\ncompatibility.</p>",
+              "type": "module",
+              "displayName": "`import` statements"
+            },
             {
               "textRaw": "`require`",
               "name": "`require`",
-              "desc": "<p><code>require</code> always treats the files it references as CommonJS. This applies\nwhether <code>require</code> is used the traditional way within a CommonJS environment, or\nin an ES module environment using <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>\n<p>To include an ES module into CommonJS, use <a href=\"esm.html#esm_import_expressions\"><code>import()</code></a>.</p>",
+              "desc": "<p>The CommonJS module <code>require</code> always treats the files it references as CommonJS.</p>\n<p>Using <code>require</code> to load an ES module is not supported because ES modules have\nasynchronous execution. Instead, use <a href=\"esm.html#esm_import_expressions\"><code>import()</code></a> to load an ES module\nfrom a CommonJS module.</p>",
               "type": "module",
               "displayName": "`require`"
             },
             {
-              "textRaw": "`import` statements",
-              "name": "`import`_statements",
-              "desc": "<p>An <code>import</code> statement can reference an ES module or a CommonJS module.\n<code>import</code> statements are permitted only in ES modules. For similar functionality\nin CommonJS, see <a href=\"esm.html#esm_import_expressions\"><code>import()</code></a>.</p>\n<p>When importing <a href=\"esm.html#esm_commonjs_namespaces\">CommonJS modules</a>, the\n<code>module.exports</code> object is provided as the default export. Named exports may be\navailable, provided by static analysis as a convenience for better ecosystem\ncompatibility.</p>\n<p>Additional experimental flags are available for importing\n<a href=\"esm.html#esm_experimental_wasm_modules\">Wasm modules</a> or\n<a href=\"esm.html#esm_experimental_json_modules\">JSON modules</a>. For importing native modules or\nJSON modules unflagged, see <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>\n<p>The <em>specifier</em> of an <code>import</code> statement (the string after the <code>from</code> keyword)\ncan either be an URL-style relative path like <code>'./file.mjs'</code> or a package name\nlike <code>'fs'</code>.</p>\n<p>Like in CommonJS, files within packages can be accessed by appending a path to\nthe package name; unless the package’s <a href=\"packages.html#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> contains an\n<a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field, in which case files within packages need to be accessed\nvia the path defined in <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a>.</p>\n<pre><code class=\"language-js\">import { sin, cos } from 'geometry/trigonometry-functions.mjs';\n</code></pre>",
+              "textRaw": "CommonJS Namespaces",
+              "name": "commonjs_namespaces",
+              "desc": "<p>CommonJS modules consist of a <code>module.exports</code> object which can be of any type.</p>\n<p>When importing a CommonJS module, it can be reliably imported using the ES\nmodule default import or its corresponding sugar syntax:</p>\n<!-- eslint-disable no-duplicate-imports -->\n<pre><code class=\"language-js\">import { default as cjs } from 'cjs';\n\n// The following import statement is \"syntax sugar\" (equivalent but sweeter)\n// for `{ default as cjsSugar }` in the above import statement:\nimport cjsSugar from 'cjs';\n\nconsole.log(cjs);\nconsole.log(cjs === cjsSugar);\n// Prints:\n//   &#x3C;module.exports>\n//   true\n</code></pre>\n<p>The ECMAScript Module Namespace representation of a CommonJS module is always\na namespace with a <code>default</code> export key pointing to the CommonJS\n<code>module.exports</code> value.</p>\n<p>This Module Namespace Exotic Object can be directly observed either when using\n<code>import * as m from 'cjs'</code> or a dynamic import:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import * as m from 'cjs';\nconsole.log(m);\nconsole.log(m === await import('cjs'));\n// Prints:\n//   [Module] { default: &#x3C;module.exports> }\n//   true\n</code></pre>\n<p>For better compatibility with existing usage in the JS ecosystem, Node.js\nin addition attempts to determine the CommonJS named exports of every imported\nCommonJS module to provide them as separate ES module exports using a static\nanalysis process.</p>\n<p>For example, consider a CommonJS module written:</p>\n<pre><code class=\"language-cjs\">// cjs.cjs\nexports.name = 'exported';\n</code></pre>\n<p>The preceding module supports named imports in ES modules:</p>\n<!-- eslint-disable no-duplicate-imports -->\n<pre><code class=\"language-js\">import { name } from './cjs.cjs';\nconsole.log(name);\n// Prints: 'exported'\n\nimport cjs from './cjs.cjs';\nconsole.log(cjs);\n// Prints: { name: 'exported' }\n\nimport * as m from './cjs.cjs';\nconsole.log(m);\n// Prints: [Module] { default: { name: 'exported' }, name: 'exported' }\n</code></pre>\n<p>As can be seen from the last example of the Module Namespace Exotic Object being\nlogged, the <code>name</code> export is copied off of the <code>module.exports</code> object and set\ndirectly on the ES module namespace when the module is imported.</p>\n<p>Live binding updates or new exports added to <code>module.exports</code> are not detected\nfor these named exports.</p>\n<p>The detection of named exports is based on common syntax patterns but does not\nalways correctly detect named exports. In these cases, using the default\nimport form described above can be a better option.</p>\n<p>Named exports detection covers many common export patterns, reexport patterns\nand build tool and transpiler outputs. See <a href=\"https://github.com/guybedford/cjs-module-lexer/tree/1.2.2\">cjs-module-lexer</a> for the exact\nsemantics implemented.</p>",
               "type": "module",
-              "displayName": "`import` statements"
+              "displayName": "CommonJS Namespaces"
             },
             {
-              "textRaw": "`import()` expressions",
-              "name": "`import()`_expressions",
-              "desc": "<p><a href=\"https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports\">Dynamic <code>import()</code></a> is supported in both CommonJS and ES modules. It can be\nused to include ES module files from CommonJS code.</p>",
+              "textRaw": "Differences between ES modules and CommonJS",
+              "name": "differences_between_es_modules_and_commonjs",
+              "modules": [
+                {
+                  "textRaw": "No `require`, `exports` or `module.exports`",
+                  "name": "no_`require`,_`exports`_or_`module.exports`",
+                  "desc": "<p>In most cases, the ES module <code>import</code> can be used to load CommonJS modules.</p>\n<p>If needed, a <code>require</code> function can be constructed within an ES module using\n<a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>",
+                  "type": "module",
+                  "displayName": "No `require`, `exports` or `module.exports`"
+                },
+                {
+                  "textRaw": "No `__filename` or `__dirname`",
+                  "name": "no_`__filename`_or_`__dirname`",
+                  "desc": "<p>These CommonJS variables are not available in ES modules.</p>\n<p><code>__filename</code> and <code>__dirname</code> use cases can be replicated via\n<a href=\"esm.html#esm_import_meta_url\"><code>import.meta.url</code></a>.</p>",
+                  "type": "module",
+                  "displayName": "No `__filename` or `__dirname`"
+                },
+                {
+                  "textRaw": "No JSON Module Loading",
+                  "name": "no_json_module_loading",
+                  "desc": "<p>JSON imports are still experimental and only supported via the\n<code>--experimental-json-modules</code> flag.</p>\n<p>Local JSON files can be loaded relative to <code>import.meta.url</code> with <code>fs</code> directly:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import { readFile } from 'fs/promises';\nconst json = JSON.parse(await readFile(new URL('./dat.json', import.meta.url)));\n</code></pre>\n<p>Alternatively <code>module.createRequire()</code> can be used.</p>",
+                  "type": "module",
+                  "displayName": "No JSON Module Loading"
+                },
+                {
+                  "textRaw": "No Native Module Loading",
+                  "name": "no_native_module_loading",
+                  "desc": "<p>Native modules are not currently supported with ES module imports.</p>\n<p>They can instead be loaded with <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a> or\n<a href=\"process.html#process_process_dlopen_module_filename_flags\"><code>process.dlopen</code></a>.</p>",
+                  "type": "module",
+                  "displayName": "No Native Module Loading"
+                },
+                {
+                  "textRaw": "No `require.resolve`",
+                  "name": "no_`require.resolve`",
+                  "desc": "<p>Relative resolution can be handled via <code>new URL('./local', import.meta.url)</code>.</p>\n<p>For a complete <code>require.resolve</code> replacement, there is a flagged experimental\n<a href=\"esm.html#esm_import_meta_resolve_specifier_parent\"><code>import.meta.resolve</code></a> API.</p>\n<p>Alternatively <code>module.createRequire()</code> can be used.</p>",
+                  "type": "module",
+                  "displayName": "No `require.resolve`"
+                },
+                {
+                  "textRaw": "No `NODE_PATH`",
+                  "name": "no_`node_path`",
+                  "desc": "<p><code>NODE_PATH</code> is not part of resolving <code>import</code> specifiers. Please use symlinks\nif this behavior is desired.</p>",
+                  "type": "module",
+                  "displayName": "No `NODE_PATH`"
+                },
+                {
+                  "textRaw": "No `require.extensions`",
+                  "name": "no_`require.extensions`",
+                  "desc": "<p><code>require.extensions</code> is not used by <code>import</code>. The expectation is that loader\nhooks can provide this workflow in the future.</p>",
+                  "type": "module",
+                  "displayName": "No `require.extensions`"
+                },
+                {
+                  "textRaw": "No `require.cache`",
+                  "name": "no_`require.cache`",
+                  "desc": "<p><code>require.cache</code> is not used by <code>import</code> as the ES module loader has its own\nseparate cache.</p>\n<p><i id=\"esm_experimental_json_modules\"></i></p>",
+                  "type": "module",
+                  "displayName": "No `require.cache`"
+                }
+              ],
               "type": "module",
-              "displayName": "`import()` expressions"
+              "displayName": "Differences between ES modules and CommonJS"
             }
           ],
           "type": "misc",
           "displayName": "Interoperability with CommonJS"
         },
         {
-          "textRaw": "CommonJS Namespaces",
-          "name": "commonjs_namespaces",
-          "desc": "<p>CommonJS modules consist of a <code>module.exports</code> object which can be of any type.</p>\n<p>When importing a CommonJS module, it can be reliably imported using the ES\nmodule default import or its corresponding sugar syntax:</p>\n<!-- eslint-disable no-duplicate-imports -->\n<pre><code class=\"language-js\">import { default as cjs } from 'cjs';\n\n// The following import statement is \"syntax sugar\" (equivalent but sweeter)\n// for `{ default as cjsSugar }` in the above import statement:\nimport cjsSugar from 'cjs';\n\nconsole.log(cjs);\nconsole.log(cjs === cjsSugar);\n// Prints:\n//   &#x3C;module.exports>\n//   true\n</code></pre>\n<p>The ECMAScript Module Namespace representation of a CommonJS module is always\na namespace with a <code>default</code> export key pointing to the CommonJS\n<code>module.exports</code> value.</p>\n<p>This Module Namespace Exotic Object can be directly observed either when using\n<code>import * as m from 'cjs'</code> or a dynamic import:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import * as m from 'cjs';\nconsole.log(m);\nconsole.log(m === await import('cjs'));\n// Prints:\n//   [Module] { default: &#x3C;module.exports> }\n//   true\n</code></pre>\n<p>For better compatibility with existing usage in the JS ecosystem, Node.js\nin addition attempts to determine the CommonJS named exports of every imported\nCommonJS module to provide them as separate ES module exports using a static\nanalysis process.</p>\n<p>For example, consider a CommonJS module written:</p>\n<pre><code class=\"language-js\">// cjs.cjs\nexports.name = 'exported';\n</code></pre>\n<p>The preceding module supports named imports in ES modules:</p>\n<!-- eslint-disable no-duplicate-imports -->\n<pre><code class=\"language-js\">import { name } from './cjs.cjs';\nconsole.log(name);\n// Prints: 'exported'\n\nimport cjs from './cjs.cjs';\nconsole.log(cjs);\n// Prints: { name: 'exported' }\n\nimport * as m from './cjs.cjs';\nconsole.log(m);\n// Prints: [Module] { default: { name: 'exported' }, name: 'exported' }\n</code></pre>\n<p>As can be seen from the last example of the Module Namespace Exotic Object being\nlogged, the <code>name</code> export is copied off of the <code>module.exports</code> object and set\ndirectly on the ES module namespace when the module is imported.</p>\n<p>Live binding updates or new exports added to <code>module.exports</code> are not detected\nfor these named exports.</p>\n<p>The detection of named exports is based on common syntax patterns but does not\nalways correctly detect named exports. In these cases, using the default\nimport form described above can be a better option.</p>\n<p>Named exports detection covers many common export patterns, reexport patterns\nand build tool and transpiler outputs. See <a href=\"https://github.com/guybedford/cjs-module-lexer/tree/1.2.1\">cjs-module-lexer</a> for the exact\nsemantics implemented.</p>",
-          "type": "misc",
-          "displayName": "CommonJS Namespaces"
-        },
-        {
-          "textRaw": "Builtin modules",
-          "name": "builtin_modules",
-          "desc": "<p><a href=\"modules.html#modules_core_modules\">Core modules</a> provide named exports of their public API. A\ndefault export is also provided which is the value of the CommonJS exports.\nThe default export can be used for, among other things, modifying the named\nexports. Named exports of builtin modules are updated only by calling\n<a href=\"module.html#module_module_syncbuiltinesmexports\"><code>module.syncBuiltinESMExports()</code></a>.</p>\n<pre><code class=\"language-js\">import EventEmitter from 'events';\nconst e = new EventEmitter();\n</code></pre>\n<pre><code class=\"language-js\">import { readFile } from 'fs';\nreadFile('./foo.txt', (err, source) => {\n  if (err) {\n    console.error(err);\n  } else {\n    console.log(source);\n  }\n});\n</code></pre>\n<pre><code class=\"language-js\">import fs, { readFileSync } from 'fs';\nimport { syncBuiltinESMExports } from 'module';\n\nfs.readFileSync = () => Buffer.from('Hello, ESM');\nsyncBuiltinESMExports();\n\nfs.readFileSync === readFileSync;\n</code></pre>",
-          "type": "misc",
-          "displayName": "Builtin modules"
-        },
-        {
-          "textRaw": "CommonJS, JSON, and native modules",
-          "name": "commonjs,_json,_and_native_modules",
-          "desc": "<p>CommonJS, JSON, and native modules can be used with\n<a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>\n<pre><code class=\"language-js\">// cjs.cjs\nmodule.exports = 'cjs';\n\n// esm.mjs\nimport { createRequire } from 'module';\n\nconst require = createRequire(import.meta.url);\n\nconst cjs = require('./cjs.cjs');\ncjs === 'cjs'; // true\n</code></pre>",
+          "textRaw": "JSON modules",
+          "name": "json_modules",
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>Currently importing JSON modules are only supported in the <code>commonjs</code> mode\nand are loaded using the CJS loader. <a href=\"https://html.spec.whatwg.org/#creating-a-json-module-script\">WHATWG JSON modules specification</a> are\nstill being standardized, and are experimentally supported by including the\nadditional flag <code>--experimental-json-modules</code> when running Node.js.</p>\n<p>When the <code>--experimental-json-modules</code> flag is included, both the\n<code>commonjs</code> and <code>module</code> mode use the new experimental JSON\nloader. The imported JSON only exposes a <code>default</code>. There is no\nsupport for named exports. A cache entry is created in the CommonJS\ncache to avoid duplication. The same object is returned in\nCommonJS if the JSON module has already been imported from the\nsame path.</p>\n<p>Assuming an <code>index.mjs</code> with</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import packageConfig from './package.json';\n</code></pre>\n<p>The <code>--experimental-json-modules</code> flag is needed for the module\nto work.</p>\n<pre><code class=\"language-bash\">node index.mjs # fails\nnode --experimental-json-modules index.mjs # works\n</code></pre>\n<p><i id=\"esm_experimental_wasm_modules\"></i></p>",
           "type": "misc",
-          "displayName": "CommonJS, JSON, and native modules"
+          "displayName": "JSON modules"
         },
         {
-          "textRaw": "Experimental JSON modules",
-          "name": "experimental_json_modules",
-          "desc": "<p>Currently importing JSON modules are only supported in the <code>commonjs</code> mode\nand are loaded using the CJS loader. <a href=\"https://html.spec.whatwg.org/#creating-a-json-module-script\">WHATWG JSON modules specification</a> are\nstill being standardized, and are experimentally supported by including the\nadditional flag <code>--experimental-json-modules</code> when running Node.js.</p>\n<p>When the <code>--experimental-json-modules</code> flag is included, both the\n<code>commonjs</code> and <code>module</code> mode use the new experimental JSON\nloader. The imported JSON only exposes a <code>default</code>. There is no\nsupport for named exports. A cache entry is created in the CommonJS\ncache to avoid duplication. The same object is returned in\nCommonJS if the JSON module has already been imported from the\nsame path.</p>\n<p>Assuming an <code>index.mjs</code> with</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import packageConfig from './package.json';\n</code></pre>\n<p>The <code>--experimental-json-modules</code> flag is needed for the module\nto work.</p>\n<pre><code class=\"language-bash\">node index.mjs # fails\nnode --experimental-json-modules index.mjs # works\n</code></pre>",
+          "textRaw": "Wasm modules",
+          "name": "wasm_modules",
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>Importing Web Assembly modules is supported under the\n<code>--experimental-wasm-modules</code> flag, allowing any <code>.wasm</code> files to be\nimported as normal modules while also supporting their module imports.</p>\n<p>This integration is in line with the\n<a href=\"https://github.com/webassembly/esm-integration\">ES Module Integration Proposal for Web Assembly</a>.</p>\n<p>For example, an <code>index.mjs</code> containing:</p>\n<pre><code class=\"language-js\">import * as M from './module.wasm';\nconsole.log(M);\n</code></pre>\n<p>executed under:</p>\n<pre><code class=\"language-bash\">node --experimental-wasm-modules index.mjs\n</code></pre>\n<p>would provide the exports interface for the instantiation of <code>module.wasm</code>.</p>\n<p><i id=\"esm_experimental_top_level_await\"></i></p>",
           "type": "misc",
-          "displayName": "Experimental JSON modules"
+          "displayName": "Wasm modules"
         },
         {
-          "textRaw": "Experimental Wasm modules",
-          "name": "experimental_wasm_modules",
-          "desc": "<p>Importing Web Assembly modules is supported under the\n<code>--experimental-wasm-modules</code> flag, allowing any <code>.wasm</code> files to be\nimported as normal modules while also supporting their module imports.</p>\n<p>This integration is in line with the\n<a href=\"https://github.com/webassembly/esm-integration\">ES Module Integration Proposal for Web Assembly</a>.</p>\n<p>For example, an <code>index.mjs</code> containing:</p>\n<pre><code class=\"language-js\">import * as M from './module.wasm';\nconsole.log(M);\n</code></pre>\n<p>executed under:</p>\n<pre><code class=\"language-bash\">node --experimental-wasm-modules index.mjs\n</code></pre>\n<p>would provide the exports interface for the instantiation of <code>module.wasm</code>.</p>",
+          "textRaw": "Top-level `await`",
+          "name": "top-level_`await`",
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>The <code>await</code> keyword may be used in the top level (outside of async functions)\nwithin modules as per the <a href=\"https://github.com/tc39/proposal-top-level-await/\">ECMAScript Top-Level <code>await</code> proposal</a>.</p>\n<p>Assuming an <code>a.mjs</code> with</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">export const five = await Promise.resolve(5);\n</code></pre>\n<p>And a <code>b.mjs</code> with</p>\n<pre><code class=\"language-js\">import { five } from './a.mjs';\n\nconsole.log(five); // Logs `5`\n</code></pre>\n<pre><code class=\"language-bash\">node b.mjs # works\n</code></pre>\n<p><i id=\"esm_experimental_loaders\"></i></p>",
           "type": "misc",
-          "displayName": "Experimental Wasm modules"
+          "displayName": "Top-level `await`"
         },
         {
-          "textRaw": "Experimental loaders",
-          "name": "Experimental loaders",
+          "textRaw": "Loaders",
+          "name": "Loaders",
+          "stability": 1,
+          "stabilityText": "Experimental",
           "type": "misc",
           "desc": "<p><strong>Note: This API is currently being redesigned and will still change.</strong></p>\n<p>To customize the default module resolution, loader hooks can optionally be\nprovided via a <code>--experimental-loader ./loader-name.mjs</code> argument to Node.js.</p>\n<p>When hooks are used they only apply to ES module loading and not to any\nCommonJS modules loaded.</p>",
           "miscs": [
@@ -11115,7 +11806,7 @@
                       "params": []
                     }
                   ],
-                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>context</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n<li><code>defaultGetFormat</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a></li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>format</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n</li>\n</ul>\n<p>The <code>getFormat</code> hook provides a way to define a custom method of determining how\na URL should be interpreted. The <code>format</code> returned also affects what the\nacceptable forms of source values are for a module when parsing. This can be one\nof the following:</p>\n<table>\n<thead>\n<tr>\n<th><code>format</code></th>\n<th>Description</th>\n<th>Acceptable Types For <code>source</code> Returned by <code>getSource</code> or <code>transformSource</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'builtin'</code></td>\n<td>Load a Node.js builtin module</td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'dynamic'</code></td>\n<td>Use a <a href=\"esm.html#esm_code_dynamicinstantiate_code_hook\">dynamic instantiate hook</a></td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'commonjs'</code></td>\n<td>Load a Node.js CommonJS module</td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'json'</code></td>\n<td>Load a JSON file</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\"><code>string</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n<tr>\n<td><code>'module'</code></td>\n<td>Load an ES module</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\"><code>string</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n<tr>\n<td><code>'wasm'</code></td>\n<td>Load a WebAssembly module</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n</tbody>\n</table>\n<p>Note: These types all correspond to classes defined in ECMAScript.</p>\n<ul>\n<li>The specific <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> object is a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a>.</li>\n<li>The specific <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> object is a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>.</li>\n</ul>\n<p>Note: If the source value of a text-based format (i.e., <code>'json'</code>, <code>'module'</code>) is\nnot a string, it is converted to a string using <a href=\"util.md#util_class_util_textdecoder\"><code>util.TextDecoder</code></a>.</p>\n<pre><code class=\"language-js\">/**\n * @param {string} url\n * @param {Object} context (currently empty)\n * @param {Function} defaultGetFormat\n * @returns {Promise&#x3C;{ format: string }>}\n */\nexport async function getFormat(url, context, defaultGetFormat) {\n  if (Math.random() > 0.5) { // Some condition.\n    // For some or all URLs, do some custom logic for determining format.\n    // Always return an object of the form {format: &#x3C;string>}, where the\n    // format is one of the strings in the preceding table.\n    return {\n      format: 'module',\n    };\n  }\n  // Defer to Node.js for all other URLs.\n  return defaultGetFormat(url, context, defaultGetFormat);\n}\n</code></pre>"
+                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>context</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n<li><code>defaultGetFormat</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a></li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>format</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n</li>\n</ul>\n<p>The <code>getFormat</code> hook provides a way to define a custom method of determining how\na URL should be interpreted. The <code>format</code> returned also affects what the\nacceptable forms of source values are for a module when parsing. This can be one\nof the following:</p>\n<table>\n<thead>\n<tr>\n<th><code>format</code></th>\n<th>Description</th>\n<th>Acceptable Types For <code>source</code> Returned by <code>getSource</code> or <code>transformSource</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'builtin'</code></td>\n<td>Load a Node.js builtin module</td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'commonjs'</code></td>\n<td>Load a Node.js CommonJS module</td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'json'</code></td>\n<td>Load a JSON file</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\"><code>string</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n<tr>\n<td><code>'module'</code></td>\n<td>Load an ES module</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\"><code>string</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n<tr>\n<td><code>'wasm'</code></td>\n<td>Load a WebAssembly module</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n</tbody>\n</table>\n<p>Note: These types all correspond to classes defined in ECMAScript.</p>\n<ul>\n<li>The specific <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> object is a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a>.</li>\n<li>The specific <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> object is a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>.</li>\n</ul>\n<p>Note: If the source value of a text-based format (i.e., <code>'json'</code>, <code>'module'</code>) is\nnot a string, it is converted to a string using <a href=\"util.html#util_class_util_textdecoder\"><code>util.TextDecoder</code></a>.</p>\n<pre><code class=\"language-js\">/**\n * @param {string} url\n * @param {Object} context (currently empty)\n * @param {Function} defaultGetFormat\n * @returns {Promise&#x3C;{ format: string }>}\n */\nexport async function getFormat(url, context, defaultGetFormat) {\n  if (Math.random() > 0.5) { // Some condition.\n    // For some or all URLs, do some custom logic for determining format.\n    // Always return an object of the form {format: &#x3C;string>}, where the\n    // format is one of the strings in the preceding table.\n    return {\n      format: 'module',\n    };\n  }\n  // Defer to Node.js for all other URLs.\n  return defaultGetFormat(url, context, defaultGetFormat);\n}\n</code></pre>"
                 },
                 {
                   "textRaw": "`getSource(url, context, defaultGetSource)`",
@@ -11137,7 +11828,7 @@
                       "params": []
                     }
                   ],
-                  "desc": "<pre><code class=\"language-console\">NODE_OPTIONS='--experimental-loader ./custom-loader.mjs' node x.js\n</code></pre>\n<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li><code>source</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\" class=\"type\">&lt;SharedArrayBuffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\" class=\"type\">&lt;Uint8Array&gt;</a></li>\n<li><code>context</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>format</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>source</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\" class=\"type\">&lt;SharedArrayBuffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\" class=\"type\">&lt;Uint8Array&gt;</a></li>\n</ul>\n</li>\n</ul>\n<p>The <code>transformSource</code> hook provides a way to modify the source code of a loaded\nES module file after the source string has been loaded but before Node.js has\ndone anything with it.</p>\n<p>If this hook is used to convert unknown-to-Node.js file types into executable\nJavaScript, a resolve hook is also necessary in order to register any\nunknown-to-Node.js file extensions. See the <a href=\"esm.html#esm_transpiler_loader\">transpiler loader example</a> below.</p>\n<pre><code class=\"language-js\">/**\n * @param {!(string | SharedArrayBuffer | Uint8Array)} source\n * @param {{\n *   format: string,\n *   url: string,\n * }} context\n * @param {Function} defaultTransformSource\n * @returns {Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) }>}\n */\nexport async function transformSource(source, context, defaultTransformSource) {\n  const { url, format } = context;\n  if (Math.random() > 0.5) { // Some condition.\n    // For some or all URLs, do some custom logic for modifying the source.\n    // Always return an object of the form {source: &#x3C;string|buffer>}.\n    return {\n      source: '...',\n    };\n  }\n  // Defer to Node.js for all other sources.\n  return defaultTransformSource(source, context, defaultTransformSource);\n}\n</code></pre>"
+                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li><code>source</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\" class=\"type\">&lt;SharedArrayBuffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\" class=\"type\">&lt;Uint8Array&gt;</a></li>\n<li><code>context</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>format</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>source</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\" class=\"type\">&lt;SharedArrayBuffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\" class=\"type\">&lt;Uint8Array&gt;</a></li>\n</ul>\n</li>\n</ul>\n<p>The <code>transformSource</code> hook provides a way to modify the source code of a loaded\nES module file after the source string has been loaded but before Node.js has\ndone anything with it.</p>\n<p>If this hook is used to convert unknown-to-Node.js file types into executable\nJavaScript, a resolve hook is also necessary in order to register any\nunknown-to-Node.js file extensions. See the <a href=\"esm.html#esm_transpiler_loader\">transpiler loader example</a> below.</p>\n<pre><code class=\"language-js\">/**\n * @param {!(string | SharedArrayBuffer | Uint8Array)} source\n * @param {{\n *   format: string,\n *   url: string,\n * }} context\n * @param {Function} defaultTransformSource\n * @returns {Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) }>}\n */\nexport async function transformSource(source, context, defaultTransformSource) {\n  const { url, format } = context;\n  if (Math.random() > 0.5) { // Some condition.\n    // For some or all URLs, do some custom logic for modifying the source.\n    // Always return an object of the form {source: &#x3C;string|buffer>}.\n    return {\n      source: '...',\n    };\n  }\n  // Defer to Node.js for all other sources.\n  return defaultTransformSource(source, context, defaultTransformSource);\n}\n</code></pre>"
                 },
                 {
                   "textRaw": "`getGlobalPreloadCode()`",
@@ -11148,17 +11839,10 @@
                       "params": []
                     }
                   ],
-                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n<p>Sometimes it might be necessary to run some code inside of the same global scope\nthat the application runs in. This hook allows the return of a string that is\nrun as sloppy-mode script on startup.</p>\n<p>Similar to how CommonJS wrappers work, the code runs in an implicit function\nscope. The only argument is a <code>require</code>-like function that can be used to load\nbuiltins like \"fs\": <code>getBuiltin(request: string)</code>.</p>\n<p>If the code needs more advanced <code>require</code> features, it has to construct\nits own <code>require</code> using  <code>module.createRequire()</code>.</p>\n<pre><code class=\"language-js\">/**\n * @returns {string} Code to run before application startup\n */\nexport function getGlobalPreloadCode() {\n  return `\\\nglobalThis.someInjectedProperty = 42;\nconsole.log('I just set some globals!');\n\nconst { createRequire } = getBuiltin('module');\n\nconst require = createRequire(process.cwd() + '/&#x3C;preload>');\n// [...]\n`;\n}\n</code></pre>"
+                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n<p>Sometimes it might be necessary to run some code inside of the same global scope\nthat the application runs in. This hook allows the return of a string that is\nrun as sloppy-mode script on startup.</p>\n<p>Similar to how CommonJS wrappers work, the code runs in an implicit function\nscope. The only argument is a <code>require</code>-like function that can be used to load\nbuiltins like \"fs\": <code>getBuiltin(request: string)</code>.</p>\n<p>If the code needs more advanced <code>require</code> features, it has to construct\nits own <code>require</code> using  <code>module.createRequire()</code>.</p>\n<pre><code class=\"language-js\">/**\n * @returns {string} Code to run before application startup\n */\nexport function getGlobalPreloadCode() {\n  return `\\\nglobalThis.someInjectedProperty = 42;\nconsole.log('I just set some globals!');\n\nconst { createRequire } = getBuiltin('module');\n\nconst require = createRequire(process.cwd() + '/&#x3C;preload>');\n// [...]\n`;\n}\n</code></pre>\n<h3>Examples</h3>\n<p>The various loader hooks can be used together to accomplish wide-ranging\ncustomizations of Node.js’ code loading and evaluation behaviors.</p>"
                 }
               ],
               "modules": [
-                {
-                  "textRaw": "<code>dynamicInstantiate</code> hook",
-                  "name": "<code>dynamicinstantiate</code>_hook",
-                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<p>To create a custom dynamic module that doesn't correspond to one of the\nexisting <code>format</code> interpretations, the <code>dynamicInstantiate</code> hook can be used.\nThis hook is called only for modules that return <code>format: 'dynamic'</code> from\nthe <code>getFormat</code> hook.</p>\n<pre><code class=\"language-js\">/**\n * @param {string} url\n * @returns {object} response\n * @returns {array} response.exports\n * @returns {function} response.execute\n */\nexport async function dynamicInstantiate(url) {\n  return {\n    exports: ['customExportName'],\n    execute: (exports) => {\n      // Get and set functions provided for pre-allocated export names\n      exports.customExportName.set('value');\n    }\n  };\n}\n</code></pre>\n<p>With the list of module exports provided upfront, the <code>execute</code> function will\nthen be called at the exact point of module evaluation order for that module\nin the import tree.</p>\n<h3>Examples</h3>\n<p>The various loader hooks can be used together to accomplish wide-ranging\ncustomizations of Node.js’ code loading and evaluation behaviors.</p>",
-                  "type": "module",
-                  "displayName": "<code>dynamicInstantiate</code> hook"
-                },
                 {
                   "textRaw": "HTTPS loader",
                   "name": "https_loader",
@@ -11193,7 +11877,7 @@
             {
               "textRaw": "Resolver algorithm",
               "name": "resolver_algorithm",
-              "desc": "<p>The algorithm to load an ES module specifier is given through the\n<strong>ESM_RESOLVE</strong> method below. It returns the resolved URL for a\nmodule specifier relative to a parentURL.</p>\n<p>The algorithm to determine the module format of a resolved URL is\nprovided by <strong>ESM_FORMAT</strong>, which returns the unique module\nformat for any file. The <em>\"module\"</em> format is returned for an ECMAScript\nModule, while the <em>\"commonjs\"</em> format is used to indicate loading through the\nlegacy CommonJS loader. Additional formats such as <em>\"addon\"</em> can be extended in\nfuture updates.</p>\n<p>In the following algorithms, all subroutine errors are propagated as errors\nof these top-level routines unless stated otherwise.</p>\n<p><em>defaultConditions</em> is the conditional environment name array,\n<code>[\"node\", \"import\"]</code>.</p>\n<p>The resolver can throw the following errors:</p>\n<ul>\n<li><em>Invalid Module Specifier</em>: Module specifier is an invalid URL, package name\nor package subpath specifier.</li>\n<li><em>Invalid Package Configuration</em>: package.json configuration is invalid or\ncontains an invalid configuration.</li>\n<li><em>Invalid Package Target</em>: Package exports or imports define a target module\nfor the package that is an invalid type or string target.</li>\n<li><em>Package Path Not Exported</em>: Package exports do not define or permit a target\nsubpath in the package for the given module.</li>\n<li><em>Package Import Not Defined</em>: Package imports do not define the specifier.</li>\n<li><em>Module Not Found</em>: The package or module requested does not exist.</li>\n</ul>",
+              "desc": "<p>The algorithm to load an ES module specifier is given through the\n<strong>ESM_RESOLVE</strong> method below. It returns the resolved URL for a\nmodule specifier relative to a parentURL.</p>\n<p>The algorithm to determine the module format of a resolved URL is\nprovided by <strong>ESM_FORMAT</strong>, which returns the unique module\nformat for any file. The <em>\"module\"</em> format is returned for an ECMAScript\nModule, while the <em>\"commonjs\"</em> format is used to indicate loading through the\nlegacy CommonJS loader. Additional formats such as <em>\"addon\"</em> can be extended in\nfuture updates.</p>\n<p>In the following algorithms, all subroutine errors are propagated as errors\nof these top-level routines unless stated otherwise.</p>\n<p><em>defaultConditions</em> is the conditional environment name array,\n<code>[\"node\", \"import\"]</code>.</p>\n<p>The resolver can throw the following errors:</p>\n<ul>\n<li><em>Invalid Module Specifier</em>: Module specifier is an invalid URL, package name\nor package subpath specifier.</li>\n<li><em>Invalid Package Configuration</em>: package.json configuration is invalid or\ncontains an invalid configuration.</li>\n<li><em>Invalid Package Target</em>: Package exports or imports define a target module\nfor the package that is an invalid type or string target.</li>\n<li><em>Package Path Not Exported</em>: Package exports do not define or permit a target\nsubpath in the package for the given module.</li>\n<li><em>Package Import Not Defined</em>: Package imports do not define the specifier.</li>\n<li><em>Module Not Found</em>: The package or module requested does not exist.</li>\n<li><em>Unsupported Directory Import</em>: The resolved path corresponds to a directory,\nwhich is not a supported target for module imports.</li>\n</ul>",
               "type": "module",
               "displayName": "Resolver algorithm"
             },
@@ -11207,6 +11891,8 @@
             {
               "textRaw": "Customizing ESM specifier resolution algorithm",
               "name": "customizing_esm_specifier_resolution_algorithm",
+              "stability": 1,
+              "stabilityText": "Experimental",
               "desc": "<p>The current specifier resolution does not support all default behavior of\nthe CommonJS loader. One of the behavior differences is automatic resolution\nof file extensions and the ability to import directories that have an index\nfile.</p>\n<p>The <code>--experimental-specifier-resolution=[mode]</code> flag can be used to customize\nthe extension resolution algorithm. The default mode is <code>explicit</code>, which\nrequires the full path to a module be provided to the loader. To enable the\nautomatic extension resolution and importing from directories that include an\nindex file use the <code>node</code> mode.</p>\n<pre><code class=\"language-console\">$ node index.mjs\nsuccess!\n$ node index # Failure!\nError: Cannot find module\n$ node --experimental-specifier-resolution=node index\nsuccess!\n</code></pre>\n<!-- Note: The cjs-module-lexer link should be kept in-sync with the deps version -->",
               "type": "module",
               "displayName": "Customizing ESM specifier resolution algorithm"
@@ -11221,28 +11907,58 @@
           "textRaw": "`meta` {Object}",
           "type": "Object",
           "name": "meta",
-          "desc": "<p>The <code>import.meta</code> metaproperty is an <code>Object</code> that contains the following\nproperty:</p>\n<ul>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The absolute <code>file:</code> URL of the module.</li>\n</ul>"
+          "desc": "<p>The <code>import.meta</code> meta property is an <code>Object</code> that contains the following\nproperties.</p>",
+          "properties": [
+            {
+              "textRaw": "`url` {string} The absolute `file:` URL of the module.",
+              "type": "string",
+              "name": "url",
+              "desc": "<p>This is defined exactly the same as it is in browsers providing the URL of the\ncurrent module file.</p>\n<p>This enables useful patterns such as relative file loading:</p>\n<pre><code class=\"language-js\">import { readFileSync } from 'fs';\nconst buffer = readFileSync(new URL('./data.proto', import.meta.url));\n</code></pre>",
+              "shortDesc": "The absolute `file:` URL of the module."
+            }
+          ],
+          "methods": [
+            {
+              "textRaw": "`import.meta.resolve(specifier[, parent])`",
+              "type": "method",
+              "name": "resolve",
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<!--\nadded:\n  - v13.9.0\n  - v12.16.2\nchanges:\n  - version: v14.18.0\n    pr-url: https://github.com/nodejs/node/pull/38587\n    description: Add support for WHATWG `URL` object to `parentURL` parameter.\n-->\n<blockquote>\n<p>Stability: 1 - Experimental</p>\n</blockquote>\n<p>This feature is only available with the <code>--experimental-import-meta-resolve</code>\ncommand flag enabled.</p>\n<ul>\n<li><code>specifier</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The module specifier to resolve relative to <code>parent</code>.</li>\n<li><code>parent</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The absolute parent module URL to resolve from. If none\nis specified, the value of <code>import.meta.url</code> is used as the default.</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise\" class=\"type\">&lt;Promise&gt;</a></li>\n</ul>\n<p>Provides a module-relative resolution function scoped to each module, returning\nthe URL string.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">const dependencyAsset = await import.meta.resolve('component-lib/asset.css');\n</code></pre>\n<p><code>import.meta.resolve</code> also accepts a second argument which is the parent module\nfrom which to resolve from:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">await import.meta.resolve('./dep', import.meta.url);\n</code></pre>\n<p>This function is asynchronous because the ES module resolver in Node.js is\nallowed to be asynchronous.</p>"
+            }
+          ]
         }
-      ]
+      ],
+      "source": "doc/api/esm.md"
     },
     {
       "textRaw": "Modules: Packages",
       "name": "Modules: Packages",
+      "introduced_in": "v12.20.0",
       "type": "misc",
       "meta": {
         "changes": [
           {
-            "version": "v12.20.0",
+            "version": [
+              "v14.13.0"
+            ],
             "pr-url": "https://github.com/nodejs/node/pull/34718",
             "description": "Add support for `\"exports\"` patterns."
           },
           {
-            "version": "v12.19.0",
+            "version": [
+              "v14.6.0",
+              "v12.19.0"
+            ],
             "pr-url": "https://github.com/nodejs/node/pull/34117",
             "description": "Add package `\"imports\"` field."
           },
           {
             "version": [
+              "v13.7.0",
               "v12.16.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/31001",
@@ -11250,6 +11966,7 @@
           },
           {
             "version": [
+              "v13.6.0",
               "v12.16.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/31002",
@@ -11290,6 +12007,12 @@
             {
               "textRaw": "`--input-type` flag",
               "name": "`--input-type`_flag",
+              "meta": {
+                "added": [
+                  "v12.0.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>Strings passed in as an argument to <code>--eval</code> (or <code>-e</code>), or piped to <code>node</code> via\n<code>STDIN</code>, are treated as <a href=\"esm.html\">ES modules</a> when the <code>--input-type=module</code> flag\nis set.</p>\n<pre><code class=\"language-bash\">node --input-type=module --eval \"import { sep } from 'path'; console.log(sep);\"\n\necho \"import { sep } from 'path'; console.log(sep);\" | node --input-type=module\n</code></pre>\n<p>For completeness there is also <code>--input-type=commonjs</code>, for explicitly running\nstring input as CommonJS. This is the default behavior if <code>--input-type</code> is\nunspecified.</p>",
               "type": "module",
               "displayName": "`--input-type` flag"
@@ -11301,7 +12024,7 @@
         {
           "textRaw": "Package entry points",
           "name": "package_entry_points",
-          "desc": "<p>In a package’s <code>package.json</code> file, two fields can define entry points for a\npackage: <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> and <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a>. The <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> field is supported\nin all versions of Node.js, but its capabilities are limited: it only defines\nthe main entry point of the package.</p>\n<p>The <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field provides an alternative to <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> where the\npackage main entry point can be defined while also encapsulating the package,\n<strong>preventing any other entry points besides those defined in <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a></strong>.\nThis encapsulation allows module authors to define a public interface for\ntheir package.</p>\n<p>If both <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> and <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> are defined, the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field\ntakes precedence over <a href=\"packages.html#packages_main\"><code>\"main\"</code></a>. <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> are not specific to ES\nmodules or CommonJS; <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> is overridden by <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> if it\nexists. As such <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> cannot be used as a fallback for CommonJS but it\ncan be used as a fallback for legacy versions of Node.js that do not support the\n<a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field.</p>\n<p><a href=\"packages.html#packages_conditional_exports\">Conditional exports</a> can be used within <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> to define different\npackage entry points per environment, including whether the package is\nreferenced via <code>require</code> or via <code>import</code>. For more information about supporting\nboth CommonJS and ES Modules in a single package please consult\n<a href=\"packages.html#packages_dual_commonjs_es_module_packages\">the dual CommonJS/ES module packages section</a>.</p>\n<p><strong>Warning</strong>: Introducing the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field prevents consumers of a\npackage from using any entry points that are not defined, including the\n<a href=\"packages.html#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> (e.g. <code>require('your-package/package.json')</code>. <strong>This will\nlikely be a breaking change.</strong></p>\n<p>To make the introduction of <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> non-breaking, ensure that every\npreviously supported entry point is exported. It is best to explicitly specify\nentry points so that the package’s public API is well-defined. For example,\na project that previous exported <code>main</code>, <code>lib</code>,\n<code>feature</code>, and the <code>package.json</code> could use the following <code>package.exports</code>:</p>\n<pre><code class=\"language-json\">{\n  \"name\": \"my-mod\",\n  \"exports\": {\n    \".\": \"./lib/index.js\",\n    \"./lib\": \"./lib/index.js\",\n    \"./lib/index\": \"./lib/index.js\",\n    \"./lib/index.js\": \"./lib/index.js\",\n    \"./feature\": \"./feature/index.js\",\n    \"./feature/index.js\": \"./feature/index.js\",\n    \"./package.json\": \"./package.json\"\n  }\n}\n</code></pre>\n<p>Alternatively a project could choose to export entire folders:</p>\n<pre><code class=\"language-json\">{\n  \"name\": \"my-mod\",\n  \"exports\": {\n    \".\": \"./lib/index.js\",\n    \"./lib\": \"./lib/index.js\",\n    \"./lib/*\": \"./lib/*.js\",\n    \"./feature\": \"./feature/index.js\",\n    \"./feature/*\": \"./feature/*.js\",\n    \"./package.json\": \"./package.json\"\n  }\n}\n</code></pre>\n<p>As a last resort, package encapsulation can be disabled entirely by creating an\nexport for the root of the package <code>\"./*\": \"./*\"</code>. This exposes every file\nin the package at the cost of disabling the encapsulation and potential tooling\nbenefits this provides. As the ES Module loader in Node.js enforces the use of\n<a href=\"esm.md#esm_mandatory_file_extensions\">the full specifier path</a>, exporting the root rather than being explicit\nabout entry is less expressive than either of the prior examples. Not only\nis encapsulation lost but module consumers are unable to\n<code>import feature from 'my-mod/feature'</code> as they need to provide the full\npath <code>import feature from 'my-mod/feature/index.js</code>.</p>",
+          "desc": "<p>In a package’s <code>package.json</code> file, two fields can define entry points for a\npackage: <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> and <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a>. The <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> field is supported\nin all versions of Node.js, but its capabilities are limited: it only defines\nthe main entry point of the package.</p>\n<p>The <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field provides an alternative to <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> where the\npackage main entry point can be defined while also encapsulating the package,\n<strong>preventing any other entry points besides those defined in <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a></strong>.\nThis encapsulation allows module authors to define a public interface for\ntheir package.</p>\n<p>If both <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> and <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> are defined, the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field\ntakes precedence over <a href=\"packages.html#packages_main\"><code>\"main\"</code></a>. <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> are not specific to ES\nmodules or CommonJS; <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> is overridden by <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> if it\nexists. As such <a href=\"packages.html#packages_main\"><code>\"main\"</code></a> cannot be used as a fallback for CommonJS but it\ncan be used as a fallback for legacy versions of Node.js that do not support the\n<a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field.</p>\n<p><a href=\"packages.html#packages_conditional_exports\">Conditional exports</a> can be used within <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> to define different\npackage entry points per environment, including whether the package is\nreferenced via <code>require</code> or via <code>import</code>. For more information about supporting\nboth CommonJS and ES Modules in a single package please consult\n<a href=\"packages.html#packages_dual_commonjs_es_module_packages\">the dual CommonJS/ES module packages section</a>.</p>\n<p><strong>Warning</strong>: Introducing the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field prevents consumers of a\npackage from using any entry points that are not defined, including the\n<a href=\"packages.html#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> (e.g. <code>require('your-package/package.json')</code>. <strong>This will\nlikely be a breaking change.</strong></p>\n<p>To make the introduction of <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> non-breaking, ensure that every\npreviously supported entry point is exported. It is best to explicitly specify\nentry points so that the package’s public API is well-defined. For example,\na project that previous exported <code>main</code>, <code>lib</code>,\n<code>feature</code>, and the <code>package.json</code> could use the following <code>package.exports</code>:</p>\n<pre><code class=\"language-json\">{\n  \"name\": \"my-mod\",\n  \"exports\": {\n    \".\": \"./lib/index.js\",\n    \"./lib\": \"./lib/index.js\",\n    \"./lib/index\": \"./lib/index.js\",\n    \"./lib/index.js\": \"./lib/index.js\",\n    \"./feature\": \"./feature/index.js\",\n    \"./feature/index.js\": \"./feature/index.js\",\n    \"./package.json\": \"./package.json\"\n  }\n}\n</code></pre>\n<p>Alternatively a project could choose to export entire folders:</p>\n<pre><code class=\"language-json\">{\n  \"name\": \"my-mod\",\n  \"exports\": {\n    \".\": \"./lib/index.js\",\n    \"./lib\": \"./lib/index.js\",\n    \"./lib/*\": \"./lib/*.js\",\n    \"./feature\": \"./feature/index.js\",\n    \"./feature/*\": \"./feature/*.js\",\n    \"./package.json\": \"./package.json\"\n  }\n}\n</code></pre>\n<p>As a last resort, package encapsulation can be disabled entirely by creating an\nexport for the root of the package <code>\"./*\": \"./*\"</code>. This exposes every file\nin the package at the cost of disabling the encapsulation and potential tooling\nbenefits this provides. As the ES Module loader in Node.js enforces the use of\n<a href=\"esm.html#esm_mandatory_file_extensions\">the full specifier path</a>, exporting the root rather than being explicit\nabout entry is less expressive than either of the prior examples. Not only\nis encapsulation lost but module consumers are unable to\n<code>import feature from 'my-mod/feature'</code> as they need to provide the full\npath <code>import feature from 'my-mod/feature/index.js</code>.</p>",
           "modules": [
             {
               "textRaw": "Main entry point export",
@@ -11313,8 +12036,12 @@
             {
               "textRaw": "Subpath exports",
               "name": "subpath_exports",
-              "stability": 1,
-              "stabilityText": "Experimental",
+              "meta": {
+                "added": [
+                  "v12.7.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>When using the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field, custom subpaths can be defined along\nwith the main entry point by treating the main entry point as the\n<code>\".\"</code> subpath:</p>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\",\n  \"exports\": {\n    \".\": \"./main.js\",\n    \"./submodule\": \"./src/submodule.js\"\n  }\n}\n</code></pre>\n<p>Now only the defined subpath in <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> can be imported by a consumer:</p>\n<pre><code class=\"language-js\">import submodule from 'es-module-package/submodule';\n// Loads ./node_modules/es-module-package/src/submodule.js\n</code></pre>\n<p>While other subpaths will error:</p>\n<pre><code class=\"language-js\">import submodule from 'es-module-package/private-module.js';\n// Throws ERR_PACKAGE_PATH_NOT_EXPORTED\n</code></pre>",
               "type": "module",
               "displayName": "Subpath exports"
@@ -11322,8 +12049,13 @@
             {
               "textRaw": "Subpath imports",
               "name": "subpath_imports",
-              "stability": 1,
-              "stabilityText": "Experimental",
+              "meta": {
+                "added": [
+                  "v14.6.0",
+                  "v12.19.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>In addition to the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field, it is possible to define internal\npackage import maps that only apply to import specifiers from within the package\nitself.</p>\n<p>Entries in the imports field must always start with <code>#</code> to ensure they are\ndisambiguated from package specifiers.</p>\n<p>For example, the imports field can be used to gain the benefits of conditional\nexports for internal modules:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"imports\": {\n    \"#dep\": {\n      \"node\": \"dep-node-native\",\n      \"default\": \"./dep-polyfill.js\"\n    }\n  },\n  \"dependencies\": {\n    \"dep-node-native\": \"^1.0.0\"\n  }\n}\n</code></pre>\n<p>where <code>import '#dep'</code> does not get the resolution of the external package\n<code>dep-node-native</code> (including its exports in turn), and instead gets the local\nfile <code>./dep-polyfill.js</code> relative to the package in other environments.</p>\n<p>Unlike the <code>\"exports\"</code> field, the <code>\"imports\"</code> field permits mapping to external\npackages.</p>\n<p>The resolution rules for the imports field are otherwise\nanalogous to the exports field.</p>",
               "type": "module",
               "displayName": "Subpath imports"
@@ -11331,17 +12063,26 @@
             {
               "textRaw": "Subpath patterns",
               "name": "subpath_patterns",
-              "stability": 1,
-              "stabilityText": "Experimental",
-              "desc": "<p>For packages with a small number of exports or imports, we recommend\nexplicitly listing each exports subpath entry. But for packages that have\nlarge numbers of subpaths, this might cause <code>package.json</code> bloat and\nmaintenance issues.</p>\n<p>For these use cases, subpath export patterns can be used instead:</p>\n<pre><code class=\"language-json\">// ./node_modules/es-module-package/package.json\n{\n  \"exports\": {\n    \"./features/*\": \"./src/features/*.js\"\n  },\n  \"imports\": {\n    \"#internal/*\": \"./src/internal/*.js\"\n  }\n}\n</code></pre>\n<p>The left hand matching pattern must always end in <code>*</code>. All instances of <code>*</code> on\nthe right hand side will then be replaced with this value, including if it\ncontains any <code>/</code> separators.</p>\n<pre><code class=\"language-js\">import featureX from 'es-module-package/features/x';\n// Loads ./node_modules/es-module-package/src/features/x.js\n\nimport featureY from 'es-module-package/features/y/y';\n// Loads ./node_modules/es-module-package/src/features/y/y.js\n\nimport internalZ from '#internal/z';\n// Loads ./node_modules/es-module-package/src/internal/z.js\n</code></pre>\n<p>This is a direct static replacement without any special handling for file\nextensions. In the previous example, <code>pkg/features/x.json</code> would be resolved to\n<code>./src/features/x.json.js</code> in the mapping.</p>\n<p>The property of exports being statically enumerable is maintained with exports\npatterns since the individual exports for a package can be determined by\ntreating the right hand side target pattern as a <code>**</code> glob against the list of\nfiles within the package. Because <code>node_modules</code> paths are forbidden in exports\ntargets, this expansion is dependent on only the files of the package itself.</p>",
+              "meta": {
+                "added": [
+                  "v14.13.0",
+                  "v12.20.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>For packages with a small number of exports or imports, we recommend\nexplicitly listing each exports subpath entry. But for packages that have\nlarge numbers of subpaths, this might cause <code>package.json</code> bloat and\nmaintenance issues.</p>\n<p>For these use cases, subpath export patterns can be used instead:</p>\n<pre><code class=\"language-json\">// ./node_modules/es-module-package/package.json\n{\n  \"exports\": {\n    \"./features/*\": \"./src/features/*.js\"\n  },\n  \"imports\": {\n    \"#internal/*\": \"./src/internal/*.js\"\n  }\n}\n</code></pre>\n<p><strong><code>*</code> maps expose nested subpaths as it is a string replacement syntax\nonly.</strong></p>\n<p>The left hand matching pattern must always end in <code>*</code>. All instances of <code>*</code> on\nthe right hand side will then be replaced with this value, including if it\ncontains any <code>/</code> separators.</p>\n<pre><code class=\"language-js\">import featureX from 'es-module-package/features/x';\n// Loads ./node_modules/es-module-package/src/features/x.js\n\nimport featureY from 'es-module-package/features/y/y';\n// Loads ./node_modules/es-module-package/src/features/y/y.js\n\nimport internalZ from '#internal/z';\n// Loads ./node_modules/es-module-package/src/internal/z.js\n</code></pre>\n<p>This is a direct static replacement without any special handling for file\nextensions. In the previous example, <code>pkg/features/x.json</code> would be resolved to\n<code>./src/features/x.json.js</code> in the mapping.</p>\n<p>The property of exports being statically enumerable is maintained with exports\npatterns since the individual exports for a package can be determined by\ntreating the right hand side target pattern as a <code>**</code> glob against the list of\nfiles within the package. Because <code>node_modules</code> paths are forbidden in exports\ntargets, this expansion is dependent on only the files of the package itself.</p>\n<p>To exclude private subfolders from patterns, <code>null</code> targets can be used:</p>\n<pre><code class=\"language-json\">// ./node_modules/es-module-package/package.json\n{\n  \"exports\": {\n    \"./features/*\": \"./src/features/*.js\",\n    \"./features/private-internal/*\": null\n  }\n}\n</code></pre>\n<pre><code class=\"language-js\">import featureInternal from 'es-module-package/features/private-internal/m';\n// Throws: ERR_PACKAGE_PATH_NOT_EXPORTED\n\nimport featureX from 'es-module-package/features/x';\n// Loads ./node_modules/es-module-package/src/features/x.js\n</code></pre>",
               "type": "module",
               "displayName": "Subpath patterns"
             },
             {
               "textRaw": "Exports sugar",
               "name": "exports_sugar",
-              "stability": 1,
-              "stabilityText": "Experimental",
+              "meta": {
+                "added": [
+                  "v12.11.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>If the <code>\".\"</code> export is the only export, the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field provides sugar\nfor this case being the direct <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field value.</p>\n<p>If the <code>\".\"</code> export has a fallback array or string value, then the\n<a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field can be set to this value directly.</p>\n<pre><code class=\"language-json\">{\n  \"exports\": {\n    \".\": \"./main.js\"\n  }\n}\n</code></pre>\n<p>can be written:</p>\n<pre><code class=\"language-json\">{\n  \"exports\": \"./main.js\"\n}\n</code></pre>",
               "type": "module",
               "displayName": "Exports sugar"
@@ -11349,17 +12090,29 @@
             {
               "textRaw": "Conditional exports",
               "name": "conditional_exports",
-              "stability": 1,
-              "stabilityText": "Experimental",
-              "desc": "<p>Conditional exports provide a way to map to different paths depending on\ncertain conditions. They are supported for both CommonJS and ES module imports.</p>\n<p>For example, a package that wants to provide different ES module exports for\n<code>require()</code> and <code>import</code> can be written:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"main\": \"./main-require.cjs\",\n  \"exports\": {\n    \"import\": \"./main-module.js\",\n    \"require\": \"./main-require.cjs\"\n  },\n  \"type\": \"module\"\n}\n</code></pre>\n<p>Node.js supports the following conditions out of the box:</p>\n<ul>\n<li><code>\"import\"</code> - matches when the package is loaded via <code>import</code> or\n<code>import()</code>, or via any top-level import or resolve operation by the\nECMAScript module loader. Applies regardless of the module format of the\ntarget file. <em>Always mutually exclusive with <code>\"require\"</code>.</em></li>\n<li><code>\"require\"</code> - matches when the package is loaded via <code>require()</code>. The\nreferenced file should be loadable with <code>require()</code> although the condition\nmatches regardless of the module format of the target file. Expected\nformats include CommonJS, JSON, and native addons but not ES modules as\n<code>require()</code> doesn't support them. <em>Always mutually exclusive with\n<code>\"import\"</code>.</em></li>\n<li><code>\"node\"</code> - matches for any Node.js environment. Can be a CommonJS or ES\nmodule file. <em>This condition should always come after <code>\"import\"</code> or\n<code>\"require\"</code>.</em></li>\n<li><code>\"default\"</code> - the generic fallback that always matches. Can be a CommonJS\nor ES module file. <em>This condition should always come last.</em></li>\n</ul>\n<p>Within the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> object, key order is significant. During condition\nmatching, earlier entries have higher priority and take precedence over later\nentries. <em>The general rule is that conditions should be from most specific to\nleast specific in object order</em>.</p>\n<p>Other conditions such as <code>\"browser\"</code>, <code>\"electron\"</code>, <code>\"deno\"</code>, <code>\"react-native\"</code>,\netc., are unknown to Node.js, and thus ignored. Runtimes or tools other than\nNode.js can use them at their discretion. Further restrictions, definitions, or\nguidance on condition names might occur in the future.</p>\n<p>Using the <code>\"import\"</code> and <code>\"require\"</code> conditions can lead to some hazards,\nwhich are further explained in <a href=\"packages.html#packages_dual_commonjs_es_module_packages\">the dual CommonJS/ES module packages section</a>.</p>\n<p>Conditional exports can also be extended to exports subpaths, for example:</p>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\",\n  \"exports\": {\n    \".\": \"./main.js\",\n    \"./feature\": {\n      \"node\": \"./feature-node.js\",\n      \"default\": \"./feature.js\"\n    }\n  }\n}\n</code></pre>\n<p>Defines a package where <code>require('pkg/feature')</code> and <code>import 'pkg/feature'</code>\ncould provide different implementations between Node.js and other JS\nenvironments.</p>\n<p>When using environment branches, always include a <code>\"default\"</code> condition where\npossible. Providing a <code>\"default\"</code> condition ensures that any unknown JS\nenvironments are able to use this universal implementation, which helps avoid\nthese JS environments from having to pretend to be existing environments in\norder to support packages with conditional exports. For this reason, using\n<code>\"node\"</code> and <code>\"default\"</code> condition branches is usually preferable to using\n<code>\"node\"</code> and <code>\"browser\"</code> condition branches.</p>",
+              "meta": {
+                "added": [
+                  "v13.2.0",
+                  "v12.16.0"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.7.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31001",
+                    "description": "Unflag conditional exports."
+                  }
+                ]
+              },
+              "desc": "<p>Conditional exports provide a way to map to different paths depending on\ncertain conditions. They are supported for both CommonJS and ES module imports.</p>\n<p>For example, a package that wants to provide different ES module exports for\n<code>require()</code> and <code>import</code> can be written:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"main\": \"./main-require.cjs\",\n  \"exports\": {\n    \"import\": \"./main-module.js\",\n    \"require\": \"./main-require.cjs\"\n  },\n  \"type\": \"module\"\n}\n</code></pre>\n<p>Node.js implements the following conditions:</p>\n<ul>\n<li><code>\"import\"</code> - matches when the package is loaded via <code>import</code> or\n<code>import()</code>, or via any top-level import or resolve operation by the\nECMAScript module loader. Applies regardless of the module format of the\ntarget file. <em>Always mutually exclusive with <code>\"require\"</code>.</em></li>\n<li><code>\"require\"</code> - matches when the package is loaded via <code>require()</code>. The\nreferenced file should be loadable with <code>require()</code> although the condition\nmatches regardless of the module format of the target file. Expected\nformats include CommonJS, JSON, and native addons but not ES modules as\n<code>require()</code> doesn't support them. <em>Always mutually exclusive with\n<code>\"import\"</code>.</em></li>\n<li><code>\"node\"</code> - matches for any Node.js environment. Can be a CommonJS or ES\nmodule file. <em>This condition should always come after <code>\"import\"</code> or\n<code>\"require\"</code>.</em></li>\n<li><code>\"default\"</code> - the generic fallback that always matches. Can be a CommonJS\nor ES module file. <em>This condition should always come last.</em></li>\n</ul>\n<p>Within the <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> object, key order is significant. During condition\nmatching, earlier entries have higher priority and take precedence over later\nentries. <em>The general rule is that conditions should be from most specific to\nleast specific in object order</em>.</p>\n<p>Using the <code>\"import\"</code> and <code>\"require\"</code> conditions can lead to some hazards,\nwhich are further explained in <a href=\"packages.html#packages_dual_commonjs_es_module_packages\">the dual CommonJS/ES module packages section</a>.</p>\n<p>Conditional exports can also be extended to exports subpaths, for example:</p>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\",\n  \"exports\": {\n    \".\": \"./main.js\",\n    \"./feature\": {\n      \"node\": \"./feature-node.js\",\n      \"default\": \"./feature.js\"\n    }\n  }\n}\n</code></pre>\n<p>Defines a package where <code>require('pkg/feature')</code> and <code>import 'pkg/feature'</code>\ncould provide different implementations between Node.js and other JS\nenvironments.</p>\n<p>When using environment branches, always include a <code>\"default\"</code> condition where\npossible. Providing a <code>\"default\"</code> condition ensures that any unknown JS\nenvironments are able to use this universal implementation, which helps avoid\nthese JS environments from having to pretend to be existing environments in\norder to support packages with conditional exports. For this reason, using\n<code>\"node\"</code> and <code>\"default\"</code> condition branches is usually preferable to using\n<code>\"node\"</code> and <code>\"browser\"</code> condition branches.</p>",
               "type": "module",
               "displayName": "Conditional exports"
             },
             {
               "textRaw": "Nested conditions",
               "name": "nested_conditions",
-              "stability": 1,
-              "stabilityText": "Experimental",
               "desc": "<p>In addition to direct mappings, Node.js also supports nested condition objects.</p>\n<p>For example, to define a package that only has dual mode entry points for\nuse in Node.js but not the browser:</p>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\",\n  \"exports\": {\n    \"node\": {\n      \"import\": \"./feature-node.mjs\",\n      \"require\": \"./feature-node.cjs\"\n    },\n    \"default\": \"./feature.mjs\",\n  }\n}\n</code></pre>\n<p>Conditions continue to be matched in order as with flat conditions. If\na nested conditional does not have any mapping it will continue checking\nthe remaining conditions of the parent condition. In this way nested\nconditions behave analogously to nested JavaScript <code>if</code> statements.</p>",
               "type": "module",
               "displayName": "Nested conditions"
@@ -11367,14 +12120,44 @@
             {
               "textRaw": "Resolving user conditions",
               "name": "resolving_user_conditions",
+              "meta": {
+                "added": [
+                  "v14.9.0",
+                  "v12.19.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>When running Node.js, custom user conditions can be added with the\n<code>--conditions</code> flag:</p>\n<pre><code class=\"language-bash\">node --conditions=development main.js\n</code></pre>\n<p>which would then resolve the <code>\"development\"</code> condition in package imports and\nexports, while resolving the existing <code>\"node\"</code>, <code>\"default\"</code>, <code>\"import\"</code>, and\n<code>\"require\"</code> conditions as appropriate.</p>\n<p>Any number of custom conditions can be set with repeat flags.</p>",
               "type": "module",
               "displayName": "Resolving user conditions"
             },
+            {
+              "textRaw": "Conditions Definitions",
+              "name": "conditions_definitions",
+              "desc": "<p>The <code>\"import\"</code>, <code>\"require\"</code>, <code>\"node\"</code> and <code>\"default\"</code> conditions are defined\nand implemented in Node.js core,\n<a href=\"packages.html#packages_conditional_exports\">as specified above</a>.</p>\n<p>Other condition strings are unknown to Node.js and thus ignored by default.\nRuntimes or tools other than Node.js can use them at their discretion.</p>\n<p>These user conditions can be enabled in Node.js via the <a href=\"packages.html#packages_resolving_user_conditions\"><code>--conditions</code>\nflag</a>.</p>\n<p>The following condition definitions are currently endorsed by Node.js:</p>\n<ul>\n<li><code>\"browser\"</code> - any environment which implements a standard subset of global\nbrowser APIs available from JavaScript in web browsers, including the DOM\nAPIs.</li>\n<li><code>\"development\"</code> - can be used to define a development-only environment\nentry point. <em>Must always be mutually exclusive with <code>\"production\"</code>.</em></li>\n<li><code>\"production\"</code> - can be used to define a production environment entry\npoint. <em>Must always be mutually exclusive with <code>\"development\"</code>.</em></li>\n</ul>\n<p>The above user conditions can be enabled in Node.js via the <a href=\"packages.html#packages_resolving_user_conditions\"><code>--conditions</code>\nflag</a>.</p>\n<p>Platform specific conditions such as <code>\"deno\"</code>, <code>\"electron\"</code>, or <code>\"react-native\"</code>\nmay be used, but while there remain no implementation or integration intent\nfrom these platforms, the above are not explicitly endorsed by Node.js.</p>\n<p>New conditions definitions may be added to this list by creating a pull request\nto the <a href=\"https://github.com/nodejs/node/blob/HEAD/doc/api/packages.md#conditions-definitions\">Node.js documentation for this section</a>. The requirements for listing\na new condition definition here are that:</p>\n<ul>\n<li>The definition should be clear and unambiguous for all implementers.</li>\n<li>The use case for why the condition is needed should be clearly justified.</li>\n<li>There should exist sufficient existing implementation usage.</li>\n<li>The condition name should not conflict with another condition definition or\ncondition in wide usage.</li>\n<li>The listing of the condition definition should provide a coordination\nbenefit to the ecosystem that wouldn't otherwise be possible. For example,\nthis would not necessarily be the case for company-specific or\napplication-specific conditions.</li>\n</ul>\n<p>The above definitions may be moved to a dedicated conditions registry in due\ncourse.</p>",
+              "type": "module",
+              "displayName": "Conditions Definitions"
+            },
             {
               "textRaw": "Self-referencing a package using its name",
               "name": "self-referencing_a_package_using_its_name",
-              "desc": "<p>Within a package, the values defined in the package’s\n<code>package.json</code> <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field can be referenced via the package’s name.\nFor example, assuming the <code>package.json</code> is:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"name\": \"a-package\",\n  \"exports\": {\n    \".\": \"./main.mjs\",\n    \"./foo\": \"./foo.js\"\n  }\n}\n</code></pre>\n<p>Then any module <em>in that package</em> can reference an export in the package itself:</p>\n<pre><code class=\"language-js\">// ./a-module.mjs\nimport { something } from 'a-package'; // Imports \"something\" from ./main.mjs.\n</code></pre>\n<p>Self-referencing is available only if <code>package.json</code> has <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a>, and\nwill allow importing only what that <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> (in the <code>package.json</code>)\nallows. So the code below, given the previous package, will generate a runtime\nerror:</p>\n<pre><code class=\"language-js\">// ./another-module.mjs\n\n// Imports \"another\" from ./m.mjs. Fails because\n// the \"package.json\" \"exports\" field\n// does not provide an export named \"./m.mjs\".\nimport { another } from 'a-package/m.mjs';\n</code></pre>\n<p>Self-referencing is also available when using <code>require</code>, both in an ES module,\nand in a CommonJS one. For example, this code will also work:</p>\n<pre><code class=\"language-js\">// ./a-module.js\nconst { something } = require('a-package/foo'); // Loads from ./foo.js.\n</code></pre>",
+              "meta": {
+                "added": [
+                  "v13.1.0",
+                  "v12.16.0"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.6.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31002",
+                    "description": "Unflag self-referencing a package using its name."
+                  }
+                ]
+              },
+              "desc": "<p>Within a package, the values defined in the package’s\n<code>package.json</code> <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field can be referenced via the package’s name.\nFor example, assuming the <code>package.json</code> is:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"name\": \"a-package\",\n  \"exports\": {\n    \".\": \"./main.mjs\",\n    \"./foo\": \"./foo.js\"\n  }\n}\n</code></pre>\n<p>Then any module <em>in that package</em> can reference an export in the package itself:</p>\n<pre><code class=\"language-js\">// ./a-module.mjs\nimport { something } from 'a-package'; // Imports \"something\" from ./main.mjs.\n</code></pre>\n<p>Self-referencing is available only if <code>package.json</code> has <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a>, and\nwill allow importing only what that <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> (in the <code>package.json</code>)\nallows. So the code below, given the previous package, will generate a runtime\nerror:</p>\n<pre><code class=\"language-js\">// ./another-module.mjs\n\n// Imports \"another\" from ./m.mjs. Fails because\n// the \"package.json\" \"exports\" field\n// does not provide an export named \"./m.mjs\".\nimport { another } from 'a-package/m.mjs';\n</code></pre>\n<p>Self-referencing is also available when using <code>require</code>, both in an ES module,\nand in a CommonJS one. For example, this code will also work:</p>\n<pre><code class=\"language-cjs\">// ./a-module.js\nconst { something } = require('a-package/foo'); // Loads from ./foo.js.\n</code></pre>\n<p>Finally, self-referencing also works with scoped packages. For example, this\ncode will also work:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"name\": \"@my/package\",\n  \"exports\": \"./index.js\"\n}\n</code></pre>\n<pre><code class=\"language-cjs\">// ./index.js\nmodule.exports = 42;\n</code></pre>\n<pre><code class=\"language-cjs\">// ./other.js\nconsole.log(require('@my/package'));\n</code></pre>\n<pre><code class=\"language-console\">$ node other.js\n42\n</code></pre>",
               "type": "module",
               "displayName": "Self-referencing a package using its name"
             }
@@ -11402,14 +12185,14 @@
                 {
                   "textRaw": "Approach #1: Use an ES module wrapper",
                   "name": "approach_#1:_use_an_es_module_wrapper",
-                  "desc": "<p>Write the package in CommonJS or transpile ES module sources into CommonJS, and\ncreate an ES module wrapper file that defines the named exports. Using\n<a href=\"packages.html#packages_conditional_exports\">Conditional exports</a>, the ES module wrapper is used for <code>import</code> and the\nCommonJS entry point for <code>require</code>.</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \"import\": \"./wrapper.mjs\",\n    \"require\": \"./index.cjs\"\n  }\n}\n</code></pre>\n<p>The preceding example uses explicit extensions <code>.mjs</code> and <code>.cjs</code>.\nIf your files use the <code>.js</code> extension, <code>\"type\": \"module\"</code> will cause such files\nto be treated as ES modules, just as <code>\"type\": \"commonjs\"</code> would cause them\nto be treated as CommonJS.\nSee <a href=\"packages.html#esm_enabling\">Enabling</a>.</p>\n<pre><code class=\"language-js\">// ./node_modules/pkg/index.cjs\nexports.name = 'value';\n</code></pre>\n<pre><code class=\"language-js\">// ./node_modules/pkg/wrapper.mjs\nimport cjsModule from './index.cjs';\nexport const name = cjsModule.name;\n</code></pre>\n<p>In this example, the <code>name</code> from <code>import { name } from 'pkg'</code> is the same\nsingleton as the <code>name</code> from <code>const { name } = require('pkg')</code>. Therefore <code>===</code>\nreturns <code>true</code> when comparing the two <code>name</code>s and the divergent specifier hazard\nis avoided.</p>\n<p>If the module is not simply a list of named exports, but rather contains a\nunique function or object export like <code>module.exports = function () { ... }</code>,\nor if support in the wrapper for the <code>import pkg from 'pkg'</code> pattern is desired,\nthen the wrapper would instead be written to export the default optionally\nalong with any named exports as well:</p>\n<pre><code class=\"language-js\">import cjsModule from './index.cjs';\nexport const name = cjsModule.name;\nexport default cjsModule;\n</code></pre>\n<p>This approach is appropriate for any of the following use cases:</p>\n<ul>\n<li>The package is currently written in CommonJS and the author would prefer not\nto refactor it into ES module syntax, but wishes to provide named exports for\nES module consumers.</li>\n<li>The package has other packages that depend on it, and the end user might\ninstall both this package and those other packages. For example a <code>utilities</code>\npackage is used directly in an application, and a <code>utilities-plus</code> package\nadds a few more functions to <code>utilities</code>. Because the wrapper exports\nunderlying CommonJS files, it doesn’t matter if <code>utilities-plus</code> is written in\nCommonJS or ES module syntax; it will work either way.</li>\n<li>The package stores internal state, and the package author would prefer not to\nrefactor the package to isolate its state management. See the next section.</li>\n</ul>\n<p>A variant of this approach not requiring conditional exports for consumers could\nbe to add an export, e.g. <code>\"./module\"</code>, to point to an all-ES module-syntax\nversion of the package. This could be used via <code>import 'pkg/module'</code> by users\nwho are certain that the CommonJS version will not be loaded anywhere in the\napplication, such as by dependencies; or if the CommonJS version can be loaded\nbut doesn’t affect the ES module version (for example, because the package is\nstateless):</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \".\": \"./index.cjs\",\n    \"./module\": \"./wrapper.mjs\"\n  }\n}\n</code></pre>",
+                  "desc": "<p>Write the package in CommonJS or transpile ES module sources into CommonJS, and\ncreate an ES module wrapper file that defines the named exports. Using\n<a href=\"packages.html#packages_conditional_exports\">Conditional exports</a>, the ES module wrapper is used for <code>import</code> and the\nCommonJS entry point for <code>require</code>.</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \"import\": \"./wrapper.mjs\",\n    \"require\": \"./index.cjs\"\n  }\n}\n</code></pre>\n<p>The preceding example uses explicit extensions <code>.mjs</code> and <code>.cjs</code>.\nIf your files use the <code>.js</code> extension, <code>\"type\": \"module\"</code> will cause such files\nto be treated as ES modules, just as <code>\"type\": \"commonjs\"</code> would cause them\nto be treated as CommonJS.\nSee <a href=\"esm.html#esm_enabling\">Enabling</a>.</p>\n<pre><code class=\"language-cjs\">// ./node_modules/pkg/index.cjs\nexports.name = 'value';\n</code></pre>\n<pre><code class=\"language-js\">// ./node_modules/pkg/wrapper.mjs\nimport cjsModule from './index.cjs';\nexport const name = cjsModule.name;\n</code></pre>\n<p>In this example, the <code>name</code> from <code>import { name } from 'pkg'</code> is the same\nsingleton as the <code>name</code> from <code>const { name } = require('pkg')</code>. Therefore <code>===</code>\nreturns <code>true</code> when comparing the two <code>name</code>s and the divergent specifier hazard\nis avoided.</p>\n<p>If the module is not simply a list of named exports, but rather contains a\nunique function or object export like <code>module.exports = function () { ... }</code>,\nor if support in the wrapper for the <code>import pkg from 'pkg'</code> pattern is desired,\nthen the wrapper would instead be written to export the default optionally\nalong with any named exports as well:</p>\n<pre><code class=\"language-js\">import cjsModule from './index.cjs';\nexport const name = cjsModule.name;\nexport default cjsModule;\n</code></pre>\n<p>This approach is appropriate for any of the following use cases:</p>\n<ul>\n<li>The package is currently written in CommonJS and the author would prefer not\nto refactor it into ES module syntax, but wishes to provide named exports for\nES module consumers.</li>\n<li>The package has other packages that depend on it, and the end user might\ninstall both this package and those other packages. For example a <code>utilities</code>\npackage is used directly in an application, and a <code>utilities-plus</code> package\nadds a few more functions to <code>utilities</code>. Because the wrapper exports\nunderlying CommonJS files, it doesn’t matter if <code>utilities-plus</code> is written in\nCommonJS or ES module syntax; it will work either way.</li>\n<li>The package stores internal state, and the package author would prefer not to\nrefactor the package to isolate its state management. See the next section.</li>\n</ul>\n<p>A variant of this approach not requiring conditional exports for consumers could\nbe to add an export, e.g. <code>\"./module\"</code>, to point to an all-ES module-syntax\nversion of the package. This could be used via <code>import 'pkg/module'</code> by users\nwho are certain that the CommonJS version will not be loaded anywhere in the\napplication, such as by dependencies; or if the CommonJS version can be loaded\nbut doesn’t affect the ES module version (for example, because the package is\nstateless):</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \".\": \"./index.cjs\",\n    \"./module\": \"./wrapper.mjs\"\n  }\n}\n</code></pre>",
                   "type": "module",
                   "displayName": "Approach #1: Use an ES module wrapper"
                 },
                 {
                   "textRaw": "Approach #2: Isolate state",
                   "name": "approach_#2:_isolate_state",
-                  "desc": "<p>A <a href=\"packages.html#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> file can define the separate CommonJS and ES module entry\npoints directly:</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \"import\": \"./index.mjs\",\n    \"require\": \"./index.cjs\"\n  }\n}\n</code></pre>\n<p>This can be done if both the CommonJS and ES module versions of the package are\nequivalent, for example because one is the transpiled output of the other; and\nthe package’s management of state is carefully isolated (or the package is\nstateless).</p>\n<p>The reason that state is an issue is because both the CommonJS and ES module\nversions of the package might get used within an application; for example, the\nuser’s application code could <code>import</code> the ES module version while a dependency\n<code>require</code>s the CommonJS version. If that were to occur, two copies of the\npackage would be loaded in memory and therefore two separate states would be\npresent. This would likely cause hard-to-troubleshoot bugs.</p>\n<p>Aside from writing a stateless package (if JavaScript’s <code>Math</code> were a package,\nfor example, it would be stateless as all of its methods are static), there are\nsome ways to isolate state so that it’s shared between the potentially loaded\nCommonJS and ES module instances of the package:</p>\n<ol>\n<li>\n<p>If possible, contain all state within an instantiated object. JavaScript’s\n<code>Date</code>, for example, needs to be instantiated to contain state; if it were a\npackage, it would be used like this:</p>\n<pre><code class=\"language-js\">import Date from 'date';\nconst someDate = new Date();\n// someDate contains state; Date does not\n</code></pre>\n<p>The <code>new</code> keyword isn’t required; a package’s function can return a new\nobject, or modify a passed-in object, to keep the state external to the\npackage.</p>\n</li>\n<li>\n<p>Isolate the state in one or more CommonJS files that are shared between the\nCommonJS and ES module versions of the package. For example, if the CommonJS\nand ES module entry points are <code>index.cjs</code> and <code>index.mjs</code>, respectively:</p>\n<pre><code class=\"language-js\">// ./node_modules/pkg/index.cjs\nconst state = require('./state.cjs');\nmodule.exports.state = state;\n</code></pre>\n<pre><code class=\"language-js\">// ./node_modules/pkg/index.mjs\nimport state from './state.cjs';\nexport {\n  state\n};\n</code></pre>\n<p>Even if <code>pkg</code> is used via both <code>require</code> and <code>import</code> in an application (for\nexample, via <code>import</code> in application code and via <code>require</code> by a dependency)\neach reference of <code>pkg</code> will contain the same state; and modifying that\nstate from either module system will apply to both.</p>\n</li>\n</ol>\n<p>Any plugins that attach to the package’s singleton would need to separately\nattach to both the CommonJS and ES module singletons.</p>\n<p>This approach is appropriate for any of the following use cases:</p>\n<ul>\n<li>The package is currently written in ES module syntax and the package author\nwants that version to be used wherever such syntax is supported.</li>\n<li>The package is stateless or its state can be isolated without too much\ndifficulty.</li>\n<li>The package is unlikely to have other public packages that depend on it, or if\nit does, the package is stateless or has state that need not be shared between\ndependencies or with the overall application.</li>\n</ul>\n<p>Even with isolated state, there is still the cost of possible extra code\nexecution between the CommonJS and ES module versions of a package.</p>\n<p>As with the previous approach, a variant of this approach not requiring\nconditional exports for consumers could be to add an export, e.g.\n<code>\"./module\"</code>, to point to an all-ES module-syntax version of the package:</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \".\": \"./index.cjs\",\n    \"./module\": \"./index.mjs\"\n  }\n}\n</code></pre>",
+                  "desc": "<p>A <a href=\"packages.html#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> file can define the separate CommonJS and ES module entry\npoints directly:</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \"import\": \"./index.mjs\",\n    \"require\": \"./index.cjs\"\n  }\n}\n</code></pre>\n<p>This can be done if both the CommonJS and ES module versions of the package are\nequivalent, for example because one is the transpiled output of the other; and\nthe package’s management of state is carefully isolated (or the package is\nstateless).</p>\n<p>The reason that state is an issue is because both the CommonJS and ES module\nversions of the package might get used within an application; for example, the\nuser’s application code could <code>import</code> the ES module version while a dependency\n<code>require</code>s the CommonJS version. If that were to occur, two copies of the\npackage would be loaded in memory and therefore two separate states would be\npresent. This would likely cause hard-to-troubleshoot bugs.</p>\n<p>Aside from writing a stateless package (if JavaScript’s <code>Math</code> were a package,\nfor example, it would be stateless as all of its methods are static), there are\nsome ways to isolate state so that it’s shared between the potentially loaded\nCommonJS and ES module instances of the package:</p>\n<ol>\n<li>\n<p>If possible, contain all state within an instantiated object. JavaScript’s\n<code>Date</code>, for example, needs to be instantiated to contain state; if it were a\npackage, it would be used like this:</p>\n<pre><code class=\"language-js\">import Date from 'date';\nconst someDate = new Date();\n// someDate contains state; Date does not\n</code></pre>\n<p>The <code>new</code> keyword isn’t required; a package’s function can return a new\nobject, or modify a passed-in object, to keep the state external to the\npackage.</p>\n</li>\n<li>\n<p>Isolate the state in one or more CommonJS files that are shared between the\nCommonJS and ES module versions of the package. For example, if the CommonJS\nand ES module entry points are <code>index.cjs</code> and <code>index.mjs</code>, respectively:</p>\n<pre><code class=\"language-cjs\">// ./node_modules/pkg/index.cjs\nconst state = require('./state.cjs');\nmodule.exports.state = state;\n</code></pre>\n<pre><code class=\"language-js\">// ./node_modules/pkg/index.mjs\nimport state from './state.cjs';\nexport {\n  state\n};\n</code></pre>\n<p>Even if <code>pkg</code> is used via both <code>require</code> and <code>import</code> in an application (for\nexample, via <code>import</code> in application code and via <code>require</code> by a dependency)\neach reference of <code>pkg</code> will contain the same state; and modifying that\nstate from either module system will apply to both.</p>\n</li>\n</ol>\n<p>Any plugins that attach to the package’s singleton would need to separately\nattach to both the CommonJS and ES module singletons.</p>\n<p>This approach is appropriate for any of the following use cases:</p>\n<ul>\n<li>The package is currently written in ES module syntax and the package author\nwants that version to be used wherever such syntax is supported.</li>\n<li>The package is stateless or its state can be isolated without too much\ndifficulty.</li>\n<li>The package is unlikely to have other public packages that depend on it, or if\nit does, the package is stateless or has state that need not be shared between\ndependencies or with the overall application.</li>\n</ul>\n<p>Even with isolated state, there is still the cost of possible extra code\nexecution between the CommonJS and ES module versions of a package.</p>\n<p>As with the previous approach, a variant of this approach not requiring\nconditional exports for consumers could be to add an export, e.g.\n<code>\"./module\"</code>, to point to an all-ES module-syntax version of the package:</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \".\": \"./index.cjs\",\n    \"./module\": \"./index.mjs\"\n  }\n}\n</code></pre>",
                   "type": "module",
                   "displayName": "Approach #2: Isolate state"
                 }
@@ -11424,18 +12207,20 @@
         {
           "textRaw": "Node.js `package.json` field definitions",
           "name": "node.js_`package.json`_field_definitions",
-          "desc": "<p>This section describes the fields used by the Node.js runtime. Other tools (such\nas <a href=\"https://docs.npmjs.com/creating-a-package-json-file\">npm</a>) use\nadditional fields which are ignored by Node.js and not documented here.</p>\n<p>The following fields in <code>package.json</code> files are used in Node.js:</p>\n<ul>\n<li><a href=\"packages.html#packages_name\"><code>\"name\"</code></a> - Relevant when using named imports within a package. Also used\nby package managers as the name of the package.</li>\n<li><a href=\"packages.html#packages_type\"><code>\"type\"</code></a> - The package type determining whether to load <code>.js</code> files as\nCommonJS or ES modules.</li>\n<li><a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> - Package exports and conditional exports. When present,\nlimits which submodules can be loaded from within the package.</li>\n<li><a href=\"packages.html#packages_main\"><code>\"main\"</code></a> - The default module when loading the package, if exports is not\nspecified, and in versions of Node.js prior to the introduction of exports.</li>\n<li><a href=\"packages.html#packages_imports\"><code>\"imports\"</code></a> - Package imports, for use by modules within the package\nitself.</li>\n</ul>",
+          "desc": "<p>This section describes the fields used by the Node.js runtime. Other tools (such\nas <a href=\"https://docs.npmjs.com/creating-a-package-json-file\">npm</a>) use\nadditional fields which are ignored by Node.js and not documented here.</p>\n<p>The following fields in <code>package.json</code> files are used in Node.js:</p>\n<ul>\n<li><a href=\"packages.html#packages_name\"><code>\"name\"</code></a> - Relevant when using named imports within a package. Also used\nby package managers as the name of the package.</li>\n<li><a href=\"packages.html#packages_main\"><code>\"main\"</code></a> - The default module when loading the package, if exports is not\nspecified, and in versions of Node.js prior to the introduction of exports.</li>\n<li><a href=\"packages.html#packages_type\"><code>\"type\"</code></a> - The package type determining whether to load <code>.js</code> files as\nCommonJS or ES modules.</li>\n<li><a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> - Package exports and conditional exports. When present,\nlimits which submodules can be loaded from within the package.</li>\n<li><a href=\"packages.html#packages_imports\"><code>\"imports\"</code></a> - Package imports, for use by modules within the package\nitself.</li>\n</ul>",
           "modules": [
             {
               "textRaw": "`\"name\"`",
               "name": "`\"name\"`",
               "meta": {
                 "added": [
+                  "v13.1.0",
                   "v12.16.0"
                 ],
                 "changes": [
                   {
                     "version": [
+                      "v13.6.0",
                       "v12.16.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/31002",
@@ -11447,6 +12232,19 @@
               "type": "module",
               "displayName": "`\"name\"`"
             },
+            {
+              "textRaw": "`\"main\"`",
+              "name": "`\"main\"`",
+              "meta": {
+                "added": [
+                  "v0.4.0"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Type: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\"\n}\n</code></pre>\n<p>The <code>\"main\"</code> field defines the script that is used when the <a href=\"modules.html#modules_folders_as_modules\">package directory\nis loaded via <code>require()</code></a>. Its value\nis a path.</p>\n<pre><code class=\"language-cjs\">require('./path/to/directory'); // This resolves to ./path/to/directory/main.js.\n</code></pre>\n<p>When a package has an <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field, this will take precedence over the\n<code>\"main\"</code> field when importing the package by name.</p>",
+              "type": "module",
+              "displayName": "`\"main\"`"
+            },
             {
               "textRaw": "`\"type\"`",
               "name": "`\"type\"`",
@@ -11457,6 +12255,7 @@
                 "changes": [
                   {
                     "version": [
+                      "v13.2.0",
                       "v12.17.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/29866",
@@ -11478,31 +12277,35 @@
                 "changes": [
                   {
                     "version": [
-                      "v12.16.0"
+                      "v14.13.0",
+                      "v12.20.0"
                     ],
-                    "pr-url": "https://github.com/nodejs/node/pull/29978",
-                    "description": "Implement conditional exports."
+                    "pr-url": "https://github.com/nodejs/node/pull/34718",
+                    "description": "Add support for `\"exports\"` patterns."
                   },
                   {
                     "version": [
+                      "v13.7.0",
                       "v12.16.0"
                     ],
-                    "pr-url": "https://github.com/nodejs/node/pull/31001",
-                    "description": "Remove the `--experimental-conditional-exports` option."
+                    "pr-url": "https://github.com/nodejs/node/pull/31008",
+                    "description": "Implement logical conditional exports ordering."
                   },
                   {
                     "version": [
+                      "v13.7.0",
                       "v12.16.0"
                     ],
-                    "pr-url": "https://github.com/nodejs/node/pull/31008",
-                    "description": "Implement logical conditional exports ordering."
+                    "pr-url": "https://github.com/nodejs/node/pull/31001",
+                    "description": "Remove the `--experimental-conditional-exports` option."
                   },
                   {
                     "version": [
-                      "v12.20.0"
+                      "v13.2.0",
+                      "v12.16.0"
                     ],
-                    "pr-url": "https://github.com/nodejs/node/pull/34718",
-                    "description": "Add support for `\"exports\"` patterns."
+                    "pr-url": "https://github.com/nodejs/node/pull/29978",
+                    "description": "Implement conditional exports."
                   }
                 ]
               },
@@ -11510,30 +12313,16 @@
               "type": "module",
               "displayName": "`\"exports\"`"
             },
-            {
-              "textRaw": "`\"main\"`",
-              "name": "`\"main\"`",
-              "meta": {
-                "added": [
-                  "v0.4.0"
-                ],
-                "changes": []
-              },
-              "desc": "<ul>\n<li>Type: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\"\n}\n</code></pre>\n<p>The <code>\"main\"</code> field defines the script that is used when the <a href=\"modules.html#modules_folders_as_modules\">package directory\nis loaded via <code>require()</code></a>. Its value\nis interpreted as a path.</p>\n<pre><code class=\"language-js\">require('./path/to/directory'); // This resolves to ./path/to/directory/main.js.\n</code></pre>\n<p>When a package has an <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field, this will take precedence over the\n<code>\"main\"</code> field when importing the package by name.</p>",
-              "type": "module",
-              "displayName": "`\"main\"`"
-            },
             {
               "textRaw": "`\"imports\"`",
               "name": "`\"imports\"`",
               "meta": {
                 "added": [
+                  "v14.6.0",
                   "v12.19.0"
                 ],
                 "changes": []
               },
-              "stability": 1,
-              "stabilityText": "Experimental",
               "desc": "<ul>\n<li>Type: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">// package.json\n{\n  \"imports\": {\n    \"#dep\": {\n      \"node\": \"dep-node-native\",\n      \"default\": \"./dep-polyfill.js\"\n    }\n  },\n  \"dependencies\": {\n    \"dep-node-native\": \"^1.0.0\"\n  }\n}\n</code></pre>\n<p>Entries in the imports field must be strings starting with <code>#</code>.</p>\n<p>Import maps permit mapping to external packages.</p>\n<p>This field defines <a href=\"packages.html#packages_subpath_imports\">subpath imports</a> for the current package.</p>",
               "type": "module",
               "displayName": "`\"imports\"`"
@@ -11542,7 +12331,8 @@
           "type": "misc",
           "displayName": "Node.js `package.json` field definitions"
         }
-      ]
+      ],
+      "source": "doc/api/packages.md"
     },
     {
       "textRaw": "Policies",
@@ -11551,7 +12341,7 @@
       "type": "misc",
       "stability": 1,
       "stabilityText": "Experimental",
-      "desc": "<p>Node.js contains experimental support for creating policies on loading code.</p>\n<p>Policies are a security feature intended to allow guarantees\nabout what code Node.js is able to load. The use of policies assumes\nsafe practices for the policy files such as ensuring that policy\nfiles cannot be overwritten by the Node.js application by using\nfile permissions.</p>\n<p>A best practice would be to ensure that the policy manifest is read only for\nthe running Node.js application, and that the file cannot be changed\nby the running Node.js application in any way. A typical setup would be to\ncreate the policy file as a different user id than the one running Node.js\nand granting read permissions to the user id running Node.js.</p>",
+      "desc": "<p>Node.js contains experimental support for creating policies on loading code.</p>\n<p>Policies are a security feature intended to allow guarantees\nabout what code Node.js is able to load. The use of policies assumes\nsafe practices for the policy files such as ensuring that policy\nfiles cannot be overwritten by the Node.js application by using\nfile permissions.</p>\n<p>A best practice would be to ensure that the policy manifest is read-only for\nthe running Node.js application and that the file cannot be changed\nby the running Node.js application in any way. A typical setup would be to\ncreate the policy file as a different user id than the one running Node.js\nand granting read permissions to the user id running Node.js.</p>",
       "miscs": [
         {
           "textRaw": "Enabling",
@@ -11573,22 +12363,46 @@
             {
               "textRaw": "Integrity checks",
               "name": "integrity_checks",
-              "desc": "<p>Policy files must use integrity checks with Subresource Integrity strings\ncompatible with the browser\n<a href=\"https://www.w3.org/TR/SRI/#the-integrity-attribute\">integrity attribute</a>\nassociated with absolute URLs.</p>\n<p>When using <code>require()</code> all resources involved in loading are checked for\nintegrity if a policy manifest has been specified. If a resource does not match\nthe integrity listed in the manifest, an error will be thrown.</p>\n<p>An example policy file that would allow loading a file <code>checked.js</code>:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"integrity\": \"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0\"\n    }\n  }\n}\n</code></pre>\n<p>Each resource listed in the policy manifest can be of one the following\nformats to determine its location:</p>\n<ol>\n<li>A <a href=\"https://url.spec.whatwg.org/#relative-url-with-fragment-string\">relative url string</a> to a resource from the manifest such as <code>./resource.js</code>, <code>../resource.js</code>, or <code>/resource.js</code>.</li>\n<li>A complete url string to a resource such as <code>file:///resource.js</code>.</li>\n</ol>\n<p>When loading resources the entire URL must match including search parameters\nand hash fragment. <code>./a.js?b</code> will not be used when attempting to load\n<code>./a.js</code> and vice versa.</p>\n<p>To generate integrity strings, a script such as\n<code>printf \"sha384-$(cat checked.js | openssl dgst -sha384 -binary | base64)\"</code>\ncan be used.</p>\n<p>Integrity can be specified as the boolean value <code>true</code> to accept any\nbody for the resource which can be useful for local development. It is not\nrecommended in production since it would allow unexpected alteration of\nresources to be considered valid.</p>",
+              "desc": "<p>Policy files must use integrity checks with Subresource Integrity strings\ncompatible with the browser\n<a href=\"https://www.w3.org/TR/SRI/#the-integrity-attribute\">integrity attribute</a>\nassociated with absolute URLs.</p>\n<p>When using <code>require()</code> or <code>import</code> all resources involved in loading are checked\nfor integrity if a policy manifest has been specified. If a resource does not\nmatch the integrity listed in the manifest, an error will be thrown.</p>\n<p>An example policy file that would allow loading a file <code>checked.js</code>:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"integrity\": \"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0\"\n    }\n  }\n}\n</code></pre>\n<p>Each resource listed in the policy manifest can be of one the following\nformats to determine its location:</p>\n<ol>\n<li>A <a href=\"https://url.spec.whatwg.org/#relative-url-with-fragment-string\">relative-URL string</a> to a resource from the manifest such as <code>./resource.js</code>, <code>../resource.js</code>, or <code>/resource.js</code>.</li>\n<li>A complete URL string to a resource such as <code>file:///resource.js</code>.</li>\n</ol>\n<p>When loading resources the entire URL must match including search parameters\nand hash fragment. <code>./a.js?b</code> will not be used when attempting to load\n<code>./a.js</code> and vice versa.</p>\n<p>To generate integrity strings, a script such as\n<code>node -e 'process.stdout.write(\"sha256-\");process.stdin.pipe(crypto.createHash(\"sha256\").setEncoding(\"base64\")).pipe(process.stdout)' &#x3C; FILE</code>\ncan be used.</p>\n<p>Integrity can be specified as the boolean value <code>true</code> to accept any\nbody for the resource which can be useful for local development. It is not\nrecommended in production since it would allow unexpected alteration of\nresources to be considered valid.</p>",
               "type": "module",
               "displayName": "Integrity checks"
             },
             {
               "textRaw": "Dependency redirection",
               "name": "dependency_redirection",
-              "desc": "<p>An application may need to ship patched versions of modules or to prevent\nmodules from allowing all modules access to all other modules. Redirection\ncan be used by intercepting attempts to load the modules wishing to be\nreplaced.</p>\n<pre><code class=\"language-json\">{\n  \"builtins\": [],\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"dependencies\": {\n        \"fs\": true,\n        \"os\": \"./app/node_modules/alt-os\"\n      }\n    }\n  }\n}\n</code></pre>\n<p>The dependencies are keyed by the requested string specifier and have values\nof either <code>true</code> or a string pointing to a module that will be resolved.</p>\n<p>The specifier string does not perform any searching and must match exactly\nwhat is provided to the <code>require()</code>. Therefore, multiple specifiers may be\nneeded in the policy if <code>require()</code> uses multiple different strings to point\nto the same module (such as excluding the extension).</p>\n<p>If the value of the redirection is <code>true</code> the default searching algorithms will\nbe used to find the module.</p>\n<p>If the value of the redirection is a string, it will be resolved relative to\nthe manifest and then immediately be used without searching.</p>\n<p>Any specifier string that is <code>require()</code>ed and not listed in the dependencies\nwill result in an error according to the policy.</p>\n<p>Redirection will not prevent access to APIs through means such as direct access\nto <code>require.cache</code> and/or through <code>module.constructor</code> which allow access to\nloading modules. Policy redirection only affect specifiers to <code>require()</code>.\nOther means such as to prevent undesired access to APIs through variables are\nnecessary to lock down that path of loading modules.</p>\n<p>A boolean value of <code>true</code> for the dependencies map can be specified to allow a\nmodule to load any specifier without redirection. This can be useful for local\ndevelopment and may have some valid usage in production, but should be used\nonly with care after auditing a module to ensure its behavior is valid.</p>\n<h4>Example: Patched dependency</h4>\n<p>Redirected dependencies can provide attenuated or modified functionality as fits\nthe application. For example, log data about timing of function durations by\nwrapping the original:</p>\n<pre><code class=\"language-js\">const original = require('fn');\nmodule.exports = function fn(...args) {\n  console.time();\n  try {\n    return new.target ?\n      Reflect.construct(original, args) :\n      Reflect.apply(original, this, args);\n  } finally {\n    console.timeEnd();\n  }\n};\n</code></pre>",
+              "desc": "<p>An application may need to ship patched versions of modules or to prevent\nmodules from allowing all modules access to all other modules. Redirection\ncan be used by intercepting attempts to load the modules wishing to be\nreplaced.</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"dependencies\": {\n        \"fs\": true,\n        \"os\": \"./app/node_modules/alt-os\",\n        \"http\": { \"import\": true }\n      }\n    }\n  }\n}\n</code></pre>\n<p>The dependencies are keyed by the requested specifier string and have values\nof either <code>true</code>, <code>null</code>, a string pointing to a module to be resolved,\nor a conditions object.</p>\n<p>The specifier string does not perform any searching and must match exactly what\nis provided to the <code>require()</code> or <code>import</code> except for a canonicalization step.\nTherefore, multiple specifiers may be needed in the policy if it uses multiple\ndifferent strings to point to the same module (such as excluding the extension).</p>\n<p>Specifier strings are canonicalized but not resolved prior to be used for\nmatching in order to have some compatibility with import maps, for example if a\nresource <code>file:///C:/app/server.js</code> was given the following redirection from a\npolicy located at <code>file:///C:/app/policy.json</code>:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"file:///C:/app/utils.js\": {\n      \"dependencies\": {\n        \"./utils.js\": \"./utils-v2.js\"\n      }\n    }\n  }\n}\n</code></pre>\n<p>Any specifier used to load <code>file:///C:/app/utils.js</code> would then be intercepted\nand redirected to <code>file:///C:/app/utils-v2.js</code> instead regardless of using an\nabsolute or relative specifier. However, if a specifier that is not an absolute\nor relative URL string is used, it would not be intercepted. So, if an import\nsuch as <code>import('#utils')</code> was used, it would not be intercepted.</p>\n<p>If the value of the redirection is <code>true</code>, a \"dependencies\" field at the top of\nthe policy file will be used. If that field at the top of the policy file is\n<code>true</code> the default node searching algorithms are used to find the module.</p>\n<p>If the value of the redirection is a string, it is resolved relative to\nthe manifest and then immediately used without searching.</p>\n<p>Any specifier string for which resolution is attempted and that is not listed in\nthe dependencies results in an error according to the policy.</p>\n<p>Redirection does not prevent access to APIs through means such as direct access\nto <code>require.cache</code> or through <code>module.constructor</code> which allow access to\nloading modules. Policy redirection only affects specifiers to <code>require()</code> and\n<code>import</code>. Other means, such as to prevent undesired access to APIs through\nvariables, are necessary to lock down that path of loading modules.</p>\n<p>A boolean value of <code>true</code> for the dependencies map can be specified to allow a\nmodule to load any specifier without redirection. This can be useful for local\ndevelopment and may have some valid usage in production, but should be used\nonly with care after auditing a module to ensure its behavior is valid.</p>\n<p>Similar to <code>\"exports\"</code> in <code>package.json</code>, dependencies can also be specified to\nbe objects containing conditions which branch how dependencies are loaded. In\nthe preceding example, <code>\"http\"</code> is allowed when the <code>\"import\"</code> condition is\npart of loading it.</p>\n<p>A value of <code>null</code> for the resolved value causes the resolution to fail. This\ncan be used to ensure some kinds of dynamic access are explicitly prevented.</p>\n<p>Unknown values for the resolved module location cause failures but are\nnot guaranteed to be forward compatible.</p>\n<h4>Example: Patched dependency</h4>\n<p>Redirected dependencies can provide attenuated or modified functionality as fits\nthe application. For example, log data about timing of function durations by\nwrapping the original:</p>\n<pre><code class=\"language-js\">const original = require('fn');\nmodule.exports = function fn(...args) {\n  console.time();\n  try {\n    return new.target ?\n      Reflect.construct(original, args) :\n      Reflect.apply(original, this, args);\n  } finally {\n    console.timeEnd();\n  }\n};\n</code></pre>",
               "type": "module",
               "displayName": "Dependency redirection"
+            },
+            {
+              "textRaw": "Scopes",
+              "name": "scopes",
+              "desc": "<p>Use the <code>\"scopes\"</code> field of a manifest to set configuration for many resources\nat once. The <code>\"scopes\"</code> field works by matching resources by their segments.\nIf a scope or resource includes <code>\"cascade\": true</code>, unknown specifiers will\nbe searched for in their containing scope. The containing scope for cascading\nis found by recursively reducing the resource URL by removing segments for\n<a href=\"https://url.spec.whatwg.org/#special-scheme\">special schemes</a>, keeping trailing <code>\"/\"</code> suffixes, and removing the query and\nhash fragment. This leads to the eventual reduction of the URL to its origin.\nIf the URL is non-special the scope will be located by the URL's origin. If no\nscope is found for the origin or in the case of opaque origins, a protocol\nstring can be used as a scope. If no scope is found for the URL's protocol, a\nfinal empty string <code>\"\"</code> scope will be used.</p>\n<p>Note, <code>blob:</code> URLs adopt their origin from the path they contain, and so a scope\nof <code>\"blob:https://nodejs.org\"</code> will have no effect since no URL can have an\norigin of <code>blob:https://nodejs.org</code>; URLs starting with\n<code>blob:https://nodejs.org/</code> will use <code>https://nodejs.org</code> for its origin and\nthus <code>https:</code> for its protocol scope. For opaque origin <code>blob:</code> URLs they will\nhave <code>blob:</code> for their protocol scope since they do not adopt origins.</p>\n<h4>Example</h4>\n<pre><code class=\"language-json\">{\n  \"scopes\": {\n    \"file:///C:/app/\": {},\n    \"file:\": {},\n    \"\": {}\n  }\n}\n</code></pre>\n<p>Given a file located at <code>file:///C:/app/bin/main.js</code>, the following scopes would\nbe checked in order:</p>\n<ol>\n<li><code>\"file:///C:/app/bin/\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources within\n<code>\"file:///C:/app/bin/\"</code>. This is not in the <code>\"scopes\"</code> field of the policy and\nwould be skipped. Adding this scope to the policy would cause it to be used\nprior to the <code>\"file:///C:/app/\"</code> scope.</p>\n<ol start=\"2\">\n<li><code>\"file:///C:/app/\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources within\n<code>\"file:///C:/app/\"</code>. This is in the <code>\"scopes\"</code> field of the policy and it would\ndetermine the policy for the resource at <code>file:///C:/app/bin/main.js</code>. If the\nscope has <code>\"cascade\": true</code>, any unsatisfied queries about the resource would\ndelegate to the next relevant scope for <code>file:///C:/app/bin/main.js</code>, <code>\"file:\"</code>.</p>\n<ol start=\"3\">\n<li><code>\"file:///C:/\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources within <code>\"file:///C:/\"</code>.\nThis is not in the <code>\"scopes\"</code> field of the policy and would be skipped. It would\nnot be used for <code>file:///C:/app/bin/main.js</code> unless <code>\"file:///\"</code> is set to\ncascade or is not in the <code>\"scopes\"</code> of the policy.</p>\n<ol start=\"4\">\n<li><code>\"file:///\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources on the <code>localhost</code>. This\nis not in the <code>\"scopes\"</code> field of the policy and would be skipped. It would not\nbe used for <code>file:///C:/app/bin/main.js</code> unless <code>\"file:///\"</code> is set to cascade\nor is not in the <code>\"scopes\"</code> of the policy.</p>\n<ol start=\"5\">\n<li><code>\"file:\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources. It would not be used\nfor <code>file:///C:/app/bin/main.js</code> unless <code>\"file:///\"</code> is set to cascade or is not\nin the <code>\"scopes\"</code> of the policy.</p>\n<ol start=\"6\">\n<li><code>\"\"</code></li>\n</ol>\n<p>This determines the policy for all resources. It would not be used for\n<code>file:///C:/app/bin/main.js</code> unless <code>\"file:\"</code> is set to cascade.</p>",
+              "modules": [
+                {
+                  "textRaw": "Integrity using scopes",
+                  "name": "integrity_using_scopes",
+                  "desc": "<p>Setting an integrity to <code>true</code> on a scope will set the integrity for any\nresource not found in the manifest to <code>true</code>.</p>\n<p>Setting an integrity to <code>null</code> on a scope will set the integrity for any\nresource not found in the manifest to fail matching.</p>\n<p>Not including an integrity is the same as setting the integrity to <code>null</code>.</p>\n<p><code>\"cascade\"</code> for integrity checks will be ignored if <code>\"integrity\"</code> is explicitly\nset.</p>\n<p>The following example allows loading any file:</p>\n<pre><code class=\"language-json\">{\n  \"scopes\": {\n    \"file:\": {\n      \"integrity\": true\n    }\n  }\n}\n</code></pre>",
+                  "type": "module",
+                  "displayName": "Integrity using scopes"
+                },
+                {
+                  "textRaw": "Dependency redirection using scopes",
+                  "name": "dependency_redirection_using_scopes",
+                  "desc": "<p>The following example, would allow access to <code>fs</code> for all resources within\n<code>./app/</code>:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"cascade\": true,\n      \"integrity\": true\n    }\n  },\n  \"scopes\": {\n    \"./app/\": {\n      \"dependencies\": {\n        \"fs\": true\n      }\n    }\n  }\n}\n</code></pre>\n<p>The following example, would allow access to <code>fs</code> for all <code>data:</code> resources:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"data:text/javascript,import('fs');\": {\n      \"cascade\": true,\n      \"integrity\": true\n    }\n  },\n  \"scopes\": {\n    \"data:\": {\n      \"dependencies\": {\n        \"fs\": true\n      }\n    }\n  }\n}\n</code></pre>\n<h4>Example: <a href=\"https://url.spec.whatwg.org/#relative-url-with-fragment-string\">import maps</a> emulation</h4>\n<p>Given an import map:</p>\n<pre><code class=\"language-json\">{\n  \"imports\": {\n    \"react\": \"./app/node_modules/react/index.js\"\n  },\n  \"scopes\": {\n    \"./ssr/\": {\n      \"react\": \"./app/node_modules/server-side-react/index.js\"\n    }\n  }\n}\n</code></pre>\n<pre><code class=\"language-json\">{\n  \"dependencies\": true,\n  \"scopes\": {\n    \"\": {\n      \"cascade\": true,\n      \"dependencies\": {\n        \"react\": \"./app/node_modules/react/index.js\"\n      }\n    },\n    \"./ssr/\": {\n      \"cascade\": true,\n      \"dependencies\": {\n        \"react\": \"./app/node_modules/server-side-react/index.js\"\n      }\n    }\n  }\n}\n</code></pre>\n<p>Import maps assume you can get any resource by default. This means\n<code>\"dependencies\"</code> at the top level of the policy should be set to <code>true</code>.\nPolicies require this to be opt-in since it enables all resources of the\napplication cross linkage which doesn't make sense for many scenarios. They also\nassume any given scope has access to any scope above its allowed dependencies;\nall scopes emulating import maps must set <code>\"cascade\": true</code>.</p>\n<p>Import maps only have a single top level scope for their \"imports\". So for\nemulating <code>\"imports\"</code> use the <code>\"\"</code> scope. For emulating <code>\"scopes\"</code> use the\n<code>\"scopes\"</code> in a similar manner to how <code>\"scopes\"</code> works in import maps.</p>\n<p>Caveats: Policies do not use string matching for various finding of scope. They\ndo URL traversals. This means things like <code>blob:</code> and <code>data:</code> URLs might not be\nentirely interoperable between the two systems. For example import maps can\npartially match a <code>data:</code> or <code>blob:</code> URL by partitioning the URL on a <code>/</code>\ncharacter, policies intentionally cannot. For <code>blob:</code> URLs import map scopes do\nnot adopt the origin of the <code>blob:</code> URL.</p>\n<p>Additionally, import maps only work on <code>import</code> so it may be desirable to add a\n<code>\"import\"</code> condition to all dependency mappings.</p>",
+                  "type": "module",
+                  "displayName": "Dependency redirection using scopes"
+                }
+              ],
+              "type": "module",
+              "displayName": "Scopes"
             }
           ],
           "type": "misc",
           "displayName": "Features"
         }
-      ]
+      ],
+      "source": "doc/api/policy.md"
     },
     {
       "textRaw": "Diagnostic report",
@@ -11597,12 +12411,12 @@
       "type": "misc",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p>Delivers a JSON-formatted diagnostic summary, written to a file.</p>\n<p>The report is intended for development, test and production use, to capture\nand preserve information for problem determination. It includes JavaScript\nand native stack traces, heap statistics, platform information, resource\nusage etc. With the report option enabled, diagnostic reports can be triggered\non unhandled exceptions, fatal errors and user signals, in addition to\ntriggering programmatically through API calls.</p>\n<p>A complete example report that was generated on an uncaught exception\nis provided below for reference.</p>\n<pre><code class=\"language-json\">{\n  \"header\": {\n    \"reportVersion\": 1,\n    \"event\": \"exception\",\n    \"trigger\": \"Exception\",\n    \"filename\": \"report.20181221.005011.8974.0.001.json\",\n    \"dumpEventTime\": \"2018-12-21T00:50:11Z\",\n    \"dumpEventTimeStamp\": \"1545371411331\",\n    \"processId\": 8974,\n    \"cwd\": \"/home/nodeuser/project/node\",\n    \"commandLine\": [\n      \"/home/nodeuser/project/node/out/Release/node\",\n      \"--report-uncaught-exception\",\n      \"/home/nodeuser/project/node/test/report/test-exception.js\",\n      \"child\"\n    ],\n    \"nodejsVersion\": \"v12.0.0-pre\",\n    \"glibcVersionRuntime\": \"2.17\",\n    \"glibcVersionCompiler\": \"2.17\",\n    \"wordSize\": \"64 bit\",\n    \"arch\": \"x64\",\n    \"platform\": \"linux\",\n    \"componentVersions\": {\n      \"node\": \"12.0.0-pre\",\n      \"v8\": \"7.1.302.28-node.5\",\n      \"uv\": \"1.24.1\",\n      \"zlib\": \"1.2.11\",\n      \"ares\": \"1.15.0\",\n      \"modules\": \"68\",\n      \"nghttp2\": \"1.34.0\",\n      \"napi\": \"3\",\n      \"llhttp\": \"1.0.1\",\n      \"http_parser\": \"2.8.0\",\n      \"openssl\": \"1.1.0j\"\n    },\n    \"release\": {\n      \"name\": \"node\"\n    },\n    \"osName\": \"Linux\",\n    \"osRelease\": \"3.10.0-862.el7.x86_64\",\n    \"osVersion\": \"#1 SMP Wed Mar 21 18:14:51 EDT 2018\",\n    \"osMachine\": \"x86_64\",\n    \"cpus\": [\n      {\n        \"model\": \"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\",\n        \"speed\": 2700,\n        \"user\": 88902660,\n        \"nice\": 0,\n        \"sys\": 50902570,\n        \"idle\": 241732220,\n        \"irq\": 0\n      },\n      {\n        \"model\": \"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\",\n        \"speed\": 2700,\n        \"user\": 88902660,\n        \"nice\": 0,\n        \"sys\": 50902570,\n        \"idle\": 241732220,\n        \"irq\": 0\n      }\n    ],\n    \"networkInterfaces\": [\n      {\n        \"name\": \"en0\",\n        \"internal\": false,\n        \"mac\": \"13:10:de:ad:be:ef\",\n        \"address\": \"10.0.0.37\",\n        \"netmask\": \"255.255.255.0\",\n        \"family\": \"IPv4\"\n      }\n    ],\n    \"host\": \"test_machine\"\n  },\n  \"javascriptStack\": {\n    \"message\": \"Error: *** test-exception.js: throwing uncaught Error\",\n    \"stack\": [\n      \"at myException (/home/nodeuser/project/node/test/report/test-exception.js:9:11)\",\n      \"at Object.&#x3C;anonymous> (/home/nodeuser/project/node/test/report/test-exception.js:12:3)\",\n      \"at Module._compile (internal/modules/cjs/loader.js:718:30)\",\n      \"at Object.Module._extensions..js (internal/modules/cjs/loader.js:729:10)\",\n      \"at Module.load (internal/modules/cjs/loader.js:617:32)\",\n      \"at tryModuleLoad (internal/modules/cjs/loader.js:560:12)\",\n      \"at Function.Module._load (internal/modules/cjs/loader.js:552:3)\",\n      \"at Function.Module.runMain (internal/modules/cjs/loader.js:771:12)\",\n      \"at executeUserCode (internal/bootstrap/node.js:332:15)\"\n    ]\n  },\n  \"nativeStack\": [\n    {\n      \"pc\": \"0x000055b57f07a9ef\",\n      \"symbol\": \"report::GetNodeReport(v8::Isolate*, node::Environment*, char const*, char const*, v8::Local&#x3C;v8::String>, std::ostream&#x26;) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f07cf03\",\n      \"symbol\": \"report::GetReport(v8::FunctionCallbackInfo&#x3C;v8::Value> const&#x26;) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f1bccfd\",\n      \"symbol\": \" [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f1be048\",\n      \"symbol\": \"v8::internal::Builtin_HandleApiCall(int, v8::internal::Object**, v8::internal::Isolate*) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57feeda0e\",\n      \"symbol\": \" [./node]\"\n    }\n  ],\n  \"javascriptHeap\": {\n    \"totalMemory\": 6127616,\n    \"totalCommittedMemory\": 4357352,\n    \"usedMemory\": 3221136,\n    \"availableMemory\": 1521370240,\n    \"memoryLimit\": 1526909922,\n    \"heapSpaces\": {\n      \"read_only_space\": {\n        \"memorySize\": 524288,\n        \"committedMemory\": 39208,\n        \"capacity\": 515584,\n        \"used\": 30504,\n        \"available\": 485080\n      },\n      \"new_space\": {\n        \"memorySize\": 2097152,\n        \"committedMemory\": 2019312,\n        \"capacity\": 1031168,\n        \"used\": 985496,\n        \"available\": 45672\n      },\n      \"old_space\": {\n        \"memorySize\": 2273280,\n        \"committedMemory\": 1769008,\n        \"capacity\": 1974640,\n        \"used\": 1725488,\n        \"available\": 249152\n      },\n      \"code_space\": {\n        \"memorySize\": 696320,\n        \"committedMemory\": 184896,\n        \"capacity\": 152128,\n        \"used\": 152128,\n        \"available\": 0\n      },\n      \"map_space\": {\n        \"memorySize\": 536576,\n        \"committedMemory\": 344928,\n        \"capacity\": 327520,\n        \"used\": 327520,\n        \"available\": 0\n      },\n      \"large_object_space\": {\n        \"memorySize\": 0,\n        \"committedMemory\": 0,\n        \"capacity\": 1520590336,\n        \"used\": 0,\n        \"available\": 1520590336\n      },\n      \"new_large_object_space\": {\n        \"memorySize\": 0,\n        \"committedMemory\": 0,\n        \"capacity\": 0,\n        \"used\": 0,\n        \"available\": 0\n      }\n    }\n  },\n  \"resourceUsage\": {\n    \"userCpuSeconds\": 0.069595,\n    \"kernelCpuSeconds\": 0.019163,\n    \"cpuConsumptionPercent\": 0.000000,\n    \"maxRss\": 18079744,\n    \"pageFaults\": {\n      \"IORequired\": 0,\n      \"IONotRequired\": 4610\n    },\n    \"fsActivity\": {\n      \"reads\": 0,\n      \"writes\": 0\n    }\n  },\n  \"uvthreadResourceUsage\": {\n    \"userCpuSeconds\": 0.068457,\n    \"kernelCpuSeconds\": 0.019127,\n    \"cpuConsumptionPercent\": 0.000000,\n    \"fsActivity\": {\n      \"reads\": 0,\n      \"writes\": 0\n    }\n  },\n  \"libuv\": [\n    {\n      \"type\": \"async\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x0000000102910900\",\n      \"details\": \"\"\n    },\n    {\n      \"type\": \"timer\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfeab0\",\n      \"repeat\": 0,\n      \"firesInMsFromNow\": 94403548320796,\n      \"expired\": true\n    },\n    {\n      \"type\": \"check\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfeb48\"\n    },\n    {\n      \"type\": \"idle\",\n      \"is_active\": false,\n      \"is_referenced\": true,\n      \"address\": \"0x00007fff5fbfebc0\"\n    },\n    {\n      \"type\": \"prepare\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfec38\"\n    },\n    {\n      \"type\": \"check\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfecb0\"\n    },\n    {\n      \"type\": \"async\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x000000010188f2e0\"\n    },\n    {\n      \"type\": \"tty\",\n      \"is_active\": false,\n      \"is_referenced\": true,\n      \"address\": \"0x000055b581db0e18\",\n      \"width\": 204,\n      \"height\": 55,\n      \"fd\": 17,\n      \"writeQueueSize\": 0,\n      \"readable\": true,\n      \"writable\": true\n    },\n    {\n      \"type\": \"signal\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x000055b581d80010\",\n      \"signum\": 28,\n      \"signal\": \"SIGWINCH\"\n    },\n    {\n      \"type\": \"tty\",\n      \"is_active\": true,\n      \"is_referenced\": true,\n      \"address\": \"0x000055b581df59f8\",\n      \"width\": 204,\n      \"height\": 55,\n      \"fd\": 19,\n      \"writeQueueSize\": 0,\n      \"readable\": true,\n      \"writable\": true\n    },\n    {\n      \"type\": \"loop\",\n      \"is_active\": true,\n      \"address\": \"0x000055fc7b2cb180\"\n    }\n  ],\n  \"workers\": [],\n  \"environmentVariables\": {\n    \"REMOTEHOST\": \"REMOVED\",\n    \"MANPATH\": \"/opt/rh/devtoolset-3/root/usr/share/man:\",\n    \"XDG_SESSION_ID\": \"66126\",\n    \"HOSTNAME\": \"test_machine\",\n    \"HOST\": \"test_machine\",\n    \"TERM\": \"xterm-256color\",\n    \"SHELL\": \"/bin/csh\",\n    \"SSH_CLIENT\": \"REMOVED\",\n    \"PERL5LIB\": \"/opt/rh/devtoolset-3/root//usr/lib64/perl5/vendor_perl:/opt/rh/devtoolset-3/root/usr/lib/perl5:/opt/rh/devtoolset-3/root//usr/share/perl5/vendor_perl\",\n    \"OLDPWD\": \"/home/nodeuser/project/node/src\",\n    \"JAVACONFDIRS\": \"/opt/rh/devtoolset-3/root/etc/java:/etc/java\",\n    \"SSH_TTY\": \"/dev/pts/0\",\n    \"PCP_DIR\": \"/opt/rh/devtoolset-3/root\",\n    \"GROUP\": \"normaluser\",\n    \"USER\": \"nodeuser\",\n    \"LD_LIBRARY_PATH\": \"/opt/rh/devtoolset-3/root/usr/lib64:/opt/rh/devtoolset-3/root/usr/lib\",\n    \"HOSTTYPE\": \"x86_64-linux\",\n    \"XDG_CONFIG_DIRS\": \"/opt/rh/devtoolset-3/root/etc/xdg:/etc/xdg\",\n    \"MAIL\": \"/var/spool/mail/nodeuser\",\n    \"PATH\": \"/home/nodeuser/project/node:/opt/rh/devtoolset-3/root/usr/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin\",\n    \"PWD\": \"/home/nodeuser/project/node\",\n    \"LANG\": \"en_US.UTF-8\",\n    \"PS1\": \"\\\\u@\\\\h : \\\\[\\\\e[31m\\\\]\\\\w\\\\[\\\\e[m\\\\] >  \",\n    \"SHLVL\": \"2\",\n    \"HOME\": \"/home/nodeuser\",\n    \"OSTYPE\": \"linux\",\n    \"VENDOR\": \"unknown\",\n    \"PYTHONPATH\": \"/opt/rh/devtoolset-3/root/usr/lib64/python2.7/site-packages:/opt/rh/devtoolset-3/root/usr/lib/python2.7/site-packages\",\n    \"MACHTYPE\": \"x86_64\",\n    \"LOGNAME\": \"nodeuser\",\n    \"XDG_DATA_DIRS\": \"/opt/rh/devtoolset-3/root/usr/share:/usr/local/share:/usr/share\",\n    \"LESSOPEN\": \"||/usr/bin/lesspipe.sh %s\",\n    \"INFOPATH\": \"/opt/rh/devtoolset-3/root/usr/share/info\",\n    \"XDG_RUNTIME_DIR\": \"/run/user/50141\",\n    \"_\": \"./node\"\n  },\n  \"userLimits\": {\n    \"core_file_size_blocks\": {\n      \"soft\": \"\",\n      \"hard\": \"unlimited\"\n    },\n    \"data_seg_size_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"file_size_blocks\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"max_locked_memory_bytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 65536\n    },\n    \"max_memory_size_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"open_files\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 4096\n    },\n    \"stack_size_bytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"cpu_time_seconds\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"max_user_processes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 4127290\n    },\n    \"virtual_memory_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    }\n  },\n  \"sharedObjects\": [\n    \"/lib64/libdl.so.2\",\n    \"/lib64/librt.so.1\",\n    \"/lib64/libstdc++.so.6\",\n    \"/lib64/libm.so.6\",\n    \"/lib64/libgcc_s.so.1\",\n    \"/lib64/libpthread.so.0\",\n    \"/lib64/libc.so.6\",\n    \"/lib64/ld-linux-x86-64.so.2\"\n  ]\n}\n</code></pre>",
+      "desc": "<p>Delivers a JSON-formatted diagnostic summary, written to a file.</p>\n<p>The report is intended for development, test and production use, to capture\nand preserve information for problem determination. It includes JavaScript\nand native stack traces, heap statistics, platform information, resource\nusage etc. With the report option enabled, diagnostic reports can be triggered\non unhandled exceptions, fatal errors and user signals, in addition to\ntriggering programmatically through API calls.</p>\n<p>A complete example report that was generated on an uncaught exception\nis provided below for reference.</p>\n<pre><code class=\"language-json\">{\n  \"header\": {\n    \"reportVersion\": 1,\n    \"event\": \"exception\",\n    \"trigger\": \"Exception\",\n    \"filename\": \"report.20181221.005011.8974.0.001.json\",\n    \"dumpEventTime\": \"2018-12-21T00:50:11Z\",\n    \"dumpEventTimeStamp\": \"1545371411331\",\n    \"processId\": 8974,\n    \"cwd\": \"/home/nodeuser/project/node\",\n    \"commandLine\": [\n      \"/home/nodeuser/project/node/out/Release/node\",\n      \"--report-uncaught-exception\",\n      \"/home/nodeuser/project/node/test/report/test-exception.js\",\n      \"child\"\n    ],\n    \"nodejsVersion\": \"v12.0.0-pre\",\n    \"glibcVersionRuntime\": \"2.17\",\n    \"glibcVersionCompiler\": \"2.17\",\n    \"wordSize\": \"64 bit\",\n    \"arch\": \"x64\",\n    \"platform\": \"linux\",\n    \"componentVersions\": {\n      \"node\": \"12.0.0-pre\",\n      \"v8\": \"7.1.302.28-node.5\",\n      \"uv\": \"1.24.1\",\n      \"zlib\": \"1.2.11\",\n      \"ares\": \"1.15.0\",\n      \"modules\": \"68\",\n      \"nghttp2\": \"1.34.0\",\n      \"napi\": \"3\",\n      \"llhttp\": \"1.0.1\",\n      \"openssl\": \"1.1.0j\"\n    },\n    \"release\": {\n      \"name\": \"node\"\n    },\n    \"osName\": \"Linux\",\n    \"osRelease\": \"3.10.0-862.el7.x86_64\",\n    \"osVersion\": \"#1 SMP Wed Mar 21 18:14:51 EDT 2018\",\n    \"osMachine\": \"x86_64\",\n    \"cpus\": [\n      {\n        \"model\": \"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\",\n        \"speed\": 2700,\n        \"user\": 88902660,\n        \"nice\": 0,\n        \"sys\": 50902570,\n        \"idle\": 241732220,\n        \"irq\": 0\n      },\n      {\n        \"model\": \"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\",\n        \"speed\": 2700,\n        \"user\": 88902660,\n        \"nice\": 0,\n        \"sys\": 50902570,\n        \"idle\": 241732220,\n        \"irq\": 0\n      }\n    ],\n    \"networkInterfaces\": [\n      {\n        \"name\": \"en0\",\n        \"internal\": false,\n        \"mac\": \"13:10:de:ad:be:ef\",\n        \"address\": \"10.0.0.37\",\n        \"netmask\": \"255.255.255.0\",\n        \"family\": \"IPv4\"\n      }\n    ],\n    \"host\": \"test_machine\"\n  },\n  \"javascriptStack\": {\n    \"message\": \"Error: *** test-exception.js: throwing uncaught Error\",\n    \"stack\": [\n      \"at myException (/home/nodeuser/project/node/test/report/test-exception.js:9:11)\",\n      \"at Object.&#x3C;anonymous> (/home/nodeuser/project/node/test/report/test-exception.js:12:3)\",\n      \"at Module._compile (internal/modules/cjs/loader.js:718:30)\",\n      \"at Object.Module._extensions..js (internal/modules/cjs/loader.js:729:10)\",\n      \"at Module.load (internal/modules/cjs/loader.js:617:32)\",\n      \"at tryModuleLoad (internal/modules/cjs/loader.js:560:12)\",\n      \"at Function.Module._load (internal/modules/cjs/loader.js:552:3)\",\n      \"at Function.Module.runMain (internal/modules/cjs/loader.js:771:12)\",\n      \"at executeUserCode (internal/bootstrap/node.js:332:15)\"\n    ]\n  },\n  \"nativeStack\": [\n    {\n      \"pc\": \"0x000055b57f07a9ef\",\n      \"symbol\": \"report::GetNodeReport(v8::Isolate*, node::Environment*, char const*, char const*, v8::Local&#x3C;v8::String>, std::ostream&#x26;) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f07cf03\",\n      \"symbol\": \"report::GetReport(v8::FunctionCallbackInfo&#x3C;v8::Value> const&#x26;) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f1bccfd\",\n      \"symbol\": \" [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f1be048\",\n      \"symbol\": \"v8::internal::Builtin_HandleApiCall(int, v8::internal::Object**, v8::internal::Isolate*) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57feeda0e\",\n      \"symbol\": \" [./node]\"\n    }\n  ],\n  \"javascriptHeap\": {\n    \"totalMemory\": 6127616,\n    \"totalCommittedMemory\": 4357352,\n    \"usedMemory\": 3221136,\n    \"availableMemory\": 1521370240,\n    \"memoryLimit\": 1526909922,\n    \"heapSpaces\": {\n      \"read_only_space\": {\n        \"memorySize\": 524288,\n        \"committedMemory\": 39208,\n        \"capacity\": 515584,\n        \"used\": 30504,\n        \"available\": 485080\n      },\n      \"new_space\": {\n        \"memorySize\": 2097152,\n        \"committedMemory\": 2019312,\n        \"capacity\": 1031168,\n        \"used\": 985496,\n        \"available\": 45672\n      },\n      \"old_space\": {\n        \"memorySize\": 2273280,\n        \"committedMemory\": 1769008,\n        \"capacity\": 1974640,\n        \"used\": 1725488,\n        \"available\": 249152\n      },\n      \"code_space\": {\n        \"memorySize\": 696320,\n        \"committedMemory\": 184896,\n        \"capacity\": 152128,\n        \"used\": 152128,\n        \"available\": 0\n      },\n      \"map_space\": {\n        \"memorySize\": 536576,\n        \"committedMemory\": 344928,\n        \"capacity\": 327520,\n        \"used\": 327520,\n        \"available\": 0\n      },\n      \"large_object_space\": {\n        \"memorySize\": 0,\n        \"committedMemory\": 0,\n        \"capacity\": 1520590336,\n        \"used\": 0,\n        \"available\": 1520590336\n      },\n      \"new_large_object_space\": {\n        \"memorySize\": 0,\n        \"committedMemory\": 0,\n        \"capacity\": 0,\n        \"used\": 0,\n        \"available\": 0\n      }\n    }\n  },\n  \"resourceUsage\": {\n    \"userCpuSeconds\": 0.069595,\n    \"kernelCpuSeconds\": 0.019163,\n    \"cpuConsumptionPercent\": 0.000000,\n    \"maxRss\": 18079744,\n    \"pageFaults\": {\n      \"IORequired\": 0,\n      \"IONotRequired\": 4610\n    },\n    \"fsActivity\": {\n      \"reads\": 0,\n      \"writes\": 0\n    }\n  },\n  \"uvthreadResourceUsage\": {\n    \"userCpuSeconds\": 0.068457,\n    \"kernelCpuSeconds\": 0.019127,\n    \"cpuConsumptionPercent\": 0.000000,\n    \"fsActivity\": {\n      \"reads\": 0,\n      \"writes\": 0\n    }\n  },\n  \"libuv\": [\n    {\n      \"type\": \"async\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x0000000102910900\",\n      \"details\": \"\"\n    },\n    {\n      \"type\": \"timer\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfeab0\",\n      \"repeat\": 0,\n      \"firesInMsFromNow\": 94403548320796,\n      \"expired\": true\n    },\n    {\n      \"type\": \"check\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfeb48\"\n    },\n    {\n      \"type\": \"idle\",\n      \"is_active\": false,\n      \"is_referenced\": true,\n      \"address\": \"0x00007fff5fbfebc0\"\n    },\n    {\n      \"type\": \"prepare\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfec38\"\n    },\n    {\n      \"type\": \"check\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfecb0\"\n    },\n    {\n      \"type\": \"async\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x000000010188f2e0\"\n    },\n    {\n      \"type\": \"tty\",\n      \"is_active\": false,\n      \"is_referenced\": true,\n      \"address\": \"0x000055b581db0e18\",\n      \"width\": 204,\n      \"height\": 55,\n      \"fd\": 17,\n      \"writeQueueSize\": 0,\n      \"readable\": true,\n      \"writable\": true\n    },\n    {\n      \"type\": \"signal\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x000055b581d80010\",\n      \"signum\": 28,\n      \"signal\": \"SIGWINCH\"\n    },\n    {\n      \"type\": \"tty\",\n      \"is_active\": true,\n      \"is_referenced\": true,\n      \"address\": \"0x000055b581df59f8\",\n      \"width\": 204,\n      \"height\": 55,\n      \"fd\": 19,\n      \"writeQueueSize\": 0,\n      \"readable\": true,\n      \"writable\": true\n    },\n    {\n      \"type\": \"loop\",\n      \"is_active\": true,\n      \"address\": \"0x000055fc7b2cb180\",\n      \"loopIdleTimeSeconds\": 22644.8\n    }\n  ],\n  \"workers\": [],\n  \"environmentVariables\": {\n    \"REMOTEHOST\": \"REMOVED\",\n    \"MANPATH\": \"/opt/rh/devtoolset-3/root/usr/share/man:\",\n    \"XDG_SESSION_ID\": \"66126\",\n    \"HOSTNAME\": \"test_machine\",\n    \"HOST\": \"test_machine\",\n    \"TERM\": \"xterm-256color\",\n    \"SHELL\": \"/bin/csh\",\n    \"SSH_CLIENT\": \"REMOVED\",\n    \"PERL5LIB\": \"/opt/rh/devtoolset-3/root//usr/lib64/perl5/vendor_perl:/opt/rh/devtoolset-3/root/usr/lib/perl5:/opt/rh/devtoolset-3/root//usr/share/perl5/vendor_perl\",\n    \"OLDPWD\": \"/home/nodeuser/project/node/src\",\n    \"JAVACONFDIRS\": \"/opt/rh/devtoolset-3/root/etc/java:/etc/java\",\n    \"SSH_TTY\": \"/dev/pts/0\",\n    \"PCP_DIR\": \"/opt/rh/devtoolset-3/root\",\n    \"GROUP\": \"normaluser\",\n    \"USER\": \"nodeuser\",\n    \"LD_LIBRARY_PATH\": \"/opt/rh/devtoolset-3/root/usr/lib64:/opt/rh/devtoolset-3/root/usr/lib\",\n    \"HOSTTYPE\": \"x86_64-linux\",\n    \"XDG_CONFIG_DIRS\": \"/opt/rh/devtoolset-3/root/etc/xdg:/etc/xdg\",\n    \"MAIL\": \"/var/spool/mail/nodeuser\",\n    \"PATH\": \"/home/nodeuser/project/node:/opt/rh/devtoolset-3/root/usr/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin\",\n    \"PWD\": \"/home/nodeuser/project/node\",\n    \"LANG\": \"en_US.UTF-8\",\n    \"PS1\": \"\\\\u@\\\\h : \\\\[\\\\e[31m\\\\]\\\\w\\\\[\\\\e[m\\\\] >  \",\n    \"SHLVL\": \"2\",\n    \"HOME\": \"/home/nodeuser\",\n    \"OSTYPE\": \"linux\",\n    \"VENDOR\": \"unknown\",\n    \"PYTHONPATH\": \"/opt/rh/devtoolset-3/root/usr/lib64/python2.7/site-packages:/opt/rh/devtoolset-3/root/usr/lib/python2.7/site-packages\",\n    \"MACHTYPE\": \"x86_64\",\n    \"LOGNAME\": \"nodeuser\",\n    \"XDG_DATA_DIRS\": \"/opt/rh/devtoolset-3/root/usr/share:/usr/local/share:/usr/share\",\n    \"LESSOPEN\": \"||/usr/bin/lesspipe.sh %s\",\n    \"INFOPATH\": \"/opt/rh/devtoolset-3/root/usr/share/info\",\n    \"XDG_RUNTIME_DIR\": \"/run/user/50141\",\n    \"_\": \"./node\"\n  },\n  \"userLimits\": {\n    \"core_file_size_blocks\": {\n      \"soft\": \"\",\n      \"hard\": \"unlimited\"\n    },\n    \"data_seg_size_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"file_size_blocks\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"max_locked_memory_bytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 65536\n    },\n    \"max_memory_size_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"open_files\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 4096\n    },\n    \"stack_size_bytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"cpu_time_seconds\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"max_user_processes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 4127290\n    },\n    \"virtual_memory_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    }\n  },\n  \"sharedObjects\": [\n    \"/lib64/libdl.so.2\",\n    \"/lib64/librt.so.1\",\n    \"/lib64/libstdc++.so.6\",\n    \"/lib64/libm.so.6\",\n    \"/lib64/libgcc_s.so.1\",\n    \"/lib64/libpthread.so.0\",\n    \"/lib64/libc.so.6\",\n    \"/lib64/ld-linux-x86-64.so.2\"\n  ]\n}\n</code></pre>",
       "miscs": [
         {
           "textRaw": "Usage",
           "name": "usage",
-          "desc": "<pre><code class=\"language-bash\">node --report-uncaught-exception --report-on-signal \\\n--report-on-fatalerror app.js\n</code></pre>\n<ul>\n<li>\n<p><code>--report-uncaught-exception</code> Enables report to be generated on\nun-caught exceptions. Useful when inspecting JavaScript stack in conjunction\nwith native stack and other runtime environment data.</p>\n</li>\n<li>\n<p><code>--report-on-signal</code> Enables report to be generated upon receiving\nthe specified (or predefined) signal to the running Node.js process. (See below\non how to modify the signal that triggers the report.) Default signal is <code>SIGUSR2</code>.\nUseful when a report needs to be triggered from another program.\nApplication monitors may leverage this feature to collect report at regular\nintervals and plot rich set of internal runtime data to their views.</p>\n</li>\n</ul>\n<p>Signal based report generation is not supported in Windows.</p>\n<p>Under normal circumstances, there is no need to modify the report triggering\nsignal. However, if <code>SIGUSR2</code> is already used for other purposes, then this\nflag helps to change the signal for report generation and preserve the original\nmeaning of <code>SIGUSR2</code> for the said purposes.</p>\n<ul>\n<li>\n<p><code>--report-on-fatalerror</code> Enables the report to be triggered on\nfatal errors (internal errors within the Node.js runtime, such as out of memory)\nthat leads to termination of the application. Useful to inspect various\ndiagnostic data elements such as heap, stack, event loop state, resource\nconsumption etc. to reason about the fatal error.</p>\n</li>\n<li>\n<p><code>--report-compact</code> Write reports in a compact format, single-line JSON, more\neasily consumable by log processing systems than the default multi-line format\ndesigned for human consumption.</p>\n</li>\n<li>\n<p><code>--report-directory</code> Location at which the report will be\ngenerated.</p>\n</li>\n<li>\n<p><code>--report-filename</code> Name of the file to which the report will be\nwritten.</p>\n</li>\n<li>\n<p><code>--report-signal</code> Sets or resets the signal for report generation\n(not supported on Windows). Default signal is <code>SIGUSR2</code>.</p>\n</li>\n</ul>\n<p>A report can also be triggered via an API call from a JavaScript application:</p>\n<pre><code class=\"language-js\">process.report.writeReport();\n</code></pre>\n<p>This function takes an optional additional argument <code>filename</code>, which is\nthe name of a file into which the report is written.</p>\n<pre><code class=\"language-js\">process.report.writeReport('./foo.json');\n</code></pre>\n<p>This function takes an optional additional argument <code>err</code> which is an <code>Error</code>\nobject that will be used as the context for the JavaScript stack printed in the\nreport. When using report to handle errors in a callback or an exception\nhandler, this allows the report to include the location of the original error as\nwell as where it was handled.</p>\n<pre><code class=\"language-js\">try {\n  process.chdir('/non-existent-path');\n} catch (err) {\n  process.report.writeReport(err);\n}\n// Any other code\n</code></pre>\n<p>If both filename and error object are passed to <code>writeReport()</code> the\nerror object must be the second parameter.</p>\n<pre><code class=\"language-js\">try {\n  process.chdir('/non-existent-path');\n} catch (err) {\n  process.report.writeReport(filename, err);\n}\n// Any other code\n</code></pre>\n<p>The content of the diagnostic report can be returned as a JavaScript Object\nvia an API call from a JavaScript application:</p>\n<pre><code class=\"language-js\">const report = process.report.getReport();\nconsole.log(typeof report === 'object'); // true\n\n// Similar to process.report.writeReport() output\nconsole.log(JSON.stringify(report, null, 2));\n</code></pre>\n<p>This function takes an optional additional argument <code>err</code>, which is an <code>Error</code>\nobject that will be used as the context for the JavaScript stack printed in the\nreport.</p>\n<pre><code class=\"language-js\">const report = process.report.getReport(new Error('custom error'));\nconsole.log(typeof report === 'object'); // true\n</code></pre>\n<p>The API versions are useful when inspecting the runtime state from within\nthe application, in expectation of self-adjusting the resource consumption,\nload balancing, monitoring etc.</p>\n<p>The content of the report consists of a header section containing the event\ntype, date, time, PID and Node.js version, sections containing JavaScript and\nnative stack traces, a section containing V8 heap information, a section\ncontaining <code>libuv</code> handle information and an OS platform information section\nshowing CPU and memory usage and system limits. An example report can be\ntriggered using the Node.js REPL:</p>\n<pre><code class=\"language-console\">$ node\n> process.report.writeReport();\nWriting Node.js report to file: report.20181126.091102.8480.0.001.json\nNode.js report completed\n>\n</code></pre>\n<p>When a report is written, start and end messages are issued to stderr\nand the filename of the report is returned to the caller. The default filename\nincludes the date, time, PID and a sequence number. The sequence number helps\nin associating the report dump with the runtime state if generated multiple\ntimes for the same Node.js process.</p>",
+          "desc": "<pre><code class=\"language-bash\">node --report-uncaught-exception --report-on-signal \\\n--report-on-fatalerror app.js\n</code></pre>\n<ul>\n<li>\n<p><code>--report-uncaught-exception</code> Enables report to be generated on\nun-caught exceptions. Useful when inspecting JavaScript stack in conjunction\nwith native stack and other runtime environment data.</p>\n</li>\n<li>\n<p><code>--report-on-signal</code> Enables report to be generated upon receiving\nthe specified (or predefined) signal to the running Node.js process. (See\nbelow on how to modify the signal that triggers the report.) Default signal is\n<code>SIGUSR2</code>. Useful when a report needs to be triggered from another program.\nApplication monitors may leverage this feature to collect report at regular\nintervals and plot rich set of internal runtime data to their views.</p>\n</li>\n</ul>\n<p>Signal based report generation is not supported in Windows.</p>\n<p>Under normal circumstances, there is no need to modify the report triggering\nsignal. However, if <code>SIGUSR2</code> is already used for other purposes, then this\nflag helps to change the signal for report generation and preserve the original\nmeaning of <code>SIGUSR2</code> for the said purposes.</p>\n<ul>\n<li>\n<p><code>--report-on-fatalerror</code> Enables the report to be triggered on fatal errors\n(internal errors within the Node.js runtime, such as out of memory)\nthat leads to termination of the application. Useful to inspect various\ndiagnostic data elements such as heap, stack, event loop state, resource\nconsumption etc. to reason about the fatal error.</p>\n</li>\n<li>\n<p><code>--report-compact</code> Write reports in a compact format, single-line JSON, more\neasily consumable by log processing systems than the default multi-line format\ndesigned for human consumption.</p>\n</li>\n<li>\n<p><code>--report-directory</code> Location at which the report will be\ngenerated.</p>\n</li>\n<li>\n<p><code>--report-filename</code> Name of the file to which the report will be\nwritten.</p>\n</li>\n<li>\n<p><code>--report-signal</code> Sets or resets the signal for report generation\n(not supported on Windows). Default signal is <code>SIGUSR2</code>.</p>\n</li>\n</ul>\n<p>A report can also be triggered via an API call from a JavaScript application:</p>\n<pre><code class=\"language-js\">process.report.writeReport();\n</code></pre>\n<p>This function takes an optional additional argument <code>filename</code>, which is\nthe name of a file into which the report is written.</p>\n<pre><code class=\"language-js\">process.report.writeReport('./foo.json');\n</code></pre>\n<p>This function takes an optional additional argument <code>err</code> which is an <code>Error</code>\nobject that will be used as the context for the JavaScript stack printed in the\nreport. When using report to handle errors in a callback or an exception\nhandler, this allows the report to include the location of the original error as\nwell as where it was handled.</p>\n<pre><code class=\"language-js\">try {\n  process.chdir('/non-existent-path');\n} catch (err) {\n  process.report.writeReport(err);\n}\n// Any other code\n</code></pre>\n<p>If both filename and error object are passed to <code>writeReport()</code> the\nerror object must be the second parameter.</p>\n<pre><code class=\"language-js\">try {\n  process.chdir('/non-existent-path');\n} catch (err) {\n  process.report.writeReport(filename, err);\n}\n// Any other code\n</code></pre>\n<p>The content of the diagnostic report can be returned as a JavaScript Object\nvia an API call from a JavaScript application:</p>\n<pre><code class=\"language-js\">const report = process.report.getReport();\nconsole.log(typeof report === 'object'); // true\n\n// Similar to process.report.writeReport() output\nconsole.log(JSON.stringify(report, null, 2));\n</code></pre>\n<p>This function takes an optional additional argument <code>err</code>, which is an <code>Error</code>\nobject that will be used as the context for the JavaScript stack printed in the\nreport.</p>\n<pre><code class=\"language-js\">const report = process.report.getReport(new Error('custom error'));\nconsole.log(typeof report === 'object'); // true\n</code></pre>\n<p>The API versions are useful when inspecting the runtime state from within\nthe application, in expectation of self-adjusting the resource consumption,\nload balancing, monitoring etc.</p>\n<p>The content of the report consists of a header section containing the event\ntype, date, time, PID and Node.js version, sections containing JavaScript and\nnative stack traces, a section containing V8 heap information, a section\ncontaining <code>libuv</code> handle information and an OS platform information section\nshowing CPU and memory usage and system limits. An example report can be\ntriggered using the Node.js REPL:</p>\n<pre><code class=\"language-console\">$ node\n> process.report.writeReport();\nWriting Node.js report to file: report.20181126.091102.8480.0.001.json\nNode.js report completed\n>\n</code></pre>\n<p>When a report is written, start and end messages are issued to stderr\nand the filename of the report is returned to the caller. The default filename\nincludes the date, time, PID and a sequence number. The sequence number helps\nin associating the report dump with the runtime state if generated multiple\ntimes for the same Node.js process.</p>",
           "type": "misc",
           "displayName": "Usage"
         },
@@ -11619,7 +12433,10 @@
           "meta": {
             "changes": [
               {
-                "version": "v12.16.2",
+                "version": [
+                  "v13.9.0",
+                  "v12.16.2"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/31386",
                 "description": "Workers are now included in the report."
               }
@@ -11629,7 +12446,8 @@
           "type": "misc",
           "displayName": "Interaction with workers"
         }
-      ]
+      ],
+      "source": "doc/api/report.md"
     }
   ],
   "modules": [
@@ -11643,11 +12461,12 @@
           "name": "Usage",
           "introduced_in": "v0.10.0",
           "type": "misc",
-          "desc": "<p><code>node [options] [V8 options] [script.js | -e \"script\" | - ] [arguments]</code></p>\n<p>Please see the <a href=\"cli.html#cli_command_line_options\">Command Line Options</a> document for more information.</p>\n<h2>Example</h2>\n<p>An example of a <a href=\"http.html\">web server</a> written with Node.js which responds with\n<code>'Hello, World!'</code>:</p>\n<p>Commands in this document start with <code>$</code> or <code>></code> to replicate how they would\nappear in a user's terminal. Do not include the <code>$</code> and <code>></code> characters. They are\nthere to show the start of each command.</p>\n<p>Lines that don’t start with <code>$</code> or <code>></code> character show the output of the previous\ncommand.</p>\n<p>First, make sure to have downloaded and installed Node.js. See <a href=\"https://nodejs.org/en/download/package-manager/\">this guide</a>\nfor further install information.</p>\n<p>Now, create an empty project folder called <code>projects</code>, then navigate into it.</p>\n<p>Linux and Mac:</p>\n<pre><code class=\"language-console\">$ mkdir ~/projects\n$ cd ~/projects\n</code></pre>\n<p>Windows CMD:</p>\n<pre><code class=\"language-console\">> mkdir %USERPROFILE%\\projects\n> cd %USERPROFILE%\\projects\n</code></pre>\n<p>Windows PowerShell:</p>\n<pre><code class=\"language-console\">> mkdir $env:USERPROFILE\\projects\n> cd $env:USERPROFILE\\projects\n</code></pre>\n<p>Next, create a new source file in the <code>projects</code>\nfolder and call it <code>hello-world.js</code>.</p>\n<p>Open <code>hello-world.js</code> in any preferred text editor and\npaste in the following content:</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst hostname = '127.0.0.1';\nconst port = 3000;\n\nconst server = http.createServer((req, res) => {\n  res.statusCode = 200;\n  res.setHeader('Content-Type', 'text/plain');\n  res.end('Hello, World!\\n');\n});\n\nserver.listen(port, hostname, () => {\n  console.log(`Server running at http://${hostname}:${port}/`);\n});\n</code></pre>\n<p>Save the file, go back to the terminal window, and enter the following command:</p>\n<pre><code class=\"language-console\">$ node hello-world.js\n</code></pre>\n<p>Output like this should appear in the terminal:</p>\n<pre><code class=\"language-console\">Server running at http://127.0.0.1:3000/\n</code></pre>\n<p>Now, open any preferred web browser and visit <code>http://127.0.0.1:3000</code>.</p>\n<p>If the browser displays the string <code>Hello, World!</code>, that indicates\nthe server is working.</p>"
+          "desc": "<p><code>node [options] [V8 options] [script.js | -e \"script\" | - ] [arguments]</code></p>\n<p>Please see the <a href=\"cli.html#cli_command_line_options\">Command-line options</a> document for more information.</p>\n<h2>Example</h2>\n<p>An example of a <a href=\"http.html\">web server</a> written with Node.js which responds with\n<code>'Hello, World!'</code>:</p>\n<p>Commands in this document start with <code>$</code> or <code>></code> to replicate how they would\nappear in a user's terminal. Do not include the <code>$</code> and <code>></code> characters. They are\nthere to show the start of each command.</p>\n<p>Lines that don’t start with <code>$</code> or <code>></code> character show the output of the previous\ncommand.</p>\n<p>First, make sure to have downloaded and installed Node.js. See\n<a href=\"https://nodejs.org/en/download/package-manager/\">Installing Node.js via package manager</a> for further install information.</p>\n<p>Now, create an empty project folder called <code>projects</code>, then navigate into it.</p>\n<p>Linux and Mac:</p>\n<pre><code class=\"language-console\">$ mkdir ~/projects\n$ cd ~/projects\n</code></pre>\n<p>Windows CMD:</p>\n<pre><code class=\"language-console\">> mkdir %USERPROFILE%\\projects\n> cd %USERPROFILE%\\projects\n</code></pre>\n<p>Windows PowerShell:</p>\n<pre><code class=\"language-console\">> mkdir $env:USERPROFILE\\projects\n> cd $env:USERPROFILE\\projects\n</code></pre>\n<p>Next, create a new source file in the <code>projects</code>\nfolder and call it <code>hello-world.js</code>.</p>\n<p>Open <code>hello-world.js</code> in any preferred text editor and\npaste in the following content:</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst hostname = '127.0.0.1';\nconst port = 3000;\n\nconst server = http.createServer((req, res) => {\n  res.statusCode = 200;\n  res.setHeader('Content-Type', 'text/plain');\n  res.end('Hello, World!\\n');\n});\n\nserver.listen(port, hostname, () => {\n  console.log(`Server running at http://${hostname}:${port}/`);\n});\n</code></pre>\n<p>Save the file, go back to the terminal window, and enter the following command:</p>\n<pre><code class=\"language-console\">$ node hello-world.js\n</code></pre>\n<p>Output like this should appear in the terminal:</p>\n<pre><code class=\"language-console\">Server running at http://127.0.0.1:3000/\n</code></pre>\n<p>Now, open any preferred web browser and visit <code>http://127.0.0.1:3000</code>.</p>\n<p>If the browser displays the string <code>Hello, World!</code>, that indicates\nthe server is working.</p>"
         }
       ],
       "type": "module",
-      "displayName": "Usage and example"
+      "displayName": "Usage and example",
+      "source": "doc/api/synopsis.md"
     },
     {
       "textRaw": "Assert",
@@ -11655,7 +12474,7 @@
       "introduced_in": "v0.1.21",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/assert.js\">lib/assert.js</a></p>\n<p>The <code>assert</code> module provides a set of assertion functions for verifying\ninvariants.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/assert.js\">lib/assert.js</a></p>\n<p>The <code>assert</code> module provides a set of assertion functions for verifying\ninvariants.</p>",
       "modules": [
         {
           "textRaw": "Strict assertion mode",
@@ -11666,7 +12485,11 @@
             ],
             "changes": [
               {
-                "version": "v12.16.2",
+                "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\"."
               },
               {
@@ -11750,13 +12573,13 @@
           "name": "assert.CallTracker",
           "meta": {
             "added": [
-              "v12.19.0"
+              "v14.2.0"
             ],
             "changes": []
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p>This feature is currently experimental and behavior might still change.</p>\n<p>### <code>new assert.CallTracker()</code></p>\n<p>Creates a new <a href=\"assert.html#assert_class_assert_calltracker\"><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#process_event_exit\"><code>process.on('exit')</code></a> handler.</p>\n<pre><code class=\"language-js\">const assert = require('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>",
+          "desc": "<p>This feature is currently experimental and behavior might still change.</p>",
           "methods": [
             {
               "textRaw": "`tracker.calls([fn][, exact])`",
@@ -11764,7 +12587,7 @@
               "name": "calls",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.2.0"
                 ],
                 "changes": []
               },
@@ -11800,7 +12623,7 @@
               "name": "report",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.2.0"
                 ],
                 "changes": []
               },
@@ -11860,7 +12683,7 @@
               "name": "verify",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.2.0"
                 ],
                 "changes": []
               },
@@ -11871,6 +12694,12 @@
               ],
               "desc": "<p>Iterates through the list of functions passed to\n<a href=\"assert.html#assert_tracker_calls_fn_exact\"><code>tracker.calls()</code></a> and will throw an error for functions that\nhave not been called the expected number of times.</p>\n<pre><code class=\"language-js\">const assert = require('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": "<p>Creates a new <a href=\"assert.html#assert_class_assert_calltracker\"><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#process_event_exit\"><code>process.on('exit')</code></a> handler.</p>\n<pre><code class=\"language-js\">const assert = require('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>"
+            }
           ]
         }
       ],
@@ -11913,6 +12742,16 @@
               "v0.1.21"
             ],
             "changes": [
+              {
+                "version": "v14.18.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 in case both sides are NaN."
+              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/25008",
@@ -11921,25 +12760,34 @@
               {
                 "version": "v9.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/15001",
-                "description": "The `Error` names and messages are now properly compared"
+                "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"
+                "description": "The `Set` and `Map` content is also compared."
               },
               {
-                "version": "v6.4.0, v4.7.1",
+                "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",
+                "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",
+                "version": [
+                  "v5.10.1",
+                  "v4.4.3"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/5910",
                 "description": "Handle non-`Uint8Array` typed arrays correctly."
               }
@@ -11966,12 +12814,12 @@
               ]
             }
           ],
-          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"assert.html#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 0 - Deprecated: Use <a href=\"assert.html#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters. Consider\nusing <a href=\"assert.html#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a> instead. <a href=\"assert.html#assert_assert_deepequal_actual_expected_message\"><code>assert.deepEqual()</code></a> can have\nsurprising results.</p>\n<p><em>Deep equality</em> means that the enumerable \"own\" properties of child objects\nare also recursively evaluated by the following rules.</p>",
+          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"assert.html#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 3 - Legacy: Use <a href=\"assert.html#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters. Consider\nusing <a href=\"assert.html#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a> instead. <a href=\"assert.html#assert_assert_deepequal_actual_expected_message\"><code>assert.deepEqual()</code></a> can have\nsurprising results.</p>\n<p><em>Deep equality</em> means that the enumerable \"own\" properties of child objects\nare also recursively evaluated by the following rules.</p>",
           "modules": [
             {
               "textRaw": "Comparison details",
               "name": "comparison_details",
-              "desc": "<ul>\n<li>Primitive values are compared with the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>==</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#errors_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>\n<p>The following example does not throw an <a href=\"assert.html#assert_class_assert_assertionerror\"><code>AssertionError</code></a> because the\nprimitives are considered equal by the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>==</code> ).</p>\n<pre><code class=\"language-js\">// WARNING: This does not throw an AssertionError!\nassert.deepEqual('+00000000', false);\n</code></pre>\n<p>\"Deep\" equality means that the enumerable \"own\" properties of child objects\nare evaluated also:</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are not equal, an <a href=\"assert.html#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<a href=\"assert.html#assert_class_assert_assertionerror\"><code>AssertionError</code></a>.</p>",
+              "desc": "<ul>\n<li>Primitive values are compared with the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>==</code> ) with 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#errors_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>\n<p>The following example does not throw an <a href=\"assert.html#assert_class_assert_assertionerror\"><code>AssertionError</code></a> because the\nprimitives are considered equal by the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>==</code> ).</p>\n<pre><code class=\"language-js\">// WARNING: This does not throw an AssertionError!\nassert.deepEqual('+00000000', false);\n</code></pre>\n<p>\"Deep\" equality means that the enumerable \"own\" properties of child objects\nare evaluated also:</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are not equal, an <a href=\"assert.html#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<a href=\"assert.html#assert_class_assert_assertionerror\"><code>AssertionError</code></a>.</p>",
               "type": "module",
               "displayName": "Comparison details"
             }
@@ -11999,15 +12847,18 @@
               {
                 "version": "v8.5.0",
                 "pr-url": "https://github.com/nodejs/node/pull/15001",
-                "description": "The `Error` names and messages are now properly compared"
+                "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"
+                "description": "The `Set` and `Map` content is also compared."
               },
               {
-                "version": "v6.4.0, v4.7.1",
+                "version": [
+                  "v6.4.0",
+                  "v4.7.1"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/8002",
                 "description": "Typed array slices are handled correctly now."
               },
@@ -12017,7 +12868,10 @@
                 "description": "Objects with circular references can be used as inputs now."
               },
               {
-                "version": "v5.10.1, v4.4.3",
+                "version": [
+                  "v5.10.1",
+                  "v4.4.3"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/5910",
                 "description": "Handle non-`Uint8Array` typed arrays correctly."
               }
@@ -12061,6 +12915,7 @@
           "name": "doesNotMatch",
           "meta": {
             "added": [
+              "v13.6.0",
               "v12.16.0"
             ],
             "changes": []
@@ -12133,7 +12988,10 @@
             ],
             "changes": [
               {
-                "version": "v5.11.0, v4.4.5",
+                "version": [
+                  "v5.11.0",
+                  "v4.4.5"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/2407",
                 "description": "The `message` parameter is respected now."
               },
@@ -12175,7 +13033,18 @@
             "added": [
               "v0.1.21"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.18.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 in case both sides are NaN."
+              }
+            ]
           },
           "signatures": [
             {
@@ -12198,7 +13067,7 @@
               ]
             }
           ],
-          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"assert.html#assert_assert_strictequal_actual_expected_message\"><code>assert.strictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 0 - Deprecated: Use <a href=\"assert.html#assert_assert_strictequal_actual_expected_message\"><code>assert.strictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests shallow, coercive equality between the <code>actual</code> and <code>expected</code> parameters\nusing the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a> ( <code>==</code> ).</p>\n<pre><code class=\"language-js\">const assert = require('assert');\n\nassert.equal(1, 1);\n// OK, 1 == 1\nassert.equal(1, '1');\n// OK, 1 == '1'\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<p>If the values are not equal, an <a href=\"assert.html#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.</p>"
+          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"assert.html#assert_assert_strictequal_actual_expected_message\"><code>assert.strictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 3 - Legacy: Use <a href=\"assert.html#assert_assert_strictequal_actual_expected_message\"><code>assert.strictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests shallow, coercive equality between the <code>actual</code> and <code>expected</code> parameters\nusing the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a> ( <code>==</code> ). <code>NaN</code> is special handled\nand treated as being identical in case both sides are <code>NaN</code>.</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are not equal, an <a href=\"assert.html#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.</p>"
         },
         {
           "textRaw": "`assert.fail([message])`",
@@ -12317,6 +13186,7 @@
           "name": "match",
           "meta": {
             "added": [
+              "v13.6.0",
               "v12.16.0"
             ],
             "changes": []
@@ -12355,28 +13225,47 @@
               "v0.1.21"
             ],
             "changes": [
+              {
+                "version": "v14.18.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 in case 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"
+                "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"
+                "description": "The `Set` and `Map` content is also compared."
               },
               {
-                "version": "v6.4.0, v4.7.1",
+                "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",
+                "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",
+                "version": [
+                  "v5.10.1",
+                  "v4.4.3"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/5910",
                 "description": "Handle non-`Uint8Array` typed arrays correctly."
               }
@@ -12403,7 +13292,7 @@
               ]
             }
           ],
-          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"assert.html#assert_assert_notdeepstrictequal_actual_expected_message\"><code>assert.notDeepStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 0 - Deprecated: Use <a href=\"assert.html#assert_assert_notdeepstrictequal_actual_expected_message\"><code>assert.notDeepStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests for any deep inequality. Opposite of <a href=\"assert.html#assert_assert_deepequal_actual_expected_message\"><code>assert.deepEqual()</code></a>.</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are deeply equal, an <a href=\"assert.html#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown\ninstead of the <code>AssertionError</code>.</p>"
+          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"assert.html#assert_assert_notdeepstrictequal_actual_expected_message\"><code>assert.notDeepStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 3 - Legacy: Use <a href=\"assert.html#assert_assert_notdeepstrictequal_actual_expected_message\"><code>assert.notDeepStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests for any deep inequality. Opposite of <a href=\"assert.html#assert_assert_deepequal_actual_expected_message\"><code>assert.deepEqual()</code></a>.</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are deeply equal, an <a href=\"assert.html#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown\ninstead of the <code>AssertionError</code>.</p>"
         },
         {
           "textRaw": "`assert.notDeepStrictEqual(actual, expected[, message])`",
@@ -12427,15 +13316,18 @@
               {
                 "version": "v9.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/15001",
-                "description": "The `Error` names and messages are now properly compared"
+                "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"
+                "description": "The `Set` and `Map` content is also compared."
               },
               {
-                "version": "v6.4.0, v4.7.1",
+                "version": [
+                  "v6.4.0",
+                  "v4.7.1"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/8002",
                 "description": "Typed array slices are handled correctly now."
               },
@@ -12445,7 +13337,10 @@
                 "description": "Objects with circular references can be used as inputs now."
               },
               {
-                "version": "v5.10.1, v4.4.3",
+                "version": [
+                  "v5.10.1",
+                  "v4.4.3"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/5910",
                 "description": "Handle non-`Uint8Array` typed arrays correctly."
               }
@@ -12482,7 +13377,18 @@
             "added": [
               "v0.1.21"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.18.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 in case both sides are NaN."
+              }
+            ]
           },
           "signatures": [
             {
@@ -12505,7 +13411,7 @@
               ]
             }
           ],
-          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"assert.html#assert_assert_notstrictequal_actual_expected_message\"><code>assert.notStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 0 - Deprecated: Use <a href=\"assert.html#assert_assert_notstrictequal_actual_expected_message\"><code>assert.notStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests shallow, coercive inequality with the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>!=</code> ).</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are equal, an <a href=\"assert.html#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.</p>"
+          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"assert.html#assert_assert_notstrictequal_actual_expected_message\"><code>assert.notStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 3 - Legacy: Use <a href=\"assert.html#assert_assert_notstrictequal_actual_expected_message\"><code>assert.notStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests shallow, coercive inequality with the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n(<code>!=</code> ). <code>NaN</code> is special handled and treated as being identical in case both\nsides are <code>NaN</code>.</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are equal, an <a href=\"assert.html#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.</p>"
         },
         {
           "textRaw": "`assert.notStrictEqual(actual, expected[, message])`",
@@ -12519,7 +13425,7 @@
               {
                 "version": "v10.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/17003",
-                "description": "Used comparison changed from Strict Equality to `Object.is()`"
+                "description": "Used comparison changed from Strict Equality to `Object.is()`."
               }
             ]
           },
@@ -12625,7 +13531,7 @@
               {
                 "version": "v10.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/17003",
-                "description": "Used comparison changed from Strict Equality to `Object.is()`"
+                "description": "Used comparison changed from Strict Equality to `Object.is()`."
               }
             ]
           },
@@ -12703,7 +13609,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Assert"
+      "displayName": "Assert",
+      "source": "doc/api/assert.md"
     },
     {
       "textRaw": "Async hooks",
@@ -12711,7 +13618,7 @@
       "introduced_in": "v8.1.0",
       "stability": 1,
       "stabilityText": "Experimental",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/async_hooks.js\">lib/async_hooks.js</a></p>\n<p>The <code>async_hooks</code> module provides an API to track asynchronous resources. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/async_hooks.js\">lib/async_hooks.js</a></p>\n<p>The <code>async_hooks</code> module provides an API to track asynchronous resources. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Terminology",
@@ -12721,363 +13628,11 @@
           "displayName": "Terminology"
         },
         {
-          "textRaw": "Public API",
-          "name": "public_api",
-          "modules": [
-            {
-              "textRaw": "Overview",
-              "name": "overview",
-              "desc": "<p>Following is a simple overview of the public API.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\n// Return the ID of the current execution context.\nconst eid = async_hooks.executionAsyncId();\n\n// Return the ID of the handle responsible for triggering the callback of the\n// current execution scope to call.\nconst tid = async_hooks.triggerAsyncId();\n\n// Create a new AsyncHook instance. All of these callbacks are optional.\nconst asyncHook =\n    async_hooks.createHook({ init, before, after, destroy, promiseResolve });\n\n// Allow callbacks of this AsyncHook instance to call. This is not an implicit\n// action after running the constructor, and must be explicitly run to begin\n// executing callbacks.\nasyncHook.enable();\n\n// Disable listening for new asynchronous events.\nasyncHook.disable();\n\n//\n// The following are the callbacks that can be passed to createHook().\n//\n\n// init is called during object construction. The resource may not have\n// completed construction when this callback runs, therefore all fields of the\n// resource referenced by \"asyncId\" may not have been populated.\nfunction init(asyncId, type, triggerAsyncId, resource) { }\n\n// Before is called just before the resource's callback is called. It can be\n// called 0-N times for handles (e.g. TCPWrap), and will be called exactly 1\n// time for requests (e.g. FSReqCallback).\nfunction before(asyncId) { }\n\n// After is called just after the resource's callback has finished.\nfunction after(asyncId) { }\n\n// Destroy is called when the resource is destroyed.\nfunction destroy(asyncId) { }\n\n// promiseResolve is called only for promise resources, when the\n// `resolve` function passed to the `Promise` constructor is invoked\n// (either directly or through other means of resolving a promise).\nfunction promiseResolve(asyncId) { }\n</code></pre>",
-              "methods": [
-                {
-                  "textRaw": "`async_hooks.createHook(callbacks)`",
-                  "type": "method",
-                  "name": "createHook",
-                  "meta": {
-                    "added": [
-                      "v8.1.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {AsyncHook} Instance used for disabling and enabling hooks",
-                        "name": "return",
-                        "type": "AsyncHook",
-                        "desc": "Instance used for disabling and enabling hooks"
-                      },
-                      "params": [
-                        {
-                          "textRaw": "`callbacks` {Object} The [Hook Callbacks][] to register",
-                          "name": "callbacks",
-                          "type": "Object",
-                          "desc": "The [Hook Callbacks][] to register",
-                          "options": [
-                            {
-                              "textRaw": "`init` {Function} The [`init` callback][].",
-                              "name": "init",
-                              "type": "Function",
-                              "desc": "The [`init` callback][]."
-                            },
-                            {
-                              "textRaw": "`before` {Function} The [`before` callback][].",
-                              "name": "before",
-                              "type": "Function",
-                              "desc": "The [`before` callback][]."
-                            },
-                            {
-                              "textRaw": "`after` {Function} The [`after` callback][].",
-                              "name": "after",
-                              "type": "Function",
-                              "desc": "The [`after` callback][]."
-                            },
-                            {
-                              "textRaw": "`destroy` {Function} The [`destroy` callback][].",
-                              "name": "destroy",
-                              "type": "Function",
-                              "desc": "The [`destroy` callback][]."
-                            },
-                            {
-                              "textRaw": "`promiseResolve` {Function} The [`promiseResolve` callback][].",
-                              "name": "promiseResolve",
-                              "type": "Function",
-                              "desc": "The [`promiseResolve` callback][]."
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  ],
-                  "desc": "<p>Registers functions to be called for different lifetime events of each async\noperation.</p>\n<p>The callbacks <code>init()</code>/<code>before()</code>/<code>after()</code>/<code>destroy()</code> are called for the\nrespective asynchronous event during a resource's lifetime.</p>\n<p>All callbacks are optional. For example, if only resource cleanup needs to\nbe tracked, then only the <code>destroy</code> callback needs to be passed. The\nspecifics of all functions that can be passed to <code>callbacks</code> is in the\n<a href=\"async_hooks.html#async_hooks_hook_callbacks\">Hook Callbacks</a> section.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconst asyncHook = async_hooks.createHook({\n  init(asyncId, type, triggerAsyncId, resource) { },\n  destroy(asyncId) { }\n});\n</code></pre>\n<p>The callbacks will be inherited via the prototype chain:</p>\n<pre><code class=\"language-js\">class MyAsyncCallbacks {\n  init(asyncId, type, triggerAsyncId, resource) { }\n  destroy(asyncId) {}\n}\n\nclass MyAddedCallbacks extends MyAsyncCallbacks {\n  before(asyncId) { }\n  after(asyncId) { }\n}\n\nconst asyncHook = async_hooks.createHook(new MyAddedCallbacks());\n</code></pre>",
-                  "modules": [
-                    {
-                      "textRaw": "Error handling",
-                      "name": "error_handling",
-                      "desc": "<p>If any <code>AsyncHook</code> callbacks throw, the application will print the stack trace\nand exit. The exit path does follow that of an uncaught exception, but\nall <code>'uncaughtException'</code> listeners are removed, thus forcing the process to\nexit. The <code>'exit'</code> callbacks will still be called unless the application is run\nwith <code>--abort-on-uncaught-exception</code>, in which case a stack trace will be\nprinted and the application exits, leaving a core file.</p>\n<p>The reason for this error handling behavior is that these callbacks are running\nat potentially volatile points in an object's lifetime, for example during\nclass construction and destruction. Because of this, it is deemed necessary to\nbring down the process quickly in order to prevent an unintentional abort in the\nfuture. This is subject to change in the future if a comprehensive analysis is\nperformed to ensure an exception can follow the normal control flow without\nunintentional side effects.</p>",
-                      "type": "module",
-                      "displayName": "Error handling"
-                    },
-                    {
-                      "textRaw": "Printing in AsyncHooks callbacks",
-                      "name": "printing_in_asynchooks_callbacks",
-                      "desc": "<p>Because printing to the console is an asynchronous operation, <code>console.log()</code>\nwill cause the AsyncHooks callbacks to be called. Using <code>console.log()</code> or\nsimilar asynchronous operations inside an AsyncHooks callback function will thus\ncause an infinite recursion. An easy solution to this when debugging is to use a\nsynchronous logging operation such as <code>fs.writeFileSync(file, msg, flag)</code>.\nThis will print to the file and will not invoke AsyncHooks recursively because\nit is synchronous.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst util = require('util');\n\nfunction debug(...args) {\n  // Use a function like this one when debugging inside an AsyncHooks callback\n  fs.writeFileSync('log.out', `${util.format(...args)}\\n`, { flag: 'a' });\n}\n</code></pre>\n<p>If an asynchronous operation is needed for logging, it is possible to keep\ntrack of what caused the asynchronous operation using the information\nprovided by AsyncHooks itself. The logging should then be skipped when\nit was the logging itself that caused AsyncHooks callback to call. By\ndoing this the otherwise infinite recursion is broken.</p>",
-                      "type": "module",
-                      "displayName": "Printing in AsyncHooks callbacks"
-                    }
-                  ]
-                }
-              ],
-              "type": "module",
-              "displayName": "Overview"
-            }
-          ],
-          "classes": [
-            {
-              "textRaw": "Class: `AsyncHook`",
-              "type": "class",
-              "name": "AsyncHook",
-              "desc": "<p>The class <code>AsyncHook</code> exposes an interface for tracking lifetime events\nof asynchronous operations.</p>",
-              "methods": [
-                {
-                  "textRaw": "`asyncHook.enable()`",
-                  "type": "method",
-                  "name": "enable",
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {AsyncHook} A reference to `asyncHook`.",
-                        "name": "return",
-                        "type": "AsyncHook",
-                        "desc": "A reference to `asyncHook`."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Enable the callbacks for a given <code>AsyncHook</code> instance. If no callbacks are\nprovided enabling is a noop.</p>\n<p>The <code>AsyncHook</code> instance is disabled by default. If the <code>AsyncHook</code> instance\nshould be enabled immediately after creation, the following pattern can be used.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconst hook = async_hooks.createHook(callbacks).enable();\n</code></pre>"
-                },
-                {
-                  "textRaw": "`asyncHook.disable()`",
-                  "type": "method",
-                  "name": "disable",
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {AsyncHook} A reference to `asyncHook`.",
-                        "name": "return",
-                        "type": "AsyncHook",
-                        "desc": "A reference to `asyncHook`."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Disable the callbacks for a given <code>AsyncHook</code> instance from the global pool of\n<code>AsyncHook</code> callbacks to be executed. Once a hook has been disabled it will not\nbe called again until enabled.</p>\n<p>For API consistency <code>disable()</code> also returns the <code>AsyncHook</code> instance.</p>"
-                },
-                {
-                  "textRaw": "`async_hooks.executionAsyncResource()`",
-                  "type": "method",
-                  "name": "executionAsyncResource",
-                  "meta": {
-                    "added": [
-                      "v12.17.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {Object} The resource representing the current execution. Useful to store data within the resource.",
-                        "name": "return",
-                        "type": "Object",
-                        "desc": "The resource representing the current execution. Useful to store data within the resource."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Resource objects returned by <code>executionAsyncResource()</code> are most often internal\nNode.js handle objects with undocumented APIs. Using any functions or properties\non the object is likely to crash your application and should be avoided.</p>\n<p>Using <code>executionAsyncResource()</code> in the top-level execution context will\nreturn an empty object as there is no handle or request object to use,\nbut having an object representing the top-level can be helpful.</p>\n<pre><code class=\"language-js\">const { open } = require('fs');\nconst { executionAsyncId, executionAsyncResource } = require('async_hooks');\n\nconsole.log(executionAsyncId(), executionAsyncResource());  // 1 {}\nopen(__filename, 'r', (err, fd) => {\n  console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap\n});\n</code></pre>\n<p>This can be used to implement continuation local storage without the\nuse of a tracking <code>Map</code> to store the metadata:</p>\n<pre><code class=\"language-js\">const { createServer } = require('http');\nconst {\n  executionAsyncId,\n  executionAsyncResource,\n  createHook\n} = require('async_hooks');\nconst sym = Symbol('state'); // Private symbol to avoid pollution\n\ncreateHook({\n  init(asyncId, type, triggerAsyncId, resource) {\n    const cr = executionAsyncResource();\n    if (cr) {\n      resource[sym] = cr[sym];\n    }\n  }\n}).enable();\n\nconst server = createServer((req, res) => {\n  executionAsyncResource()[sym] = { state: req.url };\n  setTimeout(function() {\n    res.end(JSON.stringify(executionAsyncResource()[sym]));\n  }, 100);\n}).listen(3000);\n</code></pre>"
-                },
-                {
-                  "textRaw": "`async_hooks.executionAsyncId()`",
-                  "type": "method",
-                  "name": "executionAsyncId",
-                  "meta": {
-                    "added": [
-                      "v8.1.0"
-                    ],
-                    "changes": [
-                      {
-                        "version": "v8.2.0",
-                        "pr-url": "https://github.com/nodejs/node/pull/13490",
-                        "description": "Renamed from `currentId`"
-                      }
-                    ]
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {number} The `asyncId` of the current execution context. Useful to track when something calls.",
-                        "name": "return",
-                        "type": "number",
-                        "desc": "The `asyncId` of the current execution context. Useful to track when something calls."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconsole.log(async_hooks.executionAsyncId());  // 1 - bootstrap\nfs.open(path, 'r', (err, fd) => {\n  console.log(async_hooks.executionAsyncId());  // 6 - open()\n});\n</code></pre>\n<p>The ID returned from <code>executionAsyncId()</code> is related to execution timing, not\ncausality (which is covered by <code>triggerAsyncId()</code>):</p>\n<pre><code class=\"language-js\">const server = net.createServer((conn) => {\n  // Returns the ID of the server, not of the new connection, because the\n  // callback runs in the execution scope of the server's MakeCallback().\n  async_hooks.executionAsyncId();\n\n}).listen(port, () => {\n  // Returns the ID of a TickObject (i.e. process.nextTick()) because all\n  // callbacks passed to .listen() are wrapped in a nextTick().\n  async_hooks.executionAsyncId();\n});\n</code></pre>\n<p>Promise contexts may not get precise <code>executionAsyncIds</code> by default.\nSee the section on <a href=\"async_hooks.html#async_hooks_promise_execution_tracking\">promise execution tracking</a>.</p>"
-                },
-                {
-                  "textRaw": "`async_hooks.triggerAsyncId()`",
-                  "type": "method",
-                  "name": "triggerAsyncId",
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {number} The ID of the resource responsible for calling the callback that is currently being executed.",
-                        "name": "return",
-                        "type": "number",
-                        "desc": "The ID of the resource responsible for calling the callback that is currently being executed."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<pre><code class=\"language-js\">const server = net.createServer((conn) => {\n  // The resource that caused (or triggered) this callback to be called\n  // was that of the new connection. Thus the return value of triggerAsyncId()\n  // is the asyncId of \"conn\".\n  async_hooks.triggerAsyncId();\n\n}).listen(port, () => {\n  // Even though all callbacks passed to .listen() are wrapped in a nextTick()\n  // the callback itself exists because the call to the server's .listen()\n  // was made. So the return value would be the ID of the server.\n  async_hooks.triggerAsyncId();\n});\n</code></pre>\n<p>Promise contexts may not get valid <code>triggerAsyncId</code>s by default. See\nthe section on <a href=\"async_hooks.html#async_hooks_promise_execution_tracking\">promise execution tracking</a>.</p>"
-                }
-              ],
-              "modules": [
-                {
-                  "textRaw": "Hook callbacks",
-                  "name": "hook_callbacks",
-                  "desc": "<p>Key events in the lifetime of asynchronous events have been categorized into\nfour areas: instantiation, before/after the callback is called, and when the\ninstance is destroyed.</p>",
-                  "methods": [
-                    {
-                      "textRaw": "`init(asyncId, type, triggerAsyncId, resource)`",
-                      "type": "method",
-                      "name": "init",
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number} A unique ID for the async resource.",
-                              "name": "asyncId",
-                              "type": "number",
-                              "desc": "A unique ID for the async resource."
-                            },
-                            {
-                              "textRaw": "`type` {string} The type of the async resource.",
-                              "name": "type",
-                              "type": "string",
-                              "desc": "The type of the async resource."
-                            },
-                            {
-                              "textRaw": "`triggerAsyncId` {number} The unique ID of the async resource in whose execution context this async resource was created.",
-                              "name": "triggerAsyncId",
-                              "type": "number",
-                              "desc": "The unique ID of the async resource in whose execution context this async resource was created."
-                            },
-                            {
-                              "textRaw": "`resource` {Object} Reference to the resource representing the async operation, needs to be released during _destroy_.",
-                              "name": "resource",
-                              "type": "Object",
-                              "desc": "Reference to the resource representing the async operation, needs to be released during _destroy_."
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>Called when a class is constructed that has the <em>possibility</em> to emit an\nasynchronous event. This <em>does not</em> mean the instance must call\n<code>before</code>/<code>after</code> before <code>destroy</code> is called, only that the possibility\nexists.</p>\n<p>This behavior can be observed by doing something like opening a resource then\nclosing it before the resource can be used. The following snippet demonstrates\nthis.</p>\n<pre><code class=\"language-js\">require('net').createServer().listen(function() { this.close(); });\n// OR\nclearTimeout(setTimeout(() => {}, 10));\n</code></pre>\n<p>Every new resource is assigned an ID that is unique within the scope of the\ncurrent Node.js instance.</p>",
-                      "modules": [
-                        {
-                          "textRaw": "`type`",
-                          "name": "`type`",
-                          "desc": "<p>The <code>type</code> is a string identifying the type of resource that caused\n<code>init</code> to be called. Generally, it will correspond to the name of the\nresource's constructor.</p>\n<pre><code class=\"language-text\">FSEVENTWRAP, FSREQCALLBACK, GETADDRINFOREQWRAP, GETNAMEINFOREQWRAP, HTTPINCOMINGMESSAGE,\nHTTPCLIENTREQUEST, JSSTREAM, PIPECONNECTWRAP, PIPEWRAP, PROCESSWRAP, QUERYWRAP,\nSHUTDOWNWRAP, SIGNALWRAP, STATWATCHER, TCPCONNECTWRAP, TCPSERVERWRAP, TCPWRAP,\nTTYWRAP, UDPSENDWRAP, UDPWRAP, WRITEWRAP, ZLIB, SSLCONNECTION, PBKDF2REQUEST,\nRANDOMBYTESREQUEST, TLSWRAP, Microtask, Timeout, Immediate, TickObject\n</code></pre>\n<p>There is also the <code>PROMISE</code> resource type, which is used to track <code>Promise</code>\ninstances and asynchronous work scheduled by them.</p>\n<p>Users are able to define their own <code>type</code> when using the public embedder API.</p>\n<p>It is possible to have type name collisions. Embedders are encouraged to use\nunique prefixes, such as the npm package name, to prevent collisions when\nlistening to the hooks.</p>",
-                          "type": "module",
-                          "displayName": "`type`"
-                        },
-                        {
-                          "textRaw": "`triggerAsyncId`",
-                          "name": "`triggerasyncid`",
-                          "desc": "<p><code>triggerAsyncId</code> is the <code>asyncId</code> of the resource that caused (or \"triggered\")\nthe new resource to initialize and that caused <code>init</code> to call. This is different\nfrom <code>async_hooks.executionAsyncId()</code> that only shows <em>when</em> a resource was\ncreated, while <code>triggerAsyncId</code> shows <em>why</em> a resource was created.</p>\n<p>The following is a simple demonstration of <code>triggerAsyncId</code>:</p>\n<pre><code class=\"language-js\">async_hooks.createHook({\n  init(asyncId, type, triggerAsyncId) {\n    const eid = async_hooks.executionAsyncId();\n    fs.writeSync(\n      process.stdout.fd,\n      `${type}(${asyncId}): trigger: ${triggerAsyncId} execution: ${eid}\\n`);\n  }\n}).enable();\n\nrequire('net').createServer((conn) => {}).listen(8080);\n</code></pre>\n<p>Output when hitting the server with <code>nc localhost 8080</code>:</p>\n<pre><code class=\"language-console\">TCPSERVERWRAP(5): trigger: 1 execution: 1\nTCPWRAP(7): trigger: 5 execution: 0\n</code></pre>\n<p>The <code>TCPSERVERWRAP</code> is the server which receives the connections.</p>\n<p>The <code>TCPWRAP</code> is the new connection from the client. When a new\nconnection is made, the <code>TCPWrap</code> instance is immediately constructed. This\nhappens outside of any JavaScript stack. (An <code>executionAsyncId()</code> of <code>0</code> means\nthat it is being executed from C++ with no JavaScript stack above it.) With only\nthat information, it would be impossible to link resources together in\nterms of what caused them to be created, so <code>triggerAsyncId</code> is given the task\nof propagating what resource is responsible for the new resource's existence.</p>",
-                          "type": "module",
-                          "displayName": "`triggerAsyncId`"
-                        },
-                        {
-                          "textRaw": "`resource`",
-                          "name": "`resource`",
-                          "desc": "<p><code>resource</code> is an object that represents the actual async resource that has\nbeen initialized. This can contain useful information that can vary based on\nthe value of <code>type</code>. For instance, for the <code>GETADDRINFOREQWRAP</code> resource type,\n<code>resource</code> provides the host name used when looking up the IP address for the\nhost in <code>net.Server.listen()</code>. The API for accessing this information is\nnot supported, but using the Embedder API, users can provide\nand document their own resource objects. For example, such a resource object\ncould contain the SQL query being executed.</p>\n<p>In the case of Promises, the <code>resource</code> object will have an\n<code>isChainedPromise</code> property, set to <code>true</code> if the promise has a parent promise,\nand <code>false</code> otherwise. For example, in the case of <code>b = a.then(handler)</code>, <code>a</code> is\nconsidered a parent <code>Promise</code> of <code>b</code>. Here, <code>b</code> is considered a chained promise.</p>\n<p>In some cases the resource object is reused for performance reasons, it is\nthus not safe to use it as a key in a <code>WeakMap</code> or add properties to it.</p>",
-                          "type": "module",
-                          "displayName": "`resource`"
-                        },
-                        {
-                          "textRaw": "Asynchronous context example",
-                          "name": "asynchronous_context_example",
-                          "desc": "<p>The following is an example with additional information about the calls to\n<code>init</code> between the <code>before</code> and <code>after</code> calls, specifically what the\ncallback to <code>listen()</code> will look like. The output formatting is slightly more\nelaborate to make calling context easier to see.</p>\n<pre><code class=\"language-js\">let indent = 0;\nasync_hooks.createHook({\n  init(asyncId, type, triggerAsyncId) {\n    const eid = async_hooks.executionAsyncId();\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(\n      process.stdout.fd,\n      `${indentStr}${type}(${asyncId}):` +\n      ` trigger: ${triggerAsyncId} execution: ${eid}\\n`);\n  },\n  before(asyncId) {\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(process.stdout.fd, `${indentStr}before:  ${asyncId}\\n`);\n    indent += 2;\n  },\n  after(asyncId) {\n    indent -= 2;\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(process.stdout.fd, `${indentStr}after:  ${asyncId}\\n`);\n  },\n  destroy(asyncId) {\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(process.stdout.fd, `${indentStr}destroy:  ${asyncId}\\n`);\n  },\n}).enable();\n\nrequire('net').createServer(() => {}).listen(8080, () => {\n  // Let's wait 10ms before logging the server started.\n  setTimeout(() => {\n    console.log('>>>', async_hooks.executionAsyncId());\n  }, 10);\n});\n</code></pre>\n<p>Output from only starting the server:</p>\n<pre><code class=\"language-console\">TCPSERVERWRAP(5): trigger: 1 execution: 1\nTickObject(6): trigger: 5 execution: 1\nbefore:  6\n  Timeout(7): trigger: 6 execution: 6\nafter:   6\ndestroy: 6\nbefore:  7\n>>> 7\n  TickObject(8): trigger: 7 execution: 7\nafter:   7\nbefore:  8\nafter:   8\n</code></pre>\n<p>As illustrated in the example, <code>executionAsyncId()</code> and <code>execution</code> each specify\nthe value of the current execution context; which is delineated by calls to\n<code>before</code> and <code>after</code>.</p>\n<p>Only using <code>execution</code> to graph resource allocation results in the following:</p>\n<pre><code class=\"language-console\">  root(1)\n     ^\n     |\nTickObject(6)\n     ^\n     |\n Timeout(7)\n</code></pre>\n<p>The <code>TCPSERVERWRAP</code> is not part of this graph, even though it was the reason for\n<code>console.log()</code> being called. This is because binding to a port without a host\nname is a <em>synchronous</em> operation, but to maintain a completely asynchronous\nAPI the user's callback is placed in a <code>process.nextTick()</code>. Which is why\n<code>TickObject</code> is present in the output and is a 'parent' for <code>.listen()</code>\ncallback.</p>\n<p>The graph only shows <em>when</em> a resource was created, not <em>why</em>, so to track\nthe <em>why</em> use <code>triggerAsyncId</code>. Which can be represented with the following\ngraph:</p>\n<pre><code class=\"language-console\"> bootstrap(1)\n     |\n     ˅\nTCPSERVERWRAP(5)\n     |\n     ˅\n TickObject(6)\n     |\n     ˅\n  Timeout(7)\n</code></pre>",
-                          "type": "module",
-                          "displayName": "Asynchronous context example"
-                        }
-                      ]
-                    },
-                    {
-                      "textRaw": "`before(asyncId)`",
-                      "type": "method",
-                      "name": "before",
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number}",
-                              "name": "asyncId",
-                              "type": "number"
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>When an asynchronous operation is initiated (such as a TCP server receiving a\nnew connection) or completes (such as writing data to disk) a callback is\ncalled to notify the user. The <code>before</code> callback is called just before said\ncallback is executed. <code>asyncId</code> is the unique identifier assigned to the\nresource about to execute the callback.</p>\n<p>The <code>before</code> callback will be called 0 to N times. The <code>before</code> callback\nwill typically be called 0 times if the asynchronous operation was cancelled\nor, for example, if no connections are received by a TCP server. Persistent\nasynchronous resources like a TCP server will typically call the <code>before</code>\ncallback multiple times, while other operations like <code>fs.open()</code> will call\nit only once.</p>"
-                    },
-                    {
-                      "textRaw": "`after(asyncId)`",
-                      "type": "method",
-                      "name": "after",
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number}",
-                              "name": "asyncId",
-                              "type": "number"
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>Called immediately after the callback specified in <code>before</code> is completed.</p>\n<p>If an uncaught exception occurs during execution of the callback, then <code>after</code>\nwill run <em>after</em> the <code>'uncaughtException'</code> event is emitted or a <code>domain</code>'s\nhandler runs.</p>"
-                    },
-                    {
-                      "textRaw": "`destroy(asyncId)`",
-                      "type": "method",
-                      "name": "destroy",
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number}",
-                              "name": "asyncId",
-                              "type": "number"
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>Called after the resource corresponding to <code>asyncId</code> is destroyed. It is also\ncalled asynchronously from the embedder API <code>emitDestroy()</code>.</p>\n<p>Some resources depend on garbage collection for cleanup, so if a reference is\nmade to the <code>resource</code> object passed to <code>init</code> it is possible that <code>destroy</code>\nwill never be called, causing a memory leak in the application. If the resource\ndoes not depend on garbage collection, then this will not be an issue.</p>"
-                    },
-                    {
-                      "textRaw": "`promiseResolve(asyncId)`",
-                      "type": "method",
-                      "name": "promiseResolve",
-                      "meta": {
-                        "added": [
-                          "v8.6.0"
-                        ],
-                        "changes": []
-                      },
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number}",
-                              "name": "asyncId",
-                              "type": "number"
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>Called when the <code>resolve</code> function passed to the <code>Promise</code> constructor is\ninvoked (either directly or through other means of resolving a promise).</p>\n<p><code>resolve()</code> does not do any observable synchronous work.</p>\n<p>The <code>Promise</code> is not necessarily fulfilled or rejected at this point if the\n<code>Promise</code> was resolved by assuming the state of another <code>Promise</code>.</p>\n<pre><code class=\"language-js\">new Promise((resolve) => resolve(true)).then((a) => {});\n</code></pre>\n<p>calls the following callbacks:</p>\n<pre><code class=\"language-text\">init for PROMISE with id 5, trigger id: 1\n  promise resolve 5      # corresponds to resolve(true)\ninit for PROMISE with id 6, trigger id: 5  # the Promise returned by then()\n  before 6               # the then() callback is entered\n  promise resolve 6      # the then() callback resolves the promise by returning\n  after 6\n</code></pre>"
-                    }
-                  ],
-                  "type": "module",
-                  "displayName": "Hook callbacks"
-                }
-              ]
-            }
-          ],
+          "textRaw": "Overview",
+          "name": "overview",
+          "desc": "<p>Following is a simple overview of the public API.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\n// Return the ID of the current execution context.\nconst eid = async_hooks.executionAsyncId();\n\n// Return the ID of the handle responsible for triggering the callback of the\n// current execution scope to call.\nconst tid = async_hooks.triggerAsyncId();\n\n// Create a new AsyncHook instance. All of these callbacks are optional.\nconst asyncHook =\n    async_hooks.createHook({ init, before, after, destroy, promiseResolve });\n\n// Allow callbacks of this AsyncHook instance to call. This is not an implicit\n// action after running the constructor, and must be explicitly run to begin\n// executing callbacks.\nasyncHook.enable();\n\n// Disable listening for new asynchronous events.\nasyncHook.disable();\n\n//\n// The following are the callbacks that can be passed to createHook().\n//\n\n// init is called during object construction. The resource may not have\n// completed construction when this callback runs, therefore all fields of the\n// resource referenced by \"asyncId\" may not have been populated.\nfunction init(asyncId, type, triggerAsyncId, resource) { }\n\n// Before is called just before the resource's callback is called. It can be\n// called 0-N times for handles (such as TCPWrap), and will be called exactly 1\n// time for requests (such as FSReqCallback).\nfunction before(asyncId) { }\n\n// After is called just after the resource's callback has finished.\nfunction after(asyncId) { }\n\n// Destroy is called when the resource is destroyed.\nfunction destroy(asyncId) { }\n\n// promiseResolve is called only for promise resources, when the\n// `resolve` function passed to the `Promise` constructor is invoked\n// (either directly or through other means of resolving a promise).\nfunction promiseResolve(asyncId) { }\n</code></pre>",
           "type": "module",
-          "displayName": "Public API"
+          "displayName": "Overview"
         },
         {
           "textRaw": "Promise execution tracking",
@@ -13103,7 +13658,7 @@
                   "name": "bind",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.8.0"
                     ],
                     "changes": []
                   },
@@ -13135,7 +13690,7 @@
                   "name": "bind",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.8.0"
                     ],
                     "changes": []
                   },
@@ -13280,7 +13835,7 @@
             {
               "textRaw": "Using `AsyncResource` for a `Worker` thread pool",
               "name": "using_`asyncresource`_for_a_`worker`_thread_pool",
-              "desc": "<p>The following example shows how to use the <code>AsyncResource</code> class to properly\nprovide async tracking for a <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> pool. Other resource pools, such as\ndatabase connection pools, can follow a similar model.</p>\n<p>Assuming that the task is adding two numbers, using a file named\n<code>task_processor.js</code> with the following content:</p>\n<pre><code class=\"language-js\">const { parentPort } = require('worker_threads');\nparentPort.on('message', (task) => {\n  parentPort.postMessage(task.a + task.b);\n});\n</code></pre>\n<p>a Worker pool around it could use the following structure:</p>\n<pre><code class=\"language-js\">const { AsyncResource } = require('async_hooks');\nconst { EventEmitter } = require('events');\nconst path = require('path');\nconst { Worker } = require('worker_threads');\n\nconst kTaskInfo = Symbol('kTaskInfo');\nconst kWorkerFreedEvent = Symbol('kWorkerFreedEvent');\n\nclass WorkerPoolTaskInfo extends AsyncResource {\n  constructor(callback) {\n    super('WorkerPoolTaskInfo');\n    this.callback = callback;\n  }\n\n  done(err, result) {\n    this.runInAsyncScope(this.callback, null, err, result);\n    this.emitDestroy();  // `TaskInfo`s are used only once.\n  }\n}\n\nclass WorkerPool extends EventEmitter {\n  constructor(numThreads) {\n    super();\n    this.numThreads = numThreads;\n    this.workers = [];\n    this.freeWorkers = [];\n\n    for (let i = 0; i &#x3C; numThreads; i++)\n      this.addNewWorker();\n  }\n\n  addNewWorker() {\n    const worker = new Worker(path.resolve(__dirname, 'task_processor.js'));\n    worker.on('message', (result) => {\n      // In case of success: Call the callback that was passed to `runTask`,\n      // remove the `TaskInfo` associated with the Worker, and mark it as free\n      // again.\n      worker[kTaskInfo].done(null, result);\n      worker[kTaskInfo] = null;\n      this.freeWorkers.push(worker);\n      this.emit(kWorkerFreedEvent);\n    });\n    worker.on('error', (err) => {\n      // In case of an uncaught exception: Call the callback that was passed to\n      // `runTask` with the error.\n      if (worker[kTaskInfo])\n        worker[kTaskInfo].done(err, null);\n      else\n        this.emit('error', err);\n      // Remove the worker from the list and start a new Worker to replace the\n      // current one.\n      this.workers.splice(this.workers.indexOf(worker), 1);\n      this.addNewWorker();\n    });\n    this.workers.push(worker);\n    this.freeWorkers.push(worker);\n    this.emit(kWorkerFreedEvent);\n  }\n\n  runTask(task, callback) {\n    if (this.freeWorkers.length === 0) {\n      // No free threads, wait until a worker thread becomes free.\n      this.once(kWorkerFreedEvent, () => this.runTask(task, callback));\n      return;\n    }\n\n    const worker = this.freeWorkers.pop();\n    worker[kTaskInfo] = new WorkerPoolTaskInfo(callback);\n    worker.postMessage(task);\n  }\n\n  close() {\n    for (const worker of this.workers) worker.terminate();\n  }\n}\n\nmodule.exports = WorkerPool;\n</code></pre>\n<p>Without the explicit tracking added by the <code>WorkerPoolTaskInfo</code> objects,\nit would appear that the callbacks are associated with the individual <code>Worker</code>\nobjects. However, the creation of the <code>Worker</code>s is not associated with the\ncreation of the tasks and does not provide information about when tasks\nwere scheduled.</p>\n<p>This pool could be used as follows:</p>\n<pre><code class=\"language-js\">const WorkerPool = require('./worker_pool.js');\nconst os = require('os');\n\nconst pool = new WorkerPool(os.cpus().length);\n\nlet finished = 0;\nfor (let i = 0; i &#x3C; 10; i++) {\n  pool.runTask({ a: 42, b: 100 }, (err, result) => {\n    console.log(i, err, result);\n    if (++finished === 10)\n      pool.close();\n  });\n}\n</code></pre>",
+              "desc": "<p>The following example shows how to use the <code>AsyncResource</code> class to properly\nprovide async tracking for a <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> pool. Other resource pools, such as\ndatabase connection pools, can follow a similar model.</p>\n<p>Assuming that the task is adding two numbers, using a file named\n<code>task_processor.js</code> with the following content:</p>\n<pre><code class=\"language-js\">const { parentPort } = require('worker_threads');\nparentPort.on('message', (task) => {\n  parentPort.postMessage(task.a + task.b);\n});\n</code></pre>\n<p>a Worker pool around it could use the following structure:</p>\n<pre><code class=\"language-js\">const { AsyncResource } = require('async_hooks');\nconst { EventEmitter } = require('events');\nconst path = require('path');\nconst { Worker } = require('worker_threads');\n\nconst kTaskInfo = Symbol('kTaskInfo');\nconst kWorkerFreedEvent = Symbol('kWorkerFreedEvent');\n\nclass WorkerPoolTaskInfo extends AsyncResource {\n  constructor(callback) {\n    super('WorkerPoolTaskInfo');\n    this.callback = callback;\n  }\n\n  done(err, result) {\n    this.runInAsyncScope(this.callback, null, err, result);\n    this.emitDestroy();  // `TaskInfo`s are used only once.\n  }\n}\n\nclass WorkerPool extends EventEmitter {\n  constructor(numThreads) {\n    super();\n    this.numThreads = numThreads;\n    this.workers = [];\n    this.freeWorkers = [];\n    this.tasks = [];\n\n    for (let i = 0; i &#x3C; numThreads; i++)\n      this.addNewWorker();\n\n    // Any time the kWorkerFreedEvent is emitted, dispatch\n    // the next task pending in the queue, if any.\n    this.on(kWorkerFreedEvent, () => {\n      if (this.tasks.length > 0) {\n        const { task, callback } = this.tasks.shift();\n        this.runTask(task, callback);\n      }\n    });\n  }\n\n  addNewWorker() {\n    const worker = new Worker(path.resolve(__dirname, 'task_processor.js'));\n    worker.on('message', (result) => {\n      // In case of success: Call the callback that was passed to `runTask`,\n      // remove the `TaskInfo` associated with the Worker, and mark it as free\n      // again.\n      worker[kTaskInfo].done(null, result);\n      worker[kTaskInfo] = null;\n      this.freeWorkers.push(worker);\n      this.emit(kWorkerFreedEvent);\n    });\n    worker.on('error', (err) => {\n      // In case of an uncaught exception: Call the callback that was passed to\n      // `runTask` with the error.\n      if (worker[kTaskInfo])\n        worker[kTaskInfo].done(err, null);\n      else\n        this.emit('error', err);\n      // Remove the worker from the list and start a new Worker to replace the\n      // current one.\n      this.workers.splice(this.workers.indexOf(worker), 1);\n      this.addNewWorker();\n    });\n    this.workers.push(worker);\n    this.freeWorkers.push(worker);\n    this.emit(kWorkerFreedEvent);\n  }\n\n  runTask(task, callback) {\n    if (this.freeWorkers.length === 0) {\n      // No free threads, wait until a worker thread becomes free.\n      this.tasks.push({ task, callback });\n      return;\n    }\n\n    const worker = this.freeWorkers.pop();\n    worker[kTaskInfo] = new WorkerPoolTaskInfo(callback);\n    worker.postMessage(task);\n  }\n\n  close() {\n    for (const worker of this.workers) worker.terminate();\n  }\n}\n\nmodule.exports = WorkerPool;\n</code></pre>\n<p>Without the explicit tracking added by the <code>WorkerPoolTaskInfo</code> objects,\nit would appear that the callbacks are associated with the individual <code>Worker</code>\nobjects. However, the creation of the <code>Worker</code>s is not associated with the\ncreation of the tasks and does not provide information about when tasks\nwere scheduled.</p>\n<p>This pool could be used as follows:</p>\n<pre><code class=\"language-js\">const WorkerPool = require('./worker_pool.js');\nconst os = require('os');\n\nconst pool = new WorkerPool(os.cpus().length);\n\nlet finished = 0;\nfor (let i = 0; i &#x3C; 10; i++) {\n  pool.runTask({ a: 42, b: 100 }, (err, result) => {\n    console.log(i, err, result);\n    if (++finished === 10)\n      pool.close();\n  });\n}\n</code></pre>",
               "type": "module",
               "displayName": "Using `AsyncResource` for a `Worker` thread pool"
             },
@@ -13296,18 +13851,360 @@
           "displayName": "JavaScript embedder API"
         }
       ],
+      "methods": [
+        {
+          "textRaw": "`async_hooks.createHook(callbacks)`",
+          "type": "method",
+          "name": "createHook",
+          "meta": {
+            "added": [
+              "v8.1.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {AsyncHook} Instance used for disabling and enabling hooks",
+                "name": "return",
+                "type": "AsyncHook",
+                "desc": "Instance used for disabling and enabling hooks"
+              },
+              "params": [
+                {
+                  "textRaw": "`callbacks` {Object} The [Hook Callbacks][] to register",
+                  "name": "callbacks",
+                  "type": "Object",
+                  "desc": "The [Hook Callbacks][] to register",
+                  "options": [
+                    {
+                      "textRaw": "`init` {Function} The [`init` callback][].",
+                      "name": "init",
+                      "type": "Function",
+                      "desc": "The [`init` callback][]."
+                    },
+                    {
+                      "textRaw": "`before` {Function} The [`before` callback][].",
+                      "name": "before",
+                      "type": "Function",
+                      "desc": "The [`before` callback][]."
+                    },
+                    {
+                      "textRaw": "`after` {Function} The [`after` callback][].",
+                      "name": "after",
+                      "type": "Function",
+                      "desc": "The [`after` callback][]."
+                    },
+                    {
+                      "textRaw": "`destroy` {Function} The [`destroy` callback][].",
+                      "name": "destroy",
+                      "type": "Function",
+                      "desc": "The [`destroy` callback][]."
+                    },
+                    {
+                      "textRaw": "`promiseResolve` {Function} The [`promiseResolve` callback][].",
+                      "name": "promiseResolve",
+                      "type": "Function",
+                      "desc": "The [`promiseResolve` callback][]."
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Registers functions to be called for different lifetime events of each async\noperation.</p>\n<p>The callbacks <code>init()</code>/<code>before()</code>/<code>after()</code>/<code>destroy()</code> are called for the\nrespective asynchronous event during a resource's lifetime.</p>\n<p>All callbacks are optional. For example, if only resource cleanup needs to\nbe tracked, then only the <code>destroy</code> callback needs to be passed. The\nspecifics of all functions that can be passed to <code>callbacks</code> is in the\n<a href=\"async_hooks.html#async_hooks_hook_callbacks\">Hook Callbacks</a> section.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconst asyncHook = async_hooks.createHook({\n  init(asyncId, type, triggerAsyncId, resource) { },\n  destroy(asyncId) { }\n});\n</code></pre>\n<p>The callbacks will be inherited via the prototype chain:</p>\n<pre><code class=\"language-js\">class MyAsyncCallbacks {\n  init(asyncId, type, triggerAsyncId, resource) { }\n  destroy(asyncId) {}\n}\n\nclass MyAddedCallbacks extends MyAsyncCallbacks {\n  before(asyncId) { }\n  after(asyncId) { }\n}\n\nconst asyncHook = async_hooks.createHook(new MyAddedCallbacks());\n</code></pre>\n<p>Because promises are asynchronous resources whose lifecycle is tracked\nvia the async hooks mechanism, the <code>init()</code>, <code>before()</code>, <code>after()</code>, and\n<code>destroy()</code> callbacks <em>must not</em> be async functions that return promises.</p>",
+          "modules": [
+            {
+              "textRaw": "Error handling",
+              "name": "error_handling",
+              "desc": "<p>If any <code>AsyncHook</code> callbacks throw, the application will print the stack trace\nand exit. The exit path does follow that of an uncaught exception, but\nall <code>'uncaughtException'</code> listeners are removed, thus forcing the process to\nexit. The <code>'exit'</code> callbacks will still be called unless the application is run\nwith <code>--abort-on-uncaught-exception</code>, in which case a stack trace will be\nprinted and the application exits, leaving a core file.</p>\n<p>The reason for this error handling behavior is that these callbacks are running\nat potentially volatile points in an object's lifetime, for example during\nclass construction and destruction. Because of this, it is deemed necessary to\nbring down the process quickly in order to prevent an unintentional abort in the\nfuture. This is subject to change in the future if a comprehensive analysis is\nperformed to ensure an exception can follow the normal control flow without\nunintentional side effects.</p>",
+              "type": "module",
+              "displayName": "Error handling"
+            },
+            {
+              "textRaw": "Printing in AsyncHooks callbacks",
+              "name": "printing_in_asynchooks_callbacks",
+              "desc": "<p>Because printing to the console is an asynchronous operation, <code>console.log()</code>\nwill cause the AsyncHooks callbacks to be called. Using <code>console.log()</code> or\nsimilar asynchronous operations inside an AsyncHooks callback function will thus\ncause an infinite recursion. An easy solution to this when debugging is to use a\nsynchronous logging operation such as <code>fs.writeFileSync(file, msg, flag)</code>.\nThis will print to the file and will not invoke AsyncHooks recursively because\nit is synchronous.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst util = require('util');\n\nfunction debug(...args) {\n  // Use a function like this one when debugging inside an AsyncHooks callback\n  fs.writeFileSync('log.out', `${util.format(...args)}\\n`, { flag: 'a' });\n}\n</code></pre>\n<p>If an asynchronous operation is needed for logging, it is possible to keep\ntrack of what caused the asynchronous operation using the information\nprovided by AsyncHooks itself. The logging should then be skipped when\nit was the logging itself that caused AsyncHooks callback to call. By\ndoing this the otherwise infinite recursion is broken.</p>",
+              "type": "module",
+              "displayName": "Printing in AsyncHooks callbacks"
+            }
+          ]
+        }
+      ],
       "classes": [
+        {
+          "textRaw": "Class: `AsyncHook`",
+          "type": "class",
+          "name": "AsyncHook",
+          "desc": "<p>The class <code>AsyncHook</code> exposes an interface for tracking lifetime events\nof asynchronous operations.</p>",
+          "methods": [
+            {
+              "textRaw": "`asyncHook.enable()`",
+              "type": "method",
+              "name": "enable",
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {AsyncHook} A reference to `asyncHook`.",
+                    "name": "return",
+                    "type": "AsyncHook",
+                    "desc": "A reference to `asyncHook`."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Enable the callbacks for a given <code>AsyncHook</code> instance. If no callbacks are\nprovided, enabling is a no-op.</p>\n<p>The <code>AsyncHook</code> instance is disabled by default. If the <code>AsyncHook</code> instance\nshould be enabled immediately after creation, the following pattern can be used.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconst hook = async_hooks.createHook(callbacks).enable();\n</code></pre>"
+            },
+            {
+              "textRaw": "`asyncHook.disable()`",
+              "type": "method",
+              "name": "disable",
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {AsyncHook} A reference to `asyncHook`.",
+                    "name": "return",
+                    "type": "AsyncHook",
+                    "desc": "A reference to `asyncHook`."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Disable the callbacks for a given <code>AsyncHook</code> instance from the global pool of\n<code>AsyncHook</code> callbacks to be executed. Once a hook has been disabled it will not\nbe called again until enabled.</p>\n<p>For API consistency <code>disable()</code> also returns the <code>AsyncHook</code> instance.</p>"
+            },
+            {
+              "textRaw": "`async_hooks.executionAsyncResource()`",
+              "type": "method",
+              "name": "executionAsyncResource",
+              "meta": {
+                "added": [
+                  "v13.9.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Object} The resource representing the current execution. Useful to store data within the resource.",
+                    "name": "return",
+                    "type": "Object",
+                    "desc": "The resource representing the current execution. Useful to store data within the resource."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Resource objects returned by <code>executionAsyncResource()</code> are most often internal\nNode.js handle objects with undocumented APIs. Using any functions or properties\non the object is likely to crash your application and should be avoided.</p>\n<p>Using <code>executionAsyncResource()</code> in the top-level execution context will\nreturn an empty object as there is no handle or request object to use,\nbut having an object representing the top-level can be helpful.</p>\n<pre><code class=\"language-js\">const { open } = require('fs');\nconst { executionAsyncId, executionAsyncResource } = require('async_hooks');\n\nconsole.log(executionAsyncId(), executionAsyncResource());  // 1 {}\nopen(__filename, 'r', (err, fd) => {\n  console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap\n});\n</code></pre>\n<p>This can be used to implement continuation local storage without the\nuse of a tracking <code>Map</code> to store the metadata:</p>\n<pre><code class=\"language-js\">const { createServer } = require('http');\nconst {\n  executionAsyncId,\n  executionAsyncResource,\n  createHook\n} = require('async_hooks');\nconst sym = Symbol('state'); // Private symbol to avoid pollution\n\ncreateHook({\n  init(asyncId, type, triggerAsyncId, resource) {\n    const cr = executionAsyncResource();\n    if (cr) {\n      resource[sym] = cr[sym];\n    }\n  }\n}).enable();\n\nconst server = createServer((req, res) => {\n  executionAsyncResource()[sym] = { state: req.url };\n  setTimeout(function() {\n    res.end(JSON.stringify(executionAsyncResource()[sym]));\n  }, 100);\n}).listen(3000);\n</code></pre>"
+            },
+            {
+              "textRaw": "`async_hooks.executionAsyncId()`",
+              "type": "method",
+              "name": "executionAsyncId",
+              "meta": {
+                "added": [
+                  "v8.1.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v8.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/13490",
+                    "description": "Renamed from `currentId`."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {number} The `asyncId` of the current execution context. Useful to track when something calls.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The `asyncId` of the current execution context. Useful to track when something calls."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconsole.log(async_hooks.executionAsyncId());  // 1 - bootstrap\nfs.open(path, 'r', (err, fd) => {\n  console.log(async_hooks.executionAsyncId());  // 6 - open()\n});\n</code></pre>\n<p>The ID returned from <code>executionAsyncId()</code> is related to execution timing, not\ncausality (which is covered by <code>triggerAsyncId()</code>):</p>\n<pre><code class=\"language-js\">const server = net.createServer((conn) => {\n  // Returns the ID of the server, not of the new connection, because the\n  // callback runs in the execution scope of the server's MakeCallback().\n  async_hooks.executionAsyncId();\n\n}).listen(port, () => {\n  // Returns the ID of a TickObject (process.nextTick()) because all\n  // callbacks passed to .listen() are wrapped in a nextTick().\n  async_hooks.executionAsyncId();\n});\n</code></pre>\n<p>Promise contexts may not get precise <code>executionAsyncIds</code> by default.\nSee the section on <a href=\"async_hooks.html#async_hooks_promise_execution_tracking\">promise execution tracking</a>.</p>"
+            },
+            {
+              "textRaw": "`async_hooks.triggerAsyncId()`",
+              "type": "method",
+              "name": "triggerAsyncId",
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {number} The ID of the resource responsible for calling the callback that is currently being executed.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The ID of the resource responsible for calling the callback that is currently being executed."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<pre><code class=\"language-js\">const server = net.createServer((conn) => {\n  // The resource that caused (or triggered) this callback to be called\n  // was that of the new connection. Thus the return value of triggerAsyncId()\n  // is the asyncId of \"conn\".\n  async_hooks.triggerAsyncId();\n\n}).listen(port, () => {\n  // Even though all callbacks passed to .listen() are wrapped in a nextTick()\n  // the callback itself exists because the call to the server's .listen()\n  // was made. So the return value would be the ID of the server.\n  async_hooks.triggerAsyncId();\n});\n</code></pre>\n<p>Promise contexts may not get valid <code>triggerAsyncId</code>s by default. See\nthe section on <a href=\"async_hooks.html#async_hooks_promise_execution_tracking\">promise execution tracking</a>.</p>"
+            }
+          ],
+          "modules": [
+            {
+              "textRaw": "Hook callbacks",
+              "name": "hook_callbacks",
+              "desc": "<p>Key events in the lifetime of asynchronous events have been categorized into\nfour areas: instantiation, before/after the callback is called, and when the\ninstance is destroyed.</p>",
+              "methods": [
+                {
+                  "textRaw": "`init(asyncId, type, triggerAsyncId, resource)`",
+                  "type": "method",
+                  "name": "init",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number} A unique ID for the async resource.",
+                          "name": "asyncId",
+                          "type": "number",
+                          "desc": "A unique ID for the async resource."
+                        },
+                        {
+                          "textRaw": "`type` {string} The type of the async resource.",
+                          "name": "type",
+                          "type": "string",
+                          "desc": "The type of the async resource."
+                        },
+                        {
+                          "textRaw": "`triggerAsyncId` {number} The unique ID of the async resource in whose execution context this async resource was created.",
+                          "name": "triggerAsyncId",
+                          "type": "number",
+                          "desc": "The unique ID of the async resource in whose execution context this async resource was created."
+                        },
+                        {
+                          "textRaw": "`resource` {Object} Reference to the resource representing the async operation, needs to be released during _destroy_.",
+                          "name": "resource",
+                          "type": "Object",
+                          "desc": "Reference to the resource representing the async operation, needs to be released during _destroy_."
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Called when a class is constructed that has the <em>possibility</em> to emit an\nasynchronous event. This <em>does not</em> mean the instance must call\n<code>before</code>/<code>after</code> before <code>destroy</code> is called, only that the possibility\nexists.</p>\n<p>This behavior can be observed by doing something like opening a resource then\nclosing it before the resource can be used. The following snippet demonstrates\nthis.</p>\n<pre><code class=\"language-js\">require('net').createServer().listen(function() { this.close(); });\n// OR\nclearTimeout(setTimeout(() => {}, 10));\n</code></pre>\n<p>Every new resource is assigned an ID that is unique within the scope of the\ncurrent Node.js instance.</p>",
+                  "modules": [
+                    {
+                      "textRaw": "`type`",
+                      "name": "`type`",
+                      "desc": "<p>The <code>type</code> is a string identifying the type of resource that caused\n<code>init</code> to be called. Generally, it will correspond to the name of the\nresource's constructor.</p>\n<pre><code class=\"language-text\">FSEVENTWRAP, FSREQCALLBACK, GETADDRINFOREQWRAP, GETNAMEINFOREQWRAP, HTTPINCOMINGMESSAGE,\nHTTPCLIENTREQUEST, JSSTREAM, PIPECONNECTWRAP, PIPEWRAP, PROCESSWRAP, QUERYWRAP,\nSHUTDOWNWRAP, SIGNALWRAP, STATWATCHER, TCPCONNECTWRAP, TCPSERVERWRAP, TCPWRAP,\nTTYWRAP, UDPSENDWRAP, UDPWRAP, WRITEWRAP, ZLIB, SSLCONNECTION, PBKDF2REQUEST,\nRANDOMBYTESREQUEST, TLSWRAP, Microtask, Timeout, Immediate, TickObject\n</code></pre>\n<p>There is also the <code>PROMISE</code> resource type, which is used to track <code>Promise</code>\ninstances and asynchronous work scheduled by them.</p>\n<p>Users are able to define their own <code>type</code> when using the public embedder API.</p>\n<p>It is possible to have type name collisions. Embedders are encouraged to use\nunique prefixes, such as the npm package name, to prevent collisions when\nlistening to the hooks.</p>",
+                      "type": "module",
+                      "displayName": "`type`"
+                    },
+                    {
+                      "textRaw": "`triggerAsyncId`",
+                      "name": "`triggerasyncid`",
+                      "desc": "<p><code>triggerAsyncId</code> is the <code>asyncId</code> of the resource that caused (or \"triggered\")\nthe new resource to initialize and that caused <code>init</code> to call. This is different\nfrom <code>async_hooks.executionAsyncId()</code> that only shows <em>when</em> a resource was\ncreated, while <code>triggerAsyncId</code> shows <em>why</em> a resource was created.</p>\n<p>The following is a simple demonstration of <code>triggerAsyncId</code>:</p>\n<pre><code class=\"language-js\">const { fd } = process.stdout;\n\nasync_hooks.createHook({\n  init(asyncId, type, triggerAsyncId) {\n    const eid = async_hooks.executionAsyncId();\n    fs.writeSync(\n      fd,\n      `${type}(${asyncId}): trigger: ${triggerAsyncId} execution: ${eid}\\n`);\n  }\n}).enable();\n\nnet.createServer((conn) => {}).listen(8080);\n</code></pre>\n<p>Output when hitting the server with <code>nc localhost 8080</code>:</p>\n<pre><code class=\"language-console\">TCPSERVERWRAP(5): trigger: 1 execution: 1\nTCPWRAP(7): trigger: 5 execution: 0\n</code></pre>\n<p>The <code>TCPSERVERWRAP</code> is the server which receives the connections.</p>\n<p>The <code>TCPWRAP</code> is the new connection from the client. When a new\nconnection is made, the <code>TCPWrap</code> instance is immediately constructed. This\nhappens outside of any JavaScript stack. (An <code>executionAsyncId()</code> of <code>0</code> means\nthat it is being executed from C++ with no JavaScript stack above it.) With only\nthat information, it would be impossible to link resources together in\nterms of what caused them to be created, so <code>triggerAsyncId</code> is given the task\nof propagating what resource is responsible for the new resource's existence.</p>",
+                      "type": "module",
+                      "displayName": "`triggerAsyncId`"
+                    },
+                    {
+                      "textRaw": "`resource`",
+                      "name": "`resource`",
+                      "desc": "<p><code>resource</code> is an object that represents the actual async resource that has\nbeen initialized. This can contain useful information that can vary based on\nthe value of <code>type</code>. For instance, for the <code>GETADDRINFOREQWRAP</code> resource type,\n<code>resource</code> provides the host name used when looking up the IP address for the\nhost in <code>net.Server.listen()</code>. The API for accessing this information is\nnot supported, but using the Embedder API, users can provide\nand document their own resource objects. For example, such a resource object\ncould contain the SQL query being executed.</p>\n<p>In some cases the resource object is reused for performance reasons, it is\nthus not safe to use it as a key in a <code>WeakMap</code> or add properties to it.</p>",
+                      "type": "module",
+                      "displayName": "`resource`"
+                    },
+                    {
+                      "textRaw": "Asynchronous context example",
+                      "name": "asynchronous_context_example",
+                      "desc": "<p>The following is an example with additional information about the calls to\n<code>init</code> between the <code>before</code> and <code>after</code> calls, specifically what the\ncallback to <code>listen()</code> will look like. The output formatting is slightly more\nelaborate to make calling context easier to see.</p>\n<pre><code class=\"language-js\">const { fd } = process.stdout;\n\nlet indent = 0;\nasync_hooks.createHook({\n  init(asyncId, type, triggerAsyncId) {\n    const eid = async_hooks.executionAsyncId();\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(\n      fd,\n      `${indentStr}${type}(${asyncId}):` +\n      ` trigger: ${triggerAsyncId} execution: ${eid}\\n`);\n  },\n  before(asyncId) {\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(fd, `${indentStr}before:  ${asyncId}\\n`);\n    indent += 2;\n  },\n  after(asyncId) {\n    indent -= 2;\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(fd, `${indentStr}after:  ${asyncId}\\n`);\n  },\n  destroy(asyncId) {\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(fd, `${indentStr}destroy:  ${asyncId}\\n`);\n  },\n}).enable();\n\nnet.createServer(() => {}).listen(8080, () => {\n  // Let's wait 10ms before logging the server started.\n  setTimeout(() => {\n    console.log('>>>', async_hooks.executionAsyncId());\n  }, 10);\n});\n</code></pre>\n<p>Output from only starting the server:</p>\n<pre><code class=\"language-console\">TCPSERVERWRAP(5): trigger: 1 execution: 1\nTickObject(6): trigger: 5 execution: 1\nbefore:  6\n  Timeout(7): trigger: 6 execution: 6\nafter:   6\ndestroy: 6\nbefore:  7\n>>> 7\n  TickObject(8): trigger: 7 execution: 7\nafter:   7\nbefore:  8\nafter:   8\n</code></pre>\n<p>As illustrated in the example, <code>executionAsyncId()</code> and <code>execution</code> each specify\nthe value of the current execution context; which is delineated by calls to\n<code>before</code> and <code>after</code>.</p>\n<p>Only using <code>execution</code> to graph resource allocation results in the following:</p>\n<pre><code class=\"language-console\">  root(1)\n     ^\n     |\nTickObject(6)\n     ^\n     |\n Timeout(7)\n</code></pre>\n<p>The <code>TCPSERVERWRAP</code> is not part of this graph, even though it was the reason for\n<code>console.log()</code> being called. This is because binding to a port without a host\nname is a <em>synchronous</em> operation, but to maintain a completely asynchronous\nAPI the user's callback is placed in a <code>process.nextTick()</code>. Which is why\n<code>TickObject</code> is present in the output and is a 'parent' for <code>.listen()</code>\ncallback.</p>\n<p>The graph only shows <em>when</em> a resource was created, not <em>why</em>, so to track\nthe <em>why</em> use <code>triggerAsyncId</code>. Which can be represented with the following\ngraph:</p>\n<pre><code class=\"language-console\"> bootstrap(1)\n     |\n     ˅\nTCPSERVERWRAP(5)\n     |\n     ˅\n TickObject(6)\n     |\n     ˅\n  Timeout(7)\n</code></pre>",
+                      "type": "module",
+                      "displayName": "Asynchronous context example"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`before(asyncId)`",
+                  "type": "method",
+                  "name": "before",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number}",
+                          "name": "asyncId",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>When an asynchronous operation is initiated (such as a TCP server receiving a\nnew connection) or completes (such as writing data to disk) a callback is\ncalled to notify the user. The <code>before</code> callback is called just before said\ncallback is executed. <code>asyncId</code> is the unique identifier assigned to the\nresource about to execute the callback.</p>\n<p>The <code>before</code> callback will be called 0 to N times. The <code>before</code> callback\nwill typically be called 0 times if the asynchronous operation was cancelled\nor, for example, if no connections are received by a TCP server. Persistent\nasynchronous resources like a TCP server will typically call the <code>before</code>\ncallback multiple times, while other operations like <code>fs.open()</code> will call\nit only once.</p>"
+                },
+                {
+                  "textRaw": "`after(asyncId)`",
+                  "type": "method",
+                  "name": "after",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number}",
+                          "name": "asyncId",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Called immediately after the callback specified in <code>before</code> is completed.</p>\n<p>If an uncaught exception occurs during execution of the callback, then <code>after</code>\nwill run <em>after</em> the <code>'uncaughtException'</code> event is emitted or a <code>domain</code>'s\nhandler runs.</p>"
+                },
+                {
+                  "textRaw": "`destroy(asyncId)`",
+                  "type": "method",
+                  "name": "destroy",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number}",
+                          "name": "asyncId",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Called after the resource corresponding to <code>asyncId</code> is destroyed. It is also\ncalled asynchronously from the embedder API <code>emitDestroy()</code>.</p>\n<p>Some resources depend on garbage collection for cleanup, so if a reference is\nmade to the <code>resource</code> object passed to <code>init</code> it is possible that <code>destroy</code>\nwill never be called, causing a memory leak in the application. If the resource\ndoes not depend on garbage collection, then this will not be an issue.</p>"
+                },
+                {
+                  "textRaw": "`promiseResolve(asyncId)`",
+                  "type": "method",
+                  "name": "promiseResolve",
+                  "meta": {
+                    "added": [
+                      "v8.6.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number}",
+                          "name": "asyncId",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Called when the <code>resolve</code> function passed to the <code>Promise</code> constructor is\ninvoked (either directly or through other means of resolving a promise).</p>\n<p><code>resolve()</code> does not do any observable synchronous work.</p>\n<p>The <code>Promise</code> is not necessarily fulfilled or rejected at this point if the\n<code>Promise</code> was resolved by assuming the state of another <code>Promise</code>.</p>\n<pre><code class=\"language-js\">new Promise((resolve) => resolve(true)).then((a) => {});\n</code></pre>\n<p>calls the following callbacks:</p>\n<pre><code class=\"language-text\">init for PROMISE with id 5, trigger id: 1\n  promise resolve 5      # corresponds to resolve(true)\ninit for PROMISE with id 6, trigger id: 5  # the Promise returned by then()\n  before 6               # the then() callback is entered\n  promise resolve 6      # the then() callback resolves the promise by returning\n  after 6\n</code></pre>"
+                }
+              ],
+              "type": "module",
+              "displayName": "Hook callbacks"
+            }
+          ]
+        },
         {
           "textRaw": "Class: `AsyncLocalStorage`",
           "type": "class",
           "name": "AsyncLocalStorage",
           "meta": {
             "added": [
-              "v12.17.0"
+              "v13.10.0"
             ],
             "changes": []
           },
-          "desc": "<p>This class is used to create asynchronous state within callbacks and promise\nchains. It allows storing data throughout the lifetime of a web request\nor any other asynchronous duration. It is similar to thread-local storage\nin other languages.</p>\n<p>The following example uses <code>AsyncLocalStorage</code> to build a simple logger\nthat assigns IDs to incoming HTTP requests and includes them in messages\nlogged within each request.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst { AsyncLocalStorage } = require('async_hooks');\n\nconst asyncLocalStorage = new AsyncLocalStorage();\n\nfunction logWithId(msg) {\n  const id = asyncLocalStorage.getStore();\n  console.log(`${id !== undefined ? id : '-'}:`, msg);\n}\n\nlet idSeq = 0;\nhttp.createServer((req, res) => {\n  asyncLocalStorage.run(idSeq++, () => {\n    logWithId('start');\n    // Imagine any chain of async operations here\n    setImmediate(() => {\n      logWithId('finish');\n      res.end();\n    });\n  });\n}).listen(8080);\n\nhttp.get('http://localhost:8080');\nhttp.get('http://localhost:8080');\n// Prints:\n//   0: start\n//   1: start\n//   0: finish\n//   1: finish\n</code></pre>\n<p>When having multiple instances of <code>AsyncLocalStorage</code>, they are independent\nfrom each other. It is safe to instantiate this class multiple times.</p>",
+          "desc": "<p>This class is used to create asynchronous state within callbacks and promise\nchains. It allows storing data throughout the lifetime of a web request\nor any other asynchronous duration. It is similar to thread-local storage\nin other languages.</p>\n<p>While you can create your own implementation on top of the <code>async_hooks</code> module,\n<code>AsyncLocalStorage</code> should be preferred as it is a performant and memory safe\nimplementation that involves significant optimizations that are non-obvious to\nimplement.</p>\n<p>The following example uses <code>AsyncLocalStorage</code> to build a simple logger\nthat assigns IDs to incoming HTTP requests and includes them in messages\nlogged within each request.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst { AsyncLocalStorage } = require('async_hooks');\n\nconst asyncLocalStorage = new AsyncLocalStorage();\n\nfunction logWithId(msg) {\n  const id = asyncLocalStorage.getStore();\n  console.log(`${id !== undefined ? id : '-'}:`, msg);\n}\n\nlet idSeq = 0;\nhttp.createServer((req, res) => {\n  asyncLocalStorage.run(idSeq++, () => {\n    logWithId('start');\n    // Imagine any chain of async operations here\n    setImmediate(() => {\n      logWithId('finish');\n      res.end();\n    });\n  });\n}).listen(8080);\n\nhttp.get('http://localhost:8080');\nhttp.get('http://localhost:8080');\n// Prints:\n//   0: start\n//   1: start\n//   0: finish\n//   1: finish\n</code></pre>\n<p>When having multiple instances of <code>AsyncLocalStorage</code>, they are independent\nfrom each other. It is safe to instantiate this class multiple times.</p>",
           "methods": [
             {
               "textRaw": "`asyncLocalStorage.disable()`",
@@ -13315,7 +14212,7 @@
               "name": "disable",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -13324,7 +14221,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>This method disables the instance of <code>AsyncLocalStorage</code>. All subsequent calls\nto <code>asyncLocalStorage.getStore()</code> will return <code>undefined</code> until\n<code>asyncLocalStorage.run()</code> is called again.</p>\n<p>When calling <code>asyncLocalStorage.disable()</code>, all current contexts linked to the\ninstance will be exited.</p>\n<p>Calling <code>asyncLocalStorage.disable()</code> is required before the\n<code>asyncLocalStorage</code> can be garbage collected. This does not apply to stores\nprovided by the <code>asyncLocalStorage</code>, as those objects are garbage collected\nalong with the corresponding async resources.</p>\n<p>This method is to be used when the <code>asyncLocalStorage</code> is not in use anymore\nin the current process.</p>"
+              "desc": "<p>Disables the instance of <code>AsyncLocalStorage</code>. All subsequent calls\nto <code>asyncLocalStorage.getStore()</code> will return <code>undefined</code> until\n<code>asyncLocalStorage.run()</code> or <code>asyncLocalStorage.enterWith()</code> is called again.</p>\n<p>When calling <code>asyncLocalStorage.disable()</code>, all current contexts linked to the\ninstance will be exited.</p>\n<p>Calling <code>asyncLocalStorage.disable()</code> is required before the\n<code>asyncLocalStorage</code> can be garbage collected. This does not apply to stores\nprovided by the <code>asyncLocalStorage</code>, as those objects are garbage collected\nalong with the corresponding async resources.</p>\n<p>Use this method when the <code>asyncLocalStorage</code> is not in use anymore\nin the current process.</p>"
             },
             {
               "textRaw": "`asyncLocalStorage.getStore()`",
@@ -13332,7 +14229,7 @@
               "name": "getStore",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -13346,7 +14243,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>This method returns the current store.\nIf this method is called outside of an asynchronous context initialized by\ncalling <code>asyncLocalStorage.run</code>, it will return <code>undefined</code>.</p>"
+              "desc": "<p>Returns the current store.\nIf called outside of an asynchronous context initialized by\ncalling <code>asyncLocalStorage.run()</code> or <code>asyncLocalStorage.enterWith()</code>, it\nreturns <code>undefined</code>.</p>"
             },
             {
               "textRaw": "`asyncLocalStorage.enterWith(store)`",
@@ -13354,7 +14251,7 @@
               "name": "enterWith",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.11.0"
                 ],
                 "changes": []
               },
@@ -13369,7 +14266,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Calling <code>asyncLocalStorage.enterWith(store)</code> will transition into the context\nfor the remainder of the current synchronous execution and will persist\nthrough any following asynchronous calls.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const store = { id: 1 };\nasyncLocalStorage.enterWith(store);\nasyncLocalStorage.getStore(); // Returns the store object\nsomeAsyncOperation(() => {\n  asyncLocalStorage.getStore(); // Returns the same object\n});\n</code></pre>\n<p>This transition will continue for the <em>entire</em> synchronous execution.\nThis means that if, for example, the context is entered within an event\nhandler subsequent event handlers will also run within that context unless\nspecifically bound to another context with an <code>AsyncResource</code>.</p>\n<pre><code class=\"language-js\">const store = { id: 1 };\n\nemitter.on('my-event', () => {\n  asyncLocalStorage.enterWith(store);\n});\nemitter.on('my-event', () => {\n  asyncLocalStorage.getStore(); // Returns the same object\n});\n\nasyncLocalStorage.getStore(); // Returns undefined\nemitter.emit('my-event');\nasyncLocalStorage.getStore(); // Returns the same object\n</code></pre>"
+              "desc": "<p>Transitions into the context for the remainder of the current\nsynchronous execution and then persists the store through any following\nasynchronous calls.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const store = { id: 1 };\n// Replaces previous store with the given store object\nasyncLocalStorage.enterWith(store);\nasyncLocalStorage.getStore(); // Returns the store object\nsomeAsyncOperation(() => {\n  asyncLocalStorage.getStore(); // Returns the same object\n});\n</code></pre>\n<p>This transition will continue for the <em>entire</em> synchronous execution.\nThis means that if, for example, the context is entered within an event\nhandler subsequent event handlers will also run within that context unless\nspecifically bound to another context with an <code>AsyncResource</code>. That is why\n<code>run()</code> should be preferred over <code>enterWith()</code> unless there are strong reasons\nto use the latter method.</p>\n<pre><code class=\"language-js\">const store = { id: 1 };\n\nemitter.on('my-event', () => {\n  asyncLocalStorage.enterWith(store);\n});\nemitter.on('my-event', () => {\n  asyncLocalStorage.getStore(); // Returns the same object\n});\n\nasyncLocalStorage.getStore(); // Returns undefined\nemitter.emit('my-event');\nasyncLocalStorage.getStore(); // Returns the same object\n</code></pre>"
             },
             {
               "textRaw": "`asyncLocalStorage.run(store, callback[, ...args])`",
@@ -13377,7 +14274,7 @@
               "name": "run",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -13402,7 +14299,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This methods runs a function synchronously within a context and return its\nreturn value. The store is not accessible outside of the callback function or\nthe asynchronous operations created within the callback.</p>\n<p>Optionally, arguments can be passed to the function. They will be passed to\nthe callback function.</p>\n<p>If the callback function throws an error, it will be thrown by <code>run</code> too.\nThe stacktrace will not be impacted by this call and the context will\nbe exited.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const store = { id: 2 };\ntry {\n  asyncLocalStorage.run(store, () => {\n    asyncLocalStorage.getStore(); // Returns the store object\n    throw new Error();\n  });\n} catch (e) {\n  asyncLocalStorage.getStore(); // Returns undefined\n  // The error will be caught here\n}\n</code></pre>"
+              "desc": "<p>Runs a function synchronously within a context and returns its\nreturn value. The store is not accessible outside of the callback function.\nThe store is accessible to any asynchronous operations created within the\ncallback.</p>\n<p>The optional <code>args</code> are passed to the callback function.</p>\n<p>If the callback function throws an error, the error is thrown by <code>run()</code> too.\nThe stacktrace is not impacted by this call and the context is exited.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const store = { id: 2 };\ntry {\n  asyncLocalStorage.run(store, () => {\n    asyncLocalStorage.getStore(); // Returns the store object\n    setTimeout(() => {\n      asyncLocalStorage.getStore(); // Returns the store object\n    }, 200);\n    throw new Error();\n  });\n} catch (e) {\n  asyncLocalStorage.getStore(); // Returns undefined\n  // The error will be caught here\n}\n</code></pre>"
             },
             {
               "textRaw": "`asyncLocalStorage.exit(callback[, ...args])`",
@@ -13410,7 +14307,7 @@
               "name": "exit",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -13430,7 +14327,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This methods runs a function synchronously outside of a context and return its\nreturn value. The store is not accessible within the callback function or\nthe asynchronous operations created within the callback.</p>\n<p>Optionally, arguments can be passed to the function. They will be passed to\nthe callback function.</p>\n<p>If the callback function throws an error, it will be thrown by <code>exit</code> too.\nThe stacktrace will not be impacted by this call and\nthe context will be re-entered.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">// Within a call to run\ntry {\n  asyncLocalStorage.getStore(); // Returns the store object or value\n  asyncLocalStorage.exit(() => {\n    asyncLocalStorage.getStore(); // Returns undefined\n    throw new Error();\n  });\n} catch (e) {\n  asyncLocalStorage.getStore(); // Returns the same object or value\n  // The error will be caught here\n}\n</code></pre>"
+              "desc": "<p>Runs a function synchronously outside of a context and returns its\nreturn value. The store is not accessible within the callback function or\nthe asynchronous operations created within the callback. Any <code>getStore()</code>\ncall done within the callback function will always return <code>undefined</code>.</p>\n<p>The optional <code>args</code> are passed to the callback function.</p>\n<p>If the callback function throws an error, the error is thrown by <code>exit()</code> too.\nThe stacktrace is not impacted by this call and the context is re-entered.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">// Within a call to run\ntry {\n  asyncLocalStorage.getStore(); // Returns the store object or value\n  asyncLocalStorage.exit(() => {\n    asyncLocalStorage.getStore(); // Returns undefined\n    throw new Error();\n  });\n} catch (e) {\n  asyncLocalStorage.getStore(); // Returns the same object or value\n  // The error will be caught here\n}\n</code></pre>"
             }
           ],
           "modules": [
@@ -13452,13 +14349,14 @@
           "signatures": [
             {
               "params": [],
-              "desc": "<p>Creates a new instance of <code>AsyncLocalStorage</code>. Store is only provided within a\n<code>run</code> method call.</p>"
+              "desc": "<p>Creates a new instance of <code>AsyncLocalStorage</code>. Store is only provided within a\n<code>run()</code> call or after an <code>enterWith()</code> call.</p>"
             }
           ]
         }
       ],
       "type": "module",
-      "displayName": "Async hooks"
+      "displayName": "Async hooks",
+      "source": "doc/api/async_hooks.md"
     },
     {
       "textRaw": "Buffer",
@@ -13466,13 +14364,18 @@
       "introduced_in": "v0.1.90",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/buffer.js\">lib/buffer.js</a></p>\n<p><code>Buffer</code> objects are used to represent a fixed-length sequence of bytes. Many\nNode.js APIs support <code>Buffer</code>s.</p>\n<p>The <code>Buffer</code> class is a subclass of JavaScript's <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a> class and\nextends it with methods that cover additional use cases. Node.js APIs accept\nplain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>s wherever <code>Buffer</code>s are supported as well.</p>\n<p>The <code>Buffer</code> class is within the global scope, making it unlikely that one\nwould need to ever use <code>require('buffer').Buffer</code>.</p>\n<pre><code class=\"language-js\">// Creates a zero-filled Buffer of length 10.\nconst buf1 = Buffer.alloc(10);\n\n// Creates a Buffer of length 10,\n// filled with bytes which all have the value `1`.\nconst buf2 = Buffer.alloc(10, 1);\n\n// Creates an uninitialized buffer of length 10.\n// This is faster than calling Buffer.alloc() but the returned\n// Buffer instance might contain old data that needs to be\n// overwritten using fill(), write(), or other functions that fill the Buffer's\n// contents.\nconst buf3 = Buffer.allocUnsafe(10);\n\n// Creates a Buffer containing the bytes [1, 2, 3].\nconst buf4 = Buffer.from([1, 2, 3]);\n\n// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries\n// are all truncated using `(value &#x26; 255)` to fit into the range 0–255.\nconst buf5 = Buffer.from([257, 257.5, -255, '1']);\n\n// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':\n// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)\n// [116, 195, 169, 115, 116] (in decimal notation)\nconst buf6 = Buffer.from('tést');\n\n// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].\nconst buf7 = Buffer.from('tést', 'latin1');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/buffer.js\">lib/buffer.js</a></p>\n<p><code>Buffer</code> objects are used to represent a fixed-length sequence of bytes. Many\nNode.js APIs support <code>Buffer</code>s.</p>\n<p>The <code>Buffer</code> class is a subclass of JavaScript's <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a> class and\nextends it with methods that cover additional use cases. Node.js APIs accept\nplain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>s wherever <code>Buffer</code>s are supported as well.</p>\n<p>The <code>Buffer</code> class is within the global scope, making it unlikely that one\nwould need to ever use <code>require('buffer').Buffer</code>.</p>\n<pre><code class=\"language-js\">// Creates a zero-filled Buffer of length 10.\nconst buf1 = Buffer.alloc(10);\n\n// Creates a Buffer of length 10,\n// filled with bytes which all have the value `1`.\nconst buf2 = Buffer.alloc(10, 1);\n\n// Creates an uninitialized buffer of length 10.\n// This is faster than calling Buffer.alloc() but the returned\n// Buffer instance might contain old data that needs to be\n// overwritten using fill(), write(), or other functions that fill the Buffer's\n// contents.\nconst buf3 = Buffer.allocUnsafe(10);\n\n// Creates a Buffer containing the bytes [1, 2, 3].\nconst buf4 = Buffer.from([1, 2, 3]);\n\n// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries\n// are all truncated using `(value &#x26; 255)` to fit into the range 0–255.\nconst buf5 = Buffer.from([257, 257.5, -255, '1']);\n\n// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':\n// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)\n// [116, 195, 169, 115, 116] (in decimal notation)\nconst buf6 = Buffer.from('tést');\n\n// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].\nconst buf7 = Buffer.from('tést', 'latin1');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Buffers and character encodings",
           "name": "buffers_and_character_encodings",
           "meta": {
             "changes": [
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/36952",
+                "description": "Introduced `base64url` encoding."
+              },
               {
                 "version": "v6.4.0",
                 "pr-url": "https://github.com/nodejs/node/pull/7111",
@@ -13485,7 +14388,7 @@
               }
             ]
           },
-          "desc": "<p>When converting between <code>Buffer</code>s and strings, a character encoding may be\nspecified. If no character encoding is specified, UTF-8 will be used as the\ndefault.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('hello world', 'utf8');\n\nconsole.log(buf.toString('hex'));\n// Prints: 68656c6c6f20776f726c64\nconsole.log(buf.toString('base64'));\n// Prints: aGVsbG8gd29ybGQ=\n\nconsole.log(Buffer.from('fhqwhgads', 'utf8'));\n// Prints: &#x3C;Buffer 66 68 71 77 68 67 61 64 73>\nconsole.log(Buffer.from('fhqwhgads', 'utf16le'));\n// Prints: &#x3C;Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>\n</code></pre>\n<p>The character encodings currently supported by Node.js are the following:</p>\n<ul>\n<li>\n<p><code>'utf8'</code>: Multi-byte encoded Unicode characters. Many web pages and other\ndocument formats use <a href=\"https://en.wikipedia.org/wiki/UTF-8\">UTF-8</a>. This is the default character encoding.\nWhen decoding a <code>Buffer</code> into a string that does not exclusively contain\nvalid UTF-8 data, the Unicode replacement character <code>U+FFFD</code> � will be used\nto represent those errors.</p>\n</li>\n<li>\n<p><code>'utf16le'</code>: Multi-byte encoded Unicode characters. Unlike <code>'utf8'</code>, each\ncharacter in the string will be encoded using either 2 or 4 bytes.\nNode.js only supports the <a href=\"https://en.wikipedia.org/wiki/Endianness\">little-endian</a> variant of <a href=\"https://en.wikipedia.org/wiki/UTF-16\">UTF-16</a>.</p>\n</li>\n<li>\n<p><code>'latin1'</code>: Latin-1 stands for <a href=\"https://en.wikipedia.org/wiki/ISO-8859-1\">ISO-8859-1</a>. This character encoding only\nsupports the Unicode characters from <code>U+0000</code> to <code>U+00FF</code>. Each character is\nencoded using a single byte. Characters that do not fit into that range are\ntruncated and will be mapped to characters in that range.</p>\n</li>\n</ul>\n<p>Converting a <code>Buffer</code> into a string using one of the above is referred to as\ndecoding, and converting a string into a <code>Buffer</code> is referred to as encoding.</p>\n<p>Node.js also supports the following two binary-to-text encodings. For\nbinary-to-text encodings, the naming convention is reversed: Converting a\n<code>Buffer</code> into a string is typically referred to as encoding, and converting a\nstring into a <code>Buffer</code> as decoding.</p>\n<ul>\n<li>\n<p><code>'base64'</code>: <a href=\"https://en.wikipedia.org/wiki/Base64\">Base64</a> encoding. When creating a <code>Buffer</code> from a string,\nthis encoding will also correctly accept \"URL and Filename Safe Alphabet\" as\nspecified in <a href=\"https://tools.ietf.org/html/rfc4648#section-5\">RFC 4648, Section 5</a>. Whitespace characters such as spaces,\ntabs, and new lines contained within the base64-encoded string are ignored.</p>\n</li>\n<li>\n<p><code>'hex'</code>: Encode each byte as two hexadecimal characters. Data truncation\nmay occur when decoding strings that do exclusively contain valid hexadecimal\ncharacters. See below for an example.</p>\n</li>\n</ul>\n<p>The following legacy character encodings are also supported:</p>\n<ul>\n<li>\n<p><code>'ascii'</code>: For 7-bit <a href=\"https://en.wikipedia.org/wiki/ASCII\">ASCII</a> data only. When encoding a string into a\n<code>Buffer</code>, this is equivalent to using <code>'latin1'</code>. When decoding a <code>Buffer</code>\ninto a string, using this encoding will additionally unset the highest bit of\neach byte before decoding as <code>'latin1'</code>.\nGenerally, there should be no reason to use this encoding, as <code>'utf8'</code>\n(or, if the data is known to always be ASCII-only, <code>'latin1'</code>) will be a\nbetter choice when encoding or decoding ASCII-only text. It is only provided\nfor legacy compatibility.</p>\n</li>\n<li>\n<p><code>'binary'</code>: Alias for <code>'latin1'</code>. See <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary\">binary strings</a> for more background\non this topic. The name of this encoding can be very misleading, as all of the\nencodings listed here convert between strings and binary data. For converting\nbetween strings and <code>Buffer</code>s, typically <code>'utf-8'</code> is the right choice.</p>\n</li>\n<li>\n<p><code>'ucs2'</code>: Alias of <code>'utf16le'</code>. UCS-2 used to refer to a variant of UTF-16\nthat did not support characters that had code points larger than U+FFFF.\nIn Node.js, these code points are always supported.</p>\n</li>\n</ul>\n<pre><code class=\"language-js\">Buffer.from('1ag', 'hex');\n// Prints &#x3C;Buffer 1a>, data truncated when first non-hexadecimal value\n// ('g') encountered.\n\nBuffer.from('1a7g', 'hex');\n// Prints &#x3C;Buffer 1a>, data truncated when data ends in single digit ('7').\n\nBuffer.from('1634', 'hex');\n// Prints &#x3C;Buffer 16 34>, all data represented.\n</code></pre>\n<p>Modern Web browsers follow the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a> which aliases\nboth <code>'latin1'</code> and <code>'ISO-8859-1'</code> to <code>'win-1252'</code>. This means that while doing\nsomething like <code>http.get()</code>, if the returned charset is one of those listed in\nthe WHATWG specification it is possible that the server actually returned\n<code>'win-1252'</code>-encoded data, and using <code>'latin1'</code> encoding may incorrectly decode\nthe characters.</p>",
+          "desc": "<p>When converting between <code>Buffer</code>s and strings, a character encoding may be\nspecified. If no character encoding is specified, UTF-8 will be used as the\ndefault.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('hello world', 'utf8');\n\nconsole.log(buf.toString('hex'));\n// Prints: 68656c6c6f20776f726c64\nconsole.log(buf.toString('base64'));\n// Prints: aGVsbG8gd29ybGQ=\n\nconsole.log(Buffer.from('fhqwhgads', 'utf8'));\n// Prints: &#x3C;Buffer 66 68 71 77 68 67 61 64 73>\nconsole.log(Buffer.from('fhqwhgads', 'utf16le'));\n// Prints: &#x3C;Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>\n</code></pre>\n<p>The character encodings currently supported by Node.js are the following:</p>\n<ul>\n<li>\n<p><code>'utf8'</code>: Multi-byte encoded Unicode characters. Many web pages and other\ndocument formats use <a href=\"https://en.wikipedia.org/wiki/UTF-8\">UTF-8</a>. This is the default character encoding.\nWhen decoding a <code>Buffer</code> into a string that does not exclusively contain\nvalid UTF-8 data, the Unicode replacement character <code>U+FFFD</code> � will be used\nto represent those errors.</p>\n</li>\n<li>\n<p><code>'utf16le'</code>: Multi-byte encoded Unicode characters. Unlike <code>'utf8'</code>, each\ncharacter in the string will be encoded using either 2 or 4 bytes.\nNode.js only supports the <a href=\"https://en.wikipedia.org/wiki/Endianness\">little-endian</a> variant of <a href=\"https://en.wikipedia.org/wiki/UTF-16\">UTF-16</a>.</p>\n</li>\n<li>\n<p><code>'latin1'</code>: Latin-1 stands for <a href=\"https://en.wikipedia.org/wiki/ISO-8859-1\">ISO-8859-1</a>. This character encoding only\nsupports the Unicode characters from <code>U+0000</code> to <code>U+00FF</code>. Each character is\nencoded using a single byte. Characters that do not fit into that range are\ntruncated and will be mapped to characters in that range.</p>\n</li>\n</ul>\n<p>Converting a <code>Buffer</code> into a string using one of the above is referred to as\ndecoding, and converting a string into a <code>Buffer</code> is referred to as encoding.</p>\n<p>Node.js also supports the following binary-to-text encodings. For\nbinary-to-text encodings, the naming convention is reversed: Converting a\n<code>Buffer</code> into a string is typically referred to as encoding, and converting a\nstring into a <code>Buffer</code> as decoding.</p>\n<ul>\n<li>\n<p><code>'base64'</code>: <a href=\"https://en.wikipedia.org/wiki/Base64\">Base64</a> encoding. When creating a <code>Buffer</code> from a string,\nthis encoding will also correctly accept \"URL and Filename Safe Alphabet\" as\nspecified in <a href=\"https://tools.ietf.org/html/rfc4648#section-5\">RFC 4648, Section 5</a>. Whitespace characters such as spaces,\ntabs, and new lines contained within the base64-encoded string are ignored.</p>\n</li>\n<li>\n<p><code>'base64url'</code>: <a href=\"https://tools.ietf.org/html/rfc4648#section-5\">base64url</a> encoding as specified in\n<a href=\"https://tools.ietf.org/html/rfc4648#section-5\">RFC 4648, Section 5</a>. When creating a <code>Buffer</code> from a string, this\nencoding will also correctly accept regular base64-encoded strings. When\nencoding a <code>Buffer</code> to a string, this encoding will omit padding.</p>\n</li>\n<li>\n<p><code>'hex'</code>: Encode each byte as two hexadecimal characters. Data truncation\nmay occur when decoding strings that do exclusively contain valid hexadecimal\ncharacters. See below for an example.</p>\n</li>\n</ul>\n<p>The following legacy character encodings are also supported:</p>\n<ul>\n<li>\n<p><code>'ascii'</code>: For 7-bit <a href=\"https://en.wikipedia.org/wiki/ASCII\">ASCII</a> data only. When encoding a string into a\n<code>Buffer</code>, this is equivalent to using <code>'latin1'</code>. When decoding a <code>Buffer</code>\ninto a string, using this encoding will additionally unset the highest bit of\neach byte before decoding as <code>'latin1'</code>.\nGenerally, there should be no reason to use this encoding, as <code>'utf8'</code>\n(or, if the data is known to always be ASCII-only, <code>'latin1'</code>) will be a\nbetter choice when encoding or decoding ASCII-only text. It is only provided\nfor legacy compatibility.</p>\n</li>\n<li>\n<p><code>'binary'</code>: Alias for <code>'latin1'</code>. See <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary\">binary strings</a> for more background\non this topic. The name of this encoding can be very misleading, as all of the\nencodings listed here convert between strings and binary data. For converting\nbetween strings and <code>Buffer</code>s, typically <code>'utf-8'</code> is the right choice.</p>\n</li>\n<li>\n<p><code>'ucs2'</code>: Alias of <code>'utf16le'</code>. UCS-2 used to refer to a variant of UTF-16\nthat did not support characters that had code points larger than U+FFFF.\nIn Node.js, these code points are always supported.</p>\n</li>\n</ul>\n<pre><code class=\"language-js\">Buffer.from('1ag', 'hex');\n// Prints &#x3C;Buffer 1a>, data truncated when first non-hexadecimal value\n// ('g') encountered.\n\nBuffer.from('1a7g', 'hex');\n// Prints &#x3C;Buffer 1a>, data truncated when data ends in single digit ('7').\n\nBuffer.from('1634', 'hex');\n// Prints &#x3C;Buffer 16 34>, all data represented.\n</code></pre>\n<p>Modern Web browsers follow the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a> which aliases\nboth <code>'latin1'</code> and <code>'ISO-8859-1'</code> to <code>'win-1252'</code>. This means that while doing\nsomething like <code>http.get()</code>, if the returned charset is one of those listed in\nthe WHATWG specification it is possible that the server actually returned\n<code>'win-1252'</code>-encoded data, and using <code>'latin1'</code> encoding may incorrectly decode\nthe characters.</p>",
           "type": "module",
           "displayName": "Buffers and character encodings"
         },
@@ -13501,7 +14404,7 @@
               }
             ]
           },
-          "desc": "<p><code>Buffer</code> instances are also JavaScript <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>\ninstances. All <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> methods are available on <code>Buffer</code>s. There are,\nhowever, subtle incompatibilities between the <code>Buffer</code> API and the\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> API.</p>\n<p>In particular:</p>\n<ul>\n<li>While <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice\"><code>TypedArray#slice()</code></a> creates a copy of part of the <code>TypedArray</code>,\n<a href=\"buffer.html#buffer_buf_slice_start_end\"><code>Buffer#slice()</code></a> creates a view over the existing <code>Buffer</code>\nwithout copying. This behavior can be surprising, and only exists for legacy\ncompatibility. <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\"><code>TypedArray#subarray()</code></a> can be used to achieve the behavior\nof <a href=\"buffer.html#buffer_buf_slice_start_end\"><code>Buffer#slice()</code></a> on both <code>Buffer</code>s and other\n<code>TypedArray</code>s.</li>\n<li><a href=\"buffer.html#buffer_buf_tostring_encoding_start_end\"><code>buf.toString()</code></a> is incompatible with its <code>TypedArray</code> equivalent.</li>\n<li>A number of methods, e.g. <a href=\"buffer.html#buffer_buf_indexof_value_byteoffset_encoding\"><code>buf.indexOf()</code></a>, support additional arguments.</li>\n</ul>\n<p>There are two ways to create new <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instances from a <code>Buffer</code>:</p>\n<ul>\n<li>Passing a <code>Buffer</code> to a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> constructor will copy the <code>Buffer</code>s\ncontents, interpreted as an array of integers, and not as a byte sequence\nof the target type.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from([1, 2, 3, 4]);\nconst uint32array = new Uint32Array(buf);\n\nconsole.log(uint32array);\n\n// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]\n</code></pre>\n<ul>\n<li>Passing the <code>Buffer</code>s underlying <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> will create a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> that shares its memory with the <code>Buffer</code>.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from('hello', 'utf16le');\nconst uint16arr = new Uint16Array(\n  buf.buffer,\n  buf.byteOffset,\n  buf.length / Uint16Array.BYTES_PER_ELEMENT);\n\nconsole.log(uint16array);\n\n// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]\n</code></pre>\n<p>It is possible to create a new <code>Buffer</code> that shares the same allocated\nmemory as a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instance by using the <code>TypedArray</code> object’s\n<code>.buffer</code> property in the same way. <a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from()</code></a>\nbehaves like <code>new Uint8Array()</code> in this context.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(2);\n\narr[0] = 5000;\narr[1] = 4000;\n\n// Copies the contents of `arr`.\nconst buf1 = Buffer.from(arr);\n\n// Shares memory with `arr`.\nconst buf2 = Buffer.from(arr.buffer);\n\nconsole.log(buf1);\n// Prints: &#x3C;Buffer 88 a0>\nconsole.log(buf2);\n// Prints: &#x3C;Buffer 88 13 a0 0f>\n\narr[1] = 6000;\n\nconsole.log(buf1);\n// Prints: &#x3C;Buffer 88 a0>\nconsole.log(buf2);\n// Prints: &#x3C;Buffer 88 13 70 17>\n</code></pre>\n<p>When creating a <code>Buffer</code> using a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>'s <code>.buffer</code>, it is\npossible to use only a portion of the underlying <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> by passing in\n<code>byteOffset</code> and <code>length</code> parameters.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(20);\nconst buf = Buffer.from(arr.buffer, 0, 16);\n\nconsole.log(buf.length);\n// Prints: 16\n</code></pre>\n<p>The <code>Buffer.from()</code> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from\"><code>TypedArray.from()</code></a> have different signatures and\nimplementations. Specifically, the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> variants accept a second\nargument that is a mapping function that is invoked on every element of the\ntyped array:</p>\n<ul>\n<li><code>TypedArray.from(source[, mapFn[, thisArg]])</code></li>\n</ul>\n<p>The <code>Buffer.from()</code> method, however, does not support the use of a mapping\nfunction:</p>\n<ul>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a></li>\n</ul>",
+          "desc": "<p><code>Buffer</code> instances are also JavaScript <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>\ninstances. All <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> methods are available on <code>Buffer</code>s. There are,\nhowever, subtle incompatibilities between the <code>Buffer</code> API and the\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> API.</p>\n<p>In particular:</p>\n<ul>\n<li>While <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice\"><code>TypedArray.prototype.slice()</code></a> creates a copy of part of the <code>TypedArray</code>,\n<a href=\"buffer.html#buffer_buf_slice_start_end\"><code>Buffer.prototype.slice()</code></a> creates a view over the existing <code>Buffer</code>\nwithout copying. This behavior can be surprising, and only exists for legacy\ncompatibility. <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\"><code>TypedArray.prototype.subarray()</code></a> can be used to achieve\nthe behavior of <a href=\"buffer.html#buffer_buf_slice_start_end\"><code>Buffer.prototype.slice()</code></a> on both <code>Buffer</code>s\nand other <code>TypedArray</code>s.</li>\n<li><a href=\"buffer.html#buffer_buf_tostring_encoding_start_end\"><code>buf.toString()</code></a> is incompatible with its <code>TypedArray</code> equivalent.</li>\n<li>A number of methods, e.g. <a href=\"buffer.html#buffer_buf_indexof_value_byteoffset_encoding\"><code>buf.indexOf()</code></a>, support additional arguments.</li>\n</ul>\n<p>There are two ways to create new <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instances from a <code>Buffer</code>:</p>\n<ul>\n<li>Passing a <code>Buffer</code> to a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> constructor will copy the <code>Buffer</code>s\ncontents, interpreted as an array of integers, and not as a byte sequence\nof the target type.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from([1, 2, 3, 4]);\nconst uint32array = new Uint32Array(buf);\n\nconsole.log(uint32array);\n\n// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]\n</code></pre>\n<ul>\n<li>Passing the <code>Buffer</code>s underlying <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> will create a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> that shares its memory with the <code>Buffer</code>.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from('hello', 'utf16le');\nconst uint16array = new Uint16Array(\n  buf.buffer,\n  buf.byteOffset,\n  buf.length / Uint16Array.BYTES_PER_ELEMENT);\n\nconsole.log(uint16array);\n\n// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]\n</code></pre>\n<p>It is possible to create a new <code>Buffer</code> that shares the same allocated\nmemory as a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instance by using the <code>TypedArray</code> object’s\n<code>.buffer</code> property in the same way. <a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from()</code></a>\nbehaves like <code>new Uint8Array()</code> in this context.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(2);\n\narr[0] = 5000;\narr[1] = 4000;\n\n// Copies the contents of `arr`.\nconst buf1 = Buffer.from(arr);\n\n// Shares memory with `arr`.\nconst buf2 = Buffer.from(arr.buffer);\n\nconsole.log(buf1);\n// Prints: &#x3C;Buffer 88 a0>\nconsole.log(buf2);\n// Prints: &#x3C;Buffer 88 13 a0 0f>\n\narr[1] = 6000;\n\nconsole.log(buf1);\n// Prints: &#x3C;Buffer 88 a0>\nconsole.log(buf2);\n// Prints: &#x3C;Buffer 88 13 70 17>\n</code></pre>\n<p>When creating a <code>Buffer</code> using a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>'s <code>.buffer</code>, it is\npossible to use only a portion of the underlying <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> by passing in\n<code>byteOffset</code> and <code>length</code> parameters.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(20);\nconst buf = Buffer.from(arr.buffer, 0, 16);\n\nconsole.log(buf.length);\n// Prints: 16\n</code></pre>\n<p>The <code>Buffer.from()</code> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from\"><code>TypedArray.from()</code></a> have different signatures and\nimplementations. Specifically, the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> variants accept a second\nargument that is a mapping function that is invoked on every element of the\ntyped array:</p>\n<ul>\n<li><code>TypedArray.from(source[, mapFn[, thisArg]])</code></li>\n</ul>\n<p>The <code>Buffer.from()</code> method, however, does not support the use of a mapping\nfunction:</p>\n<ul>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a></li>\n</ul>",
           "type": "module",
           "displayName": "Buffers and TypedArrays"
         },
@@ -13516,35 +14419,55 @@
           "textRaw": "`buffer` module APIs",
           "name": "`buffer`_module_apis",
           "desc": "<p>While, the <code>Buffer</code> object is available as a global, there are additional\n<code>Buffer</code>-related APIs that are available only via the <code>buffer</code> module\naccessed using <code>require('buffer')</code>.</p>",
-          "properties": [
+          "methods": [
             {
-              "textRaw": "`INSPECT_MAX_BYTES` {integer} **Default:** `50`",
-              "type": "integer",
-              "name": "INSPECT_MAX_BYTES",
+              "textRaw": "`buffer.atob(data)`",
+              "type": "method",
+              "name": "atob",
               "meta": {
                 "added": [
-                  "v0.5.4"
+                  "v14.17.0"
                 ],
                 "changes": []
               },
-              "default": "`50`",
-              "desc": "<p>Returns the maximum number of bytes that will be returned when\n<code>buf.inspect()</code> is called. This can be overridden by user modules. See\n<a href=\"util.html#util_util_inspect_object_options\"><code>util.inspect()</code></a> for more details on <code>buf.inspect()</code> behavior.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`data` {any} The Base64-encoded input string.",
+                      "name": "data",
+                      "type": "any",
+                      "desc": "The Base64-encoded input string."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Decodes a string of Base64-encoded data into bytes, and encodes those bytes\ninto a string using Latin-1 (ISO-8859-1).</p>\n<p>The <code>data</code> may be any JavaScript-value that can be coerced into a string.</p>\n<p><strong>This function is only provided for compatibility with legacy web platform APIs\nand should never be used in new code, because they use strings to represent\nbinary data and predate the introduction of typed arrays in JavaScript.\nFor code running using Node.js APIs, converting between base64-encoded strings\nand binary data should be performed using <code>Buffer.from(str, 'base64')</code> and\n<code>buf.toString('base64')</code>.</strong></p>"
             },
             {
-              "textRaw": "`kMaxLength` {integer} The largest size allowed for a single `Buffer` instance.",
-              "type": "integer",
-              "name": "kMaxLength",
+              "textRaw": "`buffer.btoa(data)`",
+              "type": "method",
+              "name": "btoa",
               "meta": {
                 "added": [
-                  "v3.0.0"
+                  "v14.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>An alias for <a href=\"buffer.html#buffer_buffer_constants_max_length\"><code>buffer.constants.MAX_LENGTH</code></a>.</p>",
-              "shortDesc": "The largest size allowed for a single `Buffer` instance."
-            }
-          ],
-          "methods": [
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`data` {any} An ASCII (Latin1) string.",
+                      "name": "data",
+                      "type": "any",
+                      "desc": "An ASCII (Latin1) string."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes\ninto a string using Base64.</p>\n<p>The <code>data</code> may be any JavaScript-value that can be coerced into a string.</p>\n<p><strong>This function is only provided for compatibility with legacy web platform APIs\nand should never be used in new code, because they use strings to represent\nbinary data and predate the introduction of typed arrays in JavaScript.\nFor code running using Node.js APIs, converting between base64-encoded strings\nand binary data should be performed using <code>Buffer.from(str, 'base64')</code> and\n<code>buf.toString('base64')</code>.</strong></p>"
+            },
             {
               "textRaw": "`buffer.transcode(source, fromEnc, toEnc)`",
               "type": "method",
@@ -13593,6 +14516,47 @@
               "desc": "<p>Re-encodes the given <code>Buffer</code> or <code>Uint8Array</code> instance from one character\nencoding to another. Returns a new <code>Buffer</code> instance.</p>\n<p>Throws if the <code>fromEnc</code> or <code>toEnc</code> specify invalid character encodings or if\nconversion from <code>fromEnc</code> to <code>toEnc</code> is not permitted.</p>\n<p>Encodings supported by <code>buffer.transcode()</code> are: <code>'ascii'</code>, <code>'utf8'</code>,\n<code>'utf16le'</code>, <code>'ucs2'</code>, <code>'latin1'</code>, and <code>'binary'</code>.</p>\n<p>The transcoding process will use substitution characters if a given byte\nsequence cannot be adequately represented in the target encoding. For instance:</p>\n<pre><code class=\"language-js\">const buffer = require('buffer');\n\nconst newBuf = buffer.transcode(Buffer.from('€'), 'utf8', 'ascii');\nconsole.log(newBuf.toString('ascii'));\n// Prints: '?'\n</code></pre>\n<p>Because the Euro (<code>€</code>) sign is not representable in US-ASCII, it is replaced\nwith <code>?</code> in the transcoded <code>Buffer</code>.</p>"
             }
           ],
+          "properties": [
+            {
+              "textRaw": "`INSPECT_MAX_BYTES` {integer} **Default:** `50`",
+              "type": "integer",
+              "name": "INSPECT_MAX_BYTES",
+              "meta": {
+                "added": [
+                  "v0.5.4"
+                ],
+                "changes": []
+              },
+              "default": "`50`",
+              "desc": "<p>Returns the maximum number of bytes that will be returned when\n<code>buf.inspect()</code> is called. This can be overridden by user modules. See\n<a href=\"util.html#util_util_inspect_object_options\"><code>util.inspect()</code></a> for more details on <code>buf.inspect()</code> behavior.</p>"
+            },
+            {
+              "textRaw": "`kMaxLength` {integer} The largest size allowed for a single `Buffer` instance.",
+              "type": "integer",
+              "name": "kMaxLength",
+              "meta": {
+                "added": [
+                  "v3.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An alias for <a href=\"buffer.html#buffer_buffer_constants_max_length\"><code>buffer.constants.MAX_LENGTH</code></a>.</p>",
+              "shortDesc": "The largest size allowed for a single `Buffer` instance."
+            },
+            {
+              "textRaw": "`kStringMaxLength` {integer} The largest length allowed for a single `string` instance.",
+              "type": "integer",
+              "name": "kStringMaxLength",
+              "meta": {
+                "added": [
+                  "v3.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An alias for <a href=\"buffer.html#buffer_buffer_constants_max_string_length\"><code>buffer.constants.MAX_STRING_LENGTH</code></a>.</p>",
+              "shortDesc": "The largest length allowed for a single `string` instance."
+            }
+          ],
           "classes": [
             {
               "textRaw": "Class: `SlowBuffer`",
@@ -13641,9 +14605,15 @@
                     "added": [
                       "v8.2.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/32116",
+                        "description": "Value is changed from 2<sup>31</sup> - 1 to 2<sup>32</sup> - 1 on 64-bit architectures."
+                      }
+                    ]
                   },
-                  "desc": "<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).\nOn 64-bit architectures, this value currently is 2<sup>31</sup> - 1 (~2GB).</p>\n<p>This value is also available as <a href=\"buffer.html#buffer_buffer_kmaxlength\"><code>buffer.kMaxLength</code></a>.</p>",
+                  "desc": "<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).</p>\n<p>On 64-bit architectures, this value currently is 2<sup>32</sup> - 1 (~4GB).</p>\n<p>It reflects <a href=\"https://v8.github.io/api/head/classv8_1_1TypedArray.html#a54a48f4373da0850663c4393d843b9b0\"><code>v8::TypedArray::kMaxLength</code></a> under the hood.</p>\n<p>This value is also available as <a href=\"buffer.html#buffer_buffer_kmaxlength\"><code>buffer.kMaxLength</code></a>.</p>",
                   "shortDesc": "The largest size allowed for a single `Buffer` instance."
                 },
                 {
@@ -13673,17 +14643,17 @@
           "desc": "<p>In versions of Node.js prior to 6.0.0, <code>Buffer</code> instances were created using the\n<code>Buffer</code> constructor function, which allocates the returned <code>Buffer</code>\ndifferently based on what arguments are provided:</p>\n<ul>\n<li>Passing a number as the first argument to <code>Buffer()</code> (e.g. <code>new Buffer(10)</code>)\nallocates a new <code>Buffer</code> object of the specified size. Prior to Node.js 8.0.0,\nthe memory allocated for such <code>Buffer</code> instances is <em>not</em> initialized and\n<em>can contain sensitive data</em>. Such <code>Buffer</code> instances <em>must</em> be subsequently\ninitialized by using either <a href=\"buffer.html#buffer_buf_fill_value_offset_end_encoding\"><code>buf.fill(0)</code></a> or by writing to the\nentire <code>Buffer</code> before reading data from the <code>Buffer</code>.\nWhile this behavior is <em>intentional</em> to improve performance,\ndevelopment experience has demonstrated that a more explicit distinction is\nrequired between creating a fast-but-uninitialized <code>Buffer</code> versus creating a\nslower-but-safer <code>Buffer</code>. Since Node.js 8.0.0, <code>Buffer(num)</code> and <code>new Buffer(num)</code> return a <code>Buffer</code> with initialized memory.</li>\n<li>Passing a string, array, or <code>Buffer</code> as the first argument copies the\npassed object's data into the <code>Buffer</code>.</li>\n<li>Passing an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> or a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> returns a <code>Buffer</code>\nthat shares allocated memory with the given array buffer.</li>\n</ul>\n<p>Because the behavior of <code>new Buffer()</code> is different depending on the type of the\nfirst argument, security and reliability issues can be inadvertently introduced\ninto applications when argument validation or <code>Buffer</code> initialization is not\nperformed.</p>\n<p>For example, if an attacker can cause an application to receive a number where\na string is expected, the application may call <code>new Buffer(100)</code>\ninstead of <code>new Buffer(\"100\")</code>, leading it to allocate a 100 byte buffer instead\nof allocating a 3 byte buffer with content <code>\"100\"</code>. This is commonly possible\nusing JSON API calls. Since JSON distinguishes between numeric and string types,\nit allows injection of numbers where a naively written application that does not\nvalidate its input sufficiently might expect to always receive a string.\nBefore Node.js 8.0.0, the 100 byte buffer might contain\narbitrary pre-existing in-memory data, so may be used to expose in-memory\nsecrets to a remote attacker. Since Node.js 8.0.0, exposure of memory cannot\noccur because the data is zero-filled. However, other attacks are still\npossible, such as causing very large buffers to be allocated by the server,\nleading to performance degradation or crashing on memory exhaustion.</p>\n<p>To make the creation of <code>Buffer</code> instances more reliable and less error-prone,\nthe various forms of the <code>new Buffer()</code> constructor have been <strong>deprecated</strong>\nand replaced by separate <code>Buffer.from()</code>, <a href=\"buffer.html#buffer_static_method_buffer_alloc_size_fill_encoding\"><code>Buffer.alloc()</code></a>, and\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe()</code></a> methods.</p>\n<p><em>Developers should migrate all existing uses of the <code>new Buffer()</code> constructors\nto one of these new APIs.</em></p>\n<ul>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a> returns a new <code>Buffer</code> that <em>contains a copy</em> of the\nprovided octets.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a>\nreturns a new <code>Buffer</code> that <em>shares the same allocated memory</em> as the given\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a> returns a new <code>Buffer</code> that <em>contains a copy</em> of the\ncontents of the given <code>Buffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a> returns a new\n<code>Buffer</code> that <em>contains a copy</em> of the provided string.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_alloc_size_fill_encoding\"><code>Buffer.alloc(size[, fill[, encoding]])</code></a> returns a new\ninitialized <code>Buffer</code> of the specified size. This method is slower than\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe(size)</code></a> but guarantees that newly\ncreated <code>Buffer</code> instances never contain old data that is potentially\nsensitive. A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe(size)</code></a> and\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a> each return a\nnew uninitialized <code>Buffer</code> of the specified <code>size</code>. Because the <code>Buffer</code> is\nuninitialized, the allocated segment of memory might contain old data that is\npotentially sensitive.</li>\n</ul>\n<p><code>Buffer</code> instances returned by <a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe()</code></a> and\n<a href=\"buffer.html#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a> <em>may</em> be allocated off a shared internal memory pool\nif <code>size</code> is less than or equal to half <a href=\"buffer.html#buffer_class_property_buffer_poolsize\"><code>Buffer.poolSize</code></a>. Instances\nreturned by <a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow()</code></a> <em>never</em> use the shared internal\nmemory pool.</p>",
           "modules": [
             {
-              "textRaw": "The `--zero-fill-buffers` command line option",
-              "name": "the_`--zero-fill-buffers`_command_line_option",
+              "textRaw": "The `--zero-fill-buffers` command-line option",
+              "name": "the_`--zero-fill-buffers`_command-line_option",
               "meta": {
                 "added": [
                   "v5.10.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>Node.js can be started using the <code>--zero-fill-buffers</code> command line option to\ncause all newly-allocated <code>Buffer</code> instances to be zero-filled upon creation by\ndefault. Without the option, buffers created with <a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe()</code></a>,\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow()</code></a>, and <code>new SlowBuffer(size)</code> are not zero-filled.\nUse of this flag can have a measurable negative impact on performance. Use the\n<code>--zero-fill-buffers</code> option only when necessary to enforce that newly allocated\n<code>Buffer</code> instances cannot contain old data that is potentially sensitive.</p>\n<pre><code class=\"language-console\">$ node --zero-fill-buffers\n> Buffer.allocUnsafe(5);\n&#x3C;Buffer 00 00 00 00 00>\n</code></pre>",
+              "desc": "<p>Node.js can be started using the <code>--zero-fill-buffers</code> command-line option to\ncause all newly-allocated <code>Buffer</code> instances to be zero-filled upon creation by\ndefault. Without the option, buffers created with <a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe()</code></a>,\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow()</code></a>, and <code>new SlowBuffer(size)</code> are not zero-filled.\nUse of this flag can have a measurable negative impact on performance. Use the\n<code>--zero-fill-buffers</code> option only when necessary to enforce that newly allocated\n<code>Buffer</code> instances cannot contain old data that is potentially sensitive.</p>\n<pre><code class=\"language-console\">$ node --zero-fill-buffers\n> Buffer.allocUnsafe(5);\n&#x3C;Buffer 00 00 00 00 00>\n</code></pre>",
               "type": "module",
-              "displayName": "The `--zero-fill-buffers` command line option"
+              "displayName": "The `--zero-fill-buffers` command-line option"
             },
             {
               "textRaw": "What makes `Buffer.allocUnsafe()` and `Buffer.allocUnsafeSlow()` \"unsafe\"?",
@@ -13698,6 +14668,168 @@
         }
       ],
       "classes": [
+        {
+          "textRaw": "Class: `Blob`",
+          "type": "class",
+          "name": "Blob",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>A <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Blob\"><code>Blob</code></a> encapsulates immutable, raw data that can be safely shared across\nmultiple worker threads.</p>",
+          "methods": [
+            {
+              "textRaw": "`blob.arrayBuffer()`",
+              "type": "method",
+              "name": "arrayBuffer",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Promise}",
+                    "name": "return",
+                    "type": "Promise"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns a promise that fulfills with an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\" class=\"type\">&lt;ArrayBuffer&gt;</a> containing a copy of\nthe <code>Blob</code> data.</p>"
+            },
+            {
+              "textRaw": "`blob.slice([start, [end, [type]]])`",
+              "type": "method",
+              "name": "slice",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`start` {number} The starting index.",
+                      "name": "start",
+                      "type": "number",
+                      "desc": "The starting index."
+                    },
+                    {
+                      "textRaw": "`end` {number} The ending index.",
+                      "name": "end",
+                      "type": "number",
+                      "desc": "The ending index."
+                    },
+                    {
+                      "textRaw": "`type` {string} The content-type for the new `Blob`",
+                      "name": "type",
+                      "type": "string",
+                      "desc": "The content-type for the new `Blob`"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Creates and returns a new <code>Blob</code> containing a subset of this <code>Blob</code> objects\ndata. The original <code>Blob</code> is not alterered.</p>"
+            },
+            {
+              "textRaw": "`blob.text()`",
+              "type": "method",
+              "name": "text",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Promise}",
+                    "name": "return",
+                    "type": "Promise"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns a promise that resolves the contents of the <code>Blob</code> decoded as a UTF-8\nstring.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`blob.size`",
+              "name": "size",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The total size of the <code>Blob</code> in bytes.</p>"
+            },
+            {
+              "textRaw": "`type` Type: {string}",
+              "type": "string",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The content-type of the <code>Blob</code>.</p>"
+            }
+          ],
+          "modules": [
+            {
+              "textRaw": "`Blob` objects and `MessageChannel`",
+              "name": "`blob`_objects_and_`messagechannel`",
+              "desc": "<p>Once a <a href=\"buffer.html#buffer_class_blob\" class=\"type\">&lt;Blob&gt;</a> object is created, it can be sent via <code>MessagePort</code> to multiple\ndestinations without transfering or immediately copying the data. The data\ncontained by the <code>Blob</code> is copied only when the <code>arrayBuffer()</code> or <code>text()</code>\nmethods are called.</p>\n<pre><code class=\"language-js\">const { Blob } = require('buffer');\nconst blob = new Blob(['hello there']);\nconst { setTimeout: delay } = require('timers/promises');\n\nconst mc1 = new MessageChannel();\nconst mc2 = new MessageChannel();\n\nmc1.port1.onmessage = async ({ data }) => {\n  console.log(await data.arrayBuffer());\n  mc1.port1.close();\n};\n\nmc2.port1.onmessage = async ({ data }) => {\n  await delay(1000);\n  console.log(await data.arrayBuffer());\n  mc2.port1.close();\n};\n\nmc1.port2.postMessage(blob);\nmc2.port2.postMessage(blob);\n\n// The Blob is still usable after posting.\ndata.text().then(console.log);\n</code></pre>",
+              "type": "module",
+              "displayName": "`Blob` objects and `MessageChannel`"
+            }
+          ],
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`sources` {string[]|ArrayBuffer[]|TypedArray[]|DataView[]|Blob[]} An array of string, {ArrayBuffer}, {TypedArray}, {DataView}, or {Blob} objects, or any mix of such objects, that will be stored within the `Blob`.",
+                  "name": "sources",
+                  "type": "string[]|ArrayBuffer[]|TypedArray[]|DataView[]|Blob[]",
+                  "desc": "An array of string, {ArrayBuffer}, {TypedArray}, {DataView}, or {Blob} objects, or any mix of such objects, that will be stored within the `Blob`."
+                },
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`encoding` {string} The character encoding to use for string sources. **Default**: `'utf8'`.",
+                      "name": "encoding",
+                      "type": "string",
+                      "desc": "The character encoding to use for string sources. **Default**: `'utf8'`."
+                    },
+                    {
+                      "textRaw": "`type` {string} The Blob content-type. The intent is for `type` to convey the MIME media type of the data, however no validation of the type format is performed.",
+                      "name": "type",
+                      "type": "string",
+                      "desc": "The Blob content-type. The intent is for `type` to convey the MIME media type of the data, however no validation of the type format is performed."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Creates a new <code>Blob</code> object containing a concatenation of the given sources.</p>\n<p><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\" class=\"type\">&lt;ArrayBuffer&gt;</a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\" class=\"type\">&lt;TypedArray&gt;</a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\" class=\"type\">&lt;DataView&gt;</a>, and <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> sources are copied into\nthe 'Blob' and can therefore be safely modified after the 'Blob' is created.</p>\n<p>String sources are also copied into the <code>Blob</code>.</p>"
+            }
+          ]
+        },
         {
           "textRaw": "Class: `Buffer`",
           "type": "class",
@@ -13858,7 +14990,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns the byte length of a string when encoded using <code>encoding</code>.\nThis is not the same as <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length\"><code>String.prototype.length</code></a>, which does not account\nfor the encoding that is used to convert the string into bytes.</p>\n<p>For <code>'base64'</code> and <code>'hex'</code>, this function assumes valid input. For strings that\ncontain non-base64/hex-encoded data (e.g. whitespace), the return value might be\ngreater than the length of a <code>Buffer</code> created from the string.</p>\n<pre><code class=\"language-js\">const str = '\\u00bd + \\u00bc = \\u00be';\n\nconsole.log(`${str}: ${str.length} characters, ` +\n            `${Buffer.byteLength(str, 'utf8')} bytes`);\n// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes\n</code></pre>\n<p>When <code>string</code> is a <code>Buffer</code>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\"><code>DataView</code></a>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>/\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a>, the byte length as reported by <code>.byteLength</code>\nis returned.</p>"
+              "desc": "<p>Returns the byte length of a string when encoded using <code>encoding</code>.\nThis is not the same as <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length\"><code>String.prototype.length</code></a>, which does not account\nfor the encoding that is used to convert the string into bytes.</p>\n<p>For <code>'base64'</code>, <code>'base64url'</code>, and <code>'hex'</code>, this function assumes valid input.\nFor strings that contain non-base64/hex-encoded data (e.g. whitespace), the\nreturn value might be greater than the length of a <code>Buffer</code> created from the\nstring.</p>\n<pre><code class=\"language-js\">const str = '\\u00bd + \\u00bc = \\u00be';\n\nconsole.log(`${str}: ${str.length} characters, ` +\n            `${Buffer.byteLength(str, 'utf8')} bytes`);\n// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes\n</code></pre>\n<p>When <code>string</code> is a <code>Buffer</code>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\"><code>DataView</code></a>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>/\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a>, the byte length as reported by <code>.byteLength</code>\nis returned.</p>"
             },
             {
               "textRaw": "Static method: `Buffer.compare(buf1, buf2)`",
@@ -14000,7 +15132,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This creates a view of the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> without copying the underlying\nmemory. For example, when passed a reference to the <code>.buffer</code> property of a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instance, the newly created <code>Buffer</code> will share the same\nallocated memory as the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(2);\n\narr[0] = 5000;\narr[1] = 4000;\n\n// Shares memory with `arr`.\nconst buf = Buffer.from(arr.buffer);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 88 13 a0 0f>\n\n// Changing the original Uint16Array changes the Buffer also.\narr[1] = 6000;\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 88 13 70 17>\n</code></pre>\n<p>The optional <code>byteOffset</code> and <code>length</code> arguments specify a memory range within\nthe <code>arrayBuffer</code> that will be shared by the <code>Buffer</code>.</p>\n<pre><code class=\"language-js\">const ab = new ArrayBuffer(10);\nconst buf = Buffer.from(ab, 0, 2);\n\nconsole.log(buf.length);\n// Prints: 2\n</code></pre>\n<p>A <code>TypeError</code> will be thrown if <code>arrayBuffer</code> is not an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> or a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> or another type appropriate for <code>Buffer.from()</code>\nvariants.</p>"
+              "desc": "<p>This creates a view of the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> without copying the underlying\nmemory. For example, when passed a reference to the <code>.buffer</code> property of a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instance, the newly created <code>Buffer</code> will share the same\nallocated memory as the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>'s underlying <code>ArrayBuffer</code>.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(2);\n\narr[0] = 5000;\narr[1] = 4000;\n\n// Shares memory with `arr`.\nconst buf = Buffer.from(arr.buffer);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 88 13 a0 0f>\n\n// Changing the original Uint16Array changes the Buffer also.\narr[1] = 6000;\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 88 13 70 17>\n</code></pre>\n<p>The optional <code>byteOffset</code> and <code>length</code> arguments specify a memory range within\nthe <code>arrayBuffer</code> that will be shared by the <code>Buffer</code>.</p>\n<pre><code class=\"language-js\">const ab = new ArrayBuffer(10);\nconst buf = Buffer.from(ab, 0, 2);\n\nconsole.log(buf.length);\n// Prints: 2\n</code></pre>\n<p>A <code>TypeError</code> will be thrown if <code>arrayBuffer</code> is not an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> or a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> or another type appropriate for <code>Buffer.from()</code>\nvariants.</p>\n<p>It is important to remember that a backing <code>ArrayBuffer</code> can cover a range\nof memory that extends beyond the bounds of a <code>TypedArray</code> view. A new\n<code>Buffer</code> created using the <code>buffer</code> property of a <code>TypedArray</code> may extend\nbeyond the range of the <code>TypedArray</code>:</p>\n<pre><code class=\"language-js\">const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements\nconst arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements\nconsole.log(arrA.buffer === arrB.buffer); // true\n\nconst buf = Buffer.from(arrB.buffer);\nconsole.log(buf);\n// Prints: &#x3C;Buffer 63 64 65 66>\n</code></pre>"
             },
             {
               "textRaw": "Static method: `Buffer.from(buffer)`",
@@ -14119,7 +15251,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if <code>obj</code> is a <code>Buffer</code>, <code>false</code> otherwise.</p>"
+              "desc": "<p>Returns <code>true</code> if <code>obj</code> is a <code>Buffer</code>, <code>false</code> otherwise.</p>\n<pre><code class=\"language-js\">Buffer.isBuffer(Buffer.alloc(10)); // true\nBuffer.isBuffer(Buffer.from('foo')); // true\nBuffer.isBuffer('a string'); // false\nBuffer.isBuffer([]); // false\nBuffer.isBuffer(new Uint8Array(1024)); // false\n</code></pre>"
             },
             {
               "textRaw": "Static method: `Buffer.isEncoding(encoding)`",
@@ -14169,13 +15301,6 @@
               "textRaw": "`[index]` `index` {integer}",
               "type": "integer",
               "name": "index",
-              "meta": {
-                "type": "property",
-                "name": [
-                  "index"
-                ],
-                "changes": []
-              },
               "desc": "<p>The index operator <code>[index]</code> can be used to get and set the octet at position\n<code>index</code> in <code>buf</code>. The values refer to individual bytes, so the legal value\nrange is between <code>0x00</code> and <code>0xFF</code> (hex) or <code>0</code> and <code>255</code> (decimal).</p>\n<p>This operator is inherited from <code>Uint8Array</code>, so its behavior on out-of-bounds\naccess is the same as <code>Uint8Array</code>. In other words, <code>buf[index]</code> returns\n<code>undefined</code> when <code>index</code> is negative or greater or equal to <code>buf.length</code>, and\n<code>buf[index] = value</code> does not modify the buffer if <code>index</code> is negative or\n<code>>= buf.length</code>.</p>\n<pre><code class=\"language-js\">// Copy an ASCII string into a `Buffer` one byte at a time.\n// (This only works for ASCII-only strings. In general, one should use\n// `Buffer.from()` to perform this conversion.)\n\nconst str = 'Node.js';\nconst buf = Buffer.allocUnsafe(str.length);\n\nfor (let i = 0; i &#x3C; str.length; i++) {\n  buf[i] = str.charCodeAt(i);\n}\n\nconsole.log(buf.toString('utf8'));\n// Prints: Node.js\n</code></pre>"
             },
             {
@@ -14336,7 +15461,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Copies data from a region of <code>buf</code> to a region in <code>target</code>, even if the <code>target</code>\nmemory region overlaps with <code>buf</code>.</p>\n<p><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set\"><code>TypedArray#set()</code></a> performs the same operation, and is available for all\nTypedArrays, including Node.js <code>Buffer</code>s, although it takes different\nfunction arguments.</p>\n<pre><code class=\"language-js\">// Create two `Buffer` instances.\nconst buf1 = Buffer.allocUnsafe(26);\nconst buf2 = Buffer.allocUnsafe(26).fill('!');\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf1[i] = i + 97;\n}\n\n// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.\nbuf1.copy(buf2, 8, 16, 20);\n// This is equivalent to:\n// buf2.set(buf1.subarray(16, 20), 8);\n\nconsole.log(buf2.toString('ascii', 0, 25));\n// Prints: !!!!!!!!qrst!!!!!!!!!!!!!\n</code></pre>\n<pre><code class=\"language-js\">// Create a `Buffer` and copy data from one region to an overlapping region\n// within the same `Buffer`.\n\nconst buf = Buffer.allocUnsafe(26);\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf[i] = i + 97;\n}\n\nbuf.copy(buf, 0, 4, 10);\n\nconsole.log(buf.toString());\n// Prints: efghijghijklmnopqrstuvwxyz\n</code></pre>"
+              "desc": "<p>Copies data from a region of <code>buf</code> to a region in <code>target</code>, even if the <code>target</code>\nmemory region overlaps with <code>buf</code>.</p>\n<p><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set\"><code>TypedArray.prototype.set()</code></a> performs the same operation, and is available\nfor all TypedArrays, including Node.js <code>Buffer</code>s, although it takes\ndifferent function arguments.</p>\n<pre><code class=\"language-js\">// Create two `Buffer` instances.\nconst buf1 = Buffer.allocUnsafe(26);\nconst buf2 = Buffer.allocUnsafe(26).fill('!');\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf1[i] = i + 97;\n}\n\n// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.\nbuf1.copy(buf2, 8, 16, 20);\n// This is equivalent to:\n// buf2.set(buf1.subarray(16, 20), 8);\n\nconsole.log(buf2.toString('ascii', 0, 25));\n// Prints: !!!!!!!!qrst!!!!!!!!!!!!!\n</code></pre>\n<pre><code class=\"language-js\">// Create a `Buffer` and copy data from one region to an overlapping region\n// within the same `Buffer`.\n\nconst buf = Buffer.allocUnsafe(26);\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf[i] = i + 97;\n}\n\nbuf.copy(buf, 0, 4, 10);\n\nconsole.log(buf.toString());\n// Prints: efghijghijklmnopqrstuvwxyz\n</code></pre>"
             },
             {
               "textRaw": "`buf.entries()`",
@@ -14531,7 +15656,10 @@
                     "description": "The `value` can now be a `Uint8Array`."
                   },
                   {
-                    "version": "v5.7.0, v4.4.0",
+                    "version": [
+                      "v5.7.0",
+                      "v4.4.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/4803",
                     "description": "When `encoding` is being passed, the `byteOffset` parameter is no longer required."
                   }
@@ -14569,7 +15697,7 @@
                   ]
                 }
               ],
-              "desc": "<p>If <code>value</code> is:</p>\n<ul>\n<li>a string, <code>value</code> is interpreted according to the character encoding in\n<code>encoding</code>.</li>\n<li>a <code>Buffer</code> or <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>, <code>value</code> will be used in its entirety.\nTo compare a partial <code>Buffer</code>, use <a href=\"buffer.html#buffer_buf_slice_start_end\"><code>buf.slice()</code></a>.</li>\n<li>a number, <code>value</code> will be interpreted as an unsigned 8-bit integer\nvalue between <code>0</code> and <code>255</code>.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from('this is a buffer');\n\nconsole.log(buf.indexOf('this'));\n// Prints: 0\nconsole.log(buf.indexOf('is'));\n// Prints: 2\nconsole.log(buf.indexOf(Buffer.from('a buffer')));\n// Prints: 8\nconsole.log(buf.indexOf(97));\n// Prints: 8 (97 is the decimal ASCII value for 'a')\nconsole.log(buf.indexOf(Buffer.from('a buffer example')));\n// Prints: -1\nconsole.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));\n// Prints: 8\n\nconst utf16Buffer = Buffer.from('\\u039a\\u0391\\u03a3\\u03a3\\u0395', 'utf16le');\n\nconsole.log(utf16Buffer.indexOf('\\u03a3', 0, 'utf16le'));\n// Prints: 4\nconsole.log(utf16Buffer.indexOf('\\u03a3', -4, 'utf16le'));\n// Prints: 6\n</code></pre>\n<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a\n<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,\nan integer between 0 and 255.</p>\n<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. If the result\nof coercion is <code>NaN</code> or <code>0</code>, then the entire buffer will be searched. This\nbehavior matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf\"><code>String#indexOf()</code></a>.</p>\n<pre><code class=\"language-js\">const b = Buffer.from('abcdef');\n\n// Passing a value that's a number, but not a valid byte.\n// Prints: 2, equivalent to searching for 99 or 'c'.\nconsole.log(b.indexOf(99.9));\nconsole.log(b.indexOf(256 + 99));\n\n// Passing a byteOffset that coerces to NaN or 0.\n// Prints: 1, searching the whole buffer.\nconsole.log(b.indexOf('b', undefined));\nconsole.log(b.indexOf('b', {}));\nconsole.log(b.indexOf('b', null));\nconsole.log(b.indexOf('b', []));\n</code></pre>\n<p>If <code>value</code> is an empty string or empty <code>Buffer</code> and <code>byteOffset</code> is less\nthan <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code>value</code> is empty and\n<code>byteOffset</code> is at least <code>buf.length</code>, <code>buf.length</code> will be returned.</p>"
+              "desc": "<p>If <code>value</code> is:</p>\n<ul>\n<li>a string, <code>value</code> is interpreted according to the character encoding in\n<code>encoding</code>.</li>\n<li>a <code>Buffer</code> or <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>, <code>value</code> will be used in its entirety.\nTo compare a partial <code>Buffer</code>, use <a href=\"buffer.html#buffer_buf_slice_start_end\"><code>buf.slice()</code></a>.</li>\n<li>a number, <code>value</code> will be interpreted as an unsigned 8-bit integer\nvalue between <code>0</code> and <code>255</code>.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from('this is a buffer');\n\nconsole.log(buf.indexOf('this'));\n// Prints: 0\nconsole.log(buf.indexOf('is'));\n// Prints: 2\nconsole.log(buf.indexOf(Buffer.from('a buffer')));\n// Prints: 8\nconsole.log(buf.indexOf(97));\n// Prints: 8 (97 is the decimal ASCII value for 'a')\nconsole.log(buf.indexOf(Buffer.from('a buffer example')));\n// Prints: -1\nconsole.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));\n// Prints: 8\n\nconst utf16Buffer = Buffer.from('\\u039a\\u0391\\u03a3\\u03a3\\u0395', 'utf16le');\n\nconsole.log(utf16Buffer.indexOf('\\u03a3', 0, 'utf16le'));\n// Prints: 4\nconsole.log(utf16Buffer.indexOf('\\u03a3', -4, 'utf16le'));\n// Prints: 6\n</code></pre>\n<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a\n<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,\nan integer between 0 and 255.</p>\n<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. If the result\nof coercion is <code>NaN</code> or <code>0</code>, then the entire buffer will be searched. This\nbehavior matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf\"><code>String.prototype.indexOf()</code></a>.</p>\n<pre><code class=\"language-js\">const b = Buffer.from('abcdef');\n\n// Passing a value that's a number, but not a valid byte.\n// Prints: 2, equivalent to searching for 99 or 'c'.\nconsole.log(b.indexOf(99.9));\nconsole.log(b.indexOf(256 + 99));\n\n// Passing a byteOffset that coerces to NaN or 0.\n// Prints: 1, searching the whole buffer.\nconsole.log(b.indexOf('b', undefined));\nconsole.log(b.indexOf('b', {}));\nconsole.log(b.indexOf('b', null));\nconsole.log(b.indexOf('b', []));\n</code></pre>\n<p>If <code>value</code> is an empty string or empty <code>Buffer</code> and <code>byteOffset</code> is less\nthan <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code>value</code> is empty and\n<code>byteOffset</code> is at least <code>buf.length</code>, <code>buf.length</code> will be returned.</p>"
             },
             {
               "textRaw": "`buf.keys()`",
@@ -14641,7 +15769,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Identical to <a href=\"buffer.html#buffer_buf_indexof_value_byteoffset_encoding\"><code>buf.indexOf()</code></a>, except the last occurrence of <code>value</code> is found\nrather than the first occurrence.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('this buffer is a buffer');\n\nconsole.log(buf.lastIndexOf('this'));\n// Prints: 0\nconsole.log(buf.lastIndexOf('buffer'));\n// Prints: 17\nconsole.log(buf.lastIndexOf(Buffer.from('buffer')));\n// Prints: 17\nconsole.log(buf.lastIndexOf(97));\n// Prints: 15 (97 is the decimal ASCII value for 'a')\nconsole.log(buf.lastIndexOf(Buffer.from('yolo')));\n// Prints: -1\nconsole.log(buf.lastIndexOf('buffer', 5));\n// Prints: 5\nconsole.log(buf.lastIndexOf('buffer', 4));\n// Prints: -1\n\nconst utf16Buffer = Buffer.from('\\u039a\\u0391\\u03a3\\u03a3\\u0395', 'utf16le');\n\nconsole.log(utf16Buffer.lastIndexOf('\\u03a3', undefined, 'utf16le'));\n// Prints: 6\nconsole.log(utf16Buffer.lastIndexOf('\\u03a3', -5, 'utf16le'));\n// Prints: 4\n</code></pre>\n<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a\n<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,\nan integer between 0 and 255.</p>\n<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. Any arguments\nthat coerce to <code>NaN</code>, like <code>{}</code> or <code>undefined</code>, will search the whole buffer.\nThis behavior matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf\"><code>String#lastIndexOf()</code></a>.</p>\n<pre><code class=\"language-js\">const b = Buffer.from('abcdef');\n\n// Passing a value that's a number, but not a valid byte.\n// Prints: 2, equivalent to searching for 99 or 'c'.\nconsole.log(b.lastIndexOf(99.9));\nconsole.log(b.lastIndexOf(256 + 99));\n\n// Passing a byteOffset that coerces to NaN.\n// Prints: 1, searching the whole buffer.\nconsole.log(b.lastIndexOf('b', undefined));\nconsole.log(b.lastIndexOf('b', {}));\n\n// Passing a byteOffset that coerces to 0.\n// Prints: -1, equivalent to passing 0.\nconsole.log(b.lastIndexOf('b', null));\nconsole.log(b.lastIndexOf('b', []));\n</code></pre>\n<p>If <code>value</code> is an empty string or empty <code>Buffer</code>, <code>byteOffset</code> will be returned.</p>"
+              "desc": "<p>Identical to <a href=\"buffer.html#buffer_buf_indexof_value_byteoffset_encoding\"><code>buf.indexOf()</code></a>, except the last occurrence of <code>value</code> is found\nrather than the first occurrence.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('this buffer is a buffer');\n\nconsole.log(buf.lastIndexOf('this'));\n// Prints: 0\nconsole.log(buf.lastIndexOf('buffer'));\n// Prints: 17\nconsole.log(buf.lastIndexOf(Buffer.from('buffer')));\n// Prints: 17\nconsole.log(buf.lastIndexOf(97));\n// Prints: 15 (97 is the decimal ASCII value for 'a')\nconsole.log(buf.lastIndexOf(Buffer.from('yolo')));\n// Prints: -1\nconsole.log(buf.lastIndexOf('buffer', 5));\n// Prints: 5\nconsole.log(buf.lastIndexOf('buffer', 4));\n// Prints: -1\n\nconst utf16Buffer = Buffer.from('\\u039a\\u0391\\u03a3\\u03a3\\u0395', 'utf16le');\n\nconsole.log(utf16Buffer.lastIndexOf('\\u03a3', undefined, 'utf16le'));\n// Prints: 6\nconsole.log(utf16Buffer.lastIndexOf('\\u03a3', -5, 'utf16le'));\n// Prints: 4\n</code></pre>\n<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a\n<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,\nan integer between 0 and 255.</p>\n<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. Any arguments\nthat coerce to <code>NaN</code>, like <code>{}</code> or <code>undefined</code>, will search the whole buffer.\nThis behavior matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf\"><code>String.prototype.lastIndexOf()</code></a>.</p>\n<pre><code class=\"language-js\">const b = Buffer.from('abcdef');\n\n// Passing a value that's a number, but not a valid byte.\n// Prints: 2, equivalent to searching for 99 or 'c'.\nconsole.log(b.lastIndexOf(99.9));\nconsole.log(b.lastIndexOf(256 + 99));\n\n// Passing a byteOffset that coerces to NaN.\n// Prints: 1, searching the whole buffer.\nconsole.log(b.lastIndexOf('b', undefined));\nconsole.log(b.lastIndexOf('b', {}));\n\n// Passing a byteOffset that coerces to 0.\n// Prints: -1, equivalent to passing 0.\nconsole.log(b.lastIndexOf('b', null));\nconsole.log(b.lastIndexOf('b', []));\n</code></pre>\n<p>If <code>value</code> is an empty string or empty <code>Buffer</code>, <code>byteOffset</code> will be returned.</p>"
             },
             {
               "textRaw": "`buf.readBigInt64BE([offset])`",
@@ -14680,7 +15808,8 @@
               "name": "readBigInt64LE",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -14710,11 +15839,12 @@
               "name": "readBigUInt64BE",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34960",
                     "description": "This function is also available as `buf.readBigUint64BE()`."
                   }
@@ -14738,7 +15868,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, big-endian 64-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);\n\nconsole.log(buf.readBigUInt64BE(0));\n// Prints: 4294967295n\n</code></pre>"
+              "desc": "<p>Reads an unsigned, big-endian 64-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readBigUint64BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);\n\nconsole.log(buf.readBigUInt64BE(0));\n// Prints: 4294967295n\n</code></pre>"
             },
             {
               "textRaw": "`buf.readBigUInt64LE([offset])`",
@@ -14751,7 +15881,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": [
+                      "v14.10.0",
+                      "v12.19.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/34960",
                     "description": "This function is also available as `buf.readBigUint64LE()`."
                   }
@@ -14775,7 +15908,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, little-endian 64-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);\n\nconsole.log(buf.readBigUInt64LE(0));\n// Prints: 18446744069414584320n\n</code></pre>"
+              "desc": "<p>Reads an unsigned, little-endian 64-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readBigUint64LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);\n\nconsole.log(buf.readBigUInt64LE(0));\n// Prints: 18446744069414584320n\n</code></pre>"
             },
             {
               "textRaw": "`buf.readDoubleBE([offset])`",
@@ -15193,7 +16326,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint8()`."
                   },
@@ -15222,7 +16355,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([1, -2]);\n\nconsole.log(buf.readUInt8(0));\n// Prints: 1\nconsole.log(buf.readUInt8(1));\n// Prints: 254\nconsole.log(buf.readUInt8(2));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
+              "desc": "<p>Reads an unsigned 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>\n<p>This function is also available under the <code>readUint8</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([1, -2]);\n\nconsole.log(buf.readUInt8(0));\n// Prints: 1\nconsole.log(buf.readUInt8(1));\n// Prints: 254\nconsole.log(buf.readUInt8(2));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUInt16BE([offset])`",
@@ -15234,7 +16367,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint16BE()`."
                   },
@@ -15263,7 +16396,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, big-endian 16-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56]);\n\nconsole.log(buf.readUInt16BE(0).toString(16));\n// Prints: 1234\nconsole.log(buf.readUInt16BE(1).toString(16));\n// Prints: 3456\n</code></pre>"
+              "desc": "<p>Reads an unsigned, big-endian 16-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readUint16BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56]);\n\nconsole.log(buf.readUInt16BE(0).toString(16));\n// Prints: 1234\nconsole.log(buf.readUInt16BE(1).toString(16));\n// Prints: 3456\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUInt16LE([offset])`",
@@ -15275,7 +16408,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint16LE()`."
                   },
@@ -15304,7 +16437,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, little-endian 16-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56]);\n\nconsole.log(buf.readUInt16LE(0).toString(16));\n// Prints: 3412\nconsole.log(buf.readUInt16LE(1).toString(16));\n// Prints: 5634\nconsole.log(buf.readUInt16LE(2).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
+              "desc": "<p>Reads an unsigned, little-endian 16-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readUint16LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56]);\n\nconsole.log(buf.readUInt16LE(0).toString(16));\n// Prints: 3412\nconsole.log(buf.readUInt16LE(1).toString(16));\n// Prints: 5634\nconsole.log(buf.readUInt16LE(2).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUInt32BE([offset])`",
@@ -15316,7 +16449,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint32BE()`."
                   },
@@ -15345,7 +16478,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, big-endian 32-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);\n\nconsole.log(buf.readUInt32BE(0).toString(16));\n// Prints: 12345678\n</code></pre>"
+              "desc": "<p>Reads an unsigned, big-endian 32-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readUint32BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);\n\nconsole.log(buf.readUInt32BE(0).toString(16));\n// Prints: 12345678\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUInt32LE([offset])`",
@@ -15357,7 +16490,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint32LE()`."
                   },
@@ -15386,7 +16519,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, little-endian 32-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);\n\nconsole.log(buf.readUInt32LE(0).toString(16));\n// Prints: 78563412\nconsole.log(buf.readUInt32LE(1).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
+              "desc": "<p>Reads an unsigned, little-endian 32-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readUint32LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);\n\nconsole.log(buf.readUInt32LE(0).toString(16));\n// Prints: 78563412\nconsole.log(buf.readUInt32LE(1).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUIntBE(offset, byteLength)`",
@@ -15398,7 +16531,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUintBE()`."
                   },
@@ -15432,7 +16565,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>\nand interprets the result as an unsigned big-endian integer supporting\nup to 48 bits of accuracy.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);\n\nconsole.log(buf.readUIntBE(0, 6).toString(16));\n// Prints: 1234567890ab\nconsole.log(buf.readUIntBE(1, 6).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
+              "desc": "<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>\nand interprets the result as an unsigned big-endian integer supporting\nup to 48 bits of accuracy.</p>\n<p>This function is also available under the <code>readUintBE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);\n\nconsole.log(buf.readUIntBE(0, 6).toString(16));\n// Prints: 1234567890ab\nconsole.log(buf.readUIntBE(1, 6).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUIntLE(offset, byteLength)`",
@@ -15444,7 +16577,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUintLE()`."
                   },
@@ -15478,7 +16611,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>\nand interprets the result as an unsigned, little-endian integer supporting\nup to 48 bits of accuracy.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);\n\nconsole.log(buf.readUIntLE(0, 6).toString(16));\n// Prints: ab9078563412\n</code></pre>"
+              "desc": "<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>\nand interprets the result as an unsigned, little-endian integer supporting\nup to 48 bits of accuracy.</p>\n<p>This function is also available under the <code>readUintLE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);\n\nconsole.log(buf.readUIntLE(0, 6).toString(16));\n// Prints: ab9078563412\n</code></pre>"
             },
             {
               "textRaw": "`buf.subarray([start[, end]])`",
@@ -15515,7 +16648,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a new <code>Buffer</code> that references the same memory as the original, but\noffset and cropped by the <code>start</code> and <code>end</code> indices.</p>\n<p>Specifying <code>end</code> greater than <a href=\"buffer.html#buffer_buf_length\"><code>buf.length</code></a> will return the same result as\nthat of <code>end</code> equal to <a href=\"buffer.html#buffer_buf_length\"><code>buf.length</code></a>.</p>\n<p>This method is inherited from <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\"><code>TypedArray#subarray()</code></a>.</p>\n<p>Modifying the new <code>Buffer</code> slice will modify the memory in the original <code>Buffer</code>\nbecause the allocated memory of the two objects overlap.</p>\n<pre><code class=\"language-js\">// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte\n// from the original `Buffer`.\n\nconst buf1 = Buffer.allocUnsafe(26);\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf1[i] = i + 97;\n}\n\nconst buf2 = buf1.subarray(0, 3);\n\nconsole.log(buf2.toString('ascii', 0, buf2.length));\n// Prints: abc\n\nbuf1[0] = 33;\n\nconsole.log(buf2.toString('ascii', 0, buf2.length));\n// Prints: !bc\n</code></pre>\n<p>Specifying negative indexes causes the slice to be generated relative to the\nend of <code>buf</code> rather than the beginning.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('buffer');\n\nconsole.log(buf.subarray(-6, -1).toString());\n// Prints: buffe\n// (Equivalent to buf.subarray(0, 5).)\n\nconsole.log(buf.subarray(-6, -2).toString());\n// Prints: buff\n// (Equivalent to buf.subarray(0, 4).)\n\nconsole.log(buf.subarray(-5, -2).toString());\n// Prints: uff\n// (Equivalent to buf.subarray(1, 4).)\n</code></pre>"
+              "desc": "<p>Returns a new <code>Buffer</code> that references the same memory as the original, but\noffset and cropped by the <code>start</code> and <code>end</code> indices.</p>\n<p>Specifying <code>end</code> greater than <a href=\"buffer.html#buffer_buf_length\"><code>buf.length</code></a> will return the same result as\nthat of <code>end</code> equal to <a href=\"buffer.html#buffer_buf_length\"><code>buf.length</code></a>.</p>\n<p>This method is inherited from <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\"><code>TypedArray.prototype.subarray()</code></a>.</p>\n<p>Modifying the new <code>Buffer</code> slice will modify the memory in the original <code>Buffer</code>\nbecause the allocated memory of the two objects overlap.</p>\n<pre><code class=\"language-js\">// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte\n// from the original `Buffer`.\n\nconst buf1 = Buffer.allocUnsafe(26);\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf1[i] = i + 97;\n}\n\nconst buf2 = buf1.subarray(0, 3);\n\nconsole.log(buf2.toString('ascii', 0, buf2.length));\n// Prints: abc\n\nbuf1[0] = 33;\n\nconsole.log(buf2.toString('ascii', 0, buf2.length));\n// Prints: !bc\n</code></pre>\n<p>Specifying negative indexes causes the slice to be generated relative to the\nend of <code>buf</code> rather than the beginning.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('buffer');\n\nconsole.log(buf.subarray(-6, -1).toString());\n// Prints: buffe\n// (Equivalent to buf.subarray(0, 5).)\n\nconsole.log(buf.subarray(-6, -2).toString());\n// Prints: buff\n// (Equivalent to buf.subarray(0, 4).)\n\nconsole.log(buf.subarray(-5, -2).toString());\n// Prints: uff\n// (Equivalent to buf.subarray(1, 4).)\n</code></pre>"
             },
             {
               "textRaw": "`buf.slice([start[, end]])`",
@@ -15527,7 +16660,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v7.1.0, v6.9.2",
+                    "version": [
+                      "v7.1.0",
+                      "v6.9.2"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/9341",
                     "description": "Coercing the offsets to integers now handles values outside the 32-bit integer range properly."
                   },
@@ -15779,7 +16915,8 @@
               "name": "writeBigInt64BE",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -15859,7 +16996,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34960",
                     "description": "This function is also available as `buf.writeBigUint64BE()`."
                   }
@@ -15890,7 +17027,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(8);\n\nbuf.writeBigUInt64BE(0xdecafafecacefaden, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de ca fa fe ca ce fa de>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>\n<p>This function is also available under the <code>writeBigUint64BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(8);\n\nbuf.writeBigUInt64BE(0xdecafafecacefaden, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de ca fa fe ca ce fa de>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeBigUInt64LE(value[, offset])`",
@@ -15898,11 +17035,12 @@
               "name": "writeBigUInt64LE",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34960",
                     "description": "This function is also available as `buf.writeBigUint64LE()`."
                   }
@@ -15933,7 +17071,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(8);\n\nbuf.writeBigUInt64LE(0xdecafafecacefaden, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de fa ce ca fe fa ca de>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(8);\n\nbuf.writeBigUInt64LE(0xdecafafecacefaden, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de fa ce ca fe fa ca de>\n</code></pre>\n<p>This function is also available under the <code>writeBigUint64LE</code> alias.</p>"
             },
             {
               "textRaw": "`buf.writeDoubleBE(value[, offset])`",
@@ -16062,7 +17200,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. Behavior is\nundefined when <code>value</code> is anything other than a JavaScript number.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeFloatBE(0xcafebabe, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 4f 4a fe bb>\n\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. Behavior is\nundefined when <code>value</code> is anything other than a JavaScript number.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeFloatBE(0xcafebabe, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 4f 4a fe bb>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeFloatLE(value[, offset])`",
@@ -16368,7 +17506,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when\n<code>value</code> is anything other than a signed integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeIntBE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 12 34 56 78 90 ab>\n\n</code></pre>"
+              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when\n<code>value</code> is anything other than a signed integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeIntBE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 12 34 56 78 90 ab>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeIntLE(value, offset, byteLength)`",
@@ -16428,7 +17566,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint8()`."
                   },
@@ -16464,7 +17602,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code>. <code>value</code> must be a\nvalid unsigned 8-bit integer. Behavior is undefined when <code>value</code> is anything\nother than an unsigned 8-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt8(0x3, 0);\nbuf.writeUInt8(0x4, 1);\nbuf.writeUInt8(0x23, 2);\nbuf.writeUInt8(0x42, 3);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 03 04 23 42>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code>. <code>value</code> must be a\nvalid unsigned 8-bit integer. Behavior is undefined when <code>value</code> is anything\nother than an unsigned 8-bit integer.</p>\n<p>This function is also available under the <code>writeUint8</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt8(0x3, 0);\nbuf.writeUInt8(0x4, 1);\nbuf.writeUInt8(0x23, 2);\nbuf.writeUInt8(0x42, 3);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 03 04 23 42>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUInt16BE(value[, offset])`",
@@ -16476,7 +17614,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint16BE()`."
                   },
@@ -16512,7 +17650,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>\nmust be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code>\nis anything other than an unsigned 16-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt16BE(0xdead, 0);\nbuf.writeUInt16BE(0xbeef, 2);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de ad be ef>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>\nmust be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code>\nis anything other than an unsigned 16-bit integer.</p>\n<p>This function is also available under the <code>writeUint16BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt16BE(0xdead, 0);\nbuf.writeUInt16BE(0xbeef, 2);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de ad be ef>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUInt16LE(value[, offset])`",
@@ -16524,7 +17662,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": [
+                      "v14.9.0",
+                      "v12.19.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint16LE()`."
                   },
@@ -16560,7 +17701,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>\nmust be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code> is\nanything other than an unsigned 16-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt16LE(0xdead, 0);\nbuf.writeUInt16LE(0xbeef, 2);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ad de ef be>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>\nmust be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code> is\nanything other than an unsigned 16-bit integer.</p>\n<p>This function is also available under the <code>writeUint16LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt16LE(0xdead, 0);\nbuf.writeUInt16LE(0xbeef, 2);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ad de ef be>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUInt32BE(value[, offset])`",
@@ -16572,7 +17713,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint32BE()`."
                   },
@@ -16608,7 +17749,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>\nmust be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code>\nis anything other than an unsigned 32-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt32BE(0xfeedface, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer fe ed fa ce>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>\nmust be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code>\nis anything other than an unsigned 32-bit integer.</p>\n<p>This function is also available under the <code>writeUint32BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt32BE(0xfeedface, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer fe ed fa ce>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUInt32LE(value[, offset])`",
@@ -16620,7 +17761,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint32LE()`."
                   },
@@ -16656,7 +17797,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>\nmust be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code> is\nanything other than an unsigned 32-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt32LE(0xfeedface, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ce fa ed fe>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>\nmust be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code> is\nanything other than an unsigned 32-bit integer.</p>\n<p>This function is also available under the <code>writeUint32LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt32LE(0xfeedface, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ce fa ed fe>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUIntBE(value, offset, byteLength)`",
@@ -16668,7 +17809,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUintBE()`."
                   },
@@ -16709,7 +17850,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined\nwhen <code>value</code> is anything other than an unsigned integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeUIntBE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 12 34 56 78 90 ab>\n</code></pre>"
+              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined\nwhen <code>value</code> is anything other than an unsigned integer.</p>\n<p>This function is also available under the <code>writeUintBE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeUIntBE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 12 34 56 78 90 ab>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUIntLE(value, offset, byteLength)`",
@@ -16721,7 +17862,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUintLE()`."
                   },
@@ -16762,7 +17903,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas little-endian. Supports up to 48 bits of accuracy. Behavior is undefined\nwhen <code>value</code> is anything other than an unsigned integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeUIntLE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ab 90 78 56 34 12>\n</code></pre>"
+              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas little-endian. Supports up to 48 bits of accuracy. Behavior is undefined\nwhen <code>value</code> is anything other than an unsigned integer.</p>\n<p>This function is also available under the <code>writeUintLE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeUIntLE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ab 90 78 56 34 12>\n</code></pre>"
             }
           ],
           "signatures": [
@@ -16846,13 +17987,14 @@
         }
       ],
       "type": "module",
-      "displayName": "Buffer"
+      "displayName": "Buffer",
+      "source": "doc/api/buffer.md"
     },
     {
-      "textRaw": "C++ Embedder API",
+      "textRaw": "C++ embedder API",
       "name": "c++_embedder_api",
-      "introduced_in": "v12.19.0",
-      "desc": "<p>Node.js provides a number of C++ APIs that can be used to execute JavaScript\nin a Node.js environment from other C++ software.</p>\n<p>The documentation for these APIs can be found in <a href=\"https://github.com/nodejs/node/blob/master/src/node.h\">src/node.h</a> in the Node.js\nsource tree. In addition to the APIs exposed by Node.js, some required concepts\nare provided by the V8 embedder API.</p>\n<p>Because using Node.js as an embedded library is different from writing code\nthat is executed by Node.js, breaking changes do not follow typical Node.js\n<a href=\"deprecations.html\">deprecation policy</a> and may occur on each semver-major release without prior\nwarning.</p>\n<h2>Example embedding application</h2>\n<p>The following sections will provide an overview over how to use these APIs\nto create an application from scratch that will perform the equivalent of\n<code>node -e &#x3C;code></code>, i.e. that will take a piece of JavaScript and run it in\na Node.js-specific environment.</p>\n<p>The full code can be found <a href=\"https://github.com/nodejs/node/blob/master/test/embedding/embedtest.cc\">in the Node.js source tree</a>.</p>",
+      "introduced_in": "v14.0.0",
+      "desc": "<p>Node.js provides a number of C++ APIs that can be used to execute JavaScript\nin a Node.js environment from other C++ software.</p>\n<p>The documentation for these APIs can be found in <a href=\"https://github.com/nodejs/node/blob/HEAD/src/node.h\">src/node.h</a> in the Node.js\nsource tree. In addition to the APIs exposed by Node.js, some required concepts\nare provided by the V8 embedder API.</p>\n<p>Because using Node.js as an embedded library is different from writing code\nthat is executed by Node.js, breaking changes do not follow typical Node.js\n<a href=\"deprecations.html\">deprecation policy</a> and may occur on each semver-major release without prior\nwarning.</p>\n<h2>Example embedding application</h2>\n<p>The following sections will provide an overview over how to use these APIs\nto create an application from scratch that will perform the equivalent of\n<code>node -e &#x3C;code></code>, i.e. that will take a piece of JavaScript and run it in\na Node.js-specific environment.</p>\n<p>The full code can be found <a href=\"https://github.com/nodejs/node/blob/HEAD/test/embedding/embedtest.cc\">in the Node.js source tree</a>.</p>",
       "modules": [
         {
           "textRaw": "Setting up per-process state",
@@ -16864,13 +18006,14 @@
         {
           "textRaw": "Per-instance state",
           "name": "per-instance_state",
-          "desc": "<p>Node.js has a concept of a “Node.js instance”, that is commonly being referred\nto as <code>node::Environment</code>. Each <code>node::Environment</code> is associated with:</p>\n<ul>\n<li>Exactly one <code>v8::Isolate</code>, i.e. one JS Engine instance,</li>\n<li>Exactly one <code>uv_loop_t</code>, i.e. one event loop, and</li>\n<li>A number of <code>v8::Context</code>s, but exactly one main <code>v8::Context</code>.</li>\n<li>One <code>node::IsolateData</code> instance that contains information that could be\nshared by multiple <code>node::Environment</code>s that use the same <code>v8::Isolate</code>.\nCurrently, no testing if performed for this scenario.</li>\n</ul>\n<p>In order to set up a <code>v8::Isolate</code>, an <code>v8::ArrayBuffer::Allocator</code> needs\nto be provided. One possible choice is the default Node.js allocator, which\ncan be created through <code>node::ArrayBufferAllocator::Create()</code>. Using the Node.js\nallocator allows minor performance optimizations when addons use the Node.js\nC++ <code>Buffer</code> API, and is required in order to track <code>ArrayBuffer</code> memory in\n<a href=\"process.html#process_process_memoryusage\"><code>process.memoryUsage()</code></a>.</p>\n<p>Additionally, each <code>v8::Isolate</code> that is used for a Node.js instance needs to\nbe registered and unregistered with the <code>MultiIsolatePlatform</code> instance, if one\nis being used, in order for the platform to know which event loop to use\nfor tasks scheduled by the <code>v8::Isolate</code>.</p>\n<p>The <code>node::NewIsolate()</code> helper function creates a <code>v8::Isolate</code>,\nsets it up with some Node.js-specific hooks (e.g. the Node.js error handler),\nand registers it with the platform automatically.</p>\n<pre><code class=\"language-cpp\">int RunNodeInstance(MultiIsolatePlatform* platform,\n                    const std::vector&#x3C;std::string>&#x26; args,\n                    const std::vector&#x3C;std::string>&#x26; exec_args) {\n  int exit_code = 0;\n  // Set up a libuv event loop.\n  uv_loop_t loop;\n  int ret = uv_loop_init(&#x26;loop);\n  if (ret != 0) {\n    fprintf(stderr, \"%s: Failed to initialize loop: %s\\n\",\n            args[0].c_str(),\n            uv_err_name(ret));\n    return 1;\n  }\n\n  std::shared_ptr&#x3C;ArrayBufferAllocator> allocator =\n      ArrayBufferAllocator::Create();\n\n  Isolate* isolate = NewIsolate(allocator, &#x26;loop, platform);\n  if (isolate == nullptr) {\n    fprintf(stderr, \"%s: Failed to initialize V8 Isolate\\n\", args[0].c_str());\n    return 1;\n  }\n\n  {\n    Locker locker(isolate);\n    Isolate::Scope isolate_scope(isolate);\n\n    // Create a node::IsolateData instance that will later be released using\n    // node::FreeIsolateData().\n    std::unique_ptr&#x3C;IsolateData, decltype(&#x26;node::FreeIsolateData)> isolate_data(\n        node::CreateIsolateData(isolate, &#x26;loop, platform, allocator.get()),\n        node::FreeIsolateData);\n\n    // Set up a new v8::Context.\n    HandleScope handle_scope(isolate);\n    Local&#x3C;Context> context = node::NewContext(isolate);\n    if (context.IsEmpty()) {\n      fprintf(stderr, \"%s: Failed to initialize V8 Context\\n\", args[0].c_str());\n      return 1;\n    }\n\n    // The v8::Context needs to be entered when node::CreateEnvironment() and\n    // node::LoadEnvironment() are being called.\n    Context::Scope context_scope(context);\n\n    // Create a node::Environment instance that will later be released using\n    // node::FreeEnvironment().\n    std::unique_ptr&#x3C;Environment, decltype(&#x26;node::FreeEnvironment)> env(\n        node::CreateEnvironment(isolate_data.get(), context, args, exec_args),\n        node::FreeEnvironment);\n\n    // Set up the Node.js instance for execution, and run code inside of it.\n    // There is also a variant that takes a callback and provides it with\n    // the `require` and `process` objects, so that it can manually compile\n    // and run scripts as needed.\n    // The `require` function inside this script does *not* access the file\n    // system, and can only load built-in Node.js modules.\n    // `module.createRequire()` is being used to create one that is able to\n    // load files from the disk, and uses the standard CommonJS file loader\n    // instead of the internal-only `require` function.\n    MaybeLocal&#x3C;Value> loadenv_ret = node::LoadEnvironment(\n        env.get(),\n        \"const publicRequire =\"\n        \"  require('module').createRequire(process.cwd() + '/');\"\n        \"globalThis.require = publicRequire;\"\n        \"require('vm').runInThisContext(process.argv[1]);\");\n\n    if (loadenv_ret.IsEmpty())  // There has been a JS exception.\n      return 1;\n\n    {\n      // SealHandleScope protects against handle leaks from callbacks.\n      SealHandleScope seal(isolate);\n      bool more;\n      do {\n        uv_run(&#x26;loop, UV_RUN_DEFAULT);\n\n        // V8 tasks on background threads may end up scheduling new tasks in the\n        // foreground, which in turn can keep the event loop going. For example,\n        // WebAssembly.compile() may do so.\n        platform->DrainTasks(isolate);\n\n        // If there are new tasks, continue.\n        more = uv_loop_alive(&#x26;loop);\n        if (more) continue;\n\n        // node::EmitBeforeExit() is used to emit the 'beforeExit' event on\n        // the `process` object.\n        node::EmitBeforeExit(env.get());\n\n        // 'beforeExit' can also schedule new work that keeps the event loop\n        // running.\n        more = uv_loop_alive(&#x26;loop);\n      } while (more == true);\n    }\n\n    // node::EmitExit() returns the current exit code.\n    exit_code = node::EmitExit(env.get());\n\n    // node::Stop() can be used to explicitly stop the event loop and keep\n    // further JavaScript from running. It can be called from any thread,\n    // and will act like worker.terminate() if called from another thread.\n    node::Stop(env.get());\n  }\n\n  // Unregister the Isolate with the platform and add a listener that is called\n  // when the Platform is done cleaning up any state it had associated with\n  // the Isolate.\n  bool platform_finished = false;\n  platform->AddIsolateFinishedCallback(isolate, [](void* data) {\n    *static_cast&#x3C;bool*>(data) = true;\n  }, &#x26;platform_finished);\n  platform->UnregisterIsolate(isolate);\n  isolate->Dispose();\n\n  // Wait until the platform has cleaned up all relevant resources.\n  while (!platform_finished)\n    uv_run(&#x26;loop, UV_RUN_ONCE);\n  int err = uv_loop_close(&#x26;loop);\n  assert(err == 0);\n\n  return exit_code;\n}\n</code></pre>",
+          "desc": "<p>Node.js has a concept of a “Node.js instance”, that is commonly being referred\nto as <code>node::Environment</code>. Each <code>node::Environment</code> is associated with:</p>\n<ul>\n<li>Exactly one <code>v8::Isolate</code>, i.e. one JS Engine instance,</li>\n<li>Exactly one <code>uv_loop_t</code>, i.e. one event loop, and</li>\n<li>A number of <code>v8::Context</code>s, but exactly one main <code>v8::Context</code>.</li>\n<li>One <code>node::IsolateData</code> instance that contains information that could be\nshared by multiple <code>node::Environment</code>s that use the same <code>v8::Isolate</code>.\nCurrently, no testing if performed for this scenario.</li>\n</ul>\n<p>In order to set up a <code>v8::Isolate</code>, an <code>v8::ArrayBuffer::Allocator</code> needs\nto be provided. One possible choice is the default Node.js allocator, which\ncan be created through <code>node::ArrayBufferAllocator::Create()</code>. Using the Node.js\nallocator allows minor performance optimizations when addons use the Node.js\nC++ <code>Buffer</code> API, and is required in order to track <code>ArrayBuffer</code> memory in\n<a href=\"process.html#process_process_memoryusage\"><code>process.memoryUsage()</code></a>.</p>\n<p>Additionally, each <code>v8::Isolate</code> that is used for a Node.js instance needs to\nbe registered and unregistered with the <code>MultiIsolatePlatform</code> instance, if one\nis being used, in order for the platform to know which event loop to use\nfor tasks scheduled by the <code>v8::Isolate</code>.</p>\n<p>The <code>node::NewIsolate()</code> helper function creates a <code>v8::Isolate</code>,\nsets it up with some Node.js-specific hooks (e.g. the Node.js error handler),\nand registers it with the platform automatically.</p>\n<pre><code class=\"language-cpp\">int RunNodeInstance(MultiIsolatePlatform* platform,\n                    const std::vector&#x3C;std::string>&#x26; args,\n                    const std::vector&#x3C;std::string>&#x26; exec_args) {\n  int exit_code = 0;\n  // Set up a libuv event loop.\n  uv_loop_t loop;\n  int ret = uv_loop_init(&#x26;loop);\n  if (ret != 0) {\n    fprintf(stderr, \"%s: Failed to initialize loop: %s\\n\",\n            args[0].c_str(),\n            uv_err_name(ret));\n    return 1;\n  }\n\n  std::shared_ptr&#x3C;ArrayBufferAllocator> allocator =\n      ArrayBufferAllocator::Create();\n\n  Isolate* isolate = NewIsolate(allocator, &#x26;loop, platform);\n  if (isolate == nullptr) {\n    fprintf(stderr, \"%s: Failed to initialize V8 Isolate\\n\", args[0].c_str());\n    return 1;\n  }\n\n  {\n    Locker locker(isolate);\n    Isolate::Scope isolate_scope(isolate);\n\n    // Create a node::IsolateData instance that will later be released using\n    // node::FreeIsolateData().\n    std::unique_ptr&#x3C;IsolateData, decltype(&#x26;node::FreeIsolateData)> isolate_data(\n        node::CreateIsolateData(isolate, &#x26;loop, platform, allocator.get()),\n        node::FreeIsolateData);\n\n    // Set up a new v8::Context.\n    HandleScope handle_scope(isolate);\n    Local&#x3C;Context> context = node::NewContext(isolate);\n    if (context.IsEmpty()) {\n      fprintf(stderr, \"%s: Failed to initialize V8 Context\\n\", args[0].c_str());\n      return 1;\n    }\n\n    // The v8::Context needs to be entered when node::CreateEnvironment() and\n    // node::LoadEnvironment() are being called.\n    Context::Scope context_scope(context);\n\n    // Create a node::Environment instance that will later be released using\n    // node::FreeEnvironment().\n    std::unique_ptr&#x3C;Environment, decltype(&#x26;node::FreeEnvironment)> env(\n        node::CreateEnvironment(isolate_data.get(), context, args, exec_args),\n        node::FreeEnvironment);\n\n    // Set up the Node.js instance for execution, and run code inside of it.\n    // There is also a variant that takes a callback and provides it with\n    // the `require` and `process` objects, so that it can manually compile\n    // and run scripts as needed.\n    // The `require` function inside this script does *not* access the file\n    // system, and can only load built-in Node.js modules.\n    // `module.createRequire()` is being used to create one that is able to\n    // load files from the disk, and uses the standard CommonJS file loader\n    // instead of the internal-only `require` function.\n    MaybeLocal&#x3C;Value> loadenv_ret = node::LoadEnvironment(\n        env.get(),\n        \"const publicRequire =\"\n        \"  require('module').createRequire(process.cwd() + '/');\"\n        \"globalThis.require = publicRequire;\"\n        \"require('vm').runInThisContext(process.argv[1]);\");\n\n    if (loadenv_ret.IsEmpty())  // There has been a JS exception.\n      return 1;\n\n    {\n      // SealHandleScope protects against handle leaks from callbacks.\n      SealHandleScope seal(isolate);\n      bool more;\n      do {\n        uv_run(&#x26;loop, UV_RUN_DEFAULT);\n\n        // V8 tasks on background threads may end up scheduling new tasks in the\n        // foreground, which in turn can keep the event loop going. For example,\n        // WebAssembly.compile() may do so.\n        platform->DrainTasks(isolate);\n\n        // If there are new tasks, continue.\n        more = uv_loop_alive(&#x26;loop);\n        if (more) continue;\n\n        // node::EmitProcessBeforeExit() is used to emit the 'beforeExit' event\n        // on the `process` object.\n        if (node::EmitProcessBeforeExit(env.get()).IsNothing())\n          break;\n\n        // 'beforeExit' can also schedule new work that keeps the event loop\n        // running.\n        more = uv_loop_alive(&#x26;loop);\n      } while (more == true);\n    }\n\n    // node::EmitProcessExit() returns the current exit code.\n    exit_code = node::EmitProcessExit(env.get()).FromMaybe(1);\n\n    // node::Stop() can be used to explicitly stop the event loop and keep\n    // further JavaScript from running. It can be called from any thread,\n    // and will act like worker.terminate() if called from another thread.\n    node::Stop(env.get());\n  }\n\n  // Unregister the Isolate with the platform and add a listener that is called\n  // when the Platform is done cleaning up any state it had associated with\n  // the Isolate.\n  bool platform_finished = false;\n  platform->AddIsolateFinishedCallback(isolate, [](void* data) {\n    *static_cast&#x3C;bool*>(data) = true;\n  }, &#x26;platform_finished);\n  platform->UnregisterIsolate(isolate);\n  isolate->Dispose();\n\n  // Wait until the platform has cleaned up all relevant resources.\n  while (!platform_finished)\n    uv_run(&#x26;loop, UV_RUN_ONCE);\n  int err = uv_loop_close(&#x26;loop);\n  assert(err == 0);\n\n  return exit_code;\n}\n</code></pre>",
           "type": "module",
           "displayName": "Per-instance state"
         }
       ],
       "type": "module",
-      "displayName": "C++ Embedder API"
+      "displayName": "C++ embedder API",
+      "source": "doc/api/embedding.md"
     },
     {
       "textRaw": "Child process",
@@ -16878,12 +18021,12 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/child_process.js\">lib/child_process.js</a></p>\n<p>The <code>child_process</code> module provides the ability to spawn child processes in\na manner that is similar, but not identical, to <a href=\"http://man7.org/linux/man-pages/man3/popen.3.html\"><code>popen(3)</code></a>. This capability\nis primarily provided by the <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> function:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.stderr.on('data', (data) => {\n  console.error(`stderr: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>\n<p>By default, pipes for <code>stdin</code>, <code>stdout</code>, and <code>stderr</code> are established between\nthe parent Node.js process and the spawned child. These pipes have\nlimited (and platform-specific) capacity. If the child process writes to\nstdout in excess of that limit without the output being captured, the child\nprocess will block waiting for the pipe buffer to accept more data. This is\nidentical to the behavior of pipes in the shell. Use the <code>{ stdio: 'ignore' }</code>\noption if the output will not be consumed.</p>\n<p>The command lookup will be performed using <code>options.env.PATH</code> environment\nvariable if passed in <code>options</code> object, otherwise <code>process.env.PATH</code> will be\nused. To account for the fact that Windows environment variables are\ncase-insensitive Node.js will lexicographically sort all <code>env</code> keys and choose\nthe first one case-insensitively matching <code>PATH</code> to perform command lookup.\nThis may lead to issues on Windows when passing objects to <code>env</code> option that\nhave multiple variants of <code>PATH</code> variable.</p>\n<p>The <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> method spawns the child process asynchronously,\nwithout blocking the Node.js event loop. The <a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>\nfunction provides equivalent functionality in a synchronous manner that blocks\nthe event loop until the spawned process either exits or is terminated.</p>\n<p>For convenience, the <code>child_process</code> module provides a handful of synchronous\nand asynchronous alternatives to <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> and\n<a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>. Each of these alternatives are implemented on\ntop of <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> or <a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>.</p>\n<ul>\n<li><a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>: spawns a shell and runs a command within that\nshell, passing the <code>stdout</code> and <code>stderr</code> to a callback function when\ncomplete.</li>\n<li><a href=\"child_process.html#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a>: similar to <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> except\nthat it spawns the command directly without first spawning a shell by\ndefault.</li>\n<li><a href=\"child_process.html#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>: spawns a new Node.js process and invokes a\nspecified module with an IPC communication channel established that allows\nsending messages between parent and child.</li>\n<li><a href=\"child_process.html#child_process_child_process_execsync_command_options\"><code>child_process.execSync()</code></a>: a synchronous version of\n<a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> that will block the Node.js event loop.</li>\n<li><a href=\"child_process.html#child_process_child_process_execfilesync_file_args_options\"><code>child_process.execFileSync()</code></a>: a synchronous version of\n<a href=\"child_process.html#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> that will block the Node.js event loop.</li>\n</ul>\n<p>For certain use cases, such as automating shell scripts, the\n<a href=\"child_process.html#child_process_synchronous_process_creation\">synchronous counterparts</a> may be more convenient. In many cases, however,\nthe synchronous methods can have significant impact on performance due to\nstalling the event loop while spawned processes complete.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/child_process.js\">lib/child_process.js</a></p>\n<p>The <code>child_process</code> module provides the ability to spawn subprocesses in\na manner that is similar, but not identical, to <a href=\"http://man7.org/linux/man-pages/man3/popen.3.html\"><code>popen(3)</code></a>. This capability\nis primarily provided by the <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> function:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.stderr.on('data', (data) => {\n  console.error(`stderr: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>\n<p>By default, pipes for <code>stdin</code>, <code>stdout</code>, and <code>stderr</code> are established between\nthe parent Node.js process and the spawned subprocess. These pipes have\nlimited (and platform-specific) capacity. If the subprocess writes to\nstdout in excess of that limit without the output being captured, the\nsubprocess blocks waiting for the pipe buffer to accept more data. This is\nidentical to the behavior of pipes in the shell. Use the <code>{ stdio: 'ignore' }</code>\noption if the output will not be consumed.</p>\n<p>The command lookup is performed using the <code>options.env.PATH</code> environment\nvariable if it is in the <code>options</code> object. Otherwise, <code>process.env.PATH</code> is\nused.</p>\n<p>On Windows, environment variables are case-insensitive. Node.js\nlexicographically sorts the <code>env</code> keys and uses the first one that\ncase-insensitively matches. Only first (in lexicographic order) entry will be\npassed to the subprocess. This might lead to issues on Windows when passing\nobjects to the <code>env</code> option that have multiple variants of the same key, such as\n<code>PATH</code> and <code>Path</code>.</p>\n<p>The <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> method spawns the child process asynchronously,\nwithout blocking the Node.js event loop. The <a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>\nfunction provides equivalent functionality in a synchronous manner that blocks\nthe event loop until the spawned process either exits or is terminated.</p>\n<p>For convenience, the <code>child_process</code> module provides a handful of synchronous\nand asynchronous alternatives to <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> and\n<a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>. Each of these alternatives are implemented on\ntop of <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> or <a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>.</p>\n<ul>\n<li><a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>: spawns a shell and runs a command within that\nshell, passing the <code>stdout</code> and <code>stderr</code> to a callback function when\ncomplete.</li>\n<li><a href=\"child_process.html#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a>: similar to <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> except\nthat it spawns the command directly without first spawning a shell by\ndefault.</li>\n<li><a href=\"child_process.html#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>: spawns a new Node.js process and invokes a\nspecified module with an IPC communication channel established that allows\nsending messages between parent and child.</li>\n<li><a href=\"child_process.html#child_process_child_process_execsync_command_options\"><code>child_process.execSync()</code></a>: a synchronous version of\n<a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> that will block the Node.js event loop.</li>\n<li><a href=\"child_process.html#child_process_child_process_execfilesync_file_args_options\"><code>child_process.execFileSync()</code></a>: a synchronous version of\n<a href=\"child_process.html#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> that will block the Node.js event loop.</li>\n</ul>\n<p>For certain use cases, such as automating shell scripts, the\n<a href=\"child_process.html#child_process_synchronous_process_creation\">synchronous counterparts</a> may be more convenient. In many cases, however,\nthe synchronous methods can have significant impact on performance due to\nstalling the event loop while spawned processes complete.</p>",
       "modules": [
         {
           "textRaw": "Asynchronous process creation",
           "name": "asynchronous_process_creation",
-          "desc": "<p>The <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a>, <a href=\"child_process.html#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>, <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>,\nand <a href=\"child_process.html#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> methods all follow the idiomatic asynchronous\nprogramming pattern typical of other Node.js APIs.</p>\n<p>Each of the methods returns a <a href=\"child_process.html#child_process_child_process\"><code>ChildProcess</code></a> instance. These objects\nimplement the Node.js <a href=\"events.html#events_class_eventemitter\"><code>EventEmitter</code></a> API, allowing the parent process to\nregister listener functions that are called when certain events occur during\nthe life cycle of the child process.</p>\n<p>The <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> and <a href=\"child_process.html#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> methods\nadditionally allow for an optional <code>callback</code> function to be specified that is\ninvoked when the child process terminates.</p>",
+          "desc": "<p>The <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a>, <a href=\"child_process.html#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>, <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>,\nand <a href=\"child_process.html#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> methods all follow the idiomatic asynchronous\nprogramming pattern typical of other Node.js APIs.</p>\n<p>Each of the methods returns a <a href=\"child_process.html#child_process_class_childprocess\"><code>ChildProcess</code></a> instance. These objects\nimplement the Node.js <a href=\"events.html#events_class_eventemitter\"><code>EventEmitter</code></a> API, allowing the parent process to\nregister listener functions that are called when certain events occur during\nthe life cycle of the child process.</p>\n<p>The <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> and <a href=\"child_process.html#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> methods\nadditionally allow for an optional <code>callback</code> function to be specified that is\ninvoked when the child process terminates.</p>",
           "modules": [
             {
               "textRaw": "Spawning `.bat` and `.cmd` files on Windows",
@@ -16903,6 +18046,16 @@
                   "v0.1.90"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36308",
+                    "description": "AbortSignal support was added."
+                  },
                   {
                     "version": "v8.8.0",
                     "pr-url": "https://github.com/nodejs/node/pull/15380",
@@ -16930,10 +18083,10 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process. **Default:** `null`.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process. **Default:** `process.cwd()`.",
                           "name": "cwd",
-                          "type": "string",
-                          "default": "`null`",
+                          "type": "string|URL",
+                          "default": "`process.cwd()`",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -16956,6 +18109,12 @@
                           "default": "`'/bin/sh'` on Unix, `process.env.ComSpec` on Windows",
                           "desc": "Shell to execute the command with. See [Shell requirements][] and [Default Windows shell][]."
                         },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting the child process using an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting the child process using an AbortSignal."
+                        },
                         {
                           "textRaw": "`timeout` {number} **Default:** `0`",
                           "name": "timeout",
@@ -17022,7 +18181,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Spawns a shell then executes the <code>command</code> within that shell, buffering any\ngenerated output. The <code>command</code> string passed to the exec function is processed\ndirectly by the shell and special characters (vary based on\n<a href=\"https://en.wikipedia.org/wiki/List_of_command-line_interpreters\">shell</a>)\nneed to be dealt with accordingly:</p>\n<pre><code class=\"language-js\">exec('\"/path/to/test file/test.sh\" arg1 arg2');\n// Double quotes are used so that the space in the path is not interpreted as\n// a delimiter of multiple arguments.\n\nexec('echo \"The \\\\$HOME variable is $HOME\"');\n// The $HOME variable is escaped in the first instance, but not in the second.\n</code></pre>\n<p><strong>Never pass unsanitized user input to this function. Any input containing shell\nmetacharacters may be used to trigger arbitrary command execution.</strong></p>\n<p>If a <code>callback</code> function is provided, it is called with the arguments\n<code>(error, stdout, stderr)</code>. On success, <code>error</code> will be <code>null</code>. On error,\n<code>error</code> will be an instance of <a href=\"errors.html#errors_class_error\"><code>Error</code></a>. The <code>error.code</code> property will be\nthe exit code of the process. By convention, any exit code other than <code>0</code>\nindicates an error. <code>error.signal</code> will be the signal that terminated the\nprocess.</p>\n<p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the\nstdout and stderr output of the child process. By default, Node.js will decode\nthe output as UTF-8 and pass strings to the callback. The <code>encoding</code> option\ncan be used to specify the character encoding used to decode the stdout and\nstderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character\nencoding, <code>Buffer</code> objects will be passed to the callback instead.</p>\n<pre><code class=\"language-js\">const { exec } = require('child_process');\nexec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {\n  if (error) {\n    console.error(`exec error: ${error}`);\n    return;\n  }\n  console.log(`stdout: ${stdout}`);\n  console.error(`stderr: ${stderr}`);\n});\n</code></pre>\n<p>If <code>timeout</code> is greater than <code>0</code>, the parent will send the signal\nidentified by the <code>killSignal</code> property (the default is <code>'SIGTERM'</code>) if the\nchild runs longer than <code>timeout</code> milliseconds.</p>\n<p>Unlike the <a href=\"http://man7.org/linux/man-pages/man3/exec.3.html\"><code>exec(3)</code></a> POSIX system call, <code>child_process.exec()</code> does not replace\nthe existing process and uses a shell to execute the command.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>stdout</code> and <code>stderr</code> properties. The returned\n<code>ChildProcess</code> instance is attached to the <code>Promise</code> as a <code>child</code> property. In\ncase of an error (including any error resulting in an exit code other than 0), a\nrejected promise is returned, with the same <code>error</code> object given in the\ncallback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst exec = util.promisify(require('child_process').exec);\n\nasync function lsExample() {\n  const { stdout, stderr } = await exec('ls');\n  console.log('stdout:', stdout);\n  console.error('stderr:', stderr);\n}\nlsExample();\n</code></pre>"
+              "desc": "<p>Spawns a shell then executes the <code>command</code> within that shell, buffering any\ngenerated output. The <code>command</code> string passed to the exec function is processed\ndirectly by the shell and special characters (vary based on\n<a href=\"https://en.wikipedia.org/wiki/List_of_command-line_interpreters\">shell</a>)\nneed to be dealt with accordingly:</p>\n<pre><code class=\"language-js\">const { exec } = require('child_process');\n\nexec('\"/path/to/test file/test.sh\" arg1 arg2');\n// Double quotes are used so that the space in the path is not interpreted as\n// a delimiter of multiple arguments.\n\nexec('echo \"The \\\\$HOME variable is $HOME\"');\n// The $HOME variable is escaped in the first instance, but not in the second.\n</code></pre>\n<p><strong>Never pass unsanitized user input to this function. Any input containing shell\nmetacharacters may be used to trigger arbitrary command execution.</strong></p>\n<p>If a <code>callback</code> function is provided, it is called with the arguments\n<code>(error, stdout, stderr)</code>. On success, <code>error</code> will be <code>null</code>. On error,\n<code>error</code> will be an instance of <a href=\"errors.html#errors_class_error\"><code>Error</code></a>. The <code>error.code</code> property will be\nthe exit code of the process. By convention, any exit code other than <code>0</code>\nindicates an error. <code>error.signal</code> will be the signal that terminated the\nprocess.</p>\n<p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the\nstdout and stderr output of the child process. By default, Node.js will decode\nthe output as UTF-8 and pass strings to the callback. The <code>encoding</code> option\ncan be used to specify the character encoding used to decode the stdout and\nstderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character\nencoding, <code>Buffer</code> objects will be passed to the callback instead.</p>\n<pre><code class=\"language-js\">const { exec } = require('child_process');\nexec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {\n  if (error) {\n    console.error(`exec error: ${error}`);\n    return;\n  }\n  console.log(`stdout: ${stdout}`);\n  console.error(`stderr: ${stderr}`);\n});\n</code></pre>\n<p>If <code>timeout</code> is greater than <code>0</code>, the parent will send the signal\nidentified by the <code>killSignal</code> property (the default is <code>'SIGTERM'</code>) if the\nchild runs longer than <code>timeout</code> milliseconds.</p>\n<p>Unlike the <a href=\"http://man7.org/linux/man-pages/man3/exec.3.html\"><code>exec(3)</code></a> POSIX system call, <code>child_process.exec()</code> does not replace\nthe existing process and uses a shell to execute the command.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>stdout</code> and <code>stderr</code> properties. The returned\n<code>ChildProcess</code> instance is attached to the <code>Promise</code> as a <code>child</code> property. In\ncase of an error (including any error resulting in an exit code other than 0), a\nrejected promise is returned, with the same <code>error</code> object given in the\ncallback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst exec = util.promisify(require('child_process').exec);\n\nasync function lsExample() {\n  const { stdout, stderr } = await exec('ls');\n  console.log('stdout:', stdout);\n  console.error('stderr:', stderr);\n}\nlsExample();\n</code></pre>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except\nthe error passed to the callback will be an <code>AbortError</code>:</p>\n<pre><code class=\"language-js\">const { exec } = require('child_process');\nconst controller = new AbortController();\nconst { signal } = controller;\nconst child = exec('grep ssh', { signal }, (error) => {\n  console.log(error); // an AbortError\n});\ncontroller.abort();\n</code></pre>"
             },
             {
               "textRaw": "`child_process.execFile(file[, args][, options][, callback])`",
@@ -17033,6 +18192,16 @@
                   "v0.1.91"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36308",
+                    "description": "AbortSignal support was added."
+                  },
                   {
                     "version": "v8.8.0",
                     "pr-url": "https://github.com/nodejs/node/pull/15380",
@@ -17066,9 +18235,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -17135,6 +18304,12 @@
                           "type": "boolean|string",
                           "default": "`false` (no shell)",
                           "desc": "If `true`, runs `command` inside of a shell. Uses `'/bin/sh'` on Unix, and `process.env.ComSpec` on Windows. A different shell can be specified as a string. See [Shell requirements][] and [Default Windows shell][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting the child process using an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting the child process using an AbortSignal."
                         }
                       ]
                     },
@@ -17164,7 +18339,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>child_process.execFile()</code> function is similar to <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>\nexcept that it does not spawn a shell by default. Rather, the specified\nexecutable <code>file</code> is spawned directly as a new process making it slightly more\nefficient than <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>.</p>\n<p>The same options as <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> are supported. Since a shell is\nnot spawned, behaviors such as I/O redirection and file globbing are not\nsupported.</p>\n<pre><code class=\"language-js\">const { execFile } = require('child_process');\nconst child = execFile('node', ['--version'], (error, stdout, stderr) => {\n  if (error) {\n    throw error;\n  }\n  console.log(stdout);\n});\n</code></pre>\n<p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the\nstdout and stderr output of the child process. By default, Node.js will decode\nthe output as UTF-8 and pass strings to the callback. The <code>encoding</code> option\ncan be used to specify the character encoding used to decode the stdout and\nstderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character\nencoding, <code>Buffer</code> objects will be passed to the callback instead.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>stdout</code> and <code>stderr</code> properties. The returned\n<code>ChildProcess</code> instance is attached to the <code>Promise</code> as a <code>child</code> property. In\ncase of an error (including any error resulting in an exit code other than 0), a\nrejected promise is returned, with the same <code>error</code> object given in the\ncallback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst execFile = util.promisify(require('child_process').execFile);\nasync function getVersion() {\n  const { stdout } = await execFile('node', ['--version']);\n  console.log(stdout);\n}\ngetVersion();\n</code></pre>\n<p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this\nfunction. Any input containing shell metacharacters may be used to trigger\narbitrary command execution.</strong></p>"
+              "desc": "<p>The <code>child_process.execFile()</code> function is similar to <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>\nexcept that it does not spawn a shell by default. Rather, the specified\nexecutable <code>file</code> is spawned directly as a new process making it slightly more\nefficient than <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>.</p>\n<p>The same options as <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> are supported. Since a shell is\nnot spawned, behaviors such as I/O redirection and file globbing are not\nsupported.</p>\n<pre><code class=\"language-js\">const { execFile } = require('child_process');\nconst child = execFile('node', ['--version'], (error, stdout, stderr) => {\n  if (error) {\n    throw error;\n  }\n  console.log(stdout);\n});\n</code></pre>\n<p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the\nstdout and stderr output of the child process. By default, Node.js will decode\nthe output as UTF-8 and pass strings to the callback. The <code>encoding</code> option\ncan be used to specify the character encoding used to decode the stdout and\nstderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character\nencoding, <code>Buffer</code> objects will be passed to the callback instead.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>stdout</code> and <code>stderr</code> properties. The returned\n<code>ChildProcess</code> instance is attached to the <code>Promise</code> as a <code>child</code> property. In\ncase of an error (including any error resulting in an exit code other than 0), a\nrejected promise is returned, with the same <code>error</code> object given in the\ncallback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst execFile = util.promisify(require('child_process').execFile);\nasync function getVersion() {\n  const { stdout } = await execFile('node', ['--version']);\n  console.log(stdout);\n}\ngetVersion();\n</code></pre>\n<p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this\nfunction. Any input containing shell metacharacters may be used to trigger\narbitrary command execution.</strong></p>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except\nthe error passed to the callback will be an <code>AbortError</code>:</p>\n<pre><code class=\"language-js\">const { execFile } = require('child_process');\nconst controller = new AbortController();\nconst { signal } = controller;\nconst child = execFile('node', ['--version'], { signal }, (error) => {\n  console.log(error); // an AbortError\n});\ncontroller.abort();\n</code></pre>"
             },
             {
               "textRaw": "`child_process.fork(modulePath[, args][, options])`",
@@ -17176,7 +18351,30 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37256",
+                    "description": "timeout was added."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37325",
+                    "description": "killSignal for AbortSignal was added."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36603",
+                    "description": "AbortSignal support was added."
+                  },
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30162",
                     "description": "The `serialization` option is supported now."
                   },
@@ -17218,9 +18416,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -17249,6 +18447,12 @@
                           "default": "`process.execArgv`",
                           "desc": "List of string arguments passed to the executable."
                         },
+                        {
+                          "textRaw": "`gid` {number} Sets the group identity of the process (see setgid(2)).",
+                          "name": "gid",
+                          "type": "number",
+                          "desc": "Sets the group identity of the process (see setgid(2))."
+                        },
                         {
                           "textRaw": "`serialization` {string} Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`. See [Advanced serialization][] for more details. **Default:** `'json'`.",
                           "name": "serialization",
@@ -17256,6 +18460,19 @@
                           "default": "`'json'`",
                           "desc": "Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`. See [Advanced serialization][] for more details."
                         },
+                        {
+                          "textRaw": "`signal` {AbortSignal} Allows closing the child process using an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "Allows closing the child process using an AbortSignal."
+                        },
+                        {
+                          "textRaw": "`killSignal` {string|integer} The signal value to be used when the spawned process will be killed by timeout or abort signal. **Default:** `'SIGTERM'`.",
+                          "name": "killSignal",
+                          "type": "string|integer",
+                          "default": "`'SIGTERM'`",
+                          "desc": "The signal value to be used when the spawned process will be killed by timeout or abort signal."
+                        },
                         {
                           "textRaw": "`silent` {boolean} If `true`, stdin, stdout, and stderr of the child will be piped to the parent, otherwise they will be inherited from the parent, see the `'pipe'` and `'inherit'` options for [`child_process.spawn()`][]'s [`stdio`][] for more details. **Default:** `false`.",
                           "name": "silent",
@@ -17269,6 +18486,12 @@
                           "type": "Array|string",
                           "desc": "See [`child_process.spawn()`][]'s [`stdio`][]. When this option is provided, it overrides `silent`. If the array variant is used, it must contain exactly one item with value `'ipc'` or an error will be thrown. For instance `[0, 1, 2, 'ipc']`."
                         },
+                        {
+                          "textRaw": "`uid` {number} Sets the user identity of the process (see setuid(2)).",
+                          "name": "uid",
+                          "type": "number",
+                          "desc": "Sets the user identity of the process (see setuid(2))."
+                        },
                         {
                           "textRaw": "`windowsVerbatimArguments` {boolean} No quoting or escaping of arguments is done on Windows. Ignored on Unix. **Default:** `false`.",
                           "name": "windowsVerbatimArguments",
@@ -17277,23 +18500,18 @@
                           "desc": "No quoting or escaping of arguments is done on Windows. Ignored on Unix."
                         },
                         {
-                          "textRaw": "`uid` {number} Sets the user identity of the process (see setuid(2)).",
-                          "name": "uid",
-                          "type": "number",
-                          "desc": "Sets the user identity of the process (see setuid(2))."
-                        },
-                        {
-                          "textRaw": "`gid` {number} Sets the group identity of the process (see setgid(2)).",
-                          "name": "gid",
+                          "textRaw": "`timeout` {number} In milliseconds the maximum amount of time the process is allowed to run. **Default:** `undefined`.",
+                          "name": "timeout",
                           "type": "number",
-                          "desc": "Sets the group identity of the process (see setgid(2))."
+                          "default": "`undefined`",
+                          "desc": "In milliseconds the maximum amount of time the process is allowed to run."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>The <code>child_process.fork()</code> method is a special case of\n<a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> used specifically to spawn new Node.js processes.\nLike <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a>, a <a href=\"child_process.html#child_process_child_process\"><code>ChildProcess</code></a> object is returned. The\nreturned <a href=\"child_process.html#child_process_child_process\"><code>ChildProcess</code></a> will have an additional communication channel\nbuilt-in that allows messages to be passed back and forth between the parent and\nchild. See <a href=\"child_process.html#child_process_subprocess_send_message_sendhandle_options_callback\"><code>subprocess.send()</code></a> for details.</p>\n<p>Keep in mind that spawned Node.js child processes are\nindependent of the parent with exception of the IPC communication channel\nthat is established between the two. Each process has its own memory, with\ntheir own V8 instances. Because of the additional resource allocations\nrequired, spawning a large number of child Node.js processes is not\nrecommended.</p>\n<p>By default, <code>child_process.fork()</code> will spawn new Node.js instances using the\n<a href=\"process.html#process_process_execpath\"><code>process.execPath</code></a> of the parent process. The <code>execPath</code> property in the\n<code>options</code> object allows for an alternative execution path to be used.</p>\n<p>Node.js processes launched with a custom <code>execPath</code> will communicate with the\nparent process using the file descriptor (fd) identified using the\nenvironment variable <code>NODE_CHANNEL_FD</code> on the child process.</p>\n<p>Unlike the <a href=\"http://man7.org/linux/man-pages/man2/fork.2.html\"><code>fork(2)</code></a> POSIX system call, <code>child_process.fork()</code> does not clone the\ncurrent process.</p>\n<p>The <code>shell</code> option available in <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> is not supported by\n<code>child_process.fork()</code> and will be ignored if set.</p>"
+              "desc": "<p>The <code>child_process.fork()</code> method is a special case of\n<a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> used specifically to spawn new Node.js processes.\nLike <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a>, a <a href=\"child_process.html#child_process_class_childprocess\"><code>ChildProcess</code></a> object is returned. The\nreturned <a href=\"child_process.html#child_process_class_childprocess\"><code>ChildProcess</code></a> will have an additional communication channel\nbuilt-in that allows messages to be passed back and forth between the parent and\nchild. See <a href=\"child_process.html#child_process_subprocess_send_message_sendhandle_options_callback\"><code>subprocess.send()</code></a> for details.</p>\n<p>Keep in mind that spawned Node.js child processes are\nindependent of the parent with exception of the IPC communication channel\nthat is established between the two. Each process has its own memory, with\ntheir own V8 instances. Because of the additional resource allocations\nrequired, spawning a large number of child Node.js processes is not\nrecommended.</p>\n<p>By default, <code>child_process.fork()</code> will spawn new Node.js instances using the\n<a href=\"process.html#process_process_execpath\"><code>process.execPath</code></a> of the parent process. The <code>execPath</code> property in the\n<code>options</code> object allows for an alternative execution path to be used.</p>\n<p>Node.js processes launched with a custom <code>execPath</code> will communicate with the\nparent process using the file descriptor (fd) identified using the\nenvironment variable <code>NODE_CHANNEL_FD</code> on the child process.</p>\n<p>Unlike the <a href=\"http://man7.org/linux/man-pages/man2/fork.2.html\"><code>fork(2)</code></a> POSIX system call, <code>child_process.fork()</code> does not clone the\ncurrent process.</p>\n<p>The <code>shell</code> option available in <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> is not supported by\n<code>child_process.fork()</code> and will be ignored if set.</p>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except\nthe error passed to the callback will be an <code>AbortError</code>:</p>\n<pre><code class=\"language-js\">if (process.argv[2] === 'child') {\n  setTimeout(() => {\n    console.log(`Hello from ${process.argv[2]}!`);\n  }, 1_000);\n} else {\n  const { fork } = require('child_process');\n  const controller = new AbortController();\n  const { signal } = controller;\n  const child = fork(__filename, ['child'], { signal });\n  child.on('error', (err) => {\n    // This will be called with err being an AbortError if the controller aborts\n  });\n  controller.abort(); // Stops the child process\n}\n</code></pre>"
             },
             {
               "textRaw": "`child_process.spawn(command[, args][, options])`",
@@ -17305,7 +18523,30 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37256",
+                    "description": "timeout was added."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37325",
+                    "description": "killSignal for AbortSignal was added."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36432",
+                    "description": "AbortSignal support was added."
+                  },
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30162",
                     "description": "The `serialization` option is supported now."
                   },
@@ -17352,9 +18593,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -17421,13 +18662,33 @@
                           "type": "boolean",
                           "default": "`false`",
                           "desc": "Hide the subprocess console window that would normally be created on Windows systems."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting the child process using an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting the child process using an AbortSignal."
+                        },
+                        {
+                          "textRaw": "`timeout` {number} In milliseconds the maximum amount of time the process is allowed to run. **Default:** `undefined`.",
+                          "name": "timeout",
+                          "type": "number",
+                          "default": "`undefined`",
+                          "desc": "In milliseconds the maximum amount of time the process is allowed to run."
+                        },
+                        {
+                          "textRaw": "`killSignal` {string|integer} The signal value to be used when the spawned process will be killed by timeout or abort signal. **Default:** `'SIGTERM'`.",
+                          "name": "killSignal",
+                          "type": "string|integer",
+                          "default": "`'SIGTERM'`",
+                          "desc": "The signal value to be used when the spawned process will be killed by timeout or abort signal."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>The <code>child_process.spawn()</code> method spawns a new process using the given\n<code>command</code>, with command line arguments in <code>args</code>. If omitted, <code>args</code> defaults\nto an empty array.</p>\n<p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this\nfunction. Any input containing shell metacharacters may be used to trigger\narbitrary command execution.</strong></p>\n<p>A third argument may be used to specify additional options, with these defaults:</p>\n<pre><code class=\"language-js\">const defaults = {\n  cwd: undefined,\n  env: process.env\n};\n</code></pre>\n<p>Use <code>cwd</code> to specify the working directory from which the process is spawned.\nIf not given, the default is to inherit the current working directory.</p>\n<p>Use <code>env</code> to specify environment variables that will be visible to the new\nprocess, the default is <a href=\"process.html#process_process_env\"><code>process.env</code></a>.</p>\n<p><code>undefined</code> values in <code>env</code> will be ignored.</p>\n<p>Example of running <code>ls -lh /usr</code>, capturing <code>stdout</code>, <code>stderr</code>, and the\nexit code:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.stderr.on('data', (data) => {\n  console.error(`stderr: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>\n<p>Example: A very elaborate way to run <code>ps ax | grep ssh</code></p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ps = spawn('ps', ['ax']);\nconst grep = spawn('grep', ['ssh']);\n\nps.stdout.on('data', (data) => {\n  grep.stdin.write(data);\n});\n\nps.stderr.on('data', (data) => {\n  console.error(`ps stderr: ${data}`);\n});\n\nps.on('close', (code) => {\n  if (code !== 0) {\n    console.log(`ps process exited with code ${code}`);\n  }\n  grep.stdin.end();\n});\n\ngrep.stdout.on('data', (data) => {\n  console.log(data.toString());\n});\n\ngrep.stderr.on('data', (data) => {\n  console.error(`grep stderr: ${data}`);\n});\n\ngrep.on('close', (code) => {\n  if (code !== 0) {\n    console.log(`grep process exited with code ${code}`);\n  }\n});\n</code></pre>\n<p>Example of checking for failed <code>spawn</code>:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst subprocess = spawn('bad_command');\n\nsubprocess.on('error', (err) => {\n  console.error('Failed to start subprocess.');\n});\n</code></pre>\n<p>Certain platforms (macOS, Linux) will use the value of <code>argv[0]</code> for the process\ntitle while others (Windows, SunOS) will use <code>command</code>.</p>\n<p>Node.js currently overwrites <code>argv[0]</code> with <code>process.execPath</code> on startup, so\n<code>process.argv[0]</code> in a Node.js child process will not match the <code>argv0</code>\nparameter passed to <code>spawn</code> from the parent, retrieve it with the\n<code>process.argv0</code> property instead.</p>",
+              "desc": "<p>The <code>child_process.spawn()</code> method spawns a new process using the given\n<code>command</code>, with command-line arguments in <code>args</code>. If omitted, <code>args</code> defaults\nto an empty array.</p>\n<p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this\nfunction. Any input containing shell metacharacters may be used to trigger\narbitrary command execution.</strong></p>\n<p>A third argument may be used to specify additional options, with these defaults:</p>\n<pre><code class=\"language-js\">const defaults = {\n  cwd: undefined,\n  env: process.env\n};\n</code></pre>\n<p>Use <code>cwd</code> to specify the working directory from which the process is spawned.\nIf not given, the default is to inherit the current working directory. If given,\nbut the path does not exist, the child process emits an <code>ENOENT</code> error\nand exits immediately. <code>ENOENT</code> is also emitted when the command\ndoes not exist.</p>\n<p>Use <code>env</code> to specify environment variables that will be visible to the new\nprocess, the default is <a href=\"process.html#process_process_env\"><code>process.env</code></a>.</p>\n<p><code>undefined</code> values in <code>env</code> will be ignored.</p>\n<p>Example of running <code>ls -lh /usr</code>, capturing <code>stdout</code>, <code>stderr</code>, and the\nexit code:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.stderr.on('data', (data) => {\n  console.error(`stderr: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>\n<p>Example: A very elaborate way to run <code>ps ax | grep ssh</code></p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ps = spawn('ps', ['ax']);\nconst grep = spawn('grep', ['ssh']);\n\nps.stdout.on('data', (data) => {\n  grep.stdin.write(data);\n});\n\nps.stderr.on('data', (data) => {\n  console.error(`ps stderr: ${data}`);\n});\n\nps.on('close', (code) => {\n  if (code !== 0) {\n    console.log(`ps process exited with code ${code}`);\n  }\n  grep.stdin.end();\n});\n\ngrep.stdout.on('data', (data) => {\n  console.log(data.toString());\n});\n\ngrep.stderr.on('data', (data) => {\n  console.error(`grep stderr: ${data}`);\n});\n\ngrep.on('close', (code) => {\n  if (code !== 0) {\n    console.log(`grep process exited with code ${code}`);\n  }\n});\n</code></pre>\n<p>Example of checking for failed <code>spawn</code>:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst subprocess = spawn('bad_command');\n\nsubprocess.on('error', (err) => {\n  console.error('Failed to start subprocess.');\n});\n</code></pre>\n<p>Certain platforms (macOS, Linux) will use the value of <code>argv[0]</code> for the process\ntitle while others (Windows, SunOS) will use <code>command</code>.</p>\n<p>Node.js currently overwrites <code>argv[0]</code> with <code>process.execPath</code> on startup, so\n<code>process.argv[0]</code> in a Node.js child process will not match the <code>argv0</code>\nparameter passed to <code>spawn</code> from the parent, retrieve it with the\n<code>process.argv0</code> property instead.</p>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except\nthe error passed to the callback will be an <code>AbortError</code>:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst controller = new AbortController();\nconst { signal } = controller;\nconst grep = spawn('grep', ['ssh'], { signal });\ngrep.on('error', (err) => {\n  // This will be called with err being an AbortError if the controller aborts\n});\ncontroller.abort(); // Stops the child process\n</code></pre>",
               "properties": [
                 {
                   "textRaw": "`options.detached`",
@@ -17448,6 +18709,11 @@
                       "v0.7.10"
                     ],
                     "changes": [
+                      {
+                        "version": "v14.18.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/29412",
+                        "description": "Added the `overlapped` stdio flag."
+                      },
                       {
                         "version": "v3.3.1",
                         "pr-url": "https://github.com/nodejs/node/pull/2727",
@@ -17455,7 +18721,7 @@
                       }
                     ]
                   },
-                  "desc": "<p>The <code>options.stdio</code> option is used to configure the pipes that are established\nbetween the parent and child process. By default, the child's stdin, stdout,\nand stderr are redirected to corresponding <a href=\"child_process.html#child_process_subprocess_stdin\"><code>subprocess.stdin</code></a>,\n<a href=\"child_process.html#child_process_subprocess_stdout\"><code>subprocess.stdout</code></a>, and <a href=\"child_process.html#child_process_subprocess_stderr\"><code>subprocess.stderr</code></a> streams on the\n<a href=\"child_process.html#child_process_child_process\"><code>ChildProcess</code></a> object. This is equivalent to setting the <code>options.stdio</code>\nequal to <code>['pipe', 'pipe', 'pipe']</code>.</p>\n<p>For convenience, <code>options.stdio</code> may be one of the following strings:</p>\n<ul>\n<li><code>'pipe'</code>: equivalent to <code>['pipe', 'pipe', 'pipe']</code> (the default)</li>\n<li><code>'ignore'</code>: equivalent to <code>['ignore', 'ignore', 'ignore']</code></li>\n<li><code>'inherit'</code>: equivalent to <code>['inherit', 'inherit', 'inherit']</code> or <code>[0, 1, 2]</code></li>\n</ul>\n<p>Otherwise, the value of <code>options.stdio</code> is an array where each index corresponds\nto an fd in the child. The fds 0, 1, and 2 correspond to stdin, stdout,\nand stderr, respectively. Additional fds can be specified to create additional\npipes between the parent and child. The value is one of the following:</p>\n<ol>\n<li>\n<p><code>'pipe'</code>: Create a pipe between the child process and the parent process.\nThe parent end of the pipe is exposed to the parent as a property on the\n<code>child_process</code> object as <a href=\"child_process.html#child_process_subprocess_stdio\"><code>subprocess.stdio[fd]</code></a>. Pipes\ncreated for fds 0, 1, and 2 are also available as <a href=\"child_process.html#child_process_subprocess_stdin\"><code>subprocess.stdin</code></a>,\n<a href=\"child_process.html#child_process_subprocess_stdout\"><code>subprocess.stdout</code></a> and <a href=\"child_process.html#child_process_subprocess_stderr\"><code>subprocess.stderr</code></a>, respectively.</p>\n</li>\n<li>\n<p><code>'ipc'</code>: Create an IPC channel for passing messages/file descriptors\nbetween parent and child. A <a href=\"child_process.html#child_process_child_process\"><code>ChildProcess</code></a> may have at most one IPC\nstdio file descriptor. Setting this option enables the\n<a href=\"child_process.html#child_process_subprocess_send_message_sendhandle_options_callback\"><code>subprocess.send()</code></a> method. If the child is a Node.js process, the\npresence of an IPC channel will enable <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> and\n<a href=\"process.html#process_process_disconnect\"><code>process.disconnect()</code></a> methods, as well as <a href=\"process.html#process_event_disconnect\"><code>'disconnect'</code></a> and\n<a href=\"process.html#process_event_message\"><code>'message'</code></a> events within the child.</p>\n<p>Accessing the IPC channel fd in any way other than <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a>\nor using the IPC channel with a child process that is not a Node.js instance\nis not supported.</p>\n</li>\n<li>\n<p><code>'ignore'</code>: Instructs Node.js to ignore the fd in the child. While Node.js\nwill always open fds 0, 1, and 2 for the processes it spawns, setting the fd\nto <code>'ignore'</code> will cause Node.js to open <code>/dev/null</code> and attach it to the\nchild's fd.</p>\n</li>\n<li>\n<p><code>'inherit'</code>: Pass through the corresponding stdio stream to/from the\nparent process. In the first three positions, this is equivalent to\n<code>process.stdin</code>, <code>process.stdout</code>, and <code>process.stderr</code>, respectively. In\nany other position, equivalent to <code>'ignore'</code>.</p>\n</li>\n<li>\n<p><a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a> object: Share a readable or writable stream that refers to a tty,\nfile, socket, or a pipe with the child process. The stream's underlying\nfile descriptor is duplicated in the child process to the fd that\ncorresponds to the index in the <code>stdio</code> array. The stream must have an\nunderlying descriptor (file streams do not until the <code>'open'</code> event has\noccurred).</p>\n</li>\n<li>\n<p>Positive integer: The integer value is interpreted as a file descriptor\nthat is currently open in the parent process. It is shared with the child\nprocess, similar to how <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a> objects can be shared. Passing sockets\nis not supported on Windows.</p>\n</li>\n<li>\n<p><code>null</code>, <code>undefined</code>: Use default value. For stdio fds 0, 1, and 2 (in other\nwords, stdin, stdout, and stderr) a pipe is created. For fd 3 and up, the\ndefault is <code>'ignore'</code>.</p>\n</li>\n</ol>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\n\n// Child will use parent's stdios.\nspawn('prg', [], { stdio: 'inherit' });\n\n// Spawn child sharing only stderr.\nspawn('prg', [], { stdio: ['pipe', 'pipe', process.stderr] });\n\n// Open an extra fd=4, to interact with programs presenting a\n// startd-style interface.\nspawn('prg', [], { stdio: ['pipe', null, null, null, 'pipe'] });\n</code></pre>\n<p><em>It is worth noting that when an IPC channel is established between the\nparent and child processes, and the child is a Node.js process, the child\nis launched with the IPC channel unreferenced (using <code>unref()</code>) until the\nchild registers an event handler for the <a href=\"process.html#process_event_disconnect\"><code>'disconnect'</code></a> event\nor the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event. This allows the child to exit\nnormally without the process being held open by the open IPC channel.</em></p>\n<p>On Unix-like operating systems, the <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> method\nperforms memory operations synchronously before decoupling the event loop\nfrom the child. Applications with a large memory footprint may find frequent\n<a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> calls to be a bottleneck. For more information,\nsee <a href=\"https://bugs.chromium.org/p/v8/issues/detail?id=7381\">V8 issue 7381</a>.</p>\n<p>See also: <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> and <a href=\"child_process.html#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>.</p>"
+                  "desc": "<p>The <code>options.stdio</code> option is used to configure the pipes that are established\nbetween the parent and child process. By default, the child's stdin, stdout,\nand stderr are redirected to corresponding <a href=\"child_process.html#child_process_subprocess_stdin\"><code>subprocess.stdin</code></a>,\n<a href=\"child_process.html#child_process_subprocess_stdout\"><code>subprocess.stdout</code></a>, and <a href=\"child_process.html#child_process_subprocess_stderr\"><code>subprocess.stderr</code></a> streams on the\n<a href=\"child_process.html#child_process_class_childprocess\"><code>ChildProcess</code></a> object. This is equivalent to setting the <code>options.stdio</code>\nequal to <code>['pipe', 'pipe', 'pipe']</code>.</p>\n<p>For convenience, <code>options.stdio</code> may be one of the following strings:</p>\n<ul>\n<li><code>'pipe'</code>: equivalent to <code>['pipe', 'pipe', 'pipe']</code> (the default)</li>\n<li><code>'overlapped'</code>: equivalent to <code>['overlapped', 'overlapped', 'overlapped']</code></li>\n<li><code>'ignore'</code>: equivalent to <code>['ignore', 'ignore', 'ignore']</code></li>\n<li><code>'inherit'</code>: equivalent to <code>['inherit', 'inherit', 'inherit']</code> or <code>[0, 1, 2]</code></li>\n</ul>\n<p>Otherwise, the value of <code>options.stdio</code> is an array where each index corresponds\nto an fd in the child. The fds 0, 1, and 2 correspond to stdin, stdout,\nand stderr, respectively. Additional fds can be specified to create additional\npipes between the parent and child. The value is one of the following:</p>\n<ol>\n<li>\n<p><code>'pipe'</code>: Create a pipe between the child process and the parent process.\nThe parent end of the pipe is exposed to the parent as a property on the\n<code>child_process</code> object as <a href=\"child_process.html#child_process_subprocess_stdio\"><code>subprocess.stdio[fd]</code></a>. Pipes\ncreated for fds 0, 1, and 2 are also available as <a href=\"child_process.html#child_process_subprocess_stdin\"><code>subprocess.stdin</code></a>,\n<a href=\"child_process.html#child_process_subprocess_stdout\"><code>subprocess.stdout</code></a> and <a href=\"child_process.html#child_process_subprocess_stderr\"><code>subprocess.stderr</code></a>, respectively.</p>\n</li>\n<li>\n<p><code>'overlapped'</code>: Same as <code>'pipe'</code> except that the <code>FILE_FLAG_OVERLAPPED</code> flag\nis set on the handle. This is necessary for overlapped I/O on the child\nprocess's stdio handles. See the\n<a href=\"https://docs.microsoft.com/en-us/windows/win32/fileio/synchronous-and-asynchronous-i-o\">docs</a>\nfor more details. This is exactly the same as <code>'pipe'</code> on non-Windows\nsystems.</p>\n</li>\n<li>\n<p><code>'ipc'</code>: Create an IPC channel for passing messages/file descriptors\nbetween parent and child. A <a href=\"child_process.html#child_process_class_childprocess\"><code>ChildProcess</code></a> may have at most one IPC\nstdio file descriptor. Setting this option enables the\n<a href=\"child_process.html#child_process_subprocess_send_message_sendhandle_options_callback\"><code>subprocess.send()</code></a> method. If the child is a Node.js process, the\npresence of an IPC channel will enable <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> and\n<a href=\"process.html#process_process_disconnect\"><code>process.disconnect()</code></a> methods, as well as <a href=\"process.html#process_event_disconnect\"><code>'disconnect'</code></a> and\n<a href=\"process.html#process_event_message\"><code>'message'</code></a> events within the child.</p>\n<p>Accessing the IPC channel fd in any way other than <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a>\nor using the IPC channel with a child process that is not a Node.js instance\nis not supported.</p>\n</li>\n<li>\n<p><code>'ignore'</code>: Instructs Node.js to ignore the fd in the child. While Node.js\nwill always open fds 0, 1, and 2 for the processes it spawns, setting the fd\nto <code>'ignore'</code> will cause Node.js to open <code>/dev/null</code> and attach it to the\nchild's fd.</p>\n</li>\n<li>\n<p><code>'inherit'</code>: Pass through the corresponding stdio stream to/from the\nparent process. In the first three positions, this is equivalent to\n<code>process.stdin</code>, <code>process.stdout</code>, and <code>process.stderr</code>, respectively. In\nany other position, equivalent to <code>'ignore'</code>.</p>\n</li>\n<li>\n<p><a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a> object: Share a readable or writable stream that refers to a tty,\nfile, socket, or a pipe with the child process. The stream's underlying\nfile descriptor is duplicated in the child process to the fd that\ncorresponds to the index in the <code>stdio</code> array. The stream must have an\nunderlying descriptor (file streams do not until the <code>'open'</code> event has\noccurred).</p>\n</li>\n<li>\n<p>Positive integer: The integer value is interpreted as a file descriptor\nthat is currently open in the parent process. It is shared with the child\nprocess, similar to how <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a> objects can be shared. Passing sockets\nis not supported on Windows.</p>\n</li>\n<li>\n<p><code>null</code>, <code>undefined</code>: Use default value. For stdio fds 0, 1, and 2 (in other\nwords, stdin, stdout, and stderr) a pipe is created. For fd 3 and up, the\ndefault is <code>'ignore'</code>.</p>\n</li>\n</ol>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\n\n// Child will use parent's stdios.\nspawn('prg', [], { stdio: 'inherit' });\n\n// Spawn child sharing only stderr.\nspawn('prg', [], { stdio: ['pipe', 'pipe', process.stderr] });\n\n// Open an extra fd=4, to interact with programs presenting a\n// startd-style interface.\nspawn('prg', [], { stdio: ['pipe', null, null, null, 'pipe'] });\n</code></pre>\n<p><em>It is worth noting that when an IPC channel is established between the\nparent and child processes, and the child is a Node.js process, the child\nis launched with the IPC channel unreferenced (using <code>unref()</code>) until the\nchild registers an event handler for the <a href=\"process.html#process_event_disconnect\"><code>'disconnect'</code></a> event\nor the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event. This allows the child to exit\nnormally without the process being held open by the open IPC channel.</em></p>\n<p>On Unix-like operating systems, the <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> method\nperforms memory operations synchronously before decoupling the event loop\nfrom the child. Applications with a large memory footprint may find frequent\n<a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> calls to be a bottleneck. For more information,\nsee <a href=\"https://bugs.chromium.org/p/v8/issues/detail?id=7381\">V8 issue 7381</a>.</p>\n<p>See also: <a href=\"child_process.html#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> and <a href=\"child_process.html#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>.</p>"
                 }
               ]
             }
@@ -17477,6 +18743,11 @@
                   "v0.11.12"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
                   {
                     "version": "v10.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22409",
@@ -17493,7 +18764,10 @@
                     "description": "The `input` option can now be a `Uint8Array`."
                   },
                   {
-                    "version": "v6.2.1, v4.5.0",
+                    "version": [
+                      "v6.2.1",
+                      "v4.5.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/6939",
                     "description": "The `encoding` option can now explicitly be set to `buffer`."
                   }
@@ -17526,9 +18800,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -17621,6 +18895,11 @@
                   "v0.11.12"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
                   {
                     "version": "v10.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22409",
@@ -17659,9 +18938,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -17754,6 +19033,11 @@
                   "v0.11.12"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
                   {
                     "version": "v10.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22409",
@@ -17770,7 +19054,10 @@
                     "description": "The `input` option can now be a `Uint8Array`."
                   },
                   {
-                    "version": "v6.2.1, v4.5.0",
+                    "version": [
+                      "v6.2.1",
+                      "v4.5.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/6939",
                     "description": "The `encoding` option can now explicitly be set to `buffer`."
                   },
@@ -17851,9 +19138,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -17963,7 +19250,7 @@
         {
           "textRaw": "Shell requirements",
           "name": "shell_requirements",
-          "desc": "<p>The shell should understand the <code>-c</code> switch. If the shell is <code>'cmd.exe'</code>, it\nshould understand the <code>/d /s /c</code> switches and command line parsing should be\ncompatible.</p>",
+          "desc": "<p>The shell should understand the <code>-c</code> switch. If the shell is <code>'cmd.exe'</code>, it\nshould understand the <code>/d /s /c</code> switches and command-line parsing should be\ncompatible.</p>",
           "type": "module",
           "displayName": "Shell requirements"
         },
@@ -17979,6 +19266,7 @@
           "name": "advanced_serialization",
           "meta": {
             "added": [
+              "v13.2.0",
               "v12.16.0"
             ],
             "changes": []
@@ -18025,7 +19313,7 @@
                   "desc": "The signal by which the child process was terminated."
                 }
               ],
-              "desc": "<p>The <code>'close'</code> event is emitted when the stdio streams of a child process have\nbeen closed. This is distinct from the <a href=\"child_process.html#child_process_event_exit\"><code>'exit'</code></a> event, since multiple\nprocesses might share the same stdio streams.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process close all stdio with code ${code}`);\n});\n\nls.on('exit', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>"
+              "desc": "<p>The <code>'close'</code> event is emitted after a process has ended <em>and</em> the stdio\nstreams of a child process have been closed. This is distinct from the\n<a href=\"child_process.html#child_process_event_exit\"><code>'exit'</code></a> event, since multiple processes might share the same stdio\nstreams. The <code>'close'</code> event will always emit after <a href=\"child_process.html#child_process_event_exit\"><code>'exit'</code></a> was\nalready emitted, or <a href=\"child_process.html#child_process_event_error\"><code>'error'</code></a> if the child failed to spawn.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process close all stdio with code ${code}`);\n});\n\nls.on('exit', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'disconnect'`",
@@ -18105,6 +19393,19 @@
                 }
               ],
               "desc": "<p>The <code>'message'</code> event is triggered when a child process uses\n<a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> to send messages.</p>\n<p>The message goes through serialization and parsing. The resulting\nmessage might not be the same as what is originally sent.</p>\n<p>If the <code>serialization</code> option was set to <code>'advanced'</code> used when spawning the\nchild process, the <code>message</code> argument can contain data that JSON is not able\nto represent.\nSee <a href=\"child_process.html#child_process_advanced_serialization\">Advanced serialization</a> for more details.</p>"
+            },
+            {
+              "textRaw": "Event: `'spawn'`",
+              "type": "event",
+              "name": "spawn",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>The <code>'spawn'</code> event is emitted once the child process has spawned successfully.\nIf the child process does not spawn successfully, the <code>'spawn'</code> event is not\nemitted and the <code>'error'</code> event is emitted instead.</p>\n<p>If emitted, the <code>'spawn'</code> event comes before all other events and before any\ndata is received via <code>stdout</code> or <code>stderr</code>.</p>\n<p>The <code>'spawn'</code> event will fire regardless of whether an error occurs <strong>within</strong>\nthe spawned process. For example, if <code>bash some-command</code> spawns successfully,\nthe <code>'spawn'</code> event will fire, though <code>bash</code> may fail to spawn <code>some-command</code>.\nThis caveat also applies when using <code>{ shell: true }</code>.</p>"
             }
           ],
           "properties": [
@@ -18116,10 +19417,52 @@
                 "added": [
                   "v7.1.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/30165",
+                    "description": "The object no longer accidentally exposes native C++ bindings."
+                  }
+                ]
               },
               "desc": "<p>The <code>subprocess.channel</code> property is a reference to the child's IPC channel. If\nno IPC channel currently exists, this property is <code>undefined</code>.</p>",
-              "shortDesc": "A pipe representing the IPC channel to the child process."
+              "shortDesc": "A pipe representing the IPC channel to the child process.",
+              "methods": [
+                {
+                  "textRaw": "`subprocess.channel.ref()`",
+                  "type": "method",
+                  "name": "ref",
+                  "meta": {
+                    "added": [
+                      "v7.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>This method makes the IPC channel keep the event loop of the parent process\nrunning if <code>.unref()</code> has been called before.</p>"
+                },
+                {
+                  "textRaw": "`subprocess.channel.unref()`",
+                  "type": "method",
+                  "name": "unref",
+                  "meta": {
+                    "added": [
+                      "v7.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>This method makes the IPC channel not keep the event loop of the parent process\nrunning, and lets it finish even while the channel is open.</p>"
+                }
+              ]
             },
             {
               "textRaw": "`connected` {boolean} Set to `false` after `subprocess.disconnect()` is called.",
@@ -18154,8 +19497,8 @@
               "shortDesc": "Set to `true` after `subprocess.kill()` is used to successfully send a signal to the child process."
             },
             {
-              "textRaw": "`pid` {integer}",
-              "type": "integer",
+              "textRaw": "`pid` {integer|undefined}",
+              "type": "integer|undefined",
               "name": "pid",
               "meta": {
                 "added": [
@@ -18163,19 +19506,19 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Returns the process identifier (PID) of the child process.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst grep = spawn('grep', ['ssh']);\n\nconsole.log(`Spawned child pid: ${grep.pid}`);\ngrep.stdin.end();\n</code></pre>"
+              "desc": "<p>Returns the process identifier (PID) of the child process. If the child process\nfails to spawn due to errors, then the value is <code>undefined</code> and <code>error</code> is\nemitted.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst grep = spawn('grep', ['ssh']);\n\nconsole.log(`Spawned child pid: ${grep.pid}`);\ngrep.stdin.end();\n</code></pre>"
             },
             {
-              "textRaw": "`signalCode` {integer}",
-              "type": "integer",
+              "textRaw": "`signalCode` {string|null}",
+              "type": "string|null",
               "name": "signalCode",
-              "desc": "<p>The <code>subprocess.signalCode</code> property indicates the signal number received by\nthe child process if any, else <code>null</code>.</p>"
+              "desc": "<p>The <code>subprocess.signalCode</code> property indicates the signal received by\nthe child process if any, else <code>null</code>.</p>"
             },
             {
               "textRaw": "`spawnargs` {Array}",
               "type": "Array",
               "name": "spawnargs",
-              "desc": "<p>The <code>subprocess.spawnargs</code> property represents the full list of command line\narguments the child process was launched with.</p>"
+              "desc": "<p>The <code>subprocess.spawnargs</code> property represents the full list of command-line\narguments the child process was launched with.</p>"
             },
             {
               "textRaw": "`spawnfile` {string}",
@@ -18193,7 +19536,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A <code>Readable Stream</code> that represents the child process's <code>stderr</code>.</p>\n<p>If the child was spawned with <code>stdio[2]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stderr</code> is an alias for <code>subprocess.stdio[2]</code>. Both properties will\nrefer to the same value.</p>"
+              "desc": "<p>A <code>Readable Stream</code> that represents the child process's <code>stderr</code>.</p>\n<p>If the child was spawned with <code>stdio[2]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stderr</code> is an alias for <code>subprocess.stdio[2]</code>. Both properties will\nrefer to the same value.</p>\n<p>The <code>subprocess.stderr</code> property can be <code>null</code> if the child process could\nnot be successfully spawned.</p>"
             },
             {
               "textRaw": "`stdin` {stream.Writable}",
@@ -18205,7 +19548,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A <code>Writable Stream</code> that represents the child process's <code>stdin</code>.</p>\n<p>If a child process waits to read all of its input, the child will not continue\nuntil this stream has been closed via <code>end()</code>.</p>\n<p>If the child was spawned with <code>stdio[0]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stdin</code> is an alias for <code>subprocess.stdio[0]</code>. Both properties will\nrefer to the same value.</p>"
+              "desc": "<p>A <code>Writable Stream</code> that represents the child process's <code>stdin</code>.</p>\n<p>If a child process waits to read all of its input, the child will not continue\nuntil this stream has been closed via <code>end()</code>.</p>\n<p>If the child was spawned with <code>stdio[0]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stdin</code> is an alias for <code>subprocess.stdio[0]</code>. Both properties will\nrefer to the same value.</p>\n<p>The <code>subprocess.stdin</code> property can be <code>undefined</code> if the child process could\nnot be successfully spawned.</p>"
             },
             {
               "textRaw": "`stdio` {Array}",
@@ -18217,7 +19560,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A sparse array of pipes to the child process, corresponding with positions in\nthe <a href=\"child_process.html#child_process_options_stdio\"><code>stdio</code></a> option passed to <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> that have been set\nto the value <code>'pipe'</code>. <code>subprocess.stdio[0]</code>, <code>subprocess.stdio[1]</code>, and\n<code>subprocess.stdio[2]</code> are also available as <code>subprocess.stdin</code>,\n<code>subprocess.stdout</code>, and <code>subprocess.stderr</code>, respectively.</p>\n<p>In the following example, only the child's fd <code>1</code> (stdout) is configured as a\npipe, so only the parent's <code>subprocess.stdio[1]</code> is a stream, all other values\nin the array are <code>null</code>.</p>\n<pre><code class=\"language-js\">const assert = require('assert');\nconst fs = require('fs');\nconst child_process = require('child_process');\n\nconst subprocess = child_process.spawn('ls', {\n  stdio: [\n    0, // Use parent's stdin for child.\n    'pipe', // Pipe child's stdout to parent.\n    fs.openSync('err.out', 'w') // Direct child's stderr to a file.\n  ]\n});\n\nassert.strictEqual(subprocess.stdio[0], null);\nassert.strictEqual(subprocess.stdio[0], subprocess.stdin);\n\nassert(subprocess.stdout);\nassert.strictEqual(subprocess.stdio[1], subprocess.stdout);\n\nassert.strictEqual(subprocess.stdio[2], null);\nassert.strictEqual(subprocess.stdio[2], subprocess.stderr);\n</code></pre>"
+              "desc": "<p>A sparse array of pipes to the child process, corresponding with positions in\nthe <a href=\"child_process.html#child_process_options_stdio\"><code>stdio</code></a> option passed to <a href=\"child_process.html#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> that have been set\nto the value <code>'pipe'</code>. <code>subprocess.stdio[0]</code>, <code>subprocess.stdio[1]</code>, and\n<code>subprocess.stdio[2]</code> are also available as <code>subprocess.stdin</code>,\n<code>subprocess.stdout</code>, and <code>subprocess.stderr</code>, respectively.</p>\n<p>In the following example, only the child's fd <code>1</code> (stdout) is configured as a\npipe, so only the parent's <code>subprocess.stdio[1]</code> is a stream, all other values\nin the array are <code>null</code>.</p>\n<pre><code class=\"language-js\">const assert = require('assert');\nconst fs = require('fs');\nconst child_process = require('child_process');\n\nconst subprocess = child_process.spawn('ls', {\n  stdio: [\n    0, // Use parent's stdin for child.\n    'pipe', // Pipe child's stdout to parent.\n    fs.openSync('err.out', 'w'), // Direct child's stderr to a file.\n  ]\n});\n\nassert.strictEqual(subprocess.stdio[0], null);\nassert.strictEqual(subprocess.stdio[0], subprocess.stdin);\n\nassert(subprocess.stdout);\nassert.strictEqual(subprocess.stdio[1], subprocess.stdout);\n\nassert.strictEqual(subprocess.stdio[2], null);\nassert.strictEqual(subprocess.stdio[2], subprocess.stderr);\n</code></pre>\n<p>The <code>subprocess.stdio</code> property can be <code>undefined</code> if the child process could\nnot be successfully spawned.</p>"
             },
             {
               "textRaw": "`stdout` {stream.Readable}",
@@ -18229,7 +19572,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A <code>Readable Stream</code> that represents the child process's <code>stdout</code>.</p>\n<p>If the child was spawned with <code>stdio[1]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stdout</code> is an alias for <code>subprocess.stdio[1]</code>. Both properties will\nrefer to the same value.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\n\nconst subprocess = spawn('ls');\n\nsubprocess.stdout.on('data', (data) => {\n  console.log(`Received chunk ${data}`);\n});\n</code></pre>"
+              "desc": "<p>A <code>Readable Stream</code> that represents the child process's <code>stdout</code>.</p>\n<p>If the child was spawned with <code>stdio[1]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stdout</code> is an alias for <code>subprocess.stdio[1]</code>. Both properties will\nrefer to the same value.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\n\nconst subprocess = spawn('ls');\n\nsubprocess.stdout.on('data', (data) => {\n  console.log(`Received chunk ${data}`);\n});\n</code></pre>\n<p>The <code>subprocess.stdout</code> property can be <code>null</code> if the child process could\nnot be successfully spawned.</p>"
             }
           ],
           "methods": [
@@ -18276,7 +19619,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>subprocess.kill()</code> method sends a signal to the child process. If no\nargument is given, the process will be sent the <code>'SIGTERM'</code> signal. See\n<a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a> for a list of available signals. This function returns <code>true</code> if\n<a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a> succeeds, and <code>false</code> otherwise.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst grep = spawn('grep', ['ssh']);\n\ngrep.on('close', (code, signal) => {\n  console.log(\n    `child process terminated due to receipt of signal ${signal}`);\n});\n\n// Send SIGHUP to process.\ngrep.kill('SIGHUP');\n</code></pre>\n<p>The <a href=\"child_process.html#child_process_child_process\"><code>ChildProcess</code></a> object may emit an <a href=\"child_process.html#child_process_event_error\"><code>'error'</code></a> event if the signal\ncannot be delivered. Sending a signal to a child process that has already exited\nis not an error but may have unforeseen consequences. Specifically, if the\nprocess identifier (PID) has been reassigned to another process, the signal will\nbe delivered to that process instead which can have unexpected results.</p>\n<p>While the function is called <code>kill</code>, the signal delivered to the child process\nmay not actually terminate the process.</p>\n<p>See <a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a> for reference.</p>\n<p>On Linux, child processes of child processes will not be terminated\nwhen attempting to kill their parent. This is likely to happen when running a\nnew process in a shell or with the use of the <code>shell</code> option of <code>ChildProcess</code>:</p>\n<pre><code class=\"language-js\">'use strict';\nconst { spawn } = require('child_process');\n\nconst subprocess = spawn(\n  'sh',\n  [\n    '-c',\n    `node -e \"setInterval(() => {\n      console.log(process.pid, 'is alive')\n    }, 500);\"`\n  ], {\n    stdio: ['inherit', 'inherit', 'inherit']\n  }\n);\n\nsetTimeout(() => {\n  subprocess.kill(); // Does not terminate the Node.js process in the shell.\n}, 2000);\n</code></pre>"
+              "desc": "<p>The <code>subprocess.kill()</code> method sends a signal to the child process. If no\nargument is given, the process will be sent the <code>'SIGTERM'</code> signal. See\n<a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a> for a list of available signals. This function returns <code>true</code> if\n<a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a> succeeds, and <code>false</code> otherwise.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst grep = spawn('grep', ['ssh']);\n\ngrep.on('close', (code, signal) => {\n  console.log(\n    `child process terminated due to receipt of signal ${signal}`);\n});\n\n// Send SIGHUP to process.\ngrep.kill('SIGHUP');\n</code></pre>\n<p>The <a href=\"child_process.html#child_process_class_childprocess\"><code>ChildProcess</code></a> object may emit an <a href=\"child_process.html#child_process_event_error\"><code>'error'</code></a> event if the signal\ncannot be delivered. Sending a signal to a child process that has already exited\nis not an error but may have unforeseen consequences. Specifically, if the\nprocess identifier (PID) has been reassigned to another process, the signal will\nbe delivered to that process instead which can have unexpected results.</p>\n<p>While the function is called <code>kill</code>, the signal delivered to the child process\nmay not actually terminate the process.</p>\n<p>See <a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a> for reference.</p>\n<p>On Windows, where POSIX signals do not exist, the <code>signal</code> argument will be\nignored, and the process will be killed forcefully and abruptly (similar to\n<code>'SIGKILL'</code>).\nSee <a href=\"process.html#process_signal_events\">Signal Events</a> for more details.</p>\n<p>On Linux, child processes of child processes will not be terminated\nwhen attempting to kill their parent. This is likely to happen when running a\nnew process in a shell or with the use of the <code>shell</code> option of <code>ChildProcess</code>:</p>\n<pre><code class=\"language-js\">'use strict';\nconst { spawn } = require('child_process');\n\nconst subprocess = spawn(\n  'sh',\n  [\n    '-c',\n    `node -e \"setInterval(() => {\n      console.log(process.pid, 'is alive')\n    }, 500);\"`,\n  ], {\n    stdio: ['inherit', 'inherit', 'inherit']\n  }\n);\n\nsetTimeout(() => {\n  subprocess.kill(); // Does not terminate the Node.js process in the shell.\n}, 2000);\n</code></pre>"
             },
             {
               "textRaw": "`subprocess.ref()`",
@@ -18362,7 +19705,7 @@
                   ]
                 }
               ],
-              "desc": "<p>When an IPC channel has been established between the parent and child (\ni.e. when using <a href=\"child_process.html#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>), the <code>subprocess.send()</code> method can\nbe used to send messages to the child process. When the child process is a\nNode.js instance, these messages can be received via the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event.</p>\n<p>The message goes through serialization and parsing. The resulting\nmessage might not be the same as what is originally sent.</p>\n<p>For example, in the parent script:</p>\n<pre><code class=\"language-js\">const cp = require('child_process');\nconst n = cp.fork(`${__dirname}/sub.js`);\n\nn.on('message', (m) => {\n  console.log('PARENT got message:', m);\n});\n\n// Causes the child to print: CHILD got message: { hello: 'world' }\nn.send({ hello: 'world' });\n</code></pre>\n<p>And then the child script, <code>'sub.js'</code> might look like this:</p>\n<pre><code class=\"language-js\">process.on('message', (m) => {\n  console.log('CHILD got message:', m);\n});\n\n// Causes the parent to print: PARENT got message: { foo: 'bar', baz: null }\nprocess.send({ foo: 'bar', baz: NaN });\n</code></pre>\n<p>Child Node.js processes will have a <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> method of their own\nthat allows the child to send messages back to the parent.</p>\n<p>There is a special case when sending a <code>{cmd: 'NODE_foo'}</code> message. Messages\ncontaining a <code>NODE_</code> prefix in the <code>cmd</code> property are reserved for use within\nNode.js core and will not be emitted in the child's <a href=\"process.html#process_event_message\"><code>'message'</code></a>\nevent. Rather, such messages are emitted using the\n<code>'internalMessage'</code> event and are consumed internally by Node.js.\nApplications should avoid using such messages or listening for\n<code>'internalMessage'</code> events as it is subject to change without notice.</p>\n<p>The optional <code>sendHandle</code> argument that may be passed to <code>subprocess.send()</code> is\nfor passing a TCP server or socket object to the child process. The child will\nreceive the object as the second argument passed to the callback function\nregistered on the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event. Any data that is received\nand buffered in the socket will not be sent to the child.</p>\n<p>The optional <code>callback</code> is a function that is invoked after the message is\nsent but before the child may have received it. The function is called with a\nsingle argument: <code>null</code> on success, or an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object on failure.</p>\n<p>If no <code>callback</code> function is provided and the message cannot be sent, an\n<code>'error'</code> event will be emitted by the <a href=\"child_process.html#child_process_child_process\"><code>ChildProcess</code></a> object. This can\nhappen, for instance, when the child process has already exited.</p>\n<p><code>subprocess.send()</code> will return <code>false</code> if the channel has closed or when the\nbacklog of unsent messages exceeds a threshold that makes it unwise to send\nmore. Otherwise, the method returns <code>true</code>. The <code>callback</code> function can be\nused to implement flow control.</p>\n<h4>Example: sending a server object</h4>\n<p>The <code>sendHandle</code> argument can be used, for instance, to pass the handle of\na TCP server object to the child process as illustrated in the example below:</p>\n<pre><code class=\"language-js\">const subprocess = require('child_process').fork('subprocess.js');\n\n// Open up the server object and send the handle.\nconst server = require('net').createServer();\nserver.on('connection', (socket) => {\n  socket.end('handled by parent');\n});\nserver.listen(1337, () => {\n  subprocess.send('server', server);\n});\n</code></pre>\n<p>The child would then receive the server object as:</p>\n<pre><code class=\"language-js\">process.on('message', (m, server) => {\n  if (m === 'server') {\n    server.on('connection', (socket) => {\n      socket.end('handled by child');\n    });\n  }\n});\n</code></pre>\n<p>Once the server is now shared between the parent and child, some connections\ncan be handled by the parent and some by the child.</p>\n<p>While the example above uses a server created using the <code>net</code> module, <code>dgram</code>\nmodule servers use exactly the same workflow with the exceptions of listening on\na <code>'message'</code> event instead of <code>'connection'</code> and using <code>server.bind()</code> instead\nof <code>server.listen()</code>. This is, however, currently only supported on Unix\nplatforms.</p>\n<h4>Example: sending a socket object</h4>\n<p>Similarly, the <code>sendHandler</code> argument can be used to pass the handle of a\nsocket to the child process. The example below spawns two children that each\nhandle connections with \"normal\" or \"special\" priority:</p>\n<pre><code class=\"language-js\">const { fork } = require('child_process');\nconst normal = fork('subprocess.js', ['normal']);\nconst special = fork('subprocess.js', ['special']);\n\n// Open up the server and send sockets to child. Use pauseOnConnect to prevent\n// the sockets from being read before they are sent to the child process.\nconst server = require('net').createServer({ pauseOnConnect: true });\nserver.on('connection', (socket) => {\n\n  // If this is special priority...\n  if (socket.remoteAddress === '74.125.127.100') {\n    special.send('socket', socket);\n    return;\n  }\n  // This is normal priority.\n  normal.send('socket', socket);\n});\nserver.listen(1337);\n</code></pre>\n<p>The <code>subprocess.js</code> would receive the socket handle as the second argument\npassed to the event callback function:</p>\n<pre><code class=\"language-js\">process.on('message', (m, socket) => {\n  if (m === 'socket') {\n    if (socket) {\n      // Check that the client socket exists.\n      // It is possible for the socket to be closed between the time it is\n      // sent and the time it is received in the child process.\n      socket.end(`Request handled with ${process.argv[2]} priority`);\n    }\n  }\n});\n</code></pre>\n<p>Do not use <code>.maxConnections</code> on a socket that has been passed to a subprocess.\nThe parent cannot track when the socket is destroyed.</p>\n<p>Any <code>'message'</code> handlers in the subprocess should verify that <code>socket</code> exists,\nas the connection may have been closed during the time it takes to send the\nconnection to the child.</p>"
+              "desc": "<p>When an IPC channel has been established between the parent and child (\ni.e. when using <a href=\"child_process.html#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>), the <code>subprocess.send()</code> method can\nbe used to send messages to the child process. When the child process is a\nNode.js instance, these messages can be received via the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event.</p>\n<p>The message goes through serialization and parsing. The resulting\nmessage might not be the same as what is originally sent.</p>\n<p>For example, in the parent script:</p>\n<pre><code class=\"language-js\">const cp = require('child_process');\nconst n = cp.fork(`${__dirname}/sub.js`);\n\nn.on('message', (m) => {\n  console.log('PARENT got message:', m);\n});\n\n// Causes the child to print: CHILD got message: { hello: 'world' }\nn.send({ hello: 'world' });\n</code></pre>\n<p>And then the child script, <code>'sub.js'</code> might look like this:</p>\n<pre><code class=\"language-js\">process.on('message', (m) => {\n  console.log('CHILD got message:', m);\n});\n\n// Causes the parent to print: PARENT got message: { foo: 'bar', baz: null }\nprocess.send({ foo: 'bar', baz: NaN });\n</code></pre>\n<p>Child Node.js processes will have a <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> method of their own\nthat allows the child to send messages back to the parent.</p>\n<p>There is a special case when sending a <code>{cmd: 'NODE_foo'}</code> message. Messages\ncontaining a <code>NODE_</code> prefix in the <code>cmd</code> property are reserved for use within\nNode.js core and will not be emitted in the child's <a href=\"process.html#process_event_message\"><code>'message'</code></a>\nevent. Rather, such messages are emitted using the\n<code>'internalMessage'</code> event and are consumed internally by Node.js.\nApplications should avoid using such messages or listening for\n<code>'internalMessage'</code> events as it is subject to change without notice.</p>\n<p>The optional <code>sendHandle</code> argument that may be passed to <code>subprocess.send()</code> is\nfor passing a TCP server or socket object to the child process. The child will\nreceive the object as the second argument passed to the callback function\nregistered on the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event. Any data that is received\nand buffered in the socket will not be sent to the child.</p>\n<p>The optional <code>callback</code> is a function that is invoked after the message is\nsent but before the child may have received it. The function is called with a\nsingle argument: <code>null</code> on success, or an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object on failure.</p>\n<p>If no <code>callback</code> function is provided and the message cannot be sent, an\n<code>'error'</code> event will be emitted by the <a href=\"child_process.html#child_process_class_childprocess\"><code>ChildProcess</code></a> object. This can\nhappen, for instance, when the child process has already exited.</p>\n<p><code>subprocess.send()</code> will return <code>false</code> if the channel has closed or when the\nbacklog of unsent messages exceeds a threshold that makes it unwise to send\nmore. Otherwise, the method returns <code>true</code>. The <code>callback</code> function can be\nused to implement flow control.</p>\n<h4>Example: sending a server object</h4>\n<p>The <code>sendHandle</code> argument can be used, for instance, to pass the handle of\na TCP server object to the child process as illustrated in the example below:</p>\n<pre><code class=\"language-js\">const subprocess = require('child_process').fork('subprocess.js');\n\n// Open up the server object and send the handle.\nconst server = require('net').createServer();\nserver.on('connection', (socket) => {\n  socket.end('handled by parent');\n});\nserver.listen(1337, () => {\n  subprocess.send('server', server);\n});\n</code></pre>\n<p>The child would then receive the server object as:</p>\n<pre><code class=\"language-js\">process.on('message', (m, server) => {\n  if (m === 'server') {\n    server.on('connection', (socket) => {\n      socket.end('handled by child');\n    });\n  }\n});\n</code></pre>\n<p>Once the server is now shared between the parent and child, some connections\ncan be handled by the parent and some by the child.</p>\n<p>While the example above uses a server created using the <code>net</code> module, <code>dgram</code>\nmodule servers use exactly the same workflow with the exceptions of listening on\na <code>'message'</code> event instead of <code>'connection'</code> and using <code>server.bind()</code> instead\nof <code>server.listen()</code>. This is, however, currently only supported on Unix\nplatforms.</p>\n<h4>Example: sending a socket object</h4>\n<p>Similarly, the <code>sendHandler</code> argument can be used to pass the handle of a\nsocket to the child process. The example below spawns two children that each\nhandle connections with \"normal\" or \"special\" priority:</p>\n<pre><code class=\"language-js\">const { fork } = require('child_process');\nconst normal = fork('subprocess.js', ['normal']);\nconst special = fork('subprocess.js', ['special']);\n\n// Open up the server and send sockets to child. Use pauseOnConnect to prevent\n// the sockets from being read before they are sent to the child process.\nconst server = require('net').createServer({ pauseOnConnect: true });\nserver.on('connection', (socket) => {\n\n  // If this is special priority...\n  if (socket.remoteAddress === '74.125.127.100') {\n    special.send('socket', socket);\n    return;\n  }\n  // This is normal priority.\n  normal.send('socket', socket);\n});\nserver.listen(1337);\n</code></pre>\n<p>The <code>subprocess.js</code> would receive the socket handle as the second argument\npassed to the event callback function:</p>\n<pre><code class=\"language-js\">process.on('message', (m, socket) => {\n  if (m === 'socket') {\n    if (socket) {\n      // Check that the client socket exists.\n      // It is possible for the socket to be closed between the time it is\n      // sent and the time it is received in the child process.\n      socket.end(`Request handled with ${process.argv[2]} priority`);\n    }\n  }\n});\n</code></pre>\n<p>Do not use <code>.maxConnections</code> on a socket that has been passed to a subprocess.\nThe parent cannot track when the socket is destroyed.</p>\n<p>Any <code>'message'</code> handlers in the subprocess should verify that <code>socket</code> exists,\nas the connection may have been closed during the time it takes to send the\nconnection to the child.</p>"
             },
             {
               "textRaw": "`subprocess.unref()`",
@@ -18385,7 +19728,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Child process"
+      "displayName": "Child process",
+      "source": "doc/api/child_process.md"
     },
     {
       "textRaw": "Cluster",
@@ -18393,7 +19737,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/cluster.js\">lib/cluster.js</a></p>\n<p>A single instance of Node.js runs in a single thread. To take advantage of\nmulti-core systems, the user will sometimes want to launch a cluster of Node.js\nprocesses to handle the load.</p>\n<p>The cluster module allows easy creation of child processes that all share\nserver ports.</p>\n<pre><code class=\"language-js\">const cluster = require('cluster');\nconst http = require('http');\nconst numCPUs = require('os').cpus().length;\n\nif (cluster.isMaster) {\n  console.log(`Master ${process.pid} is running`);\n\n  // Fork workers.\n  for (let i = 0; i &#x3C; numCPUs; i++) {\n    cluster.fork();\n  }\n\n  cluster.on('exit', (worker, code, signal) => {\n    console.log(`worker ${worker.process.pid} died`);\n  });\n} else {\n  // Workers can share any TCP connection\n  // In this case it is an HTTP server\n  http.createServer((req, res) => {\n    res.writeHead(200);\n    res.end('hello world\\n');\n  }).listen(8000);\n\n  console.log(`Worker ${process.pid} started`);\n}\n</code></pre>\n<p>Running Node.js will now share port 8000 between the workers:</p>\n<pre><code class=\"language-console\">$ node server.js\nMaster 3596 is running\nWorker 4324 started\nWorker 4520 started\nWorker 6056 started\nWorker 5644 started\n</code></pre>\n<p>On Windows, it is not yet possible to set up a named pipe server in a worker.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/cluster.js\">lib/cluster.js</a></p>\n<p>A single instance of Node.js runs in a single thread. To take advantage of\nmulti-core systems, the user will sometimes want to launch a cluster of Node.js\nprocesses to handle the load.</p>\n<p>The cluster module allows easy creation of child processes that all share\nserver ports.</p>\n<pre><code class=\"language-js\">const cluster = require('cluster');\nconst http = require('http');\nconst numCPUs = require('os').cpus().length;\n\nif (cluster.isMaster) {\n  console.log(`Master ${process.pid} is running`);\n\n  // Fork workers.\n  for (let i = 0; i &#x3C; numCPUs; i++) {\n    cluster.fork();\n  }\n\n  cluster.on('exit', (worker, code, signal) => {\n    console.log(`worker ${worker.process.pid} died`);\n  });\n} else {\n  // Workers can share any TCP connection\n  // In this case it is an HTTP server\n  http.createServer((req, res) => {\n    res.writeHead(200);\n    res.end('hello world\\n');\n  }).listen(8000);\n\n  console.log(`Worker ${process.pid} started`);\n}\n</code></pre>\n<p>Running Node.js will now share port 8000 between the workers:</p>\n<pre><code class=\"language-console\">$ node server.js\nMaster 3596 is running\nWorker 4324 started\nWorker 4520 started\nWorker 6056 started\nWorker 5644 started\n</code></pre>\n<p>On Windows, it is not yet possible to set up a named pipe server in a worker.</p>",
       "miscs": [
         {
           "textRaw": "How it works",
@@ -19011,7 +20355,10 @@
             ],
             "changes": [
               {
-                "version": "v12.16.0",
+                "version": [
+                  "v13.2.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/30162",
                 "description": "The `serialization` option is supported now."
               },
@@ -19140,7 +20487,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Cluster"
+      "displayName": "Cluster",
+      "source": "doc/api/cluster.md"
     },
     {
       "textRaw": "Console",
@@ -19148,7 +20496,7 @@
       "introduced_in": "v0.10.13",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/console.js\">lib/console.js</a></p>\n<p>The <code>console</code> module provides a simple debugging console that is similar to the\nJavaScript console mechanism provided by web browsers.</p>\n<p>The module exports two specific components:</p>\n<ul>\n<li>A <code>Console</code> class with methods such as <code>console.log()</code>, <code>console.error()</code> and\n<code>console.warn()</code> that can be used to write to any Node.js stream.</li>\n<li>A global <code>console</code> instance configured to write to <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> and\n<a href=\"process.html#process_process_stderr\"><code>process.stderr</code></a>. The global <code>console</code> can be used without calling\n<code>require('console')</code>.</li>\n</ul>\n<p><strong><em>Warning</em></strong>: The global console object's methods are neither consistently\nsynchronous like the browser APIs they resemble, nor are they consistently\nasynchronous like all other Node.js streams. See the <a href=\"process.html#process_a_note_on_process_i_o\">note on process I/O</a> for\nmore information.</p>\n<p>Example using the global <code>console</code>:</p>\n<pre><code class=\"language-js\">console.log('hello world');\n// Prints: hello world, to stdout\nconsole.log('hello %s', 'world');\n// Prints: hello world, to stdout\nconsole.error(new Error('Whoops, something bad happened'));\n// Prints: [Error: Whoops, something bad happened], to stderr\n\nconst name = 'Will Robinson';\nconsole.warn(`Danger ${name}! Danger!`);\n// Prints: Danger Will Robinson! Danger!, to stderr\n</code></pre>\n<p>Example using the <code>Console</code> class:</p>\n<pre><code class=\"language-js\">const out = getStreamSomehow();\nconst err = getStreamSomehow();\nconst myConsole = new console.Console(out, err);\n\nmyConsole.log('hello world');\n// Prints: hello world, to out\nmyConsole.log('hello %s', 'world');\n// Prints: hello world, to out\nmyConsole.error(new Error('Whoops, something bad happened'));\n// Prints: [Error: Whoops, something bad happened], to err\n\nconst name = 'Will Robinson';\nmyConsole.warn(`Danger ${name}! Danger!`);\n// Prints: Danger Will Robinson! Danger!, to err\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/console.js\">lib/console.js</a></p>\n<p>The <code>console</code> module provides a simple debugging console that is similar to the\nJavaScript console mechanism provided by web browsers.</p>\n<p>The module exports two specific components:</p>\n<ul>\n<li>A <code>Console</code> class with methods such as <code>console.log()</code>, <code>console.error()</code> and\n<code>console.warn()</code> that can be used to write to any Node.js stream.</li>\n<li>A global <code>console</code> instance configured to write to <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> and\n<a href=\"process.html#process_process_stderr\"><code>process.stderr</code></a>. The global <code>console</code> can be used without calling\n<code>require('console')</code>.</li>\n</ul>\n<p><em><strong>Warning</strong></em>: The global console object's methods are neither consistently\nsynchronous like the browser APIs they resemble, nor are they consistently\nasynchronous like all other Node.js streams. See the <a href=\"process.html#process_a_note_on_process_i_o\">note on process I/O</a> for\nmore information.</p>\n<p>Example using the global <code>console</code>:</p>\n<pre><code class=\"language-js\">console.log('hello world');\n// Prints: hello world, to stdout\nconsole.log('hello %s', 'world');\n// Prints: hello world, to stdout\nconsole.error(new Error('Whoops, something bad happened'));\n// Prints error message and stack trace to stderr:\n//   Error: Whoops, something bad happened\n//     at [eval]:5:15\n//     at Script.runInThisContext (node:vm:132:18)\n//     at Object.runInThisContext (node:vm:309:38)\n//     at node:internal/process/execution:77:19\n//     at [eval]-wrapper:6:22\n//     at evalScript (node:internal/process/execution:76:60)\n//     at node:internal/main/eval_string:23:3\n\nconst name = 'Will Robinson';\nconsole.warn(`Danger ${name}! Danger!`);\n// Prints: Danger Will Robinson! Danger!, to stderr\n</code></pre>\n<p>Example using the <code>Console</code> class:</p>\n<pre><code class=\"language-js\">const out = getStreamSomehow();\nconst err = getStreamSomehow();\nconst myConsole = new console.Console(out, err);\n\nmyConsole.log('hello world');\n// Prints: hello world, to out\nmyConsole.log('hello %s', 'world');\n// Prints: hello world, to out\nmyConsole.error(new Error('Whoops, something bad happened'));\n// Prints: [Error: Whoops, something bad happened], to err\n\nconst name = 'Will Robinson';\nmyConsole.warn(`Danger ${name}! Danger!`);\n// Prints: Danger Will Robinson! Danger!, to err\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `Console`",
@@ -19574,7 +20922,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Starts a timer that can be used to compute the duration of an operation. Timers\nare identified by a unique <code>label</code>. Use the same <code>label</code> when calling\n<a href=\"console.html#console_console_timeend_label\"><code>console.timeEnd()</code></a> to stop the timer and output the elapsed time in\nmilliseconds to <code>stdout</code>. Timer durations are accurate to the sub-millisecond.</p>"
+              "desc": "<p>Starts a timer that can be used to compute the duration of an operation. Timers\nare identified by a unique <code>label</code>. Use the same <code>label</code> when calling\n<a href=\"console.html#console_console_timeend_label\"><code>console.timeEnd()</code></a> to stop the timer and output the elapsed time in\nsuitable time units to <code>stdout</code>. For example, if the elapsed\ntime is 3869ms, <code>console.timeEnd()</code> displays \"3.869s\".</p>"
             },
             {
               "textRaw": "`console.timeEnd([label])`",
@@ -19585,6 +20933,11 @@
                   "v0.1.104"
                 ],
                 "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29251",
+                    "description": "The elapsed time is displayed with a suitable time unit."
+                  },
                   {
                     "version": "v6.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/5901",
@@ -19875,7 +21228,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Console"
+      "displayName": "Console",
+      "source": "doc/api/console.md"
     },
     {
       "textRaw": "Crypto",
@@ -19883,7 +21237,7 @@
       "introduced_in": "v0.3.6",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/crypto.js\">lib/crypto.js</a></p>\n<p>The <code>crypto</code> module provides cryptographic functionality that includes a set of\nwrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.</p>\n<p>Use <code>require('crypto')</code> to access this module.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n\nconst secret = 'abcdefg';\nconst hash = crypto.createHmac('sha256', secret)\n                   .update('I love cupcakes')\n                   .digest('hex');\nconsole.log(hash);\n// Prints:\n//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/crypto.js\">lib/crypto.js</a></p>\n<p>The <code>crypto</code> module provides cryptographic functionality that includes a set of\nwrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.</p>\n<p>Use <code>require('crypto')</code> to access this module.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n\nconst secret = 'abcdefg';\nconst hash = crypto.createHmac('sha256', secret)\n                   .update('I love cupcakes')\n                   .digest('hex');\nconsole.log(hash);\n// Prints:\n//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e\n</code></pre>",
       "modules": [
         {
           "textRaw": "Determining if crypto support is unavailable",
@@ -20012,7 +21366,10 @@
                     "description": "The `key` argument can now be a `KeyObject`."
                   },
                   {
-                    "version": "v11.2.0",
+                    "version": [
+                      "v11.2.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/24081",
                     "description": "The cipher `chacha20-poly1305` is now supported."
                   },
@@ -20132,7 +21489,10 @@
                     "description": "The `key` argument can now be a `KeyObject`."
                   },
                   {
-                    "version": "v11.2.0",
+                    "version": [
+                      "v11.2.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/24081",
                     "description": "The cipher `chacha20-poly1305` is now supported."
                   },
@@ -20557,9 +21917,9 @@
                   },
                   "params": [
                     {
-                      "textRaw": "`key` {Buffer}",
+                      "textRaw": "`key` {Buffer | TypedArray | DataView}",
                       "name": "key",
-                      "type": "Buffer"
+                      "type": "Buffer | TypedArray | DataView"
                     }
                   ]
                 }
@@ -20640,7 +22000,7 @@
               "name": "diffieHellman",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.9.0"
                 ],
                 "changes": []
               },
@@ -20684,7 +22044,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/31178",
                     "description": "Add support for Diffie-Hellman."
                   },
@@ -20820,7 +22180,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/31178",
                     "description": "Add support for Diffie-Hellman."
                   },
@@ -21064,6 +22424,11 @@
                   "v0.5.5"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/30578",
+                    "description": "The `iterations` parameter is now restricted to positive values. Earlier releases treated other values as one."
+                  },
                   {
                     "version": "v8.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/11305",
@@ -21140,6 +22505,11 @@
                   "v0.9.3"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/30578",
+                    "description": "The `iterations` parameter is now restricted to positive values. Earlier releases treated other values as one."
+                  },
                   {
                     "version": "v6.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/4047",
@@ -21614,7 +22984,7 @@
               "name": "randomInt",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.10.0"
                 ],
                 "changes": []
               },
@@ -21644,6 +23014,42 @@
               ],
               "desc": "<p>Return a random integer <code>n</code> such that <code>min &#x3C;= n &#x3C; max</code>.  This\nimplementation avoids <a href=\"https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias\">modulo bias</a>.</p>\n<p>The range (<code>max - min</code>) must be less than 2<sup>48</sup>. <code>min</code> and <code>max</code> must\nbe <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger\">safe integers</a>.</p>\n<p>If the <code>callback</code> function is not provided, the random integer is\ngenerated synchronously.</p>\n<pre><code class=\"language-js\">// Asynchronous\ncrypto.randomInt(3, (err, n) => {\n  if (err) throw err;\n  console.log(`Random number chosen from (0, 1, 2): ${n}`);\n});\n</code></pre>\n<pre><code class=\"language-js\">// Synchronous\nconst n = crypto.randomInt(3);\nconsole.log(`Random number chosen from (0, 1, 2): ${n}`);\n</code></pre>\n<pre><code class=\"language-js\">// With `min` argument\nconst n = crypto.randomInt(1, 7);\nconsole.log(`The dice rolled: ${n}`);\n</code></pre>"
             },
+            {
+              "textRaw": "`crypto.randomUUID([options])`",
+              "type": "method",
+              "name": "randomUUID",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {string}",
+                    "name": "return",
+                    "type": "string"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`disableEntropyCache` {boolean} By default, to improve performance, Node.js generates and caches enough random data to generate up to 128 random UUIDs. To generate a UUID without using the cache, set `disableEntropyCache` to `true`. **Defaults**: `false`.",
+                          "name": "disableEntropyCache",
+                          "type": "boolean",
+                          "desc": "By default, to improve performance, Node.js generates and caches enough random data to generate up to 128 random UUIDs. To generate a UUID without using the cache, set `disableEntropyCache` to `true`. **Defaults**: `false`."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Generates a random <a href=\"https://www.rfc-editor.org/rfc/rfc4122.txt\">RFC 4122</a> version 4 UUID. The UUID is generated using a\ncryptographic pseudorandom number generator.</p>"
+            },
             {
               "textRaw": "`crypto.scrypt(password, salt, keylen[, options], callback)`",
               "type": "method",
@@ -21654,7 +23060,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.8.0",
+                    "version": [
+                      "v12.8.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/28799",
                     "description": "The `maxmem` value can now be any safe integer."
                   },
@@ -21756,7 +23165,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Provides an asynchronous <a href=\"https://en.wikipedia.org/wiki/Scrypt\">scrypt</a> implementation. Scrypt is a password-based\nkey derivation function that is designed to be expensive computationally and\nmemory-wise in order to make brute-force attacks unrewarding.</p>\n<p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is\nrandom and at least 16 bytes long. See <a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf\">NIST SP 800-132</a> for details.</p>\n<p>The <code>callback</code> function is called with two arguments: <code>err</code> and <code>derivedKey</code>.\n<code>err</code> is an exception object when key derivation fails, otherwise <code>err</code> is\n<code>null</code>. <code>derivedKey</code> is passed to the callback as a <a href=\"buffer.html\"><code>Buffer</code></a>.</p>\n<p>An exception is thrown when any of the input arguments specify invalid values\nor types.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n// Using the factory defaults.\ncrypto.scrypt('secret', 'salt', 64, (err, derivedKey) => {\n  if (err) throw err;\n  console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'\n});\n// Using a custom N parameter. Must be a power of two.\ncrypto.scrypt('secret', 'salt', 64, { N: 1024 }, (err, derivedKey) => {\n  if (err) throw err;\n  console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'\n});\n</code></pre>"
+              "desc": "<p>Provides an asynchronous <a href=\"https://en.wikipedia.org/wiki/Scrypt\">scrypt</a> implementation. Scrypt is a password-based\nkey derivation function that is designed to be expensive computationally and\nmemory-wise in order to make brute-force attacks unrewarding.</p>\n<p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is\nrandom and at least 16 bytes long. See <a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf\">NIST SP 800-132</a> for details.</p>\n<p>The <code>callback</code> function is called with two arguments: <code>err</code> and <code>derivedKey</code>.\n<code>err</code> is an exception object when key derivation fails, otherwise <code>err</code> is\n<code>null</code>. <code>derivedKey</code> is passed to the callback as a <a href=\"buffer.html\"><code>Buffer</code></a>.</p>\n<p>An exception is thrown when any of the input arguments specify invalid values\nor types.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n// Using the factory defaults.\ncrypto.scrypt('password', 'salt', 64, (err, derivedKey) => {\n  if (err) throw err;\n  console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'\n});\n// Using a custom N parameter. Must be a power of two.\ncrypto.scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {\n  if (err) throw err;\n  console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'\n});\n</code></pre>"
             },
             {
               "textRaw": "`crypto.scryptSync(password, salt, keylen[, options])`",
@@ -21768,7 +23177,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.8.0",
+                    "version": [
+                      "v12.8.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/28799",
                     "description": "The `maxmem` value can now be any safe integer."
                   },
@@ -21858,7 +23270,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Provides a synchronous <a href=\"https://en.wikipedia.org/wiki/Scrypt\">scrypt</a> implementation. Scrypt is a password-based\nkey derivation function that is designed to be expensive computationally and\nmemory-wise in order to make brute-force attacks unrewarding.</p>\n<p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is\nrandom and at least 16 bytes long. See <a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf\">NIST SP 800-132</a> for details.</p>\n<p>An exception is thrown when key derivation fails, otherwise the derived key is\nreturned as a <a href=\"buffer.html\"><code>Buffer</code></a>.</p>\n<p>An exception is thrown when any of the input arguments specify invalid values\nor types.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n// Using the factory defaults.\nconst key1 = crypto.scryptSync('secret', 'salt', 64);\nconsole.log(key1.toString('hex'));  // '3745e48...08d59ae'\n// Using a custom N parameter. Must be a power of two.\nconst key2 = crypto.scryptSync('secret', 'salt', 64, { N: 1024 });\nconsole.log(key2.toString('hex'));  // '3745e48...aa39b34'\n</code></pre>"
+              "desc": "<p>Provides a synchronous <a href=\"https://en.wikipedia.org/wiki/Scrypt\">scrypt</a> implementation. Scrypt is a password-based\nkey derivation function that is designed to be expensive computationally and\nmemory-wise in order to make brute-force attacks unrewarding.</p>\n<p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is\nrandom and at least 16 bytes long. See <a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf\">NIST SP 800-132</a> for details.</p>\n<p>An exception is thrown when key derivation fails, otherwise the derived key is\nreturned as a <a href=\"buffer.html\"><code>Buffer</code></a>.</p>\n<p>An exception is thrown when any of the input arguments specify invalid values\nor types.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n// Using the factory defaults.\nconst key1 = crypto.scryptSync('password', 'salt', 64);\nconsole.log(key1.toString('hex'));  // '3745e48...08d59ae'\n// Using a custom N parameter. Must be a power of two.\nconst key2 = crypto.scryptSync('password', 'salt', 64, { N: 1024 });\nconsole.log(key2.toString('hex'));  // '3745e48...aa39b34'\n</code></pre>"
             },
             {
               "textRaw": "`crypto.setEngine(engine[, flags])`",
@@ -21921,7 +23333,16 @@
                 "added": [
                   "v12.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29292",
+                    "description": "This function now supports IEEE-P1363 DSA and ECDSA signatures."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -21982,7 +23403,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This function is based on a constant-time algorithm.\nReturns true if <code>a</code> is equal to <code>b</code>, without leaking timing information that\nwould allow an attacker to guess one of the values. This is suitable for\ncomparing HMAC digests or secret values like authentication cookies or\n<a href=\"https://www.w3.org/TR/capability-urls/\">capability urls</a>.</p>\n<p><code>a</code> and <code>b</code> must both be <code>Buffer</code>s, <code>TypedArray</code>s, or <code>DataView</code>s, and they\nmust have the same length.</p>\n<p>Use of <code>crypto.timingSafeEqual</code> does not guarantee that the <em>surrounding</em> code\nis timing-safe. Care should be taken to ensure that the surrounding code does\nnot introduce timing vulnerabilities.</p>"
+              "desc": "<p>This function is based on a constant-time algorithm.\nReturns true if <code>a</code> is equal to <code>b</code>, without leaking timing information that\nwould allow an attacker to guess one of the values. This is suitable for\ncomparing HMAC digests or secret values like authentication cookies or\n<a href=\"https://www.w3.org/TR/capability-urls/\">capability urls</a>.</p>\n<p><code>a</code> and <code>b</code> must both be <code>Buffer</code>s, <code>TypedArray</code>s, or <code>DataView</code>s, and they\nmust have the same byte length.</p>\n<p>If at least one of <code>a</code> and <code>b</code> is a <code>TypedArray</code> with more than one byte per\nentry, such as <code>Uint16Array</code>, the result will be computed using the platform\nbyte order.</p>\n<p>Use of <code>crypto.timingSafeEqual</code> does not guarantee that the <em>surrounding</em> code\nis timing-safe. Care should be taken to ensure that the surrounding code does\nnot introduce timing vulnerabilities.</p>"
             },
             {
               "textRaw": "`crypto.verify(algorithm, data, key, signature)`",
@@ -21992,7 +23413,16 @@
                 "added": [
                   "v12.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29292",
+                    "description": "This function now supports IEEE-P1363 DSA and ECDSA signatures."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -22025,7 +23455,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Verifies the given signature for <code>data</code> using the given key and algorithm. If\n<code>algorithm</code> is <code>null</code> or <code>undefined</code>, then the algorithm is dependent upon the\nkey type (especially Ed25519 and Ed448).</p>\n<p>If <code>key</code> is not a <a href=\"crypto.html#crypto_class_keyobject\"><code>KeyObject</code></a>, this function behaves as if <code>key</code> had been\npassed to <a href=\"crypto.html#crypto_crypto_createpublickey_key\"><code>crypto.createPublicKey()</code></a>. If it is an object, the following\nadditional properties can be passed:</p>\n<ul>\n<li>\n<p><code>dsaEncoding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> For DSA and ECDSA, this option specifies the\nformat of the generated signature. It can be one of the following:</p>\n<ul>\n<li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>\n<li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>\n</ul>\n</li>\n<li>\n<p><code>padding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Optional padding value for RSA, one of the following:</p>\n<ul>\n<li><code>crypto.constants.RSA_PKCS1_PADDING</code> (default)</li>\n<li><code>crypto.constants.RSA_PKCS1_PSS_PADDING</code></li>\n</ul>\n<p><code>RSA_PKCS1_PSS_PADDING</code> will use MGF1 with the same hash function\nused to sign the message as specified in section 3.1 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>.</p>\n</li>\n<li>\n<p><code>saltLength</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Salt length for when padding is\n<code>RSA_PKCS1_PSS_PADDING</code>. The special value\n<code>crypto.constants.RSA_PSS_SALTLEN_DIGEST</code> sets the salt length to the digest\nsize, <code>crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN</code> (default) sets it to the\nmaximum permissible value.</p>\n</li>\n</ul>\n<p>The <code>signature</code> argument is the previously calculated signature for the <code>data</code>.</p>\n<p>Because public keys can be derived from private keys, a private key or a public\nkey may be passed for <code>key</code>.</p>"
+              "desc": "<p>Verifies the given signature for <code>data</code> using the given key and algorithm. If\n<code>algorithm</code> is <code>null</code> or <code>undefined</code>, then the algorithm is dependent upon the\nkey type (especially Ed25519 and Ed448).</p>\n<p>If <code>key</code> is not a <a href=\"crypto.html#crypto_class_keyobject\"><code>KeyObject</code></a>, this function behaves as if <code>key</code> had been\npassed to <a href=\"crypto.html#crypto_crypto_createpublickey_key\"><code>crypto.createPublicKey()</code></a>. If it is an object, the following\nadditional properties can be passed:</p>\n<ul>\n<li>\n<p><code>dsaEncoding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> For DSA and ECDSA, this option specifies the\nformat of the signature. It can be one of the following:</p>\n<ul>\n<li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>\n<li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>\n</ul>\n</li>\n<li>\n<p><code>padding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Optional padding value for RSA, one of the following:</p>\n<ul>\n<li><code>crypto.constants.RSA_PKCS1_PADDING</code> (default)</li>\n<li><code>crypto.constants.RSA_PKCS1_PSS_PADDING</code></li>\n</ul>\n<p><code>RSA_PKCS1_PSS_PADDING</code> will use MGF1 with the same hash function\nused to sign the message as specified in section 3.1 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>.</p>\n</li>\n<li>\n<p><code>saltLength</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Salt length for when padding is\n<code>RSA_PKCS1_PSS_PADDING</code>. The special value\n<code>crypto.constants.RSA_PSS_SALTLEN_DIGEST</code> sets the salt length to the digest\nsize, <code>crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN</code> (default) sets it to the\nmaximum permissible value.</p>\n</li>\n</ul>\n<p>The <code>signature</code> argument is the previously calculated signature for the <code>data</code>.</p>\n<p>Because public keys can be derived from private keys, a private key or a public\nkey may be passed for <code>key</code>.</p>"
             }
           ],
           "type": "module",
@@ -22036,11 +23466,11 @@
           "name": "notes",
           "modules": [
             {
-              "textRaw": "Legacy Streams API (prior to Node.js 0.10)",
+              "textRaw": "Legacy streams API (prior to Node.js 0.10)",
               "name": "legacy_streams_api_(prior_to_node.js_0.10)",
               "desc": "<p>The Crypto module was added to Node.js before there was the concept of a\nunified Stream API, and before there were <a href=\"buffer.html\"><code>Buffer</code></a> objects for handling\nbinary data. As such, the many of the <code>crypto</code> defined classes have methods not\ntypically found on other Node.js classes that implement the <a href=\"stream.html\">streams</a>\nAPI (e.g. <code>update()</code>, <code>final()</code>, or <code>digest()</code>). Also, many methods accepted\nand returned <code>'latin1'</code> encoded strings by default rather than <code>Buffer</code>s. This\ndefault was changed after Node.js v0.8 to use <a href=\"buffer.html\"><code>Buffer</code></a> objects by default\ninstead.</p>",
               "type": "module",
-              "displayName": "Legacy Streams API (prior to Node.js 0.10)"
+              "displayName": "Legacy streams API (prior to Node.js 0.10)"
             },
             {
               "textRaw": "Recent ECDH changes",
@@ -22216,7 +23646,9 @@
             {
               "textRaw": "Legacy API",
               "name": "legacy_api",
-              "desc": "<p>As a still supported legacy interface, it is possible to create new instances of\nthe <code>crypto.Certificate</code> class as illustrated in the examples below.</p>",
+              "stability": 0,
+              "stabilityText": "Deprecated",
+              "desc": "<p>As a legacy interface, it is possible to create new instances of\nthe <code>crypto.Certificate</code> class as illustrated in the examples below.</p>",
               "ctors": [
                 {
                   "textRaw": "`new crypto.Certificate()`",
@@ -22366,6 +23798,29 @@
               ],
               "desc": "<p>Once the <code>cipher.final()</code> method has been called, the <code>Cipher</code> object can no\nlonger be used to encrypt data. Attempts to call <code>cipher.final()</code> more than\nonce will result in an error being thrown.</p>"
             },
+            {
+              "textRaw": "`cipher.getAuthTag()`",
+              "type": "method",
+              "name": "getAuthTag",
+              "meta": {
+                "added": [
+                  "v1.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Buffer} When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing the _authentication tag_ that has been computed from the given data.",
+                    "name": "return",
+                    "type": "Buffer",
+                    "desc": "When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing the _authentication tag_ that has been computed from the given data."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>The <code>cipher.getAuthTag()</code> method should only be called after encryption has\nbeen completed using the <a href=\"crypto.html#crypto_cipher_final_outputencoding\"><code>cipher.final()</code></a> method.</p>"
+            },
             {
               "textRaw": "`cipher.setAAD(buffer[, options])`",
               "type": "method",
@@ -22408,29 +23863,6 @@
               ],
               "desc": "<p>When using an authenticated encryption mode (<code>GCM</code>, <code>CCM</code> and <code>OCB</code> are\ncurrently supported), the <code>cipher.setAAD()</code> method sets the value used for the\n<em>additional authenticated data</em> (AAD) input parameter.</p>\n<p>The <code>options</code> argument is optional for <code>GCM</code> and <code>OCB</code>. When using <code>CCM</code>, the\n<code>plaintextLength</code> option must be specified and its value must match the length\nof the plaintext in bytes. See <a href=\"crypto.html#crypto_ccm_mode\">CCM mode</a>.</p>\n<p>The <code>cipher.setAAD()</code> method must be called before <a href=\"crypto.html#crypto_cipher_update_data_inputencoding_outputencoding\"><code>cipher.update()</code></a>.</p>"
             },
-            {
-              "textRaw": "`cipher.getAuthTag()`",
-              "type": "method",
-              "name": "getAuthTag",
-              "meta": {
-                "added": [
-                  "v1.0.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {Buffer} When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing the _authentication tag_ that has been computed from the given data.",
-                    "name": "return",
-                    "type": "Buffer",
-                    "desc": "When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing the _authentication tag_ that has been computed from the given data."
-                  },
-                  "params": []
-                }
-              ],
-              "desc": "<p>The <code>cipher.getAuthTag()</code> method should only be called after encryption has\nbeen completed using the <a href=\"crypto.html#crypto_cipher_final_outputencoding\"><code>cipher.final()</code></a> method.</p>"
-            },
             {
               "textRaw": "`cipher.setAutoPadding([autoPadding])`",
               "type": "method",
@@ -22997,7 +24429,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>DiffieHellmanGroup</code> class takes a well-known modp group as its argument but\notherwise works the same as <code>DiffieHellman</code>.</p>\n<pre><code class=\"language-js\">const name = 'modp1';\nconst dh = crypto.createDiffieHellmanGroup(name);\n</code></pre>\n<p><code>name</code> is taken from <a href=\"https://www.rfc-editor.org/rfc/rfc2412.txt\">RFC 2412</a> (modp1 and 2) and <a href=\"https://www.rfc-editor.org/rfc/rfc3526.txt\">RFC 3526</a>:</p>\n<pre><code class=\"language-console\">$ perl -ne 'print \"$1\\n\" if /\"(modp\\d+)\"/' src/node_crypto_groups.h\nmodp1  #  768 bits\nmodp2  # 1024 bits\nmodp5  # 1536 bits\nmodp14 # 2048 bits\nmodp15 # etc.\nmodp16\nmodp17\nmodp18\n</code></pre>"
+          "desc": "<p>The <code>DiffieHellmanGroup</code> class takes a well-known modp group as its argument.\nIt works the same as <code>DiffieHellman</code>, except that it does not allow changing\nits keys after creation. In other words, it does not implement <code>setPublicKey()</code>\nor <code>setPrivateKey()</code> methods.</p>\n<pre><code class=\"language-js\">const name = 'modp1';\nconst dh = crypto.createDiffieHellmanGroup(name);\n</code></pre>\n<p><code>name</code> is taken from <a href=\"https://www.rfc-editor.org/rfc/rfc2412.txt\">RFC 2412</a> (modp1 and 2) and <a href=\"https://www.rfc-editor.org/rfc/rfc3526.txt\">RFC 3526</a>:</p>\n<pre><code class=\"language-console\">$ perl -ne 'print \"$1\\n\" if /\"(modp\\d+)\"/' src/node_crypto_groups.h\nmodp1  #  768 bits\nmodp2  # 1024 bits\nmodp5  # 1536 bits\nmodp14 # 2048 bits\nmodp15 # etc.\nmodp16\nmodp17\nmodp18\n</code></pre>"
         },
         {
           "textRaw": "Class: `ECDH`",
@@ -23073,15 +24505,15 @@
                   "v0.11.14"
                 ],
                 "changes": [
-                  {
-                    "version": "v6.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/5522",
-                    "description": "The default `inputEncoding` changed from `binary` to `utf8`"
-                  },
                   {
                     "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/16849",
-                    "description": "Changed error format to better support invalid public key error"
+                    "description": "Changed error format to better support invalid public key error."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/5522",
+                    "description": "The default `inputEncoding` changed from `binary` to `utf8`."
                   }
                 ]
               },
@@ -23291,7 +24723,7 @@
             ],
             "changes": []
           },
-          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_transform\" class=\"type\">&lt;stream.Transform&gt;</a></li>\n</ul>\n<p>The <code>Hash</code> class is a utility for creating hash digests of data. It can be\nused in one of two ways:</p>\n<ul>\n<li>As a <a href=\"stream.html\">stream</a> that is both readable and writable, where data is written\nto produce a computed hash digest on the readable side, or</li>\n<li>Using the <a href=\"crypto.html#crypto_hash_update_data_inputencoding\"><code>hash.update()</code></a> and <a href=\"crypto.html#crypto_hash_digest_encoding\"><code>hash.digest()</code></a> methods to produce the\ncomputed hash.</li>\n</ul>\n<p>The <a href=\"crypto.html#crypto_crypto_createhash_algorithm_options\"><code>crypto.createHash()</code></a> method is used to create <code>Hash</code> instances. <code>Hash</code>\nobjects are not to be created directly using the <code>new</code> keyword.</p>\n<p>Example: Using <code>Hash</code> objects as streams:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst hash = crypto.createHash('sha256');\n\nhash.on('readable', () => {\n  // Only one element is going to be produced by the\n  // hash stream.\n  const data = hash.read();\n  if (data) {\n    console.log(data.toString('hex'));\n    // Prints:\n    //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50\n  }\n});\n\nhash.write('some data to hash');\nhash.end();\n</code></pre>\n<p>Example: Using <code>Hash</code> and piped streams:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst fs = require('fs');\nconst hash = crypto.createHash('sha256');\n\nconst input = fs.createReadStream('test.js');\ninput.pipe(hash).pipe(process.stdout);\n</code></pre>\n<p>Example: Using the <a href=\"crypto.html#crypto_hash_update_data_inputencoding\"><code>hash.update()</code></a> and <a href=\"crypto.html#crypto_hash_digest_encoding\"><code>hash.digest()</code></a> methods:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst hash = crypto.createHash('sha256');\n\nhash.update('some data to hash');\nconsole.log(hash.digest('hex'));\n// Prints:\n//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50\n</code></pre>",
+          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_transform\" class=\"type\">&lt;stream.Transform&gt;</a></li>\n</ul>\n<p>The <code>Hash</code> class is a utility for creating hash digests of data. It can be\nused in one of two ways:</p>\n<ul>\n<li>As a <a href=\"stream.html\">stream</a> that is both readable and writable, where data is written\nto produce a computed hash digest on the readable side, or</li>\n<li>Using the <a href=\"crypto.html#crypto_hash_update_data_inputencoding\"><code>hash.update()</code></a> and <a href=\"crypto.html#crypto_hash_digest_encoding\"><code>hash.digest()</code></a> methods to produce the\ncomputed hash.</li>\n</ul>\n<p>The <a href=\"crypto.html#crypto_crypto_createhash_algorithm_options\"><code>crypto.createHash()</code></a> method is used to create <code>Hash</code> instances. <code>Hash</code>\nobjects are not to be created directly using the <code>new</code> keyword.</p>\n<p>Example: Using <code>Hash</code> objects as streams:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst hash = crypto.createHash('sha256');\n\nhash.on('readable', () => {\n  // Only one element is going to be produced by the\n  // hash stream.\n  const data = hash.read();\n  if (data) {\n    console.log(data.toString('hex'));\n    // Prints:\n    //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50\n  }\n});\n\nhash.write('some data to hash');\nhash.end();\n</code></pre>\n<p>Example: Using <code>Hash</code> and piped streams:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst fs = require('fs');\nconst hash = crypto.createHash('sha256');\n\nconst input = fs.createReadStream('test.js');\ninput.pipe(hash).setEncoding('hex').pipe(process.stdout);\n</code></pre>\n<p>Example: Using the <a href=\"crypto.html#crypto_hash_update_data_inputencoding\"><code>hash.update()</code></a> and <a href=\"crypto.html#crypto_hash_digest_encoding\"><code>hash.digest()</code></a> methods:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst hash = crypto.createHash('sha256');\n\nhash.update('some data to hash');\nconsole.log(hash.digest('hex'));\n// Prints:\n//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50\n</code></pre>",
           "methods": [
             {
               "textRaw": "`hash.copy([options])`",
@@ -23299,7 +24731,7 @@
               "name": "copy",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.1.0"
                 ],
                 "changes": []
               },
@@ -23476,7 +24908,7 @@
             ],
             "changes": [
               {
-                "version": "v12.19.0",
+                "version": "v14.5.0",
                 "pr-url": "https://github.com/nodejs/node/pull/33360",
                 "description": "Instances of this class can now be passed to worker threads using `postMessage`."
               },
@@ -23499,14 +24931,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/31178",
                     "description": "Added support for `'dh'`."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26960",
-                    "description": "Added support for `'rsa-pss'`"
+                    "description": "Added support for `'rsa-pss'`."
                   },
                   {
                     "version": "v12.0.0",
@@ -23516,7 +24948,7 @@
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26774",
-                    "description": "Added support for `'x25519'` and `'x448'`"
+                    "description": "Added support for `'x25519'` and `'x448'`."
                   },
                   {
                     "version": "v12.0.0",
@@ -23579,7 +25011,7 @@
                   ]
                 }
               ],
-              "desc": "<p>For symmetric keys, this function allocates a <code>Buffer</code> containing the key\nmaterial and ignores any options.</p>\n<p>For asymmetric keys, the <code>options</code> parameter is used to determine the export\nformat.</p>\n<p>For public keys, the following encoding options can be used:</p>\n<ul>\n<li><code>type</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be one of <code>'pkcs1'</code> (RSA only) or <code>'spki'</code>.</li>\n<li><code>format</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be <code>'pem'</code> or <code>'der'</code>.</li>\n</ul>\n<p>For private keys, the following encoding options can be used:</p>\n<ul>\n<li><code>type</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be one of <code>'pkcs1'</code> (RSA only), <code>'pkcs8'</code> or\n<code>'sec1'</code> (EC only).</li>\n<li><code>format</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be <code>'pem'</code> or <code>'der'</code>.</li>\n<li><code>cipher</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If specified, the private key will be encrypted with\n the given <code>cipher</code> and <code>passphrase</code> using PKCS#5 v2.0 password based\nencryption.</li>\n<li><code>passphrase</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The passphrase to use for encryption, see\n<code>cipher</code>.</li>\n</ul>\n<p>When PEM encoding was selected, the result will be a string, otherwise it will\nbe a buffer containing the data encoded as DER.</p>\n<p>PKCS#1, SEC1, and PKCS#8 type keys can be encrypted by using a combination of\nthe <code>cipher</code> and <code>format</code> options. The PKCS#8 <code>type</code> can be used with any\n<code>format</code> to encrypt any key algorithm (RSA, EC, or DH) by specifying a\n<code>cipher</code>. PKCS#1 and SEC1 can only be encrypted by specifying a <code>cipher</code>\nwhen the PEM <code>format</code> is used. For maximum compatibility, use PKCS#8 for\nencrypted private keys. Since PKCS#8 defines its own\nencryption mechanism, PEM-level encryption is not supported when encrypting\na PKCS#8 key. See <a href=\"https://www.rfc-editor.org/rfc/rfc5208.txt\">RFC 5208</a> for PKCS#8 encryption and <a href=\"https://www.rfc-editor.org/rfc/rfc1421.txt\">RFC 1421</a> for\nPKCS#1 and SEC1 encryption.</p>"
+              "desc": "<p>For symmetric keys, this function allocates a <code>Buffer</code> containing the key\nmaterial and ignores any options.</p>\n<p>For asymmetric keys, the <code>options</code> parameter is used to determine the export\nformat.</p>\n<p>For public keys, the following encoding options can be used:</p>\n<ul>\n<li><code>type</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be one of <code>'pkcs1'</code> (RSA only) or <code>'spki'</code>.</li>\n<li><code>format</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be <code>'pem'</code> or <code>'der'</code>.</li>\n</ul>\n<p>For private keys, the following encoding options can be used:</p>\n<ul>\n<li><code>type</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be one of <code>'pkcs1'</code> (RSA only), <code>'pkcs8'</code> or\n<code>'sec1'</code> (EC only).</li>\n<li><code>format</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be <code>'pem'</code> or <code>'der'</code>.</li>\n<li><code>cipher</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If specified, the private key will be encrypted with\nthe given <code>cipher</code> and <code>passphrase</code> using PKCS#5 v2.0 password based\nencryption.</li>\n<li><code>passphrase</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The passphrase to use for encryption, see\n<code>cipher</code>.</li>\n</ul>\n<p>When PEM encoding was selected, the result will be a string, otherwise it will\nbe a buffer containing the data encoded as DER.</p>\n<p>PKCS#1, SEC1, and PKCS#8 type keys can be encrypted by using a combination of\nthe <code>cipher</code> and <code>format</code> options. The PKCS#8 <code>type</code> can be used with any\n<code>format</code> to encrypt any key algorithm (RSA, EC, or DH) by specifying a\n<code>cipher</code>. PKCS#1 and SEC1 can only be encrypted by specifying a <code>cipher</code>\nwhen the PEM <code>format</code> is used. For maximum compatibility, use PKCS#8 for\nencrypted private keys. Since PKCS#8 defines its own\nencryption mechanism, PEM-level encryption is not supported when encrypting\na PKCS#8 key. See <a href=\"https://www.rfc-editor.org/rfc/rfc5208.txt\">RFC 5208</a> for PKCS#8 encryption and <a href=\"https://www.rfc-editor.org/rfc/rfc1421.txt\">RFC 1421</a> for\nPKCS#1 and SEC1 encryption.</p>"
             }
           ]
         },
@@ -23604,6 +25036,14 @@
                   "v0.1.92"
                 ],
                 "changes": [
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29292",
+                    "description": "This function now supports IEEE-P1363 DSA and ECDSA signatures."
+                  },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26960",
@@ -23755,6 +25195,14 @@
                   "v0.1.92"
                 ],
                 "changes": [
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29292",
+                    "description": "This function now supports IEEE-P1363 DSA and ECDSA signatures."
+                  },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26960",
@@ -23817,13 +25265,179 @@
                   ]
                 }
               ],
-              "desc": "<p>Verifies the provided data using the given <code>object</code> and <code>signature</code>.</p>\n<p>If <code>object</code> is not a <a href=\"crypto.html#crypto_class_keyobject\"><code>KeyObject</code></a>, this function behaves as if\n<code>object</code> had been passed to <a href=\"crypto.html#crypto_crypto_createpublickey_key\"><code>crypto.createPublicKey()</code></a>. If it is an\nobject, the following additional properties can be passed:</p>\n<ul>\n<li>\n<p><code>dsaEncoding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> For DSA and ECDSA, this option specifies the\nformat of the generated signature. It can be one of the following:</p>\n<ul>\n<li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>\n<li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>\n</ul>\n</li>\n<li>\n<p><code>padding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Optional padding value for RSA, one of the following:</p>\n<ul>\n<li><code>crypto.constants.RSA_PKCS1_PADDING</code> (default)</li>\n<li><code>crypto.constants.RSA_PKCS1_PSS_PADDING</code></li>\n</ul>\n<p><code>RSA_PKCS1_PSS_PADDING</code> will use MGF1 with the same hash function\nused to verify the message as specified in section 3.1 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>, unless\nan MGF1 hash function has been specified as part of the key in compliance with\nsection 3.3 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>.</p>\n</li>\n<li>\n<p><code>saltLength</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Salt length for when padding is\n<code>RSA_PKCS1_PSS_PADDING</code>. The special value\n<code>crypto.constants.RSA_PSS_SALTLEN_DIGEST</code> sets the salt length to the digest\nsize, <code>crypto.constants.RSA_PSS_SALTLEN_AUTO</code> (default) causes it to be\ndetermined automatically.</p>\n</li>\n</ul>\n<p>The <code>signature</code> argument is the previously calculated signature for the data, in\nthe <code>signatureEncoding</code>.\nIf a <code>signatureEncoding</code> is specified, the <code>signature</code> is expected to be a\nstring; otherwise <code>signature</code> is expected to be a <a href=\"buffer.html\"><code>Buffer</code></a>,\n<code>TypedArray</code>, or <code>DataView</code>.</p>\n<p>The <code>verify</code> object can not be used again after <code>verify.verify()</code> has been\ncalled. Multiple calls to <code>verify.verify()</code> will result in an error being\nthrown.</p>\n<p>Because public keys can be derived from private keys, a private key may\nbe passed instead of a public key.</p>"
+              "desc": "<p>Verifies the provided data using the given <code>object</code> and <code>signature</code>.</p>\n<p>If <code>object</code> is not a <a href=\"crypto.html#crypto_class_keyobject\"><code>KeyObject</code></a>, this function behaves as if\n<code>object</code> had been passed to <a href=\"crypto.html#crypto_crypto_createpublickey_key\"><code>crypto.createPublicKey()</code></a>. If it is an\nobject, the following additional properties can be passed:</p>\n<ul>\n<li>\n<p><code>dsaEncoding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> For DSA and ECDSA, this option specifies the\nformat of the signature. It can be one of the following:</p>\n<ul>\n<li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>\n<li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>\n</ul>\n</li>\n<li>\n<p><code>padding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Optional padding value for RSA, one of the following:</p>\n<ul>\n<li><code>crypto.constants.RSA_PKCS1_PADDING</code> (default)</li>\n<li><code>crypto.constants.RSA_PKCS1_PSS_PADDING</code></li>\n</ul>\n<p><code>RSA_PKCS1_PSS_PADDING</code> will use MGF1 with the same hash function\nused to verify the message as specified in section 3.1 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>, unless\nan MGF1 hash function has been specified as part of the key in compliance with\nsection 3.3 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>.</p>\n</li>\n<li>\n<p><code>saltLength</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Salt length for when padding is\n<code>RSA_PKCS1_PSS_PADDING</code>. The special value\n<code>crypto.constants.RSA_PSS_SALTLEN_DIGEST</code> sets the salt length to the digest\nsize, <code>crypto.constants.RSA_PSS_SALTLEN_AUTO</code> (default) causes it to be\ndetermined automatically.</p>\n</li>\n</ul>\n<p>The <code>signature</code> argument is the previously calculated signature for the data, in\nthe <code>signatureEncoding</code>.\nIf a <code>signatureEncoding</code> is specified, the <code>signature</code> is expected to be a\nstring; otherwise <code>signature</code> is expected to be a <a href=\"buffer.html\"><code>Buffer</code></a>,\n<code>TypedArray</code>, or <code>DataView</code>.</p>\n<p>The <code>verify</code> object can not be used again after <code>verify.verify()</code> has been\ncalled. Multiple calls to <code>verify.verify()</code> will result in an error being\nthrown.</p>\n<p>Because public keys can be derived from private keys, a private key may\nbe passed instead of a public key.</p>"
             }
           ]
         }
       ],
       "type": "module",
-      "displayName": "Crypto"
+      "displayName": "Crypto",
+      "source": "doc/api/crypto.md"
+    },
+    {
+      "textRaw": "Diagnostics Channel",
+      "name": "diagnostics_channel",
+      "introduced_in": "v14.17.0",
+      "stability": 1,
+      "stabilityText": "Experimental",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/diagnostics_channel.js\">lib/diagnostics_channel.js</a></p>\n<p>The <code>diagnostics_channel</code> module provides an API to create named channels\nto report arbitrary message data for diagnostics purposes.</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n</code></pre>\n<p>It is intended that a module writer wanting to report diagnostics messages\nwill create one or many top-level channels to report messages through.\nChannels may also be acquired at runtime but it is not encouraged\ndue to the additional overhead of doing so. Channels may be exported for\nconvenience, but as long as the name is known it can be acquired anywhere.</p>\n<p>If you intend for your module to produce diagnostics data for others to\nconsume it is recommended that you include documentation of what named\nchannels are used along with the shape of the message data. Channel names\nshould generally include the module name to avoid collisions with data from\nother modules.</p>",
+      "modules": [
+        {
+          "textRaw": "Public API",
+          "name": "public_api",
+          "modules": [
+            {
+              "textRaw": "Overview",
+              "name": "overview",
+              "desc": "<p>Following is a simple overview of the public API.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\n// Get a reusable channel object\nconst channel = diagnostics_channel.channel('my-channel');\n\n// Subscribe to the channel\nchannel.subscribe((message, name) => {\n  // Received data\n});\n\n// Check if the channel has an active subscriber\nif (channel.hasSubscribers) {\n  // Publish data to the channel\n  channel.publish({\n    some: 'data'\n  });\n}\n</code></pre>",
+              "methods": [
+                {
+                  "textRaw": "`diagnostics_channel.hasSubscribers(name)`",
+                  "type": "method",
+                  "name": "hasSubscribers",
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean} If there are active subscribers",
+                        "name": "return",
+                        "type": "boolean",
+                        "desc": "If there are active subscribers"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`name` {string|symbol} The channel name",
+                          "name": "name",
+                          "type": "string|symbol",
+                          "desc": "The channel name"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Check if there are active subscribers to the named channel. This is helpful if\nthe message you want to send might be expensive to prepare.</p>\n<p>This API is optional but helpful when trying to publish messages from very\nperformance-sensitive code.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nif (diagnostics_channel.hasSubscribers('my-channel')) {\n  // There are subscribers, prepare and publish message\n}\n</code></pre>"
+                },
+                {
+                  "textRaw": "`diagnostics_channel.channel(name)`",
+                  "type": "method",
+                  "name": "channel",
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {Channel} The named channel object",
+                        "name": "return",
+                        "type": "Channel",
+                        "desc": "The named channel object"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`name` {string|symbol} The channel name",
+                          "name": "name",
+                          "type": "string|symbol",
+                          "desc": "The channel name"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>This is the primary entry-point for anyone wanting to interact with a named\nchannel. It produces a channel object which is optimized to reduce overhead at\npublish time as much as possible.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n</code></pre>"
+                }
+              ],
+              "type": "module",
+              "displayName": "Overview"
+            }
+          ],
+          "classes": [
+            {
+              "textRaw": "Class: `Channel`",
+              "type": "class",
+              "name": "Channel",
+              "desc": "<p>The class <code>Channel</code> represents an individual named channel within the data\npipeline. It is use to track subscribers and to publish messages when there\nare subscribers present. It exists as a separate object to avoid channel\nlookups at publish time, enabling very fast publish speeds and allowing\nfor heavy use while incurring very minimal cost. Channels are created with\n<a href=\"diagnostics_channel.html#diagnostics_channel_diagnostics_channel_channel_name\"><code>diagnostics_channel.channel(name)</code></a>, constructing a channel directly\nwith <code>new Channel(name)</code> is not supported.</p>",
+              "properties": [
+                {
+                  "textRaw": "`hasSubscribers` Returns: {boolean} If there are active subscribers",
+                  "type": "boolean",
+                  "name": "return",
+                  "desc": "<p>Check if there are active subscribers to this channel. This is helpful if\nthe message you want to send might be expensive to prepare.</p>\n<p>This API is optional but helpful when trying to publish messages from very\nperformance-sensitive code.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n\nif (channel.hasSubscribers) {\n  // There are subscribers, prepare and publish message\n}\n</code></pre>",
+                  "shortDesc": "If there are active subscribers"
+                }
+              ],
+              "methods": [
+                {
+                  "textRaw": "`channel.publish(message)`",
+                  "type": "method",
+                  "name": "publish",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`message` {any} The message to send to the channel subscribers",
+                          "name": "message",
+                          "type": "any",
+                          "desc": "The message to send to the channel subscribers"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Publish a message to any subscribers to the channel. This will trigger\nmessage handlers synchronously so they will execute within the same context.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n\nchannel.publish({\n  some: 'message'\n});\n</code></pre>"
+                },
+                {
+                  "textRaw": "`channel.subscribe(onMessage)`",
+                  "type": "method",
+                  "name": "subscribe",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`onMessage` {Function} The handler to receive channel messages",
+                          "name": "onMessage",
+                          "type": "Function",
+                          "desc": "The handler to receive channel messages",
+                          "options": [
+                            {
+                              "textRaw": "`message` {any} The message data",
+                              "name": "message",
+                              "type": "any",
+                              "desc": "The message data"
+                            },
+                            {
+                              "textRaw": "`name` {string|symbol} The name of the channel",
+                              "name": "name",
+                              "type": "string|symbol",
+                              "desc": "The name of the channel"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Register a message handler to subscribe to this channel. This message handler\nwill be run synchronously whenever a message is published to the channel. Any\nerrors thrown in the message handler will trigger an <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a>.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n\nchannel.subscribe((message, name) => {\n  // Received data\n});\n</code></pre>"
+                },
+                {
+                  "textRaw": "`channel.unsubscribe(onMessage)`",
+                  "type": "method",
+                  "name": "unsubscribe",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`onMessage` {Function} The previous subscribed handler to remove",
+                          "name": "onMessage",
+                          "type": "Function",
+                          "desc": "The previous subscribed handler to remove"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Remove a message handler previously registered to this channel with\n<a href=\"diagnostics_channel.html#diagnostics_channel_channel_subscribe_onmessage\"><code>channel.subscribe(onMessage)</code></a>.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n\nfunction onMessage(message, name) {\n  // Received data\n}\n\nchannel.subscribe(onMessage);\n\nchannel.unsubscribe(onMessage);\n</code></pre>"
+                }
+              ]
+            }
+          ],
+          "type": "module",
+          "displayName": "Public API"
+        }
+      ],
+      "type": "module",
+      "displayName": "Diagnostics Channel",
+      "source": "doc/api/diagnostics_channel.md"
     },
     {
       "textRaw": "DNS",
@@ -23831,7 +25445,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/dns.js\">lib/dns.js</a></p>\n<p>The <code>dns</code> module enables name resolution. For example, use it to look up IP\naddresses of host names.</p>\n<p>Although named for the <a href=\"https://en.wikipedia.org/wiki/Domain_Name_System\">Domain Name System (DNS)</a>, it does not always use the\nDNS protocol for lookups. <a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> uses the operating system\nfacilities to perform name resolution. It may not need to perform any network\ncommunication. To perform name resolution the way other applications on the same\nsystem do, use <a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a>.</p>\n<pre><code class=\"language-js\">const dns = require('dns');\n\ndns.lookup('example.org', (err, address, family) => {\n  console.log('address: %j family: IPv%s', address, family);\n});\n// address: \"93.184.216.34\" family: IPv4\n</code></pre>\n<p>All other functions in the <code>dns</code> module connect to an actual DNS server to\nperform name resolution. They will always use the network to perform DNS\nqueries. These functions do not use the same set of configuration files used by\n<a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> (e.g. <code>/etc/hosts</code>). Use these functions to always perform\nDNS queries, bypassing other name-resolution facilities.</p>\n<pre><code class=\"language-js\">const dns = require('dns');\n\ndns.resolve4('archive.org', (err, addresses) => {\n  if (err) throw err;\n\n  console.log(`addresses: ${JSON.stringify(addresses)}`);\n\n  addresses.forEach((a) => {\n    dns.reverse(a, (err, hostnames) => {\n      if (err) {\n        throw err;\n      }\n      console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);\n    });\n  });\n});\n</code></pre>\n<p>See the <a href=\"dns.html#dns_implementation_considerations\">Implementation considerations section</a> for more information.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/dns.js\">lib/dns.js</a></p>\n<p>The <code>dns</code> module enables name resolution. For example, use it to look up IP\naddresses of host names.</p>\n<p>Although named for the <a href=\"https://en.wikipedia.org/wiki/Domain_Name_System\">Domain Name System (DNS)</a>, it does not always use the\nDNS protocol for lookups. <a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> uses the operating system\nfacilities to perform name resolution. It may not need to perform any network\ncommunication. To perform name resolution the way other applications on the same\nsystem do, use <a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a>.</p>\n<pre><code class=\"language-js\">const dns = require('dns');\n\ndns.lookup('example.org', (err, address, family) => {\n  console.log('address: %j family: IPv%s', address, family);\n});\n// address: \"93.184.216.34\" family: IPv4\n</code></pre>\n<p>All other functions in the <code>dns</code> module connect to an actual DNS server to\nperform name resolution. They will always use the network to perform DNS\nqueries. These functions do not use the same set of configuration files used by\n<a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> (e.g. <code>/etc/hosts</code>). Use these functions to always perform\nDNS queries, bypassing other name-resolution facilities.</p>\n<pre><code class=\"language-js\">const dns = require('dns');\n\ndns.resolve4('archive.org', (err, addresses) => {\n  if (err) throw err;\n\n  console.log(`addresses: ${JSON.stringify(addresses)}`);\n\n  addresses.forEach((a) => {\n    dns.reverse(a, (err, hostnames) => {\n      if (err) {\n        throw err;\n      }\n      console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);\n    });\n  });\n});\n</code></pre>\n<p>See the <a href=\"dns.html#dns_implementation_considerations\">Implementation considerations section</a> for more information.</p>",
       "classes": [
         {
           "textRaw": "Class: `dns.Resolver`",
@@ -23843,7 +25457,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>An independent resolver for DNS requests.</p>\n<p>Creating a new resolver uses the default server settings. Setting\nthe servers used for a resolver using\n<a href=\"dns.html#dns_dns_setservers_servers\"><code>resolver.setServers()</code></a> does not affect\nother resolvers:</p>\n<pre><code class=\"language-js\">const { Resolver } = require('dns');\nconst resolver = new Resolver();\nresolver.setServers(['4.4.4.4']);\n\n// This request will use the server at 4.4.4.4, independent of global settings.\nresolver.resolve4('example.org', (err, addresses) => {\n  // ...\n});\n</code></pre>\n<p>The following methods from the <code>dns</code> module are available:</p>\n<ul>\n<li><a href=\"dns.html#dns_dns_getservers\"><code>resolver.getServers()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolve_hostname_rrtype_callback\"><code>resolver.resolve()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolve4_hostname_options_callback\"><code>resolver.resolve4()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolve6_hostname_options_callback\"><code>resolver.resolve6()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolveany_hostname_callback\"><code>resolver.resolveAny()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvecname_hostname_callback\"><code>resolver.resolveCname()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvemx_hostname_callback\"><code>resolver.resolveMx()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvenaptr_hostname_callback\"><code>resolver.resolveNaptr()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvens_hostname_callback\"><code>resolver.resolveNs()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolveptr_hostname_callback\"><code>resolver.resolvePtr()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvesoa_hostname_callback\"><code>resolver.resolveSoa()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvesrv_hostname_callback\"><code>resolver.resolveSrv()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvetxt_hostname_callback\"><code>resolver.resolveTxt()</code></a></li>\n<li><a href=\"dns.html#dns_dns_reverse_ip_callback\"><code>resolver.reverse()</code></a></li>\n<li><a href=\"dns.html#dns_dns_setservers_servers\"><code>resolver.setServers()</code></a></li>\n</ul>",
+          "desc": "<p>An independent resolver for DNS requests.</p>\n<p>Creating a new resolver uses the default server settings. Setting\nthe servers used for a resolver using\n<a href=\"dns.html#dns_dns_setservers_servers\"><code>resolver.setServers()</code></a> does not affect\nother resolvers:</p>\n<pre><code class=\"language-js\">const { Resolver } = require('dns');\nconst resolver = new Resolver();\nresolver.setServers(['4.4.4.4']);\n\n// This request will use the server at 4.4.4.4, independent of global settings.\nresolver.resolve4('example.org', (err, addresses) => {\n  // ...\n});\n</code></pre>\n<p>The following methods from the <code>dns</code> module are available:</p>\n<ul>\n<li><a href=\"dns.html#dns_dns_getservers\"><code>resolver.getServers()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolve_hostname_rrtype_callback\"><code>resolver.resolve()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolve4_hostname_options_callback\"><code>resolver.resolve4()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolve6_hostname_options_callback\"><code>resolver.resolve6()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolveany_hostname_callback\"><code>resolver.resolveAny()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvecaa_hostname_callback\"><code>resolver.resolveCaa()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvecname_hostname_callback\"><code>resolver.resolveCname()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvemx_hostname_callback\"><code>resolver.resolveMx()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvenaptr_hostname_callback\"><code>resolver.resolveNaptr()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvens_hostname_callback\"><code>resolver.resolveNs()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolveptr_hostname_callback\"><code>resolver.resolvePtr()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvesoa_hostname_callback\"><code>resolver.resolveSoa()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvesrv_hostname_callback\"><code>resolver.resolveSrv()</code></a></li>\n<li><a href=\"dns.html#dns_dns_resolvetxt_hostname_callback\"><code>resolver.resolveTxt()</code></a></li>\n<li><a href=\"dns.html#dns_dns_reverse_ip_callback\"><code>resolver.reverse()</code></a></li>\n<li><a href=\"dns.html#dns_dns_setservers_servers\"><code>resolver.setServers()</code></a></li>\n</ul>",
           "methods": [
             {
               "textRaw": "`Resolver([options])`",
@@ -23855,7 +25469,12 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.18.3",
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/39610",
+                    "description": "The `options` object now accepts a `tries` option."
+                  },
+                  {
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/33472",
                     "description": "The constructor now accepts an `options` object. The single supported option is `timeout`."
                   }
@@ -23866,7 +25485,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Create a new resolver.</p>\n<ul>\n<li><code>options</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>timeout</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Query timeout in milliseconds, or <code>-1</code> to use the\ndefault timeout.</li>\n</ul>\n</li>\n</ul>"
+              "desc": "<p>Create a new resolver.</p>\n<ul>\n<li><code>options</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>timeout</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Query timeout in milliseconds, or <code>-1</code> to use the\ndefault timeout.</li>\n<li><code>tries</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> The number of tries the resolver will try contacting\neach name server before giving up. <strong>Default:</strong> <code>4</code></li>\n</ul>\n</li>\n</ul>"
             },
             {
               "textRaw": "`resolver.cancel()`",
@@ -23884,6 +25503,38 @@
                 }
               ],
               "desc": "<p>Cancel all outstanding DNS queries made by this resolver. The corresponding\ncallbacks will be called with an error with code <code>ECANCELLED</code>.</p>"
+            },
+            {
+              "textRaw": "`resolver.setLocalAddress([ipv4][, ipv6])`",
+              "type": "method",
+              "name": "setLocalAddress",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`ipv4` {string} A string representation of an IPv4 address. **Default:** `'0.0.0.0'`",
+                      "name": "ipv4",
+                      "type": "string",
+                      "default": "`'0.0.0.0'`",
+                      "desc": "A string representation of an IPv4 address."
+                    },
+                    {
+                      "textRaw": "`ipv6` {string} A string representation of an IPv6 address. **Default:** `'::0'`",
+                      "name": "ipv6",
+                      "type": "string",
+                      "default": "`'::0'`",
+                      "desc": "A string representation of an IPv6 address."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>The resolver instance will send its requests from the specified IP address.\nThis allows programs to specify outbound interfaces when used on multi-homed\nsystems.</p>\n<p>If a v4 or v6 address is not specified, it is set to the default, and the\noperating system will choose a local address automatically.</p>\n<p>The resolver will use the v4 local address when making requests to IPv4 DNS\nservers, and the v6 local address when making requests to IPv6 DNS servers.\nThe <code>rrtype</code> of resolution requests has no impact on the local address used.</p>"
             }
           ]
         }
@@ -23909,7 +25560,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns an array of IP address strings, formatted according to <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a>,\nthat are currently configured for DNS resolution. A string will include a port\nsection if a custom port is used.</p>\n<!-- eslint-disable semi-->\n<pre><code class=\"language-js\">[\n  '4.4.4.4',\n  '2001:4860:4860::8888',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053'\n]\n</code></pre>"
+          "desc": "<p>Returns an array of IP address strings, formatted according to <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a>,\nthat are currently configured for DNS resolution. A string will include a port\nsection if a custom port is used.</p>\n<!-- eslint-disable semi-->\n<pre><code class=\"language-js\">[\n  '4.4.4.4',\n  '2001:4860:4860::8888',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053',\n]\n</code></pre>"
         },
         {
           "textRaw": "`dns.lookup(hostname[, options], callback)`",
@@ -23966,10 +25617,10 @@
                       "desc": "When `true`, the callback returns all resolved addresses in an array. Otherwise, returns a single address."
                     },
                     {
-                      "textRaw": "`verbatim` {boolean} When `true`, the callback receives IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses. **Default:** currently `false` (addresses are reordered) but this is expected to change in the not too distant future. New code should use `{ verbatim: true }`.",
+                      "textRaw": "`verbatim` {boolean} When `true`, the callback receives IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses. **Default:** currently `false` (addresses are reordered) but this is expected to change in the not too distant future. Default value is configurable using [`dns.setDefaultResultOrder()`][] or [`--dns-result-order`][]. New code should use `{ verbatim: true }`.",
                       "name": "verbatim",
                       "type": "boolean",
-                      "default": "currently `false` (addresses are reordered) but this is expected to change in the not too distant future. New code should use `{ verbatim: true }`",
+                      "default": "currently `false` (addresses are reordered) but this is expected to change in the not too distant future. Default value is configurable using [`dns.setDefaultResultOrder()`][] or [`--dns-result-order`][]. New code should use `{ verbatim: true }`",
                       "desc": "When `true`, the callback receives IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses."
                     }
                   ]
@@ -24009,7 +25660,7 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v14.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32183",
                     "description": "Added support for the `dns.ALL` flag."
                   }
@@ -24119,7 +25770,7 @@
               ]
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve a host name (e.g. <code>'nodejs.org'</code>) into an array\nof the resource records. The <code>callback</code> function has arguments\n<code>(err, records)</code>. When successful, <code>records</code> will be an array of resource\nrecords. The type and structure of individual results varies based on <code>rrtype</code>:</p>\n<table>\n<thead>\n<tr>\n<th><code>rrtype</code></th>\n<th><code>records</code> contains</th>\n<th>Result type</th>\n<th>Shorthand method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td>IPv4 addresses (default)</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolve4_hostname_options_callback\"><code>dns.resolve4()</code></a></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td>IPv6 addresses</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolve6_hostname_options_callback\"><code>dns.resolve6()</code></a></td>\n</tr>\n<tr>\n<td><code>'ANY'</code></td>\n<td>any records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolveany_hostname_callback\"><code>dns.resolveAny()</code></a></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td>canonical name records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvecname_hostname_callback\"><code>dns.resolveCname()</code></a></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>mail exchange records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvemx_hostname_callback\"><code>dns.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>name authority pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvenaptr_hostname_callback\"><code>dns.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td>name server records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvens_hostname_callback\"><code>dns.resolveNs()</code></a></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td>pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolveptr_hostname_callback\"><code>dns.resolvePtr()</code></a></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>start of authority records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvesoa_hostname_callback\"><code>dns.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>service records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvesrv_hostname_callback\"><code>dns.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>text records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvetxt_hostname_callback\"><code>dns.resolveTxt()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>On error, <code>err</code> is an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code> is one of the\n<a href=\"dns.html#dns_error_codes\">DNS error codes</a>.</p>"
+          "desc": "<p>Uses the DNS protocol to resolve a host name (e.g. <code>'nodejs.org'</code>) into an array\nof the resource records. The <code>callback</code> function has arguments\n<code>(err, records)</code>. When successful, <code>records</code> will be an array of resource\nrecords. The type and structure of individual results varies based on <code>rrtype</code>:</p>\n<table>\n<thead>\n<tr>\n<th><code>rrtype</code></th>\n<th><code>records</code> contains</th>\n<th>Result type</th>\n<th>Shorthand method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td>IPv4 addresses (default)</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolve4_hostname_options_callback\"><code>dns.resolve4()</code></a></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td>IPv6 addresses</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolve6_hostname_options_callback\"><code>dns.resolve6()</code></a></td>\n</tr>\n<tr>\n<td><code>'ANY'</code></td>\n<td>any records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolveany_hostname_callback\"><code>dns.resolveAny()</code></a></td>\n</tr>\n<tr>\n<td><code>'CAA'</code></td>\n<td>CA authorization records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvecaa_hostname_callback\"><code>dns.resolveCaa()</code></a></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td>canonical name records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvecname_hostname_callback\"><code>dns.resolveCname()</code></a></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>mail exchange records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvemx_hostname_callback\"><code>dns.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>name authority pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvenaptr_hostname_callback\"><code>dns.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td>name server records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvens_hostname_callback\"><code>dns.resolveNs()</code></a></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td>pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolveptr_hostname_callback\"><code>dns.resolvePtr()</code></a></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>start of authority records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvesoa_hostname_callback\"><code>dns.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>service records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvesrv_hostname_callback\"><code>dns.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>text records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a></td>\n<td><a href=\"dns.html#dns_dns_resolvetxt_hostname_callback\"><code>dns.resolveTxt()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>On error, <code>err</code> is an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code> is one of the\n<a href=\"dns.html#dns_error_codes\">DNS error codes</a>.</p>"
         },
         {
           "textRaw": "`dns.resolve4(hostname[, options], callback)`",
@@ -24316,12 +25967,12 @@
           "desc": "<p>Uses the DNS protocol to resolve <code>CNAME</code> records for the <code>hostname</code>. The\n<code>addresses</code> argument passed to the <code>callback</code> function\nwill contain an array of canonical name records available for the <code>hostname</code>\n(e.g. <code>['bar.example.com']</code>).</p>"
         },
         {
-          "textRaw": "`dns.resolveMx(hostname, callback)`",
+          "textRaw": "`dns.resolveCaa(hostname, callback)`",
           "type": "method",
-          "name": "resolveMx",
+          "name": "resolveCaa",
           "meta": {
             "added": [
-              "v0.1.27"
+              "v14.17.0"
             ],
             "changes": []
           },
@@ -24344,8 +25995,8 @@
                       "type": "Error"
                     },
                     {
-                      "textRaw": "`addresses` {Object[]}",
-                      "name": "addresses",
+                      "textRaw": "`records` {Object[]}",
+                      "name": "records",
                       "type": "Object[]"
                     }
                   ]
@@ -24353,15 +26004,15 @@
               ]
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve mail exchange records (<code>MX</code> records) for the\n<code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will\ncontain an array of objects containing both a <code>priority</code> and <code>exchange</code>\nproperty (e.g. <code>[{priority: 10, exchange: 'mx.example.com'}, ...]</code>).</p>"
+          "desc": "<p>Uses the DNS protocol to resolve <code>CAA</code> records for the <code>hostname</code>. The\n<code>addresses</code> argument passed to the <code>callback</code> function\nwill contain an array of certification authority authorization records\navailable for the <code>hostname</code> (e.g. <code>[{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]</code>).</p>"
         },
         {
-          "textRaw": "`dns.resolveNaptr(hostname, callback)`",
+          "textRaw": "`dns.resolveMx(hostname, callback)`",
           "type": "method",
-          "name": "resolveNaptr",
+          "name": "resolveMx",
           "meta": {
             "added": [
-              "v0.9.12"
+              "v0.1.27"
             ],
             "changes": []
           },
@@ -24393,15 +26044,15 @@
               ]
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve regular expression based records (<code>NAPTR</code>\nrecords) for the <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code>\nfunction will contain an array of objects with the following properties:</p>\n<ul>\n<li><code>flags</code></li>\n<li><code>service</code></li>\n<li><code>regexp</code></li>\n<li><code>replacement</code></li>\n<li><code>order</code></li>\n<li><code>preference</code></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  flags: 's',\n  service: 'SIP+D2U',\n  regexp: '',\n  replacement: '_sip._udp.example.com',\n  order: 30,\n  preference: 100\n}\n</code></pre>"
+          "desc": "<p>Uses the DNS protocol to resolve mail exchange records (<code>MX</code> records) for the\n<code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will\ncontain an array of objects containing both a <code>priority</code> and <code>exchange</code>\nproperty (e.g. <code>[{priority: 10, exchange: 'mx.example.com'}, ...]</code>).</p>"
         },
         {
-          "textRaw": "`dns.resolveNs(hostname, callback)`",
+          "textRaw": "`dns.resolveNaptr(hostname, callback)`",
           "type": "method",
-          "name": "resolveNs",
+          "name": "resolveNaptr",
           "meta": {
             "added": [
-              "v0.1.90"
+              "v0.9.12"
             ],
             "changes": []
           },
@@ -24424,24 +26075,24 @@
                       "type": "Error"
                     },
                     {
-                      "textRaw": "`addresses` {string[]}",
+                      "textRaw": "`addresses` {Object[]}",
                       "name": "addresses",
-                      "type": "string[]"
+                      "type": "Object[]"
                     }
                   ]
                 }
               ]
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve name server records (<code>NS</code> records) for the\n<code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will\ncontain an array of name server records available for <code>hostname</code>\n(e.g. <code>['ns1.example.com', 'ns2.example.com']</code>).</p>"
+          "desc": "<p>Uses the DNS protocol to resolve regular expression based records (<code>NAPTR</code>\nrecords) for the <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code>\nfunction will contain an array of objects with the following properties:</p>\n<ul>\n<li><code>flags</code></li>\n<li><code>service</code></li>\n<li><code>regexp</code></li>\n<li><code>replacement</code></li>\n<li><code>order</code></li>\n<li><code>preference</code></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  flags: 's',\n  service: 'SIP+D2U',\n  regexp: '',\n  replacement: '_sip._udp.example.com',\n  order: 30,\n  preference: 100\n}\n</code></pre>"
         },
         {
-          "textRaw": "`dns.resolvePtr(hostname, callback)`",
+          "textRaw": "`dns.resolveNs(hostname, callback)`",
           "type": "method",
-          "name": "resolvePtr",
+          "name": "resolveNs",
           "meta": {
             "added": [
-              "v6.0.0"
+              "v0.1.90"
             ],
             "changes": []
           },
@@ -24473,55 +26124,15 @@
               ]
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve pointer records (<code>PTR</code> records) for the\n<code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will\nbe an array of strings containing the reply records.</p>"
-        },
-        {
-          "textRaw": "`dns.resolveSoa(hostname, callback)`",
-          "type": "method",
-          "name": "resolveSoa",
-          "meta": {
-            "added": [
-              "v0.11.10"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`hostname` {string}",
-                  "name": "hostname",
-                  "type": "string"
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
-                    {
-                      "textRaw": "`address` {Object}",
-                      "name": "address",
-                      "type": "Object"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Uses the DNS protocol to resolve a start of authority record (<code>SOA</code> record) for\nthe <code>hostname</code>. The <code>address</code> argument passed to the <code>callback</code> function will\nbe an object with the following properties:</p>\n<ul>\n<li><code>nsname</code></li>\n<li><code>hostmaster</code></li>\n<li><code>serial</code></li>\n<li><code>refresh</code></li>\n<li><code>retry</code></li>\n<li><code>expire</code></li>\n<li><code>minttl</code></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  nsname: 'ns.example.com',\n  hostmaster: 'root.example.com',\n  serial: 2013101809,\n  refresh: 10000,\n  retry: 2400,\n  expire: 604800,\n  minttl: 3600\n}\n</code></pre>"
+          "desc": "<p>Uses the DNS protocol to resolve name server records (<code>NS</code> records) for the\n<code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will\ncontain an array of name server records available for <code>hostname</code>\n(e.g. <code>['ns1.example.com', 'ns2.example.com']</code>).</p>"
         },
         {
-          "textRaw": "`dns.resolveSrv(hostname, callback)`",
+          "textRaw": "`dns.resolvePtr(hostname, callback)`",
           "type": "method",
-          "name": "resolveSrv",
+          "name": "resolvePtr",
           "meta": {
             "added": [
-              "v0.1.27"
+              "v6.0.0"
             ],
             "changes": []
           },
@@ -24544,24 +26155,24 @@
                       "type": "Error"
                     },
                     {
-                      "textRaw": "`addresses` {Object[]}",
+                      "textRaw": "`addresses` {string[]}",
                       "name": "addresses",
-                      "type": "Object[]"
+                      "type": "string[]"
                     }
                   ]
                 }
               ]
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve service records (<code>SRV</code> records) for the\n<code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will\nbe an array of objects with the following properties:</p>\n<ul>\n<li><code>priority</code></li>\n<li><code>weight</code></li>\n<li><code>port</code></li>\n<li><code>name</code></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  priority: 10,\n  weight: 5,\n  port: 21223,\n  name: 'service.example.com'\n}\n</code></pre>"
+          "desc": "<p>Uses the DNS protocol to resolve pointer records (<code>PTR</code> records) for the\n<code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will\nbe an array of strings containing the reply records.</p>"
         },
         {
-          "textRaw": "`dns.resolveTxt(hostname, callback)`",
+          "textRaw": "`dns.resolveSoa(hostname, callback)`",
           "type": "method",
-          "name": "resolveTxt",
+          "name": "resolveSoa",
           "meta": {
             "added": [
-              "v0.1.27"
+              "v0.11.10"
             ],
             "changes": []
           },
@@ -24584,16 +26195,73 @@
                       "type": "Error"
                     },
                     {
-                      "textRaw": "`records` <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[][]&gt;</a>",
-                      "name": "records",
-                      "desc": "<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[][]&gt;</a>"
+                      "textRaw": "`address` {Object}",
+                      "name": "address",
+                      "type": "Object"
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Uses the DNS protocol to resolve a start of authority record (<code>SOA</code> record) for\nthe <code>hostname</code>. The <code>address</code> argument passed to the <code>callback</code> function will\nbe an object with the following properties:</p>\n<ul>\n<li><code>nsname</code></li>\n<li><code>hostmaster</code></li>\n<li><code>serial</code></li>\n<li><code>refresh</code></li>\n<li><code>retry</code></li>\n<li><code>expire</code></li>\n<li><code>minttl</code></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  nsname: 'ns.example.com',\n  hostmaster: 'root.example.com',\n  serial: 2013101809,\n  refresh: 10000,\n  retry: 2400,\n  expire: 604800,\n  minttl: 3600\n}\n</code></pre>"
+        },
+        {
+          "textRaw": "`dns.resolveSrv(hostname, callback)`",
+          "type": "method",
+          "name": "resolveSrv",
+          "meta": {
+            "added": [
+              "v0.1.27"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`hostname` {string}",
+                  "name": "hostname",
+                  "type": "string"
+                },
+                {
+                  "textRaw": "`callback` {Function}",
+                  "name": "callback",
+                  "type": "Function",
+                  "options": [
+                    {
+                      "textRaw": "`err` {Error}",
+                      "name": "err",
+                      "type": "Error"
+                    },
+                    {
+                      "textRaw": "`addresses` {Object[]}",
+                      "name": "addresses",
+                      "type": "Object[]"
                     }
                   ]
                 }
               ]
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve text queries (<code>TXT</code> records) for the\n<code>hostname</code>. The <code>records</code> argument passed to the <code>callback</code> function is a\ntwo-dimensional array of the text records available for <code>hostname</code> (e.g.\n<code>[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]</code>). Each sub-array contains TXT chunks of\none record. Depending on the use case, these could be either joined together or\ntreated separately.</p>"
+          "desc": "<p>Uses the DNS protocol to resolve service records (<code>SRV</code> records) for the\n<code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will\nbe an array of objects with the following properties:</p>\n<ul>\n<li><code>priority</code></li>\n<li><code>weight</code></li>\n<li><code>port</code></li>\n<li><code>name</code></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  priority: 10,\n  weight: 5,\n  port: 21223,\n  name: 'service.example.com'\n}\n</code></pre>"
+        },
+        {
+          "textRaw": "`dns.resolveTxt(hostname, callback)`",
+          "type": "method",
+          "name": "resolveTxt",
+          "meta": {
+            "added": [
+              "v0.1.27"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<!--lint disable no-undefined-references list-item-bullet-indent-->\n<ul>\n<li><code>hostname</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a>\n<ul>\n<li><code>err</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\" class=\"type\">&lt;Error&gt;</a></li>\n<li><code>records</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&#x3C;string[][]></a></li>\n</ul>\n</li>\n</ul>\n<!--lint enable no-undefined-references list-item-bullet-indent-->\n<p>Uses the DNS protocol to resolve text queries (<code>TXT</code> records) for the\n<code>hostname</code>. The <code>records</code> argument passed to the <code>callback</code> function is a\ntwo-dimensional array of the text records available for <code>hostname</code> (e.g.\n<code>[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]</code>). Each sub-array contains TXT chunks of\none record. Depending on the use case, these could be either joined together or\ntreated separately.</p>"
         },
         {
           "textRaw": "`dns.reverse(ip, callback)`",
@@ -24635,6 +26303,30 @@
           ],
           "desc": "<p>Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an\narray of host names.</p>\n<p>On error, <code>err</code> is an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code> is\none of the <a href=\"dns.html#dns_error_codes\">DNS error codes</a>.</p>"
         },
+        {
+          "textRaw": "`dns.setDefaultResultOrder(order)`",
+          "type": "method",
+          "name": "setDefaultResultOrder",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`order` {string} must be `'ipv4first'` or `'verbatim'`.",
+                  "name": "order",
+                  "type": "string",
+                  "desc": "must be `'ipv4first'` or `'verbatim'`."
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Set the default value of <code>verbatim</code> in <a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> and\n<a href=\"dns.html#dns_dnspromises_lookup_hostname_options\"><code>dnsPromises.lookup()</code></a>. The value could be:</p>\n<ul>\n<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>\n<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>\n</ul>\n<p>The default is <code>ipv4first</code> and <a href=\"dns.html#dns_dns_setdefaultresultorder_order\"><code>dns.setDefaultResultOrder()</code></a> have higher\npriority than <a href=\"cli.html#cli_dns_result_order_order\"><code>--dns-result-order</code></a>. When using <a href=\"worker_threads.html\">worker threads</a>,\n<a href=\"dns.html#dns_dns_setdefaultresultorder_order\"><code>dns.setDefaultResultOrder()</code></a> from the main thread won't affect the default\ndns orders in workers.</p>"
+        },
         {
           "textRaw": "`dns.setServers(servers)`",
           "type": "method",
@@ -24657,13 +26349,28 @@
               ]
             }
           ],
-          "desc": "<p>Sets the IP address and port of servers to be used when performing DNS\nresolution. The <code>servers</code> argument is an array of <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a> formatted\naddresses. If the port is the IANA default DNS port (53) it can be omitted.</p>\n<pre><code class=\"language-js\">dns.setServers([\n  '4.4.4.4',\n  '[2001:4860:4860::8888]',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053'\n]);\n</code></pre>\n<p>An error will be thrown if an invalid address is provided.</p>\n<p>The <code>dns.setServers()</code> method must not be called while a DNS query is in\nprogress.</p>\n<p>The <a href=\"dns.html#dns_dns_setservers_servers\"><code>dns.setServers()</code></a> method affects only <a href=\"dns.html#dns_dns_resolve_hostname_rrtype_callback\"><code>dns.resolve()</code></a>,\n<code>dns.resolve*()</code> and <a href=\"dns.html#dns_dns_reverse_ip_callback\"><code>dns.reverse()</code></a> (and specifically <em>not</em>\n<a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a>).</p>\n<p>This method works much like\n<a href=\"https://man7.org/linux/man-pages/man5/resolv.conf.5.html\">resolve.conf</a>.\nThat is, if attempting to resolve with the first server provided results in a\n<code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with\nsubsequent servers provided. Fallback DNS servers will only be used if the\nearlier ones time out or result in some other error.</p>"
+          "desc": "<p>Sets the IP address and port of servers to be used when performing DNS\nresolution. The <code>servers</code> argument is an array of <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a> formatted\naddresses. If the port is the IANA default DNS port (53) it can be omitted.</p>\n<pre><code class=\"language-js\">dns.setServers([\n  '4.4.4.4',\n  '[2001:4860:4860::8888]',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053',\n]);\n</code></pre>\n<p>An error will be thrown if an invalid address is provided.</p>\n<p>The <code>dns.setServers()</code> method must not be called while a DNS query is in\nprogress.</p>\n<p>The <a href=\"dns.html#dns_dns_setservers_servers\"><code>dns.setServers()</code></a> method affects only <a href=\"dns.html#dns_dns_resolve_hostname_rrtype_callback\"><code>dns.resolve()</code></a>,\n<code>dns.resolve*()</code> and <a href=\"dns.html#dns_dns_reverse_ip_callback\"><code>dns.reverse()</code></a> (and specifically <em>not</em>\n<a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a>).</p>\n<p>This method works much like\n<a href=\"https://man7.org/linux/man-pages/man5/resolv.conf.5.html\">resolve.conf</a>.\nThat is, if attempting to resolve with the first server provided results in a\n<code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with\nsubsequent servers provided. Fallback DNS servers will only be used if the\nearlier ones time out or result in some other error.</p>"
         }
       ],
       "modules": [
         {
           "textRaw": "DNS promises API",
           "name": "dns_promises_api",
+          "meta": {
+            "added": [
+              "v10.6.0"
+            ],
+            "changes": [
+              {
+                "version": [
+                  "v11.14.0",
+                  "v10.17.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/26592",
+                "description": "This API is no longer experimental."
+              }
+            ]
+          },
           "desc": "<p>The <code>dns.promises</code> API provides an alternative set of asynchronous DNS methods\nthat return <code>Promise</code> objects rather than using callbacks. The API is accessible\nvia <code>require('dns').promises</code>.</p>",
           "classes": [
             {
@@ -24676,10 +26383,27 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>An independent resolver for DNS requests.</p>\n<p>Creating a new resolver uses the default server settings. Setting\nthe servers used for a resolver using\n<a href=\"dns.html#dns_dnspromises_setservers_servers\"><code>resolver.setServers()</code></a> does not affect\nother resolvers:</p>\n<pre><code class=\"language-js\">const { Resolver } = require('dns').promises;\nconst resolver = new Resolver();\nresolver.setServers(['4.4.4.4']);\n\n// This request will use the server at 4.4.4.4, independent of global settings.\nresolver.resolve4('example.org').then((addresses) => {\n  // ...\n});\n\n// Alternatively, the same code can be written using async-await style.\n(async function() {\n  const addresses = await resolver.resolve4('example.org');\n})();\n</code></pre>\n<p>The following methods from the <code>dnsPromises</code> API are available:</p>\n<ul>\n<li><a href=\"dns.html#dns_dnspromises_getservers\"><code>resolver.getServers()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolve_hostname_rrtype\"><code>resolver.resolve()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolve4_hostname_options\"><code>resolver.resolve4()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolve6_hostname_options\"><code>resolver.resolve6()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolveany_hostname\"><code>resolver.resolveAny()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvecname_hostname\"><code>resolver.resolveCname()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvemx_hostname\"><code>resolver.resolveMx()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvenaptr_hostname\"><code>resolver.resolveNaptr()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvens_hostname\"><code>resolver.resolveNs()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolveptr_hostname\"><code>resolver.resolvePtr()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvesoa_hostname\"><code>resolver.resolveSoa()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvesrv_hostname\"><code>resolver.resolveSrv()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvetxt_hostname\"><code>resolver.resolveTxt()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_reverse_ip\"><code>resolver.reverse()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_setservers_servers\"><code>resolver.setServers()</code></a></li>\n</ul>"
+              "desc": "<p>An independent resolver for DNS requests.</p>\n<p>Creating a new resolver uses the default server settings. Setting\nthe servers used for a resolver using\n<a href=\"dns.html#dns_dnspromises_setservers_servers\"><code>resolver.setServers()</code></a> does not affect\nother resolvers:</p>\n<pre><code class=\"language-js\">const { Resolver } = require('dns').promises;\nconst resolver = new Resolver();\nresolver.setServers(['4.4.4.4']);\n\n// This request will use the server at 4.4.4.4, independent of global settings.\nresolver.resolve4('example.org').then((addresses) => {\n  // ...\n});\n\n// Alternatively, the same code can be written using async-await style.\n(async function() {\n  const addresses = await resolver.resolve4('example.org');\n})();\n</code></pre>\n<p>The following methods from the <code>dnsPromises</code> API are available:</p>\n<ul>\n<li><a href=\"dns.html#dns_dnspromises_getservers\"><code>resolver.getServers()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolve_hostname_rrtype\"><code>resolver.resolve()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolve4_hostname_options\"><code>resolver.resolve4()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolve6_hostname_options\"><code>resolver.resolve6()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolveany_hostname\"><code>resolver.resolveAny()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvecaa_hostname\"><code>resolver.resolveCaa()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvecname_hostname\"><code>resolver.resolveCname()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvemx_hostname\"><code>resolver.resolveMx()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvenaptr_hostname\"><code>resolver.resolveNaptr()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvens_hostname\"><code>resolver.resolveNs()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolveptr_hostname\"><code>resolver.resolvePtr()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvesoa_hostname\"><code>resolver.resolveSoa()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvesrv_hostname\"><code>resolver.resolveSrv()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_resolvetxt_hostname\"><code>resolver.resolveTxt()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_reverse_ip\"><code>resolver.reverse()</code></a></li>\n<li><a href=\"dns.html#dns_dnspromises_setservers_servers\"><code>resolver.setServers()</code></a></li>\n</ul>"
             }
           ],
           "methods": [
+            {
+              "textRaw": "`resolver.cancel()`",
+              "type": "method",
+              "name": "cancel",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Cancel all outstanding DNS queries made by this resolver. The corresponding\npromises will be rejected with an error with code <code>ECANCELLED</code>.</p>"
+            },
             {
               "textRaw": "`dnsPromises.getServers()`",
               "type": "method",
@@ -24700,7 +26424,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns an array of IP address strings, formatted according to <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a>,\nthat are currently configured for DNS resolution. A string will include a port\nsection if a custom port is used.</p>\n<!-- eslint-disable semi-->\n<pre><code class=\"language-js\">[\n  '4.4.4.4',\n  '2001:4860:4860::8888',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053'\n]\n</code></pre>"
+              "desc": "<p>Returns an array of IP address strings, formatted according to <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a>,\nthat are currently configured for DNS resolution. A string will include a port\nsection if a custom port is used.</p>\n<!-- eslint-disable semi-->\n<pre><code class=\"language-js\">[\n  '4.4.4.4',\n  '2001:4860:4860::8888',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053',\n]\n</code></pre>"
             },
             {
               "textRaw": "`dnsPromises.lookup(hostname[, options])`",
@@ -24746,10 +26470,10 @@
                           "desc": "When `true`, the `Promise` is resolved with all addresses in an array. Otherwise, returns a single address."
                         },
                         {
-                          "textRaw": "`verbatim` {boolean} When `true`, the `Promise` is resolved with IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses. **Default:** currently `false` (addresses are reordered) but this is expected to change in the not too distant future. New code should use `{ verbatim: true }`.",
+                          "textRaw": "`verbatim` {boolean} When `true`, the `Promise` is resolved with IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses. **Default:** currently `false` (addresses are reordered) but this is expected to change in the not too distant future. Default value is configurable using [`dns.setDefaultResultOrder()`][] or [`--dns-result-order`][]. New code should use `{ verbatim: true }`.",
                           "name": "verbatim",
                           "type": "boolean",
-                          "default": "currently `false` (addresses are reordered) but this is expected to change in the not too distant future. New code should use `{ verbatim: true }`",
+                          "default": "currently `false` (addresses are reordered) but this is expected to change in the not too distant future. Default value is configurable using [`dns.setDefaultResultOrder()`][] or [`--dns-result-order`][]. New code should use `{ verbatim: true }`",
                           "desc": "When `true`, the `Promise` is resolved with IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses."
                         }
                       ]
@@ -24816,7 +26540,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Uses the DNS protocol to resolve a host name (e.g. <code>'nodejs.org'</code>) into an array\nof the resource records. When successful, the <code>Promise</code> is resolved with an\narray of resource records. The type and structure of individual results vary\nbased on <code>rrtype</code>:</p>\n<table>\n<thead>\n<tr>\n<th><code>rrtype</code></th>\n<th><code>records</code> contains</th>\n<th>Result type</th>\n<th>Shorthand method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td>IPv4 addresses (default)</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolve4_hostname_options\"><code>dnsPromises.resolve4()</code></a></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td>IPv6 addresses</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolve6_hostname_options\"><code>dnsPromises.resolve6()</code></a></td>\n</tr>\n<tr>\n<td><code>'ANY'</code></td>\n<td>any records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolveany_hostname\"><code>dnsPromises.resolveAny()</code></a></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td>canonical name records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvecname_hostname\"><code>dnsPromises.resolveCname()</code></a></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>mail exchange records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvemx_hostname\"><code>dnsPromises.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>name authority pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvenaptr_hostname\"><code>dnsPromises.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td>name server records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvens_hostname\"><code>dnsPromises.resolveNs()</code></a></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td>pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolveptr_hostname\"><code>dnsPromises.resolvePtr()</code></a></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>start of authority records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvesoa_hostname\"><code>dnsPromises.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>service records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvesrv_hostname\"><code>dnsPromises.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>text records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvetxt_hostname\"><code>dnsPromises.resolveTxt()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>On error, the <code>Promise</code> is rejected with an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code>\nis one of the <a href=\"dns.html#dns_error_codes\">DNS error codes</a>.</p>"
+              "desc": "<p>Uses the DNS protocol to resolve a host name (e.g. <code>'nodejs.org'</code>) into an array\nof the resource records. When successful, the <code>Promise</code> is resolved with an\narray of resource records. The type and structure of individual results vary\nbased on <code>rrtype</code>:</p>\n<table>\n<thead>\n<tr>\n<th><code>rrtype</code></th>\n<th><code>records</code> contains</th>\n<th>Result type</th>\n<th>Shorthand method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td>IPv4 addresses (default)</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolve4_hostname_options\"><code>dnsPromises.resolve4()</code></a></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td>IPv6 addresses</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolve6_hostname_options\"><code>dnsPromises.resolve6()</code></a></td>\n</tr>\n<tr>\n<td><code>'ANY'</code></td>\n<td>any records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolveany_hostname\"><code>dnsPromises.resolveAny()</code></a></td>\n</tr>\n<tr>\n<td><code>'CAA'</code></td>\n<td>CA authorization records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvecaa_hostname\"><code>dnsPromises.resolveCaa()</code></a></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td>canonical name records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvecname_hostname\"><code>dnsPromises.resolveCname()</code></a></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>mail exchange records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvemx_hostname\"><code>dnsPromises.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>name authority pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvenaptr_hostname\"><code>dnsPromises.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td>name server records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvens_hostname\"><code>dnsPromises.resolveNs()</code></a></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td>pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolveptr_hostname\"><code>dnsPromises.resolvePtr()</code></a></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>start of authority records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvesoa_hostname\"><code>dnsPromises.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>service records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvesrv_hostname\"><code>dnsPromises.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>text records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a></td>\n<td><a href=\"dns.html#dns_dnspromises_resolvetxt_hostname\"><code>dnsPromises.resolveTxt()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>On error, the <code>Promise</code> is rejected with an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code>\nis one of the <a href=\"dns.html#dns_error_codes\">DNS error codes</a>.</p>"
             },
             {
               "textRaw": "`dnsPromises.resolve4(hostname[, options])`",
@@ -24915,6 +26639,29 @@
               ],
               "desc": "<p>Uses the DNS protocol to resolve all records (also known as <code>ANY</code> or <code>*</code> query).\nOn success, the <code>Promise</code> is resolved with an array containing various types of\nrecords. Each object has a property <code>type</code> that indicates the type of the\ncurrent record. And depending on the <code>type</code>, additional properties will be\npresent on the object:</p>\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Properties</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td><code>address</code>/<code>ttl</code></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td><code>address</code>/<code>ttl</code></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td><code>value</code></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>Refer to <a href=\"dns.html#dns_dnspromises_resolvemx_hostname\"><code>dnsPromises.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>Refer to <a href=\"dns.html#dns_dnspromises_resolvenaptr_hostname\"><code>dnsPromises.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td><code>value</code></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td><code>value</code></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>Refer to <a href=\"dns.html#dns_dnspromises_resolvesoa_hostname\"><code>dnsPromises.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>Refer to <a href=\"dns.html#dns_dnspromises_resolvesrv_hostname\"><code>dnsPromises.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>This type of record contains an array property called <code>entries</code> which refers to <a href=\"dns.html#dns_dnspromises_resolvetxt_hostname\"><code>dnsPromises.resolveTxt()</code></a>, e.g. <code>{ entries: ['...'], type: 'TXT' }</code></td>\n</tr>\n</tbody>\n</table>\n<p>Here is an example of the result object:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[ { type: 'A', address: '127.0.0.1', ttl: 299 },\n  { type: 'CNAME', value: 'example.com' },\n  { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },\n  { type: 'NS', value: 'ns1.example.com' },\n  { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },\n  { type: 'SOA',\n    nsname: 'ns1.example.com',\n    hostmaster: 'admin.example.com',\n    serial: 156696742,\n    refresh: 900,\n    retry: 900,\n    expire: 1800,\n    minttl: 60 } ]\n</code></pre>"
             },
+            {
+              "textRaw": "`dnsPromises.resolveCaa(hostname)`",
+              "type": "method",
+              "name": "resolveCaa",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`hostname` {string}",
+                      "name": "hostname",
+                      "type": "string"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Uses the DNS protocol to resolve <code>CAA</code> records for the <code>hostname</code>. On success,\nthe <code>Promise</code> is resolved with an array of objects containing available\ncertification authority authorization records available for the <code>hostname</code>\n(e.g. <code>[{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue: 'pki.example.com'}]</code>).</p>"
+            },
             {
               "textRaw": "`dnsPromises.resolveCname(hostname)`",
               "type": "method",
@@ -25122,6 +26869,30 @@
               ],
               "desc": "<p>Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an\narray of host names.</p>\n<p>On error, the <code>Promise</code> is rejected with an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code>\nis one of the <a href=\"dns.html#dns_error_codes\">DNS error codes</a>.</p>"
             },
+            {
+              "textRaw": "`dnsPromises.setDefaultResultOrder(order)`",
+              "type": "method",
+              "name": "setDefaultResultOrder",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`order` {string} must be `'ipv4first'` or `'verbatim'`.",
+                      "name": "order",
+                      "type": "string",
+                      "desc": "must be `'ipv4first'` or `'verbatim'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Set the default value of <code>verbatim</code> in <a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> and\n<a href=\"dns.html#dns_dnspromises_lookup_hostname_options\"><code>dnsPromises.lookup()</code></a>. The value could be:</p>\n<ul>\n<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>\n<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>\n</ul>\n<p>The default is <code>ipv4first</code> and <a href=\"dns.html#dns_dnspromises_setdefaultresultorder_order\"><code>dnsPromises.setDefaultResultOrder()</code></a> have\nhigher priority than <a href=\"cli.html#cli_dns_result_order_order\"><code>--dns-result-order</code></a>. When using <a href=\"worker_threads.html\">worker threads</a>,\n<a href=\"dns.html#dns_dnspromises_setdefaultresultorder_order\"><code>dnsPromises.setDefaultResultOrder()</code></a> from the main thread won't affect the\ndefault dns orders in workers.</p>"
+            },
             {
               "textRaw": "`dnsPromises.setServers(servers)`",
               "type": "method",
@@ -25144,7 +26915,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Sets the IP address and port of servers to be used when performing DNS\nresolution. The <code>servers</code> argument is an array of <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a> formatted\naddresses. If the port is the IANA default DNS port (53) it can be omitted.</p>\n<pre><code class=\"language-js\">dnsPromises.setServers([\n  '4.4.4.4',\n  '[2001:4860:4860::8888]',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053'\n]);\n</code></pre>\n<p>An error will be thrown if an invalid address is provided.</p>\n<p>The <code>dnsPromises.setServers()</code> method must not be called while a DNS query is in\nprogress.</p>\n<p>This method works much like\n<a href=\"https://man7.org/linux/man-pages/man5/resolv.conf.5.html\">resolve.conf</a>.\nThat is, if attempting to resolve with the first server provided results in a\n<code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with\nsubsequent servers provided. Fallback DNS servers will only be used if the\nearlier ones time out or result in some other error.</p>"
+              "desc": "<p>Sets the IP address and port of servers to be used when performing DNS\nresolution. The <code>servers</code> argument is an array of <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a> formatted\naddresses. If the port is the IANA default DNS port (53) it can be omitted.</p>\n<pre><code class=\"language-js\">dnsPromises.setServers([\n  '4.4.4.4',\n  '[2001:4860:4860::8888]',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053',\n]);\n</code></pre>\n<p>An error will be thrown if an invalid address is provided.</p>\n<p>The <code>dnsPromises.setServers()</code> method must not be called while a DNS query is in\nprogress.</p>\n<p>This method works much like\n<a href=\"https://man7.org/linux/man-pages/man5/resolv.conf.5.html\">resolve.conf</a>.\nThat is, if attempting to resolve with the first server provided results in a\n<code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with\nsubsequent servers provided. Fallback DNS servers will only be used if the\nearlier ones time out or result in some other error.</p>"
             }
           ],
           "type": "module",
@@ -25188,7 +26959,8 @@
         }
       ],
       "type": "module",
-      "displayName": "DNS"
+      "displayName": "DNS",
+      "source": "doc/api/dns.md"
     },
     {
       "textRaw": "Domain",
@@ -25200,6 +26972,7 @@
         "changes": [
           {
             "version": "v8.8.0",
+            "pr-url": "https://github.com/nodejs/node/pull/15695",
             "description": "Any `Promise`s created in VM contexts no longer have a `.domain` property. Their handlers are still executed in the proper domain, however, and `Promise`s created in the main context still possess a `.domain` property."
           },
           {
@@ -25212,13 +26985,13 @@
       "introduced_in": "v0.10.0",
       "stability": 0,
       "stabilityText": "Deprecated",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/domain.js\">lib/domain.js</a></p>\n<p><strong>This module is pending deprecation</strong>. Once a replacement API has been\nfinalized, this module will be fully deprecated. Most developers should\n<strong>not</strong> have cause to use this module. Users who absolutely must have\nthe functionality that domains provide may rely on it for the time being\nbut should expect to have to migrate to a different solution\nin the future.</p>\n<p>Domains provide a way to handle multiple different IO operations as a\nsingle group. If any of the event emitters or callbacks registered to a\ndomain emit an <code>'error'</code> event, or throw an error, then the domain object\nwill be notified, rather than losing the context of the error in the\n<code>process.on('uncaughtException')</code> handler, or causing the program to\nexit immediately with an error code.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/domain.js\">lib/domain.js</a></p>\n<p><strong>This module is pending deprecation</strong>. Once a replacement API has been\nfinalized, this module will be fully deprecated. Most developers should\n<strong>not</strong> have cause to use this module. Users who absolutely must have\nthe functionality that domains provide may rely on it for the time being\nbut should expect to have to migrate to a different solution\nin the future.</p>\n<p>Domains provide a way to handle multiple different IO operations as a\nsingle group. If any of the event emitters or callbacks registered to a\ndomain emit an <code>'error'</code> event, or throw an error, then the domain object\nwill be notified, rather than losing the context of the error in the\n<code>process.on('uncaughtException')</code> handler, or causing the program to\nexit immediately with an error code.</p>",
       "miscs": [
         {
           "textRaw": "Warning: Don't ignore errors!",
           "name": "Warning: Don't ignore errors!",
           "type": "misc",
-          "desc": "<p>Domain error handlers are not a substitute for closing down a\nprocess when an error occurs.</p>\n<p>By the very nature of how <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw\"><code>throw</code></a> works in JavaScript, there is almost\nnever any way to safely \"pick up where it left off\", without leaking\nreferences, or creating some other sort of undefined brittle state.</p>\n<p>The safest way to respond to a thrown error is to shut down the\nprocess. Of course, in a normal web server, there may be many\nopen connections, and it is not reasonable to abruptly shut those down\nbecause an error was triggered by someone else.</p>\n<p>The better approach is to send an error response to the request that\ntriggered the error, while letting the others finish in their normal\ntime, and stop listening for new requests in that worker.</p>\n<p>In this way, <code>domain</code> usage goes hand-in-hand with the cluster module,\nsince the master process can fork a new worker when a worker\nencounters an error. For Node.js programs that scale to multiple\nmachines, the terminating proxy or service registry can take note of\nthe failure, and react accordingly.</p>\n<p>For example, this is not a good idea:</p>\n<pre><code class=\"language-js\">// XXX WARNING! BAD IDEA!\n\nconst d = require('domain').create();\nd.on('error', (er) => {\n  // The error won't crash the process, but what it does is worse!\n  // Though we've prevented abrupt process restarting, we are leaking\n  // resources like crazy if this ever happens.\n  // This is no better than process.on('uncaughtException')!\n  console.log(`error, but oh well ${er.message}`);\n});\nd.run(() => {\n  require('http').createServer((req, res) => {\n    handleRequest(req, res);\n  }).listen(PORT);\n});\n</code></pre>\n<p>By using the context of a domain, and the resilience of separating our\nprogram into multiple worker processes, we can react more\nappropriately, and handle errors with much greater safety.</p>\n<pre><code class=\"language-js\">// Much better!\n\nconst cluster = require('cluster');\nconst PORT = +process.env.PORT || 1337;\n\nif (cluster.isMaster) {\n  // A more realistic scenario would have more than 2 workers,\n  // and perhaps not put the master and worker in the same file.\n  //\n  // It is also possible to get a bit fancier about logging, and\n  // implement whatever custom logic is needed to prevent DoS\n  // attacks and other bad behavior.\n  //\n  // See the options in the cluster documentation.\n  //\n  // The important thing is that the master does very little,\n  // increasing our resilience to unexpected errors.\n\n  cluster.fork();\n  cluster.fork();\n\n  cluster.on('disconnect', (worker) => {\n    console.error('disconnect!');\n    cluster.fork();\n  });\n\n} else {\n  // the worker\n  //\n  // This is where we put our bugs!\n\n  const domain = require('domain');\n\n  // See the cluster documentation for more details about using\n  // worker processes to serve requests. How it works, caveats, etc.\n\n  const server = require('http').createServer((req, res) => {\n    const d = domain.create();\n    d.on('error', (er) => {\n      console.error(`error ${er.stack}`);\n\n      // We're in dangerous territory!\n      // By definition, something unexpected occurred,\n      // which we probably didn't want.\n      // Anything can happen now! Be very careful!\n\n      try {\n        // Make sure we close down within 30 seconds\n        const killtimer = setTimeout(() => {\n          process.exit(1);\n        }, 30000);\n        // But don't keep the process open just for that!\n        killtimer.unref();\n\n        // Stop taking new requests.\n        server.close();\n\n        // Let the master know we're dead. This will trigger a\n        // 'disconnect' in the cluster master, and then it will fork\n        // a new worker.\n        cluster.worker.disconnect();\n\n        // Try to send an error to the request that triggered the problem\n        res.statusCode = 500;\n        res.setHeader('content-type', 'text/plain');\n        res.end('Oops, there was a problem!\\n');\n      } catch (er2) {\n        // Oh well, not much we can do at this point.\n        console.error(`Error sending 500! ${er2.stack}`);\n      }\n    });\n\n    // Because req and res were created before this domain existed,\n    // we need to explicitly add them.\n    // See the explanation of implicit vs explicit binding below.\n    d.add(req);\n    d.add(res);\n\n    // Now run the handler function in the domain.\n    d.run(() => {\n      handleRequest(req, res);\n    });\n  });\n  server.listen(PORT);\n}\n\n// This part is not important. Just an example routing thing.\n// Put fancy application logic here.\nfunction handleRequest(req, res) {\n  switch (req.url) {\n    case '/error':\n      // We do some async stuff, and then...\n      setTimeout(() => {\n        // Whoops!\n        flerb.bark();\n      }, timeout);\n      break;\n    default:\n      res.end('ok');\n  }\n}\n</code></pre>"
+          "desc": "<p>Domain error handlers are not a substitute for closing down a\nprocess when an error occurs.</p>\n<p>By the very nature of how <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw\"><code>throw</code></a> works in JavaScript, there is almost\nnever any way to safely \"pick up where it left off\", without leaking\nreferences, or creating some other sort of undefined brittle state.</p>\n<p>The safest way to respond to a thrown error is to shut down the\nprocess. Of course, in a normal web server, there may be many\nopen connections, and it is not reasonable to abruptly shut those down\nbecause an error was triggered by someone else.</p>\n<p>The better approach is to send an error response to the request that\ntriggered the error, while letting the others finish in their normal\ntime, and stop listening for new requests in that worker.</p>\n<p>In this way, <code>domain</code> usage goes hand-in-hand with the cluster module,\nsince the master process can fork a new worker when a worker\nencounters an error. For Node.js programs that scale to multiple\nmachines, the terminating proxy or service registry can take note of\nthe failure, and react accordingly.</p>\n<p>For example, this is not a good idea:</p>\n<pre><code class=\"language-js\">// XXX WARNING! BAD IDEA!\n\nconst d = require('domain').create();\nd.on('error', (er) => {\n  // The error won't crash the process, but what it does is worse!\n  // Though we've prevented abrupt process restarting, we are leaking\n  // a lot of resources if this ever happens.\n  // This is no better than process.on('uncaughtException')!\n  console.log(`error, but oh well ${er.message}`);\n});\nd.run(() => {\n  require('http').createServer((req, res) => {\n    handleRequest(req, res);\n  }).listen(PORT);\n});\n</code></pre>\n<p>By using the context of a domain, and the resilience of separating our\nprogram into multiple worker processes, we can react more\nappropriately, and handle errors with much greater safety.</p>\n<pre><code class=\"language-js\">// Much better!\n\nconst cluster = require('cluster');\nconst PORT = +process.env.PORT || 1337;\n\nif (cluster.isMaster) {\n  // A more realistic scenario would have more than 2 workers,\n  // and perhaps not put the master and worker in the same file.\n  //\n  // It is also possible to get a bit fancier about logging, and\n  // implement whatever custom logic is needed to prevent DoS\n  // attacks and other bad behavior.\n  //\n  // See the options in the cluster documentation.\n  //\n  // The important thing is that the master does very little,\n  // increasing our resilience to unexpected errors.\n\n  cluster.fork();\n  cluster.fork();\n\n  cluster.on('disconnect', (worker) => {\n    console.error('disconnect!');\n    cluster.fork();\n  });\n\n} else {\n  // the worker\n  //\n  // This is where we put our bugs!\n\n  const domain = require('domain');\n\n  // See the cluster documentation for more details about using\n  // worker processes to serve requests. How it works, caveats, etc.\n\n  const server = require('http').createServer((req, res) => {\n    const d = domain.create();\n    d.on('error', (er) => {\n      console.error(`error ${er.stack}`);\n\n      // We're in dangerous territory!\n      // By definition, something unexpected occurred,\n      // which we probably didn't want.\n      // Anything can happen now! Be very careful!\n\n      try {\n        // Make sure we close down within 30 seconds\n        const killtimer = setTimeout(() => {\n          process.exit(1);\n        }, 30000);\n        // But don't keep the process open just for that!\n        killtimer.unref();\n\n        // Stop taking new requests.\n        server.close();\n\n        // Let the master know we're dead. This will trigger a\n        // 'disconnect' in the cluster master, and then it will fork\n        // a new worker.\n        cluster.worker.disconnect();\n\n        // Try to send an error to the request that triggered the problem\n        res.statusCode = 500;\n        res.setHeader('content-type', 'text/plain');\n        res.end('Oops, there was a problem!\\n');\n      } catch (er2) {\n        // Oh well, not much we can do at this point.\n        console.error(`Error sending 500! ${er2.stack}`);\n      }\n    });\n\n    // Because req and res were created before this domain existed,\n    // we need to explicitly add them.\n    // See the explanation of implicit vs explicit binding below.\n    d.add(req);\n    d.add(res);\n\n    // Now run the handler function in the domain.\n    d.run(() => {\n      handleRequest(req, res);\n    });\n  });\n  server.listen(PORT);\n}\n\n// This part is not important. Just an example routing thing.\n// Put fancy application logic here.\nfunction handleRequest(req, res) {\n  switch (req.url) {\n    case '/error':\n      // We do some async stuff, and then...\n      setTimeout(() => {\n        // Whoops!\n        flerb.bark();\n      }, timeout);\n      break;\n    default:\n      res.end('ok');\n  }\n}\n</code></pre>"
         },
         {
           "textRaw": "Additions to `Error` objects",
@@ -25412,7 +27185,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Domain"
+      "displayName": "Domain",
+      "source": "doc/api/domain.md"
     },
     {
       "textRaw": "Events",
@@ -25421,7 +27195,7 @@
       "stability": 2,
       "stabilityText": "Stable",
       "type": "module",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/events.js\">lib/events.js</a></p>\n<p>Much of the Node.js core API is built around an idiomatic asynchronous\nevent-driven architecture in which certain kinds of objects (called \"emitters\")\nemit named events that cause <code>Function</code> objects (\"listeners\") to be called.</p>\n<p>For instance: a <a href=\"net.html#net_class_net_server\"><code>net.Server</code></a> object emits an event each time a peer\nconnects to it; a <a href=\"fs.html#fs_class_fs_readstream\"><code>fs.ReadStream</code></a> emits an event when the file is opened;\na <a href=\"stream.html\">stream</a> emits an event whenever data is available to be read.</p>\n<p>All objects that emit events are instances of the <code>EventEmitter</code> class. These\nobjects expose an <code>eventEmitter.on()</code> function that allows one or more\nfunctions to be attached to named events emitted by the object. Typically,\nevent names are camel-cased strings but any valid JavaScript property key\ncan be used.</p>\n<p>When the <code>EventEmitter</code> object emits an event, all of the functions attached\nto that specific event are called <em>synchronously</em>. Any values returned by the\ncalled listeners are <em>ignored</em> and will be discarded.</p>\n<p>The following example shows a simple <code>EventEmitter</code> instance with a single\nlistener. The <code>eventEmitter.on()</code> method is used to register listeners, while\nthe <code>eventEmitter.emit()</code> method is used to trigger the event.</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\n\nclass MyEmitter extends EventEmitter {}\n\nconst myEmitter = new MyEmitter();\nmyEmitter.on('event', () => {\n  console.log('an event occurred!');\n});\nmyEmitter.emit('event');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/events.js\">lib/events.js</a></p>\n<p>Much of the Node.js core API is built around an idiomatic asynchronous\nevent-driven architecture in which certain kinds of objects (called \"emitters\")\nemit named events that cause <code>Function</code> objects (\"listeners\") to be called.</p>\n<p>For instance: a <a href=\"net.html#net_class_net_server\"><code>net.Server</code></a> object emits an event each time a peer\nconnects to it; a <a href=\"fs.html#fs_class_fs_readstream\"><code>fs.ReadStream</code></a> emits an event when the file is opened;\na <a href=\"stream.html\">stream</a> emits an event whenever data is available to be read.</p>\n<p>All objects that emit events are instances of the <code>EventEmitter</code> class. These\nobjects expose an <code>eventEmitter.on()</code> function that allows one or more\nfunctions to be attached to named events emitted by the object. Typically,\nevent names are camel-cased strings but any valid JavaScript property key\ncan be used.</p>\n<p>When the <code>EventEmitter</code> object emits an event, all of the functions attached\nto that specific event are called <em>synchronously</em>. Any values returned by the\ncalled listeners are <em>ignored</em> and discarded.</p>\n<p>The following example shows a simple <code>EventEmitter</code> instance with a single\nlistener. The <code>eventEmitter.on()</code> method is used to register listeners, while\nthe <code>eventEmitter.emit()</code> method is used to trigger the event.</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\n\nclass MyEmitter extends EventEmitter {}\n\nconst myEmitter = new MyEmitter();\nmyEmitter.on('event', () => {\n  console.log('an event occurred!');\n});\nmyEmitter.emit('event');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Passing arguments and `this` to listeners",
@@ -25440,14 +27214,14 @@
         {
           "textRaw": "Handling events only once",
           "name": "handling_events_only_once",
-          "desc": "<p>When a listener is registered using the <code>eventEmitter.on()</code> method, that\nlistener will be invoked <em>every time</em> the named event is emitted.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nlet m = 0;\nmyEmitter.on('event', () => {\n  console.log(++m);\n});\nmyEmitter.emit('event');\n// Prints: 1\nmyEmitter.emit('event');\n// Prints: 2\n</code></pre>\n<p>Using the <code>eventEmitter.once()</code> method, it is possible to register a listener\nthat is called at most once for a particular event. Once the event is emitted,\nthe listener is unregistered and <em>then</em> called.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nlet m = 0;\nmyEmitter.once('event', () => {\n  console.log(++m);\n});\nmyEmitter.emit('event');\n// Prints: 1\nmyEmitter.emit('event');\n// Ignored\n</code></pre>",
+          "desc": "<p>When a listener is registered using the <code>eventEmitter.on()</code> method, that\nlistener is invoked <em>every time</em> the named event is emitted.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nlet m = 0;\nmyEmitter.on('event', () => {\n  console.log(++m);\n});\nmyEmitter.emit('event');\n// Prints: 1\nmyEmitter.emit('event');\n// Prints: 2\n</code></pre>\n<p>Using the <code>eventEmitter.once()</code> method, it is possible to register a listener\nthat is called at most once for a particular event. Once the event is emitted,\nthe listener is unregistered and <em>then</em> called.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nlet m = 0;\nmyEmitter.once('event', () => {\n  console.log(++m);\n});\nmyEmitter.emit('event');\n// Prints: 1\nmyEmitter.emit('event');\n// Ignored\n</code></pre>",
           "type": "module",
           "displayName": "Handling events only once"
         },
         {
           "textRaw": "Error events",
           "name": "error_events",
-          "desc": "<p>When an error occurs within an <code>EventEmitter</code> instance, the typical action is\nfor an <code>'error'</code> event to be emitted. These are treated as special cases\nwithin Node.js.</p>\n<p>If an <code>EventEmitter</code> does <em>not</em> have at least one listener registered for the\n<code>'error'</code> event, and an <code>'error'</code> event is emitted, the error is thrown, a\nstack trace is printed, and the Node.js process exits.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.emit('error', new Error('whoops!'));\n// Throws and crashes Node.js\n</code></pre>\n<p>To guard against crashing the Node.js process the <a href=\"domain.html\"><code>domain</code></a> module can be\nused. (Note, however, that the <code>domain</code> module is deprecated.)</p>\n<p>As a best practice, listeners should always be added for the <code>'error'</code> events.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.on('error', (err) => {\n  console.error('whoops! there was an error');\n});\nmyEmitter.emit('error', new Error('whoops!'));\n// Prints: whoops! there was an error\n</code></pre>\n<p>It is possible to monitor <code>'error'</code> events without consuming the emitted error\nby installing a listener using the symbol <code>errorMonitor</code>.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.on(EventEmitter.errorMonitor, (err) => {\n  MyMonitoringTool.log(err);\n});\nmyEmitter.emit('error', new Error('whoops!'));\n// Still throws and crashes Node.js\n</code></pre>",
+          "desc": "<p>When an error occurs within an <code>EventEmitter</code> instance, the typical action is\nfor an <code>'error'</code> event to be emitted. These are treated as special cases\nwithin Node.js.</p>\n<p>If an <code>EventEmitter</code> does <em>not</em> have at least one listener registered for the\n<code>'error'</code> event, and an <code>'error'</code> event is emitted, the error is thrown, a\nstack trace is printed, and the Node.js process exits.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.emit('error', new Error('whoops!'));\n// Throws and crashes Node.js\n</code></pre>\n<p>To guard against crashing the Node.js process the <a href=\"domain.html\"><code>domain</code></a> module can be\nused. (Note, however, that the <code>domain</code> module is deprecated.)</p>\n<p>As a best practice, listeners should always be added for the <code>'error'</code> events.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.on('error', (err) => {\n  console.error('whoops! there was an error');\n});\nmyEmitter.emit('error', new Error('whoops!'));\n// Prints: whoops! there was an error\n</code></pre>\n<p>It is possible to monitor <code>'error'</code> events without consuming the emitted error\nby installing a listener using the symbol <code>events.errorMonitor</code>.</p>\n<pre><code class=\"language-js\">const { EventEmitter, errorMonitor } = require('events');\n\nconst myEmitter = new EventEmitter();\nmyEmitter.on(errorMonitor, (err) => {\n  MyMonitoringTool.log(err);\n});\nmyEmitter.emit('error', new Error('whoops!'));\n// Still throws and crashes Node.js\n</code></pre>",
           "type": "module",
           "displayName": "Error events"
         },
@@ -25456,176 +27230,875 @@
           "name": "capture_rejections_of_promises",
           "stability": 1,
           "stabilityText": "captureRejections is experimental.",
-          "desc": "<p>Using <code>async</code> functions with event handlers is problematic, because it\ncan lead to an unhandled rejection in case of a thrown exception:</p>\n<pre><code class=\"language-js\">const ee = new EventEmitter();\nee.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n</code></pre>\n<p>The <code>captureRejections</code> option in the <code>EventEmitter</code> constructor or the global\nsetting change this behavior, installing a <code>.then(undefined, handler)</code>\nhandler on the <code>Promise</code>. This handler routes the exception\nasynchronously to the <a href=\"events.html#events_emitter_symbol_for_nodejs_rejection_err_eventname_args\"><code>Symbol.for('nodejs.rejection')</code></a> method\nif there is one, or to <a href=\"events.html#events_error_events\"><code>'error'</code></a> event handler if there is none.</p>\n<pre><code class=\"language-js\">const ee1 = new EventEmitter({ captureRejections: true });\nee1.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee1.on('error', console.log);\n\nconst ee2 = new EventEmitter({ captureRejections: true });\nee2.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee2[Symbol.for('nodejs.rejection')] = console.log;\n</code></pre>\n<p>Setting <code>EventEmitter.captureRejections = true</code> will change the default for all\nnew instances of <code>EventEmitter</code>.</p>\n<pre><code class=\"language-js\">EventEmitter.captureRejections = true;\nconst ee1 = new EventEmitter();\nee1.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee1.on('error', console.log);\n</code></pre>\n<p>The <code>'error'</code> events that are generated by the <code>captureRejections</code> behavior\ndo not have a catch handler to avoid infinite error loops: the\nrecommendation is to <strong>not use <code>async</code> functions as <code>'error'</code> event handlers</strong>.</p>",
+          "desc": "<p>Using <code>async</code> functions with event handlers is problematic, because it\ncan lead to an unhandled rejection in case of a thrown exception:</p>\n<pre><code class=\"language-js\">const ee = new EventEmitter();\nee.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n</code></pre>\n<p>The <code>captureRejections</code> option in the <code>EventEmitter</code> constructor or the global\nsetting change this behavior, installing a <code>.then(undefined, handler)</code>\nhandler on the <code>Promise</code>. This handler routes the exception\nasynchronously to the <a href=\"events.html#events_emitter_symbol_for_nodejs_rejection_err_eventname_args\"><code>Symbol.for('nodejs.rejection')</code></a> method\nif there is one, or to <a href=\"events.html#events_error_events\"><code>'error'</code></a> event handler if there is none.</p>\n<pre><code class=\"language-js\">const ee1 = new EventEmitter({ captureRejections: true });\nee1.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee1.on('error', console.log);\n\nconst ee2 = new EventEmitter({ captureRejections: true });\nee2.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee2[Symbol.for('nodejs.rejection')] = console.log;\n</code></pre>\n<p>Setting <code>events.captureRejections = true</code> will change the default for all\nnew instances of <code>EventEmitter</code>.</p>\n<pre><code class=\"language-js\">const events = require('events');\nevents.captureRejections = true;\nconst ee1 = new events.EventEmitter();\nee1.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee1.on('error', console.log);\n</code></pre>\n<p>The <code>'error'</code> events that are generated by the <code>captureRejections</code> behavior\ndo not have a catch handler to avoid infinite error loops: the\nrecommendation is to <strong>not use <code>async</code> functions as <code>'error'</code> event handlers</strong>.</p>",
           "type": "module",
           "displayName": "Capture rejections of promises"
-        }
-      ],
-      "classes": [
+        },
         {
-          "textRaw": "Class: `EventEmitter`",
-          "type": "class",
-          "name": "EventEmitter",
+          "textRaw": "`EventTarget` and `Event` API",
+          "name": "`eventtarget`_and_`event`_api",
           "meta": {
             "added": [
-              "v0.1.26"
+              "v14.5.0"
             ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/27867",
-                "description": "Added captureRejections option."
-              }
-            ]
+            "changes": []
           },
-          "desc": "<p>The <code>EventEmitter</code> class is defined and exposed by the <code>events</code> module:</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\n</code></pre>\n<p>All <code>EventEmitter</code>s emit the event <code>'newListener'</code> when new listeners are\nadded and <code>'removeListener'</code> when existing listeners are removed.</p>\n<p>It supports the following option:</p>\n<ul>\n<li><code>captureRejections</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> It enables\n<a href=\"events.html#events_capture_rejections_of_promises\">automatic capturing of promise rejection</a>.\nDefault: <code>false</code>.</li>\n</ul>",
-          "events": [
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>The <code>EventTarget</code> and <code>Event</code> objects are a Node.js-specific implementation\nof the <a href=\"https://dom.spec.whatwg.org/#eventtarget\"><code>EventTarget</code> Web API</a> that are exposed by some Node.js core APIs.\nNeither the <code>EventTarget</code> nor <code>Event</code> classes are available for end\nuser code to create.</p>\n<pre><code class=\"language-js\">const target = getEventTargetSomehow();\n\ntarget.addEventListener('foo', (event) => {\n  console.log('foo event happened!');\n});\n</code></pre>",
+          "modules": [
             {
-              "textRaw": "Event: 'newListener'",
-              "type": "event",
-              "name": "newListener",
+              "textRaw": "Node.js `EventTarget` vs. DOM `EventTarget`",
+              "name": "node.js_`eventtarget`_vs._dom_`eventtarget`",
+              "desc": "<p>There are two key differences between the Node.js <code>EventTarget</code> and the\n<a href=\"https://dom.spec.whatwg.org/#eventtarget\"><code>EventTarget</code> Web API</a>:</p>\n<ol>\n<li>Whereas DOM <code>EventTarget</code> instances <em>may</em> be hierarchical, there is no\nconcept of hierarchy and event propagation in Node.js. That is, an event\ndispatched to an <code>EventTarget</code> does not propagate through a hierarchy of\nnested target objects that may each have their own set of handlers for the\nevent.</li>\n<li>In the Node.js <code>EventTarget</code>, if an event listener is an async function\nor returns a <code>Promise</code>, and the returned <code>Promise</code> rejects, the rejection\nis automatically captured and handled the same way as a listener that\nthrows synchronously (see <a href=\"events.html#events_eventtarget_error_handling\"><code>EventTarget</code> error handling</a> for details).</li>\n</ol>",
+              "type": "module",
+              "displayName": "Node.js `EventTarget` vs. DOM `EventTarget`"
+            },
+            {
+              "textRaw": "`NodeEventTarget` vs. `EventEmitter`",
+              "name": "`nodeeventtarget`_vs._`eventemitter`",
+              "desc": "<p>The <code>NodeEventTarget</code> object implements a modified subset of the\n<code>EventEmitter</code> API that allows it to closely <em>emulate</em> an <code>EventEmitter</code> in\ncertain situations. A <code>NodeEventTarget</code> is <em>not</em> an instance of <code>EventEmitter</code>\nand cannot be used in place of an <code>EventEmitter</code> in most cases.</p>\n<ol>\n<li>Unlike <code>EventEmitter</code>, any given <code>listener</code> can be registered at most once\nper event <code>type</code>. Attempts to register a <code>listener</code> multiple times are\nignored.</li>\n<li>The <code>NodeEventTarget</code> does not emulate the full <code>EventEmitter</code> API.\nSpecifically the <code>prependListener()</code>, <code>prependOnceListener()</code>,\n<code>rawListeners()</code>, <code>setMaxListeners()</code>, <code>getMaxListeners()</code>, and\n<code>errorMonitor</code> APIs are not emulated. The <code>'newListener'</code> and\n<code>'removeListener'</code> events will also not be emitted.</li>\n<li>The <code>NodeEventTarget</code> does not implement any special default behavior\nfor events with type <code>'error'</code>.</li>\n<li>The <code>NodeEventTarget</code> supports <code>EventListener</code> objects as well as\nfunctions as handlers for all event types.</li>\n</ol>",
+              "type": "module",
+              "displayName": "`NodeEventTarget` vs. `EventEmitter`"
+            },
+            {
+              "textRaw": "Event listener",
+              "name": "event_listener",
+              "desc": "<p>Event listeners registered for an event <code>type</code> may either be JavaScript\nfunctions or objects with a <code>handleEvent</code> property whose value is a function.</p>\n<p>In either case, the handler function is invoked with the <code>event</code> argument\npassed to the <code>eventTarget.dispatchEvent()</code> function.</p>\n<p>Async functions may be used as event listeners. If an async handler function\nrejects, the rejection is captured and handled as described in\n<a href=\"events.html#events_eventtarget_error_handling\"><code>EventTarget</code> error handling</a>.</p>\n<p>An error thrown by one handler function does not prevent the other handlers\nfrom being invoked.</p>\n<p>The return value of a handler function is ignored.</p>\n<p>Handlers are always invoked in the order they were added.</p>\n<p>Handler functions may mutate the <code>event</code> object.</p>\n<pre><code class=\"language-js\">function handler1(event) {\n  console.log(event.type);  // Prints 'foo'\n  event.a = 1;\n}\n\nasync function handler2(event) {\n  console.log(event.type);  // Prints 'foo'\n  console.log(event.a);  // Prints 1\n}\n\nconst handler3 = {\n  handleEvent(event) {\n    console.log(event.type);  // Prints 'foo'\n  }\n};\n\nconst handler4 = {\n  async handleEvent(event) {\n    console.log(event.type);  // Prints 'foo'\n  }\n};\n\nconst target = getEventTargetSomehow();\n\ntarget.addEventListener('foo', handler1);\ntarget.addEventListener('foo', handler2);\ntarget.addEventListener('foo', handler3);\ntarget.addEventListener('foo', handler4, { once: true });\n</code></pre>",
+              "type": "module",
+              "displayName": "Event listener"
+            },
+            {
+              "textRaw": "`EventTarget` error handling",
+              "name": "`eventtarget`_error_handling",
+              "desc": "<p>When a registered event listener throws (or returns a Promise that rejects),\nby default the error is treated as an uncaught exception on\n<code>process.nextTick()</code>. This means uncaught exceptions in <code>EventTarget</code>s will\nterminate the Node.js process by default.</p>\n<p>Throwing within an event listener will <em>not</em> stop the other registered handlers\nfrom being invoked.</p>\n<p>The <code>EventTarget</code> does not implement any special default handling for <code>'error'</code>\ntype events like <code>EventEmitter</code>.</p>\n<p>Currently errors are first forwarded to the <code>process.on('error')</code> event\nbefore reaching <code>process.on('uncaughtException')</code>. This behavior is\ndeprecated and will change in a future release to align <code>EventTarget</code> with\nother Node.js APIs. Any code relying on the <code>process.on('error')</code> event should\nbe aligned with the new behavior.</p>",
+              "type": "module",
+              "displayName": "`EventTarget` error handling"
+            }
+          ],
+          "classes": [
+            {
+              "textRaw": "Class: `Event`",
+              "type": "class",
+              "name": "Event",
               "meta": {
                 "added": [
-                  "v0.1.26"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
-              "params": [
+              "desc": "<p>The <code>Event</code> object is an adaptation of the <a href=\"https://dom.spec.whatwg.org/#event\"><code>Event</code> Web API</a>. Instances\nare created internally by Node.js.</p>",
+              "properties": [
                 {
-                  "textRaw": "`eventName` {string|symbol} The name of the event being listened for",
-                  "name": "eventName",
-                  "type": "string|symbol",
-                  "desc": "The name of the event being listened for"
+                  "textRaw": "`bubbles` Type: {boolean} Always returns `false`.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>",
+                  "shortDesc": "Always returns `false`."
                 },
                 {
-                  "textRaw": "`listener` {Function} The event handler function",
-                  "name": "listener",
-                  "type": "Function",
-                  "desc": "The event handler function"
-                }
-              ],
-              "desc": "<p>The <code>EventEmitter</code> instance will emit its own <code>'newListener'</code> event <em>before</em>\na listener is added to its internal array of listeners.</p>\n<p>Listeners registered for the <code>'newListener'</code> event will be passed the event\nname and a reference to the listener being added.</p>\n<p>The fact that the event is triggered before adding the listener has a subtle\nbut important side effect: any <em>additional</em> listeners registered to the same\n<code>name</code> <em>within</em> the <code>'newListener'</code> callback will be inserted <em>before</em> the\nlistener that is in the process of being added.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\n// Only do this once so we don't loop forever\nmyEmitter.once('newListener', (event, listener) => {\n  if (event === 'event') {\n    // Insert a new listener in front\n    myEmitter.on('event', () => {\n      console.log('B');\n    });\n  }\n});\nmyEmitter.on('event', () => {\n  console.log('A');\n});\nmyEmitter.emit('event');\n// Prints:\n//   B\n//   A\n</code></pre>"
-            },
-            {
-              "textRaw": "Event: `'removeListener'`",
-              "type": "event",
-              "name": "removeListener",
-              "meta": {
-                "added": [
-                  "v0.9.3"
-                ],
-                "changes": [
-                  {
-                    "version": "v6.1.0, v4.7.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/6394",
-                    "description": "For listeners attached using `.once()`, the `listener` argument now yields the original listener function."
-                  }
-                ]
-              },
-              "params": [
+                  "textRaw": "`cancelable` Type: {boolean} True if the event was created with the `cancelable` option.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "True if the event was created with the `cancelable` option."
+                },
                 {
-                  "textRaw": "`eventName` {string|symbol} The event name",
-                  "name": "eventName",
-                  "type": "string|symbol",
-                  "desc": "The event name"
+                  "textRaw": "`composed` Type: {boolean} Always returns `false`.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>",
+                  "shortDesc": "Always returns `false`."
                 },
                 {
-                  "textRaw": "`listener` {Function} The event handler function",
-                  "name": "listener",
-                  "type": "Function",
-                  "desc": "The event handler function"
+                  "textRaw": "`currentTarget` Type: {EventTarget} The `EventTarget` dispatching the event.",
+                  "type": "EventTarget",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Alias for <code>event.target</code>.</p>",
+                  "shortDesc": "The `EventTarget` dispatching the event."
+                },
+                {
+                  "textRaw": "`defaultPrevented` Type: {boolean}",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Is <code>true</code> if <code>cancelable</code> is <code>true</code> and <code>event.preventDefault()</code> has been\ncalled.</p>"
+                },
+                {
+                  "textRaw": "`eventPhase` Type: {number} Returns `0` while an event is not being dispatched, `2` while it is being dispatched.",
+                  "type": "number",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>",
+                  "shortDesc": "Returns `0` while an event is not being dispatched, `2` while it is being dispatched."
+                },
+                {
+                  "textRaw": "`isTrusted` Type: {boolean}",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> <code>\"abort\"</code> event is emitted with <code>isTrusted</code> set to <code>true</code>. The\nvalue is <code>false</code> in all other cases.</p>"
+                },
+                {
+                  "textRaw": "`returnValue` Type: {boolean} True if the event has not been canceled.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>",
+                  "shortDesc": "True if the event has not been canceled."
+                },
+                {
+                  "textRaw": "`srcElement` Type: {EventTarget} The `EventTarget` dispatching the event.",
+                  "type": "EventTarget",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Alias for <code>event.target</code>.</p>",
+                  "shortDesc": "The `EventTarget` dispatching the event."
+                },
+                {
+                  "textRaw": "`target` Type: {EventTarget} The `EventTarget` dispatching the event.",
+                  "type": "EventTarget",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "The `EventTarget` dispatching the event."
+                },
+                {
+                  "textRaw": "`timeStamp` Type: {number}",
+                  "type": "number",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The millisecond timestamp when the <code>Event</code> object was created.</p>"
+                },
+                {
+                  "textRaw": "`type` Type: {string}",
+                  "type": "string",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The event type identifier.</p>"
                 }
               ],
-              "desc": "<p>The <code>'removeListener'</code> event is emitted <em>after</em> the <code>listener</code> is removed.</p>"
-            }
-          ],
-          "methods": [
-            {
-              "textRaw": "`EventEmitter.listenerCount(emitter, eventName)`",
-              "type": "method",
-              "name": "listenerCount",
-              "meta": {
-                "added": [
-                  "v0.9.12"
-                ],
-                "deprecated": [
-                  "v3.2.0"
-                ],
-                "changes": []
-              },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use [`emitter.listenerCount()`][] instead.",
-              "signatures": [
+              "methods": [
                 {
-                  "params": [
+                  "textRaw": "`event.cancelBubble()`",
+                  "type": "method",
+                  "name": "cancelBubble",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`emitter` {EventEmitter} The emitter to query",
-                      "name": "emitter",
-                      "type": "EventEmitter",
-                      "desc": "The emitter to query"
-                    },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Alias for <code>event.stopPropagation()</code>. This is not used in Node.js and is\nprovided purely for completeness.</p>"
+                },
+                {
+                  "textRaw": "`event.composedPath()`",
+                  "type": "method",
+                  "name": "composedPath",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`eventName` {string|symbol} The event name",
-                      "name": "eventName",
-                      "type": "string|symbol",
-                      "desc": "The event name"
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Returns an array containing the current <code>EventTarget</code> as the only entry or\nempty if the event is not being dispatched. This is not used in\nNode.js and is provided purely for completeness.</p>"
+                },
+                {
+                  "textRaw": "`event.preventDefault()`",
+                  "type": "method",
+                  "name": "preventDefault",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Sets the <code>defaultPrevented</code> property to <code>true</code> if <code>cancelable</code> is <code>true</code>.</p>"
+                },
+                {
+                  "textRaw": "`event.stopImmediatePropagation()`",
+                  "type": "method",
+                  "name": "stopImmediatePropagation",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Stops the invocation of event listeners after the current one completes.</p>"
+                },
+                {
+                  "textRaw": "`event.stopPropagation()`",
+                  "type": "method",
+                  "name": "stopPropagation",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>"
                 }
-              ],
-              "desc": "<p>A class method that returns the number of listeners for the given <code>eventName</code>\nregistered on the given <code>emitter</code>.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.on('event', () => {});\nmyEmitter.on('event', () => {});\nconsole.log(EventEmitter.listenerCount(myEmitter, 'event'));\n// Prints: 2\n</code></pre>"
+              ]
             },
             {
-              "textRaw": "`emitter.addListener(eventName, listener)`",
-              "type": "method",
-              "name": "addListener",
+              "textRaw": "Class: `EventTarget`",
+              "type": "class",
+              "name": "EventTarget",
               "meta": {
                 "added": [
-                  "v0.1.26"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
-              "signatures": [
+              "methods": [
                 {
-                  "params": [
+                  "textRaw": "`eventTarget.addEventListener(type, listener[, options])`",
+                  "type": "method",
+                  "name": "addEventListener",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`eventName` {string|symbol}",
-                      "name": "eventName",
-                      "type": "string|symbol"
-                    },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object",
+                          "options": [
+                            {
+                              "textRaw": "`once` {boolean} When `true`, the listener is automatically removed when it is first invoked. **Default:** `false`.",
+                              "name": "once",
+                              "type": "boolean",
+                              "default": "`false`",
+                              "desc": "When `true`, the listener is automatically removed when it is first invoked."
+                            },
+                            {
+                              "textRaw": "`passive` {boolean} When `true`, serves as a hint that the listener will not call the `Event` object's `preventDefault()` method. **Default:** `false`.",
+                              "name": "passive",
+                              "type": "boolean",
+                              "default": "`false`",
+                              "desc": "When `true`, serves as a hint that the listener will not call the `Event` object's `preventDefault()` method."
+                            },
+                            {
+                              "textRaw": "`capture` {boolean} Not directly used by Node.js. Added for API completeness. **Default:** `false`.",
+                              "name": "capture",
+                              "type": "boolean",
+                              "default": "`false`",
+                              "desc": "Not directly used by Node.js. Added for API completeness."
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Adds a new handler for the <code>type</code> event. Any given <code>listener</code> is added\nonly once per <code>type</code> and per <code>capture</code> option value.</p>\n<p>If the <code>once</code> option is <code>true</code>, the <code>listener</code> is removed after the\nnext time a <code>type</code> event is dispatched.</p>\n<p>The <code>capture</code> option is not used by Node.js in any functional way other than\ntracking registered event listeners per the <code>EventTarget</code> specification.\nSpecifically, the <code>capture</code> option is used as part of the key when registering\na <code>listener</code>. Any individual <code>listener</code> may be added once with\n<code>capture = false</code>, and once with <code>capture = true</code>.</p>\n<pre><code class=\"language-js\">function handler(event) {}\n\nconst target = getEventTargetSomehow();\ntarget.addEventListener('foo', handler, { capture: true });  // first\ntarget.addEventListener('foo', handler, { capture: false }); // second\n\n// Removes the second instance of handler\ntarget.removeEventListener('foo', handler);\n\n// Removes the first instance of handler\ntarget.removeEventListener('foo', handler, { capture: true });\n</code></pre>"
+                },
+                {
+                  "textRaw": "`eventTarget.dispatchEvent(event)`",
+                  "type": "method",
+                  "name": "dispatchEvent",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`listener` {Function}",
-                      "name": "listener",
-                      "type": "Function"
+                      "return": {
+                        "textRaw": "Returns: {boolean} `true` if either event’s `cancelable` attribute value is false or its `preventDefault()` method was not invoked, otherwise `false`.",
+                        "name": "return",
+                        "type": "boolean",
+                        "desc": "`true` if either event’s `cancelable` attribute value is false or its `preventDefault()` method was not invoked, otherwise `false`."
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`event` {Event}",
+                          "name": "event",
+                          "type": "Event"
+                        }
+                      ]
                     }
-                  ]
+                  ],
+                  "desc": "<p>Dispatches the <code>event</code> to the list of handlers for <code>event.type</code>.</p>\n<p>The registered event listeners is synchronously invoked in the order they\nwere registered.</p>"
+                },
+                {
+                  "textRaw": "`eventTarget.removeEventListener(type, listener)`",
+                  "type": "method",
+                  "name": "removeEventListener",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object",
+                          "options": [
+                            {
+                              "textRaw": "`capture` {boolean}",
+                              "name": "capture",
+                              "type": "boolean"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Removes the <code>listener</code> from the list of handlers for event <code>type</code>.</p>"
                 }
-              ],
-              "desc": "<p>Alias for <code>emitter.on(eventName, listener)</code>.</p>"
+              ]
             },
             {
-              "textRaw": "`emitter.emit(eventName[, ...args])`",
-              "type": "method",
-              "name": "emit",
+              "textRaw": "Class: `NodeEventTarget`",
+              "type": "class",
+              "name": "NodeEventTarget",
               "meta": {
                 "added": [
-                  "v0.1.26"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
-              "signatures": [
+              "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventtarget\" class=\"type\">&lt;EventTarget&gt;</a></li>\n</ul>\n<p>The <code>NodeEventTarget</code> is a Node.js-specific extension to <code>EventTarget</code>\nthat emulates a subset of the <code>EventEmitter</code> API.</p>",
+              "methods": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
+                  "textRaw": "`nodeEventTarget.addListener(type, listener[, options])`",
+                  "type": "method",
+                  "name": "addListener",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
                   },
-                  "params": [
+                  "signatures": [
                     {
-                      "textRaw": "`eventName` {string|symbol}",
-                      "name": "eventName",
-                      "type": "string|symbol"
-                    },
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object",
+                          "options": [
+                            {
+                              "textRaw": "`once` {boolean}",
+                              "name": "once",
+                              "type": "boolean"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that emulates the\nequivalent <code>EventEmitter</code> API. The only difference between <code>addListener()</code> and\n<code>addEventListener()</code> is that <code>addListener()</code> will return a reference to the\n<code>EventTarget</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.eventNames()`",
+                  "type": "method",
+                  "name": "eventNames",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {string[]}",
+                        "name": "return",
+                        "type": "string[]"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that returns an array\nof event <code>type</code> names for which event listeners are registered.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.listenerCount(type)`",
+                  "type": "method",
+                  "name": "listenerCount",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {number}",
+                        "name": "return",
+                        "type": "number"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that returns the number\nof event listeners registered for the <code>type</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.off(type, listener)`",
+                  "type": "method",
+                  "name": "off",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific alias for <code>eventTarget.removeListener()</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.on(type, listener[, options])`",
+                  "type": "method",
+                  "name": "on",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object",
+                          "options": [
+                            {
+                              "textRaw": "`once` {boolean}",
+                              "name": "once",
+                              "type": "boolean"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific alias for <code>eventTarget.addListener()</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.once(type, listener[, options])`",
+                  "type": "method",
+                  "name": "once",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that adds a <code>once</code>\nlistener for the given event <code>type</code>. This is equivalent to calling <code>on</code>\nwith the <code>once</code> option set to <code>true</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.removeAllListeners([type])`",
+                  "type": "method",
+                  "name": "removeAllListeners",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class. If <code>type</code> is specified,\nremoves all registered listeners for <code>type</code>, otherwise removes all registered\nlisteners.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.removeListener(type, listener)`",
+                  "type": "method",
+                  "name": "removeListener",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that removes the\n<code>listener</code> for the given <code>type</code>. The only difference between <code>removeListener()</code>\nand <code>removeEventListener()</code> is that <code>removeListener()</code> will return a reference\nto the <code>EventTarget</code>.</p>"
+                }
+              ]
+            }
+          ],
+          "type": "module",
+          "displayName": "`EventTarget` and `Event` API"
+        }
+      ],
+      "classes": [
+        {
+          "textRaw": "Class: `EventEmitter`",
+          "type": "class",
+          "name": "EventEmitter",
+          "meta": {
+            "added": [
+              "v0.1.26"
+            ],
+            "changes": [
+              {
+                "version": [
+                  "v13.4.0",
+                  "v12.16.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/27867",
+                "description": "Added captureRejections option."
+              }
+            ]
+          },
+          "desc": "<p>The <code>EventEmitter</code> class is defined and exposed by the <code>events</code> module:</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\n</code></pre>\n<p>All <code>EventEmitter</code>s emit the event <code>'newListener'</code> when new listeners are\nadded and <code>'removeListener'</code> when existing listeners are removed.</p>\n<p>It supports the following option:</p>\n<ul>\n<li><code>captureRejections</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> It enables\n<a href=\"events.html#events_capture_rejections_of_promises\">automatic capturing of promise rejection</a>.\n<strong>Default:</strong> <code>false</code>.</li>\n</ul>",
+          "events": [
+            {
+              "textRaw": "Event: `'newListener'`",
+              "type": "event",
+              "name": "newListener",
+              "meta": {
+                "added": [
+                  "v0.1.26"
+                ],
+                "changes": []
+              },
+              "params": [
+                {
+                  "textRaw": "`eventName` {string|symbol} The name of the event being listened for",
+                  "name": "eventName",
+                  "type": "string|symbol",
+                  "desc": "The name of the event being listened for"
+                },
+                {
+                  "textRaw": "`listener` {Function} The event handler function",
+                  "name": "listener",
+                  "type": "Function",
+                  "desc": "The event handler function"
+                }
+              ],
+              "desc": "<p>The <code>EventEmitter</code> instance will emit its own <code>'newListener'</code> event <em>before</em>\na listener is added to its internal array of listeners.</p>\n<p>Listeners registered for the <code>'newListener'</code> event are passed the event\nname and a reference to the listener being added.</p>\n<p>The fact that the event is triggered before adding the listener has a subtle\nbut important side effect: any <em>additional</em> listeners registered to the same\n<code>name</code> <em>within</em> the <code>'newListener'</code> callback are inserted <em>before</em> the\nlistener that is in the process of being added.</p>\n<pre><code class=\"language-js\">class MyEmitter extends EventEmitter {}\n\nconst myEmitter = new MyEmitter();\n// Only do this once so we don't loop forever\nmyEmitter.once('newListener', (event, listener) => {\n  if (event === 'event') {\n    // Insert a new listener in front\n    myEmitter.on('event', () => {\n      console.log('B');\n    });\n  }\n});\nmyEmitter.on('event', () => {\n  console.log('A');\n});\nmyEmitter.emit('event');\n// Prints:\n//   B\n//   A\n</code></pre>"
+            },
+            {
+              "textRaw": "Event: `'removeListener'`",
+              "type": "event",
+              "name": "removeListener",
+              "meta": {
+                "added": [
+                  "v0.9.3"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v6.1.0",
+                      "v4.7.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/6394",
+                    "description": "For listeners attached using `.once()`, the `listener` argument now yields the original listener function."
+                  }
+                ]
+              },
+              "params": [
+                {
+                  "textRaw": "`eventName` {string|symbol} The event name",
+                  "name": "eventName",
+                  "type": "string|symbol",
+                  "desc": "The event name"
+                },
+                {
+                  "textRaw": "`listener` {Function} The event handler function",
+                  "name": "listener",
+                  "type": "Function",
+                  "desc": "The event handler function"
+                }
+              ],
+              "desc": "<p>The <code>'removeListener'</code> event is emitted <em>after</em> the <code>listener</code> is removed.</p>"
+            }
+          ],
+          "methods": [
+            {
+              "textRaw": "`emitter.addListener(eventName, listener)`",
+              "type": "method",
+              "name": "addListener",
+              "meta": {
+                "added": [
+                  "v0.1.26"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`eventName` {string|symbol}",
+                      "name": "eventName",
+                      "type": "string|symbol"
+                    },
+                    {
+                      "textRaw": "`listener` {Function}",
+                      "name": "listener",
+                      "type": "Function"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Alias for <code>emitter.on(eventName, listener)</code>.</p>"
+            },
+            {
+              "textRaw": "`emitter.emit(eventName[, ...args])`",
+              "type": "method",
+              "name": "emit",
+              "meta": {
+                "added": [
+                  "v0.1.26"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`eventName` {string|symbol}",
+                      "name": "eventName",
+                      "type": "string|symbol"
+                    },
                     {
                       "textRaw": "`...args` {any}",
                       "name": "...args",
@@ -25656,7 +28129,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns an array listing the events for which the emitter has registered\nlisteners. The values in the array will be strings or <code>Symbol</code>s.</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\nconst myEE = new EventEmitter();\nmyEE.on('foo', () => {});\nmyEE.on('bar', () => {});\n\nconst sym = Symbol('symbol');\nmyEE.on(sym, () => {});\n\nconsole.log(myEE.eventNames());\n// Prints: [ 'foo', 'bar', Symbol(symbol) ]\n</code></pre>"
+              "desc": "<p>Returns an array listing the events for which the emitter has registered\nlisteners. The values in the array are strings or <code>Symbol</code>s.</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\nconst myEE = new EventEmitter();\nmyEE.on('foo', () => {});\nmyEE.on('bar', () => {});\n\nconst sym = Symbol('symbol');\nmyEE.on(sym, () => {});\n\nconsole.log(myEE.eventNames());\n// Prints: [ 'foo', 'bar', Symbol(symbol) ]\n</code></pre>"
             },
             {
               "textRaw": "`emitter.getMaxListeners()`",
@@ -25678,7 +28151,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns the current max listener value for the <code>EventEmitter</code> which is either\nset by <a href=\"events.html#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> or defaults to\n<a href=\"events.html#events_eventemitter_defaultmaxlisteners\"><code>EventEmitter.defaultMaxListeners</code></a>.</p>"
+              "desc": "<p>Returns the current max listener value for the <code>EventEmitter</code> which is either\nset by <a href=\"events.html#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> or defaults to\n<a href=\"events.html#events_events_defaultmaxlisteners\"><code>events.defaultMaxListeners</code></a>.</p>"
             },
             {
               "textRaw": "`emitter.listenerCount(eventName)`",
@@ -25975,7 +28448,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Removes the specified <code>listener</code> from the listener array for the event named\n<code>eventName</code>.</p>\n<pre><code class=\"language-js\">const callback = (stream) => {\n  console.log('someone connected!');\n};\nserver.on('connection', callback);\n// ...\nserver.removeListener('connection', callback);\n</code></pre>\n<p><code>removeListener()</code> will remove, at most, one instance of a listener from the\nlistener array. If any single listener has been added multiple times to the\nlistener array for the specified <code>eventName</code>, then <code>removeListener()</code> must be\ncalled multiple times to remove each instance.</p>\n<p>Once an event has been emitted, all listeners attached to it at the\ntime of emitting will be called in order. This implies that any\n<code>removeListener()</code> or <code>removeAllListeners()</code> calls <em>after</em> emitting and\n<em>before</em> the last listener finishes execution will not remove them from\n<code>emit()</code> in progress. Subsequent events will behave as expected.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\n\nconst callbackA = () => {\n  console.log('A');\n  myEmitter.removeListener('event', callbackB);\n};\n\nconst callbackB = () => {\n  console.log('B');\n};\n\nmyEmitter.on('event', callbackA);\n\nmyEmitter.on('event', callbackB);\n\n// callbackA removes listener callbackB but it will still be called.\n// Internal listener array at time of emit [callbackA, callbackB]\nmyEmitter.emit('event');\n// Prints:\n//   A\n//   B\n\n// callbackB is now removed.\n// Internal listener array [callbackA]\nmyEmitter.emit('event');\n// Prints:\n//   A\n</code></pre>\n<p>Because listeners are managed using an internal array, calling this will\nchange the position indices of any listener registered <em>after</em> the listener\nbeing removed. This will not impact the order in which listeners are called,\nbut it means that any copies of the listener array as returned by\nthe <code>emitter.listeners()</code> method will need to be recreated.</p>\n<p>When a single function has been added as a handler multiple times for a single\nevent (as in the example below), <code>removeListener()</code> will remove the most\nrecently added instance. In the example the <code>once('ping')</code>\nlistener is removed:</p>\n<pre><code class=\"language-js\">const ee = new EventEmitter();\n\nfunction pong() {\n  console.log('pong');\n}\n\nee.on('ping', pong);\nee.once('ping', pong);\nee.removeListener('ping', pong);\n\nee.emit('ping');\nee.emit('ping');\n</code></pre>\n<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>"
+              "desc": "<p>Removes the specified <code>listener</code> from the listener array for the event named\n<code>eventName</code>.</p>\n<pre><code class=\"language-js\">const callback = (stream) => {\n  console.log('someone connected!');\n};\nserver.on('connection', callback);\n// ...\nserver.removeListener('connection', callback);\n</code></pre>\n<p><code>removeListener()</code> will remove, at most, one instance of a listener from the\nlistener array. If any single listener has been added multiple times to the\nlistener array for the specified <code>eventName</code>, then <code>removeListener()</code> must be\ncalled multiple times to remove each instance.</p>\n<p>Once an event is emitted, all listeners attached to it at the\ntime of emitting are called in order. This implies that any\n<code>removeListener()</code> or <code>removeAllListeners()</code> calls <em>after</em> emitting and\n<em>before</em> the last listener finishes execution will not remove them from\n<code>emit()</code> in progress. Subsequent events behave as expected.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\n\nconst callbackA = () => {\n  console.log('A');\n  myEmitter.removeListener('event', callbackB);\n};\n\nconst callbackB = () => {\n  console.log('B');\n};\n\nmyEmitter.on('event', callbackA);\n\nmyEmitter.on('event', callbackB);\n\n// callbackA removes listener callbackB but it will still be called.\n// Internal listener array at time of emit [callbackA, callbackB]\nmyEmitter.emit('event');\n// Prints:\n//   A\n//   B\n\n// callbackB is now removed.\n// Internal listener array [callbackA]\nmyEmitter.emit('event');\n// Prints:\n//   A\n</code></pre>\n<p>Because listeners are managed using an internal array, calling this will\nchange the position indices of any listener registered <em>after</em> the listener\nbeing removed. This will not impact the order in which listeners are called,\nbut it means that any copies of the listener array as returned by\nthe <code>emitter.listeners()</code> method will need to be recreated.</p>\n<p>When a single function has been added as a handler multiple times for a single\nevent (as in the example below), <code>removeListener()</code> will remove the most\nrecently added instance. In the example the <code>once('ping')</code>\nlistener is removed:</p>\n<pre><code class=\"language-js\">const ee = new EventEmitter();\n\nfunction pong() {\n  console.log('pong');\n}\n\nee.on('ping', pong);\nee.once('ping', pong);\nee.removeListener('ping', pong);\n\nee.emit('ping');\nee.emit('ping');\n</code></pre>\n<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>"
             },
             {
               "textRaw": "`emitter.setMaxListeners(n)`",
@@ -26034,36 +28507,13 @@
               "desc": "<p>Returns a copy of the array of listeners for the event named <code>eventName</code>,\nincluding any wrappers (such as those created by <code>.once()</code>).</p>\n<pre><code class=\"language-js\">const emitter = new EventEmitter();\nemitter.once('log', () => console.log('log once'));\n\n// Returns a new Array with a function `onceWrapper` which has a property\n// `listener` which contains the original listener bound above\nconst listeners = emitter.rawListeners('log');\nconst logFnWrapper = listeners[0];\n\n// Logs \"log once\" to the console and does not unbind the `once` event\nlogFnWrapper.listener();\n\n// Logs \"log once\" to the console and removes the listener\nlogFnWrapper();\n\nemitter.on('log', () => console.log('log persistently'));\n// Will return a new Array with a single function bound by `.on()` above\nconst newListeners = emitter.rawListeners('log');\n\n// Logs \"log persistently\" twice\nnewListeners[0]();\nemitter.emit('log');\n</code></pre>"
             }
           ],
-          "properties": [
-            {
-              "textRaw": "`EventEmitter.defaultMaxListeners`",
-              "name": "defaultMaxListeners",
-              "meta": {
-                "added": [
-                  "v0.11.2"
-                ],
-                "changes": []
-              },
-              "desc": "<p>By default, a maximum of <code>10</code> listeners can be registered for any single\nevent. This limit can be changed for individual <code>EventEmitter</code> instances\nusing the <a href=\"events.html#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> method. To change the default\nfor <em>all</em> <code>EventEmitter</code> instances, the <code>EventEmitter.defaultMaxListeners</code>\nproperty can be used. If this value is not a positive number, a <code>TypeError</code>\nwill be thrown.</p>\n<p>Take caution when setting the <code>EventEmitter.defaultMaxListeners</code> because the\nchange affects <em>all</em> <code>EventEmitter</code> instances, including those created before\nthe change is made. However, calling <a href=\"events.html#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> still has\nprecedence over <code>EventEmitter.defaultMaxListeners</code>.</p>\n<p>This is not a hard limit. The <code>EventEmitter</code> instance will allow\nmore listeners to be added but will output a trace warning to stderr indicating\nthat a \"possible EventEmitter memory leak\" has been detected. For any single\n<code>EventEmitter</code>, the <code>emitter.getMaxListeners()</code> and <code>emitter.setMaxListeners()</code>\nmethods can be used to temporarily avoid this warning:</p>\n<pre><code class=\"language-js\">emitter.setMaxListeners(emitter.getMaxListeners() + 1);\nemitter.once('event', () => {\n  // do stuff\n  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));\n});\n</code></pre>\n<p>The <a href=\"cli.html#cli_trace_warnings\"><code>--trace-warnings</code></a> command line flag can be used to display the\nstack trace for such warnings.</p>\n<p>The emitted warning can be inspected with <a href=\"process.html#process_event_warning\"><code>process.on('warning')</code></a> and will\nhave the additional <code>emitter</code>, <code>type</code> and <code>count</code> properties, referring to\nthe event emitter instance, the event’s name and the number of attached\nlisteners, respectively.\nIts <code>name</code> property is set to <code>'MaxListenersExceededWarning'</code>.</p>"
-            },
-            {
-              "textRaw": "`EventEmitter.errorMonitor`",
-              "name": "errorMonitor",
-              "meta": {
-                "added": [
-                  "v12.17.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>This symbol shall be used to install a listener for only monitoring <code>'error'</code>\nevents. Listeners installed using this symbol are called before the regular\n<code>'error'</code> listeners are called.</p>\n<p>Installing a listener using this symbol does not change the behavior once an\n<code>'error'</code> event is emitted, therefore the process will still crash if no\nregular <code>'error'</code> listener is installed.</p>"
-            }
-          ],
           "modules": [
             {
               "textRaw": "`emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])`",
               "name": "`emitter[symbol.for('nodejs.rejection')](err,_eventname[,_...args])`",
               "meta": {
                 "added": [
+                  "v13.4.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -26077,17 +28527,110 @@
           ]
         }
       ],
+      "properties": [
+        {
+          "textRaw": "`events.defaultMaxListeners`",
+          "name": "defaultMaxListeners",
+          "meta": {
+            "added": [
+              "v0.11.2"
+            ],
+            "changes": []
+          },
+          "desc": "<p>By default, a maximum of <code>10</code> listeners can be registered for any single\nevent. This limit can be changed for individual <code>EventEmitter</code> instances\nusing the <a href=\"events.html#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> method. To change the default\nfor <em>all</em> <code>EventEmitter</code> instances, the <code>events.defaultMaxListeners</code>\nproperty can be used. If this value is not a positive number, a <code>RangeError</code>\nis thrown.</p>\n<p>Take caution when setting the <code>events.defaultMaxListeners</code> because the\nchange affects <em>all</em> <code>EventEmitter</code> instances, including those created before\nthe change is made. However, calling <a href=\"events.html#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> still has\nprecedence over <code>events.defaultMaxListeners</code>.</p>\n<p>This is not a hard limit. The <code>EventEmitter</code> instance will allow\nmore listeners to be added but will output a trace warning to stderr indicating\nthat a \"possible EventEmitter memory leak\" has been detected. For any single\n<code>EventEmitter</code>, the <code>emitter.getMaxListeners()</code> and <code>emitter.setMaxListeners()</code>\nmethods can be used to temporarily avoid this warning:</p>\n<pre><code class=\"language-js\">emitter.setMaxListeners(emitter.getMaxListeners() + 1);\nemitter.once('event', () => {\n  // do stuff\n  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));\n});\n</code></pre>\n<p>The <a href=\"cli.html#cli_trace_warnings\"><code>--trace-warnings</code></a> command-line flag can be used to display the\nstack trace for such warnings.</p>\n<p>The emitted warning can be inspected with <a href=\"process.html#process_event_warning\"><code>process.on('warning')</code></a> and will\nhave the additional <code>emitter</code>, <code>type</code> and <code>count</code> properties, referring to\nthe event emitter instance, the event’s name and the number of attached\nlisteners, respectively.\nIts <code>name</code> property is set to <code>'MaxListenersExceededWarning'</code>.</p>"
+        },
+        {
+          "textRaw": "`events.errorMonitor`",
+          "name": "errorMonitor",
+          "meta": {
+            "added": [
+              "v13.6.0",
+              "v12.17.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>This symbol shall be used to install a listener for only monitoring <code>'error'</code>\nevents. Listeners installed using this symbol are called before the regular\n<code>'error'</code> listeners are called.</p>\n<p>Installing a listener using this symbol does not change the behavior once an\n<code>'error'</code> event is emitted, therefore the process will still crash if no\nregular <code>'error'</code> listener is installed.</p>"
+        },
+        {
+          "textRaw": "`events.captureRejections`",
+          "name": "captureRejections",
+          "meta": {
+            "added": [
+              "v13.4.0",
+              "v12.16.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "captureRejections is experimental.",
+          "desc": "<p>Value: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a></p>\n<p>Change the default <code>captureRejections</code> option on all new <code>EventEmitter</code> objects.</p>"
+        },
+        {
+          "textRaw": "`events.captureRejectionSymbol`",
+          "name": "captureRejectionSymbol",
+          "meta": {
+            "added": [
+              "v13.4.0",
+              "v12.16.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "captureRejections is experimental.",
+          "desc": "<p>Value: <code>Symbol.for('nodejs.rejection')</code></p>\n<p>See how to write a custom <a href=\"events.html#events_emitter_symbol_for_nodejs_rejection_err_eventname_args\">rejection handler</a>.</p>"
+        }
+      ],
       "methods": [
         {
-          "textRaw": "`events.once(emitter, name)`",
+          "textRaw": "`events.getEventListeners(emitterOrTarget, eventName)`",
           "type": "method",
-          "name": "once",
+          "name": "getEventListeners",
           "meta": {
             "added": [
-              "v11.13.0"
+              "v14.17.0"
             ],
             "changes": []
           },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {Function[]}",
+                "name": "return",
+                "type": "Function[]"
+              },
+              "params": [
+                {
+                  "textRaw": "`emitterOrTarget` {EventEmitter|EventTarget}",
+                  "name": "emitterOrTarget",
+                  "type": "EventEmitter|EventTarget"
+                },
+                {
+                  "textRaw": "`eventName` {string|symbol}",
+                  "name": "eventName",
+                  "type": "string|symbol"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Returns a copy of the array of listeners for the event named <code>eventName</code>.</p>\n<p>For <code>EventEmitter</code>s this behaves exactly the same as calling <code>.listeners</code> on\nthe emitter.</p>\n<p>For <code>EventTarget</code>s this is the only way to get the event listeners for the\nevent target. This is useful for debugging and diagnostic purposes.</p>\n<pre><code class=\"language-js\">const { getEventListeners, EventEmitter } = require('events');\n\n{\n  const ee = new EventEmitter();\n  const listener = () => console.log('Events are fun');\n  ee.on('foo', listener);\n  getEventListeners(ee, 'foo'); // [listener]\n}\n{\n  const et = new EventTarget();\n  const listener = () => console.log('Events are fun');\n  et.addEventListener('foo', listener);\n  getEventListeners(et, 'foo'); // [listener]\n}\n</code></pre>"
+        },
+        {
+          "textRaw": "`events.once(emitter, name[, options])`",
+          "type": "method",
+          "name": "once",
+          "meta": {
+            "added": [
+              "v11.13.0",
+              "v10.16.0"
+            ],
+            "changes": [
+              {
+                "version": "v14.17.0",
+                "pr-url": "https://github.com/nodejs/node/pull/34912",
+                "description": "The `signal` option is supported now."
+              }
+            ]
+          },
           "signatures": [
             {
               "return": {
@@ -26105,11 +28648,24 @@
                   "textRaw": "`name` {string}",
                   "name": "name",
                   "type": "string"
+                },
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`signal` {AbortSignal} Can be used to cancel waiting for the event.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": "Can be used to cancel waiting for the event."
+                    }
+                  ]
                 }
               ]
             }
           ],
-          "desc": "<p>Creates a <code>Promise</code> that is fulfilled when the <code>EventEmitter</code> emits the given\nevent or that is rejected if the <code>EventEmitter</code> emits <code>'error'</code> while waiting.\nThe <code>Promise</code> will resolve with an array of all the arguments emitted to the\ngiven event.</p>\n<p>This method is intentionally generic and works with the web platform\n<a href=\"https://dom.spec.whatwg.org/#interface-eventtarget\">EventTarget</a> interface, which has no special\n<code>'error'</code> event semantics and does not listen to the <code>'error'</code> event.</p>\n<pre><code class=\"language-js\">const { once, EventEmitter } = require('events');\n\nasync function run() {\n  const ee = new EventEmitter();\n\n  process.nextTick(() => {\n    ee.emit('myevent', 42);\n  });\n\n  const [value] = await once(ee, 'myevent');\n  console.log(value);\n\n  const err = new Error('kaboom');\n  process.nextTick(() => {\n    ee.emit('error', err);\n  });\n\n  try {\n    await once(ee, 'myevent');\n  } catch (err) {\n    console.log('error happened', err);\n  }\n}\n\nrun();\n</code></pre>\n<p>The special handling of the <code>'error'</code> event is only used when <code>events.once()</code>\nis used to wait for another event. If <code>events.once()</code> is used to wait for the\n'<code>error'</code> event itself, then it is treated as any other kind of event without\nspecial handling:</p>\n<pre><code class=\"language-js\">const { EventEmitter, once } = require('events');\n\nconst ee = new EventEmitter();\n\nonce(ee, 'error')\n  .then(([err]) => console.log('ok', err.message))\n  .catch((err) => console.log('error', err.message));\n\nee.emit('error', new Error('boom'));\n\n// Prints: ok boom\n</code></pre>",
+          "desc": "<p>Creates a <code>Promise</code> that is fulfilled when the <code>EventEmitter</code> emits the given\nevent or that is rejected if the <code>EventEmitter</code> emits <code>'error'</code> while waiting.\nThe <code>Promise</code> will resolve with an array of all the arguments emitted to the\ngiven event.</p>\n<p>This method is intentionally generic and works with the web platform\n<a href=\"https://dom.spec.whatwg.org/#interface-eventtarget\">EventTarget</a> interface, which has no special\n<code>'error'</code> event semantics and does not listen to the <code>'error'</code> event.</p>\n<pre><code class=\"language-js\">const { once, EventEmitter } = require('events');\n\nasync function run() {\n  const ee = new EventEmitter();\n\n  process.nextTick(() => {\n    ee.emit('myevent', 42);\n  });\n\n  const [value] = await once(ee, 'myevent');\n  console.log(value);\n\n  const err = new Error('kaboom');\n  process.nextTick(() => {\n    ee.emit('error', err);\n  });\n\n  try {\n    await once(ee, 'myevent');\n  } catch (err) {\n    console.log('error happened', err);\n  }\n}\n\nrun();\n</code></pre>\n<p>The special handling of the <code>'error'</code> event is only used when <code>events.once()</code>\nis used to wait for another event. If <code>events.once()</code> is used to wait for the\n'<code>error'</code> event itself, then it is treated as any other kind of event without\nspecial handling:</p>\n<pre><code class=\"language-js\">const { EventEmitter, once } = require('events');\n\nconst ee = new EventEmitter();\n\nonce(ee, 'error')\n  .then(([err]) => console.log('ok', err.message))\n  .catch((err) => console.log('error', err.message));\n\nee.emit('error', new Error('boom'));\n\n// Prints: ok boom\n</code></pre>\n<p>An <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> can be used to cancel waiting for the event:</p>\n<pre><code class=\"language-js\">const { EventEmitter, once } = require('events');\n\nconst ee = new EventEmitter();\nconst ac = new AbortController();\n\nasync function foo(emitter, event, signal) {\n  try {\n    await once(emitter, event, { signal });\n    console.log('event emitted!');\n  } catch (error) {\n    if (error.name === 'AbortError') {\n      console.error('Waiting for the event was canceled!');\n    } else {\n      console.error('There was an error', error.message);\n    }\n  }\n}\n\nfoo(ee, 'foo', ac.signal);\nac.abort(); // Abort waiting for the event\nee.emit('foo'); // Prints: Waiting for the event was canceled!\n</code></pre>",
           "modules": [
             {
               "textRaw": "Awaiting multiple events emitted on `process.nextTick()`",
@@ -26121,11 +28677,47 @@
           ]
         },
         {
-          "textRaw": "events.on(emitter, eventName)",
+          "textRaw": "`events.listenerCount(emitter, eventName)`",
+          "type": "method",
+          "name": "listenerCount",
+          "meta": {
+            "added": [
+              "v0.9.12"
+            ],
+            "deprecated": [
+              "v3.2.0"
+            ],
+            "changes": []
+          },
+          "stability": 0,
+          "stabilityText": "Deprecated: Use [`emitter.listenerCount()`][] instead.",
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`emitter` {EventEmitter} The emitter to query",
+                  "name": "emitter",
+                  "type": "EventEmitter",
+                  "desc": "The emitter to query"
+                },
+                {
+                  "textRaw": "`eventName` {string|symbol} The event name",
+                  "name": "eventName",
+                  "type": "string|symbol",
+                  "desc": "The event name"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>A class method that returns the number of listeners for the given <code>eventName</code>\nregistered on the given <code>emitter</code>.</p>\n<pre><code class=\"language-js\">const { EventEmitter, listenerCount } = require('events');\nconst myEmitter = new EventEmitter();\nmyEmitter.on('event', () => {});\nmyEmitter.on('event', () => {});\nconsole.log(listenerCount(myEmitter, 'event'));\n// Prints: 2\n</code></pre>"
+        },
+        {
+          "textRaw": "`events.on(emitter, eventName[, options])`",
           "type": "method",
           "name": "on",
           "meta": {
             "added": [
+              "v13.6.0",
               "v12.16.0"
             ],
             "changes": []
@@ -26149,41 +28741,57 @@
                   "name": "eventName",
                   "type": "string|symbol",
                   "desc": "The name of the event being listened for"
+                },
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`signal` {AbortSignal} Can be used to cancel awaiting events.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": "Can be used to cancel awaiting events."
+                    }
+                  ]
                 }
               ]
             }
           ],
-          "desc": "<pre><code class=\"language-js\">const { on, EventEmitter } = require('events');\n\n(async () => {\n  const ee = new EventEmitter();\n\n  // Emit later on\n  process.nextTick(() => {\n    ee.emit('foo', 'bar');\n    ee.emit('foo', 42);\n  });\n\n  for await (const event of on(ee, 'foo')) {\n    // The execution of this inner block is synchronous and it\n    // processes one event at a time (even with await). Do not use\n    // if concurrent execution is required.\n    console.log(event); // prints ['bar'] [42]\n  }\n  // Unreachable here\n})();\n</code></pre>\n<p>Returns an <code>AsyncIterator</code> that iterates <code>eventName</code> events. It will throw\nif the <code>EventEmitter</code> emits <code>'error'</code>. It removes all listeners when\nexiting the loop. The <code>value</code> returned by each iteration is an array\ncomposed of the emitted event arguments.</p>"
-        }
-      ],
-      "properties": [
-        {
-          "textRaw": "`events.captureRejections`",
-          "name": "captureRejections",
-          "meta": {
-            "added": [
-              "v12.16.0"
-            ],
-            "changes": []
-          },
-          "stability": 1,
-          "stabilityText": "captureRejections is experimental.",
-          "desc": "<p>Value: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a></p>\n<p>Change the default <code>captureRejections</code> option on all new <code>EventEmitter</code> objects.</p>"
+          "desc": "<pre><code class=\"language-js\">const { on, EventEmitter } = require('events');\n\n(async () => {\n  const ee = new EventEmitter();\n\n  // Emit later on\n  process.nextTick(() => {\n    ee.emit('foo', 'bar');\n    ee.emit('foo', 42);\n  });\n\n  for await (const event of on(ee, 'foo')) {\n    // The execution of this inner block is synchronous and it\n    // processes one event at a time (even with await). Do not use\n    // if concurrent execution is required.\n    console.log(event); // prints ['bar'] [42]\n  }\n  // Unreachable here\n})();\n</code></pre>\n<p>Returns an <code>AsyncIterator</code> that iterates <code>eventName</code> events. It will throw\nif the <code>EventEmitter</code> emits <code>'error'</code>. It removes all listeners when\nexiting the loop. The <code>value</code> returned by each iteration is an array\ncomposed of the emitted event arguments.</p>\n<p>An <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> can be used to cancel waiting on events:</p>\n<pre><code class=\"language-js\">const { on, EventEmitter } = require('events');\nconst ac = new AbortController();\n\n(async () => {\n  const ee = new EventEmitter();\n\n  // Emit later on\n  process.nextTick(() => {\n    ee.emit('foo', 'bar');\n    ee.emit('foo', 42);\n  });\n\n  for await (const event of on(ee, 'foo', { signal: ac.signal })) {\n    // The execution of this inner block is synchronous and it\n    // processes one event at a time (even with await). Do not use\n    // if concurrent execution is required.\n    console.log(event); // prints ['bar'] [42]\n  }\n  // Unreachable here\n})();\n\nprocess.nextTick(() => ac.abort());\n</code></pre>"
         },
         {
-          "textRaw": "events.captureRejectionSymbol",
-          "name": "captureRejectionSymbol",
+          "textRaw": "`events.setMaxListeners(n[, ...eventTargets])`",
+          "type": "method",
+          "name": "setMaxListeners",
           "meta": {
             "added": [
-              "v12.16.0"
+              "v14.17.0"
             ],
             "changes": []
           },
-          "stability": 1,
-          "stabilityText": "captureRejections is experimental.",
-          "desc": "<p>Value: <code>Symbol.for('nodejs.rejection')</code></p>\n<p>See how to write a custom <a href=\"events.html#events_emitter_symbol_for_nodejs_rejection_err_eventname_args\">rejection handler</a>.</p>"
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`n` {number} A non-negative number. The maximum number of listeners per `EventTarget` event.",
+                  "name": "n",
+                  "type": "number",
+                  "desc": "A non-negative number. The maximum number of listeners per `EventTarget` event."
+                },
+                {
+                  "textRaw": "`...eventsTargets` {EventTarget[]|EventEmitter[]} Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter} objects.",
+                  "name": "...eventsTargets",
+                  "type": "EventTarget[]|EventEmitter[]",
+                  "desc": "Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter} objects."
+                }
+              ]
+            }
+          ],
+          "desc": "<pre><code class=\"language-js\">const {\n  setMaxListeners,\n  EventEmitter\n} = require('events');\n\nconst target = new EventTarget();\nconst emitter = new EventEmitter();\n\nsetMaxListeners(5, target, emitter);\n</code></pre>\n<p><a id=\"event-target-and-event-api\"></a></p>"
         }
-      ]
+      ],
+      "source": "doc/api/events.md"
     },
     {
       "textRaw": "File system",
@@ -26191,76 +28799,58 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/fs.js\">lib/fs.js</a></p>\n<p>The <code>fs</code> module enables interacting with the file system in a\nway modeled on standard POSIX functions.</p>\n<p>To use this module:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n</code></pre>\n<p>All file system operations have synchronous, callback, and promise-based\nforms.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/fs.js\">lib/fs.js</a></p>\n<p>The <code>fs</code> module enables interacting with the file system in a\nway modeled on standard POSIX functions.</p>\n<p>To use the promise-based APIs:</p>\n<pre><code class=\"language-mjs\">import * as fs from 'fs/promises';\n</code></pre>\n<pre><code class=\"language-cjs\">const fs = require('fs/promises');\n</code></pre>\n<p>To use the callback and sync APIs:</p>\n<pre><code class=\"language-mjs\">import * as fs from 'fs';\n</code></pre>\n<pre><code class=\"language-cjs\">const fs = require('fs');\n</code></pre>\n<p>All file system operations have synchronous, callback, and promise-based\nforms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).</p>",
       "modules": [
         {
-          "textRaw": "Synchronous example",
-          "name": "synchronous_example",
-          "desc": "<p>The synchronous form blocks the Node.js event loop and further JavaScript\nexecution until the operation is complete. Exceptions are thrown immediately\nand can be handled using <code>try…catch</code>, or can be allowed to bubble up.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\ntry {\n  fs.unlinkSync('/tmp/hello');\n  console.log('successfully deleted /tmp/hello');\n} catch (err) {\n  // handle the error\n}\n</code></pre>",
+          "textRaw": "Promise example",
+          "name": "promise_example",
+          "desc": "<p>Promise-based operations return a promise that is fulfilled when the\nasynchronous operation is complete.</p>\n<pre><code class=\"language-mjs\">import { unlink } from 'fs/promises';\n\ntry {\n  await unlink('/tmp/hello');\n  console.log('successfully deleted /tmp/hello');\n} catch (error) {\n  console.error('there was an error:', error.message);\n}\n</code></pre>\n<pre><code class=\"language-cjs\">const { unlink } = require('fs/promises');\n\n(async function(path) {\n  try {\n    await unlink(path);\n    console.log(`successfully deleted ${path}`);\n  } catch (error) {\n    console.error('there was an error:', error.message);\n  }\n})('/tmp/hello');\n</code></pre>",
           "type": "module",
-          "displayName": "Synchronous example"
+          "displayName": "Promise example"
         },
         {
           "textRaw": "Callback example",
           "name": "callback_example",
-          "desc": "<p>The callback form takes a completion callback function as its last\nargument and invokes the operation asynchronously. The arguments passed to\nthe completion callback depend on the method, but the first argument is always\nreserved for an exception. If the operation is completed successfully, then\nthe first argument is <code>null</code> or <code>undefined</code>.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nfs.unlink('/tmp/hello', (err) => {\n  if (err) throw err;\n  console.log('successfully deleted /tmp/hello');\n});\n</code></pre>",
+          "desc": "<p>The callback form takes a completion callback function as its last\nargument and invokes the operation asynchronously. The arguments passed to\nthe completion callback depend on the method, but the first argument is always\nreserved for an exception. If the operation is completed successfully, then\nthe first argument is <code>null</code> or <code>undefined</code>.</p>\n<pre><code class=\"language-mjs\">import { unlink } from 'fs';\n\nunlink('/tmp/hello', (err) => {\n  if (err) throw err;\n  console.log('successfully deleted /tmp/hello');\n});\n</code></pre>\n<pre><code class=\"language-cjs\">const { unlink } = require('fs');\n\nunlink('/tmp/hello', (err) => {\n  if (err) throw err;\n  console.log('successfully deleted /tmp/hello');\n});\n</code></pre>\n<p>The callback-based versions of the <code>fs</code> module APIs are preferable over\nthe use of the promise APIs when maximal performance (both in terms of\nexecution time and memory allocation are required).</p>",
           "type": "module",
           "displayName": "Callback example"
         },
         {
-          "textRaw": "Promise example",
-          "name": "promise_example",
-          "desc": "<p>Promise-based operations return a <code>Promise</code> that is resolved when the\nasynchronous operation is complete.</p>\n<pre><code class=\"language-js\">const fs = require('fs').promises;\n\n(async function(path) {\n  try {\n    await fs.unlink(path);\n    console.log(`successfully deleted ${path}`);\n  } catch (error) {\n    console.error('there was an error:', error.message);\n  }\n})('/tmp/hello');\n</code></pre>",
-          "type": "module",
-          "displayName": "Promise example"
-        },
-        {
-          "textRaw": "Ordering of callback and promise-based operations",
-          "name": "ordering_of_callback_and_promise-based_operations",
-          "desc": "<p>There is no guaranteed ordering when using either the callback or\npromise-based methods. For example, the following is prone to error\nbecause the <code>fs.stat()</code> operation might complete before the <code>fs.rename()</code>\noperation:</p>\n<pre><code class=\"language-js\">fs.rename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  console.log('renamed complete');\n});\nfs.stat('/tmp/world', (err, stats) => {\n  if (err) throw err;\n  console.log(`stats: ${JSON.stringify(stats)}`);\n});\n</code></pre>\n<p>To correctly order the operations, move the <code>fs.stat()</code> call into the callback\nof the <code>fs.rename()</code> operation:</p>\n<pre><code class=\"language-js\">fs.rename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  fs.stat('/tmp/world', (err, stats) => {\n    if (err) throw err;\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  });\n});\n</code></pre>\n<p>Or, use the promise-based API:</p>\n<pre><code class=\"language-js\">const fs = require('fs').promises;\n\n(async function(from, to) {\n  try {\n    await fs.rename(from, to);\n    const stats = await fs.stat(to);\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  } catch (error) {\n    console.error('there was an error:', error.message);\n  }\n})('/tmp/hello', '/tmp/world');\n</code></pre>",
+          "textRaw": "Synchronous example",
+          "name": "synchronous_example",
+          "desc": "<p>The synchronous APIs block the Node.js event loop and further JavaScript\nexecution until the operation is complete. Exceptions are thrown immediately\nand can be handled using <code>try…catch</code>, or can be allowed to bubble up.</p>\n<pre><code class=\"language-mjs\">import { unlinkSync } from 'fs';\n\ntry {\n  unlinkSync('/tmp/hello');\n  console.log('successfully deleted /tmp/hello');\n} catch (err) {\n  // handle the error\n}\n</code></pre>\n<pre><code class=\"language-cjs\">const { unlinkSync } = require('fs');\n\ntry {\n  unlinkSync('/tmp/hello');\n  console.log('successfully deleted /tmp/hello');\n} catch (err) {\n  // handle the error\n}\n</code></pre>",
           "type": "module",
-          "displayName": "Ordering of callback and promise-based operations"
+          "displayName": "Synchronous example"
         },
         {
-          "textRaw": "File paths",
-          "name": "file_paths",
-          "desc": "<p>Most <code>fs</code> operations accept filepaths that may be specified in the form of\na string, a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object using the <code>file:</code> protocol.</p>\n<p>String form paths are interpreted as UTF-8 character sequences identifying\nthe absolute or relative filename. Relative paths will be resolved relative\nto the current working directory as determined by calling <code>process.cwd()</code>.</p>\n<p>Example using an absolute path on POSIX:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nfs.open('/open/some/file.txt', 'r', (err, fd) => {\n  if (err) throw err;\n  fs.close(fd, (err) => {\n    if (err) throw err;\n  });\n});\n</code></pre>\n<p>Example using a relative path on POSIX (relative to <code>process.cwd()</code>):</p>\n<pre><code class=\"language-js\">fs.open('file.txt', 'r', (err, fd) => {\n  if (err) throw err;\n  fs.close(fd, (err) => {\n    if (err) throw err;\n  });\n});\n</code></pre>\n<p>Paths specified using a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a> are useful primarily on certain POSIX\noperating systems that treat file paths as opaque byte sequences. On such\nsystems, it is possible for a single file path to contain sub-sequences that\nuse multiple character encodings. As with string paths, <code>Buffer</code> paths may\nbe relative or absolute:</p>\n<p>Example using an absolute path on POSIX:</p>\n<pre><code class=\"language-js\">fs.open(Buffer.from('/open/some/file.txt'), 'r', (err, fd) => {\n  if (err) throw err;\n  fs.close(fd, (err) => {\n    if (err) throw err;\n  });\n});\n</code></pre>\n<p>On Windows, Node.js follows the concept of per-drive working directory. This\nbehavior can be observed when using a drive path without a backslash. For\nexample <code>fs.readdirSync('C:\\\\')</code> can potentially return a different result than\n<code>fs.readdirSync('C:')</code>. For more information, see\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths\">this MSDN page</a>.</p>",
-          "modules": [
-            {
-              "textRaw": "URL object support",
-              "name": "url_object_support",
-              "meta": {
-                "added": [
-                  "v7.6.0"
+          "textRaw": "Promises API",
+          "name": "promises_api",
+          "meta": {
+            "added": [
+              "v10.0.0"
+            ],
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31553",
+                "description": "Exposed as `require('fs/promises')`."
+              },
+              {
+                "version": [
+                  "v11.14.0",
+                  "v10.17.0"
                 ],
-                "changes": []
+                "pr-url": "https://github.com/nodejs/node/pull/26581",
+                "description": "This API is no longer experimental."
               },
-              "desc": "<p>For most <code>fs</code> module functions, the <code>path</code> or <code>filename</code> argument may be passed\nas a WHATWG <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. Only <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> objects using the <code>file:</code> protocol\nare supported.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fileUrl = new URL('file:///tmp/hello');\n\nfs.readFileSync(fileUrl);\n</code></pre>\n<p><code>file:</code> URLs are always absolute paths.</p>\n<p>Using WHATWG <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> objects might introduce platform-specific behaviors.</p>\n<p>On Windows, <code>file:</code> URLs with a host name convert to UNC paths, while <code>file:</code>\nURLs with drive letters convert to local absolute paths. <code>file:</code> URLs without a\nhost name nor a drive letter will result in a throw:</p>\n<pre><code class=\"language-js\">// On Windows :\n\n// - WHATWG file URLs with hostname convert to UNC path\n// file://hostname/p/a/t/h/file => \\\\hostname\\p\\a\\t\\h\\file\nfs.readFileSync(new URL('file://hostname/p/a/t/h/file'));\n\n// - WHATWG file URLs with drive letters convert to absolute path\n// file:///C:/tmp/hello => C:\\tmp\\hello\nfs.readFileSync(new URL('file:///C:/tmp/hello'));\n\n// - WHATWG file URLs without hostname must have a drive letters\nfs.readFileSync(new URL('file:///notdriveletter/p/a/t/h/file'));\nfs.readFileSync(new URL('file:///c/p/a/t/h/file'));\n// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute\n</code></pre>\n<p><code>file:</code> URLs with drive letters must use <code>:</code> as a separator just after\nthe drive letter. Using another separator will result in a throw.</p>\n<p>On all other platforms, <code>file:</code> URLs with a host name are unsupported and will\nresult in a throw:</p>\n<pre><code class=\"language-js\">// On other platforms:\n\n// - WHATWG file URLs with hostname are unsupported\n// file://hostname/p/a/t/h/file => throw!\nfs.readFileSync(new URL('file://hostname/p/a/t/h/file'));\n// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute\n\n// - WHATWG file URLs convert to absolute path\n// file:///tmp/hello => /tmp/hello\nfs.readFileSync(new URL('file:///tmp/hello'));\n</code></pre>\n<p>A <code>file:</code> URL having encoded slash characters will result in a throw on all\nplatforms:</p>\n<pre><code class=\"language-js\">// On Windows\nfs.readFileSync(new URL('file:///C:/p/a/t/h/%2F'));\nfs.readFileSync(new URL('file:///C:/p/a/t/h/%2f'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n\\ or / characters */\n\n// On POSIX\nfs.readFileSync(new URL('file:///p/a/t/h/%2F'));\nfs.readFileSync(new URL('file:///p/a/t/h/%2f'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n/ characters */\n</code></pre>\n<p>On Windows, <code>file:</code> URLs having encoded backslash will result in a throw:</p>\n<pre><code class=\"language-js\">// On Windows\nfs.readFileSync(new URL('file:///C:/path/%5C'));\nfs.readFileSync(new URL('file:///C:/path/%5c'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n\\ or / characters */\n</code></pre>",
-              "type": "module",
-              "displayName": "URL object support"
-            }
-          ],
-          "type": "module",
-          "displayName": "File paths"
-        },
-        {
-          "textRaw": "File descriptors",
-          "name": "file_descriptors",
-          "desc": "<p>On POSIX systems, for every process, the kernel maintains a table of currently\nopen files and resources. Each open file is assigned a simple numeric\nidentifier called a <em>file descriptor</em>. At the system-level, all file system\noperations use these file descriptors to identify and track each specific\nfile. Windows systems use a different but conceptually similar mechanism for\ntracking resources. To simplify things for users, Node.js abstracts away the\nspecific differences between operating systems and assigns all open files a\nnumeric file descriptor.</p>\n<p>The <code>fs.open()</code> method is used to allocate a new file descriptor. Once\nallocated, the file descriptor may be used to read data from, write data to,\nor request information about the file.</p>\n<pre><code class=\"language-js\">fs.open('/open/some/file.txt', 'r', (err, fd) => {\n  if (err) throw err;\n  fs.fstat(fd, (err, stat) => {\n    if (err) throw err;\n    // use stat\n\n    // always close the file descriptor!\n    fs.close(fd, (err) => {\n      if (err) throw err;\n    });\n  });\n});\n</code></pre>\n<p>Most operating systems limit the number of file descriptors that may be open\nat any given time so it is critical to close the descriptor when operations\nare completed. Failure to do so will result in a memory leak that will\neventually cause an application to crash.</p>",
-          "type": "module",
-          "displayName": "File descriptors"
-        },
-        {
-          "textRaw": "Threadpool usage",
-          "name": "threadpool_usage",
-          "desc": "<p>All file system APIs except <code>fs.FSWatcher()</code> and those that are explicitly\nsynchronous use libuv's threadpool, which can have surprising and negative\nperformance implications for some applications. See the\n<a href=\"cli.html#cli_uv_threadpool_size_size\"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>",
-          "type": "module",
-          "displayName": "Threadpool usage"
-        },
-        {
-          "textRaw": "`fs` Promises API",
-          "name": "`fs`_promises_api",
-          "desc": "<p>The <code>fs.promises</code> API provides an alternative set of asynchronous file system\nmethods that return <code>Promise</code> objects rather than using callbacks. The\nAPI is accessible via <code>require('fs').promises</code>.</p>",
+              {
+                "version": "v10.1.0",
+                "pr-url": "https://github.com/nodejs/node/pull/20504",
+                "description": "The API is accessible via `require('fs').promises` only."
+              }
+            ]
+          },
+          "desc": "<p>The <code>fs/promises</code> API provides asynchronous file system methods that return\npromises.</p>\n<p>The promise APIs use the underlying Node.js threadpool to perform file\nsystem operations off the event loop thread. These operations are not\nsynchronized or threadsafe. Care must be taken when performing multiple\nconcurrent modifications on the same file or data corruption may occur.</p>",
           "classes": [
             {
               "textRaw": "Class: `FileHandle`",
@@ -26272,10 +28862,10 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A <code>FileHandle</code> object is a wrapper for a numeric file descriptor.\nInstances of <code>FileHandle</code> are distinct from numeric file descriptors\nin that they provide an object oriented API for working with files.</p>\n<p>If a <code>FileHandle</code> is not closed using the\n<code>filehandle.close()</code> method, it might automatically close the file descriptor\nand will emit a process warning, thereby helping to prevent memory leaks.\nPlease do not rely on this behavior because it is unreliable and\nthe file may not be closed. Instead, always explicitly close <code>FileHandle</code>s.\nNode.js may change this behavior in the future.</p>\n<p>Instances of the <code>FileHandle</code> object are created internally by the\n<code>fsPromises.open()</code> method.</p>\n<p>Unlike the callback-based API (<code>fs.fstat()</code>, <code>fs.fchown()</code>, <code>fs.fchmod()</code>, and\nso on), a numeric file descriptor is not used by the promise-based API. Instead,\nthe promise-based API uses the <code>FileHandle</code> class in order to help avoid\naccidental leaking of unclosed file descriptors after a <code>Promise</code> is resolved or\nrejected.</p>",
+              "desc": "<p>A <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> object is an object wrapper for a numeric file descriptor.</p>\n<p>Instances of the <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> object are created by the <code>fsPromises.open()</code>\nmethod.</p>\n<p>All <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> objects are <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a>s.</p>\n<p>If a <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> is not closed using the <code>filehandle.close()</code> method, it will\ntry to automatically close the file descriptor and emit a process warning,\nhelping to prevent memory leaks. Please do not rely on this behavior because\nit can be unreliable and the file may not be closed. Instead, always explicitly\nclose <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a>s. Node.js may change this behavior in the future.</p>",
               "methods": [
                 {
-                  "textRaw": "`filehandle.appendFile(data, options)`",
+                  "textRaw": "`filehandle.appendFile(data[, options])`",
                   "type": "method",
                   "name": "appendFile",
                   "meta": {
@@ -26287,15 +28877,16 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": [
                         {
-                          "textRaw": "`data` {string|Buffer}",
+                          "textRaw": "`data` {string|Buffer|TypedArray|DataView}",
                           "name": "data",
-                          "type": "string|Buffer"
+                          "type": "string|Buffer|TypedArray|DataView"
                         },
                         {
                           "textRaw": "`options` {Object|string}",
@@ -26328,20 +28919,22 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": [
                         {
-                          "textRaw": "`mode` {integer}",
+                          "textRaw": "`mode` {integer} the file mode bit mask.",
                           "name": "mode",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "the file mode bit mask."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Modifies the permissions on the file. The <code>Promise</code> is resolved with no\narguments upon success.</p>"
+                  "desc": "<p>Modifies the permissions on the file. See <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>.</p>"
                 },
                 {
                   "textRaw": "`filehandle.chown(uid, gid)`",
@@ -26356,25 +28949,28 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": [
                         {
-                          "textRaw": "`uid` {integer}",
+                          "textRaw": "`uid` {integer} The file's new owner's user id.",
                           "name": "uid",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The file's new owner's user id."
                         },
                         {
-                          "textRaw": "`gid` {integer}",
+                          "textRaw": "`gid` {integer} The file's new group's group id.",
                           "name": "gid",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The file's new group's group id."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Changes the ownership of the file then resolves the <code>Promise</code> with no arguments\nupon success.</p>"
+                  "desc": "<p>Changes the ownership of the file. A wrapper for <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>.</p>"
                 },
                 {
                   "textRaw": "`filehandle.close()`",
@@ -26389,15 +28985,15 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise} A `Promise` that will be resolved once the underlying file descriptor is closed, or will be rejected if an error occurs while closing.",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
                         "type": "Promise",
-                        "desc": "A `Promise` that will be resolved once the underlying file descriptor is closed, or will be rejected if an error occurs while closing."
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": []
                     }
                   ],
-                  "desc": "<p>Closes the file descriptor.</p>\n<pre><code class=\"language-js\">const fsPromises = require('fs').promises;\nasync function openAndClose() {\n  let filehandle;\n  try {\n    filehandle = await fsPromises.open('thefile.txt', 'r');\n  } finally {\n    if (filehandle !== undefined)\n      await filehandle.close();\n  }\n}\n</code></pre>"
+                  "desc": "<p>Closes the file handle after waiting for any pending operation on the handle to\ncomplete.</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet filehandle;\ntry {\n  filehandle = await open('thefile.txt', 'r');\n} finally {\n  await filehandle?.close();\n}\n</code></pre>"
                 },
                 {
                   "textRaw": "`filehandle.datasync()`",
@@ -26412,14 +29008,15 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": []
                     }
                   ],
-                  "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon\nsuccess.</p>"
+                  "desc": "<p>Forces all currently queued I/O operations associated with the file to the\noperating system's synchronized I/O completion state. Refer to the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a> documentation for details.</p>\n<p>Unlike <code>filehandle.sync</code> this method does not flush modified metadata.</p>"
                 },
                 {
                   "textRaw": "`filehandle.read(buffer, offset, length, position)`",
@@ -26434,42 +29031,64 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills upon success with an object with two properties:",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills upon success with an object with two properties:",
+                        "options": [
+                          {
+                            "textRaw": "`bytesRead` {integer} The number of bytes read",
+                            "name": "bytesRead",
+                            "type": "integer",
+                            "desc": "The number of bytes read"
+                          },
+                          {
+                            "textRaw": "`buffer` {Buffer|TypedArray|DataView} A reference to the passed in `buffer` argument.",
+                            "name": "buffer",
+                            "type": "Buffer|TypedArray|DataView",
+                            "desc": "A reference to the passed in `buffer` argument."
+                          }
+                        ]
                       },
                       "params": [
                         {
-                          "textRaw": "`buffer` {Buffer|Uint8Array}",
+                          "textRaw": "`buffer` {Buffer|TypedArray|DataView} A buffer that will be filled with the file data read.",
                           "name": "buffer",
-                          "type": "Buffer|Uint8Array"
+                          "type": "Buffer|TypedArray|DataView",
+                          "desc": "A buffer that will be filled with the file data read."
                         },
                         {
-                          "textRaw": "`offset` {integer}",
+                          "textRaw": "`offset` {integer} The location in the buffer at which to start filling. **Default:** `0`",
                           "name": "offset",
-                          "type": "integer"
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "The location in the buffer at which to start filling."
                         },
                         {
-                          "textRaw": "`length` {integer}",
+                          "textRaw": "`length` {integer} The number of bytes to read. **Default:** `buffer.byteLength`",
                           "name": "length",
-                          "type": "integer"
+                          "type": "integer",
+                          "default": "`buffer.byteLength`",
+                          "desc": "The number of bytes to read."
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an integer, the current file position will remain unchanged.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an integer, the current file position will remain unchanged."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Read data from the file.</p>\n<p><code>buffer</code> is the buffer that the data will be written to.</p>\n<p><code>offset</code> is the offset in the buffer to start writing at.</p>\n<p><code>length</code> is an integer specifying the number of bytes to read.</p>\n<p><code>position</code> is an argument specifying where to begin reading from in the file.\nIf <code>position</code> is <code>null</code>, data will be read from the current file position,\nand the file position will be updated.\nIf <code>position</code> is an integer, the file position will remain unchanged.</p>\n<p>Following successful read, the <code>Promise</code> is resolved with an object with a\n<code>bytesRead</code> property specifying the number of bytes read, and a <code>buffer</code>\nproperty that is a reference to the passed in <code>buffer</code> argument.</p>"
+                  "desc": "<p>Reads data from the file and stores that in the given buffer.</p>\n<p>If the file is not modified concurrently, the end-of-file is reached when the\nnumber of bytes read is zero.</p>"
                 },
                 {
-                  "textRaw": "`filehandle.read(options)`",
+                  "textRaw": "`filehandle.read([options])`",
                   "type": "method",
                   "name": "read",
                   "meta": {
                     "added": [
+                      "v13.11.0",
                       "v12.17.0"
                     ],
                     "changes": []
@@ -26477,9 +29096,24 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills upon success with an object with two properties:",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills upon success with an object with two properties:",
+                        "options": [
+                          {
+                            "textRaw": "`bytesRead` {integer} The number of bytes read",
+                            "name": "bytesRead",
+                            "type": "integer",
+                            "desc": "The number of bytes read"
+                          },
+                          {
+                            "textRaw": "`buffer` {Buffer|TypedArray|DataView} A reference to the passed in `buffer` argument.",
+                            "name": "buffer",
+                            "type": "Buffer|TypedArray|DataView",
+                            "desc": "A reference to the passed in `buffer` argument."
+                          }
+                        ]
                       },
                       "params": [
                         {
@@ -26488,34 +29122,39 @@
                           "type": "Object",
                           "options": [
                             {
-                              "textRaw": "`buffer` {Buffer|Uint8Array} **Default:** `Buffer.alloc(16384)`",
+                              "textRaw": "`buffer` {Buffer|TypedArray|DataView} A buffer that will be filled with the file data read. **Default:** `Buffer.alloc(16384)`",
                               "name": "buffer",
-                              "type": "Buffer|Uint8Array",
-                              "default": "`Buffer.alloc(16384)`"
+                              "type": "Buffer|TypedArray|DataView",
+                              "default": "`Buffer.alloc(16384)`",
+                              "desc": "A buffer that will be filled with the file data read."
                             },
                             {
-                              "textRaw": "`offset` {integer} **Default:** `0`",
+                              "textRaw": "`offset` {integer} The location in the buffer at which to start filling. **Default:** `0`",
                               "name": "offset",
                               "type": "integer",
-                              "default": "`0`"
+                              "default": "`0`",
+                              "desc": "The location in the buffer at which to start filling."
                             },
                             {
-                              "textRaw": "`length` {integer} **Default:** `buffer.length`",
+                              "textRaw": "`length` {integer} The number of bytes to read. **Default:** `buffer.byteLength`",
                               "name": "length",
                               "type": "integer",
-                              "default": "`buffer.length`"
+                              "default": "`buffer.byteLength`",
+                              "desc": "The number of bytes to read."
                             },
                             {
-                              "textRaw": "`position` {integer} **Default:** `null`",
+                              "textRaw": "`position` {integer} The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an integer, the current file position will remain unchanged. **Default:**: `null`",
                               "name": "position",
                               "type": "integer",
-                              "default": "`null`"
+                              "default": ": `null`",
+                              "desc": "The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an integer, the current file position will remain unchanged."
                             }
                           ]
                         }
                       ]
                     }
-                  ]
+                  ],
+                  "desc": "<p>Reads data from the file and stores that in the given buffer.</p>\n<p>If the file is not modified concurrently, the end-of-file is reached when the\nnumber of bytes read is zero.</p>"
                 },
                 {
                   "textRaw": "`filehandle.readFile(options)`",
@@ -26530,9 +29169,10 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills upon a successful read with the contents of the file. If no encoding is specified (using `options.encoding`), the data is returned as a {Buffer} object. Otherwise, the data will be a string.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills upon a successful read with the contents of the file. If no encoding is specified (using `options.encoding`), the data is returned as a {Buffer} object. Otherwise, the data will be a string."
                       },
                       "params": [
                         {
@@ -26545,13 +29185,19 @@
                               "name": "encoding",
                               "type": "string|null",
                               "default": "`null`"
+                            },
+                            {
+                              "textRaw": "`signal` {AbortSignal} allows aborting an in-progress readFile",
+                              "name": "signal",
+                              "type": "AbortSignal",
+                              "desc": "allows aborting an in-progress readFile"
                             }
                           ]
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<p>The <code>Promise</code> is resolved with the contents of the file. If no encoding is\nspecified (using <code>options.encoding</code>), the data is returned as a <code>Buffer</code>\nobject. Otherwise, the data will be a string.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>The <code>FileHandle</code> has to support reading.</p>\n<p>If one or more <code>filehandle.read()</code> calls are made on a file handle and then a\n<code>filehandle.readFile()</code> call is made, the data will be read from the current\nposition till the end of the file. It doesn't always read from the beginning\nof the file.</p>"
+                  "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>\n<p>The <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> has to support reading.</p>\n<p>If one or more <code>filehandle.read()</code> calls are made on a file handle and then a\n<code>filehandle.readFile()</code> call is made, the data will be read from the current\nposition till the end of the file. It doesn't always read from the beginning\nof the file.</p>"
                 },
                 {
                   "textRaw": "`filehandle.readv(buffers[, position])`",
@@ -26559,6 +29205,7 @@
                   "name": "readv",
                   "meta": {
                     "added": [
+                      "v13.13.0",
                       "v12.17.0"
                     ],
                     "changes": []
@@ -26566,25 +29213,41 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills upon success an object containing two properties:",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills upon success an object containing two properties:",
+                        "options": [
+                          {
+                            "textRaw": "`bytesRead` {integer} the number of bytes read",
+                            "name": "bytesRead",
+                            "type": "integer",
+                            "desc": "the number of bytes read"
+                          },
+                          {
+                            "textRaw": "`buffers` {Buffer[]|TypedArray[]|DataView[]} property containing a reference to the `buffers` input.",
+                            "name": "buffers",
+                            "type": "Buffer[]|TypedArray[]|DataView[]",
+                            "desc": "property containing a reference to the `buffers` input."
+                          }
+                        ]
                       },
                       "params": [
                         {
-                          "textRaw": "`buffers` {ArrayBufferView[]}",
+                          "textRaw": "`buffers` {Buffer[]|TypedArray[]|DataView[]}",
                           "name": "buffers",
-                          "type": "ArrayBufferView[]"
+                          "type": "Buffer[]|TypedArray[]|DataView[]"
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The offset from the beginning of the file where the data should be read from. If `position` is not a `number`, the data will be read from the current position.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The offset from the beginning of the file where the data should be read from. If `position` is not a `number`, the data will be read from the current position."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Read from a file and write to an array of <code>ArrayBufferView</code>s</p>\n<p>The <code>Promise</code> is resolved with an object containing a <code>bytesRead</code> property\nidentifying the number of bytes read, and a <code>buffers</code> property containing\na reference to the <code>buffers</code> input.</p>\n<p><code>position</code> is the offset from the beginning of the file where this data\nshould be read from. If <code>typeof position !== 'number'</code>, the data will be read\nfrom the current position.</p>"
+                  "desc": "<p>Read from a file and write to an array of <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView\" class=\"type\">&lt;ArrayBufferView&gt;</a>s</p>"
                 },
                 {
                   "textRaw": "`filehandle.stat([options])`",
@@ -26605,9 +29268,10 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with an {fs.Stats} for the file.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with an {fs.Stats} for the file."
                       },
                       "params": [
                         {
@@ -26616,18 +29280,17 @@
                           "type": "Object",
                           "options": [
                             {
-                              "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
+                              "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
                               "name": "bigint",
                               "type": "boolean",
                               "default": "`false`",
-                              "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                              "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
                             }
                           ]
                         }
                       ]
                     }
-                  ],
-                  "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\"><code>fs.Stats</code></a> for the file.</p>"
+                  ]
                 },
                 {
                   "textRaw": "`filehandle.sync()`",
@@ -26642,14 +29305,15 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fufills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fufills with `undefined` upon success."
                       },
                       "params": []
                     }
                   ],
-                  "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon\nsuccess.</p>"
+                  "desc": "<p>Request that all data for the open file descriptor is flushed to the storage\ndevice. The specific implementation is operating system and device specific.\nRefer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a> documentation for more detail.</p>"
                 },
                 {
                   "textRaw": "`filehandle.truncate(len)`",
@@ -26664,9 +29328,10 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": [
                         {
@@ -26678,7 +29343,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Truncates the file then resolves the <code>Promise</code> with no arguments upon success.</p>\n<p>If the file was larger than <code>len</code> bytes, only the first <code>len</code> bytes will be\nretained in the file.</p>\n<p>For example, the following program retains only the first four bytes of the\nfile:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fsPromises = fs.promises;\n\nconsole.log(fs.readFileSync('temp.txt', 'utf8'));\n// Prints: Node.js\n\nasync function doTruncate() {\n  let filehandle = null;\n  try {\n    filehandle = await fsPromises.open('temp.txt', 'r+');\n    await filehandle.truncate(4);\n  } finally {\n    if (filehandle) {\n      // Close the file if it is opened.\n      await filehandle.close();\n    }\n  }\n  console.log(fs.readFileSync('temp.txt', 'utf8'));  // Prints: Node\n}\n\ndoTruncate().catch(console.error);\n</code></pre>\n<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the\nextended part is filled with null bytes (<code>'\\0'</code>):</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fsPromises = fs.promises;\n\nconsole.log(fs.readFileSync('temp.txt', 'utf8'));\n// Prints: Node.js\n\nasync function doTruncate() {\n  let filehandle = null;\n  try {\n    filehandle = await fsPromises.open('temp.txt', 'r+');\n    await filehandle.truncate(10);\n  } finally {\n    if (filehandle) {\n      // Close the file if it is opened.\n      await filehandle.close();\n    }\n  }\n  console.log(fs.readFileSync('temp.txt', 'utf8'));  // Prints Node.js\\0\\0\\0\n}\n\ndoTruncate().catch(console.error);\n</code></pre>\n<p>The last three bytes are null bytes (<code>'\\0'</code>), to compensate the over-truncation.</p>"
+                  "desc": "<p>Truncates the file.</p>\n<p>If the file was larger than <code>len</code> bytes, only the first <code>len</code> bytes will be\nretained in the file.</p>\n<p>The following example retains only the first four bytes of the file:</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet filehandle = null;\ntry {\n  filehandle = await open('temp.txt', 'r+');\n  await filehandle.truncate(4);\n} finally {\n  await filehandle?.close();\n}\n</code></pre>\n<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the\nextended part is filled with null bytes (<code>'\\0'</code>):</p>\n<p>If <code>len</code> is negative then <code>0</code> will be used.</p>"
                 },
                 {
                   "textRaw": "`filehandle.utimes(atime, mtime)`",
@@ -26711,7 +29376,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Change the file system timestamps of the object referenced by the <code>FileHandle</code>\nthen resolves the <code>Promise</code> with no arguments upon success.</p>\n<p>This function does not work on AIX versions before 7.1, it will resolve the\n<code>Promise</code> with an error using code <code>UV_ENOSYS</code>.</p>"
+                  "desc": "<p>Change the file system timestamps of the object referenced by the <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a>\nthen resolves the promise with no arguments upon success.</p>\n<p>This function does not work on AIX versions before 7.1, it will reject the\npromise with an error using code <code>UV_ENOSYS</code>.</p>"
                 },
                 {
                   "textRaw": "`filehandle.write(buffer[, offset[, length[, position]]])`",
@@ -26721,7 +29386,18 @@
                     "added": [
                       "v10.0.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v14.12.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/34993",
+                        "description": "The `buffer` parameter will stringify an object with an explicit `toString` function."
+                      },
+                      {
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/31030",
+                        "description": "The `buffer` parameter won't coerce unsupported input to buffers anymore."
+                      }
+                    ]
                   },
                   "signatures": [
                     {
@@ -26732,29 +29408,34 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`buffer` {Buffer|Uint8Array}",
+                          "textRaw": "`buffer` {Buffer|TypedArray|DataView|string|Object}",
                           "name": "buffer",
-                          "type": "Buffer|Uint8Array"
+                          "type": "Buffer|TypedArray|DataView|string|Object"
                         },
                         {
-                          "textRaw": "`offset` {integer}",
+                          "textRaw": "`offset` {integer} The start position from within `buffer` where the data to write begins. **Default:** `0`",
                           "name": "offset",
-                          "type": "integer"
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "The start position from within `buffer` where the data to write begins."
                         },
                         {
-                          "textRaw": "`length` {integer}",
+                          "textRaw": "`length` {integer} The number of bytes from `buffer` to write. **Default:** `buffer.byteLength`",
                           "name": "length",
-                          "type": "integer"
+                          "type": "integer",
+                          "default": "`buffer.byteLength`",
+                          "desc": "The number of bytes from `buffer` to write."
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The offset from the beginning of the file where the data from `buffer` should be written. If `position` is not a `number`, the data will be written at the current position. See the POSIX pwrite(2) documentation for more detail.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The offset from the beginning of the file where the data from `buffer` should be written. If `position` is not a `number`, the data will be written at the current position. See the POSIX pwrite(2) documentation for more detail."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Write <code>buffer</code> to the file.</p>\n<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property\nidentifying the number of bytes written, and a <code>buffer</code> property containing\na reference to the <code>buffer</code> written.</p>\n<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is\nan integer specifying the number of bytes to write.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file\nwithout waiting for the <code>Promise</code> to be resolved (or rejected). For this\nscenario, use <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes do not work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+                  "desc": "<p>Write <code>buffer</code> to the file.</p>\n<p>If <code>buffer</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<p>The promise is resolved with an object containing two properties:</p>\n<ul>\n<li><code>bytesWritten</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> the number of bytes written</li>\n<li><code>buffer</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\" class=\"type\">&lt;TypedArray&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\" class=\"type\">&lt;DataView&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> a reference to the\n<code>buffer</code> written.</li>\n</ul>\n<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file\nwithout waiting for the promise to be resolved (or rejected). For this\nscenario, use <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes do not work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
                 },
                 {
                   "textRaw": "`filehandle.write(string[, position[, encoding]])`",
@@ -26764,7 +29445,18 @@
                     "added": [
                       "v10.0.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v14.12.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/34993",
+                        "description": "The `string` parameter will stringify an object with an explicit `toString` function."
+                      },
+                      {
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/31030",
+                        "description": "The `string` parameter won't coerce unsupported input to strings anymore."
+                      }
+                    ]
                   },
                   "signatures": [
                     {
@@ -26775,25 +29467,27 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`string` {string}",
+                          "textRaw": "`string` {string|Object}",
                           "name": "string",
-                          "type": "string"
+                          "type": "string|Object"
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The offset from the beginning of the file where the data from `string` should be written. If `position` is not a `number` the data will be written at the current position. See the POSIX pwrite(2) documentation for more detail.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The offset from the beginning of the file where the data from `string` should be written. If `position` is not a `number` the data will be written at the current position. See the POSIX pwrite(2) documentation for more detail."
                         },
                         {
-                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "textRaw": "`encoding` {string} The expected string encoding. **Default:** `'utf8'`",
                           "name": "encoding",
                           "type": "string",
-                          "default": "`'utf8'`"
+                          "default": "`'utf8'`",
+                          "desc": "The expected string encoding."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Write <code>string</code> to the file. If <code>string</code> is not a string, then\nthe value will be coerced to one.</p>\n<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property\nidentifying the number of bytes written, and a <code>buffer</code> property containing\na reference to the <code>string</code> written.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If the type of <code>position</code> is not a <code>number</code> the data\nwill be written at the current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p><code>encoding</code> is the expected string encoding.</p>\n<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file\nwithout waiting for the <code>Promise</code> to be resolved (or rejected). For this\nscenario, use <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes do not work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+                  "desc": "<p>Write <code>string</code> to the file. If <code>string</code> is not a string, or an object with an\nown <code>toString</code> function property, the promise is rejected with an error.</p>\n<p>The promise is resolved with an object containing two properties:</p>\n<ul>\n<li><code>bytesWritten</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> the number of bytes written</li>\n<li><code>buffer</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> a reference to the <code>string</code> written.</li>\n</ul>\n<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file\nwithout waiting for the promise to be resolved (or rejected). For this\nscenario, use <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes do not work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
                 },
                 {
                   "textRaw": "`filehandle.writeFile(data, options)`",
@@ -26803,7 +29497,23 @@
                     "added": [
                       "v10.0.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v14.18.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/37490",
+                        "description": "The `data` argument supports `AsyncIterable`, `Iterable` and `Stream`."
+                      },
+                      {
+                        "version": "v14.12.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/34993",
+                        "description": "The `data` parameter will stringify an object with an explicit `toString` function."
+                      },
+                      {
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/31030",
+                        "description": "The `data` parameter won't coerce unsupported input to strings anymore."
+                      }
+                    ]
                   },
                   "signatures": [
                     {
@@ -26814,9 +29524,9 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`data` {string|Buffer|Uint8Array}",
+                          "textRaw": "`data` {string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable |Stream}",
                           "name": "data",
-                          "type": "string|Buffer|Uint8Array"
+                          "type": "string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable |Stream"
                         },
                         {
                           "textRaw": "`options` {Object|string}",
@@ -26824,17 +29534,18 @@
                           "type": "Object|string",
                           "options": [
                             {
-                              "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                              "textRaw": "`encoding` {string|null} The expected character encoding when `data` is a string. **Default:** `'utf8'`",
                               "name": "encoding",
                               "type": "string|null",
-                              "default": "`'utf8'`"
+                              "default": "`'utf8'`",
+                              "desc": "The expected character encoding when `data` is a string."
                             }
                           ]
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Asynchronously writes data to a file, replacing the file if it already exists.\n<code>data</code> can be a string or a buffer. The <code>Promise</code> will be resolved with no\narguments upon success.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>The <code>FileHandle</code> has to support writing.</p>\n<p>It is unsafe to use <code>filehandle.writeFile()</code> multiple times on the same file\nwithout waiting for the <code>Promise</code> to be resolved (or rejected).</p>\n<p>If one or more <code>filehandle.write()</code> calls are made on a file handle and then a\n<code>filehandle.writeFile()</code> call is made, the data will be written from the\ncurrent position till the end of the file. It doesn't always write from the\nbeginning of the file.</p>"
+                  "desc": "<p>Asynchronously writes data to a file, replacing the file if it already exists.\n<code>data</code> can be a string, a buffer, an <a href=\"https://tc39.github.io/ecma262/#sec-asynciterable-interface\" class=\"type\">&lt;AsyncIterable&gt;</a> or <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol\" class=\"type\">&lt;Iterable&gt;</a> object, or an\nobject with an own <code>toString</code> function\nproperty. The promise is resolved with no arguments upon success.</p>\n<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>\n<p>The <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> has to support writing.</p>\n<p>It is unsafe to use <code>filehandle.writeFile()</code> multiple times on the same file\nwithout waiting for the promise to be resolved (or rejected).</p>\n<p>If one or more <code>filehandle.write()</code> calls are made on a file handle and then a\n<code>filehandle.writeFile()</code> call is made, the data will be written from the\ncurrent position till the end of the file. It doesn't always write from the\nbeginning of the file.</p>"
                 },
                 {
                   "textRaw": "`filehandle.writev(buffers[, position])`",
@@ -26855,24 +29566,25 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`buffers` {ArrayBufferView[]}",
+                          "textRaw": "`buffers` {Buffer[]|TypedArray[]|DataView[]}",
                           "name": "buffers",
-                          "type": "ArrayBufferView[]"
+                          "type": "Buffer[]|TypedArray[]|DataView[]"
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The offset from the beginning of the file where the data from `buffers` should be written. If `position` is not a `number`, the data will be written at the current position.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The offset from the beginning of the file where the data from `buffers` should be written. If `position` is not a `number`, the data will be written at the current position."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Write an array of <code>ArrayBufferView</code>s to the file.</p>\n<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property\nidentifying the number of bytes written, and a <code>buffers</code> property containing\na reference to the <code>buffers</code> input.</p>\n<p><code>position</code> is the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position.</p>\n<p>It is unsafe to call <code>writev()</code> multiple times on the same file without waiting\nfor the previous operation to complete.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+                  "desc": "<p>Write an array of <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView\" class=\"type\">&lt;ArrayBufferView&gt;</a>s to the file.</p>\n<p>The promise is resolved with an object containing a two properties:</p>\n<ul>\n<li><code>bytesWritten</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> the number of bytes written</li>\n<li><code>buffers</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\" class=\"type\">&lt;TypedArray[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\" class=\"type\">&lt;DataView[]&gt;</a> a reference to the <code>buffers</code>\ninput.</li>\n</ul>\n<p>It is unsafe to call <code>writev()</code> multiple times on the same file without waiting\nfor the promise to be resolved (or rejected).</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
                 }
               ],
               "properties": [
                 {
-                  "textRaw": "`fd` {number} The numeric file descriptor managed by the `FileHandle` object.",
+                  "textRaw": "`fd` {number} The numeric file descriptor managed by the {FileHandle} object.",
                   "type": "number",
                   "name": "fd",
                   "meta": {
@@ -26881,7 +29593,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "The numeric file descriptor managed by the `FileHandle` object."
+                  "desc": "The numeric file descriptor managed by the {FileHandle} object."
                 }
               ]
             }
@@ -26900,9 +29612,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -26919,7 +29632,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Tests a user's permissions for the file or directory specified by <code>path</code>.\nThe <code>mode</code> argument is an optional integer that specifies the accessibility\nchecks to be performed. Check <a href=\"fs.html#fs_file_access_constants\">File access constants</a> for possible values\nof <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of\ntwo or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>If the accessibility check is successful, the <code>Promise</code> is resolved with no\nvalue. If any of the accessibility checks fail, the <code>Promise</code> is rejected\nwith an <code>Error</code> object. The following example checks if the file\n<code>/etc/passwd</code> can be read and written by the current process.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fsPromises = fs.promises;\n\nfsPromises.access('/etc/passwd', fs.constants.R_OK | fs.constants.W_OK)\n  .then(() => console.log('can access'))\n  .catch(() => console.error('cannot access'));\n</code></pre>\n<p>Using <code>fsPromises.access()</code> to check for the accessibility of a file before\ncalling <code>fsPromises.open()</code> is not recommended. Doing so introduces a race\ncondition, since other processes may change the file's state between the two\ncalls. Instead, user code should open/read/write the file directly and handle\nthe error raised if the file is not accessible.</p>"
+              "desc": "<p>Tests a user's permissions for the file or directory specified by <code>path</code>.\nThe <code>mode</code> argument is an optional integer that specifies the accessibility\nchecks to be performed. Check <a href=\"fs.html#fs_file_access_constants\">File access constants</a> for possible values\nof <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of\ntwo or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>If the accessibility check is successful, the promise is resolved with no\nvalue. If any of the accessibility checks fail, the promise is rejected\nwith an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\" class=\"type\">&lt;Error&gt;</a> object. The following example checks if the file\n<code>/etc/passwd</code> can be read and written by the current process.</p>\n<pre><code class=\"language-mjs\">import { access } from 'fs/promises';\nimport { constants } from 'fs';\n\ntry {\n  await access('/etc/passwd', constants.R_OK | constants.W_OK);\n  console.log('can access');\n} catch {\n  console.error('cannot access');\n}\n</code></pre>\n<p>Using <code>fsPromises.access()</code> to check for the accessibility of a file before\ncalling <code>fsPromises.open()</code> is not recommended. Doing so introduces a race\ncondition, since other processes may change the file's state between the two\ncalls. Instead, user code should open/read/write the file directly and handle\nthe error raised if the file is not accessible.</p>"
             },
             {
               "textRaw": "`fsPromises.appendFile(path, data[, options])`",
@@ -26934,16 +29647,17 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
-                      "textRaw": "`path` {string|Buffer|URL|FileHandle} filename or `FileHandle`",
+                      "textRaw": "`path` {string|Buffer|URL|FileHandle} filename or {FileHandle}",
                       "name": "path",
                       "type": "string|Buffer|URL|FileHandle",
-                      "desc": "filename or `FileHandle`"
+                      "desc": "filename or {FileHandle}"
                     },
                     {
                       "textRaw": "`data` {string|Buffer}",
@@ -26979,7 +29693,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>. The <code>Promise</code> will be\nresolved with no arguments upon success.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>The <code>path</code> may be specified as a <code>FileHandle</code> that has been opened\nfor appending (using <code>fsPromises.open()</code>).</p>"
+              "desc": "<p>Asynchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"fs.html#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<p>The <code>path</code> may be specified as a <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> that has been opened\nfor appending (using <code>fsPromises.open()</code>).</p>"
             },
             {
               "textRaw": "`fsPromises.chmod(path, mode)`",
@@ -26994,9 +29708,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27012,7 +29727,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the permissions of a file then resolves the <code>Promise</code> with no\narguments upon succces.</p>"
+              "desc": "<p>Changes the permissions of a file.</p>"
             },
             {
               "textRaw": "`fsPromises.chown(path, uid, gid)`",
@@ -27027,9 +29742,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27050,10 +29766,10 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the ownership of a file then resolves the <code>Promise</code> with no arguments\nupon success.</p>"
+              "desc": "<p>Changes the ownership of a file.</p>"
             },
             {
-              "textRaw": "`fsPromises.copyFile(src, dest[, flags])`",
+              "textRaw": "`fsPromises.copyFile(src, dest[, mode])`",
               "type": "method",
               "name": "copyFile",
               "meta": {
@@ -27071,9 +29787,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27089,16 +29806,33 @@
                       "desc": "destination filename of the copy operation"
                     },
                     {
-                      "textRaw": "`flags` {number} modifiers for copy operation. **Default:** `0`.",
-                      "name": "flags",
-                      "type": "number",
+                      "textRaw": "`mode` {integer} Optional modifiers that specify the behavior of the copy operation. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g. `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`) **Default:** `0`.",
+                      "name": "mode",
+                      "type": "integer",
                       "default": "`0`",
-                      "desc": "modifiers for copy operation."
+                      "desc": "Optional modifiers that specify the behavior of the copy operation. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g. `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`)",
+                      "options": [
+                        {
+                          "textRaw": "`fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already exists.",
+                          "name": "fs.constants.COPYFILE_EXCL",
+                          "desc": "The copy operation will fail if `dest` already exists."
+                        },
+                        {
+                          "textRaw": "`fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a copy-on-write reflink. If the platform does not support copy-on-write, then a fallback copy mechanism is used.",
+                          "name": "fs.constants.COPYFILE_FICLONE",
+                          "desc": "The copy operation will attempt to create a copy-on-write reflink. If the platform does not support copy-on-write, then a fallback copy mechanism is used."
+                        },
+                        {
+                          "textRaw": "`fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to create a copy-on-write reflink. If the platform does not support copy-on-write, then the operation will fail.",
+                          "name": "fs.constants.COPYFILE_FICLONE_FORCE",
+                          "desc": "The copy operation will attempt to create a copy-on-write reflink. If the platform does not support copy-on-write, then the operation will fail."
+                        }
+                      ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. The <code>Promise</code> will be resolved with no arguments upon success.</p>\n<p>Node.js makes no guarantees about the atomicity of the copy operation. If an\nerror occurs after the destination file has been opened for writing, Node.js\nwill attempt to remove the destination.</p>\n<p><code>flags</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support copy-on-write,\nthen the operation will fail.</li>\n</ul>\n<pre><code class=\"language-js\">const fsPromises = require('fs').promises;\n\n// destination.txt will be created or overwritten by default.\nfsPromises.copyFile('source.txt', 'destination.txt')\n  .then(() => console.log('source.txt was copied to destination.txt'))\n  .catch(() => console.log('The file could not be copied'));\n</code></pre>\n<p>If the third argument is a number, then it specifies <code>flags</code>:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fsPromises = fs.promises;\nconst { COPYFILE_EXCL } = fs.constants;\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\nfsPromises.copyFile('source.txt', 'destination.txt', COPYFILE_EXCL)\n  .then(() => console.log('source.txt was copied to destination.txt'))\n  .catch(() => console.log('The file could not be copied'));\n</code></pre>"
+              "desc": "<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists.</p>\n<p>No guarantees are made about the atomicity of the copy operation. If an\nerror occurs after the destination file has been opened for writing, an attempt\nwill be made to remove the destination.</p>\n<pre><code class=\"language-mjs\">import { constants } from 'fs';\nimport { copyFile } from 'fs/promises';\n\ntry {\n  await copyFile('source.txt', 'destination.txt');\n  console.log('source.txt was copied to destination.txt');\n} catch {\n  console.log('The file could not be copied');\n}\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\ntry {\n  await copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL);\n  console.log('source.txt was copied to destination.txt');\n} catch {\n  console.log('The file could not be copied');\n}\n</code></pre>"
             },
             {
               "textRaw": "`fsPromises.lchmod(path, mode)`",
@@ -27113,9 +29847,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27131,7 +29866,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the permissions on a symbolic link then resolves the <code>Promise</code> with\nno arguments upon success. This method is only implemented on macOS.</p>"
+              "desc": "<p>Changes the permissions on a symbolic link.</p>\n<p>This method is only implemented on macOS.</p>"
             },
             {
               "textRaw": "`fsPromises.lchown(path, uid, gid)`",
@@ -27152,9 +29887,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27175,7 +29911,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the ownership on a symbolic link then resolves the <code>Promise</code> with\nno arguments upon success.</p>"
+              "desc": "<p>Changes the ownership on a symbolic link.</p>"
             },
             {
               "textRaw": "`fsPromises.lutimes(path, atime, mtime)`",
@@ -27183,6 +29919,7 @@
               "name": "lutimes",
               "meta": {
                 "added": [
+                  "v14.5.0",
                   "v12.19.0"
                 ],
                 "changes": []
@@ -27190,9 +29927,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27213,7 +29951,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the access and modification times of a file in the same way as\n<a href=\"fs.html#fs_fspromises_utimes_path_atime_mtime\"><code>fsPromises.utimes()</code></a>, with the difference that if the path refers to a\nsymbolic link, then the link is not dereferenced: instead, the timestamps of\nthe symbolic link itself are changed.</p>\n<p>Upon success, the <code>Promise</code> is resolved without arguments.</p>"
+              "desc": "<p>Changes the access and modification times of a file in the same way as\n<a href=\"fs.html#fs_fspromises_utimes_path_atime_mtime\"><code>fsPromises.utimes()</code></a>, with the difference that if the path refers to a\nsymbolic link, then the link is not dereferenced: instead, the timestamps of\nthe symbolic link itself are changed.</p>"
             },
             {
               "textRaw": "`fsPromises.link(existingPath, newPath)`",
@@ -27228,9 +29966,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27246,7 +29985,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon success.</p>"
+              "desc": "<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a> documentation for more detail.</p>"
             },
             {
               "textRaw": "`fsPromises.lstat(path[, options])`",
@@ -27267,9 +30006,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the {fs.Stats} object for the given symbolic link `path`.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the {fs.Stats} object for the given symbolic link `path`."
                   },
                   "params": [
                     {
@@ -27283,18 +30023,18 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
                           "name": "bigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a>. The <code>Promise</code> is resolved with the <a href=\"fs.html#fs_class_fs_stats\"><code>fs.Stats</code></a> object\nfor the given symbolic link <code>path</code>.</p>"
+              "desc": "<p>Equivalent to <a href=\"fs.html#fs_fspromises_stat_path_options\"><code>fsPromises.stat()</code></a> unless <code>path</code> refers to a symbolic link,\nin which case the link itself is stat-ed, not the file that it refers to.\nRefer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a> document for more detail.</p>"
             },
             {
               "textRaw": "`fsPromises.mkdir(path[, options])`",
@@ -27309,9 +30049,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Upon success, fulfills with `undefined` if `recursive` is `false`, or the first directory path created if `recursive` is `true`.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Upon success, fulfills with `undefined` if `recursive` is `false`, or the first directory path created if `recursive` is `true`."
                   },
                   "params": [
                     {
@@ -27342,7 +30083,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously creates a directory then resolves the <code>Promise</code> with either no\narguments, or the first directory path created if <code>recursive</code> is <code>true</code>.</p>\n<p>The optional <code>options</code> argument can be an integer specifying mode (permission\nand sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>\nproperty indicating whether parent directories should be created. Calling\n<code>fsPromises.mkdir()</code> when <code>path</code> is a directory that exists results in a\nrejection only when <code>recursive</code> is false.</p>"
+              "desc": "<p>Asynchronously creates a directory.</p>\n<p>The optional <code>options</code> argument can be an integer specifying <code>mode</code> (permission\nand sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>\nproperty indicating whether parent directories should be created. Calling\n<code>fsPromises.mkdir()</code> when <code>path</code> is a directory that exists results in a\nrejection only when <code>recursive</code> is false.</p>"
             },
             {
               "textRaw": "`fsPromises.mkdtemp(prefix[, options])`",
@@ -27352,14 +30093,21 @@
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/39028",
+                    "description": "The `prefix` parameter now accepts an empty string."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with a string containing the filesystem path of the newly created temporary directory.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with a string containing the filesystem path of the newly created temporary directory."
                   },
                   "params": [
                     {
@@ -27383,7 +30131,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Creates a unique temporary directory and resolves the <code>Promise</code> with the created\ndirectory path. A unique directory name is generated by appending six random\ncharacters to the end of the provided <code>prefix</code>. Due to platform\ninconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,\nnotably the BSDs, can return more than six random characters, and replace\ntrailing <code>X</code> characters in <code>prefix</code> with random characters.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>\n<pre><code class=\"language-js\">fsPromises.mkdtemp(path.join(os.tmpdir(), 'foo-'))\n  .catch(console.error);\n</code></pre>\n<p>The <code>fsPromises.mkdtemp()</code> method will append the six randomly selected\ncharacters directly to the <code>prefix</code> string. For instance, given a directory\n<code>/tmp</code>, if the intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the\n<code>prefix</code> must end with a trailing platform-specific path separator\n(<code>require('path').sep</code>).</p>"
+              "desc": "<p>Creates a unique temporary directory. A unique directory name is generated by\nappending six random characters to the end of the provided <code>prefix</code>. Due to\nplatform inconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some\nplatforms, notably the BSDs, can return more than six random characters, and\nreplace trailing <code>X</code> characters in <code>prefix</code> with random characters.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>\n<pre><code class=\"language-mjs\">import { mkdtemp } from 'fs/promises';\n\ntry {\n  await mkdtemp(path.join(os.tmpdir(), 'foo-'));\n} catch (err) {\n  console.error(err);\n}\n</code></pre>\n<p>The <code>fsPromises.mkdtemp()</code> method will append the six randomly selected\ncharacters directly to the <code>prefix</code> string. For instance, given a directory\n<code>/tmp</code>, if the intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the\n<code>prefix</code> must end with a trailing platform-specific path separator\n(<code>require('path').sep</code>).</p>"
             },
             {
               "textRaw": "`fsPromises.open(path, flags[, mode])`",
@@ -27404,9 +30152,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with a {FileHandle} object.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with a {FileHandle} object."
                   },
                   "params": [
                     {
@@ -27422,15 +30171,16 @@
                       "desc": "See [support of file system `flags`][]."
                     },
                     {
-                      "textRaw": "`mode` {string|integer} **Default:** `0o666` (readable and writable)",
+                      "textRaw": "`mode` {string|integer} Sets the file mode (permission and sticky bits) if the file is created. **Default:** `0o666` (readable and writable)",
                       "name": "mode",
                       "type": "string|integer",
-                      "default": "`0o666` (readable and writable)"
+                      "default": "`0o666` (readable and writable)",
+                      "desc": "Sets the file mode (permission and sticky bits) if the file is created."
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous file open that returns a <code>Promise</code> that, when resolved, yields a\n<code>FileHandle</code> object. See <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was\ncreated.</p>\n<p>Some characters (<code>&#x3C; > : \" / \\ | ? *</code>) are reserved under Windows as documented\nby <a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file\">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains\na colon, Node.js will open a file system stream, as described by\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams\">this MSDN page</a>.</p>"
+              "desc": "<p>Opens a <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a>.</p>\n<p>Refer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a> documentation for more detail.</p>\n<p>Some characters (<code>&#x3C; > : \" / \\ | ? *</code>) are reserved under Windows as documented\nby <a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file\">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains\na colon, Node.js will open a file system stream, as described by\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams\">this MSDN page</a>.</p>"
             },
             {
               "textRaw": "`fsPromises.opendir(path[, options])`",
@@ -27442,7 +30192,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.1.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30114",
                     "description": "The `bufferSize` option was introduced."
                   }
@@ -27451,10 +30204,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise} containing {fs.Dir}",
+                    "textRaw": "Returns: {Promise} Fulfills with an {fs.Dir}.",
                     "name": "return",
                     "type": "Promise",
-                    "desc": "containing {fs.Dir}"
+                    "desc": "Fulfills with an {fs.Dir}."
                   },
                   "params": [
                     {
@@ -27485,7 +30238,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously open a directory. See <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a>.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\"><code>fs.Dir</code></a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>\n<p>Example using async iteration:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nasync function print(path) {\n  const dir = await fs.promises.opendir(path);\n  for await (const dirent of dir) {\n    console.log(dirent.name);\n  }\n}\nprint('./').catch(console.error);\n</code></pre>"
+              "desc": "<p>Asynchronously open a directory for iterative scanning. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a> documentation for more detail.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>\n<p>Example using async iteration:</p>\n<pre><code class=\"language-mjs\">import { opendir } from 'fs/promises';\n\ntry {\n  const dir = await opendir('./');\n  for await (const dirent of dir)\n    console.log(dirent.name);\n} catch (err) {\n  console.error(err);\n}\n</code></pre>\n<p>When using the async iterator, the <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a> object will be automatically\nclosed after the iterator exits.</p>"
             },
             {
               "textRaw": "`fsPromises.readdir(path[, options])`",
@@ -27506,9 +30259,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with an array of the names of the files in the directory excluding `'.'` and `'..'`.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with an array of the names of the files in the directory excluding `'.'` and `'..'`."
                   },
                   "params": [
                     {
@@ -27538,7 +30292,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads the contents of a directory then resolves the <code>Promise</code> with an array\nof the names of the files in the directory excluding <code>'.'</code> and <code>'..'</code>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames. If the <code>encoding</code> is set to <code>'buffer'</code>, the filenames returned\nwill be passed as <code>Buffer</code> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the resolved array will contain\n<a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a> objects.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nasync function print(path) {\n  const files = await fs.promises.readdir(path);\n  for (const file of files) {\n    console.log(file);\n  }\n}\nprint('./').catch(console.error);\n</code></pre>"
+              "desc": "<p>Reads the contents of a directory.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames. If the <code>encoding</code> is set to <code>'buffer'</code>, the filenames returned\nwill be passed as <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the resolved array will contain\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> objects.</p>\n<pre><code class=\"language-mjs\">import { readdir } from 'fs/promises';\n\ntry {\n  const files = await readdir(path);\n  for (const file of files)\n    console.log(file);\n} catch (err) {\n  console.error(err);\n}\n</code></pre>"
             },
             {
               "textRaw": "`fsPromises.readFile(path[, options])`",
@@ -27548,14 +30302,21 @@
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35911",
+                    "description": "The options argument may include an AbortSignal to abort an ongoing readFile request."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the contents of the file.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the contents of the file."
                   },
                   "params": [
                     {
@@ -27581,13 +30342,19 @@
                           "type": "string",
                           "default": "`'r'`",
                           "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting an in-progress readFile",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting an in-progress readFile"
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<p>The <code>Promise</code> is resolved with the contents of the file. If no encoding is\nspecified (using <code>options.encoding</code>), the data is returned as a <code>Buffer</code>\nobject. Otherwise, the data will be a string.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>When the <code>path</code> is a directory, the behavior of <code>fsPromises.readFile()</code> is\nplatform-specific. On macOS, Linux, and Windows, the promise will be rejected\nwith an error. On FreeBSD, a representation of the directory's contents will be\nreturned.</p>\n<p>Any specified <code>FileHandle</code> has to support reading.</p>"
+              "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<p>If no encoding is specified (using <code>options.encoding</code>), the data is returned\nas a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object. Otherwise, the data will be a string.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>When the <code>path</code> is a directory, the behavior of <code>fsPromises.readFile()</code> is\nplatform-specific. On macOS, Linux, and Windows, the promise will be rejected\nwith an error. On FreeBSD, a representation of the directory's contents will be\nreturned.</p>\n<p>It is possible to abort an ongoing <code>readFile</code> using an <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a>. If a\nrequest is aborted the promise returned is rejected with an <code>AbortError</code>:</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs/promises';\n\ntry {\n  const controller = new AbortController();\n  const { signal } = controller;\n  const promise = readFile(fileName, { signal });\n\n  // Abort the request before the promise settles.\n  controller.abort();\n\n  await promise;\n} catch (err) {\n  // When a request is aborted - err is an AbortError\n  console.error(err);\n}\n</code></pre>\n<p>Aborting an ongoing request does not abort individual operating\nsystem requests but rather the internal buffering <code>fs.readFile</code> performs.</p>\n<p>Any specified <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> has to support reading.</p>"
             },
             {
               "textRaw": "`fsPromises.readlink(path[, options])`",
@@ -27602,9 +30369,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the `linkString` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the `linkString` upon success."
                   },
                   "params": [
                     {
@@ -27628,7 +30396,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a>. The <code>Promise</code> is resolved with the <code>linkString</code> upon\nsuccess.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>, the link path\nreturned will be passed as a <code>Buffer</code> object.</p>"
+              "desc": "<p>Reads the contents of the symbolic link referred to by <code>path</code>. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a> documentation for more detail. The promise is resolved with the\n<code>linkString</code> upon success.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>, the link path\nreturned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>"
             },
             {
               "textRaw": "`fsPromises.realpath(path[, options])`",
@@ -27643,9 +30411,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the resolved path upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the resolved path upon success."
                   },
                   "params": [
                     {
@@ -27669,7 +30438,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Determines the actual location of <code>path</code> using the same semantics as the\n<code>fs.realpath.native()</code> function then resolves the <code>Promise</code> with the resolved\npath.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path. If the <code>encoding</code> is set to <code>'buffer'</code>, the path returned will be\npassed as a <code>Buffer</code> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
+              "desc": "<p>Determines the actual location of <code>path</code> using the same semantics as the\n<code>fs.realpath.native()</code> function.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path. If the <code>encoding</code> is set to <code>'buffer'</code>, the path returned will be\npassed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
             },
             {
               "textRaw": "`fsPromises.rename(oldPath, newPath)`",
@@ -27684,9 +30453,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27702,7 +30472,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Renames <code>oldPath</code> to <code>newPath</code> and resolves the <code>Promise</code> with no arguments\nupon success.</p>"
+              "desc": "<p>Renames <code>oldPath</code> to <code>newPath</code>.</p>"
             },
             {
               "textRaw": "`fsPromises.rmdir(path[, options])`",
@@ -27714,7 +30484,15 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35579",
+                    "description": "The `recursive` option is deprecated, use `fsPromises.rm` instead."
+                  },
+                  {
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30644",
                     "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
                   },
@@ -27725,14 +30503,13 @@
                   }
                 ]
               },
-              "stability": 1,
-              "stabilityText": "Recursive removal is experimental.",
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27746,11 +30523,11 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
                           "name": "maxRetries",
                           "type": "integer",
                           "default": "`0`",
-                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
                         },
                         {
                           "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
@@ -27771,7 +30548,71 @@
                   ]
                 }
               ],
-              "desc": "<p>Removes the directory identified by <code>path</code> then resolves the <code>Promise</code> with\nno arguments upon success.</p>\n<p>Using <code>fsPromises.rmdir()</code> on a file (not a directory) results in the\n<code>Promise</code> being rejected with an <code>ENOENT</code> error on Windows and an <code>ENOTDIR</code>\nerror on POSIX.</p>"
+              "desc": "<p>Removes the directory identified by <code>path</code>.</p>\n<p>Using <code>fsPromises.rmdir()</code> on a file (not a directory) results in the\npromise being rejected with an <code>ENOENT</code> error on Windows and an <code>ENOTDIR</code>\nerror on POSIX.</p>\n<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command\n<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths\nthat represent files will be deleted. The permissive behavior of the\n<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in\nthe future.</p>"
+            },
+            {
+              "textRaw": "`fsPromises.rm(path[, options])`",
+              "type": "method",
+              "name": "rm",
+              "meta": {
+                "added": [
+                  "v14.14.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
+                    "name": "return",
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`force` {boolean} When `true`, exceptions will be ignored if `path` does not exist. **Default:** `false`.",
+                          "name": "force",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "When `true`, exceptions will be ignored if `path` does not exist."
+                        },
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive directory removal. In recursive mode operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Removes files and directories (modeled on the standard POSIX <code>rm</code> utility).</p>"
             },
             {
               "textRaw": "`fsPromises.stat(path[, options])`",
@@ -27792,9 +30633,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the {fs.Stats} object for the given `path`.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the {fs.Stats} object for the given `path`."
                   },
                   "params": [
                     {
@@ -27808,18 +30650,17 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
                           "name": "bigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
                         }
                       ]
                     }
                   ]
                 }
-              ],
-              "desc": "<p>The <code>Promise</code> is resolved with the <a href=\"fs.html#fs_class_fs_stats\"><code>fs.Stats</code></a> object for the given <code>path</code>.</p>"
+              ]
             },
             {
               "textRaw": "`fsPromises.symlink(target, path[, type])`",
@@ -27834,9 +30675,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27858,7 +30700,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Creates a symbolic link then resolves the <code>Promise</code> with no arguments upon\nsuccess.</p>\n<p>The <code>type</code> argument is only used on Windows platforms and can be one of <code>'dir'</code>,\n<code>'file'</code>, or <code>'junction'</code>. Windows junction points require the destination path\nto be absolute. When using <code>'junction'</code>, the <code>target</code> argument will\nautomatically be normalized to absolute path.</p>"
+              "desc": "<p>Creates a symbolic link.</p>\n<p>The <code>type</code> argument is only used on Windows platforms and can be one of <code>'dir'</code>,\n<code>'file'</code>, or <code>'junction'</code>. Windows junction points require the destination path\nto be absolute. When using <code>'junction'</code>, the <code>target</code> argument will\nautomatically be normalized to absolute path.</p>"
             },
             {
               "textRaw": "`fsPromises.truncate(path[, len])`",
@@ -27873,9 +30715,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27892,7 +30735,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Truncates the <code>path</code> then resolves the <code>Promise</code> with no arguments upon\nsuccess. The <code>path</code> <em>must</em> be a string or <code>Buffer</code>.</p>"
+              "desc": "<p>Truncates (shortens or extends the length) of the content at <code>path</code> to <code>len</code>\nbytes.</p>"
             },
             {
               "textRaw": "`fsPromises.unlink(path)`",
@@ -27907,9 +30750,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27920,7 +30764,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon\nsuccess.</p>"
+              "desc": "<p>If <code>path</code> refers to a symbolic link, then the link is removed without affecting\nthe file or directory to which that link refers. If the <code>path</code> refers to a file\npath that is not a symbolic link, the file is deleted. See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>\ndocumentation for more detail.</p>"
             },
             {
               "textRaw": "`fsPromises.utimes(path, atime, mtime)`",
@@ -27935,9 +30779,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27958,7 +30803,84 @@
                   ]
                 }
               ],
-              "desc": "<p>Change the file system timestamps of the object referenced by <code>path</code> then\nresolves the <code>Promise</code> with no arguments upon success.</p>\n<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>\n<ul>\n<li>Values can be either numbers representing Unix epoch time, <code>Date</code>s, or a\nnumeric string like <code>'123456789.0'</code>.</li>\n<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or\n<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>\n</ul>"
+              "desc": "<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>\n<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>\n<ul>\n<li>Values can be either numbers representing Unix epoch time, <code>Date</code>s, or a\nnumeric string like <code>'123456789.0'</code>.</li>\n<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or\n<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>\n</ul>"
+            },
+            {
+              "textRaw": "`fsPromises.watch(filename[, options])`",
+              "type": "method",
+              "name": "watch",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {AsyncIterator} of objects with the properties:",
+                    "name": "return",
+                    "type": "AsyncIterator",
+                    "desc": "of objects with the properties:",
+                    "options": [
+                      {
+                        "textRaw": "`eventType` {string} The type of change",
+                        "name": "eventType",
+                        "type": "string",
+                        "desc": "The type of change"
+                      },
+                      {
+                        "textRaw": "`filename` {string|Buffer} The name of the file changed.",
+                        "name": "filename",
+                        "type": "string|Buffer",
+                        "desc": "The name of the file changed."
+                      }
+                    ]
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`filename` {string|Buffer|URL}",
+                      "name": "filename",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`persistent` {boolean} Indicates whether the process should continue to run as long as files are being watched. **Default:** `true`.",
+                          "name": "persistent",
+                          "type": "boolean",
+                          "default": "`true`",
+                          "desc": "Indicates whether the process should continue to run as long as files are being watched."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [caveats][]). **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [caveats][])."
+                        },
+                        {
+                          "textRaw": "`encoding` {string} Specifies the character encoding to be used for the filename passed to the listener. **Default:** `'utf8'`.",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`",
+                          "desc": "Specifies the character encoding to be used for the filename passed to the listener."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} An {AbortSignal} used to signal when the watcher should stop.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "An {AbortSignal} used to signal when the watcher should stop."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns an async iterator that watches for changes on <code>filename</code>, where <code>filename</code>\nis either a file or a directory.</p>\n<pre><code class=\"language-js\">const { watch } = require('fs/promises');\n\nconst ac = new AbortController();\nconst { signal } = ac;\nsetTimeout(() => ac.abort(), 10000);\n\n(async () => {\n  try {\n    const watcher = watch(__filename, { signal });\n    for await (const event of watcher)\n      console.log(event);\n  } catch (err) {\n    if (err.name === 'AbortError')\n      return;\n    throw err;\n  }\n})();\n</code></pre>\n<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or\ndisappears in the directory.</p>\n<p>All the <a href=\"fs.html#fs_caveats\">caveats</a> for <code>fs.watch()</code> also apply to <code>fsPromises.watch()</code>.</p>"
             },
             {
               "textRaw": "`fsPromises.writeFile(file, data[, options])`",
@@ -27968,14 +30890,36 @@
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37490",
+                    "description": "The `data` argument supports `AsyncIterable`, `Iterable` and `Stream`."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35993",
+                    "description": "The options argument may include an AbortSignal to abort an ongoing writeFile request."
+                  },
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `data` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `data` parameter won't coerce unsupported input to strings anymore."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -27985,9 +30929,9 @@
                       "desc": "filename or `FileHandle`"
                     },
                     {
-                      "textRaw": "`data` {string|Buffer|Uint8Array}",
+                      "textRaw": "`data` {string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable |Stream}",
                       "name": "data",
-                      "type": "string|Buffer|Uint8Array"
+                      "type": "string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable |Stream"
                     },
                     {
                       "textRaw": "`options` {Object|string}",
@@ -28012,118 +30956,152 @@
                           "type": "string",
                           "default": "`'w'`",
                           "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting an in-progress writeFile",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting an in-progress writeFile"
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously writes data to a file, replacing the file if it already exists.\n<code>data</code> can be a string or a buffer. The <code>Promise</code> will be resolved with no\narguments upon success.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>Any specified <code>FileHandle</code> has to support writing.</p>\n<p>It is unsafe to use <code>fsPromises.writeFile()</code> multiple times on the same file\nwithout waiting for the <code>Promise</code> to be resolved (or rejected).</p>"
-            }
-          ],
-          "type": "module",
-          "displayName": "`fs` Promises API"
-        },
-        {
-          "textRaw": "FS constants",
-          "name": "fs_constants",
-          "desc": "<p>The following constants are exported by <code>fs.constants</code>.</p>\n<p>Not every constant will be available on every operating system.</p>\n<p>To use more than one constant, use the bitwise OR <code>|</code> operator.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nconst {\n  O_RDWR,\n  O_CREAT,\n  O_EXCL\n} = fs.constants;\n\nfs.open('/path/to/my/file', O_RDWR | O_CREAT | O_EXCL, (err, fd) => {\n  // ...\n});\n</code></pre>",
-          "modules": [
-            {
-              "textRaw": "File access constants",
-              "name": "file_access_constants",
-              "desc": "<p>The following constants are meant for use with <a href=\"fs.html#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>F_OK</code></td>\n    <td>Flag indicating that the file is visible to the calling process.\n     This is useful for determining if a file exists, but says nothing\n     about <code>rwx</code> permissions. Default if no mode is specified.</td>\n  </tr>\n  <tr>\n    <td><code>R_OK</code></td>\n    <td>Flag indicating that the file can be read by the calling process.</td>\n  </tr>\n  <tr>\n    <td><code>W_OK</code></td>\n    <td>Flag indicating that the file can be written by the calling\n    process.</td>\n  </tr>\n  <tr>\n    <td><code>X_OK</code></td>\n    <td>Flag indicating that the file can be executed by the calling\n    process. This has no effect on Windows\n    (will behave like <code>fs.constants.F_OK</code>).</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File access constants"
-            },
-            {
-              "textRaw": "File copy constants",
-              "name": "file_copy_constants",
-              "desc": "<p>The following constants are meant for use with <a href=\"fs.html#fs_fs_copyfile_src_dest_flags_callback\"><code>fs.copyFile()</code></a>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_EXCL</code></td>\n    <td>If present, the copy operation will fail with an error if the\n    destination path already exists.</td>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_FICLONE</code></td>\n    <td>If present, the copy operation will attempt to create a\n    copy-on-write reflink. If the underlying platform does not support\n    copy-on-write, then a fallback copy mechanism is used.</td>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_FICLONE_FORCE</code></td>\n    <td>If present, the copy operation will attempt to create a\n    copy-on-write reflink. If the underlying platform does not support\n    copy-on-write, then the operation will fail with an error.</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File copy constants"
-            },
-            {
-              "textRaw": "File open constants",
-              "name": "file_open_constants",
-              "desc": "<p>The following constants are meant for use with <code>fs.open()</code>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>O_RDONLY</code></td>\n    <td>Flag indicating to open a file for read-only access.</td>\n  </tr>\n  <tr>\n    <td><code>O_WRONLY</code></td>\n    <td>Flag indicating to open a file for write-only access.</td>\n  </tr>\n  <tr>\n    <td><code>O_RDWR</code></td>\n    <td>Flag indicating to open a file for read-write access.</td>\n  </tr>\n  <tr>\n    <td><code>O_CREAT</code></td>\n    <td>Flag indicating to create the file if it does not already exist.</td>\n  </tr>\n  <tr>\n    <td><code>O_EXCL</code></td>\n    <td>Flag indicating that opening a file should fail if the\n    <code>O_CREAT</code> flag is set and the file already exists.</td>\n  </tr>\n  <tr>\n    <td><code>O_NOCTTY</code></td>\n    <td>Flag indicating that if path identifies a terminal device, opening the\n    path shall not cause that terminal to become the controlling terminal for\n    the process (if the process does not already have one).</td>\n  </tr>\n  <tr>\n    <td><code>O_TRUNC</code></td>\n    <td>Flag indicating that if the file exists and is a regular file, and the\n    file is opened successfully for write access, its length shall be truncated\n    to zero.</td>\n  </tr>\n  <tr>\n    <td><code>O_APPEND</code></td>\n    <td>Flag indicating that data will be appended to the end of the file.</td>\n  </tr>\n  <tr>\n    <td><code>O_DIRECTORY</code></td>\n    <td>Flag indicating that the open should fail if the path is not a\n    directory.</td>\n  </tr>\n  <tr>\n  <td><code>O_NOATIME</code></td>\n    <td>Flag indicating reading accesses to the file system will no longer\n    result in an update to the <code>atime</code> information associated with\n    the file. This flag is available on Linux operating systems only.</td>\n  </tr>\n  <tr>\n    <td><code>O_NOFOLLOW</code></td>\n    <td>Flag indicating that the open should fail if the path is a symbolic\n    link.</td>\n  </tr>\n  <tr>\n    <td><code>O_SYNC</code></td>\n    <td>Flag indicating that the file is opened for synchronized I/O with write\n    operations waiting for file integrity.</td>\n  </tr>\n  <tr>\n    <td><code>O_DSYNC</code></td>\n    <td>Flag indicating that the file is opened for synchronized I/O with write\n    operations waiting for data integrity.</td>\n  </tr>\n  <tr>\n    <td><code>O_SYMLINK</code></td>\n    <td>Flag indicating to open the symbolic link itself rather than the\n    resource it is pointing to.</td>\n  </tr>\n  <tr>\n    <td><code>O_DIRECT</code></td>\n    <td>When set, an attempt will be made to minimize caching effects of file\n    I/O.</td>\n  </tr>\n  <tr>\n    <td><code>O_NONBLOCK</code></td>\n    <td>Flag indicating to open the file in nonblocking mode when possible.</td>\n  </tr>\n  <tr>\n    <td><code>UV_FS_O_FILEMAP</code></td>\n    <td>When set, a memory file mapping is used to access the file. This flag\n    is available on Windows operating systems only. On other operating systems,\n    this flag is ignored.</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File open constants"
-            },
-            {
-              "textRaw": "File type constants",
-              "name": "file_type_constants",
-              "desc": "<p>The following constants are meant for use with the <a href=\"fs.html#fs_class_fs_stats\"><code>fs.Stats</code></a> object's\n<code>mode</code> property for determining a file's type.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>S_IFMT</code></td>\n    <td>Bit mask used to extract the file type code.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFREG</code></td>\n    <td>File type constant for a regular file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFDIR</code></td>\n    <td>File type constant for a directory.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFCHR</code></td>\n    <td>File type constant for a character-oriented device file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFBLK</code></td>\n    <td>File type constant for a block-oriented device file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFIFO</code></td>\n    <td>File type constant for a FIFO/pipe.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFLNK</code></td>\n    <td>File type constant for a symbolic link.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFSOCK</code></td>\n    <td>File type constant for a socket.</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File type constants"
-            },
-            {
-              "textRaw": "File mode constants",
-              "name": "file_mode_constants",
-              "desc": "<p>The following constants are meant for use with the <a href=\"fs.html#fs_class_fs_stats\"><code>fs.Stats</code></a> object's\n<code>mode</code> property for determining the access permissions for a file.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>S_IRWXU</code></td>\n    <td>File mode indicating readable, writable, and executable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRUSR</code></td>\n    <td>File mode indicating readable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWUSR</code></td>\n    <td>File mode indicating writable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXUSR</code></td>\n    <td>File mode indicating executable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRWXG</code></td>\n    <td>File mode indicating readable, writable, and executable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRGRP</code></td>\n    <td>File mode indicating readable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWGRP</code></td>\n    <td>File mode indicating writable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXGRP</code></td>\n    <td>File mode indicating executable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRWXO</code></td>\n    <td>File mode indicating readable, writable, and executable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IROTH</code></td>\n    <td>File mode indicating readable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWOTH</code></td>\n    <td>File mode indicating writable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXOTH</code></td>\n    <td>File mode indicating executable by others.</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File mode constants"
+              "desc": "<p>Asynchronously writes data to a file, replacing the file if it already exists.\n<code>data</code> can be a string, a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>, or, an object with an own (not inherited)\n<code>toString</code> function property.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"fs.html#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<p>Any specified <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> has to support writing.</p>\n<p>It is unsafe to use <code>fsPromises.writeFile()</code> multiple times on the same file\nwithout waiting for the promise to be settled.</p>\n<p>Similarly to <code>fsPromises.readFile</code> - <code>fsPromises.writeFile</code> is a convenience\nmethod that performs multiple <code>write</code> calls internally to write the buffer\npassed to it. For performance sensitive code consider using\n<a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>It is possible to use an <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> to cancel an <code>fsPromises.writeFile()</code>.\nCancelation is \"best effort\", and some amount of data is likely still\nto be written.</p>\n<pre><code class=\"language-mjs\">import { writeFile } from 'fs/promises';\n\ntry {\n  const controller = new AbortController();\n  const { signal } = controller;\n  const data = new Uint8Array(Buffer.from('Hello Node.js'));\n  const promise = writeFile('message.txt', data, { signal });\n\n  // Abort the request before the promise settles.\n  controller.abort();\n\n  await promise;\n} catch (err) {\n  // When a request is aborted - err is an AbortError\n  console.error(err);\n}\n</code></pre>\n<p>Aborting an ongoing request does not abort individual operating\nsystem requests but rather the internal buffering <code>fs.writeFile</code> performs.</p>"
             }
           ],
           "type": "module",
-          "displayName": "FS constants"
+          "displayName": "Promises API"
         },
         {
-          "textRaw": "File system flags",
-          "name": "file_system_flags",
-          "desc": "<p>The following flags are available wherever the <code>flag</code> option takes a\nstring.</p>\n<ul>\n<li>\n<p><code>'a'</code>: Open file for appending.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'ax'</code>: Like <code>'a'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'a+'</code>: Open file for reading and appending.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'ax+'</code>: Like <code>'a+'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'as'</code>: Open file for appending in synchronous mode.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'as+'</code>: Open file for reading and appending in synchronous mode.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'r'</code>: Open file for reading.\nAn exception occurs if the file does not exist.</p>\n</li>\n<li>\n<p><code>'r+'</code>: Open file for reading and writing.\nAn exception occurs if the file does not exist.</p>\n</li>\n<li>\n<p><code>'rs+'</code>: Open file for reading and writing in synchronous mode. Instructs\nthe operating system to bypass the local file system cache.</p>\n<p>This is primarily useful for opening files on NFS mounts as it allows\nskipping the potentially stale local cache. It has a very real impact on\nI/O performance so using this flag is not recommended unless it is needed.</p>\n<p>This doesn't turn <code>fs.open()</code> or <code>fsPromises.open()</code> into a synchronous\nblocking call. If synchronous operation is desired, something like\n<code>fs.openSync()</code> should be used.</p>\n</li>\n<li>\n<p><code>'w'</code>: Open file for writing.\nThe file is created (if it does not exist) or truncated (if it exists).</p>\n</li>\n<li>\n<p><code>'wx'</code>: Like <code>'w'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'w+'</code>: Open file for reading and writing.\nThe file is created (if it does not exist) or truncated (if it exists).</p>\n</li>\n<li>\n<p><code>'wx+'</code>: Like <code>'w+'</code> but fails if the path exists.</p>\n</li>\n</ul>\n<p><code>flag</code> can also be a number as documented by <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>; commonly used constants\nare available from <code>fs.constants</code>. On Windows, flags are translated to\ntheir equivalent ones where applicable, e.g. <code>O_WRONLY</code> to <code>FILE_GENERIC_WRITE</code>,\nor <code>O_EXCL|O_CREAT</code> to <code>CREATE_NEW</code>, as accepted by <code>CreateFileW</code>.</p>\n<p>The exclusive flag <code>'x'</code> (<code>O_EXCL</code> flag in <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>) causes the operation to\nreturn an error if the path already exists. On POSIX, if the path is a symbolic\nlink, using <code>O_EXCL</code> returns an error even if the link is to a path that does\nnot exist. The exclusive flag may or may not work with network file systems.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>\n<p>Modifying a file rather than replacing it may require a flags mode of <code>'r+'</code>\nrather than the default mode <code>'w'</code>.</p>\n<p>The behavior of some flags are platform-specific. As such, opening a directory\non macOS and Linux with the <code>'a+'</code> flag, as in the example below, will return an\nerror. In contrast, on Windows and FreeBSD, a file descriptor or a <code>FileHandle</code>\nwill be returned.</p>\n<pre><code class=\"language-js\">// macOS and Linux\nfs.open('&#x3C;directory>', 'a+', (err, fd) => {\n  // => [Error: EISDIR: illegal operation on a directory, open &#x3C;directory>]\n});\n\n// Windows and FreeBSD\nfs.open('&#x3C;directory>', 'a+', (err, fd) => {\n  // => null, &#x3C;fd>\n});\n</code></pre>\n<p>On Windows, opening an existing hidden file using the <code>'w'</code> flag (either\nthrough <code>fs.open()</code> or <code>fs.writeFile()</code> or <code>fsPromises.open()</code>) will fail with\n<code>EPERM</code>. Existing hidden files can be opened for writing with the <code>'r+'</code> flag.</p>\n<p>A call to <code>fs.ftruncate()</code> or <code>filehandle.truncate()</code> can be used to reset\nthe file contents.</p>",
-          "type": "module",
-          "displayName": "File system flags"
-        }
-      ],
-      "classes": [
-        {
-          "textRaw": "Class: `fs.Dir`",
-          "type": "class",
-          "name": "fs.Dir",
-          "meta": {
-            "added": [
-              "v12.12.0"
-            ],
-            "changes": []
-          },
-          "desc": "<p>A class representing a directory stream.</p>\n<p>Created by <a href=\"fs.html#fs_fs_opendir_path_options_callback\"><code>fs.opendir()</code></a>, <a href=\"fs.html#fs_fs_opendirsync_path_options\"><code>fs.opendirSync()</code></a>, or\n<a href=\"fs.html#fs_fspromises_opendir_path_options\"><code>fsPromises.opendir()</code></a>.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nasync function print(path) {\n  const dir = await fs.promises.opendir(path);\n  for await (const dirent of dir) {\n    console.log(dirent.name);\n  }\n}\nprint('./').catch(console.error);\n</code></pre>",
+          "textRaw": "Callback API",
+          "name": "callback_api",
+          "desc": "<p>The callback APIs perform all operations asynchronously, without blocking the\nevent loop, then invoke a callback function upon completion or error.</p>\n<p>The callback APIs use the underlying Node.js threadpool to perform file\nsystem operations off the event loop thread. These operations are not\nsynchronized or threadsafe. Care must be taken when performing multiple\nconcurrent modifications on the same file or data corruption may occur.</p>",
           "methods": [
             {
-              "textRaw": "`dir.close()`",
+              "textRaw": "`fs.access(path[, mode], callback)`",
               "type": "method",
-              "name": "close",
+              "name": "access",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.11.15"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v6.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/6534",
+                    "description": "The constants like `fs.R_OK`, etc which were present directly on `fs` were moved into `fs.constants` as a soft deprecation. Thus for Node.js `< v6.3.0` use `fs` to access those constants, or do something like `(fs.constants || fs).R_OK` to work with all versions."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {Promise}",
-                    "name": "return",
-                    "type": "Promise"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {integer} **Default:** `fs.constants.F_OK`",
+                      "name": "mode",
+                      "type": "integer",
+                      "default": "`fs.constants.F_OK`"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Asynchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>\n<p>A <code>Promise</code> is returned that will be resolved after the resource has been\nclosed.</p>"
+              "desc": "<p>Tests a user's permissions for the file or directory specified by <code>path</code>.\nThe <code>mode</code> argument is an optional integer that specifies the accessibility\nchecks to be performed. Check <a href=\"fs.html#fs_file_access_constants\">File access constants</a> for possible values\nof <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of\ntwo or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>The final argument, <code>callback</code>, is a callback function that is invoked with\na possible error argument. If any of the accessibility checks fail, the error\nargument will be an <code>Error</code> object. The following examples check if\n<code>package.json</code> exists, and if it is readable or writable.</p>\n<pre><code class=\"language-mjs\">import { access, constants } from 'fs';\n\nconst file = 'package.json';\n\n// Check if the file exists in the current directory.\naccess(file, constants.F_OK, (err) => {\n  console.log(`${file} ${err ? 'does not exist' : 'exists'}`);\n});\n\n// Check if the file is readable.\naccess(file, constants.R_OK, (err) => {\n  console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);\n});\n\n// Check if the file is writable.\naccess(file, constants.W_OK, (err) => {\n  console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);\n});\n\n// Check if the file exists in the current directory, and if it is writable.\naccess(file, constants.F_OK | constants.W_OK, (err) => {\n  if (err) {\n    console.error(\n      `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`);\n  } else {\n    console.log(`${file} exists, and it is writable`);\n  }\n});\n</code></pre>\n<p>Do not use <code>fs.access()</code> to check for the accessibility of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code>. Doing\nso introduces a race condition, since other processes may change the file's\nstate between the two calls. Instead, user code should open/read/write the\nfile directly and handle the error raised if the file is not accessible.</p>\n<p><strong>write (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { access, open, close } from 'fs';\n\naccess('myfile', (err) => {\n  if (!err) {\n    console.error('myfile already exists');\n    return;\n  }\n\n  open('myfile', 'wx', (err, fd) => {\n    if (err) throw err;\n\n    try {\n      writeMyData(fd);\n    } finally {\n      close(fd, (err) => {\n        if (err) throw err;\n      });\n    }\n  });\n});\n</code></pre>\n<p><strong>write (RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close } from 'fs';\n\nopen('myfile', 'wx', (err, fd) => {\n  if (err) {\n    if (err.code === 'EEXIST') {\n      console.error('myfile already exists');\n      return;\n    }\n\n    throw err;\n  }\n\n  try {\n    writeMyData(fd);\n  } finally {\n    close(fd, (err) => {\n      if (err) throw err;\n    });\n  }\n});\n</code></pre>\n<p><strong>read (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { access, open, close } from 'fs';\naccess('myfile', (err) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  open('myfile', 'r', (err, fd) => {\n    if (err) throw err;\n\n    try {\n      readMyData(fd);\n    } finally {\n      close(fd, (err) => {\n        if (err) throw err;\n      });\n    }\n  });\n});\n</code></pre>\n<p><strong>read (RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close } from 'fs';\n\nopen('myfile', 'r', (err, fd) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  try {\n    readMyData(fd);\n  } finally {\n    close(fd, (err) => {\n      if (err) throw err;\n    });\n  }\n});\n</code></pre>\n<p>The \"not recommended\" examples above check for accessibility and then use the\nfile; the \"recommended\" examples are better because they use the file directly\nand handle the error, if any.</p>\n<p>In general, check for the accessibility of a file only if the file will not be\nused directly, for example when its accessibility is a signal from another\nprocess.</p>\n<p>On Windows, access-control policies (ACLs) on a directory may limit access to\na file or directory. The <code>fs.access()</code> function, however, does not check the\nACL and therefore may report that a path is accessible even if the ACL restricts\nthe user from reading or writing to it.</p>"
             },
             {
-              "textRaw": "`dir.close(callback)`",
+              "textRaw": "`fs.appendFile(path, data[, options], callback)`",
               "type": "method",
-              "name": "close",
+              "name": "appendFile",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.6.7"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `file` parameter can be a file descriptor now."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL|number} filename or file descriptor",
+                      "name": "path",
+                      "type": "string|Buffer|URL|number",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`data` {string|Buffer}",
+                      "name": "data",
+                      "type": "string|Buffer"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'a'`",
+                          "desc": "See [support of file system `flags`][]."
+                        }
+                      ]
+                    },
                     {
                       "textRaw": "`callback` {Function}",
                       "name": "callback",
@@ -28139,61 +31117,168 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>\n<p>The <code>callback</code> will be called after the resource handle has been closed.</p>"
+              "desc": "<p>Asynchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"fs.html#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<pre><code class=\"language-mjs\">import { appendFile } from 'fs';\n\nappendFile('message.txt', 'data to append', (err) => {\n  if (err) throw err;\n  console.log('The \"data to append\" was appended to file!');\n});\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-mjs\">import { appendFile } from 'fs';\n\nappendFile('message.txt', 'data to append', 'utf8', callback);\n</code></pre>\n<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened\nfor appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will\nnot be closed automatically.</p>\n<pre><code class=\"language-mjs\">import { open, close, appendFile } from 'fs';\n\nfunction closeFd(fd) {\n  close(fd, (err) => {\n    if (err) throw err;\n  });\n}\n\nopen('message.txt', 'a', (err, fd) => {\n  if (err) throw err;\n\n  try {\n    appendFile(fd, 'data to append', 'utf8', (err) => {\n      closeFd(fd);\n      if (err) throw err;\n    });\n  } catch (err) {\n    closeFd(fd);\n    throw err;\n  }\n});\n</code></pre>"
             },
             {
-              "textRaw": "`dir.closeSync()`",
+              "textRaw": "`fs.chmod(path, mode, callback)`",
               "type": "method",
-              "name": "closeSync",
+              "name": "chmod",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.1.30"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer}",
+                      "name": "mode",
+                      "type": "string|integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Synchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>"
+              "desc": "<p>Asynchronously changes the permissions of a file. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a> documentation for more detail.</p>\n<pre><code class=\"language-mjs\">import { chmod } from 'fs';\n\nchmod('my_file.txt', 0o775, (err) => {\n  if (err) throw err;\n  console.log('The permissions for file \"my_file.txt\" have been changed!');\n});\n</code></pre>",
+              "modules": [
+                {
+                  "textRaw": "File modes",
+                  "name": "file_modes",
+                  "desc": "<p>The <code>mode</code> argument used in both the <code>fs.chmod()</code> and <code>fs.chmodSync()</code>\nmethods is a numeric bitmask created using a logical OR of the following\nconstants:</p>\n<table>\n<thead>\n<tr>\n<th>Constant</th>\n<th>Octal</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>fs.constants.S_IRUSR</code></td>\n<td><code>0o400</code></td>\n<td>read by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWUSR</code></td>\n<td><code>0o200</code></td>\n<td>write by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXUSR</code></td>\n<td><code>0o100</code></td>\n<td>execute/search by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IRGRP</code></td>\n<td><code>0o40</code></td>\n<td>read by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWGRP</code></td>\n<td><code>0o20</code></td>\n<td>write by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXGRP</code></td>\n<td><code>0o10</code></td>\n<td>execute/search by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IROTH</code></td>\n<td><code>0o4</code></td>\n<td>read by others</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWOTH</code></td>\n<td><code>0o2</code></td>\n<td>write by others</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXOTH</code></td>\n<td><code>0o1</code></td>\n<td>execute/search by others</td>\n</tr>\n</tbody>\n</table>\n<p>An easier method of constructing the <code>mode</code> is to use a sequence of three\noctal digits (e.g. <code>765</code>). The left-most digit (<code>7</code> in the example), specifies\nthe permissions for the file owner. The middle digit (<code>6</code> in the example),\nspecifies permissions for the group. The right-most digit (<code>5</code> in the example),\nspecifies the permissions for others.</p>\n<table>\n<thead>\n<tr>\n<th>Number</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>7</code></td>\n<td>read, write, and execute</td>\n</tr>\n<tr>\n<td><code>6</code></td>\n<td>read and write</td>\n</tr>\n<tr>\n<td><code>5</code></td>\n<td>read and execute</td>\n</tr>\n<tr>\n<td><code>4</code></td>\n<td>read only</td>\n</tr>\n<tr>\n<td><code>3</code></td>\n<td>write and execute</td>\n</tr>\n<tr>\n<td><code>2</code></td>\n<td>write only</td>\n</tr>\n<tr>\n<td><code>1</code></td>\n<td>execute only</td>\n</tr>\n<tr>\n<td><code>0</code></td>\n<td>no permission</td>\n</tr>\n</tbody>\n</table>\n<p>For example, the octal value <code>0o765</code> means:</p>\n<ul>\n<li>The owner may read, write and execute the file.</li>\n<li>The group may read and write the file.</li>\n<li>Others may read and execute the file.</li>\n</ul>\n<p>When using raw numbers where file modes are expected, any value larger than\n<code>0o777</code> may result in platform-specific behaviors that are not supported to work\nconsistently. Therefore constants like <code>S_ISVTX</code>, <code>S_ISGID</code> or <code>S_ISUID</code> are not\nexposed in <code>fs.constants</code>.</p>\n<p>Caveats: on Windows only the write permission can be changed, and the\ndistinction among the permissions of group, owner or others is not\nimplemented.</p>",
+                  "type": "module",
+                  "displayName": "File modes"
+                }
+              ]
             },
             {
-              "textRaw": "`dir.read()`",
+              "textRaw": "`fs.chown(path, uid, gid, callback)`",
               "type": "method",
-              "name": "read",
+              "name": "chown",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.1.97"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {Promise} containing {fs.Dirent|null}",
-                    "name": "return",
-                    "type": "Promise",
-                    "desc": "containing {fs.Dirent|null}"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`uid` {integer}",
+                      "name": "uid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`gid` {integer}",
+                      "name": "gid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Asynchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a>.</p>\n<p>After the read is completed, a <code>Promise</code> is returned that will be resolved with\nan <a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a>, or <code>null</code> if there are no more directory entries to read.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory may or may not be\nincluded in the iteration results.</p>"
+              "desc": "<p>Asynchronously changes owner and group of a file. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`dir.read(callback)`",
+              "textRaw": "`fs.close(fd[, callback])`",
               "type": "method",
-              "name": "read",
+              "name": "close",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37174",
+                    "description": "A default callback is now used if one is not provided."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
                     {
                       "textRaw": "`callback` {Function}",
                       "name": "callback",
@@ -28203,6185 +31288,7226 @@
                           "textRaw": "`err` {Error}",
                           "name": "err",
                           "type": "Error"
-                        },
-                        {
-                          "textRaw": "`dirent` {fs.Dirent|null}",
-                          "name": "dirent",
-                          "type": "fs.Dirent|null"
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a>.</p>\n<p>After the read is completed, the <code>callback</code> will be called with an\n<a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a>, or <code>null</code> if there are no more directory entries to read.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory may or may not be\nincluded in the iteration results.</p>"
+              "desc": "<p>Closes the file descriptor. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>Calling <code>fs.close()</code> on any file descriptor (<code>fd</code>) that is currently in use\nthrough any other <code>fs</code> operation may lead to undefined behavior.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/close.2.html\"><code>close(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`dir.readSync()`",
+              "textRaw": "`fs.copyFile(src, dest[, mode], callback)`",
               "type": "method",
-              "name": "readSync",
+              "name": "copyFile",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v8.5.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27044",
+                    "description": "Changed 'flags' argument to 'mode' and imposed stricter type validation."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {fs.Dirent|null}",
-                    "name": "return",
-                    "type": "fs.Dirent|null"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`src` {string|Buffer|URL} source filename to copy",
+                      "name": "src",
+                      "type": "string|Buffer|URL",
+                      "desc": "source filename to copy"
+                    },
+                    {
+                      "textRaw": "`dest` {string|Buffer|URL} destination filename of the copy operation",
+                      "name": "dest",
+                      "type": "string|Buffer|URL",
+                      "desc": "destination filename of the copy operation"
+                    },
+                    {
+                      "textRaw": "`mode` {integer} modifiers for copy operation. **Default:** `0`.",
+                      "name": "mode",
+                      "type": "integer",
+                      "default": "`0`",
+                      "desc": "modifiers for copy operation."
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function"
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Synchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a>.</p>\n<p>If there are no more directory entries to read, <code>null</code> will be returned.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory may or may not be\nincluded in the iteration results.</p>"
+              "desc": "<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. No arguments other than a possible exception are given to the\ncallback function. Node.js makes no guarantees about the atomicity of the copy\noperation. If an error occurs after the destination file has been opened for\nwriting, Node.js will attempt to remove the destination.</p>\n<p><code>mode</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support\ncopy-on-write, then the operation will fail.</li>\n</ul>\n<pre><code class=\"language-mjs\">import { copyFile, constants } from 'fs';\n\nfunction callback(err) {\n  if (err) throw err;\n  console.log('source.txt was copied to destination.txt');\n}\n\n// destination.txt will be created or overwritten by default.\ncopyFile('source.txt', 'destination.txt', callback);\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\ncopyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL, callback);\n</code></pre>"
             },
             {
-              "textRaw": "`dir[Symbol.asyncIterator]()`",
+              "textRaw": "`fs.createReadStream(path[, options])`",
               "type": "method",
-              "name": "[Symbol.asyncIterator]",
+              "name": "createReadStream",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31408",
+                    "description": "Change `emitClose` default to `true`."
+                  },
+                  {
+                    "version": [
+                      "v13.6.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29083",
+                    "description": "The `fs` options allow overriding the used `fs` implementation."
+                  },
+                  {
+                    "version": "v12.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29212",
+                    "description": "Enable `emitClose` option."
+                  },
+                  {
+                    "version": "v11.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/19898",
+                    "description": "Impose new restrictions on `start` and `end`, throwing more appropriate errors in cases when we cannot reasonably handle the input values."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  },
+                  {
+                    "version": "v2.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/1845",
+                    "description": "The passed `options` object can be a string now."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {AsyncIterator} of {fs.Dirent}",
+                    "textRaw": "Returns: {fs.ReadStream} See [Readable Stream][].",
                     "name": "return",
-                    "type": "AsyncIterator",
-                    "desc": "of {fs.Dirent}"
+                    "type": "fs.ReadStream",
+                    "desc": "See [Readable Stream][]."
                   },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`flags` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
+                          "name": "flags",
+                          "type": "string",
+                          "default": "`'r'`",
+                          "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `null`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`fd` {integer} **Default:** `null`",
+                          "name": "fd",
+                          "type": "integer",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`autoClose` {boolean} **Default:** `true`",
+                          "name": "autoClose",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`emitClose` {boolean} **Default:** `true`",
+                          "name": "emitClose",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`start` {integer}",
+                          "name": "start",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`end` {integer} **Default:** `Infinity`",
+                          "name": "end",
+                          "type": "integer",
+                          "default": "`Infinity`"
+                        },
+                        {
+                          "textRaw": "`highWaterMark` {integer} **Default:** `64 * 1024`",
+                          "name": "highWaterMark",
+                          "type": "integer",
+                          "default": "`64 * 1024`"
+                        },
+                        {
+                          "textRaw": "`fs` {Object|null} **Default:** `null`",
+                          "name": "fs",
+                          "type": "Object|null",
+                          "default": "`null`"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Asynchronously iterates over the directory via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> until all entries have\nbeen read.</p>\n<p>Entries returned by the async iterator are always an <a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a>.\nThe <code>null</code> case from <code>dir.read()</code> is handled internally.</p>\n<p>See <a href=\"fs.html#fs_class_fs_dir\"><code>fs.Dir</code></a> for an example.</p>\n<p>Directory entries returned by this iterator are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory may or may not be\nincluded in the iteration results.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`path` {string}",
-              "type": "string",
-              "name": "path",
-              "meta": {
-                "added": [
-                  "v12.12.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The read-only path of this directory as was provided to <a href=\"fs.html#fs_fs_opendir_path_options_callback\"><code>fs.opendir()</code></a>,\n<a href=\"fs.html#fs_fs_opendirsync_path_options\"><code>fs.opendirSync()</code></a>, or <a href=\"fs.html#fs_fspromises_opendir_path_options\"><code>fsPromises.opendir()</code></a>.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.Dirent`",
-          "type": "class",
-          "name": "fs.Dirent",
-          "meta": {
-            "added": [
-              "v10.10.0"
-            ],
-            "changes": []
-          },
-          "desc": "<p>A representation of a directory entry, which can be a file or a subdirectory\nwithin the directory, as returned by reading from an <a href=\"fs.html#fs_class_fs_dir\"><code>fs.Dir</code></a>. The\ndirectory entry is a combination of the file name and file type pairs.</p>\n<p>Additionally, when <a href=\"fs.html#fs_fs_readdir_path_options_callback\"><code>fs.readdir()</code></a> or <a href=\"fs.html#fs_fs_readdirsync_path_options\"><code>fs.readdirSync()</code></a> is called with\nthe <code>withFileTypes</code> option set to <code>true</code>, the resulting array is filled with\n<code>fs.Dirent</code> objects, rather than strings or <code>Buffers</code>.</p>",
-          "methods": [
+              "desc": "<p>Unlike the 16 kb default <code>highWaterMark</code> for a readable stream, the stream\nreturned by this method has a default <code>highWaterMark</code> of 64 kb.</p>\n<p><code>options</code> can include <code>start</code> and <code>end</code> values to read a range of bytes from\nthe file instead of the entire file. Both <code>start</code> and <code>end</code> are inclusive and\nstart counting at 0, allowed values are in the\n[0, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\"><code>Number.MAX_SAFE_INTEGER</code></a>] range. If <code>fd</code> is specified and <code>start</code> is\nomitted or <code>undefined</code>, <code>fs.createReadStream()</code> reads sequentially from the\ncurrent file position. The <code>encoding</code> can be any one of those accepted by\n<a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>If <code>fd</code> is specified, <code>ReadStream</code> will ignore the <code>path</code> argument and will use\nthe specified file descriptor. This means that no <code>'open'</code> event will be\nemitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s should be passed to\n<a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>If <code>fd</code> points to a character device that only supports blocking reads\n(such as keyboard or sound card), read operations do not finish until data is\navailable. This can prevent the process from exiting and the stream from\nclosing naturally.</p>\n<p>By default, the stream will emit a <code>'close'</code> event after it has been\ndestroyed, like most <code>Readable</code> streams.  Set the <code>emitClose</code> option to\n<code>false</code> to change this behavior.</p>\n<p>By providing the <code>fs</code> option, it is possible to override the corresponding <code>fs</code>\nimplementations for <code>open</code>, <code>read</code>, and <code>close</code>. When providing the <code>fs</code> option,\noverrides for <code>open</code>, <code>read</code>, and <code>close</code> are required.</p>\n<pre><code class=\"language-mjs\">import { createReadStream } from 'fs';\n\n// Create a stream from some character device.\nconst stream = createReadStream('/dev/input/event0');\nsetTimeout(() => {\n  stream.close(); // This may not close the stream.\n  // Artificially marking end-of-stream, as if the underlying resource had\n  // indicated end-of-file by itself, allows the stream to close.\n  // This does not cancel pending read operations, and if there is such an\n  // operation, the process may still not be able to exit successfully\n  // until it finishes.\n  stream.push(null);\n  stream.read(0);\n}, 100);\n</code></pre>\n<p>If <code>autoClose</code> is false, then the file descriptor won't be closed, even if\nthere's an error. It is the application's responsibility to close it and make\nsure there's no file descriptor leak. If <code>autoClose</code> is set to true (default\nbehavior), on <code>'error'</code> or <code>'end'</code> the file descriptor will be closed\nautomatically.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the\nfile was created.</p>\n<p>An example to read the last 10 bytes of a file which is 100 bytes long:</p>\n<pre><code class=\"language-mjs\">import { createReadStream } from 'fs';\n\ncreateReadStream('sample.txt', { start: 90, end: 99 });\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>"
+            },
             {
-              "textRaw": "`dirent.isBlockDevice()`",
+              "textRaw": "`fs.createWriteStream(path[, options])`",
               "type": "method",
-              "name": "isBlockDevice",
+              "name": "createWriteStream",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31408",
+                    "description": "Change `emitClose` default to `true`."
+                  },
+                  {
+                    "version": [
+                      "v13.6.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29083",
+                    "description": "The `fs` options allow overriding the used `fs` implementation."
+                  },
+                  {
+                    "version": "v12.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29212",
+                    "description": "Enable `emitClose` option."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  },
+                  {
+                    "version": "v5.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3679",
+                    "description": "The `autoClose` option is supported now."
+                  },
+                  {
+                    "version": "v2.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/1845",
+                    "description": "The passed `options` object can be a string now."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {boolean}",
+                    "textRaw": "Returns: {fs.WriteStream} See [Writable Stream][].",
                     "name": "return",
-                    "type": "boolean"
+                    "type": "fs.WriteStream",
+                    "desc": "See [Writable Stream][]."
                   },
-                  "params": []
-                }
-              ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a block device.</p>"
-            },
-            {
-              "textRaw": "`dirent.isCharacterDevice()`",
-              "type": "method",
-              "name": "isCharacterDevice",
-              "meta": {
-                "added": [
-                  "v10.10.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`flags` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
+                          "name": "flags",
+                          "type": "string",
+                          "default": "`'w'`",
+                          "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`fd` {integer} **Default:** `null`",
+                          "name": "fd",
+                          "type": "integer",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`autoClose` {boolean} **Default:** `true`",
+                          "name": "autoClose",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`emitClose` {boolean} **Default:** `true`",
+                          "name": "emitClose",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`start` {integer}",
+                          "name": "start",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`fs` {Object|null} **Default:** `null`",
+                          "name": "fs",
+                          "type": "Object|null",
+                          "default": "`null`"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a character device.</p>"
+              "desc": "<p><code>options</code> may also include a <code>start</code> option to allow writing data at some\nposition past the beginning of the file, allowed values are in the\n[0, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\"><code>Number.MAX_SAFE_INTEGER</code></a>] range. Modifying a file rather than replacing\nit may require the <code>flags</code> option to be set to <code>r+</code> rather than the default <code>w</code>.\nThe <code>encoding</code> can be any one of those accepted by <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>If <code>autoClose</code> is set to true (default behavior) on <code>'error'</code> or <code>'finish'</code>\nthe file descriptor will be closed automatically. If <code>autoClose</code> is false,\nthen the file descriptor won't be closed, even if there's an error.\nIt is the application's responsibility to close it and make sure there's no\nfile descriptor leak.</p>\n<p>By default, the stream will emit a <code>'close'</code> event after it has been\ndestroyed, like most <code>Writable</code> streams.  Set the <code>emitClose</code> option to\n<code>false</code> to change this behavior.</p>\n<p>By providing the <code>fs</code> option it is possible to override the corresponding <code>fs</code>\nimplementations for <code>open</code>, <code>write</code>, <code>writev</code> and <code>close</code>. Overriding <code>write()</code>\nwithout <code>writev()</code> can reduce performance as some optimizations (<code>_writev()</code>)\nwill be disabled. When providing the <code>fs</code> option,  overrides for <code>open</code>,\n<code>close</code>, and at least one of <code>write</code> and <code>writev</code> are required.</p>\n<p>Like <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a>, if <code>fd</code> is specified, <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a> will ignore the\n<code>path</code> argument and will use the specified file descriptor. This means that no\n<code>'open'</code> event will be emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s\nshould be passed to <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>"
             },
             {
-              "textRaw": "`dirent.isDirectory()`",
+              "textRaw": "`fs.exists(path, callback)`",
               "type": "method",
-              "name": "isDirectory",
+              "name": "exists",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "deprecated": [
+                  "v1.0.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use [`fs.stat()`][] or [`fs.access()`][] instead.",
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`exists` {boolean}",
+                          "name": "exists",
+                          "type": "boolean"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a file system\ndirectory.</p>"
+              "desc": "<p>Test whether or not the given path exists by checking with the file system.\nThen call the <code>callback</code> argument with either true or false:</p>\n<pre><code class=\"language-mjs\">import { exists } from 'fs';\n\nexists('/etc/passwd', (e) => {\n  console.log(e ? 'it exists' : 'no passwd!');\n});\n</code></pre>\n<p><strong>The parameters for this callback are not consistent with other Node.js\ncallbacks.</strong> Normally, the first parameter to a Node.js callback is an <code>err</code>\nparameter, optionally followed by other parameters. The <code>fs.exists()</code> callback\nhas only one boolean parameter. This is one reason <code>fs.access()</code> is recommended\ninstead of <code>fs.exists()</code>.</p>\n<p>Using <code>fs.exists()</code> to check for the existence of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended. Doing\nso introduces a race condition, since other processes may change the file's\nstate between the two calls. Instead, user code should open/read/write the\nfile directly and handle the error raised if the file does not exist.</p>\n<p><strong>write (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { exists, open, close } from 'fs';\n\nexists('myfile', (e) => {\n  if (e) {\n    console.error('myfile already exists');\n  } else {\n    open('myfile', 'wx', (err, fd) => {\n      if (err) throw err;\n\n      try {\n        writeMyData(fd);\n      } finally {\n        close(fd, (err) => {\n          if (err) throw err;\n        });\n      }\n    });\n  }\n});\n</code></pre>\n<p><strong>write (RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close } from 'fs';\nopen('myfile', 'wx', (err, fd) => {\n  if (err) {\n    if (err.code === 'EEXIST') {\n      console.error('myfile already exists');\n      return;\n    }\n\n    throw err;\n  }\n\n  try {\n    writeMyData(fd);\n  } finally {\n    close(fd, (err) => {\n      if (err) throw err;\n    });\n  }\n});\n</code></pre>\n<p><strong>read (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close, exists } from 'fs';\n\nexists('myfile', (e) => {\n  if (e) {\n    open('myfile', 'r', (err, fd) => {\n      if (err) throw err;\n\n      try {\n        readMyData(fd);\n      } finally {\n        close(fd, (err) => {\n          if (err) throw err;\n        });\n      }\n    });\n  } else {\n    console.error('myfile does not exist');\n  }\n});\n</code></pre>\n<p><strong>read (RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close } from 'fs';\n\nopen('myfile', 'r', (err, fd) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  try {\n    readMyData(fd);\n  } finally {\n    close(fd, (err) => {\n      if (err) throw err;\n    });\n  }\n});\n</code></pre>\n<p>The \"not recommended\" examples above check for existence and then use the\nfile; the \"recommended\" examples are better because they use the file directly\nand handle the error, if any.</p>\n<p>In general, check for the existence of a file only if the file won’t be\nused directly, for example when its existence is a signal from another\nprocess.</p>"
             },
             {
-              "textRaw": "`dirent.isFIFO()`",
+              "textRaw": "`fs.fchmod(fd, mode, callback)`",
               "type": "method",
-              "name": "isFIFO",
+              "name": "fchmod",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.4.7"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer}",
+                      "name": "mode",
+                      "type": "string|integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a first-in-first-out\n(FIFO) pipe.</p>"
+              "desc": "<p>Sets the permissions on the file. No arguments other than a possible exception\nare given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fchmod.2.html\"><code>fchmod(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`dirent.isFile()`",
+              "textRaw": "`fs.fchown(fd, uid, gid, callback)`",
               "type": "method",
-              "name": "isFile",
+              "name": "fchown",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.4.7"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`uid` {integer}",
+                      "name": "uid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`gid` {integer}",
+                      "name": "gid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a regular file.</p>"
+              "desc": "<p>Sets the owner of the file. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fchown.2.html\"><code>fchown(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`dirent.isSocket()`",
+              "textRaw": "`fs.fdatasync(fd, callback)`",
               "type": "method",
-              "name": "isSocket",
+              "name": "fdatasync",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.1.96"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a socket.</p>"
+              "desc": "<p>Forces all currently queued I/O operations associated with the file to the\noperating system's synchronized I/O completion state. Refer to the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a> documentation for details. No arguments other than a possible\nexception are given to the completion callback.</p>"
             },
             {
-              "textRaw": "`dirent.isSymbolicLink()`",
+              "textRaw": "`fs.fstat(fd[, options], callback)`",
               "type": "method",
-              "name": "isSymbolicLink",
+              "name": "fstat",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.1.95"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`stats` {fs.Stats}",
+                          "name": "stats",
+                          "type": "fs.Stats"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a symbolic link.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`name` {string|Buffer}",
-              "type": "string|Buffer",
-              "name": "name",
-              "meta": {
-                "added": [
-                  "v10.10.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The file name that this <code>fs.Dirent</code> object refers to. The type of this\nvalue is determined by the <code>options.encoding</code> passed to <a href=\"fs.html#fs_fs_readdir_path_options_callback\"><code>fs.readdir()</code></a> or\n<a href=\"fs.html#fs_fs_readdirsync_path_options\"><code>fs.readdirSync()</code></a>.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.FSWatcher`",
-          "type": "class",
-          "name": "fs.FSWatcher",
-          "meta": {
-            "added": [
-              "v0.5.8"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>A successful call to <a href=\"fs.html#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> method will return a new <code>fs.FSWatcher</code>\nobject.</p>\n<p>All <code>fs.FSWatcher</code> objects emit a <code>'change'</code> event whenever a specific watched\nfile is modified.</p>",
-          "events": [
+              "desc": "<p>Invokes the callback with the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the file descriptor.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fstat.2.html\"><code>fstat(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "textRaw": "Event: `'change'`",
-              "type": "event",
-              "name": "change",
+              "textRaw": "`fs.fsync(fd, callback)`",
+              "type": "method",
+              "name": "fsync",
               "meta": {
                 "added": [
-                  "v0.5.8"
+                  "v0.1.96"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`eventType` {string} The type of change event that has occurred",
-                  "name": "eventType",
-                  "type": "string",
-                  "desc": "The type of change event that has occurred"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`filename` {string|Buffer} The filename that changed (if relevant/available)",
-                  "name": "filename",
-                  "type": "string|Buffer",
-                  "desc": "The filename that changed (if relevant/available)"
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted when something changes in a watched directory or file.\nSee more details in <a href=\"fs.html#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a>.</p>\n<p>The <code>filename</code> argument may not be provided depending on operating system\nsupport. If <code>filename</code> is provided, it will be provided as a <code>Buffer</code> if\n<code>fs.watch()</code> is called with its <code>encoding</code> option set to <code>'buffer'</code>, otherwise\n<code>filename</code> will be a UTF-8 string.</p>\n<pre><code class=\"language-js\">// Example when handled through fs.watch() listener\nfs.watch('./tmp', { encoding: 'buffer' }, (eventType, filename) => {\n  if (filename) {\n    console.log(filename);\n    // Prints: &#x3C;Buffer ...>\n  }\n});\n</code></pre>"
-            },
-            {
-              "textRaw": "Event: `'close'`",
-              "type": "event",
-              "name": "close",
-              "meta": {
-                "added": [
-                  "v10.0.0"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Emitted when the watcher stops watching for changes. The closed\n<code>fs.FSWatcher</code> object is no longer usable in the event handler.</p>"
+              "desc": "<p>Request that all data for the open file descriptor is flushed to the storage\ndevice. The specific implementation is operating system and device specific.\nRefer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a> documentation for more detail. No arguments other\nthan a possible exception are given to the completion callback.</p>"
             },
             {
-              "textRaw": "Event: `'error'`",
-              "type": "event",
-              "name": "error",
+              "textRaw": "`fs.ftruncate(fd[, len], callback)`",
+              "type": "method",
+              "name": "ftruncate",
               "meta": {
                 "added": [
-                  "v0.5.8"
+                  "v0.8.6"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "params": [
+              "signatures": [
                 {
-                  "textRaw": "`error` {Error}",
-                  "name": "error",
-                  "type": "Error"
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`len` {integer} **Default:** `0`",
+                      "name": "len",
+                      "type": "integer",
+                      "default": "`0`"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted when an error occurs while watching the file. The errored\n<code>fs.FSWatcher</code> object is no longer usable in the event handler.</p>"
-            }
-          ],
-          "methods": [
+              "desc": "<p>Truncates the file descriptor. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/ftruncate.2.html\"><code>ftruncate(2)</code></a> documentation for more detail.</p>\n<p>If the file referred to by the file descriptor was larger than <code>len</code> bytes, only\nthe first <code>len</code> bytes will be retained in the file.</p>\n<p>For example, the following program retains only the first four bytes of the\nfile:</p>\n<pre><code class=\"language-mjs\">import { open, close, ftruncate } from 'fs';\n\nfunction closeFd(fd) {\n  close(fd, (err) => {\n    if (err) throw err;\n  });\n}\n\nopen('temp.txt', 'r+', (err, fd) => {\n  if (err) throw err;\n\n  try {\n    ftruncate(fd, 4, (err) => {\n      closeFd(fd);\n      if (err) throw err;\n    });\n  } catch (err) {\n    closeFd(fd);\n    if (err) throw err;\n  }\n});\n</code></pre>\n<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the\nextended part is filled with null bytes (<code>'\\0'</code>):</p>\n<p>If <code>len</code> is negative then <code>0</code> will be used.</p>"
+            },
             {
-              "textRaw": "`watcher.close()`",
+              "textRaw": "`fs.futimes(fd, atime, mtime, callback)`",
               "type": "method",
-              "name": "close",
+              "name": "futimes",
               "meta": {
                 "added": [
-                  "v0.5.8"
+                  "v0.4.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v4.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/2387",
+                    "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Stop watching for changes on the given <code>fs.FSWatcher</code>. Once stopped, the\n<code>fs.FSWatcher</code> object is no longer usable.</p>"
+              "desc": "<p>Change the file system timestamps of the object referenced by the supplied file\ndescriptor. See <a href=\"fs.html#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>.</p>\n<p>This function does not work on AIX versions before 7.1, it will return the\nerror <code>UV_ENOSYS</code>.</p>"
             },
             {
-              "textRaw": "`watcher.ref()`",
+              "textRaw": "`fs.lchmod(path, mode, callback)`",
               "type": "method",
-              "name": "ref",
+              "name": "lchmod",
               "meta": {
-                "added": [
-                  "v12.20.0"
+                "deprecated": [
+                  "v0.4.7"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {fs.FSWatcher}",
-                    "name": "return",
-                    "type": "fs.FSWatcher"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {integer}",
+                      "name": "mode",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the\n<code>FSWatcher</code> is active. Calling <code>watcher.ref()</code> multiple times will have\nno effect.</p>\n<p>By default, all <code>FSWatcher</code> objects are \"ref'ed\", making it normally\nunnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been\ncalled previously.</p>"
+              "desc": "<p>Changes the permissions on a symbolic link. No arguments other than a possible\nexception are given to the completion callback.</p>\n<p>This method is only implemented on macOS.</p>\n<p>See the POSIX <a href=\"https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2\"><code>lchmod(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`watcher.unref()`",
+              "textRaw": "`fs.lchown(path, uid, gid, callback)`",
               "type": "method",
-              "name": "unref",
+              "name": "lchown",
               "meta": {
-                "added": [
-                  "v12.20.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {fs.FSWatcher}",
-                    "name": "return",
-                    "type": "fs.FSWatcher"
+                "changes": [
+                  {
+                    "version": "v10.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/21498",
+                    "description": "This API is no longer deprecated."
                   },
-                  "params": []
-                }
-              ],
-              "desc": "<p>When called, the active <code>FSWatcher</code> object will not require the Node.js\nevent loop to remain active. If there is no other activity keeping the\nevent loop running, the process may exit before the <code>FSWatcher</code> object's\ncallback is invoked. Calling <code>watcher.unref()</code> multiple times will have\nno effect.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.StatWatcher`",
-          "type": "class",
-          "name": "fs.StatWatcher",
-          "meta": {
-            "added": [
-              "v12.20.0"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>A successful call to <code>fs.watchFile()</code> method will return a new <code>fs.StatWatcher</code>\nobject.</p>",
-          "methods": [
-            {
-              "textRaw": "`watcher.ref()`",
-              "type": "method",
-              "name": "ref",
-              "meta": {
-                "added": [
-                  "v12.20.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {fs.StatWatcher}",
-                    "name": "return",
-                    "type": "fs.StatWatcher"
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
                   },
-                  "params": []
-                }
-              ],
-              "desc": "<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the\n<code>StatWatcher</code> is active. Calling <code>watcher.ref()</code> multiple times will have\nno effect.</p>\n<p>By default, all <code>StatWatcher</code> objects are \"ref'ed\", making it normally\nunnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been\ncalled previously.</p>"
-            },
-            {
-              "textRaw": "`watcher.unref()`",
-              "type": "method",
-              "name": "unref",
-              "meta": {
-                "added": [
-                  "v12.20.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {fs.StatWatcher}",
-                    "name": "return",
-                    "type": "fs.StatWatcher"
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
                   },
-                  "params": []
-                }
-              ],
-              "desc": "<p>When called, the active <code>StatWatcher</code> object will not require the Node.js\nevent loop to remain active. If there is no other activity keeping the\nevent loop running, the process may exit before the <code>StatWatcher</code> object's\ncallback is invoked. Calling <code>watcher.unref()</code> multiple times will have\nno effect.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.ReadStream`",
-          "type": "class",
-          "name": "fs.ReadStream",
-          "meta": {
-            "added": [
-              "v0.1.93"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_readable\" class=\"type\">&lt;stream.Readable&gt;</a></li>\n</ul>\n<p>Instances of <code>fs.ReadStream</code> are created and returned using the\n<a href=\"fs.html#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a> function.</p>",
-          "events": [
-            {
-              "textRaw": "Event: `'close'`",
-              "type": "event",
-              "name": "close",
-              "meta": {
-                "added": [
-                  "v0.1.93"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Emitted when the <code>fs.ReadStream</code>'s underlying file descriptor has been closed.</p>"
-            },
-            {
-              "textRaw": "Event: `'open'`",
-              "type": "event",
-              "name": "open",
-              "meta": {
-                "added": [
-                  "v0.1.93"
-                ],
-                "changes": []
+                  {
+                    "version": "v0.4.7",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
               },
-              "params": [
+              "signatures": [
                 {
-                  "textRaw": "`fd` {integer} Integer file descriptor used by the `ReadStream`.",
-                  "name": "fd",
-                  "type": "integer",
-                  "desc": "Integer file descriptor used by the `ReadStream`."
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`uid` {integer}",
+                      "name": "uid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`gid` {integer}",
+                      "name": "gid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted when the <code>fs.ReadStream</code>'s file descriptor has been opened.</p>"
-            },
-            {
-              "textRaw": "Event: `'ready'`",
-              "type": "event",
-              "name": "ready",
-              "meta": {
-                "added": [
-                  "v9.11.0"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Emitted when the <code>fs.ReadStream</code> is ready to be used.</p>\n<p>Fires immediately after <code>'open'</code>.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`bytesRead` {number}",
-              "type": "number",
-              "name": "bytesRead",
-              "meta": {
-                "added": [
-                  "v6.4.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The number of bytes that have been read so far.</p>"
-            },
-            {
-              "textRaw": "`path` {string|Buffer}",
-              "type": "string|Buffer",
-              "name": "path",
-              "meta": {
-                "added": [
-                  "v0.1.93"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The path to the file the stream is reading from as specified in the first\nargument to <code>fs.createReadStream()</code>. If <code>path</code> is passed as a string, then\n<code>readStream.path</code> will be a string. If <code>path</code> is passed as a <code>Buffer</code>, then\n<code>readStream.path</code> will be a <code>Buffer</code>.</p>"
+              "desc": "<p>Set the owner of the symbolic link. No arguments other than a possible\nexception are given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lchown.2.html\"><code>lchown(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`pending` {boolean}",
-              "type": "boolean",
-              "name": "pending",
-              "meta": {
-                "added": [
-                  "v11.2.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>This property is <code>true</code> if the underlying file has not been opened yet,\ni.e. before the <code>'ready'</code> event is emitted.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.Stats`",
-          "type": "class",
-          "name": "fs.Stats",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v8.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/13173",
-                "description": "Added times as numbers."
-              }
-            ]
-          },
-          "desc": "<p>A <code>fs.Stats</code> object provides information about a file.</p>\n<p>Objects returned from <a href=\"fs.html#fs_fs_stat_path_options_callback\"><code>fs.stat()</code></a>, <a href=\"fs.html#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a> and <a href=\"fs.html#fs_fs_fstat_fd_options_callback\"><code>fs.fstat()</code></a> and\ntheir synchronous counterparts are of this type.\nIf <code>bigint</code> in the <code>options</code> passed to those methods is true, the numeric values\nwill be <code>bigint</code> instead of <code>number</code>, and the object will contain additional\nnanosecond-precision properties suffixed with <code>Ns</code>.</p>\n<pre><code class=\"language-console\">Stats {\n  dev: 2114,\n  ino: 48064969,\n  mode: 33188,\n  nlink: 1,\n  uid: 85,\n  gid: 100,\n  rdev: 0,\n  size: 527,\n  blksize: 4096,\n  blocks: 8,\n  atimeMs: 1318289051000.1,\n  mtimeMs: 1318289051000.1,\n  ctimeMs: 1318289051000.1,\n  birthtimeMs: 1318289051000.1,\n  atime: Mon, 10 Oct 2011 23:24:11 GMT,\n  mtime: Mon, 10 Oct 2011 23:24:11 GMT,\n  ctime: Mon, 10 Oct 2011 23:24:11 GMT,\n  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }\n</code></pre>\n<p><code>bigint</code> version:</p>\n<pre><code class=\"language-console\">BigIntStats {\n  dev: 2114n,\n  ino: 48064969n,\n  mode: 33188n,\n  nlink: 1n,\n  uid: 85n,\n  gid: 100n,\n  rdev: 0n,\n  size: 527n,\n  blksize: 4096n,\n  blocks: 8n,\n  atimeMs: 1318289051000n,\n  mtimeMs: 1318289051000n,\n  ctimeMs: 1318289051000n,\n  birthtimeMs: 1318289051000n,\n  atimeNs: 1318289051000000000n,\n  mtimeNs: 1318289051000000000n,\n  ctimeNs: 1318289051000000000n,\n  birthtimeNs: 1318289051000000000n,\n  atime: Mon, 10 Oct 2011 23:24:11 GMT,\n  mtime: Mon, 10 Oct 2011 23:24:11 GMT,\n  ctime: Mon, 10 Oct 2011 23:24:11 GMT,\n  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }\n</code></pre>",
-          "methods": [
-            {
-              "textRaw": "`stats.isBlockDevice()`",
+              "textRaw": "`fs.lutimes(path, atime, mtime, callback)`",
               "type": "method",
-              "name": "isBlockDevice",
+              "name": "lutimes",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v14.5.0",
+                  "v12.19.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a block device.</p>"
+              "desc": "<p>Changes the access and modification times of a file in the same way as\n<a href=\"fs.html#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>, with the difference that if the path refers to a symbolic\nlink, then the link is not dereferenced: instead, the timestamps of the\nsymbolic link itself are changed.</p>\n<p>No arguments other than a possible exception are given to the completion\ncallback.</p>"
             },
             {
-              "textRaw": "`stats.isCharacterDevice()`",
+              "textRaw": "`fs.link(existingPath, newPath, callback)`",
               "type": "method",
-              "name": "isCharacterDevice",
+              "name": "link",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `existingPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`existingPath` {string|Buffer|URL}",
+                      "name": "existingPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`newPath` {string|Buffer|URL}",
+                      "name": "newPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a character device.</p>"
+              "desc": "<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a> documentation for more detail. No arguments other than a possible\nexception are given to the completion callback.</p>"
             },
             {
-              "textRaw": "`stats.isDirectory()`",
+              "textRaw": "`fs.lstat(path[, options], callback)`",
               "type": "method",
-              "name": "isDirectory",
+              "name": "lstat",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v0.1.30"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`stats` {fs.Stats}",
+                          "name": "stats",
+                          "type": "fs.Stats"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a file system directory.</p>"
+              "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the symbolic link referred to by the path.\nThe callback gets two arguments <code>(err, stats)</code> where <code>stats</code> is a <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a>\nobject. <code>lstat()</code> is identical to <code>stat()</code>, except that if <code>path</code> is a symbolic\nlink, then the link itself is stat-ed, not the file that it refers to.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a> documentation for more details.</p>"
             },
             {
-              "textRaw": "`stats.isFIFO()`",
+              "textRaw": "`fs.mkdir(path[, options], callback)`",
               "type": "method",
-              "name": "isFIFO",
+              "name": "mkdir",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v0.1.8"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.11.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31530",
+                    "description": "In `recursive` mode, the callback now receives the first created path as an argument."
+                  },
+                  {
+                    "version": "v10.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/21875",
+                    "description": "The second argument can now be an `options` object with `recursive` and `mode` properties."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object|integer}",
+                      "name": "options",
+                      "type": "Object|integer",
+                      "options": [
+                        {
+                          "textRaw": "`recursive` {boolean} **Default:** `false`",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`"
+                        },
+                        {
+                          "textRaw": "`mode` {string|integer} Not supported on Windows. **Default:** `0o777`.",
+                          "name": "mode",
+                          "type": "string|integer",
+                          "default": "`0o777`",
+                          "desc": "Not supported on Windows."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a first-in-first-out (FIFO)\npipe.</p>"
+              "desc": "<p>Asynchronously creates a directory.</p>\n<p>The callback is given a possible exception and, if <code>recursive</code> is <code>true</code>, the\nfirst directory path created, <code>(err, [path])</code>.\n<code>path</code> can still be <code>undefined</code> when <code>recursive</code> is <code>true</code>, if no directory was\ncreated.</p>\n<p>The optional <code>options</code> argument can be an integer specifying <code>mode</code> (permission\nand sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>\nproperty indicating whether parent directories should be created. Calling\n<code>fs.mkdir()</code> when <code>path</code> is a directory that exists results in an error only\nwhen <code>recursive</code> is false.</p>\n<pre><code class=\"language-mjs\">import { mkdir } from 'fs';\n\n// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.\nmkdir('/tmp/a/apple', { recursive: true }, (err) => {\n  if (err) throw err;\n});\n</code></pre>\n<p>On Windows, using <code>fs.mkdir()</code> on the root directory even with recursion will\nresult in an error:</p>\n<pre><code class=\"language-mjs\">import { mkdir } from 'fs';\n\nmkdir('/', { recursive: true }, (err) => {\n  // => [Error: EPERM: operation not permitted, mkdir 'C:\\']\n});\n</code></pre>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/mkdir.2.html\"><code>mkdir(2)</code></a> documentation for more details.</p>"
             },
             {
-              "textRaw": "`stats.isFile()`",
+              "textRaw": "`fs.mkdtemp(prefix[, options], callback)`",
               "type": "method",
-              "name": "isFile",
+              "name": "mkdtemp",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v5.10.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/39028",
+                    "description": "The `prefix` parameter now accepts an empty string."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v6.2.1",
+                    "pr-url": "https://github.com/nodejs/node/pull/6828",
+                    "description": "The `callback` parameter is optional now."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`prefix` {string}",
+                      "name": "prefix",
+                      "type": "string"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`directory` {string}",
+                          "name": "directory",
+                          "type": "string"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a regular file.</p>"
+              "desc": "<p>Creates a unique temporary directory.</p>\n<p>Generates six random characters to be appended behind a required\n<code>prefix</code> to create a unique temporary directory. Due to platform\ninconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,\nnotably the BSDs, can return more than six random characters, and replace\ntrailing <code>X</code> characters in <code>prefix</code> with random characters.</p>\n<p>The created directory path is passed as a string to the callback's second\nparameter.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>\n<pre><code class=\"language-mjs\">import { mkdtemp } from 'fs';\n\nmkdtemp(path.join(os.tmpdir(), 'foo-'), (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Prints: /tmp/foo-itXde2 or C:\\Users\\...\\AppData\\Local\\Temp\\foo-itXde2\n});\n</code></pre>\n<p>The <code>fs.mkdtemp()</code> method will append the six randomly selected characters\ndirectly to the <code>prefix</code> string. For instance, given a directory <code>/tmp</code>, if the\nintention is to create a temporary directory <em>within</em> <code>/tmp</code>, the <code>prefix</code>\nmust end with a trailing platform-specific path separator\n(<code>require('path').sep</code>).</p>\n<pre><code class=\"language-mjs\">import { tmpdir } from 'os';\nimport { mkdtemp } from 'fs';\n\n// The parent directory for the new temporary directory\nconst tmpDir = tmpdir();\n\n// This method is *INCORRECT*:\nmkdtemp(tmpDir, (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Will print something similar to `/tmpabc123`.\n  // A new temporary directory is created at the file system root\n  // rather than *within* the /tmp directory.\n});\n\n// This method is *CORRECT*:\nimport { sep } from 'path';\nmkdtemp(`${tmpDir}${sep}`, (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Will print something similar to `/tmp/abc123`.\n  // A new temporary directory is created within\n  // the /tmp directory.\n});\n</code></pre>"
             },
             {
-              "textRaw": "`stats.isSocket()`",
+              "textRaw": "`fs.open(path[, flags[, mode]], callback)`",
               "type": "method",
-              "name": "isSocket",
+              "name": "open",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v11.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23767",
+                    "description": "The `flags` argument is now optional and defaults to `'r'`."
+                  },
+                  {
+                    "version": "v9.9.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/18801",
+                    "description": "The `as` and `as+` flags are supported now."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`flags` {string|number} See [support of file system `flags`][]. **Default:** `'r'`.",
+                      "name": "flags",
+                      "type": "string|number",
+                      "default": "`'r'`",
+                      "desc": "See [support of file system `flags`][]."
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer} **Default:** `0o666` (readable and writable)",
+                      "name": "mode",
+                      "type": "string|integer",
+                      "default": "`0o666` (readable and writable)"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`fd` {integer}",
+                          "name": "fd",
+                          "type": "integer"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a socket.</p>"
+              "desc": "<p>Asynchronous file open. See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a> documentation for more details.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was\ncreated. On Windows, only the write permission can be manipulated; see\n<a href=\"fs.html#fs_fs_chmod_path_mode_callback\"><code>fs.chmod()</code></a>.</p>\n<p>The callback gets two arguments <code>(err, fd)</code>.</p>\n<p>Some characters (<code>&#x3C; > : \" / \\ | ? *</code>) are reserved under Windows as documented\nby <a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file\">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains\na colon, Node.js will open a file system stream, as described by\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams\">this MSDN page</a>.</p>\n<p>Functions based on <code>fs.open()</code> exhibit this behavior as well:\n<code>fs.writeFile()</code>, <code>fs.readFile()</code>, etc.</p>"
             },
             {
-              "textRaw": "`stats.isSymbolicLink()`",
+              "textRaw": "`fs.opendir(path[, options], callback)`",
               "type": "method",
-              "name": "isSymbolicLink",
+              "name": "opendir",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v12.12.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.1.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30114",
+                    "description": "The `bufferSize` option was introduced."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`bufferSize` {number} Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. **Default:** `32`",
+                          "name": "bufferSize",
+                          "type": "number",
+                          "default": "`32`",
+                          "desc": "Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`dir` {fs.Dir}",
+                          "name": "dir",
+                          "type": "fs.Dir"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a symbolic link.</p>\n<p>This method is only valid when using <a href=\"fs.html#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a>.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`dev` {number|bigint}",
-              "type": "number|bigint",
-              "name": "dev",
-              "desc": "<p>The numeric identifier of the device containing the file.</p>"
-            },
-            {
-              "textRaw": "`ino` {number|bigint}",
-              "type": "number|bigint",
-              "name": "ino",
-              "desc": "<p>The file system specific \"Inode\" number for the file.</p>"
-            },
-            {
-              "textRaw": "`mode` {number|bigint}",
-              "type": "number|bigint",
-              "name": "mode",
-              "desc": "<p>A bit-field describing the file type and mode.</p>"
-            },
-            {
-              "textRaw": "`nlink` {number|bigint}",
-              "type": "number|bigint",
-              "name": "nlink",
-              "desc": "<p>The number of hard-links that exist for the file.</p>"
-            },
-            {
-              "textRaw": "`uid` {number|bigint}",
-              "type": "number|bigint",
-              "name": "uid",
-              "desc": "<p>The numeric user identifier of the user that owns the file (POSIX).</p>"
-            },
-            {
-              "textRaw": "`gid` {number|bigint}",
-              "type": "number|bigint",
-              "name": "gid",
-              "desc": "<p>The numeric group identifier of the group that owns the file (POSIX).</p>"
-            },
-            {
-              "textRaw": "`rdev` {number|bigint}",
-              "type": "number|bigint",
-              "name": "rdev",
-              "desc": "<p>A numeric device identifier if the file represents a device.</p>"
+              "desc": "<p>Asynchronously open a directory. See the POSIX <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a> documentation for\nmore details.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>"
             },
             {
-              "textRaw": "`size` {number|bigint}",
-              "type": "number|bigint",
-              "name": "size",
-              "desc": "<p>The size of the file in bytes.</p>"
-            },
-            {
-              "textRaw": "`blksize` {number|bigint}",
-              "type": "number|bigint",
-              "name": "blksize",
-              "desc": "<p>The file system block size for i/o operations.</p>"
-            },
-            {
-              "textRaw": "`blocks` {number|bigint}",
-              "type": "number|bigint",
-              "name": "blocks",
-              "desc": "<p>The number of blocks allocated for this file.</p>"
-            },
-            {
-              "textRaw": "`atimeMs` {number|bigint}",
-              "type": "number|bigint",
-              "name": "atimeMs",
-              "meta": {
-                "added": [
-                  "v8.1.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The timestamp indicating the last time this file was accessed expressed in\nmilliseconds since the POSIX Epoch.</p>"
-            },
-            {
-              "textRaw": "`mtimeMs` {number|bigint}",
-              "type": "number|bigint",
-              "name": "mtimeMs",
+              "textRaw": "`fs.read(fd, buffer, offset, length, position, callback)`",
+              "type": "method",
+              "name": "read",
               "meta": {
                 "added": [
-                  "v8.1.0"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `buffer` parameter can now be any `TypedArray`, or a `DataView`."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `buffer` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4518",
+                    "description": "The `length` parameter can now be `0`."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the last time this file was modified expressed in\nmilliseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView} The buffer that the data will be written to. **Default:** `Buffer.alloc(16384)`",
+                      "name": "buffer",
+                      "type": "Buffer|TypedArray|DataView",
+                      "default": "`Buffer.alloc(16384)`",
+                      "desc": "The buffer that the data will be written to."
+                    },
+                    {
+                      "textRaw": "`offset` {integer} The position in `buffer` to write the data to. **Default:** `0`",
+                      "name": "offset",
+                      "type": "integer",
+                      "default": "`0`",
+                      "desc": "The position in `buffer` to write the data to."
+                    },
+                    {
+                      "textRaw": "`length` {integer} The number of bytes to read. **Default:** `buffer.byteLength`",
+                      "name": "length",
+                      "type": "integer",
+                      "default": "`buffer.byteLength`",
+                      "desc": "The number of bytes to read."
+                    },
+                    {
+                      "textRaw": "`position` {integer|bigint} Specifies where to begin reading from in the file. If `position` is `null` or `-1 `, data will be read from the current file position, and the file position will be updated. If `position` is an integer, the file position will be unchanged.",
+                      "name": "position",
+                      "type": "integer|bigint",
+                      "desc": "Specifies where to begin reading from in the file. If `position` is `null` or `-1 `, data will be read from the current file position, and the file position will be updated. If `position` is an integer, the file position will be unchanged."
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesRead` {integer}",
+                          "name": "bytesRead",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffer` {Buffer}",
+                          "name": "buffer",
+                          "type": "Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Read data from the file specified by <code>fd</code>.</p>\n<p>The callback is given the three arguments, <code>(err, bytesRead, buffer)</code>.</p>\n<p>If the file is not modified concurrently, the end-of-file is reached when the\nnumber of bytes read is zero.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na promise for an <code>Object</code> with <code>bytesRead</code> and <code>buffer</code> properties.</p>"
             },
             {
-              "textRaw": "`ctimeMs` {number|bigint}",
-              "type": "number|bigint",
-              "name": "ctimeMs",
+              "textRaw": "`fs.read(fd, [options,] callback)`",
+              "type": "method",
+              "name": "read",
               "meta": {
                 "added": [
-                  "v8.1.0"
+                  "v13.11.0",
+                  "v12.17.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.11.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31402",
+                    "description": "Options object can be passed in to make Buffer, offset, length and position optional."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the last time the file status was changed expressed\nin milliseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`buffer` {Buffer|TypedArray|DataView} **Default:** `Buffer.alloc(16384)`",
+                          "name": "buffer",
+                          "type": "Buffer|TypedArray|DataView",
+                          "default": "`Buffer.alloc(16384)`"
+                        },
+                        {
+                          "textRaw": "`offset` {integer} **Default:** `0`",
+                          "name": "offset",
+                          "type": "integer",
+                          "default": "`0`"
+                        },
+                        {
+                          "textRaw": "`length` {integer} **Default:** `buffer.byteLength`",
+                          "name": "length",
+                          "type": "integer",
+                          "default": "`buffer.byteLength`"
+                        },
+                        {
+                          "textRaw": "`position` {integer|bigint} **Default:** `null`",
+                          "name": "position",
+                          "type": "integer|bigint",
+                          "default": "`null`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesRead` {integer}",
+                          "name": "bytesRead",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffer` {Buffer}",
+                          "name": "buffer",
+                          "type": "Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Similar to the <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a> function, this version takes an optional\n<code>options</code> object. If no <code>options</code> object is specified, it will default with the\nabove values.</p>"
             },
             {
-              "textRaw": "`birthtimeMs` {number|bigint}",
-              "type": "number|bigint",
-              "name": "birthtimeMs",
+              "textRaw": "`fs.readdir(path[, options], callback)`",
+              "type": "method",
+              "name": "readdir",
               "meta": {
                 "added": [
-                  "v8.1.0"
+                  "v0.1.8"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22020",
+                    "description": "New option `withFileTypes` was added."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/5616",
+                    "description": "The `options` parameter was added."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the creation time of this file expressed in\nmilliseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`withFileTypes` {boolean} **Default:** `false`",
+                          "name": "withFileTypes",
+                          "type": "boolean",
+                          "default": "`false`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`files` {string[]|Buffer[]|fs.Dirent[]}",
+                          "name": "files",
+                          "type": "string[]|Buffer[]|fs.Dirent[]"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Reads the contents of a directory. The callback gets two arguments <code>(err, files)</code>\nwhere <code>files</code> is an array of the names of the files in the directory excluding\n<code>'.'</code> and <code>'..'</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> documentation for more details.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe filenames returned will be passed as <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the <code>files</code> array will contain\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> objects.</p>"
             },
             {
-              "textRaw": "`atimeNs` {bigint}",
-              "type": "bigint",
-              "name": "atimeNs",
+              "textRaw": "`fs.readFile(path[, options], callback)`",
+              "type": "method",
+              "name": "readFile",
               "meta": {
                 "added": [
-                  "v12.10.0"
+                  "v0.1.29"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35911",
+                    "description": "The options argument may include an AbortSignal to abort an ongoing readFile request."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v5.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3740",
+                    "description": "The `callback` will always be called with `null` as the `error` parameter in case of success."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `path` parameter can be a file descriptor now."
+                  }
+                ]
               },
-              "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time this file was accessed expressed in\nnanoseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL|integer} filename or file descriptor",
+                      "name": "path",
+                      "type": "string|Buffer|URL|integer",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `null`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'r'`",
+                          "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting an in-progress readFile",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting an in-progress readFile"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`data` {string|Buffer}",
+                          "name": "data",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs';\n\nreadFile('/etc/passwd', (err, data) => {\n  if (err) throw err;\n  console.log(data);\n});\n</code></pre>\n<p>The callback is passed two arguments <code>(err, data)</code>, where <code>data</code> is the\ncontents of the file.</p>\n<p>If no encoding is specified, then the raw buffer is returned.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs';\n\nreadFile('/etc/passwd', 'utf8', callback);\n</code></pre>\n<p>When the path is a directory, the behavior of <code>fs.readFile()</code> and\n<a href=\"fs.html#fs_fs_readfilesync_path_options\"><code>fs.readFileSync()</code></a> is platform-specific. On macOS, Linux, and Windows, an\nerror will be returned. On FreeBSD, a representation of the directory's contents\nwill be returned.</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs';\n\n// macOS, Linux, and Windows\nreadFile('&#x3C;directory>', (err, data) => {\n  // => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]\n});\n\n//  FreeBSD\nreadFile('&#x3C;directory>', (err, data) => {\n  // => null, &#x3C;data>\n});\n</code></pre>\n<p>It is possible to abort an ongoing request using an <code>AbortSignal</code>. If a\nrequest is aborted the callback is called with an <code>AbortError</code>:</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs';\n\nconst controller = new AbortController();\nconst signal = controller.signal;\nreadFile(fileInfo[0].name, { signal }, (err, buf) => {\n  // ...\n});\n// When you want to abort the request\ncontroller.abort();\n</code></pre>\n<p>The <code>fs.readFile()</code> function buffers the entire file. To minimize memory costs,\nwhen possible prefer streaming via <code>fs.createReadStream()</code>.</p>\n<p>Aborting an ongoing request does not abort individual operating\nsystem requests but rather the internal buffering <code>fs.readFile</code> performs.</p>",
+              "modules": [
+                {
+                  "textRaw": "File descriptors",
+                  "name": "file_descriptors",
+                  "desc": "<ol>\n<li>Any specified file descriptor has to support reading.</li>\n<li>If a file descriptor is specified as the <code>path</code>, it will not be closed\nautomatically.</li>\n<li>The reading will begin at the current position. For example, if the file\nalready had <code>'Hello World</code>' and six bytes are read with the file descriptor,\nthe call to <code>fs.readFile()</code> with the same file descriptor, would give\n<code>'World'</code>, rather than <code>'Hello World'</code>.</li>\n</ol>",
+                  "type": "module",
+                  "displayName": "File descriptors"
+                },
+                {
+                  "textRaw": "Performance Considerations",
+                  "name": "performance_considerations",
+                  "desc": "<p>The <code>fs.readFile()</code> method asynchronously reads the contents of a file into\nmemory one chunk at a time, allowing the event loop to turn between each chunk.\nThis allows the read operation to have less impact on other activity that may\nbe using the underlying libuv thread pool but means that it will take longer\nto read a complete file into memory.</p>\n<p>The additional read overhead can vary broadly on different systems and depends\non the type of file being read. If the file type is not a regular file (a pipe\nfor instance) and Node.js is unable to determine an actual file size, each read\noperation will load on 64kb of data. For regular files, each read will process\n512kb of data.</p>\n<p>For applications that require as-fast-as-possible reading of file contents, it\nis better to use <code>fs.read()</code> directly and for application code to manage\nreading the full contents of the file itself.</p>\n<p>The Node.js GitHub issue <a href=\"https://github.com/nodejs/node/issues/25741\">#25741</a> provides more information and a detailed\nanalysis on the performance of <code>fs.readFile()</code> for multiple file sizes in\ndifferent Node.js versions.</p>",
+                  "type": "module",
+                  "displayName": "Performance Considerations"
+                }
+              ]
             },
             {
-              "textRaw": "`mtimeNs` {bigint}",
-              "type": "bigint",
-              "name": "mtimeNs",
+              "textRaw": "`fs.readlink(path[, options], callback)`",
+              "type": "method",
+              "name": "readlink",
               "meta": {
                 "added": [
-                  "v12.10.0"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time this file was modified expressed in\nnanoseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`linkString` {string|Buffer}",
+                          "name": "linkString",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Reads the contents of the symbolic link referred to by <code>path</code>. The callback gets\ntwo arguments <code>(err, linkString)</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a> documentation for more details.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe link path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>"
             },
             {
-              "textRaw": "`ctimeNs` {bigint}",
-              "type": "bigint",
-              "name": "ctimeNs",
+              "textRaw": "`fs.readv(fd, buffers[, position], callback)`",
+              "type": "method",
+              "name": "readv",
               "meta": {
                 "added": [
-                  "v12.10.0"
+                  "v13.13.0",
+                  "v12.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time the file status was changed expressed\nin nanoseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffers` {ArrayBufferView[]}",
+                      "name": "buffers",
+                      "type": "ArrayBufferView[]"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesRead` {integer}",
+                          "name": "bytesRead",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffers` {ArrayBufferView[]}",
+                          "name": "buffers",
+                          "type": "ArrayBufferView[]"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Read from a file specified by <code>fd</code> and write to an array of <code>ArrayBufferView</code>s\nusing <code>readv()</code>.</p>\n<p><code>position</code> is the offset from the beginning of the file from where data\nshould be read. If <code>typeof position !== 'number'</code>, the data will be read\nfrom the current position.</p>\n<p>The callback will be given three arguments: <code>err</code>, <code>bytesRead</code>, and\n<code>buffers</code>. <code>bytesRead</code> is how many bytes were read from the file.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na promise for an <code>Object</code> with <code>bytesRead</code> and <code>buffers</code> properties.</p>"
             },
             {
-              "textRaw": "`birthtimeNs` {bigint}",
-              "type": "bigint",
-              "name": "birthtimeNs",
+              "textRaw": "`fs.realpath(path[, options], callback)`",
+              "type": "method",
+              "name": "realpath",
               "meta": {
                 "added": [
-                  "v12.10.0"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/13028",
+                    "description": "Pipe/Socket resolve support was added."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v6.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7899",
+                    "description": "Calling `realpath` now works again for various edge cases on Windows."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3594",
+                    "description": "The `cache` parameter was removed."
+                  }
+                ]
               },
-              "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the creation time of this file expressed in\nnanoseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`resolvedPath` {string|Buffer}",
+                          "name": "resolvedPath",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously computes the canonical pathname by resolving <code>.</code>, <code>..</code> and\nsymbolic links.</p>\n<p>A canonical pathname is not necessarily unique. Hard links and bind mounts can\nexpose a file system entity through many pathnames.</p>\n<p>This function behaves like <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>, with some exceptions:</p>\n<ol>\n<li>\n<p>No case conversion is performed on case-insensitive file systems.</p>\n</li>\n<li>\n<p>The maximum number of symbolic links is platform-independent and generally\n(much) higher than what the native <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a> implementation supports.</p>\n</li>\n</ol>\n<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>. May use <code>process.cwd</code>\nto resolve relative paths.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>\n<p>If <code>path</code> resolves to a socket or a pipe, the function will return a system\ndependent name for that object.</p>"
             },
             {
-              "textRaw": "`atime` {Date}",
-              "type": "Date",
-              "name": "atime",
+              "textRaw": "`fs.realpath.native(path[, options], callback)`",
+              "type": "method",
+              "name": "native",
               "meta": {
                 "added": [
-                  "v0.11.13"
+                  "v9.2.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The timestamp indicating the last time this file was accessed.</p>"
-            },
-            {
-              "textRaw": "`mtime` {Date}",
-              "type": "Date",
-              "name": "mtime",
-              "meta": {
-                "added": [
-                  "v0.11.13"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The timestamp indicating the last time this file was modified.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`resolvedPath` {string|Buffer}",
+                          "name": "resolvedPath",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>.</p>\n<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
             },
             {
-              "textRaw": "`ctime` {Date}",
-              "type": "Date",
-              "name": "ctime",
+              "textRaw": "`fs.rename(oldPath, newPath, callback)`",
+              "type": "method",
+              "name": "rename",
               "meta": {
                 "added": [
-                  "v0.11.13"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `oldPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the last time the file status was changed.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`oldPath` {string|Buffer|URL}",
+                      "name": "oldPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`newPath` {string|Buffer|URL}",
+                      "name": "newPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously rename file at <code>oldPath</code> to the pathname provided\nas <code>newPath</code>. In the case that <code>newPath</code> already exists, it will\nbe overwritten. If there is a directory at <code>newPath</code>, an error will\nbe raised instead. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>.</p>\n<pre><code class=\"language-mjs\">import { rename } from 'fs';\n\nrename('oldFile.txt', 'newFile.txt', (err) => {\n  if (err) throw err;\n  console.log('Rename complete!');\n});\n</code></pre>"
             },
             {
-              "textRaw": "`birthtime` {Date}",
-              "type": "Date",
-              "name": "birthtime",
+              "textRaw": "`fs.rmdir(path[, options], callback)`",
+              "type": "method",
+              "name": "rmdir",
               "meta": {
                 "added": [
-                  "v0.11.13"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35579",
+                    "description": "The `recursive` option is deprecated, use `fs.rm` instead."
+                  },
+                  {
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30644",
+                    "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
+                  },
+                  {
+                    "version": "v12.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29168",
+                    "description": "The `recursive`, `maxBusyTries`, and `emfileWait` options are now supported."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameters can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the creation time of this file.</p>"
-            }
-          ],
-          "modules": [
-            {
-              "textRaw": "Stat time values",
-              "name": "stat_time_values",
-              "desc": "<p>The <code>atimeMs</code>, <code>mtimeMs</code>, <code>ctimeMs</code>, <code>birthtimeMs</code> properties are\nnumeric values that hold the corresponding times in milliseconds. Their\nprecision is platform specific. When <code>bigint: true</code> is passed into the\nmethod that generates the object, the properties will be <a href=\"https://tc39.github.io/proposal-bigint\">bigints</a>,\notherwise they will be <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\">numbers</a>.</p>\n<p>The <code>atimeNs</code>, <code>mtimeNs</code>, <code>ctimeNs</code>, <code>birthtimeNs</code> properties are\n<a href=\"https://tc39.github.io/proposal-bigint\">bigints</a> that hold the corresponding times in nanoseconds. They are\nonly present when <code>bigint: true</code> is passed into the method that generates\nthe object. Their precision is platform specific.</p>\n<p><code>atime</code>, <code>mtime</code>, <code>ctime</code>, and <code>birthtime</code> are\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date\"><code>Date</code></a> object alternate representations of the various times. The\n<code>Date</code> and number values are not connected. Assigning a new number value, or\nmutating the <code>Date</code> value, will not be reflected in the corresponding alternate\nrepresentation.</p>\n<p>The times in the stat object have the following semantics:</p>\n<ul>\n<li><code>atime</code> \"Access Time\": Time when file data last accessed. Changed\nby the <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/read.2.html\"><code>read(2)</code></a> system calls.</li>\n<li><code>mtime</code> \"Modified Time\": Time when file data last modified.\nChanged by the <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/write.2.html\"><code>write(2)</code></a> system calls.</li>\n<li><code>ctime</code> \"Change Time\": Time when file status was last changed\n(inode data modification). Changed by the <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>,\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>,\n<a href=\"http://man7.org/linux/man-pages/man2/read.2.html\"><code>read(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/write.2.html\"><code>write(2)</code></a> system calls.</li>\n<li><code>birthtime</code> \"Birth Time\": Time of file creation. Set once when the\nfile is created. On filesystems where birthtime is not available,\nthis field may instead hold either the <code>ctime</code> or\n<code>1970-01-01T00:00Z</code> (ie, Unix epoch timestamp <code>0</code>). This value may be greater\nthan <code>atime</code> or <code>mtime</code> in this case. On Darwin and other FreeBSD variants,\nalso set if the <code>atime</code> is explicitly set to an earlier value than the current\n<code>birthtime</code> using the <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a> system call.</li>\n</ul>\n<p>Prior to Node.js 0.12, the <code>ctime</code> held the <code>birthtime</code> on Windows systems. As\nof 0.12, <code>ctime</code> is not \"creation time\", and on Unix systems, it never was.</p>",
-              "type": "module",
-              "displayName": "Stat time values"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.WriteStream`",
-          "type": "class",
-          "name": "fs.WriteStream",
-          "meta": {
-            "added": [
-              "v0.1.93"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends <a href=\"stream.html#stream_class_stream_writable\" class=\"type\">&lt;stream.Writable&gt;</a></li>\n</ul>\n<p>Instances of <code>fs.WriteStream</code> are created and returned using the\n<a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> function.</p>",
-          "events": [
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/rmdir.2.html\"><code>rmdir(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>\n<p>Using <code>fs.rmdir()</code> on a file (not a directory) results in an <code>ENOENT</code> error on\nWindows and an <code>ENOTDIR</code> error on POSIX.</p>\n<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command\n<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths\nthat represent files will be deleted. The permissive behavior of the\n<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in\nthe future.</p>"
+            },
             {
-              "textRaw": "Event: `'close'`",
-              "type": "event",
-              "name": "close",
+              "textRaw": "`fs.rm(path[, options], callback)`",
+              "type": "method",
+              "name": "rm",
               "meta": {
                 "added": [
-                  "v0.1.93"
+                  "v14.14.0"
                 ],
                 "changes": []
               },
-              "params": [],
-              "desc": "<p>Emitted when the <code>WriteStream</code>'s underlying file descriptor has been closed.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`force` {boolean} When `true`, exceptions will be ignored if `path` does not exist. **Default:** `false`.",
+                          "name": "force",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "When `true`, exceptions will be ignored if `path` does not exist."
+                        },
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive removal. In recursive mode operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive removal. In recursive mode operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously removes files and directories (modeled on the standard POSIX <code>rm</code>\nutility). No arguments other than a possible exception are given to the\ncompletion callback.</p>"
             },
             {
-              "textRaw": "Event: `'open'`",
-              "type": "event",
-              "name": "open",
+              "textRaw": "`fs.stat(path[, options], callback)`",
+              "type": "method",
+              "name": "stat",
               "meta": {
                 "added": [
-                  "v0.1.93"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "params": [
+              "signatures": [
                 {
-                  "textRaw": "`fd` {integer} Integer file descriptor used by the `WriteStream`.",
-                  "name": "fd",
-                  "type": "integer",
-                  "desc": "Integer file descriptor used by the `WriteStream`."
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`stats` {fs.Stats}",
+                          "name": "stats",
+                          "type": "fs.Stats"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted when the <code>WriteStream</code>'s file is opened.</p>"
+              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/stat.2.html\"><code>stat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where\n<code>stats</code> is an <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object.</p>\n<p>In case of an error, the <code>err.code</code> will be one of <a href=\"errors.html#errors_common_system_errors\">Common System Errors</a>.</p>\n<p>Using <code>fs.stat()</code> to check for the existence of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended.\nInstead, user code should open/read/write the file directly and handle the\nerror raised if the file is not available.</p>\n<p>To check if a file exists without manipulating it afterwards, <a href=\"fs.html#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a>\nis recommended.</p>\n<p>For example, given the following directory structure:</p>\n<pre><code class=\"language-text\">- txtDir\n-- file.txt\n- app.js\n</code></pre>\n<p>The next program will check for the stats of the given paths:</p>\n<pre><code class=\"language-mjs\">import { stat } from 'fs';\n\nconst pathsToCheck = ['./txtDir', './txtDir/file.txt'];\n\nfor (let i = 0; i &#x3C; pathsToCheck.length; i++) {\n  stat(pathsToCheck[i], (err, stats) => {\n    console.log(stats.isDirectory());\n    console.log(stats);\n  });\n}\n</code></pre>\n<p>The resulting output will resemble:</p>\n<pre><code class=\"language-console\">true\nStats {\n  dev: 16777220,\n  mode: 16877,\n  nlink: 3,\n  uid: 501,\n  gid: 20,\n  rdev: 0,\n  blksize: 4096,\n  ino: 14214262,\n  size: 96,\n  blocks: 0,\n  atimeMs: 1561174653071.963,\n  mtimeMs: 1561174614583.3518,\n  ctimeMs: 1561174626623.5366,\n  birthtimeMs: 1561174126937.2893,\n  atime: 2019-06-22T03:37:33.072Z,\n  mtime: 2019-06-22T03:36:54.583Z,\n  ctime: 2019-06-22T03:37:06.624Z,\n  birthtime: 2019-06-22T03:28:46.937Z\n}\nfalse\nStats {\n  dev: 16777220,\n  mode: 33188,\n  nlink: 1,\n  uid: 501,\n  gid: 20,\n  rdev: 0,\n  blksize: 4096,\n  ino: 14214074,\n  size: 8,\n  blocks: 8,\n  atimeMs: 1561174616618.8555,\n  mtimeMs: 1561174614584,\n  ctimeMs: 1561174614583.8145,\n  birthtimeMs: 1561174007710.7478,\n  atime: 2019-06-22T03:36:56.619Z,\n  mtime: 2019-06-22T03:36:54.584Z,\n  ctime: 2019-06-22T03:36:54.584Z,\n  birthtime: 2019-06-22T03:26:47.711Z\n}\n</code></pre>"
             },
             {
-              "textRaw": "Event: `'ready'`",
-              "type": "event",
-              "name": "ready",
+              "textRaw": "`fs.symlink(target, path[, type], callback)`",
+              "type": "method",
+              "name": "symlink",
               "meta": {
                 "added": [
-                  "v9.11.0"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v12.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23724",
+                    "description": "If the `type` argument is left undefined, Node will autodetect `target` type and automatically select `dir` or `file`."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `target` and `path` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  }
+                ]
               },
-              "params": [],
-              "desc": "<p>Emitted when the <code>fs.WriteStream</code> is ready to be used.</p>\n<p>Fires immediately after <code>'open'</code>.</p>"
-            }
-          ],
-          "properties": [
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`target` {string|Buffer|URL}",
+                      "name": "target",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`type` {string}",
+                      "name": "type",
+                      "type": "string"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Creates the link called <code>path</code> pointing to <code>target</code>. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/symlink.2.html\"><code>symlink(2)</code></a> documentation for more details.</p>\n<p>The <code>type</code> argument is only available on Windows and ignored on other platforms.\nIt can be set to <code>'dir'</code>, <code>'file'</code>, or <code>'junction'</code>. If the <code>type</code> argument is\nnot set, Node.js will autodetect <code>target</code> type and use <code>'file'</code> or <code>'dir'</code>. If\nthe <code>target</code> does not exist, <code>'file'</code> will be used. Windows junction points\nrequire the destination path to be absolute. When using <code>'junction'</code>, the\n<code>target</code> argument will automatically be normalized to absolute path.</p>\n<p>Relative targets are relative to the link’s parent directory.</p>\n<pre><code class=\"language-mjs\">import { symlink } from 'fs';\n\nsymlink('./mew', './example/mewtwo', callback);\n</code></pre>\n<p>The above example creates a symbolic link <code>mewtwo</code> in the <code>example</code> which points\nto <code>mew</code> in the same directory:</p>\n<pre><code class=\"language-bash\">$ tree example/\nexample/\n├── mew\n└── mewtwo -> ./mew\n</code></pre>"
+            },
             {
-              "textRaw": "`writeStream.bytesWritten`",
-              "name": "bytesWritten",
+              "textRaw": "`fs.truncate(path[, len], callback)`",
+              "type": "method",
+              "name": "truncate",
               "meta": {
                 "added": [
-                  "v0.4.7"
+                  "v0.8.6"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "desc": "<p>The number of bytes written so far. Does not include data that is still queued\nfor writing.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`len` {integer} **Default:** `0`",
+                      "name": "len",
+                      "type": "integer",
+                      "default": "`0`"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Truncates the file. No arguments other than a possible exception are\ngiven to the completion callback. A file descriptor can also be passed as the\nfirst argument. In this case, <code>fs.ftruncate()</code> is called.</p>\n<pre><code class=\"language-mjs\">import { truncate } from 'fs';\n// Assuming that 'path/file.txt' is a regular file.\ntruncate('path/file.txt', (err) => {\n  if (err) throw err;\n  console.log('path/file.txt was truncated');\n});\n</code></pre>\n<pre><code class=\"language-cjs\">const { truncate } = require('fs');\n// Assuming that 'path/file.txt' is a regular file.\ntruncate('path/file.txt', (err) => {\n  if (err) throw err;\n  console.log('path/file.txt was truncated');\n});\n</code></pre>\n<p>Passing a file descriptor is deprecated and may result in an error being thrown\nin the future.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/truncate.2.html\"><code>truncate(2)</code></a> documentation for more details.</p>"
             },
             {
-              "textRaw": "`writeStream.path`",
-              "name": "path",
+              "textRaw": "`fs.unlink(path, callback)`",
+              "type": "method",
+              "name": "unlink",
               "meta": {
                 "added": [
-                  "v0.1.93"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "desc": "<p>The path to the file the stream is writing to as specified in the first\nargument to <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>. If <code>path</code> is passed as a string, then\n<code>writeStream.path</code> will be a string. If <code>path</code> is passed as a <code>Buffer</code>, then\n<code>writeStream.path</code> will be a <code>Buffer</code>.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously removes a file or symbolic link. No arguments other than a\npossible exception are given to the completion callback.</p>\n<pre><code class=\"language-mjs\">import { unlink } from 'fs';\n// Assuming that 'path/file.txt' is a regular file.\nunlink('path/file.txt', (err) => {\n  if (err) throw err;\n  console.log('path/file.txt was deleted');\n});\n</code></pre>\n<p><code>fs.unlink()</code> will not work on a directory, empty or otherwise. To remove a\ndirectory, use <a href=\"fs.html#fs_fs_rmdir_path_options_callback\"><code>fs.rmdir()</code></a>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a> documentation for more details.</p>"
             },
             {
-              "textRaw": "`pending` {boolean}",
-              "type": "boolean",
-              "name": "pending",
+              "textRaw": "`fs.unwatchFile(filename[, listener])`",
+              "type": "method",
+              "name": "unwatchFile",
               "meta": {
                 "added": [
-                  "v11.2.0"
+                  "v0.1.31"
                 ],
                 "changes": []
               },
-              "desc": "<p>This property is <code>true</code> if the underlying file has not been opened yet,\ni.e. before the <code>'ready'</code> event is emitted.</p>"
-            }
-          ]
-        }
-      ],
-      "methods": [
-        {
-          "textRaw": "`fs.access(path[, mode], callback)`",
-          "type": "method",
-          "name": "access",
-          "meta": {
-            "added": [
-              "v0.11.15"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v6.3.0",
-                "pr-url": "https://github.com/nodejs/node/pull/6534",
-                "description": "The constants like `fs.R_OK`, etc which were present directly on `fs` were moved into `fs.constants` as a soft deprecation. Thus for Node.js `< v6.3.0` use `fs` to access those constants, or do something like `(fs.constants || fs).R_OK` to work with all versions."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {integer} **Default:** `fs.constants.F_OK`",
-                  "name": "mode",
-                  "type": "integer",
-                  "default": "`fs.constants.F_OK`"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`filename` {string|Buffer|URL}",
+                      "name": "filename",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`listener` {Function} Optional, a listener previously attached using `fs.watchFile()`",
+                      "name": "listener",
+                      "type": "Function",
+                      "desc": "Optional, a listener previously attached using `fs.watchFile()`"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Tests a user's permissions for the file or directory specified by <code>path</code>.\nThe <code>mode</code> argument is an optional integer that specifies the accessibility\nchecks to be performed. Check <a href=\"fs.html#fs_file_access_constants\">File access constants</a> for possible values\nof <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of\ntwo or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>The final argument, <code>callback</code>, is a callback function that is invoked with\na possible error argument. If any of the accessibility checks fail, the error\nargument will be an <code>Error</code> object. The following examples check if\n<code>package.json</code> exists, and if it is readable or writable.</p>\n<pre><code class=\"language-js\">const file = 'package.json';\n\n// Check if the file exists in the current directory.\nfs.access(file, fs.constants.F_OK, (err) => {\n  console.log(`${file} ${err ? 'does not exist' : 'exists'}`);\n});\n\n// Check if the file is readable.\nfs.access(file, fs.constants.R_OK, (err) => {\n  console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);\n});\n\n// Check if the file is writable.\nfs.access(file, fs.constants.W_OK, (err) => {\n  console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);\n});\n\n// Check if the file exists in the current directory, and if it is writable.\nfs.access(file, fs.constants.F_OK | fs.constants.W_OK, (err) => {\n  if (err) {\n    console.error(\n      `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`);\n  } else {\n    console.log(`${file} exists, and it is writable`);\n  }\n});\n</code></pre>\n<p>Do not use <code>fs.access()</code> to check for the accessibility of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code>. Doing\nso introduces a race condition, since other processes may change the file's\nstate between the two calls. Instead, user code should open/read/write the\nfile directly and handle the error raised if the file is not accessible.</p>\n<p><strong>write (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.access('myfile', (err) => {\n  if (!err) {\n    console.error('myfile already exists');\n    return;\n  }\n\n  fs.open('myfile', 'wx', (err, fd) => {\n    if (err) throw err;\n    writeMyData(fd);\n  });\n});\n</code></pre>\n<p><strong>write (RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.open('myfile', 'wx', (err, fd) => {\n  if (err) {\n    if (err.code === 'EEXIST') {\n      console.error('myfile already exists');\n      return;\n    }\n\n    throw err;\n  }\n\n  writeMyData(fd);\n});\n</code></pre>\n<p><strong>read (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.access('myfile', (err) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  fs.open('myfile', 'r', (err, fd) => {\n    if (err) throw err;\n    readMyData(fd);\n  });\n});\n</code></pre>\n<p><strong>read (RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.open('myfile', 'r', (err, fd) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  readMyData(fd);\n});\n</code></pre>\n<p>The \"not recommended\" examples above check for accessibility and then use the\nfile; the \"recommended\" examples are better because they use the file directly\nand handle the error, if any.</p>\n<p>In general, check for the accessibility of a file only if the file will not be\nused directly, for example when its accessibility is a signal from another\nprocess.</p>\n<p>On Windows, access-control policies (ACLs) on a directory may limit access to\na file or directory. The <code>fs.access()</code> function, however, does not check the\nACL and therefore may report that a path is accessible even if the ACL restricts\nthe user from reading or writing to it.</p>"
-        },
-        {
-          "textRaw": "`fs.accessSync(path[, mode])`",
-          "type": "method",
-          "name": "accessSync",
-          "meta": {
-            "added": [
-              "v0.11.15"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Stop watching for changes on <code>filename</code>. If <code>listener</code> is specified, only that\nparticular listener is removed. Otherwise, <em>all</em> listeners are removed,\neffectively stopping watching of <code>filename</code>.</p>\n<p>Calling <code>fs.unwatchFile()</code> with a filename that is not being watched is a\nno-op, not an error.</p>\n<p>Using <a href=\"fs.html#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile()</code> and\n<code>fs.unwatchFile()</code>. <code>fs.watch()</code> should be used instead of <code>fs.watchFile()</code>\nand <code>fs.unwatchFile()</code> when possible.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {integer} **Default:** `fs.constants.F_OK`",
-                  "name": "mode",
-                  "type": "integer",
-                  "default": "`fs.constants.F_OK`"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously tests a user's permissions for the file or directory specified\nby <code>path</code>. The <code>mode</code> argument is an optional integer that specifies the\naccessibility checks to be performed. Check <a href=\"fs.html#fs_file_access_constants\">File access constants</a> for\npossible values of <code>mode</code>. It is possible to create a mask consisting of\nthe bitwise OR of two or more values\n(e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>If any of the accessibility checks fail, an <code>Error</code> will be thrown. Otherwise,\nthe method will return <code>undefined</code>.</p>\n<pre><code class=\"language-js\">try {\n  fs.accessSync('etc/passwd', fs.constants.R_OK | fs.constants.W_OK);\n  console.log('can read/write');\n} catch (err) {\n  console.error('no access!');\n}\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.appendFile(path, data[, options], callback)`",
-          "type": "method",
-          "name": "appendFile",
-          "meta": {
-            "added": [
-              "v0.6.7"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
+              "textRaw": "`fs.utimes(path, atime, mtime, callback)`",
+              "type": "method",
+              "name": "utimes",
+              "meta": {
+                "added": [
+                  "v0.4.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/11919",
+                    "description": "`NaN`, `Infinity`, and `-Infinity` are no longer valid time specifiers."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v4.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/2387",
+                    "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
+                  }
+                ]
               },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `file` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL|number} filename or file descriptor",
-                  "name": "path",
-                  "type": "string|Buffer|URL|number",
-                  "desc": "filename or file descriptor"
-                },
-                {
-                  "textRaw": "`data` {string|Buffer}",
-                  "name": "data",
-                  "type": "string|Buffer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
                     },
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'a'`",
-                      "desc": "See [support of file system `flags`][]."
-                    }
-                  ]
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
+                    },
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>.</p>\n<pre><code class=\"language-js\">fs.appendFile('message.txt', 'data to append', (err) => {\n  if (err) throw err;\n  console.log('The \"data to append\" was appended to file!');\n});\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-js\">fs.appendFile('message.txt', 'data to append', 'utf8', callback);\n</code></pre>\n<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened\nfor appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will\nnot be closed automatically.</p>\n<pre><code class=\"language-js\">fs.open('message.txt', 'a', (err, fd) => {\n  if (err) throw err;\n  fs.appendFile(fd, 'data to append', 'utf8', (err) => {\n    fs.close(fd, (err) => {\n      if (err) throw err;\n    });\n    if (err) throw err;\n  });\n});\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.appendFileSync(path, data[, options])`",
-          "type": "method",
-          "name": "appendFileSync",
-          "meta": {
-            "added": [
-              "v0.6.7"
-            ],
-            "changes": [
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
-              },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `file` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>\n<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>\n<ul>\n<li>Values can be either numbers representing Unix epoch time in seconds,\n<code>Date</code>s, or a numeric string like <code>'123456789.0'</code>.</li>\n<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or\n<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>\n</ul>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL|number} filename or file descriptor",
-                  "name": "path",
-                  "type": "string|Buffer|URL|number",
-                  "desc": "filename or file descriptor"
-                },
-                {
-                  "textRaw": "`data` {string|Buffer}",
-                  "name": "data",
-                  "type": "string|Buffer"
-                },
+              "textRaw": "`fs.watch(filename[, options][, listener])`",
+              "type": "method",
+              "name": "watch",
+              "meta": {
+                "added": [
+                  "v0.5.10"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37190",
+                    "description": "Added support for closing the watcher with an AbortSignal."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `filename` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {fs.FSWatcher}",
+                    "name": "return",
+                    "type": "fs.FSWatcher"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
+                      "textRaw": "`filename` {string|Buffer|URL}",
+                      "name": "filename",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`persistent` {boolean} Indicates whether the process should continue to run as long as files are being watched. **Default:** `true`.",
+                          "name": "persistent",
+                          "type": "boolean",
+                          "default": "`true`",
+                          "desc": "Indicates whether the process should continue to run as long as files are being watched."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [caveats][]). **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [caveats][])."
+                        },
+                        {
+                          "textRaw": "`encoding` {string} Specifies the character encoding to be used for the filename passed to the listener. **Default:** `'utf8'`.",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`",
+                          "desc": "Specifies the character encoding to be used for the filename passed to the listener."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows closing the watcher with an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows closing the watcher with an AbortSignal."
+                        }
+                      ]
                     },
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'a'`",
-                      "desc": "See [support of file system `flags`][]."
+                      "textRaw": "`listener` {Function|undefined} **Default:** `undefined`",
+                      "name": "listener",
+                      "type": "Function|undefined",
+                      "default": "`undefined`",
+                      "options": [
+                        {
+                          "textRaw": "`eventType` {string}",
+                          "name": "eventType",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`filename` {string|Buffer}",
+                          "name": "filename",
+                          "type": "string|Buffer"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>.</p>\n<pre><code class=\"language-js\">try {\n  fs.appendFileSync('message.txt', 'data to append');\n  console.log('The \"data to append\" was appended to file!');\n} catch (err) {\n  /* Handle the error */\n}\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-js\">fs.appendFileSync('message.txt', 'data to append', 'utf8');\n</code></pre>\n<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened\nfor appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will\nnot be closed automatically.</p>\n<pre><code class=\"language-js\">let fd;\n\ntry {\n  fd = fs.openSync('message.txt', 'a');\n  fs.appendFileSync(fd, 'data to append', 'utf8');\n} catch (err) {\n  /* Handle the error */\n} finally {\n  if (fd !== undefined)\n    fs.closeSync(fd);\n}\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.chmod(path, mode, callback)`",
-          "type": "method",
-          "name": "chmod",
-          "meta": {
-            "added": [
-              "v0.1.30"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {string|integer}",
-                  "name": "mode",
-                  "type": "string|integer"
-                },
+              ],
+              "desc": "<p>Watch for changes on <code>filename</code>, where <code>filename</code> is either a file or a\ndirectory.</p>\n<p>The second argument is optional. If <code>options</code> is provided as a string, it\nspecifies the <code>encoding</code>. Otherwise <code>options</code> should be passed as an object.</p>\n<p>The listener callback gets two arguments <code>(eventType, filename)</code>. <code>eventType</code>\nis either <code>'rename'</code> or <code>'change'</code>, and <code>filename</code> is the name of the file\nwhich triggered the event.</p>\n<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or\ndisappears in the directory.</p>\n<p>The listener callback is attached to the <code>'change'</code> event fired by\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a>, but it is not the same thing as the <code>'change'</code> value of\n<code>eventType</code>.</p>\n<p>If a <code>signal</code> is passed, aborting the corresponding AbortController will close\nthe returned <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a>.</p>",
+              "miscs": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "Caveats",
+                  "name": "Caveats",
+                  "type": "misc",
+                  "desc": "<p>The <code>fs.watch</code> API is not 100% consistent across platforms, and is\nunavailable in some situations.</p>\n<p>The recursive option is only supported on macOS and Windows.\nAn <code>ERR_FEATURE_UNAVAILABLE_ON_PLATFORM</code> exception will be thrown\nwhen the option is used on a platform that does not support it.</p>\n<p>On Windows, no events will be emitted if the watched directory is moved or\nrenamed. An <code>EPERM</code> error is reported when the watched directory is deleted.</p>",
+                  "miscs": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "Availability",
+                      "name": "Availability",
+                      "type": "misc",
+                      "desc": "<p>This feature depends on the underlying operating system providing a way\nto be notified of filesystem changes.</p>\n<ul>\n<li>On Linux systems, this uses <a href=\"https://man7.org/linux/man-pages/man7/inotify.7.html\"><code>inotify(7)</code></a>.</li>\n<li>On BSD systems, this uses <a href=\"https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2\"><code>kqueue(2)</code></a>.</li>\n<li>On macOS, this uses <a href=\"https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2\"><code>kqueue(2)</code></a> for files and <a href=\"https://developer.apple.com/documentation/coreservices/file_system_events\"><code>FSEvents</code></a> for\ndirectories.</li>\n<li>On SunOS systems (including Solaris and SmartOS), this uses <a href=\"https://illumos.org/man/port_create\"><code>event ports</code></a>.</li>\n<li>On Windows systems, this feature depends on <a href=\"https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw\"><code>ReadDirectoryChangesW</code></a>.</li>\n<li>On AIX systems, this feature depends on <a href=\"https://developer.ibm.com/articles/au-aix_event_infrastructure/\"><code>AHAFS</code></a>, which must be enabled.</li>\n<li>On IBM i systems, this feature is not supported.</li>\n</ul>\n<p>If the underlying functionality is not available for some reason, then\n<code>fs.watch()</code> will not be able to function and may throw an exception.\nFor example, watching files or directories can be unreliable, and in some\ncases impossible, on network file systems (NFS, SMB, etc) or host file systems\nwhen using virtualization software such as Vagrant or Docker.</p>\n<p>It is still possible to use <code>fs.watchFile()</code>, which uses stat polling, but\nthis method is slower and less reliable.</p>"
+                    },
+                    {
+                      "textRaw": "Inodes",
+                      "name": "Inodes",
+                      "type": "misc",
+                      "desc": "<p>On Linux and macOS systems, <code>fs.watch()</code> resolves the path to an <a href=\"https://en.wikipedia.org/wiki/Inode\">inode</a> and\nwatches the inode. If the watched path is deleted and recreated, it is assigned\na new inode. The watch will emit an event for the delete but will continue\nwatching the <em>original</em> inode. Events for the new inode will not be emitted.\nThis is expected behavior.</p>\n<p>AIX files retain the same inode for the lifetime of a file. Saving and closing a\nwatched file on AIX will result in two notifications (one for adding new\ncontent, and one for truncation).</p>"
+                    },
+                    {
+                      "textRaw": "Filename argument",
+                      "name": "Filename argument",
+                      "type": "misc",
+                      "desc": "<p>Providing <code>filename</code> argument in the callback is only supported on Linux,\nmacOS, Windows, and AIX. Even on supported platforms, <code>filename</code> is not always\nguaranteed to be provided. Therefore, don't assume that <code>filename</code> argument is\nalways provided in the callback, and have some fallback logic if it is <code>null</code>.</p>\n<pre><code class=\"language-mjs\">import { watch } from 'fs';\nwatch('somedir', (eventType, filename) => {\n  console.log(`event type is: ${eventType}`);\n  if (filename) {\n    console.log(`filename provided: ${filename}`);\n  } else {\n    console.log('filename not provided');\n  }\n});\n</code></pre>"
                     }
                   ]
                 }
               ]
-            }
-          ],
-          "desc": "<p>Asynchronously changes the permissions of a file. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>.</p>\n<pre><code class=\"language-js\">fs.chmod('my_file.txt', 0o775, (err) => {\n  if (err) throw err;\n  console.log('The permissions for file \"my_file.txt\" have been changed!');\n});\n</code></pre>",
-          "modules": [
-            {
-              "textRaw": "File modes",
-              "name": "file_modes",
-              "desc": "<p>The <code>mode</code> argument used in both the <code>fs.chmod()</code> and <code>fs.chmodSync()</code>\nmethods is a numeric bitmask created using a logical OR of the following\nconstants:</p>\n<table>\n<thead>\n<tr>\n<th>Constant</th>\n<th>Octal</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>fs.constants.S_IRUSR</code></td>\n<td><code>0o400</code></td>\n<td>read by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWUSR</code></td>\n<td><code>0o200</code></td>\n<td>write by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXUSR</code></td>\n<td><code>0o100</code></td>\n<td>execute/search by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IRGRP</code></td>\n<td><code>0o40</code></td>\n<td>read by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWGRP</code></td>\n<td><code>0o20</code></td>\n<td>write by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXGRP</code></td>\n<td><code>0o10</code></td>\n<td>execute/search by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IROTH</code></td>\n<td><code>0o4</code></td>\n<td>read by others</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWOTH</code></td>\n<td><code>0o2</code></td>\n<td>write by others</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXOTH</code></td>\n<td><code>0o1</code></td>\n<td>execute/search by others</td>\n</tr>\n</tbody>\n</table>\n<p>An easier method of constructing the <code>mode</code> is to use a sequence of three\noctal digits (e.g. <code>765</code>). The left-most digit (<code>7</code> in the example), specifies\nthe permissions for the file owner. The middle digit (<code>6</code> in the example),\nspecifies permissions for the group. The right-most digit (<code>5</code> in the example),\nspecifies the permissions for others.</p>\n<table>\n<thead>\n<tr>\n<th>Number</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>7</code></td>\n<td>read, write, and execute</td>\n</tr>\n<tr>\n<td><code>6</code></td>\n<td>read and write</td>\n</tr>\n<tr>\n<td><code>5</code></td>\n<td>read and execute</td>\n</tr>\n<tr>\n<td><code>4</code></td>\n<td>read only</td>\n</tr>\n<tr>\n<td><code>3</code></td>\n<td>write and execute</td>\n</tr>\n<tr>\n<td><code>2</code></td>\n<td>write only</td>\n</tr>\n<tr>\n<td><code>1</code></td>\n<td>execute only</td>\n</tr>\n<tr>\n<td><code>0</code></td>\n<td>no permission</td>\n</tr>\n</tbody>\n</table>\n<p>For example, the octal value <code>0o765</code> means:</p>\n<ul>\n<li>The owner may read, write and execute the file.</li>\n<li>The group may read and write the file.</li>\n<li>Others may read and execute the file.</li>\n</ul>\n<p>When using raw numbers where file modes are expected, any value larger than\n<code>0o777</code> may result in platform-specific behaviors that are not supported to work\nconsistently. Therefore constants like <code>S_ISVTX</code>, <code>S_ISGID</code> or <code>S_ISUID</code> are not\nexposed in <code>fs.constants</code>.</p>\n<p>Caveats: on Windows only the write permission can be changed, and the\ndistinction among the permissions of group, owner or others is not\nimplemented.</p>",
-              "type": "module",
-              "displayName": "File modes"
-            }
-          ]
-        },
-        {
-          "textRaw": "`fs.chmodSync(path, mode)`",
-          "type": "method",
-          "name": "chmodSync",
-          "meta": {
-            "added": [
-              "v0.6.7"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {string|integer}",
-                  "name": "mode",
-                  "type": "string|integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_chmod_path_mode_callback\"><code>fs.chmod()</code></a>.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.chown(path, uid, gid, callback)`",
-          "type": "method",
-          "name": "chown",
-          "meta": {
-            "added": [
-              "v0.1.97"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
+              "textRaw": "`fs.watchFile(filename[, options], listener)`",
+              "type": "method",
+              "name": "watchFile",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "The `bigint` option is now supported."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `filename` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {fs.StatWatcher}",
+                    "name": "return",
+                    "type": "fs.StatWatcher"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`filename` {string|Buffer|URL}",
+                      "name": "filename",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} **Default:** `false`",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`"
+                        },
+                        {
+                          "textRaw": "`persistent` {boolean} **Default:** `true`",
+                          "name": "persistent",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`interval` {integer} **Default:** `5007`",
+                          "name": "interval",
+                          "type": "integer",
+                          "default": "`5007`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`listener` {Function}",
+                      "name": "listener",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`current` {fs.Stats}",
+                          "name": "current",
+                          "type": "fs.Stats"
+                        },
+                        {
+                          "textRaw": "`previous` {fs.Stats}",
+                          "name": "previous",
+                          "type": "fs.Stats"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously changes owner and group of a file. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.chownSync(path, uid, gid)`",
-          "type": "method",
-          "name": "chownSync",
-          "meta": {
-            "added": [
-              "v0.1.97"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Watch for changes on <code>filename</code>. The callback <code>listener</code> will be called each\ntime the file is accessed.</p>\n<p>The <code>options</code> argument may be omitted. If provided, it should be an object. The\n<code>options</code> object may contain a boolean named <code>persistent</code> that indicates\nwhether the process should continue to run as long as files are being watched.\nThe <code>options</code> object may specify an <code>interval</code> property indicating how often the\ntarget should be polled in milliseconds.</p>\n<p>The <code>listener</code> gets two arguments the current stat object and the previous\nstat object:</p>\n<pre><code class=\"language-mjs\">import { watchFile } from 'fs';\n\nwatchFile('message.text', (curr, prev) => {\n  console.log(`the current mtime is: ${curr.mtime}`);\n  console.log(`the previous mtime was: ${prev.mtime}`);\n});\n</code></pre>\n<p>These stat objects are instances of <code>fs.Stat</code>. If the <code>bigint</code> option is <code>true</code>,\nthe numeric values in these objects are specified as <code>BigInt</code>s.</p>\n<p>To be notified when the file was modified, not just accessed, it is necessary\nto compare <code>curr.mtime</code> and <code>prev.mtime</code>.</p>\n<p>When an <code>fs.watchFile</code> operation results in an <code>ENOENT</code> error, it\nwill invoke the listener once, with all the fields zeroed (or, for dates, the\nUnix Epoch). If the file is created later on, the listener will be called\nagain, with the latest stat objects. This is a change in functionality since\nv0.10.</p>\n<p>Using <a href=\"fs.html#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile</code> and\n<code>fs.unwatchFile</code>. <code>fs.watch</code> should be used instead of <code>fs.watchFile</code> and\n<code>fs.unwatchFile</code> when possible.</p>\n<p>When a file being watched by <code>fs.watchFile()</code> disappears and reappears,\nthen the contents of <code>previous</code> in the second callback event (the file's\nreappearance) will be the same as the contents of <code>previous</code> in the first\ncallback event (its disappearance).</p>\n<p>This happens when:</p>\n<ul>\n<li>the file is deleted, followed by a restore</li>\n<li>the file is renamed and then renamed a second time back to its original name</li>\n</ul>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously changes owner and group of a file. Returns <code>undefined</code>.\nThis is the synchronous version of <a href=\"fs.html#fs_fs_chown_path_uid_gid_callback\"><code>fs.chown()</code></a>.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.close(fd, callback)`",
-          "type": "method",
-          "name": "close",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+              "textRaw": "`fs.write(fd, buffer[, offset[, length[, position]]], callback)`",
+              "type": "method",
+              "name": "write",
+              "meta": {
+                "added": [
+                  "v0.0.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `buffer` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `buffer` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `buffer` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v7.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7856",
+                    "description": "The `offset` and `length` parameters are optional now."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView|string|Object}",
+                      "name": "buffer",
+                      "type": "Buffer|TypedArray|DataView|string|Object"
+                    },
+                    {
+                      "textRaw": "`offset` {integer}",
+                      "name": "offset",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`length` {integer}",
+                      "name": "length",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesWritten` {integer}",
+                          "name": "bytesWritten",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
+                          "name": "buffer",
+                          "type": "Buffer|TypedArray|DataView"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/close.2.html\"><code>close(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>\n<p>Calling <code>fs.close()</code> on any file descriptor (<code>fd</code>) that is currently in use\nthrough any other <code>fs</code> operation may lead to undefined behavior.</p>"
-        },
-        {
-          "textRaw": "`fs.closeSync(fd)`",
-          "type": "method",
-          "name": "closeSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Write <code>buffer</code> to the file specified by <code>fd</code>. If <code>buffer</code> is a normal object, it\nmust have an own <code>toString</code> function property.</p>\n<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is\nan integer specifying the number of bytes to write.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p>The callback will be given three arguments <code>(err, bytesWritten, buffer)</code> where\n<code>bytesWritten</code> specifies how many <em>bytes</em> were written from <code>buffer</code>.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na promise for an <code>Object</code> with <code>bytesWritten</code> and <code>buffer</code> properties.</p>\n<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting\nfor the callback. For this scenario, <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/close.2.html\"><code>close(2)</code></a>. Returns <code>undefined</code>.</p>\n<p>Calling <code>fs.closeSync()</code> on any file descriptor (<code>fd</code>) that is currently in use\nthrough any other <code>fs</code> operation may lead to undefined behavior.</p>"
-        },
-        {
-          "textRaw": "`fs.copyFile(src, dest[, flags], callback)`",
-          "type": "method",
-          "name": "copyFile",
-          "meta": {
-            "added": [
-              "v8.5.0"
-            ],
-            "changes": [
-              {
-                "version": "v14.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/27044",
-                "description": "Changed 'flags' argument to 'mode' and imposed stricter type validation."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`src` {string|Buffer|URL} source filename to copy",
-                  "name": "src",
-                  "type": "string|Buffer|URL",
-                  "desc": "source filename to copy"
-                },
-                {
-                  "textRaw": "`dest` {string|Buffer|URL} destination filename of the copy operation",
-                  "name": "dest",
-                  "type": "string|Buffer|URL",
-                  "desc": "destination filename of the copy operation"
-                },
-                {
-                  "textRaw": "`flags` {number} modifiers for copy operation. **Default:** `0`.",
-                  "name": "flags",
-                  "type": "number",
-                  "default": "`0`",
-                  "desc": "modifiers for copy operation."
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. No arguments other than a possible exception are given to the\ncallback function. Node.js makes no guarantees about the atomicity of the copy\noperation. If an error occurs after the destination file has been opened for\nwriting, Node.js will attempt to remove the destination.</p>\n<p><code>flags</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support copy-on-write,\nthen the operation will fail.</li>\n</ul>\n<pre><code class=\"language-js\">const fs = require('fs');\n\n// destination.txt will be created or overwritten by default.\nfs.copyFile('source.txt', 'destination.txt', (err) => {\n  if (err) throw err;\n  console.log('source.txt was copied to destination.txt');\n});\n</code></pre>\n<p>If the third argument is a number, then it specifies <code>flags</code>:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst { COPYFILE_EXCL } = fs.constants;\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\nfs.copyFile('source.txt', 'destination.txt', COPYFILE_EXCL, callback);\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.copyFileSync(src, dest[, flags])`",
-          "type": "method",
-          "name": "copyFileSync",
-          "meta": {
-            "added": [
-              "v8.5.0"
-            ],
-            "changes": [
-              {
-                "version": "v14.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/27044",
-                "description": "Changed 'flags' argument to 'mode' and imposed stricter type validation."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`src` {string|Buffer|URL} source filename to copy",
-                  "name": "src",
-                  "type": "string|Buffer|URL",
-                  "desc": "source filename to copy"
-                },
-                {
-                  "textRaw": "`dest` {string|Buffer|URL} destination filename of the copy operation",
-                  "name": "dest",
-                  "type": "string|Buffer|URL",
-                  "desc": "destination filename of the copy operation"
-                },
-                {
-                  "textRaw": "`flags` {number} modifiers for copy operation. **Default:** `0`.",
-                  "name": "flags",
-                  "type": "number",
-                  "default": "`0`",
-                  "desc": "modifiers for copy operation."
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. Returns <code>undefined</code>. Node.js makes no guarantees about the\natomicity of the copy operation. If an error occurs after the destination file\nhas been opened for writing, Node.js will attempt to remove the destination.</p>\n<p><code>flags</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support copy-on-write,\nthen the operation will fail.</li>\n</ul>\n<pre><code class=\"language-js\">const fs = require('fs');\n\n// destination.txt will be created or overwritten by default.\nfs.copyFileSync('source.txt', 'destination.txt');\nconsole.log('source.txt was copied to destination.txt');\n</code></pre>\n<p>If the third argument is a number, then it specifies <code>flags</code>:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst { COPYFILE_EXCL } = fs.constants;\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\nfs.copyFileSync('source.txt', 'destination.txt', COPYFILE_EXCL);\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.createReadStream(path[, options])`",
-          "type": "method",
-          "name": "createReadStream",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v12.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29212",
-                "description": "Enable `emitClose` option."
-              },
-              {
-                "version": "v11.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/19898",
-                "description": "Impose new restrictions on `start` and `end`, throwing more appropriate errors in cases when we cannot reasonably handle the input values."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
-              },
-              {
-                "version": "v2.3.0",
-                "pr-url": "https://github.com/nodejs/node/pull/1845",
-                "description": "The passed `options` object can be a string now."
-              },
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29083",
-                "description": "The `fs` options allow overriding the used `fs` implementation."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {fs.ReadStream} See [Readable Stream][].",
-                "name": "return",
-                "type": "fs.ReadStream",
-                "desc": "See [Readable Stream][]."
+              "textRaw": "`fs.write(fd, string[, position[, encoding]], callback)`",
+              "type": "method",
+              "name": "write",
+              "meta": {
+                "added": [
+                  "v0.11.5"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `string` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `string` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7856",
+                    "description": "The `position` parameter is optional now."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
-                    {
-                      "textRaw": "`flags` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
-                      "name": "flags",
-                      "type": "string",
-                      "default": "`'r'`",
-                      "desc": "See [support of file system `flags`][]."
-                    },
-                    {
-                      "textRaw": "`encoding` {string} **Default:** `null`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`null`"
-                    },
+                  "params": [
                     {
-                      "textRaw": "`fd` {integer} **Default:** `null`",
+                      "textRaw": "`fd` {integer}",
                       "name": "fd",
-                      "type": "integer",
-                      "default": "`null`"
-                    },
-                    {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
-                    },
-                    {
-                      "textRaw": "`autoClose` {boolean} **Default:** `true`",
-                      "name": "autoClose",
-                      "type": "boolean",
-                      "default": "`true`"
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`emitClose` {boolean} **Default:** `false`",
-                      "name": "emitClose",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`string` {string|Object}",
+                      "name": "string",
+                      "type": "string|Object"
                     },
                     {
-                      "textRaw": "`start` {integer}",
-                      "name": "start",
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
                       "type": "integer"
                     },
                     {
-                      "textRaw": "`end` {integer} **Default:** `Infinity`",
-                      "name": "end",
-                      "type": "integer",
-                      "default": "`Infinity`"
-                    },
-                    {
-                      "textRaw": "`highWaterMark` {integer} **Default:** `64 * 1024`",
-                      "name": "highWaterMark",
-                      "type": "integer",
-                      "default": "`64 * 1024`"
+                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                      "name": "encoding",
+                      "type": "string",
+                      "default": "`'utf8'`"
                     },
                     {
-                      "textRaw": "`fs` {Object|null} **Default:** `null`",
-                      "name": "fs",
-                      "type": "Object|null",
-                      "default": "`null`"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`written` {integer}",
+                          "name": "written",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`string` {string}",
+                          "name": "string",
+                          "type": "string"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Unlike the 16 kb default <code>highWaterMark</code> for a readable stream, the stream\nreturned by this method has a default <code>highWaterMark</code> of 64 kb.</p>\n<p><code>options</code> can include <code>start</code> and <code>end</code> values to read a range of bytes from\nthe file instead of the entire file. Both <code>start</code> and <code>end</code> are inclusive and\nstart counting at 0, allowed values are in the\n[0, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\"><code>Number.MAX_SAFE_INTEGER</code></a>] range. If <code>fd</code> is specified and <code>start</code> is\nomitted or <code>undefined</code>, <code>fs.createReadStream()</code> reads sequentially from the\ncurrent file position. The <code>encoding</code> can be any one of those accepted by\n<a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>.</p>\n<p>If <code>fd</code> is specified, <code>ReadStream</code> will ignore the <code>path</code> argument and will use\nthe specified file descriptor. This means that no <code>'open'</code> event will be\nemitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s should be passed to\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.</p>\n<p>If <code>fd</code> points to a character device that only supports blocking reads\n(such as keyboard or sound card), read operations do not finish until data is\navailable. This can prevent the process from exiting and the stream from\nclosing naturally.</p>\n<p>By default, the stream will not emit a <code>'close'</code> event after it has been\ndestroyed. This is the opposite of the default for other <code>Readable</code> streams.\nSet the <code>emitClose</code> option to <code>true</code> to change this behavior.</p>\n<p>By providing the <code>fs</code> option, it is possible to override the corresponding <code>fs</code>\nimplementations for <code>open</code>, <code>read</code>, and <code>close</code>. When providing the <code>fs</code> option,\noverrides for <code>open</code>, <code>read</code>, and <code>close</code> are required.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n// Create a stream from some character device.\nconst stream = fs.createReadStream('/dev/input/event0');\nsetTimeout(() => {\n  stream.close(); // This may not close the stream.\n  // Artificially marking end-of-stream, as if the underlying resource had\n  // indicated end-of-file by itself, allows the stream to close.\n  // This does not cancel pending read operations, and if there is such an\n  // operation, the process may still not be able to exit successfully\n  // until it finishes.\n  stream.push(null);\n  stream.read(0);\n}, 100);\n</code></pre>\n<p>If <code>autoClose</code> is false, then the file descriptor won't be closed, even if\nthere's an error. It is the application's responsibility to close it and make\nsure there's no file descriptor leak. If <code>autoClose</code> is set to true (default\nbehavior), on <code>'error'</code> or <code>'end'</code> the file descriptor will be closed\nautomatically.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the\nfile was created.</p>\n<p>An example to read the last 10 bytes of a file which is 100 bytes long:</p>\n<pre><code class=\"language-js\">fs.createReadStream('sample.txt', { start: 90, end: 99 });\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>"
-        },
-        {
-          "textRaw": "`fs.createWriteStream(path[, options])`",
-          "type": "method",
-          "name": "createWriteStream",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v12.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29212",
-                "description": "Enable `emitClose` option."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
-              },
-              {
-                "version": "v5.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3679",
-                "description": "The `autoClose` option is supported now."
-              },
-              {
-                "version": "v2.3.0",
-                "pr-url": "https://github.com/nodejs/node/pull/1845",
-                "description": "The passed `options` object can be a string now."
-              },
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/v12.17.0",
-                "description": "The `fs` options allow overriding the used `fs` implementation."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Write <code>string</code> to the file specified by <code>fd</code>. If <code>string</code> is not a string, or an\nobject with an own <code>toString</code> function property, then an exception is thrown.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code> the data will be written at\nthe current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p><code>encoding</code> is the expected string encoding.</p>\n<p>The callback will receive the arguments <code>(err, written, string)</code> where <code>written</code>\nspecifies how many <em>bytes</em> the passed string required to be written. Bytes\nwritten is not necessarily the same as string characters written. See\n<a href=\"buffer.html#buffer_static_method_buffer_bytelength_string_encoding\"><code>Buffer.byteLength</code></a>.</p>\n<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting\nfor the callback. For this scenario, <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>\n<p>On Windows, if the file descriptor is connected to the console (e.g. <code>fd == 1</code>\nor <code>stdout</code>) a string containing non-ASCII characters will not be rendered\nproperly by default, regardless of the encoding used.\nIt is possible to configure the console to render UTF-8 properly by changing the\nactive codepage with the <code>chcp 65001</code> command. See the <a href=\"https://ss64.com/nt/chcp.html\">chcp</a> docs for more\ndetails.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.WriteStream} See [Writable Stream][].",
-                "name": "return",
-                "type": "fs.WriteStream",
-                "desc": "See [Writable Stream][]."
+              "textRaw": "`fs.writeFile(file, data[, options], callback)`",
+              "type": "method",
+              "name": "writeFile",
+              "meta": {
+                "added": [
+                  "v0.1.29"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35993",
+                    "description": "The options argument may include an AbortSignal to abort an ongoing writeFile request."
+                  },
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `data` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `data` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `data` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `data` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `file` parameter can be a file descriptor now."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`flags` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
-                      "name": "flags",
-                      "type": "string",
-                      "default": "`'w'`",
-                      "desc": "See [support of file system `flags`][]."
+                      "textRaw": "`file` {string|Buffer|URL|integer} filename or file descriptor",
+                      "name": "file",
+                      "type": "string|Buffer|URL|integer",
+                      "desc": "filename or file descriptor"
                     },
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`data` {string|Buffer|TypedArray|DataView|Object}",
+                      "name": "data",
+                      "type": "string|Buffer|TypedArray|DataView|Object"
                     },
                     {
-                      "textRaw": "`fd` {integer} **Default:** `null`",
-                      "name": "fd",
-                      "type": "integer",
-                      "default": "`null`"
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'w'`",
+                          "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting an in-progress writeFile",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting an in-progress writeFile"
+                        }
+                      ]
                     },
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
-                    },
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>When <code>file</code> is a filename, asynchronously writes data to the file, replacing the\nfile if it already exists. <code>data</code> can be a string or a buffer.</p>\n<p>When <code>file</code> is a file descriptor, the behavior is similar to calling\n<code>fs.write()</code> directly (which is recommended). See the notes below on using\na file descriptor.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"fs.html#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<p>If <code>data</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<pre><code class=\"language-mjs\">import { writeFile } from 'fs';\n\nconst data = new Uint8Array(Buffer.from('Hello Node.js'));\nwriteFile('message.txt', data, (err) => {\n  if (err) throw err;\n  console.log('The file has been saved!');\n});\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-mjs\">import { writeFile } from 'fs';\n\nwriteFile('message.txt', 'Hello Node.js', 'utf8', callback);\n</code></pre>\n<p>It is unsafe to use <code>fs.writeFile()</code> multiple times on the same file without\nwaiting for the callback. For this scenario, <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>Similarly to <code>fs.readFile</code> - <code>fs.writeFile</code> is a convenience method that\nperforms multiple <code>write</code> calls internally to write the buffer passed to it.\nFor performance sensitive code consider using <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>It is possible to use an <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> to cancel an <code>fs.writeFile()</code>.\nCancelation is \"best effort\", and some amount of data is likely still\nto be written.</p>\n<pre><code class=\"language-mjs\">import { writeFile } from 'fs';\n\nconst controller = new AbortController();\nconst { signal } = controller;\nconst data = new Uint8Array(Buffer.from('Hello Node.js'));\nwriteFile('message.txt', data, { signal }, (err) => {\n  // When a request is aborted - the callback is called with an AbortError\n});\n// When the request should be aborted\ncontroller.abort();\n</code></pre>\n<p>Aborting an ongoing request does not abort individual operating\nsystem requests but rather the internal buffering <code>fs.writeFile</code> performs.</p>",
+              "modules": [
+                {
+                  "textRaw": "Using `fs.writeFile()` with file descriptors",
+                  "name": "using_`fs.writefile()`_with_file_descriptors",
+                  "desc": "<p>When <code>file</code> is a file descriptor, the behavior is almost identical to directly\ncalling <code>fs.write()</code> like:</p>\n<pre><code class=\"language-mjs\">import { write } from 'fs';\n\nwrite(fd, Buffer.from(data, options.encoding), callback);\n</code></pre>\n<p>The difference from directly calling <code>fs.write()</code> is that under some unusual\nconditions, <code>fs.write()</code> might write only part of the buffer and need to be\nretried to write the remaining data, whereas <code>fs.writeFile()</code> retries until\nthe data is entirely written (or an error occurs).</p>\n<p>The implications of this are a common source of confusion. In\nthe file descriptor case, the file is not replaced! The data is not necessarily\nwritten to the beginning of the file, and the file's original data may remain\nbefore and/or after the newly written data.</p>\n<p>For example, if <code>fs.writeFile()</code> is called twice in a row, first to write the\nstring <code>'Hello'</code>, then to write the string <code>', World'</code>, the file would contain\n<code>'Hello, World'</code>, and might contain some of the file's original data (depending\non the size of the original file, and the position of the file descriptor). If\na file name had been used instead of a descriptor, the file would be guaranteed\nto contain only <code>', World'</code>.</p>",
+                  "type": "module",
+                  "displayName": "Using `fs.writeFile()` with file descriptors"
+                }
+              ]
+            },
+            {
+              "textRaw": "`fs.writev(fd, buffers[, position], callback)`",
+              "type": "method",
+              "name": "writev",
+              "meta": {
+                "added": [
+                  "v12.9.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
                     {
-                      "textRaw": "`autoClose` {boolean} **Default:** `true`",
-                      "name": "autoClose",
-                      "type": "boolean",
-                      "default": "`true`"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`emitClose` {boolean} **Default:** `false`",
-                      "name": "emitClose",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`buffers` {ArrayBufferView[]}",
+                      "name": "buffers",
+                      "type": "ArrayBufferView[]"
                     },
                     {
-                      "textRaw": "`start` {integer}",
-                      "name": "start",
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
                       "type": "integer"
                     },
                     {
-                      "textRaw": "`fs` {Object|null} **Default:** `null`",
-                      "name": "fs",
-                      "type": "Object|null",
-                      "default": "`null`"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesWritten` {integer}",
+                          "name": "bytesWritten",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffers` {ArrayBufferView[]}",
+                          "name": "buffers",
+                          "type": "ArrayBufferView[]"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
+              ],
+              "desc": "<p>Write an array of <code>ArrayBufferView</code>s to the file specified by <code>fd</code> using\n<code>writev()</code>.</p>\n<p><code>position</code> is the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position.</p>\n<p>The callback will be given three arguments: <code>err</code>, <code>bytesWritten</code>, and\n<code>buffers</code>. <code>bytesWritten</code> is how many bytes were written from <code>buffers</code>.</p>\n<p>If this method is <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed, it returns a promise for an\n<code>Object</code> with <code>bytesWritten</code> and <code>buffers</code> properties.</p>\n<p>It is unsafe to use <code>fs.writev()</code> multiple times on the same file without\nwaiting for the callback. For this scenario, use <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
             }
           ],
-          "desc": "<p><code>options</code> may also include a <code>start</code> option to allow writing data at\nsome position past the beginning of the file, allowed values are in the\n[0, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\"><code>Number.MAX_SAFE_INTEGER</code></a>] range. Modifying a file rather\nthan replacing it may require a <code>flags</code> mode of <code>r+</code> rather than the\ndefault mode <code>w</code>. The <code>encoding</code> can be any one of those accepted by\n<a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>.</p>\n<p>If <code>autoClose</code> is set to true (default behavior) on <code>'error'</code> or <code>'finish'</code>\nthe file descriptor will be closed automatically. If <code>autoClose</code> is false,\nthen the file descriptor won't be closed, even if there's an error.\nIt is the application's responsibility to close it and make sure there's no\nfile descriptor leak.</p>\n<p>By default, the stream will not emit a <code>'close'</code> event after it has been\ndestroyed. This is the opposite of the default for other <code>Writable</code> streams.\nSet the <code>emitClose</code> option to <code>true</code> to change this behavior.</p>\n<p>By providing the <code>fs</code> option it is possible to override the corresponding <code>fs</code>\nimplementations for <code>open</code>, <code>write</code>, <code>writev</code> and <code>close</code>. Overriding <code>write()</code>\nwithout <code>writev()</code> can reduce performance as some optimizations (<code>_writev()</code>)\nwill be disabled. When providing the <code>fs</code> option,  overrides for <code>open</code>,\n<code>close</code>, and at least one of <code>write</code> and <code>writev</code> are required.</p>\n<p>Like <a href=\"fs.html#fs_class_fs_readstream\"><code>ReadStream</code></a>, if <code>fd</code> is specified, <a href=\"fs.html#fs_class_fs_writestream\"><code>WriteStream</code></a> will ignore the\n<code>path</code> argument and will use the specified file descriptor. This means that no\n<code>'open'</code> event will be emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s\nshould be passed to <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>"
+          "type": "module",
+          "displayName": "Callback API"
         },
         {
-          "textRaw": "`fs.exists(path, callback)`",
-          "type": "method",
-          "name": "exists",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ],
-            "deprecated": [
-              "v1.0.0"
-            ]
-          },
-          "stability": 0,
-          "stabilityText": "Deprecated: Use [`fs.stat()`][] or [`fs.access()`][] instead.",
-          "signatures": [
+          "textRaw": "Synchronous API",
+          "name": "synchronous_api",
+          "desc": "<p>The synchronous APIs perform all operations synchronously, blocking the\nevent loop until the operation completes or fails.</p>",
+          "methods": [
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.accessSync(path[, mode])`",
+              "type": "method",
+              "name": "accessSync",
+              "meta": {
+                "added": [
+                  "v0.11.15"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`exists` {boolean}",
-                      "name": "exists",
-                      "type": "boolean"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {integer} **Default:** `fs.constants.F_OK`",
+                      "name": "mode",
+                      "type": "integer",
+                      "default": "`fs.constants.F_OK`"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Test whether or not the given path exists by checking with the file system.\nThen call the <code>callback</code> argument with either true or false:</p>\n<pre><code class=\"language-js\">fs.exists('/etc/passwd', (exists) => {\n  console.log(exists ? 'it\\'s there' : 'no passwd!');\n});\n</code></pre>\n<p><strong>The parameters for this callback are not consistent with other Node.js\ncallbacks.</strong> Normally, the first parameter to a Node.js callback is an <code>err</code>\nparameter, optionally followed by other parameters. The <code>fs.exists()</code> callback\nhas only one boolean parameter. This is one reason <code>fs.access()</code> is recommended\ninstead of <code>fs.exists()</code>.</p>\n<p>Using <code>fs.exists()</code> to check for the existence of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended. Doing\nso introduces a race condition, since other processes may change the file's\nstate between the two calls. Instead, user code should open/read/write the\nfile directly and handle the error raised if the file does not exist.</p>\n<p><strong>write (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.exists('myfile', (exists) => {\n  if (exists) {\n    console.error('myfile already exists');\n  } else {\n    fs.open('myfile', 'wx', (err, fd) => {\n      if (err) throw err;\n      writeMyData(fd);\n    });\n  }\n});\n</code></pre>\n<p><strong>write (RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.open('myfile', 'wx', (err, fd) => {\n  if (err) {\n    if (err.code === 'EEXIST') {\n      console.error('myfile already exists');\n      return;\n    }\n\n    throw err;\n  }\n\n  writeMyData(fd);\n});\n</code></pre>\n<p><strong>read (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.exists('myfile', (exists) => {\n  if (exists) {\n    fs.open('myfile', 'r', (err, fd) => {\n      if (err) throw err;\n      readMyData(fd);\n    });\n  } else {\n    console.error('myfile does not exist');\n  }\n});\n</code></pre>\n<p><strong>read (RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.open('myfile', 'r', (err, fd) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  readMyData(fd);\n});\n</code></pre>\n<p>The \"not recommended\" examples above check for existence and then use the\nfile; the \"recommended\" examples are better because they use the file directly\nand handle the error, if any.</p>\n<p>In general, check for the existence of a file only if the file won’t be\nused directly, for example when its existence is a signal from another\nprocess.</p>"
-        },
-        {
-          "textRaw": "`fs.existsSync(path)`",
-          "type": "method",
-          "name": "existsSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously tests a user's permissions for the file or directory specified\nby <code>path</code>. The <code>mode</code> argument is an optional integer that specifies the\naccessibility checks to be performed. Check <a href=\"fs.html#fs_file_access_constants\">File access constants</a> for\npossible values of <code>mode</code>. It is possible to create a mask consisting of\nthe bitwise OR of two or more values\n(e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>If any of the accessibility checks fail, an <code>Error</code> will be thrown. Otherwise,\nthe method will return <code>undefined</code>.</p>\n<pre><code class=\"language-mjs\">import { accessSync, constants } from 'fs';\n\ntry {\n  accessSync('etc/passwd', constants.R_OK | constants.W_OK);\n  console.log('can read/write');\n} catch (err) {\n  console.error('no access!');\n}\n</code></pre>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {boolean}",
-                "name": "return",
-                "type": "boolean"
+              "textRaw": "`fs.appendFileSync(path, data[, options])`",
+              "type": "method",
+              "name": "appendFileSync",
+              "meta": {
+                "added": [
+                  "v0.6.7"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `file` parameter can be a file descriptor now."
+                  }
+                ]
               },
-              "params": [
+              "signatures": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL|number} filename or file descriptor",
+                      "name": "path",
+                      "type": "string|Buffer|URL|number",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`data` {string|Buffer}",
+                      "name": "data",
+                      "type": "string|Buffer"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'a'`",
+                          "desc": "See [support of file system `flags`][]."
+                        }
+                      ]
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns <code>true</code> if the path exists, <code>false</code> otherwise.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_exists_path_callback\"><code>fs.exists()</code></a>.</p>\n<p><code>fs.exists()</code> is deprecated, but <code>fs.existsSync()</code> is not. The <code>callback</code>\nparameter to <code>fs.exists()</code> accepts parameters that are inconsistent with other\nNode.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>\n<pre><code class=\"language-js\">if (fs.existsSync('/etc/passwd')) {\n  console.log('The path exists.');\n}\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.fchmod(fd, mode, callback)`",
-          "type": "method",
-          "name": "fchmod",
-          "meta": {
-            "added": [
-              "v0.4.7"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"fs.html#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<pre><code class=\"language-mjs\">import { appendFileSync } from 'fs';\n\ntry {\n  appendFileSync('message.txt', 'data to append');\n  console.log('The \"data to append\" was appended to file!');\n} catch (err) {\n  /* Handle the error */\n}\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-mjs\">import { appendFileSync } from 'fs';\n\nappendFileSync('message.txt', 'data to append', 'utf8');\n</code></pre>\n<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened\nfor appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will\nnot be closed automatically.</p>\n<pre><code class=\"language-mjs\">import { openSync, closeSync, appendFileSync } from 'fs';\n\nlet fd;\n\ntry {\n  fd = openSync('message.txt', 'a');\n  appendFileSync(fd, 'data to append', 'utf8');\n} catch (err) {\n  /* Handle the error */\n} finally {\n  if (fd !== undefined)\n    closeSync(fd);\n}\n</code></pre>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`mode` {string|integer}",
-                  "name": "mode",
-                  "type": "string|integer"
-                },
+              "textRaw": "`fs.chmodSync(path, mode)`",
+              "type": "method",
+              "name": "chmodSync",
+              "meta": {
+                "added": [
+                  "v0.6.7"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer}",
+                      "name": "mode",
+                      "type": "string|integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fchmod.2.html\"><code>fchmod(2)</code></a>. No arguments other than a possible exception\nare given to the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.fchmodSync(fd, mode)`",
-          "type": "method",
-          "name": "fchmodSync",
-          "meta": {
-            "added": [
-              "v0.4.7"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_chmod_path_mode_callback\"><code>fs.chmod()</code></a>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`mode` {string|integer}",
-                  "name": "mode",
-                  "type": "string|integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fchmod.2.html\"><code>fchmod(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.fchown(fd, uid, gid, callback)`",
-          "type": "method",
-          "name": "fchown",
-          "meta": {
-            "added": [
-              "v0.4.7"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+              "textRaw": "`fs.chownSync(path, uid, gid)`",
+              "type": "method",
+              "name": "chownSync",
+              "meta": {
+                "added": [
+                  "v0.1.97"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`uid` {integer}",
+                      "name": "uid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`gid` {integer}",
+                      "name": "gid",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fchown.2.html\"><code>fchown(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.fchownSync(fd, uid, gid)`",
-          "type": "method",
-          "name": "fchownSync",
-          "meta": {
-            "added": [
-              "v0.4.7"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously changes owner and group of a file. Returns <code>undefined</code>.\nThis is the synchronous version of <a href=\"fs.html#fs_fs_chown_path_uid_gid_callback\"><code>fs.chown()</code></a>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fchown.2.html\"><code>fchown(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.fdatasync(fd, callback)`",
-          "type": "method",
-          "name": "fdatasync",
-          "meta": {
-            "added": [
-              "v0.1.96"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+              "textRaw": "`fs.closeSync(fd)`",
+              "type": "method",
+              "name": "closeSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": []
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a>. No arguments other than a possible exception are\ngiven to the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.fdatasyncSync(fd)`",
-          "type": "method",
-          "name": "fdatasyncSync",
-          "meta": {
-            "added": [
-              "v0.1.96"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Closes the file descriptor. Returns <code>undefined</code>.</p>\n<p>Calling <code>fs.closeSync()</code> on any file descriptor (<code>fd</code>) that is currently in use\nthrough any other <code>fs</code> operation may lead to undefined behavior.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/close.2.html\"><code>close(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
+              "textRaw": "`fs.copyFileSync(src, dest[, mode])`",
+              "type": "method",
+              "name": "copyFileSync",
+              "meta": {
+                "added": [
+                  "v8.5.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27044",
+                    "description": "Changed 'flags' argument to 'mode' and imposed stricter type validation."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "params": [
+                    {
+                      "textRaw": "`src` {string|Buffer|URL} source filename to copy",
+                      "name": "src",
+                      "type": "string|Buffer|URL",
+                      "desc": "source filename to copy"
+                    },
+                    {
+                      "textRaw": "`dest` {string|Buffer|URL} destination filename of the copy operation",
+                      "name": "dest",
+                      "type": "string|Buffer|URL",
+                      "desc": "destination filename of the copy operation"
+                    },
+                    {
+                      "textRaw": "`mode` {integer} modifiers for copy operation. **Default:** `0`.",
+                      "name": "mode",
+                      "type": "integer",
+                      "default": "`0`",
+                      "desc": "modifiers for copy operation."
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.fstat(fd[, options], callback)`",
-          "type": "method",
-          "name": "fstat",
-          "meta": {
-            "added": [
-              "v0.1.95"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. Returns <code>undefined</code>. Node.js makes no guarantees about the\natomicity of the copy operation. If an error occurs after the destination file\nhas been opened for writing, Node.js will attempt to remove the destination.</p>\n<p><code>mode</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support\ncopy-on-write, then the operation will fail.</li>\n</ul>\n<pre><code class=\"language-mjs\">import { copyFileSync, constants } from 'fs';\n\n// destination.txt will be created or overwritten by default.\ncopyFileSync('source.txt', 'destination.txt');\nconsole.log('source.txt was copied to destination.txt');\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\ncopyFileSync('source.txt', 'destination.txt', constants.COPYFILE_EXCL);\n</code></pre>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.existsSync(path)`",
+              "type": "method",
+              "name": "existsSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Returns <code>true</code> if the path exists, <code>false</code> otherwise.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_exists_path_callback\"><code>fs.exists()</code></a>.</p>\n<p><code>fs.exists()</code> is deprecated, but <code>fs.existsSync()</code> is not. The <code>callback</code>\nparameter to <code>fs.exists()</code> accepts parameters that are inconsistent with other\nNode.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>\n<pre><code class=\"language-mjs\">import { existsSync } from 'fs';\n\nif (existsSync('/etc/passwd'))\n  console.log('The path exists.');\n</code></pre>"
+            },
+            {
+              "textRaw": "`fs.fchmodSync(fd, mode)`",
+              "type": "method",
+              "name": "fchmodSync",
+              "meta": {
+                "added": [
+                  "v0.4.7"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`stats` {fs.Stats}",
-                      "name": "stats",
-                      "type": "fs.Stats"
+                      "textRaw": "`mode` {string|integer}",
+                      "name": "mode",
+                      "type": "string|integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fstat.2.html\"><code>fstat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where\n<code>stats</code> is an <a href=\"fs.html#fs_class_fs_stats\"><code>fs.Stats</code></a> object. <code>fstat()</code> is identical to <a href=\"fs.html#fs_fs_stat_path_options_callback\"><code>stat()</code></a>,\nexcept that the file to be stat-ed is specified by the file descriptor <code>fd</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.fstatSync(fd[, options])`",
-          "type": "method",
-          "name": "fstatSync",
-          "meta": {
-            "added": [
-              "v0.1.95"
-            ],
-            "changes": [
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Sets the permissions on the file. Returns <code>undefined</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fchmod.2.html\"><code>fchmod(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.Stats}",
-                "name": "return",
-                "type": "fs.Stats"
+              "textRaw": "`fs.fchownSync(fd, uid, gid)`",
+              "type": "method",
+              "name": "fchownSync",
+              "meta": {
+                "added": [
+                  "v0.4.7"
+                ],
+                "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`uid` {integer} The file's new owner's user id.",
+                      "name": "uid",
+                      "type": "integer",
+                      "desc": "The file's new owner's user id."
+                    },
+                    {
+                      "textRaw": "`gid` {integer} The file's new group's group id.",
+                      "name": "gid",
+                      "type": "integer",
+                      "desc": "The file's new group's group id."
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fstat.2.html\"><code>fstat(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.fsync(fd, callback)`",
-          "type": "method",
-          "name": "fsync",
-          "meta": {
-            "added": [
-              "v0.1.96"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Sets the owner of the file. Returns <code>undefined</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fchown.2.html\"><code>fchown(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.fdatasyncSync(fd)`",
+              "type": "method",
+              "name": "fdatasyncSync",
+              "meta": {
+                "added": [
+                  "v0.1.96"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.fsyncSync(fd)`",
-          "type": "method",
-          "name": "fsyncSync",
-          "meta": {
-            "added": [
-              "v0.1.96"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Forces all currently queued I/O operations associated with the file to the\noperating system's synchronized I/O completion state. Refer to the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a> documentation for details. Returns <code>undefined</code>.</p>"
+            },
             {
-              "params": [
+              "textRaw": "`fs.fstatSync(fd[, options])`",
+              "type": "method",
+              "name": "fstatSync",
+              "meta": {
+                "added": [
+                  "v0.1.95"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "return": {
+                    "textRaw": "Returns: {fs.Stats}",
+                    "name": "return",
+                    "type": "fs.Stats"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        }
+                      ]
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.ftruncate(fd[, len], callback)`",
-          "type": "method",
-          "name": "ftruncate",
-          "meta": {
-            "added": [
-              "v0.8.6"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the file descriptor.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fstat.2.html\"><code>fstat(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`len` {integer} **Default:** `0`",
-                  "name": "len",
-                  "type": "integer",
-                  "default": "`0`"
-                },
+              "textRaw": "`fs.fsyncSync(fd)`",
+              "type": "method",
+              "name": "fsyncSync",
+              "meta": {
+                "added": [
+                  "v0.1.96"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/ftruncate.2.html\"><code>ftruncate(2)</code></a>. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>If the file referred to by the file descriptor was larger than <code>len</code> bytes, only\nthe first <code>len</code> bytes will be retained in the file.</p>\n<p>For example, the following program retains only the first four bytes of the\nfile:</p>\n<pre><code class=\"language-js\">console.log(fs.readFileSync('temp.txt', 'utf8'));\n// Prints: Node.js\n\n// get the file descriptor of the file to be truncated\nconst fd = fs.openSync('temp.txt', 'r+');\n\n// Truncate the file to first four bytes\nfs.ftruncate(fd, 4, (err) => {\n  assert.ifError(err);\n  console.log(fs.readFileSync('temp.txt', 'utf8'));\n});\n// Prints: Node\n</code></pre>\n<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the\nextended part is filled with null bytes (<code>'\\0'</code>):</p>\n<pre><code class=\"language-js\">console.log(fs.readFileSync('temp.txt', 'utf8'));\n// Prints: Node.js\n\n// get the file descriptor of the file to be truncated\nconst fd = fs.openSync('temp.txt', 'r+');\n\n// Truncate the file to 10 bytes, whereas the actual size is 7 bytes\nfs.ftruncate(fd, 10, (err) => {\n  assert.ifError(err);\n  console.log(fs.readFileSync('temp.txt'));\n});\n// Prints: &#x3C;Buffer 4e 6f 64 65 2e 6a 73 00 00 00>\n// ('Node.js\\0\\0\\0' in UTF8)\n</code></pre>\n<p>The last three bytes are null bytes (<code>'\\0'</code>), to compensate the over-truncation.</p>"
-        },
-        {
-          "textRaw": "`fs.ftruncateSync(fd[, len])`",
-          "type": "method",
-          "name": "ftruncateSync",
-          "meta": {
-            "added": [
-              "v0.8.6"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Request that all data for the open file descriptor is flushed to the storage\ndevice. The specific implementation is operating system and device specific.\nRefer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a> documentation for more detail. Returns <code>undefined</code>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.ftruncateSync(fd[, len])`",
+              "type": "method",
+              "name": "ftruncateSync",
+              "meta": {
+                "added": [
+                  "v0.8.6"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`len` {integer} **Default:** `0`",
-                  "name": "len",
-                  "type": "integer",
-                  "default": "`0`"
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`len` {integer} **Default:** `0`",
+                      "name": "len",
+                      "type": "integer",
+                      "default": "`0`"
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_ftruncate_fd_len_callback\"><code>fs.ftruncate()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.futimes(fd, atime, mtime, callback)`",
-          "type": "method",
-          "name": "futimes",
-          "meta": {
-            "added": [
-              "v0.4.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v4.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2387",
-                "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Truncates the file descriptor. Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_ftruncate_fd_len_callback\"><code>fs.ftruncate()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
-                {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
-                },
+              "textRaw": "`fs.futimesSync(fd, atime, mtime)`",
+              "type": "method",
+              "name": "futimesSync",
+              "meta": {
+                "added": [
+                  "v0.4.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v4.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/2387",
+                    "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Change the file system timestamps of the object referenced by the supplied file\ndescriptor. See <a href=\"fs.html#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>.</p>\n<p>This function does not work on AIX versions before 7.1, it will return the\nerror <code>UV_ENOSYS</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.futimesSync(fd, atime, mtime)`",
-          "type": "method",
-          "name": "futimesSync",
-          "meta": {
-            "added": [
-              "v0.4.2"
-            ],
-            "changes": [
-              {
-                "version": "v4.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2387",
-                "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronous version of <a href=\"fs.html#fs_fs_futimes_fd_atime_mtime_callback\"><code>fs.futimes()</code></a>. Returns <code>undefined</code>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
+              "textRaw": "`fs.lchmodSync(path, mode)`",
+              "type": "method",
+              "name": "lchmodSync",
+              "meta": {
+                "deprecated": [
+                  "v0.4.7"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {integer}",
+                      "name": "mode",
+                      "type": "integer"
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous version of <a href=\"fs.html#fs_fs_futimes_fd_atime_mtime_callback\"><code>fs.futimes()</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.lchmod(path, mode, callback)`",
-          "type": "method",
-          "name": "lchmod",
-          "meta": {
-            "deprecated": [
-              "v0.4.7"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Changes the permissions on a symbolic link. Returns <code>undefined</code>.</p>\n<p>This method is only implemented on macOS.</p>\n<p>See the POSIX <a href=\"https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2\"><code>lchmod(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {integer}",
-                  "name": "mode",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.lchownSync(path, uid, gid)`",
+              "type": "method",
+              "name": "lchownSync",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v10.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/21498",
+                    "description": "This API is no longer deprecated."
+                  },
+                  {
+                    "version": "v0.4.7",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`uid` {integer} The file's new owner's user id.",
+                      "name": "uid",
+                      "type": "integer",
+                      "desc": "The file's new owner's user id."
+                    },
+                    {
+                      "textRaw": "`gid` {integer} The file's new group's group id.",
+                      "name": "gid",
+                      "type": "integer",
+                      "desc": "The file's new group's group id."
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2\"><code>lchmod(2)</code></a>. No arguments other than a possible exception\nare given to the completion callback.</p>\n<p>Only available on macOS.</p>"
-        },
-        {
-          "textRaw": "`fs.lchmodSync(path, mode)`",
-          "type": "method",
-          "name": "lchmodSync",
-          "meta": {
-            "deprecated": [
-              "v0.4.7"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Set the owner for the path. Returns <code>undefined</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lchown.2.html\"><code>lchown(2)</code></a> documentation for more details.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.lutimesSync(path, atime, mtime)`",
+              "type": "method",
+              "name": "lutimesSync",
+              "meta": {
+                "added": [
+                  "v14.5.0",
+                  "v12.19.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`mode` {integer}",
-                  "name": "mode",
-                  "type": "integer"
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2\"><code>lchmod(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.lchown(path, uid, gid, callback)`",
-          "type": "method",
-          "name": "lchown",
-          "meta": {
-            "changes": [
-              {
-                "version": "v10.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/21498",
-                "description": "This API is no longer deprecated."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v0.4.7",
-                "description": "Documentation-only deprecation."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Change the file system timestamps of the symbolic link referenced by <code>path</code>.\nReturns <code>undefined</code>, or throws an exception when parameters are incorrect or\nthe operation fails. This is the synchronous version of <a href=\"fs.html#fs_fs_lutimes_path_atime_mtime_callback\"><code>fs.lutimes()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.linkSync(existingPath, newPath)`",
+              "type": "method",
+              "name": "linkSync",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `existingPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                },
+                  "params": [
+                    {
+                      "textRaw": "`existingPath` {string|Buffer|URL}",
+                      "name": "existingPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`newPath` {string|Buffer|URL}",
+                      "name": "newPath",
+                      "type": "string|Buffer|URL"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a> documentation for more detail. Returns <code>undefined</code>.</p>"
+            },
+            {
+              "textRaw": "`fs.lstatSync(path[, options])`",
+              "type": "method",
+              "name": "lstatSync",
+              "meta": {
+                "added": [
+                  "v0.1.30"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33716",
+                    "description": "Accepts a `throwIfNoEntry` option to specify whether an exception should be thrown if the entry does not exist."
+                  },
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {fs.Stats}",
+                    "name": "return",
+                    "type": "fs.Stats"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        },
+                        {
+                          "textRaw": "`throwIfNoEntry` {boolean} Whether an exception will be thrown if no file system entry exists, rather than returning `undefined`. **Default:** `true`.",
+                          "name": "throwIfNoEntry",
+                          "type": "boolean",
+                          "default": "`true`",
+                          "desc": "Whether an exception will be thrown if no file system entry exists, rather than returning `undefined`."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/lchown.2.html\"><code>lchown(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.lchownSync(path, uid, gid)`",
-          "type": "method",
-          "name": "lchownSync",
-          "meta": {
-            "changes": [
-              {
-                "version": "v10.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/21498",
-                "description": "This API is no longer deprecated."
+              ],
+              "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the symbolic link referred to by <code>path</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a> documentation for more details.</p>"
+            },
+            {
+              "textRaw": "`fs.mkdirSync(path[, options])`",
+              "type": "method",
+              "name": "mkdirSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.11.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31530",
+                    "description": "In `recursive` mode, the first created path is returned now."
+                  },
+                  {
+                    "version": "v10.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/21875",
+                    "description": "The second argument can now be an `options` object with `recursive` and `mode` properties."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              {
-                "version": "v0.4.7",
-                "description": "Documentation-only deprecation."
-              }
-            ]
-          },
-          "signatures": [
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {string|undefined}",
+                    "name": "return",
+                    "type": "string|undefined"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object|integer}",
+                      "name": "options",
+                      "type": "Object|integer",
+                      "options": [
+                        {
+                          "textRaw": "`recursive` {boolean} **Default:** `false`",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`"
+                        },
+                        {
+                          "textRaw": "`mode` {string|integer} Not supported on Windows. **Default:** `0o777`.",
+                          "name": "mode",
+                          "type": "string|integer",
+                          "default": "`0o777`",
+                          "desc": "Not supported on Windows."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Synchronously creates a directory. Returns <code>undefined</code>, or if <code>recursive</code> is\n<code>true</code>, the first directory path created.\nThis is the synchronous version of <a href=\"fs.html#fs_fs_mkdir_path_options_callback\"><code>fs.mkdir()</code></a>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/mkdir.2.html\"><code>mkdir(2)</code></a> documentation for more details.</p>"
+            },
             {
-              "params": [
+              "textRaw": "`fs.mkdtempSync(prefix[, options])`",
+              "type": "method",
+              "name": "mkdtempSync",
+              "meta": {
+                "added": [
+                  "v5.10.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/39028",
+                    "description": "The `prefix` parameter now accepts an empty string."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+                  "return": {
+                    "textRaw": "Returns: {string}",
+                    "name": "return",
+                    "type": "string"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`prefix` {string}",
+                      "name": "prefix",
+                      "type": "string"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns the created directory path.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_mkdtemp_prefix_options_callback\"><code>fs.mkdtemp()</code></a>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>"
+            },
+            {
+              "textRaw": "`fs.opendirSync(path[, options])`",
+              "type": "method",
+              "name": "opendirSync",
+              "meta": {
+                "added": [
+                  "v12.12.0"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.1.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30114",
+                    "description": "The `bufferSize` option was introduced."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
+                  "return": {
+                    "textRaw": "Returns: {fs.Dir}",
+                    "name": "return",
+                    "type": "fs.Dir"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`bufferSize` {number} Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. **Default:** `32`",
+                          "name": "bufferSize",
+                          "type": "number",
+                          "default": "`32`",
+                          "desc": "Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Synchronously open a directory. See <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a>.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>"
+            },
+            {
+              "textRaw": "`fs.openSync(path[, flags[, mode]])`",
+              "type": "method",
+              "name": "openSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v11.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23767",
+                    "description": "The `flags` argument is now optional and defaults to `'r'`."
+                  },
+                  {
+                    "version": "v9.9.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/18801",
+                    "description": "The `as` and `as+` flags are supported now."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
+                  "return": {
+                    "textRaw": "Returns: {number}",
+                    "name": "return",
+                    "type": "number"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`flags` {string|number} **Default:** `'r'`. See [support of file system `flags`][].",
+                      "name": "flags",
+                      "type": "string|number",
+                      "default": "`'r'`. See [support of file system `flags`][]"
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer} **Default:** `0o666`",
+                      "name": "mode",
+                      "type": "string|integer",
+                      "default": "`0o666`"
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/lchown.2.html\"><code>lchown(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.lutimes(path, atime, mtime, callback)`",
-          "type": "method",
-          "name": "lutimes",
-          "meta": {
-            "added": [
-              "v12.19.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns an integer representing the file descriptor.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>.</p>"
+            },
             {
-              "params": [
+              "textRaw": "`fs.readdirSync(path[, options])`",
+              "type": "method",
+              "name": "readdirSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22020",
+                    "description": "New option `withFileTypes` was added."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+                  "return": {
+                    "textRaw": "Returns: {string[]|Buffer[]|fs.Dirent[]}",
+                    "name": "return",
+                    "type": "string[]|Buffer[]|fs.Dirent[]"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`withFileTypes` {boolean} **Default:** `false`",
+                          "name": "withFileTypes",
+                          "type": "boolean",
+                          "default": "`false`"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Reads the contents of the directory.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> documentation for more details.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe filenames returned will be passed as <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the result will contain\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> objects.</p>"
+            },
+            {
+              "textRaw": "`fs.readFileSync(path[, options])`",
+              "type": "method",
+              "name": "readFileSync",
+              "meta": {
+                "added": [
+                  "v0.1.8"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `path` parameter can be a file descriptor now."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
+                  "return": {
+                    "textRaw": "Returns: {string|Buffer}",
+                    "name": "return",
+                    "type": "string|Buffer"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL|integer} filename or file descriptor",
+                      "name": "path",
+                      "type": "string|Buffer|URL|integer",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `null`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'r'`",
+                          "desc": "See [support of file system `flags`][]."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns the contents of the <code>path</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_readfile_path_options_callback\"><code>fs.readFile()</code></a>.</p>\n<p>If the <code>encoding</code> option is specified then this function returns a\nstring. Otherwise it returns a buffer.</p>\n<p>Similar to <a href=\"fs.html#fs_fs_readfile_path_options_callback\"><code>fs.readFile()</code></a>, when the path is a directory, the behavior of\n<code>fs.readFileSync()</code> is platform-specific.</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n\n// macOS, Linux, and Windows\nreadFileSync('&#x3C;directory>');\n// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]\n\n//  FreeBSD\nreadFileSync('&#x3C;directory>'); // => &#x3C;data>\n</code></pre>"
+            },
+            {
+              "textRaw": "`fs.readlinkSync(path[, options])`",
+              "type": "method",
+              "name": "readlinkSync",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
-                },
+                  "return": {
+                    "textRaw": "Returns: {string|Buffer}",
+                    "name": "return",
+                    "type": "string|Buffer"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns the symbolic link's string value.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a> documentation for more details.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe link path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>"
+            },
+            {
+              "textRaw": "`fs.readSync(fd, buffer, offset, length, position)`",
+              "type": "method",
+              "name": "readSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4518",
+                    "description": "The `length` parameter can now be `0`."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number}",
+                    "name": "return",
+                    "type": "number"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
+                      "name": "buffer",
+                      "type": "Buffer|TypedArray|DataView"
+                    },
+                    {
+                      "textRaw": "`offset` {integer}",
+                      "name": "offset",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`length` {integer}",
+                      "name": "length",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`position` {integer|bigint}",
+                      "name": "position",
+                      "type": "integer|bigint"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Changes the access and modification times of a file in the same way as\n<a href=\"fs.html#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>, with the difference that if the path refers to a symbolic\nlink, then the link is not dereferenced: instead, the timestamps of the\nsymbolic link itself are changed.</p>\n<p>No arguments other than a possible exception are given to the completion\ncallback.</p>"
-        },
-        {
-          "textRaw": "`fs.lutimesSync(path, atime, mtime)`",
-          "type": "method",
-          "name": "lutimesSync",
-          "meta": {
-            "added": [
-              "v12.19.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns the number of <code>bytesRead</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
-                {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Change the file system timestamps of the symbolic link referenced by <code>path</code>.\nReturns <code>undefined</code>, or throws an exception when parameters are incorrect or\nthe operation fails. This is the synchronous version of <a href=\"fs.html#fs_fs_lutimes_path_atime_mtime_callback\"><code>fs.lutimes()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.link(existingPath, newPath, callback)`",
-          "type": "method",
-          "name": "link",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `existingPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+              "textRaw": "`fs.readSync(fd, buffer, [options])`",
+              "type": "method",
+              "name": "readSync",
+              "meta": {
+                "added": [
+                  "v13.13.0",
+                  "v12.17.0"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.13.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/32460",
+                    "description": "Options object can be passed in to make offset, length and position optional."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`existingPath` {string|Buffer|URL}",
-                  "name": "existingPath",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`newPath` {string|Buffer|URL}",
-                  "name": "newPath",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number}",
+                    "name": "return",
+                    "type": "number"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
+                      "name": "buffer",
+                      "type": "Buffer|TypedArray|DataView"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`offset` {integer} **Default:** `0`",
+                          "name": "offset",
+                          "type": "integer",
+                          "default": "`0`"
+                        },
+                        {
+                          "textRaw": "`length` {integer} **Default:** `buffer.byteLength`",
+                          "name": "length",
+                          "type": "integer",
+                          "default": "`buffer.byteLength`"
+                        },
+                        {
+                          "textRaw": "`position` {integer|bigint} **Default:** `null`",
+                          "name": "position",
+                          "type": "integer|bigint",
+                          "default": "`null`"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>. No arguments other than a possible exception are given to\nthe completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.linkSync(existingPath, newPath)`",
-          "type": "method",
-          "name": "linkSync",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `existingPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns the number of <code>bytesRead</code>.</p>\n<p>Similar to the above <code>fs.readSync</code> function, this version takes an optional <code>options</code> object.\nIf no <code>options</code> object is specified, it will default with the above values.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`existingPath` {string|Buffer|URL}",
-                  "name": "existingPath",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.readvSync(fd, buffers[, position])`",
+              "type": "method",
+              "name": "readvSync",
+              "meta": {
+                "added": [
+                  "v13.13.0",
+                  "v12.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`newPath` {string|Buffer|URL}",
-                  "name": "newPath",
-                  "type": "string|Buffer|URL"
+                  "return": {
+                    "textRaw": "Returns: {number} The number of bytes read.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The number of bytes read."
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffers` {ArrayBufferView[]}",
+                      "name": "buffers",
+                      "type": "ArrayBufferView[]"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.lstat(path[, options], callback)`",
-          "type": "method",
-          "name": "lstat",
-          "meta": {
-            "added": [
-              "v0.1.30"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_readv_fd_buffers_position_callback\"><code>fs.readv()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.realpathSync(path[, options])`",
+              "type": "method",
+              "name": "realpathSync",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/13028",
+                    "description": "Pipe/Socket resolve support was added."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v6.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7899",
+                    "description": "Calling `realpathSync` now works again for various edge cases on Windows."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3594",
+                    "description": "The `cache` parameter was removed."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string|Buffer}",
+                    "name": "return",
+                    "type": "string|Buffer"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Returns the resolved pathname.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_realpath_path_options_callback\"><code>fs.realpath()</code></a>.</p>"
+            },
+            {
+              "textRaw": "`fs.realpathSync.native(path[, options])`",
+              "type": "method",
+              "name": "native",
+              "meta": {
+                "added": [
+                  "v9.2.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string|Buffer}",
+                    "name": "return",
+                    "type": "string|Buffer"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`stats` {fs.Stats}",
-                      "name": "stats",
-                      "type": "fs.Stats"
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where\n<code>stats</code> is a <a href=\"fs.html#fs_class_fs_stats\"><code>fs.Stats</code></a> object. <code>lstat()</code> is identical to <code>stat()</code>,\nexcept that if <code>path</code> is a symbolic link, then the link itself is stat-ed,\nnot the file that it refers to.</p>"
-        },
-        {
-          "textRaw": "`fs.lstatSync(path[, options])`",
-          "type": "method",
-          "name": "lstatSync",
-          "meta": {
-            "added": [
-              "v0.1.30"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.Stats}",
-                "name": "return",
-                "type": "fs.Stats"
+              "textRaw": "`fs.renameSync(oldPath, newPath)`",
+              "type": "method",
+              "name": "renameSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `oldPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "`oldPath` {string|Buffer|URL}",
+                      "name": "oldPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`newPath` {string|Buffer|URL}",
+                      "name": "newPath",
+                      "type": "string|Buffer|URL"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.mkdir(path[, options], callback)`",
-          "type": "method",
-          "name": "mkdir",
-          "meta": {
-            "added": [
-              "v0.1.8"
-            ],
-            "changes": [
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/31530",
-                "description": "In `recursive` mode, the callback now receives the first created path as an argument."
-              },
-              {
-                "version": "v10.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/21875",
-                "description": "The second argument can now be an `options` object with `recursive` and `mode` properties."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Renames the file from <code>oldPath</code> to <code>newPath</code>. Returns <code>undefined</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a> documentation for more details.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.rmdirSync(path[, options])`",
+              "type": "method",
+              "name": "rmdirSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35579",
+                    "description": "The `recursive` option is deprecated, use `fs.rmSync` instead."
+                  },
+                  {
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30644",
+                    "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
+                  },
+                  {
+                    "version": "v12.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29168",
+                    "description": "The `recursive`, `maxBusyTries`, and `emfileWait` options are now supported."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameters can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|integer}",
-                  "name": "options",
-                  "type": "Object|integer",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`recursive` {boolean} **Default:** `false`",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`mode` {string|integer} Not supported on Windows. **Default:** `0o777`.",
-                      "name": "mode",
-                      "type": "string|integer",
-                      "default": "`0o777`",
-                      "desc": "Not supported on Windows."
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/rmdir.2.html\"><code>rmdir(2)</code></a>. Returns <code>undefined</code>.</p>\n<p>Using <code>fs.rmdirSync()</code> on a file (not a directory) results in an <code>ENOENT</code> error\non Windows and an <code>ENOTDIR</code> error on POSIX.</p>\n<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command\n<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths\nthat represent files will be deleted. The permissive behavior of the\n<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in\nthe future.</p>"
+            },
+            {
+              "textRaw": "`fs.rmSync(path[, options])`",
+              "type": "method",
+              "name": "rmSync",
+              "meta": {
+                "added": [
+                  "v14.14.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`force` {boolean} When `true`, exceptions will be ignored if `path` does not exist. **Default:** `false`.",
+                          "name": "force",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "When `true`, exceptions will be ignored if `path` does not exist."
+                        },
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive directory removal. In recursive mode operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously creates a directory.</p>\n<p>The callback is given a possible exception and, if <code>recursive</code> is <code>true</code>, the\nfirst directory path created, <code>(err, [path])</code>.</p>\n<p>The optional <code>options</code> argument can be an integer specifying mode (permission\nand sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>\nproperty indicating whether parent directories should be created. Calling\n<code>fs.mkdir()</code> when <code>path</code> is a directory that exists results in an error only\nwhen <code>recursive</code> is false.</p>\n<pre><code class=\"language-js\">// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.\nfs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {\n  if (err) throw err;\n});\n</code></pre>\n<p>On Windows, using <code>fs.mkdir()</code> on the root directory even with recursion will\nresult in an error:</p>\n<pre><code class=\"language-js\">fs.mkdir('/', { recursive: true }, (err) => {\n  // => [Error: EPERM: operation not permitted, mkdir 'C:\\']\n});\n</code></pre>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/mkdir.2.html\"><code>mkdir(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.mkdirSync(path[, options])`",
-          "type": "method",
-          "name": "mkdirSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/31530",
-                "description": "In `recursive` mode, the first created path is returned now."
-              },
-              {
-                "version": "v10.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/21875",
-                "description": "The second argument can now be an `options` object with `recursive` and `mode` properties."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously removes files and directories (modeled on the standard POSIX <code>rm</code>\nutility). Returns <code>undefined</code>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string|undefined}",
-                "name": "return",
-                "type": "string|undefined"
+              "textRaw": "`fs.statSync(path[, options])`",
+              "type": "method",
+              "name": "statSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33716",
+                    "description": "Accepts a `throwIfNoEntry` option to specify whether an exception should be thrown if the entry does not exist."
+                  },
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|integer}",
-                  "name": "options",
-                  "type": "Object|integer",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {fs.Stats}",
+                    "name": "return",
+                    "type": "fs.Stats"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`recursive` {boolean} **Default:** `false`",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`mode` {string|integer} Not supported on Windows. **Default:** `0o777`.",
-                      "name": "mode",
-                      "type": "string|integer",
-                      "default": "`0o777`",
-                      "desc": "Not supported on Windows."
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        },
+                        {
+                          "textRaw": "`throwIfNoEntry` {boolean} Whether an exception will be thrown if no file system entry exists, rather than returning `undefined`. **Default:** `true`.",
+                          "name": "throwIfNoEntry",
+                          "type": "boolean",
+                          "default": "`true`",
+                          "desc": "Whether an exception will be thrown if no file system entry exists, rather than returning `undefined`."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously creates a directory. Returns <code>undefined</code>, or if <code>recursive</code> is\n<code>true</code>, the first directory path created.\nThis is the synchronous version of <a href=\"fs.html#fs_fs_mkdir_path_options_callback\"><code>fs.mkdir()</code></a>.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/mkdir.2.html\"><code>mkdir(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.mkdtemp(prefix[, options], callback)`",
-          "type": "method",
-          "name": "mkdtemp",
-          "meta": {
-            "added": [
-              "v5.10.0"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v6.2.1",
-                "pr-url": "https://github.com/nodejs/node/pull/6828",
-                "description": "The `callback` parameter is optional now."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the path.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`prefix` {string}",
-                  "name": "prefix",
-                  "type": "string"
-                },
+              "textRaw": "`fs.symlinkSync(target, path[, type])`",
+              "type": "method",
+              "name": "symlinkSync",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v12.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23724",
+                    "description": "If the `type` argument is left undefined, Node will autodetect `target` type and automatically select `dir` or `file`."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `target` and `path` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    }
-                  ]
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                      "textRaw": "`target` {string|Buffer|URL}",
+                      "name": "target",
+                      "type": "string|Buffer|URL"
+                    },
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`directory` {string}",
-                      "name": "directory",
+                      "textRaw": "`type` {string}",
+                      "name": "type",
                       "type": "string"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Creates a unique temporary directory.</p>\n<p>Generates six random characters to be appended behind a required\n<code>prefix</code> to create a unique temporary directory. Due to platform\ninconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,\nnotably the BSDs, can return more than six random characters, and replace\ntrailing <code>X</code> characters in <code>prefix</code> with random characters.</p>\n<p>The created directory path is passed as a string to the callback's second\nparameter.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>\n<pre><code class=\"language-js\">fs.mkdtemp(path.join(os.tmpdir(), 'foo-'), (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Prints: /tmp/foo-itXde2 or C:\\Users\\...\\AppData\\Local\\Temp\\foo-itXde2\n});\n</code></pre>\n<p>The <code>fs.mkdtemp()</code> method will append the six randomly selected characters\ndirectly to the <code>prefix</code> string. For instance, given a directory <code>/tmp</code>, if the\nintention is to create a temporary directory <em>within</em> <code>/tmp</code>, the <code>prefix</code>\nmust end with a trailing platform-specific path separator\n(<code>require('path').sep</code>).</p>\n<pre><code class=\"language-js\">// The parent directory for the new temporary directory\nconst tmpDir = os.tmpdir();\n\n// This method is *INCORRECT*:\nfs.mkdtemp(tmpDir, (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Will print something similar to `/tmpabc123`.\n  // A new temporary directory is created at the file system root\n  // rather than *within* the /tmp directory.\n});\n\n// This method is *CORRECT*:\nconst { sep } = require('path');\nfs.mkdtemp(`${tmpDir}${sep}`, (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Will print something similar to `/tmp/abc123`.\n  // A new temporary directory is created within\n  // the /tmp directory.\n});\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.mkdtempSync(prefix[, options])`",
-          "type": "method",
-          "name": "mkdtempSync",
-          "meta": {
-            "added": [
-              "v5.10.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_symlink_target_path_type_callback\"><code>fs.symlink()</code></a>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string}",
-                "name": "return",
-                "type": "string"
+              "textRaw": "`fs.truncateSync(path[, len])`",
+              "type": "method",
+              "name": "truncateSync",
+              "meta": {
+                "added": [
+                  "v0.8.6"
+                ],
+                "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`prefix` {string}",
-                  "name": "prefix",
-                  "type": "string"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`len` {integer} **Default:** `0`",
+                      "name": "len",
+                      "type": "integer",
+                      "default": "`0`"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the created directory path.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_mkdtemp_prefix_options_callback\"><code>fs.mkdtemp()</code></a>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>"
-        },
-        {
-          "textRaw": "`fs.open(path[, flags[, mode]], callback)`",
-          "type": "method",
-          "name": "open",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v11.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23767",
-                "description": "The `flags` argument is now optional and defaults to `'r'`."
-              },
-              {
-                "version": "v9.9.0",
-                "pr-url": "https://github.com/nodejs/node/pull/18801",
-                "description": "The `as` and `as+` modes are supported now."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Truncates the file. Returns <code>undefined</code>. A file descriptor can also be\npassed as the first argument. In this case, <code>fs.ftruncateSync()</code> is called.</p>\n<p>Passing a file descriptor is deprecated and may result in an error being thrown\nin the future.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`flags` {string|number} See [support of file system `flags`][]. **Default:** `'r'`.",
-                  "name": "flags",
-                  "type": "string|number",
-                  "default": "`'r'`",
-                  "desc": "See [support of file system `flags`][]."
-                },
-                {
-                  "textRaw": "`mode` {string|integer} **Default:** `0o666` (readable and writable)",
-                  "name": "mode",
-                  "type": "string|integer",
-                  "default": "`0o666` (readable and writable)"
-                },
+              "textRaw": "`fs.unlinkSync(path)`",
+              "type": "method",
+              "name": "unlinkSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                  "params": [
                     {
-                      "textRaw": "`fd` {integer}",
-                      "name": "fd",
-                      "type": "integer"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous file open. See <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was\ncreated. On Windows, only the write permission can be manipulated; see\n<a href=\"fs.html#fs_fs_chmod_path_mode_callback\"><code>fs.chmod()</code></a>.</p>\n<p>The callback gets two arguments <code>(err, fd)</code>.</p>\n<p>Some characters (<code>&#x3C; > : \" / \\ | ? *</code>) are reserved under Windows as documented\nby <a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file\">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains\na colon, Node.js will open a file system stream, as described by\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams\">this MSDN page</a>.</p>\n<p>Functions based on <code>fs.open()</code> exhibit this behavior as well:\n<code>fs.writeFile()</code>, <code>fs.readFile()</code>, etc.</p>"
-        },
-        {
-          "textRaw": "`fs.opendir(path[, options], callback)`",
-          "type": "method",
-          "name": "opendir",
-          "meta": {
-            "added": [
-              "v12.12.0"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30114",
-                "description": "The `bufferSize` option was introduced."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>. Returns <code>undefined</code>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.utimesSync(path, atime, mtime)`",
+              "type": "method",
+              "name": "utimesSync",
+              "meta": {
+                "added": [
+                  "v0.4.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/11919",
+                    "description": "`NaN`, `Infinity`, and `-Infinity` are no longer valid time specifiers."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v4.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/2387",
+                    "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`bufferSize` {number} Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. **Default:** `32`",
-                      "name": "bufferSize",
-                      "type": "number",
-                      "default": "`32`",
-                      "desc": "Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage."
-                    }
-                  ]
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
                     },
                     {
-                      "textRaw": "`dir` {fs.Dir}",
-                      "name": "dir",
-                      "type": "fs.Dir"
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously open a directory. See <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a>.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\"><code>fs.Dir</code></a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>"
-        },
-        {
-          "textRaw": "`fs.opendirSync(path[, options])`",
-          "type": "method",
-          "name": "opendirSync",
-          "meta": {
-            "added": [
-              "v12.12.0"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30114",
-                "description": "The `bufferSize` option was introduced."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.Dir}",
-                "name": "return",
-                "type": "fs.Dir"
+              "textRaw": "`fs.writeFileSync(file, data[, options])`",
+              "type": "method",
+              "name": "writeFileSync",
+              "meta": {
+                "added": [
+                  "v0.1.29"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `data` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `data` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `data` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `data` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `file` parameter can be a file descriptor now."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
+                      "textRaw": "`file` {string|Buffer|URL|integer} filename or file descriptor",
+                      "name": "file",
+                      "type": "string|Buffer|URL|integer",
+                      "desc": "filename or file descriptor"
                     },
                     {
-                      "textRaw": "`bufferSize` {number} Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. **Default:** `32`",
-                      "name": "bufferSize",
-                      "type": "number",
-                      "default": "`32`",
-                      "desc": "Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage."
+                      "textRaw": "`data` {string|Buffer|TypedArray|DataView|Object}",
+                      "name": "data",
+                      "type": "string|Buffer|TypedArray|DataView|Object"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'w'`",
+                          "desc": "See [support of file system `flags`][]."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously open a directory. See <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a>.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\"><code>fs.Dir</code></a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>"
-        },
-        {
-          "textRaw": "`fs.openSync(path[, flags, mode])`",
-          "type": "method",
-          "name": "openSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v11.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23767",
-                "description": "The `flags` argument is now optional and defaults to `'r'`."
-              },
-              {
-                "version": "v9.9.0",
-                "pr-url": "https://github.com/nodejs/node/pull/18801",
-                "description": "The `as` and `as+` modes are supported now."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns <code>undefined</code>.</p>\n<p>If <code>data</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"fs.html#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_writefile_file_data_options_callback\"><code>fs.writeFile()</code></a>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {number}",
-                "name": "return",
-                "type": "number"
-              },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`flags` {string|number} **Default:** `'r'`. See [support of file system `flags`][].",
-                  "name": "flags",
-                  "type": "string|number",
-                  "default": "`'r'`. See [support of file system `flags`][]"
-                },
-                {
-                  "textRaw": "`mode` {string|integer} **Default:** `0o666`",
-                  "name": "mode",
-                  "type": "string|integer",
-                  "default": "`0o666`"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns an integer representing the file descriptor.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.read(fd, buffer, offset, length, position, callback)`",
-          "type": "method",
-          "name": "read",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `buffer` parameter can now be any `TypedArray`, or a `DataView`."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `buffer` parameter can now be a `Uint8Array`."
+              "textRaw": "`fs.writeSync(fd, buffer[, offset[, length[, position]]])`",
+              "type": "method",
+              "name": "writeSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `buffer` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `buffer` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `buffer` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v7.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7856",
+                    "description": "The `offset` and `length` parameters are optional now."
+                  }
+                ]
               },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/4518",
-                "description": "The `length` parameter can now be `0`."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
-                },
-                {
-                  "textRaw": "`offset` {integer}",
-                  "name": "offset",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`length` {integer}",
-                  "name": "length",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number} The number of bytes written.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The number of bytes written."
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView|string|Object}",
+                      "name": "buffer",
+                      "type": "Buffer|TypedArray|DataView|string|Object"
                     },
                     {
-                      "textRaw": "`bytesRead` {integer}",
-                      "name": "bytesRead",
+                      "textRaw": "`offset` {integer}",
+                      "name": "offset",
                       "type": "integer"
                     },
                     {
-                      "textRaw": "`buffer` {Buffer}",
-                      "name": "buffer",
-                      "type": "Buffer"
+                      "textRaw": "`length` {integer}",
+                      "name": "length",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Read data from the file specified by <code>fd</code>.</p>\n<p><code>buffer</code> is the buffer that the data (read from the fd) will be written to.</p>\n<p><code>offset</code> is the offset in the buffer to start writing at.</p>\n<p><code>length</code> is an integer specifying the number of bytes to read.</p>\n<p><code>position</code> is an argument specifying where to begin reading from in the file.\nIf <code>position</code> is <code>null</code>, data will be read from the current file position,\nand the file position will be updated.\nIf <code>position</code> is an integer, the file position will remain unchanged.</p>\n<p>The callback is given the three arguments, <code>(err, bytesRead, buffer)</code>.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> and <code>buffer</code> properties.</p>"
-        },
-        {
-          "textRaw": "`fs.read(fd, [options,] callback)`",
-          "type": "method",
-          "name": "read",
-          "meta": {
-            "added": [
-              "v12.17.0"
-            ],
-            "changes": [
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/31402",
-                "description": "Options object can be passed in to make Buffer, offset, length and position optional"
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>If <code>buffer</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_write_fd_buffer_offset_length_position_callback\"><code>fs.write(fd, buffer...)</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.writeSync(fd, string[, position[, encoding]])`",
+              "type": "method",
+              "name": "writeSync",
+              "meta": {
+                "added": [
+                  "v0.11.5"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `string` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `string` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v7.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7856",
+                    "description": "The `position` parameter is optional now."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number} The number of bytes written.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The number of bytes written."
+                  },
+                  "params": [
                     {
-                      "textRaw": "`buffer` {Buffer|TypedArray|DataView} **Default:** `Buffer.alloc(16384)`",
-                      "name": "buffer",
-                      "type": "Buffer|TypedArray|DataView",
-                      "default": "`Buffer.alloc(16384)`"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`offset` {integer} **Default:** `0`",
-                      "name": "offset",
-                      "type": "integer",
-                      "default": "`0`"
+                      "textRaw": "`string` {string|Object}",
+                      "name": "string",
+                      "type": "string|Object"
                     },
                     {
-                      "textRaw": "`length` {integer} **Default:** `buffer.length`",
-                      "name": "length",
-                      "type": "integer",
-                      "default": "`buffer.length`"
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`position` {integer} **Default:** `null`",
-                      "name": "position",
-                      "type": "integer",
-                      "default": "`null`"
+                      "textRaw": "`encoding` {string}",
+                      "name": "encoding",
+                      "type": "string"
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>If <code>string</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_write_fd_string_position_encoding_callback\"><code>fs.write(fd, string...)</code></a>.</p>"
+            },
+            {
+              "textRaw": "`fs.writevSync(fd, buffers[, position])`",
+              "type": "method",
+              "name": "writevSync",
+              "meta": {
+                "added": [
+                  "v12.9.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number} The number of bytes written.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The number of bytes written."
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`bytesRead` {integer}",
-                      "name": "bytesRead",
-                      "type": "integer"
+                      "textRaw": "`buffers` {ArrayBufferView[]}",
+                      "name": "buffers",
+                      "type": "ArrayBufferView[]"
                     },
                     {
-                      "textRaw": "`buffer` {Buffer}",
-                      "name": "buffer",
-                      "type": "Buffer"
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
+              ],
+              "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_writev_fd_buffers_position_callback\"><code>fs.writev()</code></a>.</p>"
             }
           ],
-          "desc": "<p>Similar to the above <code>fs.read</code> function, this version takes an optional <code>options</code> object.\nIf no <code>options</code> object is specified, it will default with the above values.</p>"
+          "type": "module",
+          "displayName": "Synchronous API"
         },
         {
-          "textRaw": "`fs.readdir(path[, options], callback)`",
-          "type": "method",
-          "name": "readdir",
-          "meta": {
-            "added": [
-              "v0.1.8"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22020",
-                "description": "New option `withFileTypes` was added."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/5616",
-                "description": "The `options` parameter was added."
-              }
-            ]
-          },
-          "signatures": [
+          "textRaw": "Common Objects",
+          "name": "common_objects",
+          "desc": "<p>The common objects are shared by all of the file system API variants\n(promise, callback, and synchronous).</p>",
+          "classes": [
             {
-              "params": [
+              "textRaw": "Class: `fs.Dir`",
+              "type": "class",
+              "name": "fs.Dir",
+              "meta": {
+                "added": [
+                  "v12.12.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>A class representing a directory stream.</p>\n<p>Created by <a href=\"fs.html#fs_fs_opendir_path_options_callback\"><code>fs.opendir()</code></a>, <a href=\"fs.html#fs_fs_opendirsync_path_options\"><code>fs.opendirSync()</code></a>, or\n<a href=\"fs.html#fs_fspromises_opendir_path_options\"><code>fsPromises.opendir()</code></a>.</p>\n<pre><code class=\"language-mjs\">import { opendir } from 'fs/promises';\n\ntry {\n  const dir = await opendir('./');\n  for await (const dirent of dir)\n    console.log(dirent.name);\n} catch (err) {\n  console.error(err);\n}\n</code></pre>\n<p>When using the async iterator, the <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a> object will be automatically\nclosed after the iterator exits.</p>",
+              "methods": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`dir.close()`",
+                  "type": "method",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {Promise}",
+                        "name": "return",
+                        "type": "Promise"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Asynchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>\n<p>A promise is returned that will be resolved after the resource has been\nclosed.</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "textRaw": "`dir.close(callback)`",
+                  "type": "method",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    },
+                      "params": [
+                        {
+                          "textRaw": "`callback` {Function}",
+                          "name": "callback",
+                          "type": "Function",
+                          "options": [
+                            {
+                              "textRaw": "`err` {Error}",
+                              "name": "err",
+                              "type": "Error"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Asynchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>\n<p>The <code>callback</code> will be called after the resource handle has been closed.</p>"
+                },
+                {
+                  "textRaw": "`dir.closeSync()`",
+                  "type": "method",
+                  "name": "closeSync",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`withFileTypes` {boolean} **Default:** `false`",
-                      "name": "withFileTypes",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Synchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "`dir.read()`",
+                  "type": "method",
+                  "name": "read",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                      "return": {
+                        "textRaw": "Returns: {Promise} containing {fs.Dirent|null}",
+                        "name": "return",
+                        "type": "Promise",
+                        "desc": "containing {fs.Dirent|null}"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Asynchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>.</p>\n<p>A promise is returned that will be resolved with an <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>, or <code>null</code>\nif there are no more directory entries to read.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory might not be\nincluded in the iteration results.</p>"
+                },
+                {
+                  "textRaw": "`dir.read(callback)`",
+                  "type": "method",
+                  "name": "read",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`files` {string[]|Buffer[]|fs.Dirent[]}",
-                      "name": "files",
-                      "type": "string[]|Buffer[]|fs.Dirent[]"
+                      "params": [
+                        {
+                          "textRaw": "`callback` {Function}",
+                          "name": "callback",
+                          "type": "Function",
+                          "options": [
+                            {
+                              "textRaw": "`err` {Error}",
+                              "name": "err",
+                              "type": "Error"
+                            },
+                            {
+                              "textRaw": "`dirent` {fs.Dirent|null}",
+                              "name": "dirent",
+                              "type": "fs.Dirent|null"
+                            }
+                          ]
+                        }
+                      ]
                     }
-                  ]
+                  ],
+                  "desc": "<p>Asynchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>.</p>\n<p>After the read is completed, the <code>callback</code> will be called with an\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>, or <code>null</code> if there are no more directory entries to read.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory might not be\nincluded in the iteration results.</p>"
+                },
+                {
+                  "textRaw": "`dir.readSync()`",
+                  "type": "method",
+                  "name": "readSync",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {fs.Dirent|null}",
+                        "name": "return",
+                        "type": "fs.Dirent|null"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Synchronously read the next directory entry as an <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>. See the\nPOSIX <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> documentation for more detail.</p>\n<p>If there are no more directory entries to read, <code>null</code> will be returned.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory might not be\nincluded in the iteration results.</p>"
+                },
+                {
+                  "textRaw": "`dir[Symbol.asyncIterator]()`",
+                  "type": "method",
+                  "name": "[Symbol.asyncIterator]",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {AsyncIterator} of {fs.Dirent}",
+                        "name": "return",
+                        "type": "AsyncIterator",
+                        "desc": "of {fs.Dirent}"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Asynchronously iterates over the directory until all entries have\nbeen read. Refer to the POSIX <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> documentation for more detail.</p>\n<p>Entries returned by the async iterator are always an <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>.\nThe <code>null</code> case from <code>dir.read()</code> is handled internally.</p>\n<p>See <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a> for an example.</p>\n<p>Directory entries returned by this iterator are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory might not be\nincluded in the iteration results.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`path` {string}",
+                  "type": "string",
+                  "name": "path",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The read-only path of this directory as was provided to <a href=\"fs.html#fs_fs_opendir_path_options_callback\"><code>fs.opendir()</code></a>,\n<a href=\"fs.html#fs_fs_opendirsync_path_options\"><code>fs.opendirSync()</code></a>, or <a href=\"fs.html#fs_fspromises_opendir_path_options\"><code>fsPromises.opendir()</code></a>.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a>. Reads the contents of a directory.\nThe callback gets two arguments <code>(err, files)</code> where <code>files</code> is an array of\nthe names of the files in the directory excluding <code>'.'</code> and <code>'..'</code>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe filenames returned will be passed as <code>Buffer</code> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the <code>files</code> array will contain\n<a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a> objects.</p>"
-        },
-        {
-          "textRaw": "`fs.readdirSync(path[, options])`",
-          "type": "method",
-          "name": "readdirSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22020",
-                "description": "New option `withFileTypes` was added."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string[]|Buffer[]|fs.Dirent[]}",
-                "name": "return",
-                "type": "string[]|Buffer[]|fs.Dirent[]"
+              "textRaw": "Class: `fs.Dirent`",
+              "type": "class",
+              "name": "fs.Dirent",
+              "meta": {
+                "added": [
+                  "v10.10.0"
+                ],
+                "changes": []
               },
-              "params": [
+              "desc": "<p>A representation of a directory entry, which can be a file or a subdirectory\nwithin the directory, as returned by reading from an <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a>. The\ndirectory entry is a combination of the file name and file type pairs.</p>\n<p>Additionally, when <a href=\"fs.html#fs_fs_readdir_path_options_callback\"><code>fs.readdir()</code></a> or <a href=\"fs.html#fs_fs_readdirsync_path_options\"><code>fs.readdirSync()</code></a> is called with\nthe <code>withFileTypes</code> option set to <code>true</code>, the resulting array is filled with\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> objects, rather than strings or <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>s.</p>",
+              "methods": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`dirent.isBlockDevice()`",
+                  "type": "method",
+                  "name": "isBlockDevice",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a block device.</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    },
+                  "textRaw": "`dirent.isCharacterDevice()`",
+                  "type": "method",
+                  "name": "isCharacterDevice",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`withFileTypes` {boolean} **Default:** `false`",
-                      "name": "withFileTypes",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe filenames returned will be passed as <code>Buffer</code> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the result will contain\n<a href=\"fs.html#fs_class_fs_dirent\"><code>fs.Dirent</code></a> objects.</p>"
-        },
-        {
-          "textRaw": "`fs.readFile(path[, options], callback)`",
-          "type": "method",
-          "name": "readFile",
-          "meta": {
-            "added": [
-              "v0.1.29"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v5.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3740",
-                "description": "The `callback` will always be called with `null` as the `error` parameter in case of success."
-              },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `path` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a character device.</p>"
+                },
                 {
-                  "textRaw": "`path` {string|Buffer|URL|integer} filename or file descriptor",
-                  "name": "path",
-                  "type": "string|Buffer|URL|integer",
-                  "desc": "filename or file descriptor"
+                  "textRaw": "`dirent.isDirectory()`",
+                  "type": "method",
+                  "name": "isDirectory",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a file system\ndirectory.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
+                  "textRaw": "`dirent.isFIFO()`",
+                  "type": "method",
+                  "name": "isFIFO",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `null`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`null`"
-                    },
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a first-in-first-out\n(FIFO) pipe.</p>"
+                },
+                {
+                  "textRaw": "`dirent.isFile()`",
+                  "type": "method",
+                  "name": "isFile",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'r'`",
-                      "desc": "See [support of file system `flags`][]."
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a regular file.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "`dirent.isSocket()`",
+                  "type": "method",
+                  "name": "isSocket",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a socket.</p>"
+                },
+                {
+                  "textRaw": "`dirent.isSymbolicLink()`",
+                  "type": "method",
+                  "name": "isSymbolicLink",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`data` {string|Buffer}",
-                      "name": "data",
-                      "type": "string|Buffer"
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a symbolic link.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`name` {string|Buffer}",
+                  "type": "string|Buffer",
+                  "name": "name",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The file name that this <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object refers to. The type of this\nvalue is determined by the <code>options.encoding</code> passed to <a href=\"fs.html#fs_fs_readdir_path_options_callback\"><code>fs.readdir()</code></a> or\n<a href=\"fs.html#fs_fs_readdirsync_path_options\"><code>fs.readdirSync()</code></a>.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<pre><code class=\"language-js\">fs.readFile('/etc/passwd', (err, data) => {\n  if (err) throw err;\n  console.log(data);\n});\n</code></pre>\n<p>The callback is passed two arguments <code>(err, data)</code>, where <code>data</code> is the\ncontents of the file.</p>\n<p>If no encoding is specified, then the raw buffer is returned.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-js\">fs.readFile('/etc/passwd', 'utf8', callback);\n</code></pre>\n<p>When the path is a directory, the behavior of <code>fs.readFile()</code> and\n<a href=\"fs.html#fs_fs_readfilesync_path_options\"><code>fs.readFileSync()</code></a> is platform-specific. On macOS, Linux, and Windows, an\nerror will be returned. On FreeBSD, a representation of the directory's contents\nwill be returned.</p>\n<pre><code class=\"language-js\">// macOS, Linux, and Windows\nfs.readFile('&#x3C;directory>', (err, data) => {\n  // => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]\n});\n\n//  FreeBSD\nfs.readFile('&#x3C;directory>', (err, data) => {\n  // => null, &#x3C;data>\n});\n</code></pre>\n<p>The <code>fs.readFile()</code> function buffers the entire file. To minimize memory costs,\nwhen possible prefer streaming via <code>fs.createReadStream()</code>.</p>",
-          "modules": [
-            {
-              "textRaw": "File descriptors",
-              "name": "file_descriptors",
-              "desc": "<ol>\n<li>Any specified file descriptor has to support reading.</li>\n<li>If a file descriptor is specified as the <code>path</code>, it will not be closed\nautomatically.</li>\n<li>The reading will begin at the current position. For example, if the file\nalready had <code>'Hello World</code>' and six bytes are read with the file descriptor,\nthe call to <code>fs.readFile()</code> with the same file descriptor, would give\n<code>'World'</code>, rather than <code>'Hello World'</code>.</li>\n</ol>",
-              "type": "module",
-              "displayName": "File descriptors"
-            }
-          ]
-        },
-        {
-          "textRaw": "`fs.readFileSync(path[, options])`",
-          "type": "method",
-          "name": "readFileSync",
-          "meta": {
-            "added": [
-              "v0.1.8"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `path` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string|Buffer}",
-                "name": "return",
-                "type": "string|Buffer"
-              },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL|integer} filename or file descriptor",
-                  "name": "path",
-                  "type": "string|Buffer|URL|integer",
-                  "desc": "filename or file descriptor"
-                },
+              "textRaw": "Class: `fs.FSWatcher`",
+              "type": "class",
+              "name": "fs.FSWatcher",
+              "meta": {
+                "added": [
+                  "v0.5.8"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Extends <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>A successful call to <a href=\"fs.html#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> method will return a new <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a>\nobject.</p>\n<p>All <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> objects emit a <code>'change'</code> event whenever a specific watched\nfile is modified.</p>",
+              "events": [
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
+                  "textRaw": "Event: `'change'`",
+                  "type": "event",
+                  "name": "change",
+                  "meta": {
+                    "added": [
+                      "v0.5.8"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `null`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`null`"
+                      "textRaw": "`eventType` {string} The type of change event that has occurred",
+                      "name": "eventType",
+                      "type": "string",
+                      "desc": "The type of change event that has occurred"
                     },
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'r'`",
-                      "desc": "See [support of file system `flags`][]."
+                      "textRaw": "`filename` {string|Buffer} The filename that changed (if relevant/available)",
+                      "name": "filename",
+                      "type": "string|Buffer",
+                      "desc": "The filename that changed (if relevant/available)"
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the contents of the <code>path</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_readfile_path_options_callback\"><code>fs.readFile()</code></a>.</p>\n<p>If the <code>encoding</code> option is specified then this function returns a\nstring. Otherwise it returns a buffer.</p>\n<p>Similar to <a href=\"fs.html#fs_fs_readfile_path_options_callback\"><code>fs.readFile()</code></a>, when the path is a directory, the behavior of\n<code>fs.readFileSync()</code> is platform-specific.</p>\n<pre><code class=\"language-js\">// macOS, Linux, and Windows\nfs.readFileSync('&#x3C;directory>');\n// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]\n\n//  FreeBSD\nfs.readFileSync('&#x3C;directory>'); // => &#x3C;data>\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.readlink(path[, options], callback)`",
-          "type": "method",
-          "name": "readlink",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  ],
+                  "desc": "<p>Emitted when something changes in a watched directory or file.\nSee more details in <a href=\"fs.html#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a>.</p>\n<p>The <code>filename</code> argument may not be provided depending on operating system\nsupport. If <code>filename</code> is provided, it will be provided as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> if\n<code>fs.watch()</code> is called with its <code>encoding</code> option set to <code>'buffer'</code>, otherwise\n<code>filename</code> will be a UTF-8 string.</p>\n<pre><code class=\"language-mjs\">import { watch } from 'fs';\n// Example when handled through fs.watch() listener\nwatch('./tmp', { encoding: 'buffer' }, (eventType, filename) => {\n  if (filename) {\n    console.log(filename);\n    // Prints: &#x3C;Buffer ...>\n  }\n});\n</code></pre>"
+                },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "Event: `'close'`",
+                  "type": "event",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v10.0.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the watcher stops watching for changes. The closed\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object is no longer usable in the event handler.</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "textRaw": "Event: `'error'`",
+                  "type": "event",
+                  "name": "error",
+                  "meta": {
+                    "added": [
+                      "v0.5.8"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`error` {Error}",
+                      "name": "error",
+                      "type": "Error"
                     }
-                  ]
+                  ],
+                  "desc": "<p>Emitted when an error occurs while watching the file. The errored\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object is no longer usable in the event handler.</p>"
+                }
+              ],
+              "methods": [
+                {
+                  "textRaw": "`watcher.close()`",
+                  "type": "method",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v0.5.8"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Stop watching for changes on the given <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a>. Once stopped, the\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object is no longer usable.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "`watcher.ref()`",
+                  "type": "method",
+                  "name": "ref",
+                  "meta": {
+                    "added": [
+                      "v14.3.0",
+                      "v12.20.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                      "return": {
+                        "textRaw": "Returns: {fs.FSWatcher}",
+                        "name": "return",
+                        "type": "fs.FSWatcher"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> is active. Calling <code>watcher.ref()</code> multiple times will have\nno effect.</p>\n<p>By default, all <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> objects are \"ref'ed\", making it normally\nunnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been\ncalled previously.</p>"
+                },
+                {
+                  "textRaw": "`watcher.unref()`",
+                  "type": "method",
+                  "name": "unref",
+                  "meta": {
+                    "added": [
+                      "v14.3.0",
+                      "v12.20.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`linkString` {string|Buffer}",
-                      "name": "linkString",
-                      "type": "string|Buffer"
+                      "return": {
+                        "textRaw": "Returns: {fs.FSWatcher}",
+                        "name": "return",
+                        "type": "fs.FSWatcher"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>When called, the active <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object will not require the Node.js\nevent loop to remain active. If there is no other activity keeping the\nevent loop running, the process may exit before the <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object's\ncallback is invoked. Calling <code>watcher.unref()</code> multiple times will have\nno effect.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a>. The callback gets two arguments <code>(err, linkString)</code>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe link path returned will be passed as a <code>Buffer</code> object.</p>"
-        },
-        {
-          "textRaw": "`fs.readlinkSync(path[, options])`",
-          "type": "method",
-          "name": "readlinkSync",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string|Buffer}",
-                "name": "return",
-                "type": "string|Buffer"
+              "textRaw": "Class: `fs.StatWatcher`",
+              "type": "class",
+              "name": "fs.StatWatcher",
+              "meta": {
+                "added": [
+                  "v14.3.0",
+                  "v12.20.0"
+                ],
+                "changes": []
               },
-              "params": [
+              "desc": "<ul>\n<li>Extends <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>A successful call to <code>fs.watchFile()</code> method will return a new <a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a>\nobject.</p>",
+              "methods": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`watcher.ref()`",
+                  "type": "method",
+                  "name": "ref",
+                  "meta": {
+                    "added": [
+                      "v14.3.0",
+                      "v12.20.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {fs.StatWatcher}",
+                        "name": "return",
+                        "type": "fs.StatWatcher"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the\n<a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a> is active. Calling <code>watcher.ref()</code> multiple times will have\nno effect.</p>\n<p>By default, all <a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a> objects are \"ref'ed\", making it normally\nunnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been\ncalled previously.</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "textRaw": "`watcher.unref()`",
+                  "type": "method",
+                  "name": "unref",
+                  "meta": {
+                    "added": [
+                      "v14.3.0",
+                      "v12.20.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "return": {
+                        "textRaw": "Returns: {fs.StatWatcher}",
+                        "name": "return",
+                        "type": "fs.StatWatcher"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>When called, the active <a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a> object will not require the Node.js\nevent loop to remain active. If there is no other activity keeping the\nevent loop running, the process may exit before the <a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a> object's\ncallback is invoked. Calling <code>watcher.unref()</code> multiple times will have\nno effect.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a>. Returns the symbolic link's string value.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe link path returned will be passed as a <code>Buffer</code> object.</p>"
-        },
-        {
-          "textRaw": "`fs.readSync(fd, buffer, offset, length, position)`",
-          "type": "method",
-          "name": "readSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
-              },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/4518",
-                "description": "The `length` parameter can now be `0`."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "return": {
-                "textRaw": "Returns: {number}",
-                "name": "return",
-                "type": "number"
+              "textRaw": "Class: `fs.ReadStream`",
+              "type": "class",
+              "name": "fs.ReadStream",
+              "meta": {
+                "added": [
+                  "v0.1.93"
+                ],
+                "changes": []
               },
-              "params": [
+              "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_readable\" class=\"type\">&lt;stream.Readable&gt;</a></li>\n</ul>\n<p>Instances of <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a> are created and returned using the\n<a href=\"fs.html#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a> function.</p>",
+              "events": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "textRaw": "Event: `'close'`",
+                  "type": "event",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a>'s underlying file descriptor has been closed.</p>"
                 },
                 {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
+                  "textRaw": "Event: `'open'`",
+                  "type": "event",
+                  "name": "open",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer} Integer file descriptor used by the {fs.ReadStream}.",
+                      "name": "fd",
+                      "type": "integer",
+                      "desc": "Integer file descriptor used by the {fs.ReadStream}."
+                    }
+                  ],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a>'s file descriptor has been opened.</p>"
                 },
                 {
-                  "textRaw": "`offset` {integer}",
-                  "name": "offset",
-                  "type": "integer"
+                  "textRaw": "Event: `'ready'`",
+                  "type": "event",
+                  "name": "ready",
+                  "meta": {
+                    "added": [
+                      "v9.11.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a> is ready to be used.</p>\n<p>Fires immediately after <code>'open'</code>.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`bytesRead` {number}",
+                  "type": "number",
+                  "name": "bytesRead",
+                  "meta": {
+                    "added": [
+                      "v6.4.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The number of bytes that have been read so far.</p>"
                 },
                 {
-                  "textRaw": "`length` {integer}",
-                  "name": "length",
-                  "type": "integer"
+                  "textRaw": "`path` {string|Buffer}",
+                  "type": "string|Buffer",
+                  "name": "path",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The path to the file the stream is reading from as specified in the first\nargument to <code>fs.createReadStream()</code>. If <code>path</code> is passed as a string, then\n<code>readStream.path</code> will be a string. If <code>path</code> is passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>, then\n<code>readStream.path</code> will be a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
+                  "textRaw": "`pending` {boolean}",
+                  "type": "boolean",
+                  "name": "pending",
+                  "meta": {
+                    "added": [
+                      "v11.2.0",
+                      "v10.16.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This property is <code>true</code> if the underlying file has not been opened yet,\ni.e. before the <code>'ready'</code> event is emitted.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Returns the number of <code>bytesRead</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.readSync(fd, buffer, [options])`",
-          "type": "method",
-          "name": "readSync",
-          "meta": {
-            "added": [
-              "v12.17.0"
-            ],
-            "changes": [
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/32460",
-                "description": "Options object can be passed in to make offset, length and position optional"
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "return": {
-                "textRaw": "Returns: {number}",
-                "name": "return",
-                "type": "number"
+              "textRaw": "Class: `fs.Stats`",
+              "type": "class",
+              "name": "fs.Stats",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v8.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/13173",
+                    "description": "Added times as numbers."
+                  }
+                ]
               },
-              "params": [
+              "desc": "<p>A <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object provides information about a file.</p>\n<p>Objects returned from <a href=\"fs.html#fs_fs_stat_path_options_callback\"><code>fs.stat()</code></a>, <a href=\"fs.html#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a> and <a href=\"fs.html#fs_fs_fstat_fd_options_callback\"><code>fs.fstat()</code></a> and\ntheir synchronous counterparts are of this type.\nIf <code>bigint</code> in the <code>options</code> passed to those methods is true, the numeric values\nwill be <code>bigint</code> instead of <code>number</code>, and the object will contain additional\nnanosecond-precision properties suffixed with <code>Ns</code>.</p>\n<pre><code class=\"language-console\">Stats {\n  dev: 2114,\n  ino: 48064969,\n  mode: 33188,\n  nlink: 1,\n  uid: 85,\n  gid: 100,\n  rdev: 0,\n  size: 527,\n  blksize: 4096,\n  blocks: 8,\n  atimeMs: 1318289051000.1,\n  mtimeMs: 1318289051000.1,\n  ctimeMs: 1318289051000.1,\n  birthtimeMs: 1318289051000.1,\n  atime: Mon, 10 Oct 2011 23:24:11 GMT,\n  mtime: Mon, 10 Oct 2011 23:24:11 GMT,\n  ctime: Mon, 10 Oct 2011 23:24:11 GMT,\n  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }\n</code></pre>\n<p><code>bigint</code> version:</p>\n<pre><code class=\"language-console\">BigIntStats {\n  dev: 2114n,\n  ino: 48064969n,\n  mode: 33188n,\n  nlink: 1n,\n  uid: 85n,\n  gid: 100n,\n  rdev: 0n,\n  size: 527n,\n  blksize: 4096n,\n  blocks: 8n,\n  atimeMs: 1318289051000n,\n  mtimeMs: 1318289051000n,\n  ctimeMs: 1318289051000n,\n  birthtimeMs: 1318289051000n,\n  atimeNs: 1318289051000000000n,\n  mtimeNs: 1318289051000000000n,\n  ctimeNs: 1318289051000000000n,\n  birthtimeNs: 1318289051000000000n,\n  atime: Mon, 10 Oct 2011 23:24:11 GMT,\n  mtime: Mon, 10 Oct 2011 23:24:11 GMT,\n  ctime: Mon, 10 Oct 2011 23:24:11 GMT,\n  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }\n</code></pre>",
+              "methods": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "textRaw": "`stats.isBlockDevice()`",
+                  "type": "method",
+                  "name": "isBlockDevice",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a block device.</p>"
                 },
                 {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
+                  "textRaw": "`stats.isCharacterDevice()`",
+                  "type": "method",
+                  "name": "isCharacterDevice",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a character device.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`offset` {integer} **Default:** `0`",
-                      "name": "offset",
-                      "type": "integer",
-                      "default": "`0`"
-                    },
-                    {
-                      "textRaw": "`length` {integer} **Default:** `buffer.length`",
-                      "name": "length",
-                      "type": "integer",
-                      "default": "`buffer.length`"
-                    },
+                  "textRaw": "`stats.isDirectory()`",
+                  "type": "method",
+                  "name": "isDirectory",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`position` {integer} **Default:** `null`",
-                      "name": "position",
-                      "type": "integer",
-                      "default": "`null`"
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the number of <code>bytesRead</code>.</p>\n<p>Similar to the above <code>fs.readSync</code> function, this version takes an optional <code>options</code> object.\nIf no <code>options</code> object is specified, it will default with the above values.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.readv(fd, buffers[, position], callback)`",
-          "type": "method",
-          "name": "readv",
-          "meta": {
-            "added": [
-              "v12.17.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a file system directory.</p>\n<p>If the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object was obtained from <a href=\"fs.html#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a>, this method will\nalways return <code>false</code>. This is because <a href=\"fs.html#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a> returns information\nabout a symbolic link itself and not the path it resolves to.</p>"
                 },
                 {
-                  "textRaw": "`buffers` {ArrayBufferView[]}",
-                  "name": "buffers",
-                  "type": "ArrayBufferView[]"
+                  "textRaw": "`stats.isFIFO()`",
+                  "type": "method",
+                  "name": "isFIFO",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a first-in-first-out (FIFO)\npipe.</p>"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
+                  "textRaw": "`stats.isFile()`",
+                  "type": "method",
+                  "name": "isFile",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a regular file.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                  "textRaw": "`stats.isSocket()`",
+                  "type": "method",
+                  "name": "isSocket",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`bytesRead` {integer}",
-                      "name": "bytesRead",
-                      "type": "integer"
-                    },
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a socket.</p>"
+                },
+                {
+                  "textRaw": "`stats.isSymbolicLink()`",
+                  "type": "method",
+                  "name": "isSymbolicLink",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`buffers` {ArrayBufferView[]}",
-                      "name": "buffers",
-                      "type": "ArrayBufferView[]"
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a symbolic link.</p>\n<p>This method is only valid when using <a href=\"fs.html#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a>.</p>"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Read from a file specified by <code>fd</code> and write to an array of <code>ArrayBufferView</code>s\nusing <code>readv()</code>.</p>\n<p><code>position</code> is the offset from the beginning of the file from where data\nshould be read. If <code>typeof position !== 'number'</code>, the data will be read\nfrom the current position.</p>\n<p>The callback will be given three arguments: <code>err</code>, <code>bytesRead</code>, and\n<code>buffers</code>. <code>bytesRead</code> is how many bytes were read from the file.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> and <code>buffers</code> properties.</p>"
-        },
-        {
-          "textRaw": "`fs.readvSync(fd, buffers[, position])`",
-          "type": "method",
-          "name": "readvSync",
-          "meta": {
-            "added": [
-              "v12.17.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {number} The number of bytes read.",
-                "name": "return",
-                "type": "number",
-                "desc": "The number of bytes read."
-              },
-              "params": [
+              ],
+              "properties": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "textRaw": "`dev` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "dev",
+                  "desc": "<p>The numeric identifier of the device containing the file.</p>"
+                },
+                {
+                  "textRaw": "`ino` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "ino",
+                  "desc": "<p>The file system specific \"Inode\" number for the file.</p>"
                 },
                 {
-                  "textRaw": "`buffers` {ArrayBufferView[]}",
-                  "name": "buffers",
-                  "type": "ArrayBufferView[]"
+                  "textRaw": "`mode` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "mode",
+                  "desc": "<p>A bit-field describing the file type and mode.</p>"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_readv_fd_buffers_position_callback\"><code>fs.readv()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.realpath(path[, options], callback)`",
-          "type": "method",
-          "name": "realpath",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v8.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/13028",
-                "description": "Pipe/Socket resolve support was added."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v6.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7899",
-                "description": "Calling `realpath` now works again for various edge cases on Windows."
-              },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3594",
-                "description": "The `cache` parameter was removed."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  "textRaw": "`nlink` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "nlink",
+                  "desc": "<p>The number of hard-links that exist for the file.</p>"
+                },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`uid` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "uid",
+                  "desc": "<p>The numeric user identifier of the user that owns the file (POSIX).</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    }
-                  ]
+                  "textRaw": "`gid` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "gid",
+                  "desc": "<p>The numeric group identifier of the group that owns the file (POSIX).</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
-                    {
-                      "textRaw": "`resolvedPath` {string|Buffer}",
-                      "name": "resolvedPath",
-                      "type": "string|Buffer"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously computes the canonical pathname by resolving <code>.</code>, <code>..</code> and\nsymbolic links.</p>\n<p>A canonical pathname is not necessarily unique. Hard links and bind mounts can\nexpose a file system entity through many pathnames.</p>\n<p>This function behaves like <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>, with some exceptions:</p>\n<ol>\n<li>\n<p>No case conversion is performed on case-insensitive file systems.</p>\n</li>\n<li>\n<p>The maximum number of symbolic links is platform-independent and generally\n(much) higher than what the native <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a> implementation supports.</p>\n</li>\n</ol>\n<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>. May use <code>process.cwd</code>\nto resolve relative paths.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <code>Buffer</code> object.</p>\n<p>If <code>path</code> resolves to a socket or a pipe, the function will return a system\ndependent name for that object.</p>"
-        },
-        {
-          "textRaw": "`fs.realpath.native(path[, options], callback)`",
-          "type": "method",
-          "name": "native",
-          "meta": {
-            "added": [
-              "v9.2.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "params": [
+                  "textRaw": "`rdev` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "rdev",
+                  "desc": "<p>A numeric device identifier if the file represents a device.</p>"
+                },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`size` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "size",
+                  "desc": "<p>The size of the file in bytes.</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    }
-                  ]
+                  "textRaw": "`blksize` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "blksize",
+                  "desc": "<p>The file system block size for i/o operations.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
-                    {
-                      "textRaw": "`resolvedPath` {string|Buffer}",
-                      "name": "resolvedPath",
-                      "type": "string|Buffer"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>.</p>\n<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <code>Buffer</code> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
-        },
-        {
-          "textRaw": "`fs.realpathSync(path[, options])`",
-          "type": "method",
-          "name": "realpathSync",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v8.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/13028",
-                "description": "Pipe/Socket resolve support was added."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v6.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7899",
-                "description": "Calling `realpathSync` now works again for various edge cases on Windows."
-              },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3594",
-                "description": "The `cache` parameter was removed."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {string|Buffer}",
-                "name": "return",
-                "type": "string|Buffer"
-              },
-              "params": [
+                  "textRaw": "`blocks` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "blocks",
+                  "desc": "<p>The number of blocks allocated for this file.</p>"
+                },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`atimeMs` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "atimeMs",
+                  "meta": {
+                    "added": [
+                      "v8.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time this file was accessed expressed in\nmilliseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the resolved pathname.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_realpath_path_options_callback\"><code>fs.realpath()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.realpathSync.native(path[, options])`",
-          "type": "method",
-          "name": "native",
-          "meta": {
-            "added": [
-              "v9.2.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {string|Buffer}",
-                "name": "return",
-                "type": "string|Buffer"
-              },
-              "params": [
+                  "textRaw": "`mtimeMs` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "mtimeMs",
+                  "meta": {
+                    "added": [
+                      "v8.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time this file was modified expressed in\nmilliseconds since the POSIX Epoch.</p>"
+                },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`ctimeMs` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "ctimeMs",
+                  "meta": {
+                    "added": [
+                      "v8.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time the file status was changed expressed\nin milliseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <code>Buffer</code> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
-        },
-        {
-          "textRaw": "`fs.rename(oldPath, newPath, callback)`",
-          "type": "method",
-          "name": "rename",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `oldPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  "textRaw": "`birthtimeMs` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "birthtimeMs",
+                  "meta": {
+                    "added": [
+                      "v8.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the creation time of this file expressed in\nmilliseconds since the POSIX Epoch.</p>"
+                },
                 {
-                  "textRaw": "`oldPath` {string|Buffer|URL}",
-                  "name": "oldPath",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`atimeNs` {bigint}",
+                  "type": "bigint",
+                  "name": "atimeNs",
+                  "meta": {
+                    "added": [
+                      "v12.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time this file was accessed expressed in\nnanoseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`newPath` {string|Buffer|URL}",
-                  "name": "newPath",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`mtimeNs` {bigint}",
+                  "type": "bigint",
+                  "name": "mtimeNs",
+                  "meta": {
+                    "added": [
+                      "v12.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time this file was modified expressed in\nnanoseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously rename file at <code>oldPath</code> to the pathname provided\nas <code>newPath</code>. In the case that <code>newPath</code> already exists, it will\nbe overwritten. If there is a directory at <code>newPath</code>, an error will\nbe raised instead. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>.</p>\n<pre><code class=\"language-js\">fs.rename('oldFile.txt', 'newFile.txt', (err) => {\n  if (err) throw err;\n  console.log('Rename complete!');\n});\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.renameSync(oldPath, newPath)`",
-          "type": "method",
-          "name": "renameSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `oldPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  "textRaw": "`ctimeNs` {bigint}",
+                  "type": "bigint",
+                  "name": "ctimeNs",
+                  "meta": {
+                    "added": [
+                      "v12.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time the file status was changed expressed\nin nanoseconds since the POSIX Epoch.</p>"
+                },
                 {
-                  "textRaw": "`oldPath` {string|Buffer|URL}",
-                  "name": "oldPath",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`birthtimeNs` {bigint}",
+                  "type": "bigint",
+                  "name": "birthtimeNs",
+                  "meta": {
+                    "added": [
+                      "v12.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the creation time of this file expressed in\nnanoseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`newPath` {string|Buffer|URL}",
-                  "name": "newPath",
-                  "type": "string|Buffer|URL"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.rmdir(path[, options], callback)`",
-          "type": "method",
-          "name": "rmdir",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30644",
-                "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
-              },
-              {
-                "version": "v12.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29168",
-                "description": "The `recursive`, `maxBusyTries`, and `emfileWait` options are now supported."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameters can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "stability": 1,
-          "stabilityText": "Recursive removal is experimental.",
-          "signatures": [
-            {
-              "params": [
+                  "textRaw": "`atime` {Date}",
+                  "type": "Date",
+                  "name": "atime",
+                  "meta": {
+                    "added": [
+                      "v0.11.13"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time this file was accessed.</p>"
+                },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`mtime` {Date}",
+                  "type": "Date",
+                  "name": "mtime",
+                  "meta": {
+                    "added": [
+                      "v0.11.13"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time this file was modified.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
-                      "name": "maxRetries",
-                      "type": "integer",
-                      "default": "`0`",
-                      "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
-                    },
-                    {
-                      "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure."
-                    },
-                    {
-                      "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
-                      "name": "retryDelay",
-                      "type": "integer",
-                      "default": "`100`",
-                      "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
-                    }
-                  ]
+                  "textRaw": "`ctime` {Date}",
+                  "type": "Date",
+                  "name": "ctime",
+                  "meta": {
+                    "added": [
+                      "v0.11.13"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time the file status was changed.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    }
-                  ]
+                  "textRaw": "`birthtime` {Date}",
+                  "type": "Date",
+                  "name": "birthtime",
+                  "meta": {
+                    "added": [
+                      "v0.11.13"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the creation time of this file.</p>"
+                }
+              ],
+              "modules": [
+                {
+                  "textRaw": "Stat time values",
+                  "name": "stat_time_values",
+                  "desc": "<p>The <code>atimeMs</code>, <code>mtimeMs</code>, <code>ctimeMs</code>, <code>birthtimeMs</code> properties are\nnumeric values that hold the corresponding times in milliseconds. Their\nprecision is platform specific. When <code>bigint: true</code> is passed into the\nmethod that generates the object, the properties will be <a href=\"https://tc39.github.io/proposal-bigint\">bigints</a>,\notherwise they will be <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\">numbers</a>.</p>\n<p>The <code>atimeNs</code>, <code>mtimeNs</code>, <code>ctimeNs</code>, <code>birthtimeNs</code> properties are\n<a href=\"https://tc39.github.io/proposal-bigint\">bigints</a> that hold the corresponding times in nanoseconds. They are\nonly present when <code>bigint: true</code> is passed into the method that generates\nthe object. Their precision is platform specific.</p>\n<p><code>atime</code>, <code>mtime</code>, <code>ctime</code>, and <code>birthtime</code> are\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date\"><code>Date</code></a> object alternate representations of the various times. The\n<code>Date</code> and number values are not connected. Assigning a new number value, or\nmutating the <code>Date</code> value, will not be reflected in the corresponding alternate\nrepresentation.</p>\n<p>The times in the stat object have the following semantics:</p>\n<ul>\n<li><code>atime</code> \"Access Time\": Time when file data last accessed. Changed\nby the <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/read.2.html\"><code>read(2)</code></a> system calls.</li>\n<li><code>mtime</code> \"Modified Time\": Time when file data last modified.\nChanged by the <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/write.2.html\"><code>write(2)</code></a> system calls.</li>\n<li><code>ctime</code> \"Change Time\": Time when file status was last changed\n(inode data modification). Changed by the <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>,\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>,\n<a href=\"http://man7.org/linux/man-pages/man2/read.2.html\"><code>read(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/write.2.html\"><code>write(2)</code></a> system calls.</li>\n<li><code>birthtime</code> \"Birth Time\": Time of file creation. Set once when the\nfile is created. On filesystems where birthtime is not available,\nthis field may instead hold either the <code>ctime</code> or\n<code>1970-01-01T00:00Z</code> (ie, Unix epoch timestamp <code>0</code>). This value may be greater\nthan <code>atime</code> or <code>mtime</code> in this case. On Darwin and other FreeBSD variants,\nalso set if the <code>atime</code> is explicitly set to an earlier value than the current\n<code>birthtime</code> using the <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a> system call.</li>\n</ul>\n<p>Prior to Node.js 0.12, the <code>ctime</code> held the <code>birthtime</code> on Windows systems. As\nof 0.12, <code>ctime</code> is not \"creation time\", and on Unix systems, it never was.</p>",
+                  "type": "module",
+                  "displayName": "Stat time values"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/rmdir.2.html\"><code>rmdir(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>\n<p>Using <code>fs.rmdir()</code> on a file (not a directory) results in an <code>ENOENT</code> error on\nWindows and an <code>ENOTDIR</code> error on POSIX.</p>"
-        },
-        {
-          "textRaw": "`fs.rmdirSync(path[, options])`",
-          "type": "method",
-          "name": "rmdirSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30644",
-                "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
-              },
-              {
-                "version": "v12.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29168",
-                "description": "The `recursive`, `maxBusyTries`, and `emfileWait` options are now supported."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameters can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "stability": 1,
-          "stabilityText": "Recursive removal is experimental.",
-          "signatures": [
+            },
             {
-              "params": [
+              "textRaw": "Class: `fs.WriteStream`",
+              "type": "class",
+              "name": "fs.WriteStream",
+              "meta": {
+                "added": [
+                  "v0.1.93"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Extends <a href=\"stream.html#stream_class_stream_writable\" class=\"type\">&lt;stream.Writable&gt;</a></li>\n</ul>\n<p>Instances of <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a> are created and returned using the\n<a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> function.</p>",
+              "events": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "Event: `'close'`",
+                  "type": "event",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a>'s underlying file descriptor has been closed.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
-                      "name": "maxRetries",
-                      "type": "integer",
-                      "default": "`0`",
-                      "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
-                    },
-                    {
-                      "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure."
-                    },
+                  "textRaw": "Event: `'open'`",
+                  "type": "event",
+                  "name": "open",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
                     {
-                      "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
-                      "name": "retryDelay",
+                      "textRaw": "`fd` {integer} Integer file descriptor used by the {fs.WriteStream}.",
+                      "name": "fd",
                       "type": "integer",
-                      "default": "`100`",
-                      "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                      "desc": "Integer file descriptor used by the {fs.WriteStream}."
                     }
-                  ]
+                  ],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a>'s file is opened.</p>"
+                },
+                {
+                  "textRaw": "Event: `'ready'`",
+                  "type": "event",
+                  "name": "ready",
+                  "meta": {
+                    "added": [
+                      "v9.11.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a> is ready to be used.</p>\n<p>Fires immediately after <code>'open'</code>.</p>"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/rmdir.2.html\"><code>rmdir(2)</code></a>. Returns <code>undefined</code>.</p>\n<p>Using <code>fs.rmdirSync()</code> on a file (not a directory) results in an <code>ENOENT</code> error\non Windows and an <code>ENOTDIR</code> error on POSIX.</p>"
-        },
-        {
-          "textRaw": "`fs.stat(path[, options], callback)`",
-          "type": "method",
-          "name": "stat",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+              ],
+              "properties": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`writeStream.bytesWritten`",
+                  "name": "bytesWritten",
+                  "meta": {
+                    "added": [
+                      "v0.4.7"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The number of bytes written so far. Does not include data that is still queued\nfor writing.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
-                    }
-                  ]
+                  "textRaw": "`writeStream.path`",
+                  "name": "path",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The path to the file the stream is writing to as specified in the first\nargument to <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>. If <code>path</code> is passed as a string, then\n<code>writeStream.path</code> will be a string. If <code>path</code> is passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>, then\n<code>writeStream.path</code> will be a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                  "textRaw": "`pending` {boolean}",
+                  "type": "boolean",
+                  "name": "pending",
+                  "meta": {
+                    "added": [
+                      "v11.2.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This property is <code>true</code> if the underlying file has not been opened yet,\ni.e. before the <code>'ready'</code> event is emitted.</p>"
+                }
+              ],
+              "methods": [
+                {
+                  "textRaw": "`writeStream.close([callback])`",
+                  "type": "method",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v0.9.4"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`stats` {fs.Stats}",
-                      "name": "stats",
-                      "type": "fs.Stats"
+                      "params": [
+                        {
+                          "textRaw": "`callback` {Function}",
+                          "name": "callback",
+                          "type": "Function",
+                          "options": [
+                            {
+                              "textRaw": "`err` {Error}",
+                              "name": "err",
+                              "type": "Error"
+                            }
+                          ]
+                        }
+                      ]
                     }
-                  ]
+                  ],
+                  "desc": "<p>Closes <code>writeStream</code>. Optionally accepts a\ncallback that will be executed once the <code>writeStream</code>\nis closed.</p>"
                 }
               ]
             }
           ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/stat.2.html\"><code>stat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where\n<code>stats</code> is an <a href=\"fs.html#fs_class_fs_stats\"><code>fs.Stats</code></a> object.</p>\n<p>In case of an error, the <code>err.code</code> will be one of <a href=\"errors.html#errors_common_system_errors\">Common System Errors</a>.</p>\n<p>Using <code>fs.stat()</code> to check for the existence of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended.\nInstead, user code should open/read/write the file directly and handle the\nerror raised if the file is not available.</p>\n<p>To check if a file exists without manipulating it afterwards, <a href=\"fs.html#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a>\nis recommended.</p>\n<p>For example, given the following directory structure:</p>\n<pre><code class=\"language-text\">- txtDir\n-- file.txt\n- app.js\n</code></pre>\n<p>The next program will check for the stats of the given paths:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nconst pathsToCheck = ['./txtDir', './txtDir/file.txt'];\n\nfor (let i = 0; i &#x3C; pathsToCheck.length; i++) {\n  fs.stat(pathsToCheck[i], function(err, stats) {\n    console.log(stats.isDirectory());\n    console.log(stats);\n  });\n}\n</code></pre>\n<p>The resulting output will resemble:</p>\n<pre><code class=\"language-console\">true\nStats {\n  dev: 16777220,\n  mode: 16877,\n  nlink: 3,\n  uid: 501,\n  gid: 20,\n  rdev: 0,\n  blksize: 4096,\n  ino: 14214262,\n  size: 96,\n  blocks: 0,\n  atimeMs: 1561174653071.963,\n  mtimeMs: 1561174614583.3518,\n  ctimeMs: 1561174626623.5366,\n  birthtimeMs: 1561174126937.2893,\n  atime: 2019-06-22T03:37:33.072Z,\n  mtime: 2019-06-22T03:36:54.583Z,\n  ctime: 2019-06-22T03:37:06.624Z,\n  birthtime: 2019-06-22T03:28:46.937Z\n}\nfalse\nStats {\n  dev: 16777220,\n  mode: 33188,\n  nlink: 1,\n  uid: 501,\n  gid: 20,\n  rdev: 0,\n  blksize: 4096,\n  ino: 14214074,\n  size: 8,\n  blocks: 8,\n  atimeMs: 1561174616618.8555,\n  mtimeMs: 1561174614584,\n  ctimeMs: 1561174614583.8145,\n  birthtimeMs: 1561174007710.7478,\n  atime: 2019-06-22T03:36:56.619Z,\n  mtime: 2019-06-22T03:36:54.584Z,\n  ctime: 2019-06-22T03:36:54.584Z,\n  birthtime: 2019-06-22T03:26:47.711Z\n}\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.statSync(path[, options])`",
-          "type": "method",
-          "name": "statSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+          "properties": [
             {
-              "return": {
-                "textRaw": "Returns: {fs.Stats}",
-                "name": "return",
-                "type": "fs.Stats"
-              },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`constants` {Object}",
+              "type": "Object",
+              "name": "constants",
+              "desc": "<p>Returns an object containing commonly used constants for file system\noperations.</p>",
+              "modules": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "textRaw": "FS constants",
+                  "name": "fs_constants",
+                  "desc": "<p>The following constants are exported by <code>fs.constants</code>.</p>\n<p>Not every constant will be available on every operating system.</p>\n<p>To use more than one constant, use the bitwise OR <code>|</code> operator.</p>\n<p>Example:</p>\n<pre><code class=\"language-mjs\">import { open, constants } from 'fs';\n\nconst {\n  O_RDWR,\n  O_CREAT,\n  O_EXCL\n} = constants;\n\nopen('/path/to/my/file', O_RDWR | O_CREAT | O_EXCL, (err, fd) => {\n  // ...\n});\n</code></pre>",
+                  "modules": [
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "File access constants",
+                      "name": "file_access_constants",
+                      "desc": "<p>The following constants are meant for use with <a href=\"fs.html#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>F_OK</code></td>\n    <td>Flag indicating that the file is visible to the calling process.\n     This is useful for determining if a file exists, but says nothing\n     about <code>rwx</code> permissions. Default if no mode is specified.</td>\n  </tr>\n  <tr>\n    <td><code>R_OK</code></td>\n    <td>Flag indicating that the file can be read by the calling process.</td>\n  </tr>\n  <tr>\n    <td><code>W_OK</code></td>\n    <td>Flag indicating that the file can be written by the calling\n    process.</td>\n  </tr>\n  <tr>\n    <td><code>X_OK</code></td>\n    <td>Flag indicating that the file can be executed by the calling\n    process. This has no effect on Windows\n    (will behave like <code>fs.constants.F_OK</code>).</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File access constants"
+                    },
+                    {
+                      "textRaw": "File copy constants",
+                      "name": "file_copy_constants",
+                      "desc": "<p>The following constants are meant for use with <a href=\"fs.html#fs_fs_copyfile_src_dest_mode_callback\"><code>fs.copyFile()</code></a>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_EXCL</code></td>\n    <td>If present, the copy operation will fail with an error if the\n    destination path already exists.</td>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_FICLONE</code></td>\n    <td>If present, the copy operation will attempt to create a\n    copy-on-write reflink. If the underlying platform does not support\n    copy-on-write, then a fallback copy mechanism is used.</td>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_FICLONE_FORCE</code></td>\n    <td>If present, the copy operation will attempt to create a\n    copy-on-write reflink. If the underlying platform does not support\n    copy-on-write, then the operation will fail with an error.</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File copy constants"
+                    },
+                    {
+                      "textRaw": "File open constants",
+                      "name": "file_open_constants",
+                      "desc": "<p>The following constants are meant for use with <code>fs.open()</code>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>O_RDONLY</code></td>\n    <td>Flag indicating to open a file for read-only access.</td>\n  </tr>\n  <tr>\n    <td><code>O_WRONLY</code></td>\n    <td>Flag indicating to open a file for write-only access.</td>\n  </tr>\n  <tr>\n    <td><code>O_RDWR</code></td>\n    <td>Flag indicating to open a file for read-write access.</td>\n  </tr>\n  <tr>\n    <td><code>O_CREAT</code></td>\n    <td>Flag indicating to create the file if it does not already exist.</td>\n  </tr>\n  <tr>\n    <td><code>O_EXCL</code></td>\n    <td>Flag indicating that opening a file should fail if the\n    <code>O_CREAT</code> flag is set and the file already exists.</td>\n  </tr>\n  <tr>\n    <td><code>O_NOCTTY</code></td>\n    <td>Flag indicating that if path identifies a terminal device, opening the\n    path shall not cause that terminal to become the controlling terminal for\n    the process (if the process does not already have one).</td>\n  </tr>\n  <tr>\n    <td><code>O_TRUNC</code></td>\n    <td>Flag indicating that if the file exists and is a regular file, and the\n    file is opened successfully for write access, its length shall be truncated\n    to zero.</td>\n  </tr>\n  <tr>\n    <td><code>O_APPEND</code></td>\n    <td>Flag indicating that data will be appended to the end of the file.</td>\n  </tr>\n  <tr>\n    <td><code>O_DIRECTORY</code></td>\n    <td>Flag indicating that the open should fail if the path is not a\n    directory.</td>\n  </tr>\n  <tr>\n  <td><code>O_NOATIME</code></td>\n    <td>Flag indicating reading accesses to the file system will no longer\n    result in an update to the <code>atime</code> information associated with\n    the file. This flag is available on Linux operating systems only.</td>\n  </tr>\n  <tr>\n    <td><code>O_NOFOLLOW</code></td>\n    <td>Flag indicating that the open should fail if the path is a symbolic\n    link.</td>\n  </tr>\n  <tr>\n    <td><code>O_SYNC</code></td>\n    <td>Flag indicating that the file is opened for synchronized I/O with write\n    operations waiting for file integrity.</td>\n  </tr>\n  <tr>\n    <td><code>O_DSYNC</code></td>\n    <td>Flag indicating that the file is opened for synchronized I/O with write\n    operations waiting for data integrity.</td>\n  </tr>\n  <tr>\n    <td><code>O_SYMLINK</code></td>\n    <td>Flag indicating to open the symbolic link itself rather than the\n    resource it is pointing to.</td>\n  </tr>\n  <tr>\n    <td><code>O_DIRECT</code></td>\n    <td>When set, an attempt will be made to minimize caching effects of file\n    I/O.</td>\n  </tr>\n  <tr>\n    <td><code>O_NONBLOCK</code></td>\n    <td>Flag indicating to open the file in nonblocking mode when possible.</td>\n  </tr>\n  <tr>\n    <td><code>UV_FS_O_FILEMAP</code></td>\n    <td>When set, a memory file mapping is used to access the file. This flag\n    is available on Windows operating systems only. On other operating systems,\n    this flag is ignored.</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File open constants"
+                    },
+                    {
+                      "textRaw": "File type constants",
+                      "name": "file_type_constants",
+                      "desc": "<p>The following constants are meant for use with the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object's\n<code>mode</code> property for determining a file's type.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>S_IFMT</code></td>\n    <td>Bit mask used to extract the file type code.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFREG</code></td>\n    <td>File type constant for a regular file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFDIR</code></td>\n    <td>File type constant for a directory.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFCHR</code></td>\n    <td>File type constant for a character-oriented device file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFBLK</code></td>\n    <td>File type constant for a block-oriented device file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFIFO</code></td>\n    <td>File type constant for a FIFO/pipe.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFLNK</code></td>\n    <td>File type constant for a symbolic link.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFSOCK</code></td>\n    <td>File type constant for a socket.</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File type constants"
+                    },
+                    {
+                      "textRaw": "File mode constants",
+                      "name": "file_mode_constants",
+                      "desc": "<p>The following constants are meant for use with the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object's\n<code>mode</code> property for determining the access permissions for a file.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>S_IRWXU</code></td>\n    <td>File mode indicating readable, writable, and executable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRUSR</code></td>\n    <td>File mode indicating readable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWUSR</code></td>\n    <td>File mode indicating writable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXUSR</code></td>\n    <td>File mode indicating executable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRWXG</code></td>\n    <td>File mode indicating readable, writable, and executable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRGRP</code></td>\n    <td>File mode indicating readable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWGRP</code></td>\n    <td>File mode indicating writable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXGRP</code></td>\n    <td>File mode indicating executable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRWXO</code></td>\n    <td>File mode indicating readable, writable, and executable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IROTH</code></td>\n    <td>File mode indicating readable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWOTH</code></td>\n    <td>File mode indicating writable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXOTH</code></td>\n    <td>File mode indicating executable by others.</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File mode constants"
                     }
-                  ]
+                  ],
+                  "type": "module",
+                  "displayName": "FS constants"
                 }
               ]
             }
           ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/stat.2.html\"><code>stat(2)</code></a>.</p>"
+          "type": "module",
+          "displayName": "Common Objects"
         },
         {
-          "textRaw": "`fs.symlink(target, path[, type], callback)`",
-          "type": "method",
-          "name": "symlink",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `target` and `path` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v12.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23724",
-                "description": "If the `type` argument is left undefined, Node will autodetect `target` type and automatically select `dir` or `file`"
-              }
-            ]
-          },
-          "signatures": [
+          "textRaw": "Notes",
+          "name": "notes",
+          "modules": [
             {
-              "params": [
-                {
-                  "textRaw": "`target` {string|Buffer|URL}",
-                  "name": "target",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "Ordering of callback and promise-based operations",
+              "name": "ordering_of_callback_and_promise-based_operations",
+              "desc": "<p>Because they are executed asynchronously by the underlying thread pool,\nthere is no guaranteed ordering when using either the callback or\npromise-based methods.</p>\n<p>For example, the following is prone to error because the <code>fs.stat()</code>\noperation might complete before the <code>fs.rename()</code> operation:</p>\n<pre><code class=\"language-js\">fs.rename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  console.log('renamed complete');\n});\nfs.stat('/tmp/world', (err, stats) => {\n  if (err) throw err;\n  console.log(`stats: ${JSON.stringify(stats)}`);\n});\n</code></pre>\n<p>It is important to correctly order the operations by awaiting the results\nof one before invoking the other:</p>\n<pre><code class=\"language-mjs\">import { rename, stat } from 'fs/promises';\n\nconst from = '/tmp/hello';\nconst to = '/tmp/world';\n\ntry {\n  await rename(from, to);\n  const stats = await stat(to);\n  console.log(`stats: ${JSON.stringify(stats)}`);\n} catch (error) {\n  console.error('there was an error:', error.message);\n}\n</code></pre>\n<pre><code class=\"language-cjs\">const { rename, stat } = require('fs/promises');\n\n(async function(from, to) {\n  try {\n    await rename(from, to);\n    const stats = await stat(to);\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  } catch (error) {\n    console.error('there was an error:', error.message);\n  }\n})('/tmp/hello', '/tmp/world');\n</code></pre>\n<p>Or, when using the callback APIs, move the <code>fs.stat()</code> call into the callback\nof the <code>fs.rename()</code> operation:</p>\n<pre><code class=\"language-mjs\">import { rename, stat } from 'fs';\n\nrename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  stat('/tmp/world', (err, stats) => {\n    if (err) throw err;\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  });\n});\n</code></pre>\n<pre><code class=\"language-cjs\">const { rename, stat } = require('fs/promises');\n\nrename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  stat('/tmp/world', (err, stats) => {\n    if (err) throw err;\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  });\n});\n</code></pre>",
+              "type": "module",
+              "displayName": "Ordering of callback and promise-based operations"
+            },
+            {
+              "textRaw": "File paths",
+              "name": "file_paths",
+              "desc": "<p>Most <code>fs</code> operations accept file paths that may be specified in the form of\na string, a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>, or a <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a> object using the <code>file:</code> protocol.</p>",
+              "modules": [
                 {
-                  "textRaw": "`type` {string}",
-                  "name": "type",
-                  "type": "string"
+                  "textRaw": "String paths",
+                  "name": "string_paths",
+                  "desc": "<p>String form paths are interpreted as UTF-8 character sequences identifying\nthe absolute or relative filename. Relative paths will be resolved relative\nto the current working directory as determined by calling <code>process.cwd()</code>.</p>\n<p>Example using an absolute path on POSIX:</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet fd;\ntry {\n  fd = await open('/open/some/file.txt', 'r');\n  // Do something with the file\n} finally {\n  await fd.close();\n}\n</code></pre>\n<p>Example using a relative path on POSIX (relative to <code>process.cwd()</code>):</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet fd;\ntry {\n  fd = await open('file.txt', 'r');\n  // Do something with the file\n} finally {\n  await fd.close();\n}\n</code></pre>",
+                  "type": "module",
+                  "displayName": "String paths"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "File URL paths",
+                  "name": "file_url_paths",
+                  "meta": {
+                    "added": [
+                      "v7.6.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>For most <code>fs</code> module functions, the <code>path</code> or <code>filename</code> argument may be passed\nas a <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a> object using the <code>file:</code> protocol.</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n\nreadFileSync(new URL('file:///tmp/hello'));\n</code></pre>\n<p><code>file:</code> URLs are always absolute paths.</p>",
+                  "modules": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "Platform-specific considerations",
+                      "name": "platform-specific_considerations",
+                      "desc": "<p>On Windows, <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s with a host name convert to UNC paths, while <code>file:</code>\n<a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s with drive letters convert to local absolute paths. <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s\nwithout a host name nor a drive letter will result in an error:</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n// On Windows :\n\n// - WHATWG file URLs with hostname convert to UNC path\n// file://hostname/p/a/t/h/file => \\\\hostname\\p\\a\\t\\h\\file\nreadFileSync(new URL('file://hostname/p/a/t/h/file'));\n\n// - WHATWG file URLs with drive letters convert to absolute path\n// file:///C:/tmp/hello => C:\\tmp\\hello\nreadFileSync(new URL('file:///C:/tmp/hello'));\n\n// - WHATWG file URLs without hostname must have a drive letters\nreadFileSync(new URL('file:///notdriveletter/p/a/t/h/file'));\nreadFileSync(new URL('file:///c/p/a/t/h/file'));\n// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute\n</code></pre>\n<p><code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s with drive letters must use <code>:</code> as a separator just after\nthe drive letter. Using another separator will result in an error.</p>\n<p>On all other platforms, <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s with a host name are unsupported and\nwill result in an error:</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n// On other platforms:\n\n// - WHATWG file URLs with hostname are unsupported\n// file://hostname/p/a/t/h/file => throw!\nreadFileSync(new URL('file://hostname/p/a/t/h/file'));\n// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute\n\n// - WHATWG file URLs convert to absolute path\n// file:///tmp/hello => /tmp/hello\nreadFileSync(new URL('file:///tmp/hello'));\n</code></pre>\n<p>A <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a> having encoded slash characters will result in an error on all\nplatforms:</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n\n// On Windows\nreadFileSync(new URL('file:///C:/p/a/t/h/%2F'));\nreadFileSync(new URL('file:///C:/p/a/t/h/%2f'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n\\ or / characters */\n\n// On POSIX\nreadFileSync(new URL('file:///p/a/t/h/%2F'));\nreadFileSync(new URL('file:///p/a/t/h/%2f'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n/ characters */\n</code></pre>\n<p>On Windows, <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s having encoded backslash will result in an error:</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n\n// On Windows\nreadFileSync(new URL('file:///C:/path/%5C'));\nreadFileSync(new URL('file:///C:/path/%5c'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n\\ or / characters */\n</code></pre>",
+                      "type": "module",
+                      "displayName": "Platform-specific considerations"
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/symlink.2.html\"><code>symlink(2)</code></a> which creates the link called <code>path</code> pointing to\n<code>target</code>. No arguments other than a possible exception are given to the\ncompletion callback.</p>\n<p>The <code>type</code> argument is only available on Windows and ignored on other platforms.\nIt can be set to <code>'dir'</code>, <code>'file'</code>, or <code>'junction'</code>. If the <code>type</code> argument is\nnot set, Node.js will autodetect <code>target</code> type and use <code>'file'</code> or <code>'dir'</code>. If\nthe <code>target</code> does not exist, <code>'file'</code> will be used. Windows junction points\nrequire the destination path to be absolute. When using <code>'junction'</code>, the\n<code>target</code> argument will automatically be normalized to absolute path.</p>\n<p>Relative targets are relative to the link’s parent directory.</p>\n<pre><code class=\"language-js\">fs.symlink('./mew', './example/mewtwo', callback);\n</code></pre>\n<p>The above example creates a symbolic link <code>mewtwo</code> in the <code>example</code> which points\nto <code>mew</code> in the same directory:</p>\n<pre><code class=\"language-bash\">$ tree example/\nexample/\n├── mew\n└── mewtwo -> ./mew\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.symlinkSync(target, path[, type])`",
-          "type": "method",
-          "name": "symlinkSync",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `target` and `path` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v12.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23724",
-                "description": "If the `type` argument is left undefined, Node will autodetect `target` type and automatically select `dir` or `file`"
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`target` {string|Buffer|URL}",
-                  "name": "target",
-                  "type": "string|Buffer|URL"
+                  ],
+                  "type": "module",
+                  "displayName": "File URL paths"
                 },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "Buffer paths",
+                  "name": "buffer_paths",
+                  "desc": "<p>Paths specified using a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> are useful primarily on certain POSIX\noperating systems that treat file paths as opaque byte sequences. On such\nsystems, it is possible for a single file path to contain sub-sequences that\nuse multiple character encodings. As with string paths, <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> paths may\nbe relative or absolute:</p>\n<p>Example using an absolute path on POSIX:</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet fd;\ntry {\n  fd = await open(Buffer.from('/open/some/file.txt'), 'r');\n  // Do something with the file\n} finally {\n  await fd.close();\n}\n</code></pre>",
+                  "type": "module",
+                  "displayName": "Buffer paths"
                 },
                 {
-                  "textRaw": "`type` {string}",
-                  "name": "type",
-                  "type": "string"
+                  "textRaw": "Per-drive working directories on Windows",
+                  "name": "per-drive_working_directories_on_windows",
+                  "desc": "<p>On Windows, Node.js follows the concept of per-drive working directory. This\nbehavior can be observed when using a drive path without a backslash. For\nexample <code>fs.readdirSync('C:\\\\')</code> can potentially return a different result than\n<code>fs.readdirSync('C:')</code>. For more information, see\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths\">this MSDN page</a>.</p>",
+                  "type": "module",
+                  "displayName": "Per-drive working directories on Windows"
                 }
-              ]
+              ],
+              "type": "module",
+              "displayName": "File paths"
+            },
+            {
+              "textRaw": "File descriptors",
+              "name": "file_descriptors",
+              "desc": "<p>On POSIX systems, for every process, the kernel maintains a table of currently\nopen files and resources. Each open file is assigned a simple numeric\nidentifier called a <em>file descriptor</em>. At the system-level, all file system\noperations use these file descriptors to identify and track each specific\nfile. Windows systems use a different but conceptually similar mechanism for\ntracking resources. To simplify things for users, Node.js abstracts away the\ndifferences between operating systems and assigns all open files a numeric file\ndescriptor.</p>\n<p>The callback-based <code>fs.open()</code>, and synchronous <code>fs.openSync()</code> methods open a\nfile and allocate a new file descriptor. Once allocated, the file descriptor may\nbe used to read data from, write data to, or request information about the file.</p>\n<p>Operating systems limit the number of file descriptors that may be open\nat any given time so it is critical to close the descriptor when operations\nare completed. Failure to do so will result in a memory leak that will\neventually cause an application to crash.</p>\n<pre><code class=\"language-mjs\">import { open, close, fstat } from 'fs';\n\nfunction closeFd(fd) {\n  close(fd, (err) => {\n    if (err) throw err;\n  });\n}\n\nopen('/open/some/file.txt', 'r', (err, fd) => {\n  if (err) throw err;\n  try {\n    fstat(fd, (err, stat) => {\n      if (err) {\n        closeFd(fd);\n        throw err;\n      }\n\n      // use stat\n\n      closeFd(fd);\n    });\n  } catch (err) {\n    closeFd(fd);\n    throw err;\n  }\n});\n</code></pre>\n<p>The promise-based APIs use a <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> object in place of the numeric\nfile descriptor. These objects are better managed by the system to ensure\nthat resources are not leaked. However, it is still required that they are\nclosed when operations are completed:</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet file;\ntry {\n  file = await open('/open/some/file.txt', 'r');\n  const stat = await file.stat();\n  // use stat\n} finally {\n  await file.close();\n}\n</code></pre>",
+              "type": "module",
+              "displayName": "File descriptors"
+            },
+            {
+              "textRaw": "Threadpool usage",
+              "name": "threadpool_usage",
+              "desc": "<p>All callback and promise-based file system APIs ( with the exception of\n<code>fs.FSWatcher()</code>) use libuv's threadpool. This can have surprising and negative\nperformance implications for some applications. See the\n<a href=\"cli.html#cli_uv_threadpool_size_size\"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>",
+              "type": "module",
+              "displayName": "Threadpool usage"
+            },
+            {
+              "textRaw": "File system flags",
+              "name": "file_system_flags",
+              "desc": "<p>The following flags are available wherever the <code>flag</code> option takes a\nstring.</p>\n<ul>\n<li>\n<p><code>'a'</code>: Open file for appending.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'ax'</code>: Like <code>'a'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'a+'</code>: Open file for reading and appending.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'ax+'</code>: Like <code>'a+'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'as'</code>: Open file for appending in synchronous mode.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'as+'</code>: Open file for reading and appending in synchronous mode.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'r'</code>: Open file for reading.\nAn exception occurs if the file does not exist.</p>\n</li>\n<li>\n<p><code>'r+'</code>: Open file for reading and writing.\nAn exception occurs if the file does not exist.</p>\n</li>\n<li>\n<p><code>'rs+'</code>: Open file for reading and writing in synchronous mode. Instructs\nthe operating system to bypass the local file system cache.</p>\n<p>This is primarily useful for opening files on NFS mounts as it allows\nskipping the potentially stale local cache. It has a very real impact on\nI/O performance so using this flag is not recommended unless it is needed.</p>\n<p>This doesn't turn <code>fs.open()</code> or <code>fsPromises.open()</code> into a synchronous\nblocking call. If synchronous operation is desired, something like\n<code>fs.openSync()</code> should be used.</p>\n</li>\n<li>\n<p><code>'w'</code>: Open file for writing.\nThe file is created (if it does not exist) or truncated (if it exists).</p>\n</li>\n<li>\n<p><code>'wx'</code>: Like <code>'w'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'w+'</code>: Open file for reading and writing.\nThe file is created (if it does not exist) or truncated (if it exists).</p>\n</li>\n<li>\n<p><code>'wx+'</code>: Like <code>'w+'</code> but fails if the path exists.</p>\n</li>\n</ul>\n<p><code>flag</code> can also be a number as documented by <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>; commonly used constants\nare available from <code>fs.constants</code>. On Windows, flags are translated to\ntheir equivalent ones where applicable, e.g. <code>O_WRONLY</code> to <code>FILE_GENERIC_WRITE</code>,\nor <code>O_EXCL|O_CREAT</code> to <code>CREATE_NEW</code>, as accepted by <code>CreateFileW</code>.</p>\n<p>The exclusive flag <code>'x'</code> (<code>O_EXCL</code> flag in <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>) causes the operation to\nreturn an error if the path already exists. On POSIX, if the path is a symbolic\nlink, using <code>O_EXCL</code> returns an error even if the link is to a path that does\nnot exist. The exclusive flag might not work with network file systems.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>\n<p>Modifying a file rather than replacing it may require the <code>flag</code> option to be\nset to <code>'r+'</code> rather than the default <code>'w'</code>.</p>\n<p>The behavior of some flags are platform-specific. As such, opening a directory\non macOS and Linux with the <code>'a+'</code> flag, as in the example below, will return an\nerror. In contrast, on Windows and FreeBSD, a file descriptor or a <code>FileHandle</code>\nwill be returned.</p>\n<pre><code class=\"language-js\">// macOS and Linux\nfs.open('&#x3C;directory>', 'a+', (err, fd) => {\n  // => [Error: EISDIR: illegal operation on a directory, open &#x3C;directory>]\n});\n\n// Windows and FreeBSD\nfs.open('&#x3C;directory>', 'a+', (err, fd) => {\n  // => null, &#x3C;fd>\n});\n</code></pre>\n<p>On Windows, opening an existing hidden file using the <code>'w'</code> flag (either\nthrough <code>fs.open()</code> or <code>fs.writeFile()</code> or <code>fsPromises.open()</code>) will fail with\n<code>EPERM</code>. Existing hidden files can be opened for writing with the <code>'r+'</code> flag.</p>\n<p>A call to <code>fs.ftruncate()</code> or <code>filehandle.truncate()</code> can be used to reset\nthe file contents.</p>",
+              "type": "module",
+              "displayName": "File system flags"
             }
           ],
-          "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_symlink_target_path_type_callback\"><code>fs.symlink()</code></a>.</p>"
-        },
+          "type": "module",
+          "displayName": "Notes"
+        }
+      ],
+      "type": "module",
+      "displayName": "fs",
+      "source": "doc/api/fs.md"
+    },
+    {
+      "textRaw": "HTTP",
+      "name": "http",
+      "introduced_in": "v0.10.0",
+      "stability": 2,
+      "stabilityText": "Stable",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/http.js\">lib/http.js</a></p>\n<p>To use the HTTP server and client one must <code>require('http')</code>.</p>\n<p>The HTTP interfaces in Node.js are designed to support many features\nof the protocol which have been traditionally difficult to use.\nIn particular, large, possibly chunk-encoded, messages. The interface is\ncareful to never buffer entire requests or responses, so the\nuser is able to stream data.</p>\n<p>HTTP message headers are represented by an object like this:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{ 'content-length': '123',\n  'content-type': 'text/plain',\n  'connection': 'keep-alive',\n  'host': 'mysite.com',\n  'accept': '*/*' }\n</code></pre>\n<p>Keys are lowercased. Values are not modified.</p>\n<p>In order to support the full spectrum of possible HTTP applications, the Node.js\nHTTP API is very low-level. It deals with stream handling and message\nparsing only. It parses a message into headers and body but it does not\nparse the actual headers or the body.</p>\n<p>See <a href=\"http.html#http_message_headers\"><code>message.headers</code></a> for details on how duplicate headers are handled.</p>\n<p>The raw headers as they were received are retained in the <code>rawHeaders</code>\nproperty, which is an array of <code>[key, value, key2, value2, ...]</code>. For\nexample, the previous message header object might have a <code>rawHeaders</code>\nlist like the following:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[ 'ConTent-Length', '123456',\n  'content-LENGTH', '123',\n  'content-type', 'text/plain',\n  'CONNECTION', 'keep-alive',\n  'Host', 'mysite.com',\n  'accepT', '*/*' ]\n</code></pre>",
+      "classes": [
         {
-          "textRaw": "`fs.truncate(path[, len], callback)`",
-          "type": "method",
-          "name": "truncate",
+          "textRaw": "Class: `http.Agent`",
+          "type": "class",
+          "name": "http.Agent",
           "meta": {
             "added": [
-              "v0.8.6"
+              "v0.3.4"
             ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
+            "changes": []
           },
-          "signatures": [
+          "desc": "<p>An <code>Agent</code> is responsible for managing connection persistence\nand reuse for HTTP clients. It maintains a queue of pending requests\nfor a given host and port, reusing a single socket connection for each\nuntil the queue is empty, at which time the socket is either destroyed\nor put into a pool where it is kept to be used again for requests to the\nsame host and port. Whether it is destroyed or pooled depends on the\n<code>keepAlive</code> <a href=\"http.html#http_new_agent_options\">option</a>.</p>\n<p>Pooled connections have TCP Keep-Alive enabled for them, but servers may\nstill close idle connections, in which case they will be removed from the\npool and a new connection will be made when a new HTTP request is made for\nthat host and port. Servers may also refuse to allow multiple requests\nover the same connection, in which case the connection will have to be\nremade for every request and cannot be pooled. The <code>Agent</code> will still make\nthe requests to that server, but each one will occur over a new connection.</p>\n<p>When a connection is closed by the client or the server, it is removed\nfrom the pool. Any unused sockets in the pool will be unrefed so as not\nto keep the Node.js process running when there are no outstanding requests.\n(see <a href=\"net.html#net_socket_unref\"><code>socket.unref()</code></a>).</p>\n<p>It is good practice, to <a href=\"http.html#http_agent_destroy\"><code>destroy()</code></a> an <code>Agent</code> instance when it is no\nlonger in use, because unused sockets consume OS resources.</p>\n<p>Sockets are removed from an agent when the socket emits either\na <code>'close'</code> event or an <code>'agentRemove'</code> event. When intending to keep one\nHTTP request open for a long time without keeping it in the agent, something\nlike the following may be done:</p>\n<pre><code class=\"language-js\">http.get(options, (res) => {\n  // Do stuff\n}).on('socket', (socket) => {\n  socket.emit('agentRemove');\n});\n</code></pre>\n<p>An agent may also be used for an individual request. By providing\n<code>{agent: false}</code> as an option to the <code>http.get()</code> or <code>http.request()</code>\nfunctions, a one-time use <code>Agent</code> with default options will be used\nfor the client connection.</p>\n<p><code>agent:false</code>:</p>\n<pre><code class=\"language-js\">http.get({\n  hostname: 'localhost',\n  port: 80,\n  path: '/',\n  agent: false  // Create a new agent just for this one request\n}, (res) => {\n  // Do stuff with response\n});\n</code></pre>",
+          "methods": [
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`len` {integer} **Default:** `0`",
-                  "name": "len",
-                  "type": "integer",
-                  "default": "`0`"
-                },
+              "textRaw": "`agent.createConnection(options[, callback])`",
+              "type": "method",
+              "name": "createConnection",
+              "meta": {
+                "added": [
+                  "v0.11.4"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {stream.Duplex}",
+                    "name": "return",
+                    "type": "stream.Duplex"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`options` {Object} Options containing connection details. Check [`net.createConnection()`][] for the format of the options",
+                      "name": "options",
+                      "type": "Object",
+                      "desc": "Options containing connection details. Check [`net.createConnection()`][] for the format of the options"
+                    },
+                    {
+                      "textRaw": "`callback` {Function} Callback function that receives the created socket",
+                      "name": "callback",
+                      "type": "Function",
+                      "desc": "Callback function that receives the created socket"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/truncate.2.html\"><code>truncate(2)</code></a>. No arguments other than a possible exception are\ngiven to the completion callback. A file descriptor can also be passed as the\nfirst argument. In this case, <code>fs.ftruncate()</code> is called.</p>\n<p>Passing a file descriptor is deprecated and may result in an error being thrown\nin the future.</p>"
-        },
-        {
-          "textRaw": "`fs.truncateSync(path[, len])`",
-          "type": "method",
-          "name": "truncateSync",
-          "meta": {
-            "added": [
-              "v0.8.6"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Produces a socket/stream to be used for HTTP requests.</p>\n<p>By default, this function is the same as <a href=\"net.html#net_net_createconnection_options_connectlistener\"><code>net.createConnection()</code></a>. However,\ncustom agents may override this method in case greater flexibility is desired.</p>\n<p>A socket/stream can be supplied in one of two ways: by returning the\nsocket/stream from this function, or by passing the socket/stream to <code>callback</code>.</p>\n<p>This method is guaranteed to return an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p><code>callback</code> has a signature of <code>(err, stream)</code>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`len` {integer} **Default:** `0`",
-                  "name": "len",
-                  "type": "integer",
-                  "default": "`0`"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/truncate.2.html\"><code>truncate(2)</code></a>. Returns <code>undefined</code>. A file descriptor can also be\npassed as the first argument. In this case, <code>fs.ftruncateSync()</code> is called.</p>\n<p>Passing a file descriptor is deprecated and may result in an error being thrown\nin the future.</p>"
-        },
-        {
-          "textRaw": "`fs.unlink(path, callback)`",
-          "type": "method",
-          "name": "unlink",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
+              "textRaw": "`agent.keepSocketAlive(socket)`",
+              "type": "method",
+              "name": "keepSocketAlive",
+              "meta": {
+                "added": [
+                  "v8.1.0"
+                ],
+                "changes": []
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`socket` {stream.Duplex}",
+                      "name": "socket",
+                      "type": "stream.Duplex"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously removes a file or symbolic link. No arguments other than a\npossible exception are given to the completion callback.</p>\n<pre><code class=\"language-js\">// Assuming that 'path/file.txt' is a regular file.\nfs.unlink('path/file.txt', (err) => {\n  if (err) throw err;\n  console.log('path/file.txt was deleted');\n});\n</code></pre>\n<p><code>fs.unlink()</code> will not work on a directory, empty or otherwise. To remove a\ndirectory, use <a href=\"fs.html#fs_fs_rmdir_path_options_callback\"><code>fs.rmdir()</code></a>.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.unlinkSync(path)`",
-          "type": "method",
-          "name": "unlinkSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Called when <code>socket</code> is detached from a request and could be persisted by the\n<code>Agent</code>. Default behavior is to:</p>\n<pre><code class=\"language-js\">socket.setKeepAlive(true, this.keepAliveMsecs);\nsocket.unref();\nreturn true;\n</code></pre>\n<p>This method can be overridden by a particular <code>Agent</code> subclass. If this\nmethod returns a falsy value, the socket will be destroyed instead of persisting\nit for use with the next request.</p>\n<p>The <code>socket</code> argument can be an instance of <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>, a subclass of\n<a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>.</p>"
+            },
             {
-              "params": [
+              "textRaw": "`agent.reuseSocket(socket, request)`",
+              "type": "method",
+              "name": "reuseSocket",
+              "meta": {
+                "added": [
+                  "v8.1.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "params": [
+                    {
+                      "textRaw": "`socket` {stream.Duplex}",
+                      "name": "socket",
+                      "type": "stream.Duplex"
+                    },
+                    {
+                      "textRaw": "`request` {http.ClientRequest}",
+                      "name": "request",
+                      "type": "http.ClientRequest"
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.unwatchFile(filename[, listener])`",
-          "type": "method",
-          "name": "unwatchFile",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Called when <code>socket</code> is attached to <code>request</code> after being persisted because of\nthe keep-alive options. Default behavior is to:</p>\n<pre><code class=\"language-js\">socket.ref();\n</code></pre>\n<p>This method can be overridden by a particular <code>Agent</code> subclass.</p>\n<p>The <code>socket</code> argument can be an instance of <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>, a subclass of\n<a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`filename` {string|Buffer|URL}",
-                  "name": "filename",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`agent.destroy()`",
+              "type": "method",
+              "name": "destroy",
+              "meta": {
+                "added": [
+                  "v0.11.4"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`listener` {Function} Optional, a listener previously attached using `fs.watchFile()`",
-                  "name": "listener",
-                  "type": "Function",
-                  "desc": "Optional, a listener previously attached using `fs.watchFile()`"
+                  "params": []
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Stop watching for changes on <code>filename</code>. If <code>listener</code> is specified, only that\nparticular listener is removed. Otherwise, <em>all</em> listeners are removed,\neffectively stopping watching of <code>filename</code>.</p>\n<p>Calling <code>fs.unwatchFile()</code> with a filename that is not being watched is a\nno-op, not an error.</p>\n<p>Using <a href=\"fs.html#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile()</code> and\n<code>fs.unwatchFile()</code>. <code>fs.watch()</code> should be used instead of <code>fs.watchFile()</code>\nand <code>fs.unwatchFile()</code> when possible.</p>"
-        },
-        {
-          "textRaw": "`fs.utimes(path, atime, mtime, callback)`",
-          "type": "method",
-          "name": "utimes",
-          "meta": {
-            "added": [
-              "v0.4.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v8.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/11919",
-                "description": "`NaN`, `Infinity`, and `-Infinity` are no longer valid time specifiers."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v4.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2387",
-                "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Destroy any sockets that are currently in use by the agent.</p>\n<p>It is usually not necessary to do this. However, if using an\nagent with <code>keepAlive</code> enabled, then it is best to explicitly shut down\nthe agent when it is no longer needed. Otherwise,\nsockets might stay open for quite a long time before the server\nterminates them.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
-                {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
-                },
+              "textRaw": "`agent.getName(options)`",
+              "type": "method",
+              "name": "getName",
+              "meta": {
+                "added": [
+                  "v0.11.4"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string}",
+                    "name": "return",
+                    "type": "string"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`options` {Object} A set of options providing information for name generation",
+                      "name": "options",
+                      "type": "Object",
+                      "desc": "A set of options providing information for name generation",
+                      "options": [
+                        {
+                          "textRaw": "`host` {string} A domain name or IP address of the server to issue the request to",
+                          "name": "host",
+                          "type": "string",
+                          "desc": "A domain name or IP address of the server to issue the request to"
+                        },
+                        {
+                          "textRaw": "`port` {number} Port of remote server",
+                          "name": "port",
+                          "type": "number",
+                          "desc": "Port of remote server"
+                        },
+                        {
+                          "textRaw": "`localAddress` {string} Local interface to bind for network connections when issuing the request",
+                          "name": "localAddress",
+                          "type": "string",
+                          "desc": "Local interface to bind for network connections when issuing the request"
+                        },
+                        {
+                          "textRaw": "`family` {integer} Must be 4 or 6 if this doesn't equal `undefined`.",
+                          "name": "family",
+                          "type": "integer",
+                          "desc": "Must be 4 or 6 if this doesn't equal `undefined`."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
+              ],
+              "desc": "<p>Get a unique name for a set of request options, to determine whether a\nconnection can be reused. For an HTTP agent, this returns\n<code>host:port:localAddress</code> or <code>host:port:localAddress:family</code>. For an HTTPS agent,\nthe name includes the CA, cert, ciphers, and other HTTPS/TLS-specific options\nthat determine socket reusability.</p>"
             }
           ],
-          "desc": "<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>\n<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>\n<ul>\n<li>Values can be either numbers representing Unix epoch time in seconds,\n<code>Date</code>s, or a numeric string like <code>'123456789.0'</code>.</li>\n<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or\n<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>\n</ul>"
-        },
-        {
-          "textRaw": "`fs.utimesSync(path, atime, mtime)`",
-          "type": "method",
-          "name": "utimesSync",
-          "meta": {
-            "added": [
-              "v0.4.2"
-            ],
-            "changes": [
-              {
-                "version": "v8.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/11919",
-                "description": "`NaN`, `Infinity`, and `-Infinity` are no longer valid time specifiers."
+          "properties": [
+            {
+              "textRaw": "`freeSockets` {Object}",
+              "type": "Object",
+              "name": "freeSockets",
+              "meta": {
+                "added": [
+                  "v0.11.4"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An object which contains arrays of sockets currently awaiting use by\nthe agent when <code>keepAlive</code> is enabled. Do not modify.</p>\n<p>Sockets in the <code>freeSockets</code> list will be automatically destroyed and\nremoved from the array on <code>'timeout'</code>.</p>"
+            },
+            {
+              "textRaw": "`maxFreeSockets` {number}",
+              "type": "number",
+              "name": "maxFreeSockets",
+              "meta": {
+                "added": [
+                  "v0.11.7"
+                ],
+                "changes": []
+              },
+              "desc": "<p>By default set to 256. For agents with <code>keepAlive</code> enabled, this\nsets the maximum number of sockets that will be left open in the free\nstate.</p>"
+            },
+            {
+              "textRaw": "`maxSockets` {number}",
+              "type": "number",
+              "name": "maxSockets",
+              "meta": {
+                "added": [
+                  "v0.3.6"
+                ],
+                "changes": []
+              },
+              "desc": "<p>By default set to <code>Infinity</code>. Determines how many concurrent sockets the agent\ncan have open per origin. Origin is the returned value of <a href=\"http.html#http_agent_getname_options\"><code>agent.getName()</code></a>.</p>"
+            },
+            {
+              "textRaw": "`maxTotalSockets` {number}",
+              "type": "number",
+              "name": "maxTotalSockets",
+              "meta": {
+                "added": [
+                  "v14.5.0"
+                ],
+                "changes": []
               },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
+              "desc": "<p>By default set to <code>Infinity</code>. Determines how many concurrent sockets the agent\ncan have open. Unlike <code>maxSockets</code>, this parameter applies across all origins.</p>"
+            },
+            {
+              "textRaw": "`requests` {Object}",
+              "type": "Object",
+              "name": "requests",
+              "meta": {
+                "added": [
+                  "v0.5.9"
+                ],
+                "changes": []
               },
-              {
-                "version": "v4.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2387",
-                "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
-              }
-            ]
-          },
-          "signatures": [
+              "desc": "<p>An object which contains queues of requests that have not yet been assigned to\nsockets. Do not modify.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
-                {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
-                }
-              ]
+              "textRaw": "`sockets` {Object}",
+              "type": "Object",
+              "name": "sockets",
+              "meta": {
+                "added": [
+                  "v0.3.6"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An object which contains arrays of sockets currently in use by the\nagent. Do not modify.</p>"
             }
           ],
-          "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.watch(filename[, options][, listener])`",
-          "type": "method",
-          "name": "watch",
-          "meta": {
-            "added": [
-              "v0.5.10"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `filename` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
-              }
-            ]
-          },
           "signatures": [
             {
-              "return": {
-                "textRaw": "Returns: {fs.FSWatcher}",
-                "name": "return",
-                "type": "fs.FSWatcher"
-              },
               "params": [
                 {
-                  "textRaw": "`filename` {string|Buffer|URL}",
-                  "name": "filename",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`options` {string|Object}",
+                  "textRaw": "`options` {Object} Set of configurable options to set on the agent. Can have the following fields:",
                   "name": "options",
-                  "type": "string|Object",
+                  "type": "Object",
+                  "desc": "Set of configurable options to set on the agent. Can have the following fields:",
                   "options": [
                     {
-                      "textRaw": "`persistent` {boolean} Indicates whether the process should continue to run as long as files are being watched. **Default:** `true`.",
-                      "name": "persistent",
+                      "textRaw": "`keepAlive` {boolean} Keep sockets around even when there are no outstanding requests, so they can be used for future requests without having to reestablish a TCP connection. Not to be confused with the `keep-alive` value of the `Connection` header. The `Connection: keep-alive` header is always sent when using an agent except when the `Connection` header is explicitly specified or when the `keepAlive` and `maxSockets` options are respectively set to `false` and `Infinity`, in which case `Connection: close` will be used. **Default:** `false`.",
+                      "name": "keepAlive",
                       "type": "boolean",
-                      "default": "`true`",
-                      "desc": "Indicates whether the process should continue to run as long as files are being watched."
+                      "default": "`false`",
+                      "desc": "Keep sockets around even when there are no outstanding requests, so they can be used for future requests without having to reestablish a TCP connection. Not to be confused with the `keep-alive` value of the `Connection` header. The `Connection: keep-alive` header is always sent when using an agent except when the `Connection` header is explicitly specified or when the `keepAlive` and `maxSockets` options are respectively set to `false` and `Infinity`, in which case `Connection: close` will be used."
                     },
                     {
-                      "textRaw": "`recursive` {boolean} Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [Caveats][]). **Default:** `false`.",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [Caveats][])."
+                      "textRaw": "`keepAliveMsecs` {number} When using the `keepAlive` option, specifies the [initial delay](net.md#net_socket_setkeepalive_enable_initialdelay) for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`. **Default:** `1000`.",
+                      "name": "keepAliveMsecs",
+                      "type": "number",
+                      "default": "`1000`",
+                      "desc": "When using the `keepAlive` option, specifies the [initial delay](net.md#net_socket_setkeepalive_enable_initialdelay) for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`."
                     },
                     {
-                      "textRaw": "`encoding` {string} Specifies the character encoding to be used for the filename passed to the listener. **Default:** `'utf8'`.",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`",
-                      "desc": "Specifies the character encoding to be used for the filename passed to the listener."
-                    }
-                  ]
-                },
-                {
-                  "textRaw": "`listener` {Function|undefined} **Default:** `undefined`",
-                  "name": "listener",
-                  "type": "Function|undefined",
-                  "default": "`undefined`",
-                  "options": [
+                      "textRaw": "`maxSockets` {number} Maximum number of sockets to allow per host. If the same host opens multiple concurrent connections, each request will use new socket until the `maxSockets` value is reached. If the host attempts to open more connections than `maxSockets`, the additional requests will enter into a pending request queue, and will enter active connection state when an existing connection terminates. This makes sure there are at most `maxSockets` active connections at any point in time, from a given host. **Default:** `Infinity`.",
+                      "name": "maxSockets",
+                      "type": "number",
+                      "default": "`Infinity`",
+                      "desc": "Maximum number of sockets to allow per host. If the same host opens multiple concurrent connections, each request will use new socket until the `maxSockets` value is reached. If the host attempts to open more connections than `maxSockets`, the additional requests will enter into a pending request queue, and will enter active connection state when an existing connection terminates. This makes sure there are at most `maxSockets` active connections at any point in time, from a given host."
+                    },
                     {
-                      "textRaw": "`eventType` {string}",
-                      "name": "eventType",
-                      "type": "string"
+                      "textRaw": "`maxTotalSockets` {number} Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached. **Default:** `Infinity`.",
+                      "name": "maxTotalSockets",
+                      "type": "number",
+                      "default": "`Infinity`",
+                      "desc": "Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached."
                     },
                     {
-                      "textRaw": "`filename` {string|Buffer}",
-                      "name": "filename",
-                      "type": "string|Buffer"
+                      "textRaw": "`maxFreeSockets` {number} Maximum number of sockets to leave open in a free state. Only relevant if `keepAlive` is set to `true`. **Default:** `256`.",
+                      "name": "maxFreeSockets",
+                      "type": "number",
+                      "default": "`256`",
+                      "desc": "Maximum number of sockets to leave open in a free state. Only relevant if `keepAlive` is set to `true`."
+                    },
+                    {
+                      "textRaw": "`scheduling` {string} Scheduling strategy to apply when picking the next free socket to use. It can be `'fifo'` or `'lifo'`. The main difference between the two scheduling strategies is that `'lifo'` selects the most recently used socket, while `'fifo'` selects the least recently used socket. In case of a low rate of request per second, the `'lifo'` scheduling will lower the risk of picking a socket that might have been closed by the server due to inactivity. In case of a high rate of request per second, the `'fifo'` scheduling will maximize the number of open sockets, while the `'lifo'` scheduling will keep it as low as possible. **Default:** `'lifo'`.",
+                      "name": "scheduling",
+                      "type": "string",
+                      "default": "`'lifo'`",
+                      "desc": "Scheduling strategy to apply when picking the next free socket to use. It can be `'fifo'` or `'lifo'`. The main difference between the two scheduling strategies is that `'lifo'` selects the most recently used socket, while `'fifo'` selects the least recently used socket. In case of a low rate of request per second, the `'lifo'` scheduling will lower the risk of picking a socket that might have been closed by the server due to inactivity. In case of a high rate of request per second, the `'fifo'` scheduling will maximize the number of open sockets, while the `'lifo'` scheduling will keep it as low as possible."
+                    },
+                    {
+                      "textRaw": "`timeout` {number} Socket timeout in milliseconds. This will set the timeout when the socket is created.",
+                      "name": "timeout",
+                      "type": "number",
+                      "desc": "Socket timeout in milliseconds. This will set the timeout when the socket is created."
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Watch for changes on <code>filename</code>, where <code>filename</code> is either a file or a\ndirectory.</p>\n<p>The second argument is optional. If <code>options</code> is provided as a string, it\nspecifies the <code>encoding</code>. Otherwise <code>options</code> should be passed as an object.</p>\n<p>The listener callback gets two arguments <code>(eventType, filename)</code>. <code>eventType</code>\nis either <code>'rename'</code> or <code>'change'</code>, and <code>filename</code> is the name of the file\nwhich triggered the event.</p>\n<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or\ndisappears in the directory.</p>\n<p>The listener callback is attached to the <code>'change'</code> event fired by\n<a href=\"fs.html#fs_class_fs_fswatcher\"><code>fs.FSWatcher</code></a>, but it is not the same thing as the <code>'change'</code> value of\n<code>eventType</code>.</p>",
-          "miscs": [
-            {
-              "textRaw": "Caveats",
-              "name": "Caveats",
-              "type": "misc",
-              "desc": "<p>The <code>fs.watch</code> API is not 100% consistent across platforms, and is\nunavailable in some situations.</p>\n<p>The recursive option is only supported on macOS and Windows.</p>\n<p>On Windows, no events will be emitted if the watched directory is moved or\nrenamed. An <code>EPERM</code> error is reported when the watched directory is deleted.</p>",
-              "miscs": [
-                {
-                  "textRaw": "Availability",
-                  "name": "Availability",
-                  "type": "misc",
-                  "desc": "<p>This feature depends on the underlying operating system providing a way\nto be notified of filesystem changes.</p>\n<ul>\n<li>On Linux systems, this uses <a href=\"https://man7.org/linux/man-pages/man7/inotify.7.html\"><code>inotify(7)</code></a>.</li>\n<li>On BSD systems, this uses <a href=\"https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2\"><code>kqueue(2)</code></a>.</li>\n<li>On macOS, this uses <a href=\"https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2\"><code>kqueue(2)</code></a> for files and <a href=\"https://developer.apple.com/documentation/coreservices/file_system_events\"><code>FSEvents</code></a> for\ndirectories.</li>\n<li>On SunOS systems (including Solaris and SmartOS), this uses <a href=\"https://illumos.org/man/port_create\"><code>event ports</code></a>.</li>\n<li>On Windows systems, this feature depends on <a href=\"https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw\"><code>ReadDirectoryChangesW</code></a>.</li>\n<li>On Aix systems, this feature depends on <a href=\"https://www.ibm.com/developerworks/aix/library/au-aix_event_infrastructure/\"><code>AHAFS</code></a>, which must be enabled.</li>\n<li>On IBM i systems, this feature is not supported.</li>\n</ul>\n<p>If the underlying functionality is not available for some reason, then\n<code>fs.watch()</code> will not be able to function and may thrown an exception.\nFor example, watching files or directories can be unreliable, and in some\ncases impossible, on network file systems (NFS, SMB, etc) or host file systems\nwhen using virtualization software such as Vagrant or Docker.</p>\n<p>It is still possible to use <code>fs.watchFile()</code>, which uses stat polling, but\nthis method is slower and less reliable.</p>"
-                },
-                {
-                  "textRaw": "Inodes",
-                  "name": "Inodes",
-                  "type": "misc",
-                  "desc": "<p>On Linux and macOS systems, <code>fs.watch()</code> resolves the path to an <a href=\"https://en.wikipedia.org/wiki/Inode\">inode</a> and\nwatches the inode. If the watched path is deleted and recreated, it is assigned\na new inode. The watch will emit an event for the delete but will continue\nwatching the <em>original</em> inode. Events for the new inode will not be emitted.\nThis is expected behavior.</p>\n<p>AIX files retain the same inode for the lifetime of a file. Saving and closing a\nwatched file on AIX will result in two notifications (one for adding new\ncontent, and one for truncation).</p>"
-                },
-                {
-                  "textRaw": "Filename argument",
-                  "name": "Filename argument",
-                  "type": "misc",
-                  "desc": "<p>Providing <code>filename</code> argument in the callback is only supported on Linux,\nmacOS, Windows, and AIX. Even on supported platforms, <code>filename</code> is not always\nguaranteed to be provided. Therefore, don't assume that <code>filename</code> argument is\nalways provided in the callback, and have some fallback logic if it is <code>null</code>.</p>\n<pre><code class=\"language-js\">fs.watch('somedir', (eventType, filename) => {\n  console.log(`event type is: ${eventType}`);\n  if (filename) {\n    console.log(`filename provided: ${filename}`);\n  } else {\n    console.log('filename not provided');\n  }\n});\n</code></pre>"
-                }
-              ]
+              ],
+              "desc": "<p><code>options</code> in <a href=\"net.html#net_socket_connect_options_connectlistener\"><code>socket.connect()</code></a> are also supported.</p>\n<p>The default <a href=\"http.html#http_http_globalagent\"><code>http.globalAgent</code></a> that is used by <a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a> has all\nof these values set to their respective defaults.</p>\n<p>To configure any of them, a custom <a href=\"http.html#http_class_http_agent\"><code>http.Agent</code></a> instance must be created.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst keepAliveAgent = new http.Agent({ keepAlive: true });\noptions.agent = keepAliveAgent;\nhttp.request(options, onResponseCallback);\n</code></pre>"
             }
           ]
         },
         {
-          "textRaw": "`fs.watchFile(filename[, options], listener)`",
-          "type": "method",
-          "name": "watchFile",
+          "textRaw": "Class: `http.ClientRequest`",
+          "type": "class",
+          "name": "http.ClientRequest",
           "meta": {
             "added": [
-              "v0.1.31"
+              "v0.1.17"
             ],
-            "changes": [
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "The `bigint` option is now supported."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `filename` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
+            "changes": []
           },
-          "signatures": [
+          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a></li>\n</ul>\n<p>This object is created internally and returned from <a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a>. It\nrepresents an <em>in-progress</em> request whose header has already been queued. The\nheader is still mutable using the <a href=\"http.html#http_request_setheader_name_value\"><code>setHeader(name, value)</code></a>,\n<a href=\"http.html#http_request_getheader_name\"><code>getHeader(name)</code></a>, <a href=\"http.html#http_request_removeheader_name\"><code>removeHeader(name)</code></a> API. The actual header will\nbe sent along with the first data chunk or when calling <a href=\"http.html#http_request_end_data_encoding_callback\"><code>request.end()</code></a>.</p>\n<p>To get the response, add a listener for <a href=\"http.html#http_event_response\"><code>'response'</code></a> to the request object.\n<a href=\"http.html#http_event_response\"><code>'response'</code></a> will be emitted from the request object when the response\nheaders have been received. The <a href=\"http.html#http_event_response\"><code>'response'</code></a> event is executed with one\nargument which is an instance of <a href=\"http.html#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>During the <a href=\"http.html#http_event_response\"><code>'response'</code></a> event, one can add listeners to the\nresponse object; particularly to listen for the <code>'data'</code> event.</p>\n<p>If no <a href=\"http.html#http_event_response\"><code>'response'</code></a> handler is added, then the response will be\nentirely discarded. However, if a <a href=\"http.html#http_event_response\"><code>'response'</code></a> event handler is added,\nthen the data from the response object <strong>must</strong> be consumed, either by\ncalling <code>response.read()</code> whenever there is a <code>'readable'</code> event, or\nby adding a <code>'data'</code> handler, or by calling the <code>.resume()</code> method.\nUntil the data is consumed, the <code>'end'</code> event will not fire. Also, until\nthe data is read it will consume memory that can eventually lead to a\n'process out of memory' error.</p>\n<p>Unlike the <code>request</code> object, if the response closes prematurely, the\n<code>response</code> object does not emit an <code>'error'</code> event but instead emits the\n<code>'aborted'</code> event.</p>\n<p>Node.js does not check whether Content-Length and the length of the\nbody which has been transmitted are equal or not.</p>",
+          "events": [
             {
-              "return": {
-                "textRaw": "Returns: {fs.StatWatcher}",
-                "name": "return",
-                "type": "fs.StatWatcher"
+              "textRaw": "Event: `'abort'`",
+              "type": "event",
+              "name": "abort",
+              "meta": {
+                "added": [
+                  "v1.4.1"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>Emitted when the request has been aborted by the client. This event is only\nemitted on the first call to <code>abort()</code>.</p>"
+            },
+            {
+              "textRaw": "Event: `'connect'`",
+              "type": "event",
+              "name": "connect",
+              "meta": {
+                "added": [
+                  "v0.7.0"
+                ],
+                "changes": []
               },
               "params": [
                 {
-                  "textRaw": "`filename` {string|Buffer|URL}",
-                  "name": "filename",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`response` {http.IncomingMessage}",
+                  "name": "response",
+                  "type": "http.IncomingMessage"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`bigint` {boolean} **Default:** `false`",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`"
-                    },
-                    {
-                      "textRaw": "`persistent` {boolean} **Default:** `true`",
-                      "name": "persistent",
-                      "type": "boolean",
-                      "default": "`true`"
-                    },
-                    {
-                      "textRaw": "`interval` {integer} **Default:** `5007`",
-                      "name": "interval",
-                      "type": "integer",
-                      "default": "`5007`"
-                    }
-                  ]
+                  "textRaw": "`socket` {stream.Duplex}",
+                  "name": "socket",
+                  "type": "stream.Duplex"
                 },
                 {
-                  "textRaw": "`listener` {Function}",
-                  "name": "listener",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`current` {fs.Stats}",
-                      "name": "current",
-                      "type": "fs.Stats"
-                    },
-                    {
-                      "textRaw": "`previous` {fs.Stats}",
-                      "name": "previous",
-                      "type": "fs.Stats"
-                    }
-                  ]
+                  "textRaw": "`head` {Buffer}",
+                  "name": "head",
+                  "type": "Buffer"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Watch for changes on <code>filename</code>. The callback <code>listener</code> will be called each\ntime the file is accessed.</p>\n<p>The <code>options</code> argument may be omitted. If provided, it should be an object. The\n<code>options</code> object may contain a boolean named <code>persistent</code> that indicates\nwhether the process should continue to run as long as files are being watched.\nThe <code>options</code> object may specify an <code>interval</code> property indicating how often the\ntarget should be polled in milliseconds.</p>\n<p>The <code>listener</code> gets two arguments the current stat object and the previous\nstat object:</p>\n<pre><code class=\"language-js\">fs.watchFile('message.text', (curr, prev) => {\n  console.log(`the current mtime is: ${curr.mtime}`);\n  console.log(`the previous mtime was: ${prev.mtime}`);\n});\n</code></pre>\n<p>These stat objects are instances of <code>fs.Stat</code>. If the <code>bigint</code> option is <code>true</code>,\nthe numeric values in these objects are specified as <code>BigInt</code>s.</p>\n<p>To be notified when the file was modified, not just accessed, it is necessary\nto compare <code>curr.mtime</code> and <code>prev.mtime</code>.</p>\n<p>When an <code>fs.watchFile</code> operation results in an <code>ENOENT</code> error, it\nwill invoke the listener once, with all the fields zeroed (or, for dates, the\nUnix Epoch). If the file is created later on, the listener will be called\nagain, with the latest stat objects. This is a change in functionality since\nv0.10.</p>\n<p>Using <a href=\"fs.html#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile</code> and\n<code>fs.unwatchFile</code>. <code>fs.watch</code> should be used instead of <code>fs.watchFile</code> and\n<code>fs.unwatchFile</code> when possible.</p>\n<p>When a file being watched by <code>fs.watchFile()</code> disappears and reappears,\nthen the contents of <code>previous</code> in the second callback event (the file's\nreappearance) will be the same as the contents of <code>previous</code> in the first\ncallback event (its disappearance).</p>\n<p>This happens when:</p>\n<ul>\n<li>the file is deleted, followed by a restore</li>\n<li>the file is renamed and then renamed a second time back to its original name</li>\n</ul>"
-        },
-        {
-          "textRaw": "`fs.write(fd, buffer[, offset[, length[, position]]], callback)`",
-          "type": "method",
-          "name": "write",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`"
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `buffer` parameter can now be a `Uint8Array`."
-              },
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7856",
-                "description": "The `offset` and `length` parameters are optional now."
+              ],
+              "desc": "<p>Emitted each time a server responds to a request with a <code>CONNECT</code> method. If\nthis event is not being listened for, clients receiving a <code>CONNECT</code> method will\nhave their connections closed.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>A client and server pair demonstrating how to listen for the <code>'connect'</code> event:</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst net = require('net');\nconst { URL } = require('url');\n\n// Create an HTTP tunneling proxy\nconst proxy = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('okay');\n});\nproxy.on('connect', (req, clientSocket, head) => {\n  // Connect to an origin server\n  const { port, hostname } = new URL(`http://${req.url}`);\n  const serverSocket = net.connect(port || 80, hostname, () => {\n    clientSocket.write('HTTP/1.1 200 Connection Established\\r\\n' +\n                    'Proxy-agent: Node.js-Proxy\\r\\n' +\n                    '\\r\\n');\n    serverSocket.write(head);\n    serverSocket.pipe(clientSocket);\n    clientSocket.pipe(serverSocket);\n  });\n});\n\n// Now that proxy is running\nproxy.listen(1337, '127.0.0.1', () => {\n\n  // Make a request to a tunneling proxy\n  const options = {\n    port: 1337,\n    host: '127.0.0.1',\n    method: 'CONNECT',\n    path: 'www.google.com:80'\n  };\n\n  const req = http.request(options);\n  req.end();\n\n  req.on('connect', (res, socket, head) => {\n    console.log('got connected!');\n\n    // Make a request over an HTTP tunnel\n    socket.write('GET / HTTP/1.1\\r\\n' +\n                 'Host: www.google.com:80\\r\\n' +\n                 'Connection: close\\r\\n' +\n                 '\\r\\n');\n    socket.on('data', (chunk) => {\n      console.log(chunk.toString());\n    });\n    socket.on('end', () => {\n      proxy.close();\n    });\n  });\n});\n</code></pre>"
+            },
+            {
+              "textRaw": "Event: `'continue'`",
+              "type": "event",
+              "name": "continue",
+              "meta": {
+                "added": [
+                  "v0.3.2"
+                ],
+                "changes": []
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              "params": [],
+              "desc": "<p>Emitted when the server sends a '100 Continue' HTTP response, usually because\nthe request contained 'Expect: 100-continue'. This is an instruction that\nthe client should send the request body.</p>"
+            },
             {
+              "textRaw": "Event: `'information'`",
+              "type": "event",
+              "name": "information",
+              "meta": {
+                "added": [
+                  "v10.0.0"
+                ],
+                "changes": []
+              },
               "params": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
-                },
-                {
-                  "textRaw": "`offset` {integer}",
-                  "name": "offset",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`length` {integer}",
-                  "name": "length",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
+                  "textRaw": "`info` {Object}",
+                  "name": "info",
+                  "type": "Object",
                   "options": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`httpVersion` {string}",
+                      "name": "httpVersion",
+                      "type": "string"
                     },
                     {
-                      "textRaw": "`bytesWritten` {integer}",
-                      "name": "bytesWritten",
+                      "textRaw": "`httpVersionMajor` {integer}",
+                      "name": "httpVersionMajor",
                       "type": "integer"
                     },
                     {
-                      "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                      "name": "buffer",
-                      "type": "Buffer|TypedArray|DataView"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Write <code>buffer</code> to the file specified by <code>fd</code>.</p>\n<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is\nan integer specifying the number of bytes to write.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p>The callback will be given three arguments <code>(err, bytesWritten, buffer)</code> where\n<code>bytesWritten</code> specifies how many <em>bytes</em> were written from <code>buffer</code>.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>bytesWritten</code> and <code>buffer</code> properties.</p>\n<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting\nfor the callback. For this scenario, <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
-        },
-        {
-          "textRaw": "`fs.write(fd, string[, position[, encoding]], callback)`",
-          "type": "method",
-          "name": "write",
-          "meta": {
-            "added": [
-              "v0.11.5"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7856",
-                "description": "The `position` parameter is optional now."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`string` {string}",
-                  "name": "string",
-                  "type": "string"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                  "name": "encoding",
-                  "type": "string",
-                  "default": "`'utf8'`"
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`httpVersionMinor` {integer}",
+                      "name": "httpVersionMinor",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`written` {integer}",
-                      "name": "written",
+                      "textRaw": "`statusCode` {integer}",
+                      "name": "statusCode",
                       "type": "integer"
                     },
                     {
-                      "textRaw": "`string` {string}",
-                      "name": "string",
+                      "textRaw": "`statusMessage` {string}",
+                      "name": "statusMessage",
                       "type": "string"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Write <code>string</code> to the file specified by <code>fd</code>. If <code>string</code> is not a string, then\nthe value will be coerced to one.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code> the data will be written at\nthe current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p><code>encoding</code> is the expected string encoding.</p>\n<p>The callback will receive the arguments <code>(err, written, string)</code> where <code>written</code>\nspecifies how many <em>bytes</em> the passed string required to be written. Bytes\nwritten is not necessarily the same as string characters written. See\n<a href=\"buffer.html#buffer_static_method_buffer_bytelength_string_encoding\"><code>Buffer.byteLength</code></a>.</p>\n<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting\nfor the callback. For this scenario, <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>\n<p>On Windows, if the file descriptor is connected to the console (e.g. <code>fd == 1</code>\nor <code>stdout</code>) a string containing non-ASCII characters will not be rendered\nproperly by default, regardless of the encoding used.\nIt is possible to configure the console to render UTF-8 properly by changing the\nactive codepage with the <code>chcp 65001</code> command. See the <a href=\"https://ss64.com/nt/chcp.html\">chcp</a> docs for more\ndetails.</p>"
-        },
-        {
-          "textRaw": "`fs.writeFile(file, data[, options], callback)`",
-          "type": "method",
-          "name": "writeFile",
-          "meta": {
-            "added": [
-              "v0.1.29"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `data` parameter can now be any `TypedArray` or a `DataView`."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `data` parameter can now be a `Uint8Array`."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `file` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`file` {string|Buffer|URL|integer} filename or file descriptor",
-                  "name": "file",
-                  "type": "string|Buffer|URL|integer",
-                  "desc": "filename or file descriptor"
-                },
-                {
-                  "textRaw": "`data` {string|Buffer|TypedArray|DataView}",
-                  "name": "data",
-                  "type": "string|Buffer|TypedArray|DataView"
-                },
-                {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
                     },
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
+                      "textRaw": "`headers` {Object}",
+                      "name": "headers",
+                      "type": "Object"
                     },
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'w'`",
-                      "desc": "See [support of file system `flags`][]."
-                    }
-                  ]
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`rawHeaders` {string[]}",
+                      "name": "rawHeaders",
+                      "type": "string[]"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>When <code>file</code> is a filename, asynchronously writes data to the file, replacing the\nfile if it already exists.  <code>data</code> can be a string or a buffer.</p>\n<p>When <code>file</code> is a file descriptor, the behavior is similar to calling\n<code>fs.write()</code> directly (which is recommended). See the notes below on using\na file descriptor.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<pre><code class=\"language-js\">const data = new Uint8Array(Buffer.from('Hello Node.js'));\nfs.writeFile('message.txt', data, (err) => {\n  if (err) throw err;\n  console.log('The file has been saved!');\n});\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-js\">fs.writeFile('message.txt', 'Hello Node.js', 'utf8', callback);\n</code></pre>\n<p>It is unsafe to use <code>fs.writeFile()</code> multiple times on the same file without\nwaiting for the callback. For this scenario, <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>",
-          "modules": [
+              ],
+              "desc": "<p>Emitted when the server sends a 1xx intermediate response (excluding 101\nUpgrade). The listeners of this event will receive an object containing the\nHTTP version, status code, status message, key-value headers object,\nand array with the raw header names followed by their respective values.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst options = {\n  host: '127.0.0.1',\n  port: 8080,\n  path: '/length_request'\n};\n\n// Make a request\nconst req = http.request(options);\nreq.end();\n\nreq.on('information', (info) => {\n  console.log(`Got information prior to main response: ${info.statusCode}`);\n});\n</code></pre>\n<p>101 Upgrade statuses do not fire this event due to their break from the\ntraditional HTTP request/response chain, such as web sockets, in-place TLS\nupgrades, or HTTP 2.0. To be notified of 101 Upgrade notices, listen for the\n<a href=\"http.html#http_event_upgrade\"><code>'upgrade'</code></a> event instead.</p>"
+            },
             {
-              "textRaw": "Using `fs.writeFile()` with file descriptors",
-              "name": "using_`fs.writefile()`_with_file_descriptors",
-              "desc": "<p>When <code>file</code> is a file descriptor, the behavior is almost identical to directly\ncalling <code>fs.write()</code> like:</p>\n<pre><code class=\"language-js\">fs.write(fd, Buffer.from(data, options.encoding), callback);\n</code></pre>\n<p>The difference from directly calling <code>fs.write()</code> is that under some unusual\nconditions, <code>fs.write()</code> may write only part of the buffer and will need to be\nretried to write the remaining data, whereas <code>fs.writeFile()</code> will retry until\nthe data is entirely written (or an error occurs).</p>\n<p>The implications of this are a common source of confusion. In\nthe file descriptor case, the file is not replaced! The data is not necessarily\nwritten to the beginning of the file, and the file's original data may remain\nbefore and/or after the newly written data.</p>\n<p>For example, if <code>fs.writeFile()</code> is called twice in a row, first to write the\nstring <code>'Hello'</code>, then to write the string <code>', World'</code>, the file would contain\n<code>'Hello, World'</code>, and might contain some of the file's original data (depending\non the size of the original file, and the position of the file descriptor). If\na file name had been used instead of a descriptor, the file would be guaranteed\nto contain only <code>', World'</code>.</p>",
-              "type": "module",
-              "displayName": "Using `fs.writeFile()` with file descriptors"
-            }
-          ]
-        },
-        {
-          "textRaw": "`fs.writeFileSync(file, data[, options])`",
-          "type": "method",
-          "name": "writeFileSync",
-          "meta": {
-            "added": [
-              "v0.1.29"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `data` parameter can now be any `TypedArray` or a `DataView`."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `data` parameter can now be a `Uint8Array`."
+              "textRaw": "Event: `'response'`",
+              "type": "event",
+              "name": "response",
+              "meta": {
+                "added": [
+                  "v0.1.0"
+                ],
+                "changes": []
               },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `file` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
-            {
               "params": [
                 {
-                  "textRaw": "`file` {string|Buffer|URL|integer} filename or file descriptor",
-                  "name": "file",
-                  "type": "string|Buffer|URL|integer",
-                  "desc": "filename or file descriptor"
-                },
-                {
-                  "textRaw": "`data` {string|Buffer|TypedArray|DataView}",
-                  "name": "data",
-                  "type": "string|Buffer|TypedArray|DataView"
-                },
-                {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
-                    },
-                    {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
-                    },
-                    {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'w'`",
-                      "desc": "See [support of file system `flags`][]."
-                    }
-                  ]
+                  "textRaw": "`response` {http.IncomingMessage}",
+                  "name": "response",
+                  "type": "http.IncomingMessage"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_writefile_file_data_options_callback\"><code>fs.writeFile()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.writeSync(fd, buffer[, offset[, length[, position]]])`",
-          "type": "method",
-          "name": "writeSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
+              ],
+              "desc": "<p>Emitted when a response is received to this request. This event is emitted only\nonce.</p>"
+            },
+            {
+              "textRaw": "Event: `'socket'`",
+              "type": "event",
+              "name": "socket",
+              "meta": {
+                "added": [
+                  "v0.5.3"
+                ],
+                "changes": []
               },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `buffer` parameter can now be a `Uint8Array`."
+              "params": [
+                {
+                  "textRaw": "`socket` {stream.Duplex}",
+                  "name": "socket",
+                  "type": "stream.Duplex"
+                }
+              ],
+              "desc": "<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+            },
+            {
+              "textRaw": "Event: `'timeout'`",
+              "type": "event",
+              "name": "timeout",
+              "meta": {
+                "added": [
+                  "v0.7.8"
+                ],
+                "changes": []
               },
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7856",
-                "description": "The `offset` and `length` parameters are optional now."
-              }
-            ]
-          },
-          "signatures": [
+              "params": [],
+              "desc": "<p>Emitted when the underlying socket times out from inactivity. This only notifies\nthat the socket has been idle. The request must be aborted manually.</p>\n<p>See also: <a href=\"http.html#http_request_settimeout_timeout_callback\"><code>request.setTimeout()</code></a>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {number} The number of bytes written.",
-                "name": "return",
-                "type": "number",
-                "desc": "The number of bytes written."
+              "textRaw": "Event: `'upgrade'`",
+              "type": "event",
+              "name": "upgrade",
+              "meta": {
+                "added": [
+                  "v0.1.94"
+                ],
+                "changes": []
               },
               "params": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
-                },
-                {
-                  "textRaw": "`offset` {integer}",
-                  "name": "offset",
-                  "type": "integer"
+                  "textRaw": "`response` {http.IncomingMessage}",
+                  "name": "response",
+                  "type": "http.IncomingMessage"
                 },
                 {
-                  "textRaw": "`length` {integer}",
-                  "name": "length",
-                  "type": "integer"
+                  "textRaw": "`socket` {stream.Duplex}",
+                  "name": "socket",
+                  "type": "stream.Duplex"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
+                  "textRaw": "`head` {Buffer}",
+                  "name": "head",
+                  "type": "Buffer"
                 }
-              ]
+              ],
+              "desc": "<p>Emitted each time a server responds to a request with an upgrade. If this\nevent is not being listened for and the response status code is 101 Switching\nProtocols, clients receiving an upgrade header will have their connections\nclosed.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>A client server pair demonstrating how to listen for the <code>'upgrade'</code> event.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\n// Create an HTTP server\nconst server = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('okay');\n});\nserver.on('upgrade', (req, socket, head) => {\n  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\\r\\n' +\n               'Upgrade: WebSocket\\r\\n' +\n               'Connection: Upgrade\\r\\n' +\n               '\\r\\n');\n\n  socket.pipe(socket); // echo back\n});\n\n// Now that server is running\nserver.listen(1337, '127.0.0.1', () => {\n\n  // make a request\n  const options = {\n    port: 1337,\n    host: '127.0.0.1',\n    headers: {\n      'Connection': 'Upgrade',\n      'Upgrade': 'websocket'\n    }\n  };\n\n  const req = http.request(options);\n  req.end();\n\n  req.on('upgrade', (res, socket, upgradeHead) => {\n    console.log('got upgraded!');\n    socket.end();\n    process.exit(0);\n  });\n});\n</code></pre>"
             }
           ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_write_fd_buffer_offset_length_position_callback\"><code>fs.write(fd, buffer...)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.writeSync(fd, string[, position[, encoding]])`",
-          "type": "method",
-          "name": "writeSync",
-          "meta": {
-            "added": [
-              "v0.11.5"
-            ],
-            "changes": [
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7856",
-                "description": "The `position` parameter is optional now."
-              }
-            ]
-          },
-          "signatures": [
+          "methods": [
             {
-              "return": {
-                "textRaw": "Returns: {number} The number of bytes written.",
-                "name": "return",
-                "type": "number",
-                "desc": "The number of bytes written."
+              "textRaw": "`request.abort()`",
+              "type": "method",
+              "name": "abort",
+              "meta": {
+                "added": [
+                  "v0.3.8"
+                ],
+                "deprecated": [
+                  "v14.1.0"
+                ],
+                "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`string` {string}",
-                  "name": "string",
-                  "type": "string"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use [`request.destroy()`][] instead.",
+              "signatures": [
                 {
-                  "textRaw": "`encoding` {string}",
-                  "name": "encoding",
-                  "type": "string"
+                  "params": []
                 }
-              ]
-            }
-          ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_write_fd_string_position_encoding_callback\"><code>fs.write(fd, string...)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.writev(fd, buffers[, position], callback)`",
-          "type": "method",
-          "name": "writev",
-          "meta": {
-            "added": [
-              "v12.9.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Marks the request as aborting. Calling this will cause remaining data\nin the response to be dropped and the socket to be destroyed.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffers` {ArrayBufferView[]}",
-                  "name": "buffers",
-                  "type": "ArrayBufferView[]"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
+              "textRaw": "`request.end([data[, encoding]][, callback])`",
+              "type": "method",
+              "name": "end",
+              "meta": {
+                "added": [
+                  "v0.1.90"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/18780",
+                    "description": "This method now returns a reference to `ClientRequest`."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {this}",
+                    "name": "return",
+                    "type": "this"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`data` {string|Buffer}",
+                      "name": "data",
+                      "type": "string|Buffer"
                     },
                     {
-                      "textRaw": "`bytesWritten` {integer}",
-                      "name": "bytesWritten",
-                      "type": "integer"
+                      "textRaw": "`encoding` {string}",
+                      "name": "encoding",
+                      "type": "string"
                     },
                     {
-                      "textRaw": "`buffers` {ArrayBufferView[]}",
-                      "name": "buffers",
-                      "type": "ArrayBufferView[]"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Write an array of <code>ArrayBufferView</code>s to the file specified by <code>fd</code> using\n<code>writev()</code>.</p>\n<p><code>position</code> is the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position.</p>\n<p>The callback will be given three arguments: <code>err</code>, <code>bytesWritten</code>, and\n<code>buffers</code>. <code>bytesWritten</code> is how many bytes were written from <code>buffers</code>.</p>\n<p>If this method is <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed, it returns a <code>Promise</code> for an\n<code>Object</code> with <code>bytesWritten</code> and <code>buffers</code> properties.</p>\n<p>It is unsafe to use <code>fs.writev()</code> multiple times on the same file without\nwaiting for the callback. For this scenario, use <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
-        },
-        {
-          "textRaw": "`fs.writevSync(fd, buffers[, position])`",
-          "type": "method",
-          "name": "writevSync",
-          "meta": {
-            "added": [
-              "v12.9.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Finishes sending the request. If any parts of the body are\nunsent, it will flush them to the stream. If the request is\nchunked, this will send the terminating <code>'0\\r\\n\\r\\n'</code>.</p>\n<p>If <code>data</code> is specified, it is equivalent to calling\n<a href=\"http.html#http_request_write_chunk_encoding_callback\"><code>request.write(data, encoding)</code></a> followed by <code>request.end(callback)</code>.</p>\n<p>If <code>callback</code> is specified, it will be called when the request stream\nis finished.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {number} The number of bytes written.",
-                "name": "return",
-                "type": "number",
-                "desc": "The number of bytes written."
+              "textRaw": "`request.destroy([error])`",
+              "type": "method",
+              "name": "destroy",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32789",
+                    "description": "The function returns `this` for consistency with other Readable streams."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`buffers` {ArrayBufferView[]}",
-                  "name": "buffers",
-                  "type": "ArrayBufferView[]"
-                },
+                  "return": {
+                    "textRaw": "Returns: {this}",
+                    "name": "return",
+                    "type": "this"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`error` {Error} Optional, an error to emit with `'error'` event.",
+                      "name": "error",
+                      "type": "Error",
+                      "desc": "Optional, an error to emit with `'error'` event."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Destroy the request. Optionally emit an <code>'error'</code> event,\nand emit a <code>'close'</code> event. Calling this will cause remaining data\nin the response to be dropped and the socket to be destroyed.</p>\n<p>See <a href=\"stream.html#stream_writable_destroy_error\"><code>writable.destroy()</code></a> for further details.</p>",
+              "properties": [
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
+                  "textRaw": "`destroyed` {boolean}",
+                  "type": "boolean",
+                  "name": "destroyed",
+                  "meta": {
+                    "added": [
+                      "v14.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Is <code>true</code> after <a href=\"http.html#http_request_destroy_error\"><code>request.destroy()</code></a> has been called.</p>\n<p>See <a href=\"stream.html#stream_writable_destroyed\"><code>writable.destroyed</code></a> for further details.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_writev_fd_buffers_position_callback\"><code>fs.writev()</code></a>.</p>"
-        }
-      ],
-      "properties": [
-        {
-          "textRaw": "`constants` {Object}",
-          "type": "Object",
-          "name": "constants",
-          "desc": "<p>Returns an object containing commonly used constants for file system\noperations. The specific constants currently defined are described in\n<a href=\"fs.html#fs_fs_constants_1\">FS constants</a>.</p>"
-        }
-      ],
-      "type": "module",
-      "displayName": "fs"
-    },
-    {
-      "textRaw": "HTTP",
-      "name": "http",
-      "introduced_in": "v0.10.0",
-      "stability": 2,
-      "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/http.js\">lib/http.js</a></p>\n<p>To use the HTTP server and client one must <code>require('http')</code>.</p>\n<p>The HTTP interfaces in Node.js are designed to support many features\nof the protocol which have been traditionally difficult to use.\nIn particular, large, possibly chunk-encoded, messages. The interface is\ncareful to never buffer entire requests or responses, so the\nuser is able to stream data.</p>\n<p>HTTP message headers are represented by an object like this:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{ 'content-length': '123',\n  'content-type': 'text/plain',\n  'connection': 'keep-alive',\n  'host': 'mysite.com',\n  'accept': '*/*' }\n</code></pre>\n<p>Keys are lowercased. Values are not modified.</p>\n<p>In order to support the full spectrum of possible HTTP applications, the Node.js\nHTTP API is very low-level. It deals with stream handling and message\nparsing only. It parses a message into headers and body but it does not\nparse the actual headers or the body.</p>\n<p>See <a href=\"http.html#http_message_headers\"><code>message.headers</code></a> for details on how duplicate headers are handled.</p>\n<p>The raw headers as they were received are retained in the <code>rawHeaders</code>\nproperty, which is an array of <code>[key, value, key2, value2, ...]</code>. For\nexample, the previous message header object might have a <code>rawHeaders</code>\nlist like the following:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[ 'ConTent-Length', '123456',\n  'content-LENGTH', '123',\n  'content-type', 'text/plain',\n  'CONNECTION', 'keep-alive',\n  'Host', 'mysite.com',\n  'accepT', '*/*' ]\n</code></pre>",
-      "classes": [
-        {
-          "textRaw": "Class: `http.Agent`",
-          "type": "class",
-          "name": "http.Agent",
-          "meta": {
-            "added": [
-              "v0.3.4"
-            ],
-            "changes": []
-          },
-          "desc": "<p>An <code>Agent</code> is responsible for managing connection persistence\nand reuse for HTTP clients. It maintains a queue of pending requests\nfor a given host and port, reusing a single socket connection for each\nuntil the queue is empty, at which time the socket is either destroyed\nor put into a pool where it is kept to be used again for requests to the\nsame host and port. Whether it is destroyed or pooled depends on the\n<code>keepAlive</code> <a href=\"http.html#http_new_agent_options\">option</a>.</p>\n<p>Pooled connections have TCP Keep-Alive enabled for them, but servers may\nstill close idle connections, in which case they will be removed from the\npool and a new connection will be made when a new HTTP request is made for\nthat host and port. Servers may also refuse to allow multiple requests\nover the same connection, in which case the connection will have to be\nremade for every request and cannot be pooled. The <code>Agent</code> will still make\nthe requests to that server, but each one will occur over a new connection.</p>\n<p>When a connection is closed by the client or the server, it is removed\nfrom the pool. Any unused sockets in the pool will be unrefed so as not\nto keep the Node.js process running when there are no outstanding requests.\n(see <a href=\"net.html#net_socket_unref\"><code>socket.unref()</code></a>).</p>\n<p>It is good practice, to <a href=\"http.html#http_agent_destroy\"><code>destroy()</code></a> an <code>Agent</code> instance when it is no\nlonger in use, because unused sockets consume OS resources.</p>\n<p>Sockets are removed from an agent when the socket emits either\na <code>'close'</code> event or an <code>'agentRemove'</code> event. When intending to keep one\nHTTP request open for a long time without keeping it in the agent, something\nlike the following may be done:</p>\n<pre><code class=\"language-js\">http.get(options, (res) => {\n  // Do stuff\n}).on('socket', (socket) => {\n  socket.emit('agentRemove');\n});\n</code></pre>\n<p>An agent may also be used for an individual request. By providing\n<code>{agent: false}</code> as an option to the <code>http.get()</code> or <code>http.request()</code>\nfunctions, a one-time use <code>Agent</code> with default options will be used\nfor the client connection.</p>\n<p><code>agent:false</code>:</p>\n<pre><code class=\"language-js\">http.get({\n  hostname: 'localhost',\n  port: 80,\n  path: '/',\n  agent: false  // Create a new agent just for this one request\n}, (res) => {\n  // Do stuff with response\n});\n</code></pre>",
-          "methods": [
+            },
             {
-              "textRaw": "`agent.createConnection(options[, callback])`",
+              "textRaw": "`request.flushHeaders()`",
               "type": "method",
-              "name": "createConnection",
+              "name": "flushHeaders",
               "meta": {
                 "added": [
-                  "v0.11.4"
+                  "v1.6.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Flushes the request headers.</p>\n<p>For efficiency reasons, Node.js normally buffers the request headers until\n<code>request.end()</code> is called or the first chunk of request data is written. It\nthen tries to pack the request headers and data into a single TCP packet.</p>\n<p>That's usually desired (it saves a TCP round-trip), but not when the first\ndata is not sent until possibly much later. <code>request.flushHeaders()</code> bypasses\nthe optimization and kickstarts the request.</p>"
+            },
+            {
+              "textRaw": "`request.getHeader(name)`",
+              "type": "method",
+              "name": "getHeader",
+              "meta": {
+                "added": [
+                  "v1.6.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {stream.Duplex}",
+                    "textRaw": "Returns: {any}",
                     "name": "return",
-                    "type": "stream.Duplex"
+                    "type": "any"
                   },
                   "params": [
                     {
-                      "textRaw": "`options` {Object} Options containing connection details. Check [`net.createConnection()`][] for the format of the options",
-                      "name": "options",
-                      "type": "Object",
-                      "desc": "Options containing connection details. Check [`net.createConnection()`][] for the format of the options"
+                      "textRaw": "`name` {string}",
+                      "name": "name",
+                      "type": "string"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Reads out a header on the request. The name is case-insensitive.\nThe type of the return value depends on the arguments provided to\n<a href=\"http.html#http_request_setheader_name_value\"><code>request.setHeader()</code></a>.</p>\n<pre><code class=\"language-js\">request.setHeader('content-type', 'text/html');\nrequest.setHeader('Content-Length', Buffer.byteLength(body));\nrequest.setHeader('Cookie', ['type=ninja', 'language=javascript']);\nconst contentType = request.getHeader('Content-Type');\n// 'contentType' is 'text/html'\nconst contentLength = request.getHeader('Content-Length');\n// 'contentLength' is of type number\nconst cookie = request.getHeader('Cookie');\n// 'cookie' is of type string[]\n</code></pre>"
+            },
+            {
+              "textRaw": "`request.getRawHeaderNames()`",
+              "type": "method",
+              "name": "getRawHeaderNames",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {string[]}",
+                    "name": "return",
+                    "type": "string[]"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns an array containing the unique names of the current outgoing raw\nheaders. Header names are returned with their exact casing being set.</p>\n<pre><code class=\"language-js\">request.setHeader('Foo', 'bar');\nrequest.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);\n\nconst headerNames = request.getRawHeaderNames();\n// headerNames === ['Foo', 'Set-Cookie']\n</code></pre>"
+            },
+            {
+              "textRaw": "`request.removeHeader(name)`",
+              "type": "method",
+              "name": "removeHeader",
+              "meta": {
+                "added": [
+                  "v1.6.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`name` {string}",
+                      "name": "name",
+                      "type": "string"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Removes a header that's already defined into headers object.</p>\n<pre><code class=\"language-js\">request.removeHeader('Content-Type');\n</code></pre>"
+            },
+            {
+              "textRaw": "`request.setHeader(name, value)`",
+              "type": "method",
+              "name": "setHeader",
+              "meta": {
+                "added": [
+                  "v1.6.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`name` {string}",
+                      "name": "name",
+                      "type": "string"
                     },
                     {
-                      "textRaw": "`callback` {Function} Callback function that receives the created socket",
-                      "name": "callback",
-                      "type": "Function",
-                      "desc": "Callback function that receives the created socket"
+                      "textRaw": "`value` {any}",
+                      "name": "value",
+                      "type": "any"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Produces a socket/stream to be used for HTTP requests.</p>\n<p>By default, this function is the same as <a href=\"net.html#net_net_createconnection_options_connectlistener\"><code>net.createConnection()</code></a>. However,\ncustom agents may override this method in case greater flexibility is desired.</p>\n<p>A socket/stream can be supplied in one of two ways: by returning the\nsocket/stream from this function, or by passing the socket/stream to <code>callback</code>.</p>\n<p>This method is guaranteed to return an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p><code>callback</code> has a signature of <code>(err, stream)</code>.</p>"
+              "desc": "<p>Sets a single header value for headers object. If this header already exists in\nthe to-be-sent headers, its value will be replaced. Use an array of strings\nhere to send multiple headers with the same name. Non-string values will be\nstored without modification. Therefore, <a href=\"http.html#http_request_getheader_name\"><code>request.getHeader()</code></a> may return\nnon-string values. However, the non-string values will be converted to strings\nfor network transmission.</p>\n<pre><code class=\"language-js\">request.setHeader('Content-Type', 'application/json');\n</code></pre>\n<p>or</p>\n<pre><code class=\"language-js\">request.setHeader('Cookie', ['type=ninja', 'language=javascript']);\n</code></pre>"
             },
             {
-              "textRaw": "`agent.keepSocketAlive(socket)`",
+              "textRaw": "`request.setNoDelay([noDelay])`",
               "type": "method",
-              "name": "keepSocketAlive",
+              "name": "setNoDelay",
               "meta": {
                 "added": [
-                  "v8.1.0"
+                  "v0.5.9"
                 ],
                 "changes": []
               },
@@ -34389,22 +38515,22 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`socket` {stream.Duplex}",
-                      "name": "socket",
-                      "type": "stream.Duplex"
+                      "textRaw": "`noDelay` {boolean}",
+                      "name": "noDelay",
+                      "type": "boolean"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Called when <code>socket</code> is detached from a request and could be persisted by the\n<code>Agent</code>. Default behavior is to:</p>\n<pre><code class=\"language-js\">socket.setKeepAlive(true, this.keepAliveMsecs);\nsocket.unref();\nreturn true;\n</code></pre>\n<p>This method can be overridden by a particular <code>Agent</code> subclass. If this\nmethod returns a falsy value, the socket will be destroyed instead of persisting\nit for use with the next request.</p>\n<p>The <code>socket</code> argument can be an instance of <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>, a subclass of\n<a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>.</p>"
+              "desc": "<p>Once a socket is assigned to this request and is connected\n<a href=\"net.html#net_socket_setnodelay_nodelay\"><code>socket.setNoDelay()</code></a> will be called.</p>"
             },
             {
-              "textRaw": "`agent.reuseSocket(socket, request)`",
+              "textRaw": "`request.setSocketKeepAlive([enable][, initialDelay])`",
               "type": "method",
-              "name": "reuseSocket",
+              "name": "setSocketKeepAlive",
               "meta": {
                 "added": [
-                  "v8.1.0"
+                  "v0.5.9"
                 ],
                 "changes": []
               },
@@ -34412,255 +38538,373 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`socket` {stream.Duplex}",
-                      "name": "socket",
-                      "type": "stream.Duplex"
+                      "textRaw": "`enable` {boolean}",
+                      "name": "enable",
+                      "type": "boolean"
                     },
                     {
-                      "textRaw": "`request` {http.ClientRequest}",
-                      "name": "request",
-                      "type": "http.ClientRequest"
+                      "textRaw": "`initialDelay` {number}",
+                      "name": "initialDelay",
+                      "type": "number"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Called when <code>socket</code> is attached to <code>request</code> after being persisted because of\nthe keep-alive options. Default behavior is to:</p>\n<pre><code class=\"language-js\">socket.ref();\n</code></pre>\n<p>This method can be overridden by a particular <code>Agent</code> subclass.</p>\n<p>The <code>socket</code> argument can be an instance of <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>, a subclass of\n<a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>.</p>"
+              "desc": "<p>Once a socket is assigned to this request and is connected\n<a href=\"net.html#net_socket_setkeepalive_enable_initialdelay\"><code>socket.setKeepAlive()</code></a> will be called.</p>"
             },
             {
-              "textRaw": "`agent.destroy()`",
+              "textRaw": "`request.setTimeout(timeout[, callback])`",
               "type": "method",
-              "name": "destroy",
+              "name": "setTimeout",
               "meta": {
                 "added": [
-                  "v0.11.4"
+                  "v0.5.9"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v9.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/8895",
+                    "description": "Consistently set socket timeout only when the socket connects."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "params": []
+                  "return": {
+                    "textRaw": "Returns: {http.ClientRequest}",
+                    "name": "return",
+                    "type": "http.ClientRequest"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`timeout` {number} Milliseconds before a request times out.",
+                      "name": "timeout",
+                      "type": "number",
+                      "desc": "Milliseconds before a request times out."
+                    },
+                    {
+                      "textRaw": "`callback` {Function} Optional function to be called when a timeout occurs. Same as binding to the `'timeout'` event.",
+                      "name": "callback",
+                      "type": "Function",
+                      "desc": "Optional function to be called when a timeout occurs. Same as binding to the `'timeout'` event."
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Destroy any sockets that are currently in use by the agent.</p>\n<p>It is usually not necessary to do this. However, if using an\nagent with <code>keepAlive</code> enabled, then it is best to explicitly shut down\nthe agent when it will no longer be used. Otherwise,\nsockets may hang open for quite a long time before the server\nterminates them.</p>"
+              "desc": "<p>Once a socket is assigned to this request and is connected\n<a href=\"net.html#net_socket_settimeout_timeout_callback\"><code>socket.setTimeout()</code></a> will be called.</p>"
             },
             {
-              "textRaw": "`agent.getName(options)`",
+              "textRaw": "`request.write(chunk[, encoding][, callback])`",
               "type": "method",
-              "name": "getName",
+              "name": "write",
               "meta": {
                 "added": [
-                  "v0.11.4"
+                  "v0.1.29"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {string}",
+                    "textRaw": "Returns: {boolean}",
                     "name": "return",
-                    "type": "string"
+                    "type": "boolean"
                   },
                   "params": [
                     {
-                      "textRaw": "`options` {Object} A set of options providing information for name generation",
-                      "name": "options",
-                      "type": "Object",
-                      "desc": "A set of options providing information for name generation",
-                      "options": [
-                        {
-                          "textRaw": "`host` {string} A domain name or IP address of the server to issue the request to",
-                          "name": "host",
-                          "type": "string",
-                          "desc": "A domain name or IP address of the server to issue the request to"
-                        },
-                        {
-                          "textRaw": "`port` {number} Port of remote server",
-                          "name": "port",
-                          "type": "number",
-                          "desc": "Port of remote server"
-                        },
-                        {
-                          "textRaw": "`localAddress` {string} Local interface to bind for network connections when issuing the request",
-                          "name": "localAddress",
-                          "type": "string",
-                          "desc": "Local interface to bind for network connections when issuing the request"
-                        },
-                        {
-                          "textRaw": "`family` {integer} Must be 4 or 6 if this doesn't equal `undefined`.",
-                          "name": "family",
-                          "type": "integer",
-                          "desc": "Must be 4 or 6 if this doesn't equal `undefined`."
-                        }
-                      ]
+                      "textRaw": "`chunk` {string|Buffer}",
+                      "name": "chunk",
+                      "type": "string|Buffer"
+                    },
+                    {
+                      "textRaw": "`encoding` {string}",
+                      "name": "encoding",
+                      "type": "string"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Get a unique name for a set of request options, to determine whether a\nconnection can be reused. For an HTTP agent, this returns\n<code>host:port:localAddress</code> or <code>host:port:localAddress:family</code>. For an HTTPS agent,\nthe name includes the CA, cert, ciphers, and other HTTPS/TLS-specific options\nthat determine socket reusability.</p>"
+              "desc": "<p>Sends a chunk of the body. This method can be called multiple times. If no\n<code>Content-Length</code> is set, data will automatically be encoded in HTTP Chunked\ntransfer encoding, so that server knows when the data ends. The\n<code>Transfer-Encoding: chunked</code> header is added. Calling <a href=\"http.html#http_request_end_data_encoding_callback\"><code>request.end()</code></a>\nis necessary to finish sending the request.</p>\n<p>The <code>encoding</code> argument is optional and only applies when <code>chunk</code> is a string.\nDefaults to <code>'utf8'</code>.</p>\n<p>The <code>callback</code> argument is optional and will be called when this chunk of data\nis flushed, but only if the chunk is non-empty.</p>\n<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel\nbuffer. Returns <code>false</code> if all or part of the data was queued in user memory.\n<code>'drain'</code> will be emitted when the buffer is free again.</p>\n<p>When <code>write</code> function is called with empty string or buffer, it does\nnothing and waits for more input.</p>"
             }
           ],
           "properties": [
             {
-              "textRaw": "`freeSockets` {Object}",
-              "type": "Object",
-              "name": "freeSockets",
+              "textRaw": "`aborted` {boolean}",
+              "type": "boolean",
+              "name": "aborted",
+              "meta": {
+                "added": [
+                  "v0.11.14"
+                ],
+                "changes": [
+                  {
+                    "version": "v11.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20230",
+                    "description": "The `aborted` property is no longer a timestamp number."
+                  }
+                ]
+              },
+              "desc": "<p>The <code>request.aborted</code> property will be <code>true</code> if the request has\nbeen aborted.</p>"
+            },
+            {
+              "textRaw": "`connection` {stream.Duplex}",
+              "type": "stream.Duplex",
+              "name": "connection",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "deprecated": [
+                  "v13.0.0"
+                ],
+                "changes": []
+              },
+              "stability": 0,
+              "stabilityText": "Deprecated. Use [`request.socket`][].",
+              "desc": "<p>See <a href=\"http.html#http_request_socket\"><code>request.socket</code></a>.</p>"
+            },
+            {
+              "textRaw": "`finished` {boolean}",
+              "type": "boolean",
+              "name": "finished",
               "meta": {
                 "added": [
-                  "v0.11.4"
+                  "v0.0.1"
+                ],
+                "deprecated": [
+                  "v13.4.0",
+                  "v12.16.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>An object which contains arrays of sockets currently awaiting use by\nthe agent when <code>keepAlive</code> is enabled. Do not modify.</p>\n<p>Sockets in the <code>freeSockets</code> list will be automatically destroyed and\nremoved from the array on <code>'timeout'</code>.</p>"
+              "stability": 0,
+              "stabilityText": "Deprecated. Use [`request.writableEnded`][].",
+              "desc": "<p>The <code>request.finished</code> property will be <code>true</code> if <a href=\"http.html#http_request_end_data_encoding_callback\"><code>request.end()</code></a>\nhas been called. <code>request.end()</code> will automatically be called if the\nrequest was initiated via <a href=\"http.html#http_http_get_options_callback\"><code>http.get()</code></a>.</p>"
             },
             {
-              "textRaw": "`maxFreeSockets` {number}",
+              "textRaw": "`maxHeadersCount` {number} **Default:** `2000`",
               "type": "number",
-              "name": "maxFreeSockets",
+              "name": "maxHeadersCount",
+              "default": "`2000`",
+              "desc": "<p>Limits maximum response headers count. If set to 0, no limit will be applied.</p>"
+            },
+            {
+              "textRaw": "`path` {string} The request path.",
+              "type": "string",
+              "name": "path",
               "meta": {
                 "added": [
-                  "v0.11.7"
+                  "v0.4.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>By default set to 256. For agents with <code>keepAlive</code> enabled, this\nsets the maximum number of sockets that will be left open in the free\nstate.</p>"
+              "desc": "The request path."
             },
             {
-              "textRaw": "`maxSockets` {number}",
-              "type": "number",
-              "name": "maxSockets",
+              "textRaw": "`method` {string} The request method.",
+              "type": "string",
+              "name": "method",
               "meta": {
                 "added": [
-                  "v0.3.6"
+                  "v0.1.97"
                 ],
                 "changes": []
               },
-              "desc": "<p>By default set to <code>Infinity</code>. Determines how many concurrent sockets the agent\ncan have open per origin. Origin is the returned value of <a href=\"http.html#http_agent_getname_options\"><code>agent.getName()</code></a>.</p>"
+              "desc": "The request method."
             },
             {
-              "textRaw": "`maxTotalSockets` {number}",
-              "type": "number",
-              "name": "maxTotalSockets",
+              "textRaw": "`host` {string} The request host.",
+              "type": "string",
+              "name": "host",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>By default set to <code>Infinity</code>. Determines how many concurrent sockets the agent\ncan have open. Unlike <code>maxSockets</code>, this parameter applies across all origins.</p>"
+              "desc": "The request host."
             },
             {
-              "textRaw": "`requests` {Object}",
-              "type": "Object",
-              "name": "requests",
+              "textRaw": "`protocol` {string} The request protocol.",
+              "type": "string",
+              "name": "protocol",
               "meta": {
                 "added": [
-                  "v0.5.9"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>An object which contains queues of requests that have not yet been assigned to\nsockets. Do not modify.</p>"
+              "desc": "The request protocol."
             },
             {
-              "textRaw": "`sockets` {Object}",
-              "type": "Object",
-              "name": "sockets",
+              "textRaw": "`reusedSocket` {boolean} Whether the request is send through a reused socket.",
+              "type": "boolean",
+              "name": "reusedSocket",
               "meta": {
                 "added": [
-                  "v0.3.6"
+                  "v13.0.0",
+                  "v12.16.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>An object which contains arrays of sockets currently in use by the\nagent. Do not modify.</p>"
-            }
-          ],
-          "signatures": [
+              "desc": "<p>When sending request through a keep-alive enabled agent, the underlying socket\nmight be reused. But if server closes connection at unfortunate time, client\nmay run into a 'ECONNRESET' error.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\n// Server has a 5 seconds keep-alive timeout by default\nhttp\n  .createServer((req, res) => {\n    res.write('hello\\n');\n    res.end();\n  })\n  .listen(3000);\n\nsetInterval(() => {\n  // Adapting a keep-alive agent\n  http.get('http://localhost:3000', { agent }, (res) => {\n    res.on('data', (data) => {\n      // Do nothing\n    });\n  });\n}, 5000); // Sending request on 5s interval so it's easy to hit idle timeout\n</code></pre>\n<p>By marking a request whether it reused socket or not, we can do\nautomatic error retry base on it.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst agent = new http.Agent({ keepAlive: true });\n\nfunction retriableRequest() {\n  const req = http\n    .get('http://localhost:3000', { agent }, (res) => {\n      // ...\n    })\n    .on('error', (err) => {\n      // Check if retry is needed\n      if (req.reusedSocket &#x26;&#x26; err.code === 'ECONNRESET') {\n        retriableRequest();\n      }\n    });\n}\n\nretriableRequest();\n</code></pre>",
+              "shortDesc": "Whether the request is send through a reused socket."
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`options` {Object} Set of configurable options to set on the agent. Can have the following fields:",
-                  "name": "options",
-                  "type": "Object",
-                  "desc": "Set of configurable options to set on the agent. Can have the following fields:",
-                  "options": [
-                    {
-                      "textRaw": "`keepAlive` {boolean} Keep sockets around even when there are no outstanding requests, so they can be used for future requests without having to reestablish a TCP connection. Not to be confused with the `keep-alive` value of the `Connection` header. The `Connection: keep-alive` header is always sent when using an agent except when the `Connection` header is explicitly specified or when the `keepAlive` and `maxSockets` options are respectively set to `false` and `Infinity`, in which case `Connection: close` will be used. **Default:** `false`.",
-                      "name": "keepAlive",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Keep sockets around even when there are no outstanding requests, so they can be used for future requests without having to reestablish a TCP connection. Not to be confused with the `keep-alive` value of the `Connection` header. The `Connection: keep-alive` header is always sent when using an agent except when the `Connection` header is explicitly specified or when the `keepAlive` and `maxSockets` options are respectively set to `false` and `Infinity`, in which case `Connection: close` will be used."
-                    },
-                    {
-                      "textRaw": "`keepAliveMsecs` {number} When using the `keepAlive` option, specifies the [initial delay](net.html#net_socket_setkeepalive_enable_initialdelay) for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`. **Default:** `1000`.",
-                      "name": "keepAliveMsecs",
-                      "type": "number",
-                      "default": "`1000`",
-                      "desc": "When using the `keepAlive` option, specifies the [initial delay](net.html#net_socket_setkeepalive_enable_initialdelay) for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`."
-                    },
-                    {
-                      "textRaw": "`maxSockets` {number} Maximum number of sockets to allow per host. Each request will use a new socket until the maximum is reached. **Default:** `Infinity`.",
-                      "name": "maxSockets",
-                      "type": "number",
-                      "default": "`Infinity`",
-                      "desc": "Maximum number of sockets to allow per host. Each request will use a new socket until the maximum is reached."
-                    },
-                    {
-                      "textRaw": "`maxTotalSockets` {number} Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached. **Default:** `Infinity`.",
-                      "name": "maxTotalSockets",
-                      "type": "number",
-                      "default": "`Infinity`",
-                      "desc": "Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached."
-                    },
-                    {
-                      "textRaw": "`maxFreeSockets` {number} Maximum number of sockets to leave open in a free state. Only relevant if `keepAlive` is set to `true`. **Default:** `256`.",
-                      "name": "maxFreeSockets",
-                      "type": "number",
-                      "default": "`256`",
-                      "desc": "Maximum number of sockets to leave open in a free state. Only relevant if `keepAlive` is set to `true`."
-                    },
-                    {
-                      "textRaw": "`scheduling` {string} Scheduling strategy to apply when picking the next free socket to use. It can be `'fifo'` or `'lifo'`. The main difference between the two scheduling strategies is that `'lifo'` selects the most recently used socket, while `'fifo'` selects the least recently used socket. In case of a low rate of request per second, the `'lifo'` scheduling will lower the risk of picking a socket that might have been closed by the server due to inactivity. In case of a high rate of request per second, the `'fifo'` scheduling will maximize the number of open sockets, while the `'lifo'` scheduling will keep it as low as possible. **Default:** `'fifo'`.",
-                      "name": "scheduling",
-                      "type": "string",
-                      "default": "`'fifo'`",
-                      "desc": "Scheduling strategy to apply when picking the next free socket to use. It can be `'fifo'` or `'lifo'`. The main difference between the two scheduling strategies is that `'lifo'` selects the most recently used socket, while `'fifo'` selects the least recently used socket. In case of a low rate of request per second, the `'lifo'` scheduling will lower the risk of picking a socket that might have been closed by the server due to inactivity. In case of a high rate of request per second, the `'fifo'` scheduling will maximize the number of open sockets, while the `'lifo'` scheduling will keep it as low as possible."
-                    },
-                    {
-                      "textRaw": "`timeout` {number} Socket timeout in milliseconds. This will set the timeout when the socket is created.",
-                      "name": "timeout",
-                      "type": "number",
-                      "desc": "Socket timeout in milliseconds. This will set the timeout when the socket is created."
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p><code>options</code> in <a href=\"net.html#net_socket_connect_options_connectlistener\"><code>socket.connect()</code></a> are also supported.</p>\n<p>The default <a href=\"http.html#http_http_globalagent\"><code>http.globalAgent</code></a> that is used by <a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a> has all\nof these values set to their respective defaults.</p>\n<p>To configure any of them, a custom <a href=\"http.html#http_class_http_agent\"><code>http.Agent</code></a> instance must be created.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst keepAliveAgent = new http.Agent({ keepAlive: true });\noptions.agent = keepAliveAgent;\nhttp.request(options, onResponseCallback);\n</code></pre>"
+              "textRaw": "`socket` {stream.Duplex}",
+              "type": "stream.Duplex",
+              "name": "socket",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Reference to the underlying socket. Usually users will not want to access\nthis property. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst options = {\n  host: 'www.google.com',\n};\nconst req = http.get(options);\nreq.end();\nreq.once('response', (res) => {\n  const ip = req.socket.localAddress;\n  const port = req.socket.localPort;\n  console.log(`Your IP address is ${ip} and your source port is ${port}.`);\n  // Consume response object\n});\n</code></pre>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+            },
+            {
+              "textRaw": "`writableEnded` {boolean}",
+              "type": "boolean",
+              "name": "writableEnded",
+              "meta": {
+                "added": [
+                  "v12.9.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Is <code>true</code> after <a href=\"http.html#http_request_end_data_encoding_callback\"><code>request.end()</code></a> has been called. This property\ndoes not indicate whether the data has been flushed, for this use\n<a href=\"http.html#http_request_writablefinished\"><code>request.writableFinished</code></a> instead.</p>"
+            },
+            {
+              "textRaw": "`writableFinished` {boolean}",
+              "type": "boolean",
+              "name": "writableFinished",
+              "meta": {
+                "added": [
+                  "v12.7.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Is <code>true</code> if all data has been flushed to the underlying system, immediately\nbefore the <a href=\"http.html#http_event_finish\"><code>'finish'</code></a> event is emitted.</p>"
             }
           ]
         },
         {
-          "textRaw": "Class: `http.ClientRequest`",
+          "textRaw": "Class: `http.Server`",
           "type": "class",
-          "name": "http.ClientRequest",
+          "name": "http.Server",
           "meta": {
             "added": [
               "v0.1.17"
             ],
             "changes": []
           },
-          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a></li>\n</ul>\n<p>This object is created internally and returned from <a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a>. It\nrepresents an <em>in-progress</em> request whose header has already been queued. The\nheader is still mutable using the <a href=\"http.html#http_request_setheader_name_value\"><code>setHeader(name, value)</code></a>,\n<a href=\"http.html#http_request_getheader_name\"><code>getHeader(name)</code></a>, <a href=\"http.html#http_request_removeheader_name\"><code>removeHeader(name)</code></a> API. The actual header will\nbe sent along with the first data chunk or when calling <a href=\"http.html#http_request_end_data_encoding_callback\"><code>request.end()</code></a>.</p>\n<p>To get the response, add a listener for <a href=\"http.html#http_event_response\"><code>'response'</code></a> to the request object.\n<a href=\"http.html#http_event_response\"><code>'response'</code></a> will be emitted from the request object when the response\nheaders have been received. The <a href=\"http.html#http_event_response\"><code>'response'</code></a> event is executed with one\nargument which is an instance of <a href=\"http.html#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>During the <a href=\"http.html#http_event_response\"><code>'response'</code></a> event, one can add listeners to the\nresponse object; particularly to listen for the <code>'data'</code> event.</p>\n<p>If no <a href=\"http.html#http_event_response\"><code>'response'</code></a> handler is added, then the response will be\nentirely discarded. However, if a <a href=\"http.html#http_event_response\"><code>'response'</code></a> event handler is added,\nthen the data from the response object <strong>must</strong> be consumed, either by\ncalling <code>response.read()</code> whenever there is a <code>'readable'</code> event, or\nby adding a <code>'data'</code> handler, or by calling the <code>.resume()</code> method.\nUntil the data is consumed, the <code>'end'</code> event will not fire. Also, until\nthe data is read it will consume memory that can eventually lead to a\n'process out of memory' error.</p>\n<p>Unlike the <code>request</code> object, if the response closes prematurely, the\n<code>response</code> object does not emit an <code>'error'</code> event but instead emits the\n<code>'aborted'</code> event.</p>\n<p>Node.js does not check whether Content-Length and the length of the\nbody which has been transmitted are equal or not.</p>",
+          "desc": "<ul>\n<li>Extends: <a href=\"net.html#net_class_net_server\" class=\"type\">&lt;net.Server&gt;</a></li>\n</ul>",
           "events": [
             {
-              "textRaw": "Event: `'abort'`",
+              "textRaw": "Event: `'checkContinue'`",
               "type": "event",
-              "name": "abort",
+              "name": "checkContinue",
               "meta": {
                 "added": [
-                  "v1.4.1"
+                  "v0.3.0"
+                ],
+                "changes": []
+              },
+              "params": [
+                {
+                  "textRaw": "`request` {http.IncomingMessage}",
+                  "name": "request",
+                  "type": "http.IncomingMessage"
+                },
+                {
+                  "textRaw": "`response` {http.ServerResponse}",
+                  "name": "response",
+                  "type": "http.ServerResponse"
+                }
+              ],
+              "desc": "<p>Emitted each time a request with an HTTP <code>Expect: 100-continue</code> is received.\nIf this event is not listened for, the server will automatically respond\nwith a <code>100 Continue</code> as appropriate.</p>\n<p>Handling this event involves calling <a href=\"http.html#http_response_writecontinue\"><code>response.writeContinue()</code></a> if the\nclient should continue to send the request body, or generating an appropriate\nHTTP response (e.g. 400 Bad Request) if the client should not continue to send\nthe request body.</p>\n<p>When this event is emitted and handled, the <a href=\"http.html#http_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
+            },
+            {
+              "textRaw": "Event: `'checkExpectation'`",
+              "type": "event",
+              "name": "checkExpectation",
+              "meta": {
+                "added": [
+                  "v5.5.0"
+                ],
+                "changes": []
+              },
+              "params": [
+                {
+                  "textRaw": "`request` {http.IncomingMessage}",
+                  "name": "request",
+                  "type": "http.IncomingMessage"
+                },
+                {
+                  "textRaw": "`response` {http.ServerResponse}",
+                  "name": "response",
+                  "type": "http.ServerResponse"
+                }
+              ],
+              "desc": "<p>Emitted each time a request with an HTTP <code>Expect</code> header is received, where the\nvalue is not <code>100-continue</code>. If this event is not listened for, the server will\nautomatically respond with a <code>417 Expectation Failed</code> as appropriate.</p>\n<p>When this event is emitted and handled, the <a href=\"http.html#http_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
+            },
+            {
+              "textRaw": "Event: `'clientError'`",
+              "type": "event",
+              "name": "clientError",
+              "meta": {
+                "added": [
+                  "v0.1.94"
+                ],
+                "changes": [
+                  {
+                    "version": "v12.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/25605",
+                    "description": "The default behavior will return a 431 Request Header Fields Too Large if a HPE_HEADER_OVERFLOW error occurs."
+                  },
+                  {
+                    "version": "v9.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/17672",
+                    "description": "The `rawPacket` is the current buffer that just parsed. Adding this buffer to the error object of `'clientError'` event is to make it possible that developers can log the broken packet."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4557",
+                    "description": "The default action of calling `.destroy()` on the `socket` will no longer take place if there are listeners attached for `'clientError'`."
+                  }
+                ]
+              },
+              "params": [
+                {
+                  "textRaw": "`exception` {Error}",
+                  "name": "exception",
+                  "type": "Error"
+                },
+                {
+                  "textRaw": "`socket` {stream.Duplex}",
+                  "name": "socket",
+                  "type": "stream.Duplex"
+                }
+              ],
+              "desc": "<p>If a client connection emits an <code>'error'</code> event, it will be forwarded here.\nListener of this event is responsible for closing/destroying the underlying\nsocket. For example, one may wish to more gracefully close the socket with a\ncustom HTTP response instead of abruptly severing the connection.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>Default behavior is to try close the socket with a HTTP '400 Bad Request',\nor a HTTP '431 Request Header Fields Too Large' in the case of a\n<a href=\"errors.html#errors_hpe_header_overflow\"><code>HPE_HEADER_OVERFLOW</code></a> error. If the socket is not writable or has already\nwritten data it is immediately destroyed.</p>\n<p><code>socket</code> is the <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> object that the error originated from.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst server = http.createServer((req, res) => {\n  res.end();\n});\nserver.on('clientError', (err, socket) => {\n  socket.end('HTTP/1.1 400 Bad Request\\r\\n\\r\\n');\n});\nserver.listen(8000);\n</code></pre>\n<p>When the <code>'clientError'</code> event occurs, there is no <code>request</code> or <code>response</code>\nobject, so any HTTP response sent, including response headers and payload,\n<em>must</em> be written directly to the <code>socket</code> object. Care must be taken to\nensure the response is a properly formatted HTTP response message.</p>\n<p><code>err</code> is an instance of <code>Error</code> with two extra columns:</p>\n<ul>\n<li><code>bytesParsed</code>: the bytes count of request packet that Node.js may have parsed\ncorrectly;</li>\n<li><code>rawPacket</code>: the raw packet of current request.</li>\n</ul>\n<p>In some cases, the client has already received the response and/or the socket\nhas already been destroyed, like in case of <code>ECONNRESET</code> errors. Before\ntrying to send data to the socket, it is better to check that it is still\nwritable.</p>\n<pre><code class=\"language-js\">server.on('clientError', (err, socket) => {\n  if (err.code === 'ECONNRESET' || !socket.writable) {\n    return;\n  }\n\n  socket.end('HTTP/1.1 400 Bad Request\\r\\n\\r\\n');\n});\n</code></pre>"
+            },
+            {
+              "textRaw": "Event: `'close'`",
+              "type": "event",
+              "name": "close",
+              "meta": {
+                "added": [
+                  "v0.1.4"
                 ],
                 "changes": []
               },
               "params": [],
-              "desc": "<p>Emitted when the request has been aborted by the client. This event is only\nemitted on the first call to <code>abort()</code>.</p>"
+              "desc": "<p>Emitted when the server closes.</p>"
             },
             {
               "textRaw": "Event: `'connect'`",
@@ -34674,181 +38918,344 @@
               },
               "params": [
                 {
-                  "textRaw": "`response` {http.IncomingMessage}",
-                  "name": "response",
-                  "type": "http.IncomingMessage"
+                  "textRaw": "`request` {http.IncomingMessage} Arguments for the HTTP request, as it is in the [`'request'`][] event",
+                  "name": "request",
+                  "type": "http.IncomingMessage",
+                  "desc": "Arguments for the HTTP request, as it is in the [`'request'`][] event"
                 },
                 {
-                  "textRaw": "`socket` {stream.Duplex}",
+                  "textRaw": "`socket` {stream.Duplex} Network socket between the server and client",
                   "name": "socket",
-                  "type": "stream.Duplex"
+                  "type": "stream.Duplex",
+                  "desc": "Network socket between the server and client"
                 },
                 {
-                  "textRaw": "`head` {Buffer}",
+                  "textRaw": "`head` {Buffer} The first packet of the tunneling stream (may be empty)",
                   "name": "head",
-                  "type": "Buffer"
+                  "type": "Buffer",
+                  "desc": "The first packet of the tunneling stream (may be empty)"
                 }
               ],
-              "desc": "<p>Emitted each time a server responds to a request with a <code>CONNECT</code> method. If\nthis event is not being listened for, clients receiving a <code>CONNECT</code> method will\nhave their connections closed.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>A client and server pair demonstrating how to listen for the <code>'connect'</code> event:</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst net = require('net');\nconst { URL } = require('url');\n\n// Create an HTTP tunneling proxy\nconst proxy = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('okay');\n});\nproxy.on('connect', (req, clientSocket, head) => {\n  // Connect to an origin server\n  const { port, hostname } = new URL(`http://${req.url}`);\n  const serverSocket = net.connect(port || 80, hostname, () => {\n    clientSocket.write('HTTP/1.1 200 Connection Established\\r\\n' +\n                    'Proxy-agent: Node.js-Proxy\\r\\n' +\n                    '\\r\\n');\n    serverSocket.write(head);\n    serverSocket.pipe(clientSocket);\n    clientSocket.pipe(serverSocket);\n  });\n});\n\n// Now that proxy is running\nproxy.listen(1337, '127.0.0.1', () => {\n\n  // Make a request to a tunneling proxy\n  const options = {\n    port: 1337,\n    host: '127.0.0.1',\n    method: 'CONNECT',\n    path: 'www.google.com:80'\n  };\n\n  const req = http.request(options);\n  req.end();\n\n  req.on('connect', (res, socket, head) => {\n    console.log('got connected!');\n\n    // Make a request over an HTTP tunnel\n    socket.write('GET / HTTP/1.1\\r\\n' +\n                 'Host: www.google.com:80\\r\\n' +\n                 'Connection: close\\r\\n' +\n                 '\\r\\n');\n    socket.on('data', (chunk) => {\n      console.log(chunk.toString());\n    });\n    socket.on('end', () => {\n      proxy.close();\n    });\n  });\n});\n</code></pre>"
+              "desc": "<p>Emitted each time a client requests an HTTP <code>CONNECT</code> method. If this event is\nnot listened for, then clients requesting a <code>CONNECT</code> method will have their\nconnections closed.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>After this event is emitted, the request's socket will not have a <code>'data'</code>\nevent listener, meaning it will need to be bound in order to handle data\nsent to the server on that socket.</p>"
             },
             {
-              "textRaw": "Event: `'continue'`",
+              "textRaw": "Event: `'connection'`",
               "type": "event",
-              "name": "continue",
+              "name": "connection",
               "meta": {
                 "added": [
-                  "v0.3.2"
+                  "v0.1.0"
                 ],
                 "changes": []
               },
-              "params": [],
-              "desc": "<p>Emitted when the server sends a '100 Continue' HTTP response, usually because\nthe request contained 'Expect: 100-continue'. This is an instruction that\nthe client should send the request body.</p>"
+              "params": [
+                {
+                  "textRaw": "`socket` {stream.Duplex}",
+                  "name": "socket",
+                  "type": "stream.Duplex"
+                }
+              ],
+              "desc": "<p>This event is emitted when a new TCP stream is established. <code>socket</code> is\ntypically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>. Usually users will not want to\naccess this event. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. The <code>socket</code> can\nalso be accessed at <code>request.socket</code>.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>\n<p>If <code>socket.setTimeout()</code> is called here, the timeout will be replaced with\n<code>server.keepAliveTimeout</code> when the socket has served a request (if\n<code>server.keepAliveTimeout</code> is non-zero).</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
             },
             {
-              "textRaw": "Event: `'information'`",
+              "textRaw": "Event: `'request'`",
               "type": "event",
-              "name": "information",
+              "name": "request",
               "meta": {
                 "added": [
-                  "v10.0.0"
+                  "v0.1.0"
                 ],
                 "changes": []
               },
               "params": [
                 {
-                  "textRaw": "`info` {Object}",
-                  "name": "info",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`httpVersion` {string}",
-                      "name": "httpVersion",
-                      "type": "string"
-                    },
-                    {
-                      "textRaw": "`httpVersionMajor` {integer}",
-                      "name": "httpVersionMajor",
-                      "type": "integer"
-                    },
-                    {
-                      "textRaw": "`httpVersionMinor` {integer}",
-                      "name": "httpVersionMinor",
-                      "type": "integer"
-                    },
-                    {
-                      "textRaw": "`statusCode` {integer}",
-                      "name": "statusCode",
-                      "type": "integer"
-                    },
+                  "textRaw": "`request` {http.IncomingMessage}",
+                  "name": "request",
+                  "type": "http.IncomingMessage"
+                },
+                {
+                  "textRaw": "`response` {http.ServerResponse}",
+                  "name": "response",
+                  "type": "http.ServerResponse"
+                }
+              ],
+              "desc": "<p>Emitted each time there is a request. There may be multiple requests\nper connection (in the case of HTTP Keep-Alive connections).</p>"
+            },
+            {
+              "textRaw": "Event: `'upgrade'`",
+              "type": "event",
+              "name": "upgrade",
+              "meta": {
+                "added": [
+                  "v0.1.94"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/19981",
+                    "description": "Not listening to this event no longer causes the socket to be destroyed if a client sends an Upgrade header."
+                  }
+                ]
+              },
+              "params": [
+                {
+                  "textRaw": "`request` {http.IncomingMessage} Arguments for the HTTP request, as it is in the [`'request'`][] event",
+                  "name": "request",
+                  "type": "http.IncomingMessage",
+                  "desc": "Arguments for the HTTP request, as it is in the [`'request'`][] event"
+                },
+                {
+                  "textRaw": "`socket` {stream.Duplex} Network socket between the server and client",
+                  "name": "socket",
+                  "type": "stream.Duplex",
+                  "desc": "Network socket between the server and client"
+                },
+                {
+                  "textRaw": "`head` {Buffer} The first packet of the upgraded stream (may be empty)",
+                  "name": "head",
+                  "type": "Buffer",
+                  "desc": "The first packet of the upgraded stream (may be empty)"
+                }
+              ],
+              "desc": "<p>Emitted each time a client requests an HTTP upgrade. Listening to this event\nis optional and clients cannot insist on a protocol change.</p>\n<p>After this event is emitted, the request's socket will not have a <code>'data'</code>\nevent listener, meaning it will need to be bound in order to handle data\nsent to the server on that socket.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+            }
+          ],
+          "methods": [
+            {
+              "textRaw": "`server.close([callback])`",
+              "type": "method",
+              "name": "close",
+              "meta": {
+                "added": [
+                  "v0.1.90"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
                     {
-                      "textRaw": "`statusMessage` {string}",
-                      "name": "statusMessage",
-                      "type": "string"
-                    },
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Stops the server from accepting new connections. See <a href=\"net.html#net_server_close_callback\"><code>net.Server.close()</code></a>.</p>"
+            },
+            {
+              "textRaw": "`server.listen()`",
+              "type": "method",
+              "name": "listen",
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Starts the HTTP server listening for connections.\nThis method is identical to <a href=\"net.html#net_server_listen\"><code>server.listen()</code></a> from <a href=\"net.html#net_class_net_server\"><code>net.Server</code></a>.</p>"
+            },
+            {
+              "textRaw": "`server.setTimeout([msecs][, callback])`",
+              "type": "method",
+              "name": "setTimeout",
+              "meta": {
+                "added": [
+                  "v0.9.12"
+                ],
+                "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27558",
+                    "description": "The default timeout changed from 120s to 0 (no timeout)."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {http.Server}",
+                    "name": "return",
+                    "type": "http.Server"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`headers` {Object}",
-                      "name": "headers",
-                      "type": "Object"
+                      "textRaw": "`msecs` {number} **Default:** 0 (no timeout)",
+                      "name": "msecs",
+                      "type": "number",
+                      "default": "0 (no timeout)"
                     },
                     {
-                      "textRaw": "`rawHeaders` {string[]}",
-                      "name": "rawHeaders",
-                      "type": "string[]"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Emitted when the server sends a 1xx intermediate response (excluding 101\nUpgrade). The listeners of this event will receive an object containing the\nHTTP version, status code, status message, key-value headers object,\nand array with the raw header names followed by their respective values.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst options = {\n  host: '127.0.0.1',\n  port: 8080,\n  path: '/length_request'\n};\n\n// Make a request\nconst req = http.request(options);\nreq.end();\n\nreq.on('information', (info) => {\n  console.log(`Got information prior to main response: ${info.statusCode}`);\n});\n</code></pre>\n<p>101 Upgrade statuses do not fire this event due to their break from the\ntraditional HTTP request/response chain, such as web sockets, in-place TLS\nupgrades, or HTTP 2.0. To be notified of 101 Upgrade notices, listen for the\n<a href=\"http.html#http_event_upgrade\"><code>'upgrade'</code></a> event instead.</p>"
+              "desc": "<p>Sets the timeout value for sockets, and emits a <code>'timeout'</code> event on\nthe Server object, passing the socket as an argument, if a timeout\noccurs.</p>\n<p>If there is a <code>'timeout'</code> event listener on the Server object, then it\nwill be called with the timed-out socket as an argument.</p>\n<p>By default, the Server does not timeout sockets. However, if a callback\nis assigned to the Server's <code>'timeout'</code> event, timeouts must be handled\nexplicitly.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`headersTimeout` {number} **Default:** `60000`",
+              "type": "number",
+              "name": "headersTimeout",
+              "meta": {
+                "added": [
+                  "v11.3.0",
+                  "v10.14.0"
+                ],
+                "changes": []
+              },
+              "default": "`60000`",
+              "desc": "<p>Limit the amount of time the parser will wait to receive the complete HTTP\nheaders.</p>\n<p>In case of inactivity, the rules defined in <a href=\"http.html#http_server_timeout\"><code>server.timeout</code></a> apply. However,\nthat inactivity based timeout would still allow the connection to be kept open\nif the headers are being sent very slowly (by default, up to a byte per 2\nminutes). In order to prevent this, whenever header data arrives an additional\ncheck is made that more than <code>server.headersTimeout</code> milliseconds has not\npassed since the connection was established. If the check fails, a <code>'timeout'</code>\nevent is emitted on the server object, and (by default) the socket is destroyed.\nSee <a href=\"http.html#http_server_timeout\"><code>server.timeout</code></a> for more information on how timeout behavior can be\ncustomized.</p>"
             },
             {
-              "textRaw": "Event: `'response'`",
-              "type": "event",
-              "name": "response",
+              "textRaw": "`listening` {boolean} Indicates whether or not the server is listening for connections.",
+              "type": "boolean",
+              "name": "listening",
+              "meta": {
+                "added": [
+                  "v5.7.0"
+                ],
+                "changes": []
+              },
+              "desc": "Indicates whether or not the server is listening for connections."
+            },
+            {
+              "textRaw": "`maxHeadersCount` {number} **Default:** `2000`",
+              "type": "number",
+              "name": "maxHeadersCount",
+              "meta": {
+                "added": [
+                  "v0.7.0"
+                ],
+                "changes": []
+              },
+              "default": "`2000`",
+              "desc": "<p>Limits maximum incoming headers count. If set to 0, no limit will be applied.</p>"
+            },
+            {
+              "textRaw": "`requestTimeout` {number} **Default:** `0`",
+              "type": "number",
+              "name": "requestTimeout",
+              "meta": {
+                "added": [
+                  "v14.11.0"
+                ],
+                "changes": []
+              },
+              "default": "`0`",
+              "desc": "<p>Sets the timeout value in milliseconds for receiving the entire request from\nthe client.</p>\n<p>If the timeout expires, the server responds with status 408 without\nforwarding the request to the request listener and then closes the connection.</p>\n<p>It must be set to a non-zero value (e.g. 120 seconds) to protect against\npotential Denial-of-Service attacks in case the server is deployed without a\nreverse proxy in front.</p>"
+            },
+            {
+              "textRaw": "`timeout` {number} Timeout in milliseconds. **Default:** 0 (no timeout)",
+              "type": "number",
+              "name": "timeout",
+              "meta": {
+                "added": [
+                  "v0.9.12"
+                ],
+                "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27558",
+                    "description": "The default timeout changed from 120s to 0 (no timeout)."
+                  }
+                ]
+              },
+              "default": "0 (no timeout)",
+              "desc": "<p>The number of milliseconds of inactivity before a socket is presumed\nto have timed out.</p>\n<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>\n<p>The socket timeout logic is set up on connection, so changing this\nvalue only affects new connections to the server, not any existing connections.</p>",
+              "shortDesc": "Timeout in milliseconds."
+            },
+            {
+              "textRaw": "`keepAliveTimeout` {number} Timeout in milliseconds. **Default:** `5000` (5 seconds).",
+              "type": "number",
+              "name": "keepAliveTimeout",
               "meta": {
                 "added": [
-                  "v0.1.0"
+                  "v8.0.0"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`response` {http.IncomingMessage}",
-                  "name": "response",
-                  "type": "http.IncomingMessage"
-                }
-              ],
-              "desc": "<p>Emitted when a response is received to this request. This event is emitted only\nonce.</p>"
-            },
+              "default": "`5000` (5 seconds)",
+              "desc": "<p>The number of milliseconds of inactivity a server needs to wait for additional\nincoming data, after it has finished writing the last response, before a socket\nwill be destroyed. If the server receives new data before the keep-alive\ntimeout has fired, it will reset the regular inactivity timeout, i.e.,\n<a href=\"http.html#http_server_timeout\"><code>server.timeout</code></a>.</p>\n<p>A value of <code>0</code> will disable the keep-alive timeout behavior on incoming\nconnections.\nA value of <code>0</code> makes the http server behave similarly to Node.js versions prior\nto 8.0.0, which did not have a keep-alive timeout.</p>\n<p>The socket timeout logic is set up on connection, so changing this value only\naffects new connections to the server, not any existing connections.</p>",
+              "shortDesc": "Timeout in milliseconds."
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `http.ServerResponse`",
+          "type": "class",
+          "name": "http.ServerResponse",
+          "meta": {
+            "added": [
+              "v0.1.17"
+            ],
+            "changes": []
+          },
+          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a></li>\n</ul>\n<p>This object is created internally by an HTTP server, not by the user. It is\npassed as the second parameter to the <a href=\"http.html#http_event_request\"><code>'request'</code></a> event.</p>",
+          "events": [
             {
-              "textRaw": "Event: `'socket'`",
+              "textRaw": "Event: `'close'`",
               "type": "event",
-              "name": "socket",
+              "name": "close",
               "meta": {
                 "added": [
-                  "v0.5.3"
+                  "v0.6.7"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`socket` {stream.Duplex}",
-                  "name": "socket",
-                  "type": "stream.Duplex"
-                }
-              ],
-              "desc": "<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "params": [],
+              "desc": "<p>Indicates that the response is completed, or its underlying connection was\nterminated prematurely (before the response completion).</p>"
             },
             {
-              "textRaw": "Event: `'timeout'`",
+              "textRaw": "Event: `'finish'`",
               "type": "event",
-              "name": "timeout",
+              "name": "finish",
               "meta": {
                 "added": [
-                  "v0.7.8"
+                  "v0.3.6"
                 ],
                 "changes": []
               },
               "params": [],
-              "desc": "<p>Emitted when the underlying socket times out from inactivity. This only notifies\nthat the socket has been idle. The request must be aborted manually.</p>\n<p>See also: <a href=\"http.html#http_request_settimeout_timeout_callback\"><code>request.setTimeout()</code></a>.</p>"
-            },
+              "desc": "<p>Emitted when the response has been sent. More specifically, this event is\nemitted when the last segment of the response headers and body have been\nhanded off to the operating system for transmission over the network. It\ndoes not imply that the client has received anything yet.</p>"
+            }
+          ],
+          "methods": [
             {
-              "textRaw": "Event: `'upgrade'`",
-              "type": "event",
-              "name": "upgrade",
+              "textRaw": "`response.addTrailers(headers)`",
+              "type": "method",
+              "name": "addTrailers",
               "meta": {
                 "added": [
-                  "v0.1.94"
+                  "v0.3.0"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`response` {http.IncomingMessage}",
-                  "name": "response",
-                  "type": "http.IncomingMessage"
-                },
-                {
-                  "textRaw": "`socket` {stream.Duplex}",
-                  "name": "socket",
-                  "type": "stream.Duplex"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`head` {Buffer}",
-                  "name": "head",
-                  "type": "Buffer"
+                  "params": [
+                    {
+                      "textRaw": "`headers` {Object}",
+                      "name": "headers",
+                      "type": "Object"
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted each time a server responds to a request with an upgrade. If this\nevent is not being listened for and the response status code is 101 Switching\nProtocols, clients receiving an upgrade header will have their connections\nclosed.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>A client server pair demonstrating how to listen for the <code>'upgrade'</code> event.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\n// Create an HTTP server\nconst server = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('okay');\n});\nserver.on('upgrade', (req, socket, head) => {\n  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\\r\\n' +\n               'Upgrade: WebSocket\\r\\n' +\n               'Connection: Upgrade\\r\\n' +\n               '\\r\\n');\n\n  socket.pipe(socket); // echo back\n});\n\n// Now that server is running\nserver.listen(1337, '127.0.0.1', () => {\n\n  // make a request\n  const options = {\n    port: 1337,\n    host: '127.0.0.1',\n    headers: {\n      'Connection': 'Upgrade',\n      'Upgrade': 'websocket'\n    }\n  };\n\n  const req = http.request(options);\n  req.end();\n\n  req.on('upgrade', (res, socket, upgradeHead) => {\n    console.log('got upgraded!');\n    socket.end();\n    process.exit(0);\n  });\n});\n</code></pre>"
-            }
-          ],
-          "methods": [
+              "desc": "<p>This method adds HTTP trailing headers (a header but at the end of the\nmessage) to the response.</p>\n<p>Trailers will <strong>only</strong> be emitted if chunked encoding is used for the\nresponse; if it is not (e.g. if the request was HTTP/1.0), they will\nbe silently discarded.</p>\n<p>HTTP requires the <code>Trailer</code> header to be sent in order to\nemit trailers, with a list of the header fields in its value. E.g.,</p>\n<pre><code class=\"language-js\">response.writeHead(200, { 'Content-Type': 'text/plain',\n                          'Trailer': 'Content-MD5' });\nresponse.write(fileData);\nresponse.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' });\nresponse.end();\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
+            },
             {
-              "textRaw": "`request.abort()`",
+              "textRaw": "`response.cork()`",
               "type": "method",
-              "name": "abort",
+              "name": "cork",
               "meta": {
                 "added": [
-                  "v0.3.8"
+                  "v13.2.0",
+                  "v12.16.0"
                 ],
                 "changes": []
               },
@@ -34857,10 +39264,10 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Marks the request as aborting. Calling this will cause remaining data\nin the response to be dropped and the socket to be destroyed.</p>"
+              "desc": "<p>See <a href=\"stream.html#stream_writable_cork\"><code>writable.cork()</code></a>.</p>"
             },
             {
-              "textRaw": "`request.end([data[, encoding]][, callback])`",
+              "textRaw": "`response.end([data[, encoding]][, callback])`",
               "type": "method",
               "name": "end",
               "meta": {
@@ -34871,7 +39278,7 @@
                   {
                     "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/18780",
-                    "description": "This method now returns a reference to `ClientRequest`."
+                    "description": "This method now returns a reference to `ServerResponse`."
                   }
                 ]
               },
@@ -34901,10 +39308,10 @@
                   ]
                 }
               ],
-              "desc": "<p>Finishes sending the request. If any parts of the body are\nunsent, it will flush them to the stream. If the request is\nchunked, this will send the terminating <code>'0\\r\\n\\r\\n'</code>.</p>\n<p>If <code>data</code> is specified, it is equivalent to calling\n<a href=\"http.html#http_request_write_chunk_encoding_callback\"><code>request.write(data, encoding)</code></a> followed by <code>request.end(callback)</code>.</p>\n<p>If <code>callback</code> is specified, it will be called when the request stream\nis finished.</p>"
+              "desc": "<p>This method signals to the server that all of the response headers and body\nhave been sent; that server should consider this message complete.\nThe method, <code>response.end()</code>, MUST be called on each response.</p>\n<p>If <code>data</code> is specified, it is similar in effect to calling\n<a href=\"http.html#http_response_write_chunk_encoding_callback\"><code>response.write(data, encoding)</code></a> followed by <code>response.end(callback)</code>.</p>\n<p>If <code>callback</code> is specified, it will be called when the response stream\nis finished.</p>"
             },
             {
-              "textRaw": "`request.flushHeaders()`",
+              "textRaw": "`response.flushHeaders()`",
               "type": "method",
               "name": "flushHeaders",
               "meta": {
@@ -34918,15 +39325,15 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Flushes the request headers.</p>\n<p>For efficiency reasons, Node.js normally buffers the request headers until\n<code>request.end()</code> is called or the first chunk of request data is written. It\nthen tries to pack the request headers and data into a single TCP packet.</p>\n<p>That's usually desired (it saves a TCP round-trip), but not when the first\ndata is not sent until possibly much later. <code>request.flushHeaders()</code> bypasses\nthe optimization and kickstarts the request.</p>"
+              "desc": "<p>Flushes the response headers. See also: <a href=\"http.html#http_request_flushheaders\"><code>request.flushHeaders()</code></a>.</p>"
             },
             {
-              "textRaw": "`request.getHeader(name)`",
+              "textRaw": "`response.getHeader(name)`",
               "type": "method",
               "name": "getHeader",
               "meta": {
                 "added": [
-                  "v1.6.0"
+                  "v0.4.0"
                 ],
                 "changes": []
               },
@@ -34946,66 +39353,87 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads out a header on the request. The name is case-insensitive.\nThe type of the return value depends on the arguments provided to\n<a href=\"http.html#http_request_setheader_name_value\"><code>request.setHeader()</code></a>.</p>\n<pre><code class=\"language-js\">request.setHeader('content-type', 'text/html');\nrequest.setHeader('Content-Length', Buffer.byteLength(body));\nrequest.setHeader('Cookie', ['type=ninja', 'language=javascript']);\nconst contentType = request.getHeader('Content-Type');\n// 'contentType' is 'text/html'\nconst contentLength = request.getHeader('Content-Length');\n// 'contentLength' is of type number\nconst cookie = request.getHeader('Cookie');\n// 'cookie' is of type string[]\n</code></pre>"
+              "desc": "<p>Reads out a header that's already been queued but not sent to the client.\nThe name is case-insensitive. The type of the return value depends\non the arguments provided to <a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a>.</p>\n<pre><code class=\"language-js\">response.setHeader('Content-Type', 'text/html');\nresponse.setHeader('Content-Length', Buffer.byteLength(body));\nresponse.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);\nconst contentType = response.getHeader('content-type');\n// contentType is 'text/html'\nconst contentLength = response.getHeader('Content-Length');\n// contentLength is of type number\nconst setCookie = response.getHeader('set-cookie');\n// setCookie is of type string[]\n</code></pre>"
             },
             {
-              "textRaw": "`request.removeHeader(name)`",
+              "textRaw": "`response.getHeaderNames()`",
               "type": "method",
-              "name": "removeHeader",
+              "name": "getHeaderNames",
               "meta": {
                 "added": [
-                  "v1.6.0"
+                  "v7.7.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
-                  "params": [
-                    {
-                      "textRaw": "`name` {string}",
-                      "name": "name",
-                      "type": "string"
-                    }
-                  ]
+                  "return": {
+                    "textRaw": "Returns: {string[]}",
+                    "name": "return",
+                    "type": "string[]"
+                  },
+                  "params": []
                 }
               ],
-              "desc": "<p>Removes a header that's already defined into headers object.</p>\n<pre><code class=\"language-js\">request.removeHeader('Content-Type');\n</code></pre>"
+              "desc": "<p>Returns an array containing the unique names of the current outgoing headers.\nAll header names are lowercase.</p>\n<pre><code class=\"language-js\">response.setHeader('Foo', 'bar');\nresponse.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);\n\nconst headerNames = response.getHeaderNames();\n// headerNames === ['foo', 'set-cookie']\n</code></pre>"
             },
             {
-              "textRaw": "`request.setHeader(name, value)`",
+              "textRaw": "`response.getHeaders()`",
               "type": "method",
-              "name": "setHeader",
+              "name": "getHeaders",
               "meta": {
                 "added": [
-                  "v1.6.0"
+                  "v7.7.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Object}",
+                    "name": "return",
+                    "type": "Object"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns a shallow copy of the current outgoing headers. Since a shallow copy\nis used, array values may be mutated without additional calls to various\nheader-related http module methods. The keys of the returned object are the\nheader names and the values are the respective header values. All header names\nare lowercase.</p>\n<p>The object returned by the <code>response.getHeaders()</code> method <em>does not</em>\nprototypically inherit from the JavaScript <code>Object</code>. This means that typical\n<code>Object</code> methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>, and others\nare not defined and <em>will not work</em>.</p>\n<pre><code class=\"language-js\">response.setHeader('Foo', 'bar');\nresponse.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);\n\nconst headers = response.getHeaders();\n// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }\n</code></pre>"
+            },
+            {
+              "textRaw": "`response.hasHeader(name)`",
+              "type": "method",
+              "name": "hasHeader",
+              "meta": {
+                "added": [
+                  "v7.7.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
                   "params": [
                     {
                       "textRaw": "`name` {string}",
                       "name": "name",
                       "type": "string"
-                    },
-                    {
-                      "textRaw": "`value` {any}",
-                      "name": "value",
-                      "type": "any"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Sets a single header value for headers object. If this header already exists in\nthe to-be-sent headers, its value will be replaced. Use an array of strings\nhere to send multiple headers with the same name. Non-string values will be\nstored without modification. Therefore, <a href=\"http.html#http_request_getheader_name\"><code>request.getHeader()</code></a> may return\nnon-string values. However, the non-string values will be converted to strings\nfor network transmission.</p>\n<pre><code class=\"language-js\">request.setHeader('Content-Type', 'application/json');\n</code></pre>\n<p>or</p>\n<pre><code class=\"language-js\">request.setHeader('Cookie', ['type=ninja', 'language=javascript']);\n</code></pre>"
+              "desc": "<p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the\noutgoing headers. The header name matching is case-insensitive.</p>\n<pre><code class=\"language-js\">const hasContentType = response.hasHeader('content-type');\n</code></pre>"
             },
             {
-              "textRaw": "`request.setNoDelay([noDelay])`",
+              "textRaw": "`response.removeHeader(name)`",
               "type": "method",
-              "name": "setNoDelay",
+              "name": "removeHeader",
               "meta": {
                 "added": [
-                  "v0.5.9"
+                  "v0.4.0"
                 ],
                 "changes": []
               },
@@ -35013,86 +39441,101 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`noDelay` {boolean}",
-                      "name": "noDelay",
-                      "type": "boolean"
+                      "textRaw": "`name` {string}",
+                      "name": "name",
+                      "type": "string"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Once a socket is assigned to this request and is connected\n<a href=\"net.html#net_socket_setnodelay_nodelay\"><code>socket.setNoDelay()</code></a> will be called.</p>"
+              "desc": "<p>Removes a header that's queued for implicit sending.</p>\n<pre><code class=\"language-js\">response.removeHeader('Content-Encoding');\n</code></pre>"
             },
             {
-              "textRaw": "`request.setSocketKeepAlive([enable][, initialDelay])`",
+              "textRaw": "`response.setHeader(name, value)`",
               "type": "method",
-              "name": "setSocketKeepAlive",
+              "name": "setHeader",
               "meta": {
                 "added": [
-                  "v0.5.9"
+                  "v0.4.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
+                  "return": {
+                    "textRaw": "Returns: {http.ServerResponse}",
+                    "name": "return",
+                    "type": "http.ServerResponse"
+                  },
                   "params": [
                     {
-                      "textRaw": "`enable` {boolean}",
-                      "name": "enable",
-                      "type": "boolean"
+                      "textRaw": "`name` {string}",
+                      "name": "name",
+                      "type": "string"
                     },
                     {
-                      "textRaw": "`initialDelay` {number}",
-                      "name": "initialDelay",
-                      "type": "number"
+                      "textRaw": "`value` {any}",
+                      "name": "value",
+                      "type": "any"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Once a socket is assigned to this request and is connected\n<a href=\"net.html#net_socket_setkeepalive_enable_initialdelay\"><code>socket.setKeepAlive()</code></a> will be called.</p>"
+              "desc": "<p>Returns the response object.</p>\n<p>Sets a single header value for implicit headers. If this header already exists\nin the to-be-sent headers, its value will be replaced. Use an array of strings\nhere to send multiple headers with the same name. Non-string values will be\nstored without modification. Therefore, <a href=\"http.html#http_response_getheader_name\"><code>response.getHeader()</code></a> may return\nnon-string values. However, the non-string values will be converted to strings\nfor network transmission. The same response object is returned to the caller,\nto enable call chaining.</p>\n<pre><code class=\"language-js\">response.setHeader('Content-Type', 'text/html');\n</code></pre>\n<p>or</p>\n<pre><code class=\"language-js\">response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>\n<p>When headers have been set with <a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('ok');\n});\n</code></pre>\n<p>If <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> method is called and this method has not been\ncalled, it will directly write the supplied header values onto the network\nchannel without caching internally, and the <a href=\"http.html#http_response_getheader_name\"><code>response.getHeader()</code></a> on the\nheader will not yield the expected result. If progressive population of headers\nis desired with potential future retrieval and modification, use\n<a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a> instead of <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>.</p>"
             },
             {
-              "textRaw": "`request.setTimeout(timeout[, callback])`",
+              "textRaw": "`response.setTimeout(msecs[, callback])`",
               "type": "method",
               "name": "setTimeout",
               "meta": {
                 "added": [
-                  "v0.5.9"
+                  "v0.9.12"
                 ],
-                "changes": [
-                  {
-                    "version": "v9.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/8895",
-                    "description": "Consistently set socket timeout only when the socket connects."
-                  }
-                ]
+                "changes": []
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {http.ClientRequest}",
+                    "textRaw": "Returns: {http.ServerResponse}",
                     "name": "return",
-                    "type": "http.ClientRequest"
+                    "type": "http.ServerResponse"
                   },
                   "params": [
                     {
-                      "textRaw": "`timeout` {number} Milliseconds before a request times out.",
-                      "name": "timeout",
-                      "type": "number",
-                      "desc": "Milliseconds before a request times out."
+                      "textRaw": "`msecs` {number}",
+                      "name": "msecs",
+                      "type": "number"
                     },
                     {
-                      "textRaw": "`callback` {Function} Optional function to be called when a timeout occurs. Same as binding to the `'timeout'` event.",
+                      "textRaw": "`callback` {Function}",
                       "name": "callback",
-                      "type": "Function",
-                      "desc": "Optional function to be called when a timeout occurs. Same as binding to the `'timeout'` event."
+                      "type": "Function"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Once a socket is assigned to this request and is connected\n<a href=\"net.html#net_socket_settimeout_timeout_callback\"><code>socket.setTimeout()</code></a> will be called.</p>"
+              "desc": "<p>Sets the Socket's timeout value to <code>msecs</code>. If a callback is\nprovided, then it is added as a listener on the <code>'timeout'</code> event on\nthe response object.</p>\n<p>If no <code>'timeout'</code> listener is added to the request, the response, or\nthe server, then sockets are destroyed when they time out. If a handler is\nassigned to the request, the response, or the server's <code>'timeout'</code> events,\ntimed out sockets must be handled explicitly.</p>"
             },
             {
-              "textRaw": "`request.write(chunk[, encoding][, callback])`",
+              "textRaw": "`response.uncork()`",
+              "type": "method",
+              "name": "uncork",
+              "meta": {
+                "added": [
+                  "v13.2.0",
+                  "v12.16.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>See <a href=\"stream.html#stream_writable_uncork\"><code>writable.uncork()</code></a>.</p>"
+            },
+            {
+              "textRaw": "`response.write(chunk[, encoding][, callback])`",
               "type": "method",
               "name": "write",
               "meta": {
@@ -35115,9 +39558,10 @@
                       "type": "string|Buffer"
                     },
                     {
-                      "textRaw": "`encoding` {string}",
+                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
                       "name": "encoding",
-                      "type": "string"
+                      "type": "string",
+                      "default": "`'utf8'`"
                     },
                     {
                       "textRaw": "`callback` {Function}",
@@ -35127,28 +39571,104 @@
                   ]
                 }
               ],
-              "desc": "<p>Sends a chunk of the body. By calling this method\nmany times, a request body can be sent to a\nserver. In that case, it is suggested to use the\n<code>['Transfer-Encoding', 'chunked']</code> header line when\ncreating the request.</p>\n<p>The <code>encoding</code> argument is optional and only applies when <code>chunk</code> is a string.\nDefaults to <code>'utf8'</code>.</p>\n<p>The <code>callback</code> argument is optional and will be called when this chunk of data\nis flushed, but only if the chunk is non-empty.</p>\n<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel\nbuffer. Returns <code>false</code> if all or part of the data was queued in user memory.\n<code>'drain'</code> will be emitted when the buffer is free again.</p>\n<p>When <code>write</code> function is called with empty string or buffer, it does\nnothing and waits for more input.</p>"
-            }
-          ],
-          "properties": [
+              "desc": "<p>If this method is called and <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> has not been called,\nit will switch to implicit header mode and flush the implicit headers.</p>\n<p>This sends a chunk of the response body. This method may\nbe called multiple times to provide successive parts of the body.</p>\n<p>In the <code>http</code> module, the response body is omitted when the\nrequest is a HEAD request. Similarly, the <code>204</code> and <code>304</code> responses\n<em>must not</em> include a message body.</p>\n<p><code>chunk</code> can be a string or a buffer. If <code>chunk</code> is a string,\nthe second parameter specifies how to encode it into a byte stream.\n<code>callback</code> will be called when this chunk of data is flushed.</p>\n<p>This is the raw HTTP body and has nothing to do with higher-level multi-part\nbody encodings that may be used.</p>\n<p>The first time <a href=\"http.html#http_response_write_chunk_encoding_callback\"><code>response.write()</code></a> is called, it will send the buffered\nheader information and the first chunk of the body to the client. The second\ntime <a href=\"http.html#http_response_write_chunk_encoding_callback\"><code>response.write()</code></a> is called, Node.js assumes data will be streamed,\nand sends the new data separately. That is, the response is buffered up to the\nfirst chunk of the body.</p>\n<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel\nbuffer. Returns <code>false</code> if all or part of the data was queued in user memory.\n<code>'drain'</code> will be emitted when the buffer is free again.</p>"
+            },
             {
-              "textRaw": "`aborted` {boolean}",
-              "type": "boolean",
-              "name": "aborted",
+              "textRaw": "`response.writeContinue()`",
+              "type": "method",
+              "name": "writeContinue",
               "meta": {
                 "added": [
-                  "v0.11.14"
+                  "v0.3.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Sends a HTTP/1.1 100 Continue message to the client, indicating that\nthe request body should be sent. See the <a href=\"http.html#http_event_checkcontinue\"><code>'checkContinue'</code></a> event on\n<code>Server</code>.</p>"
+            },
+            {
+              "textRaw": "`response.writeHead(statusCode[, statusMessage][, headers])`",
+              "type": "method",
+              "name": "writeHead",
+              "meta": {
+                "added": [
+                  "v0.1.30"
                 ],
                 "changes": [
                   {
-                    "version": "v11.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/20230",
-                    "description": "The `aborted` property is no longer a timestamp number."
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35274",
+                    "description": "Allow passing headers as an array."
+                  },
+                  {
+                    "version": [
+                      "v11.10.0",
+                      "v10.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/25974",
+                    "description": "Return `this` from `writeHead()` to allow chaining with `end()`."
+                  },
+                  {
+                    "version": [
+                      "v5.11.0",
+                      "v4.4.5"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/6291",
+                    "description": "A `RangeError` is thrown if `statusCode` is not a number in the range `[100, 999]`."
                   }
                 ]
               },
-              "desc": "<p>The <code>request.aborted</code> property will be <code>true</code> if the request has\nbeen aborted.</p>"
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {http.ServerResponse}",
+                    "name": "return",
+                    "type": "http.ServerResponse"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`statusCode` {number}",
+                      "name": "statusCode",
+                      "type": "number"
+                    },
+                    {
+                      "textRaw": "`statusMessage` {string}",
+                      "name": "statusMessage",
+                      "type": "string"
+                    },
+                    {
+                      "textRaw": "`headers` {Object|Array}",
+                      "name": "headers",
+                      "type": "Object|Array"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Sends a response header to the request. The status code is a 3-digit HTTP\nstatus code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.\nOptionally one can give a human-readable <code>statusMessage</code> as the second\nargument.</p>\n<p><code>headers</code> may be an <code>Array</code> where the keys and values are in the same list.\nIt is <em>not</em> a list of tuples. So, the even-numbered offsets are key values,\nand the odd-numbered offsets are the associated values. The array is in the same\nformat as <code>request.rawHeaders</code>.</p>\n<p>Returns a reference to the <code>ServerResponse</code>, so that calls can be chained.</p>\n<pre><code class=\"language-js\">const body = 'hello world';\nresponse\n  .writeHead(200, {\n    'Content-Length': Buffer.byteLength(body),\n    'Content-Type': 'text/plain'\n  })\n  .end(body);\n</code></pre>\n<p>This method must only be called once on a message and it must\nbe called before <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> is called.</p>\n<p>If <a href=\"http.html#http_response_write_chunk_encoding_callback\"><code>response.write()</code></a> or <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> are called before calling\nthis, the implicit/mutable headers will be calculated and call this function.</p>\n<p>When headers have been set with <a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<p>If this method is called and <a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a> has not been called,\nit will directly write the supplied header values onto the network channel\nwithout caching internally, and the <a href=\"http.html#http_response_getheader_name\"><code>response.getHeader()</code></a> on the header\nwill not yield the expected result. If progressive population of headers is\ndesired with potential future retrieval and modification, use\n<a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a> instead.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('ok');\n});\n</code></pre>\n<p><code>Content-Length</code> is given in bytes, not characters. Use\n<a href=\"buffer.html#buffer_static_method_buffer_bytelength_string_encoding\"><code>Buffer.byteLength()</code></a> to determine the length of the body in bytes. Node.js\ndoes not check whether <code>Content-Length</code> and the length of the body which has\nbeen transmitted are equal or not.</p>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
             },
+            {
+              "textRaw": "`response.writeProcessing()`",
+              "type": "method",
+              "name": "writeProcessing",
+              "meta": {
+                "added": [
+                  "v10.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Sends a HTTP/1.1 102 Processing message to the client, indicating that\nthe request body should be sent.</p>"
+            }
+          ],
+          "properties": [
             {
               "textRaw": "`connection` {stream.Duplex}",
               "type": "stream.Duplex",
@@ -35157,9 +39677,14 @@
                 "added": [
                   "v0.3.0"
                 ],
+                "deprecated": [
+                  "v13.0.0"
+                ],
                 "changes": []
               },
-              "desc": "<p>See <a href=\"http.html#http_request_socket\"><code>request.socket</code></a>.</p>"
+              "stability": 0,
+              "stabilityText": "Deprecated. Use [`response.socket`][].",
+              "desc": "<p>See <a href=\"http.html#http_response_socket\"><code>response.socket</code></a>.</p>"
             },
             {
               "textRaw": "`finished` {boolean}",
@@ -35167,408 +39692,356 @@
               "name": "finished",
               "meta": {
                 "added": [
-                  "v0.0.1"
+                  "v0.0.2"
                 ],
                 "deprecated": [
+                  "v13.4.0",
                   "v12.16.0"
                 ],
                 "changes": []
               },
               "stability": 0,
-              "stabilityText": "Deprecated. Use [`request.writableEnded`][].",
-              "desc": "<p>The <code>request.finished</code> property will be <code>true</code> if <a href=\"http.html#http_request_end_data_encoding_callback\"><code>request.end()</code></a>\nhas been called. <code>request.end()</code> will automatically be called if the\nrequest was initiated via <a href=\"http.html#http_http_get_options_callback\"><code>http.get()</code></a>.</p>"
+              "stabilityText": "Deprecated. Use [`response.writableEnded`][].",
+              "desc": "<p>The <code>response.finished</code> property will be <code>true</code> if <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a>\nhas been called.</p>"
             },
             {
-              "textRaw": "`maxHeadersCount` {number} **Default:** `2000`",
-              "type": "number",
-              "name": "maxHeadersCount",
-              "default": "`2000`",
-              "desc": "<p>Limits maximum response headers count. If set to 0, no limit will be applied.</p>"
+              "textRaw": "`headersSent` {boolean}",
+              "type": "boolean",
+              "name": "headersSent",
+              "meta": {
+                "added": [
+                  "v0.9.3"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Boolean (read-only). True if headers were sent, false otherwise.</p>"
             },
             {
-              "textRaw": "`path` {string} The request path.",
-              "type": "string",
-              "name": "path",
+              "textRaw": "`sendDate` {boolean}",
+              "type": "boolean",
+              "name": "sendDate",
               "meta": {
                 "added": [
-                  "v0.4.0"
+                  "v0.7.5"
                 ],
                 "changes": []
               },
-              "desc": "The request path."
+              "desc": "<p>When true, the Date header will be automatically generated and sent in\nthe response if it is not already present in the headers. Defaults to true.</p>\n<p>This should only be disabled for testing; HTTP requires the Date header\nin responses.</p>"
             },
             {
-              "textRaw": "`method` {string} The request method.",
-              "type": "string",
-              "name": "method",
+              "textRaw": "`socket` {stream.Duplex}",
+              "type": "stream.Duplex",
+              "name": "socket",
               "meta": {
                 "added": [
-                  "v0.1.97"
+                  "v0.3.0"
                 ],
                 "changes": []
               },
-              "desc": "The request method."
+              "desc": "<p>Reference to the underlying socket. Usually users will not want to access\nthis property. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. After\n<code>response.end()</code>, the property is nulled.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst server = http.createServer((req, res) => {\n  const ip = res.socket.remoteAddress;\n  const port = res.socket.remotePort;\n  res.end(`Your IP address is ${ip} and your source port is ${port}.`);\n}).listen(3000);\n</code></pre>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
             },
             {
-              "textRaw": "`host` {string} The request host.",
-              "type": "string",
-              "name": "host",
+              "textRaw": "`statusCode` {number} **Default:** `200`",
+              "type": "number",
+              "name": "statusCode",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v0.4.0"
                 ],
                 "changes": []
               },
-              "desc": "The request host."
+              "default": "`200`",
+              "desc": "<p>When using implicit headers (not calling <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> explicitly),\nthis property controls the status code that will be sent to the client when\nthe headers get flushed.</p>\n<pre><code class=\"language-js\">response.statusCode = 404;\n</code></pre>\n<p>After response header was sent to the client, this property indicates the\nstatus code which was sent out.</p>"
             },
             {
-              "textRaw": "`protocol` {string} The request protocol.",
+              "textRaw": "`statusMessage` {string}",
               "type": "string",
-              "name": "protocol",
+              "name": "statusMessage",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v0.11.8"
                 ],
                 "changes": []
               },
-              "desc": "The request protocol."
+              "desc": "<p>When using implicit headers (not calling <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> explicitly),\nthis property controls the status message that will be sent to the client when\nthe headers get flushed. If this is left as <code>undefined</code> then the standard\nmessage for the status code will be used.</p>\n<pre><code class=\"language-js\">response.statusMessage = 'Not found';\n</code></pre>\n<p>After response header was sent to the client, this property indicates the\nstatus message which was sent out.</p>"
             },
             {
-              "textRaw": "`reusedSocket` {boolean} Whether the request is send through a reused socket.",
+              "textRaw": "`writableEnded` {boolean}",
               "type": "boolean",
-              "name": "reusedSocket",
+              "name": "writableEnded",
+              "meta": {
+                "added": [
+                  "v12.9.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Is <code>true</code> after <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> has been called. This property\ndoes not indicate whether the data has been flushed, for this use\n<a href=\"http.html#http_response_writablefinished\"><code>response.writableFinished</code></a> instead.</p>"
+            },
+            {
+              "textRaw": "`writableFinished` {boolean}",
+              "type": "boolean",
+              "name": "writableFinished",
               "meta": {
                 "added": [
+                  "v12.7.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Is <code>true</code> if all data has been flushed to the underlying system, immediately\nbefore the <a href=\"http.html#http_event_finish\"><code>'finish'</code></a> event is emitted.</p>"
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `http.IncomingMessage`",
+          "type": "class",
+          "name": "http.IncomingMessage",
+          "meta": {
+            "added": [
+              "v0.1.17"
+            ],
+            "changes": [
+              {
+                "version": [
+                  "v13.1.0",
                   "v12.16.0"
                 ],
+                "pr-url": "https://github.com/nodejs/node/pull/30135",
+                "description": "The `readableHighWaterMark` value mirrors that of the socket."
+              }
+            ]
+          },
+          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_readable\" class=\"type\">&lt;stream.Readable&gt;</a></li>\n</ul>\n<p>An <code>IncomingMessage</code> object is created by <a href=\"http.html#http_class_http_server\"><code>http.Server</code></a> or\n<a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> and passed as the first argument to the <a href=\"http.html#http_event_request\"><code>'request'</code></a>\nand <a href=\"http.html#http_event_response\"><code>'response'</code></a> event respectively. It may be used to access response\nstatus, headers and data.</p>",
+          "events": [
+            {
+              "textRaw": "Event: `'aborted'`",
+              "type": "event",
+              "name": "aborted",
+              "meta": {
+                "added": [
+                  "v0.3.8"
+                ],
                 "changes": []
               },
-              "desc": "<p>When sending request through a keep-alive enabled agent, the underlying socket\nmight be reused. But if server closes connection at unfortunate time, client\nmay run into a 'ECONNRESET' error.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\n// Server has a 5 seconds keep-alive timeout by default\nhttp\n  .createServer((req, res) => {\n    res.write('hello\\n');\n    res.end();\n  })\n  .listen(3000);\n\nsetInterval(() => {\n  // Adapting a keep-alive agent\n  http.get('http://localhost:3000', { agent }, (res) => {\n    res.on('data', (data) => {\n      // Do nothing\n    });\n  });\n}, 5000); // Sending request on 5s interval so it's easy to hit idle timeout\n</code></pre>\n<p>By marking a request whether it reused socket or not, we can do\nautomatic error retry base on it.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst agent = new http.Agent({ keepAlive: true });\n\nfunction retriableRequest() {\n  const req = http\n    .get('http://localhost:3000', { agent }, (res) => {\n      // ...\n    })\n    .on('error', (err) => {\n      // Check if retry is needed\n      if (req.reusedSocket &#x26;&#x26; err.code === 'ECONNRESET') {\n        retriableRequest();\n      }\n    });\n}\n\nretriableRequest();\n</code></pre>",
-              "shortDesc": "Whether the request is send through a reused socket."
+              "params": [],
+              "desc": "<p>Emitted when the request has been aborted.</p>"
             },
             {
-              "textRaw": "`socket` {stream.Duplex}",
-              "type": "stream.Duplex",
-              "name": "socket",
+              "textRaw": "Event: `'close'`",
+              "type": "event",
+              "name": "close",
               "meta": {
                 "added": [
-                  "v0.3.0"
+                  "v0.4.2"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>Indicates that the underlying connection was closed.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`aborted` {boolean}",
+              "type": "boolean",
+              "name": "aborted",
+              "meta": {
+                "added": [
+                  "v10.1.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>Reference to the underlying socket. Usually users will not want to access\nthis property. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. The <code>socket</code>\nmay also be accessed via <code>request.connection</code>.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst options = {\n  host: 'www.google.com',\n};\nconst req = http.get(options);\nreq.end();\nreq.once('response', (res) => {\n  const ip = req.socket.localAddress;\n  const port = req.socket.localPort;\n  console.log(`Your IP address is ${ip} and your source port is ${port}.`);\n  // Consume response object\n});\n</code></pre>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "desc": "<p>The <code>message.aborted</code> property will be <code>true</code> if the request has\nbeen aborted.</p>"
             },
             {
-              "textRaw": "`writableEnded` {boolean}",
+              "textRaw": "`complete` {boolean}",
               "type": "boolean",
-              "name": "writableEnded",
+              "name": "complete",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The <code>message.complete</code> property will be <code>true</code> if a complete HTTP message has\nbeen received and successfully parsed.</p>\n<p>This property is particularly useful as a means of determining if a client or\nserver fully transmitted a message before a connection was terminated:</p>\n<pre><code class=\"language-js\">const req = http.request({\n  host: '127.0.0.1',\n  port: 8080,\n  method: 'POST'\n}, (res) => {\n  res.resume();\n  res.on('end', () => {\n    if (!res.complete)\n      console.error(\n        'The connection was terminated while the message was still being sent');\n  });\n});\n</code></pre>"
+            },
+            {
+              "textRaw": "`headers` {Object}",
+              "type": "Object",
+              "name": "headers",
               "meta": {
                 "added": [
-                  "v12.9.0"
+                  "v0.1.5"
                 ],
                 "changes": []
               },
-              "desc": "<p>Is <code>true</code> after <a href=\"http.html#http_request_end_data_encoding_callback\"><code>request.end()</code></a> has been called. This property\ndoes not indicate whether the data has been flushed, for this use\n<a href=\"http.html#http_request_writablefinished\"><code>request.writableFinished</code></a> instead.</p>"
+              "desc": "<p>The request/response headers object.</p>\n<p>Key-value pairs of header names and values. Header names are lower-cased.</p>\n<pre><code class=\"language-js\">// Prints something like:\n//\n// { 'user-agent': 'curl/7.22.0',\n//   host: '127.0.0.1:8000',\n//   accept: '*/*' }\nconsole.log(request.headers);\n</code></pre>\n<p>Duplicates in raw headers are handled in the following ways, depending on the\nheader name:</p>\n<ul>\n<li>Duplicates of <code>age</code>, <code>authorization</code>, <code>content-length</code>, <code>content-type</code>,\n<code>etag</code>, <code>expires</code>, <code>from</code>, <code>host</code>, <code>if-modified-since</code>, <code>if-unmodified-since</code>,\n<code>last-modified</code>, <code>location</code>, <code>max-forwards</code>, <code>proxy-authorization</code>, <code>referer</code>,\n<code>retry-after</code>, <code>server</code>, or <code>user-agent</code> are discarded.</li>\n<li><code>set-cookie</code> is always an array. Duplicates are added to the array.</li>\n<li>For duplicate <code>cookie</code> headers, the values are joined together with '; '.</li>\n<li>For all other headers, the values are joined together with ', '.</li>\n</ul>"
             },
             {
-              "textRaw": "`writableFinished` {boolean}",
-              "type": "boolean",
-              "name": "writableFinished",
+              "textRaw": "`httpVersion` {string}",
+              "type": "string",
+              "name": "httpVersion",
               "meta": {
                 "added": [
-                  "v12.7.0"
+                  "v0.1.1"
                 ],
                 "changes": []
               },
-              "desc": "<p>Is <code>true</code> if all data has been flushed to the underlying system, immediately\nbefore the <a href=\"http.html#http_event_finish\"><code>'finish'</code></a> event is emitted.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `http.Server`",
-          "type": "class",
-          "name": "http.Server",
-          "meta": {
-            "added": [
-              "v0.1.17"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends: <a href=\"net.html#net_class_net_server\" class=\"type\">&lt;net.Server&gt;</a></li>\n</ul>",
-          "events": [
+              "desc": "<p>In case of server request, the HTTP version sent by the client. In the case of\nclient response, the HTTP version of the connected-to server.\nProbably either <code>'1.1'</code> or <code>'1.0'</code>.</p>\n<p>Also <code>message.httpVersionMajor</code> is the first integer and\n<code>message.httpVersionMinor</code> is the second.</p>"
+            },
             {
-              "textRaw": "Event: `'checkContinue'`",
-              "type": "event",
-              "name": "checkContinue",
+              "textRaw": "`method` {string}",
+              "type": "string",
+              "name": "method",
               "meta": {
                 "added": [
-                  "v0.3.0"
+                  "v0.1.1"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`request` {http.IncomingMessage}",
-                  "name": "request",
-                  "type": "http.IncomingMessage"
-                },
-                {
-                  "textRaw": "`response` {http.ServerResponse}",
-                  "name": "response",
-                  "type": "http.ServerResponse"
-                }
-              ],
-              "desc": "<p>Emitted each time a request with an HTTP <code>Expect: 100-continue</code> is received.\nIf this event is not listened for, the server will automatically respond\nwith a <code>100 Continue</code> as appropriate.</p>\n<p>Handling this event involves calling <a href=\"http.html#http_response_writecontinue\"><code>response.writeContinue()</code></a> if the\nclient should continue to send the request body, or generating an appropriate\nHTTP response (e.g. 400 Bad Request) if the client should not continue to send\nthe request body.</p>\n<p>When this event is emitted and handled, the <a href=\"http.html#http_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
+              "desc": "<p><strong>Only valid for request obtained from <a href=\"http.html#http_class_http_server\"><code>http.Server</code></a>.</strong></p>\n<p>The request method as a string. Read only. Examples: <code>'GET'</code>, <code>'DELETE'</code>.</p>"
             },
             {
-              "textRaw": "Event: `'checkExpectation'`",
-              "type": "event",
-              "name": "checkExpectation",
+              "textRaw": "`rawHeaders` {string[]}",
+              "type": "string[]",
+              "name": "rawHeaders",
               "meta": {
                 "added": [
-                  "v5.5.0"
+                  "v0.11.6"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`request` {http.IncomingMessage}",
-                  "name": "request",
-                  "type": "http.IncomingMessage"
-                },
-                {
-                  "textRaw": "`response` {http.ServerResponse}",
-                  "name": "response",
-                  "type": "http.ServerResponse"
-                }
-              ],
-              "desc": "<p>Emitted each time a request with an HTTP <code>Expect</code> header is received, where the\nvalue is not <code>100-continue</code>. If this event is not listened for, the server will\nautomatically respond with a <code>417 Expectation Failed</code> as appropriate.</p>\n<p>When this event is emitted and handled, the <a href=\"http.html#http_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
+              "desc": "<p>The raw request/response headers list exactly as they were received.</p>\n<p>The keys and values are in the same list. It is <em>not</em> a\nlist of tuples. So, the even-numbered offsets are key values, and the\nodd-numbered offsets are the associated values.</p>\n<p>Header names are not lowercased, and duplicates are not merged.</p>\n<pre><code class=\"language-js\">// Prints something like:\n//\n// [ 'user-agent',\n//   'this is invalid because there can be only one',\n//   'User-Agent',\n//   'curl/7.22.0',\n//   'Host',\n//   '127.0.0.1:8000',\n//   'ACCEPT',\n//   '*/*' ]\nconsole.log(request.rawHeaders);\n</code></pre>"
             },
             {
-              "textRaw": "Event: `'clientError'`",
-              "type": "event",
-              "name": "clientError",
+              "textRaw": "`rawTrailers` {string[]}",
+              "type": "string[]",
+              "name": "rawTrailers",
               "meta": {
                 "added": [
-                  "v0.1.94"
+                  "v0.11.6"
                 ],
-                "changes": [
-                  {
-                    "version": "v6.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/4557",
-                    "description": "The default action of calling `.destroy()` on the `socket` will no longer take place if there are listeners attached for `'clientError'`."
-                  },
-                  {
-                    "version": "v9.4.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/17672",
-                    "description": "The `rawPacket` is the current buffer that just parsed. Adding this buffer to the error object of `'clientError'` event is to make it possible that developers can log the broken packet."
-                  },
-                  {
-                    "version": "v12.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/25605",
-                    "description": "The default behavior will return a 431 Request Header Fields Too Large if a HPE_HEADER_OVERFLOW error occurs."
-                  }
-                ]
+                "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`exception` {Error}",
-                  "name": "exception",
-                  "type": "Error"
-                },
-                {
-                  "textRaw": "`socket` {stream.Duplex}",
-                  "name": "socket",
-                  "type": "stream.Duplex"
-                }
-              ],
-              "desc": "<p>If a client connection emits an <code>'error'</code> event, it will be forwarded here.\nListener of this event is responsible for closing/destroying the underlying\nsocket. For example, one may wish to more gracefully close the socket with a\ncustom HTTP response instead of abruptly severing the connection.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>Default behavior is to try close the socket with a HTTP '400 Bad Request',\nor a HTTP '431 Request Header Fields Too Large' in the case of a\n<a href=\"errors.html#errors_hpe_header_overflow\"><code>HPE_HEADER_OVERFLOW</code></a> error. If the socket is not writable or has already\nwritten data it is immediately destroyed.</p>\n<p><code>socket</code> is the <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> object that the error originated from.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst server = http.createServer((req, res) => {\n  res.end();\n});\nserver.on('clientError', (err, socket) => {\n  socket.end('HTTP/1.1 400 Bad Request\\r\\n\\r\\n');\n});\nserver.listen(8000);\n</code></pre>\n<p>When the <code>'clientError'</code> event occurs, there is no <code>request</code> or <code>response</code>\nobject, so any HTTP response sent, including response headers and payload,\n<em>must</em> be written directly to the <code>socket</code> object. Care must be taken to\nensure the response is a properly formatted HTTP response message.</p>\n<p><code>err</code> is an instance of <code>Error</code> with two extra columns:</p>\n<ul>\n<li><code>bytesParsed</code>: the bytes count of request packet that Node.js may have parsed\ncorrectly;</li>\n<li><code>rawPacket</code>: the raw packet of current request.</li>\n</ul>\n<p>In some cases, the client has already received the response and/or the socket\nhas already been destroyed, like in case of <code>ECONNRESET</code> errors. Before\ntrying to send data to the socket, it is better to check that it is still\nwritable.</p>\n<pre><code class=\"language-js\">server.on('clientError', (err, socket) => {\n  if (err.code === 'ECONNRESET' || !socket.writable) {\n    return;\n  }\n\n  socket.end('HTTP/1.1 400 Bad Request\\r\\n\\r\\n');\n});\n</code></pre>"
+              "desc": "<p>The raw request/response trailer keys and values exactly as they were\nreceived. Only populated at the <code>'end'</code> event.</p>"
             },
             {
-              "textRaw": "Event: `'close'`",
-              "type": "event",
-              "name": "close",
+              "textRaw": "`socket` {stream.Duplex}",
+              "type": "stream.Duplex",
+              "name": "socket",
               "meta": {
                 "added": [
-                  "v0.1.4"
+                  "v0.3.0"
                 ],
                 "changes": []
               },
-              "params": [],
-              "desc": "<p>Emitted when the server closes.</p>"
+              "desc": "<p>The <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> object associated with the connection.</p>\n<p>With HTTPS support, use <a href=\"tls.html#tls_tlssocket_getpeercertificate_detailed\"><code>request.socket.getPeerCertificate()</code></a> to obtain the\nclient's authentication details.</p>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
             },
             {
-              "textRaw": "Event: `'connect'`",
-              "type": "event",
-              "name": "connect",
+              "textRaw": "`statusCode` {number}",
+              "type": "number",
+              "name": "statusCode",
               "meta": {
                 "added": [
-                  "v0.7.0"
+                  "v0.1.1"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`request` {http.IncomingMessage} Arguments for the HTTP request, as it is in the [`'request'`][] event",
-                  "name": "request",
-                  "type": "http.IncomingMessage",
-                  "desc": "Arguments for the HTTP request, as it is in the [`'request'`][] event"
-                },
-                {
-                  "textRaw": "`socket` {stream.Duplex} Network socket between the server and client",
-                  "name": "socket",
-                  "type": "stream.Duplex",
-                  "desc": "Network socket between the server and client"
-                },
-                {
-                  "textRaw": "`head` {Buffer} The first packet of the tunneling stream (may be empty)",
-                  "name": "head",
-                  "type": "Buffer",
-                  "desc": "The first packet of the tunneling stream (may be empty)"
-                }
-              ],
-              "desc": "<p>Emitted each time a client requests an HTTP <code>CONNECT</code> method. If this event is\nnot listened for, then clients requesting a <code>CONNECT</code> method will have their\nconnections closed.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>After this event is emitted, the request's socket will not have a <code>'data'</code>\nevent listener, meaning it will need to be bound in order to handle data\nsent to the server on that socket.</p>"
+              "desc": "<p><strong>Only valid for response obtained from <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>.</strong></p>\n<p>The 3-digit HTTP response status code. E.G. <code>404</code>.</p>"
             },
             {
-              "textRaw": "Event: `'connection'`",
-              "type": "event",
-              "name": "connection",
+              "textRaw": "`statusMessage` {string}",
+              "type": "string",
+              "name": "statusMessage",
               "meta": {
                 "added": [
-                  "v0.1.0"
+                  "v0.11.10"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`socket` {stream.Duplex}",
-                  "name": "socket",
-                  "type": "stream.Duplex"
-                }
-              ],
-              "desc": "<p>This event is emitted when a new TCP stream is established. <code>socket</code> is\ntypically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>. Usually users will not want to\naccess this event. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. The <code>socket</code> can\nalso be accessed at <code>request.connection</code>.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>\n<p>If <code>socket.setTimeout()</code> is called here, the timeout will be replaced with\n<code>server.keepAliveTimeout</code> when the socket has served a request (if\n<code>server.keepAliveTimeout</code> is non-zero).</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "desc": "<p><strong>Only valid for response obtained from <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>.</strong></p>\n<p>The HTTP response status message (reason phrase). E.G. <code>OK</code> or <code>Internal Server Error</code>.</p>"
             },
             {
-              "textRaw": "Event: `'request'`",
-              "type": "event",
-              "name": "request",
+              "textRaw": "`trailers` {Object}",
+              "type": "Object",
+              "name": "trailers",
               "meta": {
                 "added": [
-                  "v0.1.0"
+                  "v0.3.0"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`request` {http.IncomingMessage}",
-                  "name": "request",
-                  "type": "http.IncomingMessage"
-                },
-                {
-                  "textRaw": "`response` {http.ServerResponse}",
-                  "name": "response",
-                  "type": "http.ServerResponse"
-                }
-              ],
-              "desc": "<p>Emitted each time there is a request. There may be multiple requests\nper connection (in the case of HTTP Keep-Alive connections).</p>"
+              "desc": "<p>The request/response trailers object. Only populated at the <code>'end'</code> event.</p>"
             },
             {
-              "textRaw": "Event: `'upgrade'`",
-              "type": "event",
-              "name": "upgrade",
+              "textRaw": "`url` {string}",
+              "type": "string",
+              "name": "url",
               "meta": {
                 "added": [
-                  "v0.1.94"
+                  "v0.1.90"
                 ],
-                "changes": [
-                  {
-                    "version": "v10.0.0",
-                    "pr-url": "v10.0.0",
-                    "description": "Not listening to this event no longer causes the socket to be destroyed if a client sends an Upgrade header."
-                  }
-                ]
+                "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`request` {http.IncomingMessage} Arguments for the HTTP request, as it is in the [`'request'`][] event",
-                  "name": "request",
-                  "type": "http.IncomingMessage",
-                  "desc": "Arguments for the HTTP request, as it is in the [`'request'`][] event"
-                },
-                {
-                  "textRaw": "`socket` {stream.Duplex} Network socket between the server and client",
-                  "name": "socket",
-                  "type": "stream.Duplex",
-                  "desc": "Network socket between the server and client"
-                },
-                {
-                  "textRaw": "`head` {Buffer} The first packet of the upgraded stream (may be empty)",
-                  "name": "head",
-                  "type": "Buffer",
-                  "desc": "The first packet of the upgraded stream (may be empty)"
-                }
-              ],
-              "desc": "<p>Emitted each time a client requests an HTTP upgrade. Listening to this event\nis optional and clients cannot insist on a protocol change.</p>\n<p>After this event is emitted, the request's socket will not have a <code>'data'</code>\nevent listener, meaning it will need to be bound in order to handle data\nsent to the server on that socket.</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "desc": "<p><strong>Only valid for request obtained from <a href=\"http.html#http_class_http_server\"><code>http.Server</code></a>.</strong></p>\n<p>Request URL string. This contains only the URL that is present in the actual\nHTTP request. Take the following request:</p>\n<pre><code class=\"language-http\">GET /status?name=ryan HTTP/1.1\nAccept: text/plain\n</code></pre>\n<p>To parse the URL into its parts:</p>\n<pre><code class=\"language-js\">new URL(request.url, `http://${request.headers.host}`);\n</code></pre>\n<p>When <code>request.url</code> is <code>'/status?name=ryan'</code> and\n<code>request.headers.host</code> is <code>'localhost:3000'</code>:</p>\n<pre><code class=\"language-console\">$ node\n> new URL(request.url, `http://${request.headers.host}`)\nURL {\n  href: 'http://localhost:3000/status?name=ryan',\n  origin: 'http://localhost:3000',\n  protocol: 'http:',\n  username: '',\n  password: '',\n  host: 'localhost:3000',\n  hostname: 'localhost',\n  port: '3000',\n  pathname: '/status',\n  search: '?name=ryan',\n  searchParams: URLSearchParams { 'name' => 'ryan' },\n  hash: ''\n}\n</code></pre>"
             }
           ],
           "methods": [
             {
-              "textRaw": "`server.close([callback])`",
+              "textRaw": "`message.destroy([error])`",
               "type": "method",
-              "name": "close",
+              "name": "destroy",
               "meta": {
                 "added": [
-                  "v0.1.90"
+                  "v0.3.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32789",
+                    "description": "The function returns `this` for consistency with other Readable streams."
+                  }
+                ]
               },
               "signatures": [
                 {
+                  "return": {
+                    "textRaw": "Returns: {this}",
+                    "name": "return",
+                    "type": "this"
+                  },
                   "params": [
                     {
-                      "textRaw": "`callback` {Function}",
-                      "name": "callback",
-                      "type": "Function"
+                      "textRaw": "`error` {Error}",
+                      "name": "error",
+                      "type": "Error"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Stops the server from accepting new connections. See <a href=\"net.html#net_server_close_callback\"><code>net.Server.close()</code></a>.</p>"
-            },
-            {
-              "textRaw": "`server.listen()`",
-              "type": "method",
-              "name": "listen",
-              "signatures": [
-                {
-                  "params": []
-                }
-              ],
-              "desc": "<p>Starts the HTTP server listening for connections.\nThis method is identical to <a href=\"net.html#net_server_listen\"><code>server.listen()</code></a> from <a href=\"net.html#net_class_net_server\"><code>net.Server</code></a>.</p>"
+              "desc": "<p>Calls <code>destroy()</code> on the socket that received the <code>IncomingMessage</code>. If <code>error</code>\nis provided, an <code>'error'</code> event is emitted on the socket and <code>error</code> is passed\nas an argument to any listeners on the event.</p>"
             },
             {
-              "textRaw": "`server.setTimeout([msecs][, callback])`",
+              "textRaw": "`message.setTimeout(msecs[, callback])`",
               "type": "method",
               "name": "setTimeout",
               "meta": {
                 "added": [
-                  "v0.9.12"
+                  "v0.5.9"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {http.Server}",
+                    "textRaw": "Returns: {http.IncomingMessage}",
                     "name": "return",
-                    "type": "http.Server"
+                    "type": "http.IncomingMessage"
                   },
                   "params": [
                     {
-                      "textRaw": "`msecs` {number} **Default:** `120000` (2 minutes)",
+                      "textRaw": "`msecs` {number}",
                       "name": "msecs",
-                      "type": "number",
-                      "default": "`120000` (2 minutes)"
+                      "type": "number"
                     },
                     {
                       "textRaw": "`callback` {Function}",
@@ -35578,120 +40051,65 @@
                   ]
                 }
               ],
-              "desc": "<p>Sets the timeout value for sockets, and emits a <code>'timeout'</code> event on\nthe Server object, passing the socket as an argument, if a timeout\noccurs.</p>\n<p>If there is a <code>'timeout'</code> event listener on the Server object, then it\nwill be called with the timed-out socket as an argument.</p>\n<p>By default, the Server's timeout value is 2 minutes, and sockets are\ndestroyed automatically if they time out. However, if a callback is assigned\nto the Server's <code>'timeout'</code> event, timeouts must be handled explicitly.</p>\n<p>To change the default timeout use the <a href=\"cli.html#cli_http_server_default_timeout_milliseconds\"><code>--http-server-default-timeout</code></a>\nflag.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`headersTimeout` {number} **Default:** `60000`",
-              "type": "number",
-              "name": "headersTimeout",
-              "meta": {
-                "added": [
-                  "v11.3.0"
-                ],
-                "changes": []
-              },
-              "default": "`60000`",
-              "desc": "<p>Limit the amount of time the parser will wait to receive the complete HTTP\nheaders.</p>\n<p>In case of inactivity, the rules defined in <a href=\"http.html#http_server_timeout\"><code>server.timeout</code></a> apply. However,\nthat inactivity based timeout would still allow the connection to be kept open\nif the headers are being sent very slowly (by default, up to a byte per 2\nminutes). In order to prevent this, whenever header data arrives an additional\ncheck is made that more than <code>server.headersTimeout</code> milliseconds has not\npassed since the connection was established. If the check fails, a <code>'timeout'</code>\nevent is emitted on the server object, and (by default) the socket is destroyed.\nSee <a href=\"http.html#http_server_timeout\"><code>server.timeout</code></a> for more information on how timeout behavior can be\ncustomized.</p>\n<p>A value of <code>0</code> will disable the HTTP headers timeout check.</p>"
-            },
-            {
-              "textRaw": "`listening` {boolean} Indicates whether or not the server is listening for connections.",
-              "type": "boolean",
-              "name": "listening",
-              "meta": {
-                "added": [
-                  "v5.7.0"
-                ],
-                "changes": []
-              },
-              "desc": "Indicates whether or not the server is listening for connections."
-            },
-            {
-              "textRaw": "`maxHeadersCount` {number} **Default:** `2000`",
-              "type": "number",
-              "name": "maxHeadersCount",
-              "meta": {
-                "added": [
-                  "v0.7.0"
-                ],
-                "changes": []
-              },
-              "default": "`2000`",
-              "desc": "<p>Limits maximum incoming headers count. If set to 0, no limit will be applied.</p>"
-            },
-            {
-              "textRaw": "`timeout` {number} Timeout in milliseconds. **Default:** `120000` (2 minutes).",
-              "type": "number",
-              "name": "timeout",
-              "meta": {
-                "added": [
-                  "v0.9.12"
-                ],
-                "changes": []
-              },
-              "default": "`120000` (2 minutes)",
-              "desc": "<p>The number of milliseconds of inactivity before a socket is presumed\nto have timed out.</p>\n<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>\n<p>The socket timeout logic is set up on connection, so changing this\nvalue only affects new connections to the server, not any existing connections.</p>\n<p>To change the default timeout use the <a href=\"cli.html#cli_http_server_default_timeout_milliseconds\"><code>--http-server-default-timeout</code></a>\nflag.</p>",
-              "shortDesc": "Timeout in milliseconds."
-            },
-            {
-              "textRaw": "`keepAliveTimeout` {number} Timeout in milliseconds. **Default:** `5000` (5 seconds).",
-              "type": "number",
-              "name": "keepAliveTimeout",
-              "meta": {
-                "added": [
-                  "v8.0.0"
-                ],
-                "changes": []
-              },
-              "default": "`5000` (5 seconds)",
-              "desc": "<p>The number of milliseconds of inactivity a server needs to wait for additional\nincoming data, after it has finished writing the last response, before a socket\nwill be destroyed. If the server receives new data before the keep-alive\ntimeout has fired, it will reset the regular inactivity timeout, i.e.,\n<a href=\"http.html#http_server_timeout\"><code>server.timeout</code></a>.</p>\n<p>A value of <code>0</code> will disable the keep-alive timeout behavior on incoming\nconnections.\nA value of <code>0</code> makes the http server behave similarly to Node.js versions prior\nto 8.0.0, which did not have a keep-alive timeout.</p>\n<p>The socket timeout logic is set up on connection, so changing this value only\naffects new connections to the server, not any existing connections.</p>",
-              "shortDesc": "Timeout in milliseconds."
+              "desc": "<p>Calls <code>message.socket.setTimeout(msecs, callback)</code>.</p>"
             }
           ]
         },
         {
-          "textRaw": "Class: `http.ServerResponse`",
+          "textRaw": "Class: `http.OutgoingMessage`",
           "type": "class",
-          "name": "http.ServerResponse",
+          "name": "http.OutgoingMessage",
           "meta": {
             "added": [
               "v0.1.17"
             ],
             "changes": []
           },
-          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a></li>\n</ul>\n<p>This object is created internally by an HTTP server, not by the user. It is\npassed as the second parameter to the <a href=\"http.html#http_event_request\"><code>'request'</code></a> event.</p>",
+          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a></li>\n</ul>\n<p>This class serves as the parent class of <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nand <a href=\"http.html#http_class_http_serverresponse\"><code>http.ServerResponse</code></a>. It is an abstract of outgoing message from\nthe perspective of the participants of HTTP transaction.</p>",
           "events": [
             {
-              "textRaw": "Event: `'close'`",
+              "textRaw": "Event: `drain`",
               "type": "event",
-              "name": "close",
+              "name": "drain`",
               "meta": {
                 "added": [
-                  "v0.6.7"
+                  "v0.3.6"
                 ],
                 "changes": []
               },
               "params": [],
-              "desc": "<p>Indicates that the the response is completed, or its underlying connection was\nterminated prematurely (before the response completion).</p>"
+              "desc": "<p>Emitted when the buffer of the message is free again.</p>"
             },
             {
-              "textRaw": "Event: `'finish'`",
+              "textRaw": "Event: `finish`",
               "type": "event",
-              "name": "finish",
+              "name": "finish`",
               "meta": {
                 "added": [
-                  "v0.3.6"
+                  "v0.1.17"
                 ],
                 "changes": []
               },
               "params": [],
-              "desc": "<p>Emitted when the response has been sent. More specifically, this event is\nemitted when the last segment of the response headers and body have been\nhanded off to the operating system for transmission over the network. It\ndoes not imply that the client has received anything yet.</p>"
+              "desc": "<p>Emitted when the transmission is finished successfully.</p>"
+            },
+            {
+              "textRaw": "Event: `prefinish`",
+              "type": "event",
+              "name": "prefinish`",
+              "meta": {
+                "added": [
+                  "v0.11.6"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>Emitted when <code>outgoingMessage.end</code> was called.\nWhen the event is emitted, all data has been processed but not necessarily\ncompletely flushed.</p>"
             }
           ],
           "methods": [
             {
-              "textRaw": "`response.addTrailers(headers)`",
+              "textRaw": "`outgoingMessage.addTrailers(headers)`",
               "type": "method",
               "name": "addTrailers",
               "meta": {
@@ -35711,15 +40129,15 @@
                   ]
                 }
               ],
-              "desc": "<p>This method adds HTTP trailing headers (a header but at the end of the\nmessage) to the response.</p>\n<p>Trailers will <strong>only</strong> be emitted if chunked encoding is used for the\nresponse; if it is not (e.g. if the request was HTTP/1.0), they will\nbe silently discarded.</p>\n<p>HTTP requires the <code>Trailer</code> header to be sent in order to\nemit trailers, with a list of the header fields in its value. E.g.,</p>\n<pre><code class=\"language-js\">response.writeHead(200, { 'Content-Type': 'text/plain',\n                          'Trailer': 'Content-MD5' });\nresponse.write(fileData);\nresponse.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' });\nresponse.end();\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
+              "desc": "<p>Adds HTTP trailers (headers but at the end of the message) to the message.</p>\n<p>Trailers are <strong>only</strong> be emitted if the message is chunked encoded. If not,\nthe trailer will be silently discarded.</p>\n<p>HTTP requires the  <code>Trailer</code> header to be sent to emit trailers,\nwith a list of header fields in its value, e.g.</p>\n<pre><code class=\"language-js\">message.writeHead(200, { 'Content-Type': 'text/plain',\n                         'Trailer': 'Content-MD5' });\nmessage.write(fileData);\nmessage.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' });\nmessage.end();\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <code>TypeError</code> being thrown.</p>"
             },
             {
-              "textRaw": "`response.cork()`",
+              "textRaw": "`outgoingMessage.cork()`",
               "type": "method",
               "name": "cork",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v14.0.0"
                 ],
                 "changes": []
               },
@@ -35731,7 +40149,36 @@
               "desc": "<p>See <a href=\"stream.html#stream_writable_cork\"><code>writable.cork()</code></a>.</p>"
             },
             {
-              "textRaw": "`response.end([data[, encoding]][, callback])`",
+              "textRaw": "`outgoingMessage.destroy([error])`",
+              "type": "method",
+              "name": "destroy",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {this}",
+                    "name": "return",
+                    "type": "this"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`error` {Error} Optional, an error to emit with `error` event",
+                      "name": "error",
+                      "type": "Error",
+                      "desc": "Optional, an error to emit with `error` event"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Destroys the message. Once a socket is associated with the message\nand is connected, that socket will be destroyed as well.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.end(chunk[, encoding][, callback])`",
               "type": "method",
               "name": "end",
               "meta": {
@@ -35740,9 +40187,8 @@
                 ],
                 "changes": [
                   {
-                    "version": "v10.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/18780",
-                    "description": "This method now returns a reference to `ServerResponse`."
+                    "version": "v0.11.6",
+                    "description": "add `callback` argument."
                   }
                 ]
               },
@@ -35755,27 +40201,29 @@
                   },
                   "params": [
                     {
-                      "textRaw": "`data` {string|Buffer}",
-                      "name": "data",
-                      "type": "string|Buffer"
+                      "textRaw": "`chunk` {string | Buffer}",
+                      "name": "chunk",
+                      "type": "string | Buffer"
                     },
                     {
-                      "textRaw": "`encoding` {string}",
+                      "textRaw": "`encoding` {string} Optional, **Default**: `utf-8`",
                       "name": "encoding",
-                      "type": "string"
+                      "type": "string",
+                      "desc": "Optional, **Default**: `utf-8`"
                     },
                     {
-                      "textRaw": "`callback` {Function}",
+                      "textRaw": "`callback` {Function} Optional",
                       "name": "callback",
-                      "type": "Function"
+                      "type": "Function",
+                      "desc": "Optional"
                     }
                   ]
                 }
               ],
-              "desc": "<p>This method signals to the server that all of the response headers and body\nhave been sent; that server should consider this message complete.\nThe method, <code>response.end()</code>, MUST be called on each response.</p>\n<p>If <code>data</code> is specified, it is similar in effect to calling\n<a href=\"http.html#http_response_write_chunk_encoding_callback\"><code>response.write(data, encoding)</code></a> followed by <code>response.end(callback)</code>.</p>\n<p>If <code>callback</code> is specified, it will be called when the response stream\nis finished.</p>"
+              "desc": "<p>Finishes the outgoing message. If any parts of the body are unsent, it will\nflush them to the underlying system. If the message is chunked, it will\nsend the terminating chunk <code>0\\r\\n\\r\\n</code>, and send the trailer (if any).</p>\n<p>If <code>chunk</code> is specified, it is equivalent to call\n<code>outgoingMessage.write(chunk, encoding)</code>, followed by\n<code>outgoingMessage.end(callback)</code>.</p>\n<p>If <code>callback</code> is provided, it will be called when the message is finished.\n(equivalent to the callback to event <code>finish</code>)</p>"
             },
             {
-              "textRaw": "`response.flushHeaders()`",
+              "textRaw": "`outgoingMessage.flushHeaders()`",
               "type": "method",
               "name": "flushHeaders",
               "meta": {
@@ -35789,10 +40237,10 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Flushes the response headers. See also: <a href=\"http.html#http_request_flushheaders\"><code>request.flushHeaders()</code></a>.</p>"
+              "desc": "<p>Compulsorily flushes the message headers</p>\n<p>For efficiency reason, Node.js normally buffers the message headers\nuntil <code>outgoingMessage.end()</code> is called or the first chunk of message data\nis written. It then tries to pack the headers and data into a single TCP\npacket.</p>\n<p>It is usually desired (it saves a TCP round-trip), but not when the first\ndata is not sent until possibly much later. <code>outgoingMessage.flushHeaders()</code>\nbypasses the optimization and kickstarts the request.</p>"
             },
             {
-              "textRaw": "`response.getHeader(name)`",
+              "textRaw": "`outgoingMessage.getHeader(name)`",
               "type": "method",
               "name": "getHeader",
               "meta": {
@@ -35804,50 +40252,51 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {any}",
+                    "textRaw": "Returns {string | undefined}",
                     "name": "return",
-                    "type": "any"
+                    "type": "string | undefined"
                   },
                   "params": [
                     {
-                      "textRaw": "`name` {string}",
+                      "textRaw": "`name` {string} Name of header",
                       "name": "name",
-                      "type": "string"
+                      "type": "string",
+                      "desc": "Name of header"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Reads out a header that's already been queued but not sent to the client.\nThe name is case-insensitive. The type of the return value depends\non the arguments provided to <a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a>.</p>\n<pre><code class=\"language-js\">response.setHeader('Content-Type', 'text/html');\nresponse.setHeader('Content-Length', Buffer.byteLength(body));\nresponse.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);\nconst contentType = response.getHeader('content-type');\n// contentType is 'text/html'\nconst contentLength = response.getHeader('Content-Length');\n// contentLength is of type number\nconst setCookie = response.getHeader('set-cookie');\n// setCookie is of type string[]\n</code></pre>"
+              "desc": "<p>Gets the value of HTTP header with the given name. If such a name doesn't\nexist in message, it will be <code>undefined</code>.</p>"
             },
             {
-              "textRaw": "`response.getHeaderNames()`",
+              "textRaw": "`outgoingMessage.getHeaderNames()`",
               "type": "method",
               "name": "getHeaderNames",
               "meta": {
                 "added": [
-                  "v7.7.0"
+                  "v8.0.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {string[]}",
+                    "textRaw": "Returns {string[]}",
                     "name": "return",
                     "type": "string[]"
                   },
                   "params": []
                 }
               ],
-              "desc": "<p>Returns an array containing the unique names of the current outgoing headers.\nAll header names are lowercase.</p>\n<pre><code class=\"language-js\">response.setHeader('Foo', 'bar');\nresponse.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);\n\nconst headerNames = response.getHeaderNames();\n// headerNames === ['foo', 'set-cookie']\n</code></pre>"
+              "desc": "<p>Returns an array of names of headers of the outgoing outgoingMessage. All\nnames are lowercase.</p>"
             },
             {
-              "textRaw": "`response.getHeaders()`",
+              "textRaw": "`outgoingMessage.getHeaders()`",
               "type": "method",
               "name": "getHeaders",
               "meta": {
                 "added": [
-                  "v7.7.0"
+                  "v8.0.0"
                 ],
                 "changes": []
               },
@@ -35861,22 +40310,22 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns a shallow copy of the current outgoing headers. Since a shallow copy\nis used, array values may be mutated without additional calls to various\nheader-related http module methods. The keys of the returned object are the\nheader names and the values are the respective header values. All header names\nare lowercase.</p>\n<p>The object returned by the <code>response.getHeaders()</code> method <em>does not</em>\nprototypically inherit from the JavaScript <code>Object</code>. This means that typical\n<code>Object</code> methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>, and others\nare not defined and <em>will not work</em>.</p>\n<pre><code class=\"language-js\">response.setHeader('Foo', 'bar');\nresponse.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);\n\nconst headers = response.getHeaders();\n// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }\n</code></pre>"
+              "desc": "<p>Returns a shallow copy of the current outgoing headers. Since a shallow\ncopy is used, array values may be mutated without additional calls to\nvarious header-related HTTP module methods. The keys of the returned\nobject are the header names and the values are the respective header\nvalues. All header names are lowercase.</p>\n<p>The object returned by the <code>outgoingMessage.getHeaders()</code> method does\nnot prototypically inherit from the JavaScript Object. This means that\ntypical Object methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>,\nand others are not defined and will not work.</p>\n<pre><code class=\"language-js\">outgoingMessage.setHeader('Foo', 'bar');\noutgoingMessage.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);\n\nconst headers = outgoingMessage.getHeaders();\n// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }\n</code></pre>"
             },
             {
-              "textRaw": "`response.hasHeader(name)`",
+              "textRaw": "`outgoingMessage.hasHeader(name)`",
               "type": "method",
               "name": "hasHeader",
               "meta": {
                 "added": [
-                  "v7.7.0"
+                  "v8.0.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {boolean}",
+                    "textRaw": "Returns {boolean}",
                     "name": "return",
                     "type": "boolean"
                   },
@@ -35889,99 +40338,32 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the\noutgoing headers. The header name matching is case-insensitive.</p>\n<pre><code class=\"language-js\">const hasContentType = response.hasHeader('content-type');\n</code></pre>"
-            },
-            {
-              "textRaw": "`response.removeHeader(name)`",
-              "type": "method",
-              "name": "removeHeader",
-              "meta": {
-                "added": [
-                  "v0.4.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "params": [
-                    {
-                      "textRaw": "`name` {string}",
-                      "name": "name",
-                      "type": "string"
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p>Removes a header that's queued for implicit sending.</p>\n<pre><code class=\"language-js\">response.removeHeader('Content-Encoding');\n</code></pre>"
-            },
-            {
-              "textRaw": "`response.setHeader(name, value)`",
-              "type": "method",
-              "name": "setHeader",
-              "meta": {
-                "added": [
-                  "v0.4.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "params": [
-                    {
-                      "textRaw": "`name` {string}",
-                      "name": "name",
-                      "type": "string"
-                    },
-                    {
-                      "textRaw": "`value` {any}",
-                      "name": "value",
-                      "type": "any"
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p>Sets a single header value for implicit headers. If this header already exists\nin the to-be-sent headers, its value will be replaced. Use an array of strings\nhere to send multiple headers with the same name. Non-string values will be\nstored without modification. Therefore, <a href=\"http.html#http_response_getheader_name\"><code>response.getHeader()</code></a> may return\nnon-string values. However, the non-string values will be converted to strings\nfor network transmission.</p>\n<pre><code class=\"language-js\">response.setHeader('Content-Type', 'text/html');\n</code></pre>\n<p>or</p>\n<pre><code class=\"language-js\">response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>\n<p>When headers have been set with <a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('ok');\n});\n</code></pre>\n<p>If <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> method is called and this method has not been\ncalled, it will directly write the supplied header values onto the network\nchannel without caching internally, and the <a href=\"http.html#http_response_getheader_name\"><code>response.getHeader()</code></a> on the\nheader will not yield the expected result. If progressive population of headers\nis desired with potential future retrieval and modification, use\n<a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a> instead of <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>.</p>"
+              "desc": "<p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the\noutgoing headers. The header name is case-insensitive.</p>\n<pre><code class=\"language-js\">const hasContentType = outgoingMessage.hasHeader('content-type');\n</code></pre>"
             },
             {
-              "textRaw": "`response.setTimeout(msecs[, callback])`",
+              "textRaw": "`outgoingMessage.pipe()`",
               "type": "method",
-              "name": "setTimeout",
+              "name": "pipe",
               "meta": {
                 "added": [
-                  "v0.9.12"
+                  "v9.0.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {http.ServerResponse}",
-                    "name": "return",
-                    "type": "http.ServerResponse"
-                  },
-                  "params": [
-                    {
-                      "textRaw": "`msecs` {number}",
-                      "name": "msecs",
-                      "type": "number"
-                    },
-                    {
-                      "textRaw": "`callback` {Function}",
-                      "name": "callback",
-                      "type": "Function"
-                    }
-                  ]
+                  "params": []
                 }
               ],
-              "desc": "<p>Sets the Socket's timeout value to <code>msecs</code>. If a callback is\nprovided, then it is added as a listener on the <code>'timeout'</code> event on\nthe response object.</p>\n<p>If no <code>'timeout'</code> listener is added to the request, the response, or\nthe server, then sockets are destroyed when they time out. If a handler is\nassigned to the request, the response, or the server's <code>'timeout'</code> events,\ntimed out sockets must be handled explicitly.</p>"
+              "desc": "<p>Overrides the pipe method of legacy <code>Stream</code> which is the parent class of\n<code>http.outgoingMessage</code>.</p>\n<p>Since <code>OutgoingMessage</code> should be a write-only stream,\ncall this function will throw an <code>Error</code>. Thus, it disabled the pipe method\nit inherits from <code>Stream</code>.</p>\n<p>The User should not call this function directly.</p>"
             },
             {
-              "textRaw": "`response.uncork()`",
+              "textRaw": "`outgoingMessage.removeHeader()`",
               "type": "method",
-              "name": "uncork",
+              "name": "removeHeader",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v0.4.0"
                 ],
                 "changes": []
               },
@@ -35990,54 +40372,79 @@
                   "params": []
                 }
               ],
-              "desc": "<p>See <a href=\"stream.html#stream_writable_uncork\"><code>writable.uncork()</code></a>.</p>"
+              "desc": "<p>Removes a header that is queued for implicit sending.</p>\n<pre><code class=\"language-js\">outgoingMessage.removeHeader('Content-Encoding');\n</code></pre>"
             },
             {
-              "textRaw": "`response.write(chunk[, encoding][, callback])`",
+              "textRaw": "`outgoingMessage.setHeader(name, value)`",
               "type": "method",
-              "name": "write",
+              "name": "setHeader",
               "meta": {
                 "added": [
-                  "v0.1.29"
+                  "v0.4.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {boolean}",
+                    "textRaw": "Returns: {this}",
                     "name": "return",
-                    "type": "boolean"
+                    "type": "this"
                   },
                   "params": [
                     {
-                      "textRaw": "`chunk` {string|Buffer}",
-                      "name": "chunk",
-                      "type": "string|Buffer"
+                      "textRaw": "`name` {string} Header name",
+                      "name": "name",
+                      "type": "string",
+                      "desc": "Header name"
                     },
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
+                      "textRaw": "`value` {string} Header value",
+                      "name": "value",
                       "type": "string",
-                      "default": "`'utf8'`"
+                      "desc": "Header value"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Sets a single header value for the header object.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.setTimeout(msesc[, callback])`",
+              "type": "method",
+              "name": "setTimeout",
+              "meta": {
+                "added": [
+                  "v0.9.12"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`msesc` {number}",
+                      "name": "msesc",
+                      "type": "number"
                     },
                     {
-                      "textRaw": "`callback` {Function}",
+                      "textRaw": "`callback` {Function} Optional function to be called when a timeout",
                       "name": "callback",
-                      "type": "Function"
+                      "type": "Function",
+                      "desc": "Optional function to be called when a timeout"
                     }
                   ]
                 }
               ],
-              "desc": "<p>If this method is called and <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> has not been called,\nit will switch to implicit header mode and flush the implicit headers.</p>\n<p>This sends a chunk of the response body. This method may\nbe called multiple times to provide successive parts of the body.</p>\n<p>In the <code>http</code> module, the response body is omitted when the\nrequest is a HEAD request. Similarly, the <code>204</code> and <code>304</code> responses\n<em>must not</em> include a message body.</p>\n<p><code>chunk</code> can be a string or a buffer. If <code>chunk</code> is a string,\nthe second parameter specifies how to encode it into a byte stream.\n<code>callback</code> will be called when this chunk of data is flushed.</p>\n<p>This is the raw HTTP body and has nothing to do with higher-level multi-part\nbody encodings that may be used.</p>\n<p>The first time <a href=\"http.html#http_response_write_chunk_encoding_callback\"><code>response.write()</code></a> is called, it will send the buffered\nheader information and the first chunk of the body to the client. The second\ntime <a href=\"http.html#http_response_write_chunk_encoding_callback\"><code>response.write()</code></a> is called, Node.js assumes data will be streamed,\nand sends the new data separately. That is, the response is buffered up to the\nfirst chunk of the body.</p>\n<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel\nbuffer. Returns <code>false</code> if all or part of the data was queued in user memory.\n<code>'drain'</code> will be emitted when the buffer is free again.</p>"
+              "desc": "<p>occurs, Same as binding to the <code>timeout</code> event.</p>\n<ul>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this\" class=\"type\">&lt;this&gt;</a></li>\n</ul>\n<p>Once a socket is associated with the message and is connected,\n<a href=\"net.html#net_socket_settimeout_timeout_callback\"><code>socket.setTimeout()</code></a> will be called with <code>msecs</code> as the first parameter.</p>"
             },
             {
-              "textRaw": "`response.writeContinue()`",
+              "textRaw": "`outgoingMessage.uncork()`",
               "type": "method",
-              "name": "writeContinue",
+              "name": "uncork",
               "meta": {
                 "added": [
-                  "v0.3.0"
+                  "v14.0.0"
                 ],
                 "changes": []
               },
@@ -36046,104 +40453,69 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Sends a HTTP/1.1 100 Continue message to the client, indicating that\nthe request body should be sent. See the <a href=\"http.html#http_event_checkcontinue\"><code>'checkContinue'</code></a> event on\n<code>Server</code>.</p>"
+              "desc": "<p>See <a href=\"stream.html#stream_writable_uncork\"><code>writable.uncork()</code></a></p>"
             },
             {
-              "textRaw": "`response.writeHead(statusCode[, statusMessage][, headers])`",
+              "textRaw": "`outgoingMessage.write(chunk[, encoding][, callback])`",
               "type": "method",
-              "name": "writeHead",
+              "name": "write",
               "meta": {
                 "added": [
-                  "v0.1.30"
+                  "v0.1.29"
                 ],
                 "changes": [
                   {
-                    "version": "v11.10.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/25974",
-                    "description": "Return `this` from `writeHead()` to allow chaining with `end()`."
-                  },
-                  {
-                    "version": "v5.11.0, v4.4.5",
-                    "pr-url": "https://github.com/nodejs/node/pull/6291",
-                    "description": "A `RangeError` is thrown if `statusCode` is not a number in the range `[100, 999]`."
+                    "version": "v0.11.6",
+                    "description": "add `callback` argument."
                   }
                 ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {http.ServerResponse}",
+                    "textRaw": "Returns {boolean}",
                     "name": "return",
-                    "type": "http.ServerResponse"
+                    "type": "boolean"
                   },
                   "params": [
                     {
-                      "textRaw": "`statusCode` {number}",
-                      "name": "statusCode",
-                      "type": "number"
+                      "textRaw": "`chunk` {string | Buffer}",
+                      "name": "chunk",
+                      "type": "string | Buffer"
                     },
                     {
-                      "textRaw": "`statusMessage` {string}",
-                      "name": "statusMessage",
-                      "type": "string"
+                      "textRaw": "`encoding` {string} **Default**: `utf-8`",
+                      "name": "encoding",
+                      "type": "string",
+                      "desc": "**Default**: `utf-8`"
                     },
                     {
-                      "textRaw": "`headers` {Object}",
-                      "name": "headers",
-                      "type": "Object"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Sends a response header to the request. The status code is a 3-digit HTTP\nstatus code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.\nOptionally one can give a human-readable <code>statusMessage</code> as the second\nargument.</p>\n<p>Returns a reference to the <code>ServerResponse</code>, so that calls can be chained.</p>\n<pre><code class=\"language-js\">const body = 'hello world';\nresponse\n  .writeHead(200, {\n    'Content-Length': Buffer.byteLength(body),\n    'Content-Type': 'text/plain'\n  })\n  .end(body);\n</code></pre>\n<p>This method must only be called once on a message and it must\nbe called before <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> is called.</p>\n<p>If <a href=\"http.html#http_response_write_chunk_encoding_callback\"><code>response.write()</code></a> or <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> are called before calling\nthis, the implicit/mutable headers will be calculated and call this function.</p>\n<p>When headers have been set with <a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<p>If this method is called and <a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a> has not been called,\nit will directly write the supplied header values onto the network channel\nwithout caching internally, and the <a href=\"http.html#http_response_getheader_name\"><code>response.getHeader()</code></a> on the header\nwill not yield the expected result. If progressive population of headers is\ndesired with potential future retrieval and modification, use\n<a href=\"http.html#http_response_setheader_name_value\"><code>response.setHeader()</code></a> instead.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('ok');\n});\n</code></pre>\n<p><code>Content-Length</code> is given in bytes, not characters. Use\n<a href=\"buffer.html#buffer_static_method_buffer_bytelength_string_encoding\"><code>Buffer.byteLength()</code></a> to determine the length of the body in bytes. Node.js\ndoes not check whether <code>Content-Length</code> and the length of the body which has\nbeen transmitted are equal or not.</p>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
-            },
-            {
-              "textRaw": "`response.writeProcessing()`",
-              "type": "method",
-              "name": "writeProcessing",
-              "meta": {
-                "added": [
-                  "v10.0.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "params": []
-                }
-              ],
-              "desc": "<p>Sends a HTTP/1.1 102 Processing message to the client, indicating that\nthe request body should be sent.</p>"
+              "desc": "<p>If this method is called and the header is not sent, it will call\n<code>this._implicitHeader</code> to flush implicit header.\nIf the message should not have a body (indicated by <code>this._hasBody</code>),\nthe call is ignored and <code>chunk</code> will not be sent. It could be useful\nwhen handling a particular message which must not include a body.\ne.g. response to <code>HEAD</code> request, <code>204</code> and <code>304</code> response.</p>\n<p><code>chunk</code> can be a string or a buffer. When <code>chunk</code> is a string, the\n<code>encoding</code> parameter specifies how to encode <code>chunk</code> into a byte stream.\n<code>callback</code> will be called when the <code>chunk</code> is flushed.</p>\n<p>If the message is transferred in chucked encoding\n(indicated by <code>this.chunkedEncoding</code>), <code>chunk</code> will be flushed as\none chunk among a stream of chunks. Otherwise, it will be flushed as the\nbody of message.</p>\n<p>This method handles the raw body of the HTTP message and has nothing to do\nwith higher-level multi-part body encodings that may be used.</p>\n<p>If it is the first call to this method of a message, it will send the\nbuffered header first, then flush the <code>chunk</code> as described above.</p>\n<p>The second and successive calls to this method will assume the data\nwill be streamed and send the new data separately. It means that the response\nis buffered up to the first chunk of the body.</p>\n<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel\nbuffer. Returns <code>false</code> if all or part of the data was queued in the user\nmemory. Event <code>drain</code> will be emitted when the buffer is free again.</p>"
             }
           ],
           "properties": [
             {
-              "textRaw": "`connection` {stream.Duplex}",
-              "type": "stream.Duplex",
+              "textRaw": "`outgoingMessage.connection`",
               "name": "connection",
               "meta": {
                 "added": [
                   "v0.3.0"
                 ],
-                "changes": []
-              },
-              "desc": "<p>See <a href=\"http.html#http_response_socket\"><code>response.socket</code></a>.</p>"
-            },
-            {
-              "textRaw": "`finished` {boolean}",
-              "type": "boolean",
-              "name": "finished",
-              "meta": {
-                "added": [
-                  "v0.0.2"
-                ],
                 "deprecated": [
-                  "v12.16.0"
+                  "v14.17.1"
                 ],
                 "changes": []
               },
               "stability": 0,
-              "stabilityText": "Deprecated. Use [`response.writableEnded`][].",
-              "desc": "<p>The <code>response.finished</code> property will be <code>true</code> if <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a>\nhas been called.</p>"
+              "stabilityText": "Deprecated: Use [`outgoingMessage.socket`][] instead.",
+              "desc": "<p>Aliases of <code>outgoingMessage.socket</code></p>"
             },
             {
               "textRaw": "`headersSent` {boolean}",
@@ -36155,19 +40527,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Boolean (read-only). True if headers were sent, false otherwise.</p>"
-            },
-            {
-              "textRaw": "`sendDate` {boolean}",
-              "type": "boolean",
-              "name": "sendDate",
-              "meta": {
-                "added": [
-                  "v0.7.5"
-                ],
-                "changes": []
-              },
-              "desc": "<p>When true, the Date header will be automatically generated and sent in\nthe response if it is not already present in the headers. Defaults to true.</p>\n<p>This should only be disabled for testing; HTTP requires the Date header\nin responses.</p>"
+              "desc": "<p>Read-only. <code>true</code> if the headers were sent, otherwise <code>false</code>.</p>"
             },
             {
               "textRaw": "`socket` {stream.Duplex}",
@@ -36179,32 +40539,19 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Reference to the underlying socket. Usually users will not want to access\nthis property. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. After\n<code>response.end()</code>, the property is nulled. The <code>socket</code> may also be accessed\nvia <code>response.connection</code>.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst server = http.createServer((req, res) => {\n  const ip = res.socket.remoteAddress;\n  const port = res.socket.remotePort;\n  res.end(`Your IP address is ${ip} and your source port is ${port}.`);\n}).listen(3000);\n</code></pre>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "desc": "<p>Reference to the underlying socket. Usually, users will not want to access\nthis property.</p>\n<p>After calling <code>outgoingMessage.end()</code>, this property will be nulled.</p>"
             },
             {
-              "textRaw": "`statusCode` {number} **Default:** `200`",
+              "textRaw": "`writableCorked` {number}",
               "type": "number",
-              "name": "statusCode",
-              "meta": {
-                "added": [
-                  "v0.4.0"
-                ],
-                "changes": []
-              },
-              "default": "`200`",
-              "desc": "<p>When using implicit headers (not calling <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> explicitly),\nthis property controls the status code that will be sent to the client when\nthe headers get flushed.</p>\n<pre><code class=\"language-js\">response.statusCode = 404;\n</code></pre>\n<p>After response header was sent to the client, this property indicates the\nstatus code which was sent out.</p>"
-            },
-            {
-              "textRaw": "`statusMessage` {string}",
-              "type": "string",
-              "name": "statusMessage",
+              "name": "writableCorked",
               "meta": {
                 "added": [
-                  "v0.11.8"
+                  "v14.0.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>When using implicit headers (not calling <a href=\"http.html#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> explicitly),\nthis property controls the status message that will be sent to the client when\nthe headers get flushed. If this is left as <code>undefined</code> then the standard\nmessage for the status code will be used.</p>\n<pre><code class=\"language-js\">response.statusMessage = 'Not found';\n</code></pre>\n<p>After response header was sent to the client, this property indicates the\nstatus message which was sent out.</p>"
+              "desc": "<p>This <code>outgoingMessage.writableCorked</code> will return the time how many\n<code>outgoingMessage.cork()</code> have been called.</p>"
             },
             {
               "textRaw": "`writableEnded` {boolean}",
@@ -36212,11 +40559,11 @@
               "name": "writableEnded",
               "meta": {
                 "added": [
-                  "v12.9.0"
+                  "v13.0.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>Is <code>true</code> after <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> has been called. This property\ndoes not indicate whether the data has been flushed, for this use\n<a href=\"http.html#http_response_writablefinished\"><code>response.writableFinished</code></a> instead.</p>"
+              "desc": "<p>Readonly, <code>true</code> if <code>outgoingMessage.end()</code> has been called. Noted that\nthis property does not reflect whether the data has been flush. For that\npurpose, use <code>message.writableFinished</code> instead.</p>"
             },
             {
               "textRaw": "`writableFinished` {boolean}",
@@ -36224,272 +40571,47 @@
               "name": "writableFinished",
               "meta": {
                 "added": [
-                  "v12.7.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>Is <code>true</code> if all data has been flushed to the underlying system, immediately\nbefore the <a href=\"http.html#http_event_finish\"><code>'finish'</code></a> event is emitted.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `http.IncomingMessage`",
-          "type": "class",
-          "name": "http.IncomingMessage",
-          "meta": {
-            "added": [
-              "v0.1.17"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30135",
-                "description": "The `readableHighWaterMark` value mirrors that of the socket."
-              }
-            ]
-          },
-          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_readable\" class=\"type\">&lt;stream.Readable&gt;</a></li>\n</ul>\n<p>An <code>IncomingMessage</code> object is created by <a href=\"http.html#http_class_http_server\"><code>http.Server</code></a> or\n<a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> and passed as the first argument to the <a href=\"http.html#http_event_request\"><code>'request'</code></a>\nand <a href=\"http.html#http_event_response\"><code>'response'</code></a> event respectively. It may be used to access response\nstatus, headers and data.</p>",
-          "events": [
-            {
-              "textRaw": "Event: `'aborted'`",
-              "type": "event",
-              "name": "aborted",
-              "meta": {
-                "added": [
-                  "v0.3.8"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Emitted when the request has been aborted.</p>"
-            },
-            {
-              "textRaw": "Event: `'close'`",
-              "type": "event",
-              "name": "close",
-              "meta": {
-                "added": [
-                  "v0.4.2"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Indicates that the underlying connection was closed.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`aborted` {boolean}",
-              "type": "boolean",
-              "name": "aborted",
-              "meta": {
-                "added": [
-                  "v10.1.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The <code>message.aborted</code> property will be <code>true</code> if the request has\nbeen aborted.</p>"
-            },
-            {
-              "textRaw": "`complete` {boolean}",
-              "type": "boolean",
-              "name": "complete",
-              "meta": {
-                "added": [
-                  "v0.3.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The <code>message.complete</code> property will be <code>true</code> if a complete HTTP message has\nbeen received and successfully parsed.</p>\n<p>This property is particularly useful as a means of determining if a client or\nserver fully transmitted a message before a connection was terminated:</p>\n<pre><code class=\"language-js\">const req = http.request({\n  host: '127.0.0.1',\n  port: 8080,\n  method: 'POST'\n}, (res) => {\n  res.resume();\n  res.on('end', () => {\n    if (!res.complete)\n      console.error(\n        'The connection was terminated while the message was still being sent');\n  });\n});\n</code></pre>"
-            },
-            {
-              "textRaw": "`headers` {Object}",
-              "type": "Object",
-              "name": "headers",
-              "meta": {
-                "added": [
-                  "v0.1.5"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The request/response headers object.</p>\n<p>Key-value pairs of header names and values. Header names are lower-cased.</p>\n<pre><code class=\"language-js\">// Prints something like:\n//\n// { 'user-agent': 'curl/7.22.0',\n//   host: '127.0.0.1:8000',\n//   accept: '*/*' }\nconsole.log(request.headers);\n</code></pre>\n<p>Duplicates in raw headers are handled in the following ways, depending on the\nheader name:</p>\n<ul>\n<li>Duplicates of <code>age</code>, <code>authorization</code>, <code>content-length</code>, <code>content-type</code>,\n<code>etag</code>, <code>expires</code>, <code>from</code>, <code>host</code>, <code>if-modified-since</code>, <code>if-unmodified-since</code>,\n<code>last-modified</code>, <code>location</code>, <code>max-forwards</code>, <code>proxy-authorization</code>, <code>referer</code>,\n<code>retry-after</code>, <code>server</code>, or <code>user-agent</code> are discarded.</li>\n<li><code>set-cookie</code> is always an array. Duplicates are added to the array.</li>\n<li>For duplicate <code>cookie</code> headers, the values are joined together with '; '.</li>\n<li>For all other headers, the values are joined together with ', '.</li>\n</ul>"
-            },
-            {
-              "textRaw": "`httpVersion` {string}",
-              "type": "string",
-              "name": "httpVersion",
-              "meta": {
-                "added": [
-                  "v0.1.1"
-                ],
-                "changes": []
-              },
-              "desc": "<p>In case of server request, the HTTP version sent by the client. In the case of\nclient response, the HTTP version of the connected-to server.\nProbably either <code>'1.1'</code> or <code>'1.0'</code>.</p>\n<p>Also <code>message.httpVersionMajor</code> is the first integer and\n<code>message.httpVersionMinor</code> is the second.</p>"
-            },
-            {
-              "textRaw": "`method` {string}",
-              "type": "string",
-              "name": "method",
-              "meta": {
-                "added": [
-                  "v0.1.1"
-                ],
-                "changes": []
-              },
-              "desc": "<p><strong>Only valid for request obtained from <a href=\"http.html#http_class_http_server\"><code>http.Server</code></a>.</strong></p>\n<p>The request method as a string. Read only. Examples: <code>'GET'</code>, <code>'DELETE'</code>.</p>"
-            },
-            {
-              "textRaw": "`rawHeaders` {string[]}",
-              "type": "string[]",
-              "name": "rawHeaders",
-              "meta": {
-                "added": [
-                  "v0.11.6"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The raw request/response headers list exactly as they were received.</p>\n<p>The keys and values are in the same list. It is <em>not</em> a\nlist of tuples. So, the even-numbered offsets are key values, and the\nodd-numbered offsets are the associated values.</p>\n<p>Header names are not lowercased, and duplicates are not merged.</p>\n<pre><code class=\"language-js\">// Prints something like:\n//\n// [ 'user-agent',\n//   'this is invalid because there can be only one',\n//   'User-Agent',\n//   'curl/7.22.0',\n//   'Host',\n//   '127.0.0.1:8000',\n//   'ACCEPT',\n//   '*/*' ]\nconsole.log(request.rawHeaders);\n</code></pre>"
-            },
-            {
-              "textRaw": "`rawTrailers` {string[]}",
-              "type": "string[]",
-              "name": "rawTrailers",
-              "meta": {
-                "added": [
-                  "v0.11.6"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The raw request/response trailer keys and values exactly as they were\nreceived. Only populated at the <code>'end'</code> event.</p>"
-            },
-            {
-              "textRaw": "`socket` {stream.Duplex}",
-              "type": "stream.Duplex",
-              "name": "socket",
-              "meta": {
-                "added": [
-                  "v0.3.0"
+                  "v13.0.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> object associated with the connection.</p>\n<p>With HTTPS support, use <a href=\"tls.html#tls_tlssocket_getpeercertificate_detailed\"><code>request.socket.getPeerCertificate()</code></a> to obtain the\nclient's authentication details.</p>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "desc": "<p>Readonly. <code>true</code> if all data has been flushed to the underlying system.</p>"
             },
             {
-              "textRaw": "`statusCode` {number}",
+              "textRaw": "`writableHighWaterMark` {number}",
               "type": "number",
-              "name": "statusCode",
-              "meta": {
-                "added": [
-                  "v0.1.1"
-                ],
-                "changes": []
-              },
-              "desc": "<p><strong>Only valid for response obtained from <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>.</strong></p>\n<p>The 3-digit HTTP response status code. E.G. <code>404</code>.</p>"
-            },
-            {
-              "textRaw": "`statusMessage` {string}",
-              "type": "string",
-              "name": "statusMessage",
-              "meta": {
-                "added": [
-                  "v0.11.10"
-                ],
-                "changes": []
-              },
-              "desc": "<p><strong>Only valid for response obtained from <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>.</strong></p>\n<p>The HTTP response status message (reason phrase). E.G. <code>OK</code> or <code>Internal Server Error</code>.</p>"
-            },
-            {
-              "textRaw": "`trailers` {Object}",
-              "type": "Object",
-              "name": "trailers",
+              "name": "writableHighWaterMark",
               "meta": {
                 "added": [
-                  "v0.3.0"
+                  "v13.0.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The request/response trailers object. Only populated at the <code>'end'</code> event.</p>"
+              "desc": "<p>This <code>outgoingMessage.writableHighWaterMark</code> will be the <code>highWaterMark</code> of\nunderlying socket if socket exists. Else, it would be the default\n<code>highWaterMark</code>.</p>\n<p><code>highWaterMark</code> is the maximum amount of data that can be potentially\nbuffered by the socket.</p>"
             },
             {
-              "textRaw": "`url` {string}",
-              "type": "string",
-              "name": "url",
+              "textRaw": "`writableLength` {number}",
+              "type": "number",
+              "name": "writableLength",
               "meta": {
                 "added": [
-                  "v0.1.90"
+                  "v13.0.0"
                 ],
                 "changes": []
               },
-              "desc": "<p><strong>Only valid for request obtained from <a href=\"http.html#http_class_http_server\"><code>http.Server</code></a>.</strong></p>\n<p>Request URL string. This contains only the URL that is present in the actual\nHTTP request. Take the following request:</p>\n<pre><code class=\"language-http\">GET /status?name=ryan HTTP/1.1\nAccept: text/plain\n</code></pre>\n<p>To parse the URL into its parts:</p>\n<pre><code class=\"language-js\">new URL(request.url, `http://${request.headers.host}`);\n</code></pre>\n<p>When <code>request.url</code> is <code>'/status?name=ryan'</code> and\n<code>request.headers.host</code> is <code>'localhost:3000'</code>:</p>\n<pre><code class=\"language-console\">$ node\n> new URL(request.url, `http://${request.headers.host}`)\nURL {\n  href: 'http://localhost:3000/status?name=ryan',\n  origin: 'http://localhost:3000',\n  protocol: 'http:',\n  username: '',\n  password: '',\n  host: 'localhost:3000',\n  hostname: 'localhost',\n  port: '3000',\n  pathname: '/status',\n  search: '?name=ryan',\n  searchParams: URLSearchParams { 'name' => 'ryan' },\n  hash: ''\n}\n</code></pre>"
-            }
-          ],
-          "methods": [
-            {
-              "textRaw": "`message.destroy([error])`",
-              "type": "method",
-              "name": "destroy",
-              "meta": {
-                "added": [
-                  "v0.3.0"
-                ],
-                "changes": [
-                  {
-                    "version": "v12.19.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/32789",
-                    "description": "The function returns `this` for consistency with other Readable streams."
-                  }
-                ]
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {this}",
-                    "name": "return",
-                    "type": "this"
-                  },
-                  "params": [
-                    {
-                      "textRaw": "`error` {Error}",
-                      "name": "error",
-                      "type": "Error"
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p>Calls <code>destroy()</code> on the socket that received the <code>IncomingMessage</code>. If <code>error</code>\nis provided, an <code>'error'</code> event is emitted on the socket and <code>error</code> is passed\nas an argument to any listeners on the event.</p>"
+              "desc": "<p>Readonly, This <code>outgoingMessage.writableLength</code> contains the number of\nbytes (or objects) in the buffer ready to send.</p>"
             },
             {
-              "textRaw": "`message.setTimeout(msecs[, callback])`",
-              "type": "method",
-              "name": "setTimeout",
+              "textRaw": "`writableObjectMode` {boolean}",
+              "type": "boolean",
+              "name": "writableObjectMode",
               "meta": {
                 "added": [
-                  "v0.5.9"
+                  "v13.0.0"
                 ],
                 "changes": []
               },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {http.IncomingMessage}",
-                    "name": "return",
-                    "type": "http.IncomingMessage"
-                  },
-                  "params": [
-                    {
-                      "textRaw": "`msecs` {number}",
-                      "name": "msecs",
-                      "type": "number"
-                    },
-                    {
-                      "textRaw": "`callback` {Function}",
-                      "name": "callback",
-                      "type": "Function"
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p>Calls <code>message.connection.setTimeout(msecs, callback)</code>.</p>"
+              "desc": "<p>Readonly, always returns <code>false</code>.</p>"
             }
           ]
         }
@@ -36537,11 +40659,12 @@
           "name": "maxHeaderSize",
           "meta": {
             "added": [
-              "v11.6.0"
+              "v11.6.0",
+              "v10.15.0"
             ],
             "changes": []
           },
-          "desc": "<p>Read-only property specifying the maximum allowed size of HTTP headers in bytes.\nDefaults to 8KB. Configurable using the <a href=\"cli.html#cli_max_http_header_size_size\"><code>--max-http-header-size</code></a> CLI option.</p>"
+          "desc": "<p>Read-only property specifying the maximum allowed size of HTTP headers in bytes.\nDefaults to 8KB. Configurable using the <a href=\"cli.html#cli_max_http_header_size_size\"><code>--max-http-header-size</code></a> CLI option.</p>\n<p>This can be overridden for servers and client requests by passing the\n<code>maxHeaderSize</code> option.</p>"
         }
       ],
       "methods": [
@@ -36555,12 +40678,24 @@
             ],
             "changes": [
               {
-                "version": "v12.15.0",
+                "version": [
+                  "v13.8.0",
+                  "v12.15.0",
+                  "v10.19.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/31448",
                 "description": "The `insecureHTTPParser` option is supported now."
               },
               {
-                "version": "v9.6.0, v8.12.0",
+                "version": "v13.3.0",
+                "pr-url": "https://github.com/nodejs/node/pull/30570",
+                "description": "The `maxHeaderSize` option is supported now."
+              },
+              {
+                "version": [
+                  "v9.6.0",
+                  "v8.12.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/15752",
                 "description": "The `options` argument is supported now."
               }
@@ -36599,6 +40734,13 @@
                       "type": "boolean",
                       "default": "`false`",
                       "desc": "Use an insecure HTTP parser that accepts invalid HTTP headers when `true`. Using the insecure parser should be avoided. See [`--insecure-http-parser`][] for more information."
+                    },
+                    {
+                      "textRaw": "`maxHeaderSize` {number} Optionally overrides the value of [`--max-http-header-size`][] for requests received by this server, i.e. the maximum length of request headers in bytes. **Default:** 16384 (16KB).",
+                      "name": "maxHeaderSize",
+                      "type": "number",
+                      "default": "16384 (16KB)",
+                      "desc": "Optionally overrides the value of [`--max-http-header-size`][] for requests received by this server, i.e. the maximum length of request headers in bytes."
                     }
                   ]
                 },
@@ -36610,7 +40752,7 @@
               ]
             }
           ],
-          "desc": "<p>Returns a new instance of <a href=\"http.html#http_class_http_server\"><code>http.Server</code></a>.</p>\n<p>The <code>requestListener</code> is a function which is automatically\nadded to the <a href=\"http.html#http_event_request\"><code>'request'</code></a> event.</p>"
+          "desc": "<p>Returns a new instance of <a href=\"http.html#http_class_http_server\"><code>http.Server</code></a>.</p>\n<p>The <code>requestListener</code> is a function which is automatically\nadded to the <a href=\"http.html#http_event_request\"><code>'request'</code></a> event.</p>\n<pre><code class=\"language-cjs\">const http = require('http');\n\n// Create a local server to receive data from\nconst server = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'application/json' });\n  res.end(JSON.stringify({\n    data: 'Hello World!'\n  }));\n});\n\nserver.listen(8000);\n</code></pre>\n<pre><code class=\"language-cjs\">const http = require('http');\n\n// Create a local server to receive data from\nconst server = http.createServer();\n\n// Listen to the request event\nserver.on('request', (request, res) => {\n  res.writeHead(200, { 'Content-Type': 'application/json' });\n  res.end(JSON.stringify({\n    data: 'Hello World!'\n  }));\n});\n\nserver.listen(8000);\n</code></pre>"
         },
         {
           "textRaw": "`http.get(options[, callback])`",
@@ -36660,7 +40802,7 @@
               ]
             }
           ],
-          "desc": "<p>Since most requests are GET requests without bodies, Node.js provides this\nconvenience method. The only difference between this method and\n<a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a> is that it sets the method to GET and calls <code>req.end()</code>\nautomatically. The callback must take care to consume the response\ndata for reasons stated in <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> section.</p>\n<p>The <code>callback</code> is invoked with a single argument that is an instance of\n<a href=\"http.html#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>JSON fetching example:</p>\n<pre><code class=\"language-js\">http.get('http://nodejs.org/dist/index.json', (res) => {\n  const { statusCode } = res;\n  const contentType = res.headers['content-type'];\n\n  let error;\n  // Any 2xx status code signals a successful response but\n  // here we're only checking for 200.\n  if (statusCode !== 200) {\n    error = new Error('Request Failed.\\n' +\n                      `Status Code: ${statusCode}`);\n  } else if (!/^application\\/json/.test(contentType)) {\n    error = new Error('Invalid content-type.\\n' +\n                      `Expected application/json but received ${contentType}`);\n  }\n  if (error) {\n    console.error(error.message);\n    // Consume response data to free up memory\n    res.resume();\n    return;\n  }\n\n  res.setEncoding('utf8');\n  let rawData = '';\n  res.on('data', (chunk) => { rawData += chunk; });\n  res.on('end', () => {\n    try {\n      const parsedData = JSON.parse(rawData);\n      console.log(parsedData);\n    } catch (e) {\n      console.error(e.message);\n    }\n  });\n}).on('error', (e) => {\n  console.error(`Got error: ${e.message}`);\n});\n</code></pre>"
+          "desc": "<p>Since most requests are GET requests without bodies, Node.js provides this\nconvenience method. The only difference between this method and\n<a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a> is that it sets the method to GET and calls <code>req.end()</code>\nautomatically. The callback must take care to consume the response\ndata for reasons stated in <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> section.</p>\n<p>The <code>callback</code> is invoked with a single argument that is an instance of\n<a href=\"http.html#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>JSON fetching example:</p>\n<pre><code class=\"language-js\">http.get('http://localhost:8000/', (res) => {\n  const { statusCode } = res;\n  const contentType = res.headers['content-type'];\n\n  let error;\n  // Any 2xx status code signals a successful response but\n  // here we're only checking for 200.\n  if (statusCode !== 200) {\n    error = new Error('Request Failed.\\n' +\n                      `Status Code: ${statusCode}`);\n  } else if (!/^application\\/json/.test(contentType)) {\n    error = new Error('Invalid content-type.\\n' +\n                      `Expected application/json but received ${contentType}`);\n  }\n  if (error) {\n    console.error(error.message);\n    // Consume response data to free up memory\n    res.resume();\n    return;\n  }\n\n  res.setEncoding('utf8');\n  let rawData = '';\n  res.on('data', (chunk) => { rawData += chunk; });\n  res.on('end', () => {\n    try {\n      const parsedData = JSON.parse(rawData);\n      console.log(parsedData);\n    } catch (e) {\n      console.error(e.message);\n    }\n  });\n}).on('error', (e) => {\n  console.error(`Got error: ${e.message}`);\n});\n\n// Create a local server to receive data from\nconst server = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'application/json' });\n  res.end(JSON.stringify({\n    data: 'Hello World!'\n  }));\n});\n\nserver.listen(8000);\n</code></pre>"
         },
         {
           "textRaw": "`http.get(url[, options][, callback])`",
@@ -36710,7 +40852,7 @@
               ]
             }
           ],
-          "desc": "<p>Since most requests are GET requests without bodies, Node.js provides this\nconvenience method. The only difference between this method and\n<a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a> is that it sets the method to GET and calls <code>req.end()</code>\nautomatically. The callback must take care to consume the response\ndata for reasons stated in <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> section.</p>\n<p>The <code>callback</code> is invoked with a single argument that is an instance of\n<a href=\"http.html#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>JSON fetching example:</p>\n<pre><code class=\"language-js\">http.get('http://nodejs.org/dist/index.json', (res) => {\n  const { statusCode } = res;\n  const contentType = res.headers['content-type'];\n\n  let error;\n  // Any 2xx status code signals a successful response but\n  // here we're only checking for 200.\n  if (statusCode !== 200) {\n    error = new Error('Request Failed.\\n' +\n                      `Status Code: ${statusCode}`);\n  } else if (!/^application\\/json/.test(contentType)) {\n    error = new Error('Invalid content-type.\\n' +\n                      `Expected application/json but received ${contentType}`);\n  }\n  if (error) {\n    console.error(error.message);\n    // Consume response data to free up memory\n    res.resume();\n    return;\n  }\n\n  res.setEncoding('utf8');\n  let rawData = '';\n  res.on('data', (chunk) => { rawData += chunk; });\n  res.on('end', () => {\n    try {\n      const parsedData = JSON.parse(rawData);\n      console.log(parsedData);\n    } catch (e) {\n      console.error(e.message);\n    }\n  });\n}).on('error', (e) => {\n  console.error(`Got error: ${e.message}`);\n});\n</code></pre>"
+          "desc": "<p>Since most requests are GET requests without bodies, Node.js provides this\nconvenience method. The only difference between this method and\n<a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a> is that it sets the method to GET and calls <code>req.end()</code>\nautomatically. The callback must take care to consume the response\ndata for reasons stated in <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> section.</p>\n<p>The <code>callback</code> is invoked with a single argument that is an instance of\n<a href=\"http.html#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>JSON fetching example:</p>\n<pre><code class=\"language-js\">http.get('http://localhost:8000/', (res) => {\n  const { statusCode } = res;\n  const contentType = res.headers['content-type'];\n\n  let error;\n  // Any 2xx status code signals a successful response but\n  // here we're only checking for 200.\n  if (statusCode !== 200) {\n    error = new Error('Request Failed.\\n' +\n                      `Status Code: ${statusCode}`);\n  } else if (!/^application\\/json/.test(contentType)) {\n    error = new Error('Invalid content-type.\\n' +\n                      `Expected application/json but received ${contentType}`);\n  }\n  if (error) {\n    console.error(error.message);\n    // Consume response data to free up memory\n    res.resume();\n    return;\n  }\n\n  res.setEncoding('utf8');\n  let rawData = '';\n  res.on('data', (chunk) => { rawData += chunk; });\n  res.on('end', () => {\n    try {\n      const parsedData = JSON.parse(rawData);\n      console.log(parsedData);\n    } catch (e) {\n      console.error(e.message);\n    }\n  });\n}).on('error', (e) => {\n  console.error(`Got error: ${e.message}`);\n});\n\n// Create a local server to receive data from\nconst server = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'application/json' });\n  res.end(JSON.stringify({\n    data: 'Hello World!'\n  }));\n});\n\nserver.listen(8000);\n</code></pre>"
         },
         {
           "textRaw": "`http.request(options[, callback])`",
@@ -36722,10 +40864,29 @@
             ],
             "changes": [
               {
-                "version": "v12.15.0",
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/39310",
+                "description": "When using a `URL` object parsed username and password will now be properly URI decoded."
+              },
+              {
+                "version": "v14.17.0",
+                "pr-url": "https://github.com/nodejs/node/pull/36048",
+                "description": "It is possible to abort a request with an AbortSignal."
+              },
+              {
+                "version": [
+                  "v13.8.0",
+                  "v12.15.0",
+                  "v10.19.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/31448",
                 "description": "The `insecureHTTPParser` option is supported now."
               },
+              {
+                "version": "v13.3.0",
+                "pr-url": "https://github.com/nodejs/node/pull/30570",
+                "description": "The `maxHeaderSize` option is supported now."
+              },
               {
                 "version": "v10.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/21616",
@@ -36810,6 +40971,12 @@
                       "type": "Object",
                       "desc": "An object containing request headers."
                     },
+                    {
+                      "textRaw": "`hints` {number} Optional [`dns.lookup()` hints][].",
+                      "name": "hints",
+                      "type": "number",
+                      "desc": "Optional [`dns.lookup()` hints][]."
+                    },
                     {
                       "textRaw": "`host` {string} A domain name or IP address of the server to issue the request to. **Default:** `'localhost'`.",
                       "name": "host",
@@ -36836,6 +41003,12 @@
                       "type": "string",
                       "desc": "Local interface to bind for network connections."
                     },
+                    {
+                      "textRaw": "`localPort` {number} Local port to connect from.",
+                      "name": "localPort",
+                      "type": "number",
+                      "desc": "Local port to connect from."
+                    },
                     {
                       "textRaw": "`lookup` {Function} Custom lookup function. **Default:** [`dns.lookup()`][].",
                       "name": "lookup",
@@ -36843,6 +41016,13 @@
                       "default": "[`dns.lookup()`][]",
                       "desc": "Custom lookup function."
                     },
+                    {
+                      "textRaw": "`maxHeaderSize` {number} Optionally overrides the value of [`--max-http-header-size`][] for requests received from the server, i.e. the maximum length of response headers in bytes. **Default:** 16384 (16KB).",
+                      "name": "maxHeaderSize",
+                      "type": "number",
+                      "default": "16384 (16KB)",
+                      "desc": "Optionally overrides the value of [`--max-http-header-size`][] for requests received from the server, i.e. the maximum length of response headers in bytes."
+                    },
                     {
                       "textRaw": "`method` {string} A string specifying the HTTP request method. **Default:** `'GET'`.",
                       "name": "method",
@@ -36888,6 +41068,12 @@
                       "name": "timeout",
                       "type": "number",
                       "desc": ": A number specifying the socket timeout in milliseconds. This will set the timeout before the socket is connected."
+                    },
+                    {
+                      "textRaw": "`signal` {AbortSignal}: An AbortSignal that may be used to abort an ongoing request.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": ": An AbortSignal that may be used to abort an ongoing request."
                     }
                   ]
                 },
@@ -36899,7 +41085,7 @@
               ]
             }
           ],
-          "desc": "<p>Node.js maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.</p>\n<p><code>url</code> can be a string or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>url</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p>If both <code>url</code> and <code>options</code> are specified, the objects are merged, with the\n<code>options</code> properties taking precedence.</p>\n<p>The optional <code>callback</code> parameter will be added as a one-time listener for\nthe <a href=\"http.html#http_event_response\"><code>'response'</code></a> event.</p>\n<p><code>http.request()</code> returns an instance of the <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const postData = querystring.stringify({\n  'msg': 'Hello World!'\n});\n\nconst options = {\n  hostname: 'www.google.com',\n  port: 80,\n  path: '/upload',\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/x-www-form-urlencoded',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n};\n\nconst req = http.request(options, (res) => {\n  console.log(`STATUS: ${res.statusCode}`);\n  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);\n  res.setEncoding('utf8');\n  res.on('data', (chunk) => {\n    console.log(`BODY: ${chunk}`);\n  });\n  res.on('end', () => {\n    console.log('No more data in response.');\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(`problem with request: ${e.message}`);\n});\n\n// Write data to request body\nreq.write(postData);\nreq.end();\n</code></pre>\n<p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one\nmust always call <code>req.end()</code> to signify the end of the request -\neven if there is no data being written to the request body.</p>\n<p>If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an <code>'error'</code> event is emitted\non the returned request object. As with all <code>'error'</code> events, if no listeners\nare registered the error will be thrown.</p>\n<p>There are a few special headers that should be noted.</p>\n<ul>\n<li>\n<p>Sending a 'Connection: keep-alive' will notify Node.js that the connection to\nthe server should be persisted until the next request.</p>\n</li>\n<li>\n<p>Sending a 'Content-Length' header will disable the default chunked encoding.</p>\n</li>\n<li>\n<p>Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', both a timeout and a listener\nfor the <code>'continue'</code> event should be set. See RFC 2616 Section 8.2.3 for more\ninformation.</p>\n</li>\n<li>\n<p>Sending an Authorization header will override using the <code>auth</code> option\nto compute basic authentication.</p>\n</li>\n</ul>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('http://abc:xyz@example.com');\n\nconst req = http.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>In a successful request, the following events will be emitted in the following\norder:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object\n(<code>'data'</code> will not be emitted at all if the response body is empty, for\ninstance, in most redirects)</li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n</ul>\n</li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a connection error, the following events will be emitted:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called before the connection succeeds, the following events\nwill be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called after the response is received, the following events\nwill be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will\nnot abort the request or do anything besides add a <code>'timeout'</code> event.</p>"
+          "desc": "<p>Node.js maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.</p>\n<p><code>url</code> can be a string or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>url</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p>If both <code>url</code> and <code>options</code> are specified, the objects are merged, with the\n<code>options</code> properties taking precedence.</p>\n<p>The optional <code>callback</code> parameter will be added as a one-time listener for\nthe <a href=\"http.html#http_event_response\"><code>'response'</code></a> event.</p>\n<p><code>http.request()</code> returns an instance of the <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst postData = JSON.stringify({\n  'msg': 'Hello World!'\n});\n\nconst options = {\n  hostname: 'www.google.com',\n  port: 80,\n  path: '/upload',\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/json',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n};\n\nconst req = http.request(options, (res) => {\n  console.log(`STATUS: ${res.statusCode}`);\n  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);\n  res.setEncoding('utf8');\n  res.on('data', (chunk) => {\n    console.log(`BODY: ${chunk}`);\n  });\n  res.on('end', () => {\n    console.log('No more data in response.');\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(`problem with request: ${e.message}`);\n});\n\n// Write data to request body\nreq.write(postData);\nreq.end();\n</code></pre>\n<p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one\nmust always call <code>req.end()</code> to signify the end of the request -\neven if there is no data being written to the request body.</p>\n<p>If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an <code>'error'</code> event is emitted\non the returned request object. As with all <code>'error'</code> events, if no listeners\nare registered the error will be thrown.</p>\n<p>There are a few special headers that should be noted.</p>\n<ul>\n<li>\n<p>Sending a 'Connection: keep-alive' will notify Node.js that the connection to\nthe server should be persisted until the next request.</p>\n</li>\n<li>\n<p>Sending a 'Content-Length' header will disable the default chunked encoding.</p>\n</li>\n<li>\n<p>Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', both a timeout and a listener\nfor the <code>'continue'</code> event should be set. See RFC 2616 Section 8.2.3 for more\ninformation.</p>\n</li>\n<li>\n<p>Sending an Authorization header will override using the <code>auth</code> option\nto compute basic authentication.</p>\n</li>\n</ul>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('http://abc:xyz@example.com');\n\nconst req = http.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>In a successful request, the following events will be emitted in the following\norder:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object\n(<code>'data'</code> will not be emitted at all if the response body is empty, for\ninstance, in most redirects)</li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n</ul>\n</li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a connection error, the following events will be emitted:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a premature connection close before the response is received,\nthe following events will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a premature connection close after the response is received,\nthe following events will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(connection closed here)</li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>If <code>req.destroy()</code> is called before a socket is assigned, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.destroy()</code> is called before the connection succeeds, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.destroy()</code> is called after the response is received, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>If <code>req.abort()</code> is called before a socket is assigned, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called before the connection succeeds, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called after the response is received, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will\nnot abort the request or do anything besides add a <code>'timeout'</code> event.</p>\n<p>Passing an <code>AbortSignal</code> and then calling <code>abort</code> on the corresponding\n<code>AbortController</code> will behave the same way as calling <code>.destroy()</code> on the\nrequest itself.</p>"
         },
         {
           "textRaw": "`http.request(url[, options][, callback])`",
@@ -36911,10 +41097,29 @@
             ],
             "changes": [
               {
-                "version": "v12.15.0",
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/39310",
+                "description": "When using a `URL` object parsed username and password will now be properly URI decoded."
+              },
+              {
+                "version": "v14.17.0",
+                "pr-url": "https://github.com/nodejs/node/pull/36048",
+                "description": "It is possible to abort a request with an AbortSignal."
+              },
+              {
+                "version": [
+                  "v13.8.0",
+                  "v12.15.0",
+                  "v10.19.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/31448",
                 "description": "The `insecureHTTPParser` option is supported now."
               },
+              {
+                "version": "v13.3.0",
+                "pr-url": "https://github.com/nodejs/node/pull/30570",
+                "description": "The `maxHeaderSize` option is supported now."
+              },
               {
                 "version": "v10.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/21616",
@@ -36999,6 +41204,12 @@
                       "type": "Object",
                       "desc": "An object containing request headers."
                     },
+                    {
+                      "textRaw": "`hints` {number} Optional [`dns.lookup()` hints][].",
+                      "name": "hints",
+                      "type": "number",
+                      "desc": "Optional [`dns.lookup()` hints][]."
+                    },
                     {
                       "textRaw": "`host` {string} A domain name or IP address of the server to issue the request to. **Default:** `'localhost'`.",
                       "name": "host",
@@ -37025,6 +41236,12 @@
                       "type": "string",
                       "desc": "Local interface to bind for network connections."
                     },
+                    {
+                      "textRaw": "`localPort` {number} Local port to connect from.",
+                      "name": "localPort",
+                      "type": "number",
+                      "desc": "Local port to connect from."
+                    },
                     {
                       "textRaw": "`lookup` {Function} Custom lookup function. **Default:** [`dns.lookup()`][].",
                       "name": "lookup",
@@ -37032,6 +41249,13 @@
                       "default": "[`dns.lookup()`][]",
                       "desc": "Custom lookup function."
                     },
+                    {
+                      "textRaw": "`maxHeaderSize` {number} Optionally overrides the value of [`--max-http-header-size`][] for requests received from the server, i.e. the maximum length of response headers in bytes. **Default:** 16384 (16KB).",
+                      "name": "maxHeaderSize",
+                      "type": "number",
+                      "default": "16384 (16KB)",
+                      "desc": "Optionally overrides the value of [`--max-http-header-size`][] for requests received from the server, i.e. the maximum length of response headers in bytes."
+                    },
                     {
                       "textRaw": "`method` {string} A string specifying the HTTP request method. **Default:** `'GET'`.",
                       "name": "method",
@@ -37077,6 +41301,12 @@
                       "name": "timeout",
                       "type": "number",
                       "desc": ": A number specifying the socket timeout in milliseconds. This will set the timeout before the socket is connected."
+                    },
+                    {
+                      "textRaw": "`signal` {AbortSignal}: An AbortSignal that may be used to abort an ongoing request.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": ": An AbortSignal that may be used to abort an ongoing request."
                     }
                   ]
                 },
@@ -37088,11 +41318,63 @@
               ]
             }
           ],
-          "desc": "<p>Node.js maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.</p>\n<p><code>url</code> can be a string or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>url</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p>If both <code>url</code> and <code>options</code> are specified, the objects are merged, with the\n<code>options</code> properties taking precedence.</p>\n<p>The optional <code>callback</code> parameter will be added as a one-time listener for\nthe <a href=\"http.html#http_event_response\"><code>'response'</code></a> event.</p>\n<p><code>http.request()</code> returns an instance of the <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const postData = querystring.stringify({\n  'msg': 'Hello World!'\n});\n\nconst options = {\n  hostname: 'www.google.com',\n  port: 80,\n  path: '/upload',\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/x-www-form-urlencoded',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n};\n\nconst req = http.request(options, (res) => {\n  console.log(`STATUS: ${res.statusCode}`);\n  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);\n  res.setEncoding('utf8');\n  res.on('data', (chunk) => {\n    console.log(`BODY: ${chunk}`);\n  });\n  res.on('end', () => {\n    console.log('No more data in response.');\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(`problem with request: ${e.message}`);\n});\n\n// Write data to request body\nreq.write(postData);\nreq.end();\n</code></pre>\n<p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one\nmust always call <code>req.end()</code> to signify the end of the request -\neven if there is no data being written to the request body.</p>\n<p>If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an <code>'error'</code> event is emitted\non the returned request object. As with all <code>'error'</code> events, if no listeners\nare registered the error will be thrown.</p>\n<p>There are a few special headers that should be noted.</p>\n<ul>\n<li>\n<p>Sending a 'Connection: keep-alive' will notify Node.js that the connection to\nthe server should be persisted until the next request.</p>\n</li>\n<li>\n<p>Sending a 'Content-Length' header will disable the default chunked encoding.</p>\n</li>\n<li>\n<p>Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', both a timeout and a listener\nfor the <code>'continue'</code> event should be set. See RFC 2616 Section 8.2.3 for more\ninformation.</p>\n</li>\n<li>\n<p>Sending an Authorization header will override using the <code>auth</code> option\nto compute basic authentication.</p>\n</li>\n</ul>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('http://abc:xyz@example.com');\n\nconst req = http.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>In a successful request, the following events will be emitted in the following\norder:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object\n(<code>'data'</code> will not be emitted at all if the response body is empty, for\ninstance, in most redirects)</li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n</ul>\n</li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a connection error, the following events will be emitted:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called before the connection succeeds, the following events\nwill be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called after the response is received, the following events\nwill be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will\nnot abort the request or do anything besides add a <code>'timeout'</code> event.</p>"
+          "desc": "<p>Node.js maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.</p>\n<p><code>url</code> can be a string or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>url</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p>If both <code>url</code> and <code>options</code> are specified, the objects are merged, with the\n<code>options</code> properties taking precedence.</p>\n<p>The optional <code>callback</code> parameter will be added as a one-time listener for\nthe <a href=\"http.html#http_event_response\"><code>'response'</code></a> event.</p>\n<p><code>http.request()</code> returns an instance of the <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst postData = JSON.stringify({\n  'msg': 'Hello World!'\n});\n\nconst options = {\n  hostname: 'www.google.com',\n  port: 80,\n  path: '/upload',\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/json',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n};\n\nconst req = http.request(options, (res) => {\n  console.log(`STATUS: ${res.statusCode}`);\n  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);\n  res.setEncoding('utf8');\n  res.on('data', (chunk) => {\n    console.log(`BODY: ${chunk}`);\n  });\n  res.on('end', () => {\n    console.log('No more data in response.');\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(`problem with request: ${e.message}`);\n});\n\n// Write data to request body\nreq.write(postData);\nreq.end();\n</code></pre>\n<p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one\nmust always call <code>req.end()</code> to signify the end of the request -\neven if there is no data being written to the request body.</p>\n<p>If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an <code>'error'</code> event is emitted\non the returned request object. As with all <code>'error'</code> events, if no listeners\nare registered the error will be thrown.</p>\n<p>There are a few special headers that should be noted.</p>\n<ul>\n<li>\n<p>Sending a 'Connection: keep-alive' will notify Node.js that the connection to\nthe server should be persisted until the next request.</p>\n</li>\n<li>\n<p>Sending a 'Content-Length' header will disable the default chunked encoding.</p>\n</li>\n<li>\n<p>Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', both a timeout and a listener\nfor the <code>'continue'</code> event should be set. See RFC 2616 Section 8.2.3 for more\ninformation.</p>\n</li>\n<li>\n<p>Sending an Authorization header will override using the <code>auth</code> option\nto compute basic authentication.</p>\n</li>\n</ul>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('http://abc:xyz@example.com');\n\nconst req = http.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>In a successful request, the following events will be emitted in the following\norder:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object\n(<code>'data'</code> will not be emitted at all if the response body is empty, for\ninstance, in most redirects)</li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n</ul>\n</li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a connection error, the following events will be emitted:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a premature connection close before the response is received,\nthe following events will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a premature connection close after the response is received,\nthe following events will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(connection closed here)</li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>If <code>req.destroy()</code> is called before a socket is assigned, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.destroy()</code> is called before the connection succeeds, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.destroy()</code> is called after the response is received, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>If <code>req.abort()</code> is called before a socket is assigned, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called before the connection succeeds, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called after the response is received, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will\nnot abort the request or do anything besides add a <code>'timeout'</code> event.</p>\n<p>Passing an <code>AbortSignal</code> and then calling <code>abort</code> on the corresponding\n<code>AbortController</code> will behave the same way as calling <code>.destroy()</code> on the\nrequest itself.</p>"
+        },
+        {
+          "textRaw": "`http.validateHeaderName(name)`",
+          "type": "method",
+          "name": "validateHeaderName",
+          "meta": {
+            "added": [
+              "v14.3.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`name` {string}",
+                  "name": "name",
+                  "type": "string"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Performs the low-level validations on the provided <code>name</code> that are done when\n<code>res.setHeader(name, value)</code> is called.</p>\n<p>Passing illegal value as <code>name</code> will result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown,\nidentified by <code>code: 'ERR_INVALID_HTTP_TOKEN'</code>.</p>\n<p>It is not necessary to use this method before passing headers to an HTTP request\nor response. The HTTP module will automatically validate such headers.\nExamples:</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const { validateHeaderName } = require('http');\n\ntry {\n  validateHeaderName('');\n} catch (err) {\n  err instanceof TypeError; // --> true\n  err.code; // --> 'ERR_INVALID_HTTP_TOKEN'\n  err.message; // --> 'Header name must be a valid HTTP token [\"\"]'\n}\n</code></pre>"
+        },
+        {
+          "textRaw": "`http.validateHeaderValue(name, value)`",
+          "type": "method",
+          "name": "validateHeaderValue",
+          "meta": {
+            "added": [
+              "v14.3.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`name` {string}",
+                  "name": "name",
+                  "type": "string"
+                },
+                {
+                  "textRaw": "`value` {any}",
+                  "name": "value",
+                  "type": "any"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Performs the low-level validations on the provided <code>value</code> that are done when\n<code>res.setHeader(name, value)</code> is called.</p>\n<p>Passing illegal value as <code>value</code> will result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>\n<ul>\n<li>Undefined value error is identified by <code>code: 'ERR_HTTP_INVALID_HEADER_VALUE'</code>.</li>\n<li>Invalid value character error is identified by <code>code: 'ERR_INVALID_CHAR'</code>.</li>\n</ul>\n<p>It is not necessary to use this method before passing headers to an HTTP request\nor response. The HTTP module will automatically validate such headers.</p>\n<p>Examples:</p>\n<pre><code class=\"language-js\">const { validateHeaderValue } = require('http');\n\ntry {\n  validateHeaderValue('x-my-header', undefined);\n} catch (err) {\n  err instanceof TypeError; // --> true\n  err.code === 'ERR_HTTP_INVALID_HEADER_VALUE'; // --> true\n  err.message; // --> 'Invalid value \"undefined\" for header \"x-my-header\"'\n}\n\ntry {\n  validateHeaderValue('x-my-header', 'oʊmɪɡə');\n} catch (err) {\n  err instanceof TypeError; // --> true\n  err.code === 'ERR_INVALID_CHAR'; // --> true\n  err.message; // --> 'Invalid character in header content [\"x-my-header\"]'\n}\n</code></pre>"
         }
       ],
       "type": "module",
-      "displayName": "HTTP"
+      "displayName": "HTTP",
+      "source": "doc/api/http.md"
     },
     {
       "textRaw": "HTTP/2",
@@ -37102,6 +41384,11 @@
           "v8.4.0"
         ],
         "changes": [
+          {
+            "version": "v14.17.0",
+            "pr-url": "https://github.com/nodejs/node/pull/36070",
+            "description": "It is possible to abort a request with an AbortSignal."
+          },
           {
             "version": "v10.10.0",
             "pr-url": "https://github.com/nodejs/node/pull/22466",
@@ -37112,7 +41399,7 @@
       "introduced_in": "v8.4.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/http2.js\">lib/http2.js</a></p>\n<p>The <code>http2</code> module provides an implementation of the <a href=\"https://tools.ietf.org/html/rfc7540\">HTTP/2</a> protocol. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/http2.js\">lib/http2.js</a></p>\n<p>The <code>http2</code> module provides an implementation of the <a href=\"https://tools.ietf.org/html/rfc7540\">HTTP/2</a> protocol. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Core API",
@@ -37137,6 +41424,15 @@
               "textRaw": "Headers object",
               "name": "headers_object",
               "desc": "<p>Headers are represented as own-properties on JavaScript objects. The property\nkeys will be serialized to lower-case. Property values should be strings (if\nthey are not they will be coerced to strings) or an <code>Array</code> of strings (in order\nto send more than one value per header field).</p>\n<pre><code class=\"language-js\">const headers = {\n  ':status': '200',\n  'content-type': 'text-plain',\n  'ABC': ['has', 'more', 'than', 'one', 'value']\n};\n\nstream.respond(headers);\n</code></pre>\n<p>Header objects passed to callback functions will have a <code>null</code> prototype. This\nmeans that normal JavaScript object methods such as\n<code>Object.prototype.toString()</code> and <code>Object.prototype.hasOwnProperty()</code> will\nnot work.</p>\n<p>For incoming headers:</p>\n<ul>\n<li>The <code>:status</code> header is converted to <code>number</code>.</li>\n<li>Duplicates of <code>:status</code>, <code>:method</code>, <code>:authority</code>, <code>:scheme</code>, <code>:path</code>,\n<code>:protocol</code>, <code>age</code>, <code>authorization</code>, <code>access-control-allow-credentials</code>,\n<code>access-control-max-age</code>, <code>access-control-request-method</code>, <code>content-encoding</code>,\n<code>content-language</code>, <code>content-length</code>, <code>content-location</code>, <code>content-md5</code>,\n<code>content-range</code>, <code>content-type</code>, <code>date</code>, <code>dnt</code>, <code>etag</code>, <code>expires</code>, <code>from</code>,\n<code>if-match</code>, <code>if-modified-since</code>, <code>if-none-match</code>, <code>if-range</code>,\n<code>if-unmodified-since</code>, <code>last-modified</code>, <code>location</code>, <code>max-forwards</code>,\n<code>proxy-authorization</code>, <code>range</code>, <code>referer</code>,<code>retry-after</code>, <code>tk</code>,\n<code>upgrade-insecure-requests</code>, <code>user-agent</code> or <code>x-content-type-options</code> are\ndiscarded.</li>\n<li><code>set-cookie</code> is always an array. Duplicates are added to the array.</li>\n<li>For duplicate <code>cookie</code> headers, the values are joined together with '; '.</li>\n<li>For all other headers, the values are joined together with ', '.</li>\n</ul>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream, headers) => {\n  console.log(headers[':path']);\n  console.log(headers.ABC);\n});\n</code></pre>",
+              "modules": [
+                {
+                  "textRaw": "Sensitive headers",
+                  "name": "sensitive_headers",
+                  "desc": "<p>HTTP2 headers can be marked as sensitive, which means that the HTTP/2\nheader compression algorithm will never index them. This can make sense for\nheader values with low entropy and that may be considered valuable to an\nattacker, for example <code>Cookie</code> or <code>Authorization</code>. To achieve this, add\nthe header name to the <code>[http2.sensitiveHeaders]</code> property as an array:</p>\n<pre><code class=\"language-js\">const headers = {\n  ':status': '200',\n  'content-type': 'text-plain',\n  'cookie': 'some-cookie',\n  'other-sensitive-header': 'very secret data',\n  [http2.sensitiveHeaders]: ['cookie', 'other-sensitive-header']\n};\n\nstream.respond(headers);\n</code></pre>\n<p>For some headers, such as <code>Authorization</code> and short <code>Cookie</code> headers,\nthis flag is set automatically.</p>\n<p>This property is also set for received headers. It will contain the names of\nall headers marked as sensitive, including ones marked that way automatically.</p>",
+                  "type": "module",
+                  "displayName": "Sensitive headers"
+                }
+              ],
               "type": "module",
               "displayName": "Headers object"
             },
@@ -37164,13 +41460,6 @@
               "type": "module",
               "displayName": "Settings object"
             },
-            {
-              "textRaw": "Using `options.selectPadding()`",
-              "name": "using_`options.selectpadding()`",
-              "desc": "<p>When <code>options.paddingStrategy</code> is equal to\n<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, the HTTP/2 implementation will\nconsult the <code>options.selectPadding()</code> callback function, if provided, to\ndetermine the specific amount of padding to use per <code>HEADERS</code> and <code>DATA</code> frame.</p>\n<p>The <code>options.selectPadding()</code> function receives two numeric arguments,\n<code>frameLen</code> and <code>maxFrameLen</code> and must return a number <code>N</code> such that\n<code>frameLen &#x3C;= N &#x3C;= maxFrameLen</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer({\n  paddingStrategy: http2.constants.PADDING_STRATEGY_CALLBACK,\n  selectPadding(frameLen, maxFrameLen) {\n    return maxFrameLen;\n  }\n});\n</code></pre>\n<p>The <code>options.selectPadding()</code> function is invoked once for <em>every</em> <code>HEADERS</code> and\n<code>DATA</code> frame. This has a definite noticeable impact on performance.</p>",
-              "type": "module",
-              "displayName": "Using `options.selectPadding()`"
-            },
             {
               "textRaw": "Error handling",
               "name": "error_handling",
@@ -37747,6 +42036,29 @@
                   ],
                   "desc": "<p>Calls <a href=\"net.html#net_socket_ref\"><code>ref()</code></a> on this <code>Http2Session</code>\ninstance's underlying <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.</p>"
                 },
+                {
+                  "textRaw": "`http2session.setLocalWindowSize(windowSize)`",
+                  "type": "method",
+                  "name": "setLocalWindowSize",
+                  "meta": {
+                    "added": [
+                      "v14.18.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`windowSize` {number}",
+                          "name": "windowSize",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Sets the local endpoint's window size.\nThe <code>windowSize</code> is the total window size to set, not\nthe delta.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\n\nconst server = http2.createServer();\nconst expectedWindowSize = 2 ** 20;\nserver.on('connect', (session) => {\n\n  // Set local window size to be 2 ** 20\n  session.setLocalWindowSize(expectedWindowSize);\n});\n</code></pre>"
+                },
                 {
                   "textRaw": "`http2session.setTimeout(msecs, callback)`",
                   "type": "method",
@@ -38038,13 +42350,19 @@
                               "name": "waitForTrailers",
                               "type": "boolean",
                               "desc": "When `true`, the `Http2Stream` will emit the `'wantTrailers'` event after the final `DATA` frame has been sent."
+                            },
+                            {
+                              "textRaw": "`signal` {AbortSignal} An AbortSignal that may be used to abort an ongoing request.",
+                              "name": "signal",
+                              "type": "AbortSignal",
+                              "desc": "An AbortSignal that may be used to abort an ongoing request."
                             }
                           ]
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>For HTTP/2 Client <code>Http2Session</code> instances only, the <code>http2session.request()</code>\ncreates and returns an <code>Http2Stream</code> instance that can be used to send an\nHTTP/2 request to the connected server.</p>\n<p>This method is only available if <code>http2session.type</code> is equal to\n<code>http2.constants.NGHTTP2_SESSION_CLIENT</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst clientSession = http2.connect('https://localhost:1234');\nconst {\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS\n} = http2.constants;\n\nconst req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });\nreq.on('response', (headers) => {\n  console.log(headers[HTTP2_HEADER_STATUS]);\n  req.on('data', (chunk) => { /* .. */ });\n  req.on('end', () => { /* .. */ });\n});\n</code></pre>\n<p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event\nis emitted immediately after queuing the last chunk of payload data to be sent.\nThe <code>http2stream.sendTrailers()</code> method can then be called to send trailing\nheaders to the peer.</p>\n<p>When <code>options.waitForTrailers</code> is set, the <code>Http2Stream</code> will not automatically\nclose when the final <code>DATA</code> frame is transmitted. User code must call either\n<code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the\n<code>Http2Stream</code>.</p>\n<p>The <code>:method</code> and <code>:path</code> pseudo-headers are not specified within <code>headers</code>,\nthey respectively default to:</p>\n<ul>\n<li><code>:method</code> = <code>'GET'</code></li>\n<li><code>:path</code> = <code>/</code></li>\n</ul>"
+                  "desc": "<p>For HTTP/2 Client <code>Http2Session</code> instances only, the <code>http2session.request()</code>\ncreates and returns an <code>Http2Stream</code> instance that can be used to send an\nHTTP/2 request to the connected server.</p>\n<p>This method is only available if <code>http2session.type</code> is equal to\n<code>http2.constants.NGHTTP2_SESSION_CLIENT</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst clientSession = http2.connect('https://localhost:1234');\nconst {\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS\n} = http2.constants;\n\nconst req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });\nreq.on('response', (headers) => {\n  console.log(headers[HTTP2_HEADER_STATUS]);\n  req.on('data', (chunk) => { /* .. */ });\n  req.on('end', () => { /* .. */ });\n});\n</code></pre>\n<p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event\nis emitted immediately after queuing the last chunk of payload data to be sent.\nThe <code>http2stream.sendTrailers()</code> method can then be called to send trailing\nheaders to the peer.</p>\n<p>When <code>options.waitForTrailers</code> is set, the <code>Http2Stream</code> will not automatically\nclose when the final <code>DATA</code> frame is transmitted. User code must call either\n<code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the\n<code>Http2Stream</code>.</p>\n<p>When <code>options.signal</code> is set with an <code>AbortSignal</code> and then <code>abort</code> on the\ncorresponding <code>AbortController</code> is called, the request will emit an <code>'error'</code>\nevent with an <code>AbortError</code> error.</p>\n<p>The <code>:method</code> and <code>:path</code> pseudo-headers are not specified within <code>headers</code>,\nthey respectively default to:</p>\n<ul>\n<li><code>:method</code> = <code>'GET'</code></li>\n<li><code>:path</code> = <code>/</code></li>\n</ul>"
                 }
               ]
             },
@@ -38246,7 +42564,8 @@
                   "name": "bufferSize",
                   "meta": {
                     "added": [
-                      "v11.2.0"
+                      "v11.2.0",
+                      "v10.16.0"
                     ],
                     "changes": []
                   },
@@ -38322,7 +42641,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Set to the <code>RST_STREAM</code> <a href=\"http2.html#error_codes\">error code</a> reported when the <code>Http2Stream</code> is\ndestroyed after either receiving an <code>RST_STREAM</code> frame from the connected peer,\ncalling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>. Will be\n<code>undefined</code> if the <code>Http2Stream</code> has not been closed.</p>"
+                  "desc": "<p>Set to the <code>RST_STREAM</code> <a href=\"http2.html#http2_error_codes_for_rst_stream_and_goaway\">error code</a> reported when the <code>Http2Stream</code> is\ndestroyed after either receiving an <code>RST_STREAM</code> frame from the connected peer,\ncalling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>. Will be\n<code>undefined</code> if the <code>Http2Stream</code> has not been closed.</p>"
                 },
                 {
                   "textRaw": "`sentHeaders` {HTTP/2 Headers Object}",
@@ -38698,9 +43017,9 @@
                     ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.5.0",
                         "pr-url": "https://github.com/nodejs/node/pull/33160",
-                        "description": "Allow explicity setting date headers."
+                        "description": "Allow explicitly setting date headers."
                       }
                     ]
                   },
@@ -38746,9 +43065,9 @@
                     ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.5.0",
                         "pr-url": "https://github.com/nodejs/node/pull/33160",
-                        "description": "Allow explicity setting date headers."
+                        "description": "Allow explicitly setting date headers."
                       },
                       {
                         "version": "v12.12.0",
@@ -38821,9 +43140,9 @@
                     ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.5.0",
                         "pr-url": "https://github.com/nodejs/node/pull/33160",
-                        "description": "Allow explicity setting date headers."
+                        "description": "Allow explicitly setting date headers."
                       },
                       {
                         "version": "v10.0.0",
@@ -38884,7 +43203,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Sends a regular file as the response. The <code>path</code> must specify a regular file\nor an <code>'error'</code> event will be emitted on the <code>Http2Stream</code> object.</p>\n<p>When used, the <code>Http2Stream</code> object's <code>Duplex</code> interface will be closed\nautomatically.</p>\n<p>The optional <code>options.statCheck</code> function may be specified to give user code\nan opportunity to set additional content headers based on the <code>fs.Stat</code> details\nof the given file:</p>\n<p>If an error occurs while attempting to read the file data, the <code>Http2Stream</code>\nwill be closed using an <code>RST_STREAM</code> frame using the standard <code>INTERNAL_ERROR</code>\ncode. If the <code>onError</code> callback is defined, then it will be called. Otherwise\nthe stream will be destroyed.</p>\n<p>Example using a file path:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  function statCheck(stat, headers) {\n    headers['last-modified'] = stat.mtime.toUTCString();\n  }\n\n  function onError(err) {\n    if (err.code === 'ENOENT') {\n      stream.respond({ ':status': 404 });\n    } else {\n      stream.respond({ ':status': 500 });\n    }\n    stream.end();\n  }\n\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { statCheck, onError });\n});\n</code></pre>\n<p>The <code>options.statCheck</code> function may also be used to cancel the send operation\nby returning <code>false</code>. For instance, a conditional request may check the stat\nresults to determine if the file has been modified to return an appropriate\n<code>304</code> response:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  function statCheck(stat, headers) {\n    // Check the stat here...\n    stream.respond({ ':status': 304 });\n    return false; // Cancel the send operation\n  }\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { statCheck });\n});\n</code></pre>\n<p>The <code>content-length</code> header field will be automatically set.</p>\n<p>The <code>offset</code> and <code>length</code> options may be used to limit the response to a\nspecific range subset. This can be used, for instance, to support HTTP Range\nrequests.</p>\n<p>The <code>options.onError</code> function may also be used to handle all the errors\nthat could happen before the delivery of the file is initiated. The\ndefault behavior is to destroy the stream.</p>\n<p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event\nwill be emitted immediately after queuing the last chunk of payload data to be\nsent. The <code>http2stream.sendTrailers()</code> method can then be used to sent trailing\nheader fields to the peer.</p>\n<p>When <code>options.waitForTrailers</code> is set, the <code>Http2Stream</code> will not automatically\nclose when the final <code>DATA</code> frame is transmitted. User code must call either\n<code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the\n<code>Http2Stream</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { waitForTrailers: true });\n  stream.on('wantTrailers', () => {\n    stream.sendTrailers({ ABC: 'some value to send' });\n  });\n});\n</code></pre>"
+                  "desc": "<p>Sends a regular file as the response. The <code>path</code> must specify a regular file\nor an <code>'error'</code> event will be emitted on the <code>Http2Stream</code> object.</p>\n<p>When used, the <code>Http2Stream</code> object's <code>Duplex</code> interface will be closed\nautomatically.</p>\n<p>The optional <code>options.statCheck</code> function may be specified to give user code\nan opportunity to set additional content headers based on the <code>fs.Stat</code> details\nof the given file:</p>\n<p>If an error occurs while attempting to read the file data, the <code>Http2Stream</code>\nwill be closed using an <code>RST_STREAM</code> frame using the standard <code>INTERNAL_ERROR</code>\ncode. If the <code>onError</code> callback is defined, then it will be called. Otherwise\nthe stream will be destroyed.</p>\n<p>Example using a file path:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  function statCheck(stat, headers) {\n    headers['last-modified'] = stat.mtime.toUTCString();\n  }\n\n  function onError(err) {\n    // stream.respond() can throw if the stream has been destroyed by\n    // the other side.\n    try {\n      if (err.code === 'ENOENT') {\n        stream.respond({ ':status': 404 });\n      } else {\n        stream.respond({ ':status': 500 });\n      }\n    } catch (err) {\n      // Perform actual error handling.\n      console.log(err);\n    }\n    stream.end();\n  }\n\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { statCheck, onError });\n});\n</code></pre>\n<p>The <code>options.statCheck</code> function may also be used to cancel the send operation\nby returning <code>false</code>. For instance, a conditional request may check the stat\nresults to determine if the file has been modified to return an appropriate\n<code>304</code> response:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  function statCheck(stat, headers) {\n    // Check the stat here...\n    stream.respond({ ':status': 304 });\n    return false; // Cancel the send operation\n  }\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { statCheck });\n});\n</code></pre>\n<p>The <code>content-length</code> header field will be automatically set.</p>\n<p>The <code>offset</code> and <code>length</code> options may be used to limit the response to a\nspecific range subset. This can be used, for instance, to support HTTP Range\nrequests.</p>\n<p>The <code>options.onError</code> function may also be used to handle all the errors\nthat could happen before the delivery of the file is initiated. The\ndefault behavior is to destroy the stream.</p>\n<p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event\nwill be emitted immediately after queuing the last chunk of payload data to be\nsent. The <code>http2stream.sendTrailers()</code> method can then be used to sent trailing\nheader fields to the peer.</p>\n<p>When <code>options.waitForTrailers</code> is set, the <code>Http2Stream</code> will not automatically\nclose when the final <code>DATA</code> frame is transmitted. User code must call either\n<code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the\n<code>Http2Stream</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { waitForTrailers: true });\n  stream.on('wantTrailers', () => {\n    stream.sendTrailers({ ABC: 'some value to send' });\n  });\n});\n</code></pre>"
                 }
               ],
               "properties": [
@@ -38949,68 +43268,26 @@
                     }
                   ],
                   "desc": "<p>If a <a href=\"http2.html#http2_event_request\"><code>'request'</code></a> listener is registered or <a href=\"http2.html#http2_http2_createserver_options_onrequesthandler\"><code>http2.createServer()</code></a> is\nsupplied a callback function, the <code>'checkContinue'</code> event is emitted each time\na request with an HTTP <code>Expect: 100-continue</code> is received. If this event is\nnot listened for, the server will automatically respond with a status\n<code>100 Continue</code> as appropriate.</p>\n<p>Handling this event involves calling <a href=\"http2.html#http2_response_writecontinue\"><code>response.writeContinue()</code></a> if the\nclient should continue to send the request body, or generating an appropriate\nHTTP response (e.g. 400 Bad Request) if the client should not continue to send\nthe request body.</p>\n<p>When this event is emitted and handled, the <a href=\"http2.html#http2_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
-                }
-              ]
-            },
-            {
-              "textRaw": "Class: `Http2SecureServer`",
-              "type": "class",
-              "name": "Http2SecureServer",
-              "meta": {
-                "added": [
-                  "v8.4.0"
-                ],
-                "changes": []
-              },
-              "desc": "<ul>\n<li>Extends: <a href=\"tls.html#tls_class_tls_server\" class=\"type\">&lt;tls.Server&gt;</a></li>\n</ul>\n<p>Instances of <code>Http2SecureServer</code> are created using the\n<code>http2.createSecureServer()</code> function. The <code>Http2SecureServer</code> class is not\nexported directly by the <code>http2</code> module.</p>",
-              "events": [
+                },
                 {
-                  "textRaw": "Event: `'checkContinue'`",
+                  "textRaw": "Event: `'connection'`",
                   "type": "event",
-                  "name": "checkContinue",
+                  "name": "connection",
                   "meta": {
                     "added": [
-                      "v8.5.0"
+                      "v8.4.0"
                     ],
                     "changes": []
                   },
                   "params": [
                     {
-                      "textRaw": "`request` {http2.Http2ServerRequest}",
-                      "name": "request",
-                      "type": "http2.Http2ServerRequest"
-                    },
-                    {
-                      "textRaw": "`response` {http2.Http2ServerResponse}",
-                      "name": "response",
-                      "type": "http2.Http2ServerResponse"
+                      "textRaw": "`socket` {stream.Duplex}",
+                      "name": "socket",
+                      "type": "stream.Duplex"
                     }
                   ],
-                  "desc": "<p>If a <a href=\"http2.html#http2_event_request\"><code>'request'</code></a> listener is registered or <a href=\"http2.html#http2_http2_createsecureserver_options_onrequesthandler\"><code>http2.createSecureServer()</code></a>\nis supplied a callback function, the <code>'checkContinue'</code> event is emitted each\ntime a request with an HTTP <code>Expect: 100-continue</code> is received. If this event\nis not listened for, the server will automatically respond with a status\n<code>100 Continue</code> as appropriate.</p>\n<p>Handling this event involves calling <a href=\"http2.html#http2_response_writecontinue\"><code>response.writeContinue()</code></a> if the\nclient should continue to send the request body, or generating an appropriate\nHTTP response (e.g. 400 Bad Request) if the client should not continue to send\nthe request body.</p>\n<p>When this event is emitted and handled, the <a href=\"http2.html#http2_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
-                }
-              ]
-            }
-          ],
-          "events": [
-            {
-              "textRaw": "Event: `'connection'`",
-              "type": "event",
-              "name": "connection",
-              "meta": {
-                "added": [
-                  "v8.4.0"
-                ],
-                "changes": []
-              },
-              "params": [
-                {
-                  "textRaw": "`socket` {stream.Duplex}",
-                  "name": "socket",
-                  "type": "stream.Duplex"
-                }
-              ],
-              "desc": "<p>This event is emitted when a new TCP stream is established. <code>socket</code> is\ntypically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>. Usually users will not want to\naccess this event.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>",
-              "events": [
+                  "desc": "<p>This event is emitted when a new TCP stream is established. <code>socket</code> is\ntypically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>. Usually users will not want to\naccess this event.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>"
+                },
                 {
                   "textRaw": "Event: `'request'`",
                   "type": "event",
@@ -39071,8 +43348,33 @@
                     ],
                     "changes": []
                   },
-                  "params": [],
-                  "desc": "<p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by\nan <code>Http2Session</code> associated with the server.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst {\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_CONTENT_TYPE\n} = http2.constants;\n\nconst server = http2.createServer();\nserver.on('stream', (stream, headers, flags) => {\n  const method = headers[HTTP2_HEADER_METHOD];\n  const path = headers[HTTP2_HEADER_PATH];\n  // ...\n  stream.respond({\n    [HTTP2_HEADER_STATUS]: 200,\n    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8'\n  });\n  stream.write('hello ');\n  stream.end('world');\n});\n</code></pre>"
+                  "params": [
+                    {
+                      "textRaw": "`stream` {Http2Stream} A reference to the stream",
+                      "name": "stream",
+                      "type": "Http2Stream",
+                      "desc": "A reference to the stream"
+                    },
+                    {
+                      "textRaw": "`headers` {HTTP/2 Headers Object} An object describing the headers",
+                      "name": "headers",
+                      "type": "HTTP/2 Headers Object",
+                      "desc": "An object describing the headers"
+                    },
+                    {
+                      "textRaw": "`flags` {number} The associated numeric flags",
+                      "name": "flags",
+                      "type": "number",
+                      "desc": "The associated numeric flags"
+                    },
+                    {
+                      "textRaw": "`rawHeaders` {Array} An array containing the raw header names followed by their respective values.",
+                      "name": "rawHeaders",
+                      "type": "Array",
+                      "desc": "An array containing the raw header names followed by their respective values."
+                    }
+                  ],
+                  "desc": "<p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by\nan <code>Http2Session</code> associated with the server.</p>\n<p>See also <a href=\"http2.html#http2_event_stream\"><code>Http2Session</code>'s <code>'stream'</code> event</a>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst {\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_CONTENT_TYPE\n} = http2.constants;\n\nconst server = http2.createServer();\nserver.on('stream', (stream, headers, flags) => {\n  const method = headers[HTTP2_HEADER_METHOD];\n  const path = headers[HTTP2_HEADER_PATH];\n  // ...\n  stream.respond({\n    [HTTP2_HEADER_STATUS]: 200,\n    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8'\n  });\n  stream.write('hello ');\n  stream.end('world');\n});\n</code></pre>"
                 },
                 {
                   "textRaw": "Event: `'timeout'`",
@@ -39082,10 +43384,16 @@
                     "added": [
                       "v8.4.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v13.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/27558",
+                        "description": "The default timeout changed from 120s to 0 (no timeout)."
+                      }
+                    ]
                   },
                   "params": [],
-                  "desc": "<p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for\na given number of milliseconds set using <code>http2server.setTimeout()</code>.\n<strong>Default:</strong> 2 minutes.</p>\n<p>To change the default timeout use the <a href=\"cli.html#cli_http_server_default_timeout_milliseconds\"><code>--http-server-default-timeout</code></a>\nflag.</p>"
+                  "desc": "<p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for\na given number of milliseconds set using <code>http2server.setTimeout()</code>.\n<strong>Default:</strong> 0 (no timeout)</p>"
                 }
               ],
               "methods": [
@@ -39120,7 +43428,13 @@
                     "added": [
                       "v8.4.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v13.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/27558",
+                        "description": "The default timeout changed from 120s to 0 (no timeout)."
+                      }
+                    ]
                   },
                   "signatures": [
                     {
@@ -39131,10 +43445,10 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`msecs` {number} **Default:** `120000` (2 minutes)",
+                          "textRaw": "`msecs` {number} **Default:** 0 (no timeout)",
                           "name": "msecs",
                           "type": "number",
-                          "default": "`120000` (2 minutes)"
+                          "default": "0 (no timeout)"
                         },
                         {
                           "textRaw": "`callback` {Function}",
@@ -39144,29 +43458,110 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Used to set the timeout value for http2 server requests,\nand sets a callback function that is called when there is no activity\non the <code>Http2Server</code> after <code>msecs</code> milliseconds.</p>\n<p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>\n<p>In case of no callback function were assigned, a new <code>ERR_INVALID_CALLBACK</code>\nerror will be thrown.</p>\n<p>To change the default timeout use the <a href=\"cli.html#cli_http_server_default_timeout_milliseconds\"><code>--http-server-default-timeout</code></a>\nflag.</p>"
+                  "desc": "<p>Used to set the timeout value for http2 server requests,\nand sets a callback function that is called when there is no activity\non the <code>Http2Server</code> after <code>msecs</code> milliseconds.</p>\n<p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>\n<p>In case if <code>callback</code> is not a function, a new <code>ERR_INVALID_CALLBACK</code>\nerror will be thrown.</p>"
+                },
+                {
+                  "textRaw": "`server.updateSettings([settings])`",
+                  "type": "method",
+                  "name": "updateSettings",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`settings` {HTTP/2 Settings Object}",
+                          "name": "settings",
+                          "type": "HTTP/2 Settings Object"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Used to update the server with the provided settings.</p>\n<p>Throws <code>ERR_HTTP2_INVALID_SETTING_VALUE</code> for invalid <code>settings</code> values.</p>\n<p>Throws <code>ERR_INVALID_ARG_TYPE</code> for invalid <code>settings</code> argument.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`timeout` {number} Timeout in milliseconds. **Default:** 0 (no timeout)",
+                  "type": "number",
+                  "name": "timeout",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "changes": [
+                      {
+                        "version": "v13.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/27558",
+                        "description": "The default timeout changed from 120s to 0 (no timeout)."
+                      }
+                    ]
+                  },
+                  "default": "0 (no timeout)",
+                  "desc": "<p>The number of milliseconds of inactivity before a socket is presumed\nto have timed out.</p>\n<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>\n<p>The socket timeout logic is set up on connection, so changing this\nvalue only affects new connections to the server, not any existing connections.</p>",
+                  "shortDesc": "Timeout in milliseconds."
                 }
               ]
             },
             {
-              "textRaw": "Event: `'connection'`",
-              "type": "event",
-              "name": "connection",
+              "textRaw": "Class: `Http2SecureServer`",
+              "type": "class",
+              "name": "Http2SecureServer",
               "meta": {
                 "added": [
                   "v8.4.0"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`socket` {stream.Duplex}",
-                  "name": "socket",
-                  "type": "stream.Duplex"
-                }
-              ],
-              "desc": "<p>This event is emitted when a new TCP stream is established, before the TLS\nhandshake begins. <code>socket</code> is typically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.\nUsually users will not want to access this event.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>",
+              "desc": "<ul>\n<li>Extends: <a href=\"tls.html#tls_class_tls_server\" class=\"type\">&lt;tls.Server&gt;</a></li>\n</ul>\n<p>Instances of <code>Http2SecureServer</code> are created using the\n<code>http2.createSecureServer()</code> function. The <code>Http2SecureServer</code> class is not\nexported directly by the <code>http2</code> module.</p>",
               "events": [
+                {
+                  "textRaw": "Event: `'checkContinue'`",
+                  "type": "event",
+                  "name": "checkContinue",
+                  "meta": {
+                    "added": [
+                      "v8.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`request` {http2.Http2ServerRequest}",
+                      "name": "request",
+                      "type": "http2.Http2ServerRequest"
+                    },
+                    {
+                      "textRaw": "`response` {http2.Http2ServerResponse}",
+                      "name": "response",
+                      "type": "http2.Http2ServerResponse"
+                    }
+                  ],
+                  "desc": "<p>If a <a href=\"http2.html#http2_event_request\"><code>'request'</code></a> listener is registered or <a href=\"http2.html#http2_http2_createsecureserver_options_onrequesthandler\"><code>http2.createSecureServer()</code></a>\nis supplied a callback function, the <code>'checkContinue'</code> event is emitted each\ntime a request with an HTTP <code>Expect: 100-continue</code> is received. If this event\nis not listened for, the server will automatically respond with a status\n<code>100 Continue</code> as appropriate.</p>\n<p>Handling this event involves calling <a href=\"http2.html#http2_response_writecontinue\"><code>response.writeContinue()</code></a> if the\nclient should continue to send the request body, or generating an appropriate\nHTTP response (e.g. 400 Bad Request) if the client should not continue to send\nthe request body.</p>\n<p>When this event is emitted and handled, the <a href=\"http2.html#http2_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
+                },
+                {
+                  "textRaw": "Event: `'connection'`",
+                  "type": "event",
+                  "name": "connection",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`socket` {stream.Duplex}",
+                      "name": "socket",
+                      "type": "stream.Duplex"
+                    }
+                  ],
+                  "desc": "<p>This event is emitted when a new TCP stream is established, before the TLS\nhandshake begins. <code>socket</code> is typically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.\nUsually users will not want to access this event.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>"
+                },
                 {
                   "textRaw": "Event: `'request'`",
                   "type": "event",
@@ -39227,8 +43622,33 @@
                     ],
                     "changes": []
                   },
-                  "params": [],
-                  "desc": "<p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by\nan <code>Http2Session</code> associated with the server.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst {\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_CONTENT_TYPE\n} = http2.constants;\n\nconst options = getOptionsSomehow();\n\nconst server = http2.createSecureServer(options);\nserver.on('stream', (stream, headers, flags) => {\n  const method = headers[HTTP2_HEADER_METHOD];\n  const path = headers[HTTP2_HEADER_PATH];\n  // ...\n  stream.respond({\n    [HTTP2_HEADER_STATUS]: 200,\n    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8'\n  });\n  stream.write('hello ');\n  stream.end('world');\n});\n</code></pre>"
+                  "params": [
+                    {
+                      "textRaw": "`stream` {Http2Stream} A reference to the stream",
+                      "name": "stream",
+                      "type": "Http2Stream",
+                      "desc": "A reference to the stream"
+                    },
+                    {
+                      "textRaw": "`headers` {HTTP/2 Headers Object} An object describing the headers",
+                      "name": "headers",
+                      "type": "HTTP/2 Headers Object",
+                      "desc": "An object describing the headers"
+                    },
+                    {
+                      "textRaw": "`flags` {number} The associated numeric flags",
+                      "name": "flags",
+                      "type": "number",
+                      "desc": "The associated numeric flags"
+                    },
+                    {
+                      "textRaw": "`rawHeaders` {Array} An array containing the raw header names followed by their respective values.",
+                      "name": "rawHeaders",
+                      "type": "Array",
+                      "desc": "An array containing the raw header names followed by their respective values."
+                    }
+                  ],
+                  "desc": "<p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by\nan <code>Http2Session</code> associated with the server.</p>\n<p>See also <a href=\"http2.html#http2_event_stream\"><code>Http2Session</code>'s <code>'stream'</code> event</a>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst {\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_CONTENT_TYPE\n} = http2.constants;\n\nconst options = getOptionsSomehow();\n\nconst server = http2.createSecureServer(options);\nserver.on('stream', (stream, headers, flags) => {\n  const method = headers[HTTP2_HEADER_METHOD];\n  const path = headers[HTTP2_HEADER_PATH];\n  // ...\n  stream.respond({\n    [HTTP2_HEADER_STATUS]: 200,\n    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8'\n  });\n  stream.write('hello ');\n  stream.end('world');\n});\n</code></pre>"
                 },
                 {
                   "textRaw": "Event: `'timeout'`",
@@ -39313,7 +43733,52 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Used to set the timeout value for http2 secure server requests,\nand sets a callback function that is called when there is no activity\non the <code>Http2SecureServer</code> after <code>msecs</code> milliseconds.</p>\n<p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>\n<p>In case of no callback function were assigned, a new <code>ERR_INVALID_CALLBACK</code>\nerror will be thrown.</p>"
+                  "desc": "<p>Used to set the timeout value for http2 secure server requests,\nand sets a callback function that is called when there is no activity\non the <code>Http2SecureServer</code> after <code>msecs</code> milliseconds.</p>\n<p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>\n<p>In case if <code>callback</code> is not a function, a new <code>ERR_INVALID_CALLBACK</code>\nerror will be thrown.</p>"
+                },
+                {
+                  "textRaw": "`server.updateSettings([settings])`",
+                  "type": "method",
+                  "name": "updateSettings",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`settings` {HTTP/2 Settings Object}",
+                          "name": "settings",
+                          "type": "HTTP/2 Settings Object"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Used to update the server with the provided settings.</p>\n<p>Throws <code>ERR_HTTP2_INVALID_SETTING_VALUE</code> for invalid <code>settings</code> values.</p>\n<p>Throws <code>ERR_INVALID_ARG_TYPE</code> for invalid <code>settings</code> argument.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`timeout` {number} Timeout in milliseconds. **Default:** 0 (no timeout)",
+                  "type": "number",
+                  "name": "timeout",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "changes": [
+                      {
+                        "version": "v13.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/27558",
+                        "description": "The default timeout changed from 120s to 0 (no timeout)."
+                      }
+                    ]
+                  },
+                  "default": "0 (no timeout)",
+                  "desc": "<p>The number of milliseconds of inactivity before a socket is presumed\nto have timed out.</p>\n<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>\n<p>The socket timeout logic is set up on connection, so changing this\nvalue only affects new connections to the server, not any existing connections.</p>",
+                  "shortDesc": "Timeout in milliseconds."
                 }
               ]
             }
@@ -39329,32 +43794,51 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.21.0",
+                    "version": "v14.16.0",
                     "pr-url": "https://github.com/nodejs-private/node-private/pull/250",
                     "description": "Added `unknownProtocolTimeout` option with a default of 10000."
                   },
                   {
                     "version": [
-                      "v12.18.0"
+                      "v14.4.0",
+                      "v12.18.0",
+                      "v10.21.0"
                     ],
-                    "pr-url": "https://github.com/nodejs-private/node-private/pull/206",
+                    "commit": "3948830ce6408be620b09a70bf66158623022af0",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/204",
                     "description": "Added `maxSettings` option with a default of 32."
                   },
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30534",
                     "description": "Added `maxSessionRejectedStreams` option with a default of 100."
                   },
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30534",
                     "description": "Added `maxSessionInvalidFrames` option with a default of 1000."
                   },
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29144",
+                    "description": "The `PADDING_STRATEGY_CALLBACK` has been made equivalent to providing `PADDING_STRATEGY_ALIGNED` and `selectPadding` has been removed."
+                  },
                   {
                     "version": "v12.4.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27782",
                     "description": "The `options` parameter now supports `net.createServer()` options."
                   },
+                  {
+                    "version": "v9.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/15752",
+                    "description": "Added the `Http1IncomingMessage` and `Http1ServerResponse` option."
+                  },
                   {
                     "version": "v8.9.3",
                     "pr-url": "https://github.com/nodejs/node/pull/17105",
@@ -39364,11 +43848,6 @@
                     "version": "v8.9.3",
                     "pr-url": "https://github.com/nodejs/node/pull/16676",
                     "description": "Added the `maxHeaderListPairs` option with a default limit of 128 header pairs."
-                  },
-                  {
-                    "version": "v9.6.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/15752",
-                    "description": "Added the `Http1IncomingMessage` and `Http1ServerResponse` option."
                   }
                 ]
               },
@@ -39434,24 +43913,19 @@
                           "desc": "The strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.",
                           "options": [
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_NONE",
-                              "desc": "Specifies that no padding is to be applied."
+                              "desc": "No padding is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding, determined by the internal implementation, is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_MAX",
-                              "desc": "Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied."
+                              "desc": "The maximum amount of padding, determined by the internal implementation, is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding.",
-                              "name": "http2.constants.PADDING_STRATEGY_CALLBACK",
-                              "desc": "Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding."
-                            },
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes.",
                               "name": "http2.constants.PADDING_STRATEGY_ALIGNED",
-                              "desc": "Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes."
+                              "desc": "Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes."
                             }
                           ]
                         },
@@ -39476,12 +43950,6 @@
                           "default": "`100`",
                           "desc": "Sets the maximum number of rejected upon creation streams that will be tolerated before the session is closed. Each rejection is associated with an `NGHTTP2_ENHANCE_YOUR_CALM` error that should tell the peer to not open any more streams, continuing to open streams is therefore regarded as a sign of a misbehaving peer."
                         },
-                        {
-                          "textRaw": "`selectPadding` {Function} When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][].",
-                          "name": "selectPadding",
-                          "type": "Function",
-                          "desc": "When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][]."
-                        },
                         {
                           "textRaw": "`settings` {HTTP/2 Settings Object} The initial settings to send to the remote peer upon connection.",
                           "name": "settings",
@@ -39551,27 +44019,41 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.21.0",
+                    "version": "v14.16.0",
                     "pr-url": "https://github.com/nodejs-private/node-private/pull/250",
                     "description": "Added `unknownProtocolTimeout` option with a default of 10000."
                   },
                   {
                     "version": [
-                      "v12.18.0"
+                      "v14.4.0",
+                      "v12.18.0",
+                      "v10.21.0"
                     ],
-                    "pr-url": "https://github.com/nodejs-private/node-private/pull/206",
+                    "commit": "3948830ce6408be620b09a70bf66158623022af0",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/204",
                     "description": "Added `maxSettings` option with a default of 32."
                   },
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30534",
                     "description": "Added `maxSessionRejectedStreams` option with a default of 100."
                   },
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30534",
                     "description": "Added `maxSessionInvalidFrames` option with a default of 1000."
                   },
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29144",
+                    "description": "The `PADDING_STRATEGY_CALLBACK` has been made equivalent to providing `PADDING_STRATEGY_ALIGNED` and `selectPadding` has been removed."
+                  },
                   {
                     "version": "v10.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22956",
@@ -39658,217 +44140,19 @@
                           "desc": "Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.",
                           "options": [
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is to be applied.",
-                              "name": "http2.constants.PADDING_STRATEGY_NONE",
-                              "desc": "Specifies that no padding is to be applied."
-                            },
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied.",
-                              "name": "http2.constants.PADDING_STRATEGY_MAX",
-                              "desc": "Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied."
-                            },
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding.",
-                              "name": "http2.constants.PADDING_STRATEGY_CALLBACK",
-                              "desc": "Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding."
-                            },
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes.",
-                              "name": "http2.constants.PADDING_STRATEGY_ALIGNED",
-                              "desc": "Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes."
-                            }
-                          ]
-                        },
-                        {
-                          "textRaw": "`peerMaxConcurrentStreams` {number} Sets the maximum number of concurrent streams for the remote peer as if a `SETTINGS` frame had been received. Will be overridden if the remote peer sets its own value for `maxConcurrentStreams`. **Default:** `100`.",
-                          "name": "peerMaxConcurrentStreams",
-                          "type": "number",
-                          "default": "`100`",
-                          "desc": "Sets the maximum number of concurrent streams for the remote peer as if a `SETTINGS` frame had been received. Will be overridden if the remote peer sets its own value for `maxConcurrentStreams`."
-                        },
-                        {
-                          "textRaw": "`maxSessionInvalidFrames` {integer} Sets the maximum number of invalid frames that will be tolerated before the session is closed. **Default:** `1000`.",
-                          "name": "maxSessionInvalidFrames",
-                          "type": "integer",
-                          "default": "`1000`",
-                          "desc": "Sets the maximum number of invalid frames that will be tolerated before the session is closed."
-                        },
-                        {
-                          "textRaw": "`maxSessionRejectedStreams` {integer} Sets the maximum number of rejected upon creation streams that will be tolerated before the session is closed. Each rejection is associated with an `NGHTTP2_ENHANCE_YOUR_CALM` error that should tell the peer to not open any more streams, continuing to open streams is therefore regarded as a sign of a misbehaving peer. **Default:** `100`.",
-                          "name": "maxSessionRejectedStreams",
-                          "type": "integer",
-                          "default": "`100`",
-                          "desc": "Sets the maximum number of rejected upon creation streams that will be tolerated before the session is closed. Each rejection is associated with an `NGHTTP2_ENHANCE_YOUR_CALM` error that should tell the peer to not open any more streams, continuing to open streams is therefore regarded as a sign of a misbehaving peer."
-                        },
-                        {
-                          "textRaw": "`selectPadding` {Function} When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][].",
-                          "name": "selectPadding",
-                          "type": "Function",
-                          "desc": "When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][]."
-                        },
-                        {
-                          "textRaw": "`settings` {HTTP/2 Settings Object} The initial settings to send to the remote peer upon connection.",
-                          "name": "settings",
-                          "type": "HTTP/2 Settings Object",
-                          "desc": "The initial settings to send to the remote peer upon connection."
-                        },
-                        {
-                          "textRaw": "...: Any [`tls.createServer()`][] options can be provided. For servers, the identity options (`pfx` or `key`/`cert`) are usually required.",
-                          "name": "...",
-                          "desc": "Any [`tls.createServer()`][] options can be provided. For servers, the identity options (`pfx` or `key`/`cert`) are usually required."
-                        },
-                        {
-                          "textRaw": "`origins` {string[]} An array of origin strings to send within an `ORIGIN` frame immediately following creation of a new server `Http2Session`.",
-                          "name": "origins",
-                          "type": "string[]",
-                          "desc": "An array of origin strings to send within an `ORIGIN` frame immediately following creation of a new server `Http2Session`."
-                        },
-                        {
-                          "textRaw": "`unknownProtocolTimeout` {number} Specifies a timeout in milliseconds that a server should wait when an [`'unknownProtocol'`][] event is emitted. If the socket has not been destroyed by that time the server will destroy it. **Default:** `10000`.",
-                          "name": "unknownProtocolTimeout",
-                          "type": "number",
-                          "default": "`10000`",
-                          "desc": "Specifies a timeout in milliseconds that a server should wait when an [`'unknownProtocol'`][] event is emitted. If the socket has not been destroyed by that time the server will destroy it."
-                        }
-                      ]
-                    },
-                    {
-                      "textRaw": "`onRequestHandler` {Function} See [Compatibility API][]",
-                      "name": "onRequestHandler",
-                      "type": "Function",
-                      "desc": "See [Compatibility API][]"
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p>Returns a <code>tls.Server</code> instance that creates and manages <code>Http2Session</code>\ninstances.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst fs = require('fs');\n\nconst options = {\n  key: fs.readFileSync('server-key.pem'),\n  cert: fs.readFileSync('server-cert.pem')\n};\n\n// Create a secure HTTP/2 server\nconst server = http2.createSecureServer(options);\n\nserver.on('stream', (stream, headers) => {\n  stream.respond({\n    'content-type': 'text/html; charset=utf-8',\n    ':status': 200\n  });\n  stream.end('&#x3C;h1>Hello World&#x3C;/h1>');\n});\n\nserver.listen(80);\n</code></pre>"
-            },
-            {
-              "textRaw": "`http2.connect(authority[, options][, listener])`",
-              "type": "method",
-              "name": "connect",
-              "meta": {
-                "added": [
-                  "v8.4.0"
-                ],
-                "changes": [
-                  {
-                    "version": "v12.21.0",
-                    "pr-url": "https://github.com/nodejs-private/node-private/pull/250",
-                    "description": "Added `unknownProtocolTimeout` option with a default of 10000."
-                  },
-                  {
-                    "version": [
-                      "v12.18.0"
-                    ],
-                    "pr-url": "https://github.com/nodejs-private/node-private/pull/206",
-                    "description": "Added `maxSettings` option with a default of 32."
-                  },
-                  {
-                    "version": "v8.9.3",
-                    "pr-url": "https://github.com/nodejs/node/pull/17105",
-                    "description": "Added the `maxOutstandingPings` option with a default limit of 10."
-                  },
-                  {
-                    "version": "v8.9.3",
-                    "pr-url": "https://github.com/nodejs/node/pull/16676",
-                    "description": "Added the `maxHeaderListPairs` option with a default limit of 128 header pairs."
-                  }
-                ]
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {ClientHttp2Session}",
-                    "name": "return",
-                    "type": "ClientHttp2Session"
-                  },
-                  "params": [
-                    {
-                      "textRaw": "`authority` {string|URL} The remote HTTP/2 server to connect to. This must be in the form of a minimal, valid URL with the `http://` or `https://` prefix, host name, and IP port (if a non-default port is used). Userinfo (user ID and password), path, querystring, and fragment details in the URL will be ignored.",
-                      "name": "authority",
-                      "type": "string|URL",
-                      "desc": "The remote HTTP/2 server to connect to. This must be in the form of a minimal, valid URL with the `http://` or `https://` prefix, host name, and IP port (if a non-default port is used). Userinfo (user ID and password), path, querystring, and fragment details in the URL will be ignored."
-                    },
-                    {
-                      "textRaw": "`options` {Object}",
-                      "name": "options",
-                      "type": "Object",
-                      "options": [
-                        {
-                          "textRaw": "`maxDeflateDynamicTableSize` {number} Sets the maximum dynamic table size for deflating header fields. **Default:** `4Kib`.",
-                          "name": "maxDeflateDynamicTableSize",
-                          "type": "number",
-                          "default": "`4Kib`",
-                          "desc": "Sets the maximum dynamic table size for deflating header fields."
-                        },
-                        {
-                          "textRaw": "`maxSettings` {number} Sets the maximum number of settings entries per `SETTINGS` frame. The minimum value allowed is `1`. **Default:** `32`.",
-                          "name": "maxSettings",
-                          "type": "number",
-                          "default": "`32`",
-                          "desc": "Sets the maximum number of settings entries per `SETTINGS` frame. The minimum value allowed is `1`."
-                        },
-                        {
-                          "textRaw": "`maxSessionMemory`{number} Sets the maximum memory that the `Http2Session` is permitted to use. The value is expressed in terms of number of megabytes, e.g. `1` equal 1 megabyte. The minimum value allowed is `1`. This is a credit based limit, existing `Http2Stream`s may cause this limit to be exceeded, but new `Http2Stream` instances will be rejected while this limit is exceeded. The current number of `Http2Stream` sessions, the current memory use of the header compression tables, current data queued to be sent, and unacknowledged `PING` and `SETTINGS` frames are all counted towards the current limit. **Default:** `10`.",
-                          "name": "maxSessionMemory",
-                          "type": "number",
-                          "default": "`10`",
-                          "desc": "Sets the maximum memory that the `Http2Session` is permitted to use. The value is expressed in terms of number of megabytes, e.g. `1` equal 1 megabyte. The minimum value allowed is `1`. This is a credit based limit, existing `Http2Stream`s may cause this limit to be exceeded, but new `Http2Stream` instances will be rejected while this limit is exceeded. The current number of `Http2Stream` sessions, the current memory use of the header compression tables, current data queued to be sent, and unacknowledged `PING` and `SETTINGS` frames are all counted towards the current limit."
-                        },
-                        {
-                          "textRaw": "`maxHeaderListPairs` {number} Sets the maximum number of header entries. This is similar to [`http.Server#maxHeadersCount`][] or [`http.ClientRequest#maxHeadersCount`][]. The minimum value is `1`. **Default:** `128`.",
-                          "name": "maxHeaderListPairs",
-                          "type": "number",
-                          "default": "`128`",
-                          "desc": "Sets the maximum number of header entries. This is similar to [`http.Server#maxHeadersCount`][] or [`http.ClientRequest#maxHeadersCount`][]. The minimum value is `1`."
-                        },
-                        {
-                          "textRaw": "`maxOutstandingPings` {number} Sets the maximum number of outstanding, unacknowledged pings. **Default:** `10`.",
-                          "name": "maxOutstandingPings",
-                          "type": "number",
-                          "default": "`10`",
-                          "desc": "Sets the maximum number of outstanding, unacknowledged pings."
-                        },
-                        {
-                          "textRaw": "`maxReservedRemoteStreams` {number} Sets the maximum number of reserved push streams the client will accept at any given time. Once the current number of currently reserved push streams exceeds reaches this limit, new push streams sent by the server will be automatically rejected. The minimum allowed value is 0. The maximum allowed value is 2<sup>32</sup>-1. A negative value sets this option to the maximum allowed value. **Default:** `200`.",
-                          "name": "maxReservedRemoteStreams",
-                          "type": "number",
-                          "default": "`200`",
-                          "desc": "Sets the maximum number of reserved push streams the client will accept at any given time. Once the current number of currently reserved push streams exceeds reaches this limit, new push streams sent by the server will be automatically rejected. The minimum allowed value is 0. The maximum allowed value is 2<sup>32</sup>-1. A negative value sets this option to the maximum allowed value."
-                        },
-                        {
-                          "textRaw": "`maxSendHeaderBlockLength` {number} Sets the maximum allowed size for a serialized, compressed block of headers. Attempts to send headers that exceed this limit will result in a `'frameError'` event being emitted and the stream being closed and destroyed.",
-                          "name": "maxSendHeaderBlockLength",
-                          "type": "number",
-                          "desc": "Sets the maximum allowed size for a serialized, compressed block of headers. Attempts to send headers that exceed this limit will result in a `'frameError'` event being emitted and the stream being closed and destroyed."
-                        },
-                        {
-                          "textRaw": "`paddingStrategy` {number} Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames. **Default:** `http2.constants.PADDING_STRATEGY_NONE`. Value may be one of:",
-                          "name": "paddingStrategy",
-                          "type": "number",
-                          "default": "`http2.constants.PADDING_STRATEGY_NONE`. Value may be one of:",
-                          "desc": "Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.",
-                          "options": [
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_NONE",
-                              "desc": "Specifies that no padding is to be applied."
+                              "desc": "No padding is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding, determined by the internal implementation, is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_MAX",
-                              "desc": "Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied."
+                              "desc": "The maximum amount of padding, determined by the internal implementation, is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding.",
-                              "name": "http2.constants.PADDING_STRATEGY_CALLBACK",
-                              "desc": "Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding."
-                            },
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes.",
                               "name": "http2.constants.PADDING_STRATEGY_ALIGNED",
-                              "desc": "Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes."
+                              "desc": "Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes."
                             }
                           ]
                         },
@@ -39880,10 +44164,194 @@
                           "desc": "Sets the maximum number of concurrent streams for the remote peer as if a `SETTINGS` frame had been received. Will be overridden if the remote peer sets its own value for `maxConcurrentStreams`."
                         },
                         {
-                          "textRaw": "`selectPadding` {Function} When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][].",
-                          "name": "selectPadding",
-                          "type": "Function",
-                          "desc": "When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][]."
+                          "textRaw": "`maxSessionInvalidFrames` {integer} Sets the maximum number of invalid frames that will be tolerated before the session is closed. **Default:** `1000`.",
+                          "name": "maxSessionInvalidFrames",
+                          "type": "integer",
+                          "default": "`1000`",
+                          "desc": "Sets the maximum number of invalid frames that will be tolerated before the session is closed."
+                        },
+                        {
+                          "textRaw": "`maxSessionRejectedStreams` {integer} Sets the maximum number of rejected upon creation streams that will be tolerated before the session is closed. Each rejection is associated with an `NGHTTP2_ENHANCE_YOUR_CALM` error that should tell the peer to not open any more streams, continuing to open streams is therefore regarded as a sign of a misbehaving peer. **Default:** `100`.",
+                          "name": "maxSessionRejectedStreams",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "Sets the maximum number of rejected upon creation streams that will be tolerated before the session is closed. Each rejection is associated with an `NGHTTP2_ENHANCE_YOUR_CALM` error that should tell the peer to not open any more streams, continuing to open streams is therefore regarded as a sign of a misbehaving peer."
+                        },
+                        {
+                          "textRaw": "`settings` {HTTP/2 Settings Object} The initial settings to send to the remote peer upon connection.",
+                          "name": "settings",
+                          "type": "HTTP/2 Settings Object",
+                          "desc": "The initial settings to send to the remote peer upon connection."
+                        },
+                        {
+                          "textRaw": "...: Any [`tls.createServer()`][] options can be provided. For servers, the identity options (`pfx` or `key`/`cert`) are usually required.",
+                          "name": "...",
+                          "desc": "Any [`tls.createServer()`][] options can be provided. For servers, the identity options (`pfx` or `key`/`cert`) are usually required."
+                        },
+                        {
+                          "textRaw": "`origins` {string[]} An array of origin strings to send within an `ORIGIN` frame immediately following creation of a new server `Http2Session`.",
+                          "name": "origins",
+                          "type": "string[]",
+                          "desc": "An array of origin strings to send within an `ORIGIN` frame immediately following creation of a new server `Http2Session`."
+                        },
+                        {
+                          "textRaw": "`unknownProtocolTimeout` {number} Specifies a timeout in milliseconds that a server should wait when an [`'unknownProtocol'`][] event is emitted. If the socket has not been destroyed by that time the server will destroy it. **Default:** `10000`.",
+                          "name": "unknownProtocolTimeout",
+                          "type": "number",
+                          "default": "`10000`",
+                          "desc": "Specifies a timeout in milliseconds that a server should wait when an [`'unknownProtocol'`][] event is emitted. If the socket has not been destroyed by that time the server will destroy it."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`onRequestHandler` {Function} See [Compatibility API][]",
+                      "name": "onRequestHandler",
+                      "type": "Function",
+                      "desc": "See [Compatibility API][]"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns a <code>tls.Server</code> instance that creates and manages <code>Http2Session</code>\ninstances.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst fs = require('fs');\n\nconst options = {\n  key: fs.readFileSync('server-key.pem'),\n  cert: fs.readFileSync('server-cert.pem')\n};\n\n// Create a secure HTTP/2 server\nconst server = http2.createSecureServer(options);\n\nserver.on('stream', (stream, headers) => {\n  stream.respond({\n    'content-type': 'text/html; charset=utf-8',\n    ':status': 200\n  });\n  stream.end('&#x3C;h1>Hello World&#x3C;/h1>');\n});\n\nserver.listen(80);\n</code></pre>"
+            },
+            {
+              "textRaw": "`http2.connect(authority[, options][, listener])`",
+              "type": "method",
+              "name": "connect",
+              "meta": {
+                "added": [
+                  "v8.4.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.16.0",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/250",
+                    "description": "Added `unknownProtocolTimeout` option with a default of 10000."
+                  },
+                  {
+                    "version": [
+                      "v14.4.0",
+                      "v12.18.0",
+                      "v10.21.0"
+                    ],
+                    "commit": "3948830ce6408be620b09a70bf66158623022af0",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/204",
+                    "description": "Added `maxSettings` option with a default of 32."
+                  },
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29144",
+                    "description": "The `PADDING_STRATEGY_CALLBACK` has been made equivalent to providing `PADDING_STRATEGY_ALIGNED` and `selectPadding` has been removed."
+                  },
+                  {
+                    "version": "v8.9.3",
+                    "pr-url": "https://github.com/nodejs/node/pull/17105",
+                    "description": "Added the `maxOutstandingPings` option with a default limit of 10."
+                  },
+                  {
+                    "version": "v8.9.3",
+                    "pr-url": "https://github.com/nodejs/node/pull/16676",
+                    "description": "Added the `maxHeaderListPairs` option with a default limit of 128 header pairs."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {ClientHttp2Session}",
+                    "name": "return",
+                    "type": "ClientHttp2Session"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`authority` {string|URL} The remote HTTP/2 server to connect to. This must be in the form of a minimal, valid URL with the `http://` or `https://` prefix, host name, and IP port (if a non-default port is used). Userinfo (user ID and password), path, querystring, and fragment details in the URL will be ignored.",
+                      "name": "authority",
+                      "type": "string|URL",
+                      "desc": "The remote HTTP/2 server to connect to. This must be in the form of a minimal, valid URL with the `http://` or `https://` prefix, host name, and IP port (if a non-default port is used). Userinfo (user ID and password), path, querystring, and fragment details in the URL will be ignored."
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`maxDeflateDynamicTableSize` {number} Sets the maximum dynamic table size for deflating header fields. **Default:** `4Kib`.",
+                          "name": "maxDeflateDynamicTableSize",
+                          "type": "number",
+                          "default": "`4Kib`",
+                          "desc": "Sets the maximum dynamic table size for deflating header fields."
+                        },
+                        {
+                          "textRaw": "`maxSettings` {number} Sets the maximum number of settings entries per `SETTINGS` frame. The minimum value allowed is `1`. **Default:** `32`.",
+                          "name": "maxSettings",
+                          "type": "number",
+                          "default": "`32`",
+                          "desc": "Sets the maximum number of settings entries per `SETTINGS` frame. The minimum value allowed is `1`."
+                        },
+                        {
+                          "textRaw": "`maxSessionMemory`{number} Sets the maximum memory that the `Http2Session` is permitted to use. The value is expressed in terms of number of megabytes, e.g. `1` equal 1 megabyte. The minimum value allowed is `1`. This is a credit based limit, existing `Http2Stream`s may cause this limit to be exceeded, but new `Http2Stream` instances will be rejected while this limit is exceeded. The current number of `Http2Stream` sessions, the current memory use of the header compression tables, current data queued to be sent, and unacknowledged `PING` and `SETTINGS` frames are all counted towards the current limit. **Default:** `10`.",
+                          "name": "maxSessionMemory",
+                          "type": "number",
+                          "default": "`10`",
+                          "desc": "Sets the maximum memory that the `Http2Session` is permitted to use. The value is expressed in terms of number of megabytes, e.g. `1` equal 1 megabyte. The minimum value allowed is `1`. This is a credit based limit, existing `Http2Stream`s may cause this limit to be exceeded, but new `Http2Stream` instances will be rejected while this limit is exceeded. The current number of `Http2Stream` sessions, the current memory use of the header compression tables, current data queued to be sent, and unacknowledged `PING` and `SETTINGS` frames are all counted towards the current limit."
+                        },
+                        {
+                          "textRaw": "`maxHeaderListPairs` {number} Sets the maximum number of header entries. This is similar to [`http.Server#maxHeadersCount`][] or [`http.ClientRequest#maxHeadersCount`][]. The minimum value is `1`. **Default:** `128`.",
+                          "name": "maxHeaderListPairs",
+                          "type": "number",
+                          "default": "`128`",
+                          "desc": "Sets the maximum number of header entries. This is similar to [`http.Server#maxHeadersCount`][] or [`http.ClientRequest#maxHeadersCount`][]. The minimum value is `1`."
+                        },
+                        {
+                          "textRaw": "`maxOutstandingPings` {number} Sets the maximum number of outstanding, unacknowledged pings. **Default:** `10`.",
+                          "name": "maxOutstandingPings",
+                          "type": "number",
+                          "default": "`10`",
+                          "desc": "Sets the maximum number of outstanding, unacknowledged pings."
+                        },
+                        {
+                          "textRaw": "`maxReservedRemoteStreams` {number} Sets the maximum number of reserved push streams the client will accept at any given time. Once the current number of currently reserved push streams exceeds reaches this limit, new push streams sent by the server will be automatically rejected. The minimum allowed value is 0. The maximum allowed value is 2<sup>32</sup>-1. A negative value sets this option to the maximum allowed value. **Default:** `200`.",
+                          "name": "maxReservedRemoteStreams",
+                          "type": "number",
+                          "default": "`200`",
+                          "desc": "Sets the maximum number of reserved push streams the client will accept at any given time. Once the current number of currently reserved push streams exceeds reaches this limit, new push streams sent by the server will be automatically rejected. The minimum allowed value is 0. The maximum allowed value is 2<sup>32</sup>-1. A negative value sets this option to the maximum allowed value."
+                        },
+                        {
+                          "textRaw": "`maxSendHeaderBlockLength` {number} Sets the maximum allowed size for a serialized, compressed block of headers. Attempts to send headers that exceed this limit will result in a `'frameError'` event being emitted and the stream being closed and destroyed.",
+                          "name": "maxSendHeaderBlockLength",
+                          "type": "number",
+                          "desc": "Sets the maximum allowed size for a serialized, compressed block of headers. Attempts to send headers that exceed this limit will result in a `'frameError'` event being emitted and the stream being closed and destroyed."
+                        },
+                        {
+                          "textRaw": "`paddingStrategy` {number} Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames. **Default:** `http2.constants.PADDING_STRATEGY_NONE`. Value may be one of:",
+                          "name": "paddingStrategy",
+                          "type": "number",
+                          "default": "`http2.constants.PADDING_STRATEGY_NONE`. Value may be one of:",
+                          "desc": "Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.",
+                          "options": [
+                            {
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.",
+                              "name": "http2.constants.PADDING_STRATEGY_NONE",
+                              "desc": "No padding is applied."
+                            },
+                            {
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding, determined by the internal implementation, is applied.",
+                              "name": "http2.constants.PADDING_STRATEGY_MAX",
+                              "desc": "The maximum amount of padding, determined by the internal implementation, is applied."
+                            },
+                            {
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes.",
+                              "name": "http2.constants.PADDING_STRATEGY_ALIGNED",
+                              "desc": "Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes."
+                            }
+                          ]
+                        },
+                        {
+                          "textRaw": "`peerMaxConcurrentStreams` {number} Sets the maximum number of concurrent streams for the remote peer as if a `SETTINGS` frame had been received. Will be overridden if the remote peer sets its own value for `maxConcurrentStreams`. **Default:** `100`.",
+                          "name": "peerMaxConcurrentStreams",
+                          "type": "number",
+                          "default": "`100`",
+                          "desc": "Sets the maximum number of concurrent streams for the remote peer as if a `SETTINGS` frame had been received. Will be overridden if the remote peer sets its own value for `maxConcurrentStreams`."
                         },
                         {
                           "textRaw": "`protocol` {string} The protocol to connect with, if not set in the `authority`. Value may be either `'http:'` or `'https:'`. **Default:** `'https:'`",
@@ -39998,9 +44466,9 @@
                   },
                   "params": [
                     {
-                      "textRaw": "`buf` {Buffer|Uint8Array} The packed settings.",
+                      "textRaw": "`buf` {Buffer|TypedArray} The packed settings.",
                       "name": "buf",
-                      "type": "Buffer|Uint8Array",
+                      "type": "Buffer|TypedArray",
                       "desc": "The packed settings."
                     }
                   ]
@@ -40023,11 +44491,23 @@
                 {
                   "textRaw": "Error codes for `RST_STREAM` and `GOAWAY`",
                   "name": "error_codes_for_`rst_stream`_and_`goaway`",
-                  "desc": "<p><a id=\"error_codes\"></a></p>\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Name</th>\n<th>Constant</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>0x00</code></td>\n<td>No Error</td>\n<td><code>http2.constants.NGHTTP2_NO_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x01</code></td>\n<td>Protocol Error</td>\n<td><code>http2.constants.NGHTTP2_PROTOCOL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x02</code></td>\n<td>Internal Error</td>\n<td><code>http2.constants.NGHTTP2_INTERNAL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x03</code></td>\n<td>Flow Control Error</td>\n<td><code>http2.constants.NGHTTP2_FLOW_CONTROL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x04</code></td>\n<td>Settings Timeout</td>\n<td><code>http2.constants.NGHTTP2_SETTINGS_TIMEOUT</code></td>\n</tr>\n<tr>\n<td><code>0x05</code></td>\n<td>Stream Closed</td>\n<td><code>http2.constants.NGHTTP2_STREAM_CLOSED</code></td>\n</tr>\n<tr>\n<td><code>0x06</code></td>\n<td>Frame Size Error</td>\n<td><code>http2.constants.NGHTTP2_FRAME_SIZE_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x07</code></td>\n<td>Refused Stream</td>\n<td><code>http2.constants.NGHTTP2_REFUSED_STREAM</code></td>\n</tr>\n<tr>\n<td><code>0x08</code></td>\n<td>Cancel</td>\n<td><code>http2.constants.NGHTTP2_CANCEL</code></td>\n</tr>\n<tr>\n<td><code>0x09</code></td>\n<td>Compression Error</td>\n<td><code>http2.constants.NGHTTP2_COMPRESSION_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x0a</code></td>\n<td>Connect Error</td>\n<td><code>http2.constants.NGHTTP2_CONNECT_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x0b</code></td>\n<td>Enhance Your Calm</td>\n<td><code>http2.constants.NGHTTP2_ENHANCE_YOUR_CALM</code></td>\n</tr>\n<tr>\n<td><code>0x0c</code></td>\n<td>Inadequate Security</td>\n<td><code>http2.constants.NGHTTP2_INADEQUATE_SECURITY</code></td>\n</tr>\n<tr>\n<td><code>0x0d</code></td>\n<td>HTTP/1.1 Required</td>\n<td><code>http2.constants.NGHTTP2_HTTP_1_1_REQUIRED</code></td>\n</tr>\n</tbody>\n</table>\n<p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for\na given number of milliseconds set using <code>http2server.setTimeout()</code>.</p>",
+                  "desc": "<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Name</th>\n<th>Constant</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>0x00</code></td>\n<td>No Error</td>\n<td><code>http2.constants.NGHTTP2_NO_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x01</code></td>\n<td>Protocol Error</td>\n<td><code>http2.constants.NGHTTP2_PROTOCOL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x02</code></td>\n<td>Internal Error</td>\n<td><code>http2.constants.NGHTTP2_INTERNAL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x03</code></td>\n<td>Flow Control Error</td>\n<td><code>http2.constants.NGHTTP2_FLOW_CONTROL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x04</code></td>\n<td>Settings Timeout</td>\n<td><code>http2.constants.NGHTTP2_SETTINGS_TIMEOUT</code></td>\n</tr>\n<tr>\n<td><code>0x05</code></td>\n<td>Stream Closed</td>\n<td><code>http2.constants.NGHTTP2_STREAM_CLOSED</code></td>\n</tr>\n<tr>\n<td><code>0x06</code></td>\n<td>Frame Size Error</td>\n<td><code>http2.constants.NGHTTP2_FRAME_SIZE_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x07</code></td>\n<td>Refused Stream</td>\n<td><code>http2.constants.NGHTTP2_REFUSED_STREAM</code></td>\n</tr>\n<tr>\n<td><code>0x08</code></td>\n<td>Cancel</td>\n<td><code>http2.constants.NGHTTP2_CANCEL</code></td>\n</tr>\n<tr>\n<td><code>0x09</code></td>\n<td>Compression Error</td>\n<td><code>http2.constants.NGHTTP2_COMPRESSION_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x0a</code></td>\n<td>Connect Error</td>\n<td><code>http2.constants.NGHTTP2_CONNECT_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x0b</code></td>\n<td>Enhance Your Calm</td>\n<td><code>http2.constants.NGHTTP2_ENHANCE_YOUR_CALM</code></td>\n</tr>\n<tr>\n<td><code>0x0c</code></td>\n<td>Inadequate Security</td>\n<td><code>http2.constants.NGHTTP2_INADEQUATE_SECURITY</code></td>\n</tr>\n<tr>\n<td><code>0x0d</code></td>\n<td>HTTP/1.1 Required</td>\n<td><code>http2.constants.NGHTTP2_HTTP_1_1_REQUIRED</code></td>\n</tr>\n</tbody>\n</table>\n<p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for\na given number of milliseconds set using <code>http2server.setTimeout()</code>.</p>",
                   "type": "module",
                   "displayName": "Error codes for `RST_STREAM` and `GOAWAY`"
                 }
               ]
+            },
+            {
+              "textRaw": "`sensitiveHeaders` {symbol}",
+              "type": "symbol",
+              "name": "sensitiveHeaders",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>This symbol can be set as a property on the HTTP/2 headers object with an array\nvalue in order to provide a list of headers considered sensitive.\nSee <a href=\"http2.html#http2_sensitive_headers\">Sensitive headers</a> for more details.</p>"
             }
           ],
           "type": "module",
@@ -40123,6 +44603,23 @@
                   },
                   "desc": "<p>The <code>request.complete</code> property will be <code>true</code> if the request has\nbeen completed, aborted, or destroyed.</p>"
                 },
+                {
+                  "textRaw": "`connection` {net.Socket|tls.TLSSocket}",
+                  "type": "net.Socket|tls.TLSSocket",
+                  "name": "connection",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "deprecated": [
+                      "v13.0.0"
+                    ],
+                    "changes": []
+                  },
+                  "stability": 0,
+                  "stabilityText": "Deprecated. Use [`request.socket`][].",
+                  "desc": "<p>See <a href=\"http2.html#http2_request_socket\"><code>request.socket</code></a>.</p>"
+                },
                 {
                   "textRaw": "`headers` {Object}",
                   "type": "Object",
@@ -40241,7 +44738,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Request URL string. This contains only the URL that is present in the actual\nHTTP request. If the request is:</p>\n<pre><code class=\"language-http\">GET /status?name=ryan HTTP/1.1\nAccept: text/plain\n</code></pre>\n<p>Then <code>request.url</code> will be:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">'/status?name=ryan'\n</code></pre>\n<p>To parse the url into its parts, <code>require('url').parse(request.url)</code>\ncan be used:</p>\n<pre><code class=\"language-console\">$ node\n> require('url').parse('/status?name=ryan')\nUrl {\n  protocol: null,\n  slashes: null,\n  auth: null,\n  host: null,\n  port: null,\n  hostname: null,\n  hash: null,\n  search: '?name=ryan',\n  query: 'name=ryan',\n  pathname: '/status',\n  path: '/status?name=ryan',\n  href: '/status?name=ryan' }\n</code></pre>\n<p>To obtain the parameters from the query string, use the\n<code>require('querystring').parse()</code> function or pass\n<code>true</code> as the second argument to <code>require('url').parse()</code>.</p>\n<pre><code class=\"language-console\">$ node\n> require('url').parse('/status?name=ryan', true)\nUrl {\n  protocol: null,\n  slashes: null,\n  auth: null,\n  host: null,\n  port: null,\n  hostname: null,\n  hash: null,\n  search: '?name=ryan',\n  query: { name: 'ryan' },\n  pathname: '/status',\n  path: '/status?name=ryan',\n  href: '/status?name=ryan' }\n</code></pre>"
+                  "desc": "<p>Request URL string. This contains only the URL that is present in the actual\nHTTP request. If the request is:</p>\n<pre><code class=\"language-http\">GET /status?name=ryan HTTP/1.1\nAccept: text/plain\n</code></pre>\n<p>Then <code>request.url</code> will be:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">'/status?name=ryan'\n</code></pre>\n<p>To parse the url into its parts, <code>new URL()</code> can be used:</p>\n<pre><code class=\"language-console\">$ node\n> new URL('/status?name=ryan', 'http://example.com')\nURL {\n  href: 'http://example.com/status?name=ryan',\n  origin: 'http://example.com',\n  protocol: 'http:',\n  username: '',\n  password: '',\n  host: 'example.com',\n  hostname: 'example.com',\n  port: '',\n  pathname: '/status',\n  search: '?name=ryan',\n  searchParams: URLSearchParams { 'name' => 'ryan' },\n  hash: ''\n}\n</code></pre>"
                 }
               ],
               "methods": [
@@ -40366,6 +44863,49 @@
                   ],
                   "desc": "<p>This method adds HTTP trailing headers (a header but at the end of the\nmessage) to the response.</p>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
                 },
+                {
+                  "textRaw": "`response.createPushResponse(headers, callback)`",
+                  "type": "method",
+                  "name": "createPushResponse",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`headers` {HTTP/2 Headers Object} An object describing the headers",
+                          "name": "headers",
+                          "type": "HTTP/2 Headers Object",
+                          "desc": "An object describing the headers"
+                        },
+                        {
+                          "textRaw": "`callback` {Function} Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method",
+                          "name": "callback",
+                          "type": "Function",
+                          "desc": "Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method",
+                          "options": [
+                            {
+                              "textRaw": "`err` {Error}",
+                              "name": "err",
+                              "type": "Error"
+                            },
+                            {
+                              "textRaw": "`res` {http2.Http2ServerResponse} The newly-created `Http2ServerResponse` object",
+                              "name": "res",
+                              "type": "http2.Http2ServerResponse",
+                              "desc": "The newly-created `Http2ServerResponse` object"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Call <a href=\"http2.html#http2_http2stream_pushstream_headers_options_callback\"><code>http2stream.pushStream()</code></a> with the given headers, and wrap the\ngiven <a href=\"http2.html#http2_class_http2stream\"><code>Http2Stream</code></a> on a newly created <code>Http2ServerResponse</code> as the callback\nparameter if successful. When <code>Http2ServerRequest</code> is closed, the callback is\ncalled with an error <code>ERR_HTTP2_INVALID_STREAM</code>.</p>"
+                },
                 {
                   "textRaw": "`response.end([data[, encoding]][, callback])`",
                   "type": "method",
@@ -40659,7 +45199,10 @@
                     ],
                     "changes": [
                       {
-                        "version": "v11.10.0",
+                        "version": [
+                          "v11.10.0",
+                          "v10.17.0"
+                        ],
                         "pr-url": "https://github.com/nodejs/node/pull/25974",
                         "description": "Return `this` from `writeHead()` to allow chaining with `end()`."
                       }
@@ -40691,50 +45234,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Sends a response header to the request. The status code is a 3-digit HTTP\nstatus code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.</p>\n<p>Returns a reference to the <code>Http2ServerResponse</code>, so that calls can be chained.</p>\n<p>For compatibility with <a href=\"http.html\">HTTP/1</a>, a human-readable <code>statusMessage</code> may be\npassed as the second argument. However, because the <code>statusMessage</code> has no\nmeaning within HTTP/2, the argument will have no effect and a process warning\nwill be emitted.</p>\n<pre><code class=\"language-js\">const body = 'hello world';\nresponse.writeHead(200, {\n  'Content-Length': Buffer.byteLength(body),\n  'Content-Type': 'text/plain; charset=utf-8' });\n</code></pre>\n<p><code>Content-Length</code> is given in bytes not characters. The\n<code>Buffer.byteLength()</code> API may be used to determine the number of bytes in a\ngiven encoding. On outbound messages, Node.js does not check if Content-Length\nand the length of the body being transmitted are equal or not. However, when\nreceiving messages, Node.js will automatically reject messages when the\n<code>Content-Length</code> does not match the actual payload size.</p>\n<p>This method may be called at most one time on a message before\n<a href=\"http2.html#http2_response_end_data_encoding_callback\"><code>response.end()</code></a> is called.</p>\n<p>If <a href=\"http2.html#http2_response_write_chunk_encoding_callback\"><code>response.write()</code></a> or <a href=\"http2.html#http2_response_end_data_encoding_callback\"><code>response.end()</code></a> are called before calling\nthis, the implicit/mutable headers will be calculated and call this function.</p>\n<p>When headers have been set with <a href=\"http2.html#http2_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"http2.html#http2_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"http2.html#http2_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http2.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html; charset=utf-8');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });\n  res.end('ok');\n});\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
-                },
-                {
-                  "textRaw": "`response.createPushResponse(headers, callback)`",
-                  "type": "method",
-                  "name": "createPushResponse",
-                  "meta": {
-                    "added": [
-                      "v8.4.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "params": [
-                        {
-                          "textRaw": "`headers` {HTTP/2 Headers Object} An object describing the headers",
-                          "name": "headers",
-                          "type": "HTTP/2 Headers Object",
-                          "desc": "An object describing the headers"
-                        },
-                        {
-                          "textRaw": "`callback` {Function} Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method",
-                          "name": "callback",
-                          "type": "Function",
-                          "desc": "Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method",
-                          "options": [
-                            {
-                              "textRaw": "`err` {Error}",
-                              "name": "err",
-                              "type": "Error"
-                            },
-                            {
-                              "textRaw": "`stream` {ServerHttp2Stream} The newly-created `ServerHttp2Stream` object",
-                              "name": "stream",
-                              "type": "ServerHttp2Stream",
-                              "desc": "The newly-created `ServerHttp2Stream` object"
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  ],
-                  "desc": "<p>Call <a href=\"http2.html#http2_http2stream_pushstream_headers_options_callback\"><code>http2stream.pushStream()</code></a> with the given headers, and wrap the\ngiven <a href=\"http2.html#http2_class_http2stream\"><code>Http2Stream</code></a> on a newly created <code>Http2ServerResponse</code> as the callback\nparameter if successful. When <code>Http2ServerRequest</code> is closed, the callback is\ncalled with an error <code>ERR_HTTP2_INVALID_STREAM</code>.</p>"
+                  "desc": "<p>Sends a response header to the request. The status code is a 3-digit HTTP\nstatus code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.</p>\n<p>Returns a reference to the <code>Http2ServerResponse</code>, so that calls can be chained.</p>\n<p>For compatibility with <a href=\"http.html\">HTTP/1</a>, a human-readable <code>statusMessage</code> may be\npassed as the second argument. However, because the <code>statusMessage</code> has no\nmeaning within HTTP/2, the argument will have no effect and a process warning\nwill be emitted.</p>\n<pre><code class=\"language-js\">const body = 'hello world';\nresponse.writeHead(200, {\n  'Content-Length': Buffer.byteLength(body),\n  'Content-Type': 'text/plain; charset=utf-8',\n});\n</code></pre>\n<p><code>Content-Length</code> is given in bytes not characters. The\n<code>Buffer.byteLength()</code> API may be used to determine the number of bytes in a\ngiven encoding. On outbound messages, Node.js does not check if Content-Length\nand the length of the body being transmitted are equal or not. However, when\nreceiving messages, Node.js will automatically reject messages when the\n<code>Content-Length</code> does not match the actual payload size.</p>\n<p>This method may be called at most one time on a message before\n<a href=\"http2.html#http2_response_end_data_encoding_callback\"><code>response.end()</code></a> is called.</p>\n<p>If <a href=\"http2.html#http2_response_write_chunk_encoding_callback\"><code>response.write()</code></a> or <a href=\"http2.html#http2_response_end_data_encoding_callback\"><code>response.end()</code></a> are called before calling\nthis, the implicit/mutable headers will be calculated and call this function.</p>\n<p>When headers have been set with <a href=\"http2.html#http2_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"http2.html#http2_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"http2.html#http2_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http2.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html; charset=utf-8');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });\n  res.end('ok');\n});\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
                 }
               ],
               "properties": [
@@ -40746,8 +45246,13 @@
                     "added": [
                       "v8.4.0"
                     ],
+                    "deprecated": [
+                      "v13.0.0"
+                    ],
                     "changes": []
                   },
+                  "stability": 0,
+                  "stabilityText": "Deprecated. Use [`response.socket`][].",
                   "desc": "<p>See <a href=\"http2.html#http2_response_socket\"><code>response.socket</code></a>.</p>"
                 },
                 {
@@ -40759,6 +45264,7 @@
                       "v8.4.0"
                     ],
                     "deprecated": [
+                      "v13.4.0",
                       "v12.16.0"
                     ],
                     "changes": []
@@ -40866,7 +45372,8 @@
         }
       ],
       "type": "module",
-      "displayName": "HTTP/2"
+      "displayName": "HTTP/2",
+      "source": "doc/api/http2.md"
     },
     {
       "textRaw": "HTTPS",
@@ -40874,7 +45381,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/https.js\">lib/https.js</a></p>\n<p>HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a\nseparate module.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/https.js\">lib/https.js</a></p>\n<p>HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a\nseparate module.</p>",
       "classes": [
         {
           "textRaw": "Class: `https.Agent`",
@@ -40885,15 +45392,15 @@
               "v0.4.5"
             ],
             "changes": [
-              {
-                "version": "v2.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2228",
-                "description": "parameter `maxCachedSessions` added to `options` for TLS sessions reuse."
-              },
               {
                 "version": "v5.3.0",
                 "pr-url": "https://github.com/nodejs/node/pull/4252",
                 "description": "support `0` `maxCachedSessions` to disable TLS session caching."
+              },
+              {
+                "version": "v2.5.0",
+                "pr-url": "https://github.com/nodejs/node/pull/2228",
+                "description": "parameter `maxCachedSessions` added to `options` for TLS sessions reuse."
               }
             ]
           },
@@ -41035,16 +45542,35 @@
               "desc": "<p>See <a href=\"http.html#http_server_maxheaderscount\"><code>http.Server#maxHeadersCount</code></a>.</p>"
             },
             {
-              "textRaw": "`timeout` {number} **Default:** `120000` (2 minutes)",
+              "textRaw": "`requestTimeout` {number} **Default:** `0`",
+              "type": "number",
+              "name": "requestTimeout",
+              "meta": {
+                "added": [
+                  "v14.11.0"
+                ],
+                "changes": []
+              },
+              "default": "`0`",
+              "desc": "<p>See <a href=\"http.html#http_server_requesttimeout\"><code>http.Server#requestTimeout</code></a>.</p>"
+            },
+            {
+              "textRaw": "`timeout` {number} **Default:** 0 (no timeout)",
               "type": "number",
               "name": "timeout",
               "meta": {
                 "added": [
                   "v0.11.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27558",
+                    "description": "The default timeout changed from 120s to 0 (no timeout)."
+                  }
+                ]
               },
-              "default": "`120000` (2 minutes)",
+              "default": "0 (no timeout)",
               "desc": "<p>See <a href=\"http.html#http_server_timeout\"><code>http.Server#timeout</code></a>.</p>"
             },
             {
@@ -41198,6 +45724,16 @@
               "v0.3.6"
             ],
             "changes": [
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/39310",
+                "description": "When using a `URL` object parsed username and password will now be properly URI decoded."
+              },
+              {
+                "version": "v14.1.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32786",
+                "description": "The `highWaterMark` option is accepted now."
+              },
               {
                 "version": "v10.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/21616",
@@ -41217,6 +45753,11 @@
           },
           "signatures": [
             {
+              "return": {
+                "textRaw": "Returns: {http.ClientRequest}",
+                "name": "return",
+                "type": "http.ClientRequest"
+              },
               "params": [
                 {
                   "textRaw": "`url` {string | URL}",
@@ -41254,7 +45795,7 @@
               ]
             }
           ],
-          "desc": "<p>Makes a request to a secure web server.</p>\n<p>The following additional <code>options</code> from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a> are also accepted:\n<code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,\n<code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,\n<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>.</p>\n<p><code>options</code> can be an object, a string, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>options</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<pre><code class=\"language-js\">const https = require('https');\n\nconst options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET'\n};\n\nconst req = https.request(options, (res) => {\n  console.log('statusCode:', res.statusCode);\n  console.log('headers:', res.headers);\n\n  res.on('data', (d) => {\n    process.stdout.write(d);\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(e);\n});\nreq.end();\n</code></pre>\n<p>Example using options from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>:</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Alternatively, opt out of connection pooling by not using an <a href=\"https.html#https_class_https_agent\"><code>Agent</code></a>.</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),\n  agent: false\n};\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('https://abc:xyz@example.com');\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example pinning on certificate fingerprint, or the public key (similar to\n<code>pin-sha256</code>):</p>\n<pre><code class=\"language-js\">const tls = require('tls');\nconst https = require('https');\nconst crypto = require('crypto');\n\nfunction sha256(s) {\n  return crypto.createHash('sha256').update(s).digest('base64');\n}\nconst options = {\n  hostname: 'github.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  checkServerIdentity: function(host, cert) {\n    // Make sure the certificate is issued to the host we are connected to\n    const err = tls.checkServerIdentity(host, cert);\n    if (err) {\n      return err;\n    }\n\n    // Pin the public key, similar to HPKP pin-sha25 pinning\n    const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';\n    if (sha256(cert.pubkey) !== pubkey256) {\n      const msg = 'Certificate verification error: ' +\n        `The public key of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // Pin the exact certificate, rather than the pub key\n    const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +\n      'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';\n    if (cert.fingerprint256 !== cert256) {\n      const msg = 'Certificate verification error: ' +\n        `The certificate of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // This loop is informational only.\n    // Print the certificate and public key fingerprints of all certs in the\n    // chain. Its common to pin the public key of the issuer on the public\n    // internet, while pinning the public key of the service in sensitive\n    // environments.\n    do {\n      console.log('Subject Common Name:', cert.subject.CN);\n      console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);\n\n      hash = crypto.createHash('sha256');\n      console.log('  Public key ping-sha256:', sha256(cert.pubkey));\n\n      lastprint256 = cert.fingerprint256;\n      cert = cert.issuerCertificate;\n    } while (cert.fingerprint256 !== lastprint256);\n\n  },\n};\n\noptions.agent = new https.Agent(options);\nconst req = https.request(options, (res) => {\n  console.log('All OK. Server matched our pinned cert or public key');\n  console.log('statusCode:', res.statusCode);\n  // Print the HPKP values\n  console.log('headers:', res.headers['public-key-pins']);\n\n  res.on('data', (d) => {});\n});\n\nreq.on('error', (e) => {\n  console.error(e.message);\n});\nreq.end();\n</code></pre>\n<p>Outputs for example:</p>\n<pre><code class=\"language-text\">Subject Common Name: github.com\n  Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16\n  Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=\nSubject Common Name: DigiCert SHA2 Extended Validation Server CA\n  Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A\n  Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\nSubject Common Name: DigiCert High Assurance EV Root CA\n  Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF\n  Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\nAll OK. Server matched our pinned cert or public key\nstatusCode: 200\nheaders: max-age=0; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains\n</code></pre>"
+          "desc": "<p>Makes a request to a secure web server.</p>\n<p>The following additional <code>options</code> from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a> are also accepted:\n<code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,\n<code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,\n<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>,\n<code>highWaterMark</code>.</p>\n<p><code>options</code> can be an object, a string, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>options</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p><code>https.request()</code> returns an instance of the <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const https = require('https');\n\nconst options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET'\n};\n\nconst req = https.request(options, (res) => {\n  console.log('statusCode:', res.statusCode);\n  console.log('headers:', res.headers);\n\n  res.on('data', (d) => {\n    process.stdout.write(d);\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(e);\n});\nreq.end();\n</code></pre>\n<p>Example using options from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>:</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Alternatively, opt out of connection pooling by not using an <a href=\"https.html#https_class_https_agent\"><code>Agent</code></a>.</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),\n  agent: false\n};\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('https://abc:xyz@example.com');\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example pinning on certificate fingerprint, or the public key (similar to\n<code>pin-sha256</code>):</p>\n<pre><code class=\"language-js\">const tls = require('tls');\nconst https = require('https');\nconst crypto = require('crypto');\n\nfunction sha256(s) {\n  return crypto.createHash('sha256').update(s).digest('base64');\n}\nconst options = {\n  hostname: 'github.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  checkServerIdentity: function(host, cert) {\n    // Make sure the certificate is issued to the host we are connected to\n    const err = tls.checkServerIdentity(host, cert);\n    if (err) {\n      return err;\n    }\n\n    // Pin the public key, similar to HPKP pin-sha25 pinning\n    const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';\n    if (sha256(cert.pubkey) !== pubkey256) {\n      const msg = 'Certificate verification error: ' +\n        `The public key of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // Pin the exact certificate, rather than the pub key\n    const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +\n      'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';\n    if (cert.fingerprint256 !== cert256) {\n      const msg = 'Certificate verification error: ' +\n        `The certificate of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // This loop is informational only.\n    // Print the certificate and public key fingerprints of all certs in the\n    // chain. Its common to pin the public key of the issuer on the public\n    // internet, while pinning the public key of the service in sensitive\n    // environments.\n    do {\n      console.log('Subject Common Name:', cert.subject.CN);\n      console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);\n\n      hash = crypto.createHash('sha256');\n      console.log('  Public key ping-sha256:', sha256(cert.pubkey));\n\n      lastprint256 = cert.fingerprint256;\n      cert = cert.issuerCertificate;\n    } while (cert.fingerprint256 !== lastprint256);\n\n  },\n};\n\noptions.agent = new https.Agent(options);\nconst req = https.request(options, (res) => {\n  console.log('All OK. Server matched our pinned cert or public key');\n  console.log('statusCode:', res.statusCode);\n  // Print the HPKP values\n  console.log('headers:', res.headers['public-key-pins']);\n\n  res.on('data', (d) => {});\n});\n\nreq.on('error', (e) => {\n  console.error(e.message);\n});\nreq.end();\n</code></pre>\n<p>Outputs for example:</p>\n<pre><code class=\"language-text\">Subject Common Name: github.com\n  Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16\n  Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=\nSubject Common Name: DigiCert SHA2 Extended Validation Server CA\n  Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A\n  Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\nSubject Common Name: DigiCert High Assurance EV Root CA\n  Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF\n  Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\nAll OK. Server matched our pinned cert or public key\nstatusCode: 200\nheaders: max-age=0; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains\n</code></pre>"
         },
         {
           "textRaw": "`https.request(url[, options][, callback])`",
@@ -41265,6 +45806,16 @@
               "v0.3.6"
             ],
             "changes": [
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/39310",
+                "description": "When using a `URL` object parsed username and password will now be properly URI decoded."
+              },
+              {
+                "version": "v14.1.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32786",
+                "description": "The `highWaterMark` option is accepted now."
+              },
               {
                 "version": "v10.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/21616",
@@ -41284,6 +45835,11 @@
           },
           "signatures": [
             {
+              "return": {
+                "textRaw": "Returns: {http.ClientRequest}",
+                "name": "return",
+                "type": "http.ClientRequest"
+              },
               "params": [
                 {
                   "textRaw": "`url` {string | URL}",
@@ -41321,7 +45877,7 @@
               ]
             }
           ],
-          "desc": "<p>Makes a request to a secure web server.</p>\n<p>The following additional <code>options</code> from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a> are also accepted:\n<code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,\n<code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,\n<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>.</p>\n<p><code>options</code> can be an object, a string, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>options</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<pre><code class=\"language-js\">const https = require('https');\n\nconst options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET'\n};\n\nconst req = https.request(options, (res) => {\n  console.log('statusCode:', res.statusCode);\n  console.log('headers:', res.headers);\n\n  res.on('data', (d) => {\n    process.stdout.write(d);\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(e);\n});\nreq.end();\n</code></pre>\n<p>Example using options from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>:</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Alternatively, opt out of connection pooling by not using an <a href=\"https.html#https_class_https_agent\"><code>Agent</code></a>.</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),\n  agent: false\n};\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('https://abc:xyz@example.com');\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example pinning on certificate fingerprint, or the public key (similar to\n<code>pin-sha256</code>):</p>\n<pre><code class=\"language-js\">const tls = require('tls');\nconst https = require('https');\nconst crypto = require('crypto');\n\nfunction sha256(s) {\n  return crypto.createHash('sha256').update(s).digest('base64');\n}\nconst options = {\n  hostname: 'github.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  checkServerIdentity: function(host, cert) {\n    // Make sure the certificate is issued to the host we are connected to\n    const err = tls.checkServerIdentity(host, cert);\n    if (err) {\n      return err;\n    }\n\n    // Pin the public key, similar to HPKP pin-sha25 pinning\n    const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';\n    if (sha256(cert.pubkey) !== pubkey256) {\n      const msg = 'Certificate verification error: ' +\n        `The public key of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // Pin the exact certificate, rather than the pub key\n    const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +\n      'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';\n    if (cert.fingerprint256 !== cert256) {\n      const msg = 'Certificate verification error: ' +\n        `The certificate of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // This loop is informational only.\n    // Print the certificate and public key fingerprints of all certs in the\n    // chain. Its common to pin the public key of the issuer on the public\n    // internet, while pinning the public key of the service in sensitive\n    // environments.\n    do {\n      console.log('Subject Common Name:', cert.subject.CN);\n      console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);\n\n      hash = crypto.createHash('sha256');\n      console.log('  Public key ping-sha256:', sha256(cert.pubkey));\n\n      lastprint256 = cert.fingerprint256;\n      cert = cert.issuerCertificate;\n    } while (cert.fingerprint256 !== lastprint256);\n\n  },\n};\n\noptions.agent = new https.Agent(options);\nconst req = https.request(options, (res) => {\n  console.log('All OK. Server matched our pinned cert or public key');\n  console.log('statusCode:', res.statusCode);\n  // Print the HPKP values\n  console.log('headers:', res.headers['public-key-pins']);\n\n  res.on('data', (d) => {});\n});\n\nreq.on('error', (e) => {\n  console.error(e.message);\n});\nreq.end();\n</code></pre>\n<p>Outputs for example:</p>\n<pre><code class=\"language-text\">Subject Common Name: github.com\n  Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16\n  Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=\nSubject Common Name: DigiCert SHA2 Extended Validation Server CA\n  Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A\n  Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\nSubject Common Name: DigiCert High Assurance EV Root CA\n  Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF\n  Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\nAll OK. Server matched our pinned cert or public key\nstatusCode: 200\nheaders: max-age=0; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains\n</code></pre>"
+          "desc": "<p>Makes a request to a secure web server.</p>\n<p>The following additional <code>options</code> from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a> are also accepted:\n<code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,\n<code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,\n<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>,\n<code>highWaterMark</code>.</p>\n<p><code>options</code> can be an object, a string, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>options</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p><code>https.request()</code> returns an instance of the <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const https = require('https');\n\nconst options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET'\n};\n\nconst req = https.request(options, (res) => {\n  console.log('statusCode:', res.statusCode);\n  console.log('headers:', res.headers);\n\n  res.on('data', (d) => {\n    process.stdout.write(d);\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(e);\n});\nreq.end();\n</code></pre>\n<p>Example using options from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>:</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Alternatively, opt out of connection pooling by not using an <a href=\"https.html#https_class_https_agent\"><code>Agent</code></a>.</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),\n  agent: false\n};\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('https://abc:xyz@example.com');\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example pinning on certificate fingerprint, or the public key (similar to\n<code>pin-sha256</code>):</p>\n<pre><code class=\"language-js\">const tls = require('tls');\nconst https = require('https');\nconst crypto = require('crypto');\n\nfunction sha256(s) {\n  return crypto.createHash('sha256').update(s).digest('base64');\n}\nconst options = {\n  hostname: 'github.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  checkServerIdentity: function(host, cert) {\n    // Make sure the certificate is issued to the host we are connected to\n    const err = tls.checkServerIdentity(host, cert);\n    if (err) {\n      return err;\n    }\n\n    // Pin the public key, similar to HPKP pin-sha25 pinning\n    const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';\n    if (sha256(cert.pubkey) !== pubkey256) {\n      const msg = 'Certificate verification error: ' +\n        `The public key of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // Pin the exact certificate, rather than the pub key\n    const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +\n      'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';\n    if (cert.fingerprint256 !== cert256) {\n      const msg = 'Certificate verification error: ' +\n        `The certificate of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // This loop is informational only.\n    // Print the certificate and public key fingerprints of all certs in the\n    // chain. Its common to pin the public key of the issuer on the public\n    // internet, while pinning the public key of the service in sensitive\n    // environments.\n    do {\n      console.log('Subject Common Name:', cert.subject.CN);\n      console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);\n\n      hash = crypto.createHash('sha256');\n      console.log('  Public key ping-sha256:', sha256(cert.pubkey));\n\n      lastprint256 = cert.fingerprint256;\n      cert = cert.issuerCertificate;\n    } while (cert.fingerprint256 !== lastprint256);\n\n  },\n};\n\noptions.agent = new https.Agent(options);\nconst req = https.request(options, (res) => {\n  console.log('All OK. Server matched our pinned cert or public key');\n  console.log('statusCode:', res.statusCode);\n  // Print the HPKP values\n  console.log('headers:', res.headers['public-key-pins']);\n\n  res.on('data', (d) => {});\n});\n\nreq.on('error', (e) => {\n  console.error(e.message);\n});\nreq.end();\n</code></pre>\n<p>Outputs for example:</p>\n<pre><code class=\"language-text\">Subject Common Name: github.com\n  Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16\n  Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=\nSubject Common Name: DigiCert SHA2 Extended Validation Server CA\n  Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A\n  Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\nSubject Common Name: DigiCert High Assurance EV Root CA\n  Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF\n  Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\nAll OK. Server matched our pinned cert or public key\nstatusCode: 200\nheaders: max-age=0; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains\n</code></pre>"
         }
       ],
       "properties": [
@@ -41338,15 +45894,16 @@
         }
       ],
       "type": "module",
-      "displayName": "HTTPS"
+      "displayName": "HTTPS",
+      "source": "doc/api/https.md"
     },
     {
       "textRaw": "Inspector",
       "name": "inspector",
       "introduced_in": "v8.0.0",
-      "stability": 1,
-      "stabilityText": "Experimental",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/inspector.js\">lib/inspector.js</a></p>\n<p>The <code>inspector</code> module provides an API for interacting with the V8 inspector.</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const inspector = require('inspector');\n</code></pre>",
+      "stability": 2,
+      "stabilityText": "Stable",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/inspector.js\">lib/inspector.js</a></p>\n<p>The <code>inspector</code> module provides an API for interacting with the V8 inspector.</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const inspector = require('inspector');\n</code></pre>",
       "methods": [
         {
           "textRaw": "`inspector.close()`",
@@ -41592,7 +46149,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Inspector"
+      "displayName": "Inspector",
+      "source": "doc/api/inspector.md"
     },
     {
       "textRaw": "Modules: CommonJS modules",
@@ -41609,8 +46167,8 @@
           "desc": "<p>When a file is run directly from Node.js, <code>require.main</code> is set to its\n<code>module</code>. That means that it is possible to determine whether a file has been\nrun directly by testing <code>require.main === module</code>.</p>\n<p>For a file <code>foo.js</code>, this will be <code>true</code> if run via <code>node foo.js</code>, but\n<code>false</code> if run by <code>require('./foo')</code>.</p>\n<p>Because <code>module</code> provides a <code>filename</code> property (normally equivalent to\n<code>__filename</code>), the entry point of the current application can be obtained\nby checking <code>require.main.filename</code>.</p>"
         },
         {
-          "textRaw": "Addenda: Package manager tips",
-          "name": "Addenda: Package manager tips",
+          "textRaw": "Package manager tips",
+          "name": "Package manager tips",
           "type": "misc",
           "desc": "<p>The semantics of the Node.js <code>require()</code> function were designed to be general\nenough to support reasonable directory structures. Package manager programs\nsuch as <code>dpkg</code>, <code>rpm</code>, and <code>npm</code> will hopefully find it possible to build\nnative packages from Node.js modules without modification.</p>\n<p>Below we give a suggested directory structure that could work:</p>\n<p>Let's say that we wanted to have the folder at\n<code>/usr/lib/node/&#x3C;some-package>/&#x3C;some-version></code> hold the contents of a\nspecific version of a package.</p>\n<p>Packages can depend on one another. In order to install package <code>foo</code>, it\nmay be necessary to install a specific version of package <code>bar</code>. The <code>bar</code>\npackage may itself have dependencies, and in some cases, these may even collide\nor form cyclic dependencies.</p>\n<p>Because Node.js looks up the <code>realpath</code> of any modules it loads (that is, it\nresolves symlinks) and then <a href=\"modules.html#modules_loading_from_node_modules_folders\">looks for their dependencies in <code>node_modules</code> folders</a>,\nthis situation can be resolved with the following architecture:</p>\n<ul>\n<li><code>/usr/lib/node/foo/1.2.3/</code>: Contents of the <code>foo</code> package, version 1.2.3.</li>\n<li><code>/usr/lib/node/bar/4.3.2/</code>: Contents of the <code>bar</code> package that <code>foo</code> depends\non.</li>\n<li><code>/usr/lib/node/foo/1.2.3/node_modules/bar</code>: Symbolic link to\n<code>/usr/lib/node/bar/4.3.2/</code>.</li>\n<li><code>/usr/lib/node/bar/4.3.2/node_modules/*</code>: Symbolic links to the packages that\n<code>bar</code> depends on.</li>\n</ul>\n<p>Thus, even if a cycle is encountered, or if there are dependency\nconflicts, every module will be able to get a version of its dependency\nthat it can use.</p>\n<p>When the code in the <code>foo</code> package does <code>require('bar')</code>, it will get the\nversion that is symlinked into <code>/usr/lib/node/foo/1.2.3/node_modules/bar</code>.\nThen, when the code in the <code>bar</code> package calls <code>require('quux')</code>, it'll get\nthe version that is symlinked into\n<code>/usr/lib/node/bar/4.3.2/node_modules/quux</code>.</p>\n<p>Furthermore, to make the module lookup process even more optimal, rather\nthan putting packages directly in <code>/usr/lib/node</code>, we could put them in\n<code>/usr/lib/node_modules/&#x3C;name>/&#x3C;version></code>. Then Node.js will not bother\nlooking for missing dependencies in <code>/usr/node_modules</code> or <code>/node_modules</code>.</p>\n<p>In order to make modules available to the Node.js REPL, it might be useful to\nalso add the <code>/usr/lib/node_modules</code> folder to the <code>$NODE_PATH</code> environment\nvariable. Since the module lookups using <code>node_modules</code> folders are all\nrelative, and based on the real path of the files making the calls to\n<code>require()</code>, the packages themselves can be anywhere.</p>"
         },
@@ -41618,7 +46176,7 @@
           "textRaw": "All together...",
           "name": "All together...",
           "type": "misc",
-          "desc": "<p>To get the exact filename that will be loaded when <code>require()</code> is called, use\nthe <code>require.resolve()</code> function.</p>\n<p>Putting together all of the above, here is the high-level algorithm\nin pseudocode of what <code>require()</code> does:</p>\n<pre><code class=\"language-text\">require(X) from module at path Y\n1. If X is a core module,\n   a. return the core module\n   b. STOP\n2. If X begins with '/'\n   a. set Y to be the filesystem root\n3. If X begins with './' or '/' or '../'\n   a. LOAD_AS_FILE(Y + X)\n   b. LOAD_AS_DIRECTORY(Y + X)\n   c. THROW \"not found\"\n4. If X begins with '#'\n   a. LOAD_PACKAGE_IMPORTS(X, dirname(Y))\n5. LOAD_PACKAGE_SELF(X, dirname(Y))\n6. LOAD_NODE_MODULES(X, dirname(Y))\n7. THROW \"not found\"\n\nLOAD_AS_FILE(X)\n1. If X is a file, load X as its file extension format. STOP\n2. If X.js is a file, load X.js as JavaScript text. STOP\n3. If X.json is a file, parse X.json to a JavaScript Object. STOP\n4. If X.node is a file, load X.node as binary addon. STOP\n\nLOAD_INDEX(X)\n1. If X/index.js is a file, load X/index.js as JavaScript text. STOP\n2. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP\n3. If X/index.node is a file, load X/index.node as binary addon. STOP\n\nLOAD_AS_DIRECTORY(X)\n1. If X/package.json is a file,\n   a. Parse X/package.json, and look for \"main\" field.\n   b. If \"main\" is a falsy value, GOTO 2.\n   c. let M = X + (json main field)\n   d. LOAD_AS_FILE(M)\n   e. LOAD_INDEX(M)\n   f. LOAD_INDEX(X) DEPRECATED\n   g. THROW \"not found\"\n2. LOAD_INDEX(X)\n\nLOAD_NODE_MODULES(X, START)\n1. let DIRS = NODE_MODULES_PATHS(START)\n2. for each DIR in DIRS:\n   a. LOAD_PACKAGE_EXPORTS(X, DIR)\n   b. LOAD_AS_FILE(DIR/X)\n   c. LOAD_AS_DIRECTORY(DIR/X)\n\nNODE_MODULES_PATHS(START)\n1. let PARTS = path split(START)\n2. let I = count of PARTS - 1\n3. let DIRS = [GLOBAL_FOLDERS]\n4. while I >= 0,\n   a. if PARTS[I] = \"node_modules\" CONTINUE\n   b. DIR = path join(PARTS[0 .. I] + \"node_modules\")\n   c. DIRS = DIRS + DIR\n   d. let I = I - 1\n5. return DIRS\n\nLOAD_PACKAGE_IMPORTS(X, DIR)\n1. Find the closest package scope SCOPE to DIR.\n2. If no scope was found, return.\n3. If the SCOPE/package.json \"imports\" is null or undefined, return.\n4. let MATCH = PACKAGE_IMPORTS_RESOLVE(X, pathToFileURL(SCOPE),\n  [\"node\", \"require\"]) defined in the ESM resolver.\n5. RESOLVE_ESM_MATCH(MATCH).\n\nLOAD_PACKAGE_EXPORTS(X, DIR)\n1. Try to interpret X as a combination of NAME and SUBPATH where the name\n   may have a @scope/ prefix and the subpath begins with a slash (`/`).\n2. If X does not match this pattern or DIR/NAME/package.json is not a file,\n   return.\n3. Parse DIR/NAME/package.json, and look for \"exports\" field.\n4. If \"exports\" is null or undefined, return.\n5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(DIR/NAME), \".\" + SUBPATH,\n   `package.json` \"exports\", [\"node\", \"require\"]) defined in the ESM resolver.\n6. RESOLVE_ESM_MATCH(MATCH)\n\nLOAD_PACKAGE_SELF(X, DIR)\n1. Find the closest package scope SCOPE to DIR.\n2. If no scope was found, return.\n3. If the SCOPE/package.json \"exports\" is null or undefined, return.\n4. If the SCOPE/package.json \"name\" is not the first segment of X, return.\n5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(SCOPE),\n   \".\" + X.slice(\"name\".length), `package.json` \"exports\", [\"node\", \"require\"])\n   defined in the ESM resolver.\n6. RESOLVE_ESM_MATCH(MATCH)\n\nRESOLVE_ESM_MATCH(MATCH)\n1. let { RESOLVED, EXACT } = MATCH\n2. let RESOLVED_PATH = fileURLToPath(RESOLVED)\n3. If EXACT is true,\n   a. If the file at RESOLVED_PATH exists, load RESOLVED_PATH as its extension\n      format. STOP\n4. Otherwise, if EXACT is false,\n   a. LOAD_AS_FILE(RESOLVED_PATH)\n   b. LOAD_AS_DIRECTORY(RESOLVED_PATH)\n5. THROW \"not found\"\n</code></pre>"
+          "desc": "<p>To get the exact filename that will be loaded when <code>require()</code> is called, use\nthe <code>require.resolve()</code> function.</p>\n<p>Putting together all of the above, here is the high-level algorithm\nin pseudocode of what <code>require()</code> does:</p>\n<pre>\nrequire(X) from module at path Y\n1. If X is a core module,\n   a. return the core module\n   b. STOP\n2. If X begins with '/'\n   a. set Y to be the filesystem root\n3. If X begins with './' or '/' or '../'\n   a. LOAD_AS_FILE(Y + X)\n   b. LOAD_AS_DIRECTORY(Y + X)\n   c. THROW \"not found\"\n4. If X begins with '#'\n   a. LOAD_PACKAGE_IMPORTS(X, dirname(Y))\n5. LOAD_PACKAGE_SELF(X, dirname(Y))\n6. LOAD_NODE_MODULES(X, dirname(Y))\n7. THROW \"not found\"\n\nLOAD_AS_FILE(X)\n1. If X is a file, load X as its file extension format. STOP\n2. If X.js is a file, load X.js as JavaScript text. STOP\n3. If X.json is a file, parse X.json to a JavaScript Object. STOP\n4. If X.node is a file, load X.node as binary addon. STOP\n\nLOAD_INDEX(X)\n1. If X/index.js is a file, load X/index.js as JavaScript text. STOP\n2. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP\n3. If X/index.node is a file, load X/index.node as binary addon. STOP\n\nLOAD_AS_DIRECTORY(X)\n1. If X/package.json is a file,\n   a. Parse X/package.json, and look for \"main\" field.\n   b. If \"main\" is a falsy value, GOTO 2.\n   c. let M = X + (json main field)\n   d. LOAD_AS_FILE(M)\n   e. LOAD_INDEX(M)\n   f. LOAD_INDEX(X) DEPRECATED\n   g. THROW \"not found\"\n2. LOAD_INDEX(X)\n\nLOAD_NODE_MODULES(X, START)\n1. let DIRS = NODE_MODULES_PATHS(START)\n2. for each DIR in DIRS:\n   a. LOAD_PACKAGE_EXPORTS(X, DIR)\n   b. LOAD_AS_FILE(DIR/X)\n   c. LOAD_AS_DIRECTORY(DIR/X)\n\nNODE_MODULES_PATHS(START)\n1. let PARTS = path split(START)\n2. let I = count of PARTS - 1\n3. let DIRS = [GLOBAL_FOLDERS]\n4. while I >= 0,\n   a. if PARTS[I] = \"node_modules\" CONTINUE\n   b. DIR = path join(PARTS[0 .. I] + \"node_modules\")\n   c. DIRS = DIRS + DIR\n   d. let I = I - 1\n5. return DIRS\n\nLOAD_PACKAGE_IMPORTS(X, DIR)\n1. Find the closest package scope SCOPE to DIR.\n2. If no scope was found, return.\n3. If the SCOPE/package.json \"imports\" is null or undefined, return.\n4. let MATCH = PACKAGE_IMPORTS_RESOLVE(X, pathToFileURL(SCOPE),\n  [\"node\", \"require\"]) <a href=\"esm.md#resolver-algorithm-specification\">defined in the ESM resolver</a>.\n5. RESOLVE_ESM_MATCH(MATCH).\n\nLOAD_PACKAGE_EXPORTS(X, DIR)\n1. Try to interpret X as a combination of NAME and SUBPATH where the name\n   may have a @scope/ prefix and the subpath begins with a slash (`/`).\n2. If X does not match this pattern or DIR/NAME/package.json is not a file,\n   return.\n3. Parse DIR/NAME/package.json, and look for \"exports\" field.\n4. If \"exports\" is null or undefined, return.\n5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(DIR/NAME), \".\" + SUBPATH,\n   `package.json` \"exports\", [\"node\", \"require\"]) <a href=\"esm.md#resolver-algorithm-specification\">defined in the ESM resolver</a>.\n6. RESOLVE_ESM_MATCH(MATCH)\n\nLOAD_PACKAGE_SELF(X, DIR)\n1. Find the closest package scope SCOPE to DIR.\n2. If no scope was found, return.\n3. If the SCOPE/package.json \"exports\" is null or undefined, return.\n4. If the SCOPE/package.json \"name\" is not the first segment of X, return.\n5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(SCOPE),\n   \".\" + X.slice(\"name\".length), `package.json` \"exports\", [\"node\", \"require\"])\n   <a href=\"esm.md#resolver-algorithm-specification\">defined in the ESM resolver</a>.\n6. RESOLVE_ESM_MATCH(MATCH)\n\nRESOLVE_ESM_MATCH(MATCH)\n1. let { RESOLVED, EXACT } = MATCH\n2. let RESOLVED_PATH = fileURLToPath(RESOLVED)\n3. If EXACT is true,\n   a. If the file at RESOLVED_PATH exists, load RESOLVED_PATH as its extension\n      format. STOP\n4. Otherwise, if EXACT is false,\n   a. LOAD_AS_FILE(RESOLVED_PATH)\n   b. LOAD_AS_DIRECTORY(RESOLVED_PATH)\n5. THROW \"not found\"\n</pre>"
         },
         {
           "textRaw": "Caching",
@@ -41638,7 +46196,16 @@
           "textRaw": "Core modules",
           "name": "Core modules",
           "type": "misc",
-          "desc": "<p>Node.js has several modules compiled into the binary. These modules are\ndescribed in greater detail elsewhere in this documentation.</p>\n<p>The core modules are defined within the Node.js source and are located in the\n<code>lib/</code> folder.</p>\n<p>Core modules are always preferentially loaded if their identifier is\npassed to <code>require()</code>. For instance, <code>require('http')</code> will always\nreturn the built in HTTP module, even if there is a file by that name.</p>"
+          "meta": {
+            "changes": [
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/37246",
+                "description": "Added `node:` import support to `require(...)`."
+              }
+            ]
+          },
+          "desc": "<p>Node.js has several modules compiled into the binary. These modules are\ndescribed in greater detail elsewhere in this documentation.</p>\n<p>The core modules are defined within the Node.js source and are located in the\n<code>lib/</code> folder.</p>\n<p>Core modules are always preferentially loaded if their identifier is\npassed to <code>require()</code>. For instance, <code>require('http')</code> will always\nreturn the built in HTTP module, even if there is a file by that name.</p>\n<p>Core modules can also be identified using the <code>node:</code> prefix, in which case\nit bypasses the <code>require</code> cache. For instance, <code>require('node:http')</code> will\nalways return the built in HTTP module, even if there is <code>require.cache</code> entry\nby that name.</p>"
         },
         {
           "textRaw": "Cycles",
@@ -41679,11 +46246,11 @@
       ],
       "modules": [
         {
-          "textRaw": "Addenda: The `.mjs` extension",
-          "name": "addenda:_the_`.mjs`_extension",
+          "textRaw": "The `.mjs` extension",
+          "name": "the_`.mjs`_extension",
           "desc": "<p>It is not possible to <code>require()</code> files that have the <code>.mjs</code> extension.\nAttempting to do so will throw <a href=\"errors.html#errors_err_require_esm\">an error</a>. The <code>.mjs</code> extension is\nreserved for <a href=\"esm.html\">ECMAScript Modules</a> which cannot be loaded via <code>require()</code>.\nSee <a href=\"esm.html\">ECMAScript Modules</a> for more details.</p>",
           "type": "module",
-          "displayName": "Addenda: The `.mjs` extension"
+          "displayName": "The `.mjs` extension"
         },
         {
           "textRaw": "The module scope",
@@ -41759,7 +46326,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Modules are cached in this object when they are required. By deleting a key\nvalue from this object, the next <code>require</code> will reload the module.\nThis does not apply to <a href=\"addons.html\">native addons</a>, for which reloading will result in an\nerror.</p>\n<p>Adding or replacing entries is also possible. This cache is checked before\nnative modules and if a name matching a native module is added to the cache,\nno require call is\ngoing to receive the native module anymore. Use with care!</p>"
+                  "desc": "<p>Modules are cached in this object when they are required. By deleting a key\nvalue from this object, the next <code>require</code> will reload the module.\nThis does not apply to <a href=\"addons.html\">native addons</a>, for which reloading will result in an\nerror.</p>\n<p>Adding or replacing entries is also possible. This cache is checked before\nnative modules and if a name matching a native module is added to the cache,\nonly <code>node:</code>-prefixed require calls are going to receive the native module.\nUse with care!</p>\n<!-- eslint-disable node-core/no-duplicate-requires -->\n<pre><code class=\"language-js\">const assert = require('assert');\nconst realFs = require('fs');\n\nconst fakeFs = {};\nrequire.cache.fs = { exports: fakeFs };\n\nassert.strictEqual(require('fs'), fakeFs);\nassert.strictEqual(require('node:fs'), realFs);\n</code></pre>"
                 },
                 {
                   "textRaw": "`extensions` {Object}",
@@ -41887,11 +46454,20 @@
         {
           "textRaw": "Source map v3 support",
           "name": "source_map_v3_support",
-          "desc": "<p>This section was moved to\n<a href=\"module.html#module_source_map_v3_support\">Modules: <code>module</code> core module</a>.</p>\n<!-- Anchors to make sure old links find a target -->\n<ul>\n<li><a id=\"modules_module_findsourcemap_path_error\" href=\"module.html#module_module_findsourcemap_path_error\"><code>module.findSourceMap(path[, error])</code></a></li>\n<li><a id=\"modules_class_module_sourcemap\" href=\"module.html#module_class_module_sourcemap\">Class: <code>module.SourceMap</code></a>\n<ul>\n<li><a id=\"modules_new_sourcemap_payload\" href=\"module.html#module_new_sourcemap_payload\"><code>new SourceMap(payload)</code></a></li>\n<li><a id=\"modules_sourcemap_payload\" href=\"module.html#module_sourcemap_payload\"><code>sourceMap.payload</code></a></li>\n<li><a id=\"modules_sourcemap_findentry_linenumber_columnnumber\" href=\"module.html#module_sourcemap_findentry_linenumber_columnnumber\"><code>sourceMap.findEntry(lineNumber, columnNumber)</code></a></li>\n</ul>\n</li>\n</ul>",
+          "desc": "<p>This section was moved to\n<a href=\"module.html#module_source_map_v3_support\">Modules: <code>module</code> core module</a>.</p>\n<!-- Anchors to make sure old links find a target -->\n<ul>\n<li><a id=\"modules_module_findsourcemap_path_error\" href=\"module.html#module_module_findsourcemap_path\"><code>module.findSourceMap(path)</code></a></li>\n<li><a id=\"modules_class_module_sourcemap\" href=\"module.html#module_class_module_sourcemap\">Class: <code>module.SourceMap</code></a>\n<ul>\n<li><a id=\"modules_new_sourcemap_payload\" href=\"module.html#module_new_sourcemap_payload\"><code>new SourceMap(payload)</code></a></li>\n<li><a id=\"modules_sourcemap_payload\" href=\"module.html#module_sourcemap_payload\"><code>sourceMap.payload</code></a></li>\n<li><a id=\"modules_sourcemap_findentry_linenumber_columnnumber\" href=\"module.html#module_sourcemap_findentry_linenumber_columnnumber\"><code>sourceMap.findEntry(lineNumber, columnNumber)</code></a></li>\n</ul>\n</li>\n</ul>",
           "type": "module",
           "displayName": "Source map v3 support"
         }
       ],
+      "meta": {
+        "changes": [
+          {
+            "version": "v14.18.0",
+            "pr-url": "https://github.com/nodejs/node/pull/37246",
+            "description": "Added `node:` import support to `require(...)`."
+          }
+        ]
+      },
       "vars": [
         {
           "textRaw": "The `module` object",
@@ -41968,6 +46544,18 @@
               },
               "desc": "<p>The identifier for the module. Typically this is the fully resolved\nfilename.</p>"
             },
+            {
+              "textRaw": "`isPreloading` Type: {boolean} `true` if the module is running during the Node.js preload phase.",
+              "type": "boolean",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "`true` if the module is running during the Node.js preload phase."
+            },
             {
               "textRaw": "`loaded` {boolean}",
               "type": "boolean",
@@ -41989,8 +46577,8 @@
                   "v0.1.16"
                 ],
                 "deprecated": [
-                  "v12.19.0",
-                  "v14.6.0"
+                  "v14.6.0",
+                  "v12.19.0"
                 ],
                 "changes": []
               },
@@ -42057,12 +46645,19 @@
         }
       ],
       "type": "module",
-      "displayName": "module"
+      "displayName": "module",
+      "source": "doc/api/modules.md"
     },
     {
       "textRaw": "Modules: `module` API",
       "name": "modules:_`module`_api",
-      "introduced_in": "v0.3.7",
+      "introduced_in": "v12.20.0",
+      "meta": {
+        "added": [
+          "v0.3.7"
+        ],
+        "changes": []
+      },
       "modules": [
         {
           "textRaw": "The `Module` object",
@@ -42081,7 +46676,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A list of the names of all modules provided by Node.js. Can be used to verify\nif a module is maintained by a third party or not.</p>\n<p><code>module</code> in this context isn't the same object that's provided\nby the <a href=\"modules_cjs.html#modules_cjs_the_module_wrapper\">module wrapper</a>. To access it, require the <code>Module</code> module:</p>\n<pre><code class=\"language-js\">// module.mjs\n// In an ECMAScript module\nimport { builtinModules as builtin } from 'module';\n</code></pre>\n<pre><code class=\"language-js\">// module.cjs\n// In a CommonJS module\nconst builtin = require('module').builtinModules;\n</code></pre>"
+              "desc": "<p>A list of the names of all modules provided by Node.js. Can be used to verify\nif a module is maintained by a third party or not.</p>\n<p><code>module</code> in this context isn't the same object that's provided\nby the <a href=\"modules.html#modules_the_module_wrapper\">module wrapper</a>. To access it, require the <code>Module</code> module:</p>\n<pre><code class=\"language-mjs\">// module.mjs\n// In an ECMAScript module\nimport { builtinModules as builtin } from 'module';\n</code></pre>\n<pre><code class=\"language-cjs\">// module.cjs\n// In a CommonJS module\nconst builtin = require('module').builtinModules;\n</code></pre>"
             }
           ],
           "methods": [
@@ -42113,7 +46708,7 @@
                   ]
                 }
               ],
-              "desc": "<pre><code class=\"language-js\">import { createRequire } from 'module';\nconst require = createRequire(import.meta.url);\n\n// sibling-module.js is a CommonJS module.\nconst siblingModule = require('./sibling-module');\n</code></pre>"
+              "desc": "<pre><code class=\"language-mjs\">import { createRequire } from 'module';\nconst require = createRequire(import.meta.url);\n\n// sibling-module.js is a CommonJS module.\nconst siblingModule = require('./sibling-module');\n</code></pre>"
             },
             {
               "textRaw": "`module.createRequireFromPath(filename)`",
@@ -42165,7 +46760,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>The <code>module.syncBuiltinESMExports()</code> method updates all the live bindings for\nbuiltin <a href=\"esm.html\">ES Modules</a> to match the properties of the <a href=\"modules.html\">CommonJS</a> exports. It\ndoes not add or remove exported names from the <a href=\"esm.html\">ES Modules</a>.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst { syncBuiltinESMExports } = require('module');\n\nfs.readFile = null;\n\ndelete fs.readFileSync;\n\nfs.newAPI = function newAPI() {\n  // ...\n};\n\nsyncBuiltinESMExports();\n\nimport('fs').then((esmFS) => {\n  assert.strictEqual(esmFS.readFile, null);\n  assert.strictEqual('readFileSync' in fs, true);\n  assert.strictEqual(esmFS.newAPI, undefined);\n});\n</code></pre>"
+              "desc": "<p>The <code>module.syncBuiltinESMExports()</code> method updates all the live bindings for\nbuiltin <a href=\"esm.html\">ES Modules</a> to match the properties of the <a href=\"modules.html\">CommonJS</a> exports. It\ndoes not add or remove exported names from the <a href=\"esm.html\">ES Modules</a>.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst assert = require('assert');\nconst { syncBuiltinESMExports } = require('module');\n\nfs.readFile = newAPI;\n\ndelete fs.readFileSync;\n\nfunction newAPI() {\n  // ...\n}\n\nfs.newAPI = newAPI;\n\nsyncBuiltinESMExports();\n\nimport('fs').then((esmFS) => {\n  // It syncs the existing readFile property with the new value\n  assert.strictEqual(esmFS.readFile, newAPI);\n  // readFileSync has been deleted from the required fs\n  assert.strictEqual('readFileSync' in fs, false);\n  // syncBuiltinESMExports() does not remove readFileSync from esmFS\n  assert.strictEqual('readFileSync' in esmFS, true);\n  // syncBuiltinESMExports() does not add names\n  assert.strictEqual(esmFS.newAPI, undefined);\n});\n</code></pre>"
             }
           ],
           "type": "module",
@@ -42183,10 +46778,10 @@
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p>Helpers for interacting with the source map cache. This cache is\npopulated when source map parsing is enabled and\n<a href=\"https://sourcemaps.info/spec.html#h.lmz475t4mvbx\">source map include directives</a> are found in a modules' footer.</p>\n<p>To enable source map parsing, Node.js must be run with the flag\n<a href=\"cli.html#cli_enable_source_maps\"><code>--enable-source-maps</code></a>, or with code coverage enabled by setting\n<a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE=dir</code></a>.</p>\n<pre><code class=\"language-js\">// module.mjs\n// In an ECMAScript module\nimport { findSourceMap, SourceMap } from 'module';\n</code></pre>\n<pre><code class=\"language-js\">// module.cjs\n// In a CommonJS module\nconst { findSourceMap, SourceMap } = require('module');\n</code></pre>",
+          "desc": "<p>Helpers for interacting with the source map cache. This cache is\npopulated when source map parsing is enabled and\n<a href=\"https://sourcemaps.info/spec.html#h.lmz475t4mvbx\">source map include directives</a> are found in a modules' footer.</p>\n<p>To enable source map parsing, Node.js must be run with the flag\n<a href=\"cli.html#cli_enable_source_maps\"><code>--enable-source-maps</code></a>, or with code coverage enabled by setting\n<a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE=dir</code></a>.</p>\n<pre><code class=\"language-mjs\">// module.mjs\n// In an ECMAScript module\nimport { findSourceMap, SourceMap } from 'module';\n</code></pre>\n<pre><code class=\"language-cjs\">// module.cjs\n// In a CommonJS module\nconst { findSourceMap, SourceMap } = require('module');\n</code></pre>\n<!-- Anchors to make sure old links find a target -->\n<p><a id=\"module_module_findsourcemap_path_error\"></a></p>",
           "methods": [
             {
-              "textRaw": "`module.findSourceMap(path[, error])`",
+              "textRaw": "`module.findSourceMap(path)`",
               "type": "method",
               "name": "findSourceMap",
               "meta": {
@@ -42208,16 +46803,11 @@
                       "textRaw": "`path` {string}",
                       "name": "path",
                       "type": "string"
-                    },
-                    {
-                      "textRaw": "`error` {Error}",
-                      "name": "error",
-                      "type": "Error"
                     }
                   ]
                 }
               ],
-              "desc": "<p><code>path</code> is the resolved path for the file for which a corresponding source map\nshould be fetched.</p>\n<p>The <code>error</code> instance should be passed as the second parameter to <code>findSourceMap</code>\nin exceptional flows, such as when an overridden\n<a href=\"https://v8.dev/docs/stack-trace-api#customizing-stack-traces\"><code>Error.prepareStackTrace(error, trace)</code></a> is invoked. Modules are not added to\nthe module cache until they are successfully loaded. In these cases, source maps\nare associated with the <code>error</code> instance along with the <code>path</code>.</p>"
+              "desc": "<p><code>path</code> is the resolved path for the file for which a corresponding source map\nshould be fetched.</p>"
             }
           ],
           "classes": [
@@ -42266,7 +46856,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Given a line number and column number in the generated source file, returns\nan object representing the position in the original file. The object returned\nconsists of the following keys:</p>\n<ul>\n<li>generatedLine: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>generatedColumn: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>originalSource: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li>originalLine: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>originalColumn: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>"
+                  "desc": "<p>Given a line number and column number in the generated source file, returns\nan object representing the position in the original file. The object returned\nconsists of the following keys:</p>\n<ul>\n<li>generatedLine: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>generatedColumn: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>originalSource: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li>originalLine: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>originalColumn: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>name: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>"
                 }
               ],
               "signatures": [
@@ -42288,13 +46878,14 @@
         }
       ],
       "type": "module",
-      "displayName": "Modules: `module` API"
+      "displayName": "Modules: `module` API",
+      "source": "doc/api/module.md"
     },
     {
       "textRaw": "Net",
       "name": "net",
       "introduced_in": "v0.10.0",
-      "desc": "<!--lint disable maximum-line-length-->\n<blockquote>\n<p>Stability: 2 - Stable</p>\n</blockquote>\n<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/net.js\">lib/net.js</a></p>\n<p>The <code>net</code> module provides an asynchronous network API for creating stream-based\nTCP or <a href=\"net.html#net_ipc_support\">IPC</a> servers (<a href=\"net.html#net_net_createserver_options_connectionlistener\"><code>net.createServer()</code></a>) and clients\n(<a href=\"net.html#net_net_createconnection\"><code>net.createConnection()</code></a>).</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const net = require('net');\n</code></pre>",
+      "desc": "<!--lint disable maximum-line-length-->\n<blockquote>\n<p>Stability: 2 - Stable</p>\n</blockquote>\n<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/net.js\">lib/net.js</a></p>\n<p>The <code>net</code> module provides an asynchronous network API for creating stream-based\nTCP or <a href=\"net.html#net_ipc_support\">IPC</a> servers (<a href=\"net.html#net_net_createserver_options_connectionlistener\"><code>net.createServer()</code></a>) and clients\n(<a href=\"net.html#net_net_createconnection\"><code>net.createConnection()</code></a>).</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const net = require('net');\n</code></pre>",
       "modules": [
         {
           "textRaw": "IPC support",
@@ -42314,6 +46905,270 @@
         }
       ],
       "classes": [
+        {
+          "textRaw": "Class: `net.BlockList`",
+          "type": "class",
+          "name": "net.BlockList",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>The <code>BlockList</code> object can be used with some network APIs to specify rules for\ndisabling inbound or outbound access to specific IP addresses, IP ranges, or\nIP subnets.</p>",
+          "methods": [
+            {
+              "textRaw": "`blockList.addAddress(address[, type])`",
+              "type": "method",
+              "name": "addAddress",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`address` {string|net.SocketAddress} An IPv4 or IPv6 address.",
+                      "name": "address",
+                      "type": "string|net.SocketAddress",
+                      "desc": "An IPv4 or IPv6 address."
+                    },
+                    {
+                      "textRaw": "`type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.",
+                      "name": "type",
+                      "type": "string",
+                      "default": "`'ipv4'`",
+                      "desc": "Either `'ipv4'` or `'ipv6'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Adds a rule to block the given IP address.</p>"
+            },
+            {
+              "textRaw": "`blockList.addRange(start, end[, type])`",
+              "type": "method",
+              "name": "addRange",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`start` {string|net.SocketAddress} The starting IPv4 or IPv6 address in the range.",
+                      "name": "start",
+                      "type": "string|net.SocketAddress",
+                      "desc": "The starting IPv4 or IPv6 address in the range."
+                    },
+                    {
+                      "textRaw": "`end` {string|net.SocketAddress} The ending IPv4 or IPv6 address in the range.",
+                      "name": "end",
+                      "type": "string|net.SocketAddress",
+                      "desc": "The ending IPv4 or IPv6 address in the range."
+                    },
+                    {
+                      "textRaw": "`type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.",
+                      "name": "type",
+                      "type": "string",
+                      "default": "`'ipv4'`",
+                      "desc": "Either `'ipv4'` or `'ipv6'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Adds a rule to block a range of IP addresses from <code>start</code> (inclusive) to\n<code>end</code> (inclusive).</p>"
+            },
+            {
+              "textRaw": "`blockList.addSubnet(net, prefix[, type])`",
+              "type": "method",
+              "name": "addSubnet",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`net` {string|net.SocketAddress} The network IPv4 or IPv6 address.",
+                      "name": "net",
+                      "type": "string|net.SocketAddress",
+                      "desc": "The network IPv4 or IPv6 address."
+                    },
+                    {
+                      "textRaw": "`prefix` {number} The number of CIDR prefix bits. For IPv4, this must be a value between `0` and `32`. For IPv6, this must be between `0` and `128`.",
+                      "name": "prefix",
+                      "type": "number",
+                      "desc": "The number of CIDR prefix bits. For IPv4, this must be a value between `0` and `32`. For IPv6, this must be between `0` and `128`."
+                    },
+                    {
+                      "textRaw": "`type` {string} Either `'ipv4'` or `'ipv6'`. **Default**: `'ipv4'`.",
+                      "name": "type",
+                      "type": "string",
+                      "desc": "Either `'ipv4'` or `'ipv6'`. **Default**: `'ipv4'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Adds a rule to block a range of IP addresses specified as a subnet mask.</p>"
+            },
+            {
+              "textRaw": "`blockList.check(address[, type])`",
+              "type": "method",
+              "name": "check",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`address` {string|net.SocketAddress} The IP address to check",
+                      "name": "address",
+                      "type": "string|net.SocketAddress",
+                      "desc": "The IP address to check"
+                    },
+                    {
+                      "textRaw": "`type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.",
+                      "name": "type",
+                      "type": "string",
+                      "default": "`'ipv4'`",
+                      "desc": "Either `'ipv4'` or `'ipv6'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns <code>true</code> if the given IP address matches any of the rules added to the\n<code>BlockList</code>.</p>\n<pre><code class=\"language-js\">const blockList = new net.BlockList();\nblockList.addAddress('123.123.123.123');\nblockList.addRange('10.0.0.1', '10.0.0.10');\nblockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');\n\nconsole.log(blockList.check('123.123.123.123'));  // Prints: true\nconsole.log(blockList.check('10.0.0.3'));  // Prints: true\nconsole.log(blockList.check('222.111.111.222'));  // Prints: false\n\n// IPv6 notation for IPv4 addresses works:\nconsole.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true\nconsole.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true\n</code></pre>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`rules` Type: {string[]}",
+              "type": "string[]",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The list of rules added to the blocklist.</p>"
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `net.SocketAddress`",
+          "type": "class",
+          "name": "net.SocketAddress",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "properties": [
+            {
+              "textRaw": "`address` Type {string}",
+              "type": "string",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "Either `'ipv4'` or `'ipv6'`."
+            },
+            {
+              "textRaw": "`family` Type {string} Either `'ipv4'` or `'ipv6'`.",
+              "type": "string",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "Either `'ipv4'` or `'ipv6'`."
+            },
+            {
+              "textRaw": "`flowlabel` Type {number}",
+              "type": "number",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              }
+            },
+            {
+              "textRaw": "`port` Type {number}",
+              "type": "number",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              }
+            }
+          ],
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`address` {string} The network address as either an IPv4 or IPv6 string. **Default**: `'127.0.0.1'` if `family` is `'ipv4'`; `'::'` if `family` is `'ipv6'`.",
+                      "name": "address",
+                      "type": "string",
+                      "desc": "The network address as either an IPv4 or IPv6 string. **Default**: `'127.0.0.1'` if `family` is `'ipv4'`; `'::'` if `family` is `'ipv6'`."
+                    },
+                    {
+                      "textRaw": "`family` {string} One of either `'ipv4'` or 'ipv6'`. **Default**: `'ipv4'`.",
+                      "name": "family",
+                      "type": "string",
+                      "desc": "One of either `'ipv4'` or 'ipv6'`. **Default**: `'ipv4'`."
+                    },
+                    {
+                      "textRaw": "`flowlabel` {number} An IPv6 flow-label used only if `family` is `'ipv6'`.",
+                      "name": "flowlabel",
+                      "type": "number",
+                      "desc": "An IPv6 flow-label used only if `family` is `'ipv6'`."
+                    },
+                    {
+                      "textRaw": "`port` {number} An IP port.",
+                      "name": "port",
+                      "type": "number",
+                      "desc": "An IP port."
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
         {
           "textRaw": "Class: `net.Server`",
           "type": "class",
@@ -42479,7 +47334,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Start a server listening for connections. A <code>net.Server</code> can be a TCP or\nan <a href=\"net.html#net_ipc_support\">IPC</a> server depending on what it listens to.</p>\n<p>Possible signatures:</p>\n<ul>\n<li><a href=\"net.html#net_server_listen_handle_backlog_callback\"><code>server.listen(handle[, backlog][, callback])</code></a></li>\n<li><a href=\"net.html#net_server_listen_options_callback\"><code>server.listen(options[, callback])</code></a></li>\n<li><a href=\"net.html#net_server_listen_path_backlog_callback\"><code>server.listen(path[, backlog][, callback])</code></a>\nfor <a href=\"net.html#net_ipc_support\">IPC</a> servers</li>\n<li>\n<a href=\"net.html#net_server_listen_port_host_backlog_callback\">\n<code>server.listen([port[, host[, backlog]]][, callback])</code></a>\nfor TCP servers\n</li>\n</ul>\n<p>This function is asynchronous. When the server starts listening, the\n<a href=\"net.html#net_event_listening\"><code>'listening'</code></a> event will be emitted. The last parameter <code>callback</code>\nwill be added as a listener for the <a href=\"net.html#net_event_listening\"><code>'listening'</code></a> event.</p>\n<p>All <code>listen()</code> methods can take a <code>backlog</code> parameter to specify the maximum\nlength of the queue of pending connections. The actual length will be determined\nby the OS through sysctl settings such as <code>tcp_max_syn_backlog</code> and <code>somaxconn</code>\non Linux. The default value of this parameter is 511 (not 512).</p>\n<p>All <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> are set to <code>SO_REUSEADDR</code> (see <a href=\"https://man7.org/linux/man-pages/man7/socket.7.html\"><code>socket(7)</code></a> for\ndetails).</p>\n<p>The <code>server.listen()</code> method can be called again if and only if there was an\nerror during the first <code>server.listen()</code> call or <code>server.close()</code> has been\ncalled. Otherwise, an <code>ERR_SERVER_ALREADY_LISTEN</code> error will be thrown.</p>\n<p>One of the most common errors raised when listening is <code>EADDRINUSE</code>.\nThis happens when another server is already listening on the requested\n<code>port</code>/<code>path</code>/<code>handle</code>. One way to handle this would be to retry\nafter a certain amount of time:</p>\n<pre><code class=\"language-js\">server.on('error', (e) => {\n  if (e.code === 'EADDRINUSE') {\n    console.log('Address in use, retrying...');\n    setTimeout(() => {\n      server.close();\n      server.listen(PORT, HOST);\n    }, 1000);\n  }\n});\n</code></pre>",
+              "desc": "<p>Start a server listening for connections. A <code>net.Server</code> can be a TCP or\nan <a href=\"net.html#net_ipc_support\">IPC</a> server depending on what it listens to.</p>\n<p>Possible signatures:</p>\n<!--lint disable no-undefined-references-->\n<ul>\n<li><a href=\"net.html#net_server_listen_handle_backlog_callback\"><code>server.listen(handle[, backlog][, callback])</code></a></li>\n<li><a href=\"net.html#net_server_listen_options_callback\"><code>server.listen(options[, callback])</code></a></li>\n<li><a href=\"net.html#net_server_listen_path_backlog_callback\"><code>server.listen(path[, backlog][, callback])</code></a>\nfor <a href=\"net.html#net_ipc_support\">IPC</a> servers</li>\n<li>\n<a href=\"net.html#net_server_listen_port_host_backlog_callback\">\n<code>server.listen([port[, host[, backlog]]][, callback])</code></a>\nfor TCP servers\n</li>\n</ul>\n<!--lint enable no-undefined-references-->\n<p>This function is asynchronous. When the server starts listening, the\n<a href=\"net.html#net_event_listening\"><code>'listening'</code></a> event will be emitted. The last parameter <code>callback</code>\nwill be added as a listener for the <a href=\"net.html#net_event_listening\"><code>'listening'</code></a> event.</p>\n<p>All <code>listen()</code> methods can take a <code>backlog</code> parameter to specify the maximum\nlength of the queue of pending connections. The actual length will be determined\nby the OS through sysctl settings such as <code>tcp_max_syn_backlog</code> and <code>somaxconn</code>\non Linux. The default value of this parameter is 511 (not 512).</p>\n<p>All <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> are set to <code>SO_REUSEADDR</code> (see <a href=\"https://man7.org/linux/man-pages/man7/socket.7.html\"><code>socket(7)</code></a> for\ndetails).</p>\n<p>The <code>server.listen()</code> method can be called again if and only if there was an\nerror during the first <code>server.listen()</code> call or <code>server.close()</code> has been\ncalled. Otherwise, an <code>ERR_SERVER_ALREADY_LISTEN</code> error will be thrown.</p>\n<p>One of the most common errors raised when listening is <code>EADDRINUSE</code>.\nThis happens when another server is already listening on the requested\n<code>port</code>/<code>path</code>/<code>handle</code>. One way to handle this would be to retry\nafter a certain amount of time:</p>\n<pre><code class=\"language-js\">server.on('error', (e) => {\n  if (e.code === 'EADDRINUSE') {\n    console.log('Address in use, retrying...');\n    setTimeout(() => {\n      server.close();\n      server.listen(PORT, HOST);\n    }, 1000);\n  }\n});\n</code></pre>",
               "methods": [
                 {
                   "textRaw": "`server.listen(handle[, backlog][, callback])`",
@@ -42610,7 +47465,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>If <code>port</code> is specified, it behaves the same as\n<a href=\"net.html#net_server_listen_port_host_backlog_callback\">\n<code>server.listen([port[, host[, backlog]]][, callback])</code></a>.\nOtherwise, if <code>path</code> is specified, it behaves the same as\n<a href=\"net.html#net_server_listen_path_backlog_callback\"><code>server.listen(path[, backlog][, callback])</code></a>.\nIf none of them is specified, an error will be thrown.</p>\n<p>If <code>exclusive</code> is <code>false</code> (default), then cluster workers will use the same\nunderlying handle, allowing connection handling duties to be shared. When\n<code>exclusive</code> is <code>true</code>, the handle is not shared, and attempted port sharing\nresults in an error. An example which listens on an exclusive port is\nshown below.</p>\n<pre><code class=\"language-js\">server.listen({\n  host: 'localhost',\n  port: 80,\n  exclusive: true\n});\n</code></pre>\n<p>Starting an IPC server as root may cause the server path to be inaccessible for\nunprivileged users. Using <code>readableAll</code> and <code>writableAll</code> will make the server\naccessible for all users.</p>"
+                  "desc": "<!--lint disable no-undefined-references-->\n<p>If <code>port</code> is specified, it behaves the same as\n<a href=\"net.html#net_server_listen_port_host_backlog_callback\">\n<code>server.listen([port[, host[, backlog]]][, callback])</code></a>.\nOtherwise, if <code>path</code> is specified, it behaves the same as\n<a href=\"net.html#net_server_listen_path_backlog_callback\"><code>server.listen(path[, backlog][, callback])</code></a>.\nIf none of them is specified, an error will be thrown.</p>\n<!--lint enable no-undefined-references-->\n<p>If <code>exclusive</code> is <code>false</code> (default), then cluster workers will use the same\nunderlying handle, allowing connection handling duties to be shared. When\n<code>exclusive</code> is <code>true</code>, the handle is not shared, and attempted port sharing\nresults in an error. An example which listens on an exclusive port is\nshown below.</p>\n<pre><code class=\"language-js\">server.listen({\n  host: 'localhost',\n  port: 80,\n  exclusive: true\n});\n</code></pre>\n<p>Starting an IPC server as root may cause the server path to be inaccessible for\nunprivileged users. Using <code>readableAll</code> and <code>writableAll</code> will make the server\naccessible for all users.</p>"
                 },
                 {
                   "textRaw": "`server.listen(path[, backlog][, callback])`",
@@ -42900,7 +47755,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>Emitted when the other end of the socket sends a FIN packet, thus ending the\nreadable side of the socket.</p>\n<p>By default (<code>allowHalfOpen</code> is <code>false</code>) the socket will send a FIN packet\nback and destroy its file descriptor once it has written out its pending\nwrite queue. However, if <code>allowHalfOpen</code> is set to <code>true</code>, the socket will\nnot automatically <a href=\"net.html#net_socket_end_data_encoding_callback\"><code>end()</code></a> its writable side, allowing the\nuser to write arbitrary amounts of data. The user must call\n<a href=\"net.html#net_socket_end_data_encoding_callback\"><code>end()</code></a> explicitly to close the connection (i.e. sending a\nFIN packet back).</p>"
+              "desc": "<p>Emitted when the other end of the socket signals the end of transmission, thus\nending the readable side of the socket.</p>\n<p>By default (<code>allowHalfOpen</code> is <code>false</code>) the socket will send an end of\ntransmission packet back and destroy its file descriptor once it has written out\nits pending write queue. However, if <code>allowHalfOpen</code> is set to <code>true</code>, the\nsocket will not automatically <a href=\"net.html#net_socket_end_data_encoding_callback\"><code>end()</code></a> its writable side,\nallowing the user to write arbitrary amounts of data. The user must call\n<a href=\"net.html#net_socket_end_data_encoding_callback\"><code>end()</code></a> explicitly to close the connection (i.e. sending a\nFIN packet back).</p>"
             },
             {
               "textRaw": "Event: `'error'`",
@@ -43289,7 +48144,16 @@
                 "added": [
                   "v0.1.92"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.12.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/32204",
+                    "description": "New defaults for `TCP_KEEPCNT` and `TCP_KEEPINTVL` socket options were added."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -43315,7 +48179,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Enable/disable keep-alive functionality, and optionally set the initial\ndelay before the first keepalive probe is sent on an idle socket.</p>\n<p>Set <code>initialDelay</code> (in milliseconds) to set the delay between the last\ndata packet received and the first keepalive probe. Setting <code>0</code> for\n<code>initialDelay</code> will leave the value unchanged from the default\n(or previous) setting.</p>"
+              "desc": "<p>Enable/disable keep-alive functionality, and optionally set the initial\ndelay before the first keepalive probe is sent on an idle socket.</p>\n<p>Set <code>initialDelay</code> (in milliseconds) to set the delay between the last\ndata packet received and the first keepalive probe. Setting <code>0</code> for\n<code>initialDelay</code> will leave the value unchanged from the default\n(or previous) setting.</p>\n<p>Enabling the keep-alive functionality will set the following socket options:</p>\n<ul>\n<li><code>SO_KEEPALIVE=1</code></li>\n<li><code>TCP_KEEPIDLE=initialDelay</code></li>\n<li><code>TCP_KEEPCNT=10</code></li>\n<li><code>TCP_KEEPINTVL=1</code></li>\n</ul>"
             },
             {
               "textRaw": "`socket.setNoDelay([noDelay])`",
@@ -43454,8 +48318,13 @@
                 "added": [
                   "v0.3.8"
                 ],
+                "deprecated": [
+                  "v14.6.0"
+                ],
                 "changes": []
               },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use [`writable.writableLength`][] instead.",
               "desc": "<p>This property shows the number of characters buffered for writing. The buffer\nmay contain strings whose length after encoding is not yet known. So this number\nis only an approximation of the number of bytes in the buffer.</p>\n<p><code>net.Socket</code> has the property that <code>socket.write()</code> always works. This is to\nhelp users get up and running quickly. The computer cannot always keep up\nwith the amount of data that is written to a socket. The network connection\nsimply might be too slow. Node.js will internally queue up the data written to a\nsocket and send it out over the wire when it is possible.</p>\n<p>The consequence of this internal buffering is that memory may grow.\nUsers who experience large or growing <code>bufferSize</code> should attempt to\n\"throttle\" the data flows in their program with\n<a href=\"net.html#net_socket_pause\"><code>socket.pause()</code></a> and <a href=\"net.html#net_socket_resume\"><code>socket.resume()</code></a>.</p>"
             },
             {
@@ -43531,7 +48400,8 @@
               "name": "pending",
               "meta": {
                 "added": [
-                  "v11.2.0"
+                  "v11.2.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -43572,6 +48442,30 @@
                 "changes": []
               },
               "desc": "<p>The numeric representation of the remote port. For example, <code>80</code> or <code>21</code>.</p>"
+            },
+            {
+              "textRaw": "`timeout` {number|undefined}",
+              "type": "number|undefined",
+              "name": "timeout",
+              "meta": {
+                "added": [
+                  "v10.7.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The socket timeout in milliseconds as set by <a href=\"net.html#net_socket_settimeout_timeout_callback\"><code>socket.setTimeout()</code></a>.\nIt is <code>undefined</code> if a timeout has not been set.</p>"
+            },
+            {
+              "textRaw": "`readyState` {string}",
+              "type": "string",
+              "name": "readyState",
+              "meta": {
+                "added": [
+                  "v0.5.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>This property represents the state of the connection as a string.</p>\n<ul>\n<li>If the stream is connecting <code>socket.readyState</code> is <code>opening</code>.</li>\n<li>If the stream is readable and writable, it is <code>open</code>.</li>\n<li>If the stream is readable and not writable, it is <code>readOnly</code>.</li>\n<li>If the stream is not readable and writable, it is <code>writeOnly</code>.</li>\n</ul>"
             }
           ],
           "signatures": [
@@ -43595,11 +48489,11 @@
                       "desc": "If specified, wrap around an existing socket with the given file descriptor, otherwise a new socket will be created."
                     },
                     {
-                      "textRaw": "`allowHalfOpen` {boolean} Indicates whether half-opened TCP connections are allowed. See [`net.createServer()`][] and the [`'end'`][] event for details. **Default:** `false`.",
+                      "textRaw": "`allowHalfOpen` {boolean} If set to `false`, then the socket will automatically end the writable side when the readable side ends. See [`net.createServer()`][] and the [`'end'`][] event for details. **Default:** `false`.",
                       "name": "allowHalfOpen",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "Indicates whether half-opened TCP connections are allowed. See [`net.createServer()`][] and the [`'end'`][] event for details."
+                      "desc": "If set to `false`, then the socket will automatically end the writable side when the readable side ends. See [`net.createServer()`][] and the [`'end'`][] event for details."
                     },
                     {
                       "textRaw": "`readable` {boolean} Allow reads on the socket when an `fd` is passed, otherwise ignored. **Default:** `false`.",
@@ -43893,11 +48787,11 @@
                   "type": "Object",
                   "options": [
                     {
-                      "textRaw": "`allowHalfOpen` {boolean} Indicates whether half-opened TCP connections are allowed. **Default:** `false`.",
+                      "textRaw": "`allowHalfOpen` {boolean} If set to `false`, then the socket will automatically end the writable side when the readable side ends. **Default:** `false`.",
                       "name": "allowHalfOpen",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "Indicates whether half-opened TCP connections are allowed."
+                      "desc": "If set to `false`, then the socket will automatically end the writable side when the readable side ends."
                     },
                     {
                       "textRaw": "`pauseOnConnect` {boolean} Indicates whether the socket should be paused on incoming connections. **Default:** `false`.",
@@ -43917,7 +48811,7 @@
               ]
             }
           ],
-          "desc": "<p>Creates a new TCP or <a href=\"net.html#net_ipc_support\">IPC</a> server.</p>\n<p>If <code>allowHalfOpen</code> is set to <code>true</code>, when the other end of the socket\nsends a FIN packet, the server will only send a FIN packet back when\n<a href=\"net.html#net_socket_end_data_encoding_callback\"><code>socket.end()</code></a> is explicitly called, until then the connection is\nhalf-closed (non-readable but still writable). See <a href=\"net.html#net_event_end\"><code>'end'</code></a> event\nand <a href=\"https://tools.ietf.org/html/rfc1122\">RFC 1122</a> (section 4.2.2.13) for more information.</p>\n<p>If <code>pauseOnConnect</code> is set to <code>true</code>, then the socket associated with each\nincoming connection will be paused, and no data will be read from its handle.\nThis allows connections to be passed between processes without any data being\nread by the original process. To begin reading data from a paused socket, call\n<a href=\"net.html#net_socket_resume\"><code>socket.resume()</code></a>.</p>\n<p>The server can be a TCP server or an <a href=\"net.html#net_ipc_support\">IPC</a> server, depending on what it\n<a href=\"net.html#net_server_listen\"><code>listen()</code></a> to.</p>\n<p>Here is an example of an TCP echo server which listens for connections\non port 8124:</p>\n<pre><code class=\"language-js\">const net = require('net');\nconst server = net.createServer((c) => {\n  // 'connection' listener.\n  console.log('client connected');\n  c.on('end', () => {\n    console.log('client disconnected');\n  });\n  c.write('hello\\r\\n');\n  c.pipe(c);\n});\nserver.on('error', (err) => {\n  throw err;\n});\nserver.listen(8124, () => {\n  console.log('server bound');\n});\n</code></pre>\n<p>Test this by using <code>telnet</code>:</p>\n<pre><code class=\"language-console\">$ telnet localhost 8124\n</code></pre>\n<p>To listen on the socket <code>/tmp/echo.sock</code>:</p>\n<pre><code class=\"language-js\">server.listen('/tmp/echo.sock', () => {\n  console.log('server bound');\n});\n</code></pre>\n<p>Use <code>nc</code> to connect to a Unix domain socket server:</p>\n<pre><code class=\"language-console\">$ nc -U /tmp/echo.sock\n</code></pre>"
+          "desc": "<p>Creates a new TCP or <a href=\"net.html#net_ipc_support\">IPC</a> server.</p>\n<p>If <code>allowHalfOpen</code> is set to <code>true</code>, when the other end of the socket\nsignals the end of transmission, the server will only send back the end of\ntransmission when <a href=\"net.html#net_socket_end_data_encoding_callback\"><code>socket.end()</code></a> is explicitly called. For example, in the\ncontext of TCP, when a FIN packed is received, a FIN packed is sent\nback only when <a href=\"net.html#net_socket_end_data_encoding_callback\"><code>socket.end()</code></a> is explicitly called. Until then the\nconnection is half-closed (non-readable but still writable). See <a href=\"net.html#net_event_end\"><code>'end'</code></a>\nevent and <a href=\"https://tools.ietf.org/html/rfc1122\">RFC 1122</a> (section 4.2.2.13) for more information.</p>\n<p>If <code>pauseOnConnect</code> is set to <code>true</code>, then the socket associated with each\nincoming connection will be paused, and no data will be read from its handle.\nThis allows connections to be passed between processes without any data being\nread by the original process. To begin reading data from a paused socket, call\n<a href=\"net.html#net_socket_resume\"><code>socket.resume()</code></a>.</p>\n<p>The server can be a TCP server or an <a href=\"net.html#net_ipc_support\">IPC</a> server, depending on what it\n<a href=\"net.html#net_server_listen\"><code>listen()</code></a> to.</p>\n<p>Here is an example of an TCP echo server which listens for connections\non port 8124:</p>\n<pre><code class=\"language-js\">const net = require('net');\nconst server = net.createServer((c) => {\n  // 'connection' listener.\n  console.log('client connected');\n  c.on('end', () => {\n    console.log('client disconnected');\n  });\n  c.write('hello\\r\\n');\n  c.pipe(c);\n});\nserver.on('error', (err) => {\n  throw err;\n});\nserver.listen(8124, () => {\n  console.log('server bound');\n});\n</code></pre>\n<p>Test this by using <code>telnet</code>:</p>\n<pre><code class=\"language-console\">$ telnet localhost 8124\n</code></pre>\n<p>To listen on the socket <code>/tmp/echo.sock</code>:</p>\n<pre><code class=\"language-js\">server.listen('/tmp/echo.sock', () => {\n  console.log('server bound');\n});\n</code></pre>\n<p>Use <code>nc</code> to connect to a Unix domain socket server:</p>\n<pre><code class=\"language-console\">$ nc -U /tmp/echo.sock\n</code></pre>"
         },
         {
           "textRaw": "`net.isIP(input)`",
@@ -44005,7 +48899,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Net"
+      "displayName": "Net",
+      "source": "doc/api/net.md"
     },
     {
       "textRaw": "OS",
@@ -44013,7 +48908,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/os.js\">lib/os.js</a></p>\n<p>The <code>os</code> module provides operating system-related utility methods and\nproperties. It can be accessed using:</p>\n<pre><code class=\"language-js\">const os = require('os');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/os.js\">lib/os.js</a></p>\n<p>The <code>os</code> module provides operating system-related utility methods and\nproperties. It can be accessed using:</p>\n<pre><code class=\"language-js\">const os = require('os');\n</code></pre>",
       "properties": [
         {
           "textRaw": "`EOL` {string}",
@@ -44038,6 +48933,18 @@
             "changes": []
           },
           "desc": "<p>Contains commonly used operating system-specific constants for error codes,\nprocess signals, and so on. The specific constants defined are described in\n<a href=\"os.html#os_os_constants_1\">OS constants</a>.</p>"
+        },
+        {
+          "textRaw": "`devNull` {string}",
+          "type": "string",
+          "name": "devNull",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>The platform-specific file path of the null device.</p>\n<ul>\n<li><code>\\\\.\\nul</code> on Windows</li>\n<li><code>/dev/null</code> on POSIX</li>\n</ul>"
         }
       ],
       "methods": [
@@ -44083,7 +48990,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns an array of objects containing information about each logical CPU core.</p>\n<p>The properties included on each object include:</p>\n<ul>\n<li><code>model</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>speed</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> (in MHz)</li>\n<li><code>times</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>user</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in user mode.</li>\n<li><code>nice</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in nice mode.</li>\n<li><code>sys</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in sys mode.</li>\n<li><code>idle</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in idle mode.</li>\n<li><code>irq</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in irq mode.</li>\n</ul>\n</li>\n</ul>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 252020,\n      nice: 0,\n      sys: 30340,\n      idle: 1070356870,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 306960,\n      nice: 0,\n      sys: 26980,\n      idle: 1071569080,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 248450,\n      nice: 0,\n      sys: 21750,\n      idle: 1070919370,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 256880,\n      nice: 0,\n      sys: 19430,\n      idle: 1070905480,\n      irq: 20\n    }\n  }\n]\n</code></pre>\n<p><code>nice</code> values are POSIX-only. On Windows, the <code>nice</code> values of all processors\nare always 0.</p>"
+          "desc": "<p>Returns an array of objects containing information about each logical CPU core.</p>\n<p>The properties included on each object include:</p>\n<ul>\n<li><code>model</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>speed</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> (in MHz)</li>\n<li><code>times</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>user</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in user mode.</li>\n<li><code>nice</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in nice mode.</li>\n<li><code>sys</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in sys mode.</li>\n<li><code>idle</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in idle mode.</li>\n<li><code>irq</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in irq mode.</li>\n</ul>\n</li>\n</ul>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 252020,\n      nice: 0,\n      sys: 30340,\n      idle: 1070356870,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 306960,\n      nice: 0,\n      sys: 26980,\n      idle: 1071569080,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 248450,\n      nice: 0,\n      sys: 21750,\n      idle: 1070919370,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 256880,\n      nice: 0,\n      sys: 19430,\n      idle: 1070905480,\n      irq: 20\n    }\n  },\n]\n</code></pre>\n<p><code>nice</code> values are POSIX-only. On Windows, the <code>nice</code> values of all processors\nare always 0.</p>"
         },
         {
           "textRaw": "`os.endianness()`",
@@ -44266,7 +49173,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns a string identifying the operating system platform. The value is set\nat compile time. Possible values are <code>'aix'</code>, <code>'darwin'</code>, <code>'freebsd'</code>,\n<code>'linux'</code>, <code>'openbsd'</code>, <code>'sunos'</code>, and <code>'win32'</code>.</p>\n<p>The return value is equivalent to <a href=\"process.html#process_process_platform\"><code>process.platform</code></a>.</p>\n<p>The value <code>'android'</code> may also be returned if Node.js is built on the Android\noperating system. <a href=\"https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os\">Android support is experimental</a>.</p>"
+          "desc": "<p>Returns a string identifying the operating system platform. The value is set\nat compile time. Possible values are <code>'aix'</code>, <code>'darwin'</code>, <code>'freebsd'</code>,\n<code>'linux'</code>, <code>'openbsd'</code>, <code>'sunos'</code>, and <code>'win32'</code>.</p>\n<p>The return value is equivalent to <a href=\"process.html#process_process_platform\"><code>process.platform</code></a>.</p>\n<p>The value <code>'android'</code> may also be returned if Node.js is built on the Android\noperating system. <a href=\"https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os\">Android support is experimental</a>.</p>"
         },
         {
           "textRaw": "`os.release()`",
@@ -44332,7 +49239,7 @@
               {
                 "version": "v2.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/747",
-                "description": "This function is now cross-platform consistent and no longer returns a path with a trailing slash on any platform"
+                "description": "This function is now cross-platform consistent and no longer returns a path with a trailing slash on any platform."
               }
             ]
           },
@@ -44463,7 +49370,7 @@
           "name": "version",
           "meta": {
             "added": [
-              "v12.17.0"
+              "v13.11.0"
             ],
             "changes": []
           },
@@ -44498,7 +49405,7 @@
                   }
                 ]
               },
-              "desc": "<p>The following signal constants are exported by <code>os.constants.signals</code>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>SIGHUP</code></td>\n    <td>Sent to indicate when a controlling terminal is closed or a parent\n    process exits.</td>\n  </tr>\n  <tr>\n    <td><code>SIGINT</code></td>\n    <td>Sent to indicate when a user wishes to interrupt a process\n    (<code>(Ctrl+C)</code>).</td>\n  </tr>\n  <tr>\n    <td><code>SIGQUIT</code></td>\n    <td>Sent to indicate when a user wishes to terminate a process and perform a\n    core dump.</td>\n  </tr>\n  <tr>\n    <td><code>SIGILL</code></td>\n    <td>Sent to a process to notify that it has attempted to perform an illegal,\n    malformed, unknown, or privileged instruction.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTRAP</code></td>\n    <td>Sent to a process when an exception has occurred.</td>\n  </tr>\n  <tr>\n    <td><code>SIGABRT</code></td>\n    <td>Sent to a process to request that it abort.</td>\n  </tr>\n  <tr>\n    <td><code>SIGIOT</code></td>\n    <td>Synonym for <code>SIGABRT</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGBUS</code></td>\n    <td>Sent to a process to notify that it has caused a bus error.</td>\n  </tr>\n  <tr>\n    <td><code>SIGFPE</code></td>\n    <td>Sent to a process to notify that it has performed an illegal arithmetic\n    operation.</td>\n  </tr>\n  <tr>\n    <td><code>SIGKILL</code></td>\n    <td>Sent to a process to terminate it immediately.</td>\n  </tr>\n  <tr>\n    <td><code>SIGUSR1</code> <code>SIGUSR2</code></td>\n    <td>Sent to a process to identify user-defined conditions.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSEGV</code></td>\n    <td>Sent to a process to notify of a segmentation fault.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPIPE</code></td>\n    <td>Sent to a process when it has attempted to write to a disconnected\n    pipe.</td>\n  </tr>\n  <tr>\n    <td><code>SIGALRM</code></td>\n    <td>Sent to a process when a system timer elapses.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTERM</code></td>\n    <td>Sent to a process to request termination.</td>\n  </tr>\n  <tr>\n    <td><code>SIGCHLD</code></td>\n    <td>Sent to a process when a child process terminates.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSTKFLT</code></td>\n    <td>Sent to a process to indicate a stack fault on a coprocessor.</td>\n  </tr>\n  <tr>\n    <td><code>SIGCONT</code></td>\n    <td>Sent to instruct the operating system to continue a paused process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSTOP</code></td>\n    <td>Sent to instruct the operating system to halt a process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTSTP</code></td>\n    <td>Sent to a process to request it to stop.</td>\n  </tr>\n  <tr>\n    <td><code>SIGBREAK</code></td>\n    <td>Sent to indicate when a user wishes to interrupt a process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTTIN</code></td>\n    <td>Sent to a process when it reads from the TTY while in the\n    background.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTTOU</code></td>\n    <td>Sent to a process when it writes to the TTY while in the\n    background.</td>\n  </tr>\n  <tr>\n    <td><code>SIGURG</code></td>\n    <td>Sent to a process when a socket has urgent data to read.</td>\n  </tr>\n  <tr>\n    <td><code>SIGXCPU</code></td>\n    <td>Sent to a process when it has exceeded its limit on CPU usage.</td>\n  </tr>\n  <tr>\n    <td><code>SIGXFSZ</code></td>\n    <td>Sent to a process when it grows a file larger than the maximum\n    allowed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGVTALRM</code></td>\n    <td>Sent to a process when a virtual timer has elapsed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPROF</code></td>\n    <td>Sent to a process when a system timer has elapsed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGWINCH</code></td>\n    <td>Sent to a process when the controlling terminal has changed its\n    size.</td>\n  </tr>\n  <tr>\n    <td><code>SIGIO</code></td>\n    <td>Sent to a process when I/O is available.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPOLL</code></td>\n    <td>Synonym for <code>SIGIO</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGLOST</code></td>\n    <td>Sent to a process when a file lock has been lost.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPWR</code></td>\n    <td>Sent to a process to notify of a power failure.</td>\n  </tr>\n  <tr>\n    <td><code>SIGINFO</code></td>\n    <td>Synonym for <code>SIGPWR</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGSYS</code></td>\n    <td>Sent to a process to notify of a bad argument.</td>\n  </tr>\n  <tr>\n    <td><code>SIGUNUSED</code></td>\n    <td>Synonym for <code>SIGSYS</code></td>\n  </tr>\n</table>",
+              "desc": "<p>The following signal constants are exported by <code>os.constants.signals</code>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>SIGHUP</code></td>\n    <td>Sent to indicate when a controlling terminal is closed or a parent\n    process exits.</td>\n  </tr>\n  <tr>\n    <td><code>SIGINT</code></td>\n    <td>Sent to indicate when a user wishes to interrupt a process\n    (<kbd>Ctrl</kbd>+<kbd>C</kbd>).</td>\n  </tr>\n  <tr>\n    <td><code>SIGQUIT</code></td>\n    <td>Sent to indicate when a user wishes to terminate a process and perform a\n    core dump.</td>\n  </tr>\n  <tr>\n    <td><code>SIGILL</code></td>\n    <td>Sent to a process to notify that it has attempted to perform an illegal,\n    malformed, unknown, or privileged instruction.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTRAP</code></td>\n    <td>Sent to a process when an exception has occurred.</td>\n  </tr>\n  <tr>\n    <td><code>SIGABRT</code></td>\n    <td>Sent to a process to request that it abort.</td>\n  </tr>\n  <tr>\n    <td><code>SIGIOT</code></td>\n    <td>Synonym for <code>SIGABRT</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGBUS</code></td>\n    <td>Sent to a process to notify that it has caused a bus error.</td>\n  </tr>\n  <tr>\n    <td><code>SIGFPE</code></td>\n    <td>Sent to a process to notify that it has performed an illegal arithmetic\n    operation.</td>\n  </tr>\n  <tr>\n    <td><code>SIGKILL</code></td>\n    <td>Sent to a process to terminate it immediately.</td>\n  </tr>\n  <tr>\n    <td><code>SIGUSR1</code> <code>SIGUSR2</code></td>\n    <td>Sent to a process to identify user-defined conditions.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSEGV</code></td>\n    <td>Sent to a process to notify of a segmentation fault.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPIPE</code></td>\n    <td>Sent to a process when it has attempted to write to a disconnected\n    pipe.</td>\n  </tr>\n  <tr>\n    <td><code>SIGALRM</code></td>\n    <td>Sent to a process when a system timer elapses.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTERM</code></td>\n    <td>Sent to a process to request termination.</td>\n  </tr>\n  <tr>\n    <td><code>SIGCHLD</code></td>\n    <td>Sent to a process when a child process terminates.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSTKFLT</code></td>\n    <td>Sent to a process to indicate a stack fault on a coprocessor.</td>\n  </tr>\n  <tr>\n    <td><code>SIGCONT</code></td>\n    <td>Sent to instruct the operating system to continue a paused process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSTOP</code></td>\n    <td>Sent to instruct the operating system to halt a process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTSTP</code></td>\n    <td>Sent to a process to request it to stop.</td>\n  </tr>\n  <tr>\n    <td><code>SIGBREAK</code></td>\n    <td>Sent to indicate when a user wishes to interrupt a process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTTIN</code></td>\n    <td>Sent to a process when it reads from the TTY while in the\n    background.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTTOU</code></td>\n    <td>Sent to a process when it writes to the TTY while in the\n    background.</td>\n  </tr>\n  <tr>\n    <td><code>SIGURG</code></td>\n    <td>Sent to a process when a socket has urgent data to read.</td>\n  </tr>\n  <tr>\n    <td><code>SIGXCPU</code></td>\n    <td>Sent to a process when it has exceeded its limit on CPU usage.</td>\n  </tr>\n  <tr>\n    <td><code>SIGXFSZ</code></td>\n    <td>Sent to a process when it grows a file larger than the maximum\n    allowed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGVTALRM</code></td>\n    <td>Sent to a process when a virtual timer has elapsed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPROF</code></td>\n    <td>Sent to a process when a system timer has elapsed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGWINCH</code></td>\n    <td>Sent to a process when the controlling terminal has changed its\n    size.</td>\n  </tr>\n  <tr>\n    <td><code>SIGIO</code></td>\n    <td>Sent to a process when I/O is available.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPOLL</code></td>\n    <td>Synonym for <code>SIGIO</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGLOST</code></td>\n    <td>Sent to a process when a file lock has been lost.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPWR</code></td>\n    <td>Sent to a process to notify of a power failure.</td>\n  </tr>\n  <tr>\n    <td><code>SIGINFO</code></td>\n    <td>Synonym for <code>SIGPWR</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGSYS</code></td>\n    <td>Sent to a process to notify of a bad argument.</td>\n  </tr>\n  <tr>\n    <td><code>SIGUNUSED</code></td>\n    <td>Synonym for <code>SIGSYS</code></td>\n  </tr>\n</table>",
               "type": "module",
               "displayName": "Signal constants"
             },
@@ -44558,7 +49465,8 @@
         }
       ],
       "type": "module",
-      "displayName": "OS"
+      "displayName": "OS",
+      "source": "doc/api/os.md"
     },
     {
       "textRaw": "Path",
@@ -44566,7 +49474,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/path.js\">lib/path.js</a></p>\n<p>The <code>path</code> module provides utilities for working with file and directory paths.\nIt can be accessed using:</p>\n<pre><code class=\"language-js\">const path = require('path');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/path.js\">lib/path.js</a></p>\n<p>The <code>path</code> module provides utilities for working with file and directory paths.\nIt can be accessed using:</p>\n<pre><code class=\"language-js\">const path = require('path');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Windows vs. POSIX",
@@ -44704,9 +49612,10 @@
               },
               "params": [
                 {
-                  "textRaw": "`pathObject` {Object}",
+                  "textRaw": "`pathObject` {Object} Any JavaScript object having the following properties:",
                   "name": "pathObject",
                   "type": "Object",
+                  "desc": "Any JavaScript object having the following properties:",
                   "options": [
                     {
                       "textRaw": "`dir` {string}",
@@ -45001,7 +49910,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Path"
+      "displayName": "Path",
+      "source": "doc/api/path.md"
     },
     {
       "textRaw": "Performance measurement APIs",
@@ -45009,7 +49919,7 @@
       "introduced_in": "v8.5.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/perf_hooks.js\">lib/perf_hooks.js</a></p>\n<p>This module provides an implementation of a subset of the W3C\n<a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a> as well as additional APIs for\nNode.js-specific performance measurements.</p>\n<p>Node.js supports the following <a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a>:</p>\n<ul>\n<li><a href=\"https://www.w3.org/TR/hr-time-2\">High Resolution Time</a></li>\n<li><a href=\"https://w3c.github.io/performance-timeline/\">Performance Timeline</a></li>\n<li><a href=\"https://www.w3.org/TR/user-timing/\">User Timing</a></li>\n</ul>\n<pre><code class=\"language-js\">const { PerformanceObserver, performance } = require('perf_hooks');\n\nconst obs = new PerformanceObserver((items) => {\n  console.log(items.getEntries()[0].duration);\n  performance.clearMarks();\n});\nobs.observe({ entryTypes: ['measure'] });\nperformance.measure('Start to Now');\n\nperformance.mark('A');\ndoSomeLongRunningProcess(() => {\n  performance.measure('A to Now', 'A');\n\n  performance.mark('B');\n  performance.measure('A to B', 'A', 'B');\n});\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/perf_hooks.js\">lib/perf_hooks.js</a></p>\n<p>This module provides an implementation of a subset of the W3C\n<a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a> as well as additional APIs for\nNode.js-specific performance measurements.</p>\n<p>Node.js supports the following <a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a>:</p>\n<ul>\n<li><a href=\"https://www.w3.org/TR/hr-time-2\">High Resolution Time</a></li>\n<li><a href=\"https://w3c.github.io/performance-timeline/\">Performance Timeline</a></li>\n<li><a href=\"https://www.w3.org/TR/user-timing/\">User Timing</a></li>\n</ul>\n<pre><code class=\"language-js\">const { PerformanceObserver, performance } = require('perf_hooks');\n\nconst obs = new PerformanceObserver((items) => {\n  console.log(items.getEntries()[0].duration);\n  performance.clearMarks();\n});\nobs.observe({ entryTypes: ['measure'] });\nperformance.measure('Start to Now');\n\nperformance.mark('A');\ndoSomeLongRunningProcess(() => {\n  performance.measure('A to Now', 'A');\n\n  performance.mark('B');\n  performance.measure('A to B', 'A', 'B');\n});\n</code></pre>",
       "properties": [
         {
           "textRaw": "`perf_hooks.performance`",
@@ -45096,7 +50006,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>eventLoopUtilization()</code> method returns an object that contains the\ncumulative duration of time the event loop has been both idle and active as a\nhigh resolution milliseconds timer. The <code>utilization</code> value is the calculated\nEvent Loop Utilization (ELU).</p>\n<p>If bootstrapping has not yet finished on the main thread the properties have\nthe value of <code>0</code>. The ELU is immediately available on <a href=\"worker_threads.md#worker_threads_worker_threads\">Worker threads</a> since\nbootstrap happens within the event loop.</p>\n<p>Both <code>utilization1</code> and <code>utilization2</code> are optional parameters.</p>\n<p>If <code>utilization1</code> is passed, then the delta between the current call's <code>active</code>\nand <code>idle</code> times, as well as the corresponding <code>utilization</code> value are\ncalculated and returned (similar to <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>).</p>\n<p>If <code>utilization1</code> and <code>utilization2</code> are both passed, then the delta is\ncalculated between the two arguments. This is a convenience option because,\nunlike <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>, calculating the ELU is more complex than a\nsingle subtraction.</p>\n<p>ELU is similar to CPU utilization, except that it only measures event loop\nstatistics and not CPU usage. It represents the percentage of time the event\nloop has spent outside the event loop's event provider (e.g. <code>epoll_wait</code>).\nNo other CPU idle time is taken into consideration. The following is an example\nof how a mostly idle process will have a high ELU.</p>\n<pre><code class=\"language-js\">'use strict';\nconst { eventLoopUtilization } = require('perf_hooks').performance;\nconst { spawnSync } = require('child_process');\n\nsetImmediate(() => {\n  const elu = eventLoopUtilization();\n  spawnSync('sleep', ['5']);\n  console.log(eventLoopUtilization(elu).utilization);\n});\n</code></pre>\n<p>Although the CPU is mostly idle while running this script, the value of\n<code>utilization</code> is <code>1</code>. This is because the call to\n<a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a> blocks the event loop from proceeding.</p>\n<p>Passing in a user-defined object instead of the result of a previous call to\n<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values\nare not guaranteed to reflect any correct state of the event loop.</p>"
+              "desc": "<p>The <code>eventLoopUtilization()</code> method returns an object that contains the\ncumulative duration of time the event loop has been both idle and active as a\nhigh resolution milliseconds timer. The <code>utilization</code> value is the calculated\nEvent Loop Utilization (ELU).</p>\n<p>If bootstrapping has not yet finished on the main thread the properties have\nthe value of <code>0</code>. The ELU is immediately available on <a href=\"worker_threads.html#worker_threads_worker_threads\">Worker threads</a> since\nbootstrap happens within the event loop.</p>\n<p>Both <code>utilization1</code> and <code>utilization2</code> are optional parameters.</p>\n<p>If <code>utilization1</code> is passed, then the delta between the current call's <code>active</code>\nand <code>idle</code> times, as well as the corresponding <code>utilization</code> value are\ncalculated and returned (similar to <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>).</p>\n<p>If <code>utilization1</code> and <code>utilization2</code> are both passed, then the delta is\ncalculated between the two arguments. This is a convenience option because,\nunlike <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>, calculating the ELU is more complex than a\nsingle subtraction.</p>\n<p>ELU is similar to CPU utilization, except that it only measures event loop\nstatistics and not CPU usage. It represents the percentage of time the event\nloop has spent outside the event loop's event provider (e.g. <code>epoll_wait</code>).\nNo other CPU idle time is taken into consideration. The following is an example\nof how a mostly idle process will have a high ELU.</p>\n<pre><code class=\"language-js\">'use strict';\nconst { eventLoopUtilization } = require('perf_hooks').performance;\nconst { spawnSync } = require('child_process');\n\nsetImmediate(() => {\n  const elu = eventLoopUtilization();\n  spawnSync('sleep', ['5']);\n  console.log(eventLoopUtilization(elu).utilization);\n});\n</code></pre>\n<p>Although the CPU is mostly idle while running this script, the value of\n<code>utilization</code> is <code>1</code>. This is because the call to\n<a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a> blocks the event loop from proceeding.</p>\n<p>Passing in a user-defined object instead of the result of a previous call to\n<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values\nare not guaranteed to reflect any correct state of the event loop.</p>"
             },
             {
               "textRaw": "`performance.mark([name])`",
@@ -45131,7 +50041,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.3",
+                    "version": "v14.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32651",
                     "description": "Make `startMark` and `endMark` parameters optional."
                   }
@@ -45206,58 +50116,6 @@
                 }
               ],
               "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Wraps a function within a new function that measures the running time of the\nwrapped function. A <code>PerformanceObserver</code> must be subscribed to the <code>'function'</code>\nevent type in order for the timing details to be accessed.</p>\n<pre><code class=\"language-js\">const {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nfunction someFunction() {\n  console.log('hello world');\n}\n\nconst wrapped = performance.timerify(someFunction);\n\nconst obs = new PerformanceObserver((list) => {\n  console.log(list.getEntries()[0].duration);\n  obs.disconnect();\n});\nobs.observe({ entryTypes: ['function'] });\n\n// A performance timeline entry will be created\nwrapped();\n</code></pre>"
-            },
-            {
-              "textRaw": "`performance.eventLoopUtilization([util1][,util2])`",
-              "type": "method",
-              "name": "eventLoopUtilization",
-              "meta": {
-                "added": [
-                  "v12.19.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns {Object}",
-                    "name": "return",
-                    "type": "Object",
-                    "options": [
-                      {
-                        "textRaw": "`idle` {number}",
-                        "name": "idle",
-                        "type": "number"
-                      },
-                      {
-                        "textRaw": "`active` {number}",
-                        "name": "active",
-                        "type": "number"
-                      },
-                      {
-                        "textRaw": "`utilization` {number}",
-                        "name": "utilization",
-                        "type": "number"
-                      }
-                    ]
-                  },
-                  "params": [
-                    {
-                      "textRaw": "`util1` {Object} The result of a previous call to `eventLoopUtilization()`",
-                      "name": "util1",
-                      "type": "Object",
-                      "desc": "The result of a previous call to `eventLoopUtilization()`"
-                    },
-                    {
-                      "textRaw": "`util2` {Object} The result of a previous call to `eventLoopUtilization()` prior to `util1`",
-                      "name": "util2",
-                      "type": "Object",
-                      "desc": "The result of a previous call to `eventLoopUtilization()` prior to `util1`"
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p>The <code>eventLoopUtilization()</code> method returns an object that contains the\ncumulative duration of time the event loop has been both idle and active as a\nhigh resolution milliseconds timer. The <code>utilization</code> value is the calculated\nEvent Loop Utilization (ELU). If bootstrapping has not yet finished, the\nproperties have the value of 0.</p>\n<p><code>util1</code> and <code>util2</code> are optional parameters.</p>\n<p>If <code>util1</code> is passed then the delta between the current call's <code>active</code> and\n<code>idle</code> times are calculated and returned (similar to <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>).\nLikewise the adjusted <code>utilization</code> value is calculated.</p>\n<p>If <code>util1</code> and <code>util2</code> are both passed then the calculation adjustments are\ndone between the two arguments. This is a convenience option because unlike\n<a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a> additional work is done to calculate the ELU.</p>\n<p>ELU is similar to CPU utilization except that it is calculated using high\nprecision wall-clock time. It represents the percentage of time the event loop\nhas spent outside the event loop's event provider (e.g. <code>epoll_wait</code>). No other\nCPU idle time is taken into consideration. The following is an example of how\na mostly idle process will have a high ELU.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">'use strict';\nconst { eventLoopUtilization } = require('perf_hooks').performance;\nconst { spawnSync } = require('child_process');\n\nsetImmediate(() => {\n  const elu = eventLoopUtilization();\n  spawnSync('sleep', ['5']);\n  console.log(eventLoopUtilization(elu).utilization);\n});\n</code></pre>\n<p>Although the CPU is mostly idle while running this script, the value of\n<code>utilization</code> is 1. This is because the call to <a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>\nblocks the event loop from proceeding.</p>\n<p>Passing in a user-defined object instead of the result of a previous call to\n<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values\nare not guaranteed to reflect any correct state of the event loop.</p>"
             }
           ],
           "properties": [
@@ -45313,40 +50171,41 @@
               "desc": "<p>The total number of milliseconds elapsed for this entry. This value will not\nbe meaningful for all Performance Entry types.</p>"
             },
             {
-              "textRaw": "`name` {string}",
+              "textRaw": "`entryType` {string}",
               "type": "string",
-              "name": "name",
+              "name": "entryType",
               "meta": {
                 "added": [
                   "v8.5.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The name of the performance entry.</p>"
+              "desc": "<p>The type of the performance entry. It may be one of:</p>\n<ul>\n<li><code>'node'</code> (Node.js only)</li>\n<li><code>'mark'</code> (available on the Web)</li>\n<li><code>'measure'</code> (available on the Web)</li>\n<li><code>'gc'</code> (Node.js only)</li>\n<li><code>'function'</code> (Node.js only)</li>\n<li><code>'http2'</code> (Node.js only)</li>\n<li><code>'http'</code> (Node.js only)</li>\n</ul>"
             },
             {
-              "textRaw": "`startTime` {number}",
+              "textRaw": "`flags` {number}",
               "type": "number",
-              "name": "startTime",
+              "name": "flags",
               "meta": {
                 "added": [
-                  "v8.5.0"
+                  "v13.9.0",
+                  "v12.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The high resolution millisecond timestamp marking the starting time of the\nPerformance Entry.</p>"
+              "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>\nproperty contains additional information about garbage collection operation.\nThe value may be one of:</p>\n<ul>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>\n</ul>"
             },
             {
-              "textRaw": "`entryType` {string}",
+              "textRaw": "`name` {string}",
               "type": "string",
-              "name": "entryType",
+              "name": "name",
               "meta": {
                 "added": [
                   "v8.5.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The type of the performance entry. It may be one of:</p>\n<ul>\n<li><code>'node'</code> (Node.js only)</li>\n<li><code>'mark'</code> (available on the Web)</li>\n<li><code>'measure'</code> (available on the Web)</li>\n<li><code>'gc'</code> (Node.js only)</li>\n<li><code>'function'</code> (Node.js only)</li>\n<li><code>'http2'</code> (Node.js only)</li>\n<li><code>'http'</code> (Node.js only)</li>\n</ul>"
+              "desc": "<p>The name of the performance entry.</p>"
             },
             {
               "textRaw": "`kind` {number}",
@@ -45361,21 +50220,21 @@
               "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.kind</code>\nproperty identifies the type of garbage collection operation that occurred.\nThe value may be one of:</p>\n<ul>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_MAJOR</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_MINOR</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB</code></li>\n</ul>"
             },
             {
-              "textRaw": "`flags` {number}",
+              "textRaw": "`startTime` {number}",
               "type": "number",
-              "name": "flags",
+              "name": "startTime",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v8.5.0"
                 ],
                 "changes": []
               },
-              "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>\nproperty contains additional information about garbage collection operation.\nThe value may be one of:</p>\n<ul>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>\n</ul>"
+              "desc": "<p>The high resolution millisecond timestamp marking the starting time of the\nPerformance Entry.</p>"
             }
           ]
         },
         {
-          "textRaw": "Class: `PerformanceNodeTiming extends PerformanceEntry`",
+          "textRaw": "Class: `PerformanceNodeTiming`",
           "type": "class",
           "name": "PerformanceNodeTiming",
           "meta": {
@@ -45384,7 +50243,7 @@
             ],
             "changes": []
           },
-          "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Provides timing details for Node.js itself. The constructor of this class\nis not exposed to users.</p>",
+          "desc": "<ul>\n<li>Extends: <a href=\"perf_hooks.html#perf_hooks_class_performanceentry\" class=\"type\">&lt;PerformanceEntry&gt;</a></li>\n</ul>\n<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Provides timing details for Node.js itself. The constructor of this class\nis not exposed to users.</p>",
           "properties": [
             {
               "textRaw": "`bootstrapComplete` {number}",
@@ -45410,6 +50269,19 @@
               },
               "desc": "<p>The high resolution millisecond timestamp at which the Node.js environment was\ninitialized.</p>"
             },
+            {
+              "textRaw": "`idleTime` {number}",
+              "type": "number",
+              "name": "idleTime",
+              "meta": {
+                "added": [
+                  "v14.10.0",
+                  "v12.19.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The high resolution millisecond timestamp of the amount of time the event loop\nhas been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This\ndoes not take CPU usage into consideration. If the event loop has not yet\nstarted (e.g., in the first tick of the main script), the property has the\nvalue of 0.</p>"
+            },
             {
               "textRaw": "`loopExit` {number}",
               "type": "number",
@@ -45457,18 +50329,6 @@
                 "changes": []
               },
               "desc": "<p>The high resolution millisecond timestamp at which the V8 platform was\ninitialized.</p>"
-            },
-            {
-              "textRaw": "`idleTime` {number}",
-              "type": "number",
-              "name": "idleTime",
-              "meta": {
-                "added": [
-                  "v12.19.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The high resolution millisecond timestamp of the amount of time the event loop\nhas been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This\ndoes not take CPU usage into consideration. If the event loop has not yet\nstarted (e.g., in the first tick of the main script), the property has the\nvalue of 0.</p>"
             }
           ]
         },
@@ -45590,7 +50450,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code>.</p>"
+              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code>.</p>\n<pre><code class=\"language-js\">const {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((perfObserverList, observer) => {\n  console.log(perfObserverList.getEntries());\n  /**\n   * [\n   *   PerformanceEntry {\n   *     name: 'test',\n   *     entryType: 'mark',\n   *     startTime: 81.465639,\n   *     duration: 0\n   *   },\n   *   PerformanceEntry {\n   *     name: 'meow',\n   *     entryType: 'mark',\n   *     startTime: 81.860064,\n   *     duration: 0\n   *   }\n   * ]\n   */\n  observer.disconnect();\n});\nobs.observe({ entryTypes: ['mark'], buffered: true });\n\nperformance.mark('test');\nperformance.mark('meow');\n</code></pre>"
             },
             {
               "textRaw": "`performanceObserverEntryList.getEntriesByName(name[, type])`",
@@ -45623,7 +50483,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.name</code> is\nequal to <code>name</code>, and optionally, whose <code>performanceEntry.entryType</code> is equal to\n<code>type</code>.</p>"
+              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.name</code> is\nequal to <code>name</code>, and optionally, whose <code>performanceEntry.entryType</code> is equal to\n<code>type</code>.</p>\n<pre><code class=\"language-js\">const {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((perfObserverList, observer) => {\n  console.log(perfObserverList.getEntriesByName('meow'));\n  /**\n   * [\n   *   PerformanceEntry {\n   *     name: 'meow',\n   *     entryType: 'mark',\n   *     startTime: 98.545991,\n   *     duration: 0\n   *   }\n   * ]\n   */\n  console.log(perfObserverList.getEntriesByName('nope')); // []\n\n  console.log(perfObserverList.getEntriesByName('test', 'mark'));\n  /**\n   * [\n   *   PerformanceEntry {\n   *     name: 'test',\n   *     entryType: 'mark',\n   *     startTime: 63.518931,\n   *     duration: 0\n   *   }\n   * ]\n   */\n  console.log(perfObserverList.getEntriesByName('test', 'measure')); // []\n  observer.disconnect();\n});\nobs.observe({ entryTypes: ['mark', 'measure'], buffered: true });\n\nperformance.mark('test');\nperformance.mark('meow');\n</code></pre>"
             },
             {
               "textRaw": "`performanceObserverEntryList.getEntriesByType(type)`",
@@ -45651,12 +50511,323 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.entryType</code>\nis equal to <code>type</code>.</p>"
+              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.entryType</code>\nis equal to <code>type</code>.</p>\n<pre><code class=\"language-js\">const {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((perfObserverList, observer) => {\n  console.log(perfObserverList.getEntriesByType('mark'));\n  /**\n   * [\n   *   PerformanceEntry {\n   *     name: 'test',\n   *     entryType: 'mark',\n   *     startTime: 55.897834,\n   *     duration: 0\n   *   },\n   *   PerformanceEntry {\n   *     name: 'meow',\n   *     entryType: 'mark',\n   *     startTime: 56.350146,\n   *     duration: 0\n   *   }\n   * ]\n   */\n  observer.disconnect();\n});\nobs.observe({ entryTypes: ['mark'], buffered: true });\n\nperformance.mark('test');\nperformance.mark('meow');\n</code></pre>"
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `Histogram`",
+          "type": "class",
+          "name": "Histogram",
+          "meta": {
+            "added": [
+              "v11.10.0"
+            ],
+            "changes": []
+          },
+          "properties": [
+            {
+              "textRaw": "`exceeds` {number}",
+              "type": "number",
+              "name": "exceeds",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The number of times the event loop delay exceeded the maximum 1 hour event\nloop delay threshold.</p>"
+            },
+            {
+              "textRaw": "`max` {number}",
+              "type": "number",
+              "name": "max",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The maximum recorded event loop delay.</p>"
+            },
+            {
+              "textRaw": "`mean` {number}",
+              "type": "number",
+              "name": "mean",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The mean of the recorded event loop delays.</p>"
+            },
+            {
+              "textRaw": "`min` {number}",
+              "type": "number",
+              "name": "min",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The minimum recorded event loop delay.</p>"
+            },
+            {
+              "textRaw": "`percentiles` {Map}",
+              "type": "Map",
+              "name": "percentiles",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Returns a <code>Map</code> object detailing the accumulated percentile distribution.</p>"
+            },
+            {
+              "textRaw": "`stddev` {number}",
+              "type": "number",
+              "name": "stddev",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The standard deviation of the recorded event loop delays.</p>"
+            }
+          ],
+          "methods": [
+            {
+              "textRaw": "`histogram.percentile(percentile)`",
+              "type": "method",
+              "name": "percentile",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {number}",
+                    "name": "return",
+                    "type": "number"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`percentile` {number} A percentile value in the range (0, 100].",
+                      "name": "percentile",
+                      "type": "number",
+                      "desc": "A percentile value in the range (0, 100]."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns the value at the given percentile.</p>"
+            },
+            {
+              "textRaw": "`histogram.reset()`",
+              "type": "method",
+              "name": "reset",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Resets the collected histogram data.</p>"
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `IntervalHistogram extends Histogram`",
+          "type": "class",
+          "name": "IntervalHistogram",
+          "desc": "<p>A <code>Histogram</code> that is periodically updated on a given interval.</p>",
+          "methods": [
+            {
+              "textRaw": "`histogram.disable()`",
+              "type": "method",
+              "name": "disable",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Disables the update interval timer. Returns <code>true</code> if the timer was\nstopped, <code>false</code> if it was already stopped.</p>"
+            },
+            {
+              "textRaw": "`histogram.enable()`",
+              "type": "method",
+              "name": "enable",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Enables the update interval timer. Returns <code>true</code> if the timer was\nstarted, <code>false</code> if it was already started.</p>"
+            }
+          ],
+          "modules": [
+            {
+              "textRaw": "Cloning an `IntervalHistogram`",
+              "name": "cloning_an_`intervalhistogram`",
+              "desc": "<p><a href=\"perf_hooks.html#perf_hooks_class_intervalhistogram_extends_histogram\" class=\"type\">&lt;IntervalHistogram&gt;</a> instances can be cloned via <a href=\"worker_threads.html#worker_threads_class_messageport\" class=\"type\">&lt;MessagePort&gt;</a>. On the receiving\nend, the histogram is cloned as a plain <a href=\"perf_hooks.html#perf_hooks_class_histogram\" class=\"type\">&lt;Histogram&gt;</a> object that does not\nimplement the <code>enable()</code> and <code>disable()</code> methods.</p>",
+              "type": "module",
+              "displayName": "Cloning an `IntervalHistogram`"
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `RecordableHistogram extends Histogram`",
+          "type": "class",
+          "name": "RecordableHistogram",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "methods": [
+            {
+              "textRaw": "`histogram.record(val)`",
+              "type": "method",
+              "name": "record",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`val` {number|bigint} The amount to record in the histogram.",
+                      "name": "val",
+                      "type": "number|bigint",
+                      "desc": "The amount to record in the histogram."
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "textRaw": "`histogram.recordDelta()`",
+              "type": "method",
+              "name": "recordDelta",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Calculates the amount of time (in nanoseconds) that has passed since the\nprevious call to <code>recordDelta()</code> and records that amount in the histogram.</p>\n<h2>Examples</h2>"
+            }
+          ],
+          "modules": [
+            {
+              "textRaw": "Measuring the duration of async operations",
+              "name": "measuring_the_duration_of_async_operations",
+              "desc": "<p>The following example uses the <a href=\"async_hooks.html\">Async Hooks</a> and Performance APIs to measure\nthe actual duration of a Timeout operation (including the amount of time it took\nto execute the callback).</p>\n<pre><code class=\"language-js\">'use strict';\nconst async_hooks = require('async_hooks');\nconst {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nconst set = new Set();\nconst hook = async_hooks.createHook({\n  init(id, type) {\n    if (type === 'Timeout') {\n      performance.mark(`Timeout-${id}-Init`);\n      set.add(id);\n    }\n  },\n  destroy(id) {\n    if (set.has(id)) {\n      set.delete(id);\n      performance.mark(`Timeout-${id}-Destroy`);\n      performance.measure(`Timeout-${id}`,\n                          `Timeout-${id}-Init`,\n                          `Timeout-${id}-Destroy`);\n    }\n  }\n});\nhook.enable();\n\nconst obs = new PerformanceObserver((list, observer) => {\n  console.log(list.getEntries()[0]);\n  performance.clearMarks();\n  observer.disconnect();\n});\nobs.observe({ entryTypes: ['measure'], buffered: true });\n\nsetTimeout(() => {}, 1000);\n</code></pre>",
+              "type": "module",
+              "displayName": "Measuring the duration of async operations"
+            },
+            {
+              "textRaw": "Measuring how long it takes to load dependencies",
+              "name": "measuring_how_long_it_takes_to_load_dependencies",
+              "desc": "<p>The following example measures the duration of <code>require()</code> operations to load\ndependencies:</p>\n<!-- eslint-disable no-global-assign -->\n<pre><code class=\"language-js\">'use strict';\nconst {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\nconst mod = require('module');\n\n// Monkey patch the require function\nmod.Module.prototype.require =\n  performance.timerify(mod.Module.prototype.require);\nrequire = performance.timerify(require);\n\n// Activate the observer\nconst obs = new PerformanceObserver((list) => {\n  const entries = list.getEntries();\n  entries.forEach((entry) => {\n    console.log(`require('${entry[0]}')`, entry.duration);\n  });\n  obs.disconnect();\n});\nobs.observe({ entryTypes: ['function'], buffered: true });\n\nrequire('some-module');\n</code></pre>",
+              "type": "module",
+              "displayName": "Measuring how long it takes to load dependencies"
             }
           ]
         }
       ],
       "methods": [
+        {
+          "textRaw": "`perf_hooks.createHistogram([options])`",
+          "type": "method",
+          "name": "createHistogram",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns {RecordableHistogram}",
+                "name": "return",
+                "type": "RecordableHistogram"
+              },
+              "params": [
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`min` {number|bigint} The minimum recordable value. Must be an integer value greater than 0. **Defaults**: `1`.",
+                      "name": "min",
+                      "type": "number|bigint",
+                      "desc": "The minimum recordable value. Must be an integer value greater than 0. **Defaults**: `1`."
+                    },
+                    {
+                      "textRaw": "`max` {number|bigint} The maximum recordable value. Must be an integer value greater than `min`. **Defaults**: `Number.MAX_SAFE_INTEGER`.",
+                      "name": "max",
+                      "type": "number|bigint",
+                      "desc": "The maximum recordable value. Must be an integer value greater than `min`. **Defaults**: `Number.MAX_SAFE_INTEGER`."
+                    },
+                    {
+                      "textRaw": "`figures` {number} The number of accuracy digits. Must be a number between `1` and `5`. **Defaults**: `3`.",
+                      "name": "figures",
+                      "type": "number",
+                      "desc": "The number of accuracy digits. Must be a number between `1` and `5`. **Defaults**: `3`."
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Returns a <a href=\"perf_hooks.html#perf_hooks_class_recordablehistogram_extends_histogram\" class=\"type\">&lt;RecordableHistogram&gt;</a>.</p>"
+        },
         {
           "textRaw": "`perf_hooks.monitorEventLoopDelay([options])`",
           "type": "method",
@@ -45670,9 +50841,9 @@
           "signatures": [
             {
               "return": {
-                "textRaw": "Returns: {Histogram}",
+                "textRaw": "Returns: {IntervalHistogram}",
                 "name": "return",
-                "type": "Histogram"
+                "type": "IntervalHistogram"
               },
               "params": [
                 {
@@ -45692,207 +50863,12 @@
               ]
             }
           ],
-          "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Creates a <code>Histogram</code> object that samples and reports the event loop delay\nover time. The delays will be reported in nanoseconds.</p>\n<p>Using a timer to detect approximate event loop delay works because the\nexecution of timers is tied specifically to the lifecycle of the libuv\nevent loop. That is, a delay in the loop will cause a delay in the execution\nof the timer, and those delays are specifically what this API is intended to\ndetect.</p>\n<pre><code class=\"language-js\">const { monitorEventLoopDelay } = require('perf_hooks');\nconst h = monitorEventLoopDelay({ resolution: 20 });\nh.enable();\n// Do something.\nh.disable();\nconsole.log(h.min);\nconsole.log(h.max);\nconsole.log(h.mean);\nconsole.log(h.stddev);\nconsole.log(h.percentiles);\nconsole.log(h.percentile(50));\nconsole.log(h.percentile(99));\n</code></pre>",
-          "classes": [
-            {
-              "textRaw": "Class: `Histogram`",
-              "type": "class",
-              "name": "Histogram",
-              "meta": {
-                "added": [
-                  "v11.10.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>Tracks the event loop delay at a given sampling rate. The constructor of\nthis class not exposed to users.</p>\n<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>",
-              "methods": [
-                {
-                  "textRaw": "`histogram.disable()`",
-                  "type": "method",
-                  "name": "disable",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {boolean}",
-                        "name": "return",
-                        "type": "boolean"
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Disables the event loop delay sample timer. Returns <code>true</code> if the timer was\nstopped, <code>false</code> if it was already stopped.</p>"
-                },
-                {
-                  "textRaw": "`histogram.enable()`",
-                  "type": "method",
-                  "name": "enable",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {boolean}",
-                        "name": "return",
-                        "type": "boolean"
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Enables the event loop delay sample timer. Returns <code>true</code> if the timer was\nstarted, <code>false</code> if it was already started.</p>"
-                },
-                {
-                  "textRaw": "`histogram.percentile(percentile)`",
-                  "type": "method",
-                  "name": "percentile",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {number}",
-                        "name": "return",
-                        "type": "number"
-                      },
-                      "params": [
-                        {
-                          "textRaw": "`percentile` {number} A percentile value between 1 and 100.",
-                          "name": "percentile",
-                          "type": "number",
-                          "desc": "A percentile value between 1 and 100."
-                        }
-                      ]
-                    }
-                  ],
-                  "desc": "<p>Returns the value at the given percentile.</p>"
-                },
-                {
-                  "textRaw": "`histogram.reset()`",
-                  "type": "method",
-                  "name": "reset",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Resets the collected histogram data.</p>"
-                }
-              ],
-              "properties": [
-                {
-                  "textRaw": "`exceeds` {number}",
-                  "type": "number",
-                  "name": "exceeds",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The number of times the event loop delay exceeded the maximum 1 hour event\nloop delay threshold.</p>"
-                },
-                {
-                  "textRaw": "`max` {number}",
-                  "type": "number",
-                  "name": "max",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The maximum recorded event loop delay.</p>"
-                },
-                {
-                  "textRaw": "`mean` {number}",
-                  "type": "number",
-                  "name": "mean",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The mean of the recorded event loop delays.</p>"
-                },
-                {
-                  "textRaw": "`min` {number}",
-                  "type": "number",
-                  "name": "min",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The minimum recorded event loop delay.</p>"
-                },
-                {
-                  "textRaw": "`percentiles` {Map}",
-                  "type": "Map",
-                  "name": "percentiles",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>Returns a <code>Map</code> object detailing the accumulated percentile distribution.</p>"
-                },
-                {
-                  "textRaw": "`stddev` {number}",
-                  "type": "number",
-                  "name": "stddev",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The standard deviation of the recorded event loop delays.</p>\n<h2>Examples</h2>"
-                }
-              ]
-            }
-          ],
-          "modules": [
-            {
-              "textRaw": "Measuring the duration of async operations",
-              "name": "measuring_the_duration_of_async_operations",
-              "desc": "<p>The following example uses the <a href=\"async_hooks.html\">Async Hooks</a> and Performance APIs to measure\nthe actual duration of a Timeout operation (including the amount of time it took\nto execute the callback).</p>\n<pre><code class=\"language-js\">'use strict';\nconst async_hooks = require('async_hooks');\nconst {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nconst set = new Set();\nconst hook = async_hooks.createHook({\n  init(id, type) {\n    if (type === 'Timeout') {\n      performance.mark(`Timeout-${id}-Init`);\n      set.add(id);\n    }\n  },\n  destroy(id) {\n    if (set.has(id)) {\n      set.delete(id);\n      performance.mark(`Timeout-${id}-Destroy`);\n      performance.measure(`Timeout-${id}`,\n                          `Timeout-${id}-Init`,\n                          `Timeout-${id}-Destroy`);\n    }\n  }\n});\nhook.enable();\n\nconst obs = new PerformanceObserver((list, observer) => {\n  console.log(list.getEntries()[0]);\n  performance.clearMarks();\n  observer.disconnect();\n});\nobs.observe({ entryTypes: ['measure'], buffered: true });\n\nsetTimeout(() => {}, 1000);\n</code></pre>",
-              "type": "module",
-              "displayName": "Measuring the duration of async operations"
-            },
-            {
-              "textRaw": "Measuring how long it takes to load dependencies",
-              "name": "measuring_how_long_it_takes_to_load_dependencies",
-              "desc": "<p>The following example measures the duration of <code>require()</code> operations to load\ndependencies:</p>\n<!-- eslint-disable no-global-assign -->\n<pre><code class=\"language-js\">'use strict';\nconst {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\nconst mod = require('module');\n\n// Monkey patch the require function\nmod.Module.prototype.require =\n  performance.timerify(mod.Module.prototype.require);\nrequire = performance.timerify(require);\n\n// Activate the observer\nconst obs = new PerformanceObserver((list) => {\n  const entries = list.getEntries();\n  entries.forEach((entry) => {\n    console.log(`require('${entry[0]}')`, entry.duration);\n  });\n  obs.disconnect();\n});\nobs.observe({ entryTypes: ['function'], buffered: true });\n\nrequire('some-module');\n</code></pre>",
-              "type": "module",
-              "displayName": "Measuring how long it takes to load dependencies"
-            }
-          ]
+          "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Creates an <code>IntervalHistogram</code> object that samples and reports the event loop\ndelay over time. The delays will be reported in nanoseconds.</p>\n<p>Using a timer to detect approximate event loop delay works because the\nexecution of timers is tied specifically to the lifecycle of the libuv\nevent loop. That is, a delay in the loop will cause a delay in the execution\nof the timer, and those delays are specifically what this API is intended to\ndetect.</p>\n<pre><code class=\"language-js\">const { monitorEventLoopDelay } = require('perf_hooks');\nconst h = monitorEventLoopDelay({ resolution: 20 });\nh.enable();\n// Do something.\nh.disable();\nconsole.log(h.min);\nconsole.log(h.max);\nconsole.log(h.mean);\nconsole.log(h.stddev);\nconsole.log(h.percentiles);\nconsole.log(h.percentile(50));\nconsole.log(h.percentile(99));\n</code></pre>"
         }
       ],
       "type": "module",
-      "displayName": "Performance measurement APIs"
+      "displayName": "Performance measurement APIs",
+      "source": "doc/api/perf_hooks.md"
     },
     {
       "textRaw": "Punycode",
@@ -45906,7 +50882,7 @@
       "introduced_in": "v0.10.0",
       "stability": 0,
       "stabilityText": "Deprecated",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/punycode.js\">lib/punycode.js</a></p>\n<p><strong>The version of the punycode module bundled in Node.js is being deprecated</strong>.\nIn a future major version of Node.js this module will be removed. Users\ncurrently depending on the <code>punycode</code> module should switch to using the\nuserland-provided <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> module instead.</p>\n<p>The <code>punycode</code> module is a bundled version of the <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> module. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const punycode = require('punycode');\n</code></pre>\n<p><a href=\"https://tools.ietf.org/html/rfc3492\">Punycode</a> is a character encoding scheme defined by RFC 3492 that is\nprimarily intended for use in Internationalized Domain Names. Because host\nnames in URLs are limited to ASCII characters only, Domain Names that contain\nnon-ASCII characters must be converted into ASCII using the Punycode scheme.\nFor instance, the Japanese character that translates into the English word,\n<code>'example'</code> is <code>'例'</code>. The Internationalized Domain Name, <code>'例.com'</code> (equivalent\nto <code>'example.com'</code>) is represented by Punycode as the ASCII string\n<code>'xn--fsq.com'</code>.</p>\n<p>The <code>punycode</code> module provides a simple implementation of the Punycode standard.</p>\n<p>The <code>punycode</code> module is a third-party dependency used by Node.js and\nmade available to developers as a convenience. Fixes or other modifications to\nthe module must be directed to the <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> project.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/punycode.js\">lib/punycode.js</a></p>\n<p><strong>The version of the punycode module bundled in Node.js is being deprecated</strong>.\nIn a future major version of Node.js this module will be removed. Users\ncurrently depending on the <code>punycode</code> module should switch to using the\nuserland-provided <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> module instead. For punycode-based URL\nencoding, see <a href=\"url.html#url_url_domaintoascii_domain\"><code>url.domainToASCII</code></a> or, more generally, the\n<a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL API</a>.</p>\n<p>The <code>punycode</code> module is a bundled version of the <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> module. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const punycode = require('punycode');\n</code></pre>\n<p><a href=\"https://tools.ietf.org/html/rfc3492\">Punycode</a> is a character encoding scheme defined by RFC 3492 that is\nprimarily intended for use in Internationalized Domain Names. Because host\nnames in URLs are limited to ASCII characters only, Domain Names that contain\nnon-ASCII characters must be converted into ASCII using the Punycode scheme.\nFor instance, the Japanese character that translates into the English word,\n<code>'example'</code> is <code>'例'</code>. The Internationalized Domain Name, <code>'例.com'</code> (equivalent\nto <code>'example.com'</code>) is represented by Punycode as the ASCII string\n<code>'xn--fsq.com'</code>.</p>\n<p>The <code>punycode</code> module provides a simple implementation of the Punycode standard.</p>\n<p>The <code>punycode</code> module is a third-party dependency used by Node.js and\nmade available to developers as a convenience. Fixes or other modifications to\nthe module must be directed to the <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> project.</p>",
       "methods": [
         {
           "textRaw": "`punycode.decode(string)`",
@@ -46074,15 +51050,16 @@
         }
       ],
       "type": "module",
-      "displayName": "Punycode"
+      "displayName": "Punycode",
+      "source": "doc/api/punycode.md"
     },
     {
       "textRaw": "Query string",
       "name": "querystring",
       "introduced_in": "v0.1.25",
-      "stability": 2,
-      "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/querystring.js\">lib/querystring.js</a></p>\n<p>The <code>querystring</code> module provides utilities for parsing and formatting URL\nquery strings. It can be accessed using:</p>\n<pre><code class=\"language-js\">const querystring = require('querystring');\n</code></pre>",
+      "stability": 3,
+      "stabilityText": "Legacy",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/querystring.js\">lib/querystring.js</a></p>\n<p>The <code>querystring</code> module provides utilities for parsing and formatting URL\nquery strings. It can be accessed using:</p>\n<pre><code class=\"language-js\">const querystring = require('querystring');\n</code></pre>\n<p>The <code>querystring</code> API is considered Legacy. While it is still maintained,\nnew code should use the <a href=\"url.html#url_class_urlsearchparams\" class=\"type\">&lt;URLSearchParams&gt;</a> API instead.</p>",
       "methods": [
         {
           "textRaw": "`querystring.decode()`",
@@ -46161,7 +51138,10 @@
                 "description": "The returned object no longer inherits from `Object.prototype`."
               },
               {
-                "version": "v6.0.0, v4.2.4",
+                "version": [
+                  "v6.0.0",
+                  "v4.2.4"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/3807",
                 "description": "The `eq` parameter may now have a length of more than `1`."
               }
@@ -46265,7 +51245,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>querystring.stringify()</code> method produces a URL query string from a\ngiven <code>obj</code> by iterating through the object's \"own properties\".</p>\n<p>It serializes the following types of values passed in <code>obj</code>:\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean[]&gt;</a>\nAny other input values will be coerced to empty strings.</p>\n<pre><code class=\"language-js\">querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' });\n// Returns 'foo=bar&#x26;baz=qux&#x26;baz=quux&#x26;corge='\n\nquerystring.stringify({ foo: 'bar', baz: 'qux' }, ';', ':');\n// Returns 'foo:bar;baz:qux'\n</code></pre>\n<p>By default, characters requiring percent-encoding within the query string will\nbe encoded as UTF-8. If an alternative encoding is required, then an alternative\n<code>encodeURIComponent</code> option will need to be specified:</p>\n<pre><code class=\"language-js\">// Assuming gbkEncodeURIComponent function already exists,\n\nquerystring.stringify({ w: '中文', foo: 'bar' }, null, null,\n                      { encodeURIComponent: gbkEncodeURIComponent });\n</code></pre>"
+          "desc": "<p>The <code>querystring.stringify()</code> method produces a URL query string from a\ngiven <code>obj</code> by iterating through the object's \"own properties\".</p>\n<p>It serializes the following types of values passed in <code>obj</code>:\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt\" class=\"type\">&lt;bigint&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt\" class=\"type\">&lt;bigint[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean[]&gt;</a>\nThe numeric values must be finite. Any other input values will be coerced to\nempty strings.</p>\n<pre><code class=\"language-js\">querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' });\n// Returns 'foo=bar&#x26;baz=qux&#x26;baz=quux&#x26;corge='\n\nquerystring.stringify({ foo: 'bar', baz: 'qux' }, ';', ':');\n// Returns 'foo:bar;baz:qux'\n</code></pre>\n<p>By default, characters requiring percent-encoding within the query string will\nbe encoded as UTF-8. If an alternative encoding is required, then an alternative\n<code>encodeURIComponent</code> option will need to be specified:</p>\n<pre><code class=\"language-js\">// Assuming gbkEncodeURIComponent function already exists,\n\nquerystring.stringify({ w: '中文', foo: 'bar' }, null, null,\n                      { encodeURIComponent: gbkEncodeURIComponent });\n</code></pre>"
         },
         {
           "textRaw": "`querystring.unescape(str)`",
@@ -46292,7 +51272,8 @@
         }
       ],
       "type": "module",
-      "displayName": "querystring"
+      "displayName": "querystring",
+      "source": "doc/api/querystring.md"
     },
     {
       "textRaw": "Readline",
@@ -46300,7 +51281,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/readline.js\">lib/readline.js</a></p>\n<p>The <code>readline</code> module provides an interface for reading data from a <a href=\"stream.html#stream_readable_streams\">Readable</a>\nstream (such as <a href=\"process.html#process_process_stdin\"><code>process.stdin</code></a>) one line at a time. It can be accessed\nusing:</p>\n<pre><code class=\"language-js\">const readline = require('readline');\n</code></pre>\n<p>The following simple example illustrates the basic use of the <code>readline</code> module.</p>\n<pre><code class=\"language-js\">const readline = require('readline');\n\nconst rl = readline.createInterface({\n  input: process.stdin,\n  output: process.stdout\n});\n\nrl.question('What do you think of Node.js? ', (answer) => {\n  // TODO: Log the answer in a database\n  console.log(`Thank you for your valuable feedback: ${answer}`);\n\n  rl.close();\n});\n</code></pre>\n<p>Once this code is invoked, the Node.js application will not terminate until the\n<code>readline.Interface</code> is closed because the interface waits for data to be\nreceived on the <code>input</code> stream.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/readline.js\">lib/readline.js</a></p>\n<p>The <code>readline</code> module provides an interface for reading data from a <a href=\"stream.html#stream_readable_streams\">Readable</a>\nstream (such as <a href=\"process.html#process_process_stdin\"><code>process.stdin</code></a>) one line at a time. It can be accessed\nusing:</p>\n<pre><code class=\"language-js\">const readline = require('readline');\n</code></pre>\n<p>The following simple example illustrates the basic use of the <code>readline</code> module.</p>\n<pre><code class=\"language-js\">const readline = require('readline');\n\nconst rl = readline.createInterface({\n  input: process.stdin,\n  output: process.stdout\n});\n\nrl.question('What do you think of Node.js? ', (answer) => {\n  // TODO: Log the answer in a database\n  console.log(`Thank you for your valuable feedback: ${answer}`);\n\n  rl.close();\n});\n</code></pre>\n<p>Once this code is invoked, the Node.js application will not terminate until the\n<code>readline.Interface</code> is closed because the interface waits for data to be\nreceived on the <code>input</code> stream.</p>",
       "classes": [
         {
           "textRaw": "Class: `Interface`",
@@ -46325,7 +51306,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'close'</code> event is emitted when one of the following occur:</p>\n<ul>\n<li>The <code>rl.close()</code> method is called and the <code>readline.Interface</code> instance has\nrelinquished control over the <code>input</code> and <code>output</code> streams;</li>\n<li>The <code>input</code> stream receives its <code>'end'</code> event;</li>\n<li>The <code>input</code> stream receives <code>&#x3C;ctrl>-D</code> to signal end-of-transmission (EOT);</li>\n<li>The <code>input</code> stream receives <code>&#x3C;ctrl>-C</code> to signal <code>SIGINT</code> and there is no\n<code>'SIGINT'</code> event listener registered on the <code>readline.Interface</code> instance.</li>\n</ul>\n<p>The listener function is called without passing any arguments.</p>\n<p>The <code>readline.Interface</code> instance is finished once the <code>'close'</code> event is\nemitted.</p>"
+              "desc": "<p>The <code>'close'</code> event is emitted when one of the following occur:</p>\n<ul>\n<li>The <code>rl.close()</code> method is called and the <code>readline.Interface</code> instance has\nrelinquished control over the <code>input</code> and <code>output</code> streams;</li>\n<li>The <code>input</code> stream receives its <code>'end'</code> event;</li>\n<li>The <code>input</code> stream receives <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal\nend-of-transmission (EOT);</li>\n<li>The <code>input</code> stream receives <kbd>Ctrl</kbd>+<kbd>C</kbd> to signal <code>SIGINT</code>\nand there is no <code>'SIGINT'</code> event listener registered on the\n<code>readline.Interface</code> instance.</li>\n</ul>\n<p>The listener function is called without passing any arguments.</p>\n<p>The <code>readline.Interface</code> instance is finished once the <code>'close'</code> event is\nemitted.</p>"
             },
             {
               "textRaw": "Event: `'line'`",
@@ -46338,7 +51319,20 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'line'</code> event is emitted whenever the <code>input</code> stream receives an\nend-of-line input (<code>\\n</code>, <code>\\r</code>, or <code>\\r\\n</code>). This usually occurs when the user\npresses the <code>&#x3C;Enter></code>, or <code>&#x3C;Return></code> keys.</p>\n<p>The listener function is called with a string containing the single line of\nreceived input.</p>\n<pre><code class=\"language-js\">rl.on('line', (input) => {\n  console.log(`Received: ${input}`);\n});\n</code></pre>"
+              "desc": "<p>The <code>'line'</code> event is emitted whenever the <code>input</code> stream receives an\nend-of-line input (<code>\\n</code>, <code>\\r</code>, or <code>\\r\\n</code>). This usually occurs when the user\npresses <kbd>Enter</kbd> or <kbd>Return</kbd>.</p>\n<p>The listener function is called with a string containing the single line of\nreceived input.</p>\n<pre><code class=\"language-js\">rl.on('line', (input) => {\n  console.log(`Received: ${input}`);\n});\n</code></pre>"
+            },
+            {
+              "textRaw": "Event: `'history'`",
+              "type": "event",
+              "name": "history",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>The <code>'history'</code> event is emitted whenever the history array has changed.</p>\n<p>The listener function is called with an array containing the history array.\nIt will reflect all changes, added lines and removed lines due to\n<code>historySize</code> and <code>removeHistoryDuplicates</code>.</p>\n<p>The primary purpose is to allow a listener to persist the history.\nIt is also possible for the listener to change the history object. This\ncould be useful to prevent certain lines to be added to the history, like\na password.</p>\n<pre><code class=\"language-js\">rl.on('history', (history) => {\n  console.log(`Received: ${history}`);\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'pause'`",
@@ -46377,7 +51371,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'SIGCONT'</code> event is emitted when a Node.js process previously moved into\nthe background using <code>&#x3C;ctrl>-Z</code> (i.e. <code>SIGTSTP</code>) is then brought back to the\nforeground using <a href=\"http://man7.org/linux/man-pages/man1/fg.1p.html\"><code>fg(1p)</code></a>.</p>\n<p>If the <code>input</code> stream was paused <em>before</em> the <code>SIGTSTP</code> request, this event will\nnot be emitted.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGCONT', () => {\n  // `prompt` will automatically resume the stream\n  rl.prompt();\n});\n</code></pre>\n<p>The <code>'SIGCONT'</code> event is <em>not</em> supported on Windows.</p>"
+              "desc": "<p>The <code>'SIGCONT'</code> event is emitted when a Node.js process previously moved into\nthe background using <kbd>Ctrl</kbd>+<kbd>Z</kbd> (i.e. <code>SIGTSTP</code>) is then\nbrought back to the foreground using <a href=\"http://man7.org/linux/man-pages/man1/fg.1p.html\"><code>fg(1p)</code></a>.</p>\n<p>If the <code>input</code> stream was paused <em>before</em> the <code>SIGTSTP</code> request, this event will\nnot be emitted.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGCONT', () => {\n  // `prompt` will automatically resume the stream\n  rl.prompt();\n});\n</code></pre>\n<p>The <code>'SIGCONT'</code> event is <em>not</em> supported on Windows.</p>"
             },
             {
               "textRaw": "Event: `'SIGINT'`",
@@ -46390,7 +51384,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'SIGINT'</code> event is emitted whenever the <code>input</code> stream receives a\n<code>&#x3C;ctrl>-C</code> input, known typically as <code>SIGINT</code>. If there are no <code>'SIGINT'</code> event\nlisteners registered when the <code>input</code> stream receives a <code>SIGINT</code>, the <code>'pause'</code>\nevent will be emitted.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGINT', () => {\n  rl.question('Are you sure you want to exit? ', (answer) => {\n    if (answer.match(/^y(es)?$/i)) rl.pause();\n  });\n});\n</code></pre>"
+              "desc": "<p>The <code>'SIGINT'</code> event is emitted whenever the <code>input</code> stream receives a\n<kbd>Ctrl+C</kbd> input, known typically as <code>SIGINT</code>. If there are no <code>'SIGINT'</code>\nevent listeners registered when the <code>input</code> stream receives a <code>SIGINT</code>, the\n<code>'pause'</code> event will be emitted.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGINT', () => {\n  rl.question('Are you sure you want to exit? ', (answer) => {\n    if (answer.match(/^y(es)?$/i)) rl.pause();\n  });\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'SIGTSTP'`",
@@ -46403,7 +51397,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'SIGTSTP'</code> event is emitted when the <code>input</code> stream receives a <code>&#x3C;ctrl>-Z</code>\ninput, typically known as <code>SIGTSTP</code>. If there are no <code>'SIGTSTP'</code> event listeners\nregistered when the <code>input</code> stream receives a <code>SIGTSTP</code>, the Node.js process\nwill be sent to the background.</p>\n<p>When the program is resumed using <a href=\"http://man7.org/linux/man-pages/man1/fg.1p.html\"><code>fg(1p)</code></a>, the <code>'pause'</code> and <code>'SIGCONT'</code> events\nwill be emitted. These can be used to resume the <code>input</code> stream.</p>\n<p>The <code>'pause'</code> and <code>'SIGCONT'</code> events will not be emitted if the <code>input</code> was\npaused before the process was sent to the background.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGTSTP', () => {\n  // This will override SIGTSTP and prevent the program from going to the\n  // background.\n  console.log('Caught SIGTSTP.');\n});\n</code></pre>\n<p>The <code>'SIGTSTP'</code> event is <em>not</em> supported on Windows.</p>"
+              "desc": "<p>The <code>'SIGTSTP'</code> event is emitted when the <code>input</code> stream receives a\n<kbd>Ctrl</kbd>+<kbd>Z</kbd> input, typically known as <code>SIGTSTP</code>. If there are\nno <code>'SIGTSTP'</code> event listeners registered when the <code>input</code> stream receives a\n<code>SIGTSTP</code>, the Node.js process will be sent to the background.</p>\n<p>When the program is resumed using <a href=\"http://man7.org/linux/man-pages/man1/fg.1p.html\"><code>fg(1p)</code></a>, the <code>'pause'</code> and <code>'SIGCONT'</code> events\nwill be emitted. These can be used to resume the <code>input</code> stream.</p>\n<p>The <code>'pause'</code> and <code>'SIGCONT'</code> events will not be emitted if the <code>input</code> was\npaused before the process was sent to the background.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGTSTP', () => {\n  // This will override SIGTSTP and prevent the program from going to the\n  // background.\n  console.log('Caught SIGTSTP.');\n});\n</code></pre>\n<p>The <code>'SIGTSTP'</code> event is <em>not</em> supported on Windows.</p>"
             }
           ],
           "methods": [
@@ -46466,7 +51460,7 @@
               "desc": "<p>The <code>rl.prompt()</code> method writes the <code>readline.Interface</code> instances configured\n<code>prompt</code> to a new line in <code>output</code> in order to provide a user with a new\nlocation at which to provide input.</p>\n<p>When called, <code>rl.prompt()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the prompt is not written.</p>"
             },
             {
-              "textRaw": "`rl.question(query, callback)`",
+              "textRaw": "`rl.question(query[, options], callback)`",
               "type": "method",
               "name": "question",
               "meta": {
@@ -46484,6 +51478,19 @@
                       "type": "string",
                       "desc": "A statement or query to write to `output`, prepended to the prompt."
                     },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`signal` {AbortSignal} Optionally allows the `question()` to be canceled using an `AbortController`.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "Optionally allows the `question()` to be canceled using an `AbortController`."
+                        }
+                      ]
+                    },
                     {
                       "textRaw": "`callback` {Function} A callback function that is invoked with the user's input in response to the `query`.",
                       "name": "callback",
@@ -46493,7 +51500,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>rl.question()</code> method displays the <code>query</code> by writing it to the <code>output</code>,\nwaits for user input to be provided on <code>input</code>, then invokes the <code>callback</code>\nfunction passing the provided input as the first argument.</p>\n<p>When called, <code>rl.question()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the <code>query</code> is not written.</p>\n<p>Example usage:</p>\n<pre><code class=\"language-js\">rl.question('What is your favorite food? ', (answer) => {\n  console.log(`Oh, so your favorite food is ${answer}`);\n});\n</code></pre>\n<p>The <code>callback</code> function passed to <code>rl.question()</code> does not follow the typical\npattern of accepting an <code>Error</code> object or <code>null</code> as the first argument.\nThe <code>callback</code> is called with the provided answer as the only argument.</p>"
+              "desc": "<p>The <code>rl.question()</code> method displays the <code>query</code> by writing it to the <code>output</code>,\nwaits for user input to be provided on <code>input</code>, then invokes the <code>callback</code>\nfunction passing the provided input as the first argument.</p>\n<p>When called, <code>rl.question()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the <code>query</code> is not written.</p>\n<p>The <code>callback</code> function passed to <code>rl.question()</code> does not follow the typical\npattern of accepting an <code>Error</code> object or <code>null</code> as the first argument.\nThe <code>callback</code> is called with the provided answer as the only argument.</p>\n<p>Example usage:</p>\n<pre><code class=\"language-js\">rl.question('What is your favorite food? ', (answer) => {\n  console.log(`Oh, so your favorite food is ${answer}`);\n});\n</code></pre>\n<p>Using an <code>AbortController</code> to cancel a question.</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\nconst signal = ac.signal;\n\nrl.question('What is your favorite food? ', { signal }, (answer) => {\n  console.log(`Oh, so your favorite food is ${answer}`);\n});\n\nsignal.addEventListener('abort', () => {\n  console.log('The food question timed out');\n}, { once: true });\n\nsetTimeout(() => ac.abort(), 10000);\n</code></pre>\n<p>If this method is invoked as it's util.promisify()ed version, it returns a\nPromise that fulfills with the answer. If the question is canceled using\nan <code>AbortController</code> it will reject with an <code>AbortError</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst question = util.promisify(rl.question).bind(rl);\n\nasync function questionExample() {\n  try {\n    const answer = await question('What is you favorite food? ');\n    console.log(`Oh, so your favorite food is ${answer}`);\n  } catch (err) {\n    console.error('Question rejected', err);\n  }\n}\nquestionExample();\n</code></pre>"
             },
             {
               "textRaw": "`rl.resume()`",
@@ -46535,6 +51542,29 @@
               ],
               "desc": "<p>The <code>rl.setPrompt()</code> method sets the prompt that will be written to <code>output</code>\nwhenever <code>rl.prompt()</code> is called.</p>"
             },
+            {
+              "textRaw": "`rl.getPrompt()`",
+              "type": "method",
+              "name": "getPrompt",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {string} the current prompt string",
+                    "name": "return",
+                    "type": "string",
+                    "desc": "the current prompt string"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>The <code>rl.getPrompt()</code> method returns the current prompt used by <code>rl.prompt()</code>.</p>"
+            },
             {
               "textRaw": "`rl.write(data[, key])`",
               "type": "method",
@@ -46559,22 +51589,22 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`ctrl` {boolean} `true` to indicate the `<ctrl>` key.",
+                          "textRaw": "`ctrl` {boolean} `true` to indicate the <kbd>Ctrl</kbd> key.",
                           "name": "ctrl",
                           "type": "boolean",
-                          "desc": "`true` to indicate the `<ctrl>` key."
+                          "desc": "`true` to indicate the <kbd>Ctrl</kbd> key."
                         },
                         {
-                          "textRaw": "`meta` {boolean} `true` to indicate the `<Meta>` key.",
+                          "textRaw": "`meta` {boolean} `true` to indicate the <kbd>Meta</kbd> key.",
                           "name": "meta",
                           "type": "boolean",
-                          "desc": "`true` to indicate the `<Meta>` key."
+                          "desc": "`true` to indicate the <kbd>Meta</kbd> key."
                         },
                         {
-                          "textRaw": "`shift` {boolean} `true` to indicate the `<Shift>` key.",
+                          "textRaw": "`shift` {boolean} `true` to indicate the <kbd>Shift</kbd> key.",
                           "name": "shift",
                           "type": "boolean",
-                          "desc": "`true` to indicate the `<Shift>` key."
+                          "desc": "`true` to indicate the <kbd>Shift</kbd> key."
                         },
                         {
                           "textRaw": "`name` {string} The name of the a key.",
@@ -46587,7 +51617,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>rl.write()</code> method will write either <code>data</code> or a key sequence identified\nby <code>key</code> to the <code>output</code>. The <code>key</code> argument is supported only if <code>output</code> is\na <a href=\"tty.html\">TTY</a> text terminal. See <a href=\"readline.html#readline_tty_keybindings\">TTY keybindings</a> for a list of key\ncombinations.</p>\n<p>If <code>key</code> is specified, <code>data</code> is ignored.</p>\n<p>When called, <code>rl.write()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the <code>data</code> and <code>key</code> are not written.</p>\n<pre><code class=\"language-js\">rl.write('Delete this!');\n// Simulate Ctrl+u to delete the line written previously\nrl.write(null, { ctrl: true, name: 'u' });\n</code></pre>\n<p>The <code>rl.write()</code> method will write the data to the <code>readline</code> <code>Interface</code>'s\n<code>input</code> <em>as if it were provided by the user</em>.</p>"
+              "desc": "<p>The <code>rl.write()</code> method will write either <code>data</code> or a key sequence identified\nby <code>key</code> to the <code>output</code>. The <code>key</code> argument is supported only if <code>output</code> is\na <a href=\"tty.html\">TTY</a> text terminal. See <a href=\"readline.html#readline_tty_keybindings\">TTY keybindings</a> for a list of key\ncombinations.</p>\n<p>If <code>key</code> is specified, <code>data</code> is ignored.</p>\n<p>When called, <code>rl.write()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the <code>data</code> and <code>key</code> are not written.</p>\n<pre><code class=\"language-js\">rl.write('Delete this!');\n// Simulate Ctrl+U to delete the line written previously\nrl.write(null, { ctrl: true, name: 'u' });\n</code></pre>\n<p>The <code>rl.write()</code> method will write the data to the <code>readline</code> <code>Interface</code>'s\n<code>input</code> <em>as if it were provided by the user</em>.</p>"
             },
             {
               "textRaw": "`rl[Symbol.asyncIterator]()`",
@@ -46595,11 +51625,15 @@
               "name": "[Symbol.asyncIterator]",
               "meta": {
                 "added": [
-                  "v11.4.0"
+                  "v11.4.0",
+                  "v10.16.0"
                 ],
                 "changes": [
                   {
-                    "version": "v11.14.0",
+                    "version": [
+                      "v11.14.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/26989",
                     "description": "Symbol.asyncIterator support is no longer experimental."
                   }
@@ -46615,7 +51649,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Create an <code>AsyncIterator</code> object that iterates through each line in the input\nstream as a string. This method allows asynchronous iteration of\n<code>readline.Interface</code> objects through <code>for await...of</code> loops.</p>\n<p>Errors in the input stream are not forwarded.</p>\n<p>If the loop is terminated with <code>break</code>, <code>throw</code>, or <code>return</code>,\n<a href=\"readline.html#readline_rl_close\"><code>rl.close()</code></a> will be called. In other words, iterating over a\n<code>readline.Interface</code> will always consume the input stream fully.</p>\n<p>Performance is not on par with the traditional <code>'line'</code> event API. Use <code>'line'</code>\ninstead for performance-sensitive applications.</p>\n<pre><code class=\"language-js\">async function processLineByLine() {\n  const rl = readline.createInterface({\n    // ...\n  });\n\n  for await (const line of rl) {\n    // Each line in the readline input will be successively available here as\n    // `line`.\n  }\n}\n</code></pre>"
+              "desc": "<p>Create an <code>AsyncIterator</code> object that iterates through each line in the input\nstream as a string. This method allows asynchronous iteration of\n<code>readline.Interface</code> objects through <code>for await...of</code> loops.</p>\n<p>Errors in the input stream are not forwarded.</p>\n<p>If the loop is terminated with <code>break</code>, <code>throw</code>, or <code>return</code>,\n<a href=\"readline.html#readline_rl_close\"><code>rl.close()</code></a> will be called. In other words, iterating over a\n<code>readline.Interface</code> will always consume the input stream fully.</p>\n<p>Performance is not on par with the traditional <code>'line'</code> event API. Use <code>'line'</code>\ninstead for performance-sensitive applications.</p>\n<pre><code class=\"language-js\">async function processLineByLine() {\n  const rl = readline.createInterface({\n    // ...\n  });\n\n  for await (const line of rl) {\n    // Each line in the readline input will be successively available here as\n    // `line`.\n  }\n}\n</code></pre>\n<p><code>readline.createInterface()</code> will start to consume the input stream once\ninvoked. Having asynchronous operations between interface creation and\nasynchronous iteration may result in missed lines.</p>"
             },
             {
               "textRaw": "`rl.getCursorPos()`",
@@ -46623,6 +51657,7 @@
               "name": "getCursorPos",
               "meta": {
                 "added": [
+                  "v13.5.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -46656,14 +51691,20 @@
           ],
           "properties": [
             {
-              "textRaw": "`line` {string|undefined}",
-              "type": "string|undefined",
+              "textRaw": "`line` {string}",
+              "type": "string",
               "name": "line",
               "meta": {
                 "added": [
                   "v0.1.98"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33676",
+                    "description": "Value will always be a string, never undefined."
+                  }
+                ]
               },
               "desc": "<p>The current input data being processed by node.</p>\n<p>This can be used when collecting input from a TTY stream to retrieve the\ncurrent value that has been processed thus far, prior to the <code>line</code> event\nbeing emitted. Once the <code>line</code> event has been emitted, this property will\nbe an empty string.</p>\n<p>Be aware that modifying the value during the instance runtime may have\nunintended consequences if <code>rl.cursor</code> is not also controlled.</p>\n<p><strong>If not using a TTY stream for input, use the <a href=\"readline.html#readline_event_line\"><code>'line'</code></a> event.</strong></p>\n<p>One possible use case would be as follows:</p>\n<pre><code class=\"language-js\">const values = ['lorem ipsum', 'dolor sit amet'];\nconst rl = readline.createInterface(process.stdin);\nconst showResults = debounce(() => {\n  console.log(\n    '\\n',\n    values.filter((val) => val.startsWith(rl.line)).join(' ')\n  );\n}, 300);\nprocess.stdin.on('keypress', (c, k) => {\n  showResults();\n});\n</code></pre>"
             },
@@ -46797,7 +51838,25 @@
             ],
             "changes": [
               {
-                "version": "v8.3.0, 6.11.4",
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/37932",
+                "description": "The `signal` option is supported now."
+              },
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/33662",
+                "description": "The `history` option is supported now."
+              },
+              {
+                "version": "v13.9.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31318",
+                "description": "The `tabSize` option is supported now."
+              },
+              {
+                "version": [
+                  "v8.3.0",
+                  "v6.11.4"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/13497",
                 "description": "Remove max limit of `crlfDelay` option."
               },
@@ -46820,6 +51879,11 @@
           },
           "signatures": [
             {
+              "return": {
+                "textRaw": "Returns: {readline.Interface}",
+                "name": "return",
+                "type": "readline.Interface"
+              },
               "params": [
                 {
                   "textRaw": "`options` {Object}",
@@ -46851,6 +51915,13 @@
                       "default": "checking `isTTY` on the `output` stream upon instantiation",
                       "desc": "`true` if the `input` and `output` streams should be treated like a TTY, and have ANSI/VT100 escape codes written to it."
                     },
+                    {
+                      "textRaw": "`history` {string[]} Initial list of history lines. This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check, otherwise the history caching mechanism is not initialized at all. **Default:** `[]`.",
+                      "name": "history",
+                      "type": "string[]",
+                      "default": "`[]`",
+                      "desc": "Initial list of history lines. This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check, otherwise the history caching mechanism is not initialized at all."
+                    },
                     {
                       "textRaw": "`historySize` {number} Maximum number of history lines retained. To disable the history set this value to `0`. This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check, otherwise the history caching mechanism is not initialized at all. **Default:** `30`.",
                       "name": "historySize",
@@ -46858,6 +51929,13 @@
                       "default": "`30`",
                       "desc": "Maximum number of history lines retained. To disable the history set this value to `0`. This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check, otherwise the history caching mechanism is not initialized at all."
                     },
+                    {
+                      "textRaw": "`removeHistoryDuplicates` {boolean} If `true`, when a new input line added to the history list duplicates an older one, this removes the older line from the list. **Default:** `false`.",
+                      "name": "removeHistoryDuplicates",
+                      "type": "boolean",
+                      "default": "`false`",
+                      "desc": "If `true`, when a new input line added to the history list duplicates an older one, this removes the older line from the list."
+                    },
                     {
                       "textRaw": "`prompt` {string} The prompt string to use. **Default:** `'> '`.",
                       "name": "prompt",
@@ -46872,26 +51950,32 @@
                       "default": "`100`",
                       "desc": "If the delay between `\\r` and `\\n` exceeds `crlfDelay` milliseconds, both `\\r` and `\\n` will be treated as separate end-of-line input. `crlfDelay` will be coerced to a number no less than `100`. It can be set to `Infinity`, in which case `\\r` followed by `\\n` will always be considered a single newline (which may be reasonable for [reading files][] with `\\r\\n` line delimiter)."
                     },
-                    {
-                      "textRaw": "`removeHistoryDuplicates` {boolean} If `true`, when a new input line added to the history list duplicates an older one, this removes the older line from the list. **Default:** `false`.",
-                      "name": "removeHistoryDuplicates",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "If `true`, when a new input line added to the history list duplicates an older one, this removes the older line from the list."
-                    },
                     {
                       "textRaw": "`escapeCodeTimeout` {number} The duration `readline` will wait for a character (when reading an ambiguous key sequence in milliseconds one that can both form a complete key sequence using the input read so far and can take additional input to complete a longer key sequence). **Default:** `500`.",
                       "name": "escapeCodeTimeout",
                       "type": "number",
                       "default": "`500`",
                       "desc": "The duration `readline` will wait for a character (when reading an ambiguous key sequence in milliseconds one that can both form a complete key sequence using the input read so far and can take additional input to complete a longer key sequence)."
+                    },
+                    {
+                      "textRaw": "`tabSize` {integer} The number of spaces a tab is equal to (minimum 1). **Default:** `8`.",
+                      "name": "tabSize",
+                      "type": "integer",
+                      "default": "`8`",
+                      "desc": "The number of spaces a tab is equal to (minimum 1)."
+                    },
+                    {
+                      "textRaw": "`signal` {AbortSignal} Allows closing the interface using an AbortSignal. Aborting the signal will internally call `close` on the interface.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": "Allows closing the interface using an AbortSignal. Aborting the signal will internally call `close` on the interface."
                     }
                   ]
                 }
               ]
             }
           ],
-          "desc": "<p>The <code>readline.createInterface()</code> method creates a new <code>readline.Interface</code>\ninstance.</p>\n<pre><code class=\"language-js\">const readline = require('readline');\nconst rl = readline.createInterface({\n  input: process.stdin,\n  output: process.stdout\n});\n</code></pre>\n<p>Once the <code>readline.Interface</code> instance is created, the most common case is to\nlisten for the <code>'line'</code> event:</p>\n<pre><code class=\"language-js\">rl.on('line', (line) => {\n  console.log(`Received: ${line}`);\n});\n</code></pre>\n<p>If <code>terminal</code> is <code>true</code> for this instance then the <code>output</code> stream will get\nthe best compatibility if it defines an <code>output.columns</code> property and emits\na <code>'resize'</code> event on the <code>output</code> if or when the columns ever change\n(<a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> does this automatically when it is a TTY).</p>",
+          "desc": "<p>The <code>readline.createInterface()</code> method creates a new <code>readline.Interface</code>\ninstance.</p>\n<pre><code class=\"language-js\">const readline = require('readline');\nconst rl = readline.createInterface({\n  input: process.stdin,\n  output: process.stdout\n});\n</code></pre>\n<p>Once the <code>readline.Interface</code> instance is created, the most common case is to\nlisten for the <code>'line'</code> event:</p>\n<pre><code class=\"language-js\">rl.on('line', (line) => {\n  console.log(`Received: ${line}`);\n});\n</code></pre>\n<p>If <code>terminal</code> is <code>true</code> for this instance then the <code>output</code> stream will get\nthe best compatibility if it defines an <code>output.columns</code> property and emits\na <code>'resize'</code> event on the <code>output</code> if or when the columns ever change\n(<a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> does this automatically when it is a TTY).</p>\n<p>When creating a <code>readline.Interface</code> using <code>stdin</code> as input, the program\nwill not terminate until it receives <code>EOF</code> (<kbd>Ctrl</kbd>+<kbd>D</kbd> on\nLinux/macOS, <kbd>Ctrl</kbd>+<kbd>Z</kbd> followed by <kbd>Return</kbd> on\nWindows).\nIf you want your application to exit without waiting for user input, you can\n<a href=\"net.html#net_socket_unref\"><code>unref()</code></a> the standard input stream:</p>\n<pre><code class=\"language-js\">process.stdin.unref();\n</code></pre>",
           "modules": [
             {
               "textRaw": "Use of the `completer` function",
@@ -47037,13 +52121,14 @@
         {
           "textRaw": "TTY keybindings",
           "name": "tty_keybindings",
-          "desc": "<table>\n  <tr>\n    <th>Keybindings</th>\n    <th>Description</th>\n    <th>Notes</th>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>shift</code> + <code>backspace</code></td>\n    <td>Delete line left</td>\n    <td>Doesn't work on Linux, Mac and Windows</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>shift</code> + <code>delete</code></td>\n    <td>Delete line right</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>c</code></td>\n    <td>Emit <code>SIGINT</code> or close the readline instance</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>h</code></td>\n    <td>Delete left</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>d</code></td>\n    <td>Delete right or close the readline instance in case the current line is empty / EOF</td>\n    <td>Doesn't work on Windows</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>u</code></td>\n    <td>Delete from the current position to the line start</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>k</code></td>\n    <td>Delete from the current position to the end of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>a</code></td>\n    <td>Go to start of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>e</code></td>\n    <td>Go to to end of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>b</code></td>\n    <td>Back one character</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>f</code></td>\n    <td>Forward one character</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>l</code></td>\n    <td>Clear screen</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>n</code></td>\n    <td>Next history item</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>p</code></td>\n    <td>Previous history item</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>z</code></td>\n    <td>Moves running process into background. Type\n    <code>fg</code> and press <code>enter</code>\n    to return.</td>\n    <td>Doesn't work on Windows</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>w</code> or <code>ctrl</code>\n    + <code>backspace</code></td>\n    <td>Delete backward to a word boundary</td>\n    <td><code>ctrl</code> + <code>backspace</code> Doesn't\n    work on Linux, Mac and Windows</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>delete</code></td>\n    <td>Delete forward to a word boundary</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>left</code> or\n    <code>meta</code> + <code>b</code></td>\n    <td>Word left</td>\n    <td><code>ctrl</code> + <code>left</code> Doesn't work\n    on Mac</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>right</code> or\n    <code>meta</code> + <code>f</code></td>\n    <td>Word right</td>\n    <td><code>ctrl</code> + <code>right</code> Doesn't work\n    on Mac</td>\n  </tr>\n  <tr>\n    <td><code>meta</code> + <code>d</code> or <code>meta</code>\n    + <code>delete</code></td>\n    <td>Delete word right</td>\n    <td><code>meta</code> + <code>delete</code> Doesn't work\n    on windows</td>\n  </tr>\n  <tr>\n    <td><code>meta</code> + <code>backspace</code></td>\n    <td>Delete word left</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n</table>",
+          "desc": "<table>\n  <tr>\n    <th>Keybindings</th>\n    <th>Description</th>\n    <th>Notes</th>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Backspace</kbd></td>\n    <td>Delete line left</td>\n    <td>Doesn't work on Linux, Mac and Windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Delete</kbd></td>\n    <td>Delete line right</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>C</kbd></td>\n    <td>Emit <code>SIGINT</code> or close the readline instance</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>H</kbd></td>\n    <td>Delete left</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>D</kbd></td>\n    <td>Delete right or close the readline instance in case the current line is empty / EOF</td>\n    <td>Doesn't work on Windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>U</kbd></td>\n    <td>Delete from the current position to the line start</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>K</kbd></td>\n    <td>Delete from the current position to the end of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>A</kbd></td>\n    <td>Go to start of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>E</kbd></td>\n    <td>Go to to end of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>B</kbd></td>\n    <td>Back one character</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>F</kbd></td>\n    <td>Forward one character</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>L</kbd></td>\n    <td>Clear screen</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>N</kbd></td>\n    <td>Next history item</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>P</kbd></td>\n    <td>Previous history item</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Z</kbd></td>\n    <td>Moves running process into background. Type\n    <code>fg</code> and press <kbd>Enter</kbd>\n    to return.</td>\n    <td>Doesn't work on Windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>W</kbd> or <kbd>Ctrl</kbd>\n   +<kbd>Backspace</kbd></td>\n    <td>Delete backward to a word boundary</td>\n    <td><kbd>Ctrl</kbd>+<kbd>Backspace</kbd> Doesn't\n    work on Linux, Mac and Windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Delete</kbd></td>\n    <td>Delete forward to a word boundary</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> or\n    <kbd>Meta</kbd>+<kbd>B</kbd></td>\n    <td>Word left</td>\n    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> Doesn't work\n    on Mac</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> or\n    <kbd>Meta</kbd>+<kbd>F</kbd></td>\n    <td>Word right</td>\n    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> Doesn't work\n    on Mac</td>\n  </tr>\n  <tr>\n    <td><kbd>Meta</kbd>+<kbd>D</kbd> or <kbd>Meta</kbd>\n   +<kbd>Delete</kbd></td>\n    <td>Delete word right</td>\n    <td><kbd>Meta</kbd>+<kbd>Delete</kbd> Doesn't work\n    on windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Meta</kbd>+<kbd>Backspace</kbd></td>\n    <td>Delete word left</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n</table>",
           "type": "module",
           "displayName": "TTY keybindings"
         }
       ],
       "type": "module",
-      "displayName": "Readline"
+      "displayName": "Readline",
+      "source": "doc/api/readline.md"
     },
     {
       "textRaw": "REPL",
@@ -47051,7 +52136,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/repl.js\">lib/repl.js</a></p>\n<p>The <code>repl</code> module provides a Read-Eval-Print-Loop (REPL) implementation that\nis available both as a standalone program or includible in other applications.\nIt can be accessed using:</p>\n<pre><code class=\"language-js\">const repl = require('repl');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/repl.js\">lib/repl.js</a></p>\n<p>The <code>repl</code> module provides a Read-Eval-Print-Loop (REPL) implementation that\nis available both as a standalone program or includible in other applications.\nIt can be accessed using:</p>\n<pre><code class=\"language-js\">const repl = require('repl');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Design and features",
@@ -47061,7 +52146,7 @@
             {
               "textRaw": "Commands and special keys",
               "name": "commands_and_special_keys",
-              "desc": "<p>The following special commands are supported by all REPL instances:</p>\n<ul>\n<li><code>.break</code>: When in the process of inputting a multi-line expression, entering\nthe <code>.break</code> command (or pressing the <code>&#x3C;ctrl>-C</code> key combination) will abort\nfurther input or processing of that expression.</li>\n<li><code>.clear</code>: Resets the REPL <code>context</code> to an empty object and clears any\nmulti-line expression being input.</li>\n<li><code>.exit</code>: Close the I/O stream, causing the REPL to exit.</li>\n<li><code>.help</code>: Show this list of special commands.</li>\n<li><code>.save</code>: Save the current REPL session to a file:\n<code>> .save ./file/to/save.js</code></li>\n<li><code>.load</code>: Load a file into the current REPL session.\n<code>> .load ./file/to/load.js</code></li>\n<li><code>.editor</code>: Enter editor mode (<code>&#x3C;ctrl>-D</code> to finish, <code>&#x3C;ctrl>-C</code> to cancel).</li>\n</ul>\n<pre><code class=\"language-console\">> .editor\n// Entering editor mode (^D to finish, ^C to cancel)\nfunction welcome(name) {\n  return `Hello ${name}!`;\n}\n\nwelcome('Node.js User');\n\n// ^D\n'Hello Node.js User!'\n>\n</code></pre>\n<p>The following key combinations in the REPL have these special effects:</p>\n<ul>\n<li><code>&#x3C;ctrl>-C</code>: When pressed once, has the same effect as the <code>.break</code> command.\nWhen pressed twice on a blank line, has the same effect as the <code>.exit</code>\ncommand.</li>\n<li><code>&#x3C;ctrl>-D</code>: Has the same effect as the <code>.exit</code> command.</li>\n<li><code>&#x3C;tab></code>: When pressed on a blank line, displays global and local (scope)\nvariables. When pressed while entering other input, displays relevant\nautocompletion options.</li>\n</ul>\n<p>For key bindings related to the reverse-i-search, see <a href=\"repl.html#repl_reverse_i_search\"><code>reverse-i-search</code></a>.\nFor all other key bindings, see <a href=\"readline.html#readline_tty_keybindings\">TTY keybindings</a>.</p>",
+              "desc": "<p>The following special commands are supported by all REPL instances:</p>\n<ul>\n<li><code>.break</code>: When in the process of inputting a multi-line expression, enter\nthe <code>.break</code> command (or press <kbd>Ctrl</kbd>+<kbd>C</kbd>) to abort\nfurther input or processing of that expression.</li>\n<li><code>.clear</code>: Resets the REPL <code>context</code> to an empty object and clears any\nmulti-line expression being input.</li>\n<li><code>.exit</code>: Close the I/O stream, causing the REPL to exit.</li>\n<li><code>.help</code>: Show this list of special commands.</li>\n<li><code>.save</code>: Save the current REPL session to a file:\n<code>> .save ./file/to/save.js</code></li>\n<li><code>.load</code>: Load a file into the current REPL session.\n<code>> .load ./file/to/load.js</code></li>\n<li><code>.editor</code>: Enter editor mode (<kbd>Ctrl</kbd>+<kbd>D</kbd> to finish,\n<kbd>Ctrl</kbd>+<kbd>C</kbd> to cancel).</li>\n</ul>\n<pre><code class=\"language-console\">> .editor\n// Entering editor mode (^D to finish, ^C to cancel)\nfunction welcome(name) {\n  return `Hello ${name}!`;\n}\n\nwelcome('Node.js User');\n\n// ^D\n'Hello Node.js User!'\n>\n</code></pre>\n<p>The following key combinations in the REPL have these special effects:</p>\n<ul>\n<li><kbd>Ctrl</kbd>+<kbd>C</kbd>: When pressed once, has the same effect as the\n<code>.break</code> command.\nWhen pressed twice on a blank line, has the same effect as the <code>.exit</code>\ncommand.</li>\n<li><kbd>Ctrl</kbd>+<kbd>D</kbd>: Has the same effect as the <code>.exit</code> command.</li>\n<li><kbd>Tab</kbd>: When pressed on a blank line, displays global and local (scope)\nvariables. When pressed while entering other input, displays relevant\nautocompletion options.</li>\n</ul>\n<p>For key bindings related to the reverse-i-search, see <a href=\"repl.html#repl_reverse_i_search\"><code>reverse-i-search</code></a>.\nFor all other key bindings, see <a href=\"readline.html#readline_tty_keybindings\">TTY keybindings</a>.</p>",
               "type": "module",
               "displayName": "Commands and special keys"
             },
@@ -47103,7 +52188,7 @@
                       }
                     ]
                   },
-                  "desc": "<p>The REPL uses the <a href=\"domain.html\"><code>domain</code></a> module to catch all uncaught exceptions for that\nREPL session.</p>\n<p>This use of the <a href=\"domain.html\"><code>domain</code></a> module in the REPL has these side effects:</p>\n<ul>\n<li>Uncaught exceptions only emit the <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event in the\nstandalone REPL. Adding a listener for this event in a REPL within\nanother Node.js program throws <a href=\"errors.html#errors_err_invalid_repl_input\"><code>ERR_INVALID_REPL_INPUT</code></a>.</li>\n<li>Trying to use <a href=\"process.html#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a> throws\nan <a href=\"errors.html#errors_err_domain_cannot_set_uncaught_exception_capture\"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a> error.</li>\n</ul>\n<p>As standalone program:</p>\n<pre><code class=\"language-js\">process.on('uncaughtException', () => console.log('Uncaught'));\n\nthrow new Error('foobar');\n// Uncaught\n</code></pre>\n<p>When used in another application:</p>\n<pre><code class=\"language-js\">process.on('uncaughtException', () => console.log('Uncaught'));\n// TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`\n// cannot be used in the REPL\n\nthrow new Error('foobar');\n// Thrown:\n// Error: foobar\n</code></pre>",
+                  "desc": "<p>The REPL uses the <a href=\"domain.html\"><code>domain</code></a> module to catch all uncaught exceptions for that\nREPL session.</p>\n<p>This use of the <a href=\"domain.html\"><code>domain</code></a> module in the REPL has these side effects:</p>\n<ul>\n<li>\n<p>Uncaught exceptions only emit the <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event in the\nstandalone REPL. Adding a listener for this event in a REPL within\nanother Node.js program results in <a href=\"errors.html#errors_err_invalid_repl_input\"><code>ERR_INVALID_REPL_INPUT</code></a>.</p>\n<pre><code class=\"language-js\">const r = repl.start();\n\nr.write('process.on(\"uncaughtException\", () => console.log(\"Foobar\"));\\n');\n// Output stream includes:\n//   TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`\n//   cannot be used in the REPL\n\nr.close();\n</code></pre>\n</li>\n<li>\n<p>Trying to use <a href=\"process.html#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a> throws\nan <a href=\"errors.html#errors_err_domain_cannot_set_uncaught_exception_capture\"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a> error.</p>\n</li>\n</ul>",
                   "type": "module",
                   "displayName": "Global uncaught exceptions"
                 },
@@ -47126,7 +52211,7 @@
                 {
                   "textRaw": "`await` keyword",
                   "name": "`await`_keyword",
-                  "desc": "<p>With the <a href=\"cli.html#cli_experimental_repl_await\"><code>--experimental-repl-await</code></a> command line option specified,\nexperimental support for the <code>await</code> keyword is enabled.</p>\n<pre><code class=\"language-console\">> await Promise.resolve(123)\n123\n> await Promise.reject(new Error('REPL await'))\nError: REPL await\n    at repl:1:45\n> const timeout = util.promisify(setTimeout);\nundefined\n> const old = Date.now(); await timeout(1000); console.log(Date.now() - old);\n1002\nundefined\n</code></pre>",
+                  "desc": "<p>With the <a href=\"cli.html#cli_experimental_repl_await\"><code>--experimental-repl-await</code></a> command-line option specified,\nexperimental support for the <code>await</code> keyword is enabled.</p>\n<pre><code class=\"language-console\">> await Promise.resolve(123)\n123\n> await Promise.reject(new Error('REPL await'))\nError: REPL await\n    at repl:1:45\n> const timeout = util.promisify(setTimeout);\nundefined\n> const old = Date.now(); await timeout(1000); console.log(Date.now() - old);\n1002\nundefined\n</code></pre>\n<p>One known limitation of using the <code>await</code> keyword in the REPL is that\nit will invalidate the lexical scoping of the <code>const</code> and <code>let</code>\nkeywords.</p>\n<p>For example:</p>\n<pre><code class=\"language-console\">> const m = await Promise.resolve(123)\nundefined\n> m\n123\n> const m = await Promise.resolve(234)\nundefined\n> m\n234\n</code></pre>",
                   "type": "module",
                   "displayName": "`await` keyword"
                 }
@@ -47139,11 +52224,11 @@
               "name": "reverse-i-search",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.6.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The REPL supports bi-directional reverse-i-search similar to <a href=\"https://en.wikipedia.org/wiki/Z_shell\">ZSH</a>. It is\ntriggered with <code>&#x3C;ctrl> + R</code> to search backward and <code>&#x3C;ctrl> + S</code> to search\nforward.</p>\n<p>Duplicated history entires will be skipped.</p>\n<p>Entries are accepted as soon as any button is pressed that doesn't correspond\nwith the reverse search. Cancelling is possible by pressing <code>escape</code> or\n<code>&#x3C;ctrl> + C</code>.</p>\n<p>Changing the direction immediately searches for the next entry in the expected\ndirection from the current position on.</p>",
+              "desc": "<p>The REPL supports bi-directional reverse-i-search similar to <a href=\"https://en.wikipedia.org/wiki/Z_shell\">ZSH</a>. It is\ntriggered with <kbd>Ctrl</kbd>+<kbd>R</kbd> to search backward and\n<kbd>Ctrl</kbd>+<kbd>S</kbd> to search\nforwards.</p>\n<p>Duplicated history entries will be skipped.</p>\n<p>Entries are accepted as soon as any key is pressed that doesn't correspond\nwith the reverse search. Cancelling is possible by pressing <kbd>Esc</kbd> or\n<kbd>Ctrl</kbd>+<kbd>C</kbd>.</p>\n<p>Changing the direction immediately searches for the next entry in the expected\ndirection from the current position on.</p>",
               "type": "module",
               "displayName": "Reverse-i-search"
             },
@@ -47155,7 +52240,7 @@
                 {
                   "textRaw": "Recoverable errors",
                   "name": "recoverable_errors",
-                  "desc": "<p>As a user is typing input into the REPL prompt, pressing the <code>&#x3C;enter></code> key will\nsend the current line of input to the <code>eval</code> function. In order to support\nmulti-line input, the eval function can return an instance of <code>repl.Recoverable</code>\nto the provided callback function:</p>\n<pre><code class=\"language-js\">function myEval(cmd, context, filename, callback) {\n  let result;\n  try {\n    result = vm.runInThisContext(cmd);\n  } catch (e) {\n    if (isRecoverableError(e)) {\n      return callback(new repl.Recoverable(e));\n    }\n  }\n  callback(null, result);\n}\n\nfunction isRecoverableError(error) {\n  if (error.name === 'SyntaxError') {\n    return /^(Unexpected end of input|Unexpected token)/.test(error.message);\n  }\n  return false;\n}\n</code></pre>",
+                  "desc": "<p>At the REPL prompt, pressing <kbd>Enter</kbd> sends the current line of input to\nthe <code>eval</code> function. In order to support multi-line input, the <code>eval</code> function\ncan return an instance of <code>repl.Recoverable</code> to the provided callback function:</p>\n<pre><code class=\"language-js\">function myEval(cmd, context, filename, callback) {\n  let result;\n  try {\n    result = vm.runInThisContext(cmd);\n  } catch (e) {\n    if (isRecoverableError(e)) {\n      return callback(new repl.Recoverable(e));\n    }\n  }\n  callback(null, result);\n}\n\nfunction isRecoverableError(error) {\n  if (error.name === 'SyntaxError') {\n    return /^(Unexpected end of input|Unexpected token)/.test(error.message);\n  }\n  return false;\n}\n</code></pre>",
                   "type": "module",
                   "displayName": "Recoverable errors"
                 }
@@ -47236,7 +52321,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'exit'</code> event is emitted when the REPL is exited either by receiving the\n<code>.exit</code> command as input, the user pressing <code>&#x3C;ctrl>-C</code> twice to signal <code>SIGINT</code>,\nor by pressing <code>&#x3C;ctrl>-D</code> to signal <code>'end'</code> on the input stream. The listener\ncallback is invoked without any arguments.</p>\n<pre><code class=\"language-js\">replServer.on('exit', () => {\n  console.log('Received \"exit\" event from repl!');\n  process.exit();\n});\n</code></pre>"
+              "desc": "<p>The <code>'exit'</code> event is emitted when the REPL is exited either by receiving the\n<code>.exit</code> command as input, the user pressing <kbd>Ctrl</kbd>+<kbd>C</kbd> twice\nto signal <code>SIGINT</code>,\nor by pressing <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal <code>'end'</code> on the input\nstream. The listener\ncallback is invoked without any arguments.</p>\n<pre><code class=\"language-js\">replServer.on('exit', () => {\n  console.log('Received \"exit\" event from repl!');\n  process.exit();\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'reset'`",
@@ -47403,11 +52488,25 @@
                   ]
                 }
               ],
-              "desc": "<p>Initializes a history log file for the REPL instance. When executing the\nNode.js binary and using the command line REPL, a history file is initialized\nby default. However, this is not the case when creating a REPL\nprogrammatically. Use this method to initialize a history log file when working\nwith REPL instances programmatically.</p>"
+              "desc": "<p>Initializes a history log file for the REPL instance. When executing the\nNode.js binary and using the command-line REPL, a history file is initialized\nby default. However, this is not the case when creating a REPL\nprogrammatically. Use this method to initialize a history log file when working\nwith REPL instances programmatically.</p>"
             }
           ]
         }
       ],
+      "properties": [
+        {
+          "textRaw": "`builtinModules` {string[]}",
+          "type": "string[]",
+          "name": "builtinModules",
+          "meta": {
+            "added": [
+              "v14.5.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>A list of the names of all Node.js modules, e.g., <code>'http'</code>.</p>"
+        }
+      ],
       "methods": [
         {
           "textRaw": "`repl.start([options])`",
@@ -47419,7 +52518,7 @@
             ],
             "changes": [
               {
-                "version": "v12.17.0",
+                "version": "v13.4.0",
                 "pr-url": "https://github.com/nodejs/node/pull/30811",
                 "description": "The `preview` option is now available."
               },
@@ -47546,11 +52645,11 @@
                       ]
                     },
                     {
-                      "textRaw": "`breakEvalOnSigint` {boolean} Stop evaluating the current piece of code when `SIGINT` is received, such as when `Ctrl+C` is pressed. This cannot be used together with a custom `eval` function. **Default:** `false`.",
+                      "textRaw": "`breakEvalOnSigint` {boolean} Stop evaluating the current piece of code when `SIGINT` is received, such as when <kbd>Ctrl</kbd>+<kbd>C</kbd> is pressed. This cannot be used together with a custom `eval` function. **Default:** `false`.",
                       "name": "breakEvalOnSigint",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "Stop evaluating the current piece of code when `SIGINT` is received, such as when `Ctrl+C` is pressed. This cannot be used together with a custom `eval` function."
+                      "desc": "Stop evaluating the current piece of code when `SIGINT` is received, such as when <kbd>Ctrl</kbd>+<kbd>C</kbd> is pressed. This cannot be used together with a custom `eval` function."
                     },
                     {
                       "textRaw": "`preview` {boolean} Defines if the repl prints autocomplete and output previews or not. **Default:** `true` with the default eval function and `false` in case a custom eval function is used. If `terminal` is falsy, then there are no previews and the value of `preview` has no effect.",
@@ -47568,7 +52667,8 @@
         }
       ],
       "type": "module",
-      "displayName": "REPL"
+      "displayName": "REPL",
+      "source": "doc/api/repl.md"
     },
     {
       "textRaw": "Stream",
@@ -47576,7 +52676,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/stream.js\">lib/stream.js</a></p>\n<p>A stream is an abstract interface for working with streaming data in Node.js.\nThe <code>stream</code> module provides an API for implementing the stream interface.</p>\n<p>There are many stream objects provided by Node.js. For instance, a\n<a href=\"http.html#http_class_http_incomingmessage\">request to an HTTP server</a> and <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a>\nare both stream instances.</p>\n<p>Streams can be readable, writable, or both. All streams are instances of\n<a href=\"events.html#events_class_eventemitter\"><code>EventEmitter</code></a>.</p>\n<p>To access the <code>stream</code> module:</p>\n<pre><code class=\"language-js\">const stream = require('stream');\n</code></pre>\n<p>The <code>stream</code> module is useful for creating new types of stream instances. It is\nusually not necessary to use the <code>stream</code> module to consume streams.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/stream.js\">lib/stream.js</a></p>\n<p>A stream is an abstract interface for working with streaming data in Node.js.\nThe <code>stream</code> module provides an API for implementing the stream interface.</p>\n<p>There are many stream objects provided by Node.js. For instance, a\n<a href=\"http.html#http_class_http_incomingmessage\">request to an HTTP server</a> and <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a>\nare both stream instances.</p>\n<p>Streams can be readable, writable, or both. All streams are instances of\n<a href=\"events.html#events_class_eventemitter\"><code>EventEmitter</code></a>.</p>\n<p>To access the <code>stream</code> module:</p>\n<pre><code class=\"language-js\">const stream = require('stream');\n</code></pre>\n<p>The <code>stream</code> module is useful for creating new types of stream instances. It is\nusually not necessary to use the <code>stream</code> module to consume streams.</p>",
       "modules": [
         {
           "textRaw": "Organization of this document",
@@ -47588,7 +52688,7 @@
         {
           "textRaw": "Types of streams",
           "name": "types_of_streams",
-          "desc": "<p>There are four fundamental stream types within Node.js:</p>\n<ul>\n<li><a href=\"stream.html#stream_class_stream_writable\"><code>Writable</code></a>: streams to which data can be written (for example,\n<a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>).</li>\n<li><a href=\"stream.html#stream_class_stream_readable\"><code>Readable</code></a>: streams from which data can be read (for example,\n<a href=\"fs.html#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a>).</li>\n<li><a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a>: streams that are both <code>Readable</code> and <code>Writable</code> (for example,\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>).</li>\n<li><a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a>: <code>Duplex</code> streams that can modify or transform the data as it\nis written and read (for example, <a href=\"zlib.html#zlib_zlib_createdeflate_options\"><code>zlib.createDeflate()</code></a>).</li>\n</ul>\n<p>Additionally, this module includes the utility functions\n<a href=\"stream.html#stream_stream_pipeline_streams_callback\"><code>stream.pipeline()</code></a>, <a href=\"stream.html#stream_stream_finished_stream_options_callback\"><code>stream.finished()</code></a> and\n<a href=\"stream.html#stream_stream_readable_from_iterable_options\"><code>stream.Readable.from()</code></a>.</p>",
+          "desc": "<p>There are four fundamental stream types within Node.js:</p>\n<ul>\n<li><a href=\"stream.html#stream_class_stream_writable\"><code>Writable</code></a>: streams to which data can be written (for example,\n<a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>).</li>\n<li><a href=\"stream.html#stream_class_stream_readable\"><code>Readable</code></a>: streams from which data can be read (for example,\n<a href=\"fs.html#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a>).</li>\n<li><a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a>: streams that are both <code>Readable</code> and <code>Writable</code> (for example,\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>).</li>\n<li><a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a>: <code>Duplex</code> streams that can modify or transform the data as it\nis written and read (for example, <a href=\"zlib.html#zlib_zlib_createdeflate_options\"><code>zlib.createDeflate()</code></a>).</li>\n</ul>\n<p>Additionally, this module includes the utility functions\n<a href=\"stream.html#stream_stream_pipeline_source_transforms_destination_callback\"><code>stream.pipeline()</code></a>, <a href=\"stream.html#stream_stream_finished_stream_options_callback\"><code>stream.finished()</code></a> and\n<a href=\"stream.html#stream_stream_readable_from_iterable_options\"><code>stream.Readable.from()</code></a>.</p>",
           "modules": [
             {
               "textRaw": "Object mode",
@@ -47603,7 +52703,7 @@
               "textRaw": "Buffering",
               "name": "Buffering",
               "type": "misc",
-              "desc": "<p>Both <a href=\"stream.html#stream_class_stream_writable\"><code>Writable</code></a> and <a href=\"stream.html#stream_class_stream_readable\"><code>Readable</code></a> streams will store data in an internal\nbuffer that can be retrieved using <code>writable.writableBuffer</code> or\n<code>readable.readableBuffer</code>, respectively.</p>\n<p>The amount of data potentially buffered depends on the <code>highWaterMark</code> option\npassed into the stream's constructor. For normal streams, the <code>highWaterMark</code>\noption specifies a <a href=\"stream.html#stream_highwatermark_discrepancy_after_calling_readable_setencoding\">total number of bytes</a>. For streams operating\nin object mode, the <code>highWaterMark</code> specifies a total number of objects.</p>\n<p>Data is buffered in <code>Readable</code> streams when the implementation calls\n<a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>stream.push(chunk)</code></a>. If the consumer of the Stream does not\ncall <a href=\"stream.html#stream_readable_read_size\"><code>stream.read()</code></a>, the data will sit in the internal\nqueue until it is consumed.</p>\n<p>Once the total size of the internal read buffer reaches the threshold specified\nby <code>highWaterMark</code>, the stream will temporarily stop reading data from the\nunderlying resource until the data currently buffered can be consumed (that is,\nthe stream will stop calling the internal <a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> method that is\nused to fill the read buffer).</p>\n<p>Data is buffered in <code>Writable</code> streams when the\n<a href=\"stream.html#stream_writable_write_chunk_encoding_callback\"><code>writable.write(chunk)</code></a> method is called repeatedly. While the\ntotal size of the internal write buffer is below the threshold set by\n<code>highWaterMark</code>, calls to <code>writable.write()</code> will return <code>true</code>. Once\nthe size of the internal buffer reaches or exceeds the <code>highWaterMark</code>, <code>false</code>\nwill be returned.</p>\n<p>A key goal of the <code>stream</code> API, particularly the <a href=\"stream.html#stream_readable_pipe_destination_options\"><code>stream.pipe()</code></a> method,\nis to limit the buffering of data to acceptable levels such that sources and\ndestinations of differing speeds will not overwhelm the available memory.</p>\n<p>The <code>highWaterMark</code> option is a threshold, not a limit: it dictates the amount\nof data that a stream buffers before it stops asking for more data. It does not\nenforce a strict memory limitation in general. Specific stream implementations\nmay choose to enforce stricter limits but doing so is optional.</p>\n<p>Because <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> and <a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a> streams are both <code>Readable</code> and\n<code>Writable</code>, each maintains <em>two</em> separate internal buffers used for reading and\nwriting, allowing each side to operate independently of the other while\nmaintaining an appropriate and efficient flow of data. For example,\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> instances are <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> streams whose <code>Readable</code> side allows\nconsumption of data received <em>from</em> the socket and whose <code>Writable</code> side allows\nwriting data <em>to</em> the socket. Because data may be written to the socket at a\nfaster or slower rate than data is received, each side should\noperate (and buffer) independently of the other.</p>"
+              "desc": "<p>Both <a href=\"stream.html#stream_class_stream_writable\"><code>Writable</code></a> and <a href=\"stream.html#stream_class_stream_readable\"><code>Readable</code></a> streams will store data in an internal\nbuffer.</p>\n<p>The amount of data potentially buffered depends on the <code>highWaterMark</code> option\npassed into the stream's constructor. For normal streams, the <code>highWaterMark</code>\noption specifies a <a href=\"stream.html#stream_highwatermark_discrepancy_after_calling_readable_setencoding\">total number of bytes</a>. For streams operating\nin object mode, the <code>highWaterMark</code> specifies a total number of objects.</p>\n<p>Data is buffered in <code>Readable</code> streams when the implementation calls\n<a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>stream.push(chunk)</code></a>. If the consumer of the Stream does not\ncall <a href=\"stream.html#stream_readable_read_size\"><code>stream.read()</code></a>, the data will sit in the internal\nqueue until it is consumed.</p>\n<p>Once the total size of the internal read buffer reaches the threshold specified\nby <code>highWaterMark</code>, the stream will temporarily stop reading data from the\nunderlying resource until the data currently buffered can be consumed (that is,\nthe stream will stop calling the internal <a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> method that is\nused to fill the read buffer).</p>\n<p>Data is buffered in <code>Writable</code> streams when the\n<a href=\"stream.html#stream_writable_write_chunk_encoding_callback\"><code>writable.write(chunk)</code></a> method is called repeatedly. While the\ntotal size of the internal write buffer is below the threshold set by\n<code>highWaterMark</code>, calls to <code>writable.write()</code> will return <code>true</code>. Once\nthe size of the internal buffer reaches or exceeds the <code>highWaterMark</code>, <code>false</code>\nwill be returned.</p>\n<p>A key goal of the <code>stream</code> API, particularly the <a href=\"stream.html#stream_readable_pipe_destination_options\"><code>stream.pipe()</code></a> method,\nis to limit the buffering of data to acceptable levels such that sources and\ndestinations of differing speeds will not overwhelm the available memory.</p>\n<p>The <code>highWaterMark</code> option is a threshold, not a limit: it dictates the amount\nof data that a stream buffers before it stops asking for more data. It does not\nenforce a strict memory limitation in general. Specific stream implementations\nmay choose to enforce stricter limits but doing so is optional.</p>\n<p>Because <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> and <a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a> streams are both <code>Readable</code> and\n<code>Writable</code>, each maintains <em>two</em> separate internal buffers used for reading and\nwriting, allowing each side to operate independently of the other while\nmaintaining an appropriate and efficient flow of data. For example,\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> instances are <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> streams whose <code>Readable</code> side allows\nconsumption of data received <em>from</em> the socket and whose <code>Writable</code> side allows\nwriting data <em>to</em> the socket. Because data may be written to the socket at a\nfaster or slower rate than data is received, each side should\noperate (and buffer) independently of the other.</p>\n<p>The mechanics of the internal buffering are an internal implementation detail\nand may be changed at any time. However, for certain advanced implementations,\nthe internal buffers can be retrieved using <code>writable.writableBuffer</code> or\n<code>readable.readableBuffer</code>. Use of these undocumented properties is discouraged.</p>"
             }
           ],
           "type": "module",
@@ -47619,7 +52719,23 @@
             "added": [
               "v10.0.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32158",
+                "description": "The `finished(stream, cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+              },
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31545",
+                "description": "Emitting `'close'` before `'end'` on a `Readable` stream will cause an `ERR_STREAM_PREMATURE_CLOSE` error."
+              },
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31509",
+                "description": "Callback will be invoked on streams which have already finished before the call to `finished(stream, cb)`."
+              }
+            ]
           },
           "signatures": [
             {
@@ -47673,23 +52789,187 @@
           "desc": "<p>A function to get notified when a stream is no longer readable, writable\nor has experienced an error or a premature close event.</p>\n<pre><code class=\"language-js\">const { finished } = require('stream');\n\nconst rs = fs.createReadStream('archive.tar');\n\nfinished(rs, (err) => {\n  if (err) {\n    console.error('Stream failed.', err);\n  } else {\n    console.log('Stream is done reading.');\n  }\n});\n\nrs.resume(); // Drain the stream.\n</code></pre>\n<p>Especially useful in error handling scenarios where a stream is destroyed\nprematurely (like an aborted HTTP request), and will not emit <code>'end'</code>\nor <code>'finish'</code>.</p>\n<p>The <code>finished</code> API is promisify-able as well;</p>\n<pre><code class=\"language-js\">const finished = util.promisify(stream.finished);\n\nconst rs = fs.createReadStream('archive.tar');\n\nasync function run() {\n  await finished(rs);\n  console.log('Stream is done reading.');\n}\n\nrun().catch(console.error);\nrs.resume(); // Drain the stream.\n</code></pre>\n<p><code>stream.finished()</code> leaves dangling event listeners (in particular\n<code>'error'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code>) after <code>callback</code> has been\ninvoked. The reason for this is so that unexpected <code>'error'</code> events (due to\nincorrect stream implementations) do not cause unexpected crashes.\nIf this is unwanted behavior then the returned cleanup function needs to be\ninvoked in the callback:</p>\n<pre><code class=\"language-js\">const cleanup = finished(rs, (err) => {\n  cleanup();\n  // ...\n});\n</code></pre>"
         },
         {
-          "textRaw": "`stream.pipeline(...streams, callback)`",
+          "textRaw": "`stream.pipeline(source[, ...transforms], destination, callback)`",
           "type": "method",
           "name": "pipeline",
           "meta": {
             "added": [
               "v10.0.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32158",
+                "description": "The `pipeline(..., cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+              },
+              {
+                "version": "v13.10.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31223",
+                "description": "Add support for async generators."
+              }
+            ]
           },
           "signatures": [
             {
+              "return": {
+                "textRaw": "Returns: {Stream}",
+                "name": "return",
+                "type": "Stream"
+              },
               "params": [
                 {
-                  "textRaw": "`...streams` {Stream} Two or more streams to pipe between.",
-                  "name": "...streams",
-                  "type": "Stream",
-                  "desc": "Two or more streams to pipe between."
+                  "textRaw": "`streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}",
+                  "name": "streams",
+                  "type": "Stream[]|Iterable[]|AsyncIterable[]|Function[]"
+                },
+                {
+                  "textRaw": "`source` {Stream|Iterable|AsyncIterable|Function}",
+                  "name": "source",
+                  "type": "Stream|Iterable|AsyncIterable|Function",
+                  "options": [
+                    {
+                      "textRaw": "Returns: {Iterable|AsyncIterable}",
+                      "name": "return",
+                      "type": "Iterable|AsyncIterable"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`...transforms` {Stream|Function}",
+                  "name": "...transforms",
+                  "type": "Stream|Function",
+                  "options": [
+                    {
+                      "textRaw": "`source` {AsyncIterable}",
+                      "name": "source",
+                      "type": "AsyncIterable"
+                    },
+                    {
+                      "textRaw": "Returns: {AsyncIterable}",
+                      "name": "return",
+                      "type": "AsyncIterable"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`destination` {Stream|Function}",
+                  "name": "destination",
+                  "type": "Stream|Function",
+                  "options": [
+                    {
+                      "textRaw": "`source` {AsyncIterable}",
+                      "name": "source",
+                      "type": "AsyncIterable"
+                    },
+                    {
+                      "textRaw": "Returns: {AsyncIterable|Promise}",
+                      "name": "return",
+                      "type": "AsyncIterable|Promise"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`callback` {Function} Called when the pipeline is fully done.",
+                  "name": "callback",
+                  "type": "Function",
+                  "desc": "Called when the pipeline is fully done.",
+                  "options": [
+                    {
+                      "textRaw": "`err` {Error}",
+                      "name": "err",
+                      "type": "Error"
+                    },
+                    {
+                      "textRaw": "`val` Resolved value of `Promise` returned by `destination`.",
+                      "name": "val",
+                      "desc": "Resolved value of `Promise` returned by `destination`."
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p>A module method to pipe between streams and generators forwarding errors and\nproperly cleaning up and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p>The <code>pipeline</code> API also supports async generators:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\nconst fs = require('fs');\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('lowercase.txt'),\n    async function* (source) {\n      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.\n      for await (const chunk of source) {\n        yield chunk.toUpperCase();\n      }\n    },\n    fs.createWriteStream('uppercase.txt')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
+        },
+        {
+          "textRaw": "`stream.pipeline(streams, callback)`",
+          "type": "method",
+          "name": "pipeline",
+          "meta": {
+            "added": [
+              "v10.0.0"
+            ],
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32158",
+                "description": "The `pipeline(..., cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+              },
+              {
+                "version": "v13.10.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31223",
+                "description": "Add support for async generators."
+              }
+            ]
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {Stream}",
+                "name": "return",
+                "type": "Stream"
+              },
+              "params": [
+                {
+                  "textRaw": "`streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}",
+                  "name": "streams",
+                  "type": "Stream[]|Iterable[]|AsyncIterable[]|Function[]"
+                },
+                {
+                  "textRaw": "`source` {Stream|Iterable|AsyncIterable|Function}",
+                  "name": "source",
+                  "type": "Stream|Iterable|AsyncIterable|Function",
+                  "options": [
+                    {
+                      "textRaw": "Returns: {Iterable|AsyncIterable}",
+                      "name": "return",
+                      "type": "Iterable|AsyncIterable"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`...transforms` {Stream|Function}",
+                  "name": "...transforms",
+                  "type": "Stream|Function",
+                  "options": [
+                    {
+                      "textRaw": "`source` {AsyncIterable}",
+                      "name": "source",
+                      "type": "AsyncIterable"
+                    },
+                    {
+                      "textRaw": "Returns: {AsyncIterable}",
+                      "name": "return",
+                      "type": "AsyncIterable"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`destination` {Stream|Function}",
+                  "name": "destination",
+                  "type": "Stream|Function",
+                  "options": [
+                    {
+                      "textRaw": "`source` {AsyncIterable}",
+                      "name": "source",
+                      "type": "AsyncIterable"
+                    },
+                    {
+                      "textRaw": "Returns: {AsyncIterable|Promise}",
+                      "name": "return",
+                      "type": "AsyncIterable|Promise"
+                    }
+                  ]
                 },
                 {
                   "textRaw": "`callback` {Function} Called when the pipeline is fully done.",
@@ -47701,13 +52981,18 @@
                       "textRaw": "`err` {Error}",
                       "name": "err",
                       "type": "Error"
+                    },
+                    {
+                      "textRaw": "`val` Resolved value of `Promise` returned by `destination`.",
+                      "name": "val",
+                      "desc": "Resolved value of `Promise` returned by `destination`."
                     }
                   ]
                 }
               ]
             }
           ],
-          "desc": "<p>A module method to pipe between streams forwarding errors and properly cleaning\nup and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
+          "desc": "<p>A module method to pipe between streams and generators forwarding errors and\nproperly cleaning up and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p>The <code>pipeline</code> API also supports async generators:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\nconst fs = require('fs');\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('lowercase.txt'),\n    async function* (source) {\n      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.\n      for await (const chunk of source) {\n        yield chunk.toUpperCase();\n      }\n    },\n    fs.createWriteStream('uppercase.txt')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
         },
         {
           "textRaw": "`stream.Readable.from(iterable, [options])`",
@@ -47839,7 +53124,7 @@
                           "type": "Error"
                         }
                       ],
-                      "desc": "<p>The <code>'error'</code> event is emitted if an error occurred while writing or piping\ndata. The listener callback is passed a single <code>Error</code> argument when called.</p>\n<p>The stream is not closed when the <code>'error'</code> event is emitted unless the\n<a href=\"stream.html#stream_new_stream_writable_options\"><code>autoDestroy</code></a> option was set to <code>true</code> when creating the\nstream.</p>"
+                      "desc": "<p>The <code>'error'</code> event is emitted if an error occurred while writing or piping\ndata. The listener callback is passed a single <code>Error</code> argument when called.</p>\n<p>The stream is closed when the <code>'error'</code> event is emitted unless the\n<a href=\"stream.html#stream_new_stream_writable_options\"><code>autoDestroy</code></a> option was set to <code>false</code> when creating the\nstream.</p>\n<p>After <code>'error'</code>, no further events other than <code>'close'</code> <em>should</em> be emitted\n(including <code>'error'</code> events).</p>"
                     },
                     {
                       "textRaw": "Event: `'finish'`",
@@ -47921,7 +53206,13 @@
                         "added": [
                           "v8.0.0"
                         ],
-                        "changes": []
+                        "changes": [
+                          {
+                            "version": "v14.0.0",
+                            "pr-url": "https://github.com/nodejs/node/pull/29197",
+                            "description": "Work as a no-op on a stream that has already been destroyed."
+                          }
+                        ]
                       },
                       "signatures": [
                         {
@@ -47940,7 +53231,7 @@
                           ]
                         }
                       ],
-                      "desc": "<p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>\nevent (unless <code>emitClose</code> is set to <code>false</code>). After this call, the writable\nstream has ended and subsequent calls to <code>write()</code> or <code>end()</code> will result in\nan <code>ERR_STREAM_DESTROYED</code> error.\nThis is a destructive and immediate way to destroy a stream. Previous calls to\n<code>write()</code> may not have drained, and may trigger an <code>ERR_STREAM_DESTROYED</code> error.\nUse <code>end()</code> instead of destroy if data should flush before close, or wait for\nthe <code>'drain'</code> event before destroying the stream.\nImplementors should not override this method,\nbut instead implement <a href=\"stream.html#stream_writable_destroy_err_callback\"><code>writable._destroy()</code></a>.</p>"
+                      "desc": "<p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>\nevent (unless <code>emitClose</code> is set to <code>false</code>). After this call, the writable\nstream has ended and subsequent calls to <code>write()</code> or <code>end()</code> will result in\nan <code>ERR_STREAM_DESTROYED</code> error.\nThis is a destructive and immediate way to destroy a stream. Previous calls to\n<code>write()</code> may not have drained, and may trigger an <code>ERR_STREAM_DESTROYED</code> error.\nUse <code>end()</code> instead of destroy if data should flush before close, or wait for\nthe <code>'drain'</code> event before destroying the stream.</p>\n<pre><code class=\"language-cjs\">const { Writable } = require('stream');\n\nconst myStream = new Writable();\n\nconst fooErr = new Error('foo error');\nmyStream.destroy(fooErr);\nmyStream.on('error', (fooErr) => console.error(fooErr.message)); // foo error\n</code></pre>\n<pre><code class=\"language-cjs\">const { Writable } = require('stream');\n\nconst myStream = new Writable();\n\nmyStream.destroy();\nmyStream.on('error', function wontHappen() {});\n</code></pre>\n<pre><code class=\"language-cjs\">const { Writable } = require('stream');\n\nconst myStream = new Writable();\nmyStream.destroy();\n\nmyStream.write('foo', (error) => console.error(error.code));\n// ERR_STREAM_DESTROYED\n</code></pre>\n<p>Once <code>destroy()</code> has been called any further calls will be a no-op and no\nfurther errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>\n<p>Implementors should not override this method,\nbut instead implement <a href=\"stream.html#stream_writable_destroy_err_callback\"><code>writable._destroy()</code></a>.</p>"
                     },
                     {
                       "textRaw": "`writable.end([chunk[, encoding]][, callback])`",
@@ -47951,6 +53242,11 @@
                           "v0.9.4"
                         ],
                         "changes": [
+                          {
+                            "version": "v14.0.0",
+                            "pr-url": "https://github.com/nodejs/node/pull/29747",
+                            "description": "The `callback` is invoked if 'finish' or 'error' is emitted."
+                          },
                           {
                             "version": "v10.0.0",
                             "pr-url": "https://github.com/nodejs/node/pull/18780",
@@ -47984,15 +53280,15 @@
                               "desc": "The encoding if `chunk` is a string"
                             },
                             {
-                              "textRaw": "`callback` {Function} Optional callback for when the stream is finished",
+                              "textRaw": "`callback` {Function} Optional callback for when the stream finishes or errors",
                               "name": "callback",
                               "type": "Function",
-                              "desc": "Optional callback for when the stream is finished"
+                              "desc": "Optional callback for when the stream finishes or errors"
                             }
                           ]
                         }
                       ],
-                      "desc": "<p>Calling the <code>writable.end()</code> method signals that no more data will be written\nto the <a href=\"stream.html#stream_class_stream_writable\"><code>Writable</code></a>. The optional <code>chunk</code> and <code>encoding</code> arguments allow one\nfinal additional chunk of data to be written immediately before closing the\nstream. If provided, the optional <code>callback</code> function is attached as a listener\nfor the <a href=\"stream.html#stream_event_finish\"><code>'finish'</code></a> event.</p>\n<p>Calling the <a href=\"stream.html#stream_writable_write_chunk_encoding_callback\"><code>stream.write()</code></a> method after calling\n<a href=\"stream.html#stream_writable_end_chunk_encoding_callback\"><code>stream.end()</code></a> will raise an error.</p>\n<pre><code class=\"language-js\">// Write 'hello, ' and then end with 'world!'.\nconst fs = require('fs');\nconst file = fs.createWriteStream('example.txt');\nfile.write('hello, ');\nfile.end('world!');\n// Writing more now is not allowed!\n</code></pre>"
+                      "desc": "<p>Calling the <code>writable.end()</code> method signals that no more data will be written\nto the <a href=\"stream.html#stream_class_stream_writable\"><code>Writable</code></a>. The optional <code>chunk</code> and <code>encoding</code> arguments allow one\nfinal additional chunk of data to be written immediately before closing the\nstream. If provided, the optional <code>callback</code> function is attached as a listener\nfor the <a href=\"stream.html#stream_event_finish\"><code>'finish'</code></a> and the <code>'error'</code> event.</p>\n<p>Calling the <a href=\"stream.html#stream_writable_write_chunk_encoding_callback\"><code>stream.write()</code></a> method after calling\n<a href=\"stream.html#stream_writable_end_chunk_encoding_callback\"><code>stream.end()</code></a> will raise an error.</p>\n<pre><code class=\"language-js\">// Write 'hello, ' and then end with 'world!'.\nconst fs = require('fs');\nconst file = fs.createWriteStream('example.txt');\nfile.write('hello, ');\nfile.end('world!');\n// Writing more now is not allowed!\n</code></pre>"
                     },
                     {
                       "textRaw": "`writable.setDefaultEncoding(encoding)`",
@@ -48083,22 +53379,22 @@
                               "desc": "Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any JavaScript value other than `null`."
                             },
                             {
-                              "textRaw": "`encoding` {string} The encoding, if `chunk` is a string. **Default:** `'utf8'`",
+                              "textRaw": "`encoding` {string|null} The encoding, if `chunk` is a string. **Default:** `'utf8'`",
                               "name": "encoding",
-                              "type": "string",
+                              "type": "string|null",
                               "default": "`'utf8'`",
                               "desc": "The encoding, if `chunk` is a string."
                             },
                             {
-                              "textRaw": "`callback` {Function} Callback for when this chunk of data is flushed",
+                              "textRaw": "`callback` {Function} Callback for when this chunk of data is flushed.",
                               "name": "callback",
                               "type": "Function",
-                              "desc": "Callback for when this chunk of data is flushed"
+                              "desc": "Callback for when this chunk of data is flushed."
                             }
                           ]
                         }
                       ],
-                      "desc": "<p>The <code>writable.write()</code> method writes some data to the stream, and calls the\nsupplied <code>callback</code> once the data has been fully handled. If an error\noccurs, the <code>callback</code> <em>may or may not</em> be called with the error as its\nfirst argument. To reliably detect write errors, add a listener for the\n<code>'error'</code> event.</p>\n<p>The return value is <code>true</code> if the internal buffer is less than the\n<code>highWaterMark</code> configured when the stream was created after admitting <code>chunk</code>.\nIf <code>false</code> is returned, further attempts to write data to the stream should\nstop until the <a href=\"stream.html#stream_event_drain\"><code>'drain'</code></a> event is emitted.</p>\n<p>While a stream is not draining, calls to <code>write()</code> will buffer <code>chunk</code>, and\nreturn false. Once all currently buffered chunks are drained (accepted for\ndelivery by the operating system), the <code>'drain'</code> event will be emitted.\nIt is recommended that once <code>write()</code> returns false, no more chunks be written\nuntil the <code>'drain'</code> event is emitted. While calling <code>write()</code> on a stream that\nis not draining is allowed, Node.js will buffer all written chunks until\nmaximum memory usage occurs, at which point it will abort unconditionally.\nEven before it aborts, high memory usage will cause poor garbage collector\nperformance and high RSS (which is not typically released back to the system,\neven after the memory is no longer required). Since TCP sockets may never\ndrain if the remote peer does not read the data, writing a socket that is\nnot draining may lead to a remotely exploitable vulnerability.</p>\n<p>Writing data while the stream is not draining is particularly\nproblematic for a <a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a>, because the <code>Transform</code> streams are paused\nby default until they are piped or a <code>'data'</code> or <code>'readable'</code> event handler\nis added.</p>\n<p>If the data to be written can be generated or fetched on demand, it is\nrecommended to encapsulate the logic into a <a href=\"stream.html#stream_class_stream_readable\"><code>Readable</code></a> and use\n<a href=\"stream.html#stream_readable_pipe_destination_options\"><code>stream.pipe()</code></a>. However, if calling <code>write()</code> is preferred, it is\npossible to respect backpressure and avoid memory issues using the\n<a href=\"stream.html#stream_event_drain\"><code>'drain'</code></a> event:</p>\n<pre><code class=\"language-js\">function write(data, cb) {\n  if (!stream.write(data)) {\n    stream.once('drain', cb);\n  } else {\n    process.nextTick(cb);\n  }\n}\n\n// Wait for cb to be called before doing any other write.\nwrite('hello', () => {\n  console.log('Write completed, do more writes now.');\n});\n</code></pre>\n<p>A <code>Writable</code> stream in object mode will always ignore the <code>encoding</code> argument.</p>"
+                      "desc": "<p>The <code>writable.write()</code> method writes some data to the stream, and calls the\nsupplied <code>callback</code> once the data has been fully handled. If an error\noccurs, the <code>callback</code> <em>may or may not</em> be called with the error as its\nfirst argument. To reliably detect write errors, add a listener for the\n<code>'error'</code> event. The <code>callback</code> is called asynchronously and before <code>'error'</code> is\nemitted.</p>\n<p>The return value is <code>true</code> if the internal buffer is less than the\n<code>highWaterMark</code> configured when the stream was created after admitting <code>chunk</code>.\nIf <code>false</code> is returned, further attempts to write data to the stream should\nstop until the <a href=\"stream.html#stream_event_drain\"><code>'drain'</code></a> event is emitted.</p>\n<p>While a stream is not draining, calls to <code>write()</code> will buffer <code>chunk</code>, and\nreturn false. Once all currently buffered chunks are drained (accepted for\ndelivery by the operating system), the <code>'drain'</code> event will be emitted.\nIt is recommended that once <code>write()</code> returns false, no more chunks be written\nuntil the <code>'drain'</code> event is emitted. While calling <code>write()</code> on a stream that\nis not draining is allowed, Node.js will buffer all written chunks until\nmaximum memory usage occurs, at which point it will abort unconditionally.\nEven before it aborts, high memory usage will cause poor garbage collector\nperformance and high RSS (which is not typically released back to the system,\neven after the memory is no longer required). Since TCP sockets may never\ndrain if the remote peer does not read the data, writing a socket that is\nnot draining may lead to a remotely exploitable vulnerability.</p>\n<p>Writing data while the stream is not draining is particularly\nproblematic for a <a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a>, because the <code>Transform</code> streams are paused\nby default until they are piped or a <code>'data'</code> or <code>'readable'</code> event handler\nis added.</p>\n<p>If the data to be written can be generated or fetched on demand, it is\nrecommended to encapsulate the logic into a <a href=\"stream.html#stream_class_stream_readable\"><code>Readable</code></a> and use\n<a href=\"stream.html#stream_readable_pipe_destination_options\"><code>stream.pipe()</code></a>. However, if calling <code>write()</code> is preferred, it is\npossible to respect backpressure and avoid memory issues using the\n<a href=\"stream.html#stream_event_drain\"><code>'drain'</code></a> event:</p>\n<pre><code class=\"language-js\">function write(data, cb) {\n  if (!stream.write(data)) {\n    stream.once('drain', cb);\n  } else {\n    process.nextTick(cb);\n  }\n}\n\n// Wait for cb to be called before doing any other write.\nwrite('hello', () => {\n  console.log('Write completed, do more writes now.');\n});\n</code></pre>\n<p>A <code>Writable</code> stream in object mode will always ignore the <code>encoding</code> argument.</p>"
                     }
                   ],
                   "properties": [
@@ -48112,7 +53408,7 @@
                         ],
                         "changes": []
                       },
-                      "desc": "<p>Is <code>true</code> after <a href=\"stream.html#stream_writable_destroy_error\"><code>writable.destroy()</code></a> has been called.</p>"
+                      "desc": "<p>Is <code>true</code> after <a href=\"stream.html#stream_writable_destroy_error\"><code>writable.destroy()</code></a> has been called.</p>\n<pre><code class=\"language-cjs\">const { Writable } = require('stream');\n\nconst myStream = new Writable();\n\nconsole.log(myStream.destroyed); // false\nmyStream.destroy();\nconsole.log(myStream.destroyed); // true\n</code></pre>"
                     },
                     {
                       "textRaw": "`writable` {boolean}",
@@ -48124,7 +53420,7 @@
                         ],
                         "changes": []
                       },
-                      "desc": "<p>Is <code>true</code> if it is safe to call <a href=\"stream.html#stream_writable_write_chunk_encoding_callback\"><code>writable.write()</code></a>.</p>"
+                      "desc": "<p>Is <code>true</code> if it is safe to call <a href=\"stream.html#stream_writable_write_chunk_encoding_callback\"><code>writable.write()</code></a>, which means\nthe stream has not been destroyed, errored or ended.</p>"
                     },
                     {
                       "textRaw": "`writableEnded` {boolean}",
@@ -48144,6 +53440,7 @@
                       "name": "writableCorked",
                       "meta": {
                         "added": [
+                          "v13.2.0",
                           "v12.16.0"
                         ],
                         "changes": []
@@ -48186,6 +53483,18 @@
                       },
                       "desc": "<p>This property contains the number of bytes (or objects) in the queue\nready to be written. The value provides introspection data regarding\nthe status of the <code>highWaterMark</code>.</p>"
                     },
+                    {
+                      "textRaw": "`writableNeedDrain` {boolean}",
+                      "type": "boolean",
+                      "name": "writableNeedDrain",
+                      "meta": {
+                        "added": [
+                          "v14.17.0"
+                        ],
+                        "changes": []
+                      },
+                      "desc": "<p>Is <code>true</code> if the stream's buffer has been full and stream will emit <code>'drain'</code>.</p>"
+                    },
                     {
                       "textRaw": "`writableObjectMode` {boolean}",
                       "type": "boolean",
@@ -48373,7 +53682,13 @@
                         "added": [
                           "v8.0.0"
                         ],
-                        "changes": []
+                        "changes": [
+                          {
+                            "version": "v14.0.0",
+                            "pr-url": "https://github.com/nodejs/node/pull/29197",
+                            "description": "Work as a no-op on a stream that has already been destroyed."
+                          }
+                        ]
                       },
                       "signatures": [
                         {
@@ -48392,7 +53707,7 @@
                           ]
                         }
                       ],
-                      "desc": "<p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>\nevent (unless <code>emitClose</code> is set to <code>false</code>). After this call, the readable\nstream will release any internal resources and subsequent calls to <code>push()</code>\nwill be ignored.\nImplementors should not override this method, but instead implement\n<a href=\"stream.html#stream_readable_destroy_err_callback\"><code>readable._destroy()</code></a>.</p>"
+                      "desc": "<p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>\nevent (unless <code>emitClose</code> is set to <code>false</code>). After this call, the readable\nstream will release any internal resources and subsequent calls to <code>push()</code>\nwill be ignored.</p>\n<p>Once <code>destroy()</code> has been called any further calls will be a no-op and no\nfurther errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>\n<p>Implementors should not override this method, but instead implement\n<a href=\"stream.html#stream_readable_destroy_err_callback\"><code>readable._destroy()</code></a>.</p>"
                     },
                     {
                       "textRaw": "`readable.isPaused()`",
@@ -48510,7 +53825,7 @@
                           ]
                         }
                       ],
-                      "desc": "<p>The <code>readable.read()</code> method pulls some data out of the internal buffer and\nreturns it. If no data available to be read, <code>null</code> is returned. By default,\nthe data will be returned as a <code>Buffer</code> object unless an encoding has been\nspecified using the <code>readable.setEncoding()</code> method or the stream is operating\nin object mode.</p>\n<p>The optional <code>size</code> argument specifies a specific number of bytes to read. If\n<code>size</code> bytes are not available to be read, <code>null</code> will be returned <em>unless</em>\nthe stream has ended, in which case all of the data remaining in the internal\nbuffer will be returned.</p>\n<p>If the <code>size</code> argument is not specified, all of the data contained in the\ninternal buffer will be returned.</p>\n<p>The <code>size</code> argument must be less than or equal to 1 GB.</p>\n<p>The <code>readable.read()</code> method should only be called on <code>Readable</code> streams\noperating in paused mode. In flowing mode, <code>readable.read()</code> is called\nautomatically until the internal buffer is fully drained.</p>\n<pre><code class=\"language-js\">const readable = getReadableStreamSomehow();\n\n// 'readable' may be triggered multiple times as data is buffered in\nreadable.on('readable', () => {\n  let chunk;\n  console.log('Stream is readable (new data received in buffer)');\n  // Use a loop to make sure we read all currently available data\n  while (null !== (chunk = readable.read())) {\n    console.log(`Read ${chunk.length} bytes of data...`);\n  }\n});\n\n// 'end' will be triggered once when there is no more data available\nreadable.on('end', () => {\n  console.log('Reached end of stream.');\n});\n</code></pre>\n<p>Each call to <code>readable.read()</code> returns a chunk of data, or <code>null</code>. The chunks\nare not concatenated. A <code>while</code> loop is necessary to consume all data\ncurrently in the buffer. When reading a large file <code>.read()</code> may return <code>null</code>,\nhaving consumed all buffered content so far, but there is still more data to\ncome not yet buffered. In this case a new <code>'readable'</code> event will be emitted\nwhen there is more data in the buffer. Finally the <code>'end'</code> event will be\nemitted when there is no more data to come.</p>\n<p>Therefore to read a file's whole contents from a <code>readable</code>, it is necessary\nto collect chunks across multiple <code>'readable'</code> events:</p>\n<pre><code class=\"language-js\">const chunks = [];\n\nreadable.on('readable', () => {\n  let chunk;\n  while (null !== (chunk = readable.read())) {\n    chunks.push(chunk);\n  }\n});\n\nreadable.on('end', () => {\n  const content = chunks.join('');\n});\n</code></pre>\n<p>A <code>Readable</code> stream in object mode will always return a single item from\na call to <a href=\"stream.html#stream_readable_read_size\"><code>readable.read(size)</code></a>, regardless of the value of the\n<code>size</code> argument.</p>\n<p>If the <code>readable.read()</code> method returns a chunk of data, a <code>'data'</code> event will\nalso be emitted.</p>\n<p>Calling <a href=\"stream.html#stream_readable_read_size\"><code>stream.read([size])</code></a> after the <a href=\"stream.html#stream_event_end\"><code>'end'</code></a> event has\nbeen emitted will return <code>null</code>. No runtime error will be raised.</p>"
+                      "desc": "<p>The <code>readable.read()</code> method pulls some data out of the internal buffer and\nreturns it. If no data available to be read, <code>null</code> is returned. By default,\nthe data will be returned as a <code>Buffer</code> object unless an encoding has been\nspecified using the <code>readable.setEncoding()</code> method or the stream is operating\nin object mode.</p>\n<p>The optional <code>size</code> argument specifies a specific number of bytes to read. If\n<code>size</code> bytes are not available to be read, <code>null</code> will be returned <em>unless</em>\nthe stream has ended, in which case all of the data remaining in the internal\nbuffer will be returned.</p>\n<p>If the <code>size</code> argument is not specified, all of the data contained in the\ninternal buffer will be returned.</p>\n<p>The <code>size</code> argument must be less than or equal to 1 GiB.</p>\n<p>The <code>readable.read()</code> method should only be called on <code>Readable</code> streams\noperating in paused mode. In flowing mode, <code>readable.read()</code> is called\nautomatically until the internal buffer is fully drained.</p>\n<pre><code class=\"language-js\">const readable = getReadableStreamSomehow();\n\n// 'readable' may be triggered multiple times as data is buffered in\nreadable.on('readable', () => {\n  let chunk;\n  console.log('Stream is readable (new data received in buffer)');\n  // Use a loop to make sure we read all currently available data\n  while (null !== (chunk = readable.read())) {\n    console.log(`Read ${chunk.length} bytes of data...`);\n  }\n});\n\n// 'end' will be triggered once when there is no more data available\nreadable.on('end', () => {\n  console.log('Reached end of stream.');\n});\n</code></pre>\n<p>Each call to <code>readable.read()</code> returns a chunk of data, or <code>null</code>. The chunks\nare not concatenated. A <code>while</code> loop is necessary to consume all data\ncurrently in the buffer. When reading a large file <code>.read()</code> may return <code>null</code>,\nhaving consumed all buffered content so far, but there is still more data to\ncome not yet buffered. In this case a new <code>'readable'</code> event will be emitted\nwhen there is more data in the buffer. Finally the <code>'end'</code> event will be\nemitted when there is no more data to come.</p>\n<p>Therefore to read a file's whole contents from a <code>readable</code>, it is necessary\nto collect chunks across multiple <code>'readable'</code> events:</p>\n<pre><code class=\"language-js\">const chunks = [];\n\nreadable.on('readable', () => {\n  let chunk;\n  while (null !== (chunk = readable.read())) {\n    chunks.push(chunk);\n  }\n});\n\nreadable.on('end', () => {\n  const content = chunks.join('');\n});\n</code></pre>\n<p>A <code>Readable</code> stream in object mode will always return a single item from\na call to <a href=\"stream.html#stream_readable_read_size\"><code>readable.read(size)</code></a>, regardless of the value of the\n<code>size</code> argument.</p>\n<p>If the <code>readable.read()</code> method returns a chunk of data, a <code>'data'</code> event will\nalso be emitted.</p>\n<p>Calling <a href=\"stream.html#stream_readable_read_size\"><code>stream.read([size])</code></a> after the <a href=\"stream.html#stream_event_end\"><code>'end'</code></a> event has\nbeen emitted will return <code>null</code>. No runtime error will be raised.</p>"
                     },
                     {
                       "textRaw": "`readable.resume()`",
@@ -48716,7 +54031,19 @@
                         ],
                         "changes": []
                       },
-                      "desc": "<p>Is <code>true</code> if it is safe to call <a href=\"stream.html#stream_readable_read_size\"><code>readable.read()</code></a>.</p>"
+                      "desc": "<p>Is <code>true</code> if it is safe to call <a href=\"stream.html#stream_readable_read_size\"><code>readable.read()</code></a>, which means\nthe stream has not been destroyed or emitted <code>'error'</code> or <code>'end'</code>.</p>"
+                    },
+                    {
+                      "textRaw": "`readableDidRead` {boolean}",
+                      "type": "boolean",
+                      "name": "readableDidRead",
+                      "meta": {
+                        "added": [
+                          "v14.18.0"
+                        ],
+                        "changes": []
+                      },
+                      "desc": "<p>Allows determining if the stream has been or is about to be read.\nReturns true if <code>'data'</code>, <code>'end'</code>, <code>'error'</code> or <code>'close'</code> has been\nemitted.</p>"
                     },
                     {
                       "textRaw": "`readableEncoding` {null|string}",
@@ -48838,7 +54165,13 @@
                         "added": [
                           "v8.0.0"
                         ],
-                        "changes": []
+                        "changes": [
+                          {
+                            "version": "v14.0.0",
+                            "pr-url": "https://github.com/nodejs/node/pull/29197",
+                            "description": "Work as a no-op on a stream that has already been destroyed."
+                          }
+                        ]
                       },
                       "signatures": [
                         {
@@ -48856,7 +54189,7 @@
                           ]
                         }
                       ],
-                      "desc": "<p>Destroy the stream, and optionally emit an <code>'error'</code> event. After this call, the\ntransform stream would release any internal resources.\nImplementors should not override this method, but instead implement\n<a href=\"stream.html#stream_readable_destroy_err_callback\"><code>readable._destroy()</code></a>.\nThe default implementation of <code>_destroy()</code> for <code>Transform</code> also emit <code>'close'</code>\nunless <code>emitClose</code> is set in false.</p>"
+                      "desc": "<p>Destroy the stream, and optionally emit an <code>'error'</code> event. After this call, the\ntransform stream would release any internal resources.\nImplementors should not override this method, but instead implement\n<a href=\"stream.html#stream_readable_destroy_err_callback\"><code>readable._destroy()</code></a>.\nThe default implementation of <code>_destroy()</code> for <code>Transform</code> also emit <code>'close'</code>\nunless <code>emitClose</code> is set in false.</p>\n<p>Once <code>destroy()</code> has been called, any further calls will be a no-op and no\nfurther errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>"
                     }
                   ]
                 }
@@ -48874,7 +54207,23 @@
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32158",
+                    "description": "The `finished(stream, cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31545",
+                    "description": "Emitting `'close'` before `'end'` on a `Readable` stream will cause an `ERR_STREAM_PREMATURE_CLOSE` error."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31509",
+                    "description": "Callback will be invoked on streams which have already finished before the call to `finished(stream, cb)`."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -48928,23 +54277,84 @@
               "desc": "<p>A function to get notified when a stream is no longer readable, writable\nor has experienced an error or a premature close event.</p>\n<pre><code class=\"language-js\">const { finished } = require('stream');\n\nconst rs = fs.createReadStream('archive.tar');\n\nfinished(rs, (err) => {\n  if (err) {\n    console.error('Stream failed.', err);\n  } else {\n    console.log('Stream is done reading.');\n  }\n});\n\nrs.resume(); // Drain the stream.\n</code></pre>\n<p>Especially useful in error handling scenarios where a stream is destroyed\nprematurely (like an aborted HTTP request), and will not emit <code>'end'</code>\nor <code>'finish'</code>.</p>\n<p>The <code>finished</code> API is promisify-able as well;</p>\n<pre><code class=\"language-js\">const finished = util.promisify(stream.finished);\n\nconst rs = fs.createReadStream('archive.tar');\n\nasync function run() {\n  await finished(rs);\n  console.log('Stream is done reading.');\n}\n\nrun().catch(console.error);\nrs.resume(); // Drain the stream.\n</code></pre>\n<p><code>stream.finished()</code> leaves dangling event listeners (in particular\n<code>'error'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code>) after <code>callback</code> has been\ninvoked. The reason for this is so that unexpected <code>'error'</code> events (due to\nincorrect stream implementations) do not cause unexpected crashes.\nIf this is unwanted behavior then the returned cleanup function needs to be\ninvoked in the callback:</p>\n<pre><code class=\"language-js\">const cleanup = finished(rs, (err) => {\n  cleanup();\n  // ...\n});\n</code></pre>"
             },
             {
-              "textRaw": "`stream.pipeline(...streams, callback)`",
+              "textRaw": "`stream.pipeline(source[, ...transforms], destination, callback)`",
               "type": "method",
               "name": "pipeline",
               "meta": {
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32158",
+                    "description": "The `pipeline(..., cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+                  },
+                  {
+                    "version": "v13.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31223",
+                    "description": "Add support for async generators."
+                  }
+                ]
               },
               "signatures": [
                 {
+                  "return": {
+                    "textRaw": "Returns: {Stream}",
+                    "name": "return",
+                    "type": "Stream"
+                  },
                   "params": [
                     {
-                      "textRaw": "`...streams` {Stream} Two or more streams to pipe between.",
-                      "name": "...streams",
-                      "type": "Stream",
-                      "desc": "Two or more streams to pipe between."
+                      "textRaw": "`streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}",
+                      "name": "streams",
+                      "type": "Stream[]|Iterable[]|AsyncIterable[]|Function[]"
+                    },
+                    {
+                      "textRaw": "`source` {Stream|Iterable|AsyncIterable|Function}",
+                      "name": "source",
+                      "type": "Stream|Iterable|AsyncIterable|Function",
+                      "options": [
+                        {
+                          "textRaw": "Returns: {Iterable|AsyncIterable}",
+                          "name": "return",
+                          "type": "Iterable|AsyncIterable"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`...transforms` {Stream|Function}",
+                      "name": "...transforms",
+                      "type": "Stream|Function",
+                      "options": [
+                        {
+                          "textRaw": "`source` {AsyncIterable}",
+                          "name": "source",
+                          "type": "AsyncIterable"
+                        },
+                        {
+                          "textRaw": "Returns: {AsyncIterable}",
+                          "name": "return",
+                          "type": "AsyncIterable"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`destination` {Stream|Function}",
+                      "name": "destination",
+                      "type": "Stream|Function",
+                      "options": [
+                        {
+                          "textRaw": "`source` {AsyncIterable}",
+                          "name": "source",
+                          "type": "AsyncIterable"
+                        },
+                        {
+                          "textRaw": "Returns: {AsyncIterable|Promise}",
+                          "name": "return",
+                          "type": "AsyncIterable|Promise"
+                        }
+                      ]
                     },
                     {
                       "textRaw": "`callback` {Function} Called when the pipeline is fully done.",
@@ -48956,13 +54366,121 @@
                           "textRaw": "`err` {Error}",
                           "name": "err",
                           "type": "Error"
+                        },
+                        {
+                          "textRaw": "`val` Resolved value of `Promise` returned by `destination`.",
+                          "name": "val",
+                          "desc": "Resolved value of `Promise` returned by `destination`."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>A module method to pipe between streams forwarding errors and properly cleaning\nup and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
+              "desc": "<p>A module method to pipe between streams and generators forwarding errors and\nproperly cleaning up and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p>The <code>pipeline</code> API also supports async generators:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\nconst fs = require('fs');\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('lowercase.txt'),\n    async function* (source) {\n      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.\n      for await (const chunk of source) {\n        yield chunk.toUpperCase();\n      }\n    },\n    fs.createWriteStream('uppercase.txt')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
+            },
+            {
+              "textRaw": "`stream.pipeline(streams, callback)`",
+              "type": "method",
+              "name": "pipeline",
+              "meta": {
+                "added": [
+                  "v10.0.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32158",
+                    "description": "The `pipeline(..., cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+                  },
+                  {
+                    "version": "v13.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31223",
+                    "description": "Add support for async generators."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Stream}",
+                    "name": "return",
+                    "type": "Stream"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}",
+                      "name": "streams",
+                      "type": "Stream[]|Iterable[]|AsyncIterable[]|Function[]"
+                    },
+                    {
+                      "textRaw": "`source` {Stream|Iterable|AsyncIterable|Function}",
+                      "name": "source",
+                      "type": "Stream|Iterable|AsyncIterable|Function",
+                      "options": [
+                        {
+                          "textRaw": "Returns: {Iterable|AsyncIterable}",
+                          "name": "return",
+                          "type": "Iterable|AsyncIterable"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`...transforms` {Stream|Function}",
+                      "name": "...transforms",
+                      "type": "Stream|Function",
+                      "options": [
+                        {
+                          "textRaw": "`source` {AsyncIterable}",
+                          "name": "source",
+                          "type": "AsyncIterable"
+                        },
+                        {
+                          "textRaw": "Returns: {AsyncIterable}",
+                          "name": "return",
+                          "type": "AsyncIterable"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`destination` {Stream|Function}",
+                      "name": "destination",
+                      "type": "Stream|Function",
+                      "options": [
+                        {
+                          "textRaw": "`source` {AsyncIterable}",
+                          "name": "source",
+                          "type": "AsyncIterable"
+                        },
+                        {
+                          "textRaw": "Returns: {AsyncIterable|Promise}",
+                          "name": "return",
+                          "type": "AsyncIterable|Promise"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function} Called when the pipeline is fully done.",
+                      "name": "callback",
+                      "type": "Function",
+                      "desc": "Called when the pipeline is fully done.",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`val` Resolved value of `Promise` returned by `destination`.",
+                          "name": "val",
+                          "desc": "Resolved value of `Promise` returned by `destination`."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>A module method to pipe between streams and generators forwarding errors and\nproperly cleaning up and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p>The <code>pipeline</code> API also supports async generators:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\nconst fs = require('fs');\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('lowercase.txt'),\n    async function* (source) {\n      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.\n      for await (const chunk of source) {\n        yield chunk.toUpperCase();\n      }\n    },\n    fs.createWriteStream('uppercase.txt')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
             },
             {
               "textRaw": "`stream.Readable.from(iterable, [options])`",
@@ -49006,7 +54524,7 @@
           "textRaw": "API for stream implementers",
           "name": "API for stream implementers",
           "type": "misc",
-          "desc": "<p>The <code>stream</code> module API has been designed to make it possible to easily\nimplement streams using JavaScript's prototypal inheritance model.</p>\n<p>First, a stream developer would declare a new JavaScript class that extends one\nof the four basic stream classes (<code>stream.Writable</code>, <code>stream.Readable</code>,\n<code>stream.Duplex</code>, or <code>stream.Transform</code>), making sure they call the appropriate\nparent class constructor:</p>\n<!-- eslint-disable no-useless-constructor -->\n<pre><code class=\"language-js\">const { Writable } = require('stream');\n\nclass MyWritable extends Writable {\n  constructor({ highWaterMark, ...options }) {\n    super({\n      highWaterMark,\n      autoDestroy: true,\n      emitClose: true\n    });\n    // ...\n  }\n}\n</code></pre>\n<p>When extending streams, keep in mind what options the user\ncan and should provide before forwarding these to the base constructor. For\nexample, if the implementation makes assumptions in regard to the\n<code>autoDestroy</code> and <code>emitClose</code> options, do not allow the\nuser to override these. Be explicit about what\noptions are forwarded instead of implicitly forwarding all options.</p>\n<p>The new stream class must then implement one or more specific methods, depending\non the type of stream being created, as detailed in the chart below:</p>\n<table>\n<thead>\n<tr>\n<th>Use-case</th>\n<th>Class</th>\n<th>Method(s) to implement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Reading only</td>\n<td><a href=\"stream.html#stream_class_stream_readable\"><code>Readable</code></a></td>\n<td><a href=\"stream.html#stream_readable_read_size_1\"><code>_read()</code></a></td>\n</tr>\n<tr>\n<td>Writing only</td>\n<td><a href=\"stream.html#stream_class_stream_writable\"><code>Writable</code></a></td>\n<td><a href=\"stream.html#stream_writable_write_chunk_encoding_callback_1\"><code>_write()</code></a>, <a href=\"stream.html#stream_writable_writev_chunks_callback\"><code>_writev()</code></a>, <a href=\"stream.html#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n<tr>\n<td>Reading and writing</td>\n<td><a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a></td>\n<td><a href=\"stream.html#stream_readable_read_size_1\"><code>_read()</code></a>, <a href=\"stream.html#stream_writable_write_chunk_encoding_callback_1\"><code>_write()</code></a>, <a href=\"stream.html#stream_writable_writev_chunks_callback\"><code>_writev()</code></a>, <a href=\"stream.html#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n<tr>\n<td>Operate on written data, then read the result</td>\n<td><a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a></td>\n<td><a href=\"stream.html#stream_transform_transform_chunk_encoding_callback\"><code>_transform()</code></a>, <a href=\"stream.html#stream_transform_flush_callback\"><code>_flush()</code></a>, <a href=\"stream.html#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>The implementation code for a stream should <em>never</em> call the \"public\" methods\nof a stream that are intended for use by consumers (as described in the\n<a href=\"stream.html#stream_api_for_stream_consumers\">API for stream consumers</a> section). Doing so may lead to adverse side effects\nin application code consuming the stream.</p>\n<p>Avoid overriding public methods such as <code>write()</code>, <code>end()</code>, <code>cork()</code>,\n<code>uncork()</code>, <code>read()</code> and <code>destroy()</code>, or emitting internal events such\nas <code>'error'</code>, <code>'data'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code> through <code>.emit()</code>.\nDoing so can break current and future stream invariants leading to behavior\nand/or compatibility issues with other streams, stream utilities, and user\nexpectations.</p>",
+          "desc": "<p>The <code>stream</code> module API has been designed to make it possible to easily\nimplement streams using JavaScript's prototypal inheritance model.</p>\n<p>First, a stream developer would declare a new JavaScript class that extends one\nof the four basic stream classes (<code>stream.Writable</code>, <code>stream.Readable</code>,\n<code>stream.Duplex</code>, or <code>stream.Transform</code>), making sure they call the appropriate\nparent class constructor:</p>\n<!-- eslint-disable no-useless-constructor -->\n<pre><code class=\"language-js\">const { Writable } = require('stream');\n\nclass MyWritable extends Writable {\n  constructor({ highWaterMark, ...options }) {\n    super({ highWaterMark });\n    // ...\n  }\n}\n</code></pre>\n<p>When extending streams, keep in mind what options the user\ncan and should provide before forwarding these to the base constructor. For\nexample, if the implementation makes assumptions in regard to the\n<code>autoDestroy</code> and <code>emitClose</code> options, do not allow the\nuser to override these. Be explicit about what\noptions are forwarded instead of implicitly forwarding all options.</p>\n<p>The new stream class must then implement one or more specific methods, depending\non the type of stream being created, as detailed in the chart below:</p>\n<table>\n<thead>\n<tr>\n<th>Use-case</th>\n<th>Class</th>\n<th>Method(s) to implement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Reading only</td>\n<td><a href=\"stream.html#stream_class_stream_readable\"><code>Readable</code></a></td>\n<td><a href=\"stream.html#stream_readable_read_size_1\"><code>_read()</code></a></td>\n</tr>\n<tr>\n<td>Writing only</td>\n<td><a href=\"stream.html#stream_class_stream_writable\"><code>Writable</code></a></td>\n<td><a href=\"stream.html#stream_writable_write_chunk_encoding_callback_1\"><code>_write()</code></a>, <a href=\"stream.html#stream_writable_writev_chunks_callback\"><code>_writev()</code></a>, <a href=\"stream.html#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n<tr>\n<td>Reading and writing</td>\n<td><a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a></td>\n<td><a href=\"stream.html#stream_readable_read_size_1\"><code>_read()</code></a>, <a href=\"stream.html#stream_writable_write_chunk_encoding_callback_1\"><code>_write()</code></a>, <a href=\"stream.html#stream_writable_writev_chunks_callback\"><code>_writev()</code></a>, <a href=\"stream.html#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n<tr>\n<td>Operate on written data, then read the result</td>\n<td><a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a></td>\n<td><a href=\"stream.html#stream_transform_transform_chunk_encoding_callback\"><code>_transform()</code></a>, <a href=\"stream.html#stream_transform_flush_callback\"><code>_flush()</code></a>, <a href=\"stream.html#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>The implementation code for a stream should <em>never</em> call the \"public\" methods\nof a stream that are intended for use by consumers (as described in the\n<a href=\"stream.html#stream_api_for_stream_consumers\">API for stream consumers</a> section). Doing so may lead to adverse side effects\nin application code consuming the stream.</p>\n<p>Avoid overriding public methods such as <code>write()</code>, <code>end()</code>, <code>cork()</code>,\n<code>uncork()</code>, <code>read()</code> and <code>destroy()</code>, or emitting internal events such\nas <code>'error'</code>, <code>'data'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code> through <code>.emit()</code>.\nDoing so can break current and future stream invariants leading to behavior\nand/or compatibility issues with other streams, stream utilities, and user\nexpectations.</p>",
           "miscs": [
             {
               "textRaw": "Simplified construction",
@@ -49033,14 +54551,22 @@
                   "meta": {
                     "changes": [
                       {
-                        "version": "v10.0.0",
-                        "pr-url": "https://github.com/nodejs/node/pull/18438",
-                        "description": "Add `emitClose` option to specify if `'close'` is emitted on destroy."
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/30623",
+                        "description": "Change `autoDestroy` option default to `true`."
                       },
                       {
-                        "version": "v11.2.0",
+                        "version": [
+                          "v11.2.0",
+                          "v10.16.0"
+                        ],
                         "pr-url": "https://github.com/nodejs/node/pull/22795",
                         "description": "Add `autoDestroy` option to automatically `destroy()` the stream when it emits `'finish'` or errors."
+                      },
+                      {
+                        "version": "v10.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/18438",
+                        "description": "Add `emitClose` option to specify if `'close'` is emitted on destroy."
                       }
                     ]
                   },
@@ -49112,10 +54638,10 @@
                               "desc": "Implementation for the [`stream._final()`][stream-_final] method."
                             },
                             {
-                              "textRaw": "`autoDestroy` {boolean} Whether this stream should automatically call `.destroy()` on itself after ending. **Default:** `false`.",
+                              "textRaw": "`autoDestroy` {boolean} Whether this stream should automatically call `.destroy()` on itself after ending. **Default:** `true`.",
                               "name": "autoDestroy",
                               "type": "boolean",
-                              "default": "`false`",
+                              "default": "`true`",
                               "desc": "Whether this stream should automatically call `.destroy()` on itself after ending."
                             }
                           ]
@@ -49164,7 +54690,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>All <code>Writable</code> stream implementations must provide a\n<a href=\"stream.html#stream_writable_write_chunk_encoding_callback_1\"><code>writable._write()</code></a> and/or\n<a href=\"stream.html#stream_writable_writev_chunks_callback\"><code>writable._writev()</code></a> method to send data to the underlying\nresource.</p>\n<p><a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a> streams provide their own implementation of the\n<a href=\"stream.html#stream_writable_write_chunk_encoding_callback_1\"><code>writable._write()</code></a>.</p>\n<p>This function MUST NOT be called by application code directly. It should be\nimplemented by child classes, and called by the internal <code>Writable</code> class\nmethods only.</p>\n<p>The <code>callback</code> method must be called to signal either that the write completed\nsuccessfully or failed with an error. The first argument passed to the\n<code>callback</code> must be the <code>Error</code> object if the call failed or <code>null</code> if the\nwrite succeeded.</p>\n<p>All calls to <code>writable.write()</code> that occur between the time <code>writable._write()</code>\nis called and the <code>callback</code> is called will cause the written data to be\nbuffered. When the <code>callback</code> is invoked, the stream might emit a <a href=\"stream.html#stream_event_drain\"><code>'drain'</code></a>\nevent. If a stream implementation is capable of processing multiple chunks of\ndata at once, the <code>writable._writev()</code> method should be implemented.</p>\n<p>If the <code>decodeStrings</code> property is explicitly set to <code>false</code> in the constructor\noptions, then <code>chunk</code> will remain the same object that is passed to <code>.write()</code>,\nand may be a string rather than a <code>Buffer</code>. This is to support implementations\nthat have an optimized handling for certain string data encodings. In that case,\nthe <code>encoding</code> argument will indicate the character encoding of the string.\nOtherwise, the <code>encoding</code> argument can be safely ignored.</p>\n<p>The <code>writable._write()</code> method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.</p>"
+                  "desc": "<p>All <code>Writable</code> stream implementations must provide a\n<a href=\"stream.html#stream_writable_write_chunk_encoding_callback_1\"><code>writable._write()</code></a> and/or\n<a href=\"stream.html#stream_writable_writev_chunks_callback\"><code>writable._writev()</code></a> method to send data to the underlying\nresource.</p>\n<p><a href=\"stream.html#stream_class_stream_transform\"><code>Transform</code></a> streams provide their own implementation of the\n<a href=\"stream.html#stream_writable_write_chunk_encoding_callback_1\"><code>writable._write()</code></a>.</p>\n<p>This function MUST NOT be called by application code directly. It should be\nimplemented by child classes, and called by the internal <code>Writable</code> class\nmethods only.</p>\n<p>The <code>callback</code> function must be called synchronously inside of\n<code>writable._write()</code> or asynchronously (i.e. different tick) to signal either\nthat the write completed successfully or failed with an error.\nThe first argument passed to the <code>callback</code> must be the <code>Error</code> object if the\ncall failed or <code>null</code> if the write succeeded.</p>\n<p>All calls to <code>writable.write()</code> that occur between the time <code>writable._write()</code>\nis called and the <code>callback</code> is called will cause the written data to be\nbuffered. When the <code>callback</code> is invoked, the stream might emit a <a href=\"stream.html#stream_event_drain\"><code>'drain'</code></a>\nevent. If a stream implementation is capable of processing multiple chunks of\ndata at once, the <code>writable._writev()</code> method should be implemented.</p>\n<p>If the <code>decodeStrings</code> property is explicitly set to <code>false</code> in the constructor\noptions, then <code>chunk</code> will remain the same object that is passed to <code>.write()</code>,\nand may be a string rather than a <code>Buffer</code>. This is to support implementations\nthat have an optimized handling for certain string data encodings. In that case,\nthe <code>encoding</code> argument will indicate the character encoding of the string.\nOtherwise, the <code>encoding</code> argument can be safely ignored.</p>\n<p>The <code>writable._write()</code> method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.</p>"
                 },
                 {
                   "textRaw": "`writable._writev(chunks, callback)`",
@@ -49174,10 +54700,24 @@
                     {
                       "params": [
                         {
-                          "textRaw": "`chunks` {Object[]} The chunks to be written. Each chunk has following format: `{ chunk: ..., encoding: ... }`.",
+                          "textRaw": "`chunks` {Object[]} The data to be written. The value is an array of {Object} that each represent a discrete chunk of data to write. The properties of these objects are:",
                           "name": "chunks",
                           "type": "Object[]",
-                          "desc": "The chunks to be written. Each chunk has following format: `{ chunk: ..., encoding: ... }`."
+                          "desc": "The data to be written. The value is an array of {Object} that each represent a discrete chunk of data to write. The properties of these objects are:",
+                          "options": [
+                            {
+                              "textRaw": "`chunk` {Buffer|string} A buffer instance or string containing the data to be written. The `chunk` will be a string if the `Writable` was created with the `decodeStrings` option set to `false` and a string was passed to `write()`.",
+                              "name": "chunk",
+                              "type": "Buffer|string",
+                              "desc": "A buffer instance or string containing the data to be written. The `chunk` will be a string if the `Writable` was created with the `decodeStrings` option set to `false` and a string was passed to `write()`."
+                            },
+                            {
+                              "textRaw": "`encoding` {string} The character encoding of the `chunk`. If `chunk` is a `Buffer`, the `encoding` will be `'buffer'`.",
+                              "name": "encoding",
+                              "type": "string",
+                              "desc": "The character encoding of the `chunk`. If `chunk` is a `Buffer`, the `encoding` will be `'buffer'`."
+                            }
+                          ]
                         },
                         {
                           "textRaw": "`callback` {Function} A callback function (optionally with an error argument) to be invoked when processing is complete for the supplied chunks.",
@@ -49283,7 +54823,15 @@
                   "meta": {
                     "changes": [
                       {
-                        "version": "v11.2.0",
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/30623",
+                        "description": "Change `autoDestroy` option default to `true`."
+                      },
+                      {
+                        "version": [
+                          "v11.2.0",
+                          "v10.16.0"
+                        ],
                         "pr-url": "https://github.com/nodejs/node/pull/22795",
                         "description": "Add `autoDestroy` option to automatically `destroy()` the stream when it emits `'end'` or errors."
                       }
@@ -49338,10 +54886,10 @@
                               "desc": "Implementation for the [`stream._destroy()`][readable-_destroy] method."
                             },
                             {
-                              "textRaw": "`autoDestroy` {boolean} Whether this stream should automatically call `.destroy()` on itself after ending. **Default:** `false`.",
+                              "textRaw": "`autoDestroy` {boolean} Whether this stream should automatically call `.destroy()` on itself after ending. **Default:** `true`.",
                               "name": "autoDestroy",
                               "type": "boolean",
-                              "default": "`false`",
+                              "default": "`true`",
                               "desc": "Whether this stream should automatically call `.destroy()` on itself after ending."
                             }
                           ]
@@ -49375,7 +54923,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>This function MUST NOT be called by application code directly. It should be\nimplemented by child classes, and called by the internal <code>Readable</code> class\nmethods only.</p>\n<p>All <code>Readable</code> stream implementations must provide an implementation of the\n<a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> method to fetch data from the underlying resource.</p>\n<p>When <a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> is called, if data is available from the resource,\nthe implementation should begin pushing that data into the read queue using the\n<a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>this.push(dataChunk)</code></a> method. <code>_read()</code> should continue reading\nfrom the resource and pushing data until <code>readable.push()</code> returns <code>false</code>. Only\nwhen <code>_read()</code> is called again after it has stopped should it resume pushing\nadditional data onto the queue.</p>\n<p>Once the <a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> method has been called, it will not be called\nagain until more data is pushed through the <a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>readable.push()</code></a>\nmethod. Empty data such as empty buffers and strings will not cause\n<a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> to be called.</p>\n<p>The <code>size</code> argument is advisory. For implementations where a \"read\" is a\nsingle operation that returns data can use the <code>size</code> argument to determine how\nmuch data to fetch. Other implementations may ignore this argument and simply\nprovide data whenever it becomes available. There is no need to \"wait\" until\n<code>size</code> bytes are available before calling <a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>stream.push(chunk)</code></a>.</p>\n<p>The <a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.</p>"
+                  "desc": "<p>This function MUST NOT be called by application code directly. It should be\nimplemented by child classes, and called by the internal <code>Readable</code> class\nmethods only.</p>\n<p>All <code>Readable</code> stream implementations must provide an implementation of the\n<a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> method to fetch data from the underlying resource.</p>\n<p>When <a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> is called, if data is available from the resource,\nthe implementation should begin pushing that data into the read queue using the\n<a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>this.push(dataChunk)</code></a> method. <code>_read()</code> will be called again\nafter each call to <a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>this.push(dataChunk)</code></a> once the stream is\nready to accept more data. <code>_read()</code> may continue reading from the resource and\npushing data until <code>readable.push()</code> returns <code>false</code>. Only when <code>_read()</code> is\ncalled again after it has stopped should it resume pushing additional data into\nthe queue.</p>\n<p>Once the <a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> method has been called, it will not be called\nagain until more data is pushed through the <a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>readable.push()</code></a>\nmethod. Empty data such as empty buffers and strings will not cause\n<a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> to be called.</p>\n<p>The <code>size</code> argument is advisory. For implementations where a \"read\" is a\nsingle operation that returns data can use the <code>size</code> argument to determine how\nmuch data to fetch. Other implementations may ignore this argument and simply\nprovide data whenever it becomes available. There is no need to \"wait\" until\n<code>size</code> bytes are available before calling <a href=\"stream.html#stream_readable_push_chunk_encoding\"><code>stream.push(chunk)</code></a>.</p>\n<p>The <a href=\"stream.html#stream_readable_read_size_1\"><code>readable._read()</code></a> method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.</p>"
                 },
                 {
                   "textRaw": "`readable._destroy(err, callback)`",
@@ -49606,13 +55154,20 @@
                   "desc": "<!-- eslint-disable no-useless-constructor -->\n<pre><code class=\"language-js\">const { Transform } = require('stream');\n\nclass MyTransform extends Transform {\n  constructor(options) {\n    super(options);\n    // ...\n  }\n}\n</code></pre>\n<p>Or, when using pre-ES6 style constructors:</p>\n<pre><code class=\"language-js\">const { Transform } = require('stream');\nconst util = require('util');\n\nfunction MyTransform(options) {\n  if (!(this instanceof MyTransform))\n    return new MyTransform(options);\n  Transform.call(this, options);\n}\nutil.inherits(MyTransform, Transform);\n</code></pre>\n<p>Or, using the simplified constructor approach:</p>\n<pre><code class=\"language-js\">const { Transform } = require('stream');\n\nconst myTransform = new Transform({\n  transform(chunk, encoding, callback) {\n    // ...\n  }\n});\n</code></pre>"
                 }
               ],
-              "modules": [
+              "events": [
                 {
-                  "textRaw": "Events: `'finish'` and `'end'`",
-                  "name": "events:_`'finish'`_and_`'end'`",
-                  "desc": "<p>The <a href=\"stream.html#stream_event_finish\"><code>'finish'</code></a> and <a href=\"stream.html#stream_event_end\"><code>'end'</code></a> events are from the <code>stream.Writable</code>\nand <code>stream.Readable</code> classes, respectively. The <code>'finish'</code> event is emitted\nafter <a href=\"stream.html#stream_writable_end_chunk_encoding_callback\"><code>stream.end()</code></a> is called and all chunks have been processed\nby <a href=\"stream.html#stream_transform_transform_chunk_encoding_callback\"><code>stream._transform()</code></a>. The <code>'end'</code> event is emitted\nafter all data has been output, which occurs after the callback in\n<a href=\"stream.html#stream_transform_flush_callback\"><code>transform._flush()</code></a> has been called.</p>",
-                  "type": "module",
-                  "displayName": "Events: `'finish'` and `'end'`"
+                  "textRaw": "Event: `'end'`",
+                  "type": "event",
+                  "name": "end",
+                  "params": [],
+                  "desc": "<p>The <a href=\"stream.html#stream_event_end\"><code>'end'</code></a> event is from the <code>stream.Readable</code> class. The <code>'end'</code> event is\nemitted after all data has been output, which occurs after the callback in\n<a href=\"stream.html#stream_transform_flush_callback\"><code>transform._flush()</code></a> has been called. In the case of an error,\n<code>'end'</code> should not be emitted.</p>"
+                },
+                {
+                  "textRaw": "Event: `'finish'`",
+                  "type": "event",
+                  "name": "finish",
+                  "params": [],
+                  "desc": "<p>The <a href=\"stream.html#stream_event_finish\"><code>'finish'</code></a> event is from the <code>stream.Writable</code> class. The <code>'finish'</code>\nevent is emitted after <a href=\"stream.html#stream_writable_end_chunk_encoding_callback\"><code>stream.end()</code></a> is called and all chunks\nhave been processed by <a href=\"stream.html#stream_transform_transform_chunk_encoding_callback\"><code>stream._transform()</code></a>. In the case\nof an error, <code>'finish'</code> should not be emitted.</p>"
                 }
               ],
               "methods": [
@@ -49708,7 +55263,7 @@
                   "textRaw": "Piping to writable streams from async iterators",
                   "name": "Piping to writable streams from async iterators",
                   "type": "misc",
-                  "desc": "<p>In the scenario of writing to a writable stream from an async iterator, ensure\nthe correct handling of backpressure and errors.</p>\n<pre><code class=\"language-js\">const { once } = require('events');\nconst finished = util.promisify(stream.finished);\n\nconst writable = fs.createWriteStream('./file');\n\nfunction drain(writable) {\n  if (writable.destroyed) {\n    return Promise.reject(new Error('premature close'));\n  }\n  return Promise.race([\n    once(writable, 'drain'),\n    once(writable, 'close')\n      .then(() => Promise.reject(new Error('premature close')))\n  ]);\n}\n\nasync function pump(iterable, writable) {\n  for await (const chunk of iterable) {\n    // Handle backpressure on write().\n    if (!writable.write(chunk)) {\n      await drain(writable);\n    }\n  }\n  writable.end();\n}\n\n(async function() {\n  // Ensure completion without errors.\n  await Promise.all([\n    pump(iterable, writable),\n    finished(writable)\n  ]);\n})();\n</code></pre>\n<p>In the above, errors on <code>write()</code> would be caught and thrown by the\n<code>once()</code> listener for the <code>'drain'</code> event, since <code>once()</code> will also handle the\n<code>'error'</code> event. To ensure completion of the write stream without errors,\nit is safer to use the <code>finished()</code> method as above, instead of using the\n<code>once()</code> listener for the <code>'finish'</code> event. Under certain cases, an <code>'error'</code>\nevent could be emitted by the writable stream after <code>'finish'</code> and as <code>once()</code>\nwill release the <code>'error'</code> handler on handling the <code>'finish'</code> event, it could\nresult in an unhandled error.</p>\n<p>Alternatively, the readable stream could be wrapped with <code>Readable.from()</code> and\nthen piped via <code>.pipe()</code>:</p>\n<pre><code class=\"language-js\">const finished = util.promisify(stream.finished);\n\nconst writable = fs.createWriteStream('./file');\n\n(async function() {\n  const readable = Readable.from(iterable);\n  readable.pipe(writable);\n  // Ensure completion without errors.\n  await finished(writable);\n})();\n</code></pre>\n<p>Or, using <code>stream.pipeline()</code> to pipe streams:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nconst writable = fs.createWriteStream('./file');\n\n(async function() {\n  const readable = Readable.from(iterable);\n  await pipeline(readable, writable);\n})();\n</code></pre>"
+                  "desc": "<p>When writing to a writable stream from an async iterator, ensure correct\nhandling of backpressure and errors. <a href=\"stream.html#stream_stream_pipeline_source_transforms_destination_callback\"><code>stream.pipeline()</code></a> abstracts away\nthe handling of backpressure and backpressure-related errors:</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst util = require('util');\nconst fs = require('fs');\n\nconst writable = fs.createWriteStream('./file');\n\n// Callback Pattern\npipeline(iterator, writable, (err, value) => {\n  if (err) {\n    console.error(err);\n  } else {\n    console.log(value, 'value returned');\n  }\n});\n\n// Promise Pattern\nconst pipelinePromise = util.promisify(pipeline);\npipelinePromise(iterator, writable)\n  .then((value) => {\n    console.log(value, 'value returned');\n  })\n  .catch(console.error);\n</code></pre>"
                 }
               ],
               "type": "misc",
@@ -49755,7 +55310,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Stream"
+      "displayName": "Stream",
+      "source": "doc/api/stream.md"
     },
     {
       "textRaw": "String decoder",
@@ -49763,7 +55319,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/string_decoder.js\">lib/string_decoder.js</a></p>\n<p>The <code>string_decoder</code> module provides an API for decoding <code>Buffer</code> objects into\nstrings in a manner that preserves encoded multi-byte UTF-8 and UTF-16\ncharacters. It can be accessed using:</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\n</code></pre>\n<p>The following example shows the basic use of the <code>StringDecoder</code> class.</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\nconst decoder = new StringDecoder('utf8');\n\nconst cent = Buffer.from([0xC2, 0xA2]);\nconsole.log(decoder.write(cent));\n\nconst euro = Buffer.from([0xE2, 0x82, 0xAC]);\nconsole.log(decoder.write(euro));\n</code></pre>\n<p>When a <code>Buffer</code> instance is written to the <code>StringDecoder</code> instance, an\ninternal buffer is used to ensure that the decoded string does not contain\nany incomplete multibyte characters. These are held in the buffer until the\nnext call to <code>stringDecoder.write()</code> or until <code>stringDecoder.end()</code> is called.</p>\n<p>In the following example, the three UTF-8 encoded bytes of the European Euro\nsymbol (<code>€</code>) are written over three separate operations:</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\nconst decoder = new StringDecoder('utf8');\n\ndecoder.write(Buffer.from([0xE2]));\ndecoder.write(Buffer.from([0x82]));\nconsole.log(decoder.end(Buffer.from([0xAC])));\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/string_decoder.js\">lib/string_decoder.js</a></p>\n<p>The <code>string_decoder</code> module provides an API for decoding <code>Buffer</code> objects into\nstrings in a manner that preserves encoded multi-byte UTF-8 and UTF-16\ncharacters. It can be accessed using:</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\n</code></pre>\n<p>The following example shows the basic use of the <code>StringDecoder</code> class.</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\nconst decoder = new StringDecoder('utf8');\n\nconst cent = Buffer.from([0xC2, 0xA2]);\nconsole.log(decoder.write(cent));\n\nconst euro = Buffer.from([0xE2, 0x82, 0xAC]);\nconsole.log(decoder.write(euro));\n</code></pre>\n<p>When a <code>Buffer</code> instance is written to the <code>StringDecoder</code> instance, an\ninternal buffer is used to ensure that the decoded string does not contain\nany incomplete multibyte characters. These are held in the buffer until the\nnext call to <code>stringDecoder.write()</code> or until <code>stringDecoder.end()</code> is called.</p>\n<p>In the following example, the three UTF-8 encoded bytes of the European Euro\nsymbol (<code>€</code>) are written over three separate operations:</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\nconst decoder = new StringDecoder('utf8');\n\ndecoder.write(Buffer.from([0xE2]));\ndecoder.write(Buffer.from([0x82]));\nconsole.log(decoder.end(Buffer.from([0xAC])));\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `StringDecoder`",
@@ -49797,7 +55353,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns any remaining input stored in the internal buffer as a string. Bytes\nrepresenting incomplete UTF-8 and UTF-16 characters will be replaced with\nsubstitution characters appropriate for the character encoding.</p>\n<p>If the <code>buffer</code> argument is provided, one final call to <code>stringDecoder.write()</code>\nis performed before returning the remaining input.</p>"
+              "desc": "<p>Returns any remaining input stored in the internal buffer as a string. Bytes\nrepresenting incomplete UTF-8 and UTF-16 characters will be replaced with\nsubstitution characters appropriate for the character encoding.</p>\n<p>If the <code>buffer</code> argument is provided, one final call to <code>stringDecoder.write()</code>\nis performed before returning the remaining input.\nAfter <code>end()</code> is called, the <code>stringDecoder</code> object can be reused for new input.</p>"
             },
             {
               "textRaw": "`stringDecoder.write(buffer)`",
@@ -49852,7 +55408,8 @@
         }
       ],
       "type": "module",
-      "displayName": "String decoder"
+      "displayName": "String decoder",
+      "source": "doc/api/string_decoder.md"
     },
     {
       "textRaw": "Timers",
@@ -49860,7 +55417,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/timers.js\">lib/timers.js</a></p>\n<p>The <code>timer</code> module exposes a global API for scheduling functions to\nbe called at some future period of time. Because the timer functions are\nglobals, there is no need to call <code>require('timers')</code> to use the API.</p>\n<p>The timer functions within Node.js implement a similar API as the timers API\nprovided by Web Browsers but use a different internal implementation that is\nbuilt around the Node.js <a href=\"https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout\">Event Loop</a>.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/timers.js\">lib/timers.js</a></p>\n<p>The <code>timer</code> module exposes a global API for scheduling functions to\nbe called at some future period of time. Because the timer functions are\nglobals, there is no need to call <code>require('timers')</code> to use the API.</p>\n<p>The timer functions within Node.js implement a similar API as the timers API\nprovided by Web Browsers but use a different internal implementation that is\nbuilt around the Node.js <a href=\"https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout\">Event Loop</a>.</p>",
       "classes": [
         {
           "textRaw": "Class: `Immediate`",
@@ -50041,7 +55598,7 @@
               "name": "[Symbol.toPrimitive]",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.9.0"
                 ],
                 "changes": []
               },
@@ -50104,7 +55661,7 @@
               "desc": "<p>Schedules the \"immediate\" execution of the <code>callback</code> after I/O events'\ncallbacks.</p>\n<p>When multiple calls to <code>setImmediate()</code> are made, the <code>callback</code> functions are\nqueued for execution in the order in which they are created. The entire callback\nqueue is processed every event loop iteration. If an immediate timer is queued\nfrom inside an executing callback, that timer will not be triggered until the\nnext event loop iteration.</p>\n<p>If <code>callback</code> is not a function, a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> will be thrown.</p>\n<p>This method has a custom variant for promises that is available using\n<a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst setImmediatePromise = util.promisify(setImmediate);\n\nsetImmediatePromise('foobar').then((value) => {\n  // value === 'foobar' (passing values is optional)\n  // This is executed after all I/O callbacks.\n});\n\n// Or with async function\nasync function timerExample() {\n  console.log('Before I/O callbacks');\n  await setImmediatePromise();\n  console.log('After I/O callbacks');\n}\ntimerExample();\n</code></pre>"
             },
             {
-              "textRaw": "`setInterval(callback, delay[, ...args])`",
+              "textRaw": "`setInterval(callback[, delay[, ...args]])`",
               "type": "method",
               "name": "setInterval",
               "meta": {
@@ -50129,10 +55686,10 @@
                       "desc": "The function to call when the timer elapses."
                     },
                     {
-                      "textRaw": "`delay` {number} The number of milliseconds to wait before calling the `callback`.",
+                      "textRaw": "`delay` {number} The number of milliseconds to wait before calling the `callback`. **Default**: `1`.",
                       "name": "delay",
                       "type": "number",
-                      "desc": "The number of milliseconds to wait before calling the `callback`."
+                      "desc": "The number of milliseconds to wait before calling the `callback`. **Default**: `1`."
                     },
                     {
                       "textRaw": "`...args` {any} Optional arguments to pass when the `callback` is called.",
@@ -50146,7 +55703,7 @@
               "desc": "<p>Schedules repeated execution of <code>callback</code> every <code>delay</code> milliseconds.</p>\n<p>When <code>delay</code> is larger than <code>2147483647</code> or less than <code>1</code>, the <code>delay</code> will be\nset to <code>1</code>. Non-integer delays are truncated to an integer.</p>\n<p>If <code>callback</code> is not a function, a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> will be thrown.</p>"
             },
             {
-              "textRaw": "`setTimeout(callback, delay[, ...args])`",
+              "textRaw": "`setTimeout(callback[, delay[, ...args]])`",
               "type": "method",
               "name": "setTimeout",
               "meta": {
@@ -50171,10 +55728,10 @@
                       "desc": "The function to call when the timer elapses."
                     },
                     {
-                      "textRaw": "`delay` {number} The number of milliseconds to wait before calling the `callback`.",
+                      "textRaw": "`delay` {number} The number of milliseconds to wait before calling the `callback`. **Default**: `1`.",
                       "name": "delay",
                       "type": "number",
-                      "desc": "The number of milliseconds to wait before calling the `callback`."
+                      "desc": "The number of milliseconds to wait before calling the `callback`. **Default**: `1`."
                     },
                     {
                       "textRaw": "`...args` {any} Optional arguments to pass when the `callback` is called.",
@@ -50194,7 +55751,7 @@
         {
           "textRaw": "Cancelling timers",
           "name": "cancelling_timers",
-          "desc": "<p>The <a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>, <a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>, and <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> methods\neach return objects that represent the scheduled timers. These can be used to\ncancel the timer and prevent it from triggering.</p>\n<p>It is not possible to cancel timers that were created using the promisified\nvariants of <a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>, <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a>.</p>",
+          "desc": "<p>The <a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>, <a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>, and <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> methods\neach return objects that represent the scheduled timers. These can be used to\ncancel the timer and prevent it from triggering.</p>\n<p>For the promisified variants of <a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a> and <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a>,\nan <a href=\"globals.html#globals_class_abortcontroller\"><code>AbortController</code></a> may be used to cancel the timer. When canceled, the\nreturned Promises will be rejected with an <code>'AbortError'</code>.</p>\n<p>For <code>setImmediate()</code>:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst setImmediatePromise = util.promisify(setImmediate);\n\nconst ac = new AbortController();\nconst signal = ac.signal;\n\nsetImmediatePromise('foobar', { signal })\n  .then(console.log)\n  .catch((err) => {\n    if (err.name === 'AbortError')\n      console.log('The immediate was aborted');\n  });\n\nac.abort();\n</code></pre>\n<p>For <code>setTimeout()</code>:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst setTimeoutPromise = util.promisify(setTimeout);\n\nconst ac = new AbortController();\nconst signal = ac.signal;\n\nsetTimeoutPromise(1000, 'foobar', { signal })\n  .then(console.log)\n  .catch((err) => {\n    if (err.name === 'AbortError')\n      console.log('The timeout was aborted');\n  });\n\nac.abort();\n</code></pre>",
           "methods": [
             {
               "textRaw": "`clearImmediate(immediate)`",
@@ -50234,10 +55791,10 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`timeout` {Timeout} A `Timeout` object as returned by [`setInterval()`][].",
+                      "textRaw": "`timeout` {Timeout|string|number} A `Timeout` object as returned by [`setInterval()`][] or the [primitive][] of the `Timeout` object as a string or a number.",
                       "name": "timeout",
-                      "type": "Timeout",
-                      "desc": "A `Timeout` object as returned by [`setInterval()`][]."
+                      "type": "Timeout|string|number",
+                      "desc": "A `Timeout` object as returned by [`setInterval()`][] or the [primitive][] of the `Timeout` object as a string or a number."
                     }
                   ]
                 }
@@ -50258,10 +55815,10 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`timeout` {Timeout} A `Timeout` object as returned by [`setTimeout()`][].",
+                      "textRaw": "`timeout` {Timeout|string|number} A `Timeout` object as returned by [`setTimeout()`][] or the [primitive][] of the `Timeout` object as a string or a number.",
                       "name": "timeout",
-                      "type": "Timeout",
-                      "desc": "A `Timeout` object as returned by [`setTimeout()`][]."
+                      "type": "Timeout|string|number",
+                      "desc": "A `Timeout` object as returned by [`setTimeout()`][] or the [primitive][] of the `Timeout` object as a string or a number."
                     }
                   ]
                 }
@@ -50274,7 +55831,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Timers"
+      "displayName": "Timers",
+      "source": "doc/api/timers.md"
     },
     {
       "textRaw": "TLS (SSL)",
@@ -50282,7 +55840,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/tls.js\">lib/tls.js</a></p>\n<p>The <code>tls</code> module provides an implementation of the Transport Layer Security\n(TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.\nThe module can be accessed using:</p>\n<pre><code class=\"language-js\">const tls = require('tls');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/tls.js\">lib/tls.js</a></p>\n<p>The <code>tls</code> module provides an implementation of the Transport Layer Security\n(TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.\nThe module can be accessed using:</p>\n<pre><code class=\"language-js\">const tls = require('tls');\n</code></pre>",
       "modules": [
         {
           "textRaw": "TLS/SSL concepts",
@@ -50330,7 +55888,7 @@
                 {
                   "textRaw": "Session tickets",
                   "name": "session_tickets",
-                  "desc": "<p>The servers encrypt the entire session state and send it\nto the client as a \"ticket\". When reconnecting, the state is sent to the server\nin the initial connection. This mechanism avoids the need for server-side\nsession cache. If the server doesn't use the ticket, for any reason (failure\nto decrypt it, it's too old, etc.), it will create a new session and send a new\nticket. See <a href=\"https://tools.ietf.org/html/rfc5077\">RFC 5077</a> for more information.</p>\n<p>Resumption using session tickets is becoming commonly supported by many web\nbrowsers when making HTTPS requests.</p>\n<p>For Node.js, clients use the same APIs for resumption with session identifiers\nas for resumption with session tickets. For debugging, if\n<a href=\"tls.html#tls_tlssocket_gettlsticket\"><code>tls.TLSSocket.getTLSTicket()</code></a> returns a value, the session data contains a\nticket, otherwise it contains client-side session state.</p>\n<p>With TLSv1.3, be aware that multiple tickets may be sent by the server,\nresulting in multiple <code>'session'</code> events, see <a href=\"tls.html#tls_event_session\"><code>'session'</code></a> for more\ninformation.</p>\n<p>Single process servers need no specific implementation to use session tickets.\nTo use session tickets across server restarts or load balancers, servers must\nall have the same ticket keys. There are three 16-byte keys internally, but the\ntls API exposes them as a single 48-byte buffer for convenience.</p>\n<p>Its possible to get the ticket keys by calling <a href=\"tls.html#tls_server_getticketkeys\"><code>server.getTicketKeys()</code></a> on\none server instance and then distribute them, but it is more reasonable to\nsecurely generate 48 bytes of secure random data and set them with the\n<code>ticketKeys</code> option of <a href=\"tls.html#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>. The keys should be regularly\nregenerated and server's keys can be reset with\n<a href=\"tls.html#tls_server_setticketkeys_keys\"><code>server.setTicketKeys()</code></a>.</p>\n<p>Session ticket keys are cryptographic keys, and they <strong><em>must be stored\nsecurely</em></strong>. With TLS 1.2 and below, if they are compromised all sessions that\nused tickets encrypted with them can be decrypted. They should not be stored\non disk, and they should be regenerated regularly.</p>\n<p>If clients advertise support for tickets, the server will send them. The\nserver can disable tickets by supplying\n<code>require('constants').SSL_OP_NO_TICKET</code> in <code>secureOptions</code>.</p>\n<p>Both session identifiers and session tickets timeout, causing the server to\ncreate new sessions. The timeout can be configured with the <code>sessionTimeout</code>\noption of <a href=\"tls.html#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>.</p>\n<p>For all the mechanisms, when resumption fails, servers will create new sessions.\nSince failing to resume the session does not cause TLS/HTTPS connection\nfailures, it is easy to not notice unnecessarily poor TLS performance. The\nOpenSSL CLI can be used to verify that servers are resuming sessions. Use the\n<code>-reconnect</code> option to <code>openssl s_client</code>, for example:</p>\n<pre><code class=\"language-console\">$ openssl s_client -connect localhost:443 -reconnect\n</code></pre>\n<p>Read through the debug output. The first connection should say \"New\", for\nexample:</p>\n<pre><code class=\"language-text\">New, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256\n</code></pre>\n<p>Subsequent connections should say \"Reused\", for example:</p>\n<pre><code class=\"language-text\">Reused, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256\n</code></pre>",
+                  "desc": "<p>The servers encrypt the entire session state and send it\nto the client as a \"ticket\". When reconnecting, the state is sent to the server\nin the initial connection. This mechanism avoids the need for server-side\nsession cache. If the server doesn't use the ticket, for any reason (failure\nto decrypt it, it's too old, etc.), it will create a new session and send a new\nticket. See <a href=\"https://tools.ietf.org/html/rfc5077\">RFC 5077</a> for more information.</p>\n<p>Resumption using session tickets is becoming commonly supported by many web\nbrowsers when making HTTPS requests.</p>\n<p>For Node.js, clients use the same APIs for resumption with session identifiers\nas for resumption with session tickets. For debugging, if\n<a href=\"tls.html#tls_tlssocket_gettlsticket\"><code>tls.TLSSocket.getTLSTicket()</code></a> returns a value, the session data contains a\nticket, otherwise it contains client-side session state.</p>\n<p>With TLSv1.3, be aware that multiple tickets may be sent by the server,\nresulting in multiple <code>'session'</code> events, see <a href=\"tls.html#tls_event_session\"><code>'session'</code></a> for more\ninformation.</p>\n<p>Single process servers need no specific implementation to use session tickets.\nTo use session tickets across server restarts or load balancers, servers must\nall have the same ticket keys. There are three 16-byte keys internally, but the\ntls API exposes them as a single 48-byte buffer for convenience.</p>\n<p>Its possible to get the ticket keys by calling <a href=\"tls.html#tls_server_getticketkeys\"><code>server.getTicketKeys()</code></a> on\none server instance and then distribute them, but it is more reasonable to\nsecurely generate 48 bytes of secure random data and set them with the\n<code>ticketKeys</code> option of <a href=\"tls.html#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>. The keys should be regularly\nregenerated and server's keys can be reset with\n<a href=\"tls.html#tls_server_setticketkeys_keys\"><code>server.setTicketKeys()</code></a>.</p>\n<p>Session ticket keys are cryptographic keys, and they <em><strong>must be stored\nsecurely</strong></em>. With TLS 1.2 and below, if they are compromised all sessions that\nused tickets encrypted with them can be decrypted. They should not be stored\non disk, and they should be regenerated regularly.</p>\n<p>If clients advertise support for tickets, the server will send them. The\nserver can disable tickets by supplying\n<code>require('constants').SSL_OP_NO_TICKET</code> in <code>secureOptions</code>.</p>\n<p>Both session identifiers and session tickets timeout, causing the server to\ncreate new sessions. The timeout can be configured with the <code>sessionTimeout</code>\noption of <a href=\"tls.html#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>.</p>\n<p>For all the mechanisms, when resumption fails, servers will create new sessions.\nSince failing to resume the session does not cause TLS/HTTPS connection\nfailures, it is easy to not notice unnecessarily poor TLS performance. The\nOpenSSL CLI can be used to verify that servers are resuming sessions. Use the\n<code>-reconnect</code> option to <code>openssl s_client</code>, for example:</p>\n<pre><code class=\"language-console\">$ openssl s_client -connect localhost:443 -reconnect\n</code></pre>\n<p>Read through the debug output. The first connection should say \"New\", for\nexample:</p>\n<pre><code class=\"language-text\">New, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256\n</code></pre>\n<p>Subsequent connections should say \"Reused\", for example:</p>\n<pre><code class=\"language-text\">Reused, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256\n</code></pre>",
                   "type": "module",
                   "displayName": "Session tickets"
                 }
@@ -50345,7 +55903,7 @@
         {
           "textRaw": "Modifying the default TLS cipher suite",
           "name": "modifying_the_default_tls_cipher_suite",
-          "desc": "<p>Node.js is built with a default suite of enabled and disabled TLS ciphers. This\ndefault cipher list can be configured when building Node.js to allow\ndistributions to provide their own default list.</p>\n<p>The following command can be used to show the default cipher suite:</p>\n<pre><code class=\"language-console\">node -p crypto.constants.defaultCoreCipherList | tr ':' '\\n'\nTLS_AES_256_GCM_SHA384\nTLS_CHACHA20_POLY1305_SHA256\nTLS_AES_128_GCM_SHA256\nECDHE-RSA-AES128-GCM-SHA256\nECDHE-ECDSA-AES128-GCM-SHA256\nECDHE-RSA-AES256-GCM-SHA384\nECDHE-ECDSA-AES256-GCM-SHA384\nDHE-RSA-AES128-GCM-SHA256\nECDHE-RSA-AES128-SHA256\nDHE-RSA-AES128-SHA256\nECDHE-RSA-AES256-SHA384\nDHE-RSA-AES256-SHA384\nECDHE-RSA-AES256-SHA256\nDHE-RSA-AES256-SHA256\nHIGH\n!aNULL\n!eNULL\n!EXPORT\n!DES\n!RC4\n!MD5\n!PSK\n!SRP\n!CAMELLIA\n</code></pre>\n<p>This default can be replaced entirely using the <a href=\"cli.html#cli_tls_cipher_list_list\"><code>--tls-cipher-list</code></a> command\nline switch (directly, or via the <a href=\"cli.html#cli_node_options_options\"><code>NODE_OPTIONS</code></a> environment variable). For\ninstance, the following makes <code>ECDHE-RSA-AES128-GCM-SHA256:!RC4</code> the default TLS\ncipher suite:</p>\n<pre><code class=\"language-bash\">node --tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4' server.js\n\nexport NODE_OPTIONS=--tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4'\nnode server.js\n</code></pre>\n<p>The default can also be replaced on a per client or server basis using the\n<code>ciphers</code> option from <a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.createSecureContext()</code></a>, which is also available\nin <a href=\"tls.html#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>, <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>, and when creating new\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a>s.</p>\n<p>The ciphers list can contain a mixture of TLSv1.3 cipher suite names, the ones\nthat start with <code>'TLS_'</code>, and specifications for TLSv1.2 and below cipher\nsuites. The TLSv1.2 ciphers support a legacy specification format, consult\nthe OpenSSL <a href=\"https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT\">cipher list format</a> documentation for details, but those\nspecifications do <em>not</em> apply to TLSv1.3 ciphers. The TLSv1.3 suites can only\nbe enabled by including their full name in the cipher list. They cannot, for\nexample, be enabled or disabled by using the legacy TLSv1.2 <code>'EECDH'</code> or\n<code>'!EECDH'</code> specification.</p>\n<p>Despite the relative order of TLSv1.3 and TLSv1.2 cipher suites, the TLSv1.3\nprotocol is significantly more secure than TLSv1.2, and will always be chosen\nover TLSv1.2 if the handshake indicates it is supported, and if any TLSv1.3\ncipher suites are enabled.</p>\n<p>The default cipher suite included within Node.js has been carefully\nselected to reflect current security best practices and risk mitigation.\nChanging the default cipher suite can have a significant impact on the security\nof an application. The <code>--tls-cipher-list</code> switch and <code>ciphers</code> option should by\nused only if absolutely necessary.</p>\n<p>The default cipher suite prefers GCM ciphers for <a href=\"https://www.chromium.org/Home/chromium-security/education/tls#TOC-Cipher-Suites\">Chrome's 'modern\ncryptography' setting</a> and also prefers ECDHE and DHE ciphers for perfect\nforward secrecy, while offering <em>some</em> backward compatibility.</p>\n<p>128 bit AES is preferred over 192 and 256 bit AES in light of <a href=\"https://www.schneier.com/blog/archives/2009/07/another_new_aes.html\">specific\nattacks affecting larger AES key sizes</a>.</p>\n<p>Old clients that rely on insecure and deprecated RC4 or DES-based ciphers\n(like Internet Explorer 6) cannot complete the handshaking process with\nthe default configuration. If these clients <em>must</em> be supported, the\n<a href=\"https://wiki.mozilla.org/Security/Server_Side_TLS\">TLS recommendations</a> may offer a compatible cipher suite. For more details\non the format, see the OpenSSL <a href=\"https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT\">cipher list format</a> documentation.</p>\n<p>There are only 5 TLSv1.3 cipher suites:</p>\n<ul>\n<li><code>'TLS_AES_256_GCM_SHA384'</code></li>\n<li><code>'TLS_CHACHA20_POLY1305_SHA256'</code></li>\n<li><code>'TLS_AES_128_GCM_SHA256'</code></li>\n<li><code>'TLS_AES_128_CCM_SHA256'</code></li>\n<li><code>'TLS_AES_128_CCM_8_SHA256'</code></li>\n</ul>\n<p>The first 3 are enabled by default. The last 2 <code>CCM</code>-based suites are supported\nby TLSv1.3 because they may be more performant on constrained systems, but they\nare not enabled by default since they offer less security.</p>",
+          "desc": "<p>Node.js is built with a default suite of enabled and disabled TLS ciphers. This\ndefault cipher list can be configured when building Node.js to allow\ndistributions to provide their own default list.</p>\n<p>The following command can be used to show the default cipher suite:</p>\n<pre><code class=\"language-console\">node -p crypto.constants.defaultCoreCipherList | tr ':' '\\n'\nTLS_AES_256_GCM_SHA384\nTLS_CHACHA20_POLY1305_SHA256\nTLS_AES_128_GCM_SHA256\nECDHE-RSA-AES128-GCM-SHA256\nECDHE-ECDSA-AES128-GCM-SHA256\nECDHE-RSA-AES256-GCM-SHA384\nECDHE-ECDSA-AES256-GCM-SHA384\nDHE-RSA-AES128-GCM-SHA256\nECDHE-RSA-AES128-SHA256\nDHE-RSA-AES128-SHA256\nECDHE-RSA-AES256-SHA384\nDHE-RSA-AES256-SHA384\nECDHE-RSA-AES256-SHA256\nDHE-RSA-AES256-SHA256\nHIGH\n!aNULL\n!eNULL\n!EXPORT\n!DES\n!RC4\n!MD5\n!PSK\n!SRP\n!CAMELLIA\n</code></pre>\n<p>This default can be replaced entirely using the <a href=\"cli.html#cli_tls_cipher_list_list\"><code>--tls-cipher-list</code></a>\ncommand-line switch (directly, or via the <a href=\"cli.html#cli_node_options_options\"><code>NODE_OPTIONS</code></a> environment\nvariable). For instance, the following makes <code>ECDHE-RSA-AES128-GCM-SHA256:!RC4</code>\nthe default TLS cipher suite:</p>\n<pre><code class=\"language-bash\">node --tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4' server.js\n\nexport NODE_OPTIONS=--tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4'\nnode server.js\n</code></pre>\n<p>The default can also be replaced on a per client or server basis using the\n<code>ciphers</code> option from <a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.createSecureContext()</code></a>, which is also available\nin <a href=\"tls.html#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>, <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>, and when creating new\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a>s.</p>\n<p>The ciphers list can contain a mixture of TLSv1.3 cipher suite names, the ones\nthat start with <code>'TLS_'</code>, and specifications for TLSv1.2 and below cipher\nsuites. The TLSv1.2 ciphers support a legacy specification format, consult\nthe OpenSSL <a href=\"https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT\">cipher list format</a> documentation for details, but those\nspecifications do <em>not</em> apply to TLSv1.3 ciphers. The TLSv1.3 suites can only\nbe enabled by including their full name in the cipher list. They cannot, for\nexample, be enabled or disabled by using the legacy TLSv1.2 <code>'EECDH'</code> or\n<code>'!EECDH'</code> specification.</p>\n<p>Despite the relative order of TLSv1.3 and TLSv1.2 cipher suites, the TLSv1.3\nprotocol is significantly more secure than TLSv1.2, and will always be chosen\nover TLSv1.2 if the handshake indicates it is supported, and if any TLSv1.3\ncipher suites are enabled.</p>\n<p>The default cipher suite included within Node.js has been carefully\nselected to reflect current security best practices and risk mitigation.\nChanging the default cipher suite can have a significant impact on the security\nof an application. The <code>--tls-cipher-list</code> switch and <code>ciphers</code> option should by\nused only if absolutely necessary.</p>\n<p>The default cipher suite prefers GCM ciphers for <a href=\"https://www.chromium.org/Home/chromium-security/education/tls#TOC-Cipher-Suites\">Chrome's 'modern\ncryptography' setting</a> and also prefers ECDHE and DHE ciphers for perfect\nforward secrecy, while offering <em>some</em> backward compatibility.</p>\n<p>128 bit AES is preferred over 192 and 256 bit AES in light of <a href=\"https://www.schneier.com/blog/archives/2009/07/another_new_aes.html\">specific\nattacks affecting larger AES key sizes</a>.</p>\n<p>Old clients that rely on insecure and deprecated RC4 or DES-based ciphers\n(like Internet Explorer 6) cannot complete the handshaking process with\nthe default configuration. If these clients <em>must</em> be supported, the\n<a href=\"https://wiki.mozilla.org/Security/Server_Side_TLS\">TLS recommendations</a> may offer a compatible cipher suite. For more details\non the format, see the OpenSSL <a href=\"https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT\">cipher list format</a> documentation.</p>\n<p>There are only 5 TLSv1.3 cipher suites:</p>\n<ul>\n<li><code>'TLS_AES_256_GCM_SHA384'</code></li>\n<li><code>'TLS_CHACHA20_POLY1305_SHA256'</code></li>\n<li><code>'TLS_AES_128_GCM_SHA256'</code></li>\n<li><code>'TLS_AES_128_CCM_SHA256'</code></li>\n<li><code>'TLS_AES_128_CCM_8_SHA256'</code></li>\n</ul>\n<p>The first 3 are enabled by default. The last 2 <code>CCM</code>-based suites are supported\nby TLSv1.3 because they may be more performant on constrained systems, but they\nare not enabled by default since they offer less security.</p>",
           "type": "module",
           "displayName": "Modifying the default TLS cipher suite"
         }
@@ -50456,7 +56014,8 @@
               "name": "keylog",
               "meta": {
                 "added": [
-                  "v12.3.0"
+                  "v12.3.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -50702,9 +56261,9 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`keys` {Buffer} A 48-byte buffer containing the session ticket keys.",
+                      "textRaw": "`keys` {Buffer|TypedArray|DataView} A 48-byte buffer containing the session ticket keys.",
                       "name": "keys",
-                      "type": "Buffer",
+                      "type": "Buffer|TypedArray|DataView",
                       "desc": "A 48-byte buffer containing the session ticket keys."
                     }
                   ]
@@ -50751,7 +56310,8 @@
               "name": "keylog",
               "meta": {
                 "added": [
-                  "v12.3.0"
+                  "v12.3.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -50789,7 +56349,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'secureConnect'</code> event is emitted after the handshaking process for a new\nconnection has successfully completed. The listener callback will be called\nregardless of whether or not the server's certificate has been authorized. It\nis the client's responsibility to check the <code>tlsSocket.authorized</code> property to\ndetermine if the server certificate was signed by one of the specified CAs. If\n<code>tlsSocket.authorized === false</code>, then the error can be found by examining the\n<code>tlsSocket.authorizationError</code> property. If ALPN was used, the\n<code>tlsSocket.alpnProtocol</code> property can be checked to determine the negotiated\nprotocol.</p>"
+              "desc": "<p>The <code>'secureConnect'</code> event is emitted after the handshaking process for a new\nconnection has successfully completed. The listener callback will be called\nregardless of whether or not the server's certificate has been authorized. It\nis the client's responsibility to check the <code>tlsSocket.authorized</code> property to\ndetermine if the server certificate was signed by one of the specified CAs. If\n<code>tlsSocket.authorized === false</code>, then the error can be found by examining the\n<code>tlsSocket.authorizationError</code> property. If ALPN was used, the\n<code>tlsSocket.alpnProtocol</code> property can be checked to determine the negotiated\nprotocol.</p>\n<p>The <code>'secureConnect'</code> event is not emitted when a <a href=\"tls.html#tls_class_tls_tlssocket\" class=\"type\">&lt;tls.TLSSocket&gt;</a> is created\nusing the <code>new tls.TLSSocket()</code> constructor.</p>"
             },
             {
               "textRaw": "Event: `'session'`",
@@ -50899,15 +56459,18 @@
                   "v0.11.4"
                 ],
                 "changes": [
+                  {
+                    "version": [
+                      "v13.4.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30637",
+                    "description": "Return the IETF cipher name as `standardName`."
+                  },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26625",
                     "description": "Return the minimum cipher version, instead of a fixed string (`'TLSv1/SSLv3'`)."
-                  },
-                  {
-                    "version": "v12.16.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/30637",
-                    "description": "Return the IETF cipher name as `standardName`."
                   }
                 ]
               },
@@ -51030,7 +56593,7 @@
                       }
                     ]
                   },
-                  "desc": "<p>A certificate object has properties corresponding to the fields of the\ncertificate.</p>\n<ul>\n<li><code>raw</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The DER encoded X.509 certificate data.</li>\n<li><code>subject</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The certificate subject, described in terms of\n Country (<code>C:</code>), StateOrProvince (<code>ST</code>), Locality (<code>L</code>), Organization (<code>O</code>),\nOrganizationalUnit (<code>OU</code>), and CommonName (<code>CN</code>). The CommonName is typically\na DNS name with TLS certificates. Example:\n<code>{C: 'UK', ST: 'BC', L: 'Metro', O: 'Node Fans', OU: 'Docs', CN: 'example.com'}</code>.</li>\n<li><code>issuer</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The certificate issuer, described in the same terms as the\n <code>subject</code>.</li>\n<li><code>valid_from</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The date-time the certificate is valid from.</li>\n<li><code>valid_to</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The date-time the certificate is valid to.</li>\n<li><code>serialNumber</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The certificate serial number, as a hex string.\n Example: <code>'B9B0D332A1AA5635'</code>.</li>\n<li><code>fingerprint</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The SHA-1 digest of the DER encoded certificate. It is\nreturned as a <code>:</code> separated hexadecimal string. Example: <code>'2A:7A:C2:DD:...'</code>.</li>\n<li><code>fingerprint256</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The SHA-256 digest of the DER encoded certificate.\n It is returned as a <code>:</code> separated hexadecimal string. Example:\n<code>'2A:7A:C2:DD:...'</code>.</li>\n<li><code>ext_key_usage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\" class=\"type\">&lt;Array&gt;</a> (Optional) The extended key usage, a set of OIDs.</li>\n<li><code>subjectaltname</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) A string containing concatenated names\nfor the subject, an alternative to the <code>subject</code> names.</li>\n<li><code>infoAccess</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\" class=\"type\">&lt;Array&gt;</a> (Optional) An array describing the AuthorityInfoAccess,\n used with OCSP.</li>\n<li><code>issuerCertificate</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> (Optional) The issuer certificate object. For\n self-signed certificates, this may be a circular reference.</li>\n</ul>\n<p>The certificate may contain information about the public key, depending on\nthe key type.</p>\n<p>For RSA keys, the following properties may be defined:</p>\n<ul>\n<li><code>bits</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The RSA bit size. Example: <code>1024</code>.</li>\n<li><code>exponent</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The RSA exponent, as a string in hexadecimal number\nnotation. Example: <code>'0x010001'</code>.</li>\n<li><code>modulus</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The RSA modulus, as a hexadecimal string. Example:\n <code>'B56CE45CB7...'</code>.</li>\n<li><code>pubkey</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The public key.</li>\n</ul>\n<p>For EC keys, the following properties may be defined:</p>\n<ul>\n<li><code>pubkey</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The public key.</li>\n<li><code>bits</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The key size in bits. Example: <code>256</code>.</li>\n<li><code>asn1Curve</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) The ASN.1 name of the OID of the elliptic\ncurve. Well-known curves are identified by an OID. While it is unusual, it is\npossible that the curve is identified by its mathematical properties, in which\ncase it will not have an OID. Example: <code>'prime256v1'</code>.</li>\n<li><code>nistCurve</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) The NIST name for the elliptic curve, if it\nhas one (not all well-known curves have been assigned names by NIST). Example:\n<code>'P-256'</code>.</li>\n</ul>\n<p>Example certificate:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{ subject:\n   { OU: [ 'Domain Control Validated', 'PositiveSSL Wildcard' ],\n     CN: '*.nodejs.org' },\n  issuer:\n   { C: 'GB',\n     ST: 'Greater Manchester',\n     L: 'Salford',\n     O: 'COMODO CA Limited',\n     CN: 'COMODO RSA Domain Validation Secure Server CA' },\n  subjectaltname: 'DNS:*.nodejs.org, DNS:nodejs.org',\n  infoAccess:\n   { 'CA Issuers - URI':\n      [ 'http://crt.comodoca.com/COMODORSADomainValidationSecureServerCA.crt' ],\n     'OCSP - URI': [ 'http://ocsp.comodoca.com' ] },\n  modulus: 'B56CE45CB740B09A13F64AC543B712FF9EE8E4C284B542A1708A27E82A8D151CA178153E12E6DDA15BF70FFD96CB8A88618641BDFCCA03527E665B70D779C8A349A6F88FD4EF6557180BD4C98192872BCFE3AF56E863C09DDD8BC1EC58DF9D94F914F0369102B2870BECFA1348A0838C9C49BD1C20124B442477572347047506B1FCD658A80D0C44BCC16BC5C5496CFE6E4A8428EF654CD3D8972BF6E5BFAD59C93006830B5EB1056BBB38B53D1464FA6E02BFDF2FF66CD949486F0775EC43034EC2602AEFBF1703AD221DAA2A88353C3B6A688EFE8387811F645CEED7B3FE46E1F8B9F59FAD028F349B9BC14211D5830994D055EEA3D547911E07A0ADDEB8A82B9188E58720D95CD478EEC9AF1F17BE8141BE80906F1A339445A7EB5B285F68039B0F294598A7D1C0005FC22B5271B0752F58CCDEF8C8FD856FB7AE21C80B8A2CE983AE94046E53EDE4CB89F42502D31B5360771C01C80155918637490550E3F555E2EE75CC8C636DDE3633CFEDD62E91BF0F7688273694EEEBA20C2FC9F14A2A435517BC1D7373922463409AB603295CEB0BB53787A334C9CA3CA8B30005C5A62FC0715083462E00719A8FA3ED0A9828C3871360A73F8B04A4FC1E71302844E9BB9940B77E745C9D91F226D71AFCAD4B113AAF68D92B24DDB4A2136B55A1CD1ADF39605B63CB639038ED0F4C987689866743A68769CC55847E4A06D6E2E3F1',\n  exponent: '0x10001',\n  pubkey: &#x3C;Buffer ... >,\n  valid_from: 'Aug 14 00:00:00 2017 GMT',\n  valid_to: 'Nov 20 23:59:59 2019 GMT',\n  fingerprint: '01:02:59:D9:C3:D2:0D:08:F7:82:4E:44:A4:B4:53:C5:E2:3A:87:4D',\n  fingerprint256: '69:AE:1A:6A:D4:3D:C6:C1:1B:EA:C6:23:DE:BA:2A:14:62:62:93:5C:7A:EA:06:41:9B:0B:BC:87:CE:48:4E:02',\n  ext_key_usage: [ '1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2' ],\n  serialNumber: '66593D57F20CBC573E433381B5FEC280',\n  raw: &#x3C;Buffer ... > }\n</code></pre>",
+                  "desc": "<p>A certificate object has properties corresponding to the fields of the\ncertificate.</p>\n<ul>\n<li><code>raw</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The DER encoded X.509 certificate data.</li>\n<li><code>subject</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The certificate subject, described in terms of\nCountry (<code>C:</code>), StateOrProvince (<code>ST</code>), Locality (<code>L</code>), Organization (<code>O</code>),\nOrganizationalUnit (<code>OU</code>), and CommonName (<code>CN</code>). The CommonName is typically\na DNS name with TLS certificates. Example:\n<code>{C: 'UK', ST: 'BC', L: 'Metro', O: 'Node Fans', OU: 'Docs', CN: 'example.com'}</code>.</li>\n<li><code>issuer</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The certificate issuer, described in the same terms as the\n<code>subject</code>.</li>\n<li><code>valid_from</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The date-time the certificate is valid from.</li>\n<li><code>valid_to</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The date-time the certificate is valid to.</li>\n<li><code>serialNumber</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The certificate serial number, as a hex string.\nExample: <code>'B9B0D332A1AA5635'</code>.</li>\n<li><code>fingerprint</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The SHA-1 digest of the DER encoded certificate. It is\nreturned as a <code>:</code> separated hexadecimal string. Example: <code>'2A:7A:C2:DD:...'</code>.</li>\n<li><code>fingerprint256</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The SHA-256 digest of the DER encoded certificate.\nIt is returned as a <code>:</code> separated hexadecimal string. Example:\n<code>'2A:7A:C2:DD:...'</code>.</li>\n<li><code>ext_key_usage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\" class=\"type\">&lt;Array&gt;</a> (Optional) The extended key usage, a set of OIDs.</li>\n<li><code>subjectaltname</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) A string containing concatenated names\nfor the subject, an alternative to the <code>subject</code> names.</li>\n<li><code>infoAccess</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\" class=\"type\">&lt;Array&gt;</a> (Optional) An array describing the AuthorityInfoAccess,\nused with OCSP.</li>\n<li><code>issuerCertificate</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> (Optional) The issuer certificate object. For\nself-signed certificates, this may be a circular reference.</li>\n</ul>\n<p>The certificate may contain information about the public key, depending on\nthe key type.</p>\n<p>For RSA keys, the following properties may be defined:</p>\n<ul>\n<li><code>bits</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The RSA bit size. Example: <code>1024</code>.</li>\n<li><code>exponent</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The RSA exponent, as a string in hexadecimal number\nnotation. Example: <code>'0x010001'</code>.</li>\n<li><code>modulus</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The RSA modulus, as a hexadecimal string. Example:\n<code>'B56CE45CB7...'</code>.</li>\n<li><code>pubkey</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The public key.</li>\n</ul>\n<p>For EC keys, the following properties may be defined:</p>\n<ul>\n<li><code>pubkey</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The public key.</li>\n<li><code>bits</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The key size in bits. Example: <code>256</code>.</li>\n<li><code>asn1Curve</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) The ASN.1 name of the OID of the elliptic\ncurve. Well-known curves are identified by an OID. While it is unusual, it is\npossible that the curve is identified by its mathematical properties, in which\ncase it will not have an OID. Example: <code>'prime256v1'</code>.</li>\n<li><code>nistCurve</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) The NIST name for the elliptic curve, if it\nhas one (not all well-known curves have been assigned names by NIST). Example:\n<code>'P-256'</code>.</li>\n</ul>\n<p>Example certificate:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{ subject:\n   { OU: [ 'Domain Control Validated', 'PositiveSSL Wildcard' ],\n     CN: '*.nodejs.org' },\n  issuer:\n   { C: 'GB',\n     ST: 'Greater Manchester',\n     L: 'Salford',\n     O: 'COMODO CA Limited',\n     CN: 'COMODO RSA Domain Validation Secure Server CA' },\n  subjectaltname: 'DNS:*.nodejs.org, DNS:nodejs.org',\n  infoAccess:\n   { 'CA Issuers - URI':\n      [ 'http://crt.comodoca.com/COMODORSADomainValidationSecureServerCA.crt' ],\n     'OCSP - URI': [ 'http://ocsp.comodoca.com' ] },\n  modulus: 'B56CE45CB740B09A13F64AC543B712FF9EE8E4C284B542A1708A27E82A8D151CA178153E12E6DDA15BF70FFD96CB8A88618641BDFCCA03527E665B70D779C8A349A6F88FD4EF6557180BD4C98192872BCFE3AF56E863C09DDD8BC1EC58DF9D94F914F0369102B2870BECFA1348A0838C9C49BD1C20124B442477572347047506B1FCD658A80D0C44BCC16BC5C5496CFE6E4A8428EF654CD3D8972BF6E5BFAD59C93006830B5EB1056BBB38B53D1464FA6E02BFDF2FF66CD949486F0775EC43034EC2602AEFBF1703AD221DAA2A88353C3B6A688EFE8387811F645CEED7B3FE46E1F8B9F59FAD028F349B9BC14211D5830994D055EEA3D547911E07A0ADDEB8A82B9188E58720D95CD478EEC9AF1F17BE8141BE80906F1A339445A7EB5B285F68039B0F294598A7D1C0005FC22B5271B0752F58CCDEF8C8FD856FB7AE21C80B8A2CE983AE94046E53EDE4CB89F42502D31B5360771C01C80155918637490550E3F555E2EE75CC8C636DDE3633CFEDD62E91BF0F7688273694EEEBA20C2FC9F14A2A435517BC1D7373922463409AB603295CEB0BB53787A334C9CA3CA8B30005C5A62FC0715083462E00719A8FA3ED0A9828C3871360A73F8B04A4FC1E71302844E9BB9940B77E745C9D91F226D71AFCAD4B113AAF68D92B24DDB4A2136B55A1CD1ADF39605B63CB639038ED0F4C987689866743A68769CC55847E4A06D6E2E3F1',\n  exponent: '0x10001',\n  pubkey: &#x3C;Buffer ... >,\n  valid_from: 'Aug 14 00:00:00 2017 GMT',\n  valid_to: 'Nov 20 23:59:59 2019 GMT',\n  fingerprint: '01:02:59:D9:C3:D2:0D:08:F7:82:4E:44:A4:B4:53:C5:E2:3A:87:4D',\n  fingerprint256: '69:AE:1A:6A:D4:3D:C6:C1:1B:EA:C6:23:DE:BA:2A:14:62:62:93:5C:7A:EA:06:41:9B:0B:BC:87:CE:48:4E:02',\n  ext_key_usage: [ '1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2' ],\n  serialNumber: '66593D57F20CBC573E433381B5FEC280',\n  raw: &#x3C;Buffer ... > }\n</code></pre>",
                   "type": "module",
                   "displayName": "Certificate object"
                 }
@@ -51132,7 +56695,7 @@
               "name": "exportKeyingMaterial",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -51478,7 +57041,13 @@
             "added": [
               "v0.8.4"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.18.3",
+                "pr-url": "https://github.com/nodejs-private/node-private/pull/300",
+                "description": "Support for `uniformResourceIdentifier` subject alternative names has been disabled in response to CVE-2021-44531."
+              }
+            ]
           },
           "signatures": [
             {
@@ -51503,7 +57072,7 @@
               ]
             }
           ],
-          "desc": "<p>Verifies the certificate <code>cert</code> is issued to <code>hostname</code>.</p>\n<p>Returns <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\" class=\"type\">&lt;Error&gt;</a> object, populating it with <code>reason</code>, <code>host</code>, and <code>cert</code> on\nfailure. On success, returns <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type\" class=\"type\">&lt;undefined&gt;</a>.</p>\n<p>This function can be overwritten by providing alternative function as part of\nthe <code>options.checkServerIdentity</code> option passed to <code>tls.connect()</code>. The\noverwriting function can call <code>tls.checkServerIdentity()</code> of course, to augment\nthe checks done with additional verification.</p>\n<p>This function is only called if the certificate passed all other checks, such as\nbeing issued by trusted CA (<code>options.ca</code>).</p>"
+          "desc": "<p>Verifies the certificate <code>cert</code> is issued to <code>hostname</code>.</p>\n<p>Returns <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\" class=\"type\">&lt;Error&gt;</a> object, populating it with <code>reason</code>, <code>host</code>, and <code>cert</code> on\nfailure. On success, returns <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type\" class=\"type\">&lt;undefined&gt;</a>.</p>\n<p>This function can be overwritten by providing alternative function as part of\nthe <code>options.checkServerIdentity</code> option passed to <code>tls.connect()</code>. The\noverwriting function can call <code>tls.checkServerIdentity()</code> of course, to augment\nthe checks done with additional verification.</p>\n<p>This function is only called if the certificate passed all other checks, such as\nbeing issued by trusted CA (<code>options.ca</code>).</p>\n<p>Earlier versions of Node.js incorrectly accepted certificates for a given\n<code>hostname</code> if a matching <code>uniformResourceIdentifier</code> subject alternative name\nwas present (see <a href=\"https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531\">CVE-2021-44531</a>). Applications that wish to accept\n<code>uniformResourceIdentifier</code> subject alternative names can use a custom\n<code>options.checkServerIdentity</code> function that implements the desired behavior.</p>"
         },
         {
           "textRaw": "`tls.connect(options[, callback])`",
@@ -51515,7 +57084,20 @@
             ],
             "changes": [
               {
-                "version": "v12.16.0",
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/35753",
+                "description": "Added `onread` option."
+              },
+              {
+                "version": "v14.1.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32786",
+                "description": "The `highWaterMark` option is accepted now."
+              },
+              {
+                "version": [
+                  "v13.6.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/23188",
                 "description": "The `pskCallback` option is now supported."
               },
@@ -51535,7 +57117,10 @@
                 "description": "The `enableTrace` option is now supported."
               },
               {
-                "version": "v11.8.0",
+                "version": [
+                  "v11.8.0",
+                  "v10.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/25517",
                 "description": "The `timeout` option is supported now."
               },
@@ -51550,7 +57135,10 @@
                 "description": "The `ALPNProtocols` option can be a `TypedArray` or `DataView` now."
               },
               {
-                "version": "v5.3.0, v4.7.0",
+                "version": [
+                  "v5.3.0",
+                  "v4.7.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/4246",
                 "description": "The `secureContext` option is supported now."
               },
@@ -51605,11 +57193,11 @@
                       "desc": "Establish secure connection on a given socket rather than creating a new socket. Typically, this is an instance of [`net.Socket`][], but any `Duplex` stream is allowed. If this option is specified, `path`, `host` and `port` are ignored, except for certificate validation. Usually, a socket is already connected when passed to `tls.connect()`, but it can be connected later. Connection/disconnection/destruction of `socket` is the user's responsibility; calling `tls.connect()` will not cause `net.connect()` to be called."
                     },
                     {
-                      "textRaw": "`allowHalfOpen` {boolean} If the `socket` option is missing, indicates whether or not to allow the internally created socket to be half-open, otherwise the option is ignored. See the `allowHalfOpen` option of [`net.Socket`][] for details. **Default:** `false`.",
+                      "textRaw": "`allowHalfOpen` {boolean} If set to `false`, then the socket will automatically end the writable side when the readable side ends. If the `socket` option is set, this option has no effect. See the `allowHalfOpen` option of [`net.Socket`][] for details. **Default:** `false`.",
                       "name": "allowHalfOpen",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "If the `socket` option is missing, indicates whether or not to allow the internally created socket to be half-open, otherwise the option is ignored. See the `allowHalfOpen` option of [`net.Socket`][] for details."
+                      "desc": "If set to `false`, then the socket will automatically end the writable side when the readable side ends. If the `socket` option is set, this option has no effect. See the `allowHalfOpen` option of [`net.Socket`][] for details."
                     },
                     {
                       "textRaw": "`rejectUnauthorized` {boolean} If not `false`, the server certificate is verified against the list of supplied CAs. An `'error'` event is emitted if verification fails; `err.code` contains the OpenSSL error code. **Default:** `true`.",
@@ -51619,9 +57207,10 @@
                       "desc": "If not `false`, the server certificate is verified against the list of supplied CAs. An `'error'` event is emitted if verification fails; `err.code` contains the OpenSSL error code."
                     },
                     {
-                      "textRaw": "`pskCallback` {Function}",
+                      "textRaw": "`pskCallback` {Function}When negotiating TLS-PSK (pre-shared keys), this function is called with optional identity `hint` provided by the server or `null` in case of TLS 1.3 where `hint` was removed. It will be necessary to provide a custom `tls.checkServerIdentity()` for the connection as the default one will try to check host name/IP of the server against the certificate but that's not applicable for PSK because there won't be a certificate present. More information can be found in the [RFC 4279][].",
                       "name": "pskCallback",
                       "type": "Function",
+                      "desc": "When negotiating TLS-PSK (pre-shared keys), this function is called with optional identity `hint` provided by the server or `null` in case of TLS 1.3 where `hint` was removed. It will be necessary to provide a custom `tls.checkServerIdentity()` for the connection as the default one will try to check host name/IP of the server against the certificate but that's not applicable for PSK because there won't be a certificate present. More information can be found in the [RFC 4279][].",
                       "options": [
                         {
                           "textRaw": "hint: {string} optional message sent from the server to help client decide which identity to use during negotiation. Always `null` if TLS 1.3 is used.",
@@ -51630,10 +57219,10 @@
                           "desc": "optional message sent from the server to help client decide which identity to use during negotiation. Always `null` if TLS 1.3 is used."
                         },
                         {
-                          "textRaw": "Returns: {Object} in the form `{ psk: <Buffer|TypedArray|DataView>, identity: <string> }` or `null` to stop the negotiation process. `psk` must be compatible with the selected cipher's digest. `identity` must use UTF-8 encoding. When negotiating TLS-PSK (pre-shared keys), this function is called with optional identity `hint` provided by the server or `null` in case of TLS 1.3 where `hint` was removed. It will be necessary to provide a custom `tls.checkServerIdentity()` for the connection as the default one will try to check host name/IP of the server against the certificate but that's not applicable for PSK because there won't be a certificate present. More information can be found in the [RFC 4279][].",
+                          "textRaw": "Returns: {Object} in the form `{ psk: <Buffer|TypedArray|DataView>, identity: <string> }` or `null` to stop the negotiation process. `psk` must be compatible with the selected cipher's digest. `identity` must use UTF-8 encoding.",
                           "name": "return",
                           "type": "Object",
-                          "desc": "in the form `{ psk: <Buffer|TypedArray|DataView>, identity: <string> }` or `null` to stop the negotiation process. `psk` must be compatible with the selected cipher's digest. `identity` must use UTF-8 encoding. When negotiating TLS-PSK (pre-shared keys), this function is called with optional identity `hint` provided by the server or `null` in case of TLS 1.3 where `hint` was removed. It will be necessary to provide a custom `tls.checkServerIdentity()` for the connection as the default one will try to check host name/IP of the server against the certificate but that's not applicable for PSK because there won't be a certificate present. More information can be found in the [RFC 4279][]."
+                          "desc": "in the form `{ psk: <Buffer|TypedArray|DataView>, identity: <string> }` or `null` to stop the negotiation process. `psk` must be compatible with the selected cipher's digest. `identity` must use UTF-8 encoding."
                         }
                       ]
                     },
@@ -51667,11 +57256,24 @@
                       "default": "`1024`",
                       "desc": "Minimum size of the DH parameter in bits to accept a TLS connection. When a server offers a DH parameter with a size less than `minDHSize`, the TLS connection is destroyed and an error is thrown."
                     },
+                    {
+                      "textRaw": "`highWaterMark`: {number} Consistent with the readable stream `highWaterMark` parameter. **Default:** `16 * 1024`.",
+                      "name": "highWaterMark",
+                      "type": "number",
+                      "default": "`16 * 1024`",
+                      "desc": "Consistent with the readable stream `highWaterMark` parameter."
+                    },
                     {
                       "textRaw": "`secureContext`: TLS context object created with [`tls.createSecureContext()`][]. If a `secureContext` is _not_ provided, one will be created by passing the entire `options` object to `tls.createSecureContext()`.",
                       "name": "secureContext",
                       "desc": "TLS context object created with [`tls.createSecureContext()`][]. If a `secureContext` is _not_ provided, one will be created by passing the entire `options` object to `tls.createSecureContext()`."
                     },
+                    {
+                      "textRaw": "`onread` {Object} If the `socket` option is missing, incoming data is stored in a single `buffer` and passed to the supplied `callback` when data arrives on the socket, otherwise the option is ignored. See the `onread` option of [`net.Socket`][] for details.",
+                      "name": "onread",
+                      "type": "Object",
+                      "desc": "If the `socket` option is missing, incoming data is stored in a single `buffer` and passed to the supplied `callback` when data arrives on the socket, otherwise the option is ignored. See the `onread` option of [`net.Socket`][] for details."
+                    },
                     {
                       "textRaw": "...: [`tls.createSecureContext()`][] options that are used if the `secureContext` option is missing, otherwise they are ignored.",
                       "name": "...",
@@ -51812,7 +57414,10 @@
                 "description": "The `ca:` option now supports `BEGIN TRUSTED CERTIFICATE`."
               },
               {
-                "version": "v11.4.0",
+                "version": [
+                  "v11.4.0",
+                  "v10.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/24405",
                 "description": "The `minVersion` and `maxVersion` can be used to restrict the allowed TLS protocol versions."
               },
@@ -51925,18 +57530,18 @@
                       "desc": "Identifier of a private key managed by an OpenSSL engine. Should be used together with `privateKeyEngine`. Should not be set together with `key`, because both options define a private key in different ways."
                     },
                     {
-                      "textRaw": "`maxVersion` {string} Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other. **Default:** [`tls.DEFAULT_MAX_VERSION`][].",
+                      "textRaw": "`maxVersion` {string} Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option; use one or the other. **Default:** [`tls.DEFAULT_MAX_VERSION`][].",
                       "name": "maxVersion",
                       "type": "string",
                       "default": "[`tls.DEFAULT_MAX_VERSION`][]",
-                      "desc": "Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other."
+                      "desc": "Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option; use one or the other."
                     },
                     {
-                      "textRaw": "`minVersion` {string} Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other. It is not recommended to use less than TLSv1.2, but it may be required for interoperability. **Default:** [`tls.DEFAULT_MIN_VERSION`][].",
+                      "textRaw": "`minVersion` {string} Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option; use one or the other. Avoid setting to less than TLSv1.2, but it may be required for interoperability. **Default:** [`tls.DEFAULT_MIN_VERSION`][].",
                       "name": "minVersion",
                       "type": "string",
                       "default": "[`tls.DEFAULT_MIN_VERSION`][]",
-                      "desc": "Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other. It is not recommended to use less than TLSv1.2, but it may be required for interoperability."
+                      "desc": "Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option; use one or the other. Avoid setting to less than TLSv1.2, but it may be required for interoperability."
                     },
                     {
                       "textRaw": "`passphrase` {string} Shared passphrase used for a single private key and/or a PFX.",
@@ -52205,9 +57810,10 @@
                       "desc": "48-bytes of cryptographically strong pseudo-random data. See [Session Resumption][] for more information."
                     },
                     {
-                      "textRaw": "`pskCallback` {Function}",
+                      "textRaw": "`pskCallback` {Function}When negotiating TLS-PSK (pre-shared keys), this function is called with the identity provided by the client. If the return value is `null` the negotiation process will stop and an \"unknown_psk_identity\" alert message will be sent to the other party. If the server wishes to hide the fact that the PSK identity was not known, the callback must provide some random data as `psk` to make the connection fail with \"decrypt_error\" before negotiation is finished. PSK ciphers are disabled by default, and using TLS-PSK thus requires explicitly specifying a cipher suite with the `ciphers` option. More information can be found in the [RFC 4279][].",
                       "name": "pskCallback",
                       "type": "Function",
+                      "desc": "When negotiating TLS-PSK (pre-shared keys), this function is called with the identity provided by the client. If the return value is `null` the negotiation process will stop and an \"unknown_psk_identity\" alert message will be sent to the other party. If the server wishes to hide the fact that the PSK identity was not known, the callback must provide some random data as `psk` to make the connection fail with \"decrypt_error\" before negotiation is finished. PSK ciphers are disabled by default, and using TLS-PSK thus requires explicitly specifying a cipher suite with the `ciphers` option. More information can be found in the [RFC 4279][].",
                       "options": [
                         {
                           "textRaw": "socket: {tls.TLSSocket} the server [`tls.TLSSocket`][] instance for this connection.",
@@ -52222,10 +57828,10 @@
                           "desc": "identity parameter sent from the client."
                         },
                         {
-                          "textRaw": "Returns: {Buffer|TypedArray|DataView} pre-shared key that must either be a buffer or `null` to stop the negotiation process. Returned PSK must be compatible with the selected cipher's digest. When negotiating TLS-PSK (pre-shared keys), this function is called with the identity provided by the client. If the return value is `null` the negotiation process will stop and an \"unknown_psk_identity\" alert message will be sent to the other party. If the server wishes to hide the fact that the PSK identity was not known, the callback must provide some random data as `psk` to make the connection fail with \"decrypt_error\" before negotiation is finished. PSK ciphers are disabled by default, and using TLS-PSK thus requires explicitly specifying a cipher suite with the `ciphers` option. More information can be found in the [RFC 4279][].",
+                          "textRaw": "Returns: {Buffer|TypedArray|DataView} pre-shared key that must either be a buffer or `null` to stop the negotiation process. Returned PSK must be compatible with the selected cipher's digest.",
                           "name": "return",
                           "type": "Buffer|TypedArray|DataView",
-                          "desc": "pre-shared key that must either be a buffer or `null` to stop the negotiation process. Returned PSK must be compatible with the selected cipher's digest. When negotiating TLS-PSK (pre-shared keys), this function is called with the identity provided by the client. If the return value is `null` the negotiation process will stop and an \"unknown_psk_identity\" alert message will be sent to the other party. If the server wishes to hide the fact that the PSK identity was not known, the callback must provide some random data as `psk` to make the connection fail with \"decrypt_error\" before negotiation is finished. PSK ciphers are disabled by default, and using TLS-PSK thus requires explicitly specifying a cipher suite with the `ciphers` option. More information can be found in the [RFC 4279][]."
+                          "desc": "pre-shared key that must either be a buffer or `null` to stop the negotiation process. Returned PSK must be compatible with the selected cipher's digest."
                         }
                       ]
                     },
@@ -52338,7 +57944,8 @@
         }
       ],
       "type": "module",
-      "displayName": "TLS (SSL)"
+      "displayName": "TLS (SSL)",
+      "source": "doc/api/tls.md"
     },
     {
       "textRaw": "Trace events",
@@ -52346,7 +57953,7 @@
       "introduced_in": "v7.7.0",
       "stability": 1,
       "stabilityText": "Experimental",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/trace_events.js\">lib/trace_events.js</a></p>\n<p>The <code>trace_events</code> module provides a mechanism to centralize tracing information\ngenerated by V8, Node.js core, and userspace code.</p>\n<p>Tracing can be enabled with the <code>--trace-event-categories</code> command-line flag\nor by using the <code>trace_events</code> module. The <code>--trace-event-categories</code> flag\naccepts a list of comma-separated category names.</p>\n<p>The available categories are:</p>\n<ul>\n<li><code>node</code>: An empty placeholder.</li>\n<li><code>node.async_hooks</code>: Enables capture of detailed <a href=\"async_hooks.html\"><code>async_hooks</code></a> trace data.\nThe <a href=\"async_hooks.html\"><code>async_hooks</code></a> events have a unique <code>asyncId</code> and a special <code>triggerId</code>\n<code>triggerAsyncId</code> property.</li>\n<li><code>node.bootstrap</code>: Enables capture of Node.js bootstrap milestones.</li>\n<li><code>node.console</code>: Enables capture of <code>console.time()</code> and <code>console.count()</code>\noutput.</li>\n<li><code>node.dns.native</code>: Enables capture of trace data for DNS queries.</li>\n<li><code>node.environment</code>: Enables capture of Node.js Environment milestones.</li>\n<li><code>node.fs.sync</code>: Enables capture of trace data for file system sync methods.</li>\n<li><code>node.perf</code>: Enables capture of <a href=\"perf_hooks.html\">Performance API</a> measurements.\n<ul>\n<li><code>node.perf.usertiming</code>: Enables capture of only Performance API User Timing\nmeasures and marks.</li>\n<li><code>node.perf.timerify</code>: Enables capture of only Performance API timerify\nmeasurements.</li>\n</ul>\n</li>\n<li><code>node.promises.rejections</code>: Enables capture of trace data tracking the number\nof unhandled Promise rejections and handled-after-rejections.</li>\n<li><code>node.vm.script</code>: Enables capture of trace data for the <code>vm</code> module's\n<code>runInNewContext()</code>, <code>runInContext()</code>, and <code>runInThisContext()</code> methods.</li>\n<li><code>v8</code>: The <a href=\"v8.html\">V8</a> events are GC, compiling, and execution related.</li>\n</ul>\n<p>By default the <code>node</code>, <code>node.async_hooks</code>, and <code>v8</code> categories are enabled.</p>\n<pre><code class=\"language-bash\">node --trace-event-categories v8,node,node.async_hooks server.js\n</code></pre>\n<p>Prior versions of Node.js required the use of the <code>--trace-events-enabled</code>\nflag to enable trace events. This requirement has been removed. However, the\n<code>--trace-events-enabled</code> flag <em>may</em> still be used and will enable the\n<code>node</code>, <code>node.async_hooks</code>, and <code>v8</code> trace event categories by default.</p>\n<pre><code class=\"language-bash\">node --trace-events-enabled\n\n# is equivalent to\n\nnode --trace-event-categories v8,node,node.async_hooks\n</code></pre>\n<p>Alternatively, trace events may be enabled using the <code>trace_events</code> module:</p>\n<pre><code class=\"language-js\">const trace_events = require('trace_events');\nconst tracing = trace_events.createTracing({ categories: ['node.perf'] });\ntracing.enable();  // Enable trace event capture for the 'node.perf' category\n\n// do work\n\ntracing.disable();  // Disable trace event capture for the 'node.perf' category\n</code></pre>\n<p>Running Node.js with tracing enabled will produce log files that can be opened\nin the <a href=\"https://www.chromium.org/developers/how-tos/trace-event-profiling-tool\"><code>chrome://tracing</code></a>\ntab of Chrome.</p>\n<p>The logging file is by default called <code>node_trace.${rotation}.log</code>, where\n<code>${rotation}</code> is an incrementing log-rotation id. The filepath pattern can\nbe specified with <code>--trace-event-file-pattern</code> that accepts a template\nstring that supports <code>${rotation}</code> and <code>${pid}</code>:</p>\n<pre><code class=\"language-bash\">node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js\n</code></pre>\n<p>The tracing system uses the same time source\nas the one used by <code>process.hrtime()</code>.\nHowever the trace-event timestamps are expressed in microseconds,\nunlike <code>process.hrtime()</code> which returns nanoseconds.</p>\n<p>The features from this module are not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/trace_events.js\">lib/trace_events.js</a></p>\n<p>The <code>trace_events</code> module provides a mechanism to centralize tracing information\ngenerated by V8, Node.js core, and userspace code.</p>\n<p>Tracing can be enabled with the <code>--trace-event-categories</code> command-line flag\nor by using the <code>trace_events</code> module. The <code>--trace-event-categories</code> flag\naccepts a list of comma-separated category names.</p>\n<p>The available categories are:</p>\n<ul>\n<li><code>node</code>: An empty placeholder.</li>\n<li><code>node.async_hooks</code>: Enables capture of detailed <a href=\"async_hooks.html\"><code>async_hooks</code></a> trace data.\nThe <a href=\"async_hooks.html\"><code>async_hooks</code></a> events have a unique <code>asyncId</code> and a special <code>triggerId</code>\n<code>triggerAsyncId</code> property.</li>\n<li><code>node.bootstrap</code>: Enables capture of Node.js bootstrap milestones.</li>\n<li><code>node.console</code>: Enables capture of <code>console.time()</code> and <code>console.count()</code>\noutput.</li>\n<li><code>node.dns.native</code>: Enables capture of trace data for DNS queries.</li>\n<li><code>node.environment</code>: Enables capture of Node.js Environment milestones.</li>\n<li><code>node.fs.sync</code>: Enables capture of trace data for file system sync methods.</li>\n<li><code>node.perf</code>: Enables capture of <a href=\"perf_hooks.html\">Performance API</a> measurements.\n<ul>\n<li><code>node.perf.usertiming</code>: Enables capture of only Performance API User Timing\nmeasures and marks.</li>\n<li><code>node.perf.timerify</code>: Enables capture of only Performance API timerify\nmeasurements.</li>\n</ul>\n</li>\n<li><code>node.promises.rejections</code>: Enables capture of trace data tracking the number\nof unhandled Promise rejections and handled-after-rejections.</li>\n<li><code>node.vm.script</code>: Enables capture of trace data for the <code>vm</code> module's\n<code>runInNewContext()</code>, <code>runInContext()</code>, and <code>runInThisContext()</code> methods.</li>\n<li><code>v8</code>: The <a href=\"v8.html\">V8</a> events are GC, compiling, and execution related.</li>\n</ul>\n<p>By default the <code>node</code>, <code>node.async_hooks</code>, and <code>v8</code> categories are enabled.</p>\n<pre><code class=\"language-bash\">node --trace-event-categories v8,node,node.async_hooks server.js\n</code></pre>\n<p>Prior versions of Node.js required the use of the <code>--trace-events-enabled</code>\nflag to enable trace events. This requirement has been removed. However, the\n<code>--trace-events-enabled</code> flag <em>may</em> still be used and will enable the\n<code>node</code>, <code>node.async_hooks</code>, and <code>v8</code> trace event categories by default.</p>\n<pre><code class=\"language-bash\">node --trace-events-enabled\n\n# is equivalent to\n\nnode --trace-event-categories v8,node,node.async_hooks\n</code></pre>\n<p>Alternatively, trace events may be enabled using the <code>trace_events</code> module:</p>\n<pre><code class=\"language-js\">const trace_events = require('trace_events');\nconst tracing = trace_events.createTracing({ categories: ['node.perf'] });\ntracing.enable();  // Enable trace event capture for the 'node.perf' category\n\n// do work\n\ntracing.disable();  // Disable trace event capture for the 'node.perf' category\n</code></pre>\n<p>Running Node.js with tracing enabled will produce log files that can be opened\nin the <a href=\"https://www.chromium.org/developers/how-tos/trace-event-profiling-tool\"><code>chrome://tracing</code></a>\ntab of Chrome.</p>\n<p>The logging file is by default called <code>node_trace.${rotation}.log</code>, where\n<code>${rotation}</code> is an incrementing log-rotation id. The filepath pattern can\nbe specified with <code>--trace-event-file-pattern</code> that accepts a template\nstring that supports <code>${rotation}</code> and <code>${pid}</code>:</p>\n<pre><code class=\"language-bash\">node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js\n</code></pre>\n<p>The tracing system uses the same time source\nas the one used by <code>process.hrtime()</code>.\nHowever the trace-event timestamps are expressed in microseconds,\nunlike <code>process.hrtime()</code> which returns nanoseconds.</p>\n<p>The features from this module are not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>",
       "modules": [
         {
           "textRaw": "The `trace_events` module",
@@ -52500,7 +58107,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Trace events"
+      "displayName": "Trace events",
+      "source": "doc/api/tracing.md"
     },
     {
       "textRaw": "TTY",
@@ -52508,7 +58116,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/tty.js\">lib/tty.js</a></p>\n<p>The <code>tty</code> module provides the <code>tty.ReadStream</code> and <code>tty.WriteStream</code> classes.\nIn most cases, it will not be necessary or possible to use this module directly.\nHowever, it can be accessed using:</p>\n<pre><code class=\"language-js\">const tty = require('tty');\n</code></pre>\n<p>When Node.js detects that it is being run with a text terminal (\"TTY\")\nattached, <a href=\"process.html#process_process_stdin\"><code>process.stdin</code></a> will, by default, be initialized as an instance of\n<code>tty.ReadStream</code> and both <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> and <a href=\"process.html#process_process_stderr\"><code>process.stderr</code></a> will, by\ndefault be instances of <code>tty.WriteStream</code>. The preferred method of determining\nwhether Node.js is being run within a TTY context is to check that the value of\nthe <code>process.stdout.isTTY</code> property is <code>true</code>:</p>\n<pre><code class=\"language-console\">$ node -p -e \"Boolean(process.stdout.isTTY)\"\ntrue\n$ node -p -e \"Boolean(process.stdout.isTTY)\" | cat\nfalse\n</code></pre>\n<p>In most cases, there should be little to no reason for an application to\nmanually create instances of the <code>tty.ReadStream</code> and <code>tty.WriteStream</code>\nclasses.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/tty.js\">lib/tty.js</a></p>\n<p>The <code>tty</code> module provides the <code>tty.ReadStream</code> and <code>tty.WriteStream</code> classes.\nIn most cases, it will not be necessary or possible to use this module directly.\nHowever, it can be accessed using:</p>\n<pre><code class=\"language-js\">const tty = require('tty');\n</code></pre>\n<p>When Node.js detects that it is being run with a text terminal (\"TTY\")\nattached, <a href=\"process.html#process_process_stdin\"><code>process.stdin</code></a> will, by default, be initialized as an instance of\n<code>tty.ReadStream</code> and both <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> and <a href=\"process.html#process_process_stderr\"><code>process.stderr</code></a> will, by\ndefault, be instances of <code>tty.WriteStream</code>. The preferred method of determining\nwhether Node.js is being run within a TTY context is to check that the value of\nthe <code>process.stdout.isTTY</code> property is <code>true</code>:</p>\n<pre><code class=\"language-console\">$ node -p -e \"Boolean(process.stdout.isTTY)\"\ntrue\n$ node -p -e \"Boolean(process.stdout.isTTY)\" | cat\nfalse\n</code></pre>\n<p>In most cases, there should be little to no reason for an application to\nmanually create instances of the <code>tty.ReadStream</code> and <code>tty.WriteStream</code>\nclasses.</p>",
       "classes": [
         {
           "textRaw": "Class: `tty.ReadStream`",
@@ -52574,7 +58182,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Allows configuration of <code>tty.ReadStream</code> so that it operates as a raw device.</p>\n<p>When in raw mode, input is always available character-by-character, not\nincluding modifiers. Additionally, all special processing of characters by the\nterminal is disabled, including echoing input characters.\n<code>CTRL</code>+<code>C</code> will no longer cause a <code>SIGINT</code> when in this mode.</p>"
+              "desc": "<p>Allows configuration of <code>tty.ReadStream</code> so that it operates as a raw device.</p>\n<p>When in raw mode, input is always available character-by-character, not\nincluding modifiers. Additionally, all special processing of characters by the\nterminal is disabled, including echoing input characters.\n<kbd>Ctrl</kbd>+<kbd>C</kbd> will no longer cause a <code>SIGINT</code> when in this mode.</p>"
             }
           ]
         },
@@ -52773,7 +58381,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns:</p>\n<ul>\n<li><code>1</code> for 2,</li>\n<li><code>4</code> for 16,</li>\n<li><code>8</code> for 256,</li>\n<li><code>24</code> for 16,777,216\ncolors supported.</li>\n</ul>\n<p>Use this to determine what colors the terminal supports. Due to the nature of\ncolors in terminals it is possible to either have false positives or false\nnegatives. It depends on process information and the environment variables that\nmay lie about what terminal is used.\nIt is possible to pass in an <code>env</code> object to simulate the usage of a specific\nterminal. This can be useful to check how specific environment settings behave.</p>\n<p>To enforce a specific color support, use one of the below environment settings.</p>\n<ul>\n<li>2 colors: <code>FORCE_COLOR = 0</code> (Disables colors)</li>\n<li>16 colors: <code>FORCE_COLOR = 1</code></li>\n<li>256 colors: <code>FORCE_COLOR = 2</code></li>\n<li>16,777,216 colors: <code>FORCE_COLOR = 3</code></li>\n</ul>\n<p>Disabling color support is also possible by using the <code>NO_COLOR</code> and\n<code>NODE_DISABLE_COLORS</code> environment variables.</p>"
+              "desc": "<p>Returns:</p>\n<ul>\n<li><code>1</code> for 2,</li>\n<li><code>4</code> for 16,</li>\n<li><code>8</code> for 256,</li>\n<li><code>24</code> for 16,777,216</li>\n</ul>\n<p>colors supported.</p>\n<p>Use this to determine what colors the terminal supports. Due to the nature of\ncolors in terminals it is possible to either have false positives or false\nnegatives. It depends on process information and the environment variables that\nmay lie about what terminal is used.\nIt is possible to pass in an <code>env</code> object to simulate the usage of a specific\nterminal. This can be useful to check how specific environment settings behave.</p>\n<p>To enforce a specific color support, use one of the below environment settings.</p>\n<ul>\n<li>2 colors: <code>FORCE_COLOR = 0</code> (Disables colors)</li>\n<li>16 colors: <code>FORCE_COLOR = 1</code></li>\n<li>256 colors: <code>FORCE_COLOR = 2</code></li>\n<li>16,777,216 colors: <code>FORCE_COLOR = 3</code></li>\n</ul>\n<p>Disabling color support is also possible by using the <code>NO_COLOR</code> and\n<code>NODE_DISABLE_COLORS</code> environment variables.</p>"
             },
             {
               "textRaw": "`writeStream.getWindowSize()`",
@@ -52795,7 +58403,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p><code>writeStream.getWindowSize()</code> returns the size of the <a href=\"tty.html\">TTY</a>\ncorresponding to this <code>WriteStream</code>. The array is of the type\n<code>[numColumns, numRows]</code> where <code>numColumns</code> and <code>numRows</code> represent the number\nof columns and rows in the corresponding <a href=\"tty.html\">TTY</a>.</p>"
+              "desc": "<p><code>writeStream.getWindowSize()</code> returns the size of the TTY\ncorresponding to this <code>WriteStream</code>. The array is of the type\n<code>[numColumns, numRows]</code> where <code>numColumns</code> and <code>numRows</code> represent the number\nof columns and rows in the corresponding TTY.</p>"
             },
             {
               "textRaw": "`writeStream.hasColors([count][, env])`",
@@ -52803,7 +58411,8 @@
               "name": "hasColors",
               "meta": {
                 "added": [
-                  "v11.13.0"
+                  "v11.13.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -52950,7 +58559,8 @@
         }
       ],
       "type": "module",
-      "displayName": "TTY"
+      "displayName": "TTY",
+      "source": "doc/api/tty.md"
     },
     {
       "textRaw": "UDP/datagram sockets",
@@ -52958,7 +58568,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/dgram.js\">lib/dgram.js</a></p>\n<p>The <code>dgram</code> module provides an implementation of UDP datagram sockets.</p>\n<pre><code class=\"language-js\">const dgram = require('dgram');\nconst server = dgram.createSocket('udp4');\n\nserver.on('error', (err) => {\n  console.log(`server error:\\n${err.stack}`);\n  server.close();\n});\n\nserver.on('message', (msg, rinfo) => {\n  console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);\n});\n\nserver.on('listening', () => {\n  const address = server.address();\n  console.log(`server listening ${address.address}:${address.port}`);\n});\n\nserver.bind(41234);\n// Prints: server listening 0.0.0.0:41234\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/dgram.js\">lib/dgram.js</a></p>\n<p>The <code>dgram</code> module provides an implementation of UDP datagram sockets.</p>\n<pre><code class=\"language-js\">const dgram = require('dgram');\nconst server = dgram.createSocket('udp4');\n\nserver.on('error', (err) => {\n  console.log(`server error:\\n${err.stack}`);\n  server.close();\n});\n\nserver.on('message', (msg, rinfo) => {\n  console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);\n});\n\nserver.on('listening', () => {\n  const address = server.address();\n  console.log(`server listening ${address.address}:${address.port}`);\n});\n\nserver.bind(41234);\n// Prints: server listening 0.0.0.0:41234\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `dgram.Socket`",
@@ -53079,6 +58689,7 @@
               "name": "addSourceSpecificMembership",
               "meta": {
                 "added": [
+                  "v13.1.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -53138,7 +58749,8 @@
                 ],
                 "changes": [
                   {
-                    "version": "v0.10",
+                    "version": "v0.9.1",
+                    "commit": "332fea5ac1816e498030109c4211bca24a7fa667",
                     "description": "The method was changed to an asynchronous execution model. Legacy code would need to be changed to pass a callback function to the method call."
                   }
                 ]
@@ -53327,6 +58939,7 @@
               "name": "dropSourceSpecificMembership",
               "meta": {
                 "added": [
+                  "v13.1.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -53454,10 +59067,15 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22413",
                     "description": "The `msg` parameter can now be any `TypedArray` or `DataView`."
                   },
+                  {
+                    "version": "v12.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/26871",
+                    "description": "Added support for sending data on connected sockets."
+                  },
                   {
                     "version": "v8.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/11985",
@@ -53477,11 +59095,6 @@
                     "version": "v5.7.0",
                     "pr-url": "https://github.com/nodejs/node/pull/4374",
                     "description": "The `msg` parameter can be an array now. Also, the `offset` and `length` parameters are optional now."
-                  },
-                  {
-                    "version": "v12.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/26871",
-                    "description": "Added support for sending data on connected sockets."
                   }
                 ]
               },
@@ -53748,9 +59361,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v8.6.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/14560",
-                    "description": "The `lookup` option is supported."
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37026",
+                    "description": "AbortSignal support was added."
+                  },
+                  {
+                    "version": "v11.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23798",
+                    "description": "The `ipv6Only` option is supported."
                   },
                   {
                     "version": "v8.7.0",
@@ -53758,9 +59376,9 @@
                     "description": "The `recvBufferSize` and `sendBufferSize` options are supported now."
                   },
                   {
-                    "version": "v11.4.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/23798",
-                    "description": "The `ipv6Only` option is supported."
+                    "version": "v8.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/14560",
+                    "description": "The `lookup` option is supported."
                   }
                 ]
               },
@@ -53816,6 +59434,12 @@
                           "type": "Function",
                           "default": "[`dns.lookup()`][]",
                           "desc": "Custom lookup function."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} An AbortSignal that may be used to close a socket.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "An AbortSignal that may be used to close a socket."
                         }
                       ]
                     },
@@ -53828,7 +59452,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Creates a <code>dgram.Socket</code> object. Once the socket is created, calling\n<a href=\"dgram.html#dgram_socket_bind_port_address_callback\"><code>socket.bind()</code></a> will instruct the socket to begin listening for datagram\nmessages. When <code>address</code> and <code>port</code> are not passed to <a href=\"dgram.html#dgram_socket_bind_port_address_callback\"><code>socket.bind()</code></a> the\nmethod will bind the socket to the \"all interfaces\" address on a random port\n(it does the right thing for both <code>udp4</code> and <code>udp6</code> sockets). The bound address\nand port can be retrieved using <a href=\"dgram.html#dgram_socket_address\"><code>socket.address().address</code></a> and\n<a href=\"dgram.html#dgram_socket_address\"><code>socket.address().port</code></a>.</p>"
+              "desc": "<p>Creates a <code>dgram.Socket</code> object. Once the socket is created, calling\n<a href=\"dgram.html#dgram_socket_bind_port_address_callback\"><code>socket.bind()</code></a> will instruct the socket to begin listening for datagram\nmessages. When <code>address</code> and <code>port</code> are not passed to <a href=\"dgram.html#dgram_socket_bind_port_address_callback\"><code>socket.bind()</code></a> the\nmethod will bind the socket to the \"all interfaces\" address on a random port\n(it does the right thing for both <code>udp4</code> and <code>udp6</code> sockets). The bound address\nand port can be retrieved using <a href=\"dgram.html#dgram_socket_address\"><code>socket.address().address</code></a> and\n<a href=\"dgram.html#dgram_socket_address\"><code>socket.address().port</code></a>.</p>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.close()</code> on the socket:</p>\n<pre><code class=\"language-js\">const controller = new AbortController();\nconst { signal } = controller;\nconst server = dgram.createSocket({ type: 'udp4', signal });\nserver.on('message', (msg, rinfo) => {\n  console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);\n});\n// Later, when you want to close the server.\ncontroller.abort();\n</code></pre>"
             },
             {
               "textRaw": "`dgram.createSocket(type[, callback])`",
@@ -53871,7 +59495,8 @@
         }
       ],
       "type": "module",
-      "displayName": "dgram"
+      "displayName": "dgram",
+      "source": "doc/api/dgram.md"
     },
     {
       "textRaw": "URL",
@@ -53879,12 +59504,21 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/url.js\">lib/url.js</a></p>\n<p>The <code>url</code> module provides utilities for URL resolution and parsing. It can be\naccessed using:</p>\n<pre><code class=\"language-js\">const url = require('url');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/url.js\">lib/url.js</a></p>\n<p>The <code>url</code> module provides utilities for URL resolution and parsing. It can be\naccessed using:</p>\n<pre><code class=\"language-js\">const url = require('url');\n</code></pre>",
       "modules": [
         {
           "textRaw": "URL strings and URL objects",
           "name": "url_strings_and_url_objects",
-          "desc": "<p>A URL string is a structured string containing multiple meaningful components.\nWhen parsed, a URL object is returned containing properties for each of these\ncomponents.</p>\n<p>The <code>url</code> module provides two APIs for working with URLs: a legacy API that is\nNode.js specific, and a newer API that implements the same\n<a href=\"https://url.spec.whatwg.org/\">WHATWG URL Standard</a> used by web browsers.</p>\n<p>A comparison between the WHATWG and Legacy APIs is provided below. Above the URL\n<code>'http://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>, properties\nof an object returned by the legacy <code>url.parse()</code> are shown. Below it are\nproperties of a WHATWG <code>URL</code> object.</p>\n<p>WHATWG URL's <code>origin</code> property includes <code>protocol</code> and <code>host</code>, but not\n<code>username</code> or <code>password</code>.</p>\n<pre><code class=\"language-text\">┌────────────────────────────────────────────────────────────────────────────────────────────────┐\n│                                              href                                              │\n├──────────┬──┬─────────────────────┬────────────────────────┬───────────────────────────┬───────┤\n│ protocol │  │        auth         │          host          │           path            │ hash  │\n│          │  │                     ├─────────────────┬──────┼──────────┬────────────────┤       │\n│          │  │                     │    hostname     │ port │ pathname │     search     │       │\n│          │  │                     │                 │      │          ├─┬──────────────┤       │\n│          │  │                     │                 │      │          │ │    query     │       │\n\"  https:   //    user   :   pass   @ sub.example.com : 8080   /p/a/t/h  ?  query=string   #hash \"\n│          │  │          │          │    hostname     │ port │          │                │       │\n│          │  │          │          ├─────────────────┴──────┤          │                │       │\n│ protocol │  │ username │ password │          host          │          │                │       │\n├──────────┴──┼──────────┴──────────┼────────────────────────┤          │                │       │\n│   origin    │                     │         origin         │ pathname │     search     │ hash  │\n├─────────────┴─────────────────────┴────────────────────────┴──────────┴────────────────┴───────┤\n│                                              href                                              │\n└────────────────────────────────────────────────────────────────────────────────────────────────┘\n(All spaces in the \"\" line should be ignored. They are purely for formatting.)\n</code></pre>\n<p>Parsing the URL string using the WHATWG API:</p>\n<pre><code class=\"language-js\">const myURL =\n  new URL('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');\n</code></pre>\n<p>Parsing the URL string using the Legacy API:</p>\n<pre><code class=\"language-js\">const url = require('url');\nconst myURL =\n  url.parse('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');\n</code></pre>",
+          "desc": "<p>A URL string is a structured string containing multiple meaningful components.\nWhen parsed, a URL object is returned containing properties for each of these\ncomponents.</p>\n<p>The <code>url</code> module provides two APIs for working with URLs: a legacy API that is\nNode.js specific, and a newer API that implements the same\n<a href=\"https://url.spec.whatwg.org/\">WHATWG URL Standard</a> used by web browsers.</p>\n<p>A comparison between the WHATWG and Legacy APIs is provided below. Above the URL\n<code>'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>, properties\nof an object returned by the legacy <code>url.parse()</code> are shown. Below it are\nproperties of a WHATWG <code>URL</code> object.</p>\n<p>WHATWG URL's <code>origin</code> property includes <code>protocol</code> and <code>host</code>, but not\n<code>username</code> or <code>password</code>.</p>\n<pre><code class=\"language-text\">┌────────────────────────────────────────────────────────────────────────────────────────────────┐\n│                                              href                                              │\n├──────────┬──┬─────────────────────┬────────────────────────┬───────────────────────────┬───────┤\n│ protocol │  │        auth         │          host          │           path            │ hash  │\n│          │  │                     ├─────────────────┬──────┼──────────┬────────────────┤       │\n│          │  │                     │    hostname     │ port │ pathname │     search     │       │\n│          │  │                     │                 │      │          ├─┬──────────────┤       │\n│          │  │                     │                 │      │          │ │    query     │       │\n\"  https:   //    user   :   pass   @ sub.example.com : 8080   /p/a/t/h  ?  query=string   #hash \"\n│          │  │          │          │    hostname     │ port │          │                │       │\n│          │  │          │          ├─────────────────┴──────┤          │                │       │\n│ protocol │  │ username │ password │          host          │          │                │       │\n├──────────┴──┼──────────┴──────────┼────────────────────────┤          │                │       │\n│   origin    │                     │         origin         │ pathname │     search     │ hash  │\n├─────────────┴─────────────────────┴────────────────────────┴──────────┴────────────────┴───────┤\n│                                              href                                              │\n└────────────────────────────────────────────────────────────────────────────────────────────────┘\n(All spaces in the \"\" line should be ignored. They are purely for formatting.)\n</code></pre>\n<p>Parsing the URL string using the WHATWG API:</p>\n<pre><code class=\"language-js\">const myURL =\n  new URL('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');\n</code></pre>\n<p>Parsing the URL string using the Legacy API:</p>\n<pre><code class=\"language-js\">const url = require('url');\nconst myURL =\n  url.parse('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');\n</code></pre>",
+          "modules": [
+            {
+              "textRaw": "Constructing a URL from component parts and getting the constructed string",
+              "name": "constructing_a_url_from_component_parts_and_getting_the_constructed_string",
+              "desc": "<p>It is possible to construct a WHATWG URL from component parts using either the\nproperty setters or a template literal string:</p>\n<pre><code class=\"language-js\">const myURL = new URL('https://example.org');\nmyURL.pathname = '/a/b/c';\nmyURL.search = '?d=e';\nmyURL.hash = '#fgh';\n</code></pre>\n<pre><code class=\"language-js\">const pathname = '/a/b/c';\nconst search = '?d=e';\nconst hash = '#fgh';\nconst myURL = new URL(`https://example.org${pathname}${search}${hash}`);\n</code></pre>\n<p>To get the constructed URL string, use the <code>href</code> property accessor:</p>\n<pre><code class=\"language-js\">console.log(myURL.href);\n</code></pre>",
+              "type": "module",
+              "displayName": "Constructing a URL from component parts and getting the constructed string"
+            }
+          ],
           "type": "module",
           "displayName": "URL strings and URL objects"
         },
@@ -53927,7 +59561,7 @@
                   "textRaw": "`hostname` {string}",
                   "type": "string",
                   "name": "hostname",
-                  "desc": "<p>Gets and sets the host name portion of the URL. The key difference between\n<code>url.host</code> and <code>url.hostname</code> is that <code>url.hostname</code> does <em>not</em> include the\nport.</p>\n<pre><code class=\"language-js\">const myURL = new URL('https://example.org:81/foo');\nconsole.log(myURL.hostname);\n// Prints example.org\n\nmyURL.hostname = 'example.com:82';\nconsole.log(myURL.href);\n// Prints https://example.com:81/foo\n</code></pre>\n<p>Invalid host name values assigned to the <code>hostname</code> property are ignored.</p>"
+                  "desc": "<p>Gets and sets the host name portion of the URL. The key difference between\n<code>url.host</code> and <code>url.hostname</code> is that <code>url.hostname</code> does <em>not</em> include the\nport.</p>\n<pre><code class=\"language-js\">const myURL = new URL('https://example.org:81/foo');\nconsole.log(myURL.hostname);\n// Prints example.org\n\n// Setting the hostname does not change the port\nmyURL.hostname = 'example.com:82';\nconsole.log(myURL.href);\n// Prints https://example.com:81/foo\n\n// Use myURL.host to change the hostname and port\nmyURL.host = 'example.org:82';\nconsole.log(myURL.href);\n// Prints https://example.org:82/foo\n</code></pre>\n<p>Invalid host name values assigned to the <code>hostname</code> property are ignored.</p>"
                 },
                 {
                   "textRaw": "`href` {string}",
@@ -54024,7 +59658,7 @@
                       "params": []
                     }
                   ],
-                  "desc": "<p>The <code>toJSON()</code> method on the <code>URL</code> object returns the serialized URL. The\nvalue returned is equivalent to that of <a href=\"url.html#url_url_href\"><code>url.href</code></a> and\n<a href=\"url.html#url_url_tostring\"><code>url.toString()</code></a>.</p>\n<p>This method is automatically called when an <code>URL</code> object is serialized\nwith <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify\"><code>JSON.stringify()</code></a>.</p>\n<pre><code class=\"language-js\">const myURLs = [\n  new URL('https://www.example.com'),\n  new URL('https://test.example.org')\n];\nconsole.log(JSON.stringify(myURLs));\n// Prints [\"https://www.example.com/\",\"https://test.example.org/\"]\n</code></pre>"
+                  "desc": "<p>The <code>toJSON()</code> method on the <code>URL</code> object returns the serialized URL. The\nvalue returned is equivalent to that of <a href=\"url.html#url_url_href\"><code>url.href</code></a> and\n<a href=\"url.html#url_url_tostring\"><code>url.toString()</code></a>.</p>\n<p>This method is automatically called when an <code>URL</code> object is serialized\nwith <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify\"><code>JSON.stringify()</code></a>.</p>\n<pre><code class=\"language-js\">const myURLs = [\n  new URL('https://www.example.com'),\n  new URL('https://test.example.org'),\n];\nconsole.log(JSON.stringify(myURLs));\n// Prints [\"https://www.example.com/\",\"https://test.example.org/\"]\n</code></pre>"
                 }
               ],
               "signatures": [
@@ -54353,7 +59987,7 @@
                       "desc": "An iterable object whose elements are key-value pairs"
                     }
                   ],
-                  "desc": "<p>Instantiate a new <code>URLSearchParams</code> object with an iterable map in a way that\nis similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\"><code>Map</code></a>'s constructor. <code>iterable</code> can be an <code>Array</code> or any\niterable object. That means <code>iterable</code> can be another <code>URLSearchParams</code>, in\nwhich case the constructor will simply create a clone of the provided\n<code>URLSearchParams</code>. Elements of <code>iterable</code> are key-value pairs, and can\nthemselves be any iterable object.</p>\n<p>Duplicate keys are allowed.</p>\n<pre><code class=\"language-js\">let params;\n\n// Using an array\nparams = new URLSearchParams([\n  ['user', 'abc'],\n  ['query', 'first'],\n  ['query', 'second']\n]);\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=first&#x26;query=second'\n\n// Using a Map object\nconst map = new Map();\nmap.set('user', 'abc');\nmap.set('query', 'xyz');\nparams = new URLSearchParams(map);\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=xyz'\n\n// Using a generator function\nfunction* getQueryPairs() {\n  yield ['user', 'abc'];\n  yield ['query', 'first'];\n  yield ['query', 'second'];\n}\nparams = new URLSearchParams(getQueryPairs());\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=first&#x26;query=second'\n\n// Each key-value pair must have exactly two elements\nnew URLSearchParams([\n  ['user', 'abc', 'error']\n]);\n// Throws TypeError [ERR_INVALID_TUPLE]:\n//        Each query pair must be an iterable [name, value] tuple\n</code></pre>"
+                  "desc": "<p>Instantiate a new <code>URLSearchParams</code> object with an iterable map in a way that\nis similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\"><code>Map</code></a>'s constructor. <code>iterable</code> can be an <code>Array</code> or any\niterable object. That means <code>iterable</code> can be another <code>URLSearchParams</code>, in\nwhich case the constructor will simply create a clone of the provided\n<code>URLSearchParams</code>. Elements of <code>iterable</code> are key-value pairs, and can\nthemselves be any iterable object.</p>\n<p>Duplicate keys are allowed.</p>\n<pre><code class=\"language-js\">let params;\n\n// Using an array\nparams = new URLSearchParams([\n  ['user', 'abc'],\n  ['query', 'first'],\n  ['query', 'second'],\n]);\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=first&#x26;query=second'\n\n// Using a Map object\nconst map = new Map();\nmap.set('user', 'abc');\nmap.set('query', 'xyz');\nparams = new URLSearchParams(map);\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=xyz'\n\n// Using a generator function\nfunction* getQueryPairs() {\n  yield ['user', 'abc'];\n  yield ['query', 'first'];\n  yield ['query', 'second'];\n}\nparams = new URLSearchParams(getQueryPairs());\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=first&#x26;query=second'\n\n// Each key-value pair must have exactly two elements\nnew URLSearchParams([\n  ['user', 'abc', 'error'],\n]);\n// Throws TypeError [ERR_INVALID_TUPLE]:\n//        Each query pair must be an iterable [name, value] tuple\n</code></pre>"
                 }
               ]
             }
@@ -54386,7 +60020,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns the <a href=\"https://tools.ietf.org/html/rfc5891#section-4.4\">Punycode</a> ASCII serialization of the <code>domain</code>. If <code>domain</code> is an\ninvalid domain, the empty string is returned.</p>\n<p>It performs the inverse operation to <a href=\"url.html#url_url_domaintounicode_domain\"><code>url.domainToUnicode()</code></a>.</p>\n<pre><code class=\"language-js\">const url = require('url');\nconsole.log(url.domainToASCII('español.com'));\n// Prints xn--espaol-zwa.com\nconsole.log(url.domainToASCII('中文.com'));\n// Prints xn--fiq228c.com\nconsole.log(url.domainToASCII('xn--iñvalid.com'));\n// Prints an empty string\n</code></pre>"
+              "desc": "<p>Returns the <a href=\"https://tools.ietf.org/html/rfc5891#section-4.4\">Punycode</a> ASCII serialization of the <code>domain</code>. If <code>domain</code> is an\ninvalid domain, the empty string is returned.</p>\n<p>It performs the inverse operation to <a href=\"url.html#url_url_domaintounicode_domain\"><code>url.domainToUnicode()</code></a>.</p>\n<p>This feature is only available if the <code>node</code> executable was compiled with\n<a href=\"intl.html#intl_options_for_building_node_js\">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>\n<pre><code class=\"language-js\">const url = require('url');\nconsole.log(url.domainToASCII('español.com'));\n// Prints xn--espaol-zwa.com\nconsole.log(url.domainToASCII('中文.com'));\n// Prints xn--fiq228c.com\nconsole.log(url.domainToASCII('xn--iñvalid.com'));\n// Prints an empty string\n</code></pre>"
             },
             {
               "textRaw": "`url.domainToUnicode(domain)`",
@@ -54415,7 +60049,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns the Unicode serialization of the <code>domain</code>. If <code>domain</code> is an invalid\ndomain, the empty string is returned.</p>\n<p>It performs the inverse operation to <a href=\"url.html#url_url_domaintoascii_domain\"><code>url.domainToASCII()</code></a>.</p>\n<pre><code class=\"language-js\">const url = require('url');\nconsole.log(url.domainToUnicode('xn--espaol-zwa.com'));\n// Prints español.com\nconsole.log(url.domainToUnicode('xn--fiq228c.com'));\n// Prints 中文.com\nconsole.log(url.domainToUnicode('xn--iñvalid.com'));\n// Prints an empty string\n</code></pre>"
+              "desc": "<p>Returns the Unicode serialization of the <code>domain</code>. If <code>domain</code> is an invalid\ndomain, the empty string is returned.</p>\n<p>It performs the inverse operation to <a href=\"url.html#url_url_domaintoascii_domain\"><code>url.domainToASCII()</code></a>.</p>\n<p>This feature is only available if the <code>node</code> executable was compiled with\n<a href=\"intl.html#intl_options_for_building_node_js\">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>\n<pre><code class=\"language-js\">const url = require('url');\nconsole.log(url.domainToUnicode('xn--espaol-zwa.com'));\n// Prints español.com\nconsole.log(url.domainToUnicode('xn--fiq228c.com'));\n// Prints 中文.com\nconsole.log(url.domainToUnicode('xn--iñvalid.com'));\n// Prints an empty string\n</code></pre>"
             },
             {
               "textRaw": "`url.fileURLToPath(url)`",
@@ -54445,7 +60079,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This function ensures the correct decodings of percent-encoded characters as\nwell as ensuring a cross-platform valid absolute path string.</p>\n<pre><code class=\"language-js\">new URL('file:///C:/path/').pathname;    // Incorrect: /C:/path/\nfileURLToPath('file:///C:/path/');       // Correct:   C:\\path\\ (Windows)\n\nnew URL('file://nas/foo.txt').pathname;  // Incorrect: /foo.txt\nfileURLToPath('file://nas/foo.txt');     // Correct:   \\\\nas\\foo.txt (Windows)\n\nnew URL('file:///你好.txt').pathname;    // Incorrect: /%E4%BD%A0%E5%A5%BD.txt\nfileURLToPath('file:///你好.txt');       // Correct:   /你好.txt (POSIX)\n\nnew URL('file:///hello world').pathname; // Incorrect: /hello%20world\nfileURLToPath('file:///hello world');    // Correct:   /hello world (POSIX)\n</code></pre>"
+              "desc": "<p>This function ensures the correct decodings of percent-encoded characters as\nwell as ensuring a cross-platform valid absolute path string.</p>\n<pre><code class=\"language-mjs\">import { fileURLToPath } from 'url';\n\nconst __filename = fileURLToPath(import.meta.url);\n\nnew URL('file:///C:/path/').pathname;      // Incorrect: /C:/path/\nfileURLToPath('file:///C:/path/');         // Correct:   C:\\path\\ (Windows)\n\nnew URL('file://nas/foo.txt').pathname;    // Incorrect: /foo.txt\nfileURLToPath('file://nas/foo.txt');       // Correct:   \\\\nas\\foo.txt (Windows)\n\nnew URL('file:///你好.txt').pathname;      // Incorrect: /%E4%BD%A0%E5%A5%BD.txt\nfileURLToPath('file:///你好.txt');         // Correct:   /你好.txt (POSIX)\n\nnew URL('file:///hello world').pathname;   // Incorrect: /hello%20world\nfileURLToPath('file:///hello world');      // Correct:   /hello world (POSIX)\n</code></pre>\n<pre><code class=\"language-cjs\">const { fileURLToPath } = require('url');\nnew URL('file:///C:/path/').pathname;      // Incorrect: /C:/path/\nfileURLToPath('file:///C:/path/');         // Correct:   C:\\path\\ (Windows)\n\nnew URL('file://nas/foo.txt').pathname;    // Incorrect: /foo.txt\nfileURLToPath('file://nas/foo.txt');       // Correct:   \\\\nas\\foo.txt (Windows)\n\nnew URL('file:///你好.txt').pathname;      // Incorrect: /%E4%BD%A0%E5%A5%BD.txt\nfileURLToPath('file:///你好.txt');         // Correct:   /你好.txt (POSIX)\n\nnew URL('file:///hello world').pathname;   // Incorrect: /hello%20world\nfileURLToPath('file:///hello world');      // Correct:   /hello world (POSIX)\n</code></pre>"
             },
             {
               "textRaw": "`url.format(URL[, options])`",
@@ -54509,7 +60143,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a customizable serialization of a URL <code>String</code> representation of a\n<a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL</a> object.</p>\n<p>The URL object has both a <code>toString()</code> method and <code>href</code> property that return\nstring serializations of the URL. These are not, however, customizable in\nany way. The <code>url.format(URL[, options])</code> method allows for basic customization\nof the output.</p>\n<pre><code class=\"language-js\">const myURL = new URL('https://a:b@測試?abc#foo');\n\nconsole.log(myURL.href);\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(myURL.toString());\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));\n// Prints 'https://測試/?abc'\n</code></pre>"
+              "desc": "<p>Returns a customizable serialization of a URL <code>String</code> representation of a\n<a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL</a> object.</p>\n<p>The URL object has both a <code>toString()</code> method and <code>href</code> property that return\nstring serializations of the URL. These are not, however, customizable in\nany way. The <code>url.format(URL[, options])</code> method allows for basic customization\nof the output.</p>\n<pre><code class=\"language-mjs\">import url from 'url';\nconst myURL = new URL('https://a:b@測試?abc#foo');\n\nconsole.log(myURL.href);\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(myURL.toString());\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));\n// Prints 'https://測試/?abc'\n</code></pre>\n<pre><code class=\"language-cjs\">const url = require('url');\nconst myURL = new URL('https://a:b@測試?abc#foo');\n\nconsole.log(myURL.href);\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(myURL.toString());\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));\n// Prints 'https://測試/?abc'\n</code></pre>"
             },
             {
               "textRaw": "`url.pathToFileURL(path)`",
@@ -54539,7 +60173,93 @@
                   ]
                 }
               ],
-              "desc": "<p>This function ensures that <code>path</code> is resolved absolutely, and that the URL\ncontrol characters are correctly encoded when converting into a File URL.</p>\n<pre><code class=\"language-js\">new URL(__filename);                // Incorrect: throws (POSIX)\nnew URL(__filename);                // Incorrect: C:\\... (Windows)\npathToFileURL(__filename);          // Correct:   file:///... (POSIX)\npathToFileURL(__filename);          // Correct:   file:///C:/... (Windows)\n\nnew URL('/foo#1', 'file:');         // Incorrect: file:///foo#1\npathToFileURL('/foo#1');            // Correct:   file:///foo%231 (POSIX)\n\nnew URL('/some/path%.c', 'file:'); // Incorrect: file:///some/path%.c\npathToFileURL('/some/path%.c');    // Correct:   file:///some/path%25.c (POSIX)\n</code></pre>"
+              "desc": "<p>This function ensures that <code>path</code> is resolved absolutely, and that the URL\ncontrol characters are correctly encoded when converting into a File URL.</p>\n<pre><code class=\"language-mjs\">import { pathToFileURL } from 'url';\n\nnew URL('/foo#1', 'file:');           // Incorrect: file:///foo#1\npathToFileURL('/foo#1');              // Correct:   file:///foo%231 (POSIX)\n\nnew URL('/some/path%.c', 'file:');    // Incorrect: file:///some/path%.c\npathToFileURL('/some/path%.c');       // Correct:   file:///some/path%25.c (POSIX)\n</code></pre>\n<pre><code class=\"language-cjs\">const { pathToFileURL } = require('url');\nnew URL(__filename);                  // Incorrect: throws (POSIX)\nnew URL(__filename);                  // Incorrect: C:\\... (Windows)\npathToFileURL(__filename);            // Correct:   file:///... (POSIX)\npathToFileURL(__filename);            // Correct:   file:///C:/... (Windows)\n\nnew URL('/foo#1', 'file:');           // Incorrect: file:///foo#1\npathToFileURL('/foo#1');              // Correct:   file:///foo%231 (POSIX)\n\nnew URL('/some/path%.c', 'file:');    // Incorrect: file:///some/path%.c\npathToFileURL('/some/path%.c');       // Correct:   file:///some/path%25.c (POSIX)\n</code></pre>"
+            },
+            {
+              "textRaw": "`url.urlToHttpOptions(url)`",
+              "type": "method",
+              "name": "urlToHttpOptions",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Object} Options object",
+                    "name": "return",
+                    "type": "Object",
+                    "desc": "Options object",
+                    "options": [
+                      {
+                        "textRaw": "`protocol` {string} Protocol to use.",
+                        "name": "protocol",
+                        "type": "string",
+                        "desc": "Protocol to use."
+                      },
+                      {
+                        "textRaw": "`hostname` {string} A domain name or IP address of the server to issue the request to.",
+                        "name": "hostname",
+                        "type": "string",
+                        "desc": "A domain name or IP address of the server to issue the request to."
+                      },
+                      {
+                        "textRaw": "`hash` {string} The fragment portion of the URL.",
+                        "name": "hash",
+                        "type": "string",
+                        "desc": "The fragment portion of the URL."
+                      },
+                      {
+                        "textRaw": "`search` {string} The serialized query portion of the URL.",
+                        "name": "search",
+                        "type": "string",
+                        "desc": "The serialized query portion of the URL."
+                      },
+                      {
+                        "textRaw": "`pathname` {string} The path portion of the URL.",
+                        "name": "pathname",
+                        "type": "string",
+                        "desc": "The path portion of the URL."
+                      },
+                      {
+                        "textRaw": "`path` {string} Request path. Should include query string if any. E.G. `'/index.html?page=12'`. An exception is thrown when the request path contains illegal characters. Currently, only spaces are rejected but that may change in the future.",
+                        "name": "path",
+                        "type": "string",
+                        "desc": "Request path. Should include query string if any. E.G. `'/index.html?page=12'`. An exception is thrown when the request path contains illegal characters. Currently, only spaces are rejected but that may change in the future."
+                      },
+                      {
+                        "textRaw": "`href` {string} The serialized URL.",
+                        "name": "href",
+                        "type": "string",
+                        "desc": "The serialized URL."
+                      },
+                      {
+                        "textRaw": "`port` {number} Port of remote server.",
+                        "name": "port",
+                        "type": "number",
+                        "desc": "Port of remote server."
+                      },
+                      {
+                        "textRaw": "`auth` {string} Basic authentication i.e. `'user:password'` to compute an Authorization header.",
+                        "name": "auth",
+                        "type": "string",
+                        "desc": "Basic authentication i.e. `'user:password'` to compute an Authorization header."
+                      }
+                    ]
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`url` {URL} The [WHATWG URL][] object to convert to an options object.",
+                      "name": "url",
+                      "type": "URL",
+                      "desc": "The [WHATWG URL][] object to convert to an options object."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>This utility function converts a URL object into an ordinary options object as\nexpected by the <a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a> and <a href=\"https.html#https_https_request_options_callback\"><code>https.request()</code></a> APIs.</p>\n<pre><code class=\"language-js\">const { urlToHttpOptions } = require('url');\nconst myURL = new URL('https://a:b@測試?abc#foo');\n\nconsole.log(urlToHttpOptions(myUrl));\n/**\n{\n  protocol: 'https:',\n  hostname: 'xn--g6w251d',\n  hash: '#foo',\n  search: '?abc',\n  pathname: '/',\n  path: '/?abc',\n  href: 'https://a:b@xn--g6w251d/?abc#foo',\n  auth: 'a:b'\n}\n*/\n</code></pre>"
             }
           ],
           "type": "module",
@@ -54549,17 +60269,32 @@
           "textRaw": "Legacy URL API",
           "name": "legacy_url_api",
           "meta": {
-            "deprecated": [
-              "v11.0.0"
-            ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.17.0",
+                "pr-url": "https://github.com/nodejs/node/pull/37784",
+                "description": "Deprecation revoked. Status changed to \"Legacy\"."
+              },
+              {
+                "version": "v11.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/22715",
+                "description": "This API is deprecated."
+              }
+            ]
           },
+          "stability": 3,
+          "stabilityText": "Legacy: Use the WHATWG URL API instead.",
           "modules": [
             {
               "textRaw": "Legacy `urlObject`",
               "name": "legacy_`urlobject`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22715",
@@ -54567,8 +60302,8 @@
                   }
                 ]
               },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use the WHATWG URL API instead.",
+              "stability": 3,
+              "stabilityText": "Legacy: Use the WHATWG URL API instead.",
               "desc": "<p>The legacy <code>urlObject</code> (<code>require('url').Url</code>) is created and returned by the\n<code>url.parse()</code> function.</p>",
               "properties": [
                 {
@@ -54646,6 +60381,11 @@
                   "v0.1.25"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22715",
@@ -54658,8 +60398,8 @@
                   }
                 ]
               },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use the WHATWG URL API instead.",
+              "stability": 3,
+              "stabilityText": "Legacy: Use the WHATWG URL API instead.",
               "signatures": [
                 {
                   "params": [
@@ -54672,7 +60412,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>url.format()</code> method returns a formatted URL string derived from\n<code>urlObject</code>.</p>\n<pre><code class=\"language-js\">url.format({\n  protocol: 'https',\n  hostname: 'example.com',\n  pathname: '/some/path',\n  query: {\n    page: 1,\n    format: 'json'\n  }\n});\n\n// => 'https://example.com/some/path?page=1&#x26;format=json'\n</code></pre>\n<p>If <code>urlObject</code> is not an object or a string, <code>url.format()</code> will throw a\n<a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a>.</p>\n<p>The formatting process operates as follows:</p>\n<ul>\n<li>A new empty string <code>result</code> is created.</li>\n<li>If <code>urlObject.protocol</code> is a string, it is appended as-is to <code>result</code>.</li>\n<li>Otherwise, if <code>urlObject.protocol</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>For all string values of <code>urlObject.protocol</code> that <em>do not end</em> with an ASCII\ncolon (<code>:</code>) character, the literal string <code>:</code> will be appended to <code>result</code>.</li>\n<li>If either of the following conditions is true, then the literal string <code>//</code>\nwill be appended to <code>result</code>:\n<ul>\n<li><code>urlObject.slashes</code> property is true;</li>\n<li><code>urlObject.protocol</code> begins with <code>http</code>, <code>https</code>, <code>ftp</code>, <code>gopher</code>, or\n<code>file</code>;</li>\n</ul>\n</li>\n<li>If the value of the <code>urlObject.auth</code> property is truthy, and either\n<code>urlObject.host</code> or <code>urlObject.hostname</code> are not <code>undefined</code>, the value of\n<code>urlObject.auth</code> will be coerced into a string and appended to <code>result</code>\nfollowed by the literal string <code>@</code>.</li>\n<li>If the <code>urlObject.host</code> property is <code>undefined</code> then:\n<ul>\n<li>If the <code>urlObject.hostname</code> is a string, it is appended to <code>result</code>.</li>\n<li>Otherwise, if <code>urlObject.hostname</code> is not <code>undefined</code> and is not a string,\nan <a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.port</code> property value is truthy, and <code>urlObject.hostname</code>\nis not <code>undefined</code>:\n<ul>\n<li>The literal string <code>:</code> is appended to <code>result</code>, and</li>\n<li>The value of <code>urlObject.port</code> is coerced to a string and appended to\n<code>result</code>.</li>\n</ul>\n</li>\n</ul>\n</li>\n<li>Otherwise, if the <code>urlObject.host</code> property value is truthy, the value of\n<code>urlObject.host</code> is coerced to a string and appended to <code>result</code>.</li>\n<li>If the <code>urlObject.pathname</code> property is a string that is not an empty string:\n<ul>\n<li>If the <code>urlObject.pathname</code> <em>does not start</em> with an ASCII forward slash\n(<code>/</code>), then the literal string <code>'/'</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.pathname</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if <code>urlObject.pathname</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.search</code> property is <code>undefined</code> and if the <code>urlObject.query</code>\nproperty is an <code>Object</code>, the literal string <code>?</code> is appended to <code>result</code>\nfollowed by the output of calling the <a href=\"querystring.html\"><code>querystring</code></a> module's <code>stringify()</code>\nmethod passing the value of <code>urlObject.query</code>.</li>\n<li>Otherwise, if <code>urlObject.search</code> is a string:\n<ul>\n<li>If the value of <code>urlObject.search</code> <em>does not start</em> with the ASCII question\nmark (<code>?</code>) character, the literal string <code>?</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.search</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if <code>urlObject.search</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.hash</code> property is a string:\n<ul>\n<li>If the value of <code>urlObject.hash</code> <em>does not start</em> with the ASCII hash (<code>#</code>)\ncharacter, the literal string <code>#</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.hash</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if the <code>urlObject.hash</code> property is not <code>undefined</code> and is not a\nstring, an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li><code>result</code> is returned.</li>\n</ul>"
+              "desc": "<p>The <code>url.format()</code> method returns a formatted URL string derived from\n<code>urlObject</code>.</p>\n<pre><code class=\"language-js\">const url = require('url');\nurl.format({\n  protocol: 'https',\n  hostname: 'example.com',\n  pathname: '/some/path',\n  query: {\n    page: 1,\n    format: 'json'\n  }\n});\n\n// => 'https://example.com/some/path?page=1&#x26;format=json'\n</code></pre>\n<p>If <code>urlObject</code> is not an object or a string, <code>url.format()</code> will throw a\n<a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a>.</p>\n<p>The formatting process operates as follows:</p>\n<ul>\n<li>A new empty string <code>result</code> is created.</li>\n<li>If <code>urlObject.protocol</code> is a string, it is appended as-is to <code>result</code>.</li>\n<li>Otherwise, if <code>urlObject.protocol</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>For all string values of <code>urlObject.protocol</code> that <em>do not end</em> with an ASCII\ncolon (<code>:</code>) character, the literal string <code>:</code> will be appended to <code>result</code>.</li>\n<li>If either of the following conditions is true, then the literal string <code>//</code>\nwill be appended to <code>result</code>:\n<ul>\n<li><code>urlObject.slashes</code> property is true;</li>\n<li><code>urlObject.protocol</code> begins with <code>http</code>, <code>https</code>, <code>ftp</code>, <code>gopher</code>, or\n<code>file</code>;</li>\n</ul>\n</li>\n<li>If the value of the <code>urlObject.auth</code> property is truthy, and either\n<code>urlObject.host</code> or <code>urlObject.hostname</code> are not <code>undefined</code>, the value of\n<code>urlObject.auth</code> will be coerced into a string and appended to <code>result</code>\nfollowed by the literal string <code>@</code>.</li>\n<li>If the <code>urlObject.host</code> property is <code>undefined</code> then:\n<ul>\n<li>If the <code>urlObject.hostname</code> is a string, it is appended to <code>result</code>.</li>\n<li>Otherwise, if <code>urlObject.hostname</code> is not <code>undefined</code> and is not a string,\nan <a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.port</code> property value is truthy, and <code>urlObject.hostname</code>\nis not <code>undefined</code>:\n<ul>\n<li>The literal string <code>:</code> is appended to <code>result</code>, and</li>\n<li>The value of <code>urlObject.port</code> is coerced to a string and appended to\n<code>result</code>.</li>\n</ul>\n</li>\n</ul>\n</li>\n<li>Otherwise, if the <code>urlObject.host</code> property value is truthy, the value of\n<code>urlObject.host</code> is coerced to a string and appended to <code>result</code>.</li>\n<li>If the <code>urlObject.pathname</code> property is a string that is not an empty string:\n<ul>\n<li>If the <code>urlObject.pathname</code> <em>does not start</em> with an ASCII forward slash\n(<code>/</code>), then the literal string <code>'/'</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.pathname</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if <code>urlObject.pathname</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.search</code> property is <code>undefined</code> and if the <code>urlObject.query</code>\nproperty is an <code>Object</code>, the literal string <code>?</code> is appended to <code>result</code>\nfollowed by the output of calling the <a href=\"querystring.html\"><code>querystring</code></a> module's <code>stringify()</code>\nmethod passing the value of <code>urlObject.query</code>.</li>\n<li>Otherwise, if <code>urlObject.search</code> is a string:\n<ul>\n<li>If the value of <code>urlObject.search</code> <em>does not start</em> with the ASCII question\nmark (<code>?</code>) character, the literal string <code>?</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.search</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if <code>urlObject.search</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.hash</code> property is a string:\n<ul>\n<li>If the value of <code>urlObject.hash</code> <em>does not start</em> with the ASCII hash (<code>#</code>)\ncharacter, the literal string <code>#</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.hash</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if the <code>urlObject.hash</code> property is not <code>undefined</code> and is not a\nstring, an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li><code>result</code> is returned.</li>\n</ul>"
             },
             {
               "textRaw": "`url.parse(urlString[, parseQueryString[, slashesDenoteHost]])`",
@@ -54683,6 +60423,11 @@
                   "v0.1.25"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.14.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26941",
@@ -54700,8 +60445,8 @@
                   }
                 ]
               },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use the WHATWG URL API instead.",
+              "stability": 3,
+              "stabilityText": "Legacy: Use the WHATWG URL API instead.",
               "signatures": [
                 {
                   "params": [
@@ -54739,6 +60484,11 @@
                   "v0.1.25"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22715",
@@ -54750,7 +60500,10 @@
                     "description": "The `auth` fields are now kept intact when `from` and `to` refer to the same host."
                   },
                   {
-                    "version": "v6.5.0, v4.6.2",
+                    "version": [
+                      "v6.5.0",
+                      "v4.6.2"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/8214",
                     "description": "The `port` field is copied correctly now."
                   },
@@ -54761,8 +60514,8 @@
                   }
                 ]
               },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use the WHATWG URL API instead.",
+              "stability": 3,
+              "stabilityText": "Legacy: Use the WHATWG URL API instead.",
               "signatures": [
                 {
                   "params": [
@@ -54781,7 +60534,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>url.resolve()</code> method resolves a target URL relative to a base URL in a\nmanner similar to that of a Web browser resolving an anchor tag HREF.</p>\n<pre><code class=\"language-js\">const url = require('url');\nurl.resolve('/one/two/three', 'four');         // '/one/two/four'\nurl.resolve('http://example.com/', '/one');    // 'http://example.com/one'\nurl.resolve('http://example.com/one', '/two'); // 'http://example.com/two'\n</code></pre>\n<p><a id=\"whatwg-percent-encoding\"></a></p>"
+              "desc": "<p>The <code>url.resolve()</code> method resolves a target URL relative to a base URL in a\nmanner similar to that of a Web browser resolving an anchor tag HREF.</p>\n<pre><code class=\"language-js\">const url = require('url');\nurl.resolve('/one/two/three', 'four');         // '/one/two/four'\nurl.resolve('http://example.com/', '/one');    // 'http://example.com/one'\nurl.resolve('http://example.com/one', '/two'); // 'http://example.com/two'\n</code></pre>\n<p>You can achieve the same result using the WHATWG URL API:</p>\n<pre><code class=\"language-js\">function resolve(from, to) {\n  const resolvedUrl = new URL(to, new URL(from, 'resolve://'));\n  if (resolvedUrl.protocol === 'resolve:') {\n    // `from` is a relative URL.\n    const { pathname, search, hash } = resolvedUrl;\n    return pathname + search + hash;\n  }\n  return resolvedUrl.toString();\n}\n\nresolve('/one/two/three', 'four');         // '/one/two/four'\nresolve('http://example.com/', '/one');    // 'http://example.com/one'\nresolve('http://example.com/one', '/two'); // 'http://example.com/two'\n</code></pre>\n<p><a id=\"whatwg-percent-encoding\"></a></p>"
             }
           ],
           "type": "module",
@@ -54812,7 +60565,8 @@
         }
       ],
       "type": "module",
-      "displayName": "URL"
+      "displayName": "URL",
+      "source": "doc/api/url.md"
     },
     {
       "textRaw": "Util",
@@ -54820,7 +60574,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/util.js\">lib/util.js</a></p>\n<p>The <code>util</code> module supports the needs of Node.js internal APIs. Many of the\nutilities are useful for application and module developers as well. To access\nit:</p>\n<pre><code class=\"language-js\">const util = require('util');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/util.js\">lib/util.js</a></p>\n<p>The <code>util</code> module supports the needs of Node.js internal APIs. Many of the\nutilities are useful for application and module developers as well. To access\nit:</p>\n<pre><code class=\"language-js\">const util = require('util');\n</code></pre>",
       "methods": [
         {
           "textRaw": "`util.callbackify(original)`",
@@ -54886,7 +60640,39 @@
               ]
             }
           ],
-          "desc": "<p>The <code>util.debuglog()</code> method is used to create a function that conditionally\nwrites debug messages to <code>stderr</code> based on the existence of the <code>NODE_DEBUG</code>\nenvironment variable. If the <code>section</code> name appears within the value of that\nenvironment variable, then the returned function operates similar to\n<a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a>. If not, then the returned function is a no-op.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst debuglog = util.debuglog('foo');\n\ndebuglog('hello from foo [%d]', 123);\n</code></pre>\n<p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then\nit will output something like:</p>\n<pre><code class=\"language-console\">FOO 3245: hello from foo [123]\n</code></pre>\n<p>where <code>3245</code> is the process id. If it is not run with that\nenvironment variable set, then it will not print anything.</p>\n<p>The <code>section</code> supports wildcard also:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst debuglog = util.debuglog('foo-bar');\n\ndebuglog('hi there, it\\'s foo-bar [%d]', 2333);\n</code></pre>\n<p>if it is run with <code>NODE_DEBUG=foo*</code> in the environment, then it will output\nsomething like:</p>\n<pre><code class=\"language-console\">FOO-BAR 3257: hi there, it's foo-bar [2333]\n</code></pre>\n<p>Multiple comma-separated <code>section</code> names may be specified in the <code>NODE_DEBUG</code>\nenvironment variable: <code>NODE_DEBUG=fs,net,tls</code>.</p>\n<p>The optional <code>callback</code> argument can be used to replace the logging function\nwith a different function that doesn't have any initialization or\nunnecessary wrapping.</p>\n<pre><code class=\"language-js\">const util = require('util');\nlet debuglog = util.debuglog('internals', (debug) => {\n  // Replace with a logging function that optimizes out\n  // testing if the section is enabled\n  debuglog = debug;\n});\n</code></pre>"
+          "desc": "<p>The <code>util.debuglog()</code> method is used to create a function that conditionally\nwrites debug messages to <code>stderr</code> based on the existence of the <code>NODE_DEBUG</code>\nenvironment variable. If the <code>section</code> name appears within the value of that\nenvironment variable, then the returned function operates similar to\n<a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a>. If not, then the returned function is a no-op.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst debuglog = util.debuglog('foo');\n\ndebuglog('hello from foo [%d]', 123);\n</code></pre>\n<p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then\nit will output something like:</p>\n<pre><code class=\"language-console\">FOO 3245: hello from foo [123]\n</code></pre>\n<p>where <code>3245</code> is the process id. If it is not run with that\nenvironment variable set, then it will not print anything.</p>\n<p>The <code>section</code> supports wildcard also:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst debuglog = util.debuglog('foo-bar');\n\ndebuglog('hi there, it\\'s foo-bar [%d]', 2333);\n</code></pre>\n<p>if it is run with <code>NODE_DEBUG=foo*</code> in the environment, then it will output\nsomething like:</p>\n<pre><code class=\"language-console\">FOO-BAR 3257: hi there, it's foo-bar [2333]\n</code></pre>\n<p>Multiple comma-separated <code>section</code> names may be specified in the <code>NODE_DEBUG</code>\nenvironment variable: <code>NODE_DEBUG=fs,net,tls</code>.</p>\n<p>The optional <code>callback</code> argument can be used to replace the logging function\nwith a different function that doesn't have any initialization or\nunnecessary wrapping.</p>\n<pre><code class=\"language-js\">const util = require('util');\nlet debuglog = util.debuglog('internals', (debug) => {\n  // Replace with a logging function that optimizes out\n  // testing if the section is enabled\n  debuglog = debug;\n});\n</code></pre>",
+          "modules": [
+            {
+              "textRaw": "`debuglog().enabled`",
+              "name": "`debuglog().enabled`",
+              "meta": {
+                "added": [
+                  "v14.9.0"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a></li>\n</ul>\n<p>The <code>util.debuglog().enabled</code> getter is used to create a test that can be used\nin conditionals based on the existence of the <code>NODE_DEBUG</code> environment variable.\nIf the <code>section</code> name appears within the value of that environment variable,\nthen the returned value will be <code>true</code>. If not, then the returned value will be\n<code>false</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst enabled = util.debuglog('foo').enabled;\nif (enabled) {\n  console.log('hello from foo [%d]', 123);\n}\n</code></pre>\n<p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then it will\noutput something like:</p>\n<pre><code class=\"language-console\">hello from foo [123]\n</code></pre>",
+              "type": "module",
+              "displayName": "`debuglog().enabled`"
+            }
+          ]
+        },
+        {
+          "textRaw": "`util.debug(section)`",
+          "type": "method",
+          "name": "debug",
+          "meta": {
+            "added": [
+              "v14.9.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<p>Alias for <code>util.debuglog</code>. Usage allows for readability of that doesn't imply\nlogging when only using <code>util.debuglog().enabled</code>.</p>"
         },
         {
           "textRaw": "`util.deprecate(fn, msg[, code])`",
@@ -54934,7 +60720,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>util.deprecate()</code> method wraps <code>fn</code> (which may be a function or class) in\nsuch a way that it is marked as deprecated.</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nexports.obsoleteFunction = util.deprecate(() => {\n  // Do something here.\n}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');\n</code></pre>\n<p>When called, <code>util.deprecate()</code> will return a function that will emit a\n<code>DeprecationWarning</code> using the <a href=\"process.html#process_event_warning\"><code>'warning'</code></a> event. The warning will\nbe emitted and printed to <code>stderr</code> the first time the returned function is\ncalled. After the warning is emitted, the wrapped function is called without\nemitting a warning.</p>\n<p>If the same optional <code>code</code> is supplied in multiple calls to <code>util.deprecate()</code>,\nthe warning will be emitted only once for that <code>code</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');\nconst fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');\nfn1(); // Emits a deprecation warning with code DEP0001\nfn2(); // Does not emit a deprecation warning because it has the same code\n</code></pre>\n<p>If either the <code>--no-deprecation</code> or <code>--no-warnings</code> command line flags are\nused, or if the <code>process.noDeprecation</code> property is set to <code>true</code> <em>prior</em> to\nthe first deprecation warning, the <code>util.deprecate()</code> method does nothing.</p>\n<p>If the <code>--trace-deprecation</code> or <code>--trace-warnings</code> command line flags are set,\nor the <code>process.traceDeprecation</code> property is set to <code>true</code>, a warning and a\nstack trace are printed to <code>stderr</code> the first time the deprecated function is\ncalled.</p>\n<p>If the <code>--throw-deprecation</code> command line flag is set, or the\n<code>process.throwDeprecation</code> property is set to <code>true</code>, then an exception will be\nthrown when the deprecated function is called.</p>\n<p>The <code>--throw-deprecation</code> command line flag and <code>process.throwDeprecation</code>\nproperty take precedence over <code>--trace-deprecation</code> and\n<code>process.traceDeprecation</code>.</p>"
+          "desc": "<p>The <code>util.deprecate()</code> method wraps <code>fn</code> (which may be a function or class) in\nsuch a way that it is marked as deprecated.</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nexports.obsoleteFunction = util.deprecate(() => {\n  // Do something here.\n}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');\n</code></pre>\n<p>When called, <code>util.deprecate()</code> will return a function that will emit a\n<code>DeprecationWarning</code> using the <a href=\"process.html#process_event_warning\"><code>'warning'</code></a> event. The warning will\nbe emitted and printed to <code>stderr</code> the first time the returned function is\ncalled. After the warning is emitted, the wrapped function is called without\nemitting a warning.</p>\n<p>If the same optional <code>code</code> is supplied in multiple calls to <code>util.deprecate()</code>,\nthe warning will be emitted only once for that <code>code</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');\nconst fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');\nfn1(); // Emits a deprecation warning with code DEP0001\nfn2(); // Does not emit a deprecation warning because it has the same code\n</code></pre>\n<p>If either the <code>--no-deprecation</code> or <code>--no-warnings</code> command-line flags are\nused, or if the <code>process.noDeprecation</code> property is set to <code>true</code> <em>prior</em> to\nthe first deprecation warning, the <code>util.deprecate()</code> method does nothing.</p>\n<p>If the <code>--trace-deprecation</code> or <code>--trace-warnings</code> command-line flags are set,\nor the <code>process.traceDeprecation</code> property is set to <code>true</code>, a warning and a\nstack trace are printed to <code>stderr</code> the first time the deprecated function is\ncalled.</p>\n<p>If the <code>--throw-deprecation</code> command-line flag is set, or the\n<code>process.throwDeprecation</code> property is set to <code>true</code>, then an exception will be\nthrown when the deprecated function is called.</p>\n<p>The <code>--throw-deprecation</code> command-line flag and <code>process.throwDeprecation</code>\nproperty take precedence over <code>--trace-deprecation</code> and\n<code>process.traceDeprecation</code>.</p>"
         },
         {
           "textRaw": "`util.format(format[, ...args])`",
@@ -54950,11 +60736,6 @@
                 "pr-url": "https://github.com/nodejs/node/pull/29606",
                 "description": "The `%c` specifier is ignored now."
               },
-              {
-                "version": "v11.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23708",
-                "description": "The `%d`, `%f` and `%i` specifiers now support Symbols properly."
-              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/23162",
@@ -54965,6 +60746,11 @@
                 "pr-url": "https://github.com/nodejs/node/pull/23162",
                 "description": "If the `format` argument is not a format string, the output string's formatting is no longer dependent on the type of the first argument. This change removes previously present quotes from strings that were being output when the first argument was not a string."
               },
+              {
+                "version": "v11.4.0",
+                "pr-url": "https://github.com/nodejs/node/pull/23708",
+                "description": "The `%d`, `%f` and `%i` specifiers now support Symbols properly."
+              },
               {
                 "version": "v11.4.0",
                 "pr-url": "https://github.com/nodejs/node/pull/24806",
@@ -55057,6 +60843,28 @@
           ],
           "desc": "<p>Returns the string name for a numeric error code that comes from a Node.js API.\nThe mapping between error codes and error names is platform-dependent.\nSee <a href=\"errors.html#errors_common_system_errors\">Common System Errors</a> for the names of common errors.</p>\n<pre><code class=\"language-js\">fs.access('file/that/does/not/exist', (err) => {\n  const name = util.getSystemErrorName(err.errno);\n  console.error(name);  // ENOENT\n});\n</code></pre>"
         },
+        {
+          "textRaw": "`util.getSystemErrorMap()`",
+          "type": "method",
+          "name": "getSystemErrorMap",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {Map}",
+                "name": "return",
+                "type": "Map"
+              },
+              "params": []
+            }
+          ],
+          "desc": "<p>Returns a Map of all system error codes available from the Node.js API.\nThe mapping between error codes and error names is platform-dependent.\nSee <a href=\"errors.html#errors_common_system_errors\">Common System Errors</a> for the names of common errors.</p>\n<pre><code class=\"language-js\">fs.access('file/that/does/not/exist', (err) => {\n  const errorMap = util.getSystemErrorMap();\n  const name = errorMap.get(err.errno);\n  console.error(name);  // ENOENT\n});\n</code></pre>"
+        },
         {
           "textRaw": "`util.inherits(constructor, superConstructor)`",
           "type": "method",
@@ -55073,6 +60881,8 @@
               }
             ]
           },
+          "stability": 3,
+          "stabilityText": "Legacy: Use ES2015 class syntax and `extends` keyword instead.",
           "signatures": [
             {
               "params": [
@@ -55109,30 +60919,41 @@
                 "description": "If `object` is from a different `vm.Context` now, a custom inspection function on it will not receive context-specific arguments anymore."
               },
               {
-                "version": "v12.17.0",
+                "version": [
+                  "v13.13.0",
+                  "v12.17.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/32392",
                 "description": "The `maxStringLength` option is supported now."
               },
               {
-                "version": "v12.16.0",
+                "version": [
+                  "v13.5.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/30768",
                 "description": "User defined prototype properties are inspected in case `showHidden` is `true`."
               },
+              {
+                "version": "v13.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/27685",
+                "description": "Circular references now include a marker to the reference."
+              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/27109",
                 "description": "The `compact` options default is changed to `3` and the `breakLength` options default is changed to `80`."
               },
-              {
-                "version": "v11.11.0",
-                "pr-url": "https://github.com/nodejs/node/pull/26269",
-                "description": "The `compact` option accepts numbers for a new output mode."
-              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/24971",
                 "description": "Internal properties no longer appear in the context argument of a custom inspection function."
               },
+              {
+                "version": "v11.11.0",
+                "pr-url": "https://github.com/nodejs/node/pull/26269",
+                "description": "The `compact` option accepts numbers for a new output mode."
+              },
               {
                 "version": "v11.7.0",
                 "pr-url": "https://github.com/nodejs/node/pull/25006",
@@ -55153,16 +60974,16 @@
                 "pr-url": "https://github.com/nodejs/node/pull/22846",
                 "description": "The `depth` default changed to `20`."
               },
-              {
-                "version": "v10.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22788",
-                "description": "The `sorted` option is supported now."
-              },
               {
                 "version": "v11.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/22756",
                 "description": "The inspection output is now limited to about 128 MB. Data above that size will not be fully inspected."
               },
+              {
+                "version": "v10.12.0",
+                "pr-url": "https://github.com/nodejs/node/pull/22788",
+                "description": "The `sorted` option is supported now."
+              },
               {
                 "version": "v10.6.0",
                 "pr-url": "https://github.com/nodejs/node/pull/20725",
@@ -55301,7 +61122,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>util.inspect()</code> method returns a string representation of <code>object</code> that is\nintended for debugging. The output of <code>util.inspect</code> may change at any time\nand should not be depended upon programmatically. Additional <code>options</code> may be\npassed that alter the result.\n<code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make\nan identifiable tag for an inspected value.</p>\n<pre><code class=\"language-js\">class Foo {\n  get [Symbol.toStringTag]() {\n    return 'bar';\n  }\n}\n\nclass Bar {}\n\nconst baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });\n\nutil.inspect(new Foo()); // 'Foo [bar] {}'\nutil.inspect(new Bar()); // 'Bar {}'\nutil.inspect(baz);       // '[foo] {}'\n</code></pre>\n<p>Circular references are marked as <code>'[Circular]'</code>:</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = {};\nobj.a = [obj];\nobj.b = {};\nobj.b.inner = obj.b;\nobj.b.obj = obj;\n\nconsole.log(inspect(obj));\n// {\n//   a: [ [Circular] ],\n//   b: { inner: [Circular], obj: [Circular] }\n// }\n</code></pre>\n<p>The following example inspects all properties of the <code>util</code> object:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));\n</code></pre>\n<p>The following example highlights the effect of the <code>compact</code> option:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst o = {\n  a: [1, 2, [[\n    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +\n      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',\n    'test',\n    'foo']], 4],\n  b: new Map([['za', 1], ['zb', 'test']])\n};\nconsole.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));\n\n// { a:\n//   [ 1,\n//     2,\n//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line\n//           'test',\n//           'foo' ] ],\n//     4 ],\n//   b: Map { 'za' => 1, 'zb' => 'test' } }\n\n// Setting `compact` to false changes the output to be more reader friendly.\nconsole.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));\n\n// {\n//   a: [\n//     1,\n//     2,\n//     [\n//       [\n//         'Lorem ipsum dolor sit amet, consectetur ' +\n//           'adipiscing elit, sed do eiusmod tempor ' +\n//           'incididunt ut labore et dolore magna ' +\n//           'aliqua.,\n//         'test',\n//         'foo'\n//       ]\n//     ],\n//     4\n//   ],\n//   b: Map {\n//     'za' => 1,\n//     'zb' => 'test'\n//   }\n// }\n\n// Setting `breakLength` to e.g. 150 will print the \"Lorem ipsum\" text in a\n// single line.\n// Reducing the `breakLength` will split the \"Lorem ipsum\" text in smaller\n// chunks.\n</code></pre>\n<p>The <code>showHidden</code> option allows <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> entries to be\ninspected. If there are more entries than <code>maxArrayLength</code>, there is no\nguarantee which entries are displayed. That means retrieving the same\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> entries twice may result in different output. Furthermore, entries\nwith no remaining strong references may be garbage collected at any time.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = { a: 1 };\nconst obj2 = { b: 2 };\nconst weakSet = new WeakSet([obj, obj2]);\n\nconsole.log(inspect(weakSet, { showHidden: true }));\n// WeakSet { { a: 1 }, { b: 2 } }\n</code></pre>\n<p>The <code>sorted</code> option ensures that an object's property insertion order does not\nimpact the result of <code>util.inspect()</code>.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\nconst assert = require('assert');\n\nconst o1 = {\n  b: [2, 3, 1],\n  a: '`a` comes before `b`',\n  c: new Set([2, 3, 1])\n};\nconsole.log(inspect(o1, { sorted: true }));\n// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set { 1, 2, 3 } }\nconsole.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));\n// { c: Set { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }\n\nconst o2 = {\n  c: new Set([2, 1, 3]),\n  a: '`a` comes before `b`',\n  b: [2, 3, 1]\n};\nassert.strict.equal(\n  inspect(o1, { sorted: true }),\n  inspect(o2, { sorted: true })\n);\n</code></pre>\n<p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum\noutput length is approximately 128 MB. Inputs that result in longer output will\nbe truncated.</p>"
+          "desc": "<p>The <code>util.inspect()</code> method returns a string representation of <code>object</code> that is\nintended for debugging. The output of <code>util.inspect</code> may change at any time\nand should not be depended upon programmatically. Additional <code>options</code> may be\npassed that alter the result.\n<code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make\nan identifiable tag for an inspected value.</p>\n<pre><code class=\"language-js\">class Foo {\n  get [Symbol.toStringTag]() {\n    return 'bar';\n  }\n}\n\nclass Bar {}\n\nconst baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });\n\nutil.inspect(new Foo()); // 'Foo [bar] {}'\nutil.inspect(new Bar()); // 'Bar {}'\nutil.inspect(baz);       // '[foo] {}'\n</code></pre>\n<p>Circular references point to their anchor by using a reference index:</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = {};\nobj.a = [obj];\nobj.b = {};\nobj.b.inner = obj.b;\nobj.b.obj = obj;\n\nconsole.log(inspect(obj));\n// &#x3C;ref *1> {\n//   a: [ [Circular *1] ],\n//   b: &#x3C;ref *2> { inner: [Circular *2], obj: [Circular *1] }\n// }\n</code></pre>\n<p>The following example inspects all properties of the <code>util</code> object:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));\n</code></pre>\n<p>The following example highlights the effect of the <code>compact</code> option:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst o = {\n  a: [1, 2, [[\n    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +\n      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',\n    'test',\n    'foo']], 4],\n  b: new Map([['za', 1], ['zb', 'test']])\n};\nconsole.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));\n\n// { a:\n//   [ 1,\n//     2,\n//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line\n//           'test',\n//           'foo' ] ],\n//     4 ],\n//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }\n\n// Setting `compact` to false changes the output to be more reader friendly.\nconsole.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));\n\n// {\n//   a: [\n//     1,\n//     2,\n//     [\n//       [\n//         'Lorem ipsum dolor sit amet, consectetur ' +\n//           'adipiscing elit, sed do eiusmod tempor ' +\n//           'incididunt ut labore et dolore magna ' +\n//           'aliqua.,\n//         'test',\n//         'foo'\n//       ]\n//     ],\n//     4\n//   ],\n//   b: Map(2) {\n//     'za' => 1,\n//     'zb' => 'test'\n//   }\n// }\n\n// Setting `breakLength` to e.g. 150 will print the \"Lorem ipsum\" text in a\n// single line.\n// Reducing the `breakLength` will split the \"Lorem ipsum\" text in smaller\n// chunks.\n</code></pre>\n<p>The <code>showHidden</code> option allows <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> entries to be\ninspected. If there are more entries than <code>maxArrayLength</code>, there is no\nguarantee which entries are displayed. That means retrieving the same\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> entries twice may result in different output. Furthermore, entries\nwith no remaining strong references may be garbage collected at any time.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = { a: 1 };\nconst obj2 = { b: 2 };\nconst weakSet = new WeakSet([obj, obj2]);\n\nconsole.log(inspect(weakSet, { showHidden: true }));\n// WeakSet { { a: 1 }, { b: 2 } }\n</code></pre>\n<p>The <code>sorted</code> option ensures that an object's property insertion order does not\nimpact the result of <code>util.inspect()</code>.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\nconst assert = require('assert');\n\nconst o1 = {\n  b: [2, 3, 1],\n  a: '`a` comes before `b`',\n  c: new Set([2, 3, 1])\n};\nconsole.log(inspect(o1, { sorted: true }));\n// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }\nconsole.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));\n// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }\n\nconst o2 = {\n  c: new Set([2, 1, 3]),\n  a: '`a` comes before `b`',\n  b: [2, 3, 1]\n};\nassert.strict.equal(\n  inspect(o1, { sorted: true }),\n  inspect(o2, { sorted: true })\n);\n</code></pre>\n<p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum\noutput length is approximately 128 MB. Inputs that result in longer output will\nbe truncated.</p>"
         },
         {
           "textRaw": "`util.inspect(object[, showHidden[, depth[, colors]]])`",
@@ -55321,30 +61142,41 @@
                 "description": "If `object` is from a different `vm.Context` now, a custom inspection function on it will not receive context-specific arguments anymore."
               },
               {
-                "version": "v12.17.0",
+                "version": [
+                  "v13.13.0",
+                  "v12.17.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/32392",
                 "description": "The `maxStringLength` option is supported now."
               },
               {
-                "version": "v12.16.0",
+                "version": [
+                  "v13.5.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/30768",
                 "description": "User defined prototype properties are inspected in case `showHidden` is `true`."
               },
+              {
+                "version": "v13.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/27685",
+                "description": "Circular references now include a marker to the reference."
+              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/27109",
                 "description": "The `compact` options default is changed to `3` and the `breakLength` options default is changed to `80`."
               },
-              {
-                "version": "v11.11.0",
-                "pr-url": "https://github.com/nodejs/node/pull/26269",
-                "description": "The `compact` option accepts numbers for a new output mode."
-              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/24971",
                 "description": "Internal properties no longer appear in the context argument of a custom inspection function."
               },
+              {
+                "version": "v11.11.0",
+                "pr-url": "https://github.com/nodejs/node/pull/26269",
+                "description": "The `compact` option accepts numbers for a new output mode."
+              },
               {
                 "version": "v11.7.0",
                 "pr-url": "https://github.com/nodejs/node/pull/25006",
@@ -55365,16 +61197,16 @@
                 "pr-url": "https://github.com/nodejs/node/pull/22846",
                 "description": "The `depth` default changed to `20`."
               },
-              {
-                "version": "v10.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22788",
-                "description": "The `sorted` option is supported now."
-              },
               {
                 "version": "v11.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/22756",
                 "description": "The inspection output is now limited to about 128 MB. Data above that size will not be fully inspected."
               },
+              {
+                "version": "v10.12.0",
+                "pr-url": "https://github.com/nodejs/node/pull/22788",
+                "description": "The `sorted` option is supported now."
+              },
               {
                 "version": "v10.6.0",
                 "pr-url": "https://github.com/nodejs/node/pull/20725",
@@ -55513,7 +61345,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>util.inspect()</code> method returns a string representation of <code>object</code> that is\nintended for debugging. The output of <code>util.inspect</code> may change at any time\nand should not be depended upon programmatically. Additional <code>options</code> may be\npassed that alter the result.\n<code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make\nan identifiable tag for an inspected value.</p>\n<pre><code class=\"language-js\">class Foo {\n  get [Symbol.toStringTag]() {\n    return 'bar';\n  }\n}\n\nclass Bar {}\n\nconst baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });\n\nutil.inspect(new Foo()); // 'Foo [bar] {}'\nutil.inspect(new Bar()); // 'Bar {}'\nutil.inspect(baz);       // '[foo] {}'\n</code></pre>\n<p>Circular references are marked as <code>'[Circular]'</code>:</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = {};\nobj.a = [obj];\nobj.b = {};\nobj.b.inner = obj.b;\nobj.b.obj = obj;\n\nconsole.log(inspect(obj));\n// {\n//   a: [ [Circular] ],\n//   b: { inner: [Circular], obj: [Circular] }\n// }\n</code></pre>\n<p>The following example inspects all properties of the <code>util</code> object:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));\n</code></pre>\n<p>The following example highlights the effect of the <code>compact</code> option:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst o = {\n  a: [1, 2, [[\n    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +\n      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',\n    'test',\n    'foo']], 4],\n  b: new Map([['za', 1], ['zb', 'test']])\n};\nconsole.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));\n\n// { a:\n//   [ 1,\n//     2,\n//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line\n//           'test',\n//           'foo' ] ],\n//     4 ],\n//   b: Map { 'za' => 1, 'zb' => 'test' } }\n\n// Setting `compact` to false changes the output to be more reader friendly.\nconsole.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));\n\n// {\n//   a: [\n//     1,\n//     2,\n//     [\n//       [\n//         'Lorem ipsum dolor sit amet, consectetur ' +\n//           'adipiscing elit, sed do eiusmod tempor ' +\n//           'incididunt ut labore et dolore magna ' +\n//           'aliqua.,\n//         'test',\n//         'foo'\n//       ]\n//     ],\n//     4\n//   ],\n//   b: Map {\n//     'za' => 1,\n//     'zb' => 'test'\n//   }\n// }\n\n// Setting `breakLength` to e.g. 150 will print the \"Lorem ipsum\" text in a\n// single line.\n// Reducing the `breakLength` will split the \"Lorem ipsum\" text in smaller\n// chunks.\n</code></pre>\n<p>The <code>showHidden</code> option allows <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> entries to be\ninspected. If there are more entries than <code>maxArrayLength</code>, there is no\nguarantee which entries are displayed. That means retrieving the same\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> entries twice may result in different output. Furthermore, entries\nwith no remaining strong references may be garbage collected at any time.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = { a: 1 };\nconst obj2 = { b: 2 };\nconst weakSet = new WeakSet([obj, obj2]);\n\nconsole.log(inspect(weakSet, { showHidden: true }));\n// WeakSet { { a: 1 }, { b: 2 } }\n</code></pre>\n<p>The <code>sorted</code> option ensures that an object's property insertion order does not\nimpact the result of <code>util.inspect()</code>.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\nconst assert = require('assert');\n\nconst o1 = {\n  b: [2, 3, 1],\n  a: '`a` comes before `b`',\n  c: new Set([2, 3, 1])\n};\nconsole.log(inspect(o1, { sorted: true }));\n// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set { 1, 2, 3 } }\nconsole.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));\n// { c: Set { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }\n\nconst o2 = {\n  c: new Set([2, 1, 3]),\n  a: '`a` comes before `b`',\n  b: [2, 3, 1]\n};\nassert.strict.equal(\n  inspect(o1, { sorted: true }),\n  inspect(o2, { sorted: true })\n);\n</code></pre>\n<p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum\noutput length is approximately 128 MB. Inputs that result in longer output will\nbe truncated.</p>",
+          "desc": "<p>The <code>util.inspect()</code> method returns a string representation of <code>object</code> that is\nintended for debugging. The output of <code>util.inspect</code> may change at any time\nand should not be depended upon programmatically. Additional <code>options</code> may be\npassed that alter the result.\n<code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make\nan identifiable tag for an inspected value.</p>\n<pre><code class=\"language-js\">class Foo {\n  get [Symbol.toStringTag]() {\n    return 'bar';\n  }\n}\n\nclass Bar {}\n\nconst baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });\n\nutil.inspect(new Foo()); // 'Foo [bar] {}'\nutil.inspect(new Bar()); // 'Bar {}'\nutil.inspect(baz);       // '[foo] {}'\n</code></pre>\n<p>Circular references point to their anchor by using a reference index:</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = {};\nobj.a = [obj];\nobj.b = {};\nobj.b.inner = obj.b;\nobj.b.obj = obj;\n\nconsole.log(inspect(obj));\n// &#x3C;ref *1> {\n//   a: [ [Circular *1] ],\n//   b: &#x3C;ref *2> { inner: [Circular *2], obj: [Circular *1] }\n// }\n</code></pre>\n<p>The following example inspects all properties of the <code>util</code> object:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));\n</code></pre>\n<p>The following example highlights the effect of the <code>compact</code> option:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst o = {\n  a: [1, 2, [[\n    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +\n      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',\n    'test',\n    'foo']], 4],\n  b: new Map([['za', 1], ['zb', 'test']])\n};\nconsole.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));\n\n// { a:\n//   [ 1,\n//     2,\n//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line\n//           'test',\n//           'foo' ] ],\n//     4 ],\n//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }\n\n// Setting `compact` to false changes the output to be more reader friendly.\nconsole.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));\n\n// {\n//   a: [\n//     1,\n//     2,\n//     [\n//       [\n//         'Lorem ipsum dolor sit amet, consectetur ' +\n//           'adipiscing elit, sed do eiusmod tempor ' +\n//           'incididunt ut labore et dolore magna ' +\n//           'aliqua.,\n//         'test',\n//         'foo'\n//       ]\n//     ],\n//     4\n//   ],\n//   b: Map(2) {\n//     'za' => 1,\n//     'zb' => 'test'\n//   }\n// }\n\n// Setting `breakLength` to e.g. 150 will print the \"Lorem ipsum\" text in a\n// single line.\n// Reducing the `breakLength` will split the \"Lorem ipsum\" text in smaller\n// chunks.\n</code></pre>\n<p>The <code>showHidden</code> option allows <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> entries to be\ninspected. If there are more entries than <code>maxArrayLength</code>, there is no\nguarantee which entries are displayed. That means retrieving the same\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> entries twice may result in different output. Furthermore, entries\nwith no remaining strong references may be garbage collected at any time.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = { a: 1 };\nconst obj2 = { b: 2 };\nconst weakSet = new WeakSet([obj, obj2]);\n\nconsole.log(inspect(weakSet, { showHidden: true }));\n// WeakSet { { a: 1 }, { b: 2 } }\n</code></pre>\n<p>The <code>sorted</code> option ensures that an object's property insertion order does not\nimpact the result of <code>util.inspect()</code>.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\nconst assert = require('assert');\n\nconst o1 = {\n  b: [2, 3, 1],\n  a: '`a` comes before `b`',\n  c: new Set([2, 3, 1])\n};\nconsole.log(inspect(o1, { sorted: true }));\n// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }\nconsole.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));\n// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }\n\nconst o2 = {\n  c: new Set([2, 1, 3]),\n  a: '`a` comes before `b`',\n  b: [2, 3, 1]\n};\nassert.strict.equal(\n  inspect(o1, { sorted: true }),\n  inspect(o2, { sorted: true })\n);\n</code></pre>\n<p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum\noutput length is approximately 128 MB. Inputs that result in longer output will\nbe truncated.</p>",
           "miscs": [
             {
               "textRaw": "Customizing `util.inspect` colors",
@@ -55664,7 +61496,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.2",
+                    "version": [
+                      "v13.12.0",
+                      "v12.16.2"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/31672",
                     "description": "This is now defined as a shared symbol."
                   }
@@ -55674,6 +61509,29 @@
               "shortDesc": "that can be used to declare custom promisified variants of functions, see [Custom promisified functions][]."
             }
           ]
+        },
+        {
+          "textRaw": "`util.toUSVString(string)`",
+          "type": "method",
+          "name": "toUSVString",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`string` {string}",
+                  "name": "string",
+                  "type": "string"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Returns the <code>string</code> after replacing any surrogate code points\n(or equivalently, any unpaired surrogate code units) with the\nUnicode \"replacement character\" U+FFFD.</p>"
         }
       ],
       "classes": [
@@ -55692,28 +61550,28 @@
             {
               "textRaw": "WHATWG supported encodings",
               "name": "whatwg_supported_encodings",
-              "desc": "<p>Per the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a>, the encodings supported by the\n<code>TextDecoder</code> API are outlined in the tables below. For each encoding,\none or more aliases may be used.</p>\n<p>Different Node.js build configurations support different sets of encodings.\nWhile a very basic set of encodings is supported even on Node.js builds without\nICU enabled, support for some encodings is provided only when Node.js is built\nwith ICU and using the full ICU data (see <a href=\"intl.html\">Internationalization</a>).</p>",
+              "desc": "<p>Per the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a>, the encodings supported by the\n<code>TextDecoder</code> API are outlined in the tables below. For each encoding,\none or more aliases may be used.</p>\n<p>Different Node.js build configurations support different sets of encodings.\n(see <a href=\"intl.html\">Internationalization</a>)</p>",
               "modules": [
                 {
-                  "textRaw": "Encodings Supported Without ICU",
-                  "name": "encodings_supported_without_icu",
-                  "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'utf-8'</code></td>\n<td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td>\n</tr>\n<tr>\n<td><code>'utf-16le'</code></td>\n<td><code>'utf-16'</code></td>\n</tr>\n</tbody>\n</table>",
+                  "textRaw": "Encodings supported by default (with full ICU data)",
+                  "name": "encodings_supported_by_default_(with_full_icu_data)",
+                  "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'ibm866'</code></td>\n<td><code>'866'</code>, <code>'cp866'</code>, <code>'csibm866'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-2'</code></td>\n<td><code>'csisolatin2'</code>, <code>'iso-ir-101'</code>, <code>'iso8859-2'</code>, <code>'iso88592'</code>, <code>'iso_8859-2'</code>, <code>'iso_8859-2:1987'</code>, <code>'l2'</code>, <code>'latin2'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-3'</code></td>\n<td><code>'csisolatin3'</code>, <code>'iso-ir-109'</code>, <code>'iso8859-3'</code>, <code>'iso88593'</code>, <code>'iso_8859-3'</code>, <code>'iso_8859-3:1988'</code>, <code>'l3'</code>, <code>'latin3'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-4'</code></td>\n<td><code>'csisolatin4'</code>, <code>'iso-ir-110'</code>, <code>'iso8859-4'</code>, <code>'iso88594'</code>, <code>'iso_8859-4'</code>, <code>'iso_8859-4:1988'</code>, <code>'l4'</code>, <code>'latin4'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-5'</code></td>\n<td><code>'csisolatincyrillic'</code>, <code>'cyrillic'</code>, <code>'iso-ir-144'</code>, <code>'iso8859-5'</code>, <code>'iso88595'</code>, <code>'iso_8859-5'</code>, <code>'iso_8859-5:1988'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-6'</code></td>\n<td><code>'arabic'</code>, <code>'asmo-708'</code>, <code>'csiso88596e'</code>, <code>'csiso88596i'</code>, <code>'csisolatinarabic'</code>, <code>'ecma-114'</code>, <code>'iso-8859-6-e'</code>, <code>'iso-8859-6-i'</code>, <code>'iso-ir-127'</code>, <code>'iso8859-6'</code>, <code>'iso88596'</code>, <code>'iso_8859-6'</code>, <code>'iso_8859-6:1987'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-7'</code></td>\n<td><code>'csisolatingreek'</code>, <code>'ecma-118'</code>, <code>'elot_928'</code>, <code>'greek'</code>, <code>'greek8'</code>, <code>'iso-ir-126'</code>, <code>'iso8859-7'</code>, <code>'iso88597'</code>, <code>'iso_8859-7'</code>, <code>'iso_8859-7:1987'</code>, <code>'sun_eu_greek'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-8'</code></td>\n<td><code>'csiso88598e'</code>, <code>'csisolatinhebrew'</code>, <code>'hebrew'</code>, <code>'iso-8859-8-e'</code>, <code>'iso-ir-138'</code>, <code>'iso8859-8'</code>, <code>'iso88598'</code>, <code>'iso_8859-8'</code>, <code>'iso_8859-8:1988'</code>, <code>'visual'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-8-i'</code></td>\n<td><code>'csiso88598i'</code>, <code>'logical'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-10'</code></td>\n<td><code>'csisolatin6'</code>, <code>'iso-ir-157'</code>, <code>'iso8859-10'</code>, <code>'iso885910'</code>, <code>'l6'</code>, <code>'latin6'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-13'</code></td>\n<td><code>'iso8859-13'</code>, <code>'iso885913'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-14'</code></td>\n<td><code>'iso8859-14'</code>, <code>'iso885914'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-15'</code></td>\n<td><code>'csisolatin9'</code>, <code>'iso8859-15'</code>, <code>'iso885915'</code>, <code>'iso_8859-15'</code>, <code>'l9'</code></td>\n</tr>\n<tr>\n<td><code>'koi8-r'</code></td>\n<td><code>'cskoi8r'</code>, <code>'koi'</code>, <code>'koi8'</code>, <code>'koi8_r'</code></td>\n</tr>\n<tr>\n<td><code>'koi8-u'</code></td>\n<td><code>'koi8-ru'</code></td>\n</tr>\n<tr>\n<td><code>'macintosh'</code></td>\n<td><code>'csmacintosh'</code>, <code>'mac'</code>, <code>'x-mac-roman'</code></td>\n</tr>\n<tr>\n<td><code>'windows-874'</code></td>\n<td><code>'dos-874'</code>, <code>'iso-8859-11'</code>, <code>'iso8859-11'</code>, <code>'iso885911'</code>, <code>'tis-620'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1250'</code></td>\n<td><code>'cp1250'</code>, <code>'x-cp1250'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1251'</code></td>\n<td><code>'cp1251'</code>, <code>'x-cp1251'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1252'</code></td>\n<td><code>'ansi_x3.4-1968'</code>, <code>'ascii'</code>, <code>'cp1252'</code>, <code>'cp819'</code>, <code>'csisolatin1'</code>, <code>'ibm819'</code>, <code>'iso-8859-1'</code>, <code>'iso-ir-100'</code>, <code>'iso8859-1'</code>, <code>'iso88591'</code>, <code>'iso_8859-1'</code>, <code>'iso_8859-1:1987'</code>, <code>'l1'</code>, <code>'latin1'</code>, <code>'us-ascii'</code>, <code>'x-cp1252'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1253'</code></td>\n<td><code>'cp1253'</code>, <code>'x-cp1253'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1254'</code></td>\n<td><code>'cp1254'</code>, <code>'csisolatin5'</code>, <code>'iso-8859-9'</code>, <code>'iso-ir-148'</code>, <code>'iso8859-9'</code>, <code>'iso88599'</code>, <code>'iso_8859-9'</code>, <code>'iso_8859-9:1989'</code>, <code>'l5'</code>, <code>'latin5'</code>, <code>'x-cp1254'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1255'</code></td>\n<td><code>'cp1255'</code>, <code>'x-cp1255'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1256'</code></td>\n<td><code>'cp1256'</code>, <code>'x-cp1256'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1257'</code></td>\n<td><code>'cp1257'</code>, <code>'x-cp1257'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1258'</code></td>\n<td><code>'cp1258'</code>, <code>'x-cp1258'</code></td>\n</tr>\n<tr>\n<td><code>'x-mac-cyrillic'</code></td>\n<td><code>'x-mac-ukrainian'</code></td>\n</tr>\n<tr>\n<td><code>'gbk'</code></td>\n<td><code>'chinese'</code>, <code>'csgb2312'</code>, <code>'csiso58gb231280'</code>, <code>'gb2312'</code>, <code>'gb_2312'</code>, <code>'gb_2312-80'</code>, <code>'iso-ir-58'</code>, <code>'x-gbk'</code></td>\n</tr>\n<tr>\n<td><code>'gb18030'</code></td>\n<td></td>\n</tr>\n<tr>\n<td><code>'big5'</code></td>\n<td><code>'big5-hkscs'</code>, <code>'cn-big5'</code>, <code>'csbig5'</code>, <code>'x-x-big5'</code></td>\n</tr>\n<tr>\n<td><code>'euc-jp'</code></td>\n<td><code>'cseucpkdfmtjapanese'</code>, <code>'x-euc-jp'</code></td>\n</tr>\n<tr>\n<td><code>'iso-2022-jp'</code></td>\n<td><code>'csiso2022jp'</code></td>\n</tr>\n<tr>\n<td><code>'shift_jis'</code></td>\n<td><code>'csshiftjis'</code>, <code>'ms932'</code>, <code>'ms_kanji'</code>, <code>'shift-jis'</code>, <code>'sjis'</code>, <code>'windows-31j'</code>, <code>'x-sjis'</code></td>\n</tr>\n<tr>\n<td><code>'euc-kr'</code></td>\n<td><code>'cseuckr'</code>, <code>'csksc56011987'</code>, <code>'iso-ir-149'</code>, <code>'korean'</code>, <code>'ks_c_5601-1987'</code>, <code>'ks_c_5601-1989'</code>, <code>'ksc5601'</code>, <code>'ksc_5601'</code>, <code>'windows-949'</code></td>\n</tr>\n</tbody>\n</table>",
                   "type": "module",
-                  "displayName": "Encodings Supported Without ICU"
+                  "displayName": "Encodings supported by default (with full ICU data)"
                 },
                 {
-                  "textRaw": "Encodings Supported by Default (With ICU)",
-                  "name": "encodings_supported_by_default_(with_icu)",
+                  "textRaw": "Encodings supported when Node.js is built with the `small-icu` option",
+                  "name": "encodings_supported_when_node.js_is_built_with_the_`small-icu`_option",
                   "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'utf-8'</code></td>\n<td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td>\n</tr>\n<tr>\n<td><code>'utf-16le'</code></td>\n<td><code>'utf-16'</code></td>\n</tr>\n<tr>\n<td><code>'utf-16be'</code></td>\n<td></td>\n</tr>\n</tbody>\n</table>",
                   "type": "module",
-                  "displayName": "Encodings Supported by Default (With ICU)"
+                  "displayName": "Encodings supported when Node.js is built with the `small-icu` option"
                 },
                 {
-                  "textRaw": "Encodings requiring full ICU data",
-                  "name": "encodings_requiring_full_icu_data",
-                  "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'ibm866'</code></td>\n<td><code>'866'</code>, <code>'cp866'</code>, <code>'csibm866'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-2'</code></td>\n<td><code>'csisolatin2'</code>, <code>'iso-ir-101'</code>, <code>'iso8859-2'</code>, <code>'iso88592'</code>, <code>'iso_8859-2'</code>, <code>'iso_8859-2:1987'</code>, <code>'l2'</code>, <code>'latin2'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-3'</code></td>\n<td><code>'csisolatin3'</code>, <code>'iso-ir-109'</code>, <code>'iso8859-3'</code>, <code>'iso88593'</code>, <code>'iso_8859-3'</code>, <code>'iso_8859-3:1988'</code>, <code>'l3'</code>, <code>'latin3'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-4'</code></td>\n<td><code>'csisolatin4'</code>, <code>'iso-ir-110'</code>, <code>'iso8859-4'</code>, <code>'iso88594'</code>, <code>'iso_8859-4'</code>, <code>'iso_8859-4:1988'</code>, <code>'l4'</code>, <code>'latin4'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-5'</code></td>\n<td><code>'csisolatincyrillic'</code>, <code>'cyrillic'</code>, <code>'iso-ir-144'</code>, <code>'iso8859-5'</code>, <code>'iso88595'</code>, <code>'iso_8859-5'</code>, <code>'iso_8859-5:1988'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-6'</code></td>\n<td><code>'arabic'</code>, <code>'asmo-708'</code>, <code>'csiso88596e'</code>, <code>'csiso88596i'</code>, <code>'csisolatinarabic'</code>, <code>'ecma-114'</code>, <code>'iso-8859-6-e'</code>, <code>'iso-8859-6-i'</code>, <code>'iso-ir-127'</code>, <code>'iso8859-6'</code>, <code>'iso88596'</code>, <code>'iso_8859-6'</code>, <code>'iso_8859-6:1987'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-7'</code></td>\n<td><code>'csisolatingreek'</code>, <code>'ecma-118'</code>, <code>'elot_928'</code>, <code>'greek'</code>, <code>'greek8'</code>, <code>'iso-ir-126'</code>, <code>'iso8859-7'</code>, <code>'iso88597'</code>, <code>'iso_8859-7'</code>, <code>'iso_8859-7:1987'</code>, <code>'sun_eu_greek'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-8'</code></td>\n<td><code>'csiso88598e'</code>, <code>'csisolatinhebrew'</code>, <code>'hebrew'</code>, <code>'iso-8859-8-e'</code>, <code>'iso-ir-138'</code>, <code>'iso8859-8'</code>, <code>'iso88598'</code>, <code>'iso_8859-8'</code>, <code>'iso_8859-8:1988'</code>, <code>'visual'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-8-i'</code></td>\n<td><code>'csiso88598i'</code>, <code>'logical'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-10'</code></td>\n<td><code>'csisolatin6'</code>, <code>'iso-ir-157'</code>, <code>'iso8859-10'</code>, <code>'iso885910'</code>, <code>'l6'</code>, <code>'latin6'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-13'</code></td>\n<td><code>'iso8859-13'</code>, <code>'iso885913'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-14'</code></td>\n<td><code>'iso8859-14'</code>, <code>'iso885914'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-15'</code></td>\n<td><code>'csisolatin9'</code>, <code>'iso8859-15'</code>, <code>'iso885915'</code>, <code>'iso_8859-15'</code>, <code>'l9'</code></td>\n</tr>\n<tr>\n<td><code>'koi8-r'</code></td>\n<td><code>'cskoi8r'</code>, <code>'koi'</code>, <code>'koi8'</code>, <code>'koi8_r'</code></td>\n</tr>\n<tr>\n<td><code>'koi8-u'</code></td>\n<td><code>'koi8-ru'</code></td>\n</tr>\n<tr>\n<td><code>'macintosh'</code></td>\n<td><code>'csmacintosh'</code>, <code>'mac'</code>, <code>'x-mac-roman'</code></td>\n</tr>\n<tr>\n<td><code>'windows-874'</code></td>\n<td><code>'dos-874'</code>, <code>'iso-8859-11'</code>, <code>'iso8859-11'</code>, <code>'iso885911'</code>, <code>'tis-620'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1250'</code></td>\n<td><code>'cp1250'</code>, <code>'x-cp1250'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1251'</code></td>\n<td><code>'cp1251'</code>, <code>'x-cp1251'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1252'</code></td>\n<td><code>'ansi_x3.4-1968'</code>, <code>'ascii'</code>, <code>'cp1252'</code>, <code>'cp819'</code>, <code>'csisolatin1'</code>, <code>'ibm819'</code>, <code>'iso-8859-1'</code>, <code>'iso-ir-100'</code>, <code>'iso8859-1'</code>, <code>'iso88591'</code>, <code>'iso_8859-1'</code>, <code>'iso_8859-1:1987'</code>, <code>'l1'</code>, <code>'latin1'</code>, <code>'us-ascii'</code>, <code>'x-cp1252'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1253'</code></td>\n<td><code>'cp1253'</code>, <code>'x-cp1253'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1254'</code></td>\n<td><code>'cp1254'</code>, <code>'csisolatin5'</code>, <code>'iso-8859-9'</code>, <code>'iso-ir-148'</code>, <code>'iso8859-9'</code>, <code>'iso88599'</code>, <code>'iso_8859-9'</code>, <code>'iso_8859-9:1989'</code>, <code>'l5'</code>, <code>'latin5'</code>, <code>'x-cp1254'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1255'</code></td>\n<td><code>'cp1255'</code>, <code>'x-cp1255'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1256'</code></td>\n<td><code>'cp1256'</code>, <code>'x-cp1256'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1257'</code></td>\n<td><code>'cp1257'</code>, <code>'x-cp1257'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1258'</code></td>\n<td><code>'cp1258'</code>, <code>'x-cp1258'</code></td>\n</tr>\n<tr>\n<td><code>'x-mac-cyrillic'</code></td>\n<td><code>'x-mac-ukrainian'</code></td>\n</tr>\n<tr>\n<td><code>'gbk'</code></td>\n<td><code>'chinese'</code>, <code>'csgb2312'</code>, <code>'csiso58gb231280'</code>, <code>'gb2312'</code>, <code>'gb_2312'</code>, <code>'gb_2312-80'</code>, <code>'iso-ir-58'</code>, <code>'x-gbk'</code></td>\n</tr>\n<tr>\n<td><code>'gb18030'</code></td>\n<td></td>\n</tr>\n<tr>\n<td><code>'big5'</code></td>\n<td><code>'big5-hkscs'</code>, <code>'cn-big5'</code>, <code>'csbig5'</code>, <code>'x-x-big5'</code></td>\n</tr>\n<tr>\n<td><code>'euc-jp'</code></td>\n<td><code>'cseucpkdfmtjapanese'</code>, <code>'x-euc-jp'</code></td>\n</tr>\n<tr>\n<td><code>'iso-2022-jp'</code></td>\n<td><code>'csiso2022jp'</code></td>\n</tr>\n<tr>\n<td><code>'shift_jis'</code></td>\n<td><code>'csshiftjis'</code>, <code>'ms932'</code>, <code>'ms_kanji'</code>, <code>'shift-jis'</code>, <code>'sjis'</code>, <code>'windows-31j'</code>, <code>'x-sjis'</code></td>\n</tr>\n<tr>\n<td><code>'euc-kr'</code></td>\n<td><code>'cseuckr'</code>, <code>'csksc56011987'</code>, <code>'iso-ir-149'</code>, <code>'korean'</code>, <code>'ks_c_5601-1987'</code>, <code>'ks_c_5601-1989'</code>, <code>'ksc5601'</code>, <code>'ksc_5601'</code>, <code>'windows-949'</code></td>\n</tr>\n</tbody>\n</table>\n<p>The <code>'iso-8859-16'</code> encoding listed in the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a>\nis not supported.</p>",
+                  "textRaw": "Encodings supported when ICU is disabled",
+                  "name": "encodings_supported_when_icu_is_disabled",
+                  "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'utf-8'</code></td>\n<td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td>\n</tr>\n<tr>\n<td><code>'utf-16le'</code></td>\n<td><code>'utf-16'</code></td>\n</tr>\n</tbody>\n</table>\n<p>The <code>'iso-8859-16'</code> encoding listed in the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a>\nis not supported.</p>",
                   "type": "module",
-                  "displayName": "Encodings requiring full ICU data"
+                  "displayName": "Encodings supported when ICU is disabled"
                 }
               ],
               "type": "module",
@@ -55795,11 +61653,11 @@
                   "type": "Object",
                   "options": [
                     {
-                      "textRaw": "`fatal` {boolean} `true` if decoding failures are fatal. This option is only supported when ICU is enabled (see [Internationalization][]). **Default:** `false`.",
+                      "textRaw": "`fatal` {boolean} `true` if decoding failures are fatal. This option is not supported when ICU is disabled (see [Internationalization][]). **Default:** `false`.",
                       "name": "fatal",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "`true` if decoding failures are fatal. This option is only supported when ICU is enabled (see [Internationalization][])."
+                      "desc": "`true` if decoding failures are fatal. This option is not supported when ICU is disabled (see [Internationalization][])."
                     },
                     {
                       "textRaw": "`ignoreBOM` {boolean} When `true`, the `TextDecoder` will include the byte order mark in the decoded result. When `false`, the byte order mark will be removed from the output. This option is only used when `encoding` is `'utf-8'`, `'utf-16be'` or `'utf-16le'`. **Default:** `false`.",
@@ -55826,7 +61684,7 @@
             "changes": [
               {
                 "version": "v11.0.0",
-                "pr-url": "v11.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/22281",
                 "description": "The class is now available on the global object."
               }
             ]
@@ -57023,8 +62881,13 @@
                 "added": [
                   "v10.0.0"
                 ],
+                "deprecated": [
+                  "v14.0.0"
+                ],
                 "changes": []
               },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use `value instanceof WebAssembly.Module` instead.",
               "signatures": [
                 {
                   "return": {
@@ -57614,13 +63477,14 @@
         }
       ],
       "type": "module",
-      "displayName": "Util"
+      "displayName": "Util",
+      "source": "doc/api/util.md"
     },
     {
       "textRaw": "V8",
       "name": "v8",
       "introduced_in": "v4.0.0",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/v8.js\">lib/v8.js</a></p>\n<p>The <code>v8</code> module exposes APIs that are specific to the version of <a href=\"https://developers.google.com/v8/\">V8</a>\nbuilt into the Node.js binary. It can be accessed using:</p>\n<pre><code class=\"language-js\">const v8 = require('v8');\n</code></pre>\n<p>The APIs and implementation are subject to change at any time.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/v8.js\">lib/v8.js</a></p>\n<p>The <code>v8</code> module exposes APIs that are specific to the version of <a href=\"https://developers.google.com/v8/\">V8</a>\nbuilt into the Node.js binary. It can be accessed using:</p>\n<pre><code class=\"language-js\">const v8 = require('v8');\n</code></pre>",
       "methods": [
         {
           "textRaw": "`v8.cachedDataVersionTag()`",
@@ -57642,35 +63506,29 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns an integer representing a \"version tag\" derived from the V8 version,\ncommand line flags and detected CPU features. This is useful for determining\nwhether a <a href=\"vm.html#vm_new_vm_script_code_options\"><code>vm.Script</code></a> <code>cachedData</code> buffer is compatible with this instance\nof V8.</p>"
+          "desc": "<p>Returns an integer representing a version tag derived from the V8 version,\ncommand-line flags, and detected CPU features. This is useful for determining\nwhether a <a href=\"vm.html#vm_new_vm_script_code_options\"><code>vm.Script</code></a> <code>cachedData</code> buffer is compatible with this instance\nof V8.</p>\n<pre><code class=\"language-js\">console.log(v8.cachedDataVersionTag()); // 3947234607\n// The value returned by v8.cachedDataVersionTag() is derived from the V8\n// version, command-line flags, and detected CPU features. Test that the value\n// does indeed update when flags are toggled.\nv8.setFlagsFromString('--allow_natives_syntax');\nconsole.log(v8.cachedDataVersionTag()); // 183726201\n</code></pre>"
         },
         {
-          "textRaw": "`v8.getHeapSpaceStatistics()`",
+          "textRaw": "`v8.getHeapCodeStatistics()`",
           "type": "method",
-          "name": "getHeapSpaceStatistics",
+          "name": "getHeapCodeStatistics",
           "meta": {
             "added": [
-              "v6.0.0"
+              "v12.8.0"
             ],
-            "changes": [
-              {
-                "version": "v7.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10186",
-                "description": "Support values exceeding the 32-bit unsigned integer range."
-              }
-            ]
+            "changes": []
           },
           "signatures": [
             {
               "return": {
-                "textRaw": "Returns: {Object[]}",
+                "textRaw": "Returns: {Object}",
                 "name": "return",
-                "type": "Object[]"
+                "type": "Object"
               },
               "params": []
             }
           ],
-          "desc": "<p>Returns statistics about the V8 heap spaces, i.e. the segments which make up\nthe V8 heap. Neither the ordering of heap spaces, nor the availability of a\nheap space can be guaranteed as the statistics are provided via the V8\n<a href=\"https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4\"><code>GetHeapSpaceStatistics</code></a> function and may change from one V8 version to the\nnext.</p>\n<p>The value returned is an array of objects containing the following properties:</p>\n<ul>\n<li><code>space_name</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>space_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>space_used_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>space_available_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>physical_space_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">[\n  {\n    \"space_name\": \"new_space\",\n    \"space_size\": 2063872,\n    \"space_used_size\": 951112,\n    \"space_available_size\": 80824,\n    \"physical_space_size\": 2063872\n  },\n  {\n    \"space_name\": \"old_space\",\n    \"space_size\": 3090560,\n    \"space_used_size\": 2493792,\n    \"space_available_size\": 0,\n    \"physical_space_size\": 3090560\n  },\n  {\n    \"space_name\": \"code_space\",\n    \"space_size\": 1260160,\n    \"space_used_size\": 644256,\n    \"space_available_size\": 960,\n    \"physical_space_size\": 1260160\n  },\n  {\n    \"space_name\": \"map_space\",\n    \"space_size\": 1094160,\n    \"space_used_size\": 201608,\n    \"space_available_size\": 0,\n    \"physical_space_size\": 1094160\n  },\n  {\n    \"space_name\": \"large_object_space\",\n    \"space_size\": 0,\n    \"space_used_size\": 0,\n    \"space_available_size\": 1490980608,\n    \"physical_space_size\": 0\n  }\n]\n</code></pre>"
+          "desc": "<p>Returns an object with the following properties:</p>\n<ul>\n<li><code>code_and_metadata_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>bytecode_and_metadata_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>external_script_source_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  code_and_metadata_size: 212208,\n  bytecode_and_metadata_size: 161368,\n  external_script_source_size: 1410794\n}\n</code></pre>"
         },
         {
           "textRaw": "`v8.getHeapSnapshot()`",
@@ -57693,22 +63551,17 @@
               "params": []
             }
           ],
-          "desc": "<p>Generates a snapshot of the current V8 heap and returns a Readable\nStream that may be used to read the JSON serialized representation.\nThis JSON stream format is intended to be used with tools such as\nChrome DevTools. The JSON schema is undocumented and specific to the\nV8 engine, and may change from one version of V8 to the next.</p>\n<pre><code class=\"language-js\">const stream = v8.getHeapSnapshot();\nstream.pipe(process.stdout);\n</code></pre>"
+          "desc": "<p>Generates a snapshot of the current V8 heap and returns a Readable\nStream that may be used to read the JSON serialized representation.\nThis JSON stream format is intended to be used with tools such as\nChrome DevTools. The JSON schema is undocumented and specific to the\nV8 engine. Therefore, the schema may change from one version of V8 to the next.</p>\n<pre><code class=\"language-js\">// Print heap snapshot to the console\nconst v8 = require('v8');\nconst stream = v8.getHeapSnapshot();\nstream.pipe(process.stdout);\n</code></pre>"
         },
         {
-          "textRaw": "`v8.getHeapStatistics()`",
+          "textRaw": "`v8.getHeapSpaceStatistics()`",
           "type": "method",
-          "name": "getHeapStatistics",
+          "name": "getHeapSpaceStatistics",
           "meta": {
             "added": [
-              "v1.0.0"
+              "v6.0.0"
             ],
             "changes": [
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/8610",
-                "description": "Added `malloced_memory`, `peak_malloced_memory`, and `does_zap_garbage`."
-              },
               {
                 "version": "v7.5.0",
                 "pr-url": "https://github.com/nodejs/node/pull/10186",
@@ -57719,24 +63572,35 @@
           "signatures": [
             {
               "return": {
-                "textRaw": "Returns: {Object}",
+                "textRaw": "Returns: {Object[]}",
                 "name": "return",
-                "type": "Object"
+                "type": "Object[]"
               },
               "params": []
             }
           ],
-          "desc": "<p>Returns an object with the following properties:</p>\n<ul>\n<li><code>total_heap_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_heap_size_executable</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_physical_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_available_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>used_heap_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>heap_size_limit</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>malloced_memory</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>peak_malloced_memory</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>does_zap_garbage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>number_of_native_contexts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>number_of_detached_contexts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<p><code>does_zap_garbage</code> is a 0/1 boolean, which signifies whether the\n<code>--zap_code_space</code> option is enabled or not. This makes V8 overwrite heap\ngarbage with a bit pattern. The RSS footprint (resident memory set) gets bigger\nbecause it continuously touches all heap pages and that makes them less likely\nto get swapped out by the operating system.</p>\n<p><code>number_of_native_contexts</code> The value of native_context is the number of the\ntop-level contexts currently active. Increase of this number over time indicates\na memory leak.</p>\n<p><code>number_of_detached_contexts</code> The value of detached_context is the number\nof contexts that were detached and not yet garbage collected. This number\nbeing non-zero indicates a potential memory leak.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  total_heap_size: 7326976,\n  total_heap_size_executable: 4194304,\n  total_physical_size: 7326976,\n  total_available_size: 1152656,\n  used_heap_size: 3476208,\n  heap_size_limit: 1535115264,\n  malloced_memory: 16384,\n  peak_malloced_memory: 1127496,\n  does_zap_garbage: 0,\n  number_of_native_contexts: 1,\n  number_of_detached_contexts: 0\n}\n</code></pre>"
+          "desc": "<p>Returns statistics about the V8 heap spaces, i.e. the segments which make up\nthe V8 heap. Neither the ordering of heap spaces, nor the availability of a\nheap space can be guaranteed as the statistics are provided via the V8\n<a href=\"https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4\"><code>GetHeapSpaceStatistics</code></a> function and may change from one V8 version to the\nnext.</p>\n<p>The value returned is an array of objects containing the following properties:</p>\n<ul>\n<li><code>space_name</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>space_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>space_used_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>space_available_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>physical_space_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">[\n  {\n    \"space_name\": \"new_space\",\n    \"space_size\": 2063872,\n    \"space_used_size\": 951112,\n    \"space_available_size\": 80824,\n    \"physical_space_size\": 2063872\n  },\n  {\n    \"space_name\": \"old_space\",\n    \"space_size\": 3090560,\n    \"space_used_size\": 2493792,\n    \"space_available_size\": 0,\n    \"physical_space_size\": 3090560\n  },\n  {\n    \"space_name\": \"code_space\",\n    \"space_size\": 1260160,\n    \"space_used_size\": 644256,\n    \"space_available_size\": 960,\n    \"physical_space_size\": 1260160\n  },\n  {\n    \"space_name\": \"map_space\",\n    \"space_size\": 1094160,\n    \"space_used_size\": 201608,\n    \"space_available_size\": 0,\n    \"physical_space_size\": 1094160\n  },\n  {\n    \"space_name\": \"large_object_space\",\n    \"space_size\": 0,\n    \"space_used_size\": 0,\n    \"space_available_size\": 1490980608,\n    \"physical_space_size\": 0\n  }\n]\n</code></pre>"
         },
         {
-          "textRaw": "`v8.getHeapCodeStatistics()`",
+          "textRaw": "`v8.getHeapStatistics()`",
           "type": "method",
-          "name": "getHeapCodeStatistics",
+          "name": "getHeapStatistics",
           "meta": {
             "added": [
-              "v12.8.0"
+              "v1.0.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v7.5.0",
+                "pr-url": "https://github.com/nodejs/node/pull/10186",
+                "description": "Support values exceeding the 32-bit unsigned integer range."
+              },
+              {
+                "version": "v7.2.0",
+                "pr-url": "https://github.com/nodejs/node/pull/8610",
+                "description": "Added `malloced_memory`, `peak_malloced_memory`, and `does_zap_garbage`."
+              }
+            ]
           },
           "signatures": [
             {
@@ -57748,7 +63612,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns an object with the following properties:</p>\n<ul>\n<li><code>code_and_metadata_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>bytecode_and_metadata_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>external_script_source_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  code_and_metadata_size: 212208,\n  bytecode_and_metadata_size: 161368,\n  external_script_source_size: 1410794\n}\n</code></pre>"
+          "desc": "<p>Returns an object with the following properties:</p>\n<ul>\n<li><code>total_heap_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_heap_size_executable</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_physical_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_available_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>used_heap_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>heap_size_limit</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>malloced_memory</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>peak_malloced_memory</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>does_zap_garbage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>number_of_native_contexts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>number_of_detached_contexts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<p><code>does_zap_garbage</code> is a 0/1 boolean, which signifies whether the\n<code>--zap_code_space</code> option is enabled or not. This makes V8 overwrite heap\ngarbage with a bit pattern. The RSS footprint (resident set size) gets bigger\nbecause it continuously touches all heap pages and that makes them less likely\nto get swapped out by the operating system.</p>\n<p><code>number_of_native_contexts</code> The value of native_context is the number of the\ntop-level contexts currently active. Increase of this number over time indicates\na memory leak.</p>\n<p><code>number_of_detached_contexts</code> The value of detached_context is the number\nof contexts that were detached and not yet garbage collected. This number\nbeing non-zero indicates a potential memory leak.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  total_heap_size: 7326976,\n  total_heap_size_executable: 4194304,\n  total_physical_size: 7326976,\n  total_available_size: 1152656,\n  used_heap_size: 3476208,\n  heap_size_limit: 1535115264,\n  malloced_memory: 16384,\n  peak_malloced_memory: 1127496,\n  does_zap_garbage: 0,\n  number_of_native_contexts: 1,\n  number_of_detached_contexts: 0\n}\n</code></pre>"
         },
         {
           "textRaw": "`v8.setFlagsFromString(flags)`",
@@ -57771,15 +63635,15 @@
               ]
             }
           ],
-          "desc": "<p>The <code>v8.setFlagsFromString()</code> method can be used to programmatically set\nV8 command line flags. This method should be used with care. Changing settings\nafter the VM has started may result in unpredictable behavior, including\ncrashes and data loss; or it may simply do nothing.</p>\n<p>The V8 options available for a version of Node.js may be determined by running\n<code>node --v8-options</code>.</p>\n<p>Usage:</p>\n<pre><code class=\"language-js\">// Print GC events to stdout for one minute.\nconst v8 = require('v8');\nv8.setFlagsFromString('--trace_gc');\nsetTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);\n</code></pre>"
+          "desc": "<p>The <code>v8.setFlagsFromString()</code> method can be used to programmatically set\nV8 command-line flags. This method should be used with care. Changing settings\nafter the VM has started may result in unpredictable behavior, including\ncrashes and data loss; or it may simply do nothing.</p>\n<p>The V8 options available for a version of Node.js may be determined by running\n<code>node --v8-options</code>.</p>\n<p>Usage:</p>\n<pre><code class=\"language-js\">// Print GC events to stdout for one minute.\nconst v8 = require('v8');\nv8.setFlagsFromString('--trace_gc');\nsetTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);\n</code></pre>"
         },
         {
-          "textRaw": "`v8.takeCoverage()`",
+          "textRaw": "`v8.stopCoverage()`",
           "type": "method",
-          "name": "takeCoverage",
+          "name": "stopCoverage",
           "meta": {
             "added": [
-              "v12.22.0"
+              "v14.18.0"
             ],
             "changes": []
           },
@@ -57788,15 +63652,15 @@
               "params": []
             }
           ],
-          "desc": "<p>The <code>v8.takeCoverage()</code> method allows the user to write the coverage started by\n<a href=\"cli.md#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a> to disk on demand. This method can be invoked multiple\ntimes during the lifetime of the process, each time the execution counter will\nbe reset and a new coverage report will be written to the directory specified\nby <a href=\"cli.md#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a>.</p>\n<p>When the process is about to exit, one last coverage will still be written to\ndisk, unless <a href=\"v8.html#v8_v8_stopcoverage\"><code>v8.stopCoverage()</code></a> is invoked before the process exits.</p>"
+          "desc": "<p>The <code>v8.stopCoverage()</code> method allows the user to stop the coverage collection\nstarted by <a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a>, so that V8 can release the execution count\nrecords and optimize code. This can be used in conjunction with\n<a href=\"v8.html#v8_v8_takecoverage\"><code>v8.takeCoverage()</code></a> if the user wants to collect the coverage on demand.</p>"
         },
         {
-          "textRaw": "`v8.stopCoverage()`",
+          "textRaw": "`v8.takeCoverage()`",
           "type": "method",
-          "name": "stopCoverage",
+          "name": "takeCoverage",
           "meta": {
             "added": [
-              "v12.22.0"
+              "v14.18.0"
             ],
             "changes": []
           },
@@ -57805,7 +63669,7 @@
               "params": []
             }
           ],
-          "desc": "<p>The <code>v8.stopCoverage()</code> method allows the user to stop the coverage collection\nstarted by <a href=\"cli.md#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a>, so that V8 can release the execution count\nrecords and optimize code. This can be used in conjunction with\n<code>v8.takeCoverage()</code> if the user wants to collect the coverage on demand.</p>"
+          "desc": "<p>The <code>v8.takeCoverage()</code> method allows the user to write the coverage started by\n<a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a> to disk on demand. This method can be invoked multiple\ntimes during the lifetime of the process. Each time the execution counter will\nbe reset and a new coverage report will be written to the directory specified\nby <a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a>.</p>\n<p>When the process is about to exit, one last coverage will still be written to\ndisk unless <a href=\"v8.html#v8_v8_stopcoverage\"><code>v8.stopCoverage()</code></a> is invoked before the process exits.</p>"
         },
         {
           "textRaw": "`v8.writeHeapSnapshot([filename])`",
@@ -58326,7 +64190,8 @@
         }
       ],
       "type": "module",
-      "displayName": "V8"
+      "displayName": "V8",
+      "source": "doc/api/v8.md"
     },
     {
       "textRaw": "VM (executing JavaScript)",
@@ -58334,7 +64199,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/vm.js\">lib/vm.js</a></p>\n<p>The <code>vm</code> module enables compiling and running code within V8 Virtual\nMachine contexts. <strong>The <code>vm</code> module is not a security mechanism. Do\nnot use it to run untrusted code</strong>.</p>\n<p>JavaScript code can be compiled and run immediately or\ncompiled, saved, and run later.</p>\n<p>A common use case is to run the code in a different V8 Context. This means\ninvoked code has a different global object than the invoking code.</p>\n<p>One can provide the context by <a href=\"vm.html#vm_what_does_it_mean_to_contextify_an_object\"><em>contextifying</em></a> an\nobject. The invoked code treats any property in the context like a\nglobal variable. Any changes to global variables caused by the invoked\ncode are reflected in the context object.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst x = 1;\n\nconst context = { x: 2 };\nvm.createContext(context); // Contextify the object.\n\nconst code = 'x += 40; var y = 17;';\n// `x` and `y` are global variables in the context.\n// Initially, x has the value 2 because that is the value of context.x.\nvm.runInContext(code, context);\n\nconsole.log(context.x); // 42\nconsole.log(context.y); // 17\n\nconsole.log(x); // 1; y is not defined.\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/vm.js\">lib/vm.js</a></p>\n<p>The <code>vm</code> module enables compiling and running code within V8 Virtual\nMachine contexts. <strong>The <code>vm</code> module is not a security mechanism. Do\nnot use it to run untrusted code</strong>.</p>\n<p>JavaScript code can be compiled and run immediately or\ncompiled, saved, and run later.</p>\n<p>A common use case is to run the code in a different V8 Context. This means\ninvoked code has a different global object than the invoking code.</p>\n<p>One can provide the context by <a href=\"vm.html#vm_what_does_it_mean_to_contextify_an_object\"><em>contextifying</em></a> an\nobject. The invoked code treats any property in the context like a\nglobal variable. Any changes to global variables caused by the invoked\ncode are reflected in the context object.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst x = 1;\n\nconst context = { x: 2 };\nvm.createContext(context); // Contextify the object.\n\nconst code = 'x += 40; var y = 17;';\n// `x` and `y` are global variables in the context.\n// Initially, x has the value 2 because that is the value of context.x.\nvm.runInContext(code, context);\n\nconsole.log(context.x); // 42\nconsole.log(context.y); // 17\n\nconsole.log(x); // 1; y is not defined.\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `vm.Script`",
@@ -58368,7 +64233,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Creates a code cache that can be used with the Script constructor's\n<code>cachedData</code> option. Returns a Buffer. This method may be called at any\ntime and any number of times.</p>\n<pre><code class=\"language-js\">const script = new vm.Script(`\nfunction add(a, b) {\n  return a + b;\n}\n\nconst x = add(1, 2);\n`);\n\nconst cacheWithoutX = script.createCachedData();\n\nscript.runInThisContext();\n\nconst cacheWithX = script.createCachedData();\n</code></pre>"
+              "desc": "<p>Creates a code cache that can be used with the <code>Script</code> constructor's\n<code>cachedData</code> option. Returns a <code>Buffer</code>. This method may be called at any\ntime and any number of times.</p>\n<pre><code class=\"language-js\">const script = new vm.Script(`\nfunction add(a, b) {\n  return a + b;\n}\n\nconst x = add(1, 2);\n`);\n\nconst cacheWithoutX = script.createCachedData();\n\nscript.runInThisContext();\n\nconst cacheWithX = script.createCachedData();\n</code></pre>"
             },
             {
               "textRaw": "`script.runInContext(contextifiedObject[, options])`",
@@ -58420,11 +64285,11 @@
                           "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                         },
                         {
-                          "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                          "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                           "name": "breakOnSigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                          "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                         }
                       ]
                     }
@@ -58442,6 +64307,11 @@
                   "v0.3.1"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34023",
+                    "description": "The `microtaskMode` option is supported now."
+                  },
                   {
                     "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/19016",
@@ -58488,11 +64358,11 @@
                           "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                         },
                         {
-                          "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                          "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                           "name": "breakOnSigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                          "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                         },
                         {
                           "textRaw": "`contextName` {string} Human-readable name of the newly created context. **Default:** `'VM Context i'`, where `i` is an ascending numerical index of the created context.",
@@ -58528,6 +64398,12 @@
                               "desc": "If set to false any attempt to compile a WebAssembly module will throw a `WebAssembly.CompileError`."
                             }
                           ]
+                        },
+                        {
+                          "textRaw": "`microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after the script has run. They are included in the `timeout` and `breakOnSigint` scopes in that case.",
+                          "name": "microtaskMode",
+                          "type": "string",
+                          "desc": "If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after the script has run. They are included in the `timeout` and `breakOnSigint` scopes in that case."
                         }
                       ]
                     }
@@ -58580,11 +64456,11 @@
                           "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                         },
                         {
-                          "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                          "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                           "name": "breakOnSigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                          "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                         }
                       ]
                     }
@@ -58623,11 +64499,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or `TypedArray`, or `DataView` with V8's code cache data for the supplied source. When supplied, the `cachedDataRejected` value will be set to either `true` or `false` depending on acceptance of the data by V8.",
@@ -58643,10 +64519,10 @@
                       "desc": "When `true` and no `cachedData` is present, V8 will attempt to produce code cache data for `code`. Upon success, a `Buffer` with V8's code cache data will be produced and stored in the `cachedData` property of the returned `vm.Script` instance. The `cachedDataProduced` value will be set to either `true` or `false` depending on whether code cache data is produced successfully. This option is **deprecated** in favor of `script.createCachedData()`."
                     },
                     {
-                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "name": "importModuleDynamically",
                       "type": "Function",
-                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "options": [
                         {
                           "textRaw": "`specifier` {string} specifier passed to `import()`",
@@ -58655,9 +64531,9 @@
                           "desc": "specifier passed to `import()`"
                         },
                         {
-                          "textRaw": "`module` {vm.Module}",
-                          "name": "module",
-                          "type": "vm.Module"
+                          "textRaw": "`script` {vm.Script}",
+                          "name": "script",
+                          "type": "vm.Script"
                         },
                         {
                           "textRaw": "Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports.",
@@ -58680,13 +64556,14 @@
           "name": "vm.Module",
           "meta": {
             "added": [
+              "v13.0.0",
               "v12.16.0"
             ],
             "changes": []
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</em></p>\n<p>The <code>vm.Module</code> class provides a low-level interface for using\nECMAScript modules in VM contexts. It is the counterpart of the <code>vm.Script</code>\nclass that closely mirrors <a href=\"https://www.ecma-international.org/ecma-262/#sec-abstract-module-records\">Module Record</a>s as defined in the ECMAScript\nspecification.</p>\n<p>Unlike <code>vm.Script</code> however, every <code>vm.Module</code> object is bound to a context from\nits creation. Operations on <code>vm.Module</code> objects are intrinsically asynchronous,\nin contrast with the synchronous nature of <code>vm.Script</code> objects. The use of\n'async' functions can help with manipulating <code>vm.Module</code> objects.</p>\n<p>Using a <code>vm.Module</code> object requires three distinct steps: creation/parsing,\nlinking, and evaluation. These three steps are illustrated in the following\nexample.</p>\n<p>This implementation lies at a lower level than the <a href=\"esm.html#esm_modules_ecmascript_modules\">ECMAScript Module\nloader</a>. There is also no way to interact with the Loader yet, though\nsupport is planned.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst contextifiedObject = vm.createContext({ secret: 42 });\n\n(async () => {\n  // Step 1\n  //\n  // Create a Module by constructing a new `vm.SourceTextModule` object. This\n  // parses the provided source text, throwing a `SyntaxError` if anything goes\n  // wrong. By default, a Module is created in the top context. But here, we\n  // specify `contextifiedObject` as the context this Module belongs to.\n  //\n  // Here, we attempt to obtain the default export from the module \"foo\", and\n  // put it into local binding \"secret\".\n\n  const bar = new vm.SourceTextModule(`\n    import s from 'foo';\n    s;\n  `, { context: contextifiedObject });\n\n  // Step 2\n  //\n  // \"Link\" the imported dependencies of this Module to it.\n  //\n  // The provided linking callback (the \"linker\") accepts two arguments: the\n  // parent module (`bar` in this case) and the string that is the specifier of\n  // the imported module. The callback is expected to return a Module that\n  // corresponds to the provided specifier, with certain requirements documented\n  // in `module.link()`.\n  //\n  // If linking has not started for the returned Module, the same linker\n  // callback will be called on the returned Module.\n  //\n  // Even top-level Modules without dependencies must be explicitly linked. The\n  // callback provided would never be called, however.\n  //\n  // The link() method returns a Promise that will be resolved when all the\n  // Promises returned by the linker resolve.\n  //\n  // Note: This is a contrived example in that the linker function creates a new\n  // \"foo\" module every time it is called. In a full-fledged module system, a\n  // cache would probably be used to avoid duplicated modules.\n\n  async function linker(specifier, referencingModule) {\n    if (specifier === 'foo') {\n      return new vm.SourceTextModule(`\n        // The \"secret\" variable refers to the global variable we added to\n        // \"contextifiedObject\" when creating the context.\n        export default secret;\n      `, { context: referencingModule.context });\n\n      // Using `contextifiedObject` instead of `referencingModule.context`\n      // here would work as well.\n    }\n    throw new Error(`Unable to resolve dependency: ${specifier}`);\n  }\n  await bar.link(linker);\n\n  // Step 3\n  //\n  // Evaluate the Module. The evaluate() method returns a Promise with a single\n  // property \"result\" that contains the result of the very last statement\n  // executed in the Module. In the case of `bar`, it is `s;`, which refers to\n  // the default export of the `foo` module, the `secret` we set in the\n  // beginning to 42.\n\n  const { result } = await bar.evaluate();\n\n  console.log(result);\n  // Prints 42.\n})();\n</code></pre>",
+          "desc": "<p>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</p>\n<p>The <code>vm.Module</code> class provides a low-level interface for using\nECMAScript modules in VM contexts. It is the counterpart of the <code>vm.Script</code>\nclass that closely mirrors <a href=\"https://www.ecma-international.org/ecma-262/#sec-abstract-module-records\">Module Record</a>s as defined in the ECMAScript\nspecification.</p>\n<p>Unlike <code>vm.Script</code> however, every <code>vm.Module</code> object is bound to a context from\nits creation. Operations on <code>vm.Module</code> objects are intrinsically asynchronous,\nin contrast with the synchronous nature of <code>vm.Script</code> objects. The use of\n'async' functions can help with manipulating <code>vm.Module</code> objects.</p>\n<p>Using a <code>vm.Module</code> object requires three distinct steps: creation/parsing,\nlinking, and evaluation. These three steps are illustrated in the following\nexample.</p>\n<p>This implementation lies at a lower level than the <a href=\"esm.html#esm_modules_ecmascript_modules\">ECMAScript Module\nloader</a>. There is also no way to interact with the Loader yet, though\nsupport is planned.</p>\n<pre><code class=\"language-mjs\">import vm from 'vm';\n\nconst contextifiedObject = vm.createContext({\n  secret: 42,\n  print: console.log,\n});\n\n// Step 1\n//\n// Create a Module by constructing a new `vm.SourceTextModule` object. This\n// parses the provided source text, throwing a `SyntaxError` if anything goes\n// wrong. By default, a Module is created in the top context. But here, we\n// specify `contextifiedObject` as the context this Module belongs to.\n//\n// Here, we attempt to obtain the default export from the module \"foo\", and\n// put it into local binding \"secret\".\n\nconst bar = new vm.SourceTextModule(`\n  import s from 'foo';\n  s;\n  print(s);\n`, { context: contextifiedObject });\n\n// Step 2\n//\n// \"Link\" the imported dependencies of this Module to it.\n//\n// The provided linking callback (the \"linker\") accepts two arguments: the\n// parent module (`bar` in this case) and the string that is the specifier of\n// the imported module. The callback is expected to return a Module that\n// corresponds to the provided specifier, with certain requirements documented\n// in `module.link()`.\n//\n// If linking has not started for the returned Module, the same linker\n// callback will be called on the returned Module.\n//\n// Even top-level Modules without dependencies must be explicitly linked. The\n// callback provided would never be called, however.\n//\n// The link() method returns a Promise that will be resolved when all the\n// Promises returned by the linker resolve.\n//\n// Note: This is a contrived example in that the linker function creates a new\n// \"foo\" module every time it is called. In a full-fledged module system, a\n// cache would probably be used to avoid duplicated modules.\n\nasync function linker(specifier, referencingModule) {\n  if (specifier === 'foo') {\n    return new vm.SourceTextModule(`\n      // The \"secret\" variable refers to the global variable we added to\n      // \"contextifiedObject\" when creating the context.\n      export default secret;\n    `, { context: referencingModule.context });\n\n    // Using `contextifiedObject` instead of `referencingModule.context`\n    // here would work as well.\n  }\n  throw new Error(`Unable to resolve dependency: ${specifier}`);\n}\nawait bar.link(linker);\n\n// Step 3\n//\n// Evaluate the Module. The evaluate() method returns a promise which will\n// resolve after the module has finished evaluating.\n\n// Prints 42.\nawait bar.evaluate();\n</code></pre>\n<pre><code class=\"language-cjs\">const vm = require('vm');\n\nconst contextifiedObject = vm.createContext({\n  secret: 42,\n  print: console.log,\n});\n\n(async () => {\n  // Step 1\n  //\n  // Create a Module by constructing a new `vm.SourceTextModule` object. This\n  // parses the provided source text, throwing a `SyntaxError` if anything goes\n  // wrong. By default, a Module is created in the top context. But here, we\n  // specify `contextifiedObject` as the context this Module belongs to.\n  //\n  // Here, we attempt to obtain the default export from the module \"foo\", and\n  // put it into local binding \"secret\".\n\n  const bar = new vm.SourceTextModule(`\n    import s from 'foo';\n    s;\n    print(s);\n  `, { context: contextifiedObject });\n\n  // Step 2\n  //\n  // \"Link\" the imported dependencies of this Module to it.\n  //\n  // The provided linking callback (the \"linker\") accepts two arguments: the\n  // parent module (`bar` in this case) and the string that is the specifier of\n  // the imported module. The callback is expected to return a Module that\n  // corresponds to the provided specifier, with certain requirements documented\n  // in `module.link()`.\n  //\n  // If linking has not started for the returned Module, the same linker\n  // callback will be called on the returned Module.\n  //\n  // Even top-level Modules without dependencies must be explicitly linked. The\n  // callback provided would never be called, however.\n  //\n  // The link() method returns a Promise that will be resolved when all the\n  // Promises returned by the linker resolve.\n  //\n  // Note: This is a contrived example in that the linker function creates a new\n  // \"foo\" module every time it is called. In a full-fledged module system, a\n  // cache would probably be used to avoid duplicated modules.\n\n  async function linker(specifier, referencingModule) {\n    if (specifier === 'foo') {\n      return new vm.SourceTextModule(`\n        // The \"secret\" variable refers to the global variable we added to\n        // \"contextifiedObject\" when creating the context.\n        export default secret;\n      `, { context: referencingModule.context });\n\n      // Using `contextifiedObject` instead of `referencingModule.context`\n      // here would work as well.\n    }\n    throw new Error(`Unable to resolve dependency: ${specifier}`);\n  }\n  await bar.link(linker);\n\n  // Step 3\n  //\n  // Evaluate the Module. The evaluate() method returns a promise which will\n  // resolve after the module has finished evaluating.\n\n  // Prints 42.\n  await bar.evaluate();\n})();\n</code></pre>",
           "properties": [
             {
               "textRaw": "`dependencySpecifiers` {string[]}",
@@ -58700,6 +64577,12 @@
               "name": "error",
               "desc": "<p>If the <code>module.status</code> is <code>'errored'</code>, this property contains the exception\nthrown by the module during evaluation. If the status is anything else,\naccessing this property will result in a thrown exception.</p>\n<p>The value <code>undefined</code> cannot be used for cases where there is not a thrown\nexception due to possible ambiguity with <code>throw undefined;</code>.</p>\n<p>Corresponds to the <code>[[EvaluationError]]</code> field of <a href=\"https://tc39.es/ecma262/#sec-cyclic-module-records\">Cyclic Module Record</a>s\nin the ECMAScript specification.</p>"
             },
+            {
+              "textRaw": "`identifier` {string}",
+              "type": "string",
+              "name": "identifier",
+              "desc": "<p>The identifier of the current module, as set in the constructor.</p>"
+            },
             {
               "textRaw": "`namespace` {Object}",
               "type": "Object",
@@ -58711,12 +64594,6 @@
               "type": "string",
               "name": "status",
               "desc": "<p>The current status of the module. Will be one of:</p>\n<ul>\n<li>\n<p><code>'unlinked'</code>: <code>module.link()</code> has not yet been called.</p>\n</li>\n<li>\n<p><code>'linking'</code>: <code>module.link()</code> has been called, but not all Promises returned\nby the linker function have been resolved yet.</p>\n</li>\n<li>\n<p><code>'linked'</code>: The module has been linked successfully, and all of its\ndependencies are linked, but <code>module.evaluate()</code> has not yet been called.</p>\n</li>\n<li>\n<p><code>'evaluating'</code>: The module is being evaluated through a <code>module.evaluate()</code> on\nitself or a parent module.</p>\n</li>\n<li>\n<p><code>'evaluated'</code>: The module has been successfully evaluated.</p>\n</li>\n<li>\n<p><code>'errored'</code>: The module has been evaluated, but an exception was thrown.</p>\n</li>\n</ul>\n<p>Other than <code>'errored'</code>, this status string corresponds to the specification's\n<a href=\"https://tc39.es/ecma262/#sec-cyclic-module-records\">Cyclic Module Record</a>'s <code>[[Status]]</code> field. <code>'errored'</code> corresponds to\n<code>'evaluated'</code> in the specification, but with <code>[[EvaluationError]]</code> set to a\nvalue that is not <code>undefined</code>.</p>"
-            },
-            {
-              "textRaw": "`identifier` {string}",
-              "type": "string",
-              "name": "identifier",
-              "desc": "<p>The identifier of the current module, as set in the constructor.</p>"
             }
           ],
           "methods": [
@@ -58727,9 +64604,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -58744,18 +64622,18 @@
                           "desc": "Specifies the number of milliseconds to evaluate before terminating execution. If execution is interrupted, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                         },
                         {
-                          "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is interrupted, an [`Error`][] will be thrown. **Default:** `false`.",
+                          "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                           "name": "breakOnSigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is interrupted, an [`Error`][] will be thrown."
+                          "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Evaluate the module.</p>\n<p>This must be called after the module has been linked; otherwise it will\nthrow an error. It could be called also when the module has already been\nevaluated, in which case it will do one of the following two things:</p>\n<ul>\n<li>return <code>undefined</code> if the initial evaluation ended in success (<code>module.status</code>\nis <code>'evaluated'</code>)</li>\n<li>rethrow the same exception the initial evaluation threw if the initial\nevaluation ended in an error (<code>module.status</code> is <code>'errored'</code>)</li>\n</ul>\n<p>This method cannot be called while the module is being evaluated\n(<code>module.status</code> is <code>'evaluating'</code>) to prevent infinite recursion.</p>\n<p>Corresponds to the <a href=\"https://tc39.es/ecma262/#sec-moduleevaluation\">Evaluate() concrete method</a> field of <a href=\"https://tc39.es/ecma262/#sec-cyclic-module-records\">Cyclic Module\nRecord</a>s in the ECMAScript specification.</p>"
+              "desc": "<p>Evaluate the module.</p>\n<p>This must be called after the module has been linked; otherwise it will reject.\nIt could be called also when the module has already been evaluated, in which\ncase it will either do nothing if the initial evaluation ended in success\n(<code>module.status</code> is <code>'evaluated'</code>) or it will re-throw the exception that the\ninitial evaluation resulted in (<code>module.status</code> is <code>'errored'</code>).</p>\n<p>This method cannot be called while the module is being evaluated\n(<code>module.status</code> is <code>'evaluating'</code>).</p>\n<p>Corresponds to the <a href=\"https://tc39.es/ecma262/#sec-moduleevaluation\">Evaluate() concrete method</a> field of <a href=\"https://tc39.es/ecma262/#sec-cyclic-module-records\">Cyclic Module\nRecord</a>s in the ECMAScript specification.</p>"
             },
             {
               "textRaw": "`module.link(linker)`",
@@ -58775,10 +64653,10 @@
                       "type": "Function",
                       "options": [
                         {
-                          "textRaw": "`specifier` {string} The specifier of the requested module:```js import foo from 'foo'; // ^^^^^ the module specifier ```",
+                          "textRaw": "`specifier` {string} The specifier of the requested module:```mjs import foo from 'foo'; // ^^^^^ the module specifier ```",
                           "name": "specifier",
                           "type": "string",
-                          "desc": "The specifier of the requested module:```js import foo from 'foo'; // ^^^^^ the module specifier ```"
+                          "desc": "The specifier of the requested module:```mjs import foo from 'foo'; // ^^^^^ the module specifier ```"
                         },
                         {
                           "textRaw": "`referencingModule` {vm.Module} The `Module` object `link()` is called on.",
@@ -58812,7 +64690,7 @@
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</em></p>\n<ul>\n<li>Extends: <a href=\"vm.html#vm_class_vm_module\" class=\"type\">&lt;vm.Module&gt;</a></li>\n</ul>\n<p>The <code>vm.SourceTextModule</code> class provides the <a href=\"https://tc39.es/ecma262/#sec-source-text-module-records\">Source Text Module Record</a> as\ndefined in the ECMAScript specification.</p>",
+          "desc": "<p>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</p>\n<ul>\n<li>Extends: <a href=\"vm.html#vm_class_vm_module\" class=\"type\">&lt;vm.Module&gt;</a></li>\n</ul>\n<p>The <code>vm.SourceTextModule</code> class provides the <a href=\"https://tc39.es/ecma262/#sec-source-text-module-records\">Source Text Module Record</a> as\ndefined in the ECMAScript specification.</p>",
           "methods": [
             {
               "textRaw": "`sourceTextModule.createCachedData()`",
@@ -58820,7 +64698,7 @@
               "name": "createCachedData",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.7.0"
                 ],
                 "changes": []
               },
@@ -58834,7 +64712,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Creates a code cache that can be used with the SourceTextModule constructor's\n<code>cachedData</code> option. Returns a Buffer. This method may be called any number\nof times before the module has been evaluated.</p>\n<pre><code class=\"language-js\">// Create an initial module\nconst module = new vm.SourceTextModule('const a = 1;');\n\n// Create cached data from this module\nconst cachedData = module.createCachedData();\n\n// Create a new module using the cached data. The code must be the same.\nconst module2 = new vm.SourceTextModule('const a = 1;', { cachedData });\n</code></pre>"
+              "desc": "<p>Creates a code cache that can be used with the <code>SourceTextModule</code> constructor's\n<code>cachedData</code> option. Returns a <code>Buffer</code>. This method may be called any number\nof times before the module has been evaluated.</p>\n<pre><code class=\"language-js\">// Create an initial module\nconst module = new vm.SourceTextModule('const a = 1;');\n\n// Create cached data from this module\nconst cachedData = module.createCachedData();\n\n// Create a new module using the cached data. The code must be the same.\nconst module2 = new vm.SourceTextModule('const a = 1;', { cachedData });\n</code></pre>"
             }
           ],
           "signatures": [
@@ -58877,11 +64755,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this `Module`."
                     },
                     {
-                      "textRaw": "`columnOffset` {integer} Specifies the column number offset that is displayed in stack traces produced by this `Module`. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {integer} Specifies the first-line column number offset that is displayed in stack traces produced by this `Module`. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "integer",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this `Module`."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this `Module`."
                     },
                     {
                       "textRaw": "`initializeImportMeta` {Function} Called during evaluation of this `Module` to initialize the `import.meta`.",
@@ -58929,7 +64807,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Creates a new <code>SourceTextModule</code> instance.</p>\n<p>Properties assigned to the <code>import.meta</code> object that are objects may\nallow the module to access information outside the specified <code>context</code>. Use\n<code>vm.runInContext()</code> to create objects in a specific context.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst contextifiedObject = vm.createContext({ secret: 42 });\n\n(async () => {\n  const module = new vm.SourceTextModule(\n    'Object.getPrototypeOf(import.meta.prop).secret = secret;',\n    {\n      initializeImportMeta(meta) {\n        // Note: this object is created in the top context. As such,\n        // Object.getPrototypeOf(import.meta.prop) points to the\n        // Object.prototype in the top context rather than that in\n        // the contextified object.\n        meta.prop = {};\n      }\n    });\n  // Since module has no dependencies, the linker function will never be called.\n  await module.link(() => {});\n  await module.evaluate();\n\n  // Now, Object.prototype.secret will be equal to 42.\n  //\n  // To fix this problem, replace\n  //     meta.prop = {};\n  // above with\n  //     meta.prop = vm.runInContext('{}', contextifiedObject);\n})();\n</code></pre>"
+              "desc": "<p>Creates a new <code>SourceTextModule</code> instance.</p>\n<p>Properties assigned to the <code>import.meta</code> object that are objects may\nallow the module to access information outside the specified <code>context</code>. Use\n<code>vm.runInContext()</code> to create objects in a specific context.</p>\n<pre><code class=\"language-mjs\">import vm from 'vm';\n\nconst contextifiedObject = vm.createContext({ secret: 42 });\n\nconst module = new vm.SourceTextModule(\n  'Object.getPrototypeOf(import.meta.prop).secret = secret;',\n  {\n    initializeImportMeta(meta) {\n      // Note: this object is created in the top context. As such,\n      // Object.getPrototypeOf(import.meta.prop) points to the\n      // Object.prototype in the top context rather than that in\n      // the contextified object.\n      meta.prop = {};\n    }\n  });\n// Since module has no dependencies, the linker function will never be called.\nawait module.link(() => {});\nawait module.evaluate();\n\n// Now, Object.prototype.secret will be equal to 42.\n//\n// To fix this problem, replace\n//     meta.prop = {};\n// above with\n//     meta.prop = vm.runInContext('{}', contextifiedObject);\n</code></pre>\n<pre><code class=\"language-cjs\">const vm = require('vm');\nconst contextifiedObject = vm.createContext({ secret: 42 });\n(async () => {\n  const module = new vm.SourceTextModule(\n    'Object.getPrototypeOf(import.meta.prop).secret = secret;',\n    {\n      initializeImportMeta(meta) {\n        // Note: this object is created in the top context. As such,\n        // Object.getPrototypeOf(import.meta.prop) points to the\n        // Object.prototype in the top context rather than that in\n        // the contextified object.\n        meta.prop = {};\n      }\n    });\n  // Since module has no dependencies, the linker function will never be called.\n  await module.link(() => {});\n  await module.evaluate();\n  // Now, Object.prototype.secret will be equal to 42.\n  //\n  // To fix this problem, replace\n  //     meta.prop = {};\n  // above with\n  //     meta.prop = vm.runInContext('{}', contextifiedObject);\n})();\n</code></pre>"
             }
           ]
         },
@@ -58939,13 +64817,14 @@
           "name": "vm.SyntheticModule",
           "meta": {
             "added": [
+              "v13.0.0",
               "v12.16.0"
             ],
             "changes": []
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</em></p>\n<ul>\n<li>Extends: <a href=\"vm.html#vm_class_vm_module\" class=\"type\">&lt;vm.Module&gt;</a></li>\n</ul>\n<p>The <code>vm.SyntheticModule</code> class provides the <a href=\"https://heycam.github.io/webidl/#synthetic-module-records\">Synthetic Module Record</a> as\ndefined in the WebIDL specification. The purpose of synthetic modules is to\nprovide a generic interface for exposing non-JavaScript sources to ECMAScript\nmodule graphs.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst source = '{ \"a\": 1 }';\nconst module = new vm.SyntheticModule(['default'], function() {\n  const obj = JSON.parse(source);\n  this.setExport('default', obj);\n});\n\n// Use `module` in linking...\n</code></pre>",
+          "desc": "<p>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</p>\n<ul>\n<li>Extends: <a href=\"vm.html#vm_class_vm_module\" class=\"type\">&lt;vm.Module&gt;</a></li>\n</ul>\n<p>The <code>vm.SyntheticModule</code> class provides the <a href=\"https://heycam.github.io/webidl/#synthetic-module-records\">Synthetic Module Record</a> as\ndefined in the WebIDL specification. The purpose of synthetic modules is to\nprovide a generic interface for exposing non-JavaScript sources to ECMAScript\nmodule graphs.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst source = '{ \"a\": 1 }';\nconst module = new vm.SyntheticModule(['default'], function() {\n  const obj = JSON.parse(source);\n  this.setExport('default', obj);\n});\n\n// Use `module` in linking...\n</code></pre>",
           "methods": [
             {
               "textRaw": "`syntheticModule.setExport(name, value)`",
@@ -58953,6 +64832,7 @@
               "name": "setExport",
               "meta": {
                 "added": [
+                  "v13.0.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -58975,7 +64855,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This method is used after the module is linked to set the values of exports. If\nit is called before the module is linked, an <a href=\"errors.html#ERR_VM_MODULE_STATUS\"><code>ERR_VM_MODULE_STATUS</code></a> error\nwill be thrown.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\n(async () => {\n  const m = new vm.SyntheticModule(['x'], () => {\n    m.setExport('x', 1);\n  });\n\n  await m.link(() => {});\n  await m.evaluate();\n\n  assert.strictEqual(m.namespace.x, 1);\n})();\n</code></pre>"
+              "desc": "<p>This method is used after the module is linked to set the values of exports. If\nit is called before the module is linked, an <a href=\"errors.html#ERR_VM_MODULE_STATUS\"><code>ERR_VM_MODULE_STATUS</code></a> error\nwill be thrown.</p>\n<pre><code class=\"language-mjs\">import vm from 'vm';\n\nconst m = new vm.SyntheticModule(['x'], () => {\n  m.setExport('x', 1);\n});\n\nawait m.link(() => {});\nawait m.evaluate();\n\nassert.strictEqual(m.namespace.x, 1);\n</code></pre>\n<pre><code class=\"language-cjs\">const vm = require('vm');\n(async () => {\n  const m = new vm.SyntheticModule(['x'], () => {\n    m.setExport('x', 1);\n  });\n  await m.link(() => {});\n  await m.evaluate();\n  assert.strictEqual(m.namespace.x, 1);\n})();\n</code></pre>"
             }
           ],
           "signatures": [
@@ -58994,21 +64874,15 @@
                   "desc": "Called when the module is evaluated."
                 },
                 {
-                  "textRaw": "`options`",
+                  "textRaw": "`options`**Default:** `'vm:module(i)'` where `i` is a context-specific ascending index.",
                   "name": "options",
+                  "default": "`'vm:module(i)'` where `i` is a context-specific ascending index",
                   "options": [
                     {
-                      "textRaw": "`identifier` {string} String used in stack traces. **Default:** `'vm:module(i)'` where `i` is a context-specific ascending index.",
+                      "textRaw": "`identifier` {string} String used in stack traces.",
                       "name": "identifier",
                       "type": "string",
-                      "default": "`'vm:module(i)'` where `i` is a context-specific ascending index",
                       "desc": "String used in stack traces."
-                    },
-                    {
-                      "textRaw": "`context` {Object} The [contextified][] object as returned by the `vm.createContext()` method, to compile and evaluate this `Module` in.",
-                      "name": "context",
-                      "type": "Object",
-                      "desc": "The [contextified][] object as returned by the `vm.createContext()` method, to compile and evaluate this `Module` in."
                     }
                   ]
                 }
@@ -59027,7 +64901,21 @@
             "added": [
               "v10.10.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.3.0",
+                "pr-url": "https://github.com/nodejs/node/pull/33364",
+                "description": "Removal of `importModuleDynamically` due to compatibility issues."
+              },
+              {
+                "version": [
+                  "v14.1.0",
+                  "v13.14.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/32985",
+                "description": "The `importModuleDynamically` option is now supported."
+              }
+            ]
           },
           "signatures": [
             {
@@ -59069,11 +64957,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or `TypedArray`, or `DataView` with V8's code cache data for the supplied source.",
@@ -59117,6 +65005,11 @@
               "v0.3.1"
             ],
             "changes": [
+              {
+                "version": "v14.6.0",
+                "pr-url": "https://github.com/nodejs/node/pull/34023",
+                "description": "The `microtaskMode` option is supported now."
+              },
               {
                 "version": "v10.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/19398",
@@ -59182,6 +65075,12 @@
                           "desc": "If set to false any attempt to compile a WebAssembly module will throw a `WebAssembly.CompileError`."
                         }
                       ]
+                    },
+                    {
+                      "textRaw": "`microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after a script has run through [`script.runInContext()`][]. They are included in the `timeout` and `breakOnSigint` scopes in that case.",
+                      "name": "microtaskMode",
+                      "type": "string",
+                      "desc": "If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after a script has run through [`script.runInContext()`][]. They are included in the `timeout` and `breakOnSigint` scopes in that case."
                     }
                   ]
                 }
@@ -59216,7 +65115,26 @@
               ]
             }
           ],
-          "desc": "<p>Returns <code>true</code> if the given <code>oject</code> object has been <a href=\"vm.html#vm_what_does_it_mean_to_contextify_an_object\">contextified</a> using\n<a href=\"vm.html#vm_vm_createcontext_contextobject_options\"><code>vm.createContext()</code></a>.</p>"
+          "desc": "<p>Returns <code>true</code> if the given <code>object</code> object has been <a href=\"vm.html#vm_what_does_it_mean_to_contextify_an_object\">contextified</a> using\n<a href=\"vm.html#vm_vm_createcontext_contextobject_options\"><code>vm.createContext()</code></a>.</p>"
+        },
+        {
+          "textRaw": "`vm.measureMemory([options])`",
+          "type": "method",
+          "name": "measureMemory",
+          "meta": {
+            "added": [
+              "v13.10.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<p>Measure the memory known to V8 and used by all contexts known to the\ncurrent V8 isolate, or the main context.</p>\n<ul>\n<li><code>options</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> Optional.\n<ul>\n<li><code>mode</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Either <code>'summary'</code> or <code>'detailed'</code>. In summary mode,\nonly the memory measured for the main context will be returned. In\ndetailed mode, the measure measured for all contexts known to the\ncurrent V8 isolate will be returned.\n<strong>Default:</strong> <code>'summary'</code></li>\n<li><code>execution</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Either <code>'default'</code> or <code>'eager'</code>. With default\nexecution, the promise will not resolve until after the next scheduled\ngarbage collection starts, which may take a while (or never if the program\nexits before the next GC). With eager execution, the GC will be started\nright away to measure the memory.\n<strong>Default:</strong> <code>'default'</code></li>\n</ul>\n</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise\" class=\"type\">&lt;Promise&gt;</a> If the memory is successfully measured the promise will\nresolve with an object containing information about the memory usage.</li>\n</ul>\n<p>The format of the object that the returned Promise may resolve with is\nspecific to the V8 engine and may change from one version of V8 to the next.</p>\n<p>The returned result is different from the statistics returned by\n<code>v8.getHeapSpaceStatistics()</code> in that <code>vm.measureMemory()</code> measure the\nmemory reachable by each V8 specific contexts in the current instance of\nthe V8 engine, while the result of <code>v8.getHeapSpaceStatistics()</code> measure\nthe memory occupied by each heap space in the current V8 instance.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n// Measure the memory used by the main context.\nvm.measureMemory({ mode: 'summary' })\n  // This is the same as vm.measureMemory()\n  .then((result) => {\n    // The current format is:\n    // {\n    //   total: {\n    //      jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]\n    //    }\n    // }\n    console.log(result);\n  });\n\nconst context = vm.createContext({ a: 1 });\nvm.measureMemory({ mode: 'detailed', execution: 'eager' })\n  .then((result) => {\n    // Reference the context here so that it won't be GC'ed\n    // until the measurement is complete.\n    console.log(context.a);\n    // {\n    //   total: {\n    //     jsMemoryEstimate: 2574732,\n    //     jsMemoryRange: [ 2574732, 2904372 ]\n    //   },\n    //   current: {\n    //     jsMemoryEstimate: 2438996,\n    //     jsMemoryRange: [ 2438996, 2768636 ]\n    //   },\n    //   other: [\n    //     {\n    //       jsMemoryEstimate: 135736,\n    //       jsMemoryRange: [ 135736, 465376 ]\n    //     }\n    //   ]\n    // }\n    console.log(result);\n  });\n</code></pre>"
         },
         {
           "textRaw": "`vm.runInContext(code, contextifiedObject[, options])`",
@@ -59275,11 +65193,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`displayErrors` {boolean} When `true`, if an [`Error`][] occurs while compiling the `code`, the line of code causing the error is attached to the stack trace. **Default:** `true`.",
@@ -59295,11 +65213,11 @@
                       "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                     },
                     {
-                      "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                      "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                       "name": "breakOnSigint",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                      "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                     },
                     {
                       "textRaw": "`cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or `TypedArray`, or `DataView` with V8's code cache data for the supplied source. When supplied, the `cachedDataRejected` value will be set to either `true` or `false` depending on acceptance of the data by V8.",
@@ -59315,10 +65233,10 @@
                       "desc": "When `true` and no `cachedData` is present, V8 will attempt to produce code cache data for `code`. Upon success, a `Buffer` with V8's code cache data will be produced and stored in the `cachedData` property of the returned `vm.Script` instance. The `cachedDataProduced` value will be set to either `true` or `false` depending on whether code cache data is produced successfully. This option is **deprecated** in favor of `script.createCachedData()`."
                     },
                     {
-                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "name": "importModuleDynamically",
                       "type": "Function",
-                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "options": [
                         {
                           "textRaw": "`specifier` {string} specifier passed to `import()`",
@@ -59327,9 +65245,9 @@
                           "desc": "specifier passed to `import()`"
                         },
                         {
-                          "textRaw": "`module` {vm.Module}",
-                          "name": "module",
-                          "type": "vm.Module"
+                          "textRaw": "`script` {vm.Script}",
+                          "name": "script",
+                          "type": "vm.Script"
                         },
                         {
                           "textRaw": "Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports.",
@@ -59355,6 +65273,11 @@
               "v0.3.1"
             ],
             "changes": [
+              {
+                "version": "v14.6.0",
+                "pr-url": "https://github.com/nodejs/node/pull/34023",
+                "description": "The `microtaskMode` option is supported now."
+              },
               {
                 "version": "v10.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/19016",
@@ -59408,11 +65331,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`displayErrors` {boolean} When `true`, if an [`Error`][] occurs while compiling the `code`, the line of code causing the error is attached to the stack trace. **Default:** `true`.",
@@ -59428,11 +65351,11 @@
                       "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                     },
                     {
-                      "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                      "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                       "name": "breakOnSigint",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                      "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                     },
                     {
                       "textRaw": "`contextName` {string} Human-readable name of the newly created context. **Default:** `'VM Context i'`, where `i` is an ascending numerical index of the created context.",
@@ -59483,10 +65406,10 @@
                       "desc": "When `true` and no `cachedData` is present, V8 will attempt to produce code cache data for `code`. Upon success, a `Buffer` with V8's code cache data will be produced and stored in the `cachedData` property of the returned `vm.Script` instance. The `cachedDataProduced` value will be set to either `true` or `false` depending on whether code cache data is produced successfully. This option is **deprecated** in favor of `script.createCachedData()`."
                     },
                     {
-                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "name": "importModuleDynamically",
                       "type": "Function",
-                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "options": [
                         {
                           "textRaw": "`specifier` {string} specifier passed to `import()`",
@@ -59495,9 +65418,9 @@
                           "desc": "specifier passed to `import()`"
                         },
                         {
-                          "textRaw": "`module` {vm.Module}",
-                          "name": "module",
-                          "type": "vm.Module"
+                          "textRaw": "`script` {vm.Script}",
+                          "name": "script",
+                          "type": "vm.Script"
                         },
                         {
                           "textRaw": "Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports.",
@@ -59506,6 +65429,12 @@
                           "desc": "Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports."
                         }
                       ]
+                    },
+                    {
+                      "textRaw": "`microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after the script has run. They are included in the `timeout` and `breakOnSigint` scopes in that case.",
+                      "name": "microtaskMode",
+                      "type": "string",
+                      "desc": "If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after the script has run. They are included in the `timeout` and `breakOnSigint` scopes in that case."
                     }
                   ]
                 }
@@ -59565,11 +65494,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`displayErrors` {boolean} When `true`, if an [`Error`][] occurs while compiling the `code`, the line of code causing the error is attached to the stack trace. **Default:** `true`.",
@@ -59585,11 +65514,11 @@
                       "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                     },
                     {
-                      "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                      "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                       "name": "breakOnSigint",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                      "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                     },
                     {
                       "textRaw": "`cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or `TypedArray`, or `DataView` with V8's code cache data for the supplied source. When supplied, the `cachedDataRejected` value will be set to either `true` or `false` depending on acceptance of the data by V8.",
@@ -59605,10 +65534,10 @@
                       "desc": "When `true` and no `cachedData` is present, V8 will attempt to produce code cache data for `code`. Upon success, a `Buffer` with V8's code cache data will be produced and stored in the `cachedData` property of the returned `vm.Script` instance. The `cachedDataProduced` value will be set to either `true` or `false` depending on whether code cache data is produced successfully. This option is **deprecated** in favor of `script.createCachedData()`."
                     },
                     {
-                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "name": "importModuleDynamically",
                       "type": "Function",
-                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "options": [
                         {
                           "textRaw": "`specifier` {string} specifier passed to `import()`",
@@ -59617,9 +65546,9 @@
                           "desc": "specifier passed to `import()`"
                         },
                         {
-                          "textRaw": "`module` {vm.Module}",
-                          "name": "module",
-                          "type": "vm.Module"
+                          "textRaw": "`script` {vm.Script}",
+                          "name": "script",
+                          "type": "vm.Script"
                         },
                         {
                           "textRaw": "Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports.",
@@ -59646,15 +65575,16 @@
           "displayName": "What does it mean to \"contextify\" an object?"
         },
         {
-          "textRaw": "Timeout limitations when using `process.nextTick()`, promises, and `queueMicrotask()`",
-          "name": "timeout_limitations_when_using_`process.nexttick()`,_promises,_and_`queuemicrotask()`",
-          "desc": "<p>Because of the internal mechanics of how the <code>process.nextTick()</code> queue and\nthe microtask queue that underlies Promises are implemented within V8 and\nNode.js, it is possible for code running within a context to \"escape\" the\n<code>timeout</code> set using <code>vm.runInContext()</code>, <code>vm.runInNewContext()</code>, and\n<code>vm.runInThisContext()</code>.</p>\n<p>For example, the following code executed by <code>vm.runInNewContext()</code> with a\ntimeout of 5 milliseconds schedules an infinite loop to run after a promise\nresolves. The scheduled loop is never interrupted by the timeout:</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nfunction loop() {\n  while (1) console.log(Date.now());\n}\n\nvm.runInNewContext(\n  'Promise.resolve().then(loop);',\n  { loop, console },\n  { timeout: 5 }\n);\n</code></pre>\n<p>This issue also occurs when the <code>loop()</code> call is scheduled using\nthe <code>process.nextTick()</code> and <code>queueMicrotask()</code> functions.</p>\n<p>This issue occurs because all contexts share the same microtask and nextTick\nqueues.</p>",
+          "textRaw": "Timeout interactions with asynchronous tasks and Promises",
+          "name": "timeout_interactions_with_asynchronous_tasks_and_promises",
+          "desc": "<p><code>Promise</code>s and <code>async function</code>s can schedule tasks run by the JavaScript\nengine asynchronously. By default, these tasks are run after all JavaScript\nfunctions on the current stack are done executing.\nThis allows escaping the functionality of the <code>timeout</code> and\n<code>breakOnSigint</code> options.</p>\n<p>For example, the following code executed by <code>vm.runInNewContext()</code> with a\ntimeout of 5 milliseconds schedules an infinite loop to run after a promise\nresolves. The scheduled loop is never interrupted by the timeout:</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nfunction loop() {\n  console.log('entering loop');\n  while (1) console.log(Date.now());\n}\n\nvm.runInNewContext(\n  'Promise.resolve().then(() => loop());',\n  { loop, console },\n  { timeout: 5 }\n);\n// This is printed *before* 'entering loop' (!)\nconsole.log('done executing');\n</code></pre>\n<p>This can be addressed by passing <code>microtaskMode: 'afterEvaluate'</code> to the code\nthat creates the <code>Context</code>:</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nfunction loop() {\n  while (1) console.log(Date.now());\n}\n\nvm.runInNewContext(\n  'Promise.resolve().then(() => loop());',\n  { loop, console },\n  { timeout: 5, microtaskMode: 'afterEvaluate' }\n);\n</code></pre>\n<p>In this case, the microtask scheduled through <code>promise.then()</code> will be run\nbefore returning from <code>vm.runInNewContext()</code>, and will be interrupted\nby the <code>timeout</code> functionality. This applies only to code running in a\n<code>vm.Context</code>, so e.g. <a href=\"vm.html#vm_vm_runinthiscontext_code_options\"><code>vm.runInThisContext()</code></a> does not take this option.</p>\n<p>Promise callbacks are entered into the microtask queue of the context in which\nthey were created. For example, if <code>() => loop()</code> is replaced with just <code>loop</code>\nin the above example, then <code>loop</code> will be pushed into the global microtask\nqueue, because it is a function from the outer (main) context, and thus will\nalso be able to escape the timeout.</p>\n<p>If asynchronous scheduling functions such as <code>process.nextTick()</code>,\n<code>queueMicrotask()</code>, <code>setTimeout()</code>, <code>setImmediate()</code>, etc. are made available\ninside a <code>vm.Context</code>, functions passed to them will be added to global queues,\nwhich are shared by all contexts. Therefore, callbacks passed to those functions\nare not controllable through the timeout either.</p>",
           "type": "module",
-          "displayName": "Timeout limitations when using `process.nextTick()`, promises, and `queueMicrotask()`"
+          "displayName": "Timeout interactions with asynchronous tasks and Promises"
         }
       ],
       "type": "module",
-      "displayName": "vm"
+      "displayName": "vm",
+      "source": "doc/api/vm.md"
     },
     {
       "textRaw": "WebAssembly System Interface (WASI)",
@@ -59662,7 +65592,7 @@
       "introduced_in": "v12.16.0",
       "stability": 1,
       "stabilityText": "Experimental",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/wasi.js\">lib/wasi.js</a></p>\n<p>The WASI API provides an implementation of the <a href=\"https://wasi.dev/\">WebAssembly System Interface</a>\nspecification. WASI gives sandboxed WebAssembly applications access to the\nunderlying operating system via a collection of POSIX-like functions.</p>\n<pre><code class=\"language-js\">'use strict';\nconst fs = require('fs');\nconst { WASI } = require('wasi');\nconst wasi = new WASI({\n  args: process.argv,\n  env: process.env,\n  preopens: {\n    '/sandbox': '/some/real/path/that/wasm/can/access'\n  }\n});\nconst importObject = { wasi_snapshot_preview1: wasi.wasiImport };\n\n(async () => {\n  const wasm = await WebAssembly.compile(fs.readFileSync('./demo.wasm'));\n  const instance = await WebAssembly.instantiate(wasm, importObject);\n\n  wasi.start(instance);\n})();\n</code></pre>\n<p>To run the above example, create a new WebAssembly text format file named\n<code>demo.wat</code>:</p>\n<pre><code class=\"language-text\">(module\n    ;; Import the required fd_write WASI function which will write the given io vectors to stdout\n    ;; The function signature for fd_write is:\n    ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written\n    (import \"wasi_snapshot_preview1\" \"fd_write\" (func $fd_write (param i32 i32 i32 i32) (result i32)))\n\n    (memory 1)\n    (export \"memory\" (memory 0))\n\n    ;; Write 'hello world\\n' to memory at an offset of 8 bytes\n    ;; Note the trailing newline which is required for the text to appear\n    (data (i32.const 8) \"hello world\\n\")\n\n    (func $main (export \"_start\")\n        ;; Creating a new io vector within linear memory\n        (i32.store (i32.const 0) (i32.const 8))  ;; iov.iov_base - This is a pointer to the start of the 'hello world\\n' string\n        (i32.store (i32.const 4) (i32.const 12))  ;; iov.iov_len - The length of the 'hello world\\n' string\n\n        (call $fd_write\n            (i32.const 1) ;; file_descriptor - 1 for stdout\n            (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0\n            (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.\n            (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written\n        )\n        drop ;; Discard the number of bytes written from the top of the stack\n    )\n)\n</code></pre>\n<p>Use <a href=\"https://github.com/WebAssembly/wabt\">wabt</a> to compile <code>.wat</code> to <code>.wasm</code></p>\n<pre><code class=\"language-console\">$ wat2wasm demo.wat\n</code></pre>\n<p>The <code>--experimental-wasi-unstable-preview1</code> and <code>--experimental-wasm-bigint</code>\nCLI arguments are needed for this example to run.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/wasi.js\">lib/wasi.js</a></p>\n<p>The WASI API provides an implementation of the <a href=\"https://wasi.dev/\">WebAssembly System Interface</a>\nspecification. WASI gives sandboxed WebAssembly applications access to the\nunderlying operating system via a collection of POSIX-like functions.</p>\n<pre><code class=\"language-mjs\">import fs from 'fs';\nimport { WASI } from 'wasi';\n\nconst wasi = new WASI({\n  args: process.argv,\n  env: process.env,\n  preopens: {\n    '/sandbox': '/some/real/path/that/wasm/can/access'\n  }\n});\nconst importObject = { wasi_snapshot_preview1: wasi.wasiImport };\n\nconst wasm = await WebAssembly.compile(fs.readFileSync('./demo.wasm'));\nconst instance = await WebAssembly.instantiate(wasm, importObject);\n\nwasi.start(instance);\n</code></pre>\n<pre><code class=\"language-cjs\">'use strict';\nconst fs = require('fs');\nconst { WASI } = require('wasi');\nconst wasi = new WASI({\n  args: process.argv,\n  env: process.env,\n  preopens: {\n    '/sandbox': '/some/real/path/that/wasm/can/access'\n  }\n});\nconst importObject = { wasi_snapshot_preview1: wasi.wasiImport };\n\n(async () => {\n  const wasm = await WebAssembly.compile(fs.readFileSync('./demo.wasm'));\n  const instance = await WebAssembly.instantiate(wasm, importObject);\n\n  wasi.start(instance);\n})();\n</code></pre>\n<p>To run the above example, create a new WebAssembly text format file named\n<code>demo.wat</code>:</p>\n<pre><code class=\"language-text\">(module\n    ;; Import the required fd_write WASI function which will write the given io vectors to stdout\n    ;; The function signature for fd_write is:\n    ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written\n    (import \"wasi_snapshot_preview1\" \"fd_write\" (func $fd_write (param i32 i32 i32 i32) (result i32)))\n\n    (memory 1)\n    (export \"memory\" (memory 0))\n\n    ;; Write 'hello world\\n' to memory at an offset of 8 bytes\n    ;; Note the trailing newline which is required for the text to appear\n    (data (i32.const 8) \"hello world\\n\")\n\n    (func $main (export \"_start\")\n        ;; Creating a new io vector within linear memory\n        (i32.store (i32.const 0) (i32.const 8))  ;; iov.iov_base - This is a pointer to the start of the 'hello world\\n' string\n        (i32.store (i32.const 4) (i32.const 12))  ;; iov.iov_len - The length of the 'hello world\\n' string\n\n        (call $fd_write\n            (i32.const 1) ;; file_descriptor - 1 for stdout\n            (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0\n            (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.\n            (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written\n        )\n        drop ;; Discard the number of bytes written from the top of the stack\n    )\n)\n</code></pre>\n<p>Use <a href=\"https://github.com/WebAssembly/wabt\">wabt</a> to compile <code>.wat</code> to <code>.wasm</code></p>\n<pre><code class=\"language-console\">$ wat2wasm demo.wat\n</code></pre>\n<p>The <code>--experimental-wasi-unstable-preview1</code> and <code>--experimental-wasm-bigint</code>\nCLI arguments are needed for this example to run.</p>",
       "classes": [
         {
           "textRaw": "Class: `WASI`",
@@ -59670,11 +65600,12 @@
           "name": "WASI",
           "meta": {
             "added": [
+              "v13.3.0",
               "v12.16.0"
             ],
             "changes": []
           },
-          "desc": "<p>The <code>WASI</code> class provides the WASI system call API and additional convenience\nmethods for working with WASI-based applications. Each <code>WASI</code> instance\nrepresents a distinct sandbox environment. For security purposes, each <code>WASI</code>\ninstance must have its command line arguments, environment variables, and\nsandbox directory structure configured explicitly.</p>",
+          "desc": "<p>The <code>WASI</code> class provides the WASI system call API and additional convenience\nmethods for working with WASI-based applications. Each <code>WASI</code> instance\nrepresents a distinct sandbox environment. For security purposes, each <code>WASI</code>\ninstance must have its command-line arguments, environment variables, and\nsandbox directory structure configured explicitly.</p>",
           "methods": [
             {
               "textRaw": "`wasi.start(instance)`",
@@ -59682,6 +65613,7 @@
               "name": "start",
               "meta": {
                 "added": [
+                  "v13.3.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -59705,7 +65637,7 @@
               "name": "initialize",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.6.0"
                 ],
                 "changes": []
               },
@@ -59730,6 +65662,7 @@
               "name": "wasiImport",
               "meta": {
                 "added": [
+                  "v13.3.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -59746,11 +65679,11 @@
                   "type": "Object",
                   "options": [
                     {
-                      "textRaw": "`args` {Array} An array of strings that the WebAssembly application will see as command line arguments. The first argument is the virtual path to the WASI command itself. **Default:** `[]`.",
+                      "textRaw": "`args` {Array} An array of strings that the WebAssembly application will see as command-line arguments. The first argument is the virtual path to the WASI command itself. **Default:** `[]`.",
                       "name": "args",
                       "type": "Array",
                       "default": "`[]`",
-                      "desc": "An array of strings that the WebAssembly application will see as command line arguments. The first argument is the virtual path to the WASI command itself."
+                      "desc": "An array of strings that the WebAssembly application will see as command-line arguments. The first argument is the virtual path to the WASI command itself."
                     },
                     {
                       "textRaw": "`env` {Object} An object similar to `process.env` that the WebAssembly application will see as its environment. **Default:** `{}`.",
@@ -59801,7 +65734,8 @@
         }
       ],
       "type": "module",
-      "displayName": "WebAssembly System Interface (WASI)"
+      "displayName": "WebAssembly System Interface (WASI)",
+      "source": "doc/api/wasi.md"
     },
     {
       "textRaw": "Worker threads",
@@ -59809,7 +65743,152 @@
       "introduced_in": "v10.5.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/worker_threads.js\">lib/worker_threads.js</a></p>\n<p>The <code>worker_threads</code> module enables the use of threads that execute JavaScript\nin parallel. To access it:</p>\n<pre><code class=\"language-js\">const worker = require('worker_threads');\n</code></pre>\n<p>Workers (threads) are useful for performing CPU-intensive JavaScript operations.\nThey will not help much with I/O-intensive work. Node.js’s built-in asynchronous\nI/O operations are more efficient than Workers can be.</p>\n<p>Unlike <code>child_process</code> or <code>cluster</code>, <code>worker_threads</code> can share memory. They do\nso by transferring <code>ArrayBuffer</code> instances or sharing <code>SharedArrayBuffer</code>\ninstances.</p>\n<pre><code class=\"language-js\">const {\n  Worker, isMainThread, parentPort, workerData\n} = require('worker_threads');\n\nif (isMainThread) {\n  module.exports = function parseJSAsync(script) {\n    return new Promise((resolve, reject) => {\n      const worker = new Worker(__filename, {\n        workerData: script\n      });\n      worker.on('message', resolve);\n      worker.on('error', reject);\n      worker.on('exit', (code) => {\n        if (code !== 0)\n          reject(new Error(`Worker stopped with exit code ${code}`));\n      });\n    });\n  };\n} else {\n  const { parse } = require('some-js-parsing-library');\n  const script = workerData;\n  parentPort.postMessage(parse(script));\n}\n</code></pre>\n<p>The above example spawns a Worker thread for each <code>parse()</code> call. In actual\npractice, use a pool of Workers instead for these kinds of tasks. Otherwise, the\noverhead of creating Workers would likely exceed their benefit.</p>\n<p>When implementing a worker pool, use the <a href=\"async_hooks.html#async_hooks_class_asyncresource\"><code>AsyncResource</code></a> API to inform\ndiagnostic tools (e.g. in order to provide asynchronous stack traces) about the\ncorrelation between tasks and their outcomes. See\n<a href=\"async_hooks.html#async-resource-worker-pool\">\"Using <code>AsyncResource</code> for a <code>Worker</code> thread pool\"</a>\nin the <code>async_hooks</code> documentation for an example implementation.</p>\n<p>Worker threads inherit non-process-specific options by default. Refer to\n<a href=\"worker_threads.html#worker_threads_new_worker_filename_options\"><code>Worker constructor options</code></a> to know how to customize worker thread options,\nspecifically <code>argv</code> and <code>execArgv</code> options.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/worker_threads.js\">lib/worker_threads.js</a></p>\n<p>The <code>worker_threads</code> module enables the use of threads that execute JavaScript\nin parallel. To access it:</p>\n<pre><code class=\"language-js\">const worker = require('worker_threads');\n</code></pre>\n<p>Workers (threads) are useful for performing CPU-intensive JavaScript operations.\nThey will not help much with I/O-intensive work. Node.js’s built-in asynchronous\nI/O operations are more efficient than Workers can be.</p>\n<p>Unlike <code>child_process</code> or <code>cluster</code>, <code>worker_threads</code> can share memory. They do\nso by transferring <code>ArrayBuffer</code> instances or sharing <code>SharedArrayBuffer</code>\ninstances.</p>\n<pre><code class=\"language-js\">const {\n  Worker, isMainThread, parentPort, workerData\n} = require('worker_threads');\n\nif (isMainThread) {\n  module.exports = function parseJSAsync(script) {\n    return new Promise((resolve, reject) => {\n      const worker = new Worker(__filename, {\n        workerData: script\n      });\n      worker.on('message', resolve);\n      worker.on('error', reject);\n      worker.on('exit', (code) => {\n        if (code !== 0)\n          reject(new Error(`Worker stopped with exit code ${code}`));\n      });\n    });\n  };\n} else {\n  const { parse } = require('some-js-parsing-library');\n  const script = workerData;\n  parentPort.postMessage(parse(script));\n}\n</code></pre>\n<p>The above example spawns a Worker thread for each <code>parse()</code> call. In actual\npractice, use a pool of Workers instead for these kinds of tasks. Otherwise, the\noverhead of creating Workers would likely exceed their benefit.</p>\n<p>When implementing a worker pool, use the <a href=\"async_hooks.html#async_hooks_class_asyncresource\"><code>AsyncResource</code></a> API to inform\ndiagnostic tools (e.g. in order to provide asynchronous stack traces) about the\ncorrelation between tasks and their outcomes. See\n<a href=\"async_hooks.html#async-resource-worker-pool\">\"Using <code>AsyncResource</code> for a <code>Worker</code> thread pool\"</a>\nin the <code>async_hooks</code> documentation for an example implementation.</p>\n<p>Worker threads inherit non-process-specific options by default. Refer to\n<a href=\"worker_threads.html#worker_threads_new_worker_filename_options\"><code>Worker constructor options</code></a> to know how to customize worker thread options,\nspecifically <code>argv</code> and <code>execArgv</code> options.</p>",
+      "methods": [
+        {
+          "textRaw": "`worker.getEnvironmentData(key)`",
+          "type": "method",
+          "name": "getEnvironmentData",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {any}",
+                "name": "return",
+                "type": "any"
+              },
+              "params": [
+                {
+                  "textRaw": "`key` {any} Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.",
+                  "name": "key",
+                  "type": "any",
+                  "desc": "Any arbitrary, cloneable JavaScript value that can be used as a {Map} key."
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Within a worker thread, <code>worker.getEnvironmentData()</code> returns a clone\nof data passed to the spawning thread's <code>worker.setEnvironmentData()</code>.\nEvery new <code>Worker</code> receives its own copy of the environment data\nautomatically.</p>\n<pre><code class=\"language-js\">const {\n  Worker,\n  isMainThread,\n  setEnvironmentData,\n  getEnvironmentData,\n} = require('worker_threads');\n\nif (isMainThread) {\n  setEnvironmentData('Hello', 'World!');\n  const worker = new Worker(__filename);\n} else {\n  console.log(getEnvironmentData('Hello'));  // Prints 'World!'.\n}\n</code></pre>"
+        },
+        {
+          "textRaw": "`worker.markAsUntransferable(object)`",
+          "type": "method",
+          "name": "markAsUntransferable",
+          "meta": {
+            "added": [
+              "v14.5.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<p>Mark an object as not transferable. If <code>object</code> occurs in the transfer list of\na <a href=\"worker_threads.html#worker_threads_port_postmessage_value_transferlist\"><code>port.postMessage()</code></a> call, it will be ignored.</p>\n<p>In particular, this makes sense for objects that can be cloned, rather than\ntransferred, and which are used by other objects on the sending side.\nFor example, Node.js marks the <code>ArrayBuffer</code>s it uses for its\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer</code> pool</a> with this.</p>\n<p>This operation cannot be undone.</p>\n<pre><code class=\"language-js\">const { MessageChannel, markAsUntransferable } = require('worker_threads');\n\nconst pooledBuffer = new ArrayBuffer(8);\nconst typedArray1 = new Uint8Array(pooledBuffer);\nconst typedArray2 = new Float64Array(pooledBuffer);\n\nmarkAsUntransferable(pooledBuffer);\n\nconst { port1 } = new MessageChannel();\nport1.postMessage(typedArray1, [ typedArray1.buffer ]);\n\n// The following line prints the contents of typedArray1 -- it still owns\n// its memory and has been cloned, not transferred. Without\n// `markAsUntransferable()`, this would print an empty Uint8Array.\n// typedArray2 is intact as well.\nconsole.log(typedArray1);\nconsole.log(typedArray2);\n</code></pre>\n<p>There is no equivalent to this API in browsers.</p>"
+        },
+        {
+          "textRaw": "`worker.moveMessagePortToContext(port, contextifiedSandbox)`",
+          "type": "method",
+          "name": "moveMessagePortToContext",
+          "meta": {
+            "added": [
+              "v11.13.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {MessagePort}",
+                "name": "return",
+                "type": "MessagePort"
+              },
+              "params": [
+                {
+                  "textRaw": "`port` {MessagePort} The message port which will be transferred.",
+                  "name": "port",
+                  "type": "MessagePort",
+                  "desc": "The message port which will be transferred."
+                },
+                {
+                  "textRaw": "`contextifiedSandbox` {Object} A [contextified][] object as returned by the `vm.createContext()` method.",
+                  "name": "contextifiedSandbox",
+                  "type": "Object",
+                  "desc": "A [contextified][] object as returned by the `vm.createContext()` method."
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Transfer a <code>MessagePort</code> to a different <a href=\"vm.html\"><code>vm</code></a> Context. The original <code>port</code>\nobject will be rendered unusable, and the returned <code>MessagePort</code> instance will\ntake its place.</p>\n<p>The returned <code>MessagePort</code> will be an object in the target context, and will\ninherit from its global <code>Object</code> class. Objects passed to the\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage\"><code>port.onmessage()</code></a> listener will also be created in the target context\nand inherit from its global <code>Object</code> class.</p>\n<p>However, the created <code>MessagePort</code> will no longer inherit from\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/API/EventTarget\"><code>EventTarget</code></a>, and only <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage\"><code>port.onmessage()</code></a> can be used to receive\nevents using it.</p>"
+        },
+        {
+          "textRaw": "`worker.receiveMessageOnPort(port)`",
+          "type": "method",
+          "name": "receiveMessageOnPort",
+          "meta": {
+            "added": [
+              "v12.3.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {Object|undefined}",
+                "name": "return",
+                "type": "Object|undefined"
+              },
+              "params": [
+                {
+                  "textRaw": "`port` {MessagePort}",
+                  "name": "port",
+                  "type": "MessagePort"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Receive a single message from a given <code>MessagePort</code>. If no message is available,\n<code>undefined</code> is returned, otherwise an object with a single <code>message</code> property\nthat contains the message payload, corresponding to the oldest message in the\n<code>MessagePort</code>’s queue.</p>\n<pre><code class=\"language-js\">const { MessageChannel, receiveMessageOnPort } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\nport1.postMessage({ hello: 'world' });\n\nconsole.log(receiveMessageOnPort(port2));\n// Prints: { message: { hello: 'world' } }\nconsole.log(receiveMessageOnPort(port2));\n// Prints: undefined\n</code></pre>\n<p>When this function is used, no <code>'message'</code> event will be emitted and the\n<code>onmessage</code> listener will not be invoked.</p>"
+        },
+        {
+          "textRaw": "`worker.setEnvironmentData(key[, value])`",
+          "type": "method",
+          "name": "setEnvironmentData",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`key` {any} Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.",
+                  "name": "key",
+                  "type": "any",
+                  "desc": "Any arbitrary, cloneable JavaScript value that can be used as a {Map} key."
+                },
+                {
+                  "textRaw": "`value` {any} Any arbitrary, cloneable JavaScript value that will be cloned and passed automatically to all new `Worker` instances. If `value` is passed as `undefined`, any previously set value for the `key` will be deleted.",
+                  "name": "value",
+                  "type": "any",
+                  "desc": "Any arbitrary, cloneable JavaScript value that will be cloned and passed automatically to all new `Worker` instances. If `value` is passed as `undefined`, any previously set value for the `key` will be deleted."
+                }
+              ]
+            }
+          ],
+          "desc": "<p>The <code>worker.setEnvironmentData()</code> API sets the content of\n<code>worker.getEnvironmentData()</code> in the current thread and all new <code>Worker</code>\ninstances spawned from the current context.</p>"
+        }
+      ],
       "properties": [
         {
           "textRaw": "`isMainThread` {boolean}",
@@ -59841,6 +65920,7 @@
           "name": "resourceLimits",
           "meta": {
             "added": [
+              "v13.2.0",
               "v12.16.0"
             ],
             "changes": []
@@ -59905,88 +65985,6 @@
           "desc": "<p>An arbitrary JavaScript value that contains a clone of the data passed\nto this thread’s <code>Worker</code> constructor.</p>\n<p>The data is cloned as if using <a href=\"worker_threads.html#worker_threads_port_postmessage_value_transferlist\"><code>postMessage()</code></a>,\naccording to the <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\">HTML structured clone algorithm</a>.</p>\n<pre><code class=\"language-js\">const { Worker, isMainThread, workerData } = require('worker_threads');\n\nif (isMainThread) {\n  const worker = new Worker(__filename, { workerData: 'Hello, world!' });\n} else {\n  console.log(workerData);  // Prints 'Hello, world!'.\n}\n</code></pre>"
         }
       ],
-      "methods": [
-        {
-          "textRaw": "`worker.markAsUntransferable(object)`",
-          "type": "method",
-          "name": "markAsUntransferable",
-          "meta": {
-            "added": [
-              "v12.19.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "params": []
-            }
-          ],
-          "desc": "<p>Mark an object as not transferable. If <code>object</code> occurs in the transfer list of\na <a href=\"worker_threads.html#worker_threads_port_postmessage_value_transferlist\"><code>port.postMessage()</code></a> call, it will be ignored.</p>\n<p>In particular, this makes sense for objects that can be cloned, rather than\ntransferred, and which are used by other objects on the sending side.\nFor example, Node.js marks the <code>ArrayBuffer</code>s it uses for its\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer</code> pool</a> with this.</p>\n<p>This operation cannot be undone.</p>\n<pre><code class=\"language-js\">const { MessageChannel, markAsUntransferable } = require('worker_threads');\n\nconst pooledBuffer = new ArrayBuffer(8);\nconst typedArray1 = new Uint8Array(pooledBuffer);\nconst typedArray2 = new Float64Array(pooledBuffer);\n\nmarkAsUntransferable(pooledBuffer);\n\nconst { port1 } = new MessageChannel();\nport1.postMessage(typedArray1, [ typedArray1.buffer ]);\n\n// The following line prints the contents of typedArray1 -- it still owns\n// its memory and has been cloned, not transferred. Without\n// `markAsUntransferable()`, this would print an empty Uint8Array.\n// typedArray2 is intact as well.\nconsole.log(typedArray1);\nconsole.log(typedArray2);\n</code></pre>\n<p>There is no equivalent to this API in browsers.</p>"
-        },
-        {
-          "textRaw": "`worker.moveMessagePortToContext(port, contextifiedSandbox)`",
-          "type": "method",
-          "name": "moveMessagePortToContext",
-          "meta": {
-            "added": [
-              "v11.13.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {MessagePort}",
-                "name": "return",
-                "type": "MessagePort"
-              },
-              "params": [
-                {
-                  "textRaw": "`port` {MessagePort} The message port which will be transferred.",
-                  "name": "port",
-                  "type": "MessagePort",
-                  "desc": "The message port which will be transferred."
-                },
-                {
-                  "textRaw": "`contextifiedSandbox` {Object} A [contextified][] object as returned by the `vm.createContext()` method.",
-                  "name": "contextifiedSandbox",
-                  "type": "Object",
-                  "desc": "A [contextified][] object as returned by the `vm.createContext()` method."
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Transfer a <code>MessagePort</code> to a different <a href=\"vm.html\"><code>vm</code></a> Context. The original <code>port</code>\nobject will be rendered unusable, and the returned <code>MessagePort</code> instance will\ntake its place.</p>\n<p>The returned <code>MessagePort</code> will be an object in the target context, and will\ninherit from its global <code>Object</code> class. Objects passed to the\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage\"><code>port.onmessage()</code></a> listener will also be created in the target context\nand inherit from its global <code>Object</code> class.</p>\n<p>However, the created <code>MessagePort</code> will no longer inherit from\n<a href=\"events.html\"><code>EventEmitter</code></a>, and only <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage\"><code>port.onmessage()</code></a> can be used to receive\nevents using it.</p>"
-        },
-        {
-          "textRaw": "`worker.receiveMessageOnPort(port)`",
-          "type": "method",
-          "name": "receiveMessageOnPort",
-          "meta": {
-            "added": [
-              "v12.3.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {Object|undefined}",
-                "name": "return",
-                "type": "Object|undefined"
-              },
-              "params": [
-                {
-                  "textRaw": "`port` {MessagePort}",
-                  "name": "port",
-                  "type": "MessagePort"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Receive a single message from a given <code>MessagePort</code>. If no message is available,\n<code>undefined</code> is returned, otherwise an object with a single <code>message</code> property\nthat contains the message payload, corresponding to the oldest message in the\n<code>MessagePort</code>’s queue.</p>\n<pre><code class=\"language-js\">const { MessageChannel, receiveMessageOnPort } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\nport1.postMessage({ hello: 'world' });\n\nconsole.log(receiveMessageOnPort(port2));\n// Prints: { message: { hello: 'world' } }\nconsole.log(receiveMessageOnPort(port2));\n// Prints: undefined\n</code></pre>\n<p>When this function is used, no <code>'message'</code> event will be emitted and the\n<code>onmessage</code> listener will not be invoked.</p>"
-        }
-      ],
       "classes": [
         {
           "textRaw": "Class: `MessageChannel`",
@@ -60008,9 +66006,17 @@
             "added": [
               "v10.5.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": [
+                  "v14.7.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/34057",
+                "description": "This class now inherits from `EventTarget` rather than from `EventEmitter`."
+              }
+            ]
           },
-          "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>Instances of the <code>worker.MessagePort</code> class represent one end of an\nasynchronous, two-way communications channel. It can be used to transfer\nstructured data, memory regions and other <code>MessagePort</code>s between different\n<a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a>s.</p>\n<p>With the exception of <code>MessagePort</code>s being <a href=\"events.html\"><code>EventEmitter</code></a>s rather\nthan <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/EventTarget\"><code>EventTarget</code></a>s, this implementation matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort\">browser <code>MessagePort</code></a>s.</p>",
+          "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventtarget\" class=\"type\">&lt;EventTarget&gt;</a></li>\n</ul>\n<p>Instances of the <code>worker.MessagePort</code> class represent one end of an\nasynchronous, two-way communications channel. It can be used to transfer\nstructured data, memory regions and other <code>MessagePort</code>s between different\n<a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a>s.</p>\n<p>This implementation matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort\">browser <code>MessagePort</code></a>s.</p>",
           "events": [
             {
               "textRaw": "Event: `'close'`",
@@ -60051,7 +66057,7 @@
               "name": "messageerror",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -60063,7 +66069,7 @@
                   "desc": "An Error object"
                 }
               ],
-              "desc": "<p>The <code>'messageerror'</code> event is emitted when deserializing a message failed.</p>"
+              "desc": "<p>The <code>'messageerror'</code> event is emitted when deserializing a message failed.</p>\n<p>Currently, this event is emitted when there is an error occurring while\ninstantiating the posted JS object on the receiving end. Such situations\nare rare, but can happen, for instance, when certain Node.js API objects\nare received in a <code>vm.Context</code> (where Node.js APIs are currently\nunavailable).</p>"
             }
           ],
           "methods": [
@@ -60094,12 +66100,22 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37917",
+                    "description": "Add 'BlockList' to the list of cloneable types."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37155",
+                    "description": "Add 'Histogram' types to the list of cloneable types."
+                  },
+                  {
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/33360",
                     "description": "Added `KeyObject` to the list of cloneable types."
                   },
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/33772",
                     "description": "Added `FileHandle` to the list of transferable types."
                   }
@@ -60121,7 +66137,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Sends a JavaScript value to the receiving side of this channel.\n<code>value</code> will be transferred in a way which is compatible with\nthe <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\">HTML structured clone algorithm</a>.</p>\n<p>In particular, the significant differences to <code>JSON</code> are:</p>\n<ul>\n<li><code>value</code> may contain circular references.</li>\n<li><code>value</code> may contain instances of builtin JS types such as <code>RegExp</code>s,\n<code>BigInt</code>s, <code>Map</code>s, <code>Set</code>s, etc.</li>\n<li><code>value</code> may contain typed arrays, both using <code>ArrayBuffer</code>s\nand <code>SharedArrayBuffer</code>s.</li>\n<li><code>value</code> may contain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module\"><code>WebAssembly.Module</code></a> instances.</li>\n<li><code>value</code> may not contain native (C++-backed) objects other than <code>MessagePort</code>s,\n<a href=\"fs.html#fs_class_filehandle\"><code>FileHandle</code></a>s, and <a href=\"crypto.html#crypto_class_keyobject\"><code>KeyObject</code></a>s.</li>\n</ul>\n<pre><code class=\"language-js\">const { MessageChannel } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (message) => console.log(message));\n\nconst circularData = {};\ncircularData.foo = circularData;\n// Prints: { foo: [Circular] }\nport2.postMessage(circularData);\n</code></pre>\n<p><code>transferList</code> may be a list of <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"worker_threads.html#worker_threads_class_messageport\"><code>MessagePort</code></a> and\n<a href=\"fs.html#fs_class_filehandle\"><code>FileHandle</code></a> objects.\nAfter transferring, they will not be usable on the sending side of the channel\nanymore (even if they are not contained in <code>value</code>). Unlike with\n<a href=\"child_process.html\">child processes</a>, transferring handles such as network sockets is currently\nnot supported.</p>\n<p>If <code>value</code> contains <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> instances, those will be accessible\nfrom either thread. They cannot be listed in <code>transferList</code>.</p>\n<p><code>value</code> may still contain <code>ArrayBuffer</code> instances that are not in\n<code>transferList</code>; in that case, the underlying memory is copied rather than moved.</p>\n<pre><code class=\"language-js\">const { MessageChannel } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (message) => console.log(message));\n\nconst uint8Array = new Uint8Array([ 1, 2, 3, 4 ]);\n// This posts a copy of `uint8Array`:\nport2.postMessage(uint8Array);\n// This does not copy data, but renders `uint8Array` unusable:\nport2.postMessage(uint8Array, [ uint8Array.buffer ]);\n\n// The memory for the `sharedUint8Array` will be accessible from both the\n// original and the copy received by `.on('message')`:\nconst sharedUint8Array = new Uint8Array(new SharedArrayBuffer(4));\nport2.postMessage(sharedUint8Array);\n\n// This transfers a freshly created message port to the receiver.\n// This can be used, for example, to create communication channels between\n// multiple `Worker` threads that are children of the same parent thread.\nconst otherChannel = new MessageChannel();\nport2.postMessage({ port: otherChannel.port1 }, [ otherChannel.port1 ]);\n</code></pre>\n<p>Because the object cloning uses the structured clone algorithm,\nnon-enumerable properties, property accessors, and object prototypes are\nnot preserved. In particular, <a href=\"buffer.html\"><code>Buffer</code></a> objects will be read as\nplain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>s on the receiving side.</p>\n<p>The message object will be cloned immediately, and can be modified after\nposting without having side effects.</p>\n<p>For more information on the serialization and deserialization mechanisms\nbehind this API, see the <a href=\"v8.html#v8_serialization_api\">serialization API of the <code>v8</code> module</a>.</p>",
+              "desc": "<p>Sends a JavaScript value to the receiving side of this channel.\n<code>value</code> will be transferred in a way which is compatible with\nthe <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\">HTML structured clone algorithm</a>.</p>\n<p>In particular, the significant differences to <code>JSON</code> are:</p>\n<ul>\n<li><code>value</code> may contain circular references.</li>\n<li><code>value</code> may contain instances of builtin JS types such as <code>RegExp</code>s,\n<code>BigInt</code>s, <code>Map</code>s, <code>Set</code>s, etc.</li>\n<li><code>value</code> may contain typed arrays, both using <code>ArrayBuffer</code>s\nand <code>SharedArrayBuffer</code>s.</li>\n<li><code>value</code> may contain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module\"><code>WebAssembly.Module</code></a> instances.</li>\n<li><code>value</code> may not contain native (C++-backed) objects other than:\n<ul>\n<li><a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a>s,</li>\n<li><a href=\"perf_hooks.html#perf_hooks_class_histogram\" class=\"type\">&lt;Histogram&gt;</a>s,</li>\n<li><a href=\"crypto.html#crypto_class_keyobject\" class=\"type\">&lt;KeyObject&gt;</a>s,</li>\n<li><a href=\"worker_threads.html#worker_threads_class_messageport\" class=\"type\">&lt;MessagePort&gt;</a>s,</li>\n<li><a href=\"net.html#net_class_net_blocklist\" class=\"type\">&lt;net.BlockList&gt;</a>s,</li>\n<li><a href=\"net.html#net_class_net_socketaddress\" class=\"type\">&lt;net.SocketAddress&gt;</a>es,</li>\n</ul>\n</li>\n</ul>\n<pre><code class=\"language-js\">const { MessageChannel } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (message) => console.log(message));\n\nconst circularData = {};\ncircularData.foo = circularData;\n// Prints: { foo: [Circular] }\nport2.postMessage(circularData);\n</code></pre>\n<p><code>transferList</code> may be a list of <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"worker_threads.html#worker_threads_class_messageport\"><code>MessagePort</code></a> and\n<a href=\"fs.html#fs_class_filehandle\"><code>FileHandle</code></a> objects.\nAfter transferring, they will not be usable on the sending side of the channel\nanymore (even if they are not contained in <code>value</code>). Unlike with\n<a href=\"child_process.html\">child processes</a>, transferring handles such as network sockets is currently\nnot supported.</p>\n<p>If <code>value</code> contains <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> instances, those will be accessible\nfrom either thread. They cannot be listed in <code>transferList</code>.</p>\n<p><code>value</code> may still contain <code>ArrayBuffer</code> instances that are not in\n<code>transferList</code>; in that case, the underlying memory is copied rather than moved.</p>\n<pre><code class=\"language-js\">const { MessageChannel } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (message) => console.log(message));\n\nconst uint8Array = new Uint8Array([ 1, 2, 3, 4 ]);\n// This posts a copy of `uint8Array`:\nport2.postMessage(uint8Array);\n// This does not copy data, but renders `uint8Array` unusable:\nport2.postMessage(uint8Array, [ uint8Array.buffer ]);\n\n// The memory for the `sharedUint8Array` will be accessible from both the\n// original and the copy received by `.on('message')`:\nconst sharedUint8Array = new Uint8Array(new SharedArrayBuffer(4));\nport2.postMessage(sharedUint8Array);\n\n// This transfers a freshly created message port to the receiver.\n// This can be used, for example, to create communication channels between\n// multiple `Worker` threads that are children of the same parent thread.\nconst otherChannel = new MessageChannel();\nport2.postMessage({ port: otherChannel.port1 }, [ otherChannel.port1 ]);\n</code></pre>\n<p>Because the object cloning uses the structured clone algorithm,\nnon-enumerable properties, property accessors, and object prototypes are\nnot preserved. In particular, <a href=\"buffer.html\"><code>Buffer</code></a> objects will be read as\nplain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>s on the receiving side.</p>\n<p>The message object will be cloned immediately, and can be modified after\nposting without having side effects.</p>\n<p>For more information on the serialization and deserialization mechanisms\nbehind this API, see the <a href=\"v8.html#v8_serialization_api\">serialization API of the <code>v8</code> module</a>.</p>",
               "modules": [
                 {
                   "textRaw": "Considerations when transferring TypedArrays and Buffers",
@@ -60261,7 +66277,7 @@
               "name": "messageerror",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -60296,7 +66312,7 @@
               "name": "getHeapSnapshot",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.9.0"
                 ],
                 "changes": []
               },
@@ -60410,11 +66426,11 @@
               "name": "performance",
               "meta": {
                 "added": [
-                  "v12.22.0"
+                  "v14.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>An object that can be used to query performance information from a worker\ninstance. Similar to <a href=\"worker_threads.html#perf_hooks.md#perf_hooks_perf_hooks_performance\"><code>perf_hooks.performance</code></a>.</p>",
+              "desc": "<p>An object that can be used to query performance information from a worker\ninstance. Similar to <a href=\"perf_hooks.html#perf_hooks_perf_hooks_performance\"><code>perf_hooks.performance</code></a>.</p>",
               "methods": [
                 {
                   "textRaw": "`performance.eventLoopUtilization([utilization1[, utilization2]])`",
@@ -60422,7 +66438,7 @@
                   "name": "eventLoopUtilization",
                   "meta": {
                     "added": [
-                      "v12.22.0"
+                      "v14.17.0"
                     ],
                     "changes": []
                   },
@@ -60466,7 +66482,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>The same call as <a href=\"perf_hooks.md#perf_hooks_performance_eventlooputilization_utilization1_utilization2\"><code>perf_hooks</code> <code>eventLoopUtilization()</code></a>, except the values\nof the worker instance are returned.</p>\n<p>One difference is that, unlike the main thread, bootstrapping within a worker\nis done within the event loop. So the event loop utilization will be\nimmediately available once the worker's script begins execution.</p>\n<p>An <code>idle</code> time that does not increase does not indicate that the worker is\nstuck in bootstrap. The following examples shows how the worker's entire\nlifetime will never accumulate any <code>idle</code> time, but is still be able to process\nmessages.</p>\n<pre><code class=\"language-js\">const { Worker, isMainThread, parentPort } = require('worker_threads');\n\nif (isMainThread) {\n  const worker = new Worker(__filename);\n  setInterval(() => {\n    worker.postMessage('hi');\n    console.log(worker.performance.eventLoopUtilization());\n  }, 100).unref();\n  return;\n}\n\nparentPort.on('message', () => console.log('msg')).unref();\n(function r(n) {\n  if (--n &#x3C; 0) return;\n  const t = Date.now();\n  while (Date.now() - t &#x3C; 300);\n  setImmediate(r, n);\n})(10);\n</code></pre>\n<p>The event loop utilization of a worker is available only after the <a href=\"worker_threads.html#worker_threads_event_online\"><code>'online'</code>\nevent</a> emitted, and if called before this, or after the <a href=\"worker_threads.html#worker_threads_event_exit\"><code>'exit'</code>\nevent</a>, then all properties have the value of <code>0</code>.</p>"
+                  "desc": "<p>The same call as <a href=\"perf_hooks.html#perf_hooks_performance_eventlooputilization_utilization1_utilization2\"><code>perf_hooks</code> <code>eventLoopUtilization()</code></a>, except the values\nof the worker instance are returned.</p>\n<p>One difference is that, unlike the main thread, bootstrapping within a worker\nis done within the event loop. So the event loop utilization will be\nimmediately available once the worker's script begins execution.</p>\n<p>An <code>idle</code> time that does not increase does not indicate that the worker is\nstuck in bootstrap. The following examples shows how the worker's entire\nlifetime will never accumulate any <code>idle</code> time, but is still be able to process\nmessages.</p>\n<pre><code class=\"language-js\">const { Worker, isMainThread, parentPort } = require('worker_threads');\n\nif (isMainThread) {\n  const worker = new Worker(__filename);\n  setInterval(() => {\n    worker.postMessage('hi');\n    console.log(worker.performance.eventLoopUtilization());\n  }, 100).unref();\n  return;\n}\n\nparentPort.on('message', () => console.log('msg')).unref();\n(function r(n) {\n  if (--n &#x3C; 0) return;\n  const t = Date.now();\n  while (Date.now() - t &#x3C; 300);\n  setImmediate(r, n);\n})(10);\n</code></pre>\n<p>The event loop utilization of a worker is available only after the <a href=\"worker_threads.html#worker_threads_event_online\"><code>'online'</code>\nevent</a> emitted, and if called before this, or after the <a href=\"worker_threads.html#worker_threads_event_exit\"><code>'exit'</code>\nevent</a>, then all properties have the value of <code>0</code>.</p>"
                 }
               ]
             },
@@ -60476,6 +66492,7 @@
               "name": "resourceLimits",
               "meta": {
                 "added": [
+                  "v13.2.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -60557,10 +66574,10 @@
             {
               "params": [
                 {
-                  "textRaw": "`filename` {string|URL} The path to the Worker’s main script or module. Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with `./` or `../`, or a WHATWG `URL` object using `file:` protocol. If `options.eval` is `true`, this is a string containing JavaScript code rather than a path.",
+                  "textRaw": "`filename` {string|URL} The path to the Worker’s main script or module. Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with `./` or `../`, or a WHATWG `URL` object using `file:` or `data:` protocol. When using a [`data:` URL][], the data is interpreted based on MIME type using the [ECMAScript module loader][]. If `options.eval` is `true`, this is a string containing JavaScript code rather than a path.",
                   "name": "filename",
                   "type": "string|URL",
-                  "desc": "The path to the Worker’s main script or module. Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with `./` or `../`, or a WHATWG `URL` object using `file:` protocol. If `options.eval` is `true`, this is a string containing JavaScript code rather than a path."
+                  "desc": "The path to the Worker’s main script or module. Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with `./` or `../`, or a WHATWG `URL` object using `file:` or `data:` protocol. When using a [`data:` URL][], the data is interpreted based on MIME type using the [ECMAScript module loader][]. If `options.eval` is `true`, this is a string containing JavaScript code rather than a path."
                 },
                 {
                   "textRaw": "`options` {Object}",
@@ -60668,8 +66685,33 @@
           ]
         }
       ],
+      "modules": [
+        {
+          "textRaw": "Notes",
+          "name": "notes",
+          "modules": [
+            {
+              "textRaw": "Synchronous blocking of stdio",
+              "name": "synchronous_blocking_of_stdio",
+              "desc": "<p><code>Worker</code>s utilize message passing via <a href=\"worker_threads.html#worker_threads_class_messageport\" class=\"type\">&lt;MessagePort&gt;</a> to implement interactions\nwith <code>stdio</code>. This means that <code>stdio</code> output originating from a <code>Worker</code> can\nget blocked by synchronous code on the receiving end that is blocking the\nNode.js event loop.</p>\n<pre><code class=\"language-mjs\">import {\n  Worker,\n  isMainThread,\n} from 'worker_threads';\n\nif (isMainThread) {\n  new Worker(new URL(import.meta.url));\n  for (let n = 0; n &#x3C; 1e10; n++) {}\n} else {\n  // This output will be blocked by the for loop in the main thread.\n  console.log('foo');\n}\n</code></pre>\n<pre><code class=\"language-cjs\">'use strict';\n\nconst {\n  Worker,\n  isMainThread,\n} = require('worker_threads');\n\nif (isMainThread) {\n  new Worker(__filename);\n  for (let n = 0; n &#x3C; 1e10; n++) {}\n} else {\n  // This output will be blocked by the for loop in the main thread.\n  console.log('foo');\n}\n</code></pre>",
+              "type": "module",
+              "displayName": "Synchronous blocking of stdio"
+            },
+            {
+              "textRaw": "Launching worker threads from preload scripts",
+              "name": "launching_worker_threads_from_preload_scripts",
+              "desc": "<p>Take care when launching worker threads from preload scripts (scripts loaded\nand run using the <code>-r</code> command line flag). Unless the <code>execArgv</code> option is\nexplicitly set, new Worker threads automatically inherit the command line flags\nfrom the running process and will preload the same preload scripts as the main\nthread. If the preload script unconditionally launches a worker thread, every\nthread spawned will spawn another until the application crashes.</p>",
+              "type": "module",
+              "displayName": "Launching worker threads from preload scripts"
+            }
+          ],
+          "type": "module",
+          "displayName": "Notes"
+        }
+      ],
       "type": "module",
-      "displayName": "Worker threads"
+      "displayName": "Worker threads",
+      "source": "doc/api/worker_threads.md"
     },
     {
       "textRaw": "Zlib",
@@ -60677,7 +66719,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/zlib.js\">lib/zlib.js</a></p>\n<p>The <code>zlib</code> module provides compression functionality implemented using Gzip,\nDeflate/Inflate, and Brotli.</p>\n<p>To access it:</p>\n<pre><code class=\"language-js\">const zlib = require('zlib');\n</code></pre>\n<p>Compression and decompression are built around the Node.js <a href=\"stream.md\">Streams API</a>.</p>\n<p>Compressing or decompressing a stream (such as a file) can be accomplished by\npiping the source stream through a <code>zlib</code> <code>Transform</code> stream into a destination\nstream:</p>\n<pre><code class=\"language-js\">const { createGzip } = require('zlib');\nconst { pipeline } = require('stream');\nconst {\n  createReadStream,\n  createWriteStream\n} = require('fs');\n\nconst gzip = createGzip();\nconst source = createReadStream('input.txt');\nconst destination = createWriteStream('input.txt.gz');\n\npipeline(source, gzip, destination, (err) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n});\n\n// Or, Promisified\n\nconst { promisify } = require('util');\nconst pipe = promisify(pipeline);\n\nasync function do_gzip(input, output) {\n  const gzip = createGzip();\n  const source = createReadStream(input);\n  const destination = createWriteStream(output);\n  await pipe(source, gzip, destination);\n}\n\ndo_gzip('input.txt', 'input.txt.gz')\n  .catch((err) => {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  });\n</code></pre>\n<p>It is also possible to compress or decompress data in a single step:</p>\n<pre><code class=\"language-js\">const { deflate, unzip } = require('zlib');\n\nconst input = '.................................';\ndeflate(input, (err, buffer) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n  console.log(buffer.toString('base64'));\n});\n\nconst buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');\nunzip(buffer, (err, buffer) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n  console.log(buffer.toString());\n});\n\n// Or, Promisified\n\nconst { promisify } = require('util');\nconst do_unzip = promisify(unzip);\n\ndo_unzip(buffer)\n  .then((buf) => console.log(buf.toString()))\n  .catch((err) => {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  });\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/zlib.js\">lib/zlib.js</a></p>\n<p>The <code>zlib</code> module provides compression functionality implemented using Gzip,\nDeflate/Inflate, and Brotli.</p>\n<p>To access it:</p>\n<pre><code class=\"language-js\">const zlib = require('zlib');\n</code></pre>\n<p>Compression and decompression are built around the Node.js <a href=\"stream.html\">Streams API</a>.</p>\n<p>Compressing or decompressing a stream (such as a file) can be accomplished by\npiping the source stream through a <code>zlib</code> <code>Transform</code> stream into a destination\nstream:</p>\n<pre><code class=\"language-js\">const { createGzip } = require('zlib');\nconst { pipeline } = require('stream');\nconst {\n  createReadStream,\n  createWriteStream\n} = require('fs');\n\nconst gzip = createGzip();\nconst source = createReadStream('input.txt');\nconst destination = createWriteStream('input.txt.gz');\n\npipeline(source, gzip, destination, (err) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n});\n\n// Or, Promisified\n\nconst { promisify } = require('util');\nconst pipe = promisify(pipeline);\n\nasync function do_gzip(input, output) {\n  const gzip = createGzip();\n  const source = createReadStream(input);\n  const destination = createWriteStream(output);\n  await pipe(source, gzip, destination);\n}\n\ndo_gzip('input.txt', 'input.txt.gz')\n  .catch((err) => {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  });\n</code></pre>\n<p>It is also possible to compress or decompress data in a single step:</p>\n<pre><code class=\"language-js\">const { deflate, unzip } = require('zlib');\n\nconst input = '.................................';\ndeflate(input, (err, buffer) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n  console.log(buffer.toString('base64'));\n});\n\nconst buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');\nunzip(buffer, (err, buffer) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n  console.log(buffer.toString());\n});\n\n// Or, Promisified\n\nconst { promisify } = require('util');\nconst do_unzip = promisify(unzip);\n\ndo_unzip(buffer)\n  .then((buf) => console.log(buf.toString()))\n  .catch((err) => {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  });\n</code></pre>",
       "modules": [
         {
           "textRaw": "Threadpool usage and performance considerations",
@@ -60746,7 +66788,8 @@
               "name": "brotli_constants",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -60789,7 +66832,10 @@
             ],
             "changes": [
               {
-                "version": "v12.19.0",
+                "version": [
+                  "v14.5.0",
+                  "v12.19.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/33516",
                 "description": "The `maxOutputLength` option is supported now."
               },
@@ -60822,7 +66868,7 @@
             ],
             "changes": [
               {
-                "version": "v12.19.0",
+                "version": "v14.5.0",
                 "pr-url": "https://github.com/nodejs/node/pull/33516",
                 "description": "The `maxOutputLength` option is supported now."
               }
@@ -60842,7 +66888,8 @@
               "name": "brotliCompress",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -60874,7 +66921,8 @@
               "name": "brotliCompressSync",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -60902,7 +66950,8 @@
               "name": "brotliDecompress",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -60934,7 +66983,8 @@
               "name": "brotliDecompressSync",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -61611,7 +67661,8 @@
           "name": "zlib.BrotliCompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -61623,7 +67674,8 @@
           "name": "zlib.BrotliDecompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -61756,7 +67808,10 @@
             ],
             "changes": [
               {
-                "version": "v11.7.0",
+                "version": [
+                  "v11.7.0",
+                  "v10.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/24939",
                 "description": "This class was renamed from `Zlib` to `ZlibBase`."
               }
@@ -61919,7 +67974,8 @@
           "name": "createBrotliCompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -61942,7 +67998,8 @@
           "name": "createBrotliDecompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -62126,7 +68183,8 @@
           "name": "brotliCompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -62158,7 +68216,8 @@
           "name": "brotliCompressSync",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -62186,7 +68245,8 @@
           "name": "brotliDecompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -62218,7 +68278,8 @@
           "name": "brotliDecompressSync",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -62881,7 +68942,8 @@
         }
       ],
       "type": "module",
-      "displayName": "Zlib"
+      "displayName": "Zlib",
+      "source": "doc/api/zlib.md"
     }
   ],
   "classes": [
@@ -62951,37 +69013,42 @@
           ],
           "desc": "<p>Creates a new <code>Error</code> object and sets the <code>error.message</code> property to the\nprovided text message. If an object is passed as <code>message</code>, the text message\nis generated by calling <code>message.toString()</code>. The <code>error.stack</code> property will\nrepresent the point in the code at which <code>new Error()</code> was called. Stack traces\nare dependent on <a href=\"https://github.com/v8/v8/wiki/Stack-Trace-API\">V8's stack trace API</a>. Stack traces extend only to either\n(a) the beginning of <em>synchronous code execution</em>, or (b) the number of frames\ngiven by the property <code>Error.stackTraceLimit</code>, whichever is smaller.</p>"
         }
-      ]
+      ],
+      "source": "doc/api/errors.md"
     },
     {
       "textRaw": "Class: `AssertionError`",
       "type": "class",
       "name": "AssertionError",
-      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates the failure of an assertion. For details, see\n<a href=\"assert.html#assert_class_assert_assertionerror\"><code>Class: assert.AssertionError</code></a>.</p>"
+      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates the failure of an assertion. For details, see\n<a href=\"assert.html#assert_class_assert_assertionerror\"><code>Class: assert.AssertionError</code></a>.</p>",
+      "source": "doc/api/errors.md"
     },
     {
       "textRaw": "Class: `RangeError`",
       "type": "class",
       "name": "RangeError",
-      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that a provided argument was not within the set or range of\nacceptable values for a function; whether that is a numeric range, or\noutside the set of options for a given function parameter.</p>\n<pre><code class=\"language-js\">require('net').connect(-1);\n// Throws \"RangeError: \"port\" option should be >= 0 and &#x3C; 65536: -1\"\n</code></pre>\n<p>Node.js will generate and throw <code>RangeError</code> instances <em>immediately</em> as a form\nof argument validation.</p>"
+      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that a provided argument was not within the set or range of\nacceptable values for a function; whether that is a numeric range, or\noutside the set of options for a given function parameter.</p>\n<pre><code class=\"language-js\">require('net').connect(-1);\n// Throws \"RangeError: \"port\" option should be >= 0 and &#x3C; 65536: -1\"\n</code></pre>\n<p>Node.js will generate and throw <code>RangeError</code> instances <em>immediately</em> as a form\nof argument validation.</p>",
+      "source": "doc/api/errors.md"
     },
     {
       "textRaw": "Class: `ReferenceError`",
       "type": "class",
       "name": "ReferenceError",
-      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that an attempt is being made to access a variable that is not\ndefined. Such errors commonly indicate typos in code, or an otherwise broken\nprogram.</p>\n<p>While client code may generate and propagate these errors, in practice, only V8\nwill do so.</p>\n<pre><code class=\"language-js\">doesNotExist;\n// Throws ReferenceError, doesNotExist is not a variable in this program.\n</code></pre>\n<p>Unless an application is dynamically generating and running code,\n<code>ReferenceError</code> instances indicate a bug in the code or its dependencies.</p>"
+      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that an attempt is being made to access a variable that is not\ndefined. Such errors commonly indicate typos in code, or an otherwise broken\nprogram.</p>\n<p>While client code may generate and propagate these errors, in practice, only V8\nwill do so.</p>\n<pre><code class=\"language-js\">doesNotExist;\n// Throws ReferenceError, doesNotExist is not a variable in this program.\n</code></pre>\n<p>Unless an application is dynamically generating and running code,\n<code>ReferenceError</code> instances indicate a bug in the code or its dependencies.</p>",
+      "source": "doc/api/errors.md"
     },
     {
       "textRaw": "Class: `SyntaxError`",
       "type": "class",
       "name": "SyntaxError",
-      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that a program is not valid JavaScript. These errors may only be\ngenerated and propagated as a result of code evaluation. Code evaluation may\nhappen as a result of <code>eval</code>, <code>Function</code>, <code>require</code>, or <a href=\"vm.html\">vm</a>. These errors\nare almost always indicative of a broken program.</p>\n<pre><code class=\"language-js\">try {\n  require('vm').runInThisContext('binary ! isNotOk');\n} catch (err) {\n  // 'err' will be a SyntaxError.\n}\n</code></pre>\n<p><code>SyntaxError</code> instances are unrecoverable in the context that created them –\nthey may only be caught by other contexts.</p>"
+      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that a program is not valid JavaScript. These errors may only be\ngenerated and propagated as a result of code evaluation. Code evaluation may\nhappen as a result of <code>eval</code>, <code>Function</code>, <code>require</code>, or <a href=\"vm.html\">vm</a>. These errors\nare almost always indicative of a broken program.</p>\n<pre><code class=\"language-js\">try {\n  require('vm').runInThisContext('binary ! isNotOk');\n} catch (err) {\n  // 'err' will be a SyntaxError.\n}\n</code></pre>\n<p><code>SyntaxError</code> instances are unrecoverable in the context that created them –\nthey may only be caught by other contexts.</p>",
+      "source": "doc/api/errors.md"
     },
     {
       "textRaw": "Class: `SystemError`",
       "type": "class",
       "name": "SystemError",
-      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Node.js generates system errors when exceptions occur within its runtime\nenvironment. These usually occur when an application violates an operating\nsystem constraint. For example, a system error will occur if an application\nattempts to read a file that does not exist.</p>\n<ul>\n<li><code>address</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the address to which a network connection\nfailed</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> The string error code</li>\n<li><code>dest</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path destination when reporting a file\nsystem error</li>\n<li><code>errno</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The system-provided error number</li>\n<li><code>info</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> If present, extra details about the error condition</li>\n<li><code>message</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A system-provided human-readable description of the error</li>\n<li><code>path</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path when reporting a file system error</li>\n<li><code>port</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> If present, the network connection port that is not available</li>\n<li><code>syscall</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The name of the system call that triggered the error</li>\n</ul>",
+      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Node.js generates system errors when exceptions occur within its runtime\nenvironment. These usually occur when an application violates an operating\nsystem constraint. For example, a system error will occur if an application\nattempts to read a file that does not exist.</p>\n<ul>\n<li><code>address</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the address to which a network connection\nfailed</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> The string error code</li>\n<li><code>dest</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path destination when reporting a file\nsystem error</li>\n<li><code>errno</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The system-provided error number</li>\n<li><code>info</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> If present, extra details about the error condition</li>\n<li><code>message</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A system-provided human-readable description of the error</li>\n<li><code>path</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path when reporting a file system error</li>\n<li><code>port</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> If present, the network connection port that is not available</li>\n<li><code>syscall</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The name of the system call that triggered the error</li>\n</ul>",
       "properties": [
         {
           "textRaw": "`address` {string}",
@@ -63002,10 +69069,10 @@
           "desc": "<p>If present, <code>error.dest</code> is the file path destination when reporting a file\nsystem error.</p>"
         },
         {
-          "textRaw": "`errno` {string|number}",
-          "type": "string|number",
+          "textRaw": "`errno` {number}",
+          "type": "number",
           "name": "errno",
-          "desc": "<p>The <code>error.errno</code> property is a number or a string. If it is a number, it is a\nnegative value which corresponds to the error code defined in\n<a href=\"https://docs.libuv.org/en/v1.x/errors.html\"><code>libuv Error handling</code></a>. See the libuv <code>errno.h</code> header file\n(<code>deps/uv/include/uv/errno.h</code> in the Node.js source tree) for details. In case\nof a string, it is the same as <code>error.code</code>.</p>"
+          "desc": "<p>The <code>error.errno</code> property is a negative number which corresponds\nto the error code defined in <a href=\"https://docs.libuv.org/en/v1.x/errors.html\"><code>libuv Error handling</code></a>.</p>\n<p>On Windows the error number provided by the system will be normalized by libuv.</p>\n<p>To get the string representation of the error code, use\n<a href=\"util.html#util_util_getsystemerrorname_err\"><code>util.getSystemErrorName(error.errno)</code></a>.</p>"
         },
         {
           "textRaw": "`info` {Object}",
@@ -63046,16 +69113,144 @@
           "type": "module",
           "displayName": "Common system errors"
         }
-      ]
+      ],
+      "source": "doc/api/errors.md"
     },
     {
       "textRaw": "Class: `TypeError`",
       "type": "class",
       "name": "TypeError",
-      "desc": "<ul>\n<li>Extends <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that a provided argument is not an allowable type. For example,\npassing a function to a parameter which expects a string would be a <code>TypeError</code>.</p>\n<pre><code class=\"language-js\">require('url').parse(() => { });\n// Throws TypeError, since it expected a string.\n</code></pre>\n<p>Node.js will generate and throw <code>TypeError</code> instances <em>immediately</em> as a form\nof argument validation.</p>"
+      "desc": "<ul>\n<li>Extends <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Indicates that a provided argument is not an allowable type. For example,\npassing a function to a parameter which expects a string would be a <code>TypeError</code>.</p>\n<pre><code class=\"language-js\">require('url').parse(() => { });\n// Throws TypeError, since it expected a string.\n</code></pre>\n<p>Node.js will generate and throw <code>TypeError</code> instances <em>immediately</em> as a form\nof argument validation.</p>",
+      "source": "doc/api/errors.md"
     }
   ],
   "globals": [
+    {
+      "textRaw": "Class: `AbortController`",
+      "type": "global",
+      "name": "AbortController",
+      "meta": {
+        "added": [
+          "v14.17.0"
+        ],
+        "changes": []
+      },
+      "stability": 1,
+      "stabilityText": "Experimental",
+      "desc": "<p>A utility class used to signal cancelation in selected <code>Promise</code>-based APIs.\nThe API is based on the Web API <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/AbortController\"><code>AbortController</code></a>.</p>\n<p>To use, launch Node.js using the <code>--experimental-abortcontroller</code> flag.</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\n\nac.signal.addEventListener('abort', () => console.log('Aborted!'),\n                           { once: true });\n\nac.abort();\n\nconsole.log(ac.signal.aborted);  // Prints True\n</code></pre>",
+      "methods": [
+        {
+          "textRaw": "`abortController.abort()`",
+          "type": "method",
+          "name": "abort",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<p>Triggers the abort signal, causing the <code>abortController.signal</code> to emit\nthe <code>'abort'</code> event.</p>"
+        }
+      ],
+      "properties": [
+        {
+          "textRaw": "`signal` Type: {AbortSignal}",
+          "type": "AbortSignal",
+          "name": "Type",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          }
+        }
+      ],
+      "classes": [
+        {
+          "textRaw": "Class: `AbortSignal`",
+          "type": "class",
+          "name": "AbortSignal",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventtarget\" class=\"type\">&lt;EventTarget&gt;</a></li>\n</ul>\n<p>The <code>AbortSignal</code> is used to notify observers when the\n<code>abortController.abort()</code> method is called.</p>",
+          "classMethods": [
+            {
+              "textRaw": "Static method: `AbortSignal.abort()`",
+              "type": "classMethod",
+              "name": "abort",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {AbortSignal}",
+                    "name": "return",
+                    "type": "AbortSignal"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns a new already aborted <code>AbortSignal</code>.</p>"
+            }
+          ],
+          "events": [
+            {
+              "textRaw": "Event: `'abort'`",
+              "type": "event",
+              "name": "abort",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>The <code>'abort'</code> event is emitted when the <code>abortController.abort()</code> method\nis called. The callback is invoked with a single object argument with a\nsingle <code>type</code> property set to <code>'abort'</code>:</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\n\n// Use either the onabort property...\nac.signal.onabort = () => console.log('aborted!');\n\n// Or the EventTarget API...\nac.signal.addEventListener('abort', (event) => {\n  console.log(event.type);  // Prints 'abort'\n}, { once: true });\n\nac.abort();\n</code></pre>\n<p>The <code>AbortController</code> with which the <code>AbortSignal</code> is associated will only\never trigger the <code>'abort'</code> event once. We recommended that code check\nthat the <code>abortSignal.aborted</code> attribute is <code>false</code> before adding an <code>'abort'</code>\nevent listener.</p>\n<p>Any event listeners attached to the <code>AbortSignal</code> should use the\n<code>{ once: true }</code> option (or, if using the <code>EventEmitter</code> APIs to attach a\nlistener, use the <code>once()</code> method) to ensure that the event listener is\nremoved as soon as the <code>'abort'</code> event is handled. Failure to do so may\nresult in memory leaks.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`aborted` Type: {boolean} True after the `AbortController` has been aborted.",
+              "type": "boolean",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "True after the `AbortController` has been aborted."
+            },
+            {
+              "textRaw": "`onabort` Type: {Function}",
+              "type": "Function",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An optional callback function that may be set by user code to be notified\nwhen the <code>abortController.abort()</code> function has been called.</p>"
+            }
+          ]
+        }
+      ],
+      "source": "doc/api/globals.md"
+    },
     {
       "textRaw": "Class: `Buffer`",
       "type": "global",
@@ -63066,7 +69261,8 @@
         ],
         "changes": []
       },
-      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a></li>\n</ul>\n<p>Used to handle binary data. See the <a href=\"buffer.html\">buffer section</a>.</p>"
+      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a></li>\n</ul>\n<p>Used to handle binary data. See the <a href=\"buffer.html\">buffer section</a>.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`clearImmediate(immediateObject)`",
@@ -63078,7 +69274,8 @@
         ],
         "changes": []
       },
-      "desc": "<p><a href=\"timers.html#timers_clearimmediate_immediate\"><code>clearImmediate</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>"
+      "desc": "<p><a href=\"timers.html#timers_clearimmediate_immediate\"><code>clearImmediate</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`clearInterval(intervalObject)`",
@@ -63090,7 +69287,8 @@
         ],
         "changes": []
       },
-      "desc": "<p><a href=\"timers.html#timers_clearinterval_timeout\"><code>clearInterval</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>"
+      "desc": "<p><a href=\"timers.html#timers_clearinterval_timeout\"><code>clearInterval</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`clearTimeout(timeoutObject)`",
@@ -63102,7 +69300,8 @@
         ],
         "changes": []
       },
-      "desc": "<p><a href=\"timers.html#timers_cleartimeout_timeout\"><code>clearTimeout</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>"
+      "desc": "<p><a href=\"timers.html#timers_cleartimeout_timeout\"><code>clearTimeout</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`console`",
@@ -63114,7 +69313,8 @@
         "changes": []
       },
       "type": "global",
-      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n</ul>\n<p>Used to print to stdout and stderr. See the <a href=\"console.html\"><code>console</code></a> section.</p>"
+      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n</ul>\n<p>Used to print to stdout and stderr. See the <a href=\"console.html\"><code>console</code></a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`global`",
@@ -63126,7 +69326,8 @@
         "changes": []
       },
       "type": "global",
-      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The global namespace object.</li>\n</ul>\n<p>In browsers, the top-level scope is the global scope. This means that\nwithin the browser <code>var something</code> will define a new global variable. In\nNode.js this is different. The top-level scope is not the global scope;\n<code>var something</code> inside a Node.js module will be local to that module.</p>"
+      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The global namespace object.</li>\n</ul>\n<p>In browsers, the top-level scope is the global scope. This means that\nwithin the browser <code>var something</code> will define a new global variable. In\nNode.js this is different. The top-level scope is not the global scope;\n<code>var something</code> inside a Node.js module will be local to that module.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`process`",
@@ -63138,7 +69339,8 @@
         "changes": []
       },
       "type": "global",
-      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n</ul>\n<p>The process object. See the <a href=\"process.html#process_process\"><code>process</code> object</a> section.</p>"
+      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n</ul>\n<p>The process object. See the <a href=\"process.html#process_process\"><code>process</code> object</a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`queueMicrotask(callback)`",
@@ -63150,7 +69352,8 @@
         ],
         "changes": []
       },
-      "desc": "<ul>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a> Function to be queued.</li>\n</ul>\n<p>The <code>queueMicrotask()</code> method queues a microtask to invoke <code>callback</code>. If\n<code>callback</code> throws an exception, the <a href=\"process.html#process_process\"><code>process</code> object</a> <code>'uncaughtException'</code>\nevent will be emitted.</p>\n<p>The microtask queue is managed by V8 and may be used in a similar manner to\nthe <a href=\"process.html#process_process_nexttick_callback_args\"><code>process.nextTick()</code></a> queue, which is managed by Node.js. The\n<code>process.nextTick()</code> queue is always processed before the microtask queue\nwithin each turn of the Node.js event loop.</p>\n<pre><code class=\"language-js\">// Here, `queueMicrotask()` is used to ensure the 'load' event is always\n// emitted asynchronously, and therefore consistently. Using\n// `process.nextTick()` here would result in the 'load' event always emitting\n// before any other promise jobs.\n\nDataHandler.prototype.load = async function load(key) {\n  const hit = this._cache.get(url);\n  if (hit !== undefined) {\n    queueMicrotask(() => {\n      this.emit('load', hit);\n    });\n    return;\n  }\n\n  const data = await fetchData(key);\n  this._cache.set(url, data);\n  this.emit('load', data);\n};\n</code></pre>"
+      "desc": "<ul>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a> Function to be queued.</li>\n</ul>\n<p>The <code>queueMicrotask()</code> method queues a microtask to invoke <code>callback</code>. If\n<code>callback</code> throws an exception, the <a href=\"process.html#process_process\"><code>process</code> object</a> <code>'uncaughtException'</code>\nevent will be emitted.</p>\n<p>The microtask queue is managed by V8 and may be used in a similar manner to\nthe <a href=\"process.html#process_process_nexttick_callback_args\"><code>process.nextTick()</code></a> queue, which is managed by Node.js. The\n<code>process.nextTick()</code> queue is always processed before the microtask queue\nwithin each turn of the Node.js event loop.</p>\n<pre><code class=\"language-js\">// Here, `queueMicrotask()` is used to ensure the 'load' event is always\n// emitted asynchronously, and therefore consistently. Using\n// `process.nextTick()` here would result in the 'load' event always emitting\n// before any other promise jobs.\n\nDataHandler.prototype.load = async function load(key) {\n  const hit = this._cache.get(key);\n  if (hit !== undefined) {\n    queueMicrotask(() => {\n      this.emit('load', hit);\n    });\n    return;\n  }\n\n  const data = await fetchData(key);\n  this._cache.set(key, data);\n  this.emit('load', data);\n};\n</code></pre>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`setImmediate(callback[, ...args])`",
@@ -63162,7 +69365,8 @@
         ],
         "changes": []
       },
-      "desc": "<p><a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>"
+      "desc": "<p><a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`setInterval(callback, delay[, ...args])`",
@@ -63174,7 +69378,8 @@
         ],
         "changes": []
       },
-      "desc": "<p><a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>"
+      "desc": "<p><a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`setTimeout(callback, delay[, ...args])`",
@@ -63186,7 +69391,8 @@
         ],
         "changes": []
       },
-      "desc": "<p><a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>"
+      "desc": "<p><a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout</code></a> is described in the <a href=\"timers.html\">timers</a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`TextDecoder`",
@@ -63198,7 +69404,8 @@
         "changes": []
       },
       "type": "global",
-      "desc": "<p>The WHATWG <code>TextDecoder</code> class. See the <a href=\"util.html#util_class_util_textdecoder\"><code>TextDecoder</code></a> section.</p>"
+      "desc": "<p>The WHATWG <code>TextDecoder</code> class. See the <a href=\"util.html#util_class_util_textdecoder\"><code>TextDecoder</code></a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`TextEncoder`",
@@ -63210,7 +69417,8 @@
         "changes": []
       },
       "type": "global",
-      "desc": "<p>The WHATWG <code>TextEncoder</code> class. See the <a href=\"util.html#util_class_util_textencoder\"><code>TextEncoder</code></a> section.</p>"
+      "desc": "<p>The WHATWG <code>TextEncoder</code> class. See the <a href=\"util.html#util_class_util_textencoder\"><code>TextEncoder</code></a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`URL`",
@@ -63222,7 +69430,8 @@
         "changes": []
       },
       "type": "global",
-      "desc": "<p>The WHATWG <code>URL</code> class. See the <a href=\"url.html#url_class_url\"><code>URL</code></a> section.</p>"
+      "desc": "<p>The WHATWG <code>URL</code> class. See the <a href=\"url.html#url_class_url\"><code>URL</code></a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`URLSearchParams`",
@@ -63234,7 +69443,8 @@
         "changes": []
       },
       "type": "global",
-      "desc": "<p>The WHATWG <code>URLSearchParams</code> class. See the <a href=\"url.html#url_class_urlsearchparams\"><code>URLSearchParams</code></a> section.</p>"
+      "desc": "<p>The WHATWG <code>URLSearchParams</code> class. See the <a href=\"url.html#url_class_urlsearchparams\"><code>URLSearchParams</code></a> section.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "`WebAssembly`",
@@ -63246,14 +69456,15 @@
         "changes": []
       },
       "type": "global",
-      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n</ul>\n<p>The object that acts as the namespace for all W3C\n<a href=\"https://webassembly.org\">WebAssembly</a> related functionality. See the\n<a href=\"https://developer.mozilla.org/en-US/docs/WebAssembly\">Mozilla Developer Network</a> for usage and compatibility.</p>"
+      "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n</ul>\n<p>The object that acts as the namespace for all W3C\n<a href=\"https://webassembly.org\">WebAssembly</a> related functionality. See the\n<a href=\"https://developer.mozilla.org/en-US/docs/WebAssembly\">Mozilla Developer Network</a> for usage and compatibility.</p>",
+      "source": "doc/api/globals.md"
     },
     {
       "textRaw": "Process",
       "name": "Process",
       "introduced_in": "v0.10.0",
       "type": "global",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/process.js\">lib/process.js</a></p>\n<p>The <code>process</code> object is a <code>global</code> that provides information about, and control\nover, the current Node.js process. As a global, it is always available to\nNode.js applications without using <code>require()</code>. It can also be explicitly\naccessed using <code>require()</code>:</p>\n<pre><code class=\"language-js\">const process = require('process');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/process.js\">lib/process.js</a></p>\n<p>The <code>process</code> object is a <code>global</code> that provides information about, and control\nover, the current Node.js process. As a global, it is always available to\nNode.js applications without using <code>require()</code>. It can also be explicitly\naccessed using <code>require()</code>:</p>\n<pre><code class=\"language-js\">const process = require('process');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Process events",
@@ -63393,7 +69604,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.0.0",
+                    "version": [
+                      "v12.0.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/26599",
                     "description": "Added the `origin` argument."
                   }
@@ -63407,10 +69621,10 @@
                   "desc": "The uncaught exception."
                 },
                 {
-                  "textRaw": "`origin` {string} Indicates if the exception originates from an unhandled rejection or from an synchronous error. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` and an unhandled rejection.",
+                  "textRaw": "`origin` {string} Indicates if the exception originates from an unhandled rejection or from an synchronous error. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` or `throw` and an unhandled rejection.",
                   "name": "origin",
                   "type": "string",
-                  "desc": "Indicates if the exception originates from an unhandled rejection or from an synchronous error. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` and an unhandled rejection."
+                  "desc": "Indicates if the exception originates from an unhandled rejection or from an synchronous error. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` or `throw` and an unhandled rejection."
                 }
               ],
               "desc": "<p>The <code>'uncaughtException'</code> event is emitted when an uncaught JavaScript\nexception bubbles all the way back to the event loop. By default, Node.js\nhandles such exceptions by printing the stack trace to <code>stderr</code> and exiting\nwith code 1, overriding any previously set <a href=\"process.html#process_process_exitcode\"><code>process.exitCode</code></a>.\nAdding a handler for the <code>'uncaughtException'</code> event overrides this default\nbehavior. Alternatively, change the <a href=\"process.html#process_process_exitcode\"><code>process.exitCode</code></a> in the\n<code>'uncaughtException'</code> handler which will result in the process exiting with the\nprovided exit code. Otherwise, in the presence of such handler the process will\nexit with 0.</p>\n<pre><code class=\"language-js\">process.on('uncaughtException', (err, origin) => {\n  fs.writeSync(\n    process.stderr.fd,\n    `Caught exception: ${err}\\n` +\n    `Exception origin: ${origin}`\n  );\n});\n\nsetTimeout(() => {\n  console.log('This will still run.');\n}, 500);\n\n// Intentionally cause an exception, but don't catch it.\nnonexistentFunc();\nconsole.log('This will not run.');\n</code></pre>\n<p>It is possible to monitor <code>'uncaughtException'</code> events without overriding the\ndefault behavior to exit the process by installing a\n<code>'uncaughtExceptionMonitor'</code> listener.</p>",
@@ -63430,7 +69644,7 @@
               "name": "uncaughtExceptionMonitor",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.7.0"
                 ],
                 "changes": []
               },
@@ -63442,10 +69656,10 @@
                   "desc": "The uncaught exception."
                 },
                 {
-                  "textRaw": "`origin` {string} Indicates if the exception originates from an unhandled rejection or from synchronous errors. Can either be `'uncaughtException'` or `'unhandledRejection'`.",
+                  "textRaw": "`origin` {string} Indicates if the exception originates from an unhandled rejection or from synchronous errors. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` or `throw` and an unhandled rejection.",
                   "name": "origin",
                   "type": "string",
-                  "desc": "Indicates if the exception originates from an unhandled rejection or from synchronous errors. Can either be `'uncaughtException'` or `'unhandledRejection'`."
+                  "desc": "Indicates if the exception originates from an unhandled rejection or from synchronous errors. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` or `throw` and an unhandled rejection."
                 }
               ],
               "desc": "<p>The <code>'uncaughtExceptionMonitor'</code> event is emitted before an\n<code>'uncaughtException'</code> event is emitted or a hook installed via\n<a href=\"process.html#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a> is called.</p>\n<p>Installing an <code>'uncaughtExceptionMonitor'</code> listener does not change the behavior\nonce an <code>'uncaughtException'</code> event is emitted. The process will\nstill crash if no <code>'uncaughtException'</code> listener is installed.</p>\n<pre><code class=\"language-js\">process.on('uncaughtExceptionMonitor', (err, origin) => {\n  MyMonitoringTool.logSync(err, origin);\n});\n\n// Intentionally cause an exception, but don't catch it.\nnonexistentFunc();\n// Still crashes Node.js\n</code></pre>"
@@ -63526,7 +69740,27 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>'warning'</code> event is emitted whenever Node.js emits a process warning.</p>\n<p>A process warning is similar to an error in that it describes exceptional\nconditions that are being brought to the user's attention. However, warnings\nare not part of the normal Node.js and JavaScript error handling flow.\nNode.js can emit warnings whenever it detects bad coding practices that could\nlead to sub-optimal application performance, bugs, or security vulnerabilities.</p>\n<pre><code class=\"language-js\">process.on('warning', (warning) => {\n  console.warn(warning.name);    // Print the warning name\n  console.warn(warning.message); // Print the warning message\n  console.warn(warning.stack);   // Print the stack trace\n});\n</code></pre>\n<p>By default, Node.js will print process warnings to <code>stderr</code>. The <code>--no-warnings</code>\ncommand-line option can be used to suppress the default console output but the\n<code>'warning'</code> event will still be emitted by the <code>process</code> object.</p>\n<p>The following example illustrates the warning that is printed to <code>stderr</code> when\ntoo many listeners have been added to an event:</p>\n<pre><code class=\"language-console\">$ node\n> events.defaultMaxListeners = 1;\n> process.on('foo', () => {});\n> process.on('foo', () => {});\n> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak\ndetected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit\n</code></pre>\n<p>In contrast, the following example turns off the default warning output and\nadds a custom handler to the <code>'warning'</code> event:</p>\n<pre><code class=\"language-console\">$ node --no-warnings\n> const p = process.on('warning', (warning) => console.warn('Do not do that!'));\n> events.defaultMaxListeners = 1;\n> process.on('foo', () => {});\n> process.on('foo', () => {});\n> Do not do that!\n</code></pre>\n<p>The <code>--trace-warnings</code> command-line option can be used to have the default\nconsole output for warnings include the full stack trace of the warning.</p>\n<p>Launching Node.js using the <code>--throw-deprecation</code> command line flag will\ncause custom deprecation warnings to be thrown as exceptions.</p>\n<p>Using the <code>--trace-deprecation</code> command line flag will cause the custom\ndeprecation to be printed to <code>stderr</code> along with the stack trace.</p>\n<p>Using the <code>--no-deprecation</code> command line flag will suppress all reporting\nof the custom deprecation.</p>\n<p>The <code>*-deprecation</code> command line flags only affect warnings that use the name\n<code>'DeprecationWarning'</code>.</p>",
+              "desc": "<p>The <code>'warning'</code> event is emitted whenever Node.js emits a process warning.</p>\n<p>A process warning is similar to an error in that it describes exceptional\nconditions that are being brought to the user's attention. However, warnings\nare not part of the normal Node.js and JavaScript error handling flow.\nNode.js can emit warnings whenever it detects bad coding practices that could\nlead to sub-optimal application performance, bugs, or security vulnerabilities.</p>\n<pre><code class=\"language-js\">process.on('warning', (warning) => {\n  console.warn(warning.name);    // Print the warning name\n  console.warn(warning.message); // Print the warning message\n  console.warn(warning.stack);   // Print the stack trace\n});\n</code></pre>\n<p>By default, Node.js will print process warnings to <code>stderr</code>. The <code>--no-warnings</code>\ncommand-line option can be used to suppress the default console output but the\n<code>'warning'</code> event will still be emitted by the <code>process</code> object.</p>\n<p>The following example illustrates the warning that is printed to <code>stderr</code> when\ntoo many listeners have been added to an event:</p>\n<pre><code class=\"language-console\">$ node\n> events.defaultMaxListeners = 1;\n> process.on('foo', () => {});\n> process.on('foo', () => {});\n> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak\ndetected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit\n</code></pre>\n<p>In contrast, the following example turns off the default warning output and\nadds a custom handler to the <code>'warning'</code> event:</p>\n<pre><code class=\"language-console\">$ node --no-warnings\n> const p = process.on('warning', (warning) => console.warn('Do not do that!'));\n> events.defaultMaxListeners = 1;\n> process.on('foo', () => {});\n> process.on('foo', () => {});\n> Do not do that!\n</code></pre>\n<p>The <code>--trace-warnings</code> command-line option can be used to have the default\nconsole output for warnings include the full stack trace of the warning.</p>\n<p>Launching Node.js using the <code>--throw-deprecation</code> command-line flag will\ncause custom deprecation warnings to be thrown as exceptions.</p>\n<p>Using the <code>--trace-deprecation</code> command-line flag will cause the custom\ndeprecation to be printed to <code>stderr</code> along with the stack trace.</p>\n<p>Using the <code>--no-deprecation</code> command-line flag will suppress all reporting\nof the custom deprecation.</p>\n<p>The <code>*-deprecation</code> command-line flags only affect warnings that use the name\n<code>'DeprecationWarning'</code>.</p>"
+            },
+            {
+              "textRaw": "Event: `'worker'`",
+              "type": "event",
+              "name": "worker",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "params": [
+                {
+                  "textRaw": "`worker` {Worker} The {Worker} that was created.",
+                  "name": "worker",
+                  "type": "Worker",
+                  "desc": "The {Worker} that was created."
+                }
+              ],
+              "desc": "<p>The <code>'worker'</code> event is emitted after a new <a href=\"worker_threads.html#worker_threads_class_worker\" class=\"type\">&lt;Worker&gt;</a> thread has been created.</p>",
               "modules": [
                 {
                   "textRaw": "Emitting custom warnings",
@@ -63534,6 +69768,13 @@
                   "desc": "<p>See the <a href=\"process.html#process_process_emitwarning_warning_type_code_ctor\"><code>process.emitWarning()</code></a> method for issuing\ncustom or application-specific warnings.</p>",
                   "type": "module",
                   "displayName": "Emitting custom warnings"
+                },
+                {
+                  "textRaw": "Node.js warning names",
+                  "name": "node.js_warning_names",
+                  "desc": "<p>There are no strict guidelines for warning types (as identified by the <code>name</code>\nproperty) emitted by Node.js. New types of warnings can be added at any time.\nA few of the warning types that are most common include:</p>\n<ul>\n<li><code>'DeprecationWarning'</code> - Indicates use of a deprecated Node.js API or feature.\nSuch warnings must include a <code>'code'</code> property identifying the\n<a href=\"deprecations.html\">deprecation code</a>.</li>\n<li><code>'ExperimentalWarning'</code> - Indicates use of an experimental Node.js API or\nfeature. Such features must be used with caution as they may change at any\ntime and are not subject to the same strict semantic-versioning and long-term\nsupport policies as supported features.</li>\n<li><code>'MaxListenersExceededWarning'</code> - Indicates that too many listeners for a\ngiven event have been registered on either an <code>EventEmitter</code> or <code>EventTarget</code>.\nThis is often an indication of a memory leak.</li>\n<li><code>'TimeoutOverflowWarning'</code> - Indicates that a numeric value that cannot fit\nwithin a 32-bit signed integer has been provided to either the <code>setTimeout()</code>\nor <code>setInterval()</code> functions.</li>\n<li><code>'UnsupportedWarning'</code> - Indicates use of an unsupported option or feature\nthat will be ignored rather than treated as an error. One example is use of\nthe HTTP response status message when using the HTTP/2 compatibility API.</li>\n</ul>",
+                  "type": "module",
+                  "displayName": "Node.js warning names"
                 }
               ]
             },
@@ -63542,7 +69783,7 @@
               "name": "SIGINT, SIGHUP, etc.",
               "type": "event",
               "params": [],
-              "desc": "<p>Signal events will be emitted when the Node.js process receives a signal. Please\nrefer to <a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a> for a listing of standard POSIX signal names such as\n<code>'SIGINT'</code>, <code>'SIGHUP'</code>, etc.</p>\n<p>Signals are not available on <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>\n<p>The signal handler will receive the signal's name (<code>'SIGINT'</code>,\n<code>'SIGTERM'</code>, etc.) as the first argument.</p>\n<p>The name of each event will be the uppercase common name for the signal (e.g.\n<code>'SIGINT'</code> for <code>SIGINT</code> signals).</p>\n<pre><code class=\"language-js\">// Begin reading from stdin so the process does not exit.\nprocess.stdin.resume();\n\nprocess.on('SIGINT', () => {\n  console.log('Received SIGINT. Press Control-D to exit.');\n});\n\n// Using a single function to handle multiple signals\nfunction handle(signal) {\n  console.log(`Received ${signal}`);\n}\n\nprocess.on('SIGINT', handle);\nprocess.on('SIGTERM', handle);\n</code></pre>\n<ul>\n<li><code>'SIGUSR1'</code> is reserved by Node.js to start the <a href=\"debugger.html\">debugger</a>. It's possible to\ninstall a listener but doing so might interfere with the debugger.</li>\n<li><code>'SIGTERM'</code> and <code>'SIGINT'</code> have default handlers on non-Windows platforms that\nreset the terminal mode before exiting with code <code>128 + signal number</code>. If one\nof these signals has a listener installed, its default behavior will be\nremoved (Node.js will no longer exit).</li>\n<li><code>'SIGPIPE'</code> is ignored by default. It can have a listener installed.</li>\n<li><code>'SIGHUP'</code> is generated on Windows when the console window is closed, and on\nother platforms under various similar conditions. See <a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a>. It can have a\nlistener installed, however Node.js will be unconditionally terminated by\nWindows about 10 seconds later. On non-Windows platforms, the default\nbehavior of <code>SIGHUP</code> is to terminate Node.js, but once a listener has been\ninstalled its default behavior will be removed.</li>\n<li><code>'SIGTERM'</code> is not supported on Windows, it can be listened on.</li>\n<li><code>'SIGINT'</code> from the terminal is supported on all platforms, and can usually be\ngenerated with <kbd>Ctrl</kbd>+<kbd>C</kbd> (though this may be configurable).\nIt is not generated when <a href=\"tty.html#tty_readstream_setrawmode_mode\">terminal raw mode</a> is enabled and\n<kbd>Ctrl</kbd>+<kbd>C</kbd> is used.</li>\n<li><code>'SIGBREAK'</code> is delivered on Windows when <kbd>Ctrl</kbd>+<kbd>Break</kbd> is\npressed. On non-Windows platforms, it can be listened on, but there is no way\nto send or generate it.</li>\n<li><code>'SIGWINCH'</code> is delivered when the console has been resized. On Windows, this\nwill only happen on write to the console when the cursor is being moved, or\nwhen a readable tty is used in raw mode.</li>\n<li><code>'SIGKILL'</code> cannot have a listener installed, it will unconditionally\nterminate Node.js on all platforms.</li>\n<li><code>'SIGSTOP'</code> cannot have a listener installed.</li>\n<li><code>'SIGBUS'</code>, <code>'SIGFPE'</code>, <code>'SIGSEGV'</code> and <code>'SIGILL'</code>, when not raised\n artificially using <a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a>, inherently leave the process in a state from\n which it is not safe to attempt to call JS listeners. Doing so might lead to\n the process hanging in an endless loop, since listeners attached using\n <code>process.on()</code> are called asynchronously and therefore unable to correct the\nunderlying problem.</li>\n<li><code>0</code> can be sent to test for the existence of a process, it has no effect if\nthe process exists, but will throw an error if the process does not exist.</li>\n</ul>\n<p>Windows does not support signals so has no equivalent to termination by signal,\nbut Node.js offers some emulation with <a href=\"process.html#process_process_kill_pid_signal\"><code>process.kill()</code></a>, and\n<a href=\"child_process.html#child_process_subprocess_kill_signal\"><code>subprocess.kill()</code></a>:</p>\n<ul>\n<li>Sending <code>SIGINT</code>, <code>SIGTERM</code>, and <code>SIGKILL</code> will cause the unconditional\ntermination of the target process, and afterwards, subprocess will report that\nthe process was terminated by signal.</li>\n<li>Sending signal <code>0</code> can be used as a platform independent way to test for the\nexistence of a process.</li>\n</ul>"
+              "desc": "<p>Signal events will be emitted when the Node.js process receives a signal. Please\nrefer to <a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a> for a listing of standard POSIX signal names such as\n<code>'SIGINT'</code>, <code>'SIGHUP'</code>, etc.</p>\n<p>Signals are not available on <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>\n<p>The signal handler will receive the signal's name (<code>'SIGINT'</code>,\n<code>'SIGTERM'</code>, etc.) as the first argument.</p>\n<p>The name of each event will be the uppercase common name for the signal (e.g.\n<code>'SIGINT'</code> for <code>SIGINT</code> signals).</p>\n<pre><code class=\"language-js\">// Begin reading from stdin so the process does not exit.\nprocess.stdin.resume();\n\nprocess.on('SIGINT', () => {\n  console.log('Received SIGINT. Press Control-D to exit.');\n});\n\n// Using a single function to handle multiple signals\nfunction handle(signal) {\n  console.log(`Received ${signal}`);\n}\n\nprocess.on('SIGINT', handle);\nprocess.on('SIGTERM', handle);\n</code></pre>\n<ul>\n<li><code>'SIGUSR1'</code> is reserved by Node.js to start the <a href=\"debugger.html\">debugger</a>. It's possible to\ninstall a listener but doing so might interfere with the debugger.</li>\n<li><code>'SIGTERM'</code> and <code>'SIGINT'</code> have default handlers on non-Windows platforms that\nreset the terminal mode before exiting with code <code>128 + signal number</code>. If one\nof these signals has a listener installed, its default behavior will be\nremoved (Node.js will no longer exit).</li>\n<li><code>'SIGPIPE'</code> is ignored by default. It can have a listener installed.</li>\n<li><code>'SIGHUP'</code> is generated on Windows when the console window is closed, and on\nother platforms under various similar conditions. See <a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a>. It can have a\nlistener installed, however Node.js will be unconditionally terminated by\nWindows about 10 seconds later. On non-Windows platforms, the default\nbehavior of <code>SIGHUP</code> is to terminate Node.js, but once a listener has been\ninstalled its default behavior will be removed.</li>\n<li><code>'SIGTERM'</code> is not supported on Windows, it can be listened on.</li>\n<li><code>'SIGINT'</code> from the terminal is supported on all platforms, and can usually be\ngenerated with <kbd>Ctrl</kbd>+<kbd>C</kbd> (though this may be configurable).\nIt is not generated when <a href=\"tty.html#tty_readstream_setrawmode_mode\">terminal raw mode</a> is enabled and\n<kbd>Ctrl</kbd>+<kbd>C</kbd> is used.</li>\n<li><code>'SIGBREAK'</code> is delivered on Windows when <kbd>Ctrl</kbd>+<kbd>Break</kbd> is\npressed. On non-Windows platforms, it can be listened on, but there is no way\nto send or generate it.</li>\n<li><code>'SIGWINCH'</code> is delivered when the console has been resized. On Windows, this\nwill only happen on write to the console when the cursor is being moved, or\nwhen a readable tty is used in raw mode.</li>\n<li><code>'SIGKILL'</code> cannot have a listener installed, it will unconditionally\nterminate Node.js on all platforms.</li>\n<li><code>'SIGSTOP'</code> cannot have a listener installed.</li>\n<li><code>'SIGBUS'</code>, <code>'SIGFPE'</code>, <code>'SIGSEGV'</code> and <code>'SIGILL'</code>, when not raised\nartificially using <a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a>, inherently leave the process in a state from\nwhich it is not safe to call JS listeners. Doing so might cause the process\nto stop responding.</li>\n<li><code>0</code> can be sent to test for the existence of a process, it has no effect if\nthe process exists, but will throw an error if the process does not exist.</li>\n</ul>\n<p>Windows does not support signals so has no equivalent to termination by signal,\nbut Node.js offers some emulation with <a href=\"process.html#process_process_kill_pid_signal\"><code>process.kill()</code></a>, and\n<a href=\"child_process.html#child_process_subprocess_kill_signal\"><code>subprocess.kill()</code></a>:</p>\n<ul>\n<li>Sending <code>SIGINT</code>, <code>SIGTERM</code>, and <code>SIGKILL</code> will cause the unconditional\ntermination of the target process, and afterwards, subprocess will report that\nthe process was terminated by signal.</li>\n<li>Sending signal <code>0</code> can be used as a platform independent way to test for the\nexistence of a process.</li>\n</ul>"
             }
           ],
           "type": "module",
@@ -63551,7 +69792,7 @@
         {
           "textRaw": "Exit codes",
           "name": "exit_codes",
-          "desc": "<p>Node.js will normally exit with a <code>0</code> status code when no more async\noperations are pending. The following status codes are used in other\ncases:</p>\n<ul>\n<li><code>1</code> <strong>Uncaught Fatal Exception</strong>: There was an uncaught exception,\nand it was not handled by a domain or an <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event\nhandler.</li>\n<li><code>2</code>: Unused (reserved by Bash for builtin misuse)</li>\n<li><code>3</code> <strong>Internal JavaScript Parse Error</strong>: The JavaScript source code\ninternal in the Node.js bootstrapping process caused a parse error. This\nis extremely rare, and generally can only happen during development\nof Node.js itself.</li>\n<li><code>4</code> <strong>Internal JavaScript Evaluation Failure</strong>: The JavaScript\nsource code internal in the Node.js bootstrapping process failed to\nreturn a function value when evaluated. This is extremely rare, and\ngenerally can only happen during development of Node.js itself.</li>\n<li><code>5</code> <strong>Fatal Error</strong>: There was a fatal unrecoverable error in V8.\nTypically a message will be printed to stderr with the prefix <code>FATAL ERROR</code>.</li>\n<li><code>6</code> <strong>Non-function Internal Exception Handler</strong>: There was an\nuncaught exception, but the internal fatal exception handler\nfunction was somehow set to a non-function, and could not be called.</li>\n<li><code>7</code> <strong>Internal Exception Handler Run-Time Failure</strong>: There was an\nuncaught exception, and the internal fatal exception handler\nfunction itself threw an error while attempting to handle it. This\ncan happen, for example, if an <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> or\n<code>domain.on('error')</code> handler throws an error.</li>\n<li><code>8</code>: Unused. In previous versions of Node.js, exit code 8 sometimes\nindicated an uncaught exception.</li>\n<li><code>9</code> <strong>Invalid Argument</strong>: Either an unknown option was specified,\nor an option requiring a value was provided without a value.</li>\n<li><code>10</code> <strong>Internal JavaScript Run-Time Failure</strong>: The JavaScript\nsource code internal in the Node.js bootstrapping process threw an error\nwhen the bootstrapping function was called. This is extremely rare,\nand generally can only happen during development of Node.js itself.</li>\n<li><code>12</code> <strong>Invalid Debug Argument</strong>: The <code>--inspect</code> and/or <code>--inspect-brk</code>\noptions were set, but the port number chosen was invalid or unavailable.</li>\n<li><code>>128</code> <strong>Signal Exits</strong>: If Node.js receives a fatal signal such as\n<code>SIGKILL</code> or <code>SIGHUP</code>, then its exit code will be <code>128</code> plus the\nvalue of the signal code. This is a standard POSIX practice, since\nexit codes are defined to be 7-bit integers, and signal exits set\nthe high-order bit, and then contain the value of the signal code.\nFor example, signal <code>SIGABRT</code> has value <code>6</code>, so the expected exit\ncode will be <code>128</code> + <code>6</code>, or <code>134</code>.</li>\n</ul>",
+          "desc": "<p>Node.js will normally exit with a <code>0</code> status code when no more async\noperations are pending. The following status codes are used in other\ncases:</p>\n<ul>\n<li><code>1</code> <strong>Uncaught Fatal Exception</strong>: There was an uncaught exception,\nand it was not handled by a domain or an <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event\nhandler.</li>\n<li><code>2</code>: Unused (reserved by Bash for builtin misuse)</li>\n<li><code>3</code> <strong>Internal JavaScript Parse Error</strong>: The JavaScript source code\ninternal in the Node.js bootstrapping process caused a parse error. This\nis extremely rare, and generally can only happen during development\nof Node.js itself.</li>\n<li><code>4</code> <strong>Internal JavaScript Evaluation Failure</strong>: The JavaScript\nsource code internal in the Node.js bootstrapping process failed to\nreturn a function value when evaluated. This is extremely rare, and\ngenerally can only happen during development of Node.js itself.</li>\n<li><code>5</code> <strong>Fatal Error</strong>: There was a fatal unrecoverable error in V8.\nTypically a message will be printed to stderr with the prefix <code>FATAL ERROR</code>.</li>\n<li><code>6</code> <strong>Non-function Internal Exception Handler</strong>: There was an\nuncaught exception, but the internal fatal exception handler\nfunction was somehow set to a non-function, and could not be called.</li>\n<li><code>7</code> <strong>Internal Exception Handler Run-Time Failure</strong>: There was an\nuncaught exception, and the internal fatal exception handler\nfunction itself threw an error while attempting to handle it. This\ncan happen, for example, if an <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> or\n<code>domain.on('error')</code> handler throws an error.</li>\n<li><code>8</code>: Unused. In previous versions of Node.js, exit code 8 sometimes\nindicated an uncaught exception.</li>\n<li><code>9</code> <strong>Invalid Argument</strong>: Either an unknown option was specified,\nor an option requiring a value was provided without a value.</li>\n<li><code>10</code> <strong>Internal JavaScript Run-Time Failure</strong>: The JavaScript\nsource code internal in the Node.js bootstrapping process threw an error\nwhen the bootstrapping function was called. This is extremely rare,\nand generally can only happen during development of Node.js itself.</li>\n<li><code>12</code> <strong>Invalid Debug Argument</strong>: The <code>--inspect</code> and/or <code>--inspect-brk</code>\noptions were set, but the port number chosen was invalid or unavailable.</li>\n<li><code>13</code> <strong>Unfinished Top-Level Await</strong>: <code>await</code> was used outside of a function\nin the top-level code, but the passed <code>Promise</code> never resolved.</li>\n<li><code>>128</code> <strong>Signal Exits</strong>: If Node.js receives a fatal signal such as\n<code>SIGKILL</code> or <code>SIGHUP</code>, then its exit code will be <code>128</code> plus the\nvalue of the signal code. This is a standard POSIX practice, since\nexit codes are defined to be 7-bit integers, and signal exits set\nthe high-order bit, and then contain the value of the signal code.\nFor example, signal <code>SIGABRT</code> has value <code>6</code>, so the expected exit\ncode will be <code>128</code> + <code>6</code>, or <code>134</code>.</li>\n</ul>",
           "type": "module",
           "displayName": "Exit codes"
         }
@@ -63715,7 +69956,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>process.dlopen()</code> method allows to dynamically load shared\nobjects. It is primarily used by <code>require()</code> to load\nC++ Addons, and should not be used directly, except in special\ncases. In other words, <a href=\"globals.html#globals_require\"><code>require()</code></a> should be preferred over\n<code>process.dlopen()</code>, unless there are specific reasons.</p>\n<p>The <code>flags</code> argument is an integer that allows to specify dlopen\nbehavior. See the <a href=\"os.html#os_dlopen_constants\"><code>os.constants.dlopen</code></a> documentation for details.</p>\n<p>If there are specific reasons to use <code>process.dlopen()</code> (for instance,\nto specify dlopen flags), it's often useful to use <a href=\"modules.html#modules_require_resolve_request_options\"><code>require.resolve()</code></a>\nto look up the module's path.</p>\n<p>An important drawback when calling <code>process.dlopen()</code> is that the <code>module</code>\ninstance must be passed. Functions exported by the C++ Addon will be accessible\nvia <code>module.exports</code>.</p>\n<p>The example below shows how to load a C++ Addon, named as <code>binding</code>,\nthat exports a <code>foo</code> function. All the symbols will be loaded before\nthe call returns, by passing the <code>RTLD_NOW</code> constant. In this example\nthe constant is assumed to be available.</p>\n<pre><code class=\"language-js\">const os = require('os');\nprocess.dlopen(module, require.resolve('binding'),\n               os.constants.dlopen.RTLD_NOW);\nmodule.exports.foo();\n</code></pre>"
+          "desc": "<p>The <code>process.dlopen()</code> method allows dynamically loading shared objects. It is\nprimarily used by <code>require()</code> to load C++ Addons, and should not be used\ndirectly, except in special cases. In other words, <a href=\"globals.html#globals_require\"><code>require()</code></a> should be\npreferred over <code>process.dlopen()</code> unless there are specific reasons such as\ncustom dlopen flags or loading from ES modules.</p>\n<p>The <code>flags</code> argument is an integer that allows to specify dlopen\nbehavior. See the <a href=\"os.html#os_dlopen_constants\"><code>os.constants.dlopen</code></a> documentation for details.</p>\n<p>An important requirement when calling <code>process.dlopen()</code> is that the <code>module</code>\ninstance must be passed. Functions exported by the C++ Addon are then\naccessible via <code>module.exports</code>.</p>\n<p>The example below shows how to load a C++ Addon, named <code>local.node</code>,\nthat exports a <code>foo</code> function. All the symbols are loaded before\nthe call returns, by passing the <code>RTLD_NOW</code> constant. In this example\nthe constant is assumed to be available.</p>\n<pre><code class=\"language-js\">const os = require('os');\nconst path = require('path');\nconst module = { exports: {} };\nprocess.dlopen(module, path.join(__dirname, 'local.node'),\n               os.constants.dlopen.RTLD_NOW);\nmodule.exports.foo();\n</code></pre>"
         },
         {
           "textRaw": "`process.emitWarning(warning[, options])`",
@@ -63933,7 +70174,7 @@
               "params": []
             }
           ],
-          "desc": "<p>The <code>process.getgroups()</code> method returns an array with the supplementary group\nIDs. POSIX leaves it unspecified if the effective group ID is included but\nNode.js ensures it always is.</p>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).</p>"
+          "desc": "<p>The <code>process.getgroups()</code> method returns an array with the supplementary group\nIDs. POSIX leaves it unspecified if the effective group ID is included but\nNode.js ensures it always is.</p>\n<pre><code class=\"language-js\">if (process.getgroups) {\n  console.log(process.getgroups()); // [ 16, 21, 297 ]\n}\n</code></pre>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).</p>"
         },
         {
           "textRaw": "`process.getuid()`",
@@ -63989,6 +70230,8 @@
             ],
             "changes": []
           },
+          "stability": 3,
+          "stabilityText": "Legacy. Use [`process.hrtime.bigint()`][] instead.",
           "signatures": [
             {
               "return": {
@@ -64101,7 +70344,7 @@
             ],
             "changes": [
               {
-                "version": "v12.17.0",
+                "version": "v13.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/31550",
                 "description": "Added `arrayBuffers` to the returned object."
               },
@@ -64149,7 +70392,29 @@
               "params": []
             }
           ],
-          "desc": "<p>The <code>process.memoryUsage()</code> method returns an object describing the memory usage\nof the Node.js process measured in bytes.</p>\n<p>For example, the code:</p>\n<pre><code class=\"language-js\">console.log(process.memoryUsage());\n</code></pre>\n<p>Will generate:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  rss: 4935680,\n  heapTotal: 1826816,\n  heapUsed: 650472,\n  external: 49879,\n  arrayBuffers: 9386\n}\n</code></pre>\n<ul>\n<li><code>heapTotal</code> and <code>heapUsed</code> refer to V8's memory usage.</li>\n<li><code>external</code> refers to the memory usage of C++ objects bound to JavaScript\nobjects managed by V8.</li>\n<li><code>rss</code>, Resident Set Size, is the amount of space occupied in the main\nmemory device (that is a subset of the total allocated memory) for the\nprocess, including all C++ and JavaScript objects and code.</li>\n<li><code>arrayBuffers</code> refers to memory allocated for <code>ArrayBuffer</code>s and\n<code>SharedArrayBuffer</code>s, including all Node.js <a href=\"buffer.html\"><code>Buffer</code></a>s.\nThis is also included in the <code>external</code> value. When Node.js is used as an\nembedded library, this value may be <code>0</code> because allocations for <code>ArrayBuffer</code>s\nmay not be tracked in that case.</li>\n</ul>\n<p>When using <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads, <code>rss</code> will be a value that is valid for the\nentire process, while the other fields will only refer to the current thread.</p>"
+          "desc": "<p>Returns an object describing the memory usage of the Node.js process measured in\nbytes.</p>\n<pre><code class=\"language-js\">console.log(process.memoryUsage());\n// Prints:\n// {\n//  rss: 4935680,\n//  heapTotal: 1826816,\n//  heapUsed: 650472,\n//  external: 49879,\n//  arrayBuffers: 9386\n// }\n</code></pre>\n<ul>\n<li><code>heapTotal</code> and <code>heapUsed</code> refer to V8's memory usage.</li>\n<li><code>external</code> refers to the memory usage of C++ objects bound to JavaScript\nobjects managed by V8.</li>\n<li><code>rss</code>, Resident Set Size, is the amount of space occupied in the main\nmemory device (that is a subset of the total allocated memory) for the\nprocess, including all C++ and JavaScript objects and code.</li>\n<li><code>arrayBuffers</code> refers to memory allocated for <code>ArrayBuffer</code>s and\n<code>SharedArrayBuffer</code>s, including all Node.js <a href=\"buffer.html\"><code>Buffer</code></a>s.\nThis is also included in the <code>external</code> value. When Node.js is used as an\nembedded library, this value may be <code>0</code> because allocations for <code>ArrayBuffer</code>s\nmay not be tracked in that case.</li>\n</ul>\n<p>When using <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads, <code>rss</code> will be a value that is valid for the\nentire process, while the other fields will only refer to the current thread.</p>\n<p>The <code>process.memoryUsage()</code> method iterates over each page to gather\ninformation about memory usage which might be slow depending on the\nprogram memory allocations.</p>"
+        },
+        {
+          "textRaw": "`process.memoryUsage.rss()`",
+          "type": "method",
+          "name": "rss",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {integer}",
+                "name": "return",
+                "type": "integer"
+              },
+              "params": []
+            }
+          ],
+          "desc": "<p>The <code>process.memoryUsage.rss()</code> method returns an integer representing the\nResident Set Size (RSS) in bytes.</p>\n<p>The Resident Set Size, is the amount of space occupied in the main\nmemory device (that is a subset of the total allocated memory) for the\nprocess, including all C++ and JavaScript objects and code.</p>\n<p>This is the same value as the <code>rss</code> property provided by <code>process.memoryUsage()</code>\nbut <code>process.memoryUsage.rss()</code> is faster.</p>\n<pre><code class=\"language-js\">console.log(process.memoryUsage.rss());\n// 35655680\n</code></pre>"
         },
         {
           "textRaw": "`process.nextTick(callback[, ...args])`",
@@ -64184,7 +70449,16 @@
               ]
             }
           ],
-          "desc": "<p><code>process.nextTick()</code> adds <code>callback</code> to the \"next tick queue\". This queue is\nfully drained after the current operation on the JavaScript stack runs to\ncompletion and before the event loop is allowed to continue. It's possible to\ncreate an infinite loop if one were to recursively call <code>process.nextTick()</code>.\nSee the <a href=\"https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick\">Event Loop</a> guide for more background.</p>\n<pre><code class=\"language-js\">console.log('start');\nprocess.nextTick(() => {\n  console.log('nextTick callback');\n});\nconsole.log('scheduled');\n// Output:\n// start\n// scheduled\n// nextTick callback\n</code></pre>\n<p>This is important when developing APIs in order to give users the opportunity\nto assign event handlers <em>after</em> an object has been constructed but before any\nI/O has occurred:</p>\n<pre><code class=\"language-js\">function MyThing(options) {\n  this.setupOptions(options);\n\n  process.nextTick(() => {\n    this.startDoingStuff();\n  });\n}\n\nconst thing = new MyThing();\nthing.getReadyForStuff();\n\n// thing.startDoingStuff() gets called now, not before.\n</code></pre>\n<p>It is very important for APIs to be either 100% synchronous or 100%\nasynchronous. Consider this example:</p>\n<pre><code class=\"language-js\">// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!\nfunction maybeSync(arg, cb) {\n  if (arg) {\n    cb();\n    return;\n  }\n\n  fs.stat('file', cb);\n}\n</code></pre>\n<p>This API is hazardous because in the following case:</p>\n<pre><code class=\"language-js\">const maybeTrue = Math.random() > 0.5;\n\nmaybeSync(maybeTrue, () => {\n  foo();\n});\n\nbar();\n</code></pre>\n<p>It is not clear whether <code>foo()</code> or <code>bar()</code> will be called first.</p>\n<p>The following approach is much better:</p>\n<pre><code class=\"language-js\">function definitelyAsync(arg, cb) {\n  if (arg) {\n    process.nextTick(cb);\n    return;\n  }\n\n  fs.stat('file', cb);\n}\n</code></pre>"
+          "desc": "<p><code>process.nextTick()</code> adds <code>callback</code> to the \"next tick queue\". This queue is\nfully drained after the current operation on the JavaScript stack runs to\ncompletion and before the event loop is allowed to continue. It's possible to\ncreate an infinite loop if one were to recursively call <code>process.nextTick()</code>.\nSee the <a href=\"https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick\">Event Loop</a> guide for more background.</p>\n<pre><code class=\"language-js\">console.log('start');\nprocess.nextTick(() => {\n  console.log('nextTick callback');\n});\nconsole.log('scheduled');\n// Output:\n// start\n// scheduled\n// nextTick callback\n</code></pre>\n<p>This is important when developing APIs in order to give users the opportunity\nto assign event handlers <em>after</em> an object has been constructed but before any\nI/O has occurred:</p>\n<pre><code class=\"language-js\">function MyThing(options) {\n  this.setupOptions(options);\n\n  process.nextTick(() => {\n    this.startDoingStuff();\n  });\n}\n\nconst thing = new MyThing();\nthing.getReadyForStuff();\n\n// thing.startDoingStuff() gets called now, not before.\n</code></pre>\n<p>It is very important for APIs to be either 100% synchronous or 100%\nasynchronous. Consider this example:</p>\n<pre><code class=\"language-js\">// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!\nfunction maybeSync(arg, cb) {\n  if (arg) {\n    cb();\n    return;\n  }\n\n  fs.stat('file', cb);\n}\n</code></pre>\n<p>This API is hazardous because in the following case:</p>\n<pre><code class=\"language-js\">const maybeTrue = Math.random() > 0.5;\n\nmaybeSync(maybeTrue, () => {\n  foo();\n});\n\nbar();\n</code></pre>\n<p>It is not clear whether <code>foo()</code> or <code>bar()</code> will be called first.</p>\n<p>The following approach is much better:</p>\n<pre><code class=\"language-js\">function definitelyAsync(arg, cb) {\n  if (arg) {\n    process.nextTick(cb);\n    return;\n  }\n\n  fs.stat('file', cb);\n}\n</code></pre>",
+          "modules": [
+            {
+              "textRaw": "When to use `queueMicrotask()` vs. `process.nextTick()`",
+              "name": "when_to_use_`queuemicrotask()`_vs._`process.nexttick()`",
+              "desc": "<p>The <a href=\"globals.html#globals_queuemicrotask_callback\"><code>queueMicrotask()</code></a> API is an alternative to <code>process.nextTick()</code> that\nalso defers execution of a function using the same microtask queue used to\nexecute the then, catch, and finally handlers of resolved promises. Within\nNode.js, every time the \"next tick queue\" is drained, the microtask queue\nis drained immediately after.</p>\n<pre><code class=\"language-js\">Promise.resolve().then(() => console.log(2));\nqueueMicrotask(() => console.log(3));\nprocess.nextTick(() => console.log(1));\n// Output:\n// 1\n// 2\n// 3\n</code></pre>\n<p>For <em>most</em> userland use cases, the <code>queueMicrotask()</code> API provides a portable\nand reliable mechanism for deferring execution that works across multiple\nJavaScript platform environments and should be favored over <code>process.nextTick()</code>.\nIn simple scenarios, <code>queueMicrotask()</code> can be a drop-in replacement for\n<code>process.nextTick()</code>.</p>\n<pre><code class=\"language-js\">console.log('start');\nqueueMicrotask(() => {\n  console.log('microtask callback');\n});\nconsole.log('scheduled');\n// Output:\n// start\n// scheduled\n// microtask callback\n</code></pre>\n<p>One note-worthy difference between the two APIs is that <code>process.nextTick()</code>\nallows specifying additional values that will be passed as arguments to the\ndeferred function when it is called. Achieving the same result with\n<code>queueMicrotask()</code> requires using either a closure or a bound function:</p>\n<pre><code class=\"language-js\">function deferred(a, b) {\n  console.log('microtask', a + b);\n}\n\nconsole.log('start');\nqueueMicrotask(deferred.bind(undefined, 1, 2));\nconsole.log('scheduled');\n// Output:\n// start\n// scheduled\n// microtask 3\n</code></pre>\n<p>There are minor differences in the way errors raised from within the next tick\nqueue and microtask queue are handled. Errors thrown within a queued microtask\ncallback should be handled within the queued callback when possible. If they are\nnot, the <code>process.on('uncaughtException')</code> event handler can be used to capture\nand handle the errors.</p>\n<p>When in doubt, unless the specific capabilities of <code>process.nextTick()</code> are\nneeded, use <code>queueMicrotask()</code>.</p>",
+              "type": "module",
+              "displayName": "When to use `queueMicrotask()` vs. `process.nextTick()`"
+            }
+          ]
         },
         {
           "textRaw": "`process.resourceUsage()`",
@@ -64453,7 +70727,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>process.setgroups()</code> method sets the supplementary group IDs for the\nNode.js process. This is a privileged operation that requires the Node.js\nprocess to have <code>root</code> or the <code>CAP_SETGID</code> capability.</p>\n<p>The <code>groups</code> array can contain numeric group IDs, group names or both.</p>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).\nThis feature is not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>"
+          "desc": "<p>The <code>process.setgroups()</code> method sets the supplementary group IDs for the\nNode.js process. This is a privileged operation that requires the Node.js\nprocess to have <code>root</code> or the <code>CAP_SETGID</code> capability.</p>\n<p>The <code>groups</code> array can contain numeric group IDs, group names, or both.</p>\n<pre><code class=\"language-js\">if (process.getgroups &#x26;&#x26; process.setgroups) {\n  try {\n    process.setgroups([501]);\n    console.log(process.getgroups()); // new groups\n  } catch (err) {\n    console.log(`Failed to set groups: ${err}`);\n  }\n}\n</code></pre>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).\nThis feature is not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>"
         },
         {
           "textRaw": "`process.setuid(id)`",
@@ -64478,6 +70752,31 @@
           ],
           "desc": "<p>The <code>process.setuid(id)</code> method sets the user identity of the process. (See\n<a href=\"http://man7.org/linux/man-pages/man2/setuid.2.html\"><code>setuid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a username string.\nIf a username is specified, the method blocks while resolving the associated\nnumeric ID.</p>\n<pre><code class=\"language-js\">if (process.getuid &#x26;&#x26; process.setuid) {\n  console.log(`Current uid: ${process.getuid()}`);\n  try {\n    process.setuid(501);\n    console.log(`New uid: ${process.getuid()}`);\n  } catch (err) {\n    console.log(`Failed to set uid: ${err}`);\n  }\n}\n</code></pre>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).\nThis feature is not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>"
         },
+        {
+          "textRaw": "`process.setSourceMapsEnabled(val)`",
+          "type": "method",
+          "name": "setSourceMapsEnabled",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`val` {boolean}",
+                  "name": "val",
+                  "type": "boolean"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>This function enables or disables the <a href=\"https://sourcemaps.info/spec.html\">Source Map v3</a> support for\nstack traces.</p>\n<p>It provides same features as launching Node.js process with commandline options\n<code>--enable-source-maps</code>.</p>\n<p>Only source maps in JavaScript files that are loaded after source maps has been\nenabled will be parsed and loaded.</p>"
+        },
         {
           "textRaw": "`process.setUncaughtExceptionCaptureCallback(fn)`",
           "type": "method",
@@ -64499,7 +70798,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>process.setUncaughtExceptionCaptureCallback()</code> function sets a function\nthat will be invoked when an uncaught exception occurs, which will receive the\nexception value itself as its first argument.</p>\n<p>If such a function is set, the <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event will\nnot be emitted. If <code>--abort-on-uncaught-exception</code> was passed from the\ncommand line or set through <a href=\"v8.html#v8_v8_setflagsfromstring_flags\"><code>v8.setFlagsFromString()</code></a>, the process will\nnot abort.</p>\n<p>To unset the capture function,\n<code>process.setUncaughtExceptionCaptureCallback(null)</code> may be used. Calling this\nmethod with a non-<code>null</code> argument while another capture function is set will\nthrow an error.</p>\n<p>Using this function is mutually exclusive with using the deprecated\n<a href=\"domain.html\"><code>domain</code></a> built-in module.</p>"
+          "desc": "<p>The <code>process.setUncaughtExceptionCaptureCallback()</code> function sets a function\nthat will be invoked when an uncaught exception occurs, which will receive the\nexception value itself as its first argument.</p>\n<p>If such a function is set, the <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event will\nnot be emitted. If <code>--abort-on-uncaught-exception</code> was passed from the\ncommand line or set through <a href=\"v8.html#v8_v8_setflagsfromstring_flags\"><code>v8.setFlagsFromString()</code></a>, the process will\nnot abort. Actions configured to take place on exceptions such as report\ngenerations will be affected too</p>\n<p>To unset the capture function,\n<code>process.setUncaughtExceptionCaptureCallback(null)</code> may be used. Calling this\nmethod with a non-<code>null</code> argument while another capture function is set will\nthrow an error.</p>\n<p>Using this function is mutually exclusive with using the deprecated\n<a href=\"domain.html\"><code>domain</code></a> built-in module.</p>"
         },
         {
           "textRaw": "`process.umask()`",
@@ -64512,8 +70811,8 @@
             "changes": [
               {
                 "version": [
-                  "v12.19.0",
-                  "v14.0.0"
+                  "v14.0.0",
+                  "v12.19.0"
                 ],
                 "pr-url": "https://github.com/nodejs/node/pull/32499",
                 "description": "Calling `process.umask()` with no arguments is deprecated."
@@ -64610,7 +70909,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>process.argv</code> property returns an array containing the command line\narguments passed when the Node.js process was launched. The first element will\nbe <a href=\"process.html#process_process_execpath\"><code>process.execPath</code></a>. See <code>process.argv0</code> if access to the original value\nof <code>argv[0]</code> is needed. The second element will be the path to the JavaScript\nfile being executed. The remaining elements will be any additional command line\narguments.</p>\n<p>For example, assuming the following script for <code>process-args.js</code>:</p>\n<pre><code class=\"language-js\">// print process.argv\nprocess.argv.forEach((val, index) => {\n  console.log(`${index}: ${val}`);\n});\n</code></pre>\n<p>Launching the Node.js process as:</p>\n<pre><code class=\"language-console\">$ node process-args.js one two=three four\n</code></pre>\n<p>Would generate the output:</p>\n<pre><code class=\"language-text\">0: /usr/local/bin/node\n1: /Users/mjr/work/node/process-args.js\n2: one\n3: two=three\n4: four\n</code></pre>"
+          "desc": "<p>The <code>process.argv</code> property returns an array containing the command-line\narguments passed when the Node.js process was launched. The first element will\nbe <a href=\"process.html#process_process_execpath\"><code>process.execPath</code></a>. See <code>process.argv0</code> if access to the original value\nof <code>argv[0]</code> is needed. The second element will be the path to the JavaScript\nfile being executed. The remaining elements will be any additional command-line\narguments.</p>\n<p>For example, assuming the following script for <code>process-args.js</code>:</p>\n<pre><code class=\"language-js\">// print process.argv\nprocess.argv.forEach((val, index) => {\n  console.log(`${index}: ${val}`);\n});\n</code></pre>\n<p>Launching the Node.js process as:</p>\n<pre><code class=\"language-console\">$ node process-args.js one two=three four\n</code></pre>\n<p>Would generate the output:</p>\n<pre><code class=\"language-text\">0: /usr/local/bin/node\n1: /Users/mjr/work/node/process-args.js\n2: one\n3: two=three\n4: four\n</code></pre>"
         },
         {
           "textRaw": "`argv0` {string}",
@@ -64632,9 +70931,51 @@
             "added": [
               "v7.1.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/30165",
+                "description": "The object no longer accidentally exposes native C++ bindings."
+              }
+            ]
           },
-          "desc": "<p>If the Node.js process was spawned with an IPC channel (see the\n<a href=\"child_process.html\">Child Process</a> documentation), the <code>process.channel</code>\nproperty is a reference to the IPC channel. If no IPC channel exists, this\nproperty is <code>undefined</code>.</p>"
+          "desc": "<p>If the Node.js process was spawned with an IPC channel (see the\n<a href=\"child_process.html\">Child Process</a> documentation), the <code>process.channel</code>\nproperty is a reference to the IPC channel. If no IPC channel exists, this\nproperty is <code>undefined</code>.</p>",
+          "methods": [
+            {
+              "textRaw": "`process.channel.ref()`",
+              "type": "method",
+              "name": "ref",
+              "meta": {
+                "added": [
+                  "v7.1.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>This method makes the IPC channel keep the event loop of the process\nrunning if <code>.unref()</code> has been called before.</p>\n<p>Typically, this is managed through the number of <code>'disconnect'</code> and <code>'message'</code>\nlisteners on the <code>process</code> object. However, this method can be used to\nexplicitly request a specific behavior.</p>"
+            },
+            {
+              "textRaw": "`process.channel.unref()`",
+              "type": "method",
+              "name": "unref",
+              "meta": {
+                "added": [
+                  "v7.1.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>This method makes the IPC channel not keep the event loop of the process\nrunning, and lets it finish even while the channel is open.</p>\n<p>Typically, this is managed through the number of <code>'disconnect'</code> and <code>'message'</code>\nlisteners on the <code>process</code> object. However, this method can be used to\nexplicitly request a specific behavior.</p>"
+            }
+          ]
         },
         {
           "textRaw": "`config` {Object}",
@@ -64705,7 +71046,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>process.execArgv</code> property returns the set of Node.js-specific command-line\noptions passed when the Node.js process was launched. These options do not\nappear in the array returned by the <a href=\"process.html#process_process_argv\"><code>process.argv</code></a> property, and do not\ninclude the Node.js executable, the name of the script, or any options following\nthe script name. These options are useful in order to spawn child processes with\nthe same execution environment as the parent.</p>\n<pre><code class=\"language-console\">$ node --harmony script.js --version\n</code></pre>\n<p>Results in <code>process.execArgv</code>:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">['--harmony']\n</code></pre>\n<p>And <code>process.argv</code>:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">['/usr/local/bin/node', 'script.js', '--version']\n</code></pre>"
+          "desc": "<p>The <code>process.execArgv</code> property returns the set of Node.js-specific command-line\noptions passed when the Node.js process was launched. These options do not\nappear in the array returned by the <a href=\"process.html#process_process_argv\"><code>process.argv</code></a> property, and do not\ninclude the Node.js executable, the name of the script, or any options following\nthe script name. These options are useful in order to spawn child processes with\nthe same execution environment as the parent.</p>\n<pre><code class=\"language-console\">$ node --harmony script.js --version\n</code></pre>\n<p>Results in <code>process.execArgv</code>:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">['--harmony']\n</code></pre>\n<p>And <code>process.argv</code>:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">['/usr/local/bin/node', 'script.js', '--version']\n</code></pre>\n<p>Refer to <a href=\"worker_threads.html#worker_threads_new_worker_filename_options\"><code>Worker</code> constructor</a> for the detailed behavior of worker\nthreads with this property.</p>"
         },
         {
           "textRaw": "`execPath` {string}",
@@ -64739,8 +71080,13 @@
             "added": [
               "v0.1.17"
             ],
+            "deprecated": [
+              "v14.0.0"
+            ],
             "changes": []
           },
+          "stability": 0,
+          "stabilityText": "Deprecated: Use [`require.main`][] instead.",
           "desc": "<p>The <code>process.mainModule</code> property provides an alternative way of retrieving\n<a href=\"modules.html#modules_accessing_the_main_module\"><code>require.main</code></a>. The difference is that if the main module changes at\nruntime, <a href=\"modules.html#modules_accessing_the_main_module\"><code>require.main</code></a> may still refer to the original main module in\nmodules that were required before the change occurred. Generally, it's\nsafe to assume that the two refer to the same module.</p>\n<p>As with <a href=\"modules.html#modules_accessing_the_main_module\"><code>require.main</code></a>, <code>process.mainModule</code> will be <code>undefined</code> if there\nis no entry script.</p>"
         },
         {
@@ -64777,7 +71123,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>process.platform</code> property returns a string identifying the operating\nsystem platform on which the Node.js process is running.</p>\n<p>Currently possible values are:</p>\n<ul>\n<li><code>'aix'</code></li>\n<li><code>'darwin'</code></li>\n<li><code>'freebsd'</code></li>\n<li><code>'linux'</code></li>\n<li><code>'openbsd'</code></li>\n<li><code>'sunos'</code></li>\n<li><code>'win32'</code></li>\n</ul>\n<pre><code class=\"language-js\">console.log(`This platform is ${process.platform}`);\n</code></pre>\n<p>The value <code>'android'</code> may also be returned if the Node.js is built on the\nAndroid operating system. However, Android support in Node.js\n<a href=\"https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os\">is experimental</a>.</p>"
+          "desc": "<p>The <code>process.platform</code> property returns a string identifying the operating\nsystem platform on which the Node.js process is running.</p>\n<p>Currently possible values are:</p>\n<ul>\n<li><code>'aix'</code></li>\n<li><code>'darwin'</code></li>\n<li><code>'freebsd'</code></li>\n<li><code>'linux'</code></li>\n<li><code>'openbsd'</code></li>\n<li><code>'sunos'</code></li>\n<li><code>'win32'</code></li>\n</ul>\n<pre><code class=\"language-js\">console.log(`This platform is ${process.platform}`);\n</code></pre>\n<p>The value <code>'android'</code> may also be returned if the Node.js is built on the\nAndroid operating system. However, Android support in Node.js\n<a href=\"https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os\">is experimental</a>.</p>"
         },
         {
           "textRaw": "`ppid` {integer}",
@@ -64809,7 +71155,7 @@
               }
             ]
           },
-          "desc": "<p>The <code>process.release</code> property returns an <code>Object</code> containing metadata related\nto the current release, including URLs for the source tarball and headers-only\ntarball.</p>\n<p><code>process.release</code> contains the following properties:</p>\n<ul>\n<li><code>name</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A value that will always be <code>'node'</code> for Node.js. For\nlegacy io.js releases, this will be <code>'io.js'</code>.</li>\n<li><code>sourceUrl</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing\nthe source code of the current release.</li>\n<li><code>headersUrl</code><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing\nonly the source header files for the current release. This file is\nsignificantly smaller than the full source file and can be used for compiling\nNode.js native add-ons.</li>\n<li><code>libUrl</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>node.lib</code></em> file matching the\narchitecture and version of the current release. This file is used for\ncompiling Node.js native add-ons. <em>This property is only present on Windows\nbuilds of Node.js and will be missing on all other platforms.</em></li>\n<li><code>lts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> a string label identifying the <a href=\"https://github.com/nodejs/Release\">LTS</a> label for this release.\nThis property only exists for LTS releases and is <code>undefined</code> for all other\nrelease types, including <em>Current</em> releases.\nValid values include the LTS Release Codenames (including those\nthat are no longer supported). A non-exhaustive example of\nthese codenames includes:\n<ul>\n<li><code>'Dubnium'</code> for the 10.x LTS line beginning with 10.13.0.</li>\n<li><code>'Erbium'</code> for the 12.x LTS line beginning with 12.13.0.\nFor other LTS Release Codenames, see <a href=\"https://github.com/nodejs/node/blob/master/doc/changelogs/CHANGELOG_ARCHIVE.md\">Node.js Changelog Archive</a></li>\n</ul>\n</li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  name: 'node',\n  lts: 'Erbium',\n  sourceUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1.tar.gz',\n  headersUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1-headers.tar.gz',\n  libUrl: 'https://nodejs.org/download/release/v12.18.1/win-x64/node.lib'\n}\n</code></pre>\n<p>In custom builds from non-release versions of the source tree, only the\n<code>name</code> property may be present. The additional properties should not be\nrelied upon to exist.</p>"
+          "desc": "<p>The <code>process.release</code> property returns an <code>Object</code> containing metadata related\nto the current release, including URLs for the source tarball and headers-only\ntarball.</p>\n<p><code>process.release</code> contains the following properties:</p>\n<ul>\n<li><code>name</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A value that will always be <code>'node'</code>.</li>\n<li><code>sourceUrl</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing\nthe source code of the current release.</li>\n<li><code>headersUrl</code><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing\nonly the source header files for the current release. This file is\nsignificantly smaller than the full source file and can be used for compiling\nNode.js native add-ons.</li>\n<li><code>libUrl</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>node.lib</code></em> file matching the\narchitecture and version of the current release. This file is used for\ncompiling Node.js native add-ons. <em>This property is only present on Windows\nbuilds of Node.js and will be missing on all other platforms.</em></li>\n<li><code>lts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> a string label identifying the <a href=\"https://github.com/nodejs/Release\">LTS</a> label for this release.\nThis property only exists for LTS releases and is <code>undefined</code> for all other\nrelease types, including <em>Current</em> releases.\nValid values include the LTS Release code names (including those\nthat are no longer supported).\n<ul>\n<li><code>'Dubnium'</code> for the 10.x LTS line beginning with 10.13.0.</li>\n<li><code>'Erbium'</code> for the 12.x LTS line beginning with 12.13.0.</li>\n</ul>\nFor other LTS Release code names, see <a href=\"https://github.com/nodejs/node/blob/HEAD/doc/changelogs/CHANGELOG_ARCHIVE.md\">Node.js Changelog Archive</a></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  name: 'node',\n  lts: 'Erbium',\n  sourceUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1.tar.gz',\n  headersUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1-headers.tar.gz',\n  libUrl: 'https://nodejs.org/download/release/v12.18.1/win-x64/node.lib'\n}\n</code></pre>\n<p>In custom builds from non-release versions of the source tree, only the\n<code>name</code> property may be present. The additional properties should not be\nrelied upon to exist.</p>"
         },
         {
           "textRaw": "`report` {Object}",
@@ -64821,7 +71167,7 @@
             ],
             "changes": [
               {
-                "version": "v12.17.0",
+                "version": "v13.12.0",
                 "pr-url": "https://github.com/nodejs/node/pull/32242",
                 "description": "This API is no longer experimental."
               }
@@ -64835,7 +71181,7 @@
               "name": "compact",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.12.0"
                 ],
                 "changes": []
               },
@@ -64851,7 +71197,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -64869,7 +71215,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -64885,10 +71231,16 @@
                 "added": [
                   "v11.12.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v14.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/35654",
+                    "description": "This API is no longer experimental."
+                  }
+                ]
               },
-              "stability": 1,
-              "stabilityText": "Experimental",
               "desc": "<p>If <code>true</code>, a diagnostic report is generated on fatal errors, such as out of\nmemory errors or failed C++ assertions.</p>\n<pre><code class=\"language-js\">console.log(`Report on fatal error: ${process.report.reportOnFatalError}`);\n</code></pre>"
             },
             {
@@ -64901,7 +71253,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -64919,7 +71271,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -64937,7 +71289,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -64957,7 +71309,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -64980,7 +71332,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a JavaScript Object representation of a diagnostic report for the\nrunning process. The report's JavaScript stack trace is taken from <code>err</code>, if\npresent.</p>\n<pre><code class=\"language-js\">const data = process.report.getReport();\nconsole.log(data.header.nodeJsVersion);\n\n// Similar to process.report.writeReport()\nconst fs = require('fs');\nfs.writeFileSync(util.inspect(data), 'my-report.log', 'utf8');\n</code></pre>\n<p>Additional documentation is available in the <a href=\"report.html\">report documentation</a>.</p>"
+              "desc": "<p>Returns a JavaScript Object representation of a diagnostic report for the\nrunning process. The report's JavaScript stack trace is taken from <code>err</code>, if\npresent.</p>\n<pre><code class=\"language-js\">const data = process.report.getReport();\nconsole.log(data.header.nodejsVersion);\n\n// Similar to process.report.writeReport()\nconst fs = require('fs');\nfs.writeFileSync('my-report.log', util.inspect(data), 'utf8');\n</code></pre>\n<p>Additional documentation is available in the <a href=\"report.html\">report documentation</a>.</p>"
             },
             {
               "textRaw": "`process.report.writeReport([filename][, err])`",
@@ -64992,7 +71344,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -65071,7 +71423,7 @@
             {
               "textRaw": "A note on process I/O",
               "name": "a_note_on_process_i/o",
-              "desc": "<p><code>process.stdout</code> and <code>process.stderr</code> differ from other Node.js streams in\nimportant ways:</p>\n<ol>\n<li>They are used internally by <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> and <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a>,\nrespectively.</li>\n<li>Writes may be synchronous depending on what the stream is connected to\nand whether the system is Windows or POSIX:\n<ul>\n<li>Files: <em>synchronous</em> on Windows and POSIX</li>\n<li>TTYs (Terminals): <em>asynchronous</em> on Windows, <em>synchronous</em> on POSIX</li>\n<li>Pipes (and sockets): <em>synchronous</em> on Windows, <em>asynchronous</em> on POSIX</li>\n</ul>\n</li>\n</ol>\n<p>These behaviors are partly for historical reasons, as changing them would\ncreate backward incompatibility, but they are also expected by some users.</p>\n<p>Synchronous writes avoid problems such as output written with <code>console.log()</code> or\n<code>console.error()</code> being unexpectedly interleaved, or not written at all if\n<code>process.exit()</code> is called before an asynchronous write completes. See\n<a href=\"process.html#process_process_exit_code\"><code>process.exit()</code></a> for more information.</p>\n<p><strong><em>Warning</em></strong>: Synchronous writes block the event loop until the write has\ncompleted. This can be near instantaneous in the case of output to a file, but\nunder high system load, pipes that are not being read at the receiving end, or\nwith slow terminals or file systems, its possible for the event loop to be\nblocked often enough and long enough to have severe negative performance\nimpacts. This may not be a problem when writing to an interactive terminal\nsession, but consider this particularly careful when doing production logging to\nthe process output streams.</p>\n<p>To check if a stream is connected to a <a href=\"tty.html#tty_tty\">TTY</a> context, check the <code>isTTY</code>\nproperty.</p>\n<p>For instance:</p>\n<pre><code class=\"language-console\">$ node -p \"Boolean(process.stdin.isTTY)\"\ntrue\n$ echo \"foo\" | node -p \"Boolean(process.stdin.isTTY)\"\nfalse\n$ node -p \"Boolean(process.stdout.isTTY)\"\ntrue\n$ node -p \"Boolean(process.stdout.isTTY)\" | cat\nfalse\n</code></pre>\n<p>See the <a href=\"tty.html#tty_tty\">TTY</a> documentation for more information.</p>",
+              "desc": "<p><code>process.stdout</code> and <code>process.stderr</code> differ from other Node.js streams in\nimportant ways:</p>\n<ol>\n<li>They are used internally by <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> and <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a>,\nrespectively.</li>\n<li>Writes may be synchronous depending on what the stream is connected to\nand whether the system is Windows or POSIX:\n<ul>\n<li>Files: <em>synchronous</em> on Windows and POSIX</li>\n<li>TTYs (Terminals): <em>asynchronous</em> on Windows, <em>synchronous</em> on POSIX</li>\n<li>Pipes (and sockets): <em>synchronous</em> on Windows, <em>asynchronous</em> on POSIX</li>\n</ul>\n</li>\n</ol>\n<p>These behaviors are partly for historical reasons, as changing them would\ncreate backward incompatibility, but they are also expected by some users.</p>\n<p>Synchronous writes avoid problems such as output written with <code>console.log()</code> or\n<code>console.error()</code> being unexpectedly interleaved, or not written at all if\n<code>process.exit()</code> is called before an asynchronous write completes. See\n<a href=\"process.html#process_process_exit_code\"><code>process.exit()</code></a> for more information.</p>\n<p><em><strong>Warning</strong></em>: Synchronous writes block the event loop until the write has\ncompleted. This can be near instantaneous in the case of output to a file, but\nunder high system load, pipes that are not being read at the receiving end, or\nwith slow terminals or file systems, its possible for the event loop to be\nblocked often enough and long enough to have severe negative performance\nimpacts. This may not be a problem when writing to an interactive terminal\nsession, but consider this particularly careful when doing production logging to\nthe process output streams.</p>\n<p>To check if a stream is connected to a <a href=\"tty.html#tty_tty\">TTY</a> context, check the <code>isTTY</code>\nproperty.</p>\n<p>For instance:</p>\n<pre><code class=\"language-console\">$ node -p \"Boolean(process.stdin.isTTY)\"\ntrue\n$ echo \"foo\" | node -p \"Boolean(process.stdin.isTTY)\"\nfalse\n$ node -p \"Boolean(process.stdout.isTTY)\"\ntrue\n$ node -p \"Boolean(process.stdout.isTTY)\" | cat\nfalse\n</code></pre>\n<p>See the <a href=\"tty.html#tty_tty\">TTY</a> documentation for more information.</p>",
               "type": "module",
               "displayName": "A note on process I/O"
             }
@@ -65099,7 +71451,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>process.title</code> property returns the current process title (i.e. returns\nthe current value of <code>ps</code>). Assigning a new value to <code>process.title</code> modifies\nthe current value of <code>ps</code>.</p>\n<p>When a new value is assigned, different platforms will impose different maximum\nlength restrictions on the title. Usually such restrictions are quite limited.\nFor instance, on Linux and macOS, <code>process.title</code> is limited to the size of the\nbinary name plus the length of the command line arguments because setting the\n<code>process.title</code> overwrites the <code>argv</code> memory of the process. Node.js v0.8\nallowed for longer process title strings by also overwriting the <code>environ</code>\nmemory but that was potentially insecure and confusing in some (rather obscure)\ncases.</p>\n<p>Assigning a value to <code>process.title</code> might not result in an accurate label\nwithin process manager applications such as macOS Activity Monitor or Windows\nServices Manager.</p>"
+          "desc": "<p>The <code>process.title</code> property returns the current process title (i.e. returns\nthe current value of <code>ps</code>). Assigning a new value to <code>process.title</code> modifies\nthe current value of <code>ps</code>.</p>\n<p>When a new value is assigned, different platforms will impose different maximum\nlength restrictions on the title. Usually such restrictions are quite limited.\nFor instance, on Linux and macOS, <code>process.title</code> is limited to the size of the\nbinary name plus the length of the command-line arguments because setting the\n<code>process.title</code> overwrites the <code>argv</code> memory of the process. Node.js v0.8\nallowed for longer process title strings by also overwriting the <code>environ</code>\nmemory but that was potentially insecure and confusing in some (rather obscure)\ncases.</p>\n<p>Assigning a value to <code>process.title</code> might not result in an accurate label\nwithin process manager applications such as macOS Activity Monitor or Windows\nServices Manager.</p>"
         },
         {
           "textRaw": "`traceDeprecation` {boolean}",
@@ -65134,21 +71486,22 @@
               "v0.2.0"
             ],
             "changes": [
-              {
-                "version": "v4.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3102",
-                "description": "The `icu` property is now supported."
-              },
               {
                 "version": "v9.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/15785",
                 "description": "The `v8` property now includes a Node.js specific suffix."
+              },
+              {
+                "version": "v4.2.0",
+                "pr-url": "https://github.com/nodejs/node/pull/3102",
+                "description": "The `icu` property is now supported."
               }
             ]
           },
-          "desc": "<p>The <code>process.versions</code> property returns an object listing the version strings of\nNode.js and its dependencies. <code>process.versions.modules</code> indicates the current\nABI version, which is increased whenever a C++ API changes. Node.js will refuse\nto load modules that were compiled against a different module ABI version.</p>\n<pre><code class=\"language-js\">console.log(process.versions);\n</code></pre>\n<p>Will generate an object similar to:</p>\n<pre><code class=\"language-console\">{ node: '11.13.0',\n  v8: '7.0.276.38-node.18',\n  uv: '1.27.0',\n  zlib: '1.2.11',\n  brotli: '1.0.7',\n  ares: '1.15.0',\n  modules: '67',\n  nghttp2: '1.34.0',\n  napi: '4',\n  llhttp: '1.1.1',\n  http_parser: '2.8.0',\n  openssl: '1.1.1b',\n  cldr: '34.0',\n  icu: '63.1',\n  tz: '2018e',\n  unicode: '11.0' }\n</code></pre>"
+          "desc": "<p>The <code>process.versions</code> property returns an object listing the version strings of\nNode.js and its dependencies. <code>process.versions.modules</code> indicates the current\nABI version, which is increased whenever a C++ API changes. Node.js will refuse\nto load modules that were compiled against a different module ABI version.</p>\n<pre><code class=\"language-js\">console.log(process.versions);\n</code></pre>\n<p>Will generate an object similar to:</p>\n<pre><code class=\"language-console\">{ node: '11.13.0',\n  v8: '7.0.276.38-node.18',\n  uv: '1.27.0',\n  zlib: '1.2.11',\n  brotli: '1.0.7',\n  ares: '1.15.0',\n  modules: '67',\n  nghttp2: '1.34.0',\n  napi: '4',\n  llhttp: '1.1.1',\n  openssl: '1.1.1b',\n  cldr: '34.0',\n  icu: '63.1',\n  tz: '2018e',\n  unicode: '11.0' }\n</code></pre>"
         }
-      ]
+      ],
+      "source": "doc/api/process.md"
     }
   ],
   "methods": [
@@ -65161,7 +71514,8 @@
           "params": []
         }
       ],
-      "desc": "<p>This variable may appear to be global but is not. See <a href=\"modules.html#modules_require_id\"><code>require()</code></a>.</p>"
+      "desc": "<p>This variable may appear to be global but is not. See <a href=\"modules.html#modules_require_id\"><code>require()</code></a>.</p>",
+      "source": "doc/api/globals.md"
     }
   ]
 }
diff --git a/doc/api/assert.html b/doc/api/assert.html
index 1b54df97af1c7e6f911b0f52ffd18cb9742d8f85..f32918a4995a171f43b96db11acaa7213e8ae50a 100644
--- a/doc/api/assert.html
+++ b/doc/api/assert.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Assert | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Assert | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert active">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="assert" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/assert.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/assert.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/assert.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/assert.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/assert.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/assert.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/assert.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/assert.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/assert.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#assert_assert">Assert</a></span>
 <ul>
 <li><a href="#assert_strict_assertion_mode">Strict assertion mode</a></li>
@@ -138,6 +151,7 @@
 </li>
 <li><span class="stability_1"><a href="#assert_class_assert_calltracker">Class: <code>assert.CallTracker</code></a></span>
 <ul>
+<li><a href="#assert_new_assert_calltracker"><code>new assert.CallTracker()</code></a></li>
 <li><a href="#assert_tracker_calls_fn_exact"><code>tracker.calls([fn][, exact])</code></a></li>
 <li><a href="#assert_tracker_report"><code>tracker.report()</code></a></li>
 <li><a href="#assert_tracker_verify"><code>tracker.verify()</code></a></li>
@@ -172,22 +186,21 @@
 <li><a href="#assert_assert_throws_fn_error_message"><code>assert.throws(fn[, error][, message])</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Assert<span><a class="mark" href="#assert_assert" id="assert_assert">#</a></span></h1>
+        <h2>Assert<span><a class="mark" href="#assert_assert" id="assert_assert">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/assert.js">lib/assert.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/assert.js">lib/assert.js</a></p>
 <p>The <code>assert</code> module provides a set of assertion functions for verifying
 invariants.</p>
-<h2>Strict assertion mode<span><a class="mark" href="#assert_strict_assertion_mode" id="assert_strict_assertion_mode">#</a></span></h2>
+<section><h3>Strict assertion mode<span><a class="mark" href="#assert_strict_assertion_mode" id="assert_strict_assertion_mode">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.2</td>
+<tr><td>v13.9.0, v12.16.2</td>
 <td><p>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".</p></td></tr>
 <tr><td>v9.9.0</td>
 <td><p>Added error diffs to the strict assertion mode.</p></td></tr>
@@ -204,11 +217,11 @@ strict methods. For example, <a href="#assert_assert_deepequal_actual_expected_m
 <p>In strict assertion mode, error messages for objects display a diff. In legacy
 assertion mode, error messages for objects display the objects, often truncated.</p>
 <p>To use strict assertion mode:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;</code></pre>
 <p>Example error diff:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.deepEqual([[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]], <span class="hljs-number">4</span>, <span class="hljs-number">5</span>], [[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'3'</span>]], <span class="hljs-number">4</span>, <span class="hljs-number">5</span>]);
+assert.<span class="hljs-title function_">deepEqual</span>([[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]], <span class="hljs-number">4</span>, <span class="hljs-number">5</span>], [[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'3'</span>]], <span class="hljs-number">4</span>, <span class="hljs-number">5</span>]);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected ... Lines skipped</span>
 <span class="hljs-comment">//</span>
@@ -226,7 +239,7 @@ assert.deepEqual([[[<span class="hljs-number">1</span>, <span class="hljs-number
 environment variables. This will also deactivate the colors in the REPL. For
 more on color support in terminal environments, read the tty
 <a href="tty.html#tty_writestream_getcolordepth_env">getColorDepth()</a> documentation.</p>
-<h2>Legacy assertion mode<span><a class="mark" href="#assert_legacy_assertion_mode" id="assert_legacy_assertion_mode">#</a></span></h2>
+</section><section><h3>Legacy assertion mode<span><a class="mark" href="#assert_legacy_assertion_mode" id="assert_legacy_assertion_mode">#</a></span></h3>
 <p>Legacy assertion mode uses the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> in:</p>
 <ul>
 <li><a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a></li>
@@ -241,14 +254,14 @@ more on color support in terminal environments, read the tty
 especially true for <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a>, where the comparison rules are
 lax:</p>
 <pre><code class="language-js"><span class="hljs-comment">// WARNING: This does not throw an AssertionError!</span>
-assert.deepEqual(<span class="hljs-regexp">/a/gi</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>());</code></pre>
-<h2>Class: assert.AssertionError<a class="srclink" href="https://github.com/nodejs/node/blob/360a294f1f19cb8ccc9505d44a2e9efff414a5c7/lib/assert.js#L147">[src]</a><span><a class="mark" href="#assert_class_assert_assertionerror" id="assert_class_assert_assertionerror">#</a></span></h2>
+assert.<span class="hljs-title function_">deepEqual</span>(<span class="hljs-regexp">/a/gi</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>());</code></pre>
+</section><section><h3>Class: assert.AssertionError<a class="srclink" href="https://github.com/nodejs/node/blob/92df3d654b366aa115fb672756cb051d480d8acc/lib/assert.js#L172">[src]</a><span><a class="mark" href="#assert_class_assert_assertionerror" id="assert_class_assert_assertionerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="errors.html#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
 <p>Indicates the failure of an assertion. All errors thrown by the <code>assert</code> module
 will be instances of the <code>AssertionError</code> class.</p>
-<h3><code>new assert.AssertionError(options)</code><span><a class="mark" href="#assert_new_assert_assertionerror_options" id="assert_new_assert_assertionerror_options">#</a></span></h3>
+<h4><code>new assert.AssertionError(options)</code><span><a class="mark" href="#assert_new_assert_assertionerror_options" id="assert_new_assert_assertionerror_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.21</span>
 </div>
@@ -281,7 +294,7 @@ assertion error.</li>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Generate an AssertionError to compare the error message later:</span>
-<span class="hljs-keyword">const</span> { message } = <span class="hljs-keyword">new</span> assert.AssertionError({
+<span class="hljs-keyword">const</span> { message } = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">AssertionError</span>({
   <span class="hljs-attr">actual</span>: <span class="hljs-number">1</span>,
   <span class="hljs-attr">expected</span>: <span class="hljs-number">2</span>,
   <span class="hljs-attr">operator</span>: <span class="hljs-string">'strictEqual'</span>
@@ -289,26 +302,26 @@ assertion error.</li>
 
 <span class="hljs-comment">// Verify error output:</span>
 <span class="hljs-keyword">try</span> {
-  assert.strictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  assert(err <span class="hljs-keyword">instanceof</span> assert.AssertionError);
-  assert.strictEqual(err.message, message);
-  assert.strictEqual(err.name, <span class="hljs-string">'AssertionError'</span>);
-  assert.strictEqual(err.actual, <span class="hljs-number">1</span>);
-  assert.strictEqual(err.expected, <span class="hljs-number">2</span>);
-  assert.strictEqual(err.code, <span class="hljs-string">'ERR_ASSERTION'</span>);
-  assert.strictEqual(err.operator, <span class="hljs-string">'strictEqual'</span>);
-  assert.strictEqual(err.generatedMessage, <span class="hljs-literal">true</span>);
+  <span class="hljs-title function_">assert</span>(err <span class="hljs-keyword">instanceof</span> assert.<span class="hljs-property">AssertionError</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">message</span>, message);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">name</span>, <span class="hljs-string">'AssertionError'</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">actual</span>, <span class="hljs-number">1</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">expected</span>, <span class="hljs-number">2</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">code</span>, <span class="hljs-string">'ERR_ASSERTION'</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">operator</span>, <span class="hljs-string">'strictEqual'</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">generatedMessage</span>, <span class="hljs-literal">true</span>);
 }</code></pre>
-<h2>Class: <code>assert.CallTracker</code><span><a class="mark" href="#assert_class_assert_calltracker" id="assert_class_assert_calltracker">#</a></span></h2>
+</section><section><h3>Class: <code>assert.CallTracker</code><span><a class="mark" href="#assert_class_assert_calltracker" id="assert_class_assert_calltracker">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>This feature is currently experimental and behavior might still change.</p>
-<p>### <code>new assert.CallTracker()</code></p>
+<h4><code>new assert.CallTracker()</code><span><a class="mark" href="#assert_new_assert_calltracker" id="assert_new_assert_calltracker">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <p>Creates a new <a href="#assert_class_assert_calltracker"><code>CallTracker</code></a> object which can be used to track if functions
 were called a specific number of times. The <code>tracker.verify()</code> must be called
@@ -316,23 +329,23 @@ for the verification to take place. The usual pattern would be to call it in a
 <a href="process.html#process_event_exit"><code>process.on('exit')</code></a> handler.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
-<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.CallTracker();
+<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">CallTracker</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">func</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">func</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// callsfunc() must be called exactly 1 time before tracker.verify().</span>
-<span class="hljs-keyword">const</span> callsfunc = tracker.calls(func, <span class="hljs-number">1</span>);
+<span class="hljs-keyword">const</span> callsfunc = tracker.<span class="hljs-title function_">calls</span>(func, <span class="hljs-number">1</span>);
 
-callsfunc();
+<span class="hljs-title function_">callsfunc</span>();
 
 <span class="hljs-comment">// Calls tracker.verify() and verifies if all tracker.calls() functions have</span>
 <span class="hljs-comment">// been called exact times.</span>
-process.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-  tracker.verify();
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+  tracker.<span class="hljs-title function_">verify</span>();
 });</code></pre>
-<h3><code>tracker.calls([fn][, exact])</code><span><a class="mark" href="#assert_tracker_calls_fn_exact" id="assert_tracker_calls_fn_exact">#</a></span></h3>
+<h4><code>tracker.calls([fn][, exact])</code><span><a class="mark" href="#assert_tracker_calls_fn_exact" id="assert_tracker_calls_fn_exact">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> <strong>Default</strong> A no-op function.</li>
@@ -346,16 +359,16 @@ error.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Creates call tracker.</span>
-<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.CallTracker();
+<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">CallTracker</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">func</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">func</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// Returns a function that wraps func() that must be called exact times</span>
 <span class="hljs-comment">// before tracker.verify().</span>
-<span class="hljs-keyword">const</span> callsfunc = tracker.calls(func);</code></pre>
-<h3><code>tracker.report()</code><span><a class="mark" href="#assert_tracker_report" id="assert_tracker_report">#</a></span></h3>
+<span class="hljs-keyword">const</span> callsfunc = tracker.<span class="hljs-title function_">calls</span>(func);</code></pre>
+<h4><code>tracker.report()</code><span><a class="mark" href="#assert_tracker_report" id="assert_tracker_report">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> of objects containing information about the wrapper functions
@@ -376,18 +389,18 @@ the functions that have not been called the expected number of times.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Creates call tracker.</span>
-<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.CallTracker();
+<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">CallTracker</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">func</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">func</span>(<span class="hljs-params"></span>) {}
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// Returns a function that wraps func() that must be called exact times</span>
 <span class="hljs-comment">// before tracker.verify().</span>
-<span class="hljs-keyword">const</span> callsfunc = tracker.calls(func, <span class="hljs-number">2</span>);
+<span class="hljs-keyword">const</span> callsfunc = tracker.<span class="hljs-title function_">calls</span>(func, <span class="hljs-number">2</span>);
 
 <span class="hljs-comment">// Returns an array containing information on callsfunc()</span>
-tracker.report();
+tracker.<span class="hljs-title function_">report</span>();
 <span class="hljs-comment">// [</span>
 <span class="hljs-comment">//  {</span>
 <span class="hljs-comment">//    message: 'Expected the func function to be executed 2 time(s) but was</span>
@@ -398,9 +411,9 @@ tracker.report();
 <span class="hljs-comment">//    stack: stack trace</span>
 <span class="hljs-comment">//  }</span>
 <span class="hljs-comment">// ]</span></code></pre>
-<h3><code>tracker.verify()</code><span><a class="mark" href="#assert_tracker_verify" id="assert_tracker_verify">#</a></span></h3>
+<h4><code>tracker.verify()</code><span><a class="mark" href="#assert_tracker_verify" id="assert_tracker_verify">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.2.0</span>
 </div>
 <p>Iterates through the list of functions passed to
 <a href="#assert_tracker_calls_fn_exact"><code>tracker.calls()</code></a> and will throw an error for functions that
@@ -408,19 +421,19 @@ have not been called the expected number of times.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Creates call tracker.</span>
-<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.CallTracker();
+<span class="hljs-keyword">const</span> tracker = <span class="hljs-keyword">new</span> assert.<span class="hljs-title class_">CallTracker</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">func</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">func</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// Returns a function that wraps func() that must be called exact times</span>
 <span class="hljs-comment">// before tracker.verify().</span>
-<span class="hljs-keyword">const</span> callsfunc = tracker.calls(func, <span class="hljs-number">2</span>);
+<span class="hljs-keyword">const</span> callsfunc = tracker.<span class="hljs-title function_">calls</span>(func, <span class="hljs-number">2</span>);
 
-callsfunc();
+<span class="hljs-title function_">callsfunc</span>();
 
 <span class="hljs-comment">// Will throw an error since callsfunc() was only called once.</span>
-tracker.verify();</code></pre>
-<h2><code>assert(value[, message])</code><span><a class="mark" href="#assert_assert_value_message" id="assert_assert_value_message">#</a></span></h2>
+tracker.<span class="hljs-title function_">verify</span>();</code></pre>
+</section><section><h3><code>assert(value[, message])</code><span><a class="mark" href="#assert_assert_value_message" id="assert_assert_value_message">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -429,17 +442,21 @@ tracker.verify();</code></pre>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 <p>An alias of <a href="#assert_assert_ok_value_message"><code>assert.ok()</code></a>.</p>
-<h2><code>assert.deepEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_deepequal_actual_expected_message" id="assert_assert_deepequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.deepEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_deepequal_actual_expected_message" id="assert_assert_deepequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>In Legacy assertion mode, changed status from Deprecated to Legacy.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>NaN is now treated as being identical in case both sides are NaN.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>The type tags are now properly compared and there are a couple minor comparison adjustments to make the check less surprising.</p></td></tr>
 <tr><td>v9.0.0</td>
-<td><p>The <code>Error</code> names and messages are now properly compared</p></td></tr>
+<td><p>The <code>Error</code> names and messages are now properly compared.</p></td></tr>
 <tr><td>v8.0.0</td>
-<td><p>The <code>Set</code> and <code>Map</code> content is also compared</p></td></tr>
+<td><p>The <code>Set</code> and <code>Map</code> content is also compared.</p></td></tr>
 <tr><td>v6.4.0, v4.7.1</td>
 <td><p>Typed array slices are handled correctly now.</p></td></tr>
 <tr><td>v6.1.0, v4.5.0</td>
@@ -459,16 +476,17 @@ tracker.verify();</code></pre>
 <p><strong>Strict assertion mode</strong></p>
 <p>An alias of <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a>.</p>
 <p><strong>Legacy assertion mode</strong></p>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> instead.</div><p></p>
 <p>Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters. Consider
 using <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> instead. <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a> can have
 surprising results.</p>
 <p><em>Deep equality</em> means that the enumerable "own" properties of child objects
 are also recursively evaluated by the following rules.</p>
-<h3>Comparison details<span><a class="mark" href="#assert_comparison_details" id="assert_comparison_details">#</a></span></h3>
+<h4>Comparison details<span><a class="mark" href="#assert_comparison_details" id="assert_comparison_details">#</a></span></h4>
 <ul>
 <li>Primitive values are compared with the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
-( <code>==</code> ).</li>
+( <code>==</code> ) with the exception of <code>NaN</code>. It is treated as being identical in case
+both sides are <code>NaN</code>.</li>
 <li><a href="https://tc39.github.io/ecma262/#sec-object.prototype.tostring">Type tags</a> of objects should be the same.</li>
 <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>
 <li><a href="errors.html#errors_class_error"><code>Error</code></a> names and messages are always compared, even if these are not
@@ -487,7 +505,7 @@ objects.</li>
 primitives are considered equal by the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
 ( <code>==</code> ).</p>
 <pre><code class="language-js"><span class="hljs-comment">// WARNING: This does not throw an AssertionError!</span>
-assert.deepEqual(<span class="hljs-string">'+00000000'</span>, <span class="hljs-literal">false</span>);</code></pre>
+assert.<span class="hljs-title function_">deepEqual</span>(<span class="hljs-string">'+00000000'</span>, <span class="hljs-literal">false</span>);</code></pre>
 <p>"Deep" equality means that the enumerable "own" properties of child objects
 are evaluated also:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
@@ -507,27 +525,27 @@ are evaluated also:</p>
     <span class="hljs-attr">b</span>: <span class="hljs-number">1</span>
   }
 };
-<span class="hljs-keyword">const</span> obj4 = <span class="hljs-built_in">Object</span>.create(obj1);
+<span class="hljs-keyword">const</span> obj4 = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(obj1);
 
-assert.deepEqual(obj1, obj1);
+assert.<span class="hljs-title function_">deepEqual</span>(obj1, obj1);
 <span class="hljs-comment">// OK</span>
 
 <span class="hljs-comment">// Values of b are different:</span>
-assert.deepEqual(obj1, obj2);
+assert.<span class="hljs-title function_">deepEqual</span>(obj1, obj2);
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }</span>
 
-assert.deepEqual(obj1, obj3);
+assert.<span class="hljs-title function_">deepEqual</span>(obj1, obj3);
 <span class="hljs-comment">// OK</span>
 
 <span class="hljs-comment">// Prototypes are ignored:</span>
-assert.deepEqual(obj1, obj4);
+assert.<span class="hljs-title function_">deepEqual</span>(obj1, obj4);
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } deepEqual {}</span></code></pre>
 <p>If the values are not equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
 property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
 parameter is undefined, a default error message is assigned. If the <code>message</code>
 parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.deepStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_deepstrictequal_actual_expected_message" id="assert_assert_deepstrictequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.deepStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_deepstrictequal_actual_expected_message" id="assert_assert_deepstrictequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -537,13 +555,13 @@ parameter is an instance of an <a href="errors.html#errors_class_error"><code>Er
 <tr><td>v9.0.0</td>
 <td><p>The <code>NaN</code> is now compared using the <a href="https://tc39.github.io/ecma262/#sec-samevaluezero">SameValueZero</a> comparison.</p></td></tr>
 <tr><td>v8.5.0</td>
-<td><p>The <code>Error</code> names and messages are now properly compared</p></td></tr>
+<td><p>The <code>Error</code> names and messages are now properly compared.</p></td></tr>
 <tr><td>v8.0.0</td>
-<td><p>The <code>Set</code> and <code>Map</code> content is also compared</p></td></tr>
-<tr><td>v6.4.0, v4.7.1</td>
-<td><p>Typed array slices are handled correctly now.</p></td></tr>
+<td><p>The <code>Set</code> and <code>Map</code> content is also compared.</p></td></tr>
 <tr><td>v6.1.0</td>
 <td><p>Objects with circular references can be used as inputs now.</p></td></tr>
+<tr><td>v6.4.0, v4.7.1</td>
+<td><p>Typed array slices are handled correctly now.</p></td></tr>
 <tr><td>v5.10.1, v4.4.3</td>
 <td><p>Handle non-<code>Uint8Array</code> typed arrays correctly.</p></td></tr>
 <tr><td>v1.2.0</td>
@@ -559,7 +577,7 @@ parameter is an instance of an <a href="errors.html#errors_class_error"><code>Er
 <p>Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters.
 "Deep" equality means that the enumerable "own" properties of child objects
 are recursively evaluated also by the following rules.</p>
-<h3>Comparison details<span><a class="mark" href="#assert_comparison_details_1" id="assert_comparison_details_1">#</a></span></h3>
+<h4>Comparison details<span><a class="mark" href="#assert_comparison_details_1" id="assert_comparison_details_1">#</a></span></h4>
 <ul>
 <li>Primitive values are compared using the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>, used by
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is()</code></a>.</li>
@@ -578,10 +596,10 @@ reference.</li>
 <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
 below for further details.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
 <span class="hljs-comment">// This fails because 1 !== '1'.</span>
-assert.deepStrictEqual({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'1'</span> });
+assert.<span class="hljs-title function_">deepStrictEqual</span>({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'1'</span> });
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
@@ -591,13 +609,13 @@ assert.deepStrictEqual({ <span class="hljs-attr">a</span>: <span class="hljs-num
 <span class="hljs-comment">//   }</span>
 
 <span class="hljs-comment">// The following objects don't have own properties</span>
-<span class="hljs-keyword">const</span> date = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>();
+<span class="hljs-keyword">const</span> date = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>();
 <span class="hljs-keyword">const</span> object = {};
 <span class="hljs-keyword">const</span> fakeDate = {};
-<span class="hljs-built_in">Object</span>.setPrototypeOf(fakeDate, <span class="hljs-built_in">Date</span>.prototype);
+<span class="hljs-title class_">Object</span>.<span class="hljs-title function_">setPrototypeOf</span>(fakeDate, <span class="hljs-title class_">Date</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>);
 
 <span class="hljs-comment">// Different [[Prototype]]:</span>
-assert.deepStrictEqual(object, fakeDate);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(object, fakeDate);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
@@ -605,60 +623,60 @@ assert.deepStrictEqual(object, fakeDate);
 <span class="hljs-comment">// - Date {}</span>
 
 <span class="hljs-comment">// Different type tags:</span>
-assert.deepStrictEqual(date, fakeDate);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(date, fakeDate);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// + 2018-04-26T00:49:08.604Z</span>
 <span class="hljs-comment">// - Date {}</span>
 
-assert.deepStrictEqual(<span class="hljs-literal">NaN</span>, <span class="hljs-literal">NaN</span>);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(<span class="hljs-title class_">Na</span>N, <span class="hljs-title class_">Na</span>N);
 <span class="hljs-comment">// OK, because of the SameValue comparison</span>
 
 <span class="hljs-comment">// Different unwrapped numbers:</span>
-assert.deepStrictEqual(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Number</span>(<span class="hljs-number">1</span>), <span class="hljs-keyword">new</span> <span class="hljs-built_in">Number</span>(<span class="hljs-number">2</span>));
+assert.<span class="hljs-title function_">deepStrictEqual</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Number</span>(<span class="hljs-number">1</span>), <span class="hljs-keyword">new</span> <span class="hljs-title class_">Number</span>(<span class="hljs-number">2</span>));
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// + [Number: 1]</span>
 <span class="hljs-comment">// - [Number: 2]</span>
 
-assert.deepStrictEqual(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'foo'</span>), <span class="hljs-built_in">Object</span>(<span class="hljs-string">'foo'</span>));
+assert.<span class="hljs-title function_">deepStrictEqual</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(<span class="hljs-string">'foo'</span>), <span class="hljs-title class_">Object</span>(<span class="hljs-string">'foo'</span>));
 <span class="hljs-comment">// OK because the object and the string are identical when unwrapped.</span>
 
-assert.deepStrictEqual(<span class="hljs-number">-0</span>, <span class="hljs-number">-0</span>);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(-<span class="hljs-number">0</span>, -<span class="hljs-number">0</span>);
 <span class="hljs-comment">// OK</span>
 
 <span class="hljs-comment">// Different zeros using the SameValue Comparison:</span>
-assert.deepStrictEqual(<span class="hljs-number">0</span>, <span class="hljs-number">-0</span>);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(<span class="hljs-number">0</span>, -<span class="hljs-number">0</span>);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// + 0</span>
 <span class="hljs-comment">// - -0</span>
 
-<span class="hljs-keyword">const</span> symbol1 = <span class="hljs-built_in">Symbol</span>();
-<span class="hljs-keyword">const</span> symbol2 = <span class="hljs-built_in">Symbol</span>();
-assert.deepStrictEqual({ [symbol1]: <span class="hljs-number">1</span> }, { [symbol1]: <span class="hljs-number">1</span> });
+<span class="hljs-keyword">const</span> symbol1 = <span class="hljs-title class_">Symbol</span>();
+<span class="hljs-keyword">const</span> symbol2 = <span class="hljs-title class_">Symbol</span>();
+assert.<span class="hljs-title function_">deepStrictEqual</span>({ [symbol1]: <span class="hljs-number">1</span> }, { [symbol1]: <span class="hljs-number">1</span> });
 <span class="hljs-comment">// OK, because it is the same symbol on both objects.</span>
 
-assert.deepStrictEqual({ [symbol1]: <span class="hljs-number">1</span> }, { [symbol2]: <span class="hljs-number">1</span> });
+assert.<span class="hljs-title function_">deepStrictEqual</span>({ [symbol1]: <span class="hljs-number">1</span> }, { [symbol2]: <span class="hljs-number">1</span> });
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// {</span>
 <span class="hljs-comment">//   [Symbol()]: 1</span>
 <span class="hljs-comment">// }</span>
 
-<span class="hljs-keyword">const</span> weakMap1 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakMap</span>();
-<span class="hljs-keyword">const</span> weakMap2 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakMap</span>([[{}, {}]]);
-<span class="hljs-keyword">const</span> weakMap3 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakMap</span>();
-weakMap3.unequal = <span class="hljs-literal">true</span>;
+<span class="hljs-keyword">const</span> weakMap1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakMap</span>();
+<span class="hljs-keyword">const</span> weakMap2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakMap</span>([[{}, {}]]);
+<span class="hljs-keyword">const</span> weakMap3 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakMap</span>();
+weakMap3.<span class="hljs-property">unequal</span> = <span class="hljs-literal">true</span>;
 
-assert.deepStrictEqual(weakMap1, weakMap2);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(weakMap1, weakMap2);
 <span class="hljs-comment">// OK, because it is impossible to compare the entries</span>
 
 <span class="hljs-comment">// Fails because weakMap3 has a property that weakMap1 does not contain:</span>
-assert.deepStrictEqual(weakMap1, weakMap3);
+assert.<span class="hljs-title function_">deepStrictEqual</span>(weakMap1, weakMap3);
 <span class="hljs-comment">// AssertionError: Expected inputs to be strictly deep-equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
@@ -672,9 +690,9 @@ property set equal to the value of the <code>message</code> parameter. If the <c
 parameter is undefined, a default error message is assigned. If the <code>message</code>
 parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <code>AssertionError</code>.</p>
-<h2><code>assert.doesNotMatch(string, regexp[, message])</code><span><a class="mark" href="#assert_assert_doesnotmatch_string_regexp_message" id="assert_assert_doesnotmatch_string_regexp_message">#</a></span></h2>
+</section><section><h3><code>assert.doesNotMatch(string, regexp[, message])</code><span><a class="mark" href="#assert_assert_doesnotmatch_string_regexp_message" id="assert_assert_doesnotmatch_string_regexp_message">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.6.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -685,15 +703,15 @@ parameter is an instance of an <a href="errors.html#errors_class_error"><code>Er
 <p>Expects the <code>string</code> input not to match the regular expression.</p>
 <p>This feature is currently experimental and the name might change or it might be
 completely removed again.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.doesNotMatch(<span class="hljs-string">'I will fail'</span>, <span class="hljs-regexp">/fail/</span>);
+assert.<span class="hljs-title function_">doesNotMatch</span>(<span class="hljs-string">'I will fail'</span>, <span class="hljs-regexp">/fail/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...</span>
 
-assert.doesNotMatch(<span class="hljs-number">123</span>, <span class="hljs-regexp">/pass/</span>);
+assert.<span class="hljs-title function_">doesNotMatch</span>(<span class="hljs-number">123</span>, <span class="hljs-regexp">/pass/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.</span>
 
-assert.doesNotMatch(<span class="hljs-string">'I will pass'</span>, <span class="hljs-regexp">/different/</span>);
+assert.<span class="hljs-title function_">doesNotMatch</span>(<span class="hljs-string">'I will pass'</span>, <span class="hljs-regexp">/different/</span>);
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values do match, or if the <code>string</code> argument is of another type than
 <code>string</code>, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code> property set equal
@@ -701,7 +719,7 @@ to the value of the <code>message</code> parameter. If the <code>message</code>
 undefined, a default error message is assigned. If the <code>message</code> parameter is an
 instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.doesNotReject(asyncFn[, error][, message])</code><span><a class="mark" href="#assert_assert_doesnotreject_asyncfn_error_message" id="assert_assert_doesnotreject_asyncfn_error_message">#</a></span></h2>
+</section><section><h3><code>assert.doesNotReject(asyncFn[, error][, message])</code><span><a class="mark" href="#assert_assert_doesnotreject_asyncfn_error_message" id="assert_assert_doesnotreject_asyncfn_error_message">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -728,19 +746,19 @@ function. See <a href="#assert_assert_throws_fn_error_message"><code>assert.thro
 <a href="#assert_assert_doesnotthrow_fn_error_message"><code>assert.doesNotThrow()</code></a>.</p>
 <!-- eslint-disable no-restricted-syntax -->
 <pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">await</span> assert.doesNotReject(
+  <span class="hljs-keyword">await</span> assert.<span class="hljs-title function_">doesNotReject</span>(
     <span class="hljs-keyword">async</span> () => {
-      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
     },
-    <span class="hljs-built_in">SyntaxError</span>
+    <span class="hljs-title class_">SyntaxError</span>
   );
 })();</code></pre>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js">assert.doesNotReject(<span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>)))
-  .then(<span class="hljs-function">() =></span> {
+<pre><code class="language-js">assert.<span class="hljs-title function_">doesNotReject</span>(<span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>)))
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> {
     <span class="hljs-comment">// ...</span>
   });</code></pre>
-<h2><code>assert.doesNotThrow(fn[, error][, message])</code><span><a class="mark" href="#assert_assert_doesnotthrow_fn_error_message" id="assert_assert_doesnotthrow_fn_error_message">#</a></span></h2>
+</section><section><h3><code>assert.doesNotThrow(fn[, error][, message])</code><span><a class="mark" href="#assert_assert_doesnotthrow_fn_error_message" id="assert_assert_doesnotthrow_fn_error_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -775,36 +793,46 @@ function. See <a href="#assert_assert_throws_fn_error_message"><code>assert.thro
 <p>The following, for instance, will throw the <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> because there is no
 matching error type in the assertion:</p>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js">assert.doesNotThrow(
+<pre><code class="language-js">assert.<span class="hljs-title function_">doesNotThrow</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
   },
-  <span class="hljs-built_in">SyntaxError</span>
+  <span class="hljs-title class_">SyntaxError</span>
 );</code></pre>
 <p>However, the following will result in an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> with the message
 'Got unwanted exception...':</p>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js">assert.doesNotThrow(
+<pre><code class="language-js">assert.<span class="hljs-title function_">doesNotThrow</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
   },
-  <span class="hljs-built_in">TypeError</span>
+  <span class="hljs-title class_">TypeError</span>
 );</code></pre>
 <p>If an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown and a value is provided for the <code>message</code>
 parameter, the value of <code>message</code> will be appended to the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>
 message:</p>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js">assert.doesNotThrow(
+<pre><code class="language-js">assert.<span class="hljs-title function_">doesNotThrow</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
   },
   <span class="hljs-regexp">/Wrong value/</span>,
   <span class="hljs-string">'Whoops'</span>
 );
 <span class="hljs-comment">// Throws: AssertionError: Got unwanted exception: Whoops</span></code></pre>
-<h2><code>assert.equal(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_equal_actual_expected_message" id="assert_assert_equal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.equal(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_equal_actual_expected_message" id="assert_assert_equal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.1.21</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>In Legacy assertion mode, changed status from Deprecated to Legacy.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>NaN is now treated as being identical in case both sides are NaN.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
@@ -814,26 +842,29 @@ message:</p>
 <p><strong>Strict assertion mode</strong></p>
 <p>An alias of <a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a>.</p>
 <p><strong>Legacy assertion mode</strong></p>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a> instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use <a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a> instead.</div><p></p>
 <p>Tests shallow, coercive equality between the <code>actual</code> and <code>expected</code> parameters
-using the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> ( <code>==</code> ).</p>
+using the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> ( <code>==</code> ). <code>NaN</code> is special handled
+and treated as being identical in case both sides are <code>NaN</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
-assert.equal(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">equal</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
 <span class="hljs-comment">// OK, 1 == 1</span>
-assert.equal(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
+assert.<span class="hljs-title function_">equal</span>(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
 <span class="hljs-comment">// OK, 1 == '1'</span>
+assert.<span class="hljs-title function_">equal</span>(<span class="hljs-title class_">Na</span>N, <span class="hljs-title class_">Na</span>N);
+<span class="hljs-comment">// OK</span>
 
-assert.equal(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+assert.<span class="hljs-title function_">equal</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 <span class="hljs-comment">// AssertionError: 1 == 2</span>
-assert.equal({ <span class="hljs-attr">a</span>: { <span class="hljs-attr">b</span>: <span class="hljs-number">1</span> } }, { <span class="hljs-attr">a</span>: { <span class="hljs-attr">b</span>: <span class="hljs-number">1</span> } });
+assert.<span class="hljs-title function_">equal</span>({ <span class="hljs-attr">a</span>: { <span class="hljs-attr">b</span>: <span class="hljs-number">1</span> } }, { <span class="hljs-attr">a</span>: { <span class="hljs-attr">b</span>: <span class="hljs-number">1</span> } });
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }</span></code></pre>
 <p>If the values are not equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
 property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
 parameter is undefined, a default error message is assigned. If the <code>message</code>
 parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <code>AssertionError</code>.</p>
-<h2><code>assert.fail([message])</code><span><a class="mark" href="#assert_assert_fail_message" id="assert_assert_fail_message">#</a></span></h2>
+</section><section><h3><code>assert.fail([message])</code><span><a class="mark" href="#assert_assert_fail_message" id="assert_assert_fail_message">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.21</span>
 </div>
@@ -843,19 +874,19 @@ parameter is an instance of an <a href="errors.html#errors_class_error"><code>Er
 <p>Throws an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> with the provided error message or a default
 error message. If the <code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then
 it will be thrown instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.fail();
+assert.<span class="hljs-title function_">fail</span>();
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Failed</span>
 
-assert.fail(<span class="hljs-string">'boom'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-string">'boom'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: boom</span>
 
-assert.fail(<span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'need array'</span>));
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'need array'</span>));
 <span class="hljs-comment">// TypeError: need array</span></code></pre>
 <p>Using <code>assert.fail()</code> with more than two arguments is possible but deprecated.
 See below for further details.</p>
-<h2><code>assert.fail(actual, expected[, message[, operator[, stackStartFn]]])</code><span><a class="mark" href="#assert_assert_fail_actual_expected_message_operator_stackstartfn" id="assert_assert_fail_actual_expected_message_operator_stackstartfn">#</a></span></h2>
+</section><section><h3><code>assert.fail(actual, expected[, message[, operator[, stackStartFn]]])</code><span><a class="mark" href="#assert_assert_fail_actual_expected_message_operator_stackstartfn" id="assert_assert_fail_actual_expected_message_operator_stackstartfn">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -884,34 +915,34 @@ the other arguments will be stored as properties on the thrown object. If
 <code>stackStartFn</code> is provided, all stack frames above that function will be
 removed from stacktrace (see <a href="errors.html#errors_error_capturestacktrace_targetobject_constructoropt"><code>Error.captureStackTrace</code></a>). If no arguments are
 given, the default message <code>Failed</code> will be used.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.fail(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: 'a' != 'b'</span>
 
-assert.fail(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'>'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'>'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: 1 > 2</span>
 
-assert.fail(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'fail'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'fail'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: fail</span>
 
-assert.fail(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'whoops'</span>, <span class="hljs-string">'>'</span>);
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-string">'whoops'</span>, <span class="hljs-string">'>'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: whoops</span>
 
-assert.fail(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'need array'</span>));
+assert.<span class="hljs-title function_">fail</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'need array'</span>));
 <span class="hljs-comment">// TypeError: need array</span></code></pre>
 <p>In the last three cases <code>actual</code>, <code>expected</code>, and <code>operator</code> have no
 influence on the error message.</p>
 <p>Example use of <code>stackStartFn</code> for truncating the exception's stacktrace:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">suppressFrame</span>(<span class="hljs-params"></span>) </span>{
-  assert.fail(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'!=='</span>, suppressFrame);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">suppressFrame</span>(<span class="hljs-params"></span>) {
+  assert.<span class="hljs-title function_">fail</span>(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'!=='</span>, suppressFrame);
 }
-suppressFrame();
+<span class="hljs-title function_">suppressFrame</span>();
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: 'a' !== 'b'</span>
 <span class="hljs-comment">//     at repl:1:1</span>
 <span class="hljs-comment">//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)</span>
 <span class="hljs-comment">//     ...</span></code></pre>
-<h2><code>assert.ifError(value)</code><span><a class="mark" href="#assert_assert_iferror_value" id="assert_assert_iferror_value">#</a></span></h2>
+</section><section><h3><code>assert.ifError(value)</code><span><a class="mark" href="#assert_assert_iferror_value" id="assert_assert_iferror_value">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -932,32 +963,32 @@ suppressFrame();
 testing the <code>error</code> argument in callbacks. The stack trace contains all frames
 from the error passed to <code>ifError()</code> including the potential new frames for
 <code>ifError()</code> itself.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.ifError(<span class="hljs-literal">null</span>);
+assert.<span class="hljs-title function_">ifError</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// OK</span>
-assert.ifError(<span class="hljs-number">0</span>);
+assert.<span class="hljs-title function_">ifError</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0</span>
-assert.ifError(<span class="hljs-string">'error'</span>);
+assert.<span class="hljs-title function_">ifError</span>(<span class="hljs-string">'error'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'</span>
-assert.ifError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>());
+assert.<span class="hljs-title function_">ifError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>());
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error</span>
 
 <span class="hljs-comment">// Create some random error frames.</span>
 <span class="hljs-keyword">let</span> err;
-(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">errorFrame</span>(<span class="hljs-params"></span>) </span>{
-  err = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'test error'</span>);
+(<span class="hljs-keyword">function</span> <span class="hljs-title function_">errorFrame</span>(<span class="hljs-params"></span>) {
+  err = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'test error'</span>);
 })();
 
-(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">ifErrorFrame</span>(<span class="hljs-params"></span>) </span>{
-  assert.ifError(err);
+(<span class="hljs-keyword">function</span> <span class="hljs-title function_">ifErrorFrame</span>(<span class="hljs-params"></span>) {
+  assert.<span class="hljs-title function_">ifError</span>(err);
 })();
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error</span>
 <span class="hljs-comment">//     at ifErrorFrame</span>
 <span class="hljs-comment">//     at errorFrame</span></code></pre>
-<h2><code>assert.match(string, regexp[, message])</code><span><a class="mark" href="#assert_assert_match_string_regexp_message" id="assert_assert_match_string_regexp_message">#</a></span></h2>
+</section><section><h3><code>assert.match(string, regexp[, message])</code><span><a class="mark" href="#assert_assert_match_string_regexp_message" id="assert_assert_match_string_regexp_message">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.6.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -968,15 +999,15 @@ assert.ifError(<span class="hljs-keyword">new</span> <span class="hljs-built_in"
 <p>Expects the <code>string</code> input to match the regular expression.</p>
 <p>This feature is currently experimental and the name might change or it might be
 completely removed again.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.match(<span class="hljs-string">'I will fail'</span>, <span class="hljs-regexp">/pass/</span>);
+assert.<span class="hljs-title function_">match</span>(<span class="hljs-string">'I will fail'</span>, <span class="hljs-regexp">/pass/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: The input did not match the regular ...</span>
 
-assert.match(<span class="hljs-number">123</span>, <span class="hljs-regexp">/pass/</span>);
+assert.<span class="hljs-title function_">match</span>(<span class="hljs-number">123</span>, <span class="hljs-regexp">/pass/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.</span>
 
-assert.match(<span class="hljs-string">'I will pass'</span>, <span class="hljs-regexp">/pass/</span>);
+assert.<span class="hljs-title function_">match</span>(<span class="hljs-string">'I will pass'</span>, <span class="hljs-regexp">/pass/</span>);
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values do not match, or if the <code>string</code> argument is of another type than
 <code>string</code>, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code> property set equal
@@ -984,15 +1015,19 @@ to the value of the <code>message</code> parameter. If the <code>message</code>
 undefined, a default error message is assigned. If the <code>message</code> parameter is an
 instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.notDeepEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notdeepequal_actual_expected_message" id="assert_assert_notdeepequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.notDeepEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notdeepequal_actual_expected_message" id="assert_assert_notdeepequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>In Legacy assertion mode, changed status from Deprecated to Legacy.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>NaN is now treated as being identical in case both sides are NaN.</p></td></tr>
 <tr><td>v9.0.0</td>
-<td><p>The <code>Error</code> names and messages are now properly compared</p></td></tr>
+<td><p>The <code>Error</code> names and messages are now properly compared.</p></td></tr>
 <tr><td>v8.0.0</td>
-<td><p>The <code>Set</code> and <code>Map</code> content is also compared</p></td></tr>
+<td><p>The <code>Set</code> and <code>Map</code> content is also compared.</p></td></tr>
 <tr><td>v6.4.0, v4.7.1</td>
 <td><p>Typed array slices are handled correctly now.</p></td></tr>
 <tr><td>v6.1.0, v4.5.0</td>
@@ -1012,7 +1047,7 @@ instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> t
 <p><strong>Strict assertion mode</strong></p>
 <p>An alias of <a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual()</code></a>.</p>
 <p><strong>Legacy assertion mode</strong></p>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual()</code></a> instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use <a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual()</code></a> instead.</div><p></p>
 <p>Tests for any deep inequality. Opposite of <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
@@ -1031,25 +1066,25 @@ instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> t
     <span class="hljs-attr">b</span>: <span class="hljs-number">1</span>
   }
 };
-<span class="hljs-keyword">const</span> obj4 = <span class="hljs-built_in">Object</span>.create(obj1);
+<span class="hljs-keyword">const</span> obj4 = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(obj1);
 
-assert.notDeepEqual(obj1, obj1);
+assert.<span class="hljs-title function_">notDeepEqual</span>(obj1, obj1);
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }</span>
 
-assert.notDeepEqual(obj1, obj2);
+assert.<span class="hljs-title function_">notDeepEqual</span>(obj1, obj2);
 <span class="hljs-comment">// OK</span>
 
-assert.notDeepEqual(obj1, obj3);
+assert.<span class="hljs-title function_">notDeepEqual</span>(obj1, obj3);
 <span class="hljs-comment">// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }</span>
 
-assert.notDeepEqual(obj1, obj4);
+assert.<span class="hljs-title function_">notDeepEqual</span>(obj1, obj4);
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values are deeply equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
 <code>message</code> property set equal to the value of the <code>message</code> parameter. If the
 <code>message</code> parameter is undefined, a default error message is assigned. If the
 <code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown
 instead of the <code>AssertionError</code>.</p>
-<h2><code>assert.notDeepStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notdeepstrictequal_actual_expected_message" id="assert_assert_notdeepstrictequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.notDeepStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notdeepstrictequal_actual_expected_message" id="assert_assert_notdeepstrictequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1059,13 +1094,13 @@ instead of the <code>AssertionError</code>.</p>
 <tr><td>v9.0.0</td>
 <td><p>The <code>NaN</code> is now compared using the <a href="https://tc39.github.io/ecma262/#sec-samevaluezero">SameValueZero</a> comparison.</p></td></tr>
 <tr><td>v9.0.0</td>
-<td><p>The <code>Error</code> names and messages are now properly compared</p></td></tr>
+<td><p>The <code>Error</code> names and messages are now properly compared.</p></td></tr>
 <tr><td>v8.0.0</td>
-<td><p>The <code>Set</code> and <code>Map</code> content is also compared</p></td></tr>
-<tr><td>v6.4.0, v4.7.1</td>
-<td><p>Typed array slices are handled correctly now.</p></td></tr>
+<td><p>The <code>Set</code> and <code>Map</code> content is also compared.</p></td></tr>
 <tr><td>v6.1.0</td>
 <td><p>Objects with circular references can be used as inputs now.</p></td></tr>
+<tr><td>v6.4.0, v4.7.1</td>
+<td><p>Typed array slices are handled correctly now.</p></td></tr>
 <tr><td>v5.10.1, v4.4.3</td>
 <td><p>Handle non-<code>Uint8Array</code> typed arrays correctly.</p></td></tr>
 <tr><td>v1.2.0</td>
@@ -1079,18 +1114,28 @@ instead of the <code>AssertionError</code>.</p>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 <p>Tests for deep strict inequality. Opposite of <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.notDeepStrictEqual({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'1'</span> });
+assert.<span class="hljs-title function_">notDeepStrictEqual</span>({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'1'</span> });
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values are deeply and strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown
 with a <code>message</code> property set equal to the value of the <code>message</code> parameter. If
 the <code>message</code> parameter is undefined, a default error message is assigned. If
 the <code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown
 instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.notEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notequal_actual_expected_message" id="assert_assert_notequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.notEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notequal_actual_expected_message" id="assert_assert_notequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.1.21</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>In Legacy assertion mode, changed status from Deprecated to Legacy.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>NaN is now treated as being identical in case both sides are NaN.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
@@ -1100,31 +1145,32 @@ instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionErro
 <p><strong>Strict assertion mode</strong></p>
 <p>An alias of <a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual()</code></a>.</p>
 <p><strong>Legacy assertion mode</strong></p>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual()</code></a> instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use <a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual()</code></a> instead.</div><p></p>
 <p>Tests shallow, coercive inequality with the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
-( <code>!=</code> ).</p>
+(<code>!=</code> ). <code>NaN</code> is special handled and treated as being identical in case both
+sides are <code>NaN</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
-assert.notEqual(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+assert.<span class="hljs-title function_">notEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 <span class="hljs-comment">// OK</span>
 
-assert.notEqual(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">notEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
 <span class="hljs-comment">// AssertionError: 1 != 1</span>
 
-assert.notEqual(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
+assert.<span class="hljs-title function_">notEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
 <span class="hljs-comment">// AssertionError: 1 != '1'</span></code></pre>
 <p>If the values are equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
 property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
 parameter is undefined, a default error message is assigned. If the <code>message</code>
 parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
 <code>AssertionError</code>.</p>
-<h2><code>assert.notStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notstrictequal_actual_expected_message" id="assert_assert_notstrictequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.notStrictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_notstrictequal_actual_expected_message" id="assert_assert_notstrictequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
-<td><p>Used comparison changed from Strict Equality to <code>Object.is()</code></p></td></tr>
+<td><p>Used comparison changed from Strict Equality to <code>Object.is()</code>.</p></td></tr>
 <tr><td>v0.1.21</td>
 <td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
@@ -1137,24 +1183,24 @@ parameter is an instance of an <a href="errors.html#errors_class_error"><code>Er
 </ul>
 <p>Tests strict inequality between the <code>actual</code> and <code>expected</code> parameters as
 determined by the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.notStrictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+assert.<span class="hljs-title function_">notStrictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 <span class="hljs-comment">// OK</span>
 
-assert.notStrictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">notStrictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// 1</span>
 
-assert.notStrictEqual(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
+assert.<span class="hljs-title function_">notStrictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>);
 <span class="hljs-comment">// OK</span></code></pre>
 <p>If the values are strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
 <code>message</code> property set equal to the value of the <code>message</code> parameter. If the
 <code>message</code> parameter is undefined, a default error message is assigned. If the
 <code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown
 instead of the <code>AssertionError</code>.</p>
-<h2><code>assert.ok(value[, message])</code><span><a class="mark" href="#assert_assert_ok_value_message" id="assert_assert_ok_value_message">#</a></span></h2>
+</section><section><h3><code>assert.ok(value[, message])</code><span><a class="mark" href="#assert_assert_ok_value_message" id="assert_assert_ok_value_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1181,45 +1227,45 @@ If no arguments are passed in at all <code>message</code> will be set to the str
 <code>'No value argument passed to `assert.ok()`'</code>.</p>
 <p>Be aware that in the <code>repl</code> the error message will be different to the one
 thrown in a file! See below for further details.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.ok(<span class="hljs-literal">true</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-literal">true</span>);
 <span class="hljs-comment">// OK</span>
-assert.ok(<span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-number">1</span>);
 <span class="hljs-comment">// OK</span>
 
-assert.ok();
+assert.<span class="hljs-title function_">ok</span>();
 <span class="hljs-comment">// AssertionError: No value argument passed to `assert.ok()`</span>
 
-assert.ok(<span class="hljs-literal">false</span>, <span class="hljs-string">'it\'s false'</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-literal">false</span>, <span class="hljs-string">'it\'s false'</span>);
 <span class="hljs-comment">// AssertionError: it's false</span>
 
 <span class="hljs-comment">// In the repl:</span>
-assert.ok(<span class="hljs-keyword">typeof</span> <span class="hljs-number">123</span> === <span class="hljs-string">'string'</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-keyword">typeof</span> <span class="hljs-number">123</span> === <span class="hljs-string">'string'</span>);
 <span class="hljs-comment">// AssertionError: false == true</span>
 
 <span class="hljs-comment">// In a file (e.g. test.js):</span>
-assert.ok(<span class="hljs-keyword">typeof</span> <span class="hljs-number">123</span> === <span class="hljs-string">'string'</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-keyword">typeof</span> <span class="hljs-number">123</span> === <span class="hljs-string">'string'</span>);
 <span class="hljs-comment">// AssertionError: The expression evaluated to a falsy value:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">//   assert.ok(typeof 123 === 'string')</span>
 
-assert.ok(<span class="hljs-literal">false</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-literal">false</span>);
 <span class="hljs-comment">// AssertionError: The expression evaluated to a falsy value:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">//   assert.ok(false)</span>
 
-assert.ok(<span class="hljs-number">0</span>);
+assert.<span class="hljs-title function_">ok</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// AssertionError: The expression evaluated to a falsy value:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">//   assert.ok(0)</span>
 
 <span class="hljs-comment">// Using `assert()` works the same:</span>
-assert(<span class="hljs-number">0</span>);
+<span class="hljs-title function_">assert</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// AssertionError: The expression evaluated to a falsy value:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">//   assert(0)</span></code></pre>
-<h2><code>assert.rejects(asyncFn[, error][, message])</code><span><a class="mark" href="#assert_assert_rejects_asyncfn_error_message" id="assert_assert_rejects_asyncfn_error_message">#</a></span></h2>
+</section><section><h3><code>assert.rejects(asyncFn[, error][, message])</code><span><a class="mark" href="#assert_assert_rejects_asyncfn_error_message" id="assert_assert_rejects_asyncfn_error_message">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1245,9 +1291,9 @@ each property will be tested for including the non-enumerable <code>message</cod
 <p>If specified, <code>message</code> will be the message provided by the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>
 if the <code>asyncFn</code> fails to reject.</p>
 <pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">await</span> assert.rejects(
+  <span class="hljs-keyword">await</span> assert.<span class="hljs-title function_">rejects</span>(
     <span class="hljs-keyword">async</span> () => {
-      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
     },
     {
       <span class="hljs-attr">name</span>: <span class="hljs-string">'TypeError'</span>,
@@ -1256,21 +1302,21 @@ if the <code>asyncFn</code> fails to reject.</p>
   );
 })();</code></pre>
 <pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">await</span> assert.rejects(
+  <span class="hljs-keyword">await</span> assert.<span class="hljs-title function_">rejects</span>(
     <span class="hljs-keyword">async</span> () => {
-      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+      <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
     },
     <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-      assert.strictEqual(err.name, <span class="hljs-string">'TypeError'</span>);
-      assert.strictEqual(err.message, <span class="hljs-string">'Wrong value'</span>);
+      assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">name</span>, <span class="hljs-string">'TypeError'</span>);
+      assert.<span class="hljs-title function_">strictEqual</span>(err.<span class="hljs-property">message</span>, <span class="hljs-string">'Wrong value'</span>);
       <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
     }
   );
 })();</code></pre>
-<pre><code class="language-js">assert.rejects(
-  <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Wrong value'</span>)),
-  <span class="hljs-built_in">Error</span>
-).then(<span class="hljs-function">() =></span> {
+<pre><code class="language-js">assert.<span class="hljs-title function_">rejects</span>(
+  <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Wrong value'</span>)),
+  <span class="hljs-title class_">Error</span>
+).<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p><code>error</code> cannot be a string. If a string is provided as the second
@@ -1278,13 +1324,13 @@ argument, then <code>error</code> is assumed to be omitted and the string will b
 <code>message</code> instead. This can lead to easy-to-miss mistakes. Please read the
 example in <a href="#assert_assert_throws_fn_error_message"><code>assert.throws()</code></a> carefully if using a string as the second
 argument gets considered.</p>
-<h2><code>assert.strictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_strictequal_actual_expected_message" id="assert_assert_strictequal_actual_expected_message">#</a></span></h2>
+</section><section><h3><code>assert.strictEqual(actual, expected[, message])</code><span><a class="mark" href="#assert_assert_strictequal_actual_expected_message" id="assert_assert_strictequal_actual_expected_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
-<td><p>Used comparison changed from Strict Equality to <code>Object.is()</code></p></td></tr>
+<td><p>Used comparison changed from Strict Equality to <code>Object.is()</code>.</p></td></tr>
 <tr><td>v0.1.21</td>
 <td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
@@ -1297,17 +1343,17 @@ argument gets considered.</p>
 </ul>
 <p>Tests strict equality between the <code>actual</code> and <code>expected</code> parameters as
 determined by the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).strict;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>).<span class="hljs-property">strict</span>;
 
-assert.strictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:</span>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// 1 !== 2</span>
 
-assert.strictEqual(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>);
 <span class="hljs-comment">// OK</span>
 
-assert.strictEqual(<span class="hljs-string">'Hello foobar'</span>, <span class="hljs-string">'Hello World!'</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-string">'Hello foobar'</span>, <span class="hljs-string">'Hello World!'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:</span>
 <span class="hljs-comment">// + actual - expected</span>
 <span class="hljs-comment">//</span>
@@ -1317,17 +1363,17 @@ assert.strictEqual(<span class="hljs-string">'Hello foobar'</span>, <span class=
 
 <span class="hljs-keyword">const</span> apples = <span class="hljs-number">1</span>;
 <span class="hljs-keyword">const</span> oranges = <span class="hljs-number">2</span>;
-assert.strictEqual(apples, oranges, <span class="hljs-string">`apples <span class="hljs-subst">${apples}</span> !== oranges <span class="hljs-subst">${oranges}</span>`</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(apples, oranges, <span class="hljs-string">`apples <span class="hljs-subst">${apples}</span> !== oranges <span class="hljs-subst">${oranges}</span>`</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2</span>
 
-assert.strictEqual(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Inputs are not identical'</span>));
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-number">1</span>, <span class="hljs-string">'1'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Inputs are not identical'</span>));
 <span class="hljs-comment">// TypeError: Inputs are not identical</span></code></pre>
 <p>If the values are not strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
 <code>message</code> property set equal to the value of the <code>message</code> parameter. If the
 <code>message</code> parameter is undefined, a default error message is assigned. If the
 <code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown
 instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<h2><code>assert.throws(fn[, error][, message])</code><span><a class="mark" href="#assert_assert_throws_fn_error_message" id="assert_assert_throws_fn_error_message">#</a></span></h2>
+</section><section><h3><code>assert.throws(fn[, error][, message])</code><span><a class="mark" href="#assert_assert_throws_fn_error_message" id="assert_assert_throws_fn_error_message">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1359,16 +1405,16 @@ validating against a string property. See below for examples.</p>
 <code>AssertionError</code> if the <code>fn</code> call fails to throw or in case the error validation
 fails.</p>
 <p>Custom validation object/error instance:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
-err.code = <span class="hljs-number">404</span>;
-err.foo = <span class="hljs-string">'bar'</span>;
-err.info = {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>(<span class="hljs-string">'Wrong value'</span>);
+err.<span class="hljs-property">code</span> = <span class="hljs-number">404</span>;
+err.<span class="hljs-property">foo</span> = <span class="hljs-string">'bar'</span>;
+err.<span class="hljs-property">info</span> = {
   <span class="hljs-attr">nested</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">baz</span>: <span class="hljs-string">'text'</span>
 };
-err.reg = <span class="hljs-regexp">/abc/i</span>;
+err.<span class="hljs-property">reg</span> = <span class="hljs-regexp">/abc/i</span>;
 
-assert.throws(
+assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
     <span class="hljs-keyword">throw</span> err;
   },
@@ -1386,7 +1432,7 @@ assert.throws(
 );
 
 <span class="hljs-comment">// Using regular expressions to validate error properties:</span>
-assert.throws(
+assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
     <span class="hljs-keyword">throw</span> err;
   },
@@ -1395,8 +1441,8 @@ assert.throws(
     <span class="hljs-comment">// expressions on those will match against the string. If they fail, an</span>
     <span class="hljs-comment">// error is thrown.</span>
     <span class="hljs-attr">name</span>: <span class="hljs-regexp">/^TypeError$/</span>,
-    message: <span class="hljs-regexp">/Wrong/</span>,
-    foo: <span class="hljs-string">'bar'</span>,
+    <span class="hljs-attr">message</span>: <span class="hljs-regexp">/Wrong/</span>,
+    <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>,
     <span class="hljs-attr">info</span>: {
       <span class="hljs-attr">nested</span>: <span class="hljs-literal">true</span>,
       <span class="hljs-comment">// It is not possible to use regular expressions for nested properties!</span>
@@ -1410,11 +1456,11 @@ assert.throws(
 );
 
 <span class="hljs-comment">// Fails due to the different `message` and `name` properties:</span>
-assert.throws(
+assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">const</span> otherErr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Not found'</span>);
+    <span class="hljs-keyword">const</span> otherErr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Not found'</span>);
     <span class="hljs-comment">// Copy all enumerable properties from `err` to `otherErr`.</span>
-    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> [key, value] <span class="hljs-keyword">of</span> <span class="hljs-built_in">Object</span>.entries(err)) {
+    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> [key, value] <span class="hljs-keyword">of</span> <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">entries</span>(err)) {
       otherErr[key] = value;
     }
     <span class="hljs-keyword">throw</span> otherErr;
@@ -1424,31 +1470,31 @@ assert.throws(
   err
 );</code></pre>
 <p>Validate instanceof using constructor:</p>
-<pre><code class="language-js">assert.throws(
+<pre><code class="language-js">assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Wrong value'</span>);
   },
-  <span class="hljs-built_in">Error</span>
+  <span class="hljs-title class_">Error</span>
 );</code></pre>
 <p>Validate error message using <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions"><code>RegExp</code></a>:</p>
 <p>Using a regular expression runs <code>.toString</code> on the error object, and will
 therefore also include the error name.</p>
-<pre><code class="language-js">assert.throws(
+<pre><code class="language-js">assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Wrong value'</span>);
   },
   <span class="hljs-regexp">/^Error: Wrong value$/</span>
 );</code></pre>
 <p>Custom error validation:</p>
 <p>The function must return <code>true</code> to indicate all internal validations passed.
 It will otherwise fail with an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.</p>
-<pre><code class="language-js">assert.throws(
+<pre><code class="language-js">assert.<span class="hljs-title function_">throws</span>(
   <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Wrong value'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Wrong value'</span>);
   },
   <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    assert(err <span class="hljs-keyword">instanceof</span> <span class="hljs-built_in">Error</span>);
-    assert(<span class="hljs-regexp">/value/</span>.test(err));
+    <span class="hljs-title function_">assert</span>(err <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">Error</span>);
+    <span class="hljs-title function_">assert</span>(<span class="hljs-regexp">/value/</span>.<span class="hljs-title function_">test</span>(err));
     <span class="hljs-comment">// Avoid returning anything from validation functions besides `true`.</span>
     <span class="hljs-comment">// Otherwise, it's not clear what part of the validation failed. Instead,</span>
     <span class="hljs-comment">// throw an error about the specific validation that failed (as done in this</span>
@@ -1465,42 +1511,78 @@ message as the thrown error message is going to result in an
 <code>ERR_AMBIGUOUS_ARGUMENT</code> error. Please read the example below carefully if using
 a string as the second argument gets considered:</p>
 <!-- eslint-disable no-restricted-syntax -->
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">throwingFirst</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'First'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">throwingFirst</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'First'</span>);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">throwingSecond</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Second'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">throwingSecond</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Second'</span>);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">notThrowing</span>(<span class="hljs-params"></span>) </span>{}
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">notThrowing</span>(<span class="hljs-params"></span>) {}
 
 <span class="hljs-comment">// The second argument is a string and the input function threw an Error.</span>
 <span class="hljs-comment">// The first case will not throw as it does not match for the error message</span>
 <span class="hljs-comment">// thrown by the input function!</span>
-assert.throws(throwingFirst, <span class="hljs-string">'Second'</span>);
+assert.<span class="hljs-title function_">throws</span>(throwingFirst, <span class="hljs-string">'Second'</span>);
 <span class="hljs-comment">// In the next example the message has no benefit over the message from the</span>
 <span class="hljs-comment">// error and since it is not clear if the user intended to actually match</span>
 <span class="hljs-comment">// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.</span>
-assert.throws(throwingSecond, <span class="hljs-string">'Second'</span>);
+assert.<span class="hljs-title function_">throws</span>(throwingSecond, <span class="hljs-string">'Second'</span>);
 <span class="hljs-comment">// TypeError [ERR_AMBIGUOUS_ARGUMENT]</span>
 
 <span class="hljs-comment">// The string is only used (as message) in case the function does not throw:</span>
-assert.throws(notThrowing, <span class="hljs-string">'Second'</span>);
+assert.<span class="hljs-title function_">throws</span>(notThrowing, <span class="hljs-string">'Second'</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]: Missing expected exception: Second</span>
 
 <span class="hljs-comment">// If it was intended to match for the error message do this instead:</span>
 <span class="hljs-comment">// It does not throw because the error messages match.</span>
-assert.throws(throwingSecond, <span class="hljs-regexp">/Second$/</span>);
+assert.<span class="hljs-title function_">throws</span>(throwingSecond, <span class="hljs-regexp">/Second$/</span>);
 
 <span class="hljs-comment">// If the error message does not match, an AssertionError is thrown.</span>
-assert.throws(throwingFirst, <span class="hljs-regexp">/Second$/</span>);
+assert.<span class="hljs-title function_">throws</span>(throwingFirst, <span class="hljs-regexp">/Second$/</span>);
 <span class="hljs-comment">// AssertionError [ERR_ASSERTION]</span></code></pre>
 <p>Due to the confusing error-prone notation, avoid a string as the second
-argument.</p>
+argument.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/assert.json b/doc/api/assert.json
index 6deb47fc96415298ff2de692fe676de1f48e4544..589dc4eabcb771a751e0f19383df5b5300b3d6ed 100644
--- a/doc/api/assert.json
+++ b/doc/api/assert.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.1.21",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/assert.js\">lib/assert.js</a></p>\n<p>The <code>assert</code> module provides a set of assertion functions for verifying\ninvariants.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/assert.js\">lib/assert.js</a></p>\n<p>The <code>assert</code> module provides a set of assertion functions for verifying\ninvariants.</p>",
       "modules": [
         {
           "textRaw": "Strict assertion mode",
@@ -19,7 +19,11 @@
             ],
             "changes": [
               {
-                "version": "v12.16.2",
+                "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\"."
               },
               {
@@ -103,13 +107,13 @@
           "name": "assert.CallTracker",
           "meta": {
             "added": [
-              "v12.19.0"
+              "v14.2.0"
             ],
             "changes": []
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p>This feature is currently experimental and behavior might still change.</p>\n<p>### <code>new assert.CallTracker()</code></p>\n<p>Creates a new <a href=\"#assert_class_assert_calltracker\"><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#process_event_exit\"><code>process.on('exit')</code></a> handler.</p>\n<pre><code class=\"language-js\">const assert = require('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>",
+          "desc": "<p>This feature is currently experimental and behavior might still change.</p>",
           "methods": [
             {
               "textRaw": "`tracker.calls([fn][, exact])`",
@@ -117,7 +121,7 @@
               "name": "calls",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.2.0"
                 ],
                 "changes": []
               },
@@ -153,7 +157,7 @@
               "name": "report",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.2.0"
                 ],
                 "changes": []
               },
@@ -213,7 +217,7 @@
               "name": "verify",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.2.0"
                 ],
                 "changes": []
               },
@@ -224,6 +228,12 @@
               ],
               "desc": "<p>Iterates through the list of functions passed to\n<a href=\"#assert_tracker_calls_fn_exact\"><code>tracker.calls()</code></a> and will throw an error for functions that\nhave not been called the expected number of times.</p>\n<pre><code class=\"language-js\">const assert = require('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": "<p>Creates a new <a href=\"#assert_class_assert_calltracker\"><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#process_event_exit\"><code>process.on('exit')</code></a> handler.</p>\n<pre><code class=\"language-js\">const assert = require('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>"
+            }
           ]
         }
       ],
@@ -266,6 +276,16 @@
               "v0.1.21"
             ],
             "changes": [
+              {
+                "version": "v14.18.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 in case both sides are NaN."
+              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/25008",
@@ -274,25 +294,34 @@
               {
                 "version": "v9.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/15001",
-                "description": "The `Error` names and messages are now properly compared"
+                "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"
+                "description": "The `Set` and `Map` content is also compared."
               },
               {
-                "version": "v6.4.0, v4.7.1",
+                "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",
+                "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",
+                "version": [
+                  "v5.10.1",
+                  "v4.4.3"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/5910",
                 "description": "Handle non-`Uint8Array` typed arrays correctly."
               }
@@ -319,12 +348,12 @@
               ]
             }
           ],
-          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 0 - Deprecated: Use <a href=\"#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters. Consider\nusing <a href=\"#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a> instead. <a href=\"#assert_assert_deepequal_actual_expected_message\"><code>assert.deepEqual()</code></a> can have\nsurprising results.</p>\n<p><em>Deep equality</em> means that the enumerable \"own\" properties of child objects\nare also recursively evaluated by the following rules.</p>",
+          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 3 - Legacy: Use <a href=\"#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters. Consider\nusing <a href=\"#assert_assert_deepstrictequal_actual_expected_message\"><code>assert.deepStrictEqual()</code></a> instead. <a href=\"#assert_assert_deepequal_actual_expected_message\"><code>assert.deepEqual()</code></a> can have\nsurprising results.</p>\n<p><em>Deep equality</em> means that the enumerable \"own\" properties of child objects\nare also recursively evaluated by the following rules.</p>",
           "modules": [
             {
               "textRaw": "Comparison details",
               "name": "comparison_details",
-              "desc": "<ul>\n<li>Primitive values are compared with the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>==</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#errors_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>\n<p>The following example does not throw an <a href=\"#assert_class_assert_assertionerror\"><code>AssertionError</code></a> because the\nprimitives are considered equal by the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>==</code> ).</p>\n<pre><code class=\"language-js\">// WARNING: This does not throw an AssertionError!\nassert.deepEqual('+00000000', false);\n</code></pre>\n<p>\"Deep\" equality means that the enumerable \"own\" properties of child objects\nare evaluated also:</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are not equal, an <a href=\"#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<a href=\"#assert_class_assert_assertionerror\"><code>AssertionError</code></a>.</p>",
+              "desc": "<ul>\n<li>Primitive values are compared with the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>==</code> ) with 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#errors_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>\n<p>The following example does not throw an <a href=\"#assert_class_assert_assertionerror\"><code>AssertionError</code></a> because the\nprimitives are considered equal by the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>==</code> ).</p>\n<pre><code class=\"language-js\">// WARNING: This does not throw an AssertionError!\nassert.deepEqual('+00000000', false);\n</code></pre>\n<p>\"Deep\" equality means that the enumerable \"own\" properties of child objects\nare evaluated also:</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are not equal, an <a href=\"#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<a href=\"#assert_class_assert_assertionerror\"><code>AssertionError</code></a>.</p>",
               "type": "module",
               "displayName": "Comparison details"
             }
@@ -352,15 +381,18 @@
               {
                 "version": "v8.5.0",
                 "pr-url": "https://github.com/nodejs/node/pull/15001",
-                "description": "The `Error` names and messages are now properly compared"
+                "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"
+                "description": "The `Set` and `Map` content is also compared."
               },
               {
-                "version": "v6.4.0, v4.7.1",
+                "version": [
+                  "v6.4.0",
+                  "v4.7.1"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/8002",
                 "description": "Typed array slices are handled correctly now."
               },
@@ -370,7 +402,10 @@
                 "description": "Objects with circular references can be used as inputs now."
               },
               {
-                "version": "v5.10.1, v4.4.3",
+                "version": [
+                  "v5.10.1",
+                  "v4.4.3"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/5910",
                 "description": "Handle non-`Uint8Array` typed arrays correctly."
               }
@@ -414,6 +449,7 @@
           "name": "doesNotMatch",
           "meta": {
             "added": [
+              "v13.6.0",
               "v12.16.0"
             ],
             "changes": []
@@ -486,7 +522,10 @@
             ],
             "changes": [
               {
-                "version": "v5.11.0, v4.4.5",
+                "version": [
+                  "v5.11.0",
+                  "v4.4.5"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/2407",
                 "description": "The `message` parameter is respected now."
               },
@@ -528,7 +567,18 @@
             "added": [
               "v0.1.21"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.18.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 in case both sides are NaN."
+              }
+            ]
           },
           "signatures": [
             {
@@ -551,7 +601,7 @@
               ]
             }
           ],
-          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"#assert_assert_strictequal_actual_expected_message\"><code>assert.strictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 0 - Deprecated: Use <a href=\"#assert_assert_strictequal_actual_expected_message\"><code>assert.strictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests shallow, coercive equality between the <code>actual</code> and <code>expected</code> parameters\nusing the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a> ( <code>==</code> ).</p>\n<pre><code class=\"language-js\">const assert = require('assert');\n\nassert.equal(1, 1);\n// OK, 1 == 1\nassert.equal(1, '1');\n// OK, 1 == '1'\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<p>If the values are not equal, an <a href=\"#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.</p>"
+          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"#assert_assert_strictequal_actual_expected_message\"><code>assert.strictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 3 - Legacy: Use <a href=\"#assert_assert_strictequal_actual_expected_message\"><code>assert.strictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests shallow, coercive equality between the <code>actual</code> and <code>expected</code> parameters\nusing the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a> ( <code>==</code> ). <code>NaN</code> is special handled\nand treated as being identical in case both sides are <code>NaN</code>.</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are not equal, an <a href=\"#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.</p>"
         },
         {
           "textRaw": "`assert.fail([message])`",
@@ -670,6 +720,7 @@
           "name": "match",
           "meta": {
             "added": [
+              "v13.6.0",
               "v12.16.0"
             ],
             "changes": []
@@ -708,28 +759,47 @@
               "v0.1.21"
             ],
             "changes": [
+              {
+                "version": "v14.18.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 in case 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"
+                "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"
+                "description": "The `Set` and `Map` content is also compared."
               },
               {
-                "version": "v6.4.0, v4.7.1",
+                "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",
+                "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",
+                "version": [
+                  "v5.10.1",
+                  "v4.4.3"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/5910",
                 "description": "Handle non-`Uint8Array` typed arrays correctly."
               }
@@ -756,7 +826,7 @@
               ]
             }
           ],
-          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"#assert_assert_notdeepstrictequal_actual_expected_message\"><code>assert.notDeepStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 0 - Deprecated: Use <a href=\"#assert_assert_notdeepstrictequal_actual_expected_message\"><code>assert.notDeepStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests for any deep inequality. Opposite of <a href=\"#assert_assert_deepequal_actual_expected_message\"><code>assert.deepEqual()</code></a>.</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are deeply equal, an <a href=\"#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown\ninstead of the <code>AssertionError</code>.</p>"
+          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"#assert_assert_notdeepstrictequal_actual_expected_message\"><code>assert.notDeepStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 3 - Legacy: Use <a href=\"#assert_assert_notdeepstrictequal_actual_expected_message\"><code>assert.notDeepStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests for any deep inequality. Opposite of <a href=\"#assert_assert_deepequal_actual_expected_message\"><code>assert.deepEqual()</code></a>.</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are deeply equal, an <a href=\"#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown\ninstead of the <code>AssertionError</code>.</p>"
         },
         {
           "textRaw": "`assert.notDeepStrictEqual(actual, expected[, message])`",
@@ -780,15 +850,18 @@
               {
                 "version": "v9.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/15001",
-                "description": "The `Error` names and messages are now properly compared"
+                "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"
+                "description": "The `Set` and `Map` content is also compared."
               },
               {
-                "version": "v6.4.0, v4.7.1",
+                "version": [
+                  "v6.4.0",
+                  "v4.7.1"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/8002",
                 "description": "Typed array slices are handled correctly now."
               },
@@ -798,7 +871,10 @@
                 "description": "Objects with circular references can be used as inputs now."
               },
               {
-                "version": "v5.10.1, v4.4.3",
+                "version": [
+                  "v5.10.1",
+                  "v4.4.3"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/5910",
                 "description": "Handle non-`Uint8Array` typed arrays correctly."
               }
@@ -835,7 +911,18 @@
             "added": [
               "v0.1.21"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.18.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 in case both sides are NaN."
+              }
+            ]
           },
           "signatures": [
             {
@@ -858,7 +945,7 @@
               ]
             }
           ],
-          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"#assert_assert_notstrictequal_actual_expected_message\"><code>assert.notStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 0 - Deprecated: Use <a href=\"#assert_assert_notstrictequal_actual_expected_message\"><code>assert.notStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests shallow, coercive inequality with the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n( <code>!=</code> ).</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are equal, an <a href=\"#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.</p>"
+          "desc": "<p><strong>Strict assertion mode</strong></p>\n<p>An alias of <a href=\"#assert_assert_notstrictequal_actual_expected_message\"><code>assert.notStrictEqual()</code></a>.</p>\n<p><strong>Legacy assertion mode</strong></p>\n<blockquote>\n<p>Stability: 3 - Legacy: Use <a href=\"#assert_assert_notstrictequal_actual_expected_message\"><code>assert.notStrictEqual()</code></a> instead.</p>\n</blockquote>\n<p>Tests shallow, coercive inequality with the <a href=\"https://tc39.github.io/ecma262/#sec-abstract-equality-comparison\">Abstract Equality Comparison</a>\n(<code>!=</code> ). <code>NaN</code> is special handled and treated as being identical in case both\nsides are <code>NaN</code>.</p>\n<pre><code class=\"language-js\">const assert = require('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<p>If the values are equal, an <a href=\"#assert_class_assert_assertionerror\"><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#errors_class_error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.</p>"
         },
         {
           "textRaw": "`assert.notStrictEqual(actual, expected[, message])`",
@@ -872,7 +959,7 @@
               {
                 "version": "v10.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/17003",
-                "description": "Used comparison changed from Strict Equality to `Object.is()`"
+                "description": "Used comparison changed from Strict Equality to `Object.is()`."
               }
             ]
           },
@@ -978,7 +1065,7 @@
               {
                 "version": "v10.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/17003",
-                "description": "Used comparison changed from Strict Equality to `Object.is()`"
+                "description": "Used comparison changed from Strict Equality to `Object.is()`."
               }
             ]
           },
diff --git a/doc/api/assert.md b/doc/api/assert.md
index 5f90f90bc9af8db5883924a7147544cfc19edafa..82af718884a1099d7c2bf109e7d76b2c4f42a26d 100644
--- a/doc/api/assert.md
+++ b/doc/api/assert.md
@@ -13,7 +13,10 @@ invariants.
 <!-- YAML
 added: v9.9.0
 changes:
-  - version: v12.16.2
+  - 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".
@@ -62,7 +65,7 @@ assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
 To deactivate the colors, use the `NO_COLOR` or `NODE_DISABLE_COLORS`
 environment variables. This will also deactivate the colors in the REPL. For
 more on color support in terminal environments, read the tty
-[getColorDepth()](tty.html#tty_writestream_getcolordepth_env) documentation.
+[getColorDepth()](tty.md#tty_writestream_getcolordepth_env) documentation.
 
 ## Legacy assertion mode
 
@@ -151,16 +154,16 @@ try {
 
 ## Class: `assert.CallTracker`
 <!-- YAML
-added: v12.19.0
+added: v14.2.0
 -->
 
 > Stability: 1 - Experimental
 
 This feature is currently experimental and behavior might still change.
 
-### `new assert.CallTracker()`
+### `new assert.CallTracker()`
 <!-- YAML
-added: v12.19.0
+added: v14.2.0
 -->
 
 Creates a new [`CallTracker`][] object which can be used to track if functions
@@ -189,7 +192,7 @@ process.on('exit', () => {
 
 ### `tracker.calls([fn][, exact])`
 <!-- YAML
-added: v12.19.0
+added: v14.2.0
 -->
 
 * `fn` {Function} **Default** A no-op function.
@@ -216,11 +219,11 @@ const callsfunc = tracker.calls(func);
 
 ### `tracker.report()`
 <!-- YAML
-added: v12.19.0
+added: v14.2.0
 -->
 
 * Returns: {Array} of objects containing information about the wrapper functions
-returned by [`tracker.calls()`][].
+  returned by [`tracker.calls()`][].
 * Object {Object}
   * `message` {string}
   * `actual` {number} The actual number of times the function was called.
@@ -262,7 +265,7 @@ tracker.report();
 
 ### `tracker.verify()`
 <!-- YAML
-added: v12.19.0
+added: v14.2.0
 -->
 
 Iterates through the list of functions passed to
@@ -301,23 +304,37 @@ An alias of [`assert.ok()`][].
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: v14.18.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 in case 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
+    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
+    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
+  - 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
+  - version:
+    - v5.10.1
+    - v4.4.3
     pr-url: https://github.com/nodejs/node/pull/5910
     description: Handle non-`Uint8Array` typed arrays correctly.
 -->
@@ -332,7 +349,7 @@ An alias of [`assert.deepStrictEqual()`][].
 
 **Legacy assertion mode**
 
-> Stability: 0 - Deprecated: Use [`assert.deepStrictEqual()`][] instead.
+> Stability: 3 - Legacy: Use [`assert.deepStrictEqual()`][] instead.
 
 Tests for deep equality between the `actual` and `expected` parameters. Consider
 using [`assert.deepStrictEqual()`][] instead. [`assert.deepEqual()`][] can have
@@ -344,7 +361,8 @@ are also recursively evaluated by the following rules.
 ### Comparison details
 
 * Primitive values are compared with the [Abstract Equality Comparison][]
-  ( `==` ).
+  ( `==` ) with the exception of `NaN`. It is treated as being identical in case
+  both sides are `NaN`.
 * [Type tags][Object.prototype.toString()] of objects should be the same.
 * Only [enumerable "own" properties][] are considered.
 * [`Error`][] names and messages are always compared, even if these are not
@@ -426,17 +444,21 @@ changes:
               comparison.
   - version: v8.5.0
     pr-url: https://github.com/nodejs/node/pull/15001
-    description: The `Error` names and messages are now properly compared
+    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
+    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
+  - version:
+    - v5.10.1
+    - v4.4.3
     pr-url: https://github.com/nodejs/node/pull/5910
     description: Handle non-`Uint8Array` typed arrays correctly.
 -->
@@ -568,7 +590,9 @@ parameter is an instance of an [`Error`][] then it will be thrown instead of the
 
 ## `assert.doesNotMatch(string, regexp[, message])`
 <!-- YAML
-added: v12.16.0
+added:
+  - v13.6.0
+  - v12.16.0
 -->
 
 * `string` {string}
@@ -656,7 +680,9 @@ assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
 <!-- YAML
 added: v0.1.21
 changes:
-  - version: v5.11.0, v4.4.5
+  - 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
@@ -731,6 +757,15 @@ assert.doesNotThrow(
 ## `assert.equal(actual, expected[, message])`
 <!-- YAML
 added: v0.1.21
+changes:
+  - version: v14.18.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 in case both sides are
+                 NaN.
 -->
 
 * `actual` {any}
@@ -743,10 +778,11 @@ An alias of [`assert.strictEqual()`][].
 
 **Legacy assertion mode**
 
-> Stability: 0 - Deprecated: Use [`assert.strictEqual()`][] instead.
+> Stability: 3 - Legacy: Use [`assert.strictEqual()`][] instead.
 
 Tests shallow, coercive equality between the `actual` and `expected` parameters
-using the [Abstract Equality Comparison][] ( `==` ).
+using the [Abstract Equality Comparison][] ( `==` ). `NaN` is special handled
+and treated as being identical in case both sides are `NaN`.
 
 ```js
 const assert = require('assert');
@@ -755,6 +791,8 @@ assert.equal(1, 1);
 // OK, 1 == 1
 assert.equal(1, '1');
 // OK, 1 == '1'
+assert.equal(NaN, NaN);
+// OK
 
 assert.equal(1, 2);
 // AssertionError: 1 == 2
@@ -907,7 +945,9 @@ let err;
 
 ## `assert.match(string, regexp[, message])`
 <!-- YAML
-added: v12.16.0
+added:
+  - v13.6.0
+  - v12.16.0
 -->
 
 * `string` {string}
@@ -945,19 +985,33 @@ instance of an [`Error`][] then it will be thrown instead of the
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: v14.18.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 in case 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
+    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
+    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
+  - 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
+  - version:
+    - v5.10.1
+    - v4.4.3
     pr-url: https://github.com/nodejs/node/pull/5910
     description: Handle non-`Uint8Array` typed arrays correctly.
 -->
@@ -972,7 +1026,7 @@ An alias of [`assert.notDeepStrictEqual()`][].
 
 **Legacy assertion mode**
 
-> Stability: 0 - Deprecated: Use [`assert.notDeepStrictEqual()`][] instead.
+> Stability: 3 - Legacy: Use [`assert.notDeepStrictEqual()`][] instead.
 
 Tests for any deep inequality. Opposite of [`assert.deepEqual()`][].
 
@@ -1029,17 +1083,21 @@ changes:
               comparison.
   - version: v9.0.0
     pr-url: https://github.com/nodejs/node/pull/15001
-    description: The `Error` names and messages are now properly compared
+    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
+    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
+  - version:
+    - v5.10.1
+    - v4.4.3
     pr-url: https://github.com/nodejs/node/pull/5910
     description: Handle non-`Uint8Array` typed arrays correctly.
 -->
@@ -1066,6 +1124,15 @@ instead of the [`AssertionError`][].
 ## `assert.notEqual(actual, expected[, message])`
 <!-- YAML
 added: v0.1.21
+changes:
+  - version: v14.18.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 in case both sides are
+                 NaN.
 -->
 
 * `actual` {any}
@@ -1078,10 +1145,11 @@ An alias of [`assert.notStrictEqual()`][].
 
 **Legacy assertion mode**
 
-> Stability: 0 - Deprecated: Use [`assert.notStrictEqual()`][] instead.
+> Stability: 3 - Legacy: Use [`assert.notStrictEqual()`][] instead.
 
 Tests shallow, coercive inequality with the [Abstract Equality Comparison][]
-( `!=` ).
+(`!=` ). `NaN` is special handled and treated as being identical in case both
+sides are `NaN`.
 
 ```js
 const assert = require('assert');
@@ -1108,7 +1176,7 @@ 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()`
+    description: Used comparison changed from Strict Equality to `Object.is()`.
 -->
 
 * `actual` {any}
@@ -1287,7 +1355,7 @@ 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()`
+    description: Used comparison changed from Strict Equality to `Object.is()`.
 -->
 
 * `actual` {any}
@@ -1527,20 +1595,25 @@ assert.throws(throwingFirst, /Second$/);
 Due to the confusing error-prone notation, avoid a string as the second
 argument.
 
+[Abstract Equality Comparison]: https://tc39.github.io/ecma262/#sec-abstract-equality-comparison
+[Object wrappers]: https://developer.mozilla.org/en-US/docs/Glossary/Primitive#Primitive_wrapper_objects_in_JavaScript
+[Object.prototype.toString()]: https://tc39.github.io/ecma262/#sec-object.prototype.tostring
+[SameValue Comparison]: https://tc39.github.io/ecma262/#sec-samevalue
+[Strict Equality Comparison]: https://tc39.github.io/ecma262/#sec-strict-equality-comparison
 [`AssertionError`]: #assert_class_assert_assertionerror
+[`CallTracker`]: #assert_class_assert_calltracker
 [`Class`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
-[`ERR_INVALID_RETURN_VALUE`]: errors.html#errors_err_invalid_return_value
-[`Error.captureStackTrace`]: errors.html#errors_error_capturestacktrace_targetobject_constructoropt
-[`Error`]: errors.html#errors_class_error
+[`ERR_INVALID_RETURN_VALUE`]: errors.md#errors_err_invalid_return_value
+[`Error.captureStackTrace`]: errors.md#errors_error_capturestacktrace_targetobject_constructoropt
+[`Error`]: errors.md#errors_class_error
 [`Map`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
 [`Object.is()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
 [`RegExp`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
 [`Set`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
 [`Symbol`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol
-[`TypeError`]: errors.html#errors_class_typeerror
+[`TypeError`]: errors.md#errors_class_typeerror
 [`WeakMap`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
 [`WeakSet`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet
-[`CallTracker`]: #assert_class_assert_calltracker
 [`assert.deepEqual()`]: #assert_assert_deepequal_actual_expected_message
 [`assert.deepStrictEqual()`]: #assert_assert_deepstrictequal_actual_expected_message
 [`assert.doesNotThrow()`]: #assert_assert_doesnotthrow_fn_error_message
@@ -1552,14 +1625,9 @@ argument.
 [`assert.ok()`]: #assert_assert_ok_value_message
 [`assert.strictEqual()`]: #assert_assert_strictequal_actual_expected_message
 [`assert.throws()`]: #assert_assert_throws_fn_error_message
-[`process.on('exit')`]: process.html#process_event_exit
+[`process.on('exit')`]: process.md#process_event_exit
 [`tracker.calls()`]: #assert_tracker_calls_fn_exact
 [`tracker.verify()`]: #assert_tracker_verify
-[strict assertion mode]: #assert_strict_assertion_mode
-[Abstract Equality Comparison]: https://tc39.github.io/ecma262/#sec-abstract-equality-comparison
-[Object wrappers]: https://developer.mozilla.org/en-US/docs/Glossary/Primitive#Primitive_wrapper_objects_in_JavaScript
-[Object.prototype.toString()]: https://tc39.github.io/ecma262/#sec-object.prototype.tostring
-[SameValue Comparison]: https://tc39.github.io/ecma262/#sec-samevalue
-[Strict Equality Comparison]: https://tc39.github.io/ecma262/#sec-strict-equality-comparison
 [enumerable "own" properties]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties
 [prototype-spec]: https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots
+[strict assertion mode]: #assert_strict_assertion_mode
diff --git a/doc/api/assets/hljs.css b/doc/api/assets/hljs.css
index 026a93e194efc376c969b7a7bd987d95615bc714..4893f9de26fab4b9e067b49647f594ee7c07af1e 100644
--- a/doc/api/assets/hljs.css
+++ b/doc/api/assets/hljs.css
@@ -8,7 +8,8 @@
 }
 
 .hljs-attribute,
-.hljs-keyword {
+.hljs-keyword,
+.hljs-type {
   color: #338;
 }
 
@@ -28,3 +29,22 @@
   color: #666;
   font-weight: lighter;
 }
+
+.dark-mode .hljs-number,
+.dark-mode .hljs-string,
+.dark-mode .hljs-regexp {
+  color: var(--green4);
+}
+
+.dark-mode .hljs-attribute,
+.dark-mode .hljs-doctag,
+.dark-mode .hljs-keyword,
+.dark-mode .hljs-type {
+  color: #66d9ef;
+}
+
+.dark-mode .hljs-doctag .hljs-type,
+.dark-mode .hljs-doctag .hljs-variable,
+.dark-mode .hljs-comment {
+  color: var(--gray7);
+}
diff --git a/doc/api/assets/js-flavor-cjs.svg b/doc/api/assets/js-flavor-cjs.svg
new file mode 100644
index 0000000000000000000000000000000000000000..800c1516423059fa20e1fb0c96b9e3e6b6f42973
--- /dev/null
+++ b/doc/api/assets/js-flavor-cjs.svg
@@ -0,0 +1,5 @@
+<!--
+ * Font Awesome Free 5.15.2 by @fontawesome - https://fontawesome.com
+ * License - https://fontawesome.com/license/free - CC BY 4.0
+-->
+<svg xmlns="http://www.w3.org/2000/svg" width="2719" height="384"><path d="M1191.326 384h192c106 0 192-86 192-192s-86-192-192-192h-192c-106 0-192 86-192 192s86 192 192 192zm0-320c70.8 0 128 57.3 128 128 0 70.8-57.3 128-128 128-70.8 0-128-57.3-128-128 0-70.8 57.3-128 128-128z"/><text stroke-width="42" font-family="sans-serif" font-weight="lighter" font-size="490" y="370">CJS</text><text stroke-width="42" font-weight="lighter" font-family="sans-serif" font-size="490" y="370" x="1682">ESM</text></svg>
diff --git a/doc/api/assets/js-flavor-esm.svg b/doc/api/assets/js-flavor-esm.svg
new file mode 100644
index 0000000000000000000000000000000000000000..bcea3ba100698a4e2c111e5c1f197532ff1b0c3d
--- /dev/null
+++ b/doc/api/assets/js-flavor-esm.svg
@@ -0,0 +1,5 @@
+<!--
+ * Font Awesome Free 5.15.2 by @fontawesome - https://fontawesome.com
+ * License - https://fontawesome.com/license/free - CC BY 4.0
+-->
+<svg xmlns="http://www.w3.org/2000/svg" height="384" width="2719"><defs><path d="M-136.321-230.336h2994.365v653.401H-136.321z"/></defs><path d="M1383.326 0h-192c-106 0-192 86-192 192s86 192 192 192h192c106 0 192-86 192-192s-86-192-192-192zm0 320c-70.8 0-128-57.3-128-128 0-70.8 57.3-128 128-128 70.8 0 128 57.3 128 128 0 70.8-57.3 128-128 128z"/><text stroke-width="42" font-family="sans-serif" font-weight="lighter" font-size="490" y="370">CJS</text><text stroke-width="42" font-weight="lighter" font-family="sans-serif" font-size="490" y="370" x="1682">ESM</text></svg>
diff --git a/doc/api/assets/style.css b/doc/api/assets/style.css
index af170888be8f38e0a80e5abc9733c538eda89095..6faeb59efc04ddc55a6ebd75c17413cb6827e308 100644
--- a/doc/api/assets/style.css
+++ b/doc/api/assets/style.css
@@ -1,3 +1,61 @@
+/*--------------------- CSS Variables ----------------------------*/
+:root {
+  --black: #000000;
+  --black1: #090c15;
+  --black2: #2c3437;
+  --black3: #0d111d;
+  --blue1: #00f;
+  --white: #ffffff;
+  --white-smoke: #f2f2f2;
+  --grey-smoke: #e9edf0;
+  --red1: #d60027;
+  --red2: #d50027;
+  --red3: #ca5010;
+  --green1: #3e7a38;
+  --green2: #5a8147;
+  --green3: #64de64;
+  --green4: #99cc7d;
+  --green5: #84ba64;
+  --gray1: #707070;
+  --gray2: #b4b4b4;
+  --gray3: #cccccc;
+  --gray4: #040404;
+  --gray5: #7a7a7a;
+  --gray6: #333333;
+  --gray7: #c1c1c1;
+  --grey8: #ddd;
+
+  --background-color-api-stability-link: rgba(255, 255, 255, .4);
+  --background-color-highlight: var(--white-smoke);
+  --color-brand-primary: var(--gray6);
+  --color-brand-secondary: var(--green1);
+  --color-fill-app: var(--white);
+  --color-fill-side-nav: var(--gray6);
+  --color-links: var(--green1);
+  --color-text-mark: var(--gray1);
+  --color-text-nav: var(--gray3);
+  --color-text-primary: var(--gray6);
+  --color-text-secondary: var(--green2);
+}
+
+.dark-mode {
+  --background-color-highlight: var(--black2);
+  --color-fill-app: var(--black1);
+  --color-fill-side-nav: var(--black3);
+  --color-links: var(--green5);
+  --color-text-mark: var(--gray5);
+  --color-text-primary: var(--white);
+}
+
+.dark-mode code,
+.dark-mode tt {
+  color: var(--grey-smoke);
+  background-color: var(--background-color-highlight);
+}
+.dark-mode a code {
+  color: var(--green3);
+}
+
 /*--------------------- Layout and Typography ----------------------------*/
 html {
   font-size: 1rem;
@@ -16,8 +74,8 @@ body {
   font-family: Lato, "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", Verdana, Tahoma, sans-serif;
   margin: 0;
   padding: 0;
-  color: #333;
-  background-color: #fff;
+  color: var(--color-text-primary);
+  background-color: var(--color-fill-app);
 }
 
 h1, h1 code { font-size: 2.5rem; }
@@ -67,7 +125,7 @@ a.type {
 a:link,
 a:active,
 a:visited {
-  color: #43853d;
+  color: var(--color-links);
   text-decoration: none;
   border-radius: 2px;
   padding: 1px 3px;
@@ -75,8 +133,8 @@ a:visited {
 
 a:hover,
 a:focus {
-  color: #fff;
-  background-color: #43853d;
+  color: var(--white);
+  background-color:var(--green1);
   outline: none;
 }
 
@@ -109,7 +167,7 @@ em code {
 
 #gtoc > ul > li {
   display: inline;
-  border-right: 1px #000 solid;
+  border-right: 1px currentColor solid;
   margin-right: .4rem;
   padding-right: .4rem;
 }
@@ -138,8 +196,8 @@ li.version-picker a span {
 }
 
 ol.version-picker {
-  background-color: #fff;
-  border: 1px solid #43853d;
+  background-color: var(--color-fill-app);
+  border: 1px solid var(--color-brand-secondary);
   border-radius: 0 0 2px 2px;
   display: none;
   list-style: none;
@@ -175,14 +233,14 @@ ol.version-picker li:last-child a {
 }
 
 .api_stability {
-  color: #fff !important;
+  color: var(--white) !important;
   margin: 0 0 1rem;
   padding: 1rem;
   line-height: 1.5;
 }
 
 .api_stability * {
-  color: #fff !important;
+  color: var(--white) !important;
 }
 
 .api_stability a {
@@ -192,7 +250,7 @@ ol.version-picker li:last-child a {
 .api_stability a:hover,
 .api_stability a:active,
 .api_stability a:focus {
-  background-color: rgba(255, 255, 255, .4);
+  background-color: var(--background-color-api-stability-link);
 }
 
 .api_stability a code {
@@ -200,15 +258,23 @@ ol.version-picker li:last-child a {
 }
 
 .api_stability_0 {
-  background-color: #d60027;
+  background-color: var(--red1);
 }
 
 .api_stability_1 {
-  background-color: #ca5010;
+  background-color: var(--red3);
 }
 
 .api_stability_2 {
-  background-color: #5a8147;
+  background-color: var(--green2);
+}
+
+.api_stability_3 {
+  background-color: var(--blue1);
+}
+
+.module_stability {
+  vertical-align: middle;
 }
 
 .api_metadata {
@@ -317,6 +383,11 @@ dd + dt.pre {
   padding-top: 1rem;
 }
 
+#apicontent section {
+  content-visibility: auto;
+  contain-intrinsic-size: 1px 5000px;
+}
+
 #apicontent .line {
   width: calc(50% - 1rem);
   margin: 1rem 1rem .95rem;
@@ -386,7 +457,7 @@ code {
 pre {
   padding: 1rem;
   vertical-align: top;
-  background-color: #f2f2f2;
+  background-color: var(--background-color-highlight);
   margin: 1rem;
   overflow-x: auto;
 }
@@ -409,19 +480,19 @@ code.pre {
 }
 
 #intro a {
-  color: #ddd;
+  color: var(--grey8);
   font-weight: 700;
 }
 
 hr {
   background-color: transparent;
   border: medium none;
-  border-bottom: 1px solid #7a7a7a;
+  border-bottom: 1px solid var(--gray5);
   margin: 0 0 1rem;
 }
 
-#toc h2 {
-  margin: 1.5rem 0;
+#toc > ul {
+  margin-top: 1.5rem;
 }
 
 #toc p {
@@ -442,13 +513,21 @@ hr {
 }
 
 #toc .stability_0::after {
-  background-color: #d50027;
-  color: #fff;
+  background-color: var(--red2);
+  color: var(--white);
   content: "deprecated";
   margin-left: .25rem;
   padding: 1px 3px;
   border-radius: 3px;
 }
+#toc .stability_3::after {
+  background-color: var(--blue1);
+  color: var(--white);
+  content: "legacy";
+  margin-left: .25rem;
+  padding: 1px 3px;
+  border-radius: 3px;
+}
 
 #apicontent li {
   margin-bottom: .5rem;
@@ -488,7 +567,7 @@ a code {
 
 #column2.interior {
   width: 234px;
-  background-color: #333;
+  background-color: var(--color-fill-side-nav);
   position: fixed;
   left: 0;
   top: 0;
@@ -500,7 +579,7 @@ a code {
 #column2 ul {
   list-style: none;
   margin: .9rem 0 .5rem;
-  background-color: #333;
+  background-color: var(--color-fill-side-nav);
 }
 
 #column2 > :first-child {
@@ -531,8 +610,9 @@ a code {
   margin-bottom: 0;
 }
 
-#column2 ul li a {
-  color: #ccc;
+#column2 ul li a,
+#column2 ul li a code {
+  color: var(--color-text-nav);
   border-radius: 0;
 }
 
@@ -540,7 +620,7 @@ a code {
 #column2 ul li a.active:hover,
 #column2 ul li a.active:focus {
   font-weight: 700;
-  color: #fff;
+  color: var(--white);
   background-color: transparent;
 }
 
@@ -548,13 +628,13 @@ a code {
 #intro a:focus,
 #column2 ul li a:hover,
 #column2 ul li a:focus {
-  color: #fff;
+  color: var(--white);
   background-color: transparent;
 }
 
 span > .mark,
 span > .mark:visited {
-  color: #707070;
+  color: var(--color-text-mark);
   position: absolute;
   top: 0;
   right: 0;
@@ -563,7 +643,7 @@ span > .mark:visited {
 span > .mark:hover,
 span > .mark:focus,
 span > .mark:active {
-  color: #43853d;
+  color: var(--color-brand-secondary);
   background-color: transparent;
 }
 
@@ -572,6 +652,20 @@ td > *:last-child {
   margin-bottom: 0;
 }
 
+kbd {
+  background-color: #eee;
+  border-radius: 3px;
+  border: 1px solid #b4b4b4;
+  box-shadow: 0 1px 1px rgba(0, 0, 0, .2);
+  color: #333;
+  display: inline-block;
+  font-size: .85em;
+  font-weight: 700;
+  padding: 2px 4px;
+  white-space: nowrap;
+  vertical-align: middle;
+ }
+
 .changelog > summary {
   margin: .5rem 0;
   padding: .5rem 0;
@@ -587,11 +681,6 @@ td > *:last-child {
   visibility: hidden;
 }
 
-.github_icon {
-  vertical-align: middle;
-  margin: -2px 3px 0 0;
-}
-
 /* API reference sidebar */
 @media only screen and (min-width: 1025px) {
   .apidoc #column2 > .line {
@@ -635,6 +724,23 @@ td > *:last-child {
   }
 }
 
+.header-container {
+  display: flex;
+  align-items: center;
+  margin: 1.5rem 0 1rem;
+  justify-content: space-between;
+}
+
+.header-container h1 {
+  margin: 0;
+}
+
+.theme-toggle-btn {
+  border: none;
+  background: transparent;
+  outline: var(--brand3) dotted 2px;
+}
+
 @media only screen and (max-width: 1024px) {
   #content {
     overflow: visible;
@@ -651,6 +757,56 @@ td > *:last-child {
   }
 }
 
+.icon {
+  cursor: pointer;
+}
+
+.dark-icon {
+  display: block;
+}
+
+.light-icon {
+  fill: var(--white);
+  display: none;
+}
+
+.dark-mode .dark-icon {
+  display: none;
+}
+
+.dark-mode .light-icon {
+  fill: var(--white);
+  display: block;
+}
+
+.js-flavor-selector {
+  -webkit-appearance: none;
+  appearance: none;
+  float: right;
+  background-image: url(./js-flavor-cjs.svg);
+  background-size: contain;
+  background-repeat: no-repeat;
+  width: 142px;
+  height: 20px;
+}
+.js-flavor-selector:checked {
+  background-image: url(./js-flavor-esm.svg);
+}
+.js-flavor-selector:not(:checked) ~ .mjs,
+.js-flavor-selector:checked ~ .cjs {
+  display: none;
+}
+.dark-mode .js-flavor-selector {
+  filter: invert(1);
+}
+@supports (aspect-ratio: 1 / 1) {
+  .js-flavor-selector {
+    height: 1.5em;
+    width: auto;
+    aspect-ratio: 2719 / 384;
+  }
+}
+
 @media print {
   html {
     height: auto;
@@ -701,4 +857,24 @@ td > *:last-child {
   #apicontent {
     overflow: hidden;
   }
+  .js-flavor-selector {
+    display: none;
+  }
+  .js-flavor-selector + * {
+    margin-bottom: 2rem;
+    padding-bottom: 2rem;
+    border-bottom: 1px solid var(--color-text-primary);
+  }
+  .js-flavor-selector ~ * {
+    display: block !important;
+    background-position: top right;
+    background-size: 142px 20px;
+    background-repeat: no-repeat;
+  }
+  .js-flavor-selector ~ .cjs {
+    background-image: url(./js-flavor-cjs.svg);
+  }
+  .js-flavor-selector ~ .mjs {
+    background-image: url(./js-flavor-esm.svg);
+  }
 }
diff --git a/doc/api/async_hooks.html b/doc/api/async_hooks.html
index 4ca7d55db5515229b6ea2bbb59739373aa2992ce..2b8e641b2597d4028b2cef7ca7357547660c6a8b 100644
--- a/doc/api/async_hooks.html
+++ b/doc/api/async_hooks.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Async hooks | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Async hooks | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks active">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="async_hooks" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/async_hooks.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/async_hooks.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/async_hooks.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/async_hooks.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/async_hooks.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/async_hooks.html">13.x</a></li>
@@ -112,30 +127,23 @@
 <li><a href="https://nodejs.org/docs/latest-v8.x/api/async_hooks.html">8.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/async_hooks.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/async_hooks.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_1"><a href="#async_hooks_async_hooks">Async hooks</a></span>
 <ul>
 <li><a href="#async_hooks_terminology">Terminology</a></li>
-<li><a href="#async_hooks_public_api">Public API</a>
-<ul>
-<li><a href="#async_hooks_overview">Overview</a>
-<ul>
+<li><a href="#async_hooks_overview">Overview</a></li>
 <li><a href="#async_hooks_async_hooks_createhook_callbacks"><code>async_hooks.createHook(callbacks)</code></a>
 <ul>
 <li><a href="#async_hooks_error_handling">Error handling</a></li>
 <li><a href="#async_hooks_printing_in_asynchooks_callbacks">Printing in AsyncHooks callbacks</a></li>
 </ul>
 </li>
-</ul>
-</li>
 <li><a href="#async_hooks_class_asynchook">Class: <code>AsyncHook</code></a>
 <ul>
 <li><a href="#async_hooks_asynchook_enable"><code>asyncHook.enable()</code></a></li>
@@ -161,8 +169,6 @@
 <li><a href="#async_hooks_async_hooks_triggerasyncid"><code>async_hooks.triggerAsyncId()</code></a></li>
 </ul>
 </li>
-</ul>
-</li>
 <li><a href="#async_hooks_promise_execution_tracking">Promise execution tracking</a></li>
 <li><a href="#async_hooks_javascript_embedder_api">JavaScript embedder API</a>
 <ul>
@@ -195,18 +201,17 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Async hooks<span><a class="mark" href="#async_hooks_async_hooks" id="async_hooks_async_hooks">#</a></span></h1>
+        <h2>Async hooks<span><a class="mark" href="#async_hooks_async_hooks" id="async_hooks_async_hooks">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/async_hooks.js">lib/async_hooks.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/async_hooks.js">lib/async_hooks.js</a></p>
 <p>The <code>async_hooks</code> module provides an API to track asynchronous resources. It
 can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);</code></pre>
-<h2>Terminology<span><a class="mark" href="#async_hooks_terminology" id="async_hooks_terminology">#</a></span></h2>
+<section><h3>Terminology<span><a class="mark" href="#async_hooks_terminology" id="async_hooks_terminology">#</a></span></h3>
 <p>An asynchronous resource represents an object with an associated callback.
 This callback may be called multiple times, for example, the <code>'connection'</code>
 event in <code>net.createServer()</code>, or just a single time like in <code>fs.open()</code>.
@@ -215,29 +220,28 @@ not explicitly distinguish between these different cases but will represent them
 as the abstract concept that is a resource.</p>
 <p>If <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a>s are used, each thread has an independent <code>async_hooks</code>
 interface, and each thread will use a new set of async IDs.</p>
-<h2>Public API<span><a class="mark" href="#async_hooks_public_api" id="async_hooks_public_api">#</a></span></h2>
-<h3>Overview<span><a class="mark" href="#async_hooks_overview" id="async_hooks_overview">#</a></span></h3>
+</section><section><h3>Overview<span><a class="mark" href="#async_hooks_overview" id="async_hooks_overview">#</a></span></h3>
 <p>Following is a simple overview of the public API.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
 <span class="hljs-comment">// Return the ID of the current execution context.</span>
-<span class="hljs-keyword">const</span> eid = async_hooks.executionAsyncId();
+<span class="hljs-keyword">const</span> eid = async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
 
 <span class="hljs-comment">// Return the ID of the handle responsible for triggering the callback of the</span>
 <span class="hljs-comment">// current execution scope to call.</span>
-<span class="hljs-keyword">const</span> tid = async_hooks.triggerAsyncId();
+<span class="hljs-keyword">const</span> tid = async_hooks.<span class="hljs-title function_">triggerAsyncId</span>();
 
 <span class="hljs-comment">// Create a new AsyncHook instance. All of these callbacks are optional.</span>
 <span class="hljs-keyword">const</span> asyncHook =
-    async_hooks.createHook({ init, before, after, destroy, promiseResolve });
+    async_hooks.<span class="hljs-title function_">createHook</span>({ init, before, after, destroy, promiseResolve });
 
 <span class="hljs-comment">// Allow callbacks of this AsyncHook instance to call. This is not an implicit</span>
 <span class="hljs-comment">// action after running the constructor, and must be explicitly run to begin</span>
 <span class="hljs-comment">// executing callbacks.</span>
-asyncHook.enable();
+asyncHook.<span class="hljs-title function_">enable</span>();
 
 <span class="hljs-comment">// Disable listening for new asynchronous events.</span>
-asyncHook.disable();
+asyncHook.<span class="hljs-title function_">disable</span>();
 
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// The following are the callbacks that can be passed to createHook().</span>
@@ -246,24 +250,24 @@ asyncHook.disable();
 <span class="hljs-comment">// init is called during object construction. The resource may not have</span>
 <span class="hljs-comment">// completed construction when this callback runs, therefore all fields of the</span>
 <span class="hljs-comment">// resource referenced by "asyncId" may not have been populated.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) </span>{ }
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) { }
 
 <span class="hljs-comment">// Before is called just before the resource's callback is called. It can be</span>
-<span class="hljs-comment">// called 0-N times for handles (e.g. TCPWrap), and will be called exactly 1</span>
-<span class="hljs-comment">// time for requests (e.g. FSReqCallback).</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">before</span>(<span class="hljs-params">asyncId</span>) </span>{ }
+<span class="hljs-comment">// called 0-N times for handles (such as TCPWrap), and will be called exactly 1</span>
+<span class="hljs-comment">// time for requests (such as FSReqCallback).</span>
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">before</span>(<span class="hljs-params">asyncId</span>) { }
 
 <span class="hljs-comment">// After is called just after the resource's callback has finished.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">after</span>(<span class="hljs-params">asyncId</span>) </span>{ }
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">after</span>(<span class="hljs-params">asyncId</span>) { }
 
 <span class="hljs-comment">// Destroy is called when the resource is destroyed.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">destroy</span>(<span class="hljs-params">asyncId</span>) </span>{ }
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">destroy</span>(<span class="hljs-params">asyncId</span>) { }
 
 <span class="hljs-comment">// promiseResolve is called only for promise resources, when the</span>
 <span class="hljs-comment">// `resolve` function passed to the `Promise` constructor is invoked</span>
 <span class="hljs-comment">// (either directly or through other means of resolving a promise).</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">promiseResolve</span>(<span class="hljs-params">asyncId</span>) </span>{ }</code></pre>
-<h4><code>async_hooks.createHook(callbacks)</code><span><a class="mark" href="#async_hooks_async_hooks_createhook_callbacks" id="async_hooks_async_hooks_createhook_callbacks">#</a></span></h4>
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">promiseResolve</span>(<span class="hljs-params">asyncId</span>) { }</code></pre>
+</section><section><h3><code>async_hooks.createHook(callbacks)</code><span><a class="mark" href="#async_hooks_async_hooks_createhook_callbacks" id="async_hooks_async_hooks_createhook_callbacks">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.1.0</span>
 </div>
@@ -289,23 +293,26 @@ specifics of all functions that can be passed to <code>callbacks</code> is in th
 <a href="#async_hooks_hook_callbacks">Hook Callbacks</a> section.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-keyword">const</span> asyncHook = async_hooks.createHook({
-  init(asyncId, type, triggerAsyncId, resource) { },
-  destroy(asyncId) { }
+<span class="hljs-keyword">const</span> asyncHook = async_hooks.<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) { },
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">asyncId</span>) { }
 });</code></pre>
 <p>The callbacks will be inherited via the prototype chain:</p>
-<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyAsyncCallbacks</span> </span>{
-  init(asyncId, type, triggerAsyncId, resource) { }
-  destroy(asyncId) {}
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">MyAsyncCallbacks</span> {
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) { }
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">asyncId</span>) {}
 }
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyAddedCallbacks</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">MyAsyncCallbacks</span> </span>{
-  before(asyncId) { }
-  after(asyncId) { }
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyAddedCallbacks</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">MyAsyncCallbacks</span> {
+  <span class="hljs-title function_">before</span>(<span class="hljs-params">asyncId</span>) { }
+  <span class="hljs-title function_">after</span>(<span class="hljs-params">asyncId</span>) { }
 }
 
-<span class="hljs-keyword">const</span> asyncHook = async_hooks.createHook(<span class="hljs-keyword">new</span> MyAddedCallbacks());</code></pre>
-<h5>Error handling<span><a class="mark" href="#async_hooks_error_handling" id="async_hooks_error_handling">#</a></span></h5>
+<span class="hljs-keyword">const</span> asyncHook = async_hooks.<span class="hljs-title function_">createHook</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">MyAddedCallbacks</span>());</code></pre>
+<p>Because promises are asynchronous resources whose lifecycle is tracked
+via the async hooks mechanism, the <code>init()</code>, <code>before()</code>, <code>after()</code>, and
+<code>destroy()</code> callbacks <em>must not</em> be async functions that return promises.</p>
+<h4>Error handling<span><a class="mark" href="#async_hooks_error_handling" id="async_hooks_error_handling">#</a></span></h4>
 <p>If any <code>AsyncHook</code> callbacks throw, the application will print the stack trace
 and exit. The exit path does follow that of an uncaught exception, but
 all <code>'uncaughtException'</code> listeners are removed, thus forcing the process to
@@ -319,7 +326,7 @@ bring down the process quickly in order to prevent an unintentional abort in the
 future. This is subject to change in the future if a comprehensive analysis is
 performed to ensure an exception can follow the normal control flow without
 unintentional side effects.</p>
-<h5>Printing in AsyncHooks callbacks<span><a class="mark" href="#async_hooks_printing_in_asynchooks_callbacks" id="async_hooks_printing_in_asynchooks_callbacks">#</a></span></h5>
+<h4>Printing in AsyncHooks callbacks<span><a class="mark" href="#async_hooks_printing_in_asynchooks_callbacks" id="async_hooks_printing_in_asynchooks_callbacks">#</a></span></h4>
 <p>Because printing to the console is an asynchronous operation, <code>console.log()</code>
 will cause the AsyncHooks callbacks to be called. Using <code>console.log()</code> or
 similar asynchronous operations inside an AsyncHooks callback function will thus
@@ -330,16 +337,16 @@ it is synchronous.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">debug</span>(<span class="hljs-params">...args</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">debug</span>(<span class="hljs-params">...args</span>) {
   <span class="hljs-comment">// Use a function like this one when debugging inside an AsyncHooks callback</span>
-  fs.writeFileSync(<span class="hljs-string">'log.out'</span>, <span class="hljs-string">`<span class="hljs-subst">${util.format(...args)}</span>\n`</span>, { <span class="hljs-attr">flag</span>: <span class="hljs-string">'a'</span> });
+  fs.<span class="hljs-title function_">writeFileSync</span>(<span class="hljs-string">'log.out'</span>, <span class="hljs-string">`<span class="hljs-subst">${util.format(...args)}</span>\n`</span>, { <span class="hljs-attr">flag</span>: <span class="hljs-string">'a'</span> });
 }</code></pre>
 <p>If an asynchronous operation is needed for logging, it is possible to keep
 track of what caused the asynchronous operation using the information
 provided by AsyncHooks itself. The logging should then be skipped when
 it was the logging itself that caused AsyncHooks callback to call. By
 doing this the otherwise infinite recursion is broken.</p>
-<h3>Class: <code>AsyncHook</code><span><a class="mark" href="#async_hooks_class_asynchook" id="async_hooks_class_asynchook">#</a></span></h3>
+</section><section><h3>Class: <code>AsyncHook</code><span><a class="mark" href="#async_hooks_class_asynchook" id="async_hooks_class_asynchook">#</a></span></h3>
 <p>The class <code>AsyncHook</code> exposes an interface for tracking lifetime events
 of asynchronous operations.</p>
 <h4><code>asyncHook.enable()</code><span><a class="mark" href="#async_hooks_asynchook_enable" id="async_hooks_asynchook_enable">#</a></span></h4>
@@ -347,12 +354,12 @@ of asynchronous operations.</p>
 <li>Returns: <a href="async_hooks.html#async_hooks_async_hooks_createhook_callbacks" class="type">&#x3C;AsyncHook></a> A reference to <code>asyncHook</code>.</li>
 </ul>
 <p>Enable the callbacks for a given <code>AsyncHook</code> instance. If no callbacks are
-provided enabling is a noop.</p>
+provided, enabling is a no-op.</p>
 <p>The <code>AsyncHook</code> instance is disabled by default. If the <code>AsyncHook</code> instance
 should be enabled immediately after creation, the following pattern can be used.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-keyword">const</span> hook = async_hooks.createHook(callbacks).enable();</code></pre>
+<span class="hljs-keyword">const</span> hook = async_hooks.<span class="hljs-title function_">createHook</span>(callbacks).<span class="hljs-title function_">enable</span>();</code></pre>
 <h4><code>asyncHook.disable()</code><span><a class="mark" href="#async_hooks_asynchook_disable" id="async_hooks_asynchook_disable">#</a></span></h4>
 <ul>
 <li>Returns: <a href="async_hooks.html#async_hooks_async_hooks_createhook_callbacks" class="type">&#x3C;AsyncHook></a> A reference to <code>asyncHook</code>.</li>
@@ -381,7 +388,7 @@ exists.</p>
 <p>This behavior can be observed by doing something like opening a resource then
 closing it before the resource can be used. The following snippet demonstrates
 this.</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer().listen(<span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{ <span class="hljs-built_in">this</span>.close(); });
+<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-title function_">createServer</span>().<span class="hljs-title function_">listen</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) { <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">close</span>(); });
 <span class="hljs-comment">// OR</span>
 <span class="hljs-built_in">clearTimeout</span>(<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {}, <span class="hljs-number">10</span>));</code></pre>
 <p>Every new resource is assigned an ID that is unique within the scope of the
@@ -407,16 +414,18 @@ the new resource to initialize and that caused <code>init</code> to call. This i
 from <code>async_hooks.executionAsyncId()</code> that only shows <em>when</em> a resource was
 created, while <code>triggerAsyncId</code> shows <em>why</em> a resource was created.</p>
 <p>The following is a simple demonstration of <code>triggerAsyncId</code>:</p>
-<pre><code class="language-js">async_hooks.createHook({
-  init(asyncId, type, triggerAsyncId) {
-    <span class="hljs-keyword">const</span> eid = async_hooks.executionAsyncId();
-    fs.writeSync(
-      process.stdout.fd,
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { fd } = process.<span class="hljs-property">stdout</span>;
+
+async_hooks.<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId</span>) {
+    <span class="hljs-keyword">const</span> eid = async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
+    fs.<span class="hljs-title function_">writeSync</span>(
+      fd,
       <span class="hljs-string">`<span class="hljs-subst">${type}</span>(<span class="hljs-subst">${asyncId}</span>): trigger: <span class="hljs-subst">${triggerAsyncId}</span> execution: <span class="hljs-subst">${eid}</span>\n`</span>);
   }
-}).enable();
+}).<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {}).listen(<span class="hljs-number">8080</span>);</code></pre>
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8080</span>);</code></pre>
 <p>Output when hitting the server with <code>nc localhost 8080</code>:</p>
 <pre><code class="language-console">TCPSERVERWRAP(5): trigger: 1 execution: 1
 TCPWRAP(7): trigger: 5 execution: 0</code></pre>
@@ -437,10 +446,6 @@ host in <code>net.Server.listen()</code>. The API for accessing this information
 not supported, but using the Embedder API, users can provide
 and document their own resource objects. For example, such a resource object
 could contain the SQL query being executed.</p>
-<p>In the case of Promises, the <code>resource</code> object will have an
-<code>isChainedPromise</code> property, set to <code>true</code> if the promise has a parent promise,
-and <code>false</code> otherwise. For example, in the case of <code>b = a.then(handler)</code>, <code>a</code> is
-considered a parent <code>Promise</code> of <code>b</code>. Here, <code>b</code> is considered a chained promise.</p>
 <p>In some cases the resource object is reused for performance reasons, it is
 thus not safe to use it as a key in a <code>WeakMap</code> or add properties to it.</p>
 <h6>Asynchronous context example<span><a class="mark" href="#async_hooks_asynchronous_context_example" id="async_hooks_asynchronous_context_example">#</a></span></h6>
@@ -448,36 +453,38 @@ thus not safe to use it as a key in a <code>WeakMap</code> or add properties to
 <code>init</code> between the <code>before</code> and <code>after</code> calls, specifically what the
 callback to <code>listen()</code> will look like. The output formatting is slightly more
 elaborate to make calling context easier to see.</p>
-<pre><code class="language-js"><span class="hljs-keyword">let</span> indent = <span class="hljs-number">0</span>;
-async_hooks.createHook({
-  init(asyncId, type, triggerAsyncId) {
-    <span class="hljs-keyword">const</span> eid = async_hooks.executionAsyncId();
-    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.repeat(indent);
-    fs.writeSync(
-      process.stdout.fd,
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { fd } = process.<span class="hljs-property">stdout</span>;
+
+<span class="hljs-keyword">let</span> indent = <span class="hljs-number">0</span>;
+async_hooks.<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId</span>) {
+    <span class="hljs-keyword">const</span> eid = async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
+    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(indent);
+    fs.<span class="hljs-title function_">writeSync</span>(
+      fd,
       <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span><span class="hljs-subst">${type}</span>(<span class="hljs-subst">${asyncId}</span>):`</span> +
       <span class="hljs-string">` trigger: <span class="hljs-subst">${triggerAsyncId}</span> execution: <span class="hljs-subst">${eid}</span>\n`</span>);
   },
-  before(asyncId) {
-    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.repeat(indent);
-    fs.writeSync(process.stdout.fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>before:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
+  <span class="hljs-title function_">before</span>(<span class="hljs-params">asyncId</span>) {
+    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(indent);
+    fs.<span class="hljs-title function_">writeSync</span>(fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>before:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
     indent += <span class="hljs-number">2</span>;
   },
-  after(asyncId) {
+  <span class="hljs-title function_">after</span>(<span class="hljs-params">asyncId</span>) {
     indent -= <span class="hljs-number">2</span>;
-    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.repeat(indent);
-    fs.writeSync(process.stdout.fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>after:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
+    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(indent);
+    fs.<span class="hljs-title function_">writeSync</span>(fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>after:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
   },
-  destroy(asyncId) {
-    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.repeat(indent);
-    fs.writeSync(process.stdout.fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>destroy:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">asyncId</span>) {
+    <span class="hljs-keyword">const</span> indentStr = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(indent);
+    fs.<span class="hljs-title function_">writeSync</span>(fd, <span class="hljs-string">`<span class="hljs-subst">${indentStr}</span>destroy:  <span class="hljs-subst">${asyncId}</span>\n`</span>);
   },
-}).enable();
+}).<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer(<span class="hljs-function">() =></span> {}).listen(<span class="hljs-number">8080</span>, <span class="hljs-function">() =></span> {
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">() =></span> {}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8080</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Let's wait 10ms before logging the server started.</span>
   <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'>>>'</span>, async_hooks.executionAsyncId());
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'>>>'</span>, async_hooks.<span class="hljs-title function_">executionAsyncId</span>());
   }, <span class="hljs-number">10</span>);
 });</code></pre>
 <p>Output from only starting the server:</p>
@@ -488,7 +495,7 @@ before:  6
 after:   6
 destroy: 6
 before:  7
-<span class="hljs-meta">></span><span class="bash">>> 7</span>
+<span class="hljs-meta">></span><span class="language-bash">>> 7</span>
   TickObject(8): trigger: 7 execution: 7
 after:   7
 before:  8
@@ -568,7 +575,7 @@ invoked (either directly or through other means of resolving a promise).</p>
 <p><code>resolve()</code> does not do any observable synchronous work.</p>
 <p>The <code>Promise</code> is not necessarily fulfilled or rejected at this point if the
 <code>Promise</code> was resolved by assuming the state of another <code>Promise</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve</span>) =></span> resolve(<span class="hljs-literal">true</span>)).then(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> {});</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve</span>) =></span> <span class="hljs-title function_">resolve</span>(<span class="hljs-literal">true</span>)).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> {});</code></pre>
 <p>calls the following callbacks:</p>
 <pre><code class="language-text">init for PROMISE with id 5, trigger id: 1
   promise resolve 5      # corresponds to resolve(true)
@@ -578,7 +585,7 @@ init for PROMISE with id 6, trigger id: 5  # the Promise returned by then()
   after 6</code></pre>
 <h4><code>async_hooks.executionAsyncResource()</code><span><a class="mark" href="#async_hooks_async_hooks_executionasyncresource" id="async_hooks_async_hooks_executionasyncresource">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.9.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The resource representing the current execution.
@@ -593,9 +600,9 @@ but having an object representing the top-level can be helpful.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { open } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { executionAsyncId, executionAsyncResource } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-built_in">console</span>.log(executionAsyncId(), executionAsyncResource());  <span class="hljs-comment">// 1 {}</span>
-open(__filename, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(executionAsyncId(), executionAsyncResource());  <span class="hljs-comment">// 7 FSReqWrap</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">executionAsyncId</span>(), <span class="hljs-title function_">executionAsyncResource</span>());  <span class="hljs-comment">// 1 {}</span>
+<span class="hljs-title function_">open</span>(__filename, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">executionAsyncId</span>(), <span class="hljs-title function_">executionAsyncResource</span>());  <span class="hljs-comment">// 7 FSReqWrap</span>
 });</code></pre>
 <p>This can be used to implement continuation local storage without the
 use of a tracking <code>Map</code> to store the metadata:</p>
@@ -605,30 +612,30 @@ use of a tracking <code>Map</code> to store the metadata:</p>
   executionAsyncResource,
   createHook
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
-<span class="hljs-keyword">const</span> sym = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'state'</span>); <span class="hljs-comment">// Private symbol to avoid pollution</span>
+<span class="hljs-keyword">const</span> sym = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'state'</span>); <span class="hljs-comment">// Private symbol to avoid pollution</span>
 
-createHook({
-  init(asyncId, type, triggerAsyncId, resource) {
-    <span class="hljs-keyword">const</span> cr = executionAsyncResource();
+<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">asyncId, type, triggerAsyncId, resource</span>) {
+    <span class="hljs-keyword">const</span> cr = <span class="hljs-title function_">executionAsyncResource</span>();
     <span class="hljs-keyword">if</span> (cr) {
       resource[sym] = cr[sym];
     }
   }
-}).enable();
+}).<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-keyword">const</span> server = createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  executionAsyncResource()[sym] = { <span class="hljs-attr">state</span>: req.url };
-  <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-    res.end(<span class="hljs-built_in">JSON</span>.stringify(executionAsyncResource()[sym]));
+<span class="hljs-keyword">const</span> server = <span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  <span class="hljs-title function_">executionAsyncResource</span>()[sym] = { <span class="hljs-attr">state</span>: req.<span class="hljs-property">url</span> };
+  <span class="hljs-built_in">setTimeout</span>(<span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
+    res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(<span class="hljs-title function_">executionAsyncResource</span>()[sym]));
   }, <span class="hljs-number">100</span>);
-}).listen(<span class="hljs-number">3000</span>);</code></pre>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);</code></pre>
 <h4><code>async_hooks.executionAsyncId()</code><span><a class="mark" href="#async_hooks_async_hooks_executionasyncid" id="async_hooks_async_hooks_executionasyncid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v8.2.0</td>
-<td><p>Renamed from <code>currentId</code></p></td></tr>
+<td><p>Renamed from <code>currentId</code>.</p></td></tr>
 <tr><td>v8.1.0</td>
 <td><p><span>Added in: v8.1.0</span></p></td></tr>
 </tbody></table>
@@ -640,21 +647,21 @@ track when something calls.</li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-built_in">console</span>.log(async_hooks.executionAsyncId());  <span class="hljs-comment">// 1 - bootstrap</span>
-fs.open(path, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(async_hooks.executionAsyncId());  <span class="hljs-comment">// 6 - open()</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(async_hooks.<span class="hljs-title function_">executionAsyncId</span>());  <span class="hljs-comment">// 1 - bootstrap</span>
+fs.<span class="hljs-title function_">open</span>(path, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(async_hooks.<span class="hljs-title function_">executionAsyncId</span>());  <span class="hljs-comment">// 6 - open()</span>
 });</code></pre>
 <p>The ID returned from <code>executionAsyncId()</code> is related to execution timing, not
 causality (which is covered by <code>triggerAsyncId()</code>):</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {
   <span class="hljs-comment">// Returns the ID of the server, not of the new connection, because the</span>
   <span class="hljs-comment">// callback runs in the execution scope of the server's MakeCallback().</span>
-  async_hooks.executionAsyncId();
+  async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
 
-}).listen(port, <span class="hljs-function">() =></span> {
-  <span class="hljs-comment">// Returns the ID of a TickObject (i.e. process.nextTick()) because all</span>
+}).<span class="hljs-title function_">listen</span>(port, <span class="hljs-function">() =></span> {
+  <span class="hljs-comment">// Returns the ID of a TickObject (process.nextTick()) because all</span>
   <span class="hljs-comment">// callbacks passed to .listen() are wrapped in a nextTick().</span>
-  async_hooks.executionAsyncId();
+  async_hooks.<span class="hljs-title function_">executionAsyncId</span>();
 });</code></pre>
 <p>Promise contexts may not get precise <code>executionAsyncIds</code> by default.
 See the section on <a href="#async_hooks_promise_execution_tracking">promise execution tracking</a>.</p>
@@ -663,28 +670,28 @@ See the section on <a href="#async_hooks_promise_execution_tracking">promise exe
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The ID of the resource responsible for calling the callback
 that is currently being executed.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">conn</span>) =></span> {
   <span class="hljs-comment">// The resource that caused (or triggered) this callback to be called</span>
   <span class="hljs-comment">// was that of the new connection. Thus the return value of triggerAsyncId()</span>
   <span class="hljs-comment">// is the asyncId of "conn".</span>
-  async_hooks.triggerAsyncId();
+  async_hooks.<span class="hljs-title function_">triggerAsyncId</span>();
 
-}).listen(port, <span class="hljs-function">() =></span> {
+}).<span class="hljs-title function_">listen</span>(port, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Even though all callbacks passed to .listen() are wrapped in a nextTick()</span>
   <span class="hljs-comment">// the callback itself exists because the call to the server's .listen()</span>
   <span class="hljs-comment">// was made. So the return value would be the ID of the server.</span>
-  async_hooks.triggerAsyncId();
+  async_hooks.<span class="hljs-title function_">triggerAsyncId</span>();
 });</code></pre>
 <p>Promise contexts may not get valid <code>triggerAsyncId</code>s by default. See
 the section on <a href="#async_hooks_promise_execution_tracking">promise execution tracking</a>.</p>
-<h2>Promise execution tracking<span><a class="mark" href="#async_hooks_promise_execution_tracking" id="async_hooks_promise_execution_tracking">#</a></span></h2>
+</section><section><h3>Promise execution tracking<span><a class="mark" href="#async_hooks_promise_execution_tracking" id="async_hooks_promise_execution_tracking">#</a></span></h3>
 <p>By default, promise executions are not assigned <code>asyncId</code>s due to the relatively
 expensive nature of the <a href="https://docs.google.com/document/d/1rda3yKGHimKIhg5YeoAmCOtyURgsbTH_qaYR79FELlk/edit">promise introspection API</a> provided by
 V8. This means that programs using promises or <code>async</code>/<code>await</code> will not get
 correct execution and trigger ids for promise callback contexts by default.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> ah = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
-<span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">1729</span>).then(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`eid <span class="hljs-subst">${ah.executionAsyncId()}</span> tid <span class="hljs-subst">${ah.triggerAsyncId()}</span>`</span>);
+<span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">1729</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`eid <span class="hljs-subst">${ah.executionAsyncId()}</span> tid <span class="hljs-subst">${ah.triggerAsyncId()}</span>`</span>);
 });
 <span class="hljs-comment">// produces:</span>
 <span class="hljs-comment">// eid 1 tid 0</span></code></pre>
@@ -695,9 +702,9 @@ the resource that caused (triggered) the <code>then()</code> callback to be exec
 <p>Installing async hooks via <code>async_hooks.createHook</code> enables promise execution
 tracking:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> ah = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
-ah.createHook({ init() {} }).enable(); <span class="hljs-comment">// forces PromiseHooks to be enabled.</span>
-<span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">1729</span>).then(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`eid <span class="hljs-subst">${ah.executionAsyncId()}</span> tid <span class="hljs-subst">${ah.triggerAsyncId()}</span>`</span>);
+ah.<span class="hljs-title function_">createHook</span>({ <span class="hljs-title function_">init</span>(<span class="hljs-params"></span>) {} }).<span class="hljs-title function_">enable</span>(); <span class="hljs-comment">// forces PromiseHooks to be enabled.</span>
+<span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">1729</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`eid <span class="hljs-subst">${ah.executionAsyncId()}</span> tid <span class="hljs-subst">${ah.triggerAsyncId()}</span>`</span>);
 });
 <span class="hljs-comment">// produces:</span>
 <span class="hljs-comment">// eid 7 tid 6</span></code></pre>
@@ -712,23 +719,23 @@ async resource <code>6</code>.</p>
 only on chained promises. That means promises not created by <code>then()</code>/<code>catch()</code>
 will not have the <code>before</code> and <code>after</code> callbacks fired on them. For more details
 see the details of the V8 <a href="https://docs.google.com/document/d/1rda3yKGHimKIhg5YeoAmCOtyURgsbTH_qaYR79FELlk/edit">PromiseHooks</a> API.</p>
-<h2>JavaScript embedder API<span><a class="mark" href="#async_hooks_javascript_embedder_api" id="async_hooks_javascript_embedder_api">#</a></span></h2>
+</section><section><h3>JavaScript embedder API<span><a class="mark" href="#async_hooks_javascript_embedder_api" id="async_hooks_javascript_embedder_api">#</a></span></h3>
 <p>Library developers that handle their own asynchronous resources performing tasks
 like I/O, connection pooling, or managing callback queues may use the
 <code>AsyncResource</code> JavaScript API so that all the appropriate callbacks are called.</p>
-<h3>Class: <code>AsyncResource</code><span><a class="mark" href="#async_hooks_class_asyncresource" id="async_hooks_class_asyncresource">#</a></span></h3>
+<h4>Class: <code>AsyncResource</code><span><a class="mark" href="#async_hooks_class_asyncresource" id="async_hooks_class_asyncresource">#</a></span></h4>
 <p>The class <code>AsyncResource</code> is designed to be extended by the embedder's async
 resources. Using this, users can easily trigger the lifetime events of their
 own resources.</p>
 <p>The <code>init</code> hook will trigger when an <code>AsyncResource</code> is instantiated.</p>
 <p>The following is an overview of the <code>AsyncResource</code> API.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { AsyncResource, executionAsyncId } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">AsyncResource</span>, executionAsyncId } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
 <span class="hljs-comment">// AsyncResource() is meant to be extended. Instantiating a</span>
 <span class="hljs-comment">// new AsyncResource() also triggers init. If triggerAsyncId is omitted then</span>
 <span class="hljs-comment">// async_hook.executionAsyncId() is used.</span>
-<span class="hljs-keyword">const</span> asyncResource = <span class="hljs-keyword">new</span> AsyncResource(
-  type, { <span class="hljs-attr">triggerAsyncId</span>: executionAsyncId(), <span class="hljs-attr">requireManualDestroy</span>: <span class="hljs-literal">false</span> }
+<span class="hljs-keyword">const</span> asyncResource = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AsyncResource</span>(
+  type, { <span class="hljs-attr">triggerAsyncId</span>: <span class="hljs-title function_">executionAsyncId</span>(), <span class="hljs-attr">requireManualDestroy</span>: <span class="hljs-literal">false</span> }
 );
 
 <span class="hljs-comment">// Run a function in the execution context of the resource. This will</span>
@@ -737,17 +744,17 @@ own resources.</p>
 <span class="hljs-comment">// * call the provided function `fn` with the supplied arguments</span>
 <span class="hljs-comment">// * trigger the AsyncHooks after callbacks</span>
 <span class="hljs-comment">// * restore the original execution context</span>
-asyncResource.runInAsyncScope(fn, thisArg, ...args);
+asyncResource.<span class="hljs-title function_">runInAsyncScope</span>(fn, thisArg, ...args);
 
 <span class="hljs-comment">// Call AsyncHooks destroy callbacks.</span>
-asyncResource.emitDestroy();
+asyncResource.<span class="hljs-title function_">emitDestroy</span>();
 
 <span class="hljs-comment">// Return the unique ID assigned to the AsyncResource instance.</span>
-asyncResource.asyncId();
+asyncResource.<span class="hljs-title function_">asyncId</span>();
 
 <span class="hljs-comment">// Return the trigger ID for the AsyncResource instance.</span>
-asyncResource.triggerAsyncId();</code></pre>
-<h4><code>new AsyncResource(type[, options])</code><span><a class="mark" href="#async_hooks_new_asyncresource_type_options" id="async_hooks_new_asyncresource_type_options">#</a></span></h4>
+asyncResource.<span class="hljs-title function_">triggerAsyncId</span>();</code></pre>
+<h5><code>new AsyncResource(type[, options])</code><span><a class="mark" href="#async_hooks_new_asyncresource_type_options" id="async_hooks_new_asyncresource_type_options">#</a></span></h5>
 <ul>
 <li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The type of async event.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -765,26 +772,26 @@ will only take place if there is at least one active <code>destroy</code> hook.
 </li>
 </ul>
 <p>Example usage:</p>
-<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">DBQuery</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">AsyncResource</span> </span>{
-  <span class="hljs-keyword">constructor</span>(db) {
-    <span class="hljs-built_in">super</span>(<span class="hljs-string">'DBQuery'</span>);
-    <span class="hljs-built_in">this</span>.db = db;
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">DBQuery</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">AsyncResource</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">db</span>) {
+    <span class="hljs-variable language_">super</span>(<span class="hljs-string">'DBQuery'</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">db</span> = db;
   }
 
-  getInfo(query, callback) {
-    <span class="hljs-built_in">this</span>.db.get(query, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
-      <span class="hljs-built_in">this</span>.runInAsyncScope(callback, <span class="hljs-literal">null</span>, err, data);
+  <span class="hljs-title function_">getInfo</span>(<span class="hljs-params">query, callback</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">db</span>.<span class="hljs-title function_">get</span>(query, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">runInAsyncScope</span>(callback, <span class="hljs-literal">null</span>, err, data);
     });
   }
 
-  close() {
-    <span class="hljs-built_in">this</span>.db = <span class="hljs-literal">null</span>;
-    <span class="hljs-built_in">this</span>.emitDestroy();
+  <span class="hljs-title function_">close</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">db</span> = <span class="hljs-literal">null</span>;
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emitDestroy</span>();
   }
 }</code></pre>
-<h4>Static method: <code>AsyncResource.bind(fn[, type])</code><span><a class="mark" href="#async_hooks_static_method_asyncresource_bind_fn_type" id="async_hooks_static_method_asyncresource_bind_fn_type">#</a></span></h4>
+<h5>Static method: <code>AsyncResource.bind(fn[, type])</code><span><a class="mark" href="#async_hooks_static_method_asyncresource_bind_fn_type" id="async_hooks_static_method_asyncresource_bind_fn_type">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0</span>
 </div>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to bind to the current execution context.</li>
@@ -794,9 +801,9 @@ will only take place if there is at least one active <code>destroy</code> hook.
 <p>Binds the given function to the current execution context.</p>
 <p>The returned function will have an <code>asyncResource</code> property referencing
 the <code>AsyncResource</code> to which the function is bound.</p>
-<h4><code>asyncResource.bind(fn)</code><span><a class="mark" href="#async_hooks_asyncresource_bind_fn" id="async_hooks_asyncresource_bind_fn">#</a></span></h4>
+<h5><code>asyncResource.bind(fn)</code><span><a class="mark" href="#async_hooks_asyncresource_bind_fn" id="async_hooks_asyncresource_bind_fn">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0</span>
 </div>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to bind to the current <code>AsyncResource</code>.</li>
@@ -804,7 +811,7 @@ the <code>AsyncResource</code> to which the function is bound.</p>
 <p>Binds the given function to execute to this <code>AsyncResource</code>'s scope.</p>
 <p>The returned function will have an <code>asyncResource</code> property referencing
 the <code>AsyncResource</code> to which the function is bound.</p>
-<h4><code>asyncResource.runInAsyncScope(fn[, thisArg, ...args])</code><span><a class="mark" href="#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args" id="async_hooks_asyncresource_runinasyncscope_fn_thisarg_args">#</a></span></h4>
+<h5><code>asyncResource.runInAsyncScope(fn[, thisArg, ...args])</code><span><a class="mark" href="#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args" id="async_hooks_asyncresource_runinasyncscope_fn_thisarg_args">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 </div>
@@ -818,7 +825,7 @@ resource.</li>
 of the async resource. This will establish the context, trigger the AsyncHooks
 before callbacks, call the function, trigger the AsyncHooks after callbacks, and
 then restore the original execution context.</p>
-<h4><code>asyncResource.emitDestroy()</code><span><a class="mark" href="#async_hooks_asyncresource_emitdestroy" id="async_hooks_asyncresource_emitdestroy">#</a></span></h4>
+<h5><code>asyncResource.emitDestroy()</code><span><a class="mark" href="#async_hooks_asyncresource_emitdestroy" id="async_hooks_asyncresource_emitdestroy">#</a></span></h5>
 <ul>
 <li>Returns: <a href="async_hooks.html#async_hooks_class_asyncresource" class="type">&#x3C;AsyncResource></a> A reference to <code>asyncResource</code>.</li>
 </ul>
@@ -826,124 +833,134 @@ then restore the original execution context.</p>
 be thrown if it is called more than once. This <strong>must</strong> be manually called. If
 the resource is left to be collected by the GC then the <code>destroy</code> hooks will
 never be called.</p>
-<h4><code>asyncResource.asyncId()</code><span><a class="mark" href="#async_hooks_asyncresource_asyncid" id="async_hooks_asyncresource_asyncid">#</a></span></h4>
+<h5><code>asyncResource.asyncId()</code><span><a class="mark" href="#async_hooks_asyncresource_asyncid" id="async_hooks_asyncresource_asyncid">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The unique <code>asyncId</code> assigned to the resource.</li>
 </ul>
-<h4><code>asyncResource.triggerAsyncId()</code><span><a class="mark" href="#async_hooks_asyncresource_triggerasyncid" id="async_hooks_asyncresource_triggerasyncid">#</a></span></h4>
+<h5><code>asyncResource.triggerAsyncId()</code><span><a class="mark" href="#async_hooks_asyncresource_triggerasyncid" id="async_hooks_asyncresource_triggerasyncid">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The same <code>triggerAsyncId</code> that is passed to the
 <code>AsyncResource</code> constructor.</li>
 </ul>
 <p><a id="async-resource-worker-pool"></a></p>
-<h3>Using <code>AsyncResource</code> for a <code>Worker</code> thread pool<span><a class="mark" href="#async_hooks_using_asyncresource_for_a_worker_thread_pool" id="async_hooks_using_asyncresource_for_a_worker_thread_pool">#</a></span></h3>
+<h4>Using <code>AsyncResource</code> for a <code>Worker</code> thread pool<span><a class="mark" href="#async_hooks_using_asyncresource_for_a_worker_thread_pool" id="async_hooks_using_asyncresource_for_a_worker_thread_pool">#</a></span></h4>
 <p>The following example shows how to use the <code>AsyncResource</code> class to properly
 provide async tracking for a <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> pool. Other resource pools, such as
 database connection pools, can follow a similar model.</p>
 <p>Assuming that the task is adding two numbers, using a file named
 <code>task_processor.js</code> with the following content:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-parentPort.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">task</span>) =></span> {
-  parentPort.postMessage(task.a + task.b);
+parentPort.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">task</span>) =></span> {
+  parentPort.<span class="hljs-title function_">postMessage</span>(task.<span class="hljs-property">a</span> + task.<span class="hljs-property">b</span>);
 });</code></pre>
 <p>a Worker pool around it could use the following structure:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { AsyncResource } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
-<span class="hljs-keyword">const</span> { EventEmitter } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">AsyncResource</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 <span class="hljs-keyword">const</span> path = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);
-<span class="hljs-keyword">const</span> { Worker } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
-<span class="hljs-keyword">const</span> kTaskInfo = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'kTaskInfo'</span>);
-<span class="hljs-keyword">const</span> kWorkerFreedEvent = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'kWorkerFreedEvent'</span>);
+<span class="hljs-keyword">const</span> kTaskInfo = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'kTaskInfo'</span>);
+<span class="hljs-keyword">const</span> kWorkerFreedEvent = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'kWorkerFreedEvent'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">WorkerPoolTaskInfo</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">AsyncResource</span> </span>{
-  <span class="hljs-keyword">constructor</span>(callback) {
-    <span class="hljs-built_in">super</span>(<span class="hljs-string">'WorkerPoolTaskInfo'</span>);
-    <span class="hljs-built_in">this</span>.callback = callback;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">WorkerPoolTaskInfo</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">AsyncResource</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">callback</span>) {
+    <span class="hljs-variable language_">super</span>(<span class="hljs-string">'WorkerPoolTaskInfo'</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">callback</span> = callback;
   }
 
-  done(err, result) {
-    <span class="hljs-built_in">this</span>.runInAsyncScope(<span class="hljs-built_in">this</span>.callback, <span class="hljs-literal">null</span>, err, result);
-    <span class="hljs-built_in">this</span>.emitDestroy();  <span class="hljs-comment">// `TaskInfo`s are used only once.</span>
+  <span class="hljs-title function_">done</span>(<span class="hljs-params">err, result</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">runInAsyncScope</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">callback</span>, <span class="hljs-literal">null</span>, err, result);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emitDestroy</span>();  <span class="hljs-comment">// `TaskInfo`s are used only once.</span>
   }
 }
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">WorkerPool</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">EventEmitter</span> </span>{
-  <span class="hljs-keyword">constructor</span>(numThreads) {
-    <span class="hljs-built_in">super</span>();
-    <span class="hljs-built_in">this</span>.numThreads = numThreads;
-    <span class="hljs-built_in">this</span>.workers = [];
-    <span class="hljs-built_in">this</span>.freeWorkers = [];
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">WorkerPool</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">numThreads</span>) {
+    <span class="hljs-variable language_">super</span>();
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">numThreads</span> = numThreads;
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span> = [];
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span> = [];
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">tasks</span> = [];
 
     <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; numThreads; i++)
-      <span class="hljs-built_in">this</span>.addNewWorker();
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">addNewWorker</span>();
+
+    <span class="hljs-comment">// Any time the kWorkerFreedEvent is emitted, dispatch</span>
+    <span class="hljs-comment">// the next task pending in the queue, if any.</span>
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">on</span>(kWorkerFreedEvent, <span class="hljs-function">() =></span> {
+      <span class="hljs-keyword">if</span> (<span class="hljs-variable language_">this</span>.<span class="hljs-property">tasks</span>.<span class="hljs-property">length</span> > <span class="hljs-number">0</span>) {
+        <span class="hljs-keyword">const</span> { task, callback } = <span class="hljs-variable language_">this</span>.<span class="hljs-property">tasks</span>.<span class="hljs-title function_">shift</span>();
+        <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">runTask</span>(task, callback);
+      }
+    });
   }
 
-  addNewWorker() {
-    <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(path.resolve(__dirname, <span class="hljs-string">'task_processor.js'</span>));
-    worker.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+  <span class="hljs-title function_">addNewWorker</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(path.<span class="hljs-title function_">resolve</span>(__dirname, <span class="hljs-string">'task_processor.js'</span>));
+    worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
       <span class="hljs-comment">// In case of success: Call the callback that was passed to `runTask`,</span>
       <span class="hljs-comment">// remove the `TaskInfo` associated with the Worker, and mark it as free</span>
       <span class="hljs-comment">// again.</span>
-      worker[kTaskInfo].done(<span class="hljs-literal">null</span>, result);
+      worker[kTaskInfo].<span class="hljs-title function_">done</span>(<span class="hljs-literal">null</span>, result);
       worker[kTaskInfo] = <span class="hljs-literal">null</span>;
-      <span class="hljs-built_in">this</span>.freeWorkers.push(worker);
-      <span class="hljs-built_in">this</span>.emit(kWorkerFreedEvent);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span>.<span class="hljs-title function_">push</span>(worker);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(kWorkerFreedEvent);
     });
-    worker.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
       <span class="hljs-comment">// In case of an uncaught exception: Call the callback that was passed to</span>
       <span class="hljs-comment">// `runTask` with the error.</span>
       <span class="hljs-keyword">if</span> (worker[kTaskInfo])
-        worker[kTaskInfo].done(err, <span class="hljs-literal">null</span>);
+        worker[kTaskInfo].<span class="hljs-title function_">done</span>(err, <span class="hljs-literal">null</span>);
       <span class="hljs-keyword">else</span>
-        <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'error'</span>, err);
+        <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, err);
       <span class="hljs-comment">// Remove the worker from the list and start a new Worker to replace the</span>
       <span class="hljs-comment">// current one.</span>
-      <span class="hljs-built_in">this</span>.workers.splice(<span class="hljs-built_in">this</span>.workers.indexOf(worker), <span class="hljs-number">1</span>);
-      <span class="hljs-built_in">this</span>.addNewWorker();
+      <span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span>.<span class="hljs-title function_">splice</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span>.<span class="hljs-title function_">indexOf</span>(worker), <span class="hljs-number">1</span>);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">addNewWorker</span>();
     });
-    <span class="hljs-built_in">this</span>.workers.push(worker);
-    <span class="hljs-built_in">this</span>.freeWorkers.push(worker);
-    <span class="hljs-built_in">this</span>.emit(kWorkerFreedEvent);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span>.<span class="hljs-title function_">push</span>(worker);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span>.<span class="hljs-title function_">push</span>(worker);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(kWorkerFreedEvent);
   }
 
-  runTask(task, callback) {
-    <span class="hljs-keyword">if</span> (<span class="hljs-built_in">this</span>.freeWorkers.length === <span class="hljs-number">0</span>) {
+  <span class="hljs-title function_">runTask</span>(<span class="hljs-params">task, callback</span>) {
+    <span class="hljs-keyword">if</span> (<span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span>.<span class="hljs-property">length</span> === <span class="hljs-number">0</span>) {
       <span class="hljs-comment">// No free threads, wait until a worker thread becomes free.</span>
-      <span class="hljs-built_in">this</span>.once(kWorkerFreedEvent, <span class="hljs-function">() =></span> <span class="hljs-built_in">this</span>.runTask(task, callback));
+      <span class="hljs-variable language_">this</span>.<span class="hljs-property">tasks</span>.<span class="hljs-title function_">push</span>({ task, callback });
       <span class="hljs-keyword">return</span>;
     }
 
-    <span class="hljs-keyword">const</span> worker = <span class="hljs-built_in">this</span>.freeWorkers.pop();
-    worker[kTaskInfo] = <span class="hljs-keyword">new</span> WorkerPoolTaskInfo(callback);
-    worker.postMessage(task);
+    <span class="hljs-keyword">const</span> worker = <span class="hljs-variable language_">this</span>.<span class="hljs-property">freeWorkers</span>.<span class="hljs-title function_">pop</span>();
+    worker[kTaskInfo] = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WorkerPoolTaskInfo</span>(callback);
+    worker.<span class="hljs-title function_">postMessage</span>(task);
   }
 
-  close() {
-    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> worker <span class="hljs-keyword">of</span> <span class="hljs-built_in">this</span>.workers) worker.terminate();
+  <span class="hljs-title function_">close</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> worker <span class="hljs-keyword">of</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">workers</span>) worker.<span class="hljs-title function_">terminate</span>();
   }
 }
 
-<span class="hljs-built_in">module</span>.exports = WorkerPool;</code></pre>
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-title class_">WorkerPool</span>;</code></pre>
 <p>Without the explicit tracking added by the <code>WorkerPoolTaskInfo</code> objects,
 it would appear that the callbacks are associated with the individual <code>Worker</code>
 objects. However, the creation of the <code>Worker</code>s is not associated with the
 creation of the tasks and does not provide information about when tasks
 were scheduled.</p>
 <p>This pool could be used as follows:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> WorkerPool = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./worker_pool.js'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">WorkerPool</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./worker_pool.js'</span>);
 <span class="hljs-keyword">const</span> os = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>);
 
-<span class="hljs-keyword">const</span> pool = <span class="hljs-keyword">new</span> WorkerPool(os.cpus().length);
+<span class="hljs-keyword">const</span> pool = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WorkerPool</span>(os.<span class="hljs-title function_">cpus</span>().<span class="hljs-property">length</span>);
 
 <span class="hljs-keyword">let</span> finished = <span class="hljs-number">0</span>;
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">10</span>; i++) {
-  pool.runTask({ <span class="hljs-attr">a</span>: <span class="hljs-number">42</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">100</span> }, <span class="hljs-function">(<span class="hljs-params">err, result</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(i, err, result);
+  pool.<span class="hljs-title function_">runTask</span>({ <span class="hljs-attr">a</span>: <span class="hljs-number">42</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">100</span> }, <span class="hljs-function">(<span class="hljs-params">err, result</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(i, err, result);
     <span class="hljs-keyword">if</span> (++finished === <span class="hljs-number">10</span>)
-      pool.close();
+      pool.<span class="hljs-title function_">close</span>();
   });
 }</code></pre>
-<h3>Integrating <code>AsyncResource</code> with <code>EventEmitter</code><span><a class="mark" href="#async_hooks_integrating_asyncresource_with_eventemitter" id="async_hooks_integrating_asyncresource_with_eventemitter">#</a></span></h3>
+<h4>Integrating <code>AsyncResource</code> with <code>EventEmitter</code><span><a class="mark" href="#async_hooks_integrating_asyncresource_with_eventemitter" id="async_hooks_integrating_asyncresource_with_eventemitter">#</a></span></h4>
 <p>Event listeners triggered by an <a href="events.html#events_class_eventemitter"><code>EventEmitter</code></a> may be run in a different
 execution context than the one that was active when <code>eventEmitter.on()</code> was
 called.</p>
@@ -951,52 +968,56 @@ called.</p>
 associate an event listener with the correct execution context. The same
 approach can be applied to a <a href="stream.html#stream_stream"><code>Stream</code></a> or a similar event-driven class.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { createServer } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> { AsyncResource, executionAsyncId } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">AsyncResource</span>, executionAsyncId } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-keyword">const</span> server = createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  req.on(<span class="hljs-string">'close'</span>, AsyncResource.bind(<span class="hljs-function">() =></span> {
+<span class="hljs-keyword">const</span> server = <span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-title class_">AsyncResource</span>.<span class="hljs-title function_">bind</span>(<span class="hljs-function">() =></span> {
     <span class="hljs-comment">// Execution context is bound to the current outer scope.</span>
   }));
-  req.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> {
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-comment">// Execution context is bound to the scope that caused 'close' to emit.</span>
   });
-  res.end();
-}).listen(<span class="hljs-number">3000</span>);</code></pre>
-<h2>Class: <code>AsyncLocalStorage</code><span><a class="mark" href="#async_hooks_class_asynclocalstorage" id="async_hooks_class_asynclocalstorage">#</a></span></h2>
+  res.<span class="hljs-title function_">end</span>();
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);</code></pre>
+</section><section><h3>Class: <code>AsyncLocalStorage</code><span><a class="mark" href="#async_hooks_class_asynclocalstorage" id="async_hooks_class_asynclocalstorage">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <p>This class is used to create asynchronous state within callbacks and promise
 chains. It allows storing data throughout the lifetime of a web request
 or any other asynchronous duration. It is similar to thread-local storage
 in other languages.</p>
+<p>While you can create your own implementation on top of the <code>async_hooks</code> module,
+<code>AsyncLocalStorage</code> should be preferred as it is a performant and memory safe
+implementation that involves significant optimizations that are non-obvious to
+implement.</p>
 <p>The following example uses <code>AsyncLocalStorage</code> to build a simple logger
 that assigns IDs to incoming HTTP requests and includes them in messages
 logged within each request.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> { AsyncLocalStorage } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">AsyncLocalStorage</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 
-<span class="hljs-keyword">const</span> asyncLocalStorage = <span class="hljs-keyword">new</span> AsyncLocalStorage();
+<span class="hljs-keyword">const</span> asyncLocalStorage = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AsyncLocalStorage</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">logWithId</span>(<span class="hljs-params">msg</span>) </span>{
-  <span class="hljs-keyword">const</span> id = asyncLocalStorage.getStore();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${id !== <span class="hljs-literal">undefined</span> ? id : <span class="hljs-string">'-'</span>}</span>:`</span>, msg);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">logWithId</span>(<span class="hljs-params">msg</span>) {
+  <span class="hljs-keyword">const</span> id = asyncLocalStorage.<span class="hljs-title function_">getStore</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${id !== <span class="hljs-literal">undefined</span> ? id : <span class="hljs-string">'-'</span>}</span>:`</span>, msg);
 }
 
 <span class="hljs-keyword">let</span> idSeq = <span class="hljs-number">0</span>;
-http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  asyncLocalStorage.run(idSeq++, <span class="hljs-function">() =></span> {
-    logWithId(<span class="hljs-string">'start'</span>);
+http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  asyncLocalStorage.<span class="hljs-title function_">run</span>(idSeq++, <span class="hljs-function">() =></span> {
+    <span class="hljs-title function_">logWithId</span>(<span class="hljs-string">'start'</span>);
     <span class="hljs-comment">// Imagine any chain of async operations here</span>
-    setImmediate(<span class="hljs-function">() =></span> {
-      logWithId(<span class="hljs-string">'finish'</span>);
-      res.end();
+    <span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> {
+      <span class="hljs-title function_">logWithId</span>(<span class="hljs-string">'finish'</span>);
+      res.<span class="hljs-title function_">end</span>();
     });
   });
-}).listen(<span class="hljs-number">8080</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8080</span>);
 
-http.get(<span class="hljs-string">'http://localhost:8080'</span>);
-http.get(<span class="hljs-string">'http://localhost:8080'</span>);
+http.<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:8080'</span>);
+http.<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:8080'</span>);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   0: start</span>
 <span class="hljs-comment">//   1: start</span>
@@ -1004,139 +1025,144 @@ http.get(<span class="hljs-string">'http://localhost:8080'</span>);
 <span class="hljs-comment">//   1: finish</span></code></pre>
 <p>When having multiple instances of <code>AsyncLocalStorage</code>, they are independent
 from each other. It is safe to instantiate this class multiple times.</p>
-<h3><code>new AsyncLocalStorage()</code><span><a class="mark" href="#async_hooks_new_asynclocalstorage" id="async_hooks_new_asynclocalstorage">#</a></span></h3>
+<h4><code>new AsyncLocalStorage()</code><span><a class="mark" href="#async_hooks_new_asynclocalstorage" id="async_hooks_new_asynclocalstorage">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <p>Creates a new instance of <code>AsyncLocalStorage</code>. Store is only provided within a
-<code>run</code> method call.</p>
-<h3><code>asyncLocalStorage.disable()</code><span><a class="mark" href="#async_hooks_asynclocalstorage_disable" id="async_hooks_asynclocalstorage_disable">#</a></span></h3>
+<code>run()</code> call or after an <code>enterWith()</code> call.</p>
+<h4><code>asyncLocalStorage.disable()</code><span><a class="mark" href="#async_hooks_asynclocalstorage_disable" id="async_hooks_asynclocalstorage_disable">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
-<p>This method disables the instance of <code>AsyncLocalStorage</code>. All subsequent calls
+<p>Disables the instance of <code>AsyncLocalStorage</code>. All subsequent calls
 to <code>asyncLocalStorage.getStore()</code> will return <code>undefined</code> until
-<code>asyncLocalStorage.run()</code> is called again.</p>
+<code>asyncLocalStorage.run()</code> or <code>asyncLocalStorage.enterWith()</code> is called again.</p>
 <p>When calling <code>asyncLocalStorage.disable()</code>, all current contexts linked to the
 instance will be exited.</p>
 <p>Calling <code>asyncLocalStorage.disable()</code> is required before the
 <code>asyncLocalStorage</code> can be garbage collected. This does not apply to stores
 provided by the <code>asyncLocalStorage</code>, as those objects are garbage collected
 along with the corresponding async resources.</p>
-<p>This method is to be used when the <code>asyncLocalStorage</code> is not in use anymore
+<p>Use this method when the <code>asyncLocalStorage</code> is not in use anymore
 in the current process.</p>
-<h3><code>asyncLocalStorage.getStore()</code><span><a class="mark" href="#async_hooks_asynclocalstorage_getstore" id="async_hooks_asynclocalstorage_getstore">#</a></span></h3>
+<h4><code>asyncLocalStorage.getStore()</code><span><a class="mark" href="#async_hooks_asynclocalstorage_getstore" id="async_hooks_asynclocalstorage_getstore">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
-<p>This method returns the current store.
-If this method is called outside of an asynchronous context initialized by
-calling <code>asyncLocalStorage.run</code>, it will return <code>undefined</code>.</p>
-<h3><code>asyncLocalStorage.enterWith(store)</code><span><a class="mark" href="#async_hooks_asynclocalstorage_enterwith_store" id="async_hooks_asynclocalstorage_enterwith_store">#</a></span></h3>
+<p>Returns the current store.
+If called outside of an asynchronous context initialized by
+calling <code>asyncLocalStorage.run()</code> or <code>asyncLocalStorage.enterWith()</code>, it
+returns <code>undefined</code>.</p>
+<h4><code>asyncLocalStorage.enterWith(store)</code><span><a class="mark" href="#async_hooks_asynclocalstorage_enterwith_store" id="async_hooks_asynclocalstorage_enterwith_store">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.11.0</span>
 </div>
 <ul>
 <li><code>store</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
-<p>Calling <code>asyncLocalStorage.enterWith(store)</code> will transition into the context
-for the remainder of the current synchronous execution and will persist
-through any following asynchronous calls.</p>
+<p>Transitions into the context for the remainder of the current
+synchronous execution and then persists the store through any following
+asynchronous calls.</p>
 <p>Example:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> store = { <span class="hljs-attr">id</span>: <span class="hljs-number">1</span> };
-asyncLocalStorage.enterWith(store);
-asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the store object</span>
-someAsyncOperation(<span class="hljs-function">() =></span> {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the same object</span>
+<span class="hljs-comment">// Replaces previous store with the given store object</span>
+asyncLocalStorage.<span class="hljs-title function_">enterWith</span>(store);
+asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the store object</span>
+<span class="hljs-title function_">someAsyncOperation</span>(<span class="hljs-function">() =></span> {
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the same object</span>
 });</code></pre>
 <p>This transition will continue for the <em>entire</em> synchronous execution.
 This means that if, for example, the context is entered within an event
 handler subsequent event handlers will also run within that context unless
-specifically bound to another context with an <code>AsyncResource</code>.</p>
+specifically bound to another context with an <code>AsyncResource</code>. That is why
+<code>run()</code> should be preferred over <code>enterWith()</code> unless there are strong reasons
+to use the latter method.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> store = { <span class="hljs-attr">id</span>: <span class="hljs-number">1</span> };
 
-emitter.on(<span class="hljs-string">'my-event'</span>, <span class="hljs-function">() =></span> {
-  asyncLocalStorage.enterWith(store);
+emitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'my-event'</span>, <span class="hljs-function">() =></span> {
+  asyncLocalStorage.<span class="hljs-title function_">enterWith</span>(store);
 });
-emitter.on(<span class="hljs-string">'my-event'</span>, <span class="hljs-function">() =></span> {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the same object</span>
+emitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'my-event'</span>, <span class="hljs-function">() =></span> {
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the same object</span>
 });
 
-asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns undefined</span>
-emitter.emit(<span class="hljs-string">'my-event'</span>);
-asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the same object</span></code></pre>
-<h3><code>asyncLocalStorage.run(store, callback[, ...args])</code><span><a class="mark" href="#async_hooks_asynclocalstorage_run_store_callback_args" id="async_hooks_asynclocalstorage_run_store_callback_args">#</a></span></h3>
+asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns undefined</span>
+emitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'my-event'</span>);
+asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the same object</span></code></pre>
+<h4><code>asyncLocalStorage.run(store, callback[, ...args])</code><span><a class="mark" href="#async_hooks_asynclocalstorage_run_store_callback_args" id="async_hooks_asynclocalstorage_run_store_callback_args">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <ul>
 <li><code>store</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
-<p>This methods runs a function synchronously within a context and return its
-return value. The store is not accessible outside of the callback function or
-the asynchronous operations created within the callback.</p>
-<p>Optionally, arguments can be passed to the function. They will be passed to
-the callback function.</p>
-<p>If the callback function throws an error, it will be thrown by <code>run</code> too.
-The stacktrace will not be impacted by this call and the context will
-be exited.</p>
+<p>Runs a function synchronously within a context and returns its
+return value. The store is not accessible outside of the callback function.
+The store is accessible to any asynchronous operations created within the
+callback.</p>
+<p>The optional <code>args</code> are passed to the callback function.</p>
+<p>If the callback function throws an error, the error is thrown by <code>run()</code> too.
+The stacktrace is not impacted by this call and the context is exited.</p>
 <p>Example:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> store = { <span class="hljs-attr">id</span>: <span class="hljs-number">2</span> };
 <span class="hljs-keyword">try</span> {
-  asyncLocalStorage.run(store, <span class="hljs-function">() =></span> {
-    asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the store object</span>
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>();
+  asyncLocalStorage.<span class="hljs-title function_">run</span>(store, <span class="hljs-function">() =></span> {
+    asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the store object</span>
+    <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
+      asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the store object</span>
+    }, <span class="hljs-number">200</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>();
   });
 } <span class="hljs-keyword">catch</span> (e) {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns undefined</span>
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns undefined</span>
   <span class="hljs-comment">// The error will be caught here</span>
 }</code></pre>
-<h3><code>asyncLocalStorage.exit(callback[, ...args])</code><span><a class="mark" href="#async_hooks_asynclocalstorage_exit_callback_args" id="async_hooks_asynclocalstorage_exit_callback_args">#</a></span></h3>
+<h4><code>asyncLocalStorage.exit(callback[, ...args])</code><span><a class="mark" href="#async_hooks_asynclocalstorage_exit_callback_args" id="async_hooks_asynclocalstorage_exit_callback_args">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
-<p>This methods runs a function synchronously outside of a context and return its
+<p>Runs a function synchronously outside of a context and returns its
 return value. The store is not accessible within the callback function or
-the asynchronous operations created within the callback.</p>
-<p>Optionally, arguments can be passed to the function. They will be passed to
-the callback function.</p>
-<p>If the callback function throws an error, it will be thrown by <code>exit</code> too.
-The stacktrace will not be impacted by this call and
-the context will be re-entered.</p>
+the asynchronous operations created within the callback. Any <code>getStore()</code>
+call done within the callback function will always return <code>undefined</code>.</p>
+<p>The optional <code>args</code> are passed to the callback function.</p>
+<p>If the callback function throws an error, the error is thrown by <code>exit()</code> too.
+The stacktrace is not impacted by this call and the context is re-entered.</p>
 <p>Example:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Within a call to run</span>
 <span class="hljs-keyword">try</span> {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the store object or value</span>
-  asyncLocalStorage.exit(<span class="hljs-function">() =></span> {
-    asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns undefined</span>
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>();
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the store object or value</span>
+  asyncLocalStorage.<span class="hljs-title function_">exit</span>(<span class="hljs-function">() =></span> {
+    asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns undefined</span>
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>();
   });
 } <span class="hljs-keyword">catch</span> (e) {
-  asyncLocalStorage.getStore(); <span class="hljs-comment">// Returns the same object or value</span>
+  asyncLocalStorage.<span class="hljs-title function_">getStore</span>(); <span class="hljs-comment">// Returns the same object or value</span>
   <span class="hljs-comment">// The error will be caught here</span>
 }</code></pre>
-<h3>Usage with <code>async/await</code><span><a class="mark" href="#async_hooks_usage_with_async_await" id="async_hooks_usage_with_async_await">#</a></span></h3>
+<h4>Usage with <code>async/await</code><span><a class="mark" href="#async_hooks_usage_with_async_await" id="async_hooks_usage_with_async_await">#</a></span></h4>
 <p>If, within an async function, only one <code>await</code> call is to run within a context,
 the following pattern should be used:</p>
-<pre><code class="language-js"><span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">fn</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> asyncLocalStorage.run(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>(), <span class="hljs-function">() =></span> {
-    asyncLocalStorage.getStore().set(<span class="hljs-string">'key'</span>, value);
-    <span class="hljs-keyword">return</span> foo(); <span class="hljs-comment">// The return value of foo will be awaited</span>
+<pre><code class="language-js"><span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">fn</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> asyncLocalStorage.<span class="hljs-title function_">run</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>(), <span class="hljs-function">() =></span> {
+    asyncLocalStorage.<span class="hljs-title function_">getStore</span>().<span class="hljs-title function_">set</span>(<span class="hljs-string">'key'</span>, value);
+    <span class="hljs-keyword">return</span> <span class="hljs-title function_">foo</span>(); <span class="hljs-comment">// The return value of foo will be awaited</span>
   });
 }</code></pre>
 <p>In this example, the store is only available in the callback function and the
 functions called by <code>foo</code>. Outside of <code>run</code>, calling <code>getStore</code> will return
 <code>undefined</code>.</p>
-<h3>Troubleshooting<span><a class="mark" href="#async_hooks_troubleshooting" id="async_hooks_troubleshooting">#</a></span></h3>
+<h4>Troubleshooting<span><a class="mark" href="#async_hooks_troubleshooting" id="async_hooks_troubleshooting">#</a></span></h4>
 <p>In most cases your application or library code should have no issues with
 <code>AsyncLocalStorage</code>. But in rare cases you may face situations when the
 current store is lost in one of asynchronous operations. In those cases,
@@ -1145,10 +1171,46 @@ consider the following options.</p>
 <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>, so it starts working with native promises.</p>
 <p>If you need to keep using callback-based API, or your code assumes
 a custom thenable implementation, use the <a href="#async_hooks_class_asyncresource"><code>AsyncResource</code></a> class
-to associate the asynchronous operation with the correct execution context.</p>
+to associate the asynchronous operation with the correct execution context.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/async_hooks.json b/doc/api/async_hooks.json
index e32022b454939746fd6358abe02a09af3607364f..42198c4cb6c060171d1f6d7d6fed25c52ad7640e 100644
--- a/doc/api/async_hooks.json
+++ b/doc/api/async_hooks.json
@@ -8,7 +8,7 @@
       "introduced_in": "v8.1.0",
       "stability": 1,
       "stabilityText": "Experimental",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/async_hooks.js\">lib/async_hooks.js</a></p>\n<p>The <code>async_hooks</code> module provides an API to track asynchronous resources. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/async_hooks.js\">lib/async_hooks.js</a></p>\n<p>The <code>async_hooks</code> module provides an API to track asynchronous resources. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Terminology",
@@ -18,363 +18,11 @@
           "displayName": "Terminology"
         },
         {
-          "textRaw": "Public API",
-          "name": "public_api",
-          "modules": [
-            {
-              "textRaw": "Overview",
-              "name": "overview",
-              "desc": "<p>Following is a simple overview of the public API.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\n// Return the ID of the current execution context.\nconst eid = async_hooks.executionAsyncId();\n\n// Return the ID of the handle responsible for triggering the callback of the\n// current execution scope to call.\nconst tid = async_hooks.triggerAsyncId();\n\n// Create a new AsyncHook instance. All of these callbacks are optional.\nconst asyncHook =\n    async_hooks.createHook({ init, before, after, destroy, promiseResolve });\n\n// Allow callbacks of this AsyncHook instance to call. This is not an implicit\n// action after running the constructor, and must be explicitly run to begin\n// executing callbacks.\nasyncHook.enable();\n\n// Disable listening for new asynchronous events.\nasyncHook.disable();\n\n//\n// The following are the callbacks that can be passed to createHook().\n//\n\n// init is called during object construction. The resource may not have\n// completed construction when this callback runs, therefore all fields of the\n// resource referenced by \"asyncId\" may not have been populated.\nfunction init(asyncId, type, triggerAsyncId, resource) { }\n\n// Before is called just before the resource's callback is called. It can be\n// called 0-N times for handles (e.g. TCPWrap), and will be called exactly 1\n// time for requests (e.g. FSReqCallback).\nfunction before(asyncId) { }\n\n// After is called just after the resource's callback has finished.\nfunction after(asyncId) { }\n\n// Destroy is called when the resource is destroyed.\nfunction destroy(asyncId) { }\n\n// promiseResolve is called only for promise resources, when the\n// `resolve` function passed to the `Promise` constructor is invoked\n// (either directly or through other means of resolving a promise).\nfunction promiseResolve(asyncId) { }\n</code></pre>",
-              "methods": [
-                {
-                  "textRaw": "`async_hooks.createHook(callbacks)`",
-                  "type": "method",
-                  "name": "createHook",
-                  "meta": {
-                    "added": [
-                      "v8.1.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {AsyncHook} Instance used for disabling and enabling hooks",
-                        "name": "return",
-                        "type": "AsyncHook",
-                        "desc": "Instance used for disabling and enabling hooks"
-                      },
-                      "params": [
-                        {
-                          "textRaw": "`callbacks` {Object} The [Hook Callbacks][] to register",
-                          "name": "callbacks",
-                          "type": "Object",
-                          "desc": "The [Hook Callbacks][] to register",
-                          "options": [
-                            {
-                              "textRaw": "`init` {Function} The [`init` callback][].",
-                              "name": "init",
-                              "type": "Function",
-                              "desc": "The [`init` callback][]."
-                            },
-                            {
-                              "textRaw": "`before` {Function} The [`before` callback][].",
-                              "name": "before",
-                              "type": "Function",
-                              "desc": "The [`before` callback][]."
-                            },
-                            {
-                              "textRaw": "`after` {Function} The [`after` callback][].",
-                              "name": "after",
-                              "type": "Function",
-                              "desc": "The [`after` callback][]."
-                            },
-                            {
-                              "textRaw": "`destroy` {Function} The [`destroy` callback][].",
-                              "name": "destroy",
-                              "type": "Function",
-                              "desc": "The [`destroy` callback][]."
-                            },
-                            {
-                              "textRaw": "`promiseResolve` {Function} The [`promiseResolve` callback][].",
-                              "name": "promiseResolve",
-                              "type": "Function",
-                              "desc": "The [`promiseResolve` callback][]."
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  ],
-                  "desc": "<p>Registers functions to be called for different lifetime events of each async\noperation.</p>\n<p>The callbacks <code>init()</code>/<code>before()</code>/<code>after()</code>/<code>destroy()</code> are called for the\nrespective asynchronous event during a resource's lifetime.</p>\n<p>All callbacks are optional. For example, if only resource cleanup needs to\nbe tracked, then only the <code>destroy</code> callback needs to be passed. The\nspecifics of all functions that can be passed to <code>callbacks</code> is in the\n<a href=\"#async_hooks_hook_callbacks\">Hook Callbacks</a> section.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconst asyncHook = async_hooks.createHook({\n  init(asyncId, type, triggerAsyncId, resource) { },\n  destroy(asyncId) { }\n});\n</code></pre>\n<p>The callbacks will be inherited via the prototype chain:</p>\n<pre><code class=\"language-js\">class MyAsyncCallbacks {\n  init(asyncId, type, triggerAsyncId, resource) { }\n  destroy(asyncId) {}\n}\n\nclass MyAddedCallbacks extends MyAsyncCallbacks {\n  before(asyncId) { }\n  after(asyncId) { }\n}\n\nconst asyncHook = async_hooks.createHook(new MyAddedCallbacks());\n</code></pre>",
-                  "modules": [
-                    {
-                      "textRaw": "Error handling",
-                      "name": "error_handling",
-                      "desc": "<p>If any <code>AsyncHook</code> callbacks throw, the application will print the stack trace\nand exit. The exit path does follow that of an uncaught exception, but\nall <code>'uncaughtException'</code> listeners are removed, thus forcing the process to\nexit. The <code>'exit'</code> callbacks will still be called unless the application is run\nwith <code>--abort-on-uncaught-exception</code>, in which case a stack trace will be\nprinted and the application exits, leaving a core file.</p>\n<p>The reason for this error handling behavior is that these callbacks are running\nat potentially volatile points in an object's lifetime, for example during\nclass construction and destruction. Because of this, it is deemed necessary to\nbring down the process quickly in order to prevent an unintentional abort in the\nfuture. This is subject to change in the future if a comprehensive analysis is\nperformed to ensure an exception can follow the normal control flow without\nunintentional side effects.</p>",
-                      "type": "module",
-                      "displayName": "Error handling"
-                    },
-                    {
-                      "textRaw": "Printing in AsyncHooks callbacks",
-                      "name": "printing_in_asynchooks_callbacks",
-                      "desc": "<p>Because printing to the console is an asynchronous operation, <code>console.log()</code>\nwill cause the AsyncHooks callbacks to be called. Using <code>console.log()</code> or\nsimilar asynchronous operations inside an AsyncHooks callback function will thus\ncause an infinite recursion. An easy solution to this when debugging is to use a\nsynchronous logging operation such as <code>fs.writeFileSync(file, msg, flag)</code>.\nThis will print to the file and will not invoke AsyncHooks recursively because\nit is synchronous.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst util = require('util');\n\nfunction debug(...args) {\n  // Use a function like this one when debugging inside an AsyncHooks callback\n  fs.writeFileSync('log.out', `${util.format(...args)}\\n`, { flag: 'a' });\n}\n</code></pre>\n<p>If an asynchronous operation is needed for logging, it is possible to keep\ntrack of what caused the asynchronous operation using the information\nprovided by AsyncHooks itself. The logging should then be skipped when\nit was the logging itself that caused AsyncHooks callback to call. By\ndoing this the otherwise infinite recursion is broken.</p>",
-                      "type": "module",
-                      "displayName": "Printing in AsyncHooks callbacks"
-                    }
-                  ]
-                }
-              ],
-              "type": "module",
-              "displayName": "Overview"
-            }
-          ],
-          "classes": [
-            {
-              "textRaw": "Class: `AsyncHook`",
-              "type": "class",
-              "name": "AsyncHook",
-              "desc": "<p>The class <code>AsyncHook</code> exposes an interface for tracking lifetime events\nof asynchronous operations.</p>",
-              "methods": [
-                {
-                  "textRaw": "`asyncHook.enable()`",
-                  "type": "method",
-                  "name": "enable",
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {AsyncHook} A reference to `asyncHook`.",
-                        "name": "return",
-                        "type": "AsyncHook",
-                        "desc": "A reference to `asyncHook`."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Enable the callbacks for a given <code>AsyncHook</code> instance. If no callbacks are\nprovided enabling is a noop.</p>\n<p>The <code>AsyncHook</code> instance is disabled by default. If the <code>AsyncHook</code> instance\nshould be enabled immediately after creation, the following pattern can be used.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconst hook = async_hooks.createHook(callbacks).enable();\n</code></pre>"
-                },
-                {
-                  "textRaw": "`asyncHook.disable()`",
-                  "type": "method",
-                  "name": "disable",
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {AsyncHook} A reference to `asyncHook`.",
-                        "name": "return",
-                        "type": "AsyncHook",
-                        "desc": "A reference to `asyncHook`."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Disable the callbacks for a given <code>AsyncHook</code> instance from the global pool of\n<code>AsyncHook</code> callbacks to be executed. Once a hook has been disabled it will not\nbe called again until enabled.</p>\n<p>For API consistency <code>disable()</code> also returns the <code>AsyncHook</code> instance.</p>"
-                },
-                {
-                  "textRaw": "`async_hooks.executionAsyncResource()`",
-                  "type": "method",
-                  "name": "executionAsyncResource",
-                  "meta": {
-                    "added": [
-                      "v12.17.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {Object} The resource representing the current execution. Useful to store data within the resource.",
-                        "name": "return",
-                        "type": "Object",
-                        "desc": "The resource representing the current execution. Useful to store data within the resource."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Resource objects returned by <code>executionAsyncResource()</code> are most often internal\nNode.js handle objects with undocumented APIs. Using any functions or properties\non the object is likely to crash your application and should be avoided.</p>\n<p>Using <code>executionAsyncResource()</code> in the top-level execution context will\nreturn an empty object as there is no handle or request object to use,\nbut having an object representing the top-level can be helpful.</p>\n<pre><code class=\"language-js\">const { open } = require('fs');\nconst { executionAsyncId, executionAsyncResource } = require('async_hooks');\n\nconsole.log(executionAsyncId(), executionAsyncResource());  // 1 {}\nopen(__filename, 'r', (err, fd) => {\n  console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap\n});\n</code></pre>\n<p>This can be used to implement continuation local storage without the\nuse of a tracking <code>Map</code> to store the metadata:</p>\n<pre><code class=\"language-js\">const { createServer } = require('http');\nconst {\n  executionAsyncId,\n  executionAsyncResource,\n  createHook\n} = require('async_hooks');\nconst sym = Symbol('state'); // Private symbol to avoid pollution\n\ncreateHook({\n  init(asyncId, type, triggerAsyncId, resource) {\n    const cr = executionAsyncResource();\n    if (cr) {\n      resource[sym] = cr[sym];\n    }\n  }\n}).enable();\n\nconst server = createServer((req, res) => {\n  executionAsyncResource()[sym] = { state: req.url };\n  setTimeout(function() {\n    res.end(JSON.stringify(executionAsyncResource()[sym]));\n  }, 100);\n}).listen(3000);\n</code></pre>"
-                },
-                {
-                  "textRaw": "`async_hooks.executionAsyncId()`",
-                  "type": "method",
-                  "name": "executionAsyncId",
-                  "meta": {
-                    "added": [
-                      "v8.1.0"
-                    ],
-                    "changes": [
-                      {
-                        "version": "v8.2.0",
-                        "pr-url": "https://github.com/nodejs/node/pull/13490",
-                        "description": "Renamed from `currentId`"
-                      }
-                    ]
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {number} The `asyncId` of the current execution context. Useful to track when something calls.",
-                        "name": "return",
-                        "type": "number",
-                        "desc": "The `asyncId` of the current execution context. Useful to track when something calls."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconsole.log(async_hooks.executionAsyncId());  // 1 - bootstrap\nfs.open(path, 'r', (err, fd) => {\n  console.log(async_hooks.executionAsyncId());  // 6 - open()\n});\n</code></pre>\n<p>The ID returned from <code>executionAsyncId()</code> is related to execution timing, not\ncausality (which is covered by <code>triggerAsyncId()</code>):</p>\n<pre><code class=\"language-js\">const server = net.createServer((conn) => {\n  // Returns the ID of the server, not of the new connection, because the\n  // callback runs in the execution scope of the server's MakeCallback().\n  async_hooks.executionAsyncId();\n\n}).listen(port, () => {\n  // Returns the ID of a TickObject (i.e. process.nextTick()) because all\n  // callbacks passed to .listen() are wrapped in a nextTick().\n  async_hooks.executionAsyncId();\n});\n</code></pre>\n<p>Promise contexts may not get precise <code>executionAsyncIds</code> by default.\nSee the section on <a href=\"#async_hooks_promise_execution_tracking\">promise execution tracking</a>.</p>"
-                },
-                {
-                  "textRaw": "`async_hooks.triggerAsyncId()`",
-                  "type": "method",
-                  "name": "triggerAsyncId",
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {number} The ID of the resource responsible for calling the callback that is currently being executed.",
-                        "name": "return",
-                        "type": "number",
-                        "desc": "The ID of the resource responsible for calling the callback that is currently being executed."
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<pre><code class=\"language-js\">const server = net.createServer((conn) => {\n  // The resource that caused (or triggered) this callback to be called\n  // was that of the new connection. Thus the return value of triggerAsyncId()\n  // is the asyncId of \"conn\".\n  async_hooks.triggerAsyncId();\n\n}).listen(port, () => {\n  // Even though all callbacks passed to .listen() are wrapped in a nextTick()\n  // the callback itself exists because the call to the server's .listen()\n  // was made. So the return value would be the ID of the server.\n  async_hooks.triggerAsyncId();\n});\n</code></pre>\n<p>Promise contexts may not get valid <code>triggerAsyncId</code>s by default. See\nthe section on <a href=\"#async_hooks_promise_execution_tracking\">promise execution tracking</a>.</p>"
-                }
-              ],
-              "modules": [
-                {
-                  "textRaw": "Hook callbacks",
-                  "name": "hook_callbacks",
-                  "desc": "<p>Key events in the lifetime of asynchronous events have been categorized into\nfour areas: instantiation, before/after the callback is called, and when the\ninstance is destroyed.</p>",
-                  "methods": [
-                    {
-                      "textRaw": "`init(asyncId, type, triggerAsyncId, resource)`",
-                      "type": "method",
-                      "name": "init",
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number} A unique ID for the async resource.",
-                              "name": "asyncId",
-                              "type": "number",
-                              "desc": "A unique ID for the async resource."
-                            },
-                            {
-                              "textRaw": "`type` {string} The type of the async resource.",
-                              "name": "type",
-                              "type": "string",
-                              "desc": "The type of the async resource."
-                            },
-                            {
-                              "textRaw": "`triggerAsyncId` {number} The unique ID of the async resource in whose execution context this async resource was created.",
-                              "name": "triggerAsyncId",
-                              "type": "number",
-                              "desc": "The unique ID of the async resource in whose execution context this async resource was created."
-                            },
-                            {
-                              "textRaw": "`resource` {Object} Reference to the resource representing the async operation, needs to be released during _destroy_.",
-                              "name": "resource",
-                              "type": "Object",
-                              "desc": "Reference to the resource representing the async operation, needs to be released during _destroy_."
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>Called when a class is constructed that has the <em>possibility</em> to emit an\nasynchronous event. This <em>does not</em> mean the instance must call\n<code>before</code>/<code>after</code> before <code>destroy</code> is called, only that the possibility\nexists.</p>\n<p>This behavior can be observed by doing something like opening a resource then\nclosing it before the resource can be used. The following snippet demonstrates\nthis.</p>\n<pre><code class=\"language-js\">require('net').createServer().listen(function() { this.close(); });\n// OR\nclearTimeout(setTimeout(() => {}, 10));\n</code></pre>\n<p>Every new resource is assigned an ID that is unique within the scope of the\ncurrent Node.js instance.</p>",
-                      "modules": [
-                        {
-                          "textRaw": "`type`",
-                          "name": "`type`",
-                          "desc": "<p>The <code>type</code> is a string identifying the type of resource that caused\n<code>init</code> to be called. Generally, it will correspond to the name of the\nresource's constructor.</p>\n<pre><code class=\"language-text\">FSEVENTWRAP, FSREQCALLBACK, GETADDRINFOREQWRAP, GETNAMEINFOREQWRAP, HTTPINCOMINGMESSAGE,\nHTTPCLIENTREQUEST, JSSTREAM, PIPECONNECTWRAP, PIPEWRAP, PROCESSWRAP, QUERYWRAP,\nSHUTDOWNWRAP, SIGNALWRAP, STATWATCHER, TCPCONNECTWRAP, TCPSERVERWRAP, TCPWRAP,\nTTYWRAP, UDPSENDWRAP, UDPWRAP, WRITEWRAP, ZLIB, SSLCONNECTION, PBKDF2REQUEST,\nRANDOMBYTESREQUEST, TLSWRAP, Microtask, Timeout, Immediate, TickObject\n</code></pre>\n<p>There is also the <code>PROMISE</code> resource type, which is used to track <code>Promise</code>\ninstances and asynchronous work scheduled by them.</p>\n<p>Users are able to define their own <code>type</code> when using the public embedder API.</p>\n<p>It is possible to have type name collisions. Embedders are encouraged to use\nunique prefixes, such as the npm package name, to prevent collisions when\nlistening to the hooks.</p>",
-                          "type": "module",
-                          "displayName": "`type`"
-                        },
-                        {
-                          "textRaw": "`triggerAsyncId`",
-                          "name": "`triggerasyncid`",
-                          "desc": "<p><code>triggerAsyncId</code> is the <code>asyncId</code> of the resource that caused (or \"triggered\")\nthe new resource to initialize and that caused <code>init</code> to call. This is different\nfrom <code>async_hooks.executionAsyncId()</code> that only shows <em>when</em> a resource was\ncreated, while <code>triggerAsyncId</code> shows <em>why</em> a resource was created.</p>\n<p>The following is a simple demonstration of <code>triggerAsyncId</code>:</p>\n<pre><code class=\"language-js\">async_hooks.createHook({\n  init(asyncId, type, triggerAsyncId) {\n    const eid = async_hooks.executionAsyncId();\n    fs.writeSync(\n      process.stdout.fd,\n      `${type}(${asyncId}): trigger: ${triggerAsyncId} execution: ${eid}\\n`);\n  }\n}).enable();\n\nrequire('net').createServer((conn) => {}).listen(8080);\n</code></pre>\n<p>Output when hitting the server with <code>nc localhost 8080</code>:</p>\n<pre><code class=\"language-console\">TCPSERVERWRAP(5): trigger: 1 execution: 1\nTCPWRAP(7): trigger: 5 execution: 0\n</code></pre>\n<p>The <code>TCPSERVERWRAP</code> is the server which receives the connections.</p>\n<p>The <code>TCPWRAP</code> is the new connection from the client. When a new\nconnection is made, the <code>TCPWrap</code> instance is immediately constructed. This\nhappens outside of any JavaScript stack. (An <code>executionAsyncId()</code> of <code>0</code> means\nthat it is being executed from C++ with no JavaScript stack above it.) With only\nthat information, it would be impossible to link resources together in\nterms of what caused them to be created, so <code>triggerAsyncId</code> is given the task\nof propagating what resource is responsible for the new resource's existence.</p>",
-                          "type": "module",
-                          "displayName": "`triggerAsyncId`"
-                        },
-                        {
-                          "textRaw": "`resource`",
-                          "name": "`resource`",
-                          "desc": "<p><code>resource</code> is an object that represents the actual async resource that has\nbeen initialized. This can contain useful information that can vary based on\nthe value of <code>type</code>. For instance, for the <code>GETADDRINFOREQWRAP</code> resource type,\n<code>resource</code> provides the host name used when looking up the IP address for the\nhost in <code>net.Server.listen()</code>. The API for accessing this information is\nnot supported, but using the Embedder API, users can provide\nand document their own resource objects. For example, such a resource object\ncould contain the SQL query being executed.</p>\n<p>In the case of Promises, the <code>resource</code> object will have an\n<code>isChainedPromise</code> property, set to <code>true</code> if the promise has a parent promise,\nand <code>false</code> otherwise. For example, in the case of <code>b = a.then(handler)</code>, <code>a</code> is\nconsidered a parent <code>Promise</code> of <code>b</code>. Here, <code>b</code> is considered a chained promise.</p>\n<p>In some cases the resource object is reused for performance reasons, it is\nthus not safe to use it as a key in a <code>WeakMap</code> or add properties to it.</p>",
-                          "type": "module",
-                          "displayName": "`resource`"
-                        },
-                        {
-                          "textRaw": "Asynchronous context example",
-                          "name": "asynchronous_context_example",
-                          "desc": "<p>The following is an example with additional information about the calls to\n<code>init</code> between the <code>before</code> and <code>after</code> calls, specifically what the\ncallback to <code>listen()</code> will look like. The output formatting is slightly more\nelaborate to make calling context easier to see.</p>\n<pre><code class=\"language-js\">let indent = 0;\nasync_hooks.createHook({\n  init(asyncId, type, triggerAsyncId) {\n    const eid = async_hooks.executionAsyncId();\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(\n      process.stdout.fd,\n      `${indentStr}${type}(${asyncId}):` +\n      ` trigger: ${triggerAsyncId} execution: ${eid}\\n`);\n  },\n  before(asyncId) {\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(process.stdout.fd, `${indentStr}before:  ${asyncId}\\n`);\n    indent += 2;\n  },\n  after(asyncId) {\n    indent -= 2;\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(process.stdout.fd, `${indentStr}after:  ${asyncId}\\n`);\n  },\n  destroy(asyncId) {\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(process.stdout.fd, `${indentStr}destroy:  ${asyncId}\\n`);\n  },\n}).enable();\n\nrequire('net').createServer(() => {}).listen(8080, () => {\n  // Let's wait 10ms before logging the server started.\n  setTimeout(() => {\n    console.log('>>>', async_hooks.executionAsyncId());\n  }, 10);\n});\n</code></pre>\n<p>Output from only starting the server:</p>\n<pre><code class=\"language-console\">TCPSERVERWRAP(5): trigger: 1 execution: 1\nTickObject(6): trigger: 5 execution: 1\nbefore:  6\n  Timeout(7): trigger: 6 execution: 6\nafter:   6\ndestroy: 6\nbefore:  7\n>>> 7\n  TickObject(8): trigger: 7 execution: 7\nafter:   7\nbefore:  8\nafter:   8\n</code></pre>\n<p>As illustrated in the example, <code>executionAsyncId()</code> and <code>execution</code> each specify\nthe value of the current execution context; which is delineated by calls to\n<code>before</code> and <code>after</code>.</p>\n<p>Only using <code>execution</code> to graph resource allocation results in the following:</p>\n<pre><code class=\"language-console\">  root(1)\n     ^\n     |\nTickObject(6)\n     ^\n     |\n Timeout(7)\n</code></pre>\n<p>The <code>TCPSERVERWRAP</code> is not part of this graph, even though it was the reason for\n<code>console.log()</code> being called. This is because binding to a port without a host\nname is a <em>synchronous</em> operation, but to maintain a completely asynchronous\nAPI the user's callback is placed in a <code>process.nextTick()</code>. Which is why\n<code>TickObject</code> is present in the output and is a 'parent' for <code>.listen()</code>\ncallback.</p>\n<p>The graph only shows <em>when</em> a resource was created, not <em>why</em>, so to track\nthe <em>why</em> use <code>triggerAsyncId</code>. Which can be represented with the following\ngraph:</p>\n<pre><code class=\"language-console\"> bootstrap(1)\n     |\n     ˅\nTCPSERVERWRAP(5)\n     |\n     ˅\n TickObject(6)\n     |\n     ˅\n  Timeout(7)\n</code></pre>",
-                          "type": "module",
-                          "displayName": "Asynchronous context example"
-                        }
-                      ]
-                    },
-                    {
-                      "textRaw": "`before(asyncId)`",
-                      "type": "method",
-                      "name": "before",
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number}",
-                              "name": "asyncId",
-                              "type": "number"
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>When an asynchronous operation is initiated (such as a TCP server receiving a\nnew connection) or completes (such as writing data to disk) a callback is\ncalled to notify the user. The <code>before</code> callback is called just before said\ncallback is executed. <code>asyncId</code> is the unique identifier assigned to the\nresource about to execute the callback.</p>\n<p>The <code>before</code> callback will be called 0 to N times. The <code>before</code> callback\nwill typically be called 0 times if the asynchronous operation was cancelled\nor, for example, if no connections are received by a TCP server. Persistent\nasynchronous resources like a TCP server will typically call the <code>before</code>\ncallback multiple times, while other operations like <code>fs.open()</code> will call\nit only once.</p>"
-                    },
-                    {
-                      "textRaw": "`after(asyncId)`",
-                      "type": "method",
-                      "name": "after",
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number}",
-                              "name": "asyncId",
-                              "type": "number"
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>Called immediately after the callback specified in <code>before</code> is completed.</p>\n<p>If an uncaught exception occurs during execution of the callback, then <code>after</code>\nwill run <em>after</em> the <code>'uncaughtException'</code> event is emitted or a <code>domain</code>'s\nhandler runs.</p>"
-                    },
-                    {
-                      "textRaw": "`destroy(asyncId)`",
-                      "type": "method",
-                      "name": "destroy",
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number}",
-                              "name": "asyncId",
-                              "type": "number"
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>Called after the resource corresponding to <code>asyncId</code> is destroyed. It is also\ncalled asynchronously from the embedder API <code>emitDestroy()</code>.</p>\n<p>Some resources depend on garbage collection for cleanup, so if a reference is\nmade to the <code>resource</code> object passed to <code>init</code> it is possible that <code>destroy</code>\nwill never be called, causing a memory leak in the application. If the resource\ndoes not depend on garbage collection, then this will not be an issue.</p>"
-                    },
-                    {
-                      "textRaw": "`promiseResolve(asyncId)`",
-                      "type": "method",
-                      "name": "promiseResolve",
-                      "meta": {
-                        "added": [
-                          "v8.6.0"
-                        ],
-                        "changes": []
-                      },
-                      "signatures": [
-                        {
-                          "params": [
-                            {
-                              "textRaw": "`asyncId` {number}",
-                              "name": "asyncId",
-                              "type": "number"
-                            }
-                          ]
-                        }
-                      ],
-                      "desc": "<p>Called when the <code>resolve</code> function passed to the <code>Promise</code> constructor is\ninvoked (either directly or through other means of resolving a promise).</p>\n<p><code>resolve()</code> does not do any observable synchronous work.</p>\n<p>The <code>Promise</code> is not necessarily fulfilled or rejected at this point if the\n<code>Promise</code> was resolved by assuming the state of another <code>Promise</code>.</p>\n<pre><code class=\"language-js\">new Promise((resolve) => resolve(true)).then((a) => {});\n</code></pre>\n<p>calls the following callbacks:</p>\n<pre><code class=\"language-text\">init for PROMISE with id 5, trigger id: 1\n  promise resolve 5      # corresponds to resolve(true)\ninit for PROMISE with id 6, trigger id: 5  # the Promise returned by then()\n  before 6               # the then() callback is entered\n  promise resolve 6      # the then() callback resolves the promise by returning\n  after 6\n</code></pre>"
-                    }
-                  ],
-                  "type": "module",
-                  "displayName": "Hook callbacks"
-                }
-              ]
-            }
-          ],
+          "textRaw": "Overview",
+          "name": "overview",
+          "desc": "<p>Following is a simple overview of the public API.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\n// Return the ID of the current execution context.\nconst eid = async_hooks.executionAsyncId();\n\n// Return the ID of the handle responsible for triggering the callback of the\n// current execution scope to call.\nconst tid = async_hooks.triggerAsyncId();\n\n// Create a new AsyncHook instance. All of these callbacks are optional.\nconst asyncHook =\n    async_hooks.createHook({ init, before, after, destroy, promiseResolve });\n\n// Allow callbacks of this AsyncHook instance to call. This is not an implicit\n// action after running the constructor, and must be explicitly run to begin\n// executing callbacks.\nasyncHook.enable();\n\n// Disable listening for new asynchronous events.\nasyncHook.disable();\n\n//\n// The following are the callbacks that can be passed to createHook().\n//\n\n// init is called during object construction. The resource may not have\n// completed construction when this callback runs, therefore all fields of the\n// resource referenced by \"asyncId\" may not have been populated.\nfunction init(asyncId, type, triggerAsyncId, resource) { }\n\n// Before is called just before the resource's callback is called. It can be\n// called 0-N times for handles (such as TCPWrap), and will be called exactly 1\n// time for requests (such as FSReqCallback).\nfunction before(asyncId) { }\n\n// After is called just after the resource's callback has finished.\nfunction after(asyncId) { }\n\n// Destroy is called when the resource is destroyed.\nfunction destroy(asyncId) { }\n\n// promiseResolve is called only for promise resources, when the\n// `resolve` function passed to the `Promise` constructor is invoked\n// (either directly or through other means of resolving a promise).\nfunction promiseResolve(asyncId) { }\n</code></pre>",
           "type": "module",
-          "displayName": "Public API"
+          "displayName": "Overview"
         },
         {
           "textRaw": "Promise execution tracking",
@@ -400,7 +48,7 @@
                   "name": "bind",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.8.0"
                     ],
                     "changes": []
                   },
@@ -432,7 +80,7 @@
                   "name": "bind",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.8.0"
                     ],
                     "changes": []
                   },
@@ -577,7 +225,7 @@
             {
               "textRaw": "Using `AsyncResource` for a `Worker` thread pool",
               "name": "using_`asyncresource`_for_a_`worker`_thread_pool",
-              "desc": "<p>The following example shows how to use the <code>AsyncResource</code> class to properly\nprovide async tracking for a <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> pool. Other resource pools, such as\ndatabase connection pools, can follow a similar model.</p>\n<p>Assuming that the task is adding two numbers, using a file named\n<code>task_processor.js</code> with the following content:</p>\n<pre><code class=\"language-js\">const { parentPort } = require('worker_threads');\nparentPort.on('message', (task) => {\n  parentPort.postMessage(task.a + task.b);\n});\n</code></pre>\n<p>a Worker pool around it could use the following structure:</p>\n<pre><code class=\"language-js\">const { AsyncResource } = require('async_hooks');\nconst { EventEmitter } = require('events');\nconst path = require('path');\nconst { Worker } = require('worker_threads');\n\nconst kTaskInfo = Symbol('kTaskInfo');\nconst kWorkerFreedEvent = Symbol('kWorkerFreedEvent');\n\nclass WorkerPoolTaskInfo extends AsyncResource {\n  constructor(callback) {\n    super('WorkerPoolTaskInfo');\n    this.callback = callback;\n  }\n\n  done(err, result) {\n    this.runInAsyncScope(this.callback, null, err, result);\n    this.emitDestroy();  // `TaskInfo`s are used only once.\n  }\n}\n\nclass WorkerPool extends EventEmitter {\n  constructor(numThreads) {\n    super();\n    this.numThreads = numThreads;\n    this.workers = [];\n    this.freeWorkers = [];\n\n    for (let i = 0; i &#x3C; numThreads; i++)\n      this.addNewWorker();\n  }\n\n  addNewWorker() {\n    const worker = new Worker(path.resolve(__dirname, 'task_processor.js'));\n    worker.on('message', (result) => {\n      // In case of success: Call the callback that was passed to `runTask`,\n      // remove the `TaskInfo` associated with the Worker, and mark it as free\n      // again.\n      worker[kTaskInfo].done(null, result);\n      worker[kTaskInfo] = null;\n      this.freeWorkers.push(worker);\n      this.emit(kWorkerFreedEvent);\n    });\n    worker.on('error', (err) => {\n      // In case of an uncaught exception: Call the callback that was passed to\n      // `runTask` with the error.\n      if (worker[kTaskInfo])\n        worker[kTaskInfo].done(err, null);\n      else\n        this.emit('error', err);\n      // Remove the worker from the list and start a new Worker to replace the\n      // current one.\n      this.workers.splice(this.workers.indexOf(worker), 1);\n      this.addNewWorker();\n    });\n    this.workers.push(worker);\n    this.freeWorkers.push(worker);\n    this.emit(kWorkerFreedEvent);\n  }\n\n  runTask(task, callback) {\n    if (this.freeWorkers.length === 0) {\n      // No free threads, wait until a worker thread becomes free.\n      this.once(kWorkerFreedEvent, () => this.runTask(task, callback));\n      return;\n    }\n\n    const worker = this.freeWorkers.pop();\n    worker[kTaskInfo] = new WorkerPoolTaskInfo(callback);\n    worker.postMessage(task);\n  }\n\n  close() {\n    for (const worker of this.workers) worker.terminate();\n  }\n}\n\nmodule.exports = WorkerPool;\n</code></pre>\n<p>Without the explicit tracking added by the <code>WorkerPoolTaskInfo</code> objects,\nit would appear that the callbacks are associated with the individual <code>Worker</code>\nobjects. However, the creation of the <code>Worker</code>s is not associated with the\ncreation of the tasks and does not provide information about when tasks\nwere scheduled.</p>\n<p>This pool could be used as follows:</p>\n<pre><code class=\"language-js\">const WorkerPool = require('./worker_pool.js');\nconst os = require('os');\n\nconst pool = new WorkerPool(os.cpus().length);\n\nlet finished = 0;\nfor (let i = 0; i &#x3C; 10; i++) {\n  pool.runTask({ a: 42, b: 100 }, (err, result) => {\n    console.log(i, err, result);\n    if (++finished === 10)\n      pool.close();\n  });\n}\n</code></pre>",
+              "desc": "<p>The following example shows how to use the <code>AsyncResource</code> class to properly\nprovide async tracking for a <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> pool. Other resource pools, such as\ndatabase connection pools, can follow a similar model.</p>\n<p>Assuming that the task is adding two numbers, using a file named\n<code>task_processor.js</code> with the following content:</p>\n<pre><code class=\"language-js\">const { parentPort } = require('worker_threads');\nparentPort.on('message', (task) => {\n  parentPort.postMessage(task.a + task.b);\n});\n</code></pre>\n<p>a Worker pool around it could use the following structure:</p>\n<pre><code class=\"language-js\">const { AsyncResource } = require('async_hooks');\nconst { EventEmitter } = require('events');\nconst path = require('path');\nconst { Worker } = require('worker_threads');\n\nconst kTaskInfo = Symbol('kTaskInfo');\nconst kWorkerFreedEvent = Symbol('kWorkerFreedEvent');\n\nclass WorkerPoolTaskInfo extends AsyncResource {\n  constructor(callback) {\n    super('WorkerPoolTaskInfo');\n    this.callback = callback;\n  }\n\n  done(err, result) {\n    this.runInAsyncScope(this.callback, null, err, result);\n    this.emitDestroy();  // `TaskInfo`s are used only once.\n  }\n}\n\nclass WorkerPool extends EventEmitter {\n  constructor(numThreads) {\n    super();\n    this.numThreads = numThreads;\n    this.workers = [];\n    this.freeWorkers = [];\n    this.tasks = [];\n\n    for (let i = 0; i &#x3C; numThreads; i++)\n      this.addNewWorker();\n\n    // Any time the kWorkerFreedEvent is emitted, dispatch\n    // the next task pending in the queue, if any.\n    this.on(kWorkerFreedEvent, () => {\n      if (this.tasks.length > 0) {\n        const { task, callback } = this.tasks.shift();\n        this.runTask(task, callback);\n      }\n    });\n  }\n\n  addNewWorker() {\n    const worker = new Worker(path.resolve(__dirname, 'task_processor.js'));\n    worker.on('message', (result) => {\n      // In case of success: Call the callback that was passed to `runTask`,\n      // remove the `TaskInfo` associated with the Worker, and mark it as free\n      // again.\n      worker[kTaskInfo].done(null, result);\n      worker[kTaskInfo] = null;\n      this.freeWorkers.push(worker);\n      this.emit(kWorkerFreedEvent);\n    });\n    worker.on('error', (err) => {\n      // In case of an uncaught exception: Call the callback that was passed to\n      // `runTask` with the error.\n      if (worker[kTaskInfo])\n        worker[kTaskInfo].done(err, null);\n      else\n        this.emit('error', err);\n      // Remove the worker from the list and start a new Worker to replace the\n      // current one.\n      this.workers.splice(this.workers.indexOf(worker), 1);\n      this.addNewWorker();\n    });\n    this.workers.push(worker);\n    this.freeWorkers.push(worker);\n    this.emit(kWorkerFreedEvent);\n  }\n\n  runTask(task, callback) {\n    if (this.freeWorkers.length === 0) {\n      // No free threads, wait until a worker thread becomes free.\n      this.tasks.push({ task, callback });\n      return;\n    }\n\n    const worker = this.freeWorkers.pop();\n    worker[kTaskInfo] = new WorkerPoolTaskInfo(callback);\n    worker.postMessage(task);\n  }\n\n  close() {\n    for (const worker of this.workers) worker.terminate();\n  }\n}\n\nmodule.exports = WorkerPool;\n</code></pre>\n<p>Without the explicit tracking added by the <code>WorkerPoolTaskInfo</code> objects,\nit would appear that the callbacks are associated with the individual <code>Worker</code>\nobjects. However, the creation of the <code>Worker</code>s is not associated with the\ncreation of the tasks and does not provide information about when tasks\nwere scheduled.</p>\n<p>This pool could be used as follows:</p>\n<pre><code class=\"language-js\">const WorkerPool = require('./worker_pool.js');\nconst os = require('os');\n\nconst pool = new WorkerPool(os.cpus().length);\n\nlet finished = 0;\nfor (let i = 0; i &#x3C; 10; i++) {\n  pool.runTask({ a: 42, b: 100 }, (err, result) => {\n    console.log(i, err, result);\n    if (++finished === 10)\n      pool.close();\n  });\n}\n</code></pre>",
               "type": "module",
               "displayName": "Using `AsyncResource` for a `Worker` thread pool"
             },
@@ -593,18 +241,360 @@
           "displayName": "JavaScript embedder API"
         }
       ],
+      "methods": [
+        {
+          "textRaw": "`async_hooks.createHook(callbacks)`",
+          "type": "method",
+          "name": "createHook",
+          "meta": {
+            "added": [
+              "v8.1.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {AsyncHook} Instance used for disabling and enabling hooks",
+                "name": "return",
+                "type": "AsyncHook",
+                "desc": "Instance used for disabling and enabling hooks"
+              },
+              "params": [
+                {
+                  "textRaw": "`callbacks` {Object} The [Hook Callbacks][] to register",
+                  "name": "callbacks",
+                  "type": "Object",
+                  "desc": "The [Hook Callbacks][] to register",
+                  "options": [
+                    {
+                      "textRaw": "`init` {Function} The [`init` callback][].",
+                      "name": "init",
+                      "type": "Function",
+                      "desc": "The [`init` callback][]."
+                    },
+                    {
+                      "textRaw": "`before` {Function} The [`before` callback][].",
+                      "name": "before",
+                      "type": "Function",
+                      "desc": "The [`before` callback][]."
+                    },
+                    {
+                      "textRaw": "`after` {Function} The [`after` callback][].",
+                      "name": "after",
+                      "type": "Function",
+                      "desc": "The [`after` callback][]."
+                    },
+                    {
+                      "textRaw": "`destroy` {Function} The [`destroy` callback][].",
+                      "name": "destroy",
+                      "type": "Function",
+                      "desc": "The [`destroy` callback][]."
+                    },
+                    {
+                      "textRaw": "`promiseResolve` {Function} The [`promiseResolve` callback][].",
+                      "name": "promiseResolve",
+                      "type": "Function",
+                      "desc": "The [`promiseResolve` callback][]."
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Registers functions to be called for different lifetime events of each async\noperation.</p>\n<p>The callbacks <code>init()</code>/<code>before()</code>/<code>after()</code>/<code>destroy()</code> are called for the\nrespective asynchronous event during a resource's lifetime.</p>\n<p>All callbacks are optional. For example, if only resource cleanup needs to\nbe tracked, then only the <code>destroy</code> callback needs to be passed. The\nspecifics of all functions that can be passed to <code>callbacks</code> is in the\n<a href=\"#async_hooks_hook_callbacks\">Hook Callbacks</a> section.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconst asyncHook = async_hooks.createHook({\n  init(asyncId, type, triggerAsyncId, resource) { },\n  destroy(asyncId) { }\n});\n</code></pre>\n<p>The callbacks will be inherited via the prototype chain:</p>\n<pre><code class=\"language-js\">class MyAsyncCallbacks {\n  init(asyncId, type, triggerAsyncId, resource) { }\n  destroy(asyncId) {}\n}\n\nclass MyAddedCallbacks extends MyAsyncCallbacks {\n  before(asyncId) { }\n  after(asyncId) { }\n}\n\nconst asyncHook = async_hooks.createHook(new MyAddedCallbacks());\n</code></pre>\n<p>Because promises are asynchronous resources whose lifecycle is tracked\nvia the async hooks mechanism, the <code>init()</code>, <code>before()</code>, <code>after()</code>, and\n<code>destroy()</code> callbacks <em>must not</em> be async functions that return promises.</p>",
+          "modules": [
+            {
+              "textRaw": "Error handling",
+              "name": "error_handling",
+              "desc": "<p>If any <code>AsyncHook</code> callbacks throw, the application will print the stack trace\nand exit. The exit path does follow that of an uncaught exception, but\nall <code>'uncaughtException'</code> listeners are removed, thus forcing the process to\nexit. The <code>'exit'</code> callbacks will still be called unless the application is run\nwith <code>--abort-on-uncaught-exception</code>, in which case a stack trace will be\nprinted and the application exits, leaving a core file.</p>\n<p>The reason for this error handling behavior is that these callbacks are running\nat potentially volatile points in an object's lifetime, for example during\nclass construction and destruction. Because of this, it is deemed necessary to\nbring down the process quickly in order to prevent an unintentional abort in the\nfuture. This is subject to change in the future if a comprehensive analysis is\nperformed to ensure an exception can follow the normal control flow without\nunintentional side effects.</p>",
+              "type": "module",
+              "displayName": "Error handling"
+            },
+            {
+              "textRaw": "Printing in AsyncHooks callbacks",
+              "name": "printing_in_asynchooks_callbacks",
+              "desc": "<p>Because printing to the console is an asynchronous operation, <code>console.log()</code>\nwill cause the AsyncHooks callbacks to be called. Using <code>console.log()</code> or\nsimilar asynchronous operations inside an AsyncHooks callback function will thus\ncause an infinite recursion. An easy solution to this when debugging is to use a\nsynchronous logging operation such as <code>fs.writeFileSync(file, msg, flag)</code>.\nThis will print to the file and will not invoke AsyncHooks recursively because\nit is synchronous.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst util = require('util');\n\nfunction debug(...args) {\n  // Use a function like this one when debugging inside an AsyncHooks callback\n  fs.writeFileSync('log.out', `${util.format(...args)}\\n`, { flag: 'a' });\n}\n</code></pre>\n<p>If an asynchronous operation is needed for logging, it is possible to keep\ntrack of what caused the asynchronous operation using the information\nprovided by AsyncHooks itself. The logging should then be skipped when\nit was the logging itself that caused AsyncHooks callback to call. By\ndoing this the otherwise infinite recursion is broken.</p>",
+              "type": "module",
+              "displayName": "Printing in AsyncHooks callbacks"
+            }
+          ]
+        }
+      ],
       "classes": [
+        {
+          "textRaw": "Class: `AsyncHook`",
+          "type": "class",
+          "name": "AsyncHook",
+          "desc": "<p>The class <code>AsyncHook</code> exposes an interface for tracking lifetime events\nof asynchronous operations.</p>",
+          "methods": [
+            {
+              "textRaw": "`asyncHook.enable()`",
+              "type": "method",
+              "name": "enable",
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {AsyncHook} A reference to `asyncHook`.",
+                    "name": "return",
+                    "type": "AsyncHook",
+                    "desc": "A reference to `asyncHook`."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Enable the callbacks for a given <code>AsyncHook</code> instance. If no callbacks are\nprovided, enabling is a no-op.</p>\n<p>The <code>AsyncHook</code> instance is disabled by default. If the <code>AsyncHook</code> instance\nshould be enabled immediately after creation, the following pattern can be used.</p>\n<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconst hook = async_hooks.createHook(callbacks).enable();\n</code></pre>"
+            },
+            {
+              "textRaw": "`asyncHook.disable()`",
+              "type": "method",
+              "name": "disable",
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {AsyncHook} A reference to `asyncHook`.",
+                    "name": "return",
+                    "type": "AsyncHook",
+                    "desc": "A reference to `asyncHook`."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Disable the callbacks for a given <code>AsyncHook</code> instance from the global pool of\n<code>AsyncHook</code> callbacks to be executed. Once a hook has been disabled it will not\nbe called again until enabled.</p>\n<p>For API consistency <code>disable()</code> also returns the <code>AsyncHook</code> instance.</p>"
+            },
+            {
+              "textRaw": "`async_hooks.executionAsyncResource()`",
+              "type": "method",
+              "name": "executionAsyncResource",
+              "meta": {
+                "added": [
+                  "v13.9.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Object} The resource representing the current execution. Useful to store data within the resource.",
+                    "name": "return",
+                    "type": "Object",
+                    "desc": "The resource representing the current execution. Useful to store data within the resource."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Resource objects returned by <code>executionAsyncResource()</code> are most often internal\nNode.js handle objects with undocumented APIs. Using any functions or properties\non the object is likely to crash your application and should be avoided.</p>\n<p>Using <code>executionAsyncResource()</code> in the top-level execution context will\nreturn an empty object as there is no handle or request object to use,\nbut having an object representing the top-level can be helpful.</p>\n<pre><code class=\"language-js\">const { open } = require('fs');\nconst { executionAsyncId, executionAsyncResource } = require('async_hooks');\n\nconsole.log(executionAsyncId(), executionAsyncResource());  // 1 {}\nopen(__filename, 'r', (err, fd) => {\n  console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap\n});\n</code></pre>\n<p>This can be used to implement continuation local storage without the\nuse of a tracking <code>Map</code> to store the metadata:</p>\n<pre><code class=\"language-js\">const { createServer } = require('http');\nconst {\n  executionAsyncId,\n  executionAsyncResource,\n  createHook\n} = require('async_hooks');\nconst sym = Symbol('state'); // Private symbol to avoid pollution\n\ncreateHook({\n  init(asyncId, type, triggerAsyncId, resource) {\n    const cr = executionAsyncResource();\n    if (cr) {\n      resource[sym] = cr[sym];\n    }\n  }\n}).enable();\n\nconst server = createServer((req, res) => {\n  executionAsyncResource()[sym] = { state: req.url };\n  setTimeout(function() {\n    res.end(JSON.stringify(executionAsyncResource()[sym]));\n  }, 100);\n}).listen(3000);\n</code></pre>"
+            },
+            {
+              "textRaw": "`async_hooks.executionAsyncId()`",
+              "type": "method",
+              "name": "executionAsyncId",
+              "meta": {
+                "added": [
+                  "v8.1.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v8.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/13490",
+                    "description": "Renamed from `currentId`."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {number} The `asyncId` of the current execution context. Useful to track when something calls.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The `asyncId` of the current execution context. Useful to track when something calls."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<pre><code class=\"language-js\">const async_hooks = require('async_hooks');\n\nconsole.log(async_hooks.executionAsyncId());  // 1 - bootstrap\nfs.open(path, 'r', (err, fd) => {\n  console.log(async_hooks.executionAsyncId());  // 6 - open()\n});\n</code></pre>\n<p>The ID returned from <code>executionAsyncId()</code> is related to execution timing, not\ncausality (which is covered by <code>triggerAsyncId()</code>):</p>\n<pre><code class=\"language-js\">const server = net.createServer((conn) => {\n  // Returns the ID of the server, not of the new connection, because the\n  // callback runs in the execution scope of the server's MakeCallback().\n  async_hooks.executionAsyncId();\n\n}).listen(port, () => {\n  // Returns the ID of a TickObject (process.nextTick()) because all\n  // callbacks passed to .listen() are wrapped in a nextTick().\n  async_hooks.executionAsyncId();\n});\n</code></pre>\n<p>Promise contexts may not get precise <code>executionAsyncIds</code> by default.\nSee the section on <a href=\"#async_hooks_promise_execution_tracking\">promise execution tracking</a>.</p>"
+            },
+            {
+              "textRaw": "`async_hooks.triggerAsyncId()`",
+              "type": "method",
+              "name": "triggerAsyncId",
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {number} The ID of the resource responsible for calling the callback that is currently being executed.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The ID of the resource responsible for calling the callback that is currently being executed."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<pre><code class=\"language-js\">const server = net.createServer((conn) => {\n  // The resource that caused (or triggered) this callback to be called\n  // was that of the new connection. Thus the return value of triggerAsyncId()\n  // is the asyncId of \"conn\".\n  async_hooks.triggerAsyncId();\n\n}).listen(port, () => {\n  // Even though all callbacks passed to .listen() are wrapped in a nextTick()\n  // the callback itself exists because the call to the server's .listen()\n  // was made. So the return value would be the ID of the server.\n  async_hooks.triggerAsyncId();\n});\n</code></pre>\n<p>Promise contexts may not get valid <code>triggerAsyncId</code>s by default. See\nthe section on <a href=\"#async_hooks_promise_execution_tracking\">promise execution tracking</a>.</p>"
+            }
+          ],
+          "modules": [
+            {
+              "textRaw": "Hook callbacks",
+              "name": "hook_callbacks",
+              "desc": "<p>Key events in the lifetime of asynchronous events have been categorized into\nfour areas: instantiation, before/after the callback is called, and when the\ninstance is destroyed.</p>",
+              "methods": [
+                {
+                  "textRaw": "`init(asyncId, type, triggerAsyncId, resource)`",
+                  "type": "method",
+                  "name": "init",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number} A unique ID for the async resource.",
+                          "name": "asyncId",
+                          "type": "number",
+                          "desc": "A unique ID for the async resource."
+                        },
+                        {
+                          "textRaw": "`type` {string} The type of the async resource.",
+                          "name": "type",
+                          "type": "string",
+                          "desc": "The type of the async resource."
+                        },
+                        {
+                          "textRaw": "`triggerAsyncId` {number} The unique ID of the async resource in whose execution context this async resource was created.",
+                          "name": "triggerAsyncId",
+                          "type": "number",
+                          "desc": "The unique ID of the async resource in whose execution context this async resource was created."
+                        },
+                        {
+                          "textRaw": "`resource` {Object} Reference to the resource representing the async operation, needs to be released during _destroy_.",
+                          "name": "resource",
+                          "type": "Object",
+                          "desc": "Reference to the resource representing the async operation, needs to be released during _destroy_."
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Called when a class is constructed that has the <em>possibility</em> to emit an\nasynchronous event. This <em>does not</em> mean the instance must call\n<code>before</code>/<code>after</code> before <code>destroy</code> is called, only that the possibility\nexists.</p>\n<p>This behavior can be observed by doing something like opening a resource then\nclosing it before the resource can be used. The following snippet demonstrates\nthis.</p>\n<pre><code class=\"language-js\">require('net').createServer().listen(function() { this.close(); });\n// OR\nclearTimeout(setTimeout(() => {}, 10));\n</code></pre>\n<p>Every new resource is assigned an ID that is unique within the scope of the\ncurrent Node.js instance.</p>",
+                  "modules": [
+                    {
+                      "textRaw": "`type`",
+                      "name": "`type`",
+                      "desc": "<p>The <code>type</code> is a string identifying the type of resource that caused\n<code>init</code> to be called. Generally, it will correspond to the name of the\nresource's constructor.</p>\n<pre><code class=\"language-text\">FSEVENTWRAP, FSREQCALLBACK, GETADDRINFOREQWRAP, GETNAMEINFOREQWRAP, HTTPINCOMINGMESSAGE,\nHTTPCLIENTREQUEST, JSSTREAM, PIPECONNECTWRAP, PIPEWRAP, PROCESSWRAP, QUERYWRAP,\nSHUTDOWNWRAP, SIGNALWRAP, STATWATCHER, TCPCONNECTWRAP, TCPSERVERWRAP, TCPWRAP,\nTTYWRAP, UDPSENDWRAP, UDPWRAP, WRITEWRAP, ZLIB, SSLCONNECTION, PBKDF2REQUEST,\nRANDOMBYTESREQUEST, TLSWRAP, Microtask, Timeout, Immediate, TickObject\n</code></pre>\n<p>There is also the <code>PROMISE</code> resource type, which is used to track <code>Promise</code>\ninstances and asynchronous work scheduled by them.</p>\n<p>Users are able to define their own <code>type</code> when using the public embedder API.</p>\n<p>It is possible to have type name collisions. Embedders are encouraged to use\nunique prefixes, such as the npm package name, to prevent collisions when\nlistening to the hooks.</p>",
+                      "type": "module",
+                      "displayName": "`type`"
+                    },
+                    {
+                      "textRaw": "`triggerAsyncId`",
+                      "name": "`triggerasyncid`",
+                      "desc": "<p><code>triggerAsyncId</code> is the <code>asyncId</code> of the resource that caused (or \"triggered\")\nthe new resource to initialize and that caused <code>init</code> to call. This is different\nfrom <code>async_hooks.executionAsyncId()</code> that only shows <em>when</em> a resource was\ncreated, while <code>triggerAsyncId</code> shows <em>why</em> a resource was created.</p>\n<p>The following is a simple demonstration of <code>triggerAsyncId</code>:</p>\n<pre><code class=\"language-js\">const { fd } = process.stdout;\n\nasync_hooks.createHook({\n  init(asyncId, type, triggerAsyncId) {\n    const eid = async_hooks.executionAsyncId();\n    fs.writeSync(\n      fd,\n      `${type}(${asyncId}): trigger: ${triggerAsyncId} execution: ${eid}\\n`);\n  }\n}).enable();\n\nnet.createServer((conn) => {}).listen(8080);\n</code></pre>\n<p>Output when hitting the server with <code>nc localhost 8080</code>:</p>\n<pre><code class=\"language-console\">TCPSERVERWRAP(5): trigger: 1 execution: 1\nTCPWRAP(7): trigger: 5 execution: 0\n</code></pre>\n<p>The <code>TCPSERVERWRAP</code> is the server which receives the connections.</p>\n<p>The <code>TCPWRAP</code> is the new connection from the client. When a new\nconnection is made, the <code>TCPWrap</code> instance is immediately constructed. This\nhappens outside of any JavaScript stack. (An <code>executionAsyncId()</code> of <code>0</code> means\nthat it is being executed from C++ with no JavaScript stack above it.) With only\nthat information, it would be impossible to link resources together in\nterms of what caused them to be created, so <code>triggerAsyncId</code> is given the task\nof propagating what resource is responsible for the new resource's existence.</p>",
+                      "type": "module",
+                      "displayName": "`triggerAsyncId`"
+                    },
+                    {
+                      "textRaw": "`resource`",
+                      "name": "`resource`",
+                      "desc": "<p><code>resource</code> is an object that represents the actual async resource that has\nbeen initialized. This can contain useful information that can vary based on\nthe value of <code>type</code>. For instance, for the <code>GETADDRINFOREQWRAP</code> resource type,\n<code>resource</code> provides the host name used when looking up the IP address for the\nhost in <code>net.Server.listen()</code>. The API for accessing this information is\nnot supported, but using the Embedder API, users can provide\nand document their own resource objects. For example, such a resource object\ncould contain the SQL query being executed.</p>\n<p>In some cases the resource object is reused for performance reasons, it is\nthus not safe to use it as a key in a <code>WeakMap</code> or add properties to it.</p>",
+                      "type": "module",
+                      "displayName": "`resource`"
+                    },
+                    {
+                      "textRaw": "Asynchronous context example",
+                      "name": "asynchronous_context_example",
+                      "desc": "<p>The following is an example with additional information about the calls to\n<code>init</code> between the <code>before</code> and <code>after</code> calls, specifically what the\ncallback to <code>listen()</code> will look like. The output formatting is slightly more\nelaborate to make calling context easier to see.</p>\n<pre><code class=\"language-js\">const { fd } = process.stdout;\n\nlet indent = 0;\nasync_hooks.createHook({\n  init(asyncId, type, triggerAsyncId) {\n    const eid = async_hooks.executionAsyncId();\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(\n      fd,\n      `${indentStr}${type}(${asyncId}):` +\n      ` trigger: ${triggerAsyncId} execution: ${eid}\\n`);\n  },\n  before(asyncId) {\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(fd, `${indentStr}before:  ${asyncId}\\n`);\n    indent += 2;\n  },\n  after(asyncId) {\n    indent -= 2;\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(fd, `${indentStr}after:  ${asyncId}\\n`);\n  },\n  destroy(asyncId) {\n    const indentStr = ' '.repeat(indent);\n    fs.writeSync(fd, `${indentStr}destroy:  ${asyncId}\\n`);\n  },\n}).enable();\n\nnet.createServer(() => {}).listen(8080, () => {\n  // Let's wait 10ms before logging the server started.\n  setTimeout(() => {\n    console.log('>>>', async_hooks.executionAsyncId());\n  }, 10);\n});\n</code></pre>\n<p>Output from only starting the server:</p>\n<pre><code class=\"language-console\">TCPSERVERWRAP(5): trigger: 1 execution: 1\nTickObject(6): trigger: 5 execution: 1\nbefore:  6\n  Timeout(7): trigger: 6 execution: 6\nafter:   6\ndestroy: 6\nbefore:  7\n>>> 7\n  TickObject(8): trigger: 7 execution: 7\nafter:   7\nbefore:  8\nafter:   8\n</code></pre>\n<p>As illustrated in the example, <code>executionAsyncId()</code> and <code>execution</code> each specify\nthe value of the current execution context; which is delineated by calls to\n<code>before</code> and <code>after</code>.</p>\n<p>Only using <code>execution</code> to graph resource allocation results in the following:</p>\n<pre><code class=\"language-console\">  root(1)\n     ^\n     |\nTickObject(6)\n     ^\n     |\n Timeout(7)\n</code></pre>\n<p>The <code>TCPSERVERWRAP</code> is not part of this graph, even though it was the reason for\n<code>console.log()</code> being called. This is because binding to a port without a host\nname is a <em>synchronous</em> operation, but to maintain a completely asynchronous\nAPI the user's callback is placed in a <code>process.nextTick()</code>. Which is why\n<code>TickObject</code> is present in the output and is a 'parent' for <code>.listen()</code>\ncallback.</p>\n<p>The graph only shows <em>when</em> a resource was created, not <em>why</em>, so to track\nthe <em>why</em> use <code>triggerAsyncId</code>. Which can be represented with the following\ngraph:</p>\n<pre><code class=\"language-console\"> bootstrap(1)\n     |\n     ˅\nTCPSERVERWRAP(5)\n     |\n     ˅\n TickObject(6)\n     |\n     ˅\n  Timeout(7)\n</code></pre>",
+                      "type": "module",
+                      "displayName": "Asynchronous context example"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`before(asyncId)`",
+                  "type": "method",
+                  "name": "before",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number}",
+                          "name": "asyncId",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>When an asynchronous operation is initiated (such as a TCP server receiving a\nnew connection) or completes (such as writing data to disk) a callback is\ncalled to notify the user. The <code>before</code> callback is called just before said\ncallback is executed. <code>asyncId</code> is the unique identifier assigned to the\nresource about to execute the callback.</p>\n<p>The <code>before</code> callback will be called 0 to N times. The <code>before</code> callback\nwill typically be called 0 times if the asynchronous operation was cancelled\nor, for example, if no connections are received by a TCP server. Persistent\nasynchronous resources like a TCP server will typically call the <code>before</code>\ncallback multiple times, while other operations like <code>fs.open()</code> will call\nit only once.</p>"
+                },
+                {
+                  "textRaw": "`after(asyncId)`",
+                  "type": "method",
+                  "name": "after",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number}",
+                          "name": "asyncId",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Called immediately after the callback specified in <code>before</code> is completed.</p>\n<p>If an uncaught exception occurs during execution of the callback, then <code>after</code>\nwill run <em>after</em> the <code>'uncaughtException'</code> event is emitted or a <code>domain</code>'s\nhandler runs.</p>"
+                },
+                {
+                  "textRaw": "`destroy(asyncId)`",
+                  "type": "method",
+                  "name": "destroy",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number}",
+                          "name": "asyncId",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Called after the resource corresponding to <code>asyncId</code> is destroyed. It is also\ncalled asynchronously from the embedder API <code>emitDestroy()</code>.</p>\n<p>Some resources depend on garbage collection for cleanup, so if a reference is\nmade to the <code>resource</code> object passed to <code>init</code> it is possible that <code>destroy</code>\nwill never be called, causing a memory leak in the application. If the resource\ndoes not depend on garbage collection, then this will not be an issue.</p>"
+                },
+                {
+                  "textRaw": "`promiseResolve(asyncId)`",
+                  "type": "method",
+                  "name": "promiseResolve",
+                  "meta": {
+                    "added": [
+                      "v8.6.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`asyncId` {number}",
+                          "name": "asyncId",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Called when the <code>resolve</code> function passed to the <code>Promise</code> constructor is\ninvoked (either directly or through other means of resolving a promise).</p>\n<p><code>resolve()</code> does not do any observable synchronous work.</p>\n<p>The <code>Promise</code> is not necessarily fulfilled or rejected at this point if the\n<code>Promise</code> was resolved by assuming the state of another <code>Promise</code>.</p>\n<pre><code class=\"language-js\">new Promise((resolve) => resolve(true)).then((a) => {});\n</code></pre>\n<p>calls the following callbacks:</p>\n<pre><code class=\"language-text\">init for PROMISE with id 5, trigger id: 1\n  promise resolve 5      # corresponds to resolve(true)\ninit for PROMISE with id 6, trigger id: 5  # the Promise returned by then()\n  before 6               # the then() callback is entered\n  promise resolve 6      # the then() callback resolves the promise by returning\n  after 6\n</code></pre>"
+                }
+              ],
+              "type": "module",
+              "displayName": "Hook callbacks"
+            }
+          ]
+        },
         {
           "textRaw": "Class: `AsyncLocalStorage`",
           "type": "class",
           "name": "AsyncLocalStorage",
           "meta": {
             "added": [
-              "v12.17.0"
+              "v13.10.0"
             ],
             "changes": []
           },
-          "desc": "<p>This class is used to create asynchronous state within callbacks and promise\nchains. It allows storing data throughout the lifetime of a web request\nor any other asynchronous duration. It is similar to thread-local storage\nin other languages.</p>\n<p>The following example uses <code>AsyncLocalStorage</code> to build a simple logger\nthat assigns IDs to incoming HTTP requests and includes them in messages\nlogged within each request.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst { AsyncLocalStorage } = require('async_hooks');\n\nconst asyncLocalStorage = new AsyncLocalStorage();\n\nfunction logWithId(msg) {\n  const id = asyncLocalStorage.getStore();\n  console.log(`${id !== undefined ? id : '-'}:`, msg);\n}\n\nlet idSeq = 0;\nhttp.createServer((req, res) => {\n  asyncLocalStorage.run(idSeq++, () => {\n    logWithId('start');\n    // Imagine any chain of async operations here\n    setImmediate(() => {\n      logWithId('finish');\n      res.end();\n    });\n  });\n}).listen(8080);\n\nhttp.get('http://localhost:8080');\nhttp.get('http://localhost:8080');\n// Prints:\n//   0: start\n//   1: start\n//   0: finish\n//   1: finish\n</code></pre>\n<p>When having multiple instances of <code>AsyncLocalStorage</code>, they are independent\nfrom each other. It is safe to instantiate this class multiple times.</p>",
+          "desc": "<p>This class is used to create asynchronous state within callbacks and promise\nchains. It allows storing data throughout the lifetime of a web request\nor any other asynchronous duration. It is similar to thread-local storage\nin other languages.</p>\n<p>While you can create your own implementation on top of the <code>async_hooks</code> module,\n<code>AsyncLocalStorage</code> should be preferred as it is a performant and memory safe\nimplementation that involves significant optimizations that are non-obvious to\nimplement.</p>\n<p>The following example uses <code>AsyncLocalStorage</code> to build a simple logger\nthat assigns IDs to incoming HTTP requests and includes them in messages\nlogged within each request.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst { AsyncLocalStorage } = require('async_hooks');\n\nconst asyncLocalStorage = new AsyncLocalStorage();\n\nfunction logWithId(msg) {\n  const id = asyncLocalStorage.getStore();\n  console.log(`${id !== undefined ? id : '-'}:`, msg);\n}\n\nlet idSeq = 0;\nhttp.createServer((req, res) => {\n  asyncLocalStorage.run(idSeq++, () => {\n    logWithId('start');\n    // Imagine any chain of async operations here\n    setImmediate(() => {\n      logWithId('finish');\n      res.end();\n    });\n  });\n}).listen(8080);\n\nhttp.get('http://localhost:8080');\nhttp.get('http://localhost:8080');\n// Prints:\n//   0: start\n//   1: start\n//   0: finish\n//   1: finish\n</code></pre>\n<p>When having multiple instances of <code>AsyncLocalStorage</code>, they are independent\nfrom each other. It is safe to instantiate this class multiple times.</p>",
           "methods": [
             {
               "textRaw": "`asyncLocalStorage.disable()`",
@@ -612,7 +602,7 @@
               "name": "disable",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -621,7 +611,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>This method disables the instance of <code>AsyncLocalStorage</code>. All subsequent calls\nto <code>asyncLocalStorage.getStore()</code> will return <code>undefined</code> until\n<code>asyncLocalStorage.run()</code> is called again.</p>\n<p>When calling <code>asyncLocalStorage.disable()</code>, all current contexts linked to the\ninstance will be exited.</p>\n<p>Calling <code>asyncLocalStorage.disable()</code> is required before the\n<code>asyncLocalStorage</code> can be garbage collected. This does not apply to stores\nprovided by the <code>asyncLocalStorage</code>, as those objects are garbage collected\nalong with the corresponding async resources.</p>\n<p>This method is to be used when the <code>asyncLocalStorage</code> is not in use anymore\nin the current process.</p>"
+              "desc": "<p>Disables the instance of <code>AsyncLocalStorage</code>. All subsequent calls\nto <code>asyncLocalStorage.getStore()</code> will return <code>undefined</code> until\n<code>asyncLocalStorage.run()</code> or <code>asyncLocalStorage.enterWith()</code> is called again.</p>\n<p>When calling <code>asyncLocalStorage.disable()</code>, all current contexts linked to the\ninstance will be exited.</p>\n<p>Calling <code>asyncLocalStorage.disable()</code> is required before the\n<code>asyncLocalStorage</code> can be garbage collected. This does not apply to stores\nprovided by the <code>asyncLocalStorage</code>, as those objects are garbage collected\nalong with the corresponding async resources.</p>\n<p>Use this method when the <code>asyncLocalStorage</code> is not in use anymore\nin the current process.</p>"
             },
             {
               "textRaw": "`asyncLocalStorage.getStore()`",
@@ -629,7 +619,7 @@
               "name": "getStore",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -643,7 +633,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>This method returns the current store.\nIf this method is called outside of an asynchronous context initialized by\ncalling <code>asyncLocalStorage.run</code>, it will return <code>undefined</code>.</p>"
+              "desc": "<p>Returns the current store.\nIf called outside of an asynchronous context initialized by\ncalling <code>asyncLocalStorage.run()</code> or <code>asyncLocalStorage.enterWith()</code>, it\nreturns <code>undefined</code>.</p>"
             },
             {
               "textRaw": "`asyncLocalStorage.enterWith(store)`",
@@ -651,7 +641,7 @@
               "name": "enterWith",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.11.0"
                 ],
                 "changes": []
               },
@@ -666,7 +656,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Calling <code>asyncLocalStorage.enterWith(store)</code> will transition into the context\nfor the remainder of the current synchronous execution and will persist\nthrough any following asynchronous calls.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const store = { id: 1 };\nasyncLocalStorage.enterWith(store);\nasyncLocalStorage.getStore(); // Returns the store object\nsomeAsyncOperation(() => {\n  asyncLocalStorage.getStore(); // Returns the same object\n});\n</code></pre>\n<p>This transition will continue for the <em>entire</em> synchronous execution.\nThis means that if, for example, the context is entered within an event\nhandler subsequent event handlers will also run within that context unless\nspecifically bound to another context with an <code>AsyncResource</code>.</p>\n<pre><code class=\"language-js\">const store = { id: 1 };\n\nemitter.on('my-event', () => {\n  asyncLocalStorage.enterWith(store);\n});\nemitter.on('my-event', () => {\n  asyncLocalStorage.getStore(); // Returns the same object\n});\n\nasyncLocalStorage.getStore(); // Returns undefined\nemitter.emit('my-event');\nasyncLocalStorage.getStore(); // Returns the same object\n</code></pre>"
+              "desc": "<p>Transitions into the context for the remainder of the current\nsynchronous execution and then persists the store through any following\nasynchronous calls.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const store = { id: 1 };\n// Replaces previous store with the given store object\nasyncLocalStorage.enterWith(store);\nasyncLocalStorage.getStore(); // Returns the store object\nsomeAsyncOperation(() => {\n  asyncLocalStorage.getStore(); // Returns the same object\n});\n</code></pre>\n<p>This transition will continue for the <em>entire</em> synchronous execution.\nThis means that if, for example, the context is entered within an event\nhandler subsequent event handlers will also run within that context unless\nspecifically bound to another context with an <code>AsyncResource</code>. That is why\n<code>run()</code> should be preferred over <code>enterWith()</code> unless there are strong reasons\nto use the latter method.</p>\n<pre><code class=\"language-js\">const store = { id: 1 };\n\nemitter.on('my-event', () => {\n  asyncLocalStorage.enterWith(store);\n});\nemitter.on('my-event', () => {\n  asyncLocalStorage.getStore(); // Returns the same object\n});\n\nasyncLocalStorage.getStore(); // Returns undefined\nemitter.emit('my-event');\nasyncLocalStorage.getStore(); // Returns the same object\n</code></pre>"
             },
             {
               "textRaw": "`asyncLocalStorage.run(store, callback[, ...args])`",
@@ -674,7 +664,7 @@
               "name": "run",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -699,7 +689,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This methods runs a function synchronously within a context and return its\nreturn value. The store is not accessible outside of the callback function or\nthe asynchronous operations created within the callback.</p>\n<p>Optionally, arguments can be passed to the function. They will be passed to\nthe callback function.</p>\n<p>If the callback function throws an error, it will be thrown by <code>run</code> too.\nThe stacktrace will not be impacted by this call and the context will\nbe exited.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const store = { id: 2 };\ntry {\n  asyncLocalStorage.run(store, () => {\n    asyncLocalStorage.getStore(); // Returns the store object\n    throw new Error();\n  });\n} catch (e) {\n  asyncLocalStorage.getStore(); // Returns undefined\n  // The error will be caught here\n}\n</code></pre>"
+              "desc": "<p>Runs a function synchronously within a context and returns its\nreturn value. The store is not accessible outside of the callback function.\nThe store is accessible to any asynchronous operations created within the\ncallback.</p>\n<p>The optional <code>args</code> are passed to the callback function.</p>\n<p>If the callback function throws an error, the error is thrown by <code>run()</code> too.\nThe stacktrace is not impacted by this call and the context is exited.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const store = { id: 2 };\ntry {\n  asyncLocalStorage.run(store, () => {\n    asyncLocalStorage.getStore(); // Returns the store object\n    setTimeout(() => {\n      asyncLocalStorage.getStore(); // Returns the store object\n    }, 200);\n    throw new Error();\n  });\n} catch (e) {\n  asyncLocalStorage.getStore(); // Returns undefined\n  // The error will be caught here\n}\n</code></pre>"
             },
             {
               "textRaw": "`asyncLocalStorage.exit(callback[, ...args])`",
@@ -707,7 +697,7 @@
               "name": "exit",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -727,7 +717,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This methods runs a function synchronously outside of a context and return its\nreturn value. The store is not accessible within the callback function or\nthe asynchronous operations created within the callback.</p>\n<p>Optionally, arguments can be passed to the function. They will be passed to\nthe callback function.</p>\n<p>If the callback function throws an error, it will be thrown by <code>exit</code> too.\nThe stacktrace will not be impacted by this call and\nthe context will be re-entered.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">// Within a call to run\ntry {\n  asyncLocalStorage.getStore(); // Returns the store object or value\n  asyncLocalStorage.exit(() => {\n    asyncLocalStorage.getStore(); // Returns undefined\n    throw new Error();\n  });\n} catch (e) {\n  asyncLocalStorage.getStore(); // Returns the same object or value\n  // The error will be caught here\n}\n</code></pre>"
+              "desc": "<p>Runs a function synchronously outside of a context and returns its\nreturn value. The store is not accessible within the callback function or\nthe asynchronous operations created within the callback. Any <code>getStore()</code>\ncall done within the callback function will always return <code>undefined</code>.</p>\n<p>The optional <code>args</code> are passed to the callback function.</p>\n<p>If the callback function throws an error, the error is thrown by <code>exit()</code> too.\nThe stacktrace is not impacted by this call and the context is re-entered.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">// Within a call to run\ntry {\n  asyncLocalStorage.getStore(); // Returns the store object or value\n  asyncLocalStorage.exit(() => {\n    asyncLocalStorage.getStore(); // Returns undefined\n    throw new Error();\n  });\n} catch (e) {\n  asyncLocalStorage.getStore(); // Returns the same object or value\n  // The error will be caught here\n}\n</code></pre>"
             }
           ],
           "modules": [
@@ -749,7 +739,7 @@
           "signatures": [
             {
               "params": [],
-              "desc": "<p>Creates a new instance of <code>AsyncLocalStorage</code>. Store is only provided within a\n<code>run</code> method call.</p>"
+              "desc": "<p>Creates a new instance of <code>AsyncLocalStorage</code>. Store is only provided within a\n<code>run()</code> call or after an <code>enterWith()</code> call.</p>"
             }
           ]
         }
diff --git a/doc/api/async_hooks.md b/doc/api/async_hooks.md
index 8ddcbbce18a0a207576f266a11e8ccc9646bcdf5..f1c964fc20f4f38d0520cb71494f1052046d0f03 100644
--- a/doc/api/async_hooks.md
+++ b/doc/api/async_hooks.md
@@ -25,9 +25,7 @@ as the abstract concept that is a resource.
 If [`Worker`][]s are used, each thread has an independent `async_hooks`
 interface, and each thread will use a new set of async IDs.
 
-## Public API
-
-### Overview
+## Overview
 
 Following is a simple overview of the public API.
 
@@ -63,8 +61,8 @@ asyncHook.disable();
 function init(asyncId, type, triggerAsyncId, resource) { }
 
 // Before is called just before the resource's callback is called. It can be
-// called 0-N times for handles (e.g. TCPWrap), and will be called exactly 1
-// time for requests (e.g. FSReqCallback).
+// called 0-N times for handles (such as TCPWrap), and will be called exactly 1
+// time for requests (such as FSReqCallback).
 function before(asyncId) { }
 
 // After is called just after the resource's callback has finished.
@@ -79,7 +77,7 @@ function destroy(asyncId) { }
 function promiseResolve(asyncId) { }
 ```
 
-#### `async_hooks.createHook(callbacks)`
+## `async_hooks.createHook(callbacks)`
 
 <!-- YAML
 added: v8.1.0
@@ -129,7 +127,11 @@ class MyAddedCallbacks extends MyAsyncCallbacks {
 const asyncHook = async_hooks.createHook(new MyAddedCallbacks());
 ```
 
-##### Error handling
+Because promises are asynchronous resources whose lifecycle is tracked
+via the async hooks mechanism, the `init()`, `before()`, `after()`, and
+`destroy()` callbacks *must not* be async functions that return promises.
+
+### Error handling
 
 If any `AsyncHook` callbacks throw, the application will print the stack trace
 and exit. The exit path does follow that of an uncaught exception, but
@@ -146,7 +148,7 @@ future. This is subject to change in the future if a comprehensive analysis is
 performed to ensure an exception can follow the normal control flow without
 unintentional side effects.
 
-##### Printing in AsyncHooks callbacks
+### Printing in AsyncHooks callbacks
 
 Because printing to the console is an asynchronous operation, `console.log()`
 will cause the AsyncHooks callbacks to be called. Using `console.log()` or
@@ -172,17 +174,17 @@ provided by AsyncHooks itself. The logging should then be skipped when
 it was the logging itself that caused AsyncHooks callback to call. By
 doing this the otherwise infinite recursion is broken.
 
-### Class: `AsyncHook`
+## Class: `AsyncHook`
 
 The class `AsyncHook` exposes an interface for tracking lifetime events
 of asynchronous operations.
 
-#### `asyncHook.enable()`
+### `asyncHook.enable()`
 
 * Returns: {AsyncHook} A reference to `asyncHook`.
 
 Enable the callbacks for a given `AsyncHook` instance. If no callbacks are
-provided enabling is a noop.
+provided, enabling is a no-op.
 
 The `AsyncHook` instance is disabled by default. If the `AsyncHook` instance
 should be enabled immediately after creation, the following pattern can be used.
@@ -193,7 +195,7 @@ const async_hooks = require('async_hooks');
 const hook = async_hooks.createHook(callbacks).enable();
 ```
 
-#### `asyncHook.disable()`
+### `asyncHook.disable()`
 
 * Returns: {AsyncHook} A reference to `asyncHook`.
 
@@ -203,13 +205,13 @@ be called again until enabled.
 
 For API consistency `disable()` also returns the `AsyncHook` instance.
 
-#### Hook callbacks
+### Hook callbacks
 
 Key events in the lifetime of asynchronous events have been categorized into
 four areas: instantiation, before/after the callback is called, and when the
 instance is destroyed.
 
-##### `init(asyncId, type, triggerAsyncId, resource)`
+#### `init(asyncId, type, triggerAsyncId, resource)`
 
 * `asyncId` {number} A unique ID for the async resource.
 * `type` {string} The type of the async resource.
@@ -236,7 +238,7 @@ clearTimeout(setTimeout(() => {}, 10));
 Every new resource is assigned an ID that is unique within the scope of the
 current Node.js instance.
 
-###### `type`
+##### `type`
 
 The `type` is a string identifying the type of resource that caused
 `init` to be called. Generally, it will correspond to the name of the
@@ -259,7 +261,7 @@ It is possible to have type name collisions. Embedders are encouraged to use
 unique prefixes, such as the npm package name, to prevent collisions when
 listening to the hooks.
 
-###### `triggerAsyncId`
+##### `triggerAsyncId`
 
 `triggerAsyncId` is the `asyncId` of the resource that caused (or "triggered")
 the new resource to initialize and that caused `init` to call. This is different
@@ -269,16 +271,18 @@ created, while `triggerAsyncId` shows *why* a resource was created.
 The following is a simple demonstration of `triggerAsyncId`:
 
 ```js
+const { fd } = process.stdout;
+
 async_hooks.createHook({
   init(asyncId, type, triggerAsyncId) {
     const eid = async_hooks.executionAsyncId();
     fs.writeSync(
-      process.stdout.fd,
+      fd,
       `${type}(${asyncId}): trigger: ${triggerAsyncId} execution: ${eid}\n`);
   }
 }).enable();
 
-require('net').createServer((conn) => {}).listen(8080);
+net.createServer((conn) => {}).listen(8080);
 ```
 
 Output when hitting the server with `nc localhost 8080`:
@@ -298,7 +302,7 @@ that information, it would be impossible to link resources together in
 terms of what caused them to be created, so `triggerAsyncId` is given the task
 of propagating what resource is responsible for the new resource's existence.
 
-###### `resource`
+##### `resource`
 
 `resource` is an object that represents the actual async resource that has
 been initialized. This can contain useful information that can vary based on
@@ -309,15 +313,10 @@ not supported, but using the Embedder API, users can provide
 and document their own resource objects. For example, such a resource object
 could contain the SQL query being executed.
 
-In the case of Promises, the `resource` object will have an
-`isChainedPromise` property, set to `true` if the promise has a parent promise,
-and `false` otherwise. For example, in the case of `b = a.then(handler)`, `a` is
-considered a parent `Promise` of `b`. Here, `b` is considered a chained promise.
-
 In some cases the resource object is reused for performance reasons, it is
 thus not safe to use it as a key in a `WeakMap` or add properties to it.
 
-###### Asynchronous context example
+##### Asynchronous context example
 
 The following is an example with additional information about the calls to
 `init` between the `before` and `after` calls, specifically what the
@@ -325,33 +324,35 @@ callback to `listen()` will look like. The output formatting is slightly more
 elaborate to make calling context easier to see.
 
 ```js
+const { fd } = process.stdout;
+
 let indent = 0;
 async_hooks.createHook({
   init(asyncId, type, triggerAsyncId) {
     const eid = async_hooks.executionAsyncId();
     const indentStr = ' '.repeat(indent);
     fs.writeSync(
-      process.stdout.fd,
+      fd,
       `${indentStr}${type}(${asyncId}):` +
       ` trigger: ${triggerAsyncId} execution: ${eid}\n`);
   },
   before(asyncId) {
     const indentStr = ' '.repeat(indent);
-    fs.writeSync(process.stdout.fd, `${indentStr}before:  ${asyncId}\n`);
+    fs.writeSync(fd, `${indentStr}before:  ${asyncId}\n`);
     indent += 2;
   },
   after(asyncId) {
     indent -= 2;
     const indentStr = ' '.repeat(indent);
-    fs.writeSync(process.stdout.fd, `${indentStr}after:  ${asyncId}\n`);
+    fs.writeSync(fd, `${indentStr}after:  ${asyncId}\n`);
   },
   destroy(asyncId) {
     const indentStr = ' '.repeat(indent);
-    fs.writeSync(process.stdout.fd, `${indentStr}destroy:  ${asyncId}\n`);
+    fs.writeSync(fd, `${indentStr}destroy:  ${asyncId}\n`);
   },
 }).enable();
 
-require('net').createServer(() => {}).listen(8080, () => {
+net.createServer(() => {}).listen(8080, () => {
   // Let's wait 10ms before logging the server started.
   setTimeout(() => {
     console.log('>>>', async_hooks.executionAsyncId());
@@ -416,7 +417,7 @@ TCPSERVERWRAP(5)
   Timeout(7)
 ```
 
-##### `before(asyncId)`
+#### `before(asyncId)`
 
 * `asyncId` {number}
 
@@ -433,7 +434,7 @@ asynchronous resources like a TCP server will typically call the `before`
 callback multiple times, while other operations like `fs.open()` will call
 it only once.
 
-##### `after(asyncId)`
+#### `after(asyncId)`
 
 * `asyncId` {number}
 
@@ -443,7 +444,7 @@ If an uncaught exception occurs during execution of the callback, then `after`
 will run *after* the `'uncaughtException'` event is emitted or a `domain`'s
 handler runs.
 
-##### `destroy(asyncId)`
+#### `destroy(asyncId)`
 
 * `asyncId` {number}
 
@@ -455,7 +456,7 @@ made to the `resource` object passed to `init` it is possible that `destroy`
 will never be called, causing a memory leak in the application. If the resource
 does not depend on garbage collection, then this will not be an issue.
 
-##### `promiseResolve(asyncId)`
+#### `promiseResolve(asyncId)`
 
 <!-- YAML
 added: v8.6.0
@@ -486,10 +487,10 @@ init for PROMISE with id 6, trigger id: 5  # the Promise returned by then()
   after 6
 ```
 
-#### `async_hooks.executionAsyncResource()`
+### `async_hooks.executionAsyncResource()`
 
 <!-- YAML
-added: v12.17.0
+added: v13.9.0
 -->
 
 * Returns: {Object} The resource representing the current execution.
@@ -542,14 +543,14 @@ const server = createServer((req, res) => {
 }).listen(3000);
 ```
 
-#### `async_hooks.executionAsyncId()`
+### `async_hooks.executionAsyncId()`
 
 <!-- YAML
 added: v8.1.0
 changes:
   - version: v8.2.0
     pr-url: https://github.com/nodejs/node/pull/13490
-    description: Renamed from `currentId`
+    description: Renamed from `currentId`.
 -->
 
 * Returns: {number} The `asyncId` of the current execution context. Useful to
@@ -574,7 +575,7 @@ const server = net.createServer((conn) => {
   async_hooks.executionAsyncId();
 
 }).listen(port, () => {
-  // Returns the ID of a TickObject (i.e. process.nextTick()) because all
+  // Returns the ID of a TickObject (process.nextTick()) because all
   // callbacks passed to .listen() are wrapped in a nextTick().
   async_hooks.executionAsyncId();
 });
@@ -583,7 +584,7 @@ const server = net.createServer((conn) => {
 Promise contexts may not get precise `executionAsyncIds` by default.
 See the section on [promise execution tracking][].
 
-#### `async_hooks.triggerAsyncId()`
+### `async_hooks.triggerAsyncId()`
 
 * Returns: {number} The ID of the resource responsible for calling the callback
   that is currently being executed.
@@ -702,14 +703,14 @@ asyncResource.triggerAsyncId();
 * `type` {string} The type of async event.
 * `options` {Object}
   * `triggerAsyncId` {number} The ID of the execution context that created this
-  async event. **Default:** `executionAsyncId()`.
+    async event. **Default:** `executionAsyncId()`.
   * `requireManualDestroy` {boolean} If set to `true`, disables `emitDestroy`
-  when the object is garbage collected. This usually does not need to be set
-  (even if `emitDestroy` is called manually), unless the resource's `asyncId`
-  is retrieved and the sensitive API's `emitDestroy` is called with it.
-  When set to `false`, the `emitDestroy` call on garbage collection
-  will only take place if there is at least one active `destroy` hook.
-  **Default:** `false`.
+    when the object is garbage collected. This usually does not need to be set
+    (even if `emitDestroy` is called manually), unless the resource's `asyncId`
+    is retrieved and the sensitive API's `emitDestroy` is called with it.
+    When set to `false`, the `emitDestroy` call on garbage collection
+    will only take place if there is at least one active `destroy` hook.
+    **Default:** `false`.
 
 Example usage:
 
@@ -735,7 +736,7 @@ class DBQuery extends AsyncResource {
 
 #### Static method: `AsyncResource.bind(fn[, type])`
 <!-- YAML
-added: v12.19.0
+added: v14.8.0
 -->
 
 * `fn` {Function} The function to bind to the current execution context.
@@ -749,7 +750,7 @@ the `AsyncResource` to which the function is bound.
 
 #### `asyncResource.bind(fn)`
 <!-- YAML
-added: v12.19.0
+added: v14.8.0
 -->
 
 * `fn` {Function} The function to bind to the current `AsyncResource`.
@@ -790,7 +791,7 @@ never be called.
 #### `asyncResource.triggerAsyncId()`
 
 * Returns: {number} The same `triggerAsyncId` that is passed to the
-`AsyncResource` constructor.
+  `AsyncResource` constructor.
 
 <a id="async-resource-worker-pool"></a>
 ### Using `AsyncResource` for a `Worker` thread pool
@@ -838,9 +839,19 @@ class WorkerPool extends EventEmitter {
     this.numThreads = numThreads;
     this.workers = [];
     this.freeWorkers = [];
+    this.tasks = [];
 
     for (let i = 0; i < numThreads; i++)
       this.addNewWorker();
+
+    // Any time the kWorkerFreedEvent is emitted, dispatch
+    // the next task pending in the queue, if any.
+    this.on(kWorkerFreedEvent, () => {
+      if (this.tasks.length > 0) {
+        const { task, callback } = this.tasks.shift();
+        this.runTask(task, callback);
+      }
+    });
   }
 
   addNewWorker() {
@@ -874,7 +885,7 @@ class WorkerPool extends EventEmitter {
   runTask(task, callback) {
     if (this.freeWorkers.length === 0) {
       // No free threads, wait until a worker thread becomes free.
-      this.once(kWorkerFreedEvent, () => this.runTask(task, callback));
+      this.tasks.push({ task, callback });
       return;
     }
 
@@ -942,7 +953,7 @@ const server = createServer((req, res) => {
 
 ## Class: `AsyncLocalStorage`
 <!-- YAML
-added: v12.17.0
+added: v13.10.0
 -->
 
 This class is used to create asynchronous state within callbacks and promise
@@ -950,6 +961,11 @@ chains. It allows storing data throughout the lifetime of a web request
 or any other asynchronous duration. It is similar to thread-local storage
 in other languages.
 
+While you can create your own implementation on top of the `async_hooks` module,
+`AsyncLocalStorage` should be preferred as it is a performant and memory safe
+implementation that involves significant optimizations that are non-obvious to
+implement.
+
 The following example uses `AsyncLocalStorage` to build a simple logger
 that assigns IDs to incoming HTTP requests and includes them in messages
 logged within each request.
@@ -991,20 +1007,20 @@ from each other. It is safe to instantiate this class multiple times.
 
 ### `new AsyncLocalStorage()`
 <!-- YAML
-added: v12.17.0
+added: v13.10.0
 -->
 
 Creates a new instance of `AsyncLocalStorage`. Store is only provided within a
-`run` method call.
+`run()` call or after an `enterWith()` call.
 
 ### `asyncLocalStorage.disable()`
 <!-- YAML
-added: v12.17.0
+added: v13.10.0
 -->
 
-This method disables the instance of `AsyncLocalStorage`. All subsequent calls
+Disables the instance of `AsyncLocalStorage`. All subsequent calls
 to `asyncLocalStorage.getStore()` will return `undefined` until
-`asyncLocalStorage.run()` is called again.
+`asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()` is called again.
 
 When calling `asyncLocalStorage.disable()`, all current contexts linked to the
 instance will be exited.
@@ -1014,35 +1030,37 @@ Calling `asyncLocalStorage.disable()` is required before the
 provided by the `asyncLocalStorage`, as those objects are garbage collected
 along with the corresponding async resources.
 
-This method is to be used when the `asyncLocalStorage` is not in use anymore
+Use this method when the `asyncLocalStorage` is not in use anymore
 in the current process.
 
 ### `asyncLocalStorage.getStore()`
 <!-- YAML
-added: v12.17.0
+added: v13.10.0
 -->
 
 * Returns: {any}
 
-This method returns the current store.
-If this method is called outside of an asynchronous context initialized by
-calling `asyncLocalStorage.run`, it will return `undefined`.
+Returns the current store.
+If called outside of an asynchronous context initialized by
+calling `asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()`, it
+returns `undefined`.
 
 ### `asyncLocalStorage.enterWith(store)`
 <!-- YAML
-added: v12.17.0
+added: v13.11.0
 -->
 
 * `store` {any}
 
-Calling `asyncLocalStorage.enterWith(store)` will transition into the context
-for the remainder of the current synchronous execution and will persist
-through any following asynchronous calls.
+Transitions into the context for the remainder of the current
+synchronous execution and then persists the store through any following
+asynchronous calls.
 
 Example:
 
 ```js
 const store = { id: 1 };
+// Replaces previous store with the given store object
 asyncLocalStorage.enterWith(store);
 asyncLocalStorage.getStore(); // Returns the store object
 someAsyncOperation(() => {
@@ -1053,7 +1071,9 @@ someAsyncOperation(() => {
 This transition will continue for the _entire_ synchronous execution.
 This means that if, for example, the context is entered within an event
 handler subsequent event handlers will also run within that context unless
-specifically bound to another context with an `AsyncResource`.
+specifically bound to another context with an `AsyncResource`. That is why
+`run()` should be preferred over `enterWith()` unless there are strong reasons
+to use the latter method.
 
 ```js
 const store = { id: 1 };
@@ -1072,23 +1092,22 @@ asyncLocalStorage.getStore(); // Returns the same object
 
 ### `asyncLocalStorage.run(store, callback[, ...args])`
 <!-- YAML
-added: v12.17.0
+added: v13.10.0
 -->
 
 * `store` {any}
 * `callback` {Function}
 * `...args` {any}
 
-This methods runs a function synchronously within a context and return its
-return value. The store is not accessible outside of the callback function or
-the asynchronous operations created within the callback.
+Runs a function synchronously within a context and returns its
+return value. The store is not accessible outside of the callback function.
+The store is accessible to any asynchronous operations created within the
+callback.
 
-Optionally, arguments can be passed to the function. They will be passed to
-the callback function.
+The optional `args` are passed to the callback function.
 
-If the callback function throws an error, it will be thrown by `run` too.
-The stacktrace will not be impacted by this call and the context will
-be exited.
+If the callback function throws an error, the error is thrown by `run()` too.
+The stacktrace is not impacted by this call and the context is exited.
 
 Example:
 
@@ -1097,6 +1116,9 @@ const store = { id: 2 };
 try {
   asyncLocalStorage.run(store, () => {
     asyncLocalStorage.getStore(); // Returns the store object
+    setTimeout(() => {
+      asyncLocalStorage.getStore(); // Returns the store object
+    }, 200);
     throw new Error();
   });
 } catch (e) {
@@ -1107,22 +1129,21 @@ try {
 
 ### `asyncLocalStorage.exit(callback[, ...args])`
 <!-- YAML
-added: v12.17.0
+added: v13.10.0
 -->
 
 * `callback` {Function}
 * `...args` {any}
 
-This methods runs a function synchronously outside of a context and return its
+Runs a function synchronously outside of a context and returns its
 return value. The store is not accessible within the callback function or
-the asynchronous operations created within the callback.
+the asynchronous operations created within the callback. Any `getStore()`
+call done within the callback function will always return `undefined`.
 
-Optionally, arguments can be passed to the function. They will be passed to
-the callback function.
+The optional `args` are passed to the callback function.
 
-If the callback function throws an error, it will be thrown by `exit` too.
-The stacktrace will not be impacted by this call and
-the context will be re-entered.
+If the callback function throws an error, the error is thrown by `exit()` too.
+The stacktrace is not impacted by this call and the context is re-entered.
 
 Example:
 
@@ -1172,16 +1193,16 @@ If you need to keep using callback-based API, or your code assumes
 a custom thenable implementation, use the [`AsyncResource`][] class
 to associate the asynchronous operation with the correct execution context.
 
+[Hook Callbacks]: #async_hooks_hook_callbacks
+[PromiseHooks]: https://docs.google.com/document/d/1rda3yKGHimKIhg5YeoAmCOtyURgsbTH_qaYR79FELlk/edit
 [`AsyncResource`]: #async_hooks_class_asyncresource
+[`EventEmitter`]: events.md#events_class_eventemitter
+[`Stream`]: stream.md#stream_stream
+[`Worker`]: worker_threads.md#worker_threads_class_worker
 [`after` callback]: #async_hooks_after_asyncid
 [`before` callback]: #async_hooks_before_asyncid
 [`destroy` callback]: #async_hooks_destroy_asyncid
 [`init` callback]: #async_hooks_init_asyncid_type_triggerasyncid_resource
 [`promiseResolve` callback]: #async_hooks_promiseresolve_asyncid
-[`EventEmitter`]: events.html#events_class_eventemitter
-[Hook Callbacks]: #async_hooks_hook_callbacks
-[PromiseHooks]: https://docs.google.com/document/d/1rda3yKGHimKIhg5YeoAmCOtyURgsbTH_qaYR79FELlk/edit
-[`Stream`]: stream.html#stream_stream
-[`Worker`]: worker_threads.html#worker_threads_class_worker
+[`util.promisify()`]: util.md#util_util_promisify_original
 [promise execution tracking]: #async_hooks_promise_execution_tracking
-[`util.promisify()`]: util.html#util_util_promisify_original
diff --git a/doc/api/buffer.html b/doc/api/buffer.html
index a61f5d495806f1eaa25139f596fb50c6a7a7bd79..01aed5720ac595b5726ba9e5c7932586d55d313b 100644
--- a/doc/api/buffer.html
+++ b/doc/api/buffer.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Buffer | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Buffer | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer active">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="buffer" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/buffer.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/buffer.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/buffer.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/buffer.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/buffer.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/buffer.html">13.x</a></li>
@@ -118,20 +133,29 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/buffer.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/buffer.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/buffer.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#buffer_buffer">Buffer</a></span>
 <ul>
 <li><a href="#buffer_buffers_and_character_encodings">Buffers and character encodings</a></li>
 <li><a href="#buffer_buffers_and_typedarrays">Buffers and TypedArrays</a></li>
 <li><a href="#buffer_buffers_and_iteration">Buffers and iteration</a></li>
+<li><span class="stability_1"><a href="#buffer_class_blob">Class: <code>Blob</code></a></span>
+<ul>
+<li><a href="#buffer_new_buffer_blob_sources_options"><code>new buffer.Blob([sources[, options]])</code></a></li>
+<li><a href="#buffer_blob_arraybuffer"><code>blob.arrayBuffer()</code></a></li>
+<li><a href="#buffer_blob_size"><code>blob.size</code></a></li>
+<li><a href="#buffer_blob_slice_start_end_type"><code>blob.slice([start, [end, [type]]])</code></a></li>
+<li><a href="#buffer_blob_text"><code>blob.text()</code></a></li>
+<li><a href="#buffer_blob_type"><code>blob.type</code></a></li>
+<li><a href="#buffer_blob_objects_and_messagechannel"><code>Blob</code> objects and <code>MessageChannel</code></a></li>
+</ul>
+</li>
 <li><a href="#buffer_class_buffer">Class: <code>Buffer</code></a>
 <ul>
 <li><a href="#buffer_static_method_buffer_alloc_size_fill_encoding">Static method: <code>Buffer.alloc(size[, fill[, encoding]])</code></a></li>
@@ -224,8 +248,11 @@
 </li>
 <li><a href="#buffer_buffer_module_apis"><code>buffer</code> module APIs</a>
 <ul>
+<li><a href="#buffer_buffer_atob_data"><code>buffer.atob(data)</code></a></li>
+<li><a href="#buffer_buffer_btoa_data"><code>buffer.btoa(data)</code></a></li>
 <li><a href="#buffer_buffer_inspect_max_bytes"><code>buffer.INSPECT_MAX_BYTES</code></a></li>
 <li><a href="#buffer_buffer_kmaxlength"><code>buffer.kMaxLength</code></a></li>
+<li><a href="#buffer_buffer_kstringmaxlength"><code>buffer.kStringMaxLength</code></a></li>
 <li><a href="#buffer_buffer_transcode_source_fromenc_toenc"><code>buffer.transcode(source, fromEnc, toEnc)</code></a></li>
 <li><span class="stability_0"><a href="#buffer_class_slowbuffer">Class: <code>SlowBuffer</code></a></span>
 <ul>
@@ -242,20 +269,19 @@
 </li>
 <li><a href="#buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe"><code>Buffer.from()</code>, <code>Buffer.alloc()</code>, and <code>Buffer.allocUnsafe()</code></a>
 <ul>
-<li><a href="#buffer_the_zero_fill_buffers_command_line_option">The <code>--zero-fill-buffers</code> command line option</a></li>
+<li><a href="#buffer_the_zero_fill_buffers_command_line_option">The <code>--zero-fill-buffers</code> command-line option</a></li>
 <li><a href="#buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe">What makes <code>Buffer.allocUnsafe()</code> and <code>Buffer.allocUnsafeSlow()</code> "unsafe"?</a></li>
 </ul>
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Buffer<span><a class="mark" href="#buffer_buffer" id="buffer_buffer">#</a></span></h1>
+        <h2>Buffer<span><a class="mark" href="#buffer_buffer" id="buffer_buffer">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/buffer.js">lib/buffer.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/buffer.js">lib/buffer.js</a></p>
 <p><code>Buffer</code> objects are used to represent a fixed-length sequence of bytes. Many
 Node.js APIs support <code>Buffer</code>s.</p>
 <p>The <code>Buffer</code> class is a subclass of JavaScript's <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> class and
@@ -264,38 +290,40 @@ plain <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference
 <p>The <code>Buffer</code> class is within the global scope, making it unlikely that one
 would need to ever use <code>require('buffer').Buffer</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Creates a zero-filled Buffer of length 10.</span>
-<span class="hljs-keyword">const</span> buf1 = Buffer.alloc(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
 
 <span class="hljs-comment">// Creates a Buffer of length 10,</span>
 <span class="hljs-comment">// filled with bytes which all have the value `1`.</span>
-<span class="hljs-keyword">const</span> buf2 = Buffer.alloc(<span class="hljs-number">10</span>, <span class="hljs-number">1</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>, <span class="hljs-number">1</span>);
 
 <span class="hljs-comment">// Creates an uninitialized buffer of length 10.</span>
 <span class="hljs-comment">// This is faster than calling Buffer.alloc() but the returned</span>
 <span class="hljs-comment">// Buffer instance might contain old data that needs to be</span>
 <span class="hljs-comment">// overwritten using fill(), write(), or other functions that fill the Buffer's</span>
 <span class="hljs-comment">// contents.</span>
-<span class="hljs-keyword">const</span> buf3 = Buffer.allocUnsafe(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buf3 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">10</span>);
 
 <span class="hljs-comment">// Creates a Buffer containing the bytes [1, 2, 3].</span>
-<span class="hljs-keyword">const</span> buf4 = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
+<span class="hljs-keyword">const</span> buf4 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
 
 <span class="hljs-comment">// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries</span>
 <span class="hljs-comment">// are all truncated using `(value &#x26; 255)` to fit into the range 0–255.</span>
-<span class="hljs-keyword">const</span> buf5 = Buffer.from([<span class="hljs-number">257</span>, <span class="hljs-number">257.5</span>, <span class="hljs-number">-255</span>, <span class="hljs-string">'1'</span>]);
+<span class="hljs-keyword">const</span> buf5 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">257</span>, <span class="hljs-number">257.5</span>, -<span class="hljs-number">255</span>, <span class="hljs-string">'1'</span>]);
 
 <span class="hljs-comment">// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':</span>
 <span class="hljs-comment">// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)</span>
 <span class="hljs-comment">// [116, 195, 169, 115, 116] (in decimal notation)</span>
-<span class="hljs-keyword">const</span> buf6 = Buffer.from(<span class="hljs-string">'tést'</span>);
+<span class="hljs-keyword">const</span> buf6 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'tést'</span>);
 
 <span class="hljs-comment">// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].</span>
-<span class="hljs-keyword">const</span> buf7 = Buffer.from(<span class="hljs-string">'tést'</span>, <span class="hljs-string">'latin1'</span>);</code></pre>
-<h2>Buffers and character encodings<span><a class="mark" href="#buffer_buffers_and_character_encodings" id="buffer_buffers_and_character_encodings">#</a></span></h2>
+<span class="hljs-keyword">const</span> buf7 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'tést'</span>, <span class="hljs-string">'latin1'</span>);</code></pre>
+<section><h3>Buffers and character encodings<span><a class="mark" href="#buffer_buffers_and_character_encodings" id="buffer_buffers_and_character_encodings">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Introduced <code>base64url</code> encoding.</p></td></tr>
 <tr><td>v6.4.0</td>
 <td><p>Introduced <code>latin1</code> as an alias for <code>binary</code>.</p></td></tr>
 <tr><td>v5.0.0</td>
@@ -306,16 +334,16 @@ would need to ever use <code>require('buffer').Buffer</code>.</p>
 <p>When converting between <code>Buffer</code>s and strings, a character encoding may be
 specified. If no character encoding is specified, UTF-8 will be used as the
 default.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'hello world'</span>, <span class="hljs-string">'utf8'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'hello world'</span>, <span class="hljs-string">'utf8'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: 68656c6c6f20776f726c64</span>
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'base64'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'base64'</span>));
 <span class="hljs-comment">// Prints: aGVsbG8gd29ybGQ=</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.from(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf8'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer 66 68 71 77 68 67 61 64 73></span>
-<span class="hljs-built_in">console</span>.log(Buffer.from(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'fhqwhgads'</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00></span></code></pre>
 <p>The character encodings currently supported by Node.js are the following:</p>
 <ul>
@@ -340,7 +368,7 @@ truncated and will be mapped to characters in that range.</p>
 </ul>
 <p>Converting a <code>Buffer</code> into a string using one of the above is referred to as
 decoding, and converting a string into a <code>Buffer</code> is referred to as encoding.</p>
-<p>Node.js also supports the following two binary-to-text encodings. For
+<p>Node.js also supports the following binary-to-text encodings. For
 binary-to-text encodings, the naming convention is reversed: Converting a
 <code>Buffer</code> into a string is typically referred to as encoding, and converting a
 string into a <code>Buffer</code> as decoding.</p>
@@ -352,6 +380,12 @@ specified in <a href="https://tools.ietf.org/html/rfc4648#section-5">RFC 4648, S
 tabs, and new lines contained within the base64-encoded string are ignored.</p>
 </li>
 <li>
+<p><code>'base64url'</code>: <a href="https://tools.ietf.org/html/rfc4648#section-5">base64url</a> encoding as specified in
+<a href="https://tools.ietf.org/html/rfc4648#section-5">RFC 4648, Section 5</a>. When creating a <code>Buffer</code> from a string, this
+encoding will also correctly accept regular base64-encoded strings. When
+encoding a <code>Buffer</code> to a string, this encoding will omit padding.</p>
+</li>
+<li>
 <p><code>'hex'</code>: Encode each byte as two hexadecimal characters. Data truncation
 may occur when decoding strings that do exclusively contain valid hexadecimal
 characters. See below for an example.</p>
@@ -381,14 +415,14 @@ that did not support characters that had code points larger than U+FFFF.
 In Node.js, these code points are always supported.</p>
 </li>
 </ul>
-<pre><code class="language-js">Buffer.from(<span class="hljs-string">'1ag'</span>, <span class="hljs-string">'hex'</span>);
+<pre><code class="language-js"><span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'1ag'</span>, <span class="hljs-string">'hex'</span>);
 <span class="hljs-comment">// Prints &#x3C;Buffer 1a>, data truncated when first non-hexadecimal value</span>
 <span class="hljs-comment">// ('g') encountered.</span>
 
-Buffer.from(<span class="hljs-string">'1a7g'</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'1a7g'</span>, <span class="hljs-string">'hex'</span>);
 <span class="hljs-comment">// Prints &#x3C;Buffer 1a>, data truncated when data ends in single digit ('7').</span>
 
-Buffer.from(<span class="hljs-string">'1634'</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'1634'</span>, <span class="hljs-string">'hex'</span>);
 <span class="hljs-comment">// Prints &#x3C;Buffer 16 34>, all data represented.</span></code></pre>
 <p>Modern Web browsers follow the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a> which aliases
 both <code>'latin1'</code> and <code>'ISO-8859-1'</code> to <code>'win-1252'</code>. This means that while doing
@@ -396,7 +430,7 @@ something like <code>http.get()</code>, if the returned charset is one of those
 the WHATWG specification it is possible that the server actually returned
 <code>'win-1252'</code>-encoded data, and using <code>'latin1'</code> encoding may incorrectly decode
 the characters.</p>
-<h2>Buffers and TypedArrays<span><a class="mark" href="#buffer_buffers_and_typedarrays" id="buffer_buffers_and_typedarrays">#</a></span></h2>
+</section><section><h3>Buffers and TypedArrays<span><a class="mark" href="#buffer_buffers_and_typedarrays" id="buffer_buffers_and_typedarrays">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -412,12 +446,12 @@ however, subtle incompatibilities between the <code>Buffer</code> API and the
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> API.</p>
 <p>In particular:</p>
 <ul>
-<li>While <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice"><code>TypedArray#slice()</code></a> creates a copy of part of the <code>TypedArray</code>,
-<a href="#buffer_buf_slice_start_end"><code>Buffer#slice()</code></a> creates a view over the existing <code>Buffer</code>
+<li>While <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice"><code>TypedArray.prototype.slice()</code></a> creates a copy of part of the <code>TypedArray</code>,
+<a href="#buffer_buf_slice_start_end"><code>Buffer.prototype.slice()</code></a> creates a view over the existing <code>Buffer</code>
 without copying. This behavior can be surprising, and only exists for legacy
-compatibility. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray#subarray()</code></a> can be used to achieve the behavior
-of <a href="#buffer_buf_slice_start_end"><code>Buffer#slice()</code></a> on both <code>Buffer</code>s and other
-<code>TypedArray</code>s.</li>
+compatibility. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray.prototype.subarray()</code></a> can be used to achieve
+the behavior of <a href="#buffer_buf_slice_start_end"><code>Buffer.prototype.slice()</code></a> on both <code>Buffer</code>s
+and other <code>TypedArray</code>s.</li>
 <li><a href="#buffer_buf_tostring_encoding_start_end"><code>buf.toString()</code></a> is incompatible with its <code>TypedArray</code> equivalent.</li>
 <li>A number of methods, e.g. <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf()</code></a>, support additional arguments.</li>
 </ul>
@@ -427,58 +461,58 @@ of <a href="#buffer_buf_slice_start_end"><code>Buffer#slice()</code></a> on both
 contents, interpreted as an array of integers, and not as a byte sequence
 of the target type.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
-<span class="hljs-keyword">const</span> uint32array = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>(buf);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
+<span class="hljs-keyword">const</span> uint32array = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>32<span class="hljs-built_in">Array</span>(buf);
 
-<span class="hljs-built_in">console</span>.log(uint32array);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(uint32array);
 
 <span class="hljs-comment">// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]</span></code></pre>
 <ul>
 <li>Passing the <code>Buffer</code>s underlying <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> will create a
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> that shares its memory with the <code>Buffer</code>.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'hello'</span>, <span class="hljs-string">'utf16le'</span>);
-<span class="hljs-keyword">const</span> uint16arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(
-  buf.buffer,
-  buf.byteOffset,
-  buf.length / <span class="hljs-built_in">Uint16Array</span>.BYTES_PER_ELEMENT);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'hello'</span>, <span class="hljs-string">'utf16le'</span>);
+<span class="hljs-keyword">const</span> uint16array = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(
+  buf.<span class="hljs-property">buffer</span>,
+  buf.<span class="hljs-property">byteOffset</span>,
+  buf.<span class="hljs-property">length</span> / <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>.<span class="hljs-property">BYTES_PER_ELEMENT</span>);
 
-<span class="hljs-built_in">console</span>.log(uint16array);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(uint16array);
 
 <span class="hljs-comment">// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]</span></code></pre>
 <p>It is possible to create a new <code>Buffer</code> that shares the same allocated
 memory as a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instance by using the <code>TypedArray</code> object’s
 <code>.buffer</code> property in the same way. <a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from()</code></a>
 behaves like <code>new Uint8Array()</code> in this context.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(<span class="hljs-number">2</span>);
 
 arr[<span class="hljs-number">0</span>] = <span class="hljs-number">5000</span>;
 arr[<span class="hljs-number">1</span>] = <span class="hljs-number">4000</span>;
 
 <span class="hljs-comment">// Copies the contents of `arr`.</span>
-<span class="hljs-keyword">const</span> buf1 = Buffer.from(arr);
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arr);
 
 <span class="hljs-comment">// Shares memory with `arr`.</span>
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(arr.buffer);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arr.<span class="hljs-property">buffer</span>);
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 a0></span>
-<span class="hljs-built_in">console</span>.log(buf2);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 13 a0 0f></span>
 
 arr[<span class="hljs-number">1</span>] = <span class="hljs-number">6000</span>;
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 a0></span>
-<span class="hljs-built_in">console</span>.log(buf2);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 13 70 17></span></code></pre>
 <p>When creating a <code>Buffer</code> using a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>'s <code>.buffer</code>, it is
 possible to use only a portion of the underlying <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> by passing in
 <code>byteOffset</code> and <code>length</code> parameters.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">20</span>);
-<span class="hljs-keyword">const</span> buf = Buffer.from(arr.buffer, <span class="hljs-number">0</span>, <span class="hljs-number">16</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(<span class="hljs-number">20</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arr.<span class="hljs-property">buffer</span>, <span class="hljs-number">0</span>, <span class="hljs-number">16</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 16</span></code></pre>
 <p>The <code>Buffer.from()</code> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from"><code>TypedArray.from()</code></a> have different signatures and
 implementations. Specifically, the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> variants accept a second
@@ -495,12 +529,12 @@ function:</p>
 <li><a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a></li>
 <li><a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string[, encoding])</code></a></li>
 </ul>
-<h2>Buffers and iteration<span><a class="mark" href="#buffer_buffers_and_iteration" id="buffer_buffers_and_iteration">#</a></span></h2>
+</section><section><h3>Buffers and iteration<span><a class="mark" href="#buffer_buffers_and_iteration" id="buffer_buffers_and_iteration">#</a></span></h3>
 <p><code>Buffer</code> instances can be iterated over using <code>for..of</code> syntax:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> b <span class="hljs-keyword">of</span> buf) {
-  <span class="hljs-built_in">console</span>.log(b);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   1</span>
@@ -508,10 +542,109 @@ function:</p>
 <span class="hljs-comment">//   3</span></code></pre>
 <p>Additionally, the <a href="#buffer_buf_values"><code>buf.values()</code></a>, <a href="#buffer_buf_keys"><code>buf.keys()</code></a>, and
 <a href="#buffer_buf_entries"><code>buf.entries()</code></a> methods can be used to create iterators.</p>
-<h2>Class: <code>Buffer</code><span><a class="mark" href="#buffer_class_buffer" id="buffer_class_buffer">#</a></span></h2>
+</section><section><h3>Class: <code>Blob</code><span><a class="mark" href="#buffer_class_blob" id="buffer_class_blob">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>A <a href="https://developer.mozilla.org/en-US/docs/Web/API/Blob"><code>Blob</code></a> encapsulates immutable, raw data that can be safely shared across
+multiple worker threads.</p>
+<h4><code>new buffer.Blob([sources[, options]])</code><span><a class="mark" href="#buffer_new_buffer_blob_sources_options" id="buffer_new_buffer_blob_sources_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>sources</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a> | <a href="buffer.html#buffer_class_blob" class="type">&#x3C;Blob[]></a> An array
+of string, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a>, or <a href="buffer.html#buffer_class_blob" class="type">&#x3C;Blob></a> objects, or
+any mix of such objects, that will be stored within the <code>Blob</code>.</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The character encoding to use for string sources.
+<strong>Default</strong>: <code>'utf8'</code>.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The Blob content-type. The intent is for <code>type</code> to convey
+the MIME media type of the data, however no validation of the type format
+is performed.</li>
+</ul>
+</li>
+</ul>
+<p>Creates a new <code>Blob</code> object containing a concatenation of the given sources.</p>
+<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a>, and <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> sources are copied into
+the 'Blob' and can therefore be safely modified after the 'Blob' is created.</p>
+<p>String sources are also copied into the <code>Blob</code>.</p>
+<h4><code>blob.arrayBuffer()</code><span><a class="mark" href="#buffer_blob_arraybuffer" id="buffer_blob_arraybuffer">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Returns a promise that fulfills with an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> containing a copy of
+the <code>Blob</code> data.</p>
+<h4><code>blob.size</code><span><a class="mark" href="#buffer_blob_size" id="buffer_blob_size">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>The total size of the <code>Blob</code> in bytes.</p>
+<h4><code>blob.slice([start, [end, [type]]])</code><span><a class="mark" href="#buffer_blob_slice_start_end_type" id="buffer_blob_slice_start_end_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The starting index.</li>
+<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The ending index.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The content-type for the new <code>Blob</code></li>
+</ul>
+<p>Creates and returns a new <code>Blob</code> containing a subset of this <code>Blob</code> objects
+data. The original <code>Blob</code> is not alterered.</p>
+<h4><code>blob.text()</code><span><a class="mark" href="#buffer_blob_text" id="buffer_blob_text">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Returns a promise that resolves the contents of the <code>Blob</code> decoded as a UTF-8
+string.</p>
+<h4><code>blob.type</code><span><a class="mark" href="#buffer_blob_type" id="buffer_blob_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>The content-type of the <code>Blob</code>.</p>
+<h4><code>Blob</code> objects and <code>MessageChannel</code><span><a class="mark" href="#buffer_blob_objects_and_messagechannel" id="buffer_blob_objects_and_messagechannel">#</a></span></h4>
+<p>Once a <a href="buffer.html#buffer_class_blob" class="type">&#x3C;Blob></a> object is created, it can be sent via <code>MessagePort</code> to multiple
+destinations without transfering or immediately copying the data. The data
+contained by the <code>Blob</code> is copied only when the <code>arrayBuffer()</code> or <code>text()</code>
+methods are called.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Blob</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'buffer'</span>);
+<span class="hljs-keyword">const</span> blob = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Blob</span>([<span class="hljs-string">'hello there'</span>]);
+<span class="hljs-keyword">const</span> { <span class="hljs-attr">setTimeout</span>: delay } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'timers/promises'</span>);
+
+<span class="hljs-keyword">const</span> mc1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+<span class="hljs-keyword">const</span> mc2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+
+mc1.<span class="hljs-property">port1</span>.<span class="hljs-property">onmessage</span> = <span class="hljs-keyword">async</span> ({ data }) => {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-keyword">await</span> data.<span class="hljs-title function_">arrayBuffer</span>());
+  mc1.<span class="hljs-property">port1</span>.<span class="hljs-title function_">close</span>();
+};
+
+mc2.<span class="hljs-property">port1</span>.<span class="hljs-property">onmessage</span> = <span class="hljs-keyword">async</span> ({ data }) => {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">delay</span>(<span class="hljs-number">1000</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-keyword">await</span> data.<span class="hljs-title function_">arrayBuffer</span>());
+  mc2.<span class="hljs-property">port1</span>.<span class="hljs-title function_">close</span>();
+};
+
+mc1.<span class="hljs-property">port2</span>.<span class="hljs-title function_">postMessage</span>(blob);
+mc2.<span class="hljs-property">port2</span>.<span class="hljs-title function_">postMessage</span>(blob);
+
+<span class="hljs-comment">// The Blob is still usable after posting.</span>
+data.<span class="hljs-title function_">text</span>().<span class="hljs-title function_">then</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>);</code></pre>
+</section><section><h3>Class: <code>Buffer</code><span><a class="mark" href="#buffer_class_buffer" id="buffer_class_buffer">#</a></span></h3>
 <p>The <code>Buffer</code> class is a global type for dealing with binary data directly.
 It can be constructed in a variety of ways.</p>
-<h3>Static method: <code>Buffer.alloc(size[, fill[, encoding]])</code><span><a class="mark" href="#buffer_static_method_buffer_alloc_size_fill_encoding" id="buffer_static_method_buffer_alloc_size_fill_encoding">#</a></span></h3>
+<h4>Static method: <code>Buffer.alloc(size[, fill[, encoding]])</code><span><a class="mark" href="#buffer_static_method_buffer_alloc_size_fill_encoding" id="buffer_static_method_buffer_alloc_size_fill_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -536,31 +669,31 @@ with. <strong>Default:</strong> <code>0</code>.</li>
 </ul>
 <p>Allocates a new <code>Buffer</code> of <code>size</code> bytes. If <code>fill</code> is <code>undefined</code>, the
 <code>Buffer</code> will be zero-filled.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">5</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">5</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 00 00 00 00 00></span></code></pre>
 <p>If <code>size</code> is larger than
 <a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a> or smaller than 0, <a href="errors.html#ERR_INVALID_OPT_VALUE"><code>ERR_INVALID_OPT_VALUE</code></a>
 is thrown.</p>
 <p>If <code>fill</code> is specified, the allocated <code>Buffer</code> will be initialized by calling
 <a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(fill)</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">5</span>, <span class="hljs-string">'a'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">5</span>, <span class="hljs-string">'a'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 61 61 61 61 61></span></code></pre>
 <p>If both <code>fill</code> and <code>encoding</code> are specified, the allocated <code>Buffer</code> will be
 initialized by calling <a href="#buffer_buf_fill_value_offset_end_encoding"><code>buf.fill(fill, encoding)</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">11</span>, <span class="hljs-string">'aGVsbG8gd29ybGQ='</span>, <span class="hljs-string">'base64'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">11</span>, <span class="hljs-string">'aGVsbG8gd29ybGQ='</span>, <span class="hljs-string">'base64'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64></span></code></pre>
 <p>Calling <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> can be measurably slower than the alternative
 <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> but ensures that the newly created <code>Buffer</code> instance
 contents will never contain sensitive data from previous allocations, including
 data that might not have been allocated for <code>Buffer</code>s.</p>
 <p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
-<h3>Static method: <code>Buffer.allocUnsafe(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafe_size" id="buffer_static_method_buffer_allocunsafe_size">#</a></span></h3>
+<h4>Static method: <code>Buffer.allocUnsafe(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafe_size" id="buffer_static_method_buffer_allocunsafe_size">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -582,14 +715,14 @@ is thrown.</p>
 initialized</em>. The contents of the newly created <code>Buffer</code> are unknown and
 <em>may contain sensitive data</em>. Use <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> instead to initialize
 <code>Buffer</code> instances with zeroes.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">10</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">10</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints (contents may vary): &#x3C;Buffer a0 8b 28 3f 01 00 00 00 50 32></span>
 
-buf.fill(<span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">fill</span>(<span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 00 00 00 00 00 00 00 00 00 00></span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
 <p>The <code>Buffer</code> module pre-allocates an internal <code>Buffer</code> instance of
@@ -605,7 +738,7 @@ pool, while <code>Buffer.allocUnsafe(size).fill(fill)</code> <em>will</em> use t
 <code>Buffer</code> pool if <code>size</code> is less than or equal to half <a href="#buffer_class_property_buffer_poolsize"><code>Buffer.poolSize</code></a>. The
 difference is subtle but can be important when an application requires the
 additional performance that <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> provides.</p>
-<h3>Static method: <code>Buffer.allocUnsafeSlow(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafeslow_size" id="buffer_static_method_buffer_allocunsafeslow_size">#</a></span></h3>
+<h4>Static method: <code>Buffer.allocUnsafeSlow(size)</code><span><a class="mark" href="#buffer_static_method_buffer_allocunsafeslow_size" id="buffer_static_method_buffer_allocunsafeslow_size">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.12.0</span>
 </div>
@@ -632,20 +765,20 @@ then copying out the relevant bits.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Need to keep around a few small chunks of memory.</span>
 <span class="hljs-keyword">const</span> store = [];
 
-socket.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-keyword">let</span> data;
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (data = readable.read())) {
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (data = readable.<span class="hljs-title function_">read</span>())) {
     <span class="hljs-comment">// Allocate for retained data.</span>
-    <span class="hljs-keyword">const</span> sb = Buffer.allocUnsafeSlow(<span class="hljs-number">10</span>);
+    <span class="hljs-keyword">const</span> sb = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafeSlow</span>(<span class="hljs-number">10</span>);
 
     <span class="hljs-comment">// Copy the data into the new allocation.</span>
-    data.copy(sb, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">10</span>);
+    data.<span class="hljs-title function_">copy</span>(sb, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">10</span>);
 
-    store.push(sb);
+    store.<span class="hljs-title function_">push</span>(sb);
   }
 });</code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</p>
-<h3>Static method: <code>Buffer.byteLength(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_bytelength_string_encoding" id="buffer_static_method_buffer_bytelength_string_encoding">#</a></span></h3>
+<h4>Static method: <code>Buffer.byteLength(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_bytelength_string_encoding" id="buffer_static_method_buffer_bytelength_string_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -669,18 +802,19 @@ value to calculate the length of.</li>
 <p>Returns the byte length of a string when encoded using <code>encoding</code>.
 This is not the same as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length"><code>String.prototype.length</code></a>, which does not account
 for the encoding that is used to convert the string into bytes.</p>
-<p>For <code>'base64'</code> and <code>'hex'</code>, this function assumes valid input. For strings that
-contain non-base64/hex-encoded data (e.g. whitespace), the return value might be
-greater than the length of a <code>Buffer</code> created from the string.</p>
+<p>For <code>'base64'</code>, <code>'base64url'</code>, and <code>'hex'</code>, this function assumes valid input.
+For strings that contain non-base64/hex-encoded data (e.g. whitespace), the
+return value might be greater than the length of a <code>Buffer</code> created from the
+string.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> str = <span class="hljs-string">'\u00bd + \u00bc = \u00be'</span>;
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${str}</span>: <span class="hljs-subst">${str.length}</span> characters, `</span> +
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${str}</span>: <span class="hljs-subst">${str.length}</span> characters, `</span> +
             <span class="hljs-string">`<span class="hljs-subst">${Buffer.byteLength(str, <span class="hljs-string">'utf8'</span>)}</span> bytes`</span>);
 <span class="hljs-comment">// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes</span></code></pre>
 <p>When <code>string</code> is a <code>Buffer</code>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>/<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>/
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a>, the byte length as reported by <code>.byteLength</code>
 is returned.</p>
-<h3>Static method: <code>Buffer.compare(buf1, buf2)</code><span><a class="mark" href="#buffer_static_method_buffer_compare_buf1_buf2" id="buffer_static_method_buffer_compare_buf1_buf2">#</a></span></h3>
+<h4>Static method: <code>Buffer.compare(buf1, buf2)</code><span><a class="mark" href="#buffer_static_method_buffer_compare_buf1_buf2" id="buffer_static_method_buffer_compare_buf1_buf2">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -701,14 +835,14 @@ comparison. See <a href="#buffer_buf_compare_target_targetstart_targetend_source
 <p>Compares <code>buf1</code> to <code>buf2</code>, typically for the purpose of sorting arrays of
 <code>Buffer</code> instances. This is equivalent to calling
 <a href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend"><code>buf1.compare(buf2)</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'1234'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'0123'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'1234'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'0123'</span>);
 <span class="hljs-keyword">const</span> arr = [buf1, buf2];
 
-<span class="hljs-built_in">console</span>.log(arr.sort(Buffer.compare));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arr.<span class="hljs-title function_">sort</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-property">compare</span>));
 <span class="hljs-comment">// Prints: [ &#x3C;Buffer 30 31 32 33>, &#x3C;Buffer 31 32 33 34> ]</span>
 <span class="hljs-comment">// (This result is equal to: [buf2, buf1].)</span></code></pre>
-<h3>Static method: <code>Buffer.concat(list[, totalLength])</code><span><a class="mark" href="#buffer_static_method_buffer_concat_list_totallength" id="buffer_static_method_buffer_concat_list_totallength">#</a></span></h3>
+<h4>Static method: <code>Buffer.concat(list[, totalLength])</code><span><a class="mark" href="#buffer_static_method_buffer_concat_list_totallength" id="buffer_static_method_buffer_concat_list_totallength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -738,23 +872,23 @@ combined length of the <code>Buffer</code>s in <code>list</code> exceeds <code>t
 truncated to <code>totalLength</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a single `Buffer` from a list of three `Buffer` instances.</span>
 
-<span class="hljs-keyword">const</span> buf1 = Buffer.alloc(<span class="hljs-number">10</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.alloc(<span class="hljs-number">14</span>);
-<span class="hljs-keyword">const</span> buf3 = Buffer.alloc(<span class="hljs-number">18</span>);
-<span class="hljs-keyword">const</span> totalLength = buf1.length + buf2.length + buf3.length;
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">14</span>);
+<span class="hljs-keyword">const</span> buf3 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">18</span>);
+<span class="hljs-keyword">const</span> totalLength = buf1.<span class="hljs-property">length</span> + buf2.<span class="hljs-property">length</span> + buf3.<span class="hljs-property">length</span>;
 
-<span class="hljs-built_in">console</span>.log(totalLength);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(totalLength);
 <span class="hljs-comment">// Prints: 42</span>
 
-<span class="hljs-keyword">const</span> bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
+<span class="hljs-keyword">const</span> bufA = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">concat</span>([buf1, buf2, buf3], totalLength);
 
-<span class="hljs-built_in">console</span>.log(bufA);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(bufA);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 00 00 00 00 ...></span>
-<span class="hljs-built_in">console</span>.log(bufA.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(bufA.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 42</span></code></pre>
 <p><code>Buffer.concat()</code> may also use the internal <code>Buffer</code> pool like
 <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> does.</p>
-<h3>Static method: <code>Buffer.from(array)</code><span><a class="mark" href="#buffer_static_method_buffer_from_array" id="buffer_static_method_buffer_from_array">#</a></span></h3>
+<h4>Static method: <code>Buffer.from(array)</code><span><a class="mark" href="#buffer_static_method_buffer_from_array" id="buffer_static_method_buffer_from_array">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -764,12 +898,12 @@ truncated to <code>totalLength</code>.</p>
 <p>Allocates a new <code>Buffer</code> using an <code>array</code> of bytes in the range <code>0</code> – <code>255</code>.
 Array entries outside that range will be truncated to fit into it.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.</span>
-<span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x62</span>, <span class="hljs-number">0x75</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x65</span>, <span class="hljs-number">0x72</span>]);</code></pre>
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x62</span>, <span class="hljs-number">0x75</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x66</span>, <span class="hljs-number">0x65</span>, <span class="hljs-number">0x72</span>]);</code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>array</code> is not an <code>Array</code> or another type
 appropriate for <code>Buffer.from()</code> variants.</p>
 <p><code>Buffer.from(array)</code> and <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string)</code></a> may also use the internal
 <code>Buffer</code> pool like <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> does.</p>
-<h3>Static method: <code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length" id="buffer_static_method_buffer_from_arraybuffer_byteoffset_length">#</a></span></h3>
+<h4>Static method: <code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length" id="buffer_static_method_buffer_from_arraybuffer_byteoffset_length">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -784,34 +918,45 @@ appropriate for <code>Buffer.from()</code> variants.</p>
 <p>This creates a view of the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> without copying the underlying
 memory. For example, when passed a reference to the <code>.buffer</code> property of a
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instance, the newly created <code>Buffer</code> will share the same
-allocated memory as the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(<span class="hljs-number">2</span>);
+allocated memory as the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>'s underlying <code>ArrayBuffer</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(<span class="hljs-number">2</span>);
 
 arr[<span class="hljs-number">0</span>] = <span class="hljs-number">5000</span>;
 arr[<span class="hljs-number">1</span>] = <span class="hljs-number">4000</span>;
 
 <span class="hljs-comment">// Shares memory with `arr`.</span>
-<span class="hljs-keyword">const</span> buf = Buffer.from(arr.buffer);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arr.<span class="hljs-property">buffer</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 13 a0 0f></span>
 
 <span class="hljs-comment">// Changing the original Uint16Array changes the Buffer also.</span>
 arr[<span class="hljs-number">1</span>] = <span class="hljs-number">6000</span>;
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 88 13 70 17></span></code></pre>
 <p>The optional <code>byteOffset</code> and <code>length</code> arguments specify a memory range within
 the <code>arrayBuffer</code> that will be shared by the <code>Buffer</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>);
-<span class="hljs-keyword">const</span> buf = Buffer.from(ab, <span class="hljs-number">0</span>, <span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(ab, <span class="hljs-number">0</span>, <span class="hljs-number">2</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 2</span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>arrayBuffer</code> is not an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> or a
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> or another type appropriate for <code>Buffer.from()</code>
 variants.</p>
-<h3>Static method: <code>Buffer.from(buffer)</code><span><a class="mark" href="#buffer_static_method_buffer_from_buffer" id="buffer_static_method_buffer_from_buffer">#</a></span></h3>
+<p>It is important to remember that a backing <code>ArrayBuffer</code> can cover a range
+of memory that extends beyond the bounds of a <code>TypedArray</code> view. A new
+<code>Buffer</code> created using the <code>buffer</code> property of a <code>TypedArray</code> may extend
+beyond the range of the <code>TypedArray</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arrA = <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x63</span>, <span class="hljs-number">0x64</span>, <span class="hljs-number">0x65</span>, <span class="hljs-number">0x66</span>]); <span class="hljs-comment">// 4 elements</span>
+<span class="hljs-keyword">const</span> arrB = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(arrA.<span class="hljs-property">buffer</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>); <span class="hljs-comment">// 2 elements</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arrA.<span class="hljs-property">buffer</span> === arrB.<span class="hljs-property">buffer</span>); <span class="hljs-comment">// true</span>
+
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arrB.<span class="hljs-property">buffer</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
+<span class="hljs-comment">// Prints: &#x3C;Buffer 63 64 65 66></span></code></pre>
+<h4>Static method: <code>Buffer.from(buffer)</code><span><a class="mark" href="#buffer_static_method_buffer_from_buffer" id="buffer_static_method_buffer_from_buffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -820,18 +965,18 @@ variants.</p>
 which to copy data.</li>
 </ul>
 <p>Copies the passed <code>buffer</code> data onto a new <code>Buffer</code> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'buffer'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(buf1);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(buf1);
 
 buf1[<span class="hljs-number">0</span>] = <span class="hljs-number">0x61</span>;
 
-<span class="hljs-built_in">console</span>.log(buf1.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: auffer</span>
-<span class="hljs-built_in">console</span>.log(buf2.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: buffer</span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>buffer</code> is not a <code>Buffer</code> or another type
 appropriate for <code>Buffer.from()</code> variants.</p>
-<h3>Static method: <code>Buffer.from(object[, offsetOrEncoding[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_object_offsetorencoding_length" id="buffer_static_method_buffer_from_object_offsetorencoding_length">#</a></span></h3>
+<h4>Static method: <code>Buffer.from(object[, offsetOrEncoding[, length]])</code><span><a class="mark" href="#buffer_static_method_buffer_from_object_offsetorencoding_length" id="buffer_static_method_buffer_from_object_offsetorencoding_length">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 </div>
@@ -842,21 +987,21 @@ appropriate for <code>Buffer.from()</code> variants.</p>
 </ul>
 <p>For objects whose <code>valueOf()</code> function returns a value not strictly equal to
 <code>object</code>, returns <code>Buffer.from(object.valueOf(), offsetOrEncoding, length)</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'this is a test'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(<span class="hljs-string">'this is a test'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74></span></code></pre>
 <p>For objects that support <code>Symbol.toPrimitive</code>, returns
 <code>Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding)</code>.</p>
-<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Foo</span> </span>{
-  [<span class="hljs-built_in">Symbol</span>.toPrimitive]() {
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Foo</span> {
+  [<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">toPrimitive</span>]() {
     <span class="hljs-keyword">return</span> <span class="hljs-string">'this is a test'</span>;
   }
 }
 
-<span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-keyword">new</span> Foo(), <span class="hljs-string">'utf8'</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Foo</span>(), <span class="hljs-string">'utf8'</span>);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74></span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>object</code> does not have the mentioned methods or
 is not of another type appropriate for <code>Buffer.from()</code> variants.</p>
-<h3>Static method: <code>Buffer.from(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_from_string_encoding" id="buffer_static_method_buffer_from_string_encoding">#</a></span></h3>
+<h4>Static method: <code>Buffer.from(string[, encoding])</code><span><a class="mark" href="#buffer_static_method_buffer_from_string_encoding" id="buffer_static_method_buffer_from_string_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -866,18 +1011,18 @@ is not of another type appropriate for <code>Buffer.from()</code> variants.</p>
 </ul>
 <p>Creates a new <code>Buffer</code> containing <code>string</code>. The <code>encoding</code> parameter identifies
 the character encoding to be used when converting <code>string</code> into bytes.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'this is a tést'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'7468697320697320612074c3a97374'</span>, <span class="hljs-string">'hex'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'this is a tést'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'7468697320697320612074c3a97374'</span>, <span class="hljs-string">'hex'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf1.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: this is a tést</span>
-<span class="hljs-built_in">console</span>.log(buf2.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: this is a tést</span>
-<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'latin1'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'latin1'</span>));
 <span class="hljs-comment">// Prints: this is a tést</span></code></pre>
 <p>A <code>TypeError</code> will be thrown if <code>string</code> is not a string or another type
 appropriate for <code>Buffer.from()</code> variants.</p>
-<h3>Static method: <code>Buffer.isBuffer(obj)</code><span><a class="mark" href="#buffer_static_method_buffer_isbuffer_obj" id="buffer_static_method_buffer_isbuffer_obj">#</a></span></h3>
+<h4>Static method: <code>Buffer.isBuffer(obj)</code><span><a class="mark" href="#buffer_static_method_buffer_isbuffer_obj" id="buffer_static_method_buffer_isbuffer_obj">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.101</span>
 </div>
@@ -886,7 +1031,12 @@ appropriate for <code>Buffer.from()</code> variants.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if <code>obj</code> is a <code>Buffer</code>, <code>false</code> otherwise.</p>
-<h3>Static method: <code>Buffer.isEncoding(encoding)</code><span><a class="mark" href="#buffer_static_method_buffer_isencoding_encoding" id="buffer_static_method_buffer_isencoding_encoding">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>)); <span class="hljs-comment">// true</span>
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// true</span>
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-string">'a string'</span>); <span class="hljs-comment">// false</span>
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>([]); <span class="hljs-comment">// false</span>
+<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-number">1024</span>)); <span class="hljs-comment">// false</span></code></pre>
+<h4>Static method: <code>Buffer.isEncoding(encoding)</code><span><a class="mark" href="#buffer_static_method_buffer_isencoding_encoding" id="buffer_static_method_buffer_isencoding_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -896,18 +1046,18 @@ appropriate for <code>Buffer.from()</code> variants.</p>
 </ul>
 <p>Returns <code>true</code> if <code>encoding</code> is the name of a supported character encoding,
 or <code>false</code> otherwise.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'utf-8'</span>));
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isEncoding</span>(<span class="hljs-string">'utf-8'</span>));
 <span class="hljs-comment">// Prints: true</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isEncoding</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: true</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">'utf/8'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isEncoding</span>(<span class="hljs-string">'utf/8'</span>));
 <span class="hljs-comment">// Prints: false</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.isEncoding(<span class="hljs-string">''</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isEncoding</span>(<span class="hljs-string">''</span>));
 <span class="hljs-comment">// Prints: false</span></code></pre>
-<h3>Class property: <code>Buffer.poolSize</code><span><a class="mark" href="#buffer_class_property_buffer_poolsize" id="buffer_class_property_buffer_poolsize">#</a></span></h3>
+<h4>Class property: <code>Buffer.poolSize</code><span><a class="mark" href="#buffer_class_property_buffer_poolsize" id="buffer_class_property_buffer_poolsize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -916,10 +1066,7 @@ or <code>false</code> otherwise.</p>
 </ul>
 <p>This is the size (in bytes) of pre-allocated internal <code>Buffer</code> instances used
 for pooling. This value may be modified.</p>
-<h3><code>buf[index]</code><span><a class="mark" href="#buffer_buf_index" id="buffer_buf_index">#</a></span></h3>
-<div class="api_metadata">
-
-</div>
+<h4><code>buf[index]</code><span><a class="mark" href="#buffer_buf_index" id="buffer_buf_index">#</a></span></h4>
 <ul>
 <li><code>index</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
@@ -936,27 +1083,27 @@ access is the same as <code>Uint8Array</code>. In other words, <code>buf[index]<
 <span class="hljs-comment">// `Buffer.from()` to perform this conversion.)</span>
 
 <span class="hljs-keyword">const</span> str = <span class="hljs-string">'Node.js'</span>;
-<span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(str.length);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(str.<span class="hljs-property">length</span>);
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; str.length; i++) {
-  buf[i] = str.charCodeAt(i);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; str.<span class="hljs-property">length</span>; i++) {
+  buf[i] = str.<span class="hljs-title function_">charCodeAt</span>(i);
 }
 
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'utf8'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: Node.js</span></code></pre>
-<h3><code>buf.buffer</code><span><a class="mark" href="#buffer_buf_buffer" id="buffer_buf_buffer">#</a></span></h3>
+<h4><code>buf.buffer</code><span><a class="mark" href="#buffer_buf_buffer" id="buffer_buf_buffer">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> The underlying <code>ArrayBuffer</code> object based on which this <code>Buffer</code>
 object is created.</li>
 </ul>
 <p>This <code>ArrayBuffer</code> is not guaranteed to correspond exactly to the original
 <code>Buffer</code>. See the notes on <code>buf.byteOffset</code> for details.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> arrayBuffer = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">16</span>);
-<span class="hljs-keyword">const</span> buffer = Buffer.from(arrayBuffer);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> arrayBuffer = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">16</span>);
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(arrayBuffer);
 
-<span class="hljs-built_in">console</span>.log(buffer.buffer === arrayBuffer);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buffer.<span class="hljs-property">buffer</span> === arrayBuffer);
 <span class="hljs-comment">// Prints: true</span></code></pre>
-<h3><code>buf.byteOffset</code><span><a class="mark" href="#buffer_buf_byteoffset" id="buffer_buf_byteoffset">#</a></span></h3>
+<h4><code>buf.byteOffset</code><span><a class="mark" href="#buffer_buf_byteoffset" id="buffer_buf_byteoffset">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The <code>byteOffset</code> of the <code>Buffer</code>s underlying <code>ArrayBuffer</code> object.</li>
 </ul>
@@ -969,13 +1116,13 @@ to the <code>Buffer</code> object itself.</p>
 <p>A common issue when creating a <code>TypedArray</code> object that shares its memory with
 a <code>Buffer</code> is that in this case one needs to specify the <code>byteOffset</code> correctly:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a buffer smaller than `Buffer.poolSize`.</span>
-<span class="hljs-keyword">const</span> nodeBuffer = <span class="hljs-keyword">new</span> Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
+<span class="hljs-keyword">const</span> nodeBuffer = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
 
 <span class="hljs-comment">// When casting the Node.js Buffer to an Int8Array, use the byteOffset</span>
 <span class="hljs-comment">// to refer only to the part of `nodeBuffer.buffer` that contains the memory</span>
 <span class="hljs-comment">// for `nodeBuffer`.</span>
-<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int8Array</span>(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);</code></pre>
-<h3><code>buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])</code><span><a class="mark" href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend" id="buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend">#</a></span></h3>
+<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>8<span class="hljs-built_in">Array</span>(nodeBuffer.<span class="hljs-property">buffer</span>, nodeBuffer.<span class="hljs-property">byteOffset</span>, nodeBuffer.<span class="hljs-property">length</span>);</code></pre>
+<h4><code>buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])</code><span><a class="mark" href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend" id="buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1010,38 +1157,38 @@ Comparison is based on the actual sequence of bytes in each <code>Buffer</code>.
 <li><code>1</code> is returned if <code>target</code> should come <em>before</em> <code>buf</code> when sorted.</li>
 <li><code>-1</code> is returned if <code>target</code> should come <em>after</em> <code>buf</code> when sorted.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'ABC'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'BCD'</span>);
-<span class="hljs-keyword">const</span> buf3 = Buffer.from(<span class="hljs-string">'ABCD'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'ABC'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'BCD'</span>);
+<span class="hljs-keyword">const</span> buf3 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'ABCD'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf1));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf1));
 <span class="hljs-comment">// Prints: 0</span>
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf2));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf2));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf3));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf3));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf2.compare(buf1));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">compare</span>(buf1));
 <span class="hljs-comment">// Prints: 1</span>
-<span class="hljs-built_in">console</span>.log(buf2.compare(buf3));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">compare</span>(buf3));
 <span class="hljs-comment">// Prints: 1</span>
-<span class="hljs-built_in">console</span>.log([buf1, buf2, buf3].sort(Buffer.compare));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>([buf1, buf2, buf3].<span class="hljs-title function_">sort</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-property">compare</span>));
 <span class="hljs-comment">// Prints: [ &#x3C;Buffer 41 42 43>, &#x3C;Buffer 41 42 43 44>, &#x3C;Buffer 42 43 44> ]</span>
 <span class="hljs-comment">// (This result is equal to: [buf1, buf3, buf2].)</span></code></pre>
 <p>The optional <code>targetStart</code>, <code>targetEnd</code>, <code>sourceStart</code>, and <code>sourceEnd</code>
 arguments can be used to limit the comparison to specific ranges within <code>target</code>
 and <code>buf</code> respectively.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">9</span>, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">9</span>, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>));
 <span class="hljs-comment">// Prints: 0</span>
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>, <span class="hljs-number">4</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf2, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>, <span class="hljs-number">4</span>));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf1.compare(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">5</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">compare</span>(buf2, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">5</span>));
 <span class="hljs-comment">// Prints: 1</span></code></pre>
 <p><a href="errors.html#ERR_OUT_OF_RANGE"><code>ERR_OUT_OF_RANGE</code></a> is thrown if <code>targetStart &#x3C; 0</code>, <code>sourceStart &#x3C; 0</code>,
 <code>targetEnd > target.byteLength</code>, or <code>sourceEnd > source.byteLength</code>.</p>
-<h3><code>buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])</code><span><a class="mark" href="#buffer_buf_copy_target_targetstart_sourcestart_sourceend" id="buffer_buf_copy_target_targetstart_sourcestart_sourceend">#</a></span></h3>
+<h4><code>buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])</code><span><a class="mark" href="#buffer_buf_copy_target_targetstart_sourcestart_sourceend" id="buffer_buf_copy_target_targetstart_sourcestart_sourceend">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1057,12 +1204,12 @@ inclusive). <strong>Default:</strong> <a href="#buffer_buf_length"><code>buf.len
 </ul>
 <p>Copies data from a region of <code>buf</code> to a region in <code>target</code>, even if the <code>target</code>
 memory region overlaps with <code>buf</code>.</p>
-<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set"><code>TypedArray#set()</code></a> performs the same operation, and is available for all
-TypedArrays, including Node.js <code>Buffer</code>s, although it takes different
-function arguments.</p>
+<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set"><code>TypedArray.prototype.set()</code></a> performs the same operation, and is available
+for all TypedArrays, including Node.js <code>Buffer</code>s, although it takes
+different function arguments.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create two `Buffer` instances.</span>
-<span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.allocUnsafe(<span class="hljs-number">26</span>).fill(<span class="hljs-string">'!'</span>);
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>).<span class="hljs-title function_">fill</span>(<span class="hljs-string">'!'</span>);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">26</span>; i++) {
   <span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
@@ -1070,27 +1217,27 @@ function arguments.</p>
 }
 
 <span class="hljs-comment">// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.</span>
-buf1.copy(buf2, <span class="hljs-number">8</span>, <span class="hljs-number">16</span>, <span class="hljs-number">20</span>);
+buf1.<span class="hljs-title function_">copy</span>(buf2, <span class="hljs-number">8</span>, <span class="hljs-number">16</span>, <span class="hljs-number">20</span>);
 <span class="hljs-comment">// This is equivalent to:</span>
 <span class="hljs-comment">// buf2.set(buf1.subarray(16, 20), 8);</span>
 
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">25</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">25</span>));
 <span class="hljs-comment">// Prints: !!!!!!!!qrst!!!!!!!!!!!!!</span></code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` and copy data from one region to an overlapping region</span>
 <span class="hljs-comment">// within the same `Buffer`.</span>
 
-<span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">26</span>; i++) {
   <span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
   buf[i] = i + <span class="hljs-number">97</span>;
 }
 
-buf.copy(buf, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">10</span>);
+buf.<span class="hljs-title function_">copy</span>(buf, <span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">10</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: efghijghijklmnopqrstuvwxyz</span></code></pre>
-<h3><code>buf.entries()</code><span><a class="mark" href="#buffer_buf_entries" id="buffer_buf_entries">#</a></span></h3>
+<h4><code>buf.entries()</code><span><a class="mark" href="#buffer_buf_entries" id="buffer_buf_entries">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.1.0</span>
 </div>
@@ -1101,10 +1248,10 @@ buf.copy(buf, <span class="hljs-number">0</span>, <span class="hljs-number">4</s
 of <code>buf</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Log the entire contents of a `Buffer`.</span>
 
-<span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> pair <span class="hljs-keyword">of</span> buf.entries()) {
-  <span class="hljs-built_in">console</span>.log(pair);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> pair <span class="hljs-keyword">of</span> buf.<span class="hljs-title function_">entries</span>()) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(pair);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   [0, 98]</span>
@@ -1113,7 +1260,7 @@ of <code>buf</code>.</p>
 <span class="hljs-comment">//   [3, 102]</span>
 <span class="hljs-comment">//   [4, 101]</span>
 <span class="hljs-comment">//   [5, 114]</span></code></pre>
-<h3><code>buf.equals(otherBuffer)</code><span><a class="mark" href="#buffer_buf_equals_otherbuffer" id="buffer_buf_equals_otherbuffer">#</a></span></h3>
+<h4><code>buf.equals(otherBuffer)</code><span><a class="mark" href="#buffer_buf_equals_otherbuffer" id="buffer_buf_equals_otherbuffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1133,15 +1280,15 @@ compare <code>buf</code>.</li>
 <p>Returns <code>true</code> if both <code>buf</code> and <code>otherBuffer</code> have exactly the same bytes,
 <code>false</code> otherwise. Equivalent to
 <a href="#buffer_buf_compare_target_targetstart_targetend_sourcestart_sourceend"><code>buf.compare(otherBuffer) === 0</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'ABC'</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'414243'</span>, <span class="hljs-string">'hex'</span>);
-<span class="hljs-keyword">const</span> buf3 = Buffer.from(<span class="hljs-string">'ABCD'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'ABC'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'414243'</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> buf3 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'ABCD'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf1.equals(buf2));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">equals</span>(buf2));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf1.equals(buf3));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">equals</span>(buf3));
 <span class="hljs-comment">// Prints: false</span></code></pre>
-<h3><code>buf.fill(value[, offset[, end]][, encoding])</code><span><a class="mark" href="#buffer_buf_fill_value_offset_end_encoding" id="buffer_buf_fill_value_offset_end_encoding">#</a></span></h3>
+<h4><code>buf.fill(value[, offset[, end]][, encoding])</code><span><a class="mark" href="#buffer_buf_fill_value_offset_end_encoding" id="buffer_buf_fill_value_offset_end_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1175,9 +1322,9 @@ compare <code>buf</code>.</li>
 the entire <code>buf</code> will be filled:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Fill a `Buffer` with the ASCII character 'h'.</span>
 
-<span class="hljs-keyword">const</span> b = Buffer.allocUnsafe(<span class="hljs-number">50</span>).fill(<span class="hljs-string">'h'</span>);
+<span class="hljs-keyword">const</span> b = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">50</span>).<span class="hljs-title function_">fill</span>(<span class="hljs-string">'h'</span>);
 
-<span class="hljs-built_in">console</span>.log(b.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh</span></code></pre>
 <p><code>value</code> is coerced to a <code>uint32</code> value if it is not a string, <code>Buffer</code>, or
 integer. If the resulting integer is greater than <code>255</code> (decimal), <code>buf</code> will be
@@ -1186,19 +1333,19 @@ filled with <code>value &#x26; 255</code>.</p>
 then only the bytes of that character that fit into <code>buf</code> are written:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Fill a `Buffer` with character that takes up two bytes in UTF-8.</span>
 
-<span class="hljs-built_in">console</span>.log(Buffer.allocUnsafe(<span class="hljs-number">5</span>).fill(<span class="hljs-string">'\u0222'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">5</span>).<span class="hljs-title function_">fill</span>(<span class="hljs-string">'\u0222'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer c8 a2 c8 a2 c8></span></code></pre>
 <p>If <code>value</code> contains invalid characters, it is truncated; if no valid
 fill data remains, an exception is thrown:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">5</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">5</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'a'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">fill</span>(<span class="hljs-string">'a'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer 61 61 61 61 61></span>
-<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'aazz'</span>, <span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">fill</span>(<span class="hljs-string">'aazz'</span>, <span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: &#x3C;Buffer aa aa aa aa aa></span>
-<span class="hljs-built_in">console</span>.log(buf.fill(<span class="hljs-string">'zz'</span>, <span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">fill</span>(<span class="hljs-string">'zz'</span>, <span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Throws an exception.</span></code></pre>
-<h3><code>buf.includes(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_includes_value_byteoffset_encoding" id="buffer_buf_includes_value_byteoffset_encoding">#</a></span></h3>
+<h4><code>buf.includes(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_includes_value_byteoffset_encoding" id="buffer_buf_includes_value_byteoffset_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.3.0</span>
 </div>
@@ -1211,23 +1358,23 @@ offset is calculated from the end of <code>buf</code>. <strong>Default:</strong>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if <code>value</code> was found in <code>buf</code>, <code>false</code> otherwise.</li>
 </ul>
 <p>Equivalent to <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf() !== -1</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this is a buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'this is a buffer'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'this'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-string">'this'</span>));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'is'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-string">'is'</span>));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer'</span>)));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-number">97</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-number">97</span>));
 <span class="hljs-comment">// Prints: true (97 is the decimal ASCII value for 'a')</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer example'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer example'</span>)));
 <span class="hljs-comment">// Prints: false</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(Buffer.from(<span class="hljs-string">'a buffer example'</span>).slice(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer example'</span>).<span class="hljs-title function_">slice</span>(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
 <span class="hljs-comment">// Prints: true</span>
-<span class="hljs-built_in">console</span>.log(buf.includes(<span class="hljs-string">'this'</span>, <span class="hljs-number">4</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">includes</span>(<span class="hljs-string">'this'</span>, <span class="hljs-number">4</span>));
 <span class="hljs-comment">// Prints: false</span></code></pre>
-<h3><code>buf.indexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_indexof_value_byteoffset_encoding" id="buffer_buf_indexof_value_byteoffset_encoding">#</a></span></h3>
+<h4><code>buf.indexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_indexof_value_byteoffset_encoding" id="buffer_buf_indexof_value_byteoffset_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1260,50 +1407,50 @@ To compare a partial <code>Buffer</code>, use <a href="#buffer_buf_slice_start_e
 <li>a number, <code>value</code> will be interpreted as an unsigned 8-bit integer
 value between <code>0</code> and <code>255</code>.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this is a buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'this is a buffer'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-string">'this'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'this'</span>));
 <span class="hljs-comment">// Prints: 0</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-string">'is'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'is'</span>));
 <span class="hljs-comment">// Prints: 2</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer'</span>)));
 <span class="hljs-comment">// Prints: 8</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(<span class="hljs-number">97</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-number">97</span>));
 <span class="hljs-comment">// Prints: 8 (97 is the decimal ASCII value for 'a')</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer example'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer example'</span>)));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf.indexOf(Buffer.from(<span class="hljs-string">'a buffer example'</span>).slice(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">indexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'a buffer example'</span>).<span class="hljs-title function_">slice</span>(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>)));
 <span class="hljs-comment">// Prints: 8</span>
 
-<span class="hljs-keyword">const</span> utf16Buffer = Buffer.from(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
+<span class="hljs-keyword">const</span> utf16Buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
 
-<span class="hljs-built_in">console</span>.log(utf16Buffer.indexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(utf16Buffer.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: 4</span>
-<span class="hljs-built_in">console</span>.log(utf16Buffer.indexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">-4</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(utf16Buffer.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'\u03a3'</span>, -<span class="hljs-number">4</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: 6</span></code></pre>
 <p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a
 <code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,
 an integer between 0 and 255.</p>
 <p>If <code>byteOffset</code> is not a number, it will be coerced to a number. If the result
 of coercion is <code>NaN</code> or <code>0</code>, then the entire buffer will be searched. This
-behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf"><code>String#indexOf()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> b = Buffer.from(<span class="hljs-string">'abcdef'</span>);
+behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf"><code>String.prototype.indexOf()</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> b = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'abcdef'</span>);
 
 <span class="hljs-comment">// Passing a value that's a number, but not a valid byte.</span>
 <span class="hljs-comment">// Prints: 2, equivalent to searching for 99 or 'c'.</span>
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-number">99.9</span>));
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-number">99.9</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
 
 <span class="hljs-comment">// Passing a byteOffset that coerces to NaN or 0.</span>
 <span class="hljs-comment">// Prints: 1, searching the whole buffer.</span>
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, {}));
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
-<span class="hljs-built_in">console</span>.log(b.indexOf(<span class="hljs-string">'b'</span>, []));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'b'</span>, {}));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'b'</span>, []));</code></pre>
 <p>If <code>value</code> is an empty string or empty <code>Buffer</code> and <code>byteOffset</code> is less
 than <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code>value</code> is empty and
 <code>byteOffset</code> is at least <code>buf.length</code>, <code>buf.length</code> will be returned.</p>
-<h3><code>buf.keys()</code><span><a class="mark" href="#buffer_buf_keys" id="buffer_buf_keys">#</a></span></h3>
+<h4><code>buf.keys()</code><span><a class="mark" href="#buffer_buf_keys" id="buffer_buf_keys">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.1.0</span>
 </div>
@@ -1311,10 +1458,10 @@ than <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
 <p>Creates and returns an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">iterator</a> of <code>buf</code> keys (indices).</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> key <span class="hljs-keyword">of</span> buf.keys()) {
-  <span class="hljs-built_in">console</span>.log(key);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> key <span class="hljs-keyword">of</span> buf.<span class="hljs-title function_">keys</span>()) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   0</span>
@@ -1323,7 +1470,7 @@ than <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code
 <span class="hljs-comment">//   3</span>
 <span class="hljs-comment">//   4</span>
 <span class="hljs-comment">//   5</span></code></pre>
-<h3><code>buf.lastIndexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_lastindexof_value_byteoffset_encoding" id="buffer_buf_lastindexof_value_byteoffset_encoding">#</a></span></h3>
+<h4><code>buf.lastIndexOf(value[, byteOffset][, encoding])</code><span><a class="mark" href="#buffer_buf_lastindexof_value_byteoffset_encoding" id="buffer_buf_lastindexof_value_byteoffset_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1348,53 +1495,53 @@ determine the binary representation of the string that will be searched for in
 </ul>
 <p>Identical to <a href="#buffer_buf_indexof_value_byteoffset_encoding"><code>buf.indexOf()</code></a>, except the last occurrence of <code>value</code> is found
 rather than the first occurrence.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'this buffer is a buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'this buffer is a buffer'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'this'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'this'</span>));
 <span class="hljs-comment">// Prints: 0</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'buffer'</span>));
 <span class="hljs-comment">// Prints: 17</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(Buffer.from(<span class="hljs-string">'buffer'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>)));
 <span class="hljs-comment">// Prints: 17</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-number">97</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-number">97</span>));
 <span class="hljs-comment">// Prints: 15 (97 is the decimal ASCII value for 'a')</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(Buffer.from(<span class="hljs-string">'yolo'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'yolo'</span>)));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">5</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">5</span>));
 <span class="hljs-comment">// Prints: 5</span>
-<span class="hljs-built_in">console</span>.log(buf.lastIndexOf(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">4</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'buffer'</span>, <span class="hljs-number">4</span>));
 <span class="hljs-comment">// Prints: -1</span>
 
-<span class="hljs-keyword">const</span> utf16Buffer = Buffer.from(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
+<span class="hljs-keyword">const</span> utf16Buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'\u039a\u0391\u03a3\u03a3\u0395'</span>, <span class="hljs-string">'utf16le'</span>);
 
-<span class="hljs-built_in">console</span>.log(utf16Buffer.lastIndexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(utf16Buffer.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-literal">undefined</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: 6</span>
-<span class="hljs-built_in">console</span>.log(utf16Buffer.lastIndexOf(<span class="hljs-string">'\u03a3'</span>, <span class="hljs-number">-5</span>, <span class="hljs-string">'utf16le'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(utf16Buffer.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'\u03a3'</span>, -<span class="hljs-number">5</span>, <span class="hljs-string">'utf16le'</span>));
 <span class="hljs-comment">// Prints: 4</span></code></pre>
 <p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a
 <code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,
 an integer between 0 and 255.</p>
 <p>If <code>byteOffset</code> is not a number, it will be coerced to a number. Any arguments
 that coerce to <code>NaN</code>, like <code>{}</code> or <code>undefined</code>, will search the whole buffer.
-This behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf"><code>String#lastIndexOf()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> b = Buffer.from(<span class="hljs-string">'abcdef'</span>);
+This behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf"><code>String.prototype.lastIndexOf()</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> b = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'abcdef'</span>);
 
 <span class="hljs-comment">// Passing a value that's a number, but not a valid byte.</span>
 <span class="hljs-comment">// Prints: 2, equivalent to searching for 99 or 'c'.</span>
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-number">99.9</span>));
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-number">99.9</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-number">256</span> + <span class="hljs-number">99</span>));
 
 <span class="hljs-comment">// Passing a byteOffset that coerces to NaN.</span>
 <span class="hljs-comment">// Prints: 1, searching the whole buffer.</span>
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, {}));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'b'</span>, <span class="hljs-literal">undefined</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'b'</span>, {}));
 
 <span class="hljs-comment">// Passing a byteOffset that coerces to 0.</span>
 <span class="hljs-comment">// Prints: -1, equivalent to passing 0.</span>
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
-<span class="hljs-built_in">console</span>.log(b.lastIndexOf(<span class="hljs-string">'b'</span>, []));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'b'</span>, <span class="hljs-literal">null</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(b.<span class="hljs-title function_">lastIndexOf</span>(<span class="hljs-string">'b'</span>, []));</code></pre>
 <p>If <code>value</code> is an empty string or empty <code>Buffer</code>, <code>byteOffset</code> will be returned.</p>
-<h3><code>buf.length</code><span><a class="mark" href="#buffer_buf_length" id="buffer_buf_length">#</a></span></h3>
+<h4><code>buf.length</code><span><a class="mark" href="#buffer_buf_length" id="buffer_buf_length">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1404,22 +1551,22 @@ This behavior matches <a href="https://developer.mozilla.org/en-US/docs/Web/Java
 <p>Returns the number of bytes in <code>buf</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` and write a shorter string to it using UTF-8.</span>
 
-<span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">1234</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">1234</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 1234</span>
 
-buf.write(<span class="hljs-string">'some string'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf8'</span>);
+buf.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some string'</span>, <span class="hljs-number">0</span>, <span class="hljs-string">'utf8'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.length);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-property">length</span>);
 <span class="hljs-comment">// Prints: 1234</span></code></pre>
-<h3><code>buf.parent</code><span><a class="mark" href="#buffer_buf_parent" id="buffer_buf_parent">#</a></span></h3>
+<h4><code>buf.parent</code><span><a class="mark" href="#buffer_buf_parent" id="buffer_buf_parent">#</a></span></h4>
 <div class="api_metadata">
 <span>Deprecated since: v8.0.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#buffer_buf_buffer"><code>buf.buffer</code></a> instead.</div><p></p>
 <p>The <code>buf.parent</code> property is a deprecated alias for <code>buf.buffer</code>.</p>
-<h3><code>buf.readBigInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64be_offset" id="buffer_buf_readbigint64be_offset">#</a></span></h3>
+<h4><code>buf.readBigInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64be_offset" id="buffer_buf_readbigint64be_offset">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0, v10.20.0</span>
 </div>
@@ -1431,9 +1578,9 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 <p>Reads a signed, big-endian 64-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed
 values.</p>
-<h3><code>buf.readBigInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64le_offset" id="buffer_buf_readbigint64le_offset">#</a></span></h3>
+<h4><code>buf.readBigInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbigint64le_offset" id="buffer_buf_readbigint64le_offset">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <ul>
 <li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Number of bytes to skip before starting to read. Must
@@ -1444,15 +1591,15 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed
 values.</p>
-<h3><code>buf.readBigUInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64be_offset" id="buffer_buf_readbiguint64be_offset">#</a></span></h3>
+<h4><code>buf.readBigUInt64BE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64be_offset" id="buffer_buf_readbiguint64be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>This function is also available as <code>buf.readBigUint64BE()</code>.</p></td></tr>
-<tr><td>v12.0.0</td>
-<td><p><span>Added in: v12.0.0</span></p></td></tr>
+<tr><td>v12.0.0, v10.20.0</td>
+<td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -1463,16 +1610,17 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 </ul>
 <p>Reads an unsigned, big-endian 64-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
+<p>This function is also available under the <code>readBigUint64BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readBigUInt64BE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readBigUInt64BE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 4294967295n</span></code></pre>
-<h3><code>buf.readBigUInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64le_offset" id="buffer_buf_readbiguint64le_offset">#</a></span></h3>
+<h4><code>buf.readBigUInt64LE([offset])</code><span><a class="mark" href="#buffer_buf_readbiguint64le_offset" id="buffer_buf_readbiguint64le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0, v12.19.0</td>
 <td><p>This function is also available as <code>buf.readBigUint64LE()</code>.</p></td></tr>
 <tr><td>v12.0.0, v10.20.0</td>
 <td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
@@ -1486,11 +1634,12 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 </ul>
 <p>Reads an unsigned, little-endian 64-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
+<p>This function is also available under the <code>readBigUint64LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0x00</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>, <span class="hljs-number">0xff</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readBigUInt64LE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readBigUInt64LE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 18446744069414584320n</span></code></pre>
-<h3><code>buf.readDoubleBE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublebe_offset" id="buffer_buf_readdoublebe_offset">#</a></span></h3>
+<h4><code>buf.readDoubleBE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublebe_offset" id="buffer_buf_readdoublebe_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1508,11 +1657,11 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Reads a 64-bit, big-endian double from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readDoubleBE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readDoubleBE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 8.20788039913184e-304</span></code></pre>
-<h3><code>buf.readDoubleLE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublele_offset" id="buffer_buf_readdoublele_offset">#</a></span></h3>
+<h4><code>buf.readDoubleLE([offset])</code><span><a class="mark" href="#buffer_buf_readdoublele_offset" id="buffer_buf_readdoublele_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1530,13 +1679,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Reads a 64-bit, little-endian double from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readDoubleLE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readDoubleLE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 5.447603722011605e-270</span>
-<span class="hljs-built_in">console</span>.log(buf.readDoubleLE(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readDoubleLE</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readFloatBE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatbe_offset" id="buffer_buf_readfloatbe_offset">#</a></span></h3>
+<h4><code>buf.readFloatBE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatbe_offset" id="buffer_buf_readfloatbe_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1554,11 +1703,11 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Reads a 32-bit, big-endian float from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readFloatBE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readFloatBE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 2.387939260590663e-38</span></code></pre>
-<h3><code>buf.readFloatLE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatle_offset" id="buffer_buf_readfloatle_offset">#</a></span></h3>
+<h4><code>buf.readFloatLE([offset])</code><span><a class="mark" href="#buffer_buf_readfloatle_offset" id="buffer_buf_readfloatle_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1576,13 +1725,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Reads a 32-bit, little-endian float from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readFloatLE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readFloatLE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 1.539989614439558e-36</span>
-<span class="hljs-built_in">console</span>.log(buf.readFloatLE(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readFloatLE</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readInt8([offset])</code><span><a class="mark" href="#buffer_buf_readint8_offset" id="buffer_buf_readint8_offset">#</a></span></h3>
+<h4><code>buf.readInt8([offset])</code><span><a class="mark" href="#buffer_buf_readint8_offset" id="buffer_buf_readint8_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1601,15 +1750,15 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 1</code>. <strong>Default:</
 </ul>
 <p>Reads a signed 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">-1</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([-<span class="hljs-number">1</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt8</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: -1</span>
-<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt8</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Prints: 5</span>
-<span class="hljs-built_in">console</span>.log(buf.readInt8(<span class="hljs-number">2</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt8</span>(<span class="hljs-number">2</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readint16be_offset" id="buffer_buf_readint16be_offset">#</a></span></h3>
+<h4><code>buf.readInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readint16be_offset" id="buffer_buf_readint16be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1628,11 +1777,11 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 </ul>
 <p>Reads a signed, big-endian 16-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt16BE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt16BE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 5</span></code></pre>
-<h3><code>buf.readInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readint16le_offset" id="buffer_buf_readint16le_offset">#</a></span></h3>
+<h4><code>buf.readInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readint16le_offset" id="buffer_buf_readint16le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1652,13 +1801,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 <p>Reads a signed, little-endian 16-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt16LE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt16LE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 1280</span>
-<span class="hljs-built_in">console</span>.log(buf.readInt16LE(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt16LE</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readint32be_offset" id="buffer_buf_readint32be_offset">#</a></span></h3>
+<h4><code>buf.readInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readint32be_offset" id="buffer_buf_readint32be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1677,11 +1826,11 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Reads a signed, big-endian 32-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt32BE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt32BE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 5</span></code></pre>
-<h3><code>buf.readInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readint32le_offset" id="buffer_buf_readint32le_offset">#</a></span></h3>
+<h4><code>buf.readInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readint32le_offset" id="buffer_buf_readint32le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1701,13 +1850,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <p>Reads a signed, little-endian 32-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
 <p>Integers read from a <code>Buffer</code> are interpreted as two's complement signed values.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readInt32LE(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt32LE</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 83886080</span>
-<span class="hljs-built_in">console</span>.log(buf.readInt32LE(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readInt32LE</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintbe_offset_bytelength" id="buffer_buf_readintbe_offset_bytelength">#</a></span></h3>
+<h4><code>buf.readIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintbe_offset_bytelength" id="buffer_buf_readintbe_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1729,15 +1878,15 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
 and interprets the result as a big-endian, two's complement signed value
 supporting up to 48 bits of accuracy.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readIntBE</span>(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 1234567890ab</span>
-<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readIntBE</span>(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span>
-<span class="hljs-built_in">console</span>.log(buf.readIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readIntBE</span>(<span class="hljs-number">1</span>, <span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintle_offset_bytelength" id="buffer_buf_readintle_offset_bytelength">#</a></span></h3>
+<h4><code>buf.readIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readintle_offset_bytelength" id="buffer_buf_readintle_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1759,16 +1908,16 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
 and interprets the result as a little-endian, two's complement signed value
 supporting up to 48 bits of accuracy.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readIntLE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readIntLE</span>(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: -546f87a9cbee</span></code></pre>
-<h3><code>buf.readUInt8([offset])</code><span><a class="mark" href="#buffer_buf_readuint8_offset" id="buffer_buf_readuint8_offset">#</a></span></h3>
+<h4><code>buf.readUInt8([offset])</code><span><a class="mark" href="#buffer_buf_readuint8_offset" id="buffer_buf_readuint8_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint8()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -1783,20 +1932,21 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 1</code>. <strong>Default:</
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Reads an unsigned 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">1</span>, <span class="hljs-number">-2</span>]);
+<p>This function is also available under the <code>readUint8</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">1</span>, -<span class="hljs-number">2</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">0</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt8</span>(<span class="hljs-number">0</span>));
 <span class="hljs-comment">// Prints: 1</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">1</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt8</span>(<span class="hljs-number">1</span>));
 <span class="hljs-comment">// Prints: 254</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt8(<span class="hljs-number">2</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt8</span>(<span class="hljs-number">2</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readUInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16be_offset" id="buffer_buf_readuint16be_offset">#</a></span></h3>
+<h4><code>buf.readUInt16BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16be_offset" id="buffer_buf_readuint16be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint16BE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -1812,18 +1962,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 </ul>
 <p>Reads an unsigned, big-endian 16-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
+<p>This function is also available under the <code>readUint16BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt16BE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16BE</span>(<span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 1234</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt16BE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16BE</span>(<span class="hljs-number">1</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 3456</span></code></pre>
-<h3><code>buf.readUInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16le_offset" id="buffer_buf_readuint16le_offset">#</a></span></h3>
+<h4><code>buf.readUInt16LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint16le_offset" id="buffer_buf_readuint16le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint16LE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -1839,20 +1990,21 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 </ul>
 <p>Reads an unsigned, little-endian 16-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
+<p>This function is also available under the <code>readUint16LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16LE</span>(<span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 3412</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16LE</span>(<span class="hljs-number">1</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 5634</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt16LE(<span class="hljs-number">2</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt16LE</span>(<span class="hljs-number">2</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readUInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32be_offset" id="buffer_buf_readuint32be_offset">#</a></span></h3>
+<h4><code>buf.readUInt32BE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32be_offset" id="buffer_buf_readuint32be_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint32BE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -1868,16 +2020,17 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Reads an unsigned, big-endian 32-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
+<p>This function is also available under the <code>readUint32BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt32BE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt32BE</span>(<span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 12345678</span></code></pre>
-<h3><code>buf.readUInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32le_offset" id="buffer_buf_readuint32le_offset">#</a></span></h3>
+<h4><code>buf.readUInt32LE([offset])</code><span><a class="mark" href="#buffer_buf_readuint32le_offset" id="buffer_buf_readuint32le_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUint32LE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -1893,18 +2046,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Reads an unsigned, little-endian 32-bit integer from <code>buf</code> at the specified
 <code>offset</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
+<p>This function is also available under the <code>readUint32LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUInt32LE(<span class="hljs-number">0</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt32LE</span>(<span class="hljs-number">0</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 78563412</span>
-<span class="hljs-built_in">console</span>.log(buf.readUInt32LE(<span class="hljs-number">1</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUInt32LE</span>(<span class="hljs-number">1</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readUIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintbe_offset_bytelength" id="buffer_buf_readuintbe_offset_bytelength">#</a></span></h3>
+<h4><code>buf.readUIntBE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintbe_offset_bytelength" id="buffer_buf_readuintbe_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUintBE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
@@ -1923,18 +2077,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
 and interprets the result as an unsigned big-endian integer supporting
 up to 48 bits of accuracy.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
+<p>This function is also available under the <code>readUintBE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUIntBE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUIntBE</span>(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: 1234567890ab</span>
-<span class="hljs-built_in">console</span>.log(buf.readUIntBE(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUIntBE</span>(<span class="hljs-number">1</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Throws ERR_OUT_OF_RANGE.</span></code></pre>
-<h3><code>buf.readUIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintle_offset_bytelength" id="buffer_buf_readuintle_offset_bytelength">#</a></span></h3>
+<h4><code>buf.readUIntLE(offset, byteLength)</code><span><a class="mark" href="#buffer_buf_readuintle_offset_bytelength" id="buffer_buf_readuintle_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.readUintLE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
@@ -1953,11 +2108,12 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>
 and interprets the result as an unsigned, little-endian integer supporting
 up to 48 bits of accuracy.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
+<p>This function is also available under the <code>readUintLE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x12</span>, <span class="hljs-number">0x34</span>, <span class="hljs-number">0x56</span>, <span class="hljs-number">0x78</span>, <span class="hljs-number">0x90</span>, <span class="hljs-number">0xab</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf.readUIntLE(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).toString(<span class="hljs-number">16</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">readUIntLE</span>(<span class="hljs-number">0</span>, <span class="hljs-number">6</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>));
 <span class="hljs-comment">// Prints: ab9078563412</span></code></pre>
-<h3><code>buf.subarray([start[, end]])</code><span><a class="mark" href="#buffer_buf_subarray_start_end" id="buffer_buf_subarray_start_end">#</a></span></h3>
+<h4><code>buf.subarray([start[, end]])</code><span><a class="mark" href="#buffer_buf_subarray_start_end" id="buffer_buf_subarray_start_end">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
@@ -1971,52 +2127,52 @@ up to 48 bits of accuracy.</p>
 offset and cropped by the <code>start</code> and <code>end</code> indices.</p>
 <p>Specifying <code>end</code> greater than <a href="#buffer_buf_length"><code>buf.length</code></a> will return the same result as
 that of <code>end</code> equal to <a href="#buffer_buf_length"><code>buf.length</code></a>.</p>
-<p>This method is inherited from <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray#subarray()</code></a>.</p>
+<p>This method is inherited from <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray"><code>TypedArray.prototype.subarray()</code></a>.</p>
 <p>Modifying the new <code>Buffer</code> slice will modify the memory in the original <code>Buffer</code>
 because the allocated memory of the two objects overlap.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte</span>
 <span class="hljs-comment">// from the original `Buffer`.</span>
 
-<span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">26</span>; i++) {
   <span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
   buf1[i] = i + <span class="hljs-number">97</span>;
 }
 
-<span class="hljs-keyword">const</span> buf2 = buf1.subarray(<span class="hljs-number">0</span>, <span class="hljs-number">3</span>);
+<span class="hljs-keyword">const</span> buf2 = buf1.<span class="hljs-title function_">subarray</span>(<span class="hljs-number">0</span>, <span class="hljs-number">3</span>);
 
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.length));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.<span class="hljs-property">length</span>));
 <span class="hljs-comment">// Prints: abc</span>
 
 buf1[<span class="hljs-number">0</span>] = <span class="hljs-number">33</span>;
 
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.length));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'ascii'</span>, <span class="hljs-number">0</span>, buf2.<span class="hljs-property">length</span>));
 <span class="hljs-comment">// Prints: !bc</span></code></pre>
 <p>Specifying negative indexes causes the slice to be generated relative to the
 end of <code>buf</code> rather than the beginning.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-6</span>, <span class="hljs-number">-1</span>).toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">subarray</span>(-<span class="hljs-number">6</span>, -<span class="hljs-number">1</span>).<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: buffe</span>
 <span class="hljs-comment">// (Equivalent to buf.subarray(0, 5).)</span>
 
-<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-6</span>, <span class="hljs-number">-2</span>).toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">subarray</span>(-<span class="hljs-number">6</span>, -<span class="hljs-number">2</span>).<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: buff</span>
 <span class="hljs-comment">// (Equivalent to buf.subarray(0, 4).)</span>
 
-<span class="hljs-built_in">console</span>.log(buf.subarray(<span class="hljs-number">-5</span>, <span class="hljs-number">-2</span>).toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">subarray</span>(-<span class="hljs-number">5</span>, -<span class="hljs-number">2</span>).<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: uff</span>
 <span class="hljs-comment">// (Equivalent to buf.subarray(1, 4).)</span></code></pre>
-<h3><code>buf.slice([start[, end]])</code><span><a class="mark" href="#buffer_buf_slice_start_end" id="buffer_buf_slice_start_end">#</a></span></h3>
+<h4><code>buf.slice([start[, end]])</code><span><a class="mark" href="#buffer_buf_slice_start_end" id="buffer_buf_slice_start_end">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.1.0, v6.9.2</td>
-<td><p>Coercing the offsets to integers now handles values outside the 32-bit integer range properly.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>All offsets are now coerced to integers before doing any calculations with them.</p></td></tr>
+<tr><td>v7.1.0, v6.9.2</td>
+<td><p>Coercing the offsets to integers now handles values outside the 32-bit integer range properly.</p></td></tr>
 <tr><td>v0.3.0</td>
 <td><p><span>Added in: v0.3.0</span></p></td></tr>
 </tbody></table>
@@ -2034,16 +2190,16 @@ offset and cropped by the <code>start</code> and <code>end</code> indices.</p>
 <p>This method is not compatible with the <code>Uint8Array.prototype.slice()</code>,
 which is a superclass of <code>Buffer</code>. To copy the slice, use
 <code>Uint8Array.prototype.slice()</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">const</span> copiedBuf = <span class="hljs-built_in">Uint8Array</span>.prototype.slice.call(buf);
+<span class="hljs-keyword">const</span> copiedBuf = <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">slice</span>.<span class="hljs-title function_">call</span>(buf);
 copiedBuf[<span class="hljs-number">0</span>]++;
-<span class="hljs-built_in">console</span>.log(copiedBuf.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(copiedBuf.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: cuffer</span>
 
-<span class="hljs-built_in">console</span>.log(buf.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints: buffer</span></code></pre>
-<h3><code>buf.swap16()</code><span><a class="mark" href="#buffer_buf_swap16" id="buffer_buf_swap16">#</a></span></h3>
+<h4><code>buf.swap16()</code><span><a class="mark" href="#buffer_buf_swap16" id="buffer_buf_swap16">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -2053,25 +2209,25 @@ copiedBuf[<span class="hljs-number">0</span>]++;
 <p>Interprets <code>buf</code> as an array of unsigned 16-bit integers and swaps the
 byte order <em>in-place</em>. Throws <a href="errors.html#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a>
 is not a multiple of 2.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05 06 07 08></span>
 
-buf1.swap16();
+buf1.<span class="hljs-title function_">swap16</span>();
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 02 01 04 03 06 05 08 07></span>
 
-<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
 
-buf2.swap16();
+buf2.<span class="hljs-title function_">swap16</span>();
 <span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
 <p>One convenient use of <code>buf.swap16()</code> is to perform a fast in-place conversion
 between UTF-16 little-endian and UTF-16 big-endian:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'This is little-endian UTF-16'</span>, <span class="hljs-string">'utf16le'</span>);
-buf.swap16(); <span class="hljs-comment">// Convert to big-endian UTF-16 text.</span></code></pre>
-<h3><code>buf.swap32()</code><span><a class="mark" href="#buffer_buf_swap32" id="buffer_buf_swap32">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'This is little-endian UTF-16'</span>, <span class="hljs-string">'utf16le'</span>);
+buf.<span class="hljs-title function_">swap16</span>(); <span class="hljs-comment">// Convert to big-endian UTF-16 text.</span></code></pre>
+<h4><code>buf.swap32()</code><span><a class="mark" href="#buffer_buf_swap32" id="buffer_buf_swap32">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -2081,21 +2237,21 @@ buf.swap16(); <span class="hljs-comment">// Convert to big-endian UTF-16 text.</
 <p>Interprets <code>buf</code> as an array of unsigned 32-bit integers and swaps the
 byte order <em>in-place</em>. Throws <a href="errors.html#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a>
 is not a multiple of 4.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05 06 07 08></span>
 
-buf1.swap32();
+buf1.<span class="hljs-title function_">swap32</span>();
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 04 03 02 01 08 07 06 05></span>
 
-<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
 
-buf2.swap32();
+buf2.<span class="hljs-title function_">swap32</span>();
 <span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
-<h3><code>buf.swap64()</code><span><a class="mark" href="#buffer_buf_swap64" id="buffer_buf_swap64">#</a></span></h3>
+<h4><code>buf.swap64()</code><span><a class="mark" href="#buffer_buf_swap64" id="buffer_buf_swap64">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -2104,21 +2260,21 @@ buf2.swap32();
 </ul>
 <p>Interprets <code>buf</code> as an array of 64-bit numbers and swaps byte order <em>in-place</em>.
 Throws <a href="errors.html#ERR_INVALID_BUFFER_SIZE"><code>ERR_INVALID_BUFFER_SIZE</code></a> if <a href="#buffer_buf_length"><code>buf.length</code></a> is not a multiple of 8.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>, <span class="hljs-number">0x6</span>, <span class="hljs-number">0x7</span>, <span class="hljs-number">0x8</span>]);
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05 06 07 08></span>
 
-buf1.swap64();
+buf1.<span class="hljs-title function_">swap64</span>();
 
-<span class="hljs-built_in">console</span>.log(buf1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 08 07 06 05 04 03 02 01></span>
 
-<span class="hljs-keyword">const</span> buf2 = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>]);
 
-buf2.swap64();
+buf2.<span class="hljs-title function_">swap64</span>();
 <span class="hljs-comment">// Throws ERR_INVALID_BUFFER_SIZE.</span></code></pre>
-<h3><code>buf.toJSON()</code><span><a class="mark" href="#buffer_buf_tojson" id="buffer_buf_tojson">#</a></span></h3>
+<h4><code>buf.toJSON()</code><span><a class="mark" href="#buffer_buf_tojson" id="buffer_buf_tojson">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.2</span>
 </div>
@@ -2129,21 +2285,21 @@ buf2.swap64();
 this function when stringifying a <code>Buffer</code> instance.</p>
 <p><code>Buffer.from()</code> accepts objects in the format returned from this method.
 In particular, <code>Buffer.from(buf.toJSON())</code> works like <code>Buffer.from(buf)</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>]);
-<span class="hljs-keyword">const</span> json = <span class="hljs-built_in">JSON</span>.stringify(buf);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x1</span>, <span class="hljs-number">0x2</span>, <span class="hljs-number">0x3</span>, <span class="hljs-number">0x4</span>, <span class="hljs-number">0x5</span>]);
+<span class="hljs-keyword">const</span> json = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(buf);
 
-<span class="hljs-built_in">console</span>.log(json);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(json);
 <span class="hljs-comment">// Prints: {"type":"Buffer","data":[1,2,3,4,5]}</span>
 
-<span class="hljs-keyword">const</span> copy = <span class="hljs-built_in">JSON</span>.parse(json, <span class="hljs-function">(<span class="hljs-params">key, value</span>) =></span> {
-  <span class="hljs-keyword">return</span> value &#x26;&#x26; value.type === <span class="hljs-string">'Buffer'</span> ?
-    Buffer.from(value) :
+<span class="hljs-keyword">const</span> copy = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(json, <span class="hljs-function">(<span class="hljs-params">key, value</span>) =></span> {
+  <span class="hljs-keyword">return</span> value &#x26;&#x26; value.<span class="hljs-property">type</span> === <span class="hljs-string">'Buffer'</span> ?
+    <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(value) :
     value;
 });
 
-<span class="hljs-built_in">console</span>.log(copy);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(copy);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05></span></code></pre>
-<h3><code>buf.toString([encoding[, start[, end]]])</code><span><a class="mark" href="#buffer_buf_tostring_encoding_start_end" id="buffer_buf_tostring_encoding_start_end">#</a></span></h3>
+<h4><code>buf.toString([encoding[, start[, end]]])</code><span><a class="mark" href="#buffer_buf_tostring_encoding_start_end" id="buffer_buf_tostring_encoding_start_end">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -2160,27 +2316,27 @@ In particular, <code>Buffer.from(buf.toJSON())</code> works like <code>Buffer.fr
 then each invalid byte is replaced with the replacement character <code>U+FFFD</code>.</p>
 <p>The maximum length of a string instance (in UTF-16 code units) is available
 as <a href="#buffer_buffer_constants_max_string_length"><code>buffer.constants.MAX_STRING_LENGTH</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = Buffer.allocUnsafe(<span class="hljs-number">26</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">26</span>);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">26</span>; i++) {
   <span class="hljs-comment">// 97 is the decimal ASCII value for 'a'.</span>
   buf1[i] = i + <span class="hljs-number">97</span>;
 }
 
-<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'utf8'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: abcdefghijklmnopqrstuvwxyz</span>
-<span class="hljs-built_in">console</span>.log(buf1.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf1.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">5</span>));
 <span class="hljs-comment">// Prints: abcde</span>
 
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'tést'</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'tést'</span>);
 
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'hex'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: 74c3a97374</span>
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
 <span class="hljs-comment">// Prints: té</span>
-<span class="hljs-built_in">console</span>.log(buf2.toString(<span class="hljs-literal">undefined</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf2.<span class="hljs-title function_">toString</span>(<span class="hljs-literal">undefined</span>, <span class="hljs-number">0</span>, <span class="hljs-number">3</span>));
 <span class="hljs-comment">// Prints: té</span></code></pre>
-<h3><code>buf.values()</code><span><a class="mark" href="#buffer_buf_values" id="buffer_buf_values">#</a></span></h3>
+<h4><code>buf.values()</code><span><a class="mark" href="#buffer_buf_values" id="buffer_buf_values">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.1.0</span>
 </div>
@@ -2189,10 +2345,10 @@ as <a href="#buffer_buffer_constants_max_string_length"><code>buffer.constants.M
 </ul>
 <p>Creates and returns an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">iterator</a> for <code>buf</code> values (bytes). This function is
 called automatically when a <code>Buffer</code> is used in a <code>for..of</code> statement.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.from(<span class="hljs-string">'buffer'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> value <span class="hljs-keyword">of</span> buf.values()) {
-  <span class="hljs-built_in">console</span>.log(value);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> value <span class="hljs-keyword">of</span> buf.<span class="hljs-title function_">values</span>()) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   98</span>
@@ -2203,7 +2359,7 @@ called automatically when a <code>Buffer</code> is used in a <code>for..of</code
 <span class="hljs-comment">//   114</span>
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> value <span class="hljs-keyword">of</span> buf) {
-  <span class="hljs-built_in">console</span>.log(value);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   98</span>
@@ -2212,7 +2368,7 @@ called automatically when a <code>Buffer</code> is used in a <code>for..of</code
 <span class="hljs-comment">//   102</span>
 <span class="hljs-comment">//   101</span>
 <span class="hljs-comment">//   114</span></code></pre>
-<h3><code>buf.write(string[, offset[, length]][, encoding])</code><span><a class="mark" href="#buffer_buf_write_string_offset_length_encoding" id="buffer_buf_write_string_offset_length_encoding">#</a></span></h3>
+<h4><code>buf.write(string[, offset[, length]][, encoding])</code><span><a class="mark" href="#buffer_buf_write_string_offset_length_encoding" id="buffer_buf_write_string_offset_length_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -2229,22 +2385,22 @@ exceed <code>buf.length - offset</code>). <strong>Default:</strong> <code>buf.le
 <code>encoding</code>. The <code>length</code> parameter is the number of bytes to write. If <code>buf</code> did
 not contain enough space to fit the entire string, only part of <code>string</code> will be
 written. However, partially encoded characters will not be written.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">256</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">256</span>);
 
-<span class="hljs-keyword">const</span> len = buf.write(<span class="hljs-string">'\u00bd + \u00bc = \u00be'</span>, <span class="hljs-number">0</span>);
+<span class="hljs-keyword">const</span> len = buf.<span class="hljs-title function_">write</span>(<span class="hljs-string">'\u00bd + \u00bc = \u00be'</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${len}</span> bytes: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, len)}</span>`</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${len}</span> bytes: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, len)}</span>`</span>);
 <span class="hljs-comment">// Prints: 12 bytes: ½ + ¼ = ¾</span>
 
-<span class="hljs-keyword">const</span> buffer = Buffer.alloc(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
 
-<span class="hljs-keyword">const</span> length = buffer.write(<span class="hljs-string">'abcd'</span>, <span class="hljs-number">8</span>);
+<span class="hljs-keyword">const</span> length = buffer.<span class="hljs-title function_">write</span>(<span class="hljs-string">'abcd'</span>, <span class="hljs-number">8</span>);
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${length}</span> bytes: <span class="hljs-subst">${buffer.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">8</span>, <span class="hljs-number">10</span>)}</span>`</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${length}</span> bytes: <span class="hljs-subst">${buffer.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">8</span>, <span class="hljs-number">10</span>)}</span>`</span>);
 <span class="hljs-comment">// Prints: 2 bytes : ab</span></code></pre>
-<h3><code>buf.writeBigInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64be_value_offset" id="buffer_buf_writebigint64be_value_offset">#</a></span></h3>
+<h4><code>buf.writeBigInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64be_value_offset" id="buffer_buf_writebigint64be_value_offset">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> Number to be written to <code>buf</code>.</li>
@@ -2254,13 +2410,13 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>
 <p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeBigInt64BE(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeBigInt64BE</span>(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04 05 06 07 08></span></code></pre>
-<h3><code>buf.writeBigInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64le_value_offset" id="buffer_buf_writebigint64le_value_offset">#</a></span></h3>
+<h4><code>buf.writeBigInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebigint64le_value_offset" id="buffer_buf_writebigint64le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0, v10.20.0</span>
 </div>
@@ -2272,18 +2428,18 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian.</p>
 <p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeBigInt64LE(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeBigInt64LE</span>(<span class="hljs-number">0x0102030405060708n</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 08 07 06 05 04 03 02 01></span></code></pre>
-<h3><code>buf.writeBigUInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64be_value_offset" id="buffer_buf_writebiguint64be_value_offset">#</a></span></h3>
+<h4><code>buf.writeBigUInt64BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64be_value_offset" id="buffer_buf_writebiguint64be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>This function is also available as <code>buf.writeBigUint64BE()</code>.</p></td></tr>
 <tr><td>v12.0.0, v10.20.0</td>
 <td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
@@ -2297,21 +2453,22 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <code>offset</code> plus the number of bytes written.</li>
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<p>This function is also available under the <code>writeBigUint64BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeBigUInt64BE(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeBigUInt64BE</span>(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer de ca fa fe ca ce fa de></span></code></pre>
-<h3><code>buf.writeBigUInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64le_value_offset" id="buffer_buf_writebiguint64le_value_offset">#</a></span></h3>
+<h4><code>buf.writeBigUInt64LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writebiguint64le_value_offset" id="buffer_buf_writebiguint64le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>This function is also available as <code>buf.writeBigUint64LE()</code>.</p></td></tr>
-<tr><td>v12.0.0</td>
-<td><p><span>Added in: v12.0.0</span></p></td></tr>
+<tr><td>v12.0.0, v10.20.0</td>
+<td><p><span>Added in: v12.0.0, v10.20.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -2322,13 +2479,14 @@ satisfy: <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:<
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <code>offset</code> plus the number of bytes written.</li>
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeBigUInt64LE(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeBigUInt64LE</span>(<span class="hljs-number">0xdecafafecacefaden</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer de fa ce ca fe fa ca de></span></code></pre>
-<h3><code>buf.writeDoubleBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublebe_value_offset" id="buffer_buf_writedoublebe_value_offset">#</a></span></h3>
+<p>This function is also available under the <code>writeBigUint64LE</code> alias.</p>
+<h4><code>buf.writeDoubleBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublebe_value_offset" id="buffer_buf_writedoublebe_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2349,13 +2507,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
 must be a JavaScript number. Behavior is undefined when <code>value</code> is anything
 other than a JavaScript number.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeDoubleBE(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeDoubleBE</span>(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 40 5e dd 2f 1a 9f be 77></span></code></pre>
-<h3><code>buf.writeDoubleLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublele_value_offset" id="buffer_buf_writedoublele_value_offset">#</a></span></h3>
+<h4><code>buf.writeDoubleLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writedoublele_value_offset" id="buffer_buf_writedoublele_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2376,13 +2534,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 8</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
 must be a JavaScript number. Behavior is undefined when <code>value</code> is anything
 other than a JavaScript number.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">8</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">8</span>);
 
-buf.writeDoubleLE(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeDoubleLE</span>(<span class="hljs-number">123.456</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 77 be 9f 1a 2f dd 5e 40></span></code></pre>
-<h3><code>buf.writeFloatBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatbe_value_offset" id="buffer_buf_writefloatbe_value_offset">#</a></span></h3>
+<h4><code>buf.writeFloatBE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatbe_value_offset" id="buffer_buf_writefloatbe_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2402,14 +2560,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. Behavior is
 undefined when <code>value</code> is anything other than a JavaScript number.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeFloatBE(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeFloatBE</span>(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
-<span class="hljs-comment">// Prints: &#x3C;Buffer 4f 4a fe bb></span>
-</code></pre>
-<h3><code>buf.writeFloatLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatle_value_offset" id="buffer_buf_writefloatle_value_offset">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
+<span class="hljs-comment">// Prints: &#x3C;Buffer 4f 4a fe bb></span></code></pre>
+<h4><code>buf.writeFloatLE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writefloatle_value_offset" id="buffer_buf_writefloatle_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2429,13 +2586,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 </ul>
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. Behavior is
 undefined when <code>value</code> is anything other than a JavaScript number.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeFloatLE(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeFloatLE</span>(<span class="hljs-number">0xcafebabe</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer bb fe 4a 4f></span></code></pre>
-<h3><code>buf.writeInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint8_value_offset" id="buffer_buf_writeint8_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint8_value_offset" id="buffer_buf_writeint8_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2457,14 +2614,14 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 1</code>. <strong>Default:</
 signed 8-bit integer. Behavior is undefined when <code>value</code> is anything other than
 a signed 8-bit integer.</p>
 <p><code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">2</span>);
 
-buf.writeInt8(<span class="hljs-number">2</span>, <span class="hljs-number">0</span>);
-buf.writeInt8(<span class="hljs-number">-2</span>, <span class="hljs-number">1</span>);
+buf.<span class="hljs-title function_">writeInt8</span>(<span class="hljs-number">2</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt8</span>(-<span class="hljs-number">2</span>, <span class="hljs-number">1</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 02 fe></span></code></pre>
-<h3><code>buf.writeInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16be_value_offset" id="buffer_buf_writeint16be_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16be_value_offset" id="buffer_buf_writeint16be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2486,13 +2643,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 must be a valid signed 16-bit integer. Behavior is undefined when <code>value</code> is
 anything other than a signed 16-bit integer.</p>
 <p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">2</span>);
 
-buf.writeInt16BE(<span class="hljs-number">0x0102</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt16BE</span>(<span class="hljs-number">0x0102</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02></span></code></pre>
-<h3><code>buf.writeInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16le_value_offset" id="buffer_buf_writeint16le_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint16le_value_offset" id="buffer_buf_writeint16le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2514,13 +2671,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 must be a valid signed 16-bit integer. Behavior is undefined when <code>value</code> is
 anything other than a signed 16-bit integer.</p>
 <p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">2</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">2</span>);
 
-buf.writeInt16LE(<span class="hljs-number">0x0304</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt16LE</span>(<span class="hljs-number">0x0304</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 04 03></span></code></pre>
-<h3><code>buf.writeInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32be_value_offset" id="buffer_buf_writeint32be_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32be_value_offset" id="buffer_buf_writeint32be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2542,13 +2699,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 must be a valid signed 32-bit integer. Behavior is undefined when <code>value</code> is
 anything other than a signed 32-bit integer.</p>
 <p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeInt32BE(<span class="hljs-number">0x01020304</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt32BE</span>(<span class="hljs-number">0x01020304</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 01 02 03 04></span></code></pre>
-<h3><code>buf.writeInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32le_value_offset" id="buffer_buf_writeint32le_value_offset">#</a></span></h3>
+<h4><code>buf.writeInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeint32le_value_offset" id="buffer_buf_writeint32le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2570,13 +2727,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 must be a valid signed 32-bit integer. Behavior is undefined when <code>value</code> is
 anything other than a signed 32-bit integer.</p>
 <p>The <code>value</code> is interpreted and written as a two's complement signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeInt32LE(<span class="hljs-number">0x05060708</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeInt32LE</span>(<span class="hljs-number">0x05060708</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 08 07 06 05></span></code></pre>
-<h3><code>buf.writeIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintbe_value_offset_bytelength" id="buffer_buf_writeintbe_value_offset_bytelength">#</a></span></h3>
+<h4><code>buf.writeIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintbe_value_offset_bytelength" id="buffer_buf_writeintbe_value_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2599,14 +2756,13 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
 as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when
 <code>value</code> is anything other than a signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">6</span>);
 
-buf.writeIntBE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
+buf.<span class="hljs-title function_">writeIntBE</span>(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
-<span class="hljs-comment">// Prints: &#x3C;Buffer 12 34 56 78 90 ab></span>
-</code></pre>
-<h3><code>buf.writeIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintle_value_offset_bytelength" id="buffer_buf_writeintle_value_offset_bytelength">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
+<span class="hljs-comment">// Prints: &#x3C;Buffer 12 34 56 78 90 ab></span></code></pre>
+<h4><code>buf.writeIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeintle_value_offset_bytelength" id="buffer_buf_writeintle_value_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2629,18 +2785,18 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
 as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
 when <code>value</code> is anything other than a signed integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">6</span>);
 
-buf.writeIntLE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
+buf.<span class="hljs-title function_">writeIntLE</span>(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer ab 90 78 56 34 12></span></code></pre>
-<h3><code>buf.writeUInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint8_value_offset" id="buffer_buf_writeuint8_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt8(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint8_value_offset" id="buffer_buf_writeuint8_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUint8()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -2658,21 +2814,22 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 1</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code>. <code>value</code> must be a
 valid unsigned 8-bit integer. Behavior is undefined when <code>value</code> is anything
 other than an unsigned 8-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint8</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt8(<span class="hljs-number">0x3</span>, <span class="hljs-number">0</span>);
-buf.writeUInt8(<span class="hljs-number">0x4</span>, <span class="hljs-number">1</span>);
-buf.writeUInt8(<span class="hljs-number">0x23</span>, <span class="hljs-number">2</span>);
-buf.writeUInt8(<span class="hljs-number">0x42</span>, <span class="hljs-number">3</span>);
+buf.<span class="hljs-title function_">writeUInt8</span>(<span class="hljs-number">0x3</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt8</span>(<span class="hljs-number">0x4</span>, <span class="hljs-number">1</span>);
+buf.<span class="hljs-title function_">writeUInt8</span>(<span class="hljs-number">0x23</span>, <span class="hljs-number">2</span>);
+buf.<span class="hljs-title function_">writeUInt8</span>(<span class="hljs-number">0x42</span>, <span class="hljs-number">3</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 03 04 23 42></span></code></pre>
-<h3><code>buf.writeUInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16be_value_offset" id="buffer_buf_writeuint16be_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt16BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16be_value_offset" id="buffer_buf_writeuint16be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUint16BE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -2690,19 +2847,20 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
 must be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code>
 is anything other than an unsigned 16-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint16BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt16BE(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
-buf.writeUInt16BE(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
+buf.<span class="hljs-title function_">writeUInt16BE</span>(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt16BE</span>(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer de ad be ef></span></code></pre>
-<h3><code>buf.writeUInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16le_value_offset" id="buffer_buf_writeuint16le_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt16LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint16le_value_offset" id="buffer_buf_writeuint16le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0, v12.19.0</td>
 <td><p>This function is also available as <code>buf.writeUint16LE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -2720,19 +2878,20 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 2</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
 must be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code> is
 anything other than an unsigned 16-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint16LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt16LE(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
-buf.writeUInt16LE(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
+buf.<span class="hljs-title function_">writeUInt16LE</span>(<span class="hljs-number">0xdead</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt16LE</span>(<span class="hljs-number">0xbeef</span>, <span class="hljs-number">2</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer ad de ef be></span></code></pre>
-<h3><code>buf.writeUInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32be_value_offset" id="buffer_buf_writeuint32be_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt32BE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32be_value_offset" id="buffer_buf_writeuint32be_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUint32BE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -2750,18 +2909,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>
 must be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code>
 is anything other than an unsigned 32-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint32BE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt32BE(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt32BE</span>(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer fe ed fa ce></span></code></pre>
-<h3><code>buf.writeUInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32le_value_offset" id="buffer_buf_writeuint32le_value_offset">#</a></span></h3>
+<h4><code>buf.writeUInt32LE(value[, offset])</code><span><a class="mark" href="#buffer_buf_writeuint32le_value_offset" id="buffer_buf_writeuint32le_value_offset">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUint32LE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset to <code>uint32</code> anymore.</p></td></tr>
@@ -2779,18 +2939,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - 4</code>. <strong>Default:</
 <p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>
 must be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code> is
 anything other than an unsigned 32-bit integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">4</span>);
+<p>This function is also available under the <code>writeUint32LE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">4</span>);
 
-buf.writeUInt32LE(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
+buf.<span class="hljs-title function_">writeUInt32LE</span>(<span class="hljs-number">0xfeedface</span>, <span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer ce fa ed fe></span></code></pre>
-<h3><code>buf.writeUIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintbe_value_offset_bytelength" id="buffer_buf_writeuintbe_value_offset_bytelength">#</a></span></h3>
+<h4><code>buf.writeUIntBE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintbe_value_offset_bytelength" id="buffer_buf_writeuintbe_value_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUintBE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
@@ -2810,18 +2971,19 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
 as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined
 when <code>value</code> is anything other than an unsigned integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
+<p>This function is also available under the <code>writeUintBE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">6</span>);
 
-buf.writeUIntBE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
+buf.<span class="hljs-title function_">writeUIntBE</span>(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer 12 34 56 78 90 ab></span></code></pre>
-<h3><code>buf.writeUIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintle_value_offset_bytelength" id="buffer_buf_writeuintle_value_offset_bytelength">#</a></span></h3>
+<h4><code>buf.writeUIntLE(value, offset, byteLength)</code><span><a class="mark" href="#buffer_buf_writeuintle_value_offset_bytelength" id="buffer_buf_writeuintle_value_offset_bytelength">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
 <td><p>This function is also available as <code>buf.writeUintLE()</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Removed <code>noAssert</code> and no implicit coercion of the offset and <code>byteLength</code> to <code>uint32</code> anymore.</p></td></tr>
@@ -2841,13 +3003,14 @@ satisfy <code>0 &#x3C;= offset &#x3C;= buf.length - byteLength</code>.</li>
 <p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>
 as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
 when <code>value</code> is anything other than an unsigned integer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.allocUnsafe(<span class="hljs-number">6</span>);
+<p>This function is also available under the <code>writeUintLE</code> alias.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">allocUnsafe</span>(<span class="hljs-number">6</span>);
 
-buf.writeUIntLE(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
+buf.<span class="hljs-title function_">writeUIntLE</span>(<span class="hljs-number">0x1234567890ab</span>, <span class="hljs-number">0</span>, <span class="hljs-number">6</span>);
 
-<span class="hljs-built_in">console</span>.log(buf);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf);
 <span class="hljs-comment">// Prints: &#x3C;Buffer ab 90 78 56 34 12></span></code></pre>
-<h3><code>new Buffer(array)</code><span><a class="mark" href="#buffer_new_buffer_array" id="buffer_new_buffer_array">#</a></span></h3>
+<h4><code>new Buffer(array)</code><span><a class="mark" href="#buffer_new_buffer_array" id="buffer_new_buffer_array">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2868,7 +3031,7 @@ buf.writeUIntLE(<span class="hljs-number">0x1234567890ab</span>, <span class="hl
 <li><code>array</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer[]></a> An array of bytes to copy from.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_from_array"><code>Buffer.from(array)</code></a>.</p>
-<h3><code>new Buffer(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_new_buffer_arraybuffer_byteoffset_length" id="buffer_new_buffer_arraybuffer_byteoffset_length">#</a></span></h3>
+<h4><code>new Buffer(arrayBuffer[, byteOffset[, length]])</code><span><a class="mark" href="#buffer_new_buffer_arraybuffer_byteoffset_length" id="buffer_new_buffer_arraybuffer_byteoffset_length">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2900,7 +3063,7 @@ instead.</div><p></p>
 </ul>
 <p>See
 <a href="#buffer_static_method_buffer_from_arraybuffer_byteoffset_length"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a>.</p>
-<h3><code>new Buffer(buffer)</code><span><a class="mark" href="#buffer_new_buffer_buffer" id="buffer_new_buffer_buffer">#</a></span></h3>
+<h4><code>new Buffer(buffer)</code><span><a class="mark" href="#buffer_new_buffer_buffer" id="buffer_new_buffer_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2922,7 +3085,7 @@ instead.</div><p></p>
 which to copy data.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_from_buffer"><code>Buffer.from(buffer)</code></a>.</p>
-<h3><code>new Buffer(size)</code><span><a class="mark" href="#buffer_new_buffer_size" id="buffer_new_buffer_size">#</a></span></h3>
+<h4><code>new Buffer(size)</code><span><a class="mark" href="#buffer_new_buffer_size" id="buffer_new_buffer_size">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2947,7 +3110,7 @@ which to copy data.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a> and <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>. This variant of the
 constructor is equivalent to <a href="#buffer_static_method_buffer_alloc_size_fill_encoding"><code>Buffer.alloc()</code></a>.</p>
-<h3><code>new Buffer(string[, encoding])</code><span><a class="mark" href="#buffer_new_buffer_string_encoding" id="buffer_new_buffer_string_encoding">#</a></span></h3>
+<h4><code>new Buffer(string[, encoding])</code><span><a class="mark" href="#buffer_new_buffer_string_encoding" id="buffer_new_buffer_string_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2970,11 +3133,43 @@ Use <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.fro
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The encoding of <code>string</code>. <strong>Default:</strong> <code>'utf8'</code>.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_from_string_encoding"><code>Buffer.from(string[, encoding])</code></a>.</p>
-<h2><code>buffer</code> module APIs<span><a class="mark" href="#buffer_buffer_module_apis" id="buffer_buffer_module_apis">#</a></span></h2>
+</section><section><h3><code>buffer</code> module APIs<span><a class="mark" href="#buffer_buffer_module_apis" id="buffer_buffer_module_apis">#</a></span></h3>
 <p>While, the <code>Buffer</code> object is available as a global, there are additional
 <code>Buffer</code>-related APIs that are available only via the <code>buffer</code> module
 accessed using <code>require('buffer')</code>.</p>
-<h3><code>buffer.INSPECT_MAX_BYTES</code><span><a class="mark" href="#buffer_buffer_inspect_max_bytes" id="buffer_buffer_inspect_max_bytes">#</a></span></h3>
+<h4><code>buffer.atob(data)</code><span><a class="mark" href="#buffer_buffer_atob_data" id="buffer_buffer_atob_data">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The Base64-encoded input string.</li>
+</ul>
+<p>Decodes a string of Base64-encoded data into bytes, and encodes those bytes
+into a string using Latin-1 (ISO-8859-1).</p>
+<p>The <code>data</code> may be any JavaScript-value that can be coerced into a string.</p>
+<p><strong>This function is only provided for compatibility with legacy web platform APIs
+and should never be used in new code, because they use strings to represent
+binary data and predate the introduction of typed arrays in JavaScript.
+For code running using Node.js APIs, converting between base64-encoded strings
+and binary data should be performed using <code>Buffer.from(str, 'base64')</code> and
+<code>buf.toString('base64')</code>.</strong></p>
+<h4><code>buffer.btoa(data)</code><span><a class="mark" href="#buffer_buffer_btoa_data" id="buffer_buffer_btoa_data">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> An ASCII (Latin1) string.</li>
+</ul>
+<p>Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes
+into a string using Base64.</p>
+<p>The <code>data</code> may be any JavaScript-value that can be coerced into a string.</p>
+<p><strong>This function is only provided for compatibility with legacy web platform APIs
+and should never be used in new code, because they use strings to represent
+binary data and predate the introduction of typed arrays in JavaScript.
+For code running using Node.js APIs, converting between base64-encoded strings
+and binary data should be performed using <code>Buffer.from(str, 'base64')</code> and
+<code>buf.toString('base64')</code>.</strong></p>
+<h4><code>buffer.INSPECT_MAX_BYTES</code><span><a class="mark" href="#buffer_buffer_inspect_max_bytes" id="buffer_buffer_inspect_max_bytes">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.4</span>
 </div>
@@ -2984,7 +3179,7 @@ accessed using <code>require('buffer')</code>.</p>
 <p>Returns the maximum number of bytes that will be returned when
 <code>buf.inspect()</code> is called. This can be overridden by user modules. See
 <a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a> for more details on <code>buf.inspect()</code> behavior.</p>
-<h3><code>buffer.kMaxLength</code><span><a class="mark" href="#buffer_buffer_kmaxlength" id="buffer_buffer_kmaxlength">#</a></span></h3>
+<h4><code>buffer.kMaxLength</code><span><a class="mark" href="#buffer_buffer_kmaxlength" id="buffer_buffer_kmaxlength">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
@@ -2992,7 +3187,15 @@ accessed using <code>require('buffer')</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The largest size allowed for a single <code>Buffer</code> instance.</li>
 </ul>
 <p>An alias for <a href="#buffer_buffer_constants_max_length"><code>buffer.constants.MAX_LENGTH</code></a>.</p>
-<h3><code>buffer.transcode(source, fromEnc, toEnc)</code><span><a class="mark" href="#buffer_buffer_transcode_source_fromenc_toenc" id="buffer_buffer_transcode_source_fromenc_toenc">#</a></span></h3>
+<h4><code>buffer.kStringMaxLength</code><span><a class="mark" href="#buffer_buffer_kstringmaxlength" id="buffer_buffer_kstringmaxlength">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v3.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The largest length allowed for a single <code>string</code> instance.</li>
+</ul>
+<p>An alias for <a href="#buffer_buffer_constants_max_string_length"><code>buffer.constants.MAX_STRING_LENGTH</code></a>.</p>
+<h4><code>buffer.transcode(source, fromEnc, toEnc)</code><span><a class="mark" href="#buffer_buffer_transcode_source_fromenc_toenc" id="buffer_buffer_transcode_source_fromenc_toenc">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -3020,12 +3223,12 @@ conversion from <code>fromEnc</code> to <code>toEnc</code> is not permitted.</p>
 sequence cannot be adequately represented in the target encoding. For instance:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> buffer = <span class="hljs-built_in">require</span>(<span class="hljs-string">'buffer'</span>);
 
-<span class="hljs-keyword">const</span> newBuf = buffer.transcode(Buffer.from(<span class="hljs-string">'€'</span>), <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'ascii'</span>);
-<span class="hljs-built_in">console</span>.log(newBuf.toString(<span class="hljs-string">'ascii'</span>));
+<span class="hljs-keyword">const</span> newBuf = buffer.<span class="hljs-title function_">transcode</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'€'</span>), <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'ascii'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(newBuf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'ascii'</span>));
 <span class="hljs-comment">// Prints: '?'</span></code></pre>
 <p>Because the Euro (<code>€</code>) sign is not representable in US-ASCII, it is replaced
 with <code>?</code> in the transcoded <code>Buffer</code>.</p>
-<h3>Class: <code>SlowBuffer</code><span><a class="mark" href="#buffer_class_slowbuffer" id="buffer_class_slowbuffer">#</a></span></h3>
+<h4>Class: <code>SlowBuffer</code><span><a class="mark" href="#buffer_class_slowbuffer" id="buffer_class_slowbuffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Deprecated since: v6.0.0</span>
 </div>
@@ -3033,7 +3236,7 @@ with <code>?</code> in the transcoded <code>Buffer</code>.</p>
 <p>See <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>. This was never a class in the sense that
 the constructor always returned a <code>Buffer</code> instance, rather than a <code>SlowBuffer</code>
 instance.</p>
-<h4><code>new SlowBuffer(size)</code><span><a class="mark" href="#buffer_new_slowbuffer_size" id="buffer_new_slowbuffer_size">#</a></span></h4>
+<h5><code>new SlowBuffer(size)</code><span><a class="mark" href="#buffer_new_slowbuffer_size" id="buffer_new_slowbuffer_size">#</a></span></h5>
 <div class="api_metadata">
 <span>Deprecated since: v6.0.0</span>
 </div>
@@ -3042,21 +3245,30 @@ instance.</p>
 <li><code>size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The desired length of the new <code>SlowBuffer</code>.</li>
 </ul>
 <p>See <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>.</p>
-<h3>Buffer constants<span><a class="mark" href="#buffer_buffer_constants" id="buffer_buffer_constants">#</a></span></h3>
+<h4>Buffer constants<span><a class="mark" href="#buffer_buffer_constants" id="buffer_buffer_constants">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 </div>
-<h4><code>buffer.constants.MAX_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_length" id="buffer_buffer_constants_max_length">#</a></span></h4>
+<h5><code>buffer.constants.MAX_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_length" id="buffer_buffer_constants_max_length">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.2.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Value is changed from 2<sup>31</sup> - 1 to 2<sup>32</sup> - 1 on 64-bit architectures.</p></td></tr>
+<tr><td>v8.2.0</td>
+<td><p><span>Added in: v8.2.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The largest size allowed for a single <code>Buffer</code> instance.</li>
 </ul>
-<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).
-On 64-bit architectures, this value currently is 2<sup>31</sup> - 1 (~2GB).</p>
+<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).</p>
+<p>On 64-bit architectures, this value currently is 2<sup>32</sup> - 1 (~4GB).</p>
+<p>It reflects <a href="https://v8.github.io/api/head/classv8_1_1TypedArray.html#a54a48f4373da0850663c4393d843b9b0"><code>v8::TypedArray::kMaxLength</code></a> under the hood.</p>
 <p>This value is also available as <a href="#buffer_buffer_kmaxlength"><code>buffer.kMaxLength</code></a>.</p>
-<h4><code>buffer.constants.MAX_STRING_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_string_length" id="buffer_buffer_constants_max_string_length">#</a></span></h4>
+<h5><code>buffer.constants.MAX_STRING_LENGTH</code><span><a class="mark" href="#buffer_buffer_constants_max_string_length" id="buffer_buffer_constants_max_string_length">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 </div>
@@ -3066,7 +3278,7 @@ On 64-bit architectures, this value currently is 2<sup>31</sup> - 1 (~2GB).</p>
 <p>Represents the largest <code>length</code> that a <code>string</code> primitive can have, counted
 in UTF-16 code units.</p>
 <p>This value may depend on the JS engine that is being used.</p>
-<h2><code>Buffer.from()</code>, <code>Buffer.alloc()</code>, and <code>Buffer.allocUnsafe()</code><span><a class="mark" href="#buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe" id="buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe">#</a></span></h2>
+</section><section><h3><code>Buffer.from()</code>, <code>Buffer.alloc()</code>, and <code>Buffer.allocUnsafe()</code><span><a class="mark" href="#buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe" id="buffer_buffer_from_buffer_alloc_and_buffer_allocunsafe">#</a></span></h3>
 <p>In versions of Node.js prior to 6.0.0, <code>Buffer</code> instances were created using the
 <code>Buffer</code> constructor function, which allocates the returned <code>Buffer</code>
 differently based on what arguments are provided:</p>
@@ -3135,21 +3347,21 @@ potentially sensitive.</li>
 if <code>size</code> is less than or equal to half <a href="#buffer_class_property_buffer_poolsize"><code>Buffer.poolSize</code></a>. Instances
 returned by <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a> <em>never</em> use the shared internal
 memory pool.</p>
-<h3>The <code>--zero-fill-buffers</code> command line option<span><a class="mark" href="#buffer_the_zero_fill_buffers_command_line_option" id="buffer_the_zero_fill_buffers_command_line_option">#</a></span></h3>
+<h4>The <code>--zero-fill-buffers</code> command-line option<span><a class="mark" href="#buffer_the_zero_fill_buffers_command_line_option" id="buffer_the_zero_fill_buffers_command_line_option">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
-<p>Node.js can be started using the <code>--zero-fill-buffers</code> command line option to
+<p>Node.js can be started using the <code>--zero-fill-buffers</code> command-line option to
 cause all newly-allocated <code>Buffer</code> instances to be zero-filled upon creation by
 default. Without the option, buffers created with <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>,
 <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>, and <code>new SlowBuffer(size)</code> are not zero-filled.
 Use of this flag can have a measurable negative impact on performance. Use the
 <code>--zero-fill-buffers</code> option only when necessary to enforce that newly allocated
 <code>Buffer</code> instances cannot contain old data that is potentially sensitive.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --zero-fill-buffers</span>
-<span class="hljs-meta">></span><span class="bash"> Buffer.allocUnsafe(5);</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --zero-fill-buffers</span>
+<span class="hljs-meta">> </span><span class="language-bash">Buffer.allocUnsafe(5);</span>
 &#x3C;Buffer 00 00 00 00 00></code></pre>
-<h3>What makes <code>Buffer.allocUnsafe()</code> and <code>Buffer.allocUnsafeSlow()</code> "unsafe"?<span><a class="mark" href="#buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe" id="buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe">#</a></span></h3>
+<h4>What makes <code>Buffer.allocUnsafe()</code> and <code>Buffer.allocUnsafeSlow()</code> "unsafe"?<span><a class="mark" href="#buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe" id="buffer_what_makes_buffer_allocunsafe_and_buffer_allocunsafeslow_unsafe">#</a></span></h4>
 <p>When calling <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a> and <a href="#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow()</code></a>, the
 segment of allocated memory is <em>uninitialized</em> (it is not zeroed-out). While
 this design makes the allocation of memory quite fast, the allocated segment of
@@ -3158,10 +3370,46 @@ created by <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.
 memory can allow this old data to be leaked when the <code>Buffer</code> memory is read.</p>
 <p>While there are clear performance advantages to using
 <a href="#buffer_static_method_buffer_allocunsafe_size"><code>Buffer.allocUnsafe()</code></a>, extra care <em>must</em> be taken in order to avoid
-introducing security vulnerabilities into an application.</p>
+introducing security vulnerabilities into an application.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/buffer.json b/doc/api/buffer.json
index 0c2adcb2b41948e218394f3835cdfb4a34015a3e..876cb6e9806f53faeff621e5a7bfa0b95bbdc85a 100644
--- a/doc/api/buffer.json
+++ b/doc/api/buffer.json
@@ -8,13 +8,18 @@
       "introduced_in": "v0.1.90",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/buffer.js\">lib/buffer.js</a></p>\n<p><code>Buffer</code> objects are used to represent a fixed-length sequence of bytes. Many\nNode.js APIs support <code>Buffer</code>s.</p>\n<p>The <code>Buffer</code> class is a subclass of JavaScript's <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a> class and\nextends it with methods that cover additional use cases. Node.js APIs accept\nplain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>s wherever <code>Buffer</code>s are supported as well.</p>\n<p>The <code>Buffer</code> class is within the global scope, making it unlikely that one\nwould need to ever use <code>require('buffer').Buffer</code>.</p>\n<pre><code class=\"language-js\">// Creates a zero-filled Buffer of length 10.\nconst buf1 = Buffer.alloc(10);\n\n// Creates a Buffer of length 10,\n// filled with bytes which all have the value `1`.\nconst buf2 = Buffer.alloc(10, 1);\n\n// Creates an uninitialized buffer of length 10.\n// This is faster than calling Buffer.alloc() but the returned\n// Buffer instance might contain old data that needs to be\n// overwritten using fill(), write(), or other functions that fill the Buffer's\n// contents.\nconst buf3 = Buffer.allocUnsafe(10);\n\n// Creates a Buffer containing the bytes [1, 2, 3].\nconst buf4 = Buffer.from([1, 2, 3]);\n\n// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries\n// are all truncated using `(value &#x26; 255)` to fit into the range 0–255.\nconst buf5 = Buffer.from([257, 257.5, -255, '1']);\n\n// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':\n// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)\n// [116, 195, 169, 115, 116] (in decimal notation)\nconst buf6 = Buffer.from('tést');\n\n// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].\nconst buf7 = Buffer.from('tést', 'latin1');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/buffer.js\">lib/buffer.js</a></p>\n<p><code>Buffer</code> objects are used to represent a fixed-length sequence of bytes. Many\nNode.js APIs support <code>Buffer</code>s.</p>\n<p>The <code>Buffer</code> class is a subclass of JavaScript's <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a> class and\nextends it with methods that cover additional use cases. Node.js APIs accept\nplain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>s wherever <code>Buffer</code>s are supported as well.</p>\n<p>The <code>Buffer</code> class is within the global scope, making it unlikely that one\nwould need to ever use <code>require('buffer').Buffer</code>.</p>\n<pre><code class=\"language-js\">// Creates a zero-filled Buffer of length 10.\nconst buf1 = Buffer.alloc(10);\n\n// Creates a Buffer of length 10,\n// filled with bytes which all have the value `1`.\nconst buf2 = Buffer.alloc(10, 1);\n\n// Creates an uninitialized buffer of length 10.\n// This is faster than calling Buffer.alloc() but the returned\n// Buffer instance might contain old data that needs to be\n// overwritten using fill(), write(), or other functions that fill the Buffer's\n// contents.\nconst buf3 = Buffer.allocUnsafe(10);\n\n// Creates a Buffer containing the bytes [1, 2, 3].\nconst buf4 = Buffer.from([1, 2, 3]);\n\n// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries\n// are all truncated using `(value &#x26; 255)` to fit into the range 0–255.\nconst buf5 = Buffer.from([257, 257.5, -255, '1']);\n\n// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':\n// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)\n// [116, 195, 169, 115, 116] (in decimal notation)\nconst buf6 = Buffer.from('tést');\n\n// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].\nconst buf7 = Buffer.from('tést', 'latin1');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Buffers and character encodings",
           "name": "buffers_and_character_encodings",
           "meta": {
             "changes": [
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/36952",
+                "description": "Introduced `base64url` encoding."
+              },
               {
                 "version": "v6.4.0",
                 "pr-url": "https://github.com/nodejs/node/pull/7111",
@@ -27,7 +32,7 @@
               }
             ]
           },
-          "desc": "<p>When converting between <code>Buffer</code>s and strings, a character encoding may be\nspecified. If no character encoding is specified, UTF-8 will be used as the\ndefault.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('hello world', 'utf8');\n\nconsole.log(buf.toString('hex'));\n// Prints: 68656c6c6f20776f726c64\nconsole.log(buf.toString('base64'));\n// Prints: aGVsbG8gd29ybGQ=\n\nconsole.log(Buffer.from('fhqwhgads', 'utf8'));\n// Prints: &#x3C;Buffer 66 68 71 77 68 67 61 64 73>\nconsole.log(Buffer.from('fhqwhgads', 'utf16le'));\n// Prints: &#x3C;Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>\n</code></pre>\n<p>The character encodings currently supported by Node.js are the following:</p>\n<ul>\n<li>\n<p><code>'utf8'</code>: Multi-byte encoded Unicode characters. Many web pages and other\ndocument formats use <a href=\"https://en.wikipedia.org/wiki/UTF-8\">UTF-8</a>. This is the default character encoding.\nWhen decoding a <code>Buffer</code> into a string that does not exclusively contain\nvalid UTF-8 data, the Unicode replacement character <code>U+FFFD</code> � will be used\nto represent those errors.</p>\n</li>\n<li>\n<p><code>'utf16le'</code>: Multi-byte encoded Unicode characters. Unlike <code>'utf8'</code>, each\ncharacter in the string will be encoded using either 2 or 4 bytes.\nNode.js only supports the <a href=\"https://en.wikipedia.org/wiki/Endianness\">little-endian</a> variant of <a href=\"https://en.wikipedia.org/wiki/UTF-16\">UTF-16</a>.</p>\n</li>\n<li>\n<p><code>'latin1'</code>: Latin-1 stands for <a href=\"https://en.wikipedia.org/wiki/ISO-8859-1\">ISO-8859-1</a>. This character encoding only\nsupports the Unicode characters from <code>U+0000</code> to <code>U+00FF</code>. Each character is\nencoded using a single byte. Characters that do not fit into that range are\ntruncated and will be mapped to characters in that range.</p>\n</li>\n</ul>\n<p>Converting a <code>Buffer</code> into a string using one of the above is referred to as\ndecoding, and converting a string into a <code>Buffer</code> is referred to as encoding.</p>\n<p>Node.js also supports the following two binary-to-text encodings. For\nbinary-to-text encodings, the naming convention is reversed: Converting a\n<code>Buffer</code> into a string is typically referred to as encoding, and converting a\nstring into a <code>Buffer</code> as decoding.</p>\n<ul>\n<li>\n<p><code>'base64'</code>: <a href=\"https://en.wikipedia.org/wiki/Base64\">Base64</a> encoding. When creating a <code>Buffer</code> from a string,\nthis encoding will also correctly accept \"URL and Filename Safe Alphabet\" as\nspecified in <a href=\"https://tools.ietf.org/html/rfc4648#section-5\">RFC 4648, Section 5</a>. Whitespace characters such as spaces,\ntabs, and new lines contained within the base64-encoded string are ignored.</p>\n</li>\n<li>\n<p><code>'hex'</code>: Encode each byte as two hexadecimal characters. Data truncation\nmay occur when decoding strings that do exclusively contain valid hexadecimal\ncharacters. See below for an example.</p>\n</li>\n</ul>\n<p>The following legacy character encodings are also supported:</p>\n<ul>\n<li>\n<p><code>'ascii'</code>: For 7-bit <a href=\"https://en.wikipedia.org/wiki/ASCII\">ASCII</a> data only. When encoding a string into a\n<code>Buffer</code>, this is equivalent to using <code>'latin1'</code>. When decoding a <code>Buffer</code>\ninto a string, using this encoding will additionally unset the highest bit of\neach byte before decoding as <code>'latin1'</code>.\nGenerally, there should be no reason to use this encoding, as <code>'utf8'</code>\n(or, if the data is known to always be ASCII-only, <code>'latin1'</code>) will be a\nbetter choice when encoding or decoding ASCII-only text. It is only provided\nfor legacy compatibility.</p>\n</li>\n<li>\n<p><code>'binary'</code>: Alias for <code>'latin1'</code>. See <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary\">binary strings</a> for more background\non this topic. The name of this encoding can be very misleading, as all of the\nencodings listed here convert between strings and binary data. For converting\nbetween strings and <code>Buffer</code>s, typically <code>'utf-8'</code> is the right choice.</p>\n</li>\n<li>\n<p><code>'ucs2'</code>: Alias of <code>'utf16le'</code>. UCS-2 used to refer to a variant of UTF-16\nthat did not support characters that had code points larger than U+FFFF.\nIn Node.js, these code points are always supported.</p>\n</li>\n</ul>\n<pre><code class=\"language-js\">Buffer.from('1ag', 'hex');\n// Prints &#x3C;Buffer 1a>, data truncated when first non-hexadecimal value\n// ('g') encountered.\n\nBuffer.from('1a7g', 'hex');\n// Prints &#x3C;Buffer 1a>, data truncated when data ends in single digit ('7').\n\nBuffer.from('1634', 'hex');\n// Prints &#x3C;Buffer 16 34>, all data represented.\n</code></pre>\n<p>Modern Web browsers follow the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a> which aliases\nboth <code>'latin1'</code> and <code>'ISO-8859-1'</code> to <code>'win-1252'</code>. This means that while doing\nsomething like <code>http.get()</code>, if the returned charset is one of those listed in\nthe WHATWG specification it is possible that the server actually returned\n<code>'win-1252'</code>-encoded data, and using <code>'latin1'</code> encoding may incorrectly decode\nthe characters.</p>",
+          "desc": "<p>When converting between <code>Buffer</code>s and strings, a character encoding may be\nspecified. If no character encoding is specified, UTF-8 will be used as the\ndefault.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('hello world', 'utf8');\n\nconsole.log(buf.toString('hex'));\n// Prints: 68656c6c6f20776f726c64\nconsole.log(buf.toString('base64'));\n// Prints: aGVsbG8gd29ybGQ=\n\nconsole.log(Buffer.from('fhqwhgads', 'utf8'));\n// Prints: &#x3C;Buffer 66 68 71 77 68 67 61 64 73>\nconsole.log(Buffer.from('fhqwhgads', 'utf16le'));\n// Prints: &#x3C;Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>\n</code></pre>\n<p>The character encodings currently supported by Node.js are the following:</p>\n<ul>\n<li>\n<p><code>'utf8'</code>: Multi-byte encoded Unicode characters. Many web pages and other\ndocument formats use <a href=\"https://en.wikipedia.org/wiki/UTF-8\">UTF-8</a>. This is the default character encoding.\nWhen decoding a <code>Buffer</code> into a string that does not exclusively contain\nvalid UTF-8 data, the Unicode replacement character <code>U+FFFD</code> � will be used\nto represent those errors.</p>\n</li>\n<li>\n<p><code>'utf16le'</code>: Multi-byte encoded Unicode characters. Unlike <code>'utf8'</code>, each\ncharacter in the string will be encoded using either 2 or 4 bytes.\nNode.js only supports the <a href=\"https://en.wikipedia.org/wiki/Endianness\">little-endian</a> variant of <a href=\"https://en.wikipedia.org/wiki/UTF-16\">UTF-16</a>.</p>\n</li>\n<li>\n<p><code>'latin1'</code>: Latin-1 stands for <a href=\"https://en.wikipedia.org/wiki/ISO-8859-1\">ISO-8859-1</a>. This character encoding only\nsupports the Unicode characters from <code>U+0000</code> to <code>U+00FF</code>. Each character is\nencoded using a single byte. Characters that do not fit into that range are\ntruncated and will be mapped to characters in that range.</p>\n</li>\n</ul>\n<p>Converting a <code>Buffer</code> into a string using one of the above is referred to as\ndecoding, and converting a string into a <code>Buffer</code> is referred to as encoding.</p>\n<p>Node.js also supports the following binary-to-text encodings. For\nbinary-to-text encodings, the naming convention is reversed: Converting a\n<code>Buffer</code> into a string is typically referred to as encoding, and converting a\nstring into a <code>Buffer</code> as decoding.</p>\n<ul>\n<li>\n<p><code>'base64'</code>: <a href=\"https://en.wikipedia.org/wiki/Base64\">Base64</a> encoding. When creating a <code>Buffer</code> from a string,\nthis encoding will also correctly accept \"URL and Filename Safe Alphabet\" as\nspecified in <a href=\"https://tools.ietf.org/html/rfc4648#section-5\">RFC 4648, Section 5</a>. Whitespace characters such as spaces,\ntabs, and new lines contained within the base64-encoded string are ignored.</p>\n</li>\n<li>\n<p><code>'base64url'</code>: <a href=\"https://tools.ietf.org/html/rfc4648#section-5\">base64url</a> encoding as specified in\n<a href=\"https://tools.ietf.org/html/rfc4648#section-5\">RFC 4648, Section 5</a>. When creating a <code>Buffer</code> from a string, this\nencoding will also correctly accept regular base64-encoded strings. When\nencoding a <code>Buffer</code> to a string, this encoding will omit padding.</p>\n</li>\n<li>\n<p><code>'hex'</code>: Encode each byte as two hexadecimal characters. Data truncation\nmay occur when decoding strings that do exclusively contain valid hexadecimal\ncharacters. See below for an example.</p>\n</li>\n</ul>\n<p>The following legacy character encodings are also supported:</p>\n<ul>\n<li>\n<p><code>'ascii'</code>: For 7-bit <a href=\"https://en.wikipedia.org/wiki/ASCII\">ASCII</a> data only. When encoding a string into a\n<code>Buffer</code>, this is equivalent to using <code>'latin1'</code>. When decoding a <code>Buffer</code>\ninto a string, using this encoding will additionally unset the highest bit of\neach byte before decoding as <code>'latin1'</code>.\nGenerally, there should be no reason to use this encoding, as <code>'utf8'</code>\n(or, if the data is known to always be ASCII-only, <code>'latin1'</code>) will be a\nbetter choice when encoding or decoding ASCII-only text. It is only provided\nfor legacy compatibility.</p>\n</li>\n<li>\n<p><code>'binary'</code>: Alias for <code>'latin1'</code>. See <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary\">binary strings</a> for more background\non this topic. The name of this encoding can be very misleading, as all of the\nencodings listed here convert between strings and binary data. For converting\nbetween strings and <code>Buffer</code>s, typically <code>'utf-8'</code> is the right choice.</p>\n</li>\n<li>\n<p><code>'ucs2'</code>: Alias of <code>'utf16le'</code>. UCS-2 used to refer to a variant of UTF-16\nthat did not support characters that had code points larger than U+FFFF.\nIn Node.js, these code points are always supported.</p>\n</li>\n</ul>\n<pre><code class=\"language-js\">Buffer.from('1ag', 'hex');\n// Prints &#x3C;Buffer 1a>, data truncated when first non-hexadecimal value\n// ('g') encountered.\n\nBuffer.from('1a7g', 'hex');\n// Prints &#x3C;Buffer 1a>, data truncated when data ends in single digit ('7').\n\nBuffer.from('1634', 'hex');\n// Prints &#x3C;Buffer 16 34>, all data represented.\n</code></pre>\n<p>Modern Web browsers follow the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a> which aliases\nboth <code>'latin1'</code> and <code>'ISO-8859-1'</code> to <code>'win-1252'</code>. This means that while doing\nsomething like <code>http.get()</code>, if the returned charset is one of those listed in\nthe WHATWG specification it is possible that the server actually returned\n<code>'win-1252'</code>-encoded data, and using <code>'latin1'</code> encoding may incorrectly decode\nthe characters.</p>",
           "type": "module",
           "displayName": "Buffers and character encodings"
         },
@@ -43,7 +48,7 @@
               }
             ]
           },
-          "desc": "<p><code>Buffer</code> instances are also JavaScript <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>\ninstances. All <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> methods are available on <code>Buffer</code>s. There are,\nhowever, subtle incompatibilities between the <code>Buffer</code> API and the\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> API.</p>\n<p>In particular:</p>\n<ul>\n<li>While <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice\"><code>TypedArray#slice()</code></a> creates a copy of part of the <code>TypedArray</code>,\n<a href=\"#buffer_buf_slice_start_end\"><code>Buffer#slice()</code></a> creates a view over the existing <code>Buffer</code>\nwithout copying. This behavior can be surprising, and only exists for legacy\ncompatibility. <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\"><code>TypedArray#subarray()</code></a> can be used to achieve the behavior\nof <a href=\"#buffer_buf_slice_start_end\"><code>Buffer#slice()</code></a> on both <code>Buffer</code>s and other\n<code>TypedArray</code>s.</li>\n<li><a href=\"#buffer_buf_tostring_encoding_start_end\"><code>buf.toString()</code></a> is incompatible with its <code>TypedArray</code> equivalent.</li>\n<li>A number of methods, e.g. <a href=\"#buffer_buf_indexof_value_byteoffset_encoding\"><code>buf.indexOf()</code></a>, support additional arguments.</li>\n</ul>\n<p>There are two ways to create new <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instances from a <code>Buffer</code>:</p>\n<ul>\n<li>Passing a <code>Buffer</code> to a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> constructor will copy the <code>Buffer</code>s\ncontents, interpreted as an array of integers, and not as a byte sequence\nof the target type.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from([1, 2, 3, 4]);\nconst uint32array = new Uint32Array(buf);\n\nconsole.log(uint32array);\n\n// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]\n</code></pre>\n<ul>\n<li>Passing the <code>Buffer</code>s underlying <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> will create a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> that shares its memory with the <code>Buffer</code>.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from('hello', 'utf16le');\nconst uint16arr = new Uint16Array(\n  buf.buffer,\n  buf.byteOffset,\n  buf.length / Uint16Array.BYTES_PER_ELEMENT);\n\nconsole.log(uint16array);\n\n// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]\n</code></pre>\n<p>It is possible to create a new <code>Buffer</code> that shares the same allocated\nmemory as a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instance by using the <code>TypedArray</code> object’s\n<code>.buffer</code> property in the same way. <a href=\"#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from()</code></a>\nbehaves like <code>new Uint8Array()</code> in this context.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(2);\n\narr[0] = 5000;\narr[1] = 4000;\n\n// Copies the contents of `arr`.\nconst buf1 = Buffer.from(arr);\n\n// Shares memory with `arr`.\nconst buf2 = Buffer.from(arr.buffer);\n\nconsole.log(buf1);\n// Prints: &#x3C;Buffer 88 a0>\nconsole.log(buf2);\n// Prints: &#x3C;Buffer 88 13 a0 0f>\n\narr[1] = 6000;\n\nconsole.log(buf1);\n// Prints: &#x3C;Buffer 88 a0>\nconsole.log(buf2);\n// Prints: &#x3C;Buffer 88 13 70 17>\n</code></pre>\n<p>When creating a <code>Buffer</code> using a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>'s <code>.buffer</code>, it is\npossible to use only a portion of the underlying <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> by passing in\n<code>byteOffset</code> and <code>length</code> parameters.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(20);\nconst buf = Buffer.from(arr.buffer, 0, 16);\n\nconsole.log(buf.length);\n// Prints: 16\n</code></pre>\n<p>The <code>Buffer.from()</code> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from\"><code>TypedArray.from()</code></a> have different signatures and\nimplementations. Specifically, the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> variants accept a second\nargument that is a mapping function that is invoked on every element of the\ntyped array:</p>\n<ul>\n<li><code>TypedArray.from(source[, mapFn[, thisArg]])</code></li>\n</ul>\n<p>The <code>Buffer.from()</code> method, however, does not support the use of a mapping\nfunction:</p>\n<ul>\n<li><a href=\"#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a></li>\n<li><a href=\"#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a></li>\n<li><a href=\"#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a></li>\n<li><a href=\"#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a></li>\n</ul>",
+          "desc": "<p><code>Buffer</code> instances are also JavaScript <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>\ninstances. All <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> methods are available on <code>Buffer</code>s. There are,\nhowever, subtle incompatibilities between the <code>Buffer</code> API and the\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> API.</p>\n<p>In particular:</p>\n<ul>\n<li>While <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice\"><code>TypedArray.prototype.slice()</code></a> creates a copy of part of the <code>TypedArray</code>,\n<a href=\"#buffer_buf_slice_start_end\"><code>Buffer.prototype.slice()</code></a> creates a view over the existing <code>Buffer</code>\nwithout copying. This behavior can be surprising, and only exists for legacy\ncompatibility. <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\"><code>TypedArray.prototype.subarray()</code></a> can be used to achieve\nthe behavior of <a href=\"#buffer_buf_slice_start_end\"><code>Buffer.prototype.slice()</code></a> on both <code>Buffer</code>s\nand other <code>TypedArray</code>s.</li>\n<li><a href=\"#buffer_buf_tostring_encoding_start_end\"><code>buf.toString()</code></a> is incompatible with its <code>TypedArray</code> equivalent.</li>\n<li>A number of methods, e.g. <a href=\"#buffer_buf_indexof_value_byteoffset_encoding\"><code>buf.indexOf()</code></a>, support additional arguments.</li>\n</ul>\n<p>There are two ways to create new <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instances from a <code>Buffer</code>:</p>\n<ul>\n<li>Passing a <code>Buffer</code> to a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> constructor will copy the <code>Buffer</code>s\ncontents, interpreted as an array of integers, and not as a byte sequence\nof the target type.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from([1, 2, 3, 4]);\nconst uint32array = new Uint32Array(buf);\n\nconsole.log(uint32array);\n\n// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]\n</code></pre>\n<ul>\n<li>Passing the <code>Buffer</code>s underlying <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> will create a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> that shares its memory with the <code>Buffer</code>.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from('hello', 'utf16le');\nconst uint16array = new Uint16Array(\n  buf.buffer,\n  buf.byteOffset,\n  buf.length / Uint16Array.BYTES_PER_ELEMENT);\n\nconsole.log(uint16array);\n\n// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]\n</code></pre>\n<p>It is possible to create a new <code>Buffer</code> that shares the same allocated\nmemory as a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instance by using the <code>TypedArray</code> object’s\n<code>.buffer</code> property in the same way. <a href=\"#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from()</code></a>\nbehaves like <code>new Uint8Array()</code> in this context.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(2);\n\narr[0] = 5000;\narr[1] = 4000;\n\n// Copies the contents of `arr`.\nconst buf1 = Buffer.from(arr);\n\n// Shares memory with `arr`.\nconst buf2 = Buffer.from(arr.buffer);\n\nconsole.log(buf1);\n// Prints: &#x3C;Buffer 88 a0>\nconsole.log(buf2);\n// Prints: &#x3C;Buffer 88 13 a0 0f>\n\narr[1] = 6000;\n\nconsole.log(buf1);\n// Prints: &#x3C;Buffer 88 a0>\nconsole.log(buf2);\n// Prints: &#x3C;Buffer 88 13 70 17>\n</code></pre>\n<p>When creating a <code>Buffer</code> using a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>'s <code>.buffer</code>, it is\npossible to use only a portion of the underlying <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> by passing in\n<code>byteOffset</code> and <code>length</code> parameters.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(20);\nconst buf = Buffer.from(arr.buffer, 0, 16);\n\nconsole.log(buf.length);\n// Prints: 16\n</code></pre>\n<p>The <code>Buffer.from()</code> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from\"><code>TypedArray.from()</code></a> have different signatures and\nimplementations. Specifically, the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> variants accept a second\nargument that is a mapping function that is invoked on every element of the\ntyped array:</p>\n<ul>\n<li><code>TypedArray.from(source[, mapFn[, thisArg]])</code></li>\n</ul>\n<p>The <code>Buffer.from()</code> method, however, does not support the use of a mapping\nfunction:</p>\n<ul>\n<li><a href=\"#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a></li>\n<li><a href=\"#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a></li>\n<li><a href=\"#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a></li>\n<li><a href=\"#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a></li>\n</ul>",
           "type": "module",
           "displayName": "Buffers and TypedArrays"
         },
@@ -58,35 +63,55 @@
           "textRaw": "`buffer` module APIs",
           "name": "`buffer`_module_apis",
           "desc": "<p>While, the <code>Buffer</code> object is available as a global, there are additional\n<code>Buffer</code>-related APIs that are available only via the <code>buffer</code> module\naccessed using <code>require('buffer')</code>.</p>",
-          "properties": [
+          "methods": [
             {
-              "textRaw": "`INSPECT_MAX_BYTES` {integer} **Default:** `50`",
-              "type": "integer",
-              "name": "INSPECT_MAX_BYTES",
+              "textRaw": "`buffer.atob(data)`",
+              "type": "method",
+              "name": "atob",
               "meta": {
                 "added": [
-                  "v0.5.4"
+                  "v14.17.0"
                 ],
                 "changes": []
               },
-              "default": "`50`",
-              "desc": "<p>Returns the maximum number of bytes that will be returned when\n<code>buf.inspect()</code> is called. This can be overridden by user modules. See\n<a href=\"util.html#util_util_inspect_object_options\"><code>util.inspect()</code></a> for more details on <code>buf.inspect()</code> behavior.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`data` {any} The Base64-encoded input string.",
+                      "name": "data",
+                      "type": "any",
+                      "desc": "The Base64-encoded input string."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Decodes a string of Base64-encoded data into bytes, and encodes those bytes\ninto a string using Latin-1 (ISO-8859-1).</p>\n<p>The <code>data</code> may be any JavaScript-value that can be coerced into a string.</p>\n<p><strong>This function is only provided for compatibility with legacy web platform APIs\nand should never be used in new code, because they use strings to represent\nbinary data and predate the introduction of typed arrays in JavaScript.\nFor code running using Node.js APIs, converting between base64-encoded strings\nand binary data should be performed using <code>Buffer.from(str, 'base64')</code> and\n<code>buf.toString('base64')</code>.</strong></p>"
             },
             {
-              "textRaw": "`kMaxLength` {integer} The largest size allowed for a single `Buffer` instance.",
-              "type": "integer",
-              "name": "kMaxLength",
+              "textRaw": "`buffer.btoa(data)`",
+              "type": "method",
+              "name": "btoa",
               "meta": {
                 "added": [
-                  "v3.0.0"
+                  "v14.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>An alias for <a href=\"#buffer_buffer_constants_max_length\"><code>buffer.constants.MAX_LENGTH</code></a>.</p>",
-              "shortDesc": "The largest size allowed for a single `Buffer` instance."
-            }
-          ],
-          "methods": [
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`data` {any} An ASCII (Latin1) string.",
+                      "name": "data",
+                      "type": "any",
+                      "desc": "An ASCII (Latin1) string."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes\ninto a string using Base64.</p>\n<p>The <code>data</code> may be any JavaScript-value that can be coerced into a string.</p>\n<p><strong>This function is only provided for compatibility with legacy web platform APIs\nand should never be used in new code, because they use strings to represent\nbinary data and predate the introduction of typed arrays in JavaScript.\nFor code running using Node.js APIs, converting between base64-encoded strings\nand binary data should be performed using <code>Buffer.from(str, 'base64')</code> and\n<code>buf.toString('base64')</code>.</strong></p>"
+            },
             {
               "textRaw": "`buffer.transcode(source, fromEnc, toEnc)`",
               "type": "method",
@@ -135,6 +160,47 @@
               "desc": "<p>Re-encodes the given <code>Buffer</code> or <code>Uint8Array</code> instance from one character\nencoding to another. Returns a new <code>Buffer</code> instance.</p>\n<p>Throws if the <code>fromEnc</code> or <code>toEnc</code> specify invalid character encodings or if\nconversion from <code>fromEnc</code> to <code>toEnc</code> is not permitted.</p>\n<p>Encodings supported by <code>buffer.transcode()</code> are: <code>'ascii'</code>, <code>'utf8'</code>,\n<code>'utf16le'</code>, <code>'ucs2'</code>, <code>'latin1'</code>, and <code>'binary'</code>.</p>\n<p>The transcoding process will use substitution characters if a given byte\nsequence cannot be adequately represented in the target encoding. For instance:</p>\n<pre><code class=\"language-js\">const buffer = require('buffer');\n\nconst newBuf = buffer.transcode(Buffer.from('€'), 'utf8', 'ascii');\nconsole.log(newBuf.toString('ascii'));\n// Prints: '?'\n</code></pre>\n<p>Because the Euro (<code>€</code>) sign is not representable in US-ASCII, it is replaced\nwith <code>?</code> in the transcoded <code>Buffer</code>.</p>"
             }
           ],
+          "properties": [
+            {
+              "textRaw": "`INSPECT_MAX_BYTES` {integer} **Default:** `50`",
+              "type": "integer",
+              "name": "INSPECT_MAX_BYTES",
+              "meta": {
+                "added": [
+                  "v0.5.4"
+                ],
+                "changes": []
+              },
+              "default": "`50`",
+              "desc": "<p>Returns the maximum number of bytes that will be returned when\n<code>buf.inspect()</code> is called. This can be overridden by user modules. See\n<a href=\"util.html#util_util_inspect_object_options\"><code>util.inspect()</code></a> for more details on <code>buf.inspect()</code> behavior.</p>"
+            },
+            {
+              "textRaw": "`kMaxLength` {integer} The largest size allowed for a single `Buffer` instance.",
+              "type": "integer",
+              "name": "kMaxLength",
+              "meta": {
+                "added": [
+                  "v3.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An alias for <a href=\"#buffer_buffer_constants_max_length\"><code>buffer.constants.MAX_LENGTH</code></a>.</p>",
+              "shortDesc": "The largest size allowed for a single `Buffer` instance."
+            },
+            {
+              "textRaw": "`kStringMaxLength` {integer} The largest length allowed for a single `string` instance.",
+              "type": "integer",
+              "name": "kStringMaxLength",
+              "meta": {
+                "added": [
+                  "v3.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An alias for <a href=\"#buffer_buffer_constants_max_string_length\"><code>buffer.constants.MAX_STRING_LENGTH</code></a>.</p>",
+              "shortDesc": "The largest length allowed for a single `string` instance."
+            }
+          ],
           "classes": [
             {
               "textRaw": "Class: `SlowBuffer`",
@@ -183,9 +249,15 @@
                     "added": [
                       "v8.2.0"
                     ],
-                    "changes": []
-                  },
-                  "desc": "<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).\nOn 64-bit architectures, this value currently is 2<sup>31</sup> - 1 (~2GB).</p>\n<p>This value is also available as <a href=\"#buffer_buffer_kmaxlength\"><code>buffer.kMaxLength</code></a>.</p>",
+                    "changes": [
+                      {
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/32116",
+                        "description": "Value is changed from 2<sup>31</sup> - 1 to 2<sup>32</sup> - 1 on 64-bit architectures."
+                      }
+                    ]
+                  },
+                  "desc": "<p>On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).</p>\n<p>On 64-bit architectures, this value currently is 2<sup>32</sup> - 1 (~4GB).</p>\n<p>It reflects <a href=\"https://v8.github.io/api/head/classv8_1_1TypedArray.html#a54a48f4373da0850663c4393d843b9b0\"><code>v8::TypedArray::kMaxLength</code></a> under the hood.</p>\n<p>This value is also available as <a href=\"#buffer_buffer_kmaxlength\"><code>buffer.kMaxLength</code></a>.</p>",
                   "shortDesc": "The largest size allowed for a single `Buffer` instance."
                 },
                 {
@@ -215,17 +287,17 @@
           "desc": "<p>In versions of Node.js prior to 6.0.0, <code>Buffer</code> instances were created using the\n<code>Buffer</code> constructor function, which allocates the returned <code>Buffer</code>\ndifferently based on what arguments are provided:</p>\n<ul>\n<li>Passing a number as the first argument to <code>Buffer()</code> (e.g. <code>new Buffer(10)</code>)\nallocates a new <code>Buffer</code> object of the specified size. Prior to Node.js 8.0.0,\nthe memory allocated for such <code>Buffer</code> instances is <em>not</em> initialized and\n<em>can contain sensitive data</em>. Such <code>Buffer</code> instances <em>must</em> be subsequently\ninitialized by using either <a href=\"#buffer_buf_fill_value_offset_end_encoding\"><code>buf.fill(0)</code></a> or by writing to the\nentire <code>Buffer</code> before reading data from the <code>Buffer</code>.\nWhile this behavior is <em>intentional</em> to improve performance,\ndevelopment experience has demonstrated that a more explicit distinction is\nrequired between creating a fast-but-uninitialized <code>Buffer</code> versus creating a\nslower-but-safer <code>Buffer</code>. Since Node.js 8.0.0, <code>Buffer(num)</code> and <code>new Buffer(num)</code> return a <code>Buffer</code> with initialized memory.</li>\n<li>Passing a string, array, or <code>Buffer</code> as the first argument copies the\npassed object's data into the <code>Buffer</code>.</li>\n<li>Passing an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> or a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> returns a <code>Buffer</code>\nthat shares allocated memory with the given array buffer.</li>\n</ul>\n<p>Because the behavior of <code>new Buffer()</code> is different depending on the type of the\nfirst argument, security and reliability issues can be inadvertently introduced\ninto applications when argument validation or <code>Buffer</code> initialization is not\nperformed.</p>\n<p>For example, if an attacker can cause an application to receive a number where\na string is expected, the application may call <code>new Buffer(100)</code>\ninstead of <code>new Buffer(\"100\")</code>, leading it to allocate a 100 byte buffer instead\nof allocating a 3 byte buffer with content <code>\"100\"</code>. This is commonly possible\nusing JSON API calls. Since JSON distinguishes between numeric and string types,\nit allows injection of numbers where a naively written application that does not\nvalidate its input sufficiently might expect to always receive a string.\nBefore Node.js 8.0.0, the 100 byte buffer might contain\narbitrary pre-existing in-memory data, so may be used to expose in-memory\nsecrets to a remote attacker. Since Node.js 8.0.0, exposure of memory cannot\noccur because the data is zero-filled. However, other attacks are still\npossible, such as causing very large buffers to be allocated by the server,\nleading to performance degradation or crashing on memory exhaustion.</p>\n<p>To make the creation of <code>Buffer</code> instances more reliable and less error-prone,\nthe various forms of the <code>new Buffer()</code> constructor have been <strong>deprecated</strong>\nand replaced by separate <code>Buffer.from()</code>, <a href=\"#buffer_static_method_buffer_alloc_size_fill_encoding\"><code>Buffer.alloc()</code></a>, and\n<a href=\"#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe()</code></a> methods.</p>\n<p><em>Developers should migrate all existing uses of the <code>new Buffer()</code> constructors\nto one of these new APIs.</em></p>\n<ul>\n<li><a href=\"#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a> returns a new <code>Buffer</code> that <em>contains a copy</em> of the\nprovided octets.</li>\n<li><a href=\"#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a>\nreturns a new <code>Buffer</code> that <em>shares the same allocated memory</em> as the given\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>.</li>\n<li><a href=\"#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a> returns a new <code>Buffer</code> that <em>contains a copy</em> of the\ncontents of the given <code>Buffer</code>.</li>\n<li><a href=\"#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a> returns a new\n<code>Buffer</code> that <em>contains a copy</em> of the provided string.</li>\n<li><a href=\"#buffer_static_method_buffer_alloc_size_fill_encoding\"><code>Buffer.alloc(size[, fill[, encoding]])</code></a> returns a new\ninitialized <code>Buffer</code> of the specified size. This method is slower than\n<a href=\"#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe(size)</code></a> but guarantees that newly\ncreated <code>Buffer</code> instances never contain old data that is potentially\nsensitive. A <code>TypeError</code> will be thrown if <code>size</code> is not a number.</li>\n<li><a href=\"#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe(size)</code></a> and\n<a href=\"#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a> each return a\nnew uninitialized <code>Buffer</code> of the specified <code>size</code>. Because the <code>Buffer</code> is\nuninitialized, the allocated segment of memory might contain old data that is\npotentially sensitive.</li>\n</ul>\n<p><code>Buffer</code> instances returned by <a href=\"#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe()</code></a> and\n<a href=\"#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a> <em>may</em> be allocated off a shared internal memory pool\nif <code>size</code> is less than or equal to half <a href=\"#buffer_class_property_buffer_poolsize\"><code>Buffer.poolSize</code></a>. Instances\nreturned by <a href=\"#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow()</code></a> <em>never</em> use the shared internal\nmemory pool.</p>",
           "modules": [
             {
-              "textRaw": "The `--zero-fill-buffers` command line option",
-              "name": "the_`--zero-fill-buffers`_command_line_option",
+              "textRaw": "The `--zero-fill-buffers` command-line option",
+              "name": "the_`--zero-fill-buffers`_command-line_option",
               "meta": {
                 "added": [
                   "v5.10.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>Node.js can be started using the <code>--zero-fill-buffers</code> command line option to\ncause all newly-allocated <code>Buffer</code> instances to be zero-filled upon creation by\ndefault. Without the option, buffers created with <a href=\"#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe()</code></a>,\n<a href=\"#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow()</code></a>, and <code>new SlowBuffer(size)</code> are not zero-filled.\nUse of this flag can have a measurable negative impact on performance. Use the\n<code>--zero-fill-buffers</code> option only when necessary to enforce that newly allocated\n<code>Buffer</code> instances cannot contain old data that is potentially sensitive.</p>\n<pre><code class=\"language-console\">$ node --zero-fill-buffers\n> Buffer.allocUnsafe(5);\n&#x3C;Buffer 00 00 00 00 00>\n</code></pre>",
+              "desc": "<p>Node.js can be started using the <code>--zero-fill-buffers</code> command-line option to\ncause all newly-allocated <code>Buffer</code> instances to be zero-filled upon creation by\ndefault. Without the option, buffers created with <a href=\"#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe()</code></a>,\n<a href=\"#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow()</code></a>, and <code>new SlowBuffer(size)</code> are not zero-filled.\nUse of this flag can have a measurable negative impact on performance. Use the\n<code>--zero-fill-buffers</code> option only when necessary to enforce that newly allocated\n<code>Buffer</code> instances cannot contain old data that is potentially sensitive.</p>\n<pre><code class=\"language-console\">$ node --zero-fill-buffers\n> Buffer.allocUnsafe(5);\n&#x3C;Buffer 00 00 00 00 00>\n</code></pre>",
               "type": "module",
-              "displayName": "The `--zero-fill-buffers` command line option"
+              "displayName": "The `--zero-fill-buffers` command-line option"
             },
             {
               "textRaw": "What makes `Buffer.allocUnsafe()` and `Buffer.allocUnsafeSlow()` \"unsafe\"?",
@@ -240,6 +312,168 @@
         }
       ],
       "classes": [
+        {
+          "textRaw": "Class: `Blob`",
+          "type": "class",
+          "name": "Blob",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>A <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Blob\"><code>Blob</code></a> encapsulates immutable, raw data that can be safely shared across\nmultiple worker threads.</p>",
+          "methods": [
+            {
+              "textRaw": "`blob.arrayBuffer()`",
+              "type": "method",
+              "name": "arrayBuffer",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Promise}",
+                    "name": "return",
+                    "type": "Promise"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns a promise that fulfills with an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\" class=\"type\">&lt;ArrayBuffer&gt;</a> containing a copy of\nthe <code>Blob</code> data.</p>"
+            },
+            {
+              "textRaw": "`blob.slice([start, [end, [type]]])`",
+              "type": "method",
+              "name": "slice",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`start` {number} The starting index.",
+                      "name": "start",
+                      "type": "number",
+                      "desc": "The starting index."
+                    },
+                    {
+                      "textRaw": "`end` {number} The ending index.",
+                      "name": "end",
+                      "type": "number",
+                      "desc": "The ending index."
+                    },
+                    {
+                      "textRaw": "`type` {string} The content-type for the new `Blob`",
+                      "name": "type",
+                      "type": "string",
+                      "desc": "The content-type for the new `Blob`"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Creates and returns a new <code>Blob</code> containing a subset of this <code>Blob</code> objects\ndata. The original <code>Blob</code> is not alterered.</p>"
+            },
+            {
+              "textRaw": "`blob.text()`",
+              "type": "method",
+              "name": "text",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Promise}",
+                    "name": "return",
+                    "type": "Promise"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns a promise that resolves the contents of the <code>Blob</code> decoded as a UTF-8\nstring.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`blob.size`",
+              "name": "size",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The total size of the <code>Blob</code> in bytes.</p>"
+            },
+            {
+              "textRaw": "`type` Type: {string}",
+              "type": "string",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The content-type of the <code>Blob</code>.</p>"
+            }
+          ],
+          "modules": [
+            {
+              "textRaw": "`Blob` objects and `MessageChannel`",
+              "name": "`blob`_objects_and_`messagechannel`",
+              "desc": "<p>Once a <a href=\"buffer.html#buffer_class_blob\" class=\"type\">&lt;Blob&gt;</a> object is created, it can be sent via <code>MessagePort</code> to multiple\ndestinations without transfering or immediately copying the data. The data\ncontained by the <code>Blob</code> is copied only when the <code>arrayBuffer()</code> or <code>text()</code>\nmethods are called.</p>\n<pre><code class=\"language-js\">const { Blob } = require('buffer');\nconst blob = new Blob(['hello there']);\nconst { setTimeout: delay } = require('timers/promises');\n\nconst mc1 = new MessageChannel();\nconst mc2 = new MessageChannel();\n\nmc1.port1.onmessage = async ({ data }) => {\n  console.log(await data.arrayBuffer());\n  mc1.port1.close();\n};\n\nmc2.port1.onmessage = async ({ data }) => {\n  await delay(1000);\n  console.log(await data.arrayBuffer());\n  mc2.port1.close();\n};\n\nmc1.port2.postMessage(blob);\nmc2.port2.postMessage(blob);\n\n// The Blob is still usable after posting.\ndata.text().then(console.log);\n</code></pre>",
+              "type": "module",
+              "displayName": "`Blob` objects and `MessageChannel`"
+            }
+          ],
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`sources` {string[]|ArrayBuffer[]|TypedArray[]|DataView[]|Blob[]} An array of string, {ArrayBuffer}, {TypedArray}, {DataView}, or {Blob} objects, or any mix of such objects, that will be stored within the `Blob`.",
+                  "name": "sources",
+                  "type": "string[]|ArrayBuffer[]|TypedArray[]|DataView[]|Blob[]",
+                  "desc": "An array of string, {ArrayBuffer}, {TypedArray}, {DataView}, or {Blob} objects, or any mix of such objects, that will be stored within the `Blob`."
+                },
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`encoding` {string} The character encoding to use for string sources. **Default**: `'utf8'`.",
+                      "name": "encoding",
+                      "type": "string",
+                      "desc": "The character encoding to use for string sources. **Default**: `'utf8'`."
+                    },
+                    {
+                      "textRaw": "`type` {string} The Blob content-type. The intent is for `type` to convey the MIME media type of the data, however no validation of the type format is performed.",
+                      "name": "type",
+                      "type": "string",
+                      "desc": "The Blob content-type. The intent is for `type` to convey the MIME media type of the data, however no validation of the type format is performed."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Creates a new <code>Blob</code> object containing a concatenation of the given sources.</p>\n<p><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\" class=\"type\">&lt;ArrayBuffer&gt;</a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\" class=\"type\">&lt;TypedArray&gt;</a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\" class=\"type\">&lt;DataView&gt;</a>, and <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> sources are copied into\nthe 'Blob' and can therefore be safely modified after the 'Blob' is created.</p>\n<p>String sources are also copied into the <code>Blob</code>.</p>"
+            }
+          ]
+        },
         {
           "textRaw": "Class: `Buffer`",
           "type": "class",
@@ -400,7 +634,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns the byte length of a string when encoded using <code>encoding</code>.\nThis is not the same as <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length\"><code>String.prototype.length</code></a>, which does not account\nfor the encoding that is used to convert the string into bytes.</p>\n<p>For <code>'base64'</code> and <code>'hex'</code>, this function assumes valid input. For strings that\ncontain non-base64/hex-encoded data (e.g. whitespace), the return value might be\ngreater than the length of a <code>Buffer</code> created from the string.</p>\n<pre><code class=\"language-js\">const str = '\\u00bd + \\u00bc = \\u00be';\n\nconsole.log(`${str}: ${str.length} characters, ` +\n            `${Buffer.byteLength(str, 'utf8')} bytes`);\n// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes\n</code></pre>\n<p>When <code>string</code> is a <code>Buffer</code>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\"><code>DataView</code></a>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>/\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a>, the byte length as reported by <code>.byteLength</code>\nis returned.</p>"
+              "desc": "<p>Returns the byte length of a string when encoded using <code>encoding</code>.\nThis is not the same as <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length\"><code>String.prototype.length</code></a>, which does not account\nfor the encoding that is used to convert the string into bytes.</p>\n<p>For <code>'base64'</code>, <code>'base64url'</code>, and <code>'hex'</code>, this function assumes valid input.\nFor strings that contain non-base64/hex-encoded data (e.g. whitespace), the\nreturn value might be greater than the length of a <code>Buffer</code> created from the\nstring.</p>\n<pre><code class=\"language-js\">const str = '\\u00bd + \\u00bc = \\u00be';\n\nconsole.log(`${str}: ${str.length} characters, ` +\n            `${Buffer.byteLength(str, 'utf8')} bytes`);\n// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes\n</code></pre>\n<p>When <code>string</code> is a <code>Buffer</code>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\"><code>DataView</code></a>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>/<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>/\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a>, the byte length as reported by <code>.byteLength</code>\nis returned.</p>"
             },
             {
               "textRaw": "Static method: `Buffer.compare(buf1, buf2)`",
@@ -542,7 +776,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This creates a view of the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> without copying the underlying\nmemory. For example, when passed a reference to the <code>.buffer</code> property of a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instance, the newly created <code>Buffer</code> will share the same\nallocated memory as the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(2);\n\narr[0] = 5000;\narr[1] = 4000;\n\n// Shares memory with `arr`.\nconst buf = Buffer.from(arr.buffer);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 88 13 a0 0f>\n\n// Changing the original Uint16Array changes the Buffer also.\narr[1] = 6000;\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 88 13 70 17>\n</code></pre>\n<p>The optional <code>byteOffset</code> and <code>length</code> arguments specify a memory range within\nthe <code>arrayBuffer</code> that will be shared by the <code>Buffer</code>.</p>\n<pre><code class=\"language-js\">const ab = new ArrayBuffer(10);\nconst buf = Buffer.from(ab, 0, 2);\n\nconsole.log(buf.length);\n// Prints: 2\n</code></pre>\n<p>A <code>TypeError</code> will be thrown if <code>arrayBuffer</code> is not an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> or a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> or another type appropriate for <code>Buffer.from()</code>\nvariants.</p>"
+              "desc": "<p>This creates a view of the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> without copying the underlying\nmemory. For example, when passed a reference to the <code>.buffer</code> property of a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> instance, the newly created <code>Buffer</code> will share the same\nallocated memory as the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a>'s underlying <code>ArrayBuffer</code>.</p>\n<pre><code class=\"language-js\">const arr = new Uint16Array(2);\n\narr[0] = 5000;\narr[1] = 4000;\n\n// Shares memory with `arr`.\nconst buf = Buffer.from(arr.buffer);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 88 13 a0 0f>\n\n// Changing the original Uint16Array changes the Buffer also.\narr[1] = 6000;\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 88 13 70 17>\n</code></pre>\n<p>The optional <code>byteOffset</code> and <code>length</code> arguments specify a memory range within\nthe <code>arrayBuffer</code> that will be shared by the <code>Buffer</code>.</p>\n<pre><code class=\"language-js\">const ab = new ArrayBuffer(10);\nconst buf = Buffer.from(ab, 0, 2);\n\nconsole.log(buf.length);\n// Prints: 2\n</code></pre>\n<p>A <code>TypeError</code> will be thrown if <code>arrayBuffer</code> is not an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> or a\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> or another type appropriate for <code>Buffer.from()</code>\nvariants.</p>\n<p>It is important to remember that a backing <code>ArrayBuffer</code> can cover a range\nof memory that extends beyond the bounds of a <code>TypedArray</code> view. A new\n<code>Buffer</code> created using the <code>buffer</code> property of a <code>TypedArray</code> may extend\nbeyond the range of the <code>TypedArray</code>:</p>\n<pre><code class=\"language-js\">const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements\nconst arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements\nconsole.log(arrA.buffer === arrB.buffer); // true\n\nconst buf = Buffer.from(arrB.buffer);\nconsole.log(buf);\n// Prints: &#x3C;Buffer 63 64 65 66>\n</code></pre>"
             },
             {
               "textRaw": "Static method: `Buffer.from(buffer)`",
@@ -661,7 +895,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if <code>obj</code> is a <code>Buffer</code>, <code>false</code> otherwise.</p>"
+              "desc": "<p>Returns <code>true</code> if <code>obj</code> is a <code>Buffer</code>, <code>false</code> otherwise.</p>\n<pre><code class=\"language-js\">Buffer.isBuffer(Buffer.alloc(10)); // true\nBuffer.isBuffer(Buffer.from('foo')); // true\nBuffer.isBuffer('a string'); // false\nBuffer.isBuffer([]); // false\nBuffer.isBuffer(new Uint8Array(1024)); // false\n</code></pre>"
             },
             {
               "textRaw": "Static method: `Buffer.isEncoding(encoding)`",
@@ -711,13 +945,6 @@
               "textRaw": "`[index]` `index` {integer}",
               "type": "integer",
               "name": "index",
-              "meta": {
-                "type": "property",
-                "name": [
-                  "index"
-                ],
-                "changes": []
-              },
               "desc": "<p>The index operator <code>[index]</code> can be used to get and set the octet at position\n<code>index</code> in <code>buf</code>. The values refer to individual bytes, so the legal value\nrange is between <code>0x00</code> and <code>0xFF</code> (hex) or <code>0</code> and <code>255</code> (decimal).</p>\n<p>This operator is inherited from <code>Uint8Array</code>, so its behavior on out-of-bounds\naccess is the same as <code>Uint8Array</code>. In other words, <code>buf[index]</code> returns\n<code>undefined</code> when <code>index</code> is negative or greater or equal to <code>buf.length</code>, and\n<code>buf[index] = value</code> does not modify the buffer if <code>index</code> is negative or\n<code>>= buf.length</code>.</p>\n<pre><code class=\"language-js\">// Copy an ASCII string into a `Buffer` one byte at a time.\n// (This only works for ASCII-only strings. In general, one should use\n// `Buffer.from()` to perform this conversion.)\n\nconst str = 'Node.js';\nconst buf = Buffer.allocUnsafe(str.length);\n\nfor (let i = 0; i &#x3C; str.length; i++) {\n  buf[i] = str.charCodeAt(i);\n}\n\nconsole.log(buf.toString('utf8'));\n// Prints: Node.js\n</code></pre>"
             },
             {
@@ -878,7 +1105,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Copies data from a region of <code>buf</code> to a region in <code>target</code>, even if the <code>target</code>\nmemory region overlaps with <code>buf</code>.</p>\n<p><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set\"><code>TypedArray#set()</code></a> performs the same operation, and is available for all\nTypedArrays, including Node.js <code>Buffer</code>s, although it takes different\nfunction arguments.</p>\n<pre><code class=\"language-js\">// Create two `Buffer` instances.\nconst buf1 = Buffer.allocUnsafe(26);\nconst buf2 = Buffer.allocUnsafe(26).fill('!');\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf1[i] = i + 97;\n}\n\n// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.\nbuf1.copy(buf2, 8, 16, 20);\n// This is equivalent to:\n// buf2.set(buf1.subarray(16, 20), 8);\n\nconsole.log(buf2.toString('ascii', 0, 25));\n// Prints: !!!!!!!!qrst!!!!!!!!!!!!!\n</code></pre>\n<pre><code class=\"language-js\">// Create a `Buffer` and copy data from one region to an overlapping region\n// within the same `Buffer`.\n\nconst buf = Buffer.allocUnsafe(26);\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf[i] = i + 97;\n}\n\nbuf.copy(buf, 0, 4, 10);\n\nconsole.log(buf.toString());\n// Prints: efghijghijklmnopqrstuvwxyz\n</code></pre>"
+              "desc": "<p>Copies data from a region of <code>buf</code> to a region in <code>target</code>, even if the <code>target</code>\nmemory region overlaps with <code>buf</code>.</p>\n<p><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set\"><code>TypedArray.prototype.set()</code></a> performs the same operation, and is available\nfor all TypedArrays, including Node.js <code>Buffer</code>s, although it takes\ndifferent function arguments.</p>\n<pre><code class=\"language-js\">// Create two `Buffer` instances.\nconst buf1 = Buffer.allocUnsafe(26);\nconst buf2 = Buffer.allocUnsafe(26).fill('!');\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf1[i] = i + 97;\n}\n\n// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.\nbuf1.copy(buf2, 8, 16, 20);\n// This is equivalent to:\n// buf2.set(buf1.subarray(16, 20), 8);\n\nconsole.log(buf2.toString('ascii', 0, 25));\n// Prints: !!!!!!!!qrst!!!!!!!!!!!!!\n</code></pre>\n<pre><code class=\"language-js\">// Create a `Buffer` and copy data from one region to an overlapping region\n// within the same `Buffer`.\n\nconst buf = Buffer.allocUnsafe(26);\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf[i] = i + 97;\n}\n\nbuf.copy(buf, 0, 4, 10);\n\nconsole.log(buf.toString());\n// Prints: efghijghijklmnopqrstuvwxyz\n</code></pre>"
             },
             {
               "textRaw": "`buf.entries()`",
@@ -1073,7 +1300,10 @@
                     "description": "The `value` can now be a `Uint8Array`."
                   },
                   {
-                    "version": "v5.7.0, v4.4.0",
+                    "version": [
+                      "v5.7.0",
+                      "v4.4.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/4803",
                     "description": "When `encoding` is being passed, the `byteOffset` parameter is no longer required."
                   }
@@ -1111,7 +1341,7 @@
                   ]
                 }
               ],
-              "desc": "<p>If <code>value</code> is:</p>\n<ul>\n<li>a string, <code>value</code> is interpreted according to the character encoding in\n<code>encoding</code>.</li>\n<li>a <code>Buffer</code> or <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>, <code>value</code> will be used in its entirety.\nTo compare a partial <code>Buffer</code>, use <a href=\"#buffer_buf_slice_start_end\"><code>buf.slice()</code></a>.</li>\n<li>a number, <code>value</code> will be interpreted as an unsigned 8-bit integer\nvalue between <code>0</code> and <code>255</code>.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from('this is a buffer');\n\nconsole.log(buf.indexOf('this'));\n// Prints: 0\nconsole.log(buf.indexOf('is'));\n// Prints: 2\nconsole.log(buf.indexOf(Buffer.from('a buffer')));\n// Prints: 8\nconsole.log(buf.indexOf(97));\n// Prints: 8 (97 is the decimal ASCII value for 'a')\nconsole.log(buf.indexOf(Buffer.from('a buffer example')));\n// Prints: -1\nconsole.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));\n// Prints: 8\n\nconst utf16Buffer = Buffer.from('\\u039a\\u0391\\u03a3\\u03a3\\u0395', 'utf16le');\n\nconsole.log(utf16Buffer.indexOf('\\u03a3', 0, 'utf16le'));\n// Prints: 4\nconsole.log(utf16Buffer.indexOf('\\u03a3', -4, 'utf16le'));\n// Prints: 6\n</code></pre>\n<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a\n<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,\nan integer between 0 and 255.</p>\n<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. If the result\nof coercion is <code>NaN</code> or <code>0</code>, then the entire buffer will be searched. This\nbehavior matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf\"><code>String#indexOf()</code></a>.</p>\n<pre><code class=\"language-js\">const b = Buffer.from('abcdef');\n\n// Passing a value that's a number, but not a valid byte.\n// Prints: 2, equivalent to searching for 99 or 'c'.\nconsole.log(b.indexOf(99.9));\nconsole.log(b.indexOf(256 + 99));\n\n// Passing a byteOffset that coerces to NaN or 0.\n// Prints: 1, searching the whole buffer.\nconsole.log(b.indexOf('b', undefined));\nconsole.log(b.indexOf('b', {}));\nconsole.log(b.indexOf('b', null));\nconsole.log(b.indexOf('b', []));\n</code></pre>\n<p>If <code>value</code> is an empty string or empty <code>Buffer</code> and <code>byteOffset</code> is less\nthan <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code>value</code> is empty and\n<code>byteOffset</code> is at least <code>buf.length</code>, <code>buf.length</code> will be returned.</p>"
+              "desc": "<p>If <code>value</code> is:</p>\n<ul>\n<li>a string, <code>value</code> is interpreted according to the character encoding in\n<code>encoding</code>.</li>\n<li>a <code>Buffer</code> or <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>, <code>value</code> will be used in its entirety.\nTo compare a partial <code>Buffer</code>, use <a href=\"#buffer_buf_slice_start_end\"><code>buf.slice()</code></a>.</li>\n<li>a number, <code>value</code> will be interpreted as an unsigned 8-bit integer\nvalue between <code>0</code> and <code>255</code>.</li>\n</ul>\n<pre><code class=\"language-js\">const buf = Buffer.from('this is a buffer');\n\nconsole.log(buf.indexOf('this'));\n// Prints: 0\nconsole.log(buf.indexOf('is'));\n// Prints: 2\nconsole.log(buf.indexOf(Buffer.from('a buffer')));\n// Prints: 8\nconsole.log(buf.indexOf(97));\n// Prints: 8 (97 is the decimal ASCII value for 'a')\nconsole.log(buf.indexOf(Buffer.from('a buffer example')));\n// Prints: -1\nconsole.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));\n// Prints: 8\n\nconst utf16Buffer = Buffer.from('\\u039a\\u0391\\u03a3\\u03a3\\u0395', 'utf16le');\n\nconsole.log(utf16Buffer.indexOf('\\u03a3', 0, 'utf16le'));\n// Prints: 4\nconsole.log(utf16Buffer.indexOf('\\u03a3', -4, 'utf16le'));\n// Prints: 6\n</code></pre>\n<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a\n<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,\nan integer between 0 and 255.</p>\n<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. If the result\nof coercion is <code>NaN</code> or <code>0</code>, then the entire buffer will be searched. This\nbehavior matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf\"><code>String.prototype.indexOf()</code></a>.</p>\n<pre><code class=\"language-js\">const b = Buffer.from('abcdef');\n\n// Passing a value that's a number, but not a valid byte.\n// Prints: 2, equivalent to searching for 99 or 'c'.\nconsole.log(b.indexOf(99.9));\nconsole.log(b.indexOf(256 + 99));\n\n// Passing a byteOffset that coerces to NaN or 0.\n// Prints: 1, searching the whole buffer.\nconsole.log(b.indexOf('b', undefined));\nconsole.log(b.indexOf('b', {}));\nconsole.log(b.indexOf('b', null));\nconsole.log(b.indexOf('b', []));\n</code></pre>\n<p>If <code>value</code> is an empty string or empty <code>Buffer</code> and <code>byteOffset</code> is less\nthan <code>buf.length</code>, <code>byteOffset</code> will be returned. If <code>value</code> is empty and\n<code>byteOffset</code> is at least <code>buf.length</code>, <code>buf.length</code> will be returned.</p>"
             },
             {
               "textRaw": "`buf.keys()`",
@@ -1183,7 +1413,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Identical to <a href=\"#buffer_buf_indexof_value_byteoffset_encoding\"><code>buf.indexOf()</code></a>, except the last occurrence of <code>value</code> is found\nrather than the first occurrence.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('this buffer is a buffer');\n\nconsole.log(buf.lastIndexOf('this'));\n// Prints: 0\nconsole.log(buf.lastIndexOf('buffer'));\n// Prints: 17\nconsole.log(buf.lastIndexOf(Buffer.from('buffer')));\n// Prints: 17\nconsole.log(buf.lastIndexOf(97));\n// Prints: 15 (97 is the decimal ASCII value for 'a')\nconsole.log(buf.lastIndexOf(Buffer.from('yolo')));\n// Prints: -1\nconsole.log(buf.lastIndexOf('buffer', 5));\n// Prints: 5\nconsole.log(buf.lastIndexOf('buffer', 4));\n// Prints: -1\n\nconst utf16Buffer = Buffer.from('\\u039a\\u0391\\u03a3\\u03a3\\u0395', 'utf16le');\n\nconsole.log(utf16Buffer.lastIndexOf('\\u03a3', undefined, 'utf16le'));\n// Prints: 6\nconsole.log(utf16Buffer.lastIndexOf('\\u03a3', -5, 'utf16le'));\n// Prints: 4\n</code></pre>\n<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a\n<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,\nan integer between 0 and 255.</p>\n<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. Any arguments\nthat coerce to <code>NaN</code>, like <code>{}</code> or <code>undefined</code>, will search the whole buffer.\nThis behavior matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf\"><code>String#lastIndexOf()</code></a>.</p>\n<pre><code class=\"language-js\">const b = Buffer.from('abcdef');\n\n// Passing a value that's a number, but not a valid byte.\n// Prints: 2, equivalent to searching for 99 or 'c'.\nconsole.log(b.lastIndexOf(99.9));\nconsole.log(b.lastIndexOf(256 + 99));\n\n// Passing a byteOffset that coerces to NaN.\n// Prints: 1, searching the whole buffer.\nconsole.log(b.lastIndexOf('b', undefined));\nconsole.log(b.lastIndexOf('b', {}));\n\n// Passing a byteOffset that coerces to 0.\n// Prints: -1, equivalent to passing 0.\nconsole.log(b.lastIndexOf('b', null));\nconsole.log(b.lastIndexOf('b', []));\n</code></pre>\n<p>If <code>value</code> is an empty string or empty <code>Buffer</code>, <code>byteOffset</code> will be returned.</p>"
+              "desc": "<p>Identical to <a href=\"#buffer_buf_indexof_value_byteoffset_encoding\"><code>buf.indexOf()</code></a>, except the last occurrence of <code>value</code> is found\nrather than the first occurrence.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('this buffer is a buffer');\n\nconsole.log(buf.lastIndexOf('this'));\n// Prints: 0\nconsole.log(buf.lastIndexOf('buffer'));\n// Prints: 17\nconsole.log(buf.lastIndexOf(Buffer.from('buffer')));\n// Prints: 17\nconsole.log(buf.lastIndexOf(97));\n// Prints: 15 (97 is the decimal ASCII value for 'a')\nconsole.log(buf.lastIndexOf(Buffer.from('yolo')));\n// Prints: -1\nconsole.log(buf.lastIndexOf('buffer', 5));\n// Prints: 5\nconsole.log(buf.lastIndexOf('buffer', 4));\n// Prints: -1\n\nconst utf16Buffer = Buffer.from('\\u039a\\u0391\\u03a3\\u03a3\\u0395', 'utf16le');\n\nconsole.log(utf16Buffer.lastIndexOf('\\u03a3', undefined, 'utf16le'));\n// Prints: 6\nconsole.log(utf16Buffer.lastIndexOf('\\u03a3', -5, 'utf16le'));\n// Prints: 4\n</code></pre>\n<p>If <code>value</code> is not a string, number, or <code>Buffer</code>, this method will throw a\n<code>TypeError</code>. If <code>value</code> is a number, it will be coerced to a valid byte value,\nan integer between 0 and 255.</p>\n<p>If <code>byteOffset</code> is not a number, it will be coerced to a number. Any arguments\nthat coerce to <code>NaN</code>, like <code>{}</code> or <code>undefined</code>, will search the whole buffer.\nThis behavior matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf\"><code>String.prototype.lastIndexOf()</code></a>.</p>\n<pre><code class=\"language-js\">const b = Buffer.from('abcdef');\n\n// Passing a value that's a number, but not a valid byte.\n// Prints: 2, equivalent to searching for 99 or 'c'.\nconsole.log(b.lastIndexOf(99.9));\nconsole.log(b.lastIndexOf(256 + 99));\n\n// Passing a byteOffset that coerces to NaN.\n// Prints: 1, searching the whole buffer.\nconsole.log(b.lastIndexOf('b', undefined));\nconsole.log(b.lastIndexOf('b', {}));\n\n// Passing a byteOffset that coerces to 0.\n// Prints: -1, equivalent to passing 0.\nconsole.log(b.lastIndexOf('b', null));\nconsole.log(b.lastIndexOf('b', []));\n</code></pre>\n<p>If <code>value</code> is an empty string or empty <code>Buffer</code>, <code>byteOffset</code> will be returned.</p>"
             },
             {
               "textRaw": "`buf.readBigInt64BE([offset])`",
@@ -1222,7 +1452,8 @@
               "name": "readBigInt64LE",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -1252,11 +1483,12 @@
               "name": "readBigUInt64BE",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34960",
                     "description": "This function is also available as `buf.readBigUint64BE()`."
                   }
@@ -1280,7 +1512,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, big-endian 64-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);\n\nconsole.log(buf.readBigUInt64BE(0));\n// Prints: 4294967295n\n</code></pre>"
+              "desc": "<p>Reads an unsigned, big-endian 64-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readBigUint64BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);\n\nconsole.log(buf.readBigUInt64BE(0));\n// Prints: 4294967295n\n</code></pre>"
             },
             {
               "textRaw": "`buf.readBigUInt64LE([offset])`",
@@ -1293,7 +1525,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": [
+                      "v14.10.0",
+                      "v12.19.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/34960",
                     "description": "This function is also available as `buf.readBigUint64LE()`."
                   }
@@ -1317,7 +1552,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, little-endian 64-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);\n\nconsole.log(buf.readBigUInt64LE(0));\n// Prints: 18446744069414584320n\n</code></pre>"
+              "desc": "<p>Reads an unsigned, little-endian 64-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readBigUint64LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);\n\nconsole.log(buf.readBigUInt64LE(0));\n// Prints: 18446744069414584320n\n</code></pre>"
             },
             {
               "textRaw": "`buf.readDoubleBE([offset])`",
@@ -1735,7 +1970,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint8()`."
                   },
@@ -1764,7 +1999,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([1, -2]);\n\nconsole.log(buf.readUInt8(0));\n// Prints: 1\nconsole.log(buf.readUInt8(1));\n// Prints: 254\nconsole.log(buf.readUInt8(2));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
+              "desc": "<p>Reads an unsigned 8-bit integer from <code>buf</code> at the specified <code>offset</code>.</p>\n<p>This function is also available under the <code>readUint8</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([1, -2]);\n\nconsole.log(buf.readUInt8(0));\n// Prints: 1\nconsole.log(buf.readUInt8(1));\n// Prints: 254\nconsole.log(buf.readUInt8(2));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUInt16BE([offset])`",
@@ -1776,7 +2011,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint16BE()`."
                   },
@@ -1805,7 +2040,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, big-endian 16-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56]);\n\nconsole.log(buf.readUInt16BE(0).toString(16));\n// Prints: 1234\nconsole.log(buf.readUInt16BE(1).toString(16));\n// Prints: 3456\n</code></pre>"
+              "desc": "<p>Reads an unsigned, big-endian 16-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readUint16BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56]);\n\nconsole.log(buf.readUInt16BE(0).toString(16));\n// Prints: 1234\nconsole.log(buf.readUInt16BE(1).toString(16));\n// Prints: 3456\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUInt16LE([offset])`",
@@ -1817,7 +2052,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint16LE()`."
                   },
@@ -1846,7 +2081,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, little-endian 16-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56]);\n\nconsole.log(buf.readUInt16LE(0).toString(16));\n// Prints: 3412\nconsole.log(buf.readUInt16LE(1).toString(16));\n// Prints: 5634\nconsole.log(buf.readUInt16LE(2).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
+              "desc": "<p>Reads an unsigned, little-endian 16-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readUint16LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56]);\n\nconsole.log(buf.readUInt16LE(0).toString(16));\n// Prints: 3412\nconsole.log(buf.readUInt16LE(1).toString(16));\n// Prints: 5634\nconsole.log(buf.readUInt16LE(2).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUInt32BE([offset])`",
@@ -1858,7 +2093,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint32BE()`."
                   },
@@ -1887,7 +2122,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, big-endian 32-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);\n\nconsole.log(buf.readUInt32BE(0).toString(16));\n// Prints: 12345678\n</code></pre>"
+              "desc": "<p>Reads an unsigned, big-endian 32-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readUint32BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);\n\nconsole.log(buf.readUInt32BE(0).toString(16));\n// Prints: 12345678\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUInt32LE([offset])`",
@@ -1899,7 +2134,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUint32LE()`."
                   },
@@ -1928,7 +2163,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads an unsigned, little-endian 32-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);\n\nconsole.log(buf.readUInt32LE(0).toString(16));\n// Prints: 78563412\nconsole.log(buf.readUInt32LE(1).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
+              "desc": "<p>Reads an unsigned, little-endian 32-bit integer from <code>buf</code> at the specified\n<code>offset</code>.</p>\n<p>This function is also available under the <code>readUint32LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);\n\nconsole.log(buf.readUInt32LE(0).toString(16));\n// Prints: 78563412\nconsole.log(buf.readUInt32LE(1).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUIntBE(offset, byteLength)`",
@@ -1940,7 +2175,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUintBE()`."
                   },
@@ -1974,7 +2209,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>\nand interprets the result as an unsigned big-endian integer supporting\nup to 48 bits of accuracy.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);\n\nconsole.log(buf.readUIntBE(0, 6).toString(16));\n// Prints: 1234567890ab\nconsole.log(buf.readUIntBE(1, 6).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
+              "desc": "<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>\nand interprets the result as an unsigned big-endian integer supporting\nup to 48 bits of accuracy.</p>\n<p>This function is also available under the <code>readUintBE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);\n\nconsole.log(buf.readUIntBE(0, 6).toString(16));\n// Prints: 1234567890ab\nconsole.log(buf.readUIntBE(1, 6).toString(16));\n// Throws ERR_OUT_OF_RANGE.\n</code></pre>"
             },
             {
               "textRaw": "`buf.readUIntLE(offset, byteLength)`",
@@ -1986,7 +2221,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.readUintLE()`."
                   },
@@ -2020,7 +2255,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>\nand interprets the result as an unsigned, little-endian integer supporting\nup to 48 bits of accuracy.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);\n\nconsole.log(buf.readUIntLE(0, 6).toString(16));\n// Prints: ab9078563412\n</code></pre>"
+              "desc": "<p>Reads <code>byteLength</code> number of bytes from <code>buf</code> at the specified <code>offset</code>\nand interprets the result as an unsigned, little-endian integer supporting\nup to 48 bits of accuracy.</p>\n<p>This function is also available under the <code>readUintLE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);\n\nconsole.log(buf.readUIntLE(0, 6).toString(16));\n// Prints: ab9078563412\n</code></pre>"
             },
             {
               "textRaw": "`buf.subarray([start[, end]])`",
@@ -2057,7 +2292,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a new <code>Buffer</code> that references the same memory as the original, but\noffset and cropped by the <code>start</code> and <code>end</code> indices.</p>\n<p>Specifying <code>end</code> greater than <a href=\"#buffer_buf_length\"><code>buf.length</code></a> will return the same result as\nthat of <code>end</code> equal to <a href=\"#buffer_buf_length\"><code>buf.length</code></a>.</p>\n<p>This method is inherited from <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\"><code>TypedArray#subarray()</code></a>.</p>\n<p>Modifying the new <code>Buffer</code> slice will modify the memory in the original <code>Buffer</code>\nbecause the allocated memory of the two objects overlap.</p>\n<pre><code class=\"language-js\">// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte\n// from the original `Buffer`.\n\nconst buf1 = Buffer.allocUnsafe(26);\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf1[i] = i + 97;\n}\n\nconst buf2 = buf1.subarray(0, 3);\n\nconsole.log(buf2.toString('ascii', 0, buf2.length));\n// Prints: abc\n\nbuf1[0] = 33;\n\nconsole.log(buf2.toString('ascii', 0, buf2.length));\n// Prints: !bc\n</code></pre>\n<p>Specifying negative indexes causes the slice to be generated relative to the\nend of <code>buf</code> rather than the beginning.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('buffer');\n\nconsole.log(buf.subarray(-6, -1).toString());\n// Prints: buffe\n// (Equivalent to buf.subarray(0, 5).)\n\nconsole.log(buf.subarray(-6, -2).toString());\n// Prints: buff\n// (Equivalent to buf.subarray(0, 4).)\n\nconsole.log(buf.subarray(-5, -2).toString());\n// Prints: uff\n// (Equivalent to buf.subarray(1, 4).)\n</code></pre>"
+              "desc": "<p>Returns a new <code>Buffer</code> that references the same memory as the original, but\noffset and cropped by the <code>start</code> and <code>end</code> indices.</p>\n<p>Specifying <code>end</code> greater than <a href=\"#buffer_buf_length\"><code>buf.length</code></a> will return the same result as\nthat of <code>end</code> equal to <a href=\"#buffer_buf_length\"><code>buf.length</code></a>.</p>\n<p>This method is inherited from <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\"><code>TypedArray.prototype.subarray()</code></a>.</p>\n<p>Modifying the new <code>Buffer</code> slice will modify the memory in the original <code>Buffer</code>\nbecause the allocated memory of the two objects overlap.</p>\n<pre><code class=\"language-js\">// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte\n// from the original `Buffer`.\n\nconst buf1 = Buffer.allocUnsafe(26);\n\nfor (let i = 0; i &#x3C; 26; i++) {\n  // 97 is the decimal ASCII value for 'a'.\n  buf1[i] = i + 97;\n}\n\nconst buf2 = buf1.subarray(0, 3);\n\nconsole.log(buf2.toString('ascii', 0, buf2.length));\n// Prints: abc\n\nbuf1[0] = 33;\n\nconsole.log(buf2.toString('ascii', 0, buf2.length));\n// Prints: !bc\n</code></pre>\n<p>Specifying negative indexes causes the slice to be generated relative to the\nend of <code>buf</code> rather than the beginning.</p>\n<pre><code class=\"language-js\">const buf = Buffer.from('buffer');\n\nconsole.log(buf.subarray(-6, -1).toString());\n// Prints: buffe\n// (Equivalent to buf.subarray(0, 5).)\n\nconsole.log(buf.subarray(-6, -2).toString());\n// Prints: buff\n// (Equivalent to buf.subarray(0, 4).)\n\nconsole.log(buf.subarray(-5, -2).toString());\n// Prints: uff\n// (Equivalent to buf.subarray(1, 4).)\n</code></pre>"
             },
             {
               "textRaw": "`buf.slice([start[, end]])`",
@@ -2069,7 +2304,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v7.1.0, v6.9.2",
+                    "version": [
+                      "v7.1.0",
+                      "v6.9.2"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/9341",
                     "description": "Coercing the offsets to integers now handles values outside the 32-bit integer range properly."
                   },
@@ -2321,7 +2559,8 @@
               "name": "writeBigInt64BE",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -2401,7 +2640,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34960",
                     "description": "This function is also available as `buf.writeBigUint64BE()`."
                   }
@@ -2432,7 +2671,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(8);\n\nbuf.writeBigUInt64BE(0xdecafafecacefaden, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de ca fa fe ca ce fa de>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian.</p>\n<p>This function is also available under the <code>writeBigUint64BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(8);\n\nbuf.writeBigUInt64BE(0xdecafafecacefaden, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de ca fa fe ca ce fa de>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeBigUInt64LE(value[, offset])`",
@@ -2440,11 +2679,12 @@
               "name": "writeBigUInt64LE",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34960",
                     "description": "This function is also available as `buf.writeBigUint64LE()`."
                   }
@@ -2475,7 +2715,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(8);\n\nbuf.writeBigUInt64LE(0xdecafafecacefaden, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de fa ce ca fe fa ca de>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(8);\n\nbuf.writeBigUInt64LE(0xdecafafecacefaden, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de fa ce ca fe fa ca de>\n</code></pre>\n<p>This function is also available under the <code>writeBigUint64LE</code> alias.</p>"
             },
             {
               "textRaw": "`buf.writeDoubleBE(value[, offset])`",
@@ -2604,7 +2844,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. Behavior is\nundefined when <code>value</code> is anything other than a JavaScript number.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeFloatBE(0xcafebabe, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 4f 4a fe bb>\n\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. Behavior is\nundefined when <code>value</code> is anything other than a JavaScript number.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeFloatBE(0xcafebabe, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 4f 4a fe bb>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeFloatLE(value[, offset])`",
@@ -2910,7 +3150,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when\n<code>value</code> is anything other than a signed integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeIntBE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 12 34 56 78 90 ab>\n\n</code></pre>"
+              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined when\n<code>value</code> is anything other than a signed integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeIntBE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 12 34 56 78 90 ab>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeIntLE(value, offset, byteLength)`",
@@ -2970,7 +3210,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint8()`."
                   },
@@ -3006,7 +3246,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code>. <code>value</code> must be a\nvalid unsigned 8-bit integer. Behavior is undefined when <code>value</code> is anything\nother than an unsigned 8-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt8(0x3, 0);\nbuf.writeUInt8(0x4, 1);\nbuf.writeUInt8(0x23, 2);\nbuf.writeUInt8(0x42, 3);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 03 04 23 42>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code>. <code>value</code> must be a\nvalid unsigned 8-bit integer. Behavior is undefined when <code>value</code> is anything\nother than an unsigned 8-bit integer.</p>\n<p>This function is also available under the <code>writeUint8</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt8(0x3, 0);\nbuf.writeUInt8(0x4, 1);\nbuf.writeUInt8(0x23, 2);\nbuf.writeUInt8(0x42, 3);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 03 04 23 42>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUInt16BE(value[, offset])`",
@@ -3018,7 +3258,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint16BE()`."
                   },
@@ -3054,7 +3294,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>\nmust be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code>\nis anything other than an unsigned 16-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt16BE(0xdead, 0);\nbuf.writeUInt16BE(0xbeef, 2);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de ad be ef>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>\nmust be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code>\nis anything other than an unsigned 16-bit integer.</p>\n<p>This function is also available under the <code>writeUint16BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt16BE(0xdead, 0);\nbuf.writeUInt16BE(0xbeef, 2);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer de ad be ef>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUInt16LE(value[, offset])`",
@@ -3066,7 +3306,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": [
+                      "v14.9.0",
+                      "v12.19.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint16LE()`."
                   },
@@ -3102,7 +3345,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>\nmust be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code> is\nanything other than an unsigned 16-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt16LE(0xdead, 0);\nbuf.writeUInt16LE(0xbeef, 2);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ad de ef be>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>\nmust be a valid unsigned 16-bit integer. Behavior is undefined when <code>value</code> is\nanything other than an unsigned 16-bit integer.</p>\n<p>This function is also available under the <code>writeUint16LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt16LE(0xdead, 0);\nbuf.writeUInt16LE(0xbeef, 2);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ad de ef be>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUInt32BE(value[, offset])`",
@@ -3114,7 +3357,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint32BE()`."
                   },
@@ -3150,7 +3393,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>\nmust be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code>\nis anything other than an unsigned 32-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt32BE(0xfeedface, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer fe ed fa ce>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as big-endian. The <code>value</code>\nmust be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code>\nis anything other than an unsigned 32-bit integer.</p>\n<p>This function is also available under the <code>writeUint32BE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt32BE(0xfeedface, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer fe ed fa ce>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUInt32LE(value[, offset])`",
@@ -3162,7 +3405,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUint32LE()`."
                   },
@@ -3198,7 +3441,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>\nmust be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code> is\nanything other than an unsigned 32-bit integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt32LE(0xfeedface, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ce fa ed fe>\n</code></pre>"
+              "desc": "<p>Writes <code>value</code> to <code>buf</code> at the specified <code>offset</code> as little-endian. The <code>value</code>\nmust be a valid unsigned 32-bit integer. Behavior is undefined when <code>value</code> is\nanything other than an unsigned 32-bit integer.</p>\n<p>This function is also available under the <code>writeUint32LE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(4);\n\nbuf.writeUInt32LE(0xfeedface, 0);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ce fa ed fe>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUIntBE(value, offset, byteLength)`",
@@ -3210,7 +3453,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUintBE()`."
                   },
@@ -3251,7 +3494,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined\nwhen <code>value</code> is anything other than an unsigned integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeUIntBE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 12 34 56 78 90 ab>\n</code></pre>"
+              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas big-endian. Supports up to 48 bits of accuracy. Behavior is undefined\nwhen <code>value</code> is anything other than an unsigned integer.</p>\n<p>This function is also available under the <code>writeUintBE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeUIntBE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer 12 34 56 78 90 ab>\n</code></pre>"
             },
             {
               "textRaw": "`buf.writeUIntLE(value, offset, byteLength)`",
@@ -3263,7 +3506,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/34729",
                     "description": "This function is also available as `buf.writeUintLE()`."
                   },
@@ -3304,7 +3547,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas little-endian. Supports up to 48 bits of accuracy. Behavior is undefined\nwhen <code>value</code> is anything other than an unsigned integer.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeUIntLE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ab 90 78 56 34 12>\n</code></pre>"
+              "desc": "<p>Writes <code>byteLength</code> bytes of <code>value</code> to <code>buf</code> at the specified <code>offset</code>\nas little-endian. Supports up to 48 bits of accuracy. Behavior is undefined\nwhen <code>value</code> is anything other than an unsigned integer.</p>\n<p>This function is also available under the <code>writeUintLE</code> alias.</p>\n<pre><code class=\"language-js\">const buf = Buffer.allocUnsafe(6);\n\nbuf.writeUIntLE(0x1234567890ab, 0, 6);\n\nconsole.log(buf);\n// Prints: &#x3C;Buffer ab 90 78 56 34 12>\n</code></pre>"
             }
           ],
           "signatures": [
diff --git a/doc/api/buffer.md b/doc/api/buffer.md
index 36fa358bcc3c01a78499cf33e6005969477edb7f..60c857f78e7c0e9710ee5fdd469f7b73a4ee721a 100644
--- a/doc/api/buffer.md
+++ b/doc/api/buffer.md
@@ -50,6 +50,9 @@ const buf7 = Buffer.from('tést', 'latin1');
 ## Buffers and character encodings
 <!-- YAML
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/36952
+    description: Introduced `base64url` encoding.
   - version: v6.4.0
     pr-url: https://github.com/nodejs/node/pull/7111
     description: Introduced `latin1` as an alias for `binary`.
@@ -96,7 +99,7 @@ The character encodings currently supported by Node.js are the following:
 Converting a `Buffer` into a string using one of the above is referred to as
 decoding, and converting a string into a `Buffer` is referred to as encoding.
 
-Node.js also supports the following two binary-to-text encodings. For
+Node.js also supports the following binary-to-text encodings. For
 binary-to-text encodings, the naming convention is reversed: Converting a
 `Buffer` into a string is typically referred to as encoding, and converting a
 string into a `Buffer` as decoding.
@@ -106,6 +109,11 @@ string into a `Buffer` as decoding.
   specified in [RFC 4648, Section 5][]. Whitespace characters such as spaces,
   tabs, and new lines contained within the base64-encoded string are ignored.
 
+* `'base64url'`: [base64url][] encoding as specified in
+  [RFC 4648, Section 5][]. When creating a `Buffer` from a string, this
+  encoding will also correctly accept regular base64-encoded strings. When
+  encoding a `Buffer` to a string, this encoding will omit padding.
+
 * `'hex'`: Encode each byte as two hexadecimal characters. Data truncation
   may occur when decoding strings that do exclusively contain valid hexadecimal
   characters. See below for an example.
@@ -164,12 +172,12 @@ however, subtle incompatibilities between the `Buffer` API and the
 
 In particular:
 
-* While [`TypedArray#slice()`][] creates a copy of part of the `TypedArray`,
-  [`Buffer#slice()`][`buf.slice()`] creates a view over the existing `Buffer`
+* While [`TypedArray.prototype.slice()`][] creates a copy of part of the `TypedArray`,
+  [`Buffer.prototype.slice()`][`buf.slice()`] creates a view over the existing `Buffer`
   without copying. This behavior can be surprising, and only exists for legacy
-  compatibility. [`TypedArray#subarray()`][] can be used to achieve the behavior
-  of [`Buffer#slice()`][`buf.slice()`] on both `Buffer`s and other
-  `TypedArray`s.
+  compatibility. [`TypedArray.prototype.subarray()`][] can be used to achieve
+  the behavior of [`Buffer.prototype.slice()`][`buf.slice()`] on both `Buffer`s
+  and other `TypedArray`s.
 * [`buf.toString()`][] is incompatible with its `TypedArray` equivalent.
 * A number of methods, e.g. [`buf.indexOf()`][], support additional arguments.
 
@@ -193,7 +201,7 @@ console.log(uint32array);
 
 ```js
 const buf = Buffer.from('hello', 'utf16le');
-const uint16arr = new Uint16Array(
+const uint16array = new Uint16Array(
   buf.buffer,
   buf.byteOffset,
   buf.length / Uint16Array.BYTES_PER_ELEMENT);
@@ -279,6 +287,119 @@ for (const b of buf) {
 Additionally, the [`buf.values()`][], [`buf.keys()`][], and
 [`buf.entries()`][] methods can be used to create iterators.
 
+## Class: `Blob`
+<!-- YAML
+added: v14.18.0
+-->
+
+> Stability: 1 - Experimental
+
+A [`Blob`][] encapsulates immutable, raw data that can be safely shared across
+multiple worker threads.
+
+### `new buffer.Blob([sources[, options]])`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `sources` {string[]|ArrayBuffer[]|TypedArray[]|DataView[]|Blob[]} An array
+  of string, {ArrayBuffer}, {TypedArray}, {DataView}, or {Blob} objects, or
+  any mix of such objects, that will be stored within the `Blob`.
+* `options` {Object}
+  * `encoding` {string} The character encoding to use for string sources.
+    **Default**: `'utf8'`.
+  * `type` {string} The Blob content-type. The intent is for `type` to convey
+    the MIME media type of the data, however no validation of the type format
+    is performed.
+
+Creates a new `Blob` object containing a concatenation of the given sources.
+
+{ArrayBuffer}, {TypedArray}, {DataView}, and {Buffer} sources are copied into
+the 'Blob' and can therefore be safely modified after the 'Blob' is created.
+
+String sources are also copied into the `Blob`.
+
+### `blob.arrayBuffer()`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Returns: {Promise}
+
+Returns a promise that fulfills with an {ArrayBuffer} containing a copy of
+the `Blob` data.
+
+### `blob.size`
+<!-- YAML
+added: v14.18.0
+-->
+
+The total size of the `Blob` in bytes.
+
+### `blob.slice([start, [end, [type]]])`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `start` {number} The starting index.
+* `end` {number} The ending index.
+* `type` {string} The content-type for the new `Blob`
+
+Creates and returns a new `Blob` containing a subset of this `Blob` objects
+data. The original `Blob` is not alterered.
+
+### `blob.text()`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Returns: {Promise}
+
+Returns a promise that resolves the contents of the `Blob` decoded as a UTF-8
+string.
+
+### `blob.type`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Type: {string}
+
+The content-type of the `Blob`.
+
+### `Blob` objects and `MessageChannel`
+
+Once a {Blob} object is created, it can be sent via `MessagePort` to multiple
+destinations without transfering or immediately copying the data. The data
+contained by the `Blob` is copied only when the `arrayBuffer()` or `text()`
+methods are called.
+
+```js
+const { Blob } = require('buffer');
+const blob = new Blob(['hello there']);
+const { setTimeout: delay } = require('timers/promises');
+
+const mc1 = new MessageChannel();
+const mc2 = new MessageChannel();
+
+mc1.port1.onmessage = async ({ data }) => {
+  console.log(await data.arrayBuffer());
+  mc1.port1.close();
+};
+
+mc2.port1.onmessage = async ({ data }) => {
+  await delay(1000);
+  console.log(await data.arrayBuffer());
+  mc2.port1.close();
+};
+
+mc1.port2.postMessage(blob);
+mc2.port2.postMessage(blob);
+
+// The Blob is still usable after posting.
+data.text().then(console.log);
+```
+
 ## Class: `Buffer`
 
 The `Buffer` class is a global type for dealing with binary data directly.
@@ -469,9 +590,10 @@ Returns the byte length of a string when encoded using `encoding`.
 This is not the same as [`String.prototype.length`][], which does not account
 for the encoding that is used to convert the string into bytes.
 
-For `'base64'` and `'hex'`, this function assumes valid input. For strings that
-contain non-base64/hex-encoded data (e.g. whitespace), the return value might be
-greater than the length of a `Buffer` created from the string.
+For `'base64'`, `'base64url'`, and `'hex'`, this function assumes valid input.
+For strings that contain non-base64/hex-encoded data (e.g. whitespace), the
+return value might be greater than the length of a `Buffer` created from the
+string.
 
 ```js
 const str = '\u00bd + \u00bc = \u00be';
@@ -599,7 +721,7 @@ added: v5.10.0
 This creates a view of the [`ArrayBuffer`][] without copying the underlying
 memory. For example, when passed a reference to the `.buffer` property of a
 [`TypedArray`][] instance, the newly created `Buffer` will share the same
-allocated memory as the [`TypedArray`][].
+allocated memory as the [`TypedArray`][]'s underlying `ArrayBuffer`.
 
 ```js
 const arr = new Uint16Array(2);
@@ -635,6 +757,21 @@ A `TypeError` will be thrown if `arrayBuffer` is not an [`ArrayBuffer`][] or a
 [`SharedArrayBuffer`][] or another type appropriate for `Buffer.from()`
 variants.
 
+It is important to remember that a backing `ArrayBuffer` can cover a range
+of memory that extends beyond the bounds of a `TypedArray` view. A new
+`Buffer` created using the `buffer` property of a `TypedArray` may extend
+beyond the range of the `TypedArray`:
+
+```js
+const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
+const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
+console.log(arrA.buffer === arrB.buffer); // true
+
+const buf = Buffer.from(arrB.buffer);
+console.log(buf);
+// Prints: <Buffer 63 64 65 66>
+```
+
 ### Static method: `Buffer.from(buffer)`
 <!-- YAML
 added: v5.10.0
@@ -730,6 +867,14 @@ added: v0.1.101
 
 Returns `true` if `obj` is a `Buffer`, `false` otherwise.
 
+```js
+Buffer.isBuffer(Buffer.alloc(10)); // true
+Buffer.isBuffer(Buffer.from('foo')); // true
+Buffer.isBuffer('a string'); // false
+Buffer.isBuffer([]); // false
+Buffer.isBuffer(new Uint8Array(1024)); // false
+```
+
 ### Static method: `Buffer.isEncoding(encoding)`
 <!-- YAML
 added: v0.9.1
@@ -766,10 +911,6 @@ This is the size (in bytes) of pre-allocated internal `Buffer` instances used
 for pooling. This value may be modified.
 
 ### `buf[index]`
-<!-- YAML
-type: property
-name: [index]
--->
 
 * `index` {integer}
 
@@ -928,9 +1069,9 @@ added: v0.1.90
 Copies data from a region of `buf` to a region in `target`, even if the `target`
 memory region overlaps with `buf`.
 
-[`TypedArray#set()`][] performs the same operation, and is available for all
-TypedArrays, including Node.js `Buffer`s, although it takes different
-function arguments.
+[`TypedArray.prototype.set()`][] performs the same operation, and is available
+for all TypedArrays, including Node.js `Buffer`s, although it takes
+different function arguments.
 
 ```js
 // Create two `Buffer` instances.
@@ -1135,7 +1276,9 @@ changes:
   - version: v8.0.0
     pr-url: https://github.com/nodejs/node/pull/10236
     description: The `value` can now be a `Uint8Array`.
-  - version: v5.7.0, v4.4.0
+  - version:
+    - v5.7.0
+    - v4.4.0
     pr-url: https://github.com/nodejs/node/pull/4803
     description: When `encoding` is being passed, the `byteOffset` parameter
                  is no longer required.
@@ -1189,7 +1332,7 @@ an integer between 0 and 255.
 
 If `byteOffset` is not a number, it will be coerced to a number. If the result
 of coercion is `NaN` or `0`, then the entire buffer will be searched. This
-behavior matches [`String#indexOf()`][].
+behavior matches [`String.prototype.indexOf()`][].
 
 ```js
 const b = Buffer.from('abcdef');
@@ -1289,7 +1432,7 @@ an integer between 0 and 255.
 
 If `byteOffset` is not a number, it will be coerced to a number. Any arguments
 that coerce to `NaN`, like `{}` or `undefined`, will search the whole buffer.
-This behavior matches [`String#lastIndexOf()`][].
+This behavior matches [`String.prototype.lastIndexOf()`][].
 
 ```js
 const b = Buffer.from('abcdef');
@@ -1362,7 +1505,9 @@ values.
 
 ### `buf.readBigInt64LE([offset])`
 <!-- YAML
-added: v12.0.0
+added:
+ - v12.0.0
+ - v10.20.0
 -->
 
 * `offset` {integer} Number of bytes to skip before starting to read. Must
@@ -1377,9 +1522,11 @@ values.
 
 ### `buf.readBigUInt64BE([offset])`
 <!-- YAML
-added: v12.0.0
+added:
+ - v12.0.0
+ - v10.20.0
 changes:
-  - version: v12.19.0
+  - version: v14.10.0
     pr-url: https://github.com/nodejs/node/pull/34960
     description: This function is also available as `buf.readBigUint64BE()`.
 -->
@@ -1391,6 +1538,8 @@ changes:
 Reads an unsigned, big-endian 64-bit integer from `buf` at the specified
 `offset`.
 
+This function is also available under the `readBigUint64BE` alias.
+
 ```js
 const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
 
@@ -1404,7 +1553,9 @@ added:
  - v12.0.0
  - v10.20.0
 changes:
-  - version: v12.19.0
+  - version:
+    - v14.10.0
+    - v12.19.0
     pr-url: https://github.com/nodejs/node/pull/34960
     description: This function is also available as `buf.readBigUint64LE()`.
 -->
@@ -1416,6 +1567,8 @@ changes:
 Reads an unsigned, little-endian 64-bit integer from `buf` at the specified
 `offset`.
 
+This function is also available under the `readBigUint64LE` alias.
+
 ```js
 const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
 
@@ -1716,7 +1869,7 @@ console.log(buf.readIntLE(0, 6).toString(16));
 <!-- YAML
 added: v0.5.0
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.readUint8()`.
   - version: v10.0.0
@@ -1731,6 +1884,8 @@ changes:
 
 Reads an unsigned 8-bit integer from `buf` at the specified `offset`.
 
+This function is also available under the `readUint8` alias.
+
 ```js
 const buf = Buffer.from([1, -2]);
 
@@ -1746,7 +1901,7 @@ console.log(buf.readUInt8(2));
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.readUint16BE()`.
   - version: v10.0.0
@@ -1762,6 +1917,8 @@ changes:
 Reads an unsigned, big-endian 16-bit integer from `buf` at the specified
 `offset`.
 
+This function is also available under the `readUint16BE` alias.
+
 ```js
 const buf = Buffer.from([0x12, 0x34, 0x56]);
 
@@ -1775,7 +1932,7 @@ console.log(buf.readUInt16BE(1).toString(16));
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.readUint16LE()`.
   - version: v10.0.0
@@ -1791,6 +1948,8 @@ changes:
 Reads an unsigned, little-endian 16-bit integer from `buf` at the specified
 `offset`.
 
+This function is also available under the `readUint16LE` alias.
+
 ```js
 const buf = Buffer.from([0x12, 0x34, 0x56]);
 
@@ -1806,7 +1965,7 @@ console.log(buf.readUInt16LE(2).toString(16));
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.readUint32BE()`.
   - version: v10.0.0
@@ -1822,6 +1981,8 @@ changes:
 Reads an unsigned, big-endian 32-bit integer from `buf` at the specified
 `offset`.
 
+This function is also available under the `readUint32BE` alias.
+
 ```js
 const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);
 
@@ -1833,7 +1994,7 @@ console.log(buf.readUInt32BE(0).toString(16));
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.readUint32LE()`.
   - version: v10.0.0
@@ -1849,6 +2010,8 @@ changes:
 Reads an unsigned, little-endian 32-bit integer from `buf` at the specified
 `offset`.
 
+This function is also available under the `readUint32LE` alias.
+
 ```js
 const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);
 
@@ -1862,7 +2025,7 @@ console.log(buf.readUInt32LE(1).toString(16));
 <!-- YAML
 added: v0.11.15
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.readUintBE()`.
   - version: v10.0.0
@@ -1881,6 +2044,8 @@ Reads `byteLength` number of bytes from `buf` at the specified `offset`
 and interprets the result as an unsigned big-endian integer supporting
 up to 48 bits of accuracy.
 
+This function is also available under the `readUintBE` alias.
+
 ```js
 const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
 
@@ -1894,7 +2059,7 @@ console.log(buf.readUIntBE(1, 6).toString(16));
 <!-- YAML
 added: v0.11.15
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.readUintLE()`.
   - version: v10.0.0
@@ -1913,6 +2078,8 @@ Reads `byteLength` number of bytes from `buf` at the specified `offset`
 and interprets the result as an unsigned, little-endian integer supporting
 up to 48 bits of accuracy.
 
+This function is also available under the `readUintLE` alias.
+
 ```js
 const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
 
@@ -1936,7 +2103,7 @@ offset and cropped by the `start` and `end` indices.
 Specifying `end` greater than [`buf.length`][] will return the same result as
 that of `end` equal to [`buf.length`][].
 
-This method is inherited from [`TypedArray#subarray()`][].
+This method is inherited from [`TypedArray.prototype.subarray()`][].
 
 Modifying the new `Buffer` slice will modify the memory in the original `Buffer`
 because the allocated memory of the two objects overlap.
@@ -1986,7 +2153,9 @@ console.log(buf.subarray(-5, -2).toString());
 <!-- YAML
 added: v0.3.0
 changes:
-  - version: v7.1.0, v6.9.2
+  - version:
+    - v7.1.0
+    - v6.9.2
     pr-url: https://github.com/nodejs/node/pull/9341
     description: Coercing the offsets to integers now handles values outside
                  the 32-bit integer range properly.
@@ -2258,7 +2427,9 @@ console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`);
 
 ### `buf.writeBigInt64BE(value[, offset])`
 <!-- YAML
-added: v12.0.0
+added:
+ - v12.0.0
+ - v10.20.0
 -->
 
 * `value` {bigint} Number to be written to `buf`.
@@ -2310,7 +2481,7 @@ added:
  - v12.0.0
  - v10.20.0
 changes:
-  - version: v12.19.0
+  - version: v14.10.0
     pr-url: https://github.com/nodejs/node/pull/34960
     description: This function is also available as `buf.writeBigUint64BE()`.
 -->
@@ -2322,6 +2493,8 @@ changes:
 
 Writes `value` to `buf` at the specified `offset` as big-endian.
 
+This function is also available under the `writeBigUint64BE` alias.
+
 ```js
 const buf = Buffer.allocUnsafe(8);
 
@@ -2333,9 +2506,11 @@ console.log(buf);
 
 ### `buf.writeBigUInt64LE(value[, offset])`
 <!-- YAML
-added: v12.0.0
+added:
+ - v12.0.0
+ - v10.20.0
 changes:
-  - version: v12.19.0
+  - version: v14.10.0
     pr-url: https://github.com/nodejs/node/pull/34960
     description: This function is also available as `buf.writeBigUint64LE()`.
 -->
@@ -2356,6 +2531,8 @@ console.log(buf);
 // Prints: <Buffer de fa ce ca fe fa ca de>
 ```
 
+This function is also available under the `writeBigUint64LE` alias.
+
 ### `buf.writeDoubleBE(value[, offset])`
 <!-- YAML
 added: v0.11.15
@@ -2437,7 +2614,6 @@ buf.writeFloatBE(0xcafebabe, 0);
 
 console.log(buf);
 // Prints: <Buffer 4f 4a fe bb>
-
 ```
 
 ### `buf.writeFloatLE(value[, offset])`
@@ -2646,7 +2822,6 @@ buf.writeIntBE(0x1234567890ab, 0, 6);
 
 console.log(buf);
 // Prints: <Buffer 12 34 56 78 90 ab>
-
 ```
 
 ### `buf.writeIntLE(value, offset, byteLength)`
@@ -2683,7 +2858,7 @@ console.log(buf);
 <!-- YAML
 added: v0.5.0
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.writeUint8()`.
   - version: v10.0.0
@@ -2701,6 +2876,8 @@ Writes `value` to `buf` at the specified `offset`. `value` must be a
 valid unsigned 8-bit integer. Behavior is undefined when `value` is anything
 other than an unsigned 8-bit integer.
 
+This function is also available under the `writeUint8` alias.
+
 ```js
 const buf = Buffer.allocUnsafe(4);
 
@@ -2717,7 +2894,7 @@ console.log(buf);
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.writeUint16BE()`.
   - version: v10.0.0
@@ -2735,6 +2912,8 @@ Writes `value` to `buf` at the specified `offset` as big-endian. The `value`
 must be a valid unsigned 16-bit integer. Behavior is undefined when `value`
 is anything other than an unsigned 16-bit integer.
 
+This function is also available under the `writeUint16BE` alias.
+
 ```js
 const buf = Buffer.allocUnsafe(4);
 
@@ -2749,7 +2928,9 @@ console.log(buf);
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version:
+    - v14.9.0
+    - v12.19.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.writeUint16LE()`.
   - version: v10.0.0
@@ -2767,6 +2948,8 @@ Writes `value` to `buf` at the specified `offset` as little-endian. The `value`
 must be a valid unsigned 16-bit integer. Behavior is undefined when `value` is
 anything other than an unsigned 16-bit integer.
 
+This function is also available under the `writeUint16LE` alias.
+
 ```js
 const buf = Buffer.allocUnsafe(4);
 
@@ -2781,7 +2964,7 @@ console.log(buf);
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.writeUint32BE()`.
   - version: v10.0.0
@@ -2799,6 +2982,8 @@ Writes `value` to `buf` at the specified `offset` as big-endian. The `value`
 must be a valid unsigned 32-bit integer. Behavior is undefined when `value`
 is anything other than an unsigned 32-bit integer.
 
+This function is also available under the `writeUint32BE` alias.
+
 ```js
 const buf = Buffer.allocUnsafe(4);
 
@@ -2812,7 +2997,7 @@ console.log(buf);
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.writeUint32LE()`.
   - version: v10.0.0
@@ -2830,6 +3015,8 @@ Writes `value` to `buf` at the specified `offset` as little-endian. The `value`
 must be a valid unsigned 32-bit integer. Behavior is undefined when `value` is
 anything other than an unsigned 32-bit integer.
 
+This function is also available under the `writeUint32LE` alias.
+
 ```js
 const buf = Buffer.allocUnsafe(4);
 
@@ -2843,7 +3030,7 @@ console.log(buf);
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.writeUintBE()`.
   - version: v10.0.0
@@ -2863,6 +3050,8 @@ Writes `byteLength` bytes of `value` to `buf` at the specified `offset`
 as big-endian. Supports up to 48 bits of accuracy. Behavior is undefined
 when `value` is anything other than an unsigned integer.
 
+This function is also available under the `writeUintBE` alias.
+
 ```js
 const buf = Buffer.allocUnsafe(6);
 
@@ -2876,7 +3065,7 @@ console.log(buf);
 <!-- YAML
 added: v0.5.5
 changes:
-  - version: v12.19.0
+  - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34729
     description: This function is also available as `buf.writeUintLE()`.
   - version: v10.0.0
@@ -2896,6 +3085,8 @@ Writes `byteLength` bytes of `value` to `buf` at the specified `offset`
 as little-endian. Supports up to 48 bits of accuracy. Behavior is undefined
 when `value` is anything other than an unsigned integer.
 
+This function is also available under the `writeUintLE` alias.
+
 ```js
 const buf = Buffer.allocUnsafe(6);
 
@@ -3041,6 +3232,44 @@ While, the `Buffer` object is available as a global, there are additional
 `Buffer`-related APIs that are available only via the `buffer` module
 accessed using `require('buffer')`.
 
+### `buffer.atob(data)`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `data` {any} The Base64-encoded input string.
+
+Decodes a string of Base64-encoded data into bytes, and encodes those bytes
+into a string using Latin-1 (ISO-8859-1).
+
+The `data` may be any JavaScript-value that can be coerced into a string.
+
+**This function is only provided for compatibility with legacy web platform APIs
+and should never be used in new code, because they use strings to represent
+binary data and predate the introduction of typed arrays in JavaScript.
+For code running using Node.js APIs, converting between base64-encoded strings
+and binary data should be performed using `Buffer.from(str, 'base64')` and
+`buf.toString('base64')`.**
+
+### `buffer.btoa(data)`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `data` {any} An ASCII (Latin1) string.
+
+Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes
+into a string using Base64.
+
+The `data` may be any JavaScript-value that can be coerced into a string.
+
+**This function is only provided for compatibility with legacy web platform APIs
+and should never be used in new code, because they use strings to represent
+binary data and predate the introduction of typed arrays in JavaScript.
+For code running using Node.js APIs, converting between base64-encoded strings
+and binary data should be performed using `Buffer.from(str, 'base64')` and
+`buf.toString('base64')`.**
+
 ### `buffer.INSPECT_MAX_BYTES`
 <!-- YAML
 added: v0.5.4
@@ -3061,6 +3290,15 @@ added: v3.0.0
 
 An alias for [`buffer.constants.MAX_LENGTH`][].
 
+### `buffer.kStringMaxLength`
+<!-- YAML
+added: v3.0.0
+-->
+
+* {integer} The largest length allowed for a single `string` instance.
+
+An alias for [`buffer.constants.MAX_STRING_LENGTH`][].
+
 ### `buffer.transcode(source, fromEnc, toEnc)`
 <!-- YAML
 added: v7.1.0
@@ -3128,12 +3366,20 @@ added: v8.2.0
 #### `buffer.constants.MAX_LENGTH`
 <!-- YAML
 added: v8.2.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/32116
+    description: Value is changed from 2<sup>31</sup> - 1 to
+      2<sup>32</sup> - 1 on 64-bit architectures.
 -->
 
 * {integer} The largest size allowed for a single `Buffer` instance.
 
 On 32-bit architectures, this value currently is 2<sup>30</sup> - 1 (~1GB).
-On 64-bit architectures, this value currently is 2<sup>31</sup> - 1 (~2GB).
+
+On 64-bit architectures, this value currently is 2<sup>32</sup> - 1 (~4GB).
+
+It reflects [`v8::TypedArray::kMaxLength`][] under the hood.
 
 This value is also available as [`buffer.kMaxLength`][].
 
@@ -3224,12 +3470,12 @@ if `size` is less than or equal to half [`Buffer.poolSize`][]. Instances
 returned by [`Buffer.allocUnsafeSlow()`][] *never* use the shared internal
 memory pool.
 
-### The `--zero-fill-buffers` command line option
+### The `--zero-fill-buffers` command-line option
 <!-- YAML
 added: v5.10.0
 -->
 
-Node.js can be started using the `--zero-fill-buffers` command line option to
+Node.js can be started using the `--zero-fill-buffers` command-line option to
 cause all newly-allocated `Buffer` instances to be zero-filled upon creation by
 default. Without the option, buffers created with [`Buffer.allocUnsafe()`][],
 [`Buffer.allocUnsafeSlow()`][], and `new SlowBuffer(size)` are not zero-filled.
@@ -3256,9 +3502,15 @@ While there are clear performance advantages to using
 [`Buffer.allocUnsafe()`][], extra care *must* be taken in order to avoid
 introducing security vulnerabilities into an application.
 
+[ASCII]: https://en.wikipedia.org/wiki/ASCII
+[Base64]: https://en.wikipedia.org/wiki/Base64
+[ISO-8859-1]: https://en.wikipedia.org/wiki/ISO-8859-1
 [RFC 4648, Section 5]: https://tools.ietf.org/html/rfc4648#section-5
+[UTF-16]: https://en.wikipedia.org/wiki/UTF-16
+[UTF-8]: https://en.wikipedia.org/wiki/UTF-8
 [WHATWG Encoding Standard]: https://encoding.spec.whatwg.org/
 [`ArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+[`Blob`]: https://developer.mozilla.org/en-US/docs/Web/API/Blob
 [`Buffer.alloc()`]: #buffer_static_method_buffer_alloc_size_fill_encoding
 [`Buffer.allocUnsafe()`]: #buffer_static_method_buffer_allocunsafe_size
 [`Buffer.allocUnsafeSlow()`]: #buffer_static_method_buffer_allocunsafeslow_size
@@ -3269,18 +3521,18 @@ introducing security vulnerabilities into an application.
 [`Buffer.from(string)`]: #buffer_static_method_buffer_from_string_encoding
 [`Buffer.poolSize`]: #buffer_class_property_buffer_poolsize
 [`DataView`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView
-[`ERR_INVALID_BUFFER_SIZE`]: errors.html#ERR_INVALID_BUFFER_SIZE
-[`ERR_INVALID_OPT_VALUE`]: errors.html#ERR_INVALID_OPT_VALUE
-[`ERR_OUT_OF_RANGE`]: errors.html#ERR_OUT_OF_RANGE
+[`ERR_INVALID_BUFFER_SIZE`]: errors.md#ERR_INVALID_BUFFER_SIZE
+[`ERR_INVALID_OPT_VALUE`]: errors.md#ERR_INVALID_OPT_VALUE
+[`ERR_OUT_OF_RANGE`]: errors.md#ERR_OUT_OF_RANGE
 [`JSON.stringify()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
 [`SharedArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer
-[`String#indexOf()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf
-[`String#lastIndexOf()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf
+[`String.prototype.indexOf()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf
+[`String.prototype.lastIndexOf()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf
 [`String.prototype.length`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length
 [`TypedArray.from()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
-[`TypedArray#set()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
-[`TypedArray#slice()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
-[`TypedArray#subarray()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+[`TypedArray.prototype.set()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+[`TypedArray.prototype.slice()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+[`TypedArray.prototype.subarray()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
 [`TypedArray`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
 [`Uint8Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
 [`buf.buffer`]: #buffer_buf_buffer
@@ -3296,12 +3548,9 @@ introducing security vulnerabilities into an application.
 [`buffer.constants.MAX_LENGTH`]: #buffer_buffer_constants_max_length
 [`buffer.constants.MAX_STRING_LENGTH`]: #buffer_buffer_constants_max_string_length
 [`buffer.kMaxLength`]: #buffer_buffer_kmaxlength
-[`util.inspect()`]: util.html#util_util_inspect_object_options
-[ASCII]: https://en.wikipedia.org/wiki/ASCII
-[Base64]: https://en.wikipedia.org/wiki/Base64
-[ISO-8859-1]: https://en.wikipedia.org/wiki/ISO-8859-1
-[UTF-8]: https://en.wikipedia.org/wiki/UTF-8
-[UTF-16]: https://en.wikipedia.org/wiki/UTF-16
+[`util.inspect()`]: util.md#util_util_inspect_object_options
+[`v8::TypedArray::kMaxLength`]: https://v8.github.io/api/head/classv8_1_1TypedArray.html#a54a48f4373da0850663c4393d843b9b0
+[base64url]: https://tools.ietf.org/html/rfc4648#section-5
 [binary strings]: https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary
 [endianness]: https://en.wikipedia.org/wiki/Endianness
 [iterator]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
diff --git a/doc/api/child_process.html b/doc/api/child_process.html
index dab73f9836d87e10b241b59e415560b3eab29ba0..305d53829eff71b5b82533887bfc5b6f696cdce8 100644
--- a/doc/api/child_process.html
+++ b/doc/api/child_process.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Child process | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Child process | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process active">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process active">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="child_process" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/child_process.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/child_process.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/child_process.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/child_process.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/child_process.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/child_process.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/child_process.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/child_process.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/child_process.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#child_process_child_process">Child process</a></span>
 <ul>
 <li><a href="#child_process_asynchronous_process_creation">Asynchronous process creation</a>
@@ -157,7 +170,13 @@
 <li><a href="#child_process_event_error">Event: <code>'error'</code></a></li>
 <li><a href="#child_process_event_exit">Event: <code>'exit'</code></a></li>
 <li><a href="#child_process_event_message">Event: <code>'message'</code></a></li>
-<li><a href="#child_process_subprocess_channel"><code>subprocess.channel</code></a></li>
+<li><a href="#child_process_event_spawn">Event: <code>'spawn'</code></a></li>
+<li><a href="#child_process_subprocess_channel"><code>subprocess.channel</code></a>
+<ul>
+<li><a href="#child_process_subprocess_channel_ref"><code>subprocess.channel.ref()</code></a></li>
+<li><a href="#child_process_subprocess_channel_unref"><code>subprocess.channel.unref()</code></a></li>
+</ul>
+</li>
 <li><a href="#child_process_subprocess_connected"><code>subprocess.connected</code></a></li>
 <li><a href="#child_process_subprocess_disconnect"><code>subprocess.disconnect()</code></a></li>
 <li><a href="#child_process_subprocess_exitcode"><code>subprocess.exitCode</code></a></li>
@@ -187,45 +206,46 @@
 <li><a href="#child_process_advanced_serialization">Advanced serialization</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Child process<span><a class="mark" href="#child_process_child_process" id="child_process_child_process">#</a></span></h1>
+        <h2>Child process<span><a class="mark" href="#child_process_child_process" id="child_process_child_process">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/child_process.js">lib/child_process.js</a></p>
-<p>The <code>child_process</code> module provides the ability to spawn child processes in
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/child_process.js">lib/child_process.js</a></p>
+<p>The <code>child_process</code> module provides the ability to spawn subprocesses in
 a manner that is similar, but not identical, to <a href="http://man7.org/linux/man-pages/man3/popen.3.html"><code>popen(3)</code></a>. This capability
 is primarily provided by the <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> function:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> ls = spawn(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
+<span class="hljs-keyword">const</span> ls = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
 
-ls.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`stderr: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`stderr: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
+ls.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
 <p>By default, pipes for <code>stdin</code>, <code>stdout</code>, and <code>stderr</code> are established between
-the parent Node.js process and the spawned child. These pipes have
-limited (and platform-specific) capacity. If the child process writes to
-stdout in excess of that limit without the output being captured, the child
-process will block waiting for the pipe buffer to accept more data. This is
+the parent Node.js process and the spawned subprocess. These pipes have
+limited (and platform-specific) capacity. If the subprocess writes to
+stdout in excess of that limit without the output being captured, the
+subprocess blocks waiting for the pipe buffer to accept more data. This is
 identical to the behavior of pipes in the shell. Use the <code>{ stdio: 'ignore' }</code>
 option if the output will not be consumed.</p>
-<p>The command lookup will be performed using <code>options.env.PATH</code> environment
-variable if passed in <code>options</code> object, otherwise <code>process.env.PATH</code> will be
-used. To account for the fact that Windows environment variables are
-case-insensitive Node.js will lexicographically sort all <code>env</code> keys and choose
-the first one case-insensitively matching <code>PATH</code> to perform command lookup.
-This may lead to issues on Windows when passing objects to <code>env</code> option that
-have multiple variants of <code>PATH</code> variable.</p>
+<p>The command lookup is performed using the <code>options.env.PATH</code> environment
+variable if it is in the <code>options</code> object. Otherwise, <code>process.env.PATH</code> is
+used.</p>
+<p>On Windows, environment variables are case-insensitive. Node.js
+lexicographically sorts the <code>env</code> keys and uses the first one that
+case-insensitively matches. Only first (in lexicographic order) entry will be
+passed to the subprocess. This might lead to issues on Windows when passing
+objects to the <code>env</code> option that have multiple variants of the same key, such as
+<code>PATH</code> and <code>Path</code>.</p>
 <p>The <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> method spawns the child process asynchronously,
 without blocking the Node.js event loop. The <a href="#child_process_child_process_spawnsync_command_args_options"><code>child_process.spawnSync()</code></a>
 function provides equivalent functionality in a synchronous manner that blocks
@@ -253,18 +273,18 @@ sending messages between parent and child.</li>
 <a href="#child_process_synchronous_process_creation">synchronous counterparts</a> may be more convenient. In many cases, however,
 the synchronous methods can have significant impact on performance due to
 stalling the event loop while spawned processes complete.</p>
-<h2>Asynchronous process creation<span><a class="mark" href="#child_process_asynchronous_process_creation" id="child_process_asynchronous_process_creation">#</a></span></h2>
+<section><h3>Asynchronous process creation<span><a class="mark" href="#child_process_asynchronous_process_creation" id="child_process_asynchronous_process_creation">#</a></span></h3>
 <p>The <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>, <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>, <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a>,
 and <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a> methods all follow the idiomatic asynchronous
 programming pattern typical of other Node.js APIs.</p>
-<p>Each of the methods returns a <a href="#child_process_child_process"><code>ChildProcess</code></a> instance. These objects
+<p>Each of the methods returns a <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> instance. These objects
 implement the Node.js <a href="events.html#events_class_eventemitter"><code>EventEmitter</code></a> API, allowing the parent process to
 register listener functions that are called when certain events occur during
 the life cycle of the child process.</p>
 <p>The <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a> and <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a> methods
 additionally allow for an optional <code>callback</code> function to be specified that is
 invoked when the child process terminates.</p>
-<h3>Spawning <code>.bat</code> and <code>.cmd</code> files on Windows<span><a class="mark" href="#child_process_spawning_bat_and_cmd_files_on_windows" id="child_process_spawning_bat_and_cmd_files_on_windows">#</a></span></h3>
+<h4>Spawning <code>.bat</code> and <code>.cmd</code> files on Windows<span><a class="mark" href="#child_process_spawning_bat_and_cmd_files_on_windows" id="child_process_spawning_bat_and_cmd_files_on_windows">#</a></span></h4>
 <p>The importance of the distinction between <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a> and
 <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a> can vary based on platform. On Unix-type
 operating systems (Unix, Linux, macOS) <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a> can be
@@ -279,40 +299,44 @@ When running on Windows, <code>.bat</code> and <code>.cmd</code> files can be in
 spaces it needs to be quoted.</p>
 <pre><code class="language-js"><span class="hljs-comment">// On Windows Only...</span>
 <span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> bat = spawn(<span class="hljs-string">'cmd.exe'</span>, [<span class="hljs-string">'/c'</span>, <span class="hljs-string">'my.bat'</span>]);
+<span class="hljs-keyword">const</span> bat = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'cmd.exe'</span>, [<span class="hljs-string">'/c'</span>, <span class="hljs-string">'my.bat'</span>]);
 
-bat.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(data.toString());
+bat.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>());
 });
 
-bat.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(data.toString());
+bat.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(data.<span class="hljs-title function_">toString</span>());
 });
 
-bat.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Child exited with code <span class="hljs-subst">${code}</span>`</span>);
+bat.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Child exited with code <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// OR...</span>
 <span class="hljs-keyword">const</span> { exec, spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-exec(<span class="hljs-string">'my.bat'</span>, <span class="hljs-function">(<span class="hljs-params">err, stdout, stderr</span>) =></span> {
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'my.bat'</span>, <span class="hljs-function">(<span class="hljs-params">err, stdout, stderr</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
     <span class="hljs-keyword">return</span>;
   }
-  <span class="hljs-built_in">console</span>.log(stdout);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stdout);
 });
 
 <span class="hljs-comment">// Script with spaces in the filename:</span>
-<span class="hljs-keyword">const</span> bat = spawn(<span class="hljs-string">'"my script.cmd"'</span>, [<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>], { <span class="hljs-attr">shell</span>: <span class="hljs-literal">true</span> });
+<span class="hljs-keyword">const</span> bat = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'"my script.cmd"'</span>, [<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>], { <span class="hljs-attr">shell</span>: <span class="hljs-literal">true</span> });
 <span class="hljs-comment">// or:</span>
-exec(<span class="hljs-string">'"my script.cmd" a b'</span>, <span class="hljs-function">(<span class="hljs-params">err, stdout, stderr</span>) =></span> {
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'"my script.cmd" a b'</span>, <span class="hljs-function">(<span class="hljs-params">err, stdout, stderr</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
-<h3><code>child_process.exec(command[, options][, callback])</code><span><a class="mark" href="#child_process_child_process_exec_command_options_callback" id="child_process_child_process_exec_command_options_callback">#</a></span></h3>
+<h4><code>child_process.exec(command[, options][, callback])</code><span><a class="mark" href="#child_process_child_process_exec_command_options_callback" id="child_process_child_process_exec_command_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
 <tr><td>v8.8.0</td>
 <td><p>The <code>windowsHide</code> option is supported now.</p></td></tr>
 <tr><td>v0.1.90</td>
@@ -324,13 +348,15 @@ exec(<span class="hljs-string">'"my script.cmd" a b'</span>, <span class="hljs-f
 <li><code>command</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The command to run, with space-separated arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.
-<strong>Default:</strong> <code>null</code>.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.
+<strong>Default:</strong> <code>process.cwd()</code>.</li>
 <li><code>env</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Environment key-value pairs. <strong>Default:</strong> <code>process.env</code>.</li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 <li><code>shell</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Shell to execute the command with. See
 <a href="#child_process_shell_requirements">Shell requirements</a> and <a href="#child_process_default_windows_shell">Default Windows shell</a>. <strong>Default:</strong>
 <code>'/bin/sh'</code> on Unix, <code>process.env.ComSpec</code> on Windows.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting the child process using an
+AbortSignal.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>0</code></li>
 <li><code>maxBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Largest amount of data in bytes allowed on stdout or
 stderr. If exceeded, the child process is terminated and any output is
@@ -357,11 +383,13 @@ generated output. The <code>command</code> string passed to the exec function is
 directly by the shell and special characters (vary based on
 <a href="https://en.wikipedia.org/wiki/List_of_command-line_interpreters">shell</a>)
 need to be dealt with accordingly:</p>
-<pre><code class="language-js">exec(<span class="hljs-string">'"/path/to/test file/test.sh" arg1 arg2'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { exec } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'"/path/to/test file/test.sh" arg1 arg2'</span>);
 <span class="hljs-comment">// Double quotes are used so that the space in the path is not interpreted as</span>
 <span class="hljs-comment">// a delimiter of multiple arguments.</span>
 
-exec(<span class="hljs-string">'echo "The \\$HOME variable is $HOME"'</span>);
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'echo "The \\$HOME variable is $HOME"'</span>);
 <span class="hljs-comment">// The $HOME variable is escaped in the first instance, but not in the second.</span></code></pre>
 <p><strong>Never pass unsanitized user input to this function. Any input containing shell
 metacharacters may be used to trigger arbitrary command execution.</strong></p>
@@ -378,13 +406,13 @@ can be used to specify the character encoding used to decode the stdout and
 stderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character
 encoding, <code>Buffer</code> objects will be passed to the callback instead.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { exec } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-exec(<span class="hljs-string">'cat *.js missing_file | wc -l'</span>, <span class="hljs-function">(<span class="hljs-params">error, stdout, stderr</span>) =></span> {
+<span class="hljs-title function_">exec</span>(<span class="hljs-string">'cat *.js missing_file | wc -l'</span>, <span class="hljs-function">(<span class="hljs-params">error, stdout, stderr</span>) =></span> {
   <span class="hljs-keyword">if</span> (error) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`exec error: <span class="hljs-subst">${error}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`exec error: <span class="hljs-subst">${error}</span>`</span>);
     <span class="hljs-keyword">return</span>;
   }
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stdout: <span class="hljs-subst">${stdout}</span>`</span>);
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`stderr: <span class="hljs-subst">${stderr}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stdout: <span class="hljs-subst">${stdout}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`stderr: <span class="hljs-subst">${stderr}</span>`</span>);
 });</code></pre>
 <p>If <code>timeout</code> is greater than <code>0</code>, the parent will send the signal
 identified by the <code>killSignal</code> property (the default is <code>'SIGTERM'</code>) if the
@@ -398,19 +426,33 @@ case of an error (including any error resulting in an exit code other than 0), a
 rejected promise is returned, with the same <code>error</code> object given in the
 callback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> exec = util.promisify(<span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).exec);
+<span class="hljs-keyword">const</span> exec = util.<span class="hljs-title function_">promisify</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).<span class="hljs-property">exec</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">lsExample</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> { stdout, stderr } = <span class="hljs-keyword">await</span> exec(<span class="hljs-string">'ls'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'stdout:'</span>, stdout);
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'stderr:'</span>, stderr);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">lsExample</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> { stdout, stderr } = <span class="hljs-keyword">await</span> <span class="hljs-title function_">exec</span>(<span class="hljs-string">'ls'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'stdout:'</span>, stdout);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'stderr:'</span>, stderr);
 }
-lsExample();</code></pre>
-<h3><code>child_process.execFile(file[, args][, options][, callback])</code><span><a class="mark" href="#child_process_child_process_execfile_file_args_options_callback" id="child_process_child_process_execfile_file_args_options_callback">#</a></span></h3>
+<span class="hljs-title function_">lsExample</span>();</code></pre>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except
+the error passed to the callback will be an <code>AbortError</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { exec } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> child = <span class="hljs-title function_">exec</span>(<span class="hljs-string">'grep ssh'</span>, { signal }, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(error); <span class="hljs-comment">// an AbortError</span>
+});
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<h4><code>child_process.execFile(file[, args][, options][, callback])</code><span><a class="mark" href="#child_process_child_process_execfile_file_args_options_callback" id="child_process_child_process_execfile_file_args_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
 <tr><td>v8.8.0</td>
 <td><p>The <code>windowsHide</code> option is supported now.</p></td></tr>
 <tr><td>v0.1.91</td>
@@ -423,7 +465,7 @@ lsExample();</code></pre>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>env</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Environment key-value pairs. <strong>Default:</strong> <code>process.env</code>.</li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>0</code></li>
@@ -442,6 +484,8 @@ done on Windows. Ignored on Unix. <strong>Default:</strong> <code>false</code>.<
 <code>'/bin/sh'</code> on Unix, and <code>process.env.ComSpec</code> on Windows. A different
 shell can be specified as a string. See <a href="#child_process_shell_requirements">Shell requirements</a> and
 <a href="#child_process_default_windows_shell">Default Windows shell</a>. <strong>Default:</strong> <code>false</code> (no shell).</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting the child process using an
+AbortSignal.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called with the output when process terminates.
@@ -461,11 +505,11 @@ efficient than <a href="#child_process_child_process_exec_command_options_callba
 not spawned, behaviors such as I/O redirection and file globbing are not
 supported.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { execFile } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> child = execFile(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>], <span class="hljs-function">(<span class="hljs-params">error, stdout, stderr</span>) =></span> {
+<span class="hljs-keyword">const</span> child = <span class="hljs-title function_">execFile</span>(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>], <span class="hljs-function">(<span class="hljs-params">error, stdout, stderr</span>) =></span> {
   <span class="hljs-keyword">if</span> (error) {
     <span class="hljs-keyword">throw</span> error;
   }
-  <span class="hljs-built_in">console</span>.log(stdout);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stdout);
 });</code></pre>
 <p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the
 stdout and stderr output of the child process. By default, Node.js will decode
@@ -480,21 +524,39 @@ case of an error (including any error resulting in an exit code other than 0), a
 rejected promise is returned, with the same <code>error</code> object given in the
 callback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> execFile = util.promisify(<span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).execFile);
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getVersion</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> { stdout } = <span class="hljs-keyword">await</span> execFile(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>]);
-  <span class="hljs-built_in">console</span>.log(stdout);
+<span class="hljs-keyword">const</span> execFile = util.<span class="hljs-title function_">promisify</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).<span class="hljs-property">execFile</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getVersion</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> { stdout } = <span class="hljs-keyword">await</span> <span class="hljs-title function_">execFile</span>(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stdout);
 }
-getVersion();</code></pre>
+<span class="hljs-title function_">getVersion</span>();</code></pre>
 <p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this
 function. Any input containing shell metacharacters may be used to trigger
 arbitrary command execution.</strong></p>
-<h3><code>child_process.fork(modulePath[, args][, options])</code><span><a class="mark" href="#child_process_child_process_fork_modulepath_args_options" id="child_process_child_process_fork_modulepath_args_options">#</a></span></h3>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except
+the error passed to the callback will be an <code>AbortError</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { execFile } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> child = <span class="hljs-title function_">execFile</span>(<span class="hljs-string">'node'</span>, [<span class="hljs-string">'--version'</span>], { signal }, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(error); <span class="hljs-comment">// an AbortError</span>
+});
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<h4><code>child_process.fork(modulePath[, args][, options])</code><span><a class="mark" href="#child_process_child_process_fork_modulepath_args_options" id="child_process_child_process_fork_modulepath_args_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>timeout was added.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>killSignal for AbortSignal was added.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
+<tr><td>v13.2.0, v12.16.0</td>
 <td><p>The <code>serialization</code> option is supported now.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>stdio</code> option can now be a string.</p></td></tr>
@@ -510,7 +572,7 @@ arbitrary command execution.</strong></p>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>detached</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Prepare child to run independently of its parent
 process. Specific behavior depends on the platform, see
 <a href="#child_process_options_detached"><code>options.detached</code></a>).</li>
@@ -518,9 +580,14 @@ process. Specific behavior depends on the platform, see
 <li><code>execPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Executable used to create the child process.</li>
 <li><code>execArgv</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments passed to the executable.
 <strong>Default:</strong> <code>process.execArgv</code>.</li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the group identity of the process (see <a href="http://man7.org/linux/man-pages/man2/setgid.2.html"><code>setgid(2)</code></a>).</li>
 <li><code>serialization</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Specify the kind of serialization used for sending
 messages between processes. Possible values are <code>'json'</code> and <code>'advanced'</code>.
 See <a href="#child_process_advanced_serialization">Advanced serialization</a> for more details. <strong>Default:</strong> <code>'json'</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Allows closing the child process using an
+AbortSignal.</li>
+<li><code>killSignal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The signal value to be used when the spawned
+process will be killed by timeout or abort signal. <strong>Default:</strong> <code>'SIGTERM'</code>.</li>
 <li><code>silent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, stdin, stdout, and stderr of the child will be
 piped to the parent, otherwise they will be inherited from the parent, see
 the <code>'pipe'</code> and <code>'inherit'</code> options for <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>'s
@@ -529,18 +596,19 @@ the <code>'pipe'</code> and <code>'inherit'</code> options for <a href="#child_p
 When this option is provided, it overrides <code>silent</code>. If the array variant
 is used, it must contain exactly one item with value <code>'ipc'</code> or an error
 will be thrown. For instance <code>[0, 1, 2, 'ipc']</code>.</li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the user identity of the process (see <a href="http://man7.org/linux/man-pages/man2/setuid.2.html"><code>setuid(2)</code></a>).</li>
 <li><code>windowsVerbatimArguments</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> No quoting or escaping of arguments is
 done on Windows. Ignored on Unix. <strong>Default:</strong> <code>false</code>.</li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the user identity of the process (see <a href="http://man7.org/linux/man-pages/man2/setuid.2.html"><code>setuid(2)</code></a>).</li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the group identity of the process (see <a href="http://man7.org/linux/man-pages/man2/setgid.2.html"><code>setgid(2)</code></a>).</li>
+<li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> In milliseconds the maximum amount of time the process
+is allowed to run. <strong>Default:</strong> <code>undefined</code>.</li>
 </ul>
 </li>
 <li>Returns: <a href="child_process.html#child_process_class_childprocess" class="type">&#x3C;ChildProcess></a></li>
 </ul>
 <p>The <code>child_process.fork()</code> method is a special case of
 <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> used specifically to spawn new Node.js processes.
-Like <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>, a <a href="#child_process_child_process"><code>ChildProcess</code></a> object is returned. The
-returned <a href="#child_process_child_process"><code>ChildProcess</code></a> will have an additional communication channel
+Like <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>, a <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> object is returned. The
+returned <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> will have an additional communication channel
 built-in that allows messages to be passed back and forth between the parent and
 child. See <a href="#child_process_subprocess_send_message_sendhandle_options_callback"><code>subprocess.send()</code></a> for details.</p>
 <p>Keep in mind that spawned Node.js child processes are
@@ -559,12 +627,37 @@ environment variable <code>NODE_CHANNEL_FD</code> on the child process.</p>
 current process.</p>
 <p>The <code>shell</code> option available in <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> is not supported by
 <code>child_process.fork()</code> and will be ignored if set.</p>
-<h3><code>child_process.spawn(command[, args][, options])</code><span><a class="mark" href="#child_process_child_process_spawn_command_args_options" id="child_process_child_process_spawn_command_args_options">#</a></span></h3>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except
+the error passed to the callback will be an <code>AbortError</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">argv</span>[<span class="hljs-number">2</span>] === <span class="hljs-string">'child'</span>) {
+  <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Hello from <span class="hljs-subst">${process.argv[<span class="hljs-number">2</span>]}</span>!`</span>);
+  }, <span class="hljs-number">1_000</span>);
+} <span class="hljs-keyword">else</span> {
+  <span class="hljs-keyword">const</span> { fork } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+  <span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+  <span class="hljs-keyword">const</span> { signal } = controller;
+  <span class="hljs-keyword">const</span> child = <span class="hljs-title function_">fork</span>(__filename, [<span class="hljs-string">'child'</span>], { signal });
+  child.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-comment">// This will be called with err being an AbortError if the controller aborts</span>
+  });
+  controller.<span class="hljs-title function_">abort</span>(); <span class="hljs-comment">// Stops the child process</span>
+}</code></pre>
+<h4><code>child_process.spawn(command[, args][, options])</code><span><a class="mark" href="#child_process_child_process_spawn_command_args_options" id="child_process_child_process_spawn_command_args_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>timeout was added.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>killSignal for AbortSignal was added.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
+<tr><td>v13.2.0, v12.16.0</td>
 <td><p>The <code>serialization</code> option is supported now.</p></td></tr>
 <tr><td>v8.8.0</td>
 <td><p>The <code>windowsHide</code> option is supported now.</p></td></tr>
@@ -578,11 +671,16 @@ current process.</p>
 </details>
 </div>
 <ul>
-<li><code>command</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The command to run.</li>
-<li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li>
+<p><code>command</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The command to run.</p>
+</li>
+<li>
+<p><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</p>
+</li>
+<li>
+<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></p>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>env</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Environment key-value pairs. <strong>Default:</strong> <code>process.env</code>.</li>
 <li><code>argv0</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Explicitly set the value of <code>argv[0]</code> sent to the child
 process. This will be set to <code>command</code> if not specified.</li>
@@ -605,12 +703,20 @@ done on Windows. Ignored on Unix. This is set to <code>true</code> automatically
 when <code>shell</code> is specified and is CMD. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>windowsHide</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Hide the subprocess console window that would
 normally be created on Windows systems. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting the child process using an
+AbortSignal.</li>
+<li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> In milliseconds the maximum amount of time the process
+is allowed to run. <strong>Default:</strong> <code>undefined</code>.</li>
+<li><code>killSignal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The signal value to be used when the spawned
+process will be killed by timeout or abort signal. <strong>Default:</strong> <code>'SIGTERM'</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="child_process.html#child_process_class_childprocess" class="type">&#x3C;ChildProcess></a></li>
+<li>
+<p>Returns: <a href="child_process.html#child_process_class_childprocess" class="type">&#x3C;ChildProcess></a></p>
+</li>
 </ul>
 <p>The <code>child_process.spawn()</code> method spawns a new process using the given
-<code>command</code>, with command line arguments in <code>args</code>. If omitted, <code>args</code> defaults
+<code>command</code>, with command-line arguments in <code>args</code>. If omitted, <code>args</code> defaults
 to an empty array.</p>
 <p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this
 function. Any input containing shell metacharacters may be used to trigger
@@ -618,68 +724,71 @@ arbitrary command execution.</strong></p>
 <p>A third argument may be used to specify additional options, with these defaults:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> defaults = {
   <span class="hljs-attr">cwd</span>: <span class="hljs-literal">undefined</span>,
-  <span class="hljs-attr">env</span>: process.env
+  <span class="hljs-attr">env</span>: process.<span class="hljs-property">env</span>
 };</code></pre>
 <p>Use <code>cwd</code> to specify the working directory from which the process is spawned.
-If not given, the default is to inherit the current working directory.</p>
+If not given, the default is to inherit the current working directory. If given,
+but the path does not exist, the child process emits an <code>ENOENT</code> error
+and exits immediately. <code>ENOENT</code> is also emitted when the command
+does not exist.</p>
 <p>Use <code>env</code> to specify environment variables that will be visible to the new
 process, the default is <a href="process.html#process_process_env"><code>process.env</code></a>.</p>
 <p><code>undefined</code> values in <code>env</code> will be ignored.</p>
 <p>Example of running <code>ls -lh /usr</code>, capturing <code>stdout</code>, <code>stderr</code>, and the
 exit code:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> ls = spawn(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
+<span class="hljs-keyword">const</span> ls = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
 
-ls.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`stderr: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`stderr: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
+ls.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
 <p>Example: A very elaborate way to run <code>ps ax | grep ssh</code></p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> ps = spawn(<span class="hljs-string">'ps'</span>, [<span class="hljs-string">'ax'</span>]);
-<span class="hljs-keyword">const</span> grep = spawn(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
+<span class="hljs-keyword">const</span> ps = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ps'</span>, [<span class="hljs-string">'ax'</span>]);
+<span class="hljs-keyword">const</span> grep = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
 
-ps.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  grep.stdin.write(data);
+ps.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  grep.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">write</span>(data);
 });
 
-ps.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`ps stderr: <span class="hljs-subst">${data}</span>`</span>);
+ps.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`ps stderr: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ps.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+ps.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
   <span class="hljs-keyword">if</span> (code !== <span class="hljs-number">0</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`ps process exited with code <span class="hljs-subst">${code}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`ps process exited with code <span class="hljs-subst">${code}</span>`</span>);
   }
-  grep.stdin.end();
+  grep.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">end</span>();
 });
 
-grep.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(data.toString());
+grep.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>());
 });
 
-grep.stderr.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`grep stderr: <span class="hljs-subst">${data}</span>`</span>);
+grep.<span class="hljs-property">stderr</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`grep stderr: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-grep.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+grep.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
   <span class="hljs-keyword">if</span> (code !== <span class="hljs-number">0</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`grep process exited with code <span class="hljs-subst">${code}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`grep process exited with code <span class="hljs-subst">${code}</span>`</span>);
   }
 });</code></pre>
 <p>Example of checking for failed <code>spawn</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> subprocess = spawn(<span class="hljs-string">'bad_command'</span>);
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'bad_command'</span>);
 
-subprocess.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Failed to start subprocess.'</span>);
+subprocess.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Failed to start subprocess.'</span>);
 });</code></pre>
 <p>Certain platforms (macOS, Linux) will use the value of <code>argv[0]</code> for the process
 title while others (Windows, SunOS) will use <code>command</code>.</p>
@@ -687,7 +796,18 @@ title while others (Windows, SunOS) will use <code>command</code>.</p>
 <code>process.argv[0]</code> in a Node.js child process will not match the <code>argv0</code>
 parameter passed to <code>spawn</code> from the parent, retrieve it with the
 <code>process.argv0</code> property instead.</p>
-<h4><code>options.detached</code><span><a class="mark" href="#child_process_options_detached" id="child_process_options_detached">#</a></span></h4>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except
+the error passed to the callback will be an <code>AbortError</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> grep = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>], { signal });
+grep.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-comment">// This will be called with err being an AbortError if the controller aborts</span>
+});
+controller.<span class="hljs-title function_">abort</span>(); <span class="hljs-comment">// Stops the child process</span></code></pre>
+<h5><code>options.detached</code><span><a class="mark" href="#child_process_options_detached" id="child_process_options_detached">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.7.10</span>
 </div>
@@ -714,29 +834,31 @@ controlling terminal.</p>
 <code>stdio</code> file descriptors, in order to ignore the parent's termination:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(process.argv[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(process.<span class="hljs-property">argv</span>[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
   <span class="hljs-attr">detached</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">stdio</span>: <span class="hljs-string">'ignore'</span>
 });
 
-subprocess.unref();</code></pre>
+subprocess.<span class="hljs-title function_">unref</span>();</code></pre>
 <p>Alternatively one can redirect the child process' output into files:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> out = fs.openSync(<span class="hljs-string">'./out.log'</span>, <span class="hljs-string">'a'</span>);
-<span class="hljs-keyword">const</span> err = fs.openSync(<span class="hljs-string">'./out.log'</span>, <span class="hljs-string">'a'</span>);
+<span class="hljs-keyword">const</span> out = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'./out.log'</span>, <span class="hljs-string">'a'</span>);
+<span class="hljs-keyword">const</span> err = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'./out.log'</span>, <span class="hljs-string">'a'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(<span class="hljs-string">'prg'</span>, [], {
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'prg'</span>, [], {
   <span class="hljs-attr">detached</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">stdio</span>: [ <span class="hljs-string">'ignore'</span>, out, err ]
 });
 
-subprocess.unref();</code></pre>
-<h4><code>options.stdio</code><span><a class="mark" href="#child_process_options_stdio" id="child_process_options_stdio">#</a></span></h4>
+subprocess.<span class="hljs-title function_">unref</span>();</code></pre>
+<h5><code>options.stdio</code><span><a class="mark" href="#child_process_options_stdio" id="child_process_options_stdio">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Added the <code>overlapped</code> stdio flag.</p></td></tr>
 <tr><td>v3.3.1</td>
 <td><p>The value <code>0</code> is now accepted as a file descriptor.</p></td></tr>
 <tr><td>v0.7.10</td>
@@ -748,11 +870,12 @@ subprocess.unref();</code></pre>
 between the parent and child process. By default, the child's stdin, stdout,
 and stderr are redirected to corresponding <a href="#child_process_subprocess_stdin"><code>subprocess.stdin</code></a>,
 <a href="#child_process_subprocess_stdout"><code>subprocess.stdout</code></a>, and <a href="#child_process_subprocess_stderr"><code>subprocess.stderr</code></a> streams on the
-<a href="#child_process_child_process"><code>ChildProcess</code></a> object. This is equivalent to setting the <code>options.stdio</code>
+<a href="#child_process_class_childprocess"><code>ChildProcess</code></a> object. This is equivalent to setting the <code>options.stdio</code>
 equal to <code>['pipe', 'pipe', 'pipe']</code>.</p>
 <p>For convenience, <code>options.stdio</code> may be one of the following strings:</p>
 <ul>
 <li><code>'pipe'</code>: equivalent to <code>['pipe', 'pipe', 'pipe']</code> (the default)</li>
+<li><code>'overlapped'</code>: equivalent to <code>['overlapped', 'overlapped', 'overlapped']</code></li>
 <li><code>'ignore'</code>: equivalent to <code>['ignore', 'ignore', 'ignore']</code></li>
 <li><code>'inherit'</code>: equivalent to <code>['inherit', 'inherit', 'inherit']</code> or <code>[0, 1, 2]</code></li>
 </ul>
@@ -769,8 +892,16 @@ created for fds 0, 1, and 2 are also available as <a href="#child_process_subpro
 <a href="#child_process_subprocess_stdout"><code>subprocess.stdout</code></a> and <a href="#child_process_subprocess_stderr"><code>subprocess.stderr</code></a>, respectively.</p>
 </li>
 <li>
+<p><code>'overlapped'</code>: Same as <code>'pipe'</code> except that the <code>FILE_FLAG_OVERLAPPED</code> flag
+is set on the handle. This is necessary for overlapped I/O on the child
+process's stdio handles. See the
+<a href="https://docs.microsoft.com/en-us/windows/win32/fileio/synchronous-and-asynchronous-i-o">docs</a>
+for more details. This is exactly the same as <code>'pipe'</code> on non-Windows
+systems.</p>
+</li>
+<li>
 <p><code>'ipc'</code>: Create an IPC channel for passing messages/file descriptors
-between parent and child. A <a href="#child_process_child_process"><code>ChildProcess</code></a> may have at most one IPC
+between parent and child. A <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> may have at most one IPC
 stdio file descriptor. Setting this option enables the
 <a href="#child_process_subprocess_send_message_sendhandle_options_callback"><code>subprocess.send()</code></a> method. If the child is a Node.js process, the
 presence of an IPC channel will enable <a href="process.html#process_process_send_message_sendhandle_options_callback"><code>process.send()</code></a> and
@@ -815,14 +946,14 @@ default is <code>'ignore'</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
 <span class="hljs-comment">// Child will use parent's stdios.</span>
-spawn(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: <span class="hljs-string">'inherit'</span> });
+<span class="hljs-title function_">spawn</span>(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: <span class="hljs-string">'inherit'</span> });
 
 <span class="hljs-comment">// Spawn child sharing only stderr.</span>
-spawn(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'pipe'</span>, <span class="hljs-string">'pipe'</span>, process.stderr] });
+<span class="hljs-title function_">spawn</span>(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'pipe'</span>, <span class="hljs-string">'pipe'</span>, process.<span class="hljs-property">stderr</span>] });
 
 <span class="hljs-comment">// Open an extra fd=4, to interact with programs presenting a</span>
 <span class="hljs-comment">// startd-style interface.</span>
-spawn(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'pipe'</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>, <span class="hljs-string">'pipe'</span>] });</code></pre>
+<span class="hljs-title function_">spawn</span>(<span class="hljs-string">'prg'</span>, [], { <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'pipe'</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>, <span class="hljs-string">'pipe'</span>] });</code></pre>
 <p><em>It is worth noting that when an IPC channel is established between the
 parent and child processes, and the child is a Node.js process, the child
 is launched with the IPC channel unreferenced (using <code>unref()</code>) until the
@@ -835,7 +966,7 @@ from the child. Applications with a large memory footprint may find frequent
 <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a> calls to be a bottleneck. For more information,
 see <a href="https://bugs.chromium.org/p/v8/issues/detail?id=7381">V8 issue 7381</a>.</p>
 <p>See also: <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a> and <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p>
-<h2>Synchronous process creation<span><a class="mark" href="#child_process_synchronous_process_creation" id="child_process_synchronous_process_creation">#</a></span></h2>
+</section><section><h3>Synchronous process creation<span><a class="mark" href="#child_process_synchronous_process_creation" id="child_process_synchronous_process_creation">#</a></span></h3>
 <p>The <a href="#child_process_child_process_spawnsync_command_args_options"><code>child_process.spawnSync()</code></a>, <a href="#child_process_child_process_execsync_command_options"><code>child_process.execSync()</code></a>, and
 <a href="#child_process_child_process_execfilesync_file_args_options"><code>child_process.execFileSync()</code></a> methods are synchronous and will block the
 Node.js event loop, pausing execution of any additional code until the spawned
@@ -843,11 +974,13 @@ process exits.</p>
 <p>Blocking calls like these are mostly useful for simplifying general-purpose
 scripting tasks and for simplifying the loading/processing of application
 configuration at startup.</p>
-<h3><code>child_process.execFileSync(file[, args][, options])</code><span><a class="mark" href="#child_process_child_process_execfilesync_file_args_options" id="child_process_child_process_execfilesync_file_args_options">#</a></span></h3>
+<h4><code>child_process.execFileSync(file[, args][, options])</code><span><a class="mark" href="#child_process_child_process_execfilesync_file_args_options" id="child_process_child_process_execfilesync_file_args_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>input</code> option can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v8.8.0</td>
@@ -866,7 +999,7 @@ configuration at startup.</p>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The value which will be passed
 as stdin to the spawned process. Supplying this value will override
 <code>stdio[0]</code>.</li>
@@ -909,11 +1042,13 @@ exited.</p>
 <p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this
 function. Any input containing shell metacharacters may be used to trigger
 arbitrary command execution.</strong></p>
-<h3><code>child_process.execSync(command[, options])</code><span><a class="mark" href="#child_process_child_process_execsync_command_options" id="child_process_child_process_execsync_command_options">#</a></span></h3>
+<h4><code>child_process.execSync(command[, options])</code><span><a class="mark" href="#child_process_child_process_execsync_command_options" id="child_process_child_process_execsync_command_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>input</code> option can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v8.8.0</td>
@@ -929,7 +1064,7 @@ arbitrary command execution.</strong></p>
 <li><code>command</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The command to run.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The value which will be passed
 as stdin to the spawned process. Supplying this value will override
 <code>stdio[0]</code>.</li>
@@ -970,21 +1105,23 @@ The <a href="errors.html#errors_class_error"><code>Error</code></a> object will
 <a href="#child_process_child_process_spawnsync_command_args_options"><code>child_process.spawnSync()</code></a>.</p>
 <p><strong>Never pass unsanitized user input to this function. Any input containing shell
 metacharacters may be used to trigger arbitrary command execution.</strong></p>
-<h3><code>child_process.spawnSync(command[, args][, options])</code><span><a class="mark" href="#child_process_child_process_spawnsync_command_args_options" id="child_process_child_process_spawnsync_command_args_options">#</a></span></h3>
+<h4><code>child_process.spawnSync(command[, args][, options])</code><span><a class="mark" href="#child_process_child_process_spawnsync_command_args_options" id="child_process_child_process_spawnsync_command_args_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>cwd</code> option can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>input</code> option can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v8.8.0</td>
 <td><p>The <code>windowsHide</code> option is supported now.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>input</code> option can now be a <code>Uint8Array</code>.</p></td></tr>
-<tr><td>v6.2.1, v4.5.0</td>
-<td><p>The <code>encoding</code> option can now explicitly be set to <code>buffer</code>.</p></td></tr>
 <tr><td>v5.7.0</td>
 <td><p>The <code>shell</code> option is supported now.</p></td></tr>
+<tr><td>v6.2.1, v4.5.0</td>
+<td><p>The <code>encoding</code> option can now explicitly be set to <code>buffer</code>.</p></td></tr>
 <tr><td>v0.11.12</td>
 <td><p><span>Added in: v0.11.12</span></p></td></tr>
 </tbody></table>
@@ -995,7 +1132,7 @@ metacharacters may be used to trigger arbitrary command execution.</strong></p>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> List of string arguments.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Current working directory of the child process.</li>
+<li><code>cwd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> Current working directory of the child process.</li>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The value which will be passed
 as stdin to the spawned process. Supplying this value will override
 <code>stdio[0]</code>.</li>
@@ -1050,7 +1187,7 @@ exited.</p>
 <p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this
 function. Any input containing shell metacharacters may be used to trigger
 arbitrary command execution.</strong></p>
-<h2>Class: <code>ChildProcess</code><span><a class="mark" href="#child_process_class_childprocess" id="child_process_class_childprocess">#</a></span></h2>
+</section><section><h3>Class: <code>ChildProcess</code><span><a class="mark" href="#child_process_class_childprocess" id="child_process_class_childprocess">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.2.0</span>
 </div>
@@ -1062,7 +1199,7 @@ arbitrary command execution.</strong></p>
 use the <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>, <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a>,
 <a href="#child_process_child_process_execfile_file_args_options_callback"><code>child_process.execFile()</code></a>, or <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a> methods to create
 instances of <code>ChildProcess</code>.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#child_process_event_close" id="child_process_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#child_process_event_close" id="child_process_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -1070,24 +1207,26 @@ instances of <code>ChildProcess</code>.</p>
 <li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The exit code if the child exited on its own.</li>
 <li><code>signal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The signal by which the child process was terminated.</li>
 </ul>
-<p>The <code>'close'</code> event is emitted when the stdio streams of a child process have
-been closed. This is distinct from the <a href="#child_process_event_exit"><code>'exit'</code></a> event, since multiple
-processes might share the same stdio streams.</p>
+<p>The <code>'close'</code> event is emitted after a process has ended <em>and</em> the stdio
+streams of a child process have been closed. This is distinct from the
+<a href="#child_process_event_exit"><code>'exit'</code></a> event, since multiple processes might share the same stdio
+streams. The <code>'close'</code> event will always emit after <a href="#child_process_event_exit"><code>'exit'</code></a> was
+already emitted, or <a href="#child_process_event_error"><code>'error'</code></a> if the child failed to spawn.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> ls = spawn(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
+<span class="hljs-keyword">const</span> ls = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>, [<span class="hljs-string">'-lh'</span>, <span class="hljs-string">'/usr'</span>]);
 
-ls.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
+ls.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stdout: <span class="hljs-subst">${data}</span>`</span>);
 });
 
-ls.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`child process close all stdio with code <span class="hljs-subst">${code}</span>`</span>);
+ls.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`child process close all stdio with code <span class="hljs-subst">${code}</span>`</span>);
 });
 
-ls.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
+ls.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`child process exited with code <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
-<h3>Event: <code>'disconnect'</code><span><a class="mark" href="#child_process_event_disconnect" id="child_process_event_disconnect">#</a></span></h3>
+<h4>Event: <code>'disconnect'</code><span><a class="mark" href="#child_process_event_disconnect" id="child_process_event_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -1096,7 +1235,7 @@ ls.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<spa
 <a href="process.html#process_process_disconnect"><code>process.disconnect()</code></a> in child process. After disconnecting it is no longer
 possible to send or receive messages, and the <a href="#child_process_subprocess_connected"><code>subprocess.connected</code></a>
 property is <code>false</code>.</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#child_process_event_error" id="child_process_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#child_process_event_error" id="child_process_event_error">#</a></span></h4>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> The error.</li>
 </ul>
@@ -1110,7 +1249,7 @@ property is <code>false</code>.</p>
 listening to both the <code>'exit'</code> and <code>'error'</code> events, guard
 against accidentally invoking handler functions multiple times.</p>
 <p>See also <a href="#child_process_subprocess_kill_signal"><code>subprocess.kill()</code></a> and <a href="#child_process_subprocess_send_message_sendhandle_options_callback"><code>subprocess.send()</code></a>.</p>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#child_process_event_exit" id="child_process_event_exit">#</a></span></h3>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#child_process_event_exit" id="child_process_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1129,7 +1268,7 @@ processes will not terminate immediately due to receipt of those signals.
 Rather, Node.js will perform a sequence of cleanup actions and then will
 re-raise the handled signal.</p>
 <p>See <a href="http://man7.org/linux/man-pages/man2/waitpid.2.html"><code>waitpid(2)</code></a>.</p>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#child_process_event_message" id="child_process_event_message">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#child_process_event_message" id="child_process_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -1146,16 +1285,49 @@ message might not be the same as what is originally sent.</p>
 child process, the <code>message</code> argument can contain data that JSON is not able
 to represent.
 See <a href="#child_process_advanced_serialization">Advanced serialization</a> for more details.</p>
-<h3><code>subprocess.channel</code><span><a class="mark" href="#child_process_subprocess_channel" id="child_process_subprocess_channel">#</a></span></h3>
+<h4>Event: <code>'spawn'</code><span><a class="mark" href="#child_process_event_spawn" id="child_process_event_spawn">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v7.1.0</span>
+<span>Added in: v14.17.0</span>
+</div>
+<p>The <code>'spawn'</code> event is emitted once the child process has spawned successfully.
+If the child process does not spawn successfully, the <code>'spawn'</code> event is not
+emitted and the <code>'error'</code> event is emitted instead.</p>
+<p>If emitted, the <code>'spawn'</code> event comes before all other events and before any
+data is received via <code>stdout</code> or <code>stderr</code>.</p>
+<p>The <code>'spawn'</code> event will fire regardless of whether an error occurs <strong>within</strong>
+the spawned process. For example, if <code>bash some-command</code> spawns successfully,
+the <code>'spawn'</code> event will fire, though <code>bash</code> may fail to spawn <code>some-command</code>.
+This caveat also applies when using <code>{ shell: true }</code>.</p>
+<h4><code>subprocess.channel</code><span><a class="mark" href="#child_process_subprocess_channel" id="child_process_subprocess_channel">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The object no longer accidentally exposes native C++ bindings.</p></td></tr>
+<tr><td>v7.1.0</td>
+<td><p><span>Added in: v7.1.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> A pipe representing the IPC channel to the child process.</li>
 </ul>
 <p>The <code>subprocess.channel</code> property is a reference to the child's IPC channel. If
 no IPC channel currently exists, this property is <code>undefined</code>.</p>
-<h3><code>subprocess.connected</code><span><a class="mark" href="#child_process_subprocess_connected" id="child_process_subprocess_connected">#</a></span></h3>
+<h5><code>subprocess.channel.ref()</code><span><a class="mark" href="#child_process_subprocess_channel_ref" id="child_process_subprocess_channel_ref">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v7.1.0</span>
+</div>
+<p>This method makes the IPC channel keep the event loop of the parent process
+running if <code>.unref()</code> has been called before.</p>
+<h5><code>subprocess.channel.unref()</code><span><a class="mark" href="#child_process_subprocess_channel_unref" id="child_process_subprocess_channel_unref">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v7.1.0</span>
+</div>
+<p>This method makes the IPC channel not keep the event loop of the parent process
+running, and lets it finish even while the channel is open.</p>
+<h4><code>subprocess.connected</code><span><a class="mark" href="#child_process_subprocess_connected" id="child_process_subprocess_connected">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -1165,7 +1337,7 @@ no IPC channel currently exists, this property is <code>undefined</code>.</p>
 <p>The <code>subprocess.connected</code> property indicates whether it is still possible to
 send and receive messages from a child process. When <code>subprocess.connected</code> is
 <code>false</code>, it is no longer possible to send or receive messages.</p>
-<h3><code>subprocess.disconnect()</code><span><a class="mark" href="#child_process_subprocess_disconnect" id="child_process_subprocess_disconnect">#</a></span></h3>
+<h4><code>subprocess.disconnect()</code><span><a class="mark" href="#child_process_subprocess_disconnect" id="child_process_subprocess_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -1180,13 +1352,13 @@ calling <code>subprocess.disconnect()</code>.</p>
 <p>When the child process is a Node.js instance (e.g. spawned using
 <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>), the <code>process.disconnect()</code> method can be invoked
 within the child process to close the IPC channel as well.</p>
-<h3><code>subprocess.exitCode</code><span><a class="mark" href="#child_process_subprocess_exitcode" id="child_process_subprocess_exitcode">#</a></span></h3>
+<h4><code>subprocess.exitCode</code><span><a class="mark" href="#child_process_subprocess_exitcode" id="child_process_subprocess_exitcode">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The <code>subprocess.exitCode</code> property indicates the exit code of the child process.
 If the child process is still running, the field will be <code>null</code>.</p>
-<h3><code>subprocess.kill([signal])</code><span><a class="mark" href="#child_process_subprocess_kill_signal" id="child_process_subprocess_kill_signal">#</a></span></h3>
+<h4><code>subprocess.kill([signal])</code><span><a class="mark" href="#child_process_subprocess_kill_signal" id="child_process_subprocess_kill_signal">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1199,16 +1371,16 @@ argument is given, the process will be sent the <code>'SIGTERM'</code> signal. S
 <a href="http://man7.org/linux/man-pages/man7/signal.7.html"><code>signal(7)</code></a> for a list of available signals. This function returns <code>true</code> if
 <a href="http://man7.org/linux/man-pages/man2/kill.2.html"><code>kill(2)</code></a> succeeds, and <code>false</code> otherwise.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> grep = spawn(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
+<span class="hljs-keyword">const</span> grep = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
 
-grep.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code, signal</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(
+grep.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">(<span class="hljs-params">code, signal</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
     <span class="hljs-string">`child process terminated due to receipt of signal <span class="hljs-subst">${signal}</span>`</span>);
 });
 
 <span class="hljs-comment">// Send SIGHUP to process.</span>
-grep.kill(<span class="hljs-string">'SIGHUP'</span>);</code></pre>
-<p>The <a href="#child_process_child_process"><code>ChildProcess</code></a> object may emit an <a href="#child_process_event_error"><code>'error'</code></a> event if the signal
+grep.<span class="hljs-title function_">kill</span>(<span class="hljs-string">'SIGHUP'</span>);</code></pre>
+<p>The <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> object may emit an <a href="#child_process_event_error"><code>'error'</code></a> event if the signal
 cannot be delivered. Sending a signal to a child process that has already exited
 is not an error but may have unforeseen consequences. Specifically, if the
 process identifier (PID) has been reassigned to another process, the signal will
@@ -1216,28 +1388,32 @@ be delivered to that process instead which can have unexpected results.</p>
 <p>While the function is called <code>kill</code>, the signal delivered to the child process
 may not actually terminate the process.</p>
 <p>See <a href="http://man7.org/linux/man-pages/man2/kill.2.html"><code>kill(2)</code></a> for reference.</p>
+<p>On Windows, where POSIX signals do not exist, the <code>signal</code> argument will be
+ignored, and the process will be killed forcefully and abruptly (similar to
+<code>'SIGKILL'</code>).
+See <a href="process.html#process_signal_events">Signal Events</a> for more details.</p>
 <p>On Linux, child processes of child processes will not be terminated
 when attempting to kill their parent. This is likely to happen when running a
 new process in a shell or with the use of the <code>shell</code> option of <code>ChildProcess</code>:</p>
 <pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
 <span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(
   <span class="hljs-string">'sh'</span>,
   [
     <span class="hljs-string">'-c'</span>,
     <span class="hljs-string">`node -e "setInterval(() => {
       console.log(process.pid, 'is alive')
-    }, 500);"`</span>
+    }, 500);"`</span>,
   ], {
     <span class="hljs-attr">stdio</span>: [<span class="hljs-string">'inherit'</span>, <span class="hljs-string">'inherit'</span>, <span class="hljs-string">'inherit'</span>]
   }
 );
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  subprocess.kill(); <span class="hljs-comment">// Does not terminate the Node.js process in the shell.</span>
+  subprocess.<span class="hljs-title function_">kill</span>(); <span class="hljs-comment">// Does not terminate the Node.js process in the shell.</span>
 }, <span class="hljs-number">2000</span>);</code></pre>
-<h3><code>subprocess.killed</code><span><a class="mark" href="#child_process_subprocess_killed" id="child_process_subprocess_killed">#</a></span></h3>
+<h4><code>subprocess.killed</code><span><a class="mark" href="#child_process_subprocess_killed" id="child_process_subprocess_killed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -1248,20 +1424,22 @@ send a signal to the child process.</li>
 <p>The <code>subprocess.killed</code> property indicates whether the child process
 successfully received a signal from <code>subprocess.kill()</code>. The <code>killed</code> property
 does not indicate that the child process has been terminated.</p>
-<h3><code>subprocess.pid</code><span><a class="mark" href="#child_process_subprocess_pid" id="child_process_subprocess_pid">#</a></span></h3>
+<h4><code>subprocess.pid</code><span><a class="mark" href="#child_process_subprocess_pid" id="child_process_subprocess_pid">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
 </ul>
-<p>Returns the process identifier (PID) of the child process.</p>
+<p>Returns the process identifier (PID) of the child process. If the child process
+fails to spawn due to errors, then the value is <code>undefined</code> and <code>error</code> is
+emitted.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> grep = spawn(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
+<span class="hljs-keyword">const</span> grep = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'grep'</span>, [<span class="hljs-string">'ssh'</span>]);
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Spawned child pid: <span class="hljs-subst">${grep.pid}</span>`</span>);
-grep.stdin.end();</code></pre>
-<h3><code>subprocess.ref()</code><span><a class="mark" href="#child_process_subprocess_ref" id="child_process_subprocess_ref">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Spawned child pid: <span class="hljs-subst">${grep.pid}</span>`</span>);
+grep.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">end</span>();</code></pre>
+<h4><code>subprocess.ref()</code><span><a class="mark" href="#child_process_subprocess_ref" id="child_process_subprocess_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.10</span>
 </div>
@@ -1270,14 +1448,14 @@ restore the removed reference count for the child process, forcing the parent
 to wait for the child to exit before exiting itself.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(process.argv[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(process.<span class="hljs-property">argv</span>[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
   <span class="hljs-attr">detached</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">stdio</span>: <span class="hljs-string">'ignore'</span>
 });
 
-subprocess.unref();
-subprocess.ref();</code></pre>
-<h3><code>subprocess.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#child_process_subprocess_send_message_sendhandle_options_callback" id="child_process_subprocess_send_message_sendhandle_options_callback">#</a></span></h3>
+subprocess.<span class="hljs-title function_">unref</span>();
+subprocess.<span class="hljs-title function_">ref</span>();</code></pre>
+<h4><code>subprocess.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#child_process_subprocess_send_message_sendhandle_options_callback" id="child_process_subprocess_send_message_sendhandle_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1316,21 +1494,21 @@ Node.js instance, these messages can be received via the <a href="process.html#p
 message might not be the same as what is originally sent.</p>
 <p>For example, in the parent script:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cp = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> n = cp.fork(<span class="hljs-string">`<span class="hljs-subst">${__dirname}</span>/sub.js`</span>);
+<span class="hljs-keyword">const</span> n = cp.<span class="hljs-title function_">fork</span>(<span class="hljs-string">`<span class="hljs-subst">${__dirname}</span>/sub.js`</span>);
 
-n.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'PARENT got message:'</span>, m);
+n.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'PARENT got message:'</span>, m);
 });
 
 <span class="hljs-comment">// Causes the child to print: CHILD got message: { hello: 'world' }</span>
-n.send({ <span class="hljs-attr">hello</span>: <span class="hljs-string">'world'</span> });</code></pre>
+n.<span class="hljs-title function_">send</span>({ <span class="hljs-attr">hello</span>: <span class="hljs-string">'world'</span> });</code></pre>
 <p>And then the child script, <code>'sub.js'</code> might look like this:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'CHILD got message:'</span>, m);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'CHILD got message:'</span>, m);
 });
 
 <span class="hljs-comment">// Causes the parent to print: PARENT got message: { foo: 'bar', baz: null }</span>
-process.send({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: <span class="hljs-literal">NaN</span> });</code></pre>
+process.<span class="hljs-title function_">send</span>({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: <span class="hljs-title class_">Na</span>N });</code></pre>
 <p>Child Node.js processes will have a <a href="process.html#process_process_send_message_sendhandle_options_callback"><code>process.send()</code></a> method of their own
 that allows the child to send messages back to the parent.</p>
 <p>There is a special case when sending a <code>{cmd: 'NODE_foo'}</code> message. Messages
@@ -1349,30 +1527,30 @@ and buffered in the socket will not be sent to the child.</p>
 sent but before the child may have received it. The function is called with a
 single argument: <code>null</code> on success, or an <a href="errors.html#errors_class_error"><code>Error</code></a> object on failure.</p>
 <p>If no <code>callback</code> function is provided and the message cannot be sent, an
-<code>'error'</code> event will be emitted by the <a href="#child_process_child_process"><code>ChildProcess</code></a> object. This can
+<code>'error'</code> event will be emitted by the <a href="#child_process_class_childprocess"><code>ChildProcess</code></a> object. This can
 happen, for instance, when the child process has already exited.</p>
 <p><code>subprocess.send()</code> will return <code>false</code> if the channel has closed or when the
 backlog of unsent messages exceeds a threshold that makes it unwise to send
 more. Otherwise, the method returns <code>true</code>. The <code>callback</code> function can be
 used to implement flow control.</p>
-<h4>Example: sending a server object<span><a class="mark" href="#child_process_example_sending_a_server_object" id="child_process_example_sending_a_server_object">#</a></span></h4>
+<h5>Example: sending a server object<span><a class="mark" href="#child_process_example_sending_a_server_object" id="child_process_example_sending_a_server_object">#</a></span></h5>
 <p>The <code>sendHandle</code> argument can be used, for instance, to pass the handle of
 a TCP server object to the child process as illustrated in the example below:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> subprocess = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).fork(<span class="hljs-string">'subprocess.js'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> subprocess = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>).<span class="hljs-title function_">fork</span>(<span class="hljs-string">'subprocess.js'</span>);
 
 <span class="hljs-comment">// Open up the server object and send the handle.</span>
-<span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer();
-server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  socket.end(<span class="hljs-string">'handled by parent'</span>);
+<span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'handled by parent'</span>);
 });
-server.listen(<span class="hljs-number">1337</span>, <span class="hljs-function">() =></span> {
-  subprocess.send(<span class="hljs-string">'server'</span>, server);
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>, <span class="hljs-function">() =></span> {
+  subprocess.<span class="hljs-title function_">send</span>(<span class="hljs-string">'server'</span>, server);
 });</code></pre>
 <p>The child would then receive the server object as:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m, server</span>) =></span> {
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m, server</span>) =></span> {
   <span class="hljs-keyword">if</span> (m === <span class="hljs-string">'server'</span>) {
-    server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-      socket.end(<span class="hljs-string">'handled by child'</span>);
+    server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+      socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'handled by child'</span>);
     });
   }
 });</code></pre>
@@ -1383,37 +1561,37 @@ module servers use exactly the same workflow with the exceptions of listening on
 a <code>'message'</code> event instead of <code>'connection'</code> and using <code>server.bind()</code> instead
 of <code>server.listen()</code>. This is, however, currently only supported on Unix
 platforms.</p>
-<h4>Example: sending a socket object<span><a class="mark" href="#child_process_example_sending_a_socket_object" id="child_process_example_sending_a_socket_object">#</a></span></h4>
+<h5>Example: sending a socket object<span><a class="mark" href="#child_process_example_sending_a_socket_object" id="child_process_example_sending_a_socket_object">#</a></span></h5>
 <p>Similarly, the <code>sendHandler</code> argument can be used to pass the handle of a
 socket to the child process. The example below spawns two children that each
 handle connections with "normal" or "special" priority:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { fork } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-<span class="hljs-keyword">const</span> normal = fork(<span class="hljs-string">'subprocess.js'</span>, [<span class="hljs-string">'normal'</span>]);
-<span class="hljs-keyword">const</span> special = fork(<span class="hljs-string">'subprocess.js'</span>, [<span class="hljs-string">'special'</span>]);
+<span class="hljs-keyword">const</span> normal = <span class="hljs-title function_">fork</span>(<span class="hljs-string">'subprocess.js'</span>, [<span class="hljs-string">'normal'</span>]);
+<span class="hljs-keyword">const</span> special = <span class="hljs-title function_">fork</span>(<span class="hljs-string">'subprocess.js'</span>, [<span class="hljs-string">'special'</span>]);
 
 <span class="hljs-comment">// Open up the server and send sockets to child. Use pauseOnConnect to prevent</span>
 <span class="hljs-comment">// the sockets from being read before they are sent to the child process.</span>
-<span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).createServer({ <span class="hljs-attr">pauseOnConnect</span>: <span class="hljs-literal">true</span> });
-server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+<span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-title function_">createServer</span>({ <span class="hljs-attr">pauseOnConnect</span>: <span class="hljs-literal">true</span> });
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
 
   <span class="hljs-comment">// If this is special priority...</span>
-  <span class="hljs-keyword">if</span> (socket.remoteAddress === <span class="hljs-string">'74.125.127.100'</span>) {
-    special.send(<span class="hljs-string">'socket'</span>, socket);
+  <span class="hljs-keyword">if</span> (socket.<span class="hljs-property">remoteAddress</span> === <span class="hljs-string">'74.125.127.100'</span>) {
+    special.<span class="hljs-title function_">send</span>(<span class="hljs-string">'socket'</span>, socket);
     <span class="hljs-keyword">return</span>;
   }
   <span class="hljs-comment">// This is normal priority.</span>
-  normal.send(<span class="hljs-string">'socket'</span>, socket);
+  normal.<span class="hljs-title function_">send</span>(<span class="hljs-string">'socket'</span>, socket);
 });
-server.listen(<span class="hljs-number">1337</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
 <p>The <code>subprocess.js</code> would receive the socket handle as the second argument
 passed to the event callback function:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m, socket</span>) =></span> {
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">m, socket</span>) =></span> {
   <span class="hljs-keyword">if</span> (m === <span class="hljs-string">'socket'</span>) {
     <span class="hljs-keyword">if</span> (socket) {
       <span class="hljs-comment">// Check that the client socket exists.</span>
       <span class="hljs-comment">// It is possible for the socket to be closed between the time it is</span>
       <span class="hljs-comment">// sent and the time it is received in the child process.</span>
-      socket.end(<span class="hljs-string">`Request handled with <span class="hljs-subst">${process.argv[<span class="hljs-number">2</span>]}</span> priority`</span>);
+      socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">`Request handled with <span class="hljs-subst">${process.argv[<span class="hljs-number">2</span>]}</span> priority`</span>);
     }
   }
 });</code></pre>
@@ -1422,19 +1600,19 @@ The parent cannot track when the socket is destroyed.</p>
 <p>Any <code>'message'</code> handlers in the subprocess should verify that <code>socket</code> exists,
 as the connection may have been closed during the time it takes to send the
 connection to the child.</p>
-<h3><code>subprocess.signalCode</code><span><a class="mark" href="#child_process_subprocess_signalcode" id="child_process_subprocess_signalcode">#</a></span></h3>
+<h4><code>subprocess.signalCode</code><span><a class="mark" href="#child_process_subprocess_signalcode" id="child_process_subprocess_signalcode">#</a></span></h4>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
 </ul>
-<p>The <code>subprocess.signalCode</code> property indicates the signal number received by
+<p>The <code>subprocess.signalCode</code> property indicates the signal received by
 the child process if any, else <code>null</code>.</p>
-<h3><code>subprocess.spawnargs</code><span><a class="mark" href="#child_process_subprocess_spawnargs" id="child_process_subprocess_spawnargs">#</a></span></h3>
+<h4><code>subprocess.spawnargs</code><span><a class="mark" href="#child_process_subprocess_spawnargs" id="child_process_subprocess_spawnargs">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
 </ul>
-<p>The <code>subprocess.spawnargs</code> property represents the full list of command line
+<p>The <code>subprocess.spawnargs</code> property represents the full list of command-line
 arguments the child process was launched with.</p>
-<h3><code>subprocess.spawnfile</code><span><a class="mark" href="#child_process_subprocess_spawnfile" id="child_process_subprocess_spawnfile">#</a></span></h3>
+<h4><code>subprocess.spawnfile</code><span><a class="mark" href="#child_process_subprocess_spawnfile" id="child_process_subprocess_spawnfile">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -1446,7 +1624,7 @@ For <a href="#child_process_child_process_spawn_command_args_options"><code>chil
 the executable file.
 For <a href="#child_process_child_process_exec_command_options_callback"><code>child_process.exec()</code></a>,  its value will be the name of the shell
 in which the child process is launched.</p>
-<h3><code>subprocess.stderr</code><span><a class="mark" href="#child_process_subprocess_stderr" id="child_process_subprocess_stderr">#</a></span></h3>
+<h4><code>subprocess.stderr</code><span><a class="mark" href="#child_process_subprocess_stderr" id="child_process_subprocess_stderr">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1458,7 +1636,9 @@ in which the child process is launched.</p>
 then this will be <code>null</code>.</p>
 <p><code>subprocess.stderr</code> is an alias for <code>subprocess.stdio[2]</code>. Both properties will
 refer to the same value.</p>
-<h3><code>subprocess.stdin</code><span><a class="mark" href="#child_process_subprocess_stdin" id="child_process_subprocess_stdin">#</a></span></h3>
+<p>The <code>subprocess.stderr</code> property can be <code>null</code> if the child process could
+not be successfully spawned.</p>
+<h4><code>subprocess.stdin</code><span><a class="mark" href="#child_process_subprocess_stdin" id="child_process_subprocess_stdin">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1472,7 +1652,9 @@ until this stream has been closed via <code>end()</code>.</p>
 then this will be <code>null</code>.</p>
 <p><code>subprocess.stdin</code> is an alias for <code>subprocess.stdio[0]</code>. Both properties will
 refer to the same value.</p>
-<h3><code>subprocess.stdio</code><span><a class="mark" href="#child_process_subprocess_stdio" id="child_process_subprocess_stdio">#</a></span></h3>
+<p>The <code>subprocess.stdin</code> property can be <code>undefined</code> if the child process could
+not be successfully spawned.</p>
+<h4><code>subprocess.stdio</code><span><a class="mark" href="#child_process_subprocess_stdio" id="child_process_subprocess_stdio">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.10</span>
 </div>
@@ -1491,23 +1673,25 @@ in the array are <code>null</code>.</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> child_process = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = child_process.spawn(<span class="hljs-string">'ls'</span>, {
+<span class="hljs-keyword">const</span> subprocess = child_process.<span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>, {
   <span class="hljs-attr">stdio</span>: [
     <span class="hljs-number">0</span>, <span class="hljs-comment">// Use parent's stdin for child.</span>
     <span class="hljs-string">'pipe'</span>, <span class="hljs-comment">// Pipe child's stdout to parent.</span>
-    fs.openSync(<span class="hljs-string">'err.out'</span>, <span class="hljs-string">'w'</span>) <span class="hljs-comment">// Direct child's stderr to a file.</span>
+    fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'err.out'</span>, <span class="hljs-string">'w'</span>), <span class="hljs-comment">// Direct child's stderr to a file.</span>
   ]
 });
 
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">0</span>], <span class="hljs-literal">null</span>);
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">0</span>], subprocess.stdin);
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">0</span>], <span class="hljs-literal">null</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">0</span>], subprocess.<span class="hljs-property">stdin</span>);
 
-assert(subprocess.stdout);
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">1</span>], subprocess.stdout);
+<span class="hljs-title function_">assert</span>(subprocess.<span class="hljs-property">stdout</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">1</span>], subprocess.<span class="hljs-property">stdout</span>);
 
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">2</span>], <span class="hljs-literal">null</span>);
-assert.strictEqual(subprocess.stdio[<span class="hljs-number">2</span>], subprocess.stderr);</code></pre>
-<h3><code>subprocess.stdout</code><span><a class="mark" href="#child_process_subprocess_stdout" id="child_process_subprocess_stdout">#</a></span></h3>
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">2</span>], <span class="hljs-literal">null</span>);
+assert.<span class="hljs-title function_">strictEqual</span>(subprocess.<span class="hljs-property">stdio</span>[<span class="hljs-number">2</span>], subprocess.<span class="hljs-property">stderr</span>);</code></pre>
+<p>The <code>subprocess.stdio</code> property can be <code>undefined</code> if the child process could
+not be successfully spawned.</p>
+<h4><code>subprocess.stdout</code><span><a class="mark" href="#child_process_subprocess_stdout" id="child_process_subprocess_stdout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1521,12 +1705,14 @@ then this will be <code>null</code>.</p>
 refer to the same value.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(<span class="hljs-string">'ls'</span>);
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(<span class="hljs-string">'ls'</span>);
 
-subprocess.stdout.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received chunk <span class="hljs-subst">${data}</span>`</span>);
+subprocess.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received chunk <span class="hljs-subst">${data}</span>`</span>);
 });</code></pre>
-<h3><code>subprocess.unref()</code><span><a class="mark" href="#child_process_subprocess_unref" id="child_process_subprocess_unref">#</a></span></h3>
+<p>The <code>subprocess.stdout</code> property can be <code>null</code> if the child process could
+not be successfully spawned.</p>
+<h4><code>subprocess.unref()</code><span><a class="mark" href="#child_process_subprocess_unref" id="child_process_subprocess_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.10</span>
 </div>
@@ -1538,31 +1724,31 @@ independently of the child, unless there is an established IPC channel between
 the child and the parent.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { spawn } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-<span class="hljs-keyword">const</span> subprocess = spawn(process.argv[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
+<span class="hljs-keyword">const</span> subprocess = <span class="hljs-title function_">spawn</span>(process.<span class="hljs-property">argv</span>[<span class="hljs-number">0</span>], [<span class="hljs-string">'child_program.js'</span>], {
   <span class="hljs-attr">detached</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">stdio</span>: <span class="hljs-string">'ignore'</span>
 });
 
-subprocess.unref();</code></pre>
-<h2><code>maxBuffer</code> and Unicode<span><a class="mark" href="#child_process_maxbuffer_and_unicode" id="child_process_maxbuffer_and_unicode">#</a></span></h2>
+subprocess.<span class="hljs-title function_">unref</span>();</code></pre>
+</section><section><h3><code>maxBuffer</code> and Unicode<span><a class="mark" href="#child_process_maxbuffer_and_unicode" id="child_process_maxbuffer_and_unicode">#</a></span></h3>
 <p>The <code>maxBuffer</code> option specifies the largest number of bytes allowed on <code>stdout</code>
 or <code>stderr</code>. If this value is exceeded, then the child process is terminated.
 This impacts output that includes multibyte character encodings such as UTF-8 or
 UTF-16. For instance, <code>console.log('中文测试')</code> will send 13 UTF-8 encoded bytes
 to <code>stdout</code> although there are only 4 characters.</p>
-<h2>Shell requirements<span><a class="mark" href="#child_process_shell_requirements" id="child_process_shell_requirements">#</a></span></h2>
+</section><section><h3>Shell requirements<span><a class="mark" href="#child_process_shell_requirements" id="child_process_shell_requirements">#</a></span></h3>
 <p>The shell should understand the <code>-c</code> switch. If the shell is <code>'cmd.exe'</code>, it
-should understand the <code>/d /s /c</code> switches and command line parsing should be
+should understand the <code>/d /s /c</code> switches and command-line parsing should be
 compatible.</p>
-<h2>Default Windows shell<span><a class="mark" href="#child_process_default_windows_shell" id="child_process_default_windows_shell">#</a></span></h2>
+</section><section><h3>Default Windows shell<span><a class="mark" href="#child_process_default_windows_shell" id="child_process_default_windows_shell">#</a></span></h3>
 <p>Although Microsoft specifies <code>%COMSPEC%</code> must contain the path to
 <code>'cmd.exe'</code> in the root environment, child processes are not always subject to
 the same requirement. Thus, in <code>child_process</code> functions where a shell can be
 spawned, <code>'cmd.exe'</code> is used as a fallback if <code>process.env.ComSpec</code> is
 unavailable.</p>
-<h2>Advanced serialization<span><a class="mark" href="#child_process_advanced_serialization" id="child_process_advanced_serialization">#</a></span></h2>
+</section><section><h3>Advanced serialization<span><a class="mark" href="#child_process_advanced_serialization" id="child_process_advanced_serialization">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <p>Child processes support a serialization mechanism for IPC that is based on the
 <a href="v8.html#v8_serialization_api">serialization API of the <code>v8</code> module</a>, based on the
@@ -1575,10 +1761,46 @@ step. Additionally, performance may not be equivalent to that of JSON, depending
 on the structure of the passed data.
 Therefore, this feature requires opting in by setting the
 <code>serialization</code> option to <code>'advanced'</code> when calling <a href="#child_process_child_process_spawn_command_args_options"><code>child_process.spawn()</code></a>
-or <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p>
+or <a href="#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/child_process.json b/doc/api/child_process.json
index 586c68dbdf95128d5e8592de54ccf61ea9ee28f5..c769b2f45b56357f62d5f65b8371404e90526660 100644
--- a/doc/api/child_process.json
+++ b/doc/api/child_process.json
@@ -8,12 +8,12 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/child_process.js\">lib/child_process.js</a></p>\n<p>The <code>child_process</code> module provides the ability to spawn child processes in\na manner that is similar, but not identical, to <a href=\"http://man7.org/linux/man-pages/man3/popen.3.html\"><code>popen(3)</code></a>. This capability\nis primarily provided by the <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> function:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.stderr.on('data', (data) => {\n  console.error(`stderr: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>\n<p>By default, pipes for <code>stdin</code>, <code>stdout</code>, and <code>stderr</code> are established between\nthe parent Node.js process and the spawned child. These pipes have\nlimited (and platform-specific) capacity. If the child process writes to\nstdout in excess of that limit without the output being captured, the child\nprocess will block waiting for the pipe buffer to accept more data. This is\nidentical to the behavior of pipes in the shell. Use the <code>{ stdio: 'ignore' }</code>\noption if the output will not be consumed.</p>\n<p>The command lookup will be performed using <code>options.env.PATH</code> environment\nvariable if passed in <code>options</code> object, otherwise <code>process.env.PATH</code> will be\nused. To account for the fact that Windows environment variables are\ncase-insensitive Node.js will lexicographically sort all <code>env</code> keys and choose\nthe first one case-insensitively matching <code>PATH</code> to perform command lookup.\nThis may lead to issues on Windows when passing objects to <code>env</code> option that\nhave multiple variants of <code>PATH</code> variable.</p>\n<p>The <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> method spawns the child process asynchronously,\nwithout blocking the Node.js event loop. The <a href=\"#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>\nfunction provides equivalent functionality in a synchronous manner that blocks\nthe event loop until the spawned process either exits or is terminated.</p>\n<p>For convenience, the <code>child_process</code> module provides a handful of synchronous\nand asynchronous alternatives to <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> and\n<a href=\"#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>. Each of these alternatives are implemented on\ntop of <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> or <a href=\"#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>.</p>\n<ul>\n<li><a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>: spawns a shell and runs a command within that\nshell, passing the <code>stdout</code> and <code>stderr</code> to a callback function when\ncomplete.</li>\n<li><a href=\"#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a>: similar to <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> except\nthat it spawns the command directly without first spawning a shell by\ndefault.</li>\n<li><a href=\"#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>: spawns a new Node.js process and invokes a\nspecified module with an IPC communication channel established that allows\nsending messages between parent and child.</li>\n<li><a href=\"#child_process_child_process_execsync_command_options\"><code>child_process.execSync()</code></a>: a synchronous version of\n<a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> that will block the Node.js event loop.</li>\n<li><a href=\"#child_process_child_process_execfilesync_file_args_options\"><code>child_process.execFileSync()</code></a>: a synchronous version of\n<a href=\"#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> that will block the Node.js event loop.</li>\n</ul>\n<p>For certain use cases, such as automating shell scripts, the\n<a href=\"#child_process_synchronous_process_creation\">synchronous counterparts</a> may be more convenient. In many cases, however,\nthe synchronous methods can have significant impact on performance due to\nstalling the event loop while spawned processes complete.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/child_process.js\">lib/child_process.js</a></p>\n<p>The <code>child_process</code> module provides the ability to spawn subprocesses in\na manner that is similar, but not identical, to <a href=\"http://man7.org/linux/man-pages/man3/popen.3.html\"><code>popen(3)</code></a>. This capability\nis primarily provided by the <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> function:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.stderr.on('data', (data) => {\n  console.error(`stderr: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>\n<p>By default, pipes for <code>stdin</code>, <code>stdout</code>, and <code>stderr</code> are established between\nthe parent Node.js process and the spawned subprocess. These pipes have\nlimited (and platform-specific) capacity. If the subprocess writes to\nstdout in excess of that limit without the output being captured, the\nsubprocess blocks waiting for the pipe buffer to accept more data. This is\nidentical to the behavior of pipes in the shell. Use the <code>{ stdio: 'ignore' }</code>\noption if the output will not be consumed.</p>\n<p>The command lookup is performed using the <code>options.env.PATH</code> environment\nvariable if it is in the <code>options</code> object. Otherwise, <code>process.env.PATH</code> is\nused.</p>\n<p>On Windows, environment variables are case-insensitive. Node.js\nlexicographically sorts the <code>env</code> keys and uses the first one that\ncase-insensitively matches. Only first (in lexicographic order) entry will be\npassed to the subprocess. This might lead to issues on Windows when passing\nobjects to the <code>env</code> option that have multiple variants of the same key, such as\n<code>PATH</code> and <code>Path</code>.</p>\n<p>The <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> method spawns the child process asynchronously,\nwithout blocking the Node.js event loop. The <a href=\"#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>\nfunction provides equivalent functionality in a synchronous manner that blocks\nthe event loop until the spawned process either exits or is terminated.</p>\n<p>For convenience, the <code>child_process</code> module provides a handful of synchronous\nand asynchronous alternatives to <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> and\n<a href=\"#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>. Each of these alternatives are implemented on\ntop of <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> or <a href=\"#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>.</p>\n<ul>\n<li><a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>: spawns a shell and runs a command within that\nshell, passing the <code>stdout</code> and <code>stderr</code> to a callback function when\ncomplete.</li>\n<li><a href=\"#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a>: similar to <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> except\nthat it spawns the command directly without first spawning a shell by\ndefault.</li>\n<li><a href=\"#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>: spawns a new Node.js process and invokes a\nspecified module with an IPC communication channel established that allows\nsending messages between parent and child.</li>\n<li><a href=\"#child_process_child_process_execsync_command_options\"><code>child_process.execSync()</code></a>: a synchronous version of\n<a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> that will block the Node.js event loop.</li>\n<li><a href=\"#child_process_child_process_execfilesync_file_args_options\"><code>child_process.execFileSync()</code></a>: a synchronous version of\n<a href=\"#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> that will block the Node.js event loop.</li>\n</ul>\n<p>For certain use cases, such as automating shell scripts, the\n<a href=\"#child_process_synchronous_process_creation\">synchronous counterparts</a> may be more convenient. In many cases, however,\nthe synchronous methods can have significant impact on performance due to\nstalling the event loop while spawned processes complete.</p>",
       "modules": [
         {
           "textRaw": "Asynchronous process creation",
           "name": "asynchronous_process_creation",
-          "desc": "<p>The <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a>, <a href=\"#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>, <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>,\nand <a href=\"#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> methods all follow the idiomatic asynchronous\nprogramming pattern typical of other Node.js APIs.</p>\n<p>Each of the methods returns a <a href=\"#child_process_child_process\"><code>ChildProcess</code></a> instance. These objects\nimplement the Node.js <a href=\"events.html#events_class_eventemitter\"><code>EventEmitter</code></a> API, allowing the parent process to\nregister listener functions that are called when certain events occur during\nthe life cycle of the child process.</p>\n<p>The <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> and <a href=\"#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> methods\nadditionally allow for an optional <code>callback</code> function to be specified that is\ninvoked when the child process terminates.</p>",
+          "desc": "<p>The <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a>, <a href=\"#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>, <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>,\nand <a href=\"#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> methods all follow the idiomatic asynchronous\nprogramming pattern typical of other Node.js APIs.</p>\n<p>Each of the methods returns a <a href=\"#child_process_class_childprocess\"><code>ChildProcess</code></a> instance. These objects\nimplement the Node.js <a href=\"events.html#events_class_eventemitter\"><code>EventEmitter</code></a> API, allowing the parent process to\nregister listener functions that are called when certain events occur during\nthe life cycle of the child process.</p>\n<p>The <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> and <a href=\"#child_process_child_process_execfile_file_args_options_callback\"><code>child_process.execFile()</code></a> methods\nadditionally allow for an optional <code>callback</code> function to be specified that is\ninvoked when the child process terminates.</p>",
           "modules": [
             {
               "textRaw": "Spawning `.bat` and `.cmd` files on Windows",
@@ -33,6 +33,16 @@
                   "v0.1.90"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36308",
+                    "description": "AbortSignal support was added."
+                  },
                   {
                     "version": "v8.8.0",
                     "pr-url": "https://github.com/nodejs/node/pull/15380",
@@ -60,10 +70,10 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process. **Default:** `null`.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process. **Default:** `process.cwd()`.",
                           "name": "cwd",
-                          "type": "string",
-                          "default": "`null`",
+                          "type": "string|URL",
+                          "default": "`process.cwd()`",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -86,6 +96,12 @@
                           "default": "`'/bin/sh'` on Unix, `process.env.ComSpec` on Windows",
                           "desc": "Shell to execute the command with. See [Shell requirements][] and [Default Windows shell][]."
                         },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting the child process using an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting the child process using an AbortSignal."
+                        },
                         {
                           "textRaw": "`timeout` {number} **Default:** `0`",
                           "name": "timeout",
@@ -152,7 +168,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Spawns a shell then executes the <code>command</code> within that shell, buffering any\ngenerated output. The <code>command</code> string passed to the exec function is processed\ndirectly by the shell and special characters (vary based on\n<a href=\"https://en.wikipedia.org/wiki/List_of_command-line_interpreters\">shell</a>)\nneed to be dealt with accordingly:</p>\n<pre><code class=\"language-js\">exec('\"/path/to/test file/test.sh\" arg1 arg2');\n// Double quotes are used so that the space in the path is not interpreted as\n// a delimiter of multiple arguments.\n\nexec('echo \"The \\\\$HOME variable is $HOME\"');\n// The $HOME variable is escaped in the first instance, but not in the second.\n</code></pre>\n<p><strong>Never pass unsanitized user input to this function. Any input containing shell\nmetacharacters may be used to trigger arbitrary command execution.</strong></p>\n<p>If a <code>callback</code> function is provided, it is called with the arguments\n<code>(error, stdout, stderr)</code>. On success, <code>error</code> will be <code>null</code>. On error,\n<code>error</code> will be an instance of <a href=\"errors.html#errors_class_error\"><code>Error</code></a>. The <code>error.code</code> property will be\nthe exit code of the process. By convention, any exit code other than <code>0</code>\nindicates an error. <code>error.signal</code> will be the signal that terminated the\nprocess.</p>\n<p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the\nstdout and stderr output of the child process. By default, Node.js will decode\nthe output as UTF-8 and pass strings to the callback. The <code>encoding</code> option\ncan be used to specify the character encoding used to decode the stdout and\nstderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character\nencoding, <code>Buffer</code> objects will be passed to the callback instead.</p>\n<pre><code class=\"language-js\">const { exec } = require('child_process');\nexec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {\n  if (error) {\n    console.error(`exec error: ${error}`);\n    return;\n  }\n  console.log(`stdout: ${stdout}`);\n  console.error(`stderr: ${stderr}`);\n});\n</code></pre>\n<p>If <code>timeout</code> is greater than <code>0</code>, the parent will send the signal\nidentified by the <code>killSignal</code> property (the default is <code>'SIGTERM'</code>) if the\nchild runs longer than <code>timeout</code> milliseconds.</p>\n<p>Unlike the <a href=\"http://man7.org/linux/man-pages/man3/exec.3.html\"><code>exec(3)</code></a> POSIX system call, <code>child_process.exec()</code> does not replace\nthe existing process and uses a shell to execute the command.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>stdout</code> and <code>stderr</code> properties. The returned\n<code>ChildProcess</code> instance is attached to the <code>Promise</code> as a <code>child</code> property. In\ncase of an error (including any error resulting in an exit code other than 0), a\nrejected promise is returned, with the same <code>error</code> object given in the\ncallback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst exec = util.promisify(require('child_process').exec);\n\nasync function lsExample() {\n  const { stdout, stderr } = await exec('ls');\n  console.log('stdout:', stdout);\n  console.error('stderr:', stderr);\n}\nlsExample();\n</code></pre>"
+              "desc": "<p>Spawns a shell then executes the <code>command</code> within that shell, buffering any\ngenerated output. The <code>command</code> string passed to the exec function is processed\ndirectly by the shell and special characters (vary based on\n<a href=\"https://en.wikipedia.org/wiki/List_of_command-line_interpreters\">shell</a>)\nneed to be dealt with accordingly:</p>\n<pre><code class=\"language-js\">const { exec } = require('child_process');\n\nexec('\"/path/to/test file/test.sh\" arg1 arg2');\n// Double quotes are used so that the space in the path is not interpreted as\n// a delimiter of multiple arguments.\n\nexec('echo \"The \\\\$HOME variable is $HOME\"');\n// The $HOME variable is escaped in the first instance, but not in the second.\n</code></pre>\n<p><strong>Never pass unsanitized user input to this function. Any input containing shell\nmetacharacters may be used to trigger arbitrary command execution.</strong></p>\n<p>If a <code>callback</code> function is provided, it is called with the arguments\n<code>(error, stdout, stderr)</code>. On success, <code>error</code> will be <code>null</code>. On error,\n<code>error</code> will be an instance of <a href=\"errors.html#errors_class_error\"><code>Error</code></a>. The <code>error.code</code> property will be\nthe exit code of the process. By convention, any exit code other than <code>0</code>\nindicates an error. <code>error.signal</code> will be the signal that terminated the\nprocess.</p>\n<p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the\nstdout and stderr output of the child process. By default, Node.js will decode\nthe output as UTF-8 and pass strings to the callback. The <code>encoding</code> option\ncan be used to specify the character encoding used to decode the stdout and\nstderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character\nencoding, <code>Buffer</code> objects will be passed to the callback instead.</p>\n<pre><code class=\"language-js\">const { exec } = require('child_process');\nexec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {\n  if (error) {\n    console.error(`exec error: ${error}`);\n    return;\n  }\n  console.log(`stdout: ${stdout}`);\n  console.error(`stderr: ${stderr}`);\n});\n</code></pre>\n<p>If <code>timeout</code> is greater than <code>0</code>, the parent will send the signal\nidentified by the <code>killSignal</code> property (the default is <code>'SIGTERM'</code>) if the\nchild runs longer than <code>timeout</code> milliseconds.</p>\n<p>Unlike the <a href=\"http://man7.org/linux/man-pages/man3/exec.3.html\"><code>exec(3)</code></a> POSIX system call, <code>child_process.exec()</code> does not replace\nthe existing process and uses a shell to execute the command.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>stdout</code> and <code>stderr</code> properties. The returned\n<code>ChildProcess</code> instance is attached to the <code>Promise</code> as a <code>child</code> property. In\ncase of an error (including any error resulting in an exit code other than 0), a\nrejected promise is returned, with the same <code>error</code> object given in the\ncallback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst exec = util.promisify(require('child_process').exec);\n\nasync function lsExample() {\n  const { stdout, stderr } = await exec('ls');\n  console.log('stdout:', stdout);\n  console.error('stderr:', stderr);\n}\nlsExample();\n</code></pre>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except\nthe error passed to the callback will be an <code>AbortError</code>:</p>\n<pre><code class=\"language-js\">const { exec } = require('child_process');\nconst controller = new AbortController();\nconst { signal } = controller;\nconst child = exec('grep ssh', { signal }, (error) => {\n  console.log(error); // an AbortError\n});\ncontroller.abort();\n</code></pre>"
             },
             {
               "textRaw": "`child_process.execFile(file[, args][, options][, callback])`",
@@ -163,6 +179,16 @@
                   "v0.1.91"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36308",
+                    "description": "AbortSignal support was added."
+                  },
                   {
                     "version": "v8.8.0",
                     "pr-url": "https://github.com/nodejs/node/pull/15380",
@@ -196,9 +222,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -265,6 +291,12 @@
                           "type": "boolean|string",
                           "default": "`false` (no shell)",
                           "desc": "If `true`, runs `command` inside of a shell. Uses `'/bin/sh'` on Unix, and `process.env.ComSpec` on Windows. A different shell can be specified as a string. See [Shell requirements][] and [Default Windows shell][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting the child process using an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting the child process using an AbortSignal."
                         }
                       ]
                     },
@@ -294,7 +326,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>child_process.execFile()</code> function is similar to <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>\nexcept that it does not spawn a shell by default. Rather, the specified\nexecutable <code>file</code> is spawned directly as a new process making it slightly more\nefficient than <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>.</p>\n<p>The same options as <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> are supported. Since a shell is\nnot spawned, behaviors such as I/O redirection and file globbing are not\nsupported.</p>\n<pre><code class=\"language-js\">const { execFile } = require('child_process');\nconst child = execFile('node', ['--version'], (error, stdout, stderr) => {\n  if (error) {\n    throw error;\n  }\n  console.log(stdout);\n});\n</code></pre>\n<p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the\nstdout and stderr output of the child process. By default, Node.js will decode\nthe output as UTF-8 and pass strings to the callback. The <code>encoding</code> option\ncan be used to specify the character encoding used to decode the stdout and\nstderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character\nencoding, <code>Buffer</code> objects will be passed to the callback instead.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>stdout</code> and <code>stderr</code> properties. The returned\n<code>ChildProcess</code> instance is attached to the <code>Promise</code> as a <code>child</code> property. In\ncase of an error (including any error resulting in an exit code other than 0), a\nrejected promise is returned, with the same <code>error</code> object given in the\ncallback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst execFile = util.promisify(require('child_process').execFile);\nasync function getVersion() {\n  const { stdout } = await execFile('node', ['--version']);\n  console.log(stdout);\n}\ngetVersion();\n</code></pre>\n<p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this\nfunction. Any input containing shell metacharacters may be used to trigger\narbitrary command execution.</strong></p>"
+              "desc": "<p>The <code>child_process.execFile()</code> function is similar to <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>\nexcept that it does not spawn a shell by default. Rather, the specified\nexecutable <code>file</code> is spawned directly as a new process making it slightly more\nefficient than <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a>.</p>\n<p>The same options as <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> are supported. Since a shell is\nnot spawned, behaviors such as I/O redirection and file globbing are not\nsupported.</p>\n<pre><code class=\"language-js\">const { execFile } = require('child_process');\nconst child = execFile('node', ['--version'], (error, stdout, stderr) => {\n  if (error) {\n    throw error;\n  }\n  console.log(stdout);\n});\n</code></pre>\n<p>The <code>stdout</code> and <code>stderr</code> arguments passed to the callback will contain the\nstdout and stderr output of the child process. By default, Node.js will decode\nthe output as UTF-8 and pass strings to the callback. The <code>encoding</code> option\ncan be used to specify the character encoding used to decode the stdout and\nstderr output. If <code>encoding</code> is <code>'buffer'</code>, or an unrecognized character\nencoding, <code>Buffer</code> objects will be passed to the callback instead.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>stdout</code> and <code>stderr</code> properties. The returned\n<code>ChildProcess</code> instance is attached to the <code>Promise</code> as a <code>child</code> property. In\ncase of an error (including any error resulting in an exit code other than 0), a\nrejected promise is returned, with the same <code>error</code> object given in the\ncallback, but with two additional properties <code>stdout</code> and <code>stderr</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst execFile = util.promisify(require('child_process').execFile);\nasync function getVersion() {\n  const { stdout } = await execFile('node', ['--version']);\n  console.log(stdout);\n}\ngetVersion();\n</code></pre>\n<p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this\nfunction. Any input containing shell metacharacters may be used to trigger\narbitrary command execution.</strong></p>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except\nthe error passed to the callback will be an <code>AbortError</code>:</p>\n<pre><code class=\"language-js\">const { execFile } = require('child_process');\nconst controller = new AbortController();\nconst { signal } = controller;\nconst child = execFile('node', ['--version'], { signal }, (error) => {\n  console.log(error); // an AbortError\n});\ncontroller.abort();\n</code></pre>"
             },
             {
               "textRaw": "`child_process.fork(modulePath[, args][, options])`",
@@ -306,7 +338,30 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37256",
+                    "description": "timeout was added."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37325",
+                    "description": "killSignal for AbortSignal was added."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36603",
+                    "description": "AbortSignal support was added."
+                  },
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30162",
                     "description": "The `serialization` option is supported now."
                   },
@@ -348,9 +403,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -379,6 +434,12 @@
                           "default": "`process.execArgv`",
                           "desc": "List of string arguments passed to the executable."
                         },
+                        {
+                          "textRaw": "`gid` {number} Sets the group identity of the process (see setgid(2)).",
+                          "name": "gid",
+                          "type": "number",
+                          "desc": "Sets the group identity of the process (see setgid(2))."
+                        },
                         {
                           "textRaw": "`serialization` {string} Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`. See [Advanced serialization][] for more details. **Default:** `'json'`.",
                           "name": "serialization",
@@ -386,6 +447,19 @@
                           "default": "`'json'`",
                           "desc": "Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`. See [Advanced serialization][] for more details."
                         },
+                        {
+                          "textRaw": "`signal` {AbortSignal} Allows closing the child process using an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "Allows closing the child process using an AbortSignal."
+                        },
+                        {
+                          "textRaw": "`killSignal` {string|integer} The signal value to be used when the spawned process will be killed by timeout or abort signal. **Default:** `'SIGTERM'`.",
+                          "name": "killSignal",
+                          "type": "string|integer",
+                          "default": "`'SIGTERM'`",
+                          "desc": "The signal value to be used when the spawned process will be killed by timeout or abort signal."
+                        },
                         {
                           "textRaw": "`silent` {boolean} If `true`, stdin, stdout, and stderr of the child will be piped to the parent, otherwise they will be inherited from the parent, see the `'pipe'` and `'inherit'` options for [`child_process.spawn()`][]'s [`stdio`][] for more details. **Default:** `false`.",
                           "name": "silent",
@@ -399,6 +473,12 @@
                           "type": "Array|string",
                           "desc": "See [`child_process.spawn()`][]'s [`stdio`][]. When this option is provided, it overrides `silent`. If the array variant is used, it must contain exactly one item with value `'ipc'` or an error will be thrown. For instance `[0, 1, 2, 'ipc']`."
                         },
+                        {
+                          "textRaw": "`uid` {number} Sets the user identity of the process (see setuid(2)).",
+                          "name": "uid",
+                          "type": "number",
+                          "desc": "Sets the user identity of the process (see setuid(2))."
+                        },
                         {
                           "textRaw": "`windowsVerbatimArguments` {boolean} No quoting or escaping of arguments is done on Windows. Ignored on Unix. **Default:** `false`.",
                           "name": "windowsVerbatimArguments",
@@ -407,23 +487,18 @@
                           "desc": "No quoting or escaping of arguments is done on Windows. Ignored on Unix."
                         },
                         {
-                          "textRaw": "`uid` {number} Sets the user identity of the process (see setuid(2)).",
-                          "name": "uid",
-                          "type": "number",
-                          "desc": "Sets the user identity of the process (see setuid(2))."
-                        },
-                        {
-                          "textRaw": "`gid` {number} Sets the group identity of the process (see setgid(2)).",
-                          "name": "gid",
+                          "textRaw": "`timeout` {number} In milliseconds the maximum amount of time the process is allowed to run. **Default:** `undefined`.",
+                          "name": "timeout",
                           "type": "number",
-                          "desc": "Sets the group identity of the process (see setgid(2))."
+                          "default": "`undefined`",
+                          "desc": "In milliseconds the maximum amount of time the process is allowed to run."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>The <code>child_process.fork()</code> method is a special case of\n<a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> used specifically to spawn new Node.js processes.\nLike <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a>, a <a href=\"#child_process_child_process\"><code>ChildProcess</code></a> object is returned. The\nreturned <a href=\"#child_process_child_process\"><code>ChildProcess</code></a> will have an additional communication channel\nbuilt-in that allows messages to be passed back and forth between the parent and\nchild. See <a href=\"#child_process_subprocess_send_message_sendhandle_options_callback\"><code>subprocess.send()</code></a> for details.</p>\n<p>Keep in mind that spawned Node.js child processes are\nindependent of the parent with exception of the IPC communication channel\nthat is established between the two. Each process has its own memory, with\ntheir own V8 instances. Because of the additional resource allocations\nrequired, spawning a large number of child Node.js processes is not\nrecommended.</p>\n<p>By default, <code>child_process.fork()</code> will spawn new Node.js instances using the\n<a href=\"process.html#process_process_execpath\"><code>process.execPath</code></a> of the parent process. The <code>execPath</code> property in the\n<code>options</code> object allows for an alternative execution path to be used.</p>\n<p>Node.js processes launched with a custom <code>execPath</code> will communicate with the\nparent process using the file descriptor (fd) identified using the\nenvironment variable <code>NODE_CHANNEL_FD</code> on the child process.</p>\n<p>Unlike the <a href=\"http://man7.org/linux/man-pages/man2/fork.2.html\"><code>fork(2)</code></a> POSIX system call, <code>child_process.fork()</code> does not clone the\ncurrent process.</p>\n<p>The <code>shell</code> option available in <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> is not supported by\n<code>child_process.fork()</code> and will be ignored if set.</p>"
+              "desc": "<p>The <code>child_process.fork()</code> method is a special case of\n<a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> used specifically to spawn new Node.js processes.\nLike <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a>, a <a href=\"#child_process_class_childprocess\"><code>ChildProcess</code></a> object is returned. The\nreturned <a href=\"#child_process_class_childprocess\"><code>ChildProcess</code></a> will have an additional communication channel\nbuilt-in that allows messages to be passed back and forth between the parent and\nchild. See <a href=\"#child_process_subprocess_send_message_sendhandle_options_callback\"><code>subprocess.send()</code></a> for details.</p>\n<p>Keep in mind that spawned Node.js child processes are\nindependent of the parent with exception of the IPC communication channel\nthat is established between the two. Each process has its own memory, with\ntheir own V8 instances. Because of the additional resource allocations\nrequired, spawning a large number of child Node.js processes is not\nrecommended.</p>\n<p>By default, <code>child_process.fork()</code> will spawn new Node.js instances using the\n<a href=\"process.html#process_process_execpath\"><code>process.execPath</code></a> of the parent process. The <code>execPath</code> property in the\n<code>options</code> object allows for an alternative execution path to be used.</p>\n<p>Node.js processes launched with a custom <code>execPath</code> will communicate with the\nparent process using the file descriptor (fd) identified using the\nenvironment variable <code>NODE_CHANNEL_FD</code> on the child process.</p>\n<p>Unlike the <a href=\"http://man7.org/linux/man-pages/man2/fork.2.html\"><code>fork(2)</code></a> POSIX system call, <code>child_process.fork()</code> does not clone the\ncurrent process.</p>\n<p>The <code>shell</code> option available in <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> is not supported by\n<code>child_process.fork()</code> and will be ignored if set.</p>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except\nthe error passed to the callback will be an <code>AbortError</code>:</p>\n<pre><code class=\"language-js\">if (process.argv[2] === 'child') {\n  setTimeout(() => {\n    console.log(`Hello from ${process.argv[2]}!`);\n  }, 1_000);\n} else {\n  const { fork } = require('child_process');\n  const controller = new AbortController();\n  const { signal } = controller;\n  const child = fork(__filename, ['child'], { signal });\n  child.on('error', (err) => {\n    // This will be called with err being an AbortError if the controller aborts\n  });\n  controller.abort(); // Stops the child process\n}\n</code></pre>"
             },
             {
               "textRaw": "`child_process.spawn(command[, args][, options])`",
@@ -435,7 +510,30 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37256",
+                    "description": "timeout was added."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37325",
+                    "description": "killSignal for AbortSignal was added."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36432",
+                    "description": "AbortSignal support was added."
+                  },
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30162",
                     "description": "The `serialization` option is supported now."
                   },
@@ -482,9 +580,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -551,13 +649,33 @@
                           "type": "boolean",
                           "default": "`false`",
                           "desc": "Hide the subprocess console window that would normally be created on Windows systems."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting the child process using an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting the child process using an AbortSignal."
+                        },
+                        {
+                          "textRaw": "`timeout` {number} In milliseconds the maximum amount of time the process is allowed to run. **Default:** `undefined`.",
+                          "name": "timeout",
+                          "type": "number",
+                          "default": "`undefined`",
+                          "desc": "In milliseconds the maximum amount of time the process is allowed to run."
+                        },
+                        {
+                          "textRaw": "`killSignal` {string|integer} The signal value to be used when the spawned process will be killed by timeout or abort signal. **Default:** `'SIGTERM'`.",
+                          "name": "killSignal",
+                          "type": "string|integer",
+                          "default": "`'SIGTERM'`",
+                          "desc": "The signal value to be used when the spawned process will be killed by timeout or abort signal."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>The <code>child_process.spawn()</code> method spawns a new process using the given\n<code>command</code>, with command line arguments in <code>args</code>. If omitted, <code>args</code> defaults\nto an empty array.</p>\n<p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this\nfunction. Any input containing shell metacharacters may be used to trigger\narbitrary command execution.</strong></p>\n<p>A third argument may be used to specify additional options, with these defaults:</p>\n<pre><code class=\"language-js\">const defaults = {\n  cwd: undefined,\n  env: process.env\n};\n</code></pre>\n<p>Use <code>cwd</code> to specify the working directory from which the process is spawned.\nIf not given, the default is to inherit the current working directory.</p>\n<p>Use <code>env</code> to specify environment variables that will be visible to the new\nprocess, the default is <a href=\"process.html#process_process_env\"><code>process.env</code></a>.</p>\n<p><code>undefined</code> values in <code>env</code> will be ignored.</p>\n<p>Example of running <code>ls -lh /usr</code>, capturing <code>stdout</code>, <code>stderr</code>, and the\nexit code:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.stderr.on('data', (data) => {\n  console.error(`stderr: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>\n<p>Example: A very elaborate way to run <code>ps ax | grep ssh</code></p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ps = spawn('ps', ['ax']);\nconst grep = spawn('grep', ['ssh']);\n\nps.stdout.on('data', (data) => {\n  grep.stdin.write(data);\n});\n\nps.stderr.on('data', (data) => {\n  console.error(`ps stderr: ${data}`);\n});\n\nps.on('close', (code) => {\n  if (code !== 0) {\n    console.log(`ps process exited with code ${code}`);\n  }\n  grep.stdin.end();\n});\n\ngrep.stdout.on('data', (data) => {\n  console.log(data.toString());\n});\n\ngrep.stderr.on('data', (data) => {\n  console.error(`grep stderr: ${data}`);\n});\n\ngrep.on('close', (code) => {\n  if (code !== 0) {\n    console.log(`grep process exited with code ${code}`);\n  }\n});\n</code></pre>\n<p>Example of checking for failed <code>spawn</code>:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst subprocess = spawn('bad_command');\n\nsubprocess.on('error', (err) => {\n  console.error('Failed to start subprocess.');\n});\n</code></pre>\n<p>Certain platforms (macOS, Linux) will use the value of <code>argv[0]</code> for the process\ntitle while others (Windows, SunOS) will use <code>command</code>.</p>\n<p>Node.js currently overwrites <code>argv[0]</code> with <code>process.execPath</code> on startup, so\n<code>process.argv[0]</code> in a Node.js child process will not match the <code>argv0</code>\nparameter passed to <code>spawn</code> from the parent, retrieve it with the\n<code>process.argv0</code> property instead.</p>",
+              "desc": "<p>The <code>child_process.spawn()</code> method spawns a new process using the given\n<code>command</code>, with command-line arguments in <code>args</code>. If omitted, <code>args</code> defaults\nto an empty array.</p>\n<p><strong>If the <code>shell</code> option is enabled, do not pass unsanitized user input to this\nfunction. Any input containing shell metacharacters may be used to trigger\narbitrary command execution.</strong></p>\n<p>A third argument may be used to specify additional options, with these defaults:</p>\n<pre><code class=\"language-js\">const defaults = {\n  cwd: undefined,\n  env: process.env\n};\n</code></pre>\n<p>Use <code>cwd</code> to specify the working directory from which the process is spawned.\nIf not given, the default is to inherit the current working directory. If given,\nbut the path does not exist, the child process emits an <code>ENOENT</code> error\nand exits immediately. <code>ENOENT</code> is also emitted when the command\ndoes not exist.</p>\n<p>Use <code>env</code> to specify environment variables that will be visible to the new\nprocess, the default is <a href=\"process.html#process_process_env\"><code>process.env</code></a>.</p>\n<p><code>undefined</code> values in <code>env</code> will be ignored.</p>\n<p>Example of running <code>ls -lh /usr</code>, capturing <code>stdout</code>, <code>stderr</code>, and the\nexit code:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.stderr.on('data', (data) => {\n  console.error(`stderr: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>\n<p>Example: A very elaborate way to run <code>ps ax | grep ssh</code></p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ps = spawn('ps', ['ax']);\nconst grep = spawn('grep', ['ssh']);\n\nps.stdout.on('data', (data) => {\n  grep.stdin.write(data);\n});\n\nps.stderr.on('data', (data) => {\n  console.error(`ps stderr: ${data}`);\n});\n\nps.on('close', (code) => {\n  if (code !== 0) {\n    console.log(`ps process exited with code ${code}`);\n  }\n  grep.stdin.end();\n});\n\ngrep.stdout.on('data', (data) => {\n  console.log(data.toString());\n});\n\ngrep.stderr.on('data', (data) => {\n  console.error(`grep stderr: ${data}`);\n});\n\ngrep.on('close', (code) => {\n  if (code !== 0) {\n    console.log(`grep process exited with code ${code}`);\n  }\n});\n</code></pre>\n<p>Example of checking for failed <code>spawn</code>:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst subprocess = spawn('bad_command');\n\nsubprocess.on('error', (err) => {\n  console.error('Failed to start subprocess.');\n});\n</code></pre>\n<p>Certain platforms (macOS, Linux) will use the value of <code>argv[0]</code> for the process\ntitle while others (Windows, SunOS) will use <code>command</code>.</p>\n<p>Node.js currently overwrites <code>argv[0]</code> with <code>process.execPath</code> on startup, so\n<code>process.argv[0]</code> in a Node.js child process will not match the <code>argv0</code>\nparameter passed to <code>spawn</code> from the parent, retrieve it with the\n<code>process.argv0</code> property instead.</p>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.kill()</code> on the child process except\nthe error passed to the callback will be an <code>AbortError</code>:</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst controller = new AbortController();\nconst { signal } = controller;\nconst grep = spawn('grep', ['ssh'], { signal });\ngrep.on('error', (err) => {\n  // This will be called with err being an AbortError if the controller aborts\n});\ncontroller.abort(); // Stops the child process\n</code></pre>",
               "properties": [
                 {
                   "textRaw": "`options.detached`",
@@ -578,6 +696,11 @@
                       "v0.7.10"
                     ],
                     "changes": [
+                      {
+                        "version": "v14.18.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/29412",
+                        "description": "Added the `overlapped` stdio flag."
+                      },
                       {
                         "version": "v3.3.1",
                         "pr-url": "https://github.com/nodejs/node/pull/2727",
@@ -585,7 +708,7 @@
                       }
                     ]
                   },
-                  "desc": "<p>The <code>options.stdio</code> option is used to configure the pipes that are established\nbetween the parent and child process. By default, the child's stdin, stdout,\nand stderr are redirected to corresponding <a href=\"#child_process_subprocess_stdin\"><code>subprocess.stdin</code></a>,\n<a href=\"#child_process_subprocess_stdout\"><code>subprocess.stdout</code></a>, and <a href=\"#child_process_subprocess_stderr\"><code>subprocess.stderr</code></a> streams on the\n<a href=\"#child_process_child_process\"><code>ChildProcess</code></a> object. This is equivalent to setting the <code>options.stdio</code>\nequal to <code>['pipe', 'pipe', 'pipe']</code>.</p>\n<p>For convenience, <code>options.stdio</code> may be one of the following strings:</p>\n<ul>\n<li><code>'pipe'</code>: equivalent to <code>['pipe', 'pipe', 'pipe']</code> (the default)</li>\n<li><code>'ignore'</code>: equivalent to <code>['ignore', 'ignore', 'ignore']</code></li>\n<li><code>'inherit'</code>: equivalent to <code>['inherit', 'inherit', 'inherit']</code> or <code>[0, 1, 2]</code></li>\n</ul>\n<p>Otherwise, the value of <code>options.stdio</code> is an array where each index corresponds\nto an fd in the child. The fds 0, 1, and 2 correspond to stdin, stdout,\nand stderr, respectively. Additional fds can be specified to create additional\npipes between the parent and child. The value is one of the following:</p>\n<ol>\n<li>\n<p><code>'pipe'</code>: Create a pipe between the child process and the parent process.\nThe parent end of the pipe is exposed to the parent as a property on the\n<code>child_process</code> object as <a href=\"#child_process_subprocess_stdio\"><code>subprocess.stdio[fd]</code></a>. Pipes\ncreated for fds 0, 1, and 2 are also available as <a href=\"#child_process_subprocess_stdin\"><code>subprocess.stdin</code></a>,\n<a href=\"#child_process_subprocess_stdout\"><code>subprocess.stdout</code></a> and <a href=\"#child_process_subprocess_stderr\"><code>subprocess.stderr</code></a>, respectively.</p>\n</li>\n<li>\n<p><code>'ipc'</code>: Create an IPC channel for passing messages/file descriptors\nbetween parent and child. A <a href=\"#child_process_child_process\"><code>ChildProcess</code></a> may have at most one IPC\nstdio file descriptor. Setting this option enables the\n<a href=\"#child_process_subprocess_send_message_sendhandle_options_callback\"><code>subprocess.send()</code></a> method. If the child is a Node.js process, the\npresence of an IPC channel will enable <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> and\n<a href=\"process.html#process_process_disconnect\"><code>process.disconnect()</code></a> methods, as well as <a href=\"process.html#process_event_disconnect\"><code>'disconnect'</code></a> and\n<a href=\"process.html#process_event_message\"><code>'message'</code></a> events within the child.</p>\n<p>Accessing the IPC channel fd in any way other than <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a>\nor using the IPC channel with a child process that is not a Node.js instance\nis not supported.</p>\n</li>\n<li>\n<p><code>'ignore'</code>: Instructs Node.js to ignore the fd in the child. While Node.js\nwill always open fds 0, 1, and 2 for the processes it spawns, setting the fd\nto <code>'ignore'</code> will cause Node.js to open <code>/dev/null</code> and attach it to the\nchild's fd.</p>\n</li>\n<li>\n<p><code>'inherit'</code>: Pass through the corresponding stdio stream to/from the\nparent process. In the first three positions, this is equivalent to\n<code>process.stdin</code>, <code>process.stdout</code>, and <code>process.stderr</code>, respectively. In\nany other position, equivalent to <code>'ignore'</code>.</p>\n</li>\n<li>\n<p><a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a> object: Share a readable or writable stream that refers to a tty,\nfile, socket, or a pipe with the child process. The stream's underlying\nfile descriptor is duplicated in the child process to the fd that\ncorresponds to the index in the <code>stdio</code> array. The stream must have an\nunderlying descriptor (file streams do not until the <code>'open'</code> event has\noccurred).</p>\n</li>\n<li>\n<p>Positive integer: The integer value is interpreted as a file descriptor\nthat is currently open in the parent process. It is shared with the child\nprocess, similar to how <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a> objects can be shared. Passing sockets\nis not supported on Windows.</p>\n</li>\n<li>\n<p><code>null</code>, <code>undefined</code>: Use default value. For stdio fds 0, 1, and 2 (in other\nwords, stdin, stdout, and stderr) a pipe is created. For fd 3 and up, the\ndefault is <code>'ignore'</code>.</p>\n</li>\n</ol>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\n\n// Child will use parent's stdios.\nspawn('prg', [], { stdio: 'inherit' });\n\n// Spawn child sharing only stderr.\nspawn('prg', [], { stdio: ['pipe', 'pipe', process.stderr] });\n\n// Open an extra fd=4, to interact with programs presenting a\n// startd-style interface.\nspawn('prg', [], { stdio: ['pipe', null, null, null, 'pipe'] });\n</code></pre>\n<p><em>It is worth noting that when an IPC channel is established between the\nparent and child processes, and the child is a Node.js process, the child\nis launched with the IPC channel unreferenced (using <code>unref()</code>) until the\nchild registers an event handler for the <a href=\"process.html#process_event_disconnect\"><code>'disconnect'</code></a> event\nor the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event. This allows the child to exit\nnormally without the process being held open by the open IPC channel.</em></p>\n<p>On Unix-like operating systems, the <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> method\nperforms memory operations synchronously before decoupling the event loop\nfrom the child. Applications with a large memory footprint may find frequent\n<a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> calls to be a bottleneck. For more information,\nsee <a href=\"https://bugs.chromium.org/p/v8/issues/detail?id=7381\">V8 issue 7381</a>.</p>\n<p>See also: <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> and <a href=\"#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>.</p>"
+                  "desc": "<p>The <code>options.stdio</code> option is used to configure the pipes that are established\nbetween the parent and child process. By default, the child's stdin, stdout,\nand stderr are redirected to corresponding <a href=\"#child_process_subprocess_stdin\"><code>subprocess.stdin</code></a>,\n<a href=\"#child_process_subprocess_stdout\"><code>subprocess.stdout</code></a>, and <a href=\"#child_process_subprocess_stderr\"><code>subprocess.stderr</code></a> streams on the\n<a href=\"#child_process_class_childprocess\"><code>ChildProcess</code></a> object. This is equivalent to setting the <code>options.stdio</code>\nequal to <code>['pipe', 'pipe', 'pipe']</code>.</p>\n<p>For convenience, <code>options.stdio</code> may be one of the following strings:</p>\n<ul>\n<li><code>'pipe'</code>: equivalent to <code>['pipe', 'pipe', 'pipe']</code> (the default)</li>\n<li><code>'overlapped'</code>: equivalent to <code>['overlapped', 'overlapped', 'overlapped']</code></li>\n<li><code>'ignore'</code>: equivalent to <code>['ignore', 'ignore', 'ignore']</code></li>\n<li><code>'inherit'</code>: equivalent to <code>['inherit', 'inherit', 'inherit']</code> or <code>[0, 1, 2]</code></li>\n</ul>\n<p>Otherwise, the value of <code>options.stdio</code> is an array where each index corresponds\nto an fd in the child. The fds 0, 1, and 2 correspond to stdin, stdout,\nand stderr, respectively. Additional fds can be specified to create additional\npipes between the parent and child. The value is one of the following:</p>\n<ol>\n<li>\n<p><code>'pipe'</code>: Create a pipe between the child process and the parent process.\nThe parent end of the pipe is exposed to the parent as a property on the\n<code>child_process</code> object as <a href=\"#child_process_subprocess_stdio\"><code>subprocess.stdio[fd]</code></a>. Pipes\ncreated for fds 0, 1, and 2 are also available as <a href=\"#child_process_subprocess_stdin\"><code>subprocess.stdin</code></a>,\n<a href=\"#child_process_subprocess_stdout\"><code>subprocess.stdout</code></a> and <a href=\"#child_process_subprocess_stderr\"><code>subprocess.stderr</code></a>, respectively.</p>\n</li>\n<li>\n<p><code>'overlapped'</code>: Same as <code>'pipe'</code> except that the <code>FILE_FLAG_OVERLAPPED</code> flag\nis set on the handle. This is necessary for overlapped I/O on the child\nprocess's stdio handles. See the\n<a href=\"https://docs.microsoft.com/en-us/windows/win32/fileio/synchronous-and-asynchronous-i-o\">docs</a>\nfor more details. This is exactly the same as <code>'pipe'</code> on non-Windows\nsystems.</p>\n</li>\n<li>\n<p><code>'ipc'</code>: Create an IPC channel for passing messages/file descriptors\nbetween parent and child. A <a href=\"#child_process_class_childprocess\"><code>ChildProcess</code></a> may have at most one IPC\nstdio file descriptor. Setting this option enables the\n<a href=\"#child_process_subprocess_send_message_sendhandle_options_callback\"><code>subprocess.send()</code></a> method. If the child is a Node.js process, the\npresence of an IPC channel will enable <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> and\n<a href=\"process.html#process_process_disconnect\"><code>process.disconnect()</code></a> methods, as well as <a href=\"process.html#process_event_disconnect\"><code>'disconnect'</code></a> and\n<a href=\"process.html#process_event_message\"><code>'message'</code></a> events within the child.</p>\n<p>Accessing the IPC channel fd in any way other than <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a>\nor using the IPC channel with a child process that is not a Node.js instance\nis not supported.</p>\n</li>\n<li>\n<p><code>'ignore'</code>: Instructs Node.js to ignore the fd in the child. While Node.js\nwill always open fds 0, 1, and 2 for the processes it spawns, setting the fd\nto <code>'ignore'</code> will cause Node.js to open <code>/dev/null</code> and attach it to the\nchild's fd.</p>\n</li>\n<li>\n<p><code>'inherit'</code>: Pass through the corresponding stdio stream to/from the\nparent process. In the first three positions, this is equivalent to\n<code>process.stdin</code>, <code>process.stdout</code>, and <code>process.stderr</code>, respectively. In\nany other position, equivalent to <code>'ignore'</code>.</p>\n</li>\n<li>\n<p><a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a> object: Share a readable or writable stream that refers to a tty,\nfile, socket, or a pipe with the child process. The stream's underlying\nfile descriptor is duplicated in the child process to the fd that\ncorresponds to the index in the <code>stdio</code> array. The stream must have an\nunderlying descriptor (file streams do not until the <code>'open'</code> event has\noccurred).</p>\n</li>\n<li>\n<p>Positive integer: The integer value is interpreted as a file descriptor\nthat is currently open in the parent process. It is shared with the child\nprocess, similar to how <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a> objects can be shared. Passing sockets\nis not supported on Windows.</p>\n</li>\n<li>\n<p><code>null</code>, <code>undefined</code>: Use default value. For stdio fds 0, 1, and 2 (in other\nwords, stdin, stdout, and stderr) a pipe is created. For fd 3 and up, the\ndefault is <code>'ignore'</code>.</p>\n</li>\n</ol>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\n\n// Child will use parent's stdios.\nspawn('prg', [], { stdio: 'inherit' });\n\n// Spawn child sharing only stderr.\nspawn('prg', [], { stdio: ['pipe', 'pipe', process.stderr] });\n\n// Open an extra fd=4, to interact with programs presenting a\n// startd-style interface.\nspawn('prg', [], { stdio: ['pipe', null, null, null, 'pipe'] });\n</code></pre>\n<p><em>It is worth noting that when an IPC channel is established between the\nparent and child processes, and the child is a Node.js process, the child\nis launched with the IPC channel unreferenced (using <code>unref()</code>) until the\nchild registers an event handler for the <a href=\"process.html#process_event_disconnect\"><code>'disconnect'</code></a> event\nor the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event. This allows the child to exit\nnormally without the process being held open by the open IPC channel.</em></p>\n<p>On Unix-like operating systems, the <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> method\nperforms memory operations synchronously before decoupling the event loop\nfrom the child. Applications with a large memory footprint may find frequent\n<a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> calls to be a bottleneck. For more information,\nsee <a href=\"https://bugs.chromium.org/p/v8/issues/detail?id=7381\">V8 issue 7381</a>.</p>\n<p>See also: <a href=\"#child_process_child_process_exec_command_options_callback\"><code>child_process.exec()</code></a> and <a href=\"#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>.</p>"
                 }
               ]
             }
@@ -607,6 +730,11 @@
                   "v0.11.12"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
                   {
                     "version": "v10.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22409",
@@ -623,7 +751,10 @@
                     "description": "The `input` option can now be a `Uint8Array`."
                   },
                   {
-                    "version": "v6.2.1, v4.5.0",
+                    "version": [
+                      "v6.2.1",
+                      "v4.5.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/6939",
                     "description": "The `encoding` option can now explicitly be set to `buffer`."
                   }
@@ -656,9 +787,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -751,6 +882,11 @@
                   "v0.11.12"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
                   {
                     "version": "v10.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22409",
@@ -789,9 +925,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -884,6 +1020,11 @@
                   "v0.11.12"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/38862",
+                    "description": "The `cwd` option can be a WHATWG `URL` object using `file:` protocol."
+                  },
                   {
                     "version": "v10.10.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22409",
@@ -900,7 +1041,10 @@
                     "description": "The `input` option can now be a `Uint8Array`."
                   },
                   {
-                    "version": "v6.2.1, v4.5.0",
+                    "version": [
+                      "v6.2.1",
+                      "v4.5.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/6939",
                     "description": "The `encoding` option can now explicitly be set to `buffer`."
                   },
@@ -981,9 +1125,9 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`cwd` {string} Current working directory of the child process.",
+                          "textRaw": "`cwd` {string|URL} Current working directory of the child process.",
                           "name": "cwd",
-                          "type": "string",
+                          "type": "string|URL",
                           "desc": "Current working directory of the child process."
                         },
                         {
@@ -1093,7 +1237,7 @@
         {
           "textRaw": "Shell requirements",
           "name": "shell_requirements",
-          "desc": "<p>The shell should understand the <code>-c</code> switch. If the shell is <code>'cmd.exe'</code>, it\nshould understand the <code>/d /s /c</code> switches and command line parsing should be\ncompatible.</p>",
+          "desc": "<p>The shell should understand the <code>-c</code> switch. If the shell is <code>'cmd.exe'</code>, it\nshould understand the <code>/d /s /c</code> switches and command-line parsing should be\ncompatible.</p>",
           "type": "module",
           "displayName": "Shell requirements"
         },
@@ -1109,6 +1253,7 @@
           "name": "advanced_serialization",
           "meta": {
             "added": [
+              "v13.2.0",
               "v12.16.0"
             ],
             "changes": []
@@ -1155,7 +1300,7 @@
                   "desc": "The signal by which the child process was terminated."
                 }
               ],
-              "desc": "<p>The <code>'close'</code> event is emitted when the stdio streams of a child process have\nbeen closed. This is distinct from the <a href=\"#child_process_event_exit\"><code>'exit'</code></a> event, since multiple\nprocesses might share the same stdio streams.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process close all stdio with code ${code}`);\n});\n\nls.on('exit', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>"
+              "desc": "<p>The <code>'close'</code> event is emitted after a process has ended <em>and</em> the stdio\nstreams of a child process have been closed. This is distinct from the\n<a href=\"#child_process_event_exit\"><code>'exit'</code></a> event, since multiple processes might share the same stdio\nstreams. The <code>'close'</code> event will always emit after <a href=\"#child_process_event_exit\"><code>'exit'</code></a> was\nalready emitted, or <a href=\"#child_process_event_error\"><code>'error'</code></a> if the child failed to spawn.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst ls = spawn('ls', ['-lh', '/usr']);\n\nls.stdout.on('data', (data) => {\n  console.log(`stdout: ${data}`);\n});\n\nls.on('close', (code) => {\n  console.log(`child process close all stdio with code ${code}`);\n});\n\nls.on('exit', (code) => {\n  console.log(`child process exited with code ${code}`);\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'disconnect'`",
@@ -1235,6 +1380,19 @@
                 }
               ],
               "desc": "<p>The <code>'message'</code> event is triggered when a child process uses\n<a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> to send messages.</p>\n<p>The message goes through serialization and parsing. The resulting\nmessage might not be the same as what is originally sent.</p>\n<p>If the <code>serialization</code> option was set to <code>'advanced'</code> used when spawning the\nchild process, the <code>message</code> argument can contain data that JSON is not able\nto represent.\nSee <a href=\"#child_process_advanced_serialization\">Advanced serialization</a> for more details.</p>"
+            },
+            {
+              "textRaw": "Event: `'spawn'`",
+              "type": "event",
+              "name": "spawn",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>The <code>'spawn'</code> event is emitted once the child process has spawned successfully.\nIf the child process does not spawn successfully, the <code>'spawn'</code> event is not\nemitted and the <code>'error'</code> event is emitted instead.</p>\n<p>If emitted, the <code>'spawn'</code> event comes before all other events and before any\ndata is received via <code>stdout</code> or <code>stderr</code>.</p>\n<p>The <code>'spawn'</code> event will fire regardless of whether an error occurs <strong>within</strong>\nthe spawned process. For example, if <code>bash some-command</code> spawns successfully,\nthe <code>'spawn'</code> event will fire, though <code>bash</code> may fail to spawn <code>some-command</code>.\nThis caveat also applies when using <code>{ shell: true }</code>.</p>"
             }
           ],
           "properties": [
@@ -1246,10 +1404,52 @@
                 "added": [
                   "v7.1.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/30165",
+                    "description": "The object no longer accidentally exposes native C++ bindings."
+                  }
+                ]
               },
               "desc": "<p>The <code>subprocess.channel</code> property is a reference to the child's IPC channel. If\nno IPC channel currently exists, this property is <code>undefined</code>.</p>",
-              "shortDesc": "A pipe representing the IPC channel to the child process."
+              "shortDesc": "A pipe representing the IPC channel to the child process.",
+              "methods": [
+                {
+                  "textRaw": "`subprocess.channel.ref()`",
+                  "type": "method",
+                  "name": "ref",
+                  "meta": {
+                    "added": [
+                      "v7.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>This method makes the IPC channel keep the event loop of the parent process\nrunning if <code>.unref()</code> has been called before.</p>"
+                },
+                {
+                  "textRaw": "`subprocess.channel.unref()`",
+                  "type": "method",
+                  "name": "unref",
+                  "meta": {
+                    "added": [
+                      "v7.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>This method makes the IPC channel not keep the event loop of the parent process\nrunning, and lets it finish even while the channel is open.</p>"
+                }
+              ]
             },
             {
               "textRaw": "`connected` {boolean} Set to `false` after `subprocess.disconnect()` is called.",
@@ -1284,8 +1484,8 @@
               "shortDesc": "Set to `true` after `subprocess.kill()` is used to successfully send a signal to the child process."
             },
             {
-              "textRaw": "`pid` {integer}",
-              "type": "integer",
+              "textRaw": "`pid` {integer|undefined}",
+              "type": "integer|undefined",
               "name": "pid",
               "meta": {
                 "added": [
@@ -1293,19 +1493,19 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Returns the process identifier (PID) of the child process.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst grep = spawn('grep', ['ssh']);\n\nconsole.log(`Spawned child pid: ${grep.pid}`);\ngrep.stdin.end();\n</code></pre>"
+              "desc": "<p>Returns the process identifier (PID) of the child process. If the child process\nfails to spawn due to errors, then the value is <code>undefined</code> and <code>error</code> is\nemitted.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst grep = spawn('grep', ['ssh']);\n\nconsole.log(`Spawned child pid: ${grep.pid}`);\ngrep.stdin.end();\n</code></pre>"
             },
             {
-              "textRaw": "`signalCode` {integer}",
-              "type": "integer",
+              "textRaw": "`signalCode` {string|null}",
+              "type": "string|null",
               "name": "signalCode",
-              "desc": "<p>The <code>subprocess.signalCode</code> property indicates the signal number received by\nthe child process if any, else <code>null</code>.</p>"
+              "desc": "<p>The <code>subprocess.signalCode</code> property indicates the signal received by\nthe child process if any, else <code>null</code>.</p>"
             },
             {
               "textRaw": "`spawnargs` {Array}",
               "type": "Array",
               "name": "spawnargs",
-              "desc": "<p>The <code>subprocess.spawnargs</code> property represents the full list of command line\narguments the child process was launched with.</p>"
+              "desc": "<p>The <code>subprocess.spawnargs</code> property represents the full list of command-line\narguments the child process was launched with.</p>"
             },
             {
               "textRaw": "`spawnfile` {string}",
@@ -1323,7 +1523,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A <code>Readable Stream</code> that represents the child process's <code>stderr</code>.</p>\n<p>If the child was spawned with <code>stdio[2]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stderr</code> is an alias for <code>subprocess.stdio[2]</code>. Both properties will\nrefer to the same value.</p>"
+              "desc": "<p>A <code>Readable Stream</code> that represents the child process's <code>stderr</code>.</p>\n<p>If the child was spawned with <code>stdio[2]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stderr</code> is an alias for <code>subprocess.stdio[2]</code>. Both properties will\nrefer to the same value.</p>\n<p>The <code>subprocess.stderr</code> property can be <code>null</code> if the child process could\nnot be successfully spawned.</p>"
             },
             {
               "textRaw": "`stdin` {stream.Writable}",
@@ -1335,7 +1535,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A <code>Writable Stream</code> that represents the child process's <code>stdin</code>.</p>\n<p>If a child process waits to read all of its input, the child will not continue\nuntil this stream has been closed via <code>end()</code>.</p>\n<p>If the child was spawned with <code>stdio[0]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stdin</code> is an alias for <code>subprocess.stdio[0]</code>. Both properties will\nrefer to the same value.</p>"
+              "desc": "<p>A <code>Writable Stream</code> that represents the child process's <code>stdin</code>.</p>\n<p>If a child process waits to read all of its input, the child will not continue\nuntil this stream has been closed via <code>end()</code>.</p>\n<p>If the child was spawned with <code>stdio[0]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stdin</code> is an alias for <code>subprocess.stdio[0]</code>. Both properties will\nrefer to the same value.</p>\n<p>The <code>subprocess.stdin</code> property can be <code>undefined</code> if the child process could\nnot be successfully spawned.</p>"
             },
             {
               "textRaw": "`stdio` {Array}",
@@ -1347,7 +1547,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A sparse array of pipes to the child process, corresponding with positions in\nthe <a href=\"#child_process_options_stdio\"><code>stdio</code></a> option passed to <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> that have been set\nto the value <code>'pipe'</code>. <code>subprocess.stdio[0]</code>, <code>subprocess.stdio[1]</code>, and\n<code>subprocess.stdio[2]</code> are also available as <code>subprocess.stdin</code>,\n<code>subprocess.stdout</code>, and <code>subprocess.stderr</code>, respectively.</p>\n<p>In the following example, only the child's fd <code>1</code> (stdout) is configured as a\npipe, so only the parent's <code>subprocess.stdio[1]</code> is a stream, all other values\nin the array are <code>null</code>.</p>\n<pre><code class=\"language-js\">const assert = require('assert');\nconst fs = require('fs');\nconst child_process = require('child_process');\n\nconst subprocess = child_process.spawn('ls', {\n  stdio: [\n    0, // Use parent's stdin for child.\n    'pipe', // Pipe child's stdout to parent.\n    fs.openSync('err.out', 'w') // Direct child's stderr to a file.\n  ]\n});\n\nassert.strictEqual(subprocess.stdio[0], null);\nassert.strictEqual(subprocess.stdio[0], subprocess.stdin);\n\nassert(subprocess.stdout);\nassert.strictEqual(subprocess.stdio[1], subprocess.stdout);\n\nassert.strictEqual(subprocess.stdio[2], null);\nassert.strictEqual(subprocess.stdio[2], subprocess.stderr);\n</code></pre>"
+              "desc": "<p>A sparse array of pipes to the child process, corresponding with positions in\nthe <a href=\"#child_process_options_stdio\"><code>stdio</code></a> option passed to <a href=\"#child_process_child_process_spawn_command_args_options\"><code>child_process.spawn()</code></a> that have been set\nto the value <code>'pipe'</code>. <code>subprocess.stdio[0]</code>, <code>subprocess.stdio[1]</code>, and\n<code>subprocess.stdio[2]</code> are also available as <code>subprocess.stdin</code>,\n<code>subprocess.stdout</code>, and <code>subprocess.stderr</code>, respectively.</p>\n<p>In the following example, only the child's fd <code>1</code> (stdout) is configured as a\npipe, so only the parent's <code>subprocess.stdio[1]</code> is a stream, all other values\nin the array are <code>null</code>.</p>\n<pre><code class=\"language-js\">const assert = require('assert');\nconst fs = require('fs');\nconst child_process = require('child_process');\n\nconst subprocess = child_process.spawn('ls', {\n  stdio: [\n    0, // Use parent's stdin for child.\n    'pipe', // Pipe child's stdout to parent.\n    fs.openSync('err.out', 'w'), // Direct child's stderr to a file.\n  ]\n});\n\nassert.strictEqual(subprocess.stdio[0], null);\nassert.strictEqual(subprocess.stdio[0], subprocess.stdin);\n\nassert(subprocess.stdout);\nassert.strictEqual(subprocess.stdio[1], subprocess.stdout);\n\nassert.strictEqual(subprocess.stdio[2], null);\nassert.strictEqual(subprocess.stdio[2], subprocess.stderr);\n</code></pre>\n<p>The <code>subprocess.stdio</code> property can be <code>undefined</code> if the child process could\nnot be successfully spawned.</p>"
             },
             {
               "textRaw": "`stdout` {stream.Readable}",
@@ -1359,7 +1559,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A <code>Readable Stream</code> that represents the child process's <code>stdout</code>.</p>\n<p>If the child was spawned with <code>stdio[1]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stdout</code> is an alias for <code>subprocess.stdio[1]</code>. Both properties will\nrefer to the same value.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\n\nconst subprocess = spawn('ls');\n\nsubprocess.stdout.on('data', (data) => {\n  console.log(`Received chunk ${data}`);\n});\n</code></pre>"
+              "desc": "<p>A <code>Readable Stream</code> that represents the child process's <code>stdout</code>.</p>\n<p>If the child was spawned with <code>stdio[1]</code> set to anything other than <code>'pipe'</code>,\nthen this will be <code>null</code>.</p>\n<p><code>subprocess.stdout</code> is an alias for <code>subprocess.stdio[1]</code>. Both properties will\nrefer to the same value.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\n\nconst subprocess = spawn('ls');\n\nsubprocess.stdout.on('data', (data) => {\n  console.log(`Received chunk ${data}`);\n});\n</code></pre>\n<p>The <code>subprocess.stdout</code> property can be <code>null</code> if the child process could\nnot be successfully spawned.</p>"
             }
           ],
           "methods": [
@@ -1406,7 +1606,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>subprocess.kill()</code> method sends a signal to the child process. If no\nargument is given, the process will be sent the <code>'SIGTERM'</code> signal. See\n<a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a> for a list of available signals. This function returns <code>true</code> if\n<a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a> succeeds, and <code>false</code> otherwise.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst grep = spawn('grep', ['ssh']);\n\ngrep.on('close', (code, signal) => {\n  console.log(\n    `child process terminated due to receipt of signal ${signal}`);\n});\n\n// Send SIGHUP to process.\ngrep.kill('SIGHUP');\n</code></pre>\n<p>The <a href=\"#child_process_child_process\"><code>ChildProcess</code></a> object may emit an <a href=\"#child_process_event_error\"><code>'error'</code></a> event if the signal\ncannot be delivered. Sending a signal to a child process that has already exited\nis not an error but may have unforeseen consequences. Specifically, if the\nprocess identifier (PID) has been reassigned to another process, the signal will\nbe delivered to that process instead which can have unexpected results.</p>\n<p>While the function is called <code>kill</code>, the signal delivered to the child process\nmay not actually terminate the process.</p>\n<p>See <a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a> for reference.</p>\n<p>On Linux, child processes of child processes will not be terminated\nwhen attempting to kill their parent. This is likely to happen when running a\nnew process in a shell or with the use of the <code>shell</code> option of <code>ChildProcess</code>:</p>\n<pre><code class=\"language-js\">'use strict';\nconst { spawn } = require('child_process');\n\nconst subprocess = spawn(\n  'sh',\n  [\n    '-c',\n    `node -e \"setInterval(() => {\n      console.log(process.pid, 'is alive')\n    }, 500);\"`\n  ], {\n    stdio: ['inherit', 'inherit', 'inherit']\n  }\n);\n\nsetTimeout(() => {\n  subprocess.kill(); // Does not terminate the Node.js process in the shell.\n}, 2000);\n</code></pre>"
+              "desc": "<p>The <code>subprocess.kill()</code> method sends a signal to the child process. If no\nargument is given, the process will be sent the <code>'SIGTERM'</code> signal. See\n<a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a> for a list of available signals. This function returns <code>true</code> if\n<a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a> succeeds, and <code>false</code> otherwise.</p>\n<pre><code class=\"language-js\">const { spawn } = require('child_process');\nconst grep = spawn('grep', ['ssh']);\n\ngrep.on('close', (code, signal) => {\n  console.log(\n    `child process terminated due to receipt of signal ${signal}`);\n});\n\n// Send SIGHUP to process.\ngrep.kill('SIGHUP');\n</code></pre>\n<p>The <a href=\"#child_process_class_childprocess\"><code>ChildProcess</code></a> object may emit an <a href=\"#child_process_event_error\"><code>'error'</code></a> event if the signal\ncannot be delivered. Sending a signal to a child process that has already exited\nis not an error but may have unforeseen consequences. Specifically, if the\nprocess identifier (PID) has been reassigned to another process, the signal will\nbe delivered to that process instead which can have unexpected results.</p>\n<p>While the function is called <code>kill</code>, the signal delivered to the child process\nmay not actually terminate the process.</p>\n<p>See <a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a> for reference.</p>\n<p>On Windows, where POSIX signals do not exist, the <code>signal</code> argument will be\nignored, and the process will be killed forcefully and abruptly (similar to\n<code>'SIGKILL'</code>).\nSee <a href=\"process.html#process_signal_events\">Signal Events</a> for more details.</p>\n<p>On Linux, child processes of child processes will not be terminated\nwhen attempting to kill their parent. This is likely to happen when running a\nnew process in a shell or with the use of the <code>shell</code> option of <code>ChildProcess</code>:</p>\n<pre><code class=\"language-js\">'use strict';\nconst { spawn } = require('child_process');\n\nconst subprocess = spawn(\n  'sh',\n  [\n    '-c',\n    `node -e \"setInterval(() => {\n      console.log(process.pid, 'is alive')\n    }, 500);\"`,\n  ], {\n    stdio: ['inherit', 'inherit', 'inherit']\n  }\n);\n\nsetTimeout(() => {\n  subprocess.kill(); // Does not terminate the Node.js process in the shell.\n}, 2000);\n</code></pre>"
             },
             {
               "textRaw": "`subprocess.ref()`",
@@ -1492,7 +1692,7 @@
                   ]
                 }
               ],
-              "desc": "<p>When an IPC channel has been established between the parent and child (\ni.e. when using <a href=\"#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>), the <code>subprocess.send()</code> method can\nbe used to send messages to the child process. When the child process is a\nNode.js instance, these messages can be received via the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event.</p>\n<p>The message goes through serialization and parsing. The resulting\nmessage might not be the same as what is originally sent.</p>\n<p>For example, in the parent script:</p>\n<pre><code class=\"language-js\">const cp = require('child_process');\nconst n = cp.fork(`${__dirname}/sub.js`);\n\nn.on('message', (m) => {\n  console.log('PARENT got message:', m);\n});\n\n// Causes the child to print: CHILD got message: { hello: 'world' }\nn.send({ hello: 'world' });\n</code></pre>\n<p>And then the child script, <code>'sub.js'</code> might look like this:</p>\n<pre><code class=\"language-js\">process.on('message', (m) => {\n  console.log('CHILD got message:', m);\n});\n\n// Causes the parent to print: PARENT got message: { foo: 'bar', baz: null }\nprocess.send({ foo: 'bar', baz: NaN });\n</code></pre>\n<p>Child Node.js processes will have a <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> method of their own\nthat allows the child to send messages back to the parent.</p>\n<p>There is a special case when sending a <code>{cmd: 'NODE_foo'}</code> message. Messages\ncontaining a <code>NODE_</code> prefix in the <code>cmd</code> property are reserved for use within\nNode.js core and will not be emitted in the child's <a href=\"process.html#process_event_message\"><code>'message'</code></a>\nevent. Rather, such messages are emitted using the\n<code>'internalMessage'</code> event and are consumed internally by Node.js.\nApplications should avoid using such messages or listening for\n<code>'internalMessage'</code> events as it is subject to change without notice.</p>\n<p>The optional <code>sendHandle</code> argument that may be passed to <code>subprocess.send()</code> is\nfor passing a TCP server or socket object to the child process. The child will\nreceive the object as the second argument passed to the callback function\nregistered on the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event. Any data that is received\nand buffered in the socket will not be sent to the child.</p>\n<p>The optional <code>callback</code> is a function that is invoked after the message is\nsent but before the child may have received it. The function is called with a\nsingle argument: <code>null</code> on success, or an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object on failure.</p>\n<p>If no <code>callback</code> function is provided and the message cannot be sent, an\n<code>'error'</code> event will be emitted by the <a href=\"#child_process_child_process\"><code>ChildProcess</code></a> object. This can\nhappen, for instance, when the child process has already exited.</p>\n<p><code>subprocess.send()</code> will return <code>false</code> if the channel has closed or when the\nbacklog of unsent messages exceeds a threshold that makes it unwise to send\nmore. Otherwise, the method returns <code>true</code>. The <code>callback</code> function can be\nused to implement flow control.</p>\n<h4>Example: sending a server object</h4>\n<p>The <code>sendHandle</code> argument can be used, for instance, to pass the handle of\na TCP server object to the child process as illustrated in the example below:</p>\n<pre><code class=\"language-js\">const subprocess = require('child_process').fork('subprocess.js');\n\n// Open up the server object and send the handle.\nconst server = require('net').createServer();\nserver.on('connection', (socket) => {\n  socket.end('handled by parent');\n});\nserver.listen(1337, () => {\n  subprocess.send('server', server);\n});\n</code></pre>\n<p>The child would then receive the server object as:</p>\n<pre><code class=\"language-js\">process.on('message', (m, server) => {\n  if (m === 'server') {\n    server.on('connection', (socket) => {\n      socket.end('handled by child');\n    });\n  }\n});\n</code></pre>\n<p>Once the server is now shared between the parent and child, some connections\ncan be handled by the parent and some by the child.</p>\n<p>While the example above uses a server created using the <code>net</code> module, <code>dgram</code>\nmodule servers use exactly the same workflow with the exceptions of listening on\na <code>'message'</code> event instead of <code>'connection'</code> and using <code>server.bind()</code> instead\nof <code>server.listen()</code>. This is, however, currently only supported on Unix\nplatforms.</p>\n<h4>Example: sending a socket object</h4>\n<p>Similarly, the <code>sendHandler</code> argument can be used to pass the handle of a\nsocket to the child process. The example below spawns two children that each\nhandle connections with \"normal\" or \"special\" priority:</p>\n<pre><code class=\"language-js\">const { fork } = require('child_process');\nconst normal = fork('subprocess.js', ['normal']);\nconst special = fork('subprocess.js', ['special']);\n\n// Open up the server and send sockets to child. Use pauseOnConnect to prevent\n// the sockets from being read before they are sent to the child process.\nconst server = require('net').createServer({ pauseOnConnect: true });\nserver.on('connection', (socket) => {\n\n  // If this is special priority...\n  if (socket.remoteAddress === '74.125.127.100') {\n    special.send('socket', socket);\n    return;\n  }\n  // This is normal priority.\n  normal.send('socket', socket);\n});\nserver.listen(1337);\n</code></pre>\n<p>The <code>subprocess.js</code> would receive the socket handle as the second argument\npassed to the event callback function:</p>\n<pre><code class=\"language-js\">process.on('message', (m, socket) => {\n  if (m === 'socket') {\n    if (socket) {\n      // Check that the client socket exists.\n      // It is possible for the socket to be closed between the time it is\n      // sent and the time it is received in the child process.\n      socket.end(`Request handled with ${process.argv[2]} priority`);\n    }\n  }\n});\n</code></pre>\n<p>Do not use <code>.maxConnections</code> on a socket that has been passed to a subprocess.\nThe parent cannot track when the socket is destroyed.</p>\n<p>Any <code>'message'</code> handlers in the subprocess should verify that <code>socket</code> exists,\nas the connection may have been closed during the time it takes to send the\nconnection to the child.</p>"
+              "desc": "<p>When an IPC channel has been established between the parent and child (\ni.e. when using <a href=\"#child_process_child_process_fork_modulepath_args_options\"><code>child_process.fork()</code></a>), the <code>subprocess.send()</code> method can\nbe used to send messages to the child process. When the child process is a\nNode.js instance, these messages can be received via the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event.</p>\n<p>The message goes through serialization and parsing. The resulting\nmessage might not be the same as what is originally sent.</p>\n<p>For example, in the parent script:</p>\n<pre><code class=\"language-js\">const cp = require('child_process');\nconst n = cp.fork(`${__dirname}/sub.js`);\n\nn.on('message', (m) => {\n  console.log('PARENT got message:', m);\n});\n\n// Causes the child to print: CHILD got message: { hello: 'world' }\nn.send({ hello: 'world' });\n</code></pre>\n<p>And then the child script, <code>'sub.js'</code> might look like this:</p>\n<pre><code class=\"language-js\">process.on('message', (m) => {\n  console.log('CHILD got message:', m);\n});\n\n// Causes the parent to print: PARENT got message: { foo: 'bar', baz: null }\nprocess.send({ foo: 'bar', baz: NaN });\n</code></pre>\n<p>Child Node.js processes will have a <a href=\"process.html#process_process_send_message_sendhandle_options_callback\"><code>process.send()</code></a> method of their own\nthat allows the child to send messages back to the parent.</p>\n<p>There is a special case when sending a <code>{cmd: 'NODE_foo'}</code> message. Messages\ncontaining a <code>NODE_</code> prefix in the <code>cmd</code> property are reserved for use within\nNode.js core and will not be emitted in the child's <a href=\"process.html#process_event_message\"><code>'message'</code></a>\nevent. Rather, such messages are emitted using the\n<code>'internalMessage'</code> event and are consumed internally by Node.js.\nApplications should avoid using such messages or listening for\n<code>'internalMessage'</code> events as it is subject to change without notice.</p>\n<p>The optional <code>sendHandle</code> argument that may be passed to <code>subprocess.send()</code> is\nfor passing a TCP server or socket object to the child process. The child will\nreceive the object as the second argument passed to the callback function\nregistered on the <a href=\"process.html#process_event_message\"><code>'message'</code></a> event. Any data that is received\nand buffered in the socket will not be sent to the child.</p>\n<p>The optional <code>callback</code> is a function that is invoked after the message is\nsent but before the child may have received it. The function is called with a\nsingle argument: <code>null</code> on success, or an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object on failure.</p>\n<p>If no <code>callback</code> function is provided and the message cannot be sent, an\n<code>'error'</code> event will be emitted by the <a href=\"#child_process_class_childprocess\"><code>ChildProcess</code></a> object. This can\nhappen, for instance, when the child process has already exited.</p>\n<p><code>subprocess.send()</code> will return <code>false</code> if the channel has closed or when the\nbacklog of unsent messages exceeds a threshold that makes it unwise to send\nmore. Otherwise, the method returns <code>true</code>. The <code>callback</code> function can be\nused to implement flow control.</p>\n<h4>Example: sending a server object</h4>\n<p>The <code>sendHandle</code> argument can be used, for instance, to pass the handle of\na TCP server object to the child process as illustrated in the example below:</p>\n<pre><code class=\"language-js\">const subprocess = require('child_process').fork('subprocess.js');\n\n// Open up the server object and send the handle.\nconst server = require('net').createServer();\nserver.on('connection', (socket) => {\n  socket.end('handled by parent');\n});\nserver.listen(1337, () => {\n  subprocess.send('server', server);\n});\n</code></pre>\n<p>The child would then receive the server object as:</p>\n<pre><code class=\"language-js\">process.on('message', (m, server) => {\n  if (m === 'server') {\n    server.on('connection', (socket) => {\n      socket.end('handled by child');\n    });\n  }\n});\n</code></pre>\n<p>Once the server is now shared between the parent and child, some connections\ncan be handled by the parent and some by the child.</p>\n<p>While the example above uses a server created using the <code>net</code> module, <code>dgram</code>\nmodule servers use exactly the same workflow with the exceptions of listening on\na <code>'message'</code> event instead of <code>'connection'</code> and using <code>server.bind()</code> instead\nof <code>server.listen()</code>. This is, however, currently only supported on Unix\nplatforms.</p>\n<h4>Example: sending a socket object</h4>\n<p>Similarly, the <code>sendHandler</code> argument can be used to pass the handle of a\nsocket to the child process. The example below spawns two children that each\nhandle connections with \"normal\" or \"special\" priority:</p>\n<pre><code class=\"language-js\">const { fork } = require('child_process');\nconst normal = fork('subprocess.js', ['normal']);\nconst special = fork('subprocess.js', ['special']);\n\n// Open up the server and send sockets to child. Use pauseOnConnect to prevent\n// the sockets from being read before they are sent to the child process.\nconst server = require('net').createServer({ pauseOnConnect: true });\nserver.on('connection', (socket) => {\n\n  // If this is special priority...\n  if (socket.remoteAddress === '74.125.127.100') {\n    special.send('socket', socket);\n    return;\n  }\n  // This is normal priority.\n  normal.send('socket', socket);\n});\nserver.listen(1337);\n</code></pre>\n<p>The <code>subprocess.js</code> would receive the socket handle as the second argument\npassed to the event callback function:</p>\n<pre><code class=\"language-js\">process.on('message', (m, socket) => {\n  if (m === 'socket') {\n    if (socket) {\n      // Check that the client socket exists.\n      // It is possible for the socket to be closed between the time it is\n      // sent and the time it is received in the child process.\n      socket.end(`Request handled with ${process.argv[2]} priority`);\n    }\n  }\n});\n</code></pre>\n<p>Do not use <code>.maxConnections</code> on a socket that has been passed to a subprocess.\nThe parent cannot track when the socket is destroyed.</p>\n<p>Any <code>'message'</code> handlers in the subprocess should verify that <code>socket</code> exists,\nas the connection may have been closed during the time it takes to send the\nconnection to the child.</p>"
             },
             {
               "textRaw": "`subprocess.unref()`",
diff --git a/doc/api/child_process.md b/doc/api/child_process.md
index 07a08d50869bb692285fd24d7dcb296dea108d43..13e8b1b6f7fae25c74ce2db802276349608357fa 100644
--- a/doc/api/child_process.md
+++ b/doc/api/child_process.md
@@ -6,7 +6,7 @@
 
 <!-- source_link=lib/child_process.js -->
 
-The `child_process` module provides the ability to spawn child processes in
+The `child_process` module provides the ability to spawn subprocesses in
 a manner that is similar, but not identical, to popen(3). This capability
 is primarily provided by the [`child_process.spawn()`][] function:
 
@@ -28,20 +28,23 @@ ls.on('close', (code) => {
 ```
 
 By default, pipes for `stdin`, `stdout`, and `stderr` are established between
-the parent Node.js process and the spawned child. These pipes have
-limited (and platform-specific) capacity. If the child process writes to
-stdout in excess of that limit without the output being captured, the child
-process will block waiting for the pipe buffer to accept more data. This is
+the parent Node.js process and the spawned subprocess. These pipes have
+limited (and platform-specific) capacity. If the subprocess writes to
+stdout in excess of that limit without the output being captured, the
+subprocess blocks waiting for the pipe buffer to accept more data. This is
 identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }`
 option if the output will not be consumed.
 
-The command lookup will be performed using `options.env.PATH` environment
-variable if passed in `options` object, otherwise `process.env.PATH` will be
-used. To account for the fact that Windows environment variables are
-case-insensitive Node.js will lexicographically sort all `env` keys and choose
-the first one case-insensitively matching `PATH` to perform command lookup.
-This may lead to issues on Windows when passing objects to `env` option that
-have multiple variants of `PATH` variable.
+The command lookup is performed using the `options.env.PATH` environment
+variable if it is in the `options` object. Otherwise, `process.env.PATH` is
+used.
+
+On Windows, environment variables are case-insensitive. Node.js
+lexicographically sorts the `env` keys and uses the first one that
+case-insensitively matches. Only first (in lexicographic order) entry will be
+passed to the subprocess. This might lead to issues on Windows when passing
+objects to the `env` option that have multiple variants of the same key, such as
+`PATH` and `Path`.
 
 The [`child_process.spawn()`][] method spawns the child process asynchronously,
 without blocking the Node.js event loop. The [`child_process.spawnSync()`][]
@@ -143,6 +146,13 @@ exec('"my script.cmd" a b', (err, stdout, stderr) => {
 <!-- YAML
 added: v0.1.90
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38862
+    description: The `cwd` option can be a WHATWG `URL` object using
+                 `file:` protocol.
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/36308
+    description: AbortSignal support was added.
   - version: v8.8.0
     pr-url: https://github.com/nodejs/node/pull/15380
     description: The `windowsHide` option is supported now.
@@ -150,13 +160,15 @@ changes:
 
 * `command` {string} The command to run, with space-separated arguments.
 * `options` {Object}
-  * `cwd` {string} Current working directory of the child process.
-    **Default:** `null`.
+  * `cwd` {string|URL} Current working directory of the child process.
+    **Default:** `process.cwd()`.
   * `env` {Object} Environment key-value pairs. **Default:** `process.env`.
   * `encoding` {string} **Default:** `'utf8'`
   * `shell` {string} Shell to execute the command with. See
     [Shell requirements][] and [Default Windows shell][]. **Default:**
     `'/bin/sh'` on Unix, `process.env.ComSpec` on Windows.
+  * `signal` {AbortSignal} allows aborting the child process using an
+    AbortSignal.
   * `timeout` {number} **Default:** `0`
   * `maxBuffer` {number} Largest amount of data in bytes allowed on stdout or
     stderr. If exceeded, the child process is terminated and any output is
@@ -180,6 +192,8 @@ directly by the shell and special characters (vary based on
 need to be dealt with accordingly:
 
 ```js
+const { exec } = require('child_process');
+
 exec('"/path/to/test file/test.sh" arg1 arg2');
 // Double quotes are used so that the space in the path is not interpreted as
 // a delimiter of multiple arguments.
@@ -243,10 +257,31 @@ async function lsExample() {
 lsExample();
 ```
 
+If the `signal` option is enabled, calling `.abort()` on the corresponding
+`AbortController` is similar to calling `.kill()` on the child process except
+the error passed to the callback will be an `AbortError`:
+
+```js
+const { exec } = require('child_process');
+const controller = new AbortController();
+const { signal } = controller;
+const child = exec('grep ssh', { signal }, (error) => {
+  console.log(error); // an AbortError
+});
+controller.abort();
+```
+
 ### `child_process.execFile(file[, args][, options][, callback])`
 <!-- YAML
 added: v0.1.91
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38862
+    description: The `cwd` option can be a WHATWG `URL` object using
+                 `file:` protocol.
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/36308
+    description: AbortSignal support was added.
   - version: v8.8.0
     pr-url: https://github.com/nodejs/node/pull/15380
     description: The `windowsHide` option is supported now.
@@ -255,7 +290,7 @@ changes:
 * `file` {string} The name or path of the executable file to run.
 * `args` {string[]} List of string arguments.
 * `options` {Object}
-  * `cwd` {string} Current working directory of the child process.
+  * `cwd` {string|URL} Current working directory of the child process.
   * `env` {Object} Environment key-value pairs. **Default:** `process.env`.
   * `encoding` {string} **Default:** `'utf8'`
   * `timeout` {number} **Default:** `0`
@@ -274,6 +309,8 @@ changes:
     `'/bin/sh'` on Unix, and `process.env.ComSpec` on Windows. A different
     shell can be specified as a string. See [Shell requirements][] and
     [Default Windows shell][]. **Default:** `false` (no shell).
+  * `signal` {AbortSignal} allows aborting the child process using an
+    AbortSignal.
 * `callback` {Function} Called with the output when process terminates.
   * `error` {Error}
   * `stdout` {string|Buffer}
@@ -327,11 +364,40 @@ getVersion();
 function. Any input containing shell metacharacters may be used to trigger
 arbitrary command execution.**
 
+If the `signal` option is enabled, calling `.abort()` on the corresponding
+`AbortController` is similar to calling `.kill()` on the child process except
+the error passed to the callback will be an `AbortError`:
+
+```js
+const { execFile } = require('child_process');
+const controller = new AbortController();
+const { signal } = controller;
+const child = execFile('node', ['--version'], { signal }, (error) => {
+  console.log(error); // an AbortError
+});
+controller.abort();
+```
+
 ### `child_process.fork(modulePath[, args][, options])`
 <!-- YAML
 added: v0.5.0
 changes:
-  - version: v12.16.0
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38862
+    description: The `cwd` option can be a WHATWG `URL` object using
+                 `file:` protocol.
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37256
+    description: timeout was added.
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37325
+    description: killSignal for AbortSignal was added.
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/36603
+    description: AbortSignal support was added.
+  - version:
+      - v13.2.0
+      - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30162
     description: The `serialization` option is supported now.
   - version: v8.0.0
@@ -345,7 +411,7 @@ changes:
 * `modulePath` {string} The module to run in the child.
 * `args` {string[]} List of string arguments.
 * `options` {Object}
-  * `cwd` {string} Current working directory of the child process.
+  * `cwd` {string|URL} Current working directory of the child process.
   * `detached` {boolean} Prepare child to run independently of its parent
     process. Specific behavior depends on the platform, see
     [`options.detached`][]).
@@ -353,9 +419,14 @@ changes:
   * `execPath` {string} Executable used to create the child process.
   * `execArgv` {string[]} List of string arguments passed to the executable.
     **Default:** `process.execArgv`.
+  * `gid` {number} Sets the group identity of the process (see setgid(2)).
   * `serialization` {string} Specify the kind of serialization used for sending
     messages between processes. Possible values are `'json'` and `'advanced'`.
     See [Advanced serialization][] for more details. **Default:** `'json'`.
+  * `signal` {AbortSignal} Allows closing the child process using an
+    AbortSignal.
+  * `killSignal` {string|integer} The signal value to be used when the spawned
+    process will be killed by timeout or abort signal. **Default:** `'SIGTERM'`.
   * `silent` {boolean} If `true`, stdin, stdout, and stderr of the child will be
     piped to the parent, otherwise they will be inherited from the parent, see
     the `'pipe'` and `'inherit'` options for [`child_process.spawn()`][]'s
@@ -364,10 +435,11 @@ changes:
     When this option is provided, it overrides `silent`. If the array variant
     is used, it must contain exactly one item with value `'ipc'` or an error
     will be thrown. For instance `[0, 1, 2, 'ipc']`.
+  * `uid` {number} Sets the user identity of the process (see setuid(2)).
   * `windowsVerbatimArguments` {boolean} No quoting or escaping of arguments is
     done on Windows. Ignored on Unix. **Default:** `false`.
-  * `uid` {number} Sets the user identity of the process (see setuid(2)).
-  * `gid` {number} Sets the group identity of the process (see setgid(2)).
+  * `timeout` {number} In milliseconds the maximum amount of time the process
+    is allowed to run. **Default:** `undefined`.
 * Returns: {ChildProcess}
 
 The `child_process.fork()` method is a special case of
@@ -398,11 +470,47 @@ current process.
 The `shell` option available in [`child_process.spawn()`][] is not supported by
 `child_process.fork()` and will be ignored if set.
 
+If the `signal` option is enabled, calling `.abort()` on the corresponding
+`AbortController` is similar to calling `.kill()` on the child process except
+the error passed to the callback will be an `AbortError`:
+
+```js
+if (process.argv[2] === 'child') {
+  setTimeout(() => {
+    console.log(`Hello from ${process.argv[2]}!`);
+  }, 1_000);
+} else {
+  const { fork } = require('child_process');
+  const controller = new AbortController();
+  const { signal } = controller;
+  const child = fork(__filename, ['child'], { signal });
+  child.on('error', (err) => {
+    // This will be called with err being an AbortError if the controller aborts
+  });
+  controller.abort(); // Stops the child process
+}
+```
+
 ### `child_process.spawn(command[, args][, options])`
 <!-- YAML
 added: v0.1.90
 changes:
-  - version: v12.16.0
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38862
+    description: The `cwd` option can be a WHATWG `URL` object using
+                 `file:` protocol.
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37256
+    description: timeout was added.
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37325
+    description: killSignal for AbortSignal was added.
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/36432
+    description: AbortSignal support was added.
+  - version:
+      - v13.2.0
+      - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30162
     description: The `serialization` option is supported now.
   - version: v8.8.0
@@ -419,7 +527,7 @@ changes:
 * `command` {string} The command to run.
 * `args` {string[]} List of string arguments.
 * `options` {Object}
-  * `cwd` {string} Current working directory of the child process.
+  * `cwd` {string|URL} Current working directory of the child process.
   * `env` {Object} Environment key-value pairs. **Default:** `process.env`.
   * `argv0` {string} Explicitly set the value of `argv[0]` sent to the child
     process. This will be set to `command` if not specified.
@@ -442,10 +550,17 @@ changes:
     when `shell` is specified and is CMD. **Default:** `false`.
   * `windowsHide` {boolean} Hide the subprocess console window that would
     normally be created on Windows systems. **Default:** `false`.
+  * `signal` {AbortSignal} allows aborting the child process using an
+    AbortSignal.
+  * `timeout` {number} In milliseconds the maximum amount of time the process
+    is allowed to run. **Default:** `undefined`.
+  * `killSignal` {string|integer} The signal value to be used when the spawned
+    process will be killed by timeout or abort signal. **Default:** `'SIGTERM'`.
+
 * Returns: {ChildProcess}
 
 The `child_process.spawn()` method spawns a new process using the given
-`command`, with command line arguments in `args`. If omitted, `args` defaults
+`command`, with command-line arguments in `args`. If omitted, `args` defaults
 to an empty array.
 
 **If the `shell` option is enabled, do not pass unsanitized user input to this
@@ -462,7 +577,10 @@ const defaults = {
 ```
 
 Use `cwd` to specify the working directory from which the process is spawned.
-If not given, the default is to inherit the current working directory.
+If not given, the default is to inherit the current working directory. If given,
+but the path does not exist, the child process emits an `ENOENT` error
+and exits immediately. `ENOENT` is also emitted when the command
+does not exist.
 
 Use `env` to specify environment variables that will be visible to the new
 process, the default is [`process.env`][].
@@ -545,6 +663,21 @@ Node.js currently overwrites `argv[0]` with `process.execPath` on startup, so
 parameter passed to `spawn` from the parent, retrieve it with the
 `process.argv0` property instead.
 
+If the `signal` option is enabled, calling `.abort()` on the corresponding
+`AbortController` is similar to calling `.kill()` on the child process except
+the error passed to the callback will be an `AbortError`:
+
+```js
+const { spawn } = require('child_process');
+const controller = new AbortController();
+const { signal } = controller;
+const grep = spawn('grep', ['ssh'], { signal });
+grep.on('error', (err) => {
+  // This will be called with err being an AbortError if the controller aborts
+});
+controller.abort(); // Stops the child process
+```
+
 #### `options.detached`
 <!-- YAML
 added: v0.7.10
@@ -607,6 +740,9 @@ subprocess.unref();
 <!-- YAML
 added: v0.7.10
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/29412
+    description: Added the `overlapped` stdio flag.
   - version: v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2727
     description: The value `0` is now accepted as a file descriptor.
@@ -622,6 +758,7 @@ equal to `['pipe', 'pipe', 'pipe']`.
 For convenience, `options.stdio` may be one of the following strings:
 
 * `'pipe'`: equivalent to `['pipe', 'pipe', 'pipe']` (the default)
+* `'overlapped'`: equivalent to `['overlapped', 'overlapped', 'overlapped']`
 * `'ignore'`: equivalent to `['ignore', 'ignore', 'ignore']`
 * `'inherit'`: equivalent to `['inherit', 'inherit', 'inherit']` or `[0, 1, 2]`
 
@@ -635,7 +772,13 @@ pipes between the parent and child. The value is one of the following:
    `child_process` object as [`subprocess.stdio[fd]`][`subprocess.stdio`]. Pipes
    created for fds 0, 1, and 2 are also available as [`subprocess.stdin`][],
    [`subprocess.stdout`][] and [`subprocess.stderr`][], respectively.
-2. `'ipc'`: Create an IPC channel for passing messages/file descriptors
+1. `'overlapped'`: Same as `'pipe'` except that the `FILE_FLAG_OVERLAPPED` flag
+   is set on the handle. This is necessary for overlapped I/O on the child
+   process's stdio handles. See the
+   [docs](https://docs.microsoft.com/en-us/windows/win32/fileio/synchronous-and-asynchronous-i-o)
+   for more details. This is exactly the same as `'pipe'` on non-Windows
+   systems.
+1. `'ipc'`: Create an IPC channel for passing messages/file descriptors
    between parent and child. A [`ChildProcess`][] may have at most one IPC
    stdio file descriptor. Setting this option enables the
    [`subprocess.send()`][] method. If the child is a Node.js process, the
@@ -646,25 +789,25 @@ pipes between the parent and child. The value is one of the following:
    Accessing the IPC channel fd in any way other than [`process.send()`][]
    or using the IPC channel with a child process that is not a Node.js instance
    is not supported.
-3. `'ignore'`: Instructs Node.js to ignore the fd in the child. While Node.js
+1. `'ignore'`: Instructs Node.js to ignore the fd in the child. While Node.js
    will always open fds 0, 1, and 2 for the processes it spawns, setting the fd
    to `'ignore'` will cause Node.js to open `/dev/null` and attach it to the
    child's fd.
-4. `'inherit'`: Pass through the corresponding stdio stream to/from the
+1. `'inherit'`: Pass through the corresponding stdio stream to/from the
    parent process. In the first three positions, this is equivalent to
    `process.stdin`, `process.stdout`, and `process.stderr`, respectively. In
    any other position, equivalent to `'ignore'`.
-5. {Stream} object: Share a readable or writable stream that refers to a tty,
+1. {Stream} object: Share a readable or writable stream that refers to a tty,
    file, socket, or a pipe with the child process. The stream's underlying
    file descriptor is duplicated in the child process to the fd that
    corresponds to the index in the `stdio` array. The stream must have an
    underlying descriptor (file streams do not until the `'open'` event has
    occurred).
-6. Positive integer: The integer value is interpreted as a file descriptor
+1. Positive integer: The integer value is interpreted as a file descriptor
    that is currently open in the parent process. It is shared with the child
    process, similar to how {Stream} objects can be shared. Passing sockets
    is not supported on Windows.
-7. `null`, `undefined`: Use default value. For stdio fds 0, 1, and 2 (in other
+1. `null`, `undefined`: Use default value. For stdio fds 0, 1, and 2 (in other
    words, stdin, stdout, and stderr) a pipe is created. For fd 3 and up, the
    default is `'ignore'`.
 
@@ -712,6 +855,10 @@ configuration at startup.
 <!-- YAML
 added: v0.11.12
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38862
+    description: The `cwd` option can be a WHATWG `URL` object using
+                 `file:` protocol.
   - version: v10.10.0
     pr-url: https://github.com/nodejs/node/pull/22409
     description: The `input` option can now be any `TypedArray` or a
@@ -722,7 +869,9 @@ changes:
   - version: v8.0.0
     pr-url: https://github.com/nodejs/node/pull/10653
     description: The `input` option can now be a `Uint8Array`.
-  - version: v6.2.1, v4.5.0
+  - version:
+    - v6.2.1
+    - v4.5.0
     pr-url: https://github.com/nodejs/node/pull/6939
     description: The `encoding` option can now explicitly be set to `buffer`.
 -->
@@ -730,7 +879,7 @@ changes:
 * `file` {string} The name or path of the executable file to run.
 * `args` {string[]} List of string arguments.
 * `options` {Object}
-  * `cwd` {string} Current working directory of the child process.
+  * `cwd` {string|URL} Current working directory of the child process.
   * `input` {string|Buffer|TypedArray|DataView} The value which will be passed
     as stdin to the spawned process. Supplying this value will override
     `stdio[0]`.
@@ -779,6 +928,10 @@ arbitrary command execution.**
 <!-- YAML
 added: v0.11.12
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38862
+    description: The `cwd` option can be a WHATWG `URL` object using
+                 `file:` protocol.
   - version: v10.10.0
     pr-url: https://github.com/nodejs/node/pull/22409
     description: The `input` option can now be any `TypedArray` or a
@@ -793,7 +946,7 @@ changes:
 
 * `command` {string} The command to run.
 * `options` {Object}
-  * `cwd` {string} Current working directory of the child process.
+  * `cwd` {string|URL} Current working directory of the child process.
   * `input` {string|Buffer|TypedArray|DataView} The value which will be passed
     as stdin to the spawned process. Supplying this value will override
     `stdio[0]`.
@@ -839,6 +992,10 @@ metacharacters may be used to trigger arbitrary command execution.**
 <!-- YAML
 added: v0.11.12
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38862
+    description: The `cwd` option can be a WHATWG `URL` object using
+                 `file:` protocol.
   - version: v10.10.0
     pr-url: https://github.com/nodejs/node/pull/22409
     description: The `input` option can now be any `TypedArray` or a
@@ -849,7 +1006,9 @@ changes:
   - version: v8.0.0
     pr-url: https://github.com/nodejs/node/pull/10653
     description: The `input` option can now be a `Uint8Array`.
-  - version: v6.2.1, v4.5.0
+  - version:
+    - v6.2.1
+    - v4.5.0
     pr-url: https://github.com/nodejs/node/pull/6939
     description: The `encoding` option can now explicitly be set to `buffer`.
   - version: v5.7.0
@@ -860,7 +1019,7 @@ changes:
 * `command` {string} The command to run.
 * `args` {string[]} List of string arguments.
 * `options` {Object}
-  * `cwd` {string} Current working directory of the child process.
+  * `cwd` {string|URL} Current working directory of the child process.
   * `input` {string|Buffer|TypedArray|DataView} The value which will be passed
     as stdin to the spawned process. Supplying this value will override
     `stdio[0]`.
@@ -934,9 +1093,11 @@ added: v0.7.7
 * `code` {number} The exit code if the child exited on its own.
 * `signal` {string} The signal by which the child process was terminated.
 
-The `'close'` event is emitted when the stdio streams of a child process have
-been closed. This is distinct from the [`'exit'`][] event, since multiple
-processes might share the same stdio streams.
+The `'close'` event is emitted after a process has ended _and_ the stdio
+streams of a child process have been closed. This is distinct from the
+[`'exit'`][] event, since multiple processes might share the same stdio
+streams. The `'close'` event will always emit after [`'exit'`][] was
+already emitted, or [`'error'`][] if the child failed to spawn.
 
 ```js
 const { spawn } = require('child_process');
@@ -1025,9 +1186,30 @@ child process, the `message` argument can contain data that JSON is not able
 to represent.
 See [Advanced serialization][] for more details.
 
+### Event: `'spawn'`
+<!-- YAML
+added: v14.17.0
+-->
+
+The `'spawn'` event is emitted once the child process has spawned successfully.
+If the child process does not spawn successfully, the `'spawn'` event is not
+emitted and the `'error'` event is emitted instead.
+
+If emitted, the `'spawn'` event comes before all other events and before any
+data is received via `stdout` or `stderr`.
+
+The `'spawn'` event will fire regardless of whether an error occurs **within**
+the spawned process. For example, if `bash some-command` spawns successfully,
+the `'spawn'` event will fire, though `bash` may fail to spawn `some-command`.
+This caveat also applies when using `{ shell: true }`.
+
 ### `subprocess.channel`
 <!-- YAML
 added: v7.1.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/30165
+    description: The object no longer accidentally exposes native C++ bindings.
 -->
 
 * {Object} A pipe representing the IPC channel to the child process.
@@ -1035,6 +1217,22 @@ added: v7.1.0
 The `subprocess.channel` property is a reference to the child's IPC channel. If
 no IPC channel currently exists, this property is `undefined`.
 
+#### `subprocess.channel.ref()`
+<!-- YAML
+added: v7.1.0
+-->
+
+This method makes the IPC channel keep the event loop of the parent process
+running if `.unref()` has been called before.
+
+#### `subprocess.channel.unref()`
+<!-- YAML
+added: v7.1.0
+-->
+
+This method makes the IPC channel not keep the event loop of the parent process
+running, and lets it finish even while the channel is open.
+
 ### `subprocess.connected`
 <!-- YAML
 added: v0.7.2
@@ -1109,6 +1307,11 @@ may not actually terminate the process.
 
 See kill(2) for reference.
 
+On Windows, where POSIX signals do not exist, the `signal` argument will be
+ignored, and the process will be killed forcefully and abruptly (similar to
+`'SIGKILL'`).
+See [Signal Events][] for more details.
+
 On Linux, child processes of child processes will not be terminated
 when attempting to kill their parent. This is likely to happen when running a
 new process in a shell or with the use of the `shell` option of `ChildProcess`:
@@ -1123,7 +1326,7 @@ const subprocess = spawn(
     '-c',
     `node -e "setInterval(() => {
       console.log(process.pid, 'is alive')
-    }, 500);"`
+    }, 500);"`,
   ], {
     stdio: ['inherit', 'inherit', 'inherit']
   }
@@ -1151,9 +1354,11 @@ does not indicate that the child process has been terminated.
 added: v0.1.90
 -->
 
-* {integer}
+* {integer|undefined}
 
-Returns the process identifier (PID) of the child process.
+Returns the process identifier (PID) of the child process. If the child process
+fails to spawn due to errors, then the value is `undefined` and `error` is
+emitted.
 
 ```js
 const { spawn } = require('child_process');
@@ -1365,16 +1570,16 @@ connection to the child.
 
 ### `subprocess.signalCode`
 
-* {integer}
+* {string|null}
 
-The `subprocess.signalCode` property indicates the signal number received by
+The `subprocess.signalCode` property indicates the signal received by
 the child process if any, else `null`.
 
 ### `subprocess.spawnargs`
 
 * {Array}
 
-The `subprocess.spawnargs` property represents the full list of command line
+The `subprocess.spawnargs` property represents the full list of command-line
 arguments the child process was launched with.
 
 ### `subprocess.spawnfile`
@@ -1406,6 +1611,9 @@ then this will be `null`.
 `subprocess.stderr` is an alias for `subprocess.stdio[2]`. Both properties will
 refer to the same value.
 
+The `subprocess.stderr` property can be `null` if the child process could
+not be successfully spawned.
+
 ### `subprocess.stdin`
 <!-- YAML
 added: v0.1.90
@@ -1424,6 +1632,9 @@ then this will be `null`.
 `subprocess.stdin` is an alias for `subprocess.stdio[0]`. Both properties will
 refer to the same value.
 
+The `subprocess.stdin` property can be `undefined` if the child process could
+not be successfully spawned.
+
 ### `subprocess.stdio`
 <!-- YAML
 added: v0.7.10
@@ -1450,7 +1661,7 @@ const subprocess = child_process.spawn('ls', {
   stdio: [
     0, // Use parent's stdin for child.
     'pipe', // Pipe child's stdout to parent.
-    fs.openSync('err.out', 'w') // Direct child's stderr to a file.
+    fs.openSync('err.out', 'w'), // Direct child's stderr to a file.
   ]
 });
 
@@ -1464,6 +1675,9 @@ assert.strictEqual(subprocess.stdio[2], null);
 assert.strictEqual(subprocess.stdio[2], subprocess.stderr);
 ```
 
+The `subprocess.stdio` property can be `undefined` if the child process could
+not be successfully spawned.
+
 ### `subprocess.stdout`
 <!-- YAML
 added: v0.1.90
@@ -1489,6 +1703,9 @@ subprocess.stdout.on('data', (data) => {
 });
 ```
 
+The `subprocess.stdout` property can be `null` if the child process could
+not be successfully spawned.
+
 ### `subprocess.unref()`
 <!-- YAML
 added: v0.7.10
@@ -1523,7 +1740,7 @@ to `stdout` although there are only 4 characters.
 ## Shell requirements
 
 The shell should understand the `-c` switch. If the shell is `'cmd.exe'`, it
-should understand the `/d /s /c` switches and command line parsing should be
+should understand the `/d /s /c` switches and command-line parsing should be
 compatible.
 
 ## Default Windows shell
@@ -1536,7 +1753,9 @@ unavailable.
 
 ## Advanced serialization
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.2.0
+ - v12.16.0
 -->
 
 Child processes support a serialization mechanism for IPC that is based on the
@@ -1554,13 +1773,17 @@ Therefore, this feature requires opting in by setting the
 or [`child_process.fork()`][].
 
 [Advanced serialization]: #child_process_advanced_serialization
-[`'disconnect'`]: process.html#process_event_disconnect
+[Default Windows shell]: #child_process_default_windows_shell
+[HTML structured clone algorithm]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+[Shell requirements]: #child_process_shell_requirements
+[Signal Events]: process.md#process_signal_events
+[`'disconnect'`]: process.md#process_event_disconnect
 [`'error'`]: #child_process_event_error
 [`'exit'`]: #child_process_event_exit
-[`'message'`]: process.html#process_event_message
-[`ChildProcess`]: #child_process_child_process
-[`Error`]: errors.html#errors_class_error
-[`EventEmitter`]: events.html#events_class_eventemitter
+[`'message'`]: process.md#process_event_message
+[`ChildProcess`]: #child_process_class_childprocess
+[`Error`]: errors.md#errors_class_error
+[`EventEmitter`]: events.md#events_class_eventemitter
 [`child_process.exec()`]: #child_process_child_process_exec_command_options_callback
 [`child_process.execFile()`]: #child_process_child_process_execfile_file_args_options_callback
 [`child_process.execFileSync()`]: #child_process_child_process_execfilesync_file_args_options
@@ -1569,13 +1792,13 @@ or [`child_process.fork()`][].
 [`child_process.spawn()`]: #child_process_child_process_spawn_command_args_options
 [`child_process.spawnSync()`]: #child_process_child_process_spawnsync_command_args_options
 [`maxBuffer` and Unicode]: #child_process_maxbuffer_and_unicode
-[`net.Server`]: net.html#net_class_net_server
-[`net.Socket`]: net.html#net_class_net_socket
+[`net.Server`]: net.md#net_class_net_server
+[`net.Socket`]: net.md#net_class_net_socket
 [`options.detached`]: #child_process_options_detached
-[`process.disconnect()`]: process.html#process_process_disconnect
-[`process.env`]: process.html#process_process_env
-[`process.execPath`]: process.html#process_process_execpath
-[`process.send()`]: process.html#process_process_send_message_sendhandle_options_callback
+[`process.disconnect()`]: process.md#process_process_disconnect
+[`process.env`]: process.md#process_process_env
+[`process.execPath`]: process.md#process_process_execpath
+[`process.send()`]: process.md#process_process_send_message_sendhandle_options_callback
 [`stdio`]: #child_process_options_stdio
 [`subprocess.connected`]: #child_process_subprocess_connected
 [`subprocess.disconnect()`]: #child_process_subprocess_disconnect
@@ -1585,9 +1808,6 @@ or [`child_process.fork()`][].
 [`subprocess.stdin`]: #child_process_subprocess_stdin
 [`subprocess.stdio`]: #child_process_subprocess_stdio
 [`subprocess.stdout`]: #child_process_subprocess_stdout
-[`util.promisify()`]: util.html#util_util_promisify_original
-[Default Windows shell]: #child_process_default_windows_shell
-[HTML structured clone algorithm]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
-[Shell requirements]: #child_process_shell_requirements
+[`util.promisify()`]: util.md#util_util_promisify_original
 [synchronous counterparts]: #child_process_synchronous_process_creation
-[v8.serdes]: v8.html#v8_serialization_api
+[v8.serdes]: v8.md#v8_serialization_api
diff --git a/doc/api/cli.html b/doc/api/cli.html
index 1801f0046acbe352aeb63d5f73d2245a9ebc886c..bc6c9fa51b53452c6bfd4f0400782150dfac8a8c 100644
--- a/doc/api/cli.html
+++ b/doc/api/cli.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Command line options | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Command-line options | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli active">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli active">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="cli" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/cli.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/cli.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/cli.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/cli.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/cli.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/cli.html">13.x</a></li>
@@ -115,16 +130,14 @@
 <li><a href="https://nodejs.org/docs/latest-v5.x/api/cli.html">5.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/cli.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/cli.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
-<li><a href="#cli_command_line_options">Command line options</a>
+      <details id="toc" open><summary>Table of contents</summary><ul>
+<li><a href="#cli_command_line_options">Command-line options</a>
 <ul>
 <li><a href="#cli_synopsis">Synopsis</a></li>
 <li><a href="#cli_options">Options</a>
@@ -133,7 +146,7 @@
 <li><a href="#cli_1"><code>--</code></a></li>
 <li><a href="#cli_abort_on_uncaught_exception"><code>--abort-on-uncaught-exception</code></a></li>
 <li><a href="#cli_completion_bash"><code>--completion-bash</code></a></li>
-<li><span class="stability_1"><a href="#cli_conditions_condition"><code>--conditions=condition</code></a></span></li>
+<li><span class="stability_1"><a href="#cli_c_condition_conditions_condition"><code>-C=condition</code>, <code>--conditions=condition</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_cpu_prof"><code>--cpu-prof</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_cpu_prof_dir"><code>--cpu-prof-dir</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_cpu_prof_interval"><code>--cpu-prof-interval</code></a></span></li>
@@ -141,8 +154,10 @@
 <li><a href="#cli_diagnostic_dir_directory"><code>--diagnostic-dir=directory</code></a></li>
 <li><a href="#cli_disable_proto_mode"><code>--disable-proto=mode</code></a></li>
 <li><a href="#cli_disallow_code_generation_from_strings"><code>--disallow-code-generation-from-strings</code></a></li>
+<li><a href="#cli_dns_result_order_order"><code>--dns-result-order=order</code></a></li>
 <li><a href="#cli_enable_fips"><code>--enable-fips</code></a></li>
-<li><span class="stability_1"><a href="#cli_enable_source_maps"><code>--enable-source-maps</code></a></span></li>
+<li><a href="#cli_enable_source_maps"><code>--enable-source-maps</code></a></li>
+<li><a href="#cli_experimental_abortcontroller"><code>--experimental-abortcontroller</code></a></li>
 <li><a href="#cli_experimental_import_meta_resolve"><code>--experimental-import-meta-resolve</code></a></li>
 <li><a href="#cli_experimental_json_modules"><code>--experimental-json-modules</code></a></li>
 <li><a href="#cli_experimental_loader_module"><code>--experimental-loader=module</code></a></li>
@@ -156,13 +171,12 @@
 <li><a href="#cli_force_context_aware"><code>--force-context-aware</code></a></li>
 <li><a href="#cli_force_fips"><code>--force-fips</code></a></li>
 <li><span class="stability_1"><a href="#cli_frozen_intrinsics"><code>--frozen-intrinsics</code></a></span></li>
+<li><span class="stability_1"><a href="#cli_heapsnapshot_near_heap_limit_max_count"><code>--heapsnapshot-near-heap-limit=max_count</code></a></span></li>
 <li><a href="#cli_heapsnapshot_signal_signal"><code>--heapsnapshot-signal=signal</code></a></li>
 <li><span class="stability_1"><a href="#cli_heap_prof"><code>--heap-prof</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_heap_prof_dir"><code>--heap-prof-dir</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_heap_prof_interval"><code>--heap-prof-interval</code></a></span></li>
 <li><span class="stability_1"><a href="#cli_heap_prof_name"><code>--heap-prof-name</code></a></span></li>
-<li><a href="#cli_http_parser_library"><code>--http-parser=library</code></a></li>
-<li><a href="#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout=milliseconds</code></a></li>
 <li><a href="#cli_icu_data_dir_file"><code>--icu-data-dir=file</code></a></li>
 <li><a href="#cli_input_type_type"><code>--input-type=type</code></a></li>
 <li><a href="#cli_inspect_brk_host_port"><code>--inspect-brk[=[host:]port]</code></a></li>
@@ -180,6 +194,7 @@
 <li><a href="#cli_no_deprecation"><code>--no-deprecation</code></a></li>
 <li><a href="#cli_no_force_async_hooks_checks"><code>--no-force-async-hooks-checks</code></a></li>
 <li><a href="#cli_no_warnings"><code>--no-warnings</code></a></li>
+<li><a href="#cli_node_memory_debug"><code>--node-memory-debug</code></a></li>
 <li><a href="#cli_openssl_config_file"><code>--openssl-config=file</code></a></li>
 <li><a href="#cli_pending_deprecation"><code>--pending-deprecation</code></a></li>
 <li><span class="stability_1"><a href="#cli_policy_integrity_sri"><code>--policy-integrity=sri</code></a></span></li>
@@ -205,6 +220,7 @@
 <li><a href="#cli_tls_min_v1_1"><code>--tls-min-v1.1</code></a></li>
 <li><a href="#cli_tls_min_v1_2"><code>--tls-min-v1.2</code></a></li>
 <li><a href="#cli_tls_min_v1_3"><code>--tls-min-v1.3</code></a></li>
+<li><a href="#cli_trace_atomics_wait"><code>--trace-atomics-wait</code></a></li>
 <li><a href="#cli_trace_deprecation"><code>--trace-deprecation</code></a></li>
 <li><a href="#cli_trace_event_categories"><code>--trace-event-categories</code></a></li>
 <li><a href="#cli_trace_event_file_pattern"><code>--trace-event-file-pattern</code></a></li>
@@ -233,6 +249,7 @@
 </li>
 <li><a href="#cli_environment_variables">Environment variables</a>
 <ul>
+<li><a href="#cli_force_color_1_2_3"><code>FORCE_COLOR=[1, 2, 3]</code></a></li>
 <li><a href="#cli_node_debug_module"><code>NODE_DEBUG=module[,…]</code></a></li>
 <li><a href="#cli_node_debug_native_module"><code>NODE_DEBUG_NATIVE=module[,…]</code></a></li>
 <li><a href="#cli_node_disable_colors_1"><code>NODE_DISABLE_COLORS=1</code></a></li>
@@ -247,13 +264,15 @@
 <li><a href="#cli_node_redirect_warnings_file"><code>NODE_REDIRECT_WARNINGS=file</code></a></li>
 <li><a href="#cli_node_repl_history_file"><code>NODE_REPL_HISTORY=file</code></a></li>
 <li><a href="#cli_node_repl_external_module_file"><code>NODE_REPL_EXTERNAL_MODULE=file</code></a></li>
+<li><a href="#cli_node_skip_platform_check_value"><code>NODE_SKIP_PLATFORM_CHECK=value</code></a></li>
 <li><a href="#cli_node_tls_reject_unauthorized_value"><code>NODE_TLS_REJECT_UNAUTHORIZED=value</code></a></li>
 <li><a href="#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE=dir</code></a>
 <ul>
 <li><a href="#cli_coverage_output">Coverage output</a></li>
-<li><a href="#cli_source_map_cache">Source map cache</a></li>
+<li><span class="stability_1"><a href="#cli_source_map_cache">Source map cache</a></span></li>
 </ul>
 </li>
+<li><a href="#cli_no_color_any"><code>NO_COLOR=&#x3C;any></code></a></li>
 <li><a href="#cli_openssl_conf_file"><code>OPENSSL_CONF=file</code></a></li>
 <li><a href="#cli_ssl_cert_dir_dir"><code>SSL_CERT_DIR=dir</code></a></li>
 <li><a href="#cli_ssl_cert_file_file"><code>SSL_CERT_FILE=file</code></a></li>
@@ -267,23 +286,22 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Command line options<span><a class="mark" href="#cli_command_line_options" id="cli_command_line_options">#</a></span></h1>
+        <h2>Command-line options<span><a class="mark" href="#cli_command_line_options" id="cli_command_line_options">#</a></span></h2>
 
 
 <p>Node.js comes with a variety of CLI options. These options expose built-in
 debugging, multiple ways to execute scripts, and other helpful runtime options.</p>
 <p>To view this documentation as a manual page in a terminal, run <code>man node</code>.</p>
-<h2>Synopsis<span><a class="mark" href="#cli_synopsis" id="cli_synopsis">#</a></span></h2>
+<section><h3>Synopsis<span><a class="mark" href="#cli_synopsis" id="cli_synopsis">#</a></span></h3>
 <p><code>node [options] [V8 options] [script.js | -e "script" | -] [--] [arguments]</code></p>
 <p><code>node inspect [script.js | -e "script" | &#x3C;host>:&#x3C;port>] …</code></p>
 <p><code>node --v8-options</code></p>
 <p>Execute without arguments to start the <a href="repl.html">REPL</a>.</p>
-<p><em>For more info about <code>node inspect</code>, please see the <a href="debugger.html">debugger</a> documentation.</em></p>
-<h2>Options<span><a class="mark" href="#cli_options" id="cli_options">#</a></span></h2>
+<p>For more info about <code>node inspect</code>, see the <a href="debugger.html">debugger</a> documentation.</p>
+</section><section><h3>Options<span><a class="mark" href="#cli_options" id="cli_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -294,27 +312,27 @@ debugging, multiple ways to execute scripts, and other helpful runtime options.<
 </details>
 </div>
 <p>All options, including V8 options, allow words to be separated by both
-dashes (<code>-</code>) or underscores (<code>_</code>).</p>
-<p>For example, <code>--pending-deprecation</code> is equivalent to <code>--pending_deprecation</code>.</p>
-<p>If an option that takes a single value, for example <code>--max-http-header-size</code>,
-is passed more than once, then the last passed value will be used. Options
-from the command line take precedence over options passed through the
-<a href="#cli_node_options_options"><code>NODE_OPTIONS</code></a> environment variable.</p>
-<h3><code>-</code><span><a class="mark" href="#cli" id="cli">#</a></span></h3>
+dashes (<code>-</code>) or underscores (<code>_</code>). For example, <code>--pending-deprecation</code> is
+equivalent to <code>--pending_deprecation</code>.</p>
+<p>If an option that takes a single value (such as <code>--max-http-header-size</code>) is
+passed more than once, then the last passed value is used. Options from the
+command line take precedence over options passed through the <a href="#cli_node_options_options"><code>NODE_OPTIONS</code></a>
+environment variable.</p>
+<h4><code>-</code><span><a class="mark" href="#cli" id="cli">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
-<p>Alias for stdin. Analogous to the use of <code>-</code> in other command line utilities,
-meaning that the script will be read from stdin, and the rest of the options
+<p>Alias for stdin. Analogous to the use of <code>-</code> in other command-line utilities,
+meaning that the script is read from stdin, and the rest of the options
 are passed to that script.</p>
-<h3><code>--</code><span><a class="mark" href="#cli_1" id="cli_1">#</a></span></h3>
+<h4><code>--</code><span><a class="mark" href="#cli_1" id="cli_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.11.0</span>
 </div>
 <p>Indicate the end of node options. Pass the rest of the arguments to the script.
 If no script filename or eval/print script is supplied prior to this, then
-the next argument will be used as a script filename.</p>
-<h3><code>--abort-on-uncaught-exception</code><span><a class="mark" href="#cli_abort_on_uncaught_exception" id="cli_abort_on_uncaught_exception">#</a></span></h3>
+the next argument is used as a script filename.</p>
+<h4><code>--abort-on-uncaught-exception</code><span><a class="mark" href="#cli_abort_on_uncaught_exception" id="cli_abort_on_uncaught_exception">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.10.8</span>
 </div>
@@ -323,38 +341,40 @@ analysis using a debugger (such as <code>lldb</code>, <code>gdb</code>, and <cod
 <p>If this flag is passed, the behavior can still be set to not abort through
 <a href="process.html#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> (and through usage of the
 <code>domain</code> module that uses it).</p>
-<h3><code>--completion-bash</code><span><a class="mark" href="#cli_completion_bash" id="cli_completion_bash">#</a></span></h3>
+<h4><code>--completion-bash</code><span><a class="mark" href="#cli_completion_bash" id="cli_completion_bash">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
 <p>Print source-able bash completion script for Node.js.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --completion-bash > node_bash_completion</span>
-<span class="hljs-meta">$</span><span class="bash"> <span class="hljs-built_in">source</span> node_bash_completion</span></code></pre>
-<h3><code>--conditions=condition</code><span><a class="mark" href="#cli_conditions_condition" id="cli_conditions_condition">#</a></span></h3>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --completion-bash > node_bash_completion</span>
+<span class="hljs-meta">$ </span><span class="language-bash"><span class="hljs-built_in">source</span> node_bash_completion</span></code></pre>
+<h4><code>-C=condition</code>, <code>--conditions=condition</code><span><a class="mark" href="#cli_c_condition_conditions_condition" id="cli_c_condition_conditions_condition">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.9.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p>Enable experimental support for custom conditional exports resolution
+<p>Enable experimental support for custom <a href="packages.html#packages_conditional_exports">conditional exports</a> resolution
 conditions.</p>
 <p>Any number of custom string condition names are permitted.</p>
 <p>The default Node.js conditions of <code>"node"</code>, <code>"default"</code>, <code>"import"</code>, and
 <code>"require"</code> will always apply as defined.</p>
-<h3><code>--cpu-prof</code><span><a class="mark" href="#cli_cpu_prof" id="cli_cpu_prof">#</a></span></h3>
+<p>For example, to run a module with "development" resolutions:</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node -C=development app.js</span></code></pre>
+<h4><code>--cpu-prof</code><span><a class="mark" href="#cli_cpu_prof" id="cli_cpu_prof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Starts the V8 CPU profiler on start up, and writes the CPU profile to disk
 before exit.</p>
-<p>If <code>--cpu-prof-dir</code> is not specified, the generated profile will be placed
+<p>If <code>--cpu-prof-dir</code> is not specified, the generated profile is placed
 in the current working directory.</p>
-<p>If <code>--cpu-prof-name</code> is not specified, the generated profile will be
+<p>If <code>--cpu-prof-name</code> is not specified, the generated profile is
 named <code>CPU.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.cpuprofile</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --cpu-prof index.js</span>
-<span class="hljs-meta">$</span><span class="bash"> ls *.cpuprofile</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --cpu-prof index.js</span>
+<span class="hljs-meta">$ </span><span class="language-bash">ls *.cpuprofile</span>
 CPU.20190409.202950.15293.0.0.cpuprofile</code></pre>
-<h3><code>--cpu-prof-dir</code><span><a class="mark" href="#cli_cpu_prof_dir" id="cli_cpu_prof_dir">#</a></span></h3>
+<h4><code>--cpu-prof-dir</code><span><a class="mark" href="#cli_cpu_prof_dir" id="cli_cpu_prof_dir">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -362,22 +382,22 @@ CPU.20190409.202950.15293.0.0.cpuprofile</code></pre>
 <p>Specify the directory where the CPU profiles generated by <code>--cpu-prof</code> will
 be placed.</p>
 <p>The default value is controlled by the
-<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command line option.</p>
-<h3><code>--cpu-prof-interval</code><span><a class="mark" href="#cli_cpu_prof_interval" id="cli_cpu_prof_interval">#</a></span></h3>
+<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command-line option.</p>
+<h4><code>--cpu-prof-interval</code><span><a class="mark" href="#cli_cpu_prof_interval" id="cli_cpu_prof_interval">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.2.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Specify the sampling interval in microseconds for the CPU profiles generated
 by <code>--cpu-prof</code>. The default is 1000 microseconds.</p>
-<h3><code>--cpu-prof-name</code><span><a class="mark" href="#cli_cpu_prof_name" id="cli_cpu_prof_name">#</a></span></h3>
+<h4><code>--cpu-prof-name</code><span><a class="mark" href="#cli_cpu_prof_name" id="cli_cpu_prof_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Specify the file name of the CPU profile generated by <code>--cpu-prof</code>.</p>
-<h3><code>--diagnostic-dir=directory</code><span><a class="mark" href="#cli_diagnostic_dir_directory" id="cli_diagnostic_dir_directory">#</a></span></h3>
-<p>Set the directory to which all diagnostic output files will be written to.
+<h4><code>--diagnostic-dir=directory</code><span><a class="mark" href="#cli_diagnostic_dir_directory" id="cli_diagnostic_dir_directory">#</a></span></h4>
+<p>Set the directory to which all diagnostic output files are written.
 Defaults to current working directory.</p>
 <p>Affects the default output directory of:</p>
 <ul>
@@ -385,102 +405,138 @@ Defaults to current working directory.</p>
 <li><a href="#cli_heap_prof_dir">--heap-prof-dir</a></li>
 <li><a href="#cli_redirect_warnings_file">--redirect-warnings</a></li>
 </ul>
-<h3><code>--disable-proto=mode</code><span><a class="mark" href="#cli_disable_proto_mode" id="cli_disable_proto_mode">#</a></span></h3>
-<!--YAML
-added: v12.17.0
--->
+<h4><code>--disable-proto=mode</code><span><a class="mark" href="#cli_disable_proto_mode" id="cli_disable_proto_mode">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.12.0</span>
+</div>
 <p>Disable the <code>Object.prototype.__proto__</code> property. If <code>mode</code> is <code>delete</code>, the
-property will be removed entirely. If <code>mode</code> is <code>throw</code>, accesses to the
-property will throw an exception with the code <code>ERR_PROTO_ACCESS</code>.</p>
-<h3><code>--disallow-code-generation-from-strings</code><span><a class="mark" href="#cli_disallow_code_generation_from_strings" id="cli_disallow_code_generation_from_strings">#</a></span></h3>
+property is removed entirely. If <code>mode</code> is <code>throw</code>, accesses to the
+property throw an exception with the code <code>ERR_PROTO_ACCESS</code>.</p>
+<h4><code>--disallow-code-generation-from-strings</code><span><a class="mark" href="#cli_disallow_code_generation_from_strings" id="cli_disallow_code_generation_from_strings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.8.0</span>
 </div>
 <p>Make built-in language features like <code>eval</code> and <code>new Function</code> that generate
 code from strings throw an exception instead. This does not affect the Node.js
 <code>vm</code> module.</p>
-<h3><code>--enable-fips</code><span><a class="mark" href="#cli_enable_fips" id="cli_enable_fips">#</a></span></h3>
+<h4><code>--dns-result-order=order</code><span><a class="mark" href="#cli_dns_result_order_order" id="cli_dns_result_order_order">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>Set the default value of <code>verbatim</code> in <a href="dns.html#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> and
+<a href="dns.html#dns_dnspromises_lookup_hostname_options"><code>dnsPromises.lookup()</code></a>. The value could be:</p>
+<ul>
+<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>
+<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>
+</ul>
+<p>The default is <code>ipv4first</code> and <a href="dns.html#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> have higher
+priority than <code>--dns-result-order</code>.</p>
+<h4><code>--enable-fips</code><span><a class="mark" href="#cli_enable_fips" id="cli_enable_fips">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Enable FIPS-compliant crypto at startup. (Requires Node.js to be built with
 <code>./configure --openssl-fips</code>.)</p>
-<h3><code>--enable-source-maps</code><span><a class="mark" href="#cli_enable_source_maps" id="cli_enable_source_maps">#</a></span></h3>
+<h4><code>--enable-source-maps</code><span><a class="mark" href="#cli_enable_source_maps" id="cli_enable_source_maps">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>This API is no longer experimental.</p></td></tr>
+<tr><td>v12.12.0</td>
+<td><p><span>Added in: v12.12.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p>Enable experimental Source Map v3 support for stack traces.</p>
-<p>Currently, overriding <code>Error.prepareStackTrace</code> is ignored when the
-<code>--enable-source-maps</code> flag is set.</p>
-<h3><code>--experimental-import-meta-resolve</code><span><a class="mark" href="#cli_experimental_import_meta_resolve" id="cli_experimental_import_meta_resolve">#</a></span></h3>
+<p>Enable <a href="https://sourcemaps.info/spec.html">Source Map v3</a> support for stack traces.</p>
+<p>When using a transpiler, such as TypeScript, strack traces thrown by an
+application reference the transpiled code, not the original source position.
+<code>--enable-source-maps</code> enables caching of Source Maps and makes a best
+effort to report stack traces relative to the original source file.</p>
+<p>Overriding <code>Error.prepareStackTrace</code> prevents <code>--enable-source-maps</code> from
+modifiying the stack trace.</p>
+<h4><code>--experimental-abortcontroller</code><span><a class="mark" href="#cli_experimental_abortcontroller" id="cli_experimental_abortcontroller">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>Enable experimental <code>AbortController</code> and <code>AbortSignal</code> support.</p>
+<h4><code>--experimental-import-meta-resolve</code><span><a class="mark" href="#cli_experimental_import_meta_resolve" id="cli_experimental_import_meta_resolve">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.2</span>
+<span>Added in: v13.9.0, v12.16.2</span>
 </div>
 <p>Enable experimental <code>import.meta.resolve()</code> support.</p>
-<h3><code>--experimental-json-modules</code><span><a class="mark" href="#cli_experimental_json_modules" id="cli_experimental_json_modules">#</a></span></h3>
+<h4><code>--experimental-json-modules</code><span><a class="mark" href="#cli_experimental_json_modules" id="cli_experimental_json_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
 <p>Enable experimental JSON support for the ES Module loader.</p>
-<h3><code>--experimental-loader=module</code><span><a class="mark" href="#cli_experimental_loader_module" id="cli_experimental_loader_module">#</a></span></h3>
+<h4><code>--experimental-loader=module</code><span><a class="mark" href="#cli_experimental_loader_module" id="cli_experimental_loader_module">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
-<p>Specify the <code>module</code> of a custom <a href="esm.html#esm_experimental_loaders">experimental ECMAScript Module loader</a>.
+<p>Specify the <code>module</code> of a custom experimental <a href="esm.html#esm_loaders">ECMAScript Module loader</a>.
 <code>module</code> may be either a path to a file, or an ECMAScript Module name.</p>
-<h3><code>--experimental-modules</code><span><a class="mark" href="#cli_experimental_modules" id="cli_experimental_modules">#</a></span></h3>
+<h4><code>--experimental-modules</code><span><a class="mark" href="#cli_experimental_modules" id="cli_experimental_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>Enable latest experimental modules features (deprecated).</p>
-<h3><code>--experimental-policy</code><span><a class="mark" href="#cli_experimental_policy" id="cli_experimental_policy">#</a></span></h3>
+<h4><code>--experimental-policy</code><span><a class="mark" href="#cli_experimental_policy" id="cli_experimental_policy">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.8.0</span>
 </div>
 <p>Use the specified file as a security policy.</p>
-<h3><code>--experimental-repl-await</code><span><a class="mark" href="#cli_experimental_repl_await" id="cli_experimental_repl_await">#</a></span></h3>
+<h4><code>--experimental-repl-await</code><span><a class="mark" href="#cli_experimental_repl_await" id="cli_experimental_repl_await">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 <p>Enable experimental top-level <code>await</code> keyword support in REPL.</p>
-<h3><code>--experimental-specifier-resolution=mode</code><span><a class="mark" href="#cli_experimental_specifier_resolution_mode" id="cli_experimental_specifier_resolution_mode">#</a></span></h3>
+<h4><code>--experimental-specifier-resolution=mode</code><span><a class="mark" href="#cli_experimental_specifier_resolution_mode" id="cli_experimental_specifier_resolution_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.4.0, v12.16.0</span>
 </div>
 <p>Sets the resolution algorithm for resolving ES module specifiers. Valid options
 are <code>explicit</code> and <code>node</code>.</p>
 <p>The default is <code>explicit</code>, which requires providing the full path to a
-module. The <code>node</code> mode will enable support for optional file extensions and
+module. The <code>node</code> mode enables support for optional file extensions and
 the ability to import a directory that has an index file.</p>
-<p>Please see <a href="esm.html#esm_customizing_esm_specifier_resolution_algorithm">customizing ESM specifier resolution</a> for example usage.</p>
-<h3><code>--experimental-vm-modules</code><span><a class="mark" href="#cli_experimental_vm_modules" id="cli_experimental_vm_modules">#</a></span></h3>
+<p>See <a href="esm.html#esm_customizing_esm_specifier_resolution_algorithm">customizing ESM specifier resolution</a> for example usage.</p>
+<h4><code>--experimental-vm-modules</code><span><a class="mark" href="#cli_experimental_vm_modules" id="cli_experimental_vm_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 </div>
 <p>Enable experimental ES Module support in the <code>vm</code> module.</p>
-<h3><code>--experimental-wasi-unstable-preview1</code><span><a class="mark" href="#cli_experimental_wasi_unstable_preview1" id="cli_experimental_wasi_unstable_preview1">#</a></span></h3>
+<h4><code>--experimental-wasi-unstable-preview1</code><span><a class="mark" href="#cli_experimental_wasi_unstable_preview1" id="cli_experimental_wasi_unstable_preview1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.6.0</td>
+<td><p>changed from <code>--experimental-wasi-unstable-preview0</code> to <code>--experimental-wasi-unstable-preview1</code>.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
+<td><p><span>Added in: v13.3.0, v12.16.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <p>Enable experimental WebAssembly System Interface (WASI) support.</p>
-<h3><code>--experimental-wasm-modules</code><span><a class="mark" href="#cli_experimental_wasm_modules" id="cli_experimental_wasm_modules">#</a></span></h3>
+<h4><code>--experimental-wasm-modules</code><span><a class="mark" href="#cli_experimental_wasm_modules" id="cli_experimental_wasm_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
-<h3><code>--force-context-aware</code><span><a class="mark" href="#cli_force_context_aware" id="cli_force_context_aware">#</a></span></h3>
+<p>Enable experimental WebAssembly module support.</p>
+<h4><code>--force-context-aware</code><span><a class="mark" href="#cli_force_context_aware" id="cli_force_context_aware">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.12.0</span>
 </div>
 <p>Disable loading native addons that are not <a href="addons.html#addons_context_aware_addons">context-aware</a>.</p>
-<p>Enable experimental WebAssembly module support.</p>
-<h3><code>--force-fips</code><span><a class="mark" href="#cli_force_fips" id="cli_force_fips">#</a></span></h3>
+<h4><code>--force-fips</code><span><a class="mark" href="#cli_force_fips" id="cli_force_fips">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Force FIPS-compliant crypto on startup. (Cannot be disabled from script code.)
 (Same requirements as <code>--enable-fips</code>.)</p>
-<h3><code>--frozen-intrinsics</code><span><a class="mark" href="#cli_frozen_intrinsics" id="cli_frozen_intrinsics">#</a></span></h3>
+<h4><code>--frozen-intrinsics</code><span><a class="mark" href="#cli_frozen_intrinsics" id="cli_frozen_intrinsics">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.12.0</span>
 </div>
@@ -491,35 +547,73 @@ currently provided that <code>global.Array</code> is indeed the default intrinsi
 reference. Code may break under this flag.</p>
 <p><code>--require</code> runs prior to freezing intrinsics in order to allow polyfills to
 be added.</p>
-<h3><code>--heapsnapshot-signal=signal</code><span><a class="mark" href="#cli_heapsnapshot_signal_signal" id="cli_heapsnapshot_signal_signal">#</a></span></h3>
+<h4><code>--heapsnapshot-near-heap-limit=max_count</code><span><a class="mark" href="#cli_heapsnapshot_near_heap_limit_max_count" id="cli_heapsnapshot_near_heap_limit_max_count">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>Writes a V8 heap snapshot to disk when the V8 heap usage is approaching the
+heap limit. <code>count</code> should be a non-negative integer (in which case
+Node.js will write no more than <code>max_count</code> snapshots to disk).</p>
+<p>When generating snapshots, garbage collection may be triggered and bring
+the heap usage down, therefore multiple snapshots may be written to disk
+before the Node.js instance finally runs out of memory. These heap snapshots
+can be compared to determine what objects are being allocated during the
+time consecutive snapshots are taken. It's not guaranteed that Node.js will
+write exactly <code>max_count</code> snapshots to disk, but it will try
+its best to generate at least one and up to <code>max_count</code> snapshots before the
+Node.js instance runs out of memory when <code>max_count</code> is greater than <code>0</code>.</p>
+<p>Generating V8 snapshots takes time and memory (both memory managed by the
+V8 heap and native memory outside the V8 heap). The bigger the heap is,
+the more resources it needs. Node.js will adjust the V8 heap to accommondate
+the additional V8 heap memory overhead, and try its best to avoid using up
+all the memory avialable to the process. When the process uses
+more memory than the system deems appropriate, the process may be terminated
+abruptly by the system, depending on the system configuration.</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --max-old-space-size=100 --heapsnapshot-near-heap-limit=3 index.js</span>
+Wrote snapshot to Heap.20200430.100036.49580.0.001.heapsnapshot
+Wrote snapshot to Heap.20200430.100037.49580.0.002.heapsnapshot
+Wrote snapshot to Heap.20200430.100038.49580.0.003.heapsnapshot
+
+&#x3C;--- Last few GCs --->
+
+[49580:0x110000000]     4826 ms: Mark-sweep 130.6 (147.8) -> 130.5 (147.8) MB, 27.4 / 0.0 ms  (average mu = 0.126, current mu = 0.034) allocation failure scavenge might not succeed
+[49580:0x110000000]     4845 ms: Mark-sweep 130.6 (147.8) -> 130.6 (147.8) MB, 18.8 / 0.0 ms  (average mu = 0.088, current mu = 0.031) allocation failure scavenge might not succeed
+
+
+&#x3C;--- JS stacktrace --->
+
+FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory
+....</code></pre>
+<h4><code>--heapsnapshot-signal=signal</code><span><a class="mark" href="#cli_heapsnapshot_signal_signal" id="cli_heapsnapshot_signal_signal">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>Enables a signal handler that causes the Node.js process to write a heap dump
 when the specified signal is received. <code>signal</code> must be a valid signal name.
 Disabled by default.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --heapsnapshot-signal=SIGUSR2 index.js &#x26;</span>
-<span class="hljs-meta">$</span><span class="bash"> ps aux</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --heapsnapshot-signal=SIGUSR2 index.js &#x26;</span>
+<span class="hljs-meta">$ </span><span class="language-bash">ps aux</span>
 USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
 node         1  5.5  6.1 787252 247004 ?       Ssl  16:43   0:02 node --heapsnapshot-signal=SIGUSR2 index.js
-<span class="hljs-meta">$</span><span class="bash"> <span class="hljs-built_in">kill</span> -USR2 1</span>
-<span class="hljs-meta">$</span><span class="bash"> ls</span>
+<span class="hljs-meta">$ </span><span class="language-bash"><span class="hljs-built_in">kill</span> -USR2 1</span>
+<span class="hljs-meta">$ </span><span class="language-bash">ls</span>
 Heap.20190718.133405.15554.0.001.heapsnapshot</code></pre>
-<h3><code>--heap-prof</code><span><a class="mark" href="#cli_heap_prof" id="cli_heap_prof">#</a></span></h3>
+<h4><code>--heap-prof</code><span><a class="mark" href="#cli_heap_prof" id="cli_heap_prof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.4.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Starts the V8 heap profiler on start up, and writes the heap profile to disk
 before exit.</p>
-<p>If <code>--heap-prof-dir</code> is not specified, the generated profile will be placed
+<p>If <code>--heap-prof-dir</code> is not specified, the generated profile is placed
 in the current working directory.</p>
-<p>If <code>--heap-prof-name</code> is not specified, the generated profile will be
+<p>If <code>--heap-prof-name</code> is not specified, the generated profile is
 named <code>Heap.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.heapprofile</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --heap-prof index.js</span>
-<span class="hljs-meta">$</span><span class="bash"> ls *.heapprofile</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --heap-prof index.js</span>
+<span class="hljs-meta">$ </span><span class="language-bash">ls *.heapprofile</span>
 Heap.20190409.202950.15293.0.001.heapprofile</code></pre>
-<h3><code>--heap-prof-dir</code><span><a class="mark" href="#cli_heap_prof_dir" id="cli_heap_prof_dir">#</a></span></h3>
+<h4><code>--heap-prof-dir</code><span><a class="mark" href="#cli_heap_prof_dir" id="cli_heap_prof_dir">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.4.0</span>
 </div>
@@ -527,70 +621,39 @@ Heap.20190409.202950.15293.0.001.heapprofile</code></pre>
 <p>Specify the directory where the heap profiles generated by <code>--heap-prof</code> will
 be placed.</p>
 <p>The default value is controlled by the
-<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command line option.</p>
-<h3><code>--heap-prof-interval</code><span><a class="mark" href="#cli_heap_prof_interval" id="cli_heap_prof_interval">#</a></span></h3>
+<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command-line option.</p>
+<h4><code>--heap-prof-interval</code><span><a class="mark" href="#cli_heap_prof_interval" id="cli_heap_prof_interval">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.4.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Specify the average sampling interval in bytes for the heap profiles generated
 by <code>--heap-prof</code>. The default is 512 * 1024 bytes.</p>
-<h3><code>--heap-prof-name</code><span><a class="mark" href="#cli_heap_prof_name" id="cli_heap_prof_name">#</a></span></h3>
+<h4><code>--heap-prof-name</code><span><a class="mark" href="#cli_heap_prof_name" id="cli_heap_prof_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.4.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Specify the file name of the heap profile generated by <code>--heap-prof</code>.</p>
-<h3><code>--http-parser=library</code><span><a class="mark" href="#cli_http_parser_library" id="cli_http_parser_library">#</a></span></h3>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.22.0</td>
-<td><p>The legacy HTTP parser will emit a deprecation warning.</p></td></tr>
-<tr><td>v11.4.0</td>
-<td><p><span>Added in: v11.4.0</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<p>Chooses an HTTP parser library. Available values are:</p>
-<ul>
-<li><code>llhttp</code> for <a href="https://llhttp.org/">https://llhttp.org/</a></li>
-<li><code>legacy</code> for <a href="https://github.com/nodejs/http-parser">https://github.com/nodejs/http-parser</a></li>
-</ul>
-<p>The default is <code>llhttp</code>, unless otherwise specified when building Node.js.</p>
-<p>The <code>legacy</code> HTTP parser is deprecated and will emit a deprecation warning.</p>
-<p>This flag exists to aid in experimentation with the internal implementation of
-the Node.js http parser.
-This flag is likely to become a no-op and removed at some point in the future.</p>
-<h3><code>--http-server-default-timeout=milliseconds</code><span><a class="mark" href="#cli_http_server_default_timeout_milliseconds" id="cli_http_server_default_timeout_milliseconds">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.4.0</span>
-</div>
-<p>Overrides the default value of <code>http</code>, <code>https</code> and <code>http2</code> server socket
-timeout. Setting the value to 0 disables server socket timeout. Unless
-provided, http server sockets timeout after 120s (2 minutes). Programmatic
-setting of the timeout takes precedence over the value set through this
-flag.</p>
-<h3><code>--icu-data-dir=file</code><span><a class="mark" href="#cli_icu_data_dir_file" id="cli_icu_data_dir_file">#</a></span></h3>
+<h4><code>--icu-data-dir=file</code><span><a class="mark" href="#cli_icu_data_dir_file" id="cli_icu_data_dir_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
 <p>Specify ICU data load path. (Overrides <code>NODE_ICU_DATA</code>.)</p>
-<h3><code>--input-type=type</code><span><a class="mark" href="#cli_input_type_type" id="cli_input_type_type">#</a></span></h3>
+<h4><code>--input-type=type</code><span><a class="mark" href="#cli_input_type_type" id="cli_input_type_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>This configures Node.js to interpret string input as CommonJS or as an ES
 module. String input is input via <code>--eval</code>, <code>--print</code>, or <code>STDIN</code>.</p>
 <p>Valid values are <code>"commonjs"</code> and <code>"module"</code>. The default is <code>"commonjs"</code>.</p>
-<h3><code>--inspect-brk[=[host:]port]</code><span><a class="mark" href="#cli_inspect_brk_host_port" id="cli_inspect_brk_host_port">#</a></span></h3>
+<h4><code>--inspect-brk[=[host:]port]</code><span><a class="mark" href="#cli_inspect_brk_host_port" id="cli_inspect_brk_host_port">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.6.0</span>
 </div>
 <p>Activate inspector on <code>host:port</code> and break at start of user script.
 Default <code>host:port</code> is <code>127.0.0.1:9229</code>.</p>
-<h3><code>--inspect-port=[host:]port</code><span><a class="mark" href="#cli_inspect_port_host_port" id="cli_inspect_port_host_port">#</a></span></h3>
+<h4><code>--inspect-port=[host:]port</code><span><a class="mark" href="#cli_inspect_port_host_port" id="cli_inspect_port_host_port">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.6.0</span>
 </div>
@@ -599,7 +662,7 @@ Useful when activating the inspector by sending the <code>SIGUSR1</code> signal.
 <p>Default host is <code>127.0.0.1</code>.</p>
 <p>See the <a href="#inspector_security">security warning</a> below regarding the <code>host</code>
 parameter usage.</p>
-<h3><code>--inspect[=[host:]port]</code><span><a class="mark" href="#cli_inspect_host_port" id="cli_inspect_host_port">#</a></span></h3>
+<h4><code>--inspect[=[host:]port]</code><span><a class="mark" href="#cli_inspect_host_port" id="cli_inspect_host_port">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -608,7 +671,7 @@ parameter usage.</p>
 and profile Node.js instances. The tools attach to Node.js instances via a
 tcp port and communicate using the <a href="https://chromedevtools.github.io/devtools-protocol/">Chrome DevTools Protocol</a>.</p>
 <p><a id="inspector_security"></a></p>
-<h4>Warning: binding inspector to a public IP:port combination is insecure<span><a class="mark" href="#cli_warning_binding_inspector_to_a_public_ip_port_combination_is_insecure" id="cli_warning_binding_inspector_to_a_public_ip_port_combination_is_insecure">#</a></span></h4>
+<h5>Warning: binding inspector to a public IP:port combination is insecure<span><a class="mark" href="#cli_warning_binding_inspector_to_a_public_ip_port_combination_is_insecure" id="cli_warning_binding_inspector_to_a_public_ip_port_combination_is_insecure">#</a></span></h5>
 <p>Binding the inspector to a public IP (including <code>0.0.0.0</code>) with an open port is
 insecure, as it allows external hosts to connect to the inspector and perform
 a <a href="https://www.owasp.org/index.php/Code_Injection">remote code execution</a> attack.</p>
@@ -620,19 +683,19 @@ a <a href="https://www.owasp.org/index.php/Code_Injection">remote code execution
 <p><strong>More specifically, <code>--inspect=0.0.0.0</code> is insecure if the port (<code>9229</code> by
 default) is not firewall-protected.</strong></p>
 <p>See the <a href="https://nodejs.org/en/docs/guides/debugging-getting-started/#security-implications">debugging security implications</a> section for more information.</p>
-<h3><code>--inspect-publish-uid=stderr,http</code><span><a class="mark" href="#cli_inspect_publish_uid_stderr_http" id="cli_inspect_publish_uid_stderr_http">#</a></span></h3>
+<h4><code>--inspect-publish-uid=stderr,http</code><span><a class="mark" href="#cli_inspect_publish_uid_stderr_http" id="cli_inspect_publish_uid_stderr_http">#</a></span></h4>
 <p>Specify ways of the inspector web socket url exposure.</p>
 <p>By default inspector websocket url is available in stderr and under <code>/json/list</code>
 endpoint on <code>http://host:port/json/list</code>.</p>
-<h3><code>--insecure-http-parser</code><span><a class="mark" href="#cli_insecure_http_parser" id="cli_insecure_http_parser">#</a></span></h3>
+<h4><code>--insecure-http-parser</code><span><a class="mark" href="#cli_insecure_http_parser" id="cli_insecure_http_parser">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.15.0</span>
+<span>Added in: v13.4.0, v12.15.0, v10.19.0</span>
 </div>
 <p>Use an insecure HTTP parser that accepts invalid HTTP headers. This may allow
 interoperability with non-conformant HTTP implementations. It may also allow
 request smuggling and other HTTP attacks that rely on invalid headers being
 accepted. Avoid using this option.</p>
-<h3><code>--jitless</code><span><a class="mark" href="#cli_jitless" id="cli_jitless">#</a></span></h3>
+<h4><code>--jitless</code><span><a class="mark" href="#cli_jitless" id="cli_jitless">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -641,51 +704,65 @@ required on some platforms for security reasons. It can also reduce attack
 surface on other platforms, but the performance impact may be severe.</p>
 <p>This flag is inherited from V8 and is subject to change upstream. It may
 disappear in a non-semver-major release.</p>
-<h3><code>--max-http-header-size=size</code><span><a class="mark" href="#cli_max_http_header_size_size" id="cli_max_http_header_size_size">#</a></span></h3>
+<h4><code>--max-http-header-size=size</code><span><a class="mark" href="#cli_max_http_header_size_size" id="cli_max_http_header_size_size">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.6.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Change maximum default size of HTTP headers from 8KB to 16KB.</p></td></tr>
+<tr><td>v11.6.0, v10.15.0</td>
+<td><p><span>Added in: v11.6.0, v10.15.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p>Specify the maximum size, in bytes, of HTTP headers. Defaults to 8KB.</p>
-<h3><code>--napi-modules</code><span><a class="mark" href="#cli_napi_modules" id="cli_napi_modules">#</a></span></h3>
+<p>Specify the maximum size, in bytes, of HTTP headers. Defaults to 16KB.</p>
+<h4><code>--napi-modules</code><span><a class="mark" href="#cli_napi_modules" id="cli_napi_modules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.10.0</span>
 </div>
 <p>This option is a no-op. It is kept for compatibility.</p>
-<h3><code>--no-deprecation</code><span><a class="mark" href="#cli_no_deprecation" id="cli_no_deprecation">#</a></span></h3>
+<h4><code>--no-deprecation</code><span><a class="mark" href="#cli_no_deprecation" id="cli_no_deprecation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
 <p>Silence deprecation warnings.</p>
-<h3><code>--no-force-async-hooks-checks</code><span><a class="mark" href="#cli_no_force_async_hooks_checks" id="cli_no_force_async_hooks_checks">#</a></span></h3>
+<h4><code>--no-force-async-hooks-checks</code><span><a class="mark" href="#cli_no_force_async_hooks_checks" id="cli_no_force_async_hooks_checks">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
 <p>Disables runtime checks for <code>async_hooks</code>. These will still be enabled
 dynamically when <code>async_hooks</code> is enabled.</p>
-<h3><code>--no-warnings</code><span><a class="mark" href="#cli_no_warnings" id="cli_no_warnings">#</a></span></h3>
+<h4><code>--no-warnings</code><span><a class="mark" href="#cli_no_warnings" id="cli_no_warnings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Silence all process warnings (including deprecations).</p>
-<h3><code>--openssl-config=file</code><span><a class="mark" href="#cli_openssl_config_file" id="cli_openssl_config_file">#</a></span></h3>
+<h4><code>--node-memory-debug</code><span><a class="mark" href="#cli_node_memory_debug" id="cli_node_memory_debug">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>Enable extra debug checks for memory leaks in Node.js internals. This is
+usually only useful for developers debugging Node.js itself.</p>
+<h4><code>--openssl-config=file</code><span><a class="mark" href="#cli_openssl_config_file" id="cli_openssl_config_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.9.0</span>
 </div>
 <p>Load an OpenSSL configuration file on startup. Among other uses, this can be
 used to enable FIPS-compliant crypto if Node.js is built with
 <code>./configure --openssl-fips</code>.</p>
-<h3><code>--pending-deprecation</code><span><a class="mark" href="#cli_pending_deprecation" id="cli_pending_deprecation">#</a></span></h3>
+<h4><code>--pending-deprecation</code><span><a class="mark" href="#cli_pending_deprecation" id="cli_pending_deprecation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>Emit pending deprecation warnings.</p>
 <p>Pending deprecations are generally identical to a runtime deprecation with the
 notable exception that they are turned <em>off</em> by default and will not be emitted
-unless either the <code>--pending-deprecation</code> command line flag, or the
+unless either the <code>--pending-deprecation</code> command-line flag, or the
 <code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations
 are used to provide a kind of selective "early warning" mechanism that
 developers may leverage to detect deprecated API usage.</p>
-<h3><code>--policy-integrity=sri</code><span><a class="mark" href="#cli_policy_integrity_sri" id="cli_policy_integrity_sri">#</a></span></h3>
+<h4><code>--policy-integrity=sri</code><span><a class="mark" href="#cli_policy_integrity_sri" id="cli_policy_integrity_sri">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
@@ -693,7 +770,7 @@ developers may leverage to detect deprecated API usage.</p>
 <p>Instructs Node.js to error prior to running any code if the policy does not have
 the specified integrity. It expects a <a href="https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity">Subresource Integrity</a> string as a
 parameter.</p>
-<h3><code>--preserve-symlinks</code><span><a class="mark" href="#cli_preserve_symlinks" id="cli_preserve_symlinks">#</a></span></h3>
+<h4><code>--preserve-symlinks</code><span><a class="mark" href="#cli_preserve_symlinks" id="cli_preserve_symlinks">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -717,7 +794,7 @@ be thrown if <code>moduleA</code> attempts to require <code>moduleB</code> as a
  └── moduleA
      ├── index.js
      └── package.json</code></pre>
-<p>The <code>--preserve-symlinks</code> command line flag instructs Node.js to use the
+<p>The <code>--preserve-symlinks</code> command-line flag instructs Node.js to use the
 symlink path for modules as opposed to the real path, allowing symbolically
 linked peer dependencies to be found.</p>
 <p>Note, however, that using <code>--preserve-symlinks</code> can have other side effects.
@@ -728,7 +805,7 @@ times, causing an exception to be thrown).</p>
 <p>The <code>--preserve-symlinks</code> flag does not apply to the main module, which allows
 <code>node --preserve-symlinks node_module/.bin/&#x3C;foo></code> to work. To apply the same
 behavior for the main module, also use <code>--preserve-symlinks-main</code>.</p>
-<h3><code>--preserve-symlinks-main</code><span><a class="mark" href="#cli_preserve_symlinks_main" id="cli_preserve_symlinks_main">#</a></span></h3>
+<h4><code>--preserve-symlinks-main</code><span><a class="mark" href="#cli_preserve_symlinks_main" id="cli_preserve_symlinks_main">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.2.0</span>
 </div>
@@ -737,22 +814,22 @@ caching the main module (<code>require.main</code>).</p>
 <p>This flag exists so that the main module can be opted-in to the same behavior
 that <code>--preserve-symlinks</code> gives to all other imports; they are separate flags,
 however, for backward compatibility with older Node.js versions.</p>
-<p><code>--preserve-symlinks-main</code> does not imply <code>--preserve-symlinks</code>; it
-is expected that <code>--preserve-symlinks-main</code> will be used in addition to
+<p><code>--preserve-symlinks-main</code> does not imply <code>--preserve-symlinks</code>; use
+<code>--preserve-symlinks-main</code> in addition to
 <code>--preserve-symlinks</code> when it is not desirable to follow symlinks before
 resolving relative paths.</p>
 <p>See <code>--preserve-symlinks</code> for more information.</p>
-<h3><code>--prof</code><span><a class="mark" href="#cli_prof" id="cli_prof">#</a></span></h3>
+<h4><code>--prof</code><span><a class="mark" href="#cli_prof" id="cli_prof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
 <p>Generate V8 profiler output.</p>
-<h3><code>--prof-process</code><span><a class="mark" href="#cli_prof_process" id="cli_prof_process">#</a></span></h3>
+<h4><code>--prof-process</code><span><a class="mark" href="#cli_prof_process" id="cli_prof_process">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.2.0</span>
 </div>
 <p>Process V8 profiler output generated using the V8 option <code>--prof</code>.</p>
-<h3><code>--redirect-warnings=file</code><span><a class="mark" href="#cli_redirect_warnings_file" id="cli_redirect_warnings_file">#</a></span></h3>
+<h4><code>--redirect-warnings=file</code><span><a class="mark" href="#cli_redirect_warnings_file" id="cli_redirect_warnings_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -762,53 +839,53 @@ If an error occurs while attempting to write the warning to the file, the
 warning will be written to stderr instead.</p>
 <p>The <code>file</code> name may be an absolute path. If it is not, the default directory it
 will be written to is controlled by the
-<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command line option.</p>
-<h3><code>--report-compact</code><span><a class="mark" href="#cli_report_compact" id="cli_report_compact">#</a></span></h3>
+<a href="#cli_diagnostic_dir_directory">--diagnostic-dir</a> command-line option.</p>
+<h4><code>--report-compact</code><span><a class="mark" href="#cli_report_compact" id="cli_report_compact">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.12.0</span>
 </div>
 <p>Write reports in a compact format, single-line JSON, more easily consumable
 by log processing systems than the default multi-line format designed for
 human consumption.</p>
-<h3><code>--report-dir=directory</code>, <code>report-directory=directory</code><span><a class="mark" href="#cli_report_dir_directory_report_directory_directory" id="cli_report_dir_directory_report_directory_directory">#</a></span></h3>
+<h4><code>--report-dir=directory</code>, <code>report-directory=directory</code><span><a class="mark" href="#cli_report_dir_directory_report_directory_directory" id="cli_report_dir_directory_report_directory_directory">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>Changed from <code>--diagnostic-report-directory</code> to <code>--report-directory</code></p></td></tr>
+<td><p>Changed from <code>--diagnostic-report-directory</code> to <code>--report-directory</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Location at which the report will be generated.</p>
-<h3><code>--report-filename=filename</code><span><a class="mark" href="#cli_report_filename_filename" id="cli_report_filename_filename">#</a></span></h3>
+<h4><code>--report-filename=filename</code><span><a class="mark" href="#cli_report_filename_filename" id="cli_report_filename_filename">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-filename</code> to <code>--report-filename</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-filename</code> to <code>--report-filename</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Name of the file to which the report will be written.</p>
-<h3><code>--report-on-fatalerror</code><span><a class="mark" href="#cli_report_on_fatalerror" id="cli_report_on_fatalerror">#</a></span></h3>
+<h4><code>--report-on-fatalerror</code><span><a class="mark" href="#cli_report_on_fatalerror" id="cli_report_on_fatalerror">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.0.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-on-fatalerror</code> to <code>--report-on-fatalerror</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-on-fatalerror</code> to <code>--report-on-fatalerror</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
@@ -819,15 +896,15 @@ the Node.js runtime such as out of memory) that lead to termination of the
 application. Useful to inspect various diagnostic data elements such as heap,
 stack, event loop state, resource consumption etc. to reason about the fatal
 error.</p>
-<h3><code>--report-on-signal</code><span><a class="mark" href="#cli_report_on_signal" id="cli_report_on_signal">#</a></span></h3>
+<h4><code>--report-on-signal</code><span><a class="mark" href="#cli_report_on_signal" id="cli_report_on_signal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-on-signal</code> to <code>--report-on-signal</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-on-signal</code> to <code>--report-on-signal</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
@@ -836,15 +913,15 @@ error.</p>
 <p>Enables report to be generated upon receiving the specified (or predefined)
 signal to the running Node.js process. The signal to trigger the report is
 specified through <code>--report-signal</code>.</p>
-<h3><code>--report-signal=signal</code><span><a class="mark" href="#cli_report_signal_signal" id="cli_report_signal_signal">#</a></span></h3>
+<h4><code>--report-signal=signal</code><span><a class="mark" href="#cli_report_signal_signal" id="cli_report_signal_signal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-signal</code> to <code>--report-signal</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-signal</code> to <code>--report-signal</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
@@ -852,15 +929,15 @@ specified through <code>--report-signal</code>.</p>
 </div>
 <p>Sets or resets the signal for report generation (not supported on Windows).
 Default signal is <code>SIGUSR2</code>.</p>
-<h3><code>--report-uncaught-exception</code><span><a class="mark" href="#cli_report_uncaught_exception" id="cli_report_uncaught_exception">#</a></span></h3>
+<h4><code>--report-uncaught-exception</code><span><a class="mark" href="#cli_report_uncaught_exception" id="cli_report_uncaught_exception">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This option is no longer experimental.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>changed from <code>--diagnostic-report-uncaught-exception</code> to <code>--report-uncaught-exception</code></p></td></tr>
+<td><p>changed from <code>--diagnostic-report-uncaught-exception</code> to <code>--report-uncaught-exception</code>.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
 </tbody></table>
@@ -869,146 +946,172 @@ Default signal is <code>SIGUSR2</code>.</p>
 <p>Enables report to be generated on uncaught exceptions. Useful when inspecting
 the JavaScript stack in conjunction with native stack and other runtime
 environment data.</p>
-<h3><code>--throw-deprecation</code><span><a class="mark" href="#cli_throw_deprecation" id="cli_throw_deprecation">#</a></span></h3>
+<h4><code>--throw-deprecation</code><span><a class="mark" href="#cli_throw_deprecation" id="cli_throw_deprecation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
 <p>Throw errors for deprecations.</p>
-<h3><code>--title=title</code><span><a class="mark" href="#cli_title_title" id="cli_title_title">#</a></span></h3>
+<h4><code>--title=title</code><span><a class="mark" href="#cli_title_title" id="cli_title_title">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 </div>
 <p>Set <code>process.title</code> on startup.</p>
-<h3><code>--tls-cipher-list=list</code><span><a class="mark" href="#cli_tls_cipher_list_list" id="cli_tls_cipher_list_list">#</a></span></h3>
+<h4><code>--tls-cipher-list=list</code><span><a class="mark" href="#cli_tls_cipher_list_list" id="cli_tls_cipher_list_list">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v4.0.0</span>
 </div>
 <p>Specify an alternative default TLS cipher list. Requires Node.js to be built
 with crypto support (default).</p>
-<h3><code>--tls-keylog=file</code><span><a class="mark" href="#cli_tls_keylog_file" id="cli_tls_keylog_file">#</a></span></h3>
+<h4><code>--tls-keylog=file</code><span><a class="mark" href="#cli_tls_keylog_file" id="cli_tls_keylog_file">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <p>Log TLS key material to a file. The key material is in NSS <code>SSLKEYLOGFILE</code>
 format and can be used by software (such as Wireshark) to decrypt the TLS
 traffic.</p>
-<h3><code>--tls-max-v1.2</code><span><a class="mark" href="#cli_tls_max_v1_2" id="cli_tls_max_v1_2">#</a></span></h3>
+<h4><code>--tls-max-v1.2</code><span><a class="mark" href="#cli_tls_max_v1_2" id="cli_tls_max_v1_2">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <p>Set <a href="tls.html#tls_tls_default_max_version"><code>tls.DEFAULT_MAX_VERSION</code></a> to 'TLSv1.2'. Use to disable support for
 TLSv1.3.</p>
-<h3><code>--tls-max-v1.3</code><span><a class="mark" href="#cli_tls_max_v1_3" id="cli_tls_max_v1_3">#</a></span></h3>
+<h4><code>--tls-max-v1.3</code><span><a class="mark" href="#cli_tls_max_v1_3" id="cli_tls_max_v1_3">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>Set default <a href="tls.html#tls_tls_default_max_version"><code>tls.DEFAULT_MAX_VERSION</code></a> to 'TLSv1.3'. Use to enable support
 for TLSv1.3.</p>
-<h3><code>--tls-min-v1.0</code><span><a class="mark" href="#cli_tls_min_v1_0" id="cli_tls_min_v1_0">#</a></span></h3>
+<h4><code>--tls-min-v1.0</code><span><a class="mark" href="#cli_tls_min_v1_0" id="cli_tls_min_v1_0">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <p>Set default <a href="tls.html#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a> to 'TLSv1'. Use for compatibility with
 old TLS clients or servers.</p>
-<h3><code>--tls-min-v1.1</code><span><a class="mark" href="#cli_tls_min_v1_1" id="cli_tls_min_v1_1">#</a></span></h3>
+<h4><code>--tls-min-v1.1</code><span><a class="mark" href="#cli_tls_min_v1_1" id="cli_tls_min_v1_1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.20.0</span>
 </div>
 <p>Set default <a href="tls.html#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a> to 'TLSv1.1'. Use for compatibility
 with old TLS clients or servers.</p>
-<h3><code>--tls-min-v1.2</code><span><a class="mark" href="#cli_tls_min_v1_2" id="cli_tls_min_v1_2">#</a></span></h3>
+<h4><code>--tls-min-v1.2</code><span><a class="mark" href="#cli_tls_min_v1_2" id="cli_tls_min_v1_2">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.2.0</span>
+<span>Added in: v12.2.0, v10.20.0</span>
 </div>
 <p>Set default <a href="tls.html#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a> to 'TLSv1.2'. This is the default for
 12.x and later, but the option is supported for compatibility with older Node.js
 versions.</p>
-<h3><code>--tls-min-v1.3</code><span><a class="mark" href="#cli_tls_min_v1_3" id="cli_tls_min_v1_3">#</a></span></h3>
+<h4><code>--tls-min-v1.3</code><span><a class="mark" href="#cli_tls_min_v1_3" id="cli_tls_min_v1_3">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>Set default <a href="tls.html#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a> to 'TLSv1.3'. Use to disable support
 for TLSv1.2, which is not as secure as TLSv1.3.</p>
-<h3><code>--trace-deprecation</code><span><a class="mark" href="#cli_trace_deprecation" id="cli_trace_deprecation">#</a></span></h3>
+<h4><code>--trace-atomics-wait</code><span><a class="mark" href="#cli_trace_atomics_wait" id="cli_trace_atomics_wait">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.3.0</span>
+</div>
+<p>Print short summaries of calls to <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait"><code>Atomics.wait()</code></a> to stderr.
+The output could look like this:</p>
+<pre><code class="language-text">(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 1, inf) started
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 1, inf) did not wait because the values mismatched
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 0, 10) started
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 0, 10) timed out
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 4, 0, inf) started
+(node:15701) [Thread 1] Atomics.wait(&#x26;lt;address> + 4, -1, inf) started
+(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 4, 0, inf) was woken up by another thread
+(node:15701) [Thread 1] Atomics.wait(&#x26;lt;address> + 4, -1, inf) was woken up by another thread</code></pre>
+<p>The fields here correspond to:</p>
+<ul>
+<li>The thread id as given by <a href="worker_threads.html#worker_threads_worker_threadid"><code>worker_threads.threadId</code></a></li>
+<li>The base address of the <code>SharedArrayBuffer</code> in question, as well as the
+byte offset corresponding to the index passed to <code>Atomics.wait()</code></li>
+<li>The expected value that was passed to <code>Atomics.wait()</code></li>
+<li>The timeout passed to <code>Atomics.wait</code></li>
+</ul>
+<h4><code>--trace-deprecation</code><span><a class="mark" href="#cli_trace_deprecation" id="cli_trace_deprecation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
 <p>Print stack traces for deprecations.</p>
-<h3><code>--trace-event-categories</code><span><a class="mark" href="#cli_trace_event_categories" id="cli_trace_event_categories">#</a></span></h3>
+<h4><code>--trace-event-categories</code><span><a class="mark" href="#cli_trace_event_categories" id="cli_trace_event_categories">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
 <p>A comma separated list of categories that should be traced when trace event
 tracing is enabled using <code>--trace-events-enabled</code>.</p>
-<h3><code>--trace-event-file-pattern</code><span><a class="mark" href="#cli_trace_event_file_pattern" id="cli_trace_event_file_pattern">#</a></span></h3>
+<h4><code>--trace-event-file-pattern</code><span><a class="mark" href="#cli_trace_event_file_pattern" id="cli_trace_event_file_pattern">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.8.0</span>
 </div>
 <p>Template string specifying the filepath for the trace event data, it
 supports <code>${rotation}</code> and <code>${pid}</code>.</p>
-<h3><code>--trace-events-enabled</code><span><a class="mark" href="#cli_trace_events_enabled" id="cli_trace_events_enabled">#</a></span></h3>
+<h4><code>--trace-events-enabled</code><span><a class="mark" href="#cli_trace_events_enabled" id="cli_trace_events_enabled">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
 <p>Enables the collection of trace event tracing information.</p>
-<h3><code>--trace-exit</code><span><a class="mark" href="#cli_trace_exit" id="cli_trace_exit">#</a></span></h3>
+<h4><code>--trace-exit</code><span><a class="mark" href="#cli_trace_exit" id="cli_trace_exit">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.5.0, v12.16.0</span>
 </div>
 <p>Prints a stack trace whenever an environment is exited proactively,
 i.e. invoking <code>process.exit()</code>.</p>
-<h3><code>--trace-sigint</code><span><a class="mark" href="#cli_trace_sigint" id="cli_trace_sigint">#</a></span></h3>
+<h4><code>--trace-sigint</code><span><a class="mark" href="#cli_trace_sigint" id="cli_trace_sigint">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.9.0</span>
 </div>
 <p>Prints a stack trace on SIGINT.</p>
-<h3><code>--trace-sync-io</code><span><a class="mark" href="#cli_trace_sync_io" id="cli_trace_sync_io">#</a></span></h3>
+<h4><code>--trace-sync-io</code><span><a class="mark" href="#cli_trace_sync_io" id="cli_trace_sync_io">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v2.1.0</span>
 </div>
 <p>Prints a stack trace whenever synchronous I/O is detected after the first turn
 of the event loop.</p>
-<h3><code>--trace-tls</code><span><a class="mark" href="#cli_trace_tls" id="cli_trace_tls">#</a></span></h3>
+<h4><code>--trace-tls</code><span><a class="mark" href="#cli_trace_tls" id="cli_trace_tls">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.2.0</span>
 </div>
 <p>Prints TLS packet trace information to <code>stderr</code>. This can be used to debug TLS
 connection problems.</p>
-<h3><code>--trace-uncaught</code><span><a class="mark" href="#cli_trace_uncaught" id="cli_trace_uncaught">#</a></span></h3>
+<h4><code>--trace-uncaught</code><span><a class="mark" href="#cli_trace_uncaught" id="cli_trace_uncaught">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.1.0</span>
 </div>
 <p>Print stack traces for uncaught exceptions; usually, the stack trace associated
 with the creation of an <code>Error</code> is printed, whereas this makes Node.js also
 print the stack trace associated with throwing the value (which does not need
 to be an <code>Error</code> instance).</p>
 <p>Enabling this option may affect garbage collection behavior negatively.</p>
-<h3><code>--trace-warnings</code><span><a class="mark" href="#cli_trace_warnings" id="cli_trace_warnings">#</a></span></h3>
+<h4><code>--trace-warnings</code><span><a class="mark" href="#cli_trace_warnings" id="cli_trace_warnings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Print stack traces for process warnings (including deprecations).</p>
-<h3><code>--track-heap-objects</code><span><a class="mark" href="#cli_track_heap_objects" id="cli_track_heap_objects">#</a></span></h3>
+<h4><code>--track-heap-objects</code><span><a class="mark" href="#cli_track_heap_objects" id="cli_track_heap_objects">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v2.4.0</span>
 </div>
 <p>Track heap object allocations for heap snapshots.</p>
-<h3><code>--unhandled-rejections=mode</code><span><a class="mark" href="#cli_unhandled_rejections_mode" id="cli_unhandled_rejections_mode">#</a></span></h3>
+<h4><code>--unhandled-rejections=mode</code><span><a class="mark" href="#cli_unhandled_rejections_mode" id="cli_unhandled_rejections_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<span>Added in: v12.0.0, v10.17.0</span>
 </div>
 <p>By default all unhandled rejections trigger a warning plus a deprecation warning
 for the very first unhandled rejection in case no <a href="process.html#process_event_unhandledrejection"><code>unhandledRejection</code></a> hook
 is used.</p>
 <p>Using this flag allows to change what should happen when an unhandled rejection
-occurs. One of three modes can be chosen:</p>
+occurs. One of the following modes can be chosen:</p>
 <ul>
+<li><code>throw</code>: Emit <a href="process.html#process_event_unhandledrejection"><code>unhandledRejection</code></a>. If this hook is not set, raise the
+unhandled rejection as an uncaught exception.</li>
 <li><code>strict</code>: Raise the unhandled rejection as an uncaught exception.</li>
 <li><code>warn</code>: Always trigger a warning, no matter if the <a href="process.html#process_event_unhandledrejection"><code>unhandledRejection</code></a>
 hook is set or not but do not print the deprecation warning.</li>
+<li><code>warn-with-error-code</code>: Emit <a href="process.html#process_event_unhandledrejection"><code>unhandledRejection</code></a>. If this hook is not
+set, trigger a warning, and set the process exit code to 1.</li>
 <li><code>none</code>: Silence all warnings.</li>
 </ul>
-<h3><code>--use-bundled-ca</code>, <code>--use-openssl-ca</code><span><a class="mark" href="#cli_use_bundled_ca_use_openssl_ca" id="cli_use_bundled_ca_use_openssl_ca">#</a></span></h3>
+<h4><code>--use-bundled-ca</code>, <code>--use-openssl-ca</code><span><a class="mark" href="#cli_use_bundled_ca_use_openssl_ca" id="cli_use_bundled_ca_use_openssl_ca">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.11.0</span>
 </div>
@@ -1023,9 +1126,9 @@ maintainers and system administrators. OpenSSL CA store location is dependent on
 configuration of the OpenSSL library but this can be altered at runtime using
 environment variables.</p>
 <p>See <code>SSL_CERT_DIR</code> and <code>SSL_CERT_FILE</code>.</p>
-<h3><code>--use-largepages=mode</code><span><a class="mark" href="#cli_use_largepages_mode" id="cli_use_largepages_mode">#</a></span></h3>
+<h4><code>--use-largepages=mode</code><span><a class="mark" href="#cli_use_largepages_mode" id="cli_use_largepages_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.6.0</span>
 </div>
 <p>Re-map the Node.js static code to large memory pages at startup. If supported on
 the target system, this will cause the Node.js static code to be moved onto 2
@@ -1038,12 +1141,12 @@ be ignored and a message will be printed to standard error.</li>
 <li><code>silent</code>: If supported by the OS, mapping will be attempted. Failure to map
 will be ignored and will not be reported.</li>
 </ul>
-<h3><code>--v8-options</code><span><a class="mark" href="#cli_v8_options" id="cli_v8_options">#</a></span></h3>
+<h4><code>--v8-options</code><span><a class="mark" href="#cli_v8_options" id="cli_v8_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.3</span>
 </div>
-<p>Print V8 command line options.</p>
-<h3><code>--v8-pool-size=num</code><span><a class="mark" href="#cli_v8_pool_size_num" id="cli_v8_pool_size_num">#</a></span></h3>
+<p>Print V8 command-line options.</p>
+<h4><code>--v8-pool-size=num</code><span><a class="mark" href="#cli_v8_pool_size_num" id="cli_v8_pool_size_num">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.10.0</span>
 </div>
@@ -1052,13 +1155,13 @@ will be ignored and will not be reported.</li>
 on the number of online processors.</p>
 <p>If the value provided is larger than V8's maximum, then the largest value
 will be chosen.</p>
-<h3><code>--zero-fill-buffers</code><span><a class="mark" href="#cli_zero_fill_buffers" id="cli_zero_fill_buffers">#</a></span></h3>
+<h4><code>--zero-fill-buffers</code><span><a class="mark" href="#cli_zero_fill_buffers" id="cli_zero_fill_buffers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
 <p>Automatically zero-fills all newly allocated <a href="buffer.html#buffer_class_buffer"><code>Buffer</code></a> and <a href="buffer.html#buffer_class_slowbuffer"><code>SlowBuffer</code></a>
 instances.</p>
-<h3><code>-c</code>, <code>--check</code><span><a class="mark" href="#cli_c_check" id="cli_c_check">#</a></span></h3>
+<h4><code>-c</code>, <code>--check</code><span><a class="mark" href="#cli_c_check" id="cli_c_check">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1071,7 +1174,7 @@ instances.</p>
 </details>
 </div>
 <p>Syntax check the script without executing.</p>
-<h3><code>-e</code>, <code>--eval "script"</code><span><a class="mark" href="#cli_e_eval_script" id="cli_e_eval_script">#</a></span></h3>
+<h4><code>-e</code>, <code>--eval "script"</code><span><a class="mark" href="#cli_e_eval_script" id="cli_e_eval_script">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1088,18 +1191,18 @@ predefined in the REPL can also be used in <code>script</code>.</p>
 <p>On Windows, using <code>cmd.exe</code> a single quote will not work correctly because it
 only recognizes double <code>"</code> for quoting. In Powershell or Git bash, both <code>'</code>
 and <code>"</code> are usable.</p>
-<h3><code>-h</code>, <code>--help</code><span><a class="mark" href="#cli_h_help" id="cli_h_help">#</a></span></h3>
+<h4><code>-h</code>, <code>--help</code><span><a class="mark" href="#cli_h_help" id="cli_h_help">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.3</span>
 </div>
-<p>Print node command line options.
+<p>Print node command-line options.
 The output of this option is less detailed than this document.</p>
-<h3><code>-i</code>, <code>--interactive</code><span><a class="mark" href="#cli_i_interactive" id="cli_i_interactive">#</a></span></h3>
+<h4><code>-i</code>, <code>--interactive</code><span><a class="mark" href="#cli_i_interactive" id="cli_i_interactive">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>Opens the REPL even if stdin does not appear to be a terminal.</p>
-<h3><code>-p</code>, <code>--print "script"</code><span><a class="mark" href="#cli_p_print_script" id="cli_p_print_script">#</a></span></h3>
+<h4><code>-p</code>, <code>--print "script"</code><span><a class="mark" href="#cli_p_print_script" id="cli_p_print_script">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1112,32 +1215,45 @@ The output of this option is less detailed than this document.</p>
 </details>
 </div>
 <p>Identical to <code>-e</code> but prints the result.</p>
-<h3><code>-r</code>, <code>--require module</code><span><a class="mark" href="#cli_r_require_module" id="cli_r_require_module">#</a></span></h3>
+<h4><code>-r</code>, <code>--require module</code><span><a class="mark" href="#cli_r_require_module" id="cli_r_require_module">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
 <p>Preload the specified module at startup.</p>
 <p>Follows <code>require()</code>'s module resolution
 rules. <code>module</code> may be either a path to a file, or a node module name.</p>
-<h3><code>-v</code>, <code>--version</code><span><a class="mark" href="#cli_v_version" id="cli_v_version">#</a></span></h3>
+<p>Only CommonJS modules are supported. Attempting to preload a
+ES6 Module using <code>--require</code> will fail with an error.</p>
+<h4><code>-v</code>, <code>--version</code><span><a class="mark" href="#cli_v_version" id="cli_v_version">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.3</span>
 </div>
 <p>Print node's version.</p>
-<h2>Environment variables<span><a class="mark" href="#cli_environment_variables" id="cli_environment_variables">#</a></span></h2>
-<h3><code>NODE_DEBUG=module[,…]</code><span><a class="mark" href="#cli_node_debug_module" id="cli_node_debug_module">#</a></span></h3>
+</section><section><h3>Environment variables<span><a class="mark" href="#cli_environment_variables" id="cli_environment_variables">#</a></span></h3>
+<h4><code>FORCE_COLOR=[1, 2, 3]</code><span><a class="mark" href="#cli_force_color_1_2_3" id="cli_force_color_1_2_3">#</a></span></h4>
+<p>The <code>FORCE_COLOR</code> environment variable is used to
+enable ANSI colorized output. The value may be:</p>
+<ul>
+<li><code>1</code>, <code>true</code>, or the empty string <code>''</code> indicate 16-color support,</li>
+<li><code>2</code> to indicate 256-color support, or</li>
+<li><code>3</code> to indicate 16 million-color support.</li>
+</ul>
+<p>When <code>FORCE_COLOR</code> is used and set to a supported value, both the <code>NO_COLOR</code>,
+and <code>NODE_DISABLE_COLORS</code> environment variables are ignored.</p>
+<p>Any other value will result in colorized output being disabled.</p>
+<h4><code>NODE_DEBUG=module[,…]</code><span><a class="mark" href="#cli_node_debug_module" id="cli_node_debug_module">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.32</span>
 </div>
 <p><code>','</code>-separated list of core modules that should print debug information.</p>
-<h3><code>NODE_DEBUG_NATIVE=module[,…]</code><span><a class="mark" href="#cli_node_debug_native_module" id="cli_node_debug_native_module">#</a></span></h3>
+<h4><code>NODE_DEBUG_NATIVE=module[,…]</code><span><a class="mark" href="#cli_node_debug_native_module" id="cli_node_debug_native_module">#</a></span></h4>
 <p><code>','</code>-separated list of core C++ modules that should print debug information.</p>
-<h3><code>NODE_DISABLE_COLORS=1</code><span><a class="mark" href="#cli_node_disable_colors_1" id="cli_node_disable_colors_1">#</a></span></h3>
+<h4><code>NODE_DISABLE_COLORS=1</code><span><a class="mark" href="#cli_node_disable_colors_1" id="cli_node_disable_colors_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
 <p>When set, colors will not be used in the REPL.</p>
-<h3><code>NODE_EXTRA_CA_CERTS=file</code><span><a class="mark" href="#cli_node_extra_ca_certs_file" id="cli_node_extra_ca_certs_file">#</a></span></h3>
+<h4><code>NODE_EXTRA_CA_CERTS=file</code><span><a class="mark" href="#cli_node_extra_ca_certs_file" id="cli_node_extra_ca_certs_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.3.0</span>
 </div>
@@ -1150,35 +1266,37 @@ malformed, but any errors are otherwise ignored.</p>
 options property is explicitly specified for a TLS or HTTPS client or server.</p>
 <p>This environment variable is ignored when <code>node</code> runs as setuid root or
 has Linux file capabilities set.</p>
-<h3><code>NODE_ICU_DATA=file</code><span><a class="mark" href="#cli_node_icu_data_file" id="cli_node_icu_data_file">#</a></span></h3>
+<p>The <code>NODE_EXTRA_CA_CERTS</code> environment variable is only read when the Node.js
+process is first launched. Changing the value at runtime using
+<code>process.env.NODE_EXTRA_CA_CERTS</code> has no effect on the current process.</p>
+<h4><code>NODE_ICU_DATA=file</code><span><a class="mark" href="#cli_node_icu_data_file" id="cli_node_icu_data_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
 <p>Data path for ICU (<code>Intl</code> object) data. Will extend linked-in data when compiled
 with small-icu support.</p>
-<h3><code>NODE_NO_WARNINGS=1</code><span><a class="mark" href="#cli_node_no_warnings_1" id="cli_node_no_warnings_1">#</a></span></h3>
+<h4><code>NODE_NO_WARNINGS=1</code><span><a class="mark" href="#cli_node_no_warnings_1" id="cli_node_no_warnings_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.11.0</span>
 </div>
 <p>When set to <code>1</code>, process warnings are silenced.</p>
-<h3><code>NODE_OPTIONS=options...</code><span><a class="mark" href="#cli_node_options_options" id="cli_node_options_options">#</a></span></h3>
+<h4><code>NODE_OPTIONS=options...</code><span><a class="mark" href="#cli_node_options_options" id="cli_node_options_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
-<p>A space-separated list of command line options. <code>options...</code> are interpreted
-before command line options, so command line options will override or
+<p>A space-separated list of command-line options. <code>options...</code> are interpreted
+before command-line options, so command-line options will override or
 compound after anything in <code>options...</code>. Node.js will exit with an error if
 an option that is not allowed in the environment is used, such as <code>-p</code> or a
 script file.</p>
-<p>In case an option value happens to contain a space (for example a path listed
-in <code>--require</code>), it must be escaped using double quotes. For example:</p>
+<p>If an option value contains a space, it can be escaped using double quotes:</p>
 <pre><code class="language-bash">NODE_OPTIONS=<span class="hljs-string">'--require "./my path/file.js"'</span></code></pre>
-<p>A singleton flag passed as a command line option will override the same flag
+<p>A singleton flag passed as a command-line option will override the same flag
 passed into <code>NODE_OPTIONS</code>:</p>
 <pre><code class="language-bash"><span class="hljs-comment"># The inspector will be available on port 5555</span>
 NODE_OPTIONS=<span class="hljs-string">'--inspect=localhost:4444'</span> node --inspect=localhost:5555</code></pre>
 <p>A flag that can be passed multiple times will be treated as if its
-<code>NODE_OPTIONS</code> instances were passed first, and then its command line
+<code>NODE_OPTIONS</code> instances were passed first, and then its command-line
 instances afterwards:</p>
 <pre><code class="language-bash">NODE_OPTIONS=<span class="hljs-string">'--require "./a.js"'</span> node --require <span class="hljs-string">"./b.js"</span>
 <span class="hljs-comment"># is equivalent to:</span>
@@ -1186,11 +1304,13 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <p>Node.js options that are allowed are:</p>
 <!-- node-options-node start -->
 <ul>
-<li><code>--conditions</code></li>
+<li><code>--conditions</code>, <code>-C</code></li>
 <li><code>--diagnostic-dir</code></li>
 <li><code>--disable-proto</code></li>
+<li><code>--dns-result-order</code></li>
 <li><code>--enable-fips</code></li>
 <li><code>--enable-source-maps</code></li>
+<li><code>--experimental-abortcontroller</code></li>
 <li><code>--experimental-import-meta-resolve</code></li>
 <li><code>--experimental-json-modules</code></li>
 <li><code>--experimental-loader</code></li>
@@ -1198,15 +1318,16 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--experimental-policy</code></li>
 <li><code>--experimental-repl-await</code></li>
 <li><code>--experimental-specifier-resolution</code></li>
+<li><code>--experimental-top-level-await</code></li>
 <li><code>--experimental-vm-modules</code></li>
 <li><code>--experimental-wasi-unstable-preview1</code></li>
 <li><code>--experimental-wasm-modules</code></li>
 <li><code>--force-context-aware</code></li>
 <li><code>--force-fips</code></li>
 <li><code>--frozen-intrinsics</code></li>
+<li><code>--heapsnapshot-near-heap-limit</code></li>
 <li><code>--heapsnapshot-signal</code></li>
 <li><code>--http-parser</code></li>
-<li><code>--http-server-default-timeout</code></li>
 <li><code>--icu-data-dir</code></li>
 <li><code>--input-type</code></li>
 <li><code>--insecure-http-parser</code></li>
@@ -1219,6 +1340,7 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--no-deprecation</code></li>
 <li><code>--no-force-async-hooks-checks</code></li>
 <li><code>--no-warnings</code></li>
+<li><code>--node-memory-debug</code></li>
 <li><code>--openssl-config</code></li>
 <li><code>--pending-deprecation</code></li>
 <li><code>--policy-integrity</code></li>
@@ -1244,6 +1366,7 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--tls-min-v1.1</code></li>
 <li><code>--tls-min-v1.2</code></li>
 <li><code>--tls-min-v1.3</code></li>
+<li><code>--trace-atomics-wait</code></li>
 <li><code>--trace-deprecation</code></li>
 <li><code>--trace-event-categories</code></li>
 <li><code>--trace-event-file-pattern</code></li>
@@ -1260,10 +1383,9 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--use-largepages</code></li>
 <li><code>--use-openssl-ca</code></li>
 <li><code>--v8-pool-size</code></li>
-<li><code>--zero-fill-buffers</code>
-<!-- node-options-node end -->
-</li>
+<li><code>--zero-fill-buffers</code></li>
 </ul>
+<!-- node-options-node end -->
 <p>V8 options that are allowed are:</p>
 <!-- node-options-v8 start -->
 <ul>
@@ -1277,39 +1399,38 @@ node --require <span class="hljs-string">"./a.js"</span> --require <span class="
 <li><code>--perf-basic-prof</code></li>
 <li><code>--perf-prof-unwinding-info</code></li>
 <li><code>--perf-prof</code></li>
-<li><code>--stack-trace-limit</code>
-<!-- node-options-v8 end -->
-</li>
+<li><code>--stack-trace-limit</code></li>
 </ul>
+<!-- node-options-v8 end -->
 <p><code>--perf-basic-prof-only-functions</code>, <code>--perf-basic-prof</code>,
 <code>--perf-prof-unwinding-info</code>, and <code>--perf-prof</code> are only available on Linux.</p>
-<h3><code>NODE_PATH=path[:…]</code><span><a class="mark" href="#cli_node_path_path" id="cli_node_path_path">#</a></span></h3>
+<h4><code>NODE_PATH=path[:…]</code><span><a class="mark" href="#cli_node_path_path" id="cli_node_path_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.32</span>
 </div>
 <p><code>':'</code>-separated list of directories prefixed to the module search path.</p>
 <p>On Windows, this is a <code>';'</code>-separated list instead.</p>
-<h3><code>NODE_PENDING_DEPRECATION=1</code><span><a class="mark" href="#cli_node_pending_deprecation_1" id="cli_node_pending_deprecation_1">#</a></span></h3>
+<h4><code>NODE_PENDING_DEPRECATION=1</code><span><a class="mark" href="#cli_node_pending_deprecation_1" id="cli_node_pending_deprecation_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>When set to <code>1</code>, emit pending deprecation warnings.</p>
 <p>Pending deprecations are generally identical to a runtime deprecation with the
 notable exception that they are turned <em>off</em> by default and will not be emitted
-unless either the <code>--pending-deprecation</code> command line flag, or the
+unless either the <code>--pending-deprecation</code> command-line flag, or the
 <code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations
 are used to provide a kind of selective "early warning" mechanism that
 developers may leverage to detect deprecated API usage.</p>
-<h3><code>NODE_PENDING_PIPE_INSTANCES=instances</code><span><a class="mark" href="#cli_node_pending_pipe_instances_instances" id="cli_node_pending_pipe_instances_instances">#</a></span></h3>
+<h4><code>NODE_PENDING_PIPE_INSTANCES=instances</code><span><a class="mark" href="#cli_node_pending_pipe_instances_instances" id="cli_node_pending_pipe_instances_instances">#</a></span></h4>
 <p>Set the number of pending pipe instance handles when the pipe server is waiting
 for connections. This setting applies to Windows only.</p>
-<h3><code>NODE_PRESERVE_SYMLINKS=1</code><span><a class="mark" href="#cli_node_preserve_symlinks_1" id="cli_node_preserve_symlinks_1">#</a></span></h3>
+<h4><code>NODE_PRESERVE_SYMLINKS=1</code><span><a class="mark" href="#cli_node_preserve_symlinks_1" id="cli_node_preserve_symlinks_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.1.0</span>
 </div>
 <p>When set to <code>1</code>, instructs the module loader to preserve symbolic links when
 resolving and caching modules.</p>
-<h3><code>NODE_REDIRECT_WARNINGS=file</code><span><a class="mark" href="#cli_node_redirect_warnings_file" id="cli_node_redirect_warnings_file">#</a></span></h3>
+<h4><code>NODE_REDIRECT_WARNINGS=file</code><span><a class="mark" href="#cli_node_redirect_warnings_file" id="cli_node_redirect_warnings_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -1318,24 +1439,31 @@ printing to stderr. The file will be created if it does not exist, and will be
 appended to if it does. If an error occurs while attempting to write the
 warning to the file, the warning will be written to stderr instead. This is
 equivalent to using the <code>--redirect-warnings=file</code> command-line flag.</p>
-<h3><code>NODE_REPL_HISTORY=file</code><span><a class="mark" href="#cli_node_repl_history_file" id="cli_node_repl_history_file">#</a></span></h3>
+<h4><code>NODE_REPL_HISTORY=file</code><span><a class="mark" href="#cli_node_repl_history_file" id="cli_node_repl_history_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
 <p>Path to the file used to store the persistent REPL history. The default path is
 <code>~/.node_repl_history</code>, which is overridden by this variable. Setting the value
 to an empty string (<code>''</code> or <code>' '</code>) disables persistent REPL history.</p>
-<h3><code>NODE_REPL_EXTERNAL_MODULE=file</code><span><a class="mark" href="#cli_node_repl_external_module_file" id="cli_node_repl_external_module_file">#</a></span></h3>
+<h4><code>NODE_REPL_EXTERNAL_MODULE=file</code><span><a class="mark" href="#cli_node_repl_external_module_file" id="cli_node_repl_external_module_file">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <p>Path to a Node.js module which will be loaded in place of the built-in REPL.
 Overriding this value to an empty string (<code>''</code>) will use the built-in REPL.</p>
-<h3><code>NODE_TLS_REJECT_UNAUTHORIZED=value</code><span><a class="mark" href="#cli_node_tls_reject_unauthorized_value" id="cli_node_tls_reject_unauthorized_value">#</a></span></h3>
+<h4><code>NODE_SKIP_PLATFORM_CHECK=value</code><span><a class="mark" href="#cli_node_skip_platform_check_value" id="cli_node_skip_platform_check_value">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p>If <code>value</code> equals <code>'1'</code>, the check for a supported platform is skipped during
+Node.js startup. Node.js might not execute correctly. Any issues encountered
+on unsupported platforms will not be fixed.</p>
+<h4><code>NODE_TLS_REJECT_UNAUTHORIZED=value</code><span><a class="mark" href="#cli_node_tls_reject_unauthorized_value" id="cli_node_tls_reject_unauthorized_value">#</a></span></h4>
 <p>If <code>value</code> equals <code>'0'</code>, certificate validation is disabled for TLS connections.
 This makes TLS, and HTTPS by extension, insecure. The use of this environment
 variable is strongly discouraged.</p>
-<h3><code>NODE_V8_COVERAGE=dir</code><span><a class="mark" href="#cli_node_v8_coverage_dir" id="cli_node_v8_coverage_dir">#</a></span></h3>
+<h4><code>NODE_V8_COVERAGE=dir</code><span><a class="mark" href="#cli_node_v8_coverage_dir" id="cli_node_v8_coverage_dir">#</a></span></h4>
 <p>When set, Node.js will begin outputting <a href="https://v8project.blogspot.com/2017/12/javascript-code-coverage.html">V8 JavaScript code coverage</a> and
 <a href="https://sourcemaps.info/spec.html">Source Map</a> data to the directory provided as an argument (coverage
 information is written as JSON to files with a <code>coverage</code> prefix).</p>
@@ -1343,19 +1471,19 @@ information is written as JSON to files with a <code>coverage</code> prefix).</p
 easier to instrument applications that call the <code>child_process.spawn()</code> family
 of functions. <code>NODE_V8_COVERAGE</code> can be set to an empty string, to prevent
 propagation.</p>
-<h4>Coverage output<span><a class="mark" href="#cli_coverage_output" id="cli_coverage_output">#</a></span></h4>
+<h5>Coverage output<span><a class="mark" href="#cli_coverage_output" id="cli_coverage_output">#</a></span></h5>
 <p>Coverage is output as an array of <a href="https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-ScriptCoverage">ScriptCoverage</a> objects on the top-level
 key <code>result</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"result"</span>: [
-    {
-      <span class="hljs-attr">"scriptId"</span>: <span class="hljs-string">"67"</span>,
-      <span class="hljs-attr">"url"</span>: <span class="hljs-string">"internal/tty.js"</span>,
-      <span class="hljs-attr">"functions"</span>: []
-    }
-  ]
-}</code></pre>
-<h4>Source map cache<span><a class="mark" href="#cli_source_map_cache" id="cli_source_map_cache">#</a></span></h4>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"result"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"scriptId"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"67"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"url"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"internal/tty.js"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"functions"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span><span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h5>Source map cache<span><a class="mark" href="#cli_source_map_cache" id="cli_source_map_cache">#</a></span></h5>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>If found, source map data is appended to the top-level key <code>source-map-cache</code>
 on the JSON coverage object.</p>
@@ -1363,48 +1491,51 @@ on the JSON coverage object.</p>
 were extracted from, and values which include the raw source-map URL
 (in the key <code>url</code>), the parsed Source Map v3 information (in the key <code>data</code>),
 and the line lengths of the source file (in the key <code>lineLengths</code>).</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"result"</span>: [
-    {
-      <span class="hljs-attr">"scriptId"</span>: <span class="hljs-string">"68"</span>,
-      <span class="hljs-attr">"url"</span>: <span class="hljs-string">"file:///absolute/path/to/source.js"</span>,
-      <span class="hljs-attr">"functions"</span>: []
-    }
-  ],
-  <span class="hljs-attr">"source-map-cache"</span>: {
-    <span class="hljs-attr">"file:///absolute/path/to/source.js"</span>: {
-      <span class="hljs-attr">"url"</span>: <span class="hljs-string">"./path-to-map.json"</span>,
-      <span class="hljs-attr">"data"</span>: {
-        <span class="hljs-attr">"version"</span>: <span class="hljs-number">3</span>,
-        <span class="hljs-attr">"sources"</span>: [
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"result"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"scriptId"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"68"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"url"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"file:///absolute/path/to/source.js"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"functions"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span><span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"source-map-cache"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"file:///absolute/path/to/source.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"url"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./path-to-map.json"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"data"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"version"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">3</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"sources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
           <span class="hljs-string">"file:///absolute/path/to/original.js"</span>
-        ],
-        <span class="hljs-attr">"names"</span>: [
-          <span class="hljs-string">"Foo"</span>,
-          <span class="hljs-string">"console"</span>,
+        <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"names"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+          <span class="hljs-string">"Foo"</span><span class="hljs-punctuation">,</span>
+          <span class="hljs-string">"console"</span><span class="hljs-punctuation">,</span>
           <span class="hljs-string">"info"</span>
-        ],
-        <span class="hljs-attr">"mappings"</span>: <span class="hljs-string">"MAAMA,IACJC,YAAaC"</span>,
-        <span class="hljs-attr">"sourceRoot"</span>: <span class="hljs-string">"./"</span>
-      },
-      <span class="hljs-attr">"lineLengths"</span>: [
-        <span class="hljs-number">13</span>,
-        <span class="hljs-number">62</span>,
-        <span class="hljs-number">38</span>,
+        <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"mappings"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"MAAMA,IACJC,YAAaC"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"sourceRoot"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./"</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"lineLengths"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+        <span class="hljs-number">13</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-number">62</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-number">38</span><span class="hljs-punctuation">,</span>
         <span class="hljs-number">27</span>
-      ]
-    }
-  }
-}</code></pre>
-<h3><code>OPENSSL_CONF=file</code><span><a class="mark" href="#cli_openssl_conf_file" id="cli_openssl_conf_file">#</a></span></h3>
+      <span class="hljs-punctuation">]</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h4><code>NO_COLOR=&#x3C;any></code><span><a class="mark" href="#cli_no_color_any" id="cli_no_color_any">#</a></span></h4>
+<p><a href="https://no-color.org"><code>NO_COLOR</code></a>  is an alias for <code>NODE_DISABLE_COLORS</code>. The value of the
+environment variable is arbitrary.</p>
+<h4><code>OPENSSL_CONF=file</code><span><a class="mark" href="#cli_openssl_conf_file" id="cli_openssl_conf_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.11.0</span>
 </div>
 <p>Load an OpenSSL configuration file on startup. Among other uses, this can be
 used to enable FIPS-compliant crypto if Node.js is built with <code>./configure --openssl-fips</code>.</p>
-<p>If the <a href="#cli_openssl_config_file"><code>--openssl-config</code></a> command line option is used, the environment
+<p>If the <a href="#cli_openssl_config_file"><code>--openssl-config</code></a> command-line option is used, the environment
 variable is ignored.</p>
-<h3><code>SSL_CERT_DIR=dir</code><span><a class="mark" href="#cli_ssl_cert_dir_dir" id="cli_ssl_cert_dir_dir">#</a></span></h3>
+<h4><code>SSL_CERT_DIR=dir</code><span><a class="mark" href="#cli_ssl_cert_dir_dir" id="cli_ssl_cert_dir_dir">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -1413,7 +1544,7 @@ containing trusted certificates.</p>
 <p>Be aware that unless the child environment is explicitly set, this environment
 variable will be inherited by any child processes, and if they use OpenSSL, it
 may cause them to trust the same CAs as node.</p>
-<h3><code>SSL_CERT_FILE=file</code><span><a class="mark" href="#cli_ssl_cert_file_file" id="cli_ssl_cert_file_file">#</a></span></h3>
+<h4><code>SSL_CERT_FILE=file</code><span><a class="mark" href="#cli_ssl_cert_file_file" id="cli_ssl_cert_file_file">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -1422,7 +1553,7 @@ containing trusted certificates.</p>
 <p>Be aware that unless the child environment is explicitly set, this environment
 variable will be inherited by any child processes, and if they use OpenSSL, it
 may cause them to trust the same CAs as node.</p>
-<h3><code>UV_THREADPOOL_SIZE=size</code><span><a class="mark" href="#cli_uv_threadpool_size_size" id="cli_uv_threadpool_size_size">#</a></span></h3>
+<h4><code>UV_THREADPOOL_SIZE=size</code><span><a class="mark" href="#cli_uv_threadpool_size_size" id="cli_uv_threadpool_size_size">#</a></span></h4>
 <p>Set the number of threads used in libuv's threadpool to <code>size</code> threads.</p>
 <p>Asynchronous system APIs are used by Node.js whenever possible, but where they
 do not exist, libuv's threadpool is used to create asynchronous node APIs based
@@ -1442,7 +1573,7 @@ mitigate this issue, one potential solution is to increase the size of libuv's
 threadpool by setting the <code>'UV_THREADPOOL_SIZE'</code> environment variable to a value
 greater than <code>4</code> (its current default value). For more information, see the
 <a href="https://docs.libuv.org/en/latest/threadpool.html">libuv threadpool documentation</a>.</p>
-<h2>Useful V8 options<span><a class="mark" href="#cli_useful_v8_options" id="cli_useful_v8_options">#</a></span></h2>
+</section><section><h3>Useful V8 options<span><a class="mark" href="#cli_useful_v8_options" id="cli_useful_v8_options">#</a></span></h3>
 <p>V8 has its own set of CLI options. Any V8 CLI option that is provided to <code>node</code>
 will be passed on to V8 to handle. V8's options have <em>no stability guarantee</em>.
 The V8 team themselves don't consider them to be part of their formal API,
@@ -1451,16 +1582,52 @@ covered by the Node.js stability guarantees. Many of the V8
 options are of interest only to V8 developers. Despite this, there is a small
 set of V8 options that are widely applicable to Node.js, and they are
 documented here:</p>
-<h3><code>--max-old-space-size=SIZE</code> (in megabytes)<span><a class="mark" href="#cli_max_old_space_size_size_in_megabytes" id="cli_max_old_space_size_size_in_megabytes">#</a></span></h3>
+<h4><code>--max-old-space-size=SIZE</code> (in megabytes)<span><a class="mark" href="#cli_max_old_space_size_size_in_megabytes" id="cli_max_old_space_size_size_in_megabytes">#</a></span></h4>
 <p>Sets the max memory size of V8's old memory section. As memory
 consumption approaches the limit, V8 will spend more time on
 garbage collection in an effort to free unused memory.</p>
 <p>On a machine with 2GB of memory, consider setting this to
 1536 (1.5GB) to leave some memory for other uses and avoid swapping.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --max-old-space-size=1536 index.js</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --max-old-space-size=1536 index.js</span></code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/cli.json b/doc/api/cli.json
index 3fd741eee833f2810a1955c02eb3a82015a337d9..84b944c37f4bdcb6a9b5e500c9cd997cd4593c65 100644
--- a/doc/api/cli.json
+++ b/doc/api/cli.json
@@ -4,8 +4,8 @@
   "introduced_in": "v5.9.1",
   "miscs": [
     {
-      "textRaw": "Command line options",
-      "name": "Command line options",
+      "textRaw": "Command-line options",
+      "name": "Command-line options",
       "introduced_in": "v5.9.1",
       "type": "misc",
       "desc": "<p>Node.js comes with a variety of CLI options. These options expose built-in\ndebugging, multiple ways to execute scripts, and other helpful runtime options.</p>\n<p>To view this documentation as a manual page in a terminal, run <code>man node</code>.</p>",
@@ -13,7 +13,7 @@
         {
           "textRaw": "Synopsis",
           "name": "synopsis",
-          "desc": "<p><code>node [options] [V8 options] [script.js | -e \"script\" | -] [--] [arguments]</code></p>\n<p><code>node inspect [script.js | -e \"script\" | &#x3C;host>:&#x3C;port>] …</code></p>\n<p><code>node --v8-options</code></p>\n<p>Execute without arguments to start the <a href=\"repl.html\">REPL</a>.</p>\n<p><em>For more info about <code>node inspect</code>, please see the <a href=\"debugger.html\">debugger</a> documentation.</em></p>",
+          "desc": "<p><code>node [options] [V8 options] [script.js | -e \"script\" | -] [--] [arguments]</code></p>\n<p><code>node inspect [script.js | -e \"script\" | &#x3C;host>:&#x3C;port>] …</code></p>\n<p><code>node --v8-options</code></p>\n<p>Execute without arguments to start the <a href=\"repl.html\">REPL</a>.</p>\n<p>For more info about <code>node inspect</code>, see the <a href=\"debugger.html\">debugger</a> documentation.</p>",
           "type": "misc",
           "displayName": "Synopsis"
         },
@@ -29,7 +29,7 @@
               }
             ]
           },
-          "desc": "<p>All options, including V8 options, allow words to be separated by both\ndashes (<code>-</code>) or underscores (<code>_</code>).</p>\n<p>For example, <code>--pending-deprecation</code> is equivalent to <code>--pending_deprecation</code>.</p>\n<p>If an option that takes a single value, for example <code>--max-http-header-size</code>,\nis passed more than once, then the last passed value will be used. Options\nfrom the command line take precedence over options passed through the\n<a href=\"#cli_node_options_options\"><code>NODE_OPTIONS</code></a> environment variable.</p>",
+          "desc": "<p>All options, including V8 options, allow words to be separated by both\ndashes (<code>-</code>) or underscores (<code>_</code>). For example, <code>--pending-deprecation</code> is\nequivalent to <code>--pending_deprecation</code>.</p>\n<p>If an option that takes a single value (such as <code>--max-http-header-size</code>) is\npassed more than once, then the last passed value is used. Options from the\ncommand line take precedence over options passed through the <a href=\"#cli_node_options_options\"><code>NODE_OPTIONS</code></a>\nenvironment variable.</p>",
           "modules": [
             {
               "textRaw": "`-`",
@@ -40,7 +40,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Alias for stdin. Analogous to the use of <code>-</code> in other command line utilities,\nmeaning that the script will be read from stdin, and the rest of the options\nare passed to that script.</p>",
+              "desc": "<p>Alias for stdin. Analogous to the use of <code>-</code> in other command-line utilities,\nmeaning that the script is read from stdin, and the rest of the options\nare passed to that script.</p>",
               "type": "module",
               "displayName": "`-`"
             },
@@ -53,7 +53,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Indicate the end of node options. Pass the rest of the arguments to the script.\nIf no script filename or eval/print script is supplied prior to this, then\nthe next argument will be used as a script filename.</p>",
+              "desc": "<p>Indicate the end of node options. Pass the rest of the arguments to the script.\nIf no script filename or eval/print script is supplied prior to this, then\nthe next argument is used as a script filename.</p>",
               "type": "module",
               "displayName": "`--`"
             },
@@ -84,19 +84,19 @@
               "displayName": "`--completion-bash`"
             },
             {
-              "textRaw": "`--conditions=condition`",
-              "name": "`--conditions=condition`",
+              "textRaw": "`-C=condition`, `--conditions=condition`",
+              "name": "`-c=condition`,_`--conditions=condition`",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.9.0"
                 ],
                 "changes": []
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Enable experimental support for custom conditional exports resolution\nconditions.</p>\n<p>Any number of custom string condition names are permitted.</p>\n<p>The default Node.js conditions of <code>\"node\"</code>, <code>\"default\"</code>, <code>\"import\"</code>, and\n<code>\"require\"</code> will always apply as defined.</p>",
+              "desc": "<p>Enable experimental support for custom <a href=\"packages.html#packages_conditional_exports\">conditional exports</a> resolution\nconditions.</p>\n<p>Any number of custom string condition names are permitted.</p>\n<p>The default Node.js conditions of <code>\"node\"</code>, <code>\"default\"</code>, <code>\"import\"</code>, and\n<code>\"require\"</code> will always apply as defined.</p>\n<p>For example, to run a module with \"development\" resolutions:</p>\n<pre><code class=\"language-console\">$ node -C=development app.js\n</code></pre>",
               "type": "module",
-              "displayName": "`--conditions=condition`"
+              "displayName": "`-C=condition`, `--conditions=condition`"
             },
             {
               "textRaw": "`--cpu-prof`",
@@ -109,7 +109,7 @@
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Starts the V8 CPU profiler on start up, and writes the CPU profile to disk\nbefore exit.</p>\n<p>If <code>--cpu-prof-dir</code> is not specified, the generated profile will be placed\nin the current working directory.</p>\n<p>If <code>--cpu-prof-name</code> is not specified, the generated profile will be\nnamed <code>CPU.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.cpuprofile</code>.</p>\n<pre><code class=\"language-console\">$ node --cpu-prof index.js\n$ ls *.cpuprofile\nCPU.20190409.202950.15293.0.0.cpuprofile\n</code></pre>",
+              "desc": "<p>Starts the V8 CPU profiler on start up, and writes the CPU profile to disk\nbefore exit.</p>\n<p>If <code>--cpu-prof-dir</code> is not specified, the generated profile is placed\nin the current working directory.</p>\n<p>If <code>--cpu-prof-name</code> is not specified, the generated profile is\nnamed <code>CPU.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.cpuprofile</code>.</p>\n<pre><code class=\"language-console\">$ node --cpu-prof index.js\n$ ls *.cpuprofile\nCPU.20190409.202950.15293.0.0.cpuprofile\n</code></pre>",
               "type": "module",
               "displayName": "`--cpu-prof`"
             },
@@ -124,7 +124,7 @@
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Specify the directory where the CPU profiles generated by <code>--cpu-prof</code> will\nbe placed.</p>\n<p>The default value is controlled by the\n<a href=\"#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command line option.</p>",
+              "desc": "<p>Specify the directory where the CPU profiles generated by <code>--cpu-prof</code> will\nbe placed.</p>\n<p>The default value is controlled by the\n<a href=\"#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command-line option.</p>",
               "type": "module",
               "displayName": "`--cpu-prof-dir`"
             },
@@ -161,14 +161,20 @@
             {
               "textRaw": "`--diagnostic-dir=directory`",
               "name": "`--diagnostic-dir=directory`",
-              "desc": "<p>Set the directory to which all diagnostic output files will be written to.\nDefaults to current working directory.</p>\n<p>Affects the default output directory of:</p>\n<ul>\n<li><a href=\"#cli_cpu_prof_dir\">--cpu-prof-dir</a></li>\n<li><a href=\"#cli_heap_prof_dir\">--heap-prof-dir</a></li>\n<li><a href=\"#cli_redirect_warnings_file\">--redirect-warnings</a></li>\n</ul>",
+              "desc": "<p>Set the directory to which all diagnostic output files are written.\nDefaults to current working directory.</p>\n<p>Affects the default output directory of:</p>\n<ul>\n<li><a href=\"#cli_cpu_prof_dir\">--cpu-prof-dir</a></li>\n<li><a href=\"#cli_heap_prof_dir\">--heap-prof-dir</a></li>\n<li><a href=\"#cli_redirect_warnings_file\">--redirect-warnings</a></li>\n</ul>",
               "type": "module",
               "displayName": "`--diagnostic-dir=directory`"
             },
             {
               "textRaw": "`--disable-proto=mode`",
               "name": "`--disable-proto=mode`",
-              "desc": "<!--YAML\nadded: v12.17.0\n-->\n<p>Disable the <code>Object.prototype.__proto__</code> property. If <code>mode</code> is <code>delete</code>, the\nproperty will be removed entirely. If <code>mode</code> is <code>throw</code>, accesses to the\nproperty will throw an exception with the code <code>ERR_PROTO_ACCESS</code>.</p>",
+              "meta": {
+                "added": [
+                  "v13.12.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Disable the <code>Object.prototype.__proto__</code> property. If <code>mode</code> is <code>delete</code>, the\nproperty is removed entirely. If <code>mode</code> is <code>throw</code>, accesses to the\nproperty throw an exception with the code <code>ERR_PROTO_ACCESS</code>.</p>",
               "type": "module",
               "displayName": "`--disable-proto=mode`"
             },
@@ -185,6 +191,19 @@
               "type": "module",
               "displayName": "`--disallow-code-generation-from-strings`"
             },
+            {
+              "textRaw": "`--dns-result-order=order`",
+              "name": "`--dns-result-order=order`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Set the default value of <code>verbatim</code> in <a href=\"dns.html#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> and\n<a href=\"dns.html#dns_dnspromises_lookup_hostname_options\"><code>dnsPromises.lookup()</code></a>. The value could be:</p>\n<ul>\n<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>\n<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>\n</ul>\n<p>The default is <code>ipv4first</code> and <a href=\"dns.html#dns_dns_setdefaultresultorder_order\"><code>dns.setDefaultResultOrder()</code></a> have higher\npriority than <code>--dns-result-order</code>.</p>",
+              "type": "module",
+              "displayName": "`--dns-result-order=order`"
+            },
             {
               "textRaw": "`--enable-fips`",
               "name": "`--enable-fips`",
@@ -205,19 +224,37 @@
                 "added": [
                   "v12.12.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37362",
+                    "description": "This API is no longer experimental."
+                  }
+                ]
               },
-              "stability": 1,
-              "stabilityText": "Experimental",
-              "desc": "<p>Enable experimental Source Map v3 support for stack traces.</p>\n<p>Currently, overriding <code>Error.prepareStackTrace</code> is ignored when the\n<code>--enable-source-maps</code> flag is set.</p>",
+              "desc": "<p>Enable <a href=\"https://sourcemaps.info/spec.html\">Source Map v3</a> support for stack traces.</p>\n<p>When using a transpiler, such as TypeScript, strack traces thrown by an\napplication reference the transpiled code, not the original source position.\n<code>--enable-source-maps</code> enables caching of Source Maps and makes a best\neffort to report stack traces relative to the original source file.</p>\n<p>Overriding <code>Error.prepareStackTrace</code> prevents <code>--enable-source-maps</code> from\nmodifiying the stack trace.</p>",
               "type": "module",
               "displayName": "`--enable-source-maps`"
             },
+            {
+              "textRaw": "`--experimental-abortcontroller`",
+              "name": "`--experimental-abortcontroller`",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Enable experimental <code>AbortController</code> and <code>AbortSignal</code> support.</p>",
+              "type": "module",
+              "displayName": "`--experimental-abortcontroller`"
+            },
             {
               "textRaw": "`--experimental-import-meta-resolve`",
               "name": "`--experimental-import-meta-resolve`",
               "meta": {
                 "added": [
+                  "v13.9.0",
                   "v12.16.2"
                 ],
                 "changes": []
@@ -248,7 +285,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Specify the <code>module</code> of a custom <a href=\"esm.html#esm_experimental_loaders\">experimental ECMAScript Module loader</a>.\n<code>module</code> may be either a path to a file, or an ECMAScript Module name.</p>",
+              "desc": "<p>Specify the <code>module</code> of a custom experimental <a href=\"esm.html#esm_loaders\">ECMAScript Module loader</a>.\n<code>module</code> may be either a path to a file, or an ECMAScript Module name.</p>",
               "type": "module",
               "displayName": "`--experimental-loader=module`"
             },
@@ -296,11 +333,12 @@
               "name": "`--experimental-specifier-resolution=mode`",
               "meta": {
                 "added": [
+                  "v13.4.0",
                   "v12.16.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>Sets the resolution algorithm for resolving ES module specifiers. Valid options\nare <code>explicit</code> and <code>node</code>.</p>\n<p>The default is <code>explicit</code>, which requires providing the full path to a\nmodule. The <code>node</code> mode will enable support for optional file extensions and\nthe ability to import a directory that has an index file.</p>\n<p>Please see <a href=\"esm.html#esm_customizing_esm_specifier_resolution_algorithm\">customizing ESM specifier resolution</a> for example usage.</p>",
+              "desc": "<p>Sets the resolution algorithm for resolving ES module specifiers. Valid options\nare <code>explicit</code> and <code>node</code>.</p>\n<p>The default is <code>explicit</code>, which requires providing the full path to a\nmodule. The <code>node</code> mode enables support for optional file extensions and\nthe ability to import a directory that has an index file.</p>\n<p>See <a href=\"esm.html#esm_customizing_esm_specifier_resolution_algorithm\">customizing ESM specifier resolution</a> for example usage.</p>",
               "type": "module",
               "displayName": "`--experimental-specifier-resolution=mode`"
             },
@@ -322,9 +360,16 @@
               "name": "`--experimental-wasi-unstable-preview1`",
               "meta": {
                 "added": [
+                  "v13.3.0",
                   "v12.16.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v13.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/30980",
+                    "description": "changed from `--experimental-wasi-unstable-preview0` to `--experimental-wasi-unstable-preview1`."
+                  }
+                ]
               },
               "desc": "<p>Enable experimental WebAssembly System Interface (WASI) support.</p>",
               "type": "module",
@@ -339,6 +384,7 @@
                 ],
                 "changes": []
               },
+              "desc": "<p>Enable experimental WebAssembly module support.</p>",
               "type": "module",
               "displayName": "`--experimental-wasm-modules`"
             },
@@ -351,7 +397,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Disable loading native addons that are not <a href=\"addons.html#addons_context_aware_addons\">context-aware</a>.</p>\n<p>Enable experimental WebAssembly module support.</p>",
+              "desc": "<p>Disable loading native addons that are not <a href=\"addons.html#addons_context_aware_addons\">context-aware</a>.</p>",
               "type": "module",
               "displayName": "`--force-context-aware`"
             },
@@ -383,6 +429,21 @@
               "type": "module",
               "displayName": "`--frozen-intrinsics`"
             },
+            {
+              "textRaw": "`--heapsnapshot-near-heap-limit=max_count`",
+              "name": "`--heapsnapshot-near-heap-limit=max_count`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "stability": 1,
+              "stabilityText": "Experimental",
+              "desc": "<p>Writes a V8 heap snapshot to disk when the V8 heap usage is approaching the\nheap limit. <code>count</code> should be a non-negative integer (in which case\nNode.js will write no more than <code>max_count</code> snapshots to disk).</p>\n<p>When generating snapshots, garbage collection may be triggered and bring\nthe heap usage down, therefore multiple snapshots may be written to disk\nbefore the Node.js instance finally runs out of memory. These heap snapshots\ncan be compared to determine what objects are being allocated during the\ntime consecutive snapshots are taken. It's not guaranteed that Node.js will\nwrite exactly <code>max_count</code> snapshots to disk, but it will try\nits best to generate at least one and up to <code>max_count</code> snapshots before the\nNode.js instance runs out of memory when <code>max_count</code> is greater than <code>0</code>.</p>\n<p>Generating V8 snapshots takes time and memory (both memory managed by the\nV8 heap and native memory outside the V8 heap). The bigger the heap is,\nthe more resources it needs. Node.js will adjust the V8 heap to accommondate\nthe additional V8 heap memory overhead, and try its best to avoid using up\nall the memory avialable to the process. When the process uses\nmore memory than the system deems appropriate, the process may be terminated\nabruptly by the system, depending on the system configuration.</p>\n<pre><code class=\"language-console\">$ node --max-old-space-size=100 --heapsnapshot-near-heap-limit=3 index.js\nWrote snapshot to Heap.20200430.100036.49580.0.001.heapsnapshot\nWrote snapshot to Heap.20200430.100037.49580.0.002.heapsnapshot\nWrote snapshot to Heap.20200430.100038.49580.0.003.heapsnapshot\n\n&#x3C;--- Last few GCs --->\n\n[49580:0x110000000]     4826 ms: Mark-sweep 130.6 (147.8) -> 130.5 (147.8) MB, 27.4 / 0.0 ms  (average mu = 0.126, current mu = 0.034) allocation failure scavenge might not succeed\n[49580:0x110000000]     4845 ms: Mark-sweep 130.6 (147.8) -> 130.6 (147.8) MB, 18.8 / 0.0 ms  (average mu = 0.088, current mu = 0.031) allocation failure scavenge might not succeed\n\n\n&#x3C;--- JS stacktrace --->\n\nFATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory\n....\n</code></pre>",
+              "type": "module",
+              "displayName": "`--heapsnapshot-near-heap-limit=max_count`"
+            },
             {
               "textRaw": "`--heapsnapshot-signal=signal`",
               "name": "`--heapsnapshot-signal=signal`",
@@ -407,7 +468,7 @@
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Starts the V8 heap profiler on start up, and writes the heap profile to disk\nbefore exit.</p>\n<p>If <code>--heap-prof-dir</code> is not specified, the generated profile will be placed\nin the current working directory.</p>\n<p>If <code>--heap-prof-name</code> is not specified, the generated profile will be\nnamed <code>Heap.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.heapprofile</code>.</p>\n<pre><code class=\"language-console\">$ node --heap-prof index.js\n$ ls *.heapprofile\nHeap.20190409.202950.15293.0.001.heapprofile\n</code></pre>",
+              "desc": "<p>Starts the V8 heap profiler on start up, and writes the heap profile to disk\nbefore exit.</p>\n<p>If <code>--heap-prof-dir</code> is not specified, the generated profile is placed\nin the current working directory.</p>\n<p>If <code>--heap-prof-name</code> is not specified, the generated profile is\nnamed <code>Heap.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.heapprofile</code>.</p>\n<pre><code class=\"language-console\">$ node --heap-prof index.js\n$ ls *.heapprofile\nHeap.20190409.202950.15293.0.001.heapprofile\n</code></pre>",
               "type": "module",
               "displayName": "`--heap-prof`"
             },
@@ -422,7 +483,7 @@
               },
               "stability": 1,
               "stabilityText": "Experimental",
-              "desc": "<p>Specify the directory where the heap profiles generated by <code>--heap-prof</code> will\nbe placed.</p>\n<p>The default value is controlled by the\n<a href=\"#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command line option.</p>",
+              "desc": "<p>Specify the directory where the heap profiles generated by <code>--heap-prof</code> will\nbe placed.</p>\n<p>The default value is controlled by the\n<a href=\"#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command-line option.</p>",
               "type": "module",
               "displayName": "`--heap-prof-dir`"
             },
@@ -456,38 +517,6 @@
               "type": "module",
               "displayName": "`--heap-prof-name`"
             },
-            {
-              "textRaw": "`--http-parser=library`",
-              "name": "`--http-parser=library`",
-              "meta": {
-                "added": [
-                  "v11.4.0"
-                ],
-                "changes": [
-                  {
-                    "version": "v12.22.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/37603",
-                    "description": "The legacy HTTP parser will emit a deprecation warning."
-                  }
-                ]
-              },
-              "desc": "<p>Chooses an HTTP parser library. Available values are:</p>\n<ul>\n<li><code>llhttp</code> for <a href=\"https://llhttp.org/\">https://llhttp.org/</a></li>\n<li><code>legacy</code> for <a href=\"https://github.com/nodejs/http-parser\">https://github.com/nodejs/http-parser</a></li>\n</ul>\n<p>The default is <code>llhttp</code>, unless otherwise specified when building Node.js.</p>\n<p>The <code>legacy</code> HTTP parser is deprecated and will emit a deprecation warning.</p>\n<p>This flag exists to aid in experimentation with the internal implementation of\nthe Node.js http parser.\nThis flag is likely to become a no-op and removed at some point in the future.</p>",
-              "type": "module",
-              "displayName": "`--http-parser=library`"
-            },
-            {
-              "textRaw": "`--http-server-default-timeout=milliseconds`",
-              "name": "`--http-server-default-timeout=milliseconds`",
-              "meta": {
-                "added": [
-                  "v12.4.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>Overrides the default value of <code>http</code>, <code>https</code> and <code>http2</code> server socket\ntimeout. Setting the value to 0 disables server socket timeout. Unless\nprovided, http server sockets timeout after 120s (2 minutes). Programmatic\nsetting of the timeout takes precedence over the value set through this\nflag.</p>",
-              "type": "module",
-              "displayName": "`--http-server-default-timeout=milliseconds`"
-            },
             {
               "textRaw": "`--icu-data-dir=file`",
               "name": "`--icu-data-dir=file`",
@@ -574,7 +603,9 @@
               "name": "`--insecure-http-parser`",
               "meta": {
                 "added": [
-                  "v12.15.0"
+                  "v13.4.0",
+                  "v12.15.0",
+                  "v10.19.0"
                 ],
                 "changes": []
               },
@@ -600,11 +631,18 @@
               "name": "`--max-http-header-size=size`",
               "meta": {
                 "added": [
-                  "v11.6.0"
+                  "v11.6.0",
+                  "v10.15.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32520",
+                    "description": "Change maximum default size of HTTP headers from 8KB to 16KB."
+                  }
+                ]
               },
-              "desc": "<p>Specify the maximum size, in bytes, of HTTP headers. Defaults to 8KB.</p>",
+              "desc": "<p>Specify the maximum size, in bytes, of HTTP headers. Defaults to 16KB.</p>",
               "type": "module",
               "displayName": "`--max-http-header-size=size`"
             },
@@ -660,6 +698,19 @@
               "type": "module",
               "displayName": "`--no-warnings`"
             },
+            {
+              "textRaw": "`--node-memory-debug`",
+              "name": "`--node-memory-debug`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Enable extra debug checks for memory leaks in Node.js internals. This is\nusually only useful for developers debugging Node.js itself.</p>",
+              "type": "module",
+              "displayName": "`--node-memory-debug`"
+            },
             {
               "textRaw": "`--openssl-config=file`",
               "name": "`--openssl-config=file`",
@@ -682,7 +733,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Emit pending deprecation warnings.</p>\n<p>Pending deprecations are generally identical to a runtime deprecation with the\nnotable exception that they are turned <em>off</em> by default and will not be emitted\nunless either the <code>--pending-deprecation</code> command line flag, or the\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations\nare used to provide a kind of selective \"early warning\" mechanism that\ndevelopers may leverage to detect deprecated API usage.</p>",
+              "desc": "<p>Emit pending deprecation warnings.</p>\n<p>Pending deprecations are generally identical to a runtime deprecation with the\nnotable exception that they are turned <em>off</em> by default and will not be emitted\nunless either the <code>--pending-deprecation</code> command-line flag, or the\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations\nare used to provide a kind of selective \"early warning\" mechanism that\ndevelopers may leverage to detect deprecated API usage.</p>",
               "type": "module",
               "displayName": "`--pending-deprecation`"
             },
@@ -710,7 +761,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Instructs the module loader to preserve symbolic links when resolving and\ncaching modules.</p>\n<p>By default, when Node.js loads a module from a path that is symbolically linked\nto a different on-disk location, Node.js will dereference the link and use the\nactual on-disk \"real path\" of the module as both an identifier and as a root\npath to locate other dependency modules. In most cases, this default behavior\nis acceptable. However, when using symbolically linked peer dependencies, as\nillustrated in the example below, the default behavior causes an exception to\nbe thrown if <code>moduleA</code> attempts to require <code>moduleB</code> as a peer dependency:</p>\n<pre><code class=\"language-text\">{appDir}\n ├── app\n │   ├── index.js\n │   └── node_modules\n │       ├── moduleA -> {appDir}/moduleA\n │       └── moduleB\n │           ├── index.js\n │           └── package.json\n └── moduleA\n     ├── index.js\n     └── package.json\n</code></pre>\n<p>The <code>--preserve-symlinks</code> command line flag instructs Node.js to use the\nsymlink path for modules as opposed to the real path, allowing symbolically\nlinked peer dependencies to be found.</p>\n<p>Note, however, that using <code>--preserve-symlinks</code> can have other side effects.\nSpecifically, symbolically linked <em>native</em> modules can fail to load if those\nare linked from more than one location in the dependency tree (Node.js would\nsee those as two separate modules and would attempt to load the module multiple\ntimes, causing an exception to be thrown).</p>\n<p>The <code>--preserve-symlinks</code> flag does not apply to the main module, which allows\n<code>node --preserve-symlinks node_module/.bin/&#x3C;foo></code> to work. To apply the same\nbehavior for the main module, also use <code>--preserve-symlinks-main</code>.</p>",
+              "desc": "<p>Instructs the module loader to preserve symbolic links when resolving and\ncaching modules.</p>\n<p>By default, when Node.js loads a module from a path that is symbolically linked\nto a different on-disk location, Node.js will dereference the link and use the\nactual on-disk \"real path\" of the module as both an identifier and as a root\npath to locate other dependency modules. In most cases, this default behavior\nis acceptable. However, when using symbolically linked peer dependencies, as\nillustrated in the example below, the default behavior causes an exception to\nbe thrown if <code>moduleA</code> attempts to require <code>moduleB</code> as a peer dependency:</p>\n<pre><code class=\"language-text\">{appDir}\n ├── app\n │   ├── index.js\n │   └── node_modules\n │       ├── moduleA -> {appDir}/moduleA\n │       └── moduleB\n │           ├── index.js\n │           └── package.json\n └── moduleA\n     ├── index.js\n     └── package.json\n</code></pre>\n<p>The <code>--preserve-symlinks</code> command-line flag instructs Node.js to use the\nsymlink path for modules as opposed to the real path, allowing symbolically\nlinked peer dependencies to be found.</p>\n<p>Note, however, that using <code>--preserve-symlinks</code> can have other side effects.\nSpecifically, symbolically linked <em>native</em> modules can fail to load if those\nare linked from more than one location in the dependency tree (Node.js would\nsee those as two separate modules and would attempt to load the module multiple\ntimes, causing an exception to be thrown).</p>\n<p>The <code>--preserve-symlinks</code> flag does not apply to the main module, which allows\n<code>node --preserve-symlinks node_module/.bin/&#x3C;foo></code> to work. To apply the same\nbehavior for the main module, also use <code>--preserve-symlinks-main</code>.</p>",
               "type": "module",
               "displayName": "`--preserve-symlinks`"
             },
@@ -723,7 +774,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Instructs the module loader to preserve symbolic links when resolving and\ncaching the main module (<code>require.main</code>).</p>\n<p>This flag exists so that the main module can be opted-in to the same behavior\nthat <code>--preserve-symlinks</code> gives to all other imports; they are separate flags,\nhowever, for backward compatibility with older Node.js versions.</p>\n<p><code>--preserve-symlinks-main</code> does not imply <code>--preserve-symlinks</code>; it\nis expected that <code>--preserve-symlinks-main</code> will be used in addition to\n<code>--preserve-symlinks</code> when it is not desirable to follow symlinks before\nresolving relative paths.</p>\n<p>See <code>--preserve-symlinks</code> for more information.</p>",
+              "desc": "<p>Instructs the module loader to preserve symbolic links when resolving and\ncaching the main module (<code>require.main</code>).</p>\n<p>This flag exists so that the main module can be opted-in to the same behavior\nthat <code>--preserve-symlinks</code> gives to all other imports; they are separate flags,\nhowever, for backward compatibility with older Node.js versions.</p>\n<p><code>--preserve-symlinks-main</code> does not imply <code>--preserve-symlinks</code>; use\n<code>--preserve-symlinks-main</code> in addition to\n<code>--preserve-symlinks</code> when it is not desirable to follow symlinks before\nresolving relative paths.</p>\n<p>See <code>--preserve-symlinks</code> for more information.</p>",
               "type": "module",
               "displayName": "`--preserve-symlinks-main`"
             },
@@ -762,7 +813,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Write process warnings to the given file instead of printing to stderr. The\nfile will be created if it does not exist, and will be appended to if it does.\nIf an error occurs while attempting to write the warning to the file, the\nwarning will be written to stderr instead.</p>\n<p>The <code>file</code> name may be an absolute path. If it is not, the default directory it\nwill be written to is controlled by the\n<a href=\"#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command line option.</p>",
+              "desc": "<p>Write process warnings to the given file instead of printing to stderr. The\nfile will be created if it does not exist, and will be appended to if it does.\nIf an error occurs while attempting to write the warning to the file, the\nwarning will be written to stderr instead.</p>\n<p>The <code>file</code> name may be an absolute path. If it is not, the default directory it\nwill be written to is controlled by the\n<a href=\"#cli_diagnostic_dir_directory\">--diagnostic-dir</a> command-line option.</p>",
               "type": "module",
               "displayName": "`--redirect-warnings=file`"
             },
@@ -771,7 +822,7 @@
               "name": "`--report-compact`",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.12.0"
                 ],
                 "changes": []
               },
@@ -788,14 +839,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "Changed from `--diagnostic-report-directory` to `--report-directory`"
+                    "description": "Changed from `--diagnostic-report-directory` to `--report-directory`."
                   }
                 ]
               },
@@ -812,14 +863,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-filename` to `--report-filename`"
+                    "description": "changed from `--diagnostic-report-filename` to `--report-filename`."
                   }
                 ]
               },
@@ -836,14 +887,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v14.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32496",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-on-fatalerror` to `--report-on-fatalerror`"
+                    "description": "changed from `--diagnostic-report-on-fatalerror` to `--report-on-fatalerror`."
                   }
                 ]
               },
@@ -860,14 +911,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-on-signal` to `--report-on-signal`"
+                    "description": "changed from `--diagnostic-report-on-signal` to `--report-on-signal`."
                   }
                 ]
               },
@@ -884,14 +935,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-signal` to `--report-signal`"
+                    "description": "changed from `--diagnostic-report-signal` to `--report-signal`."
                   }
                 ]
               },
@@ -908,14 +959,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This option is no longer experimental."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27312",
-                    "description": "changed from `--diagnostic-report-uncaught-exception` to `--report-uncaught-exception`"
+                    "description": "changed from `--diagnostic-report-uncaught-exception` to `--report-uncaught-exception`."
                   }
                 ]
               },
@@ -967,6 +1018,7 @@
               "name": "`--tls-keylog=file`",
               "meta": {
                 "added": [
+                  "v13.2.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -980,7 +1032,8 @@
               "name": "`--tls-max-v1.2`",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -1006,7 +1059,8 @@
               "name": "`--tls-min-v1.0`",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -1019,7 +1073,8 @@
               "name": "`--tls-min-v1.1`",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -1032,7 +1087,8 @@
               "name": "`--tls-min-v1.2`",
               "meta": {
                 "added": [
-                  "v12.2.0"
+                  "v12.2.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -1053,6 +1109,19 @@
               "type": "module",
               "displayName": "`--tls-min-v1.3`"
             },
+            {
+              "textRaw": "`--trace-atomics-wait`",
+              "name": "`--trace-atomics-wait`",
+              "meta": {
+                "added": [
+                  "v14.3.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Print short summaries of calls to <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait\"><code>Atomics.wait()</code></a> to stderr.\nThe output could look like this:</p>\n<pre><code class=\"language-text\">(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 1, inf) started\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 1, inf) did not wait because the values mismatched\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 0, 10) started\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 0, 0, 10) timed out\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 4, 0, inf) started\n(node:15701) [Thread 1] Atomics.wait(&#x26;lt;address> + 4, -1, inf) started\n(node:15701) [Thread 0] Atomics.wait(&#x26;lt;address> + 4, 0, inf) was woken up by another thread\n(node:15701) [Thread 1] Atomics.wait(&#x26;lt;address> + 4, -1, inf) was woken up by another thread\n</code></pre>\n<p>The fields here correspond to:</p>\n<ul>\n<li>The thread id as given by <a href=\"worker_threads.html#worker_threads_worker_threadid\"><code>worker_threads.threadId</code></a></li>\n<li>The base address of the <code>SharedArrayBuffer</code> in question, as well as the\nbyte offset corresponding to the index passed to <code>Atomics.wait()</code></li>\n<li>The expected value that was passed to <code>Atomics.wait()</code></li>\n<li>The timeout passed to <code>Atomics.wait</code></li>\n</ul>",
+              "type": "module",
+              "displayName": "`--trace-atomics-wait`"
+            },
             {
               "textRaw": "`--trace-deprecation`",
               "name": "`--trace-deprecation`",
@@ -1110,6 +1179,7 @@
               "name": "`--trace-exit`",
               "meta": {
                 "added": [
+                  "v13.5.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -1123,7 +1193,7 @@
               "name": "`--trace-sigint`",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.9.0"
                 ],
                 "changes": []
               },
@@ -1162,7 +1232,7 @@
               "name": "`--trace-uncaught`",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.1.0"
                 ],
                 "changes": []
               },
@@ -1201,11 +1271,12 @@
               "name": "`--unhandled-rejections=mode`",
               "meta": {
                 "added": [
-                  "v12.0.0"
+                  "v12.0.0",
+                  "v10.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>By default all unhandled rejections trigger a warning plus a deprecation warning\nfor the very first unhandled rejection in case no <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a> hook\nis used.</p>\n<p>Using this flag allows to change what should happen when an unhandled rejection\noccurs. One of three modes can be chosen:</p>\n<ul>\n<li><code>strict</code>: Raise the unhandled rejection as an uncaught exception.</li>\n<li><code>warn</code>: Always trigger a warning, no matter if the <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a>\nhook is set or not but do not print the deprecation warning.</li>\n<li><code>none</code>: Silence all warnings.</li>\n</ul>",
+              "desc": "<p>By default all unhandled rejections trigger a warning plus a deprecation warning\nfor the very first unhandled rejection in case no <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a> hook\nis used.</p>\n<p>Using this flag allows to change what should happen when an unhandled rejection\noccurs. One of the following modes can be chosen:</p>\n<ul>\n<li><code>throw</code>: Emit <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a>. If this hook is not set, raise the\nunhandled rejection as an uncaught exception.</li>\n<li><code>strict</code>: Raise the unhandled rejection as an uncaught exception.</li>\n<li><code>warn</code>: Always trigger a warning, no matter if the <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a>\nhook is set or not but do not print the deprecation warning.</li>\n<li><code>warn-with-error-code</code>: Emit <a href=\"process.html#process_event_unhandledrejection\"><code>unhandledRejection</code></a>. If this hook is not\nset, trigger a warning, and set the process exit code to 1.</li>\n<li><code>none</code>: Silence all warnings.</li>\n</ul>",
               "type": "module",
               "displayName": "`--unhandled-rejections=mode`"
             },
@@ -1227,7 +1298,7 @@
               "name": "`--use-largepages=mode`",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.6.0"
                 ],
                 "changes": []
               },
@@ -1244,7 +1315,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Print V8 command line options.</p>",
+              "desc": "<p>Print V8 command-line options.</p>",
               "type": "module",
               "displayName": "`--v8-options`"
             },
@@ -1322,7 +1393,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Print node command line options.\nThe output of this option is less detailed than this document.</p>",
+              "desc": "<p>Print node command-line options.\nThe output of this option is less detailed than this document.</p>",
               "type": "module",
               "displayName": "`-h`, `--help`"
             },
@@ -1367,7 +1438,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Preload the specified module at startup.</p>\n<p>Follows <code>require()</code>'s module resolution\nrules. <code>module</code> may be either a path to a file, or a node module name.</p>",
+              "desc": "<p>Preload the specified module at startup.</p>\n<p>Follows <code>require()</code>'s module resolution\nrules. <code>module</code> may be either a path to a file, or a node module name.</p>\n<p>Only CommonJS modules are supported. Attempting to preload a\nES6 Module using <code>--require</code> will fail with an error.</p>",
               "type": "module",
               "displayName": "`-r`, `--require module`"
             },
@@ -1392,6 +1463,13 @@
           "textRaw": "Environment variables",
           "name": "environment_variables",
           "modules": [
+            {
+              "textRaw": "`FORCE_COLOR=[1, 2, 3]`",
+              "name": "`force_color=[1,_2,_3]`",
+              "desc": "<p>The <code>FORCE_COLOR</code> environment variable is used to\nenable ANSI colorized output. The value may be:</p>\n<ul>\n<li><code>1</code>, <code>true</code>, or the empty string <code>''</code> indicate 16-color support,</li>\n<li><code>2</code> to indicate 256-color support, or</li>\n<li><code>3</code> to indicate 16 million-color support.</li>\n</ul>\n<p>When <code>FORCE_COLOR</code> is used and set to a supported value, both the <code>NO_COLOR</code>,\nand <code>NODE_DISABLE_COLORS</code> environment variables are ignored.</p>\n<p>Any other value will result in colorized output being disabled.</p>",
+              "type": "module",
+              "displayName": "`FORCE_COLOR=[1, 2, 3]`"
+            },
             {
               "textRaw": "`NODE_DEBUG=module[,…]`",
               "name": "`node_debug=module[,…]`",
@@ -1434,7 +1512,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>When set, the well known \"root\" CAs (like VeriSign) will be extended with the\nextra certificates in <code>file</code>. The file should consist of one or more trusted\ncertificates in PEM format. A message will be emitted (once) with\n<a href=\"process.html#process_process_emitwarning_warning_type_code_ctor\"><code>process.emitWarning()</code></a> if the file is missing or\nmalformed, but any errors are otherwise ignored.</p>\n<p>Neither the well known nor extra certificates are used when the <code>ca</code>\noptions property is explicitly specified for a TLS or HTTPS client or server.</p>\n<p>This environment variable is ignored when <code>node</code> runs as setuid root or\nhas Linux file capabilities set.</p>",
+              "desc": "<p>When set, the well known \"root\" CAs (like VeriSign) will be extended with the\nextra certificates in <code>file</code>. The file should consist of one or more trusted\ncertificates in PEM format. A message will be emitted (once) with\n<a href=\"process.html#process_process_emitwarning_warning_type_code_ctor\"><code>process.emitWarning()</code></a> if the file is missing or\nmalformed, but any errors are otherwise ignored.</p>\n<p>Neither the well known nor extra certificates are used when the <code>ca</code>\noptions property is explicitly specified for a TLS or HTTPS client or server.</p>\n<p>This environment variable is ignored when <code>node</code> runs as setuid root or\nhas Linux file capabilities set.</p>\n<p>The <code>NODE_EXTRA_CA_CERTS</code> environment variable is only read when the Node.js\nprocess is first launched. Changing the value at runtime using\n<code>process.env.NODE_EXTRA_CA_CERTS</code> has no effect on the current process.</p>",
               "type": "module",
               "displayName": "`NODE_EXTRA_CA_CERTS=file`"
             },
@@ -1473,7 +1551,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A space-separated list of command line options. <code>options...</code> are interpreted\nbefore command line options, so command line options will override or\ncompound after anything in <code>options...</code>. Node.js will exit with an error if\nan option that is not allowed in the environment is used, such as <code>-p</code> or a\nscript file.</p>\n<p>In case an option value happens to contain a space (for example a path listed\nin <code>--require</code>), it must be escaped using double quotes. For example:</p>\n<pre><code class=\"language-bash\">NODE_OPTIONS='--require \"./my path/file.js\"'\n</code></pre>\n<p>A singleton flag passed as a command line option will override the same flag\npassed into <code>NODE_OPTIONS</code>:</p>\n<pre><code class=\"language-bash\"># The inspector will be available on port 5555\nNODE_OPTIONS='--inspect=localhost:4444' node --inspect=localhost:5555\n</code></pre>\n<p>A flag that can be passed multiple times will be treated as if its\n<code>NODE_OPTIONS</code> instances were passed first, and then its command line\ninstances afterwards:</p>\n<pre><code class=\"language-bash\">NODE_OPTIONS='--require \"./a.js\"' node --require \"./b.js\"\n# is equivalent to:\nnode --require \"./a.js\" --require \"./b.js\"\n</code></pre>\n<p>Node.js options that are allowed are:</p>\n<!-- node-options-node start -->\n<ul>\n<li><code>--conditions</code></li>\n<li><code>--diagnostic-dir</code></li>\n<li><code>--disable-proto</code></li>\n<li><code>--enable-fips</code></li>\n<li><code>--enable-source-maps</code></li>\n<li><code>--experimental-import-meta-resolve</code></li>\n<li><code>--experimental-json-modules</code></li>\n<li><code>--experimental-loader</code></li>\n<li><code>--experimental-modules</code></li>\n<li><code>--experimental-policy</code></li>\n<li><code>--experimental-repl-await</code></li>\n<li><code>--experimental-specifier-resolution</code></li>\n<li><code>--experimental-vm-modules</code></li>\n<li><code>--experimental-wasi-unstable-preview1</code></li>\n<li><code>--experimental-wasm-modules</code></li>\n<li><code>--force-context-aware</code></li>\n<li><code>--force-fips</code></li>\n<li><code>--frozen-intrinsics</code></li>\n<li><code>--heapsnapshot-signal</code></li>\n<li><code>--http-parser</code></li>\n<li><code>--http-server-default-timeout</code></li>\n<li><code>--icu-data-dir</code></li>\n<li><code>--input-type</code></li>\n<li><code>--insecure-http-parser</code></li>\n<li><code>--inspect-brk</code></li>\n<li><code>--inspect-port</code>, <code>--debug-port</code></li>\n<li><code>--inspect-publish-uid</code></li>\n<li><code>--inspect</code></li>\n<li><code>--max-http-header-size</code></li>\n<li><code>--napi-modules</code></li>\n<li><code>--no-deprecation</code></li>\n<li><code>--no-force-async-hooks-checks</code></li>\n<li><code>--no-warnings</code></li>\n<li><code>--openssl-config</code></li>\n<li><code>--pending-deprecation</code></li>\n<li><code>--policy-integrity</code></li>\n<li><code>--preserve-symlinks-main</code></li>\n<li><code>--preserve-symlinks</code></li>\n<li><code>--prof-process</code></li>\n<li><code>--redirect-warnings</code></li>\n<li><code>--report-compact</code></li>\n<li><code>--report-dir</code>, <code>--report-directory</code></li>\n<li><code>--report-filename</code></li>\n<li><code>--report-on-fatalerror</code></li>\n<li><code>--report-on-signal</code></li>\n<li><code>--report-signal</code></li>\n<li><code>--report-uncaught-exception</code></li>\n<li><code>--require</code>, <code>-r</code></li>\n<li><code>--throw-deprecation</code></li>\n<li><code>--title</code></li>\n<li><code>--tls-cipher-list</code></li>\n<li><code>--tls-keylog</code></li>\n<li><code>--tls-max-v1.2</code></li>\n<li><code>--tls-max-v1.3</code></li>\n<li><code>--tls-min-v1.0</code></li>\n<li><code>--tls-min-v1.1</code></li>\n<li><code>--tls-min-v1.2</code></li>\n<li><code>--tls-min-v1.3</code></li>\n<li><code>--trace-deprecation</code></li>\n<li><code>--trace-event-categories</code></li>\n<li><code>--trace-event-file-pattern</code></li>\n<li><code>--trace-events-enabled</code></li>\n<li><code>--trace-exit</code></li>\n<li><code>--trace-sigint</code></li>\n<li><code>--trace-sync-io</code></li>\n<li><code>--trace-tls</code></li>\n<li><code>--trace-uncaught</code></li>\n<li><code>--trace-warnings</code></li>\n<li><code>--track-heap-objects</code></li>\n<li><code>--unhandled-rejections</code></li>\n<li><code>--use-bundled-ca</code></li>\n<li><code>--use-largepages</code></li>\n<li><code>--use-openssl-ca</code></li>\n<li><code>--v8-pool-size</code></li>\n<li><code>--zero-fill-buffers</code>\n<!-- node-options-node end -->\n</li>\n</ul>\n<p>V8 options that are allowed are:</p>\n<!-- node-options-v8 start -->\n<ul>\n<li><code>--abort-on-uncaught-exception</code></li>\n<li><code>--disallow-code-generation-from-strings</code></li>\n<li><code>--huge-max-old-generation-size</code></li>\n<li><code>--interpreted-frames-native-stack</code></li>\n<li><code>--jitless</code></li>\n<li><code>--max-old-space-size</code></li>\n<li><code>--perf-basic-prof-only-functions</code></li>\n<li><code>--perf-basic-prof</code></li>\n<li><code>--perf-prof-unwinding-info</code></li>\n<li><code>--perf-prof</code></li>\n<li><code>--stack-trace-limit</code>\n<!-- node-options-v8 end -->\n</li>\n</ul>\n<p><code>--perf-basic-prof-only-functions</code>, <code>--perf-basic-prof</code>,\n<code>--perf-prof-unwinding-info</code>, and <code>--perf-prof</code> are only available on Linux.</p>",
+              "desc": "<p>A space-separated list of command-line options. <code>options...</code> are interpreted\nbefore command-line options, so command-line options will override or\ncompound after anything in <code>options...</code>. Node.js will exit with an error if\nan option that is not allowed in the environment is used, such as <code>-p</code> or a\nscript file.</p>\n<p>If an option value contains a space, it can be escaped using double quotes:</p>\n<pre><code class=\"language-bash\">NODE_OPTIONS='--require \"./my path/file.js\"'\n</code></pre>\n<p>A singleton flag passed as a command-line option will override the same flag\npassed into <code>NODE_OPTIONS</code>:</p>\n<pre><code class=\"language-bash\"># The inspector will be available on port 5555\nNODE_OPTIONS='--inspect=localhost:4444' node --inspect=localhost:5555\n</code></pre>\n<p>A flag that can be passed multiple times will be treated as if its\n<code>NODE_OPTIONS</code> instances were passed first, and then its command-line\ninstances afterwards:</p>\n<pre><code class=\"language-bash\">NODE_OPTIONS='--require \"./a.js\"' node --require \"./b.js\"\n# is equivalent to:\nnode --require \"./a.js\" --require \"./b.js\"\n</code></pre>\n<p>Node.js options that are allowed are:</p>\n<!-- node-options-node start -->\n<ul>\n<li><code>--conditions</code>, <code>-C</code></li>\n<li><code>--diagnostic-dir</code></li>\n<li><code>--disable-proto</code></li>\n<li><code>--dns-result-order</code></li>\n<li><code>--enable-fips</code></li>\n<li><code>--enable-source-maps</code></li>\n<li><code>--experimental-abortcontroller</code></li>\n<li><code>--experimental-import-meta-resolve</code></li>\n<li><code>--experimental-json-modules</code></li>\n<li><code>--experimental-loader</code></li>\n<li><code>--experimental-modules</code></li>\n<li><code>--experimental-policy</code></li>\n<li><code>--experimental-repl-await</code></li>\n<li><code>--experimental-specifier-resolution</code></li>\n<li><code>--experimental-top-level-await</code></li>\n<li><code>--experimental-vm-modules</code></li>\n<li><code>--experimental-wasi-unstable-preview1</code></li>\n<li><code>--experimental-wasm-modules</code></li>\n<li><code>--force-context-aware</code></li>\n<li><code>--force-fips</code></li>\n<li><code>--frozen-intrinsics</code></li>\n<li><code>--heapsnapshot-near-heap-limit</code></li>\n<li><code>--heapsnapshot-signal</code></li>\n<li><code>--http-parser</code></li>\n<li><code>--icu-data-dir</code></li>\n<li><code>--input-type</code></li>\n<li><code>--insecure-http-parser</code></li>\n<li><code>--inspect-brk</code></li>\n<li><code>--inspect-port</code>, <code>--debug-port</code></li>\n<li><code>--inspect-publish-uid</code></li>\n<li><code>--inspect</code></li>\n<li><code>--max-http-header-size</code></li>\n<li><code>--napi-modules</code></li>\n<li><code>--no-deprecation</code></li>\n<li><code>--no-force-async-hooks-checks</code></li>\n<li><code>--no-warnings</code></li>\n<li><code>--node-memory-debug</code></li>\n<li><code>--openssl-config</code></li>\n<li><code>--pending-deprecation</code></li>\n<li><code>--policy-integrity</code></li>\n<li><code>--preserve-symlinks-main</code></li>\n<li><code>--preserve-symlinks</code></li>\n<li><code>--prof-process</code></li>\n<li><code>--redirect-warnings</code></li>\n<li><code>--report-compact</code></li>\n<li><code>--report-dir</code>, <code>--report-directory</code></li>\n<li><code>--report-filename</code></li>\n<li><code>--report-on-fatalerror</code></li>\n<li><code>--report-on-signal</code></li>\n<li><code>--report-signal</code></li>\n<li><code>--report-uncaught-exception</code></li>\n<li><code>--require</code>, <code>-r</code></li>\n<li><code>--throw-deprecation</code></li>\n<li><code>--title</code></li>\n<li><code>--tls-cipher-list</code></li>\n<li><code>--tls-keylog</code></li>\n<li><code>--tls-max-v1.2</code></li>\n<li><code>--tls-max-v1.3</code></li>\n<li><code>--tls-min-v1.0</code></li>\n<li><code>--tls-min-v1.1</code></li>\n<li><code>--tls-min-v1.2</code></li>\n<li><code>--tls-min-v1.3</code></li>\n<li><code>--trace-atomics-wait</code></li>\n<li><code>--trace-deprecation</code></li>\n<li><code>--trace-event-categories</code></li>\n<li><code>--trace-event-file-pattern</code></li>\n<li><code>--trace-events-enabled</code></li>\n<li><code>--trace-exit</code></li>\n<li><code>--trace-sigint</code></li>\n<li><code>--trace-sync-io</code></li>\n<li><code>--trace-tls</code></li>\n<li><code>--trace-uncaught</code></li>\n<li><code>--trace-warnings</code></li>\n<li><code>--track-heap-objects</code></li>\n<li><code>--unhandled-rejections</code></li>\n<li><code>--use-bundled-ca</code></li>\n<li><code>--use-largepages</code></li>\n<li><code>--use-openssl-ca</code></li>\n<li><code>--v8-pool-size</code></li>\n<li><code>--zero-fill-buffers</code></li>\n</ul>\n<!-- node-options-node end -->\n<p>V8 options that are allowed are:</p>\n<!-- node-options-v8 start -->\n<ul>\n<li><code>--abort-on-uncaught-exception</code></li>\n<li><code>--disallow-code-generation-from-strings</code></li>\n<li><code>--huge-max-old-generation-size</code></li>\n<li><code>--interpreted-frames-native-stack</code></li>\n<li><code>--jitless</code></li>\n<li><code>--max-old-space-size</code></li>\n<li><code>--perf-basic-prof-only-functions</code></li>\n<li><code>--perf-basic-prof</code></li>\n<li><code>--perf-prof-unwinding-info</code></li>\n<li><code>--perf-prof</code></li>\n<li><code>--stack-trace-limit</code></li>\n</ul>\n<!-- node-options-v8 end -->\n<p><code>--perf-basic-prof-only-functions</code>, <code>--perf-basic-prof</code>,\n<code>--perf-prof-unwinding-info</code>, and <code>--perf-prof</code> are only available on Linux.</p>",
               "type": "module",
               "displayName": "`NODE_OPTIONS=options...`"
             },
@@ -1499,7 +1577,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>When set to <code>1</code>, emit pending deprecation warnings.</p>\n<p>Pending deprecations are generally identical to a runtime deprecation with the\nnotable exception that they are turned <em>off</em> by default and will not be emitted\nunless either the <code>--pending-deprecation</code> command line flag, or the\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations\nare used to provide a kind of selective \"early warning\" mechanism that\ndevelopers may leverage to detect deprecated API usage.</p>",
+              "desc": "<p>When set to <code>1</code>, emit pending deprecation warnings.</p>\n<p>Pending deprecations are generally identical to a runtime deprecation with the\nnotable exception that they are turned <em>off</em> by default and will not be emitted\nunless either the <code>--pending-deprecation</code> command-line flag, or the\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable, is set. Pending deprecations\nare used to provide a kind of selective \"early warning\" mechanism that\ndevelopers may leverage to detect deprecated API usage.</p>",
               "type": "module",
               "displayName": "`NODE_PENDING_DEPRECATION=1`"
             },
@@ -1554,6 +1632,7 @@
               "name": "`node_repl_external_module=file`",
               "meta": {
                 "added": [
+                  "v13.0.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -1562,6 +1641,19 @@
               "type": "module",
               "displayName": "`NODE_REPL_EXTERNAL_MODULE=file`"
             },
+            {
+              "textRaw": "`NODE_SKIP_PLATFORM_CHECK=value`",
+              "name": "`node_skip_platform_check=value`",
+              "meta": {
+                "added": [
+                  "v14.5.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>If <code>value</code> equals <code>'1'</code>, the check for a supported platform is skipped during\nNode.js startup. Node.js might not execute correctly. Any issues encountered\non unsupported platforms will not be fixed.</p>",
+              "type": "module",
+              "displayName": "`NODE_SKIP_PLATFORM_CHECK=value`"
+            },
             {
               "textRaw": "`NODE_TLS_REJECT_UNAUTHORIZED=value`",
               "name": "`node_tls_reject_unauthorized=value`",
@@ -1594,6 +1686,13 @@
               "type": "module",
               "displayName": "`NODE_V8_COVERAGE=dir`"
             },
+            {
+              "textRaw": "`NO_COLOR=<any>`",
+              "name": "`no_color=<any>`",
+              "desc": "<p><a href=\"https://no-color.org\"><code>NO_COLOR</code></a>  is an alias for <code>NODE_DISABLE_COLORS</code>. The value of the\nenvironment variable is arbitrary.</p>",
+              "type": "module",
+              "displayName": "`NO_COLOR=<any>`"
+            },
             {
               "textRaw": "`OPENSSL_CONF=file`",
               "name": "`openssl_conf=file`",
@@ -1603,7 +1702,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Load an OpenSSL configuration file on startup. Among other uses, this can be\nused to enable FIPS-compliant crypto if Node.js is built with <code>./configure --openssl-fips</code>.</p>\n<p>If the <a href=\"#cli_openssl_config_file\"><code>--openssl-config</code></a> command line option is used, the environment\nvariable is ignored.</p>",
+              "desc": "<p>Load an OpenSSL configuration file on startup. Among other uses, this can be\nused to enable FIPS-compliant crypto if Node.js is built with <code>./configure --openssl-fips</code>.</p>\n<p>If the <a href=\"#cli_openssl_config_file\"><code>--openssl-config</code></a> command-line option is used, the environment\nvariable is ignored.</p>",
               "type": "module",
               "displayName": "`OPENSSL_CONF=file`"
             },
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 86635f267b383d1287140c6eed618d9b5607e89d..3f3e5e4eeb72c874ebde90af19b353170f48caeb 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1,4 +1,4 @@
-# Command line options
+# Command-line options
 
 <!--introduced_in=v5.9.1-->
 <!--type=misc-->
@@ -18,7 +18,7 @@ To view this documentation as a manual page in a terminal, run `man node`.
 
 Execute without arguments to start the [REPL][].
 
-_For more info about `node inspect`, please see the [debugger][] documentation._
+For more info about `node inspect`, see the [debugger][] documentation.
 
 ## Options
 <!-- YAML
@@ -30,22 +30,21 @@ changes:
 -->
 
 All options, including V8 options, allow words to be separated by both
-dashes (`-`) or underscores (`_`).
+dashes (`-`) or underscores (`_`). For example, `--pending-deprecation` is
+equivalent to `--pending_deprecation`.
 
-For example, `--pending-deprecation` is equivalent to `--pending_deprecation`.
-
-If an option that takes a single value, for example `--max-http-header-size`,
-is passed more than once, then the last passed value will be used. Options
-from the command line take precedence over options passed through the
-[`NODE_OPTIONS`][] environment variable.
+If an option that takes a single value (such as `--max-http-header-size`) is
+passed more than once, then the last passed value is used. Options from the
+command line take precedence over options passed through the [`NODE_OPTIONS`][]
+environment variable.
 
 ### `-`
 <!-- YAML
 added: v8.0.0
 -->
 
-Alias for stdin. Analogous to the use of `-` in other command line utilities,
-meaning that the script will be read from stdin, and the rest of the options
+Alias for stdin. Analogous to the use of `-` in other command-line utilities,
+meaning that the script is read from stdin, and the rest of the options
 are passed to that script.
 
 ### `--`
@@ -55,7 +54,7 @@ added: v6.11.0
 
 Indicate the end of node options. Pass the rest of the arguments to the script.
 If no script filename or eval/print script is supplied prior to this, then
-the next argument will be used as a script filename.
+the next argument is used as a script filename.
 
 ### `--abort-on-uncaught-exception`
 <!-- YAML
@@ -81,14 +80,14 @@ $ node --completion-bash > node_bash_completion
 $ source node_bash_completion
 ```
 
-### `--conditions=condition`
+### `-C=condition`, `--conditions=condition`
 <!-- YAML
-added: v12.19.0
+added: v14.9.0
 -->
 
 > Stability: 1 - Experimental
 
-Enable experimental support for custom conditional exports resolution
+Enable experimental support for custom [conditional exports][] resolution
 conditions.
 
 Any number of custom string condition names are permitted.
@@ -96,6 +95,12 @@ Any number of custom string condition names are permitted.
 The default Node.js conditions of `"node"`, `"default"`, `"import"`, and
 `"require"` will always apply as defined.
 
+For example, to run a module with "development" resolutions:
+
+```console
+$ node -C=development app.js
+```
+
 ### `--cpu-prof`
 <!-- YAML
 added: v12.0.0
@@ -106,10 +111,10 @@ added: v12.0.0
 Starts the V8 CPU profiler on start up, and writes the CPU profile to disk
 before exit.
 
-If `--cpu-prof-dir` is not specified, the generated profile will be placed
+If `--cpu-prof-dir` is not specified, the generated profile is placed
 in the current working directory.
 
-If `--cpu-prof-name` is not specified, the generated profile will be
+If `--cpu-prof-name` is not specified, the generated profile is
 named `CPU.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.cpuprofile`.
 
 ```console
@@ -129,7 +134,7 @@ Specify the directory where the CPU profiles generated by `--cpu-prof` will
 be placed.
 
 The default value is controlled by the
-[--diagnostic-dir](#cli_diagnostic_dir_directory) command line option.
+[--diagnostic-dir](#cli_diagnostic_dir_directory) command-line option.
 
 ### `--cpu-prof-interval`
 <!-- YAML
@@ -152,7 +157,7 @@ Specify the file name of the CPU profile generated by `--cpu-prof`.
 
 ### `--diagnostic-dir=directory`
 
-Set the directory to which all diagnostic output files will be written to.
+Set the directory to which all diagnostic output files are written.
 Defaults to current working directory.
 
 Affects the default output directory of:
@@ -161,13 +166,13 @@ Affects the default output directory of:
 * [--redirect-warnings](#cli_redirect_warnings_file)
 
 ### `--disable-proto=mode`
-<!--YAML
-added: v12.17.0
+<!-- YAML
+added: v13.12.0
 -->
 
 Disable the `Object.prototype.__proto__` property. If `mode` is `delete`, the
-property will be removed entirely. If `mode` is `throw`, accesses to the
-property will throw an exception with the code `ERR_PROTO_ACCESS`.
+property is removed entirely. If `mode` is `throw`, accesses to the
+property throw an exception with the code `ERR_PROTO_ACCESS`.
 
 ### `--disallow-code-generation-from-strings`
 <!-- YAML
@@ -178,6 +183,19 @@ Make built-in language features like `eval` and `new Function` that generate
 code from strings throw an exception instead. This does not affect the Node.js
 `vm` module.
 
+### `--dns-result-order=order`
+<!-- YAML
+added: v14.18.0
+-->
+
+Set the default value of `verbatim` in [`dns.lookup()`][] and
+[`dnsPromises.lookup()`][]. The value could be:
+* `ipv4first`: sets default `verbatim` `false`.
+* `verbatim`: sets default `verbatim` `true`.
+
+The default is `ipv4first` and [`dns.setDefaultResultOrder()`][] have higher
+priority than `--dns-result-order`.
+
 ### `--enable-fips`
 <!-- YAML
 added: v6.0.0
@@ -189,18 +207,34 @@ Enable FIPS-compliant crypto at startup. (Requires Node.js to be built with
 ### `--enable-source-maps`
 <!-- YAML
 added: v12.12.0
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37362
+    description: This API is no longer experimental.
 -->
 
-> Stability: 1 - Experimental
+Enable [Source Map v3][Source Map] support for stack traces.
 
-Enable experimental Source Map v3 support for stack traces.
+When using a transpiler, such as TypeScript, strack traces thrown by an
+application reference the transpiled code, not the original source position.
+`--enable-source-maps` enables caching of Source Maps and makes a best
+effort to report stack traces relative to the original source file.
 
-Currently, overriding `Error.prepareStackTrace` is ignored when the
-`--enable-source-maps` flag is set.
+Overriding `Error.prepareStackTrace` prevents `--enable-source-maps` from
+modifiying the stack trace.
+
+### `--experimental-abortcontroller`
+<!-- YAML
+added: v14.17.0
+-->
+
+Enable experimental `AbortController` and `AbortSignal` support.
 
 ### `--experimental-import-meta-resolve`
 <!-- YAML
-added: v12.16.2
+added:
+  - v13.9.0
+  - v12.16.2
 -->
 
 Enable experimental `import.meta.resolve()` support.
@@ -217,7 +251,7 @@ Enable experimental JSON support for the ES Module loader.
 added: v9.0.0
 -->
 
-Specify the `module` of a custom [experimental ECMAScript Module loader][].
+Specify the `module` of a custom experimental [ECMAScript Module loader][].
 `module` may be either a path to a file, or an ECMAScript Module name.
 
 ### `--experimental-modules`
@@ -243,17 +277,19 @@ Enable experimental top-level `await` keyword support in REPL.
 
 ### `--experimental-specifier-resolution=mode`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.4.0
+ - v12.16.0
 -->
 
 Sets the resolution algorithm for resolving ES module specifiers. Valid options
 are `explicit` and `node`.
 
 The default is `explicit`, which requires providing the full path to a
-module. The `node` mode will enable support for optional file extensions and
+module. The `node` mode enables support for optional file extensions and
 the ability to import a directory that has an index file.
 
-Please see [customizing ESM specifier resolution][] for example usage.
+See [customizing ESM specifier resolution][] for example usage.
 
 ### `--experimental-vm-modules`
 <!-- YAML
@@ -264,7 +300,14 @@ Enable experimental ES Module support in the `vm` module.
 
 ### `--experimental-wasi-unstable-preview1`
 <!-- YAML
-added: v12.16.0
+added:
+  - v13.3.0
+  - v12.16.0
+changes:
+  - version: v13.6.0
+    pr-url: https://github.com/nodejs/node/pull/30980
+    description: changed from `--experimental-wasi-unstable-preview0` to
+                 `--experimental-wasi-unstable-preview1`.
 -->
 
 Enable experimental WebAssembly System Interface (WASI) support.
@@ -274,6 +317,8 @@ Enable experimental WebAssembly System Interface (WASI) support.
 added: v12.3.0
 -->
 
+Enable experimental WebAssembly module support.
+
 ### `--force-context-aware`
 <!-- YAML
 added: v12.12.0
@@ -281,8 +326,6 @@ added: v12.12.0
 
 Disable loading native addons that are not [context-aware][].
 
-Enable experimental WebAssembly module support.
-
 ### `--force-fips`
 <!-- YAML
 added: v6.0.0
@@ -307,6 +350,52 @@ reference. Code may break under this flag.
 `--require` runs prior to freezing intrinsics in order to allow polyfills to
 be added.
 
+### `--heapsnapshot-near-heap-limit=max_count`
+<!-- YAML
+added: v14.18.0
+-->
+
+> Stability: 1 - Experimental
+
+Writes a V8 heap snapshot to disk when the V8 heap usage is approaching the
+heap limit. `count` should be a non-negative integer (in which case
+Node.js will write no more than `max_count` snapshots to disk).
+
+When generating snapshots, garbage collection may be triggered and bring
+the heap usage down, therefore multiple snapshots may be written to disk
+before the Node.js instance finally runs out of memory. These heap snapshots
+can be compared to determine what objects are being allocated during the
+time consecutive snapshots are taken. It's not guaranteed that Node.js will
+write exactly `max_count` snapshots to disk, but it will try
+its best to generate at least one and up to `max_count` snapshots before the
+Node.js instance runs out of memory when `max_count` is greater than `0`.
+
+Generating V8 snapshots takes time and memory (both memory managed by the
+V8 heap and native memory outside the V8 heap). The bigger the heap is,
+the more resources it needs. Node.js will adjust the V8 heap to accommondate
+the additional V8 heap memory overhead, and try its best to avoid using up
+all the memory avialable to the process. When the process uses
+more memory than the system deems appropriate, the process may be terminated
+abruptly by the system, depending on the system configuration.
+
+```console
+$ node --max-old-space-size=100 --heapsnapshot-near-heap-limit=3 index.js
+Wrote snapshot to Heap.20200430.100036.49580.0.001.heapsnapshot
+Wrote snapshot to Heap.20200430.100037.49580.0.002.heapsnapshot
+Wrote snapshot to Heap.20200430.100038.49580.0.003.heapsnapshot
+
+<--- Last few GCs --->
+
+[49580:0x110000000]     4826 ms: Mark-sweep 130.6 (147.8) -> 130.5 (147.8) MB, 27.4 / 0.0 ms  (average mu = 0.126, current mu = 0.034) allocation failure scavenge might not succeed
+[49580:0x110000000]     4845 ms: Mark-sweep 130.6 (147.8) -> 130.6 (147.8) MB, 18.8 / 0.0 ms  (average mu = 0.088, current mu = 0.031) allocation failure scavenge might not succeed
+
+
+<--- JS stacktrace --->
+
+FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory
+....
+```
+
 ### `--heapsnapshot-signal=signal`
 <!-- YAML
 added: v12.0.0
@@ -336,10 +425,10 @@ added: v12.4.0
 Starts the V8 heap profiler on start up, and writes the heap profile to disk
 before exit.
 
-If `--heap-prof-dir` is not specified, the generated profile will be placed
+If `--heap-prof-dir` is not specified, the generated profile is placed
 in the current working directory.
 
-If `--heap-prof-name` is not specified, the generated profile will be
+If `--heap-prof-name` is not specified, the generated profile is
 named `Heap.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.heapprofile`.
 
 ```console
@@ -359,7 +448,7 @@ Specify the directory where the heap profiles generated by `--heap-prof` will
 be placed.
 
 The default value is controlled by the
-[--diagnostic-dir](#cli_diagnostic_dir_directory) command line option.
+[--diagnostic-dir](#cli_diagnostic_dir_directory) command-line option.
 
 ### `--heap-prof-interval`
 <!-- YAML
@@ -380,39 +469,6 @@ added: v12.4.0
 
 Specify the file name of the heap profile generated by `--heap-prof`.
 
-### `--http-parser=library`
-<!-- YAML
-added: v11.4.0
-changes:
-  - version: v12.22.0
-    pr-url: https://github.com/nodejs/node/pull/37603
-    description: The legacy HTTP parser will emit a deprecation warning.
--->
-
-Chooses an HTTP parser library. Available values are:
-
-* `llhttp` for <https://llhttp.org/>
-* `legacy` for <https://github.com/nodejs/http-parser>
-
-The default is `llhttp`, unless otherwise specified when building Node.js.
-
-The `legacy` HTTP parser is deprecated and will emit a deprecation warning.
-
-This flag exists to aid in experimentation with the internal implementation of
-the Node.js http parser.
-This flag is likely to become a no-op and removed at some point in the future.
-
-### `--http-server-default-timeout=milliseconds`
-<!-- YAML
-added: v12.4.0
--->
-
-Overrides the default value of `http`, `https` and `http2` server socket
-timeout. Setting the value to 0 disables server socket timeout. Unless
-provided, http server sockets timeout after 120s (2 minutes). Programmatic
-setting of the timeout takes precedence over the value set through this
-flag.
-
 ### `--icu-data-dir=file`
 <!-- YAML
 added: v0.11.15
@@ -488,7 +544,10 @@ endpoint on `http://host:port/json/list`.
 
 ### `--insecure-http-parser`
 <!-- YAML
-added: v12.15.0
+added:
+ - v13.4.0
+ - v12.15.0
+ - v10.19.0
 -->
 
 Use an insecure HTTP parser that accepts invalid HTTP headers. This may allow
@@ -510,10 +569,16 @@ disappear in a non-semver-major release.
 
 ### `--max-http-header-size=size`
 <!-- YAML
-added: v11.6.0
+added:
+ - v11.6.0
+ - v10.15.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/32520
+    description: Change maximum default size of HTTP headers from 8KB to 16KB.
 -->
 
-Specify the maximum size, in bytes, of HTTP headers. Defaults to 8KB.
+Specify the maximum size, in bytes, of HTTP headers. Defaults to 16KB.
 
 ### `--napi-modules`
 <!-- YAML
@@ -544,6 +609,14 @@ added: v6.0.0
 
 Silence all process warnings (including deprecations).
 
+### `--node-memory-debug`
+<!-- YAML
+added: v14.18.0
+-->
+
+Enable extra debug checks for memory leaks in Node.js internals. This is
+usually only useful for developers debugging Node.js itself.
+
 ### `--openssl-config=file`
 <!-- YAML
 added: v6.9.0
@@ -562,7 +635,7 @@ Emit pending deprecation warnings.
 
 Pending deprecations are generally identical to a runtime deprecation with the
 notable exception that they are turned *off* by default and will not be emitted
-unless either the `--pending-deprecation` command line flag, or the
+unless either the `--pending-deprecation` command-line flag, or the
 `NODE_PENDING_DEPRECATION=1` environment variable, is set. Pending deprecations
 are used to provide a kind of selective "early warning" mechanism that
 developers may leverage to detect deprecated API usage.
@@ -608,7 +681,7 @@ be thrown if `moduleA` attempts to require `moduleB` as a peer dependency:
      └── package.json
 ```
 
-The `--preserve-symlinks` command line flag instructs Node.js to use the
+The `--preserve-symlinks` command-line flag instructs Node.js to use the
 symlink path for modules as opposed to the real path, allowing symbolically
 linked peer dependencies to be found.
 
@@ -634,8 +707,8 @@ This flag exists so that the main module can be opted-in to the same behavior
 that `--preserve-symlinks` gives to all other imports; they are separate flags,
 however, for backward compatibility with older Node.js versions.
 
-`--preserve-symlinks-main` does not imply `--preserve-symlinks`; it
-is expected that `--preserve-symlinks-main` will be used in addition to
+`--preserve-symlinks-main` does not imply `--preserve-symlinks`; use
+`--preserve-symlinks-main` in addition to
 `--preserve-symlinks` when it is not desirable to follow symlinks before
 resolving relative paths.
 
@@ -667,11 +740,11 @@ warning will be written to stderr instead.
 
 The `file` name may be an absolute path. If it is not, the default directory it
 will be written to is controlled by the
-[--diagnostic-dir](#cli_diagnostic_dir_directory) command line option.
+[--diagnostic-dir](#cli_diagnostic_dir_directory) command-line option.
 
 ### `--report-compact`
 <!-- YAML
-added: v12.17.0
+added: v13.12.0
 -->
 
 Write reports in a compact format, single-line JSON, more easily consumable
@@ -682,13 +755,13 @@ human consumption.
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This option is no longer experimental.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/27312
     description: Changed from `--diagnostic-report-directory` to
-                 `--report-directory`
+                 `--report-directory`.
 -->
 
 Location at which the report will be generated.
@@ -697,13 +770,13 @@ Location at which the report will be generated.
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This option is no longer experimental.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/27312
     description: changed from `--diagnostic-report-filename` to
-                 `--report-filename`
+                 `--report-filename`.
 -->
 
 Name of the file to which the report will be written.
@@ -712,13 +785,13 @@ Name of the file to which the report will be written.
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v14.0.0
     pr-url: https://github.com/nodejs/node/pull/32496
     description: This option is no longer experimental.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/27312
     description: changed from `--diagnostic-report-on-fatalerror` to
-                 `--report-on-fatalerror`
+                 `--report-on-fatalerror`.
 -->
 
 Enables the report to be triggered on fatal errors (internal errors within
@@ -731,13 +804,13 @@ error.
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This option is no longer experimental.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/27312
     description: changed from `--diagnostic-report-on-signal` to
-                 `--report-on-signal`
+                 `--report-on-signal`.
 -->
 
 Enables report to be generated upon receiving the specified (or predefined)
@@ -748,13 +821,13 @@ specified through `--report-signal`.
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This option is no longer experimental.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/27312
     description: changed from `--diagnostic-report-signal` to
-                 `--report-signal`
+                 `--report-signal`.
 -->
 
 Sets or resets the signal for report generation (not supported on Windows).
@@ -764,13 +837,13 @@ Default signal is `SIGUSR2`.
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This option is no longer experimental.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/27312
     description: changed from `--diagnostic-report-uncaught-exception` to
-                 `--report-uncaught-exception`
+                 `--report-uncaught-exception`.
 -->
 
 Enables report to be generated on uncaught exceptions. Useful when inspecting
@@ -801,7 +874,9 @@ with crypto support (default).
 
 ### `--tls-keylog=file`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.2.0
+ - v12.16.0
 -->
 
 Log TLS key material to a file. The key material is in NSS `SSLKEYLOGFILE`
@@ -810,7 +885,9 @@ traffic.
 
 ### `--tls-max-v1.2`
 <!-- YAML
-added: v12.0.0
+added:
+ - v12.0.0
+ - v10.20.0
 -->
 
 Set [`tls.DEFAULT_MAX_VERSION`][] to 'TLSv1.2'. Use to disable support for
@@ -826,7 +903,9 @@ for TLSv1.3.
 
 ### `--tls-min-v1.0`
 <!-- YAML
-added: v12.0.0
+added:
+ - v12.0.0
+ - v10.20.0
 -->
 
 Set default [`tls.DEFAULT_MIN_VERSION`][] to 'TLSv1'. Use for compatibility with
@@ -834,7 +913,9 @@ old TLS clients or servers.
 
 ### `--tls-min-v1.1`
 <!-- YAML
-added: v12.0.0
+added:
+ - v12.0.0
+ - v10.20.0
 -->
 
 Set default [`tls.DEFAULT_MIN_VERSION`][] to 'TLSv1.1'. Use for compatibility
@@ -842,7 +923,9 @@ with old TLS clients or servers.
 
 ### `--tls-min-v1.2`
 <!-- YAML
-added: v12.2.0
+added:
+ - v12.2.0
+ - v10.20.0
 -->
 
 Set default [`tls.DEFAULT_MIN_VERSION`][] to 'TLSv1.2'. This is the default for
@@ -857,6 +940,33 @@ added: v12.0.0
 Set default [`tls.DEFAULT_MIN_VERSION`][] to 'TLSv1.3'. Use to disable support
 for TLSv1.2, which is not as secure as TLSv1.3.
 
+### `--trace-atomics-wait`
+<!-- YAML
+added: v14.3.0
+-->
+
+Print short summaries of calls to [`Atomics.wait()`][] to stderr.
+The output could look like this:
+
+```text
+(node:15701) [Thread 0] Atomics.wait(&lt;address> + 0, 1, inf) started
+(node:15701) [Thread 0] Atomics.wait(&lt;address> + 0, 1, inf) did not wait because the values mismatched
+(node:15701) [Thread 0] Atomics.wait(&lt;address> + 0, 0, 10) started
+(node:15701) [Thread 0] Atomics.wait(&lt;address> + 0, 0, 10) timed out
+(node:15701) [Thread 0] Atomics.wait(&lt;address> + 4, 0, inf) started
+(node:15701) [Thread 1] Atomics.wait(&lt;address> + 4, -1, inf) started
+(node:15701) [Thread 0] Atomics.wait(&lt;address> + 4, 0, inf) was woken up by another thread
+(node:15701) [Thread 1] Atomics.wait(&lt;address> + 4, -1, inf) was woken up by another thread
+```
+
+The fields here correspond to:
+
+* The thread id as given by [`worker_threads.threadId`][]
+* The base address of the `SharedArrayBuffer` in question, as well as the
+  byte offset corresponding to the index passed to `Atomics.wait()`
+* The expected value that was passed to `Atomics.wait()`
+* The timeout passed to `Atomics.wait`
+
 ### `--trace-deprecation`
 <!-- YAML
 added: v0.8.0
@@ -889,7 +999,9 @@ Enables the collection of trace event tracing information.
 
 ### `--trace-exit`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.5.0
+ - v12.16.0
 -->
 
 Prints a stack trace whenever an environment is exited proactively,
@@ -897,7 +1009,7 @@ i.e. invoking `process.exit()`.
 
 ### `--trace-sigint`
 <!-- YAML
-added: v12.17.0
+added: v13.9.0
 -->
 
 Prints a stack trace on SIGINT.
@@ -920,7 +1032,7 @@ connection problems.
 
 ### `--trace-uncaught`
 <!-- YAML
-added: v12.16.0
+added: v13.1.0
 -->
 
 Print stack traces for uncaught exceptions; usually, the stack trace associated
@@ -946,7 +1058,9 @@ Track heap object allocations for heap snapshots.
 
 ### `--unhandled-rejections=mode`
 <!-- YAML
-added: v12.0.0
+added:
+ - v12.0.0
+ - v10.17.0
 -->
 
 By default all unhandled rejections trigger a warning plus a deprecation warning
@@ -954,11 +1068,15 @@ for the very first unhandled rejection in case no [`unhandledRejection`][] hook
 is used.
 
 Using this flag allows to change what should happen when an unhandled rejection
-occurs. One of three modes can be chosen:
+occurs. One of the following modes can be chosen:
 
+* `throw`: Emit [`unhandledRejection`][]. If this hook is not set, raise the
+  unhandled rejection as an uncaught exception.
 * `strict`: Raise the unhandled rejection as an uncaught exception.
 * `warn`: Always trigger a warning, no matter if the [`unhandledRejection`][]
   hook is set or not but do not print the deprecation warning.
+* `warn-with-error-code`: Emit [`unhandledRejection`][]. If this hook is not
+  set, trigger a warning, and set the process exit code to 1.
 * `none`: Silence all warnings.
 
 ### `--use-bundled-ca`, `--use-openssl-ca`
@@ -983,7 +1101,7 @@ See `SSL_CERT_DIR` and `SSL_CERT_FILE`.
 
 ### `--use-largepages=mode`
 <!-- YAML
-added: v12.17.0
+added: v13.6.0
 -->
 
 Re-map the Node.js static code to large memory pages at startup. If supported on
@@ -1002,7 +1120,7 @@ The following values are valid for `mode`:
 added: v0.1.3
 -->
 
-Print V8 command line options.
+Print V8 command-line options.
 
 ### `--v8-pool-size=num`
 <!-- YAML
@@ -1059,7 +1177,7 @@ and `"` are usable.
 added: v0.1.3
 -->
 
-Print node command line options.
+Print node command-line options.
 The output of this option is less detailed than this document.
 
 ### `-i`, `--interactive`
@@ -1090,6 +1208,9 @@ Preload the specified module at startup.
 Follows `require()`'s module resolution
 rules. `module` may be either a path to a file, or a node module name.
 
+Only CommonJS modules are supported. Attempting to preload a
+ES6 Module using `--require` will fail with an error.
+
 ### `-v`, `--version`
 <!-- YAML
 added: v0.1.3
@@ -1099,6 +1220,19 @@ Print node's version.
 
 ## Environment variables
 
+### `FORCE_COLOR=[1, 2, 3]`
+
+The `FORCE_COLOR` environment variable is used to
+enable ANSI colorized output. The value may be:
+
+* `1`, `true`, or the empty string `''` indicate 16-color support,
+* `2` to indicate 256-color support, or
+* `3` to indicate 16 million-color support.
+
+When `FORCE_COLOR` is used and set to a supported value, both the `NO_COLOR`,
+and `NODE_DISABLE_COLORS` environment variables are ignored.
+
+Any other value will result in colorized output being disabled.
 ### `NODE_DEBUG=module[,…]`
 <!-- YAML
 added: v0.1.32
@@ -1134,6 +1268,10 @@ options property is explicitly specified for a TLS or HTTPS client or server.
 This environment variable is ignored when `node` runs as setuid root or
 has Linux file capabilities set.
 
+The `NODE_EXTRA_CA_CERTS` environment variable is only read when the Node.js
+process is first launched. Changing the value at runtime using
+`process.env.NODE_EXTRA_CA_CERTS` has no effect on the current process.
+
 ### `NODE_ICU_DATA=file`
 <!-- YAML
 added: v0.11.15
@@ -1154,20 +1292,19 @@ When set to `1`, process warnings are silenced.
 added: v8.0.0
 -->
 
-A space-separated list of command line options. `options...` are interpreted
-before command line options, so command line options will override or
+A space-separated list of command-line options. `options...` are interpreted
+before command-line options, so command-line options will override or
 compound after anything in `options...`. Node.js will exit with an error if
 an option that is not allowed in the environment is used, such as `-p` or a
 script file.
 
-In case an option value happens to contain a space (for example a path listed
-in `--require`), it must be escaped using double quotes. For example:
+If an option value contains a space, it can be escaped using double quotes:
 
 ```bash
 NODE_OPTIONS='--require "./my path/file.js"'
 ```
 
-A singleton flag passed as a command line option will override the same flag
+A singleton flag passed as a command-line option will override the same flag
 passed into `NODE_OPTIONS`:
 
 ```bash
@@ -1176,7 +1313,7 @@ NODE_OPTIONS='--inspect=localhost:4444' node --inspect=localhost:5555
 ```
 
 A flag that can be passed multiple times will be treated as if its
-`NODE_OPTIONS` instances were passed first, and then its command line
+`NODE_OPTIONS` instances were passed first, and then its command-line
 instances afterwards:
 
 ```bash
@@ -1187,11 +1324,13 @@ node --require "./a.js" --require "./b.js"
 
 Node.js options that are allowed are:
 <!-- node-options-node start -->
-* `--conditions`
+* `--conditions`, `-C`
 * `--diagnostic-dir`
 * `--disable-proto`
+* `--dns-result-order`
 * `--enable-fips`
 * `--enable-source-maps`
+* `--experimental-abortcontroller`
 * `--experimental-import-meta-resolve`
 * `--experimental-json-modules`
 * `--experimental-loader`
@@ -1199,15 +1338,16 @@ Node.js options that are allowed are:
 * `--experimental-policy`
 * `--experimental-repl-await`
 * `--experimental-specifier-resolution`
+* `--experimental-top-level-await`
 * `--experimental-vm-modules`
 * `--experimental-wasi-unstable-preview1`
 * `--experimental-wasm-modules`
 * `--force-context-aware`
 * `--force-fips`
 * `--frozen-intrinsics`
+* `--heapsnapshot-near-heap-limit`
 * `--heapsnapshot-signal`
 * `--http-parser`
-* `--http-server-default-timeout`
 * `--icu-data-dir`
 * `--input-type`
 * `--insecure-http-parser`
@@ -1220,6 +1360,7 @@ Node.js options that are allowed are:
 * `--no-deprecation`
 * `--no-force-async-hooks-checks`
 * `--no-warnings`
+* `--node-memory-debug`
 * `--openssl-config`
 * `--pending-deprecation`
 * `--policy-integrity`
@@ -1245,6 +1386,7 @@ Node.js options that are allowed are:
 * `--tls-min-v1.1`
 * `--tls-min-v1.2`
 * `--tls-min-v1.3`
+* `--trace-atomics-wait`
 * `--trace-deprecation`
 * `--trace-event-categories`
 * `--trace-event-file-pattern`
@@ -1300,7 +1442,7 @@ When set to `1`, emit pending deprecation warnings.
 
 Pending deprecations are generally identical to a runtime deprecation with the
 notable exception that they are turned *off* by default and will not be emitted
-unless either the `--pending-deprecation` command line flag, or the
+unless either the `--pending-deprecation` command-line flag, or the
 `NODE_PENDING_DEPRECATION=1` environment variable, is set. Pending deprecations
 are used to provide a kind of selective "early warning" mechanism that
 developers may leverage to detect deprecated API usage.
@@ -1340,12 +1482,23 @@ to an empty string (`''` or `' '`) disables persistent REPL history.
 
 ### `NODE_REPL_EXTERNAL_MODULE=file`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.0.0
+ - v12.16.0
 -->
 
 Path to a Node.js module which will be loaded in place of the built-in REPL.
 Overriding this value to an empty string (`''`) will use the built-in REPL.
 
+### `NODE_SKIP_PLATFORM_CHECK=value`
+<!-- YAML
+added: v14.5.0
+-->
+
+If `value` equals `'1'`, the check for a supported platform is skipped during
+Node.js startup. Node.js might not execute correctly. Any issues encountered
+on unsupported platforms will not be fixed.
+
 ### `NODE_TLS_REJECT_UNAUTHORIZED=value`
 
 If `value` equals `'0'`, certificate validation is disabled for TLS connections.
@@ -1428,6 +1581,11 @@ and the line lengths of the source file (in the key `lineLengths`).
 }
 ```
 
+### `NO_COLOR=<any>`
+
+[`NO_COLOR`][]  is an alias for `NODE_DISABLE_COLORS`. The value of the
+environment variable is arbitrary.
+
 ### `OPENSSL_CONF=file`
 <!-- YAML
 added: v6.11.0
@@ -1437,7 +1595,7 @@ Load an OpenSSL configuration file on startup. Among other uses, this can be
 used to enable FIPS-compliant crypto if Node.js is built with `./configure
 --openssl-fips`.
 
-If the [`--openssl-config`][] command line option is used, the environment
+If the [`--openssl-config`][] command-line option is used, the environment
 variable is ignored.
 
 ### `SSL_CERT_DIR=dir`
@@ -1511,26 +1669,33 @@ On a machine with 2GB of memory, consider setting this to
 $ node --max-old-space-size=1536 index.js
 ```
 
-[`--openssl-config`]: #cli_openssl_config_file
-[`Buffer`]: buffer.html#buffer_class_buffer
-[`SlowBuffer`]: buffer.html#buffer_class_slowbuffer
-[`NODE_OPTIONS`]: #cli_node_options_options
-[`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
-[`tls.DEFAULT_MAX_VERSION`]: tls.html#tls_tls_default_max_version
-[`tls.DEFAULT_MIN_VERSION`]: tls.html#tls_tls_default_min_version
-[`unhandledRejection`]: process.html#process_event_unhandledrejection
 [Chrome DevTools Protocol]: https://chromedevtools.github.io/devtools-protocol/
-[REPL]: repl.html
+[ECMAScript Module loader]: esm.md#esm_loaders
+[REPL]: repl.md
 [ScriptCoverage]: https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-ScriptCoverage
 [Source Map]: https://sourcemaps.info/spec.html
 [Subresource Integrity]: https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity
 [V8 JavaScript code coverage]: https://v8project.blogspot.com/2017/12/javascript-code-coverage.html
-[context-aware]: addons.html#addons_context_aware_addons
-[customizing ESM specifier resolution]: esm.html#esm_customizing_esm_specifier_resolution_algorithm
-[debugger]: debugger.html
+[`--openssl-config`]: #cli_openssl_config_file
+[`Atomics.wait()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait
+[`Buffer`]: buffer.md#buffer_class_buffer
+[`NODE_OPTIONS`]: #cli_node_options_options
+[`NO_COLOR`]: https://no-color.org
+[`SlowBuffer`]: buffer.md#buffer_class_slowbuffer
+[`dns.lookup()`]: dns.md#dns_dns_lookup_hostname_options_callback
+[`dns.setDefaultResultOrder()`]: dns.md#dns_dns_setdefaultresultorder_order
+[`dnsPromises.lookup()`]: dns.md#dns_dnspromises_lookup_hostname_options
+[`process.setUncaughtExceptionCaptureCallback()`]: process.md#process_process_setuncaughtexceptioncapturecallback_fn
+[`tls.DEFAULT_MAX_VERSION`]: tls.md#tls_tls_default_max_version
+[`tls.DEFAULT_MIN_VERSION`]: tls.md#tls_tls_default_min_version
+[`unhandledRejection`]: process.md#process_event_unhandledrejection
+[`worker_threads.threadId`]: worker_threads.md#worker_threads_worker_threadid
+[conditional exports]: packages.md#packages_conditional_exports
+[context-aware]: addons.md#addons_context_aware_addons
+[customizing ESM specifier resolution]: esm.md#esm_customizing_esm_specifier_resolution_algorithm
+[debugger]: debugger.md
 [debugging security implications]: https://nodejs.org/en/docs/guides/debugging-getting-started/#security-implications
-[emit_warning]: process.html#process_process_emitwarning_warning_type_code_ctor
-[experimental ECMAScript Module loader]: esm.html#esm_experimental_loaders
+[emit_warning]: process.md#process_process_emitwarning_warning_type_code_ctor
 [jitless]: https://v8.dev/blog/jitless
 [libuv threadpool documentation]: https://docs.libuv.org/en/latest/threadpool.html
 [remote code execution]: https://www.owasp.org/index.php/Code_Injection
diff --git a/doc/api/cluster.html b/doc/api/cluster.html
index 4cfc08f4d4f13fb2ba6dec2121f6c42333896887..ab4006048adbbcdcbe522a118ef209c0708fb9f2 100644
--- a/doc/api/cluster.html
+++ b/doc/api/cluster.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Cluster | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Cluster | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster active">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="cluster" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/cluster.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/cluster.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/cluster.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/cluster.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/cluster.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/cluster.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/cluster.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/cluster.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/cluster.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#cluster_cluster">Cluster</a></span>
 <ul>
 <li><a href="#cluster_how_it_works">How it works</a></li>
@@ -166,14 +179,13 @@
 <li><a href="#cluster_cluster_workers"><code>cluster.workers</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Cluster<span><a class="mark" href="#cluster_cluster" id="cluster_cluster">#</a></span></h1>
+        <h2>Cluster<span><a class="mark" href="#cluster_cluster" id="cluster_cluster">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/cluster.js">lib/cluster.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/cluster.js">lib/cluster.js</a></p>
 <p>A single instance of Node.js runs in a single thread. To take advantage of
 multi-core systems, the user will sometimes want to launch a cluster of Node.js
 processes to handle the load.</p>
@@ -181,38 +193,38 @@ processes to handle the load.</p>
 server ports.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).cpus().length;
+<span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).<span class="hljs-title function_">cpus</span>().<span class="hljs-property">length</span>;
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Master <span class="hljs-subst">${process.pid}</span> is running`</span>);
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Master <span class="hljs-subst">${process.pid}</span> is running`</span>);
 
   <span class="hljs-comment">// Fork workers.</span>
   <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; numCPUs; i++) {
-    cluster.fork();
+    cluster.<span class="hljs-title function_">fork</span>();
   }
 
-  cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`worker <span class="hljs-subst">${worker.process.pid}</span> died`</span>);
+  cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`worker <span class="hljs-subst">${worker.process.pid}</span> died`</span>);
   });
 } <span class="hljs-keyword">else</span> {
   <span class="hljs-comment">// Workers can share any TCP connection</span>
   <span class="hljs-comment">// In this case it is an HTTP server</span>
-  http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    res.writeHead(<span class="hljs-number">200</span>);
-    res.end(<span class="hljs-string">'hello world\n'</span>);
-  }).listen(<span class="hljs-number">8000</span>);
+  http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+    res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'hello world\n'</span>);
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);
 
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Worker <span class="hljs-subst">${process.pid}</span> started`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Worker <span class="hljs-subst">${process.pid}</span> started`</span>);
 }</code></pre>
 <p>Running Node.js will now share port 8000 between the workers:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node server.js</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node server.js</span>
 Master 3596 is running
 Worker 4324 started
 Worker 4520 started
 Worker 6056 started
 Worker 5644 started</code></pre>
 <p>On Windows, it is not yet possible to set up a named pipe server in a worker.</p>
-<h2>How it works<span><a class="mark" href="#cluster_how_it_works" id="cluster_how_it_works">#</a></span></h2>
+<section><h3>How it works<span><a class="mark" href="#cluster_how_it_works" id="cluster_how_it_works">#</a></span></h3>
 
 <p>The worker processes are spawned using the <a href="child_process.html#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a> method,
 so that they can communicate with the parent via IPC and pass server
@@ -261,7 +273,7 @@ automatically manage the number of workers, however. It is the application's
 responsibility to manage the worker pool based on its own needs.</p>
 <p>Although a primary use case for the <code>cluster</code> module is networking, it can
 also be used for other use cases requiring worker processes.</p>
-<h2>Class: <code>Worker</code><span><a class="mark" href="#cluster_class_worker" id="cluster_class_worker">#</a></span></h2>
+</section><section><h3>Class: <code>Worker</code><span><a class="mark" href="#cluster_class_worker" id="cluster_class_worker">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -271,21 +283,21 @@ also be used for other use cases requiring worker processes.</p>
 <p>A <code>Worker</code> object contains all public information and method about a worker.
 In the master it can be obtained using <code>cluster.workers</code>. In a worker
 it can be obtained using <code>cluster.worker</code>.</p>
-<h3>Event: <code>'disconnect'</code><span><a class="mark" href="#cluster_event_disconnect" id="cluster_event_disconnect">#</a></span></h3>
+<h4>Event: <code>'disconnect'</code><span><a class="mark" href="#cluster_event_disconnect" id="cluster_event_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>Similar to the <code>cluster.on('disconnect')</code> event, but specific to this worker.</p>
-<pre><code class="language-js">cluster.fork().on(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">cluster.<span class="hljs-title function_">fork</span>().<span class="hljs-title function_">on</span>(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Worker has disconnected</span>
 });</code></pre>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#cluster_event_error" id="cluster_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#cluster_event_error" id="cluster_event_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.3</span>
 </div>
 <p>This event is the same as the one provided by <a href="child_process.html#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p>
 <p>Within a worker, <code>process.on('error')</code> may also be used.</p>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#cluster_event_exit" id="cluster_event_exit">#</a></span></h3>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#cluster_event_exit" id="cluster_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -295,17 +307,17 @@ it can be obtained using <code>cluster.worker</code>.</p>
 the process to be killed.</li>
 </ul>
 <p>Similar to the <code>cluster.on('exit')</code> event, but specific to this worker.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> worker = cluster.fork();
-worker.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code, signal</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> worker = cluster.<span class="hljs-title function_">fork</span>();
+worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code, signal</span>) =></span> {
   <span class="hljs-keyword">if</span> (signal) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`worker was killed by signal: <span class="hljs-subst">${signal}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`worker was killed by signal: <span class="hljs-subst">${signal}</span>`</span>);
   } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (code !== <span class="hljs-number">0</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`worker exited with error code: <span class="hljs-subst">${code}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`worker exited with error code: <span class="hljs-subst">${code}</span>`</span>);
   } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'worker success!'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'worker success!'</span>);
   }
 });</code></pre>
-<h3>Event: <code>'listening'</code><span><a class="mark" href="#cluster_event_listening" id="cluster_event_listening">#</a></span></h3>
+<h4>Event: <code>'listening'</code><span><a class="mark" href="#cluster_event_listening" id="cluster_event_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -313,11 +325,11 @@ worker.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(
 <li><code>address</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>Similar to the <code>cluster.on('listening')</code> event, but specific to this worker.</p>
-<pre><code class="language-js">cluster.fork().on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">address</span>) =></span> {
+<pre><code class="language-js">cluster.<span class="hljs-title function_">fork</span>().<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">address</span>) =></span> {
   <span class="hljs-comment">// Worker is listening</span>
 });</code></pre>
 <p>It is not emitted in the worker.</p>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#cluster_event_message" id="cluster_event_message">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#cluster_event_message" id="cluster_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -333,52 +345,52 @@ process of the number of HTTP requests received by the workers:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
 
   <span class="hljs-comment">// Keep track of http requests</span>
   <span class="hljs-keyword">let</span> numReqs = <span class="hljs-number">0</span>;
   <span class="hljs-built_in">setInterval</span>(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`numReqs = <span class="hljs-subst">${numReqs}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`numReqs = <span class="hljs-subst">${numReqs}</span>`</span>);
   }, <span class="hljs-number">1000</span>);
 
   <span class="hljs-comment">// Count requests</span>
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">messageHandler</span>(<span class="hljs-params">msg</span>) </span>{
-    <span class="hljs-keyword">if</span> (msg.cmd &#x26;&#x26; msg.cmd === <span class="hljs-string">'notifyRequest'</span>) {
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">messageHandler</span>(<span class="hljs-params">msg</span>) {
+    <span class="hljs-keyword">if</span> (msg.<span class="hljs-property">cmd</span> &#x26;&#x26; msg.<span class="hljs-property">cmd</span> === <span class="hljs-string">'notifyRequest'</span>) {
       numReqs += <span class="hljs-number">1</span>;
     }
   }
 
   <span class="hljs-comment">// Start workers and listen for messages containing notifyRequest</span>
-  <span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).cpus().length;
+  <span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).<span class="hljs-title function_">cpus</span>().<span class="hljs-property">length</span>;
   <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; numCPUs; i++) {
-    cluster.fork();
+    cluster.<span class="hljs-title function_">fork</span>();
   }
 
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> id <span class="hljs-keyword">in</span> cluster.workers) {
-    cluster.workers[id].on(<span class="hljs-string">'message'</span>, messageHandler);
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> id <span class="hljs-keyword">in</span> cluster.<span class="hljs-property">workers</span>) {
+    cluster.<span class="hljs-property">workers</span>[id].<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, messageHandler);
   }
 
 } <span class="hljs-keyword">else</span> {
 
   <span class="hljs-comment">// Worker processes have a http server.</span>
-  http.Server(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    res.writeHead(<span class="hljs-number">200</span>);
-    res.end(<span class="hljs-string">'hello world\n'</span>);
+  http.<span class="hljs-title class_">Server</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+    res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'hello world\n'</span>);
 
     <span class="hljs-comment">// Notify master about the request</span>
-    process.send({ <span class="hljs-attr">cmd</span>: <span class="hljs-string">'notifyRequest'</span> });
-  }).listen(<span class="hljs-number">8000</span>);
+    process.<span class="hljs-title function_">send</span>({ <span class="hljs-attr">cmd</span>: <span class="hljs-string">'notifyRequest'</span> });
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);
 }</code></pre>
-<h3>Event: <code>'online'</code><span><a class="mark" href="#cluster_event_online" id="cluster_event_online">#</a></span></h3>
+<h4>Event: <code>'online'</code><span><a class="mark" href="#cluster_event_online" id="cluster_event_online">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
 <p>Similar to the <code>cluster.on('online')</code> event, but specific to this worker.</p>
-<pre><code class="language-js">cluster.fork().on(<span class="hljs-string">'online'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">cluster.<span class="hljs-title function_">fork</span>().<span class="hljs-title function_">on</span>(<span class="hljs-string">'online'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Worker is online</span>
 });</code></pre>
 <p>It is not emitted in the worker.</p>
-<h3><code>worker.disconnect()</code><span><a class="mark" href="#cluster_worker_disconnect" id="cluster_worker_disconnect">#</a></span></h3>
+<h4><code>worker.disconnect()</code><span><a class="mark" href="#cluster_worker_disconnect" id="cluster_worker_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -412,37 +424,37 @@ it is <a href="child_process.html#child_process_subprocess_disconnect"><code>dis
 may be useful to send a message, so application specific actions may be taken to
 close them. It also may be useful to implement a timeout, killing a worker if
 the <code>'disconnect'</code> event has not been emitted after some time.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-keyword">const</span> worker = cluster.fork();
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-keyword">const</span> worker = cluster.<span class="hljs-title function_">fork</span>();
   <span class="hljs-keyword">let</span> timeout;
 
-  worker.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">address</span>) =></span> {
-    worker.send(<span class="hljs-string">'shutdown'</span>);
-    worker.disconnect();
+  worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">address</span>) =></span> {
+    worker.<span class="hljs-title function_">send</span>(<span class="hljs-string">'shutdown'</span>);
+    worker.<span class="hljs-title function_">disconnect</span>();
     timeout = <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-      worker.kill();
+      worker.<span class="hljs-title function_">kill</span>();
     }, <span class="hljs-number">2000</span>);
   });
 
-  worker.on(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">() =></span> {
+  worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-built_in">clearTimeout</span>(timeout);
   });
 
-} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.isWorker) {
+} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isWorker</span>) {
   <span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-  <span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  <span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
     <span class="hljs-comment">// Connections never end</span>
   });
 
-  server.listen(<span class="hljs-number">8000</span>);
+  server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);
 
-  process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
+  process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
     <span class="hljs-keyword">if</span> (msg === <span class="hljs-string">'shutdown'</span>) {
       <span class="hljs-comment">// Initiate graceful close of any connections to server</span>
     }
   });
 }</code></pre>
-<h3><code>worker.exitedAfterDisconnect</code><span><a class="mark" href="#cluster_worker_exitedafterdisconnect" id="cluster_worker_exitedafterdisconnect">#</a></span></h3>
+<h4><code>worker.exitedAfterDisconnect</code><span><a class="mark" href="#cluster_worker_exitedafterdisconnect" id="cluster_worker_exitedafterdisconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -455,15 +467,15 @@ worker has not exited, it is <code>undefined</code>.</p>
 <p>The boolean <a href="#cluster_worker_exitedafterdisconnect"><code>worker.exitedAfterDisconnect</code></a> allows distinguishing between
 voluntary and accidental exit, the master may choose not to respawn a worker
 based on this value.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-  <span class="hljs-keyword">if</span> (worker.exitedAfterDisconnect === <span class="hljs-literal">true</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Oh, it was just voluntary – no need to worry'</span>);
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+  <span class="hljs-keyword">if</span> (worker.<span class="hljs-property">exitedAfterDisconnect</span> === <span class="hljs-literal">true</span>) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Oh, it was just voluntary – no need to worry'</span>);
   }
 });
 
 <span class="hljs-comment">// kill worker</span>
-worker.kill();</code></pre>
-<h3><code>worker.id</code><span><a class="mark" href="#cluster_worker_id" id="cluster_worker_id">#</a></span></h3>
+worker.<span class="hljs-title function_">kill</span>();</code></pre>
+<h4><code>worker.id</code><span><a class="mark" href="#cluster_worker_id" id="cluster_worker_id">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
@@ -474,14 +486,14 @@ worker.kill();</code></pre>
 <code>id</code>.</p>
 <p>While a worker is alive, this is the key that indexes it in
 <code>cluster.workers</code>.</p>
-<h3><code>worker.isConnected()</code><span><a class="mark" href="#cluster_worker_isconnected" id="cluster_worker_isconnected">#</a></span></h3>
+<h4><code>worker.isConnected()</code><span><a class="mark" href="#cluster_worker_isconnected" id="cluster_worker_isconnected">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
 <p>This function returns <code>true</code> if the worker is connected to its master via its
 IPC channel, <code>false</code> otherwise. A worker is connected to its master after it
 has been created. It is disconnected after the <code>'disconnect'</code> event is emitted.</p>
-<h3><code>worker.isDead()</code><span><a class="mark" href="#cluster_worker_isdead" id="cluster_worker_isdead">#</a></span></h3>
+<h4><code>worker.isDead()</code><span><a class="mark" href="#cluster_worker_isdead" id="cluster_worker_isdead">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -489,32 +501,32 @@ has been created. It is disconnected after the <code>'disconnect'</code> event i
 because of exiting or being signaled). Otherwise, it returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).cpus().length;
+<span class="hljs-keyword">const</span> numCPUs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>).<span class="hljs-title function_">cpus</span>().<span class="hljs-property">length</span>;
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Master <span class="hljs-subst">${process.pid}</span> is running`</span>);
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Master <span class="hljs-subst">${process.pid}</span> is running`</span>);
 
   <span class="hljs-comment">// Fork workers.</span>
   <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; numCPUs; i++) {
-    cluster.fork();
+    cluster.<span class="hljs-title function_">fork</span>();
   }
 
-  cluster.on(<span class="hljs-string">'fork'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'worker is dead:'</span>, worker.isDead());
+  cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'fork'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'worker is dead:'</span>, worker.<span class="hljs-title function_">isDead</span>());
   });
 
-  cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'worker is dead:'</span>, worker.isDead());
+  cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'worker is dead:'</span>, worker.<span class="hljs-title function_">isDead</span>());
   });
 } <span class="hljs-keyword">else</span> {
   <span class="hljs-comment">// Workers can share any TCP connection. In this case, it is an HTTP server.</span>
-  http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    res.writeHead(<span class="hljs-number">200</span>);
-    res.end(<span class="hljs-string">`Current process\n <span class="hljs-subst">${process.pid}</span>`</span>);
-    process.kill(process.pid);
-  }).listen(<span class="hljs-number">8000</span>);
+  http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+    res.<span class="hljs-title function_">end</span>(<span class="hljs-string">`Current process\n <span class="hljs-subst">${process.pid}</span>`</span>);
+    process.<span class="hljs-title function_">kill</span>(process.<span class="hljs-property">pid</span>);
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);
 }</code></pre>
-<h3><code>worker.kill([signal])</code><span><a class="mark" href="#cluster_worker_kill_signal" id="cluster_worker_kill_signal">#</a></span></h3>
+<h4><code>worker.kill([signal])</code><span><a class="mark" href="#cluster_worker_kill_signal" id="cluster_worker_kill_signal">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.12</span>
 </div>
@@ -533,7 +545,7 @@ If the graceful disconnect behavior is not needed, use <code>worker.process.kill
 <p>This method is aliased as <code>worker.destroy()</code> for backward compatibility.</p>
 <p>In a worker, <code>process.kill()</code> exists, but it is not this function;
 it is <a href="process.html#process_process_kill_pid_signal"><code>kill()</code></a>.</p>
-<h3><code>worker.process</code><span><a class="mark" href="#cluster_worker_process" id="cluster_worker_process">#</a></span></h3>
+<h4><code>worker.process</code><span><a class="mark" href="#cluster_worker_process" id="cluster_worker_process">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -547,7 +559,7 @@ is stored.</p>
 <p>Workers will call <code>process.exit(0)</code> if the <code>'disconnect'</code> event occurs
 on <code>process</code> and <code>.exitedAfterDisconnect</code> is not <code>true</code>. This protects against
 accidental disconnection.</p>
-<h3><code>worker.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#cluster_worker_send_message_sendhandle_options_callback" id="cluster_worker_send_message_sendhandle_options_callback">#</a></span></h3>
+<h4><code>worker.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#cluster_worker_send_message_sendhandle_options_callback" id="cluster_worker_send_message_sendhandle_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -580,16 +592,16 @@ the following properties:
 <p>In a worker this sends a message to the master. It is identical to
 <code>process.send()</code>.</p>
 <p>This example will echo back all messages from the master:</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-keyword">const</span> worker = cluster.fork();
-  worker.send(<span class="hljs-string">'hi there'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-keyword">const</span> worker = cluster.<span class="hljs-title function_">fork</span>();
+  worker.<span class="hljs-title function_">send</span>(<span class="hljs-string">'hi there'</span>);
 
-} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.isWorker) {
-  process.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
-    process.send(msg);
+} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isWorker</span>) {
+  process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg</span>) =></span> {
+    process.<span class="hljs-title function_">send</span>(msg);
   });
 }</code></pre>
-<h2>Event: <code>'disconnect'</code><span><a class="mark" href="#cluster_event_disconnect_1" id="cluster_event_disconnect_1">#</a></span></h2>
+</section><section><h3>Event: <code>'disconnect'</code><span><a class="mark" href="#cluster_event_disconnect_1" id="cluster_event_disconnect_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.9</span>
 </div>
@@ -602,10 +614,10 @@ worker exits gracefully, is killed, or is disconnected manually (such as with
 <p>There may be a delay between the <code>'disconnect'</code> and <code>'exit'</code> events. These
 events can be used to detect if the process is stuck in a cleanup or if there
 are long-living connections.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The worker #<span class="hljs-subst">${worker.id}</span> has disconnected`</span>);
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The worker #<span class="hljs-subst">${worker.id}</span> has disconnected`</span>);
 });</code></pre>
-<h2>Event: <code>'exit'</code><span><a class="mark" href="#cluster_event_exit_1" id="cluster_event_exit_1">#</a></span></h2>
+</section><section><h3>Event: <code>'exit'</code><span><a class="mark" href="#cluster_event_exit_1" id="cluster_event_exit_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.9</span>
 </div>
@@ -617,13 +629,13 @@ the process to be killed.</li>
 </ul>
 <p>When any of the workers die the cluster module will emit the <code>'exit'</code> event.</p>
 <p>This can be used to restart the worker by calling <a href="#cluster_cluster_fork_env"><code>.fork()</code></a> again.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'worker %d died (%s). restarting...'</span>,
-              worker.process.pid, signal || code);
-  cluster.fork();
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'worker %d died (%s). restarting...'</span>,
+              worker.<span class="hljs-property">process</span>.<span class="hljs-property">pid</span>, signal || code);
+  cluster.<span class="hljs-title function_">fork</span>();
 });</code></pre>
 <p>See <a href="child_process.html#child_process_event_exit"><code>child_process</code> event: <code>'exit'</code></a>.</p>
-<h2>Event: <code>'fork'</code><span><a class="mark" href="#cluster_event_fork" id="cluster_event_fork">#</a></span></h2>
+</section><section><h3>Event: <code>'fork'</code><span><a class="mark" href="#cluster_event_fork" id="cluster_event_fork">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -633,21 +645,21 @@ the process to be killed.</li>
 <p>When a new worker is forked the cluster module will emit a <code>'fork'</code> event.
 This can be used to log worker activity, and create a custom timeout.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> timeouts = [];
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">errorMsg</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Something must be wrong with the connection ...'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">errorMsg</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Something must be wrong with the connection ...'</span>);
 }
 
-cluster.on(<span class="hljs-string">'fork'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-  timeouts[worker.id] = <span class="hljs-built_in">setTimeout</span>(errorMsg, <span class="hljs-number">2000</span>);
+cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'fork'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+  timeouts[worker.<span class="hljs-property">id</span>] = <span class="hljs-built_in">setTimeout</span>(errorMsg, <span class="hljs-number">2000</span>);
 });
-cluster.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">worker, address</span>) =></span> {
-  <span class="hljs-built_in">clearTimeout</span>(timeouts[worker.id]);
+cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">worker, address</span>) =></span> {
+  <span class="hljs-built_in">clearTimeout</span>(timeouts[worker.<span class="hljs-property">id</span>]);
 });
-cluster.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
-  <span class="hljs-built_in">clearTimeout</span>(timeouts[worker.id]);
-  errorMsg();
+cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">worker, code, signal</span>) =></span> {
+  <span class="hljs-built_in">clearTimeout</span>(timeouts[worker.<span class="hljs-property">id</span>]);
+  <span class="hljs-title function_">errorMsg</span>();
 });</code></pre>
-<h2>Event: <code>'listening'</code><span><a class="mark" href="#cluster_event_listening_1" id="cluster_event_listening_1">#</a></span></h2>
+</section><section><h3>Event: <code>'listening'</code><span><a class="mark" href="#cluster_event_listening_1" id="cluster_event_listening_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -662,8 +674,8 @@ master.</p>
 worker object and the <code>address</code> object contains the following connection
 properties: <code>address</code>, <code>port</code> and <code>addressType</code>. This is very useful if the
 worker is listening on more than one address.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">worker, address</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">(<span class="hljs-params">worker, address</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
     <span class="hljs-string">`A worker is now connected to <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
 });</code></pre>
 <p>The <code>addressType</code> is one of:</p>
@@ -673,7 +685,7 @@ worker is listening on more than one address.</p>
 <li><code>-1</code> (Unix domain socket)</li>
 <li><code>'udp4'</code> or <code>'udp6'</code> (UDP v4 or v6)</li>
 </ul>
-<h2>Event: <code>'message'</code><span><a class="mark" href="#cluster_event_message_1" id="cluster_event_message_1">#</a></span></h2>
+</section><section><h3>Event: <code>'message'</code><span><a class="mark" href="#cluster_event_message_1" id="cluster_event_message_1">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -692,7 +704,7 @@ worker is listening on more than one address.</p>
 </ul>
 <p>Emitted when the cluster master receives a message from any worker.</p>
 <p>See <a href="child_process.html#child_process_event_message"><code>child_process</code> event: <code>'message'</code></a>.</p>
-<h2>Event: <code>'online'</code><span><a class="mark" href="#cluster_event_online_1" id="cluster_event_online_1">#</a></span></h2>
+</section><section><h3>Event: <code>'online'</code><span><a class="mark" href="#cluster_event_online_1" id="cluster_event_online_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -703,10 +715,10 @@ worker is listening on more than one address.</p>
 When the master receives an online message it will emit this event.
 The difference between <code>'fork'</code> and <code>'online'</code> is that fork is emitted when the
 master forks a worker, and <code>'online'</code> is emitted when the worker is running.</p>
-<pre><code class="language-js">cluster.on(<span class="hljs-string">'online'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Yay, the worker responded after it was forked'</span>);
+<pre><code class="language-js">cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'online'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Yay, the worker responded after it was forked'</span>);
 });</code></pre>
-<h2>Event: <code>'setup'</code><span><a class="mark" href="#cluster_event_setup" id="cluster_event_setup">#</a></span></h2>
+</section><section><h3>Event: <code>'setup'</code><span><a class="mark" href="#cluster_event_setup" id="cluster_event_setup">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.1</span>
 </div>
@@ -718,7 +730,7 @@ master forks a worker, and <code>'online'</code> is emitted when the worker is r
 <a href="#cluster_cluster_setupmaster_settings"><code>.setupMaster()</code></a> was called and is advisory only, since multiple calls to
 <a href="#cluster_cluster_setupmaster_settings"><code>.setupMaster()</code></a> can be made in a single tick.</p>
 <p>If accuracy is important, use <code>cluster.settings</code>.</p>
-<h2><code>cluster.disconnect([callback])</code><span><a class="mark" href="#cluster_cluster_disconnect_callback" id="cluster_cluster_disconnect_callback">#</a></span></h2>
+</section><section><h3><code>cluster.disconnect([callback])</code><span><a class="mark" href="#cluster_cluster_disconnect_callback" id="cluster_cluster_disconnect_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -732,7 +744,7 @@ master process to die gracefully if no other event is waiting.</p>
 <p>The method takes an optional callback argument which will be called when
 finished.</p>
 <p>This can only be called from the master process.</p>
-<h2><code>cluster.fork([env])</code><span><a class="mark" href="#cluster_cluster_fork_env" id="cluster_cluster_fork_env">#</a></span></h2>
+</section><section><h3><code>cluster.fork([env])</code><span><a class="mark" href="#cluster_cluster_fork_env" id="cluster_cluster_fork_env">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span>
 </div>
@@ -742,7 +754,7 @@ finished.</p>
 </ul>
 <p>Spawn a new worker process.</p>
 <p>This can only be called from the master process.</p>
-<h2><code>cluster.isMaster</code><span><a class="mark" href="#cluster_cluster_ismaster" id="cluster_cluster_ismaster">#</a></span></h2>
+</section><section><h3><code>cluster.isMaster</code><span><a class="mark" href="#cluster_cluster_ismaster" id="cluster_cluster_ismaster">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.8.1</span>
 </div>
@@ -752,7 +764,7 @@ finished.</p>
 <p>True if the process is a master. This is determined
 by the <code>process.env.NODE_UNIQUE_ID</code>. If <code>process.env.NODE_UNIQUE_ID</code> is
 undefined, then <code>isMaster</code> is <code>true</code>.</p>
-<h2><code>cluster.isWorker</code><span><a class="mark" href="#cluster_cluster_isworker" id="cluster_cluster_isworker">#</a></span></h2>
+</section><section><h3><code>cluster.isWorker</code><span><a class="mark" href="#cluster_cluster_isworker" id="cluster_cluster_isworker">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span>
 </div>
@@ -760,7 +772,7 @@ undefined, then <code>isMaster</code> is <code>true</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>True if the process is not a master (it is the negation of <code>cluster.isMaster</code>).</p>
-<h2><code>cluster.schedulingPolicy</code><span><a class="mark" href="#cluster_cluster_schedulingpolicy" id="cluster_cluster_schedulingpolicy">#</a></span></h2>
+</section><section><h3><code>cluster.schedulingPolicy</code><span><a class="mark" href="#cluster_cluster_schedulingpolicy" id="cluster_cluster_schedulingpolicy">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -774,12 +786,12 @@ distribute IOCP handles without incurring a large performance hit.</p>
 <p><code>cluster.schedulingPolicy</code> can also be set through the
 <code>NODE_CLUSTER_SCHED_POLICY</code> environment variable. Valid
 values are <code>'rr'</code> and <code>'none'</code>.</p>
-<h2><code>cluster.settings</code><span><a class="mark" href="#cluster_cluster_settings" id="cluster_cluster_settings">#</a></span></h2>
+</section><section><h3><code>cluster.settings</code><span><a class="mark" href="#cluster_cluster_settings" id="cluster_cluster_settings">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.2.0, v12.16.0</td>
 <td><p>The <code>serialization</code> option is supported now.</p></td></tr>
 <tr><td>v9.5.0</td>
 <td><p>The <code>cwd</code> option is supported now.</p></td></tr>
@@ -827,7 +839,7 @@ normally be created on Windows systems. <strong>Default:</strong> <code>false</c
 <p>After calling <a href="#cluster_cluster_setupmaster_settings"><code>.setupMaster()</code></a> (or <a href="#cluster_cluster_fork_env"><code>.fork()</code></a>) this settings object will
 contain the settings, including the default values.</p>
 <p>This object is not intended to be changed or set manually.</p>
-<h2><code>cluster.setupMaster([settings])</code><span><a class="mark" href="#cluster_cluster_setupmaster_settings" id="cluster_cluster_setupmaster_settings">#</a></span></h2>
+</section><section><h3><code>cluster.setupMaster([settings])</code><span><a class="mark" href="#cluster_cluster_setupmaster_settings" id="cluster_cluster_setupmaster_settings">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -851,19 +863,19 @@ the <code>env</code> passed to <a href="#cluster_cluster_fork_env"><code>.fork()
 <p>The defaults above apply to the first call only; the defaults for later
 calls are the current values at the time of <code>cluster.setupMaster()</code> is called.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
-cluster.setupMaster({
+cluster.<span class="hljs-title function_">setupMaster</span>({
   <span class="hljs-attr">exec</span>: <span class="hljs-string">'worker.js'</span>,
   <span class="hljs-attr">args</span>: [<span class="hljs-string">'--use'</span>, <span class="hljs-string">'https'</span>],
   <span class="hljs-attr">silent</span>: <span class="hljs-literal">true</span>
 });
-cluster.fork(); <span class="hljs-comment">// https worker</span>
-cluster.setupMaster({
+cluster.<span class="hljs-title function_">fork</span>(); <span class="hljs-comment">// https worker</span>
+cluster.<span class="hljs-title function_">setupMaster</span>({
   <span class="hljs-attr">exec</span>: <span class="hljs-string">'worker.js'</span>,
   <span class="hljs-attr">args</span>: [<span class="hljs-string">'--use'</span>, <span class="hljs-string">'http'</span>]
 });
-cluster.fork(); <span class="hljs-comment">// http worker</span></code></pre>
+cluster.<span class="hljs-title function_">fork</span>(); <span class="hljs-comment">// http worker</span></code></pre>
 <p>This can only be called from the master process.</p>
-<h2><code>cluster.worker</code><span><a class="mark" href="#cluster_cluster_worker" id="cluster_cluster_worker">#</a></span></h2>
+</section><section><h3><code>cluster.worker</code><span><a class="mark" href="#cluster_cluster_worker" id="cluster_cluster_worker">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -873,14 +885,14 @@ cluster.fork(); <span class="hljs-comment">// http worker</span></code></pre>
 <p>A reference to the current worker object. Not available in the master process.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'I am master'</span>);
-  cluster.fork();
-  cluster.fork();
-} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.isWorker) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`I am worker #<span class="hljs-subst">${cluster.worker.id}</span>`</span>);
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'I am master'</span>);
+  cluster.<span class="hljs-title function_">fork</span>();
+  cluster.<span class="hljs-title function_">fork</span>();
+} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isWorker</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`I am worker #<span class="hljs-subst">${cluster.worker.id}</span>`</span>);
 }</code></pre>
-<h2><code>cluster.workers</code><span><a class="mark" href="#cluster_cluster_workers" id="cluster_cluster_workers">#</a></span></h2>
+</section><section><h3><code>cluster.workers</code><span><a class="mark" href="#cluster_cluster_workers" id="cluster_cluster_workers">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -895,21 +907,57 @@ process.</p>
 advance. However, it is guaranteed that the removal from the <code>cluster.workers</code>
 list happens before last <code>'disconnect'</code> or <code>'exit'</code> event is emitted.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Go through all workers</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">eachWorker</span>(<span class="hljs-params">callback</span>) </span>{
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> id <span class="hljs-keyword">in</span> cluster.workers) {
-    callback(cluster.workers[id]);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">eachWorker</span>(<span class="hljs-params">callback</span>) {
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> id <span class="hljs-keyword">in</span> cluster.<span class="hljs-property">workers</span>) {
+    <span class="hljs-title function_">callback</span>(cluster.<span class="hljs-property">workers</span>[id]);
   }
 }
-eachWorker(<span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-  worker.send(<span class="hljs-string">'big announcement to all workers'</span>);
+<span class="hljs-title function_">eachWorker</span>(<span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+  worker.<span class="hljs-title function_">send</span>(<span class="hljs-string">'big announcement to all workers'</span>);
 });</code></pre>
 <p>Using the worker's unique id is the easiest way to locate the worker.</p>
-<pre><code class="language-js">socket.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">id</span>) =></span> {
-  <span class="hljs-keyword">const</span> worker = cluster.workers[id];
-});</code></pre>
+<pre><code class="language-js">socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">id</span>) =></span> {
+  <span class="hljs-keyword">const</span> worker = cluster.<span class="hljs-property">workers</span>[id];
+});</code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/cluster.json b/doc/api/cluster.json
index 03fb922476a2673abd340e9e9c9195383b32ab6c..ebe263d328a33295340b2b8845a5f6f601e964e2 100644
--- a/doc/api/cluster.json
+++ b/doc/api/cluster.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/cluster.js\">lib/cluster.js</a></p>\n<p>A single instance of Node.js runs in a single thread. To take advantage of\nmulti-core systems, the user will sometimes want to launch a cluster of Node.js\nprocesses to handle the load.</p>\n<p>The cluster module allows easy creation of child processes that all share\nserver ports.</p>\n<pre><code class=\"language-js\">const cluster = require('cluster');\nconst http = require('http');\nconst numCPUs = require('os').cpus().length;\n\nif (cluster.isMaster) {\n  console.log(`Master ${process.pid} is running`);\n\n  // Fork workers.\n  for (let i = 0; i &#x3C; numCPUs; i++) {\n    cluster.fork();\n  }\n\n  cluster.on('exit', (worker, code, signal) => {\n    console.log(`worker ${worker.process.pid} died`);\n  });\n} else {\n  // Workers can share any TCP connection\n  // In this case it is an HTTP server\n  http.createServer((req, res) => {\n    res.writeHead(200);\n    res.end('hello world\\n');\n  }).listen(8000);\n\n  console.log(`Worker ${process.pid} started`);\n}\n</code></pre>\n<p>Running Node.js will now share port 8000 between the workers:</p>\n<pre><code class=\"language-console\">$ node server.js\nMaster 3596 is running\nWorker 4324 started\nWorker 4520 started\nWorker 6056 started\nWorker 5644 started\n</code></pre>\n<p>On Windows, it is not yet possible to set up a named pipe server in a worker.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/cluster.js\">lib/cluster.js</a></p>\n<p>A single instance of Node.js runs in a single thread. To take advantage of\nmulti-core systems, the user will sometimes want to launch a cluster of Node.js\nprocesses to handle the load.</p>\n<p>The cluster module allows easy creation of child processes that all share\nserver ports.</p>\n<pre><code class=\"language-js\">const cluster = require('cluster');\nconst http = require('http');\nconst numCPUs = require('os').cpus().length;\n\nif (cluster.isMaster) {\n  console.log(`Master ${process.pid} is running`);\n\n  // Fork workers.\n  for (let i = 0; i &#x3C; numCPUs; i++) {\n    cluster.fork();\n  }\n\n  cluster.on('exit', (worker, code, signal) => {\n    console.log(`worker ${worker.process.pid} died`);\n  });\n} else {\n  // Workers can share any TCP connection\n  // In this case it is an HTTP server\n  http.createServer((req, res) => {\n    res.writeHead(200);\n    res.end('hello world\\n');\n  }).listen(8000);\n\n  console.log(`Worker ${process.pid} started`);\n}\n</code></pre>\n<p>Running Node.js will now share port 8000 between the workers:</p>\n<pre><code class=\"language-console\">$ node server.js\nMaster 3596 is running\nWorker 4324 started\nWorker 4520 started\nWorker 6056 started\nWorker 5644 started\n</code></pre>\n<p>On Windows, it is not yet possible to set up a named pipe server in a worker.</p>",
       "miscs": [
         {
           "textRaw": "How it works",
@@ -626,7 +626,10 @@
             ],
             "changes": [
               {
-                "version": "v12.16.0",
+                "version": [
+                  "v13.2.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/30162",
                 "description": "The `serialization` option is supported now."
               },
diff --git a/doc/api/cluster.md b/doc/api/cluster.md
index e913bdcd954e9c8ca245a7e0360e507eb53214fa..0b3586d10cd4392b8c8a073d358cc62152bf1f4f 100644
--- a/doc/api/cluster.md
+++ b/doc/api/cluster.md
@@ -726,7 +726,9 @@ values are `'rr'` and `'none'`.
 <!-- YAML
 added: v0.7.1
 changes:
-  - version: v12.16.0
+  - version:
+     - v13.2.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30162
     description: The `serialization` option is supported now.
   - version: v9.5.0
@@ -871,17 +873,17 @@ socket.on('data', (id) => {
 });
 ```
 
+[Advanced serialization for `child_process`]: child_process.md#child_process_advanced_serialization
+[Child Process module]: child_process.md#child_process_child_process_fork_modulepath_args_options
 [`.fork()`]: #cluster_cluster_fork_env
 [`.setupMaster()`]: #cluster_cluster_setupmaster_settings
-[`ChildProcess.send()`]: child_process.html#child_process_subprocess_send_message_sendhandle_options_callback
-[`child_process.fork()`]: child_process.html#child_process_child_process_fork_modulepath_args_options
-[`child_process` event: `'exit'`]: child_process.html#child_process_event_exit
-[`child_process` event: `'message'`]: child_process.html#child_process_event_message
+[`ChildProcess.send()`]: child_process.md#child_process_subprocess_send_message_sendhandle_options_callback
+[`child_process.fork()`]: child_process.md#child_process_child_process_fork_modulepath_args_options
+[`child_process` event: `'exit'`]: child_process.md#child_process_event_exit
+[`child_process` event: `'message'`]: child_process.md#child_process_event_message
 [`cluster.settings`]: #cluster_cluster_settings
-[`disconnect()`]: child_process.html#child_process_subprocess_disconnect
-[`kill()`]: process.html#process_process_kill_pid_signal
-[`process` event: `'message'`]: process.html#process_event_message
-[`server.close()`]: net.html#net_event_close
+[`disconnect()`]: child_process.md#child_process_subprocess_disconnect
+[`kill()`]: process.md#process_process_kill_pid_signal
+[`process` event: `'message'`]: process.md#process_event_message
+[`server.close()`]: net.md#net_event_close
 [`worker.exitedAfterDisconnect`]: #cluster_worker_exitedafterdisconnect
-[Advanced serialization for `child_process`]: child_process.html#child_process_advanced_serialization
-[Child Process module]: child_process.html#child_process_child_process_fork_modulepath_args_options
diff --git a/doc/api/console.html b/doc/api/console.html
index 72c8f5de4223b7c2cd84a67273bc3699cad3af6d..4c631a7a3f682b94600acc0c66917f658efcc1e5 100644
--- a/doc/api/console.html
+++ b/doc/api/console.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Console | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Console | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console active">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="console" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/console.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/console.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/console.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/console.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/console.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/console.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/console.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/console.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/console.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#console_console">Console</a></span>
 <ul>
 <li><a href="#console_class_console">Class: <code>Console</code></a>
@@ -163,14 +176,13 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Console<span><a class="mark" href="#console_console" id="console_console">#</a></span></h1>
+        <h2>Console<span><a class="mark" href="#console_console" id="console_console">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/console.js">lib/console.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/console.js">lib/console.js</a></p>
 <p>The <code>console</code> module provides a simple debugging console that is similar to the
 JavaScript console mechanism provided by web browsers.</p>
 <p>The module exports two specific components:</p>
@@ -181,37 +193,45 @@ JavaScript console mechanism provided by web browsers.</p>
 <a href="process.html#process_process_stderr"><code>process.stderr</code></a>. The global <code>console</code> can be used without calling
 <code>require('console')</code>.</li>
 </ul>
-<p><strong><em>Warning</em></strong>: The global console object's methods are neither consistently
+<p><em><strong>Warning</strong></em>: The global console object's methods are neither consistently
 synchronous like the browser APIs they resemble, nor are they consistently
 asynchronous like all other Node.js streams. See the <a href="process.html#process_a_note_on_process_i_o">note on process I/O</a> for
 more information.</p>
 <p>Example using the global <code>console</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'hello world'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello world'</span>);
 <span class="hljs-comment">// Prints: hello world, to stdout</span>
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'hello %s'</span>, <span class="hljs-string">'world'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello %s'</span>, <span class="hljs-string">'world'</span>);
 <span class="hljs-comment">// Prints: hello world, to stdout</span>
-<span class="hljs-built_in">console</span>.error(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Whoops, something bad happened'</span>));
-<span class="hljs-comment">// Prints: [Error: Whoops, something bad happened], to stderr</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Whoops, something bad happened'</span>));
+<span class="hljs-comment">// Prints error message and stack trace to stderr:</span>
+<span class="hljs-comment">//   Error: Whoops, something bad happened</span>
+<span class="hljs-comment">//     at [eval]:5:15</span>
+<span class="hljs-comment">//     at Script.runInThisContext (node:vm:132:18)</span>
+<span class="hljs-comment">//     at Object.runInThisContext (node:vm:309:38)</span>
+<span class="hljs-comment">//     at node:internal/process/execution:77:19</span>
+<span class="hljs-comment">//     at [eval]-wrapper:6:22</span>
+<span class="hljs-comment">//     at evalScript (node:internal/process/execution:76:60)</span>
+<span class="hljs-comment">//     at node:internal/main/eval_string:23:3</span>
 
 <span class="hljs-keyword">const</span> name = <span class="hljs-string">'Will Robinson'</span>;
-<span class="hljs-built_in">console</span>.warn(<span class="hljs-string">`Danger <span class="hljs-subst">${name}</span>! Danger!`</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(<span class="hljs-string">`Danger <span class="hljs-subst">${name}</span>! Danger!`</span>);
 <span class="hljs-comment">// Prints: Danger Will Robinson! Danger!, to stderr</span></code></pre>
 <p>Example using the <code>Console</code> class:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> out = getStreamSomehow();
-<span class="hljs-keyword">const</span> err = getStreamSomehow();
-<span class="hljs-keyword">const</span> myConsole = <span class="hljs-keyword">new</span> <span class="hljs-built_in">console</span>.Console(out, err);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> out = <span class="hljs-title function_">getStreamSomehow</span>();
+<span class="hljs-keyword">const</span> err = <span class="hljs-title function_">getStreamSomehow</span>();
+<span class="hljs-keyword">const</span> myConsole = <span class="hljs-keyword">new</span> <span class="hljs-variable language_">console</span>.<span class="hljs-title class_">Console</span>(out, err);
 
-myConsole.log(<span class="hljs-string">'hello world'</span>);
+myConsole.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello world'</span>);
 <span class="hljs-comment">// Prints: hello world, to out</span>
-myConsole.log(<span class="hljs-string">'hello %s'</span>, <span class="hljs-string">'world'</span>);
+myConsole.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello %s'</span>, <span class="hljs-string">'world'</span>);
 <span class="hljs-comment">// Prints: hello world, to out</span>
-myConsole.error(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Whoops, something bad happened'</span>));
+myConsole.<span class="hljs-title function_">error</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Whoops, something bad happened'</span>));
 <span class="hljs-comment">// Prints: [Error: Whoops, something bad happened], to err</span>
 
 <span class="hljs-keyword">const</span> name = <span class="hljs-string">'Will Robinson'</span>;
-myConsole.warn(<span class="hljs-string">`Danger <span class="hljs-subst">${name}</span>! Danger!`</span>);
+myConsole.<span class="hljs-title function_">warn</span>(<span class="hljs-string">`Danger <span class="hljs-subst">${name}</span>! Danger!`</span>);
 <span class="hljs-comment">// Prints: Danger Will Robinson! Danger!, to err</span></code></pre>
-<h2>Class: <code>Console</code><span><a class="mark" href="#console_class_console" id="console_class_console">#</a></span></h2>
+<section><h3>Class: <code>Console</code><span><a class="mark" href="#console_class_console" id="console_class_console">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -225,15 +245,15 @@ myConsole.warn(<span class="hljs-string">`Danger <span class="hljs-subst">${name
 <p>The <code>Console</code> class can be used to create a simple logger with configurable
 output streams and can be accessed using either <code>require('console').Console</code>
 or <code>console.Console</code> (or their destructured counterparts):</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Console } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'console'</span>);</code></pre>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Console } = <span class="hljs-built_in">console</span>;</code></pre>
-<h3><code>new Console(stdout[, stderr][, ignoreErrors])</code><span><a class="mark" href="#console_new_console_stdout_stderr_ignoreerrors" id="console_new_console_stdout_stderr_ignoreerrors">#</a></span></h3>
-<h3><code>new Console(options)</code><span><a class="mark" href="#console_new_console_options" id="console_new_console_options">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Console</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'console'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Console</span> } = <span class="hljs-variable language_">console</span>;</code></pre>
+<h4><code>new Console(stdout[, stderr][, ignoreErrors])</code><span><a class="mark" href="#console_new_console_stdout_stderr_ignoreerrors" id="console_new_console_stdout_stderr_ignoreerrors">#</a></span></h4>
+<h4><code>new Console(options)</code><span><a class="mark" href="#console_new_console_options" id="console_new_console_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.2.0</td>
 <td><p>The <code>groupIndentation</code> option was introduced.</p></td></tr>
 <tr><td>v11.7.0</td>
 <td><p>The <code>inspectOptions</code> option is introduced.</p></td></tr>
@@ -268,18 +288,18 @@ option can not be used, if <code>inspectOptions.colors</code> is set as well.
 <p>Creates a new <code>Console</code> with one or two writable stream instances. <code>stdout</code> is a
 writable stream to print log or info output. <code>stderr</code> is used for warning or
 error output. If <code>stderr</code> is not provided, <code>stdout</code> is used for <code>stderr</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> output = fs.createWriteStream(<span class="hljs-string">'./stdout.log'</span>);
-<span class="hljs-keyword">const</span> errorOutput = fs.createWriteStream(<span class="hljs-string">'./stderr.log'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> output = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'./stdout.log'</span>);
+<span class="hljs-keyword">const</span> errorOutput = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'./stderr.log'</span>);
 <span class="hljs-comment">// Custom simple logger</span>
-<span class="hljs-keyword">const</span> logger = <span class="hljs-keyword">new</span> Console({ <span class="hljs-attr">stdout</span>: output, <span class="hljs-attr">stderr</span>: errorOutput });
+<span class="hljs-keyword">const</span> logger = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Console</span>({ <span class="hljs-attr">stdout</span>: output, <span class="hljs-attr">stderr</span>: errorOutput });
 <span class="hljs-comment">// use it like console</span>
 <span class="hljs-keyword">const</span> count = <span class="hljs-number">5</span>;
-logger.log(<span class="hljs-string">'count: %d'</span>, count);
+logger.<span class="hljs-title function_">log</span>(<span class="hljs-string">'count: %d'</span>, count);
 <span class="hljs-comment">// In stdout.log: count 5</span></code></pre>
 <p>The global <code>console</code> is a special <code>Console</code> whose output is sent to
 <a href="process.html#process_process_stdout"><code>process.stdout</code></a> and <a href="process.html#process_process_stderr"><code>process.stderr</code></a>. It is equivalent to calling:</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> Console({ <span class="hljs-attr">stdout</span>: process.stdout, <span class="hljs-attr">stderr</span>: process.stderr });</code></pre>
-<h3><code>console.assert(value[, ...message])</code><span><a class="mark" href="#console_console_assert_value_message" id="console_console_assert_value_message">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">new</span> <span class="hljs-title class_">Console</span>({ <span class="hljs-attr">stdout</span>: process.<span class="hljs-property">stdout</span>, <span class="hljs-attr">stderr</span>: process.<span class="hljs-property">stderr</span> });</code></pre>
+<h4><code>console.assert(value[, ...message])</code><span><a class="mark" href="#console_console_assert_value_message" id="console_console_assert_value_message">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -300,14 +320,14 @@ writes a message and does not otherwise affect execution. The output always
 starts with <code>"Assertion failed"</code>. If provided, <code>message</code> is formatted using
 <a href="util.html#util_util_format_format_args"><code>util.format()</code></a>.</p>
 <p>If <code>value</code> is <a href="https://developer.mozilla.org/en-US/docs/Glossary/Truthy">truthy</a>, nothing happens.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.assert(<span class="hljs-literal">true</span>, <span class="hljs-string">'does nothing'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">assert</span>(<span class="hljs-literal">true</span>, <span class="hljs-string">'does nothing'</span>);
 
-<span class="hljs-built_in">console</span>.assert(<span class="hljs-literal">false</span>, <span class="hljs-string">'Whoops %s work'</span>, <span class="hljs-string">'didn\'t'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">assert</span>(<span class="hljs-literal">false</span>, <span class="hljs-string">'Whoops %s work'</span>, <span class="hljs-string">'didn\'t'</span>);
 <span class="hljs-comment">// Assertion failed: Whoops didn't work</span>
 
-<span class="hljs-built_in">console</span>.assert();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">assert</span>();
 <span class="hljs-comment">// Assertion failed</span></code></pre>
-<h3><code>console.clear()</code><span><a class="mark" href="#console_console_clear" id="console_console_clear">#</a></span></h3>
+<h4><code>console.clear()</code><span><a class="mark" href="#console_console_clear" id="console_console_clear">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
@@ -318,7 +338,7 @@ and terminal types. For most Linux operating systems, <code>console.clear()</cod
 operates similarly to the <code>clear</code> shell command. On Windows, <code>console.clear()</code>
 will clear only the output in the current terminal viewport for the Node.js
 binary.</p>
-<h3><code>console.count([label])</code><span><a class="mark" href="#console_console_count_label" id="console_console_count_label">#</a></span></h3>
+<h4><code>console.count([label])</code><span><a class="mark" href="#console_console_count_label" id="console_console_count_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
@@ -328,26 +348,26 @@ binary.</p>
 <p>Maintains an internal counter specific to <code>label</code> and outputs to <code>stdout</code> the
 number of times <code>console.count()</code> has been called with the given <code>label</code>.</p>
 <!-- eslint-skip -->
-<pre><code class="language-js">> <span class="hljs-built_in">console</span>.count()
+<pre><code class="language-js">> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>()
 <span class="hljs-attr">default</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'default'</span>)
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'default'</span>)
 <span class="hljs-attr">default</span>: <span class="hljs-number">2</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'abc'</span>)
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'abc'</span>)
 <span class="hljs-attr">abc</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'xyz'</span>)
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'xyz'</span>)
 <span class="hljs-attr">xyz</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'abc'</span>)
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'abc'</span>)
 <span class="hljs-attr">abc</span>: <span class="hljs-number">2</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count()
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>()
 <span class="hljs-attr">default</span>: <span class="hljs-number">3</span>
 <span class="hljs-literal">undefined</span>
 ></code></pre>
-<h3><code>console.countReset([label])</code><span><a class="mark" href="#console_console_countreset_label" id="console_console_countreset_label">#</a></span></h3>
+<h4><code>console.countReset([label])</code><span><a class="mark" href="#console_console_countreset_label" id="console_console_countreset_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
@@ -356,16 +376,16 @@ number of times <code>console.count()</code> has been called with the given <cod
 </ul>
 <p>Resets the internal counter specific to <code>label</code>.</p>
 <!-- eslint-skip -->
-<pre><code class="language-js">> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'abc'</span>);
-abc: <span class="hljs-number">1</span>
+<pre><code class="language-js">> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'abc'</span>);
+<span class="hljs-attr">abc</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.countReset(<span class="hljs-string">'abc'</span>);
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">countReset</span>(<span class="hljs-string">'abc'</span>);
 <span class="hljs-literal">undefined</span>
-> <span class="hljs-built_in">console</span>.count(<span class="hljs-string">'abc'</span>);
-abc: <span class="hljs-number">1</span>
+> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">count</span>(<span class="hljs-string">'abc'</span>);
+<span class="hljs-attr">abc</span>: <span class="hljs-number">1</span>
 <span class="hljs-literal">undefined</span>
 ></code></pre>
-<h3><code>console.debug(data[, ...args])</code><span><a class="mark" href="#console_console_debug_data_args" id="console_console_debug_data_args">#</a></span></h3>
+<h4><code>console.debug(data[, ...args])</code><span><a class="mark" href="#console_console_debug_data_args" id="console_console_debug_data_args">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -382,7 +402,7 @@ abc: <span class="hljs-number">1</span>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
 <p>The <code>console.debug()</code> function is an alias for <a href="#console_console_log_data_args"><code>console.log()</code></a>.</p>
-<h3><code>console.dir(obj[, options])</code><span><a class="mark" href="#console_console_dir_obj_options" id="console_console_dir_obj_options">#</a></span></h3>
+<h4><code>console.dir(obj[, options])</code><span><a class="mark" href="#console_console_dir_obj_options" id="console_console_dir_obj_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.101</span>
 </div>
@@ -403,7 +423,7 @@ see <a href="util.html#util_customizing_util_inspect_colors">customizing <code>u
 </ul>
 <p>Uses <a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a> on <code>obj</code> and prints the resulting string to <code>stdout</code>.
 This function bypasses any custom <code>inspect()</code> function defined on <code>obj</code>.</p>
-<h3><code>console.dirxml(...data)</code><span><a class="mark" href="#console_console_dirxml_data" id="console_console_dirxml_data">#</a></span></h3>
+<h4><code>console.dirxml(...data)</code><span><a class="mark" href="#console_console_dirxml_data" id="console_console_dirxml_data">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -420,7 +440,7 @@ This function bypasses any custom <code>inspect()</code> function defined on <co
 </ul>
 <p>This method calls <code>console.log()</code> passing it the arguments received.
 This method does not produce any XML formatting.</p>
-<h3><code>console.error([data][, ...args])</code><span><a class="mark" href="#console_console_error_data_args" id="console_console_error_data_args">#</a></span></h3>
+<h4><code>console.error([data][, ...args])</code><span><a class="mark" href="#console_console_error_data_args" id="console_console_error_data_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -433,14 +453,14 @@ first used as the primary message and all additional used as substitution
 values similar to <a href="http://man7.org/linux/man-pages/man3/printf.3.html"><code>printf(3)</code></a> (the arguments are all passed to
 <a href="util.html#util_util_format_format_args"><code>util.format()</code></a>).</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> code = <span class="hljs-number">5</span>;
-<span class="hljs-built_in">console</span>.error(<span class="hljs-string">'error #%d'</span>, code);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'error #%d'</span>, code);
 <span class="hljs-comment">// Prints: error #5, to stderr</span>
-<span class="hljs-built_in">console</span>.error(<span class="hljs-string">'error'</span>, code);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'error'</span>, code);
 <span class="hljs-comment">// Prints: error 5, to stderr</span></code></pre>
 <p>If formatting elements (e.g. <code>%d</code>) are not found in the first string then
 <a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a> is called on each argument and the resulting string
 values are concatenated. See <a href="util.html#util_util_format_format_args"><code>util.format()</code></a> for more information.</p>
-<h3><code>console.group([...label])</code><span><a class="mark" href="#console_console_group_label" id="console_console_group_label">#</a></span></h3>
+<h4><code>console.group([...label])</code><span><a class="mark" href="#console_console_group_label" id="console_console_group_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -451,18 +471,18 @@ values are concatenated. See <a href="util.html#util_util_format_format_args"><c
 length.</p>
 <p>If one or more <code>label</code>s are provided, those are printed first without the
 additional indentation.</p>
-<h3><code>console.groupCollapsed()</code><span><a class="mark" href="#console_console_groupcollapsed" id="console_console_groupcollapsed">#</a></span></h3>
+<h4><code>console.groupCollapsed()</code><span><a class="mark" href="#console_console_groupcollapsed" id="console_console_groupcollapsed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>An alias for <a href="#console_console_group_label"><code>console.group()</code></a>.</p>
-<h3><code>console.groupEnd()</code><span><a class="mark" href="#console_console_groupend" id="console_console_groupend">#</a></span></h3>
+<h4><code>console.groupEnd()</code><span><a class="mark" href="#console_console_groupend" id="console_console_groupend">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>Decreases indentation of subsequent lines by spaces for <code>groupIndentation</code>
 length.</p>
-<h3><code>console.info([data][, ...args])</code><span><a class="mark" href="#console_console_info_data_args" id="console_console_info_data_args">#</a></span></h3>
+<h4><code>console.info([data][, ...args])</code><span><a class="mark" href="#console_console_info_data_args" id="console_console_info_data_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -471,7 +491,7 @@ length.</p>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
 <p>The <code>console.info()</code> function is an alias for <a href="#console_console_log_data_args"><code>console.log()</code></a>.</p>
-<h3><code>console.log([data][, ...args])</code><span><a class="mark" href="#console_console_log_data_args" id="console_console_log_data_args">#</a></span></h3>
+<h4><code>console.log([data][, ...args])</code><span><a class="mark" href="#console_console_log_data_args" id="console_console_log_data_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -484,12 +504,12 @@ first used as the primary message and all additional used as substitution
 values similar to <a href="http://man7.org/linux/man-pages/man3/printf.3.html"><code>printf(3)</code></a> (the arguments are all passed to
 <a href="util.html#util_util_format_format_args"><code>util.format()</code></a>).</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> count = <span class="hljs-number">5</span>;
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'count: %d'</span>, count);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'count: %d'</span>, count);
 <span class="hljs-comment">// Prints: count: 5, to stdout</span>
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'count:'</span>, count);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'count:'</span>, count);
 <span class="hljs-comment">// Prints: count: 5, to stdout</span></code></pre>
 <p>See <a href="util.html#util_util_format_format_args"><code>util.format()</code></a> for more information.</p>
-<h3><code>console.table(tabularData[, properties])</code><span><a class="mark" href="#console_console_table_tabulardata_properties" id="console_console_table_tabulardata_properties">#</a></span></h3>
+<h4><code>console.table(tabularData[, properties])</code><span><a class="mark" href="#console_console_table_tabulardata_properties" id="console_console_table_tabulardata_properties">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -501,13 +521,13 @@ values similar to <a href="http://man7.org/linux/man-pages/man3/printf.3.html"><
 (or use <code>properties</code>) and rows of <code>tabularData</code> and log it. Falls back to just
 logging the argument if it can’t be parsed as tabular.</p>
 <pre><code class="language-js"><span class="hljs-comment">// These can't be parsed as tabular data</span>
-<span class="hljs-built_in">console</span>.table(<span class="hljs-built_in">Symbol</span>());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">table</span>(<span class="hljs-title class_">Symbol</span>());
 <span class="hljs-comment">// Symbol()</span>
 
-<span class="hljs-built_in">console</span>.table(<span class="hljs-literal">undefined</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">table</span>(<span class="hljs-literal">undefined</span>);
 <span class="hljs-comment">// undefined</span>
 
-<span class="hljs-built_in">console</span>.table([{ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span>, <span class="hljs-attr">b</span>: <span class="hljs-string">'Y'</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'Z'</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> }]);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">table</span>([{ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span>, <span class="hljs-attr">b</span>: <span class="hljs-string">'Y'</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'Z'</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> }]);
 <span class="hljs-comment">// ┌─────────┬─────┬─────┐</span>
 <span class="hljs-comment">// │ (index) │  a  │  b  │</span>
 <span class="hljs-comment">// ├─────────┼─────┼─────┤</span>
@@ -515,14 +535,14 @@ logging the argument if it can’t be parsed as tabular.</p>
 <span class="hljs-comment">// │    1    │ 'Z' │  2  │</span>
 <span class="hljs-comment">// └─────────┴─────┴─────┘</span>
 
-<span class="hljs-built_in">console</span>.table([{ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span>, <span class="hljs-attr">b</span>: <span class="hljs-string">'Y'</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'Z'</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> }], [<span class="hljs-string">'a'</span>]);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">table</span>([{ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span>, <span class="hljs-attr">b</span>: <span class="hljs-string">'Y'</span> }, { <span class="hljs-attr">a</span>: <span class="hljs-string">'Z'</span>, <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> }], [<span class="hljs-string">'a'</span>]);
 <span class="hljs-comment">// ┌─────────┬─────┐</span>
 <span class="hljs-comment">// │ (index) │  a  │</span>
 <span class="hljs-comment">// ├─────────┼─────┤</span>
 <span class="hljs-comment">// │    0    │  1  │</span>
 <span class="hljs-comment">// │    1    │ 'Z' │</span>
 <span class="hljs-comment">// └─────────┴─────┘</span></code></pre>
-<h3><code>console.time([label])</code><span><a class="mark" href="#console_console_time_label" id="console_console_time_label">#</a></span></h3>
+<h4><code>console.time([label])</code><span><a class="mark" href="#console_console_time_label" id="console_console_time_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.104</span>
 </div>
@@ -532,12 +552,15 @@ logging the argument if it can’t be parsed as tabular.</p>
 <p>Starts a timer that can be used to compute the duration of an operation. Timers
 are identified by a unique <code>label</code>. Use the same <code>label</code> when calling
 <a href="#console_console_timeend_label"><code>console.timeEnd()</code></a> to stop the timer and output the elapsed time in
-milliseconds to <code>stdout</code>. Timer durations are accurate to the sub-millisecond.</p>
-<h3><code>console.timeEnd([label])</code><span><a class="mark" href="#console_console_timeend_label" id="console_console_timeend_label">#</a></span></h3>
+suitable time units to <code>stdout</code>. For example, if the elapsed
+time is 3869ms, <code>console.timeEnd()</code> displays "3.869s".</p>
+<h4><code>console.timeEnd([label])</code><span><a class="mark" href="#console_console_timeend_label" id="console_console_timeend_label">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The elapsed time is displayed with a suitable time unit.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>This method no longer supports multiple calls that don’t map to individual <code>console.time()</code> calls; see below for details.</p></td></tr>
 <tr><td>v0.1.104</td>
@@ -550,11 +573,11 @@ milliseconds to <code>stdout</code>. Timer durations are accurate to the sub-mil
 </ul>
 <p>Stops a timer that was previously started by calling <a href="#console_console_time_label"><code>console.time()</code></a> and
 prints the result to <code>stdout</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.time(<span class="hljs-string">'100-elements'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">time</span>(<span class="hljs-string">'100-elements'</span>);
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">100</span>; i++) {}
-<span class="hljs-built_in">console</span>.timeEnd(<span class="hljs-string">'100-elements'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">timeEnd</span>(<span class="hljs-string">'100-elements'</span>);
 <span class="hljs-comment">// prints 100-elements: 225.438ms</span></code></pre>
-<h3><code>console.timeLog([label][, ...data])</code><span><a class="mark" href="#console_console_timelog_label_data" id="console_console_timelog_label_data">#</a></span></h3>
+<h4><code>console.timeLog([label][, ...data])</code><span><a class="mark" href="#console_console_timelog_label_data" id="console_console_timelog_label_data">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 </div>
@@ -564,13 +587,13 @@ prints the result to <code>stdout</code>:</p>
 </ul>
 <p>For a timer that was previously started by calling <a href="#console_console_time_label"><code>console.time()</code></a>, prints
 the elapsed time and other <code>data</code> arguments to <code>stdout</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.time(<span class="hljs-string">'process'</span>);
-<span class="hljs-keyword">const</span> value = expensiveProcess1(); <span class="hljs-comment">// Returns 42</span>
-<span class="hljs-built_in">console</span>.timeLog(<span class="hljs-string">'process'</span>, value);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">time</span>(<span class="hljs-string">'process'</span>);
+<span class="hljs-keyword">const</span> value = <span class="hljs-title function_">expensiveProcess1</span>(); <span class="hljs-comment">// Returns 42</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">timeLog</span>(<span class="hljs-string">'process'</span>, value);
 <span class="hljs-comment">// Prints "process: 365.227ms 42".</span>
-doExpensiveProcess2(value);
-<span class="hljs-built_in">console</span>.timeEnd(<span class="hljs-string">'process'</span>);</code></pre>
-<h3><code>console.trace([message][, ...args])</code><span><a class="mark" href="#console_console_trace_message_args" id="console_console_trace_message_args">#</a></span></h3>
+<span class="hljs-title function_">doExpensiveProcess2</span>(value);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">timeEnd</span>(<span class="hljs-string">'process'</span>);</code></pre>
+<h4><code>console.trace([message][, ...args])</code><span><a class="mark" href="#console_console_trace_message_args" id="console_console_trace_message_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.104</span>
 </div>
@@ -580,7 +603,7 @@ doExpensiveProcess2(value);
 </ul>
 <p>Prints to <code>stderr</code> the string <code>'Trace: '</code>, followed by the <a href="util.html#util_util_format_format_args"><code>util.format()</code></a>
 formatted message and stack trace to the current position in the code.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.trace(<span class="hljs-string">'Show me'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">trace</span>(<span class="hljs-string">'Show me'</span>);
 <span class="hljs-comment">// Prints: (stack trace will vary based on where trace is called)</span>
 <span class="hljs-comment">//  Trace: Show me</span>
 <span class="hljs-comment">//    at repl:2:9</span>
@@ -593,7 +616,7 @@ formatted message and stack trace to the current position in the code.</p>
 <span class="hljs-comment">//    at REPLServer.Interface._onLine (readline.js:210:10)</span>
 <span class="hljs-comment">//    at REPLServer.Interface._line (readline.js:549:8)</span>
 <span class="hljs-comment">//    at REPLServer.Interface._ttyWrite (readline.js:826:14)</span></code></pre>
-<h3><code>console.warn([data][, ...args])</code><span><a class="mark" href="#console_console_warn_data_args" id="console_console_warn_data_args">#</a></span></h3>
+<h4><code>console.warn([data][, ...args])</code><span><a class="mark" href="#console_console_warn_data_args" id="console_console_warn_data_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -602,11 +625,11 @@ formatted message and stack trace to the current position in the code.</p>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
 <p>The <code>console.warn()</code> function is an alias for <a href="#console_console_error_data_args"><code>console.error()</code></a>.</p>
-<h2>Inspector only methods<span><a class="mark" href="#console_inspector_only_methods" id="console_inspector_only_methods">#</a></span></h2>
+</section><section><h3>Inspector only methods<span><a class="mark" href="#console_inspector_only_methods" id="console_inspector_only_methods">#</a></span></h3>
 <p>The following methods are exposed by the V8 engine in the general API but do
 not display anything unless used in conjunction with the <a href="debugger.html">inspector</a>
 (<code>--inspect</code> flag).</p>
-<h3><code>console.profile([label])</code><span><a class="mark" href="#console_console_profile_label" id="console_console_profile_label">#</a></span></h3>
+<h4><code>console.profile([label])</code><span><a class="mark" href="#console_console_profile_label" id="console_console_profile_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -617,11 +640,11 @@ not display anything unless used in conjunction with the <a href="debugger.html"
 <code>console.profile()</code> method starts a JavaScript CPU profile with an optional
 label until <a href="#console_console_profileend_label"><code>console.profileEnd()</code></a> is called. The profile is then added to
 the <strong>Profile</strong> panel of the inspector.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.profile(<span class="hljs-string">'MyLabel'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">profile</span>(<span class="hljs-string">'MyLabel'</span>);
 <span class="hljs-comment">// Some code</span>
-<span class="hljs-built_in">console</span>.profileEnd(<span class="hljs-string">'MyLabel'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">profileEnd</span>(<span class="hljs-string">'MyLabel'</span>);
 <span class="hljs-comment">// Adds the profile 'MyLabel' to the Profiles panel of the inspector.</span></code></pre>
-<h3><code>console.profileEnd([label])</code><span><a class="mark" href="#console_console_profileend_label" id="console_console_profileend_label">#</a></span></h3>
+<h4><code>console.profileEnd([label])</code><span><a class="mark" href="#console_console_profileend_label" id="console_console_profileend_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -634,7 +657,7 @@ the report to the <strong>Profiles</strong> panel of the inspector. See
 <a href="#console_console_profile_label"><code>console.profile()</code></a> for an example.</p>
 <p>If this method is called without a label, the most recently started profile is
 stopped.</p>
-<h3><code>console.timeStamp([label])</code><span><a class="mark" href="#console_console_timestamp_label" id="console_console_timestamp_label">#</a></span></h3>
+<h4><code>console.timeStamp([label])</code><span><a class="mark" href="#console_console_timestamp_label" id="console_console_timestamp_label">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -643,10 +666,46 @@ stopped.</p>
 </ul>
 <p>This method does not display anything unless used in the inspector. The
 <code>console.timeStamp()</code> method adds an event with the label <code>'label'</code> to the
-<strong>Timeline</strong> panel of the inspector.</p>
+<strong>Timeline</strong> panel of the inspector.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/console.json b/doc/api/console.json
index 8e2a2c4ffe03e7a59640361d89e72c1688f2b1a2..9346b2b331c949731c340b28523d404df3a34e5f 100644
--- a/doc/api/console.json
+++ b/doc/api/console.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.13",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/console.js\">lib/console.js</a></p>\n<p>The <code>console</code> module provides a simple debugging console that is similar to the\nJavaScript console mechanism provided by web browsers.</p>\n<p>The module exports two specific components:</p>\n<ul>\n<li>A <code>Console</code> class with methods such as <code>console.log()</code>, <code>console.error()</code> and\n<code>console.warn()</code> that can be used to write to any Node.js stream.</li>\n<li>A global <code>console</code> instance configured to write to <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> and\n<a href=\"process.html#process_process_stderr\"><code>process.stderr</code></a>. The global <code>console</code> can be used without calling\n<code>require('console')</code>.</li>\n</ul>\n<p><strong><em>Warning</em></strong>: The global console object's methods are neither consistently\nsynchronous like the browser APIs they resemble, nor are they consistently\nasynchronous like all other Node.js streams. See the <a href=\"process.html#process_a_note_on_process_i_o\">note on process I/O</a> for\nmore information.</p>\n<p>Example using the global <code>console</code>:</p>\n<pre><code class=\"language-js\">console.log('hello world');\n// Prints: hello world, to stdout\nconsole.log('hello %s', 'world');\n// Prints: hello world, to stdout\nconsole.error(new Error('Whoops, something bad happened'));\n// Prints: [Error: Whoops, something bad happened], to stderr\n\nconst name = 'Will Robinson';\nconsole.warn(`Danger ${name}! Danger!`);\n// Prints: Danger Will Robinson! Danger!, to stderr\n</code></pre>\n<p>Example using the <code>Console</code> class:</p>\n<pre><code class=\"language-js\">const out = getStreamSomehow();\nconst err = getStreamSomehow();\nconst myConsole = new console.Console(out, err);\n\nmyConsole.log('hello world');\n// Prints: hello world, to out\nmyConsole.log('hello %s', 'world');\n// Prints: hello world, to out\nmyConsole.error(new Error('Whoops, something bad happened'));\n// Prints: [Error: Whoops, something bad happened], to err\n\nconst name = 'Will Robinson';\nmyConsole.warn(`Danger ${name}! Danger!`);\n// Prints: Danger Will Robinson! Danger!, to err\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/console.js\">lib/console.js</a></p>\n<p>The <code>console</code> module provides a simple debugging console that is similar to the\nJavaScript console mechanism provided by web browsers.</p>\n<p>The module exports two specific components:</p>\n<ul>\n<li>A <code>Console</code> class with methods such as <code>console.log()</code>, <code>console.error()</code> and\n<code>console.warn()</code> that can be used to write to any Node.js stream.</li>\n<li>A global <code>console</code> instance configured to write to <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> and\n<a href=\"process.html#process_process_stderr\"><code>process.stderr</code></a>. The global <code>console</code> can be used without calling\n<code>require('console')</code>.</li>\n</ul>\n<p><em><strong>Warning</strong></em>: The global console object's methods are neither consistently\nsynchronous like the browser APIs they resemble, nor are they consistently\nasynchronous like all other Node.js streams. See the <a href=\"process.html#process_a_note_on_process_i_o\">note on process I/O</a> for\nmore information.</p>\n<p>Example using the global <code>console</code>:</p>\n<pre><code class=\"language-js\">console.log('hello world');\n// Prints: hello world, to stdout\nconsole.log('hello %s', 'world');\n// Prints: hello world, to stdout\nconsole.error(new Error('Whoops, something bad happened'));\n// Prints error message and stack trace to stderr:\n//   Error: Whoops, something bad happened\n//     at [eval]:5:15\n//     at Script.runInThisContext (node:vm:132:18)\n//     at Object.runInThisContext (node:vm:309:38)\n//     at node:internal/process/execution:77:19\n//     at [eval]-wrapper:6:22\n//     at evalScript (node:internal/process/execution:76:60)\n//     at node:internal/main/eval_string:23:3\n\nconst name = 'Will Robinson';\nconsole.warn(`Danger ${name}! Danger!`);\n// Prints: Danger Will Robinson! Danger!, to stderr\n</code></pre>\n<p>Example using the <code>Console</code> class:</p>\n<pre><code class=\"language-js\">const out = getStreamSomehow();\nconst err = getStreamSomehow();\nconst myConsole = new console.Console(out, err);\n\nmyConsole.log('hello world');\n// Prints: hello world, to out\nmyConsole.log('hello %s', 'world');\n// Prints: hello world, to out\nmyConsole.error(new Error('Whoops, something bad happened'));\n// Prints: [Error: Whoops, something bad happened], to err\n\nconst name = 'Will Robinson';\nmyConsole.warn(`Danger ${name}! Danger!`);\n// Prints: Danger Will Robinson! Danger!, to err\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `Console`",
@@ -434,7 +434,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Starts a timer that can be used to compute the duration of an operation. Timers\nare identified by a unique <code>label</code>. Use the same <code>label</code> when calling\n<a href=\"#console_console_timeend_label\"><code>console.timeEnd()</code></a> to stop the timer and output the elapsed time in\nmilliseconds to <code>stdout</code>. Timer durations are accurate to the sub-millisecond.</p>"
+              "desc": "<p>Starts a timer that can be used to compute the duration of an operation. Timers\nare identified by a unique <code>label</code>. Use the same <code>label</code> when calling\n<a href=\"#console_console_timeend_label\"><code>console.timeEnd()</code></a> to stop the timer and output the elapsed time in\nsuitable time units to <code>stdout</code>. For example, if the elapsed\ntime is 3869ms, <code>console.timeEnd()</code> displays \"3.869s\".</p>"
             },
             {
               "textRaw": "`console.timeEnd([label])`",
@@ -445,6 +445,11 @@
                   "v0.1.104"
                 ],
                 "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29251",
+                    "description": "The elapsed time is displayed with a suitable time unit."
+                  },
                   {
                     "version": "v6.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/5901",
diff --git a/doc/api/console.md b/doc/api/console.md
index b747492d981260aecb706b31c6201023c7c1b30b..803af0d13dbac98e0ace436b9661262fe07f631c 100644
--- a/doc/api/console.md
+++ b/doc/api/console.md
@@ -30,7 +30,15 @@ console.log('hello world');
 console.log('hello %s', 'world');
 // Prints: hello world, to stdout
 console.error(new Error('Whoops, something bad happened'));
-// Prints: [Error: Whoops, something bad happened], to stderr
+// Prints error message and stack trace to stderr:
+//   Error: Whoops, something bad happened
+//     at [eval]:5:15
+//     at Script.runInThisContext (node:vm:132:18)
+//     at Object.runInThisContext (node:vm:309:38)
+//     at node:internal/process/execution:77:19
+//     at [eval]-wrapper:6:22
+//     at evalScript (node:internal/process/execution:76:60)
+//     at node:internal/main/eval_string:23:3
 
 const name = 'Will Robinson';
 console.warn(`Danger ${name}! Danger!`);
@@ -83,7 +91,7 @@ const { Console } = console;
 ### `new Console(options)`
 <!-- YAML
 changes:
-  - version: v12.17.0
+  - version: v14.2.0
     pr-url: https://github.com/nodejs/node/pull/32964
     description: The `groupIndentation` option was introduced.
   - version: v11.7.0
@@ -416,12 +424,16 @@ added: v0.1.104
 Starts a timer that can be used to compute the duration of an operation. Timers
 are identified by a unique `label`. Use the same `label` when calling
 [`console.timeEnd()`][] to stop the timer and output the elapsed time in
-milliseconds to `stdout`. Timer durations are accurate to the sub-millisecond.
+suitable time units to `stdout`. For example, if the elapsed
+time is 3869ms, `console.timeEnd()` displays "3.869s".
 
 ### `console.timeEnd([label])`
 <!-- YAML
 added: v0.1.104
 changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/29251
+    description: The elapsed time is displayed with a suitable time unit.
   - version: v6.0.0
     pr-url: https://github.com/nodejs/node/pull/5901
     description: This method no longer supports multiple calls that don’t map
@@ -554,12 +566,12 @@ This method does not display anything unless used in the inspector. The
 [`console.profileEnd()`]: #console_console_profileend_label
 [`console.time()`]: #console_console_time_label
 [`console.timeEnd()`]: #console_console_timeend_label
-[`process.stderr`]: process.html#process_process_stderr
-[`process.stdout`]: process.html#process_process_stdout
-[`util.format()`]: util.html#util_util_format_format_args
-[`util.inspect()`]: util.html#util_util_inspect_object_options
-[customizing `util.inspect()` colors]: util.html#util_customizing_util_inspect_colors
+[`process.stderr`]: process.md#process_process_stderr
+[`process.stdout`]: process.md#process_process_stdout
+[`util.format()`]: util.md#util_util_format_format_args
+[`util.inspect()`]: util.md#util_util_inspect_object_options
+[customizing `util.inspect()` colors]: util.md#util_customizing_util_inspect_colors
 [falsy]: https://developer.mozilla.org/en-US/docs/Glossary/Falsy
-[inspector]: debugger.html
-[note on process I/O]: process.html#process_a_note_on_process_i_o
+[inspector]: debugger.md
+[note on process I/O]: process.md#process_a_note_on_process_i_o
 [truthy]: https://developer.mozilla.org/en-US/docs/Glossary/Truthy
diff --git a/doc/api/crypto.html b/doc/api/crypto.html
index 752a4db2e32424687e147311201062a518e087c9..53b22f711364aadc0730026b153f917391707d8a 100644
--- a/doc/api/crypto.html
+++ b/doc/api/crypto.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Crypto | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Crypto | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto active">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="crypto" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/crypto.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/crypto.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/crypto.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/crypto.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/crypto.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/crypto.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/crypto.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/crypto.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/crypto.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#crypto_crypto">Crypto</a></span>
 <ul>
 <li><a href="#crypto_determining_if_crypto_support_is_unavailable">Determining if crypto support is unavailable</a></li>
@@ -135,7 +148,7 @@
 <li><a href="#crypto_certificate_exportchallenge_spkac"><code>Certificate.exportChallenge(spkac)</code></a></li>
 <li><a href="#crypto_certificate_exportpublickey_spkac_encoding"><code>Certificate.exportPublicKey(spkac[, encoding])</code></a></li>
 <li><a href="#crypto_certificate_verifyspkac_spkac"><code>Certificate.verifySpkac(spkac)</code></a></li>
-<li><a href="#crypto_legacy_api">Legacy API</a>
+<li><span class="stability_0"><a href="#crypto_legacy_api">Legacy API</a></span>
 <ul>
 <li><a href="#crypto_new_crypto_certificate"><code>new crypto.Certificate()</code></a></li>
 <li><a href="#crypto_certificate_exportchallenge_spkac_1"><code>certificate.exportChallenge(spkac)</code></a></li>
@@ -148,8 +161,8 @@
 <li><a href="#crypto_class_cipher">Class: <code>Cipher</code></a>
 <ul>
 <li><a href="#crypto_cipher_final_outputencoding"><code>cipher.final([outputEncoding])</code></a></li>
-<li><a href="#crypto_cipher_setaad_buffer_options"><code>cipher.setAAD(buffer[, options])</code></a></li>
 <li><a href="#crypto_cipher_getauthtag"><code>cipher.getAuthTag()</code></a></li>
+<li><a href="#crypto_cipher_setaad_buffer_options"><code>cipher.setAAD(buffer[, options])</code></a></li>
 <li><a href="#crypto_cipher_setautopadding_autopadding"><code>cipher.setAutoPadding([autoPadding])</code></a></li>
 <li><a href="#crypto_cipher_update_data_inputencoding_outputencoding"><code>cipher.update(data[, inputEncoding][, outputEncoding])</code></a></li>
 </ul>
@@ -259,6 +272,7 @@
 <li><a href="#crypto_crypto_randomfillsync_buffer_offset_size"><code>crypto.randomFillSync(buffer[, offset][, size])</code></a></li>
 <li><a href="#crypto_crypto_randomfill_buffer_offset_size_callback"><code>crypto.randomFill(buffer[, offset][, size], callback)</code></a></li>
 <li><a href="#crypto_crypto_randomint_min_max_callback"><code>crypto.randomInt([min, ]max[, callback])</code></a></li>
+<li><a href="#crypto_crypto_randomuuid_options"><code>crypto.randomUUID([options])</code></a></li>
 <li><a href="#crypto_crypto_scrypt_password_salt_keylen_options_callback"><code>crypto.scrypt(password, salt, keylen[, options], callback)</code></a></li>
 <li><a href="#crypto_crypto_scryptsync_password_salt_keylen_options"><code>crypto.scryptSync(password, salt, keylen[, options])</code></a></li>
 <li><a href="#crypto_crypto_setengine_engine_flags"><code>crypto.setEngine(engine[, flags])</code></a></li>
@@ -270,7 +284,7 @@
 </li>
 <li><a href="#crypto_notes">Notes</a>
 <ul>
-<li><a href="#crypto_legacy_streams_api_prior_to_node_js_0_10">Legacy Streams API (prior to Node.js 0.10)</a></li>
+<li><a href="#crypto_legacy_streams_api_prior_to_node_js_0_10">Legacy streams API (prior to Node.js 0.10)</a></li>
 <li><a href="#crypto_recent_ecdh_changes">Recent ECDH changes</a></li>
 <li><a href="#crypto_support_for_weak_or_compromised_algorithms">Support for weak or compromised algorithms</a></li>
 <li><a href="#crypto_ccm_mode">CCM mode</a></li>
@@ -286,27 +300,26 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Crypto<span><a class="mark" href="#crypto_crypto" id="crypto_crypto">#</a></span></h1>
+        <h2>Crypto<span><a class="mark" href="#crypto_crypto" id="crypto_crypto">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/crypto.js">lib/crypto.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/crypto.js">lib/crypto.js</a></p>
 <p>The <code>crypto</code> module provides cryptographic functionality that includes a set of
 wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.</p>
 <p>Use <code>require('crypto')</code> to access this module.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
 <span class="hljs-keyword">const</span> secret = <span class="hljs-string">'abcdefg'</span>;
-<span class="hljs-keyword">const</span> hash = crypto.createHmac(<span class="hljs-string">'sha256'</span>, secret)
-                   .update(<span class="hljs-string">'I love cupcakes'</span>)
-                   .digest(<span class="hljs-string">'hex'</span>);
-<span class="hljs-built_in">console</span>.log(hash);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, secret)
+                   .<span class="hljs-title function_">update</span>(<span class="hljs-string">'I love cupcakes'</span>)
+                   .<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e</span></code></pre>
-<h2>Determining if crypto support is unavailable<span><a class="mark" href="#crypto_determining_if_crypto_support_is_unavailable" id="crypto_determining_if_crypto_support_is_unavailable">#</a></span></h2>
+<section><h3>Determining if crypto support is unavailable<span><a class="mark" href="#crypto_determining_if_crypto_support_is_unavailable" id="crypto_determining_if_crypto_support_is_unavailable">#</a></span></h3>
 <p>It is possible for Node.js to be built without including support for the
 <code>crypto</code> module. In such cases, calling <code>require('crypto')</code> will result in an
 error being thrown.</p>
@@ -314,9 +327,9 @@ error being thrown.</p>
 <span class="hljs-keyword">try</span> {
   crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'crypto support is disabled!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'crypto support is disabled!'</span>);
 }</code></pre>
-<h2>Class: <code>Certificate</code><span><a class="mark" href="#crypto_class_certificate" id="crypto_class_certificate">#</a></span></h2>
+</section><section><h3>Class: <code>Certificate</code><span><a class="mark" href="#crypto_class_certificate" id="crypto_class_certificate">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -327,7 +340,7 @@ should not use this element anymore.</p>
 <p>The <code>crypto</code> module provides the <code>Certificate</code> class for working with SPKAC
 data. The most common usage is handling output generated by the HTML5
 <code>&#x3C;keygen></code> element. Node.js uses <a href="https://www.openssl.org/docs/man1.1.0/apps/openssl-spkac.html">OpenSSL's SPKAC implementation</a> internally.</p>
-<h3><code>Certificate.exportChallenge(spkac)</code><span><a class="mark" href="#crypto_certificate_exportchallenge_spkac" id="crypto_certificate_exportchallenge_spkac">#</a></span></h3>
+<h4><code>Certificate.exportChallenge(spkac)</code><span><a class="mark" href="#crypto_certificate_exportchallenge_spkac" id="crypto_certificate_exportchallenge_spkac">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -336,12 +349,12 @@ data. The most common usage is handling output generated by the HTML5
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The challenge component of the <code>spkac</code> data structure, which
 includes a public key and a challenge.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Certificate } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-keyword">const</span> challenge = Certificate.exportChallenge(spkac);
-<span class="hljs-built_in">console</span>.log(challenge.toString(<span class="hljs-string">'utf8'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Certificate</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-keyword">const</span> challenge = <span class="hljs-title class_">Certificate</span>.<span class="hljs-title function_">exportChallenge</span>(spkac);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(challenge.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: the challenge as a UTF8 string</span></code></pre>
-<h3><code>Certificate.exportPublicKey(spkac[, encoding])</code><span><a class="mark" href="#crypto_certificate_exportpublickey_spkac_encoding" id="crypto_certificate_exportpublickey_spkac_encoding">#</a></span></h3>
+<h4><code>Certificate.exportPublicKey(spkac[, encoding])</code><span><a class="mark" href="#crypto_certificate_exportpublickey_spkac_encoding" id="crypto_certificate_exportpublickey_spkac_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -351,12 +364,12 @@ includes a public key and a challenge.</li>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The public key component of the <code>spkac</code> data structure,
 which includes a public key and a challenge.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Certificate } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-keyword">const</span> publicKey = Certificate.exportPublicKey(spkac);
-<span class="hljs-built_in">console</span>.log(publicKey);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Certificate</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-keyword">const</span> publicKey = <span class="hljs-title class_">Certificate</span>.<span class="hljs-title function_">exportPublicKey</span>(spkac);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(publicKey);
 <span class="hljs-comment">// Prints: the public key as &#x3C;Buffer ...></span></code></pre>
-<h3><code>Certificate.verifySpkac(spkac)</code><span><a class="mark" href="#crypto_certificate_verifyspkac_spkac" id="crypto_certificate_verifyspkac_spkac">#</a></span></h3>
+<h4><code>Certificate.verifySpkac(spkac)</code><span><a class="mark" href="#crypto_certificate_verifyspkac_spkac" id="crypto_certificate_verifyspkac_spkac">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -365,21 +378,22 @@ which includes a public key and a challenge.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the given <code>spkac</code> data structure is valid,
 <code>false</code> otherwise.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Certificate } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-built_in">console</span>.log(Certificate.verifySpkac(Buffer.from(spkac)));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Certificate</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Certificate</span>.<span class="hljs-title function_">verifySpkac</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(spkac)));
 <span class="hljs-comment">// Prints: true or false</span></code></pre>
-<h3>Legacy API<span><a class="mark" href="#crypto_legacy_api" id="crypto_legacy_api">#</a></span></h3>
-<p>As a still supported legacy interface, it is possible to create new instances of
+<h4>Legacy API<span><a class="mark" href="#crypto_legacy_api" id="crypto_legacy_api">#</a></span></h4>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated</div><p></p>
+<p>As a legacy interface, it is possible to create new instances of
 the <code>crypto.Certificate</code> class as illustrated in the examples below.</p>
-<h4><code>new crypto.Certificate()</code><span><a class="mark" href="#crypto_new_crypto_certificate" id="crypto_new_crypto_certificate">#</a></span></h4>
+<h5><code>new crypto.Certificate()</code><span><a class="mark" href="#crypto_new_crypto_certificate" id="crypto_new_crypto_certificate">#</a></span></h5>
 <p>Instances of the <code>Certificate</code> class can be created using the <code>new</code> keyword
 or by calling <code>crypto.Certificate()</code> as a function:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-keyword">const</span> cert1 = <span class="hljs-keyword">new</span> crypto.Certificate();
-<span class="hljs-keyword">const</span> cert2 = crypto.Certificate();</code></pre>
-<h4><code>certificate.exportChallenge(spkac)</code><span><a class="mark" href="#crypto_certificate_exportchallenge_spkac_1" id="crypto_certificate_exportchallenge_spkac_1">#</a></span></h4>
+<span class="hljs-keyword">const</span> cert1 = <span class="hljs-keyword">new</span> crypto.<span class="hljs-title class_">Certificate</span>();
+<span class="hljs-keyword">const</span> cert2 = crypto.<span class="hljs-title class_">Certificate</span>();</code></pre>
+<h5><code>certificate.exportChallenge(spkac)</code><span><a class="mark" href="#crypto_certificate_exportchallenge_spkac_1" id="crypto_certificate_exportchallenge_spkac_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -388,12 +402,12 @@ or by calling <code>crypto.Certificate()</code> as a function:</p>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The challenge component of the <code>spkac</code> data structure, which
 includes a public key and a challenge.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).Certificate();
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-keyword">const</span> challenge = cert.exportChallenge(spkac);
-<span class="hljs-built_in">console</span>.log(challenge.toString(<span class="hljs-string">'utf8'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).<span class="hljs-title class_">Certificate</span>();
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-keyword">const</span> challenge = cert.<span class="hljs-title function_">exportChallenge</span>(spkac);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(challenge.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>));
 <span class="hljs-comment">// Prints: the challenge as a UTF8 string</span></code></pre>
-<h4><code>certificate.exportPublicKey(spkac)</code><span><a class="mark" href="#crypto_certificate_exportpublickey_spkac" id="crypto_certificate_exportpublickey_spkac">#</a></span></h4>
+<h5><code>certificate.exportPublicKey(spkac)</code><span><a class="mark" href="#crypto_certificate_exportpublickey_spkac" id="crypto_certificate_exportpublickey_spkac">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -402,12 +416,12 @@ includes a public key and a challenge.</li>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The public key component of the <code>spkac</code> data structure,
 which includes a public key and a challenge.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).Certificate();
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-keyword">const</span> publicKey = cert.exportPublicKey(spkac);
-<span class="hljs-built_in">console</span>.log(publicKey);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).<span class="hljs-title class_">Certificate</span>();
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-keyword">const</span> publicKey = cert.<span class="hljs-title function_">exportPublicKey</span>(spkac);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(publicKey);
 <span class="hljs-comment">// Prints: the public key as &#x3C;Buffer ...></span></code></pre>
-<h4><code>certificate.verifySpkac(spkac)</code><span><a class="mark" href="#crypto_certificate_verifyspkac_spkac_1" id="crypto_certificate_verifyspkac_spkac_1">#</a></span></h4>
+<h5><code>certificate.verifySpkac(spkac)</code><span><a class="mark" href="#crypto_certificate_verifyspkac_spkac_1" id="crypto_certificate_verifyspkac_spkac_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -416,11 +430,11 @@ which includes a public key and a challenge.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the given <code>spkac</code> data structure is valid,
 <code>false</code> otherwise.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).Certificate();
-<span class="hljs-keyword">const</span> spkac = getSpkacSomehow();
-<span class="hljs-built_in">console</span>.log(cert.verifySpkac(Buffer.from(spkac)));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> cert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>).<span class="hljs-title class_">Certificate</span>();
+<span class="hljs-keyword">const</span> spkac = <span class="hljs-title function_">getSpkacSomehow</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(cert.<span class="hljs-title function_">verifySpkac</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(spkac)));
 <span class="hljs-comment">// Prints: true or false</span></code></pre>
-<h2>Class: <code>Cipher</code><span><a class="mark" href="#crypto_class_cipher" id="crypto_class_cipher">#</a></span></h2>
+</section><section><h3>Class: <code>Cipher</code><span><a class="mark" href="#crypto_class_cipher" id="crypto_class_cipher">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -446,27 +460,27 @@ directly using the <code>new</code> keyword.</p>
 <span class="hljs-comment">// Key length is dependent on the algorithm. In this case for aes192, it is</span>
 <span class="hljs-comment">// 24 bytes (192 bits).</span>
 <span class="hljs-comment">// Use async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// Use `crypto.randomBytes()` to generate a random iv instead of the static iv</span>
 <span class="hljs-comment">// shown here.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> cipher = crypto.createCipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> cipher = crypto.<span class="hljs-title function_">createCipheriv</span>(algorithm, key, iv);
 
 <span class="hljs-keyword">let</span> encrypted = <span class="hljs-string">''</span>;
-cipher.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+cipher.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-keyword">let</span> chunk;
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = cipher.read())) {
-    encrypted += chunk.toString(<span class="hljs-string">'hex'</span>);
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = cipher.<span class="hljs-title function_">read</span>())) {
+    encrypted += chunk.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>);
   }
 });
-cipher.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(encrypted);
+cipher.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(encrypted);
   <span class="hljs-comment">// Prints: e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa</span>
 });
 
-cipher.write(<span class="hljs-string">'some clear text data'</span>);
-cipher.end();</code></pre>
+cipher.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some clear text data'</span>);
+cipher.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example: Using <code>Cipher</code> and piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
@@ -474,35 +488,35 @@ cipher.end();</code></pre>
 <span class="hljs-keyword">const</span> algorithm = <span class="hljs-string">'aes-192-cbc'</span>;
 <span class="hljs-keyword">const</span> password = <span class="hljs-string">'Password used to generate key'</span>;
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// Use `crypto.randomBytes()` to generate a random iv instead of the static iv</span>
 <span class="hljs-comment">// shown here.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> cipher = crypto.createCipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> cipher = crypto.<span class="hljs-title function_">createCipheriv</span>(algorithm, key, iv);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(<span class="hljs-string">'test.js'</span>);
-<span class="hljs-keyword">const</span> output = fs.createWriteStream(<span class="hljs-string">'test.enc'</span>);
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'test.js'</span>);
+<span class="hljs-keyword">const</span> output = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'test.enc'</span>);
 
-input.pipe(cipher).pipe(output);</code></pre>
+input.<span class="hljs-title function_">pipe</span>(cipher).<span class="hljs-title function_">pipe</span>(output);</code></pre>
 <p>Example: Using the <a href="#crypto_cipher_update_data_inputencoding_outputencoding"><code>cipher.update()</code></a> and <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
 <span class="hljs-keyword">const</span> algorithm = <span class="hljs-string">'aes-192-cbc'</span>;
 <span class="hljs-keyword">const</span> password = <span class="hljs-string">'Password used to generate key'</span>;
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// Use `crypto.randomBytes` to generate a random iv instead of the static iv</span>
 <span class="hljs-comment">// shown here.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> cipher = crypto.createCipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> cipher = crypto.<span class="hljs-title function_">createCipheriv</span>(algorithm, key, iv);
 
-<span class="hljs-keyword">let</span> encrypted = cipher.update(<span class="hljs-string">'some clear text data'</span>, <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'hex'</span>);
-encrypted += cipher.final(<span class="hljs-string">'hex'</span>);
-<span class="hljs-built_in">console</span>.log(encrypted);
+<span class="hljs-keyword">let</span> encrypted = cipher.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some clear text data'</span>, <span class="hljs-string">'utf8'</span>, <span class="hljs-string">'hex'</span>);
+encrypted += cipher.<span class="hljs-title function_">final</span>(<span class="hljs-string">'hex'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(encrypted);
 <span class="hljs-comment">// Prints: e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa</span></code></pre>
-<h3><code>cipher.final([outputEncoding])</code><span><a class="mark" href="#crypto_cipher_final_outputencoding" id="crypto_cipher_final_outputencoding">#</a></span></h3>
+<h4><code>cipher.final([outputEncoding])</code><span><a class="mark" href="#crypto_cipher_final_outputencoding" id="crypto_cipher_final_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -515,7 +529,19 @@ returned. If an <code>outputEncoding</code> is not provided, a <a href="buffer.h
 <p>Once the <code>cipher.final()</code> method has been called, the <code>Cipher</code> object can no
 longer be used to encrypt data. Attempts to call <code>cipher.final()</code> more than
 once will result in an error being thrown.</p>
-<h3><code>cipher.setAAD(buffer[, options])</code><span><a class="mark" href="#crypto_cipher_setaad_buffer_options" id="crypto_cipher_setaad_buffer_options">#</a></span></h3>
+<h4><code>cipher.getAuthTag()</code><span><a class="mark" href="#crypto_cipher_getauthtag" id="crypto_cipher_getauthtag">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v1.0.0</span>
+</div>
+<ul>
+<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> When using an authenticated encryption mode (<code>GCM</code>, <code>CCM</code>
+and <code>OCB</code> are currently supported), the <code>cipher.getAuthTag()</code> method returns a
+<a href="buffer.html"><code>Buffer</code></a> containing the <em>authentication tag</em> that has been computed from
+the given data.</li>
+</ul>
+<p>The <code>cipher.getAuthTag()</code> method should only be called after encryption has
+been completed using the <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> method.</p>
+<h4><code>cipher.setAAD(buffer[, options])</code><span><a class="mark" href="#crypto_cipher_setaad_buffer_options" id="crypto_cipher_setaad_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.0.0</span>
 </div>
@@ -535,19 +561,7 @@ currently supported), the <code>cipher.setAAD()</code> method sets the value use
 <code>plaintextLength</code> option must be specified and its value must match the length
 of the plaintext in bytes. See <a href="#crypto_ccm_mode">CCM mode</a>.</p>
 <p>The <code>cipher.setAAD()</code> method must be called before <a href="#crypto_cipher_update_data_inputencoding_outputencoding"><code>cipher.update()</code></a>.</p>
-<h3><code>cipher.getAuthTag()</code><span><a class="mark" href="#crypto_cipher_getauthtag" id="crypto_cipher_getauthtag">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v1.0.0</span>
-</div>
-<ul>
-<li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> When using an authenticated encryption mode (<code>GCM</code>, <code>CCM</code>
-and <code>OCB</code> are currently supported), the <code>cipher.getAuthTag()</code> method returns a
-<a href="buffer.html"><code>Buffer</code></a> containing the <em>authentication tag</em> that has been computed from
-the given data.</li>
-</ul>
-<p>The <code>cipher.getAuthTag()</code> method should only be called after encryption has
-been completed using the <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> method.</p>
-<h3><code>cipher.setAutoPadding([autoPadding])</code><span><a class="mark" href="#crypto_cipher_setautopadding_autopadding" id="crypto_cipher_setautopadding_autopadding">#</a></span></h3>
+<h4><code>cipher.setAutoPadding([autoPadding])</code><span><a class="mark" href="#crypto_cipher_setautopadding_autopadding" id="crypto_cipher_setautopadding_autopadding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.1</span>
 </div>
@@ -564,7 +578,7 @@ Disabling automatic padding is useful for non-standard padding, for instance
 using <code>0x0</code> instead of PKCS padding.</p>
 <p>The <code>cipher.setAutoPadding()</code> method must be called before
 <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a>.</p>
-<h3><code>cipher.update(data[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_cipher_update_data_inputencoding_outputencoding" id="crypto_cipher_update_data_inputencoding_outputencoding">#</a></span></h3>
+<h4><code>cipher.update(data[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_cipher_update_data_inputencoding_outputencoding" id="crypto_cipher_update_data_inputencoding_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -595,7 +609,7 @@ is specified, a string using the specified encoding is returned. If no
 <p>The <code>cipher.update()</code> method can be called multiple times with new data until
 <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> is called. Calling <code>cipher.update()</code> after
 <a href="#crypto_cipher_final_outputencoding"><code>cipher.final()</code></a> will result in an error being thrown.</p>
-<h2>Class: <code>Decipher</code><span><a class="mark" href="#crypto_class_decipher" id="crypto_class_decipher">#</a></span></h2>
+</section><section><h3>Class: <code>Decipher</code><span><a class="mark" href="#crypto_class_decipher" id="crypto_class_decipher">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -621,28 +635,28 @@ directly using the <code>new</code> keyword.</p>
 <span class="hljs-comment">// Key length is dependent on the algorithm. In this case for aes192, it is</span>
 <span class="hljs-comment">// 24 bytes (192 bits).</span>
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// The IV is usually passed along with the ciphertext.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> decipher = crypto.createDecipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> decipher = crypto.<span class="hljs-title function_">createDecipheriv</span>(algorithm, key, iv);
 
 <span class="hljs-keyword">let</span> decrypted = <span class="hljs-string">''</span>;
-decipher.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = decipher.read())) {
-    decrypted += chunk.toString(<span class="hljs-string">'utf8'</span>);
+decipher.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = decipher.<span class="hljs-title function_">read</span>())) {
+    decrypted += chunk.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>);
   }
 });
-decipher.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(decrypted);
+decipher.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decrypted);
   <span class="hljs-comment">// Prints: some clear text data</span>
 });
 
 <span class="hljs-comment">// Encrypted with same algorithm, key and iv.</span>
 <span class="hljs-keyword">const</span> encrypted =
   <span class="hljs-string">'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'</span>;
-decipher.write(encrypted, <span class="hljs-string">'hex'</span>);
-decipher.end();</code></pre>
+decipher.<span class="hljs-title function_">write</span>(encrypted, <span class="hljs-string">'hex'</span>);
+decipher.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example: Using <code>Decipher</code> and piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
@@ -650,36 +664,36 @@ decipher.end();</code></pre>
 <span class="hljs-keyword">const</span> algorithm = <span class="hljs-string">'aes-192-cbc'</span>;
 <span class="hljs-keyword">const</span> password = <span class="hljs-string">'Password used to generate key'</span>;
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// The IV is usually passed along with the ciphertext.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> decipher = crypto.createDecipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> decipher = crypto.<span class="hljs-title function_">createDecipheriv</span>(algorithm, key, iv);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(<span class="hljs-string">'test.enc'</span>);
-<span class="hljs-keyword">const</span> output = fs.createWriteStream(<span class="hljs-string">'test.js'</span>);
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'test.enc'</span>);
+<span class="hljs-keyword">const</span> output = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'test.js'</span>);
 
-input.pipe(decipher).pipe(output);</code></pre>
+input.<span class="hljs-title function_">pipe</span>(decipher).<span class="hljs-title function_">pipe</span>(output);</code></pre>
 <p>Example: Using the <a href="#crypto_decipher_update_data_inputencoding_outputencoding"><code>decipher.update()</code></a> and <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
 <span class="hljs-keyword">const</span> algorithm = <span class="hljs-string">'aes-192-cbc'</span>;
 <span class="hljs-keyword">const</span> password = <span class="hljs-string">'Password used to generate key'</span>;
 <span class="hljs-comment">// Use the async `crypto.scrypt()` instead.</span>
-<span class="hljs-keyword">const</span> key = crypto.scryptSync(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">scryptSync</span>(password, <span class="hljs-string">'salt'</span>, <span class="hljs-number">24</span>);
 <span class="hljs-comment">// The IV is usually passed along with the ciphertext.</span>
-<span class="hljs-keyword">const</span> iv = Buffer.alloc(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
+<span class="hljs-keyword">const</span> iv = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">16</span>, <span class="hljs-number">0</span>); <span class="hljs-comment">// Initialization vector.</span>
 
-<span class="hljs-keyword">const</span> decipher = crypto.createDecipheriv(algorithm, key, iv);
+<span class="hljs-keyword">const</span> decipher = crypto.<span class="hljs-title function_">createDecipheriv</span>(algorithm, key, iv);
 
 <span class="hljs-comment">// Encrypted using same algorithm, key and iv.</span>
 <span class="hljs-keyword">const</span> encrypted =
   <span class="hljs-string">'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'</span>;
-<span class="hljs-keyword">let</span> decrypted = decipher.update(encrypted, <span class="hljs-string">'hex'</span>, <span class="hljs-string">'utf8'</span>);
-decrypted += decipher.final(<span class="hljs-string">'utf8'</span>);
-<span class="hljs-built_in">console</span>.log(decrypted);
+<span class="hljs-keyword">let</span> decrypted = decipher.<span class="hljs-title function_">update</span>(encrypted, <span class="hljs-string">'hex'</span>, <span class="hljs-string">'utf8'</span>);
+decrypted += decipher.<span class="hljs-title function_">final</span>(<span class="hljs-string">'utf8'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decrypted);
 <span class="hljs-comment">// Prints: some clear text data</span></code></pre>
-<h3><code>decipher.final([outputEncoding])</code><span><a class="mark" href="#crypto_decipher_final_outputencoding" id="crypto_decipher_final_outputencoding">#</a></span></h3>
+<h4><code>decipher.final([outputEncoding])</code><span><a class="mark" href="#crypto_decipher_final_outputencoding" id="crypto_decipher_final_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -692,7 +706,7 @@ returned. If an <code>outputEncoding</code> is not provided, a <a href="buffer.h
 <p>Once the <code>decipher.final()</code> method has been called, the <code>Decipher</code> object can
 no longer be used to decrypt data. Attempts to call <code>decipher.final()</code> more
 than once will result in an error being thrown.</p>
-<h3><code>decipher.setAAD(buffer[, options])</code><span><a class="mark" href="#crypto_decipher_setaad_buffer_options" id="crypto_decipher_setaad_buffer_options">#</a></span></h3>
+<h4><code>decipher.setAAD(buffer[, options])</code><span><a class="mark" href="#crypto_decipher_setaad_buffer_options" id="crypto_decipher_setaad_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -720,7 +734,7 @@ currently supported), the <code>decipher.setAAD()</code> method sets the value u
 <code>plaintextLength</code> option must be specified and its value must match the length
 of the ciphertext in bytes. See <a href="#crypto_ccm_mode">CCM mode</a>.</p>
 <p>The <code>decipher.setAAD()</code> method must be called before <a href="#crypto_decipher_update_data_inputencoding_outputencoding"><code>decipher.update()</code></a>.</p>
-<h3><code>decipher.setAuthTag(buffer)</code><span><a class="mark" href="#crypto_decipher_setauthtag_buffer" id="crypto_decipher_setauthtag_buffer">#</a></span></h3>
+<h4><code>decipher.setAuthTag(buffer)</code><span><a class="mark" href="#crypto_decipher_setauthtag_buffer" id="crypto_decipher_setauthtag_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -748,7 +762,7 @@ is invalid according to <a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nis
 <p>The <code>decipher.setAuthTag()</code> method must be called before <a href="#crypto_decipher_update_data_inputencoding_outputencoding"><code>decipher.update()</code></a>
 for <code>CCM</code> mode or before <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> for <code>GCM</code> and <code>OCB</code> modes.
 <code>decipher.setAuthTag()</code> can only be called once.</p>
-<h3><code>decipher.setAutoPadding([autoPadding])</code><span><a class="mark" href="#crypto_decipher_setautopadding_autopadding" id="crypto_decipher_setautopadding_autopadding">#</a></span></h3>
+<h4><code>decipher.setAutoPadding([autoPadding])</code><span><a class="mark" href="#crypto_decipher_setautopadding_autopadding" id="crypto_decipher_setautopadding_autopadding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.1</span>
 </div>
@@ -763,7 +777,7 @@ for <code>CCM</code> mode or before <a href="#crypto_decipher_final_outputencodi
 multiple of the ciphers block size.</p>
 <p>The <code>decipher.setAutoPadding()</code> method must be called before
 <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a>.</p>
-<h3><code>decipher.update(data[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_decipher_update_data_inputencoding_outputencoding" id="crypto_decipher_update_data_inputencoding_outputencoding">#</a></span></h3>
+<h4><code>decipher.update(data[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_decipher_update_data_inputencoding_outputencoding" id="crypto_decipher_update_data_inputencoding_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -793,7 +807,7 @@ is specified, a string using the specified encoding is returned. If no
 <p>The <code>decipher.update()</code> method can be called multiple times with new data until
 <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> is called. Calling <code>decipher.update()</code> after
 <a href="#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> will result in an error being thrown.</p>
-<h2>Class: <code>DiffieHellman</code><span><a class="mark" href="#crypto_class_diffiehellman" id="crypto_class_diffiehellman">#</a></span></h2>
+</section><section><h3>Class: <code>DiffieHellman</code><span><a class="mark" href="#crypto_class_diffiehellman" id="crypto_class_diffiehellman">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -805,20 +819,20 @@ exchanges.</p>
 <span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Generate Alice's keys...</span>
-<span class="hljs-keyword">const</span> alice = crypto.createDiffieHellman(<span class="hljs-number">2048</span>);
-<span class="hljs-keyword">const</span> aliceKey = alice.generateKeys();
+<span class="hljs-keyword">const</span> alice = crypto.<span class="hljs-title function_">createDiffieHellman</span>(<span class="hljs-number">2048</span>);
+<span class="hljs-keyword">const</span> aliceKey = alice.<span class="hljs-title function_">generateKeys</span>();
 
 <span class="hljs-comment">// Generate Bob's keys...</span>
-<span class="hljs-keyword">const</span> bob = crypto.createDiffieHellman(alice.getPrime(), alice.getGenerator());
-<span class="hljs-keyword">const</span> bobKey = bob.generateKeys();
+<span class="hljs-keyword">const</span> bob = crypto.<span class="hljs-title function_">createDiffieHellman</span>(alice.<span class="hljs-title function_">getPrime</span>(), alice.<span class="hljs-title function_">getGenerator</span>());
+<span class="hljs-keyword">const</span> bobKey = bob.<span class="hljs-title function_">generateKeys</span>();
 
 <span class="hljs-comment">// Exchange and generate the secret...</span>
-<span class="hljs-keyword">const</span> aliceSecret = alice.computeSecret(bobKey);
-<span class="hljs-keyword">const</span> bobSecret = bob.computeSecret(aliceKey);
+<span class="hljs-keyword">const</span> aliceSecret = alice.<span class="hljs-title function_">computeSecret</span>(bobKey);
+<span class="hljs-keyword">const</span> bobSecret = bob.<span class="hljs-title function_">computeSecret</span>(aliceKey);
 
 <span class="hljs-comment">// OK</span>
-assert.strictEqual(aliceSecret.toString(<span class="hljs-string">'hex'</span>), bobSecret.toString(<span class="hljs-string">'hex'</span>));</code></pre>
-<h3><code>diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_diffiehellman_computesecret_otherpublickey_inputencoding_outputencoding" id="crypto_diffiehellman_computesecret_otherpublickey_inputencoding_outputencoding">#</a></span></h3>
+assert.<span class="hljs-title function_">strictEqual</span>(aliceSecret.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>), bobSecret.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));</code></pre>
+<h4><code>diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_diffiehellman_computesecret_otherpublickey_inputencoding_outputencoding" id="crypto_diffiehellman_computesecret_otherpublickey_inputencoding_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -837,7 +851,7 @@ provided, <code>otherPublicKey</code> is expected to be a <a href="buffer.html">
 <code>TypedArray</code>, or <code>DataView</code>.</p>
 <p>If <code>outputEncoding</code> is given a string is returned; otherwise, a
 <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.generateKeys([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_generatekeys_encoding" id="crypto_diffiehellman_generatekeys_encoding">#</a></span></h3>
+<h4><code>diffieHellman.generateKeys([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_generatekeys_encoding" id="crypto_diffiehellman_generatekeys_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -850,7 +864,7 @@ the public key in the specified <code>encoding</code>. This key should be
 transferred to the other party.
 If <code>encoding</code> is provided a string is returned; otherwise a
 <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.getGenerator([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getgenerator_encoding" id="crypto_diffiehellman_getgenerator_encoding">#</a></span></h3>
+<h4><code>diffieHellman.getGenerator([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getgenerator_encoding" id="crypto_diffiehellman_getgenerator_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -861,7 +875,7 @@ If <code>encoding</code> is provided a string is returned; otherwise a
 <p>Returns the Diffie-Hellman generator in the specified <code>encoding</code>.
 If <code>encoding</code> is provided a string is
 returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.getPrime([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getprime_encoding" id="crypto_diffiehellman_getprime_encoding">#</a></span></h3>
+<h4><code>diffieHellman.getPrime([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getprime_encoding" id="crypto_diffiehellman_getprime_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -872,7 +886,7 @@ returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.
 <p>Returns the Diffie-Hellman prime in the specified <code>encoding</code>.
 If <code>encoding</code> is provided a string is
 returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.getPrivateKey([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getprivatekey_encoding" id="crypto_diffiehellman_getprivatekey_encoding">#</a></span></h3>
+<h4><code>diffieHellman.getPrivateKey([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getprivatekey_encoding" id="crypto_diffiehellman_getprivatekey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -883,7 +897,7 @@ returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.
 <p>Returns the Diffie-Hellman private key in the specified <code>encoding</code>.
 If <code>encoding</code> is provided a
 string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.getPublicKey([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getpublickey_encoding" id="crypto_diffiehellman_getpublickey_encoding">#</a></span></h3>
+<h4><code>diffieHellman.getPublicKey([encoding])</code><span><a class="mark" href="#crypto_diffiehellman_getpublickey_encoding" id="crypto_diffiehellman_getpublickey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -894,7 +908,7 @@ string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is
 <p>Returns the Diffie-Hellman public key in the specified <code>encoding</code>.
 If <code>encoding</code> is provided a
 string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
-<h3><code>diffieHellman.setPrivateKey(privateKey[, encoding])</code><span><a class="mark" href="#crypto_diffiehellman_setprivatekey_privatekey_encoding" id="crypto_diffiehellman_setprivatekey_privatekey_encoding">#</a></span></h3>
+<h4><code>diffieHellman.setPrivateKey(privateKey[, encoding])</code><span><a class="mark" href="#crypto_diffiehellman_setprivatekey_privatekey_encoding" id="crypto_diffiehellman_setprivatekey_privatekey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -906,7 +920,7 @@ string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is
 <code>privateKey</code> is expected
 to be a string. If no <code>encoding</code> is provided, <code>privateKey</code> is expected
 to be a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or <code>DataView</code>.</p>
-<h3><code>diffieHellman.setPublicKey(publicKey[, encoding])</code><span><a class="mark" href="#crypto_diffiehellman_setpublickey_publickey_encoding" id="crypto_diffiehellman_setpublickey_publickey_encoding">#</a></span></h3>
+<h4><code>diffieHellman.setPublicKey(publicKey[, encoding])</code><span><a class="mark" href="#crypto_diffiehellman_setpublickey_publickey_encoding" id="crypto_diffiehellman_setpublickey_publickey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -918,7 +932,7 @@ to be a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>,
 <code>publicKey</code> is expected
 to be a string. If no <code>encoding</code> is provided, <code>publicKey</code> is expected
 to be a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or <code>DataView</code>.</p>
-<h3><code>diffieHellman.verifyError</code><span><a class="mark" href="#crypto_diffiehellman_verifyerror" id="crypto_diffiehellman_verifyerror">#</a></span></h3>
+<h4><code>diffieHellman.verifyError</code><span><a class="mark" href="#crypto_diffiehellman_verifyerror" id="crypto_diffiehellman_verifyerror">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.12</span>
 </div>
@@ -932,16 +946,18 @@ module):</p>
 <li><code>DH_UNABLE_TO_CHECK_GENERATOR</code></li>
 <li><code>DH_NOT_SUITABLE_GENERATOR</code></li>
 </ul>
-<h2>Class: <code>DiffieHellmanGroup</code><span><a class="mark" href="#crypto_class_diffiehellmangroup" id="crypto_class_diffiehellmangroup">#</a></span></h2>
+</section><section><h3>Class: <code>DiffieHellmanGroup</code><span><a class="mark" href="#crypto_class_diffiehellmangroup" id="crypto_class_diffiehellmangroup">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
-<p>The <code>DiffieHellmanGroup</code> class takes a well-known modp group as its argument but
-otherwise works the same as <code>DiffieHellman</code>.</p>
+<p>The <code>DiffieHellmanGroup</code> class takes a well-known modp group as its argument.
+It works the same as <code>DiffieHellman</code>, except that it does not allow changing
+its keys after creation. In other words, it does not implement <code>setPublicKey()</code>
+or <code>setPrivateKey()</code> methods.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> name = <span class="hljs-string">'modp1'</span>;
-<span class="hljs-keyword">const</span> dh = crypto.createDiffieHellmanGroup(name);</code></pre>
+<span class="hljs-keyword">const</span> dh = crypto.<span class="hljs-title function_">createDiffieHellmanGroup</span>(name);</code></pre>
 <p><code>name</code> is taken from <a href="https://www.rfc-editor.org/rfc/rfc2412.txt">RFC 2412</a> (modp1 and 2) and <a href="https://www.rfc-editor.org/rfc/rfc3526.txt">RFC 3526</a>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> perl -ne <span class="hljs-string">'print "$1\n" if /"(modp\d+)"/'</span> src/node_crypto_groups.h</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">perl -ne <span class="hljs-string">'print "$1\n" if /"(modp\d+)"/'</span> src/node_crypto_groups.h</span>
 modp1  #  768 bits
 modp2  # 1024 bits
 modp5  # 1536 bits
@@ -950,7 +966,7 @@ modp15 # etc.
 modp16
 modp17
 modp18</code></pre>
-<h2>Class: <code>ECDH</code><span><a class="mark" href="#crypto_class_ecdh" id="crypto_class_ecdh">#</a></span></h2>
+</section><section><h3>Class: <code>ECDH</code><span><a class="mark" href="#crypto_class_ecdh" id="crypto_class_ecdh">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -962,20 +978,20 @@ key exchanges.</p>
 <span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 
 <span class="hljs-comment">// Generate Alice's keys...</span>
-<span class="hljs-keyword">const</span> alice = crypto.createECDH(<span class="hljs-string">'secp521r1'</span>);
-<span class="hljs-keyword">const</span> aliceKey = alice.generateKeys();
+<span class="hljs-keyword">const</span> alice = crypto.<span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp521r1'</span>);
+<span class="hljs-keyword">const</span> aliceKey = alice.<span class="hljs-title function_">generateKeys</span>();
 
 <span class="hljs-comment">// Generate Bob's keys...</span>
-<span class="hljs-keyword">const</span> bob = crypto.createECDH(<span class="hljs-string">'secp521r1'</span>);
-<span class="hljs-keyword">const</span> bobKey = bob.generateKeys();
+<span class="hljs-keyword">const</span> bob = crypto.<span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp521r1'</span>);
+<span class="hljs-keyword">const</span> bobKey = bob.<span class="hljs-title function_">generateKeys</span>();
 
 <span class="hljs-comment">// Exchange and generate the secret...</span>
-<span class="hljs-keyword">const</span> aliceSecret = alice.computeSecret(bobKey);
-<span class="hljs-keyword">const</span> bobSecret = bob.computeSecret(aliceKey);
+<span class="hljs-keyword">const</span> aliceSecret = alice.<span class="hljs-title function_">computeSecret</span>(bobKey);
+<span class="hljs-keyword">const</span> bobSecret = bob.<span class="hljs-title function_">computeSecret</span>(aliceKey);
 
-assert.strictEqual(aliceSecret.toString(<span class="hljs-string">'hex'</span>), bobSecret.toString(<span class="hljs-string">'hex'</span>));
+assert.<span class="hljs-title function_">strictEqual</span>(aliceSecret.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>), bobSecret.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// OK</span></code></pre>
-<h3>Static method: <code>ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])</code><span><a class="mark" href="#crypto_static_method_ecdh_convertkey_key_curve_inputencoding_outputencoding_format" id="crypto_static_method_ecdh_convertkey_key_curve_inputencoding_outputencoding_format">#</a></span></h3>
+<h4>Static method: <code>ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])</code><span><a class="mark" href="#crypto_static_method_ecdh_convertkey_key_curve_inputencoding_outputencoding_format" id="crypto_static_method_ecdh_convertkey_key_curve_inputencoding_outputencoding_format">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1000,30 +1016,30 @@ format.</p>
 <p>If the <code>inputEncoding</code> is not provided, <code>key</code> is expected to be a <a href="buffer.html"><code>Buffer</code></a>,
 <code>TypedArray</code>, or <code>DataView</code>.</p>
 <p>Example (uncompressing a key):</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { createECDH, ECDH } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { createECDH, <span class="hljs-variable constant_">ECDH</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-keyword">const</span> ecdh = createECDH(<span class="hljs-string">'secp256k1'</span>);
-ecdh.generateKeys();
+<span class="hljs-keyword">const</span> ecdh = <span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp256k1'</span>);
+ecdh.<span class="hljs-title function_">generateKeys</span>();
 
-<span class="hljs-keyword">const</span> compressedKey = ecdh.getPublicKey(<span class="hljs-string">'hex'</span>, <span class="hljs-string">'compressed'</span>);
+<span class="hljs-keyword">const</span> compressedKey = ecdh.<span class="hljs-title function_">getPublicKey</span>(<span class="hljs-string">'hex'</span>, <span class="hljs-string">'compressed'</span>);
 
-<span class="hljs-keyword">const</span> uncompressedKey = ECDH.convertKey(compressedKey,
+<span class="hljs-keyword">const</span> uncompressedKey = <span class="hljs-variable constant_">ECDH</span>.<span class="hljs-title function_">convertKey</span>(compressedKey,
                                         <span class="hljs-string">'secp256k1'</span>,
                                         <span class="hljs-string">'hex'</span>,
                                         <span class="hljs-string">'hex'</span>,
                                         <span class="hljs-string">'uncompressed'</span>);
 
 <span class="hljs-comment">// The converted key and the uncompressed public key should be the same</span>
-<span class="hljs-built_in">console</span>.log(uncompressedKey === ecdh.getPublicKey(<span class="hljs-string">'hex'</span>));</code></pre>
-<h3><code>ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_ecdh_computesecret_otherpublickey_inputencoding_outputencoding" id="crypto_ecdh_computesecret_otherpublickey_inputencoding_outputencoding">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(uncompressedKey === ecdh.<span class="hljs-title function_">getPublicKey</span>(<span class="hljs-string">'hex'</span>));</code></pre>
+<h4><code>ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])</code><span><a class="mark" href="#crypto_ecdh_computesecret_otherpublickey_inputencoding_outputencoding" id="crypto_ecdh_computesecret_otherpublickey_inputencoding_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
-<td><p>Changed error format to better support invalid public key error</p></td></tr>
+<td><p>Changed error format to better support invalid public key error.</p></td></tr>
 <tr><td>v6.0.0</td>
-<td><p>The default <code>inputEncoding</code> changed from <code>binary</code> to <code>utf8</code></p></td></tr>
+<td><p>The default <code>inputEncoding</code> changed from <code>binary</code> to <code>utf8</code>.</p></td></tr>
 <tr><td>v0.11.14</td>
 <td><p><span>Added in: v0.11.14</span></p></td></tr>
 </tbody></table>
@@ -1049,7 +1065,7 @@ provided, <code>otherPublicKey</code> is expected to be a <a href="buffer.html">
 lies outside of the elliptic curve. Since <code>otherPublicKey</code> is
 usually supplied from a remote user over an insecure network,
 be sure to handle this exception accordingly.</p>
-<h3><code>ecdh.generateKeys([encoding[, format]])</code><span><a class="mark" href="#crypto_ecdh_generatekeys_encoding_format" id="crypto_ecdh_generatekeys_encoding_format">#</a></span></h3>
+<h4><code>ecdh.generateKeys([encoding[, format]])</code><span><a class="mark" href="#crypto_ecdh_generatekeys_encoding_format" id="crypto_ecdh_generatekeys_encoding_format">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -1066,7 +1082,7 @@ transferred to the other party.</p>
 <code>'uncompressed'</code> format.</p>
 <p>If <code>encoding</code> is provided a string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a>
 is returned.</p>
-<h3><code>ecdh.getPrivateKey([encoding])</code><span><a class="mark" href="#crypto_ecdh_getprivatekey_encoding" id="crypto_ecdh_getprivatekey_encoding">#</a></span></h3>
+<h4><code>ecdh.getPrivateKey([encoding])</code><span><a class="mark" href="#crypto_ecdh_getprivatekey_encoding" id="crypto_ecdh_getprivatekey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -1076,7 +1092,7 @@ is returned.</p>
 </ul>
 <p>If <code>encoding</code> is specified, a string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is
 returned.</p>
-<h3><code>ecdh.getPublicKey([encoding][, format])</code><span><a class="mark" href="#crypto_ecdh_getpublickey_encoding_format" id="crypto_ecdh_getpublickey_encoding_format">#</a></span></h3>
+<h4><code>ecdh.getPublicKey([encoding][, format])</code><span><a class="mark" href="#crypto_ecdh_getpublickey_encoding_format" id="crypto_ecdh_getpublickey_encoding_format">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -1091,7 +1107,7 @@ returned.</p>
 <code>'uncompressed'</code> format.</p>
 <p>If <code>encoding</code> is specified, a string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is
 returned.</p>
-<h3><code>ecdh.setPrivateKey(privateKey[, encoding])</code><span><a class="mark" href="#crypto_ecdh_setprivatekey_privatekey_encoding" id="crypto_ecdh_setprivatekey_privatekey_encoding">#</a></span></h3>
+<h4><code>ecdh.setPrivateKey(privateKey[, encoding])</code><span><a class="mark" href="#crypto_ecdh_setprivatekey_privatekey_encoding" id="crypto_ecdh_setprivatekey_privatekey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -1106,7 +1122,7 @@ to be a string; otherwise <code>privateKey</code> is expected to be a <a href="b
 <p>If <code>privateKey</code> is not valid for the curve specified when the <code>ECDH</code> object was
 created, an error is thrown. Upon setting the private key, the associated
 public point (key) is also generated and set in the <code>ECDH</code> object.</p>
-<h3><code>ecdh.setPublicKey(publicKey[, encoding])</code><span><a class="mark" href="#crypto_ecdh_setpublickey_publickey_encoding" id="crypto_ecdh_setpublickey_publickey_encoding">#</a></span></h3>
+<h4><code>ecdh.setPublicKey(publicKey[, encoding])</code><span><a class="mark" href="#crypto_ecdh_setpublickey_publickey_encoding" id="crypto_ecdh_setpublickey_publickey_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span><span>Deprecated since: v5.2.0</span>
 </div>
@@ -1126,26 +1142,26 @@ attempts to generate the public point/key associated with the private key being
 set.</p>
 <p>Example (obtaining a shared secret):</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> alice = crypto.createECDH(<span class="hljs-string">'secp256k1'</span>);
-<span class="hljs-keyword">const</span> bob = crypto.createECDH(<span class="hljs-string">'secp256k1'</span>);
+<span class="hljs-keyword">const</span> alice = crypto.<span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp256k1'</span>);
+<span class="hljs-keyword">const</span> bob = crypto.<span class="hljs-title function_">createECDH</span>(<span class="hljs-string">'secp256k1'</span>);
 
 <span class="hljs-comment">// This is a shortcut way of specifying one of Alice's previous private</span>
 <span class="hljs-comment">// keys. It would be unwise to use such a predictable private key in a real</span>
 <span class="hljs-comment">// application.</span>
-alice.setPrivateKey(
-  crypto.createHash(<span class="hljs-string">'sha256'</span>).update(<span class="hljs-string">'alice'</span>, <span class="hljs-string">'utf8'</span>).digest()
+alice.<span class="hljs-title function_">setPrivateKey</span>(
+  crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>).<span class="hljs-title function_">update</span>(<span class="hljs-string">'alice'</span>, <span class="hljs-string">'utf8'</span>).<span class="hljs-title function_">digest</span>()
 );
 
 <span class="hljs-comment">// Bob uses a newly generated cryptographically strong</span>
 <span class="hljs-comment">// pseudorandom key pair</span>
-bob.generateKeys();
+bob.<span class="hljs-title function_">generateKeys</span>();
 
-<span class="hljs-keyword">const</span> aliceSecret = alice.computeSecret(bob.getPublicKey(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
-<span class="hljs-keyword">const</span> bobSecret = bob.computeSecret(alice.getPublicKey(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> aliceSecret = alice.<span class="hljs-title function_">computeSecret</span>(bob.<span class="hljs-title function_">getPublicKey</span>(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> bobSecret = bob.<span class="hljs-title function_">computeSecret</span>(alice.<span class="hljs-title function_">getPublicKey</span>(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
 
 <span class="hljs-comment">// aliceSecret and bobSecret should be the same shared secret value</span>
-<span class="hljs-built_in">console</span>.log(aliceSecret === bobSecret);</code></pre>
-<h2>Class: <code>Hash</code><span><a class="mark" href="#crypto_class_hash" id="crypto_class_hash">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(aliceSecret === bobSecret);</code></pre>
+</section><section><h3>Class: <code>Hash</code><span><a class="mark" href="#crypto_class_hash" id="crypto_class_hash">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -1164,39 +1180,39 @@ computed hash.</li>
 objects are not to be created directly using the <code>new</code> keyword.</p>
 <p>Example: Using <code>Hash</code> objects as streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-hash.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+hash.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Only one element is going to be produced by the</span>
   <span class="hljs-comment">// hash stream.</span>
-  <span class="hljs-keyword">const</span> data = hash.read();
+  <span class="hljs-keyword">const</span> data = hash.<span class="hljs-title function_">read</span>();
   <span class="hljs-keyword">if</span> (data) {
-    <span class="hljs-built_in">console</span>.log(data.toString(<span class="hljs-string">'hex'</span>));
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
     <span class="hljs-comment">// Prints:</span>
     <span class="hljs-comment">//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50</span>
   }
 });
 
-hash.write(<span class="hljs-string">'some data to hash'</span>);
-hash.end();</code></pre>
+hash.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data to hash'</span>);
+hash.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example: Using <code>Hash</code> and piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(<span class="hljs-string">'test.js'</span>);
-input.pipe(hash).pipe(process.stdout);</code></pre>
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'test.js'</span>);
+input.<span class="hljs-title function_">pipe</span>(hash).<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'hex'</span>).<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
 <p>Example: Using the <a href="#crypto_hash_update_data_inputencoding"><code>hash.update()</code></a> and <a href="#crypto_hash_digest_encoding"><code>hash.digest()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-hash.update(<span class="hljs-string">'some data to hash'</span>);
-<span class="hljs-built_in">console</span>.log(hash.digest(<span class="hljs-string">'hex'</span>));
+hash.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some data to hash'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash.<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50</span></code></pre>
-<h3><code>hash.copy([options])</code><span><a class="mark" href="#crypto_hash_copy_options" id="crypto_hash_copy_options">#</a></span></h3>
+<h4><code>hash.copy([options])</code><span><a class="mark" href="#crypto_hash_copy_options" id="crypto_hash_copy_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.1.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> <a href="stream.html#stream_new_stream_transform_options"><code>stream.transform</code> options</a></li>
@@ -1211,19 +1227,19 @@ specify the desired output length in bytes.</p>
 its <a href="#crypto_hash_digest_encoding"><code>hash.digest()</code></a> method has been called.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Calculate a rolling hash.</span>
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-hash.update(<span class="hljs-string">'one'</span>);
-<span class="hljs-built_in">console</span>.log(hash.copy().digest(<span class="hljs-string">'hex'</span>));
+hash.<span class="hljs-title function_">update</span>(<span class="hljs-string">'one'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash.<span class="hljs-title function_">copy</span>().<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 
-hash.update(<span class="hljs-string">'two'</span>);
-<span class="hljs-built_in">console</span>.log(hash.copy().digest(<span class="hljs-string">'hex'</span>));
+hash.<span class="hljs-title function_">update</span>(<span class="hljs-string">'two'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash.<span class="hljs-title function_">copy</span>().<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 
-hash.update(<span class="hljs-string">'three'</span>);
-<span class="hljs-built_in">console</span>.log(hash.copy().digest(<span class="hljs-string">'hex'</span>));
+hash.<span class="hljs-title function_">update</span>(<span class="hljs-string">'three'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hash.<span class="hljs-title function_">copy</span>().<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 
 <span class="hljs-comment">// Etc.</span></code></pre>
-<h3><code>hash.digest([encoding])</code><span><a class="mark" href="#crypto_hash_digest_encoding" id="crypto_hash_digest_encoding">#</a></span></h3>
+<h4><code>hash.digest([encoding])</code><span><a class="mark" href="#crypto_hash_digest_encoding" id="crypto_hash_digest_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -1237,7 +1253,7 @@ If <code>encoding</code> is provided a string will be returned; otherwise
 a <a href="buffer.html"><code>Buffer</code></a> is returned.</p>
 <p>The <code>Hash</code> object can not be used again after <code>hash.digest()</code> method has been
 called. Multiple calls will cause an error to be thrown.</p>
-<h3><code>hash.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_hash_update_data_inputencoding" id="crypto_hash_update_data_inputencoding">#</a></span></h3>
+<h4><code>hash.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_hash_update_data_inputencoding" id="crypto_hash_update_data_inputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1259,7 +1275,7 @@ If <code>encoding</code> is not provided, and the <code>data</code> is a string,
 encoding of <code>'utf8'</code> is enforced. If <code>data</code> is a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or
 <code>DataView</code>, then <code>inputEncoding</code> is ignored.</p>
 <p>This can be called many times with new data as it is streamed.</p>
-<h2>Class: <code>Hmac</code><span><a class="mark" href="#crypto_class_hmac" id="crypto_class_hmac">#</a></span></h2>
+</section><section><h3>Class: <code>Hmac</code><span><a class="mark" href="#crypto_class_hmac" id="crypto_class_hmac">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -1278,37 +1294,37 @@ computed HMAC digest.</li>
 objects are not to be created directly using the <code>new</code> keyword.</p>
 <p>Example: Using <code>Hmac</code> objects as streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hmac = crypto.createHmac(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
+<span class="hljs-keyword">const</span> hmac = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
 
-hmac.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+hmac.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Only one element is going to be produced by the</span>
   <span class="hljs-comment">// hash stream.</span>
-  <span class="hljs-keyword">const</span> data = hmac.read();
+  <span class="hljs-keyword">const</span> data = hmac.<span class="hljs-title function_">read</span>();
   <span class="hljs-keyword">if</span> (data) {
-    <span class="hljs-built_in">console</span>.log(data.toString(<span class="hljs-string">'hex'</span>));
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
     <span class="hljs-comment">// Prints:</span>
     <span class="hljs-comment">//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e</span>
   }
 });
 
-hmac.write(<span class="hljs-string">'some data to hash'</span>);
-hmac.end();</code></pre>
+hmac.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data to hash'</span>);
+hmac.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example: Using <code>Hmac</code> and piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> hmac = crypto.createHmac(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
+<span class="hljs-keyword">const</span> hmac = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(<span class="hljs-string">'test.js'</span>);
-input.pipe(hmac).pipe(process.stdout);</code></pre>
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'test.js'</span>);
+input.<span class="hljs-title function_">pipe</span>(hmac).<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
 <p>Example: Using the <a href="#crypto_hmac_update_data_inputencoding"><code>hmac.update()</code></a> and <a href="#crypto_hmac_digest_encoding"><code>hmac.digest()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> hmac = crypto.createHmac(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
+<span class="hljs-keyword">const</span> hmac = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
 
-hmac.update(<span class="hljs-string">'some data to hash'</span>);
-<span class="hljs-built_in">console</span>.log(hmac.digest(<span class="hljs-string">'hex'</span>));
+hmac.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some data to hash'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hmac.<span class="hljs-title function_">digest</span>(<span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e</span></code></pre>
-<h3><code>hmac.digest([encoding])</code><span><a class="mark" href="#crypto_hmac_digest_encoding" id="crypto_hmac_digest_encoding">#</a></span></h3>
+<h4><code>hmac.digest([encoding])</code><span><a class="mark" href="#crypto_hmac_digest_encoding" id="crypto_hmac_digest_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -1321,7 +1337,7 @@ If <code>encoding</code> is
 provided a string is returned; otherwise a <a href="buffer.html"><code>Buffer</code></a> is returned;</p>
 <p>The <code>Hmac</code> object can not be used again after <code>hmac.digest()</code> has been
 called. Multiple calls to <code>hmac.digest()</code> will result in an error being thrown.</p>
-<h3><code>hmac.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_hmac_update_data_inputencoding" id="crypto_hmac_update_data_inputencoding">#</a></span></h3>
+<h4><code>hmac.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_hmac_update_data_inputencoding" id="crypto_hmac_update_data_inputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1343,12 +1359,12 @@ If <code>encoding</code> is not provided, and the <code>data</code> is a string,
 encoding of <code>'utf8'</code> is enforced. If <code>data</code> is a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or
 <code>DataView</code>, then <code>inputEncoding</code> is ignored.</p>
 <p>This can be called many times with new data as it is streamed.</p>
-<h2>Class: <code>KeyObject</code><span><a class="mark" href="#crypto_class_keyobject" id="crypto_class_keyobject">#</a></span></h2>
+</section><section><h3>Class: <code>KeyObject</code><span><a class="mark" href="#crypto_class_keyobject" id="crypto_class_keyobject">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>Instances of this class can now be passed to worker threads using <code>postMessage</code>.</p></td></tr>
 <tr><td>v11.13.0</td>
 <td><p>This class is now exported.</p></td></tr>
@@ -1368,19 +1384,19 @@ passing keys as strings or <code>Buffer</code>s due to improved security feature
 <p><code>KeyObject</code> instances can be passed to other threads via <a href="worker_threads.html#worker_threads_port_postmessage_value_transferlist"><code>postMessage()</code></a>.
 The receiver obtains a cloned <code>KeyObject</code>, and the <code>KeyObject</code> does not need to
 be listed in the <code>transferList</code> argument.</p>
-<h3><code>keyObject.asymmetricKeyType</code><span><a class="mark" href="#crypto_keyobject_asymmetrickeytype" id="crypto_keyobject_asymmetrickeytype">#</a></span></h3>
+<h4><code>keyObject.asymmetricKeyType</code><span><a class="mark" href="#crypto_keyobject_asymmetrickeytype" id="crypto_keyobject_asymmetrickeytype">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.9.0</td>
 <td><p>Added support for <code>'dh'</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>Added support for <code>'rsa-pss'</code></p></td></tr>
+<td><p>Added support for <code>'rsa-pss'</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>This property now returns <code>undefined</code> for KeyObject instances of unrecognized type instead of aborting.</p></td></tr>
 <tr><td>v12.0.0</td>
-<td><p>Added support for <code>'x25519'</code> and <code>'x448'</code></p></td></tr>
+<td><p>Added support for <code>'x25519'</code> and <code>'x448'</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Added support for <code>'ed25519'</code> and <code>'ed448'</code>.</p></td></tr>
 <tr><td>v11.6.0</td>
@@ -1406,7 +1422,7 @@ types are:</p>
 </ul>
 <p>This property is <code>undefined</code> for unrecognized <code>KeyObject</code> types and symmetric
 keys.</p>
-<h3><code>keyObject.export([options])</code><span><a class="mark" href="#crypto_keyobject_export_options" id="crypto_keyobject_export_options">#</a></span></h3>
+<h4><code>keyObject.export([options])</code><span><a class="mark" href="#crypto_keyobject_export_options" id="crypto_keyobject_export_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
@@ -1429,7 +1445,7 @@ format.</p>
 <code>'sec1'</code> (EC only).</li>
 <li><code>format</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Must be <code>'pem'</code> or <code>'der'</code>.</li>
 <li><code>cipher</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If specified, the private key will be encrypted with
- the given <code>cipher</code> and <code>passphrase</code> using PKCS#5 v2.0 password based
+the given <code>cipher</code> and <code>passphrase</code> using PKCS#5 v2.0 password based
 encryption.</li>
 <li><code>passphrase</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The passphrase to use for encryption, see
 <code>cipher</code>.</li>
@@ -1445,7 +1461,7 @@ encrypted private keys. Since PKCS#8 defines its own
 encryption mechanism, PEM-level encryption is not supported when encrypting
 a PKCS#8 key. See <a href="https://www.rfc-editor.org/rfc/rfc5208.txt">RFC 5208</a> for PKCS#8 encryption and <a href="https://www.rfc-editor.org/rfc/rfc1421.txt">RFC 1421</a> for
 PKCS#1 and SEC1 encryption.</p>
-<h3><code>keyObject.symmetricKeySize</code><span><a class="mark" href="#crypto_keyobject_symmetrickeysize" id="crypto_keyobject_symmetrickeysize">#</a></span></h3>
+<h4><code>keyObject.symmetricKeySize</code><span><a class="mark" href="#crypto_keyobject_symmetrickeysize" id="crypto_keyobject_symmetrickeysize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
@@ -1454,7 +1470,7 @@ PKCS#1 and SEC1 encryption.</p>
 </ul>
 <p>For secret keys, this property represents the size of the key in bytes. This
 property is <code>undefined</code> for asymmetric keys.</p>
-<h3><code>keyObject.type</code><span><a class="mark" href="#crypto_keyobject_type" id="crypto_keyobject_type">#</a></span></h3>
+<h4><code>keyObject.type</code><span><a class="mark" href="#crypto_keyobject_type" id="crypto_keyobject_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
@@ -1464,7 +1480,7 @@ property is <code>undefined</code> for asymmetric keys.</p>
 <p>Depending on the type of this <code>KeyObject</code>, this property is either
 <code>'secret'</code> for secret (symmetric) keys, <code>'public'</code> for public (asymmetric) keys
 or <code>'private'</code> for private (asymmetric) keys.</p>
-<h2>Class: <code>Sign</code><span><a class="mark" href="#crypto_class_sign" id="crypto_class_sign">#</a></span></h2>
+</section><section><h3>Class: <code>Sign</code><span><a class="mark" href="#crypto_class_sign" id="crypto_class_sign">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -1485,42 +1501,44 @@ to be created directly using the <code>new</code> keyword.</p>
 <p>Example: Using <code>Sign</code> and <a href="#crypto_class_verify"><code>Verify</code></a> objects as streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-keyword">const</span> { privateKey, publicKey } = crypto.generateKeyPairSync(<span class="hljs-string">'ec'</span>, {
+<span class="hljs-keyword">const</span> { privateKey, publicKey } = crypto.<span class="hljs-title function_">generateKeyPairSync</span>(<span class="hljs-string">'ec'</span>, {
   <span class="hljs-attr">namedCurve</span>: <span class="hljs-string">'sect239k1'</span>
 });
 
-<span class="hljs-keyword">const</span> sign = crypto.createSign(<span class="hljs-string">'SHA256'</span>);
-sign.write(<span class="hljs-string">'some data to sign'</span>);
-sign.end();
-<span class="hljs-keyword">const</span> signature = sign.sign(privateKey, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> sign = crypto.<span class="hljs-title function_">createSign</span>(<span class="hljs-string">'SHA256'</span>);
+sign.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data to sign'</span>);
+sign.<span class="hljs-title function_">end</span>();
+<span class="hljs-keyword">const</span> signature = sign.<span class="hljs-title function_">sign</span>(privateKey, <span class="hljs-string">'hex'</span>);
 
-<span class="hljs-keyword">const</span> verify = crypto.createVerify(<span class="hljs-string">'SHA256'</span>);
-verify.write(<span class="hljs-string">'some data to sign'</span>);
-verify.end();
-<span class="hljs-built_in">console</span>.log(verify.verify(publicKey, signature, <span class="hljs-string">'hex'</span>));
+<span class="hljs-keyword">const</span> verify = crypto.<span class="hljs-title function_">createVerify</span>(<span class="hljs-string">'SHA256'</span>);
+verify.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data to sign'</span>);
+verify.<span class="hljs-title function_">end</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(verify.<span class="hljs-title function_">verify</span>(publicKey, signature, <span class="hljs-string">'hex'</span>));
 <span class="hljs-comment">// Prints: true</span></code></pre>
 <p>Example: Using the <a href="#crypto_sign_update_data_inputencoding"><code>sign.update()</code></a> and <a href="#crypto_verify_update_data_inputencoding"><code>verify.update()</code></a> methods:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-keyword">const</span> { privateKey, publicKey } = crypto.generateKeyPairSync(<span class="hljs-string">'rsa'</span>, {
+<span class="hljs-keyword">const</span> { privateKey, publicKey } = crypto.<span class="hljs-title function_">generateKeyPairSync</span>(<span class="hljs-string">'rsa'</span>, {
   <span class="hljs-attr">modulusLength</span>: <span class="hljs-number">2048</span>,
 });
 
-<span class="hljs-keyword">const</span> sign = crypto.createSign(<span class="hljs-string">'SHA256'</span>);
-sign.update(<span class="hljs-string">'some data to sign'</span>);
-sign.end();
-<span class="hljs-keyword">const</span> signature = sign.sign(privateKey);
+<span class="hljs-keyword">const</span> sign = crypto.<span class="hljs-title function_">createSign</span>(<span class="hljs-string">'SHA256'</span>);
+sign.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some data to sign'</span>);
+sign.<span class="hljs-title function_">end</span>();
+<span class="hljs-keyword">const</span> signature = sign.<span class="hljs-title function_">sign</span>(privateKey);
 
-<span class="hljs-keyword">const</span> verify = crypto.createVerify(<span class="hljs-string">'SHA256'</span>);
-verify.update(<span class="hljs-string">'some data to sign'</span>);
-verify.end();
-<span class="hljs-built_in">console</span>.log(verify.verify(publicKey, signature));
+<span class="hljs-keyword">const</span> verify = crypto.<span class="hljs-title function_">createVerify</span>(<span class="hljs-string">'SHA256'</span>);
+verify.<span class="hljs-title function_">update</span>(<span class="hljs-string">'some data to sign'</span>);
+verify.<span class="hljs-title function_">end</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(verify.<span class="hljs-title function_">verify</span>(publicKey, signature));
 <span class="hljs-comment">// Prints: true</span></code></pre>
-<h3><code>sign.sign(privateKey[, outputEncoding])</code><span><a class="mark" href="#crypto_sign_sign_privatekey_outputencoding" id="crypto_sign_sign_privatekey_outputencoding">#</a></span></h3>
+<h4><code>sign.sign(privateKey[, outputEncoding])</code><span><a class="mark" href="#crypto_sign_sign_privatekey_outputencoding" id="crypto_sign_sign_privatekey_outputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>This function now supports IEEE-P1363 DSA and ECDSA signatures.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>This function now supports RSA-PSS keys.</p></td></tr>
 <tr><td>v11.6.0</td>
@@ -1580,7 +1598,7 @@ maximum permissible value.</p>
 is returned.</p>
 <p>The <code>Sign</code> object can not be again used after <code>sign.sign()</code> method has been
 called. Multiple calls to <code>sign.sign()</code> will result in an error being thrown.</p>
-<h3><code>sign.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_sign_update_data_inputencoding" id="crypto_sign_update_data_inputencoding">#</a></span></h3>
+<h4><code>sign.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_sign_update_data_inputencoding" id="crypto_sign_update_data_inputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1602,7 +1620,7 @@ If <code>encoding</code> is not provided, and the <code>data</code> is a string,
 encoding of <code>'utf8'</code> is enforced. If <code>data</code> is a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or
 <code>DataView</code>, then <code>inputEncoding</code> is ignored.</p>
 <p>This can be called many times with new data as it is streamed.</p>
-<h2>Class: <code>Verify</code><span><a class="mark" href="#crypto_class_verify" id="crypto_class_verify">#</a></span></h2>
+</section><section><h3>Class: <code>Verify</code><span><a class="mark" href="#crypto_class_verify" id="crypto_class_verify">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -1620,7 +1638,7 @@ the signature.</li>
 <p>The <a href="#crypto_crypto_createverify_algorithm_options"><code>crypto.createVerify()</code></a> method is used to create <code>Verify</code> instances.
 <code>Verify</code> objects are not to be created directly using the <code>new</code> keyword.</p>
 <p>See <a href="#crypto_class_sign"><code>Sign</code></a> for examples.</p>
-<h3><code>verify.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_verify_update_data_inputencoding" id="crypto_verify_update_data_inputencoding">#</a></span></h3>
+<h4><code>verify.update(data[, inputEncoding])</code><span><a class="mark" href="#crypto_verify_update_data_inputencoding" id="crypto_verify_update_data_inputencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1642,11 +1660,13 @@ If <code>inputEncoding</code> is not provided, and the <code>data</code> is a st
 encoding of <code>'utf8'</code> is enforced. If <code>data</code> is a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or
 <code>DataView</code>, then <code>inputEncoding</code> is ignored.</p>
 <p>This can be called many times with new data as it is streamed.</p>
-<h3><code>verify.verify(object, signature[, signatureEncoding])</code><span><a class="mark" href="#crypto_verify_verify_object_signature_signatureencoding" id="crypto_verify_verify_object_signature_signatureencoding">#</a></span></h3>
+<h4><code>verify.verify(object, signature[, signatureEncoding])</code><span><a class="mark" href="#crypto_verify_verify_object_signature_signatureencoding" id="crypto_verify_verify_object_signature_signatureencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>This function now supports IEEE-P1363 DSA and ECDSA signatures.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>This function now supports RSA-PSS keys.</p></td></tr>
 <tr><td>v11.7.0</td>
@@ -1678,7 +1698,7 @@ object, the following additional properties can be passed:</p>
 <ul>
 <li>
 <p><code>dsaEncoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> For DSA and ECDSA, this option specifies the
-format of the generated signature. It can be one of the following:</p>
+format of the signature. It can be one of the following:</p>
 <ul>
 <li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>
 <li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>
@@ -1713,8 +1733,8 @@ called. Multiple calls to <code>verify.verify()</code> will result in an error b
 thrown.</p>
 <p>Because public keys can be derived from private keys, a private key may
 be passed instead of a public key.</p>
-<h2><code>crypto</code> module methods and properties<span><a class="mark" href="#crypto_crypto_module_methods_and_properties" id="crypto_crypto_module_methods_and_properties">#</a></span></h2>
-<h3><code>crypto.constants</code><span><a class="mark" href="#crypto_crypto_constants" id="crypto_crypto_constants">#</a></span></h3>
+</section><section><h3><code>crypto</code> module methods and properties<span><a class="mark" href="#crypto_crypto_module_methods_and_properties" id="crypto_crypto_module_methods_and_properties">#</a></span></h3>
+<h4><code>crypto.constants</code><span><a class="mark" href="#crypto_crypto_constants" id="crypto_crypto_constants">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -1723,7 +1743,7 @@ be passed instead of a public key.</p>
 security related operations. The specific constants currently defined are
 described in <a href="#crypto_crypto_constants_1">Crypto constants</a>.</li>
 </ul>
-<h3><code>crypto.DEFAULT_ENCODING</code><span><a class="mark" href="#crypto_crypto_default_encoding" id="crypto_crypto_default_encoding">#</a></span></h3>
+<h4><code>crypto.DEFAULT_ENCODING</code><span><a class="mark" href="#crypto_crypto_default_encoding" id="crypto_crypto_default_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span><span>Deprecated since: v10.0.0</span>
 </div>
@@ -1735,7 +1755,7 @@ default to <a href="buffer.html"><code>Buffer</code></a> objects.</p>
 with legacy programs that expect <code>'latin1'</code> to be the default encoding.</p>
 <p>New applications should expect the default to be <code>'buffer'</code>.</p>
 <p>This property is deprecated.</p>
-<h3><code>crypto.fips</code><span><a class="mark" href="#crypto_crypto_fips" id="crypto_crypto_fips">#</a></span></h3>
+<h4><code>crypto.fips</code><span><a class="mark" href="#crypto_crypto_fips" id="crypto_crypto_fips">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span><span>Deprecated since: v10.0.0</span>
 </div>
@@ -1744,7 +1764,7 @@ with legacy programs that expect <code>'latin1'</code> to be the default encodin
 is currently in use. Setting to true requires a FIPS build of Node.js.</p>
 <p>This property is deprecated. Please use <code>crypto.setFips()</code> and
 <code>crypto.getFips()</code> instead.</p>
-<h3><code>crypto.createCipher(algorithm, password[, options])</code><span><a class="mark" href="#crypto_crypto_createcipher_algorithm_password_options" id="crypto_crypto_createcipher_algorithm_password_options">#</a></span></h3>
+<h4><code>crypto.createCipher(algorithm, password[, options])</code><span><a class="mark" href="#crypto_crypto_createcipher_algorithm_password_options" id="crypto_crypto_createcipher_algorithm_password_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1796,14 +1816,14 @@ to create the <code>Cipher</code> object. Users should not use ciphers with coun
 they are used in order to avoid the risk of IV reuse that causes
 vulnerabilities. For the case when IV is reused in GCM, see <a href="https://github.com/nonce-disrespect/nonce-disrespect">Nonce-Disrespecting
 Adversaries</a> for details.</p>
-<h3><code>crypto.createCipheriv(algorithm, key, iv[, options])</code><span><a class="mark" href="#crypto_crypto_createcipheriv_algorithm_key_iv_options" id="crypto_crypto_createcipheriv_algorithm_key_iv_options">#</a></span></h3>
+<h4><code>crypto.createCipheriv(algorithm, key, iv[, options])</code><span><a class="mark" href="#crypto_crypto_createcipheriv_algorithm_key_iv_options" id="crypto_crypto_createcipheriv_algorithm_key_iv_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v11.6.0</td>
 <td><p>The <code>key</code> argument can now be a <code>KeyObject</code>.</p></td></tr>
-<tr><td>v11.2.0</td>
+<tr><td>v11.2.0, v10.17.0</td>
 <td><p>The cipher <code>chacha20-poly1305</code> is now supported.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>Ciphers in OCB mode are now supported.</p></td></tr>
@@ -1846,7 +1866,7 @@ added to ciphertext messages unencrypted. It may sound contradictory that
 something has to be unpredictable and unique, but does not have to be secret;
 remember that an attacker must not be able to predict ahead of time what a
 given IV will be.</p>
-<h3><code>crypto.createDecipher(algorithm, password[, options])</code><span><a class="mark" href="#crypto_crypto_createdecipher_algorithm_password_options" id="crypto_crypto_createdecipher_algorithm_password_options">#</a></span></h3>
+<h4><code>crypto.createDecipher(algorithm, password[, options])</code><span><a class="mark" href="#crypto_crypto_createdecipher_algorithm_password_options" id="crypto_crypto_createdecipher_algorithm_password_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1883,14 +1903,14 @@ rapidly.</p>
 <a href="https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html"><code>EVP_BytesToKey</code></a> it is recommended that developers derive a key and IV on
 their own using <a href="#crypto_crypto_scrypt_password_salt_keylen_options_callback"><code>crypto.scrypt()</code></a> and to use <a href="#crypto_crypto_createdecipheriv_algorithm_key_iv_options"><code>crypto.createDecipheriv()</code></a>
 to create the <code>Decipher</code> object.</p>
-<h3><code>crypto.createDecipheriv(algorithm, key, iv[, options])</code><span><a class="mark" href="#crypto_crypto_createdecipheriv_algorithm_key_iv_options" id="crypto_crypto_createdecipheriv_algorithm_key_iv_options">#</a></span></h3>
+<h4><code>crypto.createDecipheriv(algorithm, key, iv[, options])</code><span><a class="mark" href="#crypto_crypto_createdecipheriv_algorithm_key_iv_options" id="crypto_crypto_createdecipheriv_algorithm_key_iv_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v11.6.0</td>
 <td><p>The <code>key</code> argument can now be a <code>KeyObject</code>.</p></td></tr>
-<tr><td>v11.2.0</td>
+<tr><td>v11.2.0, v10.17.0</td>
 <td><p>The cipher <code>chacha20-poly1305</code> is now supported.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>Ciphers in OCB mode are now supported.</p></td></tr>
@@ -1933,7 +1953,7 @@ added to ciphertext messages unencrypted. It may sound contradictory that
 something has to be unpredictable and unique, but does not have to be secret;
 remember that an attacker must not be able to predict ahead of time what a given
 IV will be.</p>
-<h3><code>crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])</code><span><a class="mark" href="#crypto_crypto_creatediffiehellman_prime_primeencoding_generator_generatorencoding" id="crypto_crypto_creatediffiehellman_prime_primeencoding_generator_generatorencoding">#</a></span></h3>
+<h4><code>crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])</code><span><a class="mark" href="#crypto_crypto_creatediffiehellman_prime_primeencoding_generator_generatorencoding" id="crypto_crypto_creatediffiehellman_prime_primeencoding_generator_generatorencoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1965,7 +1985,7 @@ optional specific <code>generator</code>.</p>
 a <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or <code>DataView</code> is expected.</p>
 <p>If <code>generatorEncoding</code> is specified, <code>generator</code> is expected to be a string;
 otherwise a number, <a href="buffer.html"><code>Buffer</code></a>, <code>TypedArray</code>, or <code>DataView</code> is expected.</p>
-<h3><code>crypto.createDiffieHellman(primeLength[, generator])</code><span><a class="mark" href="#crypto_crypto_creatediffiehellman_primelength_generator" id="crypto_crypto_creatediffiehellman_primelength_generator">#</a></span></h3>
+<h4><code>crypto.createDiffieHellman(primeLength[, generator])</code><span><a class="mark" href="#crypto_crypto_creatediffiehellman_primelength_generator" id="crypto_crypto_creatediffiehellman_primelength_generator">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -1977,7 +1997,7 @@ otherwise a number, <a href="buffer.html"><code>Buffer</code></a>, <code>TypedAr
 <p>Creates a <code>DiffieHellman</code> key exchange object and generates a prime of
 <code>primeLength</code> bits using an optional specific numeric <code>generator</code>.
 If <code>generator</code> is not specified, the value <code>2</code> is used.</p>
-<h3><code>crypto.createDiffieHellmanGroup(name)</code><span><a class="mark" href="#crypto_crypto_creatediffiehellmangroup_name" id="crypto_crypto_creatediffiehellmangroup_name">#</a></span></h3>
+<h4><code>crypto.createDiffieHellmanGroup(name)</code><span><a class="mark" href="#crypto_crypto_creatediffiehellmangroup_name" id="crypto_crypto_creatediffiehellmangroup_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -1986,7 +2006,7 @@ If <code>generator</code> is not specified, the value <code>2</code> is used.</p
 <li>Returns: <a href="crypto.html#crypto_class_diffiehellmangroup" class="type">&#x3C;DiffieHellmanGroup></a></li>
 </ul>
 <p>An alias for <a href="#crypto_crypto_getdiffiehellman_groupname"><code>crypto.getDiffieHellman()</code></a></p>
-<h3><code>crypto.createECDH(curveName)</code><span><a class="mark" href="#crypto_crypto_createecdh_curvename" id="crypto_crypto_createecdh_curvename">#</a></span></h3>
+<h4><code>crypto.createECDH(curveName)</code><span><a class="mark" href="#crypto_crypto_createecdh_curvename" id="crypto_crypto_createecdh_curvename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -1999,7 +2019,7 @@ predefined curve specified by the <code>curveName</code> string. Use
 <a href="#crypto_crypto_getcurves"><code>crypto.getCurves()</code></a> to obtain a list of available curve names. On recent
 OpenSSL releases, <code>openssl ecparam -list_curves</code> will also display the name
 and description of each available elliptic curve.</p>
-<h3><code>crypto.createHash(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createhash_algorithm_options" id="crypto_crypto_createhash_algorithm_options">#</a></span></h3>
+<h4><code>crypto.createHash(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createhash_algorithm_options" id="crypto_crypto_createhash_algorithm_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2026,24 +2046,24 @@ On recent releases of OpenSSL, <code>openssl list -digest-algorithms</code>
 (<code>openssl list-message-digest-algorithms</code> for older versions of OpenSSL) will
 display the available digest algorithms.</p>
 <p>Example: generating the sha256 sum of a file</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> filename = process.argv[<span class="hljs-number">2</span>];
+<pre><code class="language-js"><span class="hljs-keyword">const</span> filename = process.<span class="hljs-property">argv</span>[<span class="hljs-number">2</span>];
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
+<span class="hljs-keyword">const</span> hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(filename);
-input.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(filename);
+input.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Only one element is going to be produced by the</span>
   <span class="hljs-comment">// hash stream.</span>
-  <span class="hljs-keyword">const</span> data = input.read();
+  <span class="hljs-keyword">const</span> data = input.<span class="hljs-title function_">read</span>();
   <span class="hljs-keyword">if</span> (data)
-    hash.update(data);
+    hash.<span class="hljs-title function_">update</span>(data);
   <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${hash.digest(<span class="hljs-string">'hex'</span>)}</span> <span class="hljs-subst">${filename}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${hash.digest(<span class="hljs-string">'hex'</span>)}</span> <span class="hljs-subst">${filename}</span>`</span>);
   }
 });</code></pre>
-<h3><code>crypto.createHmac(algorithm, key[, options])</code><span><a class="mark" href="#crypto_crypto_createhmac_algorithm_key_options" id="crypto_crypto_createhmac_algorithm_key_options">#</a></span></h3>
+<h4><code>crypto.createHmac(algorithm, key[, options])</code><span><a class="mark" href="#crypto_crypto_createhmac_algorithm_key_options" id="crypto_crypto_createhmac_algorithm_key_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2071,24 +2091,24 @@ display the available digest algorithms.</p>
 <p>The <code>key</code> is the HMAC key used to generate the cryptographic HMAC hash. If it is
 a <a href="#crypto_class_keyobject"><code>KeyObject</code></a>, its type must be <code>secret</code>.</p>
 <p>Example: generating the sha256 HMAC of a file</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> filename = process.argv[<span class="hljs-number">2</span>];
+<pre><code class="language-js"><span class="hljs-keyword">const</span> filename = process.<span class="hljs-property">argv</span>[<span class="hljs-number">2</span>];
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> hmac = crypto.createHmac(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
+<span class="hljs-keyword">const</span> hmac = crypto.<span class="hljs-title function_">createHmac</span>(<span class="hljs-string">'sha256'</span>, <span class="hljs-string">'a secret'</span>);
 
-<span class="hljs-keyword">const</span> input = fs.createReadStream(filename);
-input.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+<span class="hljs-keyword">const</span> input = fs.<span class="hljs-title function_">createReadStream</span>(filename);
+input.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Only one element is going to be produced by the</span>
   <span class="hljs-comment">// hash stream.</span>
-  <span class="hljs-keyword">const</span> data = input.read();
+  <span class="hljs-keyword">const</span> data = input.<span class="hljs-title function_">read</span>();
   <span class="hljs-keyword">if</span> (data)
-    hmac.update(data);
+    hmac.<span class="hljs-title function_">update</span>(data);
   <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${hmac.digest(<span class="hljs-string">'hex'</span>)}</span> <span class="hljs-subst">${filename}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${hmac.digest(<span class="hljs-string">'hex'</span>)}</span> <span class="hljs-subst">${filename}</span>`</span>);
   }
 });</code></pre>
-<h3><code>crypto.createPrivateKey(key)</code><span><a class="mark" href="#crypto_crypto_createprivatekey_key" id="crypto_crypto_createprivatekey_key">#</a></span></h3>
+<h4><code>crypto.createPrivateKey(key)</code><span><a class="mark" href="#crypto_crypto_createprivatekey_key" id="crypto_crypto_createprivatekey_key">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
@@ -2109,7 +2129,7 @@ string or <code>Buffer</code>, <code>format</code> is assumed to be <code>'pem'<
 must be an object with the properties described above.</p>
 <p>If the private key is encrypted, a <code>passphrase</code> must be specified. The length
 of the passphrase is limited to 1024 bytes.</p>
-<h3><code>crypto.createPublicKey(key)</code><span><a class="mark" href="#crypto_crypto_createpublickey_key" id="crypto_crypto_createpublickey_key">#</a></span></h3>
+<h4><code>crypto.createPublicKey(key)</code><span><a class="mark" href="#crypto_crypto_createpublickey_key" id="crypto_crypto_createpublickey_key">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2146,17 +2166,17 @@ returned <code>KeyObject</code> will be <code>'public'</code> and that the priva
 extracted from the returned <code>KeyObject</code>. Similarly, if a <code>KeyObject</code> with type
 <code>'private'</code> is given, a new <code>KeyObject</code> with type <code>'public'</code> will be returned
 and it will be impossible to extract the private key from the returned object.</p>
-<h3><code>crypto.createSecretKey(key)</code><span><a class="mark" href="#crypto_crypto_createsecretkey_key" id="crypto_crypto_createsecretkey_key">#</a></span></h3>
+<h4><code>crypto.createSecretKey(key)</code><span><a class="mark" href="#crypto_crypto_createsecretkey_key" id="crypto_crypto_createsecretkey_key">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.6.0</span>
 </div>
 <ul>
-<li><code>key</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>key</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
 <li>Returns: <a href="crypto.html#crypto_class_keyobject" class="type">&#x3C;KeyObject></a></li>
 </ul>
 <p>Creates and returns a new key object containing a secret key for symmetric
 encryption or <code>Hmac</code>.</p>
-<h3><code>crypto.createSign(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createsign_algorithm_options" id="crypto_crypto_createsign_algorithm_options">#</a></span></h3>
+<h4><code>crypto.createSign(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createsign_algorithm_options" id="crypto_crypto_createsign_algorithm_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -2173,7 +2193,7 @@ algorithm, such as <code>'RSA-SHA256'</code>, instead of a digest algorithm. Thi
 the corresponding digest algorithm. This does not work for all signature
 algorithms, such as <code>'ecdsa-with-SHA256'</code>, so it is best to always use digest
 algorithm names.</p>
-<h3><code>crypto.createVerify(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createverify_algorithm_options" id="crypto_crypto_createverify_algorithm_options">#</a></span></h3>
+<h4><code>crypto.createVerify(algorithm[, options])</code><span><a class="mark" href="#crypto_crypto_createverify_algorithm_options" id="crypto_crypto_createverify_algorithm_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.92</span>
 </div>
@@ -2191,9 +2211,9 @@ algorithm, such as <code>'RSA-SHA256'</code>, instead of a digest algorithm. Thi
 the corresponding digest algorithm. This does not work for all signature
 algorithms, such as <code>'ecdsa-with-SHA256'</code>, so it is best to always use digest
 algorithm names.</p>
-<h3><code>crypto.diffieHellman(options)</code><span><a class="mark" href="#crypto_crypto_diffiehellman_options" id="crypto_crypto_diffiehellman_options">#</a></span></h3>
+<h4><code>crypto.diffieHellman(options)</code><span><a class="mark" href="#crypto_crypto_diffiehellman_options" id="crypto_crypto_diffiehellman_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.9.0</span>
 </div>
 <ul>
 <li><code>options</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -2207,12 +2227,12 @@ algorithm names.</p>
 <p>Computes the Diffie-Hellman secret based on a <code>privateKey</code> and a <code>publicKey</code>.
 Both keys must have the same <code>asymmetricKeyType</code>, which must be one of <code>'dh'</code>
 (for Diffie-Hellman), <code>'ec'</code> (for ECDH), <code>'x448'</code>, or <code>'x25519'</code> (for ECDH-ES).</p>
-<h3><code>crypto.generateKeyPair(type, options, callback)</code><span><a class="mark" href="#crypto_crypto_generatekeypair_type_options_callback" id="crypto_crypto_generatekeypair_type_options_callback">#</a></span></h3>
+<h4><code>crypto.generateKeyPair(type, options, callback)</code><span><a class="mark" href="#crypto_crypto_generatekeypair_type_options_callback" id="crypto_crypto_generatekeypair_type_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.9.0</td>
 <td><p>Add support for Diffie-Hellman.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Add ability to generate X25519 and X448 key pairs.</p></td></tr>
@@ -2259,7 +2279,7 @@ the respective part of the key is returned as a <a href="#crypto_class_keyobject
 <p>It is recommended to encode public keys as <code>'spki'</code> and private keys as
 <code>'pkcs8'</code> with encryption for long-term storage:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { generateKeyPair } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-generateKeyPair(<span class="hljs-string">'rsa'</span>, {
+<span class="hljs-title function_">generateKeyPair</span>(<span class="hljs-string">'rsa'</span>, {
   <span class="hljs-attr">modulusLength</span>: <span class="hljs-number">4096</span>,
   <span class="hljs-attr">publicKeyEncoding</span>: {
     <span class="hljs-attr">type</span>: <span class="hljs-string">'spki'</span>,
@@ -2278,12 +2298,12 @@ generateKeyPair(<span class="hljs-string">'rsa'</span>, {
 <code>publicKey</code> / <code>privateKey</code> representing the generated key pair.</p>
 <p>If this method is invoked as its <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
 a <code>Promise</code> for an <code>Object</code> with <code>publicKey</code> and <code>privateKey</code> properties.</p>
-<h3><code>crypto.generateKeyPairSync(type, options)</code><span><a class="mark" href="#crypto_crypto_generatekeypairsync_type_options" id="crypto_crypto_generatekeypairsync_type_options">#</a></span></h3>
+<h4><code>crypto.generateKeyPairSync(type, options)</code><span><a class="mark" href="#crypto_crypto_generatekeypairsync_type_options" id="crypto_crypto_generatekeypairsync_type_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.9.0</td>
 <td><p>Add support for Diffie-Hellman.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Add ability to generate Ed25519 and Ed448 key pairs.</p></td></tr>
@@ -2328,7 +2348,7 @@ the respective part of the key is returned as a <a href="#crypto_class_keyobject
 private keys, it is recommended to use <code>'pkcs8'</code> with a strong passphrase,
 and to keep the passphrase confidential.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { generateKeyPairSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> { publicKey, privateKey } = generateKeyPairSync(<span class="hljs-string">'rsa'</span>, {
+<span class="hljs-keyword">const</span> { publicKey, privateKey } = <span class="hljs-title function_">generateKeyPairSync</span>(<span class="hljs-string">'rsa'</span>, {
   <span class="hljs-attr">modulusLength</span>: <span class="hljs-number">4096</span>,
   <span class="hljs-attr">publicKeyEncoding</span>: {
     <span class="hljs-attr">type</span>: <span class="hljs-string">'spki'</span>,
@@ -2344,7 +2364,7 @@ and to keep the passphrase confidential.</p>
 <p>The return value <code>{ publicKey, privateKey }</code> represents the generated key pair.
 When PEM encoding was selected, the respective key will be a string, otherwise
 it will be a buffer containing the data encoded as DER.</p>
-<h3><code>crypto.getCiphers()</code><span><a class="mark" href="#crypto_crypto_getciphers" id="crypto_crypto_getciphers">#</a></span></h3>
+<h4><code>crypto.getCiphers()</code><span><a class="mark" href="#crypto_crypto_getciphers" id="crypto_crypto_getciphers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -2352,18 +2372,18 @@ it will be a buffer containing the data encoded as DER.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> An array with the names of the supported cipher
 algorithms.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ciphers = crypto.getCiphers();
-<span class="hljs-built_in">console</span>.log(ciphers); <span class="hljs-comment">// ['aes-128-cbc', 'aes-128-ccm', ...]</span></code></pre>
-<h3><code>crypto.getCurves()</code><span><a class="mark" href="#crypto_crypto_getcurves" id="crypto_crypto_getcurves">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ciphers = crypto.<span class="hljs-title function_">getCiphers</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(ciphers); <span class="hljs-comment">// ['aes-128-cbc', 'aes-128-ccm', ...]</span></code></pre>
+<h4><code>crypto.getCurves()</code><span><a class="mark" href="#crypto_crypto_getcurves" id="crypto_crypto_getcurves">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v2.3.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> An array with the names of the supported elliptic curves.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> curves = crypto.getCurves();
-<span class="hljs-built_in">console</span>.log(curves); <span class="hljs-comment">// ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]</span></code></pre>
-<h3><code>crypto.getDiffieHellman(groupName)</code><span><a class="mark" href="#crypto_crypto_getdiffiehellman_groupname" id="crypto_crypto_getdiffiehellman_groupname">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> curves = crypto.<span class="hljs-title function_">getCurves</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(curves); <span class="hljs-comment">// ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]</span></code></pre>
+<h4><code>crypto.getDiffieHellman(groupName)</code><span><a class="mark" href="#crypto_crypto_getdiffiehellman_groupname" id="crypto_crypto_getdiffiehellman_groupname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
@@ -2383,18 +2403,18 @@ generate nor exchange a group modulus beforehand, saving both processor
 and communication time.</p>
 <p>Example (obtaining a shared secret):</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> alice = crypto.getDiffieHellman(<span class="hljs-string">'modp14'</span>);
-<span class="hljs-keyword">const</span> bob = crypto.getDiffieHellman(<span class="hljs-string">'modp14'</span>);
+<span class="hljs-keyword">const</span> alice = crypto.<span class="hljs-title function_">getDiffieHellman</span>(<span class="hljs-string">'modp14'</span>);
+<span class="hljs-keyword">const</span> bob = crypto.<span class="hljs-title function_">getDiffieHellman</span>(<span class="hljs-string">'modp14'</span>);
 
-alice.generateKeys();
-bob.generateKeys();
+alice.<span class="hljs-title function_">generateKeys</span>();
+bob.<span class="hljs-title function_">generateKeys</span>();
 
-<span class="hljs-keyword">const</span> aliceSecret = alice.computeSecret(bob.getPublicKey(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
-<span class="hljs-keyword">const</span> bobSecret = bob.computeSecret(alice.getPublicKey(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> aliceSecret = alice.<span class="hljs-title function_">computeSecret</span>(bob.<span class="hljs-title function_">getPublicKey</span>(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> bobSecret = bob.<span class="hljs-title function_">computeSecret</span>(alice.<span class="hljs-title function_">getPublicKey</span>(), <span class="hljs-literal">null</span>, <span class="hljs-string">'hex'</span>);
 
 <span class="hljs-comment">/* aliceSecret and bobSecret should be the same */</span>
-<span class="hljs-built_in">console</span>.log(aliceSecret === bobSecret);</code></pre>
-<h3><code>crypto.getFips()</code><span><a class="mark" href="#crypto_crypto_getfips" id="crypto_crypto_getfips">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(aliceSecret === bobSecret);</code></pre>
+<h4><code>crypto.getFips()</code><span><a class="mark" href="#crypto_crypto_getfips" id="crypto_crypto_getfips">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -2403,7 +2423,7 @@ bob.generateKeys();
 currently in use, <code>0</code> otherwise. A future semver-major release may change
 the return type of this API to a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a>.</li>
 </ul>
-<h3><code>crypto.getHashes()</code><span><a class="mark" href="#crypto_crypto_gethashes" id="crypto_crypto_gethashes">#</a></span></h3>
+<h4><code>crypto.getHashes()</code><span><a class="mark" href="#crypto_crypto_gethashes" id="crypto_crypto_gethashes">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -2411,13 +2431,15 @@ the return type of this API to a <a href="https://developer.mozilla.org/en-US/do
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> An array of the names of the supported hash algorithms,
 such as <code>'RSA-SHA256'</code>. Hash algorithms are also called "digest" algorithms.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hashes = crypto.getHashes();
-<span class="hljs-built_in">console</span>.log(hashes); <span class="hljs-comment">// ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]</span></code></pre>
-<h3><code>crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)</code><span><a class="mark" href="#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback" id="crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hashes = crypto.<span class="hljs-title function_">getHashes</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hashes); <span class="hljs-comment">// ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]</span></code></pre>
+<h4><code>crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)</code><span><a class="mark" href="#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback" id="crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>iterations</code> parameter is now restricted to positive values. Earlier releases treated other values as one.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>digest</code> parameter is always required now.</p></td></tr>
 <tr><td>v6.0.0</td>
@@ -2459,29 +2481,31 @@ but will take a longer amount of time to complete.</p>
 <p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is
 random and at least 16 bytes long. See <a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf">NIST SP 800-132</a> for details.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-crypto.pbkdf2(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'sha512'</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
+crypto.<span class="hljs-title function_">pbkdf2</span>(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'sha512'</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(derivedKey.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(derivedKey.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
 });</code></pre>
 <p>The <code>crypto.DEFAULT_ENCODING</code> property can be used to change the way the
 <code>derivedKey</code> is passed to the callback. This property, however, has been
 deprecated and use should be avoided.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-crypto.DEFAULT_ENCODING = <span class="hljs-string">'hex'</span>;
-crypto.pbkdf2(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">512</span>, <span class="hljs-string">'sha512'</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
+crypto.<span class="hljs-property">DEFAULT_ENCODING</span> = <span class="hljs-string">'hex'</span>;
+crypto.<span class="hljs-title function_">pbkdf2</span>(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">512</span>, <span class="hljs-string">'sha512'</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(derivedKey);  <span class="hljs-comment">// '3745e48...aa39b34'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(derivedKey);  <span class="hljs-comment">// '3745e48...aa39b34'</span>
 });</code></pre>
 <p>An array of supported digest functions can be retrieved using
 <a href="#crypto_crypto_gethashes"><code>crypto.getHashes()</code></a>.</p>
 <p>This API uses libuv's threadpool, which can have surprising and
 negative performance implications for some applications; see the
 <a href="cli.html#cli_uv_threadpool_size_size"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>
-<h3><code>crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)</code><span><a class="mark" href="#crypto_crypto_pbkdf2sync_password_salt_iterations_keylen_digest" id="crypto_crypto_pbkdf2sync_password_salt_iterations_keylen_digest">#</a></span></h3>
+<h4><code>crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)</code><span><a class="mark" href="#crypto_crypto_pbkdf2sync_password_salt_iterations_keylen_digest" id="crypto_crypto_pbkdf2sync_password_salt_iterations_keylen_digest">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>iterations</code> parameter is now restricted to positive values. Earlier releases treated other values as one.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>Calling this function without passing the <code>digest</code> parameter is deprecated now and will emit a warning.</p></td></tr>
 <tr><td>v6.0.0</td>
@@ -2513,18 +2537,18 @@ but will take a longer amount of time to complete.</p>
 <p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is
 random and at least 16 bytes long. See <a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf">NIST SP 800-132</a> for details.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-<span class="hljs-keyword">const</span> key = crypto.pbkdf2Sync(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'sha512'</span>);
-<span class="hljs-built_in">console</span>.log(key.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span></code></pre>
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">pbkdf2Sync</span>(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'sha512'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span></code></pre>
 <p>The <code>crypto.DEFAULT_ENCODING</code> property may be used to change the way the
 <code>derivedKey</code> is returned. This property, however, is deprecated and use
 should be avoided.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-crypto.DEFAULT_ENCODING = <span class="hljs-string">'hex'</span>;
-<span class="hljs-keyword">const</span> key = crypto.pbkdf2Sync(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">512</span>, <span class="hljs-string">'sha512'</span>);
-<span class="hljs-built_in">console</span>.log(key);  <span class="hljs-comment">// '3745e48...aa39b34'</span></code></pre>
+crypto.<span class="hljs-property">DEFAULT_ENCODING</span> = <span class="hljs-string">'hex'</span>;
+<span class="hljs-keyword">const</span> key = crypto.<span class="hljs-title function_">pbkdf2Sync</span>(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">100000</span>, <span class="hljs-number">512</span>, <span class="hljs-string">'sha512'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key);  <span class="hljs-comment">// '3745e48...aa39b34'</span></code></pre>
 <p>An array of supported digest functions can be retrieved using
 <a href="#crypto_crypto_gethashes"><code>crypto.getHashes()</code></a>.</p>
-<h3><code>crypto.privateDecrypt(privateKey, buffer)</code><span><a class="mark" href="#crypto_crypto_privatedecrypt_privatekey_buffer" id="crypto_crypto_privatedecrypt_privatekey_buffer">#</a></span></h3>
+<h4><code>crypto.privateDecrypt(privateKey, buffer)</code><span><a class="mark" href="#crypto_crypto_privatedecrypt_privatekey_buffer" id="crypto_crypto_privatedecrypt_privatekey_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2546,7 +2570,7 @@ crypto.DEFAULT_ENCODING = <span class="hljs-string">'hex'</span>;
 <li><code>oaepHash</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The hash function to use for OAEP padding and MGF1.
 <strong>Default:</strong> <code>'sha1'</code></li>
 <li><code>oaepLabel</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The label to use for OAEP
- padding. If not specified, no label is used.</li>
+padding. If not specified, no label is used.</li>
 <li><code>padding</code> <a href="crypto.html#crypto_crypto_constants_1" class="type">&#x3C;crypto.constants></a> An optional padding value defined in
 <code>crypto.constants</code>, which may be: <code>crypto.constants.RSA_NO_PADDING</code>,
 <code>crypto.constants.RSA_PKCS1_PADDING</code>, or
@@ -2562,7 +2586,7 @@ the corresponding public key, for example using <a href="#crypto_crypto_publicen
 <code>privateKey</code> had been passed to <a href="#crypto_crypto_createprivatekey_key"><code>crypto.createPrivateKey()</code></a>. If it is an
 object, the <code>padding</code> property can be passed. Otherwise, this function uses
 <code>RSA_PKCS1_OAEP_PADDING</code>.</p>
-<h3><code>crypto.privateEncrypt(privateKey, buffer)</code><span><a class="mark" href="#crypto_crypto_privateencrypt_privatekey_buffer" id="crypto_crypto_privateencrypt_privatekey_buffer">#</a></span></h3>
+<h4><code>crypto.privateEncrypt(privateKey, buffer)</code><span><a class="mark" href="#crypto_crypto_privateencrypt_privatekey_buffer" id="crypto_crypto_privateencrypt_privatekey_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2593,7 +2617,7 @@ the corresponding public key, for example using <a href="#crypto_crypto_publicde
 <code>privateKey</code> had been passed to <a href="#crypto_crypto_createprivatekey_key"><code>crypto.createPrivateKey()</code></a>. If it is an
 object, the <code>padding</code> property can be passed. Otherwise, this function uses
 <code>RSA_PKCS1_PADDING</code>.</p>
-<h3><code>crypto.publicDecrypt(key, buffer)</code><span><a class="mark" href="#crypto_crypto_publicdecrypt_key_buffer" id="crypto_crypto_publicdecrypt_key_buffer">#</a></span></h3>
+<h4><code>crypto.publicDecrypt(key, buffer)</code><span><a class="mark" href="#crypto_crypto_publicdecrypt_key_buffer" id="crypto_crypto_publicdecrypt_key_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2625,7 +2649,7 @@ object, the <code>padding</code> property can be passed. Otherwise, this functio
 <code>RSA_PKCS1_PADDING</code>.</p>
 <p>Because RSA public keys can be derived from private keys, a private key may
 be passed instead of a public key.</p>
-<h3><code>crypto.publicEncrypt(key, buffer)</code><span><a class="mark" href="#crypto_crypto_publicencrypt_key_buffer" id="crypto_crypto_publicencrypt_key_buffer">#</a></span></h3>
+<h4><code>crypto.publicEncrypt(key, buffer)</code><span><a class="mark" href="#crypto_crypto_publicencrypt_key_buffer" id="crypto_crypto_publicencrypt_key_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2648,7 +2672,7 @@ be passed instead of a public key.</p>
 <li><code>oaepHash</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The hash function to use for OAEP padding and MGF1.
 <strong>Default:</strong> <code>'sha1'</code></li>
 <li><code>oaepLabel</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The label to use for OAEP
- padding. If not specified, no label is used.</li>
+padding. If not specified, no label is used.</li>
 <li><code>passphrase</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> An optional passphrase for the private key.</li>
 <li><code>padding</code> <a href="crypto.html#crypto_crypto_constants_1" class="type">&#x3C;crypto.constants></a> An optional padding value defined in
 <code>crypto.constants</code>, which may be: <code>crypto.constants.RSA_NO_PADDING</code>,
@@ -2668,7 +2692,7 @@ object, the <code>padding</code> property can be passed. Otherwise, this functio
 <code>RSA_PKCS1_OAEP_PADDING</code>.</p>
 <p>Because RSA public keys can be derived from private keys, a private key may
 be passed instead of a public key.</p>
-<h3><code>crypto.randomBytes(size[, callback])</code><span><a class="mark" href="#crypto_crypto_randombytes_size_callback" id="crypto_crypto_randombytes_size_callback">#</a></span></h3>
+<h4><code>crypto.randomBytes(size[, callback])</code><span><a class="mark" href="#crypto_crypto_randombytes_size_callback" id="crypto_crypto_randombytes_size_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2698,16 +2722,16 @@ If an error occurs, <code>err</code> will be an <code>Error</code> object; other
 <code>buf</code> argument is a <a href="buffer.html"><code>Buffer</code></a> containing the generated bytes.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Asynchronous</span>
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
-crypto.randomBytes(<span class="hljs-number">256</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+crypto.<span class="hljs-title function_">randomBytes</span>(<span class="hljs-number">256</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${buf.length}</span> bytes of random data: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'hex'</span>)}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${buf.length}</span> bytes of random data: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'hex'</span>)}</span>`</span>);
 });</code></pre>
 <p>If the <code>callback</code> function is not provided, the random bytes are generated
 synchronously and returned as a <a href="buffer.html"><code>Buffer</code></a>. An error will be thrown if
 there is a problem generating the bytes.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Synchronous</span>
-<span class="hljs-keyword">const</span> buf = crypto.randomBytes(<span class="hljs-number">256</span>);
-<span class="hljs-built_in">console</span>.log(
+<span class="hljs-keyword">const</span> buf = crypto.<span class="hljs-title function_">randomBytes</span>(<span class="hljs-number">256</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
   <span class="hljs-string">`<span class="hljs-subst">${buf.length}</span> bytes of random data: <span class="hljs-subst">${buf.toString(<span class="hljs-string">'hex'</span>)}</span>`</span>);</code></pre>
 <p>The <code>crypto.randomBytes()</code> method will not complete until there is
 sufficient entropy available.
@@ -2721,7 +2745,7 @@ negative performance implications for some applications; see the
 threadpool request. To minimize threadpool task length variation, partition
 large <code>randomBytes</code> requests when doing so as part of fulfilling a client
 request.</p>
-<h3><code>crypto.randomFillSync(buffer[, offset][, size])</code><span><a class="mark" href="#crypto_crypto_randomfillsync_buffer_offset_size" id="crypto_crypto_randomfillsync_buffer_offset_size">#</a></span></h3>
+<h4><code>crypto.randomFillSync(buffer[, offset][, size])</code><span><a class="mark" href="#crypto_crypto_randomfillsync_buffer_offset_size" id="crypto_crypto_randomfillsync_buffer_offset_size">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2740,28 +2764,28 @@ request.</p>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The object passed as <code>buffer</code> argument.</li>
 </ul>
 <p>Synchronous version of <a href="#crypto_crypto_randomfill_buffer_offset_size_callback"><code>crypto.randomFill()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(crypto.randomFillSync(buf).toString(<span class="hljs-string">'hex'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(crypto.<span class="hljs-title function_">randomFillSync</span>(buf).<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 
-crypto.randomFillSync(buf, <span class="hljs-number">5</span>);
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+crypto.<span class="hljs-title function_">randomFillSync</span>(buf, <span class="hljs-number">5</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 
 <span class="hljs-comment">// The above is equivalent to the following:</span>
-crypto.randomFillSync(buf, <span class="hljs-number">5</span>, <span class="hljs-number">5</span>);
-<span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));</code></pre>
+crypto.<span class="hljs-title function_">randomFillSync</span>(buf, <span class="hljs-number">5</span>, <span class="hljs-number">5</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));</code></pre>
 <p>Any <code>TypedArray</code> or <code>DataView</code> instance may be passed as <code>buffer</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(Buffer.from(crypto.randomFillSync(a).buffer,
-                        a.byteOffset, a.byteLength).toString(<span class="hljs-string">'hex'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>32<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(crypto.<span class="hljs-title function_">randomFillSync</span>(a).<span class="hljs-property">buffer</span>,
+                        a.<span class="hljs-property">byteOffset</span>, a.<span class="hljs-property">byteLength</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 
-<span class="hljs-keyword">const</span> b = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>(<span class="hljs-number">10</span>);
-<span class="hljs-built_in">console</span>.log(Buffer.from(crypto.randomFillSync(b).buffer,
-                        b.byteOffset, b.byteLength).toString(<span class="hljs-string">'hex'</span>));
+<span class="hljs-keyword">const</span> b = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(crypto.<span class="hljs-title function_">randomFillSync</span>(b).<span class="hljs-property">buffer</span>,
+                        b.<span class="hljs-property">byteOffset</span>, b.<span class="hljs-property">byteLength</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 
-<span class="hljs-keyword">const</span> c = <span class="hljs-keyword">new</span> <span class="hljs-built_in">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>));
-<span class="hljs-built_in">console</span>.log(Buffer.from(crypto.randomFillSync(c).buffer,
-                        c.byteOffset, c.byteLength).toString(<span class="hljs-string">'hex'</span>));</code></pre>
-<h3><code>crypto.randomFill(buffer[, offset][, size], callback)</code><span><a class="mark" href="#crypto_crypto_randomfill_buffer_offset_size_callback" id="crypto_crypto_randomfill_buffer_offset_size_callback">#</a></span></h3>
+<span class="hljs-keyword">const</span> c = <span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">10</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(crypto.<span class="hljs-title function_">randomFillSync</span>(c).<span class="hljs-property">buffer</span>,
+                        c.<span class="hljs-property">byteOffset</span>, c.<span class="hljs-property">byteLength</span>).<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));</code></pre>
+<h4><code>crypto.randomFill(buffer[, offset][, size], callback)</code><span><a class="mark" href="#crypto_crypto_randomfill_buffer_offset_size_callback" id="crypto_crypto_randomfill_buffer_offset_size_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2783,42 +2807,42 @@ crypto.randomFillSync(buf, <span class="hljs-number">5</span>, <span class="hljs
 argument to be a <a href="buffer.html"><code>Buffer</code></a> that will be filled. It also
 requires that a callback is passed in.</p>
 <p>If the <code>callback</code> function is not provided, an error will be thrown.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">10</span>);
-crypto.randomFill(buf, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">10</span>);
+crypto.<span class="hljs-title function_">randomFill</span>(buf, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });
 
-crypto.randomFill(buf, <span class="hljs-number">5</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+crypto.<span class="hljs-title function_">randomFill</span>(buf, <span class="hljs-number">5</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });
 
 <span class="hljs-comment">// The above is equivalent to the following:</span>
-crypto.randomFill(buf, <span class="hljs-number">5</span>, <span class="hljs-number">5</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+crypto.<span class="hljs-title function_">randomFill</span>(buf, <span class="hljs-number">5</span>, <span class="hljs-number">5</span>, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });</code></pre>
 <p>Any <code>TypedArray</code> or <code>DataView</code> instance may be passed as <code>buffer</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>(<span class="hljs-number">10</span>);
-crypto.randomFill(a, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>32<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+crypto.<span class="hljs-title function_">randomFill</span>(a, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
-    .toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(buf.<span class="hljs-property">buffer</span>, buf.<span class="hljs-property">byteOffset</span>, buf.<span class="hljs-property">byteLength</span>)
+    .<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });
 
-<span class="hljs-keyword">const</span> b = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>(<span class="hljs-number">10</span>);
-crypto.randomFill(b, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+<span class="hljs-keyword">const</span> b = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+crypto.<span class="hljs-title function_">randomFill</span>(b, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
-    .toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(buf.<span class="hljs-property">buffer</span>, buf.<span class="hljs-property">byteOffset</span>, buf.<span class="hljs-property">byteLength</span>)
+    .<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });
 
-<span class="hljs-keyword">const</span> c = <span class="hljs-keyword">new</span> <span class="hljs-built_in">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>));
-crypto.randomFill(c, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+<span class="hljs-keyword">const</span> c = <span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">10</span>));
+crypto.<span class="hljs-title function_">randomFill</span>(c, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
-    .toString(<span class="hljs-string">'hex'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(buf.<span class="hljs-property">buffer</span>, buf.<span class="hljs-property">byteOffset</span>, buf.<span class="hljs-property">byteLength</span>)
+    .<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));
 });</code></pre>
 <p>This API uses libuv's threadpool, which can have surprising and
 negative performance implications for some applications; see the
@@ -2827,9 +2851,9 @@ negative performance implications for some applications; see the
 threadpool request. To minimize threadpool task length variation, partition
 large <code>randomFill</code> requests when doing so as part of fulfilling a client
 request.</p>
-<h3><code>crypto.randomInt([min, ]max[, callback])</code><span><a class="mark" href="#crypto_crypto_randomint_min_max_callback" id="crypto_crypto_randomint_min_max_callback">#</a></span></h3>
+<h4><code>crypto.randomInt([min, ]max[, callback])</code><span><a class="mark" href="#crypto_crypto_randomint_min_max_callback" id="crypto_crypto_randomint_min_max_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.10.0</span>
 </div>
 <ul>
 <li><code>min</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Start of random range (inclusive). <strong>Default</strong>: <code>0</code>.</li>
@@ -2843,22 +2867,39 @@ be <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Gl
 <p>If the <code>callback</code> function is not provided, the random integer is
 generated synchronously.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Asynchronous</span>
-crypto.randomInt(<span class="hljs-number">3</span>, <span class="hljs-function">(<span class="hljs-params">err, n</span>) =></span> {
+crypto.<span class="hljs-title function_">randomInt</span>(<span class="hljs-number">3</span>, <span class="hljs-function">(<span class="hljs-params">err, n</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Random number chosen from (0, 1, 2): <span class="hljs-subst">${n}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Random number chosen from (0, 1, 2): <span class="hljs-subst">${n}</span>`</span>);
 });</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// Synchronous</span>
-<span class="hljs-keyword">const</span> n = crypto.randomInt(<span class="hljs-number">3</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Random number chosen from (0, 1, 2): <span class="hljs-subst">${n}</span>`</span>);</code></pre>
+<span class="hljs-keyword">const</span> n = crypto.<span class="hljs-title function_">randomInt</span>(<span class="hljs-number">3</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Random number chosen from (0, 1, 2): <span class="hljs-subst">${n}</span>`</span>);</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// With `min` argument</span>
-<span class="hljs-keyword">const</span> n = crypto.randomInt(<span class="hljs-number">1</span>, <span class="hljs-number">7</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The dice rolled: <span class="hljs-subst">${n}</span>`</span>);</code></pre>
-<h3><code>crypto.scrypt(password, salt, keylen[, options], callback)</code><span><a class="mark" href="#crypto_crypto_scrypt_password_salt_keylen_options_callback" id="crypto_crypto_scrypt_password_salt_keylen_options_callback">#</a></span></h3>
+<span class="hljs-keyword">const</span> n = crypto.<span class="hljs-title function_">randomInt</span>(<span class="hljs-number">1</span>, <span class="hljs-number">7</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The dice rolled: <span class="hljs-subst">${n}</span>`</span>);</code></pre>
+<h4><code>crypto.randomUUID([options])</code><span><a class="mark" href="#crypto_crypto_randomuuid_options" id="crypto_crypto_randomuuid_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>disableEntropyCache</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> By default, to improve performance,
+Node.js generates and caches enough random data to generate up to
+128 random UUIDs. To generate a UUID without using the cache, set
+<code>disableEntropyCache</code> to <code>true</code>. <strong>Defaults</strong>: <code>false</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Generates a random <a href="https://www.rfc-editor.org/rfc/rfc4122.txt">RFC 4122</a> version 4 UUID. The UUID is generated using a
+cryptographic pseudorandom number generator.</p>
+<h4><code>crypto.scrypt(password, salt, keylen[, options], callback)</code><span><a class="mark" href="#crypto_crypto_scrypt_password_salt_keylen_options_callback" id="crypto_crypto_scrypt_password_salt_keylen_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.8.0</td>
+<tr><td>v12.8.0, v10.17.0</td>
 <td><p>The <code>maxmem</code> value can now be any safe integer.</p></td></tr>
 <tr><td>v10.9.0</td>
 <td><p>The <code>cost</code>, <code>blockSize</code> and <code>parallelization</code> option names have been added.</p></td></tr>
@@ -2903,21 +2944,21 @@ random and at least 16 bytes long. See <a href="https://nvlpubs.nist.gov/nistpub
 or types.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-comment">// Using the factory defaults.</span>
-crypto.scrypt(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
+crypto.<span class="hljs-title function_">scrypt</span>(<span class="hljs-string">'password'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(derivedKey.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(derivedKey.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
 });
 <span class="hljs-comment">// Using a custom N parameter. Must be a power of two.</span>
-crypto.scrypt(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, { <span class="hljs-attr">N</span>: <span class="hljs-number">1024</span> }, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
+crypto.<span class="hljs-title function_">scrypt</span>(<span class="hljs-string">'password'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, { <span class="hljs-attr">N</span>: <span class="hljs-number">1024</span> }, <span class="hljs-function">(<span class="hljs-params">err, derivedKey</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(derivedKey.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...aa39b34'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(derivedKey.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...aa39b34'</span>
 });</code></pre>
-<h3><code>crypto.scryptSync(password, salt, keylen[, options])</code><span><a class="mark" href="#crypto_crypto_scryptsync_password_salt_keylen_options" id="crypto_crypto_scryptsync_password_salt_keylen_options">#</a></span></h3>
+<h4><code>crypto.scryptSync(password, salt, keylen[, options])</code><span><a class="mark" href="#crypto_crypto_scryptsync_password_salt_keylen_options" id="crypto_crypto_scryptsync_password_salt_keylen_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.8.0</td>
+<tr><td>v12.8.0, v10.17.0</td>
 <td><p>The <code>maxmem</code> value can now be any safe integer.</p></td></tr>
 <tr><td>v10.9.0</td>
 <td><p>The <code>cost</code>, <code>blockSize</code> and <code>parallelization</code> option names have been added.</p></td></tr>
@@ -2956,12 +2997,12 @@ returned as a <a href="buffer.html"><code>Buffer</code></a>.</p>
 or types.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 <span class="hljs-comment">// Using the factory defaults.</span>
-<span class="hljs-keyword">const</span> key1 = crypto.scryptSync(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>);
-<span class="hljs-built_in">console</span>.log(key1.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
+<span class="hljs-keyword">const</span> key1 = crypto.<span class="hljs-title function_">scryptSync</span>(<span class="hljs-string">'password'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key1.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...08d59ae'</span>
 <span class="hljs-comment">// Using a custom N parameter. Must be a power of two.</span>
-<span class="hljs-keyword">const</span> key2 = crypto.scryptSync(<span class="hljs-string">'secret'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, { <span class="hljs-attr">N</span>: <span class="hljs-number">1024</span> });
-<span class="hljs-built_in">console</span>.log(key2.toString(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...aa39b34'</span></code></pre>
-<h3><code>crypto.setEngine(engine[, flags])</code><span><a class="mark" href="#crypto_crypto_setengine_engine_flags" id="crypto_crypto_setengine_engine_flags">#</a></span></h3>
+<span class="hljs-keyword">const</span> key2 = crypto.<span class="hljs-title function_">scryptSync</span>(<span class="hljs-string">'password'</span>, <span class="hljs-string">'salt'</span>, <span class="hljs-number">64</span>, { <span class="hljs-attr">N</span>: <span class="hljs-number">1024</span> });
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(key2.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>));  <span class="hljs-comment">// '3745e48...aa39b34'</span></code></pre>
+<h4><code>crypto.setEngine(engine[, flags])</code><span><a class="mark" href="#crypto_crypto_setengine_engine_flags" id="crypto_crypto_setengine_engine_flags">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.11</span>
 </div>
@@ -2993,7 +3034,7 @@ is a bit field taking one of or a mix of the following flags (defined in
 <li><code>crypto.constants.ENGINE_METHOD_ECDSA</code></li>
 <li><code>crypto.constants.ENGINE_METHOD_STORE</code></li>
 </ul>
-<h3><code>crypto.setFips(bool)</code><span><a class="mark" href="#crypto_crypto_setfips_bool" id="crypto_crypto_setfips_bool">#</a></span></h3>
+<h4><code>crypto.setFips(bool)</code><span><a class="mark" href="#crypto_crypto_setfips_bool" id="crypto_crypto_setfips_bool">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -3002,9 +3043,17 @@ is a bit field taking one of or a mix of the following flags (defined in
 </ul>
 <p>Enables the FIPS compliant crypto provider in a FIPS-enabled Node.js build.
 Throws an error if FIPS mode is not available.</p>
-<h3><code>crypto.sign(algorithm, data, key)</code><span><a class="mark" href="#crypto_crypto_sign_algorithm_data_key" id="crypto_crypto_sign_algorithm_data_key">#</a></span></h3>
+<h4><code>crypto.sign(algorithm, data, key)</code><span><a class="mark" href="#crypto_crypto_sign_algorithm_data_key" id="crypto_crypto_sign_algorithm_data_key">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>This function now supports IEEE-P1363 DSA and ECDSA signatures.</p></td></tr>
+<tr><td>v12.0.0</td>
+<td><p><span>Added in: v12.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>algorithm</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
@@ -3044,7 +3093,7 @@ size, <code>crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN</code> (default) sets it t
 maximum permissible value.</p>
 </li>
 </ul>
-<h3><code>crypto.timingSafeEqual(a, b)</code><span><a class="mark" href="#crypto_crypto_timingsafeequal_a_b" id="crypto_crypto_timingsafeequal_a_b">#</a></span></h3>
+<h4><code>crypto.timingSafeEqual(a, b)</code><span><a class="mark" href="#crypto_crypto_timingsafeequal_a_b" id="crypto_crypto_timingsafeequal_a_b">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.6.0</span>
 </div>
@@ -3059,13 +3108,24 @@ would allow an attacker to guess one of the values. This is suitable for
 comparing HMAC digests or secret values like authentication cookies or
 <a href="https://www.w3.org/TR/capability-urls/">capability urls</a>.</p>
 <p><code>a</code> and <code>b</code> must both be <code>Buffer</code>s, <code>TypedArray</code>s, or <code>DataView</code>s, and they
-must have the same length.</p>
+must have the same byte length.</p>
+<p>If at least one of <code>a</code> and <code>b</code> is a <code>TypedArray</code> with more than one byte per
+entry, such as <code>Uint16Array</code>, the result will be computed using the platform
+byte order.</p>
 <p>Use of <code>crypto.timingSafeEqual</code> does not guarantee that the <em>surrounding</em> code
 is timing-safe. Care should be taken to ensure that the surrounding code does
 not introduce timing vulnerabilities.</p>
-<h3><code>crypto.verify(algorithm, data, key, signature)</code><span><a class="mark" href="#crypto_crypto_verify_algorithm_data_key_signature" id="crypto_crypto_verify_algorithm_data_key_signature">#</a></span></h3>
+<h4><code>crypto.verify(algorithm, data, key, signature)</code><span><a class="mark" href="#crypto_crypto_verify_algorithm_data_key_signature" id="crypto_crypto_verify_algorithm_data_key_signature">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>This function now supports IEEE-P1363 DSA and ECDSA signatures.</p></td></tr>
+<tr><td>v12.0.0</td>
+<td><p><span>Added in: v12.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>algorithm</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
@@ -3083,7 +3143,7 @@ additional properties can be passed:</p>
 <ul>
 <li>
 <p><code>dsaEncoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> For DSA and ECDSA, this option specifies the
-format of the generated signature. It can be one of the following:</p>
+format of the signature. It can be one of the following:</p>
 <ul>
 <li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>
 <li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>
@@ -3109,8 +3169,8 @@ maximum permissible value.</p>
 <p>The <code>signature</code> argument is the previously calculated signature for the <code>data</code>.</p>
 <p>Because public keys can be derived from private keys, a private key or a public
 key may be passed for <code>key</code>.</p>
-<h2>Notes<span><a class="mark" href="#crypto_notes" id="crypto_notes">#</a></span></h2>
-<h3>Legacy Streams API (prior to Node.js 0.10)<span><a class="mark" href="#crypto_legacy_streams_api_prior_to_node_js_0_10" id="crypto_legacy_streams_api_prior_to_node_js_0_10">#</a></span></h3>
+</section><section><h3>Notes<span><a class="mark" href="#crypto_notes" id="crypto_notes">#</a></span></h3>
+<h4>Legacy streams API (prior to Node.js 0.10)<span><a class="mark" href="#crypto_legacy_streams_api_prior_to_node_js_0_10" id="crypto_legacy_streams_api_prior_to_node_js_0_10">#</a></span></h4>
 <p>The Crypto module was added to Node.js before there was the concept of a
 unified Stream API, and before there were <a href="buffer.html"><code>Buffer</code></a> objects for handling
 binary data. As such, the many of the <code>crypto</code> defined classes have methods not
@@ -3119,7 +3179,7 @@ API (e.g. <code>update()</code>, <code>final()</code>, or <code>digest()</code>)
 and returned <code>'latin1'</code> encoded strings by default rather than <code>Buffer</code>s. This
 default was changed after Node.js v0.8 to use <a href="buffer.html"><code>Buffer</code></a> objects by default
 instead.</p>
-<h3>Recent ECDH changes<span><a class="mark" href="#crypto_recent_ecdh_changes" id="crypto_recent_ecdh_changes">#</a></span></h3>
+<h4>Recent ECDH changes<span><a class="mark" href="#crypto_recent_ecdh_changes" id="crypto_recent_ecdh_changes">#</a></span></h4>
 <p>Usage of <code>ECDH</code> with non-dynamically generated key pairs has been simplified.
 Now, <a href="#crypto_ecdh_setprivatekey_privatekey_encoding"><code>ecdh.setPrivateKey()</code></a> can be called with a preselected private key
 and the associated public point (key) will be computed and stored in the object.
@@ -3131,7 +3191,7 @@ API is not useful. Either a previously stored private key should be set, which
 automatically generates the associated public key, or <a href="#crypto_ecdh_generatekeys_encoding_format"><code>ecdh.generateKeys()</code></a>
 should be called. The main drawback of using <a href="#crypto_ecdh_setpublickey_publickey_encoding"><code>ecdh.setPublicKey()</code></a> is that
 it can be used to put the ECDH key pair into an inconsistent state.</p>
-<h3>Support for weak or compromised algorithms<span><a class="mark" href="#crypto_support_for_weak_or_compromised_algorithms" id="crypto_support_for_weak_or_compromised_algorithms">#</a></span></h3>
+<h4>Support for weak or compromised algorithms<span><a class="mark" href="#crypto_support_for_weak_or_compromised_algorithms" id="crypto_support_for_weak_or_compromised_algorithms">#</a></span></h4>
 <p>The <code>crypto</code> module still supports some algorithms which are already
 compromised and are not currently recommended for use. The API also allows
 the use of ciphers and hashes with a small key size that are too weak for safe
@@ -3149,7 +3209,7 @@ at least 2048 bits and that of the curve of ECDSA and ECDH at least
 smaller than 2048 bits and are not recommended.</li>
 </ul>
 <p>See the reference for other recommendations and details.</p>
-<h3>CCM mode<span><a class="mark" href="#crypto_ccm_mode" id="crypto_ccm_mode">#</a></span></h3>
+<h4>CCM mode<span><a class="mark" href="#crypto_ccm_mode" id="crypto_ccm_mode">#</a></span></h4>
 <p>CCM is one of the supported <a href="https://en.wikipedia.org/wiki/Authenticated_encryption">AEAD algorithms</a>. Applications which use this
 mode must adhere to certain restrictions when using the cipher API:</p>
 <ul>
@@ -3182,44 +3242,44 @@ authentication tag.</li>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
 <span class="hljs-keyword">const</span> key = <span class="hljs-string">'keykeykeykeykeykeykeykey'</span>;
-<span class="hljs-keyword">const</span> nonce = crypto.randomBytes(<span class="hljs-number">12</span>);
+<span class="hljs-keyword">const</span> nonce = crypto.<span class="hljs-title function_">randomBytes</span>(<span class="hljs-number">12</span>);
 
-<span class="hljs-keyword">const</span> aad = Buffer.from(<span class="hljs-string">'0123456789'</span>, <span class="hljs-string">'hex'</span>);
+<span class="hljs-keyword">const</span> aad = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'0123456789'</span>, <span class="hljs-string">'hex'</span>);
 
-<span class="hljs-keyword">const</span> cipher = crypto.createCipheriv(<span class="hljs-string">'aes-192-ccm'</span>, key, nonce, {
+<span class="hljs-keyword">const</span> cipher = crypto.<span class="hljs-title function_">createCipheriv</span>(<span class="hljs-string">'aes-192-ccm'</span>, key, nonce, {
   <span class="hljs-attr">authTagLength</span>: <span class="hljs-number">16</span>
 });
 <span class="hljs-keyword">const</span> plaintext = <span class="hljs-string">'Hello world'</span>;
-cipher.setAAD(aad, {
-  <span class="hljs-attr">plaintextLength</span>: Buffer.byteLength(plaintext)
+cipher.<span class="hljs-title function_">setAAD</span>(aad, {
+  <span class="hljs-attr">plaintextLength</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(plaintext)
 });
-<span class="hljs-keyword">const</span> ciphertext = cipher.update(plaintext, <span class="hljs-string">'utf8'</span>);
-cipher.final();
-<span class="hljs-keyword">const</span> tag = cipher.getAuthTag();
+<span class="hljs-keyword">const</span> ciphertext = cipher.<span class="hljs-title function_">update</span>(plaintext, <span class="hljs-string">'utf8'</span>);
+cipher.<span class="hljs-title function_">final</span>();
+<span class="hljs-keyword">const</span> tag = cipher.<span class="hljs-title function_">getAuthTag</span>();
 
 <span class="hljs-comment">// Now transmit { ciphertext, nonce, tag }.</span>
 
-<span class="hljs-keyword">const</span> decipher = crypto.createDecipheriv(<span class="hljs-string">'aes-192-ccm'</span>, key, nonce, {
+<span class="hljs-keyword">const</span> decipher = crypto.<span class="hljs-title function_">createDecipheriv</span>(<span class="hljs-string">'aes-192-ccm'</span>, key, nonce, {
   <span class="hljs-attr">authTagLength</span>: <span class="hljs-number">16</span>
 });
-decipher.setAuthTag(tag);
-decipher.setAAD(aad, {
-  <span class="hljs-attr">plaintextLength</span>: ciphertext.length
+decipher.<span class="hljs-title function_">setAuthTag</span>(tag);
+decipher.<span class="hljs-title function_">setAAD</span>(aad, {
+  <span class="hljs-attr">plaintextLength</span>: ciphertext.<span class="hljs-property">length</span>
 });
-<span class="hljs-keyword">const</span> receivedPlaintext = decipher.update(ciphertext, <span class="hljs-literal">null</span>, <span class="hljs-string">'utf8'</span>);
+<span class="hljs-keyword">const</span> receivedPlaintext = decipher.<span class="hljs-title function_">update</span>(ciphertext, <span class="hljs-literal">null</span>, <span class="hljs-string">'utf8'</span>);
 
 <span class="hljs-keyword">try</span> {
-  decipher.final();
+  decipher.<span class="hljs-title function_">final</span>();
 } <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Authentication failed!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Authentication failed!'</span>);
   <span class="hljs-keyword">return</span>;
 }
 
-<span class="hljs-built_in">console</span>.log(receivedPlaintext);</code></pre>
-<h2>Crypto constants<span><a class="mark" href="#crypto_crypto_constants_1" id="crypto_crypto_constants_1">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(receivedPlaintext);</code></pre>
+</section><section><h3>Crypto constants<span><a class="mark" href="#crypto_crypto_constants_1" id="crypto_crypto_constants_1">#</a></span></h3>
 <p>The following constants exported by <code>crypto.constants</code> apply to various uses of
 the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and are generally specific to OpenSSL.</p>
-<h3>OpenSSL options<span><a class="mark" href="#crypto_openssl_options" id="crypto_openssl_options">#</a></span></h3>
+<h4>OpenSSL options<span><a class="mark" href="#crypto_openssl_options" id="crypto_openssl_options">#</a></span></h4>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -3398,7 +3458,7 @@ the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and ar
     <td>Instructs OpenSSL to disable version rollback attack detection.</td>
   </tr>
 </tbody></table>
-<h3>OpenSSL engine constants<span><a class="mark" href="#crypto_openssl_engine_constants" id="crypto_openssl_engine_constants">#</a></span></h3>
+<h4>OpenSSL engine constants<span><a class="mark" href="#crypto_openssl_engine_constants" id="crypto_openssl_engine_constants">#</a></span></h4>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -3449,7 +3509,7 @@ the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and ar
     <td></td>
   </tr>
 </tbody></table>
-<h3>Other OpenSSL constants<span><a class="mark" href="#crypto_other_openssl_constants" id="crypto_other_openssl_constants">#</a></span></h3>
+<h4>Other OpenSSL constants<span><a class="mark" href="#crypto_other_openssl_constants" id="crypto_other_openssl_constants">#</a></span></h4>
 <p>See the <a href="https://wiki.openssl.org/index.php/List_of_SSL_OP_Flags#Table_of_Options">list of SSL OP Flags</a> for details.</p>
 <table>
   <tbody><tr>
@@ -3528,7 +3588,7 @@ the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and ar
     <td></td>
   </tr>
 </tbody></table>
-<h3>Node.js crypto constants<span><a class="mark" href="#crypto_node_js_crypto_constants" id="crypto_node_js_crypto_constants">#</a></span></h3>
+<h4>Node.js crypto constants<span><a class="mark" href="#crypto_node_js_crypto_constants" id="crypto_node_js_crypto_constants">#</a></span></h4>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -3543,10 +3603,46 @@ the <code>crypto</code>, <code>tls</code>, and <code>https</code> modules and ar
     <td>Specifies the active default cipher list used by the current Node.js
     process.</td>
   </tr>
-</tbody></table>
+</tbody></table></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/crypto.json b/doc/api/crypto.json
index a3a19ea6a9e01f965ee7394da7728f3aac434689..fbd4033ea39d40101b96912167e4bff3e87c065c 100644
--- a/doc/api/crypto.json
+++ b/doc/api/crypto.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.3.6",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/crypto.js\">lib/crypto.js</a></p>\n<p>The <code>crypto</code> module provides cryptographic functionality that includes a set of\nwrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.</p>\n<p>Use <code>require('crypto')</code> to access this module.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n\nconst secret = 'abcdefg';\nconst hash = crypto.createHmac('sha256', secret)\n                   .update('I love cupcakes')\n                   .digest('hex');\nconsole.log(hash);\n// Prints:\n//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/crypto.js\">lib/crypto.js</a></p>\n<p>The <code>crypto</code> module provides cryptographic functionality that includes a set of\nwrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions.</p>\n<p>Use <code>require('crypto')</code> to access this module.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n\nconst secret = 'abcdefg';\nconst hash = crypto.createHmac('sha256', secret)\n                   .update('I love cupcakes')\n                   .digest('hex');\nconsole.log(hash);\n// Prints:\n//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e\n</code></pre>",
       "modules": [
         {
           "textRaw": "Determining if crypto support is unavailable",
@@ -137,7 +137,10 @@
                     "description": "The `key` argument can now be a `KeyObject`."
                   },
                   {
-                    "version": "v11.2.0",
+                    "version": [
+                      "v11.2.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/24081",
                     "description": "The cipher `chacha20-poly1305` is now supported."
                   },
@@ -257,7 +260,10 @@
                     "description": "The `key` argument can now be a `KeyObject`."
                   },
                   {
-                    "version": "v11.2.0",
+                    "version": [
+                      "v11.2.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/24081",
                     "description": "The cipher `chacha20-poly1305` is now supported."
                   },
@@ -682,9 +688,9 @@
                   },
                   "params": [
                     {
-                      "textRaw": "`key` {Buffer}",
+                      "textRaw": "`key` {Buffer | TypedArray | DataView}",
                       "name": "key",
-                      "type": "Buffer"
+                      "type": "Buffer | TypedArray | DataView"
                     }
                   ]
                 }
@@ -765,7 +771,7 @@
               "name": "diffieHellman",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.9.0"
                 ],
                 "changes": []
               },
@@ -809,7 +815,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/31178",
                     "description": "Add support for Diffie-Hellman."
                   },
@@ -945,7 +951,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/31178",
                     "description": "Add support for Diffie-Hellman."
                   },
@@ -1189,6 +1195,11 @@
                   "v0.5.5"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/30578",
+                    "description": "The `iterations` parameter is now restricted to positive values. Earlier releases treated other values as one."
+                  },
                   {
                     "version": "v8.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/11305",
@@ -1265,6 +1276,11 @@
                   "v0.9.3"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/30578",
+                    "description": "The `iterations` parameter is now restricted to positive values. Earlier releases treated other values as one."
+                  },
                   {
                     "version": "v6.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/4047",
@@ -1739,7 +1755,7 @@
               "name": "randomInt",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.10.0"
                 ],
                 "changes": []
               },
@@ -1769,6 +1785,42 @@
               ],
               "desc": "<p>Return a random integer <code>n</code> such that <code>min &#x3C;= n &#x3C; max</code>.  This\nimplementation avoids <a href=\"https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias\">modulo bias</a>.</p>\n<p>The range (<code>max - min</code>) must be less than 2<sup>48</sup>. <code>min</code> and <code>max</code> must\nbe <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger\">safe integers</a>.</p>\n<p>If the <code>callback</code> function is not provided, the random integer is\ngenerated synchronously.</p>\n<pre><code class=\"language-js\">// Asynchronous\ncrypto.randomInt(3, (err, n) => {\n  if (err) throw err;\n  console.log(`Random number chosen from (0, 1, 2): ${n}`);\n});\n</code></pre>\n<pre><code class=\"language-js\">// Synchronous\nconst n = crypto.randomInt(3);\nconsole.log(`Random number chosen from (0, 1, 2): ${n}`);\n</code></pre>\n<pre><code class=\"language-js\">// With `min` argument\nconst n = crypto.randomInt(1, 7);\nconsole.log(`The dice rolled: ${n}`);\n</code></pre>"
             },
+            {
+              "textRaw": "`crypto.randomUUID([options])`",
+              "type": "method",
+              "name": "randomUUID",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {string}",
+                    "name": "return",
+                    "type": "string"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`disableEntropyCache` {boolean} By default, to improve performance, Node.js generates and caches enough random data to generate up to 128 random UUIDs. To generate a UUID without using the cache, set `disableEntropyCache` to `true`. **Defaults**: `false`.",
+                          "name": "disableEntropyCache",
+                          "type": "boolean",
+                          "desc": "By default, to improve performance, Node.js generates and caches enough random data to generate up to 128 random UUIDs. To generate a UUID without using the cache, set `disableEntropyCache` to `true`. **Defaults**: `false`."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Generates a random <a href=\"https://www.rfc-editor.org/rfc/rfc4122.txt\">RFC 4122</a> version 4 UUID. The UUID is generated using a\ncryptographic pseudorandom number generator.</p>"
+            },
             {
               "textRaw": "`crypto.scrypt(password, salt, keylen[, options], callback)`",
               "type": "method",
@@ -1779,7 +1831,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.8.0",
+                    "version": [
+                      "v12.8.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/28799",
                     "description": "The `maxmem` value can now be any safe integer."
                   },
@@ -1881,7 +1936,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Provides an asynchronous <a href=\"https://en.wikipedia.org/wiki/Scrypt\">scrypt</a> implementation. Scrypt is a password-based\nkey derivation function that is designed to be expensive computationally and\nmemory-wise in order to make brute-force attacks unrewarding.</p>\n<p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is\nrandom and at least 16 bytes long. See <a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf\">NIST SP 800-132</a> for details.</p>\n<p>The <code>callback</code> function is called with two arguments: <code>err</code> and <code>derivedKey</code>.\n<code>err</code> is an exception object when key derivation fails, otherwise <code>err</code> is\n<code>null</code>. <code>derivedKey</code> is passed to the callback as a <a href=\"buffer.html\"><code>Buffer</code></a>.</p>\n<p>An exception is thrown when any of the input arguments specify invalid values\nor types.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n// Using the factory defaults.\ncrypto.scrypt('secret', 'salt', 64, (err, derivedKey) => {\n  if (err) throw err;\n  console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'\n});\n// Using a custom N parameter. Must be a power of two.\ncrypto.scrypt('secret', 'salt', 64, { N: 1024 }, (err, derivedKey) => {\n  if (err) throw err;\n  console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'\n});\n</code></pre>"
+              "desc": "<p>Provides an asynchronous <a href=\"https://en.wikipedia.org/wiki/Scrypt\">scrypt</a> implementation. Scrypt is a password-based\nkey derivation function that is designed to be expensive computationally and\nmemory-wise in order to make brute-force attacks unrewarding.</p>\n<p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is\nrandom and at least 16 bytes long. See <a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf\">NIST SP 800-132</a> for details.</p>\n<p>The <code>callback</code> function is called with two arguments: <code>err</code> and <code>derivedKey</code>.\n<code>err</code> is an exception object when key derivation fails, otherwise <code>err</code> is\n<code>null</code>. <code>derivedKey</code> is passed to the callback as a <a href=\"buffer.html\"><code>Buffer</code></a>.</p>\n<p>An exception is thrown when any of the input arguments specify invalid values\nor types.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n// Using the factory defaults.\ncrypto.scrypt('password', 'salt', 64, (err, derivedKey) => {\n  if (err) throw err;\n  console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'\n});\n// Using a custom N parameter. Must be a power of two.\ncrypto.scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {\n  if (err) throw err;\n  console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'\n});\n</code></pre>"
             },
             {
               "textRaw": "`crypto.scryptSync(password, salt, keylen[, options])`",
@@ -1893,7 +1948,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.8.0",
+                    "version": [
+                      "v12.8.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/28799",
                     "description": "The `maxmem` value can now be any safe integer."
                   },
@@ -1983,7 +2041,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Provides a synchronous <a href=\"https://en.wikipedia.org/wiki/Scrypt\">scrypt</a> implementation. Scrypt is a password-based\nkey derivation function that is designed to be expensive computationally and\nmemory-wise in order to make brute-force attacks unrewarding.</p>\n<p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is\nrandom and at least 16 bytes long. See <a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf\">NIST SP 800-132</a> for details.</p>\n<p>An exception is thrown when key derivation fails, otherwise the derived key is\nreturned as a <a href=\"buffer.html\"><code>Buffer</code></a>.</p>\n<p>An exception is thrown when any of the input arguments specify invalid values\nor types.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n// Using the factory defaults.\nconst key1 = crypto.scryptSync('secret', 'salt', 64);\nconsole.log(key1.toString('hex'));  // '3745e48...08d59ae'\n// Using a custom N parameter. Must be a power of two.\nconst key2 = crypto.scryptSync('secret', 'salt', 64, { N: 1024 });\nconsole.log(key2.toString('hex'));  // '3745e48...aa39b34'\n</code></pre>"
+              "desc": "<p>Provides a synchronous <a href=\"https://en.wikipedia.org/wiki/Scrypt\">scrypt</a> implementation. Scrypt is a password-based\nkey derivation function that is designed to be expensive computationally and\nmemory-wise in order to make brute-force attacks unrewarding.</p>\n<p>The <code>salt</code> should be as unique as possible. It is recommended that a salt is\nrandom and at least 16 bytes long. See <a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf\">NIST SP 800-132</a> for details.</p>\n<p>An exception is thrown when key derivation fails, otherwise the derived key is\nreturned as a <a href=\"buffer.html\"><code>Buffer</code></a>.</p>\n<p>An exception is thrown when any of the input arguments specify invalid values\nor types.</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\n// Using the factory defaults.\nconst key1 = crypto.scryptSync('password', 'salt', 64);\nconsole.log(key1.toString('hex'));  // '3745e48...08d59ae'\n// Using a custom N parameter. Must be a power of two.\nconst key2 = crypto.scryptSync('password', 'salt', 64, { N: 1024 });\nconsole.log(key2.toString('hex'));  // '3745e48...aa39b34'\n</code></pre>"
             },
             {
               "textRaw": "`crypto.setEngine(engine[, flags])`",
@@ -2046,7 +2104,16 @@
                 "added": [
                   "v12.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29292",
+                    "description": "This function now supports IEEE-P1363 DSA and ECDSA signatures."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -2107,7 +2174,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This function is based on a constant-time algorithm.\nReturns true if <code>a</code> is equal to <code>b</code>, without leaking timing information that\nwould allow an attacker to guess one of the values. This is suitable for\ncomparing HMAC digests or secret values like authentication cookies or\n<a href=\"https://www.w3.org/TR/capability-urls/\">capability urls</a>.</p>\n<p><code>a</code> and <code>b</code> must both be <code>Buffer</code>s, <code>TypedArray</code>s, or <code>DataView</code>s, and they\nmust have the same length.</p>\n<p>Use of <code>crypto.timingSafeEqual</code> does not guarantee that the <em>surrounding</em> code\nis timing-safe. Care should be taken to ensure that the surrounding code does\nnot introduce timing vulnerabilities.</p>"
+              "desc": "<p>This function is based on a constant-time algorithm.\nReturns true if <code>a</code> is equal to <code>b</code>, without leaking timing information that\nwould allow an attacker to guess one of the values. This is suitable for\ncomparing HMAC digests or secret values like authentication cookies or\n<a href=\"https://www.w3.org/TR/capability-urls/\">capability urls</a>.</p>\n<p><code>a</code> and <code>b</code> must both be <code>Buffer</code>s, <code>TypedArray</code>s, or <code>DataView</code>s, and they\nmust have the same byte length.</p>\n<p>If at least one of <code>a</code> and <code>b</code> is a <code>TypedArray</code> with more than one byte per\nentry, such as <code>Uint16Array</code>, the result will be computed using the platform\nbyte order.</p>\n<p>Use of <code>crypto.timingSafeEqual</code> does not guarantee that the <em>surrounding</em> code\nis timing-safe. Care should be taken to ensure that the surrounding code does\nnot introduce timing vulnerabilities.</p>"
             },
             {
               "textRaw": "`crypto.verify(algorithm, data, key, signature)`",
@@ -2117,7 +2184,16 @@
                 "added": [
                   "v12.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29292",
+                    "description": "This function now supports IEEE-P1363 DSA and ECDSA signatures."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -2150,7 +2226,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Verifies the given signature for <code>data</code> using the given key and algorithm. If\n<code>algorithm</code> is <code>null</code> or <code>undefined</code>, then the algorithm is dependent upon the\nkey type (especially Ed25519 and Ed448).</p>\n<p>If <code>key</code> is not a <a href=\"#crypto_class_keyobject\"><code>KeyObject</code></a>, this function behaves as if <code>key</code> had been\npassed to <a href=\"#crypto_crypto_createpublickey_key\"><code>crypto.createPublicKey()</code></a>. If it is an object, the following\nadditional properties can be passed:</p>\n<ul>\n<li>\n<p><code>dsaEncoding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> For DSA and ECDSA, this option specifies the\nformat of the generated signature. It can be one of the following:</p>\n<ul>\n<li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>\n<li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>\n</ul>\n</li>\n<li>\n<p><code>padding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Optional padding value for RSA, one of the following:</p>\n<ul>\n<li><code>crypto.constants.RSA_PKCS1_PADDING</code> (default)</li>\n<li><code>crypto.constants.RSA_PKCS1_PSS_PADDING</code></li>\n</ul>\n<p><code>RSA_PKCS1_PSS_PADDING</code> will use MGF1 with the same hash function\nused to sign the message as specified in section 3.1 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>.</p>\n</li>\n<li>\n<p><code>saltLength</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Salt length for when padding is\n<code>RSA_PKCS1_PSS_PADDING</code>. The special value\n<code>crypto.constants.RSA_PSS_SALTLEN_DIGEST</code> sets the salt length to the digest\nsize, <code>crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN</code> (default) sets it to the\nmaximum permissible value.</p>\n</li>\n</ul>\n<p>The <code>signature</code> argument is the previously calculated signature for the <code>data</code>.</p>\n<p>Because public keys can be derived from private keys, a private key or a public\nkey may be passed for <code>key</code>.</p>"
+              "desc": "<p>Verifies the given signature for <code>data</code> using the given key and algorithm. If\n<code>algorithm</code> is <code>null</code> or <code>undefined</code>, then the algorithm is dependent upon the\nkey type (especially Ed25519 and Ed448).</p>\n<p>If <code>key</code> is not a <a href=\"#crypto_class_keyobject\"><code>KeyObject</code></a>, this function behaves as if <code>key</code> had been\npassed to <a href=\"#crypto_crypto_createpublickey_key\"><code>crypto.createPublicKey()</code></a>. If it is an object, the following\nadditional properties can be passed:</p>\n<ul>\n<li>\n<p><code>dsaEncoding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> For DSA and ECDSA, this option specifies the\nformat of the signature. It can be one of the following:</p>\n<ul>\n<li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>\n<li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>\n</ul>\n</li>\n<li>\n<p><code>padding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Optional padding value for RSA, one of the following:</p>\n<ul>\n<li><code>crypto.constants.RSA_PKCS1_PADDING</code> (default)</li>\n<li><code>crypto.constants.RSA_PKCS1_PSS_PADDING</code></li>\n</ul>\n<p><code>RSA_PKCS1_PSS_PADDING</code> will use MGF1 with the same hash function\nused to sign the message as specified in section 3.1 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>.</p>\n</li>\n<li>\n<p><code>saltLength</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Salt length for when padding is\n<code>RSA_PKCS1_PSS_PADDING</code>. The special value\n<code>crypto.constants.RSA_PSS_SALTLEN_DIGEST</code> sets the salt length to the digest\nsize, <code>crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN</code> (default) sets it to the\nmaximum permissible value.</p>\n</li>\n</ul>\n<p>The <code>signature</code> argument is the previously calculated signature for the <code>data</code>.</p>\n<p>Because public keys can be derived from private keys, a private key or a public\nkey may be passed for <code>key</code>.</p>"
             }
           ],
           "type": "module",
@@ -2161,11 +2237,11 @@
           "name": "notes",
           "modules": [
             {
-              "textRaw": "Legacy Streams API (prior to Node.js 0.10)",
+              "textRaw": "Legacy streams API (prior to Node.js 0.10)",
               "name": "legacy_streams_api_(prior_to_node.js_0.10)",
               "desc": "<p>The Crypto module was added to Node.js before there was the concept of a\nunified Stream API, and before there were <a href=\"buffer.html\"><code>Buffer</code></a> objects for handling\nbinary data. As such, the many of the <code>crypto</code> defined classes have methods not\ntypically found on other Node.js classes that implement the <a href=\"stream.html\">streams</a>\nAPI (e.g. <code>update()</code>, <code>final()</code>, or <code>digest()</code>). Also, many methods accepted\nand returned <code>'latin1'</code> encoded strings by default rather than <code>Buffer</code>s. This\ndefault was changed after Node.js v0.8 to use <a href=\"buffer.html\"><code>Buffer</code></a> objects by default\ninstead.</p>",
               "type": "module",
-              "displayName": "Legacy Streams API (prior to Node.js 0.10)"
+              "displayName": "Legacy streams API (prior to Node.js 0.10)"
             },
             {
               "textRaw": "Recent ECDH changes",
@@ -2341,7 +2417,9 @@
             {
               "textRaw": "Legacy API",
               "name": "legacy_api",
-              "desc": "<p>As a still supported legacy interface, it is possible to create new instances of\nthe <code>crypto.Certificate</code> class as illustrated in the examples below.</p>",
+              "stability": 0,
+              "stabilityText": "Deprecated",
+              "desc": "<p>As a legacy interface, it is possible to create new instances of\nthe <code>crypto.Certificate</code> class as illustrated in the examples below.</p>",
               "ctors": [
                 {
                   "textRaw": "`new crypto.Certificate()`",
@@ -2491,6 +2569,29 @@
               ],
               "desc": "<p>Once the <code>cipher.final()</code> method has been called, the <code>Cipher</code> object can no\nlonger be used to encrypt data. Attempts to call <code>cipher.final()</code> more than\nonce will result in an error being thrown.</p>"
             },
+            {
+              "textRaw": "`cipher.getAuthTag()`",
+              "type": "method",
+              "name": "getAuthTag",
+              "meta": {
+                "added": [
+                  "v1.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Buffer} When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing the _authentication tag_ that has been computed from the given data.",
+                    "name": "return",
+                    "type": "Buffer",
+                    "desc": "When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing the _authentication tag_ that has been computed from the given data."
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>The <code>cipher.getAuthTag()</code> method should only be called after encryption has\nbeen completed using the <a href=\"#crypto_cipher_final_outputencoding\"><code>cipher.final()</code></a> method.</p>"
+            },
             {
               "textRaw": "`cipher.setAAD(buffer[, options])`",
               "type": "method",
@@ -2533,29 +2634,6 @@
               ],
               "desc": "<p>When using an authenticated encryption mode (<code>GCM</code>, <code>CCM</code> and <code>OCB</code> are\ncurrently supported), the <code>cipher.setAAD()</code> method sets the value used for the\n<em>additional authenticated data</em> (AAD) input parameter.</p>\n<p>The <code>options</code> argument is optional for <code>GCM</code> and <code>OCB</code>. When using <code>CCM</code>, the\n<code>plaintextLength</code> option must be specified and its value must match the length\nof the plaintext in bytes. See <a href=\"#crypto_ccm_mode\">CCM mode</a>.</p>\n<p>The <code>cipher.setAAD()</code> method must be called before <a href=\"#crypto_cipher_update_data_inputencoding_outputencoding\"><code>cipher.update()</code></a>.</p>"
             },
-            {
-              "textRaw": "`cipher.getAuthTag()`",
-              "type": "method",
-              "name": "getAuthTag",
-              "meta": {
-                "added": [
-                  "v1.0.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {Buffer} When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing the _authentication tag_ that has been computed from the given data.",
-                    "name": "return",
-                    "type": "Buffer",
-                    "desc": "When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing the _authentication tag_ that has been computed from the given data."
-                  },
-                  "params": []
-                }
-              ],
-              "desc": "<p>The <code>cipher.getAuthTag()</code> method should only be called after encryption has\nbeen completed using the <a href=\"#crypto_cipher_final_outputencoding\"><code>cipher.final()</code></a> method.</p>"
-            },
             {
               "textRaw": "`cipher.setAutoPadding([autoPadding])`",
               "type": "method",
@@ -3122,7 +3200,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>DiffieHellmanGroup</code> class takes a well-known modp group as its argument but\notherwise works the same as <code>DiffieHellman</code>.</p>\n<pre><code class=\"language-js\">const name = 'modp1';\nconst dh = crypto.createDiffieHellmanGroup(name);\n</code></pre>\n<p><code>name</code> is taken from <a href=\"https://www.rfc-editor.org/rfc/rfc2412.txt\">RFC 2412</a> (modp1 and 2) and <a href=\"https://www.rfc-editor.org/rfc/rfc3526.txt\">RFC 3526</a>:</p>\n<pre><code class=\"language-console\">$ perl -ne 'print \"$1\\n\" if /\"(modp\\d+)\"/' src/node_crypto_groups.h\nmodp1  #  768 bits\nmodp2  # 1024 bits\nmodp5  # 1536 bits\nmodp14 # 2048 bits\nmodp15 # etc.\nmodp16\nmodp17\nmodp18\n</code></pre>"
+          "desc": "<p>The <code>DiffieHellmanGroup</code> class takes a well-known modp group as its argument.\nIt works the same as <code>DiffieHellman</code>, except that it does not allow changing\nits keys after creation. In other words, it does not implement <code>setPublicKey()</code>\nor <code>setPrivateKey()</code> methods.</p>\n<pre><code class=\"language-js\">const name = 'modp1';\nconst dh = crypto.createDiffieHellmanGroup(name);\n</code></pre>\n<p><code>name</code> is taken from <a href=\"https://www.rfc-editor.org/rfc/rfc2412.txt\">RFC 2412</a> (modp1 and 2) and <a href=\"https://www.rfc-editor.org/rfc/rfc3526.txt\">RFC 3526</a>:</p>\n<pre><code class=\"language-console\">$ perl -ne 'print \"$1\\n\" if /\"(modp\\d+)\"/' src/node_crypto_groups.h\nmodp1  #  768 bits\nmodp2  # 1024 bits\nmodp5  # 1536 bits\nmodp14 # 2048 bits\nmodp15 # etc.\nmodp16\nmodp17\nmodp18\n</code></pre>"
         },
         {
           "textRaw": "Class: `ECDH`",
@@ -3198,15 +3276,15 @@
                   "v0.11.14"
                 ],
                 "changes": [
-                  {
-                    "version": "v6.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/5522",
-                    "description": "The default `inputEncoding` changed from `binary` to `utf8`"
-                  },
                   {
                     "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/16849",
-                    "description": "Changed error format to better support invalid public key error"
+                    "description": "Changed error format to better support invalid public key error."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/5522",
+                    "description": "The default `inputEncoding` changed from `binary` to `utf8`."
                   }
                 ]
               },
@@ -3416,7 +3494,7 @@
             ],
             "changes": []
           },
-          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_transform\" class=\"type\">&lt;stream.Transform&gt;</a></li>\n</ul>\n<p>The <code>Hash</code> class is a utility for creating hash digests of data. It can be\nused in one of two ways:</p>\n<ul>\n<li>As a <a href=\"stream.html\">stream</a> that is both readable and writable, where data is written\nto produce a computed hash digest on the readable side, or</li>\n<li>Using the <a href=\"#crypto_hash_update_data_inputencoding\"><code>hash.update()</code></a> and <a href=\"#crypto_hash_digest_encoding\"><code>hash.digest()</code></a> methods to produce the\ncomputed hash.</li>\n</ul>\n<p>The <a href=\"#crypto_crypto_createhash_algorithm_options\"><code>crypto.createHash()</code></a> method is used to create <code>Hash</code> instances. <code>Hash</code>\nobjects are not to be created directly using the <code>new</code> keyword.</p>\n<p>Example: Using <code>Hash</code> objects as streams:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst hash = crypto.createHash('sha256');\n\nhash.on('readable', () => {\n  // Only one element is going to be produced by the\n  // hash stream.\n  const data = hash.read();\n  if (data) {\n    console.log(data.toString('hex'));\n    // Prints:\n    //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50\n  }\n});\n\nhash.write('some data to hash');\nhash.end();\n</code></pre>\n<p>Example: Using <code>Hash</code> and piped streams:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst fs = require('fs');\nconst hash = crypto.createHash('sha256');\n\nconst input = fs.createReadStream('test.js');\ninput.pipe(hash).pipe(process.stdout);\n</code></pre>\n<p>Example: Using the <a href=\"#crypto_hash_update_data_inputencoding\"><code>hash.update()</code></a> and <a href=\"#crypto_hash_digest_encoding\"><code>hash.digest()</code></a> methods:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst hash = crypto.createHash('sha256');\n\nhash.update('some data to hash');\nconsole.log(hash.digest('hex'));\n// Prints:\n//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50\n</code></pre>",
+          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_transform\" class=\"type\">&lt;stream.Transform&gt;</a></li>\n</ul>\n<p>The <code>Hash</code> class is a utility for creating hash digests of data. It can be\nused in one of two ways:</p>\n<ul>\n<li>As a <a href=\"stream.html\">stream</a> that is both readable and writable, where data is written\nto produce a computed hash digest on the readable side, or</li>\n<li>Using the <a href=\"#crypto_hash_update_data_inputencoding\"><code>hash.update()</code></a> and <a href=\"#crypto_hash_digest_encoding\"><code>hash.digest()</code></a> methods to produce the\ncomputed hash.</li>\n</ul>\n<p>The <a href=\"#crypto_crypto_createhash_algorithm_options\"><code>crypto.createHash()</code></a> method is used to create <code>Hash</code> instances. <code>Hash</code>\nobjects are not to be created directly using the <code>new</code> keyword.</p>\n<p>Example: Using <code>Hash</code> objects as streams:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst hash = crypto.createHash('sha256');\n\nhash.on('readable', () => {\n  // Only one element is going to be produced by the\n  // hash stream.\n  const data = hash.read();\n  if (data) {\n    console.log(data.toString('hex'));\n    // Prints:\n    //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50\n  }\n});\n\nhash.write('some data to hash');\nhash.end();\n</code></pre>\n<p>Example: Using <code>Hash</code> and piped streams:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst fs = require('fs');\nconst hash = crypto.createHash('sha256');\n\nconst input = fs.createReadStream('test.js');\ninput.pipe(hash).setEncoding('hex').pipe(process.stdout);\n</code></pre>\n<p>Example: Using the <a href=\"#crypto_hash_update_data_inputencoding\"><code>hash.update()</code></a> and <a href=\"#crypto_hash_digest_encoding\"><code>hash.digest()</code></a> methods:</p>\n<pre><code class=\"language-js\">const crypto = require('crypto');\nconst hash = crypto.createHash('sha256');\n\nhash.update('some data to hash');\nconsole.log(hash.digest('hex'));\n// Prints:\n//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50\n</code></pre>",
           "methods": [
             {
               "textRaw": "`hash.copy([options])`",
@@ -3424,7 +3502,7 @@
               "name": "copy",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.1.0"
                 ],
                 "changes": []
               },
@@ -3601,7 +3679,7 @@
             ],
             "changes": [
               {
-                "version": "v12.19.0",
+                "version": "v14.5.0",
                 "pr-url": "https://github.com/nodejs/node/pull/33360",
                 "description": "Instances of this class can now be passed to worker threads using `postMessage`."
               },
@@ -3624,14 +3702,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.9.0",
                     "pr-url": "https://github.com/nodejs/node/pull/31178",
                     "description": "Added support for `'dh'`."
                   },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26960",
-                    "description": "Added support for `'rsa-pss'`"
+                    "description": "Added support for `'rsa-pss'`."
                   },
                   {
                     "version": "v12.0.0",
@@ -3641,7 +3719,7 @@
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26774",
-                    "description": "Added support for `'x25519'` and `'x448'`"
+                    "description": "Added support for `'x25519'` and `'x448'`."
                   },
                   {
                     "version": "v12.0.0",
@@ -3704,7 +3782,7 @@
                   ]
                 }
               ],
-              "desc": "<p>For symmetric keys, this function allocates a <code>Buffer</code> containing the key\nmaterial and ignores any options.</p>\n<p>For asymmetric keys, the <code>options</code> parameter is used to determine the export\nformat.</p>\n<p>For public keys, the following encoding options can be used:</p>\n<ul>\n<li><code>type</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be one of <code>'pkcs1'</code> (RSA only) or <code>'spki'</code>.</li>\n<li><code>format</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be <code>'pem'</code> or <code>'der'</code>.</li>\n</ul>\n<p>For private keys, the following encoding options can be used:</p>\n<ul>\n<li><code>type</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be one of <code>'pkcs1'</code> (RSA only), <code>'pkcs8'</code> or\n<code>'sec1'</code> (EC only).</li>\n<li><code>format</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be <code>'pem'</code> or <code>'der'</code>.</li>\n<li><code>cipher</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If specified, the private key will be encrypted with\n the given <code>cipher</code> and <code>passphrase</code> using PKCS#5 v2.0 password based\nencryption.</li>\n<li><code>passphrase</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The passphrase to use for encryption, see\n<code>cipher</code>.</li>\n</ul>\n<p>When PEM encoding was selected, the result will be a string, otherwise it will\nbe a buffer containing the data encoded as DER.</p>\n<p>PKCS#1, SEC1, and PKCS#8 type keys can be encrypted by using a combination of\nthe <code>cipher</code> and <code>format</code> options. The PKCS#8 <code>type</code> can be used with any\n<code>format</code> to encrypt any key algorithm (RSA, EC, or DH) by specifying a\n<code>cipher</code>. PKCS#1 and SEC1 can only be encrypted by specifying a <code>cipher</code>\nwhen the PEM <code>format</code> is used. For maximum compatibility, use PKCS#8 for\nencrypted private keys. Since PKCS#8 defines its own\nencryption mechanism, PEM-level encryption is not supported when encrypting\na PKCS#8 key. See <a href=\"https://www.rfc-editor.org/rfc/rfc5208.txt\">RFC 5208</a> for PKCS#8 encryption and <a href=\"https://www.rfc-editor.org/rfc/rfc1421.txt\">RFC 1421</a> for\nPKCS#1 and SEC1 encryption.</p>"
+              "desc": "<p>For symmetric keys, this function allocates a <code>Buffer</code> containing the key\nmaterial and ignores any options.</p>\n<p>For asymmetric keys, the <code>options</code> parameter is used to determine the export\nformat.</p>\n<p>For public keys, the following encoding options can be used:</p>\n<ul>\n<li><code>type</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be one of <code>'pkcs1'</code> (RSA only) or <code>'spki'</code>.</li>\n<li><code>format</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be <code>'pem'</code> or <code>'der'</code>.</li>\n</ul>\n<p>For private keys, the following encoding options can be used:</p>\n<ul>\n<li><code>type</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be one of <code>'pkcs1'</code> (RSA only), <code>'pkcs8'</code> or\n<code>'sec1'</code> (EC only).</li>\n<li><code>format</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Must be <code>'pem'</code> or <code>'der'</code>.</li>\n<li><code>cipher</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If specified, the private key will be encrypted with\nthe given <code>cipher</code> and <code>passphrase</code> using PKCS#5 v2.0 password based\nencryption.</li>\n<li><code>passphrase</code>: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The passphrase to use for encryption, see\n<code>cipher</code>.</li>\n</ul>\n<p>When PEM encoding was selected, the result will be a string, otherwise it will\nbe a buffer containing the data encoded as DER.</p>\n<p>PKCS#1, SEC1, and PKCS#8 type keys can be encrypted by using a combination of\nthe <code>cipher</code> and <code>format</code> options. The PKCS#8 <code>type</code> can be used with any\n<code>format</code> to encrypt any key algorithm (RSA, EC, or DH) by specifying a\n<code>cipher</code>. PKCS#1 and SEC1 can only be encrypted by specifying a <code>cipher</code>\nwhen the PEM <code>format</code> is used. For maximum compatibility, use PKCS#8 for\nencrypted private keys. Since PKCS#8 defines its own\nencryption mechanism, PEM-level encryption is not supported when encrypting\na PKCS#8 key. See <a href=\"https://www.rfc-editor.org/rfc/rfc5208.txt\">RFC 5208</a> for PKCS#8 encryption and <a href=\"https://www.rfc-editor.org/rfc/rfc1421.txt\">RFC 1421</a> for\nPKCS#1 and SEC1 encryption.</p>"
             }
           ]
         },
@@ -3729,6 +3807,14 @@
                   "v0.1.92"
                 ],
                 "changes": [
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29292",
+                    "description": "This function now supports IEEE-P1363 DSA and ECDSA signatures."
+                  },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26960",
@@ -3880,6 +3966,14 @@
                   "v0.1.92"
                 ],
                 "changes": [
+                  {
+                    "version": [
+                      "v13.2.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29292",
+                    "description": "This function now supports IEEE-P1363 DSA and ECDSA signatures."
+                  },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26960",
@@ -3942,7 +4036,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Verifies the provided data using the given <code>object</code> and <code>signature</code>.</p>\n<p>If <code>object</code> is not a <a href=\"#crypto_class_keyobject\"><code>KeyObject</code></a>, this function behaves as if\n<code>object</code> had been passed to <a href=\"#crypto_crypto_createpublickey_key\"><code>crypto.createPublicKey()</code></a>. If it is an\nobject, the following additional properties can be passed:</p>\n<ul>\n<li>\n<p><code>dsaEncoding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> For DSA and ECDSA, this option specifies the\nformat of the generated signature. It can be one of the following:</p>\n<ul>\n<li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>\n<li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>\n</ul>\n</li>\n<li>\n<p><code>padding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Optional padding value for RSA, one of the following:</p>\n<ul>\n<li><code>crypto.constants.RSA_PKCS1_PADDING</code> (default)</li>\n<li><code>crypto.constants.RSA_PKCS1_PSS_PADDING</code></li>\n</ul>\n<p><code>RSA_PKCS1_PSS_PADDING</code> will use MGF1 with the same hash function\nused to verify the message as specified in section 3.1 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>, unless\nan MGF1 hash function has been specified as part of the key in compliance with\nsection 3.3 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>.</p>\n</li>\n<li>\n<p><code>saltLength</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Salt length for when padding is\n<code>RSA_PKCS1_PSS_PADDING</code>. The special value\n<code>crypto.constants.RSA_PSS_SALTLEN_DIGEST</code> sets the salt length to the digest\nsize, <code>crypto.constants.RSA_PSS_SALTLEN_AUTO</code> (default) causes it to be\ndetermined automatically.</p>\n</li>\n</ul>\n<p>The <code>signature</code> argument is the previously calculated signature for the data, in\nthe <code>signatureEncoding</code>.\nIf a <code>signatureEncoding</code> is specified, the <code>signature</code> is expected to be a\nstring; otherwise <code>signature</code> is expected to be a <a href=\"buffer.html\"><code>Buffer</code></a>,\n<code>TypedArray</code>, or <code>DataView</code>.</p>\n<p>The <code>verify</code> object can not be used again after <code>verify.verify()</code> has been\ncalled. Multiple calls to <code>verify.verify()</code> will result in an error being\nthrown.</p>\n<p>Because public keys can be derived from private keys, a private key may\nbe passed instead of a public key.</p>"
+              "desc": "<p>Verifies the provided data using the given <code>object</code> and <code>signature</code>.</p>\n<p>If <code>object</code> is not a <a href=\"#crypto_class_keyobject\"><code>KeyObject</code></a>, this function behaves as if\n<code>object</code> had been passed to <a href=\"#crypto_crypto_createpublickey_key\"><code>crypto.createPublicKey()</code></a>. If it is an\nobject, the following additional properties can be passed:</p>\n<ul>\n<li>\n<p><code>dsaEncoding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> For DSA and ECDSA, this option specifies the\nformat of the signature. It can be one of the following:</p>\n<ul>\n<li><code>'der'</code> (default): DER-encoded ASN.1 signature structure encoding <code>(r, s)</code>.</li>\n<li><code>'ieee-p1363'</code>: Signature format <code>r || s</code> as proposed in IEEE-P1363.</li>\n</ul>\n</li>\n<li>\n<p><code>padding</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Optional padding value for RSA, one of the following:</p>\n<ul>\n<li><code>crypto.constants.RSA_PKCS1_PADDING</code> (default)</li>\n<li><code>crypto.constants.RSA_PKCS1_PSS_PADDING</code></li>\n</ul>\n<p><code>RSA_PKCS1_PSS_PADDING</code> will use MGF1 with the same hash function\nused to verify the message as specified in section 3.1 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>, unless\nan MGF1 hash function has been specified as part of the key in compliance with\nsection 3.3 of <a href=\"https://www.rfc-editor.org/rfc/rfc4055.txt\">RFC 4055</a>.</p>\n</li>\n<li>\n<p><code>saltLength</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Salt length for when padding is\n<code>RSA_PKCS1_PSS_PADDING</code>. The special value\n<code>crypto.constants.RSA_PSS_SALTLEN_DIGEST</code> sets the salt length to the digest\nsize, <code>crypto.constants.RSA_PSS_SALTLEN_AUTO</code> (default) causes it to be\ndetermined automatically.</p>\n</li>\n</ul>\n<p>The <code>signature</code> argument is the previously calculated signature for the data, in\nthe <code>signatureEncoding</code>.\nIf a <code>signatureEncoding</code> is specified, the <code>signature</code> is expected to be a\nstring; otherwise <code>signature</code> is expected to be a <a href=\"buffer.html\"><code>Buffer</code></a>,\n<code>TypedArray</code>, or <code>DataView</code>.</p>\n<p>The <code>verify</code> object can not be used again after <code>verify.verify()</code> has been\ncalled. Multiple calls to <code>verify.verify()</code> will result in an error being\nthrown.</p>\n<p>Because public keys can be derived from private keys, a private key may\nbe passed instead of a public key.</p>"
             }
           ]
         }
diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index 745bed42b44c86b7e2576599df784e716933a187..36307e6f7a297bcb6e1dd6c3ab0b5eec41fcd306 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -106,7 +106,9 @@ console.log(Certificate.verifySpkac(Buffer.from(spkac)));
 
 ### Legacy API
 
-As a still supported legacy interface, it is possible to create new instances of
+> Stability: 0 - Deprecated
+
+As a legacy interface, it is possible to create new instances of
 the `crypto.Certificate` class as illustrated in the examples below.
 
 #### `new crypto.Certificate()`
@@ -280,6 +282,19 @@ Once the `cipher.final()` method has been called, the `Cipher` object can no
 longer be used to encrypt data. Attempts to call `cipher.final()` more than
 once will result in an error being thrown.
 
+### `cipher.getAuthTag()`
+<!-- YAML
+added: v1.0.0
+-->
+
+* Returns: {Buffer} When using an authenticated encryption mode (`GCM`, `CCM`
+  and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a
+  [`Buffer`][] containing the _authentication tag_ that has been computed from
+  the given data.
+
+The `cipher.getAuthTag()` method should only be called after encryption has
+been completed using the [`cipher.final()`][] method.
+
 ### `cipher.setAAD(buffer[, options])`
 <!-- YAML
 added: v1.0.0
@@ -300,19 +315,6 @@ of the plaintext in bytes. See [CCM mode][].
 
 The `cipher.setAAD()` method must be called before [`cipher.update()`][].
 
-### `cipher.getAuthTag()`
-<!-- YAML
-added: v1.0.0
--->
-
-* Returns: {Buffer} When using an authenticated encryption mode (`GCM`, `CCM`
-  and `OCB` are currently supported), the `cipher.getAuthTag()` method returns a
-  [`Buffer`][] containing the _authentication tag_ that has been computed from
-  the given data.
-
-The `cipher.getAuthTag()` method should only be called after encryption has
-been completed using the [`cipher.final()`][] method.
-
 ### `cipher.setAutoPadding([autoPadding])`
 <!-- YAML
 added: v0.7.1
@@ -733,8 +735,10 @@ module):
 added: v0.7.5
 -->
 
-The `DiffieHellmanGroup` class takes a well-known modp group as its argument but
-otherwise works the same as `DiffieHellman`.
+The `DiffieHellmanGroup` class takes a well-known modp group as its argument.
+It works the same as `DiffieHellman`, except that it does not allow changing
+its keys after creation. In other words, it does not implement `setPublicKey()`
+or `setPrivateKey()` methods.
 
 ```js
 const name = 'modp1';
@@ -838,13 +842,13 @@ console.log(uncompressedKey === ecdh.getPublicKey('hex'));
 <!-- YAML
 added: v0.11.14
 changes:
-  - version: v6.0.0
-    pr-url: https://github.com/nodejs/node/pull/5522
-    description: The default `inputEncoding` changed from `binary` to `utf8`
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/16849
     description: Changed error format to better support invalid public key
-                 error
+                 error.
+  - version: v6.0.0
+    pr-url: https://github.com/nodejs/node/pull/5522
+    description: The default `inputEncoding` changed from `binary` to `utf8`.
 -->
 
 * `otherPublicKey` {string | Buffer | TypedArray | DataView}
@@ -1028,7 +1032,7 @@ const fs = require('fs');
 const hash = crypto.createHash('sha256');
 
 const input = fs.createReadStream('test.js');
-input.pipe(hash).pipe(process.stdout);
+input.pipe(hash).setEncoding('hex').pipe(process.stdout);
 ```
 
 Example: Using the [`hash.update()`][] and [`hash.digest()`][] methods:
@@ -1045,7 +1049,7 @@ console.log(hash.digest('hex'));
 
 ### `hash.copy([options])`
 <!-- YAML
-added: v12.16.0
+added: v13.1.0
 -->
 
 * `options` {Object} [`stream.transform` options][]
@@ -1215,7 +1219,7 @@ This can be called many times with new data as it is streamed.
 <!-- YAML
 added: v11.6.0
 changes:
-  - version: v12.19.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33360
     description: Instances of this class can now be passed to worker threads
                  using `postMessage`.
@@ -1242,19 +1246,19 @@ be listed in the `transferList` argument.
 <!-- YAML
 added: v11.6.0
 changes:
-  - version: v12.17.0
+  - version: v13.9.0
     pr-url: https://github.com/nodejs/node/pull/31178
     description: Added support for `'dh'`.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26960
-    description: Added support for `'rsa-pss'`
+    description: Added support for `'rsa-pss'`.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26786
     description: This property now returns `undefined` for KeyObject
                  instances of unrecognized type instead of aborting.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26774
-    description: Added support for `'x25519'` and `'x448'`
+    description: Added support for `'x25519'` and `'x448'`.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26319
     description: Added support for `'ed25519'` and `'ed448'`.
@@ -1407,6 +1411,11 @@ console.log(verify.verify(publicKey, signature));
 <!-- YAML
 added: v0.1.92
 changes:
+  - version:
+     - v13.2.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/29292
+    description: This function now supports IEEE-P1363 DSA and ECDSA signatures.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26960
     description: This function now supports RSA-PSS keys.
@@ -1520,6 +1529,11 @@ This can be called many times with new data as it is streamed.
 <!-- YAML
 added: v0.1.92
 changes:
+  - version:
+     - v13.2.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/29292
+    description: This function now supports IEEE-P1363 DSA and ECDSA signatures.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26960
     description: This function now supports RSA-PSS keys.
@@ -1547,7 +1561,7 @@ If `object` is not a [`KeyObject`][], this function behaves as if
 object, the following additional properties can be passed:
 
 * `dsaEncoding` {string} For DSA and ECDSA, this option specifies the
-  format of the generated signature. It can be one of the following:
+  format of the signature. It can be one of the following:
   * `'der'` (default): DER-encoded ASN.1 signature structure encoding `(r, s)`.
   * `'ieee-p1363'`: Signature format `r || s` as proposed in IEEE-P1363.
 * `padding` {integer} Optional padding value for RSA, one of the following:
@@ -1684,7 +1698,9 @@ changes:
   - version: v11.6.0
     pr-url: https://github.com/nodejs/node/pull/24234
     description: The `key` argument can now be a `KeyObject`.
-  - version: v11.2.0
+  - version:
+     - v11.2.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/24081
     description: The cipher `chacha20-poly1305` is now supported.
   - version: v10.10.0
@@ -1778,7 +1794,9 @@ changes:
   - version: v11.6.0
     pr-url: https://github.com/nodejs/node/pull/24234
     description: The `key` argument can now be a `KeyObject`.
-  - version: v11.2.0
+  - version:
+     - v11.2.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/24081
     description: The cipher `chacha20-poly1305` is now supported.
   - version: v10.10.0
@@ -2054,7 +2072,7 @@ and it will be impossible to extract the private key from the returned object.
 added: v11.6.0
 -->
 
-* `key` {Buffer}
+* `key` {Buffer | TypedArray | DataView}
 * Returns: {KeyObject}
 
 Creates and returns a new key object containing a secret key for symmetric
@@ -2101,7 +2119,7 @@ algorithm names.
 
 ### `crypto.diffieHellman(options)`
 <!-- YAML
-added: v12.17.0
+added: v13.9.0
 -->
 
 * `options`: {Object}
@@ -2117,7 +2135,7 @@ Both keys must have the same `asymmetricKeyType`, which must be one of `'dh'`
 <!-- YAML
 added: v10.12.0
 changes:
-  - version: v12.17.0
+  - version: v13.9.0
     pr-url: https://github.com/nodejs/node/pull/31178
     description: Add support for Diffie-Hellman.
   - version: v12.0.0
@@ -2190,7 +2208,7 @@ a `Promise` for an `Object` with `publicKey` and `privateKey` properties.
 <!-- YAML
 added: v10.12.0
 changes:
-  - version: v12.17.0
+  - version: v13.9.0
     pr-url: https://github.com/nodejs/node/pull/31178
     description: Add support for Diffie-Hellman.
   - version: v12.0.0
@@ -2339,6 +2357,10 @@ console.log(hashes); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
 <!-- YAML
 added: v0.5.5
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/30578
+    description: The `iterations` parameter is now restricted to positive
+                 values. Earlier releases treated other values as one.
   - version: v8.0.0
     pr-url: https://github.com/nodejs/node/pull/11305
     description: The `digest` parameter is always required now.
@@ -2414,6 +2436,10 @@ negative performance implications for some applications; see the
 <!-- YAML
 added: v0.9.3
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/30578
+    description: The `iterations` parameter is now restricted to positive
+                 values. Earlier releases treated other values as one.
   - version: v6.0.0
     pr-url: https://github.com/nodejs/node/pull/4047
     description: Calling this function without passing the `digest` parameter
@@ -2781,7 +2807,7 @@ request.
 
 ### `crypto.randomInt([min, ]max[, callback])`
 <!-- YAML
-added: v12.19.0
+added: v14.10.0
 -->
 
 * `min` {integer} Start of random range (inclusive). **Default**: `0`.
@@ -2817,11 +2843,28 @@ const n = crypto.randomInt(1, 7);
 console.log(`The dice rolled: ${n}`);
 ```
 
+### `crypto.randomUUID([options])`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `options` {Object}
+  * `disableEntropyCache` {boolean} By default, to improve performance,
+    Node.js generates and caches enough random data to generate up to
+    128 random UUIDs. To generate a UUID without using the cache, set
+    `disableEntropyCache` to `true`. **Defaults**: `false`.
+* Returns: {string}
+
+Generates a random [RFC 4122][] version 4 UUID. The UUID is generated using a
+cryptographic pseudorandom number generator.
+
 ### `crypto.scrypt(password, salt, keylen[, options], callback)`
 <!-- YAML
 added: v10.5.0
 changes:
-  - version: v12.8.0
+  - version:
+     - v12.8.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/28799
     description: The `maxmem` value can now be any safe integer.
   - version: v10.9.0
@@ -2864,12 +2907,12 @@ or types.
 ```js
 const crypto = require('crypto');
 // Using the factory defaults.
-crypto.scrypt('secret', 'salt', 64, (err, derivedKey) => {
+crypto.scrypt('password', 'salt', 64, (err, derivedKey) => {
   if (err) throw err;
   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
 });
 // Using a custom N parameter. Must be a power of two.
-crypto.scrypt('secret', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
+crypto.scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
   if (err) throw err;
   console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'
 });
@@ -2879,7 +2922,9 @@ crypto.scrypt('secret', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
 <!-- YAML
 added: v10.5.0
 changes:
-  - version: v12.8.0
+  - version:
+     - v12.8.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/28799
     description: The `maxmem` value can now be any safe integer.
   - version: v10.9.0
@@ -2919,10 +2964,10 @@ or types.
 ```js
 const crypto = require('crypto');
 // Using the factory defaults.
-const key1 = crypto.scryptSync('secret', 'salt', 64);
+const key1 = crypto.scryptSync('password', 'salt', 64);
 console.log(key1.toString('hex'));  // '3745e48...08d59ae'
 // Using a custom N parameter. Must be a power of two.
-const key2 = crypto.scryptSync('secret', 'salt', 64, { N: 1024 });
+const key2 = crypto.scryptSync('password', 'salt', 64, { N: 1024 });
 console.log(key2.toString('hex'));  // '3745e48...aa39b34'
 ```
 
@@ -2973,6 +3018,12 @@ Throws an error if FIPS mode is not available.
 ### `crypto.sign(algorithm, data, key)`
 <!-- YAML
 added: v12.0.0
+changes:
+  - version:
+     - v13.2.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/29292
+    description: This function now supports IEEE-P1363 DSA and ECDSA signatures.
 -->
 
 * `algorithm` {string | null | undefined}
@@ -3020,7 +3071,11 @@ comparing HMAC digests or secret values like authentication cookies or
 [capability urls](https://www.w3.org/TR/capability-urls/).
 
 `a` and `b` must both be `Buffer`s, `TypedArray`s, or `DataView`s, and they
-must have the same length.
+must have the same byte length.
+
+If at least one of `a` and `b` is a `TypedArray` with more than one byte per
+entry, such as `Uint16Array`, the result will be computed using the platform
+byte order.
 
 Use of `crypto.timingSafeEqual` does not guarantee that the *surrounding* code
 is timing-safe. Care should be taken to ensure that the surrounding code does
@@ -3029,6 +3084,12 @@ not introduce timing vulnerabilities.
 ### `crypto.verify(algorithm, data, key, signature)`
 <!-- YAML
 added: v12.0.0
+changes:
+  - version:
+     - v13.2.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/29292
+    description: This function now supports IEEE-P1363 DSA and ECDSA signatures.
 -->
 
 * `algorithm` {string | null | undefined}
@@ -3046,7 +3107,7 @@ passed to [`crypto.createPublicKey()`][]. If it is an object, the following
 additional properties can be passed:
 
 * `dsaEncoding` {string} For DSA and ECDSA, this option specifies the
-  format of the generated signature. It can be one of the following:
+  format of the signature. It can be one of the following:
   * `'der'` (default): DER-encoded ASN.1 signature structure encoding `(r, s)`.
   * `'ieee-p1363'`: Signature format `r || s` as proposed in IEEE-P1363.
 * `padding` {integer} Optional padding value for RSA, one of the following:
@@ -3068,7 +3129,7 @@ key may be passed for `key`.
 
 ## Notes
 
-### Legacy Streams API (prior to Node.js 0.10)
+### Legacy streams API (prior to Node.js 0.10)
 
 The Crypto module was added to Node.js before there was the concept of a
 unified Stream API, and before there were [`Buffer`][] objects for handling
@@ -3526,11 +3587,29 @@ See the [list of SSL OP Flags][] for details.
   </tr>
 </table>
 
-[`Buffer`]: buffer.html
+[AEAD algorithms]: https://en.wikipedia.org/wiki/Authenticated_encryption
+[CCM mode]: #crypto_ccm_mode
+[Caveats]: #crypto_support_for_weak_or_compromised_algorithms
+[Crypto constants]: #crypto_crypto_constants_1
+[HTML 5.2]: https://www.w3.org/TR/html52/changes.html#features-removed
+[HTML5's `keygen` element]: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/keygen
+[NIST SP 800-131A]: https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf
+[NIST SP 800-132]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf
+[NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
+[Nonce-Disrespecting Adversaries]: https://github.com/nonce-disrespect/nonce-disrespect
+[OpenSSL's SPKAC implementation]: https://www.openssl.org/docs/man1.1.0/apps/openssl-spkac.html
+[RFC 1421]: https://www.rfc-editor.org/rfc/rfc1421.txt
+[RFC 2412]: https://www.rfc-editor.org/rfc/rfc2412.txt
+[RFC 3526]: https://www.rfc-editor.org/rfc/rfc3526.txt
+[RFC 3610]: https://www.rfc-editor.org/rfc/rfc3610.txt
+[RFC 4055]: https://www.rfc-editor.org/rfc/rfc4055.txt
+[RFC 4122]: https://www.rfc-editor.org/rfc/rfc4122.txt
+[RFC 5208]: https://www.rfc-editor.org/rfc/rfc5208.txt
+[`Buffer`]: buffer.md
 [`EVP_BytesToKey`]: https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html
 [`KeyObject`]: #crypto_class_keyobject
 [`Sign`]: #crypto_class_sign
-[`UV_THREADPOOL_SIZE`]: cli.html#cli_uv_threadpool_size_size
+[`UV_THREADPOOL_SIZE`]: cli.md#cli_uv_threadpool_size_size
 [`Verify`]: #crypto_class_verify
 [`cipher.final()`]: #crypto_cipher_final_outputencoding
 [`cipher.update()`]: #crypto_cipher_update_data_inputencoding_outputencoding
@@ -3568,36 +3647,19 @@ See the [list of SSL OP Flags][] for details.
 [`hmac.digest()`]: #crypto_hmac_digest_encoding
 [`hmac.update()`]: #crypto_hmac_update_data_inputencoding
 [`keyObject.export()`]: #crypto_keyobject_export_options
-[`postMessage()`]: worker_threads.html#worker_threads_port_postmessage_value_transferlist
+[`postMessage()`]: worker_threads.md#worker_threads_port_postmessage_value_transferlist
 [`sign.sign()`]: #crypto_sign_sign_privatekey_outputencoding
 [`sign.update()`]: #crypto_sign_update_data_inputencoding
-[`stream.Writable` options]: stream.html#stream_new_stream_writable_options
-[`stream.transform` options]: stream.html#stream_new_stream_transform_options
-[`util.promisify()`]: util.html#util_util_promisify_original
+[`stream.Writable` options]: stream.md#stream_new_stream_writable_options
+[`stream.transform` options]: stream.md#stream_new_stream_transform_options
+[`util.promisify()`]: util.md#util_util_promisify_original
 [`verify.update()`]: #crypto_verify_update_data_inputencoding
 [`verify.verify()`]: #crypto_verify_verify_object_signature_signatureencoding
-[AEAD algorithms]: https://en.wikipedia.org/wiki/Authenticated_encryption
-[CCM mode]: #crypto_ccm_mode
-[Caveats]: #crypto_support_for_weak_or_compromised_algorithms
-[Crypto constants]: #crypto_crypto_constants_1
-[HTML 5.2]: https://www.w3.org/TR/html52/changes.html#features-removed
-[HTML5's `keygen` element]: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/keygen
-[NIST SP 800-131A]: https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf
-[NIST SP 800-132]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf
-[NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
-[modulo bias]: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias
-[Nonce-Disrespecting Adversaries]: https://github.com/nonce-disrespect/nonce-disrespect
-[OpenSSL's SPKAC implementation]: https://www.openssl.org/docs/man1.1.0/apps/openssl-spkac.html
-[RFC 1421]: https://www.rfc-editor.org/rfc/rfc1421.txt
-[RFC 2412]: https://www.rfc-editor.org/rfc/rfc2412.txt
-[RFC 3526]: https://www.rfc-editor.org/rfc/rfc3526.txt
-[RFC 3610]: https://www.rfc-editor.org/rfc/rfc3610.txt
-[RFC 4055]: https://www.rfc-editor.org/rfc/rfc4055.txt
-[RFC 5208]: https://www.rfc-editor.org/rfc/rfc5208.txt
-[encoding]: buffer.html#buffer_buffers_and_character_encodings
+[encoding]: buffer.md#buffer_buffers_and_character_encodings
 [initialization vector]: https://en.wikipedia.org/wiki/Initialization_vector
 [list of SSL OP Flags]: https://wiki.openssl.org/index.php/List_of_SSL_OP_Flags#Table_of_Options
+[modulo bias]: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias
 [safe integers]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
 [scrypt]: https://en.wikipedia.org/wiki/Scrypt
-[stream]: stream.html
-[stream-writable-write]: stream.html#stream_writable_write_chunk_encoding_callback
+[stream]: stream.md
+[stream-writable-write]: stream.md#stream_writable_write_chunk_encoding_callback
diff --git a/doc/api/debugger.html b/doc/api/debugger.html
index 02fe34ddc4c7a467cc9d8e0576eb21e9ba6b8f4e..ef5462253cf804a2658dfaa0322a86c9a88651c6 100644
--- a/doc/api/debugger.html
+++ b/doc/api/debugger.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Debugger | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Debugger | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger active">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="debugger" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/debugger.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/debugger.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/debugger.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/debugger.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/debugger.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/debugger.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/debugger.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/debugger.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/debugger.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#debugger_debugger">Debugger</a></span>
 <ul>
 <li><a href="#debugger_watchers">Watchers</a></li>
@@ -146,26 +159,27 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Debugger<span><a class="mark" href="#debugger_debugger" id="debugger_debugger">#</a></span></h1>
+        <h2>Debugger<span><a class="mark" href="#debugger_debugger" id="debugger_debugger">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p>Node.js includes an out-of-process debugging utility accessible via a
-<a href="#debugger_v8_inspector_integration_for_node_js">V8 Inspector</a> and built-in debugging client. To use it, start Node.js
-with the <code>inspect</code> argument followed by the path to the script to debug; a
-prompt will be displayed indicating successful launch of the debugger:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node inspect myscript.js</span>
-&#x3C; Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba
+<p>Node.js includes a command-line debugging utility. To use it, start Node.js
+with the <code>inspect</code> argument followed by the path to the script to debug.</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node inspect myscript.js</span>
+&#x3C; Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8
 &#x3C; For help, see: https://nodejs.org/en/docs/inspector
+&#x3C;
 &#x3C; Debugger attached.
-Break on start in myscript.js:1
-<span class="hljs-meta">></span><span class="bash"> 1 (<span class="hljs-keyword">function</span> (exports, require, module, __filename, __dirname) { global.x = 5;</span>
-  2 setTimeout(() => {
-  3   console.log('world');
+&#x3C;
+ ok
+Break on start in myscript.js:2
+  1 // myscript.js
+<span class="hljs-meta">> </span><span class="language-bash">2 global.x = 5;</span>
+  3 setTimeout(() => {
+  4   debugger;
 <span class="hljs-meta">debug></span></code></pre>
 <p>The Node.js debugger client is not a full-featured debugger, but simple step and
 inspection are possible.</p>
@@ -173,56 +187,63 @@ inspection are possible.</p>
 enable a breakpoint at that position in the code:</p>
 <!-- eslint-disable no-debugger -->
 <pre><code class="language-js"><span class="hljs-comment">// myscript.js</span>
-<span class="hljs-built_in">global</span>.x = <span class="hljs-number">5</span>;
+<span class="hljs-variable language_">global</span>.<span class="hljs-property">x</span> = <span class="hljs-number">5</span>;
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-keyword">debugger</span>;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'world'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'world'</span>);
 }, <span class="hljs-number">1000</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'hello'</span>);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello'</span>);</code></pre>
 <p>Once the debugger is run, a breakpoint will occur at line 3:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node inspect myscript.js</span>
-&#x3C; Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node inspect myscript.js</span>
+&#x3C; Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8
 &#x3C; For help, see: https://nodejs.org/en/docs/inspector
+&#x3C;
 &#x3C; Debugger attached.
-Break on start in myscript.js:1
-<span class="hljs-meta">></span><span class="bash"> 1 (<span class="hljs-keyword">function</span> (exports, require, module, __filename, __dirname) { global.x = 5;</span>
-  2 setTimeout(() => {
-  3   debugger;
-<span class="hljs-meta">debug></span><span class="bash"> cont</span>
+&#x3C;
+ ok
+Break on start in myscript.js:2
+  1 // myscript.js
+<span class="hljs-meta">> </span><span class="language-bash">2 global.x = 5;</span>
+  3 setTimeout(() => {
+  4   debugger;
+<span class="hljs-meta">debug> </span><span class="language-bash">cont</span>
 &#x3C; hello
-break in myscript.js:3
-  1 (function (exports, require, module, __filename, __dirname) { global.x = 5;
-  2 setTimeout(() => {
-<span class="hljs-meta">></span><span class="bash"> 3   debugger;</span>
-  4   console.log('world');
-  5 }, 1000);
-<span class="hljs-meta">debug></span><span class="bash"> next</span>
+&#x3C;
 break in myscript.js:4
-  2 setTimeout(() => {
-  3   debugger;
-<span class="hljs-meta">></span><span class="bash"> 4   console.log(<span class="hljs-string">'world'</span>);</span>
-  5 }, 1000);
-  6 console.log('hello');
-<span class="hljs-meta">debug></span><span class="bash"> repl</span>
-Press Ctrl + C to leave debug repl
-<span class="hljs-meta">></span><span class="bash"> x</span>
+  2 global.x = 5;
+  3 setTimeout(() => {
+<span class="hljs-meta">> </span><span class="language-bash">4   debugger;</span>
+  5   console.log('world');
+  6 }, 1000);
+<span class="hljs-meta">debug> </span><span class="language-bash">next</span>
+break in myscript.js:5
+  3 setTimeout(() => {
+  4   debugger;
+<span class="hljs-meta">> </span><span class="language-bash">5   console.log(<span class="hljs-string">'world'</span>);</span>
+  6 }, 1000);
+  7 console.log('hello');
+<span class="hljs-meta">debug> </span><span class="language-bash">repl</span>
+Press Ctrl+C to leave debug repl
+<span class="hljs-meta">> </span><span class="language-bash">x</span>
 5
-<span class="hljs-meta">></span><span class="bash"> 2 + 2</span>
+<span class="hljs-meta">> </span><span class="language-bash">2 + 2</span>
 4
-<span class="hljs-meta">debug></span><span class="bash"> next</span>
+<span class="hljs-meta">debug> </span><span class="language-bash">next</span>
 &#x3C; world
-break in myscript.js:5
-  3   debugger;
-  4   console.log('world');
-<span class="hljs-meta">></span><span class="bash"> 5 }, 1000);</span>
-  6 console.log('hello');
-  7
-<span class="hljs-meta">debug></span><span class="bash"> .<span class="hljs-built_in">exit</span></span></code></pre>
+&#x3C;
+break in myscript.js:6
+  4   debugger;
+  5   console.log('world');
+<span class="hljs-meta">> </span><span class="language-bash">6 }, 1000);</span>
+  7 console.log('hello');
+  8
+<span class="hljs-meta">debug> </span><span class="language-bash">.<span class="hljs-built_in">exit</span></span>
+<span class="hljs-meta">$</span></code></pre>
 <p>The <code>repl</code> command allows code to be evaluated remotely. The <code>next</code> command
 steps to the next line. Type <code>help</code> to see what other commands are available.</p>
 <p>Pressing <code>enter</code> without typing a command will repeat the previous debugger
 command.</p>
-<h2>Watchers<span><a class="mark" href="#debugger_watchers" id="debugger_watchers">#</a></span></h2>
+<section><h3>Watchers<span><a class="mark" href="#debugger_watchers" id="debugger_watchers">#</a></span></h3>
 <p>It is possible to watch expression and variable values while debugging. On
 every breakpoint, each expression from the watchers list will be evaluated
 in the current context and displayed immediately before the breakpoint's
@@ -230,8 +251,8 @@ source code listing.</p>
 <p>To begin watching an expression, type <code>watch('my_expression')</code>. The command
 <code>watchers</code> will print the active watchers. To remove a watcher, type
 <code>unwatch('my_expression')</code>.</p>
-<h2>Command reference<span><a class="mark" href="#debugger_command_reference" id="debugger_command_reference">#</a></span></h2>
-<h3>Stepping<span><a class="mark" href="#debugger_stepping" id="debugger_stepping">#</a></span></h3>
+</section><section><h3>Command reference<span><a class="mark" href="#debugger_command_reference" id="debugger_command_reference">#</a></span></h3>
+<h4>Stepping<span><a class="mark" href="#debugger_stepping" id="debugger_stepping">#</a></span></h4>
 <ul>
 <li><code>cont</code>, <code>c</code>: Continue execution</li>
 <li><code>next</code>, <code>n</code>: Step next</li>
@@ -239,38 +260,76 @@ source code listing.</p>
 <li><code>out</code>, <code>o</code>: Step out</li>
 <li><code>pause</code>: Pause running code (like pause button in Developer Tools)</li>
 </ul>
-<h3>Breakpoints<span><a class="mark" href="#debugger_breakpoints" id="debugger_breakpoints">#</a></span></h3>
+<h4>Breakpoints<span><a class="mark" href="#debugger_breakpoints" id="debugger_breakpoints">#</a></span></h4>
 <ul>
 <li><code>setBreakpoint()</code>, <code>sb()</code>: Set breakpoint on current line</li>
 <li><code>setBreakpoint(line)</code>, <code>sb(line)</code>: Set breakpoint on specific line</li>
 <li><code>setBreakpoint('fn()')</code>, <code>sb(...)</code>: Set breakpoint on a first statement in
-functions body</li>
+function's body</li>
 <li><code>setBreakpoint('script.js', 1)</code>, <code>sb(...)</code>: Set breakpoint on first line of
 <code>script.js</code></li>
+<li><code>setBreakpoint('script.js', 1, 'num &#x3C; 4')</code>, <code>sb(...)</code>: Set conditional
+breakpoint on first line of <code>script.js</code> that only breaks when <code>num &#x3C; 4</code>
+evaluates to <code>true</code></li>
 <li><code>clearBreakpoint('script.js', 1)</code>, <code>cb(...)</code>: Clear breakpoint in <code>script.js</code>
 on line 1</li>
 </ul>
 <p>It is also possible to set a breakpoint in a file (module) that
 is not loaded yet:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node inspect main.js</span>
-&#x3C; Debugger listening on ws://127.0.0.1:9229/4e3db158-9791-4274-8909-914f7facf3bd
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node inspect main.js</span>
+&#x3C; Debugger listening on ws://127.0.0.1:9229/48a5b28a-550c-471b-b5e1-d13dd7165df9
 &#x3C; For help, see: https://nodejs.org/en/docs/inspector
+&#x3C;
 &#x3C; Debugger attached.
+&#x3C;
+ ok
 Break on start in main.js:1
-<span class="hljs-meta">></span><span class="bash"> 1 (<span class="hljs-keyword">function</span> (exports, require, module, __filename, __dirname) { const mod = require(<span class="hljs-string">'./mod.js'</span>);</span>
+<span class="hljs-meta">> </span><span class="language-bash">1 const mod = require(<span class="hljs-string">'./mod.js'</span>);</span>
   2 mod.hello();
   3 mod.hello();
-<span class="hljs-meta">debug></span><span class="bash"> setBreakpoint(<span class="hljs-string">'mod.js'</span>, 22)</span>
+<span class="hljs-meta">debug> </span><span class="language-bash">setBreakpoint(<span class="hljs-string">'mod.js'</span>, 22)</span>
 Warning: script 'mod.js' was not loaded yet.
-<span class="hljs-meta">debug></span><span class="bash"> c</span>
+<span class="hljs-meta">debug> </span><span class="language-bash">c</span>
 break in mod.js:22
  20 // USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
-<span class="hljs-meta">></span><span class="bash">22 exports.hello = <span class="hljs-function"><span class="hljs-title">function</span></span>() {</span>
+<span class="hljs-meta">></span><span class="language-bash">22 exports.hello = <span class="hljs-function"><span class="hljs-title">function</span></span>() {</span>
  23   return 'hello from module';
  24 };
 <span class="hljs-meta">debug></span></code></pre>
-<h3>Information<span><a class="mark" href="#debugger_information" id="debugger_information">#</a></span></h3>
+<p>It is also possible to set a conditional breakpoint that only breaks when a
+given expression evaluates to <code>true</code>:</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node inspect main.js</span>
+&#x3C; Debugger listening on ws://127.0.0.1:9229/ce24daa8-3816-44d4-b8ab-8273c8a66d35
+&#x3C; For help, see: https://nodejs.org/en/docs/inspector
+&#x3C; Debugger attached.
+Break on start in main.js:7
+  5 }
+  6
+<span class="hljs-meta">> </span><span class="language-bash">7 addOne(10);</span>
+  8 addOne(-1);
+  9
+<span class="hljs-meta">debug> </span><span class="language-bash">setBreakpoint(<span class="hljs-string">'main.js'</span>, 4, <span class="hljs-string">'num &#x3C; 0'</span>)</span>
+  1 'use strict';
+  2
+  3 function addOne(num) {
+<span class="hljs-meta">> </span><span class="language-bash">4   <span class="hljs-built_in">return</span> num + 1;</span>
+  5 }
+  6
+  7 addOne(10);
+  8 addOne(-1);
+  9
+<span class="hljs-meta">debug> </span><span class="language-bash">cont</span>
+break in main.js:4
+  2
+  3 function addOne(num) {
+<span class="hljs-meta">> </span><span class="language-bash">4   <span class="hljs-built_in">return</span> num + 1;</span>
+  5 }
+  6
+<span class="hljs-meta">debug> </span><span class="language-bash"><span class="hljs-built_in">exec</span>(<span class="hljs-string">'num'</span>)</span>
+-1
+<span class="hljs-meta">debug></span></code></pre>
+<h4>Information<span><a class="mark" href="#debugger_information" id="debugger_information">#</a></span></h4>
 <ul>
 <li><code>backtrace</code>, <code>bt</code>: Print backtrace of current execution frame</li>
 <li><code>list(5)</code>: List scripts source code with 5 line context (5 lines before and
@@ -282,19 +341,19 @@ breakpoint)</li>
 <li><code>repl</code>: Open debugger's repl for evaluation in debugging script's context</li>
 <li><code>exec expr</code>: Execute an expression in debugging script's context</li>
 </ul>
-<h3>Execution control<span><a class="mark" href="#debugger_execution_control" id="debugger_execution_control">#</a></span></h3>
+<h4>Execution control<span><a class="mark" href="#debugger_execution_control" id="debugger_execution_control">#</a></span></h4>
 <ul>
 <li><code>run</code>: Run script (automatically runs on debugger's start)</li>
 <li><code>restart</code>: Restart script</li>
 <li><code>kill</code>: Kill script</li>
 </ul>
-<h3>Various<span><a class="mark" href="#debugger_various" id="debugger_various">#</a></span></h3>
+<h4>Various<span><a class="mark" href="#debugger_various" id="debugger_various">#</a></span></h4>
 <ul>
 <li><code>scripts</code>: List all loaded scripts</li>
 <li><code>version</code>: Display V8's version</li>
 </ul>
-<h2>Advanced usage<span><a class="mark" href="#debugger_advanced_usage" id="debugger_advanced_usage">#</a></span></h2>
-<h3>V8 inspector integration for Node.js<span><a class="mark" href="#debugger_v8_inspector_integration_for_node_js" id="debugger_v8_inspector_integration_for_node_js">#</a></span></h3>
+</section><section><h3>Advanced usage<span><a class="mark" href="#debugger_advanced_usage" id="debugger_advanced_usage">#</a></span></h3>
+<h4>V8 inspector integration for Node.js<span><a class="mark" href="#debugger_v8_inspector_integration_for_node_js" id="debugger_v8_inspector_integration_for_node_js">#</a></span></h4>
 <p>V8 Inspector integration allows attaching Chrome DevTools to Node.js
 instances for debugging and profiling. It uses the
 <a href="https://chromedevtools.github.io/devtools-protocol/">Chrome DevTools Protocol</a>.</p>
@@ -303,7 +362,7 @@ Node.js application. It is also possible to supply a custom port with that flag,
 e.g. <code>--inspect=9222</code> will accept DevTools connections on port 9222.</p>
 <p>To break on the first line of the application code, pass the <code>--inspect-brk</code>
 flag instead of <code>--inspect</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --inspect index.js</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --inspect index.js</span>
 Debugger listening on ws://127.0.0.1:9229/dc9010dd-f8b8-4ac5-a510-c1a114ec7d29
 For help, see: https://nodejs.org/en/docs/inspector</code></pre>
 <p>(In the example above, the UUID dc9010dd-f8b8-4ac5-a510-c1a114ec7d29
@@ -312,10 +371,46 @@ debugging sessions.)</p>
 <p>If the Chrome browser is older than 66.0.3345.0,
 use <code>inspector.html</code> instead of <code>js_app.html</code> in the above URL.</p>
 <p>Chrome DevTools doesn't support debugging <a href="worker_threads.html">worker threads</a> yet.
-<a href="https://github.com/GoogleChromeLabs/ndb/">ndb</a> can be used to debug them.</p>
+<a href="https://github.com/GoogleChromeLabs/ndb/">ndb</a> can be used to debug them.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/debugger.json b/doc/api/debugger.json
index 68310a31d5269aac6c08c737d60b0a5cdfefd163..0baad7e1c93aef7e5f74ee6db7ddb5395e8df017 100644
--- a/doc/api/debugger.json
+++ b/doc/api/debugger.json
@@ -12,7 +12,7 @@
       "stability": 2,
       "stabilityText": "Stable",
       "type": "misc",
-      "desc": "<p>Node.js includes an out-of-process debugging utility accessible via a\n<a href=\"#debugger_v8_inspector_integration_for_node_js\">V8 Inspector</a> and built-in debugging client. To use it, start Node.js\nwith the <code>inspect</code> argument followed by the path to the script to debug; a\nprompt will be displayed indicating successful launch of the debugger:</p>\n<pre><code class=\"language-console\">$ node inspect myscript.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C; Debugger attached.\nBreak on start in myscript.js:1\n> 1 (function (exports, require, module, __filename, __dirname) { global.x = 5;\n  2 setTimeout(() => {\n  3   console.log('world');\ndebug>\n</code></pre>\n<p>The Node.js debugger client is not a full-featured debugger, but simple step and\ninspection are possible.</p>\n<p>Inserting the statement <code>debugger;</code> into the source code of a script will\nenable a breakpoint at that position in the code:</p>\n<!-- eslint-disable no-debugger -->\n<pre><code class=\"language-js\">// myscript.js\nglobal.x = 5;\nsetTimeout(() => {\n  debugger;\n  console.log('world');\n}, 1000);\nconsole.log('hello');\n</code></pre>\n<p>Once the debugger is run, a breakpoint will occur at line 3:</p>\n<pre><code class=\"language-console\">$ node inspect myscript.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C; Debugger attached.\nBreak on start in myscript.js:1\n> 1 (function (exports, require, module, __filename, __dirname) { global.x = 5;\n  2 setTimeout(() => {\n  3   debugger;\ndebug> cont\n&#x3C; hello\nbreak in myscript.js:3\n  1 (function (exports, require, module, __filename, __dirname) { global.x = 5;\n  2 setTimeout(() => {\n> 3   debugger;\n  4   console.log('world');\n  5 }, 1000);\ndebug> next\nbreak in myscript.js:4\n  2 setTimeout(() => {\n  3   debugger;\n> 4   console.log('world');\n  5 }, 1000);\n  6 console.log('hello');\ndebug> repl\nPress Ctrl + C to leave debug repl\n> x\n5\n> 2 + 2\n4\ndebug> next\n&#x3C; world\nbreak in myscript.js:5\n  3   debugger;\n  4   console.log('world');\n> 5 }, 1000);\n  6 console.log('hello');\n  7\ndebug> .exit\n</code></pre>\n<p>The <code>repl</code> command allows code to be evaluated remotely. The <code>next</code> command\nsteps to the next line. Type <code>help</code> to see what other commands are available.</p>\n<p>Pressing <code>enter</code> without typing a command will repeat the previous debugger\ncommand.</p>",
+      "desc": "<p>Node.js includes a command-line debugging utility. To use it, start Node.js\nwith the <code>inspect</code> argument followed by the path to the script to debug.</p>\n<pre><code class=\"language-console\">$ node inspect myscript.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C;\n&#x3C; Debugger attached.\n&#x3C;\n ok\nBreak on start in myscript.js:2\n  1 // myscript.js\n> 2 global.x = 5;\n  3 setTimeout(() => {\n  4   debugger;\ndebug>\n</code></pre>\n<p>The Node.js debugger client is not a full-featured debugger, but simple step and\ninspection are possible.</p>\n<p>Inserting the statement <code>debugger;</code> into the source code of a script will\nenable a breakpoint at that position in the code:</p>\n<!-- eslint-disable no-debugger -->\n<pre><code class=\"language-js\">// myscript.js\nglobal.x = 5;\nsetTimeout(() => {\n  debugger;\n  console.log('world');\n}, 1000);\nconsole.log('hello');\n</code></pre>\n<p>Once the debugger is run, a breakpoint will occur at line 3:</p>\n<pre><code class=\"language-console\">$ node inspect myscript.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C;\n&#x3C; Debugger attached.\n&#x3C;\n ok\nBreak on start in myscript.js:2\n  1 // myscript.js\n> 2 global.x = 5;\n  3 setTimeout(() => {\n  4   debugger;\ndebug> cont\n&#x3C; hello\n&#x3C;\nbreak in myscript.js:4\n  2 global.x = 5;\n  3 setTimeout(() => {\n> 4   debugger;\n  5   console.log('world');\n  6 }, 1000);\ndebug> next\nbreak in myscript.js:5\n  3 setTimeout(() => {\n  4   debugger;\n> 5   console.log('world');\n  6 }, 1000);\n  7 console.log('hello');\ndebug> repl\nPress Ctrl+C to leave debug repl\n> x\n5\n> 2 + 2\n4\ndebug> next\n&#x3C; world\n&#x3C;\nbreak in myscript.js:6\n  4   debugger;\n  5   console.log('world');\n> 6 }, 1000);\n  7 console.log('hello');\n  8\ndebug> .exit\n$\n</code></pre>\n<p>The <code>repl</code> command allows code to be evaluated remotely. The <code>next</code> command\nsteps to the next line. Type <code>help</code> to see what other commands are available.</p>\n<p>Pressing <code>enter</code> without typing a command will repeat the previous debugger\ncommand.</p>",
       "miscs": [
         {
           "textRaw": "Watchers",
@@ -35,7 +35,7 @@
             {
               "textRaw": "Breakpoints",
               "name": "breakpoints",
-              "desc": "<ul>\n<li><code>setBreakpoint()</code>, <code>sb()</code>: Set breakpoint on current line</li>\n<li><code>setBreakpoint(line)</code>, <code>sb(line)</code>: Set breakpoint on specific line</li>\n<li><code>setBreakpoint('fn()')</code>, <code>sb(...)</code>: Set breakpoint on a first statement in\nfunctions body</li>\n<li><code>setBreakpoint('script.js', 1)</code>, <code>sb(...)</code>: Set breakpoint on first line of\n<code>script.js</code></li>\n<li><code>clearBreakpoint('script.js', 1)</code>, <code>cb(...)</code>: Clear breakpoint in <code>script.js</code>\non line 1</li>\n</ul>\n<p>It is also possible to set a breakpoint in a file (module) that\nis not loaded yet:</p>\n<pre><code class=\"language-console\">$ node inspect main.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/4e3db158-9791-4274-8909-914f7facf3bd\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C; Debugger attached.\nBreak on start in main.js:1\n> 1 (function (exports, require, module, __filename, __dirname) { const mod = require('./mod.js');\n  2 mod.hello();\n  3 mod.hello();\ndebug> setBreakpoint('mod.js', 22)\nWarning: script 'mod.js' was not loaded yet.\ndebug> c\nbreak in mod.js:22\n 20 // USE OR OTHER DEALINGS IN THE SOFTWARE.\n 21\n>22 exports.hello = function() {\n 23   return 'hello from module';\n 24 };\ndebug>\n</code></pre>",
+              "desc": "<ul>\n<li><code>setBreakpoint()</code>, <code>sb()</code>: Set breakpoint on current line</li>\n<li><code>setBreakpoint(line)</code>, <code>sb(line)</code>: Set breakpoint on specific line</li>\n<li><code>setBreakpoint('fn()')</code>, <code>sb(...)</code>: Set breakpoint on a first statement in\nfunction's body</li>\n<li><code>setBreakpoint('script.js', 1)</code>, <code>sb(...)</code>: Set breakpoint on first line of\n<code>script.js</code></li>\n<li><code>setBreakpoint('script.js', 1, 'num &#x3C; 4')</code>, <code>sb(...)</code>: Set conditional\nbreakpoint on first line of <code>script.js</code> that only breaks when <code>num &#x3C; 4</code>\nevaluates to <code>true</code></li>\n<li><code>clearBreakpoint('script.js', 1)</code>, <code>cb(...)</code>: Clear breakpoint in <code>script.js</code>\non line 1</li>\n</ul>\n<p>It is also possible to set a breakpoint in a file (module) that\nis not loaded yet:</p>\n<pre><code class=\"language-console\">$ node inspect main.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/48a5b28a-550c-471b-b5e1-d13dd7165df9\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C;\n&#x3C; Debugger attached.\n&#x3C;\n ok\nBreak on start in main.js:1\n> 1 const mod = require('./mod.js');\n  2 mod.hello();\n  3 mod.hello();\ndebug> setBreakpoint('mod.js', 22)\nWarning: script 'mod.js' was not loaded yet.\ndebug> c\nbreak in mod.js:22\n 20 // USE OR OTHER DEALINGS IN THE SOFTWARE.\n 21\n>22 exports.hello = function() {\n 23   return 'hello from module';\n 24 };\ndebug>\n</code></pre>\n<p>It is also possible to set a conditional breakpoint that only breaks when a\ngiven expression evaluates to <code>true</code>:</p>\n<pre><code class=\"language-console\">$ node inspect main.js\n&#x3C; Debugger listening on ws://127.0.0.1:9229/ce24daa8-3816-44d4-b8ab-8273c8a66d35\n&#x3C; For help, see: https://nodejs.org/en/docs/inspector\n&#x3C; Debugger attached.\nBreak on start in main.js:7\n  5 }\n  6\n> 7 addOne(10);\n  8 addOne(-1);\n  9\ndebug> setBreakpoint('main.js', 4, 'num &#x3C; 0')\n  1 'use strict';\n  2\n  3 function addOne(num) {\n> 4   return num + 1;\n  5 }\n  6\n  7 addOne(10);\n  8 addOne(-1);\n  9\ndebug> cont\nbreak in main.js:4\n  2\n  3 function addOne(num) {\n> 4   return num + 1;\n  5 }\n  6\ndebug> exec('num')\n-1\ndebug>\n</code></pre>",
               "type": "module",
               "displayName": "Breakpoints"
             },
diff --git a/doc/api/debugger.md b/doc/api/debugger.md
index 8253c176e43c95006ad8234d8f40723f2d5eb1e9..b155738b073165c2c0e443ac20f9fdc7a056da26 100644
--- a/doc/api/debugger.md
+++ b/doc/api/debugger.md
@@ -6,20 +6,22 @@
 
 <!-- type=misc -->
 
-Node.js includes an out-of-process debugging utility accessible via a
-[V8 Inspector][] and built-in debugging client. To use it, start Node.js
-with the `inspect` argument followed by the path to the script to debug; a
-prompt will be displayed indicating successful launch of the debugger:
+Node.js includes a command-line debugging utility. To use it, start Node.js
+with the `inspect` argument followed by the path to the script to debug.
 
 ```console
 $ node inspect myscript.js
-< Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba
+< Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8
 < For help, see: https://nodejs.org/en/docs/inspector
+<
 < Debugger attached.
-Break on start in myscript.js:1
-> 1 (function (exports, require, module, __filename, __dirname) { global.x = 5;
-  2 setTimeout(() => {
-  3   console.log('world');
+<
+ ok
+Break on start in myscript.js:2
+  1 // myscript.js
+> 2 global.x = 5;
+  3 setTimeout(() => {
+  4   debugger;
 debug>
 ```
 
@@ -44,43 +46,50 @@ Once the debugger is run, a breakpoint will occur at line 3:
 
 ```console
 $ node inspect myscript.js
-< Debugger listening on ws://127.0.0.1:9229/80e7a814-7cd3-49fb-921a-2e02228cd5ba
+< Debugger listening on ws://127.0.0.1:9229/621111f9-ffcb-4e82-b718-48a145fa5db8
 < For help, see: https://nodejs.org/en/docs/inspector
+<
 < Debugger attached.
-Break on start in myscript.js:1
-> 1 (function (exports, require, module, __filename, __dirname) { global.x = 5;
-  2 setTimeout(() => {
-  3   debugger;
+<
+ ok
+Break on start in myscript.js:2
+  1 // myscript.js
+> 2 global.x = 5;
+  3 setTimeout(() => {
+  4   debugger;
 debug> cont
 < hello
-break in myscript.js:3
-  1 (function (exports, require, module, __filename, __dirname) { global.x = 5;
-  2 setTimeout(() => {
-> 3   debugger;
-  4   console.log('world');
-  5 }, 1000);
-debug> next
+<
 break in myscript.js:4
-  2 setTimeout(() => {
-  3   debugger;
-> 4   console.log('world');
-  5 }, 1000);
-  6 console.log('hello');
+  2 global.x = 5;
+  3 setTimeout(() => {
+> 4   debugger;
+  5   console.log('world');
+  6 }, 1000);
+debug> next
+break in myscript.js:5
+  3 setTimeout(() => {
+  4   debugger;
+> 5   console.log('world');
+  6 }, 1000);
+  7 console.log('hello');
 debug> repl
-Press Ctrl + C to leave debug repl
+Press Ctrl+C to leave debug repl
 > x
 5
 > 2 + 2
 4
 debug> next
 < world
-break in myscript.js:5
-  3   debugger;
-  4   console.log('world');
-> 5 }, 1000);
-  6 console.log('hello');
-  7
+<
+break in myscript.js:6
+  4   debugger;
+  5   console.log('world');
+> 6 }, 1000);
+  7 console.log('hello');
+  8
 debug> .exit
+$
 ```
 
 The `repl` command allows code to be evaluated remotely. The `next` command
@@ -115,22 +124,28 @@ To begin watching an expression, type `watch('my_expression')`. The command
 * `setBreakpoint()`, `sb()`: Set breakpoint on current line
 * `setBreakpoint(line)`, `sb(line)`: Set breakpoint on specific line
 * `setBreakpoint('fn()')`, `sb(...)`: Set breakpoint on a first statement in
-functions body
+  function's body
 * `setBreakpoint('script.js', 1)`, `sb(...)`: Set breakpoint on first line of
-`script.js`
+  `script.js`
+* `setBreakpoint('script.js', 1, 'num < 4')`, `sb(...)`: Set conditional
+  breakpoint on first line of `script.js` that only breaks when `num < 4`
+  evaluates to `true`
 * `clearBreakpoint('script.js', 1)`, `cb(...)`: Clear breakpoint in `script.js`
-on line 1
+  on line 1
 
 It is also possible to set a breakpoint in a file (module) that
 is not loaded yet:
 
 ```console
 $ node inspect main.js
-< Debugger listening on ws://127.0.0.1:9229/4e3db158-9791-4274-8909-914f7facf3bd
+< Debugger listening on ws://127.0.0.1:9229/48a5b28a-550c-471b-b5e1-d13dd7165df9
 < For help, see: https://nodejs.org/en/docs/inspector
+<
 < Debugger attached.
+<
+ ok
 Break on start in main.js:1
-> 1 (function (exports, require, module, __filename, __dirname) { const mod = require('./mod.js');
+> 1 const mod = require('./mod.js');
   2 mod.hello();
   3 mod.hello();
 debug> setBreakpoint('mod.js', 22)
@@ -145,15 +160,51 @@ break in mod.js:22
 debug>
 ```
 
+It is also possible to set a conditional breakpoint that only breaks when a
+given expression evaluates to `true`:
+
+```console
+$ node inspect main.js
+< Debugger listening on ws://127.0.0.1:9229/ce24daa8-3816-44d4-b8ab-8273c8a66d35
+< For help, see: https://nodejs.org/en/docs/inspector
+< Debugger attached.
+Break on start in main.js:7
+  5 }
+  6
+> 7 addOne(10);
+  8 addOne(-1);
+  9
+debug> setBreakpoint('main.js', 4, 'num < 0')
+  1 'use strict';
+  2
+  3 function addOne(num) {
+> 4   return num + 1;
+  5 }
+  6
+  7 addOne(10);
+  8 addOne(-1);
+  9
+debug> cont
+break in main.js:4
+  2
+  3 function addOne(num) {
+> 4   return num + 1;
+  5 }
+  6
+debug> exec('num')
+-1
+debug>
+```
+
 ### Information
 
 * `backtrace`, `bt`: Print backtrace of current execution frame
 * `list(5)`: List scripts source code with 5 line context (5 lines before and
-after)
+  after)
 * `watch(expr)`: Add expression to watch list
 * `unwatch(expr)`: Remove expression from watch list
 * `watchers`: List all watchers and their values (automatically listed on each
-breakpoint)
+  breakpoint)
 * `repl`: Open debugger's repl for evaluation in debugging script's context
 * `exec expr`: Execute an expression in debugging script's context
 
@@ -200,6 +251,5 @@ Chrome DevTools doesn't support debugging [worker threads][] yet.
 [ndb][] can be used to debug them.
 
 [Chrome DevTools Protocol]: https://chromedevtools.github.io/devtools-protocol/
-[V8 Inspector]: #debugger_v8_inspector_integration_for_node_js
-[worker threads]: worker_threads.html
 [ndb]: https://github.com/GoogleChromeLabs/ndb/
+[worker threads]: worker_threads.md
diff --git a/doc/api/deprecations.html b/doc/api/deprecations.html
index 5bcc5e1795e24681ebe6e7d215069c7e124f8043..2c9a85c1817874738b25c95d67382ee4c404de46 100644
--- a/doc/api/deprecations.html
+++ b/doc/api/deprecations.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Deprecated APIs | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Deprecated APIs | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations active">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="deprecations" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/deprecations.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/deprecations.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/deprecations.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/deprecations.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/deprecations.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/deprecations.html">13.x</a></li>
@@ -113,173 +128,181 @@
 <li><a href="https://nodejs.org/docs/latest-v7.x/api/deprecations.html">7.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/deprecations.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/deprecations.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#deprecations_deprecated_apis">Deprecated APIs</a>
 <ul>
 <li><a href="#deprecations_revoking_deprecations">Revoking deprecations</a></li>
 <li><a href="#deprecations_list_of_deprecated_apis">List of deprecated APIs</a>
 <ul>
-<li><a href="#deprecations_dep0001_http_outgoingmessage_prototype_flush">DEP0001: <code>http.OutgoingMessage.prototype.flush</code></a></li>
-<li><a href="#deprecations_dep0002_require_linklist">DEP0002: <code>require('_linklist')</code></a></li>
-<li><a href="#deprecations_dep0003_writablestate_buffer">DEP0003: <code>_writableState.buffer</code></a></li>
-<li><a href="#deprecations_dep0004_cryptostream_prototype_readystate">DEP0004: <code>CryptoStream.prototype.readyState</code></a></li>
-<li><a href="#deprecations_dep0005_buffer_constructor">DEP0005: <code>Buffer()</code> constructor</a></li>
-<li><a href="#deprecations_dep0006_child_process_options_customfds">DEP0006: <code>child_process</code> <code>options.customFds</code></a></li>
-<li><a href="#deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect">DEP0007: Replace <code>cluster</code> <code>worker.suicide</code> with <code>worker.exitedAfterDisconnect</code></a></li>
-<li><a href="#deprecations_dep0008_require_constants">DEP0008: <code>require('constants')</code></a></li>
-<li><a href="#deprecations_dep0009_crypto_pbkdf2_without_digest">DEP0009: <code>crypto.pbkdf2</code> without digest</a></li>
-<li><a href="#deprecations_dep0010_crypto_createcredentials">DEP0010: <code>crypto.createCredentials</code></a></li>
-<li><a href="#deprecations_dep0011_crypto_credentials">DEP0011: <code>crypto.Credentials</code></a></li>
-<li><a href="#deprecations_dep0012_domain_dispose">DEP0012: <code>Domain.dispose</code></a></li>
-<li><a href="#deprecations_dep0013_fs_asynchronous_function_without_callback">DEP0013: <code>fs</code> asynchronous function without callback</a></li>
-<li><a href="#deprecations_dep0014_fs_read_legacy_string_interface">DEP0014: <code>fs.read</code> legacy String interface</a></li>
-<li><a href="#deprecations_dep0015_fs_readsync_legacy_string_interface">DEP0015: <code>fs.readSync</code> legacy String interface</a></li>
-<li><a href="#deprecations_dep0016_global_root">DEP0016: <code>GLOBAL</code>/<code>root</code></a></li>
-<li><a href="#deprecations_dep0017_intl_v8breakiterator">DEP0017: <code>Intl.v8BreakIterator</code></a></li>
-<li><a href="#deprecations_dep0018_unhandled_promise_rejections">DEP0018: Unhandled promise rejections</a></li>
-<li><a href="#deprecations_dep0019_require_resolved_outside_directory">DEP0019: <code>require('.')</code> resolved outside directory</a></li>
-<li><a href="#deprecations_dep0020_server_connections">DEP0020: <code>Server.connections</code></a></li>
-<li><a href="#deprecations_dep0021_server_listenfd">DEP0021: <code>Server.listenFD</code></a></li>
-<li><a href="#deprecations_dep0022_os_tmpdir">DEP0022: <code>os.tmpDir()</code></a></li>
-<li><a href="#deprecations_dep0023_os_getnetworkinterfaces">DEP0023: <code>os.getNetworkInterfaces()</code></a></li>
-<li><a href="#deprecations_dep0024_replserver_prototype_converttocontext">DEP0024: <code>REPLServer.prototype.convertToContext()</code></a></li>
-<li><a href="#deprecations_dep0025_require_sys">DEP0025: <code>require('sys')</code></a></li>
-<li><a href="#deprecations_dep0026_util_print">DEP0026: <code>util.print()</code></a></li>
-<li><a href="#deprecations_dep0027_util_puts">DEP0027: <code>util.puts()</code></a></li>
-<li><a href="#deprecations_dep0028_util_debug">DEP0028: <code>util.debug()</code></a></li>
-<li><a href="#deprecations_dep0029_util_error">DEP0029: <code>util.error()</code></a></li>
-<li><a href="#deprecations_dep0030_slowbuffer">DEP0030: <code>SlowBuffer</code></a></li>
-<li><a href="#deprecations_dep0031_ecdh_setpublickey">DEP0031: <code>ecdh.setPublicKey()</code></a></li>
-<li><a href="#deprecations_dep0032_domain_module">DEP0032: <code>domain</code> module</a></li>
-<li><a href="#deprecations_dep0033_eventemitter_listenercount">DEP0033: <code>EventEmitter.listenerCount()</code></a></li>
-<li><a href="#deprecations_dep0034_fs_exists_path_callback">DEP0034: <code>fs.exists(path, callback)</code></a></li>
-<li><a href="#deprecations_dep0035_fs_lchmod_path_mode_callback">DEP0035: <code>fs.lchmod(path, mode, callback)</code></a></li>
-<li><a href="#deprecations_dep0036_fs_lchmodsync_path_mode">DEP0036: <code>fs.lchmodSync(path, mode)</code></a></li>
-<li><a href="#deprecations_dep0037_fs_lchown_path_uid_gid_callback">DEP0037: <code>fs.lchown(path, uid, gid, callback)</code></a></li>
-<li><a href="#deprecations_dep0038_fs_lchownsync_path_uid_gid">DEP0038: <code>fs.lchownSync(path, uid, gid)</code></a></li>
-<li><a href="#deprecations_dep0039_require_extensions">DEP0039: <code>require.extensions</code></a></li>
-<li><a href="#deprecations_dep0040_punycode_module">DEP0040: <code>punycode</code> module</a></li>
-<li><a href="#deprecations_dep0041_node_repl_history_file_environment_variable">DEP0041: <code>NODE_REPL_HISTORY_FILE</code> environment variable</a></li>
-<li><a href="#deprecations_dep0042_tls_cryptostream">DEP0042: <code>tls.CryptoStream</code></a></li>
-<li><a href="#deprecations_dep0043_tls_securepair">DEP0043: <code>tls.SecurePair</code></a></li>
-<li><a href="#deprecations_dep0044_util_isarray">DEP0044: <code>util.isArray()</code></a></li>
-<li><a href="#deprecations_dep0045_util_isboolean">DEP0045: <code>util.isBoolean()</code></a></li>
-<li><a href="#deprecations_dep0046_util_isbuffer">DEP0046: <code>util.isBuffer()</code></a></li>
-<li><a href="#deprecations_dep0047_util_isdate">DEP0047: <code>util.isDate()</code></a></li>
-<li><a href="#deprecations_dep0048_util_iserror">DEP0048: <code>util.isError()</code></a></li>
-<li><a href="#deprecations_dep0049_util_isfunction">DEP0049: <code>util.isFunction()</code></a></li>
-<li><a href="#deprecations_dep0050_util_isnull">DEP0050: <code>util.isNull()</code></a></li>
-<li><a href="#deprecations_dep0051_util_isnullorundefined">DEP0051: <code>util.isNullOrUndefined()</code></a></li>
-<li><a href="#deprecations_dep0052_util_isnumber">DEP0052: <code>util.isNumber()</code></a></li>
-<li><a href="#deprecations_dep0053_util_isobject">DEP0053 <code>util.isObject()</code></a></li>
-<li><a href="#deprecations_dep0054_util_isprimitive">DEP0054: <code>util.isPrimitive()</code></a></li>
-<li><a href="#deprecations_dep0055_util_isregexp">DEP0055: <code>util.isRegExp()</code></a></li>
-<li><a href="#deprecations_dep0056_util_isstring">DEP0056: <code>util.isString()</code></a></li>
-<li><a href="#deprecations_dep0057_util_issymbol">DEP0057: <code>util.isSymbol()</code></a></li>
-<li><a href="#deprecations_dep0058_util_isundefined">DEP0058: <code>util.isUndefined()</code></a></li>
-<li><a href="#deprecations_dep0059_util_log">DEP0059: <code>util.log()</code></a></li>
-<li><a href="#deprecations_dep0060_util_extend">DEP0060: <code>util._extend()</code></a></li>
-<li><a href="#deprecations_dep0061_fs_syncwritestream">DEP0061: <code>fs.SyncWriteStream</code></a></li>
-<li><a href="#deprecations_dep0062_node_debug">DEP0062: <code>node --debug</code></a></li>
-<li><a href="#deprecations_dep0063_serverresponse_prototype_writeheader">DEP0063: <code>ServerResponse.prototype.writeHeader()</code></a></li>
-<li><a href="#deprecations_dep0064_tls_createsecurepair">DEP0064: <code>tls.createSecurePair()</code></a></li>
-<li><a href="#deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic">DEP0065: <code>repl.REPL_MODE_MAGIC</code> and <code>NODE_REPL_MODE=magic</code></a></li>
-<li><a href="#deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames">DEP0066: <code>OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames</code></a></li>
-<li><a href="#deprecations_dep0067_outgoingmessage_prototype_renderheaders">DEP0067: <code>OutgoingMessage.prototype._renderHeaders</code></a></li>
-<li><a href="#deprecations_dep0068_node_debug">DEP0068: <code>node debug</code></a></li>
-<li><a href="#deprecations_dep0069_vm_runindebugcontext_string">DEP0069: <code>vm.runInDebugContext(string)</code></a></li>
-<li><a href="#deprecations_dep0070_async_hooks_currentid">DEP0070: <code>async_hooks.currentId()</code></a></li>
-<li><a href="#deprecations_dep0071_async_hooks_triggerid">DEP0071: <code>async_hooks.triggerId()</code></a></li>
-<li><a href="#deprecations_dep0072_async_hooks_asyncresource_triggerid">DEP0072: <code>async_hooks.AsyncResource.triggerId()</code></a></li>
-<li><a href="#deprecations_dep0073_several_internal_properties_of_net_server">DEP0073: Several internal properties of <code>net.Server</code></a></li>
-<li><a href="#deprecations_dep0074_replserver_bufferedcommand">DEP0074: <code>REPLServer.bufferedCommand</code></a></li>
-<li><a href="#deprecations_dep0075_replserver_parsereplkeyword">DEP0075: <code>REPLServer.parseREPLKeyword()</code></a></li>
-<li><a href="#deprecations_dep0076_tls_parsecertstring">DEP0076: <code>tls.parseCertString()</code></a></li>
-<li><a href="#deprecations_dep0077_module_debug">DEP0077: <code>Module._debug()</code></a></li>
-<li><a href="#deprecations_dep0078_replserver_turnoffeditormode">DEP0078: <code>REPLServer.turnOffEditorMode()</code></a></li>
-<li><a href="#deprecations_dep0079_custom_inspection_function_on_objects_via_inspect">DEP0079: Custom inspection function on objects via <code>.inspect()</code></a></li>
-<li><a href="#deprecations_dep0080_path_makelong">DEP0080: <code>path._makeLong()</code></a></li>
-<li><a href="#deprecations_dep0081_fs_truncate_using_a_file_descriptor">DEP0081: <code>fs.truncate()</code> using a file descriptor</a></li>
-<li><a href="#deprecations_dep0082_replserver_prototype_memory">DEP0082: <code>REPLServer.prototype.memory()</code></a></li>
-<li><a href="#deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false">DEP0083: Disabling ECDH by setting <code>ecdhCurve</code> to <code>false</code></a></li>
-<li><a href="#deprecations_dep0084_requiring_bundled_internal_dependencies">DEP0084: requiring bundled internal dependencies</a></li>
-<li><a href="#deprecations_dep0085_asynchooks_sensitive_api">DEP0085: AsyncHooks sensitive API</a></li>
-<li><a href="#deprecations_dep0086_remove_runinasyncidscope">DEP0086: Remove <code>runInAsyncIdScope</code></a></li>
-<li><a href="#deprecations_dep0089_require_assert">DEP0089: <code>require('assert')</code></a></li>
-<li><a href="#deprecations_dep0090_invalid_gcm_authentication_tag_lengths">DEP0090: Invalid GCM authentication tag lengths</a></li>
-<li><a href="#deprecations_dep0091_crypto_default_encoding">DEP0091: <code>crypto.DEFAULT_ENCODING</code></a></li>
-<li><a href="#deprecations_dep0092_top_level_this_bound_to_module_exports">DEP0092: Top-level <code>this</code> bound to <code>module.exports</code></a></li>
-<li><a href="#deprecations_dep0093_crypto_fips_is_deprecated_and_replaced">DEP0093: <code>crypto.fips</code> is deprecated and replaced.</a></li>
-<li><a href="#deprecations_dep0094_using_assert_fail_with_more_than_one_argument">DEP0094: Using <code>assert.fail()</code> with more than one argument.</a></li>
-<li><a href="#deprecations_dep0095_timers_enroll">DEP0095: <code>timers.enroll()</code></a></li>
-<li><a href="#deprecations_dep0096_timers_unenroll">DEP0096: <code>timers.unenroll()</code></a></li>
-<li><a href="#deprecations_dep0097_makecallback_with_domain_property">DEP0097: <code>MakeCallback</code> with <code>domain</code> property</a></li>
-<li><a href="#deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis">DEP0098: AsyncHooks embedder <code>AsyncResource.emitBefore</code> and <code>AsyncResource.emitAfter</code> APIs</a></li>
-<li><a href="#deprecations_dep0099_async_context_unaware_node_makecallback_c_apis">DEP0099: Async context-unaware <code>node::MakeCallback</code> C++ APIs</a></li>
-<li><a href="#deprecations_dep0100_process_assert">DEP0100: <code>process.assert()</code></a></li>
-<li><a href="#deprecations_dep0101_with_lttng">DEP0101: <code>--with-lttng</code></a></li>
-<li><a href="#deprecations_dep0102_using_noassert_in_buffer_read_write_operations">DEP0102: Using <code>noAssert</code> in <code>Buffer#(read|write)</code> operations.</a></li>
-<li><a href="#deprecations_dep0103_process_binding_util_is_typechecks">DEP0103: <code>process.binding('util').is[...]</code> typechecks</a></li>
-<li><a href="#deprecations_dep0104_process_env_string_coercion">DEP0104: <code>process.env</code> string coercion</a></li>
-<li><a href="#deprecations_dep0105_decipher_finaltol">DEP0105: <code>decipher.finaltol</code></a></li>
-<li><a href="#deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher">DEP0106: <code>crypto.createCipher</code> and <code>crypto.createDecipher</code></a></li>
-<li><a href="#deprecations_dep0107_tls_convertnpnprotocols">DEP0107: <code>tls.convertNPNProtocols()</code></a></li>
-<li><a href="#deprecations_dep0108_zlib_bytesread">DEP0108: <code>zlib.bytesRead</code></a></li>
-<li><a href="#deprecations_dep0109_http_https_and_tls_support_for_invalid_urls">DEP0109: <code>http</code>, <code>https</code>, and <code>tls</code> support for invalid URLs</a></li>
-<li><a href="#deprecations_dep0110_vm_script_cached_data">DEP0110: <code>vm.Script</code> cached data</a></li>
-<li><a href="#deprecations_dep0111_process_binding">DEP0111: <code>process.binding()</code></a></li>
-<li><a href="#deprecations_dep0112_dgram_private_apis">DEP0112: <code>dgram</code> private APIs</a></li>
-<li><a href="#deprecations_dep0113_cipher_setauthtag_decipher_getauthtag">DEP0113: <code>Cipher.setAuthTag()</code>, <code>Decipher.getAuthTag()</code></a></li>
-<li><a href="#deprecations_dep0114_crypto_tobuf">DEP0114: <code>crypto._toBuf()</code></a></li>
-<li><a href="#deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng">DEP0115: <code>crypto.prng()</code>, <code>crypto.pseudoRandomBytes()</code>, <code>crypto.rng()</code></a></li>
-<li><a href="#deprecations_dep0116_legacy_url_api">DEP0116: Legacy URL API</a></li>
-<li><a href="#deprecations_dep0117_native_crypto_handles">DEP0117: Native crypto handles</a></li>
-<li><a href="#deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name">DEP0118: <code>dns.lookup()</code> support for a falsy host name</a></li>
-<li><a href="#deprecations_dep0119_process_binding_uv_errname_private_api">DEP0119: <code>process.binding('uv').errname()</code> private API</a></li>
-<li><a href="#deprecations_dep0120_windows_performance_counter_support">DEP0120: Windows Performance Counter support</a></li>
-<li><a href="#deprecations_dep0121_net_setsimultaneousaccepts">DEP0121: <code>net._setSimultaneousAccepts()</code></a></li>
-<li><a href="#deprecations_dep0122_tls_server_prototype_setoptions">DEP0122: <code>tls</code> <code>Server.prototype.setOptions()</code></a></li>
-<li><a href="#deprecations_dep0123_setting_the_tls_servername_to_an_ip_address">DEP0123: setting the TLS ServerName to an IP address</a></li>
-<li><a href="#deprecations_dep0124_using_replserver_rli">DEP0124: using <code>REPLServer.rli</code></a></li>
-<li><a href="#deprecations_dep0125_require_stream_wrap">DEP0125: <code>require('_stream_wrap')</code></a></li>
-<li><a href="#deprecations_dep0126_timers_active">DEP0126: <code>timers.active()</code></a></li>
-<li><a href="#deprecations_dep0127_timers_unrefactive">DEP0127: <code>timers._unrefActive()</code></a></li>
-<li><a href="#deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file">DEP0128: modules with an invalid <code>main</code> entry and an <code>index.js</code> file</a></li>
-<li><a href="#deprecations_dep0129_childprocess_channel">DEP0129: <code>ChildProcess._channel</code></a></li>
-<li><a href="#deprecations_dep0130_module_createrequirefrompath">DEP0130: <code>Module.createRequireFromPath()</code></a></li>
-<li><a href="#deprecations_dep0131_legacy_http_parser">DEP0131: Legacy HTTP parser</a></li>
-<li><a href="#deprecations_dep0132_worker_terminate_with_callback">DEP0132: <code>worker.terminate()</code> with callback</a></li>
-<li><a href="#deprecations_dep0133_http_connection">DEP0133: <code>http</code> <code>connection</code></a></li>
-<li><a href="#deprecations_dep0134_process_tickcallback">DEP0134: <code>process._tickCallback</code></a></li>
-<li><a href="#deprecations_dep0136_http_finished">DEP0136: <code>http</code> <code>finished</code></a></li>
-<li><a href="#deprecations_dep0139_process_umask_with_no_arguments">DEP0139: <code>process.umask()</code> with no arguments</a></li>
-<li><a href="#deprecations_dep0144_module_parent">DEP0144: <code>module.parent</code></a></li>
+<li><a href="#DEP0001">DEP0001: <code>http.OutgoingMessage.prototype.flush</code></a></li>
+<li><a href="#DEP0002">DEP0002: <code>require('_linklist')</code></a></li>
+<li><a href="#DEP0003">DEP0003: <code>_writableState.buffer</code></a></li>
+<li><a href="#DEP0004">DEP0004: <code>CryptoStream.prototype.readyState</code></a></li>
+<li><a href="#DEP0005">DEP0005: <code>Buffer()</code> constructor</a></li>
+<li><a href="#DEP0006">DEP0006: <code>child_process</code> <code>options.customFds</code></a></li>
+<li><a href="#DEP0007">DEP0007: Replace <code>cluster</code> <code>worker.suicide</code> with <code>worker.exitedAfterDisconnect</code></a></li>
+<li><a href="#DEP0008">DEP0008: <code>require('constants')</code></a></li>
+<li><a href="#DEP0009">DEP0009: <code>crypto.pbkdf2</code> without digest</a></li>
+<li><a href="#DEP0010">DEP0010: <code>crypto.createCredentials</code></a></li>
+<li><a href="#DEP0011">DEP0011: <code>crypto.Credentials</code></a></li>
+<li><a href="#DEP0012">DEP0012: <code>Domain.dispose</code></a></li>
+<li><a href="#DEP0013">DEP0013: <code>fs</code> asynchronous function without callback</a></li>
+<li><a href="#DEP0014">DEP0014: <code>fs.read</code> legacy String interface</a></li>
+<li><a href="#DEP0015">DEP0015: <code>fs.readSync</code> legacy String interface</a></li>
+<li><a href="#DEP0016">DEP0016: <code>GLOBAL</code>/<code>root</code></a></li>
+<li><a href="#DEP0017">DEP0017: <code>Intl.v8BreakIterator</code></a></li>
+<li><a href="#DEP0018">DEP0018: Unhandled promise rejections</a></li>
+<li><a href="#DEP0019">DEP0019: <code>require('.')</code> resolved outside directory</a></li>
+<li><a href="#DEP0020">DEP0020: <code>Server.connections</code></a></li>
+<li><a href="#DEP0021">DEP0021: <code>Server.listenFD</code></a></li>
+<li><a href="#DEP0022">DEP0022: <code>os.tmpDir()</code></a></li>
+<li><a href="#DEP0023">DEP0023: <code>os.getNetworkInterfaces()</code></a></li>
+<li><a href="#DEP0024">DEP0024: <code>REPLServer.prototype.convertToContext()</code></a></li>
+<li><a href="#DEP0025">DEP0025: <code>require('sys')</code></a></li>
+<li><a href="#DEP0026">DEP0026: <code>util.print()</code></a></li>
+<li><a href="#DEP0027">DEP0027: <code>util.puts()</code></a></li>
+<li><a href="#DEP0028">DEP0028: <code>util.debug()</code></a></li>
+<li><a href="#DEP0029">DEP0029: <code>util.error()</code></a></li>
+<li><a href="#DEP0030">DEP0030: <code>SlowBuffer</code></a></li>
+<li><a href="#DEP0031">DEP0031: <code>ecdh.setPublicKey()</code></a></li>
+<li><a href="#DEP0032">DEP0032: <code>domain</code> module</a></li>
+<li><a href="#DEP0033">DEP0033: <code>EventEmitter.listenerCount()</code></a></li>
+<li><a href="#DEP0034">DEP0034: <code>fs.exists(path, callback)</code></a></li>
+<li><a href="#DEP0035">DEP0035: <code>fs.lchmod(path, mode, callback)</code></a></li>
+<li><a href="#DEP0036">DEP0036: <code>fs.lchmodSync(path, mode)</code></a></li>
+<li><a href="#DEP0037">DEP0037: <code>fs.lchown(path, uid, gid, callback)</code></a></li>
+<li><a href="#DEP0038">DEP0038: <code>fs.lchownSync(path, uid, gid)</code></a></li>
+<li><a href="#DEP0039">DEP0039: <code>require.extensions</code></a></li>
+<li><a href="#DEP0040">DEP0040: <code>punycode</code> module</a></li>
+<li><a href="#DEP0041">DEP0041: <code>NODE_REPL_HISTORY_FILE</code> environment variable</a></li>
+<li><a href="#DEP0042">DEP0042: <code>tls.CryptoStream</code></a></li>
+<li><a href="#DEP0043">DEP0043: <code>tls.SecurePair</code></a></li>
+<li><a href="#DEP0044">DEP0044: <code>util.isArray()</code></a></li>
+<li><a href="#DEP0045">DEP0045: <code>util.isBoolean()</code></a></li>
+<li><a href="#DEP0046">DEP0046: <code>util.isBuffer()</code></a></li>
+<li><a href="#DEP0047">DEP0047: <code>util.isDate()</code></a></li>
+<li><a href="#DEP0048">DEP0048: <code>util.isError()</code></a></li>
+<li><a href="#DEP0049">DEP0049: <code>util.isFunction()</code></a></li>
+<li><a href="#DEP0050">DEP0050: <code>util.isNull()</code></a></li>
+<li><a href="#DEP0051">DEP0051: <code>util.isNullOrUndefined()</code></a></li>
+<li><a href="#DEP0052">DEP0052: <code>util.isNumber()</code></a></li>
+<li><a href="#DEP0053">DEP0053: <code>util.isObject()</code></a></li>
+<li><a href="#DEP0054">DEP0054: <code>util.isPrimitive()</code></a></li>
+<li><a href="#DEP0055">DEP0055: <code>util.isRegExp()</code></a></li>
+<li><a href="#DEP0056">DEP0056: <code>util.isString()</code></a></li>
+<li><a href="#DEP0057">DEP0057: <code>util.isSymbol()</code></a></li>
+<li><a href="#DEP0058">DEP0058: <code>util.isUndefined()</code></a></li>
+<li><a href="#DEP0059">DEP0059: <code>util.log()</code></a></li>
+<li><a href="#DEP0060">DEP0060: <code>util._extend()</code></a></li>
+<li><a href="#DEP0061">DEP0061: <code>fs.SyncWriteStream</code></a></li>
+<li><a href="#DEP0062">DEP0062: <code>node --debug</code></a></li>
+<li><a href="#DEP0063">DEP0063: <code>ServerResponse.prototype.writeHeader()</code></a></li>
+<li><a href="#DEP0064">DEP0064: <code>tls.createSecurePair()</code></a></li>
+<li><a href="#DEP0065">DEP0065: <code>repl.REPL_MODE_MAGIC</code> and <code>NODE_REPL_MODE=magic</code></a></li>
+<li><a href="#DEP0066">DEP0066: <code>OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames</code></a></li>
+<li><a href="#DEP0067">DEP0067: <code>OutgoingMessage.prototype._renderHeaders</code></a></li>
+<li><a href="#DEP0068">DEP0068: <code>node debug</code></a></li>
+<li><a href="#DEP0069">DEP0069: <code>vm.runInDebugContext(string)</code></a></li>
+<li><a href="#DEP0070">DEP0070: <code>async_hooks.currentId()</code></a></li>
+<li><a href="#DEP0071">DEP0071: <code>async_hooks.triggerId()</code></a></li>
+<li><a href="#DEP0072">DEP0072: <code>async_hooks.AsyncResource.triggerId()</code></a></li>
+<li><a href="#DEP0073">DEP0073: Several internal properties of <code>net.Server</code></a></li>
+<li><a href="#DEP0074">DEP0074: <code>REPLServer.bufferedCommand</code></a></li>
+<li><a href="#DEP0075">DEP0075: <code>REPLServer.parseREPLKeyword()</code></a></li>
+<li><a href="#DEP0076">DEP0076: <code>tls.parseCertString()</code></a></li>
+<li><a href="#DEP0077">DEP0077: <code>Module._debug()</code></a></li>
+<li><a href="#DEP0078">DEP0078: <code>REPLServer.turnOffEditorMode()</code></a></li>
+<li><a href="#DEP0079">DEP0079: Custom inspection function on objects via <code>.inspect()</code></a></li>
+<li><a href="#DEP0080">DEP0080: <code>path._makeLong()</code></a></li>
+<li><a href="#DEP0081">DEP0081: <code>fs.truncate()</code> using a file descriptor</a></li>
+<li><a href="#DEP0082">DEP0082: <code>REPLServer.prototype.memory()</code></a></li>
+<li><a href="#DEP0083">DEP0083: Disabling ECDH by setting <code>ecdhCurve</code> to <code>false</code></a></li>
+<li><a href="#DEP0084">DEP0084: requiring bundled internal dependencies</a></li>
+<li><a href="#DEP0085">DEP0085: AsyncHooks sensitive API</a></li>
+<li><a href="#DEP0086">DEP0086: Remove <code>runInAsyncIdScope</code></a></li>
+<li><a href="#DEP0089">DEP0089: <code>require('assert')</code></a></li>
+<li><a href="#DEP0090">DEP0090: Invalid GCM authentication tag lengths</a></li>
+<li><a href="#DEP0091">DEP0091: <code>crypto.DEFAULT_ENCODING</code></a></li>
+<li><a href="#DEP0092">DEP0092: Top-level <code>this</code> bound to <code>module.exports</code></a></li>
+<li><a href="#DEP0093">DEP0093: <code>crypto.fips</code> is deprecated and replaced</a></li>
+<li><a href="#DEP0094">DEP0094: Using <code>assert.fail()</code> with more than one argument</a></li>
+<li><a href="#DEP0095">DEP0095: <code>timers.enroll()</code></a></li>
+<li><a href="#DEP0096">DEP0096: <code>timers.unenroll()</code></a></li>
+<li><a href="#DEP0097">DEP0097: <code>MakeCallback</code> with <code>domain</code> property</a></li>
+<li><a href="#DEP0098">DEP0098: AsyncHooks embedder <code>AsyncResource.emitBefore</code> and <code>AsyncResource.emitAfter</code> APIs</a></li>
+<li><a href="#DEP0099">DEP0099: Async context-unaware <code>node::MakeCallback</code> C++ APIs</a></li>
+<li><a href="#DEP0100">DEP0100: <code>process.assert()</code></a></li>
+<li><a href="#DEP0101">DEP0101: <code>--with-lttng</code></a></li>
+<li><a href="#DEP0102">DEP0102: Using <code>noAssert</code> in <code>Buffer#(read|write)</code> operations</a></li>
+<li><a href="#DEP0103">DEP0103: <code>process.binding('util').is[...]</code> typechecks</a></li>
+<li><a href="#DEP0104">DEP0104: <code>process.env</code> string coercion</a></li>
+<li><a href="#DEP0105">DEP0105: <code>decipher.finaltol</code></a></li>
+<li><a href="#DEP0106">DEP0106: <code>crypto.createCipher</code> and <code>crypto.createDecipher</code></a></li>
+<li><a href="#DEP0107">DEP0107: <code>tls.convertNPNProtocols()</code></a></li>
+<li><a href="#DEP0108">DEP0108: <code>zlib.bytesRead</code></a></li>
+<li><a href="#DEP0109">DEP0109: <code>http</code>, <code>https</code>, and <code>tls</code> support for invalid URLs</a></li>
+<li><a href="#DEP0110">DEP0110: <code>vm.Script</code> cached data</a></li>
+<li><a href="#DEP0111">DEP0111: <code>process.binding()</code></a></li>
+<li><a href="#DEP0112">DEP0112: <code>dgram</code> private APIs</a></li>
+<li><a href="#DEP0113">DEP0113: <code>Cipher.setAuthTag()</code>, <code>Decipher.getAuthTag()</code></a></li>
+<li><a href="#DEP0114">DEP0114: <code>crypto._toBuf()</code></a></li>
+<li><a href="#DEP0115">DEP0115: <code>crypto.prng()</code>, <code>crypto.pseudoRandomBytes()</code>, <code>crypto.rng()</code></a></li>
+<li><a href="#DEP0116">DEP0116: Legacy URL API</a></li>
+<li><a href="#DEP0117">DEP0117: Native crypto handles</a></li>
+<li><a href="#DEP0118">DEP0118: <code>dns.lookup()</code> support for a falsy host name</a></li>
+<li><a href="#DEP0119">DEP0119: <code>process.binding('uv').errname()</code> private API</a></li>
+<li><a href="#DEP0120">DEP0120: Windows Performance Counter support</a></li>
+<li><a href="#DEP0121">DEP0121: <code>net._setSimultaneousAccepts()</code></a></li>
+<li><a href="#DEP0122">DEP0122: <code>tls</code> <code>Server.prototype.setOptions()</code></a></li>
+<li><a href="#DEP0123">DEP0123: setting the TLS ServerName to an IP address</a></li>
+<li><a href="#DEP0124">DEP0124: using <code>REPLServer.rli</code></a></li>
+<li><a href="#DEP0125">DEP0125: <code>require('_stream_wrap')</code></a></li>
+<li><a href="#DEP0126">DEP0126: <code>timers.active()</code></a></li>
+<li><a href="#DEP0127">DEP0127: <code>timers._unrefActive()</code></a></li>
+<li><a href="#DEP0128">DEP0128: modules with an invalid <code>main</code> entry and an <code>index.js</code> file</a></li>
+<li><a href="#DEP0129">DEP0129: <code>ChildProcess._channel</code></a></li>
+<li><a href="#DEP0130">DEP0130: <code>Module.createRequireFromPath()</code></a></li>
+<li><a href="#DEP0131">DEP0131: Legacy HTTP parser</a></li>
+<li><a href="#DEP0132">DEP0132: <code>worker.terminate()</code> with callback</a></li>
+<li><a href="#DEP0133">DEP0133: <code>http</code> <code>connection</code></a></li>
+<li><a href="#DEP0134">DEP0134: <code>process._tickCallback</code></a></li>
+<li><a href="#DEP0135">DEP0135: <code>WriteStream.open()</code> and <code>ReadStream.open()</code> are internal</a></li>
+<li><a href="#DEP0136">DEP0136: <code>http</code> <code>finished</code></a></li>
+<li><a href="#DEP0137">DEP0137: Closing fs.FileHandle on garbage collection</a></li>
+<li><a href="#DEP0138">DEP0138: <code>process.mainModule</code></a></li>
+<li><a href="#DEP0139">DEP0139: <code>process.umask()</code> with no arguments</a></li>
+<li><a href="#DEP0140">DEP0140: Use <code>request.destroy()</code> instead of <code>request.abort()</code></a></li>
+<li><a href="#DEP0141">DEP0141: <code>repl.inputStream</code> and <code>repl.outputStream</code></a></li>
+<li><a href="#DEP0142">DEP0142: <code>repl._builtinLibs</code></a></li>
+<li><a href="#DEP0143">DEP0143: <code>Transform._transformState</code></a></li>
+<li><a href="#DEP0144">DEP0144: <code>module.parent</code></a></li>
+<li><a href="#DEP0145">DEP0145: <code>socket.bufferSize</code></a></li>
+<li><a href="#DEP0146">DEP0146: <code>new crypto.Certificate()</code></a></li>
+<li><a href="#DEP0147">DEP0147: <code>fs.rmdir(path, { recursive: true })</code></a></li>
+<li><a href="#DEP0151">DEP0151: Main index lookup and extension searching</a></li>
 </ul>
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Deprecated APIs<span><a class="mark" href="#deprecations_deprecated_apis" id="deprecations_deprecated_apis">#</a></span></h1>
+        <h2>Deprecated APIs<span><a class="mark" href="#deprecations_deprecated_apis" id="deprecations_deprecated_apis">#</a></span></h2>
 
 
-<p>Node.js may deprecate APIs for any of the following reasons:</p>
+<p>Node.js APIs might be deprecated for any of the following reasons:</p>
 <ul>
 <li>Use of the API is unsafe.</li>
 <li>An improved alternative API is available.</li>
 <li>Breaking changes to the API are expected in a future major release.</li>
 </ul>
-<p>Node.js utilizes three kinds of Deprecations:</p>
+<p>Node.js uses three kinds of Deprecations:</p>
 <ul>
 <li>Documentation-only</li>
 <li>Runtime</li>
@@ -299,29 +322,29 @@ be printed to <code>stderr</code> the first time the deprecated API is used. Whe
 cause an error to be thrown.</p>
 <p>An End-of-Life deprecation is used when functionality is or will soon be removed
 from Node.js.</p>
-<h2>Revoking deprecations<span><a class="mark" href="#deprecations_revoking_deprecations" id="deprecations_revoking_deprecations">#</a></span></h2>
-<p>Occasionally, the deprecation of an API may be reversed. In such situations,
+<section><h3>Revoking deprecations<span><a class="mark" href="#deprecations_revoking_deprecations" id="deprecations_revoking_deprecations">#</a></span></h3>
+<p>Occasionally, the deprecation of an API might be reversed. In such situations,
 this document will be updated with information relevant to the decision.
 However, the deprecation identifier will not be modified.</p>
-<h2>List of deprecated APIs<span><a class="mark" href="#deprecations_list_of_deprecated_apis" id="deprecations_list_of_deprecated_apis">#</a></span></h2>
-<p><a id="DEP0001"></a></p>
-<h3>DEP0001: <code>http.OutgoingMessage.prototype.flush</code><span><a class="mark" href="#deprecations_dep0001_http_outgoingmessage_prototype_flush" id="deprecations_dep0001_http_outgoingmessage_prototype_flush">#</a></span></h3>
+</section><section><h3>List of deprecated APIs<span><a class="mark" href="#deprecations_list_of_deprecated_apis" id="deprecations_list_of_deprecated_apis">#</a></span></h3>
+<h4 id="DEP0001">DEP0001: <code>http.OutgoingMessage.prototype.flush</code><span><a class="mark" href="#deprecations_dep0001_http_outgoingmessage_prototype_flush" id="deprecations_dep0001_http_outgoingmessage_prototype_flush">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.6.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
-<p>The <code>OutgoingMessage.prototype.flush()</code> method is deprecated. Use
+<p>Type: End-of-Life</p>
+<p><code>OutgoingMessage.prototype.flush()</code> has been removed. Use
 <code>OutgoingMessage.prototype.flushHeaders()</code> instead.</p>
-<p><a id="DEP0002"></a></p>
-<h3>DEP0002: <code>require('_linklist')</code><span><a class="mark" href="#deprecations_dep0002_require_linklist" id="deprecations_dep0002_require_linklist">#</a></span></h3>
+<h4 id="DEP0002">DEP0002: <code>require('_linklist')</code><span><a class="mark" href="#deprecations_dep0002_require_linklist" id="deprecations_dep0002_require_linklist">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -337,41 +360,40 @@ However, the deprecation identifier will not be modified.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p>The <code>_linklist</code> module is deprecated. Please use a userland alternative.</p>
-<p><a id="DEP0003"></a></p>
-<h3>DEP0003: <code>_writableState.buffer</code><span><a class="mark" href="#deprecations_dep0003_writablestate_buffer" id="deprecations_dep0003_writablestate_buffer">#</a></span></h3>
+<h4 id="DEP0003">DEP0003: <code>_writableState.buffer</code><span><a class="mark" href="#deprecations_dep0003_writablestate_buffer" id="deprecations_dep0003_writablestate_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.15</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
-<p>The <code>_writableState.buffer</code> property is deprecated. Use the
-<code>_writableState.getBuffer()</code> method instead.</p>
-<p><a id="DEP0004"></a></p>
-<h3>DEP0004: <code>CryptoStream.prototype.readyState</code><span><a class="mark" href="#deprecations_dep0004_cryptostream_prototype_readystate" id="deprecations_dep0004_cryptostream_prototype_readystate">#</a></span></h3>
+<p>Type: End-of-Life</p>
+<p>The <code>_writableState.buffer</code> has been removed. Use <code>_writableState.getBuffer()</code>
+instead.</p>
+<h4 id="DEP0004">DEP0004: <code>CryptoStream.prototype.readyState</code><span><a class="mark" href="#deprecations_dep0004_cryptostream_prototype_readystate" id="deprecations_dep0004_cryptostream_prototype_readystate">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>0.4.0</td>
+<tr><td>v0.4.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: End-of-Life</p>
 <p>The <code>CryptoStream.prototype.readyState</code> property was removed.</p>
-<p><a id="DEP0005"></a></p>
-<h3>DEP0005: <code>Buffer()</code> constructor<span><a class="mark" href="#deprecations_dep0005_buffer_constructor" id="deprecations_dep0005_buffer_constructor">#</a></span></h3>
+<h4 id="DEP0005">DEP0005: <code>Buffer()</code> constructor<span><a class="mark" href="#deprecations_dep0005_buffer_constructor" id="deprecations_dep0005_buffer_constructor">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -408,19 +430,18 @@ that copies <code>string</code>.</li>
 <code>node_modules</code>. This means there will not be deprecation warnings for
 <code>Buffer()</code> usage in dependencies. With <code>--pending-deprecation</code>, a runtime
 warning results no matter where the <code>Buffer()</code> usage occurs.</p>
-<p><a id="DEP0006"></a></p>
-<h3>DEP0006: <code>child_process</code> <code>options.customFds</code><span><a class="mark" href="#deprecations_dep0006_child_process_options_customfds" id="deprecations_dep0006_child_process_options_customfds">#</a></span></h3>
+<h4 id="DEP0006">DEP0006: <code>child_process</code> <code>options.customFds</code><span><a class="mark" href="#deprecations_dep0006_child_process_options_customfds" id="deprecations_dep0006_child_process_options_customfds">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.14</td>
 <td><p>Runtime deprecation.</p></td></tr>
-<tr><td>v0.5.11</td>
+<tr><td>v0.5.10</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -429,8 +450,7 @@ warning results no matter where the <code>Buffer()</code> usage occurs.</p>
 <p>Within the <a href="child_process.html"><code>child_process</code></a> module's <code>spawn()</code>, <code>fork()</code>, and <code>exec()</code>
 methods, the <code>options.customFds</code> option is deprecated. The <code>options.stdio</code>
 option should be used instead.</p>
-<p><a id="DEP0007"></a></p>
-<h3>DEP0007: Replace <code>cluster</code> <code>worker.suicide</code> with <code>worker.exitedAfterDisconnect</code><span><a class="mark" href="#deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect" id="deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect">#</a></span></h3>
+<h4 id="DEP0007">DEP0007: Replace <code>cluster</code> <code>worker.suicide</code> with <code>worker.exitedAfterDisconnect</code><span><a class="mark" href="#deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect" id="deprecations_dep0007_replace_cluster_worker_suicide_with_worker_exitedafterdisconnect">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -453,8 +473,7 @@ provide an indication of how and why the <code>Worker</code> instance exited. In
 6.0.0, the old property was deprecated and replaced with a new
 <a href="cluster.html#cluster_worker_exitedafterdisconnect"><code>worker.exitedAfterDisconnect</code></a> property. The old property name did not
 precisely describe the actual semantics and was unnecessarily emotion-laden.</p>
-<p><a id="DEP0008"></a></p>
-<h3>DEP0008: <code>require('constants')</code><span><a class="mark" href="#deprecations_dep0008_require_constants" id="deprecations_dep0008_require_constants">#</a></span></h3>
+<h4 id="DEP0008">DEP0008: <code>require('constants')</code><span><a class="mark" href="#deprecations_dep0008_require_constants" id="deprecations_dep0008_require_constants">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -471,12 +490,13 @@ precisely describe the actual semantics and was unnecessarily emotion-laden.</p>
 relevant to specific Node.js builtin modules, developers should instead refer
 to the <code>constants</code> property exposed by the relevant module. For instance,
 <code>require('fs').constants</code> and <code>require('os').constants</code>.</p>
-<p><a id="DEP0009"></a></p>
-<h3>DEP0009: <code>crypto.pbkdf2</code> without digest<span><a class="mark" href="#deprecations_dep0009_crypto_pbkdf2_without_digest" id="deprecations_dep0009_crypto_pbkdf2_without_digest">#</a></span></h3>
+<h4 id="DEP0009">DEP0009: <code>crypto.pbkdf2</code> without digest<span><a class="mark" href="#deprecations_dep0009_crypto_pbkdf2_without_digest" id="deprecations_dep0009_crypto_pbkdf2_without_digest">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life (for <code>digest === null</code>).</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>Runtime deprecation (for <code>digest === null</code>).</p></td></tr>
 <tr><td>v8.0.0</td>
@@ -488,24 +508,24 @@ to the <code>constants</code> property exposed by the relevant module. For insta
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
+<p>Type: End-of-Life</p>
 <p>Use of the <a href="crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback"><code>crypto.pbkdf2()</code></a> API without specifying a digest was deprecated
 in Node.js 6.0 because the method defaulted to using the non-recommended
 <code>'SHA1'</code> digest. Previously, a deprecation warning was printed. Starting in
 Node.js 8.0.0, calling <code>crypto.pbkdf2()</code> or <code>crypto.pbkdf2Sync()</code> with
 <code>digest</code> set to <code>undefined</code> will throw a <code>TypeError</code>.</p>
 <p>Beginning in Node.js v11.0.0, calling these functions with <code>digest</code> set to
-<code>null</code> will print a deprecation warning to align with the behavior when <code>digest</code>
+<code>null</code> would print a deprecation warning to align with the behavior when <code>digest</code>
 is <code>undefined</code>.</p>
-<p><a id="DEP0010"></a></p>
-<h3>DEP0010: <code>crypto.createCredentials</code><span><a class="mark" href="#deprecations_dep0010_crypto_createcredentials" id="deprecations_dep0010_crypto_createcredentials">#</a></span></h3>
+<p>Now, however, passing either <code>undefined</code> or <code>null</code> will throw a <code>TypeError</code>.</p>
+<h4 id="DEP0010">DEP0010: <code>crypto.createCredentials</code><span><a class="mark" href="#deprecations_dep0010_crypto_createcredentials" id="deprecations_dep0010_crypto_createcredentials">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v11.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.13</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -515,15 +535,14 @@ is <code>undefined</code>.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>crypto.createCredentials()</code> API was removed. Please use
 <a href="tls.html#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a> instead.</p>
-<p><a id="DEP0011"></a></p>
-<h3>DEP0011: <code>crypto.Credentials</code><span><a class="mark" href="#deprecations_dep0011_crypto_credentials" id="deprecations_dep0011_crypto_credentials">#</a></span></h3>
+<h4 id="DEP0011">DEP0011: <code>crypto.Credentials</code><span><a class="mark" href="#deprecations_dep0011_crypto_credentials" id="deprecations_dep0011_crypto_credentials">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v11.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.13</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -533,15 +552,14 @@ is <code>undefined</code>.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>crypto.Credentials</code> class was removed. Please use <a href="tls.html#tls_tls_createsecurecontext_options"><code>tls.SecureContext</code></a>
 instead.</p>
-<p><a id="DEP0012"></a></p>
-<h3>DEP0012: <code>Domain.dispose</code><span><a class="mark" href="#deprecations_dep0012_domain_dispose" id="deprecations_dep0012_domain_dispose">#</a></span></h3>
+<h4 id="DEP0012">DEP0012: <code>Domain.dispose</code><span><a class="mark" href="#deprecations_dep0012_domain_dispose" id="deprecations_dep0012_domain_dispose">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v9.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.7</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -551,8 +569,7 @@ instead.</p>
 <p>Type: End-of-Life</p>
 <p><code>Domain.dispose()</code> has been removed. Recover from failed I/O actions
 explicitly via error event handlers set on the domain instead.</p>
-<p><a id="DEP0013"></a></p>
-<h3>DEP0013: <code>fs</code> asynchronous function without callback<span><a class="mark" href="#deprecations_dep0013_fs_asynchronous_function_without_callback" id="deprecations_dep0013_fs_asynchronous_function_without_callback">#</a></span></h3>
+<h4 id="DEP0013">DEP0013: <code>fs</code> asynchronous function without callback<span><a class="mark" href="#deprecations_dep0013_fs_asynchronous_function_without_callback" id="deprecations_dep0013_fs_asynchronous_function_without_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -567,8 +584,7 @@ explicitly via error event handlers set on the domain instead.</p>
 <p>Type: End-of-Life</p>
 <p>Calling an asynchronous function without a callback throws a <code>TypeError</code>
 in Node.js 10.0.0 onwards. See <a href="https://github.com/nodejs/node/pull/12562">https://github.com/nodejs/node/pull/12562</a>.</p>
-<p><a id="DEP0014"></a></p>
-<h3>DEP0014: <code>fs.read</code> legacy String interface<span><a class="mark" href="#deprecations_dep0014_fs_read_legacy_string_interface" id="deprecations_dep0014_fs_read_legacy_string_interface">#</a></span></h3>
+<h4 id="DEP0014">DEP0014: <code>fs.read</code> legacy String interface<span><a class="mark" href="#deprecations_dep0014_fs_read_legacy_string_interface" id="deprecations_dep0014_fs_read_legacy_string_interface">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -577,7 +593,7 @@ in Node.js 10.0.0 onwards. See <a href="https://github.com/nodejs/node/pull/1256
 <td><p>End-of-Life.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.1.96</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -587,8 +603,7 @@ in Node.js 10.0.0 onwards. See <a href="https://github.com/nodejs/node/pull/1256
 <p>Type: End-of-Life</p>
 <p>The <a href="fs.html#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a> legacy <code>String</code> interface is deprecated. Use the <code>Buffer</code>
 API as mentioned in the documentation instead.</p>
-<p><a id="DEP0015"></a></p>
-<h3>DEP0015: <code>fs.readSync</code> legacy String interface<span><a class="mark" href="#deprecations_dep0015_fs_readsync_legacy_string_interface" id="deprecations_dep0015_fs_readsync_legacy_string_interface">#</a></span></h3>
+<h4 id="DEP0015">DEP0015: <code>fs.readSync</code> legacy String interface<span><a class="mark" href="#deprecations_dep0015_fs_readsync_legacy_string_interface" id="deprecations_dep0015_fs_readsync_legacy_string_interface">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -597,7 +612,7 @@ API as mentioned in the documentation instead.</p>
 <td><p>End-of-Life.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.1.96</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -607,12 +622,13 @@ API as mentioned in the documentation instead.</p>
 <p>Type: End-of-Life</p>
 <p>The <a href="fs.html#fs_fs_readsync_fd_buffer_offset_length_position"><code>fs.readSync()</code></a> legacy <code>String</code> interface is deprecated. Use the
 <code>Buffer</code> API as mentioned in the documentation instead.</p>
-<p><a id="DEP0016"></a></p>
-<h3>DEP0016: <code>GLOBAL</code>/<code>root</code><span><a class="mark" href="#deprecations_dep0016_global_root" id="deprecations_dep0016_global_root">#</a></span></h3>
+<h4 id="DEP0016">DEP0016: <code>GLOBAL</code>/<code>root</code><span><a class="mark" href="#deprecations_dep0016_global_root" id="deprecations_dep0016_global_root">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
 <tr><td>v6.12.0</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v6.0.0</td>
@@ -620,11 +636,10 @@ API as mentioned in the documentation instead.</p>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
-<p>The <code>GLOBAL</code> and <code>root</code> aliases for the <code>global</code> property are deprecated
-and should no longer be used.</p>
-<p><a id="DEP0017"></a></p>
-<h3>DEP0017: <code>Intl.v8BreakIterator</code><span><a class="mark" href="#deprecations_dep0017_intl_v8breakiterator" id="deprecations_dep0017_intl_v8breakiterator">#</a></span></h3>
+<p>Type: End-of-Life</p>
+<p>The <code>GLOBAL</code> and <code>root</code> aliases for the <code>global</code> property were deprecated
+in Node.js 6.0.0 and have since been removed.</p>
+<h4 id="DEP0017">DEP0017: <code>Intl.v8BreakIterator</code><span><a class="mark" href="#deprecations_dep0017_intl_v8breakiterator" id="deprecations_dep0017_intl_v8breakiterator">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -639,8 +654,7 @@ and should no longer be used.</p>
 <p>Type: End-of-Life</p>
 <p><code>Intl.v8BreakIterator</code> was a non-standard extension and has been removed.
 See <a href="https://github.com/tc39/proposal-intl-segmenter"><code>Intl.Segmenter</code></a>.</p>
-<p><a id="DEP0018"></a></p>
-<h3>DEP0018: Unhandled promise rejections<span><a class="mark" href="#deprecations_dep0018_unhandled_promise_rejections" id="deprecations_dep0018_unhandled_promise_rejections">#</a></span></h3>
+<h4 id="DEP0018">DEP0018: Unhandled promise rejections<span><a class="mark" href="#deprecations_dep0018_unhandled_promise_rejections" id="deprecations_dep0018_unhandled_promise_rejections">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -654,15 +668,14 @@ See <a href="https://github.com/tc39/proposal-intl-segmenter"><code>Intl.Segment
 <p>Unhandled promise rejections are deprecated. In the future, promise rejections
 that are not handled will terminate the Node.js process with a non-zero exit
 code.</p>
-<p><a id="DEP0019"></a></p>
-<h3>DEP0019: <code>require('.')</code> resolved outside directory<span><a class="mark" href="#deprecations_dep0019_require_resolved_outside_directory" id="deprecations_dep0019_require_resolved_outside_directory">#</a></span></h3>
+<h4 id="DEP0019">DEP0019: <code>require('.')</code> resolved outside directory<span><a class="mark" href="#deprecations_dep0019_require_resolved_outside_directory" id="deprecations_dep0019_require_resolved_outside_directory">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>Removed functionality.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.8.1</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -672,13 +685,12 @@ code.</p>
 <p>Type: End-of-Life</p>
 <p>In certain cases, <code>require('.')</code> could resolve outside the package directory.
 This behavior has been removed.</p>
-<p><a id="DEP0020"></a></p>
-<h3>DEP0020: <code>Server.connections</code><span><a class="mark" href="#deprecations_dep0020_server_connections" id="deprecations_dep0020_server_connections">#</a></span></h3>
+<h4 id="DEP0020">DEP0020: <code>Server.connections</code><span><a class="mark" href="#deprecations_dep0020_server_connections" id="deprecations_dep0020_server_connections">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.9.7</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -688,15 +700,14 @@ This behavior has been removed.</p>
 <p>Type: Runtime</p>
 <p>The <a href="net.html#net_server_connections"><code>Server.connections</code></a> property is deprecated. Please use the
 <a href="net.html#net_server_getconnections_callback"><code>Server.getConnections()</code></a> method instead.</p>
-<p><a id="DEP0021"></a></p>
-<h3>DEP0021: <code>Server.listenFD</code><span><a class="mark" href="#deprecations_dep0021_server_listenfd" id="deprecations_dep0021_server_listenfd">#</a></span></h3>
+<h4 id="DEP0021">DEP0021: <code>Server.listenFD</code><span><a class="mark" href="#deprecations_dep0021_server_listenfd" id="deprecations_dep0021_server_listenfd">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.7.12</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -706,28 +717,29 @@ This behavior has been removed.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>Server.listenFD()</code> method was deprecated and removed. Please use
 <a href="net.html#net_server_listen_handle_backlog_callback"><code>Server.listen({fd: &#x3C;number>})</code></a> instead.</p>
-<p><a id="DEP0022"></a></p>
-<h3>DEP0022: <code>os.tmpDir()</code><span><a class="mark" href="#deprecations_dep0022_os_tmpdir" id="deprecations_dep0022_os_tmpdir">#</a></span></h3>
+<h4 id="DEP0022">DEP0022: <code>os.tmpDir()</code><span><a class="mark" href="#deprecations_dep0022_os_tmpdir" id="deprecations_dep0022_os_tmpdir">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
-<p>The <code>os.tmpDir()</code> API is deprecated. Please use <a href="os.html#os_os_tmpdir"><code>os.tmpdir()</code></a> instead.</p>
-<p><a id="DEP0023"></a></p>
-<h3>DEP0023: <code>os.getNetworkInterfaces()</code><span><a class="mark" href="#deprecations_dep0023_os_getnetworkinterfaces" id="deprecations_dep0023_os_getnetworkinterfaces">#</a></span></h3>
+<p>Type: End-of-Life</p>
+<p>The <code>os.tmpDir()</code> API was deprecated in Node.js 7.0.0 and has since been
+removed. Please use <a href="os.html#os_os_tmpdir"><code>os.tmpdir()</code></a> instead.</p>
+<h4 id="DEP0023">DEP0023: <code>os.getNetworkInterfaces()</code><span><a class="mark" href="#deprecations_dep0023_os_getnetworkinterfaces" id="deprecations_dep0023_os_getnetworkinterfaces">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.6.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -737,8 +749,7 @@ This behavior has been removed.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>os.getNetworkInterfaces()</code> method is deprecated. Please use the
 <a href="os.html#os_os_networkinterfaces"><code>os.networkInterfaces()</code></a> method instead.</p>
-<p><a id="DEP0024"></a></p>
-<h3>DEP0024: <code>REPLServer.prototype.convertToContext()</code><span><a class="mark" href="#deprecations_dep0024_replserver_prototype_converttocontext" id="deprecations_dep0024_replserver_prototype_converttocontext">#</a></span></h3>
+<h4 id="DEP0024">DEP0024: <code>REPLServer.prototype.convertToContext()</code><span><a class="mark" href="#deprecations_dep0024_replserver_prototype_converttocontext" id="deprecations_dep0024_replserver_prototype_converttocontext">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -752,13 +763,12 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p>The <code>REPLServer.prototype.convertToContext()</code> API has been removed.</p>
-<p><a id="DEP0025"></a></p>
-<h3>DEP0025: <code>require('sys')</code><span><a class="mark" href="#deprecations_dep0025_require_sys" id="deprecations_dep0025_require_sys">#</a></span></h3>
+<h4 id="DEP0025">DEP0025: <code>require('sys')</code><span><a class="mark" href="#deprecations_dep0025_require_sys" id="deprecations_dep0025_require_sys">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.0.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -767,15 +777,14 @@ This behavior has been removed.</p>
 </div>
 <p>Type: Runtime</p>
 <p>The <code>sys</code> module is deprecated. Please use the <a href="util.html"><code>util</code></a> module instead.</p>
-<p><a id="DEP0026"></a></p>
-<h3>DEP0026: <code>util.print()</code><span><a class="mark" href="#deprecations_dep0026_util_print" id="deprecations_dep0026_util_print">#</a></span></h3>
+<h4 id="DEP0026">DEP0026: <code>util.print()</code><span><a class="mark" href="#deprecations_dep0026_util_print" id="deprecations_dep0026_util_print">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -784,15 +793,14 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p><code>util.print()</code> has been removed. Please use <a href="console.html#console_console_log_data_args"><code>console.log()</code></a> instead.</p>
-<p><a id="DEP0027"></a></p>
-<h3>DEP0027: <code>util.puts()</code><span><a class="mark" href="#deprecations_dep0027_util_puts" id="deprecations_dep0027_util_puts">#</a></span></h3>
+<h4 id="DEP0027">DEP0027: <code>util.puts()</code><span><a class="mark" href="#deprecations_dep0027_util_puts" id="deprecations_dep0027_util_puts">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -801,15 +809,14 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p><code>util.puts()</code> has been removed. Please use <a href="console.html#console_console_log_data_args"><code>console.log()</code></a> instead.</p>
-<p><a id="DEP0028"></a></p>
-<h3>DEP0028: <code>util.debug()</code><span><a class="mark" href="#deprecations_dep0028_util_debug" id="deprecations_dep0028_util_debug">#</a></span></h3>
+<h4 id="DEP0028">DEP0028: <code>util.debug()</code><span><a class="mark" href="#deprecations_dep0028_util_debug" id="deprecations_dep0028_util_debug">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -818,15 +825,14 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p><code>util.debug()</code> has been removed. Please use <a href="console.html#console_console_error_data_args"><code>console.error()</code></a> instead.</p>
-<p><a id="DEP0029"></a></p>
-<h3>DEP0029: <code>util.error()</code><span><a class="mark" href="#deprecations_dep0029_util_error" id="deprecations_dep0029_util_error">#</a></span></h3>
+<h4 id="DEP0029">DEP0029: <code>util.error()</code><span><a class="mark" href="#deprecations_dep0029_util_error" id="deprecations_dep0029_util_error">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Runtime deprecation.</p></td></tr>
@@ -835,8 +841,7 @@ This behavior has been removed.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p><code>util.error()</code> has been removed. Please use <a href="console.html#console_console_error_data_args"><code>console.error()</code></a> instead.</p>
-<p><a id="DEP0030"></a></p>
-<h3>DEP0030: <code>SlowBuffer</code><span><a class="mark" href="#deprecations_dep0030_slowbuffer" id="deprecations_dep0030_slowbuffer">#</a></span></h3>
+<h4 id="DEP0030">DEP0030: <code>SlowBuffer</code><span><a class="mark" href="#deprecations_dep0030_slowbuffer" id="deprecations_dep0030_slowbuffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -851,8 +856,7 @@ This behavior has been removed.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="buffer.html#buffer_class_slowbuffer"><code>SlowBuffer</code></a> class is deprecated. Please use
 <a href="buffer.html#buffer_static_method_buffer_allocunsafeslow_size"><code>Buffer.allocUnsafeSlow(size)</code></a> instead.</p>
-<p><a id="DEP0031"></a></p>
-<h3>DEP0031: <code>ecdh.setPublicKey()</code><span><a class="mark" href="#deprecations_dep0031_ecdh_setpublickey" id="deprecations_dep0031_ecdh_setpublickey">#</a></span></h3>
+<h4 id="DEP0031">DEP0031: <code>ecdh.setPublicKey()</code><span><a class="mark" href="#deprecations_dep0031_ecdh_setpublickey" id="deprecations_dep0031_ecdh_setpublickey">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -867,13 +871,12 @@ This behavior has been removed.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="crypto.html#crypto_ecdh_setpublickey_publickey_encoding"><code>ecdh.setPublicKey()</code></a> method is now deprecated as its inclusion in the
 API is not useful.</p>
-<p><a id="DEP0032"></a></p>
-<h3>DEP0032: <code>domain</code> module<span><a class="mark" href="#deprecations_dep0032_domain_module" id="deprecations_dep0032_domain_module">#</a></span></h3>
+<h4 id="DEP0032">DEP0032: <code>domain</code> module<span><a class="mark" href="#deprecations_dep0032_domain_module" id="deprecations_dep0032_domain_module">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.4.2</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -882,13 +885,12 @@ API is not useful.</p>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="domain.html"><code>domain</code></a> module is deprecated and should not be used.</p>
-<p><a id="DEP0033"></a></p>
-<h3>DEP0033: <code>EventEmitter.listenerCount()</code><span><a class="mark" href="#deprecations_dep0033_eventemitter_listenercount" id="deprecations_dep0033_eventemitter_listenercount">#</a></span></h3>
+<h4 id="DEP0033">DEP0033: <code>EventEmitter.listenerCount()</code><span><a class="mark" href="#deprecations_dep0033_eventemitter_listenercount" id="deprecations_dep0033_eventemitter_listenercount">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v3.2.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -896,15 +898,14 @@ API is not useful.</p>
 </details>
 </div>
 <p>Type: Documentation-only</p>
-<p>The <a href="events.html#events_eventemitter_listenercount_emitter_eventname"><code>EventEmitter.listenerCount(emitter, eventName)</code></a> API is
+<p>The <a href="events.html#events_events_listenercount_emitter_eventname"><code>events.listenerCount(emitter, eventName)</code></a> API is
 deprecated. Please use <a href="events.html#events_emitter_listenercount_eventname"><code>emitter.listenerCount(eventName)</code></a> instead.</p>
-<p><a id="DEP0034"></a></p>
-<h3>DEP0034: <code>fs.exists(path, callback)</code><span><a class="mark" href="#deprecations_dep0034_fs_exists_path_callback" id="deprecations_dep0034_fs_exists_path_callback">#</a></span></h3>
+<h4 id="DEP0034">DEP0034: <code>fs.exists(path, callback)</code><span><a class="mark" href="#deprecations_dep0034_fs_exists_path_callback" id="deprecations_dep0034_fs_exists_path_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v1.0.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -914,13 +915,12 @@ deprecated. Please use <a href="events.html#events_emitter_listenercount_eventna
 <p>Type: Documentation-only</p>
 <p>The <a href="fs.html#fs_fs_exists_path_callback"><code>fs.exists(path, callback)</code></a> API is deprecated. Please use
 <a href="fs.html#fs_fs_stat_path_options_callback"><code>fs.stat()</code></a> or <a href="fs.html#fs_fs_access_path_mode_callback"><code>fs.access()</code></a> instead.</p>
-<p><a id="DEP0035"></a></p>
-<h3>DEP0035: <code>fs.lchmod(path, mode, callback)</code><span><a class="mark" href="#deprecations_dep0035_fs_lchmod_path_mode_callback" id="deprecations_dep0035_fs_lchmod_path_mode_callback">#</a></span></h3>
+<h4 id="DEP0035">DEP0035: <code>fs.lchmod(path, mode, callback)</code><span><a class="mark" href="#deprecations_dep0035_fs_lchmod_path_mode_callback" id="deprecations_dep0035_fs_lchmod_path_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.4.7</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -929,13 +929,12 @@ deprecated. Please use <a href="events.html#events_emitter_listenercount_eventna
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="fs.html#fs_fs_lchmod_path_mode_callback"><code>fs.lchmod(path, mode, callback)</code></a> API is deprecated.</p>
-<p><a id="DEP0036"></a></p>
-<h3>DEP0036: <code>fs.lchmodSync(path, mode)</code><span><a class="mark" href="#deprecations_dep0036_fs_lchmodsync_path_mode" id="deprecations_dep0036_fs_lchmodsync_path_mode">#</a></span></h3>
+<h4 id="DEP0036">DEP0036: <code>fs.lchmodSync(path, mode)</code><span><a class="mark" href="#deprecations_dep0036_fs_lchmodsync_path_mode" id="deprecations_dep0036_fs_lchmodsync_path_mode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.4.7</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -944,15 +943,14 @@ deprecated. Please use <a href="events.html#events_emitter_listenercount_eventna
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="fs.html#fs_fs_lchmodsync_path_mode"><code>fs.lchmodSync(path, mode)</code></a> API is deprecated.</p>
-<p><a id="DEP0037"></a></p>
-<h3>DEP0037: <code>fs.lchown(path, uid, gid, callback)</code><span><a class="mark" href="#deprecations_dep0037_fs_lchown_path_uid_gid_callback" id="deprecations_dep0037_fs_lchown_path_uid_gid_callback">#</a></span></h3>
+<h4 id="DEP0037">DEP0037: <code>fs.lchown(path, uid, gid, callback)</code><span><a class="mark" href="#deprecations_dep0037_fs_lchown_path_uid_gid_callback" id="deprecations_dep0037_fs_lchown_path_uid_gid_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.6.0</td>
 <td><p>Deprecation revoked.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.4.7</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -963,15 +961,14 @@ deprecated. Please use <a href="events.html#events_emitter_listenercount_eventna
 <p>The <a href="fs.html#fs_fs_lchown_path_uid_gid_callback"><code>fs.lchown(path, uid, gid, callback)</code></a> API was deprecated. The
 deprecation was revoked because the requisite supporting APIs were added in
 libuv.</p>
-<p><a id="DEP0038"></a></p>
-<h3>DEP0038: <code>fs.lchownSync(path, uid, gid)</code><span><a class="mark" href="#deprecations_dep0038_fs_lchownsync_path_uid_gid" id="deprecations_dep0038_fs_lchownsync_path_uid_gid">#</a></span></h3>
+<h4 id="DEP0038">DEP0038: <code>fs.lchownSync(path, uid, gid)</code><span><a class="mark" href="#deprecations_dep0038_fs_lchownsync_path_uid_gid" id="deprecations_dep0038_fs_lchownsync_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.6.0</td>
 <td><p>Deprecation revoked.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.4.7</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -981,13 +978,12 @@ libuv.</p>
 <p>Type: Deprecation revoked</p>
 <p>The <a href="fs.html#fs_fs_lchownsync_path_uid_gid"><code>fs.lchownSync(path, uid, gid)</code></a> API was deprecated. The deprecation was
 revoked because the requisite supporting APIs were added in libuv.</p>
-<p><a id="DEP0039"></a></p>
-<h3>DEP0039: <code>require.extensions</code><span><a class="mark" href="#deprecations_dep0039_require_extensions" id="deprecations_dep0039_require_extensions">#</a></span></h3>
+<h4 id="DEP0039">DEP0039: <code>require.extensions</code><span><a class="mark" href="#deprecations_dep0039_require_extensions" id="deprecations_dep0039_require_extensions">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.10.6</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -996,8 +992,7 @@ revoked because the requisite supporting APIs were added in libuv.</p>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="modules.html#modules_require_extensions"><code>require.extensions</code></a> property is deprecated.</p>
-<p><a id="DEP0040"></a></p>
-<h3>DEP0040: <code>punycode</code> module<span><a class="mark" href="#deprecations_dep0040_punycode_module" id="deprecations_dep0040_punycode_module">#</a></span></h3>
+<h4 id="DEP0040">DEP0040: <code>punycode</code> module<span><a class="mark" href="#deprecations_dep0040_punycode_module" id="deprecations_dep0040_punycode_module">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1010,15 +1005,14 @@ revoked because the requisite supporting APIs were added in libuv.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="punycode.html"><code>punycode</code></a> module is deprecated. Please use a userland alternative
 instead.</p>
-<p><a id="DEP0041"></a></p>
-<h3>DEP0041: <code>NODE_REPL_HISTORY_FILE</code> environment variable<span><a class="mark" href="#deprecations_dep0041_node_repl_history_file_environment_variable" id="deprecations_dep0041_node_repl_history_file_environment_variable">#</a></span></h3>
+<h4 id="DEP0041">DEP0041: <code>NODE_REPL_HISTORY_FILE</code> environment variable<span><a class="mark" href="#deprecations_dep0041_node_repl_history_file_environment_variable" id="deprecations_dep0041_node_repl_history_file_environment_variable">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v3.0.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -1028,15 +1022,14 @@ instead.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>NODE_REPL_HISTORY_FILE</code> environment variable was removed. Please use
 <code>NODE_REPL_HISTORY</code> instead.</p>
-<p><a id="DEP0042"></a></p>
-<h3>DEP0042: <code>tls.CryptoStream</code><span><a class="mark" href="#deprecations_dep0042_tls_cryptostream" id="deprecations_dep0042_tls_cryptostream">#</a></span></h3>
+<h4 id="DEP0042">DEP0042: <code>tls.CryptoStream</code><span><a class="mark" href="#deprecations_dep0042_tls_cryptostream" id="deprecations_dep0042_tls_cryptostream">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
@@ -1046,8 +1039,7 @@ instead.</p>
 <p>Type: End-of-Life</p>
 <p>The <a href="tls.html#tls_class_tls_cryptostream"><code>tls.CryptoStream</code></a> class was removed. Please use
 <a href="tls.html#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> instead.</p>
-<p><a id="DEP0043"></a></p>
-<h3>DEP0043: <code>tls.SecurePair</code><span><a class="mark" href="#deprecations_dep0043_tls_securepair" id="deprecations_dep0043_tls_securepair">#</a></span></h3>
+<h4 id="DEP0043">DEP0043: <code>tls.SecurePair</code><span><a class="mark" href="#deprecations_dep0043_tls_securepair" id="deprecations_dep0043_tls_securepair">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1068,15 +1060,14 @@ instead.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="tls.html#tls_class_tls_securepair"><code>tls.SecurePair</code></a> class is deprecated. Please use
 <a href="tls.html#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> instead.</p>
-<p><a id="DEP0044"></a></p>
-<h3>DEP0044: <code>util.isArray()</code><span><a class="mark" href="#deprecations_dep0044_util_isarray" id="deprecations_dep0044_util_isarray">#</a></span></h3>
+<h4 id="DEP0044">DEP0044: <code>util.isArray()</code><span><a class="mark" href="#deprecations_dep0044_util_isarray" id="deprecations_dep0044_util_isarray">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -1084,30 +1075,28 @@ instead.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isarray_object"><code>util.isArray()</code></a> API is deprecated. Please use <code>Array.isArray()</code>
 instead.</p>
-<p><a id="DEP0045"></a></p>
-<h3>DEP0045: <code>util.isBoolean()</code><span><a class="mark" href="#deprecations_dep0045_util_isboolean" id="deprecations_dep0045_util_isboolean">#</a></span></h3>
+<h4 id="DEP0045">DEP0045: <code>util.isBoolean()</code><span><a class="mark" href="#deprecations_dep0045_util_isboolean" id="deprecations_dep0045_util_isboolean">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isboolean_object"><code>util.isBoolean()</code></a> API is deprecated.</p>
-<p><a id="DEP0046"></a></p>
-<h3>DEP0046: <code>util.isBuffer()</code><span><a class="mark" href="#deprecations_dep0046_util_isbuffer" id="deprecations_dep0046_util_isbuffer">#</a></span></h3>
+<h4 id="DEP0046">DEP0046: <code>util.isBuffer()</code><span><a class="mark" href="#deprecations_dep0046_util_isbuffer" id="deprecations_dep0046_util_isbuffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -1115,188 +1104,175 @@ instead.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isbuffer_object"><code>util.isBuffer()</code></a> API is deprecated. Please use
 <a href="buffer.html#buffer_static_method_buffer_isbuffer_obj"><code>Buffer.isBuffer()</code></a> instead.</p>
-<p><a id="DEP0047"></a></p>
-<h3>DEP0047: <code>util.isDate()</code><span><a class="mark" href="#deprecations_dep0047_util_isdate" id="deprecations_dep0047_util_isdate">#</a></span></h3>
+<h4 id="DEP0047">DEP0047: <code>util.isDate()</code><span><a class="mark" href="#deprecations_dep0047_util_isdate" id="deprecations_dep0047_util_isdate">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isdate_object"><code>util.isDate()</code></a> API is deprecated.</p>
-<p><a id="DEP0048"></a></p>
-<h3>DEP0048: <code>util.isError()</code><span><a class="mark" href="#deprecations_dep0048_util_iserror" id="deprecations_dep0048_util_iserror">#</a></span></h3>
+<h4 id="DEP0048">DEP0048: <code>util.isError()</code><span><a class="mark" href="#deprecations_dep0048_util_iserror" id="deprecations_dep0048_util_iserror">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_iserror_object"><code>util.isError()</code></a> API is deprecated.</p>
-<p><a id="DEP0049"></a></p>
-<h3>DEP0049: <code>util.isFunction()</code><span><a class="mark" href="#deprecations_dep0049_util_isfunction" id="deprecations_dep0049_util_isfunction">#</a></span></h3>
+<h4 id="DEP0049">DEP0049: <code>util.isFunction()</code><span><a class="mark" href="#deprecations_dep0049_util_isfunction" id="deprecations_dep0049_util_isfunction">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isfunction_object"><code>util.isFunction()</code></a> API is deprecated.</p>
-<p><a id="DEP0050"></a></p>
-<h3>DEP0050: <code>util.isNull()</code><span><a class="mark" href="#deprecations_dep0050_util_isnull" id="deprecations_dep0050_util_isnull">#</a></span></h3>
+<h4 id="DEP0050">DEP0050: <code>util.isNull()</code><span><a class="mark" href="#deprecations_dep0050_util_isnull" id="deprecations_dep0050_util_isnull">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isnull_object"><code>util.isNull()</code></a> API is deprecated.</p>
-<p><a id="DEP0051"></a></p>
-<h3>DEP0051: <code>util.isNullOrUndefined()</code><span><a class="mark" href="#deprecations_dep0051_util_isnullorundefined" id="deprecations_dep0051_util_isnullorundefined">#</a></span></h3>
+<h4 id="DEP0051">DEP0051: <code>util.isNullOrUndefined()</code><span><a class="mark" href="#deprecations_dep0051_util_isnullorundefined" id="deprecations_dep0051_util_isnullorundefined">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isnullorundefined_object"><code>util.isNullOrUndefined()</code></a> API is deprecated.</p>
-<p><a id="DEP0052"></a></p>
-<h3>DEP0052: <code>util.isNumber()</code><span><a class="mark" href="#deprecations_dep0052_util_isnumber" id="deprecations_dep0052_util_isnumber">#</a></span></h3>
+<h4 id="DEP0052">DEP0052: <code>util.isNumber()</code><span><a class="mark" href="#deprecations_dep0052_util_isnumber" id="deprecations_dep0052_util_isnumber">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isnumber_object"><code>util.isNumber()</code></a> API is deprecated.</p>
-<p><a id="DEP0053"></a></p>
-<h3>DEP0053 <code>util.isObject()</code><span><a class="mark" href="#deprecations_dep0053_util_isobject" id="deprecations_dep0053_util_isobject">#</a></span></h3>
+<h4 id="DEP0053">DEP0053: <code>util.isObject()</code><span><a class="mark" href="#deprecations_dep0053_util_isobject" id="deprecations_dep0053_util_isobject">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isobject_object"><code>util.isObject()</code></a> API is deprecated.</p>
-<p><a id="DEP0054"></a></p>
-<h3>DEP0054: <code>util.isPrimitive()</code><span><a class="mark" href="#deprecations_dep0054_util_isprimitive" id="deprecations_dep0054_util_isprimitive">#</a></span></h3>
+<h4 id="DEP0054">DEP0054: <code>util.isPrimitive()</code><span><a class="mark" href="#deprecations_dep0054_util_isprimitive" id="deprecations_dep0054_util_isprimitive">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isprimitive_object"><code>util.isPrimitive()</code></a> API is deprecated.</p>
-<p><a id="DEP0055"></a></p>
-<h3>DEP0055: <code>util.isRegExp()</code><span><a class="mark" href="#deprecations_dep0055_util_isregexp" id="deprecations_dep0055_util_isregexp">#</a></span></h3>
+<h4 id="DEP0055">DEP0055: <code>util.isRegExp()</code><span><a class="mark" href="#deprecations_dep0055_util_isregexp" id="deprecations_dep0055_util_isregexp">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isregexp_object"><code>util.isRegExp()</code></a> API is deprecated.</p>
-<p><a id="DEP0056"></a></p>
-<h3>DEP0056: <code>util.isString()</code><span><a class="mark" href="#deprecations_dep0056_util_isstring" id="deprecations_dep0056_util_isstring">#</a></span></h3>
+<h4 id="DEP0056">DEP0056: <code>util.isString()</code><span><a class="mark" href="#deprecations_dep0056_util_isstring" id="deprecations_dep0056_util_isstring">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isstring_object"><code>util.isString()</code></a> API is deprecated.</p>
-<p><a id="DEP0057"></a></p>
-<h3>DEP0057: <code>util.isSymbol()</code><span><a class="mark" href="#deprecations_dep0057_util_issymbol" id="deprecations_dep0057_util_issymbol">#</a></span></h3>
+<h4 id="DEP0057">DEP0057: <code>util.isSymbol()</code><span><a class="mark" href="#deprecations_dep0057_util_issymbol" id="deprecations_dep0057_util_issymbol">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_issymbol_object"><code>util.isSymbol()</code></a> API is deprecated.</p>
-<p><a id="DEP0058"></a></p>
-<h3>DEP0058: <code>util.isUndefined()</code><span><a class="mark" href="#deprecations_dep0058_util_isundefined" id="deprecations_dep0058_util_isundefined">#</a></span></h3>
+<h4 id="DEP0058">DEP0058: <code>util.isUndefined()</code><span><a class="mark" href="#deprecations_dep0058_util_isundefined" id="deprecations_dep0058_util_isundefined">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.8.6, v6.12.0</td>
+<tr><td>v6.12.0, v4.8.6</td>
 <td><p>A deprecation code has been assigned.</p></td></tr>
-<tr><td>v3.3.1, v4.0.0</td>
+<tr><td>v4.0.0, v3.3.1</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_isundefined_object"><code>util.isUndefined()</code></a> API is deprecated.</p>
-<p><a id="DEP0059"></a></p>
-<h3>DEP0059: <code>util.log()</code><span><a class="mark" href="#deprecations_dep0059_util_log" id="deprecations_dep0059_util_log">#</a></span></h3>
+<h4 id="DEP0059">DEP0059: <code>util.log()</code><span><a class="mark" href="#deprecations_dep0059_util_log" id="deprecations_dep0059_util_log">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1310,8 +1286,7 @@ instead.</p>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_log_string"><code>util.log()</code></a> API is deprecated.</p>
-<p><a id="DEP0060"></a></p>
-<h3>DEP0060: <code>util._extend()</code><span><a class="mark" href="#deprecations_dep0060_util_extend" id="deprecations_dep0060_util_extend">#</a></span></h3>
+<h4 id="DEP0060">DEP0060: <code>util._extend()</code><span><a class="mark" href="#deprecations_dep0060_util_extend" id="deprecations_dep0060_util_extend">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1325,8 +1300,7 @@ instead.</p>
 </div>
 <p>Type: Documentation-only</p>
 <p>The <a href="util.html#util_util_extend_target_source"><code>util._extend()</code></a> API is deprecated.</p>
-<p><a id="DEP0061"></a></p>
-<h3>DEP0061: <code>fs.SyncWriteStream</code><span><a class="mark" href="#deprecations_dep0061_fs_syncwritestream" id="deprecations_dep0061_fs_syncwritestream">#</a></span></h3>
+<h4 id="DEP0061">DEP0061: <code>fs.SyncWriteStream</code><span><a class="mark" href="#deprecations_dep0061_fs_syncwritestream" id="deprecations_dep0061_fs_syncwritestream">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1344,8 +1318,7 @@ instead.</p>
 <p>The <code>fs.SyncWriteStream</code> class was never intended to be a publicly accessible
 API and has been removed. No alternative API is available. Please use a userland
 alternative.</p>
-<p><a id="DEP0062"></a></p>
-<h3>DEP0062: <code>node --debug</code><span><a class="mark" href="#deprecations_dep0062_node_debug" id="deprecations_dep0062_node_debug">#</a></span></h3>
+<h4 id="DEP0062">DEP0062: <code>node --debug</code><span><a class="mark" href="#deprecations_dep0062_node_debug" id="deprecations_dep0062_node_debug">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1361,8 +1334,7 @@ alternative.</p>
 <p><code>--debug</code> activates the legacy V8 debugger interface, which was removed as
 of V8 5.8. It is replaced by Inspector which is activated with <code>--inspect</code>
 instead.</p>
-<p><a id="DEP0063"></a></p>
-<h3>DEP0063: <code>ServerResponse.prototype.writeHeader()</code><span><a class="mark" href="#deprecations_dep0063_serverresponse_prototype_writeheader" id="deprecations_dep0063_serverresponse_prototype_writeheader">#</a></span></h3>
+<h4 id="DEP0063">DEP0063: <code>ServerResponse.prototype.writeHeader()</code><span><a class="mark" href="#deprecations_dep0063_serverresponse_prototype_writeheader" id="deprecations_dep0063_serverresponse_prototype_writeheader">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1377,8 +1349,7 @@ instead.</p>
 deprecated. Please use <code>ServerResponse.prototype.writeHead()</code> instead.</p>
 <p>The <code>ServerResponse.prototype.writeHeader()</code> method was never documented as an
 officially supported API.</p>
-<p><a id="DEP0064"></a></p>
-<h3>DEP0064: <code>tls.createSecurePair()</code><span><a class="mark" href="#deprecations_dep0064_tls_createsecurepair" id="deprecations_dep0064_tls_createsecurepair">#</a></span></h3>
+<h4 id="DEP0064">DEP0064: <code>tls.createSecurePair()</code><span><a class="mark" href="#deprecations_dep0064_tls_createsecurepair" id="deprecations_dep0064_tls_createsecurepair">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1399,8 +1370,7 @@ officially supported API.</p>
 <p>Type: Runtime</p>
 <p>The <code>tls.createSecurePair()</code> API was deprecated in documentation in Node.js
 0.11.3. Users should use <code>tls.Socket</code> instead.</p>
-<p><a id="DEP0065"></a></p>
-<h3>DEP0065: <code>repl.REPL_MODE_MAGIC</code> and <code>NODE_REPL_MODE=magic</code><span><a class="mark" href="#deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic" id="deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic">#</a></span></h3>
+<h4 id="DEP0065">DEP0065: <code>repl.REPL_MODE_MAGIC</code> and <code>NODE_REPL_MODE=magic</code><span><a class="mark" href="#deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic" id="deprecations_dep0065_repl_repl_mode_magic_and_node_repl_mode_magic">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1420,8 +1390,7 @@ been removed. Its behavior has been functionally identical to that of
 <p>The <code>NODE_REPL_MODE</code> environment variable is used to set the underlying
 <code>replMode</code> of an interactive <code>node</code> session. Its value, <code>magic</code>, is also
 removed. Please use <code>sloppy</code> instead.</p>
-<p><a id="DEP0066"></a></p>
-<h3>DEP0066: <code>OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames</code><span><a class="mark" href="#deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames" id="deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames">#</a></span></h3>
+<h4 id="DEP0066">DEP0066: <code>OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames</code><span><a class="mark" href="#deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames" id="deprecations_dep0066_outgoingmessage_prototype_headers_outgoingmessage_prototype_headernames">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1439,14 +1408,14 @@ removed. Please use <code>sloppy</code> instead.</p>
 the public methods (e.g. <code>OutgoingMessage.prototype.getHeader()</code>,
 <code>OutgoingMessage.prototype.getHeaders()</code>,
 <code>OutgoingMessage.prototype.getHeaderNames()</code>,
+<code>OutgoingMessage.prototype.getRawHeaderNames()</code>,
 <code>OutgoingMessage.prototype.hasHeader()</code>,
 <code>OutgoingMessage.prototype.removeHeader()</code>,
 <code>OutgoingMessage.prototype.setHeader()</code>) for working with outgoing headers.</p>
 <p>The <code>OutgoingMessage.prototype._headers</code> and
 <code>OutgoingMessage.prototype._headerNames</code> properties were never documented as
 officially supported properties.</p>
-<p><a id="DEP0067"></a></p>
-<h3>DEP0067: <code>OutgoingMessage.prototype._renderHeaders</code><span><a class="mark" href="#deprecations_dep0067_outgoingmessage_prototype_renderheaders" id="deprecations_dep0067_outgoingmessage_prototype_renderheaders">#</a></span></h3>
+<h4 id="DEP0067">DEP0067: <code>OutgoingMessage.prototype._renderHeaders</code><span><a class="mark" href="#deprecations_dep0067_outgoingmessage_prototype_renderheaders" id="deprecations_dep0067_outgoingmessage_prototype_renderheaders">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1461,8 +1430,7 @@ officially supported properties.</p>
 deprecated.</p>
 <p>The <code>OutgoingMessage.prototype._renderHeaders</code> property was never documented as
 an officially supported API.</p>
-<p><a id="DEP0068"></a></p>
-<h3>DEP0068: <code>node debug</code><span><a class="mark" href="#deprecations_dep0068_node_debug" id="deprecations_dep0068_node_debug">#</a></span></h3>
+<h4 id="DEP0068">DEP0068: <code>node debug</code><span><a class="mark" href="#deprecations_dep0068_node_debug" id="deprecations_dep0068_node_debug">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1475,8 +1443,7 @@ an officially supported API.</p>
 <p>Type: Runtime</p>
 <p><code>node debug</code> corresponds to the legacy CLI debugger which has been replaced with
 a V8-inspector based CLI debugger available through <code>node inspect</code>.</p>
-<p><a id="DEP0069"></a></p>
-<h3>DEP0069: <code>vm.runInDebugContext(string)</code><span><a class="mark" href="#deprecations_dep0069_vm_runindebugcontext_string" id="deprecations_dep0069_vm_runindebugcontext_string">#</a></span></h3>
+<h4 id="DEP0069">DEP0069: <code>vm.runInDebugContext(string)</code><span><a class="mark" href="#deprecations_dep0069_vm_runindebugcontext_string" id="deprecations_dep0069_vm_runindebugcontext_string">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1493,8 +1460,7 @@ a V8-inspector based CLI debugger available through <code>node inspect</code>.</
 <p>Type: End-of-Life</p>
 <p>DebugContext has been removed in V8 and is not available in Node.js 10+.</p>
 <p>DebugContext was an experimental API.</p>
-<p><a id="DEP0070"></a></p>
-<h3>DEP0070: <code>async_hooks.currentId()</code><span><a class="mark" href="#deprecations_dep0070_async_hooks_currentid" id="deprecations_dep0070_async_hooks_currentid">#</a></span></h3>
+<h4 id="DEP0070">DEP0070: <code>async_hooks.currentId()</code><span><a class="mark" href="#deprecations_dep0070_async_hooks_currentid" id="deprecations_dep0070_async_hooks_currentid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1510,8 +1476,7 @@ a V8-inspector based CLI debugger available through <code>node inspect</code>.</
 <p><code>async_hooks.currentId()</code> was renamed to <code>async_hooks.executionAsyncId()</code> for
 clarity.</p>
 <p>This change was made while <code>async_hooks</code> was an experimental API.</p>
-<p><a id="DEP0071"></a></p>
-<h3>DEP0071: <code>async_hooks.triggerId()</code><span><a class="mark" href="#deprecations_dep0071_async_hooks_triggerid" id="deprecations_dep0071_async_hooks_triggerid">#</a></span></h3>
+<h4 id="DEP0071">DEP0071: <code>async_hooks.triggerId()</code><span><a class="mark" href="#deprecations_dep0071_async_hooks_triggerid" id="deprecations_dep0071_async_hooks_triggerid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1527,8 +1492,7 @@ clarity.</p>
 <p><code>async_hooks.triggerId()</code> was renamed to <code>async_hooks.triggerAsyncId()</code> for
 clarity.</p>
 <p>This change was made while <code>async_hooks</code> was an experimental API.</p>
-<p><a id="DEP0072"></a></p>
-<h3>DEP0072: <code>async_hooks.AsyncResource.triggerId()</code><span><a class="mark" href="#deprecations_dep0072_async_hooks_asyncresource_triggerid" id="deprecations_dep0072_async_hooks_asyncresource_triggerid">#</a></span></h3>
+<h4 id="DEP0072">DEP0072: <code>async_hooks.AsyncResource.triggerId()</code><span><a class="mark" href="#deprecations_dep0072_async_hooks_asyncresource_triggerid" id="deprecations_dep0072_async_hooks_asyncresource_triggerid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1544,8 +1508,7 @@ clarity.</p>
 <p><code>async_hooks.AsyncResource.triggerId()</code> was renamed to
 <code>async_hooks.AsyncResource.triggerAsyncId()</code> for clarity.</p>
 <p>This change was made while <code>async_hooks</code> was an experimental API.</p>
-<p><a id="DEP0073"></a></p>
-<h3>DEP0073: Several internal properties of <code>net.Server</code><span><a class="mark" href="#deprecations_dep0073_several_internal_properties_of_net_server" id="deprecations_dep0073_several_internal_properties_of_net_server">#</a></span></h3>
+<h4 id="DEP0073">DEP0073: Several internal properties of <code>net.Server</code><span><a class="mark" href="#deprecations_dep0073_several_internal_properties_of_net_server" id="deprecations_dep0073_several_internal_properties_of_net_server">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1562,8 +1525,7 @@ clarity.</p>
 with inappropriate names is deprecated.</p>
 <p>As the original API was undocumented and not generally useful for non-internal
 code, no replacement API is provided.</p>
-<p><a id="DEP0074"></a></p>
-<h3>DEP0074: <code>REPLServer.bufferedCommand</code><span><a class="mark" href="#deprecations_dep0074_replserver_bufferedcommand" id="deprecations_dep0074_replserver_bufferedcommand">#</a></span></h3>
+<h4 id="DEP0074">DEP0074: <code>REPLServer.bufferedCommand</code><span><a class="mark" href="#deprecations_dep0074_replserver_bufferedcommand" id="deprecations_dep0074_replserver_bufferedcommand">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1576,8 +1538,7 @@ code, no replacement API is provided.</p>
 <p>Type: Runtime</p>
 <p>The <code>REPLServer.bufferedCommand</code> property was deprecated in favor of
 <a href="repl.html#repl_replserver_clearbufferedcommand"><code>REPLServer.clearBufferedCommand()</code></a>.</p>
-<p><a id="DEP0075"></a></p>
-<h3>DEP0075: <code>REPLServer.parseREPLKeyword()</code><span><a class="mark" href="#deprecations_dep0075_replserver_parsereplkeyword" id="deprecations_dep0075_replserver_parsereplkeyword">#</a></span></h3>
+<h4 id="DEP0075">DEP0075: <code>REPLServer.parseREPLKeyword()</code><span><a class="mark" href="#deprecations_dep0075_replserver_parsereplkeyword" id="deprecations_dep0075_replserver_parsereplkeyword">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1589,8 +1550,7 @@ code, no replacement API is provided.</p>
 </div>
 <p>Type: Runtime</p>
 <p><code>REPLServer.parseREPLKeyword()</code> was removed from userland visibility.</p>
-<p><a id="DEP0076"></a></p>
-<h3>DEP0076: <code>tls.parseCertString()</code><span><a class="mark" href="#deprecations_dep0076_tls_parsecertstring" id="deprecations_dep0076_tls_parsecertstring">#</a></span></h3>
+<h4 id="DEP0076">DEP0076: <code>tls.parseCertString()</code><span><a class="mark" href="#deprecations_dep0076_tls_parsecertstring" id="deprecations_dep0076_tls_parsecertstring">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1606,15 +1566,14 @@ code, no replacement API is provided.</p>
 <p><code>tls.parseCertString()</code> is a trivial parsing helper that was made public by
 mistake. This function can usually be replaced with:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> querystring = <span class="hljs-built_in">require</span>(<span class="hljs-string">'querystring'</span>);
-querystring.parse(str, <span class="hljs-string">'\n'</span>, <span class="hljs-string">'='</span>);</code></pre>
+querystring.<span class="hljs-title function_">parse</span>(str, <span class="hljs-string">'\n'</span>, <span class="hljs-string">'='</span>);</code></pre>
 <p>This function is not completely equivalent to <code>querystring.parse()</code>. One
 difference is that <code>querystring.parse()</code> does url decoding:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> querystring.parse(<span class="hljs-string">'%E5%A5%BD=1'</span>, <span class="hljs-string">'\n'</span>, <span class="hljs-string">'='</span>);</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">querystring.parse(<span class="hljs-string">'%E5%A5%BD=1'</span>, <span class="hljs-string">'\n'</span>, <span class="hljs-string">'='</span>);</span>
 { '好': '1' }
-<span class="hljs-meta">></span><span class="bash"> tls.parseCertString(<span class="hljs-string">'%E5%A5%BD=1'</span>);</span>
+<span class="hljs-meta">> </span><span class="language-bash">tls.parseCertString(<span class="hljs-string">'%E5%A5%BD=1'</span>);</span>
 { '%E5%A5%BD': '1' }</code></pre>
-<p><a id="DEP0077"></a></p>
-<h3>DEP0077: <code>Module._debug()</code><span><a class="mark" href="#deprecations_dep0077_module_debug" id="deprecations_dep0077_module_debug">#</a></span></h3>
+<h4 id="DEP0077">DEP0077: <code>Module._debug()</code><span><a class="mark" href="#deprecations_dep0077_module_debug" id="deprecations_dep0077_module_debug">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1628,8 +1587,7 @@ difference is that <code>querystring.parse()</code> does url decoding:</p>
 <p><code>Module._debug()</code> is deprecated.</p>
 <p>The <code>Module._debug()</code> function was never documented as an officially
 supported API.</p>
-<p><a id="DEP0078"></a></p>
-<h3>DEP0078: <code>REPLServer.turnOffEditorMode()</code><span><a class="mark" href="#deprecations_dep0078_replserver_turnoffeditormode" id="deprecations_dep0078_replserver_turnoffeditormode">#</a></span></h3>
+<h4 id="DEP0078">DEP0078: <code>REPLServer.turnOffEditorMode()</code><span><a class="mark" href="#deprecations_dep0078_replserver_turnoffeditormode" id="deprecations_dep0078_replserver_turnoffeditormode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1641,8 +1599,7 @@ supported API.</p>
 </div>
 <p>Type: Runtime</p>
 <p><code>REPLServer.turnOffEditorMode()</code> was removed from userland visibility.</p>
-<p><a id="DEP0079"></a></p>
-<h3>DEP0079: Custom inspection function on objects via <code>.inspect()</code><span><a class="mark" href="#deprecations_dep0079_custom_inspection_function_on_objects_via_inspect" id="deprecations_dep0079_custom_inspection_function_on_objects_via_inspect">#</a></span></h3>
+<h4 id="DEP0079">DEP0079: Custom inspection function on objects via <code>.inspect()</code><span><a class="mark" href="#deprecations_dep0079_custom_inspection_function_on_objects_via_inspect" id="deprecations_dep0079_custom_inspection_function_on_objects_via_inspect">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1660,9 +1617,8 @@ supported API.</p>
 <p>Using a property named <code>inspect</code> on an object to specify a custom inspection
 function for <a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a> is deprecated. Use <a href="util.html#util_util_inspect_custom"><code>util.inspect.custom</code></a>
 instead. For backward compatibility with Node.js prior to version 6.4.0, both
-may be specified.</p>
-<p><a id="DEP0080"></a></p>
-<h3>DEP0080: <code>path._makeLong()</code><span><a class="mark" href="#deprecations_dep0080_path_makelong" id="deprecations_dep0080_path_makelong">#</a></span></h3>
+can be specified.</p>
+<h4 id="DEP0080">DEP0080: <code>path._makeLong()</code><span><a class="mark" href="#deprecations_dep0080_path_makelong" id="deprecations_dep0080_path_makelong">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1676,8 +1632,7 @@ may be specified.</p>
 <p>The internal <code>path._makeLong()</code> was not intended for public use. However,
 userland modules have found it useful. The internal API is deprecated
 and replaced with an identical, public <code>path.toNamespacedPath()</code> method.</p>
-<p><a id="DEP0081"></a></p>
-<h3>DEP0081: <code>fs.truncate()</code> using a file descriptor<span><a class="mark" href="#deprecations_dep0081_fs_truncate_using_a_file_descriptor" id="deprecations_dep0081_fs_truncate_using_a_file_descriptor">#</a></span></h3>
+<h4 id="DEP0081">DEP0081: <code>fs.truncate()</code> using a file descriptor<span><a class="mark" href="#deprecations_dep0081_fs_truncate_using_a_file_descriptor" id="deprecations_dep0081_fs_truncate_using_a_file_descriptor">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1691,8 +1646,7 @@ and replaced with an identical, public <code>path.toNamespacedPath()</code> meth
 <p><code>fs.truncate()</code> <code>fs.truncateSync()</code> usage with a file descriptor is
 deprecated. Please use <code>fs.ftruncate()</code> or <code>fs.ftruncateSync()</code> to work with
 file descriptors.</p>
-<p><a id="DEP0082"></a></p>
-<h3>DEP0082: <code>REPLServer.prototype.memory()</code><span><a class="mark" href="#deprecations_dep0082_replserver_prototype_memory" id="deprecations_dep0082_replserver_prototype_memory">#</a></span></h3>
+<h4 id="DEP0082">DEP0082: <code>REPLServer.prototype.memory()</code><span><a class="mark" href="#deprecations_dep0082_replserver_prototype_memory" id="deprecations_dep0082_replserver_prototype_memory">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1705,8 +1659,7 @@ file descriptors.</p>
 <p>Type: Runtime</p>
 <p><code>REPLServer.prototype.memory()</code> is only necessary for the internal mechanics of
 the <code>REPLServer</code> itself. Do not use this function.</p>
-<p><a id="DEP0083"></a></p>
-<h3>DEP0083: Disabling ECDH by setting <code>ecdhCurve</code> to <code>false</code><span><a class="mark" href="#deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false" id="deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false">#</a></span></h3>
+<h4 id="DEP0083">DEP0083: Disabling ECDH by setting <code>ecdhCurve</code> to <code>false</code><span><a class="mark" href="#deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false" id="deprecations_dep0083_disabling_ecdh_by_setting_ecdhcurve_to_false">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1723,8 +1676,7 @@ the <code>REPLServer</code> itself. Do not use this function.</p>
 be set to <code>false</code> to disable ECDH entirely on the server only. This mode was
 deprecated in preparation for migrating to OpenSSL 1.1.0 and consistency with
 the client and is now unsupported. Use the <code>ciphers</code> parameter instead.</p>
-<p><a id="DEP0084"></a></p>
-<h3>DEP0084: requiring bundled internal dependencies<span><a class="mark" href="#deprecations_dep0084_requiring_bundled_internal_dependencies" id="deprecations_dep0084_requiring_bundled_internal_dependencies">#</a></span></h3>
+<h4 id="DEP0084">DEP0084: requiring bundled internal dependencies<span><a class="mark" href="#deprecations_dep0084_requiring_bundled_internal_dependencies" id="deprecations_dep0084_requiring_bundled_internal_dependencies">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1758,18 +1710,17 @@ modules were:</p>
 <p>The <code>v8/*</code> modules do not have any exports, and if not imported in a specific
 order would in fact throw errors. As such there are virtually no legitimate use
 cases for importing them through <code>require()</code>.</p>
-<p>On the other hand, <code>node-inspect</code> may be installed locally through a package
+<p>On the other hand, <code>node-inspect</code> can be installed locally through a package
 manager, as it is published on the npm registry under the same name. No source
 code modification is necessary if that is done.</p>
-<p><a id="DEP0085"></a></p>
-<h3>DEP0085: AsyncHooks sensitive API<span><a class="mark" href="#deprecations_dep0085_asynchooks_sensitive_api" id="deprecations_dep0085_asynchooks_sensitive_api">#</a></span></h3>
+<h4 id="DEP0085">DEP0085: AsyncHooks sensitive API<span><a class="mark" href="#deprecations_dep0085_asynchooks_sensitive_api" id="deprecations_dep0085_asynchooks_sensitive_api">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>10.0.0</td>
+<tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v8.10.0, v9.4.0</td>
+<tr><td>v9.4.0, v8.10.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -1778,15 +1729,14 @@ code modification is necessary if that is done.</p>
 <p>The AsyncHooks sensitive API was never documented and had various minor issues.
 Use the <code>AsyncResource</code> API instead. See
 <a href="https://github.com/nodejs/node/issues/15572">https://github.com/nodejs/node/issues/15572</a>.</p>
-<p><a id="DEP0086"></a></p>
-<h3>DEP0086: Remove <code>runInAsyncIdScope</code><span><a class="mark" href="#deprecations_dep0086_remove_runinasyncidscope" id="deprecations_dep0086_remove_runinasyncidscope">#</a></span></h3>
+<h4 id="DEP0086">DEP0086: Remove <code>runInAsyncIdScope</code><span><a class="mark" href="#deprecations_dep0086_remove_runinasyncidscope" id="deprecations_dep0086_remove_runinasyncidscope">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>10.0.0</td>
+<tr><td>v10.0.0</td>
 <td><p>End-of-Life.</p></td></tr>
-<tr><td>v8.10.0, v9.4.0</td>
+<tr><td>v9.4.0, v8.10.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -1794,15 +1744,14 @@ Use the <code>AsyncResource</code> API instead. See
 <p>Type: End-of-Life</p>
 <p><code>runInAsyncIdScope</code> doesn't emit the <code>'before'</code> or <code>'after'</code> event and can thus
 cause a lot of issues. See <a href="https://github.com/nodejs/node/issues/14328">https://github.com/nodejs/node/issues/14328</a>.</p>
-<p><a id="DEP0089"></a></p>
-<h3>DEP0089: <code>require('assert')</code><span><a class="mark" href="#deprecations_dep0089_require_assert" id="deprecations_dep0089_require_assert">#</a></span></h3>
+<h4 id="DEP0089">DEP0089: <code>require('assert')</code><span><a class="mark" href="#deprecations_dep0089_require_assert" id="deprecations_dep0089_require_assert">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.8.0</td>
 <td><p>Deprecation revoked.</p></td></tr>
-<tr><td>v9.9.0, v10.0.0</td>
+<tr><td>v9.9.0, v8.13.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -1811,8 +1760,7 @@ cause a lot of issues. See <a href="https://github.com/nodejs/node/issues/14328"
 <p>Importing assert directly was not recommended as the exposed functions use
 loose equality checks. The deprecation was revoked because use of the <code>assert</code>
 module is not discouraged, and the deprecation caused developer confusion.</p>
-<p><a id="DEP0090"></a></p>
-<h3>DEP0090: Invalid GCM authentication tag lengths<span><a class="mark" href="#deprecations_dep0090_invalid_gcm_authentication_tag_lengths" id="deprecations_dep0090_invalid_gcm_authentication_tag_lengths">#</a></span></h3>
+<h4 id="DEP0090">DEP0090: Invalid GCM authentication tag lengths<span><a class="mark" href="#deprecations_dep0090_invalid_gcm_authentication_tag_lengths" id="deprecations_dep0090_invalid_gcm_authentication_tag_lengths">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1830,8 +1778,7 @@ OpenSSL when calling <a href="crypto.html#crypto_decipher_setauthtag_buffer"><co
 v11.0.0, only authentication tag lengths of 128, 120, 112, 104, 96, 64, and 32
 bits are allowed. Authentication tags of other lengths are invalid per
 <a href="https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf">NIST SP 800-38D</a>.</p>
-<p><a id="DEP0091"></a></p>
-<h3>DEP0091: <code>crypto.DEFAULT_ENCODING</code><span><a class="mark" href="#deprecations_dep0091_crypto_default_encoding" id="deprecations_dep0091_crypto_default_encoding">#</a></span></h3>
+<h4 id="DEP0091">DEP0091: <code>crypto.DEFAULT_ENCODING</code><span><a class="mark" href="#deprecations_dep0091_crypto_default_encoding" id="deprecations_dep0091_crypto_default_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1843,8 +1790,7 @@ bits are allowed. Authentication tags of other lengths are invalid per
 </div>
 <p>Type: Runtime</p>
 <p>The <a href="crypto.html#crypto_crypto_default_encoding"><code>crypto.DEFAULT_ENCODING</code></a> property is deprecated.</p>
-<p><a id="DEP0092"></a></p>
-<h3>DEP0092: Top-level <code>this</code> bound to <code>module.exports</code><span><a class="mark" href="#deprecations_dep0092_top_level_this_bound_to_module_exports" id="deprecations_dep0092_top_level_this_bound_to_module_exports">#</a></span></h3>
+<h4 id="DEP0092">DEP0092: Top-level <code>this</code> bound to <code>module.exports</code><span><a class="mark" href="#deprecations_dep0092_top_level_this_bound_to_module_exports" id="deprecations_dep0092_top_level_this_bound_to_module_exports">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1858,8 +1804,7 @@ bits are allowed. Authentication tags of other lengths are invalid per
 <p>Assigning properties to the top-level <code>this</code> as an alternative
 to <code>module.exports</code> is deprecated. Developers should use <code>exports</code>
 or <code>module.exports</code> instead.</p>
-<p><a id="DEP0093"></a></p>
-<h3>DEP0093: <code>crypto.fips</code> is deprecated and replaced.<span><a class="mark" href="#deprecations_dep0093_crypto_fips_is_deprecated_and_replaced" id="deprecations_dep0093_crypto_fips_is_deprecated_and_replaced">#</a></span></h3>
+<h4 id="DEP0093">DEP0093: <code>crypto.fips</code> is deprecated and replaced<span><a class="mark" href="#deprecations_dep0093_crypto_fips_is_deprecated_and_replaced" id="deprecations_dep0093_crypto_fips_is_deprecated_and_replaced">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1872,8 +1817,7 @@ or <code>module.exports</code> instead.</p>
 <p>Type: Documentation-only</p>
 <p>The <a href="crypto.html#crypto_crypto_fips"><code>crypto.fips</code></a> property is deprecated. Please use <code>crypto.setFips()</code>
 and <code>crypto.getFips()</code> instead.</p>
-<p><a id="DEP0094"></a></p>
-<h3>DEP0094: Using <code>assert.fail()</code> with more than one argument.<span><a class="mark" href="#deprecations_dep0094_using_assert_fail_with_more_than_one_argument" id="deprecations_dep0094_using_assert_fail_with_more_than_one_argument">#</a></span></h3>
+<h4 id="DEP0094">DEP0094: Using <code>assert.fail()</code> with more than one argument<span><a class="mark" href="#deprecations_dep0094_using_assert_fail_with_more_than_one_argument" id="deprecations_dep0094_using_assert_fail_with_more_than_one_argument">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1887,8 +1831,7 @@ and <code>crypto.getFips()</code> instead.</p>
 <p>Using <code>assert.fail()</code> with more than one argument is deprecated. Use
 <code>assert.fail()</code> with only one argument or use a different <code>assert</code> module
 method.</p>
-<p><a id="DEP0095"></a></p>
-<h3>DEP0095: <code>timers.enroll()</code><span><a class="mark" href="#deprecations_dep0095_timers_enroll" id="deprecations_dep0095_timers_enroll">#</a></span></h3>
+<h4 id="DEP0095">DEP0095: <code>timers.enroll()</code><span><a class="mark" href="#deprecations_dep0095_timers_enroll" id="deprecations_dep0095_timers_enroll">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1901,8 +1844,7 @@ method.</p>
 <p>Type: Runtime</p>
 <p><code>timers.enroll()</code> is deprecated. Please use the publicly documented
 <a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> or <a href="timers.html#timers_setinterval_callback_delay_args"><code>setInterval()</code></a> instead.</p>
-<p><a id="DEP0096"></a></p>
-<h3>DEP0096: <code>timers.unenroll()</code><span><a class="mark" href="#deprecations_dep0096_timers_unenroll" id="deprecations_dep0096_timers_unenroll">#</a></span></h3>
+<h4 id="DEP0096">DEP0096: <code>timers.unenroll()</code><span><a class="mark" href="#deprecations_dep0096_timers_unenroll" id="deprecations_dep0096_timers_unenroll">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1915,8 +1857,7 @@ method.</p>
 <p>Type: Runtime</p>
 <p><code>timers.unenroll()</code> is deprecated. Please use the publicly documented
 <a href="timers.html#timers_cleartimeout_timeout"><code>clearTimeout()</code></a> or <a href="timers.html#timers_clearinterval_timeout"><code>clearInterval()</code></a> instead.</p>
-<p><a id="DEP0097"></a></p>
-<h3>DEP0097: <code>MakeCallback</code> with <code>domain</code> property<span><a class="mark" href="#deprecations_dep0097_makecallback_with_domain_property" id="deprecations_dep0097_makecallback_with_domain_property">#</a></span></h3>
+<h4 id="DEP0097">DEP0097: <code>MakeCallback</code> with <code>domain</code> property<span><a class="mark" href="#deprecations_dep0097_makecallback_with_domain_property" id="deprecations_dep0097_makecallback_with_domain_property">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1930,15 +1871,14 @@ method.</p>
 <p>Users of <code>MakeCallback</code> that add the <code>domain</code> property to carry context,
 should start using the <code>async_context</code> variant of <code>MakeCallback</code> or
 <code>CallbackScope</code>, or the high-level <code>AsyncResource</code> class.</p>
-<p><a id="DEP0098"></a></p>
-<h3>DEP0098: AsyncHooks embedder <code>AsyncResource.emitBefore</code> and <code>AsyncResource.emitAfter</code> APIs<span><a class="mark" href="#deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis" id="deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis">#</a></span></h3>
+<h4 id="DEP0098">DEP0098: AsyncHooks embedder <code>AsyncResource.emitBefore</code> and <code>AsyncResource.emitAfter</code> APIs<span><a class="mark" href="#deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis" id="deprecations_dep0098_asynchooks_embedder_asyncresource_emitbefore_and_asyncresource_emitafter_apis">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v12.0.0</td>
-<td><p>End-of-Life</p></td></tr>
-<tr><td>v8.12.0, v9.6.0, v10.0.0</td>
+<td><p>End-of-Life.</p></td></tr>
+<tr><td>v10.0.0, v9.6.0, v8.12.0</td>
 <td><p>Runtime deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -1950,8 +1890,7 @@ to unrecoverable errors.</p>
 <p>Use <a href="async_hooks.html#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args"><code>asyncResource.runInAsyncScope()</code></a> API instead which provides a much
 safer, and more convenient, alternative. See
 <a href="https://github.com/nodejs/node/pull/18513">https://github.com/nodejs/node/pull/18513</a>.</p>
-<p><a id="DEP0099"></a></p>
-<h3>DEP0099: Async context-unaware <code>node::MakeCallback</code> C++ APIs<span><a class="mark" href="#deprecations_dep0099_async_context_unaware_node_makecallback_c_apis" id="deprecations_dep0099_async_context_unaware_node_makecallback_c_apis">#</a></span></h3>
+<h4 id="DEP0099">DEP0099: Async context-unaware <code>node::MakeCallback</code> C++ APIs<span><a class="mark" href="#deprecations_dep0099_async_context_unaware_node_makecallback_c_apis" id="deprecations_dep0099_async_context_unaware_node_makecallback_c_apis">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1965,8 +1904,7 @@ safer, and more convenient, alternative. See
 <p>Certain versions of <code>node::MakeCallback</code> APIs available to native modules are
 deprecated. Please use the versions of the API that accept an <code>async_context</code>
 parameter.</p>
-<p><a id="DEP0100"></a></p>
-<h3>DEP0100: <code>process.assert()</code><span><a class="mark" href="#deprecations_dep0100_process_assert" id="deprecations_dep0100_process_assert">#</a></span></h3>
+<h4 id="DEP0100">DEP0100: <code>process.assert()</code><span><a class="mark" href="#deprecations_dep0100_process_assert" id="deprecations_dep0100_process_assert">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1981,8 +1919,7 @@ parameter.</p>
 <p>Type: Runtime</p>
 <p><code>process.assert()</code> is deprecated. Please use the <a href="assert.html"><code>assert</code></a> module instead.</p>
 <p>This was never a documented feature.</p>
-<p><a id="DEP0101"></a></p>
-<h3>DEP0101: <code>--with-lttng</code><span><a class="mark" href="#deprecations_dep0101_with_lttng" id="deprecations_dep0101_with_lttng">#</a></span></h3>
+<h4 id="DEP0101">DEP0101: <code>--with-lttng</code><span><a class="mark" href="#deprecations_dep0101_with_lttng" id="deprecations_dep0101_with_lttng">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1994,8 +1931,7 @@ parameter.</p>
 </div>
 <p>Type: End-of-Life</p>
 <p>The <code>--with-lttng</code> compile-time option has been removed.</p>
-<p><a id="DEP0102"></a></p>
-<h3>DEP0102: Using <code>noAssert</code> in <code>Buffer#(read|write)</code> operations.<span><a class="mark" href="#deprecations_dep0102_using_noassert_in_buffer_read_write_operations" id="deprecations_dep0102_using_noassert_in_buffer_read_write_operations">#</a></span></h3>
+<h4 id="DEP0102">DEP0102: Using <code>noAssert</code> in <code>Buffer#(read|write)</code> operations<span><a class="mark" href="#deprecations_dep0102_using_noassert_in_buffer_read_write_operations" id="deprecations_dep0102_using_noassert_in_buffer_read_write_operations">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2009,8 +1945,7 @@ parameter.</p>
 <p>Using the <code>noAssert</code> argument has no functionality anymore. All input is going
 to be verified, no matter if it is set to true or not. Skipping the verification
 could lead to hard to find errors and crashes.</p>
-<p><a id="DEP0103"></a></p>
-<h3>DEP0103: <code>process.binding('util').is[...]</code> typechecks<span><a class="mark" href="#deprecations_dep0103_process_binding_util_is_typechecks" id="deprecations_dep0103_process_binding_util_is_typechecks">#</a></span></h3>
+<h4 id="DEP0103">DEP0103: <code>process.binding('util').is[...]</code> typechecks<span><a class="mark" href="#deprecations_dep0103_process_binding_util_is_typechecks" id="deprecations_dep0103_process_binding_util_is_typechecks">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2027,8 +1962,7 @@ could lead to hard to find errors and crashes.</p>
 methods in particular can be replaced by using <a href="util.html#util_util_types"><code>util.types</code></a>.</p>
 <p>This deprecation has been superseded by the deprecation of the
 <code>process.binding()</code> API (<a href="#DEP0111">DEP0111</a>).</p>
-<p><a id="DEP0104"></a></p>
-<h3>DEP0104: <code>process.env</code> string coercion<span><a class="mark" href="#deprecations_dep0104_process_env_string_coercion" id="deprecations_dep0104_process_env_string_coercion">#</a></span></h3>
+<h4 id="DEP0104">DEP0104: <code>process.env</code> string coercion<span><a class="mark" href="#deprecations_dep0104_process_env_string_coercion" id="deprecations_dep0104_process_env_string_coercion">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2041,11 +1975,10 @@ methods in particular can be replaced by using <a href="util.html#util_util_type
 <p>Type: Documentation-only (supports <a href="cli.html#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p>When assigning a non-string property to <a href="process.html#process_process_env"><code>process.env</code></a>, the assigned value is
 implicitly converted to a string. This behavior is deprecated if the assigned
-value is not a string, boolean, or number. In the future, such assignment may
+value is not a string, boolean, or number. In the future, such assignment might
 result in a thrown error. Please convert the property to a string before
 assigning it to <code>process.env</code>.</p>
-<p><a id="DEP0105"></a></p>
-<h3>DEP0105: <code>decipher.finaltol</code><span><a class="mark" href="#deprecations_dep0105_decipher_finaltol" id="deprecations_dep0105_decipher_finaltol">#</a></span></h3>
+<h4 id="DEP0105">DEP0105: <code>decipher.finaltol</code><span><a class="mark" href="#deprecations_dep0105_decipher_finaltol" id="deprecations_dep0105_decipher_finaltol">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2061,8 +1994,7 @@ assigning it to <code>process.env</code>.</p>
 <p><code>decipher.finaltol()</code> has never been documented and was an alias for
 <a href="crypto.html#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a>. This API has been removed, and it is recommended to use
 <a href="crypto.html#crypto_decipher_final_outputencoding"><code>decipher.final()</code></a> instead.</p>
-<p><a id="DEP0106"></a></p>
-<h3>DEP0106: <code>crypto.createCipher</code> and <code>crypto.createDecipher</code><span><a class="mark" href="#deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher" id="deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher">#</a></span></h3>
+<h4 id="DEP0106">DEP0106: <code>crypto.createCipher</code> and <code>crypto.createDecipher</code><span><a class="mark" href="#deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher" id="deprecations_dep0106_crypto_createcipher_and_crypto_createdecipher">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2081,8 +2013,7 @@ initialization vectors. It is recommended to derive a key using
 <a href="crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback"><code>crypto.pbkdf2()</code></a> or <a href="crypto.html#crypto_crypto_scrypt_password_salt_keylen_options_callback"><code>crypto.scrypt()</code></a> and to use
 <a href="crypto.html#crypto_crypto_createcipheriv_algorithm_key_iv_options"><code>crypto.createCipheriv()</code></a> and <a href="crypto.html#crypto_crypto_createdecipheriv_algorithm_key_iv_options"><code>crypto.createDecipheriv()</code></a> to obtain the
 <a href="crypto.html#crypto_class_cipher"><code>Cipher</code></a> and <a href="crypto.html#crypto_class_decipher"><code>Decipher</code></a> objects respectively.</p>
-<p><a id="DEP0107"></a></p>
-<h3>DEP0107: <code>tls.convertNPNProtocols()</code><span><a class="mark" href="#deprecations_dep0107_tls_convertnpnprotocols" id="deprecations_dep0107_tls_convertnpnprotocols">#</a></span></h3>
+<h4 id="DEP0107">DEP0107: <code>tls.convertNPNProtocols()</code><span><a class="mark" href="#deprecations_dep0107_tls_convertnpnprotocols" id="deprecations_dep0107_tls_convertnpnprotocols">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2097,8 +2028,7 @@ initialization vectors. It is recommended to derive a key using
 <p>Type: End-of-Life</p>
 <p>This was an undocumented helper function not intended for use outside Node.js
 core and obsoleted by the removal of NPN (Next Protocol Negotiation) support.</p>
-<p><a id="DEP0108"></a></p>
-<h3>DEP0108: <code>zlib.bytesRead</code><span><a class="mark" href="#deprecations_dep0108_zlib_bytesread" id="deprecations_dep0108_zlib_bytesread">#</a></span></h3>
+<h4 id="DEP0108">DEP0108: <code>zlib.bytesRead</code><span><a class="mark" href="#deprecations_dep0108_zlib_bytesread" id="deprecations_dep0108_zlib_bytesread">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2115,8 +2045,7 @@ core and obsoleted by the removal of NPN (Next Protocol Negotiation) support.</p
 because it also made sense to interpret the value as the number of bytes
 read by the engine, but is inconsistent with other streams in Node.js that
 expose values under these names.</p>
-<p><a id="DEP0109"></a></p>
-<h3>DEP0109: <code>http</code>, <code>https</code>, and <code>tls</code> support for invalid URLs<span><a class="mark" href="#deprecations_dep0109_http_https_and_tls_support_for_invalid_urls" id="deprecations_dep0109_http_https_and_tls_support_for_invalid_urls">#</a></span></h3>
+<h4 id="DEP0109">DEP0109: <code>http</code>, <code>https</code>, and <code>tls</code> support for invalid URLs<span><a class="mark" href="#deprecations_dep0109_http_https_and_tls_support_for_invalid_urls" id="deprecations_dep0109_http_https_and_tls_support_for_invalid_urls">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2133,8 +2062,7 @@ expose values under these names.</p>
 accepted by the legacy <code>url.parse()</code> API. The mentioned APIs now use the WHATWG
 URL parser that requires strictly valid URLs. Passing an invalid URL is
 deprecated and support will be removed in the future.</p>
-<p><a id="DEP0110"></a></p>
-<h3>DEP0110: <code>vm.Script</code> cached data<span><a class="mark" href="#deprecations_dep0110_vm_script_cached_data" id="deprecations_dep0110_vm_script_cached_data">#</a></span></h3>
+<h4 id="DEP0110">DEP0110: <code>vm.Script</code> cached data<span><a class="mark" href="#deprecations_dep0110_vm_script_cached_data" id="deprecations_dep0110_vm_script_cached_data">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2147,8 +2075,7 @@ deprecated and support will be removed in the future.</p>
 <p>Type: Documentation-only</p>
 <p>The <code>produceCachedData</code> option is deprecated. Use
 <a href="vm.html#vm_script_createcacheddata"><code>script.createCachedData()</code></a> instead.</p>
-<p><a id="DEP0111"></a></p>
-<h3>DEP0111: <code>process.binding()</code><span><a class="mark" href="#deprecations_dep0111_process_binding" id="deprecations_dep0111_process_binding">#</a></span></h3>
+<h4 id="DEP0111">DEP0111: <code>process.binding()</code><span><a class="mark" href="#deprecations_dep0111_process_binding" id="deprecations_dep0111_process_binding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2162,8 +2089,7 @@ deprecated and support will be removed in the future.</p>
 </div>
 <p>Type: Documentation-only (supports <a href="cli.html#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p><code>process.binding()</code> is for use by Node.js internal code only.</p>
-<p><a id="DEP0112"></a></p>
-<h3>DEP0112: <code>dgram</code> private APIs<span><a class="mark" href="#deprecations_dep0112_dgram_private_apis" id="deprecations_dep0112_dgram_private_apis">#</a></span></h3>
+<h4 id="DEP0112">DEP0112: <code>dgram</code> private APIs<span><a class="mark" href="#deprecations_dep0112_dgram_private_apis" id="deprecations_dep0112_dgram_private_apis">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2180,8 +2106,7 @@ accessed outside of Node.js core: <code>Socket.prototype._handle</code>,
 <code>Socket.prototype._queue</code>, <code>Socket.prototype._reuseAddr</code>,
 <code>Socket.prototype._healthCheck()</code>, <code>Socket.prototype._stopReceiving()</code>, and
 <code>dgram._createSocketHandle()</code>.</p>
-<p><a id="DEP0113"></a></p>
-<h3>DEP0113: <code>Cipher.setAuthTag()</code>, <code>Decipher.getAuthTag()</code><span><a class="mark" href="#deprecations_dep0113_cipher_setauthtag_decipher_getauthtag" id="deprecations_dep0113_cipher_setauthtag_decipher_getauthtag">#</a></span></h3>
+<h4 id="DEP0113">DEP0113: <code>Cipher.setAuthTag()</code>, <code>Decipher.getAuthTag()</code><span><a class="mark" href="#deprecations_dep0113_cipher_setauthtag_decipher_getauthtag" id="deprecations_dep0113_cipher_setauthtag_decipher_getauthtag">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2196,8 +2121,7 @@ accessed outside of Node.js core: <code>Socket.prototype._handle</code>,
 <p>Type: End-of-Life</p>
 <p><code>Cipher.setAuthTag()</code> and <code>Decipher.getAuthTag()</code> are no longer available. They
 were never documented and would throw when called.</p>
-<p><a id="DEP0114"></a></p>
-<h3>DEP0114: <code>crypto._toBuf()</code><span><a class="mark" href="#deprecations_dep0114_crypto_tobuf" id="deprecations_dep0114_crypto_tobuf">#</a></span></h3>
+<h4 id="DEP0114">DEP0114: <code>crypto._toBuf()</code><span><a class="mark" href="#deprecations_dep0114_crypto_tobuf" id="deprecations_dep0114_crypto_tobuf">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2212,8 +2136,8 @@ were never documented and would throw when called.</p>
 <p>Type: End-of-Life</p>
 <p>The <code>crypto._toBuf()</code> function was not designed to be used by modules outside
 of Node.js core and was removed.</p>
-<p><a id="DEP0115"></a></p>
-<h3>DEP0115: <code>crypto.prng()</code>, <code>crypto.pseudoRandomBytes()</code>, <code>crypto.rng()</code><span><a class="mark" href="#deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng" id="deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng">#</a></span></h3>
+<h4 id="DEP0115">DEP0115: <code>crypto.prng()</code>, <code>crypto.pseudoRandomBytes()</code>, <code>crypto.rng()</code><span><a class="mark" href="#deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng" id="deprecations_dep0115_crypto_prng_crypto_pseudorandombytes_crypto_rng">#</a></span></h4>
+<!--lint disable nodejs-yaml-comments -->
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2223,29 +2147,30 @@ of Node.js core and was removed.</p>
 </tbody></table>
 </details>
 </div>
+<!--lint enable nodejs-yaml-comments -->
 <p>Type: Documentation-only (supports <a href="cli.html#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p>In recent versions of Node.js, there is no difference between
 <a href="crypto.html#crypto_crypto_randombytes_size_callback"><code>crypto.randomBytes()</code></a> and <code>crypto.pseudoRandomBytes()</code>. The latter is
 deprecated along with the undocumented aliases <code>crypto.prng()</code> and
-<code>crypto.rng()</code> in favor of <a href="crypto.html#crypto_crypto_randombytes_size_callback"><code>crypto.randomBytes()</code></a> and may be removed in a
+<code>crypto.rng()</code> in favor of <a href="crypto.html#crypto_crypto_randombytes_size_callback"><code>crypto.randomBytes()</code></a> and might be removed in a
 future release.</p>
-<p><a id="DEP0116"></a></p>
-<h3>DEP0116: Legacy URL API<span><a class="mark" href="#deprecations_dep0116_legacy_url_api" id="deprecations_dep0116_legacy_url_api">#</a></span></h3>
+<h4 id="DEP0116">DEP0116: Legacy URL API<span><a class="mark" href="#deprecations_dep0116_legacy_url_api" id="deprecations_dep0116_legacy_url_api">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Documentation-only</p>
+<p>Type: Deprecation revoked</p>
 <p>The <a href="url.html#url_legacy_url_api">Legacy URL API</a> is deprecated. This includes <a href="url.html#url_url_format_urlobject"><code>url.format()</code></a>,
 <a href="url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a>, <a href="url.html#url_url_resolve_from_to"><code>url.resolve()</code></a>, and the <a href="url.html#url_legacy_urlobject">legacy <code>urlObject</code></a>. Please
 use the <a href="url.html#url_the_whatwg_url_api">WHATWG URL API</a> instead.</p>
-<p><a id="DEP0117"></a></p>
-<h3>DEP0117: Native crypto handles<span><a class="mark" href="#deprecations_dep0117_native_crypto_handles" id="deprecations_dep0117_native_crypto_handles">#</a></span></h3>
+<h4 id="DEP0117">DEP0117: Native crypto handles<span><a class="mark" href="#deprecations_dep0117_native_crypto_handles" id="deprecations_dep0117_native_crypto_handles">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2263,8 +2188,7 @@ the <code>_handle</code> property of the <code>Cipher</code>, <code>Decipher</co
 <code>DiffieHellmanGroup</code>, <code>ECDH</code>, <code>Hash</code>, <code>Hmac</code>, <code>Sign</code>, and <code>Verify</code> classes.
 The <code>_handle</code> property has been removed because improper use of the native
 object can lead to crashing the application.</p>
-<p><a id="DEP0118"></a></p>
-<h3>DEP0118: <code>dns.lookup()</code> support for a falsy host name<span><a class="mark" href="#deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name" id="deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name">#</a></span></h3>
+<h4 id="DEP0118">DEP0118: <code>dns.lookup()</code> support for a falsy host name<span><a class="mark" href="#deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name" id="deprecations_dep0118_dns_lookup_support_for_a_falsy_host_name">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2279,8 +2203,7 @@ object can lead to crashing the application.</p>
 like <code>dns.lookup(false)</code> due to backward compatibility.
 This behavior is undocumented and is thought to be unused in real world apps.
 It will become an error in future versions of Node.js.</p>
-<p><a id="DEP0119"></a></p>
-<h3>DEP0119: <code>process.binding('uv').errname()</code> private API<span><a class="mark" href="#deprecations_dep0119_process_binding_uv_errname_private_api" id="deprecations_dep0119_process_binding_uv_errname_private_api">#</a></span></h3>
+<h4 id="DEP0119">DEP0119: <code>process.binding('uv').errname()</code> private API<span><a class="mark" href="#deprecations_dep0119_process_binding_uv_errname_private_api" id="deprecations_dep0119_process_binding_uv_errname_private_api">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2293,8 +2216,7 @@ It will become an error in future versions of Node.js.</p>
 <p>Type: Documentation-only (supports <a href="cli.html#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p><code>process.binding('uv').errname()</code> is deprecated. Please use
 <a href="util.html#util_util_getsystemerrorname_err"><code>util.getSystemErrorName()</code></a> instead.</p>
-<p><a id="DEP0120"></a></p>
-<h3>DEP0120: Windows Performance Counter support<span><a class="mark" href="#deprecations_dep0120_windows_performance_counter_support" id="deprecations_dep0120_windows_performance_counter_support">#</a></span></h3>
+<h4 id="DEP0120">DEP0120: Windows Performance Counter support<span><a class="mark" href="#deprecations_dep0120_windows_performance_counter_support" id="deprecations_dep0120_windows_performance_counter_support">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2312,8 +2234,7 @@ undocumented <code>COUNTER_NET_SERVER_CONNECTION()</code>,
 <code>COUNTER_NET_SERVER_CONNECTION_CLOSE()</code>, <code>COUNTER_HTTP_SERVER_REQUEST()</code>,
 <code>COUNTER_HTTP_SERVER_RESPONSE()</code>, <code>COUNTER_HTTP_CLIENT_REQUEST()</code>, and
 <code>COUNTER_HTTP_CLIENT_RESPONSE()</code> functions have been deprecated.</p>
-<p><a id="DEP0121"></a></p>
-<h3>DEP0121: <code>net._setSimultaneousAccepts()</code><span><a class="mark" href="#deprecations_dep0121_net_setsimultaneousaccepts" id="deprecations_dep0121_net_setsimultaneousaccepts">#</a></span></h3>
+<h4 id="DEP0121">DEP0121: <code>net._setSimultaneousAccepts()</code><span><a class="mark" href="#deprecations_dep0121_net_setsimultaneousaccepts" id="deprecations_dep0121_net_setsimultaneousaccepts">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2329,8 +2250,7 @@ intended for debugging and performance tuning when using the <code>child_process
 and <code>cluster</code> modules on Windows. The function is not generally useful and
 is being removed. See discussion here:
 <a href="https://github.com/nodejs/node/issues/18391">https://github.com/nodejs/node/issues/18391</a></p>
-<p><a id="DEP0122"></a></p>
-<h3>DEP0122: <code>tls</code> <code>Server.prototype.setOptions()</code><span><a class="mark" href="#deprecations_dep0122_tls_server_prototype_setoptions" id="deprecations_dep0122_tls_server_prototype_setoptions">#</a></span></h3>
+<h4 id="DEP0122">DEP0122: <code>tls</code> <code>Server.prototype.setOptions()</code><span><a class="mark" href="#deprecations_dep0122_tls_server_prototype_setoptions" id="deprecations_dep0122_tls_server_prototype_setoptions">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2342,8 +2262,7 @@ is being removed. See discussion here:
 </div>
 <p>Type: Runtime</p>
 <p>Please use <code>Server.prototype.setSecureContext()</code> instead.</p>
-<p><a id="DEP0123"></a></p>
-<h3>DEP0123: setting the TLS ServerName to an IP address<span><a class="mark" href="#deprecations_dep0123_setting_the_tls_servername_to_an_ip_address" id="deprecations_dep0123_setting_the_tls_servername_to_an_ip_address">#</a></span></h3>
+<h4 id="DEP0123">DEP0123: setting the TLS ServerName to an IP address<span><a class="mark" href="#deprecations_dep0123_setting_the_tls_servername_to_an_ip_address" id="deprecations_dep0123_setting_the_tls_servername_to_an_ip_address">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2356,8 +2275,7 @@ is being removed. See discussion here:
 <p>Type: Runtime</p>
 <p>Setting the TLS ServerName to an IP address is not permitted by
 <a href="https://tools.ietf.org/html/rfc6066#section-3">RFC 6066</a>. This will be ignored in a future version.</p>
-<p><a id="DEP0124"></a></p>
-<h3>DEP0124: using <code>REPLServer.rli</code><span><a class="mark" href="#deprecations_dep0124_using_replserver_rli" id="deprecations_dep0124_using_replserver_rli">#</a></span></h3>
+<h4 id="DEP0124">DEP0124: using <code>REPLServer.rli</code><span><a class="mark" href="#deprecations_dep0124_using_replserver_rli" id="deprecations_dep0124_using_replserver_rli">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2369,8 +2287,7 @@ is being removed. See discussion here:
 </div>
 <p>Type: Runtime</p>
 <p>This property is a reference to the instance itself.</p>
-<p><a id="DEP0125"></a></p>
-<h3>DEP0125: <code>require('_stream_wrap')</code><span><a class="mark" href="#deprecations_dep0125_require_stream_wrap" id="deprecations_dep0125_require_stream_wrap">#</a></span></h3>
+<h4 id="DEP0125">DEP0125: <code>require('_stream_wrap')</code><span><a class="mark" href="#deprecations_dep0125_require_stream_wrap" id="deprecations_dep0125_require_stream_wrap">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2382,8 +2299,7 @@ is being removed. See discussion here:
 </div>
 <p>Type: Runtime</p>
 <p>The <code>_stream_wrap</code> module is deprecated.</p>
-<p><a id="DEP0126"></a></p>
-<h3>DEP0126: <code>timers.active()</code><span><a class="mark" href="#deprecations_dep0126_timers_active" id="deprecations_dep0126_timers_active">#</a></span></h3>
+<h4 id="DEP0126">DEP0126: <code>timers.active()</code><span><a class="mark" href="#deprecations_dep0126_timers_active" id="deprecations_dep0126_timers_active">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2398,8 +2314,7 @@ is being removed. See discussion here:
 Please use the publicly documented <a href="timers.html#timers_timeout_refresh"><code>timeout.refresh()</code></a> instead.
 If re-referencing the timeout is necessary, <a href="timers.html#timers_timeout_ref"><code>timeout.ref()</code></a> can be used
 with no performance impact since Node.js 10.</p>
-<p><a id="DEP0127"></a></p>
-<h3>DEP0127: <code>timers._unrefActive()</code><span><a class="mark" href="#deprecations_dep0127_timers_unrefactive" id="deprecations_dep0127_timers_unrefactive">#</a></span></h3>
+<h4 id="DEP0127">DEP0127: <code>timers._unrefActive()</code><span><a class="mark" href="#deprecations_dep0127_timers_unrefactive" id="deprecations_dep0127_timers_unrefactive">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2414,8 +2329,7 @@ with no performance impact since Node.js 10.</p>
 Please use the publicly documented <a href="timers.html#timers_timeout_refresh"><code>timeout.refresh()</code></a> instead.
 If unreferencing the timeout is necessary, <a href="timers.html#timers_timeout_unref"><code>timeout.unref()</code></a> can be used
 with no performance impact since Node.js 10.</p>
-<p><a id="DEP0128"></a></p>
-<h3>DEP0128: modules with an invalid <code>main</code> entry and an <code>index.js</code> file<span><a class="mark" href="#deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file" id="deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file">#</a></span></h3>
+<h4 id="DEP0128">DEP0128: modules with an invalid <code>main</code> entry and an <code>index.js</code> file<span><a class="mark" href="#deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file" id="deprecations_dep0128_modules_with_an_invalid_main_entry_and_an_index_js_file">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2430,53 +2344,55 @@ with no performance impact since Node.js 10.</p>
 also have an <code>index.js</code> file in the top level directory will resolve the
 <code>index.js</code> file. That is deprecated and is going to throw an error in future
 Node.js versions.</p>
-<p><a id="DEP0129"></a></p>
-<h3>DEP0129: <code>ChildProcess._channel</code><span><a class="mark" href="#deprecations_dep0129_childprocess_channel" id="deprecations_dep0129_childprocess_channel">#</a></span></h3>
+<h4 id="DEP0129">DEP0129: <code>ChildProcess._channel</code><span><a class="mark" href="#deprecations_dep0129_childprocess_channel" id="deprecations_dep0129_childprocess_channel">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
 <tr><td>v11.14.0</td>
 <td><p>Documentation-only.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Documentation-only</p>
+<p>Type: Runtime</p>
 <p>The <code>_channel</code> property of child process objects returned by <code>spawn()</code> and
 similar functions is not intended for public use. Use <code>ChildProcess.channel</code>
 instead.</p>
-<p><a id="DEP0130"></a></p>
-<h3>DEP0130: <code>Module.createRequireFromPath()</code><span><a class="mark" href="#deprecations_dep0130_module_createrequirefrompath" id="deprecations_dep0130_module_createrequirefrompath">#</a></span></h3>
+<h4 id="DEP0130">DEP0130: <code>Module.createRequireFromPath()</code><span><a class="mark" href="#deprecations_dep0130_module_createrequirefrompath" id="deprecations_dep0130_module_createrequirefrompath">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
 <tr><td>v12.2.0</td>
 <td><p>Documentation-only.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Documentation-only</p>
-<p>Module.createRequireFromPath() is deprecated. Please use <a href="module.html#module_module_createrequire_filename"><code>module.createRequire()</code></a> instead.</p>
-<p><a id="DEP0131"></a></p>
-<h3>DEP0131: Legacy HTTP parser<span><a class="mark" href="#deprecations_dep0131_legacy_http_parser" id="deprecations_dep0131_legacy_http_parser">#</a></span></h3>
+<p>Type: Runtime</p>
+<p>Module.createRequireFromPath() is deprecated. Please use
+<a href="module.html#module_module_createrequire_filename"><code>module.createRequire()</code></a> instead.</p>
+<h4 id="DEP0131">DEP0131: Legacy HTTP parser<span><a class="mark" href="#deprecations_dep0131_legacy_http_parser" id="deprecations_dep0131_legacy_http_parser">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.22.0</td>
-<td><p>Runtime deprecation.</p></td></tr>
+<tr><td>v13.0.0</td>
+<td><p>This feature has been removed.</p></td></tr>
 <tr><td>v12.3.0</td>
 <td><p>Documentation-only.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>Type: Runtime</p>
+<p>Type: End-of-Life</p>
 <p>The legacy HTTP parser, used by default in versions of Node.js prior to 12.0.0,
-is deprecated. This deprecation applies to users of the
-<a href="cli.html#cli_http_parser_library"><code>--http-parser=legacy</code></a> command-line flag.</p>
-<p><a id="DEP0132"></a></p>
-<h3>DEP0132: <code>worker.terminate()</code> with callback<span><a class="mark" href="#deprecations_dep0132_worker_terminate_with_callback" id="deprecations_dep0132_worker_terminate_with_callback">#</a></span></h3>
+is deprecated and has been removed in v13.0.0. Prior to v13.0.0, the
+<code>--http-parser=legacy</code> command-line flag could be used to revert to using the
+legacy parser.</p>
+<h4 id="DEP0132">DEP0132: <code>worker.terminate()</code> with callback<span><a class="mark" href="#deprecations_dep0132_worker_terminate_with_callback" id="deprecations_dep0132_worker_terminate_with_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2489,8 +2405,7 @@ is deprecated. This deprecation applies to users of the
 <p>Type: Runtime</p>
 <p>Passing a callback to <a href="worker_threads.html#worker_threads_worker_terminate"><code>worker.terminate()</code></a> is deprecated. Use the returned
 <code>Promise</code> instead, or a listener to the worker’s <code>'exit'</code> event.</p>
-<p><a id="DEP0133"></a></p>
-<h3>DEP0133: <code>http</code> <code>connection</code><span><a class="mark" href="#deprecations_dep0133_http_connection" id="deprecations_dep0133_http_connection">#</a></span></h3>
+<h4 id="DEP0133">DEP0133: <code>http</code> <code>connection</code><span><a class="mark" href="#deprecations_dep0133_http_connection" id="deprecations_dep0133_http_connection">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2503,8 +2418,7 @@ is deprecated. This deprecation applies to users of the
 <p>Type: Documentation-only</p>
 <p>Prefer <a href="http.html#http_response_socket"><code>response.socket</code></a> over <a href="http.html#http_response_connection"><code>response.connection</code></a> and
 <a href="http.html#http_request_socket"><code>request.socket</code></a> over <a href="http.html#http_request_connection"><code>request.connection</code></a>.</p>
-<p><a id="DEP0134"></a></p>
-<h3>DEP0134: <code>process._tickCallback</code><span><a class="mark" href="#deprecations_dep0134_process_tickcallback" id="deprecations_dep0134_process_tickcallback">#</a></span></h3>
+<h4 id="DEP0134">DEP0134: <code>process._tickCallback</code><span><a class="mark" href="#deprecations_dep0134_process_tickcallback" id="deprecations_dep0134_process_tickcallback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2517,13 +2431,27 @@ is deprecated. This deprecation applies to users of the
 <p>Type: Documentation-only (supports <a href="cli.html#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
 <p>The <code>process._tickCallback</code> property was never documented as
 an officially supported API.</p>
-<p><a id="DEP0136"></a></p>
-<h3>DEP0136: <code>http</code> <code>finished</code><span><a class="mark" href="#deprecations_dep0136_http_finished" id="deprecations_dep0136_http_finished">#</a></span></h3>
+<h4 id="DEP0135">DEP0135: <code>WriteStream.open()</code> and <code>ReadStream.open()</code> are internal<span><a class="mark" href="#deprecations_dep0135_writestream_open_and_readstream_open_are_internal" id="deprecations_dep0135_writestream_open_and_readstream_open_are_internal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.0.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Runtime</p>
+<p><a href="fs.html#fs_class_fs_writestream"><code>WriteStream.open()</code></a> and <a href="fs.html#fs_class_fs_readstream"><code>ReadStream.open()</code></a> are undocumented internal
+APIs that do not make sense to use in userland. File streams should always be
+opened through their corresponding factory methods <a href="fs.html#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>
+and <a href="fs.html#fs_fs_createreadstream_path_options"><code>fs.createReadStream()</code></a>) or by passing a file descriptor in options.</p>
+<h4 id="DEP0136">DEP0136: <code>http</code> <code>finished</code><span><a class="mark" href="#deprecations_dep0136_http_finished" id="deprecations_dep0136_http_finished">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.4.0, v12.16.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -2533,16 +2461,57 @@ an officially supported API.</p>
 called, not whether <code>'finish'</code> has been emitted and the underlying data
 is flushed.</p>
 <p>Use <a href="http.html#http_response_writablefinished"><code>response.writableFinished</code></a> or <a href="http.html#http_response_writableended"><code>response.writableEnded</code></a>
-accordingly instead to avoid the ambigiuty.</p>
+accordingly instead to avoid the ambiguity.</p>
 <p>To maintain existing behaviour <code>response.finished</code> should be replaced with
 <code>response.writableEnded</code>.</p>
-<p><a id="DEP0139"></a></p>
-<h3>DEP0139: <code>process.umask()</code> with no arguments<span><a class="mark" href="#deprecations_dep0139_process_umask_with_no_arguments" id="deprecations_dep0139_process_umask_with_no_arguments">#</a></span></h3>
+<h4 id="DEP0137">DEP0137: Closing fs.FileHandle on garbage collection<span><a class="mark" href="#deprecations_dep0137_closing_fs_filehandle_on_garbage_collection" id="deprecations_dep0137_closing_fs_filehandle_on_garbage_collection">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Runtime</p>
+<p>Allowing a <a href="fs.html#fs_class_filehandle"><code>fs.FileHandle</code></a> object to be closed on garbage collection is
+deprecated. In the future, doing so might result in a thrown error that will
+terminate the process.</p>
+<p>Please ensure that all <code>fs.FileHandle</code> objects are explicitly closed using
+<code>FileHandle.prototype.close()</code> when the <code>fs.FileHandle</code> is no longer needed:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> fsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).<span class="hljs-property">promises</span>;
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">openAndClose</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">let</span> filehandle;
+  <span class="hljs-keyword">try</span> {
+    filehandle = <span class="hljs-keyword">await</span> fsPromises.<span class="hljs-title function_">open</span>(<span class="hljs-string">'thefile.txt'</span>, <span class="hljs-string">'r'</span>);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-keyword">if</span> (filehandle !== <span class="hljs-literal">undefined</span>)
+      <span class="hljs-keyword">await</span> filehandle.<span class="hljs-title function_">close</span>();
+  }
+}</code></pre>
+<h4 id="DEP0138">DEP0138: <code>process.mainModule</code><span><a class="mark" href="#deprecations_dep0138_process_mainmodule" id="deprecations_dep0138_process_mainmodule">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p><a href="process.html#process_process_mainmodule"><code>process.mainModule</code></a> is a CommonJS-only feature while <code>process</code> global
+object is shared with non-CommonJS environment. Its use within ECMAScript
+modules is unsupported.</p>
+<p>It is deprecated in favor of <a href="modules.html#modules_accessing_the_main_module"><code>require.main</code></a>, because it serves the same
+purpose and is only available on CommonJS environment.</p>
+<h4 id="DEP0139">DEP0139: <code>process.umask()</code> with no arguments<span><a class="mark" href="#deprecations_dep0139_process_umask_with_no_arguments" id="deprecations_dep0139_process_umask_with_no_arguments">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0, v14.0.0</td>
+<tr><td>v14.0.0, v12.19.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -2552,13 +2521,64 @@ accordingly instead to avoid the ambigiuty.</p>
 written twice. This introduces a race condition between threads, and is a
 potential security vulnerability. There is no safe, cross-platform alternative
 API.</p>
-<p><a id="DEP0144"></a></p>
-<h3>DEP0144: <code>module.parent</code><span><a class="mark" href="#deprecations_dep0144_module_parent" id="deprecations_dep0144_module_parent">#</a></span></h3>
+<h4 id="DEP0140">DEP0140: Use <code>request.destroy()</code> instead of <code>request.abort()</code><span><a class="mark" href="#deprecations_dep0140_use_request_destroy_instead_of_request_abort" id="deprecations_dep0140_use_request_destroy_instead_of_request_abort">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.1.0, v13.14.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p>Use <a href="http.html#http_request_destroy_error"><code>request.destroy()</code></a> instead of <a href="http.html#http_request_abort"><code>request.abort()</code></a>.</p>
+<h4 id="DEP0141">DEP0141: <code>repl.inputStream</code> and <code>repl.outputStream</code><span><a class="mark" href="#deprecations_dep0141_repl_inputstream_and_repl_outputstream" id="deprecations_dep0141_repl_inputstream_and_repl_outputstream">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.3.0</td>
+<td><p>Documentation-only (supports [<code>--pending-deprecation</code>][]).</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only (supports <a href="cli.html#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
+<p>The <code>repl</code> module exported the input and output stream twice. Use <code>.input</code>
+instead of <code>.inputStream</code> and <code>.output</code> instead of <code>.outputStream</code>.</p>
+<h4 id="DEP0142">DEP0142: <code>repl._builtinLibs</code><span><a class="mark" href="#deprecations_dep0142_repl_builtinlibs" id="deprecations_dep0142_repl_builtinlibs">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.3.0</td>
+<td><p>Documentation-only (supports [<code>--pending-deprecation</code>][]).</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p>The <code>repl</code> module exports a <code>_builtinLibs</code> property that contains an array with
+native modules. It was incomplete so far and instead it's better to rely upon
+<code>require('module').builtinModules</code>.</p>
+<h4 id="DEP0143">DEP0143: <code>Transform._transformState</code><span><a class="mark" href="#deprecations_dep0143_transform_transformstate" id="deprecations_dep0143_transform_transformstate">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.5.0</td>
+<td><p>Runtime deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Runtime
+<code>Transform._transformState</code> will be removed in future versions where it is
+no longer required due to simplification of the implementation.</p>
+<h4 id="DEP0144">DEP0144: <code>module.parent</code><span><a class="mark" href="#deprecations_dep0144_module_parent" id="deprecations_dep0144_module_parent">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0, v14.6.0</td>
+<tr><td>v14.6.0, v12.19.0</td>
 <td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
@@ -2570,16 +2590,106 @@ consistently in the presence of ECMAScript modules and because it gives an
 inaccurate representation of the CommonJS module graph.</p>
 <p>Some modules use it to check if they are the entry point of the current process.
 Instead, it is recommended to compare <code>require.main</code> and <code>module</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (<span class="hljs-built_in">require</span>.main === <span class="hljs-built_in">module</span>) {
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (<span class="hljs-built_in">require</span>.<span class="hljs-property">main</span> === <span class="hljs-variable language_">module</span>) {
   <span class="hljs-comment">// Code section that will run only if current file is the entry point.</span>
 }</code></pre>
 <p>When looking for the CommonJS modules that have required the current one,
 <code>require.cache</code> and <code>module.children</code> can be used:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> moduleParents = <span class="hljs-built_in">Object</span>.values(<span class="hljs-built_in">require</span>.cache)
-  .filter(<span class="hljs-function">(<span class="hljs-params">m</span>) =></span> m.children.includes(<span class="hljs-built_in">module</span>));</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> moduleParents = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">values</span>(<span class="hljs-built_in">require</span>.<span class="hljs-property">cache</span>)
+  .<span class="hljs-title function_">filter</span>(<span class="hljs-function">(<span class="hljs-params">m</span>) =></span> m.<span class="hljs-property">children</span>.<span class="hljs-title function_">includes</span>(<span class="hljs-variable language_">module</span>));</code></pre>
+<h4 id="DEP0145">DEP0145: <code>socket.bufferSize</code><span><a class="mark" href="#deprecations_dep0145_socket_buffersize" id="deprecations_dep0145_socket_buffersize">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p><a href="net.html#net_socket_buffersize"><code>socket.bufferSize</code></a> is just an alias for <a href="stream.html#stream_writable_writablelength"><code>writable.writableLength</code></a>.</p>
+<h4 id="DEP0146">DEP0146: <code>new crypto.Certificate()</code><span><a class="mark" href="#deprecations_dep0146_new_crypto_certificate" id="deprecations_dep0146_new_crypto_certificate">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.9.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p>The <a href="crypto.html#crypto_legacy_api"><code>crypto.Certificate()</code> constructor</a> is deprecated. Use
+<a href="crypto.html#crypto_class_certificate">static methods of <code>crypto.Certificate()</code></a> instead.</p>
+<h4 id="DEP0147">DEP0147: <code>fs.rmdir(path, { recursive: true })</code><span><a class="mark" href="#deprecations_dep0147_fs_rmdir_path_recursive_true" id="deprecations_dep0147_fs_rmdir_path_recursive_true">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.14.0</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only</p>
+<p>In future versions of Node.js, <code>fs.rmdir(path, { recursive: true })</code> will throw
+on nonexistent paths, or when given a file as a target.
+Use <code>fs.rm(path, { recursive: true, force: true })</code> instead.</p>
+<h4 id="DEP0151">DEP0151: Main index lookup and extension searching<span><a class="mark" href="#deprecations_dep0151_main_index_lookup_and_extension_searching" id="deprecations_dep0151_main_index_lookup_and_extension_searching">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Documentation-only deprecation with <code>--pending-deprecation</code> support.</p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p>Type: Documentation-only (supports <a href="cli.html#cli_pending_deprecation"><code>--pending-deprecation</code></a>)</p>
+<p>Previously, <code>index.js</code> and extension searching lookups would apply to
+<code>import 'pkg'</code> main entry point resolution, even when resolving ES modules.</p>
+<p>With this deprecation, all ES module main entry point resolutions require
+an explicit <a href="packages.html#packages_main_entry_point_export"><code>"exports"</code> or <code>"main"</code> entry</a> with the exact file extension.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/deprecations.json b/doc/api/deprecations.json
index 14ab9454c809944c4a4671bdd2679b819b197955..566fa3f8aaac6705248b016f2833437454e50ffc 100644
--- a/doc/api/deprecations.json
+++ b/doc/api/deprecations.json
@@ -8,29 +8,33 @@
       "name": "Deprecated APIs",
       "introduced_in": "v7.7.0",
       "type": "misc",
-      "desc": "<p>Node.js may deprecate APIs for any of the following reasons:</p>\n<ul>\n<li>Use of the API is unsafe.</li>\n<li>An improved alternative API is available.</li>\n<li>Breaking changes to the API are expected in a future major release.</li>\n</ul>\n<p>Node.js utilizes three kinds of Deprecations:</p>\n<ul>\n<li>Documentation-only</li>\n<li>Runtime</li>\n<li>End-of-Life</li>\n</ul>\n<p>A Documentation-only deprecation is one that is expressed only within the\nNode.js API docs. These generate no side-effects while running Node.js.\nSome Documentation-only deprecations trigger a runtime warning when launched\nwith <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a> flag (or its alternative,\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable), similarly to Runtime\ndeprecations below. Documentation-only deprecations that support that flag\nare explicitly labeled as such in the\n<a href=\"#deprecations_list_of_deprecated_apis\">list of Deprecated APIs</a>.</p>\n<p>A Runtime deprecation will, by default, generate a process warning that will\nbe printed to <code>stderr</code> the first time the deprecated API is used. When the\n<a href=\"cli.html#cli_throw_deprecation\"><code>--throw-deprecation</code></a> command-line flag is used, a Runtime deprecation will\ncause an error to be thrown.</p>\n<p>An End-of-Life deprecation is used when functionality is or will soon be removed\nfrom Node.js.</p>",
+      "desc": "<p>Node.js APIs might be deprecated for any of the following reasons:</p>\n<ul>\n<li>Use of the API is unsafe.</li>\n<li>An improved alternative API is available.</li>\n<li>Breaking changes to the API are expected in a future major release.</li>\n</ul>\n<p>Node.js uses three kinds of Deprecations:</p>\n<ul>\n<li>Documentation-only</li>\n<li>Runtime</li>\n<li>End-of-Life</li>\n</ul>\n<p>A Documentation-only deprecation is one that is expressed only within the\nNode.js API docs. These generate no side-effects while running Node.js.\nSome Documentation-only deprecations trigger a runtime warning when launched\nwith <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a> flag (or its alternative,\n<code>NODE_PENDING_DEPRECATION=1</code> environment variable), similarly to Runtime\ndeprecations below. Documentation-only deprecations that support that flag\nare explicitly labeled as such in the\n<a href=\"#deprecations_list_of_deprecated_apis\">list of Deprecated APIs</a>.</p>\n<p>A Runtime deprecation will, by default, generate a process warning that will\nbe printed to <code>stderr</code> the first time the deprecated API is used. When the\n<a href=\"cli.html#cli_throw_deprecation\"><code>--throw-deprecation</code></a> command-line flag is used, a Runtime deprecation will\ncause an error to be thrown.</p>\n<p>An End-of-Life deprecation is used when functionality is or will soon be removed\nfrom Node.js.</p>",
       "miscs": [
         {
           "textRaw": "Revoking deprecations",
           "name": "revoking_deprecations",
-          "desc": "<p>Occasionally, the deprecation of an API may be reversed. In such situations,\nthis document will be updated with information relevant to the decision.\nHowever, the deprecation identifier will not be modified.</p>",
+          "desc": "<p>Occasionally, the deprecation of an API might be reversed. In such situations,\nthis document will be updated with information relevant to the decision.\nHowever, the deprecation identifier will not be modified.</p>",
           "type": "misc",
           "displayName": "Revoking deprecations"
         },
         {
           "textRaw": "List of deprecated APIs",
           "name": "list_of_deprecated_apis",
-          "desc": "<p><a id=\"DEP0001\"></a></p>",
           "modules": [
             {
               "textRaw": "DEP0001: `http.OutgoingMessage.prototype.flush`",
               "name": "dep0001:_`http.outgoingmessage.prototype.flush`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31164",
+                    "description": "End-of-Life."
+                  },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -42,7 +46,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>OutgoingMessage.prototype.flush()</code> method is deprecated. Use\n<code>OutgoingMessage.prototype.flushHeaders()</code> instead.</p>\n<p><a id=\"DEP0002\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>OutgoingMessage.prototype.flush()</code> has been removed. Use\n<code>OutgoingMessage.prototype.flushHeaders()</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0001: `http.OutgoingMessage.prototype.flush`"
             },
@@ -68,7 +72,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>_linklist</code> module is deprecated. Please use a userland alternative.</p>\n<p><a id=\"DEP0003\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>_linklist</code> module is deprecated. Please use a userland alternative.</p>",
               "type": "module",
               "displayName": "DEP0002: `require('_linklist')`"
             },
@@ -77,10 +81,15 @@
               "name": "dep0003:_`_writablestate.buffer`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31165",
+                    "description": "End-of-Life."
+                  },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -92,7 +101,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>_writableState.buffer</code> property is deprecated. Use the\n<code>_writableState.getBuffer()</code> method instead.</p>\n<p><a id=\"DEP0004\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>_writableState.buffer</code> has been removed. Use <code>_writableState.getBuffer()</code>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0003: `_writableState.buffer`"
             },
@@ -108,20 +117,20 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
-                    "version": "0.4.0",
+                    "version": "v0.4.0",
                     "commit": "9c7f89bf56abd37a796fea621ad2e47dd33d2b82",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>CryptoStream.prototype.readyState</code> property was removed.</p>\n<p><a id=\"DEP0005\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>CryptoStream.prototype.readyState</code> property was removed.</p>",
               "type": "module",
               "displayName": "DEP0004: `CryptoStream.prototype.readyState`"
             },
@@ -147,7 +156,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>Buffer()</code> function and <code>new Buffer()</code> constructor are deprecated due to\nAPI usability issues that can lead to accidental security issues.</p>\n<p>As an alternative, use one of the following methods of constructing <code>Buffer</code>\nobjects:</p>\n<ul>\n<li><a href=\"buffer.html#buffer_static_method_buffer_alloc_size_fill_encoding\"><code>Buffer.alloc(size[, fill[, encoding]])</code></a>: Create a <code>Buffer</code> with\n<em>initialized</em> memory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe(size)</code></a>: Create a <code>Buffer</code> with\n<em>uninitialized</em> memory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a>: Create a <code>Buffer</code> with <em>uninitialized</em>\nmemory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a>: Create a <code>Buffer</code> with a copy of <code>array</code></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a> -\nCreate a <code>Buffer</code> that wraps the given <code>arrayBuffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a>: Create a <code>Buffer</code> that copies <code>buffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a>: Create a <code>Buffer</code>\nthat copies <code>string</code>.</li>\n</ul>\n<p>Without <code>--pending-deprecation</code>, runtime warnings occur only for code not in\n<code>node_modules</code>. This means there will not be deprecation warnings for\n<code>Buffer()</code> usage in dependencies. With <code>--pending-deprecation</code>, a runtime\nwarning results no matter where the <code>Buffer()</code> usage occurs.</p>\n<p><a id=\"DEP0006\"></a></p>",
+              "desc": "<p>Type: Runtime (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>Buffer()</code> function and <code>new Buffer()</code> constructor are deprecated due to\nAPI usability issues that can lead to accidental security issues.</p>\n<p>As an alternative, use one of the following methods of constructing <code>Buffer</code>\nobjects:</p>\n<ul>\n<li><a href=\"buffer.html#buffer_static_method_buffer_alloc_size_fill_encoding\"><code>Buffer.alloc(size[, fill[, encoding]])</code></a>: Create a <code>Buffer</code> with\n<em>initialized</em> memory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer.allocUnsafe(size)</code></a>: Create a <code>Buffer</code> with\n<em>uninitialized</em> memory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a>: Create a <code>Buffer</code> with <em>uninitialized</em>\nmemory.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_array\"><code>Buffer.from(array)</code></a>: Create a <code>Buffer</code> with a copy of <code>array</code></li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length\"><code>Buffer.from(arrayBuffer[, byteOffset[, length]])</code></a> -\nCreate a <code>Buffer</code> that wraps the given <code>arrayBuffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_buffer\"><code>Buffer.from(buffer)</code></a>: Create a <code>Buffer</code> that copies <code>buffer</code>.</li>\n<li><a href=\"buffer.html#buffer_static_method_buffer_from_string_encoding\"><code>Buffer.from(string[, encoding])</code></a>: Create a <code>Buffer</code>\nthat copies <code>string</code>.</li>\n</ul>\n<p>Without <code>--pending-deprecation</code>, runtime warnings occur only for code not in\n<code>node_modules</code>. This means there will not be deprecation warnings for\n<code>Buffer()</code> usage in dependencies. With <code>--pending-deprecation</code>, a runtime\nwarning results no matter where the <code>Buffer()</code> usage occurs.</p>",
               "type": "module",
               "displayName": "DEP0005: `Buffer()` constructor"
             },
@@ -163,8 +172,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -174,12 +183,12 @@
                     "description": "Runtime deprecation."
                   },
                   {
-                    "version": "v0.5.11",
+                    "version": "v0.5.10",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Within the <a href=\"child_process.html\"><code>child_process</code></a> module's <code>spawn()</code>, <code>fork()</code>, and <code>exec()</code>\nmethods, the <code>options.customFds</code> option is deprecated. The <code>options.stdio</code>\noption should be used instead.</p>\n<p><a id=\"DEP0007\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Within the <a href=\"child_process.html\"><code>child_process</code></a> module's <code>spawn()</code>, <code>fork()</code>, and <code>exec()</code>\nmethods, the <code>options.customFds</code> option is deprecated. The <code>options.stdio</code>\noption should be used instead.</p>",
               "type": "module",
               "displayName": "DEP0006: `child_process` `options.customFds`"
             },
@@ -210,7 +219,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>In an earlier version of the Node.js <code>cluster</code>, a boolean property with the name\n<code>suicide</code> was added to the <code>Worker</code> object. The intent of this property was to\nprovide an indication of how and why the <code>Worker</code> instance exited. In Node.js\n6.0.0, the old property was deprecated and replaced with a new\n<a href=\"cluster.html#cluster_worker_exitedafterdisconnect\"><code>worker.exitedAfterDisconnect</code></a> property. The old property name did not\nprecisely describe the actual semantics and was unnecessarily emotion-laden.</p>\n<p><a id=\"DEP0008\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>In an earlier version of the Node.js <code>cluster</code>, a boolean property with the name\n<code>suicide</code> was added to the <code>Worker</code> object. The intent of this property was to\nprovide an indication of how and why the <code>Worker</code> instance exited. In Node.js\n6.0.0, the old property was deprecated and replaced with a new\n<a href=\"cluster.html#cluster_worker_exitedafterdisconnect\"><code>worker.exitedAfterDisconnect</code></a> property. The old property name did not\nprecisely describe the actual semantics and was unnecessarily emotion-laden.</p>",
               "type": "module",
               "displayName": "DEP0007: Replace `cluster` `worker.suicide` with `worker.exitedAfterDisconnect`"
             },
@@ -231,7 +240,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>constants</code> module is deprecated. When requiring access to constants\nrelevant to specific Node.js builtin modules, developers should instead refer\nto the <code>constants</code> property exposed by the relevant module. For instance,\n<code>require('fs').constants</code> and <code>require('os').constants</code>.</p>\n<p><a id=\"DEP0009\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>constants</code> module is deprecated. When requiring access to constants\nrelevant to specific Node.js builtin modules, developers should instead refer\nto the <code>constants</code> property exposed by the relevant module. For instance,\n<code>require('fs').constants</code> and <code>require('os').constants</code>.</p>",
               "type": "module",
               "displayName": "DEP0008: `require('constants')`"
             },
@@ -240,6 +249,11 @@
               "name": "dep0009:_`crypto.pbkdf2`_without_digest",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31166",
+                    "description": "End-of-Life (for `digest === null`)."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22861",
@@ -262,7 +276,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Use of the <a href=\"crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback\"><code>crypto.pbkdf2()</code></a> API without specifying a digest was deprecated\nin Node.js 6.0 because the method defaulted to using the non-recommended\n<code>'SHA1'</code> digest. Previously, a deprecation warning was printed. Starting in\nNode.js 8.0.0, calling <code>crypto.pbkdf2()</code> or <code>crypto.pbkdf2Sync()</code> with\n<code>digest</code> set to <code>undefined</code> will throw a <code>TypeError</code>.</p>\n<p>Beginning in Node.js v11.0.0, calling these functions with <code>digest</code> set to\n<code>null</code> will print a deprecation warning to align with the behavior when <code>digest</code>\nis <code>undefined</code>.</p>\n<p><a id=\"DEP0010\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Use of the <a href=\"crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback\"><code>crypto.pbkdf2()</code></a> API without specifying a digest was deprecated\nin Node.js 6.0 because the method defaulted to using the non-recommended\n<code>'SHA1'</code> digest. Previously, a deprecation warning was printed. Starting in\nNode.js 8.0.0, calling <code>crypto.pbkdf2()</code> or <code>crypto.pbkdf2Sync()</code> with\n<code>digest</code> set to <code>undefined</code> will throw a <code>TypeError</code>.</p>\n<p>Beginning in Node.js v11.0.0, calling these functions with <code>digest</code> set to\n<code>null</code> would print a deprecation warning to align with the behavior when <code>digest</code>\nis <code>undefined</code>.</p>\n<p>Now, however, passing either <code>undefined</code> or <code>null</code> will throw a <code>TypeError</code>.</p>",
               "type": "module",
               "displayName": "DEP0009: `crypto.pbkdf2` without digest"
             },
@@ -278,8 +292,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -291,7 +305,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto.createCredentials()</code> API was removed. Please use\n<a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.createSecureContext()</code></a> instead.</p>\n<p><a id=\"DEP0011\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto.createCredentials()</code> API was removed. Please use\n<a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.createSecureContext()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0010: `crypto.createCredentials`"
             },
@@ -307,8 +321,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -320,7 +334,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto.Credentials</code> class was removed. Please use <a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.SecureContext</code></a>\ninstead.</p>\n<p><a id=\"DEP0012\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto.Credentials</code> class was removed. Please use <a href=\"tls.html#tls_tls_createsecurecontext_options\"><code>tls.SecureContext</code></a>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0011: `crypto.Credentials`"
             },
@@ -336,8 +350,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -349,7 +363,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>Domain.dispose()</code> has been removed. Recover from failed I/O actions\nexplicitly via error event handlers set on the domain instead.</p>\n<p><a id=\"DEP0013\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>Domain.dispose()</code> has been removed. Recover from failed I/O actions\nexplicitly via error event handlers set on the domain instead.</p>",
               "type": "module",
               "displayName": "DEP0012: `Domain.dispose`"
             },
@@ -370,7 +384,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Calling an asynchronous function without a callback throws a <code>TypeError</code>\nin Node.js 10.0.0 onwards. See <a href=\"https://github.com/nodejs/node/pull/12562\">https://github.com/nodejs/node/pull/12562</a>.</p>\n<p><a id=\"DEP0014\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Calling an asynchronous function without a callback throws a <code>TypeError</code>\nin Node.js 10.0.0 onwards. See <a href=\"https://github.com/nodejs/node/pull/12562\">https://github.com/nodejs/node/pull/12562</a>.</p>",
               "type": "module",
               "displayName": "DEP0013: `fs` asynchronous function without callback"
             },
@@ -384,19 +398,19 @@
                     "pr-url": "https://github.com/nodejs/node/pull/9683",
                     "description": "End-of-Life."
                   },
-                  {
-                    "version": "v6.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/4525",
-                    "description": "Runtime deprecation."
-                  },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4525",
+                    "description": "Runtime deprecation."
+                  },
                   {
                     "version": "v0.1.96",
                     "commit": "c93e0aaf062081db3ec40ac45b3e2c979d5759d6",
@@ -404,7 +418,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a> legacy <code>String</code> interface is deprecated. Use the <code>Buffer</code>\nAPI as mentioned in the documentation instead.</p>\n<p><a id=\"DEP0015\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"fs.html#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a> legacy <code>String</code> interface is deprecated. Use the <code>Buffer</code>\nAPI as mentioned in the documentation instead.</p>",
               "type": "module",
               "displayName": "DEP0014: `fs.read` legacy String interface"
             },
@@ -418,19 +432,19 @@
                     "pr-url": "https://github.com/nodejs/node/pull/9683",
                     "description": "End-of-Life."
                   },
-                  {
-                    "version": "v6.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/4525",
-                    "description": "Runtime deprecation."
-                  },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4525",
+                    "description": "Runtime deprecation."
+                  },
                   {
                     "version": "v0.1.96",
                     "commit": "c93e0aaf062081db3ec40ac45b3e2c979d5759d6",
@@ -438,7 +452,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"fs.html#fs_fs_readsync_fd_buffer_offset_length_position\"><code>fs.readSync()</code></a> legacy <code>String</code> interface is deprecated. Use the\n<code>Buffer</code> API as mentioned in the documentation instead.</p>\n<p><a id=\"DEP0016\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"fs.html#fs_fs_readsync_fd_buffer_offset_length_position\"><code>fs.readSync()</code></a> legacy <code>String</code> interface is deprecated. Use the\n<code>Buffer</code> API as mentioned in the documentation instead.</p>",
               "type": "module",
               "displayName": "DEP0015: `fs.readSync` legacy String interface"
             },
@@ -447,6 +461,11 @@
               "name": "dep0016:_`global`/`root`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31167",
+                    "description": "End-of-Life."
+                  },
                   {
                     "version": "v6.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
@@ -459,7 +478,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>GLOBAL</code> and <code>root</code> aliases for the <code>global</code> property are deprecated\nand should no longer be used.</p>\n<p><a id=\"DEP0017\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>GLOBAL</code> and <code>root</code> aliases for the <code>global</code> property were deprecated\nin Node.js 6.0.0 and have since been removed.</p>",
               "type": "module",
               "displayName": "DEP0016: `GLOBAL`/`root`"
             },
@@ -480,7 +499,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>Intl.v8BreakIterator</code> was a non-standard extension and has been removed.\nSee <a href=\"https://github.com/tc39/proposal-intl-segmenter\"><code>Intl.Segmenter</code></a>.</p>\n<p><a id=\"DEP0018\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>Intl.v8BreakIterator</code> was a non-standard extension and has been removed.\nSee <a href=\"https://github.com/tc39/proposal-intl-segmenter\"><code>Intl.Segmenter</code></a>.</p>",
               "type": "module",
               "displayName": "DEP0017: `Intl.v8BreakIterator`"
             },
@@ -496,7 +515,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Unhandled promise rejections are deprecated. In the future, promise rejections\nthat are not handled will terminate the Node.js process with a non-zero exit\ncode.</p>\n<p><a id=\"DEP0019\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Unhandled promise rejections are deprecated. In the future, promise rejections\nthat are not handled will terminate the Node.js process with a non-zero exit\ncode.</p>",
               "type": "module",
               "displayName": "DEP0018: Unhandled promise rejections"
             },
@@ -512,8 +531,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -525,7 +544,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>In certain cases, <code>require('.')</code> could resolve outside the package directory.\nThis behavior has been removed.</p>\n<p><a id=\"DEP0020\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>In certain cases, <code>require('.')</code> could resolve outside the package directory.\nThis behavior has been removed.</p>",
               "type": "module",
               "displayName": "DEP0019: `require('.')` resolved outside directory"
             },
@@ -536,8 +555,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -549,7 +568,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <a href=\"net.html#net_server_connections\"><code>Server.connections</code></a> property is deprecated. Please use the\n<a href=\"net.html#net_server_getconnections_callback\"><code>Server.getConnections()</code></a> method instead.</p>\n<p><a id=\"DEP0021\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <a href=\"net.html#net_server_connections\"><code>Server.connections</code></a> property is deprecated. Please use the\n<a href=\"net.html#net_server_getconnections_callback\"><code>Server.getConnections()</code></a> method instead.</p>",
               "type": "module",
               "displayName": "DEP0020: `Server.connections`"
             },
@@ -565,8 +584,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -578,7 +597,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>Server.listenFD()</code> method was deprecated and removed. Please use\n<a href=\"net.html#net_server_listen_handle_backlog_callback\"><code>Server.listen({fd: &#x3C;number>})</code></a> instead.</p>\n<p><a id=\"DEP0022\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>Server.listenFD()</code> method was deprecated and removed. Please use\n<a href=\"net.html#net_server_listen_handle_backlog_callback\"><code>Server.listen({fd: &#x3C;number>})</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0021: `Server.listenFD`"
             },
@@ -587,6 +606,11 @@
               "name": "dep0022:_`os.tmpdir()`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31169",
+                    "description": "End-of-Life."
+                  },
                   {
                     "version": "v7.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/6739",
@@ -594,7 +618,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>os.tmpDir()</code> API is deprecated. Please use <a href=\"os.html#os_os_tmpdir\"><code>os.tmpdir()</code></a> instead.</p>\n<p><a id=\"DEP0023\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>os.tmpDir()</code> API was deprecated in Node.js 7.0.0 and has since been\nremoved. Please use <a href=\"os.html#os_os_tmpdir\"><code>os.tmpdir()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0022: `os.tmpDir()`"
             },
@@ -610,8 +634,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -623,7 +647,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>os.getNetworkInterfaces()</code> method is deprecated. Please use the\n<a href=\"os.html#os_os_networkinterfaces\"><code>os.networkInterfaces()</code></a> method instead.</p>\n<p><a id=\"DEP0024\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>os.getNetworkInterfaces()</code> method is deprecated. Please use the\n<a href=\"os.html#os_os_networkinterfaces\"><code>os.networkInterfaces()</code></a> method instead.</p>",
               "type": "module",
               "displayName": "DEP0023: `os.getNetworkInterfaces()`"
             },
@@ -644,7 +668,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>REPLServer.prototype.convertToContext()</code> API has been removed.</p>\n<p><a id=\"DEP0025\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>REPLServer.prototype.convertToContext()</code> API has been removed.</p>",
               "type": "module",
               "displayName": "DEP0024: `REPLServer.prototype.convertToContext()`"
             },
@@ -655,8 +679,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -668,7 +692,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>sys</code> module is deprecated. Please use the <a href=\"util.html\"><code>util</code></a> module instead.</p>\n<p><a id=\"DEP0026\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>sys</code> module is deprecated. Please use the <a href=\"util.html\"><code>util</code></a> module instead.</p>",
               "type": "module",
               "displayName": "DEP0025: `require('sys')`"
             },
@@ -684,8 +708,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -697,7 +721,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.print()</code> has been removed. Please use <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> instead.</p>\n<p><a id=\"DEP0027\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.print()</code> has been removed. Please use <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0026: `util.print()`"
             },
@@ -713,8 +737,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -726,7 +750,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.puts()</code> has been removed. Please use <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> instead.</p>\n<p><a id=\"DEP0028\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.puts()</code> has been removed. Please use <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0027: `util.puts()`"
             },
@@ -742,8 +766,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -755,7 +779,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.debug()</code> has been removed. Please use <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a> instead.</p>\n<p><a id=\"DEP0029\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.debug()</code> has been removed. Please use <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0028: `util.debug()`"
             },
@@ -771,8 +795,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -784,7 +808,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.error()</code> has been removed. Please use <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a> instead.</p>\n<p><a id=\"DEP0030\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>util.error()</code> has been removed. Please use <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0029: `util.error()`"
             },
@@ -805,7 +829,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"buffer.html#buffer_class_slowbuffer\"><code>SlowBuffer</code></a> class is deprecated. Please use\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a> instead.</p>\n<p><a id=\"DEP0031\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"buffer.html#buffer_class_slowbuffer\"><code>SlowBuffer</code></a> class is deprecated. Please use\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafeslow_size\"><code>Buffer.allocUnsafeSlow(size)</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0030: `SlowBuffer`"
             },
@@ -826,7 +850,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_ecdh_setpublickey_publickey_encoding\"><code>ecdh.setPublicKey()</code></a> method is now deprecated as its inclusion in the\nAPI is not useful.</p>\n<p><a id=\"DEP0032\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_ecdh_setpublickey_publickey_encoding\"><code>ecdh.setPublicKey()</code></a> method is now deprecated as its inclusion in the\nAPI is not useful.</p>",
               "type": "module",
               "displayName": "DEP0031: `ecdh.setPublicKey()`"
             },
@@ -837,8 +861,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -850,7 +874,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"domain.html\"><code>domain</code></a> module is deprecated and should not be used.</p>\n<p><a id=\"DEP0033\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"domain.html\"><code>domain</code></a> module is deprecated and should not be used.</p>",
               "type": "module",
               "displayName": "DEP0032: `domain` module"
             },
@@ -861,8 +885,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -874,7 +898,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"events.html#events_eventemitter_listenercount_emitter_eventname\"><code>EventEmitter.listenerCount(emitter, eventName)</code></a> API is\ndeprecated. Please use <a href=\"events.html#events_emitter_listenercount_eventname\"><code>emitter.listenerCount(eventName)</code></a> instead.</p>\n<p><a id=\"DEP0034\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"events.html#events_events_listenercount_emitter_eventname\"><code>events.listenerCount(emitter, eventName)</code></a> API is\ndeprecated. Please use <a href=\"events.html#events_emitter_listenercount_eventname\"><code>emitter.listenerCount(eventName)</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0033: `EventEmitter.listenerCount()`"
             },
@@ -885,20 +909,20 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": "v1.0.0",
-                    "pr-url": "https://github.com/iojs/io.js/pull/166",
+                    "pr-url": "https://github.com/nodejs/node/pull/166",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_exists_path_callback\"><code>fs.exists(path, callback)</code></a> API is deprecated. Please use\n<a href=\"fs.html#fs_fs_stat_path_options_callback\"><code>fs.stat()</code></a> or <a href=\"fs.html#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a> instead.</p>\n<p><a id=\"DEP0035\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_exists_path_callback\"><code>fs.exists(path, callback)</code></a> API is deprecated. Please use\n<a href=\"fs.html#fs_fs_stat_path_options_callback\"><code>fs.stat()</code></a> or <a href=\"fs.html#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0034: `fs.exists(path, callback)`"
             },
@@ -909,8 +933,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -921,7 +945,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_lchmod_path_mode_callback\"><code>fs.lchmod(path, mode, callback)</code></a> API is deprecated.</p>\n<p><a id=\"DEP0036\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_lchmod_path_mode_callback\"><code>fs.lchmod(path, mode, callback)</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0035: `fs.lchmod(path, mode, callback)`"
             },
@@ -932,8 +956,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -944,7 +968,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_lchmodsync_path_mode\"><code>fs.lchmodSync(path, mode)</code></a> API is deprecated.</p>\n<p><a id=\"DEP0037\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"fs.html#fs_fs_lchmodsync_path_mode\"><code>fs.lchmodSync(path, mode)</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0036: `fs.lchmodSync(path, mode)`"
             },
@@ -960,8 +984,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -972,7 +996,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"fs.html#fs_fs_lchown_path_uid_gid_callback\"><code>fs.lchown(path, uid, gid, callback)</code></a> API was deprecated. The\ndeprecation was revoked because the requisite supporting APIs were added in\nlibuv.</p>\n<p><a id=\"DEP0038\"></a></p>",
+              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"fs.html#fs_fs_lchown_path_uid_gid_callback\"><code>fs.lchown(path, uid, gid, callback)</code></a> API was deprecated. The\ndeprecation was revoked because the requisite supporting APIs were added in\nlibuv.</p>",
               "type": "module",
               "displayName": "DEP0037: `fs.lchown(path, uid, gid, callback)`"
             },
@@ -988,8 +1012,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -1000,7 +1024,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"fs.html#fs_fs_lchownsync_path_uid_gid\"><code>fs.lchownSync(path, uid, gid)</code></a> API was deprecated. The deprecation was\nrevoked because the requisite supporting APIs were added in libuv.</p>\n<p><a id=\"DEP0039\"></a></p>",
+              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"fs.html#fs_fs_lchownsync_path_uid_gid\"><code>fs.lchownSync(path, uid, gid)</code></a> API was deprecated. The deprecation was\nrevoked because the requisite supporting APIs were added in libuv.</p>",
               "type": "module",
               "displayName": "DEP0038: `fs.lchownSync(path, uid, gid)`"
             },
@@ -1011,8 +1035,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -1024,7 +1048,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"modules.html#modules_require_extensions\"><code>require.extensions</code></a> property is deprecated.</p>\n<p><a id=\"DEP0040\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"modules.html#modules_require_extensions\"><code>require.extensions</code></a> property is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0039: `require.extensions`"
             },
@@ -1040,7 +1064,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"punycode.html\"><code>punycode</code></a> module is deprecated. Please use a userland alternative\ninstead.</p>\n<p><a id=\"DEP0041\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"punycode.html\"><code>punycode</code></a> module is deprecated. Please use a userland alternative\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0040: `punycode` module"
             },
@@ -1056,8 +1080,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -1069,7 +1093,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>NODE_REPL_HISTORY_FILE</code> environment variable was removed. Please use\n<code>NODE_REPL_HISTORY</code> instead.</p>\n<p><a id=\"DEP0042\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>NODE_REPL_HISTORY_FILE</code> environment variable was removed. Please use\n<code>NODE_REPL_HISTORY</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0041: `NODE_REPL_HISTORY_FILE` environment variable"
             },
@@ -1085,8 +1109,8 @@
                   },
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
@@ -1098,7 +1122,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"tls.html#tls_class_tls_cryptostream\"><code>tls.CryptoStream</code></a> class was removed. Please use\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a> instead.</p>\n<p><a id=\"DEP0043\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <a href=\"tls.html#tls_class_tls_cryptostream\"><code>tls.CryptoStream</code></a> class was removed. Please use\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0042: `tls.CryptoStream`"
             },
@@ -1137,7 +1161,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"tls.html#tls_class_tls_securepair\"><code>tls.SecurePair</code></a> class is deprecated. Please use\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a> instead.</p>\n<p><a id=\"DEP0044\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"tls.html#tls_class_tls_securepair\"><code>tls.SecurePair</code></a> class is deprecated. Please use\n<a href=\"tls.html#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0043: `tls.SecurePair`"
             },
@@ -1148,23 +1172,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isarray_object\"><code>util.isArray()</code></a> API is deprecated. Please use <code>Array.isArray()</code>\ninstead.</p>\n<p><a id=\"DEP0045\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isarray_object\"><code>util.isArray()</code></a> API is deprecated. Please use <code>Array.isArray()</code>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0044: `util.isArray()`"
             },
@@ -1175,23 +1199,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isboolean_object\"><code>util.isBoolean()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0046\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isboolean_object\"><code>util.isBoolean()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0045: `util.isBoolean()`"
             },
@@ -1202,23 +1226,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isbuffer_object\"><code>util.isBuffer()</code></a> API is deprecated. Please use\n<a href=\"buffer.html#buffer_static_method_buffer_isbuffer_obj\"><code>Buffer.isBuffer()</code></a> instead.</p>\n<p><a id=\"DEP0047\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isbuffer_object\"><code>util.isBuffer()</code></a> API is deprecated. Please use\n<a href=\"buffer.html#buffer_static_method_buffer_isbuffer_obj\"><code>Buffer.isBuffer()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0046: `util.isBuffer()`"
             },
@@ -1229,23 +1253,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isdate_object\"><code>util.isDate()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0048\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isdate_object\"><code>util.isDate()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0047: `util.isDate()`"
             },
@@ -1256,23 +1280,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_iserror_object\"><code>util.isError()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0049\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_iserror_object\"><code>util.isError()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0048: `util.isError()`"
             },
@@ -1283,23 +1307,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isfunction_object\"><code>util.isFunction()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0050\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isfunction_object\"><code>util.isFunction()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0049: `util.isFunction()`"
             },
@@ -1310,23 +1334,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnull_object\"><code>util.isNull()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0051\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnull_object\"><code>util.isNull()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0050: `util.isNull()`"
             },
@@ -1337,23 +1361,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnullorundefined_object\"><code>util.isNullOrUndefined()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0052\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnullorundefined_object\"><code>util.isNullOrUndefined()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0051: `util.isNullOrUndefined()`"
             },
@@ -1364,52 +1388,52 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnumber_object\"><code>util.isNumber()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0053\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isnumber_object\"><code>util.isNumber()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0052: `util.isNumber()`"
             },
             {
-              "textRaw": "DEP0053 `util.isObject()`",
-              "name": "dep0053_`util.isobject()`",
+              "textRaw": "DEP0053: `util.isObject()`",
+              "name": "dep0053:_`util.isobject()`",
               "meta": {
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isobject_object\"><code>util.isObject()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0054\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isobject_object\"><code>util.isObject()</code></a> API is deprecated.</p>",
               "type": "module",
-              "displayName": "DEP0053 `util.isObject()`"
+              "displayName": "DEP0053: `util.isObject()`"
             },
             {
               "textRaw": "DEP0054: `util.isPrimitive()`",
@@ -1418,23 +1442,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isprimitive_object\"><code>util.isPrimitive()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0055\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isprimitive_object\"><code>util.isPrimitive()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0054: `util.isPrimitive()`"
             },
@@ -1445,23 +1469,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isregexp_object\"><code>util.isRegExp()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0056\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isregexp_object\"><code>util.isRegExp()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0055: `util.isRegExp()`"
             },
@@ -1472,23 +1496,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isstring_object\"><code>util.isString()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0057\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isstring_object\"><code>util.isString()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0056: `util.isString()`"
             },
@@ -1499,23 +1523,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_issymbol_object\"><code>util.isSymbol()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0058\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_issymbol_object\"><code>util.isSymbol()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0057: `util.isSymbol()`"
             },
@@ -1526,23 +1550,23 @@
                 "changes": [
                   {
                     "version": [
-                      "v4.8.6",
-                      "v6.12.0"
+                      "v6.12.0",
+                      "v4.8.6"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/10116",
                     "description": "A deprecation code has been assigned."
                   },
                   {
                     "version": [
-                      "v3.3.1",
-                      "v4.0.0"
+                      "v4.0.0",
+                      "v3.3.1"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/2447",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isundefined_object\"><code>util.isUndefined()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0059\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_isundefined_object\"><code>util.isUndefined()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0058: `util.isUndefined()`"
             },
@@ -1563,7 +1587,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_log_string\"><code>util.log()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0060\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_log_string\"><code>util.log()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0059: `util.log()`"
             },
@@ -1584,7 +1608,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_extend_target_source\"><code>util._extend()</code></a> API is deprecated.</p>\n<p><a id=\"DEP0061\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"util.html#util_util_extend_target_source\"><code>util._extend()</code></a> API is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0060: `util._extend()`"
             },
@@ -1610,7 +1634,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>fs.SyncWriteStream</code> class was never intended to be a publicly accessible\nAPI and has been removed. No alternative API is available. Please use a userland\nalternative.</p>\n<p><a id=\"DEP0062\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>fs.SyncWriteStream</code> class was never intended to be a publicly accessible\nAPI and has been removed. No alternative API is available. Please use a userland\nalternative.</p>",
               "type": "module",
               "displayName": "DEP0061: `fs.SyncWriteStream`"
             },
@@ -1619,19 +1643,19 @@
               "name": "dep0062:_`node_--debug`",
               "meta": {
                 "changes": [
-                  {
-                    "version": "v8.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/10970",
-                    "description": "Runtime deprecation."
-                  },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/25828",
                     "description": "End-of-Life."
+                  },
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10970",
+                    "description": "Runtime deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>--debug</code> activates the legacy V8 debugger interface, which was removed as\nof V8 5.8. It is replaced by Inspector which is activated with <code>--inspect</code>\ninstead.</p>\n<p><a id=\"DEP0063\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>--debug</code> activates the legacy V8 debugger interface, which was removed as\nof V8 5.8. It is replaced by Inspector which is activated with <code>--inspect</code>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0062: `node --debug`"
             },
@@ -1647,7 +1671,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>http</code> module <code>ServerResponse.prototype.writeHeader()</code> API is\ndeprecated. Please use <code>ServerResponse.prototype.writeHead()</code> instead.</p>\n<p>The <code>ServerResponse.prototype.writeHeader()</code> method was never documented as an\nofficially supported API.</p>\n<p><a id=\"DEP0064\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>http</code> module <code>ServerResponse.prototype.writeHeader()</code> API is\ndeprecated. Please use <code>ServerResponse.prototype.writeHead()</code> instead.</p>\n<p>The <code>ServerResponse.prototype.writeHeader()</code> method was never documented as an\nofficially supported API.</p>",
               "type": "module",
               "displayName": "DEP0063: `ServerResponse.prototype.writeHeader()`"
             },
@@ -1686,7 +1710,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>tls.createSecurePair()</code> API was deprecated in documentation in Node.js\n0.11.3. Users should use <code>tls.Socket</code> instead.</p>\n<p><a id=\"DEP0065\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>tls.createSecurePair()</code> API was deprecated in documentation in Node.js\n0.11.3. Users should use <code>tls.Socket</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0064: `tls.createSecurePair()`"
             },
@@ -1707,7 +1731,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>repl</code> module's <code>REPL_MODE_MAGIC</code> constant, used for <code>replMode</code> option, has\nbeen removed. Its behavior has been functionally identical to that of\n<code>REPL_MODE_SLOPPY</code> since Node.js 6.0.0, when V8 5.0 was imported. Please use\n<code>REPL_MODE_SLOPPY</code> instead.</p>\n<p>The <code>NODE_REPL_MODE</code> environment variable is used to set the underlying\n<code>replMode</code> of an interactive <code>node</code> session. Its value, <code>magic</code>, is also\nremoved. Please use <code>sloppy</code> instead.</p>\n<p><a id=\"DEP0066\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>repl</code> module's <code>REPL_MODE_MAGIC</code> constant, used for <code>replMode</code> option, has\nbeen removed. Its behavior has been functionally identical to that of\n<code>REPL_MODE_SLOPPY</code> since Node.js 6.0.0, when V8 5.0 was imported. Please use\n<code>REPL_MODE_SLOPPY</code> instead.</p>\n<p>The <code>NODE_REPL_MODE</code> environment variable is used to set the underlying\n<code>replMode</code> of an interactive <code>node</code> session. Its value, <code>magic</code>, is also\nremoved. Please use <code>sloppy</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0065: `repl.REPL_MODE_MAGIC` and `NODE_REPL_MODE=magic`"
             },
@@ -1728,7 +1752,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>http</code> module <code>OutgoingMessage.prototype._headers</code> and\n<code>OutgoingMessage.prototype._headerNames</code> properties are deprecated. Use one of\nthe public methods (e.g. <code>OutgoingMessage.prototype.getHeader()</code>,\n<code>OutgoingMessage.prototype.getHeaders()</code>,\n<code>OutgoingMessage.prototype.getHeaderNames()</code>,\n<code>OutgoingMessage.prototype.hasHeader()</code>,\n<code>OutgoingMessage.prototype.removeHeader()</code>,\n<code>OutgoingMessage.prototype.setHeader()</code>) for working with outgoing headers.</p>\n<p>The <code>OutgoingMessage.prototype._headers</code> and\n<code>OutgoingMessage.prototype._headerNames</code> properties were never documented as\nofficially supported properties.</p>\n<p><a id=\"DEP0067\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>http</code> module <code>OutgoingMessage.prototype._headers</code> and\n<code>OutgoingMessage.prototype._headerNames</code> properties are deprecated. Use one of\nthe public methods (e.g. <code>OutgoingMessage.prototype.getHeader()</code>,\n<code>OutgoingMessage.prototype.getHeaders()</code>,\n<code>OutgoingMessage.prototype.getHeaderNames()</code>,\n<code>OutgoingMessage.prototype.getRawHeaderNames()</code>,\n<code>OutgoingMessage.prototype.hasHeader()</code>,\n<code>OutgoingMessage.prototype.removeHeader()</code>,\n<code>OutgoingMessage.prototype.setHeader()</code>) for working with outgoing headers.</p>\n<p>The <code>OutgoingMessage.prototype._headers</code> and\n<code>OutgoingMessage.prototype._headerNames</code> properties were never documented as\nofficially supported properties.</p>",
               "type": "module",
               "displayName": "DEP0066: `OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames`"
             },
@@ -1744,7 +1768,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>http</code> module <code>OutgoingMessage.prototype._renderHeaders()</code> API is\ndeprecated.</p>\n<p>The <code>OutgoingMessage.prototype._renderHeaders</code> property was never documented as\nan officially supported API.</p>\n<p><a id=\"DEP0068\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>http</code> module <code>OutgoingMessage.prototype._renderHeaders()</code> API is\ndeprecated.</p>\n<p>The <code>OutgoingMessage.prototype._renderHeaders</code> property was never documented as\nan officially supported API.</p>",
               "type": "module",
               "displayName": "DEP0067: `OutgoingMessage.prototype._renderHeaders`"
             },
@@ -1760,7 +1784,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>node debug</code> corresponds to the legacy CLI debugger which has been replaced with\na V8-inspector based CLI debugger available through <code>node inspect</code>.</p>\n<p><a id=\"DEP0069\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>node debug</code> corresponds to the legacy CLI debugger which has been replaced with\na V8-inspector based CLI debugger available through <code>node inspect</code>.</p>",
               "type": "module",
               "displayName": "DEP0068: `node debug`"
             },
@@ -1786,7 +1810,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>DebugContext has been removed in V8 and is not available in Node.js 10+.</p>\n<p>DebugContext was an experimental API.</p>\n<p><a id=\"DEP0070\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>DebugContext has been removed in V8 and is not available in Node.js 10+.</p>\n<p>DebugContext was an experimental API.</p>",
               "type": "module",
               "displayName": "DEP0069: `vm.runInDebugContext(string)`"
             },
@@ -1807,7 +1831,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.currentId()</code> was renamed to <code>async_hooks.executionAsyncId()</code> for\nclarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>\n<p><a id=\"DEP0071\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.currentId()</code> was renamed to <code>async_hooks.executionAsyncId()</code> for\nclarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>",
               "type": "module",
               "displayName": "DEP0070: `async_hooks.currentId()`"
             },
@@ -1828,7 +1852,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.triggerId()</code> was renamed to <code>async_hooks.triggerAsyncId()</code> for\nclarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>\n<p><a id=\"DEP0072\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.triggerId()</code> was renamed to <code>async_hooks.triggerAsyncId()</code> for\nclarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>",
               "type": "module",
               "displayName": "DEP0071: `async_hooks.triggerId()`"
             },
@@ -1849,7 +1873,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.AsyncResource.triggerId()</code> was renamed to\n<code>async_hooks.AsyncResource.triggerAsyncId()</code> for clarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>\n<p><a id=\"DEP0073\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>async_hooks.AsyncResource.triggerId()</code> was renamed to\n<code>async_hooks.AsyncResource.triggerAsyncId()</code> for clarity.</p>\n<p>This change was made while <code>async_hooks</code> was an experimental API.</p>",
               "type": "module",
               "displayName": "DEP0072: `async_hooks.AsyncResource.triggerId()`"
             },
@@ -1870,7 +1894,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Accessing several internal, undocumented properties of <code>net.Server</code> instances\nwith inappropriate names is deprecated.</p>\n<p>As the original API was undocumented and not generally useful for non-internal\ncode, no replacement API is provided.</p>\n<p><a id=\"DEP0074\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Accessing several internal, undocumented properties of <code>net.Server</code> instances\nwith inappropriate names is deprecated.</p>\n<p>As the original API was undocumented and not generally useful for non-internal\ncode, no replacement API is provided.</p>",
               "type": "module",
               "displayName": "DEP0073: Several internal properties of `net.Server`"
             },
@@ -1886,7 +1910,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>REPLServer.bufferedCommand</code> property was deprecated in favor of\n<a href=\"repl.html#repl_replserver_clearbufferedcommand\"><code>REPLServer.clearBufferedCommand()</code></a>.</p>\n<p><a id=\"DEP0075\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>REPLServer.bufferedCommand</code> property was deprecated in favor of\n<a href=\"repl.html#repl_replserver_clearbufferedcommand\"><code>REPLServer.clearBufferedCommand()</code></a>.</p>",
               "type": "module",
               "displayName": "DEP0074: `REPLServer.bufferedCommand`"
             },
@@ -1902,7 +1926,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.parseREPLKeyword()</code> was removed from userland visibility.</p>\n<p><a id=\"DEP0076\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.parseREPLKeyword()</code> was removed from userland visibility.</p>",
               "type": "module",
               "displayName": "DEP0075: `REPLServer.parseREPLKeyword()`"
             },
@@ -1923,7 +1947,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>tls.parseCertString()</code> is a trivial parsing helper that was made public by\nmistake. This function can usually be replaced with:</p>\n<pre><code class=\"language-js\">const querystring = require('querystring');\nquerystring.parse(str, '\\n', '=');\n</code></pre>\n<p>This function is not completely equivalent to <code>querystring.parse()</code>. One\ndifference is that <code>querystring.parse()</code> does url decoding:</p>\n<pre><code class=\"language-console\">> querystring.parse('%E5%A5%BD=1', '\\n', '=');\n{ '好': '1' }\n> tls.parseCertString('%E5%A5%BD=1');\n{ '%E5%A5%BD': '1' }\n</code></pre>\n<p><a id=\"DEP0077\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>tls.parseCertString()</code> is a trivial parsing helper that was made public by\nmistake. This function can usually be replaced with:</p>\n<pre><code class=\"language-js\">const querystring = require('querystring');\nquerystring.parse(str, '\\n', '=');\n</code></pre>\n<p>This function is not completely equivalent to <code>querystring.parse()</code>. One\ndifference is that <code>querystring.parse()</code> does url decoding:</p>\n<pre><code class=\"language-console\">> querystring.parse('%E5%A5%BD=1', '\\n', '=');\n{ '好': '1' }\n> tls.parseCertString('%E5%A5%BD=1');\n{ '%E5%A5%BD': '1' }\n</code></pre>",
               "type": "module",
               "displayName": "DEP0076: `tls.parseCertString()`"
             },
@@ -1939,7 +1963,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>Module._debug()</code> is deprecated.</p>\n<p>The <code>Module._debug()</code> function was never documented as an officially\nsupported API.</p>\n<p><a id=\"DEP0078\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>Module._debug()</code> is deprecated.</p>\n<p>The <code>Module._debug()</code> function was never documented as an officially\nsupported API.</p>",
               "type": "module",
               "displayName": "DEP0077: `Module._debug()`"
             },
@@ -1955,7 +1979,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.turnOffEditorMode()</code> was removed from userland visibility.</p>\n<p><a id=\"DEP0079\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.turnOffEditorMode()</code> was removed from userland visibility.</p>",
               "type": "module",
               "displayName": "DEP0078: `REPLServer.turnOffEditorMode()`"
             },
@@ -1981,7 +2005,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Using a property named <code>inspect</code> on an object to specify a custom inspection\nfunction for <a href=\"util.html#util_util_inspect_object_options\"><code>util.inspect()</code></a> is deprecated. Use <a href=\"util.html#util_util_inspect_custom\"><code>util.inspect.custom</code></a>\ninstead. For backward compatibility with Node.js prior to version 6.4.0, both\nmay be specified.</p>\n<p><a id=\"DEP0080\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Using a property named <code>inspect</code> on an object to specify a custom inspection\nfunction for <a href=\"util.html#util_util_inspect_object_options\"><code>util.inspect()</code></a> is deprecated. Use <a href=\"util.html#util_util_inspect_custom\"><code>util.inspect.custom</code></a>\ninstead. For backward compatibility with Node.js prior to version 6.4.0, both\ncan be specified.</p>",
               "type": "module",
               "displayName": "DEP0079: Custom inspection function on objects via `.inspect()`"
             },
@@ -1997,7 +2021,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The internal <code>path._makeLong()</code> was not intended for public use. However,\nuserland modules have found it useful. The internal API is deprecated\nand replaced with an identical, public <code>path.toNamespacedPath()</code> method.</p>\n<p><a id=\"DEP0081\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The internal <code>path._makeLong()</code> was not intended for public use. However,\nuserland modules have found it useful. The internal API is deprecated\nand replaced with an identical, public <code>path.toNamespacedPath()</code> method.</p>",
               "type": "module",
               "displayName": "DEP0080: `path._makeLong()`"
             },
@@ -2013,7 +2037,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>fs.truncate()</code> <code>fs.truncateSync()</code> usage with a file descriptor is\ndeprecated. Please use <code>fs.ftruncate()</code> or <code>fs.ftruncateSync()</code> to work with\nfile descriptors.</p>\n<p><a id=\"DEP0082\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>fs.truncate()</code> <code>fs.truncateSync()</code> usage with a file descriptor is\ndeprecated. Please use <code>fs.ftruncate()</code> or <code>fs.ftruncateSync()</code> to work with\nfile descriptors.</p>",
               "type": "module",
               "displayName": "DEP0081: `fs.truncate()` using a file descriptor"
             },
@@ -2029,7 +2053,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.prototype.memory()</code> is only necessary for the internal mechanics of\nthe <code>REPLServer</code> itself. Do not use this function.</p>\n<p><a id=\"DEP0083\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>REPLServer.prototype.memory()</code> is only necessary for the internal mechanics of\nthe <code>REPLServer</code> itself. Do not use this function.</p>",
               "type": "module",
               "displayName": "DEP0082: `REPLServer.prototype.memory()`"
             },
@@ -2050,7 +2074,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life.</p>\n<p>The <code>ecdhCurve</code> option to <code>tls.createSecureContext()</code> and <code>tls.TLSSocket</code> could\nbe set to <code>false</code> to disable ECDH entirely on the server only. This mode was\ndeprecated in preparation for migrating to OpenSSL 1.1.0 and consistency with\nthe client and is now unsupported. Use the <code>ciphers</code> parameter instead.</p>\n<p><a id=\"DEP0084\"></a></p>",
+              "desc": "<p>Type: End-of-Life.</p>\n<p>The <code>ecdhCurve</code> option to <code>tls.createSecureContext()</code> and <code>tls.TLSSocket</code> could\nbe set to <code>false</code> to disable ECDH entirely on the server only. This mode was\ndeprecated in preparation for migrating to OpenSSL 1.1.0 and consistency with\nthe client and is now unsupported. Use the <code>ciphers</code> parameter instead.</p>",
               "type": "module",
               "displayName": "DEP0083: Disabling ECDH by setting `ecdhCurve` to `false`"
             },
@@ -2071,7 +2095,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Since Node.js versions 4.4.0 and 5.2.0, several modules only intended for\ninternal usage were mistakenly exposed to user code through <code>require()</code>. These\nmodules were:</p>\n<ul>\n<li><code>v8/tools/codemap</code></li>\n<li><code>v8/tools/consarray</code></li>\n<li><code>v8/tools/csvparser</code></li>\n<li><code>v8/tools/logreader</code></li>\n<li><code>v8/tools/profile_view</code></li>\n<li><code>v8/tools/profile</code></li>\n<li><code>v8/tools/SourceMap</code></li>\n<li><code>v8/tools/splaytree</code></li>\n<li><code>v8/tools/tickprocessor-driver</code></li>\n<li><code>v8/tools/tickprocessor</code></li>\n<li><code>node-inspect/lib/_inspect</code> (from 7.6.0)</li>\n<li><code>node-inspect/lib/internal/inspect_client</code> (from 7.6.0)</li>\n<li><code>node-inspect/lib/internal/inspect_repl</code> (from 7.6.0)</li>\n</ul>\n<p>The <code>v8/*</code> modules do not have any exports, and if not imported in a specific\norder would in fact throw errors. As such there are virtually no legitimate use\ncases for importing them through <code>require()</code>.</p>\n<p>On the other hand, <code>node-inspect</code> may be installed locally through a package\nmanager, as it is published on the npm registry under the same name. No source\ncode modification is necessary if that is done.</p>\n<p><a id=\"DEP0085\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Since Node.js versions 4.4.0 and 5.2.0, several modules only intended for\ninternal usage were mistakenly exposed to user code through <code>require()</code>. These\nmodules were:</p>\n<ul>\n<li><code>v8/tools/codemap</code></li>\n<li><code>v8/tools/consarray</code></li>\n<li><code>v8/tools/csvparser</code></li>\n<li><code>v8/tools/logreader</code></li>\n<li><code>v8/tools/profile_view</code></li>\n<li><code>v8/tools/profile</code></li>\n<li><code>v8/tools/SourceMap</code></li>\n<li><code>v8/tools/splaytree</code></li>\n<li><code>v8/tools/tickprocessor-driver</code></li>\n<li><code>v8/tools/tickprocessor</code></li>\n<li><code>node-inspect/lib/_inspect</code> (from 7.6.0)</li>\n<li><code>node-inspect/lib/internal/inspect_client</code> (from 7.6.0)</li>\n<li><code>node-inspect/lib/internal/inspect_repl</code> (from 7.6.0)</li>\n</ul>\n<p>The <code>v8/*</code> modules do not have any exports, and if not imported in a specific\norder would in fact throw errors. As such there are virtually no legitimate use\ncases for importing them through <code>require()</code>.</p>\n<p>On the other hand, <code>node-inspect</code> can be installed locally through a package\nmanager, as it is published on the npm registry under the same name. No source\ncode modification is necessary if that is done.</p>",
               "type": "module",
               "displayName": "DEP0084: requiring bundled internal dependencies"
             },
@@ -2081,21 +2105,21 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "10.0.0",
+                    "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/17147",
                     "description": "End-of-Life."
                   },
                   {
                     "version": [
-                      "v8.10.0",
-                      "v9.4.0"
+                      "v9.4.0",
+                      "v8.10.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/16972",
                     "description": "Runtime deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The AsyncHooks sensitive API was never documented and had various minor issues.\nUse the <code>AsyncResource</code> API instead. See\n<a href=\"https://github.com/nodejs/node/issues/15572\">https://github.com/nodejs/node/issues/15572</a>.</p>\n<p><a id=\"DEP0086\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The AsyncHooks sensitive API was never documented and had various minor issues.\nUse the <code>AsyncResource</code> API instead. See\n<a href=\"https://github.com/nodejs/node/issues/15572\">https://github.com/nodejs/node/issues/15572</a>.</p>",
               "type": "module",
               "displayName": "DEP0085: AsyncHooks sensitive API"
             },
@@ -2105,21 +2129,21 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "10.0.0",
+                    "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/17147",
                     "description": "End-of-Life."
                   },
                   {
                     "version": [
-                      "v8.10.0",
-                      "v9.4.0"
+                      "v9.4.0",
+                      "v8.10.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/16972",
                     "description": "Runtime deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>runInAsyncIdScope</code> doesn't emit the <code>'before'</code> or <code>'after'</code> event and can thus\ncause a lot of issues. See <a href=\"https://github.com/nodejs/node/issues/14328\">https://github.com/nodejs/node/issues/14328</a>.</p>\n<p><a id=\"DEP0089\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>runInAsyncIdScope</code> doesn't emit the <code>'before'</code> or <code>'after'</code> event and can thus\ncause a lot of issues. See <a href=\"https://github.com/nodejs/node/issues/14328\">https://github.com/nodejs/node/issues/14328</a>.</p>",
               "type": "module",
               "displayName": "DEP0086: Remove `runInAsyncIdScope`"
             },
@@ -2136,14 +2160,14 @@
                   {
                     "version": [
                       "v9.9.0",
-                      "v10.0.0"
+                      "v8.13.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/17002",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Deprecation revoked</p>\n<p>Importing assert directly was not recommended as the exposed functions use\nloose equality checks. The deprecation was revoked because use of the <code>assert</code>\nmodule is not discouraged, and the deprecation caused developer confusion.</p>\n<p><a id=\"DEP0090\"></a></p>",
+              "desc": "<p>Type: Deprecation revoked</p>\n<p>Importing assert directly was not recommended as the exposed functions use\nloose equality checks. The deprecation was revoked because use of the <code>assert</code>\nmodule is not discouraged, and the deprecation caused developer confusion.</p>",
               "type": "module",
               "displayName": "DEP0089: `require('assert')`"
             },
@@ -2164,7 +2188,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Node.js used to support all GCM authentication tag lengths which are accepted by\nOpenSSL when calling <a href=\"crypto.html#crypto_decipher_setauthtag_buffer\"><code>decipher.setAuthTag()</code></a>. Beginning with Node.js\nv11.0.0, only authentication tag lengths of 128, 120, 112, 104, 96, 64, and 32\nbits are allowed. Authentication tags of other lengths are invalid per\n<a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf\">NIST SP 800-38D</a>.</p>\n<p><a id=\"DEP0091\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Node.js used to support all GCM authentication tag lengths which are accepted by\nOpenSSL when calling <a href=\"crypto.html#crypto_decipher_setauthtag_buffer\"><code>decipher.setAuthTag()</code></a>. Beginning with Node.js\nv11.0.0, only authentication tag lengths of 128, 120, 112, 104, 96, 64, and 32\nbits are allowed. Authentication tags of other lengths are invalid per\n<a href=\"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf\">NIST SP 800-38D</a>.</p>",
               "type": "module",
               "displayName": "DEP0090: Invalid GCM authentication tag lengths"
             },
@@ -2180,7 +2204,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <a href=\"crypto.html#crypto_crypto_default_encoding\"><code>crypto.DEFAULT_ENCODING</code></a> property is deprecated.</p>\n<p><a id=\"DEP0092\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <a href=\"crypto.html#crypto_crypto_default_encoding\"><code>crypto.DEFAULT_ENCODING</code></a> property is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0091: `crypto.DEFAULT_ENCODING`"
             },
@@ -2196,13 +2220,13 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>Assigning properties to the top-level <code>this</code> as an alternative\nto <code>module.exports</code> is deprecated. Developers should use <code>exports</code>\nor <code>module.exports</code> instead.</p>\n<p><a id=\"DEP0093\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>Assigning properties to the top-level <code>this</code> as an alternative\nto <code>module.exports</code> is deprecated. Developers should use <code>exports</code>\nor <code>module.exports</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0092: Top-level `this` bound to `module.exports`"
             },
             {
-              "textRaw": "DEP0093: `crypto.fips` is deprecated and replaced.",
-              "name": "dep0093:_`crypto.fips`_is_deprecated_and_replaced.",
+              "textRaw": "DEP0093: `crypto.fips` is deprecated and replaced",
+              "name": "dep0093:_`crypto.fips`_is_deprecated_and_replaced",
               "meta": {
                 "changes": [
                   {
@@ -2212,13 +2236,13 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_crypto_fips\"><code>crypto.fips</code></a> property is deprecated. Please use <code>crypto.setFips()</code>\nand <code>crypto.getFips()</code> instead.</p>\n<p><a id=\"DEP0094\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_crypto_fips\"><code>crypto.fips</code></a> property is deprecated. Please use <code>crypto.setFips()</code>\nand <code>crypto.getFips()</code> instead.</p>",
               "type": "module",
-              "displayName": "DEP0093: `crypto.fips` is deprecated and replaced."
+              "displayName": "DEP0093: `crypto.fips` is deprecated and replaced"
             },
             {
-              "textRaw": "DEP0094: Using `assert.fail()` with more than one argument.",
-              "name": "dep0094:_using_`assert.fail()`_with_more_than_one_argument.",
+              "textRaw": "DEP0094: Using `assert.fail()` with more than one argument",
+              "name": "dep0094:_using_`assert.fail()`_with_more_than_one_argument",
               "meta": {
                 "changes": [
                   {
@@ -2228,9 +2252,9 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Using <code>assert.fail()</code> with more than one argument is deprecated. Use\n<code>assert.fail()</code> with only one argument or use a different <code>assert</code> module\nmethod.</p>\n<p><a id=\"DEP0095\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Using <code>assert.fail()</code> with more than one argument is deprecated. Use\n<code>assert.fail()</code> with only one argument or use a different <code>assert</code> module\nmethod.</p>",
               "type": "module",
-              "displayName": "DEP0094: Using `assert.fail()` with more than one argument."
+              "displayName": "DEP0094: Using `assert.fail()` with more than one argument"
             },
             {
               "textRaw": "DEP0095: `timers.enroll()`",
@@ -2244,7 +2268,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>timers.enroll()</code> is deprecated. Please use the publicly documented\n<a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> or <a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a> instead.</p>\n<p><a id=\"DEP0096\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>timers.enroll()</code> is deprecated. Please use the publicly documented\n<a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> or <a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0095: `timers.enroll()`"
             },
@@ -2260,7 +2284,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>timers.unenroll()</code> is deprecated. Please use the publicly documented\n<a href=\"timers.html#timers_cleartimeout_timeout\"><code>clearTimeout()</code></a> or <a href=\"timers.html#timers_clearinterval_timeout\"><code>clearInterval()</code></a> instead.</p>\n<p><a id=\"DEP0097\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>timers.unenroll()</code> is deprecated. Please use the publicly documented\n<a href=\"timers.html#timers_cleartimeout_timeout\"><code>clearTimeout()</code></a> or <a href=\"timers.html#timers_clearinterval_timeout\"><code>clearInterval()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0096: `timers.unenroll()`"
             },
@@ -2276,7 +2300,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Users of <code>MakeCallback</code> that add the <code>domain</code> property to carry context,\nshould start using the <code>async_context</code> variant of <code>MakeCallback</code> or\n<code>CallbackScope</code>, or the high-level <code>AsyncResource</code> class.</p>\n<p><a id=\"DEP0098\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Users of <code>MakeCallback</code> that add the <code>domain</code> property to carry context,\nshould start using the <code>async_context</code> variant of <code>MakeCallback</code> or\n<code>CallbackScope</code>, or the high-level <code>AsyncResource</code> class.</p>",
               "type": "module",
               "displayName": "DEP0097: `MakeCallback` with `domain` property"
             },
@@ -2288,20 +2312,20 @@
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26530",
-                    "description": "End-of-Life"
+                    "description": "End-of-Life."
                   },
                   {
                     "version": [
-                      "v8.12.0",
+                      "v10.0.0",
                       "v9.6.0",
-                      "v10.0.0"
+                      "v8.12.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/18632",
                     "description": "Runtime deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The embedded API provided by AsyncHooks exposes <code>.emitBefore()</code> and\n<code>.emitAfter()</code> methods which are very easy to use incorrectly which can lead\nto unrecoverable errors.</p>\n<p>Use <a href=\"async_hooks.html#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args\"><code>asyncResource.runInAsyncScope()</code></a> API instead which provides a much\nsafer, and more convenient, alternative. See\n<a href=\"https://github.com/nodejs/node/pull/18513\">https://github.com/nodejs/node/pull/18513</a>.</p>\n<p><a id=\"DEP0099\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The embedded API provided by AsyncHooks exposes <code>.emitBefore()</code> and\n<code>.emitAfter()</code> methods which are very easy to use incorrectly which can lead\nto unrecoverable errors.</p>\n<p>Use <a href=\"async_hooks.html#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args\"><code>asyncResource.runInAsyncScope()</code></a> API instead which provides a much\nsafer, and more convenient, alternative. See\n<a href=\"https://github.com/nodejs/node/pull/18513\">https://github.com/nodejs/node/pull/18513</a>.</p>",
               "type": "module",
               "displayName": "DEP0098: AsyncHooks embedder `AsyncResource.emitBefore` and `AsyncResource.emitAfter` APIs"
             },
@@ -2317,7 +2341,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Compile-time</p>\n<p>Certain versions of <code>node::MakeCallback</code> APIs available to native modules are\ndeprecated. Please use the versions of the API that accept an <code>async_context</code>\nparameter.</p>\n<p><a id=\"DEP0100\"></a></p>",
+              "desc": "<p>Type: Compile-time</p>\n<p>Certain versions of <code>node::MakeCallback</code> APIs available to native modules are\ndeprecated. Please use the versions of the API that accept an <code>async_context</code>\nparameter.</p>",
               "type": "module",
               "displayName": "DEP0099: Async context-unaware `node::MakeCallback` C++ APIs"
             },
@@ -2337,7 +2361,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p><code>process.assert()</code> is deprecated. Please use the <a href=\"assert.html\"><code>assert</code></a> module instead.</p>\n<p>This was never a documented feature.</p>\n<p><a id=\"DEP0101\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p><code>process.assert()</code> is deprecated. Please use the <a href=\"assert.html\"><code>assert</code></a> module instead.</p>\n<p>This was never a documented feature.</p>",
               "type": "module",
               "displayName": "DEP0100: `process.assert()`"
             },
@@ -2353,13 +2377,13 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>--with-lttng</code> compile-time option has been removed.</p>\n<p><a id=\"DEP0102\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>--with-lttng</code> compile-time option has been removed.</p>",
               "type": "module",
               "displayName": "DEP0101: `--with-lttng`"
             },
             {
-              "textRaw": "DEP0102: Using `noAssert` in `Buffer#(read|write)` operations.",
-              "name": "dep0102:_using_`noassert`_in_`buffer#(read|write)`_operations.",
+              "textRaw": "DEP0102: Using `noAssert` in `Buffer#(read|write)` operations",
+              "name": "dep0102:_using_`noassert`_in_`buffer#(read|write)`_operations",
               "meta": {
                 "changes": [
                   {
@@ -2369,9 +2393,9 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Using the <code>noAssert</code> argument has no functionality anymore. All input is going\nto be verified, no matter if it is set to true or not. Skipping the verification\ncould lead to hard to find errors and crashes.</p>\n<p><a id=\"DEP0103\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Using the <code>noAssert</code> argument has no functionality anymore. All input is going\nto be verified, no matter if it is set to true or not. Skipping the verification\ncould lead to hard to find errors and crashes.</p>",
               "type": "module",
-              "displayName": "DEP0102: Using `noAssert` in `Buffer#(read|write)` operations."
+              "displayName": "DEP0102: Using `noAssert` in `Buffer#(read|write)` operations"
             },
             {
               "textRaw": "DEP0103: `process.binding('util').is[...]` typechecks",
@@ -2390,7 +2414,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Using <code>process.binding()</code> in general should be avoided. The type checking\nmethods in particular can be replaced by using <a href=\"util.html#util_util_types\"><code>util.types</code></a>.</p>\n<p>This deprecation has been superseded by the deprecation of the\n<code>process.binding()</code> API (<a href=\"#DEP0111\">DEP0111</a>).</p>\n<p><a id=\"DEP0104\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Using <code>process.binding()</code> in general should be avoided. The type checking\nmethods in particular can be replaced by using <a href=\"util.html#util_util_types\"><code>util.types</code></a>.</p>\n<p>This deprecation has been superseded by the deprecation of the\n<code>process.binding()</code> API (<a href=\"#DEP0111\">DEP0111</a>).</p>",
               "type": "module",
               "displayName": "DEP0103: `process.binding('util').is[...]` typechecks"
             },
@@ -2406,7 +2430,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>When assigning a non-string property to <a href=\"process.html#process_process_env\"><code>process.env</code></a>, the assigned value is\nimplicitly converted to a string. This behavior is deprecated if the assigned\nvalue is not a string, boolean, or number. In the future, such assignment may\nresult in a thrown error. Please convert the property to a string before\nassigning it to <code>process.env</code>.</p>\n<p><a id=\"DEP0105\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>When assigning a non-string property to <a href=\"process.html#process_process_env\"><code>process.env</code></a>, the assigned value is\nimplicitly converted to a string. This behavior is deprecated if the assigned\nvalue is not a string, boolean, or number. In the future, such assignment might\nresult in a thrown error. Please convert the property to a string before\nassigning it to <code>process.env</code>.</p>",
               "type": "module",
               "displayName": "DEP0104: `process.env` string coercion"
             },
@@ -2427,7 +2451,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>decipher.finaltol()</code> has never been documented and was an alias for\n<a href=\"crypto.html#crypto_decipher_final_outputencoding\"><code>decipher.final()</code></a>. This API has been removed, and it is recommended to use\n<a href=\"crypto.html#crypto_decipher_final_outputencoding\"><code>decipher.final()</code></a> instead.</p>\n<p><a id=\"DEP0106\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>decipher.finaltol()</code> has never been documented and was an alias for\n<a href=\"crypto.html#crypto_decipher_final_outputencoding\"><code>decipher.final()</code></a>. This API has been removed, and it is recommended to use\n<a href=\"crypto.html#crypto_decipher_final_outputencoding\"><code>decipher.final()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0105: `decipher.finaltol`"
             },
@@ -2448,7 +2472,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Using <a href=\"crypto.html#crypto_crypto_createcipher_algorithm_password_options\"><code>crypto.createCipher()</code></a> and <a href=\"crypto.html#crypto_crypto_createdecipher_algorithm_password_options\"><code>crypto.createDecipher()</code></a> should be\navoided as they use a weak key derivation function (MD5 with no salt) and static\ninitialization vectors. It is recommended to derive a key using\n<a href=\"crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback\"><code>crypto.pbkdf2()</code></a> or <a href=\"crypto.html#crypto_crypto_scrypt_password_salt_keylen_options_callback\"><code>crypto.scrypt()</code></a> and to use\n<a href=\"crypto.html#crypto_crypto_createcipheriv_algorithm_key_iv_options\"><code>crypto.createCipheriv()</code></a> and <a href=\"crypto.html#crypto_crypto_createdecipheriv_algorithm_key_iv_options\"><code>crypto.createDecipheriv()</code></a> to obtain the\n<a href=\"crypto.html#crypto_class_cipher\"><code>Cipher</code></a> and <a href=\"crypto.html#crypto_class_decipher\"><code>Decipher</code></a> objects respectively.</p>\n<p><a id=\"DEP0107\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Using <a href=\"crypto.html#crypto_crypto_createcipher_algorithm_password_options\"><code>crypto.createCipher()</code></a> and <a href=\"crypto.html#crypto_crypto_createdecipher_algorithm_password_options\"><code>crypto.createDecipher()</code></a> should be\navoided as they use a weak key derivation function (MD5 with no salt) and static\ninitialization vectors. It is recommended to derive a key using\n<a href=\"crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback\"><code>crypto.pbkdf2()</code></a> or <a href=\"crypto.html#crypto_crypto_scrypt_password_salt_keylen_options_callback\"><code>crypto.scrypt()</code></a> and to use\n<a href=\"crypto.html#crypto_crypto_createcipheriv_algorithm_key_iv_options\"><code>crypto.createCipheriv()</code></a> and <a href=\"crypto.html#crypto_crypto_createdecipheriv_algorithm_key_iv_options\"><code>crypto.createDecipheriv()</code></a> to obtain the\n<a href=\"crypto.html#crypto_class_cipher\"><code>Cipher</code></a> and <a href=\"crypto.html#crypto_class_decipher\"><code>Decipher</code></a> objects respectively.</p>",
               "type": "module",
               "displayName": "DEP0106: `crypto.createCipher` and `crypto.createDecipher`"
             },
@@ -2469,7 +2493,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>This was an undocumented helper function not intended for use outside Node.js\ncore and obsoleted by the removal of NPN (Next Protocol Negotiation) support.</p>\n<p><a id=\"DEP0108\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>This was an undocumented helper function not intended for use outside Node.js\ncore and obsoleted by the removal of NPN (Next Protocol Negotiation) support.</p>",
               "type": "module",
               "displayName": "DEP0107: `tls.convertNPNProtocols()`"
             },
@@ -2490,7 +2514,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Deprecated alias for <a href=\"zlib.html#zlib_zlib_byteswritten\"><code>zlib.bytesWritten</code></a>. This original name was chosen\nbecause it also made sense to interpret the value as the number of bytes\nread by the engine, but is inconsistent with other streams in Node.js that\nexpose values under these names.</p>\n<p><a id=\"DEP0109\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Deprecated alias for <a href=\"zlib.html#zlib_zlib_byteswritten\"><code>zlib.bytesWritten</code></a>. This original name was chosen\nbecause it also made sense to interpret the value as the number of bytes\nread by the engine, but is inconsistent with other streams in Node.js that\nexpose values under these names.</p>",
               "type": "module",
               "displayName": "DEP0108: `zlib.bytesRead`"
             },
@@ -2506,7 +2530,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Some previously supported (but strictly invalid) URLs were accepted through the\n<a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a>, <a href=\"http.html#http_http_get_options_callback\"><code>http.get()</code></a>, <a href=\"https.html#https_https_request_options_callback\"><code>https.request()</code></a>,\n<a href=\"https.html#https_https_get_options_callback\"><code>https.get()</code></a>, and <a href=\"tls.html#tls_tls_checkserveridentity_hostname_cert\"><code>tls.checkServerIdentity()</code></a> APIs because those were\naccepted by the legacy <code>url.parse()</code> API. The mentioned APIs now use the WHATWG\nURL parser that requires strictly valid URLs. Passing an invalid URL is\ndeprecated and support will be removed in the future.</p>\n<p><a id=\"DEP0110\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Some previously supported (but strictly invalid) URLs were accepted through the\n<a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a>, <a href=\"http.html#http_http_get_options_callback\"><code>http.get()</code></a>, <a href=\"https.html#https_https_request_options_callback\"><code>https.request()</code></a>,\n<a href=\"https.html#https_https_get_options_callback\"><code>https.get()</code></a>, and <a href=\"tls.html#tls_tls_checkserveridentity_hostname_cert\"><code>tls.checkServerIdentity()</code></a> APIs because those were\naccepted by the legacy <code>url.parse()</code> API. The mentioned APIs now use the WHATWG\nURL parser that requires strictly valid URLs. Passing an invalid URL is\ndeprecated and support will be removed in the future.</p>",
               "type": "module",
               "displayName": "DEP0109: `http`, `https`, and `tls` support for invalid URLs"
             },
@@ -2522,7 +2546,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>produceCachedData</code> option is deprecated. Use\n<a href=\"vm.html#vm_script_createcacheddata\"><code>script.createCachedData()</code></a> instead.</p>\n<p><a id=\"DEP0111\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>produceCachedData</code> option is deprecated. Use\n<a href=\"vm.html#vm_script_createcacheddata\"><code>script.createCachedData()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0110: `vm.Script` cached data"
             },
@@ -2531,19 +2555,19 @@
               "name": "dep0111:_`process.binding()`",
               "meta": {
                 "changes": [
-                  {
-                    "version": "v10.9.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/22004",
-                    "description": "Documentation-only deprecation."
-                  },
                   {
                     "version": "v11.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26500",
                     "description": "Added support for `--pending-deprecation`."
+                  },
+                  {
+                    "version": "v10.9.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22004",
+                    "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p><code>process.binding()</code> is for use by Node.js internal code only.</p>\n<p><a id=\"DEP0112\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p><code>process.binding()</code> is for use by Node.js internal code only.</p>",
               "type": "module",
               "displayName": "DEP0111: `process.binding()`"
             },
@@ -2559,7 +2583,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>dgram</code> module previously contained several APIs that were never meant to\naccessed outside of Node.js core: <code>Socket.prototype._handle</code>,\n<code>Socket.prototype._receiving</code>, <code>Socket.prototype._bindState</code>,\n<code>Socket.prototype._queue</code>, <code>Socket.prototype._reuseAddr</code>,\n<code>Socket.prototype._healthCheck()</code>, <code>Socket.prototype._stopReceiving()</code>, and\n<code>dgram._createSocketHandle()</code>.</p>\n<p><a id=\"DEP0113\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>dgram</code> module previously contained several APIs that were never meant to\naccessed outside of Node.js core: <code>Socket.prototype._handle</code>,\n<code>Socket.prototype._receiving</code>, <code>Socket.prototype._bindState</code>,\n<code>Socket.prototype._queue</code>, <code>Socket.prototype._reuseAddr</code>,\n<code>Socket.prototype._healthCheck()</code>, <code>Socket.prototype._stopReceiving()</code>, and\n<code>dgram._createSocketHandle()</code>.</p>",
               "type": "module",
               "displayName": "DEP0112: `dgram` private APIs"
             },
@@ -2580,7 +2604,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p><code>Cipher.setAuthTag()</code> and <code>Decipher.getAuthTag()</code> are no longer available. They\nwere never documented and would throw when called.</p>\n<p><a id=\"DEP0114\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p><code>Cipher.setAuthTag()</code> and <code>Decipher.getAuthTag()</code> are no longer available. They\nwere never documented and would throw when called.</p>",
               "type": "module",
               "displayName": "DEP0113: `Cipher.setAuthTag()`, `Decipher.getAuthTag()`"
             },
@@ -2601,7 +2625,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto._toBuf()</code> function was not designed to be used by modules outside\nof Node.js core and was removed.</p>\n<p><a id=\"DEP0115\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The <code>crypto._toBuf()</code> function was not designed to be used by modules outside\nof Node.js core and was removed.</p>",
               "type": "module",
               "displayName": "DEP0114: `crypto._toBuf()`"
             },
@@ -2620,7 +2644,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>In recent versions of Node.js, there is no difference between\n<a href=\"crypto.html#crypto_crypto_randombytes_size_callback\"><code>crypto.randomBytes()</code></a> and <code>crypto.pseudoRandomBytes()</code>. The latter is\ndeprecated along with the undocumented aliases <code>crypto.prng()</code> and\n<code>crypto.rng()</code> in favor of <a href=\"crypto.html#crypto_crypto_randombytes_size_callback\"><code>crypto.randomBytes()</code></a> and may be removed in a\nfuture release.</p>\n<p><a id=\"DEP0116\"></a></p>",
+              "desc": "<!--lint disable nodejs-yaml-comments -->\n<!--lint enable nodejs-yaml-comments -->\n<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>In recent versions of Node.js, there is no difference between\n<a href=\"crypto.html#crypto_crypto_randombytes_size_callback\"><code>crypto.randomBytes()</code></a> and <code>crypto.pseudoRandomBytes()</code>. The latter is\ndeprecated along with the undocumented aliases <code>crypto.prng()</code> and\n<code>crypto.rng()</code> in favor of <a href=\"crypto.html#crypto_crypto_randombytes_size_callback\"><code>crypto.randomBytes()</code></a> and might be removed in a\nfuture release.</p>",
               "type": "module",
               "displayName": "DEP0115: `crypto.prng()`, `crypto.pseudoRandomBytes()`, `crypto.rng()`"
             },
@@ -2629,6 +2653,11 @@
               "name": "dep0116:_legacy_url_api",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22715",
@@ -2636,7 +2665,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"url.html#url_legacy_url_api\">Legacy URL API</a> is deprecated. This includes <a href=\"url.html#url_url_format_urlobject\"><code>url.format()</code></a>,\n<a href=\"url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost\"><code>url.parse()</code></a>, <a href=\"url.html#url_url_resolve_from_to\"><code>url.resolve()</code></a>, and the <a href=\"url.html#url_legacy_urlobject\">legacy <code>urlObject</code></a>. Please\nuse the <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL API</a> instead.</p>\n<p><a id=\"DEP0117\"></a></p>",
+              "desc": "<p>Type: Deprecation revoked</p>\n<p>The <a href=\"url.html#url_legacy_url_api\">Legacy URL API</a> is deprecated. This includes <a href=\"url.html#url_url_format_urlobject\"><code>url.format()</code></a>,\n<a href=\"url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost\"><code>url.parse()</code></a>, <a href=\"url.html#url_url_resolve_from_to\"><code>url.resolve()</code></a>, and the <a href=\"url.html#url_legacy_urlobject\">legacy <code>urlObject</code></a>. Please\nuse the <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL API</a> instead.</p>",
               "type": "module",
               "displayName": "DEP0116: Legacy URL API"
             },
@@ -2657,7 +2686,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Previous versions of Node.js exposed handles to internal native objects through\nthe <code>_handle</code> property of the <code>Cipher</code>, <code>Decipher</code>, <code>DiffieHellman</code>,\n<code>DiffieHellmanGroup</code>, <code>ECDH</code>, <code>Hash</code>, <code>Hmac</code>, <code>Sign</code>, and <code>Verify</code> classes.\nThe <code>_handle</code> property has been removed because improper use of the native\nobject can lead to crashing the application.</p>\n<p><a id=\"DEP0118\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Previous versions of Node.js exposed handles to internal native objects through\nthe <code>_handle</code> property of the <code>Cipher</code>, <code>Decipher</code>, <code>DiffieHellman</code>,\n<code>DiffieHellmanGroup</code>, <code>ECDH</code>, <code>Hash</code>, <code>Hmac</code>, <code>Sign</code>, and <code>Verify</code> classes.\nThe <code>_handle</code> property has been removed because improper use of the native\nobject can lead to crashing the application.</p>",
               "type": "module",
               "displayName": "DEP0117: Native crypto handles"
             },
@@ -2673,7 +2702,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Previous versions of Node.js supported <code>dns.lookup()</code> with a falsy host name\nlike <code>dns.lookup(false)</code> due to backward compatibility.\nThis behavior is undocumented and is thought to be unused in real world apps.\nIt will become an error in future versions of Node.js.</p>\n<p><a id=\"DEP0119\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Previous versions of Node.js supported <code>dns.lookup()</code> with a falsy host name\nlike <code>dns.lookup(false)</code> due to backward compatibility.\nThis behavior is undocumented and is thought to be unused in real world apps.\nIt will become an error in future versions of Node.js.</p>",
               "type": "module",
               "displayName": "DEP0118: `dns.lookup()` support for a falsy host name"
             },
@@ -2689,7 +2718,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p><code>process.binding('uv').errname()</code> is deprecated. Please use\n<a href=\"util.html#util_util_getsystemerrorname_err\"><code>util.getSystemErrorName()</code></a> instead.</p>\n<p><a id=\"DEP0120\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p><code>process.binding('uv').errname()</code> is deprecated. Please use\n<a href=\"util.html#util_util_getsystemerrorname_err\"><code>util.getSystemErrorName()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0119: `process.binding('uv').errname()` private API"
             },
@@ -2710,7 +2739,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: End-of-Life</p>\n<p>Windows Performance Counter support has been removed from Node.js. The\nundocumented <code>COUNTER_NET_SERVER_CONNECTION()</code>,\n<code>COUNTER_NET_SERVER_CONNECTION_CLOSE()</code>, <code>COUNTER_HTTP_SERVER_REQUEST()</code>,\n<code>COUNTER_HTTP_SERVER_RESPONSE()</code>, <code>COUNTER_HTTP_CLIENT_REQUEST()</code>, and\n<code>COUNTER_HTTP_CLIENT_RESPONSE()</code> functions have been deprecated.</p>\n<p><a id=\"DEP0121\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>Windows Performance Counter support has been removed from Node.js. The\nundocumented <code>COUNTER_NET_SERVER_CONNECTION()</code>,\n<code>COUNTER_NET_SERVER_CONNECTION_CLOSE()</code>, <code>COUNTER_HTTP_SERVER_REQUEST()</code>,\n<code>COUNTER_HTTP_SERVER_RESPONSE()</code>, <code>COUNTER_HTTP_CLIENT_REQUEST()</code>, and\n<code>COUNTER_HTTP_CLIENT_RESPONSE()</code> functions have been deprecated.</p>",
               "type": "module",
               "displayName": "DEP0120: Windows Performance Counter support"
             },
@@ -2726,7 +2755,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The undocumented <code>net._setSimultaneousAccepts()</code> function was originally\nintended for debugging and performance tuning when using the <code>child_process</code>\nand <code>cluster</code> modules on Windows. The function is not generally useful and\nis being removed. See discussion here:\n<a href=\"https://github.com/nodejs/node/issues/18391\">https://github.com/nodejs/node/issues/18391</a></p>\n<p><a id=\"DEP0122\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The undocumented <code>net._setSimultaneousAccepts()</code> function was originally\nintended for debugging and performance tuning when using the <code>child_process</code>\nand <code>cluster</code> modules on Windows. The function is not generally useful and\nis being removed. See discussion here:\n<a href=\"https://github.com/nodejs/node/issues/18391\">https://github.com/nodejs/node/issues/18391</a></p>",
               "type": "module",
               "displayName": "DEP0121: `net._setSimultaneousAccepts()`"
             },
@@ -2742,7 +2771,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Please use <code>Server.prototype.setSecureContext()</code> instead.</p>\n<p><a id=\"DEP0123\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Please use <code>Server.prototype.setSecureContext()</code> instead.</p>",
               "type": "module",
               "displayName": "DEP0122: `tls` `Server.prototype.setOptions()`"
             },
@@ -2758,7 +2787,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Setting the TLS ServerName to an IP address is not permitted by\n<a href=\"https://tools.ietf.org/html/rfc6066#section-3\">RFC 6066</a>. This will be ignored in a future version.</p>\n<p><a id=\"DEP0124\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Setting the TLS ServerName to an IP address is not permitted by\n<a href=\"https://tools.ietf.org/html/rfc6066#section-3\">RFC 6066</a>. This will be ignored in a future version.</p>",
               "type": "module",
               "displayName": "DEP0123: setting the TLS ServerName to an IP address"
             },
@@ -2774,7 +2803,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>This property is a reference to the instance itself.</p>\n<p><a id=\"DEP0125\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>This property is a reference to the instance itself.</p>",
               "type": "module",
               "displayName": "DEP0124: using `REPLServer.rli`"
             },
@@ -2790,7 +2819,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The <code>_stream_wrap</code> module is deprecated.</p>\n<p><a id=\"DEP0126\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>_stream_wrap</code> module is deprecated.</p>",
               "type": "module",
               "displayName": "DEP0125: `require('_stream_wrap')`"
             },
@@ -2806,7 +2835,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The previously undocumented <code>timers.active()</code> is deprecated.\nPlease use the publicly documented <a href=\"timers.html#timers_timeout_refresh\"><code>timeout.refresh()</code></a> instead.\nIf re-referencing the timeout is necessary, <a href=\"timers.html#timers_timeout_ref\"><code>timeout.ref()</code></a> can be used\nwith no performance impact since Node.js 10.</p>\n<p><a id=\"DEP0127\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The previously undocumented <code>timers.active()</code> is deprecated.\nPlease use the publicly documented <a href=\"timers.html#timers_timeout_refresh\"><code>timeout.refresh()</code></a> instead.\nIf re-referencing the timeout is necessary, <a href=\"timers.html#timers_timeout_ref\"><code>timeout.ref()</code></a> can be used\nwith no performance impact since Node.js 10.</p>",
               "type": "module",
               "displayName": "DEP0126: `timers.active()`"
             },
@@ -2822,7 +2851,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The previously undocumented and \"private\" <code>timers._unrefActive()</code> is deprecated.\nPlease use the publicly documented <a href=\"timers.html#timers_timeout_refresh\"><code>timeout.refresh()</code></a> instead.\nIf unreferencing the timeout is necessary, <a href=\"timers.html#timers_timeout_unref\"><code>timeout.unref()</code></a> can be used\nwith no performance impact since Node.js 10.</p>\n<p><a id=\"DEP0128\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The previously undocumented and \"private\" <code>timers._unrefActive()</code> is deprecated.\nPlease use the publicly documented <a href=\"timers.html#timers_timeout_refresh\"><code>timeout.refresh()</code></a> instead.\nIf unreferencing the timeout is necessary, <a href=\"timers.html#timers_timeout_unref\"><code>timeout.unref()</code></a> can be used\nwith no performance impact since Node.js 10.</p>",
               "type": "module",
               "displayName": "DEP0127: `timers._unrefActive()`"
             },
@@ -2838,7 +2867,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Modules that have an invalid <code>main</code> entry (e.g., <code>./does-not-exist.js</code>) and\nalso have an <code>index.js</code> file in the top level directory will resolve the\n<code>index.js</code> file. That is deprecated and is going to throw an error in future\nNode.js versions.</p>\n<p><a id=\"DEP0129\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Modules that have an invalid <code>main</code> entry (e.g., <code>./does-not-exist.js</code>) and\nalso have an <code>index.js</code> file in the top level directory will resolve the\n<code>index.js</code> file. That is deprecated and is going to throw an error in future\nNode.js versions.</p>",
               "type": "module",
               "displayName": "DEP0128: modules with an invalid `main` entry and an `index.js` file"
             },
@@ -2847,6 +2876,11 @@
               "name": "dep0129:_`childprocess._channel`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27949",
+                    "description": "Runtime deprecation."
+                  },
                   {
                     "version": "v11.14.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26982",
@@ -2854,7 +2888,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>_channel</code> property of child process objects returned by <code>spawn()</code> and\nsimilar functions is not intended for public use. Use <code>ChildProcess.channel</code>\ninstead.</p>\n<p><a id=\"DEP0130\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>The <code>_channel</code> property of child process objects returned by <code>spawn()</code> and\nsimilar functions is not intended for public use. Use <code>ChildProcess.channel</code>\ninstead.</p>",
               "type": "module",
               "displayName": "DEP0129: `ChildProcess._channel`"
             },
@@ -2863,6 +2897,11 @@
               "name": "dep0130:_`module.createrequirefrompath()`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27951",
+                    "description": "Runtime deprecation."
+                  },
                   {
                     "version": "v12.2.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27405",
@@ -2870,7 +2909,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>Module.createRequireFromPath() is deprecated. Please use <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a> instead.</p>\n<p><a id=\"DEP0131\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Module.createRequireFromPath() is deprecated. Please use\n<a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a> instead.</p>",
               "type": "module",
               "displayName": "DEP0130: `Module.createRequireFromPath()`"
             },
@@ -2880,9 +2919,9 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "v12.22.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/37603",
-                    "description": "Runtime deprecation."
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29589",
+                    "description": "This feature has been removed."
                   },
                   {
                     "version": "v12.3.0",
@@ -2891,7 +2930,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>The legacy HTTP parser, used by default in versions of Node.js prior to 12.0.0,\nis deprecated. This deprecation applies to users of the\n<a href=\"cli.html#cli_http_parser_library\"><code>--http-parser=legacy</code></a> command-line flag.</p>\n<p><a id=\"DEP0132\"></a></p>",
+              "desc": "<p>Type: End-of-Life</p>\n<p>The legacy HTTP parser, used by default in versions of Node.js prior to 12.0.0,\nis deprecated and has been removed in v13.0.0. Prior to v13.0.0, the\n<code>--http-parser=legacy</code> command-line flag could be used to revert to using the\nlegacy parser.</p>",
               "type": "module",
               "displayName": "DEP0131: Legacy HTTP parser"
             },
@@ -2907,7 +2946,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Runtime</p>\n<p>Passing a callback to <a href=\"worker_threads.html#worker_threads_worker_terminate\"><code>worker.terminate()</code></a> is deprecated. Use the returned\n<code>Promise</code> instead, or a listener to the worker’s <code>'exit'</code> event.</p>\n<p><a id=\"DEP0133\"></a></p>",
+              "desc": "<p>Type: Runtime</p>\n<p>Passing a callback to <a href=\"worker_threads.html#worker_threads_worker_terminate\"><code>worker.terminate()</code></a> is deprecated. Use the returned\n<code>Promise</code> instead, or a listener to the worker’s <code>'exit'</code> event.</p>",
               "type": "module",
               "displayName": "DEP0132: `worker.terminate()` with callback"
             },
@@ -2923,7 +2962,7 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>Prefer <a href=\"http.html#http_response_socket\"><code>response.socket</code></a> over <a href=\"http.html#http_response_connection\"><code>response.connection</code></a> and\n<a href=\"http.html#http_request_socket\"><code>request.socket</code></a> over <a href=\"http.html#http_request_connection\"><code>request.connection</code></a>.</p>\n<p><a id=\"DEP0134\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>Prefer <a href=\"http.html#http_response_socket\"><code>response.socket</code></a> over <a href=\"http.html#http_response_connection\"><code>response.connection</code></a> and\n<a href=\"http.html#http_request_socket\"><code>request.socket</code></a> over <a href=\"http.html#http_request_connection\"><code>request.connection</code></a>.</p>",
               "type": "module",
               "displayName": "DEP0133: `http` `connection`"
             },
@@ -2939,26 +2978,77 @@
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>process._tickCallback</code> property was never documented as\nan officially supported API.</p>\n<p><a id=\"DEP0136\"></a></p>",
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>process._tickCallback</code> property was never documented as\nan officially supported API.</p>",
               "type": "module",
               "displayName": "DEP0134: `process._tickCallback`"
             },
+            {
+              "textRaw": "DEP0135: `WriteStream.open()` and `ReadStream.open()` are internal",
+              "name": "dep0135:_`writestream.open()`_and_`readstream.open()`_are_internal",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29061",
+                    "description": "Runtime deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Runtime</p>\n<p><a href=\"fs.html#fs_class_fs_writestream\"><code>WriteStream.open()</code></a> and <a href=\"fs.html#fs_class_fs_readstream\"><code>ReadStream.open()</code></a> are undocumented internal\nAPIs that do not make sense to use in userland. File streams should always be\nopened through their corresponding factory methods <a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>\nand <a href=\"fs.html#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a>) or by passing a file descriptor in options.</p>",
+              "type": "module",
+              "displayName": "DEP0135: `WriteStream.open()` and `ReadStream.open()` are internal"
+            },
             {
               "textRaw": "DEP0136: `http` `finished`",
               "name": "dep0136:_`http`_`finished`",
               "meta": {
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.4.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/28679",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p><a href=\"http.html#http_response_finished\"><code>response.finished</code></a> indicates whether <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> has been\ncalled, not whether <code>'finish'</code> has been emitted and the underlying data\nis flushed.</p>\n<p>Use <a href=\"http.html#http_response_writablefinished\"><code>response.writableFinished</code></a> or <a href=\"http.html#http_response_writableended\"><code>response.writableEnded</code></a>\naccordingly instead to avoid the ambigiuty.</p>\n<p>To maintain existing behaviour <code>response.finished</code> should be replaced with\n<code>response.writableEnded</code>.</p>\n<p><a id=\"DEP0139\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p><a href=\"http.html#http_response_finished\"><code>response.finished</code></a> indicates whether <a href=\"http.html#http_response_end_data_encoding_callback\"><code>response.end()</code></a> has been\ncalled, not whether <code>'finish'</code> has been emitted and the underlying data\nis flushed.</p>\n<p>Use <a href=\"http.html#http_response_writablefinished\"><code>response.writableFinished</code></a> or <a href=\"http.html#http_response_writableended\"><code>response.writableEnded</code></a>\naccordingly instead to avoid the ambiguity.</p>\n<p>To maintain existing behaviour <code>response.finished</code> should be replaced with\n<code>response.writableEnded</code>.</p>",
               "type": "module",
               "displayName": "DEP0136: `http` `finished`"
             },
+            {
+              "textRaw": "DEP0137: Closing fs.FileHandle on garbage collection",
+              "name": "dep0137:_closing_fs.filehandle_on_garbage_collection",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/28396",
+                    "description": "Runtime deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Runtime</p>\n<p>Allowing a <a href=\"fs.html#fs_class_filehandle\"><code>fs.FileHandle</code></a> object to be closed on garbage collection is\ndeprecated. In the future, doing so might result in a thrown error that will\nterminate the process.</p>\n<p>Please ensure that all <code>fs.FileHandle</code> objects are explicitly closed using\n<code>FileHandle.prototype.close()</code> when the <code>fs.FileHandle</code> is no longer needed:</p>\n<pre><code class=\"language-js\">const fsPromises = require('fs').promises;\nasync function openAndClose() {\n  let filehandle;\n  try {\n    filehandle = await fsPromises.open('thefile.txt', 'r');\n  } finally {\n    if (filehandle !== undefined)\n      await filehandle.close();\n  }\n}\n</code></pre>",
+              "type": "module",
+              "displayName": "DEP0137: Closing fs.FileHandle on garbage collection"
+            },
+            {
+              "textRaw": "DEP0138: `process.mainModule`",
+              "name": "dep0138:_`process.mainmodule`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32232",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p><a href=\"process.html#process_process_mainmodule\"><code>process.mainModule</code></a> is a CommonJS-only feature while <code>process</code> global\nobject is shared with non-CommonJS environment. Its use within ECMAScript\nmodules is unsupported.</p>\n<p>It is deprecated in favor of <a href=\"modules.html#modules_accessing_the_main_module\"><code>require.main</code></a>, because it serves the same\npurpose and is only available on CommonJS environment.</p>",
+              "type": "module",
+              "displayName": "DEP0138: `process.mainModule`"
+            },
             {
               "textRaw": "DEP0139: `process.umask()` with no arguments",
               "name": "dep0139:_`process.umask()`_with_no_arguments",
@@ -2966,18 +3056,85 @@
                 "changes": [
                   {
                     "version": [
-                      "v12.19.0",
-                      "v14.0.0"
+                      "v14.0.0",
+                      "v12.19.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/32499",
                     "description": "Documentation-only deprecation."
                   }
                 ]
               },
-              "desc": "<p>Type: Documentation-only</p>\n<p>Calling <code>process.umask()</code> with no argument causes the process-wide umask to be\nwritten twice. This introduces a race condition between threads, and is a\npotential security vulnerability. There is no safe, cross-platform alternative\nAPI.</p>\n<p><a id=\"DEP0144\"></a></p>",
+              "desc": "<p>Type: Documentation-only</p>\n<p>Calling <code>process.umask()</code> with no argument causes the process-wide umask to be\nwritten twice. This introduces a race condition between threads, and is a\npotential security vulnerability. There is no safe, cross-platform alternative\nAPI.</p>",
               "type": "module",
               "displayName": "DEP0139: `process.umask()` with no arguments"
             },
+            {
+              "textRaw": "DEP0140: Use `request.destroy()` instead of `request.abort()`",
+              "name": "dep0140:_use_`request.destroy()`_instead_of_`request.abort()`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": [
+                      "v14.1.0",
+                      "v13.14.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/32807",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p>Use <a href=\"http.html#http_request_destroy_error\"><code>request.destroy()</code></a> instead of <a href=\"http.html#http_request_abort\"><code>request.abort()</code></a>.</p>",
+              "type": "module",
+              "displayName": "DEP0140: Use `request.destroy()` instead of `request.abort()`"
+            },
+            {
+              "textRaw": "DEP0141: `repl.inputStream` and `repl.outputStream`",
+              "name": "dep0141:_`repl.inputstream`_and_`repl.outputstream`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33294",
+                    "description": "Documentation-only (supports [`--pending-deprecation`][])."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>The <code>repl</code> module exported the input and output stream twice. Use <code>.input</code>\ninstead of <code>.inputStream</code> and <code>.output</code> instead of <code>.outputStream</code>.</p>",
+              "type": "module",
+              "displayName": "DEP0141: `repl.inputStream` and `repl.outputStream`"
+            },
+            {
+              "textRaw": "DEP0142: `repl._builtinLibs`",
+              "name": "dep0142:_`repl._builtinlibs`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33294",
+                    "description": "Documentation-only (supports [`--pending-deprecation`][])."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <code>repl</code> module exports a <code>_builtinLibs</code> property that contains an array with\nnative modules. It was incomplete so far and instead it's better to rely upon\n<code>require('module').builtinModules</code>.</p>",
+              "type": "module",
+              "displayName": "DEP0142: `repl._builtinLibs`"
+            },
+            {
+              "textRaw": "DEP0143: `Transform._transformState`",
+              "name": "dep0143:_`transform._transformstate`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33126",
+                    "description": "Runtime deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Runtime\n<code>Transform._transformState</code> will be removed in future versions where it is\nno longer required due to simplification of the implementation.</p>",
+              "type": "module",
+              "displayName": "DEP0143: `Transform._transformState`"
+            },
             {
               "textRaw": "DEP0144: `module.parent`",
               "name": "dep0144:_`module.parent`",
@@ -2985,8 +3142,8 @@
                 "changes": [
                   {
                     "version": [
-                      "v12.19.0",
-                      "v14.6.0"
+                      "v14.6.0",
+                      "v12.19.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/32217",
                     "description": "Documentation-only deprecation."
@@ -2996,6 +3153,70 @@
               "desc": "<p>Type: Documentation-only</p>\n<p>A CommonJS module can access the first module that required it using\n<code>module.parent</code>. This feature is deprecated because it does not work\nconsistently in the presence of ECMAScript modules and because it gives an\ninaccurate representation of the CommonJS module graph.</p>\n<p>Some modules use it to check if they are the entry point of the current process.\nInstead, it is recommended to compare <code>require.main</code> and <code>module</code>:</p>\n<pre><code class=\"language-js\">if (require.main === module) {\n  // Code section that will run only if current file is the entry point.\n}\n</code></pre>\n<p>When looking for the CommonJS modules that have required the current one,\n<code>require.cache</code> and <code>module.children</code> can be used:</p>\n<pre><code class=\"language-js\">const moduleParents = Object.values(require.cache)\n  .filter((m) => m.children.includes(module));\n</code></pre>",
               "type": "module",
               "displayName": "DEP0144: `module.parent`"
+            },
+            {
+              "textRaw": "DEP0145: `socket.bufferSize`",
+              "name": "dep0145:_`socket.buffersize`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34088",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p><a href=\"net.html#net_socket_buffersize\"><code>socket.bufferSize</code></a> is just an alias for <a href=\"stream.html#stream_writable_writablelength\"><code>writable.writableLength</code></a>.</p>",
+              "type": "module",
+              "displayName": "DEP0145: `socket.bufferSize`"
+            },
+            {
+              "textRaw": "DEP0146: `new crypto.Certificate()`",
+              "name": "dep0146:_`new_crypto.certificate()`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.9.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34697",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p>The <a href=\"crypto.html#crypto_legacy_api\"><code>crypto.Certificate()</code> constructor</a> is deprecated. Use\n<a href=\"crypto.html#crypto_class_certificate\">static methods of <code>crypto.Certificate()</code></a> instead.</p>",
+              "type": "module",
+              "displayName": "DEP0146: `new crypto.Certificate()`"
+            },
+            {
+              "textRaw": "DEP0147: `fs.rmdir(path, { recursive: true })`",
+              "name": "dep0147:_`fs.rmdir(path,_{_recursive:_true_})`",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35579",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only</p>\n<p>In future versions of Node.js, <code>fs.rmdir(path, { recursive: true })</code> will throw\non nonexistent paths, or when given a file as a target.\nUse <code>fs.rm(path, { recursive: true, force: true })</code> instead.</p>",
+              "type": "module",
+              "displayName": "DEP0147: `fs.rmdir(path, { recursive: true })`"
+            },
+            {
+              "textRaw": "DEP0151: Main index lookup and extension searching",
+              "name": "dep0151:_main_index_lookup_and_extension_searching",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/36918",
+                    "description": "Documentation-only deprecation with `--pending-deprecation` support."
+                  }
+                ]
+              },
+              "desc": "<p>Type: Documentation-only (supports <a href=\"cli.html#cli_pending_deprecation\"><code>--pending-deprecation</code></a>)</p>\n<p>Previously, <code>index.js</code> and extension searching lookups would apply to\n<code>import 'pkg'</code> main entry point resolution, even when resolving ES modules.</p>\n<p>With this deprecation, all ES module main entry point resolutions require\nan explicit <a href=\"packages.html#packages_main_entry_point_export\"><code>\"exports\"</code> or <code>\"main\"</code> entry</a> with the exact file extension.</p>",
+              "type": "module",
+              "displayName": "DEP0151: Main index lookup and extension searching"
             }
           ],
           "type": "misc",
diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 59df3c52cce6f452826c00e58598756f7073cbfe..484d565cc72d9ddbc992f669c59e9c93a756a2f9 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -3,13 +3,13 @@
 <!--introduced_in=v7.7.0-->
 <!-- type=misc -->
 
-Node.js may deprecate APIs for any of the following reasons:
+Node.js APIs might be deprecated for any of the following reasons:
 
 * Use of the API is unsafe.
 * An improved alternative API is available.
 * Breaking changes to the API are expected in a future major release.
 
-Node.js utilizes three kinds of Deprecations:
+Node.js uses three kinds of Deprecations:
 
 * Documentation-only
 * Runtime
@@ -34,19 +34,21 @@ from Node.js.
 
 ## Revoking deprecations
 
-Occasionally, the deprecation of an API may be reversed. In such situations,
+Occasionally, the deprecation of an API might be reversed. In such situations,
 this document will be updated with information relevant to the decision.
 However, the deprecation identifier will not be modified.
 
 ## List of deprecated APIs
 
-<a id="DEP0001"></a>
 ### DEP0001: `http.OutgoingMessage.prototype.flush`
 <!-- YAML
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31164
+    description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v1.6.0
@@ -54,12 +56,11 @@ changes:
     description: Runtime deprecation.
 -->
 
-Type: Runtime
+Type: End-of-Life
 
-The `OutgoingMessage.prototype.flush()` method is deprecated. Use
+`OutgoingMessage.prototype.flush()` has been removed. Use
 `OutgoingMessage.prototype.flushHeaders()` instead.
 
-<a id="DEP0002"></a>
 ### DEP0002: `require('_linklist')`
 <!-- YAML
 changes:
@@ -78,13 +79,15 @@ Type: End-of-Life
 
 The `_linklist` module is deprecated. Please use a userland alternative.
 
-<a id="DEP0003"></a>
 ### DEP0003: `_writableState.buffer`
 <!-- YAML
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31165
+    description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.15
@@ -92,12 +95,11 @@ changes:
     description: Runtime deprecation.
 -->
 
-Type: Runtime
+Type: End-of-Life
 
-The `_writableState.buffer` property is deprecated. Use the
-`_writableState.getBuffer()` method instead.
+The `_writableState.buffer` has been removed. Use `_writableState.getBuffer()`
+instead.
 
-<a id="DEP0004"></a>
 ### DEP0004: `CryptoStream.prototype.readyState`
 <!-- YAML
 changes:
@@ -105,11 +107,11 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/17882
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
-  - version: 0.4.0
+  - version: v0.4.0
     commit: 9c7f89bf56abd37a796fea621ad2e47dd33d2b82
     description: Documentation-only deprecation.
 -->
@@ -118,7 +120,6 @@ Type: End-of-Life
 
 The `CryptoStream.prototype.readyState` property was removed.
 
-<a id="DEP0005"></a>
 ### DEP0005: `Buffer()` constructor
 <!-- YAML
 changes:
@@ -159,7 +160,6 @@ Without `--pending-deprecation`, runtime warnings occur only for code not in
 `Buffer()` usage in dependencies. With `--pending-deprecation`, a runtime
 warning results no matter where the `Buffer()` usage occurs.
 
-<a id="DEP0006"></a>
 ### DEP0006: `child_process` `options.customFds`
 <!-- YAML
 changes:
@@ -167,13 +167,13 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/25279
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.14
     description: Runtime deprecation.
-  - version: v0.5.11
+  - version: v0.5.10
     description: Documentation-only deprecation.
 -->
 
@@ -183,7 +183,6 @@ Within the [`child_process`][] module's `spawn()`, `fork()`, and `exec()`
 methods, the `options.customFds` option is deprecated. The `options.stdio`
 option should be used instead.
 
-<a id="DEP0007"></a>
 ### DEP0007: Replace `cluster` `worker.suicide` with `worker.exitedAfterDisconnect`
 <!-- YAML
 changes:
@@ -210,7 +209,6 @@ provide an indication of how and why the `Worker` instance exited. In Node.js
 [`worker.exitedAfterDisconnect`][] property. The old property name did not
 precisely describe the actual semantics and was unnecessarily emotion-laden.
 
-<a id="DEP0008"></a>
 ### DEP0008: `require('constants')`
 <!-- YAML
 changes:
@@ -229,10 +227,12 @@ relevant to specific Node.js builtin modules, developers should instead refer
 to the `constants` property exposed by the relevant module. For instance,
 `require('fs').constants` and `require('os').constants`.
 
-<a id="DEP0009"></a>
 ### DEP0009: `crypto.pbkdf2` without digest
 <!-- YAML
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31166
+    description: End-of-Life (for `digest === null`).
   - version: v11.0.0
     pr-url: https://github.com/nodejs/node/pull/22861
     description: Runtime deprecation (for `digest === null`).
@@ -247,7 +247,7 @@ changes:
     description: Runtime deprecation (for `digest === undefined`).
 -->
 
-Type: Runtime
+Type: End-of-Life
 
 Use of the [`crypto.pbkdf2()`][] API without specifying a digest was deprecated
 in Node.js 6.0 because the method defaulted to using the non-recommended
@@ -256,10 +256,11 @@ Node.js 8.0.0, calling `crypto.pbkdf2()` or `crypto.pbkdf2Sync()` with
 `digest` set to `undefined` will throw a `TypeError`.
 
 Beginning in Node.js v11.0.0, calling these functions with `digest` set to
-`null` will print a deprecation warning to align with the behavior when `digest`
+`null` would print a deprecation warning to align with the behavior when `digest`
 is `undefined`.
 
-<a id="DEP0010"></a>
+Now, however, passing either `undefined` or `null` will throw a `TypeError`.
+
 ### DEP0010: `crypto.createCredentials`
 <!-- YAML
 changes:
@@ -267,8 +268,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/21153
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.13
@@ -281,7 +282,6 @@ Type: End-of-Life
 The `crypto.createCredentials()` API was removed. Please use
 [`tls.createSecureContext()`][] instead.
 
-<a id="DEP0011"></a>
 ### DEP0011: `crypto.Credentials`
 <!-- YAML
 changes:
@@ -289,8 +289,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/21153
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.13
@@ -303,7 +303,6 @@ Type: End-of-Life
 The `crypto.Credentials` class was removed. Please use [`tls.SecureContext`][]
 instead.
 
-<a id="DEP0012"></a>
 ### DEP0012: `Domain.dispose`
 <!-- YAML
 changes:
@@ -311,8 +310,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/15412
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.7
@@ -325,7 +324,6 @@ Type: End-of-Life
 `Domain.dispose()` has been removed. Recover from failed I/O actions
 explicitly via error event handlers set on the domain instead.
 
-<a id="DEP0013"></a>
 ### DEP0013: `fs` asynchronous function without callback
 <!-- YAML
 changes:
@@ -342,21 +340,20 @@ Type: End-of-Life
 Calling an asynchronous function without a callback throws a `TypeError`
 in Node.js 10.0.0 onwards. See <https://github.com/nodejs/node/pull/12562>.
 
-<a id="DEP0014"></a>
 ### DEP0014: `fs.read` legacy String interface
 <!-- YAML
 changes:
   - version: v8.0.0
     pr-url: https://github.com/nodejs/node/pull/9683
     description: End-of-Life.
-  - version: v6.0.0
-    pr-url: https://github.com/nodejs/node/pull/4525
-    description: Runtime deprecation.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
+  - version: v6.0.0
+    pr-url: https://github.com/nodejs/node/pull/4525
+    description: Runtime deprecation.
   - version: v0.1.96
     commit: c93e0aaf062081db3ec40ac45b3e2c979d5759d6
     description: Documentation-only deprecation.
@@ -367,21 +364,20 @@ Type: End-of-Life
 The [`fs.read()`][] legacy `String` interface is deprecated. Use the `Buffer`
 API as mentioned in the documentation instead.
 
-<a id="DEP0015"></a>
 ### DEP0015: `fs.readSync` legacy String interface
 <!-- YAML
 changes:
   - version: v8.0.0
     pr-url: https://github.com/nodejs/node/pull/9683
     description: End-of-Life.
-  - version: v6.0.0
-    pr-url: https://github.com/nodejs/node/pull/4525
-    description: Runtime deprecation.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
+  - version: v6.0.0
+    pr-url: https://github.com/nodejs/node/pull/4525
+    description: Runtime deprecation.
   - version: v0.1.96
     commit: c93e0aaf062081db3ec40ac45b3e2c979d5759d6
     description: Documentation-only deprecation.
@@ -392,10 +388,12 @@ Type: End-of-Life
 The [`fs.readSync()`][] legacy `String` interface is deprecated. Use the
 `Buffer` API as mentioned in the documentation instead.
 
-<a id="DEP0016"></a>
 ### DEP0016: `GLOBAL`/`root`
 <!-- YAML
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31167
+    description: End-of-Life.
   - version: v6.12.0
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
@@ -404,12 +402,11 @@ changes:
     description: Runtime deprecation.
 -->
 
-Type: Runtime
+Type: End-of-Life
 
-The `GLOBAL` and `root` aliases for the `global` property are deprecated
-and should no longer be used.
+The `GLOBAL` and `root` aliases for the `global` property were deprecated
+in Node.js 6.0.0 and have since been removed.
 
-<a id="DEP0017"></a>
 ### DEP0017: `Intl.v8BreakIterator`
 <!-- YAML
 changes:
@@ -426,7 +423,6 @@ Type: End-of-Life
 `Intl.v8BreakIterator` was a non-standard extension and has been removed.
 See [`Intl.Segmenter`](https://github.com/tc39/proposal-intl-segmenter).
 
-<a id="DEP0018"></a>
 ### DEP0018: Unhandled promise rejections
 <!-- YAML
 changes:
@@ -441,7 +437,6 @@ Unhandled promise rejections are deprecated. In the future, promise rejections
 that are not handled will terminate the Node.js process with a non-zero exit
 code.
 
-<a id="DEP0019"></a>
 ### DEP0019: `require('.')` resolved outside directory
 <!-- YAML
 changes:
@@ -449,8 +444,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/26973
     description: Removed functionality.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v1.8.1
@@ -463,13 +458,12 @@ Type: End-of-Life
 In certain cases, `require('.')` could resolve outside the package directory.
 This behavior has been removed.
 
-<a id="DEP0020"></a>
 ### DEP0020: `Server.connections`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.9.7
@@ -482,7 +476,6 @@ Type: Runtime
 The [`Server.connections`][] property is deprecated. Please use the
 [`Server.getConnections()`][] method instead.
 
-<a id="DEP0021"></a>
 ### DEP0021: `Server.listenFD`
 <!-- YAML
 changes:
@@ -490,8 +483,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/27127
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.7.12
@@ -504,20 +497,22 @@ Type: End-of-Life
 The `Server.listenFD()` method was deprecated and removed. Please use
 [`Server.listen({fd: <number>})`][] instead.
 
-<a id="DEP0022"></a>
 ### DEP0022: `os.tmpDir()`
 <!-- YAML
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31169
+    description: End-of-Life.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/6739
     description: Runtime deprecation.
 -->
 
-Type: Runtime
+Type: End-of-Life
 
-The `os.tmpDir()` API is deprecated. Please use [`os.tmpdir()`][] instead.
+The `os.tmpDir()` API was deprecated in Node.js 7.0.0 and has since been
+removed. Please use [`os.tmpdir()`][] instead.
 
-<a id="DEP0023"></a>
 ### DEP0023: `os.getNetworkInterfaces()`
 <!-- YAML
 changes:
@@ -525,8 +520,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/25280
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.6.0
@@ -539,7 +534,6 @@ Type: End-of-Life
 The `os.getNetworkInterfaces()` method is deprecated. Please use the
 [`os.networkInterfaces()`][] method instead.
 
-<a id="DEP0024"></a>
 ### DEP0024: `REPLServer.prototype.convertToContext()`
 <!-- YAML
 changes:
@@ -555,13 +549,12 @@ Type: End-of-Life
 
 The `REPLServer.prototype.convertToContext()` API has been removed.
 
-<a id="DEP0025"></a>
 ### DEP0025: `require('sys')`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v1.0.0
@@ -573,7 +566,6 @@ Type: Runtime
 
 The `sys` module is deprecated. Please use the [`util`][] module instead.
 
-<a id="DEP0026"></a>
 ### DEP0026: `util.print()`
 <!-- YAML
 changes:
@@ -581,8 +573,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/25377
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.3
@@ -594,7 +586,6 @@ Type: End-of-Life
 
 `util.print()` has been removed. Please use [`console.log()`][] instead.
 
-<a id="DEP0027"></a>
 ### DEP0027: `util.puts()`
 <!-- YAML
 changes:
@@ -602,8 +593,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/25377
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.3
@@ -615,7 +606,6 @@ Type: End-of-Life
 
 `util.puts()` has been removed. Please use [`console.log()`][] instead.
 
-<a id="DEP0028"></a>
 ### DEP0028: `util.debug()`
 <!-- YAML
 changes:
@@ -623,8 +613,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/25377
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.3
@@ -636,7 +626,6 @@ Type: End-of-Life
 
 `util.debug()` has been removed. Please use [`console.error()`][] instead.
 
-<a id="DEP0029"></a>
 ### DEP0029: `util.error()`
 <!-- YAML
 changes:
@@ -644,8 +633,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/25377
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.3
@@ -657,7 +646,6 @@ Type: End-of-Life
 
 `util.error()` has been removed. Please use [`console.error()`][] instead.
 
-<a id="DEP0030"></a>
 ### DEP0030: `SlowBuffer`
 <!-- YAML
 changes:
@@ -674,7 +662,6 @@ Type: Documentation-only
 The [`SlowBuffer`][] class is deprecated. Please use
 [`Buffer.allocUnsafeSlow(size)`][] instead.
 
-<a id="DEP0031"></a>
 ### DEP0031: `ecdh.setPublicKey()`
 <!-- YAML
 changes:
@@ -691,13 +678,12 @@ Type: Documentation-only
 The [`ecdh.setPublicKey()`][] method is now deprecated as its inclusion in the
 API is not useful.
 
-<a id="DEP0032"></a>
 ### DEP0032: `domain` module
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v1.4.2
@@ -709,13 +695,12 @@ Type: Documentation-only
 
 The [`domain`][] module is deprecated and should not be used.
 
-<a id="DEP0033"></a>
 ### DEP0033: `EventEmitter.listenerCount()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v3.2.0
@@ -725,20 +710,19 @@ changes:
 
 Type: Documentation-only
 
-The [`EventEmitter.listenerCount(emitter, eventName)`][] API is
+The [`events.listenerCount(emitter, eventName)`][] API is
 deprecated. Please use [`emitter.listenerCount(eventName)`][] instead.
 
-<a id="DEP0034"></a>
 ### DEP0034: `fs.exists(path, callback)`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v1.0.0
-    pr-url: https://github.com/iojs/io.js/pull/166
+    pr-url: https://github.com/nodejs/node/pull/166
     description: Documentation-only deprecation.
 -->
 
@@ -747,13 +731,12 @@ Type: Documentation-only
 The [`fs.exists(path, callback)`][] API is deprecated. Please use
 [`fs.stat()`][] or [`fs.access()`][] instead.
 
-<a id="DEP0035"></a>
 ### DEP0035: `fs.lchmod(path, mode, callback)`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.4.7
@@ -764,13 +747,12 @@ Type: Documentation-only
 
 The [`fs.lchmod(path, mode, callback)`][] API is deprecated.
 
-<a id="DEP0036"></a>
 ### DEP0036: `fs.lchmodSync(path, mode)`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.4.7
@@ -781,7 +763,6 @@ Type: Documentation-only
 
 The [`fs.lchmodSync(path, mode)`][] API is deprecated.
 
-<a id="DEP0037"></a>
 ### DEP0037: `fs.lchown(path, uid, gid, callback)`
 <!-- YAML
 changes:
@@ -789,8 +770,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/21498
     description: Deprecation revoked.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.4.7
@@ -803,7 +784,6 @@ The [`fs.lchown(path, uid, gid, callback)`][] API was deprecated. The
 deprecation was revoked because the requisite supporting APIs were added in
 libuv.
 
-<a id="DEP0038"></a>
 ### DEP0038: `fs.lchownSync(path, uid, gid)`
 <!-- YAML
 changes:
@@ -811,8 +791,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/21498
     description: Deprecation revoked.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.4.7
@@ -824,13 +804,12 @@ Type: Deprecation revoked
 The [`fs.lchownSync(path, uid, gid)`][] API was deprecated. The deprecation was
 revoked because the requisite supporting APIs were added in libuv.
 
-<a id="DEP0039"></a>
 ### DEP0039: `require.extensions`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.10.6
@@ -842,7 +821,6 @@ Type: Documentation-only
 
 The [`require.extensions`][] property is deprecated.
 
-<a id="DEP0040"></a>
 ### DEP0040: `punycode` module
 <!-- YAML
 changes:
@@ -856,7 +834,6 @@ Type: Documentation-only
 The [`punycode`][] module is deprecated. Please use a userland alternative
 instead.
 
-<a id="DEP0041"></a>
 ### DEP0041: `NODE_REPL_HISTORY_FILE` environment variable
 <!-- YAML
 changes:
@@ -864,8 +841,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/13876
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v3.0.0
@@ -878,7 +855,6 @@ Type: End-of-Life
 The `NODE_REPL_HISTORY_FILE` environment variable was removed. Please use
 `NODE_REPL_HISTORY` instead.
 
-<a id="DEP0042"></a>
 ### DEP0042: `tls.CryptoStream`
 <!-- YAML
 changes:
@@ -886,8 +862,8 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/17882
     description: End-of-Life.
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version: v0.11.3
@@ -900,7 +876,6 @@ Type: End-of-Life
 The [`tls.CryptoStream`][] class was removed. Please use
 [`tls.TLSSocket`][] instead.
 
-<a id="DEP0043"></a>
 ### DEP0043: `tls.SecurePair`
 <!-- YAML
 changes:
@@ -928,18 +903,17 @@ Type: Documentation-only
 The [`tls.SecurePair`][] class is deprecated. Please use
 [`tls.TLSSocket`][] instead.
 
-<a id="DEP0044"></a>
 ### DEP0044: `util.isArray()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -949,18 +923,17 @@ Type: Documentation-only
 The [`util.isArray()`][] API is deprecated. Please use `Array.isArray()`
 instead.
 
-<a id="DEP0045"></a>
 ### DEP0045: `util.isBoolean()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -969,18 +942,17 @@ Type: Documentation-only
 
 The [`util.isBoolean()`][] API is deprecated.
 
-<a id="DEP0046"></a>
 ### DEP0046: `util.isBuffer()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -990,18 +962,17 @@ Type: Documentation-only
 The [`util.isBuffer()`][] API is deprecated. Please use
 [`Buffer.isBuffer()`][] instead.
 
-<a id="DEP0047"></a>
 ### DEP0047: `util.isDate()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1010,18 +981,17 @@ Type: Documentation-only
 
 The [`util.isDate()`][] API is deprecated.
 
-<a id="DEP0048"></a>
 ### DEP0048: `util.isError()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1030,18 +1000,17 @@ Type: Documentation-only
 
 The [`util.isError()`][] API is deprecated.
 
-<a id="DEP0049"></a>
 ### DEP0049: `util.isFunction()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1050,18 +1019,17 @@ Type: Documentation-only
 
 The [`util.isFunction()`][] API is deprecated.
 
-<a id="DEP0050"></a>
 ### DEP0050: `util.isNull()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1070,18 +1038,17 @@ Type: Documentation-only
 
 The [`util.isNull()`][] API is deprecated.
 
-<a id="DEP0051"></a>
 ### DEP0051: `util.isNullOrUndefined()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1090,18 +1057,17 @@ Type: Documentation-only
 
 The [`util.isNullOrUndefined()`][] API is deprecated.
 
-<a id="DEP0052"></a>
 ### DEP0052: `util.isNumber()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1110,18 +1076,17 @@ Type: Documentation-only
 
 The [`util.isNumber()`][] API is deprecated.
 
-<a id="DEP0053"></a>
-### DEP0053 `util.isObject()`
+### DEP0053: `util.isObject()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1130,18 +1095,17 @@ Type: Documentation-only
 
 The [`util.isObject()`][] API is deprecated.
 
-<a id="DEP0054"></a>
 ### DEP0054: `util.isPrimitive()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1150,18 +1114,17 @@ Type: Documentation-only
 
 The [`util.isPrimitive()`][] API is deprecated.
 
-<a id="DEP0055"></a>
 ### DEP0055: `util.isRegExp()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1170,18 +1133,17 @@ Type: Documentation-only
 
 The [`util.isRegExp()`][] API is deprecated.
 
-<a id="DEP0056"></a>
 ### DEP0056: `util.isString()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1190,18 +1152,17 @@ Type: Documentation-only
 
 The [`util.isString()`][] API is deprecated.
 
-<a id="DEP0057"></a>
 ### DEP0057: `util.isSymbol()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1210,18 +1171,17 @@ Type: Documentation-only
 
 The [`util.isSymbol()`][] API is deprecated.
 
-<a id="DEP0058"></a>
 ### DEP0058: `util.isUndefined()`
 <!-- YAML
 changes:
   - version:
-    - v4.8.6
     - v6.12.0
+    - v4.8.6
     pr-url: https://github.com/nodejs/node/pull/10116
     description: A deprecation code has been assigned.
   - version:
-    - v3.3.1
     - v4.0.0
+    - v3.3.1
     pr-url: https://github.com/nodejs/node/pull/2447
     description: Documentation-only deprecation.
 -->
@@ -1230,7 +1190,6 @@ Type: Documentation-only
 
 The [`util.isUndefined()`][] API is deprecated.
 
-<a id="DEP0059"></a>
 ### DEP0059: `util.log()`
 <!-- YAML
 changes:
@@ -1246,7 +1205,6 @@ Type: Documentation-only
 
 The [`util.log()`][] API is deprecated.
 
-<a id="DEP0060"></a>
 ### DEP0060: `util._extend()`
 <!-- YAML
 changes:
@@ -1262,7 +1220,6 @@ Type: Documentation-only
 
 The [`util._extend()`][] API is deprecated.
 
-<a id="DEP0061"></a>
 ### DEP0061: `fs.SyncWriteStream`
 <!-- YAML
 changes:
@@ -1283,16 +1240,15 @@ The `fs.SyncWriteStream` class was never intended to be a publicly accessible
 API and has been removed. No alternative API is available. Please use a userland
 alternative.
 
-<a id="DEP0062"></a>
 ### DEP0062: `node --debug`
 <!-- YAML
 changes:
-  - version: v8.0.0
-    pr-url: https://github.com/nodejs/node/pull/10970
-    description: Runtime deprecation.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/25828
     description: End-of-Life.
+  - version: v8.0.0
+    pr-url: https://github.com/nodejs/node/pull/10970
+    description: Runtime deprecation.
 -->
 
 Type: End-of-Life
@@ -1301,7 +1257,6 @@ Type: End-of-Life
 of V8 5.8. It is replaced by Inspector which is activated with `--inspect`
 instead.
 
-<a id="DEP0063"></a>
 ### DEP0063: `ServerResponse.prototype.writeHeader()`
 <!-- YAML
 changes:
@@ -1318,7 +1273,6 @@ deprecated. Please use `ServerResponse.prototype.writeHead()` instead.
 The `ServerResponse.prototype.writeHeader()` method was never documented as an
 officially supported API.
 
-<a id="DEP0064"></a>
 ### DEP0064: `tls.createSecurePair()`
 <!-- YAML
 changes:
@@ -1346,7 +1300,6 @@ Type: Runtime
 The `tls.createSecurePair()` API was deprecated in documentation in Node.js
 0.11.3. Users should use `tls.Socket` instead.
 
-<a id="DEP0065"></a>
 ### DEP0065: `repl.REPL_MODE_MAGIC` and `NODE_REPL_MODE=magic`
 <!-- YAML
 changes:
@@ -1369,7 +1322,6 @@ The `NODE_REPL_MODE` environment variable is used to set the underlying
 `replMode` of an interactive `node` session. Its value, `magic`, is also
 removed. Please use `sloppy` instead.
 
-<a id="DEP0066"></a>
 ### DEP0066: `OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames`
 <!-- YAML
 changes:
@@ -1388,6 +1340,7 @@ The `http` module `OutgoingMessage.prototype._headers` and
 the public methods (e.g. `OutgoingMessage.prototype.getHeader()`,
 `OutgoingMessage.prototype.getHeaders()`,
 `OutgoingMessage.prototype.getHeaderNames()`,
+`OutgoingMessage.prototype.getRawHeaderNames()`,
 `OutgoingMessage.prototype.hasHeader()`,
 `OutgoingMessage.prototype.removeHeader()`,
 `OutgoingMessage.prototype.setHeader()`) for working with outgoing headers.
@@ -1396,7 +1349,6 @@ The `OutgoingMessage.prototype._headers` and
 `OutgoingMessage.prototype._headerNames` properties were never documented as
 officially supported properties.
 
-<a id="DEP0067"></a>
 ### DEP0067: `OutgoingMessage.prototype._renderHeaders`
 <!-- YAML
 changes:
@@ -1413,7 +1365,6 @@ deprecated.
 The `OutgoingMessage.prototype._renderHeaders` property was never documented as
 an officially supported API.
 
-<a id="DEP0068"></a>
 ### DEP0068: `node debug`
 <!-- YAML
 changes:
@@ -1427,7 +1378,6 @@ Type: Runtime
 `node debug` corresponds to the legacy CLI debugger which has been replaced with
 a V8-inspector based CLI debugger available through `node inspect`.
 
-<a id="DEP0069"></a>
 ### DEP0069: `vm.runInDebugContext(string)`
 <!-- YAML
 changes:
@@ -1448,7 +1398,6 @@ DebugContext has been removed in V8 and is not available in Node.js 10+.
 
 DebugContext was an experimental API.
 
-<a id="DEP0070"></a>
 ### DEP0070: `async_hooks.currentId()`
 <!-- YAML
 changes:
@@ -1467,7 +1416,6 @@ clarity.
 
 This change was made while `async_hooks` was an experimental API.
 
-<a id="DEP0071"></a>
 ### DEP0071: `async_hooks.triggerId()`
 <!-- YAML
 changes:
@@ -1486,7 +1434,6 @@ clarity.
 
 This change was made while `async_hooks` was an experimental API.
 
-<a id="DEP0072"></a>
 ### DEP0072: `async_hooks.AsyncResource.triggerId()`
 <!-- YAML
 changes:
@@ -1505,7 +1452,6 @@ Type: End-of-Life
 
 This change was made while `async_hooks` was an experimental API.
 
-<a id="DEP0073"></a>
 ### DEP0073: Several internal properties of `net.Server`
 <!-- YAML
 changes:
@@ -1525,7 +1471,6 @@ with inappropriate names is deprecated.
 As the original API was undocumented and not generally useful for non-internal
 code, no replacement API is provided.
 
-<a id="DEP0074"></a>
 ### DEP0074: `REPLServer.bufferedCommand`
 <!-- YAML
 changes:
@@ -1539,7 +1484,6 @@ Type: Runtime
 The `REPLServer.bufferedCommand` property was deprecated in favor of
 [`REPLServer.clearBufferedCommand()`][].
 
-<a id="DEP0075"></a>
 ### DEP0075: `REPLServer.parseREPLKeyword()`
 <!-- YAML
 changes:
@@ -1552,7 +1496,6 @@ Type: Runtime
 
 `REPLServer.parseREPLKeyword()` was removed from userland visibility.
 
-<a id="DEP0076"></a>
 ### DEP0076: `tls.parseCertString()`
 <!-- YAML
 changes:
@@ -1584,7 +1527,6 @@ difference is that `querystring.parse()` does url decoding:
 { '%E5%A5%BD': '1' }
 ```
 
-<a id="DEP0077"></a>
 ### DEP0077: `Module._debug()`
 <!-- YAML
 changes:
@@ -1600,7 +1542,6 @@ Type: Runtime
 The `Module._debug()` function was never documented as an officially
 supported API.
 
-<a id="DEP0078"></a>
 ### DEP0078: `REPLServer.turnOffEditorMode()`
 <!-- YAML
 changes:
@@ -1613,7 +1554,6 @@ Type: Runtime
 
 `REPLServer.turnOffEditorMode()` was removed from userland visibility.
 
-<a id="DEP0079"></a>
 ### DEP0079: Custom inspection function on objects via `.inspect()`
 <!-- YAML
 changes:
@@ -1633,9 +1573,8 @@ Type: End-of-Life
 Using a property named `inspect` on an object to specify a custom inspection
 function for [`util.inspect()`][] is deprecated. Use [`util.inspect.custom`][]
 instead. For backward compatibility with Node.js prior to version 6.4.0, both
-may be specified.
+can be specified.
 
-<a id="DEP0080"></a>
 ### DEP0080: `path._makeLong()`
 <!-- YAML
 changes:
@@ -1650,7 +1589,6 @@ The internal `path._makeLong()` was not intended for public use. However,
 userland modules have found it useful. The internal API is deprecated
 and replaced with an identical, public `path.toNamespacedPath()` method.
 
-<a id="DEP0081"></a>
 ### DEP0081: `fs.truncate()` using a file descriptor
 <!-- YAML
 changes:
@@ -1665,7 +1603,6 @@ Type: Runtime
 deprecated. Please use `fs.ftruncate()` or `fs.ftruncateSync()` to work with
 file descriptors.
 
-<a id="DEP0082"></a>
 ### DEP0082: `REPLServer.prototype.memory()`
 <!-- YAML
 changes:
@@ -1679,7 +1616,6 @@ Type: Runtime
 `REPLServer.prototype.memory()` is only necessary for the internal mechanics of
 the `REPLServer` itself. Do not use this function.
 
-<a id="DEP0083"></a>
 ### DEP0083: Disabling ECDH by setting `ecdhCurve` to `false`
 <!-- YAML
 changes:
@@ -1698,7 +1634,6 @@ be set to `false` to disable ECDH entirely on the server only. This mode was
 deprecated in preparation for migrating to OpenSSL 1.1.0 and consistency with
 the client and is now unsupported. Use the `ciphers` parameter instead.
 
-<a id="DEP0084"></a>
 ### DEP0084: requiring bundled internal dependencies
 <!-- YAML
 changes:
@@ -1734,20 +1669,19 @@ The `v8/*` modules do not have any exports, and if not imported in a specific
 order would in fact throw errors. As such there are virtually no legitimate use
 cases for importing them through `require()`.
 
-On the other hand, `node-inspect` may be installed locally through a package
+On the other hand, `node-inspect` can be installed locally through a package
 manager, as it is published on the npm registry under the same name. No source
 code modification is necessary if that is done.
 
-<a id="DEP0085"></a>
 ### DEP0085: AsyncHooks sensitive API
 <!-- YAML
 changes:
-  - version: 10.0.0
+  - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/17147
     description: End-of-Life.
   - version:
-    - v8.10.0
     - v9.4.0
+    - v8.10.0
     pr-url: https://github.com/nodejs/node/pull/16972
     description: Runtime deprecation.
 -->
@@ -1758,16 +1692,15 @@ The AsyncHooks sensitive API was never documented and had various minor issues.
 Use the `AsyncResource` API instead. See
 <https://github.com/nodejs/node/issues/15572>.
 
-<a id="DEP0086"></a>
 ### DEP0086: Remove `runInAsyncIdScope`
 <!-- YAML
 changes:
-  - version: 10.0.0
+  - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/17147
     description: End-of-Life.
   - version:
-    - v8.10.0
     - v9.4.0
+    - v8.10.0
     pr-url: https://github.com/nodejs/node/pull/16972
     description: Runtime deprecation.
 -->
@@ -1777,7 +1710,6 @@ Type: End-of-Life
 `runInAsyncIdScope` doesn't emit the `'before'` or `'after'` event and can thus
 cause a lot of issues. See <https://github.com/nodejs/node/issues/14328>.
 
-<a id="DEP0089"></a>
 ### DEP0089: `require('assert')`
 <!-- YAML
 changes:
@@ -1786,7 +1718,7 @@ changes:
     description: Deprecation revoked.
   - version:
       - v9.9.0
-      - v10.0.0
+      - v8.13.0
     pr-url: https://github.com/nodejs/node/pull/17002
     description: Documentation-only deprecation.
 -->
@@ -1797,7 +1729,6 @@ Importing assert directly was not recommended as the exposed functions use
 loose equality checks. The deprecation was revoked because use of the `assert`
 module is not discouraged, and the deprecation caused developer confusion.
 
-<a id="DEP0090"></a>
 ### DEP0090: Invalid GCM authentication tag lengths
 <!-- YAML
 changes:
@@ -1817,7 +1748,6 @@ v11.0.0, only authentication tag lengths of 128, 120, 112, 104, 96, 64, and 32
 bits are allowed. Authentication tags of other lengths are invalid per
 [NIST SP 800-38D][].
 
-<a id="DEP0091"></a>
 ### DEP0091: `crypto.DEFAULT_ENCODING`
 <!-- YAML
 changes:
@@ -1830,7 +1760,6 @@ Type: Runtime
 
 The [`crypto.DEFAULT_ENCODING`][] property is deprecated.
 
-<a id="DEP0092"></a>
 ### DEP0092: Top-level `this` bound to `module.exports`
 <!-- YAML
 changes:
@@ -1845,8 +1774,7 @@ Assigning properties to the top-level `this` as an alternative
 to `module.exports` is deprecated. Developers should use `exports`
 or `module.exports` instead.
 
-<a id="DEP0093"></a>
-### DEP0093: `crypto.fips` is deprecated and replaced.
+### DEP0093: `crypto.fips` is deprecated and replaced
 <!-- YAML
 changes:
   - version: v10.0.0
@@ -1859,8 +1787,7 @@ Type: Documentation-only
 The [`crypto.fips`][] property is deprecated. Please use `crypto.setFips()`
 and `crypto.getFips()` instead.
 
-<a id="DEP0094"></a>
-### DEP0094: Using `assert.fail()` with more than one argument.
+### DEP0094: Using `assert.fail()` with more than one argument
 <!-- YAML
 changes:
   - version: v10.0.0
@@ -1874,7 +1801,6 @@ Using `assert.fail()` with more than one argument is deprecated. Use
 `assert.fail()` with only one argument or use a different `assert` module
 method.
 
-<a id="DEP0095"></a>
 ### DEP0095: `timers.enroll()`
 <!-- YAML
 changes:
@@ -1888,7 +1814,6 @@ Type: Runtime
 `timers.enroll()` is deprecated. Please use the publicly documented
 [`setTimeout()`][] or [`setInterval()`][] instead.
 
-<a id="DEP0096"></a>
 ### DEP0096: `timers.unenroll()`
 <!-- YAML
 changes:
@@ -1902,7 +1827,6 @@ Type: Runtime
 `timers.unenroll()` is deprecated. Please use the publicly documented
 [`clearTimeout()`][] or [`clearInterval()`][] instead.
 
-<a id="DEP0097"></a>
 ### DEP0097: `MakeCallback` with `domain` property
 <!-- YAML
 changes:
@@ -1917,17 +1841,16 @@ Users of `MakeCallback` that add the `domain` property to carry context,
 should start using the `async_context` variant of `MakeCallback` or
 `CallbackScope`, or the high-level `AsyncResource` class.
 
-<a id="DEP0098"></a>
 ### DEP0098: AsyncHooks embedder `AsyncResource.emitBefore` and `AsyncResource.emitAfter` APIs
 <!-- YAML
 changes:
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26530
-    description: End-of-Life
+    description: End-of-Life.
   - version:
-    - v8.12.0
-    - v9.6.0
     - v10.0.0
+    - v9.6.0
+    - v8.12.0
     pr-url: https://github.com/nodejs/node/pull/18632
     description: Runtime deprecation.
 -->
@@ -1942,7 +1865,6 @@ Use [`asyncResource.runInAsyncScope()`][] API instead which provides a much
 safer, and more convenient, alternative. See
 <https://github.com/nodejs/node/pull/18513>.
 
-<a id="DEP0099"></a>
 ### DEP0099: Async context-unaware `node::MakeCallback` C++ APIs
 <!-- YAML
 changes:
@@ -1957,7 +1879,6 @@ Certain versions of `node::MakeCallback` APIs available to native modules are
 deprecated. Please use the versions of the API that accept an `async_context`
 parameter.
 
-<a id="DEP0100"></a>
 ### DEP0100: `process.assert()`
 <!-- YAML
 changes:
@@ -1974,7 +1895,6 @@ Type: Runtime
 
 This was never a documented feature.
 
-<a id="DEP0101"></a>
 ### DEP0101: `--with-lttng`
 <!-- YAML
 changes:
@@ -1987,8 +1907,7 @@ Type: End-of-Life
 
 The `--with-lttng` compile-time option has been removed.
 
-<a id="DEP0102"></a>
-### DEP0102: Using `noAssert` in `Buffer#(read|write)` operations.
+### DEP0102: Using `noAssert` in `Buffer#(read|write)` operations
 <!-- YAML
 changes:
   - version: v10.0.0
@@ -2002,7 +1921,6 @@ Using the `noAssert` argument has no functionality anymore. All input is going
 to be verified, no matter if it is set to true or not. Skipping the verification
 could lead to hard to find errors and crashes.
 
-<a id="DEP0103"></a>
 ### DEP0103: `process.binding('util').is[...]` typechecks
 <!-- YAML
 changes:
@@ -2022,7 +1940,6 @@ methods in particular can be replaced by using [`util.types`][].
 This deprecation has been superseded by the deprecation of the
 `process.binding()` API ([DEP0111](#DEP0111)).
 
-<a id="DEP0104"></a>
 ### DEP0104: `process.env` string coercion
 <!-- YAML
 changes:
@@ -2035,11 +1952,10 @@ Type: Documentation-only (supports [`--pending-deprecation`][])
 
 When assigning a non-string property to [`process.env`][], the assigned value is
 implicitly converted to a string. This behavior is deprecated if the assigned
-value is not a string, boolean, or number. In the future, such assignment may
+value is not a string, boolean, or number. In the future, such assignment might
 result in a thrown error. Please convert the property to a string before
 assigning it to `process.env`.
 
-<a id="DEP0105"></a>
 ### DEP0105: `decipher.finaltol`
 <!-- YAML
 changes:
@@ -2057,7 +1973,6 @@ Type: End-of-Life
 [`decipher.final()`][]. This API has been removed, and it is recommended to use
 [`decipher.final()`][] instead.
 
-<a id="DEP0106"></a>
 ### DEP0106: `crypto.createCipher` and `crypto.createDecipher`
 <!-- YAML
 changes:
@@ -2078,7 +1993,6 @@ initialization vectors. It is recommended to derive a key using
 [`crypto.createCipheriv()`][] and [`crypto.createDecipheriv()`][] to obtain the
 [`Cipher`][] and [`Decipher`][] objects respectively.
 
-<a id="DEP0107"></a>
 ### DEP0107: `tls.convertNPNProtocols()`
 <!-- YAML
 changes:
@@ -2095,7 +2009,6 @@ Type: End-of-Life
 This was an undocumented helper function not intended for use outside Node.js
 core and obsoleted by the removal of NPN (Next Protocol Negotiation) support.
 
-<a id="DEP0108"></a>
 ### DEP0108: `zlib.bytesRead`
 <!-- YAML
 changes:
@@ -2114,7 +2027,6 @@ because it also made sense to interpret the value as the number of bytes
 read by the engine, but is inconsistent with other streams in Node.js that
 expose values under these names.
 
-<a id="DEP0109"></a>
 ### DEP0109: `http`, `https`, and `tls` support for invalid URLs
 <!-- YAML
 changes:
@@ -2132,7 +2044,6 @@ accepted by the legacy `url.parse()` API. The mentioned APIs now use the WHATWG
 URL parser that requires strictly valid URLs. Passing an invalid URL is
 deprecated and support will be removed in the future.
 
-<a id="DEP0110"></a>
 ### DEP0110: `vm.Script` cached data
 <!-- YAML
 changes:
@@ -2146,23 +2057,21 @@ Type: Documentation-only
 The `produceCachedData` option is deprecated. Use
 [`script.createCachedData()`][] instead.
 
-<a id="DEP0111"></a>
 ### DEP0111: `process.binding()`
 <!-- YAML
 changes:
-  - version: v10.9.0
-    pr-url: https://github.com/nodejs/node/pull/22004
-    description: Documentation-only deprecation.
   - version: v11.12.0
     pr-url: https://github.com/nodejs/node/pull/26500
     description: Added support for `--pending-deprecation`.
+  - version: v10.9.0
+    pr-url: https://github.com/nodejs/node/pull/22004
+    description: Documentation-only deprecation.
 -->
 
 Type: Documentation-only (supports [`--pending-deprecation`][])
 
 `process.binding()` is for use by Node.js internal code only.
 
-<a id="DEP0112"></a>
 ### DEP0112: `dgram` private APIs
 <!-- YAML
 changes:
@@ -2180,7 +2089,6 @@ accessed outside of Node.js core: `Socket.prototype._handle`,
 `Socket.prototype._healthCheck()`, `Socket.prototype._stopReceiving()`, and
 `dgram._createSocketHandle()`.
 
-<a id="DEP0113"></a>
 ### DEP0113: `Cipher.setAuthTag()`, `Decipher.getAuthTag()`
 <!-- YAML
 changes:
@@ -2197,7 +2105,6 @@ Type: End-of-Life
 `Cipher.setAuthTag()` and `Decipher.getAuthTag()` are no longer available. They
 were never documented and would throw when called.
 
-<a id="DEP0114"></a>
 ### DEP0114: `crypto._toBuf()`
 <!-- YAML
 changes:
@@ -2214,8 +2121,10 @@ Type: End-of-Life
 The `crypto._toBuf()` function was not designed to be used by modules outside
 of Node.js core and was removed.
 
-<a id="DEP0115"></a>
 ### DEP0115: `crypto.prng()`, `crypto.pseudoRandomBytes()`, `crypto.rng()`
+
+<!--lint disable nodejs-yaml-comments -->
+
 <!-- YAML
 changes:
   - version: v11.0.0
@@ -2226,30 +2135,33 @@ changes:
                  with `--pending-deprecation` support.
 -->
 
+<!--lint enable nodejs-yaml-comments -->
+
 Type: Documentation-only (supports [`--pending-deprecation`][])
 
 In recent versions of Node.js, there is no difference between
 [`crypto.randomBytes()`][] and `crypto.pseudoRandomBytes()`. The latter is
 deprecated along with the undocumented aliases `crypto.prng()` and
-`crypto.rng()` in favor of [`crypto.randomBytes()`][] and may be removed in a
+`crypto.rng()` in favor of [`crypto.randomBytes()`][] and might be removed in a
 future release.
 
-<a id="DEP0116"></a>
 ### DEP0116: Legacy URL API
 <!-- YAML
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37784
+    description: Deprecation revoked. Status changed to "Legacy".
   - version: v11.0.0
     pr-url: https://github.com/nodejs/node/pull/22715
     description: Documentation-only deprecation.
 -->
 
-Type: Documentation-only
+Type: Deprecation revoked
 
 The [Legacy URL API][] is deprecated. This includes [`url.format()`][],
 [`url.parse()`][], [`url.resolve()`][], and the [legacy `urlObject`][]. Please
 use the [WHATWG URL API][] instead.
 
-<a id="DEP0117"></a>
 ### DEP0117: Native crypto handles
 <!-- YAML
 changes:
@@ -2269,7 +2181,6 @@ the `_handle` property of the `Cipher`, `Decipher`, `DiffieHellman`,
 The `_handle` property has been removed because improper use of the native
 object can lead to crashing the application.
 
-<a id="DEP0118"></a>
 ### DEP0118: `dns.lookup()` support for a falsy host name
 <!-- YAML
 changes:
@@ -2285,7 +2196,6 @@ like `dns.lookup(false)` due to backward compatibility.
 This behavior is undocumented and is thought to be unused in real world apps.
 It will become an error in future versions of Node.js.
 
-<a id="DEP0119"></a>
 ### DEP0119: `process.binding('uv').errname()` private API
 <!-- YAML
 changes:
@@ -2299,7 +2209,6 @@ Type: Documentation-only (supports [`--pending-deprecation`][])
 `process.binding('uv').errname()` is deprecated. Please use
 [`util.getSystemErrorName()`][] instead.
 
-<a id="DEP0120"></a>
 ### DEP0120: Windows Performance Counter support
 <!-- YAML
 changes:
@@ -2319,7 +2228,6 @@ undocumented `COUNTER_NET_SERVER_CONNECTION()`,
 `COUNTER_HTTP_SERVER_RESPONSE()`, `COUNTER_HTTP_CLIENT_REQUEST()`, and
 `COUNTER_HTTP_CLIENT_RESPONSE()` functions have been deprecated.
 
-<a id="DEP0121"></a>
 ### DEP0121: `net._setSimultaneousAccepts()`
 <!-- YAML
 changes:
@@ -2336,7 +2244,6 @@ and `cluster` modules on Windows. The function is not generally useful and
 is being removed. See discussion here:
 <https://github.com/nodejs/node/issues/18391>
 
-<a id="DEP0122"></a>
 ### DEP0122: `tls` `Server.prototype.setOptions()`
 <!-- YAML
 changes:
@@ -2349,7 +2256,6 @@ Type: Runtime
 
 Please use `Server.prototype.setSecureContext()` instead.
 
-<a id="DEP0123"></a>
 ### DEP0123: setting the TLS ServerName to an IP address
 <!-- YAML
 changes:
@@ -2363,7 +2269,6 @@ Type: Runtime
 Setting the TLS ServerName to an IP address is not permitted by
 [RFC 6066][]. This will be ignored in a future version.
 
-<a id="DEP0124"></a>
 ### DEP0124: using `REPLServer.rli`
 <!-- YAML
 changes:
@@ -2376,7 +2281,6 @@ Type: Runtime
 
 This property is a reference to the instance itself.
 
-<a id="DEP0125"></a>
 ### DEP0125: `require('_stream_wrap')`
 <!-- YAML
 changes:
@@ -2389,7 +2293,6 @@ Type: Runtime
 
 The `_stream_wrap` module is deprecated.
 
-<a id="DEP0126"></a>
 ### DEP0126: `timers.active()`
 <!-- YAML
 changes:
@@ -2405,7 +2308,6 @@ Please use the publicly documented [`timeout.refresh()`][] instead.
 If re-referencing the timeout is necessary, [`timeout.ref()`][] can be used
 with no performance impact since Node.js 10.
 
-<a id="DEP0127"></a>
 ### DEP0127: `timers._unrefActive()`
 <!-- YAML
 changes:
@@ -2421,7 +2323,6 @@ Please use the publicly documented [`timeout.refresh()`][] instead.
 If unreferencing the timeout is necessary, [`timeout.unref()`][] can be used
 with no performance impact since Node.js 10.
 
-<a id="DEP0128"></a>
 ### DEP0128: modules with an invalid `main` entry and an `index.js` file
 <!-- YAML
 changes:
@@ -2437,53 +2338,57 @@ also have an `index.js` file in the top level directory will resolve the
 `index.js` file. That is deprecated and is going to throw an error in future
 Node.js versions.
 
-<a id="DEP0129"></a>
 ### DEP0129: `ChildProcess._channel`
 <!-- YAML
 changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27949
+    description: Runtime deprecation.
   - version: v11.14.0
     pr-url: https://github.com/nodejs/node/pull/26982
     description: Documentation-only.
 -->
 
-Type: Documentation-only
+Type: Runtime
 
 The `_channel` property of child process objects returned by `spawn()` and
 similar functions is not intended for public use. Use `ChildProcess.channel`
 instead.
 
-<a id="DEP0130"></a>
 ### DEP0130: `Module.createRequireFromPath()`
 <!-- YAML
 changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27951
+    description: Runtime deprecation.
   - version: v12.2.0
     pr-url: https://github.com/nodejs/node/pull/27405
     description: Documentation-only.
 -->
 
-Type: Documentation-only
+Type: Runtime
 
-Module.createRequireFromPath() is deprecated. Please use [`module.createRequire()`][] instead.
+Module.createRequireFromPath() is deprecated. Please use
+[`module.createRequire()`][] instead.
 
-<a id="DEP0131"></a>
 ### DEP0131: Legacy HTTP parser
 <!-- YAML
 changes:
-  - version: v12.22.0
-    pr-url: https://github.com/nodejs/node/pull/37603
-    description: Runtime deprecation.
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/29589
+    description: This feature has been removed.
   - version: v12.3.0
     pr-url: https://github.com/nodejs/node/pull/27498
     description: Documentation-only.
 -->
 
-Type: Runtime
+Type: End-of-Life
 
 The legacy HTTP parser, used by default in versions of Node.js prior to 12.0.0,
-is deprecated. This deprecation applies to users of the
-[`--http-parser=legacy`][] command-line flag.
+is deprecated and has been removed in v13.0.0. Prior to v13.0.0, the
+`--http-parser=legacy` command-line flag could be used to revert to using the
+legacy parser.
 
-<a id="DEP0132"></a>
 ### DEP0132: `worker.terminate()` with callback
 <!-- YAML
 changes:
@@ -2497,7 +2402,6 @@ Type: Runtime
 Passing a callback to [`worker.terminate()`][] is deprecated. Use the returned
 `Promise` instead, or a listener to the worker’s `'exit'` event.
 
-<a id="DEP0133"></a>
 ### DEP0133: `http` `connection`
 <!-- YAML
 changes:
@@ -2511,7 +2415,6 @@ Type: Documentation-only
 Prefer [`response.socket`][] over [`response.connection`][] and
 [`request.socket`][] over [`request.connection`][].
 
-<a id="DEP0134"></a>
 ### DEP0134: `process._tickCallback`
 <!-- YAML
 changes:
@@ -2524,11 +2427,27 @@ Type: Documentation-only (supports [`--pending-deprecation`][])
 The `process._tickCallback` property was never documented as
 an officially supported API.
 
-<a id="DEP0136"></a>
+### DEP0135: `WriteStream.open()` and `ReadStream.open()` are internal
+<!-- YAML
+changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/29061
+    description: Runtime deprecation.
+-->
+
+Type: Runtime
+
+[`WriteStream.open()`][] and [`ReadStream.open()`][] are undocumented internal
+APIs that do not make sense to use in userland. File streams should always be
+opened through their corresponding factory methods [`fs.createWriteStream()`][]
+and [`fs.createReadStream()`][]) or by passing a file descriptor in options.
+
 ### DEP0136: `http` `finished`
 <!-- YAML
 changes:
-  - version: v12.16.0
+  - version:
+     - v13.4.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/28679
     description: Documentation-only deprecation.
 -->
@@ -2540,18 +2459,64 @@ called, not whether `'finish'` has been emitted and the underlying data
 is flushed.
 
 Use [`response.writableFinished`][] or [`response.writableEnded`][]
-accordingly instead to avoid the ambigiuty.
+accordingly instead to avoid the ambiguity.
 
 To maintain existing behaviour `response.finished` should be replaced with
 `response.writableEnded`.
 
-<a id="DEP0139"></a>
+### DEP0137: Closing fs.FileHandle on garbage collection
+<!-- YAML
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/28396
+    description: Runtime deprecation.
+-->
+
+Type: Runtime
+
+Allowing a [`fs.FileHandle`][] object to be closed on garbage collection is
+deprecated. In the future, doing so might result in a thrown error that will
+terminate the process.
+
+Please ensure that all `fs.FileHandle` objects are explicitly closed using
+`FileHandle.prototype.close()` when the `fs.FileHandle` is no longer needed:
+
+```js
+const fsPromises = require('fs').promises;
+async function openAndClose() {
+  let filehandle;
+  try {
+    filehandle = await fsPromises.open('thefile.txt', 'r');
+  } finally {
+    if (filehandle !== undefined)
+      await filehandle.close();
+  }
+}
+```
+
+### DEP0138: `process.mainModule`
+<!-- YAML
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/32232
+    description: Documentation-only deprecation.
+-->
+
+Type: Documentation-only
+
+[`process.mainModule`][] is a CommonJS-only feature while `process` global
+object is shared with non-CommonJS environment. Its use within ECMAScript
+modules is unsupported.
+
+It is deprecated in favor of [`require.main`][], because it serves the same
+purpose and is only available on CommonJS environment.
+
 ### DEP0139: `process.umask()` with no arguments
 <!-- YAML
 changes:
   - version:
-    - v12.19.0
     - v14.0.0
+    - v12.19.0
     pr-url: https://github.com/nodejs/node/pull/32499
     description: Documentation-only deprecation.
 -->
@@ -2563,13 +2528,64 @@ written twice. This introduces a race condition between threads, and is a
 potential security vulnerability. There is no safe, cross-platform alternative
 API.
 
-<a id="DEP0144"></a>
+### DEP0140: Use `request.destroy()` instead of `request.abort()`
+<!-- YAML
+changes:
+  - version:
+    - v14.1.0
+    - v13.14.0
+    pr-url: https://github.com/nodejs/node/pull/32807
+    description: Documentation-only deprecation.
+-->
+
+Type: Documentation-only
+
+Use [`request.destroy()`][] instead of [`request.abort()`][].
+
+### DEP0141: `repl.inputStream` and `repl.outputStream`
+<!-- YAML
+changes:
+  - version: v14.3.0
+    pr-url: https://github.com/nodejs/node/pull/33294
+    description: Documentation-only (supports [`--pending-deprecation`][]).
+-->
+
+Type: Documentation-only (supports [`--pending-deprecation`][])
+
+The `repl` module exported the input and output stream twice. Use `.input`
+instead of `.inputStream` and `.output` instead of `.outputStream`.
+
+### DEP0142: `repl._builtinLibs`
+<!-- YAML
+changes:
+  - version: v14.3.0
+    pr-url: https://github.com/nodejs/node/pull/33294
+    description: Documentation-only (supports [`--pending-deprecation`][]).
+-->
+
+Type: Documentation-only
+
+The `repl` module exports a `_builtinLibs` property that contains an array with
+native modules. It was incomplete so far and instead it's better to rely upon
+`require('module').builtinModules`.
+
+### DEP0143: `Transform._transformState`
+<!-- YAML
+changes:
+  - version: v14.5.0
+    pr-url: https://github.com/nodejs/node/pull/33126
+    description: Runtime deprecation.
+-->
+Type: Runtime
+`Transform._transformState` will be removed in future versions where it is
+no longer required due to simplification of the implementation.
+
 ### DEP0144: `module.parent`
 <!-- YAML
 changes:
   - version:
-    - v12.19.0
     - v14.6.0
+    - v12.19.0
     pr-url: https://github.com/nodejs/node/pull/32217
     description: Documentation-only deprecation.
 -->
@@ -2598,115 +2614,184 @@ const moduleParents = Object.values(require.cache)
   .filter((m) => m.children.includes(module));
 ```
 
-[`--http-parser=legacy`]: cli.html#cli_http_parser_library
-[`--pending-deprecation`]: cli.html#cli_pending_deprecation
-[`--throw-deprecation`]: cli.html#cli_throw_deprecation
-[`Buffer.allocUnsafeSlow(size)`]: buffer.html#buffer_static_method_buffer_allocunsafeslow_size
-[`Buffer.from(array)`]: buffer.html#buffer_static_method_buffer_from_array
-[`Buffer.from(buffer)`]: buffer.html#buffer_static_method_buffer_from_buffer
-[`Buffer.isBuffer()`]: buffer.html#buffer_static_method_buffer_isbuffer_obj
-[`Cipher`]: crypto.html#crypto_class_cipher
-[`Decipher`]: crypto.html#crypto_class_decipher
-[`EventEmitter.listenerCount(emitter, eventName)`]: events.html#events_eventemitter_listenercount_emitter_eventname
-[`REPLServer.clearBufferedCommand()`]: repl.html#repl_replserver_clearbufferedcommand
-[`Server.connections`]: net.html#net_server_connections
-[`Server.getConnections()`]: net.html#net_server_getconnections_callback
-[`Server.listen({fd: <number>})`]: net.html#net_server_listen_handle_backlog_callback
-[`SlowBuffer`]: buffer.html#buffer_class_slowbuffer
-[`assert`]: assert.html
-[`asyncResource.runInAsyncScope()`]: async_hooks.html#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args
-[`child_process`]: child_process.html
-[`clearInterval()`]: timers.html#timers_clearinterval_timeout
-[`clearTimeout()`]: timers.html#timers_cleartimeout_timeout
-[`console.error()`]: console.html#console_console_error_data_args
-[`console.log()`]: console.html#console_console_log_data_args
-[`crypto.DEFAULT_ENCODING`]: crypto.html#crypto_crypto_default_encoding
-[`crypto.createCipher()`]: crypto.html#crypto_crypto_createcipher_algorithm_password_options
-[`crypto.createCipheriv()`]: crypto.html#crypto_crypto_createcipheriv_algorithm_key_iv_options
-[`crypto.createDecipher()`]: crypto.html#crypto_crypto_createdecipher_algorithm_password_options
-[`crypto.createDecipheriv()`]: crypto.html#crypto_crypto_createdecipheriv_algorithm_key_iv_options
-[`crypto.fips`]: crypto.html#crypto_crypto_fips
-[`crypto.pbkdf2()`]: crypto.html#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback
-[`crypto.randomBytes()`]: crypto.html#crypto_crypto_randombytes_size_callback
-[`crypto.scrypt()`]: crypto.html#crypto_crypto_scrypt_password_salt_keylen_options_callback
-[`decipher.final()`]: crypto.html#crypto_decipher_final_outputencoding
-[`decipher.setAuthTag()`]: crypto.html#crypto_decipher_setauthtag_buffer
-[`domain`]: domain.html
-[`ecdh.setPublicKey()`]: crypto.html#crypto_ecdh_setpublickey_publickey_encoding
-[`emitter.listenerCount(eventName)`]: events.html#events_emitter_listenercount_eventname
-[`fs.access()`]: fs.html#fs_fs_access_path_mode_callback
-[`fs.exists(path, callback)`]: fs.html#fs_fs_exists_path_callback
-[`fs.lchmod(path, mode, callback)`]: fs.html#fs_fs_lchmod_path_mode_callback
-[`fs.lchmodSync(path, mode)`]: fs.html#fs_fs_lchmodsync_path_mode
-[`fs.lchown(path, uid, gid, callback)`]: fs.html#fs_fs_lchown_path_uid_gid_callback
-[`fs.lchownSync(path, uid, gid)`]: fs.html#fs_fs_lchownsync_path_uid_gid
-[`fs.read()`]: fs.html#fs_fs_read_fd_buffer_offset_length_position_callback
-[`fs.readSync()`]: fs.html#fs_fs_readsync_fd_buffer_offset_length_position
-[`fs.stat()`]: fs.html#fs_fs_stat_path_options_callback
-[`http.get()`]: http.html#http_http_get_options_callback
-[`http.request()`]: http.html#http_http_request_options_callback
-[`https.get()`]: https.html#https_https_get_options_callback
-[`https.request()`]: https.html#https_https_request_options_callback
-[`module.createRequire()`]: module.html#module_module_createrequire_filename
-[`os.networkInterfaces()`]: os.html#os_os_networkinterfaces
-[`os.tmpdir()`]: os.html#os_os_tmpdir
-[`process.env`]: process.html#process_process_env
-[`punycode`]: punycode.html
-[`require.extensions`]: modules.html#modules_require_extensions
-[`request.socket`]: http.html#http_request_socket
-[`request.connection`]: http.html#http_request_connection
-[`response.socket`]: http.html#http_response_socket
-[`response.connection`]: http.html#http_response_connection
-[`response.end()`]: http.html#http_response_end_data_encoding_callback
-[`response.finished`]: http.html#http_response_finished
-[`response.writableFinished`]: http.html#http_response_writablefinished
-[`response.writableEnded`]: http.html#http_response_writableended
-[`script.createCachedData()`]: vm.html#vm_script_createcacheddata
-[`setInterval()`]: timers.html#timers_setinterval_callback_delay_args
-[`setTimeout()`]: timers.html#timers_settimeout_callback_delay_args
-[`timeout.ref()`]: timers.html#timers_timeout_ref
-[`timeout.refresh()`]: timers.html#timers_timeout_refresh
-[`timeout.unref()`]: timers.html#timers_timeout_unref
-[`tls.CryptoStream`]: tls.html#tls_class_tls_cryptostream
-[`tls.SecureContext`]: tls.html#tls_tls_createsecurecontext_options
-[`tls.SecurePair`]: tls.html#tls_class_tls_securepair
-[`tls.TLSSocket`]: tls.html#tls_class_tls_tlssocket
-[`tls.checkServerIdentity()`]: tls.html#tls_tls_checkserveridentity_hostname_cert
-[`tls.createSecureContext()`]: tls.html#tls_tls_createsecurecontext_options
-[`url.format()`]: url.html#url_url_format_urlobject
-[`url.parse()`]: url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost
-[`url.resolve()`]: url.html#url_url_resolve_from_to
-[`util._extend()`]: util.html#util_util_extend_target_source
-[`util.getSystemErrorName()`]: util.html#util_util_getsystemerrorname_err
-[`util.inspect()`]: util.html#util_util_inspect_object_options
-[`util.inspect.custom`]: util.html#util_util_inspect_custom
-[`util.isArray()`]: util.html#util_util_isarray_object
-[`util.isBoolean()`]: util.html#util_util_isboolean_object
-[`util.isBuffer()`]: util.html#util_util_isbuffer_object
-[`util.isDate()`]: util.html#util_util_isdate_object
-[`util.isError()`]: util.html#util_util_iserror_object
-[`util.isFunction()`]: util.html#util_util_isfunction_object
-[`util.isNull()`]: util.html#util_util_isnull_object
-[`util.isNullOrUndefined()`]: util.html#util_util_isnullorundefined_object
-[`util.isNumber()`]: util.html#util_util_isnumber_object
-[`util.isObject()`]: util.html#util_util_isobject_object
-[`util.isPrimitive()`]: util.html#util_util_isprimitive_object
-[`util.isRegExp()`]: util.html#util_util_isregexp_object
-[`util.isString()`]: util.html#util_util_isstring_object
-[`util.isSymbol()`]: util.html#util_util_issymbol_object
-[`util.isUndefined()`]: util.html#util_util_isundefined_object
-[`util.log()`]: util.html#util_util_log_string
-[`util.types`]: util.html#util_util_types
-[`util`]: util.html
-[`worker.exitedAfterDisconnect`]: cluster.html#cluster_worker_exitedafterdisconnect
-[`worker.terminate()`]: worker_threads.html#worker_threads_worker_terminate
-[`zlib.bytesWritten`]: zlib.html#zlib_zlib_byteswritten
-[Legacy URL API]: url.html#url_legacy_url_api
+### DEP0145: `socket.bufferSize`
+<!-- YAML
+changes:
+  - version: v14.6.0
+    pr-url: https://github.com/nodejs/node/pull/34088
+    description: Documentation-only deprecation.
+-->
+
+Type: Documentation-only
+
+[`socket.bufferSize`][] is just an alias for [`writable.writableLength`][].
+
+### DEP0146: `new crypto.Certificate()`
+<!-- YAML
+changes:
+  - version: v14.9.0
+    pr-url: https://github.com/nodejs/node/pull/34697
+    description: Documentation-only deprecation.
+-->
+
+Type: Documentation-only
+
+The [`crypto.Certificate()` constructor][] is deprecated. Use
+[static methods of `crypto.Certificate()`][] instead.
+
+### DEP0147: `fs.rmdir(path, { recursive: true })`
+<!-- YAML
+changes:
+  - version: v14.14.0
+    pr-url: https://github.com/nodejs/node/pull/35579
+    description: Documentation-only deprecation.
+-->
+
+Type: Documentation-only
+
+In future versions of Node.js, `fs.rmdir(path, { recursive: true })` will throw
+on nonexistent paths, or when given a file as a target.
+Use `fs.rm(path, { recursive: true, force: true })` instead.
+
+### DEP0151: Main index lookup and extension searching
+<!-- YAML
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/36918
+    description: Documentation-only deprecation
+                 with `--pending-deprecation` support.
+-->
+
+Type: Documentation-only (supports [`--pending-deprecation`][])
+
+Previously, `index.js` and extension searching lookups would apply to
+`import 'pkg'` main entry point resolution, even when resolving ES modules.
+
+With this deprecation, all ES module main entry point resolutions require
+an explicit [`"exports"` or `"main"` entry][] with the exact file extension.
+
+[Legacy URL API]: url.md#url_legacy_url_api
 [NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
 [RFC 6066]: https://tools.ietf.org/html/rfc6066#section-3
-[WHATWG URL API]: url.html#url_the_whatwg_url_api
-[alloc]: buffer.html#buffer_static_method_buffer_alloc_size_fill_encoding
-[alloc_unsafe_size]: buffer.html#buffer_static_method_buffer_allocunsafe_size
-[from_arraybuffer]: buffer.html#buffer_static_method_buffer_from_arraybuffer_byteoffset_length
-[from_string_encoding]: buffer.html#buffer_static_method_buffer_from_string_encoding
-[legacy `urlObject`]: url.html#url_legacy_urlobject
+[WHATWG URL API]: url.md#url_the_whatwg_url_api
+[`"exports"` or `"main"` entry]: packages.md#packages_main_entry_point_export
+[`--pending-deprecation`]: cli.md#cli_pending_deprecation
+[`--throw-deprecation`]: cli.md#cli_throw_deprecation
+[`Buffer.allocUnsafeSlow(size)`]: buffer.md#buffer_static_method_buffer_allocunsafeslow_size
+[`Buffer.from(array)`]: buffer.md#buffer_static_method_buffer_from_array
+[`Buffer.from(buffer)`]: buffer.md#buffer_static_method_buffer_from_buffer
+[`Buffer.isBuffer()`]: buffer.md#buffer_static_method_buffer_isbuffer_obj
+[`Cipher`]: crypto.md#crypto_class_cipher
+[`Decipher`]: crypto.md#crypto_class_decipher
+[`REPLServer.clearBufferedCommand()`]: repl.md#repl_replserver_clearbufferedcommand
+[`ReadStream.open()`]: fs.md#fs_class_fs_readstream
+[`Server.connections`]: net.md#net_server_connections
+[`Server.getConnections()`]: net.md#net_server_getconnections_callback
+[`Server.listen({fd: <number>})`]: net.md#net_server_listen_handle_backlog_callback
+[`SlowBuffer`]: buffer.md#buffer_class_slowbuffer
+[`WriteStream.open()`]: fs.md#fs_class_fs_writestream
+[`assert`]: assert.md
+[`asyncResource.runInAsyncScope()`]: async_hooks.md#async_hooks_asyncresource_runinasyncscope_fn_thisarg_args
+[`child_process`]: child_process.md
+[`clearInterval()`]: timers.md#timers_clearinterval_timeout
+[`clearTimeout()`]: timers.md#timers_cleartimeout_timeout
+[`console.error()`]: console.md#console_console_error_data_args
+[`console.log()`]: console.md#console_console_log_data_args
+[`crypto.Certificate()` constructor]: crypto.md#crypto_legacy_api
+[`crypto.DEFAULT_ENCODING`]: crypto.md#crypto_crypto_default_encoding
+[`crypto.createCipher()`]: crypto.md#crypto_crypto_createcipher_algorithm_password_options
+[`crypto.createCipheriv()`]: crypto.md#crypto_crypto_createcipheriv_algorithm_key_iv_options
+[`crypto.createDecipher()`]: crypto.md#crypto_crypto_createdecipher_algorithm_password_options
+[`crypto.createDecipheriv()`]: crypto.md#crypto_crypto_createdecipheriv_algorithm_key_iv_options
+[`crypto.fips`]: crypto.md#crypto_crypto_fips
+[`crypto.pbkdf2()`]: crypto.md#crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback
+[`crypto.randomBytes()`]: crypto.md#crypto_crypto_randombytes_size_callback
+[`crypto.scrypt()`]: crypto.md#crypto_crypto_scrypt_password_salt_keylen_options_callback
+[`decipher.final()`]: crypto.md#crypto_decipher_final_outputencoding
+[`decipher.setAuthTag()`]: crypto.md#crypto_decipher_setauthtag_buffer
+[`domain`]: domain.md
+[`ecdh.setPublicKey()`]: crypto.md#crypto_ecdh_setpublickey_publickey_encoding
+[`emitter.listenerCount(eventName)`]: events.md#events_emitter_listenercount_eventname
+[`events.listenerCount(emitter, eventName)`]: events.md#events_events_listenercount_emitter_eventname
+[`fs.FileHandle`]: fs.md#fs_class_filehandle
+[`fs.access()`]: fs.md#fs_fs_access_path_mode_callback
+[`fs.createReadStream()`]: fs.md#fs_fs_createreadstream_path_options
+[`fs.createWriteStream()`]: fs.md#fs_fs_createwritestream_path_options
+[`fs.exists(path, callback)`]: fs.md#fs_fs_exists_path_callback
+[`fs.lchmod(path, mode, callback)`]: fs.md#fs_fs_lchmod_path_mode_callback
+[`fs.lchmodSync(path, mode)`]: fs.md#fs_fs_lchmodsync_path_mode
+[`fs.lchown(path, uid, gid, callback)`]: fs.md#fs_fs_lchown_path_uid_gid_callback
+[`fs.lchownSync(path, uid, gid)`]: fs.md#fs_fs_lchownsync_path_uid_gid
+[`fs.read()`]: fs.md#fs_fs_read_fd_buffer_offset_length_position_callback
+[`fs.readSync()`]: fs.md#fs_fs_readsync_fd_buffer_offset_length_position
+[`fs.stat()`]: fs.md#fs_fs_stat_path_options_callback
+[`http.get()`]: http.md#http_http_get_options_callback
+[`http.request()`]: http.md#http_http_request_options_callback
+[`https.get()`]: https.md#https_https_get_options_callback
+[`https.request()`]: https.md#https_https_request_options_callback
+[`module.createRequire()`]: module.md#module_module_createrequire_filename
+[`os.networkInterfaces()`]: os.md#os_os_networkinterfaces
+[`os.tmpdir()`]: os.md#os_os_tmpdir
+[`process.env`]: process.md#process_process_env
+[`process.mainModule`]: process.md#process_process_mainmodule
+[`punycode`]: punycode.md
+[`request.abort()`]: http.md#http_request_abort
+[`request.connection`]: http.md#http_request_connection
+[`request.destroy()`]: http.md#http_request_destroy_error
+[`request.socket`]: http.md#http_request_socket
+[`require.extensions`]: modules.md#modules_require_extensions
+[`require.main`]: modules.md#modules_accessing_the_main_module
+[`response.connection`]: http.md#http_response_connection
+[`response.end()`]: http.md#http_response_end_data_encoding_callback
+[`response.finished`]: http.md#http_response_finished
+[`response.socket`]: http.md#http_response_socket
+[`response.writableEnded`]: http.md#http_response_writableended
+[`response.writableFinished`]: http.md#http_response_writablefinished
+[`script.createCachedData()`]: vm.md#vm_script_createcacheddata
+[`setInterval()`]: timers.md#timers_setinterval_callback_delay_args
+[`setTimeout()`]: timers.md#timers_settimeout_callback_delay_args
+[`socket.bufferSize`]: net.md#net_socket_buffersize
+[`timeout.ref()`]: timers.md#timers_timeout_ref
+[`timeout.refresh()`]: timers.md#timers_timeout_refresh
+[`timeout.unref()`]: timers.md#timers_timeout_unref
+[`tls.CryptoStream`]: tls.md#tls_class_tls_cryptostream
+[`tls.SecureContext`]: tls.md#tls_tls_createsecurecontext_options
+[`tls.SecurePair`]: tls.md#tls_class_tls_securepair
+[`tls.TLSSocket`]: tls.md#tls_class_tls_tlssocket
+[`tls.checkServerIdentity()`]: tls.md#tls_tls_checkserveridentity_hostname_cert
+[`tls.createSecureContext()`]: tls.md#tls_tls_createsecurecontext_options
+[`url.format()`]: url.md#url_url_format_urlobject
+[`url.parse()`]: url.md#url_url_parse_urlstring_parsequerystring_slashesdenotehost
+[`url.resolve()`]: url.md#url_url_resolve_from_to
+[`util._extend()`]: util.md#util_util_extend_target_source
+[`util.getSystemErrorName()`]: util.md#util_util_getsystemerrorname_err
+[`util.inspect()`]: util.md#util_util_inspect_object_options
+[`util.inspect.custom`]: util.md#util_util_inspect_custom
+[`util.isArray()`]: util.md#util_util_isarray_object
+[`util.isBoolean()`]: util.md#util_util_isboolean_object
+[`util.isBuffer()`]: util.md#util_util_isbuffer_object
+[`util.isDate()`]: util.md#util_util_isdate_object
+[`util.isError()`]: util.md#util_util_iserror_object
+[`util.isFunction()`]: util.md#util_util_isfunction_object
+[`util.isNull()`]: util.md#util_util_isnull_object
+[`util.isNullOrUndefined()`]: util.md#util_util_isnullorundefined_object
+[`util.isNumber()`]: util.md#util_util_isnumber_object
+[`util.isObject()`]: util.md#util_util_isobject_object
+[`util.isPrimitive()`]: util.md#util_util_isprimitive_object
+[`util.isRegExp()`]: util.md#util_util_isregexp_object
+[`util.isString()`]: util.md#util_util_isstring_object
+[`util.isSymbol()`]: util.md#util_util_issymbol_object
+[`util.isUndefined()`]: util.md#util_util_isundefined_object
+[`util.log()`]: util.md#util_util_log_string
+[`util.types`]: util.md#util_util_types
+[`util`]: util.md
+[`worker.exitedAfterDisconnect`]: cluster.md#cluster_worker_exitedafterdisconnect
+[`worker.terminate()`]: worker_threads.md#worker_threads_worker_terminate
+[`writable.writableLength`]: stream.md#stream_writable_writablelength
+[`zlib.bytesWritten`]: zlib.md#zlib_zlib_byteswritten
+[alloc]: buffer.md#buffer_static_method_buffer_alloc_size_fill_encoding
+[alloc_unsafe_size]: buffer.md#buffer_static_method_buffer_allocunsafe_size
+[from_arraybuffer]: buffer.md#buffer_static_method_buffer_from_arraybuffer_byteoffset_length
+[from_string_encoding]: buffer.md#buffer_static_method_buffer_from_string_encoding
+[legacy `urlObject`]: url.md#url_legacy_urlobject
+[static methods of `crypto.Certificate()`]: crypto.md#crypto_class_certificate
diff --git a/doc/api/dgram.html b/doc/api/dgram.html
index fc4d9c904aba81f69bbc68a18d1d28f16c246dba..df37359a18fc0069c471bbbe4db9a51ca8d06242 100644
--- a/doc/api/dgram.html
+++ b/doc/api/dgram.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>UDP/datagram sockets | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>UDP/datagram sockets | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="dgram" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/dgram.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/dgram.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/dgram.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/dgram.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/dgram.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/dgram.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/dgram.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/dgram.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/dgram.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#dgram_udp_datagram_sockets">UDP/datagram sockets</a></span>
 <ul>
 <li><a href="#dgram_class_dgram_socket">Class: <code>dgram.Socket</code></a>
@@ -179,36 +192,35 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>UDP/datagram sockets<span><a class="mark" href="#dgram_udp_datagram_sockets" id="dgram_udp_datagram_sockets">#</a></span></h1>
+        <h2>UDP/datagram sockets<span><a class="mark" href="#dgram_udp_datagram_sockets" id="dgram_udp_datagram_sockets">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/dgram.js">lib/dgram.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/dgram.js">lib/dgram.js</a></p>
 <p>The <code>dgram</code> module provides an implementation of UDP datagram sockets.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> server = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
+<span class="hljs-keyword">const</span> server = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
 
-server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server error:\n<span class="hljs-subst">${err.stack}</span>`</span>);
-  server.close();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server error:\n<span class="hljs-subst">${err.stack}</span>`</span>);
+  server.<span class="hljs-title function_">close</span>();
 });
 
-server.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
 });
 
-server.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> address = server.address();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server listening <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">const</span> address = server.<span class="hljs-title function_">address</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server listening <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
 });
 
-server.bind(<span class="hljs-number">41234</span>);
+server.<span class="hljs-title function_">bind</span>(<span class="hljs-number">41234</span>);
 <span class="hljs-comment">// Prints: server listening 0.0.0.0:41234</span></code></pre>
-<h2>Class: <code>dgram.Socket</code><span><a class="mark" href="#dgram_class_dgram_socket" id="dgram_class_dgram_socket">#</a></span></h2>
+<section><h3>Class: <code>dgram.Socket</code><span><a class="mark" href="#dgram_class_dgram_socket" id="dgram_class_dgram_socket">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -218,19 +230,19 @@ server.bind(<span class="hljs-number">41234</span>);
 <p>Encapsulates the datagram functionality.</p>
 <p>New instances of <code>dgram.Socket</code> are created using <a href="#dgram_dgram_createsocket_options_callback"><code>dgram.createSocket()</code></a>.
 The <code>new</code> keyword is not to be used to create <code>dgram.Socket</code> instances.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#dgram_event_close" id="dgram_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#dgram_event_close" id="dgram_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
 <p>The <code>'close'</code> event is emitted after a socket is closed with <a href="#dgram_socket_close_callback"><code>close()</code></a>.
 Once triggered, no new <code>'message'</code> events will be emitted on this socket.</p>
-<h3>Event: <code>'connect'</code><span><a class="mark" href="#dgram_event_connect" id="dgram_event_connect">#</a></span></h3>
+<h4>Event: <code>'connect'</code><span><a class="mark" href="#dgram_event_connect" id="dgram_event_connect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
 <p>The <code>'connect'</code> event is emitted after a socket is associated to a remote
 address as a result of a successful <a href="#dgram_socket_connect_port_address_callback"><code>connect()</code></a> call.</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#dgram_event_error" id="dgram_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#dgram_event_error" id="dgram_event_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -239,7 +251,7 @@ address as a result of a successful <a href="#dgram_socket_connect_port_address_
 </ul>
 <p>The <code>'error'</code> event is emitted whenever any error occurs. The event handler
 function is passed a single <code>Error</code> object.</p>
-<h3>Event: <code>'listening'</code><span><a class="mark" href="#dgram_event_listening" id="dgram_event_listening">#</a></span></h3>
+<h4>Event: <code>'listening'</code><span><a class="mark" href="#dgram_event_listening" id="dgram_event_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -248,7 +260,7 @@ can receive data. This happens either explicitly with <code>socket.bind()</code>
 implicitly the first time data is sent using <code>socket.send()</code>.
 Until the <code>dgram.Socket</code> is listening, the underlying system resources do not
 exist and calls such as <code>socket.address()</code> and <code>socket.setTTL()</code> will fail.</p>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#dgram_event_message" id="dgram_event_message">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#dgram_event_message" id="dgram_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -270,7 +282,7 @@ address, the interface name is added to the <code>address</code>. For
 example, a packet received on the <code>en0</code> interface might have the
 address field set to <code>'fe80::2618:1234:ab11:3b9c%en0'</code>, where <code>'%en0'</code>
 is the interface name as a zone ID suffix.</p>
-<h3><code>socket.addMembership(multicastAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_addmembership_multicastaddress_multicastinterface" id="dgram_socket_addmembership_multicastaddress_multicastinterface">#</a></span></h3>
+<h4><code>socket.addMembership(multicastAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_addmembership_multicastaddress_multicastinterface" id="dgram_socket_addmembership_multicastaddress_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.9</span>
 </div>
@@ -290,18 +302,18 @@ port, listening on all interfaces.</p>
 <code>EADDRINUSE</code> error will occur:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
 <span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
-  cluster.fork(); <span class="hljs-comment">// Works ok.</span>
-  cluster.fork(); <span class="hljs-comment">// Fails with EADDRINUSE.</span>
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
+  cluster.<span class="hljs-title function_">fork</span>(); <span class="hljs-comment">// Works ok.</span>
+  cluster.<span class="hljs-title function_">fork</span>(); <span class="hljs-comment">// Fails with EADDRINUSE.</span>
 } <span class="hljs-keyword">else</span> {
-  <span class="hljs-keyword">const</span> s = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
-  s.bind(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
-    s.addMembership(<span class="hljs-string">'224.0.0.114'</span>);
+  <span class="hljs-keyword">const</span> s = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
+  s.<span class="hljs-title function_">bind</span>(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
+    s.<span class="hljs-title function_">addMembership</span>(<span class="hljs-string">'224.0.0.114'</span>);
   });
 }</code></pre>
-<h3><code>socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_addsourcespecificmembership_sourceaddress_groupaddress_multicastinterface" id="dgram_socket_addsourcespecificmembership_sourceaddress_groupaddress_multicastinterface">#</a></span></h3>
+<h4><code>socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_addsourcespecificmembership_sourceaddress_groupaddress_multicastinterface" id="dgram_socket_addsourcespecificmembership_sourceaddress_groupaddress_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.1.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>sourceAddress</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -316,7 +328,7 @@ membership to it. To add membership to every available interface, call
 <code>socket.addSourceSpecificMembership()</code> multiple times, once per interface.</p>
 <p>When called on an unbound socket, this method will implicitly bind to a random
 port, listening on all interfaces.</p>
-<h3><code>socket.address()</code><span><a class="mark" href="#dgram_socket_address" id="dgram_socket_address">#</a></span></h3>
+<h4><code>socket.address()</code><span><a class="mark" href="#dgram_socket_address" id="dgram_socket_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -327,12 +339,12 @@ port, listening on all interfaces.</p>
 For UDP sockets, this object will contain <code>address</code>, <code>family</code> and <code>port</code>
 properties.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.bind([port][, address][, callback])</code><span><a class="mark" href="#dgram_socket_bind_port_address_callback" id="dgram_socket_bind_port_address_callback">#</a></span></h3>
+<h4><code>socket.bind([port][, address][, callback])</code><span><a class="mark" href="#dgram_socket_bind_port_address_callback" id="dgram_socket_bind_port_address_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v0.10</td>
+<tr><td>v0.9.1</td>
 <td><p>The method was changed to an asynchronous execution model. Legacy code would need to be changed to pass a callback function to the method call.</p></td></tr>
 <tr><td>v0.1.99</td>
 <td><p><span>Added in: v0.1.99</span></p></td></tr>
@@ -360,25 +372,25 @@ datagram messages.</p>
 attempting to bind with a closed socket), an <a href="errors.html#errors_class_error"><code>Error</code></a> may be thrown.</p>
 <p>Example of a UDP server listening on port 41234:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> server = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
+<span class="hljs-keyword">const</span> server = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
 
-server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server error:\n<span class="hljs-subst">${err.stack}</span>`</span>);
-  server.close();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server error:\n<span class="hljs-subst">${err.stack}</span>`</span>);
+  server.<span class="hljs-title function_">close</span>();
 });
 
-server.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
 });
 
-server.on(<span class="hljs-string">'listening'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> address = server.address();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`server listening <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'listening'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">const</span> address = server.<span class="hljs-title function_">address</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server listening <span class="hljs-subst">${address.address}</span>:<span class="hljs-subst">${address.port}</span>`</span>);
 });
 
-server.bind(<span class="hljs-number">41234</span>);
+server.<span class="hljs-title function_">bind</span>(<span class="hljs-number">41234</span>);
 <span class="hljs-comment">// Prints: server listening 0.0.0.0:41234</span></code></pre>
-<h3><code>socket.bind(options[, callback])</code><span><a class="mark" href="#dgram_socket_bind_options_callback" id="dgram_socket_bind_options_callback">#</a></span></h3>
+<h4><code>socket.bind(options[, callback])</code><span><a class="mark" href="#dgram_socket_bind_options_callback" id="dgram_socket_bind_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -419,12 +431,12 @@ datagram messages.</p>
 <p>If binding fails, an <code>'error'</code> event is generated. In rare case (e.g.
 attempting to bind with a closed socket), an <a href="errors.html#errors_class_error"><code>Error</code></a> may be thrown.</p>
 <p>An example socket listening on an exclusive port is shown below.</p>
-<pre><code class="language-js">socket.bind({
+<pre><code class="language-js">socket.<span class="hljs-title function_">bind</span>({
   <span class="hljs-attr">address</span>: <span class="hljs-string">'localhost'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">8000</span>,
   <span class="hljs-attr">exclusive</span>: <span class="hljs-literal">true</span>
 });</code></pre>
-<h3><code>socket.close([callback])</code><span><a class="mark" href="#dgram_socket_close_callback" id="dgram_socket_close_callback">#</a></span></h3>
+<h4><code>socket.close([callback])</code><span><a class="mark" href="#dgram_socket_close_callback" id="dgram_socket_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -433,7 +445,7 @@ attempting to bind with a closed socket), an <a href="errors.html#errors_class_e
 </ul>
 <p>Close the underlying socket and stop listening for data on it. If a callback is
 provided, it is added as a listener for the <a href="#dgram_event_close"><code>'close'</code></a> event.</p>
-<h3><code>socket.connect(port[, address][, callback])</code><span><a class="mark" href="#dgram_socket_connect_port_address_callback" id="dgram_socket_connect_port_address_callback">#</a></span></h3>
+<h4><code>socket.connect(port[, address][, callback])</code><span><a class="mark" href="#dgram_socket_connect_port_address_callback" id="dgram_socket_connect_port_address_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -451,7 +463,7 @@ provided, <code>'127.0.0.1'</code> (for <code>udp4</code> sockets) or <code>'::1
 will be used by default. Once the connection is complete, a <code>'connect'</code> event
 is emitted and the optional <code>callback</code> function is called. In case of failure,
 the <code>callback</code> is called or, failing this, an <code>'error'</code> event is emitted.</p>
-<h3><code>socket.disconnect()</code><span><a class="mark" href="#dgram_socket_disconnect" id="dgram_socket_disconnect">#</a></span></h3>
+<h4><code>socket.disconnect()</code><span><a class="mark" href="#dgram_socket_disconnect" id="dgram_socket_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -459,7 +471,7 @@ the <code>callback</code> is called or, failing this, an <code>'error'</code> ev
 its remote address. Trying to call <code>disconnect()</code> on an unbound or already
 disconnected socket will result in an <a href="errors.html#errors_err_socket_dgram_not_connected"><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code></a>
 exception.</p>
-<h3><code>socket.dropMembership(multicastAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_dropmembership_multicastaddress_multicastinterface" id="dgram_socket_dropmembership_multicastaddress_multicastinterface">#</a></span></h3>
+<h4><code>socket.dropMembership(multicastAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_dropmembership_multicastaddress_multicastinterface" id="dgram_socket_dropmembership_multicastaddress_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.9</span>
 </div>
@@ -473,9 +485,9 @@ kernel when the socket is closed or the process terminates, so most apps will
 never have reason to call this.</p>
 <p>If <code>multicastInterface</code> is not specified, the operating system will attempt to
 drop membership on all valid interfaces.</p>
-<h3><code>socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_dropsourcespecificmembership_sourceaddress_groupaddress_multicastinterface" id="dgram_socket_dropsourcespecificmembership_sourceaddress_groupaddress_multicastinterface">#</a></span></h3>
+<h4><code>socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])</code><span><a class="mark" href="#dgram_socket_dropsourcespecificmembership_sourceaddress_groupaddress_multicastinterface" id="dgram_socket_dropsourcespecificmembership_sourceaddress_groupaddress_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.1.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>sourceAddress</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -489,7 +501,7 @@ socket is closed or the process terminates, so most apps will never have
 reason to call this.</p>
 <p>If <code>multicastInterface</code> is not specified, the operating system will attempt to
 drop membership on all valid interfaces.</p>
-<h3><code>socket.getRecvBufferSize()</code><span><a class="mark" href="#dgram_socket_getrecvbuffersize" id="dgram_socket_getrecvbuffersize">#</a></span></h3>
+<h4><code>socket.getRecvBufferSize()</code><span><a class="mark" href="#dgram_socket_getrecvbuffersize" id="dgram_socket_getrecvbuffersize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.7.0</span>
 </div>
@@ -497,7 +509,7 @@ drop membership on all valid interfaces.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> the <code>SO_RCVBUF</code> socket receive buffer size in bytes.</li>
 </ul>
 <p>This method throws <a href="errors.html#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a> if called on an unbound socket.</p>
-<h3><code>socket.getSendBufferSize()</code><span><a class="mark" href="#dgram_socket_getsendbuffersize" id="dgram_socket_getsendbuffersize">#</a></span></h3>
+<h4><code>socket.getSendBufferSize()</code><span><a class="mark" href="#dgram_socket_getsendbuffersize" id="dgram_socket_getsendbuffersize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.7.0</span>
 </div>
@@ -505,7 +517,7 @@ drop membership on all valid interfaces.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> the <code>SO_SNDBUF</code> socket send buffer size in bytes.</li>
 </ul>
 <p>This method throws <a href="errors.html#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a> if called on an unbound socket.</p>
-<h3><code>socket.ref()</code><span><a class="mark" href="#dgram_socket_ref" id="dgram_socket_ref">#</a></span></h3>
+<h4><code>socket.ref()</code><span><a class="mark" href="#dgram_socket_ref" id="dgram_socket_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -520,7 +532,7 @@ counting and restores the default behavior.</p>
 <p>Calling <code>socket.ref()</code> multiples times will have no additional effect.</p>
 <p>The <code>socket.ref()</code> method returns a reference to the socket so calls can be
 chained.</p>
-<h3><code>socket.remoteAddress()</code><span><a class="mark" href="#dgram_socket_remoteaddress" id="dgram_socket_remoteaddress">#</a></span></h3>
+<h4><code>socket.remoteAddress()</code><span><a class="mark" href="#dgram_socket_remoteaddress" id="dgram_socket_remoteaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.0.0</span>
 </div>
@@ -530,12 +542,12 @@ chained.</p>
 <p>Returns an object containing the <code>address</code>, <code>family</code>, and <code>port</code> of the remote
 endpoint. This method throws an <a href="errors.html#errors_err_socket_dgram_not_connected"><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code></a> exception
 if the socket is not connected.</p>
-<h3><code>socket.send(msg[, offset, length][, port][, address][, callback])</code><span><a class="mark" href="#dgram_socket_send_msg_offset_length_port_address_callback" id="dgram_socket_send_msg_offset_length_port_address_callback">#</a></span></h3>
+<h4><code>socket.send(msg[, offset, length][, port][, address][, callback])</code><span><a class="mark" href="#dgram_socket_send_msg_offset_length_port_address_callback" id="dgram_socket_send_msg_offset_length_port_address_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>The <code>msg</code> parameter can now be any <code>TypedArray</code> or <code>DataView</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Added support for sending data on connected sockets.</p></td></tr>
@@ -595,19 +607,19 @@ or a <code>DataView</code>.</p>
 <p>This method throws <a href="errors.html#errors_err_socket_bad_port"><code>ERR_SOCKET_BAD_PORT</code></a> if called on an unbound socket.</p>
 <p>Example of sending a UDP packet to a port on <code>localhost</code>;</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> message = Buffer.from(<span class="hljs-string">'Some bytes'</span>);
-<span class="hljs-keyword">const</span> client = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
-client.send(message, <span class="hljs-number">41234</span>, <span class="hljs-string">'localhost'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  client.close();
+<span class="hljs-keyword">const</span> message = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Some bytes'</span>);
+<span class="hljs-keyword">const</span> client = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
+client.<span class="hljs-title function_">send</span>(message, <span class="hljs-number">41234</span>, <span class="hljs-string">'localhost'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  client.<span class="hljs-title function_">close</span>();
 });</code></pre>
 <p>Example of sending a UDP packet composed of multiple buffers to a port on
 <code>127.0.0.1</code>;</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> buf1 = Buffer.from(<span class="hljs-string">'Some '</span>);
-<span class="hljs-keyword">const</span> buf2 = Buffer.from(<span class="hljs-string">'bytes'</span>);
-<span class="hljs-keyword">const</span> client = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
-client.send([buf1, buf2], <span class="hljs-number">41234</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  client.close();
+<span class="hljs-keyword">const</span> buf1 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Some '</span>);
+<span class="hljs-keyword">const</span> buf2 = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'bytes'</span>);
+<span class="hljs-keyword">const</span> client = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
+client.<span class="hljs-title function_">send</span>([buf1, buf2], <span class="hljs-number">41234</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  client.<span class="hljs-title function_">close</span>();
 });</code></pre>
 <p>Sending multiple buffers might be faster or slower depending on the
 application and operating system. Run benchmarks to
@@ -616,14 +628,14 @@ however, sending multiple buffers is faster.</p>
 <p>Example of sending a UDP packet using a socket connected to a port on
 <code>localhost</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dgram = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dgram'</span>);
-<span class="hljs-keyword">const</span> message = Buffer.from(<span class="hljs-string">'Some bytes'</span>);
-<span class="hljs-keyword">const</span> client = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
-client.connect(<span class="hljs-number">41234</span>, <span class="hljs-string">'localhost'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  client.send(message, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    client.close();
+<span class="hljs-keyword">const</span> message = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Some bytes'</span>);
+<span class="hljs-keyword">const</span> client = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
+client.<span class="hljs-title function_">connect</span>(<span class="hljs-number">41234</span>, <span class="hljs-string">'localhost'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  client.<span class="hljs-title function_">send</span>(message, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    client.<span class="hljs-title function_">close</span>();
   });
 });</code></pre>
-<h4>Note about UDP datagram size<span><a class="mark" href="#dgram_note_about_udp_datagram_size" id="dgram_note_about_udp_datagram_size">#</a></span></h4>
+<h5>Note about UDP datagram size<span><a class="mark" href="#dgram_note_about_udp_datagram_size" id="dgram_note_about_udp_datagram_size">#</a></span></h5>
 <p>The maximum size of an IPv4/v6 datagram depends on the <code>MTU</code>
 (Maximum Transmission Unit) and on the <code>Payload Length</code> field size.</p>
 <ul>
@@ -650,7 +662,7 @@ minimum <code>MTU</code> of 1500.</p>
 a packet might travel. Sending a datagram greater than the receiver <code>MTU</code> will
 not work because the packet will get silently dropped without informing the
 source that the data did not reach its intended recipient.</p>
-<h3><code>socket.setBroadcast(flag)</code><span><a class="mark" href="#dgram_socket_setbroadcast_flag" id="dgram_socket_setbroadcast_flag">#</a></span></h3>
+<h4><code>socket.setBroadcast(flag)</code><span><a class="mark" href="#dgram_socket_setbroadcast_flag" id="dgram_socket_setbroadcast_flag">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.9</span>
 </div>
@@ -660,7 +672,7 @@ source that the data did not reach its intended recipient.</p>
 <p>Sets or clears the <code>SO_BROADCAST</code> socket option. When set to <code>true</code>, UDP
 packets may be sent to a local interface's broadcast address.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.setMulticastInterface(multicastInterface)</code><span><a class="mark" href="#dgram_socket_setmulticastinterface_multicastinterface" id="dgram_socket_setmulticastinterface_multicastinterface">#</a></span></h3>
+<h4><code>socket.setMulticastInterface(multicastInterface)</code><span><a class="mark" href="#dgram_socket_setmulticastinterface_multicastinterface" id="dgram_socket_setmulticastinterface_multicastinterface">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.6.0</span>
 </div>
@@ -683,27 +695,27 @@ also use explicit scope in addresses, so only packets sent to a multicast
 address without specifying an explicit scope are affected by the most recent
 successful use of this call.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h4>Example: IPv6 outgoing multicast interface<span><a class="mark" href="#dgram_example_ipv6_outgoing_multicast_interface" id="dgram_example_ipv6_outgoing_multicast_interface">#</a></span></h4>
+<h5>Example: IPv6 outgoing multicast interface<span><a class="mark" href="#dgram_example_ipv6_outgoing_multicast_interface" id="dgram_example_ipv6_outgoing_multicast_interface">#</a></span></h5>
 <p>On most systems, where scope format uses the interface name:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.createSocket(<span class="hljs-string">'udp6'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp6'</span>);
 
-socket.bind(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
-  socket.setMulticastInterface(<span class="hljs-string">'::%eth1'</span>);
+socket.<span class="hljs-title function_">bind</span>(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
+  socket.<span class="hljs-title function_">setMulticastInterface</span>(<span class="hljs-string">'::%eth1'</span>);
 });</code></pre>
 <p>On Windows, where scope format uses an interface number:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.createSocket(<span class="hljs-string">'udp6'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp6'</span>);
 
-socket.bind(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
-  socket.setMulticastInterface(<span class="hljs-string">'::%2'</span>);
+socket.<span class="hljs-title function_">bind</span>(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
+  socket.<span class="hljs-title function_">setMulticastInterface</span>(<span class="hljs-string">'::%2'</span>);
 });</code></pre>
-<h4>Example: IPv4 outgoing multicast interface<span><a class="mark" href="#dgram_example_ipv4_outgoing_multicast_interface" id="dgram_example_ipv4_outgoing_multicast_interface">#</a></span></h4>
+<h5>Example: IPv4 outgoing multicast interface<span><a class="mark" href="#dgram_example_ipv4_outgoing_multicast_interface" id="dgram_example_ipv4_outgoing_multicast_interface">#</a></span></h5>
 <p>All systems use an IP of the host on the desired physical interface:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.createSocket(<span class="hljs-string">'udp4'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> socket = dgram.<span class="hljs-title function_">createSocket</span>(<span class="hljs-string">'udp4'</span>);
 
-socket.bind(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
-  socket.setMulticastInterface(<span class="hljs-string">'10.0.0.2'</span>);
+socket.<span class="hljs-title function_">bind</span>(<span class="hljs-number">1234</span>, <span class="hljs-function">() =></span> {
+  socket.<span class="hljs-title function_">setMulticastInterface</span>(<span class="hljs-string">'10.0.0.2'</span>);
 });</code></pre>
-<h4>Call results<span><a class="mark" href="#dgram_call_results" id="dgram_call_results">#</a></span></h4>
+<h5>Call results<span><a class="mark" href="#dgram_call_results" id="dgram_call_results">#</a></span></h5>
 <p>A call on a socket that is not ready to send or no longer open may throw a <em>Not
 running</em> <a href="errors.html#errors_class_error"><code>Error</code></a>.</p>
 <p>If <code>multicastInterface</code> can not be parsed into an IP then an <em>EINVAL</em>
@@ -716,7 +728,7 @@ continuing to use (or returning to) the system's default interface selection.</p
 <p>A socket's address family's ANY address (IPv4 <code>'0.0.0.0'</code> or IPv6 <code>'::'</code>) can be
 used to return control of the sockets default outgoing interface to the system
 for future multicast packets.</p>
-<h3><code>socket.setMulticastLoopback(flag)</code><span><a class="mark" href="#dgram_socket_setmulticastloopback_flag" id="dgram_socket_setmulticastloopback_flag">#</a></span></h3>
+<h4><code>socket.setMulticastLoopback(flag)</code><span><a class="mark" href="#dgram_socket_setmulticastloopback_flag" id="dgram_socket_setmulticastloopback_flag">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.8</span>
 </div>
@@ -726,7 +738,7 @@ for future multicast packets.</p>
 <p>Sets or clears the <code>IP_MULTICAST_LOOP</code> socket option. When set to <code>true</code>,
 multicast packets will also be received on the local interface.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.setMulticastTTL(ttl)</code><span><a class="mark" href="#dgram_socket_setmulticastttl_ttl" id="dgram_socket_setmulticastttl_ttl">#</a></span></h3>
+<h4><code>socket.setMulticastTTL(ttl)</code><span><a class="mark" href="#dgram_socket_setmulticastttl_ttl" id="dgram_socket_setmulticastttl_ttl">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.8</span>
 </div>
@@ -740,7 +752,7 @@ router or gateway that forwards a packet decrements the TTL. If the TTL is
 decremented to 0 by a router, it will not be forwarded.</p>
 <p>The <code>ttl</code> argument may be between 0 and 255. The default on most systems is <code>1</code>.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.setRecvBufferSize(size)</code><span><a class="mark" href="#dgram_socket_setrecvbuffersize_size" id="dgram_socket_setrecvbuffersize_size">#</a></span></h3>
+<h4><code>socket.setRecvBufferSize(size)</code><span><a class="mark" href="#dgram_socket_setrecvbuffersize_size" id="dgram_socket_setrecvbuffersize_size">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.7.0</span>
 </div>
@@ -750,7 +762,7 @@ decremented to 0 by a router, it will not be forwarded.</p>
 <p>Sets the <code>SO_RCVBUF</code> socket option. Sets the maximum socket receive buffer
 in bytes.</p>
 <p>This method throws <a href="errors.html#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a> if called on an unbound socket.</p>
-<h3><code>socket.setSendBufferSize(size)</code><span><a class="mark" href="#dgram_socket_setsendbuffersize_size" id="dgram_socket_setsendbuffersize_size">#</a></span></h3>
+<h4><code>socket.setSendBufferSize(size)</code><span><a class="mark" href="#dgram_socket_setsendbuffersize_size" id="dgram_socket_setsendbuffersize_size">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.7.0</span>
 </div>
@@ -760,7 +772,7 @@ in bytes.</p>
 <p>Sets the <code>SO_SNDBUF</code> socket option. Sets the maximum socket send buffer
 in bytes.</p>
 <p>This method throws <a href="errors.html#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a> if called on an unbound socket.</p>
-<h3><code>socket.setTTL(ttl)</code><span><a class="mark" href="#dgram_socket_setttl_ttl" id="dgram_socket_setttl_ttl">#</a></span></h3>
+<h4><code>socket.setTTL(ttl)</code><span><a class="mark" href="#dgram_socket_setttl_ttl" id="dgram_socket_setttl_ttl">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.101</span>
 </div>
@@ -775,7 +787,7 @@ Changing TTL values is typically done for network probes or when multicasting.</
 <p>The <code>ttl</code> argument may be between between 1 and 255. The default on most systems
 is 64.</p>
 <p>This method throws <code>EBADF</code> if called on an unbound socket.</p>
-<h3><code>socket.unref()</code><span><a class="mark" href="#dgram_socket_unref" id="dgram_socket_unref">#</a></span></h3>
+<h4><code>socket.unref()</code><span><a class="mark" href="#dgram_socket_unref" id="dgram_socket_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -790,12 +802,14 @@ listening.</p>
 <p>Calling <code>socket.unref()</code> multiple times will have no addition effect.</p>
 <p>The <code>socket.unref()</code> method returns a reference to the socket so calls can be
 chained.</p>
-<h2><code>dgram</code> module functions<span><a class="mark" href="#dgram_dgram_module_functions" id="dgram_dgram_module_functions">#</a></span></h2>
-<h3><code>dgram.createSocket(options[, callback])</code><span><a class="mark" href="#dgram_dgram_createsocket_options_callback" id="dgram_dgram_createsocket_options_callback">#</a></span></h3>
+</section><section><h3><code>dgram</code> module functions<span><a class="mark" href="#dgram_dgram_module_functions" id="dgram_dgram_module_functions">#</a></span></h3>
+<h4><code>dgram.createSocket(options[, callback])</code><span><a class="mark" href="#dgram_dgram_createsocket_options_callback" id="dgram_dgram_createsocket_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>AbortSignal support was added.</p></td></tr>
 <tr><td>v11.4.0</td>
 <td><p>The <code>ipv6Only</code> option is supported.</p></td></tr>
 <tr><td>v8.7.0</td>
@@ -821,6 +835,7 @@ disable dual-stack support, i.e., binding to address <code>::</code> won't make
 <li><code>recvBufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the <code>SO_RCVBUF</code> socket value.</li>
 <li><code>sendBufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the <code>SO_SNDBUF</code> socket value.</li>
 <li><code>lookup</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Custom lookup function. <strong>Default:</strong> <a href="dns.html#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> An AbortSignal that may be used to close a socket.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Attached as a listener for <code>'message'</code> events. Optional.</li>
@@ -833,7 +848,17 @@ method will bind the socket to the "all interfaces" address on a random port
 (it does the right thing for both <code>udp4</code> and <code>udp6</code> sockets). The bound address
 and port can be retrieved using <a href="#dgram_socket_address"><code>socket.address().address</code></a> and
 <a href="#dgram_socket_address"><code>socket.address().port</code></a>.</p>
-<h3><code>dgram.createSocket(type[, callback])</code><span><a class="mark" href="#dgram_dgram_createsocket_type_callback" id="dgram_dgram_createsocket_type_callback">#</a></span></h3>
+<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding
+<code>AbortController</code> is similar to calling <code>.close()</code> on the socket:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> server = dgram.<span class="hljs-title function_">createSocket</span>({ <span class="hljs-attr">type</span>: <span class="hljs-string">'udp4'</span>, signal });
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">msg, rinfo</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`server got: <span class="hljs-subst">${msg}</span> from <span class="hljs-subst">${rinfo.address}</span>:<span class="hljs-subst">${rinfo.port}</span>`</span>);
+});
+<span class="hljs-comment">// Later, when you want to close the server.</span>
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<h4><code>dgram.createSocket(type[, callback])</code><span><a class="mark" href="#dgram_dgram_createsocket_type_callback" id="dgram_dgram_createsocket_type_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -848,10 +873,46 @@ socket to begin listening for datagram messages. When <code>address</code> and <
 not passed to <a href="#dgram_socket_bind_port_address_callback"><code>socket.bind()</code></a> the method will bind the socket to the "all
 interfaces" address on a random port (it does the right thing for both <code>udp4</code>
 and <code>udp6</code> sockets). The bound address and port can be retrieved using
-<a href="#dgram_socket_address"><code>socket.address().address</code></a> and <a href="#dgram_socket_address"><code>socket.address().port</code></a>.</p>
+<a href="#dgram_socket_address"><code>socket.address().address</code></a> and <a href="#dgram_socket_address"><code>socket.address().port</code></a>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/dgram.json b/doc/api/dgram.json
index 906d0d65f989fa06ecb108768801626538e222bf..c8209899616359b585f740cf1fba95ebb826c98d 100644
--- a/doc/api/dgram.json
+++ b/doc/api/dgram.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/dgram.js\">lib/dgram.js</a></p>\n<p>The <code>dgram</code> module provides an implementation of UDP datagram sockets.</p>\n<pre><code class=\"language-js\">const dgram = require('dgram');\nconst server = dgram.createSocket('udp4');\n\nserver.on('error', (err) => {\n  console.log(`server error:\\n${err.stack}`);\n  server.close();\n});\n\nserver.on('message', (msg, rinfo) => {\n  console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);\n});\n\nserver.on('listening', () => {\n  const address = server.address();\n  console.log(`server listening ${address.address}:${address.port}`);\n});\n\nserver.bind(41234);\n// Prints: server listening 0.0.0.0:41234\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/dgram.js\">lib/dgram.js</a></p>\n<p>The <code>dgram</code> module provides an implementation of UDP datagram sockets.</p>\n<pre><code class=\"language-js\">const dgram = require('dgram');\nconst server = dgram.createSocket('udp4');\n\nserver.on('error', (err) => {\n  console.log(`server error:\\n${err.stack}`);\n  server.close();\n});\n\nserver.on('message', (msg, rinfo) => {\n  console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);\n});\n\nserver.on('listening', () => {\n  const address = server.address();\n  console.log(`server listening ${address.address}:${address.port}`);\n});\n\nserver.bind(41234);\n// Prints: server listening 0.0.0.0:41234\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `dgram.Socket`",
@@ -129,6 +129,7 @@
               "name": "addSourceSpecificMembership",
               "meta": {
                 "added": [
+                  "v13.1.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -188,7 +189,8 @@
                 ],
                 "changes": [
                   {
-                    "version": "v0.10",
+                    "version": "v0.9.1",
+                    "commit": "332fea5ac1816e498030109c4211bca24a7fa667",
                     "description": "The method was changed to an asynchronous execution model. Legacy code would need to be changed to pass a callback function to the method call."
                   }
                 ]
@@ -377,6 +379,7 @@
               "name": "dropSourceSpecificMembership",
               "meta": {
                 "added": [
+                  "v13.1.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -504,10 +507,15 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22413",
                     "description": "The `msg` parameter can now be any `TypedArray` or `DataView`."
                   },
+                  {
+                    "version": "v12.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/26871",
+                    "description": "Added support for sending data on connected sockets."
+                  },
                   {
                     "version": "v8.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/11985",
@@ -527,11 +535,6 @@
                     "version": "v5.7.0",
                     "pr-url": "https://github.com/nodejs/node/pull/4374",
                     "description": "The `msg` parameter can be an array now. Also, the `offset` and `length` parameters are optional now."
-                  },
-                  {
-                    "version": "v12.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/26871",
-                    "description": "Added support for sending data on connected sockets."
                   }
                 ]
               },
@@ -798,9 +801,14 @@
                 ],
                 "changes": [
                   {
-                    "version": "v8.6.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/14560",
-                    "description": "The `lookup` option is supported."
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37026",
+                    "description": "AbortSignal support was added."
+                  },
+                  {
+                    "version": "v11.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23798",
+                    "description": "The `ipv6Only` option is supported."
                   },
                   {
                     "version": "v8.7.0",
@@ -808,9 +816,9 @@
                     "description": "The `recvBufferSize` and `sendBufferSize` options are supported now."
                   },
                   {
-                    "version": "v11.4.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/23798",
-                    "description": "The `ipv6Only` option is supported."
+                    "version": "v8.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/14560",
+                    "description": "The `lookup` option is supported."
                   }
                 ]
               },
@@ -866,6 +874,12 @@
                           "type": "Function",
                           "default": "[`dns.lookup()`][]",
                           "desc": "Custom lookup function."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} An AbortSignal that may be used to close a socket.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "An AbortSignal that may be used to close a socket."
                         }
                       ]
                     },
@@ -878,7 +892,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Creates a <code>dgram.Socket</code> object. Once the socket is created, calling\n<a href=\"#dgram_socket_bind_port_address_callback\"><code>socket.bind()</code></a> will instruct the socket to begin listening for datagram\nmessages. When <code>address</code> and <code>port</code> are not passed to <a href=\"#dgram_socket_bind_port_address_callback\"><code>socket.bind()</code></a> the\nmethod will bind the socket to the \"all interfaces\" address on a random port\n(it does the right thing for both <code>udp4</code> and <code>udp6</code> sockets). The bound address\nand port can be retrieved using <a href=\"#dgram_socket_address\"><code>socket.address().address</code></a> and\n<a href=\"#dgram_socket_address\"><code>socket.address().port</code></a>.</p>"
+              "desc": "<p>Creates a <code>dgram.Socket</code> object. Once the socket is created, calling\n<a href=\"#dgram_socket_bind_port_address_callback\"><code>socket.bind()</code></a> will instruct the socket to begin listening for datagram\nmessages. When <code>address</code> and <code>port</code> are not passed to <a href=\"#dgram_socket_bind_port_address_callback\"><code>socket.bind()</code></a> the\nmethod will bind the socket to the \"all interfaces\" address on a random port\n(it does the right thing for both <code>udp4</code> and <code>udp6</code> sockets). The bound address\nand port can be retrieved using <a href=\"#dgram_socket_address\"><code>socket.address().address</code></a> and\n<a href=\"#dgram_socket_address\"><code>socket.address().port</code></a>.</p>\n<p>If the <code>signal</code> option is enabled, calling <code>.abort()</code> on the corresponding\n<code>AbortController</code> is similar to calling <code>.close()</code> on the socket:</p>\n<pre><code class=\"language-js\">const controller = new AbortController();\nconst { signal } = controller;\nconst server = dgram.createSocket({ type: 'udp4', signal });\nserver.on('message', (msg, rinfo) => {\n  console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);\n});\n// Later, when you want to close the server.\ncontroller.abort();\n</code></pre>"
             },
             {
               "textRaw": "`dgram.createSocket(type[, callback])`",
diff --git a/doc/api/dgram.md b/doc/api/dgram.md
index 42b47fc98232db6c78dc8ad2b62da1491943b14c..1e2d46f6159ceb12661ea5e01a57841f21ce1990 100644
--- a/doc/api/dgram.md
+++ b/doc/api/dgram.md
@@ -139,7 +139,9 @@ if (cluster.isMaster) {
 
 ### `socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.1.0
+ - v12.16.0
 -->
 * `sourceAddress` {string}
 * `groupAddress` {string}
@@ -172,7 +174,8 @@ This method throws `EBADF` if called on an unbound socket.
 <!-- YAML
 added: v0.1.99
 changes:
-  - version: v0.10
+  - version: v0.9.1
+    commit: 332fea5ac1816e498030109c4211bca24a7fa667
     description: The method was changed to an asynchronous execution model.
                  Legacy code would need to be changed to pass a callback
                  function to the method call.
@@ -334,7 +337,9 @@ drop membership on all valid interfaces.
 
 ### `socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.1.0
+ - v12.16.0
 -->
 
 * `sourceAddress` {string}
@@ -401,9 +406,12 @@ if the socket is not connected.
 <!-- YAML
 added: v0.1.99
 changes:
-  - version: v12.19.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/22413
     description: The `msg` parameter can now be any `TypedArray` or `DataView`.
+  - version: v12.0.0
+    pr-url: https://github.com/nodejs/node/pull/26871
+    description: Added support for sending data on connected sockets.
   - version: v8.0.0
     pr-url: https://github.com/nodejs/node/pull/11985
     description: The `msg` parameter can be an `Uint8Array` now.
@@ -418,9 +426,6 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/4374
     description: The `msg` parameter can be an array now. Also, the `offset`
                  and `length` parameters are optional now.
-  - version: v12.0.0
-    pr-url: https://github.com/nodejs/node/pull/26871
-    description: Added support for sending data on connected sockets.
 -->
 
 * `msg` {Buffer|TypedArray|DataView|string|Array} Message to be sent.
@@ -728,16 +733,19 @@ chained.
 <!-- YAML
 added: v0.11.13
 changes:
-  - version: v8.6.0
-    pr-url: https://github.com/nodejs/node/pull/14560
-    description: The `lookup` option is supported.
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37026
+    description: AbortSignal support was added.
+  - version: v11.4.0
+    pr-url: https://github.com/nodejs/node/pull/23798
+    description: The `ipv6Only` option is supported.
   - version: v8.7.0
     pr-url: https://github.com/nodejs/node/pull/13623
     description: The `recvBufferSize` and `sendBufferSize` options are
                  supported now.
-  - version: v11.4.0
-    pr-url: https://github.com/nodejs/node/pull/23798
-    description: The `ipv6Only` option is supported.
+  - version: v8.6.0
+    pr-url: https://github.com/nodejs/node/pull/14560
+    description: The `lookup` option is supported.
 -->
 
 * `options` {Object} Available options are:
@@ -752,6 +760,7 @@ changes:
   * `recvBufferSize` {number} Sets the `SO_RCVBUF` socket value.
   * `sendBufferSize` {number} Sets the `SO_SNDBUF` socket value.
   * `lookup` {Function} Custom lookup function. **Default:** [`dns.lookup()`][].
+  * `signal` {AbortSignal} An AbortSignal that may be used to close a socket.
 * `callback` {Function} Attached as a listener for `'message'` events. Optional.
 * Returns: {dgram.Socket}
 
@@ -763,6 +772,20 @@ method will bind the socket to the "all interfaces" address on a random port
 and port can be retrieved using [`socket.address().address`][] and
 [`socket.address().port`][].
 
+If the `signal` option is enabled, calling `.abort()` on the corresponding
+`AbortController` is similar to calling `.close()` on the socket:
+
+```js
+const controller = new AbortController();
+const { signal } = controller;
+const server = dgram.createSocket({ type: 'udp4', signal });
+server.on('message', (msg, rinfo) => {
+  console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
+});
+// Later, when you want to close the server.
+controller.abort();
+```
+
 ### `dgram.createSocket(type[, callback])`
 <!-- YAML
 added: v0.1.99
@@ -781,21 +804,21 @@ interfaces" address on a random port (it does the right thing for both `udp4`
 and `udp6` sockets). The bound address and port can be retrieved using
 [`socket.address().address`][] and [`socket.address().port`][].
 
+[IPv6 Zone Indices]: https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses
+[RFC 4007]: https://tools.ietf.org/html/rfc4007
 [`'close'`]: #dgram_event_close
-[`ERR_SOCKET_BAD_PORT`]: errors.html#errors_err_socket_bad_port
-[`ERR_SOCKET_BUFFER_SIZE`]: errors.html#errors_err_socket_buffer_size
-[`ERR_SOCKET_DGRAM_IS_CONNECTED`]: errors.html#errors_err_socket_dgram_is_connected
-[`ERR_SOCKET_DGRAM_NOT_CONNECTED`]: errors.html#errors_err_socket_dgram_not_connected
-[`Error`]: errors.html#errors_class_error
-[`System Error`]: errors.html#errors_class_systemerror
+[`ERR_SOCKET_BAD_PORT`]: errors.md#errors_err_socket_bad_port
+[`ERR_SOCKET_BUFFER_SIZE`]: errors.md#errors_err_socket_buffer_size
+[`ERR_SOCKET_DGRAM_IS_CONNECTED`]: errors.md#errors_err_socket_dgram_is_connected
+[`ERR_SOCKET_DGRAM_NOT_CONNECTED`]: errors.md#errors_err_socket_dgram_not_connected
+[`Error`]: errors.md#errors_class_error
+[`System Error`]: errors.md#errors_class_systemerror
 [`close()`]: #dgram_socket_close_callback
-[`cluster`]: cluster.html
+[`cluster`]: cluster.md
 [`connect()`]: #dgram_socket_connect_port_address_callback
 [`dgram.createSocket()`]: #dgram_dgram_createsocket_options_callback
-[`dns.lookup()`]: dns.html#dns_dns_lookup_hostname_options_callback
+[`dns.lookup()`]: dns.md#dns_dns_lookup_hostname_options_callback
 [`socket.address().address`]: #dgram_socket_address
 [`socket.address().port`]: #dgram_socket_address
 [`socket.bind()`]: #dgram_socket_bind_port_address_callback
-[IPv6 Zone Indices]: https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses
-[RFC 4007]: https://tools.ietf.org/html/rfc4007
-[byte length]: buffer.html#buffer_static_method_buffer_bytelength_string_encoding
+[byte length]: buffer.md#buffer_static_method_buffer_bytelength_string_encoding
diff --git a/doc/api/diagnostics_channel.html b/doc/api/diagnostics_channel.html
new file mode 100644
index 0000000000000000000000000000000000000000..63224133c1eb6e3bdc3d9c33c14c9a9fb8bed9c9
--- /dev/null
+++ b/doc/api/diagnostics_channel.html
@@ -0,0 +1,332 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width">
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Diagnostics Channel | Node.js v14.18.3 Documentation</title>
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
+  <link rel="stylesheet" href="assets/style.css">
+  <link rel="stylesheet" href="assets/hljs.css">
+  <link rel="canonical" href="https://nodejs.org/api/diagnostics_channel.html">
+</head>
+<body class="alt apidoc" id="api-section-diagnostics_channel">
+  <div id="content" class="clearfix">
+    <div id="column2" class="interior">
+      <div id="intro" class="interior">
+        <a href="/" title="Go back to the home page">
+          Node.js
+        </a>
+      </div>
+      <ul>
+<li><a href="documentation.html" class="nav-documentation">About this documentation</a></li>
+<li><a href="synopsis.html" class="nav-synopsis">Usage and example</a></li>
+</ul>
+<hr class="line">
+<ul>
+<li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
+<li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
+<li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
+<li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
+<li><a href="console.html" class="nav-console">Console</a></li>
+<li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
+<li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
+<li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel active">Diagnostics Channel</a></li>
+<li><a href="dns.html" class="nav-dns">DNS</a></li>
+<li><a href="domain.html" class="nav-domain">Domain</a></li>
+<li><a href="errors.html" class="nav-errors">Errors</a></li>
+<li><a href="events.html" class="nav-events">Events</a></li>
+<li><a href="fs.html" class="nav-fs">File system</a></li>
+<li><a href="globals.html" class="nav-globals">Globals</a></li>
+<li><a href="http.html" class="nav-http">HTTP</a></li>
+<li><a href="http2.html" class="nav-http2">HTTP/2</a></li>
+<li><a href="https.html" class="nav-https">HTTPS</a></li>
+<li><a href="inspector.html" class="nav-inspector">Inspector</a></li>
+<li><a href="intl.html" class="nav-intl">Internationalization</a></li>
+<li><a href="modules.html" class="nav-modules">Modules: CommonJS modules</a></li>
+<li><a href="esm.html" class="nav-esm">Modules: ECMAScript modules</a></li>
+<li><a href="module.html" class="nav-module">Modules: <code>module</code> API</a></li>
+<li><a href="packages.html" class="nav-packages">Modules: Packages</a></li>
+<li><a href="net.html" class="nav-net">Net</a></li>
+<li><a href="os.html" class="nav-os">OS</a></li>
+<li><a href="path.html" class="nav-path">Path</a></li>
+<li><a href="perf_hooks.html" class="nav-perf_hooks">Performance hooks</a></li>
+<li><a href="policy.html" class="nav-policy">Policies</a></li>
+<li><a href="process.html" class="nav-process">Process</a></li>
+<li><a href="punycode.html" class="nav-punycode">Punycode</a></li>
+<li><a href="querystring.html" class="nav-querystring">Query strings</a></li>
+<li><a href="readline.html" class="nav-readline">Readline</a></li>
+<li><a href="repl.html" class="nav-repl">REPL</a></li>
+<li><a href="report.html" class="nav-report">Report</a></li>
+<li><a href="stream.html" class="nav-stream">Stream</a></li>
+<li><a href="string_decoder.html" class="nav-string_decoder">String decoder</a></li>
+<li><a href="timers.html" class="nav-timers">Timers</a></li>
+<li><a href="tls.html" class="nav-tls">TLS/SSL</a></li>
+<li><a href="tracing.html" class="nav-tracing">Trace events</a></li>
+<li><a href="tty.html" class="nav-tty">TTY</a></li>
+<li><a href="dgram.html" class="nav-dgram">UDP/datagram</a></li>
+<li><a href="url.html" class="nav-url">URL</a></li>
+<li><a href="util.html" class="nav-util">Utilities</a></li>
+<li><a href="v8.html" class="nav-v8">V8</a></li>
+<li><a href="vm.html" class="nav-vm">VM</a></li>
+<li><a href="wasi.html" class="nav-wasi">WASI</a></li>
+<li><a href="worker_threads.html" class="nav-worker_threads">Worker threads</a></li>
+<li><a href="zlib.html" class="nav-zlib">Zlib</a></li>
+</ul>
+<hr class="line">
+<ul>
+<li><a href="https://github.com/nodejs/node" class="nav-https-github-com-nodejs-node">Code repository and issue tracker</a></li>
+</ul>
+    </div>
+
+    <div id="column1" data-id="diagnostics_channel" class="interior">
+      <header>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
+        <div id="gtoc">
+          <ul>
+            <li>
+              <a href="index.html">Index</a>
+            </li>
+            <li>
+              <a href="all.html">View on single page</a>
+            </li>
+            <li>
+              <a href="diagnostics_channel.json">View as JSON</a>
+            </li>
+            
+    <li class="version-picker">
+      <a href="#">View another version <span>&#x25bc;</span></a>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/diagnostics_channel.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/diagnostics_channel.html">16.x <b>LTS</b></a></li>
+<li><a href="https://nodejs.org/docs/latest-v15.x/api/diagnostics_channel.html">15.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v14.x/api/diagnostics_channel.html">14.x <b>LTS</b></a></li></ol>
+    </li>
+  
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/diagnostics_channel.md">Edit on GitHub</a></li>
+          </ul>
+        </div>
+        <hr>
+      </header>
+
+      <details id="toc" open><summary>Table of contents</summary><ul>
+<li><span class="stability_1"><a href="#diagnostics_channel_diagnostics_channel">Diagnostics Channel</a></span>
+<ul>
+<li><a href="#diagnostics_channel_public_api">Public API</a>
+<ul>
+<li><a href="#diagnostics_channel_overview">Overview</a>
+<ul>
+<li><a href="#diagnostics_channel_diagnostics_channel_hassubscribers_name"><code>diagnostics_channel.hasSubscribers(name)</code></a></li>
+<li><a href="#diagnostics_channel_diagnostics_channel_channel_name"><code>diagnostics_channel.channel(name)</code></a></li>
+</ul>
+</li>
+<li><a href="#diagnostics_channel_class_channel">Class: <code>Channel</code></a>
+<ul>
+<li><a href="#diagnostics_channel_channel_hassubscribers"><code>channel.hasSubscribers</code></a></li>
+<li><a href="#diagnostics_channel_channel_publish_message"><code>channel.publish(message)</code></a></li>
+<li><a href="#diagnostics_channel_channel_subscribe_onmessage"><code>channel.subscribe(onMessage)</code></a></li>
+<li><a href="#diagnostics_channel_channel_unsubscribe_onmessage"><code>channel.unsubscribe(onMessage)</code></a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul></details>
+
+      <div id="apicontent">
+        <h2>Diagnostics Channel<span><a class="mark" href="#diagnostics_channel_diagnostics_channel" id="diagnostics_channel_diagnostics_channel">#</a></span></h2>
+
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/diagnostics_channel.js">lib/diagnostics_channel.js</a></p>
+<p>The <code>diagnostics_channel</code> module provides an API to create named channels
+to report arbitrary message data for diagnostics purposes.</p>
+<p>It can be accessed using:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);</code></pre>
+<p>It is intended that a module writer wanting to report diagnostics messages
+will create one or many top-level channels to report messages through.
+Channels may also be acquired at runtime but it is not encouraged
+due to the additional overhead of doing so. Channels may be exported for
+convenience, but as long as the name is known it can be acquired anywhere.</p>
+<p>If you intend for your module to produce diagnostics data for others to
+consume it is recommended that you include documentation of what named
+channels are used along with the shape of the message data. Channel names
+should generally include the module name to avoid collisions with data from
+other modules.</p>
+<section><h3>Public API<span><a class="mark" href="#diagnostics_channel_public_api" id="diagnostics_channel_public_api">#</a></span></h3>
+<h4>Overview<span><a class="mark" href="#diagnostics_channel_overview" id="diagnostics_channel_overview">#</a></span></h4>
+<p>Following is a simple overview of the public API.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-comment">// Get a reusable channel object</span>
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+<span class="hljs-comment">// Subscribe to the channel</span>
+channel.<span class="hljs-title function_">subscribe</span>(<span class="hljs-function">(<span class="hljs-params">message, name</span>) =></span> {
+  <span class="hljs-comment">// Received data</span>
+});
+
+<span class="hljs-comment">// Check if the channel has an active subscriber</span>
+<span class="hljs-keyword">if</span> (channel.<span class="hljs-property">hasSubscribers</span>) {
+  <span class="hljs-comment">// Publish data to the channel</span>
+  channel.<span class="hljs-title function_">publish</span>({
+    <span class="hljs-attr">some</span>: <span class="hljs-string">'data'</span>
+  });
+}</code></pre>
+<h5><code>diagnostics_channel.hasSubscribers(name)</code><span><a class="mark" href="#diagnostics_channel_diagnostics_channel_hassubscribers_name" id="diagnostics_channel_diagnostics_channel_hassubscribers_name">#</a></span></h5>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The channel name</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If there are active subscribers</li>
+</ul>
+<p>Check if there are active subscribers to the named channel. This is helpful if
+the message you want to send might be expensive to prepare.</p>
+<p>This API is optional but helpful when trying to publish messages from very
+performance-sensitive code.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">if</span> (diagnostics_channel.<span class="hljs-title function_">hasSubscribers</span>(<span class="hljs-string">'my-channel'</span>)) {
+  <span class="hljs-comment">// There are subscribers, prepare and publish message</span>
+}</code></pre>
+<h5><code>diagnostics_channel.channel(name)</code><span><a class="mark" href="#diagnostics_channel_diagnostics_channel_channel_name" id="diagnostics_channel_diagnostics_channel_channel_name">#</a></span></h5>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The channel name</li>
+<li>Returns: <a href="diagnostics_channel.html#diagnostics_channel_class_channel" class="type">&#x3C;Channel></a> The named channel object</li>
+</ul>
+<p>This is the primary entry-point for anyone wanting to interact with a named
+channel. It produces a channel object which is optimized to reduce overhead at
+publish time as much as possible.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);</code></pre>
+<h4>Class: <code>Channel</code><span><a class="mark" href="#diagnostics_channel_class_channel" id="diagnostics_channel_class_channel">#</a></span></h4>
+<p>The class <code>Channel</code> represents an individual named channel within the data
+pipeline. It is use to track subscribers and to publish messages when there
+are subscribers present. It exists as a separate object to avoid channel
+lookups at publish time, enabling very fast publish speeds and allowing
+for heavy use while incurring very minimal cost. Channels are created with
+<a href="#diagnostics_channel_diagnostics_channel_channel_name"><code>diagnostics_channel.channel(name)</code></a>, constructing a channel directly
+with <code>new Channel(name)</code> is not supported.</p>
+<h5><code>channel.hasSubscribers</code><span><a class="mark" href="#diagnostics_channel_channel_hassubscribers" id="diagnostics_channel_channel_hassubscribers">#</a></span></h5>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If there are active subscribers</li>
+</ul>
+<p>Check if there are active subscribers to this channel. This is helpful if
+the message you want to send might be expensive to prepare.</p>
+<p>This API is optional but helpful when trying to publish messages from very
+performance-sensitive code.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+<span class="hljs-keyword">if</span> (channel.<span class="hljs-property">hasSubscribers</span>) {
+  <span class="hljs-comment">// There are subscribers, prepare and publish message</span>
+}</code></pre>
+<h5><code>channel.publish(message)</code><span><a class="mark" href="#diagnostics_channel_channel_publish_message" id="diagnostics_channel_channel_publish_message">#</a></span></h5>
+<ul>
+<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The message to send to the channel subscribers</li>
+</ul>
+<p>Publish a message to any subscribers to the channel. This will trigger
+message handlers synchronously so they will execute within the same context.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+channel.<span class="hljs-title function_">publish</span>({
+  <span class="hljs-attr">some</span>: <span class="hljs-string">'message'</span>
+});</code></pre>
+<h5><code>channel.subscribe(onMessage)</code><span><a class="mark" href="#diagnostics_channel_channel_subscribe_onmessage" id="diagnostics_channel_channel_subscribe_onmessage">#</a></span></h5>
+<ul>
+<li><code>onMessage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The handler to receive channel messages
+<ul>
+<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The message data</li>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the channel</li>
+</ul>
+</li>
+</ul>
+<p>Register a message handler to subscribe to this channel. This message handler
+will be run synchronously whenever a message is published to the channel. Any
+errors thrown in the message handler will trigger an <a href="process.html#process_event_uncaughtexception"><code>'uncaughtException'</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+channel.<span class="hljs-title function_">subscribe</span>(<span class="hljs-function">(<span class="hljs-params">message, name</span>) =></span> {
+  <span class="hljs-comment">// Received data</span>
+});</code></pre>
+<h5><code>channel.unsubscribe(onMessage)</code><span><a class="mark" href="#diagnostics_channel_channel_unsubscribe_onmessage" id="diagnostics_channel_channel_unsubscribe_onmessage">#</a></span></h5>
+<ul>
+<li><code>onMessage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The previous subscribed handler to remove</li>
+</ul>
+<p>Remove a message handler previously registered to this channel with
+<a href="#diagnostics_channel_channel_subscribe_onmessage"><code>channel.subscribe(onMessage)</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> diagnostics_channel = <span class="hljs-built_in">require</span>(<span class="hljs-string">'diagnostics_channel'</span>);
+
+<span class="hljs-keyword">const</span> channel = diagnostics_channel.<span class="hljs-title function_">channel</span>(<span class="hljs-string">'my-channel'</span>);
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">onMessage</span>(<span class="hljs-params">message, name</span>) {
+  <span class="hljs-comment">// Received data</span>
+}
+
+channel.<span class="hljs-title function_">subscribe</span>(onMessage);
+
+channel.<span class="hljs-title function_">unsubscribe</span>(onMessage);</code></pre></section>
+        <!-- API END -->
+      </div>
+    </div>
+  </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
+</body>
+</html>
diff --git a/doc/api/diagnostics_channel.json b/doc/api/diagnostics_channel.json
new file mode 100644
index 0000000000000000000000000000000000000000..70b47d570da618ed2048916566780f47073c6b92
--- /dev/null
+++ b/doc/api/diagnostics_channel.json
@@ -0,0 +1,170 @@
+{
+  "type": "module",
+  "source": "doc/api/diagnostics_channel.md",
+  "modules": [
+    {
+      "textRaw": "Diagnostics Channel",
+      "name": "diagnostics_channel",
+      "introduced_in": "v14.17.0",
+      "stability": 1,
+      "stabilityText": "Experimental",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/diagnostics_channel.js\">lib/diagnostics_channel.js</a></p>\n<p>The <code>diagnostics_channel</code> module provides an API to create named channels\nto report arbitrary message data for diagnostics purposes.</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n</code></pre>\n<p>It is intended that a module writer wanting to report diagnostics messages\nwill create one or many top-level channels to report messages through.\nChannels may also be acquired at runtime but it is not encouraged\ndue to the additional overhead of doing so. Channels may be exported for\nconvenience, but as long as the name is known it can be acquired anywhere.</p>\n<p>If you intend for your module to produce diagnostics data for others to\nconsume it is recommended that you include documentation of what named\nchannels are used along with the shape of the message data. Channel names\nshould generally include the module name to avoid collisions with data from\nother modules.</p>",
+      "modules": [
+        {
+          "textRaw": "Public API",
+          "name": "public_api",
+          "modules": [
+            {
+              "textRaw": "Overview",
+              "name": "overview",
+              "desc": "<p>Following is a simple overview of the public API.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\n// Get a reusable channel object\nconst channel = diagnostics_channel.channel('my-channel');\n\n// Subscribe to the channel\nchannel.subscribe((message, name) => {\n  // Received data\n});\n\n// Check if the channel has an active subscriber\nif (channel.hasSubscribers) {\n  // Publish data to the channel\n  channel.publish({\n    some: 'data'\n  });\n}\n</code></pre>",
+              "methods": [
+                {
+                  "textRaw": "`diagnostics_channel.hasSubscribers(name)`",
+                  "type": "method",
+                  "name": "hasSubscribers",
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean} If there are active subscribers",
+                        "name": "return",
+                        "type": "boolean",
+                        "desc": "If there are active subscribers"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`name` {string|symbol} The channel name",
+                          "name": "name",
+                          "type": "string|symbol",
+                          "desc": "The channel name"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Check if there are active subscribers to the named channel. This is helpful if\nthe message you want to send might be expensive to prepare.</p>\n<p>This API is optional but helpful when trying to publish messages from very\nperformance-sensitive code.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nif (diagnostics_channel.hasSubscribers('my-channel')) {\n  // There are subscribers, prepare and publish message\n}\n</code></pre>"
+                },
+                {
+                  "textRaw": "`diagnostics_channel.channel(name)`",
+                  "type": "method",
+                  "name": "channel",
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {Channel} The named channel object",
+                        "name": "return",
+                        "type": "Channel",
+                        "desc": "The named channel object"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`name` {string|symbol} The channel name",
+                          "name": "name",
+                          "type": "string|symbol",
+                          "desc": "The channel name"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>This is the primary entry-point for anyone wanting to interact with a named\nchannel. It produces a channel object which is optimized to reduce overhead at\npublish time as much as possible.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n</code></pre>"
+                }
+              ],
+              "type": "module",
+              "displayName": "Overview"
+            }
+          ],
+          "classes": [
+            {
+              "textRaw": "Class: `Channel`",
+              "type": "class",
+              "name": "Channel",
+              "desc": "<p>The class <code>Channel</code> represents an individual named channel within the data\npipeline. It is use to track subscribers and to publish messages when there\nare subscribers present. It exists as a separate object to avoid channel\nlookups at publish time, enabling very fast publish speeds and allowing\nfor heavy use while incurring very minimal cost. Channels are created with\n<a href=\"#diagnostics_channel_diagnostics_channel_channel_name\"><code>diagnostics_channel.channel(name)</code></a>, constructing a channel directly\nwith <code>new Channel(name)</code> is not supported.</p>",
+              "properties": [
+                {
+                  "textRaw": "`hasSubscribers` Returns: {boolean} If there are active subscribers",
+                  "type": "boolean",
+                  "name": "return",
+                  "desc": "<p>Check if there are active subscribers to this channel. This is helpful if\nthe message you want to send might be expensive to prepare.</p>\n<p>This API is optional but helpful when trying to publish messages from very\nperformance-sensitive code.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n\nif (channel.hasSubscribers) {\n  // There are subscribers, prepare and publish message\n}\n</code></pre>",
+                  "shortDesc": "If there are active subscribers"
+                }
+              ],
+              "methods": [
+                {
+                  "textRaw": "`channel.publish(message)`",
+                  "type": "method",
+                  "name": "publish",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`message` {any} The message to send to the channel subscribers",
+                          "name": "message",
+                          "type": "any",
+                          "desc": "The message to send to the channel subscribers"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Publish a message to any subscribers to the channel. This will trigger\nmessage handlers synchronously so they will execute within the same context.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n\nchannel.publish({\n  some: 'message'\n});\n</code></pre>"
+                },
+                {
+                  "textRaw": "`channel.subscribe(onMessage)`",
+                  "type": "method",
+                  "name": "subscribe",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`onMessage` {Function} The handler to receive channel messages",
+                          "name": "onMessage",
+                          "type": "Function",
+                          "desc": "The handler to receive channel messages",
+                          "options": [
+                            {
+                              "textRaw": "`message` {any} The message data",
+                              "name": "message",
+                              "type": "any",
+                              "desc": "The message data"
+                            },
+                            {
+                              "textRaw": "`name` {string|symbol} The name of the channel",
+                              "name": "name",
+                              "type": "string|symbol",
+                              "desc": "The name of the channel"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Register a message handler to subscribe to this channel. This message handler\nwill be run synchronously whenever a message is published to the channel. Any\nerrors thrown in the message handler will trigger an <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a>.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n\nchannel.subscribe((message, name) => {\n  // Received data\n});\n</code></pre>"
+                },
+                {
+                  "textRaw": "`channel.unsubscribe(onMessage)`",
+                  "type": "method",
+                  "name": "unsubscribe",
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`onMessage` {Function} The previous subscribed handler to remove",
+                          "name": "onMessage",
+                          "type": "Function",
+                          "desc": "The previous subscribed handler to remove"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Remove a message handler previously registered to this channel with\n<a href=\"#diagnostics_channel_channel_subscribe_onmessage\"><code>channel.subscribe(onMessage)</code></a>.</p>\n<pre><code class=\"language-js\">const diagnostics_channel = require('diagnostics_channel');\n\nconst channel = diagnostics_channel.channel('my-channel');\n\nfunction onMessage(message, name) {\n  // Received data\n}\n\nchannel.subscribe(onMessage);\n\nchannel.unsubscribe(onMessage);\n</code></pre>"
+                }
+              ]
+            }
+          ],
+          "type": "module",
+          "displayName": "Public API"
+        }
+      ],
+      "type": "module",
+      "displayName": "Diagnostics Channel"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/doc/api/diagnostics_channel.md b/doc/api/diagnostics_channel.md
new file mode 100644
index 0000000000000000000000000000000000000000..16b47db3bf6cc42cb32ec851f95629ecdb2c6157
--- /dev/null
+++ b/doc/api/diagnostics_channel.md
@@ -0,0 +1,180 @@
+# Diagnostics Channel
+
+<!--introduced_in=v14.17.0-->
+
+> Stability: 1 - Experimental
+
+<!-- source_link=lib/diagnostics_channel.js -->
+
+The `diagnostics_channel` module provides an API to create named channels
+to report arbitrary message data for diagnostics purposes.
+
+It can be accessed using:
+
+```js
+const diagnostics_channel = require('diagnostics_channel');
+```
+
+It is intended that a module writer wanting to report diagnostics messages
+will create one or many top-level channels to report messages through.
+Channels may also be acquired at runtime but it is not encouraged
+due to the additional overhead of doing so. Channels may be exported for
+convenience, but as long as the name is known it can be acquired anywhere.
+
+If you intend for your module to produce diagnostics data for others to
+consume it is recommended that you include documentation of what named
+channels are used along with the shape of the message data. Channel names
+should generally include the module name to avoid collisions with data from
+other modules.
+
+## Public API
+
+### Overview
+
+Following is a simple overview of the public API.
+
+```js
+const diagnostics_channel = require('diagnostics_channel');
+
+// Get a reusable channel object
+const channel = diagnostics_channel.channel('my-channel');
+
+// Subscribe to the channel
+channel.subscribe((message, name) => {
+  // Received data
+});
+
+// Check if the channel has an active subscriber
+if (channel.hasSubscribers) {
+  // Publish data to the channel
+  channel.publish({
+    some: 'data'
+  });
+}
+```
+
+#### `diagnostics_channel.hasSubscribers(name)`
+
+* `name` {string|symbol} The channel name
+* Returns: {boolean} If there are active subscribers
+
+Check if there are active subscribers to the named channel. This is helpful if
+the message you want to send might be expensive to prepare.
+
+This API is optional but helpful when trying to publish messages from very
+performance-sensitive code.
+
+```js
+const diagnostics_channel = require('diagnostics_channel');
+
+if (diagnostics_channel.hasSubscribers('my-channel')) {
+  // There are subscribers, prepare and publish message
+}
+```
+
+#### `diagnostics_channel.channel(name)`
+
+* `name` {string|symbol} The channel name
+* Returns: {Channel} The named channel object
+
+This is the primary entry-point for anyone wanting to interact with a named
+channel. It produces a channel object which is optimized to reduce overhead at
+publish time as much as possible.
+
+```js
+const diagnostics_channel = require('diagnostics_channel');
+
+const channel = diagnostics_channel.channel('my-channel');
+```
+
+### Class: `Channel`
+
+The class `Channel` represents an individual named channel within the data
+pipeline. It is use to track subscribers and to publish messages when there
+are subscribers present. It exists as a separate object to avoid channel
+lookups at publish time, enabling very fast publish speeds and allowing
+for heavy use while incurring very minimal cost. Channels are created with
+[`diagnostics_channel.channel(name)`][], constructing a channel directly
+with `new Channel(name)` is not supported.
+
+#### `channel.hasSubscribers`
+
+* Returns: {boolean} If there are active subscribers
+
+Check if there are active subscribers to this channel. This is helpful if
+the message you want to send might be expensive to prepare.
+
+This API is optional but helpful when trying to publish messages from very
+performance-sensitive code.
+
+```js
+const diagnostics_channel = require('diagnostics_channel');
+
+const channel = diagnostics_channel.channel('my-channel');
+
+if (channel.hasSubscribers) {
+  // There are subscribers, prepare and publish message
+}
+```
+
+#### `channel.publish(message)`
+
+* `message` {any} The message to send to the channel subscribers
+
+Publish a message to any subscribers to the channel. This will trigger
+message handlers synchronously so they will execute within the same context.
+
+```js
+const diagnostics_channel = require('diagnostics_channel');
+
+const channel = diagnostics_channel.channel('my-channel');
+
+channel.publish({
+  some: 'message'
+});
+```
+
+#### `channel.subscribe(onMessage)`
+
+* `onMessage` {Function} The handler to receive channel messages
+  * `message` {any} The message data
+  * `name` {string|symbol} The name of the channel
+
+Register a message handler to subscribe to this channel. This message handler
+will be run synchronously whenever a message is published to the channel. Any
+errors thrown in the message handler will trigger an [`'uncaughtException'`][].
+
+```js
+const diagnostics_channel = require('diagnostics_channel');
+
+const channel = diagnostics_channel.channel('my-channel');
+
+channel.subscribe((message, name) => {
+  // Received data
+});
+```
+
+#### `channel.unsubscribe(onMessage)`
+
+* `onMessage` {Function} The previous subscribed handler to remove
+
+Remove a message handler previously registered to this channel with
+[`channel.subscribe(onMessage)`][].
+
+```js
+const diagnostics_channel = require('diagnostics_channel');
+
+const channel = diagnostics_channel.channel('my-channel');
+
+function onMessage(message, name) {
+  // Received data
+}
+
+channel.subscribe(onMessage);
+
+channel.unsubscribe(onMessage);
+```
+
+[`'uncaughtException'`]: process.md#process_event_uncaughtexception
+[`channel.subscribe(onMessage)`]: #diagnostics_channel_channel_subscribe_onmessage
+[`diagnostics_channel.channel(name)`]: #diagnostics_channel_diagnostics_channel_channel_name
diff --git a/doc/api/dns.html b/doc/api/dns.html
index 4238c3ae847cb6d80e0f1a3206be270d905f2973..fa5614958a0abec287e0b71939ea6c39b4a4a1ab 100644
--- a/doc/api/dns.html
+++ b/doc/api/dns.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>DNS | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>DNS | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns active">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="dns" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/dns.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/dns.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/dns.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/dns.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/dns.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/dns.html">13.x</a></li>
@@ -118,21 +133,20 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/dns.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/dns.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/dns.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#dns_dns">DNS</a></span>
 <ul>
 <li><a href="#dns_class_dns_resolver">Class: <code>dns.Resolver</code></a>
 <ul>
 <li><a href="#dns_resolver_options"><code>Resolver([options])</code></a></li>
 <li><a href="#dns_resolver_cancel"><code>resolver.cancel()</code></a></li>
+<li><a href="#dns_resolver_setlocaladdress_ipv4_ipv6"><code>resolver.setLocalAddress([ipv4][, ipv6])</code></a></li>
 </ul>
 </li>
 <li><a href="#dns_dns_getservers"><code>dns.getServers()</code></a></li>
@@ -147,6 +161,7 @@
 <li><a href="#dns_dns_resolve6_hostname_options_callback"><code>dns.resolve6(hostname[, options], callback)</code></a></li>
 <li><a href="#dns_dns_resolveany_hostname_callback"><code>dns.resolveAny(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvecname_hostname_callback"><code>dns.resolveCname(hostname, callback)</code></a></li>
+<li><a href="#dns_dns_resolvecaa_hostname_callback"><code>dns.resolveCaa(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvemx_hostname_callback"><code>dns.resolveMx(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvenaptr_hostname_callback"><code>dns.resolveNaptr(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvens_hostname_callback"><code>dns.resolveNs(hostname, callback)</code></a></li>
@@ -155,10 +170,12 @@
 <li><a href="#dns_dns_resolvesrv_hostname_callback"><code>dns.resolveSrv(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_resolvetxt_hostname_callback"><code>dns.resolveTxt(hostname, callback)</code></a></li>
 <li><a href="#dns_dns_reverse_ip_callback"><code>dns.reverse(ip, callback)</code></a></li>
+<li><a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder(order)</code></a></li>
 <li><a href="#dns_dns_setservers_servers"><code>dns.setServers(servers)</code></a></li>
 <li><a href="#dns_dns_promises_api">DNS promises API</a>
 <ul>
 <li><a href="#dns_class_dnspromises_resolver">Class: <code>dnsPromises.Resolver</code></a></li>
+<li><a href="#dns_resolver_cancel_1"><code>resolver.cancel()</code></a></li>
 <li><a href="#dns_dnspromises_getservers"><code>dnsPromises.getServers()</code></a></li>
 <li><a href="#dns_dnspromises_lookup_hostname_options"><code>dnsPromises.lookup(hostname[, options])</code></a></li>
 <li><a href="#dns_dnspromises_lookupservice_address_port"><code>dnsPromises.lookupService(address, port)</code></a></li>
@@ -166,6 +183,7 @@
 <li><a href="#dns_dnspromises_resolve4_hostname_options"><code>dnsPromises.resolve4(hostname[, options])</code></a></li>
 <li><a href="#dns_dnspromises_resolve6_hostname_options"><code>dnsPromises.resolve6(hostname[, options])</code></a></li>
 <li><a href="#dns_dnspromises_resolveany_hostname"><code>dnsPromises.resolveAny(hostname)</code></a></li>
+<li><a href="#dns_dnspromises_resolvecaa_hostname"><code>dnsPromises.resolveCaa(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_resolvecname_hostname"><code>dnsPromises.resolveCname(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_resolvemx_hostname"><code>dnsPromises.resolveMx(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_resolvenaptr_hostname"><code>dnsPromises.resolveNaptr(hostname)</code></a></li>
@@ -175,6 +193,7 @@
 <li><a href="#dns_dnspromises_resolvesrv_hostname"><code>dnsPromises.resolveSrv(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_resolvetxt_hostname"><code>dnsPromises.resolveTxt(hostname)</code></a></li>
 <li><a href="#dns_dnspromises_reverse_ip"><code>dnsPromises.reverse(ip)</code></a></li>
+<li><a href="#dns_dnspromises_setdefaultresultorder_order"><code>dnsPromises.setDefaultResultOrder(order)</code></a></li>
 <li><a href="#dns_dnspromises_setservers_servers"><code>dnsPromises.setServers(servers)</code></a></li>
 </ul>
 </li>
@@ -187,14 +206,13 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>DNS<span><a class="mark" href="#dns_dns" id="dns_dns">#</a></span></h1>
+        <h2>DNS<span><a class="mark" href="#dns_dns" id="dns_dns">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/dns.js">lib/dns.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/dns.js">lib/dns.js</a></p>
 <p>The <code>dns</code> module enables name resolution. For example, use it to look up IP
 addresses of host names.</p>
 <p>Although named for the <a href="https://en.wikipedia.org/wiki/Domain_Name_System">Domain Name System (DNS)</a>, it does not always use the
@@ -204,8 +222,8 @@ communication. To perform name resolution the way other applications on the same
 system do, use <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
 
-dns.lookup(<span class="hljs-string">'example.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, address, family</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'address: %j family: IPv%s'</span>, address, family);
+dns.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, address, family</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'address: %j family: IPv%s'</span>, address, family);
 });
 <span class="hljs-comment">// address: "93.184.216.34" family: IPv4</span></code></pre>
 <p>All other functions in the <code>dns</code> module connect to an actual DNS server to
@@ -215,22 +233,22 @@ queries. These functions do not use the same set of configuration files used by
 DNS queries, bypassing other name-resolution facilities.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
 
-dns.resolve4(<span class="hljs-string">'archive.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span> {
+dns.<span class="hljs-title function_">resolve4</span>(<span class="hljs-string">'archive.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
 
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`addresses: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(addresses)}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`addresses: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(addresses)}</span>`</span>);
 
-  addresses.forEach(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> {
-    dns.reverse(a, <span class="hljs-function">(<span class="hljs-params">err, hostnames</span>) =></span> {
+  addresses.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> {
+    dns.<span class="hljs-title function_">reverse</span>(a, <span class="hljs-function">(<span class="hljs-params">err, hostnames</span>) =></span> {
       <span class="hljs-keyword">if</span> (err) {
         <span class="hljs-keyword">throw</span> err;
       }
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`reverse for <span class="hljs-subst">${a}</span>: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(hostnames)}</span>`</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`reverse for <span class="hljs-subst">${a}</span>: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(hostnames)}</span>`</span>);
     });
   });
 });</code></pre>
 <p>See the <a href="#dns_implementation_considerations">Implementation considerations section</a> for more information.</p>
-<h2>Class: <code>dns.Resolver</code><span><a class="mark" href="#dns_class_dns_resolver" id="dns_class_dns_resolver">#</a></span></h2>
+<section><h3>Class: <code>dns.Resolver</code><span><a class="mark" href="#dns_class_dns_resolver" id="dns_class_dns_resolver">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
@@ -239,12 +257,12 @@ dns.resolve4(<span class="hljs-string">'archive.org'</span>, <span class="hljs-f
 the servers used for a resolver using
 <a href="#dns_dns_setservers_servers"><code>resolver.setServers()</code></a> does not affect
 other resolvers:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Resolver } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
-<span class="hljs-keyword">const</span> resolver = <span class="hljs-keyword">new</span> Resolver();
-resolver.setServers([<span class="hljs-string">'4.4.4.4'</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Resolver</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
+<span class="hljs-keyword">const</span> resolver = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Resolver</span>();
+resolver.<span class="hljs-title function_">setServers</span>([<span class="hljs-string">'4.4.4.4'</span>]);
 
 <span class="hljs-comment">// This request will use the server at 4.4.4.4, independent of global settings.</span>
-resolver.resolve4(<span class="hljs-string">'example.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span> {
+resolver.<span class="hljs-title function_">resolve4</span>(<span class="hljs-string">'example.org'</span>, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>The following methods from the <code>dns</code> module are available:</p>
@@ -254,6 +272,7 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>, <span class="h
 <li><a href="#dns_dns_resolve4_hostname_options_callback"><code>resolver.resolve4()</code></a></li>
 <li><a href="#dns_dns_resolve6_hostname_options_callback"><code>resolver.resolve6()</code></a></li>
 <li><a href="#dns_dns_resolveany_hostname_callback"><code>resolver.resolveAny()</code></a></li>
+<li><a href="#dns_dns_resolvecaa_hostname_callback"><code>resolver.resolveCaa()</code></a></li>
 <li><a href="#dns_dns_resolvecname_hostname_callback"><code>resolver.resolveCname()</code></a></li>
 <li><a href="#dns_dns_resolvemx_hostname_callback"><code>resolver.resolveMx()</code></a></li>
 <li><a href="#dns_dns_resolvenaptr_hostname_callback"><code>resolver.resolveNaptr()</code></a></li>
@@ -265,12 +284,14 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>, <span class="h
 <li><a href="#dns_dns_reverse_ip_callback"><code>resolver.reverse()</code></a></li>
 <li><a href="#dns_dns_setservers_servers"><code>resolver.setServers()</code></a></li>
 </ul>
-<h3><code>Resolver([options])</code><span><a class="mark" href="#dns_resolver_options" id="dns_resolver_options">#</a></span></h3>
+<h4><code>Resolver([options])</code><span><a class="mark" href="#dns_resolver_options" id="dns_resolver_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.18.3</td>
+<tr><td>v14.18.0</td>
+<td><p>The <code>options</code> object now accepts a <code>tries</code> option.</p></td></tr>
+<tr><td>v14.5.0</td>
 <td><p>The constructor now accepts an <code>options</code> object. The single supported option is <code>timeout</code>.</p></td></tr>
 <tr><td>v8.3.0</td>
 <td><p><span>Added in: v8.3.0</span></p></td></tr>
@@ -283,16 +304,36 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>, <span class="h
 <ul>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Query timeout in milliseconds, or <code>-1</code> to use the
 default timeout.</li>
+<li><code>tries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of tries the resolver will try contacting
+each name server before giving up. <strong>Default:</strong> <code>4</code></li>
 </ul>
 </li>
 </ul>
-<h3><code>resolver.cancel()</code><span><a class="mark" href="#dns_resolver_cancel" id="dns_resolver_cancel">#</a></span></h3>
+<h4><code>resolver.cancel()</code><span><a class="mark" href="#dns_resolver_cancel" id="dns_resolver_cancel">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
 <p>Cancel all outstanding DNS queries made by this resolver. The corresponding
 callbacks will be called with an error with code <code>ECANCELLED</code>.</p>
-<h2><code>dns.getServers()</code><span><a class="mark" href="#dns_dns_getservers" id="dns_dns_getservers">#</a></span></h2>
+<h4><code>resolver.setLocalAddress([ipv4][, ipv6])</code><span><a class="mark" href="#dns_resolver_setlocaladdress_ipv4_ipv6" id="dns_resolver_setlocaladdress_ipv4_ipv6">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>ipv4</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A string representation of an IPv4 address.
+<strong>Default:</strong> <code>'0.0.0.0'</code></li>
+<li><code>ipv6</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A string representation of an IPv6 address.
+<strong>Default:</strong> <code>'::0'</code></li>
+</ul>
+<p>The resolver instance will send its requests from the specified IP address.
+This allows programs to specify outbound interfaces when used on multi-homed
+systems.</p>
+<p>If a v4 or v6 address is not specified, it is set to the default, and the
+operating system will choose a local address automatically.</p>
+<p>The resolver will use the v4 local address when making requests to IPv4 DNS
+servers, and the v6 local address when making requests to IPv6 DNS servers.
+The <code>rrtype</code> of resolution requests has no impact on the local address used.</p>
+</section><section><h3><code>dns.getServers()</code><span><a class="mark" href="#dns_dns_getservers" id="dns_dns_getservers">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -307,9 +348,9 @@ section if a custom port is used.</p>
   <span class="hljs-string">'4.4.4.4'</span>,
   <span class="hljs-string">'2001:4860:4860::8888'</span>,
   <span class="hljs-string">'4.4.4.4:1053'</span>,
-  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>
+  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>,
 ]</code></pre>
-<h2><code>dns.lookup(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_lookup_hostname_options_callback" id="dns_dns_lookup_hostname_options_callback">#</a></span></h2>
+</section><section><h3><code>dns.lookup(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_lookup_hostname_options_callback" id="dns_dns_lookup_hostname_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -338,8 +379,9 @@ an array. Otherwise, returns a single address. <strong>Default:</strong> <code>f
 addresses in the order the DNS resolver returned them. When <code>false</code>,
 IPv4 addresses are placed before IPv6 addresses.
 <strong>Default:</strong> currently <code>false</code> (addresses are reordered) but this is
-expected to change in the not too distant future.
-New code should use <code>{ verbatim: true }</code>.</li>
+expected to change in the not too distant future. Default value is
+configurable using <a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> or
+<a href="cli.html#cli_dns_result_order_order"><code>--dns-result-order</code></a>. New code should use <code>{ verbatim: true }</code>.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -373,26 +415,26 @@ time to consult the <a href="#dns_implementation_considerations">Implementation
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">family</span>: <span class="hljs-number">6</span>,
-  <span class="hljs-attr">hints</span>: dns.ADDRCONFIG | dns.V4MAPPED,
+  <span class="hljs-attr">hints</span>: dns.<span class="hljs-property">ADDRCONFIG</span> | dns.<span class="hljs-property">V4MAPPED</span>,
 };
-dns.lookup(<span class="hljs-string">'example.com'</span>, options, <span class="hljs-function">(<span class="hljs-params">err, address, family</span>) =></span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'address: %j family: IPv%s'</span>, address, family));
+dns.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.com'</span>, options, <span class="hljs-function">(<span class="hljs-params">err, address, family</span>) =></span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'address: %j family: IPv%s'</span>, address, family));
 <span class="hljs-comment">// address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6</span>
 
 <span class="hljs-comment">// When options.all is true, the result will be an Array.</span>
-options.all = <span class="hljs-literal">true</span>;
-dns.lookup(<span class="hljs-string">'example.com'</span>, options, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'addresses: %j'</span>, addresses));
+options.<span class="hljs-property">all</span> = <span class="hljs-literal">true</span>;
+dns.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.com'</span>, options, <span class="hljs-function">(<span class="hljs-params">err, addresses</span>) =></span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'addresses: %j'</span>, addresses));
 <span class="hljs-comment">// addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]</span></code></pre>
 <p>If this method is invoked as its <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed version, and <code>all</code>
 is not set to <code>true</code>, it returns a <code>Promise</code> for an <code>Object</code> with <code>address</code> and
 <code>family</code> properties.</p>
-<h3>Supported getaddrinfo flags<span><a class="mark" href="#dns_supported_getaddrinfo_flags" id="dns_supported_getaddrinfo_flags">#</a></span></h3>
+<h4>Supported getaddrinfo flags<span><a class="mark" href="#dns_supported_getaddrinfo_flags" id="dns_supported_getaddrinfo_flags">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.0.0</td>
 <td><p>Added support for the <code>dns.ALL</code> flag.</p></td></tr>
 </tbody></table>
 </details>
@@ -408,7 +450,7 @@ on some operating systems (e.g FreeBSD 10.1).</li>
 <li><code>dns.ALL</code>: If <code>dns.V4MAPPED</code> is specified, return resolved IPv6 addresses as
 well as IPv4 mapped IPv6 addresses.</li>
 </ul>
-<h2><code>dns.lookupService(address, port, callback)</code><span><a class="mark" href="#dns_dns_lookupservice_address_port_callback" id="dns_dns_lookupservice_address_port_callback">#</a></span></h2>
+</section><section><h3><code>dns.lookupService(address, port, callback)</code><span><a class="mark" href="#dns_dns_lookupservice_address_port_callback" id="dns_dns_lookupservice_address_port_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -430,13 +472,13 @@ The <code>port</code> will be coerced to a number. If it is not a legal port, a
 will be thrown.</p>
 <p>On an error, <code>err</code> is an <a href="errors.html#errors_class_error"><code>Error</code></a> object, where <code>err.code</code> is the error code.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
-dns.lookupService(<span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-number">22</span>, <span class="hljs-function">(<span class="hljs-params">err, hostname, service</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(hostname, service);
+dns.<span class="hljs-title function_">lookupService</span>(<span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-number">22</span>, <span class="hljs-function">(<span class="hljs-params">err, hostname, service</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(hostname, service);
   <span class="hljs-comment">// Prints: localhost ssh</span>
 });</code></pre>
 <p>If this method is invoked as its <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns a
 <code>Promise</code> for an <code>Object</code> with <code>hostname</code> and <code>service</code> properties.</p>
-<h2><code>dns.resolve(hostname[, rrtype], callback)</code><span><a class="mark" href="#dns_dns_resolve_hostname_rrtype_callback" id="dns_dns_resolve_hostname_rrtype_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolve(hostname[, rrtype], callback)</code><span><a class="mark" href="#dns_dns_resolve_hostname_rrtype_callback" id="dns_dns_resolve_hostname_rrtype_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -531,10 +573,16 @@ records. The type and structure of individual results varies based on <code>rrty
 
 
 
-<table><thead><tr><th><code>rrtype</code></th><th><code>records</code> contains</th><th>Result type</th><th>Shorthand method</th></tr></thead><tbody><tr><td><code>'A'</code></td><td>IPv4 addresses (default)</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolve4_hostname_options_callback"><code>dns.resolve4()</code></a></td></tr><tr><td><code>'AAAA'</code></td><td>IPv6 addresses</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolve6_hostname_options_callback"><code>dns.resolve6()</code></a></td></tr><tr><td><code>'ANY'</code></td><td>any records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolveany_hostname_callback"><code>dns.resolveAny()</code></a></td></tr><tr><td><code>'CNAME'</code></td><td>canonical name records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolvecname_hostname_callback"><code>dns.resolveCname()</code></a></td></tr><tr><td><code>'MX'</code></td><td>mail exchange records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvemx_hostname_callback"><code>dns.resolveMx()</code></a></td></tr><tr><td><code>'NAPTR'</code></td><td>name authority pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvenaptr_hostname_callback"><code>dns.resolveNaptr()</code></a></td></tr><tr><td><code>'NS'</code></td><td>name server records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolvens_hostname_callback"><code>dns.resolveNs()</code></a></td></tr><tr><td><code>'PTR'</code></td><td>pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolveptr_hostname_callback"><code>dns.resolvePtr()</code></a></td></tr><tr><td><code>'SOA'</code></td><td>start of authority records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvesoa_hostname_callback"><code>dns.resolveSoa()</code></a></td></tr><tr><td><code>'SRV'</code></td><td>service records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvesrv_hostname_callback"><code>dns.resolveSrv()</code></a></td></tr><tr><td><code>'TXT'</code></td><td>text records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></td><td><a href="#dns_dns_resolvetxt_hostname_callback"><code>dns.resolveTxt()</code></a></td></tr></tbody></table>
+
+
+
+
+
+
+<table><thead><tr><th><code>rrtype</code></th><th><code>records</code> contains</th><th>Result type</th><th>Shorthand method</th></tr></thead><tbody><tr><td><code>'A'</code></td><td>IPv4 addresses (default)</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolve4_hostname_options_callback"><code>dns.resolve4()</code></a></td></tr><tr><td><code>'AAAA'</code></td><td>IPv6 addresses</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolve6_hostname_options_callback"><code>dns.resolve6()</code></a></td></tr><tr><td><code>'ANY'</code></td><td>any records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolveany_hostname_callback"><code>dns.resolveAny()</code></a></td></tr><tr><td><code>'CAA'</code></td><td>CA authorization records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvecaa_hostname_callback"><code>dns.resolveCaa()</code></a></td></tr><tr><td><code>'CNAME'</code></td><td>canonical name records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolvecname_hostname_callback"><code>dns.resolveCname()</code></a></td></tr><tr><td><code>'MX'</code></td><td>mail exchange records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvemx_hostname_callback"><code>dns.resolveMx()</code></a></td></tr><tr><td><code>'NAPTR'</code></td><td>name authority pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvenaptr_hostname_callback"><code>dns.resolveNaptr()</code></a></td></tr><tr><td><code>'NS'</code></td><td>name server records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolvens_hostname_callback"><code>dns.resolveNs()</code></a></td></tr><tr><td><code>'PTR'</code></td><td>pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dns_resolveptr_hostname_callback"><code>dns.resolvePtr()</code></a></td></tr><tr><td><code>'SOA'</code></td><td>start of authority records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvesoa_hostname_callback"><code>dns.resolveSoa()</code></a></td></tr><tr><td><code>'SRV'</code></td><td>service records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dns_resolvesrv_hostname_callback"><code>dns.resolveSrv()</code></a></td></tr><tr><td><code>'TXT'</code></td><td>text records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></td><td><a href="#dns_dns_resolvetxt_hostname_callback"><code>dns.resolveTxt()</code></a></td></tr></tbody></table>
 <p>On error, <code>err</code> is an <a href="errors.html#errors_class_error"><code>Error</code></a> object, where <code>err.code</code> is one of the
 <a href="#dns_error_codes">DNS error codes</a>.</p>
-<h2><code>dns.resolve4(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_resolve4_hostname_options_callback" id="dns_dns_resolve4_hostname_options_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolve4(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_resolve4_hostname_options_callback" id="dns_dns_resolve4_hostname_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -567,7 +615,7 @@ with the TTL expressed in seconds.</li>
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function
 will contain an array of IPv4 addresses (e.g.
 <code>['74.125.79.104', '74.125.79.105', '74.125.79.106']</code>).</p>
-<h2><code>dns.resolve6(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_resolve6_hostname_options_callback" id="dns_dns_resolve6_hostname_options_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolve6(hostname[, options], callback)</code><span><a class="mark" href="#dns_dns_resolve6_hostname_options_callback" id="dns_dns_resolve6_hostname_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -599,7 +647,7 @@ strings, with the TTL expressed in seconds.</li>
 <p>Uses the DNS protocol to resolve a IPv6 addresses (<code>AAAA</code> records) for the
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function
 will contain an array of IPv6 addresses.</p>
-<h2><code>dns.resolveAny(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolveany_hostname_callback" id="dns_dns_resolveany_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveAny(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolveany_hostname_callback" id="dns_dns_resolveany_hostname_callback">#</a></span></h3>
 <ul>
 <li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -682,7 +730,7 @@ will be present on the object:</p>
 <p>DNS server operators may choose not to respond to <code>ANY</code>
 queries. It may be better to call individual methods like <a href="#dns_dns_resolve4_hostname_options_callback"><code>dns.resolve4()</code></a>,
 <a href="#dns_dns_resolvemx_hostname_callback"><code>dns.resolveMx()</code></a>, and so on. For more details, see <a href="https://tools.ietf.org/html/rfc8482">RFC 8482</a>.</p>
-<h2><code>dns.resolveCname(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvecname_hostname_callback" id="dns_dns_resolvecname_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveCname(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvecname_hostname_callback" id="dns_dns_resolvecname_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -699,7 +747,24 @@ queries. It may be better to call individual methods like <a href="#dns_dns_reso
 <code>addresses</code> argument passed to the <code>callback</code> function
 will contain an array of canonical name records available for the <code>hostname</code>
 (e.g. <code>['bar.example.com']</code>).</p>
-<h2><code>dns.resolveMx(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvemx_hostname_callback" id="dns_dns_resolvemx_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveCaa(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvecaa_hostname_callback" id="dns_dns_resolvecaa_hostname_callback">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>records</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object[]></a></li>
+</ul>
+</li>
+</ul>
+<p>Uses the DNS protocol to resolve <code>CAA</code> records for the <code>hostname</code>. The
+<code>addresses</code> argument passed to the <code>callback</code> function
+will contain an array of certification authority authorization records
+available for the <code>hostname</code> (e.g. <code>[{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]</code>).</p>
+</section><section><h3><code>dns.resolveMx(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvemx_hostname_callback" id="dns_dns_resolvemx_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -716,7 +781,7 @@ will contain an array of canonical name records available for the <code>hostname
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will
 contain an array of objects containing both a <code>priority</code> and <code>exchange</code>
 property (e.g. <code>[{priority: 10, exchange: 'mx.example.com'}, ...]</code>).</p>
-<h2><code>dns.resolveNaptr(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvenaptr_hostname_callback" id="dns_dns_resolvenaptr_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveNaptr(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvenaptr_hostname_callback" id="dns_dns_resolvenaptr_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.12</span>
 </div>
@@ -749,7 +814,7 @@ function will contain an array of objects with the following properties:</p>
   <span class="hljs-attr">order</span>: <span class="hljs-number">30</span>,
   <span class="hljs-attr">preference</span>: <span class="hljs-number">100</span>
 }</code></pre>
-<h2><code>dns.resolveNs(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvens_hostname_callback" id="dns_dns_resolvens_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveNs(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvens_hostname_callback" id="dns_dns_resolvens_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -766,7 +831,7 @@ function will contain an array of objects with the following properties:</p>
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will
 contain an array of name server records available for <code>hostname</code>
 (e.g. <code>['ns1.example.com', 'ns2.example.com']</code>).</p>
-<h2><code>dns.resolvePtr(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolveptr_hostname_callback" id="dns_dns_resolveptr_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolvePtr(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolveptr_hostname_callback" id="dns_dns_resolveptr_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -782,7 +847,7 @@ contain an array of name server records available for <code>hostname</code>
 <p>Uses the DNS protocol to resolve pointer records (<code>PTR</code> records) for the
 <code>hostname</code>. The <code>addresses</code> argument passed to the <code>callback</code> function will
 be an array of strings containing the reply records.</p>
-<h2><code>dns.resolveSoa(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvesoa_hostname_callback" id="dns_dns_resolvesoa_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveSoa(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvesoa_hostname_callback" id="dns_dns_resolvesoa_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.10</span>
 </div>
@@ -817,7 +882,7 @@ be an object with the following properties:</p>
   <span class="hljs-attr">expire</span>: <span class="hljs-number">604800</span>,
   <span class="hljs-attr">minttl</span>: <span class="hljs-number">3600</span>
 }</code></pre>
-<h2><code>dns.resolveSrv(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvesrv_hostname_callback" id="dns_dns_resolvesrv_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveSrv(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvesrv_hostname_callback" id="dns_dns_resolvesrv_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -846,10 +911,11 @@ be an array of objects with the following properties:</p>
   <span class="hljs-attr">port</span>: <span class="hljs-number">21223</span>,
   <span class="hljs-attr">name</span>: <span class="hljs-string">'service.example.com'</span>
 }</code></pre>
-<h2><code>dns.resolveTxt(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvetxt_hostname_callback" id="dns_dns_resolvetxt_hostname_callback">#</a></span></h2>
+</section><section><h3><code>dns.resolveTxt(hostname, callback)</code><span><a class="mark" href="#dns_dns_resolvetxt_hostname_callback" id="dns_dns_resolvetxt_hostname_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
+<!--lint disable no-undefined-references list-item-bullet-indent-->
 <ul>
 <li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -859,13 +925,14 @@ be an array of objects with the following properties:</p>
 </ul>
 </li>
 </ul>
+<!--lint enable no-undefined-references list-item-bullet-indent-->
 <p>Uses the DNS protocol to resolve text queries (<code>TXT</code> records) for the
 <code>hostname</code>. The <code>records</code> argument passed to the <code>callback</code> function is a
 two-dimensional array of the text records available for <code>hostname</code> (e.g.
 <code>[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]</code>). Each sub-array contains TXT chunks of
 one record. Depending on the use case, these could be either joined together or
 treated separately.</p>
-<h2><code>dns.reverse(ip, callback)</code><span><a class="mark" href="#dns_dns_reverse_ip_callback" id="dns_dns_reverse_ip_callback">#</a></span></h2>
+</section><section><h3><code>dns.reverse(ip, callback)</code><span><a class="mark" href="#dns_dns_reverse_ip_callback" id="dns_dns_reverse_ip_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -882,7 +949,24 @@ treated separately.</p>
 array of host names.</p>
 <p>On error, <code>err</code> is an <a href="errors.html#errors_class_error"><code>Error</code></a> object, where <code>err.code</code> is
 one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
-<h2><code>dns.setServers(servers)</code><span><a class="mark" href="#dns_dns_setservers_servers" id="dns_dns_setservers_servers">#</a></span></h2>
+</section><section><h3><code>dns.setDefaultResultOrder(order)</code><span><a class="mark" href="#dns_dns_setdefaultresultorder_order" id="dns_dns_setdefaultresultorder_order">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>order</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> must be <code>'ipv4first'</code> or <code>'verbatim'</code>.</li>
+</ul>
+<p>Set the default value of <code>verbatim</code> in <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> and
+<a href="#dns_dnspromises_lookup_hostname_options"><code>dnsPromises.lookup()</code></a>. The value could be:</p>
+<ul>
+<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>
+<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>
+</ul>
+<p>The default is <code>ipv4first</code> and <a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> have higher
+priority than <a href="cli.html#cli_dns_result_order_order"><code>--dns-result-order</code></a>. When using <a href="worker_threads.html">worker threads</a>,
+<a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> from the main thread won't affect the default
+dns orders in workers.</p>
+</section><section><h3><code>dns.setServers(servers)</code><span><a class="mark" href="#dns_dns_setservers_servers" id="dns_dns_setservers_servers">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -892,11 +976,11 @@ one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
 <p>Sets the IP address and port of servers to be used when performing DNS
 resolution. The <code>servers</code> argument is an array of <a href="https://tools.ietf.org/html/rfc5952#section-6">RFC 5952</a> formatted
 addresses. If the port is the IANA default DNS port (53) it can be omitted.</p>
-<pre><code class="language-js">dns.setServers([
+<pre><code class="language-js">dns.<span class="hljs-title function_">setServers</span>([
   <span class="hljs-string">'4.4.4.4'</span>,
   <span class="hljs-string">'[2001:4860:4860::8888]'</span>,
   <span class="hljs-string">'4.4.4.4:1053'</span>,
-  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>
+  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>,
 ]);</code></pre>
 <p>An error will be thrown if an invalid address is provided.</p>
 <p>The <code>dns.setServers()</code> method must not be called while a DNS query is in
@@ -910,11 +994,22 @@ That is, if attempting to resolve with the first server provided results in a
 <code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with
 subsequent servers provided. Fallback DNS servers will only be used if the
 earlier ones time out or result in some other error.</p>
-<h2>DNS promises API<span><a class="mark" href="#dns_dns_promises_api" id="dns_dns_promises_api">#</a></span></h2>
+</section><section><h3>DNS promises API<span><a class="mark" href="#dns_dns_promises_api" id="dns_dns_promises_api">#</a></span></h3>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v11.14.0, v10.17.0</td>
+<td><p>This API is no longer experimental.</p></td></tr>
+<tr><td>v10.6.0</td>
+<td><p><span>Added in: v10.6.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
 <p>The <code>dns.promises</code> API provides an alternative set of asynchronous DNS methods
 that return <code>Promise</code> objects rather than using callbacks. The API is accessible
 via <code>require('dns').promises</code>.</p>
-<h3>Class: <code>dnsPromises.Resolver</code><span><a class="mark" href="#dns_class_dnspromises_resolver" id="dns_class_dnspromises_resolver">#</a></span></h3>
+<h4>Class: <code>dnsPromises.Resolver</code><span><a class="mark" href="#dns_class_dnspromises_resolver" id="dns_class_dnspromises_resolver">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -923,18 +1018,18 @@ via <code>require('dns').promises</code>.</p>
 the servers used for a resolver using
 <a href="#dns_dnspromises_setservers_servers"><code>resolver.setServers()</code></a> does not affect
 other resolvers:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Resolver } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>).promises;
-<span class="hljs-keyword">const</span> resolver = <span class="hljs-keyword">new</span> Resolver();
-resolver.setServers([<span class="hljs-string">'4.4.4.4'</span>]);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Resolver</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>).<span class="hljs-property">promises</span>;
+<span class="hljs-keyword">const</span> resolver = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Resolver</span>();
+resolver.<span class="hljs-title function_">setServers</span>([<span class="hljs-string">'4.4.4.4'</span>]);
 
 <span class="hljs-comment">// This request will use the server at 4.4.4.4, independent of global settings.</span>
-resolver.resolve4(<span class="hljs-string">'example.org'</span>).then(<span class="hljs-function">(<span class="hljs-params">addresses</span>) =></span> {
+resolver.<span class="hljs-title function_">resolve4</span>(<span class="hljs-string">'example.org'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">addresses</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });
 
 <span class="hljs-comment">// Alternatively, the same code can be written using async-await style.</span>
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> addresses = <span class="hljs-keyword">await</span> resolver.resolve4(<span class="hljs-string">'example.org'</span>);
+(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> addresses = <span class="hljs-keyword">await</span> resolver.<span class="hljs-title function_">resolve4</span>(<span class="hljs-string">'example.org'</span>);
 })();</code></pre>
 <p>The following methods from the <code>dnsPromises</code> API are available:</p>
 <ul>
@@ -943,6 +1038,7 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>).then(<span cla
 <li><a href="#dns_dnspromises_resolve4_hostname_options"><code>resolver.resolve4()</code></a></li>
 <li><a href="#dns_dnspromises_resolve6_hostname_options"><code>resolver.resolve6()</code></a></li>
 <li><a href="#dns_dnspromises_resolveany_hostname"><code>resolver.resolveAny()</code></a></li>
+<li><a href="#dns_dnspromises_resolvecaa_hostname"><code>resolver.resolveCaa()</code></a></li>
 <li><a href="#dns_dnspromises_resolvecname_hostname"><code>resolver.resolveCname()</code></a></li>
 <li><a href="#dns_dnspromises_resolvemx_hostname"><code>resolver.resolveMx()</code></a></li>
 <li><a href="#dns_dnspromises_resolvenaptr_hostname"><code>resolver.resolveNaptr()</code></a></li>
@@ -954,7 +1050,13 @@ resolver.resolve4(<span class="hljs-string">'example.org'</span>).then(<span cla
 <li><a href="#dns_dnspromises_reverse_ip"><code>resolver.reverse()</code></a></li>
 <li><a href="#dns_dnspromises_setservers_servers"><code>resolver.setServers()</code></a></li>
 </ul>
-<h3><code>dnsPromises.getServers()</code><span><a class="mark" href="#dns_dnspromises_getservers" id="dns_dnspromises_getservers">#</a></span></h3>
+<h4><code>resolver.cancel()</code><span><a class="mark" href="#dns_resolver_cancel_1" id="dns_resolver_cancel_1">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>Cancel all outstanding DNS queries made by this resolver. The corresponding
+promises will be rejected with an error with code <code>ECANCELLED</code>.</p>
+<h4><code>dnsPromises.getServers()</code><span><a class="mark" href="#dns_dnspromises_getservers" id="dns_dnspromises_getservers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -969,9 +1071,9 @@ section if a custom port is used.</p>
   <span class="hljs-string">'4.4.4.4'</span>,
   <span class="hljs-string">'2001:4860:4860::8888'</span>,
   <span class="hljs-string">'4.4.4.4:1053'</span>,
-  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>
+  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>,
 ]</code></pre>
-<h3><code>dnsPromises.lookup(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_lookup_hostname_options" id="dns_dnspromises_lookup_hostname_options">#</a></span></h3>
+<h4><code>dnsPromises.lookup(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_lookup_hostname_options" id="dns_dnspromises_lookup_hostname_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -990,8 +1092,9 @@ an array. Otherwise, returns a single address. <strong>Default:</strong> <code>f
 IPv6 addresses in the order the DNS resolver returned them. When <code>false</code>,
 IPv4 addresses are placed before IPv6 addresses.
 <strong>Default:</strong> currently <code>false</code> (addresses are reordered) but this is
-expected to change in the not too distant future.
-New code should use <code>{ verbatim: true }</code>.</li>
+expected to change in the not too distant future. Default value is
+configurable using <a href="#dns_dns_setdefaultresultorder_order"><code>dns.setDefaultResultOrder()</code></a> or
+<a href="cli.html#cli_dns_result_order_order"><code>--dns-result-order</code></a>. New code should use <code>{ verbatim: true }</code>.</li>
 </ul>
 </li>
 </ul>
@@ -1014,24 +1117,24 @@ take some time to consult the <a href="#dns_implementation_considerations">Imple
 using <code>dnsPromises.lookup()</code>.</p>
 <p>Example usage:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> dns = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>);
-<span class="hljs-keyword">const</span> dnsPromises = dns.promises;
+<span class="hljs-keyword">const</span> dnsPromises = dns.<span class="hljs-property">promises</span>;
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">family</span>: <span class="hljs-number">6</span>,
-  <span class="hljs-attr">hints</span>: dns.ADDRCONFIG | dns.V4MAPPED,
+  <span class="hljs-attr">hints</span>: dns.<span class="hljs-property">ADDRCONFIG</span> | dns.<span class="hljs-property">V4MAPPED</span>,
 };
 
-dnsPromises.lookup(<span class="hljs-string">'example.com'</span>, options).then(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'address: %j family: IPv%s'</span>, result.address, result.family);
+dnsPromises.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.com'</span>, options).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'address: %j family: IPv%s'</span>, result.<span class="hljs-property">address</span>, result.<span class="hljs-property">family</span>);
   <span class="hljs-comment">// address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6</span>
 });
 
 <span class="hljs-comment">// When options.all is true, the result will be an Array.</span>
-options.all = <span class="hljs-literal">true</span>;
-dnsPromises.lookup(<span class="hljs-string">'example.com'</span>, options).then(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'addresses: %j'</span>, result);
+options.<span class="hljs-property">all</span> = <span class="hljs-literal">true</span>;
+dnsPromises.<span class="hljs-title function_">lookup</span>(<span class="hljs-string">'example.com'</span>, options).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'addresses: %j'</span>, result);
   <span class="hljs-comment">// addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]</span>
 });</code></pre>
-<h3><code>dnsPromises.lookupService(address, port)</code><span><a class="mark" href="#dns_dnspromises_lookupservice_address_port" id="dns_dnspromises_lookupservice_address_port">#</a></span></h3>
+<h4><code>dnsPromises.lookupService(address, port)</code><span><a class="mark" href="#dns_dnspromises_lookupservice_address_port" id="dns_dnspromises_lookupservice_address_port">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1046,12 +1149,12 @@ The <code>port</code> will be coerced to a number. If it is not a legal port, a
 will be thrown.</p>
 <p>On error, the <code>Promise</code> is rejected with an <a href="errors.html#errors_class_error"><code>Error</code></a> object, where <code>err.code</code>
 is the error code.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> dnsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>).promises;
-dnsPromises.lookupService(<span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-number">22</span>).then(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(result.hostname, result.service);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> dnsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'dns'</span>).<span class="hljs-property">promises</span>;
+dnsPromises.<span class="hljs-title function_">lookupService</span>(<span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-number">22</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result.<span class="hljs-property">hostname</span>, result.<span class="hljs-property">service</span>);
   <span class="hljs-comment">// Prints: localhost ssh</span>
 });</code></pre>
-<h3><code>dnsPromises.resolve(hostname[, rrtype])</code><span><a class="mark" href="#dns_dnspromises_resolve_hostname_rrtype" id="dns_dnspromises_resolve_hostname_rrtype">#</a></span></h3>
+<h4><code>dnsPromises.resolve(hostname[, rrtype])</code><span><a class="mark" href="#dns_dnspromises_resolve_hostname_rrtype" id="dns_dnspromises_resolve_hostname_rrtype">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1140,10 +1243,16 @@ based on <code>rrtype</code>:</p>
 
 
 
-<table><thead><tr><th><code>rrtype</code></th><th><code>records</code> contains</th><th>Result type</th><th>Shorthand method</th></tr></thead><tbody><tr><td><code>'A'</code></td><td>IPv4 addresses (default)</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolve4_hostname_options"><code>dnsPromises.resolve4()</code></a></td></tr><tr><td><code>'AAAA'</code></td><td>IPv6 addresses</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolve6_hostname_options"><code>dnsPromises.resolve6()</code></a></td></tr><tr><td><code>'ANY'</code></td><td>any records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolveany_hostname"><code>dnsPromises.resolveAny()</code></a></td></tr><tr><td><code>'CNAME'</code></td><td>canonical name records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolvecname_hostname"><code>dnsPromises.resolveCname()</code></a></td></tr><tr><td><code>'MX'</code></td><td>mail exchange records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvemx_hostname"><code>dnsPromises.resolveMx()</code></a></td></tr><tr><td><code>'NAPTR'</code></td><td>name authority pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvenaptr_hostname"><code>dnsPromises.resolveNaptr()</code></a></td></tr><tr><td><code>'NS'</code></td><td>name server records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolvens_hostname"><code>dnsPromises.resolveNs()</code></a></td></tr><tr><td><code>'PTR'</code></td><td>pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolveptr_hostname"><code>dnsPromises.resolvePtr()</code></a></td></tr><tr><td><code>'SOA'</code></td><td>start of authority records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvesoa_hostname"><code>dnsPromises.resolveSoa()</code></a></td></tr><tr><td><code>'SRV'</code></td><td>service records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvesrv_hostname"><code>dnsPromises.resolveSrv()</code></a></td></tr><tr><td><code>'TXT'</code></td><td>text records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></td><td><a href="#dns_dnspromises_resolvetxt_hostname"><code>dnsPromises.resolveTxt()</code></a></td></tr></tbody></table>
+
+
+
+
+
+
+<table><thead><tr><th><code>rrtype</code></th><th><code>records</code> contains</th><th>Result type</th><th>Shorthand method</th></tr></thead><tbody><tr><td><code>'A'</code></td><td>IPv4 addresses (default)</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolve4_hostname_options"><code>dnsPromises.resolve4()</code></a></td></tr><tr><td><code>'AAAA'</code></td><td>IPv6 addresses</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolve6_hostname_options"><code>dnsPromises.resolve6()</code></a></td></tr><tr><td><code>'ANY'</code></td><td>any records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolveany_hostname"><code>dnsPromises.resolveAny()</code></a></td></tr><tr><td><code>'CAA'</code></td><td>CA authorization records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvecaa_hostname"><code>dnsPromises.resolveCaa()</code></a></td></tr><tr><td><code>'CNAME'</code></td><td>canonical name records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolvecname_hostname"><code>dnsPromises.resolveCname()</code></a></td></tr><tr><td><code>'MX'</code></td><td>mail exchange records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvemx_hostname"><code>dnsPromises.resolveMx()</code></a></td></tr><tr><td><code>'NAPTR'</code></td><td>name authority pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvenaptr_hostname"><code>dnsPromises.resolveNaptr()</code></a></td></tr><tr><td><code>'NS'</code></td><td>name server records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolvens_hostname"><code>dnsPromises.resolveNs()</code></a></td></tr><tr><td><code>'PTR'</code></td><td>pointer records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></td><td><a href="#dns_dnspromises_resolveptr_hostname"><code>dnsPromises.resolvePtr()</code></a></td></tr><tr><td><code>'SOA'</code></td><td>start of authority records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvesoa_hostname"><code>dnsPromises.resolveSoa()</code></a></td></tr><tr><td><code>'SRV'</code></td><td>service records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></td><td><a href="#dns_dnspromises_resolvesrv_hostname"><code>dnsPromises.resolveSrv()</code></a></td></tr><tr><td><code>'TXT'</code></td><td>text records</td><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></td><td><a href="#dns_dnspromises_resolvetxt_hostname"><code>dnsPromises.resolveTxt()</code></a></td></tr></tbody></table>
 <p>On error, the <code>Promise</code> is rejected with an <a href="errors.html#errors_class_error"><code>Error</code></a> object, where <code>err.code</code>
 is one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
-<h3><code>dnsPromises.resolve4(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_resolve4_hostname_options" id="dns_dnspromises_resolve4_hostname_options">#</a></span></h3>
+<h4><code>dnsPromises.resolve4(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_resolve4_hostname_options" id="dns_dnspromises_resolve4_hostname_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1161,7 +1270,7 @@ with the TTL expressed in seconds.</li>
 <p>Uses the DNS protocol to resolve IPv4 addresses (<code>A</code> records) for the
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of IPv4
 addresses (e.g. <code>['74.125.79.104', '74.125.79.105', '74.125.79.106']</code>).</p>
-<h3><code>dnsPromises.resolve6(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_resolve6_hostname_options" id="dns_dnspromises_resolve6_hostname_options">#</a></span></h3>
+<h4><code>dnsPromises.resolve6(hostname[, options])</code><span><a class="mark" href="#dns_dnspromises_resolve6_hostname_options" id="dns_dnspromises_resolve6_hostname_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1179,7 +1288,7 @@ strings, with the TTL expressed in seconds.</li>
 <p>Uses the DNS protocol to resolve IPv6 addresses (<code>AAAA</code> records) for the
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of IPv6
 addresses.</p>
-<h3><code>dnsPromises.resolveAny(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolveany_hostname" id="dns_dnspromises_resolveany_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveAny(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolveany_hostname" id="dns_dnspromises_resolveany_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1256,7 +1365,18 @@ present on the object:</p>
     <span class="hljs-attr">retry</span>: <span class="hljs-number">900</span>,
     <span class="hljs-attr">expire</span>: <span class="hljs-number">1800</span>,
     <span class="hljs-attr">minttl</span>: <span class="hljs-number">60</span> } ]</code></pre>
-<h3><code>dnsPromises.resolveCname(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvecname_hostname" id="dns_dnspromises_resolvecname_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveCaa(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvecaa_hostname" id="dns_dnspromises_resolvecaa_hostname">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Uses the DNS protocol to resolve <code>CAA</code> records for the <code>hostname</code>. On success,
+the <code>Promise</code> is resolved with an array of objects containing available
+certification authority authorization records available for the <code>hostname</code>
+(e.g. <code>[{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue: 'pki.example.com'}]</code>).</p>
+<h4><code>dnsPromises.resolveCname(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvecname_hostname" id="dns_dnspromises_resolvecname_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1266,7 +1386,7 @@ present on the object:</p>
 <p>Uses the DNS protocol to resolve <code>CNAME</code> records for the <code>hostname</code>. On success,
 the <code>Promise</code> is resolved with an array of canonical name records available for
 the <code>hostname</code> (e.g. <code>['bar.example.com']</code>).</p>
-<h3><code>dnsPromises.resolveMx(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvemx_hostname" id="dns_dnspromises_resolvemx_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveMx(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvemx_hostname" id="dns_dnspromises_resolvemx_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1277,7 +1397,7 @@ the <code>hostname</code> (e.g. <code>['bar.example.com']</code>).</p>
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of objects
 containing both a <code>priority</code> and <code>exchange</code> property (e.g.
 <code>[{priority: 10, exchange: 'mx.example.com'}, ...]</code>).</p>
-<h3><code>dnsPromises.resolveNaptr(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvenaptr_hostname" id="dns_dnspromises_resolvenaptr_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveNaptr(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvenaptr_hostname" id="dns_dnspromises_resolvenaptr_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1304,7 +1424,7 @@ of objects with the following properties:</p>
   <span class="hljs-attr">order</span>: <span class="hljs-number">30</span>,
   <span class="hljs-attr">preference</span>: <span class="hljs-number">100</span>
 }</code></pre>
-<h3><code>dnsPromises.resolveNs(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvens_hostname" id="dns_dnspromises_resolvens_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveNs(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvens_hostname" id="dns_dnspromises_resolvens_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1315,7 +1435,7 @@ of objects with the following properties:</p>
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of name server
 records available for <code>hostname</code> (e.g.
 <code>['ns1.example.com', 'ns2.example.com']</code>).</p>
-<h3><code>dnsPromises.resolvePtr(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolveptr_hostname" id="dns_dnspromises_resolveptr_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolvePtr(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolveptr_hostname" id="dns_dnspromises_resolveptr_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1325,7 +1445,7 @@ records available for <code>hostname</code> (e.g.
 <p>Uses the DNS protocol to resolve pointer records (<code>PTR</code> records) for the
 <code>hostname</code>. On success, the <code>Promise</code> is resolved with an array of strings
 containing the reply records.</p>
-<h3><code>dnsPromises.resolveSoa(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvesoa_hostname" id="dns_dnspromises_resolvesoa_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveSoa(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvesoa_hostname" id="dns_dnspromises_resolvesoa_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1354,7 +1474,7 @@ following properties:</p>
   <span class="hljs-attr">expire</span>: <span class="hljs-number">604800</span>,
   <span class="hljs-attr">minttl</span>: <span class="hljs-number">3600</span>
 }</code></pre>
-<h3><code>dnsPromises.resolveSrv(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvesrv_hostname" id="dns_dnspromises_resolvesrv_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveSrv(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvesrv_hostname" id="dns_dnspromises_resolvesrv_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1377,7 +1497,7 @@ the following properties:</p>
   <span class="hljs-attr">port</span>: <span class="hljs-number">21223</span>,
   <span class="hljs-attr">name</span>: <span class="hljs-string">'service.example.com'</span>
 }</code></pre>
-<h3><code>dnsPromises.resolveTxt(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvetxt_hostname" id="dns_dnspromises_resolvetxt_hostname">#</a></span></h3>
+<h4><code>dnsPromises.resolveTxt(hostname)</code><span><a class="mark" href="#dns_dnspromises_resolvetxt_hostname" id="dns_dnspromises_resolvetxt_hostname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1390,7 +1510,7 @@ of the text records available for <code>hostname</code> (e.g.
 <code>[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]</code>). Each sub-array contains TXT chunks of
 one record. Depending on the use case, these could be either joined together or
 treated separately.</p>
-<h3><code>dnsPromises.reverse(ip)</code><span><a class="mark" href="#dns_dnspromises_reverse_ip" id="dns_dnspromises_reverse_ip">#</a></span></h3>
+<h4><code>dnsPromises.reverse(ip)</code><span><a class="mark" href="#dns_dnspromises_reverse_ip" id="dns_dnspromises_reverse_ip">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1401,7 +1521,24 @@ treated separately.</p>
 array of host names.</p>
 <p>On error, the <code>Promise</code> is rejected with an <a href="errors.html#errors_class_error"><code>Error</code></a> object, where <code>err.code</code>
 is one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
-<h3><code>dnsPromises.setServers(servers)</code><span><a class="mark" href="#dns_dnspromises_setservers_servers" id="dns_dnspromises_setservers_servers">#</a></span></h3>
+<h4><code>dnsPromises.setDefaultResultOrder(order)</code><span><a class="mark" href="#dns_dnspromises_setdefaultresultorder_order" id="dns_dnspromises_setdefaultresultorder_order">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>order</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> must be <code>'ipv4first'</code> or <code>'verbatim'</code>.</li>
+</ul>
+<p>Set the default value of <code>verbatim</code> in <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> and
+<a href="#dns_dnspromises_lookup_hostname_options"><code>dnsPromises.lookup()</code></a>. The value could be:</p>
+<ul>
+<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>
+<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>
+</ul>
+<p>The default is <code>ipv4first</code> and <a href="#dns_dnspromises_setdefaultresultorder_order"><code>dnsPromises.setDefaultResultOrder()</code></a> have
+higher priority than <a href="cli.html#cli_dns_result_order_order"><code>--dns-result-order</code></a>. When using <a href="worker_threads.html">worker threads</a>,
+<a href="#dns_dnspromises_setdefaultresultorder_order"><code>dnsPromises.setDefaultResultOrder()</code></a> from the main thread won't affect the
+default dns orders in workers.</p>
+<h4><code>dnsPromises.setServers(servers)</code><span><a class="mark" href="#dns_dnspromises_setservers_servers" id="dns_dnspromises_setservers_servers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
@@ -1411,11 +1548,11 @@ is one of the <a href="#dns_error_codes">DNS error codes</a>.</p>
 <p>Sets the IP address and port of servers to be used when performing DNS
 resolution. The <code>servers</code> argument is an array of <a href="https://tools.ietf.org/html/rfc5952#section-6">RFC 5952</a> formatted
 addresses. If the port is the IANA default DNS port (53) it can be omitted.</p>
-<pre><code class="language-js">dnsPromises.setServers([
+<pre><code class="language-js">dnsPromises.<span class="hljs-title function_">setServers</span>([
   <span class="hljs-string">'4.4.4.4'</span>,
   <span class="hljs-string">'[2001:4860:4860::8888]'</span>,
   <span class="hljs-string">'4.4.4.4:1053'</span>,
-  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>
+  <span class="hljs-string">'[2001:4860:4860::8888]:1053'</span>,
 ]);</code></pre>
 <p>An error will be thrown if an invalid address is provided.</p>
 <p>The <code>dnsPromises.setServers()</code> method must not be called while a DNS query is in
@@ -1426,7 +1563,7 @@ That is, if attempting to resolve with the first server provided results in a
 <code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with
 subsequent servers provided. Fallback DNS servers will only be used if the
 earlier ones time out or result in some other error.</p>
-<h2>Error codes<span><a class="mark" href="#dns_error_codes" id="dns_error_codes">#</a></span></h2>
+</section><section><h3>Error codes<span><a class="mark" href="#dns_error_codes" id="dns_error_codes">#</a></span></h3>
 <p>Each DNS query can return one of the following error codes:</p>
 <ul>
 <li><code>dns.NODATA</code>: DNS server returned answer with no data.</li>
@@ -1454,13 +1591,13 @@ earlier ones time out or result in some other error.</p>
 <li><code>dns.ADDRGETNETWORKPARAMS</code>: Could not find <code>GetNetworkParams</code> function.</li>
 <li><code>dns.CANCELLED</code>: DNS query cancelled.</li>
 </ul>
-<h2>Implementation considerations<span><a class="mark" href="#dns_implementation_considerations" id="dns_implementation_considerations">#</a></span></h2>
+</section><section><h3>Implementation considerations<span><a class="mark" href="#dns_implementation_considerations" id="dns_implementation_considerations">#</a></span></h3>
 <p>Although <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> and the various <code>dns.resolve*()/dns.reverse()</code>
 functions have the same goal of associating a network name with a network
 address (or vice versa), their behavior is quite different. These differences
 can have subtle but significant consequences on the behavior of Node.js
 programs.</p>
-<h3><code>dns.lookup()</code><span><a class="mark" href="#dns_dns_lookup" id="dns_dns_lookup">#</a></span></h3>
+<h4><code>dns.lookup()</code><span><a class="mark" href="#dns_dns_lookup" id="dns_dns_lookup">#</a></span></h4>
 <p>Under the hood, <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> uses the same operating system facilities
 as most other programs. For instance, <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> will almost always
 resolve a given name the same way as the <code>ping</code> command. On most POSIX-like
@@ -1478,7 +1615,7 @@ host names. If that is an issue, consider resolving the host name to an address
 using <code>dns.resolve()</code> and using the address instead of a host name. Also, some
 networking APIs (such as <a href="net.html#net_socket_connect_options_connectlistener"><code>socket.connect()</code></a> and <a href="dgram.html#dgram_dgram_createsocket_options_callback"><code>dgram.createSocket()</code></a>)
 allow the default resolver, <code>dns.lookup()</code>, to be replaced.</p>
-<h3><code>dns.resolve()</code>, <code>dns.resolve*()</code> and <code>dns.reverse()</code><span><a class="mark" href="#dns_dns_resolve_dns_resolve_and_dns_reverse" id="dns_dns_resolve_dns_resolve_and_dns_reverse">#</a></span></h3>
+<h4><code>dns.resolve()</code>, <code>dns.resolve*()</code> and <code>dns.reverse()</code><span><a class="mark" href="#dns_dns_resolve_dns_resolve_and_dns_reverse" id="dns_dns_resolve_dns_resolve_and_dns_reverse">#</a></span></h4>
 <p>These functions are implemented quite differently than <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>. They
 do not use <a href="http://man7.org/linux/man-pages/man3/getaddrinfo.3.html"><code>getaddrinfo(3)</code></a> and they <em>always</em> perform a DNS query on the
 network. This network communication is always done asynchronously, and does not
@@ -1486,10 +1623,46 @@ use libuv's threadpool.</p>
 <p>As a result, these functions cannot have the same negative impact on other
 processing that happens on libuv's threadpool that <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a> can have.</p>
 <p>They do not use the same set of configuration files than what <a href="#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>
-uses. For instance, <em>they do not use the configuration from <code>/etc/hosts</code></em>.</p>
+uses. For instance, <em>they do not use the configuration from <code>/etc/hosts</code></em>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/dns.json b/doc/api/dns.json
index 872f2b84e2fb2b38011390fc1441271ba6907fff..916fe03b7aab8ea7cda11a6108da4d00a05efd60 100644
--- a/doc/api/dns.json
+++ b/doc/api/dns.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/dns.js\">lib/dns.js</a></p>\n<p>The <code>dns</code> module enables name resolution. For example, use it to look up IP\naddresses of host names.</p>\n<p>Although named for the <a href=\"https://en.wikipedia.org/wiki/Domain_Name_System\">Domain Name System (DNS)</a>, it does not always use the\nDNS protocol for lookups. <a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> uses the operating system\nfacilities to perform name resolution. It may not need to perform any network\ncommunication. To perform name resolution the way other applications on the same\nsystem do, use <a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a>.</p>\n<pre><code class=\"language-js\">const dns = require('dns');\n\ndns.lookup('example.org', (err, address, family) => {\n  console.log('address: %j family: IPv%s', address, family);\n});\n// address: \"93.184.216.34\" family: IPv4\n</code></pre>\n<p>All other functions in the <code>dns</code> module connect to an actual DNS server to\nperform name resolution. They will always use the network to perform DNS\nqueries. These functions do not use the same set of configuration files used by\n<a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> (e.g. <code>/etc/hosts</code>). Use these functions to always perform\nDNS queries, bypassing other name-resolution facilities.</p>\n<pre><code class=\"language-js\">const dns = require('dns');\n\ndns.resolve4('archive.org', (err, addresses) => {\n  if (err) throw err;\n\n  console.log(`addresses: ${JSON.stringify(addresses)}`);\n\n  addresses.forEach((a) => {\n    dns.reverse(a, (err, hostnames) => {\n      if (err) {\n        throw err;\n      }\n      console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);\n    });\n  });\n});\n</code></pre>\n<p>See the <a href=\"#dns_implementation_considerations\">Implementation considerations section</a> for more information.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/dns.js\">lib/dns.js</a></p>\n<p>The <code>dns</code> module enables name resolution. For example, use it to look up IP\naddresses of host names.</p>\n<p>Although named for the <a href=\"https://en.wikipedia.org/wiki/Domain_Name_System\">Domain Name System (DNS)</a>, it does not always use the\nDNS protocol for lookups. <a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> uses the operating system\nfacilities to perform name resolution. It may not need to perform any network\ncommunication. To perform name resolution the way other applications on the same\nsystem do, use <a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a>.</p>\n<pre><code class=\"language-js\">const dns = require('dns');\n\ndns.lookup('example.org', (err, address, family) => {\n  console.log('address: %j family: IPv%s', address, family);\n});\n// address: \"93.184.216.34\" family: IPv4\n</code></pre>\n<p>All other functions in the <code>dns</code> module connect to an actual DNS server to\nperform name resolution. They will always use the network to perform DNS\nqueries. These functions do not use the same set of configuration files used by\n<a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> (e.g. <code>/etc/hosts</code>). Use these functions to always perform\nDNS queries, bypassing other name-resolution facilities.</p>\n<pre><code class=\"language-js\">const dns = require('dns');\n\ndns.resolve4('archive.org', (err, addresses) => {\n  if (err) throw err;\n\n  console.log(`addresses: ${JSON.stringify(addresses)}`);\n\n  addresses.forEach((a) => {\n    dns.reverse(a, (err, hostnames) => {\n      if (err) {\n        throw err;\n      }\n      console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);\n    });\n  });\n});\n</code></pre>\n<p>See the <a href=\"#dns_implementation_considerations\">Implementation considerations section</a> for more information.</p>",
       "classes": [
         {
           "textRaw": "Class: `dns.Resolver`",
@@ -20,7 +20,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>An independent resolver for DNS requests.</p>\n<p>Creating a new resolver uses the default server settings. Setting\nthe servers used for a resolver using\n<a href=\"#dns_dns_setservers_servers\"><code>resolver.setServers()</code></a> does not affect\nother resolvers:</p>\n<pre><code class=\"language-js\">const { Resolver } = require('dns');\nconst resolver = new Resolver();\nresolver.setServers(['4.4.4.4']);\n\n// This request will use the server at 4.4.4.4, independent of global settings.\nresolver.resolve4('example.org', (err, addresses) => {\n  // ...\n});\n</code></pre>\n<p>The following methods from the <code>dns</code> module are available:</p>\n<ul>\n<li><a href=\"#dns_dns_getservers\"><code>resolver.getServers()</code></a></li>\n<li><a href=\"#dns_dns_resolve_hostname_rrtype_callback\"><code>resolver.resolve()</code></a></li>\n<li><a href=\"#dns_dns_resolve4_hostname_options_callback\"><code>resolver.resolve4()</code></a></li>\n<li><a href=\"#dns_dns_resolve6_hostname_options_callback\"><code>resolver.resolve6()</code></a></li>\n<li><a href=\"#dns_dns_resolveany_hostname_callback\"><code>resolver.resolveAny()</code></a></li>\n<li><a href=\"#dns_dns_resolvecname_hostname_callback\"><code>resolver.resolveCname()</code></a></li>\n<li><a href=\"#dns_dns_resolvemx_hostname_callback\"><code>resolver.resolveMx()</code></a></li>\n<li><a href=\"#dns_dns_resolvenaptr_hostname_callback\"><code>resolver.resolveNaptr()</code></a></li>\n<li><a href=\"#dns_dns_resolvens_hostname_callback\"><code>resolver.resolveNs()</code></a></li>\n<li><a href=\"#dns_dns_resolveptr_hostname_callback\"><code>resolver.resolvePtr()</code></a></li>\n<li><a href=\"#dns_dns_resolvesoa_hostname_callback\"><code>resolver.resolveSoa()</code></a></li>\n<li><a href=\"#dns_dns_resolvesrv_hostname_callback\"><code>resolver.resolveSrv()</code></a></li>\n<li><a href=\"#dns_dns_resolvetxt_hostname_callback\"><code>resolver.resolveTxt()</code></a></li>\n<li><a href=\"#dns_dns_reverse_ip_callback\"><code>resolver.reverse()</code></a></li>\n<li><a href=\"#dns_dns_setservers_servers\"><code>resolver.setServers()</code></a></li>\n</ul>",
+          "desc": "<p>An independent resolver for DNS requests.</p>\n<p>Creating a new resolver uses the default server settings. Setting\nthe servers used for a resolver using\n<a href=\"#dns_dns_setservers_servers\"><code>resolver.setServers()</code></a> does not affect\nother resolvers:</p>\n<pre><code class=\"language-js\">const { Resolver } = require('dns');\nconst resolver = new Resolver();\nresolver.setServers(['4.4.4.4']);\n\n// This request will use the server at 4.4.4.4, independent of global settings.\nresolver.resolve4('example.org', (err, addresses) => {\n  // ...\n});\n</code></pre>\n<p>The following methods from the <code>dns</code> module are available:</p>\n<ul>\n<li><a href=\"#dns_dns_getservers\"><code>resolver.getServers()</code></a></li>\n<li><a href=\"#dns_dns_resolve_hostname_rrtype_callback\"><code>resolver.resolve()</code></a></li>\n<li><a href=\"#dns_dns_resolve4_hostname_options_callback\"><code>resolver.resolve4()</code></a></li>\n<li><a href=\"#dns_dns_resolve6_hostname_options_callback\"><code>resolver.resolve6()</code></a></li>\n<li><a href=\"#dns_dns_resolveany_hostname_callback\"><code>resolver.resolveAny()</code></a></li>\n<li><a href=\"#dns_dns_resolvecaa_hostname_callback\"><code>resolver.resolveCaa()</code></a></li>\n<li><a href=\"#dns_dns_resolvecname_hostname_callback\"><code>resolver.resolveCname()</code></a></li>\n<li><a href=\"#dns_dns_resolvemx_hostname_callback\"><code>resolver.resolveMx()</code></a></li>\n<li><a href=\"#dns_dns_resolvenaptr_hostname_callback\"><code>resolver.resolveNaptr()</code></a></li>\n<li><a href=\"#dns_dns_resolvens_hostname_callback\"><code>resolver.resolveNs()</code></a></li>\n<li><a href=\"#dns_dns_resolveptr_hostname_callback\"><code>resolver.resolvePtr()</code></a></li>\n<li><a href=\"#dns_dns_resolvesoa_hostname_callback\"><code>resolver.resolveSoa()</code></a></li>\n<li><a href=\"#dns_dns_resolvesrv_hostname_callback\"><code>resolver.resolveSrv()</code></a></li>\n<li><a href=\"#dns_dns_resolvetxt_hostname_callback\"><code>resolver.resolveTxt()</code></a></li>\n<li><a href=\"#dns_dns_reverse_ip_callback\"><code>resolver.reverse()</code></a></li>\n<li><a href=\"#dns_dns_setservers_servers\"><code>resolver.setServers()</code></a></li>\n</ul>",
           "methods": [
             {
               "textRaw": "`Resolver([options])`",
@@ -32,7 +32,12 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.18.3",
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/39610",
+                    "description": "The `options` object now accepts a `tries` option."
+                  },
+                  {
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/33472",
                     "description": "The constructor now accepts an `options` object. The single supported option is `timeout`."
                   }
@@ -43,7 +48,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Create a new resolver.</p>\n<ul>\n<li><code>options</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>timeout</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Query timeout in milliseconds, or <code>-1</code> to use the\ndefault timeout.</li>\n</ul>\n</li>\n</ul>"
+              "desc": "<p>Create a new resolver.</p>\n<ul>\n<li><code>options</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>timeout</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> Query timeout in milliseconds, or <code>-1</code> to use the\ndefault timeout.</li>\n<li><code>tries</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> The number of tries the resolver will try contacting\neach name server before giving up. <strong>Default:</strong> <code>4</code></li>\n</ul>\n</li>\n</ul>"
             },
             {
               "textRaw": "`resolver.cancel()`",
@@ -61,6 +66,38 @@
                 }
               ],
               "desc": "<p>Cancel all outstanding DNS queries made by this resolver. The corresponding\ncallbacks will be called with an error with code <code>ECANCELLED</code>.</p>"
+            },
+            {
+              "textRaw": "`resolver.setLocalAddress([ipv4][, ipv6])`",
+              "type": "method",
+              "name": "setLocalAddress",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`ipv4` {string} A string representation of an IPv4 address. **Default:** `'0.0.0.0'`",
+                      "name": "ipv4",
+                      "type": "string",
+                      "default": "`'0.0.0.0'`",
+                      "desc": "A string representation of an IPv4 address."
+                    },
+                    {
+                      "textRaw": "`ipv6` {string} A string representation of an IPv6 address. **Default:** `'::0'`",
+                      "name": "ipv6",
+                      "type": "string",
+                      "default": "`'::0'`",
+                      "desc": "A string representation of an IPv6 address."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>The resolver instance will send its requests from the specified IP address.\nThis allows programs to specify outbound interfaces when used on multi-homed\nsystems.</p>\n<p>If a v4 or v6 address is not specified, it is set to the default, and the\noperating system will choose a local address automatically.</p>\n<p>The resolver will use the v4 local address when making requests to IPv4 DNS\nservers, and the v6 local address when making requests to IPv6 DNS servers.\nThe <code>rrtype</code> of resolution requests has no impact on the local address used.</p>"
             }
           ]
         }
@@ -86,7 +123,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns an array of IP address strings, formatted according to <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a>,\nthat are currently configured for DNS resolution. A string will include a port\nsection if a custom port is used.</p>\n<!-- eslint-disable semi-->\n<pre><code class=\"language-js\">[\n  '4.4.4.4',\n  '2001:4860:4860::8888',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053'\n]\n</code></pre>"
+          "desc": "<p>Returns an array of IP address strings, formatted according to <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a>,\nthat are currently configured for DNS resolution. A string will include a port\nsection if a custom port is used.</p>\n<!-- eslint-disable semi-->\n<pre><code class=\"language-js\">[\n  '4.4.4.4',\n  '2001:4860:4860::8888',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053',\n]\n</code></pre>"
         },
         {
           "textRaw": "`dns.lookup(hostname[, options], callback)`",
@@ -143,10 +180,10 @@
                       "desc": "When `true`, the callback returns all resolved addresses in an array. Otherwise, returns a single address."
                     },
                     {
-                      "textRaw": "`verbatim` {boolean} When `true`, the callback receives IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses. **Default:** currently `false` (addresses are reordered) but this is expected to change in the not too distant future. New code should use `{ verbatim: true }`.",
+                      "textRaw": "`verbatim` {boolean} When `true`, the callback receives IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses. **Default:** currently `false` (addresses are reordered) but this is expected to change in the not too distant future. Default value is configurable using [`dns.setDefaultResultOrder()`][] or [`--dns-result-order`][]. New code should use `{ verbatim: true }`.",
                       "name": "verbatim",
                       "type": "boolean",
-                      "default": "currently `false` (addresses are reordered) but this is expected to change in the not too distant future. New code should use `{ verbatim: true }`",
+                      "default": "currently `false` (addresses are reordered) but this is expected to change in the not too distant future. Default value is configurable using [`dns.setDefaultResultOrder()`][] or [`--dns-result-order`][]. New code should use `{ verbatim: true }`",
                       "desc": "When `true`, the callback receives IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses."
                     }
                   ]
@@ -186,7 +223,7 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v14.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32183",
                     "description": "Added support for the `dns.ALL` flag."
                   }
@@ -296,7 +333,7 @@
               ]
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve a host name (e.g. <code>'nodejs.org'</code>) into an array\nof the resource records. The <code>callback</code> function has arguments\n<code>(err, records)</code>. When successful, <code>records</code> will be an array of resource\nrecords. The type and structure of individual results varies based on <code>rrtype</code>:</p>\n<table>\n<thead>\n<tr>\n<th><code>rrtype</code></th>\n<th><code>records</code> contains</th>\n<th>Result type</th>\n<th>Shorthand method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td>IPv4 addresses (default)</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolve4_hostname_options_callback\"><code>dns.resolve4()</code></a></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td>IPv6 addresses</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolve6_hostname_options_callback\"><code>dns.resolve6()</code></a></td>\n</tr>\n<tr>\n<td><code>'ANY'</code></td>\n<td>any records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolveany_hostname_callback\"><code>dns.resolveAny()</code></a></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td>canonical name records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolvecname_hostname_callback\"><code>dns.resolveCname()</code></a></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>mail exchange records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvemx_hostname_callback\"><code>dns.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>name authority pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvenaptr_hostname_callback\"><code>dns.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td>name server records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolvens_hostname_callback\"><code>dns.resolveNs()</code></a></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td>pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolveptr_hostname_callback\"><code>dns.resolvePtr()</code></a></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>start of authority records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvesoa_hostname_callback\"><code>dns.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>service records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvesrv_hostname_callback\"><code>dns.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>text records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a></td>\n<td><a href=\"#dns_dns_resolvetxt_hostname_callback\"><code>dns.resolveTxt()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>On error, <code>err</code> is an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code> is one of the\n<a href=\"#dns_error_codes\">DNS error codes</a>.</p>"
+          "desc": "<p>Uses the DNS protocol to resolve a host name (e.g. <code>'nodejs.org'</code>) into an array\nof the resource records. The <code>callback</code> function has arguments\n<code>(err, records)</code>. When successful, <code>records</code> will be an array of resource\nrecords. The type and structure of individual results varies based on <code>rrtype</code>:</p>\n<table>\n<thead>\n<tr>\n<th><code>rrtype</code></th>\n<th><code>records</code> contains</th>\n<th>Result type</th>\n<th>Shorthand method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td>IPv4 addresses (default)</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolve4_hostname_options_callback\"><code>dns.resolve4()</code></a></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td>IPv6 addresses</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolve6_hostname_options_callback\"><code>dns.resolve6()</code></a></td>\n</tr>\n<tr>\n<td><code>'ANY'</code></td>\n<td>any records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolveany_hostname_callback\"><code>dns.resolveAny()</code></a></td>\n</tr>\n<tr>\n<td><code>'CAA'</code></td>\n<td>CA authorization records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvecaa_hostname_callback\"><code>dns.resolveCaa()</code></a></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td>canonical name records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolvecname_hostname_callback\"><code>dns.resolveCname()</code></a></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>mail exchange records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvemx_hostname_callback\"><code>dns.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>name authority pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvenaptr_hostname_callback\"><code>dns.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td>name server records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolvens_hostname_callback\"><code>dns.resolveNs()</code></a></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td>pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dns_resolveptr_hostname_callback\"><code>dns.resolvePtr()</code></a></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>start of authority records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvesoa_hostname_callback\"><code>dns.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>service records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dns_resolvesrv_hostname_callback\"><code>dns.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>text records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a></td>\n<td><a href=\"#dns_dns_resolvetxt_hostname_callback\"><code>dns.resolveTxt()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>On error, <code>err</code> is an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code> is one of the\n<a href=\"#dns_error_codes\">DNS error codes</a>.</p>"
         },
         {
           "textRaw": "`dns.resolve4(hostname[, options], callback)`",
@@ -492,6 +529,46 @@
           ],
           "desc": "<p>Uses the DNS protocol to resolve <code>CNAME</code> records for the <code>hostname</code>. The\n<code>addresses</code> argument passed to the <code>callback</code> function\nwill contain an array of canonical name records available for the <code>hostname</code>\n(e.g. <code>['bar.example.com']</code>).</p>"
         },
+        {
+          "textRaw": "`dns.resolveCaa(hostname, callback)`",
+          "type": "method",
+          "name": "resolveCaa",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`hostname` {string}",
+                  "name": "hostname",
+                  "type": "string"
+                },
+                {
+                  "textRaw": "`callback` {Function}",
+                  "name": "callback",
+                  "type": "Function",
+                  "options": [
+                    {
+                      "textRaw": "`err` {Error}",
+                      "name": "err",
+                      "type": "Error"
+                    },
+                    {
+                      "textRaw": "`records` {Object[]}",
+                      "name": "records",
+                      "type": "Object[]"
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Uses the DNS protocol to resolve <code>CAA</code> records for the <code>hostname</code>. The\n<code>addresses</code> argument passed to the <code>callback</code> function\nwill contain an array of certification authority authorization records\navailable for the <code>hostname</code> (e.g. <code>[{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]</code>).</p>"
+        },
         {
           "textRaw": "`dns.resolveMx(hostname, callback)`",
           "type": "method",
@@ -744,33 +821,10 @@
           },
           "signatures": [
             {
-              "params": [
-                {
-                  "textRaw": "`hostname` {string}",
-                  "name": "hostname",
-                  "type": "string"
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
-                    {
-                      "textRaw": "`records` <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[][]&gt;</a>",
-                      "name": "records",
-                      "desc": "<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[][]&gt;</a>"
-                    }
-                  ]
-                }
-              ]
+              "params": []
             }
           ],
-          "desc": "<p>Uses the DNS protocol to resolve text queries (<code>TXT</code> records) for the\n<code>hostname</code>. The <code>records</code> argument passed to the <code>callback</code> function is a\ntwo-dimensional array of the text records available for <code>hostname</code> (e.g.\n<code>[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]</code>). Each sub-array contains TXT chunks of\none record. Depending on the use case, these could be either joined together or\ntreated separately.</p>"
+          "desc": "<!--lint disable no-undefined-references list-item-bullet-indent-->\n<ul>\n<li><code>hostname</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a>\n<ul>\n<li><code>err</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\" class=\"type\">&lt;Error&gt;</a></li>\n<li><code>records</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&#x3C;string[][]></a></li>\n</ul>\n</li>\n</ul>\n<!--lint enable no-undefined-references list-item-bullet-indent-->\n<p>Uses the DNS protocol to resolve text queries (<code>TXT</code> records) for the\n<code>hostname</code>. The <code>records</code> argument passed to the <code>callback</code> function is a\ntwo-dimensional array of the text records available for <code>hostname</code> (e.g.\n<code>[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]</code>). Each sub-array contains TXT chunks of\none record. Depending on the use case, these could be either joined together or\ntreated separately.</p>"
         },
         {
           "textRaw": "`dns.reverse(ip, callback)`",
@@ -812,6 +866,30 @@
           ],
           "desc": "<p>Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an\narray of host names.</p>\n<p>On error, <code>err</code> is an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code> is\none of the <a href=\"#dns_error_codes\">DNS error codes</a>.</p>"
         },
+        {
+          "textRaw": "`dns.setDefaultResultOrder(order)`",
+          "type": "method",
+          "name": "setDefaultResultOrder",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`order` {string} must be `'ipv4first'` or `'verbatim'`.",
+                  "name": "order",
+                  "type": "string",
+                  "desc": "must be `'ipv4first'` or `'verbatim'`."
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Set the default value of <code>verbatim</code> in <a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> and\n<a href=\"#dns_dnspromises_lookup_hostname_options\"><code>dnsPromises.lookup()</code></a>. The value could be:</p>\n<ul>\n<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>\n<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>\n</ul>\n<p>The default is <code>ipv4first</code> and <a href=\"#dns_dns_setdefaultresultorder_order\"><code>dns.setDefaultResultOrder()</code></a> have higher\npriority than <a href=\"cli.html#cli_dns_result_order_order\"><code>--dns-result-order</code></a>. When using <a href=\"worker_threads.html\">worker threads</a>,\n<a href=\"#dns_dns_setdefaultresultorder_order\"><code>dns.setDefaultResultOrder()</code></a> from the main thread won't affect the default\ndns orders in workers.</p>"
+        },
         {
           "textRaw": "`dns.setServers(servers)`",
           "type": "method",
@@ -834,13 +912,28 @@
               ]
             }
           ],
-          "desc": "<p>Sets the IP address and port of servers to be used when performing DNS\nresolution. The <code>servers</code> argument is an array of <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a> formatted\naddresses. If the port is the IANA default DNS port (53) it can be omitted.</p>\n<pre><code class=\"language-js\">dns.setServers([\n  '4.4.4.4',\n  '[2001:4860:4860::8888]',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053'\n]);\n</code></pre>\n<p>An error will be thrown if an invalid address is provided.</p>\n<p>The <code>dns.setServers()</code> method must not be called while a DNS query is in\nprogress.</p>\n<p>The <a href=\"#dns_dns_setservers_servers\"><code>dns.setServers()</code></a> method affects only <a href=\"#dns_dns_resolve_hostname_rrtype_callback\"><code>dns.resolve()</code></a>,\n<code>dns.resolve*()</code> and <a href=\"#dns_dns_reverse_ip_callback\"><code>dns.reverse()</code></a> (and specifically <em>not</em>\n<a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a>).</p>\n<p>This method works much like\n<a href=\"https://man7.org/linux/man-pages/man5/resolv.conf.5.html\">resolve.conf</a>.\nThat is, if attempting to resolve with the first server provided results in a\n<code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with\nsubsequent servers provided. Fallback DNS servers will only be used if the\nearlier ones time out or result in some other error.</p>"
+          "desc": "<p>Sets the IP address and port of servers to be used when performing DNS\nresolution. The <code>servers</code> argument is an array of <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a> formatted\naddresses. If the port is the IANA default DNS port (53) it can be omitted.</p>\n<pre><code class=\"language-js\">dns.setServers([\n  '4.4.4.4',\n  '[2001:4860:4860::8888]',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053',\n]);\n</code></pre>\n<p>An error will be thrown if an invalid address is provided.</p>\n<p>The <code>dns.setServers()</code> method must not be called while a DNS query is in\nprogress.</p>\n<p>The <a href=\"#dns_dns_setservers_servers\"><code>dns.setServers()</code></a> method affects only <a href=\"#dns_dns_resolve_hostname_rrtype_callback\"><code>dns.resolve()</code></a>,\n<code>dns.resolve*()</code> and <a href=\"#dns_dns_reverse_ip_callback\"><code>dns.reverse()</code></a> (and specifically <em>not</em>\n<a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a>).</p>\n<p>This method works much like\n<a href=\"https://man7.org/linux/man-pages/man5/resolv.conf.5.html\">resolve.conf</a>.\nThat is, if attempting to resolve with the first server provided results in a\n<code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with\nsubsequent servers provided. Fallback DNS servers will only be used if the\nearlier ones time out or result in some other error.</p>"
         }
       ],
       "modules": [
         {
           "textRaw": "DNS promises API",
           "name": "dns_promises_api",
+          "meta": {
+            "added": [
+              "v10.6.0"
+            ],
+            "changes": [
+              {
+                "version": [
+                  "v11.14.0",
+                  "v10.17.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/26592",
+                "description": "This API is no longer experimental."
+              }
+            ]
+          },
           "desc": "<p>The <code>dns.promises</code> API provides an alternative set of asynchronous DNS methods\nthat return <code>Promise</code> objects rather than using callbacks. The API is accessible\nvia <code>require('dns').promises</code>.</p>",
           "classes": [
             {
@@ -853,10 +946,27 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>An independent resolver for DNS requests.</p>\n<p>Creating a new resolver uses the default server settings. Setting\nthe servers used for a resolver using\n<a href=\"#dns_dnspromises_setservers_servers\"><code>resolver.setServers()</code></a> does not affect\nother resolvers:</p>\n<pre><code class=\"language-js\">const { Resolver } = require('dns').promises;\nconst resolver = new Resolver();\nresolver.setServers(['4.4.4.4']);\n\n// This request will use the server at 4.4.4.4, independent of global settings.\nresolver.resolve4('example.org').then((addresses) => {\n  // ...\n});\n\n// Alternatively, the same code can be written using async-await style.\n(async function() {\n  const addresses = await resolver.resolve4('example.org');\n})();\n</code></pre>\n<p>The following methods from the <code>dnsPromises</code> API are available:</p>\n<ul>\n<li><a href=\"#dns_dnspromises_getservers\"><code>resolver.getServers()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolve_hostname_rrtype\"><code>resolver.resolve()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolve4_hostname_options\"><code>resolver.resolve4()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolve6_hostname_options\"><code>resolver.resolve6()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolveany_hostname\"><code>resolver.resolveAny()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvecname_hostname\"><code>resolver.resolveCname()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvemx_hostname\"><code>resolver.resolveMx()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvenaptr_hostname\"><code>resolver.resolveNaptr()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvens_hostname\"><code>resolver.resolveNs()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolveptr_hostname\"><code>resolver.resolvePtr()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvesoa_hostname\"><code>resolver.resolveSoa()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvesrv_hostname\"><code>resolver.resolveSrv()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvetxt_hostname\"><code>resolver.resolveTxt()</code></a></li>\n<li><a href=\"#dns_dnspromises_reverse_ip\"><code>resolver.reverse()</code></a></li>\n<li><a href=\"#dns_dnspromises_setservers_servers\"><code>resolver.setServers()</code></a></li>\n</ul>"
+              "desc": "<p>An independent resolver for DNS requests.</p>\n<p>Creating a new resolver uses the default server settings. Setting\nthe servers used for a resolver using\n<a href=\"#dns_dnspromises_setservers_servers\"><code>resolver.setServers()</code></a> does not affect\nother resolvers:</p>\n<pre><code class=\"language-js\">const { Resolver } = require('dns').promises;\nconst resolver = new Resolver();\nresolver.setServers(['4.4.4.4']);\n\n// This request will use the server at 4.4.4.4, independent of global settings.\nresolver.resolve4('example.org').then((addresses) => {\n  // ...\n});\n\n// Alternatively, the same code can be written using async-await style.\n(async function() {\n  const addresses = await resolver.resolve4('example.org');\n})();\n</code></pre>\n<p>The following methods from the <code>dnsPromises</code> API are available:</p>\n<ul>\n<li><a href=\"#dns_dnspromises_getservers\"><code>resolver.getServers()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolve_hostname_rrtype\"><code>resolver.resolve()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolve4_hostname_options\"><code>resolver.resolve4()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolve6_hostname_options\"><code>resolver.resolve6()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolveany_hostname\"><code>resolver.resolveAny()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvecaa_hostname\"><code>resolver.resolveCaa()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvecname_hostname\"><code>resolver.resolveCname()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvemx_hostname\"><code>resolver.resolveMx()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvenaptr_hostname\"><code>resolver.resolveNaptr()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvens_hostname\"><code>resolver.resolveNs()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolveptr_hostname\"><code>resolver.resolvePtr()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvesoa_hostname\"><code>resolver.resolveSoa()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvesrv_hostname\"><code>resolver.resolveSrv()</code></a></li>\n<li><a href=\"#dns_dnspromises_resolvetxt_hostname\"><code>resolver.resolveTxt()</code></a></li>\n<li><a href=\"#dns_dnspromises_reverse_ip\"><code>resolver.reverse()</code></a></li>\n<li><a href=\"#dns_dnspromises_setservers_servers\"><code>resolver.setServers()</code></a></li>\n</ul>"
             }
           ],
           "methods": [
+            {
+              "textRaw": "`resolver.cancel()`",
+              "type": "method",
+              "name": "cancel",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Cancel all outstanding DNS queries made by this resolver. The corresponding\npromises will be rejected with an error with code <code>ECANCELLED</code>.</p>"
+            },
             {
               "textRaw": "`dnsPromises.getServers()`",
               "type": "method",
@@ -877,7 +987,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns an array of IP address strings, formatted according to <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a>,\nthat are currently configured for DNS resolution. A string will include a port\nsection if a custom port is used.</p>\n<!-- eslint-disable semi-->\n<pre><code class=\"language-js\">[\n  '4.4.4.4',\n  '2001:4860:4860::8888',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053'\n]\n</code></pre>"
+              "desc": "<p>Returns an array of IP address strings, formatted according to <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a>,\nthat are currently configured for DNS resolution. A string will include a port\nsection if a custom port is used.</p>\n<!-- eslint-disable semi-->\n<pre><code class=\"language-js\">[\n  '4.4.4.4',\n  '2001:4860:4860::8888',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053',\n]\n</code></pre>"
             },
             {
               "textRaw": "`dnsPromises.lookup(hostname[, options])`",
@@ -923,10 +1033,10 @@
                           "desc": "When `true`, the `Promise` is resolved with all addresses in an array. Otherwise, returns a single address."
                         },
                         {
-                          "textRaw": "`verbatim` {boolean} When `true`, the `Promise` is resolved with IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses. **Default:** currently `false` (addresses are reordered) but this is expected to change in the not too distant future. New code should use `{ verbatim: true }`.",
+                          "textRaw": "`verbatim` {boolean} When `true`, the `Promise` is resolved with IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses. **Default:** currently `false` (addresses are reordered) but this is expected to change in the not too distant future. Default value is configurable using [`dns.setDefaultResultOrder()`][] or [`--dns-result-order`][]. New code should use `{ verbatim: true }`.",
                           "name": "verbatim",
                           "type": "boolean",
-                          "default": "currently `false` (addresses are reordered) but this is expected to change in the not too distant future. New code should use `{ verbatim: true }`",
+                          "default": "currently `false` (addresses are reordered) but this is expected to change in the not too distant future. Default value is configurable using [`dns.setDefaultResultOrder()`][] or [`--dns-result-order`][]. New code should use `{ verbatim: true }`",
                           "desc": "When `true`, the `Promise` is resolved with IPv4 and IPv6 addresses in the order the DNS resolver returned them. When `false`, IPv4 addresses are placed before IPv6 addresses."
                         }
                       ]
@@ -993,7 +1103,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Uses the DNS protocol to resolve a host name (e.g. <code>'nodejs.org'</code>) into an array\nof the resource records. When successful, the <code>Promise</code> is resolved with an\narray of resource records. The type and structure of individual results vary\nbased on <code>rrtype</code>:</p>\n<table>\n<thead>\n<tr>\n<th><code>rrtype</code></th>\n<th><code>records</code> contains</th>\n<th>Result type</th>\n<th>Shorthand method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td>IPv4 addresses (default)</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolve4_hostname_options\"><code>dnsPromises.resolve4()</code></a></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td>IPv6 addresses</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolve6_hostname_options\"><code>dnsPromises.resolve6()</code></a></td>\n</tr>\n<tr>\n<td><code>'ANY'</code></td>\n<td>any records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolveany_hostname\"><code>dnsPromises.resolveAny()</code></a></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td>canonical name records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvecname_hostname\"><code>dnsPromises.resolveCname()</code></a></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>mail exchange records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvemx_hostname\"><code>dnsPromises.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>name authority pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvenaptr_hostname\"><code>dnsPromises.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td>name server records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvens_hostname\"><code>dnsPromises.resolveNs()</code></a></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td>pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolveptr_hostname\"><code>dnsPromises.resolvePtr()</code></a></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>start of authority records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvesoa_hostname\"><code>dnsPromises.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>service records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvesrv_hostname\"><code>dnsPromises.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>text records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvetxt_hostname\"><code>dnsPromises.resolveTxt()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>On error, the <code>Promise</code> is rejected with an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code>\nis one of the <a href=\"#dns_error_codes\">DNS error codes</a>.</p>"
+              "desc": "<p>Uses the DNS protocol to resolve a host name (e.g. <code>'nodejs.org'</code>) into an array\nof the resource records. When successful, the <code>Promise</code> is resolved with an\narray of resource records. The type and structure of individual results vary\nbased on <code>rrtype</code>:</p>\n<table>\n<thead>\n<tr>\n<th><code>rrtype</code></th>\n<th><code>records</code> contains</th>\n<th>Result type</th>\n<th>Shorthand method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td>IPv4 addresses (default)</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolve4_hostname_options\"><code>dnsPromises.resolve4()</code></a></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td>IPv6 addresses</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolve6_hostname_options\"><code>dnsPromises.resolve6()</code></a></td>\n</tr>\n<tr>\n<td><code>'ANY'</code></td>\n<td>any records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolveany_hostname\"><code>dnsPromises.resolveAny()</code></a></td>\n</tr>\n<tr>\n<td><code>'CAA'</code></td>\n<td>CA authorization records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvecaa_hostname\"><code>dnsPromises.resolveCaa()</code></a></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td>canonical name records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvecname_hostname\"><code>dnsPromises.resolveCname()</code></a></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>mail exchange records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvemx_hostname\"><code>dnsPromises.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>name authority pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvenaptr_hostname\"><code>dnsPromises.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td>name server records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvens_hostname\"><code>dnsPromises.resolveNs()</code></a></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td>pointer records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolveptr_hostname\"><code>dnsPromises.resolvePtr()</code></a></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>start of authority records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvesoa_hostname\"><code>dnsPromises.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>service records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvesrv_hostname\"><code>dnsPromises.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>text records</td>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a></td>\n<td><a href=\"#dns_dnspromises_resolvetxt_hostname\"><code>dnsPromises.resolveTxt()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>On error, the <code>Promise</code> is rejected with an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code>\nis one of the <a href=\"#dns_error_codes\">DNS error codes</a>.</p>"
             },
             {
               "textRaw": "`dnsPromises.resolve4(hostname[, options])`",
@@ -1092,6 +1202,29 @@
               ],
               "desc": "<p>Uses the DNS protocol to resolve all records (also known as <code>ANY</code> or <code>*</code> query).\nOn success, the <code>Promise</code> is resolved with an array containing various types of\nrecords. Each object has a property <code>type</code> that indicates the type of the\ncurrent record. And depending on the <code>type</code>, additional properties will be\npresent on the object:</p>\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Properties</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'A'</code></td>\n<td><code>address</code>/<code>ttl</code></td>\n</tr>\n<tr>\n<td><code>'AAAA'</code></td>\n<td><code>address</code>/<code>ttl</code></td>\n</tr>\n<tr>\n<td><code>'CNAME'</code></td>\n<td><code>value</code></td>\n</tr>\n<tr>\n<td><code>'MX'</code></td>\n<td>Refer to <a href=\"#dns_dnspromises_resolvemx_hostname\"><code>dnsPromises.resolveMx()</code></a></td>\n</tr>\n<tr>\n<td><code>'NAPTR'</code></td>\n<td>Refer to <a href=\"#dns_dnspromises_resolvenaptr_hostname\"><code>dnsPromises.resolveNaptr()</code></a></td>\n</tr>\n<tr>\n<td><code>'NS'</code></td>\n<td><code>value</code></td>\n</tr>\n<tr>\n<td><code>'PTR'</code></td>\n<td><code>value</code></td>\n</tr>\n<tr>\n<td><code>'SOA'</code></td>\n<td>Refer to <a href=\"#dns_dnspromises_resolvesoa_hostname\"><code>dnsPromises.resolveSoa()</code></a></td>\n</tr>\n<tr>\n<td><code>'SRV'</code></td>\n<td>Refer to <a href=\"#dns_dnspromises_resolvesrv_hostname\"><code>dnsPromises.resolveSrv()</code></a></td>\n</tr>\n<tr>\n<td><code>'TXT'</code></td>\n<td>This type of record contains an array property called <code>entries</code> which refers to <a href=\"#dns_dnspromises_resolvetxt_hostname\"><code>dnsPromises.resolveTxt()</code></a>, e.g. <code>{ entries: ['...'], type: 'TXT' }</code></td>\n</tr>\n</tbody>\n</table>\n<p>Here is an example of the result object:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[ { type: 'A', address: '127.0.0.1', ttl: 299 },\n  { type: 'CNAME', value: 'example.com' },\n  { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },\n  { type: 'NS', value: 'ns1.example.com' },\n  { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },\n  { type: 'SOA',\n    nsname: 'ns1.example.com',\n    hostmaster: 'admin.example.com',\n    serial: 156696742,\n    refresh: 900,\n    retry: 900,\n    expire: 1800,\n    minttl: 60 } ]\n</code></pre>"
             },
+            {
+              "textRaw": "`dnsPromises.resolveCaa(hostname)`",
+              "type": "method",
+              "name": "resolveCaa",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`hostname` {string}",
+                      "name": "hostname",
+                      "type": "string"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Uses the DNS protocol to resolve <code>CAA</code> records for the <code>hostname</code>. On success,\nthe <code>Promise</code> is resolved with an array of objects containing available\ncertification authority authorization records available for the <code>hostname</code>\n(e.g. <code>[{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue: 'pki.example.com'}]</code>).</p>"
+            },
             {
               "textRaw": "`dnsPromises.resolveCname(hostname)`",
               "type": "method",
@@ -1299,6 +1432,30 @@
               ],
               "desc": "<p>Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an\narray of host names.</p>\n<p>On error, the <code>Promise</code> is rejected with an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> object, where <code>err.code</code>\nis one of the <a href=\"#dns_error_codes\">DNS error codes</a>.</p>"
             },
+            {
+              "textRaw": "`dnsPromises.setDefaultResultOrder(order)`",
+              "type": "method",
+              "name": "setDefaultResultOrder",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`order` {string} must be `'ipv4first'` or `'verbatim'`.",
+                      "name": "order",
+                      "type": "string",
+                      "desc": "must be `'ipv4first'` or `'verbatim'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Set the default value of <code>verbatim</code> in <a href=\"#dns_dns_lookup_hostname_options_callback\"><code>dns.lookup()</code></a> and\n<a href=\"#dns_dnspromises_lookup_hostname_options\"><code>dnsPromises.lookup()</code></a>. The value could be:</p>\n<ul>\n<li><code>ipv4first</code>: sets default <code>verbatim</code> <code>false</code>.</li>\n<li><code>verbatim</code>: sets default <code>verbatim</code> <code>true</code>.</li>\n</ul>\n<p>The default is <code>ipv4first</code> and <a href=\"#dns_dnspromises_setdefaultresultorder_order\"><code>dnsPromises.setDefaultResultOrder()</code></a> have\nhigher priority than <a href=\"cli.html#cli_dns_result_order_order\"><code>--dns-result-order</code></a>. When using <a href=\"worker_threads.html\">worker threads</a>,\n<a href=\"#dns_dnspromises_setdefaultresultorder_order\"><code>dnsPromises.setDefaultResultOrder()</code></a> from the main thread won't affect the\ndefault dns orders in workers.</p>"
+            },
             {
               "textRaw": "`dnsPromises.setServers(servers)`",
               "type": "method",
@@ -1321,7 +1478,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Sets the IP address and port of servers to be used when performing DNS\nresolution. The <code>servers</code> argument is an array of <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a> formatted\naddresses. If the port is the IANA default DNS port (53) it can be omitted.</p>\n<pre><code class=\"language-js\">dnsPromises.setServers([\n  '4.4.4.4',\n  '[2001:4860:4860::8888]',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053'\n]);\n</code></pre>\n<p>An error will be thrown if an invalid address is provided.</p>\n<p>The <code>dnsPromises.setServers()</code> method must not be called while a DNS query is in\nprogress.</p>\n<p>This method works much like\n<a href=\"https://man7.org/linux/man-pages/man5/resolv.conf.5.html\">resolve.conf</a>.\nThat is, if attempting to resolve with the first server provided results in a\n<code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with\nsubsequent servers provided. Fallback DNS servers will only be used if the\nearlier ones time out or result in some other error.</p>"
+              "desc": "<p>Sets the IP address and port of servers to be used when performing DNS\nresolution. The <code>servers</code> argument is an array of <a href=\"https://tools.ietf.org/html/rfc5952#section-6\">RFC 5952</a> formatted\naddresses. If the port is the IANA default DNS port (53) it can be omitted.</p>\n<pre><code class=\"language-js\">dnsPromises.setServers([\n  '4.4.4.4',\n  '[2001:4860:4860::8888]',\n  '4.4.4.4:1053',\n  '[2001:4860:4860::8888]:1053',\n]);\n</code></pre>\n<p>An error will be thrown if an invalid address is provided.</p>\n<p>The <code>dnsPromises.setServers()</code> method must not be called while a DNS query is in\nprogress.</p>\n<p>This method works much like\n<a href=\"https://man7.org/linux/man-pages/man5/resolv.conf.5.html\">resolve.conf</a>.\nThat is, if attempting to resolve with the first server provided results in a\n<code>NOTFOUND</code> error, the <code>resolve()</code> method will <em>not</em> attempt to resolve with\nsubsequent servers provided. Fallback DNS servers will only be used if the\nearlier ones time out or result in some other error.</p>"
             }
           ],
           "type": "module",
diff --git a/doc/api/dns.md b/doc/api/dns.md
index 78f421bd29d1586aa4f2ca14d393fee93fea5918..6a50fa0335d3920b3c40357e42382df870c09eb2 100644
--- a/doc/api/dns.md
+++ b/doc/api/dns.md
@@ -81,6 +81,7 @@ The following methods from the `dns` module are available:
 * [`resolver.resolve4()`][`dns.resolve4()`]
 * [`resolver.resolve6()`][`dns.resolve6()`]
 * [`resolver.resolveAny()`][`dns.resolveAny()`]
+* [`resolver.resolveCaa()`][`dns.resolveCaa()`]
 * [`resolver.resolveCname()`][`dns.resolveCname()`]
 * [`resolver.resolveMx()`][`dns.resolveMx()`]
 * [`resolver.resolveNaptr()`][`dns.resolveNaptr()`]
@@ -96,7 +97,10 @@ The following methods from the `dns` module are available:
 <!-- YAML
 added: v8.3.0
 changes:
-  - version: v12.18.3
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/39610
+    description: The `options` object now accepts a `tries` option.
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33472
     description: The constructor now accepts an `options` object.
                  The single supported option is `timeout`.
@@ -107,6 +111,8 @@ Create a new resolver.
 * `options` {Object}
   * `timeout` {integer} Query timeout in milliseconds, or `-1` to use the
     default timeout.
+  * `tries` {integer} The number of tries the resolver will try contacting
+    each name server before giving up. **Default:** `4`
 
 ### `resolver.cancel()`
 <!-- YAML
@@ -116,6 +122,27 @@ added: v8.3.0
 Cancel all outstanding DNS queries made by this resolver. The corresponding
 callbacks will be called with an error with code `ECANCELLED`.
 
+### `resolver.setLocalAddress([ipv4][, ipv6])`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `ipv4` {string} A string representation of an IPv4 address.
+  **Default:** `'0.0.0.0'`
+* `ipv6` {string} A string representation of an IPv6 address.
+  **Default:** `'::0'`
+
+The resolver instance will send its requests from the specified IP address.
+This allows programs to specify outbound interfaces when used on multi-homed
+systems.
+
+If a v4 or v6 address is not specified, it is set to the default, and the
+operating system will choose a local address automatically.
+
+The resolver will use the v4 local address when making requests to IPv4 DNS
+servers, and the v6 local address when making requests to IPv6 DNS servers.
+The `rrtype` of resolution requests has no impact on the local address used.
+
 ## `dns.getServers()`
 <!-- YAML
 added: v0.11.3
@@ -133,7 +160,7 @@ section if a custom port is used.
   '4.4.4.4',
   '2001:4860:4860::8888',
   '4.4.4.4:1053',
-  '[2001:4860:4860::8888]:1053'
+  '[2001:4860:4860::8888]:1053',
 ]
 ```
 
@@ -162,8 +189,9 @@ changes:
     addresses in the order the DNS resolver returned them. When `false`,
     IPv4 addresses are placed before IPv6 addresses.
     **Default:** currently `false` (addresses are reordered) but this is
-    expected to change in the not too distant future.
-    New code should use `{ verbatim: true }`.
+    expected to change in the not too distant future. Default value is
+    configurable using [`dns.setDefaultResultOrder()`][] or
+    [`--dns-result-order`][]. New code should use `{ verbatim: true }`.
 * `callback` {Function}
   * `err` {Error}
   * `address` {string} A string representation of an IPv4 or IPv6 address.
@@ -218,7 +246,7 @@ is not set to `true`, it returns a `Promise` for an `Object` with `address` and
 ### Supported getaddrinfo flags
 <!-- YAML
 changes:
-  - version: v12.17.0
+  - version: v14.0.0
     pr-url: https://github.com/nodejs/node/pull/32183
     description: Added support for the `dns.ALL` flag.
 -->
@@ -226,13 +254,13 @@ changes:
 The following flags can be passed as hints to [`dns.lookup()`][].
 
 * `dns.ADDRCONFIG`: Limits returned address types to the types of non-loopback
-addresses configured on the system. For example, IPv4 addresses are only
-returned if the current system has at least one IPv4 address configured.
+  addresses configured on the system. For example, IPv4 addresses are only
+  returned if the current system has at least one IPv4 address configured.
 * `dns.V4MAPPED`: If the IPv6 family was specified, but no IPv6 addresses were
-found, then return IPv4 mapped IPv6 addresses. It is not supported
-on some operating systems (e.g FreeBSD 10.1).
+  found, then return IPv4 mapped IPv6 addresses. It is not supported
+  on some operating systems (e.g FreeBSD 10.1).
 * `dns.ALL`: If `dns.V4MAPPED` is specified, return resolved IPv6 addresses as
-well as IPv4 mapped IPv6 addresses.
+  well as IPv4 mapped IPv6 addresses.
 
 ## `dns.lookupService(address, port, callback)`
 <!-- YAML
@@ -287,6 +315,7 @@ records. The type and structure of individual results varies based on `rrtype`:
 | `'A'`     | IPv4 addresses (default)       | {string}    | [`dns.resolve4()`][]     |
 | `'AAAA'`  | IPv6 addresses                 | {string}    | [`dns.resolve6()`][]     |
 | `'ANY'`   | any records                    | {Object}    | [`dns.resolveAny()`][]   |
+| `'CAA'`   | CA authorization records       | {Object}    | [`dns.resolveCaa()`][]   |
 | `'CNAME'` | canonical name records         | {string}    | [`dns.resolveCname()`][] |
 | `'MX'`    | mail exchange records          | {Object}    | [`dns.resolveMx()`][]    |
 | `'NAPTR'` | name authority pointer records | {Object}    | [`dns.resolveNaptr()`][] |
@@ -412,6 +441,22 @@ Uses the DNS protocol to resolve `CNAME` records for the `hostname`. The
 will contain an array of canonical name records available for the `hostname`
 (e.g. `['bar.example.com']`).
 
+## `dns.resolveCaa(hostname, callback)`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `hostname` {string}
+* `callback` {Function}
+  * `err` {Error}
+  * `records` {Object[]}
+
+Uses the DNS protocol to resolve `CAA` records for the `hostname`. The
+`addresses` argument passed to the `callback` function
+will contain an array of certification authority authorization records
+available for the `hostname` (e.g. `[{critical: 0, iodef:
+'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]`).
+
 ## `dns.resolveMx(hostname, callback)`
 <!-- YAML
 added: v0.1.27
@@ -558,10 +603,12 @@ be an array of objects with the following properties:
 added: v0.1.27
 -->
 
+<!--lint disable no-undefined-references list-item-bullet-indent-->
 * `hostname` {string}
 * `callback` {Function}
   * `err` {Error}
   * `records` <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string[][]&gt;</a>
+<!--lint enable no-undefined-references list-item-bullet-indent-->
 
 Uses the DNS protocol to resolve text queries (`TXT` records) for the
 `hostname`. The `records` argument passed to the `callback` function is a
@@ -586,6 +633,23 @@ array of host names.
 On error, `err` is an [`Error`][] object, where `err.code` is
 one of the [DNS error codes][].
 
+## `dns.setDefaultResultOrder(order)`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `order` {string} must be `'ipv4first'` or `'verbatim'`.
+
+Set the default value of `verbatim` in [`dns.lookup()`][] and
+[`dnsPromises.lookup()`][]. The value could be:
+* `ipv4first`: sets default `verbatim` `false`.
+* `verbatim`: sets default `verbatim` `true`.
+
+The default is `ipv4first` and [`dns.setDefaultResultOrder()`][] have higher
+priority than [`--dns-result-order`][]. When using [worker threads][],
+[`dns.setDefaultResultOrder()`][] from the main thread won't affect the default
+dns orders in workers.
+
 ## `dns.setServers(servers)`
 <!-- YAML
 added: v0.11.3
@@ -602,7 +666,7 @@ dns.setServers([
   '4.4.4.4',
   '[2001:4860:4860::8888]',
   '4.4.4.4:1053',
-  '[2001:4860:4860::8888]:1053'
+  '[2001:4860:4860::8888]:1053',
 ]);
 ```
 
@@ -623,6 +687,15 @@ subsequent servers provided. Fallback DNS servers will only be used if the
 earlier ones time out or result in some other error.
 
 ## DNS promises API
+<!-- YAML
+added: v10.6.0
+changes:
+  - version:
+    - v11.14.0
+    - v10.17.0
+    pr-url: https://github.com/nodejs/node/pull/26592
+    description: This API is no longer experimental.
+-->
 
 The `dns.promises` API provides an alternative set of asynchronous DNS methods
 that return `Promise` objects rather than using callbacks. The API is accessible
@@ -663,6 +736,7 @@ The following methods from the `dnsPromises` API are available:
 * [`resolver.resolve4()`][`dnsPromises.resolve4()`]
 * [`resolver.resolve6()`][`dnsPromises.resolve6()`]
 * [`resolver.resolveAny()`][`dnsPromises.resolveAny()`]
+* [`resolver.resolveCaa()`][`dnsPromises.resolveCaa()`]
 * [`resolver.resolveCname()`][`dnsPromises.resolveCname()`]
 * [`resolver.resolveMx()`][`dnsPromises.resolveMx()`]
 * [`resolver.resolveNaptr()`][`dnsPromises.resolveNaptr()`]
@@ -674,6 +748,14 @@ The following methods from the `dnsPromises` API are available:
 * [`resolver.reverse()`][`dnsPromises.reverse()`]
 * [`resolver.setServers()`][`dnsPromises.setServers()`]
 
+### `resolver.cancel()`
+<!-- YAML
+added: v14.17.0
+-->
+
+Cancel all outstanding DNS queries made by this resolver. The corresponding
+promises will be rejected with an error with code `ECANCELLED`.
+
 ### `dnsPromises.getServers()`
 <!-- YAML
 added: v10.6.0
@@ -691,7 +773,7 @@ section if a custom port is used.
   '4.4.4.4',
   '2001:4860:4860::8888',
   '4.4.4.4:1053',
-  '[2001:4860:4860::8888]:1053'
+  '[2001:4860:4860::8888]:1053',
 ]
 ```
 
@@ -713,8 +795,9 @@ added: v10.6.0
     IPv6 addresses in the order the DNS resolver returned them. When `false`,
     IPv4 addresses are placed before IPv6 addresses.
     **Default:** currently `false` (addresses are reordered) but this is
-    expected to change in the not too distant future.
-    New code should use `{ verbatim: true }`.
+    expected to change in the not too distant future. Default value is
+    configurable using [`dns.setDefaultResultOrder()`][] or
+    [`--dns-result-order`][]. New code should use `{ verbatim: true }`.
 
 Resolves a host name (e.g. `'nodejs.org'`) into the first found A (IPv4) or
 AAAA (IPv6) record. All `option` properties are optional. If `options` is an
@@ -804,6 +887,7 @@ based on `rrtype`:
 | `'A'`     | IPv4 addresses (default)       | {string}    | [`dnsPromises.resolve4()`][]     |
 | `'AAAA'`  | IPv6 addresses                 | {string}    | [`dnsPromises.resolve6()`][]     |
 | `'ANY'`   | any records                    | {Object}    | [`dnsPromises.resolveAny()`][]   |
+| `'CAA'`   | CA authorization records       | {Object}    | [`dnsPromises.resolveCaa()`][] |
 | `'CNAME'` | canonical name records         | {string}    | [`dnsPromises.resolveCname()`][] |
 | `'MX'`    | mail exchange records          | {Object}    | [`dnsPromises.resolveMx()`][]    |
 | `'NAPTR'` | name authority pointer records | {Object}    | [`dnsPromises.resolveNaptr()`][] |
@@ -893,6 +977,19 @@ Here is an example of the result object:
     minttl: 60 } ]
 ```
 
+### `dnsPromises.resolveCaa(hostname)`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `hostname` {string}
+
+Uses the DNS protocol to resolve `CAA` records for the `hostname`. On success,
+the `Promise` is resolved with an array of objects containing available
+certification authority authorization records available for the `hostname`
+(e.g. `[{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue:
+'pki.example.com'}]`).
+
 ### `dnsPromises.resolveCname(hostname)`
 <!-- YAML
 added: v10.6.0
@@ -1054,6 +1151,23 @@ array of host names.
 On error, the `Promise` is rejected with an [`Error`][] object, where `err.code`
 is one of the [DNS error codes](#dns_error_codes).
 
+### `dnsPromises.setDefaultResultOrder(order)`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `order` {string} must be `'ipv4first'` or `'verbatim'`.
+
+Set the default value of `verbatim` in [`dns.lookup()`][] and
+[`dnsPromises.lookup()`][]. The value could be:
+* `ipv4first`: sets default `verbatim` `false`.
+* `verbatim`: sets default `verbatim` `true`.
+
+The default is `ipv4first` and [`dnsPromises.setDefaultResultOrder()`][] have
+higher priority than [`--dns-result-order`][]. When using [worker threads][],
+[`dnsPromises.setDefaultResultOrder()`][] from the main thread won't affect the
+default dns orders in workers.
+
 ### `dnsPromises.setServers(servers)`
 <!-- YAML
 added: v10.6.0
@@ -1070,7 +1184,7 @@ dnsPromises.setServers([
   '4.4.4.4',
   '[2001:4860:4860::8888]',
   '4.4.4.4:1053',
-  '[2001:4860:4860::8888]:1053'
+  '[2001:4860:4860::8888]:1053',
 ]);
 ```
 
@@ -1158,15 +1272,22 @@ processing that happens on libuv's threadpool that [`dns.lookup()`][] can have.
 They do not use the same set of configuration files than what [`dns.lookup()`][]
 uses. For instance, _they do not use the configuration from `/etc/hosts`_.
 
-[`Error`]: errors.html#errors_class_error
-[`UV_THREADPOOL_SIZE`]: cli.html#cli_uv_threadpool_size_size
-[`dgram.createSocket()`]: dgram.html#dgram_dgram_createsocket_options_callback
+[DNS error codes]: #dns_error_codes
+[Domain Name System (DNS)]: https://en.wikipedia.org/wiki/Domain_Name_System
+[Implementation considerations section]: #dns_implementation_considerations
+[RFC 5952]: https://tools.ietf.org/html/rfc5952#section-6
+[RFC 8482]: https://tools.ietf.org/html/rfc8482
+[`--dns-result-order`]: cli.md#cli_dns_result_order_order
+[`Error`]: errors.md#errors_class_error
+[`UV_THREADPOOL_SIZE`]: cli.md#cli_uv_threadpool_size_size
+[`dgram.createSocket()`]: dgram.md#dgram_dgram_createsocket_options_callback
 [`dns.getServers()`]: #dns_dns_getservers
 [`dns.lookup()`]: #dns_dns_lookup_hostname_options_callback
 [`dns.resolve()`]: #dns_dns_resolve_hostname_rrtype_callback
 [`dns.resolve4()`]: #dns_dns_resolve4_hostname_options_callback
 [`dns.resolve6()`]: #dns_dns_resolve6_hostname_options_callback
 [`dns.resolveAny()`]: #dns_dns_resolveany_hostname_callback
+[`dns.resolveCaa()`]: #dns_dns_resolvecaa_hostname_callback
 [`dns.resolveCname()`]: #dns_dns_resolvecname_hostname_callback
 [`dns.resolveMx()`]: #dns_dns_resolvemx_hostname_callback
 [`dns.resolveNaptr()`]: #dns_dns_resolvenaptr_hostname_callback
@@ -1176,6 +1297,7 @@ uses. For instance, _they do not use the configuration from `/etc/hosts`_.
 [`dns.resolveSrv()`]: #dns_dns_resolvesrv_hostname_callback
 [`dns.resolveTxt()`]: #dns_dns_resolvetxt_hostname_callback
 [`dns.reverse()`]: #dns_dns_reverse_ip_callback
+[`dns.setDefaultResultOrder()`]: #dns_dns_setdefaultresultorder_order
 [`dns.setServers()`]: #dns_dns_setservers_servers
 [`dnsPromises.getServers()`]: #dns_dnspromises_getservers
 [`dnsPromises.lookup()`]: #dns_dnspromises_lookup_hostname_options
@@ -1183,6 +1305,7 @@ uses. For instance, _they do not use the configuration from `/etc/hosts`_.
 [`dnsPromises.resolve4()`]: #dns_dnspromises_resolve4_hostname_options
 [`dnsPromises.resolve6()`]: #dns_dnspromises_resolve6_hostname_options
 [`dnsPromises.resolveAny()`]: #dns_dnspromises_resolveany_hostname
+[`dnsPromises.resolveCaa()`]: #dns_dnspromises_resolvecaa_hostname
 [`dnsPromises.resolveCname()`]: #dns_dnspromises_resolvecname_hostname
 [`dnsPromises.resolveMx()`]: #dns_dnspromises_resolvemx_hostname
 [`dnsPromises.resolveNaptr()`]: #dns_dnspromises_resolvenaptr_hostname
@@ -1192,12 +1315,9 @@ uses. For instance, _they do not use the configuration from `/etc/hosts`_.
 [`dnsPromises.resolveSrv()`]: #dns_dnspromises_resolvesrv_hostname
 [`dnsPromises.resolveTxt()`]: #dns_dnspromises_resolvetxt_hostname
 [`dnsPromises.reverse()`]: #dns_dnspromises_reverse_ip
+[`dnsPromises.setDefaultResultOrder()`]: #dns_dnspromises_setdefaultresultorder_order
 [`dnsPromises.setServers()`]: #dns_dnspromises_setservers_servers
-[`socket.connect()`]: net.html#net_socket_connect_options_connectlistener
-[`util.promisify()`]: util.html#util_util_promisify_original
-[DNS error codes]: #dns_error_codes
-[Domain Name System (DNS)]: https://en.wikipedia.org/wiki/Domain_Name_System
-[Implementation considerations section]: #dns_implementation_considerations
-[RFC 5952]: https://tools.ietf.org/html/rfc5952#section-6
-[RFC 8482]: https://tools.ietf.org/html/rfc8482
+[`socket.connect()`]: net.md#net_socket_connect_options_connectlistener
+[`util.promisify()`]: util.md#util_util_promisify_original
 [supported `getaddrinfo` flags]: #dns_supported_getaddrinfo_flags
+[worker threads]: worker_threads.md
diff --git a/doc/api/documentation.html b/doc/api/documentation.html
index a9f34d711baff56141069d43c201aea0f6c45232..99b5b9959c8769af34a9ba145289a16b45e4ef0d 100644
--- a/doc/api/documentation.html
+++ b/doc/api/documentation.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>About this documentation | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>About this documentation | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="documentation" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/documentation.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/documentation.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/documentation.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/documentation.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/documentation.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/documentation.html">13.x</a></li>
@@ -118,70 +133,110 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/documentation.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/documentation.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/documentation.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#documentation_about_this_documentation">About this documentation</a>
 <ul>
 <li><a href="#documentation_contributing">Contributing</a></li>
 <li><a href="#documentation_stability_index">Stability index</a></li>
+<li><a href="#documentation_stability_overview">Stability overview</a></li>
 <li><a href="#documentation_json_output">JSON output</a></li>
 <li><a href="#documentation_system_calls_and_man_pages">System calls and man pages</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>About this documentation<span><a class="mark" href="#documentation_about_this_documentation" id="documentation_about_this_documentation">#</a></span></h1>
+        <h2>About this documentation<span><a class="mark" href="#documentation_about_this_documentation" id="documentation_about_this_documentation">#</a></span></h2>
 
 
 <p>Welcome to the official API reference documentation for Node.js!</p>
 <p>Node.js is a JavaScript runtime built on the <a href="https://v8.dev/">V8 JavaScript engine</a>.</p>
-<h2>Contributing<span><a class="mark" href="#documentation_contributing" id="documentation_contributing">#</a></span></h2>
+<section><h3>Contributing<span><a class="mark" href="#documentation_contributing" id="documentation_contributing">#</a></span></h3>
 <p>Report errors in this documentation in <a href="https://github.com/nodejs/node/issues/new">the issue tracker</a>. See
-<a href="https://github.com/nodejs/node/blob/master/CONTRIBUTING.md">the contributing guide</a> for directions on how to submit pull requests.</p>
-<h2>Stability index<span><a class="mark" href="#documentation_stability_index" id="documentation_stability_index">#</a></span></h2>
+<a href="https://github.com/nodejs/node/blob/HEAD/CONTRIBUTING.md">the contributing guide</a> for directions on how to submit pull requests.</p>
+</section><section><h3>Stability index<span><a class="mark" href="#documentation_stability_index" id="documentation_stability_index">#</a></span></h3>
 
 <p>Throughout the documentation are indications of a section's stability. Some APIs
 are so proven and so relied upon that they are unlikely to ever change at all.
 Others are brand new and experimental, or known to be hazardous.</p>
 <p>The stability indices are as follows:</p>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. The feature may emit warnings. Backward
+<p></p><div class="api_stability api_stability_0">Stability: 0 - Deprecated. The feature may emit warnings. Backward
 compatibility is not guaranteed.</div><p></p>
 <!-- separator -->
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental. The feature is not subject to
+<p></p><div class="api_stability api_stability_1">Stability: 1 - Experimental. The feature is not subject to
 <a href="https://semver.org/">Semantic Versioning</a> rules. Non-backward compatible changes or removal may
 occur in any future release. Use of the feature is not recommended in
 production environments.</div><p></p>
 <!-- separator -->
-<p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable. Compatibility with the npm ecosystem is a high
+<p></p><div class="api_stability api_stability_2">Stability: 2 - Stable. Compatibility with the npm ecosystem is a high
 priority.</div><p></p>
+<!-- separator -->
+<p></p><div class="api_stability api_stability_3">Stability: 3 - Legacy. The feature is no longer recommended for use. While it
+likely will not be removed, and is still covered by semantic-versioning
+guarantees, use of the feature should be avoided.</div><p></p>
 <p>Use caution when making use of Experimental features, particularly within
 modules. Users may not be aware that experimental features are being used.
 Bugs or behavior changes may surprise users when Experimental API
 modifications occur. To avoid surprises, use of an Experimental feature may need
 a command-line flag. Experimental features may also emit a <a href="process.html#process_event_warning">warning</a>.</p>
-<h2>JSON output<span><a class="mark" href="#documentation_json_output" id="documentation_json_output">#</a></span></h2>
+</section><section><h3>Stability overview<span><a class="mark" href="#documentation_stability_overview" id="documentation_stability_overview">#</a></span></h3>
+<!-- STABILITY_OVERVIEW_SLOT_BEGIN --><table><thead><tr><th>API</th><th>Stability</th></tr></thead><tbody><tr><td class="module_stability"><a href="assert.html">assert</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="async_hooks.html">async_hooks</a></td><td class="api_stability api_stability_1">(1) Experimental</td></tr><tr><td class="module_stability"><a href="buffer.html">buffer</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="child_process.html">child_process</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="cluster.html">cluster</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="console.html">console</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="crypto.html">crypto</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="dgram.html">dgram</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="diagnostics_channel.html">diagnostics_channel</a></td><td class="api_stability api_stability_1">(1) Experimental</td></tr><tr><td class="module_stability"><a href="dns.html">dns</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="domain.html">domain</a></td><td class="api_stability api_stability_0">(0) Deprecated</td></tr><tr><td class="module_stability"><a href="fs.html">fs</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="http.html">http</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="http2.html">http/2</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="https.html">https</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="inspector.html">inspector</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="modules.html">module</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="os.html">os</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="path.html">path</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="perf_hooks.html">performance_measurement_apis</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="punycode.html">punycode</a></td><td class="api_stability api_stability_0">(0) Deprecated</td></tr><tr><td class="module_stability"><a href="querystring.html">querystring</a></td><td class="api_stability api_stability_3">(3) Legacy</td></tr><tr><td class="module_stability"><a href="readline.html">readline</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="repl.html">repl</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="stream.html">stream</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="string_decoder.html">string_decoder</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="timers.html">timers</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="tls.html">tls_(ssl)</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="tracing.html">trace_events</a></td><td class="api_stability api_stability_1">(1) Experimental</td></tr><tr><td class="module_stability"><a href="tty.html">tty</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="url.html">url</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="util.html">util</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="vm.html">vm</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="wasi.html">webassembly_system_interface_(wasi)</a></td><td class="api_stability api_stability_1">(1) Experimental</td></tr><tr><td class="module_stability"><a href="worker_threads.html">worker_threads</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr><tr><td class="module_stability"><a href="zlib.html">zlib</a></td><td class="api_stability api_stability_2">(2) Stable</td></tr></tbody></table><!-- STABILITY_OVERVIEW_SLOT_END -->
+</section><section><h3>JSON output<span><a class="mark" href="#documentation_json_output" id="documentation_json_output">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.12</span>
 </div>
 <p>Every <code>.html</code> document has a corresponding <code>.json</code> document. This is for IDEs
 and other utilities that consume the documentation.</p>
-<h2>System calls and man pages<span><a class="mark" href="#documentation_system_calls_and_man_pages" id="documentation_system_calls_and_man_pages">#</a></span></h2>
+</section><section><h3>System calls and man pages<span><a class="mark" href="#documentation_system_calls_and_man_pages" id="documentation_system_calls_and_man_pages">#</a></span></h3>
 <p>Node.js functions which wrap a system call will document that. The docs link
 to the corresponding man pages which describe how the system call works.</p>
 <p>Most Unix system calls have Windows analogues. Still, behavior differences may
-be unavoidable.</p>
+be unavoidable.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/documentation.json b/doc/api/documentation.json
index 522292f754a171fdb3db3e47aa68a8256a6d449f..1de9a5c94ef1458ddbd2a7f5ccf5a50553290eeb 100644
--- a/doc/api/documentation.json
+++ b/doc/api/documentation.json
@@ -13,7 +13,7 @@
         {
           "textRaw": "Contributing",
           "name": "contributing",
-          "desc": "<p>Report errors in this documentation in <a href=\"https://github.com/nodejs/node/issues/new\">the issue tracker</a>. See\n<a href=\"https://github.com/nodejs/node/blob/master/CONTRIBUTING.md\">the contributing guide</a> for directions on how to submit pull requests.</p>",
+          "desc": "<p>Report errors in this documentation in <a href=\"https://github.com/nodejs/node/issues/new\">the issue tracker</a>. See\n<a href=\"https://github.com/nodejs/node/blob/HEAD/CONTRIBUTING.md\">the contributing guide</a> for directions on how to submit pull requests.</p>",
           "type": "misc",
           "displayName": "Contributing"
         },
@@ -21,7 +21,14 @@
           "textRaw": "Stability index",
           "name": "Stability index",
           "type": "misc",
-          "desc": "<p>Throughout the documentation are indications of a section's stability. Some APIs\nare so proven and so relied upon that they are unlikely to ever change at all.\nOthers are brand new and experimental, or known to be hazardous.</p>\n<p>The stability indices are as follows:</p>\n<blockquote>\n<p>Stability: 0 - Deprecated. The feature may emit warnings. Backward\ncompatibility is not guaranteed.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 1 - Experimental. The feature is not subject to\n<a href=\"https://semver.org/\">Semantic Versioning</a> rules. Non-backward compatible changes or removal may\noccur in any future release. Use of the feature is not recommended in\nproduction environments.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 2 - Stable. Compatibility with the npm ecosystem is a high\npriority.</p>\n</blockquote>\n<p>Use caution when making use of Experimental features, particularly within\nmodules. Users may not be aware that experimental features are being used.\nBugs or behavior changes may surprise users when Experimental API\nmodifications occur. To avoid surprises, use of an Experimental feature may need\na command-line flag. Experimental features may also emit a <a href=\"process.html#process_event_warning\">warning</a>.</p>"
+          "desc": "<p>Throughout the documentation are indications of a section's stability. Some APIs\nare so proven and so relied upon that they are unlikely to ever change at all.\nOthers are brand new and experimental, or known to be hazardous.</p>\n<p>The stability indices are as follows:</p>\n<blockquote>\n<p>Stability: 0 - Deprecated. The feature may emit warnings. Backward\ncompatibility is not guaranteed.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 1 - Experimental. The feature is not subject to\n<a href=\"https://semver.org/\">Semantic Versioning</a> rules. Non-backward compatible changes or removal may\noccur in any future release. Use of the feature is not recommended in\nproduction environments.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 2 - Stable. Compatibility with the npm ecosystem is a high\npriority.</p>\n</blockquote>\n<!-- separator -->\n<blockquote>\n<p>Stability: 3 - Legacy. The feature is no longer recommended for use. While it\nlikely will not be removed, and is still covered by semantic-versioning\nguarantees, use of the feature should be avoided.</p>\n</blockquote>\n<p>Use caution when making use of Experimental features, particularly within\nmodules. Users may not be aware that experimental features are being used.\nBugs or behavior changes may surprise users when Experimental API\nmodifications occur. To avoid surprises, use of an Experimental feature may need\na command-line flag. Experimental features may also emit a <a href=\"process.html#process_event_warning\">warning</a>.</p>"
+        },
+        {
+          "textRaw": "Stability overview",
+          "name": "stability_overview",
+          "desc": "<!-- STABILITY_OVERVIEW_SLOT_BEGIN --><table><thead><tr><th>API</th><th>Stability</th></tr></thead><tbody><tr><td class=\"module_stability\"><a href=\"assert.html\">assert</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"async_hooks.html\">async_hooks</a></td><td class=\"api_stability api_stability_1\">(1) Experimental</td></tr><tr><td class=\"module_stability\"><a href=\"buffer.html\">buffer</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"child_process.html\">child_process</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"cluster.html\">cluster</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"console.html\">console</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"crypto.html\">crypto</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"dgram.html\">dgram</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"diagnostics_channel.html\">diagnostics_channel</a></td><td class=\"api_stability api_stability_1\">(1) Experimental</td></tr><tr><td class=\"module_stability\"><a href=\"dns.html\">dns</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"domain.html\">domain</a></td><td class=\"api_stability api_stability_0\">(0) Deprecated</td></tr><tr><td class=\"module_stability\"><a href=\"fs.html\">fs</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"http.html\">http</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"http2.html\">http/2</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"https.html\">https</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"inspector.html\">inspector</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"modules.html\">module</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"os.html\">os</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"path.html\">path</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"perf_hooks.html\">performance_measurement_apis</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"punycode.html\">punycode</a></td><td class=\"api_stability api_stability_0\">(0) Deprecated</td></tr><tr><td class=\"module_stability\"><a href=\"querystring.html\">querystring</a></td><td class=\"api_stability api_stability_3\">(3) Legacy</td></tr><tr><td class=\"module_stability\"><a href=\"readline.html\">readline</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"repl.html\">repl</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"stream.html\">stream</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"string_decoder.html\">string_decoder</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"timers.html\">timers</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"tls.html\">tls_(ssl)</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"tracing.html\">trace_events</a></td><td class=\"api_stability api_stability_1\">(1) Experimental</td></tr><tr><td class=\"module_stability\"><a href=\"tty.html\">tty</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"url.html\">url</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"util.html\">util</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"vm.html\">vm</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"wasi.html\">webassembly_system_interface_(wasi)</a></td><td class=\"api_stability api_stability_1\">(1) Experimental</td></tr><tr><td class=\"module_stability\"><a href=\"worker_threads.html\">worker_threads</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr><tr><td class=\"module_stability\"><a href=\"zlib.html\">zlib</a></td><td class=\"api_stability api_stability_2\">(2) Stable</td></tr></tbody></table><!-- STABILITY_OVERVIEW_SLOT_END -->",
+          "type": "misc",
+          "displayName": "Stability overview"
         },
         {
           "textRaw": "JSON output",
diff --git a/doc/api/documentation.md b/doc/api/documentation.md
index 779b02d14c7bfe56ba556bc8adf8a3d0c3ca7f69..d8ba4e7d49c4b5df4637720a81b13aa725a9cc2c 100644
--- a/doc/api/documentation.md
+++ b/doc/api/documentation.md
@@ -37,12 +37,60 @@ The stability indices are as follows:
 > Stability: 2 - Stable. Compatibility with the npm ecosystem is a high
 > priority.
 
+<!-- separator -->
+
+> Stability: 3 - Legacy. The feature is no longer recommended for use. While it
+> likely will not be removed, and is still covered by semantic-versioning
+> guarantees, use of the feature should be avoided.
+
 Use caution when making use of Experimental features, particularly within
 modules. Users may not be aware that experimental features are being used.
 Bugs or behavior changes may surprise users when Experimental API
 modifications occur. To avoid surprises, use of an Experimental feature may need
 a command-line flag. Experimental features may also emit a [warning][].
 
+## Stability overview
+<!-- STABILITY_OVERVIEW_SLOT_BEGIN -->
+| API | Stability |
+| --- | --------- |
+| [assert](assert.html) | (2) Stable |
+| [async_hooks](async_hooks.html) | (1) Experimental |
+| [buffer](buffer.html) | (2) Stable |
+| [child_process](child_process.html) | (2) Stable |
+| [cluster](cluster.html) | (2) Stable |
+| [console](console.html) | (2) Stable |
+| [crypto](crypto.html) | (2) Stable |
+| [dgram](dgram.html) | (2) Stable |
+| [diagnostics_channel](diagnostics_channel.html) | (1) Experimental |
+| [dns](dns.html) | (2) Stable |
+| [domain](domain.html) | (0) Deprecated |
+| [fs](fs.html) | (2) Stable |
+| [http](http.html) | (2) Stable |
+| [http/2](http2.html) | (2) Stable |
+| [https](https.html) | (2) Stable |
+| [inspector](inspector.html) | (2) Stable |
+| [module](modules.html) | (2) Stable |
+| [os](os.html) | (2) Stable |
+| [path](path.html) | (2) Stable |
+| [performance_measurement_apis](perf_hooks.html) | (2) Stable |
+| [punycode](punycode.html) | (0) Deprecated |
+| [querystring](querystring.html) | (3) Legacy |
+| [readline](readline.html) | (2) Stable |
+| [repl](repl.html) | (2) Stable |
+| [stream](stream.html) | (2) Stable |
+| [string_decoder](string_decoder.html) | (2) Stable |
+| [timers](timers.html) | (2) Stable |
+| [tls_(ssl)](tls.html) | (2) Stable |
+| [trace_events](tracing.html) | (1) Experimental |
+| [tty](tty.html) | (2) Stable |
+| [url](url.html) | (2) Stable |
+| [util](util.html) | (2) Stable |
+| [vm](vm.html) | (2) Stable |
+| [webassembly_system_interface_(wasi)](wasi.html) | (1) Experimental |
+| [worker_threads](worker_threads.html) | (2) Stable |
+| [zlib](zlib.html) | (2) Stable |
+<!-- STABILITY_OVERVIEW_SLOT_END -->
+
 ## JSON output
 <!-- YAML
 added: v0.6.12
@@ -60,7 +108,7 @@ Most Unix system calls have Windows analogues. Still, behavior differences may
 be unavoidable.
 
 [Semantic Versioning]: https://semver.org/
-[the contributing guide]: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
-[the issue tracker]: https://github.com/nodejs/node/issues/new
 [V8 JavaScript engine]: https://v8.dev/
-[warning]: process.html#process_event_warning
+[the contributing guide]: https://github.com/nodejs/node/blob/HEAD/CONTRIBUTING.md
+[the issue tracker]: https://github.com/nodejs/node/issues/new
+[warning]: process.md#process_event_warning
diff --git a/doc/api/domain.html b/doc/api/domain.html
index d7c1ad6cbebe3e4e1c47030d4cfbdd2ada8d02c8..849848ca739e090a53490fd0f7200aa47024e4b3 100644
--- a/doc/api/domain.html
+++ b/doc/api/domain.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Domain | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Domain | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain active">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="domain" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/domain.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/domain.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/domain.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/domain.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/domain.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/domain.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/domain.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/domain.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/domain.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_0"><a href="#domain_domain">Domain</a></span>
 <ul>
 <li><a href="#domain_warning_don_t_ignore_errors">Warning: Don't ignore errors!</a></li>
@@ -149,11 +162,10 @@
 <li><a href="#domain_domains_and_promises">Domains and promises</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Domain<span><a class="mark" href="#domain_domain" id="domain_domain">#</a></span></h1>
+        <h2>Domain<span><a class="mark" href="#domain_domain" id="domain_domain">#</a></span></h2>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -169,7 +181,7 @@
 </div>
 
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/domain.js">lib/domain.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/domain.js">lib/domain.js</a></p>
 <p><strong>This module is pending deprecation</strong>. Once a replacement API has been
 finalized, this module will be fully deprecated. Most developers should
 <strong>not</strong> have cause to use this module. Users who absolutely must have
@@ -182,7 +194,7 @@ domain emit an <code>'error'</code> event, or throw an error, then the domain ob
 will be notified, rather than losing the context of the error in the
 <code>process.on('uncaughtException')</code> handler, or causing the program to
 exit immediately with an error code.</p>
-<h2>Warning: Don't ignore errors!<span><a class="mark" href="#domain_warning_don_t_ignore_errors" id="domain_warning_don_t_ignore_errors">#</a></span></h2>
+<section><h3>Warning: Don't ignore errors!<span><a class="mark" href="#domain_warning_don_t_ignore_errors" id="domain_warning_don_t_ignore_errors">#</a></span></h3>
 
 <p>Domain error handlers are not a substitute for closing down a
 process when an error occurs.</p>
@@ -204,18 +216,18 @@ the failure, and react accordingly.</p>
 <p>For example, this is not a good idea:</p>
 <pre><code class="language-js"><span class="hljs-comment">// XXX WARNING! BAD IDEA!</span>
 
-<span class="hljs-keyword">const</span> d = <span class="hljs-built_in">require</span>(<span class="hljs-string">'domain'</span>).create();
-d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+<span class="hljs-keyword">const</span> d = <span class="hljs-built_in">require</span>(<span class="hljs-string">'domain'</span>).<span class="hljs-title function_">create</span>();
+d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
   <span class="hljs-comment">// The error won't crash the process, but what it does is worse!</span>
   <span class="hljs-comment">// Though we've prevented abrupt process restarting, we are leaking</span>
-  <span class="hljs-comment">// resources like crazy if this ever happens.</span>
+  <span class="hljs-comment">// a lot of resources if this ever happens.</span>
   <span class="hljs-comment">// This is no better than process.on('uncaughtException')!</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`error, but oh well <span class="hljs-subst">${er.message}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`error, but oh well <span class="hljs-subst">${er.message}</span>`</span>);
 });
-d.run(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>).createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    handleRequest(req, res);
-  }).listen(PORT);
+d.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>).<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    <span class="hljs-title function_">handleRequest</span>(req, res);
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-variable constant_">PORT</span>);
 });</code></pre>
 <p>By using the context of a domain, and the resilience of separating our
 program into multiple worker processes, we can react more
@@ -223,9 +235,9 @@ appropriately, and handle errors with much greater safety.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Much better!</span>
 
 <span class="hljs-keyword">const</span> cluster = <span class="hljs-built_in">require</span>(<span class="hljs-string">'cluster'</span>);
-<span class="hljs-keyword">const</span> PORT = +process.env.PORT || <span class="hljs-number">1337</span>;
+<span class="hljs-keyword">const</span> <span class="hljs-variable constant_">PORT</span> = +process.<span class="hljs-property">env</span>.<span class="hljs-property">PORT</span> || <span class="hljs-number">1337</span>;
 
-<span class="hljs-keyword">if</span> (cluster.isMaster) {
+<span class="hljs-keyword">if</span> (cluster.<span class="hljs-property">isMaster</span>) {
   <span class="hljs-comment">// A more realistic scenario would have more than 2 workers,</span>
   <span class="hljs-comment">// and perhaps not put the master and worker in the same file.</span>
   <span class="hljs-comment">//</span>
@@ -238,12 +250,12 @@ appropriately, and handle errors with much greater safety.</p>
   <span class="hljs-comment">// The important thing is that the master does very little,</span>
   <span class="hljs-comment">// increasing our resilience to unexpected errors.</span>
 
-  cluster.fork();
-  cluster.fork();
+  cluster.<span class="hljs-title function_">fork</span>();
+  cluster.<span class="hljs-title function_">fork</span>();
 
-  cluster.on(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'disconnect!'</span>);
-    cluster.fork();
+  cluster.<span class="hljs-title function_">on</span>(<span class="hljs-string">'disconnect'</span>, <span class="hljs-function">(<span class="hljs-params">worker</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'disconnect!'</span>);
+    cluster.<span class="hljs-title function_">fork</span>();
   });
 
 } <span class="hljs-keyword">else</span> {
@@ -256,10 +268,10 @@ appropriately, and handle errors with much greater safety.</p>
   <span class="hljs-comment">// See the cluster documentation for more details about using</span>
   <span class="hljs-comment">// worker processes to serve requests. How it works, caveats, etc.</span>
 
-  <span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>).createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    <span class="hljs-keyword">const</span> d = domain.create();
-    d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`error <span class="hljs-subst">${er.stack}</span>`</span>);
+  <span class="hljs-keyword">const</span> server = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>).<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    <span class="hljs-keyword">const</span> d = domain.<span class="hljs-title function_">create</span>();
+    d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`error <span class="hljs-subst">${er.stack}</span>`</span>);
 
       <span class="hljs-comment">// We're in dangerous territory!</span>
       <span class="hljs-comment">// By definition, something unexpected occurred,</span>
@@ -269,59 +281,59 @@ appropriately, and handle errors with much greater safety.</p>
       <span class="hljs-keyword">try</span> {
         <span class="hljs-comment">// Make sure we close down within 30 seconds</span>
         <span class="hljs-keyword">const</span> killtimer = <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-          process.exit(<span class="hljs-number">1</span>);
+          process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">1</span>);
         }, <span class="hljs-number">30000</span>);
         <span class="hljs-comment">// But don't keep the process open just for that!</span>
-        killtimer.unref();
+        killtimer.<span class="hljs-title function_">unref</span>();
 
         <span class="hljs-comment">// Stop taking new requests.</span>
-        server.close();
+        server.<span class="hljs-title function_">close</span>();
 
         <span class="hljs-comment">// Let the master know we're dead. This will trigger a</span>
         <span class="hljs-comment">// 'disconnect' in the cluster master, and then it will fork</span>
         <span class="hljs-comment">// a new worker.</span>
-        cluster.worker.disconnect();
+        cluster.<span class="hljs-property">worker</span>.<span class="hljs-title function_">disconnect</span>();
 
         <span class="hljs-comment">// Try to send an error to the request that triggered the problem</span>
-        res.statusCode = <span class="hljs-number">500</span>;
-        res.setHeader(<span class="hljs-string">'content-type'</span>, <span class="hljs-string">'text/plain'</span>);
-        res.end(<span class="hljs-string">'Oops, there was a problem!\n'</span>);
+        res.<span class="hljs-property">statusCode</span> = <span class="hljs-number">500</span>;
+        res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'content-type'</span>, <span class="hljs-string">'text/plain'</span>);
+        res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Oops, there was a problem!\n'</span>);
       } <span class="hljs-keyword">catch</span> (er2) {
         <span class="hljs-comment">// Oh well, not much we can do at this point.</span>
-        <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`Error sending 500! <span class="hljs-subst">${er2.stack}</span>`</span>);
+        <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`Error sending 500! <span class="hljs-subst">${er2.stack}</span>`</span>);
       }
     });
 
     <span class="hljs-comment">// Because req and res were created before this domain existed,</span>
     <span class="hljs-comment">// we need to explicitly add them.</span>
     <span class="hljs-comment">// See the explanation of implicit vs explicit binding below.</span>
-    d.add(req);
-    d.add(res);
+    d.<span class="hljs-title function_">add</span>(req);
+    d.<span class="hljs-title function_">add</span>(res);
 
     <span class="hljs-comment">// Now run the handler function in the domain.</span>
-    d.run(<span class="hljs-function">() =></span> {
-      handleRequest(req, res);
+    d.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+      <span class="hljs-title function_">handleRequest</span>(req, res);
     });
   });
-  server.listen(PORT);
+  server.<span class="hljs-title function_">listen</span>(<span class="hljs-variable constant_">PORT</span>);
 }
 
 <span class="hljs-comment">// This part is not important. Just an example routing thing.</span>
 <span class="hljs-comment">// Put fancy application logic here.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">handleRequest</span>(<span class="hljs-params">req, res</span>) </span>{
-  <span class="hljs-keyword">switch</span> (req.url) {
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">handleRequest</span>(<span class="hljs-params">req, res</span>) {
+  <span class="hljs-keyword">switch</span> (req.<span class="hljs-property">url</span>) {
     <span class="hljs-keyword">case</span> <span class="hljs-string">'/error'</span>:
       <span class="hljs-comment">// We do some async stuff, and then...</span>
       <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
         <span class="hljs-comment">// Whoops!</span>
-        flerb.bark();
+        flerb.<span class="hljs-title function_">bark</span>();
       }, timeout);
       <span class="hljs-keyword">break</span>;
-    <span class="hljs-keyword">default</span>:
-      res.end(<span class="hljs-string">'ok'</span>);
+    <span class="hljs-attr">default</span>:
+      res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
   }
 }</code></pre>
-<h2>Additions to <code>Error</code> objects<span><a class="mark" href="#domain_additions_to_error_objects" id="domain_additions_to_error_objects">#</a></span></h2>
+</section><section><h3>Additions to <code>Error</code> objects<span><a class="mark" href="#domain_additions_to_error_objects" id="domain_additions_to_error_objects">#</a></span></h3>
 
 <p>Any time an <code>Error</code> object is routed through a domain, a few extra fields
 are added to it.</p>
@@ -334,7 +346,7 @@ domain, and passed an error as its first argument.</li>
 <li><code>error.domainThrown</code> A boolean indicating whether the error was
 thrown, emitted, or passed to a bound callback function.</li>
 </ul>
-<h2>Implicit binding<span><a class="mark" href="#domain_implicit_binding" id="domain_implicit_binding">#</a></span></h2>
+</section><section><h3>Implicit binding<span><a class="mark" href="#domain_implicit_binding" id="domain_implicit_binding">#</a></span></h3>
 
 <p>If domains are in use, then all <strong>new</strong> <code>EventEmitter</code> objects (including
 Stream objects, requests, responses, etc.) will be implicitly bound to
@@ -353,7 +365,7 @@ explicitly added.</p>
 <code>Domain</code>'s <code>'error'</code> event, but does not register the <code>EventEmitter</code> on the
 <code>Domain</code>.
 Implicit binding only takes care of thrown errors and <code>'error'</code> events.</p>
-<h2>Explicit binding<span><a class="mark" href="#domain_explicit_binding" id="domain_explicit_binding">#</a></span></h2>
+</section><section><h3>Explicit binding<span><a class="mark" href="#domain_explicit_binding" id="domain_explicit_binding">#</a></span></h3>
 
 <p>Sometimes, the domain in use is not the one that ought to be used for a
 specific event emitter. Or, the event emitter could have been created
@@ -365,46 +377,46 @@ perhaps we would like to have a separate domain to use for each request.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create a top-level domain for the server</span>
 <span class="hljs-keyword">const</span> domain = <span class="hljs-built_in">require</span>(<span class="hljs-string">'domain'</span>);
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> serverDomain = domain.create();
+<span class="hljs-keyword">const</span> serverDomain = domain.<span class="hljs-title function_">create</span>();
 
-serverDomain.run(<span class="hljs-function">() =></span> {
+serverDomain.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Server is created in the scope of serverDomain</span>
-  http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
     <span class="hljs-comment">// Req and res are also created in the scope of serverDomain</span>
     <span class="hljs-comment">// however, we'd prefer to have a separate domain for each request.</span>
     <span class="hljs-comment">// create it first thing, and add req and res to it.</span>
-    <span class="hljs-keyword">const</span> reqd = domain.create();
-    reqd.add(req);
-    reqd.add(res);
-    reqd.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Error'</span>, er, req.url);
+    <span class="hljs-keyword">const</span> reqd = domain.<span class="hljs-title function_">create</span>();
+    reqd.<span class="hljs-title function_">add</span>(req);
+    reqd.<span class="hljs-title function_">add</span>(res);
+    reqd.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Error'</span>, er, req.<span class="hljs-property">url</span>);
       <span class="hljs-keyword">try</span> {
-        res.writeHead(<span class="hljs-number">500</span>);
-        res.end(<span class="hljs-string">'Error occurred, sorry.'</span>);
+        res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">500</span>);
+        res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Error occurred, sorry.'</span>);
       } <span class="hljs-keyword">catch</span> (er2) {
-        <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Error sending 500'</span>, er2, req.url);
+        <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Error sending 500'</span>, er2, req.<span class="hljs-property">url</span>);
       }
     });
-  }).listen(<span class="hljs-number">1337</span>);
+  }).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);
 });</code></pre>
-<h2><code>domain.create()</code><span><a class="mark" href="#domain_domain_create" id="domain_domain_create">#</a></span></h2>
+</section><section><h3><code>domain.create()</code><span><a class="mark" href="#domain_domain_create" id="domain_domain_create">#</a></span></h3>
 <ul>
 <li>Returns: <a href="domain.html#domain_class_domain" class="type">&#x3C;Domain></a></li>
 </ul>
-<h2>Class: <code>Domain</code><span><a class="mark" href="#domain_class_domain" id="domain_class_domain">#</a></span></h2>
+</section><section><h3>Class: <code>Domain</code><span><a class="mark" href="#domain_class_domain" id="domain_class_domain">#</a></span></h3>
 <ul>
 <li>Extends: <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
 <p>The <code>Domain</code> class encapsulates the functionality of routing errors and
 uncaught exceptions to the active <code>Domain</code> object.</p>
 <p>To handle the errors that it catches, listen to its <code>'error'</code> event.</p>
-<h3><code>domain.members</code><span><a class="mark" href="#domain_domain_members" id="domain_domain_members">#</a></span></h3>
+<h4><code>domain.members</code><span><a class="mark" href="#domain_domain_members" id="domain_domain_members">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
 </ul>
 <p>An array of timers and event emitters that have been explicitly added
 to the domain.</p>
-<h3><code>domain.add(emitter)</code><span><a class="mark" href="#domain_domain_add_emitter" id="domain_domain_add_emitter">#</a></span></h3>
+<h4><code>domain.add(emitter)</code><span><a class="mark" href="#domain_domain_add_emitter" id="domain_domain_add_emitter">#</a></span></h4>
 <ul>
 <li><code>emitter</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> | <a href="timers.html#timers_timers" class="type">&#x3C;Timer></a> emitter or timer to be added to the domain</li>
 </ul>
@@ -417,7 +429,7 @@ binding.</p>
 the domain <code>'error'</code> handler.</p>
 <p>If the Timer or <code>EventEmitter</code> was already bound to a domain, it is removed
 from that one, and bound to this one instead.</p>
-<h3><code>domain.bind(callback)</code><span><a class="mark" href="#domain_domain_bind_callback" id="domain_domain_bind_callback">#</a></span></h3>
+<h4><code>domain.bind(callback)</code><span><a class="mark" href="#domain_domain_bind_callback" id="domain_domain_bind_callback">#</a></span></h4>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The bound function</li>
@@ -425,20 +437,20 @@ from that one, and bound to this one instead.</p>
 <p>The returned function will be a wrapper around the supplied callback
 function. When the returned function is called, any errors that are
 thrown will be routed to the domain's <code>'error'</code> event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> d = domain.create();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> d = domain.<span class="hljs-title function_">create</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">readSomeFile</span>(<span class="hljs-params">filename, cb</span>) </span>{
-  fs.readFile(filename, <span class="hljs-string">'utf8'</span>, d.bind(<span class="hljs-function">(<span class="hljs-params">er, data</span>) =></span> {
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">readSomeFile</span>(<span class="hljs-params">filename, cb</span>) {
+  fs.<span class="hljs-title function_">readFile</span>(filename, <span class="hljs-string">'utf8'</span>, d.<span class="hljs-title function_">bind</span>(<span class="hljs-function">(<span class="hljs-params">er, data</span>) =></span> {
     <span class="hljs-comment">// If this throws, it will also be passed to the domain.</span>
-    <span class="hljs-keyword">return</span> cb(er, data ? <span class="hljs-built_in">JSON</span>.parse(data) : <span class="hljs-literal">null</span>);
+    <span class="hljs-keyword">return</span> <span class="hljs-title function_">cb</span>(er, data ? <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(data) : <span class="hljs-literal">null</span>);
   }));
 }
 
-d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
   <span class="hljs-comment">// An error occurred somewhere. If we throw it now, it will crash the program</span>
   <span class="hljs-comment">// with the normal line number and stack message.</span>
 });</code></pre>
-<h3><code>domain.enter()</code><span><a class="mark" href="#domain_domain_enter" id="domain_domain_enter">#</a></span></h3>
+<h4><code>domain.enter()</code><span><a class="mark" href="#domain_domain_enter" id="domain_domain_enter">#</a></span></h4>
 <p>The <code>enter()</code> method is plumbing used by the <code>run()</code>, <code>bind()</code>, and
 <code>intercept()</code> methods to set the active domain. It sets <code>domain.active</code> and
 <code>process.domain</code> to the domain, and implicitly pushes the domain onto the domain
@@ -448,7 +460,7 @@ asynchronous calls and I/O operations bound to a domain.</p>
 <p>Calling <code>enter()</code> changes only the active domain, and does not alter the domain
 itself. <code>enter()</code> and <code>exit()</code> can be called an arbitrary number of times on a
 single domain.</p>
-<h3><code>domain.exit()</code><span><a class="mark" href="#domain_domain_exit" id="domain_domain_exit">#</a></span></h3>
+<h4><code>domain.exit()</code><span><a class="mark" href="#domain_domain_exit" id="domain_domain_exit">#</a></span></h4>
 <p>The <code>exit()</code> method exits the current domain, popping it off the domain stack.
 Any time execution is going to switch to the context of a different chain of
 asynchronous calls, it's important to ensure that the current domain is exited.
@@ -459,7 +471,7 @@ of asynchronous calls and I/O operations bound to a domain.</p>
 <p>Calling <code>exit()</code> changes only the active domain, and does not alter the domain
 itself. <code>enter()</code> and <code>exit()</code> can be called an arbitrary number of times on a
 single domain.</p>
-<h3><code>domain.intercept(callback)</code><span><a class="mark" href="#domain_domain_intercept_callback" id="domain_domain_intercept_callback">#</a></span></h3>
+<h4><code>domain.intercept(callback)</code><span><a class="mark" href="#domain_domain_intercept_callback" id="domain_domain_intercept_callback">#</a></span></h4>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The intercepted function</li>
@@ -469,10 +481,10 @@ addition to catching thrown errors, it will also intercept <a href="errors.html#
 objects sent as the first argument to the function.</p>
 <p>In this way, the common <code>if (err) return callback(err);</code> pattern can be replaced
 with a single error handler in a single place.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> d = domain.create();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> d = domain.<span class="hljs-title function_">create</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">readSomeFile</span>(<span class="hljs-params">filename, cb</span>) </span>{
-  fs.readFile(filename, <span class="hljs-string">'utf8'</span>, d.intercept(<span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">readSomeFile</span>(<span class="hljs-params">filename, cb</span>) {
+  fs.<span class="hljs-title function_">readFile</span>(filename, <span class="hljs-string">'utf8'</span>, d.<span class="hljs-title function_">intercept</span>(<span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
     <span class="hljs-comment">// Note, the first argument is never passed to the</span>
     <span class="hljs-comment">// callback since it is assumed to be the 'Error' argument</span>
     <span class="hljs-comment">// and thus intercepted by the domain.</span>
@@ -481,21 +493,21 @@ with a single error handler in a single place.</p>
     <span class="hljs-comment">// so the error-handling logic can be moved to the 'error'</span>
     <span class="hljs-comment">// event on the domain instead of being repeated throughout</span>
     <span class="hljs-comment">// the program.</span>
-    <span class="hljs-keyword">return</span> cb(<span class="hljs-literal">null</span>, <span class="hljs-built_in">JSON</span>.parse(data));
+    <span class="hljs-keyword">return</span> <span class="hljs-title function_">cb</span>(<span class="hljs-literal">null</span>, <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(data));
   }));
 }
 
-d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
   <span class="hljs-comment">// An error occurred somewhere. If we throw it now, it will crash the program</span>
   <span class="hljs-comment">// with the normal line number and stack message.</span>
 });</code></pre>
-<h3><code>domain.remove(emitter)</code><span><a class="mark" href="#domain_domain_remove_emitter" id="domain_domain_remove_emitter">#</a></span></h3>
+<h4><code>domain.remove(emitter)</code><span><a class="mark" href="#domain_domain_remove_emitter" id="domain_domain_remove_emitter">#</a></span></h4>
 <ul>
 <li><code>emitter</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> | <a href="timers.html#timers_timers" class="type">&#x3C;Timer></a> emitter or timer to be removed from the domain</li>
 </ul>
 <p>The opposite of <a href="#domain_domain_add_emitter"><code>domain.add(emitter)</code></a>. Removes domain handling from the
 specified emitter.</p>
-<h3><code>domain.run(fn[, ...args])</code><span><a class="mark" href="#domain_domain_run_fn_args" id="domain_domain_run_fn_args">#</a></span></h3>
+<h4><code>domain.run(fn[, ...args])</code><span><a class="mark" href="#domain_domain_run_fn_args" id="domain_domain_run_fn_args">#</a></span></h4>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
@@ -507,14 +519,14 @@ the function.</p>
 <p>This is the most basic way to use a domain.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> domain = <span class="hljs-built_in">require</span>(<span class="hljs-string">'domain'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> d = domain.create();
-d.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Caught error!'</span>, er);
+<span class="hljs-keyword">const</span> d = domain.<span class="hljs-title function_">create</span>();
+d.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">er</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Caught error!'</span>, er);
 });
-d.run(<span class="hljs-function">() =></span> {
-  process.nextTick(<span class="hljs-function">() =></span> {
+d.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
     <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> { <span class="hljs-comment">// Simulating some various async stuff</span>
-      fs.open(<span class="hljs-string">'non-existent file'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">er, fd</span>) =></span> {
+      fs.<span class="hljs-title function_">open</span>(<span class="hljs-string">'non-existent file'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">er, fd</span>) =></span> {
         <span class="hljs-keyword">if</span> (er) <span class="hljs-keyword">throw</span> er;
         <span class="hljs-comment">// proceed...</span>
       });
@@ -523,42 +535,78 @@ d.run(<span class="hljs-function">() =></span> {
 });</code></pre>
 <p>In this example, the <code>d.on('error')</code> handler will be triggered, rather
 than crashing the program.</p>
-<h2>Domains and promises<span><a class="mark" href="#domain_domains_and_promises" id="domain_domains_and_promises">#</a></span></h2>
+</section><section><h3>Domains and promises<span><a class="mark" href="#domain_domains_and_promises" id="domain_domains_and_promises">#</a></span></h3>
 <p>As of Node.js 8.0.0, the handlers of promises are run inside the domain in
 which the call to <code>.then()</code> or <code>.catch()</code> itself was made:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> d1 = domain.create();
-<span class="hljs-keyword">const</span> d2 = domain.create();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> d1 = domain.<span class="hljs-title function_">create</span>();
+<span class="hljs-keyword">const</span> d2 = domain.<span class="hljs-title function_">create</span>();
 
 <span class="hljs-keyword">let</span> p;
-d1.run(<span class="hljs-function">() =></span> {
-  p = <span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">42</span>);
+d1.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  p = <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">42</span>);
 });
 
-d2.run(<span class="hljs-function">() =></span> {
-  p.then(<span class="hljs-function">(<span class="hljs-params">v</span>) =></span> {
+d2.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  p.<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">v</span>) =></span> {
     <span class="hljs-comment">// running in d2</span>
   });
 });</code></pre>
 <p>A callback may be bound to a specific domain using <a href="#domain_domain_bind_callback"><code>domain.bind(callback)</code></a>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> d1 = domain.create();
-<span class="hljs-keyword">const</span> d2 = domain.create();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> d1 = domain.<span class="hljs-title function_">create</span>();
+<span class="hljs-keyword">const</span> d2 = domain.<span class="hljs-title function_">create</span>();
 
 <span class="hljs-keyword">let</span> p;
-d1.run(<span class="hljs-function">() =></span> {
-  p = <span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">42</span>);
+d1.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  p = <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">42</span>);
 });
 
-d2.run(<span class="hljs-function">() =></span> {
-  p.then(p.domain.bind(<span class="hljs-function">(<span class="hljs-params">v</span>) =></span> {
+d2.<span class="hljs-title function_">run</span>(<span class="hljs-function">() =></span> {
+  p.<span class="hljs-title function_">then</span>(p.<span class="hljs-property">domain</span>.<span class="hljs-title function_">bind</span>(<span class="hljs-function">(<span class="hljs-params">v</span>) =></span> {
     <span class="hljs-comment">// running in d1</span>
   }));
 });</code></pre>
 <p>Domains will not interfere with the error handling mechanisms for
 promises. In other words, no <code>'error'</code> event will be emitted for unhandled
-<code>Promise</code> rejections.</p>
+<code>Promise</code> rejections.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/domain.json b/doc/api/domain.json
index 47e42a7d6700dc51c9e6fb55debbfeea18be20c5..6f993d70627693c2b5097f8a06297a05647ce089 100644
--- a/doc/api/domain.json
+++ b/doc/api/domain.json
@@ -12,6 +12,7 @@
         "changes": [
           {
             "version": "v8.8.0",
+            "pr-url": "https://github.com/nodejs/node/pull/15695",
             "description": "Any `Promise`s created in VM contexts no longer have a `.domain` property. Their handlers are still executed in the proper domain, however, and `Promise`s created in the main context still possess a `.domain` property."
           },
           {
@@ -24,13 +25,13 @@
       "introduced_in": "v0.10.0",
       "stability": 0,
       "stabilityText": "Deprecated",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/domain.js\">lib/domain.js</a></p>\n<p><strong>This module is pending deprecation</strong>. Once a replacement API has been\nfinalized, this module will be fully deprecated. Most developers should\n<strong>not</strong> have cause to use this module. Users who absolutely must have\nthe functionality that domains provide may rely on it for the time being\nbut should expect to have to migrate to a different solution\nin the future.</p>\n<p>Domains provide a way to handle multiple different IO operations as a\nsingle group. If any of the event emitters or callbacks registered to a\ndomain emit an <code>'error'</code> event, or throw an error, then the domain object\nwill be notified, rather than losing the context of the error in the\n<code>process.on('uncaughtException')</code> handler, or causing the program to\nexit immediately with an error code.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/domain.js\">lib/domain.js</a></p>\n<p><strong>This module is pending deprecation</strong>. Once a replacement API has been\nfinalized, this module will be fully deprecated. Most developers should\n<strong>not</strong> have cause to use this module. Users who absolutely must have\nthe functionality that domains provide may rely on it for the time being\nbut should expect to have to migrate to a different solution\nin the future.</p>\n<p>Domains provide a way to handle multiple different IO operations as a\nsingle group. If any of the event emitters or callbacks registered to a\ndomain emit an <code>'error'</code> event, or throw an error, then the domain object\nwill be notified, rather than losing the context of the error in the\n<code>process.on('uncaughtException')</code> handler, or causing the program to\nexit immediately with an error code.</p>",
       "miscs": [
         {
           "textRaw": "Warning: Don't ignore errors!",
           "name": "Warning: Don't ignore errors!",
           "type": "misc",
-          "desc": "<p>Domain error handlers are not a substitute for closing down a\nprocess when an error occurs.</p>\n<p>By the very nature of how <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw\"><code>throw</code></a> works in JavaScript, there is almost\nnever any way to safely \"pick up where it left off\", without leaking\nreferences, or creating some other sort of undefined brittle state.</p>\n<p>The safest way to respond to a thrown error is to shut down the\nprocess. Of course, in a normal web server, there may be many\nopen connections, and it is not reasonable to abruptly shut those down\nbecause an error was triggered by someone else.</p>\n<p>The better approach is to send an error response to the request that\ntriggered the error, while letting the others finish in their normal\ntime, and stop listening for new requests in that worker.</p>\n<p>In this way, <code>domain</code> usage goes hand-in-hand with the cluster module,\nsince the master process can fork a new worker when a worker\nencounters an error. For Node.js programs that scale to multiple\nmachines, the terminating proxy or service registry can take note of\nthe failure, and react accordingly.</p>\n<p>For example, this is not a good idea:</p>\n<pre><code class=\"language-js\">// XXX WARNING! BAD IDEA!\n\nconst d = require('domain').create();\nd.on('error', (er) => {\n  // The error won't crash the process, but what it does is worse!\n  // Though we've prevented abrupt process restarting, we are leaking\n  // resources like crazy if this ever happens.\n  // This is no better than process.on('uncaughtException')!\n  console.log(`error, but oh well ${er.message}`);\n});\nd.run(() => {\n  require('http').createServer((req, res) => {\n    handleRequest(req, res);\n  }).listen(PORT);\n});\n</code></pre>\n<p>By using the context of a domain, and the resilience of separating our\nprogram into multiple worker processes, we can react more\nappropriately, and handle errors with much greater safety.</p>\n<pre><code class=\"language-js\">// Much better!\n\nconst cluster = require('cluster');\nconst PORT = +process.env.PORT || 1337;\n\nif (cluster.isMaster) {\n  // A more realistic scenario would have more than 2 workers,\n  // and perhaps not put the master and worker in the same file.\n  //\n  // It is also possible to get a bit fancier about logging, and\n  // implement whatever custom logic is needed to prevent DoS\n  // attacks and other bad behavior.\n  //\n  // See the options in the cluster documentation.\n  //\n  // The important thing is that the master does very little,\n  // increasing our resilience to unexpected errors.\n\n  cluster.fork();\n  cluster.fork();\n\n  cluster.on('disconnect', (worker) => {\n    console.error('disconnect!');\n    cluster.fork();\n  });\n\n} else {\n  // the worker\n  //\n  // This is where we put our bugs!\n\n  const domain = require('domain');\n\n  // See the cluster documentation for more details about using\n  // worker processes to serve requests. How it works, caveats, etc.\n\n  const server = require('http').createServer((req, res) => {\n    const d = domain.create();\n    d.on('error', (er) => {\n      console.error(`error ${er.stack}`);\n\n      // We're in dangerous territory!\n      // By definition, something unexpected occurred,\n      // which we probably didn't want.\n      // Anything can happen now! Be very careful!\n\n      try {\n        // Make sure we close down within 30 seconds\n        const killtimer = setTimeout(() => {\n          process.exit(1);\n        }, 30000);\n        // But don't keep the process open just for that!\n        killtimer.unref();\n\n        // Stop taking new requests.\n        server.close();\n\n        // Let the master know we're dead. This will trigger a\n        // 'disconnect' in the cluster master, and then it will fork\n        // a new worker.\n        cluster.worker.disconnect();\n\n        // Try to send an error to the request that triggered the problem\n        res.statusCode = 500;\n        res.setHeader('content-type', 'text/plain');\n        res.end('Oops, there was a problem!\\n');\n      } catch (er2) {\n        // Oh well, not much we can do at this point.\n        console.error(`Error sending 500! ${er2.stack}`);\n      }\n    });\n\n    // Because req and res were created before this domain existed,\n    // we need to explicitly add them.\n    // See the explanation of implicit vs explicit binding below.\n    d.add(req);\n    d.add(res);\n\n    // Now run the handler function in the domain.\n    d.run(() => {\n      handleRequest(req, res);\n    });\n  });\n  server.listen(PORT);\n}\n\n// This part is not important. Just an example routing thing.\n// Put fancy application logic here.\nfunction handleRequest(req, res) {\n  switch (req.url) {\n    case '/error':\n      // We do some async stuff, and then...\n      setTimeout(() => {\n        // Whoops!\n        flerb.bark();\n      }, timeout);\n      break;\n    default:\n      res.end('ok');\n  }\n}\n</code></pre>"
+          "desc": "<p>Domain error handlers are not a substitute for closing down a\nprocess when an error occurs.</p>\n<p>By the very nature of how <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw\"><code>throw</code></a> works in JavaScript, there is almost\nnever any way to safely \"pick up where it left off\", without leaking\nreferences, or creating some other sort of undefined brittle state.</p>\n<p>The safest way to respond to a thrown error is to shut down the\nprocess. Of course, in a normal web server, there may be many\nopen connections, and it is not reasonable to abruptly shut those down\nbecause an error was triggered by someone else.</p>\n<p>The better approach is to send an error response to the request that\ntriggered the error, while letting the others finish in their normal\ntime, and stop listening for new requests in that worker.</p>\n<p>In this way, <code>domain</code> usage goes hand-in-hand with the cluster module,\nsince the master process can fork a new worker when a worker\nencounters an error. For Node.js programs that scale to multiple\nmachines, the terminating proxy or service registry can take note of\nthe failure, and react accordingly.</p>\n<p>For example, this is not a good idea:</p>\n<pre><code class=\"language-js\">// XXX WARNING! BAD IDEA!\n\nconst d = require('domain').create();\nd.on('error', (er) => {\n  // The error won't crash the process, but what it does is worse!\n  // Though we've prevented abrupt process restarting, we are leaking\n  // a lot of resources if this ever happens.\n  // This is no better than process.on('uncaughtException')!\n  console.log(`error, but oh well ${er.message}`);\n});\nd.run(() => {\n  require('http').createServer((req, res) => {\n    handleRequest(req, res);\n  }).listen(PORT);\n});\n</code></pre>\n<p>By using the context of a domain, and the resilience of separating our\nprogram into multiple worker processes, we can react more\nappropriately, and handle errors with much greater safety.</p>\n<pre><code class=\"language-js\">// Much better!\n\nconst cluster = require('cluster');\nconst PORT = +process.env.PORT || 1337;\n\nif (cluster.isMaster) {\n  // A more realistic scenario would have more than 2 workers,\n  // and perhaps not put the master and worker in the same file.\n  //\n  // It is also possible to get a bit fancier about logging, and\n  // implement whatever custom logic is needed to prevent DoS\n  // attacks and other bad behavior.\n  //\n  // See the options in the cluster documentation.\n  //\n  // The important thing is that the master does very little,\n  // increasing our resilience to unexpected errors.\n\n  cluster.fork();\n  cluster.fork();\n\n  cluster.on('disconnect', (worker) => {\n    console.error('disconnect!');\n    cluster.fork();\n  });\n\n} else {\n  // the worker\n  //\n  // This is where we put our bugs!\n\n  const domain = require('domain');\n\n  // See the cluster documentation for more details about using\n  // worker processes to serve requests. How it works, caveats, etc.\n\n  const server = require('http').createServer((req, res) => {\n    const d = domain.create();\n    d.on('error', (er) => {\n      console.error(`error ${er.stack}`);\n\n      // We're in dangerous territory!\n      // By definition, something unexpected occurred,\n      // which we probably didn't want.\n      // Anything can happen now! Be very careful!\n\n      try {\n        // Make sure we close down within 30 seconds\n        const killtimer = setTimeout(() => {\n          process.exit(1);\n        }, 30000);\n        // But don't keep the process open just for that!\n        killtimer.unref();\n\n        // Stop taking new requests.\n        server.close();\n\n        // Let the master know we're dead. This will trigger a\n        // 'disconnect' in the cluster master, and then it will fork\n        // a new worker.\n        cluster.worker.disconnect();\n\n        // Try to send an error to the request that triggered the problem\n        res.statusCode = 500;\n        res.setHeader('content-type', 'text/plain');\n        res.end('Oops, there was a problem!\\n');\n      } catch (er2) {\n        // Oh well, not much we can do at this point.\n        console.error(`Error sending 500! ${er2.stack}`);\n      }\n    });\n\n    // Because req and res were created before this domain existed,\n    // we need to explicitly add them.\n    // See the explanation of implicit vs explicit binding below.\n    d.add(req);\n    d.add(res);\n\n    // Now run the handler function in the domain.\n    d.run(() => {\n      handleRequest(req, res);\n    });\n  });\n  server.listen(PORT);\n}\n\n// This part is not important. Just an example routing thing.\n// Put fancy application logic here.\nfunction handleRequest(req, res) {\n  switch (req.url) {\n    case '/error':\n      // We do some async stuff, and then...\n      setTimeout(() => {\n        // Whoops!\n        flerb.bark();\n      }, timeout);\n      break;\n    default:\n      res.end('ok');\n  }\n}\n</code></pre>"
         },
         {
           "textRaw": "Additions to `Error` objects",
diff --git a/doc/api/domain.md b/doc/api/domain.md
index 0b79ec5b37e861f3e80f2f1cf18919c86bc4bdd9..5ce428fc8823708c5a0e95268f2be075e92cbf73 100644
--- a/doc/api/domain.md
+++ b/doc/api/domain.md
@@ -3,6 +3,7 @@
 deprecated: v1.4.2
 changes:
   - version: v8.8.0
+    pr-url: https://github.com/nodejs/node/pull/15695
     description: Any `Promise`s created in VM contexts no longer have a
                  `.domain` property. Their handlers are still executed in the
                  proper domain, however, and `Promise`s created in the main
@@ -68,7 +69,7 @@ const d = require('domain').create();
 d.on('error', (er) => {
   // The error won't crash the process, but what it does is worse!
   // Though we've prevented abrupt process restarting, we are leaking
-  // resources like crazy if this ever happens.
+  // a lot of resources if this ever happens.
   // This is no better than process.on('uncaughtException')!
   console.log(`error, but oh well ${er.message}`);
 });
@@ -478,10 +479,10 @@ Domains will not interfere with the error handling mechanisms for
 promises. In other words, no `'error'` event will be emitted for unhandled
 `Promise` rejections.
 
-[`Error`]: errors.html#errors_class_error
+[`Error`]: errors.md#errors_class_error
 [`domain.add(emitter)`]: #domain_domain_add_emitter
 [`domain.bind(callback)`]: #domain_domain_bind_callback
 [`domain.exit()`]: #domain_domain_exit
-[`setInterval()`]: timers.html#timers_setinterval_callback_delay_args
-[`setTimeout()`]: timers.html#timers_settimeout_callback_delay_args
+[`setInterval()`]: timers.md#timers_setinterval_callback_delay_args
+[`setTimeout()`]: timers.md#timers_settimeout_callback_delay_args
 [`throw`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw
diff --git a/doc/api/embedding.html b/doc/api/embedding.html
index c7296f303040fb09daade78a4d2b2464b5850224..54fa4be9b659894d92f8d1783dfbdce63abbe830 100644
--- a/doc/api/embedding.html
+++ b/doc/api/embedding.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>C++ Embedder API | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>C++ embedder API | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding active">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding active">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="embedding" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,23 +115,20 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/embedding.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/embedding.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/embedding.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/embedding.html">15.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v14.x/api/embedding.html">14.x <b>LTS</b></a></li>
-<li><a href="https://nodejs.org/docs/latest-v13.x/api/embedding.html">13.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v12.x/api/embedding.html">12.x <b>LTS</b></a></li></ol>
+<li><a href="https://nodejs.org/docs/latest-v14.x/api/embedding.html">14.x <b>LTS</b></a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/embedding.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/embedding.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
-<li><a href="#embedding_c_embedder_api">C++ Embedder API</a>
+      <details id="toc" open><summary>Table of contents</summary><ul>
+<li><a href="#embedding_c_embedder_api">C++ embedder API</a>
 <ul>
 <li><a href="#embedding_example_embedding_application">Example embedding application</a>
 <ul>
@@ -127,28 +138,27 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>C++ Embedder API<span><a class="mark" href="#embedding_c_embedder_api" id="embedding_c_embedder_api">#</a></span></h1>
+        <h2>C++ embedder API<span><a class="mark" href="#embedding_c_embedder_api" id="embedding_c_embedder_api">#</a></span></h2>
 
 <p>Node.js provides a number of C++ APIs that can be used to execute JavaScript
 in a Node.js environment from other C++ software.</p>
-<p>The documentation for these APIs can be found in <a href="https://github.com/nodejs/node/blob/master/src/node.h">src/node.h</a> in the Node.js
+<p>The documentation for these APIs can be found in <a href="https://github.com/nodejs/node/blob/HEAD/src/node.h">src/node.h</a> in the Node.js
 source tree. In addition to the APIs exposed by Node.js, some required concepts
 are provided by the V8 embedder API.</p>
 <p>Because using Node.js as an embedded library is different from writing code
 that is executed by Node.js, breaking changes do not follow typical Node.js
 <a href="deprecations.html">deprecation policy</a> and may occur on each semver-major release without prior
 warning.</p>
-<h2>Example embedding application<span><a class="mark" href="#embedding_example_embedding_application" id="embedding_example_embedding_application">#</a></span></h2>
+<section><h3>Example embedding application<span><a class="mark" href="#embedding_example_embedding_application" id="embedding_example_embedding_application">#</a></span></h3>
 <p>The following sections will provide an overview over how to use these APIs
 to create an application from scratch that will perform the equivalent of
 <code>node -e &#x3C;code></code>, i.e. that will take a piece of JavaScript and run it in
 a Node.js-specific environment.</p>
-<p>The full code can be found <a href="https://github.com/nodejs/node/blob/master/test/embedding/embedtest.cc">in the Node.js source tree</a>.</p>
-<h3>Setting up per-process state<span><a class="mark" href="#embedding_setting_up_per_process_state" id="embedding_setting_up_per_process_state">#</a></span></h3>
+<p>The full code can be found <a href="https://github.com/nodejs/node/blob/HEAD/test/embedding/embedtest.cc">in the Node.js source tree</a>.</p>
+<h4>Setting up per-process state<span><a class="mark" href="#embedding_setting_up_per_process_state" id="embedding_setting_up_per_process_state">#</a></span></h4>
 <p>Node.js requires some per-process state management in order to run:</p>
 <ul>
 <li>Arguments parsing for Node.js <a href="cli.html">CLI options</a>,</li>
@@ -156,16 +166,16 @@ a Node.js-specific environment.</p>
 </ul>
 <p>The following example shows how these can be set up. Some class names are from
 the <code>node</code> and <code>v8</code> C++ namespaces, respectively.</p>
-<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-keyword">int</span> <span class="hljs-title">main</span><span class="hljs-params">(<span class="hljs-keyword">int</span> argc, <span class="hljs-keyword">char</span>** argv)</span> </span>{
-  argv = uv_setup_args(argc, argv);
-  <span class="hljs-function"><span class="hljs-built_in">std</span>::<span class="hljs-built_in">vector</span>&#x3C;<span class="hljs-built_in">std</span>::<span class="hljs-built_in">string</span>> <span class="hljs-title">args</span><span class="hljs-params">(argv, argv + argc)</span></span>;
-  <span class="hljs-built_in">std</span>::<span class="hljs-built_in">vector</span>&#x3C;<span class="hljs-built_in">std</span>::<span class="hljs-built_in">string</span>> exec_args;
-  <span class="hljs-built_in">std</span>::<span class="hljs-built_in">vector</span>&#x3C;<span class="hljs-built_in">std</span>::<span class="hljs-built_in">string</span>> errors;
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">main</span><span class="hljs-params">(<span class="hljs-type">int</span> argc, <span class="hljs-type">char</span>** argv)</span> </span>{
+  argv = <span class="hljs-built_in">uv_setup_args</span>(argc, argv);
+  <span class="hljs-function">std::vector&#x3C;std::string> <span class="hljs-title">args</span><span class="hljs-params">(argv, argv + argc)</span></span>;
+  std::vector&#x3C;std::string> exec_args;
+  std::vector&#x3C;std::string> errors;
   <span class="hljs-comment">// Parse Node.js CLI options, and print any errors that have occurred while</span>
   <span class="hljs-comment">// trying to parse them.</span>
-  <span class="hljs-keyword">int</span> exit_code = node::InitializeNodeWithArgs(&#x26;args, &#x26;exec_args, &#x26;errors);
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> <span class="hljs-built_in">std</span>::<span class="hljs-built_in">string</span>&#x26; error : errors)
-    <span class="hljs-built_in">fprintf</span>(<span class="hljs-built_in">stderr</span>, <span class="hljs-string">"%s: %s\n"</span>, args[<span class="hljs-number">0</span>].c_str(), error.c_str());
+  <span class="hljs-type">int</span> exit_code = node::<span class="hljs-built_in">InitializeNodeWithArgs</span>(&#x26;args, &#x26;exec_args, &#x26;errors);
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> std::string&#x26; error : errors)
+    <span class="hljs-built_in">fprintf</span>(stderr, <span class="hljs-string">"%s: %s\n"</span>, args[<span class="hljs-number">0</span>].<span class="hljs-built_in">c_str</span>(), error.<span class="hljs-built_in">c_str</span>());
   <span class="hljs-keyword">if</span> (exit_code != <span class="hljs-number">0</span>) {
     <span class="hljs-keyword">return</span> exit_code;
   }
@@ -174,19 +184,19 @@ the <code>node</code> and <code>v8</code> C++ namespaces, respectively.</p>
   <span class="hljs-comment">// to create a v8::Platform instance that Node.js can use when creating</span>
   <span class="hljs-comment">// Worker threads. When no `MultiIsolatePlatform` instance is present,</span>
   <span class="hljs-comment">// Worker threads are disabled.</span>
-  <span class="hljs-built_in">std</span>::<span class="hljs-built_in">unique_ptr</span>&#x3C;MultiIsolatePlatform> platform =
-      MultiIsolatePlatform::Create(<span class="hljs-number">4</span>);
-  V8::InitializePlatform(platform.get());
-  V8::Initialize();
+  std::unique_ptr&#x3C;MultiIsolatePlatform> platform =
+      MultiIsolatePlatform::<span class="hljs-built_in">Create</span>(<span class="hljs-number">4</span>);
+  V8::<span class="hljs-built_in">InitializePlatform</span>(platform.<span class="hljs-built_in">get</span>());
+  V8::<span class="hljs-built_in">Initialize</span>();
 
   <span class="hljs-comment">// See below for the contents of this function.</span>
-  <span class="hljs-keyword">int</span> ret = RunNodeInstance(platform.get(), args, exec_args);
+  <span class="hljs-type">int</span> ret = <span class="hljs-built_in">RunNodeInstance</span>(platform.<span class="hljs-built_in">get</span>(), args, exec_args);
 
-  V8::Dispose();
-  V8::ShutdownPlatform();
+  V8::<span class="hljs-built_in">Dispose</span>();
+  V8::<span class="hljs-built_in">ShutdownPlatform</span>();
   <span class="hljs-keyword">return</span> ret;
 }</code></pre>
-<h3>Per-instance state<span><a class="mark" href="#embedding_per_instance_state" id="embedding_per_instance_state">#</a></span></h3>
+<h4>Per-instance state<span><a class="mark" href="#embedding_per_instance_state" id="embedding_per_instance_state">#</a></span></h4>
 <p>Node.js has a concept of a “Node.js instance”, that is commonly being referred
 to as <code>node::Environment</code>. Each <code>node::Environment</code> is associated with:</p>
 <ul>
@@ -210,132 +220,169 @@ for tasks scheduled by the <code>v8::Isolate</code>.</p>
 <p>The <code>node::NewIsolate()</code> helper function creates a <code>v8::Isolate</code>,
 sets it up with some Node.js-specific hooks (e.g. the Node.js error handler),
 and registers it with the platform automatically.</p>
-<pre><code class="language-cpp">int RunNodeInstance(MultiIsolatePlatform* platform,
-                    const std::vector&#x3C;std::string>&#x26; args,
-                    const std::vector&#x3C;std::string>&#x26; exec_args) {
-  int exit_code = 0;
-  // Set up a libuv event loop.
-  uv_loop_t loop;
-  int ret = uv_loop_init(&#x26;loop);
-  if (ret != 0) {
-    fprintf(stderr, "%s: Failed to initialize loop: %s\n",
-            args[0].c_str(),
-            uv_err_name(ret));
-    return 1;
+<pre><code class="language-cpp"><span class="hljs-function"><span class="hljs-type">int</span> <span class="hljs-title">RunNodeInstance</span><span class="hljs-params">(MultiIsolatePlatform* platform,
+                    <span class="hljs-keyword">const</span> std::vector&#x3C;std::string>&#x26; args,
+                    <span class="hljs-keyword">const</span> std::vector&#x3C;std::string>&#x26; exec_args)</span> </span>{
+  <span class="hljs-type">int</span> exit_code = <span class="hljs-number">0</span>;
+  <span class="hljs-comment">// Set up a libuv event loop.</span>
+  <span class="hljs-type">uv_loop_t</span> loop;
+  <span class="hljs-type">int</span> ret = <span class="hljs-built_in">uv_loop_init</span>(&#x26;loop);
+  <span class="hljs-keyword">if</span> (ret != <span class="hljs-number">0</span>) {
+    <span class="hljs-built_in">fprintf</span>(stderr, <span class="hljs-string">"%s: Failed to initialize loop: %s\n"</span>,
+            args[<span class="hljs-number">0</span>].<span class="hljs-built_in">c_str</span>(),
+            <span class="hljs-built_in">uv_err_name</span>(ret));
+    <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
   }
 
   std::shared_ptr&#x3C;ArrayBufferAllocator> allocator =
-      ArrayBufferAllocator::Create();
+      ArrayBufferAllocator::<span class="hljs-built_in">Create</span>();
 
-  Isolate* isolate = NewIsolate(allocator, &#x26;loop, platform);
-  if (isolate == nullptr) {
-    fprintf(stderr, "%s: Failed to initialize V8 Isolate\n", args[0].c_str());
-    return 1;
+  Isolate* isolate = <span class="hljs-built_in">NewIsolate</span>(allocator, &#x26;loop, platform);
+  <span class="hljs-keyword">if</span> (isolate == <span class="hljs-literal">nullptr</span>) {
+    <span class="hljs-built_in">fprintf</span>(stderr, <span class="hljs-string">"%s: Failed to initialize V8 Isolate\n"</span>, args[<span class="hljs-number">0</span>].<span class="hljs-built_in">c_str</span>());
+    <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
   }
 
   {
-    Locker locker(isolate);
-    Isolate::Scope isolate_scope(isolate);
+    <span class="hljs-function">Locker <span class="hljs-title">locker</span><span class="hljs-params">(isolate)</span></span>;
+    <span class="hljs-function">Isolate::Scope <span class="hljs-title">isolate_scope</span><span class="hljs-params">(isolate)</span></span>;
 
-    // Create a node::IsolateData instance that will later be released using
-    // node::FreeIsolateData().
-    std::unique_ptr&#x3C;IsolateData, decltype(&#x26;node::FreeIsolateData)> isolate_data(
+    <span class="hljs-comment">// Create a node::IsolateData instance that will later be released using</span>
+    <span class="hljs-comment">// node::FreeIsolateData().</span>
+    <span class="hljs-function">std::unique_ptr&#x3C;IsolateData, <span class="hljs-title">decltype</span><span class="hljs-params">(&#x26;node::FreeIsolateData)</span>> <span class="hljs-title">isolate_data</span><span class="hljs-params">(
         node::CreateIsolateData(isolate, &#x26;loop, platform, allocator.get()),
-        node::FreeIsolateData);
+        node::FreeIsolateData)</span></span>;
 
-    // Set up a new v8::Context.
-    HandleScope handle_scope(isolate);
-    Local&#x3C;Context> context = node::NewContext(isolate);
-    if (context.IsEmpty()) {
-      fprintf(stderr, "%s: Failed to initialize V8 Context\n", args[0].c_str());
-      return 1;
+    <span class="hljs-comment">// Set up a new v8::Context.</span>
+    <span class="hljs-function">HandleScope <span class="hljs-title">handle_scope</span><span class="hljs-params">(isolate)</span></span>;
+    Local&#x3C;Context> context = node::<span class="hljs-built_in">NewContext</span>(isolate);
+    <span class="hljs-keyword">if</span> (context.<span class="hljs-built_in">IsEmpty</span>()) {
+      <span class="hljs-built_in">fprintf</span>(stderr, <span class="hljs-string">"%s: Failed to initialize V8 Context\n"</span>, args[<span class="hljs-number">0</span>].<span class="hljs-built_in">c_str</span>());
+      <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
     }
 
-    // The v8::Context needs to be entered when node::CreateEnvironment() and
-    // node::LoadEnvironment() are being called.
-    Context::Scope context_scope(context);
+    <span class="hljs-comment">// The v8::Context needs to be entered when node::CreateEnvironment() and</span>
+    <span class="hljs-comment">// node::LoadEnvironment() are being called.</span>
+    <span class="hljs-function">Context::Scope <span class="hljs-title">context_scope</span><span class="hljs-params">(context)</span></span>;
 
-    // Create a node::Environment instance that will later be released using
-    // node::FreeEnvironment().
-    std::unique_ptr&#x3C;Environment, decltype(&#x26;node::FreeEnvironment)> env(
+    <span class="hljs-comment">// Create a node::Environment instance that will later be released using</span>
+    <span class="hljs-comment">// node::FreeEnvironment().</span>
+    <span class="hljs-function">std::unique_ptr&#x3C;Environment, <span class="hljs-title">decltype</span><span class="hljs-params">(&#x26;node::FreeEnvironment)</span>> <span class="hljs-title">env</span><span class="hljs-params">(
         node::CreateEnvironment(isolate_data.get(), context, args, exec_args),
-        node::FreeEnvironment);
+        node::FreeEnvironment)</span></span>;
 
-    // Set up the Node.js instance for execution, and run code inside of it.
-    // There is also a variant that takes a callback and provides it with
-    // the `require` and `process` objects, so that it can manually compile
-    // and run scripts as needed.
-    // The `require` function inside this script does *not* access the file
-    // system, and can only load built-in Node.js modules.
-    // `module.createRequire()` is being used to create one that is able to
-    // load files from the disk, and uses the standard CommonJS file loader
-    // instead of the internal-only `require` function.
-    MaybeLocal&#x3C;Value> loadenv_ret = node::LoadEnvironment(
-        env.get(),
-        "const publicRequire ="
-        "  require('module').createRequire(process.cwd() + '/');"
-        "globalThis.require = publicRequire;"
-        "require('vm').runInThisContext(process.argv[1]);");
+    <span class="hljs-comment">// Set up the Node.js instance for execution, and run code inside of it.</span>
+    <span class="hljs-comment">// There is also a variant that takes a callback and provides it with</span>
+    <span class="hljs-comment">// the `require` and `process` objects, so that it can manually compile</span>
+    <span class="hljs-comment">// and run scripts as needed.</span>
+    <span class="hljs-comment">// The `require` function inside this script does *not* access the file</span>
+    <span class="hljs-comment">// system, and can only load built-in Node.js modules.</span>
+    <span class="hljs-comment">// `module.createRequire()` is being used to create one that is able to</span>
+    <span class="hljs-comment">// load files from the disk, and uses the standard CommonJS file loader</span>
+    <span class="hljs-comment">// instead of the internal-only `require` function.</span>
+    MaybeLocal&#x3C;Value> loadenv_ret = node::<span class="hljs-built_in">LoadEnvironment</span>(
+        env.<span class="hljs-built_in">get</span>(),
+        <span class="hljs-string">"const publicRequire ="</span>
+        <span class="hljs-string">"  require('module').createRequire(process.cwd() + '/');"</span>
+        <span class="hljs-string">"globalThis.require = publicRequire;"</span>
+        <span class="hljs-string">"require('vm').runInThisContext(process.argv[1]);"</span>);
 
-    if (loadenv_ret.IsEmpty())  // There has been a JS exception.
-      return 1;
+    <span class="hljs-keyword">if</span> (loadenv_ret.<span class="hljs-built_in">IsEmpty</span>())  <span class="hljs-comment">// There has been a JS exception.</span>
+      <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
 
     {
-      // SealHandleScope protects against handle leaks from callbacks.
-      SealHandleScope seal(isolate);
-      bool more;
-      do {
-        uv_run(&#x26;loop, UV_RUN_DEFAULT);
+      <span class="hljs-comment">// SealHandleScope protects against handle leaks from callbacks.</span>
+      <span class="hljs-function">SealHandleScope <span class="hljs-title">seal</span><span class="hljs-params">(isolate)</span></span>;
+      <span class="hljs-type">bool</span> more;
+      <span class="hljs-keyword">do</span> {
+        <span class="hljs-built_in">uv_run</span>(&#x26;loop, UV_RUN_DEFAULT);
 
-        // V8 tasks on background threads may end up scheduling new tasks in the
-        // foreground, which in turn can keep the event loop going. For example,
-        // WebAssembly.compile() may do so.
-        platform->DrainTasks(isolate);
+        <span class="hljs-comment">// V8 tasks on background threads may end up scheduling new tasks in the</span>
+        <span class="hljs-comment">// foreground, which in turn can keep the event loop going. For example,</span>
+        <span class="hljs-comment">// WebAssembly.compile() may do so.</span>
+        platform-><span class="hljs-built_in">DrainTasks</span>(isolate);
 
-        // If there are new tasks, continue.
-        more = uv_loop_alive(&#x26;loop);
-        if (more) continue;
+        <span class="hljs-comment">// If there are new tasks, continue.</span>
+        more = <span class="hljs-built_in">uv_loop_alive</span>(&#x26;loop);
+        <span class="hljs-keyword">if</span> (more) <span class="hljs-keyword">continue</span>;
 
-        // node::EmitBeforeExit() is used to emit the 'beforeExit' event on
-        // the `process` object.
-        node::EmitBeforeExit(env.get());
+        <span class="hljs-comment">// node::EmitProcessBeforeExit() is used to emit the 'beforeExit' event</span>
+        <span class="hljs-comment">// on the `process` object.</span>
+        <span class="hljs-keyword">if</span> (node::<span class="hljs-built_in">EmitProcessBeforeExit</span>(env.<span class="hljs-built_in">get</span>()).<span class="hljs-built_in">IsNothing</span>())
+          <span class="hljs-keyword">break</span>;
 
-        // 'beforeExit' can also schedule new work that keeps the event loop
-        // running.
-        more = uv_loop_alive(&#x26;loop);
-      } while (more == true);
+        <span class="hljs-comment">// 'beforeExit' can also schedule new work that keeps the event loop</span>
+        <span class="hljs-comment">// running.</span>
+        more = <span class="hljs-built_in">uv_loop_alive</span>(&#x26;loop);
+      } <span class="hljs-keyword">while</span> (more == <span class="hljs-literal">true</span>);
     }
 
-    // node::EmitExit() returns the current exit code.
-    exit_code = node::EmitExit(env.get());
+    <span class="hljs-comment">// node::EmitProcessExit() returns the current exit code.</span>
+    exit_code = node::<span class="hljs-built_in">EmitProcessExit</span>(env.<span class="hljs-built_in">get</span>()).<span class="hljs-built_in">FromMaybe</span>(<span class="hljs-number">1</span>);
 
-    // node::Stop() can be used to explicitly stop the event loop and keep
-    // further JavaScript from running. It can be called from any thread,
-    // and will act like worker.terminate() if called from another thread.
-    node::Stop(env.get());
+    <span class="hljs-comment">// node::Stop() can be used to explicitly stop the event loop and keep</span>
+    <span class="hljs-comment">// further JavaScript from running. It can be called from any thread,</span>
+    <span class="hljs-comment">// and will act like worker.terminate() if called from another thread.</span>
+    node::<span class="hljs-built_in">Stop</span>(env.<span class="hljs-built_in">get</span>());
   }
 
-  // Unregister the Isolate with the platform and add a listener that is called
-  // when the Platform is done cleaning up any state it had associated with
-  // the Isolate.
-  bool platform_finished = false;
-  platform->AddIsolateFinishedCallback(isolate, [](void* data) {
-    *static_cast&#x3C;bool*>(data) = true;
+  <span class="hljs-comment">// Unregister the Isolate with the platform and add a listener that is called</span>
+  <span class="hljs-comment">// when the Platform is done cleaning up any state it had associated with</span>
+  <span class="hljs-comment">// the Isolate.</span>
+  <span class="hljs-type">bool</span> platform_finished = <span class="hljs-literal">false</span>;
+  platform-><span class="hljs-built_in">AddIsolateFinishedCallback</span>(isolate, [](<span class="hljs-type">void</span>* data) {
+    *<span class="hljs-built_in">static_cast</span>&#x3C;<span class="hljs-type">bool</span>*>(data) = <span class="hljs-literal">true</span>;
   }, &#x26;platform_finished);
-  platform->UnregisterIsolate(isolate);
-  isolate->Dispose();
+  platform-><span class="hljs-built_in">UnregisterIsolate</span>(isolate);
+  isolate-><span class="hljs-built_in">Dispose</span>();
 
-  // Wait until the platform has cleaned up all relevant resources.
-  while (!platform_finished)
-    uv_run(&#x26;loop, UV_RUN_ONCE);
-  int err = uv_loop_close(&#x26;loop);
-  assert(err == 0);
+  <span class="hljs-comment">// Wait until the platform has cleaned up all relevant resources.</span>
+  <span class="hljs-keyword">while</span> (!platform_finished)
+    <span class="hljs-built_in">uv_run</span>(&#x26;loop, UV_RUN_ONCE);
+  <span class="hljs-type">int</span> err = <span class="hljs-built_in">uv_loop_close</span>(&#x26;loop);
+  <span class="hljs-built_in">assert</span>(err == <span class="hljs-number">0</span>);
 
-  return exit_code;
-}</code></pre>
+  <span class="hljs-keyword">return</span> exit_code;
+}</code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/embedding.json b/doc/api/embedding.json
index c96833f8feab6a31ae78f01067b2027630649cbc..6aade9263ad5a5a8a49ac17aa49f5c4c73f517e0 100644
--- a/doc/api/embedding.json
+++ b/doc/api/embedding.json
@@ -3,10 +3,10 @@
   "source": "doc/api/embedding.md",
   "modules": [
     {
-      "textRaw": "C++ Embedder API",
+      "textRaw": "C++ embedder API",
       "name": "c++_embedder_api",
-      "introduced_in": "v12.19.0",
-      "desc": "<p>Node.js provides a number of C++ APIs that can be used to execute JavaScript\nin a Node.js environment from other C++ software.</p>\n<p>The documentation for these APIs can be found in <a href=\"https://github.com/nodejs/node/blob/master/src/node.h\">src/node.h</a> in the Node.js\nsource tree. In addition to the APIs exposed by Node.js, some required concepts\nare provided by the V8 embedder API.</p>\n<p>Because using Node.js as an embedded library is different from writing code\nthat is executed by Node.js, breaking changes do not follow typical Node.js\n<a href=\"deprecations.html\">deprecation policy</a> and may occur on each semver-major release without prior\nwarning.</p>\n<h2>Example embedding application</h2>\n<p>The following sections will provide an overview over how to use these APIs\nto create an application from scratch that will perform the equivalent of\n<code>node -e &#x3C;code></code>, i.e. that will take a piece of JavaScript and run it in\na Node.js-specific environment.</p>\n<p>The full code can be found <a href=\"https://github.com/nodejs/node/blob/master/test/embedding/embedtest.cc\">in the Node.js source tree</a>.</p>",
+      "introduced_in": "v14.0.0",
+      "desc": "<p>Node.js provides a number of C++ APIs that can be used to execute JavaScript\nin a Node.js environment from other C++ software.</p>\n<p>The documentation for these APIs can be found in <a href=\"https://github.com/nodejs/node/blob/HEAD/src/node.h\">src/node.h</a> in the Node.js\nsource tree. In addition to the APIs exposed by Node.js, some required concepts\nare provided by the V8 embedder API.</p>\n<p>Because using Node.js as an embedded library is different from writing code\nthat is executed by Node.js, breaking changes do not follow typical Node.js\n<a href=\"deprecations.html\">deprecation policy</a> and may occur on each semver-major release without prior\nwarning.</p>\n<h2>Example embedding application</h2>\n<p>The following sections will provide an overview over how to use these APIs\nto create an application from scratch that will perform the equivalent of\n<code>node -e &#x3C;code></code>, i.e. that will take a piece of JavaScript and run it in\na Node.js-specific environment.</p>\n<p>The full code can be found <a href=\"https://github.com/nodejs/node/blob/HEAD/test/embedding/embedtest.cc\">in the Node.js source tree</a>.</p>",
       "modules": [
         {
           "textRaw": "Setting up per-process state",
@@ -18,13 +18,13 @@
         {
           "textRaw": "Per-instance state",
           "name": "per-instance_state",
-          "desc": "<p>Node.js has a concept of a “Node.js instance”, that is commonly being referred\nto as <code>node::Environment</code>. Each <code>node::Environment</code> is associated with:</p>\n<ul>\n<li>Exactly one <code>v8::Isolate</code>, i.e. one JS Engine instance,</li>\n<li>Exactly one <code>uv_loop_t</code>, i.e. one event loop, and</li>\n<li>A number of <code>v8::Context</code>s, but exactly one main <code>v8::Context</code>.</li>\n<li>One <code>node::IsolateData</code> instance that contains information that could be\nshared by multiple <code>node::Environment</code>s that use the same <code>v8::Isolate</code>.\nCurrently, no testing if performed for this scenario.</li>\n</ul>\n<p>In order to set up a <code>v8::Isolate</code>, an <code>v8::ArrayBuffer::Allocator</code> needs\nto be provided. One possible choice is the default Node.js allocator, which\ncan be created through <code>node::ArrayBufferAllocator::Create()</code>. Using the Node.js\nallocator allows minor performance optimizations when addons use the Node.js\nC++ <code>Buffer</code> API, and is required in order to track <code>ArrayBuffer</code> memory in\n<a href=\"process.html#process_process_memoryusage\"><code>process.memoryUsage()</code></a>.</p>\n<p>Additionally, each <code>v8::Isolate</code> that is used for a Node.js instance needs to\nbe registered and unregistered with the <code>MultiIsolatePlatform</code> instance, if one\nis being used, in order for the platform to know which event loop to use\nfor tasks scheduled by the <code>v8::Isolate</code>.</p>\n<p>The <code>node::NewIsolate()</code> helper function creates a <code>v8::Isolate</code>,\nsets it up with some Node.js-specific hooks (e.g. the Node.js error handler),\nand registers it with the platform automatically.</p>\n<pre><code class=\"language-cpp\">int RunNodeInstance(MultiIsolatePlatform* platform,\n                    const std::vector&#x3C;std::string>&#x26; args,\n                    const std::vector&#x3C;std::string>&#x26; exec_args) {\n  int exit_code = 0;\n  // Set up a libuv event loop.\n  uv_loop_t loop;\n  int ret = uv_loop_init(&#x26;loop);\n  if (ret != 0) {\n    fprintf(stderr, \"%s: Failed to initialize loop: %s\\n\",\n            args[0].c_str(),\n            uv_err_name(ret));\n    return 1;\n  }\n\n  std::shared_ptr&#x3C;ArrayBufferAllocator> allocator =\n      ArrayBufferAllocator::Create();\n\n  Isolate* isolate = NewIsolate(allocator, &#x26;loop, platform);\n  if (isolate == nullptr) {\n    fprintf(stderr, \"%s: Failed to initialize V8 Isolate\\n\", args[0].c_str());\n    return 1;\n  }\n\n  {\n    Locker locker(isolate);\n    Isolate::Scope isolate_scope(isolate);\n\n    // Create a node::IsolateData instance that will later be released using\n    // node::FreeIsolateData().\n    std::unique_ptr&#x3C;IsolateData, decltype(&#x26;node::FreeIsolateData)> isolate_data(\n        node::CreateIsolateData(isolate, &#x26;loop, platform, allocator.get()),\n        node::FreeIsolateData);\n\n    // Set up a new v8::Context.\n    HandleScope handle_scope(isolate);\n    Local&#x3C;Context> context = node::NewContext(isolate);\n    if (context.IsEmpty()) {\n      fprintf(stderr, \"%s: Failed to initialize V8 Context\\n\", args[0].c_str());\n      return 1;\n    }\n\n    // The v8::Context needs to be entered when node::CreateEnvironment() and\n    // node::LoadEnvironment() are being called.\n    Context::Scope context_scope(context);\n\n    // Create a node::Environment instance that will later be released using\n    // node::FreeEnvironment().\n    std::unique_ptr&#x3C;Environment, decltype(&#x26;node::FreeEnvironment)> env(\n        node::CreateEnvironment(isolate_data.get(), context, args, exec_args),\n        node::FreeEnvironment);\n\n    // Set up the Node.js instance for execution, and run code inside of it.\n    // There is also a variant that takes a callback and provides it with\n    // the `require` and `process` objects, so that it can manually compile\n    // and run scripts as needed.\n    // The `require` function inside this script does *not* access the file\n    // system, and can only load built-in Node.js modules.\n    // `module.createRequire()` is being used to create one that is able to\n    // load files from the disk, and uses the standard CommonJS file loader\n    // instead of the internal-only `require` function.\n    MaybeLocal&#x3C;Value> loadenv_ret = node::LoadEnvironment(\n        env.get(),\n        \"const publicRequire =\"\n        \"  require('module').createRequire(process.cwd() + '/');\"\n        \"globalThis.require = publicRequire;\"\n        \"require('vm').runInThisContext(process.argv[1]);\");\n\n    if (loadenv_ret.IsEmpty())  // There has been a JS exception.\n      return 1;\n\n    {\n      // SealHandleScope protects against handle leaks from callbacks.\n      SealHandleScope seal(isolate);\n      bool more;\n      do {\n        uv_run(&#x26;loop, UV_RUN_DEFAULT);\n\n        // V8 tasks on background threads may end up scheduling new tasks in the\n        // foreground, which in turn can keep the event loop going. For example,\n        // WebAssembly.compile() may do so.\n        platform->DrainTasks(isolate);\n\n        // If there are new tasks, continue.\n        more = uv_loop_alive(&#x26;loop);\n        if (more) continue;\n\n        // node::EmitBeforeExit() is used to emit the 'beforeExit' event on\n        // the `process` object.\n        node::EmitBeforeExit(env.get());\n\n        // 'beforeExit' can also schedule new work that keeps the event loop\n        // running.\n        more = uv_loop_alive(&#x26;loop);\n      } while (more == true);\n    }\n\n    // node::EmitExit() returns the current exit code.\n    exit_code = node::EmitExit(env.get());\n\n    // node::Stop() can be used to explicitly stop the event loop and keep\n    // further JavaScript from running. It can be called from any thread,\n    // and will act like worker.terminate() if called from another thread.\n    node::Stop(env.get());\n  }\n\n  // Unregister the Isolate with the platform and add a listener that is called\n  // when the Platform is done cleaning up any state it had associated with\n  // the Isolate.\n  bool platform_finished = false;\n  platform->AddIsolateFinishedCallback(isolate, [](void* data) {\n    *static_cast&#x3C;bool*>(data) = true;\n  }, &#x26;platform_finished);\n  platform->UnregisterIsolate(isolate);\n  isolate->Dispose();\n\n  // Wait until the platform has cleaned up all relevant resources.\n  while (!platform_finished)\n    uv_run(&#x26;loop, UV_RUN_ONCE);\n  int err = uv_loop_close(&#x26;loop);\n  assert(err == 0);\n\n  return exit_code;\n}\n</code></pre>",
+          "desc": "<p>Node.js has a concept of a “Node.js instance”, that is commonly being referred\nto as <code>node::Environment</code>. Each <code>node::Environment</code> is associated with:</p>\n<ul>\n<li>Exactly one <code>v8::Isolate</code>, i.e. one JS Engine instance,</li>\n<li>Exactly one <code>uv_loop_t</code>, i.e. one event loop, and</li>\n<li>A number of <code>v8::Context</code>s, but exactly one main <code>v8::Context</code>.</li>\n<li>One <code>node::IsolateData</code> instance that contains information that could be\nshared by multiple <code>node::Environment</code>s that use the same <code>v8::Isolate</code>.\nCurrently, no testing if performed for this scenario.</li>\n</ul>\n<p>In order to set up a <code>v8::Isolate</code>, an <code>v8::ArrayBuffer::Allocator</code> needs\nto be provided. One possible choice is the default Node.js allocator, which\ncan be created through <code>node::ArrayBufferAllocator::Create()</code>. Using the Node.js\nallocator allows minor performance optimizations when addons use the Node.js\nC++ <code>Buffer</code> API, and is required in order to track <code>ArrayBuffer</code> memory in\n<a href=\"process.html#process_process_memoryusage\"><code>process.memoryUsage()</code></a>.</p>\n<p>Additionally, each <code>v8::Isolate</code> that is used for a Node.js instance needs to\nbe registered and unregistered with the <code>MultiIsolatePlatform</code> instance, if one\nis being used, in order for the platform to know which event loop to use\nfor tasks scheduled by the <code>v8::Isolate</code>.</p>\n<p>The <code>node::NewIsolate()</code> helper function creates a <code>v8::Isolate</code>,\nsets it up with some Node.js-specific hooks (e.g. the Node.js error handler),\nand registers it with the platform automatically.</p>\n<pre><code class=\"language-cpp\">int RunNodeInstance(MultiIsolatePlatform* platform,\n                    const std::vector&#x3C;std::string>&#x26; args,\n                    const std::vector&#x3C;std::string>&#x26; exec_args) {\n  int exit_code = 0;\n  // Set up a libuv event loop.\n  uv_loop_t loop;\n  int ret = uv_loop_init(&#x26;loop);\n  if (ret != 0) {\n    fprintf(stderr, \"%s: Failed to initialize loop: %s\\n\",\n            args[0].c_str(),\n            uv_err_name(ret));\n    return 1;\n  }\n\n  std::shared_ptr&#x3C;ArrayBufferAllocator> allocator =\n      ArrayBufferAllocator::Create();\n\n  Isolate* isolate = NewIsolate(allocator, &#x26;loop, platform);\n  if (isolate == nullptr) {\n    fprintf(stderr, \"%s: Failed to initialize V8 Isolate\\n\", args[0].c_str());\n    return 1;\n  }\n\n  {\n    Locker locker(isolate);\n    Isolate::Scope isolate_scope(isolate);\n\n    // Create a node::IsolateData instance that will later be released using\n    // node::FreeIsolateData().\n    std::unique_ptr&#x3C;IsolateData, decltype(&#x26;node::FreeIsolateData)> isolate_data(\n        node::CreateIsolateData(isolate, &#x26;loop, platform, allocator.get()),\n        node::FreeIsolateData);\n\n    // Set up a new v8::Context.\n    HandleScope handle_scope(isolate);\n    Local&#x3C;Context> context = node::NewContext(isolate);\n    if (context.IsEmpty()) {\n      fprintf(stderr, \"%s: Failed to initialize V8 Context\\n\", args[0].c_str());\n      return 1;\n    }\n\n    // The v8::Context needs to be entered when node::CreateEnvironment() and\n    // node::LoadEnvironment() are being called.\n    Context::Scope context_scope(context);\n\n    // Create a node::Environment instance that will later be released using\n    // node::FreeEnvironment().\n    std::unique_ptr&#x3C;Environment, decltype(&#x26;node::FreeEnvironment)> env(\n        node::CreateEnvironment(isolate_data.get(), context, args, exec_args),\n        node::FreeEnvironment);\n\n    // Set up the Node.js instance for execution, and run code inside of it.\n    // There is also a variant that takes a callback and provides it with\n    // the `require` and `process` objects, so that it can manually compile\n    // and run scripts as needed.\n    // The `require` function inside this script does *not* access the file\n    // system, and can only load built-in Node.js modules.\n    // `module.createRequire()` is being used to create one that is able to\n    // load files from the disk, and uses the standard CommonJS file loader\n    // instead of the internal-only `require` function.\n    MaybeLocal&#x3C;Value> loadenv_ret = node::LoadEnvironment(\n        env.get(),\n        \"const publicRequire =\"\n        \"  require('module').createRequire(process.cwd() + '/');\"\n        \"globalThis.require = publicRequire;\"\n        \"require('vm').runInThisContext(process.argv[1]);\");\n\n    if (loadenv_ret.IsEmpty())  // There has been a JS exception.\n      return 1;\n\n    {\n      // SealHandleScope protects against handle leaks from callbacks.\n      SealHandleScope seal(isolate);\n      bool more;\n      do {\n        uv_run(&#x26;loop, UV_RUN_DEFAULT);\n\n        // V8 tasks on background threads may end up scheduling new tasks in the\n        // foreground, which in turn can keep the event loop going. For example,\n        // WebAssembly.compile() may do so.\n        platform->DrainTasks(isolate);\n\n        // If there are new tasks, continue.\n        more = uv_loop_alive(&#x26;loop);\n        if (more) continue;\n\n        // node::EmitProcessBeforeExit() is used to emit the 'beforeExit' event\n        // on the `process` object.\n        if (node::EmitProcessBeforeExit(env.get()).IsNothing())\n          break;\n\n        // 'beforeExit' can also schedule new work that keeps the event loop\n        // running.\n        more = uv_loop_alive(&#x26;loop);\n      } while (more == true);\n    }\n\n    // node::EmitProcessExit() returns the current exit code.\n    exit_code = node::EmitProcessExit(env.get()).FromMaybe(1);\n\n    // node::Stop() can be used to explicitly stop the event loop and keep\n    // further JavaScript from running. It can be called from any thread,\n    // and will act like worker.terminate() if called from another thread.\n    node::Stop(env.get());\n  }\n\n  // Unregister the Isolate with the platform and add a listener that is called\n  // when the Platform is done cleaning up any state it had associated with\n  // the Isolate.\n  bool platform_finished = false;\n  platform->AddIsolateFinishedCallback(isolate, [](void* data) {\n    *static_cast&#x3C;bool*>(data) = true;\n  }, &#x26;platform_finished);\n  platform->UnregisterIsolate(isolate);\n  isolate->Dispose();\n\n  // Wait until the platform has cleaned up all relevant resources.\n  while (!platform_finished)\n    uv_run(&#x26;loop, UV_RUN_ONCE);\n  int err = uv_loop_close(&#x26;loop);\n  assert(err == 0);\n\n  return exit_code;\n}\n</code></pre>",
           "type": "module",
           "displayName": "Per-instance state"
         }
       ],
       "type": "module",
-      "displayName": "C++ Embedder API"
+      "displayName": "C++ embedder API"
     }
   ]
 }
\ No newline at end of file
diff --git a/doc/api/embedding.md b/doc/api/embedding.md
index 9d884dae1a4818aa4a8946f4fd5f2d9233c9b7f5..7dc4a2db7fca639547f320b7f53d7ec8cb9e3e73 100644
--- a/doc/api/embedding.md
+++ b/doc/api/embedding.md
@@ -1,6 +1,6 @@
-# C++ Embedder API
+# C++ embedder API
 
-<!--introduced_in=v12.19.0-->
+<!--introduced_in=v14.0.0-->
 
 Node.js provides a number of C++ APIs that can be used to execute JavaScript
 in a Node.js environment from other C++ software.
@@ -181,9 +181,10 @@ int RunNodeInstance(MultiIsolatePlatform* platform,
         more = uv_loop_alive(&loop);
         if (more) continue;
 
-        // node::EmitBeforeExit() is used to emit the 'beforeExit' event on
-        // the `process` object.
-        node::EmitBeforeExit(env.get());
+        // node::EmitProcessBeforeExit() is used to emit the 'beforeExit' event
+        // on the `process` object.
+        if (node::EmitProcessBeforeExit(env.get()).IsNothing())
+          break;
 
         // 'beforeExit' can also schedule new work that keeps the event loop
         // running.
@@ -191,8 +192,8 @@ int RunNodeInstance(MultiIsolatePlatform* platform,
       } while (more == true);
     }
 
-    // node::EmitExit() returns the current exit code.
-    exit_code = node::EmitExit(env.get());
+    // node::EmitProcessExit() returns the current exit code.
+    exit_code = node::EmitProcessExit(env.get()).FromMaybe(1);
 
     // node::Stop() can be used to explicitly stop the event loop and keep
     // further JavaScript from running. It can be called from any thread,
@@ -220,8 +221,8 @@ int RunNodeInstance(MultiIsolatePlatform* platform,
 }
 ```
 
-[`process.memoryUsage()`]: process.html#process_process_memoryusage
-[CLI options]: cli.html
-[deprecation policy]: deprecations.html
-[embedtest.cc]: https://github.com/nodejs/node/blob/master/test/embedding/embedtest.cc
-[src/node.h]: https://github.com/nodejs/node/blob/master/src/node.h
+[CLI options]: cli.md
+[`process.memoryUsage()`]: process.md#process_process_memoryusage
+[deprecation policy]: deprecations.md
+[embedtest.cc]: https://github.com/nodejs/node/blob/HEAD/test/embedding/embedtest.cc
+[src/node.h]: https://github.com/nodejs/node/blob/HEAD/src/node.h
diff --git a/doc/api/errors.html b/doc/api/errors.html
index b89052dfeaba1f4128fe12f04e710505e0912c22..3aca479db264f61529510a1c93d0aedc6af4baf7 100644
--- a/doc/api/errors.html
+++ b/doc/api/errors.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Errors | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Errors | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors active">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="errors" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/errors.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/errors.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/errors.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/errors.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/errors.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/errors.html">13.x</a></li>
@@ -116,15 +131,13 @@
 <li><a href="https://nodejs.org/docs/latest-v4.x/api/errors.html">4.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/errors.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/errors.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#errors_errors">Errors</a>
 <ul>
 <li><a href="#errors_error_propagation_and_interception">Error propagation and interception</a>
@@ -172,6 +185,7 @@
 </li>
 <li><a href="#errors_node_js_error_codes">Node.js error codes</a>
 <ul>
+<li><a href="#errors_abort_err"><code>ABORT_ERR</code></a></li>
 <li><a href="#errors_err_ambiguous_argument"><code>ERR_AMBIGUOUS_ARGUMENT</code></a></li>
 <li><a href="#errors_err_arg_not_iterable"><code>ERR_ARG_NOT_ITERABLE</code></a></li>
 <li><a href="#errors_err_assertion"><code>ERR_ASSERTION</code></a></li>
@@ -186,9 +200,11 @@
 <li><a href="#errors_err_child_closed_before_reply"><code>ERR_CHILD_CLOSED_BEFORE_REPLY</code></a></li>
 <li><a href="#errors_err_child_process_ipc_required"><code>ERR_CHILD_PROCESS_IPC_REQUIRED</code></a></li>
 <li><a href="#errors_err_child_process_stdio_maxbuffer"><code>ERR_CHILD_PROCESS_STDIO_MAXBUFFER</code></a></li>
+<li><a href="#errors_err_closed_message_port"><code>ERR_CLOSED_MESSAGE_PORT</code></a></li>
 <li><a href="#errors_err_console_writable_stream"><code>ERR_CONSOLE_WRITABLE_STREAM</code></a></li>
-<li><a href="#errors_err_construct_call_required"><code>ERR_CONSTRUCT_CALL_REQUIRED</code></a></li>
 <li><a href="#errors_err_construct_call_invalid"><code>ERR_CONSTRUCT_CALL_INVALID</code></a></li>
+<li><a href="#errors_err_construct_call_required"><code>ERR_CONSTRUCT_CALL_REQUIRED</code></a></li>
+<li><a href="#errors_err_context_not_initialized"><code>ERR_CONTEXT_NOT_INITIALIZED</code></a></li>
 <li><a href="#errors_err_cpu_usage"><code>ERR_CPU_USAGE</code></a></li>
 <li><a href="#errors_err_crypto_custom_engine_not_supported"><code>ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED</code></a></li>
 <li><a href="#errors_err_crypto_ecdh_invalid_format"><code>ERR_CRYPTO_ECDH_INVALID_FORMAT</code></a></li>
@@ -210,6 +226,9 @@
 <li><a href="#errors_err_crypto_timing_safe_equal_length"><code>ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH</code></a></li>
 <li><a href="#errors_err_crypto_unknown_cipher"><code>ERR_CRYPTO_UNKNOWN_CIPHER</code></a></li>
 <li><a href="#errors_err_crypto_unknown_dh_group"><code>ERR_CRYPTO_UNKNOWN_DH_GROUP</code></a></li>
+<li><a href="#errors_err_dlopen_failed"><code>ERR_DLOPEN_FAILED</code></a></li>
+<li><a href="#errors_err_debugger_error"><code>ERR_DEBUGGER_ERROR</code></a></li>
+<li><a href="#errors_err_debugger_startup_error"><code>ERR_DEBUGGER_STARTUP_ERROR</code></a></li>
 <li><a href="#errors_err_dir_closed"><code>ERR_DIR_CLOSED</code></a></li>
 <li><a href="#errors_err_dir_concurrent_operation"><code>ERR_DIR_CONCURRENT_OPERATION</code></a></li>
 <li><a href="#errors_err_dns_set_servers_failed"><code>ERR_DNS_SET_SERVERS_FAILED</code></a></li>
@@ -217,8 +236,12 @@
 <li><a href="#errors_err_domain_cannot_set_uncaught_exception_capture"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a></li>
 <li><a href="#errors_err_encoding_invalid_encoded_data"><code>ERR_ENCODING_INVALID_ENCODED_DATA</code></a></li>
 <li><a href="#errors_err_encoding_not_supported"><code>ERR_ENCODING_NOT_SUPPORTED</code></a></li>
+<li><a href="#errors_err_eval_esm_cannot_print"><code>ERR_EVAL_ESM_CANNOT_PRINT</code></a></li>
+<li><a href="#errors_err_event_recursion"><code>ERR_EVENT_RECURSION</code></a></li>
 <li><a href="#errors_err_execution_environment_not_available"><code>ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE</code></a></li>
 <li><a href="#errors_err_falsy_value_rejection"><code>ERR_FALSY_VALUE_REJECTION</code></a></li>
+<li><a href="#errors_err_feature_unavailable_on_platform"><code>ERR_FEATURE_UNAVAILABLE_ON_PLATFORM</code></a></li>
+<li><a href="#errors_err_fs_eisdir"><code>ERR_FS_EISDIR</code></a></li>
 <li><a href="#errors_err_fs_file_too_large"><code>ERR_FS_FILE_TOO_LARGE</code></a></li>
 <li><a href="#errors_err_fs_invalid_symlink_type"><code>ERR_FS_INVALID_SYMLINK_TYPE</code></a></li>
 <li><a href="#errors_err_http_headers_sent"><code>ERR_HTTP_HEADERS_SENT</code></a></li>
@@ -232,9 +255,9 @@
 <li><a href="#errors_err_http2_connect_scheme"><code>ERR_HTTP2_CONNECT_SCHEME</code></a></li>
 <li><a href="#errors_err_http2_error"><code>ERR_HTTP2_ERROR</code></a></li>
 <li><a href="#errors_err_http2_goaway_session"><code>ERR_HTTP2_GOAWAY_SESSION</code></a></li>
+<li><a href="#errors_err_http2_header_single_value"><code>ERR_HTTP2_HEADER_SINGLE_VALUE</code></a></li>
 <li><a href="#errors_err_http2_headers_after_respond"><code>ERR_HTTP2_HEADERS_AFTER_RESPOND</code></a></li>
 <li><a href="#errors_err_http2_headers_sent"><code>ERR_HTTP2_HEADERS_SENT</code></a></li>
-<li><a href="#errors_err_http2_header_single_value"><code>ERR_HTTP2_HEADER_SINGLE_VALUE</code></a></li>
 <li><a href="#errors_err_http2_info_status_not_allowed"><code>ERR_HTTP2_INFO_STATUS_NOT_ALLOWED</code></a></li>
 <li><a href="#errors_err_http2_invalid_connection_headers"><code>ERR_HTTP2_INVALID_CONNECTION_HEADERS</code></a></li>
 <li><a href="#errors_err_http2_invalid_header_value"><code>ERR_HTTP2_INVALID_HEADER_VALUE</code></a></li>
@@ -247,6 +270,7 @@
 <li><a href="#errors_err_http2_invalid_stream"><code>ERR_HTTP2_INVALID_STREAM</code></a></li>
 <li><a href="#errors_err_http2_max_pending_settings_ack"><code>ERR_HTTP2_MAX_PENDING_SETTINGS_ACK</code></a></li>
 <li><a href="#errors_err_http2_nested_push"><code>ERR_HTTP2_NESTED_PUSH</code></a></li>
+<li><a href="#errors_err_http2_no_mem"><code>ERR_HTTP2_NO_MEM</code></a></li>
 <li><a href="#errors_err_http2_no_socket_manipulation"><code>ERR_HTTP2_NO_SOCKET_MANIPULATION</code></a></li>
 <li><a href="#errors_err_http2_origin_length"><code>ERR_HTTP2_ORIGIN_LENGTH</code></a></li>
 <li><a href="#errors_err_http2_out_of_streams"><code>ERR_HTTP2_OUT_OF_STREAMS</code></a></li>
@@ -269,9 +293,8 @@
 <li><a href="#errors_err_http2_trailers_already_sent"><code>ERR_HTTP2_TRAILERS_ALREADY_SENT</code></a></li>
 <li><a href="#errors_err_http2_trailers_not_ready"><code>ERR_HTTP2_TRAILERS_NOT_READY</code></a></li>
 <li><a href="#errors_err_http2_unsupported_protocol"><code>ERR_HTTP2_UNSUPPORTED_PROTOCOL</code></a></li>
-<li><a href="#errors_err_internal_assertion"><code>ERR_INTERNAL_ASSERTION</code></a></li>
 <li><a href="#errors_err_incompatible_option_pair"><code>ERR_INCOMPATIBLE_OPTION_PAIR</code></a></li>
-<li><a href="#errors_err_input_type_not_allowed"><code>ERR_INPUT_TYPE_NOT_ALLOWED</code></a></li>
+<li><span class="stability_1"><a href="#errors_err_input_type_not_allowed"><code>ERR_INPUT_TYPE_NOT_ALLOWED</code></a></span></li>
 <li><a href="#errors_err_inspector_already_activated"><code>ERR_INSPECTOR_ALREADY_ACTIVATED</code></a></li>
 <li><a href="#errors_err_inspector_already_connected"><code>ERR_INSPECTOR_ALREADY_CONNECTED</code></a></li>
 <li><a href="#errors_err_inspector_closed"><code>ERR_INSPECTOR_CLOSED</code></a></li>
@@ -280,6 +303,7 @@
 <li><a href="#errors_err_inspector_not_available"><code>ERR_INSPECTOR_NOT_AVAILABLE</code></a></li>
 <li><a href="#errors_err_inspector_not_connected"><code>ERR_INSPECTOR_NOT_CONNECTED</code></a></li>
 <li><a href="#errors_err_inspector_not_worker"><code>ERR_INSPECTOR_NOT_WORKER</code></a></li>
+<li><a href="#errors_err_internal_assertion"><code>ERR_INTERNAL_ASSERTION</code></a></li>
 <li><a href="#errors_err_invalid_address_family"><code>ERR_INVALID_ADDRESS_FAMILY</code></a></li>
 <li><a href="#errors_err_invalid_arg_type"><code>ERR_INVALID_ARG_TYPE</code></a></li>
 <li><a href="#errors_err_invalid_arg_value"><code>ERR_INVALID_ARG_VALUE</code></a></li>
@@ -295,6 +319,7 @@
 <li><a href="#errors_err_invalid_handle_type"><code>ERR_INVALID_HANDLE_TYPE</code></a></li>
 <li><a href="#errors_err_invalid_http_token"><code>ERR_INVALID_HTTP_TOKEN</code></a></li>
 <li><a href="#errors_err_invalid_ip_address"><code>ERR_INVALID_IP_ADDRESS</code></a></li>
+<li><a href="#errors_err_invalid_module"><code>ERR_INVALID_MODULE</code></a></li>
 <li><a href="#errors_err_invalid_module_specifier"><code>ERR_INVALID_MODULE_SPECIFIER</code></a></li>
 <li><a href="#errors_err_invalid_opt_value"><code>ERR_INVALID_OPT_VALUE</code></a></li>
 <li><a href="#errors_err_invalid_opt_value_encoding"><code>ERR_INVALID_OPT_VALUE_ENCODING</code></a></li>
@@ -322,6 +347,7 @@
 <li><a href="#errors_err_manifest_dependency_missing"><code>ERR_MANIFEST_DEPENDENCY_MISSING</code></a></li>
 <li><a href="#errors_err_manifest_integrity_mismatch"><code>ERR_MANIFEST_INTEGRITY_MISMATCH</code></a></li>
 <li><a href="#errors_err_manifest_invalid_resource_field"><code>ERR_MANIFEST_INVALID_RESOURCE_FIELD</code></a></li>
+<li><a href="#errors_err_manifest_invalid_specifier"><code>ERR_MANIFEST_INVALID_SPECIFIER</code></a></li>
 <li><a href="#errors_err_manifest_parse_policy"><code>ERR_MANIFEST_PARSE_POLICY</code></a></li>
 <li><a href="#errors_err_manifest_tdz"><code>ERR_MANIFEST_TDZ</code></a></li>
 <li><a href="#errors_err_manifest_unknown_onerror"><code>ERR_MANIFEST_UNKNOWN_ONERROR</code></a></li>
@@ -329,12 +355,11 @@
 <li><a href="#errors_err_message_target_context_unavailable"><code>ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE</code></a></li>
 <li><a href="#errors_err_method_not_implemented"><code>ERR_METHOD_NOT_IMPLEMENTED</code></a></li>
 <li><a href="#errors_err_missing_args"><code>ERR_MISSING_ARGS</code></a></li>
-<li><a href="#errors_err_missing_dynamic_instantiate_hook"><code>ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK</code></a></li>
-<li><a href="#errors_err_missing_option"><code>ERR_MISSING_OPTION</code></a></li>
 <li><a href="#errors_err_missing_message_port_in_transfer_list"><code>ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST</code></a></li>
+<li><a href="#errors_err_missing_option"><code>ERR_MISSING_OPTION</code></a></li>
 <li><a href="#errors_err_missing_passphrase"><code>ERR_MISSING_PASSPHRASE</code></a></li>
 <li><a href="#errors_err_missing_platform_for_worker"><code>ERR_MISSING_PLATFORM_FOR_WORKER</code></a></li>
-<li><a href="#errors_err_module_not_found"><code>ERR_MODULE_NOT_FOUND</code></a></li>
+<li><span class="stability_1"><a href="#errors_err_module_not_found"><code>ERR_MODULE_NOT_FOUND</code></a></span></li>
 <li><a href="#errors_err_multiple_callback"><code>ERR_MULTIPLE_CALLBACK</code></a></li>
 <li><a href="#errors_err_napi_cons_function"><code>ERR_NAPI_CONS_FUNCTION</code></a></li>
 <li><a href="#errors_err_napi_invalid_dataview_args"><code>ERR_NAPI_INVALID_DATAVIEW_ARGS</code></a></li>
@@ -347,11 +372,12 @@
 <li><a href="#errors_err_no_crypto"><code>ERR_NO_CRYPTO</code></a></li>
 <li><a href="#errors_err_no_icu"><code>ERR_NO_ICU</code></a></li>
 <li><a href="#errors_err_non_context_aware_disabled"><code>ERR_NON_CONTEXT_AWARE_DISABLED</code></a></li>
+<li><a href="#errors_err_operation_failed"><code>ERR_OPERATION_FAILED</code></a></li>
 <li><a href="#errors_err_out_of_range"><code>ERR_OUT_OF_RANGE</code></a></li>
 <li><a href="#errors_err_package_import_not_defined"><code>ERR_PACKAGE_IMPORT_NOT_DEFINED</code></a></li>
 <li><a href="#errors_err_package_path_not_exported"><code>ERR_PACKAGE_PATH_NOT_EXPORTED</code></a></li>
 <li><a href="#errors_err_proto_access"><code>ERR_PROTO_ACCESS</code></a></li>
-<li><a href="#errors_err_require_esm"><code>ERR_REQUIRE_ESM</code></a></li>
+<li><span class="stability_1"><a href="#errors_err_require_esm"><code>ERR_REQUIRE_ESM</code></a></span></li>
 <li><a href="#errors_err_script_execution_interrupted"><code>ERR_SCRIPT_EXECUTION_INTERRUPTED</code></a></li>
 <li><a href="#errors_err_script_execution_timeout"><code>ERR_SCRIPT_EXECUTION_TIMEOUT</code></a></li>
 <li><a href="#errors_err_server_already_listen"><code>ERR_SERVER_ALREADY_LISTEN</code></a></li>
@@ -361,12 +387,12 @@
 <li><a href="#errors_err_socket_bad_port"><code>ERR_SOCKET_BAD_PORT</code></a></li>
 <li><a href="#errors_err_socket_bad_type"><code>ERR_SOCKET_BAD_TYPE</code></a></li>
 <li><a href="#errors_err_socket_buffer_size"><code>ERR_SOCKET_BUFFER_SIZE</code></a></li>
-<li><a href="#errors_err_socket_cannot_send"><code>ERR_SOCKET_CANNOT_SEND</code></a></li>
 <li><a href="#errors_err_socket_closed"><code>ERR_SOCKET_CLOSED</code></a></li>
 <li><a href="#errors_err_socket_dgram_is_connected"><code>ERR_SOCKET_DGRAM_IS_CONNECTED</code></a></li>
 <li><a href="#errors_err_socket_dgram_not_connected"><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code></a></li>
 <li><a href="#errors_err_socket_dgram_not_running"><code>ERR_SOCKET_DGRAM_NOT_RUNNING</code></a></li>
 <li><a href="#errors_err_sri_parse"><code>ERR_SRI_PARSE</code></a></li>
+<li><a href="#errors_err_stream_already_finished"><code>ERR_STREAM_ALREADY_FINISHED</code></a></li>
 <li><a href="#errors_err_stream_cannot_pipe"><code>ERR_STREAM_CANNOT_PIPE</code></a></li>
 <li><a href="#errors_err_stream_destroyed"><code>ERR_STREAM_DESTROYED</code></a></li>
 <li><a href="#errors_err_stream_null_values"><code>ERR_STREAM_NULL_VALUES</code></a></li>
@@ -378,22 +404,22 @@
 <li><a href="#errors_err_string_too_long"><code>ERR_STRING_TOO_LONG</code></a></li>
 <li><a href="#errors_err_synthetic"><code>ERR_SYNTHETIC</code></a></li>
 <li><a href="#errors_err_system_error"><code>ERR_SYSTEM_ERROR</code></a></li>
+<li><a href="#errors_err_tls_cert_altname_format"><code>ERR_TLS_CERT_ALTNAME_FORMAT</code></a></li>
 <li><a href="#errors_err_tls_cert_altname_invalid"><code>ERR_TLS_CERT_ALTNAME_INVALID</code></a></li>
 <li><a href="#errors_err_tls_dh_param_size"><code>ERR_TLS_DH_PARAM_SIZE</code></a></li>
 <li><a href="#errors_err_tls_handshake_timeout"><code>ERR_TLS_HANDSHAKE_TIMEOUT</code></a></li>
 <li><a href="#errors_err_tls_invalid_context"><code>ERR_TLS_INVALID_CONTEXT</code></a></li>
-<li><a href="#errors_err_tls_invalid_state"><code>ERR_TLS_INVALID_STATE</code></a></li>
 <li><a href="#errors_err_tls_invalid_protocol_method"><code>ERR_TLS_INVALID_PROTOCOL_METHOD</code></a></li>
 <li><a href="#errors_err_tls_invalid_protocol_version"><code>ERR_TLS_INVALID_PROTOCOL_VERSION</code></a></li>
+<li><a href="#errors_err_tls_invalid_state"><code>ERR_TLS_INVALID_STATE</code></a></li>
 <li><a href="#errors_err_tls_protocol_version_conflict"><code>ERR_TLS_PROTOCOL_VERSION_CONFLICT</code></a></li>
+<li><a href="#errors_err_tls_psk_set_identiy_hint_failed"><code>ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED</code></a></li>
 <li><a href="#errors_err_tls_renegotiation_disabled"><code>ERR_TLS_RENEGOTIATION_DISABLED</code></a></li>
 <li><a href="#errors_err_tls_required_server_name"><code>ERR_TLS_REQUIRED_SERVER_NAME</code></a></li>
 <li><a href="#errors_err_tls_session_attack"><code>ERR_TLS_SESSION_ATTACK</code></a></li>
 <li><a href="#errors_err_tls_sni_from_server"><code>ERR_TLS_SNI_FROM_SERVER</code></a></li>
-<li><a href="#errors_err_tls_psk_set_identiy_hint_failed"><code>ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED</code></a></li>
 <li><a href="#errors_err_trace_events_category_required"><code>ERR_TRACE_EVENTS_CATEGORY_REQUIRED</code></a></li>
 <li><a href="#errors_err_trace_events_unavailable"><code>ERR_TRACE_EVENTS_UNAVAILABLE</code></a></li>
-<li><a href="#errors_err_transferring_externalized_sharedarraybuffer"><code>ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER</code></a></li>
 <li><a href="#errors_err_transform_already_transforming"><code>ERR_TRANSFORM_ALREADY_TRANSFORMING</code></a></li>
 <li><a href="#errors_err_transform_with_length_0"><code>ERR_TRANSFORM_WITH_LENGTH_0</code></a></li>
 <li><a href="#errors_err_tty_init_failed"><code>ERR_TTY_INIT_FAILED</code></a></li>
@@ -404,8 +430,8 @@
 <li><a href="#errors_err_unknown_builtin_module"><code>ERR_UNKNOWN_BUILTIN_MODULE</code></a></li>
 <li><a href="#errors_err_unknown_credential"><code>ERR_UNKNOWN_CREDENTIAL</code></a></li>
 <li><a href="#errors_err_unknown_encoding"><code>ERR_UNKNOWN_ENCODING</code></a></li>
-<li><a href="#errors_err_unknown_file_extension"><code>ERR_UNKNOWN_FILE_EXTENSION</code></a></li>
-<li><a href="#errors_err_unknown_module_format"><code>ERR_UNKNOWN_MODULE_FORMAT</code></a></li>
+<li><span class="stability_1"><a href="#errors_err_unknown_file_extension"><code>ERR_UNKNOWN_FILE_EXTENSION</code></a></span></li>
+<li><span class="stability_1"><a href="#errors_err_unknown_module_format"><code>ERR_UNKNOWN_MODULE_FORMAT</code></a></span></li>
 <li><a href="#errors_err_unknown_signal"><code>ERR_UNKNOWN_SIGNAL</code></a></li>
 <li><a href="#errors_err_unsupported_dir_import"><code>ERR_UNSUPPORTED_DIR_IMPORT</code></a></li>
 <li><a href="#errors_err_unsupported_esm_url_scheme"><code>ERR_UNSUPPORTED_ESM_URL_SCHEME</code></a></li>
@@ -416,6 +442,7 @@
 <li><a href="#errors_err_vm_module_cannot_create_cached_data"><code>ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA</code></a></li>
 <li><a href="#errors_err_vm_module_different_context"><code>ERR_VM_MODULE_DIFFERENT_CONTEXT</code></a></li>
 <li><a href="#errors_err_vm_module_linking_errored"><code>ERR_VM_MODULE_LINKING_ERRORED</code></a></li>
+<li><a href="#errors_err_vm_module_link_failure"><code>ERR_VM_MODULE_LINK_FAILURE</code></a></li>
 <li><a href="#errors_err_vm_module_not_module"><code>ERR_VM_MODULE_NOT_MODULE</code></a></li>
 <li><a href="#errors_err_vm_module_status"><code>ERR_VM_MODULE_STATUS</code></a></li>
 <li><a href="#errors_err_wasi_already_started"><code>ERR_WASI_ALREADY_STARTED</code></a></li>
@@ -434,10 +461,9 @@
 <li><a href="#errors_module_not_found"><code>MODULE_NOT_FOUND</code></a></li>
 </ul>
 </li>
-<li><a href="#errors_legacy_node_js_error_codes">Legacy Node.js error codes</a>
+<li><span class="stability_0"><a href="#errors_legacy_node_js_error_codes">Legacy Node.js error codes</a></span>
 <ul>
 <li><a href="#errors_err_cannot_transfer_object"><code>ERR_CANNOT_TRANSFER_OBJECT</code></a></li>
-<li><a href="#errors_err_closed_message_port"><code>ERR_CLOSED_MESSAGE_PORT</code></a></li>
 <li><a href="#errors_err_crypto_hash_digest_no_utf16"><code>ERR_CRYPTO_HASH_DIGEST_NO_UTF16</code></a></li>
 <li><a href="#errors_err_http2_frame_error"><code>ERR_HTTP2_FRAME_ERROR</code></a></li>
 <li><a href="#errors_err_http2_headers_object"><code>ERR_HTTP2_HEADERS_OBJECT</code></a></li>
@@ -445,16 +471,18 @@
 <li><a href="#errors_err_http2_info_headers_after_respond"><code>ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND</code></a></li>
 <li><a href="#errors_err_http2_stream_closed"><code>ERR_HTTP2_STREAM_CLOSED</code></a></li>
 <li><a href="#errors_err_http_invalid_char"><code>ERR_HTTP_INVALID_CHAR</code></a></li>
+<li><a href="#errors_err_http_request_timeout"><code>ERR_HTTP_REQUEST_TIMEOUT</code></a></li>
 <li><a href="#errors_err_index_out_of_range"><code>ERR_INDEX_OUT_OF_RANGE</code></a></li>
 <li><a href="#errors_err_napi_cons_prototype_object"><code>ERR_NAPI_CONS_PROTOTYPE_OBJECT</code></a></li>
 <li><a href="#errors_err_no_longer_supported"><code>ERR_NO_LONGER_SUPPORTED</code></a></li>
 <li><a href="#errors_err_outofmemory"><code>ERR_OUTOFMEMORY</code></a></li>
 <li><a href="#errors_err_parse_history_data"><code>ERR_PARSE_HISTORY_DATA</code></a></li>
+<li><a href="#errors_err_socket_cannot_send"><code>ERR_SOCKET_CANNOT_SEND</code></a></li>
 <li><a href="#errors_err_stderr_close"><code>ERR_STDERR_CLOSE</code></a></li>
 <li><a href="#errors_err_stdout_close"><code>ERR_STDOUT_CLOSE</code></a></li>
 <li><a href="#errors_err_stream_read_not_implemented"><code>ERR_STREAM_READ_NOT_IMPLEMENTED</code></a></li>
 <li><a href="#errors_err_tls_renegotiation_failed"><code>ERR_TLS_RENEGOTIATION_FAILED</code></a></li>
-<li><a href="#errors_err_unknown_builtin_module_1"><code>ERR_UNKNOWN_BUILTIN_MODULE</code></a></li>
+<li><a href="#errors_err_transferring_externalized_sharedarraybuffer"><code>ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER</code></a></li>
 <li><a href="#errors_err_unknown_stdin_type"><code>ERR_UNKNOWN_STDIN_TYPE</code></a></li>
 <li><a href="#errors_err_unknown_stream_type"><code>ERR_UNKNOWN_STREAM_TYPE</code></a></li>
 <li><a href="#errors_err_v8breakiterator"><code>ERR_V8BREAKITERATOR</code></a></li>
@@ -465,11 +493,10 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Errors<span><a class="mark" href="#errors_errors" id="errors_errors">#</a></span></h1>
+        <h2>Errors<span><a class="mark" href="#errors_errors" id="errors_errors">#</a></span></h2>
 
 
 <p>Applications running in Node.js will generally experience four categories of
@@ -488,7 +515,7 @@ are raised typically by the <code>assert</code> module.</li>
 <p>All JavaScript and system errors raised by Node.js inherit from, or are
 instances of, the standard JavaScript <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> class and are guaranteed
 to provide <em>at least</em> the properties available on that class.</p>
-<h2>Error propagation and interception<span><a class="mark" href="#errors_error_propagation_and_interception" id="errors_error_propagation_and_interception">#</a></span></h2>
+<section><h3>Error propagation and interception<span><a class="mark" href="#errors_error_propagation_and_interception" id="errors_error_propagation_and_interception">#</a></span></h3>
 
 <p>Node.js supports several mechanisms for propagating and handling errors that
 occur while an application is running. How these errors are reported and
@@ -520,9 +547,9 @@ that should be handled.</li>
 </ul>
 <!-- eslint-disable no-useless-return -->
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-fs.readFile(<span class="hljs-string">'a file that does not exist'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+fs.<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'a file that does not exist'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'There was an error reading the file!'</span>, err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'There was an error reading the file!'</span>, err);
     <span class="hljs-keyword">return</span>;
   }
   <span class="hljs-comment">// Otherwise handle the data</span>
@@ -532,17 +559,17 @@ fs.readFile(<span class="hljs-string">'a file that does not exist'</span>, <span
 <p>When an asynchronous method is called on an object that is an
 <a href="events.html#events_class_eventemitter"><code>EventEmitter</code></a>, errors can be routed to that object's <code>'error'</code> event.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-<span class="hljs-keyword">const</span> connection = net.connect(<span class="hljs-string">'localhost'</span>);
+<span class="hljs-keyword">const</span> connection = net.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'localhost'</span>);
 
 <span class="hljs-comment">// Adding an 'error' event handler to a stream:</span>
-connection.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+connection.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-comment">// If the connection is reset by the server, or if it can't</span>
   <span class="hljs-comment">// connect at all, or on any sort of error encountered by</span>
   <span class="hljs-comment">// the connection, the error will be sent here.</span>
-  <span class="hljs-built_in">console</span>.error(err);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
 });
 
-connection.pipe(process.stdout);</code></pre>
+connection.<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
 </li>
 <li>
 <p>A handful of typically asynchronous methods in the Node.js API may still
@@ -561,19 +588,19 @@ provided, the error will be thrown, causing the Node.js process to report an
 uncaught exception and crash unless either: The <a href="domain.html"><code>domain</code></a> module is
 used appropriately or a handler has been registered for the
 <a href="process.html#process_event_uncaughtexception"><code>'uncaughtException'</code></a> event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-setImmediate(<span class="hljs-function">() =></span> {
+<span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// This will crash the process because no 'error' event</span>
   <span class="hljs-comment">// handler has been added.</span>
-  ee.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'This will crash'</span>));
+  ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'This will crash'</span>));
 });</code></pre>
 <p>Errors generated in this way <em>cannot</em> be intercepted using <code>try…catch</code> as
 they are thrown <em>after</em> the calling code has already exited.</p>
 <p>Developers must refer to the documentation for each method to determine
 exactly how errors raised by those methods are propagated.</p>
-<h3>Error-first callbacks<span><a class="mark" href="#errors_error_first_callbacks" id="errors_error_first_callbacks">#</a></span></h3>
+<h4>Error-first callbacks<span><a class="mark" href="#errors_error_first_callbacks" id="errors_error_first_callbacks">#</a></span></h4>
 
 <p>Most asynchronous methods exposed by the Node.js core API follow an idiomatic
 pattern referred to as an <em>error-first callback</em>. With this pattern, a callback
@@ -583,16 +610,16 @@ completes or an error is raised, the callback function is called with the
 the first argument will be passed as <code>null</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">errorFirstCallback</span>(<span class="hljs-params">err, data</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">errorFirstCallback</span>(<span class="hljs-params">err, data</span>) {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'There was an error'</span>, err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'There was an error'</span>, err);
     <span class="hljs-keyword">return</span>;
   }
-  <span class="hljs-built_in">console</span>.log(data);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
 }
 
-fs.readFile(<span class="hljs-string">'/some/file/that/does-not-exist'</span>, errorFirstCallback);
-fs.readFile(<span class="hljs-string">'/some/file/that/does-exist'</span>, errorFirstCallback);</code></pre>
+fs.<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/some/file/that/does-not-exist'</span>, errorFirstCallback);
+fs.<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/some/file/that/does-exist'</span>, errorFirstCallback);</code></pre>
 <p>The JavaScript <code>try…catch</code> mechanism <strong>cannot</strong> be used to intercept errors
 generated by asynchronous APIs. A common mistake for beginners is to try to
 use <code>throw</code> inside an error-first callback:</p>
@@ -600,7 +627,7 @@ use <code>throw</code> inside an error-first callback:</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">try</span> {
-  fs.readFile(<span class="hljs-string">'/some/file/that/does-not-exist'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+  fs.<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/some/file/that/does-not-exist'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
     <span class="hljs-comment">// Mistaken assumption: throwing here...</span>
     <span class="hljs-keyword">if</span> (err) {
       <span class="hljs-keyword">throw</span> err;
@@ -608,7 +635,7 @@ use <code>throw</code> inside an error-first callback:</p>
   });
 } <span class="hljs-keyword">catch</span> (err) {
   <span class="hljs-comment">// This will not catch the throw!</span>
-  <span class="hljs-built_in">console</span>.error(err);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
 }</code></pre>
 <p>This will not work because the callback function passed to <code>fs.readFile()</code> is
 called asynchronously. By the time the callback has been called, the
@@ -616,7 +643,7 @@ surrounding code, including the <code>try…catch</code> block, will have alread
 Throwing an error inside the callback <strong>can crash the Node.js process</strong> in most
 cases. If <a href="domain.html">domains</a> are enabled, or a handler has been registered with
 <code>process.on('uncaughtException')</code>, such errors can be intercepted.</p>
-<h2>Class: <code>Error</code><span><a class="mark" href="#errors_class_error" id="errors_class_error">#</a></span></h2>
+</section><section><h3>Class: <code>Error</code><span><a class="mark" href="#errors_class_error" id="errors_class_error">#</a></span></h3>
 
 <p>A generic JavaScript <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> object that does not denote any specific
 circumstance of why the error occurred. <code>Error</code> objects capture a "stack trace"
@@ -624,7 +651,7 @@ detailing the point in the code at which the <code>Error</code> was instantiated
 provide a text description of the error.</p>
 <p>All errors generated by Node.js, including all system and JavaScript errors,
 will either be instances of, or inherit from, the <code>Error</code> class.</p>
-<h3><code>new Error(message)</code><span><a class="mark" href="#errors_new_error_message" id="errors_new_error_message">#</a></span></h3>
+<h4><code>new Error(message)</code><span><a class="mark" href="#errors_new_error_message" id="errors_new_error_message">#</a></span></h4>
 <ul>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -635,7 +662,7 @@ represent the point in the code at which <code>new Error()</code> was called. St
 are dependent on <a href="https://github.com/v8/v8/wiki/Stack-Trace-API">V8's stack trace API</a>. Stack traces extend only to either
 (a) the beginning of <em>synchronous code execution</em>, or (b) the number of frames
 given by the property <code>Error.stackTraceLimit</code>, whichever is smaller.</p>
-<h3><code>Error.captureStackTrace(targetObject[, constructorOpt])</code><span><a class="mark" href="#errors_error_capturestacktrace_targetobject_constructoropt" id="errors_error_capturestacktrace_targetobject_constructoropt">#</a></span></h3>
+<h4><code>Error.captureStackTrace(targetObject[, constructorOpt])</code><span><a class="mark" href="#errors_error_capturestacktrace_targetobject_constructoropt" id="errors_error_capturestacktrace_targetobject_constructoropt">#</a></span></h4>
 <ul>
 <li><code>targetObject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>constructorOpt</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
@@ -644,8 +671,8 @@ given by the property <code>Error.stackTraceLimit</code>, whichever is smaller.<
 a string representing the location in the code at which
 <code>Error.captureStackTrace()</code> was called.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> myObject = {};
-<span class="hljs-built_in">Error</span>.captureStackTrace(myObject);
-myObject.stack;  <span class="hljs-comment">// Similar to `new Error().stack`</span></code></pre>
+<span class="hljs-title class_">Error</span>.<span class="hljs-title function_">captureStackTrace</span>(myObject);
+myObject.<span class="hljs-property">stack</span>;  <span class="hljs-comment">// Similar to `new Error().stack`</span></code></pre>
 <p>The first line of the trace will be prefixed with
 <code>${myObject.name}: ${myObject.message}</code>.</p>
 <p>The optional <code>constructorOpt</code> argument accepts a function. If given, all frames
@@ -653,15 +680,15 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
 generated stack trace.</p>
 <p>The <code>constructorOpt</code> argument is useful for hiding implementation
 details of error generation from the user. For instance:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyError</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">Error</span>.captureStackTrace(<span class="hljs-built_in">this</span>, MyError);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">MyError</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-title class_">Error</span>.<span class="hljs-title function_">captureStackTrace</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-title class_">MyError</span>);
 }
 
 <span class="hljs-comment">// Without passing MyError to captureStackTrace, the MyError</span>
 <span class="hljs-comment">// frame would show up in the .stack property. By passing</span>
 <span class="hljs-comment">// the constructor, we omit that frame, and retain all frames below it.</span>
-<span class="hljs-keyword">new</span> MyError().stack;</code></pre>
-<h3><code>Error.stackTraceLimit</code><span><a class="mark" href="#errors_error_stacktracelimit" id="errors_error_stacktracelimit">#</a></span></h3>
+<span class="hljs-keyword">new</span> <span class="hljs-title class_">MyError</span>().<span class="hljs-property">stack</span>;</code></pre>
+<h4><code>Error.stackTraceLimit</code><span><a class="mark" href="#errors_error_stacktracelimit" id="errors_error_stacktracelimit">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
@@ -672,7 +699,7 @@ collected by a stack trace (whether generated by <code>new Error().stack</code>
 will affect any stack trace captured <em>after</em> the value has been changed.</p>
 <p>If set to a non-number value, or set to a negative number, stack traces will
 not capture any frames.</p>
-<h3><code>error.code</code><span><a class="mark" href="#errors_error_code" id="errors_error_code">#</a></span></h3>
+<h4><code>error.code</code><span><a class="mark" href="#errors_error_code" id="errors_error_code">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -681,7 +708,7 @@ not capture any frames.</p>
 between major versions of Node.js. In contrast, <code>error.message</code> strings may
 change between any versions of Node.js. See <a href="#nodejs-error-codes">Node.js error codes</a> for details
 about specific codes.</p>
-<h3><code>error.message</code><span><a class="mark" href="#errors_error_message" id="errors_error_message">#</a></span></h3>
+<h4><code>error.message</code><span><a class="mark" href="#errors_error_message" id="errors_error_message">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -691,10 +718,10 @@ appear in the first line of the stack trace of the <code>Error</code>, however c
 this property after the <code>Error</code> object is created <em>may not</em> change the first
 line of the stack trace (for example, when <code>error.stack</code> is read before this
 property is changed).</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'The message'</span>);
-<span class="hljs-built_in">console</span>.error(err.message);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'The message'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err.<span class="hljs-property">message</span>);
 <span class="hljs-comment">// Prints: The message</span></code></pre>
-<h3><code>error.stack</code><span><a class="mark" href="#errors_error_stack" id="errors_error_stack">#</a></span></h3>
+<h4><code>error.stack</code><span><a class="mark" href="#errors_error_stack" id="errors_error_stack">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -720,14 +747,14 @@ itself calls a JavaScript function, the frame representing the <code>cheetahify<
 will not be present in the stack traces:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> cheetahify = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./native-binding.node'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">makeFaster</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">makeFaster</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// `cheetahify()` *synchronously* calls speedy.</span>
-  cheetahify(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">speedy</span>(<span class="hljs-params"></span>) </span>{
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'oh no!'</span>);
+  <span class="hljs-title function_">cheetahify</span>(<span class="hljs-keyword">function</span> <span class="hljs-title function_">speedy</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'oh no!'</span>);
   });
 }
 
-makeFaster();
+<span class="hljs-title function_">makeFaster</span>();
 <span class="hljs-comment">// will throw:</span>
 <span class="hljs-comment">//   /home/gbusey/file.js:6</span>
 <span class="hljs-comment">//       throw new Error('oh no!');</span>
@@ -756,24 +783,24 @@ a user program, or its dependencies.</li>
 <p>The number of frames captured by the stack trace is bounded by the smaller of
 <code>Error.stackTraceLimit</code> or the number of available frames on the current event
 loop tick.</p>
-<h2>Class: <code>AssertionError</code><span><a class="mark" href="#errors_class_assertionerror" id="errors_class_assertionerror">#</a></span></h2>
+</section><section><h3>Class: <code>AssertionError</code><span><a class="mark" href="#errors_class_assertionerror" id="errors_class_assertionerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="errors.html#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
 <p>Indicates the failure of an assertion. For details, see
 <a href="assert.html#assert_class_assert_assertionerror"><code>Class: assert.AssertionError</code></a>.</p>
-<h2>Class: <code>RangeError</code><span><a class="mark" href="#errors_class_rangeerror" id="errors_class_rangeerror">#</a></span></h2>
+</section><section><h3>Class: <code>RangeError</code><span><a class="mark" href="#errors_class_rangeerror" id="errors_class_rangeerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="errors.html#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
 <p>Indicates that a provided argument was not within the set or range of
 acceptable values for a function; whether that is a numeric range, or
 outside the set of options for a given function parameter.</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).connect(<span class="hljs-number">-1</span>);
+<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-title function_">connect</span>(-<span class="hljs-number">1</span>);
 <span class="hljs-comment">// Throws "RangeError: "port" option should be >= 0 and &#x3C; 65536: -1"</span></code></pre>
 <p>Node.js will generate and throw <code>RangeError</code> instances <em>immediately</em> as a form
 of argument validation.</p>
-<h2>Class: <code>ReferenceError</code><span><a class="mark" href="#errors_class_referenceerror" id="errors_class_referenceerror">#</a></span></h2>
+</section><section><h3>Class: <code>ReferenceError</code><span><a class="mark" href="#errors_class_referenceerror" id="errors_class_referenceerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="errors.html#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
@@ -786,7 +813,7 @@ will do so.</p>
 <span class="hljs-comment">// Throws ReferenceError, doesNotExist is not a variable in this program.</span></code></pre>
 <p>Unless an application is dynamically generating and running code,
 <code>ReferenceError</code> instances indicate a bug in the code or its dependencies.</p>
-<h2>Class: <code>SyntaxError</code><span><a class="mark" href="#errors_class_syntaxerror" id="errors_class_syntaxerror">#</a></span></h2>
+</section><section><h3>Class: <code>SyntaxError</code><span><a class="mark" href="#errors_class_syntaxerror" id="errors_class_syntaxerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="errors.html#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
@@ -795,13 +822,13 @@ generated and propagated as a result of code evaluation. Code evaluation may
 happen as a result of <code>eval</code>, <code>Function</code>, <code>require</code>, or <a href="vm.html">vm</a>. These errors
 are almost always indicative of a broken program.</p>
 <pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>).runInThisContext(<span class="hljs-string">'binary ! isNotOk'</span>);
+  <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>).<span class="hljs-title function_">runInThisContext</span>(<span class="hljs-string">'binary ! isNotOk'</span>);
 } <span class="hljs-keyword">catch</span> (err) {
   <span class="hljs-comment">// 'err' will be a SyntaxError.</span>
 }</code></pre>
 <p><code>SyntaxError</code> instances are unrecoverable in the context that created them –
 they may only be caught by other contexts.</p>
-<h2>Class: <code>SystemError</code><span><a class="mark" href="#errors_class_systemerror" id="errors_class_systemerror">#</a></span></h2>
+</section><section><h3>Class: <code>SystemError</code><span><a class="mark" href="#errors_class_systemerror" id="errors_class_systemerror">#</a></span></h3>
 <ul>
 <li>Extends: <a href="errors.html#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
@@ -815,65 +842,65 @@ failed</li>
 <li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The string error code</li>
 <li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If present, the file path destination when reporting a file
 system error</li>
-<li><code>errno</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The system-provided error number</li>
+<li><code>errno</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The system-provided error number</li>
 <li><code>info</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> If present, extra details about the error condition</li>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A system-provided human-readable description of the error</li>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If present, the file path when reporting a file system error</li>
 <li><code>port</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> If present, the network connection port that is not available</li>
 <li><code>syscall</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The name of the system call that triggered the error</li>
 </ul>
-<h3><code>error.address</code><span><a class="mark" href="#errors_error_address" id="errors_error_address">#</a></span></h3>
+<h4><code>error.address</code><span><a class="mark" href="#errors_error_address" id="errors_error_address">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>If present, <code>error.address</code> is a string describing the address to which a
 network connection failed.</p>
-<h3><code>error.code</code><span><a class="mark" href="#errors_error_code_1" id="errors_error_code_1">#</a></span></h3>
+<h4><code>error.code</code><span><a class="mark" href="#errors_error_code_1" id="errors_error_code_1">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The <code>error.code</code> property is a string representing the error code.</p>
-<h3><code>error.dest</code><span><a class="mark" href="#errors_error_dest" id="errors_error_dest">#</a></span></h3>
+<h4><code>error.dest</code><span><a class="mark" href="#errors_error_dest" id="errors_error_dest">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>If present, <code>error.dest</code> is the file path destination when reporting a file
 system error.</p>
-<h3><code>error.errno</code><span><a class="mark" href="#errors_error_errno" id="errors_error_errno">#</a></span></h3>
+<h4><code>error.errno</code><span><a class="mark" href="#errors_error_errno" id="errors_error_errno">#</a></span></h4>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>The <code>error.errno</code> property is a number or a string. If it is a number, it is a
-negative value which corresponds to the error code defined in
-<a href="https://docs.libuv.org/en/v1.x/errors.html"><code>libuv Error handling</code></a>. See the libuv <code>errno.h</code> header file
-(<code>deps/uv/include/uv/errno.h</code> in the Node.js source tree) for details. In case
-of a string, it is the same as <code>error.code</code>.</p>
-<h3><code>error.info</code><span><a class="mark" href="#errors_error_info" id="errors_error_info">#</a></span></h3>
+<p>The <code>error.errno</code> property is a negative number which corresponds
+to the error code defined in <a href="https://docs.libuv.org/en/v1.x/errors.html"><code>libuv Error handling</code></a>.</p>
+<p>On Windows the error number provided by the system will be normalized by libuv.</p>
+<p>To get the string representation of the error code, use
+<a href="util.html#util_util_getsystemerrorname_err"><code>util.getSystemErrorName(error.errno)</code></a>.</p>
+<h4><code>error.info</code><span><a class="mark" href="#errors_error_info" id="errors_error_info">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>If present, <code>error.info</code> is an object with details about the error condition.</p>
-<h3><code>error.message</code><span><a class="mark" href="#errors_error_message_1" id="errors_error_message_1">#</a></span></h3>
+<h4><code>error.message</code><span><a class="mark" href="#errors_error_message_1" id="errors_error_message_1">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p><code>error.message</code> is a system-provided human-readable description of the error.</p>
-<h3><code>error.path</code><span><a class="mark" href="#errors_error_path" id="errors_error_path">#</a></span></h3>
+<h4><code>error.path</code><span><a class="mark" href="#errors_error_path" id="errors_error_path">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>If present, <code>error.path</code> is a string containing a relevant invalid pathname.</p>
-<h3><code>error.port</code><span><a class="mark" href="#errors_error_port" id="errors_error_port">#</a></span></h3>
+<h4><code>error.port</code><span><a class="mark" href="#errors_error_port" id="errors_error_port">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>If present, <code>error.port</code> is the network connection port that is not available.</p>
-<h3><code>error.syscall</code><span><a class="mark" href="#errors_error_syscall" id="errors_error_syscall">#</a></span></h3>
+<h4><code>error.syscall</code><span><a class="mark" href="#errors_error_syscall" id="errors_error_syscall">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The <code>error.syscall</code> property is a string describing the <a href="https://man7.org/linux/man-pages/man2/syscalls.2.html">syscall</a> that failed.</p>
-<h3>Common system errors<span><a class="mark" href="#errors_common_system_errors" id="errors_common_system_errors">#</a></span></h3>
+<h4>Common system errors<span><a class="mark" href="#errors_common_system_errors" id="errors_common_system_errors">#</a></span></h4>
 <p>This is a list of system errors commonly-encountered when writing a Node.js
 program. For a comprehensive list, see the <a href="https://man7.org/linux/man-pages/man3/errno.3.html"><code>errno</code>(3) man page</a>.</p>
 <ul>
@@ -948,17 +975,17 @@ encountered by <a href="http.html"><code>http</code></a> or <a href="net.html"><
 was not properly called.</p>
 </li>
 </ul>
-<h2>Class: <code>TypeError</code><span><a class="mark" href="#errors_class_typeerror" id="errors_class_typeerror">#</a></span></h2>
+</section><section><h3>Class: <code>TypeError</code><span><a class="mark" href="#errors_class_typeerror" id="errors_class_typeerror">#</a></span></h3>
 <ul>
 <li>Extends <a href="errors.html#errors_class_error" class="type">&#x3C;errors.Error></a></li>
 </ul>
 <p>Indicates that a provided argument is not an allowable type. For example,
 passing a function to a parameter which expects a string would be a <code>TypeError</code>.</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>).parse(<span class="hljs-function">() =></span> { });
+<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>).<span class="hljs-title function_">parse</span>(<span class="hljs-function">() =></span> { });
 <span class="hljs-comment">// Throws TypeError, since it expected a string.</span></code></pre>
 <p>Node.js will generate and throw <code>TypeError</code> instances <em>immediately</em> as a form
 of argument validation.</p>
-<h2>Exceptions vs. errors<span><a class="mark" href="#errors_exceptions_vs_errors" id="errors_exceptions_vs_errors">#</a></span></h2>
+</section><section><h3>Exceptions vs. errors<span><a class="mark" href="#errors_exceptions_vs_errors" id="errors_exceptions_vs_errors">#</a></span></h3>
 
 <p>A JavaScript exception is a value that is thrown as a result of an invalid
 operation or as the target of a <code>throw</code> statement. While it is not required
@@ -968,23 +995,32 @@ instances of <code>Error</code>.</p>
 <p>Some exceptions are <em>unrecoverable</em> at the JavaScript layer. Such exceptions
 will <em>always</em> cause the Node.js process to crash. Examples include <code>assert()</code>
 checks or <code>abort()</code> calls in the C++ layer.</p>
-<h2>OpenSSL errors<span><a class="mark" href="#errors_openssl_errors" id="errors_openssl_errors">#</a></span></h2>
+</section><section><h3>OpenSSL errors<span><a class="mark" href="#errors_openssl_errors" id="errors_openssl_errors">#</a></span></h3>
 <p>Errors originating in <code>crypto</code> or <code>tls</code> are of class <code>Error</code>, and in addition to
 the standard <code>.code</code> and <code>.message</code> properties, may have some additional
 OpenSSL-specific properties.</p>
-<h3><code>error.opensslErrorStack</code><span><a class="mark" href="#errors_error_opensslerrorstack" id="errors_error_opensslerrorstack">#</a></span></h3>
+<h4><code>error.opensslErrorStack</code><span><a class="mark" href="#errors_error_opensslerrorstack" id="errors_error_opensslerrorstack">#</a></span></h4>
 <p>An array of errors that can give context to where in the OpenSSL library an
 error originates from.</p>
-<h3><code>error.function</code><span><a class="mark" href="#errors_error_function" id="errors_error_function">#</a></span></h3>
+<h4><code>error.function</code><span><a class="mark" href="#errors_error_function" id="errors_error_function">#</a></span></h4>
 <p>The OpenSSL function the error originates in.</p>
-<h3><code>error.library</code><span><a class="mark" href="#errors_error_library" id="errors_error_library">#</a></span></h3>
+<h4><code>error.library</code><span><a class="mark" href="#errors_error_library" id="errors_error_library">#</a></span></h4>
 <p>The OpenSSL library the error originates in.</p>
-<h3><code>error.reason</code><span><a class="mark" href="#errors_error_reason" id="errors_error_reason">#</a></span></h3>
+<h4><code>error.reason</code><span><a class="mark" href="#errors_error_reason" id="errors_error_reason">#</a></span></h4>
 <p>A human-readable string describing the reason for the error.</p>
 <p><a id="nodejs-error-codes"></a></p>
-<h2>Node.js error codes<span><a class="mark" href="#errors_node_js_error_codes" id="errors_node_js_error_codes">#</a></span></h2>
+</section><section><h3>Node.js error codes<span><a class="mark" href="#errors_node_js_error_codes" id="errors_node_js_error_codes">#</a></span></h3>
+<p><a id="ABORT_ERR"></a></p>
+<h4><code>ABORT_ERR</code><span><a class="mark" href="#errors_abort_err" id="errors_abort_err">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>Used when an operation has been aborted (typically using an <code>AbortController</code>).</p>
+<p>APIs <em>not</em> using <code>AbortSignal</code>s typically do not raise an error with this code.</p>
+<p>This code does not use the regular <code>ERR_*</code> convention Node.js errors use in
+order to be compatible with the web platform's <code>AbortError</code>.</p>
 <p><a id="ERR_AMBIGUOUS_ARGUMENT"></a></p>
-<h3><code>ERR_AMBIGUOUS_ARGUMENT</code><span><a class="mark" href="#errors_err_ambiguous_argument" id="errors_err_ambiguous_argument">#</a></span></h3>
+<h4><code>ERR_AMBIGUOUS_ARGUMENT</code><span><a class="mark" href="#errors_err_ambiguous_argument" id="errors_err_ambiguous_argument">#</a></span></h4>
 <p>A function argument is being used in a way that suggests that the function
 signature may be misunderstood. This is thrown by the <code>assert</code> module when the
 <code>message</code> parameter in <code>assert.throws(block, message)</code> matches the error message
@@ -992,30 +1028,30 @@ thrown by <code>block</code> because that usage suggests that the user believes
 is the expected message rather than the message the <code>AssertionError</code> will
 display if <code>block</code> does not throw.</p>
 <p><a id="ERR_ARG_NOT_ITERABLE"></a></p>
-<h3><code>ERR_ARG_NOT_ITERABLE</code><span><a class="mark" href="#errors_err_arg_not_iterable" id="errors_err_arg_not_iterable">#</a></span></h3>
+<h4><code>ERR_ARG_NOT_ITERABLE</code><span><a class="mark" href="#errors_err_arg_not_iterable" id="errors_err_arg_not_iterable">#</a></span></h4>
 <p>An iterable argument (i.e. a value that works with <code>for...of</code> loops) was
 required, but not provided to a Node.js API.</p>
 <p><a id="ERR_ASSERTION"></a></p>
-<h3><code>ERR_ASSERTION</code><span><a class="mark" href="#errors_err_assertion" id="errors_err_assertion">#</a></span></h3>
+<h4><code>ERR_ASSERTION</code><span><a class="mark" href="#errors_err_assertion" id="errors_err_assertion">#</a></span></h4>
 <p>A special type of error that can be triggered whenever Node.js detects an
 exceptional logic violation that should never occur. These are raised typically
 by the <code>assert</code> module.</p>
 <p><a id="ERR_ASYNC_CALLBACK"></a></p>
-<h3><code>ERR_ASYNC_CALLBACK</code><span><a class="mark" href="#errors_err_async_callback" id="errors_err_async_callback">#</a></span></h3>
+<h4><code>ERR_ASYNC_CALLBACK</code><span><a class="mark" href="#errors_err_async_callback" id="errors_err_async_callback">#</a></span></h4>
 <p>An attempt was made to register something that is not a function as an
 <code>AsyncHooks</code> callback.</p>
 <p><a id="ERR_ASYNC_TYPE"></a></p>
-<h3><code>ERR_ASYNC_TYPE</code><span><a class="mark" href="#errors_err_async_type" id="errors_err_async_type">#</a></span></h3>
+<h4><code>ERR_ASYNC_TYPE</code><span><a class="mark" href="#errors_err_async_type" id="errors_err_async_type">#</a></span></h4>
 <p>The type of an asynchronous resource was invalid. Users are also able
 to define their own types if using the public embedder API.</p>
 <p><a id="ERR_BROTLI_COMPRESSION_FAILED"></a></p>
-<h3><code>ERR_BROTLI_COMPRESSION_FAILED</code><span><a class="mark" href="#errors_err_brotli_compression_failed" id="errors_err_brotli_compression_failed">#</a></span></h3>
+<h4><code>ERR_BROTLI_COMPRESSION_FAILED</code><span><a class="mark" href="#errors_err_brotli_compression_failed" id="errors_err_brotli_compression_failed">#</a></span></h4>
 <p>Data passed to a Brotli stream was not successfully compressed.</p>
 <p><a id="ERR_BROTLI_INVALID_PARAM"></a></p>
-<h3><code>ERR_BROTLI_INVALID_PARAM</code><span><a class="mark" href="#errors_err_brotli_invalid_param" id="errors_err_brotli_invalid_param">#</a></span></h3>
+<h4><code>ERR_BROTLI_INVALID_PARAM</code><span><a class="mark" href="#errors_err_brotli_invalid_param" id="errors_err_brotli_invalid_param">#</a></span></h4>
 <p>An invalid parameter key was passed during construction of a Brotli stream.</p>
 <p><a id="ERR_BUFFER_CONTEXT_NOT_AVAILABLE"></a></p>
-<h3><code>ERR_BUFFER_CONTEXT_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_buffer_context_not_available" id="errors_err_buffer_context_not_available">#</a></span></h3>
+<h4><code>ERR_BUFFER_CONTEXT_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_buffer_context_not_available" id="errors_err_buffer_context_not_available">#</a></span></h4>
 <p>An attempt was made to create a Node.js <code>Buffer</code> instance from addon or embedder
 code, while in a JS engine Context that is not associated with a Node.js
 instance. The data passed to the <code>Buffer</code> method will have been released
@@ -1025,920 +1061,988 @@ instance is to create a normal <code>Uint8Array</code>, which only differs in th
 prototype of the resulting object. <code>Uint8Array</code>s are generally accepted in all
 Node.js core APIs where <code>Buffer</code>s are; they are available in all Contexts.</p>
 <p><a id="ERR_BUFFER_OUT_OF_BOUNDS"></a></p>
-<h3><code>ERR_BUFFER_OUT_OF_BOUNDS</code><span><a class="mark" href="#errors_err_buffer_out_of_bounds" id="errors_err_buffer_out_of_bounds">#</a></span></h3>
+<h4><code>ERR_BUFFER_OUT_OF_BOUNDS</code><span><a class="mark" href="#errors_err_buffer_out_of_bounds" id="errors_err_buffer_out_of_bounds">#</a></span></h4>
 <p>An operation outside the bounds of a <code>Buffer</code> was attempted.</p>
 <p><a id="ERR_BUFFER_TOO_LARGE"></a></p>
-<h3><code>ERR_BUFFER_TOO_LARGE</code><span><a class="mark" href="#errors_err_buffer_too_large" id="errors_err_buffer_too_large">#</a></span></h3>
+<h4><code>ERR_BUFFER_TOO_LARGE</code><span><a class="mark" href="#errors_err_buffer_too_large" id="errors_err_buffer_too_large">#</a></span></h4>
 <p>An attempt has been made to create a <code>Buffer</code> larger than the maximum allowed
 size.</p>
 <p><a id="ERR_CANNOT_WATCH_SIGINT"></a></p>
-<h3><code>ERR_CANNOT_WATCH_SIGINT</code><span><a class="mark" href="#errors_err_cannot_watch_sigint" id="errors_err_cannot_watch_sigint">#</a></span></h3>
+<h4><code>ERR_CANNOT_WATCH_SIGINT</code><span><a class="mark" href="#errors_err_cannot_watch_sigint" id="errors_err_cannot_watch_sigint">#</a></span></h4>
 <p>Node.js was unable to watch for the <code>SIGINT</code> signal.</p>
 <p><a id="ERR_CHILD_CLOSED_BEFORE_REPLY"></a></p>
-<h3><code>ERR_CHILD_CLOSED_BEFORE_REPLY</code><span><a class="mark" href="#errors_err_child_closed_before_reply" id="errors_err_child_closed_before_reply">#</a></span></h3>
+<h4><code>ERR_CHILD_CLOSED_BEFORE_REPLY</code><span><a class="mark" href="#errors_err_child_closed_before_reply" id="errors_err_child_closed_before_reply">#</a></span></h4>
 <p>A child process was closed before the parent received a reply.</p>
 <p><a id="ERR_CHILD_PROCESS_IPC_REQUIRED"></a></p>
-<h3><code>ERR_CHILD_PROCESS_IPC_REQUIRED</code><span><a class="mark" href="#errors_err_child_process_ipc_required" id="errors_err_child_process_ipc_required">#</a></span></h3>
+<h4><code>ERR_CHILD_PROCESS_IPC_REQUIRED</code><span><a class="mark" href="#errors_err_child_process_ipc_required" id="errors_err_child_process_ipc_required">#</a></span></h4>
 <p>Used when a child process is being forked without specifying an IPC channel.</p>
 <p><a id="ERR_CHILD_PROCESS_STDIO_MAXBUFFER"></a></p>
-<h3><code>ERR_CHILD_PROCESS_STDIO_MAXBUFFER</code><span><a class="mark" href="#errors_err_child_process_stdio_maxbuffer" id="errors_err_child_process_stdio_maxbuffer">#</a></span></h3>
+<h4><code>ERR_CHILD_PROCESS_STDIO_MAXBUFFER</code><span><a class="mark" href="#errors_err_child_process_stdio_maxbuffer" id="errors_err_child_process_stdio_maxbuffer">#</a></span></h4>
 <p>Used when the main process is trying to read data from the child process's
 STDERR/STDOUT, and the data's length is longer than the <code>maxBuffer</code> option.</p>
+<p><a id="ERR_CLOSED_MESSAGE_PORT"></a></p>
+<h4><code>ERR_CLOSED_MESSAGE_PORT</code><span><a class="mark" href="#errors_err_closed_message_port" id="errors_err_closed_message_port">#</a></span></h4>
+<!--
+added: v14.17.1
+changes:
+  - version: 11.12.0
+    pr-url: https://github.com/nodejs/node/pull/26487
+    description: The error message was removed.
+  - version: v14.17.1
+    pr-url: https://github.com/nodejs/node/pull/38510
+    description: The error message was reintroduced.
+-->
+<p>There was an attempt to use a <code>MessagePort</code> instance in a closed
+state, usually after <code>.close()</code> has been called.</p>
 <p><a id="ERR_CONSOLE_WRITABLE_STREAM"></a></p>
-<h3><code>ERR_CONSOLE_WRITABLE_STREAM</code><span><a class="mark" href="#errors_err_console_writable_stream" id="errors_err_console_writable_stream">#</a></span></h3>
+<h4><code>ERR_CONSOLE_WRITABLE_STREAM</code><span><a class="mark" href="#errors_err_console_writable_stream" id="errors_err_console_writable_stream">#</a></span></h4>
 <p><code>Console</code> was instantiated without <code>stdout</code> stream, or <code>Console</code> has a
 non-writable <code>stdout</code> or <code>stderr</code> stream.</p>
-<p><a id="ERR_CONSTRUCT_CALL_REQUIRED"></a></p>
-<h3><code>ERR_CONSTRUCT_CALL_REQUIRED</code><span><a class="mark" href="#errors_err_construct_call_required" id="errors_err_construct_call_required">#</a></span></h3>
-<p>A constructor for a class was called without <code>new</code>.</p>
 <p><a id="ERR_CONSTRUCT_CALL_INVALID"></a></p>
-<h3><code>ERR_CONSTRUCT_CALL_INVALID</code><span><a class="mark" href="#errors_err_construct_call_invalid" id="errors_err_construct_call_invalid">#</a></span></h3>
+<h4><code>ERR_CONSTRUCT_CALL_INVALID</code><span><a class="mark" href="#errors_err_construct_call_invalid" id="errors_err_construct_call_invalid">#</a></span></h4>
 <!--
 added: v12.5.0
 -->
 <p>A class constructor was called that is not callable.</p>
+<p><a id="ERR_CONSTRUCT_CALL_REQUIRED"></a></p>
+<h4><code>ERR_CONSTRUCT_CALL_REQUIRED</code><span><a class="mark" href="#errors_err_construct_call_required" id="errors_err_construct_call_required">#</a></span></h4>
+<p>A constructor for a class was called without <code>new</code>.</p>
+<p><a id="ERR_CONTEXT_NOT_INITIALIZED"></a></p>
+<h4><code>ERR_CONTEXT_NOT_INITIALIZED</code><span><a class="mark" href="#errors_err_context_not_initialized" id="errors_err_context_not_initialized">#</a></span></h4>
+<p>The vm context passed into the API is not yet initialized. This could happen
+when an error occurs (and is caught) during the creation of the
+context, for example, when the allocation fails or the maximum call stack
+size is reached when the context is created.</p>
 <p><a id="ERR_CPU_USAGE"></a></p>
-<h3><code>ERR_CPU_USAGE</code><span><a class="mark" href="#errors_err_cpu_usage" id="errors_err_cpu_usage">#</a></span></h3>
+<h4><code>ERR_CPU_USAGE</code><span><a class="mark" href="#errors_err_cpu_usage" id="errors_err_cpu_usage">#</a></span></h4>
 <p>The native call from <code>process.cpuUsage</code> could not be processed.</p>
 <p><a id="ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED"></a></p>
-<h3><code>ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_crypto_custom_engine_not_supported" id="errors_err_crypto_custom_engine_not_supported">#</a></span></h3>
+<h4><code>ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_crypto_custom_engine_not_supported" id="errors_err_crypto_custom_engine_not_supported">#</a></span></h4>
 <p>A client certificate engine was requested that is not supported by the version
 of OpenSSL being used.</p>
 <p><a id="ERR_CRYPTO_ECDH_INVALID_FORMAT"></a></p>
-<h3><code>ERR_CRYPTO_ECDH_INVALID_FORMAT</code><span><a class="mark" href="#errors_err_crypto_ecdh_invalid_format" id="errors_err_crypto_ecdh_invalid_format">#</a></span></h3>
+<h4><code>ERR_CRYPTO_ECDH_INVALID_FORMAT</code><span><a class="mark" href="#errors_err_crypto_ecdh_invalid_format" id="errors_err_crypto_ecdh_invalid_format">#</a></span></h4>
 <p>An invalid value for the <code>format</code> argument was passed to the <code>crypto.ECDH()</code>
 class <code>getPublicKey()</code> method.</p>
 <p><a id="ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY"></a></p>
-<h3><code>ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY</code><span><a class="mark" href="#errors_err_crypto_ecdh_invalid_public_key" id="errors_err_crypto_ecdh_invalid_public_key">#</a></span></h3>
+<h4><code>ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY</code><span><a class="mark" href="#errors_err_crypto_ecdh_invalid_public_key" id="errors_err_crypto_ecdh_invalid_public_key">#</a></span></h4>
 <p>An invalid value for the <code>key</code> argument has been passed to the
 <code>crypto.ECDH()</code> class <code>computeSecret()</code> method. It means that the public
 key lies outside of the elliptic curve.</p>
 <p><a id="ERR_CRYPTO_ENGINE_UNKNOWN"></a></p>
-<h3><code>ERR_CRYPTO_ENGINE_UNKNOWN</code><span><a class="mark" href="#errors_err_crypto_engine_unknown" id="errors_err_crypto_engine_unknown">#</a></span></h3>
+<h4><code>ERR_CRYPTO_ENGINE_UNKNOWN</code><span><a class="mark" href="#errors_err_crypto_engine_unknown" id="errors_err_crypto_engine_unknown">#</a></span></h4>
 <p>An invalid crypto engine identifier was passed to
 <a href="crypto.html#crypto_crypto_setengine_engine_flags"><code>require('crypto').setEngine()</code></a>.</p>
 <p><a id="ERR_CRYPTO_FIPS_FORCED"></a></p>
-<h3><code>ERR_CRYPTO_FIPS_FORCED</code><span><a class="mark" href="#errors_err_crypto_fips_forced" id="errors_err_crypto_fips_forced">#</a></span></h3>
+<h4><code>ERR_CRYPTO_FIPS_FORCED</code><span><a class="mark" href="#errors_err_crypto_fips_forced" id="errors_err_crypto_fips_forced">#</a></span></h4>
 <p>The <a href="cli.html#cli_force_fips"><code>--force-fips</code></a> command-line argument was used but there was an attempt
 to enable or disable FIPS mode in the <code>crypto</code> module.</p>
 <p><a id="ERR_CRYPTO_FIPS_UNAVAILABLE"></a></p>
-<h3><code>ERR_CRYPTO_FIPS_UNAVAILABLE</code><span><a class="mark" href="#errors_err_crypto_fips_unavailable" id="errors_err_crypto_fips_unavailable">#</a></span></h3>
+<h4><code>ERR_CRYPTO_FIPS_UNAVAILABLE</code><span><a class="mark" href="#errors_err_crypto_fips_unavailable" id="errors_err_crypto_fips_unavailable">#</a></span></h4>
 <p>An attempt was made to enable or disable FIPS mode, but FIPS mode was not
 available.</p>
 <p><a id="ERR_CRYPTO_HASH_FINALIZED"></a></p>
-<h3><code>ERR_CRYPTO_HASH_FINALIZED</code><span><a class="mark" href="#errors_err_crypto_hash_finalized" id="errors_err_crypto_hash_finalized">#</a></span></h3>
+<h4><code>ERR_CRYPTO_HASH_FINALIZED</code><span><a class="mark" href="#errors_err_crypto_hash_finalized" id="errors_err_crypto_hash_finalized">#</a></span></h4>
 <p><a href="crypto.html#crypto_hash_digest_encoding"><code>hash.digest()</code></a> was called multiple times. The <code>hash.digest()</code> method must
 be called no more than one time per instance of a <code>Hash</code> object.</p>
 <p><a id="ERR_CRYPTO_HASH_UPDATE_FAILED"></a></p>
-<h3><code>ERR_CRYPTO_HASH_UPDATE_FAILED</code><span><a class="mark" href="#errors_err_crypto_hash_update_failed" id="errors_err_crypto_hash_update_failed">#</a></span></h3>
+<h4><code>ERR_CRYPTO_HASH_UPDATE_FAILED</code><span><a class="mark" href="#errors_err_crypto_hash_update_failed" id="errors_err_crypto_hash_update_failed">#</a></span></h4>
 <p><a href="crypto.html#crypto_hash_update_data_inputencoding"><code>hash.update()</code></a> failed for any reason. This should rarely, if ever, happen.</p>
 <p><a id="ERR_CRYPTO_INCOMPATIBLE_KEY"></a></p>
-<h3><code>ERR_CRYPTO_INCOMPATIBLE_KEY</code><span><a class="mark" href="#errors_err_crypto_incompatible_key" id="errors_err_crypto_incompatible_key">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INCOMPATIBLE_KEY</code><span><a class="mark" href="#errors_err_crypto_incompatible_key" id="errors_err_crypto_incompatible_key">#</a></span></h4>
 <p>The given crypto keys are incompatible with the attempted operation.</p>
 <p><a id="ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS"></a></p>
-<h3><code>ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS</code><span><a class="mark" href="#errors_err_crypto_incompatible_key_options" id="errors_err_crypto_incompatible_key_options">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS</code><span><a class="mark" href="#errors_err_crypto_incompatible_key_options" id="errors_err_crypto_incompatible_key_options">#</a></span></h4>
 <p>The selected public or private key encoding is incompatible with other options.</p>
 <p><a id="ERR_CRYPTO_INVALID_DIGEST"></a></p>
-<h3><code>ERR_CRYPTO_INVALID_DIGEST</code><span><a class="mark" href="#errors_err_crypto_invalid_digest" id="errors_err_crypto_invalid_digest">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INVALID_DIGEST</code><span><a class="mark" href="#errors_err_crypto_invalid_digest" id="errors_err_crypto_invalid_digest">#</a></span></h4>
 <p>An invalid <a href="crypto.html#crypto_crypto_gethashes">crypto digest algorithm</a> was specified.</p>
 <p><a id="ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE"></a></p>
-<h3><code>ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE</code><span><a class="mark" href="#errors_err_crypto_invalid_key_object_type" id="errors_err_crypto_invalid_key_object_type">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE</code><span><a class="mark" href="#errors_err_crypto_invalid_key_object_type" id="errors_err_crypto_invalid_key_object_type">#</a></span></h4>
 <p>The given crypto key object's type is invalid for the attempted operation.</p>
 <p><a id="ERR_CRYPTO_INVALID_STATE"></a></p>
-<h3><code>ERR_CRYPTO_INVALID_STATE</code><span><a class="mark" href="#errors_err_crypto_invalid_state" id="errors_err_crypto_invalid_state">#</a></span></h3>
+<h4><code>ERR_CRYPTO_INVALID_STATE</code><span><a class="mark" href="#errors_err_crypto_invalid_state" id="errors_err_crypto_invalid_state">#</a></span></h4>
 <p>A crypto method was used on an object that was in an invalid state. For
 instance, calling <a href="crypto.html#crypto_cipher_getauthtag"><code>cipher.getAuthTag()</code></a> before calling <code>cipher.final()</code>.</p>
 <p><a id="ERR_CRYPTO_PBKDF2_ERROR"></a></p>
-<h3><code>ERR_CRYPTO_PBKDF2_ERROR</code><span><a class="mark" href="#errors_err_crypto_pbkdf2_error" id="errors_err_crypto_pbkdf2_error">#</a></span></h3>
+<h4><code>ERR_CRYPTO_PBKDF2_ERROR</code><span><a class="mark" href="#errors_err_crypto_pbkdf2_error" id="errors_err_crypto_pbkdf2_error">#</a></span></h4>
 <p>The PBKDF2 algorithm failed for unspecified reasons. OpenSSL does not provide
 more details and therefore neither does Node.js.</p>
 <p><a id="ERR_CRYPTO_SCRYPT_INVALID_PARAMETER"></a></p>
-<h3><code>ERR_CRYPTO_SCRYPT_INVALID_PARAMETER</code><span><a class="mark" href="#errors_err_crypto_scrypt_invalid_parameter" id="errors_err_crypto_scrypt_invalid_parameter">#</a></span></h3>
+<h4><code>ERR_CRYPTO_SCRYPT_INVALID_PARAMETER</code><span><a class="mark" href="#errors_err_crypto_scrypt_invalid_parameter" id="errors_err_crypto_scrypt_invalid_parameter">#</a></span></h4>
 <p>One or more <a href="crypto.html#crypto_crypto_scrypt_password_salt_keylen_options_callback"><code>crypto.scrypt()</code></a> or <a href="crypto.html#crypto_crypto_scryptsync_password_salt_keylen_options"><code>crypto.scryptSync()</code></a> parameters are
 outside their legal range.</p>
 <p><a id="ERR_CRYPTO_SCRYPT_NOT_SUPPORTED"></a></p>
-<h3><code>ERR_CRYPTO_SCRYPT_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_crypto_scrypt_not_supported" id="errors_err_crypto_scrypt_not_supported">#</a></span></h3>
+<h4><code>ERR_CRYPTO_SCRYPT_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_crypto_scrypt_not_supported" id="errors_err_crypto_scrypt_not_supported">#</a></span></h4>
 <p>Node.js was compiled without <code>scrypt</code> support. Not possible with the official
 release binaries but can happen with custom builds, including distro builds.</p>
 <p><a id="ERR_CRYPTO_SIGN_KEY_REQUIRED"></a></p>
-<h3><code>ERR_CRYPTO_SIGN_KEY_REQUIRED</code><span><a class="mark" href="#errors_err_crypto_sign_key_required" id="errors_err_crypto_sign_key_required">#</a></span></h3>
+<h4><code>ERR_CRYPTO_SIGN_KEY_REQUIRED</code><span><a class="mark" href="#errors_err_crypto_sign_key_required" id="errors_err_crypto_sign_key_required">#</a></span></h4>
 <p>A signing <code>key</code> was not provided to the <a href="crypto.html#crypto_sign_sign_privatekey_outputencoding"><code>sign.sign()</code></a> method.</p>
 <p><a id="ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH"></a></p>
-<h3><code>ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH</code><span><a class="mark" href="#errors_err_crypto_timing_safe_equal_length" id="errors_err_crypto_timing_safe_equal_length">#</a></span></h3>
+<h4><code>ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH</code><span><a class="mark" href="#errors_err_crypto_timing_safe_equal_length" id="errors_err_crypto_timing_safe_equal_length">#</a></span></h4>
 <p><a href="crypto.html#crypto_crypto_timingsafeequal_a_b"><code>crypto.timingSafeEqual()</code></a> was called with <code>Buffer</code>, <code>TypedArray</code>, or
 <code>DataView</code> arguments of different lengths.</p>
 <p><a id="ERR_CRYPTO_UNKNOWN_CIPHER"></a></p>
-<h3><code>ERR_CRYPTO_UNKNOWN_CIPHER</code><span><a class="mark" href="#errors_err_crypto_unknown_cipher" id="errors_err_crypto_unknown_cipher">#</a></span></h3>
+<h4><code>ERR_CRYPTO_UNKNOWN_CIPHER</code><span><a class="mark" href="#errors_err_crypto_unknown_cipher" id="errors_err_crypto_unknown_cipher">#</a></span></h4>
 <p>An unknown cipher was specified.</p>
 <p><a id="ERR_CRYPTO_UNKNOWN_DH_GROUP"></a></p>
-<h3><code>ERR_CRYPTO_UNKNOWN_DH_GROUP</code><span><a class="mark" href="#errors_err_crypto_unknown_dh_group" id="errors_err_crypto_unknown_dh_group">#</a></span></h3>
+<h4><code>ERR_CRYPTO_UNKNOWN_DH_GROUP</code><span><a class="mark" href="#errors_err_crypto_unknown_dh_group" id="errors_err_crypto_unknown_dh_group">#</a></span></h4>
 <p>An unknown Diffie-Hellman group name was given. See
 <a href="crypto.html#crypto_crypto_getdiffiehellman_groupname"><code>crypto.getDiffieHellman()</code></a> for a list of valid group names.</p>
+<p><a id="ERR_DLOPEN_FAILED"></a></p>
+<h4><code>ERR_DLOPEN_FAILED</code><span><a class="mark" href="#errors_err_dlopen_failed" id="errors_err_dlopen_failed">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>A call to <code>process.dlopen()</code> failed.</p>
+<p><a id="ERR_DEBUGGER_ERROR"></a></p>
+<h4><code>ERR_DEBUGGER_ERROR</code><span><a class="mark" href="#errors_err_debugger_error" id="errors_err_debugger_error">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.4</span>
+</div>
+<p>An error occurred with the <a href="debugger.html">debugger</a>.</p>
+<p><a id="ERR_DEBUGGER_STARTUP_ERROR"></a></p>
+<h4><code>ERR_DEBUGGER_STARTUP_ERROR</code><span><a class="mark" href="#errors_err_debugger_startup_error" id="errors_err_debugger_startup_error">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.4</span>
+</div>
+<p>The <a href="debugger.html">debugger</a> timed out waiting for the required host/port to be free.</p>
 <p><a id="ERR_DIR_CLOSED"></a></p>
-<h3><code>ERR_DIR_CLOSED</code><span><a class="mark" href="#errors_err_dir_closed" id="errors_err_dir_closed">#</a></span></h3>
+<h4><code>ERR_DIR_CLOSED</code><span><a class="mark" href="#errors_err_dir_closed" id="errors_err_dir_closed">#</a></span></h4>
 <p>The <a href="fs.html#fs_class_fs_dir"><code>fs.Dir</code></a> was previously closed.</p>
 <p><a id="ERR_DIR_CONCURRENT_OPERATION"></a></p>
-<h3><code>ERR_DIR_CONCURRENT_OPERATION</code><span><a class="mark" href="#errors_err_dir_concurrent_operation" id="errors_err_dir_concurrent_operation">#</a></span></h3>
+<h4><code>ERR_DIR_CONCURRENT_OPERATION</code><span><a class="mark" href="#errors_err_dir_concurrent_operation" id="errors_err_dir_concurrent_operation">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.18.1</span>
+<span>Added in: v14.3.0</span>
 </div>
 <p>A synchronous read or close call was attempted on an <a href="fs.html#fs_class_fs_dir"><code>fs.Dir</code></a> which has
 ongoing asynchronous operations.</p>
 <p><a id="ERR_DNS_SET_SERVERS_FAILED"></a></p>
-<h3><code>ERR_DNS_SET_SERVERS_FAILED</code><span><a class="mark" href="#errors_err_dns_set_servers_failed" id="errors_err_dns_set_servers_failed">#</a></span></h3>
+<h4><code>ERR_DNS_SET_SERVERS_FAILED</code><span><a class="mark" href="#errors_err_dns_set_servers_failed" id="errors_err_dns_set_servers_failed">#</a></span></h4>
 <p><code>c-ares</code> failed to set the DNS server.</p>
 <p><a id="ERR_DOMAIN_CALLBACK_NOT_AVAILABLE"></a></p>
-<h3><code>ERR_DOMAIN_CALLBACK_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_domain_callback_not_available" id="errors_err_domain_callback_not_available">#</a></span></h3>
+<h4><code>ERR_DOMAIN_CALLBACK_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_domain_callback_not_available" id="errors_err_domain_callback_not_available">#</a></span></h4>
 <p>The <code>domain</code> module was not usable since it could not establish the required
 error handling hooks, because
 <a href="process.html#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> had been called at an
 earlier point in time.</p>
 <p><a id="ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE"></a></p>
-<h3><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code><span><a class="mark" href="#errors_err_domain_cannot_set_uncaught_exception_capture" id="errors_err_domain_cannot_set_uncaught_exception_capture">#</a></span></h3>
+<h4><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code><span><a class="mark" href="#errors_err_domain_cannot_set_uncaught_exception_capture" id="errors_err_domain_cannot_set_uncaught_exception_capture">#</a></span></h4>
 <p><a href="process.html#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> could not be called
 because the <code>domain</code> module has been loaded at an earlier point in time.</p>
 <p>The stack trace is extended to include the point in time at which the
 <code>domain</code> module had been loaded.</p>
 <p><a id="ERR_ENCODING_INVALID_ENCODED_DATA"></a></p>
-<h3><code>ERR_ENCODING_INVALID_ENCODED_DATA</code><span><a class="mark" href="#errors_err_encoding_invalid_encoded_data" id="errors_err_encoding_invalid_encoded_data">#</a></span></h3>
+<h4><code>ERR_ENCODING_INVALID_ENCODED_DATA</code><span><a class="mark" href="#errors_err_encoding_invalid_encoded_data" id="errors_err_encoding_invalid_encoded_data">#</a></span></h4>
 <p>Data provided to <code>TextDecoder()</code> API was invalid according to the encoding
 provided.</p>
 <p><a id="ERR_ENCODING_NOT_SUPPORTED"></a></p>
-<h3><code>ERR_ENCODING_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_encoding_not_supported" id="errors_err_encoding_not_supported">#</a></span></h3>
+<h4><code>ERR_ENCODING_NOT_SUPPORTED</code><span><a class="mark" href="#errors_err_encoding_not_supported" id="errors_err_encoding_not_supported">#</a></span></h4>
 <p>Encoding provided to <code>TextDecoder()</code> API was not one of the
 <a href="util.html#util_whatwg_supported_encodings">WHATWG Supported Encodings</a>.</p>
+<p><a id="ERR_EVAL_ESM_CANNOT_PRINT"></a></p>
+<h4><code>ERR_EVAL_ESM_CANNOT_PRINT</code><span><a class="mark" href="#errors_err_eval_esm_cannot_print" id="errors_err_eval_esm_cannot_print">#</a></span></h4>
+<p><code>--print</code> cannot be used with ESM input.</p>
+<p><a id="ERR_EVENT_RECURSION"></a></p>
+<h4><code>ERR_EVENT_RECURSION</code><span><a class="mark" href="#errors_err_event_recursion" id="errors_err_event_recursion">#</a></span></h4>
+<p>Thrown when an attempt is made to recursively dispatch an event on <code>EventTarget</code>.</p>
 <p><a id="ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE"></a></p>
-<h3><code>ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_execution_environment_not_available" id="errors_err_execution_environment_not_available">#</a></span></h3>
+<h4><code>ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_execution_environment_not_available" id="errors_err_execution_environment_not_available">#</a></span></h4>
 <p>The JS execution context is not associated with a Node.js environment.
 This may occur when Node.js is used as an embedded library and some hooks
 for the JS engine are not set up properly.</p>
 <p><a id="ERR_FALSY_VALUE_REJECTION"></a></p>
-<h3><code>ERR_FALSY_VALUE_REJECTION</code><span><a class="mark" href="#errors_err_falsy_value_rejection" id="errors_err_falsy_value_rejection">#</a></span></h3>
+<h4><code>ERR_FALSY_VALUE_REJECTION</code><span><a class="mark" href="#errors_err_falsy_value_rejection" id="errors_err_falsy_value_rejection">#</a></span></h4>
 <p>A <code>Promise</code> that was callbackified via <code>util.callbackify()</code> was rejected with a
 falsy value.</p>
+<p><a id="ERR_FEATURE_UNAVAILABLE_ON_PLATFORM"></a></p>
+<h4><code>ERR_FEATURE_UNAVAILABLE_ON_PLATFORM</code><span><a class="mark" href="#errors_err_feature_unavailable_on_platform" id="errors_err_feature_unavailable_on_platform">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.0.0</span>
+</div>
+<p>Used when a feature that is not available
+to the current platform which is running Node.js is used.</p>
+<p><a id="ERR_FS_EISDIR"></a></p>
+<h4><code>ERR_FS_EISDIR</code><span><a class="mark" href="#errors_err_fs_eisdir" id="errors_err_fs_eisdir">#</a></span></h4>
+<p>Path is a directory.</p>
 <p><a id="ERR_FS_FILE_TOO_LARGE"></a></p>
-<h3><code>ERR_FS_FILE_TOO_LARGE</code><span><a class="mark" href="#errors_err_fs_file_too_large" id="errors_err_fs_file_too_large">#</a></span></h3>
+<h4><code>ERR_FS_FILE_TOO_LARGE</code><span><a class="mark" href="#errors_err_fs_file_too_large" id="errors_err_fs_file_too_large">#</a></span></h4>
 <p>An attempt has been made to read a file whose size is larger than the maximum
 allowed size for a <code>Buffer</code>.</p>
 <p><a id="ERR_FS_INVALID_SYMLINK_TYPE"></a></p>
-<h3><code>ERR_FS_INVALID_SYMLINK_TYPE</code><span><a class="mark" href="#errors_err_fs_invalid_symlink_type" id="errors_err_fs_invalid_symlink_type">#</a></span></h3>
+<h4><code>ERR_FS_INVALID_SYMLINK_TYPE</code><span><a class="mark" href="#errors_err_fs_invalid_symlink_type" id="errors_err_fs_invalid_symlink_type">#</a></span></h4>
 <p>An invalid symlink type was passed to the <a href="fs.html#fs_fs_symlink_target_path_type_callback"><code>fs.symlink()</code></a> or
 <a href="fs.html#fs_fs_symlinksync_target_path_type"><code>fs.symlinkSync()</code></a> methods.</p>
 <p><a id="ERR_HTTP_HEADERS_SENT"></a></p>
-<h3><code>ERR_HTTP_HEADERS_SENT</code><span><a class="mark" href="#errors_err_http_headers_sent" id="errors_err_http_headers_sent">#</a></span></h3>
+<h4><code>ERR_HTTP_HEADERS_SENT</code><span><a class="mark" href="#errors_err_http_headers_sent" id="errors_err_http_headers_sent">#</a></span></h4>
 <p>An attempt was made to add more headers after the headers had already been sent.</p>
 <p><a id="ERR_HTTP_INVALID_HEADER_VALUE"></a></p>
-<h3><code>ERR_HTTP_INVALID_HEADER_VALUE</code><span><a class="mark" href="#errors_err_http_invalid_header_value" id="errors_err_http_invalid_header_value">#</a></span></h3>
+<h4><code>ERR_HTTP_INVALID_HEADER_VALUE</code><span><a class="mark" href="#errors_err_http_invalid_header_value" id="errors_err_http_invalid_header_value">#</a></span></h4>
 <p>An invalid HTTP header value was specified.</p>
 <p><a id="ERR_HTTP_INVALID_STATUS_CODE"></a></p>
-<h3><code>ERR_HTTP_INVALID_STATUS_CODE</code><span><a class="mark" href="#errors_err_http_invalid_status_code" id="errors_err_http_invalid_status_code">#</a></span></h3>
+<h4><code>ERR_HTTP_INVALID_STATUS_CODE</code><span><a class="mark" href="#errors_err_http_invalid_status_code" id="errors_err_http_invalid_status_code">#</a></span></h4>
 <p>Status code was outside the regular status code range (100-999).</p>
 <p><a id="ERR_HTTP_TRAILER_INVALID"></a></p>
-<h3><code>ERR_HTTP_TRAILER_INVALID</code><span><a class="mark" href="#errors_err_http_trailer_invalid" id="errors_err_http_trailer_invalid">#</a></span></h3>
+<h4><code>ERR_HTTP_TRAILER_INVALID</code><span><a class="mark" href="#errors_err_http_trailer_invalid" id="errors_err_http_trailer_invalid">#</a></span></h4>
 <p>The <code>Trailer</code> header was set even though the transfer encoding does not support
 that.</p>
 <p><a id="ERR_HTTP2_ALTSVC_INVALID_ORIGIN"></a></p>
-<h3><code>ERR_HTTP2_ALTSVC_INVALID_ORIGIN</code><span><a class="mark" href="#errors_err_http2_altsvc_invalid_origin" id="errors_err_http2_altsvc_invalid_origin">#</a></span></h3>
+<h4><code>ERR_HTTP2_ALTSVC_INVALID_ORIGIN</code><span><a class="mark" href="#errors_err_http2_altsvc_invalid_origin" id="errors_err_http2_altsvc_invalid_origin">#</a></span></h4>
 <p>HTTP/2 ALTSVC frames require a valid origin.</p>
 <p><a id="ERR_HTTP2_ALTSVC_LENGTH"></a></p>
-<h3><code>ERR_HTTP2_ALTSVC_LENGTH</code><span><a class="mark" href="#errors_err_http2_altsvc_length" id="errors_err_http2_altsvc_length">#</a></span></h3>
+<h4><code>ERR_HTTP2_ALTSVC_LENGTH</code><span><a class="mark" href="#errors_err_http2_altsvc_length" id="errors_err_http2_altsvc_length">#</a></span></h4>
 <p>HTTP/2 ALTSVC frames are limited to a maximum of 16,382 payload bytes.</p>
 <p><a id="ERR_HTTP2_CONNECT_AUTHORITY"></a></p>
-<h3><code>ERR_HTTP2_CONNECT_AUTHORITY</code><span><a class="mark" href="#errors_err_http2_connect_authority" id="errors_err_http2_connect_authority">#</a></span></h3>
+<h4><code>ERR_HTTP2_CONNECT_AUTHORITY</code><span><a class="mark" href="#errors_err_http2_connect_authority" id="errors_err_http2_connect_authority">#</a></span></h4>
 <p>For HTTP/2 requests using the <code>CONNECT</code> method, the <code>:authority</code> pseudo-header
 is required.</p>
 <p><a id="ERR_HTTP2_CONNECT_PATH"></a></p>
-<h3><code>ERR_HTTP2_CONNECT_PATH</code><span><a class="mark" href="#errors_err_http2_connect_path" id="errors_err_http2_connect_path">#</a></span></h3>
+<h4><code>ERR_HTTP2_CONNECT_PATH</code><span><a class="mark" href="#errors_err_http2_connect_path" id="errors_err_http2_connect_path">#</a></span></h4>
 <p>For HTTP/2 requests using the <code>CONNECT</code> method, the <code>:path</code> pseudo-header is
 forbidden.</p>
 <p><a id="ERR_HTTP2_CONNECT_SCHEME"></a></p>
-<h3><code>ERR_HTTP2_CONNECT_SCHEME</code><span><a class="mark" href="#errors_err_http2_connect_scheme" id="errors_err_http2_connect_scheme">#</a></span></h3>
+<h4><code>ERR_HTTP2_CONNECT_SCHEME</code><span><a class="mark" href="#errors_err_http2_connect_scheme" id="errors_err_http2_connect_scheme">#</a></span></h4>
 <p>For HTTP/2 requests using the <code>CONNECT</code> method, the <code>:scheme</code> pseudo-header is
 forbidden.</p>
 <p><a id="ERR_HTTP2_ERROR"></a></p>
-<h3><code>ERR_HTTP2_ERROR</code><span><a class="mark" href="#errors_err_http2_error" id="errors_err_http2_error">#</a></span></h3>
+<h4><code>ERR_HTTP2_ERROR</code><span><a class="mark" href="#errors_err_http2_error" id="errors_err_http2_error">#</a></span></h4>
 <p>A non-specific HTTP/2 error has occurred.</p>
 <p><a id="ERR_HTTP2_GOAWAY_SESSION"></a></p>
-<h3><code>ERR_HTTP2_GOAWAY_SESSION</code><span><a class="mark" href="#errors_err_http2_goaway_session" id="errors_err_http2_goaway_session">#</a></span></h3>
+<h4><code>ERR_HTTP2_GOAWAY_SESSION</code><span><a class="mark" href="#errors_err_http2_goaway_session" id="errors_err_http2_goaway_session">#</a></span></h4>
 <p>New HTTP/2 Streams may not be opened after the <code>Http2Session</code> has received a
 <code>GOAWAY</code> frame from the connected peer.</p>
+<p><a id="ERR_HTTP2_HEADER_SINGLE_VALUE"></a></p>
+<h4><code>ERR_HTTP2_HEADER_SINGLE_VALUE</code><span><a class="mark" href="#errors_err_http2_header_single_value" id="errors_err_http2_header_single_value">#</a></span></h4>
+<p>Multiple values were provided for an HTTP/2 header field that was required to
+have only a single value.</p>
 <p><a id="ERR_HTTP2_HEADERS_AFTER_RESPOND"></a></p>
-<h3><code>ERR_HTTP2_HEADERS_AFTER_RESPOND</code><span><a class="mark" href="#errors_err_http2_headers_after_respond" id="errors_err_http2_headers_after_respond">#</a></span></h3>
+<h4><code>ERR_HTTP2_HEADERS_AFTER_RESPOND</code><span><a class="mark" href="#errors_err_http2_headers_after_respond" id="errors_err_http2_headers_after_respond">#</a></span></h4>
 <p>An additional headers was specified after an HTTP/2 response was initiated.</p>
 <p><a id="ERR_HTTP2_HEADERS_SENT"></a></p>
-<h3><code>ERR_HTTP2_HEADERS_SENT</code><span><a class="mark" href="#errors_err_http2_headers_sent" id="errors_err_http2_headers_sent">#</a></span></h3>
+<h4><code>ERR_HTTP2_HEADERS_SENT</code><span><a class="mark" href="#errors_err_http2_headers_sent" id="errors_err_http2_headers_sent">#</a></span></h4>
 <p>An attempt was made to send multiple response headers.</p>
-<p><a id="ERR_HTTP2_HEADER_SINGLE_VALUE"></a></p>
-<h3><code>ERR_HTTP2_HEADER_SINGLE_VALUE</code><span><a class="mark" href="#errors_err_http2_header_single_value" id="errors_err_http2_header_single_value">#</a></span></h3>
-<p>Multiple values were provided for an HTTP/2 header field that was required to
-have only a single value.</p>
 <p><a id="ERR_HTTP2_INFO_STATUS_NOT_ALLOWED"></a></p>
-<h3><code>ERR_HTTP2_INFO_STATUS_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_http2_info_status_not_allowed" id="errors_err_http2_info_status_not_allowed">#</a></span></h3>
+<h4><code>ERR_HTTP2_INFO_STATUS_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_http2_info_status_not_allowed" id="errors_err_http2_info_status_not_allowed">#</a></span></h4>
 <p>Informational HTTP status codes (<code>1xx</code>) may not be set as the response status
 code on HTTP/2 responses.</p>
 <p><a id="ERR_HTTP2_INVALID_CONNECTION_HEADERS"></a></p>
-<h3><code>ERR_HTTP2_INVALID_CONNECTION_HEADERS</code><span><a class="mark" href="#errors_err_http2_invalid_connection_headers" id="errors_err_http2_invalid_connection_headers">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_CONNECTION_HEADERS</code><span><a class="mark" href="#errors_err_http2_invalid_connection_headers" id="errors_err_http2_invalid_connection_headers">#</a></span></h4>
 <p>HTTP/1 connection specific headers are forbidden to be used in HTTP/2
 requests and responses.</p>
 <p><a id="ERR_HTTP2_INVALID_HEADER_VALUE"></a></p>
-<h3><code>ERR_HTTP2_INVALID_HEADER_VALUE</code><span><a class="mark" href="#errors_err_http2_invalid_header_value" id="errors_err_http2_invalid_header_value">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_HEADER_VALUE</code><span><a class="mark" href="#errors_err_http2_invalid_header_value" id="errors_err_http2_invalid_header_value">#</a></span></h4>
 <p>An invalid HTTP/2 header value was specified.</p>
 <p><a id="ERR_HTTP2_INVALID_INFO_STATUS"></a></p>
-<h3><code>ERR_HTTP2_INVALID_INFO_STATUS</code><span><a class="mark" href="#errors_err_http2_invalid_info_status" id="errors_err_http2_invalid_info_status">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_INFO_STATUS</code><span><a class="mark" href="#errors_err_http2_invalid_info_status" id="errors_err_http2_invalid_info_status">#</a></span></h4>
 <p>An invalid HTTP informational status code has been specified. Informational
 status codes must be an integer between <code>100</code> and <code>199</code> (inclusive).</p>
 <p><a id="ERR_HTTP2_INVALID_ORIGIN"></a></p>
-<h3><code>ERR_HTTP2_INVALID_ORIGIN</code><span><a class="mark" href="#errors_err_http2_invalid_origin" id="errors_err_http2_invalid_origin">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_ORIGIN</code><span><a class="mark" href="#errors_err_http2_invalid_origin" id="errors_err_http2_invalid_origin">#</a></span></h4>
 <p>HTTP/2 <code>ORIGIN</code> frames require a valid origin.</p>
 <p><a id="ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH"></a></p>
-<h3><code>ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH</code><span><a class="mark" href="#errors_err_http2_invalid_packed_settings_length" id="errors_err_http2_invalid_packed_settings_length">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH</code><span><a class="mark" href="#errors_err_http2_invalid_packed_settings_length" id="errors_err_http2_invalid_packed_settings_length">#</a></span></h4>
 <p>Input <code>Buffer</code> and <code>Uint8Array</code> instances passed to the
 <code>http2.getUnpackedSettings()</code> API must have a length that is a multiple of
 six.</p>
 <p><a id="ERR_HTTP2_INVALID_PSEUDOHEADER"></a></p>
-<h3><code>ERR_HTTP2_INVALID_PSEUDOHEADER</code><span><a class="mark" href="#errors_err_http2_invalid_pseudoheader" id="errors_err_http2_invalid_pseudoheader">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_PSEUDOHEADER</code><span><a class="mark" href="#errors_err_http2_invalid_pseudoheader" id="errors_err_http2_invalid_pseudoheader">#</a></span></h4>
 <p>Only valid HTTP/2 pseudoheaders (<code>:status</code>, <code>:path</code>, <code>:authority</code>, <code>:scheme</code>,
 and <code>:method</code>) may be used.</p>
 <p><a id="ERR_HTTP2_INVALID_SESSION"></a></p>
-<h3><code>ERR_HTTP2_INVALID_SESSION</code><span><a class="mark" href="#errors_err_http2_invalid_session" id="errors_err_http2_invalid_session">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_SESSION</code><span><a class="mark" href="#errors_err_http2_invalid_session" id="errors_err_http2_invalid_session">#</a></span></h4>
 <p>An action was performed on an <code>Http2Session</code> object that had already been
 destroyed.</p>
 <p><a id="ERR_HTTP2_INVALID_SETTING_VALUE"></a></p>
-<h3><code>ERR_HTTP2_INVALID_SETTING_VALUE</code><span><a class="mark" href="#errors_err_http2_invalid_setting_value" id="errors_err_http2_invalid_setting_value">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_SETTING_VALUE</code><span><a class="mark" href="#errors_err_http2_invalid_setting_value" id="errors_err_http2_invalid_setting_value">#</a></span></h4>
 <p>An invalid value has been specified for an HTTP/2 setting.</p>
 <p><a id="ERR_HTTP2_INVALID_STREAM"></a></p>
-<h3><code>ERR_HTTP2_INVALID_STREAM</code><span><a class="mark" href="#errors_err_http2_invalid_stream" id="errors_err_http2_invalid_stream">#</a></span></h3>
+<h4><code>ERR_HTTP2_INVALID_STREAM</code><span><a class="mark" href="#errors_err_http2_invalid_stream" id="errors_err_http2_invalid_stream">#</a></span></h4>
 <p>An operation was performed on a stream that had already been destroyed.</p>
 <p><a id="ERR_HTTP2_MAX_PENDING_SETTINGS_ACK"></a></p>
-<h3><code>ERR_HTTP2_MAX_PENDING_SETTINGS_ACK</code><span><a class="mark" href="#errors_err_http2_max_pending_settings_ack" id="errors_err_http2_max_pending_settings_ack">#</a></span></h3>
+<h4><code>ERR_HTTP2_MAX_PENDING_SETTINGS_ACK</code><span><a class="mark" href="#errors_err_http2_max_pending_settings_ack" id="errors_err_http2_max_pending_settings_ack">#</a></span></h4>
 <p>Whenever an HTTP/2 <code>SETTINGS</code> frame is sent to a connected peer, the peer is
 required to send an acknowledgment that it has received and applied the new
 <code>SETTINGS</code>. By default, a maximum number of unacknowledged <code>SETTINGS</code> frames may
 be sent at any given time. This error code is used when that limit has been
 reached.</p>
 <p><a id="ERR_HTTP2_NESTED_PUSH"></a></p>
-<h3><code>ERR_HTTP2_NESTED_PUSH</code><span><a class="mark" href="#errors_err_http2_nested_push" id="errors_err_http2_nested_push">#</a></span></h3>
+<h4><code>ERR_HTTP2_NESTED_PUSH</code><span><a class="mark" href="#errors_err_http2_nested_push" id="errors_err_http2_nested_push">#</a></span></h4>
 <p>An attempt was made to initiate a new push stream from within a push stream.
 Nested push streams are not permitted.</p>
+<p><a id="ERR_HTTP2_NO_MEM"></a></p>
+<h4><code>ERR_HTTP2_NO_MEM</code><span><a class="mark" href="#errors_err_http2_no_mem" id="errors_err_http2_no_mem">#</a></span></h4>
+<p>Out of memory when using the <code>http2session.setLocalWindowSize(windowSize)</code> API.</p>
 <p><a id="ERR_HTTP2_NO_SOCKET_MANIPULATION"></a></p>
-<h3><code>ERR_HTTP2_NO_SOCKET_MANIPULATION</code><span><a class="mark" href="#errors_err_http2_no_socket_manipulation" id="errors_err_http2_no_socket_manipulation">#</a></span></h3>
+<h4><code>ERR_HTTP2_NO_SOCKET_MANIPULATION</code><span><a class="mark" href="#errors_err_http2_no_socket_manipulation" id="errors_err_http2_no_socket_manipulation">#</a></span></h4>
 <p>An attempt was made to directly manipulate (read, write, pause, resume, etc.) a
 socket attached to an <code>Http2Session</code>.</p>
 <p><a id="ERR_HTTP2_ORIGIN_LENGTH"></a></p>
-<h3><code>ERR_HTTP2_ORIGIN_LENGTH</code><span><a class="mark" href="#errors_err_http2_origin_length" id="errors_err_http2_origin_length">#</a></span></h3>
+<h4><code>ERR_HTTP2_ORIGIN_LENGTH</code><span><a class="mark" href="#errors_err_http2_origin_length" id="errors_err_http2_origin_length">#</a></span></h4>
 <p>HTTP/2 <code>ORIGIN</code> frames are limited to a length of 16382 bytes.</p>
 <p><a id="ERR_HTTP2_OUT_OF_STREAMS"></a></p>
-<h3><code>ERR_HTTP2_OUT_OF_STREAMS</code><span><a class="mark" href="#errors_err_http2_out_of_streams" id="errors_err_http2_out_of_streams">#</a></span></h3>
+<h4><code>ERR_HTTP2_OUT_OF_STREAMS</code><span><a class="mark" href="#errors_err_http2_out_of_streams" id="errors_err_http2_out_of_streams">#</a></span></h4>
 <p>The number of streams created on a single HTTP/2 session reached the maximum
 limit.</p>
 <p><a id="ERR_HTTP2_PAYLOAD_FORBIDDEN"></a></p>
-<h3><code>ERR_HTTP2_PAYLOAD_FORBIDDEN</code><span><a class="mark" href="#errors_err_http2_payload_forbidden" id="errors_err_http2_payload_forbidden">#</a></span></h3>
+<h4><code>ERR_HTTP2_PAYLOAD_FORBIDDEN</code><span><a class="mark" href="#errors_err_http2_payload_forbidden" id="errors_err_http2_payload_forbidden">#</a></span></h4>
 <p>A message payload was specified for an HTTP response code for which a payload is
 forbidden.</p>
 <p><a id="ERR_HTTP2_PING_CANCEL"></a></p>
-<h3><code>ERR_HTTP2_PING_CANCEL</code><span><a class="mark" href="#errors_err_http2_ping_cancel" id="errors_err_http2_ping_cancel">#</a></span></h3>
+<h4><code>ERR_HTTP2_PING_CANCEL</code><span><a class="mark" href="#errors_err_http2_ping_cancel" id="errors_err_http2_ping_cancel">#</a></span></h4>
 <p>An HTTP/2 ping was canceled.</p>
 <p><a id="ERR_HTTP2_PING_LENGTH"></a></p>
-<h3><code>ERR_HTTP2_PING_LENGTH</code><span><a class="mark" href="#errors_err_http2_ping_length" id="errors_err_http2_ping_length">#</a></span></h3>
+<h4><code>ERR_HTTP2_PING_LENGTH</code><span><a class="mark" href="#errors_err_http2_ping_length" id="errors_err_http2_ping_length">#</a></span></h4>
 <p>HTTP/2 ping payloads must be exactly 8 bytes in length.</p>
 <p><a id="ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED"></a></p>
-<h3><code>ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_http2_pseudoheader_not_allowed" id="errors_err_http2_pseudoheader_not_allowed">#</a></span></h3>
+<h4><code>ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_http2_pseudoheader_not_allowed" id="errors_err_http2_pseudoheader_not_allowed">#</a></span></h4>
 <p>An HTTP/2 pseudo-header has been used inappropriately. Pseudo-headers are header
 key names that begin with the <code>:</code> prefix.</p>
 <p><a id="ERR_HTTP2_PUSH_DISABLED"></a></p>
-<h3><code>ERR_HTTP2_PUSH_DISABLED</code><span><a class="mark" href="#errors_err_http2_push_disabled" id="errors_err_http2_push_disabled">#</a></span></h3>
+<h4><code>ERR_HTTP2_PUSH_DISABLED</code><span><a class="mark" href="#errors_err_http2_push_disabled" id="errors_err_http2_push_disabled">#</a></span></h4>
 <p>An attempt was made to create a push stream, which had been disabled by the
 client.</p>
 <p><a id="ERR_HTTP2_SEND_FILE"></a></p>
-<h3><code>ERR_HTTP2_SEND_FILE</code><span><a class="mark" href="#errors_err_http2_send_file" id="errors_err_http2_send_file">#</a></span></h3>
+<h4><code>ERR_HTTP2_SEND_FILE</code><span><a class="mark" href="#errors_err_http2_send_file" id="errors_err_http2_send_file">#</a></span></h4>
 <p>An attempt was made to use the <code>Http2Stream.prototype.responseWithFile()</code> API to
 send a directory.</p>
 <p><a id="ERR_HTTP2_SEND_FILE_NOSEEK"></a></p>
-<h3><code>ERR_HTTP2_SEND_FILE_NOSEEK</code><span><a class="mark" href="#errors_err_http2_send_file_noseek" id="errors_err_http2_send_file_noseek">#</a></span></h3>
+<h4><code>ERR_HTTP2_SEND_FILE_NOSEEK</code><span><a class="mark" href="#errors_err_http2_send_file_noseek" id="errors_err_http2_send_file_noseek">#</a></span></h4>
 <p>An attempt was made to use the <code>Http2Stream.prototype.responseWithFile()</code> API to
 send something other than a regular file, but <code>offset</code> or <code>length</code> options were
 provided.</p>
 <p><a id="ERR_HTTP2_SESSION_ERROR"></a></p>
-<h3><code>ERR_HTTP2_SESSION_ERROR</code><span><a class="mark" href="#errors_err_http2_session_error" id="errors_err_http2_session_error">#</a></span></h3>
+<h4><code>ERR_HTTP2_SESSION_ERROR</code><span><a class="mark" href="#errors_err_http2_session_error" id="errors_err_http2_session_error">#</a></span></h4>
 <p>The <code>Http2Session</code> closed with a non-zero error code.</p>
 <p><a id="ERR_HTTP2_SETTINGS_CANCEL"></a></p>
-<h3><code>ERR_HTTP2_SETTINGS_CANCEL</code><span><a class="mark" href="#errors_err_http2_settings_cancel" id="errors_err_http2_settings_cancel">#</a></span></h3>
+<h4><code>ERR_HTTP2_SETTINGS_CANCEL</code><span><a class="mark" href="#errors_err_http2_settings_cancel" id="errors_err_http2_settings_cancel">#</a></span></h4>
 <p>The <code>Http2Session</code> settings canceled.</p>
 <p><a id="ERR_HTTP2_SOCKET_BOUND"></a></p>
-<h3><code>ERR_HTTP2_SOCKET_BOUND</code><span><a class="mark" href="#errors_err_http2_socket_bound" id="errors_err_http2_socket_bound">#</a></span></h3>
+<h4><code>ERR_HTTP2_SOCKET_BOUND</code><span><a class="mark" href="#errors_err_http2_socket_bound" id="errors_err_http2_socket_bound">#</a></span></h4>
 <p>An attempt was made to connect a <code>Http2Session</code> object to a <code>net.Socket</code> or
 <code>tls.TLSSocket</code> that had already been bound to another <code>Http2Session</code> object.</p>
 <p><a id="ERR_HTTP2_SOCKET_UNBOUND"></a></p>
-<h3><code>ERR_HTTP2_SOCKET_UNBOUND</code><span><a class="mark" href="#errors_err_http2_socket_unbound" id="errors_err_http2_socket_unbound">#</a></span></h3>
+<h4><code>ERR_HTTP2_SOCKET_UNBOUND</code><span><a class="mark" href="#errors_err_http2_socket_unbound" id="errors_err_http2_socket_unbound">#</a></span></h4>
 <p>An attempt was made to use the <code>socket</code> property of an <code>Http2Session</code> that
 has already been closed.</p>
 <p><a id="ERR_HTTP2_STATUS_101"></a></p>
-<h3><code>ERR_HTTP2_STATUS_101</code><span><a class="mark" href="#errors_err_http2_status_101" id="errors_err_http2_status_101">#</a></span></h3>
+<h4><code>ERR_HTTP2_STATUS_101</code><span><a class="mark" href="#errors_err_http2_status_101" id="errors_err_http2_status_101">#</a></span></h4>
 <p>Use of the <code>101</code> Informational status code is forbidden in HTTP/2.</p>
 <p><a id="ERR_HTTP2_STATUS_INVALID"></a></p>
-<h3><code>ERR_HTTP2_STATUS_INVALID</code><span><a class="mark" href="#errors_err_http2_status_invalid" id="errors_err_http2_status_invalid">#</a></span></h3>
+<h4><code>ERR_HTTP2_STATUS_INVALID</code><span><a class="mark" href="#errors_err_http2_status_invalid" id="errors_err_http2_status_invalid">#</a></span></h4>
 <p>An invalid HTTP status code has been specified. Status codes must be an integer
 between <code>100</code> and <code>599</code> (inclusive).</p>
 <p><a id="ERR_HTTP2_STREAM_CANCEL"></a></p>
-<h3><code>ERR_HTTP2_STREAM_CANCEL</code><span><a class="mark" href="#errors_err_http2_stream_cancel" id="errors_err_http2_stream_cancel">#</a></span></h3>
+<h4><code>ERR_HTTP2_STREAM_CANCEL</code><span><a class="mark" href="#errors_err_http2_stream_cancel" id="errors_err_http2_stream_cancel">#</a></span></h4>
 <p>An <code>Http2Stream</code> was destroyed before any data was transmitted to the connected
 peer.</p>
 <p><a id="ERR_HTTP2_STREAM_ERROR"></a></p>
-<h3><code>ERR_HTTP2_STREAM_ERROR</code><span><a class="mark" href="#errors_err_http2_stream_error" id="errors_err_http2_stream_error">#</a></span></h3>
+<h4><code>ERR_HTTP2_STREAM_ERROR</code><span><a class="mark" href="#errors_err_http2_stream_error" id="errors_err_http2_stream_error">#</a></span></h4>
 <p>A non-zero error code was been specified in an <code>RST_STREAM</code> frame.</p>
 <p><a id="ERR_HTTP2_STREAM_SELF_DEPENDENCY"></a></p>
-<h3><code>ERR_HTTP2_STREAM_SELF_DEPENDENCY</code><span><a class="mark" href="#errors_err_http2_stream_self_dependency" id="errors_err_http2_stream_self_dependency">#</a></span></h3>
+<h4><code>ERR_HTTP2_STREAM_SELF_DEPENDENCY</code><span><a class="mark" href="#errors_err_http2_stream_self_dependency" id="errors_err_http2_stream_self_dependency">#</a></span></h4>
 <p>When setting the priority for an HTTP/2 stream, the stream may be marked as
 a dependency for a parent stream. This error code is used when an attempt is
 made to mark a stream and dependent of itself.</p>
 <p><a id="ERR_HTTP2_TRAILERS_ALREADY_SENT"></a></p>
-<h3><code>ERR_HTTP2_TRAILERS_ALREADY_SENT</code><span><a class="mark" href="#errors_err_http2_trailers_already_sent" id="errors_err_http2_trailers_already_sent">#</a></span></h3>
+<h4><code>ERR_HTTP2_TRAILERS_ALREADY_SENT</code><span><a class="mark" href="#errors_err_http2_trailers_already_sent" id="errors_err_http2_trailers_already_sent">#</a></span></h4>
 <p>Trailing headers have already been sent on the <code>Http2Stream</code>.</p>
 <p><a id="ERR_HTTP2_TRAILERS_NOT_READY"></a></p>
-<h3><code>ERR_HTTP2_TRAILERS_NOT_READY</code><span><a class="mark" href="#errors_err_http2_trailers_not_ready" id="errors_err_http2_trailers_not_ready">#</a></span></h3>
+<h4><code>ERR_HTTP2_TRAILERS_NOT_READY</code><span><a class="mark" href="#errors_err_http2_trailers_not_ready" id="errors_err_http2_trailers_not_ready">#</a></span></h4>
 <p>The <code>http2stream.sendTrailers()</code> method cannot be called until after the
 <code>'wantTrailers'</code> event is emitted on an <code>Http2Stream</code> object. The
 <code>'wantTrailers'</code> event will only be emitted if the <code>waitForTrailers</code> option
 is set for the <code>Http2Stream</code>.</p>
 <p><a id="ERR_HTTP2_UNSUPPORTED_PROTOCOL"></a></p>
-<h3><code>ERR_HTTP2_UNSUPPORTED_PROTOCOL</code><span><a class="mark" href="#errors_err_http2_unsupported_protocol" id="errors_err_http2_unsupported_protocol">#</a></span></h3>
+<h4><code>ERR_HTTP2_UNSUPPORTED_PROTOCOL</code><span><a class="mark" href="#errors_err_http2_unsupported_protocol" id="errors_err_http2_unsupported_protocol">#</a></span></h4>
 <p><code>http2.connect()</code> was passed a URL that uses any protocol other than <code>http:</code> or
 <code>https:</code>.</p>
-<p><a id="ERR_INTERNAL_ASSERTION"></a></p>
-<h3><code>ERR_INTERNAL_ASSERTION</code><span><a class="mark" href="#errors_err_internal_assertion" id="errors_err_internal_assertion">#</a></span></h3>
-<p>There was a bug in Node.js or incorrect usage of Node.js internals.
-To fix the error, open an issue at <a href="https://github.com/nodejs/node/issues">https://github.com/nodejs/node/issues</a>.</p>
 <p><a id="ERR_INCOMPATIBLE_OPTION_PAIR"></a></p>
-<h3><code>ERR_INCOMPATIBLE_OPTION_PAIR</code><span><a class="mark" href="#errors_err_incompatible_option_pair" id="errors_err_incompatible_option_pair">#</a></span></h3>
+<h4><code>ERR_INCOMPATIBLE_OPTION_PAIR</code><span><a class="mark" href="#errors_err_incompatible_option_pair" id="errors_err_incompatible_option_pair">#</a></span></h4>
 <p>An option pair is incompatible with each other and cannot be used at the same
 time.</p>
 <p><a id="ERR_INPUT_TYPE_NOT_ALLOWED"></a></p>
-<h3><code>ERR_INPUT_TYPE_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_input_type_not_allowed" id="errors_err_input_type_not_allowed">#</a></span></h3>
+<h4><code>ERR_INPUT_TYPE_NOT_ALLOWED</code><span><a class="mark" href="#errors_err_input_type_not_allowed" id="errors_err_input_type_not_allowed">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>The <code>--input-type</code> flag was used to attempt to execute a file. This flag can
 only be used with input via <code>--eval</code>, <code>--print</code> or <code>STDIN</code>.</p>
 <p><a id="ERR_INSPECTOR_ALREADY_ACTIVATED"></a></p>
-<h3><code>ERR_INSPECTOR_ALREADY_ACTIVATED</code><span><a class="mark" href="#errors_err_inspector_already_activated" id="errors_err_inspector_already_activated">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_ALREADY_ACTIVATED</code><span><a class="mark" href="#errors_err_inspector_already_activated" id="errors_err_inspector_already_activated">#</a></span></h4>
 <p>While using the <code>inspector</code> module, an attempt was made to activate the
 inspector when it already started to listen on a port. Use <code>inspector.close()</code>
 before activating it on a different address.</p>
 <p><a id="ERR_INSPECTOR_ALREADY_CONNECTED"></a></p>
-<h3><code>ERR_INSPECTOR_ALREADY_CONNECTED</code><span><a class="mark" href="#errors_err_inspector_already_connected" id="errors_err_inspector_already_connected">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_ALREADY_CONNECTED</code><span><a class="mark" href="#errors_err_inspector_already_connected" id="errors_err_inspector_already_connected">#</a></span></h4>
 <p>While using the <code>inspector</code> module, an attempt was made to connect when the
 inspector was already connected.</p>
 <p><a id="ERR_INSPECTOR_CLOSED"></a></p>
-<h3><code>ERR_INSPECTOR_CLOSED</code><span><a class="mark" href="#errors_err_inspector_closed" id="errors_err_inspector_closed">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_CLOSED</code><span><a class="mark" href="#errors_err_inspector_closed" id="errors_err_inspector_closed">#</a></span></h4>
 <p>While using the <code>inspector</code> module, an attempt was made to use the inspector
 after the session had already closed.</p>
 <p><a id="ERR_INSPECTOR_COMMAND"></a></p>
-<h3><code>ERR_INSPECTOR_COMMAND</code><span><a class="mark" href="#errors_err_inspector_command" id="errors_err_inspector_command">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_COMMAND</code><span><a class="mark" href="#errors_err_inspector_command" id="errors_err_inspector_command">#</a></span></h4>
 <p>An error occurred while issuing a command via the <code>inspector</code> module.</p>
 <p><a id="ERR_INSPECTOR_NOT_ACTIVE"></a></p>
-<h3><code>ERR_INSPECTOR_NOT_ACTIVE</code><span><a class="mark" href="#errors_err_inspector_not_active" id="errors_err_inspector_not_active">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_NOT_ACTIVE</code><span><a class="mark" href="#errors_err_inspector_not_active" id="errors_err_inspector_not_active">#</a></span></h4>
 <p>The <code>inspector</code> is not active when <code>inspector.waitForDebugger()</code> is called.</p>
 <p><a id="ERR_INSPECTOR_NOT_AVAILABLE"></a></p>
-<h3><code>ERR_INSPECTOR_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_inspector_not_available" id="errors_err_inspector_not_available">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_NOT_AVAILABLE</code><span><a class="mark" href="#errors_err_inspector_not_available" id="errors_err_inspector_not_available">#</a></span></h4>
 <p>The <code>inspector</code> module is not available for use.</p>
 <p><a id="ERR_INSPECTOR_NOT_CONNECTED"></a></p>
-<h3><code>ERR_INSPECTOR_NOT_CONNECTED</code><span><a class="mark" href="#errors_err_inspector_not_connected" id="errors_err_inspector_not_connected">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_NOT_CONNECTED</code><span><a class="mark" href="#errors_err_inspector_not_connected" id="errors_err_inspector_not_connected">#</a></span></h4>
 <p>While using the <code>inspector</code> module, an attempt was made to use the inspector
 before it was connected.</p>
 <p><a id="ERR_INSPECTOR_NOT_WORKER"></a></p>
-<h3><code>ERR_INSPECTOR_NOT_WORKER</code><span><a class="mark" href="#errors_err_inspector_not_worker" id="errors_err_inspector_not_worker">#</a></span></h3>
+<h4><code>ERR_INSPECTOR_NOT_WORKER</code><span><a class="mark" href="#errors_err_inspector_not_worker" id="errors_err_inspector_not_worker">#</a></span></h4>
 <p>An API was called on the main thread that can only be used from
 the worker thread.</p>
+<p><a id="ERR_INTERNAL_ASSERTION"></a></p>
+<h4><code>ERR_INTERNAL_ASSERTION</code><span><a class="mark" href="#errors_err_internal_assertion" id="errors_err_internal_assertion">#</a></span></h4>
+<p>There was a bug in Node.js or incorrect usage of Node.js internals.
+To fix the error, open an issue at <a href="https://github.com/nodejs/node/issues">https://github.com/nodejs/node/issues</a>.</p>
 <p><a id="ERR_INVALID_ADDRESS_FAMILY"></a></p>
-<h3><code>ERR_INVALID_ADDRESS_FAMILY</code><span><a class="mark" href="#errors_err_invalid_address_family" id="errors_err_invalid_address_family">#</a></span></h3>
+<h4><code>ERR_INVALID_ADDRESS_FAMILY</code><span><a class="mark" href="#errors_err_invalid_address_family" id="errors_err_invalid_address_family">#</a></span></h4>
 <p>The provided address family is not understood by the Node.js API.</p>
 <p><a id="ERR_INVALID_ARG_TYPE"></a></p>
-<h3><code>ERR_INVALID_ARG_TYPE</code><span><a class="mark" href="#errors_err_invalid_arg_type" id="errors_err_invalid_arg_type">#</a></span></h3>
+<h4><code>ERR_INVALID_ARG_TYPE</code><span><a class="mark" href="#errors_err_invalid_arg_type" id="errors_err_invalid_arg_type">#</a></span></h4>
 <p>An argument of the wrong type was passed to a Node.js API.</p>
 <p><a id="ERR_INVALID_ARG_VALUE"></a></p>
-<h3><code>ERR_INVALID_ARG_VALUE</code><span><a class="mark" href="#errors_err_invalid_arg_value" id="errors_err_invalid_arg_value">#</a></span></h3>
+<h4><code>ERR_INVALID_ARG_VALUE</code><span><a class="mark" href="#errors_err_invalid_arg_value" id="errors_err_invalid_arg_value">#</a></span></h4>
 <p>An invalid or unsupported value was passed for a given argument.</p>
 <p><a id="ERR_INVALID_ASYNC_ID"></a></p>
-<h3><code>ERR_INVALID_ASYNC_ID</code><span><a class="mark" href="#errors_err_invalid_async_id" id="errors_err_invalid_async_id">#</a></span></h3>
+<h4><code>ERR_INVALID_ASYNC_ID</code><span><a class="mark" href="#errors_err_invalid_async_id" id="errors_err_invalid_async_id">#</a></span></h4>
 <p>An invalid <code>asyncId</code> or <code>triggerAsyncId</code> was passed using <code>AsyncHooks</code>. An id
 less than -1 should never happen.</p>
 <p><a id="ERR_INVALID_BUFFER_SIZE"></a></p>
-<h3><code>ERR_INVALID_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_invalid_buffer_size" id="errors_err_invalid_buffer_size">#</a></span></h3>
+<h4><code>ERR_INVALID_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_invalid_buffer_size" id="errors_err_invalid_buffer_size">#</a></span></h4>
 <p>A swap was performed on a <code>Buffer</code> but its size was not compatible with the
 operation.</p>
 <p><a id="ERR_INVALID_CALLBACK"></a></p>
-<h3><code>ERR_INVALID_CALLBACK</code><span><a class="mark" href="#errors_err_invalid_callback" id="errors_err_invalid_callback">#</a></span></h3>
+<h4><code>ERR_INVALID_CALLBACK</code><span><a class="mark" href="#errors_err_invalid_callback" id="errors_err_invalid_callback">#</a></span></h4>
 <p>A callback function was required but was not been provided to a Node.js API.</p>
 <p><a id="ERR_INVALID_CHAR"></a></p>
-<h3><code>ERR_INVALID_CHAR</code><span><a class="mark" href="#errors_err_invalid_char" id="errors_err_invalid_char">#</a></span></h3>
+<h4><code>ERR_INVALID_CHAR</code><span><a class="mark" href="#errors_err_invalid_char" id="errors_err_invalid_char">#</a></span></h4>
 <p>Invalid characters were detected in headers.</p>
 <p><a id="ERR_INVALID_CURSOR_POS"></a></p>
-<h3><code>ERR_INVALID_CURSOR_POS</code><span><a class="mark" href="#errors_err_invalid_cursor_pos" id="errors_err_invalid_cursor_pos">#</a></span></h3>
+<h4><code>ERR_INVALID_CURSOR_POS</code><span><a class="mark" href="#errors_err_invalid_cursor_pos" id="errors_err_invalid_cursor_pos">#</a></span></h4>
 <p>A cursor on a given stream cannot be moved to a specified row without a
 specified column.</p>
 <p><a id="ERR_INVALID_FD"></a></p>
-<h3><code>ERR_INVALID_FD</code><span><a class="mark" href="#errors_err_invalid_fd" id="errors_err_invalid_fd">#</a></span></h3>
+<h4><code>ERR_INVALID_FD</code><span><a class="mark" href="#errors_err_invalid_fd" id="errors_err_invalid_fd">#</a></span></h4>
 <p>A file descriptor ('fd') was not valid (e.g. it was a negative value).</p>
 <p><a id="ERR_INVALID_FD_TYPE"></a></p>
-<h3><code>ERR_INVALID_FD_TYPE</code><span><a class="mark" href="#errors_err_invalid_fd_type" id="errors_err_invalid_fd_type">#</a></span></h3>
+<h4><code>ERR_INVALID_FD_TYPE</code><span><a class="mark" href="#errors_err_invalid_fd_type" id="errors_err_invalid_fd_type">#</a></span></h4>
 <p>A file descriptor ('fd') type was not valid.</p>
 <p><a id="ERR_INVALID_FILE_URL_HOST"></a></p>
-<h3><code>ERR_INVALID_FILE_URL_HOST</code><span><a class="mark" href="#errors_err_invalid_file_url_host" id="errors_err_invalid_file_url_host">#</a></span></h3>
+<h4><code>ERR_INVALID_FILE_URL_HOST</code><span><a class="mark" href="#errors_err_invalid_file_url_host" id="errors_err_invalid_file_url_host">#</a></span></h4>
 <p>A Node.js API that consumes <code>file:</code> URLs (such as certain functions in the
 <a href="fs.html"><code>fs</code></a> module) encountered a file URL with an incompatible host. This
 situation can only occur on Unix-like systems where only <code>localhost</code> or an empty
 host is supported.</p>
 <p><a id="ERR_INVALID_FILE_URL_PATH"></a></p>
-<h3><code>ERR_INVALID_FILE_URL_PATH</code><span><a class="mark" href="#errors_err_invalid_file_url_path" id="errors_err_invalid_file_url_path">#</a></span></h3>
+<h4><code>ERR_INVALID_FILE_URL_PATH</code><span><a class="mark" href="#errors_err_invalid_file_url_path" id="errors_err_invalid_file_url_path">#</a></span></h4>
 <p>A Node.js API that consumes <code>file:</code> URLs (such as certain functions in the
 <a href="fs.html"><code>fs</code></a> module) encountered a file URL with an incompatible path. The exact
 semantics for determining whether a path can be used is platform-dependent.</p>
 <p><a id="ERR_INVALID_HANDLE_TYPE"></a></p>
-<h3><code>ERR_INVALID_HANDLE_TYPE</code><span><a class="mark" href="#errors_err_invalid_handle_type" id="errors_err_invalid_handle_type">#</a></span></h3>
+<h4><code>ERR_INVALID_HANDLE_TYPE</code><span><a class="mark" href="#errors_err_invalid_handle_type" id="errors_err_invalid_handle_type">#</a></span></h4>
 <p>An attempt was made to send an unsupported "handle" over an IPC communication
 channel to a child process. See <a href="child_process.html#child_process_subprocess_send_message_sendhandle_options_callback"><code>subprocess.send()</code></a> and <a href="process.html#process_process_send_message_sendhandle_options_callback"><code>process.send()</code></a>
 for more information.</p>
 <p><a id="ERR_INVALID_HTTP_TOKEN"></a></p>
-<h3><code>ERR_INVALID_HTTP_TOKEN</code><span><a class="mark" href="#errors_err_invalid_http_token" id="errors_err_invalid_http_token">#</a></span></h3>
+<h4><code>ERR_INVALID_HTTP_TOKEN</code><span><a class="mark" href="#errors_err_invalid_http_token" id="errors_err_invalid_http_token">#</a></span></h4>
 <p>An invalid HTTP token was supplied.</p>
 <p><a id="ERR_INVALID_IP_ADDRESS"></a></p>
-<h3><code>ERR_INVALID_IP_ADDRESS</code><span><a class="mark" href="#errors_err_invalid_ip_address" id="errors_err_invalid_ip_address">#</a></span></h3>
+<h4><code>ERR_INVALID_IP_ADDRESS</code><span><a class="mark" href="#errors_err_invalid_ip_address" id="errors_err_invalid_ip_address">#</a></span></h4>
 <p>An IP address is not valid.</p>
+<p><a id="ERR_INVALID_MODULE"></a></p>
+<h4><code>ERR_INVALID_MODULE</code><span><a class="mark" href="#errors_err_invalid_module" id="errors_err_invalid_module">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>An attempt was made to load a module that does not exist or was otherwise not
+valid.</p>
 <p><a id="ERR_INVALID_MODULE_SPECIFIER"></a></p>
-<h3><code>ERR_INVALID_MODULE_SPECIFIER</code><span><a class="mark" href="#errors_err_invalid_module_specifier" id="errors_err_invalid_module_specifier">#</a></span></h3>
+<h4><code>ERR_INVALID_MODULE_SPECIFIER</code><span><a class="mark" href="#errors_err_invalid_module_specifier" id="errors_err_invalid_module_specifier">#</a></span></h4>
 <p>The imported module string is an invalid URL, package name, or package subpath
 specifier.</p>
 <p><a id="ERR_INVALID_OPT_VALUE"></a></p>
-<h3><code>ERR_INVALID_OPT_VALUE</code><span><a class="mark" href="#errors_err_invalid_opt_value" id="errors_err_invalid_opt_value">#</a></span></h3>
+<h4><code>ERR_INVALID_OPT_VALUE</code><span><a class="mark" href="#errors_err_invalid_opt_value" id="errors_err_invalid_opt_value">#</a></span></h4>
 <p>An invalid or unexpected value was passed in an options object.</p>
 <p><a id="ERR_INVALID_OPT_VALUE_ENCODING"></a></p>
-<h3><code>ERR_INVALID_OPT_VALUE_ENCODING</code><span><a class="mark" href="#errors_err_invalid_opt_value_encoding" id="errors_err_invalid_opt_value_encoding">#</a></span></h3>
+<h4><code>ERR_INVALID_OPT_VALUE_ENCODING</code><span><a class="mark" href="#errors_err_invalid_opt_value_encoding" id="errors_err_invalid_opt_value_encoding">#</a></span></h4>
 <p>An invalid or unknown file encoding was passed.</p>
 <p><a id="ERR_INVALID_PACKAGE_CONFIG"></a></p>
-<h3><code>ERR_INVALID_PACKAGE_CONFIG</code><span><a class="mark" href="#errors_err_invalid_package_config" id="errors_err_invalid_package_config">#</a></span></h3>
+<h4><code>ERR_INVALID_PACKAGE_CONFIG</code><span><a class="mark" href="#errors_err_invalid_package_config" id="errors_err_invalid_package_config">#</a></span></h4>
 <p>An invalid <a href="packages.html#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file was found which failed parsing.</p>
 <p><a id="ERR_INVALID_PACKAGE_TARGET"></a></p>
-<h3><code>ERR_INVALID_PACKAGE_TARGET</code><span><a class="mark" href="#errors_err_invalid_package_target" id="errors_err_invalid_package_target">#</a></span></h3>
+<h4><code>ERR_INVALID_PACKAGE_TARGET</code><span><a class="mark" href="#errors_err_invalid_package_target" id="errors_err_invalid_package_target">#</a></span></h4>
 <p>The <code>package.json</code> <a href="packages.html#packages_exports"><code>"exports"</code></a> field contains an invalid target mapping
 value for the attempted module resolution.</p>
 <p><a id="ERR_INVALID_PERFORMANCE_MARK"></a></p>
-<h3><code>ERR_INVALID_PERFORMANCE_MARK</code><span><a class="mark" href="#errors_err_invalid_performance_mark" id="errors_err_invalid_performance_mark">#</a></span></h3>
+<h4><code>ERR_INVALID_PERFORMANCE_MARK</code><span><a class="mark" href="#errors_err_invalid_performance_mark" id="errors_err_invalid_performance_mark">#</a></span></h4>
 <p>While using the Performance Timing API (<code>perf_hooks</code>), a performance mark is
 invalid.</p>
 <p><a id="ERR_INVALID_PROTOCOL"></a></p>
-<h3><code>ERR_INVALID_PROTOCOL</code><span><a class="mark" href="#errors_err_invalid_protocol" id="errors_err_invalid_protocol">#</a></span></h3>
+<h4><code>ERR_INVALID_PROTOCOL</code><span><a class="mark" href="#errors_err_invalid_protocol" id="errors_err_invalid_protocol">#</a></span></h4>
 <p>An invalid <code>options.protocol</code> was passed to <code>http.request()</code>.</p>
 <p><a id="ERR_INVALID_REPL_EVAL_CONFIG"></a></p>
-<h3><code>ERR_INVALID_REPL_EVAL_CONFIG</code><span><a class="mark" href="#errors_err_invalid_repl_eval_config" id="errors_err_invalid_repl_eval_config">#</a></span></h3>
+<h4><code>ERR_INVALID_REPL_EVAL_CONFIG</code><span><a class="mark" href="#errors_err_invalid_repl_eval_config" id="errors_err_invalid_repl_eval_config">#</a></span></h4>
 <p>Both <code>breakEvalOnSigint</code> and <code>eval</code> options were set in the <a href="repl.html"><code>REPL</code></a> config,
 which is not supported.</p>
 <p><a id="ERR_INVALID_REPL_INPUT"></a></p>
-<h3><code>ERR_INVALID_REPL_INPUT</code><span><a class="mark" href="#errors_err_invalid_repl_input" id="errors_err_invalid_repl_input">#</a></span></h3>
-<p>The input may not be used in the <a href="repl.html"><code>REPL</code></a>. All prohibited inputs are
-documented in the <a href="repl.html"><code>REPL</code></a>'s documentation.</p>
+<h4><code>ERR_INVALID_REPL_INPUT</code><span><a class="mark" href="#errors_err_invalid_repl_input" id="errors_err_invalid_repl_input">#</a></span></h4>
+<p>The input may not be used in the <a href="repl.html"><code>REPL</code></a>. The conditions under which this
+error is used are described in the <a href="repl.html"><code>REPL</code></a> documentation.</p>
 <p><a id="ERR_INVALID_RETURN_PROPERTY"></a></p>
-<h3><code>ERR_INVALID_RETURN_PROPERTY</code><span><a class="mark" href="#errors_err_invalid_return_property" id="errors_err_invalid_return_property">#</a></span></h3>
+<h4><code>ERR_INVALID_RETURN_PROPERTY</code><span><a class="mark" href="#errors_err_invalid_return_property" id="errors_err_invalid_return_property">#</a></span></h4>
 <p>Thrown in case a function option does not provide a valid value for one of its
 returned object properties on execution.</p>
 <p><a id="ERR_INVALID_RETURN_PROPERTY_VALUE"></a></p>
-<h3><code>ERR_INVALID_RETURN_PROPERTY_VALUE</code><span><a class="mark" href="#errors_err_invalid_return_property_value" id="errors_err_invalid_return_property_value">#</a></span></h3>
+<h4><code>ERR_INVALID_RETURN_PROPERTY_VALUE</code><span><a class="mark" href="#errors_err_invalid_return_property_value" id="errors_err_invalid_return_property_value">#</a></span></h4>
 <p>Thrown in case a function option does not provide an expected value
 type for one of its returned object properties on execution.</p>
 <p><a id="ERR_INVALID_RETURN_VALUE"></a></p>
-<h3><code>ERR_INVALID_RETURN_VALUE</code><span><a class="mark" href="#errors_err_invalid_return_value" id="errors_err_invalid_return_value">#</a></span></h3>
+<h4><code>ERR_INVALID_RETURN_VALUE</code><span><a class="mark" href="#errors_err_invalid_return_value" id="errors_err_invalid_return_value">#</a></span></h4>
 <p>Thrown in case a function option does not return an expected value
 type on execution, such as when a function is expected to return a promise.</p>
 <p><a id="ERR_INVALID_SYNC_FORK_INPUT"></a></p>
-<h3><code>ERR_INVALID_SYNC_FORK_INPUT</code><span><a class="mark" href="#errors_err_invalid_sync_fork_input" id="errors_err_invalid_sync_fork_input">#</a></span></h3>
+<h4><code>ERR_INVALID_SYNC_FORK_INPUT</code><span><a class="mark" href="#errors_err_invalid_sync_fork_input" id="errors_err_invalid_sync_fork_input">#</a></span></h4>
 <p>A <code>Buffer</code>, <code>TypedArray</code>, <code>DataView</code> or <code>string</code> was provided as stdio input to
 an asynchronous fork. See the documentation for the <a href="child_process.html"><code>child_process</code></a> module
 for more information.</p>
 <p><a id="ERR_INVALID_THIS"></a></p>
-<h3><code>ERR_INVALID_THIS</code><span><a class="mark" href="#errors_err_invalid_this" id="errors_err_invalid_this">#</a></span></h3>
+<h4><code>ERR_INVALID_THIS</code><span><a class="mark" href="#errors_err_invalid_this" id="errors_err_invalid_this">#</a></span></h4>
 <p>A Node.js API function was called with an incompatible <code>this</code> value.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> urlSearchParams = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'foo=bar&#x26;baz=new'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> urlSearchParams = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'foo=bar&#x26;baz=new'</span>);
 
-<span class="hljs-keyword">const</span> buf = Buffer.alloc(<span class="hljs-number">1</span>);
-urlSearchParams.has.call(buf, <span class="hljs-string">'foo'</span>);
+<span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">1</span>);
+urlSearchParams.<span class="hljs-property">has</span>.<span class="hljs-title function_">call</span>(buf, <span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Throws a TypeError with code 'ERR_INVALID_THIS'</span></code></pre>
 <p><a id="ERR_INVALID_TRANSFER_OBJECT"></a></p>
-<h3><code>ERR_INVALID_TRANSFER_OBJECT</code><span><a class="mark" href="#errors_err_invalid_transfer_object" id="errors_err_invalid_transfer_object">#</a></span></h3>
+<h4><code>ERR_INVALID_TRANSFER_OBJECT</code><span><a class="mark" href="#errors_err_invalid_transfer_object" id="errors_err_invalid_transfer_object">#</a></span></h4>
 <p>An invalid transfer object was passed to <code>postMessage()</code>.</p>
 <p><a id="ERR_INVALID_TUPLE"></a></p>
-<h3><code>ERR_INVALID_TUPLE</code><span><a class="mark" href="#errors_err_invalid_tuple" id="errors_err_invalid_tuple">#</a></span></h3>
+<h4><code>ERR_INVALID_TUPLE</code><span><a class="mark" href="#errors_err_invalid_tuple" id="errors_err_invalid_tuple">#</a></span></h4>
 <p>An element in the <code>iterable</code> provided to the <a href="url.html#url_the_whatwg_url_api">WHATWG</a>
 <a href="url.html#url_new_urlsearchparams_iterable"><code>URLSearchParams</code> constructor</a> did not
 represent a <code>[name, value]</code> tuple – that is, if an element is not iterable, or
 does not consist of exactly two elements.</p>
 <p><a id="ERR_INVALID_URI"></a></p>
-<h3><code>ERR_INVALID_URI</code><span><a class="mark" href="#errors_err_invalid_uri" id="errors_err_invalid_uri">#</a></span></h3>
+<h4><code>ERR_INVALID_URI</code><span><a class="mark" href="#errors_err_invalid_uri" id="errors_err_invalid_uri">#</a></span></h4>
 <p>An invalid URI was passed.</p>
 <p><a id="ERR_INVALID_URL"></a></p>
-<h3><code>ERR_INVALID_URL</code><span><a class="mark" href="#errors_err_invalid_url" id="errors_err_invalid_url">#</a></span></h3>
+<h4><code>ERR_INVALID_URL</code><span><a class="mark" href="#errors_err_invalid_url" id="errors_err_invalid_url">#</a></span></h4>
 <p>An invalid URL was passed to the <a href="url.html#url_the_whatwg_url_api">WHATWG</a>
 <a href="url.html#url_new_url_input_base"><code>URL</code> constructor</a> to be parsed. The thrown error object
 typically has an additional property <code>'input'</code> that contains the URL that failed
 to parse.</p>
 <p><a id="ERR_INVALID_URL_SCHEME"></a></p>
-<h3><code>ERR_INVALID_URL_SCHEME</code><span><a class="mark" href="#errors_err_invalid_url_scheme" id="errors_err_invalid_url_scheme">#</a></span></h3>
+<h4><code>ERR_INVALID_URL_SCHEME</code><span><a class="mark" href="#errors_err_invalid_url_scheme" id="errors_err_invalid_url_scheme">#</a></span></h4>
 <p>An attempt was made to use a URL of an incompatible scheme (protocol) for a
 specific purpose. It is only used in the <a href="url.html#url_the_whatwg_url_api">WHATWG URL API</a> support in the
 <a href="fs.html"><code>fs</code></a> module (which only accepts URLs with <code>'file'</code> scheme), but may be used
 in other Node.js APIs as well in the future.</p>
 <p><a id="ERR_IPC_CHANNEL_CLOSED"></a></p>
-<h3><code>ERR_IPC_CHANNEL_CLOSED</code><span><a class="mark" href="#errors_err_ipc_channel_closed" id="errors_err_ipc_channel_closed">#</a></span></h3>
+<h4><code>ERR_IPC_CHANNEL_CLOSED</code><span><a class="mark" href="#errors_err_ipc_channel_closed" id="errors_err_ipc_channel_closed">#</a></span></h4>
 <p>An attempt was made to use an IPC communication channel that was already closed.</p>
 <p><a id="ERR_IPC_DISCONNECTED"></a></p>
-<h3><code>ERR_IPC_DISCONNECTED</code><span><a class="mark" href="#errors_err_ipc_disconnected" id="errors_err_ipc_disconnected">#</a></span></h3>
+<h4><code>ERR_IPC_DISCONNECTED</code><span><a class="mark" href="#errors_err_ipc_disconnected" id="errors_err_ipc_disconnected">#</a></span></h4>
 <p>An attempt was made to disconnect an IPC communication channel that was already
 disconnected. See the documentation for the <a href="child_process.html"><code>child_process</code></a> module
 for more information.</p>
 <p><a id="ERR_IPC_ONE_PIPE"></a></p>
-<h3><code>ERR_IPC_ONE_PIPE</code><span><a class="mark" href="#errors_err_ipc_one_pipe" id="errors_err_ipc_one_pipe">#</a></span></h3>
+<h4><code>ERR_IPC_ONE_PIPE</code><span><a class="mark" href="#errors_err_ipc_one_pipe" id="errors_err_ipc_one_pipe">#</a></span></h4>
 <p>An attempt was made to create a child Node.js process using more than one IPC
 communication channel. See the documentation for the <a href="child_process.html"><code>child_process</code></a> module
 for more information.</p>
 <p><a id="ERR_IPC_SYNC_FORK"></a></p>
-<h3><code>ERR_IPC_SYNC_FORK</code><span><a class="mark" href="#errors_err_ipc_sync_fork" id="errors_err_ipc_sync_fork">#</a></span></h3>
+<h4><code>ERR_IPC_SYNC_FORK</code><span><a class="mark" href="#errors_err_ipc_sync_fork" id="errors_err_ipc_sync_fork">#</a></span></h4>
 <p>An attempt was made to open an IPC communication channel with a synchronously
 forked Node.js process. See the documentation for the <a href="child_process.html"><code>child_process</code></a> module
 for more information.</p>
 <p><a id="ERR_MANIFEST_ASSERT_INTEGRITY"></a></p>
-<h3><code>ERR_MANIFEST_ASSERT_INTEGRITY</code><span><a class="mark" href="#errors_err_manifest_assert_integrity" id="errors_err_manifest_assert_integrity">#</a></span></h3>
+<h4><code>ERR_MANIFEST_ASSERT_INTEGRITY</code><span><a class="mark" href="#errors_err_manifest_assert_integrity" id="errors_err_manifest_assert_integrity">#</a></span></h4>
 <p>An attempt was made to load a resource, but the resource did not match the
 integrity defined by the policy manifest. See the documentation for <a href="policy.html">policy</a>
 manifests for more information.</p>
 <p><a id="ERR_MANIFEST_DEPENDENCY_MISSING"></a></p>
-<h3><code>ERR_MANIFEST_DEPENDENCY_MISSING</code><span><a class="mark" href="#errors_err_manifest_dependency_missing" id="errors_err_manifest_dependency_missing">#</a></span></h3>
+<h4><code>ERR_MANIFEST_DEPENDENCY_MISSING</code><span><a class="mark" href="#errors_err_manifest_dependency_missing" id="errors_err_manifest_dependency_missing">#</a></span></h4>
 <p>An attempt was made to load a resource, but the resource was not listed as a
 dependency from the location that attempted to load it. See the documentation
 for <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MANIFEST_INTEGRITY_MISMATCH"></a></p>
-<h3><code>ERR_MANIFEST_INTEGRITY_MISMATCH</code><span><a class="mark" href="#errors_err_manifest_integrity_mismatch" id="errors_err_manifest_integrity_mismatch">#</a></span></h3>
+<h4><code>ERR_MANIFEST_INTEGRITY_MISMATCH</code><span><a class="mark" href="#errors_err_manifest_integrity_mismatch" id="errors_err_manifest_integrity_mismatch">#</a></span></h4>
 <p>An attempt was made to load a policy manifest, but the manifest had multiple
 entries for a resource which did not match each other. Update the manifest
 entries to match in order to resolve this error. See the documentation for
 <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MANIFEST_INVALID_RESOURCE_FIELD"></a></p>
-<h3><code>ERR_MANIFEST_INVALID_RESOURCE_FIELD</code><span><a class="mark" href="#errors_err_manifest_invalid_resource_field" id="errors_err_manifest_invalid_resource_field">#</a></span></h3>
+<h4><code>ERR_MANIFEST_INVALID_RESOURCE_FIELD</code><span><a class="mark" href="#errors_err_manifest_invalid_resource_field" id="errors_err_manifest_invalid_resource_field">#</a></span></h4>
 <p>A policy manifest resource had an invalid value for one of its fields. Update
 the manifest entry to match in order to resolve this error. See the
 documentation for <a href="policy.html">policy</a> manifests for more information.</p>
+<p><a id="ERR_MANIFEST_INVALID_SPECIFIER"></a></p>
+<h4><code>ERR_MANIFEST_INVALID_SPECIFIER</code><span><a class="mark" href="#errors_err_manifest_invalid_specifier" id="errors_err_manifest_invalid_specifier">#</a></span></h4>
+<p>A policy manifest resource had an invalid value for one of its dependency
+mappings. Update the manifest entry to match to resolve this error. See the
+documentation for <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MANIFEST_PARSE_POLICY"></a></p>
-<h3><code>ERR_MANIFEST_PARSE_POLICY</code><span><a class="mark" href="#errors_err_manifest_parse_policy" id="errors_err_manifest_parse_policy">#</a></span></h3>
+<h4><code>ERR_MANIFEST_PARSE_POLICY</code><span><a class="mark" href="#errors_err_manifest_parse_policy" id="errors_err_manifest_parse_policy">#</a></span></h4>
 <p>An attempt was made to load a policy manifest, but the manifest was unable to
 be parsed. See the documentation for <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MANIFEST_TDZ"></a></p>
-<h3><code>ERR_MANIFEST_TDZ</code><span><a class="mark" href="#errors_err_manifest_tdz" id="errors_err_manifest_tdz">#</a></span></h3>
+<h4><code>ERR_MANIFEST_TDZ</code><span><a class="mark" href="#errors_err_manifest_tdz" id="errors_err_manifest_tdz">#</a></span></h4>
 <p>An attempt was made to read from a policy manifest, but the manifest
 initialization has not yet taken place. This is likely a bug in Node.js.</p>
 <p><a id="ERR_MANIFEST_UNKNOWN_ONERROR"></a></p>
-<h3><code>ERR_MANIFEST_UNKNOWN_ONERROR</code><span><a class="mark" href="#errors_err_manifest_unknown_onerror" id="errors_err_manifest_unknown_onerror">#</a></span></h3>
+<h4><code>ERR_MANIFEST_UNKNOWN_ONERROR</code><span><a class="mark" href="#errors_err_manifest_unknown_onerror" id="errors_err_manifest_unknown_onerror">#</a></span></h4>
 <p>A policy manifest was loaded, but had an unknown value for its "onerror"
 behavior. See the documentation for <a href="policy.html">policy</a> manifests for more information.</p>
 <p><a id="ERR_MEMORY_ALLOCATION_FAILED"></a></p>
-<h3><code>ERR_MEMORY_ALLOCATION_FAILED</code><span><a class="mark" href="#errors_err_memory_allocation_failed" id="errors_err_memory_allocation_failed">#</a></span></h3>
+<h4><code>ERR_MEMORY_ALLOCATION_FAILED</code><span><a class="mark" href="#errors_err_memory_allocation_failed" id="errors_err_memory_allocation_failed">#</a></span></h4>
 <p>An attempt was made to allocate memory (usually in the C++ layer) but it
 failed.</p>
 <p><a id="ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE"></a></p>
-<h3><code>ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE</code><span><a class="mark" href="#errors_err_message_target_context_unavailable" id="errors_err_message_target_context_unavailable">#</a></span></h3>
+<h4><code>ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE</code><span><a class="mark" href="#errors_err_message_target_context_unavailable" id="errors_err_message_target_context_unavailable">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <p>A message posted to a <a href="worker_threads.html#worker_threads_class_messageport"><code>MessagePort</code></a> could not be deserialized in the target
 <a href="vm.html">vm</a> <code>Context</code>. Not all Node.js objects can be successfully instantiated in
 any context at this time, and attempting to transfer them using <code>postMessage()</code>
 can fail on the receiving side in that case.</p>
 <p><a id="ERR_METHOD_NOT_IMPLEMENTED"></a></p>
-<h3><code>ERR_METHOD_NOT_IMPLEMENTED</code><span><a class="mark" href="#errors_err_method_not_implemented" id="errors_err_method_not_implemented">#</a></span></h3>
+<h4><code>ERR_METHOD_NOT_IMPLEMENTED</code><span><a class="mark" href="#errors_err_method_not_implemented" id="errors_err_method_not_implemented">#</a></span></h4>
 <p>A method is required but not implemented.</p>
 <p><a id="ERR_MISSING_ARGS"></a></p>
-<h3><code>ERR_MISSING_ARGS</code><span><a class="mark" href="#errors_err_missing_args" id="errors_err_missing_args">#</a></span></h3>
+<h4><code>ERR_MISSING_ARGS</code><span><a class="mark" href="#errors_err_missing_args" id="errors_err_missing_args">#</a></span></h4>
 <p>A required argument of a Node.js API was not passed. This is only used for
 strict compliance with the API specification (which in some cases may accept
 <code>func(undefined)</code> but not <code>func()</code>). In most native Node.js APIs,
 <code>func(undefined)</code> and <code>func()</code> are treated identically, and the
 <a href="#ERR_INVALID_ARG_TYPE"><code>ERR_INVALID_ARG_TYPE</code></a> error code may be used instead.</p>
-<p><a id="ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK"></a></p>
-<h3><code>ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK</code><span><a class="mark" href="#errors_err_missing_dynamic_instantiate_hook" id="errors_err_missing_dynamic_instantiate_hook">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p>An <a href="esm.html">ES Module</a> loader hook specified <code>format: 'dynamic'</code> but did not provide
-a <code>dynamicInstantiate</code> hook.</p>
+<p><a id="ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST"></a></p>
+<h4><code>ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST</code><span><a class="mark" href="#errors_err_missing_message_port_in_transfer_list" id="errors_err_missing_message_port_in_transfer_list">#</a></span></h4>
+<p>An object that needs to be explicitly listed in the <code>transferList</code> argument
+is in the object passed to a <code>postMessage()</code> call, but is not provided
+in the <code>transferList</code> for that call. Usually, this is a <code>MessagePort</code>.</p>
 <p><a id="ERR_MISSING_OPTION"></a></p>
-<h3><code>ERR_MISSING_OPTION</code><span><a class="mark" href="#errors_err_missing_option" id="errors_err_missing_option">#</a></span></h3>
+<h4><code>ERR_MISSING_OPTION</code><span><a class="mark" href="#errors_err_missing_option" id="errors_err_missing_option">#</a></span></h4>
 <p>For APIs that accept options objects, some options might be mandatory. This code
 is thrown if a required option is missing.</p>
-<p><a id="ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST"></a></p>
-<h3><code>ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST</code><span><a class="mark" href="#errors_err_missing_message_port_in_transfer_list" id="errors_err_missing_message_port_in_transfer_list">#</a></span></h3>
-<p>An object that needs to be explicitly listed in the <code>transferList</code> argument
-was found in the object passed to a <code>postMessage()</code> call, but not provided in
-the <code>transferList</code> for that call. Usually, this is a <code>MessagePort</code>.</p>
 <p><a id="ERR_MISSING_PASSPHRASE"></a></p>
-<h3><code>ERR_MISSING_PASSPHRASE</code><span><a class="mark" href="#errors_err_missing_passphrase" id="errors_err_missing_passphrase">#</a></span></h3>
+<h4><code>ERR_MISSING_PASSPHRASE</code><span><a class="mark" href="#errors_err_missing_passphrase" id="errors_err_missing_passphrase">#</a></span></h4>
 <p>An attempt was made to read an encrypted key without specifying a passphrase.</p>
 <p><a id="ERR_MISSING_PLATFORM_FOR_WORKER"></a></p>
-<h3><code>ERR_MISSING_PLATFORM_FOR_WORKER</code><span><a class="mark" href="#errors_err_missing_platform_for_worker" id="errors_err_missing_platform_for_worker">#</a></span></h3>
+<h4><code>ERR_MISSING_PLATFORM_FOR_WORKER</code><span><a class="mark" href="#errors_err_missing_platform_for_worker" id="errors_err_missing_platform_for_worker">#</a></span></h4>
 <p>The V8 platform used by this instance of Node.js does not support creating
 Workers. This is caused by lack of embedder support for Workers. In particular,
 this error will not occur with standard builds of Node.js.</p>
 <p><a id="ERR_MODULE_NOT_FOUND"></a></p>
-<h3><code>ERR_MODULE_NOT_FOUND</code><span><a class="mark" href="#errors_err_module_not_found" id="errors_err_module_not_found">#</a></span></h3>
+<h4><code>ERR_MODULE_NOT_FOUND</code><span><a class="mark" href="#errors_err_module_not_found" id="errors_err_module_not_found">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>An <a href="esm.html">ES Module</a> could not be resolved.</p>
 <p><a id="ERR_MULTIPLE_CALLBACK"></a></p>
-<h3><code>ERR_MULTIPLE_CALLBACK</code><span><a class="mark" href="#errors_err_multiple_callback" id="errors_err_multiple_callback">#</a></span></h3>
+<h4><code>ERR_MULTIPLE_CALLBACK</code><span><a class="mark" href="#errors_err_multiple_callback" id="errors_err_multiple_callback">#</a></span></h4>
 <p>A callback was called more than once.</p>
 <p>A callback is almost always meant to only be called once as the query
 can either be fulfilled or rejected but not both at the same time. The latter
 would be possible by calling a callback more than once.</p>
 <p><a id="ERR_NAPI_CONS_FUNCTION"></a></p>
-<h3><code>ERR_NAPI_CONS_FUNCTION</code><span><a class="mark" href="#errors_err_napi_cons_function" id="errors_err_napi_cons_function">#</a></span></h3>
-<p>While using <code>N-API</code>, a constructor passed was not a function.</p>
+<h4><code>ERR_NAPI_CONS_FUNCTION</code><span><a class="mark" href="#errors_err_napi_cons_function" id="errors_err_napi_cons_function">#</a></span></h4>
+<p>While using <code>Node-API</code>, a constructor passed was not a function.</p>
 <p><a id="ERR_NAPI_INVALID_DATAVIEW_ARGS"></a></p>
-<h3><code>ERR_NAPI_INVALID_DATAVIEW_ARGS</code><span><a class="mark" href="#errors_err_napi_invalid_dataview_args" id="errors_err_napi_invalid_dataview_args">#</a></span></h3>
+<h4><code>ERR_NAPI_INVALID_DATAVIEW_ARGS</code><span><a class="mark" href="#errors_err_napi_invalid_dataview_args" id="errors_err_napi_invalid_dataview_args">#</a></span></h4>
 <p>While calling <code>napi_create_dataview()</code>, a given <code>offset</code> was outside the bounds
 of the dataview or <code>offset + length</code> was larger than a length of given <code>buffer</code>.</p>
 <p><a id="ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT"></a></p>
-<h3><code>ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT</code><span><a class="mark" href="#errors_err_napi_invalid_typedarray_alignment" id="errors_err_napi_invalid_typedarray_alignment">#</a></span></h3>
+<h4><code>ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT</code><span><a class="mark" href="#errors_err_napi_invalid_typedarray_alignment" id="errors_err_napi_invalid_typedarray_alignment">#</a></span></h4>
 <p>While calling <code>napi_create_typedarray()</code>, the provided <code>offset</code> was not a
 multiple of the element size.</p>
 <p><a id="ERR_NAPI_INVALID_TYPEDARRAY_LENGTH"></a></p>
-<h3><code>ERR_NAPI_INVALID_TYPEDARRAY_LENGTH</code><span><a class="mark" href="#errors_err_napi_invalid_typedarray_length" id="errors_err_napi_invalid_typedarray_length">#</a></span></h3>
+<h4><code>ERR_NAPI_INVALID_TYPEDARRAY_LENGTH</code><span><a class="mark" href="#errors_err_napi_invalid_typedarray_length" id="errors_err_napi_invalid_typedarray_length">#</a></span></h4>
 <p>While calling <code>napi_create_typedarray()</code>, <code>(length * size_of_element) + byte_offset</code> was larger than the length of given <code>buffer</code>.</p>
 <p><a id="ERR_NAPI_TSFN_CALL_JS"></a></p>
-<h3><code>ERR_NAPI_TSFN_CALL_JS</code><span><a class="mark" href="#errors_err_napi_tsfn_call_js" id="errors_err_napi_tsfn_call_js">#</a></span></h3>
+<h4><code>ERR_NAPI_TSFN_CALL_JS</code><span><a class="mark" href="#errors_err_napi_tsfn_call_js" id="errors_err_napi_tsfn_call_js">#</a></span></h4>
 <p>An error occurred while invoking the JavaScript portion of the thread-safe
 function.</p>
 <p><a id="ERR_NAPI_TSFN_GET_UNDEFINED"></a></p>
-<h3><code>ERR_NAPI_TSFN_GET_UNDEFINED</code><span><a class="mark" href="#errors_err_napi_tsfn_get_undefined" id="errors_err_napi_tsfn_get_undefined">#</a></span></h3>
+<h4><code>ERR_NAPI_TSFN_GET_UNDEFINED</code><span><a class="mark" href="#errors_err_napi_tsfn_get_undefined" id="errors_err_napi_tsfn_get_undefined">#</a></span></h4>
 <p>An error occurred while attempting to retrieve the JavaScript <code>undefined</code>
 value.</p>
 <p><a id="ERR_NAPI_TSFN_START_IDLE_LOOP"></a></p>
-<h3><code>ERR_NAPI_TSFN_START_IDLE_LOOP</code><span><a class="mark" href="#errors_err_napi_tsfn_start_idle_loop" id="errors_err_napi_tsfn_start_idle_loop">#</a></span></h3>
+<h4><code>ERR_NAPI_TSFN_START_IDLE_LOOP</code><span><a class="mark" href="#errors_err_napi_tsfn_start_idle_loop" id="errors_err_napi_tsfn_start_idle_loop">#</a></span></h4>
 <p>On the main thread, values are removed from the queue associated with the
 thread-safe function in an idle loop. This error indicates that an error
 has occurred when attempting to start the loop.</p>
 <p><a id="ERR_NAPI_TSFN_STOP_IDLE_LOOP"></a></p>
-<h3><code>ERR_NAPI_TSFN_STOP_IDLE_LOOP</code><span><a class="mark" href="#errors_err_napi_tsfn_stop_idle_loop" id="errors_err_napi_tsfn_stop_idle_loop">#</a></span></h3>
+<h4><code>ERR_NAPI_TSFN_STOP_IDLE_LOOP</code><span><a class="mark" href="#errors_err_napi_tsfn_stop_idle_loop" id="errors_err_napi_tsfn_stop_idle_loop">#</a></span></h4>
 <p>Once no more items are left in the queue, the idle loop must be suspended. This
 error indicates that the idle loop has failed to stop.</p>
 <p><a id="ERR_NO_CRYPTO"></a></p>
-<h3><code>ERR_NO_CRYPTO</code><span><a class="mark" href="#errors_err_no_crypto" id="errors_err_no_crypto">#</a></span></h3>
+<h4><code>ERR_NO_CRYPTO</code><span><a class="mark" href="#errors_err_no_crypto" id="errors_err_no_crypto">#</a></span></h4>
 <p>An attempt was made to use crypto features while Node.js was not compiled with
 OpenSSL crypto support.</p>
 <p><a id="ERR_NO_ICU"></a></p>
-<h3><code>ERR_NO_ICU</code><span><a class="mark" href="#errors_err_no_icu" id="errors_err_no_icu">#</a></span></h3>
+<h4><code>ERR_NO_ICU</code><span><a class="mark" href="#errors_err_no_icu" id="errors_err_no_icu">#</a></span></h4>
 <p>An attempt was made to use features that require <a href="intl.html#intl_internationalization_support">ICU</a>, but Node.js was not
 compiled with ICU support.</p>
 <p><a id="ERR_NON_CONTEXT_AWARE_DISABLED"></a></p>
-<h3><code>ERR_NON_CONTEXT_AWARE_DISABLED</code><span><a class="mark" href="#errors_err_non_context_aware_disabled" id="errors_err_non_context_aware_disabled">#</a></span></h3>
+<h4><code>ERR_NON_CONTEXT_AWARE_DISABLED</code><span><a class="mark" href="#errors_err_non_context_aware_disabled" id="errors_err_non_context_aware_disabled">#</a></span></h4>
 <p>A non-context-aware native addon was loaded in a process that disallows them.</p>
+<p><a id="ERR_OPERATION_FAILED"></a></p>
+<h4><code>ERR_OPERATION_FAILED</code><span><a class="mark" href="#errors_err_operation_failed" id="errors_err_operation_failed">#</a></span></h4>
+<p>An operation failed. This is typically used to signal the general failure of an
+asynchronous operation.</p>
 <p><a id="ERR_OUT_OF_RANGE"></a></p>
-<h3><code>ERR_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_out_of_range" id="errors_err_out_of_range">#</a></span></h3>
+<h4><code>ERR_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_out_of_range" id="errors_err_out_of_range">#</a></span></h4>
 <p>A given value is out of the accepted range.</p>
 <p><a id="ERR_PACKAGE_IMPORT_NOT_DEFINED"></a></p>
-<h3><code>ERR_PACKAGE_IMPORT_NOT_DEFINED</code><span><a class="mark" href="#errors_err_package_import_not_defined" id="errors_err_package_import_not_defined">#</a></span></h3>
+<h4><code>ERR_PACKAGE_IMPORT_NOT_DEFINED</code><span><a class="mark" href="#errors_err_package_import_not_defined" id="errors_err_package_import_not_defined">#</a></span></h4>
 <p>The <code>package.json</code> <a href="packages.html#packages_imports"><code>"imports"</code></a> field does not define the given internal
 package specifier mapping.</p>
 <p><a id="ERR_PACKAGE_PATH_NOT_EXPORTED"></a></p>
-<h3><code>ERR_PACKAGE_PATH_NOT_EXPORTED</code><span><a class="mark" href="#errors_err_package_path_not_exported" id="errors_err_package_path_not_exported">#</a></span></h3>
+<h4><code>ERR_PACKAGE_PATH_NOT_EXPORTED</code><span><a class="mark" href="#errors_err_package_path_not_exported" id="errors_err_package_path_not_exported">#</a></span></h4>
 <p>The <code>package.json</code> <a href="packages.html#packages_exports"><code>"exports"</code></a> field does not export the requested subpath.
 Because exports are encapsulated, private internal modules that are not exported
 cannot be imported through the package resolution, unless using an absolute URL.</p>
 <p><a id="ERR_PROTO_ACCESS"></a></p>
-<h3><code>ERR_PROTO_ACCESS</code><span><a class="mark" href="#errors_err_proto_access" id="errors_err_proto_access">#</a></span></h3>
+<h4><code>ERR_PROTO_ACCESS</code><span><a class="mark" href="#errors_err_proto_access" id="errors_err_proto_access">#</a></span></h4>
 <p>Accessing <code>Object.prototype.__proto__</code> has been forbidden using
 <a href="cli.html#cli_disable_proto_mode"><code>--disable-proto=throw</code></a>. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf"><code>Object.getPrototypeOf</code></a> and
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf"><code>Object.setPrototypeOf</code></a> should be used to get and set the prototype of an
 object.</p>
 <p><a id="ERR_REQUIRE_ESM"></a></p>
-<h3><code>ERR_REQUIRE_ESM</code><span><a class="mark" href="#errors_err_require_esm" id="errors_err_require_esm">#</a></span></h3>
+<h4><code>ERR_REQUIRE_ESM</code><span><a class="mark" href="#errors_err_require_esm" id="errors_err_require_esm">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>An attempt was made to <code>require()</code> an <a href="esm.html">ES Module</a>.</p>
 <p><a id="ERR_SCRIPT_EXECUTION_INTERRUPTED"></a></p>
-<h3><code>ERR_SCRIPT_EXECUTION_INTERRUPTED</code><span><a class="mark" href="#errors_err_script_execution_interrupted" id="errors_err_script_execution_interrupted">#</a></span></h3>
+<h4><code>ERR_SCRIPT_EXECUTION_INTERRUPTED</code><span><a class="mark" href="#errors_err_script_execution_interrupted" id="errors_err_script_execution_interrupted">#</a></span></h4>
 <p>Script execution was interrupted by <code>SIGINT</code> (For example,
 <kbd>Ctrl</kbd>+<kbd>C</kbd> was pressed.)</p>
 <p><a id="ERR_SCRIPT_EXECUTION_TIMEOUT"></a></p>
-<h3><code>ERR_SCRIPT_EXECUTION_TIMEOUT</code><span><a class="mark" href="#errors_err_script_execution_timeout" id="errors_err_script_execution_timeout">#</a></span></h3>
+<h4><code>ERR_SCRIPT_EXECUTION_TIMEOUT</code><span><a class="mark" href="#errors_err_script_execution_timeout" id="errors_err_script_execution_timeout">#</a></span></h4>
 <p>Script execution timed out, possibly due to bugs in the script being executed.</p>
 <p><a id="ERR_SERVER_ALREADY_LISTEN"></a></p>
-<h3><code>ERR_SERVER_ALREADY_LISTEN</code><span><a class="mark" href="#errors_err_server_already_listen" id="errors_err_server_already_listen">#</a></span></h3>
+<h4><code>ERR_SERVER_ALREADY_LISTEN</code><span><a class="mark" href="#errors_err_server_already_listen" id="errors_err_server_already_listen">#</a></span></h4>
 <p>The <a href="net.html#net_server_listen"><code>server.listen()</code></a> method was called while a <code>net.Server</code> was already
 listening. This applies to all instances of <code>net.Server</code>, including HTTP, HTTPS,
 and HTTP/2 <code>Server</code> instances.</p>
 <p><a id="ERR_SERVER_NOT_RUNNING"></a></p>
-<h3><code>ERR_SERVER_NOT_RUNNING</code><span><a class="mark" href="#errors_err_server_not_running" id="errors_err_server_not_running">#</a></span></h3>
+<h4><code>ERR_SERVER_NOT_RUNNING</code><span><a class="mark" href="#errors_err_server_not_running" id="errors_err_server_not_running">#</a></span></h4>
 <p>The <a href="net.html#net_server_close_callback"><code>server.close()</code></a> method was called when a <code>net.Server</code> was not
 running. This applies to all instances of <code>net.Server</code>, including HTTP, HTTPS,
 and HTTP/2 <code>Server</code> instances.</p>
 <p><a id="ERR_SOCKET_ALREADY_BOUND"></a></p>
-<h3><code>ERR_SOCKET_ALREADY_BOUND</code><span><a class="mark" href="#errors_err_socket_already_bound" id="errors_err_socket_already_bound">#</a></span></h3>
+<h4><code>ERR_SOCKET_ALREADY_BOUND</code><span><a class="mark" href="#errors_err_socket_already_bound" id="errors_err_socket_already_bound">#</a></span></h4>
 <p>An attempt was made to bind a socket that has already been bound.</p>
 <p><a id="ERR_SOCKET_BAD_BUFFER_SIZE"></a></p>
-<h3><code>ERR_SOCKET_BAD_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_socket_bad_buffer_size" id="errors_err_socket_bad_buffer_size">#</a></span></h3>
+<h4><code>ERR_SOCKET_BAD_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_socket_bad_buffer_size" id="errors_err_socket_bad_buffer_size">#</a></span></h4>
 <p>An invalid (negative) size was passed for either the <code>recvBufferSize</code> or
 <code>sendBufferSize</code> options in <a href="dgram.html#dgram_dgram_createsocket_options_callback"><code>dgram.createSocket()</code></a>.</p>
 <p><a id="ERR_SOCKET_BAD_PORT"></a></p>
-<h3><code>ERR_SOCKET_BAD_PORT</code><span><a class="mark" href="#errors_err_socket_bad_port" id="errors_err_socket_bad_port">#</a></span></h3>
+<h4><code>ERR_SOCKET_BAD_PORT</code><span><a class="mark" href="#errors_err_socket_bad_port" id="errors_err_socket_bad_port">#</a></span></h4>
 <p>An API function expecting a port >= 0 and &#x3C; 65536 received an invalid value.</p>
 <p><a id="ERR_SOCKET_BAD_TYPE"></a></p>
-<h3><code>ERR_SOCKET_BAD_TYPE</code><span><a class="mark" href="#errors_err_socket_bad_type" id="errors_err_socket_bad_type">#</a></span></h3>
+<h4><code>ERR_SOCKET_BAD_TYPE</code><span><a class="mark" href="#errors_err_socket_bad_type" id="errors_err_socket_bad_type">#</a></span></h4>
 <p>An API function expecting a socket type (<code>udp4</code> or <code>udp6</code>) received an invalid
 value.</p>
 <p><a id="ERR_SOCKET_BUFFER_SIZE"></a></p>
-<h3><code>ERR_SOCKET_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_socket_buffer_size" id="errors_err_socket_buffer_size">#</a></span></h3>
+<h4><code>ERR_SOCKET_BUFFER_SIZE</code><span><a class="mark" href="#errors_err_socket_buffer_size" id="errors_err_socket_buffer_size">#</a></span></h4>
 <p>While using <a href="dgram.html#dgram_dgram_createsocket_options_callback"><code>dgram.createSocket()</code></a>, the size of the receive or send <code>Buffer</code>
 could not be determined.</p>
-<p><a id="ERR_SOCKET_CANNOT_SEND"></a></p>
-<h3><code>ERR_SOCKET_CANNOT_SEND</code><span><a class="mark" href="#errors_err_socket_cannot_send" id="errors_err_socket_cannot_send">#</a></span></h3>
-<p>Data could be sent on a socket.</p>
 <p><a id="ERR_SOCKET_CLOSED"></a></p>
-<h3><code>ERR_SOCKET_CLOSED</code><span><a class="mark" href="#errors_err_socket_closed" id="errors_err_socket_closed">#</a></span></h3>
+<h4><code>ERR_SOCKET_CLOSED</code><span><a class="mark" href="#errors_err_socket_closed" id="errors_err_socket_closed">#</a></span></h4>
 <p>An attempt was made to operate on an already closed socket.</p>
 <p><a id="ERR_SOCKET_DGRAM_IS_CONNECTED"></a></p>
-<h3><code>ERR_SOCKET_DGRAM_IS_CONNECTED</code><span><a class="mark" href="#errors_err_socket_dgram_is_connected" id="errors_err_socket_dgram_is_connected">#</a></span></h3>
+<h4><code>ERR_SOCKET_DGRAM_IS_CONNECTED</code><span><a class="mark" href="#errors_err_socket_dgram_is_connected" id="errors_err_socket_dgram_is_connected">#</a></span></h4>
 <p>A <a href="dgram.html#dgram_socket_connect_port_address_callback"><code>dgram.connect()</code></a> call was made on an already connected socket.</p>
 <p><a id="ERR_SOCKET_DGRAM_NOT_CONNECTED"></a></p>
-<h3><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code><span><a class="mark" href="#errors_err_socket_dgram_not_connected" id="errors_err_socket_dgram_not_connected">#</a></span></h3>
+<h4><code>ERR_SOCKET_DGRAM_NOT_CONNECTED</code><span><a class="mark" href="#errors_err_socket_dgram_not_connected" id="errors_err_socket_dgram_not_connected">#</a></span></h4>
 <p>A <a href="dgram.html#dgram_socket_disconnect"><code>dgram.disconnect()</code></a> or <a href="dgram.html#dgram_socket_remoteaddress"><code>dgram.remoteAddress()</code></a> call was made on a
 disconnected socket.</p>
 <p><a id="ERR_SOCKET_DGRAM_NOT_RUNNING"></a></p>
-<h3><code>ERR_SOCKET_DGRAM_NOT_RUNNING</code><span><a class="mark" href="#errors_err_socket_dgram_not_running" id="errors_err_socket_dgram_not_running">#</a></span></h3>
+<h4><code>ERR_SOCKET_DGRAM_NOT_RUNNING</code><span><a class="mark" href="#errors_err_socket_dgram_not_running" id="errors_err_socket_dgram_not_running">#</a></span></h4>
 <p>A call was made and the UDP subsystem was not running.</p>
 <p><a id="ERR_SRI_PARSE"></a></p>
-<h3><code>ERR_SRI_PARSE</code><span><a class="mark" href="#errors_err_sri_parse" id="errors_err_sri_parse">#</a></span></h3>
+<h4><code>ERR_SRI_PARSE</code><span><a class="mark" href="#errors_err_sri_parse" id="errors_err_sri_parse">#</a></span></h4>
 <p>A string was provided for a Subresource Integrity check, but was unable to be
 parsed. Check the format of integrity attributes by looking at the
 <a href="https://www.w3.org/TR/SRI/#the-integrity-attribute">Subresource Integrity specification</a>.</p>
+<p><a id="ERR_STREAM_ALREADY_FINISHED"></a></p>
+<h4><code>ERR_STREAM_ALREADY_FINISHED</code><span><a class="mark" href="#errors_err_stream_already_finished" id="errors_err_stream_already_finished">#</a></span></h4>
+<p>A stream method was called that cannot complete because the stream was
+finished.</p>
 <p><a id="ERR_STREAM_CANNOT_PIPE"></a></p>
-<h3><code>ERR_STREAM_CANNOT_PIPE</code><span><a class="mark" href="#errors_err_stream_cannot_pipe" id="errors_err_stream_cannot_pipe">#</a></span></h3>
+<h4><code>ERR_STREAM_CANNOT_PIPE</code><span><a class="mark" href="#errors_err_stream_cannot_pipe" id="errors_err_stream_cannot_pipe">#</a></span></h4>
 <p>An attempt was made to call <a href="stream.html#stream_readable_pipe_destination_options"><code>stream.pipe()</code></a> on a <a href="stream.html#stream_class_stream_writable"><code>Writable</code></a> stream.</p>
 <p><a id="ERR_STREAM_DESTROYED"></a></p>
-<h3><code>ERR_STREAM_DESTROYED</code><span><a class="mark" href="#errors_err_stream_destroyed" id="errors_err_stream_destroyed">#</a></span></h3>
+<h4><code>ERR_STREAM_DESTROYED</code><span><a class="mark" href="#errors_err_stream_destroyed" id="errors_err_stream_destroyed">#</a></span></h4>
 <p>A stream method was called that cannot complete because the stream was
 destroyed using <code>stream.destroy()</code>.</p>
 <p><a id="ERR_STREAM_NULL_VALUES"></a></p>
-<h3><code>ERR_STREAM_NULL_VALUES</code><span><a class="mark" href="#errors_err_stream_null_values" id="errors_err_stream_null_values">#</a></span></h3>
+<h4><code>ERR_STREAM_NULL_VALUES</code><span><a class="mark" href="#errors_err_stream_null_values" id="errors_err_stream_null_values">#</a></span></h4>
 <p>An attempt was made to call <a href="stream.html#stream_writable_write_chunk_encoding_callback"><code>stream.write()</code></a> with a <code>null</code> chunk.</p>
 <p><a id="ERR_STREAM_PREMATURE_CLOSE"></a></p>
-<h3><code>ERR_STREAM_PREMATURE_CLOSE</code><span><a class="mark" href="#errors_err_stream_premature_close" id="errors_err_stream_premature_close">#</a></span></h3>
+<h4><code>ERR_STREAM_PREMATURE_CLOSE</code><span><a class="mark" href="#errors_err_stream_premature_close" id="errors_err_stream_premature_close">#</a></span></h4>
 <p>An error returned by <code>stream.finished()</code> and <code>stream.pipeline()</code>, when a stream
 or a pipeline ends non gracefully with no explicit error.</p>
 <p><a id="ERR_STREAM_PUSH_AFTER_EOF"></a></p>
-<h3><code>ERR_STREAM_PUSH_AFTER_EOF</code><span><a class="mark" href="#errors_err_stream_push_after_eof" id="errors_err_stream_push_after_eof">#</a></span></h3>
+<h4><code>ERR_STREAM_PUSH_AFTER_EOF</code><span><a class="mark" href="#errors_err_stream_push_after_eof" id="errors_err_stream_push_after_eof">#</a></span></h4>
 <p>An attempt was made to call <a href="stream.html#stream_readable_push_chunk_encoding"><code>stream.push()</code></a> after a <code>null</code>(EOF) had been
 pushed to the stream.</p>
 <p><a id="ERR_STREAM_UNSHIFT_AFTER_END_EVENT"></a></p>
-<h3><code>ERR_STREAM_UNSHIFT_AFTER_END_EVENT</code><span><a class="mark" href="#errors_err_stream_unshift_after_end_event" id="errors_err_stream_unshift_after_end_event">#</a></span></h3>
+<h4><code>ERR_STREAM_UNSHIFT_AFTER_END_EVENT</code><span><a class="mark" href="#errors_err_stream_unshift_after_end_event" id="errors_err_stream_unshift_after_end_event">#</a></span></h4>
 <p>An attempt was made to call <a href="stream.html#stream_readable_unshift_chunk_encoding"><code>stream.unshift()</code></a> after the <code>'end'</code> event was
 emitted.</p>
 <p><a id="ERR_STREAM_WRAP"></a></p>
-<h3><code>ERR_STREAM_WRAP</code><span><a class="mark" href="#errors_err_stream_wrap" id="errors_err_stream_wrap">#</a></span></h3>
+<h4><code>ERR_STREAM_WRAP</code><span><a class="mark" href="#errors_err_stream_wrap" id="errors_err_stream_wrap">#</a></span></h4>
 <p>Prevents an abort if a string decoder was set on the Socket or if the decoder
 is in <code>objectMode</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> Socket = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).Socket;
-<span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">new</span> Socket();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">Socket</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>).<span class="hljs-property">Socket</span>;
+<span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Socket</span>();
 
-instance.setEncoding(<span class="hljs-string">'utf8'</span>);</code></pre>
+instance.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);</code></pre>
 <p><a id="ERR_STREAM_WRITE_AFTER_END"></a></p>
-<h3><code>ERR_STREAM_WRITE_AFTER_END</code><span><a class="mark" href="#errors_err_stream_write_after_end" id="errors_err_stream_write_after_end">#</a></span></h3>
+<h4><code>ERR_STREAM_WRITE_AFTER_END</code><span><a class="mark" href="#errors_err_stream_write_after_end" id="errors_err_stream_write_after_end">#</a></span></h4>
 <p>An attempt was made to call <a href="stream.html#stream_writable_write_chunk_encoding_callback"><code>stream.write()</code></a> after <code>stream.end()</code> has been
 called.</p>
 <p><a id="ERR_STRING_TOO_LONG"></a></p>
-<h3><code>ERR_STRING_TOO_LONG</code><span><a class="mark" href="#errors_err_string_too_long" id="errors_err_string_too_long">#</a></span></h3>
+<h4><code>ERR_STRING_TOO_LONG</code><span><a class="mark" href="#errors_err_string_too_long" id="errors_err_string_too_long">#</a></span></h4>
 <p>An attempt has been made to create a string longer than the maximum allowed
 length.</p>
 <p><a id="ERR_SYNTHETIC"></a></p>
-<h3><code>ERR_SYNTHETIC</code><span><a class="mark" href="#errors_err_synthetic" id="errors_err_synthetic">#</a></span></h3>
+<h4><code>ERR_SYNTHETIC</code><span><a class="mark" href="#errors_err_synthetic" id="errors_err_synthetic">#</a></span></h4>
 <p>An artificial error object used to capture the call stack for diagnostic
 reports.</p>
 <p><a id="ERR_SYSTEM_ERROR"></a></p>
-<h3><code>ERR_SYSTEM_ERROR</code><span><a class="mark" href="#errors_err_system_error" id="errors_err_system_error">#</a></span></h3>
+<h4><code>ERR_SYSTEM_ERROR</code><span><a class="mark" href="#errors_err_system_error" id="errors_err_system_error">#</a></span></h4>
 <p>An unspecified or non-specific system error has occurred within the Node.js
 process. The error object will have an <code>err.info</code> object property with
 additional details.</p>
+<p><a id="ERR_TLS_CERT_ALTNAME_FORMAT"></a></p>
+<h4><code>ERR_TLS_CERT_ALTNAME_FORMAT</code><span><a class="mark" href="#errors_err_tls_cert_altname_format" id="errors_err_tls_cert_altname_format">#</a></span></h4>
+<p>This error is thrown by <code>checkServerIdentity</code> if a user-supplied
+<code>subjectaltname</code> property violates encoding rules. Certificate objects produced
+by Node.js itself always comply with encoding rules and will never cause
+this error.</p>
 <p><a id="ERR_TLS_CERT_ALTNAME_INVALID"></a></p>
-<h3><code>ERR_TLS_CERT_ALTNAME_INVALID</code><span><a class="mark" href="#errors_err_tls_cert_altname_invalid" id="errors_err_tls_cert_altname_invalid">#</a></span></h3>
+<h4><code>ERR_TLS_CERT_ALTNAME_INVALID</code><span><a class="mark" href="#errors_err_tls_cert_altname_invalid" id="errors_err_tls_cert_altname_invalid">#</a></span></h4>
 <p>While using TLS, the host name/IP of the peer did not match any of the
 <code>subjectAltNames</code> in its certificate.</p>
 <p><a id="ERR_TLS_DH_PARAM_SIZE"></a></p>
-<h3><code>ERR_TLS_DH_PARAM_SIZE</code><span><a class="mark" href="#errors_err_tls_dh_param_size" id="errors_err_tls_dh_param_size">#</a></span></h3>
+<h4><code>ERR_TLS_DH_PARAM_SIZE</code><span><a class="mark" href="#errors_err_tls_dh_param_size" id="errors_err_tls_dh_param_size">#</a></span></h4>
 <p>While using TLS, the parameter offered for the Diffie-Hellman (<code>DH</code>)
 key-agreement protocol is too small. By default, the key length must be greater
 than or equal to 1024 bits to avoid vulnerabilities, even though it is strongly
 recommended to use 2048 bits or larger for stronger security.</p>
 <p><a id="ERR_TLS_HANDSHAKE_TIMEOUT"></a></p>
-<h3><code>ERR_TLS_HANDSHAKE_TIMEOUT</code><span><a class="mark" href="#errors_err_tls_handshake_timeout" id="errors_err_tls_handshake_timeout">#</a></span></h3>
+<h4><code>ERR_TLS_HANDSHAKE_TIMEOUT</code><span><a class="mark" href="#errors_err_tls_handshake_timeout" id="errors_err_tls_handshake_timeout">#</a></span></h4>
 <p>A TLS/SSL handshake timed out. In this case, the server must also abort the
 connection.</p>
 <p><a id="ERR_TLS_INVALID_CONTEXT"></a></p>
-<h3><code>ERR_TLS_INVALID_CONTEXT</code><span><a class="mark" href="#errors_err_tls_invalid_context" id="errors_err_tls_invalid_context">#</a></span></h3>
+<h4><code>ERR_TLS_INVALID_CONTEXT</code><span><a class="mark" href="#errors_err_tls_invalid_context" id="errors_err_tls_invalid_context">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0</span>
 </div>
 <p>The context must be a <code>SecureContext</code>.</p>
-<p><a id="ERR_TLS_INVALID_STATE"></a></p>
-<h3><code>ERR_TLS_INVALID_STATE</code><span><a class="mark" href="#errors_err_tls_invalid_state" id="errors_err_tls_invalid_state">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.17.0</span>
-</div>
-<p>The TLS socket must be connected and securily established. Ensure the 'secure'
-event is emitted before continuing.</p>
 <p><a id="ERR_TLS_INVALID_PROTOCOL_METHOD"></a></p>
-<h3><code>ERR_TLS_INVALID_PROTOCOL_METHOD</code><span><a class="mark" href="#errors_err_tls_invalid_protocol_method" id="errors_err_tls_invalid_protocol_method">#</a></span></h3>
+<h4><code>ERR_TLS_INVALID_PROTOCOL_METHOD</code><span><a class="mark" href="#errors_err_tls_invalid_protocol_method" id="errors_err_tls_invalid_protocol_method">#</a></span></h4>
 <p>The specified  <code>secureProtocol</code> method is invalid. It is  either unknown, or
 disabled because it is insecure.</p>
 <p><a id="ERR_TLS_INVALID_PROTOCOL_VERSION"></a></p>
-<h3><code>ERR_TLS_INVALID_PROTOCOL_VERSION</code><span><a class="mark" href="#errors_err_tls_invalid_protocol_version" id="errors_err_tls_invalid_protocol_version">#</a></span></h3>
+<h4><code>ERR_TLS_INVALID_PROTOCOL_VERSION</code><span><a class="mark" href="#errors_err_tls_invalid_protocol_version" id="errors_err_tls_invalid_protocol_version">#</a></span></h4>
 <p>Valid TLS protocol versions are <code>'TLSv1'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1.2'</code>.</p>
+<p><a id="ERR_TLS_INVALID_STATE"></a></p>
+<h4><code>ERR_TLS_INVALID_STATE</code><span><a class="mark" href="#errors_err_tls_invalid_state" id="errors_err_tls_invalid_state">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.10.0, v12.17.0</span>
+</div>
+<p>The TLS socket must be connected and securily established. Ensure the 'secure'
+event is emitted before continuing.</p>
 <p><a id="ERR_TLS_PROTOCOL_VERSION_CONFLICT"></a></p>
-<h3><code>ERR_TLS_PROTOCOL_VERSION_CONFLICT</code><span><a class="mark" href="#errors_err_tls_protocol_version_conflict" id="errors_err_tls_protocol_version_conflict">#</a></span></h3>
+<h4><code>ERR_TLS_PROTOCOL_VERSION_CONFLICT</code><span><a class="mark" href="#errors_err_tls_protocol_version_conflict" id="errors_err_tls_protocol_version_conflict">#</a></span></h4>
 <p>Attempting to set a TLS protocol <code>minVersion</code> or <code>maxVersion</code> conflicts with an
 attempt to set the <code>secureProtocol</code> explicitly. Use one mechanism or the other.</p>
+<p><a id="ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED"></a></p>
+<h4><code>ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED</code><span><a class="mark" href="#errors_err_tls_psk_set_identiy_hint_failed" id="errors_err_tls_psk_set_identiy_hint_failed">#</a></span></h4>
+<p>Failed to set PSK identity hint. Hint may be too long.</p>
 <p><a id="ERR_TLS_RENEGOTIATION_DISABLED"></a></p>
-<h3><code>ERR_TLS_RENEGOTIATION_DISABLED</code><span><a class="mark" href="#errors_err_tls_renegotiation_disabled" id="errors_err_tls_renegotiation_disabled">#</a></span></h3>
+<h4><code>ERR_TLS_RENEGOTIATION_DISABLED</code><span><a class="mark" href="#errors_err_tls_renegotiation_disabled" id="errors_err_tls_renegotiation_disabled">#</a></span></h4>
 <p>An attempt was made to renegotiate TLS on a socket instance with TLS disabled.</p>
 <p><a id="ERR_TLS_REQUIRED_SERVER_NAME"></a></p>
-<h3><code>ERR_TLS_REQUIRED_SERVER_NAME</code><span><a class="mark" href="#errors_err_tls_required_server_name" id="errors_err_tls_required_server_name">#</a></span></h3>
+<h4><code>ERR_TLS_REQUIRED_SERVER_NAME</code><span><a class="mark" href="#errors_err_tls_required_server_name" id="errors_err_tls_required_server_name">#</a></span></h4>
 <p>While using TLS, the <code>server.addContext()</code> method was called without providing
 a host name in the first parameter.</p>
 <p><a id="ERR_TLS_SESSION_ATTACK"></a></p>
-<h3><code>ERR_TLS_SESSION_ATTACK</code><span><a class="mark" href="#errors_err_tls_session_attack" id="errors_err_tls_session_attack">#</a></span></h3>
+<h4><code>ERR_TLS_SESSION_ATTACK</code><span><a class="mark" href="#errors_err_tls_session_attack" id="errors_err_tls_session_attack">#</a></span></h4>
 <p>An excessive amount of TLS renegotiations is detected, which is a potential
 vector for denial-of-service attacks.</p>
 <p><a id="ERR_TLS_SNI_FROM_SERVER"></a></p>
-<h3><code>ERR_TLS_SNI_FROM_SERVER</code><span><a class="mark" href="#errors_err_tls_sni_from_server" id="errors_err_tls_sni_from_server">#</a></span></h3>
+<h4><code>ERR_TLS_SNI_FROM_SERVER</code><span><a class="mark" href="#errors_err_tls_sni_from_server" id="errors_err_tls_sni_from_server">#</a></span></h4>
 <p>An attempt was made to issue Server Name Indication from a TLS server-side
 socket, which is only valid from a client.</p>
-<p><a id="ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED"></a></p>
-<h3><code>ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED</code><span><a class="mark" href="#errors_err_tls_psk_set_identiy_hint_failed" id="errors_err_tls_psk_set_identiy_hint_failed">#</a></span></h3>
-<p>Failed to set PSK identity hint. Hint may be too long.</p>
 <p><a id="ERR_TRACE_EVENTS_CATEGORY_REQUIRED"></a></p>
-<h3><code>ERR_TRACE_EVENTS_CATEGORY_REQUIRED</code><span><a class="mark" href="#errors_err_trace_events_category_required" id="errors_err_trace_events_category_required">#</a></span></h3>
+<h4><code>ERR_TRACE_EVENTS_CATEGORY_REQUIRED</code><span><a class="mark" href="#errors_err_trace_events_category_required" id="errors_err_trace_events_category_required">#</a></span></h4>
 <p>The <code>trace_events.createTracing()</code> method requires at least one trace event
 category.</p>
 <p><a id="ERR_TRACE_EVENTS_UNAVAILABLE"></a></p>
-<h3><code>ERR_TRACE_EVENTS_UNAVAILABLE</code><span><a class="mark" href="#errors_err_trace_events_unavailable" id="errors_err_trace_events_unavailable">#</a></span></h3>
+<h4><code>ERR_TRACE_EVENTS_UNAVAILABLE</code><span><a class="mark" href="#errors_err_trace_events_unavailable" id="errors_err_trace_events_unavailable">#</a></span></h4>
 <p>The <code>trace_events</code> module could not be loaded because Node.js was compiled with
 the <code>--without-v8-platform</code> flag.</p>
-<p><a id="ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER"></a></p>
-<h3><code>ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER</code><span><a class="mark" href="#errors_err_transferring_externalized_sharedarraybuffer" id="errors_err_transferring_externalized_sharedarraybuffer">#</a></span></h3>
-<p>A <code>SharedArrayBuffer</code> whose memory is not managed by the JavaScript engine
-or by Node.js was encountered during serialization. Such a <code>SharedArrayBuffer</code>
-cannot be serialized.</p>
-<p>This can only happen when native addons create <code>SharedArrayBuffer</code>s in
-"externalized" mode, or put existing <code>SharedArrayBuffer</code> into externalized mode.</p>
 <p><a id="ERR_TRANSFORM_ALREADY_TRANSFORMING"></a></p>
-<h3><code>ERR_TRANSFORM_ALREADY_TRANSFORMING</code><span><a class="mark" href="#errors_err_transform_already_transforming" id="errors_err_transform_already_transforming">#</a></span></h3>
+<h4><code>ERR_TRANSFORM_ALREADY_TRANSFORMING</code><span><a class="mark" href="#errors_err_transform_already_transforming" id="errors_err_transform_already_transforming">#</a></span></h4>
 <p>A <code>Transform</code> stream finished while it was still transforming.</p>
 <p><a id="ERR_TRANSFORM_WITH_LENGTH_0"></a></p>
-<h3><code>ERR_TRANSFORM_WITH_LENGTH_0</code><span><a class="mark" href="#errors_err_transform_with_length_0" id="errors_err_transform_with_length_0">#</a></span></h3>
+<h4><code>ERR_TRANSFORM_WITH_LENGTH_0</code><span><a class="mark" href="#errors_err_transform_with_length_0" id="errors_err_transform_with_length_0">#</a></span></h4>
 <p>A <code>Transform</code> stream finished with data still in the write buffer.</p>
 <p><a id="ERR_TTY_INIT_FAILED"></a></p>
-<h3><code>ERR_TTY_INIT_FAILED</code><span><a class="mark" href="#errors_err_tty_init_failed" id="errors_err_tty_init_failed">#</a></span></h3>
+<h4><code>ERR_TTY_INIT_FAILED</code><span><a class="mark" href="#errors_err_tty_init_failed" id="errors_err_tty_init_failed">#</a></span></h4>
 <p>The initialization of a TTY failed due to a system error.</p>
 <p><a id="ERR_UNAVAILABLE_DURING_EXIT"></a></p>
-<h3><code>ERR_UNAVAILABLE_DURING_EXIT</code><span><a class="mark" href="#errors_err_unavailable_during_exit" id="errors_err_unavailable_during_exit">#</a></span></h3>
-<p>Function was called within a <a href="process.html#Event:-%60&#x27;exit&#x27;%60"><code>process.on('exit')</code></a> handler that shouldn't be
-called within <a href="process.html#Event:-%60&#x27;exit&#x27;%60"><code>process.on('exit')</code></a> handler.</p>
+<h4><code>ERR_UNAVAILABLE_DURING_EXIT</code><span><a class="mark" href="#errors_err_unavailable_during_exit" id="errors_err_unavailable_during_exit">#</a></span></h4>
+<p>Function was called within a <a href="process.html#process_event_exit"><code>process.on('exit')</code></a> handler that shouldn't be
+called within <a href="process.html#process_event_exit"><code>process.on('exit')</code></a> handler.</p>
 <p><a id="ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET"></a></p>
-<h3><code>ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET</code><span><a class="mark" href="#errors_err_uncaught_exception_capture_already_set" id="errors_err_uncaught_exception_capture_already_set">#</a></span></h3>
+<h4><code>ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET</code><span><a class="mark" href="#errors_err_uncaught_exception_capture_already_set" id="errors_err_uncaught_exception_capture_already_set">#</a></span></h4>
 <p><a href="process.html#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> was called twice,
 without first resetting the callback to <code>null</code>.</p>
 <p>This error is designed to prevent accidentally overwriting a callback registered
 from another module.</p>
 <p><a id="ERR_UNESCAPED_CHARACTERS"></a></p>
-<h3><code>ERR_UNESCAPED_CHARACTERS</code><span><a class="mark" href="#errors_err_unescaped_characters" id="errors_err_unescaped_characters">#</a></span></h3>
+<h4><code>ERR_UNESCAPED_CHARACTERS</code><span><a class="mark" href="#errors_err_unescaped_characters" id="errors_err_unescaped_characters">#</a></span></h4>
 <p>A string that contained unescaped characters was received.</p>
 <p><a id="ERR_UNHANDLED_ERROR"></a></p>
-<h3><code>ERR_UNHANDLED_ERROR</code><span><a class="mark" href="#errors_err_unhandled_error" id="errors_err_unhandled_error">#</a></span></h3>
+<h4><code>ERR_UNHANDLED_ERROR</code><span><a class="mark" href="#errors_err_unhandled_error" id="errors_err_unhandled_error">#</a></span></h4>
 <p>An unhandled error occurred (for instance, when an <code>'error'</code> event is emitted
 by an <a href="events.html#events_class_eventemitter"><code>EventEmitter</code></a> but an <code>'error'</code> handler is not registered).</p>
 <p><a id="ERR_UNKNOWN_BUILTIN_MODULE"></a></p>
-<h3><code>ERR_UNKNOWN_BUILTIN_MODULE</code><span><a class="mark" href="#errors_err_unknown_builtin_module" id="errors_err_unknown_builtin_module">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_BUILTIN_MODULE</code><span><a class="mark" href="#errors_err_unknown_builtin_module" id="errors_err_unknown_builtin_module">#</a></span></h4>
 <p>Used to identify a specific kind of internal Node.js error that should not
 typically be triggered by user code. Instances of this error point to an
 internal bug within the Node.js binary itself.</p>
 <p><a id="ERR_UNKNOWN_CREDENTIAL"></a></p>
-<h3><code>ERR_UNKNOWN_CREDENTIAL</code><span><a class="mark" href="#errors_err_unknown_credential" id="errors_err_unknown_credential">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_CREDENTIAL</code><span><a class="mark" href="#errors_err_unknown_credential" id="errors_err_unknown_credential">#</a></span></h4>
 <p>A Unix group or user identifier that does not exist was passed.</p>
 <p><a id="ERR_UNKNOWN_ENCODING"></a></p>
-<h3><code>ERR_UNKNOWN_ENCODING</code><span><a class="mark" href="#errors_err_unknown_encoding" id="errors_err_unknown_encoding">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_ENCODING</code><span><a class="mark" href="#errors_err_unknown_encoding" id="errors_err_unknown_encoding">#</a></span></h4>
 <p>An invalid or unknown encoding option was passed to an API.</p>
 <p><a id="ERR_UNKNOWN_FILE_EXTENSION"></a></p>
-<h3><code>ERR_UNKNOWN_FILE_EXTENSION</code><span><a class="mark" href="#errors_err_unknown_file_extension" id="errors_err_unknown_file_extension">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_FILE_EXTENSION</code><span><a class="mark" href="#errors_err_unknown_file_extension" id="errors_err_unknown_file_extension">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>An attempt was made to load a module with an unknown or unsupported file
 extension.</p>
 <p><a id="ERR_UNKNOWN_MODULE_FORMAT"></a></p>
-<h3><code>ERR_UNKNOWN_MODULE_FORMAT</code><span><a class="mark" href="#errors_err_unknown_module_format" id="errors_err_unknown_module_format">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_MODULE_FORMAT</code><span><a class="mark" href="#errors_err_unknown_module_format" id="errors_err_unknown_module_format">#</a></span></h4>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>An attempt was made to load a module with an unknown or unsupported format.</p>
 <p><a id="ERR_UNKNOWN_SIGNAL"></a></p>
-<h3><code>ERR_UNKNOWN_SIGNAL</code><span><a class="mark" href="#errors_err_unknown_signal" id="errors_err_unknown_signal">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_SIGNAL</code><span><a class="mark" href="#errors_err_unknown_signal" id="errors_err_unknown_signal">#</a></span></h4>
 <p>An invalid or unknown process signal was passed to an API expecting a valid
 signal (such as <a href="child_process.html#child_process_subprocess_kill_signal"><code>subprocess.kill()</code></a>).</p>
 <p><a id="ERR_UNSUPPORTED_DIR_IMPORT"></a></p>
-<h3><code>ERR_UNSUPPORTED_DIR_IMPORT</code><span><a class="mark" href="#errors_err_unsupported_dir_import" id="errors_err_unsupported_dir_import">#</a></span></h3>
+<h4><code>ERR_UNSUPPORTED_DIR_IMPORT</code><span><a class="mark" href="#errors_err_unsupported_dir_import" id="errors_err_unsupported_dir_import">#</a></span></h4>
 <p><code>import</code> a directory URL is unsupported. Instead,
 <a href="packages.html#packages_self_referencing_a_package_using_its_name">self-reference a package using its name</a> and <a href="packages.html#packages_subpath_exports">define a custom subpath</a> in
 the <a href="packages.html#packages_exports"><code>"exports"</code></a> field of the <a href="packages.html#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file.</p>
@@ -1947,17 +2051,17 @@ the <a href="packages.html#packages_exports"><code>"exports"</code></a> field of
 <span class="hljs-keyword">import</span> <span class="hljs-string">'./index.js'</span>; <span class="hljs-comment">// supported</span>
 <span class="hljs-keyword">import</span> <span class="hljs-string">'package-name'</span>; <span class="hljs-comment">// supported</span></code></pre>
 <p><a id="ERR_UNSUPPORTED_ESM_URL_SCHEME"></a></p>
-<h3><code>ERR_UNSUPPORTED_ESM_URL_SCHEME</code><span><a class="mark" href="#errors_err_unsupported_esm_url_scheme" id="errors_err_unsupported_esm_url_scheme">#</a></span></h3>
+<h4><code>ERR_UNSUPPORTED_ESM_URL_SCHEME</code><span><a class="mark" href="#errors_err_unsupported_esm_url_scheme" id="errors_err_unsupported_esm_url_scheme">#</a></span></h4>
 <p><code>import</code> with URL schemes other than <code>file</code> and <code>data</code> is unsupported.</p>
 <p><a id="ERR_VALID_PERFORMANCE_ENTRY_TYPE"></a></p>
-<h3><code>ERR_VALID_PERFORMANCE_ENTRY_TYPE</code><span><a class="mark" href="#errors_err_valid_performance_entry_type" id="errors_err_valid_performance_entry_type">#</a></span></h3>
+<h4><code>ERR_VALID_PERFORMANCE_ENTRY_TYPE</code><span><a class="mark" href="#errors_err_valid_performance_entry_type" id="errors_err_valid_performance_entry_type">#</a></span></h4>
 <p>While using the Performance Timing API (<code>perf_hooks</code>), no valid performance
-entry types were found.</p>
+entry types are found.</p>
 <p><a id="ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"></a></p>
-<h3><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code><span><a class="mark" href="#errors_err_vm_dynamic_import_callback_missing" id="errors_err_vm_dynamic_import_callback_missing">#</a></span></h3>
+<h4><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code><span><a class="mark" href="#errors_err_vm_dynamic_import_callback_missing" id="errors_err_vm_dynamic_import_callback_missing">#</a></span></h4>
 <p>A dynamic import callback was not specified.</p>
 <p><a id="ERR_VM_MODULE_ALREADY_LINKED"></a></p>
-<h3><code>ERR_VM_MODULE_ALREADY_LINKED</code><span><a class="mark" href="#errors_err_vm_module_already_linked" id="errors_err_vm_module_already_linked">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_ALREADY_LINKED</code><span><a class="mark" href="#errors_err_vm_module_already_linked" id="errors_err_vm_module_already_linked">#</a></span></h4>
 <p>The module attempted to be linked is not eligible for linking, because of one of
 the following reasons:</p>
 <ul>
@@ -1966,68 +2070,71 @@ the following reasons:</p>
 <li>Linking has failed for this module (<code>linkingStatus</code> is <code>'errored'</code>)</li>
 </ul>
 <p><a id="ERR_VM_MODULE_CACHED_DATA_REJECTED"></a></p>
-<h3><code>ERR_VM_MODULE_CACHED_DATA_REJECTED</code><span><a class="mark" href="#errors_err_vm_module_cached_data_rejected" id="errors_err_vm_module_cached_data_rejected">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_CACHED_DATA_REJECTED</code><span><a class="mark" href="#errors_err_vm_module_cached_data_rejected" id="errors_err_vm_module_cached_data_rejected">#</a></span></h4>
 <p>The <code>cachedData</code> option passed to a module constructor is invalid.</p>
 <p><a id="ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA"></a></p>
-<h3><code>ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA</code><span><a class="mark" href="#errors_err_vm_module_cannot_create_cached_data" id="errors_err_vm_module_cannot_create_cached_data">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA</code><span><a class="mark" href="#errors_err_vm_module_cannot_create_cached_data" id="errors_err_vm_module_cannot_create_cached_data">#</a></span></h4>
 <p>Cached data cannot be created for modules which have already been evaluated.</p>
 <p><a id="ERR_VM_MODULE_DIFFERENT_CONTEXT"></a></p>
-<h3><code>ERR_VM_MODULE_DIFFERENT_CONTEXT</code><span><a class="mark" href="#errors_err_vm_module_different_context" id="errors_err_vm_module_different_context">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_DIFFERENT_CONTEXT</code><span><a class="mark" href="#errors_err_vm_module_different_context" id="errors_err_vm_module_different_context">#</a></span></h4>
 <p>The module being returned from the linker function is from a different context
 than the parent module. Linked modules must share the same context.</p>
 <p><a id="ERR_VM_MODULE_LINKING_ERRORED"></a></p>
-<h3><code>ERR_VM_MODULE_LINKING_ERRORED</code><span><a class="mark" href="#errors_err_vm_module_linking_errored" id="errors_err_vm_module_linking_errored">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_LINKING_ERRORED</code><span><a class="mark" href="#errors_err_vm_module_linking_errored" id="errors_err_vm_module_linking_errored">#</a></span></h4>
 <p>The linker function returned a module for which linking has failed.</p>
+<p><a id="ERR_VM_MODULE_LINK_FAILURE"></a></p>
+<h4><code>ERR_VM_MODULE_LINK_FAILURE</code><span><a class="mark" href="#errors_err_vm_module_link_failure" id="errors_err_vm_module_link_failure">#</a></span></h4>
+<p>The module was unable to be linked due to a failure.</p>
 <p><a id="ERR_VM_MODULE_NOT_MODULE"></a></p>
-<h3><code>ERR_VM_MODULE_NOT_MODULE</code><span><a class="mark" href="#errors_err_vm_module_not_module" id="errors_err_vm_module_not_module">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_NOT_MODULE</code><span><a class="mark" href="#errors_err_vm_module_not_module" id="errors_err_vm_module_not_module">#</a></span></h4>
 <p>The fulfilled value of a linking promise is not a <code>vm.Module</code> object.</p>
 <p><a id="ERR_VM_MODULE_STATUS"></a></p>
-<h3><code>ERR_VM_MODULE_STATUS</code><span><a class="mark" href="#errors_err_vm_module_status" id="errors_err_vm_module_status">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_STATUS</code><span><a class="mark" href="#errors_err_vm_module_status" id="errors_err_vm_module_status">#</a></span></h4>
 <p>The current module's status does not allow for this operation. The specific
 meaning of the error depends on the specific function.</p>
 <p><a id="ERR_WASI_ALREADY_STARTED"></a></p>
-<h3><code>ERR_WASI_ALREADY_STARTED</code><span><a class="mark" href="#errors_err_wasi_already_started" id="errors_err_wasi_already_started">#</a></span></h3>
+<h4><code>ERR_WASI_ALREADY_STARTED</code><span><a class="mark" href="#errors_err_wasi_already_started" id="errors_err_wasi_already_started">#</a></span></h4>
 <p>The WASI instance has already started.</p>
 <p><a id="ERR_WASI_NOT_STARTED"></a></p>
-<h3><code>ERR_WASI_NOT_STARTED</code><span><a class="mark" href="#errors_err_wasi_not_started" id="errors_err_wasi_not_started">#</a></span></h3>
+<h4><code>ERR_WASI_NOT_STARTED</code><span><a class="mark" href="#errors_err_wasi_not_started" id="errors_err_wasi_not_started">#</a></span></h4>
 <p>The WASI instance has not been started.</p>
 <p><a id="ERR_WORKER_INIT_FAILED"></a></p>
-<h3><code>ERR_WORKER_INIT_FAILED</code><span><a class="mark" href="#errors_err_worker_init_failed" id="errors_err_worker_init_failed">#</a></span></h3>
+<h4><code>ERR_WORKER_INIT_FAILED</code><span><a class="mark" href="#errors_err_worker_init_failed" id="errors_err_worker_init_failed">#</a></span></h4>
 <p>The <code>Worker</code> initialization failed.</p>
 <p><a id="ERR_WORKER_INVALID_EXEC_ARGV"></a></p>
-<h3><code>ERR_WORKER_INVALID_EXEC_ARGV</code><span><a class="mark" href="#errors_err_worker_invalid_exec_argv" id="errors_err_worker_invalid_exec_argv">#</a></span></h3>
+<h4><code>ERR_WORKER_INVALID_EXEC_ARGV</code><span><a class="mark" href="#errors_err_worker_invalid_exec_argv" id="errors_err_worker_invalid_exec_argv">#</a></span></h4>
 <p>The <code>execArgv</code> option passed to the <code>Worker</code> constructor contains
 invalid flags.</p>
 <p><a id="ERR_WORKER_NOT_RUNNING"></a></p>
-<h3><code>ERR_WORKER_NOT_RUNNING</code><span><a class="mark" href="#errors_err_worker_not_running" id="errors_err_worker_not_running">#</a></span></h3>
+<h4><code>ERR_WORKER_NOT_RUNNING</code><span><a class="mark" href="#errors_err_worker_not_running" id="errors_err_worker_not_running">#</a></span></h4>
 <p>An operation failed because the <code>Worker</code> instance is not currently running.</p>
 <p><a id="ERR_WORKER_OUT_OF_MEMORY"></a></p>
-<h3><code>ERR_WORKER_OUT_OF_MEMORY</code><span><a class="mark" href="#errors_err_worker_out_of_memory" id="errors_err_worker_out_of_memory">#</a></span></h3>
+<h4><code>ERR_WORKER_OUT_OF_MEMORY</code><span><a class="mark" href="#errors_err_worker_out_of_memory" id="errors_err_worker_out_of_memory">#</a></span></h4>
 <p>The <code>Worker</code> instance terminated because it reached its memory limit.</p>
 <p><a id="ERR_WORKER_PATH"></a></p>
-<h3><code>ERR_WORKER_PATH</code><span><a class="mark" href="#errors_err_worker_path" id="errors_err_worker_path">#</a></span></h3>
+<h4><code>ERR_WORKER_PATH</code><span><a class="mark" href="#errors_err_worker_path" id="errors_err_worker_path">#</a></span></h4>
 <p>The path for the main script of a worker is neither an absolute path
 nor a relative path starting with <code>./</code> or <code>../</code>.</p>
 <p><a id="ERR_WORKER_UNSERIALIZABLE_ERROR"></a></p>
-<h3><code>ERR_WORKER_UNSERIALIZABLE_ERROR</code><span><a class="mark" href="#errors_err_worker_unserializable_error" id="errors_err_worker_unserializable_error">#</a></span></h3>
+<h4><code>ERR_WORKER_UNSERIALIZABLE_ERROR</code><span><a class="mark" href="#errors_err_worker_unserializable_error" id="errors_err_worker_unserializable_error">#</a></span></h4>
 <p>All attempts at serializing an uncaught exception from a worker thread failed.</p>
 <p><a id="ERR_WORKER_UNSUPPORTED_EXTENSION"></a></p>
-<h3><code>ERR_WORKER_UNSUPPORTED_EXTENSION</code><span><a class="mark" href="#errors_err_worker_unsupported_extension" id="errors_err_worker_unsupported_extension">#</a></span></h3>
+<h4><code>ERR_WORKER_UNSUPPORTED_EXTENSION</code><span><a class="mark" href="#errors_err_worker_unsupported_extension" id="errors_err_worker_unsupported_extension">#</a></span></h4>
 <p>The pathname used for the main script of a worker has an
 unknown file extension.</p>
 <p><a id="ERR_WORKER_UNSUPPORTED_OPERATION"></a></p>
-<h3><code>ERR_WORKER_UNSUPPORTED_OPERATION</code><span><a class="mark" href="#errors_err_worker_unsupported_operation" id="errors_err_worker_unsupported_operation">#</a></span></h3>
+<h4><code>ERR_WORKER_UNSUPPORTED_OPERATION</code><span><a class="mark" href="#errors_err_worker_unsupported_operation" id="errors_err_worker_unsupported_operation">#</a></span></h4>
 <p>The requested functionality is not supported in worker threads.</p>
 <p><a id="ERR_ZLIB_INITIALIZATION_FAILED"></a></p>
-<h3><code>ERR_ZLIB_INITIALIZATION_FAILED</code><span><a class="mark" href="#errors_err_zlib_initialization_failed" id="errors_err_zlib_initialization_failed">#</a></span></h3>
+<h4><code>ERR_ZLIB_INITIALIZATION_FAILED</code><span><a class="mark" href="#errors_err_zlib_initialization_failed" id="errors_err_zlib_initialization_failed">#</a></span></h4>
 <p>Creation of a <a href="zlib.html"><code>zlib</code></a> object failed due to incorrect configuration.</p>
 <p><a id="HPE_HEADER_OVERFLOW"></a></p>
-<h3><code>HPE_HEADER_OVERFLOW</code><span><a class="mark" href="#errors_hpe_header_overflow" id="errors_hpe_header_overflow">#</a></span></h3>
+<h4><code>HPE_HEADER_OVERFLOW</code><span><a class="mark" href="#errors_hpe_header_overflow" id="errors_hpe_header_overflow">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.4.0</td>
+<tr><td>v11.4.0, v10.15.0</td>
 <td><p>Max header size in <code>http_parser</code> was set to 8KB.</p></td></tr>
 </tbody></table>
 </details>
@@ -2037,14 +2144,14 @@ malconfigured clients, if more than 8KB of HTTP header data is received then
 HTTP parsing will abort without a request or response object being created, and
 an <code>Error</code> with this code will be emitted.</p>
 <p><a id="HPE_UNEXPECTED_CONTENT_LENGTH"></a></p>
-<h3><code>HPE_UNEXPECTED_CONTENT_LENGTH</code><span><a class="mark" href="#errors_hpe_unexpected_content_length" id="errors_hpe_unexpected_content_length">#</a></span></h3>
+<h4><code>HPE_UNEXPECTED_CONTENT_LENGTH</code><span><a class="mark" href="#errors_hpe_unexpected_content_length" id="errors_hpe_unexpected_content_length">#</a></span></h4>
 <p>Server is sending both a <code>Content-Length</code> header and <code>Transfer-Encoding: chunked</code>.</p>
 <p><code>Transfer-Encoding: chunked</code> allows the server to maintain an HTTP persistent
 connection for dynamically generated content.
 In this case, the <code>Content-Length</code> HTTP header cannot be used.</p>
 <p>Use <code>Content-Length</code> or <code>Transfer-Encoding: chunked</code>.</p>
 <p><a id="MODULE_NOT_FOUND"></a></p>
-<h3><code>MODULE_NOT_FOUND</code><span><a class="mark" href="#errors_module_not_found" id="errors_module_not_found">#</a></span></h3>
+<h4><code>MODULE_NOT_FOUND</code><span><a class="mark" href="#errors_module_not_found" id="errors_module_not_found">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2056,26 +2163,19 @@ In this case, the <code>Content-Length</code> HTTP header cannot be used.</p>
 </div>
 <p>A module file could not be resolved while attempting a <a href="modules.html#modules_require_id"><code>require()</code></a> or
 <code>import</code> operation.</p>
-<h2>Legacy Node.js error codes<span><a class="mark" href="#errors_legacy_node_js_error_codes" id="errors_legacy_node_js_error_codes">#</a></span></h2>
+</section><section><h3>Legacy Node.js error codes<span><a class="mark" href="#errors_legacy_node_js_error_codes" id="errors_legacy_node_js_error_codes">#</a></span></h3>
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. These error codes are either inconsistent, or have
 been removed.</div><p></p>
 <p><a id="ERR_CANNOT_TRANSFER_OBJECT"></a></p>
-<h3><code>ERR_CANNOT_TRANSFER_OBJECT</code><span><a class="mark" href="#errors_err_cannot_transfer_object" id="errors_err_cannot_transfer_object">#</a></span></h3>
+<h4><code>ERR_CANNOT_TRANSFER_OBJECT</code><span><a class="mark" href="#errors_err_cannot_transfer_object" id="errors_err_cannot_transfer_object">#</a></span></h4>
 <!--
 added: v10.5.0
 removed: v12.5.0
 -->
 <p>The value passed to <code>postMessage()</code> contained an object that is not supported
 for transferring.</p>
-<p><a id="ERR_CLOSED_MESSAGE_PORT"></a></p>
-<h3><code>ERR_CLOSED_MESSAGE_PORT</code><span><a class="mark" href="#errors_err_closed_message_port" id="errors_err_closed_message_port">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.5.0</span><span>Removed in: v11.12.0</span>
-</div>
-<p>There was an attempt to use a <code>MessagePort</code> instance in a closed
-state, usually after <code>.close()</code> has been called.</p>
 <p><a id="ERR_CRYPTO_HASH_DIGEST_NO_UTF16"></a></p>
-<h3><code>ERR_CRYPTO_HASH_DIGEST_NO_UTF16</code><span><a class="mark" href="#errors_err_crypto_hash_digest_no_utf16" id="errors_err_crypto_hash_digest_no_utf16">#</a></span></h3>
+<h4><code>ERR_CRYPTO_HASH_DIGEST_NO_UTF16</code><span><a class="mark" href="#errors_err_crypto_hash_digest_no_utf16" id="errors_err_crypto_hash_digest_no_utf16">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v12.12.0</span>
 </div>
@@ -2084,76 +2184,85 @@ state, usually after <code>.close()</code> has been called.</p>
 causing the method to return a string rather than a <code>Buffer</code>, the UTF-16
 encoding (e.g. <code>ucs</code> or <code>utf16le</code>) is not supported.</p>
 <p><a id="ERR_HTTP2_FRAME_ERROR"></a></p>
-<h3><code>ERR_HTTP2_FRAME_ERROR</code><span><a class="mark" href="#errors_err_http2_frame_error" id="errors_err_http2_frame_error">#</a></span></h3>
+<h4><code>ERR_HTTP2_FRAME_ERROR</code><span><a class="mark" href="#errors_err_http2_frame_error" id="errors_err_http2_frame_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when a failure occurs sending an individual frame on the HTTP/2
 session.</p>
 <p><a id="ERR_HTTP2_HEADERS_OBJECT"></a></p>
-<h3><code>ERR_HTTP2_HEADERS_OBJECT</code><span><a class="mark" href="#errors_err_http2_headers_object" id="errors_err_http2_headers_object">#</a></span></h3>
+<h4><code>ERR_HTTP2_HEADERS_OBJECT</code><span><a class="mark" href="#errors_err_http2_headers_object" id="errors_err_http2_headers_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an HTTP/2 Headers Object is expected.</p>
 <p><a id="ERR_HTTP2_HEADER_REQUIRED"></a></p>
-<h3><code>ERR_HTTP2_HEADER_REQUIRED</code><span><a class="mark" href="#errors_err_http2_header_required" id="errors_err_http2_header_required">#</a></span></h3>
+<h4><code>ERR_HTTP2_HEADER_REQUIRED</code><span><a class="mark" href="#errors_err_http2_header_required" id="errors_err_http2_header_required">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when a required header is missing in an HTTP/2 message.</p>
 <p><a id="ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND"></a></p>
-<h3><code>ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND</code><span><a class="mark" href="#errors_err_http2_info_headers_after_respond" id="errors_err_http2_info_headers_after_respond">#</a></span></h3>
+<h4><code>ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND</code><span><a class="mark" href="#errors_err_http2_info_headers_after_respond" id="errors_err_http2_info_headers_after_respond">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>HTTP/2 informational headers must only be sent <em>prior</em> to calling the
 <code>Http2Stream.prototype.respond()</code> method.</p>
 <p><a id="ERR_HTTP2_STREAM_CLOSED"></a></p>
-<h3><code>ERR_HTTP2_STREAM_CLOSED</code><span><a class="mark" href="#errors_err_http2_stream_closed" id="errors_err_http2_stream_closed">#</a></span></h3>
+<h4><code>ERR_HTTP2_STREAM_CLOSED</code><span><a class="mark" href="#errors_err_http2_stream_closed" id="errors_err_http2_stream_closed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an action has been performed on an HTTP/2 Stream that has already
 been closed.</p>
 <p><a id="ERR_HTTP_INVALID_CHAR"></a></p>
-<h3><code>ERR_HTTP_INVALID_CHAR</code><span><a class="mark" href="#errors_err_http_invalid_char" id="errors_err_http_invalid_char">#</a></span></h3>
+<h4><code>ERR_HTTP_INVALID_CHAR</code><span><a class="mark" href="#errors_err_http_invalid_char" id="errors_err_http_invalid_char">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an invalid character is found in an HTTP response status message
 (reason phrase).</p>
+<p><a id="ERR_HTTP_REQUEST_TIMEOUT"></a></p>
+<h4><code>ERR_HTTP_REQUEST_TIMEOUT</code><span><a class="mark" href="#errors_err_http_request_timeout" id="errors_err_http_request_timeout">#</a></span></h4>
+<p>The client has not sent the entire request within the allowed time.</p>
 <p><a id="ERR_INDEX_OUT_OF_RANGE"></a></p>
-<h3><code>ERR_INDEX_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_index_out_of_range" id="errors_err_index_out_of_range">#</a></span></h3>
+<h4><code>ERR_INDEX_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_index_out_of_range" id="errors_err_index_out_of_range">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span><span>Removed in: v11.0.0</span>
 </div>
 <p>A given index was out of the accepted range (e.g. negative offsets).</p>
 <p><a id="ERR_NAPI_CONS_PROTOTYPE_OBJECT"></a></p>
-<h3><code>ERR_NAPI_CONS_PROTOTYPE_OBJECT</code><span><a class="mark" href="#errors_err_napi_cons_prototype_object" id="errors_err_napi_cons_prototype_object">#</a></span></h3>
+<h4><code>ERR_NAPI_CONS_PROTOTYPE_OBJECT</code><span><a class="mark" href="#errors_err_napi_cons_prototype_object" id="errors_err_napi_cons_prototype_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
-<p>Used by the <code>N-API</code> when <code>Constructor.prototype</code> is not an object.</p>
+<p>Used by the <code>Node-API</code> when <code>Constructor.prototype</code> is not an object.</p>
 <p><a id="ERR_NO_LONGER_SUPPORTED"></a></p>
-<h3><code>ERR_NO_LONGER_SUPPORTED</code><span><a class="mark" href="#errors_err_no_longer_supported" id="errors_err_no_longer_supported">#</a></span></h3>
+<h4><code>ERR_NO_LONGER_SUPPORTED</code><span><a class="mark" href="#errors_err_no_longer_supported" id="errors_err_no_longer_supported">#</a></span></h4>
 <p>A Node.js API was called in an unsupported manner, such as
 <code>Buffer.write(string, encoding, offset[, length])</code>.</p>
 <p><a id="ERR_OUTOFMEMORY"></a></p>
-<h3><code>ERR_OUTOFMEMORY</code><span><a class="mark" href="#errors_err_outofmemory" id="errors_err_outofmemory">#</a></span></h3>
+<h4><code>ERR_OUTOFMEMORY</code><span><a class="mark" href="#errors_err_outofmemory" id="errors_err_outofmemory">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used generically to identify that an operation caused an out of memory
 condition.</p>
 <p><a id="ERR_PARSE_HISTORY_DATA"></a></p>
-<h3><code>ERR_PARSE_HISTORY_DATA</code><span><a class="mark" href="#errors_err_parse_history_data" id="errors_err_parse_history_data">#</a></span></h3>
+<h4><code>ERR_PARSE_HISTORY_DATA</code><span><a class="mark" href="#errors_err_parse_history_data" id="errors_err_parse_history_data">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>The <code>repl</code> module was unable to parse data from the REPL history file.</p>
+<p><a id="ERR_SOCKET_CANNOT_SEND"></a></p>
+<h4><code>ERR_SOCKET_CANNOT_SEND</code><span><a class="mark" href="#errors_err_socket_cannot_send" id="errors_err_socket_cannot_send">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v9.0.0</span><span>Removed in: v14.0.0</span>
+</div>
+<p>Data could not be sent on a socket.</p>
 <p><a id="ERR_STDERR_CLOSE"></a></p>
-<h3><code>ERR_STDERR_CLOSE</code><span><a class="mark" href="#errors_err_stderr_close" id="errors_err_stderr_close">#</a></span></h3>
+<h4><code>ERR_STDERR_CLOSE</code><span><a class="mark" href="#errors_err_stderr_close" id="errors_err_stderr_close">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2168,7 +2277,7 @@ condition.</p>
 <p>An attempt was made to close the <code>process.stderr</code> stream. By design, Node.js
 does not allow <code>stdout</code> or <code>stderr</code> streams to be closed by user code.</p>
 <p><a id="ERR_STDOUT_CLOSE"></a></p>
-<h3><code>ERR_STDOUT_CLOSE</code><span><a class="mark" href="#errors_err_stdout_close" id="errors_err_stdout_close">#</a></span></h3>
+<h4><code>ERR_STDOUT_CLOSE</code><span><a class="mark" href="#errors_err_stdout_close" id="errors_err_stdout_close">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2183,29 +2292,30 @@ does not allow <code>stdout</code> or <code>stderr</code> streams to be closed b
 <p>An attempt was made to close the <code>process.stdout</code> stream. By design, Node.js
 does not allow <code>stdout</code> or <code>stderr</code> streams to be closed by user code.</p>
 <p><a id="ERR_STREAM_READ_NOT_IMPLEMENTED"></a></p>
-<h3><code>ERR_STREAM_READ_NOT_IMPLEMENTED</code><span><a class="mark" href="#errors_err_stream_read_not_implemented" id="errors_err_stream_read_not_implemented">#</a></span></h3>
+<h4><code>ERR_STREAM_READ_NOT_IMPLEMENTED</code><span><a class="mark" href="#errors_err_stream_read_not_implemented" id="errors_err_stream_read_not_implemented">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an attempt is made to use a readable stream that has not implemented
 <a href="stream.html#stream_readable_read_size_1"><code>readable._read()</code></a>.</p>
 <p><a id="ERR_TLS_RENEGOTIATION_FAILED"></a></p>
-<h3><code>ERR_TLS_RENEGOTIATION_FAILED</code><span><a class="mark" href="#errors_err_tls_renegotiation_failed" id="errors_err_tls_renegotiation_failed">#</a></span></h3>
+<h4><code>ERR_TLS_RENEGOTIATION_FAILED</code><span><a class="mark" href="#errors_err_tls_renegotiation_failed" id="errors_err_tls_renegotiation_failed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when a TLS renegotiation request has failed in a non-specific way.</p>
-<p><a id="ERR_UNKNOWN_BUILTIN_MODULE"></a></p>
-<h3><code>ERR_UNKNOWN_BUILTIN_MODULE</code><span><a class="mark" href="#errors_err_unknown_builtin_module_1" id="errors_err_unknown_builtin_module_1">#</a></span></h3>
+<p><a id="ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER"></a></p>
+<h4><code>ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER</code><span><a class="mark" href="#errors_err_transferring_externalized_sharedarraybuffer" id="errors_err_transferring_externalized_sharedarraybuffer">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v8.0.0</span><span>Removed in: v9.0.0</span>
+<span>Added in: v10.5.0</span><span>Removed in: v14.0.0</span>
 </div>
-<p>The <code>'ERR_UNKNOWN_BUILTIN_MODULE'</code> error code is used to identify a specific
-kind of internal Node.js error that should not typically be triggered by user
-code. Instances of this error point to an internal bug within the Node.js
-binary itself.</p>
+<p>A <code>SharedArrayBuffer</code> whose memory is not managed by the JavaScript engine
+or by Node.js was encountered during serialization. Such a <code>SharedArrayBuffer</code>
+cannot be serialized.</p>
+<p>This can only happen when native addons create <code>SharedArrayBuffer</code>s in
+"externalized" mode, or put existing <code>SharedArrayBuffer</code> into externalized mode.</p>
 <p><a id="ERR_UNKNOWN_STDIN_TYPE"></a></p>
-<h3><code>ERR_UNKNOWN_STDIN_TYPE</code><span><a class="mark" href="#errors_err_unknown_stdin_type" id="errors_err_unknown_stdin_type">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_STDIN_TYPE</code><span><a class="mark" href="#errors_err_unknown_stdin_type" id="errors_err_unknown_stdin_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span><span>Removed in: v11.7.0</span>
 </div>
@@ -2213,7 +2323,7 @@ binary itself.</p>
 type. This error is usually an indication of a bug within Node.js itself,
 although it is possible for user code to trigger it.</p>
 <p><a id="ERR_UNKNOWN_STREAM_TYPE"></a></p>
-<h3><code>ERR_UNKNOWN_STREAM_TYPE</code><span><a class="mark" href="#errors_err_unknown_stream_type" id="errors_err_unknown_stream_type">#</a></span></h3>
+<h4><code>ERR_UNKNOWN_STREAM_TYPE</code><span><a class="mark" href="#errors_err_unknown_stream_type" id="errors_err_unknown_stream_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span><span>Removed in: v11.7.0</span>
 </div>
@@ -2221,27 +2331,63 @@ although it is possible for user code to trigger it.</p>
 <code>stderr</code> file type. This error is usually an indication of a bug within Node.js
 itself, although it is possible for user code to trigger it.</p>
 <p><a id="ERR_V8BREAKITERATOR"></a></p>
-<h3><code>ERR_V8BREAKITERATOR</code><span><a class="mark" href="#errors_err_v8breakiterator" id="errors_err_v8breakiterator">#</a></span></h3>
+<h4><code>ERR_V8BREAKITERATOR</code><span><a class="mark" href="#errors_err_v8breakiterator" id="errors_err_v8breakiterator">#</a></span></h4>
 <p>The V8 <code>BreakIterator</code> API was used but the full ICU data set is not installed.</p>
 <p><a id="ERR_VALUE_OUT_OF_RANGE"></a></p>
-<h3><code>ERR_VALUE_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_value_out_of_range" id="errors_err_value_out_of_range">#</a></span></h3>
+<h4><code>ERR_VALUE_OUT_OF_RANGE</code><span><a class="mark" href="#errors_err_value_out_of_range" id="errors_err_value_out_of_range">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when a given value is out of the accepted range.</p>
 <p><a id="ERR_VM_MODULE_NOT_LINKED"></a></p>
-<h3><code>ERR_VM_MODULE_NOT_LINKED</code><span><a class="mark" href="#errors_err_vm_module_not_linked" id="errors_err_vm_module_not_linked">#</a></span></h3>
+<h4><code>ERR_VM_MODULE_NOT_LINKED</code><span><a class="mark" href="#errors_err_vm_module_not_linked" id="errors_err_vm_module_not_linked">#</a></span></h4>
 <p>The module must be successfully linked before instantiation.</p>
 <p><a id="ERR_ZLIB_BINDING_CLOSED"></a></p>
-<h3><code>ERR_ZLIB_BINDING_CLOSED</code><span><a class="mark" href="#errors_err_zlib_binding_closed" id="errors_err_zlib_binding_closed">#</a></span></h3>
+<h4><code>ERR_ZLIB_BINDING_CLOSED</code><span><a class="mark" href="#errors_err_zlib_binding_closed" id="errors_err_zlib_binding_closed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span><span>Removed in: v10.0.0</span>
 </div>
 <p>Used when an attempt is made to use a <code>zlib</code> object after it has already been
-closed.</p>
+closed.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/errors.json b/doc/api/errors.json
index 638fb72620a53c345af4a06b00e78fccf507efe5..bfdf9feebdb527488e4cd984ef6b807a17597bef 100644
--- a/doc/api/errors.json
+++ b/doc/api/errors.json
@@ -99,7 +99,7 @@
       "textRaw": "Class: `SystemError`",
       "type": "class",
       "name": "SystemError",
-      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Node.js generates system errors when exceptions occur within its runtime\nenvironment. These usually occur when an application violates an operating\nsystem constraint. For example, a system error will occur if an application\nattempts to read a file that does not exist.</p>\n<ul>\n<li><code>address</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the address to which a network connection\nfailed</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> The string error code</li>\n<li><code>dest</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path destination when reporting a file\nsystem error</li>\n<li><code>errno</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The system-provided error number</li>\n<li><code>info</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> If present, extra details about the error condition</li>\n<li><code>message</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A system-provided human-readable description of the error</li>\n<li><code>path</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path when reporting a file system error</li>\n<li><code>port</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> If present, the network connection port that is not available</li>\n<li><code>syscall</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The name of the system call that triggered the error</li>\n</ul>",
+      "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Node.js generates system errors when exceptions occur within its runtime\nenvironment. These usually occur when an application violates an operating\nsystem constraint. For example, a system error will occur if an application\nattempts to read a file that does not exist.</p>\n<ul>\n<li><code>address</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the address to which a network connection\nfailed</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> The string error code</li>\n<li><code>dest</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path destination when reporting a file\nsystem error</li>\n<li><code>errno</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The system-provided error number</li>\n<li><code>info</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> If present, extra details about the error condition</li>\n<li><code>message</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A system-provided human-readable description of the error</li>\n<li><code>path</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path when reporting a file system error</li>\n<li><code>port</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> If present, the network connection port that is not available</li>\n<li><code>syscall</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The name of the system call that triggered the error</li>\n</ul>",
       "properties": [
         {
           "textRaw": "`address` {string}",
@@ -120,10 +120,10 @@
           "desc": "<p>If present, <code>error.dest</code> is the file path destination when reporting a file\nsystem error.</p>"
         },
         {
-          "textRaw": "`errno` {string|number}",
-          "type": "string|number",
+          "textRaw": "`errno` {number}",
+          "type": "number",
           "name": "errno",
-          "desc": "<p>The <code>error.errno</code> property is a number or a string. If it is a number, it is a\nnegative value which corresponds to the error code defined in\n<a href=\"https://docs.libuv.org/en/v1.x/errors.html\"><code>libuv Error handling</code></a>. See the libuv <code>errno.h</code> header file\n(<code>deps/uv/include/uv/errno.h</code> in the Node.js source tree) for details. In case\nof a string, it is the same as <code>error.code</code>.</p>"
+          "desc": "<p>The <code>error.errno</code> property is a negative number which corresponds\nto the error code defined in <a href=\"https://docs.libuv.org/en/v1.x/errors.html\"><code>libuv Error handling</code></a>.</p>\n<p>On Windows the error number provided by the system will be normalized by libuv.</p>\n<p>To get the string representation of the error code, use\n<a href=\"util.html#util_util_getsystemerrorname_err\"><code>util.getSystemErrorName(error.errno)</code></a>.</p>"
         },
         {
           "textRaw": "`info` {Object}",
@@ -233,8 +233,21 @@
         {
           "textRaw": "Node.js error codes",
           "name": "node.js_error_codes",
-          "desc": "<p><a id=\"ERR_AMBIGUOUS_ARGUMENT\"></a></p>",
+          "desc": "<p><a id=\"ABORT_ERR\"></a></p>",
           "modules": [
+            {
+              "textRaw": "`ABORT_ERR`",
+              "name": "`abort_err`",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Used when an operation has been aborted (typically using an <code>AbortController</code>).</p>\n<p>APIs <em>not</em> using <code>AbortSignal</code>s typically do not raise an error with this code.</p>\n<p>This code does not use the regular <code>ERR_*</code> convention Node.js errors use in\norder to be compatible with the web platform's <code>AbortError</code>.</p>\n<p><a id=\"ERR_AMBIGUOUS_ARGUMENT\"></a></p>",
+              "type": "module",
+              "displayName": "`ABORT_ERR`"
+            },
             {
               "textRaw": "`ERR_AMBIGUOUS_ARGUMENT`",
               "name": "`err_ambiguous_argument`",
@@ -329,30 +342,44 @@
             {
               "textRaw": "`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`",
               "name": "`err_child_process_stdio_maxbuffer`",
-              "desc": "<p>Used when the main process is trying to read data from the child process's\nSTDERR/STDOUT, and the data's length is longer than the <code>maxBuffer</code> option.</p>\n<p><a id=\"ERR_CONSOLE_WRITABLE_STREAM\"></a></p>",
+              "desc": "<p>Used when the main process is trying to read data from the child process's\nSTDERR/STDOUT, and the data's length is longer than the <code>maxBuffer</code> option.</p>\n<p><a id=\"ERR_CLOSED_MESSAGE_PORT\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`"
             },
+            {
+              "textRaw": "`ERR_CLOSED_MESSAGE_PORT`",
+              "name": "`err_closed_message_port`",
+              "desc": "<!--\nadded: v14.17.1\nchanges:\n  - version: 11.12.0\n    pr-url: https://github.com/nodejs/node/pull/26487\n    description: The error message was removed.\n  - version: v14.17.1\n    pr-url: https://github.com/nodejs/node/pull/38510\n    description: The error message was reintroduced.\n-->\n<p>There was an attempt to use a <code>MessagePort</code> instance in a closed\nstate, usually after <code>.close()</code> has been called.</p>\n<p><a id=\"ERR_CONSOLE_WRITABLE_STREAM\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_CLOSED_MESSAGE_PORT`"
+            },
             {
               "textRaw": "`ERR_CONSOLE_WRITABLE_STREAM`",
               "name": "`err_console_writable_stream`",
-              "desc": "<p><code>Console</code> was instantiated without <code>stdout</code> stream, or <code>Console</code> has a\nnon-writable <code>stdout</code> or <code>stderr</code> stream.</p>\n<p><a id=\"ERR_CONSTRUCT_CALL_REQUIRED\"></a></p>",
+              "desc": "<p><code>Console</code> was instantiated without <code>stdout</code> stream, or <code>Console</code> has a\nnon-writable <code>stdout</code> or <code>stderr</code> stream.</p>\n<p><a id=\"ERR_CONSTRUCT_CALL_INVALID\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CONSOLE_WRITABLE_STREAM`"
             },
+            {
+              "textRaw": "`ERR_CONSTRUCT_CALL_INVALID`",
+              "name": "`err_construct_call_invalid`",
+              "desc": "<!--\nadded: v12.5.0\n-->\n<p>A class constructor was called that is not callable.</p>\n<p><a id=\"ERR_CONSTRUCT_CALL_REQUIRED\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_CONSTRUCT_CALL_INVALID`"
+            },
             {
               "textRaw": "`ERR_CONSTRUCT_CALL_REQUIRED`",
               "name": "`err_construct_call_required`",
-              "desc": "<p>A constructor for a class was called without <code>new</code>.</p>\n<p><a id=\"ERR_CONSTRUCT_CALL_INVALID\"></a></p>",
+              "desc": "<p>A constructor for a class was called without <code>new</code>.</p>\n<p><a id=\"ERR_CONTEXT_NOT_INITIALIZED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CONSTRUCT_CALL_REQUIRED`"
             },
             {
-              "textRaw": "`ERR_CONSTRUCT_CALL_INVALID`",
-              "name": "`err_construct_call_invalid`",
-              "desc": "<!--\nadded: v12.5.0\n-->\n<p>A class constructor was called that is not callable.</p>\n<p><a id=\"ERR_CPU_USAGE\"></a></p>",
+              "textRaw": "`ERR_CONTEXT_NOT_INITIALIZED`",
+              "name": "`err_context_not_initialized`",
+              "desc": "<p>The vm context passed into the API is not yet initialized. This could happen\nwhen an error occurs (and is caught) during the creation of the\ncontext, for example, when the allocation fails or the maximum call stack\nsize is reached when the context is created.</p>\n<p><a id=\"ERR_CPU_USAGE\"></a></p>",
               "type": "module",
-              "displayName": "`ERR_CONSTRUCT_CALL_INVALID`"
+              "displayName": "`ERR_CONTEXT_NOT_INITIALIZED`"
             },
             {
               "textRaw": "`ERR_CPU_USAGE`",
@@ -497,10 +524,49 @@
             {
               "textRaw": "`ERR_CRYPTO_UNKNOWN_DH_GROUP`",
               "name": "`err_crypto_unknown_dh_group`",
-              "desc": "<p>An unknown Diffie-Hellman group name was given. See\n<a href=\"crypto.html#crypto_crypto_getdiffiehellman_groupname\"><code>crypto.getDiffieHellman()</code></a> for a list of valid group names.</p>\n<p><a id=\"ERR_DIR_CLOSED\"></a></p>",
+              "desc": "<p>An unknown Diffie-Hellman group name was given. See\n<a href=\"crypto.html#crypto_crypto_getdiffiehellman_groupname\"><code>crypto.getDiffieHellman()</code></a> for a list of valid group names.</p>\n<p><a id=\"ERR_DLOPEN_FAILED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CRYPTO_UNKNOWN_DH_GROUP`"
             },
+            {
+              "textRaw": "`ERR_DLOPEN_FAILED`",
+              "name": "`err_dlopen_failed`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>A call to <code>process.dlopen()</code> failed.</p>\n<p><a id=\"ERR_DEBUGGER_ERROR\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_DLOPEN_FAILED`"
+            },
+            {
+              "textRaw": "`ERR_DEBUGGER_ERROR`",
+              "name": "`err_debugger_error`",
+              "meta": {
+                "added": [
+                  "v14.17.4"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An error occurred with the <a href=\"debugger.html\">debugger</a>.</p>\n<p><a id=\"ERR_DEBUGGER_STARTUP_ERROR\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_DEBUGGER_ERROR`"
+            },
+            {
+              "textRaw": "`ERR_DEBUGGER_STARTUP_ERROR`",
+              "name": "`err_debugger_startup_error`",
+              "meta": {
+                "added": [
+                  "v14.17.4"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The <a href=\"debugger.html\">debugger</a> timed out waiting for the required host/port to be free.</p>\n<p><a id=\"ERR_DIR_CLOSED\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_DEBUGGER_STARTUP_ERROR`"
+            },
             {
               "textRaw": "`ERR_DIR_CLOSED`",
               "name": "`err_dir_closed`",
@@ -513,7 +579,7 @@
               "name": "`err_dir_concurrent_operation`",
               "meta": {
                 "added": [
-                  "v12.18.1"
+                  "v14.3.0"
                 ],
                 "changes": []
               },
@@ -552,10 +618,24 @@
             {
               "textRaw": "`ERR_ENCODING_NOT_SUPPORTED`",
               "name": "`err_encoding_not_supported`",
-              "desc": "<p>Encoding provided to <code>TextDecoder()</code> API was not one of the\n<a href=\"util.html#util_whatwg_supported_encodings\">WHATWG Supported Encodings</a>.</p>\n<p><a id=\"ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE\"></a></p>",
+              "desc": "<p>Encoding provided to <code>TextDecoder()</code> API was not one of the\n<a href=\"util.html#util_whatwg_supported_encodings\">WHATWG Supported Encodings</a>.</p>\n<p><a id=\"ERR_EVAL_ESM_CANNOT_PRINT\"></a></p>",
               "type": "module",
               "displayName": "`ERR_ENCODING_NOT_SUPPORTED`"
             },
+            {
+              "textRaw": "`ERR_EVAL_ESM_CANNOT_PRINT`",
+              "name": "`err_eval_esm_cannot_print`",
+              "desc": "<p><code>--print</code> cannot be used with ESM input.</p>\n<p><a id=\"ERR_EVENT_RECURSION\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_EVAL_ESM_CANNOT_PRINT`"
+            },
+            {
+              "textRaw": "`ERR_EVENT_RECURSION`",
+              "name": "`err_event_recursion`",
+              "desc": "<p>Thrown when an attempt is made to recursively dispatch an event on <code>EventTarget</code>.</p>\n<p><a id=\"ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_EVENT_RECURSION`"
+            },
             {
               "textRaw": "`ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`",
               "name": "`err_execution_environment_not_available`",
@@ -566,10 +646,30 @@
             {
               "textRaw": "`ERR_FALSY_VALUE_REJECTION`",
               "name": "`err_falsy_value_rejection`",
-              "desc": "<p>A <code>Promise</code> that was callbackified via <code>util.callbackify()</code> was rejected with a\nfalsy value.</p>\n<p><a id=\"ERR_FS_FILE_TOO_LARGE\"></a></p>",
+              "desc": "<p>A <code>Promise</code> that was callbackified via <code>util.callbackify()</code> was rejected with a\nfalsy value.</p>\n<p><a id=\"ERR_FEATURE_UNAVAILABLE_ON_PLATFORM\"></a></p>",
               "type": "module",
               "displayName": "`ERR_FALSY_VALUE_REJECTION`"
             },
+            {
+              "textRaw": "`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`",
+              "name": "`err_feature_unavailable_on_platform`",
+              "meta": {
+                "added": [
+                  "v14.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Used when a feature that is not available\nto the current platform which is running Node.js is used.</p>\n<p><a id=\"ERR_FS_EISDIR\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`"
+            },
+            {
+              "textRaw": "`ERR_FS_EISDIR`",
+              "name": "`err_fs_eisdir`",
+              "desc": "<p>Path is a directory.</p>\n<p><a id=\"ERR_FS_FILE_TOO_LARGE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_FS_EISDIR`"
+            },
             {
               "textRaw": "`ERR_FS_FILE_TOO_LARGE`",
               "name": "`err_fs_file_too_large`",
@@ -657,10 +757,17 @@
             {
               "textRaw": "`ERR_HTTP2_GOAWAY_SESSION`",
               "name": "`err_http2_goaway_session`",
-              "desc": "<p>New HTTP/2 Streams may not be opened after the <code>Http2Session</code> has received a\n<code>GOAWAY</code> frame from the connected peer.</p>\n<p><a id=\"ERR_HTTP2_HEADERS_AFTER_RESPOND\"></a></p>",
+              "desc": "<p>New HTTP/2 Streams may not be opened after the <code>Http2Session</code> has received a\n<code>GOAWAY</code> frame from the connected peer.</p>\n<p><a id=\"ERR_HTTP2_HEADER_SINGLE_VALUE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP2_GOAWAY_SESSION`"
             },
+            {
+              "textRaw": "`ERR_HTTP2_HEADER_SINGLE_VALUE`",
+              "name": "`err_http2_header_single_value`",
+              "desc": "<p>Multiple values were provided for an HTTP/2 header field that was required to\nhave only a single value.</p>\n<p><a id=\"ERR_HTTP2_HEADERS_AFTER_RESPOND\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_HTTP2_HEADER_SINGLE_VALUE`"
+            },
             {
               "textRaw": "`ERR_HTTP2_HEADERS_AFTER_RESPOND`",
               "name": "`err_http2_headers_after_respond`",
@@ -671,17 +778,10 @@
             {
               "textRaw": "`ERR_HTTP2_HEADERS_SENT`",
               "name": "`err_http2_headers_sent`",
-              "desc": "<p>An attempt was made to send multiple response headers.</p>\n<p><a id=\"ERR_HTTP2_HEADER_SINGLE_VALUE\"></a></p>",
+              "desc": "<p>An attempt was made to send multiple response headers.</p>\n<p><a id=\"ERR_HTTP2_INFO_STATUS_NOT_ALLOWED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP2_HEADERS_SENT`"
             },
-            {
-              "textRaw": "`ERR_HTTP2_HEADER_SINGLE_VALUE`",
-              "name": "`err_http2_header_single_value`",
-              "desc": "<p>Multiple values were provided for an HTTP/2 header field that was required to\nhave only a single value.</p>\n<p><a id=\"ERR_HTTP2_INFO_STATUS_NOT_ALLOWED\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_HTTP2_HEADER_SINGLE_VALUE`"
-            },
             {
               "textRaw": "`ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`",
               "name": "`err_http2_info_status_not_allowed`",
@@ -762,10 +862,17 @@
             {
               "textRaw": "`ERR_HTTP2_NESTED_PUSH`",
               "name": "`err_http2_nested_push`",
-              "desc": "<p>An attempt was made to initiate a new push stream from within a push stream.\nNested push streams are not permitted.</p>\n<p><a id=\"ERR_HTTP2_NO_SOCKET_MANIPULATION\"></a></p>",
+              "desc": "<p>An attempt was made to initiate a new push stream from within a push stream.\nNested push streams are not permitted.</p>\n<p><a id=\"ERR_HTTP2_NO_MEM\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP2_NESTED_PUSH`"
             },
+            {
+              "textRaw": "`ERR_HTTP2_NO_MEM`",
+              "name": "`err_http2_no_mem`",
+              "desc": "<p>Out of memory when using the <code>http2session.setLocalWindowSize(windowSize)</code> API.</p>\n<p><a id=\"ERR_HTTP2_NO_SOCKET_MANIPULATION\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_HTTP2_NO_MEM`"
+            },
             {
               "textRaw": "`ERR_HTTP2_NO_SOCKET_MANIPULATION`",
               "name": "`err_http2_no_socket_manipulation`",
@@ -916,17 +1023,10 @@
             {
               "textRaw": "`ERR_HTTP2_UNSUPPORTED_PROTOCOL`",
               "name": "`err_http2_unsupported_protocol`",
-              "desc": "<p><code>http2.connect()</code> was passed a URL that uses any protocol other than <code>http:</code> or\n<code>https:</code>.</p>\n<p><a id=\"ERR_INTERNAL_ASSERTION\"></a></p>",
+              "desc": "<p><code>http2.connect()</code> was passed a URL that uses any protocol other than <code>http:</code> or\n<code>https:</code>.</p>\n<p><a id=\"ERR_INCOMPATIBLE_OPTION_PAIR\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP2_UNSUPPORTED_PROTOCOL`"
             },
-            {
-              "textRaw": "`ERR_INTERNAL_ASSERTION`",
-              "name": "`err_internal_assertion`",
-              "desc": "<p>There was a bug in Node.js or incorrect usage of Node.js internals.\nTo fix the error, open an issue at <a href=\"https://github.com/nodejs/node/issues\">https://github.com/nodejs/node/issues</a>.</p>\n<p><a id=\"ERR_INCOMPATIBLE_OPTION_PAIR\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_INTERNAL_ASSERTION`"
-            },
             {
               "textRaw": "`ERR_INCOMPATIBLE_OPTION_PAIR`",
               "name": "`err_incompatible_option_pair`",
@@ -995,10 +1095,17 @@
             {
               "textRaw": "`ERR_INSPECTOR_NOT_WORKER`",
               "name": "`err_inspector_not_worker`",
-              "desc": "<p>An API was called on the main thread that can only be used from\nthe worker thread.</p>\n<p><a id=\"ERR_INVALID_ADDRESS_FAMILY\"></a></p>",
+              "desc": "<p>An API was called on the main thread that can only be used from\nthe worker thread.</p>\n<p><a id=\"ERR_INTERNAL_ASSERTION\"></a></p>",
               "type": "module",
               "displayName": "`ERR_INSPECTOR_NOT_WORKER`"
             },
+            {
+              "textRaw": "`ERR_INTERNAL_ASSERTION`",
+              "name": "`err_internal_assertion`",
+              "desc": "<p>There was a bug in Node.js or incorrect usage of Node.js internals.\nTo fix the error, open an issue at <a href=\"https://github.com/nodejs/node/issues\">https://github.com/nodejs/node/issues</a>.</p>\n<p><a id=\"ERR_INVALID_ADDRESS_FAMILY\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_INTERNAL_ASSERTION`"
+            },
             {
               "textRaw": "`ERR_INVALID_ADDRESS_FAMILY`",
               "name": "`err_invalid_address_family`",
@@ -1100,10 +1207,23 @@
             {
               "textRaw": "`ERR_INVALID_IP_ADDRESS`",
               "name": "`err_invalid_ip_address`",
-              "desc": "<p>An IP address is not valid.</p>\n<p><a id=\"ERR_INVALID_MODULE_SPECIFIER\"></a></p>",
+              "desc": "<p>An IP address is not valid.</p>\n<p><a id=\"ERR_INVALID_MODULE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_INVALID_IP_ADDRESS`"
             },
+            {
+              "textRaw": "`ERR_INVALID_MODULE`",
+              "name": "`err_invalid_module`",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An attempt was made to load a module that does not exist or was otherwise not\nvalid.</p>\n<p><a id=\"ERR_INVALID_MODULE_SPECIFIER\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_INVALID_MODULE`"
+            },
             {
               "textRaw": "`ERR_INVALID_MODULE_SPECIFIER`",
               "name": "`err_invalid_module_specifier`",
@@ -1163,7 +1283,7 @@
             {
               "textRaw": "`ERR_INVALID_REPL_INPUT`",
               "name": "`err_invalid_repl_input`",
-              "desc": "<p>The input may not be used in the <a href=\"repl.html\"><code>REPL</code></a>. All prohibited inputs are\ndocumented in the <a href=\"repl.html\"><code>REPL</code></a>'s documentation.</p>\n<p><a id=\"ERR_INVALID_RETURN_PROPERTY\"></a></p>",
+              "desc": "<p>The input may not be used in the <a href=\"repl.html\"><code>REPL</code></a>. The conditions under which this\nerror is used are described in the <a href=\"repl.html\"><code>REPL</code></a> documentation.</p>\n<p><a id=\"ERR_INVALID_RETURN_PROPERTY\"></a></p>",
               "type": "module",
               "displayName": "`ERR_INVALID_REPL_INPUT`"
             },
@@ -1289,10 +1409,17 @@
             {
               "textRaw": "`ERR_MANIFEST_INVALID_RESOURCE_FIELD`",
               "name": "`err_manifest_invalid_resource_field`",
-              "desc": "<p>A policy manifest resource had an invalid value for one of its fields. Update\nthe manifest entry to match in order to resolve this error. See the\ndocumentation for <a href=\"policy.html\">policy</a> manifests for more information.</p>\n<p><a id=\"ERR_MANIFEST_PARSE_POLICY\"></a></p>",
+              "desc": "<p>A policy manifest resource had an invalid value for one of its fields. Update\nthe manifest entry to match in order to resolve this error. See the\ndocumentation for <a href=\"policy.html\">policy</a> manifests for more information.</p>\n<p><a id=\"ERR_MANIFEST_INVALID_SPECIFIER\"></a></p>",
               "type": "module",
               "displayName": "`ERR_MANIFEST_INVALID_RESOURCE_FIELD`"
             },
+            {
+              "textRaw": "`ERR_MANIFEST_INVALID_SPECIFIER`",
+              "name": "`err_manifest_invalid_specifier`",
+              "desc": "<p>A policy manifest resource had an invalid value for one of its dependency\nmappings. Update the manifest entry to match to resolve this error. See the\ndocumentation for <a href=\"policy.html\">policy</a> manifests for more information.</p>\n<p><a id=\"ERR_MANIFEST_PARSE_POLICY\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_MANIFEST_INVALID_SPECIFIER`"
+            },
             {
               "textRaw": "`ERR_MANIFEST_PARSE_POLICY`",
               "name": "`err_manifest_parse_policy`",
@@ -1326,7 +1453,7 @@
               "name": "`err_message_target_context_unavailable`",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -1344,33 +1471,24 @@
             {
               "textRaw": "`ERR_MISSING_ARGS`",
               "name": "`err_missing_args`",
-              "desc": "<p>A required argument of a Node.js API was not passed. This is only used for\nstrict compliance with the API specification (which in some cases may accept\n<code>func(undefined)</code> but not <code>func()</code>). In most native Node.js APIs,\n<code>func(undefined)</code> and <code>func()</code> are treated identically, and the\n<a href=\"#ERR_INVALID_ARG_TYPE\"><code>ERR_INVALID_ARG_TYPE</code></a> error code may be used instead.</p>\n<p><a id=\"ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK\"></a></p>",
+              "desc": "<p>A required argument of a Node.js API was not passed. This is only used for\nstrict compliance with the API specification (which in some cases may accept\n<code>func(undefined)</code> but not <code>func()</code>). In most native Node.js APIs,\n<code>func(undefined)</code> and <code>func()</code> are treated identically, and the\n<a href=\"#ERR_INVALID_ARG_TYPE\"><code>ERR_INVALID_ARG_TYPE</code></a> error code may be used instead.</p>\n<p><a id=\"ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST\"></a></p>",
               "type": "module",
               "displayName": "`ERR_MISSING_ARGS`"
             },
             {
-              "textRaw": "`ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK`",
-              "name": "`err_missing_dynamic_instantiate_hook`",
-              "stability": 1,
-              "stabilityText": "Experimental",
-              "desc": "<p>An <a href=\"esm.html\">ES Module</a> loader hook specified <code>format: 'dynamic'</code> but did not provide\na <code>dynamicInstantiate</code> hook.</p>\n<p><a id=\"ERR_MISSING_OPTION\"></a></p>",
+              "textRaw": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`",
+              "name": "`err_missing_message_port_in_transfer_list`",
+              "desc": "<p>An object that needs to be explicitly listed in the <code>transferList</code> argument\nis in the object passed to a <code>postMessage()</code> call, but is not provided\nin the <code>transferList</code> for that call. Usually, this is a <code>MessagePort</code>.</p>\n<p><a id=\"ERR_MISSING_OPTION\"></a></p>",
               "type": "module",
-              "displayName": "`ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK`"
+              "displayName": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`"
             },
             {
               "textRaw": "`ERR_MISSING_OPTION`",
               "name": "`err_missing_option`",
-              "desc": "<p>For APIs that accept options objects, some options might be mandatory. This code\nis thrown if a required option is missing.</p>\n<p><a id=\"ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST\"></a></p>",
+              "desc": "<p>For APIs that accept options objects, some options might be mandatory. This code\nis thrown if a required option is missing.</p>\n<p><a id=\"ERR_MISSING_PASSPHRASE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_MISSING_OPTION`"
             },
-            {
-              "textRaw": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`",
-              "name": "`err_missing_message_port_in_transfer_list`",
-              "desc": "<p>An object that needs to be explicitly listed in the <code>transferList</code> argument\nwas found in the object passed to a <code>postMessage()</code> call, but not provided in\nthe <code>transferList</code> for that call. Usually, this is a <code>MessagePort</code>.</p>\n<p><a id=\"ERR_MISSING_PASSPHRASE\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`"
-            },
             {
               "textRaw": "`ERR_MISSING_PASSPHRASE`",
               "name": "`err_missing_passphrase`",
@@ -1404,7 +1522,7 @@
             {
               "textRaw": "`ERR_NAPI_CONS_FUNCTION`",
               "name": "`err_napi_cons_function`",
-              "desc": "<p>While using <code>N-API</code>, a constructor passed was not a function.</p>\n<p><a id=\"ERR_NAPI_INVALID_DATAVIEW_ARGS\"></a></p>",
+              "desc": "<p>While using <code>Node-API</code>, a constructor passed was not a function.</p>\n<p><a id=\"ERR_NAPI_INVALID_DATAVIEW_ARGS\"></a></p>",
               "type": "module",
               "displayName": "`ERR_NAPI_CONS_FUNCTION`"
             },
@@ -1474,10 +1592,17 @@
             {
               "textRaw": "`ERR_NON_CONTEXT_AWARE_DISABLED`",
               "name": "`err_non_context_aware_disabled`",
-              "desc": "<p>A non-context-aware native addon was loaded in a process that disallows them.</p>\n<p><a id=\"ERR_OUT_OF_RANGE\"></a></p>",
+              "desc": "<p>A non-context-aware native addon was loaded in a process that disallows them.</p>\n<p><a id=\"ERR_OPERATION_FAILED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_NON_CONTEXT_AWARE_DISABLED`"
             },
+            {
+              "textRaw": "`ERR_OPERATION_FAILED`",
+              "name": "`err_operation_failed`",
+              "desc": "<p>An operation failed. This is typically used to signal the general failure of an\nasynchronous operation.</p>\n<p><a id=\"ERR_OUT_OF_RANGE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_OPERATION_FAILED`"
+            },
             {
               "textRaw": "`ERR_OUT_OF_RANGE`",
               "name": "`err_out_of_range`",
@@ -1574,17 +1699,10 @@
             {
               "textRaw": "`ERR_SOCKET_BUFFER_SIZE`",
               "name": "`err_socket_buffer_size`",
-              "desc": "<p>While using <a href=\"dgram.html#dgram_dgram_createsocket_options_callback\"><code>dgram.createSocket()</code></a>, the size of the receive or send <code>Buffer</code>\ncould not be determined.</p>\n<p><a id=\"ERR_SOCKET_CANNOT_SEND\"></a></p>",
+              "desc": "<p>While using <a href=\"dgram.html#dgram_dgram_createsocket_options_callback\"><code>dgram.createSocket()</code></a>, the size of the receive or send <code>Buffer</code>\ncould not be determined.</p>\n<p><a id=\"ERR_SOCKET_CLOSED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_SOCKET_BUFFER_SIZE`"
             },
-            {
-              "textRaw": "`ERR_SOCKET_CANNOT_SEND`",
-              "name": "`err_socket_cannot_send`",
-              "desc": "<p>Data could be sent on a socket.</p>\n<p><a id=\"ERR_SOCKET_CLOSED\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_SOCKET_CANNOT_SEND`"
-            },
             {
               "textRaw": "`ERR_SOCKET_CLOSED`",
               "name": "`err_socket_closed`",
@@ -1616,10 +1734,17 @@
             {
               "textRaw": "`ERR_SRI_PARSE`",
               "name": "`err_sri_parse`",
-              "desc": "<p>A string was provided for a Subresource Integrity check, but was unable to be\nparsed. Check the format of integrity attributes by looking at the\n<a href=\"https://www.w3.org/TR/SRI/#the-integrity-attribute\">Subresource Integrity specification</a>.</p>\n<p><a id=\"ERR_STREAM_CANNOT_PIPE\"></a></p>",
+              "desc": "<p>A string was provided for a Subresource Integrity check, but was unable to be\nparsed. Check the format of integrity attributes by looking at the\n<a href=\"https://www.w3.org/TR/SRI/#the-integrity-attribute\">Subresource Integrity specification</a>.</p>\n<p><a id=\"ERR_STREAM_ALREADY_FINISHED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_SRI_PARSE`"
             },
+            {
+              "textRaw": "`ERR_STREAM_ALREADY_FINISHED`",
+              "name": "`err_stream_already_finished`",
+              "desc": "<p>A stream method was called that cannot complete because the stream was\nfinished.</p>\n<p><a id=\"ERR_STREAM_CANNOT_PIPE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_STREAM_ALREADY_FINISHED`"
+            },
             {
               "textRaw": "`ERR_STREAM_CANNOT_PIPE`",
               "name": "`err_stream_cannot_pipe`",
@@ -1693,10 +1818,17 @@
             {
               "textRaw": "`ERR_SYSTEM_ERROR`",
               "name": "`err_system_error`",
-              "desc": "<p>An unspecified or non-specific system error has occurred within the Node.js\nprocess. The error object will have an <code>err.info</code> object property with\nadditional details.</p>\n<p><a id=\"ERR_TLS_CERT_ALTNAME_INVALID\"></a></p>",
+              "desc": "<p>An unspecified or non-specific system error has occurred within the Node.js\nprocess. The error object will have an <code>err.info</code> object property with\nadditional details.</p>\n<p><a id=\"ERR_TLS_CERT_ALTNAME_FORMAT\"></a></p>",
               "type": "module",
               "displayName": "`ERR_SYSTEM_ERROR`"
             },
+            {
+              "textRaw": "`ERR_TLS_CERT_ALTNAME_FORMAT`",
+              "name": "`err_tls_cert_altname_format`",
+              "desc": "<p>This error is thrown by <code>checkServerIdentity</code> if a user-supplied\n<code>subjectaltname</code> property violates encoding rules. Certificate objects produced\nby Node.js itself always comply with encoding rules and will never cause\nthis error.</p>\n<p><a id=\"ERR_TLS_CERT_ALTNAME_INVALID\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_TLS_CERT_ALTNAME_FORMAT`"
+            },
             {
               "textRaw": "`ERR_TLS_CERT_ALTNAME_INVALID`",
               "name": "`err_tls_cert_altname_invalid`",
@@ -1723,27 +1855,14 @@
               "name": "`err_tls_invalid_context`",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.3.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The context must be a <code>SecureContext</code>.</p>\n<p><a id=\"ERR_TLS_INVALID_STATE\"></a></p>",
+              "desc": "<p>The context must be a <code>SecureContext</code>.</p>\n<p><a id=\"ERR_TLS_INVALID_PROTOCOL_METHOD\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_INVALID_CONTEXT`"
             },
-            {
-              "textRaw": "`ERR_TLS_INVALID_STATE`",
-              "name": "`err_tls_invalid_state`",
-              "meta": {
-                "added": [
-                  "v12.17.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The TLS socket must be connected and securily established. Ensure the 'secure'\nevent is emitted before continuing.</p>\n<p><a id=\"ERR_TLS_INVALID_PROTOCOL_METHOD\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_TLS_INVALID_STATE`"
-            },
             {
               "textRaw": "`ERR_TLS_INVALID_PROTOCOL_METHOD`",
               "name": "`err_tls_invalid_protocol_method`",
@@ -1754,17 +1873,38 @@
             {
               "textRaw": "`ERR_TLS_INVALID_PROTOCOL_VERSION`",
               "name": "`err_tls_invalid_protocol_version`",
-              "desc": "<p>Valid TLS protocol versions are <code>'TLSv1'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1.2'</code>.</p>\n<p><a id=\"ERR_TLS_PROTOCOL_VERSION_CONFLICT\"></a></p>",
+              "desc": "<p>Valid TLS protocol versions are <code>'TLSv1'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1.2'</code>.</p>\n<p><a id=\"ERR_TLS_INVALID_STATE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_INVALID_PROTOCOL_VERSION`"
             },
+            {
+              "textRaw": "`ERR_TLS_INVALID_STATE`",
+              "name": "`err_tls_invalid_state`",
+              "meta": {
+                "added": [
+                  "v13.10.0",
+                  "v12.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The TLS socket must be connected and securily established. Ensure the 'secure'\nevent is emitted before continuing.</p>\n<p><a id=\"ERR_TLS_PROTOCOL_VERSION_CONFLICT\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_TLS_INVALID_STATE`"
+            },
             {
               "textRaw": "`ERR_TLS_PROTOCOL_VERSION_CONFLICT`",
               "name": "`err_tls_protocol_version_conflict`",
-              "desc": "<p>Attempting to set a TLS protocol <code>minVersion</code> or <code>maxVersion</code> conflicts with an\nattempt to set the <code>secureProtocol</code> explicitly. Use one mechanism or the other.</p>\n<p><a id=\"ERR_TLS_RENEGOTIATION_DISABLED\"></a></p>",
+              "desc": "<p>Attempting to set a TLS protocol <code>minVersion</code> or <code>maxVersion</code> conflicts with an\nattempt to set the <code>secureProtocol</code> explicitly. Use one mechanism or the other.</p>\n<p><a id=\"ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_PROTOCOL_VERSION_CONFLICT`"
             },
+            {
+              "textRaw": "`ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`",
+              "name": "`err_tls_psk_set_identiy_hint_failed`",
+              "desc": "<p>Failed to set PSK identity hint. Hint may be too long.</p>\n<p><a id=\"ERR_TLS_RENEGOTIATION_DISABLED\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`"
+            },
             {
               "textRaw": "`ERR_TLS_RENEGOTIATION_DISABLED`",
               "name": "`err_tls_renegotiation_disabled`",
@@ -1789,17 +1929,10 @@
             {
               "textRaw": "`ERR_TLS_SNI_FROM_SERVER`",
               "name": "`err_tls_sni_from_server`",
-              "desc": "<p>An attempt was made to issue Server Name Indication from a TLS server-side\nsocket, which is only valid from a client.</p>\n<p><a id=\"ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED\"></a></p>",
+              "desc": "<p>An attempt was made to issue Server Name Indication from a TLS server-side\nsocket, which is only valid from a client.</p>\n<p><a id=\"ERR_TRACE_EVENTS_CATEGORY_REQUIRED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_SNI_FROM_SERVER`"
             },
-            {
-              "textRaw": "`ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`",
-              "name": "`err_tls_psk_set_identiy_hint_failed`",
-              "desc": "<p>Failed to set PSK identity hint. Hint may be too long.</p>\n<p><a id=\"ERR_TRACE_EVENTS_CATEGORY_REQUIRED\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`"
-            },
             {
               "textRaw": "`ERR_TRACE_EVENTS_CATEGORY_REQUIRED`",
               "name": "`err_trace_events_category_required`",
@@ -1810,17 +1943,10 @@
             {
               "textRaw": "`ERR_TRACE_EVENTS_UNAVAILABLE`",
               "name": "`err_trace_events_unavailable`",
-              "desc": "<p>The <code>trace_events</code> module could not be loaded because Node.js was compiled with\nthe <code>--without-v8-platform</code> flag.</p>\n<p><a id=\"ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER\"></a></p>",
+              "desc": "<p>The <code>trace_events</code> module could not be loaded because Node.js was compiled with\nthe <code>--without-v8-platform</code> flag.</p>\n<p><a id=\"ERR_TRANSFORM_ALREADY_TRANSFORMING\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TRACE_EVENTS_UNAVAILABLE`"
             },
-            {
-              "textRaw": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`",
-              "name": "`err_transferring_externalized_sharedarraybuffer`",
-              "desc": "<p>A <code>SharedArrayBuffer</code> whose memory is not managed by the JavaScript engine\nor by Node.js was encountered during serialization. Such a <code>SharedArrayBuffer</code>\ncannot be serialized.</p>\n<p>This can only happen when native addons create <code>SharedArrayBuffer</code>s in\n\"externalized\" mode, or put existing <code>SharedArrayBuffer</code> into externalized mode.</p>\n<p><a id=\"ERR_TRANSFORM_ALREADY_TRANSFORMING\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`"
-            },
             {
               "textRaw": "`ERR_TRANSFORM_ALREADY_TRANSFORMING`",
               "name": "`err_transform_already_transforming`",
@@ -1845,7 +1971,7 @@
             {
               "textRaw": "`ERR_UNAVAILABLE_DURING_EXIT`",
               "name": "`err_unavailable_during_exit`",
-              "desc": "<p>Function was called within a <a href=\"process.html#Event:-%60&#x27;exit&#x27;%60\"><code>process.on('exit')</code></a> handler that shouldn't be\ncalled within <a href=\"process.html#Event:-%60&#x27;exit&#x27;%60\"><code>process.on('exit')</code></a> handler.</p>\n<p><a id=\"ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET\"></a></p>",
+              "desc": "<p>Function was called within a <a href=\"process.html#process_event_exit\"><code>process.on('exit')</code></a> handler that shouldn't be\ncalled within <a href=\"process.html#process_event_exit\"><code>process.on('exit')</code></a> handler.</p>\n<p><a id=\"ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET\"></a></p>",
               "type": "module",
               "displayName": "`ERR_UNAVAILABLE_DURING_EXIT`"
             },
@@ -1933,7 +2059,7 @@
             {
               "textRaw": "`ERR_VALID_PERFORMANCE_ENTRY_TYPE`",
               "name": "`err_valid_performance_entry_type`",
-              "desc": "<p>While using the Performance Timing API (<code>perf_hooks</code>), no valid performance\nentry types were found.</p>\n<p><a id=\"ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING\"></a></p>",
+              "desc": "<p>While using the Performance Timing API (<code>perf_hooks</code>), no valid performance\nentry types are found.</p>\n<p><a id=\"ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING\"></a></p>",
               "type": "module",
               "displayName": "`ERR_VALID_PERFORMANCE_ENTRY_TYPE`"
             },
@@ -1975,10 +2101,17 @@
             {
               "textRaw": "`ERR_VM_MODULE_LINKING_ERRORED`",
               "name": "`err_vm_module_linking_errored`",
-              "desc": "<p>The linker function returned a module for which linking has failed.</p>\n<p><a id=\"ERR_VM_MODULE_NOT_MODULE\"></a></p>",
+              "desc": "<p>The linker function returned a module for which linking has failed.</p>\n<p><a id=\"ERR_VM_MODULE_LINK_FAILURE\"></a></p>",
               "type": "module",
               "displayName": "`ERR_VM_MODULE_LINKING_ERRORED`"
             },
+            {
+              "textRaw": "`ERR_VM_MODULE_LINK_FAILURE`",
+              "name": "`err_vm_module_link_failure`",
+              "desc": "<p>The module was unable to be linked due to a failure.</p>\n<p><a id=\"ERR_VM_MODULE_NOT_MODULE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_VM_MODULE_LINK_FAILURE`"
+            },
             {
               "textRaw": "`ERR_VM_MODULE_NOT_MODULE`",
               "name": "`err_vm_module_not_module`",
@@ -2076,8 +2209,12 @@
               "meta": {
                 "changes": [
                   {
-                    "version": "v11.4.0",
-                    "pr-url": "https://github.com/nodejs/node/commit/186035243fad247e3955f",
+                    "version": [
+                      "v11.4.0",
+                      "v10.15.0"
+                    ],
+                    "commit": "186035243fad247e3955f",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/143",
                     "description": "Max header size in `http_parser` was set to 8KB."
                   }
                 ]
@@ -2123,26 +2260,10 @@
             {
               "textRaw": "`ERR_CANNOT_TRANSFER_OBJECT`",
               "name": "`err_cannot_transfer_object`",
-              "desc": "<!--\nadded: v10.5.0\nremoved: v12.5.0\n-->\n<p>The value passed to <code>postMessage()</code> contained an object that is not supported\nfor transferring.</p>\n<p><a id=\"ERR_CLOSED_MESSAGE_PORT\"></a></p>",
+              "desc": "<!--\nadded: v10.5.0\nremoved: v12.5.0\n-->\n<p>The value passed to <code>postMessage()</code> contained an object that is not supported\nfor transferring.</p>\n<p><a id=\"ERR_CRYPTO_HASH_DIGEST_NO_UTF16\"></a></p>",
               "type": "module",
               "displayName": "`ERR_CANNOT_TRANSFER_OBJECT`"
             },
-            {
-              "textRaw": "`ERR_CLOSED_MESSAGE_PORT`",
-              "name": "`err_closed_message_port`",
-              "meta": {
-                "added": [
-                  "v10.5.0"
-                ],
-                "removed": [
-                  "v11.12.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>There was an attempt to use a <code>MessagePort</code> instance in a closed\nstate, usually after <code>.close()</code> has been called.</p>\n<p><a id=\"ERR_CRYPTO_HASH_DIGEST_NO_UTF16\"></a></p>",
-              "type": "module",
-              "displayName": "`ERR_CLOSED_MESSAGE_PORT`"
-            },
             {
               "textRaw": "`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`",
               "name": "`err_crypto_hash_digest_no_utf16`",
@@ -2251,10 +2372,17 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Used when an invalid character is found in an HTTP response status message\n(reason phrase).</p>\n<p><a id=\"ERR_INDEX_OUT_OF_RANGE\"></a></p>",
+              "desc": "<p>Used when an invalid character is found in an HTTP response status message\n(reason phrase).</p>\n<p><a id=\"ERR_HTTP_REQUEST_TIMEOUT\"></a></p>",
               "type": "module",
               "displayName": "`ERR_HTTP_INVALID_CHAR`"
             },
+            {
+              "textRaw": "`ERR_HTTP_REQUEST_TIMEOUT`",
+              "name": "`err_http_request_timeout`",
+              "desc": "<p>The client has not sent the entire request within the allowed time.</p>\n<p><a id=\"ERR_INDEX_OUT_OF_RANGE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_HTTP_REQUEST_TIMEOUT`"
+            },
             {
               "textRaw": "`ERR_INDEX_OUT_OF_RANGE`",
               "name": "`err_index_out_of_range`",
@@ -2283,7 +2411,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Used by the <code>N-API</code> when <code>Constructor.prototype</code> is not an object.</p>\n<p><a id=\"ERR_NO_LONGER_SUPPORTED\"></a></p>",
+              "desc": "<p>Used by the <code>Node-API</code> when <code>Constructor.prototype</code> is not an object.</p>\n<p><a id=\"ERR_NO_LONGER_SUPPORTED\"></a></p>",
               "type": "module",
               "displayName": "`ERR_NAPI_CONS_PROTOTYPE_OBJECT`"
             },
@@ -2322,10 +2450,26 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>The <code>repl</code> module was unable to parse data from the REPL history file.</p>\n<p><a id=\"ERR_STDERR_CLOSE\"></a></p>",
+              "desc": "<p>The <code>repl</code> module was unable to parse data from the REPL history file.</p>\n<p><a id=\"ERR_SOCKET_CANNOT_SEND\"></a></p>",
               "type": "module",
               "displayName": "`ERR_PARSE_HISTORY_DATA`"
             },
+            {
+              "textRaw": "`ERR_SOCKET_CANNOT_SEND`",
+              "name": "`err_socket_cannot_send`",
+              "meta": {
+                "added": [
+                  "v9.0.0"
+                ],
+                "removed": [
+                  "v14.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Data could not be sent on a socket.</p>\n<p><a id=\"ERR_STDERR_CLOSE\"></a></p>",
+              "type": "module",
+              "displayName": "`ERR_SOCKET_CANNOT_SEND`"
+            },
             {
               "textRaw": "`ERR_STDERR_CLOSE`",
               "name": "`err_stderr_close`",
@@ -2392,25 +2536,25 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Used when a TLS renegotiation request has failed in a non-specific way.</p>\n<p><a id=\"ERR_UNKNOWN_BUILTIN_MODULE\"></a></p>",
+              "desc": "<p>Used when a TLS renegotiation request has failed in a non-specific way.</p>\n<p><a id=\"ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER\"></a></p>",
               "type": "module",
               "displayName": "`ERR_TLS_RENEGOTIATION_FAILED`"
             },
             {
-              "textRaw": "`ERR_UNKNOWN_BUILTIN_MODULE`",
-              "name": "`err_unknown_builtin_module`",
+              "textRaw": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`",
+              "name": "`err_transferring_externalized_sharedarraybuffer`",
               "meta": {
                 "added": [
-                  "v8.0.0"
+                  "v10.5.0"
                 ],
                 "removed": [
-                  "v9.0.0"
+                  "v14.0.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The <code>'ERR_UNKNOWN_BUILTIN_MODULE'</code> error code is used to identify a specific\nkind of internal Node.js error that should not typically be triggered by user\ncode. Instances of this error point to an internal bug within the Node.js\nbinary itself.</p>\n<p><a id=\"ERR_UNKNOWN_STDIN_TYPE\"></a></p>",
+              "desc": "<p>A <code>SharedArrayBuffer</code> whose memory is not managed by the JavaScript engine\nor by Node.js was encountered during serialization. Such a <code>SharedArrayBuffer</code>\ncannot be serialized.</p>\n<p>This can only happen when native addons create <code>SharedArrayBuffer</code>s in\n\"externalized\" mode, or put existing <code>SharedArrayBuffer</code> into externalized mode.</p>\n<p><a id=\"ERR_UNKNOWN_STDIN_TYPE\"></a></p>",
               "type": "module",
-              "displayName": "`ERR_UNKNOWN_BUILTIN_MODULE`"
+              "displayName": "`ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`"
             },
             {
               "textRaw": "`ERR_UNKNOWN_STDIN_TYPE`",
@@ -2592,7 +2736,7 @@
           "textRaw": "Class: `SystemError`",
           "type": "class",
           "name": "SystemError",
-          "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Node.js generates system errors when exceptions occur within its runtime\nenvironment. These usually occur when an application violates an operating\nsystem constraint. For example, a system error will occur if an application\nattempts to read a file that does not exist.</p>\n<ul>\n<li><code>address</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the address to which a network connection\nfailed</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> The string error code</li>\n<li><code>dest</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path destination when reporting a file\nsystem error</li>\n<li><code>errno</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The system-provided error number</li>\n<li><code>info</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> If present, extra details about the error condition</li>\n<li><code>message</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A system-provided human-readable description of the error</li>\n<li><code>path</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path when reporting a file system error</li>\n<li><code>port</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> If present, the network connection port that is not available</li>\n<li><code>syscall</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The name of the system call that triggered the error</li>\n</ul>",
+          "desc": "<ul>\n<li>Extends: <a href=\"errors.html#errors_class_error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\n<p>Node.js generates system errors when exceptions occur within its runtime\nenvironment. These usually occur when an application violates an operating\nsystem constraint. For example, a system error will occur if an application\nattempts to read a file that does not exist.</p>\n<ul>\n<li><code>address</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the address to which a network connection\nfailed</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> The string error code</li>\n<li><code>dest</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path destination when reporting a file\nsystem error</li>\n<li><code>errno</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The system-provided error number</li>\n<li><code>info</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> If present, extra details about the error condition</li>\n<li><code>message</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A system-provided human-readable description of the error</li>\n<li><code>path</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> If present, the file path when reporting a file system error</li>\n<li><code>port</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> If present, the network connection port that is not available</li>\n<li><code>syscall</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The name of the system call that triggered the error</li>\n</ul>",
           "properties": [
             {
               "textRaw": "`address` {string}",
@@ -2613,10 +2757,10 @@
               "desc": "<p>If present, <code>error.dest</code> is the file path destination when reporting a file\nsystem error.</p>"
             },
             {
-              "textRaw": "`errno` {string|number}",
-              "type": "string|number",
+              "textRaw": "`errno` {number}",
+              "type": "number",
               "name": "errno",
-              "desc": "<p>The <code>error.errno</code> property is a number or a string. If it is a number, it is a\nnegative value which corresponds to the error code defined in\n<a href=\"https://docs.libuv.org/en/v1.x/errors.html\"><code>libuv Error handling</code></a>. See the libuv <code>errno.h</code> header file\n(<code>deps/uv/include/uv/errno.h</code> in the Node.js source tree) for details. In case\nof a string, it is the same as <code>error.code</code>.</p>"
+              "desc": "<p>The <code>error.errno</code> property is a negative number which corresponds\nto the error code defined in <a href=\"https://docs.libuv.org/en/v1.x/errors.html\"><code>libuv Error handling</code></a>.</p>\n<p>On Windows the error number provided by the system will be normalized by libuv.</p>\n<p>To get the string representation of the error code, use\n<a href=\"util.html#util_util_getsystemerrorname_err\"><code>util.getSystemErrorName(error.errno)</code></a>.</p>"
             },
             {
               "textRaw": "`info` {Object}",
diff --git a/doc/api/errors.md b/doc/api/errors.md
index d5d8e1efa7ebe825091135a76731f96a5f11574a..fc30497feaf5454d2754f6cfe4794ecbe99d9379 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -427,7 +427,7 @@ attempts to read a file that does not exist.
 * `code` {string} The string error code
 * `dest` {string} If present, the file path destination when reporting a file
   system error
-* `errno` {number|string} The system-provided error number
+* `errno` {number} The system-provided error number
 * `info` {Object} If present, extra details about the error condition
 * `message` {string} A system-provided human-readable description of the error
 * `path` {string} If present, the file path when reporting a file system error
@@ -456,13 +456,15 @@ system error.
 
 ### `error.errno`
 
-* {string|number}
+* {number}
+
+The `error.errno` property is a negative number which corresponds
+to the error code defined in [`libuv Error handling`][].
+
+On Windows the error number provided by the system will be normalized by libuv.
 
-The `error.errno` property is a number or a string. If it is a number, it is a
-negative value which corresponds to the error code defined in
-[`libuv Error handling`][]. See the libuv `errno.h` header file
-(`deps/uv/include/uv/errno.h` in the Node.js source tree) for details. In case
-of a string, it is the same as `error.code`.
+To get the string representation of the error code, use
+[`util.getSystemErrorName(error.errno)`][].
 
 ### `error.info`
 
@@ -610,6 +612,18 @@ A human-readable string describing the reason for the error.
 <a id="nodejs-error-codes"></a>
 ## Node.js error codes
 
+<a id="ABORT_ERR"></a>
+### `ABORT_ERR`
+<!-- YAML
+added: v14.17.0
+-->
+Used when an operation has been aborted (typically using an `AbortController`).
+
+APIs _not_ using `AbortSignal`s typically do not raise an error with this code.
+
+This code does not use the regular `ERR_*` convention Node.js errors use in
+order to be compatible with the web platform's `AbortError`.
+
 <a id="ERR_AMBIGUOUS_ARGUMENT"></a>
 ### `ERR_AMBIGUOUS_ARGUMENT`
 
@@ -700,17 +714,28 @@ Used when a child process is being forked without specifying an IPC channel.
 Used when the main process is trying to read data from the child process's
 STDERR/STDOUT, and the data's length is longer than the `maxBuffer` option.
 
+<a id="ERR_CLOSED_MESSAGE_PORT"></a>
+### `ERR_CLOSED_MESSAGE_PORT`
+<!--
+added: v14.17.1
+changes:
+  - version: 11.12.0
+    pr-url: https://github.com/nodejs/node/pull/26487
+    description: The error message was removed.
+  - version: v14.17.1
+    pr-url: https://github.com/nodejs/node/pull/38510
+    description: The error message was reintroduced.
+-->
+
+There was an attempt to use a `MessagePort` instance in a closed
+state, usually after `.close()` has been called.
+
 <a id="ERR_CONSOLE_WRITABLE_STREAM"></a>
 ### `ERR_CONSOLE_WRITABLE_STREAM`
 
 `Console` was instantiated without `stdout` stream, or `Console` has a
 non-writable `stdout` or `stderr` stream.
 
-<a id="ERR_CONSTRUCT_CALL_REQUIRED"></a>
-### `ERR_CONSTRUCT_CALL_REQUIRED`
-
-A constructor for a class was called without `new`.
-
 <a id="ERR_CONSTRUCT_CALL_INVALID"></a>
 ### `ERR_CONSTRUCT_CALL_INVALID`
 <!--
@@ -719,6 +744,19 @@ added: v12.5.0
 
 A class constructor was called that is not callable.
 
+<a id="ERR_CONSTRUCT_CALL_REQUIRED"></a>
+### `ERR_CONSTRUCT_CALL_REQUIRED`
+
+A constructor for a class was called without `new`.
+
+<a id="ERR_CONTEXT_NOT_INITIALIZED"></a>
+### `ERR_CONTEXT_NOT_INITIALIZED`
+
+The vm context passed into the API is not yet initialized. This could happen
+when an error occurs (and is caught) during the creation of the
+context, for example, when the allocation fails or the maximum call stack
+size is reached when the context is created.
+
 <a id="ERR_CPU_USAGE"></a>
 ### `ERR_CPU_USAGE`
 
@@ -838,6 +876,30 @@ An unknown cipher was specified.
 An unknown Diffie-Hellman group name was given. See
 [`crypto.getDiffieHellman()`][] for a list of valid group names.
 
+<a id="ERR_DLOPEN_FAILED"></a>
+### `ERR_DLOPEN_FAILED`
+<!-- YAML
+added: v14.18.0
+-->
+
+A call to `process.dlopen()` failed.
+
+<a id="ERR_DEBUGGER_ERROR"></a>
+### `ERR_DEBUGGER_ERROR`
+<!-- YAML
+added: v14.17.4
+-->
+
+An error occurred with the [debugger][].
+
+<a id="ERR_DEBUGGER_STARTUP_ERROR"></a>
+### `ERR_DEBUGGER_STARTUP_ERROR`
+<!-- YAML
+added: v14.17.4
+-->
+
+The [debugger][] timed out waiting for the required host/port to be free.
+
 <a id="ERR_DIR_CLOSED"></a>
 ### `ERR_DIR_CLOSED`
 
@@ -846,7 +908,7 @@ The [`fs.Dir`][] was previously closed.
 <a id="ERR_DIR_CONCURRENT_OPERATION"></a>
 ### `ERR_DIR_CONCURRENT_OPERATION`
 <!-- YAML
-added: v12.18.1
+added: v14.3.0
 -->
 
 A synchronous read or close call was attempted on an [`fs.Dir`][] which has
@@ -886,6 +948,16 @@ provided.
 Encoding provided to `TextDecoder()` API was not one of the
 [WHATWG Supported Encodings][].
 
+<a id="ERR_EVAL_ESM_CANNOT_PRINT"></a>
+### `ERR_EVAL_ESM_CANNOT_PRINT`
+
+`--print` cannot be used with ESM input.
+
+<a id="ERR_EVENT_RECURSION"></a>
+### `ERR_EVENT_RECURSION`
+
+Thrown when an attempt is made to recursively dispatch an event on `EventTarget`.
+
 <a id="ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE"></a>
 ### `ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`
 
@@ -899,6 +971,20 @@ for the JS engine are not set up properly.
 A `Promise` that was callbackified via `util.callbackify()` was rejected with a
 falsy value.
 
+<a id="ERR_FEATURE_UNAVAILABLE_ON_PLATFORM"></a>
+### `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`
+<!-- YAML
+added: v14.0.0
+-->
+
+Used when a feature that is not available
+to the current platform which is running Node.js is used.
+
+<a id="ERR_FS_EISDIR"></a>
+### `ERR_FS_EISDIR`
+
+Path is a directory.
+
 <a id="ERR_FS_FILE_TOO_LARGE"></a>
 ### `ERR_FS_FILE_TOO_LARGE`
 
@@ -971,6 +1057,12 @@ A non-specific HTTP/2 error has occurred.
 New HTTP/2 Streams may not be opened after the `Http2Session` has received a
 `GOAWAY` frame from the connected peer.
 
+<a id="ERR_HTTP2_HEADER_SINGLE_VALUE"></a>
+### `ERR_HTTP2_HEADER_SINGLE_VALUE`
+
+Multiple values were provided for an HTTP/2 header field that was required to
+have only a single value.
+
 <a id="ERR_HTTP2_HEADERS_AFTER_RESPOND"></a>
 ### `ERR_HTTP2_HEADERS_AFTER_RESPOND`
 
@@ -981,12 +1073,6 @@ An additional headers was specified after an HTTP/2 response was initiated.
 
 An attempt was made to send multiple response headers.
 
-<a id="ERR_HTTP2_HEADER_SINGLE_VALUE"></a>
-### `ERR_HTTP2_HEADER_SINGLE_VALUE`
-
-Multiple values were provided for an HTTP/2 header field that was required to
-have only a single value.
-
 <a id="ERR_HTTP2_INFO_STATUS_NOT_ALLOWED"></a>
 ### `ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`
 
@@ -1059,6 +1145,11 @@ reached.
 An attempt was made to initiate a new push stream from within a push stream.
 Nested push streams are not permitted.
 
+<a id="ERR_HTTP2_NO_MEM"></a>
+### `ERR_HTTP2_NO_MEM`
+
+Out of memory when using the `http2session.setLocalWindowSize(windowSize)` API.
+
 <a id="ERR_HTTP2_NO_SOCKET_MANIPULATION"></a>
 ### `ERR_HTTP2_NO_SOCKET_MANIPULATION`
 
@@ -1187,12 +1278,6 @@ is set for the `Http2Stream`.
 `http2.connect()` was passed a URL that uses any protocol other than `http:` or
 `https:`.
 
-<a id="ERR_INTERNAL_ASSERTION"></a>
-### `ERR_INTERNAL_ASSERTION`
-
-There was a bug in Node.js or incorrect usage of Node.js internals.
-To fix the error, open an issue at <https://github.com/nodejs/node/issues>.
-
 <a id="ERR_INCOMPATIBLE_OPTION_PAIR"></a>
 ### `ERR_INCOMPATIBLE_OPTION_PAIR`
 
@@ -1253,6 +1338,12 @@ before it was connected.
 An API was called on the main thread that can only be used from
 the worker thread.
 
+<a id="ERR_INTERNAL_ASSERTION"></a>
+### `ERR_INTERNAL_ASSERTION`
+
+There was a bug in Node.js or incorrect usage of Node.js internals.
+To fix the error, open an issue at <https://github.com/nodejs/node/issues>.
+
 <a id="ERR_INVALID_ADDRESS_FAMILY"></a>
 ### `ERR_INVALID_ADDRESS_FAMILY`
 
@@ -1338,6 +1429,15 @@ An invalid HTTP token was supplied.
 
 An IP address is not valid.
 
+<a id="ERR_INVALID_MODULE"></a>
+### `ERR_INVALID_MODULE`
+<!-- YAML
+added: v14.18.0
+-->
+
+An attempt was made to load a module that does not exist or was otherwise not
+valid.
+
 <a id="ERR_INVALID_MODULE_SPECIFIER"></a>
 ### `ERR_INVALID_MODULE_SPECIFIER`
 
@@ -1385,8 +1485,8 @@ which is not supported.
 <a id="ERR_INVALID_REPL_INPUT"></a>
 ### `ERR_INVALID_REPL_INPUT`
 
-The input may not be used in the [`REPL`][]. All prohibited inputs are
-documented in the [`REPL`][]'s documentation.
+The input may not be used in the [`REPL`][]. The conditions under which this
+error is used are described in the [`REPL`][] documentation.
 
 <a id="ERR_INVALID_RETURN_PROPERTY"></a>
 ### `ERR_INVALID_RETURN_PROPERTY`
@@ -1515,6 +1615,13 @@ A policy manifest resource had an invalid value for one of its fields. Update
 the manifest entry to match in order to resolve this error. See the
 documentation for [policy][] manifests for more information.
 
+<a id="ERR_MANIFEST_INVALID_SPECIFIER"></a>
+### `ERR_MANIFEST_INVALID_SPECIFIER`
+
+A policy manifest resource had an invalid value for one of its dependency
+mappings. Update the manifest entry to match to resolve this error. See the
+documentation for [policy][] manifests for more information.
+
 <a id="ERR_MANIFEST_PARSE_POLICY"></a>
 ### `ERR_MANIFEST_PARSE_POLICY`
 
@@ -1542,7 +1649,7 @@ failed.
 <a id="ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE"></a>
 ### `ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE`
 <!-- YAML
-added: v12.19.0
+added: v14.5.0
 -->
 
 A message posted to a [`MessagePort`][] could not be deserialized in the target
@@ -1564,13 +1671,12 @@ strict compliance with the API specification (which in some cases may accept
 `func(undefined)` and `func()` are treated identically, and the
 [`ERR_INVALID_ARG_TYPE`][] error code may be used instead.
 
-<a id="ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK"></a>
-### `ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK`
-
-> Stability: 1 - Experimental
+<a id="ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST"></a>
+### `ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`
 
-An [ES Module][] loader hook specified `format: 'dynamic'` but did not provide
-a `dynamicInstantiate` hook.
+An object that needs to be explicitly listed in the `transferList` argument
+is in the object passed to a `postMessage()` call, but is not provided
+in the `transferList` for that call. Usually, this is a `MessagePort`.
 
 <a id="ERR_MISSING_OPTION"></a>
 ### `ERR_MISSING_OPTION`
@@ -1578,13 +1684,6 @@ a `dynamicInstantiate` hook.
 For APIs that accept options objects, some options might be mandatory. This code
 is thrown if a required option is missing.
 
-<a id="ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST"></a>
-### `ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`
-
-An object that needs to be explicitly listed in the `transferList` argument
-was found in the object passed to a `postMessage()` call, but not provided in
-the `transferList` for that call. Usually, this is a `MessagePort`.
-
 <a id="ERR_MISSING_PASSPHRASE"></a>
 ### `ERR_MISSING_PASSPHRASE`
 
@@ -1616,7 +1715,7 @@ would be possible by calling a callback more than once.
 <a id="ERR_NAPI_CONS_FUNCTION"></a>
 ### `ERR_NAPI_CONS_FUNCTION`
 
-While using `N-API`, a constructor passed was not a function.
+While using `Node-API`, a constructor passed was not a function.
 
 <a id="ERR_NAPI_INVALID_DATAVIEW_ARGS"></a>
 ### `ERR_NAPI_INVALID_DATAVIEW_ARGS`
@@ -1678,6 +1777,12 @@ compiled with ICU support.
 
 A non-context-aware native addon was loaded in a process that disallows them.
 
+<a id="ERR_OPERATION_FAILED"></a>
+### `ERR_OPERATION_FAILED`
+
+An operation failed. This is typically used to signal the general failure of an
+asynchronous operation.
+
 <a id="ERR_OUT_OF_RANGE"></a>
 ### `ERR_OUT_OF_RANGE`
 
@@ -1764,11 +1869,6 @@ value.
 While using [`dgram.createSocket()`][], the size of the receive or send `Buffer`
 could not be determined.
 
-<a id="ERR_SOCKET_CANNOT_SEND"></a>
-### `ERR_SOCKET_CANNOT_SEND`
-
-Data could be sent on a socket.
-
 <a id="ERR_SOCKET_CLOSED"></a>
 ### `ERR_SOCKET_CLOSED`
 
@@ -1797,6 +1897,12 @@ A string was provided for a Subresource Integrity check, but was unable to be
 parsed. Check the format of integrity attributes by looking at the
 [Subresource Integrity specification][].
 
+<a id="ERR_STREAM_ALREADY_FINISHED"></a>
+### `ERR_STREAM_ALREADY_FINISHED`
+
+A stream method was called that cannot complete because the stream was
+finished.
+
 <a id="ERR_STREAM_CANNOT_PIPE"></a>
 ### `ERR_STREAM_CANNOT_PIPE`
 
@@ -1869,6 +1975,14 @@ An unspecified or non-specific system error has occurred within the Node.js
 process. The error object will have an `err.info` object property with
 additional details.
 
+<a id="ERR_TLS_CERT_ALTNAME_FORMAT"></a>
+### `ERR_TLS_CERT_ALTNAME_FORMAT`
+
+This error is thrown by `checkServerIdentity` if a user-supplied
+`subjectaltname` property violates encoding rules. Certificate objects produced
+by Node.js itself always comply with encoding rules and will never cause
+this error.
+
 <a id="ERR_TLS_CERT_ALTNAME_INVALID"></a>
 ### `ERR_TLS_CERT_ALTNAME_INVALID`
 
@@ -1892,20 +2006,11 @@ connection.
 <a id="ERR_TLS_INVALID_CONTEXT"></a>
 ### `ERR_TLS_INVALID_CONTEXT`
 <!-- YAML
-added: v12.16.0
+added: v13.3.0
 -->
 
 The context must be a `SecureContext`.
 
-<a id="ERR_TLS_INVALID_STATE"></a>
-### `ERR_TLS_INVALID_STATE`
-<!-- YAML
-added: v12.17.0
--->
-
-The TLS socket must be connected and securily established. Ensure the 'secure'
-event is emitted before continuing.
-
 <a id="ERR_TLS_INVALID_PROTOCOL_METHOD"></a>
 ### `ERR_TLS_INVALID_PROTOCOL_METHOD`
 
@@ -1917,12 +2022,28 @@ disabled because it is insecure.
 
 Valid TLS protocol versions are `'TLSv1'`, `'TLSv1.1'`, or `'TLSv1.2'`.
 
+<a id="ERR_TLS_INVALID_STATE"></a>
+### `ERR_TLS_INVALID_STATE`
+<!-- YAML
+added:
+ - v13.10.0
+ - v12.17.0
+-->
+
+The TLS socket must be connected and securily established. Ensure the 'secure'
+event is emitted before continuing.
+
 <a id="ERR_TLS_PROTOCOL_VERSION_CONFLICT"></a>
 ### `ERR_TLS_PROTOCOL_VERSION_CONFLICT`
 
 Attempting to set a TLS protocol `minVersion` or `maxVersion` conflicts with an
 attempt to set the `secureProtocol` explicitly. Use one mechanism or the other.
 
+<a id="ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED"></a>
+### `ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`
+
+Failed to set PSK identity hint. Hint may be too long.
+
 <a id="ERR_TLS_RENEGOTIATION_DISABLED"></a>
 ### `ERR_TLS_RENEGOTIATION_DISABLED`
 
@@ -1946,11 +2067,6 @@ vector for denial-of-service attacks.
 An attempt was made to issue Server Name Indication from a TLS server-side
 socket, which is only valid from a client.
 
-<a id="ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED"></a>
-### `ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED`
-
-Failed to set PSK identity hint. Hint may be too long.
-
 <a id="ERR_TRACE_EVENTS_CATEGORY_REQUIRED"></a>
 ### `ERR_TRACE_EVENTS_CATEGORY_REQUIRED`
 
@@ -1963,16 +2079,6 @@ category.
 The `trace_events` module could not be loaded because Node.js was compiled with
 the `--without-v8-platform` flag.
 
-<a id="ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER"></a>
-### `ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`
-
-A `SharedArrayBuffer` whose memory is not managed by the JavaScript engine
-or by Node.js was encountered during serialization. Such a `SharedArrayBuffer`
-cannot be serialized.
-
-This can only happen when native addons create `SharedArrayBuffer`s in
-"externalized" mode, or put existing `SharedArrayBuffer` into externalized mode.
-
 <a id="ERR_TRANSFORM_ALREADY_TRANSFORMING"></a>
 ### `ERR_TRANSFORM_ALREADY_TRANSFORMING`
 
@@ -2075,7 +2181,7 @@ import 'package-name'; // supported
 ### `ERR_VALID_PERFORMANCE_ENTRY_TYPE`
 
 While using the Performance Timing API (`perf_hooks`), no valid performance
-entry types were found.
+entry types are found.
 
 <a id="ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"></a>
 ### `ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`
@@ -2113,6 +2219,11 @@ than the parent module. Linked modules must share the same context.
 
 The linker function returned a module for which linking has failed.
 
+<a id="ERR_VM_MODULE_LINK_FAILURE"></a>
+### `ERR_VM_MODULE_LINK_FAILURE`
+
+The module was unable to be linked due to a failure.
+
 <a id="ERR_VM_MODULE_NOT_MODULE"></a>
 ### `ERR_VM_MODULE_NOT_MODULE`
 
@@ -2186,8 +2297,11 @@ Creation of a [`zlib`][] object failed due to incorrect configuration.
 ### `HPE_HEADER_OVERFLOW`
 <!-- YAML
 changes:
-  - version: v11.4.0
-    pr-url: https://github.com/nodejs/node/commit/186035243fad247e3955f
+  - version:
+     - v11.4.0
+     - v10.15.0
+    commit: 186035243fad247e3955f
+    pr-url: https://github.com/nodejs-private/node-private/pull/143
     description: Max header size in `http_parser` was set to 8KB.
 -->
 
@@ -2233,16 +2347,6 @@ removed: v12.5.0
 The value passed to `postMessage()` contained an object that is not supported
 for transferring.
 
-<a id="ERR_CLOSED_MESSAGE_PORT"></a>
-### `ERR_CLOSED_MESSAGE_PORT`
-<!-- YAML
-added: v10.5.0
-removed: v11.12.0
--->
-
-There was an attempt to use a `MessagePort` instance in a closed
-state, usually after `.close()` has been called.
-
 <a id="ERR_CRYPTO_HASH_DIGEST_NO_UTF16"></a>
 ### `ERR_CRYPTO_HASH_DIGEST_NO_UTF16`
 <!-- YAML
@@ -2313,6 +2417,11 @@ removed: v10.0.0
 Used when an invalid character is found in an HTTP response status message
 (reason phrase).
 
+<a id="ERR_HTTP_REQUEST_TIMEOUT"></a>
+### `ERR_HTTP_REQUEST_TIMEOUT`
+
+The client has not sent the entire request within the allowed time.
+
 <a id="ERR_INDEX_OUT_OF_RANGE"></a>
 ### `ERR_INDEX_OUT_OF_RANGE`
 <!-- YAML
@@ -2328,7 +2437,7 @@ added: v9.0.0
 removed: v10.0.0
 -->
 
-Used by the `N-API` when `Constructor.prototype` is not an object.
+Used by the `Node-API` when `Constructor.prototype` is not an object.
 
 <a id="ERR_NO_LONGER_SUPPORTED"></a>
 ### `ERR_NO_LONGER_SUPPORTED`
@@ -2355,6 +2464,15 @@ removed: v10.0.0
 
 The `repl` module was unable to parse data from the REPL history file.
 
+<a id="ERR_SOCKET_CANNOT_SEND"></a>
+### `ERR_SOCKET_CANNOT_SEND`
+<!-- YAML
+added: v9.0.0
+removed: v14.0.0
+-->
+
+Data could not be sent on a socket.
+
 <a id="ERR_STDERR_CLOSE"></a>
 ### `ERR_STDERR_CLOSE`
 <!-- YAML
@@ -2404,17 +2522,19 @@ removed: v10.0.0
 
 Used when a TLS renegotiation request has failed in a non-specific way.
 
-<a id="ERR_UNKNOWN_BUILTIN_MODULE"></a>
-### `ERR_UNKNOWN_BUILTIN_MODULE`
+<a id="ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER"></a>
+### `ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER`
 <!-- YAML
-added: v8.0.0
-removed: v9.0.0
+added: v10.5.0
+removed: v14.0.0
 -->
 
-The `'ERR_UNKNOWN_BUILTIN_MODULE'` error code is used to identify a specific
-kind of internal Node.js error that should not typically be triggered by user
-code. Instances of this error point to an internal bug within the Node.js
-binary itself.
+A `SharedArrayBuffer` whose memory is not managed by the JavaScript engine
+or by Node.js was encountered during serialization. Such a `SharedArrayBuffer`
+cannot be serialized.
+
+This can only happen when native addons create `SharedArrayBuffer`s in
+"externalized" mode, or put existing `SharedArrayBuffer` into externalized mode.
 
 <a id="ERR_UNKNOWN_STDIN_TYPE"></a>
 ### `ERR_UNKNOWN_STDIN_TYPE`
@@ -2467,77 +2587,79 @@ removed: v10.0.0
 Used when an attempt is made to use a `zlib` object after it has already been
 closed.
 
-[`'uncaughtException'`]: process.html#process_event_uncaughtexception
-[`--disable-proto=throw`]: cli.html#cli_disable_proto_mode
-[`--force-fips`]: cli.html#cli_force_fips
-[`Class: assert.AssertionError`]: assert.html#assert_class_assert_assertionerror
+[ES Module]: esm.md
+[ICU]: intl.md#intl_internationalization_support
+[Node.js error codes]: #nodejs-error-codes
+[Subresource Integrity specification]: https://www.w3.org/TR/SRI/#the-integrity-attribute
+[V8's stack trace API]: https://github.com/v8/v8/wiki/Stack-Trace-API
+[WHATWG Supported Encodings]: util.md#util_whatwg_supported_encodings
+[WHATWG URL API]: url.md#url_the_whatwg_url_api
+[`"exports"`]: packages.md#packages_exports
+[`"imports"`]: packages.md#packages_imports
+[`'uncaughtException'`]: process.md#process_event_uncaughtexception
+[`--disable-proto=throw`]: cli.md#cli_disable_proto_mode
+[`--force-fips`]: cli.md#cli_force_fips
+[`Class: assert.AssertionError`]: assert.md#assert_class_assert_assertionerror
 [`ERR_INVALID_ARG_TYPE`]: #ERR_INVALID_ARG_TYPE
-[`EventEmitter`]: events.html#events_class_eventemitter
-[`MessagePort`]: worker_threads.html#worker_threads_class_messageport
+[`EventEmitter`]: events.md#events_class_eventemitter
+[`MessagePort`]: worker_threads.md#worker_threads_class_messageport
 [`Object.getPrototypeOf`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf
 [`Object.setPrototypeOf`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
-[`REPL`]: repl.html
-[`Writable`]: stream.html#stream_class_stream_writable
-[`child_process`]: child_process.html
-[`cipher.getAuthTag()`]: crypto.html#crypto_cipher_getauthtag
-[`crypto.getDiffieHellman()`]: crypto.html#crypto_crypto_getdiffiehellman_groupname
-[`crypto.scrypt()`]: crypto.html#crypto_crypto_scrypt_password_salt_keylen_options_callback
-[`crypto.scryptSync()`]: crypto.html#crypto_crypto_scryptsync_password_salt_keylen_options
-[`crypto.timingSafeEqual()`]: crypto.html#crypto_crypto_timingsafeequal_a_b
-[`dgram.connect()`]: dgram.html#dgram_socket_connect_port_address_callback
-[`dgram.createSocket()`]: dgram.html#dgram_dgram_createsocket_options_callback
-[`dgram.disconnect()`]: dgram.html#dgram_socket_disconnect
-[`dgram.remoteAddress()`]: dgram.html#dgram_socket_remoteaddress
+[`REPL`]: repl.md
+[`Writable`]: stream.md#stream_class_stream_writable
+[`child_process`]: child_process.md
+[`cipher.getAuthTag()`]: crypto.md#crypto_cipher_getauthtag
+[`crypto.getDiffieHellman()`]: crypto.md#crypto_crypto_getdiffiehellman_groupname
+[`crypto.scrypt()`]: crypto.md#crypto_crypto_scrypt_password_salt_keylen_options_callback
+[`crypto.scryptSync()`]: crypto.md#crypto_crypto_scryptsync_password_salt_keylen_options
+[`crypto.timingSafeEqual()`]: crypto.md#crypto_crypto_timingsafeequal_a_b
+[`dgram.connect()`]: dgram.md#dgram_socket_connect_port_address_callback
+[`dgram.createSocket()`]: dgram.md#dgram_dgram_createsocket_options_callback
+[`dgram.disconnect()`]: dgram.md#dgram_socket_disconnect
+[`dgram.remoteAddress()`]: dgram.md#dgram_socket_remoteaddress
 [`errno`(3) man page]: https://man7.org/linux/man-pages/man3/errno.3.html
-[`fs.Dir`]: fs.html#fs_class_fs_dir
-[`fs.readFileSync`]: fs.html#fs_fs_readfilesync_path_options
-[`fs.readdir`]: fs.html#fs_fs_readdir_path_options_callback
-[`fs.symlink()`]: fs.html#fs_fs_symlink_target_path_type_callback
-[`fs.symlinkSync()`]: fs.html#fs_fs_symlinksync_target_path_type
-[`fs.unlink`]: fs.html#fs_fs_unlink_path_callback
-[`fs`]: fs.html
-[`hash.digest()`]: crypto.html#crypto_hash_digest_encoding
-[`hash.update()`]: crypto.html#crypto_hash_update_data_inputencoding
-[`http`]: http.html
-[`https`]: https.html
+[`fs.Dir`]: fs.md#fs_class_fs_dir
+[`fs.readFileSync`]: fs.md#fs_fs_readfilesync_path_options
+[`fs.readdir`]: fs.md#fs_fs_readdir_path_options_callback
+[`fs.symlink()`]: fs.md#fs_fs_symlink_target_path_type_callback
+[`fs.symlinkSync()`]: fs.md#fs_fs_symlinksync_target_path_type
+[`fs.unlink`]: fs.md#fs_fs_unlink_path_callback
+[`fs`]: fs.md
+[`hash.digest()`]: crypto.md#crypto_hash_digest_encoding
+[`hash.update()`]: crypto.md#crypto_hash_update_data_inputencoding
+[`http`]: http.md
+[`https`]: https.md
 [`libuv Error handling`]: https://docs.libuv.org/en/v1.x/errors.html
-[`net`]: net.html
-[`new URL(input)`]: url.html#url_new_url_input_base
-[`new URLSearchParams(iterable)`]: url.html#url_new_urlsearchparams_iterable
-[`process.on('exit')`]: process.html#Event:-`'exit'`
-[`process.send()`]: process.html#process_process_send_message_sendhandle_options_callback
-[`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
-[`readable._read()`]: stream.html#stream_readable_read_size_1
-[`require('crypto').setEngine()`]: crypto.html#crypto_crypto_setengine_engine_flags
-[`require()`]: modules.html#modules_require_id
-[`server.close()`]: net.html#net_server_close_callback
-[`server.listen()`]: net.html#net_server_listen
-[`sign.sign()`]: crypto.html#crypto_sign_sign_privatekey_outputencoding
-[`stream.pipe()`]: stream.html#stream_readable_pipe_destination_options
-[`stream.push()`]: stream.html#stream_readable_push_chunk_encoding
-[`stream.unshift()`]: stream.html#stream_readable_unshift_chunk_encoding
-[`stream.write()`]: stream.html#stream_writable_write_chunk_encoding_callback
-[`subprocess.kill()`]: child_process.html#child_process_subprocess_kill_signal
-[`subprocess.send()`]: child_process.html#child_process_subprocess_send_message_sendhandle_options_callback
-[`zlib`]: zlib.html
-[ES Module]: esm.html
-[ICU]: intl.html#intl_internationalization_support
-[Node.js error codes]: #nodejs-error-codes
-[V8's stack trace API]: https://github.com/v8/v8/wiki/Stack-Trace-API
-[WHATWG Supported Encodings]: util.html#util_whatwg_supported_encodings
-[WHATWG URL API]: url.html#url_the_whatwg_url_api
-[crypto digest algorithm]: crypto.html#crypto_crypto_gethashes
-[domains]: domain.html
-[event emitter-based]: events.html#events_class_eventemitter
-[`package.json`]: packages.html#packages_node_js_package_json_field_definitions
-[`"exports"`]: packages.html#packages_exports
+[`net`]: net.md
+[`new URL(input)`]: url.md#url_new_url_input_base
+[`new URLSearchParams(iterable)`]: url.md#url_new_urlsearchparams_iterable
+[`package.json`]: packages.md#packages_node_js_package_json_field_definitions
+[`process.on('exit')`]: process.md#process_event_exit
+[`process.send()`]: process.md#process_process_send_message_sendhandle_options_callback
+[`process.setUncaughtExceptionCaptureCallback()`]: process.md#process_process_setuncaughtexceptioncapturecallback_fn
+[`readable._read()`]: stream.md#stream_readable_read_size_1
+[`require('crypto').setEngine()`]: crypto.md#crypto_crypto_setengine_engine_flags
+[`require()`]: modules.md#modules_require_id
+[`server.close()`]: net.md#net_server_close_callback
+[`server.listen()`]: net.md#net_server_listen
+[`sign.sign()`]: crypto.md#crypto_sign_sign_privatekey_outputencoding
+[`stream.pipe()`]: stream.md#stream_readable_pipe_destination_options
+[`stream.push()`]: stream.md#stream_readable_push_chunk_encoding
+[`stream.unshift()`]: stream.md#stream_readable_unshift_chunk_encoding
+[`stream.write()`]: stream.md#stream_writable_write_chunk_encoding_callback
+[`subprocess.kill()`]: child_process.md#child_process_subprocess_kill_signal
+[`subprocess.send()`]: child_process.md#child_process_subprocess_send_message_sendhandle_options_callback
+[`util.getSystemErrorName(error.errno)`]: util.md#util_util_getsystemerrorname_err
+[`zlib`]: zlib.md
+[crypto digest algorithm]: crypto.md#crypto_crypto_gethashes
+[debugger]: debugger.md
+[define a custom subpath]: packages.md#packages_subpath_exports
+[domains]: domain.md
+[event emitter-based]: events.md#events_class_eventemitter
 [file descriptors]: https://en.wikipedia.org/wiki/File_descriptor
-[policy]: policy.html
-[stream-based]: stream.html
+[policy]: policy.md
+[self-reference a package using its name]: packages.md#packages_self_referencing_a_package_using_its_name
+[stream-based]: stream.md
 [syscall]: https://man7.org/linux/man-pages/man2/syscalls.2.html
-[Subresource Integrity specification]: https://www.w3.org/TR/SRI/#the-integrity-attribute
 [try-catch]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch
-[vm]: vm.html
-[self-reference a package using its name]: packages.html#packages_self_referencing_a_package_using_its_name
-[define a custom subpath]: packages.html#packages_subpath_exports
-[`"imports"`]: packages.html#packages_imports
+[vm]: vm.md
diff --git a/doc/api/esm.html b/doc/api/esm.html
index e9a68596ee2fa62be2d378b805346bb62585019d..bc4ad2e70278cc3764c23b894bca837c5199107a 100644
--- a/doc/api/esm.html
+++ b/doc/api/esm.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Modules: ECMAScript modules | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Modules: ECMAScript modules | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="esm" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/esm.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/esm.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/esm.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/esm.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/esm.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/esm.html">13.x</a></li>
@@ -112,15 +127,13 @@
 <li><a href="https://nodejs.org/docs/latest-v8.x/api/esm.html">8.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/esm.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/esm.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#esm_modules_ecmascript_modules">Modules: ECMAScript modules</a>
 <ul>
 <li><a href="#esm_introduction">Introduction</a></li>
@@ -128,39 +141,48 @@
 <li><a href="#esm_packages">Packages</a></li>
 <li><a href="#esm_import_specifiers"><code>import</code> Specifiers</a>
 <ul>
-<li><a href="#esm_terminology">Terminology</a>
+<li><a href="#esm_terminology">Terminology</a></li>
+<li><a href="#esm_mandatory_file_extensions">Mandatory file extensions</a></li>
+<li><a href="#esm_urls">URLs</a>
 <ul>
-<li><a href="#esm_node_imports"><code>node:</code> Imports</a></li>
+<li><a href="#esm_file_urls"><code>file:</code> URLs</a></li>
 <li><a href="#esm_data_imports"><code>data:</code> Imports</a></li>
+<li><a href="#esm_node_imports"><code>node:</code> Imports</a></li>
 </ul>
 </li>
 </ul>
 </li>
-<li><a href="#esm_import_meta"><code>import.meta</code></a></li>
+<li><a href="#esm_builtin_modules">Builtin modules</a></li>
+<li><a href="#esm_import_expressions"><code>import()</code> expressions</a></li>
+<li><a href="#esm_import_meta"><code>import.meta</code></a>
+<ul>
+<li><a href="#esm_import_meta_url"><code>import.meta.url</code></a></li>
+<li><span class="stability_1"><a href="#esm_import_meta_resolve_specifier_parent"><code>import.meta.resolve(specifier[, parent])</code></a></span></li>
+</ul>
+</li>
+<li><a href="#esm_interoperability_with_commonjs">Interoperability with CommonJS</a>
+<ul>
+<li><a href="#esm_import_statements"><code>import</code> statements</a></li>
+<li><a href="#esm_require"><code>require</code></a></li>
+<li><a href="#esm_commonjs_namespaces">CommonJS Namespaces</a></li>
 <li><a href="#esm_differences_between_es_modules_and_commonjs">Differences between ES modules and CommonJS</a>
 <ul>
-<li><a href="#esm_mandatory_file_extensions">Mandatory file extensions</a></li>
-<li><a href="#esm_no_node_path">No <code>NODE_PATH</code></a></li>
-<li><a href="#esm_no_require_exports_module_exports_filename_dirname">No <code>require</code>, <code>exports</code>, <code>module.exports</code>, <code>__filename</code>, <code>__dirname</code></a></li>
+<li><a href="#esm_no_require_exports_or_module_exports">No <code>require</code>, <code>exports</code> or <code>module.exports</code></a></li>
+<li><a href="#esm_no_filename_or_dirname">No <code>__filename</code> or <code>__dirname</code></a></li>
+<li><a href="#esm_no_json_module_loading">No JSON Module Loading</a></li>
+<li><a href="#esm_no_native_module_loading">No Native Module Loading</a></li>
 <li><a href="#esm_no_require_resolve">No <code>require.resolve</code></a></li>
+<li><a href="#esm_no_node_path">No <code>NODE_PATH</code></a></li>
 <li><a href="#esm_no_require_extensions">No <code>require.extensions</code></a></li>
 <li><a href="#esm_no_require_cache">No <code>require.cache</code></a></li>
-<li><a href="#esm_url_based_paths">URL-based paths</a></li>
 </ul>
 </li>
-<li><a href="#esm_interoperability_with_commonjs">Interoperability with CommonJS</a>
-<ul>
-<li><a href="#esm_require"><code>require</code></a></li>
-<li><a href="#esm_import_statements"><code>import</code> statements</a></li>
-<li><a href="#esm_import_expressions"><code>import()</code> expressions</a></li>
 </ul>
 </li>
-<li><a href="#esm_commonjs_namespaces">CommonJS Namespaces</a></li>
-<li><a href="#esm_builtin_modules">Builtin modules</a></li>
-<li><a href="#esm_commonjs_json_and_native_modules">CommonJS, JSON, and native modules</a></li>
-<li><a href="#esm_experimental_json_modules">Experimental JSON modules</a></li>
-<li><a href="#esm_experimental_wasm_modules">Experimental Wasm modules</a></li>
-<li><a href="#esm_experimental_loaders">Experimental loaders</a>
+<li><span class="stability_1"><a href="#esm_json_modules">JSON modules</a></span></li>
+<li><span class="stability_1"><a href="#esm_wasm_modules">Wasm modules</a></span></li>
+<li><span class="stability_1"><a href="#esm_top_level_await">Top-level <code>await</code></a></span></li>
+<li><span class="stability_1"><a href="#esm_loaders">Loaders</a></span>
 <ul>
 <li><a href="#esm_hooks">Hooks</a>
 <ul>
@@ -169,7 +191,6 @@
 <li><a href="#esm_getsource_url_context_defaultgetsource"><code>getSource(url, context, defaultGetSource)</code></a></li>
 <li><a href="#esm_transformsource_source_context_defaulttransformsource"><code>transformSource(source, context, defaultTransformSource)</code></a></li>
 <li><a href="#esm_getglobalpreloadcode"><code>getGlobalPreloadCode()</code></a></li>
-<li><a href="#esm_code_dynamicinstantiate_code_hook"><code>dynamicInstantiate</code> hook</a></li>
 </ul>
 </li>
 <li><a href="#esm_examples">Examples</a>
@@ -185,29 +206,30 @@
 <li><a href="#esm_features">Features</a></li>
 <li><a href="#esm_resolver_algorithm">Resolver algorithm</a></li>
 <li><a href="#esm_resolver_algorithm_specification">Resolver Algorithm Specification</a></li>
-<li><a href="#esm_customizing_esm_specifier_resolution_algorithm">Customizing ESM specifier resolution algorithm</a></li>
+<li><span class="stability_1"><a href="#esm_customizing_esm_specifier_resolution_algorithm">Customizing ESM specifier resolution algorithm</a></span></li>
 </ul>
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Modules: ECMAScript modules<span><a class="mark" href="#esm_modules_ecmascript_modules" id="esm_modules_ecmascript_modules">#</a></span></h1>
+        <h2>Modules: ECMAScript modules<span><a class="mark" href="#esm_modules_ecmascript_modules" id="esm_modules_ecmascript_modules">#</a></span></h2>
 
 
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.22.0</td>
+<tr><td>v14.17.0</td>
 <td><p>Stabilize modules implementation.</p></td></tr>
-<tr><td>v12.20.0</td>
+<tr><td>v14.13.0</td>
 <td><p>Support for detection of CommonJS named exports.</p></td></tr>
-<tr><td>v12.20.0</td>
+<tr><td>v14.8.0</td>
+<td><p>Unflag Top-Level Await.</p></td></tr>
+<tr><td>v14.0.0, v13.14.0</td>
 <td><p>Remove experimental modules warning.</p></td></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.2.0, v12.17.0</td>
 <td><p>Loading ECMAScript modules no longer requires a command-line flag.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Add support for ES modules using <code>.js</code> file extension via <code>package.json</code> <code>"type"</code> field.</p></td></tr>
@@ -217,14 +239,14 @@
 </details>
 </div>
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<h2>Introduction<span><a class="mark" href="#esm_introduction" id="esm_introduction">#</a></span></h2>
+<section><h3>Introduction<span><a class="mark" href="#esm_introduction" id="esm_introduction">#</a></span></h3>
 
 <p>ECMAScript modules are <a href="https://tc39.github.io/ecma262/#sec-modules">the official standard format</a> to package JavaScript
 code for reuse. Modules are defined using a variety of <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import"><code>import</code></a> and
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export"><code>export</code></a> statements.</p>
 <p>The following example of an ES module exports a function:</p>
 <pre><code class="language-js"><span class="hljs-comment">// addTwo.mjs</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">addTwo</span>(<span class="hljs-params">num</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">addTwo</span>(<span class="hljs-params">num</span>) {
   <span class="hljs-keyword">return</span> num + <span class="hljs-number">2</span>;
 }
 
@@ -234,15 +256,15 @@ code for reuse. Modules are defined using a variety of <a href="https://develope
 <span class="hljs-keyword">import</span> { addTwo } <span class="hljs-keyword">from</span> <span class="hljs-string">'./addTwo.mjs'</span>;
 
 <span class="hljs-comment">// Prints: 6</span>
-<span class="hljs-built_in">console</span>.log(addTwo(<span class="hljs-number">4</span>));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">addTwo</span>(<span class="hljs-number">4</span>));</code></pre>
 <p>Node.js fully supports ECMAScript modules as they are currently specified and
 provides interoperability between them and its original module format,
 <a href="modules.html">CommonJS</a>.</p>
 <!-- Anchors to make sure old links find a target -->
-<p><i id="#esm_package_json_type_field"></i>
-<i id="#esm_package_scope_and_file_extensions"></i>
-<i id="#esm_input_type_flag"></i></p>
-<h2>Enabling<span><a class="mark" href="#esm_enabling" id="esm_enabling">#</a></span></h2>
+<p><i id="esm_package_json_type_field"></i>
+<i id="esm_package_scope_and_file_extensions"></i>
+<i id="esm_input_type_flag"></i></p>
+</section><section><h3>Enabling<span><a class="mark" href="#esm_enabling" id="esm_enabling">#</a></span></h3>
 
 <p>Node.js treats JavaScript code as CommonJS modules by default.
 Authors can tell Node.js to treat JavaScript code as ECMAScript modules
@@ -265,48 +287,62 @@ details.</p>
 <i id="esm_writing_dual_packages_while_avoiding_or_minimizing_hazards"></i>
 <i id="esm_approach_1_use_an_es_module_wrapper"></i>
 <i id="esm_approach_2_isolate_state"></i></p>
-<h2>Packages<span><a class="mark" href="#esm_packages" id="esm_packages">#</a></span></h2>
+</section><section><h3>Packages<span><a class="mark" href="#esm_packages" id="esm_packages">#</a></span></h3>
 <p>This section was moved to <a href="packages.html">Modules: Packages</a>.</p>
-<h2><code>import</code> Specifiers<span><a class="mark" href="#esm_import_specifiers" id="esm_import_specifiers">#</a></span></h2>
-<h3>Terminology<span><a class="mark" href="#esm_terminology" id="esm_terminology">#</a></span></h3>
+</section><section><h3><code>import</code> Specifiers<span><a class="mark" href="#esm_import_specifiers" id="esm_import_specifiers">#</a></span></h3>
+<h4>Terminology<span><a class="mark" href="#esm_terminology" id="esm_terminology">#</a></span></h4>
 <p>The <em>specifier</em> of an <code>import</code> statement is the string after the <code>from</code> keyword,
 e.g. <code>'path'</code> in <code>import { sep } from 'path'</code>. Specifiers are also used in
 <code>export from</code> statements, and as the argument to an <code>import()</code> expression.</p>
-<p>There are four types of specifiers:</p>
+<p>There are three types of specifiers:</p>
 <ul>
 <li>
-<p><em>Bare specifiers</em> like <code>'some-package'</code>. They refer to an entry point of a
-package by the package name.</p>
-</li>
-<li>
-<p><em>Deep import specifiers</em> like <code>'some-package/lib/shuffle.mjs'</code>. They refer to
-a path within a package prefixed by the package name.</p>
+<p><em>Relative specifiers</em> like <code>'./startup.js'</code> or <code>'../config.mjs'</code>. They refer
+to a path relative to the location of the importing file. <em>The file extension
+is always necessary for these.</em></p>
 </li>
 <li>
-<p><em>Relative specifiers</em> like <code>'./startup.js'</code> or <code>'../config.mjs'</code>. They refer
-to a path relative to the location of the importing file.</p>
+<p><em>Bare specifiers</em> like <code>'some-package'</code> or <code>'some-package/shuffle'</code>. They can
+refer to the main entry point of a package by the package name, or a
+specific feature module within a package prefixed by the package name as per
+the examples respectively. <em>Including the file extension is only necessary
+for packages without an <a href="packages.html#packages_exports"><code>"exports"</code></a> field.</em></p>
 </li>
 <li>
 <p><em>Absolute specifiers</em> like <code>'file:///opt/nodejs/config.js'</code>. They refer
 directly and explicitly to a full path.</p>
 </li>
 </ul>
-<p>Bare specifiers, and the bare specifier portion of deep import specifiers, are
-strings; but everything else in a specifier is a URL.</p>
-<p><code>file:</code>, <code>node:</code>, and <code>data:</code> URLs are supported. A specifier like
-<code>'https://example.com/app.js'</code> may be supported by browsers but it is not
-supported in Node.js.</p>
-<p>Specifiers may not begin with <code>/</code> or <code>//</code>. These are reserved for potential
-future use. The root of the current volume may be referenced via <code>file:///</code>.</p>
-<h4><code>node:</code> Imports<span><a class="mark" href="#esm_node_imports" id="esm_node_imports">#</a></span></h4>
-<div class="api_metadata">
-<span>Added in: v12.20.0</span>
-</div>
-<p><code>node:</code> URLs are supported as a means to load Node.js builtin modules. This
-URL scheme allows for builtin modules to be referenced by valid absolute URL
-strings.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'node:fs/promises'</span>;</code></pre>
-<h4><code>data:</code> Imports<span><a class="mark" href="#esm_data_imports" id="esm_data_imports">#</a></span></h4>
+<p>Bare specifier resolutions are handled by the <a href="#esm_resolver_algorithm_specification">Node.js module resolution
+algorithm</a>. All other specifier resolutions are always only resolved with
+the standard relative <a href="https://url.spec.whatwg.org/">URL</a> resolution semantics.</p>
+<p>Like in CommonJS, module files within packages can be accessed by appending a
+path to the package name unless the package’s <a href="packages.html#packages_node_js_package_json_field_definitions"><code>package.json</code></a> contains an
+<a href="packages.html#packages_exports"><code>"exports"</code></a> field, in which case files within packages can only be accessed
+via the paths defined in <a href="packages.html#packages_exports"><code>"exports"</code></a>.</p>
+<p>For details on these package resolution rules that apply to bare specifiers in
+the Node.js module resolution, see the <a href="packages.html">packages documentation</a>.</p>
+<h4>Mandatory file extensions<span><a class="mark" href="#esm_mandatory_file_extensions" id="esm_mandatory_file_extensions">#</a></span></h4>
+<p>A file extension must be provided when using the <code>import</code> keyword to resolve
+relative or absolute specifiers. Directory indexes (e.g. <code>'./startup/index.js'</code>)
+must also be fully specified.</p>
+<p>This behavior matches how <code>import</code> behaves in browser environments, assuming a
+typically configured server.</p>
+<h4>URLs<span><a class="mark" href="#esm_urls" id="esm_urls">#</a></span></h4>
+<p>ES modules are resolved and cached as URLs. This means that files containing
+special characters such as <code>#</code> and <code>?</code> need to be escaped.</p>
+<p><code>file:</code>, <code>node:</code>, and <code>data:</code> URL schemes are supported. A specifier like
+<code>'https://example.com/app.js'</code> is not supported natively in Node.js unless using
+a <a href="#esm_https_loader">custom HTTPS loader</a>.</p>
+<h5><code>file:</code> URLs<span><a class="mark" href="#esm_file_urls" id="esm_file_urls">#</a></span></h5>
+<p>Modules are loaded multiple times if the <code>import</code> specifier used to resolve
+them has a different query or fragment.</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-string">'./foo.mjs?query=1'</span>; <span class="hljs-comment">// loads ./foo.mjs with query of "?query=1"</span>
+<span class="hljs-keyword">import</span> <span class="hljs-string">'./foo.mjs?query=2'</span>; <span class="hljs-comment">// loads ./foo.mjs with query of "?query=2"</span></code></pre>
+<p>The volume root may be referenced via <code>/</code>, <code>//</code> or <code>file:///</code>. Given the
+differences between <a href="https://url.spec.whatwg.org/">URL</a> and path resolution (such as percent encoding
+details), it is recommended to use <a href="url.html#url_url_pathtofileurl_path">url.pathToFileURL</a> when importing a path.</p>
+<h5><code>data:</code> Imports<span><a class="mark" href="#esm_data_imports" id="esm_data_imports">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v12.10.0</span>
 </div>
@@ -325,94 +361,107 @@ is no concept of relative resolution for <code>data:</code> URLs. An example of
 URLs being used is:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-string">'data:text/javascript,console.log("hello!");'</span>;
 <span class="hljs-keyword">import</span> _ <span class="hljs-keyword">from</span> <span class="hljs-string">'data:application/json,"world!"'</span>;</code></pre>
-<h2><code>import.meta</code><span><a class="mark" href="#esm_import_meta" id="esm_import_meta">#</a></span></h2>
+<h5><code>node:</code> Imports<span><a class="mark" href="#esm_node_imports" id="esm_node_imports">#</a></span></h5>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Added <code>node:</code> import support to <code>require(...)</code>.</p></td></tr>
+<tr><td>v14.13.1, v12.20.0</td>
+<td><p><span>Added in: v14.13.1, v12.20.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p><code>node:</code> URLs are supported as an alternative means to load Node.js builtin
+modules. This URL scheme allows for builtin modules to be referenced by valid
+absolute URL strings.</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'node:fs/promises'</span>;</code></pre>
+</section><section><h3>Builtin modules<span><a class="mark" href="#esm_builtin_modules" id="esm_builtin_modules">#</a></span></h3>
+<p><a href="modules.html#modules_core_modules">Core modules</a> provide named exports of their public API. A
+default export is also provided which is the value of the CommonJS exports.
+The default export can be used for, among other things, modifying the named
+exports. Named exports of builtin modules are updated only by calling
+<a href="module.html#module_module_syncbuiltinesmexports"><code>module.syncBuiltinESMExports()</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-title class_">EventEmitter</span> <span class="hljs-keyword">from</span> <span class="hljs-string">'events'</span>;
+<span class="hljs-keyword">const</span> e = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'./foo.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err, source</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+  } <span class="hljs-keyword">else</span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(source);
+  }
+});</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> fs, { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-keyword">import</span> { syncBuiltinESMExports } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
+
+fs.<span class="hljs-property">readFileSync</span> = <span class="hljs-function">() =></span> <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Hello, ESM'</span>);
+<span class="hljs-title function_">syncBuiltinESMExports</span>();
+
+fs.<span class="hljs-property">readFileSync</span> === readFileSync;</code></pre>
+</section><section><h3><code>import()</code> expressions<span><a class="mark" href="#esm_import_expressions" id="esm_import_expressions">#</a></span></h3>
+<p><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports">Dynamic <code>import()</code></a> is supported in both CommonJS and ES modules. In CommonJS
+modules it can be used to load ES modules.</p>
+</section><section><h3><code>import.meta</code><span><a class="mark" href="#esm_import_meta" id="esm_import_meta">#</a></span></h3>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
-<p>The <code>import.meta</code> metaproperty is an <code>Object</code> that contains the following
-property:</p>
+<p>The <code>import.meta</code> meta property is an <code>Object</code> that contains the following
+properties.</p>
+<h4><code>import.meta.url</code><span><a class="mark" href="#esm_import_meta_url" id="esm_import_meta_url">#</a></span></h4>
 <ul>
-<li><code>url</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The absolute <code>file:</code> URL of the module.</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The absolute <code>file:</code> URL of the module.</li>
 </ul>
-<h2>Differences between ES modules and CommonJS<span><a class="mark" href="#esm_differences_between_es_modules_and_commonjs" id="esm_differences_between_es_modules_and_commonjs">#</a></span></h2>
-<h3>Mandatory file extensions<span><a class="mark" href="#esm_mandatory_file_extensions" id="esm_mandatory_file_extensions">#</a></span></h3>
-<p>A file extension must be provided when using the <code>import</code> keyword. Directory
-indexes (e.g. <code>'./startup/index.js'</code>) must also be fully specified.</p>
-<p>This behavior matches how <code>import</code> behaves in browser environments, assuming a
-typically configured server.</p>
-<h3>No <code>NODE_PATH</code><span><a class="mark" href="#esm_no_node_path" id="esm_no_node_path">#</a></span></h3>
-<p><code>NODE_PATH</code> is not part of resolving <code>import</code> specifiers. Please use symlinks
-if this behavior is desired.</p>
-<h3>No <code>require</code>, <code>exports</code>, <code>module.exports</code>, <code>__filename</code>, <code>__dirname</code><span><a class="mark" href="#esm_no_require_exports_module_exports_filename_dirname" id="esm_no_require_exports_module_exports_filename_dirname">#</a></span></h3>
-<p>These CommonJS variables are not available in ES modules.</p>
-<p><code>require</code> can be imported into an ES module using <a href="module.html#module_module_createrequire_filename"><code>module.createRequire()</code></a>.</p>
-<p>Equivalents of <code>__filename</code> and <code>__dirname</code> can be created inside of each file
-via <a href="#esm_import_meta"><code>import.meta.url</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> { fileURLToPath } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
-<span class="hljs-keyword">import</span> { dirname } <span class="hljs-keyword">from</span> <span class="hljs-string">'path'</span>;
-
-<span class="hljs-keyword">const</span> __filename = fileURLToPath(<span class="hljs-keyword">import</span>.meta.url);
-<span class="hljs-keyword">const</span> __dirname = dirname(__filename);</code></pre>
-<h3>No <code>require.resolve</code><span><a class="mark" href="#esm_no_require_resolve" id="esm_no_require_resolve">#</a></span></h3>
-<p>Former use cases relying on <code>require.resolve</code> to determine the resolved path
-of a module can be supported via <code>import.meta.resolve</code>, which is experimental
-and supported via the <code>--experimental-import-meta-resolve</code> flag:</p>
-<pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> dependencyAsset = <span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>.meta.resolve(<span class="hljs-string">'component-lib/asset.css'</span>);
-})();</code></pre>
+<p>This is defined exactly the same as it is in browsers providing the URL of the
+current module file.</p>
+<p>This enables useful patterns such as relative file loading:</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'./data.proto'</span>, <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>));</code></pre>
+<h4><code>import.meta.resolve(specifier[, parent])</code><span><a class="mark" href="#esm_import_meta_resolve_specifier_parent" id="esm_import_meta_resolve_specifier_parent">#</a></span></h4>
+<!--
+added:
+  - v13.9.0
+  - v12.16.2
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38587
+    description: Add support for WHATWG `URL` object to `parentURL` parameter.
+-->
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>This feature is only available with the <code>--experimental-import-meta-resolve</code>
+command flag enabled.</p>
+<ul>
+<li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The module specifier to resolve relative to <code>parent</code>.</li>
+<li><code>parent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The absolute parent module URL to resolve from. If none
+is specified, the value of <code>import.meta.url</code> is used as the default.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Provides a module-relative resolution function scoped to each module, returning
+the URL string.</p>
+<!-- eslint-skip -->
+<pre><code class="language-js"><span class="hljs-keyword">const</span> dependencyAsset = <span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'component-lib/asset.css'</span>);</code></pre>
 <p><code>import.meta.resolve</code> also accepts a second argument which is the parent module
 from which to resolve from:</p>
-<pre><code class="language-js">(<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-comment">// Equivalent to import.meta.resolve('./dep')</span>
-  <span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>.meta.resolve(<span class="hljs-string">'./dep'</span>, <span class="hljs-keyword">import</span>.meta.url);
-})();</code></pre>
+<!-- eslint-skip -->
+<pre><code class="language-js"><span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'./dep'</span>, <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>);</code></pre>
 <p>This function is asynchronous because the ES module resolver in Node.js is
-asynchronous. With the introduction of <a href="https://github.com/tc39/proposal-top-level-await">Top-Level Await</a>, these use cases
-will be easier as they won't require an async function wrapper.</p>
-<h3>No <code>require.extensions</code><span><a class="mark" href="#esm_no_require_extensions" id="esm_no_require_extensions">#</a></span></h3>
-<p><code>require.extensions</code> is not used by <code>import</code>. The expectation is that loader
-hooks can provide this workflow in the future.</p>
-<h3>No <code>require.cache</code><span><a class="mark" href="#esm_no_require_cache" id="esm_no_require_cache">#</a></span></h3>
-<p><code>require.cache</code> is not used by <code>import</code>. It has a separate cache.</p>
-<h3>URL-based paths<span><a class="mark" href="#esm_url_based_paths" id="esm_url_based_paths">#</a></span></h3>
-<p>ES modules are resolved and cached based upon
-<a href="https://url.spec.whatwg.org/">URL</a> semantics. This means that files containing
-special characters such as <code>#</code> and <code>?</code> need to be escaped.</p>
-<p>Modules are loaded multiple times if the <code>import</code> specifier used to resolve
-them has a different query or fragment.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-string">'./foo.mjs?query=1'</span>; <span class="hljs-comment">// loads ./foo.mjs with query of "?query=1"</span>
-<span class="hljs-keyword">import</span> <span class="hljs-string">'./foo.mjs?query=2'</span>; <span class="hljs-comment">// loads ./foo.mjs with query of "?query=2"</span></code></pre>
-<p>For now, only modules using the <code>file:</code> protocol can be loaded.</p>
-<h2>Interoperability with CommonJS<span><a class="mark" href="#esm_interoperability_with_commonjs" id="esm_interoperability_with_commonjs">#</a></span></h2>
-<h3><code>require</code><span><a class="mark" href="#esm_require" id="esm_require">#</a></span></h3>
-<p><code>require</code> always treats the files it references as CommonJS. This applies
-whether <code>require</code> is used the traditional way within a CommonJS environment, or
-in an ES module environment using <a href="module.html#module_module_createrequire_filename"><code>module.createRequire()</code></a>.</p>
-<p>To include an ES module into CommonJS, use <a href="#esm_import_expressions"><code>import()</code></a>.</p>
-<h3><code>import</code> statements<span><a class="mark" href="#esm_import_statements" id="esm_import_statements">#</a></span></h3>
+allowed to be asynchronous.</p>
+</section><section><h3>Interoperability with CommonJS<span><a class="mark" href="#esm_interoperability_with_commonjs" id="esm_interoperability_with_commonjs">#</a></span></h3>
+<h4><code>import</code> statements<span><a class="mark" href="#esm_import_statements" id="esm_import_statements">#</a></span></h4>
 <p>An <code>import</code> statement can reference an ES module or a CommonJS module.
-<code>import</code> statements are permitted only in ES modules. For similar functionality
-in CommonJS, see <a href="#esm_import_expressions"><code>import()</code></a>.</p>
+<code>import</code> statements are permitted only in ES modules, but dynamic <a href="#esm_import_expressions"><code>import()</code></a>
+expressions are supported in CommonJS for loading ES modules.</p>
 <p>When importing <a href="#esm_commonjs_namespaces">CommonJS modules</a>, the
 <code>module.exports</code> object is provided as the default export. Named exports may be
 available, provided by static analysis as a convenience for better ecosystem
 compatibility.</p>
-<p>Additional experimental flags are available for importing
-<a href="#esm_experimental_wasm_modules">Wasm modules</a> or
-<a href="#esm_experimental_json_modules">JSON modules</a>. For importing native modules or
-JSON modules unflagged, see <a href="module.html#module_module_createrequire_filename"><code>module.createRequire()</code></a>.</p>
-<p>The <em>specifier</em> of an <code>import</code> statement (the string after the <code>from</code> keyword)
-can either be an URL-style relative path like <code>'./file.mjs'</code> or a package name
-like <code>'fs'</code>.</p>
-<p>Like in CommonJS, files within packages can be accessed by appending a path to
-the package name; unless the package’s <a href="packages.html#packages_node_js_package_json_field_definitions"><code>package.json</code></a> contains an
-<a href="packages.html#packages_exports"><code>"exports"</code></a> field, in which case files within packages need to be accessed
-via the path defined in <a href="packages.html#packages_exports"><code>"exports"</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> { sin, cos } <span class="hljs-keyword">from</span> <span class="hljs-string">'geometry/trigonometry-functions.mjs'</span>;</code></pre>
-<h3><code>import()</code> expressions<span><a class="mark" href="#esm_import_expressions" id="esm_import_expressions">#</a></span></h3>
-<p><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports">Dynamic <code>import()</code></a> is supported in both CommonJS and ES modules. It can be
-used to include ES module files from CommonJS code.</p>
-<h2>CommonJS Namespaces<span><a class="mark" href="#esm_commonjs_namespaces" id="esm_commonjs_namespaces">#</a></span></h2>
+<h4><code>require</code><span><a class="mark" href="#esm_require" id="esm_require">#</a></span></h4>
+<p>The CommonJS module <code>require</code> always treats the files it references as CommonJS.</p>
+<p>Using <code>require</code> to load an ES module is not supported because ES modules have
+asynchronous execution. Instead, use <a href="#esm_import_expressions"><code>import()</code></a> to load an ES module
+from a CommonJS module.</p>
+<h4>CommonJS Namespaces<span><a class="mark" href="#esm_commonjs_namespaces" id="esm_commonjs_namespaces">#</a></span></h4>
 <p>CommonJS modules consist of a <code>module.exports</code> object which can be of any type.</p>
 <p>When importing a CommonJS module, it can be reliably imported using the ES
 module default import or its corresponding sugar syntax:</p>
@@ -423,8 +472,8 @@ module default import or its corresponding sugar syntax:</p>
 <span class="hljs-comment">// for `{ default as cjsSugar }` in the above import statement:</span>
 <span class="hljs-keyword">import</span> cjsSugar <span class="hljs-keyword">from</span> <span class="hljs-string">'cjs'</span>;
 
-<span class="hljs-built_in">console</span>.log(cjs);
-<span class="hljs-built_in">console</span>.log(cjs === cjsSugar);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(cjs);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(cjs === cjsSugar);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   &#x3C;module.exports></span>
 <span class="hljs-comment">//   true</span></code></pre>
@@ -435,8 +484,8 @@ a namespace with a <code>default</code> export key pointing to the CommonJS
 <code>import * as m from 'cjs'</code> or a dynamic import:</p>
 <!-- eslint-skip -->
 <pre><code class="language-js"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> m <span class="hljs-keyword">from</span> <span class="hljs-string">'cjs'</span>;
-<span class="hljs-built_in">console</span>.log(m);
-<span class="hljs-built_in">console</span>.log(m === <span class="hljs-keyword">await</span> <span class="hljs-keyword">import</span>(<span class="hljs-string">'cjs'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(m);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(m === <span class="hljs-keyword">await</span> <span class="hljs-title function_">import</span>(<span class="hljs-string">'cjs'</span>));
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   [Module] { default: &#x3C;module.exports> }</span>
 <span class="hljs-comment">//   true</span></code></pre>
@@ -445,20 +494,20 @@ in addition attempts to determine the CommonJS named exports of every imported
 CommonJS module to provide them as separate ES module exports using a static
 analysis process.</p>
 <p>For example, consider a CommonJS module written:</p>
-<pre><code class="language-js"><span class="hljs-comment">// cjs.cjs</span>
-<span class="hljs-built_in">exports</span>.name = <span class="hljs-string">'exported'</span>;</code></pre>
+<pre><code class="language-js cjs"><span class="hljs-comment">// cjs.cjs</span>
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">name</span> = <span class="hljs-string">'exported'</span>;</code></pre>
 <p>The preceding module supports named imports in ES modules:</p>
 <!-- eslint-disable no-duplicate-imports -->
 <pre><code class="language-js"><span class="hljs-keyword">import</span> { name } <span class="hljs-keyword">from</span> <span class="hljs-string">'./cjs.cjs'</span>;
-<span class="hljs-built_in">console</span>.log(name);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(name);
 <span class="hljs-comment">// Prints: 'exported'</span>
 
 <span class="hljs-keyword">import</span> cjs <span class="hljs-keyword">from</span> <span class="hljs-string">'./cjs.cjs'</span>;
-<span class="hljs-built_in">console</span>.log(cjs);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(cjs);
 <span class="hljs-comment">// Prints: { name: 'exported' }</span>
 
 <span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> m <span class="hljs-keyword">from</span> <span class="hljs-string">'./cjs.cjs'</span>;
-<span class="hljs-built_in">console</span>.log(m);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(m);
 <span class="hljs-comment">// Prints: [Module] { default: { name: 'exported' }, name: 'exported' }</span></code></pre>
 <p>As can be seen from the last example of the Module Namespace Exotic Object being
 logged, the <code>name</code> export is copied off of the <code>module.exports</code> object and set
@@ -469,45 +518,46 @@ for these named exports.</p>
 always correctly detect named exports. In these cases, using the default
 import form described above can be a better option.</p>
 <p>Named exports detection covers many common export patterns, reexport patterns
-and build tool and transpiler outputs. See <a href="https://github.com/guybedford/cjs-module-lexer/tree/1.2.1">cjs-module-lexer</a> for the exact
+and build tool and transpiler outputs. See <a href="https://github.com/guybedford/cjs-module-lexer/tree/1.2.2">cjs-module-lexer</a> for the exact
 semantics implemented.</p>
-<h2>Builtin modules<span><a class="mark" href="#esm_builtin_modules" id="esm_builtin_modules">#</a></span></h2>
-<p><a href="modules.html#modules_core_modules">Core modules</a> provide named exports of their public API. A
-default export is also provided which is the value of the CommonJS exports.
-The default export can be used for, among other things, modifying the named
-exports. Named exports of builtin modules are updated only by calling
-<a href="module.html#module_module_syncbuiltinesmexports"><code>module.syncBuiltinESMExports()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> EventEmitter <span class="hljs-keyword">from</span> <span class="hljs-string">'events'</span>;
-<span class="hljs-keyword">const</span> e = <span class="hljs-keyword">new</span> EventEmitter();</code></pre>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
-readFile(<span class="hljs-string">'./foo.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err, source</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(err);
-  } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(source);
-  }
-});</code></pre>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> fs, { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
-<span class="hljs-keyword">import</span> { syncBuiltinESMExports } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
-
-fs.readFileSync = <span class="hljs-function">() =></span> Buffer.from(<span class="hljs-string">'Hello, ESM'</span>);
-syncBuiltinESMExports();
-
-fs.readFileSync === readFileSync;</code></pre>
-<h2>CommonJS, JSON, and native modules<span><a class="mark" href="#esm_commonjs_json_and_native_modules" id="esm_commonjs_json_and_native_modules">#</a></span></h2>
-<p>CommonJS, JSON, and native modules can be used with
+<h4>Differences between ES modules and CommonJS<span><a class="mark" href="#esm_differences_between_es_modules_and_commonjs" id="esm_differences_between_es_modules_and_commonjs">#</a></span></h4>
+<h5>No <code>require</code>, <code>exports</code> or <code>module.exports</code><span><a class="mark" href="#esm_no_require_exports_or_module_exports" id="esm_no_require_exports_or_module_exports">#</a></span></h5>
+<p>In most cases, the ES module <code>import</code> can be used to load CommonJS modules.</p>
+<p>If needed, a <code>require</code> function can be constructed within an ES module using
 <a href="module.html#module_module_createrequire_filename"><code>module.createRequire()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-comment">// cjs.cjs</span>
-<span class="hljs-built_in">module</span>.exports = <span class="hljs-string">'cjs'</span>;
-
-<span class="hljs-comment">// esm.mjs</span>
-<span class="hljs-keyword">import</span> { createRequire } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
-
-<span class="hljs-keyword">const</span> <span class="hljs-built_in">require</span> = createRequire(<span class="hljs-keyword">import</span>.meta.url);
-
-<span class="hljs-keyword">const</span> cjs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./cjs.cjs'</span>);
-cjs === <span class="hljs-string">'cjs'</span>; <span class="hljs-comment">// true</span></code></pre>
-<h2>Experimental JSON modules<span><a class="mark" href="#esm_experimental_json_modules" id="esm_experimental_json_modules">#</a></span></h2>
+<h5>No <code>__filename</code> or <code>__dirname</code><span><a class="mark" href="#esm_no_filename_or_dirname" id="esm_no_filename_or_dirname">#</a></span></h5>
+<p>These CommonJS variables are not available in ES modules.</p>
+<p><code>__filename</code> and <code>__dirname</code> use cases can be replicated via
+<a href="#esm_import_meta_url"><code>import.meta.url</code></a>.</p>
+<h5>No JSON Module Loading<span><a class="mark" href="#esm_no_json_module_loading" id="esm_no_json_module_loading">#</a></span></h5>
+<p>JSON imports are still experimental and only supported via the
+<code>--experimental-json-modules</code> flag.</p>
+<p>Local JSON files can be loaded relative to <code>import.meta.url</code> with <code>fs</code> directly:</p>
+<!-- eslint-skip -->
+<pre><code class="language-js"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+<span class="hljs-keyword">const</span> json = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(<span class="hljs-keyword">await</span> <span class="hljs-title function_">readFile</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'./dat.json'</span>, <span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>)));</code></pre>
+<p>Alternatively <code>module.createRequire()</code> can be used.</p>
+<h5>No Native Module Loading<span><a class="mark" href="#esm_no_native_module_loading" id="esm_no_native_module_loading">#</a></span></h5>
+<p>Native modules are not currently supported with ES module imports.</p>
+<p>They can instead be loaded with <a href="module.html#module_module_createrequire_filename"><code>module.createRequire()</code></a> or
+<a href="process.html#process_process_dlopen_module_filename_flags"><code>process.dlopen</code></a>.</p>
+<h5>No <code>require.resolve</code><span><a class="mark" href="#esm_no_require_resolve" id="esm_no_require_resolve">#</a></span></h5>
+<p>Relative resolution can be handled via <code>new URL('./local', import.meta.url)</code>.</p>
+<p>For a complete <code>require.resolve</code> replacement, there is a flagged experimental
+<a href="#esm_import_meta_resolve_specifier_parent"><code>import.meta.resolve</code></a> API.</p>
+<p>Alternatively <code>module.createRequire()</code> can be used.</p>
+<h5>No <code>NODE_PATH</code><span><a class="mark" href="#esm_no_node_path" id="esm_no_node_path">#</a></span></h5>
+<p><code>NODE_PATH</code> is not part of resolving <code>import</code> specifiers. Please use symlinks
+if this behavior is desired.</p>
+<h5>No <code>require.extensions</code><span><a class="mark" href="#esm_no_require_extensions" id="esm_no_require_extensions">#</a></span></h5>
+<p><code>require.extensions</code> is not used by <code>import</code>. The expectation is that loader
+hooks can provide this workflow in the future.</p>
+<h5>No <code>require.cache</code><span><a class="mark" href="#esm_no_require_cache" id="esm_no_require_cache">#</a></span></h5>
+<p><code>require.cache</code> is not used by <code>import</code> as the ES module loader has its own
+separate cache.</p>
+<p><i id="esm_experimental_json_modules"></i></p>
+</section><section><h3>JSON modules<span><a class="mark" href="#esm_json_modules" id="esm_json_modules">#</a></span></h3>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Currently importing JSON modules are only supported in the <code>commonjs</code> mode
 and are loaded using the CJS loader. <a href="https://html.spec.whatwg.org/#creating-a-json-module-script">WHATWG JSON modules specification</a> are
 still being standardized, and are experimentally supported by including the
@@ -526,7 +576,9 @@ same path.</p>
 to work.</p>
 <pre><code class="language-bash">node index.mjs <span class="hljs-comment"># fails</span>
 node --experimental-json-modules index.mjs <span class="hljs-comment"># works</span></code></pre>
-<h2>Experimental Wasm modules<span><a class="mark" href="#esm_experimental_wasm_modules" id="esm_experimental_wasm_modules">#</a></span></h2>
+<p><i id="esm_experimental_wasm_modules"></i></p>
+</section><section><h3>Wasm modules<span><a class="mark" href="#esm_wasm_modules" id="esm_wasm_modules">#</a></span></h3>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>Importing Web Assembly modules is supported under the
 <code>--experimental-wasm-modules</code> flag, allowing any <code>.wasm</code> files to be
 imported as normal modules while also supporting their module imports.</p>
@@ -534,19 +586,34 @@ imported as normal modules while also supporting their module imports.</p>
 <a href="https://github.com/webassembly/esm-integration">ES Module Integration Proposal for Web Assembly</a>.</p>
 <p>For example, an <code>index.mjs</code> containing:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> M <span class="hljs-keyword">from</span> <span class="hljs-string">'./module.wasm'</span>;
-<span class="hljs-built_in">console</span>.log(M);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(M);</code></pre>
 <p>executed under:</p>
 <pre><code class="language-bash">node --experimental-wasm-modules index.mjs</code></pre>
 <p>would provide the exports interface for the instantiation of <code>module.wasm</code>.</p>
-<h2>Experimental loaders<span><a class="mark" href="#esm_experimental_loaders" id="esm_experimental_loaders">#</a></span></h2>
+<p><i id="esm_experimental_top_level_await"></i></p>
+</section><section><h3>Top-level <code>await</code><span><a class="mark" href="#esm_top_level_await" id="esm_top_level_await">#</a></span></h3>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>The <code>await</code> keyword may be used in the top level (outside of async functions)
+within modules as per the <a href="https://github.com/tc39/proposal-top-level-await/">ECMAScript Top-Level <code>await</code> proposal</a>.</p>
+<p>Assuming an <code>a.mjs</code> with</p>
+<!-- eslint-skip -->
+<pre><code class="language-js"><span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> five = <span class="hljs-keyword">await</span> <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">5</span>);</code></pre>
+<p>And a <code>b.mjs</code> with</p>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> { five } <span class="hljs-keyword">from</span> <span class="hljs-string">'./a.mjs'</span>;
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(five); <span class="hljs-comment">// Logs `5`</span></code></pre>
+<pre><code class="language-bash">node b.mjs <span class="hljs-comment"># works</span></code></pre>
+<p><i id="esm_experimental_loaders"></i></p>
+</section><section><h3>Loaders<span><a class="mark" href="#esm_loaders" id="esm_loaders">#</a></span></h3>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p><strong>Note: This API is currently being redesigned and will still change.</strong></p>
 
 <p>To customize the default module resolution, loader hooks can optionally be
 provided via a <code>--experimental-loader ./loader-name.mjs</code> argument to Node.js.</p>
 <p>When hooks are used they only apply to ES module loading and not to any
 CommonJS modules loaded.</p>
-<h3>Hooks<span><a class="mark" href="#esm_hooks" id="esm_hooks">#</a></span></h3>
-<h4><code>resolve(specifier, context, defaultResolve)</code><span><a class="mark" href="#esm_resolve_specifier_context_defaultresolve" id="esm_resolve_specifier_context_defaultresolve">#</a></span></h4>
+<h4>Hooks<span><a class="mark" href="#esm_hooks" id="esm_hooks">#</a></span></h4>
+<h5><code>resolve(specifier, context, defaultResolve)</code><span><a class="mark" href="#esm_resolve_specifier_context_defaultresolve" id="esm_resolve_specifier_context_defaultresolve">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -580,37 +647,37 @@ Node.js module specifier resolution behavior</em> when calling <code>defaultReso
 <code>context.conditions</code> array passed to it <em>must</em> include <em>all</em> elements of the
 <code>context.conditions</code> array originally passed into the <code>resolve</code> hook.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{string}</span> <span class="hljs-variable">specifier</span></span>
- * <span class="hljs-doctag">@param <span class="hljs-type">{{
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">string</span>} <span class="hljs-variable">specifier</span>
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">{
  *   conditions: !Array&#x3C;string>,
  *   parentURL: !(string | undefined),
- * }</span></span>} context
- * <span class="hljs-doctag">@param <span class="hljs-type">{Function}</span> <span class="hljs-variable">defaultResolve</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{Promise&#x3C;{ url: string }</span></span>>}
+ * </span>}} context
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Function</span>} <span class="hljs-variable">defaultResolve</span>
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">Promise&#x3C;{ url: string </span>}>}
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) {
   <span class="hljs-keyword">const</span> { parentURL = <span class="hljs-literal">null</span> } = context;
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
     <span class="hljs-comment">// For some or all specifiers, do some custom logic for resolving.</span>
     <span class="hljs-comment">// Always return an object of the form {url: &#x3C;string>}.</span>
     <span class="hljs-keyword">return</span> {
       <span class="hljs-attr">url</span>: parentURL ?
-        <span class="hljs-keyword">new</span> URL(specifier, parentURL).href :
-        <span class="hljs-keyword">new</span> URL(specifier).href,
+        <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(specifier, parentURL).<span class="hljs-property">href</span> :
+        <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(specifier).<span class="hljs-property">href</span>,
     };
   }
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() &#x3C; <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Another condition.</span>
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() &#x3C; <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Another condition.</span>
     <span class="hljs-comment">// When calling `defaultResolve`, the arguments can be modified. In this</span>
     <span class="hljs-comment">// case it's adding another value for matching conditional exports.</span>
-    <span class="hljs-keyword">return</span> defaultResolve(specifier, {
+    <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultResolve</span>(specifier, {
       ...context,
-      <span class="hljs-attr">conditions</span>: [...context.conditions, <span class="hljs-string">'another-condition'</span>],
+      <span class="hljs-attr">conditions</span>: [...context.<span class="hljs-property">conditions</span>, <span class="hljs-string">'another-condition'</span>],
     });
   }
   <span class="hljs-comment">// Defer to Node.js for all other specifiers.</span>
-  <span class="hljs-keyword">return</span> defaultResolve(specifier, context, defaultResolve);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultResolve</span>(specifier, context, defaultResolve);
 }</code></pre>
-<h4><code>getFormat(url, context, defaultGetFormat)</code><span><a class="mark" href="#esm_getformat_url_context_defaultgetformat" id="esm_getformat_url_context_defaultgetformat">#</a></span></h4>
+<h5><code>getFormat(url, context, defaultGetFormat)</code><span><a class="mark" href="#esm_getformat_url_context_defaultgetformat" id="esm_getformat_url_context_defaultgetformat">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -664,27 +731,22 @@ of the following:</p>
 
 
 
-
-
-
-
-
-<table><thead><tr><th><code>format</code></th><th>Description</th><th>Acceptable Types For <code>source</code> Returned by <code>getSource</code> or <code>transformSource</code></th></tr></thead><tbody><tr><td><code>'builtin'</code></td><td>Load a Node.js builtin module</td><td>Not applicable</td></tr><tr><td><code>'dynamic'</code></td><td>Use a <a href="#esm_code_dynamicinstantiate_code_hook">dynamic instantiate hook</a></td><td>Not applicable</td></tr><tr><td><code>'commonjs'</code></td><td>Load a Node.js CommonJS module</td><td>Not applicable</td></tr><tr><td><code>'json'</code></td><td>Load a JSON file</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"><code>string</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr><tr><td><code>'module'</code></td><td>Load an ES module</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"><code>string</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr><tr><td><code>'wasm'</code></td><td>Load a WebAssembly module</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr></tbody></table>
+<table><thead><tr><th><code>format</code></th><th>Description</th><th>Acceptable Types For <code>source</code> Returned by <code>getSource</code> or <code>transformSource</code></th></tr></thead><tbody><tr><td><code>'builtin'</code></td><td>Load a Node.js builtin module</td><td>Not applicable</td></tr><tr><td><code>'commonjs'</code></td><td>Load a Node.js CommonJS module</td><td>Not applicable</td></tr><tr><td><code>'json'</code></td><td>Load a JSON file</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"><code>string</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr><tr><td><code>'module'</code></td><td>Load an ES module</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"><code>string</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr><tr><td><code>'wasm'</code></td><td>Load a WebAssembly module</td><td>{ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> }</td></tr></tbody></table>
 <p>Note: These types all correspond to classes defined in ECMAScript.</p>
 <ul>
 <li>The specific <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> object is a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a>.</li>
 <li>The specific <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> object is a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a>.</li>
 </ul>
 <p>Note: If the source value of a text-based format (i.e., <code>'json'</code>, <code>'module'</code>) is
-not a string, it is converted to a string using <a href="util.md#util_class_util_textdecoder"><code>util.TextDecoder</code></a>.</p>
+not a string, it is converted to a string using <a href="util.html#util_class_util_textdecoder"><code>util.TextDecoder</code></a>.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{string}</span> <span class="hljs-variable">url</span></span>
- * <span class="hljs-doctag">@param <span class="hljs-type">{Object}</span> </span>context (currently empty)
- * <span class="hljs-doctag">@param <span class="hljs-type">{Function}</span> <span class="hljs-variable">defaultGetFormat</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{Promise&#x3C;{ format: string }</span></span>>}
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">string</span>} <span class="hljs-variable">url</span>
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Object</span>} context (currently empty)
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Function</span>} <span class="hljs-variable">defaultGetFormat</span>
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">Promise&#x3C;{ format: string </span>}>}
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) </span>{
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) {
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
     <span class="hljs-comment">// For some or all URLs, do some custom logic for determining format.</span>
     <span class="hljs-comment">// Always return an object of the form {format: &#x3C;string>}, where the</span>
     <span class="hljs-comment">// format is one of the strings in the preceding table.</span>
@@ -693,9 +755,9 @@ not a string, it is converted to a string using <a href="util.md#util_class_util
     };
   }
   <span class="hljs-comment">// Defer to Node.js for all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetFormat(url, context, defaultGetFormat);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetFormat</span>(url, context, defaultGetFormat);
 }</code></pre>
-<h4><code>getSource(url, context, defaultGetSource)</code><span><a class="mark" href="#esm_getsource_url_context_defaultgetsource" id="esm_getsource_url_context_defaultgetsource">#</a></span></h4>
+<h5><code>getSource(url, context, defaultGetSource)</code><span><a class="mark" href="#esm_getsource_url_context_defaultgetsource" id="esm_getsource_url_context_defaultgetsource">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -718,14 +780,14 @@ signature may change. Do not rely on the API described below.</p>
 the source code of an ES module specifier. This would allow a loader to
 potentially avoid reading files from disk.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{string}</span> <span class="hljs-variable">url</span></span>
- * <span class="hljs-doctag">@param <span class="hljs-type">{{ format: string }</span></span>} context
- * <span class="hljs-doctag">@param <span class="hljs-type">{Function}</span> <span class="hljs-variable">defaultGetSource</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) }</span></span>>}
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">string</span>} <span class="hljs-variable">url</span>
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">{ format: string </span>}} context
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Function</span>} <span class="hljs-variable">defaultGetSource</span>
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) </span>}>}
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getSource</span>(<span class="hljs-params">url, context, defaultGetSource</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getSource</span>(<span class="hljs-params">url, context, defaultGetSource</span>) {
   <span class="hljs-keyword">const</span> { format } = context;
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
     <span class="hljs-comment">// For some or all URLs, do some custom logic for retrieving the source.</span>
     <span class="hljs-comment">// Always return an object of the form {source: &#x3C;string|buffer>}.</span>
     <span class="hljs-keyword">return</span> {
@@ -733,10 +795,9 @@ potentially avoid reading files from disk.</p>
     };
   }
   <span class="hljs-comment">// Defer to Node.js for all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetSource(url, context, defaultGetSource);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetSource</span>(url, context, defaultGetSource);
 }</code></pre>
-<h4><code>transformSource(source, context, defaultTransformSource)</code><span><a class="mark" href="#esm_transformsource_source_context_defaulttransformsource" id="esm_transformsource_source_context_defaulttransformsource">#</a></span></h4>
-<pre><code class="language-console">NODE_OPTIONS='--experimental-loader ./custom-loader.mjs' node x.js</code></pre>
+<h5><code>transformSource(source, context, defaultTransformSource)</code><span><a class="mark" href="#esm_transformsource_source_context_defaulttransformsource" id="esm_transformsource_source_context_defaulttransformsource">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -762,17 +823,17 @@ done anything with it.</p>
 JavaScript, a resolve hook is also necessary in order to register any
 unknown-to-Node.js file extensions. See the <a href="#esm_transpiler_loader">transpiler loader example</a> below.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{!(string | SharedArrayBuffer | Uint8Array)}</span> <span class="hljs-variable">source</span></span>
- * <span class="hljs-doctag">@param <span class="hljs-type">{{
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">!(string | SharedArrayBuffer | Uint8Array)</span>} <span class="hljs-variable">source</span>
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">{
  *   format: string,
  *   url: string,
- * }</span></span>} context
- * <span class="hljs-doctag">@param <span class="hljs-type">{Function}</span> <span class="hljs-variable">defaultTransformSource</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) }</span></span>>}
+ * </span>}} context
+ * <span class="hljs-doctag">@param</span> {<span class="hljs-type">Function</span>} <span class="hljs-variable">defaultTransformSource</span>
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) </span>}>}
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">transformSource</span>(<span class="hljs-params">source, context, defaultTransformSource</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">transformSource</span>(<span class="hljs-params">source, context, defaultTransformSource</span>) {
   <span class="hljs-keyword">const</span> { url, format } = context;
-  <span class="hljs-keyword">if</span> (<span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
+  <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>) { <span class="hljs-comment">// Some condition.</span>
     <span class="hljs-comment">// For some or all URLs, do some custom logic for modifying the source.</span>
     <span class="hljs-comment">// Always return an object of the form {source: &#x3C;string|buffer>}.</span>
     <span class="hljs-keyword">return</span> {
@@ -780,9 +841,9 @@ unknown-to-Node.js file extensions. See the <a href="#esm_transpiler_loader">tra
     };
   }
   <span class="hljs-comment">// Defer to Node.js for all other sources.</span>
-  <span class="hljs-keyword">return</span> defaultTransformSource(source, context, defaultTransformSource);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultTransformSource</span>(source, context, defaultTransformSource);
 }</code></pre>
-<h4><code>getGlobalPreloadCode()</code><span><a class="mark" href="#esm_getglobalpreloadcode" id="esm_getglobalpreloadcode">#</a></span></h4>
+<h5><code>getGlobalPreloadCode()</code><span><a class="mark" href="#esm_getglobalpreloadcode" id="esm_getglobalpreloadcode">#</a></span></h5>
 <blockquote>
 <p>Note: The loaders API is being redesigned. This hook may disappear or its
 signature may change. Do not rely on the API described below.</p>
@@ -799,9 +860,9 @@ builtins like "fs": <code>getBuiltin(request: string)</code>.</p>
 <p>If the code needs more advanced <code>require</code> features, it has to construct
 its own <code>require</code> using  <code>module.createRequire()</code>.</p>
 <pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@returns <span class="hljs-type">{string}</span> </span>Code to run before application startup
+ * <span class="hljs-doctag">@returns</span> {<span class="hljs-type">string</span>} Code to run before application startup
  */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getGlobalPreloadCode</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getGlobalPreloadCode</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">return</span> <span class="hljs-string">`\
 globalThis.someInjectedProperty = 42;
 console.log('I just set some globals!');
@@ -812,37 +873,10 @@ const require = createRequire(process.cwd() + '/&#x3C;preload>');
 // [...]
 `</span>;
 }</code></pre>
-<h4><code>dynamicInstantiate</code> hook<span><a class="mark" href="#esm_code_dynamicinstantiate_code_hook" id="esm_code_dynamicinstantiate_code_hook">#</a></span></h4>
-<blockquote>
-<p>Note: The loaders API is being redesigned. This hook may disappear or its
-signature may change. Do not rely on the API described below.</p>
-</blockquote>
-<p>To create a custom dynamic module that doesn't correspond to one of the
-existing <code>format</code> interpretations, the <code>dynamicInstantiate</code> hook can be used.
-This hook is called only for modules that return <code>format: 'dynamic'</code> from
-the <code>getFormat</code> hook.</p>
-<pre><code class="language-js"><span class="hljs-comment">/**
- * <span class="hljs-doctag">@param <span class="hljs-type">{string}</span> <span class="hljs-variable">url</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{object}</span> <span class="hljs-variable">response</span></span>
- * <span class="hljs-doctag">@returns <span class="hljs-type">{array}</span> </span>response.exports
- * <span class="hljs-doctag">@returns <span class="hljs-type">{function}</span> </span>response.execute
- */</span>
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">dynamicInstantiate</span>(<span class="hljs-params">url</span>) </span>{
-  <span class="hljs-keyword">return</span> {
-    <span class="hljs-attr">exports</span>: [<span class="hljs-string">'customExportName'</span>],
-    <span class="hljs-attr">execute</span>: <span class="hljs-function">(<span class="hljs-params"><span class="hljs-built_in">exports</span></span>) =></span> {
-      <span class="hljs-comment">// Get and set functions provided for pre-allocated export names</span>
-      <span class="hljs-built_in">exports</span>.customExportName.set(<span class="hljs-string">'value'</span>);
-    }
-  };
-}</code></pre>
-<p>With the list of module exports provided upfront, the <code>execute</code> function will
-then be called at the exact point of module evaluation order for that module
-in the import tree.</p>
-<h3>Examples<span><a class="mark" href="#esm_examples" id="esm_examples">#</a></span></h3>
+<h4>Examples<span><a class="mark" href="#esm_examples" id="esm_examples">#</a></span></h4>
 <p>The various loader hooks can be used together to accomplish wide-ranging
 customizations of Node.js’ code loading and evaluation behaviors.</p>
-<h4>HTTPS loader<span><a class="mark" href="#esm_https_loader" id="esm_https_loader">#</a></span></h4>
+<h5>HTTPS loader<span><a class="mark" href="#esm_https_loader" id="esm_https_loader">#</a></span></h5>
 <p>In current Node.js, specifiers starting with <code>https://</code> are unsupported. The
 loader below registers hooks to enable rudimentary support for such specifiers.
 While this may seem like a significant improvement to Node.js core
@@ -852,63 +886,63 @@ and there is no security.</p>
 <pre><code class="language-js"><span class="hljs-comment">// https-loader.mjs</span>
 <span class="hljs-keyword">import</span> { get } <span class="hljs-keyword">from</span> <span class="hljs-string">'https'</span>;
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) {
   <span class="hljs-keyword">const</span> { parentURL = <span class="hljs-literal">null</span> } = context;
 
   <span class="hljs-comment">// Normally Node.js would error on specifiers starting with 'https://', so</span>
   <span class="hljs-comment">// this hook intercepts them and converts them into absolute URLs to be</span>
   <span class="hljs-comment">// passed along to the later hooks below.</span>
-  <span class="hljs-keyword">if</span> (specifier.startsWith(<span class="hljs-string">'https://'</span>)) {
+  <span class="hljs-keyword">if</span> (specifier.<span class="hljs-title function_">startsWith</span>(<span class="hljs-string">'https://'</span>)) {
     <span class="hljs-keyword">return</span> {
       <span class="hljs-attr">url</span>: specifier
     };
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (parentURL &#x26;&#x26; parentURL.startsWith(<span class="hljs-string">'https://'</span>)) {
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (parentURL &#x26;&#x26; parentURL.<span class="hljs-title function_">startsWith</span>(<span class="hljs-string">'https://'</span>)) {
     <span class="hljs-keyword">return</span> {
-      <span class="hljs-attr">url</span>: <span class="hljs-keyword">new</span> URL(specifier, parentURL).href
+      <span class="hljs-attr">url</span>: <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(specifier, parentURL).<span class="hljs-property">href</span>
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other specifiers.</span>
-  <span class="hljs-keyword">return</span> defaultResolve(specifier, context, defaultResolve);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultResolve</span>(specifier, context, defaultResolve);
 }
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) {
   <span class="hljs-comment">// This loader assumes all network-provided JavaScript is ES module code.</span>
-  <span class="hljs-keyword">if</span> (url.startsWith(<span class="hljs-string">'https://'</span>)) {
+  <span class="hljs-keyword">if</span> (url.<span class="hljs-title function_">startsWith</span>(<span class="hljs-string">'https://'</span>)) {
     <span class="hljs-keyword">return</span> {
       <span class="hljs-attr">format</span>: <span class="hljs-string">'module'</span>
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetFormat(url, context, defaultGetFormat);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetFormat</span>(url, context, defaultGetFormat);
 }
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getSource</span>(<span class="hljs-params">url, context, defaultGetSource</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getSource</span>(<span class="hljs-params">url, context, defaultGetSource</span>) {
   <span class="hljs-comment">// For JavaScript to be loaded over the network, we need to fetch and</span>
   <span class="hljs-comment">// return it.</span>
-  <span class="hljs-keyword">if</span> (url.startsWith(<span class="hljs-string">'https://'</span>)) {
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-      get(url, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-keyword">if</span> (url.<span class="hljs-title function_">startsWith</span>(<span class="hljs-string">'https://'</span>)) {
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+      <span class="hljs-title function_">get</span>(url, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
         <span class="hljs-keyword">let</span> data = <span class="hljs-string">''</span>;
-        res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> data += chunk);
-        res.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> resolve({ <span class="hljs-attr">source</span>: data }));
-      }).on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> reject(err));
+        res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> data += chunk);
+        res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> <span class="hljs-title function_">resolve</span>({ <span class="hljs-attr">source</span>: data }));
+      }).<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-title function_">reject</span>(err));
     });
   }
 
   <span class="hljs-comment">// Let Node.js handle all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetSource(url, context, defaultGetSource);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetSource</span>(url, context, defaultGetSource);
 }</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// main.mjs</span>
-<span class="hljs-keyword">import</span> { VERSION } <span class="hljs-keyword">from</span> <span class="hljs-string">'https://coffeescript.org/browser-compiler-modern/coffeescript.js'</span>;
+<span class="hljs-keyword">import</span> { <span class="hljs-variable constant_">VERSION</span> } <span class="hljs-keyword">from</span> <span class="hljs-string">'https://coffeescript.org/browser-compiler-modern/coffeescript.js'</span>;
 
-<span class="hljs-built_in">console</span>.log(VERSION);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable constant_">VERSION</span>);</code></pre>
 <p>With the preceding loader, running
 <code>node --experimental-loader ./https-loader.mjs ./main.mjs</code>
 prints the current version of CoffeeScript per the module at the URL in
 <code>main.mjs</code>.</p>
-<h4>Transpiler loader<span><a class="mark" href="#esm_transpiler_loader" id="esm_transpiler_loader">#</a></span></h4>
+<h5>Transpiler loader<span><a class="mark" href="#esm_transpiler_loader" id="esm_transpiler_loader">#</a></span></h5>
 <p>Sources that are in formats Node.js doesn’t understand can be converted into
 JavaScript using the <a href="#esm_transformsource_source_context_defaulttransformsource"><code>transformSource</code> hook</a>. Before that hook gets called,
 however, other hooks need to tell Node.js not to throw an error on unknown file
@@ -917,61 +951,61 @@ types; and to tell Node.js how to load this new file type.</p>
 Node.js; a transpiler loader should only be used for development and testing
 purposes.</p>
 <pre><code class="language-js"><span class="hljs-comment">// coffeescript-loader.mjs</span>
-<span class="hljs-keyword">import</span> { URL, pathToFileURL } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
-<span class="hljs-keyword">import</span> CoffeeScript <span class="hljs-keyword">from</span> <span class="hljs-string">'coffeescript'</span>;
+<span class="hljs-keyword">import</span> { <span class="hljs-variable constant_">URL</span>, pathToFileURL } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
+<span class="hljs-keyword">import</span> <span class="hljs-title class_">CoffeeScript</span> <span class="hljs-keyword">from</span> <span class="hljs-string">'coffeescript'</span>;
 
-<span class="hljs-keyword">const</span> baseURL = pathToFileURL(<span class="hljs-string">`<span class="hljs-subst">${process.cwd()}</span>/`</span>).href;
+<span class="hljs-keyword">const</span> baseURL = <span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">`<span class="hljs-subst">${process.cwd()}</span>/`</span>).<span class="hljs-property">href</span>;
 
 <span class="hljs-comment">// CoffeeScript files end in .coffee, .litcoffee or .coffee.md.</span>
 <span class="hljs-keyword">const</span> extensionsRegex = <span class="hljs-regexp">/\.coffee$|\.litcoffee$|\.coffee\.md$/</span>;
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">resolve</span>(<span class="hljs-params">specifier, context, defaultResolve</span>) {
   <span class="hljs-keyword">const</span> { parentURL = baseURL } = context;
 
   <span class="hljs-comment">// Node.js normally errors on unknown file extensions, so return a URL for</span>
   <span class="hljs-comment">// specifiers ending in the CoffeeScript file extensions.</span>
-  <span class="hljs-keyword">if</span> (extensionsRegex.test(specifier)) {
+  <span class="hljs-keyword">if</span> (extensionsRegex.<span class="hljs-title function_">test</span>(specifier)) {
     <span class="hljs-keyword">return</span> {
-      <span class="hljs-attr">url</span>: <span class="hljs-keyword">new</span> URL(specifier, parentURL).href
+      <span class="hljs-attr">url</span>: <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(specifier, parentURL).<span class="hljs-property">href</span>
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other specifiers.</span>
-  <span class="hljs-keyword">return</span> defaultResolve(specifier, context, defaultResolve);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultResolve</span>(specifier, context, defaultResolve);
 }
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">getFormat</span>(<span class="hljs-params">url, context, defaultGetFormat</span>) {
   <span class="hljs-comment">// Now that we patched resolve to let CoffeeScript URLs through, we need to</span>
   <span class="hljs-comment">// tell Node.js what format such URLs should be interpreted as. For the</span>
   <span class="hljs-comment">// purposes of this loader, all CoffeeScript URLs are ES modules.</span>
-  <span class="hljs-keyword">if</span> (extensionsRegex.test(url)) {
+  <span class="hljs-keyword">if</span> (extensionsRegex.<span class="hljs-title function_">test</span>(url)) {
     <span class="hljs-keyword">return</span> {
       <span class="hljs-attr">format</span>: <span class="hljs-string">'module'</span>
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other URLs.</span>
-  <span class="hljs-keyword">return</span> defaultGetFormat(url, context, defaultGetFormat);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultGetFormat</span>(url, context, defaultGetFormat);
 }
 
-<span class="hljs-keyword">export</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">transformSource</span>(<span class="hljs-params">source, context, defaultTransformSource</span>) </span>{
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">transformSource</span>(<span class="hljs-params">source, context, defaultTransformSource</span>) {
   <span class="hljs-keyword">const</span> { url, format } = context;
 
-  <span class="hljs-keyword">if</span> (extensionsRegex.test(url)) {
+  <span class="hljs-keyword">if</span> (extensionsRegex.<span class="hljs-title function_">test</span>(url)) {
     <span class="hljs-keyword">return</span> {
-      <span class="hljs-attr">source</span>: CoffeeScript.compile(source, { <span class="hljs-attr">bare</span>: <span class="hljs-literal">true</span> })
+      <span class="hljs-attr">source</span>: <span class="hljs-title class_">CoffeeScript</span>.<span class="hljs-title function_">compile</span>(source, { <span class="hljs-attr">bare</span>: <span class="hljs-literal">true</span> })
     };
   }
 
   <span class="hljs-comment">// Let Node.js handle all other sources.</span>
-  <span class="hljs-keyword">return</span> defaultTransformSource(source, context, defaultTransformSource);
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">defaultTransformSource</span>(source, context, defaultTransformSource);
 }</code></pre>
 <pre><code class="language-coffee"><span class="hljs-comment"># main.coffee</span>
 <span class="hljs-keyword">import</span> { scream } <span class="hljs-keyword">from</span> <span class="hljs-string">'./scream.coffee'</span>
-<span class="hljs-built_in">console</span>.log scream <span class="hljs-string">'hello, world'</span>
+console.log scream <span class="hljs-string">'hello, world'</span>
 
 <span class="hljs-keyword">import</span> { version } <span class="hljs-keyword">from</span> <span class="hljs-string">'process'</span>
-<span class="hljs-built_in">console</span>.log <span class="hljs-string">"Brought to you by Node.js version <span class="hljs-subst">#{version}</span>"</span></code></pre>
+console.log <span class="hljs-string">"Brought to you by Node.js version <span class="hljs-subst">#{version}</span>"</span></code></pre>
 <pre><code class="language-coffee"><span class="hljs-comment"># scream.coffee</span>
 <span class="hljs-keyword">export</span> scream = <span class="hljs-function"><span class="hljs-params">(str)</span> -></span> str.toUpperCase()</code></pre>
 <p>With the preceding loader, running
@@ -980,8 +1014,8 @@ causes <code>main.coffee</code> to be turned into JavaScript after its source co
 loaded from disk but before Node.js executes it; and so on for any <code>.coffee</code>,
 <code>.litcoffee</code> or <code>.coffee.md</code> files referenced via <code>import</code> statements of any
 loaded file.</p>
-<h2>Resolution algorithm<span><a class="mark" href="#esm_resolution_algorithm" id="esm_resolution_algorithm">#</a></span></h2>
-<h3>Features<span><a class="mark" href="#esm_features" id="esm_features">#</a></span></h3>
+</section><section><h3>Resolution algorithm<span><a class="mark" href="#esm_resolution_algorithm" id="esm_resolution_algorithm">#</a></span></h3>
+<h4>Features<span><a class="mark" href="#esm_features" id="esm_features">#</a></span></h4>
 <p>The resolver has the following properties:</p>
 <ul>
 <li>FileURL-based resolution as is used by ES modules</li>
@@ -991,7 +1025,7 @@ loaded file.</p>
 <li>No folder mains</li>
 <li>Bare specifier package resolution lookup through node_modules</li>
 </ul>
-<h3>Resolver algorithm<span><a class="mark" href="#esm_resolver_algorithm" id="esm_resolver_algorithm">#</a></span></h3>
+<h4>Resolver algorithm<span><a class="mark" href="#esm_resolver_algorithm" id="esm_resolver_algorithm">#</a></span></h4>
 <p>The algorithm to load an ES module specifier is given through the
 <strong>ESM_RESOLVE</strong> method below. It returns the resolved URL for a
 module specifier relative to a parentURL.</p>
@@ -1017,8 +1051,10 @@ for the package that is an invalid type or string target.</li>
 subpath in the package for the given module.</li>
 <li><em>Package Import Not Defined</em>: Package imports do not define the specifier.</li>
 <li><em>Module Not Found</em>: The package or module requested does not exist.</li>
+<li><em>Unsupported Directory Import</em>: The resolved path corresponds to a directory,
+which is not a supported target for module imports.</li>
 </ul>
-<h3>Resolver Algorithm Specification<span><a class="mark" href="#esm_resolver_algorithm_specification" id="esm_resolver_algorithm_specification">#</a></span></h3>
+<h4>Resolver Algorithm Specification<span><a class="mark" href="#esm_resolver_algorithm_specification" id="esm_resolver_algorithm_specification">#</a></span></h4>
 <p><strong>ESM_RESOLVE</strong>(<em>specifier</em>, <em>parentURL</em>)</p>
 <blockquote>
 <ol>
@@ -1459,7 +1495,8 @@ error.</li>
 <li>Return the parsed JSON source of the file at <em>pjsonURL</em>.</li>
 </ol>
 </blockquote>
-<h3>Customizing ESM specifier resolution algorithm<span><a class="mark" href="#esm_customizing_esm_specifier_resolution_algorithm" id="esm_customizing_esm_specifier_resolution_algorithm">#</a></span></h3>
+<h4>Customizing ESM specifier resolution algorithm<span><a class="mark" href="#esm_customizing_esm_specifier_resolution_algorithm" id="esm_customizing_esm_specifier_resolution_algorithm">#</a></span></h4>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <p>The current specifier resolution does not support all default behavior of
 the CommonJS loader. One of the behavior differences is automatic resolution
 of file extensions and the ability to import directories that have an index
@@ -1469,16 +1506,52 @@ the extension resolution algorithm. The default mode is <code>explicit</code>, w
 requires the full path to a module be provided to the loader. To enable the
 automatic extension resolution and importing from directories that include an
 index file use the <code>node</code> mode.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node index.mjs</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node index.mjs</span>
 success!
-<span class="hljs-meta">$</span><span class="bash"> node index <span class="hljs-comment"># Failure!</span></span>
+<span class="hljs-meta">$ </span><span class="language-bash">node index <span class="hljs-comment"># Failure!</span></span>
 Error: Cannot find module
-<span class="hljs-meta">$</span><span class="bash"> node --experimental-specifier-resolution=node index</span>
+<span class="hljs-meta">$ </span><span class="language-bash">node --experimental-specifier-resolution=node index</span>
 success!</code></pre>
-<!-- Note: The cjs-module-lexer link should be kept in-sync with the deps version -->
+<!-- Note: The cjs-module-lexer link should be kept in-sync with the deps version --></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/esm.json b/doc/api/esm.json
index 29fedcf2b046e8bac61aac870fbbd23cc5f2fced..669935ca1fc91333ee313dcf6c93fd11f4e7827c 100644
--- a/doc/api/esm.json
+++ b/doc/api/esm.json
@@ -9,25 +9,34 @@
     "changes": [
       {
         "version": [
-          "v12.22.0"
+          "v14.17.0"
         ],
         "pr-url": "https://github.com/nodejs/node/pull/35781",
         "description": "Stabilize modules implementation."
       },
       {
         "version": [
-          "v12.20.0"
+          "v14.13.0"
         ],
         "pr-url": "https://github.com/nodejs/node/pull/35249",
         "description": "Support for detection of CommonJS named exports."
       },
       {
-        "version": "v12.20.0",
+        "version": "v14.8.0",
+        "pr-url": "https://github.com/nodejs/node/pull/34558",
+        "description": "Unflag Top-Level Await."
+      },
+      {
+        "version": [
+          "v14.0.0",
+          "v13.14.0"
+        ],
         "pr-url": "https://github.com/nodejs/node/pull/31974",
         "description": "Remove experimental modules warning."
       },
       {
         "version": [
+          "v13.2.0",
           "v12.17.0"
         ],
         "pr-url": "https://github.com/nodejs/node/pull/29866",
@@ -47,7 +56,29 @@
       "textRaw": "`meta` {Object}",
       "type": "Object",
       "name": "meta",
-      "desc": "<p>The <code>import.meta</code> metaproperty is an <code>Object</code> that contains the following\nproperty:</p>\n<ul>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The absolute <code>file:</code> URL of the module.</li>\n</ul>"
+      "desc": "<p>The <code>import.meta</code> meta property is an <code>Object</code> that contains the following\nproperties.</p>",
+      "properties": [
+        {
+          "textRaw": "`url` {string} The absolute `file:` URL of the module.",
+          "type": "string",
+          "name": "url",
+          "desc": "<p>This is defined exactly the same as it is in browsers providing the URL of the\ncurrent module file.</p>\n<p>This enables useful patterns such as relative file loading:</p>\n<pre><code class=\"language-js\">import { readFileSync } from 'fs';\nconst buffer = readFileSync(new URL('./data.proto', import.meta.url));\n</code></pre>",
+          "shortDesc": "The absolute `file:` URL of the module."
+        }
+      ],
+      "methods": [
+        {
+          "textRaw": "`import.meta.resolve(specifier[, parent])`",
+          "type": "method",
+          "name": "resolve",
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<!--\nadded:\n  - v13.9.0\n  - v12.16.2\nchanges:\n  - version: v14.18.0\n    pr-url: https://github.com/nodejs/node/pull/38587\n    description: Add support for WHATWG `URL` object to `parentURL` parameter.\n-->\n<blockquote>\n<p>Stability: 1 - Experimental</p>\n</blockquote>\n<p>This feature is only available with the <code>--experimental-import-meta-resolve</code>\ncommand flag enabled.</p>\n<ul>\n<li><code>specifier</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The module specifier to resolve relative to <code>parent</code>.</li>\n<li><code>parent</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The absolute parent module URL to resolve from. If none\nis specified, the value of <code>import.meta.url</code> is used as the default.</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise\" class=\"type\">&lt;Promise&gt;</a></li>\n</ul>\n<p>Provides a module-relative resolution function scoped to each module, returning\nthe URL string.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">const dependencyAsset = await import.meta.resolve('component-lib/asset.css');\n</code></pre>\n<p><code>import.meta.resolve</code> also accepts a second argument which is the parent module\nfrom which to resolve from:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">await import.meta.resolve('./dep', import.meta.url);\n</code></pre>\n<p>This function is asynchronous because the ES module resolver in Node.js is\nallowed to be asynchronous.</p>"
+        }
+      ]
     }
   ],
   "miscs": [
@@ -63,25 +94,34 @@
         "changes": [
           {
             "version": [
-              "v12.22.0"
+              "v14.17.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/35781",
             "description": "Stabilize modules implementation."
           },
           {
             "version": [
-              "v12.20.0"
+              "v14.13.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/35249",
             "description": "Support for detection of CommonJS named exports."
           },
           {
-            "version": "v12.20.0",
+            "version": "v14.8.0",
+            "pr-url": "https://github.com/nodejs/node/pull/34558",
+            "description": "Unflag Top-Level Await."
+          },
+          {
+            "version": [
+              "v14.0.0",
+              "v13.14.0"
+            ],
             "pr-url": "https://github.com/nodejs/node/pull/31974",
             "description": "Remove experimental modules warning."
           },
           {
             "version": [
+              "v13.2.0",
               "v12.17.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/29866",
@@ -100,7 +140,7 @@
         {
           "textRaw": "Introduction",
           "name": "esm",
-          "desc": "<p>ECMAScript modules are <a href=\"https://tc39.github.io/ecma262/#sec-modules\">the official standard format</a> to package JavaScript\ncode for reuse. Modules are defined using a variety of <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import\"><code>import</code></a> and\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export\"><code>export</code></a> statements.</p>\n<p>The following example of an ES module exports a function:</p>\n<pre><code class=\"language-js\">// addTwo.mjs\nfunction addTwo(num) {\n  return num + 2;\n}\n\nexport { addTwo };\n</code></pre>\n<p>The following example of an ES module imports the function from <code>addTwo.mjs</code>:</p>\n<pre><code class=\"language-js\">// app.mjs\nimport { addTwo } from './addTwo.mjs';\n\n// Prints: 6\nconsole.log(addTwo(4));\n</code></pre>\n<p>Node.js fully supports ECMAScript modules as they are currently specified and\nprovides interoperability between them and its original module format,\n<a href=\"modules.html\">CommonJS</a>.</p>\n<!-- Anchors to make sure old links find a target -->\n<p><i id=\"#esm_package_json_type_field\"></i>\n<i id=\"#esm_package_scope_and_file_extensions\"></i>\n<i id=\"#esm_input_type_flag\"></i></p>",
+          "desc": "<p>ECMAScript modules are <a href=\"https://tc39.github.io/ecma262/#sec-modules\">the official standard format</a> to package JavaScript\ncode for reuse. Modules are defined using a variety of <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import\"><code>import</code></a> and\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export\"><code>export</code></a> statements.</p>\n<p>The following example of an ES module exports a function:</p>\n<pre><code class=\"language-js\">// addTwo.mjs\nfunction addTwo(num) {\n  return num + 2;\n}\n\nexport { addTwo };\n</code></pre>\n<p>The following example of an ES module imports the function from <code>addTwo.mjs</code>:</p>\n<pre><code class=\"language-js\">// app.mjs\nimport { addTwo } from './addTwo.mjs';\n\n// Prints: 6\nconsole.log(addTwo(4));\n</code></pre>\n<p>Node.js fully supports ECMAScript modules as they are currently specified and\nprovides interoperability between them and its original module format,\n<a href=\"modules.html\">CommonJS</a>.</p>\n<!-- Anchors to make sure old links find a target -->\n<p><i id=\"esm_package_json_type_field\"></i>\n<i id=\"esm_package_scope_and_file_extensions\"></i>\n<i id=\"esm_input_type_flag\"></i></p>",
           "type": "misc",
           "displayName": "esm"
         },
@@ -124,20 +164,28 @@
             {
               "textRaw": "Terminology",
               "name": "terminology",
-              "desc": "<p>The <em>specifier</em> of an <code>import</code> statement is the string after the <code>from</code> keyword,\ne.g. <code>'path'</code> in <code>import { sep } from 'path'</code>. Specifiers are also used in\n<code>export from</code> statements, and as the argument to an <code>import()</code> expression.</p>\n<p>There are four types of specifiers:</p>\n<ul>\n<li>\n<p><em>Bare specifiers</em> like <code>'some-package'</code>. They refer to an entry point of a\npackage by the package name.</p>\n</li>\n<li>\n<p><em>Deep import specifiers</em> like <code>'some-package/lib/shuffle.mjs'</code>. They refer to\na path within a package prefixed by the package name.</p>\n</li>\n<li>\n<p><em>Relative specifiers</em> like <code>'./startup.js'</code> or <code>'../config.mjs'</code>. They refer\nto a path relative to the location of the importing file.</p>\n</li>\n<li>\n<p><em>Absolute specifiers</em> like <code>'file:///opt/nodejs/config.js'</code>. They refer\ndirectly and explicitly to a full path.</p>\n</li>\n</ul>\n<p>Bare specifiers, and the bare specifier portion of deep import specifiers, are\nstrings; but everything else in a specifier is a URL.</p>\n<p><code>file:</code>, <code>node:</code>, and <code>data:</code> URLs are supported. A specifier like\n<code>'https://example.com/app.js'</code> may be supported by browsers but it is not\nsupported in Node.js.</p>\n<p>Specifiers may not begin with <code>/</code> or <code>//</code>. These are reserved for potential\nfuture use. The root of the current volume may be referenced via <code>file:///</code>.</p>",
+              "desc": "<p>The <em>specifier</em> of an <code>import</code> statement is the string after the <code>from</code> keyword,\ne.g. <code>'path'</code> in <code>import { sep } from 'path'</code>. Specifiers are also used in\n<code>export from</code> statements, and as the argument to an <code>import()</code> expression.</p>\n<p>There are three types of specifiers:</p>\n<ul>\n<li>\n<p><em>Relative specifiers</em> like <code>'./startup.js'</code> or <code>'../config.mjs'</code>. They refer\nto a path relative to the location of the importing file. <em>The file extension\nis always necessary for these.</em></p>\n</li>\n<li>\n<p><em>Bare specifiers</em> like <code>'some-package'</code> or <code>'some-package/shuffle'</code>. They can\nrefer to the main entry point of a package by the package name, or a\nspecific feature module within a package prefixed by the package name as per\nthe examples respectively. <em>Including the file extension is only necessary\nfor packages without an <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field.</em></p>\n</li>\n<li>\n<p><em>Absolute specifiers</em> like <code>'file:///opt/nodejs/config.js'</code>. They refer\ndirectly and explicitly to a full path.</p>\n</li>\n</ul>\n<p>Bare specifier resolutions are handled by the <a href=\"#esm_resolver_algorithm_specification\">Node.js module resolution\nalgorithm</a>. All other specifier resolutions are always only resolved with\nthe standard relative <a href=\"https://url.spec.whatwg.org/\">URL</a> resolution semantics.</p>\n<p>Like in CommonJS, module files within packages can be accessed by appending a\npath to the package name unless the package’s <a href=\"packages.html#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> contains an\n<a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field, in which case files within packages can only be accessed\nvia the paths defined in <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a>.</p>\n<p>For details on these package resolution rules that apply to bare specifiers in\nthe Node.js module resolution, see the <a href=\"packages.html\">packages documentation</a>.</p>",
+              "type": "module",
+              "displayName": "Terminology"
+            },
+            {
+              "textRaw": "Mandatory file extensions",
+              "name": "mandatory_file_extensions",
+              "desc": "<p>A file extension must be provided when using the <code>import</code> keyword to resolve\nrelative or absolute specifiers. Directory indexes (e.g. <code>'./startup/index.js'</code>)\nmust also be fully specified.</p>\n<p>This behavior matches how <code>import</code> behaves in browser environments, assuming a\ntypically configured server.</p>",
+              "type": "module",
+              "displayName": "Mandatory file extensions"
+            },
+            {
+              "textRaw": "URLs",
+              "name": "urls",
+              "desc": "<p>ES modules are resolved and cached as URLs. This means that files containing\nspecial characters such as <code>#</code> and <code>?</code> need to be escaped.</p>\n<p><code>file:</code>, <code>node:</code>, and <code>data:</code> URL schemes are supported. A specifier like\n<code>'https://example.com/app.js'</code> is not supported natively in Node.js unless using\na <a href=\"#esm_https_loader\">custom HTTPS loader</a>.</p>",
               "modules": [
                 {
-                  "textRaw": "`node:` Imports",
-                  "name": "`node:`_imports",
-                  "meta": {
-                    "added": [
-                      "v12.20.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p><code>node:</code> URLs are supported as a means to load Node.js builtin modules. This\nURL scheme allows for builtin modules to be referenced by valid absolute URL\nstrings.</p>\n<pre><code class=\"language-js\">import fs from 'node:fs/promises';\n</code></pre>",
+                  "textRaw": "`file:` URLs",
+                  "name": "`file:`_urls",
+                  "desc": "<p>Modules are loaded multiple times if the <code>import</code> specifier used to resolve\nthem has a different query or fragment.</p>\n<pre><code class=\"language-js\">import './foo.mjs?query=1'; // loads ./foo.mjs with query of \"?query=1\"\nimport './foo.mjs?query=2'; // loads ./foo.mjs with query of \"?query=2\"\n</code></pre>\n<p>The volume root may be referenced via <code>/</code>, <code>//</code> or <code>file:///</code>. Given the\ndifferences between <a href=\"https://url.spec.whatwg.org/\">URL</a> and path resolution (such as percent encoding\ndetails), it is recommended to use <a href=\"url.html#url_url_pathtofileurl_path\">url.pathToFileURL</a> when importing a path.</p>",
                   "type": "module",
-                  "displayName": "`node:` Imports"
+                  "displayName": "`file:` URLs"
                 },
                 {
                   "textRaw": "`data:` Imports",
@@ -151,139 +199,174 @@
                   "desc": "<p><a href=\"https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs\"><code>data:</code> URLs</a> are supported for importing with the following MIME types:</p>\n<ul>\n<li><code>text/javascript</code> for ES Modules</li>\n<li><code>application/json</code> for JSON</li>\n<li><code>application/wasm</code> for Wasm</li>\n</ul>\n<p><code>data:</code> URLs only resolve <a href=\"#esm_terminology\"><em>Bare specifiers</em></a> for builtin modules\nand <a href=\"#esm_terminology\"><em>Absolute specifiers</em></a>. Resolving\n<a href=\"#esm_terminology\"><em>Relative specifiers</em></a> does not work because <code>data:</code> is not a\n<a href=\"https://url.spec.whatwg.org/#special-scheme\">special scheme</a>. For example, attempting to load <code>./foo</code>\nfrom <code>data:text/javascript,import \"./foo\";</code> fails to resolve because there\nis no concept of relative resolution for <code>data:</code> URLs. An example of a <code>data:</code>\nURLs being used is:</p>\n<pre><code class=\"language-js\">import 'data:text/javascript,console.log(\"hello!\");';\nimport _ from 'data:application/json,\"world!\"';\n</code></pre>",
                   "type": "module",
                   "displayName": "`data:` Imports"
+                },
+                {
+                  "textRaw": "`node:` Imports",
+                  "name": "`node:`_imports",
+                  "meta": {
+                    "added": [
+                      "v14.13.1",
+                      "v12.20.0"
+                    ],
+                    "changes": [
+                      {
+                        "version": "v14.18.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/37246",
+                        "description": "Added `node:` import support to `require(...)`."
+                      }
+                    ]
+                  },
+                  "desc": "<p><code>node:</code> URLs are supported as an alternative means to load Node.js builtin\nmodules. This URL scheme allows for builtin modules to be referenced by valid\nabsolute URL strings.</p>\n<pre><code class=\"language-js\">import fs from 'node:fs/promises';\n</code></pre>",
+                  "type": "module",
+                  "displayName": "`node:` Imports"
                 }
               ],
               "type": "module",
-              "displayName": "Terminology"
+              "displayName": "URLs"
             }
           ],
           "type": "misc",
           "displayName": "`import` Specifiers"
         },
         {
-          "textRaw": "Differences between ES modules and CommonJS",
-          "name": "differences_between_es_modules_and_commonjs",
-          "modules": [
-            {
-              "textRaw": "Mandatory file extensions",
-              "name": "mandatory_file_extensions",
-              "desc": "<p>A file extension must be provided when using the <code>import</code> keyword. Directory\nindexes (e.g. <code>'./startup/index.js'</code>) must also be fully specified.</p>\n<p>This behavior matches how <code>import</code> behaves in browser environments, assuming a\ntypically configured server.</p>",
-              "type": "module",
-              "displayName": "Mandatory file extensions"
-            },
-            {
-              "textRaw": "No `NODE_PATH`",
-              "name": "no_`node_path`",
-              "desc": "<p><code>NODE_PATH</code> is not part of resolving <code>import</code> specifiers. Please use symlinks\nif this behavior is desired.</p>",
-              "type": "module",
-              "displayName": "No `NODE_PATH`"
-            },
-            {
-              "textRaw": "No `require`, `exports`, `module.exports`, `__filename`, `__dirname`",
-              "name": "no_`require`,_`exports`,_`module.exports`,_`__filename`,_`__dirname`",
-              "desc": "<p>These CommonJS variables are not available in ES modules.</p>\n<p><code>require</code> can be imported into an ES module using <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>\n<p>Equivalents of <code>__filename</code> and <code>__dirname</code> can be created inside of each file\nvia <a href=\"#esm_import_meta\"><code>import.meta.url</code></a>.</p>\n<pre><code class=\"language-js\">import { fileURLToPath } from 'url';\nimport { dirname } from 'path';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n</code></pre>",
-              "type": "module",
-              "displayName": "No `require`, `exports`, `module.exports`, `__filename`, `__dirname`"
-            },
-            {
-              "textRaw": "No `require.resolve`",
-              "name": "no_`require.resolve`",
-              "desc": "<p>Former use cases relying on <code>require.resolve</code> to determine the resolved path\nof a module can be supported via <code>import.meta.resolve</code>, which is experimental\nand supported via the <code>--experimental-import-meta-resolve</code> flag:</p>\n<pre><code class=\"language-js\">(async () => {\n  const dependencyAsset = await import.meta.resolve('component-lib/asset.css');\n})();\n</code></pre>\n<p><code>import.meta.resolve</code> also accepts a second argument which is the parent module\nfrom which to resolve from:</p>\n<pre><code class=\"language-js\">(async () => {\n  // Equivalent to import.meta.resolve('./dep')\n  await import.meta.resolve('./dep', import.meta.url);\n})();\n</code></pre>\n<p>This function is asynchronous because the ES module resolver in Node.js is\nasynchronous. With the introduction of <a href=\"https://github.com/tc39/proposal-top-level-await\">Top-Level Await</a>, these use cases\nwill be easier as they won't require an async function wrapper.</p>",
-              "type": "module",
-              "displayName": "No `require.resolve`"
-            },
-            {
-              "textRaw": "No `require.extensions`",
-              "name": "no_`require.extensions`",
-              "desc": "<p><code>require.extensions</code> is not used by <code>import</code>. The expectation is that loader\nhooks can provide this workflow in the future.</p>",
-              "type": "module",
-              "displayName": "No `require.extensions`"
-            },
-            {
-              "textRaw": "No `require.cache`",
-              "name": "no_`require.cache`",
-              "desc": "<p><code>require.cache</code> is not used by <code>import</code>. It has a separate cache.</p>",
-              "type": "module",
-              "displayName": "No `require.cache`"
-            },
-            {
-              "textRaw": "URL-based paths",
-              "name": "url-based_paths",
-              "desc": "<p>ES modules are resolved and cached based upon\n<a href=\"https://url.spec.whatwg.org/\">URL</a> semantics. This means that files containing\nspecial characters such as <code>#</code> and <code>?</code> need to be escaped.</p>\n<p>Modules are loaded multiple times if the <code>import</code> specifier used to resolve\nthem has a different query or fragment.</p>\n<pre><code class=\"language-js\">import './foo.mjs?query=1'; // loads ./foo.mjs with query of \"?query=1\"\nimport './foo.mjs?query=2'; // loads ./foo.mjs with query of \"?query=2\"\n</code></pre>\n<p>For now, only modules using the <code>file:</code> protocol can be loaded.</p>",
-              "type": "module",
-              "displayName": "URL-based paths"
-            }
-          ],
+          "textRaw": "Builtin modules",
+          "name": "builtin_modules",
+          "desc": "<p><a href=\"modules.html#modules_core_modules\">Core modules</a> provide named exports of their public API. A\ndefault export is also provided which is the value of the CommonJS exports.\nThe default export can be used for, among other things, modifying the named\nexports. Named exports of builtin modules are updated only by calling\n<a href=\"module.html#module_module_syncbuiltinesmexports\"><code>module.syncBuiltinESMExports()</code></a>.</p>\n<pre><code class=\"language-js\">import EventEmitter from 'events';\nconst e = new EventEmitter();\n</code></pre>\n<pre><code class=\"language-js\">import { readFile } from 'fs';\nreadFile('./foo.txt', (err, source) => {\n  if (err) {\n    console.error(err);\n  } else {\n    console.log(source);\n  }\n});\n</code></pre>\n<pre><code class=\"language-js\">import fs, { readFileSync } from 'fs';\nimport { syncBuiltinESMExports } from 'module';\n\nfs.readFileSync = () => Buffer.from('Hello, ESM');\nsyncBuiltinESMExports();\n\nfs.readFileSync === readFileSync;\n</code></pre>",
+          "type": "misc",
+          "displayName": "Builtin modules"
+        },
+        {
+          "textRaw": "`import()` expressions",
+          "name": "`import()`_expressions",
+          "desc": "<p><a href=\"https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports\">Dynamic <code>import()</code></a> is supported in both CommonJS and ES modules. In CommonJS\nmodules it can be used to load ES modules.</p>",
           "type": "misc",
-          "displayName": "Differences between ES modules and CommonJS"
+          "displayName": "`import()` expressions"
         },
         {
           "textRaw": "Interoperability with CommonJS",
           "name": "interoperability_with_commonjs",
           "modules": [
+            {
+              "textRaw": "`import` statements",
+              "name": "`import`_statements",
+              "desc": "<p>An <code>import</code> statement can reference an ES module or a CommonJS module.\n<code>import</code> statements are permitted only in ES modules, but dynamic <a href=\"#esm_import_expressions\"><code>import()</code></a>\nexpressions are supported in CommonJS for loading ES modules.</p>\n<p>When importing <a href=\"#esm_commonjs_namespaces\">CommonJS modules</a>, the\n<code>module.exports</code> object is provided as the default export. Named exports may be\navailable, provided by static analysis as a convenience for better ecosystem\ncompatibility.</p>",
+              "type": "module",
+              "displayName": "`import` statements"
+            },
             {
               "textRaw": "`require`",
               "name": "`require`",
-              "desc": "<p><code>require</code> always treats the files it references as CommonJS. This applies\nwhether <code>require</code> is used the traditional way within a CommonJS environment, or\nin an ES module environment using <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>\n<p>To include an ES module into CommonJS, use <a href=\"#esm_import_expressions\"><code>import()</code></a>.</p>",
+              "desc": "<p>The CommonJS module <code>require</code> always treats the files it references as CommonJS.</p>\n<p>Using <code>require</code> to load an ES module is not supported because ES modules have\nasynchronous execution. Instead, use <a href=\"#esm_import_expressions\"><code>import()</code></a> to load an ES module\nfrom a CommonJS module.</p>",
               "type": "module",
               "displayName": "`require`"
             },
             {
-              "textRaw": "`import` statements",
-              "name": "`import`_statements",
-              "desc": "<p>An <code>import</code> statement can reference an ES module or a CommonJS module.\n<code>import</code> statements are permitted only in ES modules. For similar functionality\nin CommonJS, see <a href=\"#esm_import_expressions\"><code>import()</code></a>.</p>\n<p>When importing <a href=\"#esm_commonjs_namespaces\">CommonJS modules</a>, the\n<code>module.exports</code> object is provided as the default export. Named exports may be\navailable, provided by static analysis as a convenience for better ecosystem\ncompatibility.</p>\n<p>Additional experimental flags are available for importing\n<a href=\"#esm_experimental_wasm_modules\">Wasm modules</a> or\n<a href=\"#esm_experimental_json_modules\">JSON modules</a>. For importing native modules or\nJSON modules unflagged, see <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>\n<p>The <em>specifier</em> of an <code>import</code> statement (the string after the <code>from</code> keyword)\ncan either be an URL-style relative path like <code>'./file.mjs'</code> or a package name\nlike <code>'fs'</code>.</p>\n<p>Like in CommonJS, files within packages can be accessed by appending a path to\nthe package name; unless the package’s <a href=\"packages.html#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> contains an\n<a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a> field, in which case files within packages need to be accessed\nvia the path defined in <a href=\"packages.html#packages_exports\"><code>\"exports\"</code></a>.</p>\n<pre><code class=\"language-js\">import { sin, cos } from 'geometry/trigonometry-functions.mjs';\n</code></pre>",
+              "textRaw": "CommonJS Namespaces",
+              "name": "commonjs_namespaces",
+              "desc": "<p>CommonJS modules consist of a <code>module.exports</code> object which can be of any type.</p>\n<p>When importing a CommonJS module, it can be reliably imported using the ES\nmodule default import or its corresponding sugar syntax:</p>\n<!-- eslint-disable no-duplicate-imports -->\n<pre><code class=\"language-js\">import { default as cjs } from 'cjs';\n\n// The following import statement is \"syntax sugar\" (equivalent but sweeter)\n// for `{ default as cjsSugar }` in the above import statement:\nimport cjsSugar from 'cjs';\n\nconsole.log(cjs);\nconsole.log(cjs === cjsSugar);\n// Prints:\n//   &#x3C;module.exports>\n//   true\n</code></pre>\n<p>The ECMAScript Module Namespace representation of a CommonJS module is always\na namespace with a <code>default</code> export key pointing to the CommonJS\n<code>module.exports</code> value.</p>\n<p>This Module Namespace Exotic Object can be directly observed either when using\n<code>import * as m from 'cjs'</code> or a dynamic import:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import * as m from 'cjs';\nconsole.log(m);\nconsole.log(m === await import('cjs'));\n// Prints:\n//   [Module] { default: &#x3C;module.exports> }\n//   true\n</code></pre>\n<p>For better compatibility with existing usage in the JS ecosystem, Node.js\nin addition attempts to determine the CommonJS named exports of every imported\nCommonJS module to provide them as separate ES module exports using a static\nanalysis process.</p>\n<p>For example, consider a CommonJS module written:</p>\n<pre><code class=\"language-cjs\">// cjs.cjs\nexports.name = 'exported';\n</code></pre>\n<p>The preceding module supports named imports in ES modules:</p>\n<!-- eslint-disable no-duplicate-imports -->\n<pre><code class=\"language-js\">import { name } from './cjs.cjs';\nconsole.log(name);\n// Prints: 'exported'\n\nimport cjs from './cjs.cjs';\nconsole.log(cjs);\n// Prints: { name: 'exported' }\n\nimport * as m from './cjs.cjs';\nconsole.log(m);\n// Prints: [Module] { default: { name: 'exported' }, name: 'exported' }\n</code></pre>\n<p>As can be seen from the last example of the Module Namespace Exotic Object being\nlogged, the <code>name</code> export is copied off of the <code>module.exports</code> object and set\ndirectly on the ES module namespace when the module is imported.</p>\n<p>Live binding updates or new exports added to <code>module.exports</code> are not detected\nfor these named exports.</p>\n<p>The detection of named exports is based on common syntax patterns but does not\nalways correctly detect named exports. In these cases, using the default\nimport form described above can be a better option.</p>\n<p>Named exports detection covers many common export patterns, reexport patterns\nand build tool and transpiler outputs. See <a href=\"https://github.com/guybedford/cjs-module-lexer/tree/1.2.2\">cjs-module-lexer</a> for the exact\nsemantics implemented.</p>",
               "type": "module",
-              "displayName": "`import` statements"
+              "displayName": "CommonJS Namespaces"
             },
             {
-              "textRaw": "`import()` expressions",
-              "name": "`import()`_expressions",
-              "desc": "<p><a href=\"https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports\">Dynamic <code>import()</code></a> is supported in both CommonJS and ES modules. It can be\nused to include ES module files from CommonJS code.</p>",
+              "textRaw": "Differences between ES modules and CommonJS",
+              "name": "differences_between_es_modules_and_commonjs",
+              "modules": [
+                {
+                  "textRaw": "No `require`, `exports` or `module.exports`",
+                  "name": "no_`require`,_`exports`_or_`module.exports`",
+                  "desc": "<p>In most cases, the ES module <code>import</code> can be used to load CommonJS modules.</p>\n<p>If needed, a <code>require</code> function can be constructed within an ES module using\n<a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>",
+                  "type": "module",
+                  "displayName": "No `require`, `exports` or `module.exports`"
+                },
+                {
+                  "textRaw": "No `__filename` or `__dirname`",
+                  "name": "no_`__filename`_or_`__dirname`",
+                  "desc": "<p>These CommonJS variables are not available in ES modules.</p>\n<p><code>__filename</code> and <code>__dirname</code> use cases can be replicated via\n<a href=\"#esm_import_meta_url\"><code>import.meta.url</code></a>.</p>",
+                  "type": "module",
+                  "displayName": "No `__filename` or `__dirname`"
+                },
+                {
+                  "textRaw": "No JSON Module Loading",
+                  "name": "no_json_module_loading",
+                  "desc": "<p>JSON imports are still experimental and only supported via the\n<code>--experimental-json-modules</code> flag.</p>\n<p>Local JSON files can be loaded relative to <code>import.meta.url</code> with <code>fs</code> directly:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import { readFile } from 'fs/promises';\nconst json = JSON.parse(await readFile(new URL('./dat.json', import.meta.url)));\n</code></pre>\n<p>Alternatively <code>module.createRequire()</code> can be used.</p>",
+                  "type": "module",
+                  "displayName": "No JSON Module Loading"
+                },
+                {
+                  "textRaw": "No Native Module Loading",
+                  "name": "no_native_module_loading",
+                  "desc": "<p>Native modules are not currently supported with ES module imports.</p>\n<p>They can instead be loaded with <a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a> or\n<a href=\"process.html#process_process_dlopen_module_filename_flags\"><code>process.dlopen</code></a>.</p>",
+                  "type": "module",
+                  "displayName": "No Native Module Loading"
+                },
+                {
+                  "textRaw": "No `require.resolve`",
+                  "name": "no_`require.resolve`",
+                  "desc": "<p>Relative resolution can be handled via <code>new URL('./local', import.meta.url)</code>.</p>\n<p>For a complete <code>require.resolve</code> replacement, there is a flagged experimental\n<a href=\"#esm_import_meta_resolve_specifier_parent\"><code>import.meta.resolve</code></a> API.</p>\n<p>Alternatively <code>module.createRequire()</code> can be used.</p>",
+                  "type": "module",
+                  "displayName": "No `require.resolve`"
+                },
+                {
+                  "textRaw": "No `NODE_PATH`",
+                  "name": "no_`node_path`",
+                  "desc": "<p><code>NODE_PATH</code> is not part of resolving <code>import</code> specifiers. Please use symlinks\nif this behavior is desired.</p>",
+                  "type": "module",
+                  "displayName": "No `NODE_PATH`"
+                },
+                {
+                  "textRaw": "No `require.extensions`",
+                  "name": "no_`require.extensions`",
+                  "desc": "<p><code>require.extensions</code> is not used by <code>import</code>. The expectation is that loader\nhooks can provide this workflow in the future.</p>",
+                  "type": "module",
+                  "displayName": "No `require.extensions`"
+                },
+                {
+                  "textRaw": "No `require.cache`",
+                  "name": "no_`require.cache`",
+                  "desc": "<p><code>require.cache</code> is not used by <code>import</code> as the ES module loader has its own\nseparate cache.</p>\n<p><i id=\"esm_experimental_json_modules\"></i></p>",
+                  "type": "module",
+                  "displayName": "No `require.cache`"
+                }
+              ],
               "type": "module",
-              "displayName": "`import()` expressions"
+              "displayName": "Differences between ES modules and CommonJS"
             }
           ],
           "type": "misc",
           "displayName": "Interoperability with CommonJS"
         },
         {
-          "textRaw": "CommonJS Namespaces",
-          "name": "commonjs_namespaces",
-          "desc": "<p>CommonJS modules consist of a <code>module.exports</code> object which can be of any type.</p>\n<p>When importing a CommonJS module, it can be reliably imported using the ES\nmodule default import or its corresponding sugar syntax:</p>\n<!-- eslint-disable no-duplicate-imports -->\n<pre><code class=\"language-js\">import { default as cjs } from 'cjs';\n\n// The following import statement is \"syntax sugar\" (equivalent but sweeter)\n// for `{ default as cjsSugar }` in the above import statement:\nimport cjsSugar from 'cjs';\n\nconsole.log(cjs);\nconsole.log(cjs === cjsSugar);\n// Prints:\n//   &#x3C;module.exports>\n//   true\n</code></pre>\n<p>The ECMAScript Module Namespace representation of a CommonJS module is always\na namespace with a <code>default</code> export key pointing to the CommonJS\n<code>module.exports</code> value.</p>\n<p>This Module Namespace Exotic Object can be directly observed either when using\n<code>import * as m from 'cjs'</code> or a dynamic import:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import * as m from 'cjs';\nconsole.log(m);\nconsole.log(m === await import('cjs'));\n// Prints:\n//   [Module] { default: &#x3C;module.exports> }\n//   true\n</code></pre>\n<p>For better compatibility with existing usage in the JS ecosystem, Node.js\nin addition attempts to determine the CommonJS named exports of every imported\nCommonJS module to provide them as separate ES module exports using a static\nanalysis process.</p>\n<p>For example, consider a CommonJS module written:</p>\n<pre><code class=\"language-js\">// cjs.cjs\nexports.name = 'exported';\n</code></pre>\n<p>The preceding module supports named imports in ES modules:</p>\n<!-- eslint-disable no-duplicate-imports -->\n<pre><code class=\"language-js\">import { name } from './cjs.cjs';\nconsole.log(name);\n// Prints: 'exported'\n\nimport cjs from './cjs.cjs';\nconsole.log(cjs);\n// Prints: { name: 'exported' }\n\nimport * as m from './cjs.cjs';\nconsole.log(m);\n// Prints: [Module] { default: { name: 'exported' }, name: 'exported' }\n</code></pre>\n<p>As can be seen from the last example of the Module Namespace Exotic Object being\nlogged, the <code>name</code> export is copied off of the <code>module.exports</code> object and set\ndirectly on the ES module namespace when the module is imported.</p>\n<p>Live binding updates or new exports added to <code>module.exports</code> are not detected\nfor these named exports.</p>\n<p>The detection of named exports is based on common syntax patterns but does not\nalways correctly detect named exports. In these cases, using the default\nimport form described above can be a better option.</p>\n<p>Named exports detection covers many common export patterns, reexport patterns\nand build tool and transpiler outputs. See <a href=\"https://github.com/guybedford/cjs-module-lexer/tree/1.2.1\">cjs-module-lexer</a> for the exact\nsemantics implemented.</p>",
-          "type": "misc",
-          "displayName": "CommonJS Namespaces"
-        },
-        {
-          "textRaw": "Builtin modules",
-          "name": "builtin_modules",
-          "desc": "<p><a href=\"modules.html#modules_core_modules\">Core modules</a> provide named exports of their public API. A\ndefault export is also provided which is the value of the CommonJS exports.\nThe default export can be used for, among other things, modifying the named\nexports. Named exports of builtin modules are updated only by calling\n<a href=\"module.html#module_module_syncbuiltinesmexports\"><code>module.syncBuiltinESMExports()</code></a>.</p>\n<pre><code class=\"language-js\">import EventEmitter from 'events';\nconst e = new EventEmitter();\n</code></pre>\n<pre><code class=\"language-js\">import { readFile } from 'fs';\nreadFile('./foo.txt', (err, source) => {\n  if (err) {\n    console.error(err);\n  } else {\n    console.log(source);\n  }\n});\n</code></pre>\n<pre><code class=\"language-js\">import fs, { readFileSync } from 'fs';\nimport { syncBuiltinESMExports } from 'module';\n\nfs.readFileSync = () => Buffer.from('Hello, ESM');\nsyncBuiltinESMExports();\n\nfs.readFileSync === readFileSync;\n</code></pre>",
-          "type": "misc",
-          "displayName": "Builtin modules"
-        },
-        {
-          "textRaw": "CommonJS, JSON, and native modules",
-          "name": "commonjs,_json,_and_native_modules",
-          "desc": "<p>CommonJS, JSON, and native modules can be used with\n<a href=\"module.html#module_module_createrequire_filename\"><code>module.createRequire()</code></a>.</p>\n<pre><code class=\"language-js\">// cjs.cjs\nmodule.exports = 'cjs';\n\n// esm.mjs\nimport { createRequire } from 'module';\n\nconst require = createRequire(import.meta.url);\n\nconst cjs = require('./cjs.cjs');\ncjs === 'cjs'; // true\n</code></pre>",
+          "textRaw": "JSON modules",
+          "name": "json_modules",
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>Currently importing JSON modules are only supported in the <code>commonjs</code> mode\nand are loaded using the CJS loader. <a href=\"https://html.spec.whatwg.org/#creating-a-json-module-script\">WHATWG JSON modules specification</a> are\nstill being standardized, and are experimentally supported by including the\nadditional flag <code>--experimental-json-modules</code> when running Node.js.</p>\n<p>When the <code>--experimental-json-modules</code> flag is included, both the\n<code>commonjs</code> and <code>module</code> mode use the new experimental JSON\nloader. The imported JSON only exposes a <code>default</code>. There is no\nsupport for named exports. A cache entry is created in the CommonJS\ncache to avoid duplication. The same object is returned in\nCommonJS if the JSON module has already been imported from the\nsame path.</p>\n<p>Assuming an <code>index.mjs</code> with</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import packageConfig from './package.json';\n</code></pre>\n<p>The <code>--experimental-json-modules</code> flag is needed for the module\nto work.</p>\n<pre><code class=\"language-bash\">node index.mjs # fails\nnode --experimental-json-modules index.mjs # works\n</code></pre>\n<p><i id=\"esm_experimental_wasm_modules\"></i></p>",
           "type": "misc",
-          "displayName": "CommonJS, JSON, and native modules"
+          "displayName": "JSON modules"
         },
         {
-          "textRaw": "Experimental JSON modules",
-          "name": "experimental_json_modules",
-          "desc": "<p>Currently importing JSON modules are only supported in the <code>commonjs</code> mode\nand are loaded using the CJS loader. <a href=\"https://html.spec.whatwg.org/#creating-a-json-module-script\">WHATWG JSON modules specification</a> are\nstill being standardized, and are experimentally supported by including the\nadditional flag <code>--experimental-json-modules</code> when running Node.js.</p>\n<p>When the <code>--experimental-json-modules</code> flag is included, both the\n<code>commonjs</code> and <code>module</code> mode use the new experimental JSON\nloader. The imported JSON only exposes a <code>default</code>. There is no\nsupport for named exports. A cache entry is created in the CommonJS\ncache to avoid duplication. The same object is returned in\nCommonJS if the JSON module has already been imported from the\nsame path.</p>\n<p>Assuming an <code>index.mjs</code> with</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">import packageConfig from './package.json';\n</code></pre>\n<p>The <code>--experimental-json-modules</code> flag is needed for the module\nto work.</p>\n<pre><code class=\"language-bash\">node index.mjs # fails\nnode --experimental-json-modules index.mjs # works\n</code></pre>",
+          "textRaw": "Wasm modules",
+          "name": "wasm_modules",
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>Importing Web Assembly modules is supported under the\n<code>--experimental-wasm-modules</code> flag, allowing any <code>.wasm</code> files to be\nimported as normal modules while also supporting their module imports.</p>\n<p>This integration is in line with the\n<a href=\"https://github.com/webassembly/esm-integration\">ES Module Integration Proposal for Web Assembly</a>.</p>\n<p>For example, an <code>index.mjs</code> containing:</p>\n<pre><code class=\"language-js\">import * as M from './module.wasm';\nconsole.log(M);\n</code></pre>\n<p>executed under:</p>\n<pre><code class=\"language-bash\">node --experimental-wasm-modules index.mjs\n</code></pre>\n<p>would provide the exports interface for the instantiation of <code>module.wasm</code>.</p>\n<p><i id=\"esm_experimental_top_level_await\"></i></p>",
           "type": "misc",
-          "displayName": "Experimental JSON modules"
+          "displayName": "Wasm modules"
         },
         {
-          "textRaw": "Experimental Wasm modules",
-          "name": "experimental_wasm_modules",
-          "desc": "<p>Importing Web Assembly modules is supported under the\n<code>--experimental-wasm-modules</code> flag, allowing any <code>.wasm</code> files to be\nimported as normal modules while also supporting their module imports.</p>\n<p>This integration is in line with the\n<a href=\"https://github.com/webassembly/esm-integration\">ES Module Integration Proposal for Web Assembly</a>.</p>\n<p>For example, an <code>index.mjs</code> containing:</p>\n<pre><code class=\"language-js\">import * as M from './module.wasm';\nconsole.log(M);\n</code></pre>\n<p>executed under:</p>\n<pre><code class=\"language-bash\">node --experimental-wasm-modules index.mjs\n</code></pre>\n<p>would provide the exports interface for the instantiation of <code>module.wasm</code>.</p>",
+          "textRaw": "Top-level `await`",
+          "name": "top-level_`await`",
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>The <code>await</code> keyword may be used in the top level (outside of async functions)\nwithin modules as per the <a href=\"https://github.com/tc39/proposal-top-level-await/\">ECMAScript Top-Level <code>await</code> proposal</a>.</p>\n<p>Assuming an <code>a.mjs</code> with</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">export const five = await Promise.resolve(5);\n</code></pre>\n<p>And a <code>b.mjs</code> with</p>\n<pre><code class=\"language-js\">import { five } from './a.mjs';\n\nconsole.log(five); // Logs `5`\n</code></pre>\n<pre><code class=\"language-bash\">node b.mjs # works\n</code></pre>\n<p><i id=\"esm_experimental_loaders\"></i></p>",
           "type": "misc",
-          "displayName": "Experimental Wasm modules"
+          "displayName": "Top-level `await`"
         },
         {
-          "textRaw": "Experimental loaders",
-          "name": "Experimental loaders",
+          "textRaw": "Loaders",
+          "name": "Loaders",
+          "stability": 1,
+          "stabilityText": "Experimental",
           "type": "misc",
           "desc": "<p><strong>Note: This API is currently being redesigned and will still change.</strong></p>\n<p>To customize the default module resolution, loader hooks can optionally be\nprovided via a <code>--experimental-loader ./loader-name.mjs</code> argument to Node.js.</p>\n<p>When hooks are used they only apply to ES module loading and not to any\nCommonJS modules loaded.</p>",
           "miscs": [
@@ -311,7 +394,7 @@
                       "params": []
                     }
                   ],
-                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>context</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n<li><code>defaultGetFormat</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a></li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>format</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n</li>\n</ul>\n<p>The <code>getFormat</code> hook provides a way to define a custom method of determining how\na URL should be interpreted. The <code>format</code> returned also affects what the\nacceptable forms of source values are for a module when parsing. This can be one\nof the following:</p>\n<table>\n<thead>\n<tr>\n<th><code>format</code></th>\n<th>Description</th>\n<th>Acceptable Types For <code>source</code> Returned by <code>getSource</code> or <code>transformSource</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'builtin'</code></td>\n<td>Load a Node.js builtin module</td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'dynamic'</code></td>\n<td>Use a <a href=\"#esm_code_dynamicinstantiate_code_hook\">dynamic instantiate hook</a></td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'commonjs'</code></td>\n<td>Load a Node.js CommonJS module</td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'json'</code></td>\n<td>Load a JSON file</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\"><code>string</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n<tr>\n<td><code>'module'</code></td>\n<td>Load an ES module</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\"><code>string</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n<tr>\n<td><code>'wasm'</code></td>\n<td>Load a WebAssembly module</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n</tbody>\n</table>\n<p>Note: These types all correspond to classes defined in ECMAScript.</p>\n<ul>\n<li>The specific <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> object is a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a>.</li>\n<li>The specific <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> object is a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>.</li>\n</ul>\n<p>Note: If the source value of a text-based format (i.e., <code>'json'</code>, <code>'module'</code>) is\nnot a string, it is converted to a string using <a href=\"util.md#util_class_util_textdecoder\"><code>util.TextDecoder</code></a>.</p>\n<pre><code class=\"language-js\">/**\n * @param {string} url\n * @param {Object} context (currently empty)\n * @param {Function} defaultGetFormat\n * @returns {Promise&#x3C;{ format: string }>}\n */\nexport async function getFormat(url, context, defaultGetFormat) {\n  if (Math.random() > 0.5) { // Some condition.\n    // For some or all URLs, do some custom logic for determining format.\n    // Always return an object of the form {format: &#x3C;string>}, where the\n    // format is one of the strings in the preceding table.\n    return {\n      format: 'module',\n    };\n  }\n  // Defer to Node.js for all other URLs.\n  return defaultGetFormat(url, context, defaultGetFormat);\n}\n</code></pre>"
+                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>context</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n<li><code>defaultGetFormat</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a></li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>format</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n</li>\n</ul>\n<p>The <code>getFormat</code> hook provides a way to define a custom method of determining how\na URL should be interpreted. The <code>format</code> returned also affects what the\nacceptable forms of source values are for a module when parsing. This can be one\nof the following:</p>\n<table>\n<thead>\n<tr>\n<th><code>format</code></th>\n<th>Description</th>\n<th>Acceptable Types For <code>source</code> Returned by <code>getSource</code> or <code>transformSource</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'builtin'</code></td>\n<td>Load a Node.js builtin module</td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'commonjs'</code></td>\n<td>Load a Node.js CommonJS module</td>\n<td>Not applicable</td>\n</tr>\n<tr>\n<td><code>'json'</code></td>\n<td>Load a JSON file</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\"><code>string</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n<tr>\n<td><code>'module'</code></td>\n<td>Load an ES module</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\"><code>string</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n<tr>\n<td><code>'wasm'</code></td>\n<td>Load a WebAssembly module</td>\n<td>{ <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> }</td>\n</tr>\n</tbody>\n</table>\n<p>Note: These types all correspond to classes defined in ECMAScript.</p>\n<ul>\n<li>The specific <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a> object is a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a>.</li>\n<li>The specific <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\"><code>TypedArray</code></a> object is a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>.</li>\n</ul>\n<p>Note: If the source value of a text-based format (i.e., <code>'json'</code>, <code>'module'</code>) is\nnot a string, it is converted to a string using <a href=\"util.html#util_class_util_textdecoder\"><code>util.TextDecoder</code></a>.</p>\n<pre><code class=\"language-js\">/**\n * @param {string} url\n * @param {Object} context (currently empty)\n * @param {Function} defaultGetFormat\n * @returns {Promise&#x3C;{ format: string }>}\n */\nexport async function getFormat(url, context, defaultGetFormat) {\n  if (Math.random() > 0.5) { // Some condition.\n    // For some or all URLs, do some custom logic for determining format.\n    // Always return an object of the form {format: &#x3C;string>}, where the\n    // format is one of the strings in the preceding table.\n    return {\n      format: 'module',\n    };\n  }\n  // Defer to Node.js for all other URLs.\n  return defaultGetFormat(url, context, defaultGetFormat);\n}\n</code></pre>"
                 },
                 {
                   "textRaw": "`getSource(url, context, defaultGetSource)`",
@@ -333,7 +416,7 @@
                       "params": []
                     }
                   ],
-                  "desc": "<pre><code class=\"language-console\">NODE_OPTIONS='--experimental-loader ./custom-loader.mjs' node x.js\n</code></pre>\n<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li><code>source</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\" class=\"type\">&lt;SharedArrayBuffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\" class=\"type\">&lt;Uint8Array&gt;</a></li>\n<li><code>context</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>format</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>source</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\" class=\"type\">&lt;SharedArrayBuffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\" class=\"type\">&lt;Uint8Array&gt;</a></li>\n</ul>\n</li>\n</ul>\n<p>The <code>transformSource</code> hook provides a way to modify the source code of a loaded\nES module file after the source string has been loaded but before Node.js has\ndone anything with it.</p>\n<p>If this hook is used to convert unknown-to-Node.js file types into executable\nJavaScript, a resolve hook is also necessary in order to register any\nunknown-to-Node.js file extensions. See the <a href=\"#esm_transpiler_loader\">transpiler loader example</a> below.</p>\n<pre><code class=\"language-js\">/**\n * @param {!(string | SharedArrayBuffer | Uint8Array)} source\n * @param {{\n *   format: string,\n *   url: string,\n * }} context\n * @param {Function} defaultTransformSource\n * @returns {Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) }>}\n */\nexport async function transformSource(source, context, defaultTransformSource) {\n  const { url, format } = context;\n  if (Math.random() > 0.5) { // Some condition.\n    // For some or all URLs, do some custom logic for modifying the source.\n    // Always return an object of the form {source: &#x3C;string|buffer>}.\n    return {\n      source: '...',\n    };\n  }\n  // Defer to Node.js for all other sources.\n  return defaultTransformSource(source, context, defaultTransformSource);\n}\n</code></pre>"
+                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li><code>source</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\" class=\"type\">&lt;SharedArrayBuffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\" class=\"type\">&lt;Uint8Array&gt;</a></li>\n<li><code>context</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>format</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>source</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\" class=\"type\">&lt;SharedArrayBuffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\" class=\"type\">&lt;Uint8Array&gt;</a></li>\n</ul>\n</li>\n</ul>\n<p>The <code>transformSource</code> hook provides a way to modify the source code of a loaded\nES module file after the source string has been loaded but before Node.js has\ndone anything with it.</p>\n<p>If this hook is used to convert unknown-to-Node.js file types into executable\nJavaScript, a resolve hook is also necessary in order to register any\nunknown-to-Node.js file extensions. See the <a href=\"#esm_transpiler_loader\">transpiler loader example</a> below.</p>\n<pre><code class=\"language-js\">/**\n * @param {!(string | SharedArrayBuffer | Uint8Array)} source\n * @param {{\n *   format: string,\n *   url: string,\n * }} context\n * @param {Function} defaultTransformSource\n * @returns {Promise&#x3C;{ source: !(string | SharedArrayBuffer | Uint8Array) }>}\n */\nexport async function transformSource(source, context, defaultTransformSource) {\n  const { url, format } = context;\n  if (Math.random() > 0.5) { // Some condition.\n    // For some or all URLs, do some custom logic for modifying the source.\n    // Always return an object of the form {source: &#x3C;string|buffer>}.\n    return {\n      source: '...',\n    };\n  }\n  // Defer to Node.js for all other sources.\n  return defaultTransformSource(source, context, defaultTransformSource);\n}\n</code></pre>"
                 },
                 {
                   "textRaw": "`getGlobalPreloadCode()`",
@@ -344,17 +427,10 @@
                       "params": []
                     }
                   ],
-                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n<p>Sometimes it might be necessary to run some code inside of the same global scope\nthat the application runs in. This hook allows the return of a string that is\nrun as sloppy-mode script on startup.</p>\n<p>Similar to how CommonJS wrappers work, the code runs in an implicit function\nscope. The only argument is a <code>require</code>-like function that can be used to load\nbuiltins like \"fs\": <code>getBuiltin(request: string)</code>.</p>\n<p>If the code needs more advanced <code>require</code> features, it has to construct\nits own <code>require</code> using  <code>module.createRequire()</code>.</p>\n<pre><code class=\"language-js\">/**\n * @returns {string} Code to run before application startup\n */\nexport function getGlobalPreloadCode() {\n  return `\\\nglobalThis.someInjectedProperty = 42;\nconsole.log('I just set some globals!');\n\nconst { createRequire } = getBuiltin('module');\n\nconst require = createRequire(process.cwd() + '/&#x3C;preload>');\n// [...]\n`;\n}\n</code></pre>"
+                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<ul>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n<p>Sometimes it might be necessary to run some code inside of the same global scope\nthat the application runs in. This hook allows the return of a string that is\nrun as sloppy-mode script on startup.</p>\n<p>Similar to how CommonJS wrappers work, the code runs in an implicit function\nscope. The only argument is a <code>require</code>-like function that can be used to load\nbuiltins like \"fs\": <code>getBuiltin(request: string)</code>.</p>\n<p>If the code needs more advanced <code>require</code> features, it has to construct\nits own <code>require</code> using  <code>module.createRequire()</code>.</p>\n<pre><code class=\"language-js\">/**\n * @returns {string} Code to run before application startup\n */\nexport function getGlobalPreloadCode() {\n  return `\\\nglobalThis.someInjectedProperty = 42;\nconsole.log('I just set some globals!');\n\nconst { createRequire } = getBuiltin('module');\n\nconst require = createRequire(process.cwd() + '/&#x3C;preload>');\n// [...]\n`;\n}\n</code></pre>\n<h3>Examples</h3>\n<p>The various loader hooks can be used together to accomplish wide-ranging\ncustomizations of Node.js’ code loading and evaluation behaviors.</p>"
                 }
               ],
               "modules": [
-                {
-                  "textRaw": "<code>dynamicInstantiate</code> hook",
-                  "name": "<code>dynamicinstantiate</code>_hook",
-                  "desc": "<blockquote>\n<p>Note: The loaders API is being redesigned. This hook may disappear or its\nsignature may change. Do not rely on the API described below.</p>\n</blockquote>\n<p>To create a custom dynamic module that doesn't correspond to one of the\nexisting <code>format</code> interpretations, the <code>dynamicInstantiate</code> hook can be used.\nThis hook is called only for modules that return <code>format: 'dynamic'</code> from\nthe <code>getFormat</code> hook.</p>\n<pre><code class=\"language-js\">/**\n * @param {string} url\n * @returns {object} response\n * @returns {array} response.exports\n * @returns {function} response.execute\n */\nexport async function dynamicInstantiate(url) {\n  return {\n    exports: ['customExportName'],\n    execute: (exports) => {\n      // Get and set functions provided for pre-allocated export names\n      exports.customExportName.set('value');\n    }\n  };\n}\n</code></pre>\n<p>With the list of module exports provided upfront, the <code>execute</code> function will\nthen be called at the exact point of module evaluation order for that module\nin the import tree.</p>\n<h3>Examples</h3>\n<p>The various loader hooks can be used together to accomplish wide-ranging\ncustomizations of Node.js’ code loading and evaluation behaviors.</p>",
-                  "type": "module",
-                  "displayName": "<code>dynamicInstantiate</code> hook"
-                },
                 {
                   "textRaw": "HTTPS loader",
                   "name": "https_loader",
@@ -389,7 +465,7 @@
             {
               "textRaw": "Resolver algorithm",
               "name": "resolver_algorithm",
-              "desc": "<p>The algorithm to load an ES module specifier is given through the\n<strong>ESM_RESOLVE</strong> method below. It returns the resolved URL for a\nmodule specifier relative to a parentURL.</p>\n<p>The algorithm to determine the module format of a resolved URL is\nprovided by <strong>ESM_FORMAT</strong>, which returns the unique module\nformat for any file. The <em>\"module\"</em> format is returned for an ECMAScript\nModule, while the <em>\"commonjs\"</em> format is used to indicate loading through the\nlegacy CommonJS loader. Additional formats such as <em>\"addon\"</em> can be extended in\nfuture updates.</p>\n<p>In the following algorithms, all subroutine errors are propagated as errors\nof these top-level routines unless stated otherwise.</p>\n<p><em>defaultConditions</em> is the conditional environment name array,\n<code>[\"node\", \"import\"]</code>.</p>\n<p>The resolver can throw the following errors:</p>\n<ul>\n<li><em>Invalid Module Specifier</em>: Module specifier is an invalid URL, package name\nor package subpath specifier.</li>\n<li><em>Invalid Package Configuration</em>: package.json configuration is invalid or\ncontains an invalid configuration.</li>\n<li><em>Invalid Package Target</em>: Package exports or imports define a target module\nfor the package that is an invalid type or string target.</li>\n<li><em>Package Path Not Exported</em>: Package exports do not define or permit a target\nsubpath in the package for the given module.</li>\n<li><em>Package Import Not Defined</em>: Package imports do not define the specifier.</li>\n<li><em>Module Not Found</em>: The package or module requested does not exist.</li>\n</ul>",
+              "desc": "<p>The algorithm to load an ES module specifier is given through the\n<strong>ESM_RESOLVE</strong> method below. It returns the resolved URL for a\nmodule specifier relative to a parentURL.</p>\n<p>The algorithm to determine the module format of a resolved URL is\nprovided by <strong>ESM_FORMAT</strong>, which returns the unique module\nformat for any file. The <em>\"module\"</em> format is returned for an ECMAScript\nModule, while the <em>\"commonjs\"</em> format is used to indicate loading through the\nlegacy CommonJS loader. Additional formats such as <em>\"addon\"</em> can be extended in\nfuture updates.</p>\n<p>In the following algorithms, all subroutine errors are propagated as errors\nof these top-level routines unless stated otherwise.</p>\n<p><em>defaultConditions</em> is the conditional environment name array,\n<code>[\"node\", \"import\"]</code>.</p>\n<p>The resolver can throw the following errors:</p>\n<ul>\n<li><em>Invalid Module Specifier</em>: Module specifier is an invalid URL, package name\nor package subpath specifier.</li>\n<li><em>Invalid Package Configuration</em>: package.json configuration is invalid or\ncontains an invalid configuration.</li>\n<li><em>Invalid Package Target</em>: Package exports or imports define a target module\nfor the package that is an invalid type or string target.</li>\n<li><em>Package Path Not Exported</em>: Package exports do not define or permit a target\nsubpath in the package for the given module.</li>\n<li><em>Package Import Not Defined</em>: Package imports do not define the specifier.</li>\n<li><em>Module Not Found</em>: The package or module requested does not exist.</li>\n<li><em>Unsupported Directory Import</em>: The resolved path corresponds to a directory,\nwhich is not a supported target for module imports.</li>\n</ul>",
               "type": "module",
               "displayName": "Resolver algorithm"
             },
@@ -403,6 +479,8 @@
             {
               "textRaw": "Customizing ESM specifier resolution algorithm",
               "name": "customizing_esm_specifier_resolution_algorithm",
+              "stability": 1,
+              "stabilityText": "Experimental",
               "desc": "<p>The current specifier resolution does not support all default behavior of\nthe CommonJS loader. One of the behavior differences is automatic resolution\nof file extensions and the ability to import directories that have an index\nfile.</p>\n<p>The <code>--experimental-specifier-resolution=[mode]</code> flag can be used to customize\nthe extension resolution algorithm. The default mode is <code>explicit</code>, which\nrequires the full path to a module be provided to the loader. To enable the\nautomatic extension resolution and importing from directories that include an\nindex file use the <code>node</code> mode.</p>\n<pre><code class=\"language-console\">$ node index.mjs\nsuccess!\n$ node index # Failure!\nError: Cannot find module\n$ node --experimental-specifier-resolution=node index\nsuccess!\n</code></pre>\n<!-- Note: The cjs-module-lexer link should be kept in-sync with the deps version -->",
               "type": "module",
               "displayName": "Customizing ESM specifier resolution algorithm"
@@ -417,7 +495,29 @@
           "textRaw": "`meta` {Object}",
           "type": "Object",
           "name": "meta",
-          "desc": "<p>The <code>import.meta</code> metaproperty is an <code>Object</code> that contains the following\nproperty:</p>\n<ul>\n<li><code>url</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The absolute <code>file:</code> URL of the module.</li>\n</ul>"
+          "desc": "<p>The <code>import.meta</code> meta property is an <code>Object</code> that contains the following\nproperties.</p>",
+          "properties": [
+            {
+              "textRaw": "`url` {string} The absolute `file:` URL of the module.",
+              "type": "string",
+              "name": "url",
+              "desc": "<p>This is defined exactly the same as it is in browsers providing the URL of the\ncurrent module file.</p>\n<p>This enables useful patterns such as relative file loading:</p>\n<pre><code class=\"language-js\">import { readFileSync } from 'fs';\nconst buffer = readFileSync(new URL('./data.proto', import.meta.url));\n</code></pre>",
+              "shortDesc": "The absolute `file:` URL of the module."
+            }
+          ],
+          "methods": [
+            {
+              "textRaw": "`import.meta.resolve(specifier[, parent])`",
+              "type": "method",
+              "name": "resolve",
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<!--\nadded:\n  - v13.9.0\n  - v12.16.2\nchanges:\n  - version: v14.18.0\n    pr-url: https://github.com/nodejs/node/pull/38587\n    description: Add support for WHATWG `URL` object to `parentURL` parameter.\n-->\n<blockquote>\n<p>Stability: 1 - Experimental</p>\n</blockquote>\n<p>This feature is only available with the <code>--experimental-import-meta-resolve</code>\ncommand flag enabled.</p>\n<ul>\n<li><code>specifier</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The module specifier to resolve relative to <code>parent</code>.</li>\n<li><code>parent</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The absolute parent module URL to resolve from. If none\nis specified, the value of <code>import.meta.url</code> is used as the default.</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise\" class=\"type\">&lt;Promise&gt;</a></li>\n</ul>\n<p>Provides a module-relative resolution function scoped to each module, returning\nthe URL string.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">const dependencyAsset = await import.meta.resolve('component-lib/asset.css');\n</code></pre>\n<p><code>import.meta.resolve</code> also accepts a second argument which is the parent module\nfrom which to resolve from:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">await import.meta.resolve('./dep', import.meta.url);\n</code></pre>\n<p>This function is asynchronous because the ES module resolver in Node.js is\nallowed to be asynchronous.</p>"
+            }
+          ]
         }
       ]
     }
diff --git a/doc/api/esm.md b/doc/api/esm.md
index 3c76d1d6cc5cac3a41ac8854aeee5919f74827d8..632569537b62e7d851debe50a06c66ef327f5bdb 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -6,17 +6,23 @@
 added: v8.5.0
 changes:
   - version:
-    - v12.22.0
+    - v14.17.0
     pr-url: https://github.com/nodejs/node/pull/35781
     description: Stabilize modules implementation.
   - version:
-    - v12.20.0
+    - v14.13.0
     pr-url: https://github.com/nodejs/node/pull/35249
     description: Support for detection of CommonJS named exports.
-  - version: v12.20.0
+  - version: v14.8.0
+    pr-url: https://github.com/nodejs/node/pull/34558
+    description: Unflag Top-Level Await.
+  - version:
+    - v14.0.0
+    - v13.14.0
     pr-url: https://github.com/nodejs/node/pull/31974
     description: Remove experimental modules warning.
   - version:
+    - v13.2.0
     - v12.17.0
     pr-url: https://github.com/nodejs/node/pull/29866
     description: Loading ECMAScript modules no longer requires a command-line flag.
@@ -63,9 +69,9 @@ provides interoperability between them and its original module format,
 [CommonJS][].
 
 <!-- Anchors to make sure old links find a target -->
-<i id="#esm_package_json_type_field"></i>
-<i id="#esm_package_scope_and_file_extensions"></i>
-<i id="#esm_input_type_flag"></i>
+<i id="esm_package_json_type_field"></i>
+<i id="esm_package_scope_and_file_extensions"></i>
+<i id="esm_input_type_flag"></i>
 
 ## Enabling
 
@@ -75,7 +81,7 @@ Node.js treats JavaScript code as CommonJS modules by default.
 Authors can tell Node.js to treat JavaScript code as ECMAScript modules
 via the `.mjs` file extension, the `package.json` [`"type"`][] field, or the
 `--input-type` flag. See
-[Modules: Packages](packages.html#packages_determining_module_system) for more
+[Modules: Packages](packages.md#packages_determining_module_system) for more
 details.
 
 <!-- Anchors to make sure old links find a target -->
@@ -96,7 +102,7 @@ details.
 
 ## Packages
 
-This section was moved to [Modules: Packages](packages.html).
+This section was moved to [Modules: Packages](packages.md).
 
 ## `import` Specifiers
 
@@ -106,44 +112,65 @@ The _specifier_ of an `import` statement is the string after the `from` keyword,
 e.g. `'path'` in `import { sep } from 'path'`. Specifiers are also used in
 `export from` statements, and as the argument to an `import()` expression.
 
-There are four types of specifiers:
-
-* _Bare specifiers_ like `'some-package'`. They refer to an entry point of a
-  package by the package name.
-
-* _Deep import specifiers_ like `'some-package/lib/shuffle.mjs'`. They refer to
-  a path within a package prefixed by the package name.
+There are three types of specifiers:
 
 * _Relative specifiers_ like `'./startup.js'` or `'../config.mjs'`. They refer
-  to a path relative to the location of the importing file.
+  to a path relative to the location of the importing file. _The file extension
+  is always necessary for these._
+
+* _Bare specifiers_ like `'some-package'` or `'some-package/shuffle'`. They can
+  refer to the main entry point of a package by the package name, or a
+  specific feature module within a package prefixed by the package name as per
+  the examples respectively. _Including the file extension is only necessary
+  for packages without an [`"exports"`][] field._
 
 * _Absolute specifiers_ like `'file:///opt/nodejs/config.js'`. They refer
   directly and explicitly to a full path.
 
-Bare specifiers, and the bare specifier portion of deep import specifiers, are
-strings; but everything else in a specifier is a URL.
+Bare specifier resolutions are handled by the [Node.js module resolution
+algorithm][]. All other specifier resolutions are always only resolved with
+the standard relative [URL][] resolution semantics.
 
-`file:`, `node:`, and `data:` URLs are supported. A specifier like
-`'https://example.com/app.js'` may be supported by browsers but it is not
-supported in Node.js.
+Like in CommonJS, module files within packages can be accessed by appending a
+path to the package name unless the package’s [`package.json`][] contains an
+[`"exports"`][] field, in which case files within packages can only be accessed
+via the paths defined in [`"exports"`][].
 
-Specifiers may not begin with `/` or `//`. These are reserved for potential
-future use. The root of the current volume may be referenced via `file:///`.
+For details on these package resolution rules that apply to bare specifiers in
+the Node.js module resolution, see the [packages documentation](packages.md).
 
-#### `node:` Imports
+### Mandatory file extensions
 
-<!-- YAML
-added: v12.20.0
--->
+A file extension must be provided when using the `import` keyword to resolve
+relative or absolute specifiers. Directory indexes (e.g. `'./startup/index.js'`)
+must also be fully specified.
+
+This behavior matches how `import` behaves in browser environments, assuming a
+typically configured server.
+
+### URLs
+
+ES modules are resolved and cached as URLs. This means that files containing
+special characters such as `#` and `?` need to be escaped.
+
+`file:`, `node:`, and `data:` URL schemes are supported. A specifier like
+`'https://example.com/app.js'` is not supported natively in Node.js unless using
+a [custom HTTPS loader][].
 
-`node:` URLs are supported as a means to load Node.js builtin modules. This
-URL scheme allows for builtin modules to be referenced by valid absolute URL
-strings.
+#### `file:` URLs
+
+Modules are loaded multiple times if the `import` specifier used to resolve
+them has a different query or fragment.
 
 ```js
-import fs from 'node:fs/promises';
+import './foo.mjs?query=1'; // loads ./foo.mjs with query of "?query=1"
+import './foo.mjs?query=2'; // loads ./foo.mjs with query of "?query=2"
 ```
 
+The volume root may be referenced via `/`, `//` or `file:///`. Given the
+differences between [URL][] and path resolution (such as percent encoding
+details), it is recommended to use [url.pathToFileURL][] when importing a path.
+
 #### `data:` Imports
 
 <!-- YAML
@@ -169,143 +196,148 @@ import 'data:text/javascript,console.log("hello!");';
 import _ from 'data:application/json,"world!"';
 ```
 
-## `import.meta`
+#### `node:` Imports
 
-* {Object}
+<!-- YAML
+added:
+  - v14.13.1
+  - v12.20.0
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37246
+    description: Added `node:` import support to `require(...)`.
+-->
 
-The `import.meta` metaproperty is an `Object` that contains the following
-property:
+`node:` URLs are supported as an alternative means to load Node.js builtin
+modules. This URL scheme allows for builtin modules to be referenced by valid
+absolute URL strings.
 
-* `url` {string} The absolute `file:` URL of the module.
+```js
+import fs from 'node:fs/promises';
+```
 
-## Differences between ES modules and CommonJS
+## Builtin modules
 
-### Mandatory file extensions
+[Core modules][] provide named exports of their public API. A
+default export is also provided which is the value of the CommonJS exports.
+The default export can be used for, among other things, modifying the named
+exports. Named exports of builtin modules are updated only by calling
+[`module.syncBuiltinESMExports()`][].
 
-A file extension must be provided when using the `import` keyword. Directory
-indexes (e.g. `'./startup/index.js'`) must also be fully specified.
+```js
+import EventEmitter from 'events';
+const e = new EventEmitter();
+```
 
-This behavior matches how `import` behaves in browser environments, assuming a
-typically configured server.
+```js
+import { readFile } from 'fs';
+readFile('./foo.txt', (err, source) => {
+  if (err) {
+    console.error(err);
+  } else {
+    console.log(source);
+  }
+});
+```
 
-### No `NODE_PATH`
+```js
+import fs, { readFileSync } from 'fs';
+import { syncBuiltinESMExports } from 'module';
 
-`NODE_PATH` is not part of resolving `import` specifiers. Please use symlinks
-if this behavior is desired.
+fs.readFileSync = () => Buffer.from('Hello, ESM');
+syncBuiltinESMExports();
 
-### No `require`, `exports`, `module.exports`, `__filename`, `__dirname`
+fs.readFileSync === readFileSync;
+```
 
-These CommonJS variables are not available in ES modules.
+## `import()` expressions
 
-`require` can be imported into an ES module using [`module.createRequire()`][].
+[Dynamic `import()`][] is supported in both CommonJS and ES modules. In CommonJS
+modules it can be used to load ES modules.
 
-Equivalents of `__filename` and `__dirname` can be created inside of each file
-via [`import.meta.url`][].
+## `import.meta`
 
-```js
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
+* {Object}
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-```
+The `import.meta` meta property is an `Object` that contains the following
+properties.
 
-### No `require.resolve`
+### `import.meta.url`
 
-Former use cases relying on `require.resolve` to determine the resolved path
-of a module can be supported via `import.meta.resolve`, which is experimental
-and supported via the `--experimental-import-meta-resolve` flag:
+* {string} The absolute `file:` URL of the module.
 
-```js
-(async () => {
-  const dependencyAsset = await import.meta.resolve('component-lib/asset.css');
-})();
-```
+This is defined exactly the same as it is in browsers providing the URL of the
+current module file.
 
-`import.meta.resolve` also accepts a second argument which is the parent module
-from which to resolve from:
+This enables useful patterns such as relative file loading:
 
 ```js
-(async () => {
-  // Equivalent to import.meta.resolve('./dep')
-  await import.meta.resolve('./dep', import.meta.url);
-})();
+import { readFileSync } from 'fs';
+const buffer = readFileSync(new URL('./data.proto', import.meta.url));
 ```
 
-This function is asynchronous because the ES module resolver in Node.js is
-asynchronous. With the introduction of [Top-Level Await][], these use cases
-will be easier as they won't require an async function wrapper.
-
-### No `require.extensions`
+### `import.meta.resolve(specifier[, parent])`
+<!--
+added:
+  - v13.9.0
+  - v12.16.2
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/38587
+    description: Add support for WHATWG `URL` object to `parentURL` parameter.
+-->
 
-`require.extensions` is not used by `import`. The expectation is that loader
-hooks can provide this workflow in the future.
+> Stability: 1 - Experimental
 
-### No `require.cache`
+This feature is only available with the `--experimental-import-meta-resolve`
+command flag enabled.
 
-`require.cache` is not used by `import`. It has a separate cache.
+* `specifier` {string} The module specifier to resolve relative to `parent`.
+* `parent` {string} The absolute parent module URL to resolve from. If none
+  is specified, the value of `import.meta.url` is used as the default.
+* Returns: {Promise}
 
-### URL-based paths
+Provides a module-relative resolution function scoped to each module, returning
+the URL string.
 
-ES modules are resolved and cached based upon
-[URL](https://url.spec.whatwg.org/) semantics. This means that files containing
-special characters such as `#` and `?` need to be escaped.
+<!-- eslint-skip -->
+```js
+const dependencyAsset = await import.meta.resolve('component-lib/asset.css');
+```
 
-Modules are loaded multiple times if the `import` specifier used to resolve
-them has a different query or fragment.
+`import.meta.resolve` also accepts a second argument which is the parent module
+from which to resolve from:
 
+<!-- eslint-skip -->
 ```js
-import './foo.mjs?query=1'; // loads ./foo.mjs with query of "?query=1"
-import './foo.mjs?query=2'; // loads ./foo.mjs with query of "?query=2"
+await import.meta.resolve('./dep', import.meta.url);
 ```
 
-For now, only modules using the `file:` protocol can be loaded.
+This function is asynchronous because the ES module resolver in Node.js is
+allowed to be asynchronous.
 
 ## Interoperability with CommonJS
 
-### `require`
-
-`require` always treats the files it references as CommonJS. This applies
-whether `require` is used the traditional way within a CommonJS environment, or
-in an ES module environment using [`module.createRequire()`][].
-
-To include an ES module into CommonJS, use [`import()`][].
-
 ### `import` statements
 
 An `import` statement can reference an ES module or a CommonJS module.
-`import` statements are permitted only in ES modules. For similar functionality
-in CommonJS, see [`import()`][].
+`import` statements are permitted only in ES modules, but dynamic [`import()`][]
+expressions are supported in CommonJS for loading ES modules.
 
 When importing [CommonJS modules](#esm_commonjs_namespaces), the
 `module.exports` object is provided as the default export. Named exports may be
 available, provided by static analysis as a convenience for better ecosystem
 compatibility.
 
-Additional experimental flags are available for importing
-[Wasm modules](#esm_experimental_wasm_modules) or
-[JSON modules](#esm_experimental_json_modules). For importing native modules or
-JSON modules unflagged, see [`module.createRequire()`][].
-
-The _specifier_ of an `import` statement (the string after the `from` keyword)
-can either be an URL-style relative path like `'./file.mjs'` or a package name
-like `'fs'`.
-
-Like in CommonJS, files within packages can be accessed by appending a path to
-the package name; unless the package’s [`package.json`][] contains an
-[`"exports"`][] field, in which case files within packages need to be accessed
-via the path defined in [`"exports"`][].
-
-```js
-import { sin, cos } from 'geometry/trigonometry-functions.mjs';
-```
+### `require`
 
-### `import()` expressions
+The CommonJS module `require` always treats the files it references as CommonJS.
 
-[Dynamic `import()`][] is supported in both CommonJS and ES modules. It can be
-used to include ES module files from CommonJS code.
+Using `require` to load an ES module is not supported because ES modules have
+asynchronous execution. Instead, use [`import()`][] to load an ES module
+from a CommonJS module.
 
-## CommonJS Namespaces
+### CommonJS Namespaces
 
 CommonJS modules consist of a `module.exports` object which can be of any type.
 
@@ -351,7 +383,7 @@ analysis process.
 
 For example, consider a CommonJS module written:
 
-```js
+```cjs
 // cjs.cjs
 exports.name = 'exported';
 ```
@@ -388,59 +420,73 @@ Named exports detection covers many common export patterns, reexport patterns
 and build tool and transpiler outputs. See [cjs-module-lexer][] for the exact
 semantics implemented.
 
-## Builtin modules
+### Differences between ES modules and CommonJS
 
-[Core modules][] provide named exports of their public API. A
-default export is also provided which is the value of the CommonJS exports.
-The default export can be used for, among other things, modifying the named
-exports. Named exports of builtin modules are updated only by calling
-[`module.syncBuiltinESMExports()`][].
+#### No `require`, `exports` or `module.exports`
 
-```js
-import EventEmitter from 'events';
-const e = new EventEmitter();
-```
+In most cases, the ES module `import` can be used to load CommonJS modules.
+
+If needed, a `require` function can be constructed within an ES module using
+[`module.createRequire()`][].
+
+#### No `__filename` or `__dirname`
 
+These CommonJS variables are not available in ES modules.
+
+`__filename` and `__dirname` use cases can be replicated via
+[`import.meta.url`][].
+
+#### No JSON Module Loading
+
+JSON imports are still experimental and only supported via the
+`--experimental-json-modules` flag.
+
+Local JSON files can be loaded relative to `import.meta.url` with `fs` directly:
+
+<!-- eslint-skip -->
 ```js
-import { readFile } from 'fs';
-readFile('./foo.txt', (err, source) => {
-  if (err) {
-    console.error(err);
-  } else {
-    console.log(source);
-  }
-});
+import { readFile } from 'fs/promises';
+const json = JSON.parse(await readFile(new URL('./dat.json', import.meta.url)));
 ```
 
-```js
-import fs, { readFileSync } from 'fs';
-import { syncBuiltinESMExports } from 'module';
+Alternatively `module.createRequire()` can be used.
 
-fs.readFileSync = () => Buffer.from('Hello, ESM');
-syncBuiltinESMExports();
+#### No Native Module Loading
 
-fs.readFileSync === readFileSync;
-```
+Native modules are not currently supported with ES module imports.
 
-## CommonJS, JSON, and native modules
+They can instead be loaded with [`module.createRequire()`][] or
+[`process.dlopen`][].
 
-CommonJS, JSON, and native modules can be used with
-[`module.createRequire()`][].
+#### No `require.resolve`
 
-```js
-// cjs.cjs
-module.exports = 'cjs';
+Relative resolution can be handled via `new URL('./local', import.meta.url)`.
 
-// esm.mjs
-import { createRequire } from 'module';
+For a complete `require.resolve` replacement, there is a flagged experimental
+[`import.meta.resolve`][] API.
 
-const require = createRequire(import.meta.url);
+Alternatively `module.createRequire()` can be used.
 
-const cjs = require('./cjs.cjs');
-cjs === 'cjs'; // true
-```
+#### No `NODE_PATH`
+
+`NODE_PATH` is not part of resolving `import` specifiers. Please use symlinks
+if this behavior is desired.
+
+#### No `require.extensions`
+
+`require.extensions` is not used by `import`. The expectation is that loader
+hooks can provide this workflow in the future.
+
+#### No `require.cache`
+
+`require.cache` is not used by `import` as the ES module loader has its own
+separate cache.
+
+<i id="esm_experimental_json_modules"></i>
+
+## JSON modules
 
-## Experimental JSON modules
+> Stability: 1 - Experimental
 
 Currently importing JSON modules are only supported in the `commonjs` mode
 and are loaded using the CJS loader. [WHATWG JSON modules specification][] are
@@ -470,7 +516,11 @@ node index.mjs # fails
 node --experimental-json-modules index.mjs # works
 ```
 
-## Experimental Wasm modules
+<i id="esm_experimental_wasm_modules"></i>
+
+## Wasm modules
+
+> Stability: 1 - Experimental
 
 Importing Web Assembly modules is supported under the
 `--experimental-wasm-modules` flag, allowing any `.wasm` files to be
@@ -494,7 +544,39 @@ node --experimental-wasm-modules index.mjs
 
 would provide the exports interface for the instantiation of `module.wasm`.
 
-## Experimental loaders
+<i id="esm_experimental_top_level_await"></i>
+
+## Top-level `await`
+
+> Stability: 1 - Experimental
+
+The `await` keyword may be used in the top level (outside of async functions)
+within modules as per the [ECMAScript Top-Level `await` proposal][].
+
+Assuming an `a.mjs` with
+
+<!-- eslint-skip -->
+```js
+export const five = await Promise.resolve(5);
+```
+
+And a `b.mjs` with
+
+```js
+import { five } from './a.mjs';
+
+console.log(five); // Logs `5`
+```
+
+```bash
+node b.mjs # works
+```
+
+<i id="esm_experimental_loaders"></i>
+
+## Loaders
+
+> Stability: 1 - Experimental
 
 **Note: This API is currently being redesigned and will still change.**
 
@@ -587,14 +669,13 @@ a URL should be interpreted. The `format` returned also affects what the
 acceptable forms of source values are for a module when parsing. This can be one
 of the following:
 
-| `format`     | Description                        | Acceptable Types For `source` Returned by `getSource` or `transformSource` |
-| ------------ | ------------------------------     | -------------------------------------------------------------------------- |
-| `'builtin'`  | Load a Node.js builtin module      | Not applicable                                                             |
-| `'dynamic'`  | Use a [dynamic instantiate hook][] | Not applicable                                                             |
-| `'commonjs'` | Load a Node.js CommonJS module     | Not applicable                                                             |
-| `'json'`     | Load a JSON file                   | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][] }                      |
-| `'module'`   | Load an ES module                  | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][] }                      |
-| `'wasm'`     | Load a WebAssembly module          | { [`ArrayBuffer`][], [`TypedArray`][] }                                    |
+| `format`     | Description                    | Acceptable Types For `source` Returned by `getSource` or `transformSource` |
+| ------------ | ------------------------------ | -------------------------------------------------------------------------- |
+| `'builtin'`  | Load a Node.js builtin module  | Not applicable                                                             |
+| `'commonjs'` | Load a Node.js CommonJS module | Not applicable                                                             |
+| `'json'`     | Load a JSON file               | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][] }                      |
+| `'module'`   | Load an ES module              | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][] }                      |
+| `'wasm'`     | Load a WebAssembly module      | { [`ArrayBuffer`][], [`TypedArray`][] }                                    |
 
 Note: These types all correspond to classes defined in ECMAScript.
 
@@ -664,10 +745,6 @@ export async function getSource(url, context, defaultGetSource) {
 
 #### `transformSource(source, context, defaultTransformSource)`
 
-```console
-NODE_OPTIONS='--experimental-loader ./custom-loader.mjs' node x.js
-```
-
 > Note: The loaders API is being redesigned. This hook may disappear or its
 > signature may change. Do not rely on the API described below.
 
@@ -745,38 +822,6 @@ const require = createRequire(process.cwd() + '/<preload>');
 }
 ```
 
-#### <code>dynamicInstantiate</code> hook
-
-> Note: The loaders API is being redesigned. This hook may disappear or its
-> signature may change. Do not rely on the API described below.
-
-To create a custom dynamic module that doesn't correspond to one of the
-existing `format` interpretations, the `dynamicInstantiate` hook can be used.
-This hook is called only for modules that return `format: 'dynamic'` from
-the `getFormat` hook.
-
-```js
-/**
- * @param {string} url
- * @returns {object} response
- * @returns {array} response.exports
- * @returns {function} response.execute
- */
-export async function dynamicInstantiate(url) {
-  return {
-    exports: ['customExportName'],
-    execute: (exports) => {
-      // Get and set functions provided for pre-allocated export names
-      exports.customExportName.set('value');
-    }
-  };
-}
-```
-
-With the list of module exports provided upfront, the `execute` function will
-then be called at the exact point of module evaluation order for that module
-in the import tree.
-
 ### Examples
 
 The various loader hooks can be used together to accomplish wide-ranging
@@ -985,6 +1030,8 @@ The resolver can throw the following errors:
   subpath in the package for the given module.
 * _Package Import Not Defined_: Package imports do not define the specifier.
 * _Module Not Found_: The package or module requested does not exist.
+* _Unsupported Directory Import_: The resolved path corresponds to a directory,
+  which is not a supported target for module imports.
 
 ### Resolver Algorithm Specification
 
@@ -1242,6 +1289,8 @@ _internal_, _conditions_)
 
 ### Customizing ESM specifier resolution algorithm
 
+> Stability: 1 - Experimental
+
 The current specifier resolution does not support all default behavior of
 the CommonJS loader. One of the behavior differences is automatic resolution
 of file extensions and the ability to import directories that have an index
@@ -1263,34 +1312,39 @@ success!
 ```
 
 <!-- Note: The cjs-module-lexer link should be kept in-sync with the deps version -->
-[CommonJS]: modules.html
-[Conditional exports]: packages.html#packages_conditional_exports
+[6.1.7 Array Index]: https://tc39.es/ecma262/#integer-index
+[CommonJS]: modules.md
+[Conditional exports]: packages.md#packages_conditional_exports
+[Core modules]: modules.md#modules_core_modules
 [Dynamic `import()`]: https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports
+[ECMAScript Top-Level `await` proposal]: https://github.com/tc39/proposal-top-level-await/
 [ES Module Integration Proposal for Web Assembly]: https://github.com/webassembly/esm-integration
+[Node.js Module Resolution Algorithm]: #esm_resolver_algorithm_specification
 [Terminology]: #esm_terminology
+[URL]: https://url.spec.whatwg.org/
 [WHATWG JSON modules specification]: https://html.spec.whatwg.org/#creating-a-json-module-script
+[`"exports"`]: packages.md#packages_exports
+[`"type"`]: packages.md#packages_type
+[`ArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+[`SharedArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer
+[`TypedArray`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+[`Uint8Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
 [`data:` URLs]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
 [`export`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export
 [`import()`]: #esm_import_expressions
-[`import.meta.url`]: #esm_import_meta
+[`import.meta.resolve`]: #esm_import_meta_resolve_specifier_parent
+[`import.meta.url`]: #esm_import_meta_url
 [`import`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import
-[`module.createRequire()`]: module.html#module_module_createrequire_filename
-[`module.syncBuiltinESMExports()`]: module.html#module_module_syncbuiltinesmexports
-[`transformSource` hook]: #esm_transformsource_source_context_defaulttransformsource
-[`ArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
-[`SharedArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer
+[`module.createRequire()`]: module.md#module_module_createrequire_filename
+[`module.syncBuiltinESMExports()`]: module.md#module_module_syncbuiltinesmexports
+[`package.json`]: packages.md#packages_node_js_package_json_field_definitions
+[`process.dlopen`]: process.md#process_process_dlopen_module_filename_flags
 [`string`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String
-[`TypedArray`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
-[`Uint8Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
-[dynamic instantiate hook]: #esm_code_dynamicinstantiate_code_hook
+[`transformSource` hook]: #esm_transformsource_source_context_defaulttransformsource
 [`util.TextDecoder`]: util.md#util_class_util_textdecoder
-[cjs-module-lexer]: https://github.com/guybedford/cjs-module-lexer/tree/1.2.1
+[cjs-module-lexer]: https://github.com/guybedford/cjs-module-lexer/tree/1.2.2
+[custom https loader]: #esm_https_loader
 [special scheme]: https://url.spec.whatwg.org/#special-scheme
 [the official standard format]: https://tc39.github.io/ecma262/#sec-modules
 [transpiler loader example]: #esm_transpiler_loader
-[6.1.7 Array Index]: https://tc39.es/ecma262/#integer-index
-[Top-Level Await]: https://github.com/tc39/proposal-top-level-await
-[Core modules]: modules.html#modules_core_modules
-[`package.json`]: packages.html#packages_node_js_package_json_field_definitions
-[`"exports"`]: packages.html#packages_exports
-[`"type"`]: packages.html#packages_type
+[url.pathToFileURL]: url.md#url_url_pathtofileurl_path
diff --git a/doc/api/events.html b/doc/api/events.html
index 78cacec65ccf4af40dcfe384f246e3be526dcacc..c6320ad62a92470f20ca2c75a8fa8c2d135ef51b 100644
--- a/doc/api/events.html
+++ b/doc/api/events.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Events | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Events | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="events" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/events.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/events.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/events.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/events.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/events.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/events.html">13.x</a></li>
@@ -118,29 +133,24 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/events.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/events.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/events.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#events_events">Events</a></span>
 <ul>
 <li><a href="#events_passing_arguments_and_this_to_listeners">Passing arguments and <code>this</code> to listeners</a></li>
 <li><a href="#events_asynchronous_vs_synchronous">Asynchronous vs. synchronous</a></li>
 <li><a href="#events_handling_events_only_once">Handling events only once</a></li>
 <li><a href="#events_error_events">Error events</a></li>
-<li><a href="#events_capture_rejections_of_promises">Capture rejections of promises</a></li>
+<li><span class="stability_1"><a href="#events_capture_rejections_of_promises">Capture rejections of promises</a></span></li>
 <li><a href="#events_class_eventemitter">Class: <code>EventEmitter</code></a>
 <ul>
-<li><a href="#events_event_newlistener">Event: 'newListener'</a></li>
+<li><a href="#events_event_newlistener">Event: <code>'newListener'</code></a></li>
 <li><a href="#events_event_removelistener">Event: <code>'removeListener'</code></a></li>
-<li><span class="stability_0"><a href="#events_eventemitter_listenercount_emitter_eventname"><code>EventEmitter.listenerCount(emitter, eventName)</code></a></span></li>
-<li><a href="#events_eventemitter_defaultmaxlisteners"><code>EventEmitter.defaultMaxListeners</code></a></li>
-<li><a href="#events_eventemitter_errormonitor"><code>EventEmitter.errorMonitor</code></a></li>
 <li><a href="#events_emitter_addlistener_eventname_listener"><code>emitter.addListener(eventName, listener)</code></a></li>
 <li><a href="#events_emitter_emit_eventname_args"><code>emitter.emit(eventName[, ...args])</code></a></li>
 <li><a href="#events_emitter_eventnames"><code>emitter.eventNames()</code></a></li>
@@ -159,25 +169,77 @@
 <li><span class="stability_1"><a href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args"><code>emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])</code></a></span></li>
 </ul>
 </li>
-<li><a href="#events_events_once_emitter_name"><code>events.once(emitter, name)</code></a>
+<li><a href="#events_events_defaultmaxlisteners"><code>events.defaultMaxListeners</code></a></li>
+<li><a href="#events_events_errormonitor"><code>events.errorMonitor</code></a></li>
+<li><a href="#events_events_geteventlisteners_emitterortarget_eventname"><code>events.getEventListeners(emitterOrTarget, eventName)</code></a></li>
+<li><a href="#events_events_once_emitter_name_options"><code>events.once(emitter, name[, options])</code></a>
 <ul>
 <li><a href="#events_awaiting_multiple_events_emitted_on_process_nexttick">Awaiting multiple events emitted on <code>process.nextTick()</code></a></li>
 </ul>
 </li>
 <li><span class="stability_1"><a href="#events_events_capturerejections"><code>events.captureRejections</code></a></span></li>
-<li><span class="stability_1"><a href="#events_events_capturerejectionsymbol">events.captureRejectionSymbol</a></span></li>
-<li><a href="#events_events_on_emitter_eventname">events.on(emitter, eventName)</a></li>
+<li><span class="stability_1"><a href="#events_events_capturerejectionsymbol"><code>events.captureRejectionSymbol</code></a></span></li>
+<li><span class="stability_0"><a href="#events_events_listenercount_emitter_eventname"><code>events.listenerCount(emitter, eventName)</code></a></span></li>
+<li><a href="#events_events_on_emitter_eventname_options"><code>events.on(emitter, eventName[, options])</code></a></li>
+<li><a href="#events_events_setmaxlisteners_n_eventtargets"><code>events.setMaxListeners(n[, ...eventTargets])</code></a></li>
+<li><span class="stability_1"><a href="#events_eventtarget_and_event_api"><code>EventTarget</code> and <code>Event</code> API</a></span>
+<ul>
+<li><a href="#events_node_js_eventtarget_vs_dom_eventtarget">Node.js <code>EventTarget</code> vs. DOM <code>EventTarget</code></a></li>
+<li><a href="#events_nodeeventtarget_vs_eventemitter"><code>NodeEventTarget</code> vs. <code>EventEmitter</code></a></li>
+<li><a href="#events_event_listener">Event listener</a></li>
+<li><a href="#events_eventtarget_error_handling"><code>EventTarget</code> error handling</a></li>
+<li><a href="#events_class_event">Class: <code>Event</code></a>
+<ul>
+<li><a href="#events_event_bubbles"><code>event.bubbles</code></a></li>
+<li><a href="#events_event_cancelbubble"><code>event.cancelBubble()</code></a></li>
+<li><a href="#events_event_cancelable"><code>event.cancelable</code></a></li>
+<li><a href="#events_event_composed"><code>event.composed</code></a></li>
+<li><a href="#events_event_composedpath"><code>event.composedPath()</code></a></li>
+<li><a href="#events_event_currenttarget"><code>event.currentTarget</code></a></li>
+<li><a href="#events_event_defaultprevented"><code>event.defaultPrevented</code></a></li>
+<li><a href="#events_event_eventphase"><code>event.eventPhase</code></a></li>
+<li><a href="#events_event_istrusted"><code>event.isTrusted</code></a></li>
+<li><a href="#events_event_preventdefault"><code>event.preventDefault()</code></a></li>
+<li><a href="#events_event_returnvalue"><code>event.returnValue</code></a></li>
+<li><a href="#events_event_srcelement"><code>event.srcElement</code></a></li>
+<li><a href="#events_event_stopimmediatepropagation"><code>event.stopImmediatePropagation()</code></a></li>
+<li><a href="#events_event_stoppropagation"><code>event.stopPropagation()</code></a></li>
+<li><a href="#events_event_target"><code>event.target</code></a></li>
+<li><a href="#events_event_timestamp"><code>event.timeStamp</code></a></li>
+<li><a href="#events_event_type"><code>event.type</code></a></li>
 </ul>
 </li>
+<li><a href="#events_class_eventtarget">Class: <code>EventTarget</code></a>
+<ul>
+<li><a href="#events_eventtarget_addeventlistener_type_listener_options"><code>eventTarget.addEventListener(type, listener[, options])</code></a></li>
+<li><a href="#events_eventtarget_dispatchevent_event"><code>eventTarget.dispatchEvent(event)</code></a></li>
+<li><a href="#events_eventtarget_removeeventlistener_type_listener"><code>eventTarget.removeEventListener(type, listener)</code></a></li>
 </ul>
-      </div>
+</li>
+<li><a href="#events_class_nodeeventtarget">Class: <code>NodeEventTarget</code></a>
+<ul>
+<li><a href="#events_nodeeventtarget_addlistener_type_listener_options"><code>nodeEventTarget.addListener(type, listener[, options])</code></a></li>
+<li><a href="#events_nodeeventtarget_eventnames"><code>nodeEventTarget.eventNames()</code></a></li>
+<li><a href="#events_nodeeventtarget_listenercount_type"><code>nodeEventTarget.listenerCount(type)</code></a></li>
+<li><a href="#events_nodeeventtarget_off_type_listener"><code>nodeEventTarget.off(type, listener)</code></a></li>
+<li><a href="#events_nodeeventtarget_on_type_listener_options"><code>nodeEventTarget.on(type, listener[, options])</code></a></li>
+<li><a href="#events_nodeeventtarget_once_type_listener_options"><code>nodeEventTarget.once(type, listener[, options])</code></a></li>
+<li><a href="#events_nodeeventtarget_removealllisteners_type"><code>nodeEventTarget.removeAllListeners([type])</code></a></li>
+<li><a href="#events_nodeeventtarget_removelistener_type_listener"><code>nodeEventTarget.removeListener(type, listener)</code></a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Events<span><a class="mark" href="#events_events" id="events_events">#</a></span></h1>
+        <h2>Events<span><a class="mark" href="#events_events" id="events_events">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/events.js">lib/events.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/events.js">lib/events.js</a></p>
 <p>Much of the Node.js core API is built around an idiomatic asynchronous
 event-driven architecture in which certain kinds of objects (called "emitters")
 emit named events that cause <code>Function</code> objects ("listeners") to be called.</p>
@@ -191,28 +253,28 @@ event names are camel-cased strings but any valid JavaScript property key
 can be used.</p>
 <p>When the <code>EventEmitter</code> object emits an event, all of the functions attached
 to that specific event are called <em>synchronously</em>. Any values returned by the
-called listeners are <em>ignored</em> and will be discarded.</p>
+called listeners are <em>ignored</em> and discarded.</p>
 <p>The following example shows a simple <code>EventEmitter</code> instance with a single
 listener. The <code>eventEmitter.on()</code> method is used to register listeners, while
 the <code>eventEmitter.emit()</code> method is used to trigger the event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyEmitter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">EventEmitter</span> </span>{}
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyEmitter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {}
 
-<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'an event occurred!'</span>);
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'an event occurred!'</span>);
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>);</code></pre>
-<h2>Passing arguments and <code>this</code> to listeners<span><a class="mark" href="#events_passing_arguments_and_this_to_listeners" id="events_passing_arguments_and_this_to_listeners">#</a></span></h2>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);</code></pre>
+<section><h3>Passing arguments and <code>this</code> to listeners<span><a class="mark" href="#events_passing_arguments_and_this_to_listeners" id="events_passing_arguments_and_this_to_listeners">#</a></span></h3>
 <p>The <code>eventEmitter.emit()</code> method allows an arbitrary set of arguments to be
 passed to the listener functions. Keep in mind that when
 an ordinary listener function is called, the standard <code>this</code> keyword
 is intentionally set to reference the <code>EventEmitter</code> instance to which the
 listener is attached.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">a, b</span>) </span>{
-  <span class="hljs-built_in">console</span>.log(a, b, <span class="hljs-built_in">this</span>, <span class="hljs-built_in">this</span> === myEmitter);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-keyword">function</span>(<span class="hljs-params">a, b</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(a, b, <span class="hljs-variable language_">this</span>, <span class="hljs-variable language_">this</span> === myEmitter);
   <span class="hljs-comment">// Prints:</span>
   <span class="hljs-comment">//   a b MyEmitter {</span>
   <span class="hljs-comment">//     domain: null,</span>
@@ -220,123 +282,126 @@ myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-functio
   <span class="hljs-comment">//     _eventsCount: 1,</span>
   <span class="hljs-comment">//     _maxListeners: undefined } true</span>
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
 <p>It is possible to use ES6 Arrow Functions as listeners, however, when doing so,
 the <code>this</code> keyword will no longer reference the <code>EventEmitter</code> instance:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(a, b, <span class="hljs-built_in">this</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(a, b, <span class="hljs-variable language_">this</span>);
   <span class="hljs-comment">// Prints: a b {}</span>
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
-<h2>Asynchronous vs. synchronous<span><a class="mark" href="#events_asynchronous_vs_synchronous" id="events_asynchronous_vs_synchronous">#</a></span></h2>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
+</section><section><h3>Asynchronous vs. synchronous<span><a class="mark" href="#events_asynchronous_vs_synchronous" id="events_asynchronous_vs_synchronous">#</a></span></h3>
 <p>The <code>EventEmitter</code> calls all listeners synchronously in the order in which
 they were registered. This ensures the proper sequencing of
 events and helps avoid race conditions and logic errors. When appropriate,
 listener functions can switch to an asynchronous mode of operation using
 the <code>setImmediate()</code> or <code>process.nextTick()</code> methods:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> {
-  setImmediate(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'this happens asynchronously'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> {
+  <span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'this happens asynchronously'</span>);
   });
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
-<h2>Handling events only once<span><a class="mark" href="#events_handling_events_only_once" id="events_handling_events_only_once">#</a></span></h2>
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);</code></pre>
+</section><section><h3>Handling events only once<span><a class="mark" href="#events_handling_events_only_once" id="events_handling_events_only_once">#</a></span></h3>
 <p>When a listener is registered using the <code>eventEmitter.on()</code> method, that
-listener will be invoked <em>every time</em> the named event is emitted.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
+listener is invoked <em>every time</em> the named event is emitted.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
 <span class="hljs-keyword">let</span> m = <span class="hljs-number">0</span>;
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(++m);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(++m);
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints: 1</span>
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints: 2</span></code></pre>
 <p>Using the <code>eventEmitter.once()</code> method, it is possible to register a listener
 that is called at most once for a particular event. Once the event is emitted,
 the listener is unregistered and <em>then</em> called.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
 <span class="hljs-keyword">let</span> m = <span class="hljs-number">0</span>;
-myEmitter.once(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(++m);
+myEmitter.<span class="hljs-title function_">once</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(++m);
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints: 1</span>
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Ignored</span></code></pre>
-<h2>Error events<span><a class="mark" href="#events_error_events" id="events_error_events">#</a></span></h2>
+</section><section><h3>Error events<span><a class="mark" href="#events_error_events" id="events_error_events">#</a></span></h3>
 <p>When an error occurs within an <code>EventEmitter</code> instance, the typical action is
 for an <code>'error'</code> event to be emitted. These are treated as special cases
 within Node.js.</p>
 <p>If an <code>EventEmitter</code> does <em>not</em> have at least one listener registered for the
 <code>'error'</code> event, and an <code>'error'</code> event is emitted, the error is thrown, a
 stack trace is printed, and the Node.js process exits.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'whoops!'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'whoops!'</span>));
 <span class="hljs-comment">// Throws and crashes Node.js</span></code></pre>
 <p>To guard against crashing the Node.js process the <a href="domain.html"><code>domain</code></a> module can be
 used. (Note, however, that the <code>domain</code> module is deprecated.)</p>
 <p>As a best practice, listeners should always be added for the <code>'error'</code> events.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'whoops! there was an error'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'whoops! there was an error'</span>);
 });
-myEmitter.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'whoops!'</span>));
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'whoops!'</span>));
 <span class="hljs-comment">// Prints: whoops! there was an error</span></code></pre>
 <p>It is possible to monitor <code>'error'</code> events without consuming the emitted error
-by installing a listener using the symbol <code>errorMonitor</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(EventEmitter.errorMonitor, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  MyMonitoringTool.log(err);
+by installing a listener using the symbol <code>events.errorMonitor</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, errorMonitor } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(errorMonitor, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-title class_">MyMonitoringTool</span>.<span class="hljs-title function_">log</span>(err);
 });
-myEmitter.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'whoops!'</span>));
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'whoops!'</span>));
 <span class="hljs-comment">// Still throws and crashes Node.js</span></code></pre>
-<h2>Capture rejections of promises<span><a class="mark" href="#events_capture_rejections_of_promises" id="events_capture_rejections_of_promises">#</a></span></h2>
+</section><section><h3>Capture rejections of promises<span><a class="mark" href="#events_capture_rejections_of_promises" id="events_capture_rejections_of_promises">#</a></span></h3>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
 <p>Using <code>async</code> functions with event handlers is problematic, because it
 can lead to an unhandled rejection in case of a thrown exception:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
-ee.on(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+ee.<span class="hljs-title function_">on</span>(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
 });</code></pre>
 <p>The <code>captureRejections</code> option in the <code>EventEmitter</code> constructor or the global
 setting change this behavior, installing a <code>.then(undefined, handler)</code>
 handler on the <code>Promise</code>. This handler routes the exception
 asynchronously to the <a href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args"><code>Symbol.for('nodejs.rejection')</code></a> method
 if there is one, or to <a href="#events_error_events"><code>'error'</code></a> event handler if there is none.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ee1 = <span class="hljs-keyword">new</span> EventEmitter({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
-ee1.on(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ee1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
+ee1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
 });
 
-ee1.on(<span class="hljs-string">'error'</span>, <span class="hljs-built_in">console</span>.log);
+ee1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>);
 
-<span class="hljs-keyword">const</span> ee2 = <span class="hljs-keyword">new</span> EventEmitter({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
-ee2.on(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
+<span class="hljs-keyword">const</span> ee2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
+ee2.<span class="hljs-title function_">on</span>(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
 });
 
-ee2[<span class="hljs-built_in">Symbol</span>.for(<span class="hljs-string">'nodejs.rejection'</span>)] = <span class="hljs-built_in">console</span>.log;</code></pre>
-<p>Setting <code>EventEmitter.captureRejections = true</code> will change the default for all
+ee2[<span class="hljs-title class_">Symbol</span>.<span class="hljs-title function_">for</span>(<span class="hljs-string">'nodejs.rejection'</span>)] = <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>;</code></pre>
+<p>Setting <code>events.captureRejections = true</code> will change the default for all
 new instances of <code>EventEmitter</code>.</p>
-<pre><code class="language-js">EventEmitter.captureRejections = <span class="hljs-literal">true</span>;
-<span class="hljs-keyword">const</span> ee1 = <span class="hljs-keyword">new</span> EventEmitter();
-ee1.on(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
-  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+events.<span class="hljs-property">captureRejections</span> = <span class="hljs-literal">true</span>;
+<span class="hljs-keyword">const</span> ee1 = <span class="hljs-keyword">new</span> events.<span class="hljs-title class_">EventEmitter</span>();
+ee1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'something'</span>, <span class="hljs-keyword">async</span> (value) => {
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
 });
 
-ee1.on(<span class="hljs-string">'error'</span>, <span class="hljs-built_in">console</span>.log);</code></pre>
+ee1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>);</code></pre>
 <p>The <code>'error'</code> events that are generated by the <code>captureRejections</code> behavior
 do not have a catch handler to avoid infinite error loops: the
 recommendation is to <strong>not use <code>async</code> functions as <code>'error'</code> event handlers</strong>.</p>
-<h2>Class: <code>EventEmitter</code><span><a class="mark" href="#events_class_eventemitter" id="events_class_eventemitter">#</a></span></h2>
+</section><section><h3>Class: <code>EventEmitter</code><span><a class="mark" href="#events_class_eventemitter" id="events_class_eventemitter">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.4.0, v12.16.0</td>
 <td><p>Added captureRejections option.</p></td></tr>
 <tr><td>v0.1.26</td>
 <td><p><span>Added in: v0.1.26</span></p></td></tr>
@@ -344,16 +409,16 @@ recommendation is to <strong>not use <code>async</code> functions as <code>'erro
 </details>
 </div>
 <p>The <code>EventEmitter</code> class is defined and exposed by the <code>events</code> module:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);</code></pre>
 <p>All <code>EventEmitter</code>s emit the event <code>'newListener'</code> when new listeners are
 added and <code>'removeListener'</code> when existing listeners are removed.</p>
 <p>It supports the following option:</p>
 <ul>
 <li><code>captureRejections</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> It enables
 <a href="#events_capture_rejections_of_promises">automatic capturing of promise rejection</a>.
-Default: <code>false</code>.</li>
+<strong>Default:</strong> <code>false</code>.</li>
 </ul>
-<h3>Event: 'newListener'<span><a class="mark" href="#events_event_newlistener" id="events_event_newlistener">#</a></span></h3>
+<h4>Event: <code>'newListener'</code><span><a class="mark" href="#events_event_newlistener" id="events_event_newlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.26</span>
 </div>
@@ -363,30 +428,32 @@ Default: <code>false</code>.</li>
 </ul>
 <p>The <code>EventEmitter</code> instance will emit its own <code>'newListener'</code> event <em>before</em>
 a listener is added to its internal array of listeners.</p>
-<p>Listeners registered for the <code>'newListener'</code> event will be passed the event
+<p>Listeners registered for the <code>'newListener'</code> event are passed the event
 name and a reference to the listener being added.</p>
 <p>The fact that the event is triggered before adding the listener has a subtle
 but important side effect: any <em>additional</em> listeners registered to the same
-<code>name</code> <em>within</em> the <code>'newListener'</code> callback will be inserted <em>before</em> the
+<code>name</code> <em>within</em> the <code>'newListener'</code> callback are inserted <em>before</em> the
 listener that is in the process of being added.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">MyEmitter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {}
+
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
 <span class="hljs-comment">// Only do this once so we don't loop forever</span>
-myEmitter.once(<span class="hljs-string">'newListener'</span>, <span class="hljs-function">(<span class="hljs-params">event, listener</span>) =></span> {
+myEmitter.<span class="hljs-title function_">once</span>(<span class="hljs-string">'newListener'</span>, <span class="hljs-function">(<span class="hljs-params">event, listener</span>) =></span> {
   <span class="hljs-keyword">if</span> (event === <span class="hljs-string">'event'</span>) {
     <span class="hljs-comment">// Insert a new listener in front</span>
-    myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'B'</span>);
+    myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'B'</span>);
     });
   }
 });
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'A'</span>);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'A'</span>);
 });
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   B</span>
 <span class="hljs-comment">//   A</span></code></pre>
-<h3>Event: <code>'removeListener'</code><span><a class="mark" href="#events_event_removelistener" id="events_event_removelistener">#</a></span></h3>
+<h4>Event: <code>'removeListener'</code><span><a class="mark" href="#events_event_removelistener" id="events_event_removelistener">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -403,64 +470,7 @@ myEmitter.emit(<span class="hljs-string">'event'</span>);
 <li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The event handler function</li>
 </ul>
 <p>The <code>'removeListener'</code> event is emitted <em>after</em> the <code>listener</code> is removed.</p>
-<h3><code>EventEmitter.listenerCount(emitter, eventName)</code><span><a class="mark" href="#events_eventemitter_listenercount_emitter_eventname" id="events_eventemitter_listenercount_emitter_eventname">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.9.12</span><span>Deprecated since: v3.2.0</span>
-</div>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#events_emitter_listenercount_eventname"><code>emitter.listenerCount()</code></a> instead.</div><p></p>
-<ul>
-<li><code>emitter</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> The emitter to query</li>
-<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The event name</li>
-</ul>
-<p>A class method that returns the number of listeners for the given <code>eventName</code>
-registered on the given <code>emitter</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {});
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {});
-<span class="hljs-built_in">console</span>.log(EventEmitter.listenerCount(myEmitter, <span class="hljs-string">'event'</span>));
-<span class="hljs-comment">// Prints: 2</span></code></pre>
-<h3><code>EventEmitter.defaultMaxListeners</code><span><a class="mark" href="#events_eventemitter_defaultmaxlisteners" id="events_eventemitter_defaultmaxlisteners">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.11.2</span>
-</div>
-<p>By default, a maximum of <code>10</code> listeners can be registered for any single
-event. This limit can be changed for individual <code>EventEmitter</code> instances
-using the <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> method. To change the default
-for <em>all</em> <code>EventEmitter</code> instances, the <code>EventEmitter.defaultMaxListeners</code>
-property can be used. If this value is not a positive number, a <code>TypeError</code>
-will be thrown.</p>
-<p>Take caution when setting the <code>EventEmitter.defaultMaxListeners</code> because the
-change affects <em>all</em> <code>EventEmitter</code> instances, including those created before
-the change is made. However, calling <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> still has
-precedence over <code>EventEmitter.defaultMaxListeners</code>.</p>
-<p>This is not a hard limit. The <code>EventEmitter</code> instance will allow
-more listeners to be added but will output a trace warning to stderr indicating
-that a "possible EventEmitter memory leak" has been detected. For any single
-<code>EventEmitter</code>, the <code>emitter.getMaxListeners()</code> and <code>emitter.setMaxListeners()</code>
-methods can be used to temporarily avoid this warning:</p>
-<pre><code class="language-js">emitter.setMaxListeners(emitter.getMaxListeners() + <span class="hljs-number">1</span>);
-emitter.once(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-comment">// do stuff</span>
-  emitter.setMaxListeners(<span class="hljs-built_in">Math</span>.max(emitter.getMaxListeners() - <span class="hljs-number">1</span>, <span class="hljs-number">0</span>));
-});</code></pre>
-<p>The <a href="cli.html#cli_trace_warnings"><code>--trace-warnings</code></a> command line flag can be used to display the
-stack trace for such warnings.</p>
-<p>The emitted warning can be inspected with <a href="process.html#process_event_warning"><code>process.on('warning')</code></a> and will
-have the additional <code>emitter</code>, <code>type</code> and <code>count</code> properties, referring to
-the event emitter instance, the event’s name and the number of attached
-listeners, respectively.
-Its <code>name</code> property is set to <code>'MaxListenersExceededWarning'</code>.</p>
-<h3><code>EventEmitter.errorMonitor</code><span><a class="mark" href="#events_eventemitter_errormonitor" id="events_eventemitter_errormonitor">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.17.0</span>
-</div>
-<p>This symbol shall be used to install a listener for only monitoring <code>'error'</code>
-events. Listeners installed using this symbol are called before the regular
-<code>'error'</code> listeners are called.</p>
-<p>Installing a listener using this symbol does not change the behavior once an
-<code>'error'</code> event is emitted, therefore the process will still crash if no
-regular <code>'error'</code> listener is installed.</p>
-<h3><code>emitter.addListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_addlistener_eventname_listener" id="events_emitter_addlistener_eventname_listener">#</a></span></h3>
+<h4><code>emitter.addListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_addlistener_eventname_listener" id="events_emitter_addlistener_eventname_listener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.26</span>
 </div>
@@ -469,7 +479,7 @@ regular <code>'error'</code> listener is installed.</p>
 <li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <p>Alias for <code>emitter.on(eventName, listener)</code>.</p>
-<h3><code>emitter.emit(eventName[, ...args])</code><span><a class="mark" href="#events_emitter_emit_eventname_args" id="events_emitter_emit_eventname_args">#</a></span></h3>
+<h4><code>emitter.emit(eventName[, ...args])</code><span><a class="mark" href="#events_emitter_emit_eventname_args" id="events_emitter_emit_eventname_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.26</span>
 </div>
@@ -482,26 +492,26 @@ regular <code>'error'</code> listener is installed.</p>
 <code>eventName</code>, in the order they were registered, passing the supplied arguments
 to each.</p>
 <p>Returns <code>true</code> if the event had listeners, <code>false</code> otherwise.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> EventEmitter();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
 <span class="hljs-comment">// First listener</span>
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">firstListener</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Helloooo! first listener'</span>);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">firstListener</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Helloooo! first listener'</span>);
 });
 <span class="hljs-comment">// Second listener</span>
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">secondListener</span>(<span class="hljs-params">arg1, arg2</span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`event with parameters <span class="hljs-subst">${arg1}</span>, <span class="hljs-subst">${arg2}</span> in second listener`</span>);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">secondListener</span>(<span class="hljs-params">arg1, arg2</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`event with parameters <span class="hljs-subst">${arg1}</span>, <span class="hljs-subst">${arg2}</span> in second listener`</span>);
 });
 <span class="hljs-comment">// Third listener</span>
-myEmitter.on(<span class="hljs-string">'event'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">thirdListener</span>(<span class="hljs-params">...args</span>) </span>{
-  <span class="hljs-keyword">const</span> parameters = args.join(<span class="hljs-string">', '</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`event with parameters <span class="hljs-subst">${parameters}</span> in third listener`</span>);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">thirdListener</span>(<span class="hljs-params">...args</span>) {
+  <span class="hljs-keyword">const</span> parameters = args.<span class="hljs-title function_">join</span>(<span class="hljs-string">', '</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`event with parameters <span class="hljs-subst">${parameters}</span> in third listener`</span>);
 });
 
-<span class="hljs-built_in">console</span>.log(myEmitter.listeners(<span class="hljs-string">'event'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myEmitter.<span class="hljs-title function_">listeners</span>(<span class="hljs-string">'event'</span>));
 
-myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>);
 
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">// [</span>
@@ -512,7 +522,7 @@ myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-numbe
 <span class="hljs-comment">// Helloooo! first listener</span>
 <span class="hljs-comment">// event with parameters 1, 2 in second listener</span>
 <span class="hljs-comment">// event with parameters 1, 2, 3, 4, 5 in third listener</span></code></pre>
-<h3><code>emitter.eventNames()</code><span><a class="mark" href="#events_emitter_eventnames" id="events_emitter_eventnames">#</a></span></h3>
+<h4><code>emitter.eventNames()</code><span><a class="mark" href="#events_emitter_eventnames" id="events_emitter_eventnames">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -520,18 +530,18 @@ myEmitter.emit(<span class="hljs-string">'event'</span>, <span class="hljs-numbe
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
 </ul>
 <p>Returns an array listing the events for which the emitter has registered
-listeners. The values in the array will be strings or <code>Symbol</code>s.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
-myEE.on(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> {});
-myEE.on(<span class="hljs-string">'bar'</span>, <span class="hljs-function">() =></span> {});
+listeners. The values in the array are strings or <code>Symbol</code>s.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEE.<span class="hljs-title function_">on</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> {});
+myEE.<span class="hljs-title function_">on</span>(<span class="hljs-string">'bar'</span>, <span class="hljs-function">() =></span> {});
 
-<span class="hljs-keyword">const</span> sym = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'symbol'</span>);
-myEE.on(sym, <span class="hljs-function">() =></span> {});
+<span class="hljs-keyword">const</span> sym = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'symbol'</span>);
+myEE.<span class="hljs-title function_">on</span>(sym, <span class="hljs-function">() =></span> {});
 
-<span class="hljs-built_in">console</span>.log(myEE.eventNames());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myEE.<span class="hljs-title function_">eventNames</span>());
 <span class="hljs-comment">// Prints: [ 'foo', 'bar', Symbol(symbol) ]</span></code></pre>
-<h3><code>emitter.getMaxListeners()</code><span><a class="mark" href="#events_emitter_getmaxlisteners" id="events_emitter_getmaxlisteners">#</a></span></h3>
+<h4><code>emitter.getMaxListeners()</code><span><a class="mark" href="#events_emitter_getmaxlisteners" id="events_emitter_getmaxlisteners">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.0.0</span>
 </div>
@@ -540,8 +550,8 @@ myEE.on(sym, <span class="hljs-function">() =></span> {});
 </ul>
 <p>Returns the current max listener value for the <code>EventEmitter</code> which is either
 set by <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> or defaults to
-<a href="#events_eventemitter_defaultmaxlisteners"><code>EventEmitter.defaultMaxListeners</code></a>.</p>
-<h3><code>emitter.listenerCount(eventName)</code><span><a class="mark" href="#events_emitter_listenercount_eventname" id="events_emitter_listenercount_eventname">#</a></span></h3>
+<a href="#events_events_defaultmaxlisteners"><code>events.defaultMaxListeners</code></a>.</p>
+<h4><code>emitter.listenerCount(eventName)</code><span><a class="mark" href="#events_emitter_listenercount_eventname" id="events_emitter_listenercount_eventname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.2.0</span>
 </div>
@@ -550,7 +560,7 @@ set by <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Returns the number of listeners listening to the event named <code>eventName</code>.</p>
-<h3><code>emitter.listeners(eventName)</code><span><a class="mark" href="#events_emitter_listeners_eventname" id="events_emitter_listeners_eventname">#</a></span></h3>
+<h4><code>emitter.listeners(eventName)</code><span><a class="mark" href="#events_emitter_listeners_eventname" id="events_emitter_listeners_eventname">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -567,12 +577,12 @@ set by <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
 </ul>
 <p>Returns a copy of the array of listeners for the event named <code>eventName</code>.</p>
-<pre><code class="language-js">server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'someone connected!'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'someone connected!'</span>);
 });
-<span class="hljs-built_in">console</span>.log(util.inspect(server.listeners(<span class="hljs-string">'connection'</span>)));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(util.<span class="hljs-title function_">inspect</span>(server.<span class="hljs-title function_">listeners</span>(<span class="hljs-string">'connection'</span>)));
 <span class="hljs-comment">// Prints: [ [Function] ]</span></code></pre>
-<h3><code>emitter.off(eventName, listener)</code><span><a class="mark" href="#events_emitter_off_eventname_listener" id="events_emitter_off_eventname_listener">#</a></span></h3>
+<h4><code>emitter.off(eventName, listener)</code><span><a class="mark" href="#events_emitter_off_eventname_listener" id="events_emitter_off_eventname_listener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -582,7 +592,7 @@ set by <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners
 <li>Returns: <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
 <p>Alias for <a href="#events_emitter_removelistener_eventname_listener"><code>emitter.removeListener()</code></a>.</p>
-<h3><code>emitter.on(eventName, listener)</code><span><a class="mark" href="#events_emitter_on_eventname_listener" id="events_emitter_on_eventname_listener">#</a></span></h3>
+<h4><code>emitter.on(eventName, listener)</code><span><a class="mark" href="#events_emitter_on_eventname_listener" id="events_emitter_on_eventname_listener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.101</span>
 </div>
@@ -596,21 +606,21 @@ event named <code>eventName</code>. No checks are made to see if the <code>liste
 already been added. Multiple calls passing the same combination of <code>eventName</code>
 and <code>listener</code> will result in the <code>listener</code> being added, and called, multiple
 times.</p>
-<pre><code class="language-js">server.on(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'someone connected!'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'someone connected!'</span>);
 });</code></pre>
 <p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
 <p>By default, event listeners are invoked in the order they are added. The
 <code>emitter.prependListener()</code> method can be used as an alternative to add the
 event listener to the beginning of the listeners array.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
-myEE.on(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'a'</span>));
-myEE.prependListener(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'b'</span>));
-myEE.emit(<span class="hljs-string">'foo'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEE.<span class="hljs-title function_">on</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a'</span>));
+myEE.<span class="hljs-title function_">prependListener</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'b'</span>));
+myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   b</span>
 <span class="hljs-comment">//   a</span></code></pre>
-<h3><code>emitter.once(eventName, listener)</code><span><a class="mark" href="#events_emitter_once_eventname_listener" id="events_emitter_once_eventname_listener">#</a></span></h3>
+<h4><code>emitter.once(eventName, listener)</code><span><a class="mark" href="#events_emitter_once_eventname_listener" id="events_emitter_once_eventname_listener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -621,21 +631,21 @@ myEE.emit(<span class="hljs-string">'foo'</span>);
 </ul>
 <p>Adds a <strong>one-time</strong> <code>listener</code> function for the event named <code>eventName</code>. The
 next time <code>eventName</code> is triggered, this listener is removed and then invoked.</p>
-<pre><code class="language-js">server.once(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Ah, we have our first user!'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">once</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Ah, we have our first user!'</span>);
 });</code></pre>
 <p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
 <p>By default, event listeners are invoked in the order they are added. The
 <code>emitter.prependOnceListener()</code> method can be used as an alternative to add the
 event listener to the beginning of the listeners array.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
-myEE.once(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'a'</span>));
-myEE.prependOnceListener(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'b'</span>));
-myEE.emit(<span class="hljs-string">'foo'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEE.<span class="hljs-title function_">once</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a'</span>));
+myEE.<span class="hljs-title function_">prependOnceListener</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'b'</span>));
+myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   b</span>
 <span class="hljs-comment">//   a</span></code></pre>
-<h3><code>emitter.prependListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_prependlistener_eventname_listener" id="events_emitter_prependlistener_eventname_listener">#</a></span></h3>
+<h4><code>emitter.prependListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_prependlistener_eventname_listener" id="events_emitter_prependlistener_eventname_listener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -649,11 +659,11 @@ event named <code>eventName</code>. No checks are made to see if the <code>liste
 already been added. Multiple calls passing the same combination of <code>eventName</code>
 and <code>listener</code> will result in the <code>listener</code> being added, and called, multiple
 times.</p>
-<pre><code class="language-js">server.prependListener(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'someone connected!'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">prependListener</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'someone connected!'</span>);
 });</code></pre>
 <p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.prependOnceListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_prependoncelistener_eventname_listener" id="events_emitter_prependoncelistener_eventname_listener">#</a></span></h3>
+<h4><code>emitter.prependOnceListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_prependoncelistener_eventname_listener" id="events_emitter_prependoncelistener_eventname_listener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -665,11 +675,11 @@ times.</p>
 <p>Adds a <strong>one-time</strong> <code>listener</code> function for the event named <code>eventName</code> to the
 <em>beginning</em> of the listeners array. The next time <code>eventName</code> is triggered, this
 listener is removed, and then invoked.</p>
-<pre><code class="language-js">server.prependOnceListener(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Ah, we have our first user!'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">prependOnceListener</span>(<span class="hljs-string">'connection'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Ah, we have our first user!'</span>);
 });</code></pre>
 <p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.removeAllListeners([eventName])</code><span><a class="mark" href="#events_emitter_removealllisteners_eventname" id="events_emitter_removealllisteners_eventname">#</a></span></h3>
+<h4><code>emitter.removeAllListeners([eventName])</code><span><a class="mark" href="#events_emitter_removealllisteners_eventname" id="events_emitter_removealllisteners_eventname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.26</span>
 </div>
@@ -682,7 +692,7 @@ listener is removed, and then invoked.</p>
 particularly when the <code>EventEmitter</code> instance was created by some other
 component or module (e.g. sockets or file streams).</p>
 <p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.removeListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_removelistener_eventname_listener" id="events_emitter_removelistener_eventname_listener">#</a></span></h3>
+<h4><code>emitter.removeListener(eventName, listener)</code><span><a class="mark" href="#events_emitter_removelistener_eventname_listener" id="events_emitter_removelistener_eventname_listener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.26</span>
 </div>
@@ -693,46 +703,46 @@ component or module (e.g. sockets or file streams).</p>
 </ul>
 <p>Removes the specified <code>listener</code> from the listener array for the event named
 <code>eventName</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> callback = <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'someone connected!'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title function_">callback</span> = (<span class="hljs-params">stream</span>) => {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'someone connected!'</span>);
 };
-server.on(<span class="hljs-string">'connection'</span>, callback);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connection'</span>, callback);
 <span class="hljs-comment">// ...</span>
-server.removeListener(<span class="hljs-string">'connection'</span>, callback);</code></pre>
+server.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'connection'</span>, callback);</code></pre>
 <p><code>removeListener()</code> will remove, at most, one instance of a listener from the
 listener array. If any single listener has been added multiple times to the
 listener array for the specified <code>eventName</code>, then <code>removeListener()</code> must be
 called multiple times to remove each instance.</p>
-<p>Once an event has been emitted, all listeners attached to it at the
-time of emitting will be called in order. This implies that any
+<p>Once an event is emitted, all listeners attached to it at the
+time of emitting are called in order. This implies that any
 <code>removeListener()</code> or <code>removeAllListeners()</code> calls <em>after</em> emitting and
 <em>before</em> the last listener finishes execution will not remove them from
-<code>emit()</code> in progress. Subsequent events will behave as expected.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> MyEmitter();
+<code>emit()</code> in progress. Subsequent events behave as expected.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyEmitter</span>();
 
-<span class="hljs-keyword">const</span> callbackA = <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'A'</span>);
-  myEmitter.removeListener(<span class="hljs-string">'event'</span>, callbackB);
+<span class="hljs-keyword">const</span> <span class="hljs-title function_">callbackA</span> = (<span class="hljs-params"></span>) => {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'A'</span>);
+  myEmitter.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'event'</span>, callbackB);
 };
 
-<span class="hljs-keyword">const</span> callbackB = <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'B'</span>);
+<span class="hljs-keyword">const</span> <span class="hljs-title function_">callbackB</span> = (<span class="hljs-params"></span>) => {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'B'</span>);
 };
 
-myEmitter.on(<span class="hljs-string">'event'</span>, callbackA);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, callbackA);
 
-myEmitter.on(<span class="hljs-string">'event'</span>, callbackB);
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, callbackB);
 
 <span class="hljs-comment">// callbackA removes listener callbackB but it will still be called.</span>
 <span class="hljs-comment">// Internal listener array at time of emit [callbackA, callbackB]</span>
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   A</span>
 <span class="hljs-comment">//   B</span>
 
 <span class="hljs-comment">// callbackB is now removed.</span>
 <span class="hljs-comment">// Internal listener array [callbackA]</span>
-myEmitter.emit(<span class="hljs-string">'event'</span>);
+myEmitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'event'</span>);
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   A</span></code></pre>
 <p>Because listeners are managed using an internal array, calling this will
@@ -744,20 +754,20 @@ the <code>emitter.listeners()</code> method will need to be recreated.</p>
 event (as in the example below), <code>removeListener()</code> will remove the most
 recently added instance. In the example the <code>once('ping')</code>
 listener is removed:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">pong</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'pong'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">pong</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'pong'</span>);
 }
 
-ee.on(<span class="hljs-string">'ping'</span>, pong);
-ee.once(<span class="hljs-string">'ping'</span>, pong);
-ee.removeListener(<span class="hljs-string">'ping'</span>, pong);
+ee.<span class="hljs-title function_">on</span>(<span class="hljs-string">'ping'</span>, pong);
+ee.<span class="hljs-title function_">once</span>(<span class="hljs-string">'ping'</span>, pong);
+ee.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'ping'</span>, pong);
 
-ee.emit(<span class="hljs-string">'ping'</span>);
-ee.emit(<span class="hljs-string">'ping'</span>);</code></pre>
+ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'ping'</span>);
+ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'ping'</span>);</code></pre>
 <p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.setMaxListeners(n)</code><span><a class="mark" href="#events_emitter_setmaxlisteners_n" id="events_emitter_setmaxlisteners_n">#</a></span></h3>
+<h4><code>emitter.setMaxListeners(n)</code><span><a class="mark" href="#events_emitter_setmaxlisteners_n" id="events_emitter_setmaxlisteners_n">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.5</span>
 </div>
@@ -771,7 +781,7 @@ memory leaks. The <code>emitter.setMaxListeners()</code> method allows the limit
 modified for this specific <code>EventEmitter</code> instance. The value can be set to
 <code>Infinity</code> (or <code>0</code>) to indicate an unlimited number of listeners.</p>
 <p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>
-<h3><code>emitter.rawListeners(eventName)</code><span><a class="mark" href="#events_emitter_rawlisteners_eventname" id="events_emitter_rawlisteners_eventname">#</a></span></h3>
+<h4><code>emitter.rawListeners(eventName)</code><span><a class="mark" href="#events_emitter_rawlisteners_eventname" id="events_emitter_rawlisteners_eventname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -781,30 +791,30 @@ modified for this specific <code>EventEmitter</code> instance. The value can be
 </ul>
 <p>Returns a copy of the array of listeners for the event named <code>eventName</code>,
 including any wrappers (such as those created by <code>.once()</code>).</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> emitter = <span class="hljs-keyword">new</span> EventEmitter();
-emitter.once(<span class="hljs-string">'log'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'log once'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> emitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+emitter.<span class="hljs-title function_">once</span>(<span class="hljs-string">'log'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'log once'</span>));
 
 <span class="hljs-comment">// Returns a new Array with a function `onceWrapper` which has a property</span>
 <span class="hljs-comment">// `listener` which contains the original listener bound above</span>
-<span class="hljs-keyword">const</span> listeners = emitter.rawListeners(<span class="hljs-string">'log'</span>);
+<span class="hljs-keyword">const</span> listeners = emitter.<span class="hljs-title function_">rawListeners</span>(<span class="hljs-string">'log'</span>);
 <span class="hljs-keyword">const</span> logFnWrapper = listeners[<span class="hljs-number">0</span>];
 
 <span class="hljs-comment">// Logs "log once" to the console and does not unbind the `once` event</span>
-logFnWrapper.listener();
+logFnWrapper.<span class="hljs-title function_">listener</span>();
 
 <span class="hljs-comment">// Logs "log once" to the console and removes the listener</span>
-logFnWrapper();
+<span class="hljs-title function_">logFnWrapper</span>();
 
-emitter.on(<span class="hljs-string">'log'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'log persistently'</span>));
+emitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'log'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'log persistently'</span>));
 <span class="hljs-comment">// Will return a new Array with a single function bound by `.on()` above</span>
-<span class="hljs-keyword">const</span> newListeners = emitter.rawListeners(<span class="hljs-string">'log'</span>);
+<span class="hljs-keyword">const</span> newListeners = emitter.<span class="hljs-title function_">rawListeners</span>(<span class="hljs-string">'log'</span>);
 
 <span class="hljs-comment">// Logs "log persistently" twice</span>
 newListeners[<span class="hljs-number">0</span>]();
-emitter.emit(<span class="hljs-string">'log'</span>);</code></pre>
-<h3><code>emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])</code><span><a class="mark" href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args" id="events_emitter_symbol_for_nodejs_rejection_err_eventname_args">#</a></span></h3>
+emitter.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'log'</span>);</code></pre>
+<h4><code>emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])</code><span><a class="mark" href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args" id="events_emitter_symbol_for_nodejs_rejection_err_eventname_args">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
 <ul>
@@ -817,29 +827,111 @@ promise rejection happens when emitting an event and
 <a href="#events_capture_rejections_of_promises"><code>captureRejections</code></a> is enabled on the emitter.
 It is possible to use <a href="#events_events_capturerejectionsymbol"><code>events.captureRejectionSymbol</code></a> in
 place of <code>Symbol.for('nodejs.rejection')</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { EventEmitter, captureRejectionSymbol } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, captureRejectionSymbol } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyClass</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">EventEmitter</span> </span>{
-  <span class="hljs-keyword">constructor</span>() {
-    <span class="hljs-built_in">super</span>({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyClass</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-variable language_">super</span>({ <span class="hljs-attr">captureRejections</span>: <span class="hljs-literal">true</span> });
   }
 
   [captureRejectionSymbol](err, event, ...args) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'rejection happened for'</span>, event, <span class="hljs-string">'with'</span>, err, ...args);
-    <span class="hljs-built_in">this</span>.destroy(err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'rejection happened for'</span>, event, <span class="hljs-string">'with'</span>, err, ...args);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">destroy</span>(err);
   }
 
-  destroy(err) {
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">err</span>) {
     <span class="hljs-comment">// Tear the resource down here.</span>
   }
 }</code></pre>
-<h2><code>events.once(emitter, name)</code><span><a class="mark" href="#events_events_once_emitter_name" id="events_events_once_emitter_name">#</a></span></h2>
+</section><section><h3><code>events.defaultMaxListeners</code><span><a class="mark" href="#events_events_defaultmaxlisteners" id="events_events_defaultmaxlisteners">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v0.11.2</span>
+</div>
+<p>By default, a maximum of <code>10</code> listeners can be registered for any single
+event. This limit can be changed for individual <code>EventEmitter</code> instances
+using the <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> method. To change the default
+for <em>all</em> <code>EventEmitter</code> instances, the <code>events.defaultMaxListeners</code>
+property can be used. If this value is not a positive number, a <code>RangeError</code>
+is thrown.</p>
+<p>Take caution when setting the <code>events.defaultMaxListeners</code> because the
+change affects <em>all</em> <code>EventEmitter</code> instances, including those created before
+the change is made. However, calling <a href="#events_emitter_setmaxlisteners_n"><code>emitter.setMaxListeners(n)</code></a> still has
+precedence over <code>events.defaultMaxListeners</code>.</p>
+<p>This is not a hard limit. The <code>EventEmitter</code> instance will allow
+more listeners to be added but will output a trace warning to stderr indicating
+that a "possible EventEmitter memory leak" has been detected. For any single
+<code>EventEmitter</code>, the <code>emitter.getMaxListeners()</code> and <code>emitter.setMaxListeners()</code>
+methods can be used to temporarily avoid this warning:</p>
+<pre><code class="language-js">emitter.<span class="hljs-title function_">setMaxListeners</span>(emitter.<span class="hljs-title function_">getMaxListeners</span>() + <span class="hljs-number">1</span>);
+emitter.<span class="hljs-title function_">once</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-comment">// do stuff</span>
+  emitter.<span class="hljs-title function_">setMaxListeners</span>(<span class="hljs-title class_">Math</span>.<span class="hljs-title function_">max</span>(emitter.<span class="hljs-title function_">getMaxListeners</span>() - <span class="hljs-number">1</span>, <span class="hljs-number">0</span>));
+});</code></pre>
+<p>The <a href="cli.html#cli_trace_warnings"><code>--trace-warnings</code></a> command-line flag can be used to display the
+stack trace for such warnings.</p>
+<p>The emitted warning can be inspected with <a href="process.html#process_event_warning"><code>process.on('warning')</code></a> and will
+have the additional <code>emitter</code>, <code>type</code> and <code>count</code> properties, referring to
+the event emitter instance, the event’s name and the number of attached
+listeners, respectively.
+Its <code>name</code> property is set to <code>'MaxListenersExceededWarning'</code>.</p>
+</section><section><h3><code>events.errorMonitor</code><span><a class="mark" href="#events_events_errormonitor" id="events_events_errormonitor">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v13.6.0, v12.17.0</span>
+</div>
+<p>This symbol shall be used to install a listener for only monitoring <code>'error'</code>
+events. Listeners installed using this symbol are called before the regular
+<code>'error'</code> listeners are called.</p>
+<p>Installing a listener using this symbol does not change the behavior once an
+<code>'error'</code> event is emitted, therefore the process will still crash if no
+regular <code>'error'</code> listener is installed.</p>
+</section><section><h3><code>events.getEventListeners(emitterOrTarget, eventName)</code><span><a class="mark" href="#events_events_geteventlisteners_emitterortarget_eventname" id="events_events_geteventlisteners_emitterortarget_eventname">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>emitterOrTarget</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> | <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a></li>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
+</ul>
+<p>Returns a copy of the array of listeners for the event named <code>eventName</code>.</p>
+<p>For <code>EventEmitter</code>s this behaves exactly the same as calling <code>.listeners</code> on
+the emitter.</p>
+<p>For <code>EventTarget</code>s this is the only way to get the event listeners for the
+event target. This is useful for debugging and diagnostic purposes.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { getEventListeners, <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+
+{
+  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+  <span class="hljs-keyword">const</span> <span class="hljs-title function_">listener</span> = (<span class="hljs-params"></span>) => <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Events are fun'</span>);
+  ee.<span class="hljs-title function_">on</span>(<span class="hljs-string">'foo'</span>, listener);
+  <span class="hljs-title function_">getEventListeners</span>(ee, <span class="hljs-string">'foo'</span>); <span class="hljs-comment">// [listener]</span>
+}
+{
+  <span class="hljs-keyword">const</span> et = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventTarget</span>();
+  <span class="hljs-keyword">const</span> <span class="hljs-title function_">listener</span> = (<span class="hljs-params"></span>) => <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Events are fun'</span>);
+  et.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, listener);
+  <span class="hljs-title function_">getEventListeners</span>(et, <span class="hljs-string">'foo'</span>); <span class="hljs-comment">// [listener]</span>
+}</code></pre>
+</section><section><h3><code>events.once(emitter, name[, options])</code><span><a class="mark" href="#events_events_once_emitter_name_options" id="events_events_once_emitter_name_options">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.13.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>The <code>signal</code> option is supported now.</p></td></tr>
+<tr><td>v11.13.0, v10.16.0</td>
+<td><p><span>Added in: v11.13.0, v10.16.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>emitter</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Can be used to cancel waiting for the event.</li>
+</ul>
+</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
 <p>Creates a <code>Promise</code> that is fulfilled when the <code>EventEmitter</code> emits the given
@@ -849,130 +941,174 @@ given event.</p>
 <p>This method is intentionally generic and works with the web platform
 <a href="https://dom.spec.whatwg.org/#interface-eventtarget">EventTarget</a> interface, which has no special
 <code>'error'</code> event semantics and does not listen to the <code>'error'</code> event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { once, EventEmitter } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { once, <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">run</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">run</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-  process.nextTick(<span class="hljs-function">() =></span> {
-    ee.emit(<span class="hljs-string">'myevent'</span>, <span class="hljs-number">42</span>);
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'myevent'</span>, <span class="hljs-number">42</span>);
   });
 
-  <span class="hljs-keyword">const</span> [value] = <span class="hljs-keyword">await</span> once(ee, <span class="hljs-string">'myevent'</span>);
-  <span class="hljs-built_in">console</span>.log(value);
+  <span class="hljs-keyword">const</span> [value] = <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(ee, <span class="hljs-string">'myevent'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value);
 
-  <span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'kaboom'</span>);
-  process.nextTick(<span class="hljs-function">() =></span> {
-    ee.emit(<span class="hljs-string">'error'</span>, err);
+  <span class="hljs-keyword">const</span> err = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'kaboom'</span>);
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, err);
   });
 
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">await</span> once(ee, <span class="hljs-string">'myevent'</span>);
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(ee, <span class="hljs-string">'myevent'</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'error happened'</span>, err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'error happened'</span>, err);
   }
 }
 
-run();</code></pre>
+<span class="hljs-title function_">run</span>();</code></pre>
 <p>The special handling of the <code>'error'</code> event is only used when <code>events.once()</code>
 is used to wait for another event. If <code>events.once()</code> is used to wait for the
 '<code>error'</code> event itself, then it is treated as any other kind of event without
 special handling:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { EventEmitter, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-once(ee, <span class="hljs-string">'error'</span>)
-  .then(<span class="hljs-function">(<span class="hljs-params">[err]</span>) =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'ok'</span>, err.message))
-  .catch(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'error'</span>, err.message));
+<span class="hljs-title function_">once</span>(ee, <span class="hljs-string">'error'</span>)
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">[err]</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'ok'</span>, err.<span class="hljs-property">message</span>))
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'error'</span>, err.<span class="hljs-property">message</span>));
 
-ee.emit(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'boom'</span>));
+ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'boom'</span>));
 
 <span class="hljs-comment">// Prints: ok boom</span></code></pre>
-<h3>Awaiting multiple events emitted on <code>process.nextTick()</code><span><a class="mark" href="#events_awaiting_multiple_events_emitted_on_process_nexttick" id="events_awaiting_multiple_events_emitted_on_process_nexttick">#</a></span></h3>
+<p>An <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> can be used to cancel waiting for the event:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+
+<span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params">emitter, event, signal</span>) {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(emitter, event, { signal });
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'event emitted!'</span>);
+  } <span class="hljs-keyword">catch</span> (error) {
+    <span class="hljs-keyword">if</span> (error.<span class="hljs-property">name</span> === <span class="hljs-string">'AbortError'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Waiting for the event was canceled!'</span>);
+    } <span class="hljs-keyword">else</span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'There was an error'</span>, error.<span class="hljs-property">message</span>);
+    }
+  }
+}
+
+<span class="hljs-title function_">foo</span>(ee, <span class="hljs-string">'foo'</span>, ac.<span class="hljs-property">signal</span>);
+ac.<span class="hljs-title function_">abort</span>(); <span class="hljs-comment">// Abort waiting for the event</span>
+ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>); <span class="hljs-comment">// Prints: Waiting for the event was canceled!</span></code></pre>
+<h4>Awaiting multiple events emitted on <code>process.nextTick()</code><span><a class="mark" href="#events_awaiting_multiple_events_emitted_on_process_nexttick" id="events_awaiting_multiple_events_emitted_on_process_nexttick">#</a></span></h4>
 <p>There is an edge case worth noting when using the <code>events.once()</code> function
 to await multiple events emitted on in the same batch of <code>process.nextTick()</code>
 operations, or whenever multiple events are emitted synchronously. Specifically,
 because the <code>process.nextTick()</code> queue is drained before the <code>Promise</code> microtask
 queue, and because <code>EventEmitter</code> emits all events synchronously, it is possible
 for <code>events.once()</code> to miss an event.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { EventEmitter, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> once(myEE, <span class="hljs-string">'bar'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'bar'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(myEE, <span class="hljs-string">'bar'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'bar'</span>);
 
   <span class="hljs-comment">// This Promise will never resolve because the 'foo' event will</span>
   <span class="hljs-comment">// have already been emitted before the Promise is created.</span>
-  <span class="hljs-keyword">await</span> once(myEE, <span class="hljs-string">'foo'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'foo'</span>);
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(myEE, <span class="hljs-string">'foo'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo'</span>);
 }
 
-process.nextTick(<span class="hljs-function">() =></span> {
-  myEE.emit(<span class="hljs-string">'bar'</span>);
-  myEE.emit(<span class="hljs-string">'foo'</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+  myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'bar'</span>);
+  myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>);
 });
 
-foo().then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'done'</span>));</code></pre>
+<span class="hljs-title function_">foo</span>().<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'done'</span>));</code></pre>
 <p>To catch both events, create each of the Promises <em>before</em> awaiting either
 of them, then it becomes possible to use <code>Promise.all()</code>, <code>Promise.race()</code>,
 or <code>Promise.allSettled()</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { EventEmitter, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-keyword">const</span> myEE = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> <span class="hljs-built_in">Promise</span>.all([once(myEE, <span class="hljs-string">'bar'</span>), once(myEE, <span class="hljs-string">'foo'</span>)]);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">all</span>([<span class="hljs-title function_">once</span>(myEE, <span class="hljs-string">'bar'</span>), <span class="hljs-title function_">once</span>(myEE, <span class="hljs-string">'foo'</span>)]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
 }
 
-process.nextTick(<span class="hljs-function">() =></span> {
-  myEE.emit(<span class="hljs-string">'bar'</span>);
-  myEE.emit(<span class="hljs-string">'foo'</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+  myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'bar'</span>);
+  myEE.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>);
 });
 
-foo().then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'done'</span>));</code></pre>
-<h2><code>events.captureRejections</code><span><a class="mark" href="#events_events_capturerejections" id="events_events_capturerejections">#</a></span></h2>
+<span class="hljs-title function_">foo</span>().<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'done'</span>));</code></pre>
+</section><section><h3><code>events.captureRejections</code><span><a class="mark" href="#events_events_capturerejections" id="events_events_capturerejections">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
 <p>Value: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></p>
 <p>Change the default <code>captureRejections</code> option on all new <code>EventEmitter</code> objects.</p>
-<h2>events.captureRejectionSymbol<span><a class="mark" href="#events_events_capturerejectionsymbol" id="events_events_capturerejectionsymbol">#</a></span></h2>
+</section><section><h3><code>events.captureRejectionSymbol</code><span><a class="mark" href="#events_events_capturerejectionsymbol" id="events_events_capturerejectionsymbol">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - captureRejections is experimental.</div><p></p>
 <p>Value: <code>Symbol.for('nodejs.rejection')</code></p>
 <p>See how to write a custom <a href="#events_emitter_symbol_for_nodejs_rejection_err_eventname_args">rejection handler</a>.</p>
-<h2>events.on(emitter, eventName)<a class="srclink" href="https://github.com/nodejs/node/blob/360a294f1f19cb8ccc9505d44a2e9efff414a5c7/lib/events.js#L674">[src]</a><span><a class="mark" href="#events_events_on_emitter_eventname" id="events_events_on_emitter_eventname">#</a></span></h2>
+</section><section><h3><code>events.listenerCount(emitter, eventName)</code><span><a class="mark" href="#events_events_listenercount_emitter_eventname" id="events_events_listenercount_emitter_eventname">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v0.9.12</span><span>Deprecated since: v3.2.0</span>
+</div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#events_emitter_listenercount_eventname"><code>emitter.listenerCount()</code></a> instead.</div><p></p>
+<ul>
+<li><code>emitter</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> The emitter to query</li>
+<li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The event name</li>
+</ul>
+<p>A class method that returns the number of listeners for the given <code>eventName</code>
+registered on the given <code>emitter</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">EventEmitter</span>, listenerCount } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> myEmitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {});
+myEmitter.<span class="hljs-title function_">on</span>(<span class="hljs-string">'event'</span>, <span class="hljs-function">() =></span> {});
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">listenerCount</span>(myEmitter, <span class="hljs-string">'event'</span>));
+<span class="hljs-comment">// Prints: 2</span></code></pre>
+</section><section><h3><code>events.on(emitter, eventName[, options])</code><span><a class="mark" href="#events_events_on_emitter_eventname_options" id="events_events_on_emitter_eventname_options">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v13.6.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>emitter</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 <li><code>eventName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> The name of the event being listened for</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Can be used to cancel awaiting events.</li>
+</ul>
+</li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterator-interface" class="type">&#x3C;AsyncIterator></a> that iterates <code>eventName</code> events emitted by the <code>emitter</code></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { on, EventEmitter } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { on, <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
 (<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> EventEmitter();
+  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
   <span class="hljs-comment">// Emit later on</span>
-  process.nextTick(<span class="hljs-function">() =></span> {
-    ee.emit(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
-    ee.emit(<span class="hljs-string">'foo'</span>, <span class="hljs-number">42</span>);
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-number">42</span>);
   });
 
-  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> event <span class="hljs-keyword">of</span> on(ee, <span class="hljs-string">'foo'</span>)) {
+  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> event <span class="hljs-keyword">of</span> <span class="hljs-title function_">on</span>(ee, <span class="hljs-string">'foo'</span>)) {
     <span class="hljs-comment">// The execution of this inner block is synchronous and it</span>
     <span class="hljs-comment">// processes one event at a time (even with await). Do not use</span>
     <span class="hljs-comment">// if concurrent execution is required.</span>
-    <span class="hljs-built_in">console</span>.log(event); <span class="hljs-comment">// prints ['bar'] [42]</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event); <span class="hljs-comment">// prints ['bar'] [42]</span>
   }
   <span class="hljs-comment">// Unreachable here</span>
 })();</code></pre>
@@ -980,9 +1116,541 @@ foo().then(<span class="hljs-function">() =></span> <span class="hljs-built_in">
 if the <code>EventEmitter</code> emits <code>'error'</code>. It removes all listeners when
 exiting the loop. The <code>value</code> returned by each iteration is an array
 composed of the emitted event arguments.</p>
+<p>An <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> can be used to cancel waiting on events:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { on, <span class="hljs-title class_">EventEmitter</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+
+(<span class="hljs-keyword">async</span> () => {
+  <span class="hljs-keyword">const</span> ee = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+
+  <span class="hljs-comment">// Emit later on</span>
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
+    ee.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-number">42</span>);
+  });
+
+  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> event <span class="hljs-keyword">of</span> <span class="hljs-title function_">on</span>(ee, <span class="hljs-string">'foo'</span>, { <span class="hljs-attr">signal</span>: ac.<span class="hljs-property">signal</span> })) {
+    <span class="hljs-comment">// The execution of this inner block is synchronous and it</span>
+    <span class="hljs-comment">// processes one event at a time (even with await). Do not use</span>
+    <span class="hljs-comment">// if concurrent execution is required.</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event); <span class="hljs-comment">// prints ['bar'] [42]</span>
+  }
+  <span class="hljs-comment">// Unreachable here</span>
+})();
+
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> ac.<span class="hljs-title function_">abort</span>());</code></pre>
+</section><section><h3><code>events.setMaxListeners(n[, ...eventTargets])</code><span><a class="mark" href="#events_events_setmaxlisteners_n_eventtargets" id="events_events_setmaxlisteners_n_eventtargets">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>n</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A non-negative number. The maximum number of listeners per
+<code>EventTarget</code> event.</li>
+<li><code>...eventsTargets</code> <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget[]></a> | <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter[]></a> Zero or more <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a>
+or <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> instances. If none are specified, <code>n</code> is set as the default
+max for all newly created <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> and <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> objects.</li>
+</ul>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  setMaxListeners,
+  <span class="hljs-title class_">EventEmitter</span>
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+
+<span class="hljs-keyword">const</span> target = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventTarget</span>();
+<span class="hljs-keyword">const</span> emitter = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
+
+<span class="hljs-title function_">setMaxListeners</span>(<span class="hljs-number">5</span>, target, emitter);</code></pre>
+<p><a id="event-target-and-event-api"></a></p>
+</section><section><h3><code>EventTarget</code> and <code>Event</code> API<span><a class="mark" href="#events_eventtarget_and_event_api" id="events_eventtarget_and_event_api">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>The <code>EventTarget</code> and <code>Event</code> objects are a Node.js-specific implementation
+of the <a href="https://dom.spec.whatwg.org/#eventtarget"><code>EventTarget</code> Web API</a> that are exposed by some Node.js core APIs.
+Neither the <code>EventTarget</code> nor <code>Event</code> classes are available for end
+user code to create.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> target = <span class="hljs-title function_">getEventTargetSomehow</span>();
+
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">(<span class="hljs-params">event</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo event happened!'</span>);
+});</code></pre>
+<h4>Node.js <code>EventTarget</code> vs. DOM <code>EventTarget</code><span><a class="mark" href="#events_node_js_eventtarget_vs_dom_eventtarget" id="events_node_js_eventtarget_vs_dom_eventtarget">#</a></span></h4>
+<p>There are two key differences between the Node.js <code>EventTarget</code> and the
+<a href="https://dom.spec.whatwg.org/#eventtarget"><code>EventTarget</code> Web API</a>:</p>
+<ol>
+<li>Whereas DOM <code>EventTarget</code> instances <em>may</em> be hierarchical, there is no
+concept of hierarchy and event propagation in Node.js. That is, an event
+dispatched to an <code>EventTarget</code> does not propagate through a hierarchy of
+nested target objects that may each have their own set of handlers for the
+event.</li>
+<li>In the Node.js <code>EventTarget</code>, if an event listener is an async function
+or returns a <code>Promise</code>, and the returned <code>Promise</code> rejects, the rejection
+is automatically captured and handled the same way as a listener that
+throws synchronously (see <a href="#events_eventtarget_error_handling"><code>EventTarget</code> error handling</a> for details).</li>
+</ol>
+<h4><code>NodeEventTarget</code> vs. <code>EventEmitter</code><span><a class="mark" href="#events_nodeeventtarget_vs_eventemitter" id="events_nodeeventtarget_vs_eventemitter">#</a></span></h4>
+<p>The <code>NodeEventTarget</code> object implements a modified subset of the
+<code>EventEmitter</code> API that allows it to closely <em>emulate</em> an <code>EventEmitter</code> in
+certain situations. A <code>NodeEventTarget</code> is <em>not</em> an instance of <code>EventEmitter</code>
+and cannot be used in place of an <code>EventEmitter</code> in most cases.</p>
+<ol>
+<li>Unlike <code>EventEmitter</code>, any given <code>listener</code> can be registered at most once
+per event <code>type</code>. Attempts to register a <code>listener</code> multiple times are
+ignored.</li>
+<li>The <code>NodeEventTarget</code> does not emulate the full <code>EventEmitter</code> API.
+Specifically the <code>prependListener()</code>, <code>prependOnceListener()</code>,
+<code>rawListeners()</code>, <code>setMaxListeners()</code>, <code>getMaxListeners()</code>, and
+<code>errorMonitor</code> APIs are not emulated. The <code>'newListener'</code> and
+<code>'removeListener'</code> events will also not be emitted.</li>
+<li>The <code>NodeEventTarget</code> does not implement any special default behavior
+for events with type <code>'error'</code>.</li>
+<li>The <code>NodeEventTarget</code> supports <code>EventListener</code> objects as well as
+functions as handlers for all event types.</li>
+</ol>
+<h4>Event listener<span><a class="mark" href="#events_event_listener" id="events_event_listener">#</a></span></h4>
+<p>Event listeners registered for an event <code>type</code> may either be JavaScript
+functions or objects with a <code>handleEvent</code> property whose value is a function.</p>
+<p>In either case, the handler function is invoked with the <code>event</code> argument
+passed to the <code>eventTarget.dispatchEvent()</code> function.</p>
+<p>Async functions may be used as event listeners. If an async handler function
+rejects, the rejection is captured and handled as described in
+<a href="#events_eventtarget_error_handling"><code>EventTarget</code> error handling</a>.</p>
+<p>An error thrown by one handler function does not prevent the other handlers
+from being invoked.</p>
+<p>The return value of a handler function is ignored.</p>
+<p>Handlers are always invoked in the order they were added.</p>
+<p>Handler functions may mutate the <code>event</code> object.</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">handler1</span>(<span class="hljs-params">event</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'foo'</span>
+  event.<span class="hljs-property">a</span> = <span class="hljs-number">1</span>;
+}
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">handler2</span>(<span class="hljs-params">event</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'foo'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">a</span>);  <span class="hljs-comment">// Prints 1</span>
+}
+
+<span class="hljs-keyword">const</span> handler3 = {
+  <span class="hljs-title function_">handleEvent</span>(<span class="hljs-params">event</span>) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'foo'</span>
+  }
+};
+
+<span class="hljs-keyword">const</span> handler4 = {
+  <span class="hljs-keyword">async</span> <span class="hljs-title function_">handleEvent</span>(<span class="hljs-params">event</span>) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'foo'</span>
+  }
+};
+
+<span class="hljs-keyword">const</span> target = <span class="hljs-title function_">getEventTargetSomehow</span>();
+
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler1);
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler2);
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler3);
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler4, { <span class="hljs-attr">once</span>: <span class="hljs-literal">true</span> });</code></pre>
+<h4><code>EventTarget</code> error handling<span><a class="mark" href="#events_eventtarget_error_handling" id="events_eventtarget_error_handling">#</a></span></h4>
+<p>When a registered event listener throws (or returns a Promise that rejects),
+by default the error is treated as an uncaught exception on
+<code>process.nextTick()</code>. This means uncaught exceptions in <code>EventTarget</code>s will
+terminate the Node.js process by default.</p>
+<p>Throwing within an event listener will <em>not</em> stop the other registered handlers
+from being invoked.</p>
+<p>The <code>EventTarget</code> does not implement any special default handling for <code>'error'</code>
+type events like <code>EventEmitter</code>.</p>
+<p>Currently errors are first forwarded to the <code>process.on('error')</code> event
+before reaching <code>process.on('uncaughtException')</code>. This behavior is
+deprecated and will change in a future release to align <code>EventTarget</code> with
+other Node.js APIs. Any code relying on the <code>process.on('error')</code> event should
+be aligned with the new behavior.</p>
+<h4>Class: <code>Event</code><span><a class="mark" href="#events_class_event" id="events_class_event">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p>The <code>Event</code> object is an adaptation of the <a href="https://dom.spec.whatwg.org/#event"><code>Event</code> Web API</a>. Instances
+are created internally by Node.js.</p>
+<h5><code>event.bubbles</code><span><a class="mark" href="#events_event_bubbles" id="events_event_bubbles">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Always returns <code>false</code>.</li>
+</ul>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.cancelBubble()</code><span><a class="mark" href="#events_event_cancelbubble" id="events_event_cancelbubble">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p>Alias for <code>event.stopPropagation()</code>. This is not used in Node.js and is
+provided purely for completeness.</p>
+<h5><code>event.cancelable</code><span><a class="mark" href="#events_event_cancelable" id="events_event_cancelable">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> True if the event was created with the <code>cancelable</code> option.</li>
+</ul>
+<h5><code>event.composed</code><span><a class="mark" href="#events_event_composed" id="events_event_composed">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Always returns <code>false</code>.</li>
+</ul>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.composedPath()</code><span><a class="mark" href="#events_event_composedpath" id="events_event_composedpath">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p>Returns an array containing the current <code>EventTarget</code> as the only entry or
+empty if the event is not being dispatched. This is not used in
+Node.js and is provided purely for completeness.</p>
+<h5><code>event.currentTarget</code><span><a class="mark" href="#events_event_currenttarget" id="events_event_currenttarget">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> The <code>EventTarget</code> dispatching the event.</li>
+</ul>
+<p>Alias for <code>event.target</code>.</p>
+<h5><code>event.defaultPrevented</code><span><a class="mark" href="#events_event_defaultprevented" id="events_event_defaultprevented">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Is <code>true</code> if <code>cancelable</code> is <code>true</code> and <code>event.preventDefault()</code> has been
+called.</p>
+<h5><code>event.eventPhase</code><span><a class="mark" href="#events_event_eventphase" id="events_event_eventphase">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Returns <code>0</code> while an event is not being dispatched, <code>2</code> while
+it is being dispatched.</li>
+</ul>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.isTrusted</code><span><a class="mark" href="#events_event_istrusted" id="events_event_istrusted">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>The <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> <code>"abort"</code> event is emitted with <code>isTrusted</code> set to <code>true</code>. The
+value is <code>false</code> in all other cases.</p>
+<h5><code>event.preventDefault()</code><span><a class="mark" href="#events_event_preventdefault" id="events_event_preventdefault">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p>Sets the <code>defaultPrevented</code> property to <code>true</code> if <code>cancelable</code> is <code>true</code>.</p>
+<h5><code>event.returnValue</code><span><a class="mark" href="#events_event_returnvalue" id="events_event_returnvalue">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> True if the event has not been canceled.</li>
+</ul>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.srcElement</code><span><a class="mark" href="#events_event_srcelement" id="events_event_srcelement">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> The <code>EventTarget</code> dispatching the event.</li>
+</ul>
+<p>Alias for <code>event.target</code>.</p>
+<h5><code>event.stopImmediatePropagation()</code><span><a class="mark" href="#events_event_stopimmediatepropagation" id="events_event_stopimmediatepropagation">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p>Stops the invocation of event listeners after the current one completes.</p>
+<h5><code>event.stopPropagation()</code><span><a class="mark" href="#events_event_stoppropagation" id="events_event_stoppropagation">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<p>This is not used in Node.js and is provided purely for completeness.</p>
+<h5><code>event.target</code><span><a class="mark" href="#events_event_target" id="events_event_target">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> The <code>EventTarget</code> dispatching the event.</li>
+</ul>
+<h5><code>event.timeStamp</code><span><a class="mark" href="#events_event_timestamp" id="events_event_timestamp">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>The millisecond timestamp when the <code>Event</code> object was created.</p>
+<h5><code>event.type</code><span><a class="mark" href="#events_event_type" id="events_event_type">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>The event type identifier.</p>
+<h4>Class: <code>EventTarget</code><span><a class="mark" href="#events_class_eventtarget" id="events_class_eventtarget">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<h5><code>eventTarget.addEventListener(type, listener[, options])</code><span><a class="mark" href="#events_eventtarget_addeventlistener_type_listener_options" id="events_eventtarget_addeventlistener_type_listener_options">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="events.html#events_event_listener" class="type">&#x3C;EventListener></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>once</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, the listener is automatically removed
+when it is first invoked. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>passive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, serves as a hint that the listener will
+not call the <code>Event</code> object's <code>preventDefault()</code> method.
+<strong>Default:</strong> <code>false</code>.</li>
+<li><code>capture</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Not directly used by Node.js. Added for API
+completeness. <strong>Default:</strong> <code>false</code>.</li>
+</ul>
+</li>
+</ul>
+<p>Adds a new handler for the <code>type</code> event. Any given <code>listener</code> is added
+only once per <code>type</code> and per <code>capture</code> option value.</p>
+<p>If the <code>once</code> option is <code>true</code>, the <code>listener</code> is removed after the
+next time a <code>type</code> event is dispatched.</p>
+<p>The <code>capture</code> option is not used by Node.js in any functional way other than
+tracking registered event listeners per the <code>EventTarget</code> specification.
+Specifically, the <code>capture</code> option is used as part of the key when registering
+a <code>listener</code>. Any individual <code>listener</code> may be added once with
+<code>capture = false</code>, and once with <code>capture = true</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">handler</span>(<span class="hljs-params">event</span>) {}
+
+<span class="hljs-keyword">const</span> target = <span class="hljs-title function_">getEventTargetSomehow</span>();
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler, { <span class="hljs-attr">capture</span>: <span class="hljs-literal">true</span> });  <span class="hljs-comment">// first</span>
+target.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'foo'</span>, handler, { <span class="hljs-attr">capture</span>: <span class="hljs-literal">false</span> }); <span class="hljs-comment">// second</span>
+
+<span class="hljs-comment">// Removes the second instance of handler</span>
+target.<span class="hljs-title function_">removeEventListener</span>(<span class="hljs-string">'foo'</span>, handler);
+
+<span class="hljs-comment">// Removes the first instance of handler</span>
+target.<span class="hljs-title function_">removeEventListener</span>(<span class="hljs-string">'foo'</span>, handler, { <span class="hljs-attr">capture</span>: <span class="hljs-literal">true</span> });</code></pre>
+<h5><code>eventTarget.dispatchEvent(event)</code><span><a class="mark" href="#events_eventtarget_dispatchevent_event" id="events_eventtarget_dispatchevent_event">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li><code>event</code> <a href="events.html#events_class_event" class="type">&#x3C;Event></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if either event’s <code>cancelable</code> attribute value is
+false or its <code>preventDefault()</code> method was not invoked, otherwise <code>false</code>.</li>
+</ul>
+<p>Dispatches the <code>event</code> to the list of handlers for <code>event.type</code>.</p>
+<p>The registered event listeners is synchronously invoked in the order they
+were registered.</p>
+<h5><code>eventTarget.removeEventListener(type, listener)</code><span><a class="mark" href="#events_eventtarget_removeeventlistener_type_listener" id="events_eventtarget_removeeventlistener_type_listener">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="events.html#events_event_listener" class="type">&#x3C;EventListener></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>capture</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+</li>
+</ul>
+<p>Removes the <code>listener</code> from the list of handlers for event <code>type</code>.</p>
+<h4>Class: <code>NodeEventTarget</code><span><a class="mark" href="#events_class_nodeeventtarget" id="events_class_nodeeventtarget">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Extends: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a></li>
+</ul>
+<p>The <code>NodeEventTarget</code> is a Node.js-specific extension to <code>EventTarget</code>
+that emulates a subset of the <code>EventEmitter</code> API.</p>
+<h5><code>nodeEventTarget.addListener(type, listener[, options])</code><span><a class="mark" href="#events_nodeeventtarget_addlistener_type_listener_options" id="events_nodeeventtarget_addlistener_type_listener_options">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="events.html#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></p>
+<ul>
+<li><code>once</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+</li>
+<li>
+<p>Returns: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
+</ul>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that emulates the
+equivalent <code>EventEmitter</code> API. The only difference between <code>addListener()</code> and
+<code>addEventListener()</code> is that <code>addListener()</code> will return a reference to the
+<code>EventTarget</code>.</p>
+<h5><code>nodeEventTarget.eventNames()</code><span><a class="mark" href="#events_nodeeventtarget_eventnames" id="events_nodeeventtarget_eventnames">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that returns an array
+of event <code>type</code> names for which event listeners are registered.</p>
+<h5><code>nodeEventTarget.listenerCount(type)</code><span><a class="mark" href="#events_nodeeventtarget_listenercount_type" id="events_nodeeventtarget_listenercount_type">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></p>
+</li>
+</ul>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that returns the number
+of event listeners registered for the <code>type</code>.</p>
+<h5><code>nodeEventTarget.off(type, listener)</code><span><a class="mark" href="#events_nodeeventtarget_off_type_listener" id="events_nodeeventtarget_off_type_listener">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="events.html#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p>Returns: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
+</ul>
+<p>Node.js-specific alias for <code>eventTarget.removeListener()</code>.</p>
+<h5><code>nodeEventTarget.on(type, listener[, options])</code><span><a class="mark" href="#events_nodeeventtarget_on_type_listener_options" id="events_nodeeventtarget_on_type_listener_options">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="events.html#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></p>
+<ul>
+<li><code>once</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+</li>
+<li>
+<p>Returns: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
+</ul>
+<p>Node.js-specific alias for <code>eventTarget.addListener()</code>.</p>
+<h5><code>nodeEventTarget.once(type, listener[, options])</code><span><a class="mark" href="#events_nodeeventtarget_once_type_listener_options" id="events_nodeeventtarget_once_type_listener_options">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="events.html#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></p>
+</li>
+<li>
+<p>Returns: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
+</ul>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that adds a <code>once</code>
+listener for the given event <code>type</code>. This is equivalent to calling <code>on</code>
+with the <code>once</code> option set to <code>true</code>.</p>
+<h5><code>nodeEventTarget.removeAllListeners([type])</code><span><a class="mark" href="#events_nodeeventtarget_removealllisteners_type" id="events_nodeeventtarget_removealllisteners_type">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p>Returns: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
+</ul>
+<p>Node.js-specific extension to the <code>EventTarget</code> class. If <code>type</code> is specified,
+removes all registered listeners for <code>type</code>, otherwise removes all registered
+listeners.</p>
+<h5><code>nodeEventTarget.removeListener(type, listener)</code><span><a class="mark" href="#events_nodeeventtarget_removelistener_type_listener" id="events_nodeeventtarget_removelistener_type_listener">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li>
+<p><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></p>
+</li>
+<li>
+<p><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="events.html#events_event_listener" class="type">&#x3C;EventListener></a></p>
+</li>
+<li>
+<p>Returns: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a> this</p>
+</li>
+</ul>
+<p>Node.js-specific extension to the <code>EventTarget</code> class that removes the
+<code>listener</code> for the given <code>type</code>. The only difference between <code>removeListener()</code>
+and <code>removeEventListener()</code> is that <code>removeListener()</code> will return a reference
+to the <code>EventTarget</code>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/events.json b/doc/api/events.json
index ea26248e603826eb7140b5e329c646e7bd3e429f..051c8ae90a0d336de5ba37fd3facea20fa86a706 100644
--- a/doc/api/events.json
+++ b/doc/api/events.json
@@ -9,7 +9,7 @@
       "stability": 2,
       "stabilityText": "Stable",
       "type": "module",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/events.js\">lib/events.js</a></p>\n<p>Much of the Node.js core API is built around an idiomatic asynchronous\nevent-driven architecture in which certain kinds of objects (called \"emitters\")\nemit named events that cause <code>Function</code> objects (\"listeners\") to be called.</p>\n<p>For instance: a <a href=\"net.html#net_class_net_server\"><code>net.Server</code></a> object emits an event each time a peer\nconnects to it; a <a href=\"fs.html#fs_class_fs_readstream\"><code>fs.ReadStream</code></a> emits an event when the file is opened;\na <a href=\"stream.html\">stream</a> emits an event whenever data is available to be read.</p>\n<p>All objects that emit events are instances of the <code>EventEmitter</code> class. These\nobjects expose an <code>eventEmitter.on()</code> function that allows one or more\nfunctions to be attached to named events emitted by the object. Typically,\nevent names are camel-cased strings but any valid JavaScript property key\ncan be used.</p>\n<p>When the <code>EventEmitter</code> object emits an event, all of the functions attached\nto that specific event are called <em>synchronously</em>. Any values returned by the\ncalled listeners are <em>ignored</em> and will be discarded.</p>\n<p>The following example shows a simple <code>EventEmitter</code> instance with a single\nlistener. The <code>eventEmitter.on()</code> method is used to register listeners, while\nthe <code>eventEmitter.emit()</code> method is used to trigger the event.</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\n\nclass MyEmitter extends EventEmitter {}\n\nconst myEmitter = new MyEmitter();\nmyEmitter.on('event', () => {\n  console.log('an event occurred!');\n});\nmyEmitter.emit('event');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/events.js\">lib/events.js</a></p>\n<p>Much of the Node.js core API is built around an idiomatic asynchronous\nevent-driven architecture in which certain kinds of objects (called \"emitters\")\nemit named events that cause <code>Function</code> objects (\"listeners\") to be called.</p>\n<p>For instance: a <a href=\"net.html#net_class_net_server\"><code>net.Server</code></a> object emits an event each time a peer\nconnects to it; a <a href=\"fs.html#fs_class_fs_readstream\"><code>fs.ReadStream</code></a> emits an event when the file is opened;\na <a href=\"stream.html\">stream</a> emits an event whenever data is available to be read.</p>\n<p>All objects that emit events are instances of the <code>EventEmitter</code> class. These\nobjects expose an <code>eventEmitter.on()</code> function that allows one or more\nfunctions to be attached to named events emitted by the object. Typically,\nevent names are camel-cased strings but any valid JavaScript property key\ncan be used.</p>\n<p>When the <code>EventEmitter</code> object emits an event, all of the functions attached\nto that specific event are called <em>synchronously</em>. Any values returned by the\ncalled listeners are <em>ignored</em> and discarded.</p>\n<p>The following example shows a simple <code>EventEmitter</code> instance with a single\nlistener. The <code>eventEmitter.on()</code> method is used to register listeners, while\nthe <code>eventEmitter.emit()</code> method is used to trigger the event.</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\n\nclass MyEmitter extends EventEmitter {}\n\nconst myEmitter = new MyEmitter();\nmyEmitter.on('event', () => {\n  console.log('an event occurred!');\n});\nmyEmitter.emit('event');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Passing arguments and `this` to listeners",
@@ -28,14 +28,14 @@
         {
           "textRaw": "Handling events only once",
           "name": "handling_events_only_once",
-          "desc": "<p>When a listener is registered using the <code>eventEmitter.on()</code> method, that\nlistener will be invoked <em>every time</em> the named event is emitted.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nlet m = 0;\nmyEmitter.on('event', () => {\n  console.log(++m);\n});\nmyEmitter.emit('event');\n// Prints: 1\nmyEmitter.emit('event');\n// Prints: 2\n</code></pre>\n<p>Using the <code>eventEmitter.once()</code> method, it is possible to register a listener\nthat is called at most once for a particular event. Once the event is emitted,\nthe listener is unregistered and <em>then</em> called.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nlet m = 0;\nmyEmitter.once('event', () => {\n  console.log(++m);\n});\nmyEmitter.emit('event');\n// Prints: 1\nmyEmitter.emit('event');\n// Ignored\n</code></pre>",
+          "desc": "<p>When a listener is registered using the <code>eventEmitter.on()</code> method, that\nlistener is invoked <em>every time</em> the named event is emitted.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nlet m = 0;\nmyEmitter.on('event', () => {\n  console.log(++m);\n});\nmyEmitter.emit('event');\n// Prints: 1\nmyEmitter.emit('event');\n// Prints: 2\n</code></pre>\n<p>Using the <code>eventEmitter.once()</code> method, it is possible to register a listener\nthat is called at most once for a particular event. Once the event is emitted,\nthe listener is unregistered and <em>then</em> called.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nlet m = 0;\nmyEmitter.once('event', () => {\n  console.log(++m);\n});\nmyEmitter.emit('event');\n// Prints: 1\nmyEmitter.emit('event');\n// Ignored\n</code></pre>",
           "type": "module",
           "displayName": "Handling events only once"
         },
         {
           "textRaw": "Error events",
           "name": "error_events",
-          "desc": "<p>When an error occurs within an <code>EventEmitter</code> instance, the typical action is\nfor an <code>'error'</code> event to be emitted. These are treated as special cases\nwithin Node.js.</p>\n<p>If an <code>EventEmitter</code> does <em>not</em> have at least one listener registered for the\n<code>'error'</code> event, and an <code>'error'</code> event is emitted, the error is thrown, a\nstack trace is printed, and the Node.js process exits.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.emit('error', new Error('whoops!'));\n// Throws and crashes Node.js\n</code></pre>\n<p>To guard against crashing the Node.js process the <a href=\"domain.html\"><code>domain</code></a> module can be\nused. (Note, however, that the <code>domain</code> module is deprecated.)</p>\n<p>As a best practice, listeners should always be added for the <code>'error'</code> events.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.on('error', (err) => {\n  console.error('whoops! there was an error');\n});\nmyEmitter.emit('error', new Error('whoops!'));\n// Prints: whoops! there was an error\n</code></pre>\n<p>It is possible to monitor <code>'error'</code> events without consuming the emitted error\nby installing a listener using the symbol <code>errorMonitor</code>.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.on(EventEmitter.errorMonitor, (err) => {\n  MyMonitoringTool.log(err);\n});\nmyEmitter.emit('error', new Error('whoops!'));\n// Still throws and crashes Node.js\n</code></pre>",
+          "desc": "<p>When an error occurs within an <code>EventEmitter</code> instance, the typical action is\nfor an <code>'error'</code> event to be emitted. These are treated as special cases\nwithin Node.js.</p>\n<p>If an <code>EventEmitter</code> does <em>not</em> have at least one listener registered for the\n<code>'error'</code> event, and an <code>'error'</code> event is emitted, the error is thrown, a\nstack trace is printed, and the Node.js process exits.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.emit('error', new Error('whoops!'));\n// Throws and crashes Node.js\n</code></pre>\n<p>To guard against crashing the Node.js process the <a href=\"domain.html\"><code>domain</code></a> module can be\nused. (Note, however, that the <code>domain</code> module is deprecated.)</p>\n<p>As a best practice, listeners should always be added for the <code>'error'</code> events.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.on('error', (err) => {\n  console.error('whoops! there was an error');\n});\nmyEmitter.emit('error', new Error('whoops!'));\n// Prints: whoops! there was an error\n</code></pre>\n<p>It is possible to monitor <code>'error'</code> events without consuming the emitted error\nby installing a listener using the symbol <code>events.errorMonitor</code>.</p>\n<pre><code class=\"language-js\">const { EventEmitter, errorMonitor } = require('events');\n\nconst myEmitter = new EventEmitter();\nmyEmitter.on(errorMonitor, (err) => {\n  MyMonitoringTool.log(err);\n});\nmyEmitter.emit('error', new Error('whoops!'));\n// Still throws and crashes Node.js\n</code></pre>",
           "type": "module",
           "displayName": "Error events"
         },
@@ -44,9 +44,737 @@
           "name": "capture_rejections_of_promises",
           "stability": 1,
           "stabilityText": "captureRejections is experimental.",
-          "desc": "<p>Using <code>async</code> functions with event handlers is problematic, because it\ncan lead to an unhandled rejection in case of a thrown exception:</p>\n<pre><code class=\"language-js\">const ee = new EventEmitter();\nee.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n</code></pre>\n<p>The <code>captureRejections</code> option in the <code>EventEmitter</code> constructor or the global\nsetting change this behavior, installing a <code>.then(undefined, handler)</code>\nhandler on the <code>Promise</code>. This handler routes the exception\nasynchronously to the <a href=\"#events_emitter_symbol_for_nodejs_rejection_err_eventname_args\"><code>Symbol.for('nodejs.rejection')</code></a> method\nif there is one, or to <a href=\"#events_error_events\"><code>'error'</code></a> event handler if there is none.</p>\n<pre><code class=\"language-js\">const ee1 = new EventEmitter({ captureRejections: true });\nee1.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee1.on('error', console.log);\n\nconst ee2 = new EventEmitter({ captureRejections: true });\nee2.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee2[Symbol.for('nodejs.rejection')] = console.log;\n</code></pre>\n<p>Setting <code>EventEmitter.captureRejections = true</code> will change the default for all\nnew instances of <code>EventEmitter</code>.</p>\n<pre><code class=\"language-js\">EventEmitter.captureRejections = true;\nconst ee1 = new EventEmitter();\nee1.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee1.on('error', console.log);\n</code></pre>\n<p>The <code>'error'</code> events that are generated by the <code>captureRejections</code> behavior\ndo not have a catch handler to avoid infinite error loops: the\nrecommendation is to <strong>not use <code>async</code> functions as <code>'error'</code> event handlers</strong>.</p>",
+          "desc": "<p>Using <code>async</code> functions with event handlers is problematic, because it\ncan lead to an unhandled rejection in case of a thrown exception:</p>\n<pre><code class=\"language-js\">const ee = new EventEmitter();\nee.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n</code></pre>\n<p>The <code>captureRejections</code> option in the <code>EventEmitter</code> constructor or the global\nsetting change this behavior, installing a <code>.then(undefined, handler)</code>\nhandler on the <code>Promise</code>. This handler routes the exception\nasynchronously to the <a href=\"#events_emitter_symbol_for_nodejs_rejection_err_eventname_args\"><code>Symbol.for('nodejs.rejection')</code></a> method\nif there is one, or to <a href=\"#events_error_events\"><code>'error'</code></a> event handler if there is none.</p>\n<pre><code class=\"language-js\">const ee1 = new EventEmitter({ captureRejections: true });\nee1.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee1.on('error', console.log);\n\nconst ee2 = new EventEmitter({ captureRejections: true });\nee2.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee2[Symbol.for('nodejs.rejection')] = console.log;\n</code></pre>\n<p>Setting <code>events.captureRejections = true</code> will change the default for all\nnew instances of <code>EventEmitter</code>.</p>\n<pre><code class=\"language-js\">const events = require('events');\nevents.captureRejections = true;\nconst ee1 = new events.EventEmitter();\nee1.on('something', async (value) => {\n  throw new Error('kaboom');\n});\n\nee1.on('error', console.log);\n</code></pre>\n<p>The <code>'error'</code> events that are generated by the <code>captureRejections</code> behavior\ndo not have a catch handler to avoid infinite error loops: the\nrecommendation is to <strong>not use <code>async</code> functions as <code>'error'</code> event handlers</strong>.</p>",
           "type": "module",
           "displayName": "Capture rejections of promises"
+        },
+        {
+          "textRaw": "`EventTarget` and `Event` API",
+          "name": "`eventtarget`_and_`event`_api",
+          "meta": {
+            "added": [
+              "v14.5.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>The <code>EventTarget</code> and <code>Event</code> objects are a Node.js-specific implementation\nof the <a href=\"https://dom.spec.whatwg.org/#eventtarget\"><code>EventTarget</code> Web API</a> that are exposed by some Node.js core APIs.\nNeither the <code>EventTarget</code> nor <code>Event</code> classes are available for end\nuser code to create.</p>\n<pre><code class=\"language-js\">const target = getEventTargetSomehow();\n\ntarget.addEventListener('foo', (event) => {\n  console.log('foo event happened!');\n});\n</code></pre>",
+          "modules": [
+            {
+              "textRaw": "Node.js `EventTarget` vs. DOM `EventTarget`",
+              "name": "node.js_`eventtarget`_vs._dom_`eventtarget`",
+              "desc": "<p>There are two key differences between the Node.js <code>EventTarget</code> and the\n<a href=\"https://dom.spec.whatwg.org/#eventtarget\"><code>EventTarget</code> Web API</a>:</p>\n<ol>\n<li>Whereas DOM <code>EventTarget</code> instances <em>may</em> be hierarchical, there is no\nconcept of hierarchy and event propagation in Node.js. That is, an event\ndispatched to an <code>EventTarget</code> does not propagate through a hierarchy of\nnested target objects that may each have their own set of handlers for the\nevent.</li>\n<li>In the Node.js <code>EventTarget</code>, if an event listener is an async function\nor returns a <code>Promise</code>, and the returned <code>Promise</code> rejects, the rejection\nis automatically captured and handled the same way as a listener that\nthrows synchronously (see <a href=\"#events_eventtarget_error_handling\"><code>EventTarget</code> error handling</a> for details).</li>\n</ol>",
+              "type": "module",
+              "displayName": "Node.js `EventTarget` vs. DOM `EventTarget`"
+            },
+            {
+              "textRaw": "`NodeEventTarget` vs. `EventEmitter`",
+              "name": "`nodeeventtarget`_vs._`eventemitter`",
+              "desc": "<p>The <code>NodeEventTarget</code> object implements a modified subset of the\n<code>EventEmitter</code> API that allows it to closely <em>emulate</em> an <code>EventEmitter</code> in\ncertain situations. A <code>NodeEventTarget</code> is <em>not</em> an instance of <code>EventEmitter</code>\nand cannot be used in place of an <code>EventEmitter</code> in most cases.</p>\n<ol>\n<li>Unlike <code>EventEmitter</code>, any given <code>listener</code> can be registered at most once\nper event <code>type</code>. Attempts to register a <code>listener</code> multiple times are\nignored.</li>\n<li>The <code>NodeEventTarget</code> does not emulate the full <code>EventEmitter</code> API.\nSpecifically the <code>prependListener()</code>, <code>prependOnceListener()</code>,\n<code>rawListeners()</code>, <code>setMaxListeners()</code>, <code>getMaxListeners()</code>, and\n<code>errorMonitor</code> APIs are not emulated. The <code>'newListener'</code> and\n<code>'removeListener'</code> events will also not be emitted.</li>\n<li>The <code>NodeEventTarget</code> does not implement any special default behavior\nfor events with type <code>'error'</code>.</li>\n<li>The <code>NodeEventTarget</code> supports <code>EventListener</code> objects as well as\nfunctions as handlers for all event types.</li>\n</ol>",
+              "type": "module",
+              "displayName": "`NodeEventTarget` vs. `EventEmitter`"
+            },
+            {
+              "textRaw": "Event listener",
+              "name": "event_listener",
+              "desc": "<p>Event listeners registered for an event <code>type</code> may either be JavaScript\nfunctions or objects with a <code>handleEvent</code> property whose value is a function.</p>\n<p>In either case, the handler function is invoked with the <code>event</code> argument\npassed to the <code>eventTarget.dispatchEvent()</code> function.</p>\n<p>Async functions may be used as event listeners. If an async handler function\nrejects, the rejection is captured and handled as described in\n<a href=\"#events_eventtarget_error_handling\"><code>EventTarget</code> error handling</a>.</p>\n<p>An error thrown by one handler function does not prevent the other handlers\nfrom being invoked.</p>\n<p>The return value of a handler function is ignored.</p>\n<p>Handlers are always invoked in the order they were added.</p>\n<p>Handler functions may mutate the <code>event</code> object.</p>\n<pre><code class=\"language-js\">function handler1(event) {\n  console.log(event.type);  // Prints 'foo'\n  event.a = 1;\n}\n\nasync function handler2(event) {\n  console.log(event.type);  // Prints 'foo'\n  console.log(event.a);  // Prints 1\n}\n\nconst handler3 = {\n  handleEvent(event) {\n    console.log(event.type);  // Prints 'foo'\n  }\n};\n\nconst handler4 = {\n  async handleEvent(event) {\n    console.log(event.type);  // Prints 'foo'\n  }\n};\n\nconst target = getEventTargetSomehow();\n\ntarget.addEventListener('foo', handler1);\ntarget.addEventListener('foo', handler2);\ntarget.addEventListener('foo', handler3);\ntarget.addEventListener('foo', handler4, { once: true });\n</code></pre>",
+              "type": "module",
+              "displayName": "Event listener"
+            },
+            {
+              "textRaw": "`EventTarget` error handling",
+              "name": "`eventtarget`_error_handling",
+              "desc": "<p>When a registered event listener throws (or returns a Promise that rejects),\nby default the error is treated as an uncaught exception on\n<code>process.nextTick()</code>. This means uncaught exceptions in <code>EventTarget</code>s will\nterminate the Node.js process by default.</p>\n<p>Throwing within an event listener will <em>not</em> stop the other registered handlers\nfrom being invoked.</p>\n<p>The <code>EventTarget</code> does not implement any special default handling for <code>'error'</code>\ntype events like <code>EventEmitter</code>.</p>\n<p>Currently errors are first forwarded to the <code>process.on('error')</code> event\nbefore reaching <code>process.on('uncaughtException')</code>. This behavior is\ndeprecated and will change in a future release to align <code>EventTarget</code> with\nother Node.js APIs. Any code relying on the <code>process.on('error')</code> event should\nbe aligned with the new behavior.</p>",
+              "type": "module",
+              "displayName": "`EventTarget` error handling"
+            }
+          ],
+          "classes": [
+            {
+              "textRaw": "Class: `Event`",
+              "type": "class",
+              "name": "Event",
+              "meta": {
+                "added": [
+                  "v14.5.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The <code>Event</code> object is an adaptation of the <a href=\"https://dom.spec.whatwg.org/#event\"><code>Event</code> Web API</a>. Instances\nare created internally by Node.js.</p>",
+              "properties": [
+                {
+                  "textRaw": "`bubbles` Type: {boolean} Always returns `false`.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>",
+                  "shortDesc": "Always returns `false`."
+                },
+                {
+                  "textRaw": "`cancelable` Type: {boolean} True if the event was created with the `cancelable` option.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "True if the event was created with the `cancelable` option."
+                },
+                {
+                  "textRaw": "`composed` Type: {boolean} Always returns `false`.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>",
+                  "shortDesc": "Always returns `false`."
+                },
+                {
+                  "textRaw": "`currentTarget` Type: {EventTarget} The `EventTarget` dispatching the event.",
+                  "type": "EventTarget",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Alias for <code>event.target</code>.</p>",
+                  "shortDesc": "The `EventTarget` dispatching the event."
+                },
+                {
+                  "textRaw": "`defaultPrevented` Type: {boolean}",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Is <code>true</code> if <code>cancelable</code> is <code>true</code> and <code>event.preventDefault()</code> has been\ncalled.</p>"
+                },
+                {
+                  "textRaw": "`eventPhase` Type: {number} Returns `0` while an event is not being dispatched, `2` while it is being dispatched.",
+                  "type": "number",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>",
+                  "shortDesc": "Returns `0` while an event is not being dispatched, `2` while it is being dispatched."
+                },
+                {
+                  "textRaw": "`isTrusted` Type: {boolean}",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> <code>\"abort\"</code> event is emitted with <code>isTrusted</code> set to <code>true</code>. The\nvalue is <code>false</code> in all other cases.</p>"
+                },
+                {
+                  "textRaw": "`returnValue` Type: {boolean} True if the event has not been canceled.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>",
+                  "shortDesc": "True if the event has not been canceled."
+                },
+                {
+                  "textRaw": "`srcElement` Type: {EventTarget} The `EventTarget` dispatching the event.",
+                  "type": "EventTarget",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Alias for <code>event.target</code>.</p>",
+                  "shortDesc": "The `EventTarget` dispatching the event."
+                },
+                {
+                  "textRaw": "`target` Type: {EventTarget} The `EventTarget` dispatching the event.",
+                  "type": "EventTarget",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "The `EventTarget` dispatching the event."
+                },
+                {
+                  "textRaw": "`timeStamp` Type: {number}",
+                  "type": "number",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The millisecond timestamp when the <code>Event</code> object was created.</p>"
+                },
+                {
+                  "textRaw": "`type` Type: {string}",
+                  "type": "string",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The event type identifier.</p>"
+                }
+              ],
+              "methods": [
+                {
+                  "textRaw": "`event.cancelBubble()`",
+                  "type": "method",
+                  "name": "cancelBubble",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Alias for <code>event.stopPropagation()</code>. This is not used in Node.js and is\nprovided purely for completeness.</p>"
+                },
+                {
+                  "textRaw": "`event.composedPath()`",
+                  "type": "method",
+                  "name": "composedPath",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns an array containing the current <code>EventTarget</code> as the only entry or\nempty if the event is not being dispatched. This is not used in\nNode.js and is provided purely for completeness.</p>"
+                },
+                {
+                  "textRaw": "`event.preventDefault()`",
+                  "type": "method",
+                  "name": "preventDefault",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Sets the <code>defaultPrevented</code> property to <code>true</code> if <code>cancelable</code> is <code>true</code>.</p>"
+                },
+                {
+                  "textRaw": "`event.stopImmediatePropagation()`",
+                  "type": "method",
+                  "name": "stopImmediatePropagation",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Stops the invocation of event listeners after the current one completes.</p>"
+                },
+                {
+                  "textRaw": "`event.stopPropagation()`",
+                  "type": "method",
+                  "name": "stopPropagation",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>This is not used in Node.js and is provided purely for completeness.</p>"
+                }
+              ]
+            },
+            {
+              "textRaw": "Class: `EventTarget`",
+              "type": "class",
+              "name": "EventTarget",
+              "meta": {
+                "added": [
+                  "v14.5.0"
+                ],
+                "changes": []
+              },
+              "methods": [
+                {
+                  "textRaw": "`eventTarget.addEventListener(type, listener[, options])`",
+                  "type": "method",
+                  "name": "addEventListener",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object",
+                          "options": [
+                            {
+                              "textRaw": "`once` {boolean} When `true`, the listener is automatically removed when it is first invoked. **Default:** `false`.",
+                              "name": "once",
+                              "type": "boolean",
+                              "default": "`false`",
+                              "desc": "When `true`, the listener is automatically removed when it is first invoked."
+                            },
+                            {
+                              "textRaw": "`passive` {boolean} When `true`, serves as a hint that the listener will not call the `Event` object's `preventDefault()` method. **Default:** `false`.",
+                              "name": "passive",
+                              "type": "boolean",
+                              "default": "`false`",
+                              "desc": "When `true`, serves as a hint that the listener will not call the `Event` object's `preventDefault()` method."
+                            },
+                            {
+                              "textRaw": "`capture` {boolean} Not directly used by Node.js. Added for API completeness. **Default:** `false`.",
+                              "name": "capture",
+                              "type": "boolean",
+                              "default": "`false`",
+                              "desc": "Not directly used by Node.js. Added for API completeness."
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Adds a new handler for the <code>type</code> event. Any given <code>listener</code> is added\nonly once per <code>type</code> and per <code>capture</code> option value.</p>\n<p>If the <code>once</code> option is <code>true</code>, the <code>listener</code> is removed after the\nnext time a <code>type</code> event is dispatched.</p>\n<p>The <code>capture</code> option is not used by Node.js in any functional way other than\ntracking registered event listeners per the <code>EventTarget</code> specification.\nSpecifically, the <code>capture</code> option is used as part of the key when registering\na <code>listener</code>. Any individual <code>listener</code> may be added once with\n<code>capture = false</code>, and once with <code>capture = true</code>.</p>\n<pre><code class=\"language-js\">function handler(event) {}\n\nconst target = getEventTargetSomehow();\ntarget.addEventListener('foo', handler, { capture: true });  // first\ntarget.addEventListener('foo', handler, { capture: false }); // second\n\n// Removes the second instance of handler\ntarget.removeEventListener('foo', handler);\n\n// Removes the first instance of handler\ntarget.removeEventListener('foo', handler, { capture: true });\n</code></pre>"
+                },
+                {
+                  "textRaw": "`eventTarget.dispatchEvent(event)`",
+                  "type": "method",
+                  "name": "dispatchEvent",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean} `true` if either event’s `cancelable` attribute value is false or its `preventDefault()` method was not invoked, otherwise `false`.",
+                        "name": "return",
+                        "type": "boolean",
+                        "desc": "`true` if either event’s `cancelable` attribute value is false or its `preventDefault()` method was not invoked, otherwise `false`."
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`event` {Event}",
+                          "name": "event",
+                          "type": "Event"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Dispatches the <code>event</code> to the list of handlers for <code>event.type</code>.</p>\n<p>The registered event listeners is synchronously invoked in the order they\nwere registered.</p>"
+                },
+                {
+                  "textRaw": "`eventTarget.removeEventListener(type, listener)`",
+                  "type": "method",
+                  "name": "removeEventListener",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object",
+                          "options": [
+                            {
+                              "textRaw": "`capture` {boolean}",
+                              "name": "capture",
+                              "type": "boolean"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Removes the <code>listener</code> from the list of handlers for event <code>type</code>.</p>"
+                }
+              ]
+            },
+            {
+              "textRaw": "Class: `NodeEventTarget`",
+              "type": "class",
+              "name": "NodeEventTarget",
+              "meta": {
+                "added": [
+                  "v14.5.0"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventtarget\" class=\"type\">&lt;EventTarget&gt;</a></li>\n</ul>\n<p>The <code>NodeEventTarget</code> is a Node.js-specific extension to <code>EventTarget</code>\nthat emulates a subset of the <code>EventEmitter</code> API.</p>",
+              "methods": [
+                {
+                  "textRaw": "`nodeEventTarget.addListener(type, listener[, options])`",
+                  "type": "method",
+                  "name": "addListener",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object",
+                          "options": [
+                            {
+                              "textRaw": "`once` {boolean}",
+                              "name": "once",
+                              "type": "boolean"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that emulates the\nequivalent <code>EventEmitter</code> API. The only difference between <code>addListener()</code> and\n<code>addEventListener()</code> is that <code>addListener()</code> will return a reference to the\n<code>EventTarget</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.eventNames()`",
+                  "type": "method",
+                  "name": "eventNames",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {string[]}",
+                        "name": "return",
+                        "type": "string[]"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that returns an array\nof event <code>type</code> names for which event listeners are registered.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.listenerCount(type)`",
+                  "type": "method",
+                  "name": "listenerCount",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {number}",
+                        "name": "return",
+                        "type": "number"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that returns the number\nof event listeners registered for the <code>type</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.off(type, listener)`",
+                  "type": "method",
+                  "name": "off",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific alias for <code>eventTarget.removeListener()</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.on(type, listener[, options])`",
+                  "type": "method",
+                  "name": "on",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object",
+                          "options": [
+                            {
+                              "textRaw": "`once` {boolean}",
+                              "name": "once",
+                              "type": "boolean"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific alias for <code>eventTarget.addListener()</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.once(type, listener[, options])`",
+                  "type": "method",
+                  "name": "once",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        },
+                        {
+                          "textRaw": "`options` {Object}",
+                          "name": "options",
+                          "type": "Object"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that adds a <code>once</code>\nlistener for the given event <code>type</code>. This is equivalent to calling <code>on</code>\nwith the <code>once</code> option set to <code>true</code>.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.removeAllListeners([type])`",
+                  "type": "method",
+                  "name": "removeAllListeners",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class. If <code>type</code> is specified,\nremoves all registered listeners for <code>type</code>, otherwise removes all registered\nlisteners.</p>"
+                },
+                {
+                  "textRaw": "`nodeEventTarget.removeListener(type, listener)`",
+                  "type": "method",
+                  "name": "removeListener",
+                  "meta": {
+                    "added": [
+                      "v14.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {EventTarget} this",
+                        "name": "return",
+                        "type": "EventTarget",
+                        "desc": "this"
+                      },
+                      "params": [
+                        {
+                          "textRaw": "`type` {string}",
+                          "name": "type",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`listener` {Function|EventListener}",
+                          "name": "listener",
+                          "type": "Function|EventListener"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Node.js-specific extension to the <code>EventTarget</code> class that removes the\n<code>listener</code> for the given <code>type</code>. The only difference between <code>removeListener()</code>\nand <code>removeEventListener()</code> is that <code>removeListener()</code> will return a reference\nto the <code>EventTarget</code>.</p>"
+                }
+              ]
+            }
+          ],
+          "type": "module",
+          "displayName": "`EventTarget` and `Event` API"
         }
       ],
       "classes": [
@@ -60,16 +788,19 @@
             ],
             "changes": [
               {
-                "version": "v12.16.0",
+                "version": [
+                  "v13.4.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/27867",
                 "description": "Added captureRejections option."
               }
             ]
           },
-          "desc": "<p>The <code>EventEmitter</code> class is defined and exposed by the <code>events</code> module:</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\n</code></pre>\n<p>All <code>EventEmitter</code>s emit the event <code>'newListener'</code> when new listeners are\nadded and <code>'removeListener'</code> when existing listeners are removed.</p>\n<p>It supports the following option:</p>\n<ul>\n<li><code>captureRejections</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> It enables\n<a href=\"#events_capture_rejections_of_promises\">automatic capturing of promise rejection</a>.\nDefault: <code>false</code>.</li>\n</ul>",
+          "desc": "<p>The <code>EventEmitter</code> class is defined and exposed by the <code>events</code> module:</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\n</code></pre>\n<p>All <code>EventEmitter</code>s emit the event <code>'newListener'</code> when new listeners are\nadded and <code>'removeListener'</code> when existing listeners are removed.</p>\n<p>It supports the following option:</p>\n<ul>\n<li><code>captureRejections</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> It enables\n<a href=\"#events_capture_rejections_of_promises\">automatic capturing of promise rejection</a>.\n<strong>Default:</strong> <code>false</code>.</li>\n</ul>",
           "events": [
             {
-              "textRaw": "Event: 'newListener'",
+              "textRaw": "Event: `'newListener'`",
               "type": "event",
               "name": "newListener",
               "meta": {
@@ -92,7 +823,7 @@
                   "desc": "The event handler function"
                 }
               ],
-              "desc": "<p>The <code>EventEmitter</code> instance will emit its own <code>'newListener'</code> event <em>before</em>\na listener is added to its internal array of listeners.</p>\n<p>Listeners registered for the <code>'newListener'</code> event will be passed the event\nname and a reference to the listener being added.</p>\n<p>The fact that the event is triggered before adding the listener has a subtle\nbut important side effect: any <em>additional</em> listeners registered to the same\n<code>name</code> <em>within</em> the <code>'newListener'</code> callback will be inserted <em>before</em> the\nlistener that is in the process of being added.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\n// Only do this once so we don't loop forever\nmyEmitter.once('newListener', (event, listener) => {\n  if (event === 'event') {\n    // Insert a new listener in front\n    myEmitter.on('event', () => {\n      console.log('B');\n    });\n  }\n});\nmyEmitter.on('event', () => {\n  console.log('A');\n});\nmyEmitter.emit('event');\n// Prints:\n//   B\n//   A\n</code></pre>"
+              "desc": "<p>The <code>EventEmitter</code> instance will emit its own <code>'newListener'</code> event <em>before</em>\na listener is added to its internal array of listeners.</p>\n<p>Listeners registered for the <code>'newListener'</code> event are passed the event\nname and a reference to the listener being added.</p>\n<p>The fact that the event is triggered before adding the listener has a subtle\nbut important side effect: any <em>additional</em> listeners registered to the same\n<code>name</code> <em>within</em> the <code>'newListener'</code> callback are inserted <em>before</em> the\nlistener that is in the process of being added.</p>\n<pre><code class=\"language-js\">class MyEmitter extends EventEmitter {}\n\nconst myEmitter = new MyEmitter();\n// Only do this once so we don't loop forever\nmyEmitter.once('newListener', (event, listener) => {\n  if (event === 'event') {\n    // Insert a new listener in front\n    myEmitter.on('event', () => {\n      console.log('B');\n    });\n  }\n});\nmyEmitter.on('event', () => {\n  console.log('A');\n});\nmyEmitter.emit('event');\n// Prints:\n//   B\n//   A\n</code></pre>"
             },
             {
               "textRaw": "Event: `'removeListener'`",
@@ -104,7 +835,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v6.1.0, v4.7.0",
+                    "version": [
+                      "v6.1.0",
+                      "v4.7.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/6394",
                     "description": "For listeners attached using `.once()`, the `listener` argument now yields the original listener function."
                   }
@@ -128,41 +862,6 @@
             }
           ],
           "methods": [
-            {
-              "textRaw": "`EventEmitter.listenerCount(emitter, eventName)`",
-              "type": "method",
-              "name": "listenerCount",
-              "meta": {
-                "added": [
-                  "v0.9.12"
-                ],
-                "deprecated": [
-                  "v3.2.0"
-                ],
-                "changes": []
-              },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use [`emitter.listenerCount()`][] instead.",
-              "signatures": [
-                {
-                  "params": [
-                    {
-                      "textRaw": "`emitter` {EventEmitter} The emitter to query",
-                      "name": "emitter",
-                      "type": "EventEmitter",
-                      "desc": "The emitter to query"
-                    },
-                    {
-                      "textRaw": "`eventName` {string|symbol} The event name",
-                      "name": "eventName",
-                      "type": "string|symbol",
-                      "desc": "The event name"
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p>A class method that returns the number of listeners for the given <code>eventName</code>\nregistered on the given <code>emitter</code>.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\nmyEmitter.on('event', () => {});\nmyEmitter.on('event', () => {});\nconsole.log(EventEmitter.listenerCount(myEmitter, 'event'));\n// Prints: 2\n</code></pre>"
-            },
             {
               "textRaw": "`emitter.addListener(eventName, listener)`",
               "type": "method",
@@ -244,7 +943,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns an array listing the events for which the emitter has registered\nlisteners. The values in the array will be strings or <code>Symbol</code>s.</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\nconst myEE = new EventEmitter();\nmyEE.on('foo', () => {});\nmyEE.on('bar', () => {});\n\nconst sym = Symbol('symbol');\nmyEE.on(sym, () => {});\n\nconsole.log(myEE.eventNames());\n// Prints: [ 'foo', 'bar', Symbol(symbol) ]\n</code></pre>"
+              "desc": "<p>Returns an array listing the events for which the emitter has registered\nlisteners. The values in the array are strings or <code>Symbol</code>s.</p>\n<pre><code class=\"language-js\">const EventEmitter = require('events');\nconst myEE = new EventEmitter();\nmyEE.on('foo', () => {});\nmyEE.on('bar', () => {});\n\nconst sym = Symbol('symbol');\nmyEE.on(sym, () => {});\n\nconsole.log(myEE.eventNames());\n// Prints: [ 'foo', 'bar', Symbol(symbol) ]\n</code></pre>"
             },
             {
               "textRaw": "`emitter.getMaxListeners()`",
@@ -266,7 +965,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns the current max listener value for the <code>EventEmitter</code> which is either\nset by <a href=\"#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> or defaults to\n<a href=\"#events_eventemitter_defaultmaxlisteners\"><code>EventEmitter.defaultMaxListeners</code></a>.</p>"
+              "desc": "<p>Returns the current max listener value for the <code>EventEmitter</code> which is either\nset by <a href=\"#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> or defaults to\n<a href=\"#events_events_defaultmaxlisteners\"><code>events.defaultMaxListeners</code></a>.</p>"
             },
             {
               "textRaw": "`emitter.listenerCount(eventName)`",
@@ -563,7 +1262,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Removes the specified <code>listener</code> from the listener array for the event named\n<code>eventName</code>.</p>\n<pre><code class=\"language-js\">const callback = (stream) => {\n  console.log('someone connected!');\n};\nserver.on('connection', callback);\n// ...\nserver.removeListener('connection', callback);\n</code></pre>\n<p><code>removeListener()</code> will remove, at most, one instance of a listener from the\nlistener array. If any single listener has been added multiple times to the\nlistener array for the specified <code>eventName</code>, then <code>removeListener()</code> must be\ncalled multiple times to remove each instance.</p>\n<p>Once an event has been emitted, all listeners attached to it at the\ntime of emitting will be called in order. This implies that any\n<code>removeListener()</code> or <code>removeAllListeners()</code> calls <em>after</em> emitting and\n<em>before</em> the last listener finishes execution will not remove them from\n<code>emit()</code> in progress. Subsequent events will behave as expected.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\n\nconst callbackA = () => {\n  console.log('A');\n  myEmitter.removeListener('event', callbackB);\n};\n\nconst callbackB = () => {\n  console.log('B');\n};\n\nmyEmitter.on('event', callbackA);\n\nmyEmitter.on('event', callbackB);\n\n// callbackA removes listener callbackB but it will still be called.\n// Internal listener array at time of emit [callbackA, callbackB]\nmyEmitter.emit('event');\n// Prints:\n//   A\n//   B\n\n// callbackB is now removed.\n// Internal listener array [callbackA]\nmyEmitter.emit('event');\n// Prints:\n//   A\n</code></pre>\n<p>Because listeners are managed using an internal array, calling this will\nchange the position indices of any listener registered <em>after</em> the listener\nbeing removed. This will not impact the order in which listeners are called,\nbut it means that any copies of the listener array as returned by\nthe <code>emitter.listeners()</code> method will need to be recreated.</p>\n<p>When a single function has been added as a handler multiple times for a single\nevent (as in the example below), <code>removeListener()</code> will remove the most\nrecently added instance. In the example the <code>once('ping')</code>\nlistener is removed:</p>\n<pre><code class=\"language-js\">const ee = new EventEmitter();\n\nfunction pong() {\n  console.log('pong');\n}\n\nee.on('ping', pong);\nee.once('ping', pong);\nee.removeListener('ping', pong);\n\nee.emit('ping');\nee.emit('ping');\n</code></pre>\n<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>"
+              "desc": "<p>Removes the specified <code>listener</code> from the listener array for the event named\n<code>eventName</code>.</p>\n<pre><code class=\"language-js\">const callback = (stream) => {\n  console.log('someone connected!');\n};\nserver.on('connection', callback);\n// ...\nserver.removeListener('connection', callback);\n</code></pre>\n<p><code>removeListener()</code> will remove, at most, one instance of a listener from the\nlistener array. If any single listener has been added multiple times to the\nlistener array for the specified <code>eventName</code>, then <code>removeListener()</code> must be\ncalled multiple times to remove each instance.</p>\n<p>Once an event is emitted, all listeners attached to it at the\ntime of emitting are called in order. This implies that any\n<code>removeListener()</code> or <code>removeAllListeners()</code> calls <em>after</em> emitting and\n<em>before</em> the last listener finishes execution will not remove them from\n<code>emit()</code> in progress. Subsequent events behave as expected.</p>\n<pre><code class=\"language-js\">const myEmitter = new MyEmitter();\n\nconst callbackA = () => {\n  console.log('A');\n  myEmitter.removeListener('event', callbackB);\n};\n\nconst callbackB = () => {\n  console.log('B');\n};\n\nmyEmitter.on('event', callbackA);\n\nmyEmitter.on('event', callbackB);\n\n// callbackA removes listener callbackB but it will still be called.\n// Internal listener array at time of emit [callbackA, callbackB]\nmyEmitter.emit('event');\n// Prints:\n//   A\n//   B\n\n// callbackB is now removed.\n// Internal listener array [callbackA]\nmyEmitter.emit('event');\n// Prints:\n//   A\n</code></pre>\n<p>Because listeners are managed using an internal array, calling this will\nchange the position indices of any listener registered <em>after</em> the listener\nbeing removed. This will not impact the order in which listeners are called,\nbut it means that any copies of the listener array as returned by\nthe <code>emitter.listeners()</code> method will need to be recreated.</p>\n<p>When a single function has been added as a handler multiple times for a single\nevent (as in the example below), <code>removeListener()</code> will remove the most\nrecently added instance. In the example the <code>once('ping')</code>\nlistener is removed:</p>\n<pre><code class=\"language-js\">const ee = new EventEmitter();\n\nfunction pong() {\n  console.log('pong');\n}\n\nee.on('ping', pong);\nee.once('ping', pong);\nee.removeListener('ping', pong);\n\nee.emit('ping');\nee.emit('ping');\n</code></pre>\n<p>Returns a reference to the <code>EventEmitter</code>, so that calls can be chained.</p>"
             },
             {
               "textRaw": "`emitter.setMaxListeners(n)`",
@@ -622,36 +1321,13 @@
               "desc": "<p>Returns a copy of the array of listeners for the event named <code>eventName</code>,\nincluding any wrappers (such as those created by <code>.once()</code>).</p>\n<pre><code class=\"language-js\">const emitter = new EventEmitter();\nemitter.once('log', () => console.log('log once'));\n\n// Returns a new Array with a function `onceWrapper` which has a property\n// `listener` which contains the original listener bound above\nconst listeners = emitter.rawListeners('log');\nconst logFnWrapper = listeners[0];\n\n// Logs \"log once\" to the console and does not unbind the `once` event\nlogFnWrapper.listener();\n\n// Logs \"log once\" to the console and removes the listener\nlogFnWrapper();\n\nemitter.on('log', () => console.log('log persistently'));\n// Will return a new Array with a single function bound by `.on()` above\nconst newListeners = emitter.rawListeners('log');\n\n// Logs \"log persistently\" twice\nnewListeners[0]();\nemitter.emit('log');\n</code></pre>"
             }
           ],
-          "properties": [
-            {
-              "textRaw": "`EventEmitter.defaultMaxListeners`",
-              "name": "defaultMaxListeners",
-              "meta": {
-                "added": [
-                  "v0.11.2"
-                ],
-                "changes": []
-              },
-              "desc": "<p>By default, a maximum of <code>10</code> listeners can be registered for any single\nevent. This limit can be changed for individual <code>EventEmitter</code> instances\nusing the <a href=\"#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> method. To change the default\nfor <em>all</em> <code>EventEmitter</code> instances, the <code>EventEmitter.defaultMaxListeners</code>\nproperty can be used. If this value is not a positive number, a <code>TypeError</code>\nwill be thrown.</p>\n<p>Take caution when setting the <code>EventEmitter.defaultMaxListeners</code> because the\nchange affects <em>all</em> <code>EventEmitter</code> instances, including those created before\nthe change is made. However, calling <a href=\"#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> still has\nprecedence over <code>EventEmitter.defaultMaxListeners</code>.</p>\n<p>This is not a hard limit. The <code>EventEmitter</code> instance will allow\nmore listeners to be added but will output a trace warning to stderr indicating\nthat a \"possible EventEmitter memory leak\" has been detected. For any single\n<code>EventEmitter</code>, the <code>emitter.getMaxListeners()</code> and <code>emitter.setMaxListeners()</code>\nmethods can be used to temporarily avoid this warning:</p>\n<pre><code class=\"language-js\">emitter.setMaxListeners(emitter.getMaxListeners() + 1);\nemitter.once('event', () => {\n  // do stuff\n  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));\n});\n</code></pre>\n<p>The <a href=\"cli.html#cli_trace_warnings\"><code>--trace-warnings</code></a> command line flag can be used to display the\nstack trace for such warnings.</p>\n<p>The emitted warning can be inspected with <a href=\"process.html#process_event_warning\"><code>process.on('warning')</code></a> and will\nhave the additional <code>emitter</code>, <code>type</code> and <code>count</code> properties, referring to\nthe event emitter instance, the event’s name and the number of attached\nlisteners, respectively.\nIts <code>name</code> property is set to <code>'MaxListenersExceededWarning'</code>.</p>"
-            },
-            {
-              "textRaw": "`EventEmitter.errorMonitor`",
-              "name": "errorMonitor",
-              "meta": {
-                "added": [
-                  "v12.17.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>This symbol shall be used to install a listener for only monitoring <code>'error'</code>\nevents. Listeners installed using this symbol are called before the regular\n<code>'error'</code> listeners are called.</p>\n<p>Installing a listener using this symbol does not change the behavior once an\n<code>'error'</code> event is emitted, therefore the process will still crash if no\nregular <code>'error'</code> listener is installed.</p>"
-            }
-          ],
           "modules": [
             {
               "textRaw": "`emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])`",
               "name": "`emitter[symbol.for('nodejs.rejection')](err,_eventname[,_...args])`",
               "meta": {
                 "added": [
+                  "v13.4.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -665,17 +1341,110 @@
           ]
         }
       ],
+      "properties": [
+        {
+          "textRaw": "`events.defaultMaxListeners`",
+          "name": "defaultMaxListeners",
+          "meta": {
+            "added": [
+              "v0.11.2"
+            ],
+            "changes": []
+          },
+          "desc": "<p>By default, a maximum of <code>10</code> listeners can be registered for any single\nevent. This limit can be changed for individual <code>EventEmitter</code> instances\nusing the <a href=\"#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> method. To change the default\nfor <em>all</em> <code>EventEmitter</code> instances, the <code>events.defaultMaxListeners</code>\nproperty can be used. If this value is not a positive number, a <code>RangeError</code>\nis thrown.</p>\n<p>Take caution when setting the <code>events.defaultMaxListeners</code> because the\nchange affects <em>all</em> <code>EventEmitter</code> instances, including those created before\nthe change is made. However, calling <a href=\"#events_emitter_setmaxlisteners_n\"><code>emitter.setMaxListeners(n)</code></a> still has\nprecedence over <code>events.defaultMaxListeners</code>.</p>\n<p>This is not a hard limit. The <code>EventEmitter</code> instance will allow\nmore listeners to be added but will output a trace warning to stderr indicating\nthat a \"possible EventEmitter memory leak\" has been detected. For any single\n<code>EventEmitter</code>, the <code>emitter.getMaxListeners()</code> and <code>emitter.setMaxListeners()</code>\nmethods can be used to temporarily avoid this warning:</p>\n<pre><code class=\"language-js\">emitter.setMaxListeners(emitter.getMaxListeners() + 1);\nemitter.once('event', () => {\n  // do stuff\n  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));\n});\n</code></pre>\n<p>The <a href=\"cli.html#cli_trace_warnings\"><code>--trace-warnings</code></a> command-line flag can be used to display the\nstack trace for such warnings.</p>\n<p>The emitted warning can be inspected with <a href=\"process.html#process_event_warning\"><code>process.on('warning')</code></a> and will\nhave the additional <code>emitter</code>, <code>type</code> and <code>count</code> properties, referring to\nthe event emitter instance, the event’s name and the number of attached\nlisteners, respectively.\nIts <code>name</code> property is set to <code>'MaxListenersExceededWarning'</code>.</p>"
+        },
+        {
+          "textRaw": "`events.errorMonitor`",
+          "name": "errorMonitor",
+          "meta": {
+            "added": [
+              "v13.6.0",
+              "v12.17.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>This symbol shall be used to install a listener for only monitoring <code>'error'</code>\nevents. Listeners installed using this symbol are called before the regular\n<code>'error'</code> listeners are called.</p>\n<p>Installing a listener using this symbol does not change the behavior once an\n<code>'error'</code> event is emitted, therefore the process will still crash if no\nregular <code>'error'</code> listener is installed.</p>"
+        },
+        {
+          "textRaw": "`events.captureRejections`",
+          "name": "captureRejections",
+          "meta": {
+            "added": [
+              "v13.4.0",
+              "v12.16.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "captureRejections is experimental.",
+          "desc": "<p>Value: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a></p>\n<p>Change the default <code>captureRejections</code> option on all new <code>EventEmitter</code> objects.</p>"
+        },
+        {
+          "textRaw": "`events.captureRejectionSymbol`",
+          "name": "captureRejectionSymbol",
+          "meta": {
+            "added": [
+              "v13.4.0",
+              "v12.16.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "captureRejections is experimental.",
+          "desc": "<p>Value: <code>Symbol.for('nodejs.rejection')</code></p>\n<p>See how to write a custom <a href=\"#events_emitter_symbol_for_nodejs_rejection_err_eventname_args\">rejection handler</a>.</p>"
+        }
+      ],
       "methods": [
         {
-          "textRaw": "`events.once(emitter, name)`",
+          "textRaw": "`events.getEventListeners(emitterOrTarget, eventName)`",
           "type": "method",
-          "name": "once",
+          "name": "getEventListeners",
           "meta": {
             "added": [
-              "v11.13.0"
+              "v14.17.0"
             ],
             "changes": []
           },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {Function[]}",
+                "name": "return",
+                "type": "Function[]"
+              },
+              "params": [
+                {
+                  "textRaw": "`emitterOrTarget` {EventEmitter|EventTarget}",
+                  "name": "emitterOrTarget",
+                  "type": "EventEmitter|EventTarget"
+                },
+                {
+                  "textRaw": "`eventName` {string|symbol}",
+                  "name": "eventName",
+                  "type": "string|symbol"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Returns a copy of the array of listeners for the event named <code>eventName</code>.</p>\n<p>For <code>EventEmitter</code>s this behaves exactly the same as calling <code>.listeners</code> on\nthe emitter.</p>\n<p>For <code>EventTarget</code>s this is the only way to get the event listeners for the\nevent target. This is useful for debugging and diagnostic purposes.</p>\n<pre><code class=\"language-js\">const { getEventListeners, EventEmitter } = require('events');\n\n{\n  const ee = new EventEmitter();\n  const listener = () => console.log('Events are fun');\n  ee.on('foo', listener);\n  getEventListeners(ee, 'foo'); // [listener]\n}\n{\n  const et = new EventTarget();\n  const listener = () => console.log('Events are fun');\n  et.addEventListener('foo', listener);\n  getEventListeners(et, 'foo'); // [listener]\n}\n</code></pre>"
+        },
+        {
+          "textRaw": "`events.once(emitter, name[, options])`",
+          "type": "method",
+          "name": "once",
+          "meta": {
+            "added": [
+              "v11.13.0",
+              "v10.16.0"
+            ],
+            "changes": [
+              {
+                "version": "v14.17.0",
+                "pr-url": "https://github.com/nodejs/node/pull/34912",
+                "description": "The `signal` option is supported now."
+              }
+            ]
+          },
           "signatures": [
             {
               "return": {
@@ -693,11 +1462,24 @@
                   "textRaw": "`name` {string}",
                   "name": "name",
                   "type": "string"
+                },
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`signal` {AbortSignal} Can be used to cancel waiting for the event.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": "Can be used to cancel waiting for the event."
+                    }
+                  ]
                 }
               ]
             }
           ],
-          "desc": "<p>Creates a <code>Promise</code> that is fulfilled when the <code>EventEmitter</code> emits the given\nevent or that is rejected if the <code>EventEmitter</code> emits <code>'error'</code> while waiting.\nThe <code>Promise</code> will resolve with an array of all the arguments emitted to the\ngiven event.</p>\n<p>This method is intentionally generic and works with the web platform\n<a href=\"https://dom.spec.whatwg.org/#interface-eventtarget\">EventTarget</a> interface, which has no special\n<code>'error'</code> event semantics and does not listen to the <code>'error'</code> event.</p>\n<pre><code class=\"language-js\">const { once, EventEmitter } = require('events');\n\nasync function run() {\n  const ee = new EventEmitter();\n\n  process.nextTick(() => {\n    ee.emit('myevent', 42);\n  });\n\n  const [value] = await once(ee, 'myevent');\n  console.log(value);\n\n  const err = new Error('kaboom');\n  process.nextTick(() => {\n    ee.emit('error', err);\n  });\n\n  try {\n    await once(ee, 'myevent');\n  } catch (err) {\n    console.log('error happened', err);\n  }\n}\n\nrun();\n</code></pre>\n<p>The special handling of the <code>'error'</code> event is only used when <code>events.once()</code>\nis used to wait for another event. If <code>events.once()</code> is used to wait for the\n'<code>error'</code> event itself, then it is treated as any other kind of event without\nspecial handling:</p>\n<pre><code class=\"language-js\">const { EventEmitter, once } = require('events');\n\nconst ee = new EventEmitter();\n\nonce(ee, 'error')\n  .then(([err]) => console.log('ok', err.message))\n  .catch((err) => console.log('error', err.message));\n\nee.emit('error', new Error('boom'));\n\n// Prints: ok boom\n</code></pre>",
+          "desc": "<p>Creates a <code>Promise</code> that is fulfilled when the <code>EventEmitter</code> emits the given\nevent or that is rejected if the <code>EventEmitter</code> emits <code>'error'</code> while waiting.\nThe <code>Promise</code> will resolve with an array of all the arguments emitted to the\ngiven event.</p>\n<p>This method is intentionally generic and works with the web platform\n<a href=\"https://dom.spec.whatwg.org/#interface-eventtarget\">EventTarget</a> interface, which has no special\n<code>'error'</code> event semantics and does not listen to the <code>'error'</code> event.</p>\n<pre><code class=\"language-js\">const { once, EventEmitter } = require('events');\n\nasync function run() {\n  const ee = new EventEmitter();\n\n  process.nextTick(() => {\n    ee.emit('myevent', 42);\n  });\n\n  const [value] = await once(ee, 'myevent');\n  console.log(value);\n\n  const err = new Error('kaboom');\n  process.nextTick(() => {\n    ee.emit('error', err);\n  });\n\n  try {\n    await once(ee, 'myevent');\n  } catch (err) {\n    console.log('error happened', err);\n  }\n}\n\nrun();\n</code></pre>\n<p>The special handling of the <code>'error'</code> event is only used when <code>events.once()</code>\nis used to wait for another event. If <code>events.once()</code> is used to wait for the\n'<code>error'</code> event itself, then it is treated as any other kind of event without\nspecial handling:</p>\n<pre><code class=\"language-js\">const { EventEmitter, once } = require('events');\n\nconst ee = new EventEmitter();\n\nonce(ee, 'error')\n  .then(([err]) => console.log('ok', err.message))\n  .catch((err) => console.log('error', err.message));\n\nee.emit('error', new Error('boom'));\n\n// Prints: ok boom\n</code></pre>\n<p>An <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> can be used to cancel waiting for the event:</p>\n<pre><code class=\"language-js\">const { EventEmitter, once } = require('events');\n\nconst ee = new EventEmitter();\nconst ac = new AbortController();\n\nasync function foo(emitter, event, signal) {\n  try {\n    await once(emitter, event, { signal });\n    console.log('event emitted!');\n  } catch (error) {\n    if (error.name === 'AbortError') {\n      console.error('Waiting for the event was canceled!');\n    } else {\n      console.error('There was an error', error.message);\n    }\n  }\n}\n\nfoo(ee, 'foo', ac.signal);\nac.abort(); // Abort waiting for the event\nee.emit('foo'); // Prints: Waiting for the event was canceled!\n</code></pre>",
           "modules": [
             {
               "textRaw": "Awaiting multiple events emitted on `process.nextTick()`",
@@ -709,11 +1491,47 @@
           ]
         },
         {
-          "textRaw": "events.on(emitter, eventName)",
+          "textRaw": "`events.listenerCount(emitter, eventName)`",
+          "type": "method",
+          "name": "listenerCount",
+          "meta": {
+            "added": [
+              "v0.9.12"
+            ],
+            "deprecated": [
+              "v3.2.0"
+            ],
+            "changes": []
+          },
+          "stability": 0,
+          "stabilityText": "Deprecated: Use [`emitter.listenerCount()`][] instead.",
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`emitter` {EventEmitter} The emitter to query",
+                  "name": "emitter",
+                  "type": "EventEmitter",
+                  "desc": "The emitter to query"
+                },
+                {
+                  "textRaw": "`eventName` {string|symbol} The event name",
+                  "name": "eventName",
+                  "type": "string|symbol",
+                  "desc": "The event name"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>A class method that returns the number of listeners for the given <code>eventName</code>\nregistered on the given <code>emitter</code>.</p>\n<pre><code class=\"language-js\">const { EventEmitter, listenerCount } = require('events');\nconst myEmitter = new EventEmitter();\nmyEmitter.on('event', () => {});\nmyEmitter.on('event', () => {});\nconsole.log(listenerCount(myEmitter, 'event'));\n// Prints: 2\n</code></pre>"
+        },
+        {
+          "textRaw": "`events.on(emitter, eventName[, options])`",
           "type": "method",
           "name": "on",
           "meta": {
             "added": [
+              "v13.6.0",
               "v12.16.0"
             ],
             "changes": []
@@ -737,39 +1555,54 @@
                   "name": "eventName",
                   "type": "string|symbol",
                   "desc": "The name of the event being listened for"
+                },
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`signal` {AbortSignal} Can be used to cancel awaiting events.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": "Can be used to cancel awaiting events."
+                    }
+                  ]
                 }
               ]
             }
           ],
-          "desc": "<pre><code class=\"language-js\">const { on, EventEmitter } = require('events');\n\n(async () => {\n  const ee = new EventEmitter();\n\n  // Emit later on\n  process.nextTick(() => {\n    ee.emit('foo', 'bar');\n    ee.emit('foo', 42);\n  });\n\n  for await (const event of on(ee, 'foo')) {\n    // The execution of this inner block is synchronous and it\n    // processes one event at a time (even with await). Do not use\n    // if concurrent execution is required.\n    console.log(event); // prints ['bar'] [42]\n  }\n  // Unreachable here\n})();\n</code></pre>\n<p>Returns an <code>AsyncIterator</code> that iterates <code>eventName</code> events. It will throw\nif the <code>EventEmitter</code> emits <code>'error'</code>. It removes all listeners when\nexiting the loop. The <code>value</code> returned by each iteration is an array\ncomposed of the emitted event arguments.</p>"
-        }
-      ],
-      "properties": [
-        {
-          "textRaw": "`events.captureRejections`",
-          "name": "captureRejections",
-          "meta": {
-            "added": [
-              "v12.16.0"
-            ],
-            "changes": []
-          },
-          "stability": 1,
-          "stabilityText": "captureRejections is experimental.",
-          "desc": "<p>Value: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a></p>\n<p>Change the default <code>captureRejections</code> option on all new <code>EventEmitter</code> objects.</p>"
+          "desc": "<pre><code class=\"language-js\">const { on, EventEmitter } = require('events');\n\n(async () => {\n  const ee = new EventEmitter();\n\n  // Emit later on\n  process.nextTick(() => {\n    ee.emit('foo', 'bar');\n    ee.emit('foo', 42);\n  });\n\n  for await (const event of on(ee, 'foo')) {\n    // The execution of this inner block is synchronous and it\n    // processes one event at a time (even with await). Do not use\n    // if concurrent execution is required.\n    console.log(event); // prints ['bar'] [42]\n  }\n  // Unreachable here\n})();\n</code></pre>\n<p>Returns an <code>AsyncIterator</code> that iterates <code>eventName</code> events. It will throw\nif the <code>EventEmitter</code> emits <code>'error'</code>. It removes all listeners when\nexiting the loop. The <code>value</code> returned by each iteration is an array\ncomposed of the emitted event arguments.</p>\n<p>An <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> can be used to cancel waiting on events:</p>\n<pre><code class=\"language-js\">const { on, EventEmitter } = require('events');\nconst ac = new AbortController();\n\n(async () => {\n  const ee = new EventEmitter();\n\n  // Emit later on\n  process.nextTick(() => {\n    ee.emit('foo', 'bar');\n    ee.emit('foo', 42);\n  });\n\n  for await (const event of on(ee, 'foo', { signal: ac.signal })) {\n    // The execution of this inner block is synchronous and it\n    // processes one event at a time (even with await). Do not use\n    // if concurrent execution is required.\n    console.log(event); // prints ['bar'] [42]\n  }\n  // Unreachable here\n})();\n\nprocess.nextTick(() => ac.abort());\n</code></pre>"
         },
         {
-          "textRaw": "events.captureRejectionSymbol",
-          "name": "captureRejectionSymbol",
+          "textRaw": "`events.setMaxListeners(n[, ...eventTargets])`",
+          "type": "method",
+          "name": "setMaxListeners",
           "meta": {
             "added": [
-              "v12.16.0"
+              "v14.17.0"
             ],
             "changes": []
           },
-          "stability": 1,
-          "stabilityText": "captureRejections is experimental.",
-          "desc": "<p>Value: <code>Symbol.for('nodejs.rejection')</code></p>\n<p>See how to write a custom <a href=\"#events_emitter_symbol_for_nodejs_rejection_err_eventname_args\">rejection handler</a>.</p>"
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`n` {number} A non-negative number. The maximum number of listeners per `EventTarget` event.",
+                  "name": "n",
+                  "type": "number",
+                  "desc": "A non-negative number. The maximum number of listeners per `EventTarget` event."
+                },
+                {
+                  "textRaw": "`...eventsTargets` {EventTarget[]|EventEmitter[]} Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter} objects.",
+                  "name": "...eventsTargets",
+                  "type": "EventTarget[]|EventEmitter[]",
+                  "desc": "Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter} objects."
+                }
+              ]
+            }
+          ],
+          "desc": "<pre><code class=\"language-js\">const {\n  setMaxListeners,\n  EventEmitter\n} = require('events');\n\nconst target = new EventTarget();\nconst emitter = new EventEmitter();\n\nsetMaxListeners(5, target, emitter);\n</code></pre>\n<p><a id=\"event-target-and-event-api\"></a></p>"
         }
       ]
     }
diff --git a/doc/api/events.md b/doc/api/events.md
index eecfa96f8c4312c81a731628a4d96b4f50818602..5cc49018e0ec1128c4bedb97cac0f6d63866447b 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -24,7 +24,7 @@ can be used.
 
 When the `EventEmitter` object emits an event, all of the functions attached
 to that specific event are called _synchronously_. Any values returned by the
-called listeners are _ignored_ and will be discarded.
+called listeners are _ignored_ and discarded.
 
 The following example shows a simple `EventEmitter` instance with a single
 listener. The `eventEmitter.on()` method is used to register listeners, while
@@ -97,7 +97,7 @@ myEmitter.emit('event', 'a', 'b');
 ## Handling events only once
 
 When a listener is registered using the `eventEmitter.on()` method, that
-listener will be invoked _every time_ the named event is emitted.
+listener is invoked _every time_ the named event is emitted.
 
 ```js
 const myEmitter = new MyEmitter();
@@ -158,11 +158,13 @@ myEmitter.emit('error', new Error('whoops!'));
 ```
 
 It is possible to monitor `'error'` events without consuming the emitted error
-by installing a listener using the symbol `errorMonitor`.
+by installing a listener using the symbol `events.errorMonitor`.
 
 ```js
-const myEmitter = new MyEmitter();
-myEmitter.on(EventEmitter.errorMonitor, (err) => {
+const { EventEmitter, errorMonitor } = require('events');
+
+const myEmitter = new EventEmitter();
+myEmitter.on(errorMonitor, (err) => {
   MyMonitoringTool.log(err);
 });
 myEmitter.emit('error', new Error('whoops!'));
@@ -205,12 +207,13 @@ ee2.on('something', async (value) => {
 ee2[Symbol.for('nodejs.rejection')] = console.log;
 ```
 
-Setting `EventEmitter.captureRejections = true` will change the default for all
+Setting `events.captureRejections = true` will change the default for all
 new instances of `EventEmitter`.
 
 ```js
-EventEmitter.captureRejections = true;
-const ee1 = new EventEmitter();
+const events = require('events');
+events.captureRejections = true;
+const ee1 = new events.EventEmitter();
 ee1.on('something', async (value) => {
   throw new Error('kaboom');
 });
@@ -226,7 +229,9 @@ recommendation is to **not use `async` functions as `'error'` event handlers**.
 <!-- YAML
 added: v0.1.26
 changes:
-  - version: v12.16.0
+  - version:
+     - v13.4.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/27867
     description: Added captureRejections option.
 -->
@@ -244,9 +249,9 @@ It supports the following option:
 
 * `captureRejections` {boolean} It enables
   [automatic capturing of promise rejection][capturerejections].
-  Default: `false`.
+  **Default:** `false`.
 
-### Event: 'newListener'
+### Event: `'newListener'`
 <!-- YAML
 added: v0.1.26
 -->
@@ -257,15 +262,17 @@ added: v0.1.26
 The `EventEmitter` instance will emit its own `'newListener'` event *before*
 a listener is added to its internal array of listeners.
 
-Listeners registered for the `'newListener'` event will be passed the event
+Listeners registered for the `'newListener'` event are passed the event
 name and a reference to the listener being added.
 
 The fact that the event is triggered before adding the listener has a subtle
 but important side effect: any *additional* listeners registered to the same
-`name` *within* the `'newListener'` callback will be inserted *before* the
+`name` *within* the `'newListener'` callback are inserted *before* the
 listener that is in the process of being added.
 
 ```js
+class MyEmitter extends EventEmitter {}
+
 const myEmitter = new MyEmitter();
 // Only do this once so we don't loop forever
 myEmitter.once('newListener', (event, listener) => {
@@ -289,7 +296,9 @@ myEmitter.emit('event');
 <!-- YAML
 added: v0.9.3
 changes:
-  - version: v6.1.0, v4.7.0
+  - version:
+    - v6.1.0
+    - v4.7.0
     pr-url: https://github.com/nodejs/node/pull/6394
     description: For listeners attached using `.once()`, the `listener` argument
                  now yields the original listener function.
@@ -300,81 +309,6 @@ changes:
 
 The `'removeListener'` event is emitted *after* the `listener` is removed.
 
-### `EventEmitter.listenerCount(emitter, eventName)`
-<!-- YAML
-added: v0.9.12
-deprecated: v3.2.0
--->
-
-> Stability: 0 - Deprecated: Use [`emitter.listenerCount()`][] instead.
-
-* `emitter` {EventEmitter} The emitter to query
-* `eventName` {string|symbol} The event name
-
-A class method that returns the number of listeners for the given `eventName`
-registered on the given `emitter`.
-
-```js
-const myEmitter = new MyEmitter();
-myEmitter.on('event', () => {});
-myEmitter.on('event', () => {});
-console.log(EventEmitter.listenerCount(myEmitter, 'event'));
-// Prints: 2
-```
-
-### `EventEmitter.defaultMaxListeners`
-<!-- YAML
-added: v0.11.2
--->
-
-By default, a maximum of `10` listeners can be registered for any single
-event. This limit can be changed for individual `EventEmitter` instances
-using the [`emitter.setMaxListeners(n)`][] method. To change the default
-for *all* `EventEmitter` instances, the `EventEmitter.defaultMaxListeners`
-property can be used. If this value is not a positive number, a `TypeError`
-will be thrown.
-
-Take caution when setting the `EventEmitter.defaultMaxListeners` because the
-change affects *all* `EventEmitter` instances, including those created before
-the change is made. However, calling [`emitter.setMaxListeners(n)`][] still has
-precedence over `EventEmitter.defaultMaxListeners`.
-
-This is not a hard limit. The `EventEmitter` instance will allow
-more listeners to be added but will output a trace warning to stderr indicating
-that a "possible EventEmitter memory leak" has been detected. For any single
-`EventEmitter`, the `emitter.getMaxListeners()` and `emitter.setMaxListeners()`
-methods can be used to temporarily avoid this warning:
-
-```js
-emitter.setMaxListeners(emitter.getMaxListeners() + 1);
-emitter.once('event', () => {
-  // do stuff
-  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
-});
-```
-
-The [`--trace-warnings`][] command line flag can be used to display the
-stack trace for such warnings.
-
-The emitted warning can be inspected with [`process.on('warning')`][] and will
-have the additional `emitter`, `type` and `count` properties, referring to
-the event emitter instance, the event’s name and the number of attached
-listeners, respectively.
-Its `name` property is set to `'MaxListenersExceededWarning'`.
-
-### `EventEmitter.errorMonitor`
-<!-- YAML
-added: v12.17.0
--->
-
-This symbol shall be used to install a listener for only monitoring `'error'`
-events. Listeners installed using this symbol are called before the regular
-`'error'` listeners are called.
-
-Installing a listener using this symbol does not change the behavior once an
-`'error'` event is emitted, therefore the process will still crash if no
-regular `'error'` listener is installed.
-
 ### `emitter.addListener(eventName, listener)`
 <!-- YAML
 added: v0.1.26
@@ -441,7 +375,7 @@ added: v6.0.0
 * Returns: {Array}
 
 Returns an array listing the events for which the emitter has registered
-listeners. The values in the array will be strings or `Symbol`s.
+listeners. The values in the array are strings or `Symbol`s.
 
 ```js
 const EventEmitter = require('events');
@@ -465,7 +399,7 @@ added: v1.0.0
 
 Returns the current max listener value for the `EventEmitter` which is either
 set by [`emitter.setMaxListeners(n)`][] or defaults to
-[`EventEmitter.defaultMaxListeners`][].
+[`events.defaultMaxListeners`][].
 
 ### `emitter.listenerCount(eventName)`
 <!-- YAML
@@ -668,11 +602,11 @@ listener array. If any single listener has been added multiple times to the
 listener array for the specified `eventName`, then `removeListener()` must be
 called multiple times to remove each instance.
 
-Once an event has been emitted, all listeners attached to it at the
-time of emitting will be called in order. This implies that any
+Once an event is emitted, all listeners attached to it at the
+time of emitting are called in order. This implies that any
 `removeListener()` or `removeAllListeners()` calls *after* emitting and
 *before* the last listener finishes execution will not remove them from
-`emit()` in progress. Subsequent events will behave as expected.
+`emit()` in progress. Subsequent events behave as expected.
 
 ```js
 const myEmitter = new MyEmitter();
@@ -785,7 +719,9 @@ emitter.emit('log');
 
 ### `emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.4.0
+ - v12.16.0
 -->
 
 > Stability: 1 - captureRejections is experimental.
@@ -819,13 +755,110 @@ class MyClass extends EventEmitter {
 }
 ```
 
-## `events.once(emitter, name)`
+## `events.defaultMaxListeners`
 <!-- YAML
-added: v11.13.0
+added: v0.11.2
+-->
+
+By default, a maximum of `10` listeners can be registered for any single
+event. This limit can be changed for individual `EventEmitter` instances
+using the [`emitter.setMaxListeners(n)`][] method. To change the default
+for *all* `EventEmitter` instances, the `events.defaultMaxListeners`
+property can be used. If this value is not a positive number, a `RangeError`
+is thrown.
+
+Take caution when setting the `events.defaultMaxListeners` because the
+change affects *all* `EventEmitter` instances, including those created before
+the change is made. However, calling [`emitter.setMaxListeners(n)`][] still has
+precedence over `events.defaultMaxListeners`.
+
+This is not a hard limit. The `EventEmitter` instance will allow
+more listeners to be added but will output a trace warning to stderr indicating
+that a "possible EventEmitter memory leak" has been detected. For any single
+`EventEmitter`, the `emitter.getMaxListeners()` and `emitter.setMaxListeners()`
+methods can be used to temporarily avoid this warning:
+
+```js
+emitter.setMaxListeners(emitter.getMaxListeners() + 1);
+emitter.once('event', () => {
+  // do stuff
+  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
+});
+```
+
+The [`--trace-warnings`][] command-line flag can be used to display the
+stack trace for such warnings.
+
+The emitted warning can be inspected with [`process.on('warning')`][] and will
+have the additional `emitter`, `type` and `count` properties, referring to
+the event emitter instance, the event’s name and the number of attached
+listeners, respectively.
+Its `name` property is set to `'MaxListenersExceededWarning'`.
+
+## `events.errorMonitor`
+<!-- YAML
+added:
+ - v13.6.0
+ - v12.17.0
+-->
+
+This symbol shall be used to install a listener for only monitoring `'error'`
+events. Listeners installed using this symbol are called before the regular
+`'error'` listeners are called.
+
+Installing a listener using this symbol does not change the behavior once an
+`'error'` event is emitted, therefore the process will still crash if no
+regular `'error'` listener is installed.
+
+## `events.getEventListeners(emitterOrTarget, eventName)`
+<!-- YAML
+added:
+ - v14.17.0
+-->
+* `emitterOrTarget` {EventEmitter|EventTarget}
+* `eventName` {string|symbol}
+* Returns: {Function[]}
+
+Returns a copy of the array of listeners for the event named `eventName`.
+
+For `EventEmitter`s this behaves exactly the same as calling `.listeners` on
+the emitter.
+
+For `EventTarget`s this is the only way to get the event listeners for the
+event target. This is useful for debugging and diagnostic purposes.
+
+```js
+const { getEventListeners, EventEmitter } = require('events');
+
+{
+  const ee = new EventEmitter();
+  const listener = () => console.log('Events are fun');
+  ee.on('foo', listener);
+  getEventListeners(ee, 'foo'); // [listener]
+}
+{
+  const et = new EventTarget();
+  const listener = () => console.log('Events are fun');
+  et.addEventListener('foo', listener);
+  getEventListeners(et, 'foo'); // [listener]
+}
+```
+
+## `events.once(emitter, name[, options])`
+<!-- YAML
+added:
+ - v11.13.0
+ - v10.16.0
+changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/34912
+    description: The `signal` option is supported now.
 -->
 
 * `emitter` {EventEmitter}
 * `name` {string}
+* `options` {Object}
+  * `signal` {AbortSignal} Can be used to cancel waiting for the event.
 * Returns: {Promise}
 
 Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
@@ -884,6 +917,32 @@ ee.emit('error', new Error('boom'));
 // Prints: ok boom
 ```
 
+An {AbortSignal} can be used to cancel waiting for the event:
+
+```js
+const { EventEmitter, once } = require('events');
+
+const ee = new EventEmitter();
+const ac = new AbortController();
+
+async function foo(emitter, event, signal) {
+  try {
+    await once(emitter, event, { signal });
+    console.log('event emitted!');
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      console.error('Waiting for the event was canceled!');
+    } else {
+      console.error('There was an error', error.message);
+    }
+  }
+}
+
+foo(ee, 'foo', ac.signal);
+ac.abort(); // Abort waiting for the event
+ee.emit('foo'); // Prints: Waiting for the event was canceled!
+```
+
 ### Awaiting multiple events emitted on `process.nextTick()`
 
 There is an edge case worth noting when using the `events.once()` function
@@ -940,7 +999,9 @@ foo().then(() => console.log('done'));
 
 ## `events.captureRejections`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.4.0
+ - v12.16.0
 -->
 
 > Stability: 1 - captureRejections is experimental.
@@ -949,9 +1010,11 @@ Value: {boolean}
 
 Change the default `captureRejections` option on all new `EventEmitter` objects.
 
-## events.captureRejectionSymbol
+## `events.captureRejectionSymbol`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.4.0
+ - v12.16.0
 -->
 
 > Stability: 1 - captureRejections is experimental.
@@ -960,13 +1023,40 @@ Value: `Symbol.for('nodejs.rejection')`
 
 See how to write a custom [rejection handler][rejection].
 
-## events.on(emitter, eventName)
+## `events.listenerCount(emitter, eventName)`
 <!-- YAML
-added: v12.16.0
+added: v0.9.12
+deprecated: v3.2.0
+-->
+
+> Stability: 0 - Deprecated: Use [`emitter.listenerCount()`][] instead.
+
+* `emitter` {EventEmitter} The emitter to query
+* `eventName` {string|symbol} The event name
+
+A class method that returns the number of listeners for the given `eventName`
+registered on the given `emitter`.
+
+```js
+const { EventEmitter, listenerCount } = require('events');
+const myEmitter = new EventEmitter();
+myEmitter.on('event', () => {});
+myEmitter.on('event', () => {});
+console.log(listenerCount(myEmitter, 'event'));
+// Prints: 2
+```
+
+## `events.on(emitter, eventName[, options])`
+<!-- YAML
+added:
+ - v13.6.0
+ - v12.16.0
 -->
 
 * `emitter` {EventEmitter}
 * `eventName` {string|symbol} The name of the event being listened for
+* `options` {Object}
+  * `signal` {AbortSignal} Can be used to cancel awaiting events.
 * Returns: {AsyncIterator} that iterates `eventName` events emitted by the `emitter`
 
 ```js
@@ -996,18 +1086,542 @@ if the `EventEmitter` emits `'error'`. It removes all listeners when
 exiting the loop. The `value` returned by each iteration is an array
 composed of the emitted event arguments.
 
+An {AbortSignal} can be used to cancel waiting on events:
+
+```js
+const { on, EventEmitter } = require('events');
+const ac = new AbortController();
+
+(async () => {
+  const ee = new EventEmitter();
+
+  // Emit later on
+  process.nextTick(() => {
+    ee.emit('foo', 'bar');
+    ee.emit('foo', 42);
+  });
+
+  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
+    // The execution of this inner block is synchronous and it
+    // processes one event at a time (even with await). Do not use
+    // if concurrent execution is required.
+    console.log(event); // prints ['bar'] [42]
+  }
+  // Unreachable here
+})();
+
+process.nextTick(() => ac.abort());
+```
+
+## `events.setMaxListeners(n[, ...eventTargets])`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `n` {number} A non-negative number. The maximum number of listeners per
+  `EventTarget` event.
+* `...eventsTargets` {EventTarget[]|EventEmitter[]} Zero or more {EventTarget}
+  or {EventEmitter} instances. If none are specified, `n` is set as the default
+  max for all newly created {EventTarget} and {EventEmitter} objects.
+
+```js
+const {
+  setMaxListeners,
+  EventEmitter
+} = require('events');
+
+const target = new EventTarget();
+const emitter = new EventEmitter();
+
+setMaxListeners(5, target, emitter);
+```
+
+<a id="event-target-and-event-api"></a>
+## `EventTarget` and `Event` API
+<!-- YAML
+added: v14.5.0
+-->
+
+> Stability: 1 - Experimental
+
+The `EventTarget` and `Event` objects are a Node.js-specific implementation
+of the [`EventTarget` Web API][] that are exposed by some Node.js core APIs.
+Neither the `EventTarget` nor `Event` classes are available for end
+user code to create.
+
+```js
+const target = getEventTargetSomehow();
+
+target.addEventListener('foo', (event) => {
+  console.log('foo event happened!');
+});
+```
+
+### Node.js `EventTarget` vs. DOM `EventTarget`
+
+There are two key differences between the Node.js `EventTarget` and the
+[`EventTarget` Web API][]:
+
+1. Whereas DOM `EventTarget` instances *may* be hierarchical, there is no
+   concept of hierarchy and event propagation in Node.js. That is, an event
+   dispatched to an `EventTarget` does not propagate through a hierarchy of
+   nested target objects that may each have their own set of handlers for the
+   event.
+2. In the Node.js `EventTarget`, if an event listener is an async function
+   or returns a `Promise`, and the returned `Promise` rejects, the rejection
+   is automatically captured and handled the same way as a listener that
+   throws synchronously (see [`EventTarget` error handling][] for details).
+
+### `NodeEventTarget` vs. `EventEmitter`
+
+The `NodeEventTarget` object implements a modified subset of the
+`EventEmitter` API that allows it to closely *emulate* an `EventEmitter` in
+certain situations. A `NodeEventTarget` is *not* an instance of `EventEmitter`
+and cannot be used in place of an `EventEmitter` in most cases.
+
+1. Unlike `EventEmitter`, any given `listener` can be registered at most once
+   per event `type`. Attempts to register a `listener` multiple times are
+   ignored.
+2. The `NodeEventTarget` does not emulate the full `EventEmitter` API.
+   Specifically the `prependListener()`, `prependOnceListener()`,
+   `rawListeners()`, `setMaxListeners()`, `getMaxListeners()`, and
+   `errorMonitor` APIs are not emulated. The `'newListener'` and
+   `'removeListener'` events will also not be emitted.
+3. The `NodeEventTarget` does not implement any special default behavior
+   for events with type `'error'`.
+3. The `NodeEventTarget` supports `EventListener` objects as well as
+   functions as handlers for all event types.
+
+### Event listener
+
+Event listeners registered for an event `type` may either be JavaScript
+functions or objects with a `handleEvent` property whose value is a function.
+
+In either case, the handler function is invoked with the `event` argument
+passed to the `eventTarget.dispatchEvent()` function.
+
+Async functions may be used as event listeners. If an async handler function
+rejects, the rejection is captured and handled as described in
+[`EventTarget` error handling][].
+
+An error thrown by one handler function does not prevent the other handlers
+from being invoked.
+
+The return value of a handler function is ignored.
+
+Handlers are always invoked in the order they were added.
+
+Handler functions may mutate the `event` object.
+
+```js
+function handler1(event) {
+  console.log(event.type);  // Prints 'foo'
+  event.a = 1;
+}
+
+async function handler2(event) {
+  console.log(event.type);  // Prints 'foo'
+  console.log(event.a);  // Prints 1
+}
+
+const handler3 = {
+  handleEvent(event) {
+    console.log(event.type);  // Prints 'foo'
+  }
+};
+
+const handler4 = {
+  async handleEvent(event) {
+    console.log(event.type);  // Prints 'foo'
+  }
+};
+
+const target = getEventTargetSomehow();
+
+target.addEventListener('foo', handler1);
+target.addEventListener('foo', handler2);
+target.addEventListener('foo', handler3);
+target.addEventListener('foo', handler4, { once: true });
+```
+
+### `EventTarget` error handling
+
+When a registered event listener throws (or returns a Promise that rejects),
+by default the error is treated as an uncaught exception on
+`process.nextTick()`. This means uncaught exceptions in `EventTarget`s will
+terminate the Node.js process by default.
+
+Throwing within an event listener will *not* stop the other registered handlers
+from being invoked.
+
+The `EventTarget` does not implement any special default handling for `'error'`
+type events like `EventEmitter`.
+
+Currently errors are first forwarded to the `process.on('error')` event
+before reaching `process.on('uncaughtException')`. This behavior is
+deprecated and will change in a future release to align `EventTarget` with
+other Node.js APIs. Any code relying on the `process.on('error')` event should
+be aligned with the new behavior.
+
+### Class: `Event`
+<!-- YAML
+added: v14.5.0
+-->
+
+The `Event` object is an adaptation of the [`Event` Web API][]. Instances
+are created internally by Node.js.
+
+#### `event.bubbles`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {boolean} Always returns `false`.
+
+This is not used in Node.js and is provided purely for completeness.
+
+#### `event.cancelBubble()`
+<!-- YAML
+added: v14.5.0
+-->
+
+Alias for `event.stopPropagation()`. This is not used in Node.js and is
+provided purely for completeness.
+
+#### `event.cancelable`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {boolean} True if the event was created with the `cancelable` option.
+
+#### `event.composed`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {boolean} Always returns `false`.
+
+This is not used in Node.js and is provided purely for completeness.
+
+#### `event.composedPath()`
+<!-- YAML
+added: v14.5.0
+-->
+
+Returns an array containing the current `EventTarget` as the only entry or
+empty if the event is not being dispatched. This is not used in
+Node.js and is provided purely for completeness.
+
+#### `event.currentTarget`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {EventTarget} The `EventTarget` dispatching the event.
+
+Alias for `event.target`.
+
+#### `event.defaultPrevented`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {boolean}
+
+Is `true` if `cancelable` is `true` and `event.preventDefault()` has been
+called.
+
+#### `event.eventPhase`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {number} Returns `0` while an event is not being dispatched, `2` while
+  it is being dispatched.
+
+This is not used in Node.js and is provided purely for completeness.
+
+#### `event.isTrusted`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {boolean}
+
+The {AbortSignal} `"abort"` event is emitted with `isTrusted` set to `true`. The
+value is `false` in all other cases.
+
+#### `event.preventDefault()`
+<!-- YAML
+added: v14.5.0
+-->
+
+Sets the `defaultPrevented` property to `true` if `cancelable` is `true`.
+
+#### `event.returnValue`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {boolean} True if the event has not been canceled.
+
+This is not used in Node.js and is provided purely for completeness.
+
+#### `event.srcElement`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {EventTarget} The `EventTarget` dispatching the event.
+
+Alias for `event.target`.
+
+#### `event.stopImmediatePropagation()`
+<!-- YAML
+added: v14.5.0
+-->
+
+Stops the invocation of event listeners after the current one completes.
+
+#### `event.stopPropagation()`
+<!-- YAML
+added: v14.5.0
+-->
+
+This is not used in Node.js and is provided purely for completeness.
+
+#### `event.target`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {EventTarget} The `EventTarget` dispatching the event.
+
+#### `event.timeStamp`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {number}
+
+The millisecond timestamp when the `Event` object was created.
+
+#### `event.type`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Type: {string}
+
+The event type identifier.
+
+### Class: `EventTarget`
+<!-- YAML
+added: v14.5.0
+-->
+
+#### `eventTarget.addEventListener(type, listener[, options])`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+* `listener` {Function|EventListener}
+* `options` {Object}
+  * `once` {boolean} When `true`, the listener is automatically removed
+    when it is first invoked. **Default:** `false`.
+  * `passive` {boolean} When `true`, serves as a hint that the listener will
+    not call the `Event` object's `preventDefault()` method.
+    **Default:** `false`.
+  * `capture` {boolean} Not directly used by Node.js. Added for API
+    completeness. **Default:** `false`.
+
+Adds a new handler for the `type` event. Any given `listener` is added
+only once per `type` and per `capture` option value.
+
+If the `once` option is `true`, the `listener` is removed after the
+next time a `type` event is dispatched.
+
+The `capture` option is not used by Node.js in any functional way other than
+tracking registered event listeners per the `EventTarget` specification.
+Specifically, the `capture` option is used as part of the key when registering
+a `listener`. Any individual `listener` may be added once with
+`capture = false`, and once with `capture = true`.
+
+```js
+function handler(event) {}
+
+const target = getEventTargetSomehow();
+target.addEventListener('foo', handler, { capture: true });  // first
+target.addEventListener('foo', handler, { capture: false }); // second
+
+// Removes the second instance of handler
+target.removeEventListener('foo', handler);
+
+// Removes the first instance of handler
+target.removeEventListener('foo', handler, { capture: true });
+```
+
+#### `eventTarget.dispatchEvent(event)`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `event` {Event}
+* Returns: {boolean} `true` if either event’s `cancelable` attribute value is
+  false or its `preventDefault()` method was not invoked, otherwise `false`.
+
+Dispatches the `event` to the list of handlers for `event.type`.
+
+The registered event listeners is synchronously invoked in the order they
+were registered.
+
+#### `eventTarget.removeEventListener(type, listener)`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+* `listener` {Function|EventListener}
+* `options` {Object}
+  * `capture` {boolean}
+
+Removes the `listener` from the list of handlers for event `type`.
+
+### Class: `NodeEventTarget`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Extends: {EventTarget}
+
+The `NodeEventTarget` is a Node.js-specific extension to `EventTarget`
+that emulates a subset of the `EventEmitter` API.
+
+#### `nodeEventTarget.addListener(type, listener[, options])`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+* `listener` {Function|EventListener}
+* `options` {Object}
+  * `once` {boolean}
+
+* Returns: {EventTarget} this
+
+Node.js-specific extension to the `EventTarget` class that emulates the
+equivalent `EventEmitter` API. The only difference between `addListener()` and
+`addEventListener()` is that `addListener()` will return a reference to the
+`EventTarget`.
+
+#### `nodeEventTarget.eventNames()`
+<!-- YAML
+added: v14.5.0
+-->
+
+* Returns: {string[]}
+
+Node.js-specific extension to the `EventTarget` class that returns an array
+of event `type` names for which event listeners are registered.
+
+#### `nodeEventTarget.listenerCount(type)`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+
+* Returns: {number}
+
+Node.js-specific extension to the `EventTarget` class that returns the number
+of event listeners registered for the `type`.
+
+#### `nodeEventTarget.off(type, listener)`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+* `listener` {Function|EventListener}
+
+* Returns: {EventTarget} this
+
+Node.js-specific alias for `eventTarget.removeListener()`.
+
+#### `nodeEventTarget.on(type, listener[, options])`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+* `listener` {Function|EventListener}
+* `options` {Object}
+  * `once` {boolean}
+
+* Returns: {EventTarget} this
+
+Node.js-specific alias for `eventTarget.addListener()`.
+
+#### `nodeEventTarget.once(type, listener[, options])`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+* `listener` {Function|EventListener}
+* `options` {Object}
+
+* Returns: {EventTarget} this
+
+Node.js-specific extension to the `EventTarget` class that adds a `once`
+listener for the given event `type`. This is equivalent to calling `on`
+with the `once` option set to `true`.
+
+#### `nodeEventTarget.removeAllListeners([type])`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+
+* Returns: {EventTarget} this
+
+Node.js-specific extension to the `EventTarget` class. If `type` is specified,
+removes all registered listeners for `type`, otherwise removes all registered
+listeners.
+
+#### `nodeEventTarget.removeListener(type, listener)`
+<!-- YAML
+added: v14.5.0
+-->
+
+* `type` {string}
+* `listener` {Function|EventListener}
+
+* Returns: {EventTarget} this
+
+Node.js-specific extension to the `EventTarget` class that removes the
+`listener` for the given `type`. The only difference between `removeListener()`
+and `removeEventListener()` is that `removeListener()` will return a reference
+to the `EventTarget`.
+
 [WHATWG-EventTarget]: https://dom.spec.whatwg.org/#interface-eventtarget
-[`--trace-warnings`]: cli.html#cli_trace_warnings
-[`EventEmitter.defaultMaxListeners`]: #events_eventemitter_defaultmaxlisteners
-[`domain`]: domain.html
+[`--trace-warnings`]: cli.md#cli_trace_warnings
+[`EventTarget` Web API]: https://dom.spec.whatwg.org/#eventtarget
+[`EventTarget` error handling]: #events_eventtarget_error_handling
+[`Event` Web API]: https://dom.spec.whatwg.org/#event
+[`domain`]: domain.md
 [`emitter.listenerCount()`]: #events_emitter_listenercount_eventname
 [`emitter.removeListener()`]: #events_emitter_removelistener_eventname_listener
 [`emitter.setMaxListeners(n)`]: #events_emitter_setmaxlisteners_n
-[`fs.ReadStream`]: fs.html#fs_class_fs_readstream
-[`net.Server`]: net.html#net_class_net_server
-[`process.on('warning')`]: process.html#process_event_warning
-[stream]: stream.html
+[`events.defaultMaxListeners`]: #events_events_defaultmaxlisteners
+[`fs.ReadStream`]: fs.md#fs_class_fs_readstream
+[`net.Server`]: net.md#net_class_net_server
+[`process.on('warning')`]: process.md#process_event_warning
 [capturerejections]: #events_capture_rejections_of_promises
+[error]: #events_error_events
 [rejection]: #events_emitter_symbol_for_nodejs_rejection_err_eventname_args
 [rejectionsymbol]: #events_events_capturerejectionsymbol
-[error]: #events_error_events
+[stream]: stream.md
diff --git a/doc/api/fs.html b/doc/api/fs.html
index 87d353e3f1de98629c1ad289c086bbd8b6819617..db70d2a9c00012323b1eeb53a60c37188abcc124 100644
--- a/doc/api/fs.html
+++ b/doc/api/fs.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>File system | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>File system | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="fs" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/fs.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/fs.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/fs.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/fs.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/fs.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/fs.html">13.x</a></li>
@@ -118,28 +133,196 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/fs.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/fs.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/fs.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#fs_file_system">File system</a></span>
 <ul>
-<li><a href="#fs_synchronous_example">Synchronous example</a></li>
-<li><a href="#fs_callback_example">Callback example</a></li>
 <li><a href="#fs_promise_example">Promise example</a></li>
-<li><a href="#fs_ordering_of_callback_and_promise_based_operations">Ordering of callback and promise-based operations</a></li>
-<li><a href="#fs_file_paths">File paths</a>
+<li><a href="#fs_callback_example">Callback example</a></li>
+<li><a href="#fs_synchronous_example">Synchronous example</a></li>
+<li><a href="#fs_promises_api">Promises API</a>
+<ul>
+<li><a href="#fs_class_filehandle">Class: <code>FileHandle</code></a>
+<ul>
+<li><a href="#fs_filehandle_appendfile_data_options"><code>filehandle.appendFile(data[, options])</code></a></li>
+<li><a href="#fs_filehandle_chmod_mode"><code>filehandle.chmod(mode)</code></a></li>
+<li><a href="#fs_filehandle_chown_uid_gid"><code>filehandle.chown(uid, gid)</code></a></li>
+<li><a href="#fs_filehandle_close"><code>filehandle.close()</code></a></li>
+<li><a href="#fs_filehandle_datasync"><code>filehandle.datasync()</code></a></li>
+<li><a href="#fs_filehandle_fd"><code>filehandle.fd</code></a></li>
+<li><a href="#fs_filehandle_read_buffer_offset_length_position"><code>filehandle.read(buffer, offset, length, position)</code></a></li>
+<li><a href="#fs_filehandle_read_options"><code>filehandle.read([options])</code></a></li>
+<li><a href="#fs_filehandle_readfile_options"><code>filehandle.readFile(options)</code></a></li>
+<li><a href="#fs_filehandle_readv_buffers_position"><code>filehandle.readv(buffers[, position])</code></a></li>
+<li><a href="#fs_filehandle_stat_options"><code>filehandle.stat([options])</code></a></li>
+<li><a href="#fs_filehandle_sync"><code>filehandle.sync()</code></a></li>
+<li><a href="#fs_filehandle_truncate_len"><code>filehandle.truncate(len)</code></a></li>
+<li><a href="#fs_filehandle_utimes_atime_mtime"><code>filehandle.utimes(atime, mtime)</code></a></li>
+<li><a href="#fs_filehandle_write_buffer_offset_length_position"><code>filehandle.write(buffer[, offset[, length[, position]]])</code></a></li>
+<li><a href="#fs_filehandle_write_string_position_encoding"><code>filehandle.write(string[, position[, encoding]])</code></a></li>
+<li><a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile(data, options)</code></a></li>
+<li><a href="#fs_filehandle_writev_buffers_position"><code>filehandle.writev(buffers[, position])</code></a></li>
+</ul>
+</li>
+<li><a href="#fs_fspromises_access_path_mode"><code>fsPromises.access(path[, mode])</code></a></li>
+<li><a href="#fs_fspromises_appendfile_path_data_options"><code>fsPromises.appendFile(path, data[, options])</code></a></li>
+<li><a href="#fs_fspromises_chmod_path_mode"><code>fsPromises.chmod(path, mode)</code></a></li>
+<li><a href="#fs_fspromises_chown_path_uid_gid"><code>fsPromises.chown(path, uid, gid)</code></a></li>
+<li><a href="#fs_fspromises_copyfile_src_dest_mode"><code>fsPromises.copyFile(src, dest[, mode])</code></a></li>
+<li><a href="#fs_fspromises_lchmod_path_mode"><code>fsPromises.lchmod(path, mode)</code></a></li>
+<li><a href="#fs_fspromises_lchown_path_uid_gid"><code>fsPromises.lchown(path, uid, gid)</code></a></li>
+<li><a href="#fs_fspromises_lutimes_path_atime_mtime"><code>fsPromises.lutimes(path, atime, mtime)</code></a></li>
+<li><a href="#fs_fspromises_link_existingpath_newpath"><code>fsPromises.link(existingPath, newPath)</code></a></li>
+<li><a href="#fs_fspromises_lstat_path_options"><code>fsPromises.lstat(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_mkdir_path_options"><code>fsPromises.mkdir(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_mkdtemp_prefix_options"><code>fsPromises.mkdtemp(prefix[, options])</code></a></li>
+<li><a href="#fs_fspromises_open_path_flags_mode"><code>fsPromises.open(path, flags[, mode])</code></a></li>
+<li><a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_readdir_path_options"><code>fsPromises.readdir(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_readfile_path_options"><code>fsPromises.readFile(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_readlink_path_options"><code>fsPromises.readlink(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_realpath_path_options"><code>fsPromises.realpath(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_rename_oldpath_newpath"><code>fsPromises.rename(oldPath, newPath)</code></a></li>
+<li><a href="#fs_fspromises_rmdir_path_options"><code>fsPromises.rmdir(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_rm_path_options"><code>fsPromises.rm(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_stat_path_options"><code>fsPromises.stat(path[, options])</code></a></li>
+<li><a href="#fs_fspromises_symlink_target_path_type"><code>fsPromises.symlink(target, path[, type])</code></a></li>
+<li><a href="#fs_fspromises_truncate_path_len"><code>fsPromises.truncate(path[, len])</code></a></li>
+<li><a href="#fs_fspromises_unlink_path"><code>fsPromises.unlink(path)</code></a></li>
+<li><a href="#fs_fspromises_utimes_path_atime_mtime"><code>fsPromises.utimes(path, atime, mtime)</code></a></li>
+<li><a href="#fs_fspromises_watch_filename_options"><code>fsPromises.watch(filename[, options])</code></a></li>
+<li><a href="#fs_fspromises_writefile_file_data_options"><code>fsPromises.writeFile(file, data[, options])</code></a></li>
+</ul>
+</li>
+<li><a href="#fs_callback_api">Callback API</a>
+<ul>
+<li><a href="#fs_fs_access_path_mode_callback"><code>fs.access(path[, mode], callback)</code></a></li>
+<li><a href="#fs_fs_appendfile_path_data_options_callback"><code>fs.appendFile(path, data[, options], callback)</code></a></li>
+<li><a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod(path, mode, callback)</code></a>
 <ul>
-<li><a href="#fs_url_object_support">URL object support</a></li>
+<li><a href="#fs_file_modes">File modes</a></li>
 </ul>
 </li>
+<li><a href="#fs_fs_chown_path_uid_gid_callback"><code>fs.chown(path, uid, gid, callback)</code></a></li>
+<li><a href="#fs_fs_close_fd_callback"><code>fs.close(fd[, callback])</code></a></li>
+<li><a href="#fs_fs_copyfile_src_dest_mode_callback"><code>fs.copyFile(src, dest[, mode], callback)</code></a></li>
+<li><a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream(path[, options])</code></a></li>
+<li><a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream(path[, options])</code></a></li>
+<li><span class="stability_0"><a href="#fs_fs_exists_path_callback"><code>fs.exists(path, callback)</code></a></span></li>
+<li><a href="#fs_fs_fchmod_fd_mode_callback"><code>fs.fchmod(fd, mode, callback)</code></a></li>
+<li><a href="#fs_fs_fchown_fd_uid_gid_callback"><code>fs.fchown(fd, uid, gid, callback)</code></a></li>
+<li><a href="#fs_fs_fdatasync_fd_callback"><code>fs.fdatasync(fd, callback)</code></a></li>
+<li><a href="#fs_fs_fstat_fd_options_callback"><code>fs.fstat(fd[, options], callback)</code></a></li>
+<li><a href="#fs_fs_fsync_fd_callback"><code>fs.fsync(fd, callback)</code></a></li>
+<li><a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate(fd[, len], callback)</code></a></li>
+<li><a href="#fs_fs_futimes_fd_atime_mtime_callback"><code>fs.futimes(fd, atime, mtime, callback)</code></a></li>
+<li><a href="#fs_fs_lchmod_path_mode_callback"><code>fs.lchmod(path, mode, callback)</code></a></li>
+<li><a href="#fs_fs_lchown_path_uid_gid_callback"><code>fs.lchown(path, uid, gid, callback)</code></a></li>
+<li><a href="#fs_fs_lutimes_path_atime_mtime_callback"><code>fs.lutimes(path, atime, mtime, callback)</code></a></li>
+<li><a href="#fs_fs_link_existingpath_newpath_callback"><code>fs.link(existingPath, newPath, callback)</code></a></li>
+<li><a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_mkdir_path_options_callback"><code>fs.mkdir(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_mkdtemp_prefix_options_callback"><code>fs.mkdtemp(prefix[, options], callback)</code></a></li>
+<li><a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open(path[, flags[, mode]], callback)</code></a></li>
+<li><a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read(fd, buffer, offset, length, position, callback)</code></a></li>
+<li><a href="#fs_fs_read_fd_options_callback"><code>fs.read(fd, [options,] callback)</code></a></li>
+<li><a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile(path[, options], callback)</code></a>
+<ul>
 <li><a href="#fs_file_descriptors">File descriptors</a></li>
-<li><a href="#fs_threadpool_usage">Threadpool usage</a></li>
+<li><a href="#fs_performance_considerations">Performance Considerations</a></li>
+</ul>
+</li>
+<li><a href="#fs_fs_readlink_path_options_callback"><code>fs.readlink(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv(fd, buffers[, position], callback)</code></a></li>
+<li><a href="#fs_fs_realpath_path_options_callback"><code>fs.realpath(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_realpath_native_path_options_callback"><code>fs.realpath.native(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_rename_oldpath_newpath_callback"><code>fs.rename(oldPath, newPath, callback)</code></a></li>
+<li><a href="#fs_fs_rmdir_path_options_callback"><code>fs.rmdir(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_rm_path_options_callback"><code>fs.rm(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_stat_path_options_callback"><code>fs.stat(path[, options], callback)</code></a></li>
+<li><a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink(target, path[, type], callback)</code></a></li>
+<li><a href="#fs_fs_truncate_path_len_callback"><code>fs.truncate(path[, len], callback)</code></a></li>
+<li><a href="#fs_fs_unlink_path_callback"><code>fs.unlink(path, callback)</code></a></li>
+<li><a href="#fs_fs_unwatchfile_filename_listener"><code>fs.unwatchFile(filename[, listener])</code></a></li>
+<li><a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes(path, atime, mtime, callback)</code></a></li>
+<li><a href="#fs_fs_watch_filename_options_listener"><code>fs.watch(filename[, options][, listener])</code></a>
+<ul>
+<li><a href="#fs_caveats">Caveats</a>
+<ul>
+<li><a href="#fs_availability">Availability</a></li>
+<li><a href="#fs_inodes">Inodes</a></li>
+<li><a href="#fs_filename_argument">Filename argument</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a href="#fs_fs_watchfile_filename_options_listener"><code>fs.watchFile(filename[, options], listener)</code></a></li>
+<li><a href="#fs_fs_write_fd_buffer_offset_length_position_callback"><code>fs.write(fd, buffer[, offset[, length[, position]]], callback)</code></a></li>
+<li><a href="#fs_fs_write_fd_string_position_encoding_callback"><code>fs.write(fd, string[, position[, encoding]], callback)</code></a></li>
+<li><a href="#fs_fs_writefile_file_data_options_callback"><code>fs.writeFile(file, data[, options], callback)</code></a>
+<ul>
+<li><a href="#fs_using_fs_writefile_with_file_descriptors">Using <code>fs.writeFile()</code> with file descriptors</a></li>
+</ul>
+</li>
+<li><a href="#fs_fs_writev_fd_buffers_position_callback"><code>fs.writev(fd, buffers[, position], callback)</code></a></li>
+</ul>
+</li>
+<li><a href="#fs_synchronous_api">Synchronous API</a>
+<ul>
+<li><a href="#fs_fs_accesssync_path_mode"><code>fs.accessSync(path[, mode])</code></a></li>
+<li><a href="#fs_fs_appendfilesync_path_data_options"><code>fs.appendFileSync(path, data[, options])</code></a></li>
+<li><a href="#fs_fs_chmodsync_path_mode"><code>fs.chmodSync(path, mode)</code></a></li>
+<li><a href="#fs_fs_chownsync_path_uid_gid"><code>fs.chownSync(path, uid, gid)</code></a></li>
+<li><a href="#fs_fs_closesync_fd"><code>fs.closeSync(fd)</code></a></li>
+<li><a href="#fs_fs_copyfilesync_src_dest_mode"><code>fs.copyFileSync(src, dest[, mode])</code></a></li>
+<li><a href="#fs_fs_existssync_path"><code>fs.existsSync(path)</code></a></li>
+<li><a href="#fs_fs_fchmodsync_fd_mode"><code>fs.fchmodSync(fd, mode)</code></a></li>
+<li><a href="#fs_fs_fchownsync_fd_uid_gid"><code>fs.fchownSync(fd, uid, gid)</code></a></li>
+<li><a href="#fs_fs_fdatasyncsync_fd"><code>fs.fdatasyncSync(fd)</code></a></li>
+<li><a href="#fs_fs_fstatsync_fd_options"><code>fs.fstatSync(fd[, options])</code></a></li>
+<li><a href="#fs_fs_fsyncsync_fd"><code>fs.fsyncSync(fd)</code></a></li>
+<li><a href="#fs_fs_ftruncatesync_fd_len"><code>fs.ftruncateSync(fd[, len])</code></a></li>
+<li><a href="#fs_fs_futimessync_fd_atime_mtime"><code>fs.futimesSync(fd, atime, mtime)</code></a></li>
+<li><a href="#fs_fs_lchmodsync_path_mode"><code>fs.lchmodSync(path, mode)</code></a></li>
+<li><a href="#fs_fs_lchownsync_path_uid_gid"><code>fs.lchownSync(path, uid, gid)</code></a></li>
+<li><a href="#fs_fs_lutimessync_path_atime_mtime"><code>fs.lutimesSync(path, atime, mtime)</code></a></li>
+<li><a href="#fs_fs_linksync_existingpath_newpath"><code>fs.linkSync(existingPath, newPath)</code></a></li>
+<li><a href="#fs_fs_lstatsync_path_options"><code>fs.lstatSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_mkdirsync_path_options"><code>fs.mkdirSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_mkdtempsync_prefix_options"><code>fs.mkdtempSync(prefix[, options])</code></a></li>
+<li><a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_opensync_path_flags_mode"><code>fs.openSync(path[, flags[, mode]])</code></a></li>
+<li><a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_readfilesync_path_options"><code>fs.readFileSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_readlinksync_path_options"><code>fs.readlinkSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_readsync_fd_buffer_offset_length_position"><code>fs.readSync(fd, buffer, offset, length, position)</code></a></li>
+<li><a href="#fs_fs_readsync_fd_buffer_options"><code>fs.readSync(fd, buffer, [options])</code></a></li>
+<li><a href="#fs_fs_readvsync_fd_buffers_position"><code>fs.readvSync(fd, buffers[, position])</code></a></li>
+<li><a href="#fs_fs_realpathsync_path_options"><code>fs.realpathSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_realpathsync_native_path_options"><code>fs.realpathSync.native(path[, options])</code></a></li>
+<li><a href="#fs_fs_renamesync_oldpath_newpath"><code>fs.renameSync(oldPath, newPath)</code></a></li>
+<li><a href="#fs_fs_rmdirsync_path_options"><code>fs.rmdirSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_rmsync_path_options"><code>fs.rmSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_statsync_path_options"><code>fs.statSync(path[, options])</code></a></li>
+<li><a href="#fs_fs_symlinksync_target_path_type"><code>fs.symlinkSync(target, path[, type])</code></a></li>
+<li><a href="#fs_fs_truncatesync_path_len"><code>fs.truncateSync(path[, len])</code></a></li>
+<li><a href="#fs_fs_unlinksync_path"><code>fs.unlinkSync(path)</code></a></li>
+<li><a href="#fs_fs_utimessync_path_atime_mtime"><code>fs.utimesSync(path, atime, mtime)</code></a></li>
+<li><a href="#fs_fs_writefilesync_file_data_options"><code>fs.writeFileSync(file, data[, options])</code></a></li>
+<li><a href="#fs_fs_writesync_fd_buffer_offset_length_position"><code>fs.writeSync(fd, buffer[, offset[, length[, position]]])</code></a></li>
+<li><a href="#fs_fs_writesync_fd_string_position_encoding"><code>fs.writeSync(fd, string[, position[, encoding]])</code></a></li>
+<li><a href="#fs_fs_writevsync_fd_buffers_position"><code>fs.writevSync(fd, buffers[, position])</code></a></li>
+</ul>
+</li>
+<li><a href="#fs_common_objects">Common Objects</a>
+<ul>
 <li><a href="#fs_class_fs_dir">Class: <code>fs.Dir</code></a>
 <ul>
 <li><a href="#fs_dir_close"><code>dir.close()</code></a></li>
@@ -230,1148 +413,1298 @@
 <li><a href="#fs_event_open_1">Event: <code>'open'</code></a></li>
 <li><a href="#fs_event_ready_1">Event: <code>'ready'</code></a></li>
 <li><a href="#fs_writestream_byteswritten"><code>writeStream.bytesWritten</code></a></li>
+<li><a href="#fs_writestream_close_callback"><code>writeStream.close([callback])</code></a></li>
 <li><a href="#fs_writestream_path"><code>writeStream.path</code></a></li>
 <li><a href="#fs_writestream_pending"><code>writeStream.pending</code></a></li>
 </ul>
 </li>
-<li><a href="#fs_fs_access_path_mode_callback"><code>fs.access(path[, mode], callback)</code></a></li>
-<li><a href="#fs_fs_accesssync_path_mode"><code>fs.accessSync(path[, mode])</code></a></li>
-<li><a href="#fs_fs_appendfile_path_data_options_callback"><code>fs.appendFile(path, data[, options], callback)</code></a></li>
-<li><a href="#fs_fs_appendfilesync_path_data_options"><code>fs.appendFileSync(path, data[, options])</code></a></li>
-<li><a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod(path, mode, callback)</code></a>
+<li><a href="#fs_fs_constants"><code>fs.constants</code></a>
 <ul>
-<li><a href="#fs_file_modes">File modes</a></li>
+<li><a href="#fs_fs_constants_1">FS constants</a>
+<ul>
+<li><a href="#fs_file_access_constants">File access constants</a></li>
+<li><a href="#fs_file_copy_constants">File copy constants</a></li>
+<li><a href="#fs_file_open_constants">File open constants</a></li>
+<li><a href="#fs_file_type_constants">File type constants</a></li>
+<li><a href="#fs_file_mode_constants">File mode constants</a></li>
 </ul>
 </li>
-<li><a href="#fs_fs_chmodsync_path_mode"><code>fs.chmodSync(path, mode)</code></a></li>
-<li><a href="#fs_fs_chown_path_uid_gid_callback"><code>fs.chown(path, uid, gid, callback)</code></a></li>
-<li><a href="#fs_fs_chownsync_path_uid_gid"><code>fs.chownSync(path, uid, gid)</code></a></li>
-<li><a href="#fs_fs_close_fd_callback"><code>fs.close(fd, callback)</code></a></li>
-<li><a href="#fs_fs_closesync_fd"><code>fs.closeSync(fd)</code></a></li>
-<li><a href="#fs_fs_constants"><code>fs.constants</code></a></li>
-<li><a href="#fs_fs_copyfile_src_dest_flags_callback"><code>fs.copyFile(src, dest[, flags], callback)</code></a></li>
-<li><a href="#fs_fs_copyfilesync_src_dest_flags"><code>fs.copyFileSync(src, dest[, flags])</code></a></li>
-<li><a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream(path[, options])</code></a></li>
-<li><a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream(path[, options])</code></a></li>
-<li><span class="stability_0"><a href="#fs_fs_exists_path_callback"><code>fs.exists(path, callback)</code></a></span></li>
-<li><a href="#fs_fs_existssync_path"><code>fs.existsSync(path)</code></a></li>
-<li><a href="#fs_fs_fchmod_fd_mode_callback"><code>fs.fchmod(fd, mode, callback)</code></a></li>
-<li><a href="#fs_fs_fchmodsync_fd_mode"><code>fs.fchmodSync(fd, mode)</code></a></li>
-<li><a href="#fs_fs_fchown_fd_uid_gid_callback"><code>fs.fchown(fd, uid, gid, callback)</code></a></li>
-<li><a href="#fs_fs_fchownsync_fd_uid_gid"><code>fs.fchownSync(fd, uid, gid)</code></a></li>
-<li><a href="#fs_fs_fdatasync_fd_callback"><code>fs.fdatasync(fd, callback)</code></a></li>
-<li><a href="#fs_fs_fdatasyncsync_fd"><code>fs.fdatasyncSync(fd)</code></a></li>
-<li><a href="#fs_fs_fstat_fd_options_callback"><code>fs.fstat(fd[, options], callback)</code></a></li>
-<li><a href="#fs_fs_fstatsync_fd_options"><code>fs.fstatSync(fd[, options])</code></a></li>
-<li><a href="#fs_fs_fsync_fd_callback"><code>fs.fsync(fd, callback)</code></a></li>
-<li><a href="#fs_fs_fsyncsync_fd"><code>fs.fsyncSync(fd)</code></a></li>
-<li><a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate(fd[, len], callback)</code></a></li>
-<li><a href="#fs_fs_ftruncatesync_fd_len"><code>fs.ftruncateSync(fd[, len])</code></a></li>
-<li><a href="#fs_fs_futimes_fd_atime_mtime_callback"><code>fs.futimes(fd, atime, mtime, callback)</code></a></li>
-<li><a href="#fs_fs_futimessync_fd_atime_mtime"><code>fs.futimesSync(fd, atime, mtime)</code></a></li>
-<li><a href="#fs_fs_lchmod_path_mode_callback"><code>fs.lchmod(path, mode, callback)</code></a></li>
-<li><a href="#fs_fs_lchmodsync_path_mode"><code>fs.lchmodSync(path, mode)</code></a></li>
-<li><a href="#fs_fs_lchown_path_uid_gid_callback"><code>fs.lchown(path, uid, gid, callback)</code></a></li>
-<li><a href="#fs_fs_lchownsync_path_uid_gid"><code>fs.lchownSync(path, uid, gid)</code></a></li>
-<li><a href="#fs_fs_lutimes_path_atime_mtime_callback"><code>fs.lutimes(path, atime, mtime, callback)</code></a></li>
-<li><a href="#fs_fs_lutimessync_path_atime_mtime"><code>fs.lutimesSync(path, atime, mtime)</code></a></li>
-<li><a href="#fs_fs_link_existingpath_newpath_callback"><code>fs.link(existingPath, newPath, callback)</code></a></li>
-<li><a href="#fs_fs_linksync_existingpath_newpath"><code>fs.linkSync(existingPath, newPath)</code></a></li>
-<li><a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_lstatsync_path_options"><code>fs.lstatSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_mkdir_path_options_callback"><code>fs.mkdir(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_mkdirsync_path_options"><code>fs.mkdirSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_mkdtemp_prefix_options_callback"><code>fs.mkdtemp(prefix[, options], callback)</code></a></li>
-<li><a href="#fs_fs_mkdtempsync_prefix_options"><code>fs.mkdtempSync(prefix[, options])</code></a></li>
-<li><a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open(path[, flags[, mode]], callback)</code></a></li>
-<li><a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_opensync_path_flags_mode"><code>fs.openSync(path[, flags, mode])</code></a></li>
-<li><a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read(fd, buffer, offset, length, position, callback)</code></a></li>
-<li><a href="#fs_fs_read_fd_options_callback"><code>fs.read(fd, [options,] callback)</code></a></li>
-<li><a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile(path[, options], callback)</code></a>
-<ul>
-<li><a href="#fs_file_descriptors_1">File descriptors</a></li>
 </ul>
 </li>
-<li><a href="#fs_fs_readfilesync_path_options"><code>fs.readFileSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_readlink_path_options_callback"><code>fs.readlink(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_readlinksync_path_options"><code>fs.readlinkSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_readsync_fd_buffer_offset_length_position"><code>fs.readSync(fd, buffer, offset, length, position)</code></a></li>
-<li><a href="#fs_fs_readsync_fd_buffer_options"><code>fs.readSync(fd, buffer, [options])</code></a></li>
-<li><a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv(fd, buffers[, position], callback)</code></a></li>
-<li><a href="#fs_fs_readvsync_fd_buffers_position"><code>fs.readvSync(fd, buffers[, position])</code></a></li>
-<li><a href="#fs_fs_realpath_path_options_callback"><code>fs.realpath(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_realpath_native_path_options_callback"><code>fs.realpath.native(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_realpathsync_path_options"><code>fs.realpathSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_realpathsync_native_path_options"><code>fs.realpathSync.native(path[, options])</code></a></li>
-<li><a href="#fs_fs_rename_oldpath_newpath_callback"><code>fs.rename(oldPath, newPath, callback)</code></a></li>
-<li><a href="#fs_fs_renamesync_oldpath_newpath"><code>fs.renameSync(oldPath, newPath)</code></a></li>
-<li><span class="stability_1"><a href="#fs_fs_rmdir_path_options_callback"><code>fs.rmdir(path[, options], callback)</code></a></span></li>
-<li><span class="stability_1"><a href="#fs_fs_rmdirsync_path_options"><code>fs.rmdirSync(path[, options])</code></a></span></li>
-<li><a href="#fs_fs_stat_path_options_callback"><code>fs.stat(path[, options], callback)</code></a></li>
-<li><a href="#fs_fs_statsync_path_options"><code>fs.statSync(path[, options])</code></a></li>
-<li><a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink(target, path[, type], callback)</code></a></li>
-<li><a href="#fs_fs_symlinksync_target_path_type"><code>fs.symlinkSync(target, path[, type])</code></a></li>
-<li><a href="#fs_fs_truncate_path_len_callback"><code>fs.truncate(path[, len], callback)</code></a></li>
-<li><a href="#fs_fs_truncatesync_path_len"><code>fs.truncateSync(path[, len])</code></a></li>
-<li><a href="#fs_fs_unlink_path_callback"><code>fs.unlink(path, callback)</code></a></li>
-<li><a href="#fs_fs_unlinksync_path"><code>fs.unlinkSync(path)</code></a></li>
-<li><a href="#fs_fs_unwatchfile_filename_listener"><code>fs.unwatchFile(filename[, listener])</code></a></li>
-<li><a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes(path, atime, mtime, callback)</code></a></li>
-<li><a href="#fs_fs_utimessync_path_atime_mtime"><code>fs.utimesSync(path, atime, mtime)</code></a></li>
-<li><a href="#fs_fs_watch_filename_options_listener"><code>fs.watch(filename[, options][, listener])</code></a>
+</ul>
+</li>
+<li><a href="#fs_notes">Notes</a>
 <ul>
-<li><a href="#fs_caveats">Caveats</a>
+<li><a href="#fs_ordering_of_callback_and_promise_based_operations">Ordering of callback and promise-based operations</a></li>
+<li><a href="#fs_file_paths">File paths</a>
 <ul>
-<li><a href="#fs_availability">Availability</a></li>
-<li><a href="#fs_inodes">Inodes</a></li>
-<li><a href="#fs_filename_argument">Filename argument</a></li>
+<li><a href="#fs_string_paths">String paths</a></li>
+<li><a href="#fs_file_url_paths">File URL paths</a>
+<ul>
+<li><a href="#fs_platform_specific_considerations">Platform-specific considerations</a></li>
 </ul>
 </li>
+<li><a href="#fs_buffer_paths">Buffer paths</a></li>
+<li><a href="#fs_per_drive_working_directories_on_windows">Per-drive working directories on Windows</a></li>
 </ul>
 </li>
-<li><a href="#fs_fs_watchfile_filename_options_listener"><code>fs.watchFile(filename[, options], listener)</code></a></li>
-<li><a href="#fs_fs_write_fd_buffer_offset_length_position_callback"><code>fs.write(fd, buffer[, offset[, length[, position]]], callback)</code></a></li>
-<li><a href="#fs_fs_write_fd_string_position_encoding_callback"><code>fs.write(fd, string[, position[, encoding]], callback)</code></a></li>
-<li><a href="#fs_fs_writefile_file_data_options_callback"><code>fs.writeFile(file, data[, options], callback)</code></a>
-<ul>
-<li><a href="#fs_using_fs_writefile_with_file_descriptors">Using <code>fs.writeFile()</code> with file descriptors</a></li>
-</ul>
-</li>
-<li><a href="#fs_fs_writefilesync_file_data_options"><code>fs.writeFileSync(file, data[, options])</code></a></li>
-<li><a href="#fs_fs_writesync_fd_buffer_offset_length_position"><code>fs.writeSync(fd, buffer[, offset[, length[, position]]])</code></a></li>
-<li><a href="#fs_fs_writesync_fd_string_position_encoding"><code>fs.writeSync(fd, string[, position[, encoding]])</code></a></li>
-<li><a href="#fs_fs_writev_fd_buffers_position_callback"><code>fs.writev(fd, buffers[, position], callback)</code></a></li>
-<li><a href="#fs_fs_writevsync_fd_buffers_position"><code>fs.writevSync(fd, buffers[, position])</code></a></li>
-<li><a href="#fs_fs_promises_api"><code>fs</code> Promises API</a>
-<ul>
-<li><a href="#fs_class_filehandle">Class: <code>FileHandle</code></a>
-<ul>
-<li><a href="#fs_filehandle_appendfile_data_options"><code>filehandle.appendFile(data, options)</code></a></li>
-<li><a href="#fs_filehandle_chmod_mode"><code>filehandle.chmod(mode)</code></a></li>
-<li><a href="#fs_filehandle_chown_uid_gid"><code>filehandle.chown(uid, gid)</code></a></li>
-<li><a href="#fs_filehandle_close"><code>filehandle.close()</code></a></li>
-<li><a href="#fs_filehandle_datasync"><code>filehandle.datasync()</code></a></li>
-<li><a href="#fs_filehandle_fd"><code>filehandle.fd</code></a></li>
-<li><a href="#fs_filehandle_read_buffer_offset_length_position"><code>filehandle.read(buffer, offset, length, position)</code></a></li>
-<li><a href="#fs_filehandle_read_options"><code>filehandle.read(options)</code></a></li>
-<li><a href="#fs_filehandle_readfile_options"><code>filehandle.readFile(options)</code></a></li>
-<li><a href="#fs_filehandle_readv_buffers_position"><code>filehandle.readv(buffers[, position])</code></a></li>
-<li><a href="#fs_filehandle_stat_options"><code>filehandle.stat([options])</code></a></li>
-<li><a href="#fs_filehandle_sync"><code>filehandle.sync()</code></a></li>
-<li><a href="#fs_filehandle_truncate_len"><code>filehandle.truncate(len)</code></a></li>
-<li><a href="#fs_filehandle_utimes_atime_mtime"><code>filehandle.utimes(atime, mtime)</code></a></li>
-<li><a href="#fs_filehandle_write_buffer_offset_length_position"><code>filehandle.write(buffer[, offset[, length[, position]]])</code></a></li>
-<li><a href="#fs_filehandle_write_string_position_encoding"><code>filehandle.write(string[, position[, encoding]])</code></a></li>
-<li><a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile(data, options)</code></a></li>
-<li><a href="#fs_filehandle_writev_buffers_position"><code>filehandle.writev(buffers[, position])</code></a></li>
-</ul>
-</li>
-<li><a href="#fs_fspromises_access_path_mode"><code>fsPromises.access(path[, mode])</code></a></li>
-<li><a href="#fs_fspromises_appendfile_path_data_options"><code>fsPromises.appendFile(path, data[, options])</code></a></li>
-<li><a href="#fs_fspromises_chmod_path_mode"><code>fsPromises.chmod(path, mode)</code></a></li>
-<li><a href="#fs_fspromises_chown_path_uid_gid"><code>fsPromises.chown(path, uid, gid)</code></a></li>
-<li><a href="#fs_fspromises_copyfile_src_dest_flags"><code>fsPromises.copyFile(src, dest[, flags])</code></a></li>
-<li><a href="#fs_fspromises_lchmod_path_mode"><code>fsPromises.lchmod(path, mode)</code></a></li>
-<li><a href="#fs_fspromises_lchown_path_uid_gid"><code>fsPromises.lchown(path, uid, gid)</code></a></li>
-<li><a href="#fs_fspromises_lutimes_path_atime_mtime"><code>fsPromises.lutimes(path, atime, mtime)</code></a></li>
-<li><a href="#fs_fspromises_link_existingpath_newpath"><code>fsPromises.link(existingPath, newPath)</code></a></li>
-<li><a href="#fs_fspromises_lstat_path_options"><code>fsPromises.lstat(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_mkdir_path_options"><code>fsPromises.mkdir(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_mkdtemp_prefix_options"><code>fsPromises.mkdtemp(prefix[, options])</code></a></li>
-<li><a href="#fs_fspromises_open_path_flags_mode"><code>fsPromises.open(path, flags[, mode])</code></a></li>
-<li><a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_readdir_path_options"><code>fsPromises.readdir(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_readfile_path_options"><code>fsPromises.readFile(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_readlink_path_options"><code>fsPromises.readlink(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_realpath_path_options"><code>fsPromises.realpath(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_rename_oldpath_newpath"><code>fsPromises.rename(oldPath, newPath)</code></a></li>
-<li><span class="stability_1"><a href="#fs_fspromises_rmdir_path_options"><code>fsPromises.rmdir(path[, options])</code></a></span></li>
-<li><a href="#fs_fspromises_stat_path_options"><code>fsPromises.stat(path[, options])</code></a></li>
-<li><a href="#fs_fspromises_symlink_target_path_type"><code>fsPromises.symlink(target, path[, type])</code></a></li>
-<li><a href="#fs_fspromises_truncate_path_len"><code>fsPromises.truncate(path[, len])</code></a></li>
-<li><a href="#fs_fspromises_unlink_path"><code>fsPromises.unlink(path)</code></a></li>
-<li><a href="#fs_fspromises_utimes_path_atime_mtime"><code>fsPromises.utimes(path, atime, mtime)</code></a></li>
-<li><a href="#fs_fspromises_writefile_file_data_options"><code>fsPromises.writeFile(file, data[, options])</code></a></li>
-</ul>
-</li>
-<li><a href="#fs_fs_constants_1">FS constants</a>
-<ul>
-<li><a href="#fs_file_access_constants">File access constants</a></li>
-<li><a href="#fs_file_copy_constants">File copy constants</a></li>
-<li><a href="#fs_file_open_constants">File open constants</a></li>
-<li><a href="#fs_file_type_constants">File type constants</a></li>
-<li><a href="#fs_file_mode_constants">File mode constants</a></li>
-</ul>
-</li>
+<li><a href="#fs_file_descriptors_1">File descriptors</a></li>
+<li><a href="#fs_threadpool_usage">Threadpool usage</a></li>
 <li><a href="#fs_file_system_flags">File system flags</a></li>
 </ul>
 </li>
 </ul>
-      </div>
+</li>
+</ul></details>
 
       <div id="apicontent">
-        <h1>File system<span><a class="mark" href="#fs_file_system" id="fs_file_system">#</a></span></h1>
+        <h2>File system<span><a class="mark" href="#fs_file_system" id="fs_file_system">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/fs.js">lib/fs.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/fs.js">lib/fs.js</a></p>
 <p>The <code>fs</code> module enables interacting with the file system in a
 way modeled on standard POSIX functions.</p>
-<p>To use this module:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);</code></pre>
+<p>To use the promise-based APIs:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;</code><code class="language-js cjs"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);</code></pre>
+<p>To use the callback and sync APIs:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;</code><code class="language-js cjs"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);</code></pre>
 <p>All file system operations have synchronous, callback, and promise-based
-forms.</p>
-<h2>Synchronous example<span><a class="mark" href="#fs_synchronous_example" id="fs_synchronous_example">#</a></span></h2>
-<p>The synchronous form blocks the Node.js event loop and further JavaScript
-execution until the operation is complete. Exceptions are thrown immediately
-and can be handled using <code>try…catch</code>, or can be allowed to bubble up.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).</p>
+<section><h3>Promise example<span><a class="mark" href="#fs_promise_example" id="fs_promise_example">#</a></span></h3>
+<p>Promise-based operations return a promise that is fulfilled when the
+asynchronous operation is complete.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { unlink } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
 
 <span class="hljs-keyword">try</span> {
-  fs.unlinkSync(<span class="hljs-string">'/tmp/hello'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
-} <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-comment">// handle the error</span>
-}</code></pre>
-<h2>Callback example<span><a class="mark" href="#fs_callback_example" id="fs_callback_example">#</a></span></h2>
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">unlink</span>(<span class="hljs-string">'/tmp/hello'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+} <span class="hljs-keyword">catch</span> (error) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'there was an error:'</span>, error.<span class="hljs-property">message</span>);
+}</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { unlink } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);
+
+(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>(<span class="hljs-params">path</span>) {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">unlink</span>(path);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`successfully deleted <span class="hljs-subst">${path}</span>`</span>);
+  } <span class="hljs-keyword">catch</span> (error) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'there was an error:'</span>, error.<span class="hljs-property">message</span>);
+  }
+})(<span class="hljs-string">'/tmp/hello'</span>);</code></pre>
+</section><section><h3>Callback example<span><a class="mark" href="#fs_callback_example" id="fs_callback_example">#</a></span></h3>
 <p>The callback form takes a completion callback function as its last
 argument and invokes the operation asynchronously. The arguments passed to
 the completion callback depend on the method, but the first argument is always
 reserved for an exception. If the operation is completed successfully, then
 the first argument is <code>null</code> or <code>undefined</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-fs.unlink(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
-});</code></pre>
-<h2>Promise example<span><a class="mark" href="#fs_promise_example" id="fs_promise_example">#</a></span></h2>
-<p>Promise-based operations return a <code>Promise</code> that is resolved when the
-asynchronous operation is complete.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).promises;
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { unlink } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">path</span>) </span>{
-  <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">await</span> fs.unlink(path);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`successfully deleted <span class="hljs-subst">${path}</span>`</span>);
-  } <span class="hljs-keyword">catch</span> (error) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'there was an error:'</span>, error.message);
-  }
-})(<span class="hljs-string">'/tmp/hello'</span>);</code></pre>
-<h2>Ordering of callback and promise-based operations<span><a class="mark" href="#fs_ordering_of_callback_and_promise_based_operations" id="fs_ordering_of_callback_and_promise_based_operations">#</a></span></h2>
-<p>There is no guaranteed ordering when using either the callback or
-promise-based methods. For example, the following is prone to error
-because the <code>fs.stat()</code> operation might complete before the <code>fs.rename()</code>
-operation:</p>
-<pre><code class="language-js">fs.rename(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'renamed complete'</span>);
-});
-fs.stat(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+<span class="hljs-title function_">unlink</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
-});</code></pre>
-<p>To correctly order the operations, move the <code>fs.stat()</code> call into the callback
-of the <code>fs.rename()</code> operation:</p>
-<pre><code class="language-js">fs.rename(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.stat(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
-  });
-});</code></pre>
-<p>Or, use the promise-based API:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).promises;
-
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">from, to</span>) </span>{
-  <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">await</span> fs.rename(<span class="hljs-keyword">from</span>, to);
-    <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> fs.stat(to);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
-  } <span class="hljs-keyword">catch</span> (error) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'there was an error:'</span>, error.message);
-  }
-})(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>);</code></pre>
-<h2>File paths<span><a class="mark" href="#fs_file_paths" id="fs_file_paths">#</a></span></h2>
-<p>Most <code>fs</code> operations accept filepaths that may be specified in the form of
-a string, a <a href="buffer.html#buffer_buffer"><code>Buffer</code></a>, or a <a href="url.html#url_the_whatwg_url_api"><code>URL</code></a> object using the <code>file:</code> protocol.</p>
-<p>String form paths are interpreted as UTF-8 character sequences identifying
-the absolute or relative filename. Relative paths will be resolved relative
-to the current working directory as determined by calling <code>process.cwd()</code>.</p>
-<p>Example using an absolute path on POSIX:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+});</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { unlink } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-fs.open(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  });
-});</code></pre>
-<p>Example using a relative path on POSIX (relative to <code>process.cwd()</code>):</p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'file.txt'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  });
-});</code></pre>
-<p>Paths specified using a <a href="buffer.html#buffer_buffer"><code>Buffer</code></a> are useful primarily on certain POSIX
-operating systems that treat file paths as opaque byte sequences. On such
-systems, it is possible for a single file path to contain sub-sequences that
-use multiple character encodings. As with string paths, <code>Buffer</code> paths may
-be relative or absolute:</p>
-<p>Example using an absolute path on POSIX:</p>
-<pre><code class="language-js">fs.open(Buffer.from(<span class="hljs-string">'/open/some/file.txt'</span>), <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<span class="hljs-title function_">unlink</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  });
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
 });</code></pre>
-<p>On Windows, Node.js follows the concept of per-drive working directory. This
-behavior can be observed when using a drive path without a backslash. For
-example <code>fs.readdirSync('C:\\')</code> can potentially return a different result than
-<code>fs.readdirSync('C:')</code>. For more information, see
-<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths">this MSDN page</a>.</p>
-<h3>URL object support<span><a class="mark" href="#fs_url_object_support" id="fs_url_object_support">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v7.6.0</span>
-</div>
-<p>For most <code>fs</code> module functions, the <code>path</code> or <code>filename</code> argument may be passed
-as a WHATWG <a href="url.html#url_the_whatwg_url_api"><code>URL</code></a> object. Only <a href="url.html#url_the_whatwg_url_api"><code>URL</code></a> objects using the <code>file:</code> protocol
-are supported.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fileUrl = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///tmp/hello'</span>);
-
-fs.readFileSync(fileUrl);</code></pre>
-<p><code>file:</code> URLs are always absolute paths.</p>
-<p>Using WHATWG <a href="url.html#url_the_whatwg_url_api"><code>URL</code></a> objects might introduce platform-specific behaviors.</p>
-<p>On Windows, <code>file:</code> URLs with a host name convert to UNC paths, while <code>file:</code>
-URLs with drive letters convert to local absolute paths. <code>file:</code> URLs without a
-host name nor a drive letter will result in a throw:</p>
-<pre><code class="language-js"><span class="hljs-comment">// On Windows :</span>
-
-<span class="hljs-comment">// - WHATWG file URLs with hostname convert to UNC path</span>
-<span class="hljs-comment">// file://hostname/p/a/t/h/file => \\hostname\p\a\t\h\file</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file://hostname/p/a/t/h/file'</span>));
-
-<span class="hljs-comment">// - WHATWG file URLs with drive letters convert to absolute path</span>
-<span class="hljs-comment">// file:///C:/tmp/hello => C:\tmp\hello</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/tmp/hello'</span>));
-
-<span class="hljs-comment">// - WHATWG file URLs without hostname must have a drive letters</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///notdriveletter/p/a/t/h/file'</span>));
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///c/p/a/t/h/file'</span>));
-<span class="hljs-comment">// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute</span></code></pre>
-<p><code>file:</code> URLs with drive letters must use <code>:</code> as a separator just after
-the drive letter. Using another separator will result in a throw.</p>
-<p>On all other platforms, <code>file:</code> URLs with a host name are unsupported and will
-result in a throw:</p>
-<pre><code class="language-js"><span class="hljs-comment">// On other platforms:</span>
-
-<span class="hljs-comment">// - WHATWG file URLs with hostname are unsupported</span>
-<span class="hljs-comment">// file://hostname/p/a/t/h/file => throw!</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file://hostname/p/a/t/h/file'</span>));
-<span class="hljs-comment">// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute</span>
+<p>The callback-based versions of the <code>fs</code> module APIs are preferable over
+the use of the promise APIs when maximal performance (both in terms of
+execution time and memory allocation are required).</p>
+</section><section><h3>Synchronous example<span><a class="mark" href="#fs_synchronous_example" id="fs_synchronous_example">#</a></span></h3>
+<p>The synchronous APIs block the Node.js event loop and further JavaScript
+execution until the operation is complete. Exceptions are thrown immediately
+and can be handled using <code>try…catch</code>, or can be allowed to bubble up.</p>
 
-<span class="hljs-comment">// - WHATWG file URLs convert to absolute path</span>
-<span class="hljs-comment">// file:///tmp/hello => /tmp/hello</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///tmp/hello'</span>));</code></pre>
-<p>A <code>file:</code> URL having encoded slash characters will result in a throw on all
-platforms:</p>
-<pre><code class="language-js"><span class="hljs-comment">// On Windows</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/p/a/t/h/%2F'</span>));
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/p/a/t/h/%2f'</span>));
-<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-\ or / characters */</span>
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { unlinkSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">// On POSIX</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///p/a/t/h/%2F'</span>));
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///p/a/t/h/%2f'</span>));
-<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-/ characters */</span></code></pre>
-<p>On Windows, <code>file:</code> URLs having encoded backslash will result in a throw:</p>
-<pre><code class="language-js"><span class="hljs-comment">// On Windows</span>
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/path/%5C'</span>));
-fs.readFileSync(<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/path/%5c'</span>));
-<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-\ or / characters */</span></code></pre>
-<h2>File descriptors<span><a class="mark" href="#fs_file_descriptors" id="fs_file_descriptors">#</a></span></h2>
-<p>On POSIX systems, for every process, the kernel maintains a table of currently
-open files and resources. Each open file is assigned a simple numeric
-identifier called a <em>file descriptor</em>. At the system-level, all file system
-operations use these file descriptors to identify and track each specific
-file. Windows systems use a different but conceptually similar mechanism for
-tracking resources. To simplify things for users, Node.js abstracts away the
-specific differences between operating systems and assigns all open files a
-numeric file descriptor.</p>
-<p>The <code>fs.open()</code> method is used to allocate a new file descriptor. Once
-allocated, the file descriptor may be used to read data from, write data to,
-or request information about the file.</p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.fstat(fd, <span class="hljs-function">(<span class="hljs-params">err, stat</span>) =></span> {
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    <span class="hljs-comment">// use stat</span>
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">unlinkSync</span>(<span class="hljs-string">'/tmp/hello'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">// handle the error</span>
+}</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { unlinkSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-    <span class="hljs-comment">// always close the file descriptor!</span>
-    fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    });
-  });
-});</code></pre>
-<p>Most operating systems limit the number of file descriptors that may be open
-at any given time so it is critical to close the descriptor when operations
-are completed. Failure to do so will result in a memory leak that will
-eventually cause an application to crash.</p>
-<h2>Threadpool usage<span><a class="mark" href="#fs_threadpool_usage" id="fs_threadpool_usage">#</a></span></h2>
-<p>All file system APIs except <code>fs.FSWatcher()</code> and those that are explicitly
-synchronous use libuv's threadpool, which can have surprising and negative
-performance implications for some applications. See the
-<a href="cli.html#cli_uv_threadpool_size_size"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>
-<h2>Class: <code>fs.Dir</code><span><a class="mark" href="#fs_class_fs_dir" id="fs_class_fs_dir">#</a></span></h2>
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">unlinkSync</span>(<span class="hljs-string">'/tmp/hello'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'successfully deleted /tmp/hello'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">// handle the error</span>
+}</code></pre>
+</section><section><h3>Promises API<span><a class="mark" href="#fs_promises_api" id="fs_promises_api">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Exposed as <code>require('fs/promises')</code>.</p></td></tr>
+<tr><td>v11.14.0, v10.17.0</td>
+<td><p>This API is no longer experimental.</p></td></tr>
+<tr><td>v10.1.0</td>
+<td><p>The API is accessible via <code>require('fs').promises</code> only.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p>A class representing a directory stream.</p>
-<p>Created by <a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir()</code></a>, <a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync()</code></a>, or
-<a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">print</span>(<span class="hljs-params">path</span>) </span>{
-  <span class="hljs-keyword">const</span> dir = <span class="hljs-keyword">await</span> fs.promises.opendir(path);
-  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> dirent <span class="hljs-keyword">of</span> dir) {
-    <span class="hljs-built_in">console</span>.log(dirent.name);
-  }
-}
-print(<span class="hljs-string">'./'</span>).catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<h3><code>dir.close()</code><span><a class="mark" href="#fs_dir_close" id="fs_dir_close">#</a></span></h3>
+<p>The <code>fs/promises</code> API provides asynchronous file system methods that return
+promises.</p>
+<p>The promise APIs use the underlying Node.js threadpool to perform file
+system operations off the event loop thread. These operations are not
+synchronized or threadsafe. Care must be taken when performing multiple
+concurrent modifications on the same file or data corruption may occur.</p>
+<h4>Class: <code>FileHandle</code><span><a class="mark" href="#fs_class_filehandle" id="fs_class_filehandle">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v10.0.0</span>
 </div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
-</ul>
-<p>Asynchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.</p>
-<p>A <code>Promise</code> is returned that will be resolved after the resource has been
-closed.</p>
-<h3><code>dir.close(callback)</code><span><a class="mark" href="#fs_dir_close_callback" id="fs_dir_close_callback">#</a></span></h3>
+<p>A <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object is an object wrapper for a numeric file descriptor.</p>
+<p>Instances of the <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object are created by the <code>fsPromises.open()</code>
+method.</p>
+<p>All <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> objects are <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a>s.</p>
+<p>If a <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> is not closed using the <code>filehandle.close()</code> method, it will
+try to automatically close the file descriptor and emit a process warning,
+helping to prevent memory leaks. Please do not rely on this behavior because
+it can be unreliable and the file may not be closed. Instead, always explicitly
+close <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a>s. Node.js may change this behavior in the future.</p>
+<h5><code>filehandle.appendFile(data[, options])</code><span><a class="mark" href="#fs_filehandle_appendfile_data_options" id="fs_filehandle_appendfile_data_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
 </li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Asynchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.</p>
-<p>The <code>callback</code> will be called after the resource handle has been closed.</p>
-<h3><code>dir.closeSync()</code><span><a class="mark" href="#fs_dir_closesync" id="fs_dir_closesync">#</a></span></h3>
+<p>Alias of <a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile()</code></a>.</p>
+<p>When operating on file handles, the mode cannot be changed from what it was set
+to with <a href="#fs_fspromises_open_path_flags_mode"><code>fsPromises.open()</code></a>. Therefore, this is equivalent to
+<a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile()</code></a>.</p>
+<h5><code>filehandle.chmod(mode)</code><span><a class="mark" href="#fs_filehandle_chmod_mode" id="fs_filehandle_chmod_mode">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v10.0.0</span>
 </div>
-<p>Synchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.</p>
-<h3><code>dir.path</code><span><a class="mark" href="#fs_dir_path" id="fs_dir_path">#</a></span></h3>
+<ul>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the file mode bit mask.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Modifies the permissions on the file. See <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>.</p>
+<h5><code>filehandle.chown(uid, gid)</code><span><a class="mark" href="#fs_filehandle_chown_uid_gid" id="fs_filehandle_chown_uid_gid">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new owner's user id.</li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new group's group id.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>The read-only path of this directory as was provided to <a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir()</code></a>,
-<a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync()</code></a>, or <a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir()</code></a>.</p>
-<h3><code>dir.read()</code><span><a class="mark" href="#fs_dir_read" id="fs_dir_read">#</a></span></h3>
+<p>Changes the ownership of the file. A wrapper for <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>.</p>
+<h5><code>filehandle.close()</code><span><a class="mark" href="#fs_filehandle_close" id="fs_filehandle_close">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> containing <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Asynchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>.</p>
-<p>After the read is completed, a <code>Promise</code> is returned that will be resolved with
-an <a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>, or <code>null</code> if there are no more directory entries to read.</p>
-<p>Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.</p>
-<h3><code>dir.read(callback)</code><span><a class="mark" href="#fs_dir_read_callback" id="fs_dir_read_callback">#</a></span></h3>
+<p>Closes the file handle after waiting for any pending operation on the handle to
+complete.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> filehandle;
+<span class="hljs-keyword">try</span> {
+  filehandle = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'thefile.txt'</span>, <span class="hljs-string">'r'</span>);
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> filehandle?.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<h5><code>filehandle.datasync()</code><span><a class="mark" href="#fs_filehandle_datasync" id="fs_filehandle_datasync">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>dirent</code> <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-</li>
+<p>Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+<a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a> documentation for details.</p>
+<p>Unlike <code>filehandle.sync</code> this method does not flush modified metadata.</p>
+<h5><code>filehandle.fd</code><span><a class="mark" href="#fs_filehandle_fd" id="fs_filehandle_fd">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The numeric file descriptor managed by the <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object.</li>
 </ul>
-<p>Asynchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>.</p>
-<p>After the read is completed, the <code>callback</code> will be called with an
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>, or <code>null</code> if there are no more directory entries to read.</p>
-<p>Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.</p>
-<h3><code>dir.readSync()</code><span><a class="mark" href="#fs_dir_readsync" id="fs_dir_readsync">#</a></span></h3>
+<h5><code>filehandle.read(buffer, offset, length, position)</code><span><a class="mark" href="#fs_filehandle_read_buffer_offset_length_position" id="fs_filehandle_read_buffer_offset_length_position">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.12.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
-</ul>
-<p>Synchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>.</p>
-<p>If there are no more directory entries to read, <code>null</code> will be returned.</p>
-<p>Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.</p>
-<h3><code>dir[Symbol.asyncIterator]()</code><span><a class="mark" href="#fs_dir_symbol_asynciterator" id="fs_dir_symbol_asynciterator">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.12.0</span>
-</div>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A buffer that will be filled with the
+file data read.</li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The location in the buffer at which to start filling.
+<strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes to read. <strong>Default:</strong>
+<code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The location where to begin reading data from the
+file. If <code>null</code>, data will be read from the current file position, and
+the position will be updated. If <code>position</code> is an integer, the current
+file position will remain unchanged.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills upon success with an object with two properties:
 <ul>
-<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterator-interface" class="type">&#x3C;AsyncIterator></a> of <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a></li>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes read</li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A reference to the passed in <code>buffer</code>
+argument.</li>
 </ul>
-<p>Asynchronously iterates over the directory via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> until all entries have
-been read.</p>
-<p>Entries returned by the async iterator are always an <a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a>.
-The <code>null</code> case from <code>dir.read()</code> is handled internally.</p>
-<p>See <a href="#fs_class_fs_dir"><code>fs.Dir</code></a> for an example.</p>
-<p>Directory entries returned by this iterator are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.</p>
-<h2>Class: <code>fs.Dirent</code><span><a class="mark" href="#fs_class_fs_dirent" id="fs_class_fs_dirent">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v10.10.0</span>
-</div>
-<p>A representation of a directory entry, which can be a file or a subdirectory
-within the directory, as returned by reading from an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a>. The
-directory entry is a combination of the file name and file type pairs.</p>
-<p>Additionally, when <a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir()</code></a> or <a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync()</code></a> is called with
-the <code>withFileTypes</code> option set to <code>true</code>, the resulting array is filled with
-<code>fs.Dirent</code> objects, rather than strings or <code>Buffers</code>.</p>
-<h3><code>dirent.isBlockDevice()</code><span><a class="mark" href="#fs_dirent_isblockdevice" id="fs_dirent_isblockdevice">#</a></span></h3>
+</li>
+</ul>
+<p>Reads data from the file and stores that in the given buffer.</p>
+<p>If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.</p>
+<h5><code>filehandle.read([options])</code><span><a class="mark" href="#fs_filehandle_read_options" id="fs_filehandle_read_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v13.11.0, v12.17.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A buffer that will be filled with the
+file data read. <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The location in the buffer at which to start filling.
+<strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes to read. <strong>Default:</strong>
+<code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The location where to begin reading data from the
+file. If <code>null</code>, data will be read from the current file position, and
+the position will be updated. If <code>position</code> is an integer, the current
+file position will remain unchanged. <strong>Default:</strong>: <code>null</code></li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a block device.</p>
-<h3><code>dirent.isCharacterDevice()</code><span><a class="mark" href="#fs_dirent_ischaracterdevice" id="fs_dirent_ischaracterdevice">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.10.0</span>
-</div>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills upon success with an object with two properties:
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes read</li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A reference to the passed in <code>buffer</code>
+argument.</li>
+</ul>
+</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a character device.</p>
-<h3><code>dirent.isDirectory()</code><span><a class="mark" href="#fs_dirent_isdirectory" id="fs_dirent_isdirectory">#</a></span></h3>
+<p>Reads data from the file and stores that in the given buffer.</p>
+<p>If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.</p>
+<h5><code>filehandle.readFile(options)</code><span><a class="mark" href="#fs_filehandle_readfile_options" id="fs_filehandle_readfile_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress readFile</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a file system
-directory.</p>
-<h3><code>dirent.isFIFO()</code><span><a class="mark" href="#fs_dirent_isfifo" id="fs_dirent_isfifo">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills upon a successful read with the contents of the
+file. If no encoding is specified (using <code>options.encoding</code>), the data is
+returned as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object. Otherwise, the data will be a string.</li>
+</ul>
+<p>Asynchronously reads the entire contents of a file.</p>
+<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>
+<p>The <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> has to support reading.</p>
+<p>If one or more <code>filehandle.read()</code> calls are made on a file handle and then a
+<code>filehandle.readFile()</code> call is made, the data will be read from the current
+position till the end of the file. It doesn't always read from the beginning
+of the file.</p>
+<h5><code>filehandle.readv(buffers[, position])</code><span><a class="mark" href="#fs_filehandle_readv_buffers_position" id="fs_filehandle_readv_buffers_position">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v13.13.0, v12.17.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>buffers</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The offset from the beginning of the file where the data
+should be read from. If <code>position</code> is not a <code>number</code>, the data will be read
+from the current position.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills upon success an object containing two properties:
+<ul>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the number of bytes read</li>
+<li><code>buffers</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a> property containing
+a reference to the <code>buffers</code> input.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a first-in-first-out
-(FIFO) pipe.</p>
-<h3><code>dirent.isFile()</code><span><a class="mark" href="#fs_dirent_isfile" id="fs_dirent_isfile">#</a></span></h3>
+</li>
+</ul>
+<p>Read from a file and write to an array of <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView></a>s</p>
+<h5><code>filehandle.stat([options])</code><span><a class="mark" href="#fs_filehandle_stat_options" id="fs_filehandle_stat_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with an <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the file.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a regular file.</p>
-<h3><code>dirent.isSocket()</code><span><a class="mark" href="#fs_dirent_issocket" id="fs_dirent_issocket">#</a></span></h3>
+<h5><code>filehandle.sync()</code><span><a class="mark" href="#fs_filehandle_sync" id="fs_filehandle_sync">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fufills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a socket.</p>
-<h3><code>dirent.isSymbolicLink()</code><span><a class="mark" href="#fs_dirent_issymboliclink" id="fs_dirent_issymboliclink">#</a></span></h3>
+<p>Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a> documentation for more detail.</p>
+<h5><code>filehandle.truncate(len)</code><span><a class="mark" href="#fs_filehandle_truncate_len" id="fs_filehandle_truncate_len">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a symbolic link.</p>
-<h3><code>dirent.name</code><span><a class="mark" href="#fs_dirent_name" id="fs_dirent_name">#</a></span></h3>
+<p>Truncates the file.</p>
+<p>If the file was larger than <code>len</code> bytes, only the first <code>len</code> bytes will be
+retained in the file.</p>
+<p>The following example retains only the first four bytes of the file:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> filehandle = <span class="hljs-literal">null</span>;
+<span class="hljs-keyword">try</span> {
+  filehandle = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
+  <span class="hljs-keyword">await</span> filehandle.<span class="hljs-title function_">truncate</span>(<span class="hljs-number">4</span>);
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> filehandle?.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the
+extended part is filled with null bytes (<code>'\0'</code>):</p>
+<p>If <code>len</code> is negative then <code>0</code> will be used.</p>
+<h5><code>filehandle.utimes(atime, mtime)</code><span><a class="mark" href="#fs_filehandle_utimes_atime_mtime" id="fs_filehandle_utimes_atime_mtime">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>The file name that this <code>fs.Dirent</code> object refers to. The type of this
-value is determined by the <code>options.encoding</code> passed to <a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir()</code></a> or
-<a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync()</code></a>.</p>
-<h2>Class: <code>fs.FSWatcher</code><span><a class="mark" href="#fs_class_fs_fswatcher" id="fs_class_fs_fswatcher">#</a></span></h2>
+<p>Change the file system timestamps of the object referenced by the <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a>
+then resolves the promise with no arguments upon success.</p>
+<p>This function does not work on AIX versions before 7.1, it will reject the
+promise with an error using code <code>UV_ENOSYS</code>.</p>
+<h5><code>filehandle.write(buffer[, offset[, length[, position]]])</code><span><a class="mark" href="#fs_filehandle_write_buffer_offset_length_position" id="fs_filehandle_write_buffer_offset_length_position">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.5.8</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>buffer</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>buffer</code> parameter won't coerce unsupported input to buffers anymore.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li>Extends <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The start position from within <code>buffer</code> where the data
+to write begins. <strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes from <code>buffer</code> to write. <strong>Default:</strong>
+<code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The offset from the beginning of the file where the
+data from <code>buffer</code> should be written. If <code>position</code> is not a <code>number</code>,
+the data will be written at the current position. See the POSIX <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>
+documentation for more detail.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>A successful call to <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> method will return a new <code>fs.FSWatcher</code>
-object.</p>
-<p>All <code>fs.FSWatcher</code> objects emit a <code>'change'</code> event whenever a specific watched
-file is modified.</p>
-<h3>Event: <code>'change'</code><span><a class="mark" href="#fs_event_change" id="fs_event_change">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.5.8</span>
-</div>
+<p>Write <code>buffer</code> to the file.</p>
+<p>If <code>buffer</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
+<p>The promise is resolved with an object containing two properties:</p>
 <ul>
-<li><code>eventType</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The type of change event that has occurred</li>
-<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The filename that changed (if relevant/available)</li>
+<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the number of bytes written</li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> a reference to the
+<code>buffer</code> written.</li>
 </ul>
-<p>Emitted when something changes in a watched directory or file.
-See more details in <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a>.</p>
-<p>The <code>filename</code> argument may not be provided depending on operating system
-support. If <code>filename</code> is provided, it will be provided as a <code>Buffer</code> if
-<code>fs.watch()</code> is called with its <code>encoding</code> option set to <code>'buffer'</code>, otherwise
-<code>filename</code> will be a UTF-8 string.</p>
-<pre><code class="language-js"><span class="hljs-comment">// Example when handled through fs.watch() listener</span>
-fs.watch(<span class="hljs-string">'./tmp'</span>, { <span class="hljs-attr">encoding</span>: <span class="hljs-string">'buffer'</span> }, <span class="hljs-function">(<span class="hljs-params">eventType, filename</span>) =></span> {
-  <span class="hljs-keyword">if</span> (filename) {
-    <span class="hljs-built_in">console</span>.log(filename);
-    <span class="hljs-comment">// Prints: &#x3C;Buffer ...></span>
-  }
-});</code></pre>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close" id="fs_event_close">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
-<p>Emitted when the watcher stops watching for changes. The closed
-<code>fs.FSWatcher</code> object is no longer usable in the event handler.</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#fs_event_error" id="fs_event_error">#</a></span></h3>
+<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file
+without waiting for the promise to be resolved (or rejected). For this
+scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>On Linux, positional writes do not work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+<h5><code>filehandle.write(string[, position[, encoding]])</code><span><a class="mark" href="#fs_filehandle_write_string_position_encoding" id="fs_filehandle_write_string_position_encoding">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v0.5.8</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>string</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>string</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The offset from the beginning of the file where the
+data from <code>string</code> should be written. If <code>position</code> is not a <code>number</code> the
+data will be written at the current position. See the POSIX <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>
+documentation for more detail.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The expected string encoding. <strong>Default:</strong> <code>'utf8'</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Emitted when an error occurs while watching the file. The errored
-<code>fs.FSWatcher</code> object is no longer usable in the event handler.</p>
-<h3><code>watcher.close()</code><span><a class="mark" href="#fs_watcher_close" id="fs_watcher_close">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.5.8</span>
-</div>
-<p>Stop watching for changes on the given <code>fs.FSWatcher</code>. Once stopped, the
-<code>fs.FSWatcher</code> object is no longer usable.</p>
-<h3><code>watcher.ref()</code><span><a class="mark" href="#fs_watcher_ref" id="fs_watcher_ref">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.20.0</span>
-</div>
+<p>Write <code>string</code> to the file. If <code>string</code> is not a string, or an object with an
+own <code>toString</code> function property, the promise is rejected with an error.</p>
+<p>The promise is resolved with an object containing two properties:</p>
 <ul>
-<li>Returns: <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
+<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the number of bytes written</li>
+<li><code>buffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> a reference to the <code>string</code> written.</li>
 </ul>
-<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the
-<code>FSWatcher</code> is active. Calling <code>watcher.ref()</code> multiple times will have
-no effect.</p>
-<p>By default, all <code>FSWatcher</code> objects are "ref'ed", making it normally
-unnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been
-called previously.</p>
-<h3><code>watcher.unref()</code><span><a class="mark" href="#fs_watcher_unref" id="fs_watcher_unref">#</a></span></h3>
+<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file
+without waiting for the promise to be resolved (or rejected). For this
+scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>On Linux, positional writes do not work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+<h5><code>filehandle.writeFile(data, options)</code><span><a class="mark" href="#fs_filehandle_writefile_data_options" id="fs_filehandle_writefile_data_options">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>data</code> argument supports <code>AsyncIterable</code>, <code>Iterable</code> and <code>Stream</code>.</p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>data</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>data</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li>Returns: <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> | <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> The expected character encoding when <code>data</code> is a
+string. <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>When called, the active <code>FSWatcher</code> object will not require the Node.js
-event loop to remain active. If there is no other activity keeping the
-event loop running, the process may exit before the <code>FSWatcher</code> object's
-callback is invoked. Calling <code>watcher.unref()</code> multiple times will have
-no effect.</p>
-<h2>Class: <code>fs.StatWatcher</code><span><a class="mark" href="#fs_class_fs_statwatcher" id="fs_class_fs_statwatcher">#</a></span></h2>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+<p>Asynchronously writes data to a file, replacing the file if it already exists.
+<code>data</code> can be a string, a buffer, an <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> object, or an
+object with an own <code>toString</code> function
+property. The promise is resolved with no arguments upon success.</p>
+<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>
+<p>The <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> has to support writing.</p>
+<p>It is unsafe to use <code>filehandle.writeFile()</code> multiple times on the same file
+without waiting for the promise to be resolved (or rejected).</p>
+<p>If one or more <code>filehandle.write()</code> calls are made on a file handle and then a
+<code>filehandle.writeFile()</code> call is made, the data will be written from the
+current position till the end of the file. It doesn't always write from the
+beginning of the file.</p>
+<h5><code>filehandle.writev(buffers[, position])</code><span><a class="mark" href="#fs_filehandle_writev_buffers_position" id="fs_filehandle_writev_buffers_position">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v12.9.0</span>
 </div>
 <ul>
-<li>Extends <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+<li><code>buffers</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The offset from the beginning of the file where the
+data from <code>buffers</code> should be written. If <code>position</code> is not a <code>number</code>,
+the data will be written at the current position.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>A successful call to <code>fs.watchFile()</code> method will return a new <code>fs.StatWatcher</code>
-object.</p>
-<h3><code>watcher.ref()</code><span><a class="mark" href="#fs_watcher_ref_1" id="fs_watcher_ref_1">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.20.0</span>
-</div>
+<p>Write an array of <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView></a>s to the file.</p>
+<p>The promise is resolved with an object containing a two properties:</p>
 <ul>
-<li>Returns: <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
+<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> the number of bytes written</li>
+<li><code>buffers</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a> a reference to the <code>buffers</code>
+input.</li>
 </ul>
-<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the
-<code>StatWatcher</code> is active. Calling <code>watcher.ref()</code> multiple times will have
-no effect.</p>
-<p>By default, all <code>StatWatcher</code> objects are "ref'ed", making it normally
-unnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been
-called previously.</p>
-<h3><code>watcher.unref()</code><span><a class="mark" href="#fs_watcher_unref_1" id="fs_watcher_unref_1">#</a></span></h3>
+<p>It is unsafe to call <code>writev()</code> multiple times on the same file without waiting
+for the promise to be resolved (or rejected).</p>
+<p>On Linux, positional writes don't work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+<h4><code>fsPromises.access(path[, mode])</code><span><a class="mark" href="#fs_fspromises_access_path_mode" id="fs_fspromises_access_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>fs.constants.F_OK</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>When called, the active <code>StatWatcher</code> object will not require the Node.js
-event loop to remain active. If there is no other activity keeping the
-event loop running, the process may exit before the <code>StatWatcher</code> object's
-callback is invoked. Calling <code>watcher.unref()</code> multiple times will have
-no effect.</p>
-<h2>Class: <code>fs.ReadStream</code><span><a class="mark" href="#fs_class_fs_readstream" id="fs_class_fs_readstream">#</a></span></h2>
+<p>Tests a user's permissions for the file or directory specified by <code>path</code>.
+The <code>mode</code> argument is an optional integer that specifies the accessibility
+checks to be performed. Check <a href="#fs_file_access_constants">File access constants</a> for possible values
+of <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of
+two or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>
+<p>If the accessibility check is successful, the promise is resolved with no
+value. If any of the accessibility checks fail, the promise is rejected
+with an <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> object. The following example checks if the file
+<code>/etc/passwd</code> can be read and written by the current process.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { access } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+<span class="hljs-keyword">import</span> { constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">access</span>(<span class="hljs-string">'/etc/passwd'</span>, constants.<span class="hljs-property">R_OK</span> | constants.<span class="hljs-property">W_OK</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'can access'</span>);
+} <span class="hljs-keyword">catch</span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'cannot access'</span>);
+}</code></pre>
+<p>Using <code>fsPromises.access()</code> to check for the accessibility of a file before
+calling <code>fsPromises.open()</code> is not recommended. Doing so introduces a race
+condition, since other processes may change the file's state between the two
+calls. Instead, user code should open/read/write the file directly and handle
+the error raised if the file is not accessible.</p>
+<h4><code>fsPromises.appendFile(path, data[, options])</code><span><a class="mark" href="#fs_fspromises_appendfile_path_data_options" id="fs_fspromises_appendfile_path_data_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Extends: <a href="stream.html#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'a'</code>.</li>
 </ul>
-<p>Instances of <code>fs.ReadStream</code> are created and returned using the
-<a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream()</code></a> function.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close_1" id="fs_event_close_1">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.93</span>
-</div>
-<p>Emitted when the <code>fs.ReadStream</code>'s underlying file descriptor has been closed.</p>
-<h3>Event: <code>'open'</code><span><a class="mark" href="#fs_event_open" id="fs_event_open">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Asynchronously append data to a file, creating the file if it does not yet
+exist. <code>data</code> can be a string or a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<p>The <code>path</code> may be specified as a <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> that has been opened
+for appending (using <code>fsPromises.open()</code>).</p>
+<h4><code>fsPromises.chmod(path, mode)</code><span><a class="mark" href="#fs_fspromises_chmod_path_mode" id="fs_fspromises_chmod_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Integer file descriptor used by the <code>ReadStream</code>.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Emitted when the <code>fs.ReadStream</code>'s file descriptor has been opened.</p>
-<h3>Event: <code>'ready'</code><span><a class="mark" href="#fs_event_ready" id="fs_event_ready">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v9.11.0</span>
-</div>
-<p>Emitted when the <code>fs.ReadStream</code> is ready to be used.</p>
-<p>Fires immediately after <code>'open'</code>.</p>
-<h3><code>readStream.bytesRead</code><span><a class="mark" href="#fs_readstream_bytesread" id="fs_readstream_bytesread">#</a></span></h3>
+<p>Changes the permissions of a file.</p>
+<h4><code>fsPromises.chown(path, uid, gid)</code><span><a class="mark" href="#fs_fspromises_chown_path_uid_gid" id="fs_fspromises_chown_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v6.4.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>The number of bytes that have been read so far.</p>
-<h3><code>readStream.path</code><span><a class="mark" href="#fs_readstream_path" id="fs_readstream_path">#</a></span></h3>
+<p>Changes the ownership of a file.</p>
+<h4><code>fsPromises.copyFile(src, dest[, mode])</code><span><a class="mark" href="#fs_fspromises_copyfile_src_dest_mode" id="fs_fspromises_copyfile_src_dest_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
+<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Optional modifiers that specify the behavior of the copy
+operation. It is possible to create a mask consisting of the bitwise OR of
+two or more values (e.g.
+<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>)
+<strong>Default:</strong> <code>0</code>.
+<ul>
+<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code>
+already exists.</li>
+<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create
+a copy-on-write reflink. If the platform does not support copy-on-write,
+then a fallback copy mechanism is used.</li>
+<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
+create a copy-on-write reflink. If the platform does not support
+copy-on-write, then the operation will fail.</li>
 </ul>
-<p>The path to the file the stream is reading from as specified in the first
-argument to <code>fs.createReadStream()</code>. If <code>path</code> is passed as a string, then
-<code>readStream.path</code> will be a string. If <code>path</code> is passed as a <code>Buffer</code>, then
-<code>readStream.path</code> will be a <code>Buffer</code>.</p>
-<h3><code>readStream.pending</code><span><a class="mark" href="#fs_readstream_pending" id="fs_readstream_pending">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
+already exists.</p>
+<p>No guarantees are made about the atomicity of the copy operation. If an
+error occurs after the destination file has been opened for writing, an attempt
+will be made to remove the destination.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-keyword">import</span> { copyFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">copyFile</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
+} <span class="hljs-keyword">catch</span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The file could not be copied'</span>);
+}
+
+<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">copyFile</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, constants.<span class="hljs-property">COPYFILE_EXCL</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
+} <span class="hljs-keyword">catch</span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The file could not be copied'</span>);
+}</code></pre>
+<h4><code>fsPromises.lchmod(path, mode)</code><span><a class="mark" href="#fs_fspromises_lchmod_path_mode" id="fs_fspromises_lchmod_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.2.0</span>
+<span>Deprecated since: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>This property is <code>true</code> if the underlying file has not been opened yet,
-i.e. before the <code>'ready'</code> event is emitted.</p>
-<h2>Class: <code>fs.Stats</code><span><a class="mark" href="#fs_class_fs_stats" id="fs_class_fs_stats">#</a></span></h2>
+<p>Changes the permissions on a symbolic link.</p>
+<p>This method is only implemented on macOS.</p>
+<h4><code>fsPromises.lchown(path, uid, gid)</code><span><a class="mark" href="#fs_fspromises_lchown_path_uid_gid" id="fs_fspromises_lchown_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v8.1.0</td>
-<td><p>Added times as numbers.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
+<tr><td>v10.6.0</td>
+<td><p>This API is no longer deprecated.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p>A <code>fs.Stats</code> object provides information about a file.</p>
-<p>Objects returned from <a href="#fs_fs_stat_path_options_callback"><code>fs.stat()</code></a>, <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a> and <a href="#fs_fs_fstat_fd_options_callback"><code>fs.fstat()</code></a> and
-their synchronous counterparts are of this type.
-If <code>bigint</code> in the <code>options</code> passed to those methods is true, the numeric values
-will be <code>bigint</code> instead of <code>number</code>, and the object will contain additional
-nanosecond-precision properties suffixed with <code>Ns</code>.</p>
-<pre><code class="language-console">Stats {
-  dev: 2114,
-  ino: 48064969,
-  mode: 33188,
-  nlink: 1,
-  uid: 85,
-  gid: 100,
-  rdev: 0,
-  size: 527,
-  blksize: 4096,
-  blocks: 8,
-  atimeMs: 1318289051000.1,
-  mtimeMs: 1318289051000.1,
-  ctimeMs: 1318289051000.1,
-  birthtimeMs: 1318289051000.1,
-  atime: Mon, 10 Oct 2011 23:24:11 GMT,
-  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
-  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
-  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }</code></pre>
-<p><code>bigint</code> version:</p>
-<pre><code class="language-console">BigIntStats {
-  dev: 2114n,
-  ino: 48064969n,
-  mode: 33188n,
-  nlink: 1n,
-  uid: 85n,
-  gid: 100n,
-  rdev: 0n,
-  size: 527n,
-  blksize: 4096n,
-  blocks: 8n,
-  atimeMs: 1318289051000n,
-  mtimeMs: 1318289051000n,
-  ctimeMs: 1318289051000n,
-  birthtimeMs: 1318289051000n,
-  atimeNs: 1318289051000000000n,
-  mtimeNs: 1318289051000000000n,
-  ctimeNs: 1318289051000000000n,
-  birthtimeNs: 1318289051000000000n,
-  atime: Mon, 10 Oct 2011 23:24:11 GMT,
-  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
-  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
-  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }</code></pre>
-<h3><code>stats.isBlockDevice()</code><span><a class="mark" href="#fs_stats_isblockdevice" id="fs_stats_isblockdevice">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.10</span>
-</div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a block device.</p>
-<h3><code>stats.isCharacterDevice()</code><span><a class="mark" href="#fs_stats_ischaracterdevice" id="fs_stats_ischaracterdevice">#</a></span></h3>
+<p>Changes the ownership on a symbolic link.</p>
+<h4><code>fsPromises.lutimes(path, atime, mtime)</code><span><a class="mark" href="#fs_fspromises_lutimes_path_atime_mtime" id="fs_fspromises_lutimes_path_atime_mtime">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v14.5.0, v12.19.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a character device.</p>
-<h3><code>stats.isDirectory()</code><span><a class="mark" href="#fs_stats_isdirectory" id="fs_stats_isdirectory">#</a></span></h3>
+<p>Changes the access and modification times of a file in the same way as
+<a href="#fs_fspromises_utimes_path_atime_mtime"><code>fsPromises.utimes()</code></a>, with the difference that if the path refers to a
+symbolic link, then the link is not dereferenced: instead, the timestamps of
+the symbolic link itself are changed.</p>
+<h4><code>fsPromises.link(existingPath, newPath)</code><span><a class="mark" href="#fs_fspromises_link_existingpath_newpath" id="fs_fspromises_link_existingpath_newpath">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a file system directory.</p>
-<h3><code>stats.isFIFO()</code><span><a class="mark" href="#fs_stats_isfifo" id="fs_stats_isfifo">#</a></span></h3>
+<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX
+<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a> documentation for more detail.</p>
+<h4><code>fsPromises.lstat(path[, options])</code><span><a class="mark" href="#fs_fspromises_lstat_path_options" id="fs_fspromises_lstat_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a first-in-first-out (FIFO)
-pipe.</p>
-<h3><code>stats.isFile()</code><span><a class="mark" href="#fs_stats_isfile" id="fs_stats_isfile">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.10</span>
-</div>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a regular file.</p>
-<h3><code>stats.isSocket()</code><span><a class="mark" href="#fs_stats_issocket" id="fs_stats_issocket">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.1.10</span>
-</div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object for the given
+symbolic link <code>path</code>.</li>
 </ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a socket.</p>
-<h3><code>stats.isSymbolicLink()</code><span><a class="mark" href="#fs_stats_issymboliclink" id="fs_stats_issymboliclink">#</a></span></h3>
+<p>Equivalent to <a href="#fs_fspromises_stat_path_options"><code>fsPromises.stat()</code></a> unless <code>path</code> refers to a symbolic link,
+in which case the link itself is stat-ed, not the file that it refers to.
+Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a> document for more detail.</p>
+<h4><code>fsPromises.mkdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_mkdir_path_options" id="fs_fspromises_mkdir_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.10</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a symbolic link.</p>
-<p>This method is only valid when using <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a>.</p>
-<h3><code>stats.dev</code><span><a class="mark" href="#fs_stats_dev" id="fs_stats_dev">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The numeric identifier of the device containing the file.</p>
-<h3><code>stats.ino</code><span><a class="mark" href="#fs_stats_ino" id="fs_stats_ino">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The file system specific "Inode" number for the file.</p>
-<h3><code>stats.mode</code><span><a class="mark" href="#fs_stats_mode" id="fs_stats_mode">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>A bit-field describing the file type and mode.</p>
-<h3><code>stats.nlink</code><span><a class="mark" href="#fs_stats_nlink" id="fs_stats_nlink">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The number of hard-links that exist for the file.</p>
-<h3><code>stats.uid</code><span><a class="mark" href="#fs_stats_uid" id="fs_stats_uid">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The numeric user identifier of the user that owns the file (POSIX).</p>
-<h3><code>stats.gid</code><span><a class="mark" href="#fs_stats_gid" id="fs_stats_gid">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The numeric group identifier of the group that owns the file (POSIX).</p>
-<h3><code>stats.rdev</code><span><a class="mark" href="#fs_stats_rdev" id="fs_stats_rdev">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>A numeric device identifier if the file represents a device.</p>
-<h3><code>stats.size</code><span><a class="mark" href="#fs_stats_size" id="fs_stats_size">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The size of the file in bytes.</p>
-<h3><code>stats.blksize</code><span><a class="mark" href="#fs_stats_blksize" id="fs_stats_blksize">#</a></span></h3>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
 </ul>
-<p>The file system block size for i/o operations.</p>
-<h3><code>stats.blocks</code><span><a class="mark" href="#fs_stats_blocks" id="fs_stats_blocks">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Upon success, fulfills with <code>undefined</code> if <code>recursive</code>
+is <code>false</code>, or the first directory path created if <code>recursive</code> is <code>true</code>.</li>
 </ul>
-<p>The number of blocks allocated for this file.</p>
-<h3><code>stats.atimeMs</code><span><a class="mark" href="#fs_stats_atimems" id="fs_stats_atimems">#</a></span></h3>
+<p>Asynchronously creates a directory.</p>
+<p>The optional <code>options</code> argument can be an integer specifying <code>mode</code> (permission
+and sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>
+property indicating whether parent directories should be created. Calling
+<code>fsPromises.mkdir()</code> when <code>path</code> is a directory that exists results in a
+rejection only when <code>recursive</code> is false.</p>
+<h4><code>fsPromises.mkdtemp(prefix[, options])</code><span><a class="mark" href="#fs_fspromises_mkdtemp_prefix_options" id="fs_fspromises_mkdtemp_prefix_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v8.1.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>prefix</code> parameter now accepts an empty string.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
-</ul>
-<p>The timestamp indicating the last time this file was accessed expressed in
-milliseconds since the POSIX Epoch.</p>
-<h3><code>stats.mtimeMs</code><span><a class="mark" href="#fs_stats_mtimems" id="fs_stats_mtimems">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v8.1.0</span>
-</div>
+<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>The timestamp indicating the last time this file was modified expressed in
-milliseconds since the POSIX Epoch.</p>
-<h3><code>stats.ctimeMs</code><span><a class="mark" href="#fs_stats_ctimems" id="fs_stats_ctimems">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v8.1.0</span>
-</div>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with a string containing the filesystem path
+of the newly created temporary directory.</li>
 </ul>
-<p>The timestamp indicating the last time the file status was changed expressed
-in milliseconds since the POSIX Epoch.</p>
-<h3><code>stats.birthtimeMs</code><span><a class="mark" href="#fs_stats_birthtimems" id="fs_stats_birthtimems">#</a></span></h3>
+<p>Creates a unique temporary directory. A unique directory name is generated by
+appending six random characters to the end of the provided <code>prefix</code>. Due to
+platform inconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some
+platforms, notably the BSDs, can return more than six random characters, and
+replace trailing <code>X</code> characters in <code>prefix</code> with random characters.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { mkdtemp } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">mkdtemp</span>(path.<span class="hljs-title function_">join</span>(os.<span class="hljs-title function_">tmpdir</span>(), <span class="hljs-string">'foo-'</span>));
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>The <code>fsPromises.mkdtemp()</code> method will append the six randomly selected
+characters directly to the <code>prefix</code> string. For instance, given a directory
+<code>/tmp</code>, if the intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the
+<code>prefix</code> must end with a trailing platform-specific path separator
+(<code>require('path').sep</code>).</p>
+<h4><code>fsPromises.open(path, flags[, mode])</code><span><a class="mark" href="#fs_fspromises_open_path_flags_mode" id="fs_fspromises_open_path_flags_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v8.1.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v11.1.0</td>
+<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.
+<strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Sets the file mode (permission and sticky bits)
+if the file is created. <strong>Default:</strong> <code>0o666</code> (readable and writable)</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with a <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object.</li>
 </ul>
-<p>The timestamp indicating the creation time of this file expressed in
-milliseconds since the POSIX Epoch.</p>
-<h3><code>stats.atimeNs</code><span><a class="mark" href="#fs_stats_atimens" id="fs_stats_atimens">#</a></span></h3>
+<p>Opens a <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a>.</p>
+<p>Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a> documentation for more detail.</p>
+<p>Some characters (<code>&#x3C; > : " / \ | ? *</code>) are reserved under Windows as documented
+by <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains
+a colon, Node.js will open a file system stream, as described by
+<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams">this MSDN page</a>.</p>
+<h4><code>fsPromises.opendir(path[, options])</code><span><a class="mark" href="#fs_fspromises_opendir_path_options" id="fs_fspromises_opendir_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.10.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
+<tr><td>v12.12.0</td>
+<td><p><span>Added in: v12.12.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
+internally when reading from the directory. Higher values lead to better
+performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
 </ul>
-<p>Only present when <code>bigint: true</code> is passed into the method that generates
-the object.
-The timestamp indicating the last time this file was accessed expressed in
-nanoseconds since the POSIX Epoch.</p>
-<h3><code>stats.mtimeNs</code><span><a class="mark" href="#fs_stats_mtimens" id="fs_stats_mtimens">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with an <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>.</li>
+</ul>
+<p>Asynchronously open a directory for iterative scanning. See the POSIX
+<a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a> documentation for more detail.</p>
+<p>Creates an <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>, which contains all further functions for reading from
+and cleaning up the directory.</p>
+<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
+directory and subsequent read operations.</p>
+<p>Example using async iteration:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { opendir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> dir = <span class="hljs-keyword">await</span> <span class="hljs-title function_">opendir</span>(<span class="hljs-string">'./'</span>);
+  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> dirent <span class="hljs-keyword">of</span> dir)
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(dirent.<span class="hljs-property">name</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>When using the async iterator, the <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a> object will be automatically
+closed after the iterator exits.</p>
+<h4><code>fsPromises.readdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_readdir_path_options" id="fs_fspromises_readdir_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.10.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.11.0</td>
+<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
 </ul>
-<p>Only present when <code>bigint: true</code> is passed into the method that generates
-the object.
-The timestamp indicating the last time this file was modified expressed in
-nanoseconds since the POSIX Epoch.</p>
-<h3><code>stats.ctimeNs</code><span><a class="mark" href="#fs_stats_ctimens" id="fs_stats_ctimens">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with an array of the names of the files in
+the directory excluding <code>'.'</code> and <code>'..'</code>.</li>
+</ul>
+<p>Reads the contents of a directory.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the filenames. If the <code>encoding</code> is set to <code>'buffer'</code>, the filenames returned
+will be passed as <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> objects.</p>
+<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the resolved array will contain
+<a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> objects.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readdir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> files = <span class="hljs-keyword">await</span> <span class="hljs-title function_">readdir</span>(path);
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> file <span class="hljs-keyword">of</span> files)
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(file);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<h4><code>fsPromises.readFile(path[, options])</code><span><a class="mark" href="#fs_fspromises_readfile_path_options" id="fs_fspromises_readfile_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.10.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>The options argument may include an AbortSignal to abort an ongoing readFile request.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress readFile</li>
 </ul>
-<p>Only present when <code>bigint: true</code> is passed into the method that generates
-the object.
-The timestamp indicating the last time the file status was changed expressed
-in nanoseconds since the POSIX Epoch.</p>
-<h3><code>stats.birthtimeNs</code><span><a class="mark" href="#fs_stats_birthtimens" id="fs_stats_birthtimens">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with the contents of the file.</li>
+</ul>
+<p>Asynchronously reads the entire contents of a file.</p>
+<p>If no encoding is specified (using <code>options.encoding</code>), the data is returned
+as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object. Otherwise, the data will be a string.</p>
+<p>If <code>options</code> is a string, then it specifies the encoding.</p>
+<p>When the <code>path</code> is a directory, the behavior of <code>fsPromises.readFile()</code> is
+platform-specific. On macOS, Linux, and Windows, the promise will be rejected
+with an error. On FreeBSD, a representation of the directory's contents will be
+returned.</p>
+<p>It is possible to abort an ongoing <code>readFile</code> using an <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a>. If a
+request is aborted the promise returned is rejected with an <code>AbortError</code>:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+  <span class="hljs-keyword">const</span> { signal } = controller;
+  <span class="hljs-keyword">const</span> promise = <span class="hljs-title function_">readFile</span>(fileName, { signal });
+
+  <span class="hljs-comment">// Abort the request before the promise settles.</span>
+  controller.<span class="hljs-title function_">abort</span>();
+
+  <span class="hljs-keyword">await</span> promise;
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">// When a request is aborted - err is an AbortError</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering <code>fs.readFile</code> performs.</p>
+<p>Any specified <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> has to support reading.</p>
+<h4><code>fsPromises.readlink(path[, options])</code><span><a class="mark" href="#fs_fspromises_readlink_path_options" id="fs_fspromises_readlink_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.10.0</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>Only present when <code>bigint: true</code> is passed into the method that generates
-the object.
-The timestamp indicating the creation time of this file expressed in
-nanoseconds since the POSIX Epoch.</p>
-<h3><code>stats.atime</code><span><a class="mark" href="#fs_stats_atime" id="fs_stats_atime">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with the <code>linkString</code> upon success.</li>
+</ul>
+<p>Reads the contents of the symbolic link referred to by <code>path</code>. See the POSIX
+<a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a> documentation for more detail. The promise is resolved with the
+<code>linkString</code> upon success.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>, the link path
+returned will be passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<h4><code>fsPromises.realpath(path[, options])</code><span><a class="mark" href="#fs_fspromises_realpath_path_options" id="fs_fspromises_realpath_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.11.13</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>The timestamp indicating the last time this file was accessed.</p>
-<h3><code>stats.mtime</code><span><a class="mark" href="#fs_stats_mtime" id="fs_stats_mtime">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with the resolved path upon success.</li>
+</ul>
+<p>Determines the actual location of <code>path</code> using the same semantics as the
+<code>fs.realpath.native()</code> function.</p>
+<p>Only paths that can be converted to UTF8 strings are supported.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the path. If the <code>encoding</code> is set to <code>'buffer'</code>, the path returned will be
+passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
+be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
+this restriction.</p>
+<h4><code>fsPromises.rename(oldPath, newPath)</code><span><a class="mark" href="#fs_fspromises_rename_oldpath_newpath" id="fs_fspromises_rename_oldpath_newpath">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.11.13</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>The timestamp indicating the last time this file was modified.</p>
-<h3><code>stats.ctime</code><span><a class="mark" href="#fs_stats_ctime" id="fs_stats_ctime">#</a></span></h3>
+<p>Renames <code>oldPath</code> to <code>newPath</code>.</p>
+<h4><code>fsPromises.rmdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_rmdir_path_options" id="fs_fspromises_rmdir_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.11.13</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.14.0</td>
+<td><p>The <code>recursive</code> option is deprecated, use <code>fsPromises.rm</code> instead.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
+<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
+<tr><td>v12.10.0</td>
+<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js retries the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode, errors are not reported if <code>path</code> does not exist, and
+operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
 </ul>
-<p>The timestamp indicating the last time the file status was changed.</p>
-<h3><code>stats.birthtime</code><span><a class="mark" href="#fs_stats_birthtime" id="fs_stats_birthtime">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Removes the directory identified by <code>path</code>.</p>
+<p>Using <code>fsPromises.rmdir()</code> on a file (not a directory) results in the
+promise being rejected with an <code>ENOENT</code> error on Windows and an <code>ENOTDIR</code>
+error on POSIX.</p>
+<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command
+<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in
+the future.</p>
+<h4><code>fsPromises.rm(path[, options])</code><span><a class="mark" href="#fs_fspromises_rm_path_options" id="fs_fspromises_rm_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.11.13</span>
+<span>Added in: v14.14.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-</ul>
-<p>The timestamp indicating the creation time of this file.</p>
-<h3>Stat time values<span><a class="mark" href="#fs_stat_time_values" id="fs_stat_time_values">#</a></span></h3>
-<p>The <code>atimeMs</code>, <code>mtimeMs</code>, <code>ctimeMs</code>, <code>birthtimeMs</code> properties are
-numeric values that hold the corresponding times in milliseconds. Their
-precision is platform specific. When <code>bigint: true</code> is passed into the
-method that generates the object, the properties will be <a href="https://tc39.github.io/proposal-bigint">bigints</a>,
-otherwise they will be <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type">numbers</a>.</p>
-<p>The <code>atimeNs</code>, <code>mtimeNs</code>, <code>ctimeNs</code>, <code>birthtimeNs</code> properties are
-<a href="https://tc39.github.io/proposal-bigint">bigints</a> that hold the corresponding times in nanoseconds. They are
-only present when <code>bigint: true</code> is passed into the method that generates
-the object. Their precision is platform specific.</p>
-<p><code>atime</code>, <code>mtime</code>, <code>ctime</code>, and <code>birthtime</code> are
-<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a> object alternate representations of the various times. The
-<code>Date</code> and number values are not connected. Assigning a new number value, or
-mutating the <code>Date</code> value, will not be reflected in the corresponding alternate
-representation.</p>
-<p>The times in the stat object have the following semantics:</p>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>atime</code> "Access Time": Time when file data last accessed. Changed
-by the <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/read.2.html"><code>read(2)</code></a> system calls.</li>
-<li><code>mtime</code> "Modified Time": Time when file data last modified.
-Changed by the <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/write.2.html"><code>write(2)</code></a> system calls.</li>
-<li><code>ctime</code> "Change Time": Time when file status was last changed
-(inode data modification). Changed by the <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>,
-<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>,
-<a href="http://man7.org/linux/man-pages/man2/read.2.html"><code>read(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/write.2.html"><code>write(2)</code></a> system calls.</li>
-<li><code>birthtime</code> "Birth Time": Time of file creation. Set once when the
-file is created. On filesystems where birthtime is not available,
-this field may instead hold either the <code>ctime</code> or
-<code>1970-01-01T00:00Z</code> (ie, Unix epoch timestamp <code>0</code>). This value may be greater
-than <code>atime</code> or <code>mtime</code> in this case. On Darwin and other FreeBSD variants,
-also set if the <code>atime</code> is explicitly set to an earlier value than the current
-<code>birthtime</code> using the <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a> system call.</li>
+<li><code>force</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, exceptions will be ignored if <code>path</code> does
+not exist. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
 </ul>
-<p>Prior to Node.js 0.12, the <code>ctime</code> held the <code>birthtime</code> on Windows systems. As
-of 0.12, <code>ctime</code> is not "creation time", and on Unix systems, it never was.</p>
-<h2>Class: <code>fs.WriteStream</code><span><a class="mark" href="#fs_class_fs_writestream" id="fs_class_fs_writestream">#</a></span></h2>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Removes files and directories (modeled on the standard POSIX <code>rm</code> utility).</p>
+<h4><code>fsPromises.stat(path[, options])</code><span><a class="mark" href="#fs_fspromises_stat_path_options" id="fs_fspromises_stat_path_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li>Extends <a href="stream.html#stream_class_stream_writable" class="type">&#x3C;stream.Writable></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
-<p>Instances of <code>fs.WriteStream</code> are created and returned using the
-<a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> function.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close_2" id="fs_event_close_2">#</a></span></h3>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a>  Fulfills with the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object for the
+given <code>path</code>.</li>
+</ul>
+<h4><code>fsPromises.symlink(target, path[, type])</code><span><a class="mark" href="#fs_fspromises_symlink_target_path_type" id="fs_fspromises_symlink_target_path_type">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v10.0.0</span>
 </div>
-<p>Emitted when the <code>WriteStream</code>'s underlying file descriptor has been closed.</p>
-<h3>Event: <code>'open'</code><span><a class="mark" href="#fs_event_open_1" id="fs_event_open_1">#</a></span></h3>
+<ul>
+<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'file'</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Creates a symbolic link.</p>
+<p>The <code>type</code> argument is only used on Windows platforms and can be one of <code>'dir'</code>,
+<code>'file'</code>, or <code>'junction'</code>. Windows junction points require the destination path
+to be absolute. When using <code>'junction'</code>, the <code>target</code> argument will
+automatically be normalized to absolute path.</p>
+<h4><code>fsPromises.truncate(path[, len])</code><span><a class="mark" href="#fs_fspromises_truncate_path_len" id="fs_fspromises_truncate_path_len">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v10.0.0</span>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Integer file descriptor used by the <code>WriteStream</code>.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
-<p>Emitted when the <code>WriteStream</code>'s file is opened.</p>
-<h3>Event: <code>'ready'</code><span><a class="mark" href="#fs_event_ready_1" id="fs_event_ready_1">#</a></span></h3>
+<p>Truncates (shortens or extends the length) of the content at <code>path</code> to <code>len</code>
+bytes.</p>
+<h4><code>fsPromises.unlink(path)</code><span><a class="mark" href="#fs_fspromises_unlink_path" id="fs_fspromises_unlink_path">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v9.11.0</span>
+<span>Added in: v10.0.0</span>
 </div>
-<p>Emitted when the <code>fs.WriteStream</code> is ready to be used.</p>
-<p>Fires immediately after <code>'open'</code>.</p>
-<h3><code>writeStream.bytesWritten</code><span><a class="mark" href="#fs_writestream_byteswritten" id="fs_writestream_byteswritten">#</a></span></h3>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>If <code>path</code> refers to a symbolic link, then the link is removed without affecting
+the file or directory to which that link refers. If the <code>path</code> refers to a file
+path that is not a symbolic link, the file is deleted. See the POSIX <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>
+documentation for more detail.</p>
+<h4><code>fsPromises.utimes(path, atime, mtime)</code><span><a class="mark" href="#fs_fspromises_utimes_path_atime_mtime" id="fs_fspromises_utimes_path_atime_mtime">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.4.7</span>
+<span>Added in: v10.0.0</span>
 </div>
-<p>The number of bytes written so far. Does not include data that is still queued
-for writing.</p>
-<h3><code>writeStream.path</code><span><a class="mark" href="#fs_writestream_path" id="fs_writestream_path">#</a></span></h3>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>
+<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>
+<ul>
+<li>Values can be either numbers representing Unix epoch time, <code>Date</code>s, or a
+numeric string like <code>'123456789.0'</code>.</li>
+<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or
+<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>
+</ul>
+<h4><code>fsPromises.watch(filename[, options])</code><span><a class="mark" href="#fs_fspromises_watch_filename_options" id="fs_fspromises_watch_filename_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.93</span>
+<span>Added in: v14.18.0</span>
 </div>
-<p>The path to the file the stream is writing to as specified in the first
-argument to <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>. If <code>path</code> is passed as a string, then
-<code>writeStream.path</code> will be a string. If <code>path</code> is passed as a <code>Buffer</code>, then
-<code>writeStream.path</code> will be a <code>Buffer</code>.</p>
-<h3><code>writeStream.pending</code><span><a class="mark" href="#fs_writestream_pending" id="fs_writestream_pending">#</a></span></h3>
+<ul>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>persistent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether the process should continue to run
+as long as files are being watched. <strong>Default:</strong> <code>true</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether all subdirectories should be
+watched, or only the current directory. This applies when a directory is
+specified, and only on supported platforms (See <a href="#fs_caveats">caveats</a>). <strong>Default:</strong>
+<code>false</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Specifies the character encoding to be used for the
+filename passed to the listener. <strong>Default:</strong> <code>'utf8'</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> An <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> used to signal when the watcher
+should stop.</li>
+</ul>
+</li>
+<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterator-interface" class="type">&#x3C;AsyncIterator></a> of objects with the properties:
+<ul>
+<li><code>eventType</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The type of change</li>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The name of the file changed.</li>
+</ul>
+</li>
+</ul>
+<p>Returns an async iterator that watches for changes on <code>filename</code>, where <code>filename</code>
+is either a file or a directory.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { watch } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);
+
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = ac;
+<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> ac.<span class="hljs-title function_">abort</span>(), <span class="hljs-number">10000</span>);
+
+(<span class="hljs-keyword">async</span> () => {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">const</span> watcher = <span class="hljs-title function_">watch</span>(__filename, { signal });
+    <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> event <span class="hljs-keyword">of</span> watcher)
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event);
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">name</span> === <span class="hljs-string">'AbortError'</span>)
+      <span class="hljs-keyword">return</span>;
+    <span class="hljs-keyword">throw</span> err;
+  }
+})();</code></pre>
+<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or
+disappears in the directory.</p>
+<p>All the <a href="#fs_caveats">caveats</a> for <code>fs.watch()</code> also apply to <code>fsPromises.watch()</code>.</p>
+<h4><code>fsPromises.writeFile(file, data[, options])</code><span><a class="mark" href="#fs_fspromises_writefile_file_data_options" id="fs_fspromises_writefile_file_data_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.2.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>data</code> argument supports <code>AsyncIterable</code>, <code>Iterable</code> and <code>Stream</code>.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>The options argument may include an AbortSignal to abort an ongoing writeFile request.</p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>data</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>data</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> | <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress writeFile</li>
 </ul>
-<p>This property is <code>true</code> if the underlying file has not been opened yet,
-i.e. before the <code>'ready'</code> event is emitted.</p>
-<h2><code>fs.access(path[, mode], callback)</code><span><a class="mark" href="#fs_fs_access_path_mode_callback" id="fs_fs_access_path_mode_callback">#</a></span></h2>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
+</ul>
+<p>Asynchronously writes data to a file, replacing the file if it already exists.
+<code>data</code> can be a string, a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>, or, an object with an own (not inherited)
+<code>toString</code> function property.</p>
+<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
+<p>If <code>options</code> is a string, then it specifies the encoding.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<p>Any specified <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> has to support writing.</p>
+<p>It is unsafe to use <code>fsPromises.writeFile()</code> multiple times on the same file
+without waiting for the promise to be settled.</p>
+<p>Similarly to <code>fsPromises.readFile</code> - <code>fsPromises.writeFile</code> is a convenience
+method that performs multiple <code>write</code> calls internally to write the buffer
+passed to it. For performance sensitive code consider using
+<a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>It is possible to use an <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> to cancel an <code>fsPromises.writeFile()</code>.
+Cancelation is "best effort", and some amount of data is likely still
+to be written.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { writeFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+  <span class="hljs-keyword">const</span> { signal } = controller;
+  <span class="hljs-keyword">const</span> data = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Hello Node.js'</span>));
+  <span class="hljs-keyword">const</span> promise = <span class="hljs-title function_">writeFile</span>(<span class="hljs-string">'message.txt'</span>, data, { signal });
+
+  <span class="hljs-comment">// Abort the request before the promise settles.</span>
+  controller.<span class="hljs-title function_">abort</span>();
+
+  <span class="hljs-keyword">await</span> promise;
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">// When a request is aborted - err is an AbortError</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering <code>fs.writeFile</code> performs.</p>
+</section><section><h3>Callback API<span><a class="mark" href="#fs_callback_api" id="fs_callback_api">#</a></span></h3>
+<p>The callback APIs perform all operations asynchronously, without blocking the
+event loop, then invoke a callback function upon completion or error.</p>
+<p>The callback APIs use the underlying Node.js threadpool to perform file
+system operations off the event loop thread. These operations are not
+synchronized or threadsafe. Care must be taken when performing multiple
+concurrent modifications on the same file or data corruption may occur.</p>
+<h4><code>fs.access(path[, mode], callback)</code><span><a class="mark" href="#fs_fs_access_path_mode_callback" id="fs_fs_access_path_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v6.3.0</td>
 <td><p>The constants like <code>fs.R_OK</code>, etc which were present directly on <code>fs</code> were moved into <code>fs.constants</code> as a soft deprecation. Thus for Node.js <code>&#x3C; v6.3.0</code> use <code>fs</code> to access those constants, or do something like <code>(fs.constants || fs).R_OK</code> to work with all versions.</p></td></tr>
 <tr><td>v0.11.15</td>
@@ -1397,30 +1730,32 @@ two or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p
 a possible error argument. If any of the accessibility checks fail, the error
 argument will be an <code>Error</code> object. The following examples check if
 <code>package.json</code> exists, and if it is readable or writable.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> file = <span class="hljs-string">'package.json'</span>;
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { access, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">const</span> file = <span class="hljs-string">'package.json'</span>;
 
 <span class="hljs-comment">// Check if the file exists in the current directory.</span>
-fs.access(file, fs.constants.F_OK, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'does not exist'</span> : <span class="hljs-string">'exists'</span>}</span>`</span>);
+<span class="hljs-title function_">access</span>(file, constants.<span class="hljs-property">F_OK</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'does not exist'</span> : <span class="hljs-string">'exists'</span>}</span>`</span>);
 });
 
 <span class="hljs-comment">// Check if the file is readable.</span>
-fs.access(file, fs.constants.R_OK, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'is not readable'</span> : <span class="hljs-string">'is readable'</span>}</span>`</span>);
+<span class="hljs-title function_">access</span>(file, constants.<span class="hljs-property">R_OK</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'is not readable'</span> : <span class="hljs-string">'is readable'</span>}</span>`</span>);
 });
 
 <span class="hljs-comment">// Check if the file is writable.</span>
-fs.access(file, fs.constants.W_OK, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'is not writable'</span> : <span class="hljs-string">'is writable'</span>}</span>`</span>);
+<span class="hljs-title function_">access</span>(file, constants.<span class="hljs-property">W_OK</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err ? <span class="hljs-string">'is not writable'</span> : <span class="hljs-string">'is writable'</span>}</span>`</span>);
 });
 
 <span class="hljs-comment">// Check if the file exists in the current directory, and if it is writable.</span>
-fs.access(file, fs.constants.F_OK | fs.constants.W_OK, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<span class="hljs-title function_">access</span>(file, constants.<span class="hljs-property">F_OK</span> | constants.<span class="hljs-property">W_OK</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(
       <span class="hljs-string">`<span class="hljs-subst">${file}</span> <span class="hljs-subst">${err.code === <span class="hljs-string">'ENOENT'</span> ? <span class="hljs-string">'does not exist'</span> : <span class="hljs-string">'is read-only'</span>}</span>`</span>);
   } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${file}</span> exists, and it is writable`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${file}</span> exists, and it is writable`</span>);
   }
 });</code></pre>
 <p>Do not use <code>fs.access()</code> to check for the accessibility of a file before calling
@@ -1429,100 +1764,103 @@ so introduces a race condition, since other processes may change the file's
 state between the two calls. Instead, user code should open/read/write the
 file directly and handle the error raised if the file is not accessible.</p>
 <p><strong>write (NOT RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.access(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { access, open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">access</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (!err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile already exists'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile already exists'</span>);
     <span class="hljs-keyword">return</span>;
   }
 
-  fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    writeMyData(fd);
+
+    <span class="hljs-keyword">try</span> {
+      <span class="hljs-title function_">writeMyData</span>(fd);
+    } <span class="hljs-keyword">finally</span> {
+      <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+        <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+      });
+    }
   });
 });</code></pre>
 <p><strong>write (RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'EEXIST'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile already exists'</span>);
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'EEXIST'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile already exists'</span>);
       <span class="hljs-keyword">return</span>;
     }
 
     <span class="hljs-keyword">throw</span> err;
   }
 
-  writeMyData(fd);
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">writeMyData</span>(fd);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  }
 });</code></pre>
 <p><strong>read (NOT RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.access(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { access, open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-title function_">access</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ENOENT'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile does not exist'</span>);
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ENOENT'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile does not exist'</span>);
       <span class="hljs-keyword">return</span>;
     }
 
     <span class="hljs-keyword">throw</span> err;
   }
 
-  fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    readMyData(fd);
+
+    <span class="hljs-keyword">try</span> {
+      <span class="hljs-title function_">readMyData</span>(fd);
+    } <span class="hljs-keyword">finally</span> {
+      <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+        <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+      });
+    }
   });
 });</code></pre>
 <p><strong>read (RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ENOENT'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile does not exist'</span>);
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ENOENT'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile does not exist'</span>);
       <span class="hljs-keyword">return</span>;
     }
 
     <span class="hljs-keyword">throw</span> err;
   }
 
-  readMyData(fd);
-});</code></pre>
-<p>The "not recommended" examples above check for accessibility and then use the
-file; the "recommended" examples are better because they use the file directly
-and handle the error, if any.</p>
-<p>In general, check for the accessibility of a file only if the file will not be
-used directly, for example when its accessibility is a signal from another
-process.</p>
-<p>On Windows, access-control policies (ACLs) on a directory may limit access to
-a file or directory. The <code>fs.access()</code> function, however, does not check the
-ACL and therefore may report that a path is accessible even if the ACL restricts
-the user from reading or writing to it.</p>
-<h2><code>fs.accessSync(path[, mode])</code><span><a class="mark" href="#fs_fs_accesssync_path_mode" id="fs_fs_accesssync_path_mode">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.11.15</td>
-<td><p><span>Added in: v0.11.15</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>fs.constants.F_OK</code></li>
-</ul>
-<p>Synchronously tests a user's permissions for the file or directory specified
-by <code>path</code>. The <code>mode</code> argument is an optional integer that specifies the
-accessibility checks to be performed. Check <a href="#fs_file_access_constants">File access constants</a> for
-possible values of <code>mode</code>. It is possible to create a mask consisting of
-the bitwise OR of two or more values
-(e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>
-<p>If any of the accessibility checks fail, an <code>Error</code> will be thrown. Otherwise,
-the method will return <code>undefined</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  fs.accessSync(<span class="hljs-string">'etc/passwd'</span>, fs.constants.R_OK | fs.constants.W_OK);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'can read/write'</span>);
-} <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'no access!'</span>);
-}</code></pre>
-<h2><code>fs.appendFile(path, data[, options], callback)</code><span><a class="mark" href="#fs_fs_appendfile_path_data_options_callback" id="fs_fs_appendfile_path_data_options_callback">#</a></span></h2>
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">readMyData</span>(fd);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  }
+});</code></pre>
+<p>The "not recommended" examples above check for accessibility and then use the
+file; the "recommended" examples are better because they use the file directly
+and handle the error, if any.</p>
+<p>In general, check for the accessibility of a file only if the file will not be
+used directly, for example when its accessibility is a signal from another
+process.</p>
+<p>On Windows, access-control policies (ACLs) on a directory may limit access to
+a file or directory. The <code>fs.access()</code> function, however, does not check the
+ACL and therefore may report that a path is accessible even if the ACL restricts
+the user from reading or writing to it.</p>
+<h4><code>fs.appendFile(path, data[, options], callback)</code><span><a class="mark" href="#fs_fs_appendfile_path_data_options_callback" id="fs_fs_appendfile_path_data_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1557,75 +1895,44 @@ the method will return <code>undefined</code>.</p>
 </li>
 </ul>
 <p>Asynchronously append data to a file, creating the file if it does not yet
-exist. <code>data</code> can be a string or a <a href="buffer.html#buffer_buffer"><code>Buffer</code></a>.</p>
-<pre><code class="language-js">fs.appendFile(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+exist. <code>data</code> can be a string or a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { appendFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">appendFile</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The "data to append" was appended to file!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The "data to append" was appended to file!'</span>);
 });</code></pre>
 <p>If <code>options</code> is a string, then it specifies the encoding:</p>
-<pre><code class="language-js">fs.appendFile(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { appendFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">appendFile</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
 <p>The <code>path</code> may be specified as a numeric file descriptor that has been opened
 for appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will
 not be closed automatically.</p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close, appendFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">closeFd</span>(<span class="hljs-params">fd</span>) {
+  <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  });
+}
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'a'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  fs.appendFile(fd, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    fs.close(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">appendFile</span>(fd, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-title function_">closeFd</span>(fd);
       <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
     });
-    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  });
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-title function_">closeFd</span>(fd);
+    <span class="hljs-keyword">throw</span> err;
+  }
 });</code></pre>
-<h2><code>fs.appendFileSync(path, data[, options])</code><span><a class="mark" href="#fs_fs_appendfilesync_path_data_options" id="fs_fs_appendfilesync_path_data_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.0.0</td>
-<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
-<tr><td>v5.0.0</td>
-<td><p>The <code>file</code> parameter can be a file descriptor now.</p></td></tr>
-<tr><td>v0.6.7</td>
-<td><p><span>Added in: v0.6.7</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> filename or file descriptor</li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'a'</code>.</li>
-</ul>
-</li>
-</ul>
-<p>Synchronously append data to a file, creating the file if it does not yet
-exist. <code>data</code> can be a string or a <a href="buffer.html#buffer_buffer"><code>Buffer</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  fs.appendFileSync(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The "data to append" was appended to file!'</span>);
-} <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-comment">/* Handle the error */</span>
-}</code></pre>
-<p>If <code>options</code> is a string, then it specifies the encoding:</p>
-<pre><code class="language-js">fs.appendFileSync(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>);</code></pre>
-<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened
-for appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will
-not be closed automatically.</p>
-<pre><code class="language-js"><span class="hljs-keyword">let</span> fd;
-
-<span class="hljs-keyword">try</span> {
-  fd = fs.openSync(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'a'</span>);
-  fs.appendFileSync(fd, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>);
-} <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-comment">/* Handle the error */</span>
-} <span class="hljs-keyword">finally</span> {
-  <span class="hljs-keyword">if</span> (fd !== <span class="hljs-literal">undefined</span>)
-    fs.closeSync(fd);
-}</code></pre>
-<h2><code>fs.chmod(path, mode, callback)</code><span><a class="mark" href="#fs_fs_chmod_path_mode_callback" id="fs_fs_chmod_path_mode_callback">#</a></span></h2>
+<h4><code>fs.chmod(path, mode, callback)</code><span><a class="mark" href="#fs_fs_chmod_path_mode_callback" id="fs_fs_chmod_path_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1633,7 +1940,7 @@ not be closed automatically.</p>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.1.30</td>
@@ -1652,12 +1959,14 @@ not be closed automatically.</p>
 </ul>
 <p>Asynchronously changes the permissions of a file. No arguments other than a
 possible exception are given to the completion callback.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>.</p>
-<pre><code class="language-js">fs.chmod(<span class="hljs-string">'my_file.txt'</span>, <span class="hljs-number">0o775</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a> documentation for more detail.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { chmod } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">chmod</span>(<span class="hljs-string">'my_file.txt'</span>, <span class="hljs-number">0o775</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The permissions for file "my_file.txt" have been changed!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The permissions for file "my_file.txt" have been changed!'</span>);
 });</code></pre>
-<h3>File modes<span><a class="mark" href="#fs_file_modes" id="fs_file_modes">#</a></span></h3>
+<h5>File modes<span><a class="mark" href="#fs_file_modes" id="fs_file_modes">#</a></span></h5>
 <p>The <code>mode</code> argument used in both the <code>fs.chmod()</code> and <code>fs.chmodSync()</code>
 methods is a numeric bitmask created using a logical OR of the following
 constants:</p>
@@ -1763,57 +2072,452 @@ specifies the permissions for others.</p>
 
 
 
-<table><thead><tr><th>Number</th><th>Description</th></tr></thead><tbody><tr><td><code>7</code></td><td>read, write, and execute</td></tr><tr><td><code>6</code></td><td>read and write</td></tr><tr><td><code>5</code></td><td>read and execute</td></tr><tr><td><code>4</code></td><td>read only</td></tr><tr><td><code>3</code></td><td>write and execute</td></tr><tr><td><code>2</code></td><td>write only</td></tr><tr><td><code>1</code></td><td>execute only</td></tr><tr><td><code>0</code></td><td>no permission</td></tr></tbody></table>
-<p>For example, the octal value <code>0o765</code> means:</p>
-<ul>
-<li>The owner may read, write and execute the file.</li>
-<li>The group may read and write the file.</li>
-<li>Others may read and execute the file.</li>
-</ul>
-<p>When using raw numbers where file modes are expected, any value larger than
-<code>0o777</code> may result in platform-specific behaviors that are not supported to work
-consistently. Therefore constants like <code>S_ISVTX</code>, <code>S_ISGID</code> or <code>S_ISUID</code> are not
-exposed in <code>fs.constants</code>.</p>
-<p>Caveats: on Windows only the write permission can be changed, and the
-distinction among the permissions of group, owner or others is not
-implemented.</p>
-<h2><code>fs.chmodSync(path, mode)</code><span><a class="mark" href="#fs_fs_chmodsync_path_mode" id="fs_fs_chmodsync_path_mode">#</a></span></h2>
+<table><thead><tr><th>Number</th><th>Description</th></tr></thead><tbody><tr><td><code>7</code></td><td>read, write, and execute</td></tr><tr><td><code>6</code></td><td>read and write</td></tr><tr><td><code>5</code></td><td>read and execute</td></tr><tr><td><code>4</code></td><td>read only</td></tr><tr><td><code>3</code></td><td>write and execute</td></tr><tr><td><code>2</code></td><td>write only</td></tr><tr><td><code>1</code></td><td>execute only</td></tr><tr><td><code>0</code></td><td>no permission</td></tr></tbody></table>
+<p>For example, the octal value <code>0o765</code> means:</p>
+<ul>
+<li>The owner may read, write and execute the file.</li>
+<li>The group may read and write the file.</li>
+<li>Others may read and execute the file.</li>
+</ul>
+<p>When using raw numbers where file modes are expected, any value larger than
+<code>0o777</code> may result in platform-specific behaviors that are not supported to work
+consistently. Therefore constants like <code>S_ISVTX</code>, <code>S_ISGID</code> or <code>S_ISUID</code> are not
+exposed in <code>fs.constants</code>.</p>
+<p>Caveats: on Windows only the write permission can be changed, and the
+distinction among the permissions of group, owner or others is not
+implemented.</p>
+<h4><code>fs.chown(path, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_chown_path_uid_gid_callback" id="fs_fs_chown_path_uid_gid_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.1.97</td>
+<td><p><span>Added in: v0.1.97</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+</ul>
+</li>
+</ul>
+<p>Asynchronously changes owner and group of a file. No arguments other than a
+possible exception are given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.close(fd[, callback])</code><span><a class="mark" href="#fs_fs_close_fd_callback" id="fs_fs_close_fd_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>A default callback is now used if one is not provided.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.0.2</td>
+<td><p><span>Added in: v0.0.2</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+</ul>
+</li>
+</ul>
+<p>Closes the file descriptor. No arguments other than a possible exception are
+given to the completion callback.</p>
+<p>Calling <code>fs.close()</code> on any file descriptor (<code>fd</code>) that is currently in use
+through any other <code>fs</code> operation may lead to undefined behavior.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/close.2.html"><code>close(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.copyFile(src, dest[, mode], callback)</code><span><a class="mark" href="#fs_fs_copyfile_src_dest_mode_callback" id="fs_fs_copyfile_src_dest_mode_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
+<tr><td>v8.5.0</td>
+<td><p><span>Added in: v8.5.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
+<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+</ul>
+<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
+already exists. No arguments other than a possible exception are given to the
+callback function. Node.js makes no guarantees about the atomicity of the copy
+operation. If an error occurs after the destination file has been opened for
+writing, Node.js will attempt to remove the destination.</p>
+<p><code>mode</code> is an optional integer that specifies the behavior
+of the copy operation. It is possible to create a mask consisting of the bitwise
+OR of two or more values (e.g.
+<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
+<ul>
+<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already
+exists.</li>
+<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a
+copy-on-write reflink. If the platform does not support copy-on-write, then a
+fallback copy mechanism is used.</li>
+<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
+create a copy-on-write reflink. If the platform does not support
+copy-on-write, then the operation will fail.</li>
+</ul>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { copyFile, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">callback</span>(<span class="hljs-params">err</span>) {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
+}
+
+<span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
+<span class="hljs-title function_">copyFile</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, callback);
+
+<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
+<span class="hljs-title function_">copyFile</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, constants.<span class="hljs-property">COPYFILE_EXCL</span>, callback);</code></pre>
+<h4><code>fs.createReadStream(path[, options])</code><span><a class="mark" href="#fs_fs_createreadstream_path_options" id="fs_fs_createreadstream_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Change <code>emitClose</code> default to <code>true</code>.</p></td></tr>
+<tr><td>v13.6.0, v12.17.0</td>
+<td><p>The <code>fs</code> options allow overriding the used <code>fs</code> implementation.</p></td></tr>
+<tr><td>v12.10.0</td>
+<td><p>Enable <code>emitClose</code> option.</p></td></tr>
+<tr><td>v11.0.0</td>
+<td><p>Impose new restrictions on <code>start</code> and <code>end</code>, throwing more appropriate errors in cases when we cannot reasonably handle the input values.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
+<tr><td>v2.3.0</td>
+<td><p>The passed <code>options</code> object can be a string now.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong>
+<code>'r'</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>autoClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
+<li><code>emitClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
+<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>Infinity</code></li>
+<li><code>highWaterMark</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>64 * 1024</code></li>
+<li><code>fs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+</ul>
+</li>
+<li>Returns: <a href="fs.html#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a> See <a href="stream.html#stream_class_stream_readable">Readable Stream</a>.</li>
+</ul>
+<p>Unlike the 16 kb default <code>highWaterMark</code> for a readable stream, the stream
+returned by this method has a default <code>highWaterMark</code> of 64 kb.</p>
+<p><code>options</code> can include <code>start</code> and <code>end</code> values to read a range of bytes from
+the file instead of the entire file. Both <code>start</code> and <code>end</code> are inclusive and
+start counting at 0, allowed values are in the
+[0, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER"><code>Number.MAX_SAFE_INTEGER</code></a>] range. If <code>fd</code> is specified and <code>start</code> is
+omitted or <code>undefined</code>, <code>fs.createReadStream()</code> reads sequentially from the
+current file position. The <code>encoding</code> can be any one of those accepted by
+<a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<p>If <code>fd</code> is specified, <code>ReadStream</code> will ignore the <code>path</code> argument and will use
+the specified file descriptor. This means that no <code>'open'</code> event will be
+emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s should be passed to
+<a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
+<p>If <code>fd</code> points to a character device that only supports blocking reads
+(such as keyboard or sound card), read operations do not finish until data is
+available. This can prevent the process from exiting and the stream from
+closing naturally.</p>
+<p>By default, the stream will emit a <code>'close'</code> event after it has been
+destroyed, like most <code>Readable</code> streams.  Set the <code>emitClose</code> option to
+<code>false</code> to change this behavior.</p>
+<p>By providing the <code>fs</code> option, it is possible to override the corresponding <code>fs</code>
+implementations for <code>open</code>, <code>read</code>, and <code>close</code>. When providing the <code>fs</code> option,
+overrides for <code>open</code>, <code>read</code>, and <code>close</code> are required.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { createReadStream } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// Create a stream from some character device.</span>
+<span class="hljs-keyword">const</span> stream = <span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'/dev/input/event0'</span>);
+<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
+  stream.<span class="hljs-title function_">close</span>(); <span class="hljs-comment">// This may not close the stream.</span>
+  <span class="hljs-comment">// Artificially marking end-of-stream, as if the underlying resource had</span>
+  <span class="hljs-comment">// indicated end-of-file by itself, allows the stream to close.</span>
+  <span class="hljs-comment">// This does not cancel pending read operations, and if there is such an</span>
+  <span class="hljs-comment">// operation, the process may still not be able to exit successfully</span>
+  <span class="hljs-comment">// until it finishes.</span>
+  stream.<span class="hljs-title function_">push</span>(<span class="hljs-literal">null</span>);
+  stream.<span class="hljs-title function_">read</span>(<span class="hljs-number">0</span>);
+}, <span class="hljs-number">100</span>);</code></pre>
+<p>If <code>autoClose</code> is false, then the file descriptor won't be closed, even if
+there's an error. It is the application's responsibility to close it and make
+sure there's no file descriptor leak. If <code>autoClose</code> is set to true (default
+behavior), on <code>'error'</code> or <code>'end'</code> the file descriptor will be closed
+automatically.</p>
+<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the
+file was created.</p>
+<p>An example to read the last 10 bytes of a file which is 100 bytes long:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { createReadStream } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'sample.txt'</span>, { <span class="hljs-attr">start</span>: <span class="hljs-number">90</span>, <span class="hljs-attr">end</span>: <span class="hljs-number">99</span> });</code></pre>
+<p>If <code>options</code> is a string, then it specifies the encoding.</p>
+<h4><code>fs.createWriteStream(path[, options])</code><span><a class="mark" href="#fs_fs_createwritestream_path_options" id="fs_fs_createwritestream_path_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Change <code>emitClose</code> default to <code>true</code>.</p></td></tr>
+<tr><td>v13.6.0, v12.17.0</td>
+<td><p>The <code>fs</code> options allow overriding the used <code>fs</code> implementation.</p></td></tr>
+<tr><td>v12.10.0</td>
+<td><p>Enable <code>emitClose</code> option.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
+<tr><td>v5.5.0</td>
+<td><p>The <code>autoClose</code> option is supported now.</p></td></tr>
+<tr><td>v2.3.0</td>
+<td><p>The passed <code>options</code> object can be a string now.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong>
+<code>'w'</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>autoClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
+<li><code>emitClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
+<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>fs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+</ul>
+</li>
+<li>Returns: <a href="fs.html#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> See <a href="stream.html#stream_class_stream_writable">Writable Stream</a>.</li>
+</ul>
+<p><code>options</code> may also include a <code>start</code> option to allow writing data at some
+position past the beginning of the file, allowed values are in the
+[0, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER"><code>Number.MAX_SAFE_INTEGER</code></a>] range. Modifying a file rather than replacing
+it may require the <code>flags</code> option to be set to <code>r+</code> rather than the default <code>w</code>.
+The <code>encoding</code> can be any one of those accepted by <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<p>If <code>autoClose</code> is set to true (default behavior) on <code>'error'</code> or <code>'finish'</code>
+the file descriptor will be closed automatically. If <code>autoClose</code> is false,
+then the file descriptor won't be closed, even if there's an error.
+It is the application's responsibility to close it and make sure there's no
+file descriptor leak.</p>
+<p>By default, the stream will emit a <code>'close'</code> event after it has been
+destroyed, like most <code>Writable</code> streams.  Set the <code>emitClose</code> option to
+<code>false</code> to change this behavior.</p>
+<p>By providing the <code>fs</code> option it is possible to override the corresponding <code>fs</code>
+implementations for <code>open</code>, <code>write</code>, <code>writev</code> and <code>close</code>. Overriding <code>write()</code>
+without <code>writev()</code> can reduce performance as some optimizations (<code>_writev()</code>)
+will be disabled. When providing the <code>fs</code> option,  overrides for <code>open</code>,
+<code>close</code>, and at least one of <code>write</code> and <code>writev</code> are required.</p>
+<p>Like <a href="fs.html#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a>, if <code>fd</code> is specified, <a href="fs.html#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> will ignore the
+<code>path</code> argument and will use the specified file descriptor. This means that no
+<code>'open'</code> event will be emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s
+should be passed to <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
+<p>If <code>options</code> is a string, then it specifies the encoding.</p>
+<h4><code>fs.exists(path, callback)</code><span><a class="mark" href="#fs_fs_exists_path_callback" id="fs_fs_exists_path_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v1.0.0</td>
+<td><p><span>Deprecated since: v1.0.0</span></p></td></tr>
+<tr><td>v0.0.2</td>
+<td><p><span>Added in: v0.0.2</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#fs_fs_stat_path_options_callback"><code>fs.stat()</code></a> or <a href="#fs_fs_access_path_mode_callback"><code>fs.access()</code></a> instead.</div><p></p>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>exists</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+</li>
+</ul>
+<p>Test whether or not the given path exists by checking with the file system.
+Then call the <code>callback</code> argument with either true or false:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { exists } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">exists</span>(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(e ? <span class="hljs-string">'it exists'</span> : <span class="hljs-string">'no passwd!'</span>);
+});</code></pre>
+<p><strong>The parameters for this callback are not consistent with other Node.js
+callbacks.</strong> Normally, the first parameter to a Node.js callback is an <code>err</code>
+parameter, optionally followed by other parameters. The <code>fs.exists()</code> callback
+has only one boolean parameter. This is one reason <code>fs.access()</code> is recommended
+instead of <code>fs.exists()</code>.</p>
+<p>Using <code>fs.exists()</code> to check for the existence of a file before calling
+<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended. Doing
+so introduces a race condition, since other processes may change the file's
+state between the two calls. Instead, user code should open/read/write the
+file directly and handle the error raised if the file does not exist.</p>
+<p><strong>write (NOT RECOMMENDED)</strong></p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { exists, open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">exists</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-keyword">if</span> (e) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile already exists'</span>);
+  } <span class="hljs-keyword">else</span> {
+    <span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+
+      <span class="hljs-keyword">try</span> {
+        <span class="hljs-title function_">writeMyData</span>(fd);
+      } <span class="hljs-keyword">finally</span> {
+        <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+          <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+        });
+      }
+    });
+  }
+});</code></pre>
+<p><strong>write (RECOMMENDED)</strong></p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) {
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'EEXIST'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile already exists'</span>);
+      <span class="hljs-keyword">return</span>;
+    }
+
+    <span class="hljs-keyword">throw</span> err;
+  }
+
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">writeMyData</span>(fd);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  }
+});</code></pre>
+<p><strong>read (NOT RECOMMENDED)</strong></p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close, exists } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">exists</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-keyword">if</span> (e) {
+    <span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+
+      <span class="hljs-keyword">try</span> {
+        <span class="hljs-title function_">readMyData</span>(fd);
+      } <span class="hljs-keyword">finally</span> {
+        <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+          <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+        });
+      }
+    });
+  } <span class="hljs-keyword">else</span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile does not exist'</span>);
+  }
+});</code></pre>
+<p><strong>read (RECOMMENDED)</strong></p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) {
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ENOENT'</span>) {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'myfile does not exist'</span>);
+      <span class="hljs-keyword">return</span>;
+    }
+
+    <span class="hljs-keyword">throw</span> err;
+  }
+
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">readMyData</span>(fd);
+  } <span class="hljs-keyword">finally</span> {
+    <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  }
+});</code></pre>
+<p>The "not recommended" examples above check for existence and then use the
+file; the "recommended" examples are better because they use the file directly
+and handle the error, if any.</p>
+<p>In general, check for the existence of a file only if the file won’t be
+used directly, for example when its existence is a signal from another
+process.</p>
+<h4><code>fs.fchmod(fd, mode, callback)</code><span><a class="mark" href="#fs_fs_fchmod_fd_mode_callback" id="fs_fs_fchmod_fd_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.6.7</td>
-<td><p><span>Added in: v0.6.7</span></p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.4.7</td>
+<td><p><span>Added in: v0.4.7</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>.</p>
-<h2><code>fs.chown(path, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_chown_path_uid_gid_callback" id="fs_fs_chown_path_uid_gid_callback">#</a></span></h2>
+</li>
+</ul>
+<p>Sets the permissions on the file. No arguments other than a possible exception
+are given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fchmod.2.html"><code>fchmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fchown(fd, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_fchown_fd_uid_gid_callback" id="fs_fs_fchown_fd_uid_gid_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.1.97</td>
-<td><p><span>Added in: v0.1.97</span></p></td></tr>
+<tr><td>v0.4.7</td>
+<td><p><span>Added in: v0.4.7</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -1822,900 +2526,1031 @@ this API: <a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.
 </ul>
 </li>
 </ul>
-<p>Asynchronously changes owner and group of a file. No arguments other than a
-possible exception are given to the completion callback.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>.</p>
-<h2><code>fs.chownSync(path, uid, gid)</code><span><a class="mark" href="#fs_fs_chownsync_path_uid_gid" id="fs_fs_chownsync_path_uid_gid">#</a></span></h2>
+<p>Sets the owner of the file. No arguments other than a possible exception are
+given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fchown.2.html"><code>fchown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fdatasync(fd, callback)</code><span><a class="mark" href="#fs_fs_fdatasync_fd_callback" id="fs_fs_fdatasync_fd_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.97</td>
-<td><p><span>Added in: v0.1.97</span></p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.1.96</td>
+<td><p><span>Added in: v0.1.96</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
-<p>Synchronously changes owner and group of a file. Returns <code>undefined</code>.
-This is the synchronous version of <a href="#fs_fs_chown_path_uid_gid_callback"><code>fs.chown()</code></a>.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>.</p>
-<h2><code>fs.close(fd, callback)</code><span><a class="mark" href="#fs_fs_close_fd_callback" id="fs_fs_close_fd_callback">#</a></span></h2>
+</li>
+</ul>
+<p>Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+<a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a> documentation for details. No arguments other than a possible
+exception are given to the completion callback.</p>
+<h4><code>fs.fstat(fd[, options], callback)</code><span><a class="mark" href="#fs_fs_fstat_fd_options_callback" id="fs_fs_fstat_fd_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.0.2</td>
-<td><p><span>Added in: v0.0.2</span></p></td></tr>
+<tr><td>v0.1.95</td>
+<td><p><span>Added in: v0.1.95</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>stats</code> <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/close.2.html"><code>close(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
-<p>Calling <code>fs.close()</code> on any file descriptor (<code>fd</code>) that is currently in use
-through any other <code>fs</code> operation may lead to undefined behavior.</p>
-<h2><code>fs.closeSync(fd)</code><span><a class="mark" href="#fs_fs_closesync_fd" id="fs_fs_closesync_fd">#</a></span></h2>
+<p>Invokes the callback with the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the file descriptor.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fstat.2.html"><code>fstat(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fsync(fd, callback)</code><span><a class="mark" href="#fs_fs_fsync_fd_callback" id="fs_fs_fsync_fd_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.21</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.1.96</td>
+<td><p><span>Added in: v0.1.96</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/close.2.html"><code>close(2)</code></a>. Returns <code>undefined</code>.</p>
-<p>Calling <code>fs.closeSync()</code> on any file descriptor (<code>fd</code>) that is currently in use
-through any other <code>fs</code> operation may lead to undefined behavior.</p>
-<h2><code>fs.constants</code><span><a class="mark" href="#fs_fs_constants" id="fs_fs_constants">#</a></span></h2>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
-<p>Returns an object containing commonly used constants for file system
-operations. The specific constants currently defined are described in
-<a href="#fs_fs_constants_1">FS constants</a>.</p>
-<h2><code>fs.copyFile(src, dest[, flags], callback)</code><span><a class="mark" href="#fs_fs_copyfile_src_dest_flags_callback" id="fs_fs_copyfile_src_dest_flags_callback">#</a></span></h2>
+</li>
+</ul>
+<p>Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a> documentation for more detail. No arguments other
+than a possible exception are given to the completion callback.</p>
+<h4><code>fs.ftruncate(fd[, len], callback)</code><span><a class="mark" href="#fs_fs_ftruncate_fd_len_callback" id="fs_fs_ftruncate_fd_len_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v14.0.0</td>
-<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
-<tr><td>v8.5.0</td>
-<td><p><span>Added in: v8.5.0</span></p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.8.6</td>
+<td><p><span>Added in: v0.8.6</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
-<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
-</ul>
-<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
-already exists. No arguments other than a possible exception are given to the
-callback function. Node.js makes no guarantees about the atomicity of the copy
-operation. If an error occurs after the destination file has been opened for
-writing, Node.js will attempt to remove the destination.</p>
-<p><code>flags</code> is an optional integer that specifies the behavior
-of the copy operation. It is possible to create a mask consisting of the bitwise
-OR of two or more values (e.g.
-<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already
-exists.</li>
-<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a
-copy-on-write reflink. If the platform does not support copy-on-write, then a
-fallback copy mechanism is used.</li>
-<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.</li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+</ul>
+</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<p>Truncates the file descriptor. No arguments other than a possible exception are
+given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/ftruncate.2.html"><code>ftruncate(2)</code></a> documentation for more detail.</p>
+<p>If the file referred to by the file descriptor was larger than <code>len</code> bytes, only
+the first <code>len</code> bytes will be retained in the file.</p>
+<p>For example, the following program retains only the first four bytes of the
+file:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close, ftruncate } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
-fs.copyFile(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">closeFd</span>(<span class="hljs-params">fd</span>) {
+  <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  });
+}
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
-});</code></pre>
-<p>If the third argument is a number, then it specifies <code>flags</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> { COPYFILE_EXCL } = fs.constants;
 
-<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
-fs.copyFile(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, COPYFILE_EXCL, callback);</code></pre>
-<h2><code>fs.copyFileSync(src, dest[, flags])</code><span><a class="mark" href="#fs_fs_copyfilesync_src_dest_flags" id="fs_fs_copyfilesync_src_dest_flags">#</a></span></h2>
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">ftruncate</span>(fd, <span class="hljs-number">4</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+      <span class="hljs-title function_">closeFd</span>(fd);
+      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    });
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-title function_">closeFd</span>(fd);
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  }
+});</code></pre>
+<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the
+extended part is filled with null bytes (<code>'\0'</code>):</p>
+<p>If <code>len</code> is negative then <code>0</code> will be used.</p>
+<h4><code>fs.futimes(fd, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_futimes_fd_atime_mtime_callback" id="fs_fs_futimes_fd_atime_mtime_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v14.0.0</td>
-<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
-<tr><td>v8.5.0</td>
-<td><p><span>Added in: v8.5.0</span></p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v4.1.0</td>
+<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
+<tr><td>v0.4.2</td>
+<td><p><span>Added in: v0.4.2</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
-<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
-</ul>
-<p>Synchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
-already exists. Returns <code>undefined</code>. Node.js makes no guarantees about the
-atomicity of the copy operation. If an error occurs after the destination file
-has been opened for writing, Node.js will attempt to remove the destination.</p>
-<p><code>flags</code> is an optional integer that specifies the behavior
-of the copy operation. It is possible to create a mask consisting of the bitwise
-OR of two or more values (e.g.
-<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already
-exists.</li>
-<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a
-copy-on-write reflink. If the platform does not support copy-on-write, then a
-fallback copy mechanism is used.</li>
-<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.</li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-
-<span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
-fs.copyFileSync(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);</code></pre>
-<p>If the third argument is a number, then it specifies <code>flags</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> { COPYFILE_EXCL } = fs.constants;
-
-<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
-fs.copyFileSync(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, COPYFILE_EXCL);</code></pre>
-<h2><code>fs.createReadStream(path[, options])</code><span><a class="mark" href="#fs_fs_createreadstream_path_options" id="fs_fs_createreadstream_path_options">#</a></span></h2>
+</li>
+</ul>
+<p>Change the file system timestamps of the object referenced by the supplied file
+descriptor. See <a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>.</p>
+<p>This function does not work on AIX versions before 7.1, it will return the
+error <code>UV_ENOSYS</code>.</p>
+<h4><code>fs.lchmod(path, mode, callback)</code><span><a class="mark" href="#fs_fs_lchmod_path_mode_callback" id="fs_fs_lchmod_path_mode_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>The <code>fs</code> options allow overriding the used <code>fs</code> implementation.</p></td></tr>
-<tr><td>v12.10.0</td>
-<td><p>Enable <code>emitClose</code> option.</p></td></tr>
-<tr><td>v11.0.0</td>
-<td><p>Impose new restrictions on <code>start</code> and <code>end</code>, throwing more appropriate errors in cases when we cannot reasonably handle the input values.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.0.0</td>
-<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
-<tr><td>v2.3.0</td>
-<td><p>The passed <code>options</code> object can be a string now.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.4.7</td>
+<td><p><span>Deprecated since: v0.4.7</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong>
-<code>'r'</code>.</li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>null</code></li>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>autoClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
-<li><code>emitClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>Infinity</code></li>
-<li><code>highWaterMark</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>64 * 1024</code></li>
-<li><code>fs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
-<li>Returns: <a href="fs.html#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a> See <a href="stream.html#stream_class_stream_readable">Readable Stream</a>.</li>
 </ul>
-<p>Unlike the 16 kb default <code>highWaterMark</code> for a readable stream, the stream
-returned by this method has a default <code>highWaterMark</code> of 64 kb.</p>
-<p><code>options</code> can include <code>start</code> and <code>end</code> values to read a range of bytes from
-the file instead of the entire file. Both <code>start</code> and <code>end</code> are inclusive and
-start counting at 0, allowed values are in the
-[0, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER"><code>Number.MAX_SAFE_INTEGER</code></a>] range. If <code>fd</code> is specified and <code>start</code> is
-omitted or <code>undefined</code>, <code>fs.createReadStream()</code> reads sequentially from the
-current file position. The <code>encoding</code> can be any one of those accepted by
-<a href="buffer.html#buffer_buffer"><code>Buffer</code></a>.</p>
-<p>If <code>fd</code> is specified, <code>ReadStream</code> will ignore the <code>path</code> argument and will use
-the specified file descriptor. This means that no <code>'open'</code> event will be
-emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s should be passed to
-<a href="net.html#net_class_net_socket"><code>net.Socket</code></a>.</p>
-<p>If <code>fd</code> points to a character device that only supports blocking reads
-(such as keyboard or sound card), read operations do not finish until data is
-available. This can prevent the process from exiting and the stream from
-closing naturally.</p>
-<p>By default, the stream will not emit a <code>'close'</code> event after it has been
-destroyed. This is the opposite of the default for other <code>Readable</code> streams.
-Set the <code>emitClose</code> option to <code>true</code> to change this behavior.</p>
-<p>By providing the <code>fs</code> option, it is possible to override the corresponding <code>fs</code>
-implementations for <code>open</code>, <code>read</code>, and <code>close</code>. When providing the <code>fs</code> option,
-overrides for <code>open</code>, <code>read</code>, and <code>close</code> are required.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-comment">// Create a stream from some character device.</span>
-<span class="hljs-keyword">const</span> stream = fs.createReadStream(<span class="hljs-string">'/dev/input/event0'</span>);
-<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  stream.close(); <span class="hljs-comment">// This may not close the stream.</span>
-  <span class="hljs-comment">// Artificially marking end-of-stream, as if the underlying resource had</span>
-  <span class="hljs-comment">// indicated end-of-file by itself, allows the stream to close.</span>
-  <span class="hljs-comment">// This does not cancel pending read operations, and if there is such an</span>
-  <span class="hljs-comment">// operation, the process may still not be able to exit successfully</span>
-  <span class="hljs-comment">// until it finishes.</span>
-  stream.push(<span class="hljs-literal">null</span>);
-  stream.read(<span class="hljs-number">0</span>);
-}, <span class="hljs-number">100</span>);</code></pre>
-<p>If <code>autoClose</code> is false, then the file descriptor won't be closed, even if
-there's an error. It is the application's responsibility to close it and make
-sure there's no file descriptor leak. If <code>autoClose</code> is set to true (default
-behavior), on <code>'error'</code> or <code>'end'</code> the file descriptor will be closed
-automatically.</p>
-<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the
-file was created.</p>
-<p>An example to read the last 10 bytes of a file which is 100 bytes long:</p>
-<pre><code class="language-js">fs.createReadStream(<span class="hljs-string">'sample.txt'</span>, { <span class="hljs-attr">start</span>: <span class="hljs-number">90</span>, <span class="hljs-attr">end</span>: <span class="hljs-number">99</span> });</code></pre>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<h2><code>fs.createWriteStream(path[, options])</code><span><a class="mark" href="#fs_fs_createwritestream_path_options" id="fs_fs_createwritestream_path_options">#</a></span></h2>
+<p>Changes the permissions on a symbolic link. No arguments other than a possible
+exception are given to the completion callback.</p>
+<p>This method is only implemented on macOS.</p>
+<p>See the POSIX <a href="https://www.freebsd.org/cgi/man.cgi?query=lchmod&#x26;sektion=2"><code>lchmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.lchown(path, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_lchown_path_uid_gid_callback" id="fs_fs_lchown_path_uid_gid_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>The <code>fs</code> options allow overriding the used <code>fs</code> implementation.</p></td></tr>
-<tr><td>v12.10.0</td>
-<td><p>Enable <code>emitClose</code> option.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v10.6.0</td>
+<td><p>This API is no longer deprecated.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.0.0</td>
-<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
-<tr><td>v5.5.0</td>
-<td><p>The <code>autoClose</code> option is supported now.</p></td></tr>
-<tr><td>v2.3.0</td>
-<td><p>The passed <code>options</code> object can be a string now.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.4.7</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong>
-<code>'w'</code>.</li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>autoClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
-<li><code>emitClose</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>fs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
-<li>Returns: <a href="fs.html#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> See <a href="#stream_class_stream_writable">Writable Stream</a>.</li>
 </ul>
-<p><code>options</code> may also include a <code>start</code> option to allow writing data at
-some position past the beginning of the file, allowed values are in the
-[0, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER"><code>Number.MAX_SAFE_INTEGER</code></a>] range. Modifying a file rather
-than replacing it may require a <code>flags</code> mode of <code>r+</code> rather than the
-default mode <code>w</code>. The <code>encoding</code> can be any one of those accepted by
-<a href="buffer.html#buffer_buffer"><code>Buffer</code></a>.</p>
-<p>If <code>autoClose</code> is set to true (default behavior) on <code>'error'</code> or <code>'finish'</code>
-the file descriptor will be closed automatically. If <code>autoClose</code> is false,
-then the file descriptor won't be closed, even if there's an error.
-It is the application's responsibility to close it and make sure there's no
-file descriptor leak.</p>
-<p>By default, the stream will not emit a <code>'close'</code> event after it has been
-destroyed. This is the opposite of the default for other <code>Writable</code> streams.
-Set the <code>emitClose</code> option to <code>true</code> to change this behavior.</p>
-<p>By providing the <code>fs</code> option it is possible to override the corresponding <code>fs</code>
-implementations for <code>open</code>, <code>write</code>, <code>writev</code> and <code>close</code>. Overriding <code>write()</code>
-without <code>writev()</code> can reduce performance as some optimizations (<code>_writev()</code>)
-will be disabled. When providing the <code>fs</code> option,  overrides for <code>open</code>,
-<code>close</code>, and at least one of <code>write</code> and <code>writev</code> are required.</p>
-<p>Like <a href="#fs_class_fs_readstream"><code>ReadStream</code></a>, if <code>fd</code> is specified, <a href="#fs_class_fs_writestream"><code>WriteStream</code></a> will ignore the
-<code>path</code> argument and will use the specified file descriptor. This means that no
-<code>'open'</code> event will be emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s
-should be passed to <a href="net.html#net_class_net_socket"><code>net.Socket</code></a>.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<h2><code>fs.exists(path, callback)</code><span><a class="mark" href="#fs_fs_exists_path_callback" id="fs_fs_exists_path_callback">#</a></span></h2>
+<p>Set the owner of the symbolic link. No arguments other than a possible
+exception are given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/lchown.2.html"><code>lchown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.lutimes(path, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_lutimes_path_atime_mtime_callback" id="fs_fs_lutimes_path_atime_mtime_callback">#</a></span></h4>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v1.0.0</td>
-<td><p><span>Deprecated since: v1.0.0</span></p></td></tr>
-<tr><td>v0.0.2</td>
-<td><p><span>Added in: v0.0.2</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v14.5.0, v12.19.0</span>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#fs_fs_stat_path_options_callback"><code>fs.stat()</code></a> or <a href="#fs_fs_access_path_mode_callback"><code>fs.access()</code></a> instead.</div><p></p>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>exists</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
 </ul>
-<p>Test whether or not the given path exists by checking with the file system.
-Then call the <code>callback</code> argument with either true or false:</p>
-<pre><code class="language-js">fs.exists(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-function">(<span class="hljs-params">exists</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(exists ? <span class="hljs-string">'it\'s there'</span> : <span class="hljs-string">'no passwd!'</span>);
-});</code></pre>
-<p><strong>The parameters for this callback are not consistent with other Node.js
-callbacks.</strong> Normally, the first parameter to a Node.js callback is an <code>err</code>
-parameter, optionally followed by other parameters. The <code>fs.exists()</code> callback
-has only one boolean parameter. This is one reason <code>fs.access()</code> is recommended
-instead of <code>fs.exists()</code>.</p>
-<p>Using <code>fs.exists()</code> to check for the existence of a file before calling
-<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended. Doing
-so introduces a race condition, since other processes may change the file's
-state between the two calls. Instead, user code should open/read/write the
-file directly and handle the error raised if the file does not exist.</p>
-<p><strong>write (NOT RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.exists(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">exists</span>) =></span> {
-  <span class="hljs-keyword">if</span> (exists) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile already exists'</span>);
-  } <span class="hljs-keyword">else</span> {
-    fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-      writeMyData(fd);
-    });
-  }
-});</code></pre>
-<p><strong>write (RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'wx'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'EEXIST'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile already exists'</span>);
-      <span class="hljs-keyword">return</span>;
-    }
-
-    <span class="hljs-keyword">throw</span> err;
-  }
-
-  writeMyData(fd);
-});</code></pre>
-<p><strong>read (NOT RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.exists(<span class="hljs-string">'myfile'</span>, <span class="hljs-function">(<span class="hljs-params">exists</span>) =></span> {
-  <span class="hljs-keyword">if</span> (exists) {
-    fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-      <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-      readMyData(fd);
-    });
-  } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile does not exist'</span>);
-  }
-});</code></pre>
-<p><strong>read (RECOMMENDED)</strong></p>
-<pre><code class="language-js">fs.open(<span class="hljs-string">'myfile'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ENOENT'</span>) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'myfile does not exist'</span>);
-      <span class="hljs-keyword">return</span>;
-    }
-
-    <span class="hljs-keyword">throw</span> err;
-  }
-
-  readMyData(fd);
-});</code></pre>
-<p>The "not recommended" examples above check for existence and then use the
-file; the "recommended" examples are better because they use the file directly
-and handle the error, if any.</p>
-<p>In general, check for the existence of a file only if the file won’t be
-used directly, for example when its existence is a signal from another
-process.</p>
-<h2><code>fs.existsSync(path)</code><span><a class="mark" href="#fs_fs_existssync_path" id="fs_fs_existssync_path">#</a></span></h2>
+<p>Changes the access and modification times of a file in the same way as
+<a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>, with the difference that if the path refers to a symbolic
+link, then the link is not dereferenced: instead, the timestamps of the
+symbolic link itself are changed.</p>
+<p>No arguments other than a possible exception are given to the completion
+callback.</p>
+<h4><code>fs.link(existingPath, newPath, callback)</code><span><a class="mark" href="#fs_fs_link_existingpath_newpath_callback" id="fs_fs_link_existingpath_newpath_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
+<td><p>The <code>existingPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
-<p>Returns <code>true</code> if the path exists, <code>false</code> otherwise.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="fs.html#fs_fs_exists_path_callback"><code>fs.exists()</code></a>.</p>
-<p><code>fs.exists()</code> is deprecated, but <code>fs.existsSync()</code> is not. The <code>callback</code>
-parameter to <code>fs.exists()</code> accepts parameters that are inconsistent with other
-Node.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (fs.existsSync(<span class="hljs-string">'/etc/passwd'</span>)) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The path exists.'</span>);
-}</code></pre>
-<h2><code>fs.fchmod(fd, mode, callback)</code><span><a class="mark" href="#fs_fs_fchmod_fd_mode_callback" id="fs_fs_fchmod_fd_mode_callback">#</a></span></h2>
+</li>
+</ul>
+<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX
+<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a> documentation for more detail. No arguments other than a possible
+exception are given to the completion callback.</p>
+<h4><code>fs.lstat(path[, options], callback)</code><span><a class="mark" href="#fs_fs_lstat_path_options_callback" id="fs_fs_lstat_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.4.7</td>
-<td><p><span>Added in: v0.4.7</span></p></td></tr>
+<tr><td>v0.1.30</td>
+<td><p><span>Added in: v0.1.30</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>stats</code> <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fchmod.2.html"><code>fchmod(2)</code></a>. No arguments other than a possible exception
-are given to the completion callback.</p>
-<h2><code>fs.fchmodSync(fd, mode)</code><span><a class="mark" href="#fs_fs_fchmodsync_fd_mode" id="fs_fs_fchmodsync_fd_mode">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.4.7</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fchmod.2.html"><code>fchmod(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.fchown(fd, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_fchown_fd_uid_gid_callback" id="fs_fs_fchown_fd_uid_gid_callback">#</a></span></h2>
+<p>Retrieves the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the symbolic link referred to by the path.
+The callback gets two arguments <code>(err, stats)</code> where <code>stats</code> is a <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a>
+object. <code>lstat()</code> is identical to <code>stat()</code>, except that if <code>path</code> is a symbolic
+link, then the link itself is stat-ed, not the file that it refers to.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a> documentation for more details.</p>
+<h4><code>fs.mkdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_mkdir_path_options_callback" id="fs_fs_mkdir_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.11.0, v12.17.0</td>
+<td><p>In <code>recursive</code> mode, the callback now receives the first created path as an argument.</p></td></tr>
+<tr><td>v10.12.0</td>
+<td><p>The second argument can now be an <code>options</code> object with <code>recursive</code> and <code>mode</code> properties.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.4.7</td>
-<td><p><span>Added in: v0.4.7</span></p></td></tr>
+<tr><td>v0.1.8</td>
+<td><p><span>Added in: v0.1.8</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
+<ul>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fchown.2.html"><code>fchown(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
-<h2><code>fs.fchownSync(fd, uid, gid)</code><span><a class="mark" href="#fs_fs_fchownsync_fd_uid_gid" id="fs_fs_fchownsync_fd_uid_gid">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.4.7</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fchown.2.html"><code>fchown(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.fdatasync(fd, callback)</code><span><a class="mark" href="#fs_fs_fdatasync_fd_callback" id="fs_fs_fdatasync_fd_callback">#</a></span></h2>
+<p>Asynchronously creates a directory.</p>
+<p>The callback is given a possible exception and, if <code>recursive</code> is <code>true</code>, the
+first directory path created, <code>(err, [path])</code>.
+<code>path</code> can still be <code>undefined</code> when <code>recursive</code> is <code>true</code>, if no directory was
+created.</p>
+<p>The optional <code>options</code> argument can be an integer specifying <code>mode</code> (permission
+and sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>
+property indicating whether parent directories should be created. Calling
+<code>fs.mkdir()</code> when <code>path</code> is a directory that exists results in an error only
+when <code>recursive</code> is false.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { mkdir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.</span>
+<span class="hljs-title function_">mkdir</span>(<span class="hljs-string">'/tmp/a/apple'</span>, { <span class="hljs-attr">recursive</span>: <span class="hljs-literal">true</span> }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+});</code></pre>
+<p>On Windows, using <code>fs.mkdir()</code> on the root directory even with recursion will
+result in an error:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { mkdir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">mkdir</span>(<span class="hljs-string">'/'</span>, { <span class="hljs-attr">recursive</span>: <span class="hljs-literal">true</span> }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-comment">// => [Error: EPERM: operation not permitted, mkdir 'C:\']</span>
+});</code></pre>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/mkdir.2.html"><code>mkdir(2)</code></a> documentation for more details.</p>
+<h4><code>fs.mkdtemp(prefix[, options], callback)</code><span><a class="mark" href="#fs_fs_mkdtemp_prefix_options_callback" id="fs_fs_mkdtemp_prefix_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>prefix</code> parameter now accepts an empty string.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.1.96</td>
-<td><p><span>Added in: v0.1.96</span></p></td></tr>
+<tr><td>v6.2.1</td>
+<td><p>The <code>callback</code> parameter is optional now.</p></td></tr>
+<tr><td>v5.10.0</td>
+<td><p><span>Added in: v5.10.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>directory</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a>. No arguments other than a possible exception are
-given to the completion callback.</p>
-<h2><code>fs.fdatasyncSync(fd)</code><span><a class="mark" href="#fs_fs_fdatasyncsync_fd" id="fs_fs_fdatasyncsync_fd">#</a></span></h2>
+<p>Creates a unique temporary directory.</p>
+<p>Generates six random characters to be appended behind a required
+<code>prefix</code> to create a unique temporary directory. Due to platform
+inconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,
+notably the BSDs, can return more than six random characters, and replace
+trailing <code>X</code> characters in <code>prefix</code> with random characters.</p>
+<p>The created directory path is passed as a string to the callback's second
+parameter.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { mkdtemp } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">mkdtemp</span>(path.<span class="hljs-title function_">join</span>(os.<span class="hljs-title function_">tmpdir</span>(), <span class="hljs-string">'foo-'</span>), <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(directory);
+  <span class="hljs-comment">// Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2</span>
+});</code></pre>
+<p>The <code>fs.mkdtemp()</code> method will append the six randomly selected characters
+directly to the <code>prefix</code> string. For instance, given a directory <code>/tmp</code>, if the
+intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the <code>prefix</code>
+must end with a trailing platform-specific path separator
+(<code>require('path').sep</code>).</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { tmpdir } <span class="hljs-keyword">from</span> <span class="hljs-string">'os'</span>;
+<span class="hljs-keyword">import</span> { mkdtemp } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// The parent directory for the new temporary directory</span>
+<span class="hljs-keyword">const</span> tmpDir = <span class="hljs-title function_">tmpdir</span>();
+
+<span class="hljs-comment">// This method is *INCORRECT*:</span>
+<span class="hljs-title function_">mkdtemp</span>(tmpDir, <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(directory);
+  <span class="hljs-comment">// Will print something similar to `/tmpabc123`.</span>
+  <span class="hljs-comment">// A new temporary directory is created at the file system root</span>
+  <span class="hljs-comment">// rather than *within* the /tmp directory.</span>
+});
+
+<span class="hljs-comment">// This method is *CORRECT*:</span>
+<span class="hljs-keyword">import</span> { sep } <span class="hljs-keyword">from</span> <span class="hljs-string">'path'</span>;
+<span class="hljs-title function_">mkdtemp</span>(<span class="hljs-string">`<span class="hljs-subst">${tmpDir}</span><span class="hljs-subst">${sep}</span>`</span>, <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(directory);
+  <span class="hljs-comment">// Will print something similar to `/tmp/abc123`.</span>
+  <span class="hljs-comment">// A new temporary directory is created within</span>
+  <span class="hljs-comment">// the /tmp directory.</span>
+});</code></pre>
+<h4><code>fs.open(path[, flags[, mode]], callback)</code><span><a class="mark" href="#fs_fs_open_path_flags_mode_callback" id="fs_fs_open_path_flags_mode_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.96</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v11.1.0</td>
+<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
+<tr><td>v9.9.0</td>
+<td><p>The <code>as</code> and <code>as+</code> flags are supported now.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.0.2</td>
+<td><p><span>Added in: v0.0.2</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.
+<strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code> (readable and writable)</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.fstat(fd[, options], callback)</code><span><a class="mark" href="#fs_fs_fstat_fd_options_callback" id="fs_fs_fstat_fd_options_callback">#</a></span></h2>
+</li>
+</ul>
+<p>Asynchronous file open. See the POSIX <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a> documentation for more details.</p>
+<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was
+created. On Windows, only the write permission can be manipulated; see
+<a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.</p>
+<p>The callback gets two arguments <code>(err, fd)</code>.</p>
+<p>Some characters (<code>&#x3C; > : " / \ | ? *</code>) are reserved under Windows as documented
+by <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains
+a colon, Node.js will open a file system stream, as described by
+<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams">this MSDN page</a>.</p>
+<p>Functions based on <code>fs.open()</code> exhibit this behavior as well:
+<code>fs.writeFile()</code>, <code>fs.readFile()</code>, etc.</p>
+<h4><code>fs.opendir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_opendir_path_options_callback" id="fs_fs_opendir_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.1.95</td>
-<td><p><span>Added in: v0.1.95</span></p></td></tr>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
+<tr><td>v12.12.0</td>
+<td><p><span>Added in: v12.12.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
+internally when reading from the directory. Higher values lead to better
+performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>stats</code> <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
+<li><code>dir</code> <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fstat.2.html"><code>fstat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where
-<code>stats</code> is an <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object. <code>fstat()</code> is identical to <a href="fs.html#fs_fs_stat_path_options_callback"><code>stat()</code></a>,
-except that the file to be stat-ed is specified by the file descriptor <code>fd</code>.</p>
-<h2><code>fs.fstatSync(fd[, options])</code><span><a class="mark" href="#fs_fs_fstatsync_fd_options" id="fs_fs_fstatsync_fd_options">#</a></span></h2>
+<p>Asynchronously open a directory. See the POSIX <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a> documentation for
+more details.</p>
+<p>Creates an <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>, which contains all further functions for reading from
+and cleaning up the directory.</p>
+<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
+directory and subsequent read operations.</p>
+<h4><code>fs.read(fd, buffer, offset, length, position, callback)</code><span><a class="mark" href="#fs_fs_read_fd_buffer_offset_length_position_callback" id="fs_fs_read_fd_buffer_offset_length_position_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v0.1.95</td>
-<td><p><span>Added in: v0.1.95</span></p></td></tr>
+<tr><td>v10.10.0</td>
+<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code>, or a <code>DataView</code>.</p></td></tr>
+<tr><td>v7.4.0</td>
+<td><p>The <code>buffer</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
+<tr><td>v6.0.0</td>
+<td><p>The <code>length</code> parameter can now be <code>0</code>.</p></td></tr>
+<tr><td>v0.0.2</td>
+<td><p><span>Added in: v0.0.2</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> The buffer that the data will be
+written to. <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The position in <code>buffer</code> to write the data to. <strong>Default:</strong>
+<code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of bytes to read. <strong>Default:</strong>
+<code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> Specifies where to begin reading from in the
+file. If <code>position</code> is <code>null</code> or <code>-1 </code>, data will be read from the current
+file position, and the file position will be updated. If <code>position</code> is an
+integer, the file position will be unchanged.</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 </li>
-<li>Returns: <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fstat.2.html"><code>fstat(2)</code></a>.</p>
-<h2><code>fs.fsync(fd, callback)</code><span><a class="mark" href="#fs_fs_fsync_fd_callback" id="fs_fs_fsync_fd_callback">#</a></span></h2>
+<p>Read data from the file specified by <code>fd</code>.</p>
+<p>The callback is given the three arguments, <code>(err, bytesRead, buffer)</code>.</p>
+<p>If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.</p>
+<p>If this method is invoked as its <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
+a promise for an <code>Object</code> with <code>bytesRead</code> and <code>buffer</code> properties.</p>
+<h4><code>fs.read(fd, [options,] callback)</code><span><a class="mark" href="#fs_fs_read_fd_options_callback" id="fs_fs_read_fd_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.1.96</td>
-<td><p><span>Added in: v0.1.96</span></p></td></tr>
+<tr><td>v13.11.0, v12.17.0</td>
+<td><p><span>Added in: v13.11.0, v12.17.0</span></p></td></tr>
+<tr><td>v13.11.0, v12.17.0</td>
+<td><p>Options object can be passed in to make Buffer, offset, length and position optional.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> <strong>Default:</strong> <code>null</code></li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
-<h2><code>fs.fsyncSync(fd)</code><span><a class="mark" href="#fs_fs_fsyncsync_fd" id="fs_fs_fsyncsync_fd">#</a></span></h2>
+<p>Similar to the <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a> function, this version takes an optional
+<code>options</code> object. If no <code>options</code> object is specified, it will default with the
+above values.</p>
+<h4><code>fs.readdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readdir_path_options_callback" id="fs_fs_readdir_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.96</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v10.10.0</td>
+<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v6.0.0</td>
+<td><p>The <code>options</code> parameter was added.</p></td></tr>
+<tr><td>v0.1.8</td>
+<td><p><span>Added in: v0.1.8</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+</ul>
+</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>files</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent[]></a></li>
+</ul>
+</li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.ftruncate(fd[, len], callback)</code><span><a class="mark" href="#fs_fs_ftruncate_fd_len_callback" id="fs_fs_ftruncate_fd_len_callback">#</a></span></h2>
+<p>Reads the contents of a directory. The callback gets two arguments <code>(err, files)</code>
+where <code>files</code> is an array of the names of the files in the directory excluding
+<code>'.'</code> and <code>'..'</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> documentation for more details.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the filenames passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the filenames returned will be passed as <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> objects.</p>
+<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the <code>files</code> array will contain
+<a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> objects.</p>
+<h4><code>fs.readFile(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readfile_path_options_callback" id="fs_fs_readfile_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>The options argument may include an AbortSignal to abort an ongoing readFile request.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.8.6</td>
-<td><p><span>Added in: v0.8.6</span></p></td></tr>
+<tr><td>v5.1.0</td>
+<td><p>The <code>callback</code> will always be called with <code>null</code> as the <code>error</code> parameter in case of success.</p></td></tr>
+<tr><td>v5.0.0</td>
+<td><p>The <code>path</code> parameter can be a file descriptor now.</p></td></tr>
+<tr><td>v0.1.29</td>
+<td><p><span>Added in: v0.1.29</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress readFile</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/ftruncate.2.html"><code>ftruncate(2)</code></a>. No arguments other than a possible exception are
-given to the completion callback.</p>
-<p>If the file referred to by the file descriptor was larger than <code>len</code> bytes, only
-the first <code>len</code> bytes will be retained in the file.</p>
-<p>For example, the following program retains only the first four bytes of the
-file:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-<span class="hljs-comment">// Prints: Node.js</span>
+<p>Asynchronously reads the entire contents of a file.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
+});</code></pre>
+<p>The callback is passed two arguments <code>(err, data)</code>, where <code>data</code> is the
+contents of the file.</p>
+<p>If no encoding is specified, then the raw buffer is returned.</p>
+<p>If <code>options</code> is a string, then it specifies the encoding:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">// get the file descriptor of the file to be truncated</span>
-<span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
+<p>When the path is a directory, the behavior of <code>fs.readFile()</code> and
+<a href="#fs_fs_readfilesync_path_options"><code>fs.readFileSync()</code></a> is platform-specific. On macOS, Linux, and Windows, an
+error will be returned. On FreeBSD, a representation of the directory's contents
+will be returned.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">// Truncate the file to first four bytes</span>
-fs.ftruncate(fd, <span class="hljs-number">4</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  assert.ifError(err);
-  <span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
+<span class="hljs-comment">// macOS, Linux, and Windows</span>
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+  <span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]</span>
 });
-<span class="hljs-comment">// Prints: Node</span></code></pre>
-<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the
-extended part is filled with null bytes (<code>'\0'</code>):</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-<span class="hljs-comment">// Prints: Node.js</span>
 
-<span class="hljs-comment">// get the file descriptor of the file to be truncated</span>
-<span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
+<span class="hljs-comment">//  FreeBSD</span>
+<span class="hljs-title function_">readFile</span>(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+  <span class="hljs-comment">// => null, &#x3C;data></span>
+});</code></pre>
+<p>It is possible to abort an ongoing request using an <code>AbortSignal</code>. If a
+request is aborted the callback is called with an <code>AbortError</code>:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">// Truncate the file to 10 bytes, whereas the actual size is 7 bytes</span>
-fs.ftruncate(fd, <span class="hljs-number">10</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  assert.ifError(err);
-  <span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>));
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> signal = controller.<span class="hljs-property">signal</span>;
+<span class="hljs-title function_">readFile</span>(fileInfo[<span class="hljs-number">0</span>].<span class="hljs-property">name</span>, { signal }, <span class="hljs-function">(<span class="hljs-params">err, buf</span>) =></span> {
+  <span class="hljs-comment">// ...</span>
 });
-<span class="hljs-comment">// Prints: &#x3C;Buffer 4e 6f 64 65 2e 6a 73 00 00 00></span>
-<span class="hljs-comment">// ('Node.js\0\0\0' in UTF8)</span></code></pre>
-<p>The last three bytes are null bytes (<code>'\0'</code>), to compensate the over-truncation.</p>
-<h2><code>fs.ftruncateSync(fd[, len])</code><span><a class="mark" href="#fs_fs_ftruncatesync_fd_len" id="fs_fs_ftruncatesync_fd_len">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.8.6</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-</ul>
-<p>Returns <code>undefined</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate()</code></a>.</p>
-<h2><code>fs.futimes(fd, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_futimes_fd_atime_mtime_callback" id="fs_fs_futimes_fd_atime_mtime_callback">#</a></span></h2>
+<span class="hljs-comment">// When you want to abort the request</span>
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<p>The <code>fs.readFile()</code> function buffers the entire file. To minimize memory costs,
+when possible prefer streaming via <code>fs.createReadStream()</code>.</p>
+<p>Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering <code>fs.readFile</code> performs.</p>
+<h5>File descriptors<span><a class="mark" href="#fs_file_descriptors" id="fs_file_descriptors">#</a></span></h5>
+<ol>
+<li>Any specified file descriptor has to support reading.</li>
+<li>If a file descriptor is specified as the <code>path</code>, it will not be closed
+automatically.</li>
+<li>The reading will begin at the current position. For example, if the file
+already had <code>'Hello World</code>' and six bytes are read with the file descriptor,
+the call to <code>fs.readFile()</code> with the same file descriptor, would give
+<code>'World'</code>, rather than <code>'Hello World'</code>.</li>
+</ol>
+<h5>Performance Considerations<span><a class="mark" href="#fs_performance_considerations" id="fs_performance_considerations">#</a></span></h5>
+<p>The <code>fs.readFile()</code> method asynchronously reads the contents of a file into
+memory one chunk at a time, allowing the event loop to turn between each chunk.
+This allows the read operation to have less impact on other activity that may
+be using the underlying libuv thread pool but means that it will take longer
+to read a complete file into memory.</p>
+<p>The additional read overhead can vary broadly on different systems and depends
+on the type of file being read. If the file type is not a regular file (a pipe
+for instance) and Node.js is unable to determine an actual file size, each read
+operation will load on 64kb of data. For regular files, each read will process
+512kb of data.</p>
+<p>For applications that require as-fast-as-possible reading of file contents, it
+is better to use <code>fs.read()</code> directly and for application code to manage
+reading the full contents of the file itself.</p>
+<p>The Node.js GitHub issue <a href="https://github.com/nodejs/node/issues/25741">#25741</a> provides more information and a detailed
+analysis on the performance of <code>fs.readFile()</code> for multiple file sizes in
+different Node.js versions.</p>
+<h4><code>fs.readlink(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readlink_path_options_callback" id="fs_fs_readlink_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v4.1.0</td>
-<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
-<tr><td>v0.4.2</td>
-<td><p><span>Added in: v0.4.2</span></p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>linkString</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 </li>
 </ul>
-<p>Change the file system timestamps of the object referenced by the supplied file
-descriptor. See <a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>.</p>
-<p>This function does not work on AIX versions before 7.1, it will return the
-error <code>UV_ENOSYS</code>.</p>
-<h2><code>fs.futimesSync(fd, atime, mtime)</code><span><a class="mark" href="#fs_fs_futimessync_fd_atime_mtime" id="fs_fs_futimessync_fd_atime_mtime">#</a></span></h2>
+<p>Reads the contents of the symbolic link referred to by <code>path</code>. The callback gets
+two arguments <code>(err, linkString)</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a> documentation for more details.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the link path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the link path returned will be passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<h4><code>fs.readv(fd, buffers[, position], callback)</code><span><a class="mark" href="#fs_fs_readv_fd_buffers_position_callback" id="fs_fs_readv_fd_buffers_position_callback">#</a></span></h4>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v4.1.0</td>
-<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
-<tr><td>v0.4.2</td>
-<td><p><span>Added in: v0.4.2</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v13.13.0, v12.17.0</span>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
 </ul>
-<p>Synchronous version of <a href="#fs_fs_futimes_fd_atime_mtime_callback"><code>fs.futimes()</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.lchmod(path, mode, callback)</code><span><a class="mark" href="#fs_fs_lchmod_path_mode_callback" id="fs_fs_lchmod_path_mode_callback">#</a></span></h2>
+</li>
+</ul>
+<p>Read from a file specified by <code>fd</code> and write to an array of <code>ArrayBufferView</code>s
+using <code>readv()</code>.</p>
+<p><code>position</code> is the offset from the beginning of the file from where data
+should be read. If <code>typeof position !== 'number'</code>, the data will be read
+from the current position.</p>
+<p>The callback will be given three arguments: <code>err</code>, <code>bytesRead</code>, and
+<code>buffers</code>. <code>bytesRead</code> is how many bytes were read from the file.</p>
+<p>If this method is invoked as its <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
+a promise for an <code>Object</code> with <code>bytesRead</code> and <code>buffers</code> properties.</p>
+<h4><code>fs.realpath(path[, options], callback)</code><span><a class="mark" href="#fs_fs_realpath_path_options_callback" id="fs_fs_realpath_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v8.0.0</td>
+<td><p>Pipe/Socket resolve support was added.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.4.7</td>
-<td><p><span>Deprecated since: v0.4.7</span></p></td></tr>
+<tr><td>v6.4.0</td>
+<td><p>Calling <code>realpath</code> now works again for various edge cases on Windows.</p></td></tr>
+<tr><td>v6.0.0</td>
+<td><p>The <code>cache</code> parameter was removed.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>resolvedPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="https://www.freebsd.org/cgi/man.cgi?query=lchmod&#x26;sektion=2"><code>lchmod(2)</code></a>. No arguments other than a possible exception
-are given to the completion callback.</p>
-<p>Only available on macOS.</p>
-<h2><code>fs.lchmodSync(path, mode)</code><span><a class="mark" href="#fs_fs_lchmodsync_path_mode" id="fs_fs_lchmodsync_path_mode">#</a></span></h2>
+<p>Asynchronously computes the canonical pathname by resolving <code>.</code>, <code>..</code> and
+symbolic links.</p>
+<p>A canonical pathname is not necessarily unique. Hard links and bind mounts can
+expose a file system entity through many pathnames.</p>
+<p>This function behaves like <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a>, with some exceptions:</p>
+<ol>
+<li>
+<p>No case conversion is performed on case-insensitive file systems.</p>
+</li>
+<li>
+<p>The maximum number of symbolic links is platform-independent and generally
+(much) higher than what the native <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a> implementation supports.</p>
+</li>
+</ol>
+<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>. May use <code>process.cwd</code>
+to resolve relative paths.</p>
+<p>Only paths that can be converted to UTF8 strings are supported.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the path returned will be passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<p>If <code>path</code> resolves to a socket or a pipe, the function will return a system
+dependent name for that object.</p>
+<h4><code>fs.realpath.native(path[, options], callback)</code><span><a class="mark" href="#fs_fs_realpath_native_path_options_callback" id="fs_fs_realpath_native_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Deprecated since: v0.4.7</span>
+<span>Added in: v9.2.0</span>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="https://www.freebsd.org/cgi/man.cgi?query=lchmod&#x26;sektion=2"><code>lchmod(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.lchown(path, uid, gid, callback)</code><span><a class="mark" href="#fs_fs_lchown_path_uid_gid_callback" id="fs_fs_lchown_path_uid_gid_callback">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.6.0</td>
-<td><p>This API is no longer deprecated.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.4.7</td>
-<td><p>Documentation-only deprecation.</p></td></tr>
-</tbody></table>
-</details>
-</div>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>resolvedPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/lchown.2.html"><code>lchown(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
-<h2><code>fs.lchownSync(path, uid, gid)</code><span><a class="mark" href="#fs_fs_lchownsync_path_uid_gid" id="fs_fs_lchownsync_path_uid_gid">#</a></span></h2>
+<p>Asynchronous <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a>.</p>
+<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>.</p>
+<p>Only paths that can be converted to UTF8 strings are supported.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the path returned will be passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
+be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
+this restriction.</p>
+<h4><code>fs.rename(oldPath, newPath, callback)</code><span><a class="mark" href="#fs_fs_rename_oldpath_newpath_callback" id="fs_fs_rename_oldpath_newpath_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.6.0</td>
-<td><p>This API is no longer deprecated.</p></td></tr>
-<tr><td>v0.4.7</td>
-<td><p>Documentation-only deprecation.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>oldPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v0.0.2</td>
+<td><p><span>Added in: v0.0.2</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/lchown.2.html"><code>lchown(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.lutimes(path, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_lutimes_path_atime_mtime_callback" id="fs_fs_lutimes_path_atime_mtime_callback">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.19.0</span>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
 </ul>
-<p>Changes the access and modification times of a file in the same way as
-<a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>, with the difference that if the path refers to a symbolic
-link, then the link is not dereferenced: instead, the timestamps of the
-symbolic link itself are changed.</p>
-<p>No arguments other than a possible exception are given to the completion
-callback.</p>
-<h2><code>fs.lutimesSync(path, atime, mtime)</code><span><a class="mark" href="#fs_fs_lutimessync_path_atime_mtime" id="fs_fs_lutimessync_path_atime_mtime">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.19.0</span>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-</ul>
-<p>Change the file system timestamps of the symbolic link referenced by <code>path</code>.
-Returns <code>undefined</code>, or throws an exception when parameters are incorrect or
-the operation fails. This is the synchronous version of <a href="#fs_fs_lutimes_path_atime_mtime_callback"><code>fs.lutimes()</code></a>.</p>
-<h2><code>fs.link(existingPath, newPath, callback)</code><span><a class="mark" href="#fs_fs_link_existingpath_newpath_callback" id="fs_fs_link_existingpath_newpath_callback">#</a></span></h2>
+<p>Asynchronously rename file at <code>oldPath</code> to the pathname provided
+as <code>newPath</code>. In the case that <code>newPath</code> already exists, it will
+be overwritten. If there is a directory at <code>newPath</code>, an error will
+be raised instead. No arguments other than a possible exception are
+given to the completion callback.</p>
+<p>See also: <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { rename } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">rename</span>(<span class="hljs-string">'oldFile.txt'</span>, <span class="hljs-string">'newFile.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Rename complete!'</span>);
+});</code></pre>
+<h4><code>fs.rmdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_rmdir_path_options_callback" id="fs_fs_rmdir_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.14.0</td>
+<td><p>The <code>recursive</code> option is deprecated, use <code>fs.rm</code> instead.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
+<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
+<tr><td>v12.10.0</td>
+<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>existingPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameters can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<tr><td>v0.0.2</td>
+<td><p><span>Added in: v0.0.2</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js retries the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode, errors are not reported if <code>path</code> does not exist, and
+operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>. No arguments other than a possible exception are given to
-the completion callback.</p>
-<h2><code>fs.linkSync(existingPath, newPath)</code><span><a class="mark" href="#fs_fs_linksync_existingpath_newpath" id="fs_fs_linksync_existingpath_newpath">#</a></span></h2>
+<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/rmdir.2.html"><code>rmdir(2)</code></a>. No arguments other than a possible exception are given
+to the completion callback.</p>
+<p>Using <code>fs.rmdir()</code> on a file (not a directory) results in an <code>ENOENT</code> error on
+Windows and an <code>ENOTDIR</code> error on POSIX.</p>
+<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command
+<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in
+the future.</p>
+<h4><code>fs.rm(path[, options], callback)</code><span><a class="mark" href="#fs_fs_rm_path_options_callback" id="fs_fs_rm_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>existingPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v14.14.0</span>
 </div>
 <ul>
-<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>force</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, exceptions will be ignored if <code>path</code> does
+not exist. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive removal. In
+recursive mode operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
+</ul>
+</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+</ul>
+</li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.lstat(path[, options], callback)</code><span><a class="mark" href="#fs_fs_lstat_path_options_callback" id="fs_fs_lstat_path_options_callback">#</a></span></h2>
+<p>Asynchronously removes files and directories (modeled on the standard POSIX <code>rm</code>
+utility). No arguments other than a possible exception are given to the
+completion callback.</p>
+<h4><code>fs.stat(path[, options], callback)</code><span><a class="mark" href="#fs_fs_stat_path_options_callback" id="fs_fs_stat_path_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2725,11 +3560,11 @@ the completion callback.</p>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.1.30</td>
-<td><p><span>Added in: v0.1.30</span></p></td></tr>
+<tr><td>v0.0.2</td>
+<td><p><span>Added in: v0.0.2</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -2738,7 +3573,7 @@ the completion callback.</p>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
@@ -2748,345 +3583,441 @@ the completion callback.</p>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where
-<code>stats</code> is a <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object. <code>lstat()</code> is identical to <code>stat()</code>,
-except that if <code>path</code> is a symbolic link, then the link itself is stat-ed,
-not the file that it refers to.</p>
-<h2><code>fs.lstatSync(path[, options])</code><span><a class="mark" href="#fs_fs_lstatsync_path_options" id="fs_fs_lstatsync_path_options">#</a></span></h2>
+<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/stat.2.html"><code>stat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where
+<code>stats</code> is an <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object.</p>
+<p>In case of an error, the <code>err.code</code> will be one of <a href="errors.html#errors_common_system_errors">Common System Errors</a>.</p>
+<p>Using <code>fs.stat()</code> to check for the existence of a file before calling
+<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended.
+Instead, user code should open/read/write the file directly and handle the
+error raised if the file is not available.</p>
+<p>To check if a file exists without manipulating it afterwards, <a href="#fs_fs_access_path_mode_callback"><code>fs.access()</code></a>
+is recommended.</p>
+<p>For example, given the following directory structure:</p>
+<pre><code class="language-text">- txtDir
+-- file.txt
+- app.js</code></pre>
+<p>The next program will check for the stats of the given paths:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { stat } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">const</span> pathsToCheck = [<span class="hljs-string">'./txtDir'</span>, <span class="hljs-string">'./txtDir/file.txt'</span>];
+
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; pathsToCheck.<span class="hljs-property">length</span>; i++) {
+  <span class="hljs-title function_">stat</span>(pathsToCheck[i], <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stats.<span class="hljs-title function_">isDirectory</span>());
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stats);
+  });
+}</code></pre>
+<p>The resulting output will resemble:</p>
+<pre><code class="language-console">true
+Stats {
+  dev: 16777220,
+  mode: 16877,
+  nlink: 3,
+  uid: 501,
+  gid: 20,
+  rdev: 0,
+  blksize: 4096,
+  ino: 14214262,
+  size: 96,
+  blocks: 0,
+  atimeMs: 1561174653071.963,
+  mtimeMs: 1561174614583.3518,
+  ctimeMs: 1561174626623.5366,
+  birthtimeMs: 1561174126937.2893,
+  atime: 2019-06-22T03:37:33.072Z,
+  mtime: 2019-06-22T03:36:54.583Z,
+  ctime: 2019-06-22T03:37:06.624Z,
+  birthtime: 2019-06-22T03:28:46.937Z
+}
+false
+Stats {
+  dev: 16777220,
+  mode: 33188,
+  nlink: 1,
+  uid: 501,
+  gid: 20,
+  rdev: 0,
+  blksize: 4096,
+  ino: 14214074,
+  size: 8,
+  blocks: 8,
+  atimeMs: 1561174616618.8555,
+  mtimeMs: 1561174614584,
+  ctimeMs: 1561174614583.8145,
+  birthtimeMs: 1561174007710.7478,
+  atime: 2019-06-22T03:36:56.619Z,
+  mtime: 2019-06-22T03:36:54.584Z,
+  ctime: 2019-06-22T03:36:54.584Z,
+  birthtime: 2019-06-22T03:26:47.711Z
+}</code></pre>
+<h4><code>fs.symlink(target, path[, type], callback)</code><span><a class="mark" href="#fs_fs_symlink_target_path_type_callback" id="fs_fs_symlink_target_path_type_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v12.0.0</td>
+<td><p>If the <code>type</code> argument is left undefined, Node will autodetect <code>target</code> type and automatically select <code>dir</code> or <code>file</code>.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.30</td>
-<td><p><span>Added in: v0.1.30</span></p></td></tr>
+<td><p>The <code>target</code> and <code>path</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
+<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
-<li>Returns: <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a>.</p>
-<h2><code>fs.mkdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_mkdir_path_options_callback" id="fs_fs_mkdir_path_options_callback">#</a></span></h2>
+<p>Creates the link called <code>path</code> pointing to <code>target</code>. No arguments other than a
+possible exception are given to the completion callback.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/symlink.2.html"><code>symlink(2)</code></a> documentation for more details.</p>
+<p>The <code>type</code> argument is only available on Windows and ignored on other platforms.
+It can be set to <code>'dir'</code>, <code>'file'</code>, or <code>'junction'</code>. If the <code>type</code> argument is
+not set, Node.js will autodetect <code>target</code> type and use <code>'file'</code> or <code>'dir'</code>. If
+the <code>target</code> does not exist, <code>'file'</code> will be used. Windows junction points
+require the destination path to be absolute. When using <code>'junction'</code>, the
+<code>target</code> argument will automatically be normalized to absolute path.</p>
+<p>Relative targets are relative to the link’s parent directory.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { symlink } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">symlink</span>(<span class="hljs-string">'./mew'</span>, <span class="hljs-string">'./example/mewtwo'</span>, callback);</code></pre>
+<p>The above example creates a symbolic link <code>mewtwo</code> in the <code>example</code> which points
+to <code>mew</code> in the same directory:</p>
+<pre><code class="language-bash">$ tree example/
+example/
+├── mew
+└── mewtwo -> ./mew</code></pre>
+<h4><code>fs.truncate(path[, len], callback)</code><span><a class="mark" href="#fs_fs_truncate_path_len_callback" id="fs_fs_truncate_path_len_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>In <code>recursive</code> mode, the callback now receives the first created path as an argument.</p></td></tr>
-<tr><td>v10.12.0</td>
-<td><p>The second argument can now be an <code>options</code> object with <code>recursive</code> and <code>mode</code> properties.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.1.8</td>
-<td><p><span>Added in: v0.1.8</span></p></td></tr>
+<tr><td>v0.8.6</td>
+<td><p><span>Added in: v0.8.6</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
-<ul>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
-</ul>
-</li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronously creates a directory.</p>
-<p>The callback is given a possible exception and, if <code>recursive</code> is <code>true</code>, the
-first directory path created, <code>(err, [path])</code>.</p>
-<p>The optional <code>options</code> argument can be an integer specifying mode (permission
-and sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>
-property indicating whether parent directories should be created. Calling
-<code>fs.mkdir()</code> when <code>path</code> is a directory that exists results in an error only
-when <code>recursive</code> is false.</p>
-<pre><code class="language-js"><span class="hljs-comment">// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.</span>
-fs.mkdir(<span class="hljs-string">'/tmp/a/apple'</span>, { <span class="hljs-attr">recursive</span>: <span class="hljs-literal">true</span> }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<p>Truncates the file. No arguments other than a possible exception are
+given to the completion callback. A file descriptor can also be passed as the
+first argument. In this case, <code>fs.ftruncate()</code> is called.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { truncate } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// Assuming that 'path/file.txt' is a regular file.</span>
+<span class="hljs-title function_">truncate</span>(<span class="hljs-string">'path/file.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'path/file.txt was truncated'</span>);
+});</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { truncate } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<span class="hljs-comment">// Assuming that 'path/file.txt' is a regular file.</span>
+<span class="hljs-title function_">truncate</span>(<span class="hljs-string">'path/file.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'path/file.txt was truncated'</span>);
 });</code></pre>
-<p>On Windows, using <code>fs.mkdir()</code> on the root directory even with recursion will
-result in an error:</p>
-<pre><code class="language-js">fs.mkdir(<span class="hljs-string">'/'</span>, { <span class="hljs-attr">recursive</span>: <span class="hljs-literal">true</span> }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-comment">// => [Error: EPERM: operation not permitted, mkdir 'C:\']</span>
-});</code></pre>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/mkdir.2.html"><code>mkdir(2)</code></a>.</p>
-<h2><code>fs.mkdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_mkdirsync_path_options" id="fs_fs_mkdirsync_path_options">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>In <code>recursive</code> mode, the first created path is returned now.</p></td></tr>
-<tr><td>v10.12.0</td>
-<td><p>The second argument can now be an <code>options</code> object with <code>recursive</code> and <code>mode</code> properties.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
-<ul>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
-</ul>
-<p>Synchronously creates a directory. Returns <code>undefined</code>, or if <code>recursive</code> is
-<code>true</code>, the first directory path created.
-This is the synchronous version of <a href="#fs_fs_mkdir_path_options_callback"><code>fs.mkdir()</code></a>.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/mkdir.2.html"><code>mkdir(2)</code></a>.</p>
-<h2><code>fs.mkdtemp(prefix[, options], callback)</code><span><a class="mark" href="#fs_fs_mkdtemp_prefix_options_callback" id="fs_fs_mkdtemp_prefix_options_callback">#</a></span></h2>
+<p>Passing a file descriptor is deprecated and may result in an error being thrown
+in the future.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/truncate.2.html"><code>truncate(2)</code></a> documentation for more details.</p>
+<h4><code>fs.unlink(path, callback)</code><span><a class="mark" href="#fs_fs_unlink_path_callback" id="fs_fs_unlink_path_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v6.2.1</td>
-<td><p>The <code>callback</code> parameter is optional now.</p></td></tr>
-<tr><td>v5.10.0</td>
-<td><p><span>Added in: v5.10.0</span></p></td></tr>
+<tr><td>v0.0.2</td>
+<td><p><span>Added in: v0.0.2</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>directory</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 </li>
 </ul>
-<p>Creates a unique temporary directory.</p>
-<p>Generates six random characters to be appended behind a required
-<code>prefix</code> to create a unique temporary directory. Due to platform
-inconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,
-notably the BSDs, can return more than six random characters, and replace
-trailing <code>X</code> characters in <code>prefix</code> with random characters.</p>
-<p>The created directory path is passed as a string to the callback's second
-parameter.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use.</p>
-<pre><code class="language-js">fs.mkdtemp(path.join(os.tmpdir(), <span class="hljs-string">'foo-'</span>), <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(directory);
-  <span class="hljs-comment">// Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2</span>
-});</code></pre>
-<p>The <code>fs.mkdtemp()</code> method will append the six randomly selected characters
-directly to the <code>prefix</code> string. For instance, given a directory <code>/tmp</code>, if the
-intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the <code>prefix</code>
-must end with a trailing platform-specific path separator
-(<code>require('path').sep</code>).</p>
-<pre><code class="language-js"><span class="hljs-comment">// The parent directory for the new temporary directory</span>
-<span class="hljs-keyword">const</span> tmpDir = os.tmpdir();
-
-<span class="hljs-comment">// This method is *INCORRECT*:</span>
-fs.mkdtemp(tmpDir, <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(directory);
-  <span class="hljs-comment">// Will print something similar to `/tmpabc123`.</span>
-  <span class="hljs-comment">// A new temporary directory is created at the file system root</span>
-  <span class="hljs-comment">// rather than *within* the /tmp directory.</span>
-});
-
-<span class="hljs-comment">// This method is *CORRECT*:</span>
-<span class="hljs-keyword">const</span> { sep } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);
-fs.mkdtemp(<span class="hljs-string">`<span class="hljs-subst">${tmpDir}</span><span class="hljs-subst">${sep}</span>`</span>, <span class="hljs-function">(<span class="hljs-params">err, directory</span>) =></span> {
+<p>Asynchronously removes a file or symbolic link. No arguments other than a
+possible exception are given to the completion callback.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { unlink } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// Assuming that 'path/file.txt' is a regular file.</span>
+<span class="hljs-title function_">unlink</span>(<span class="hljs-string">'path/file.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(directory);
-  <span class="hljs-comment">// Will print something similar to `/tmp/abc123`.</span>
-  <span class="hljs-comment">// A new temporary directory is created within</span>
-  <span class="hljs-comment">// the /tmp directory.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'path/file.txt was deleted'</span>);
 });</code></pre>
-<h2><code>fs.mkdtempSync(prefix[, options])</code><span><a class="mark" href="#fs_fs_mkdtempsync_prefix_options" id="fs_fs_mkdtempsync_prefix_options">#</a></span></h2>
+<p><code>fs.unlink()</code> will not work on a directory, empty or otherwise. To remove a
+directory, use <a href="#fs_fs_rmdir_path_options_callback"><code>fs.rmdir()</code></a>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a> documentation for more details.</p>
+<h4><code>fs.unwatchFile(filename[, listener])</code><span><a class="mark" href="#fs_fs_unwatchfile_filename_listener" id="fs_fs_unwatchfile_filename_listener">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v5.10.0</span>
+<span>Added in: v0.1.31</span>
 </div>
 <ul>
-<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional, a listener previously attached using
+<code>fs.watchFile()</code></li>
 </ul>
-<p>Returns the created directory path.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_mkdtemp_prefix_options_callback"><code>fs.mkdtemp()</code></a>.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use.</p>
-<h2><code>fs.open(path[, flags[, mode]], callback)</code><span><a class="mark" href="#fs_fs_open_path_flags_mode_callback" id="fs_fs_open_path_flags_mode_callback">#</a></span></h2>
+<p>Stop watching for changes on <code>filename</code>. If <code>listener</code> is specified, only that
+particular listener is removed. Otherwise, <em>all</em> listeners are removed,
+effectively stopping watching of <code>filename</code>.</p>
+<p>Calling <code>fs.unwatchFile()</code> with a filename that is not being watched is a
+no-op, not an error.</p>
+<p>Using <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile()</code> and
+<code>fs.unwatchFile()</code>. <code>fs.watch()</code> should be used instead of <code>fs.watchFile()</code>
+and <code>fs.unwatchFile()</code> when possible.</p>
+<h4><code>fs.utimes(path, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_utimes_path_atime_mtime_callback" id="fs_fs_utimes_path_atime_mtime_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.1.0</td>
-<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
-<tr><td>v9.9.0</td>
-<td><p>The <code>as</code> and <code>as+</code> modes are supported now.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v8.0.0</td>
+<td><p><code>NaN</code>, <code>Infinity</code>, and <code>-Infinity</code> are no longer valid time specifiers.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.0.2</td>
-<td><p><span>Added in: v0.0.2</span></p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
+<tr><td>v4.1.0</td>
+<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
+<tr><td>v0.4.2</td>
+<td><p><span>Added in: v0.4.2</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.
-<strong>Default:</strong> <code>'r'</code>.</li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code> (readable and writable)</li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous file open. See <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a>.</p>
-<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was
-created. On Windows, only the write permission can be manipulated; see
-<a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.</p>
-<p>The callback gets two arguments <code>(err, fd)</code>.</p>
-<p>Some characters (<code>&#x3C; > : " / \ | ? *</code>) are reserved under Windows as documented
-by <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains
-a colon, Node.js will open a file system stream, as described by
-<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams">this MSDN page</a>.</p>
-<p>Functions based on <code>fs.open()</code> exhibit this behavior as well:
-<code>fs.writeFile()</code>, <code>fs.readFile()</code>, etc.</p>
-<h2><code>fs.opendir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_opendir_path_options_callback" id="fs_fs_opendir_path_options_callback">#</a></span></h2>
+<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>
+<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>
+<ul>
+<li>Values can be either numbers representing Unix epoch time in seconds,
+<code>Date</code>s, or a numeric string like <code>'123456789.0'</code>.</li>
+<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or
+<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>
+</ul>
+<h4><code>fs.watch(filename[, options][, listener])</code><span><a class="mark" href="#fs_fs_watch_filename_options_listener" id="fs_fs_watch_filename_options_listener">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
-<tr><td>v12.12.0</td>
-<td><p><span>Added in: v12.12.0</span></p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>Added support for closing the watcher with an AbortSignal.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
+<tr><td>v0.5.10</td>
+<td><p><span>Added in: v0.5.10</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
-internally when reading from the directory. Higher values lead to better
-performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
+<li><code>persistent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether the process should continue to run
+as long as files are being watched. <strong>Default:</strong> <code>true</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether all subdirectories should be
+watched, or only the current directory. This applies when a directory is
+specified, and only on supported platforms (See <a href="#fs_caveats">caveats</a>). <strong>Default:</strong>
+<code>false</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Specifies the character encoding to be used for the
+filename passed to the listener. <strong>Default:</strong> <code>'utf8'</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows closing the watcher with an AbortSignal.</li>
 </ul>
 </li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a> <strong>Default:</strong> <code>undefined</code>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>dir</code> <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a></li>
+<li><code>eventType</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 </li>
+<li>Returns: <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
 </ul>
-<p>Asynchronously open a directory. See <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a>.</p>
-<p>Creates an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a>, which contains all further functions for reading from
-and cleaning up the directory.</p>
-<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
-directory and subsequent read operations.</p>
-<h2><code>fs.opendirSync(path[, options])</code><span><a class="mark" href="#fs_fs_opendirsync_path_options" id="fs_fs_opendirsync_path_options">#</a></span></h2>
+<p>Watch for changes on <code>filename</code>, where <code>filename</code> is either a file or a
+directory.</p>
+<p>The second argument is optional. If <code>options</code> is provided as a string, it
+specifies the <code>encoding</code>. Otherwise <code>options</code> should be passed as an object.</p>
+<p>The listener callback gets two arguments <code>(eventType, filename)</code>. <code>eventType</code>
+is either <code>'rename'</code> or <code>'change'</code>, and <code>filename</code> is the name of the file
+which triggered the event.</p>
+<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or
+disappears in the directory.</p>
+<p>The listener callback is attached to the <code>'change'</code> event fired by
+<a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a>, but it is not the same thing as the <code>'change'</code> value of
+<code>eventType</code>.</p>
+<p>If a <code>signal</code> is passed, aborting the corresponding AbortController will close
+the returned <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a>.</p>
+<h5>Caveats<span><a class="mark" href="#fs_caveats" id="fs_caveats">#</a></span></h5>
+
+<p>The <code>fs.watch</code> API is not 100% consistent across platforms, and is
+unavailable in some situations.</p>
+<p>The recursive option is only supported on macOS and Windows.
+An <code>ERR_FEATURE_UNAVAILABLE_ON_PLATFORM</code> exception will be thrown
+when the option is used on a platform that does not support it.</p>
+<p>On Windows, no events will be emitted if the watched directory is moved or
+renamed. An <code>EPERM</code> error is reported when the watched directory is deleted.</p>
+<h6>Availability<span><a class="mark" href="#fs_availability" id="fs_availability">#</a></span></h6>
+
+<p>This feature depends on the underlying operating system providing a way
+to be notified of filesystem changes.</p>
+<ul>
+<li>On Linux systems, this uses <a href="https://man7.org/linux/man-pages/man7/inotify.7.html"><code>inotify(7)</code></a>.</li>
+<li>On BSD systems, this uses <a href="https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2"><code>kqueue(2)</code></a>.</li>
+<li>On macOS, this uses <a href="https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2"><code>kqueue(2)</code></a> for files and <a href="https://developer.apple.com/documentation/coreservices/file_system_events"><code>FSEvents</code></a> for
+directories.</li>
+<li>On SunOS systems (including Solaris and SmartOS), this uses <a href="https://illumos.org/man/port_create"><code>event ports</code></a>.</li>
+<li>On Windows systems, this feature depends on <a href="https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw"><code>ReadDirectoryChangesW</code></a>.</li>
+<li>On AIX systems, this feature depends on <a href="https://developer.ibm.com/articles/au-aix_event_infrastructure/"><code>AHAFS</code></a>, which must be enabled.</li>
+<li>On IBM i systems, this feature is not supported.</li>
+</ul>
+<p>If the underlying functionality is not available for some reason, then
+<code>fs.watch()</code> will not be able to function and may throw an exception.
+For example, watching files or directories can be unreliable, and in some
+cases impossible, on network file systems (NFS, SMB, etc) or host file systems
+when using virtualization software such as Vagrant or Docker.</p>
+<p>It is still possible to use <code>fs.watchFile()</code>, which uses stat polling, but
+this method is slower and less reliable.</p>
+<h6>Inodes<span><a class="mark" href="#fs_inodes" id="fs_inodes">#</a></span></h6>
+
+<p>On Linux and macOS systems, <code>fs.watch()</code> resolves the path to an <a href="https://en.wikipedia.org/wiki/Inode">inode</a> and
+watches the inode. If the watched path is deleted and recreated, it is assigned
+a new inode. The watch will emit an event for the delete but will continue
+watching the <em>original</em> inode. Events for the new inode will not be emitted.
+This is expected behavior.</p>
+<p>AIX files retain the same inode for the lifetime of a file. Saving and closing a
+watched file on AIX will result in two notifications (one for adding new
+content, and one for truncation).</p>
+<h6>Filename argument<span><a class="mark" href="#fs_filename_argument" id="fs_filename_argument">#</a></span></h6>
+
+<p>Providing <code>filename</code> argument in the callback is only supported on Linux,
+macOS, Windows, and AIX. Even on supported platforms, <code>filename</code> is not always
+guaranteed to be provided. Therefore, don't assume that <code>filename</code> argument is
+always provided in the callback, and have some fallback logic if it is <code>null</code>.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { watch } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-title function_">watch</span>(<span class="hljs-string">'somedir'</span>, <span class="hljs-function">(<span class="hljs-params">eventType, filename</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`event type is: <span class="hljs-subst">${eventType}</span>`</span>);
+  <span class="hljs-keyword">if</span> (filename) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`filename provided: <span class="hljs-subst">${filename}</span>`</span>);
+  } <span class="hljs-keyword">else</span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'filename not provided'</span>);
+  }
+});</code></pre>
+<h4><code>fs.watchFile(filename[, options], listener)</code><span><a class="mark" href="#fs_fs_watchfile_filename_options_listener" id="fs_fs_watchfile_filename_options_listener">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
-<tr><td>v12.12.0</td>
-<td><p><span>Added in: v12.12.0</span></p></td></tr>
+<tr><td>v10.5.0</td>
+<td><p>The <code>bigint</code> option is now supported.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
-internally when reading from the directory. Higher values lead to better
-performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><code>persistent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
+<li><code>interval</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>5007</code></li>
 </ul>
 </li>
-<li>Returns: <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a></li>
+<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>current</code> <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
+<li><code>previous</code> <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Synchronously open a directory. See <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a>.</p>
-<p>Creates an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a>, which contains all further functions for reading from
-and cleaning up the directory.</p>
-<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
-directory and subsequent read operations.</p>
-<h2><code>fs.openSync(path[, flags, mode])</code><span><a class="mark" href="#fs_fs_opensync_path_flags_mode" id="fs_fs_opensync_path_flags_mode">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.1.0</td>
-<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
-<tr><td>v9.9.0</td>
-<td><p>The <code>as</code> and <code>as+</code> modes are supported now.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
+</li>
+<li>Returns: <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
+</ul>
+<p>Watch for changes on <code>filename</code>. The callback <code>listener</code> will be called each
+time the file is accessed.</p>
+<p>The <code>options</code> argument may be omitted. If provided, it should be an object. The
+<code>options</code> object may contain a boolean named <code>persistent</code> that indicates
+whether the process should continue to run as long as files are being watched.
+The <code>options</code> object may specify an <code>interval</code> property indicating how often the
+target should be polled in milliseconds.</p>
+<p>The <code>listener</code> gets two arguments the current stat object and the previous
+stat object:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { watchFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">watchFile</span>(<span class="hljs-string">'message.text'</span>, <span class="hljs-function">(<span class="hljs-params">curr, prev</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`the current mtime is: <span class="hljs-subst">${curr.mtime}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`the previous mtime was: <span class="hljs-subst">${prev.mtime}</span>`</span>);
+});</code></pre>
+<p>These stat objects are instances of <code>fs.Stat</code>. If the <code>bigint</code> option is <code>true</code>,
+the numeric values in these objects are specified as <code>BigInt</code>s.</p>
+<p>To be notified when the file was modified, not just accessed, it is necessary
+to compare <code>curr.mtime</code> and <code>prev.mtime</code>.</p>
+<p>When an <code>fs.watchFile</code> operation results in an <code>ENOENT</code> error, it
+will invoke the listener once, with all the fields zeroed (or, for dates, the
+Unix Epoch). If the file is created later on, the listener will be called
+again, with the latest stat objects. This is a change in functionality since
+v0.10.</p>
+<p>Using <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile</code> and
+<code>fs.unwatchFile</code>. <code>fs.watch</code> should be used instead of <code>fs.watchFile</code> and
+<code>fs.unwatchFile</code> when possible.</p>
+<p>When a file being watched by <code>fs.watchFile()</code> disappears and reappears,
+then the contents of <code>previous</code> in the second callback event (the file's
+reappearance) will be the same as the contents of <code>previous</code> in the first
+callback event (its disappearance).</p>
+<p>This happens when:</p>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>'r'</code>.
-See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.</li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li>the file is deleted, followed by a restore</li>
+<li>the file is renamed and then renamed a second time back to its original name</li>
 </ul>
-<p>Returns an integer representing the file descriptor.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>.</p>
-<h2><code>fs.read(fd, buffer, offset, length, position, callback)</code><span><a class="mark" href="#fs_fs_read_fd_buffer_offset_length_position_callback" id="fs_fs_read_fd_buffer_offset_length_position_callback">#</a></span></h2>
+<h4><code>fs.write(fd, buffer[, offset[, length[, position]]], callback)</code><span><a class="mark" href="#fs_fs_write_fd_buffer_offset_length_position_callback" id="fs_fs_write_fd_buffer_offset_length_position_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>buffer</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>buffer</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v10.10.0</td>
-<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code>, or a <code>DataView</code>.</p></td></tr>
+<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.4.0</td>
 <td><p>The <code>buffer</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
-<tr><td>v6.0.0</td>
-<td><p>The <code>length</code> parameter can now be <code>0</code>.</p></td></tr>
+<tr><td>v7.2.0</td>
+<td><p>The <code>offset</code> and <code>length</code> parameters are optional now.</p></td></tr>
+<tr><td>v7.0.0</td>
+<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
 <tr><td>v0.0.2</td>
 <td><p><span>Added in: v0.0.2</span></p></td></tr>
 </tbody></table>
@@ -3094,783 +4025,686 @@ this API: <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code><
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
 </ul>
 </li>
 </ul>
-<p>Read data from the file specified by <code>fd</code>.</p>
-<p><code>buffer</code> is the buffer that the data (read from the fd) will be written to.</p>
-<p><code>offset</code> is the offset in the buffer to start writing at.</p>
-<p><code>length</code> is an integer specifying the number of bytes to read.</p>
-<p><code>position</code> is an argument specifying where to begin reading from in the file.
-If <code>position</code> is <code>null</code>, data will be read from the current file position,
-and the file position will be updated.
-If <code>position</code> is an integer, the file position will remain unchanged.</p>
-<p>The callback is given the three arguments, <code>(err, bytesRead, buffer)</code>.</p>
+<p>Write <code>buffer</code> to the file specified by <code>fd</code>. If <code>buffer</code> is a normal object, it
+must have an own <code>toString</code> function property.</p>
+<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is
+an integer specifying the number of bytes to write.</p>
+<p><code>position</code> refers to the offset from the beginning of the file where this data
+should be written. If <code>typeof position !== 'number'</code>, the data will be written
+at the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
+<p>The callback will be given three arguments <code>(err, bytesWritten, buffer)</code> where
+<code>bytesWritten</code> specifies how many <em>bytes</em> were written from <code>buffer</code>.</p>
 <p>If this method is invoked as its <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
-a <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> and <code>buffer</code> properties.</p>
-<h2><code>fs.read(fd, [options,] callback)</code><span><a class="mark" href="#fs_fs_read_fd_options_callback" id="fs_fs_read_fd_options_callback">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>Options object can be passed in to make Buffer, offset, length and position optional</p></td></tr>
-<tr><td>v12.17.0</td>
-<td><p><span>Added in: v12.17.0</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.length</code></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
-</ul>
-</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-</ul>
-</li>
-</ul>
-<p>Similar to the above <code>fs.read</code> function, this version takes an optional <code>options</code> object.
-If no <code>options</code> object is specified, it will default with the above values.</p>
-<h2><code>fs.readdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readdir_path_options_callback" id="fs_fs_readdir_path_options_callback">#</a></span></h2>
+a promise for an <code>Object</code> with <code>bytesWritten</code> and <code>buffer</code> properties.</p>
+<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting
+for the callback. For this scenario, <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> is
+recommended.</p>
+<p>On Linux, positional writes don't work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+<h4><code>fs.write(fd, string[, position[, encoding]], callback)</code><span><a class="mark" href="#fs_fs_write_fd_string_position_encoding_callback" id="fs_fs_write_fd_string_position_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.10.0</td>
-<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>string</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>string</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v7.2.0</td>
+<td><p>The <code>position</code> parameter is optional now.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v6.0.0</td>
-<td><p>The <code>options</code> parameter was added.</p></td></tr>
-<tr><td>v0.1.8</td>
-<td><p><span>Added in: v0.1.8</span></p></td></tr>
+<tr><td>v0.11.5</td>
+<td><p><span>Added in: v0.11.5</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-</ul>
-</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>files</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent[]></a></li>
+<li><code>written</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a>. Reads the contents of a directory.
-The callback gets two arguments <code>(err, files)</code> where <code>files</code> is an array of
-the names of the files in the directory excluding <code>'.'</code> and <code>'..'</code>.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the filenames passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the filenames returned will be passed as <code>Buffer</code> objects.</p>
-<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the <code>files</code> array will contain
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a> objects.</p>
-<h2><code>fs.readdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_readdirsync_path_options" id="fs_fs_readdirsync_path_options">#</a></span></h2>
+<p>Write <code>string</code> to the file specified by <code>fd</code>. If <code>string</code> is not a string, or an
+object with an own <code>toString</code> function property, then an exception is thrown.</p>
+<p><code>position</code> refers to the offset from the beginning of the file where this data
+should be written. If <code>typeof position !== 'number'</code> the data will be written at
+the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
+<p><code>encoding</code> is the expected string encoding.</p>
+<p>The callback will receive the arguments <code>(err, written, string)</code> where <code>written</code>
+specifies how many <em>bytes</em> the passed string required to be written. Bytes
+written is not necessarily the same as string characters written. See
+<a href="buffer.html#buffer_static_method_buffer_bytelength_string_encoding"><code>Buffer.byteLength</code></a>.</p>
+<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting
+for the callback. For this scenario, <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> is
+recommended.</p>
+<p>On Linux, positional writes don't work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+<p>On Windows, if the file descriptor is connected to the console (e.g. <code>fd == 1</code>
+or <code>stdout</code>) a string containing non-ASCII characters will not be rendered
+properly by default, regardless of the encoding used.
+It is possible to configure the console to render UTF-8 properly by changing the
+active codepage with the <code>chcp 65001</code> command. See the <a href="https://ss64.com/nt/chcp.html">chcp</a> docs for more
+details.</p>
+<h4><code>fs.writeFile(file, data[, options], callback)</code><span><a class="mark" href="#fs_fs_writefile_file_data_options_callback" id="fs_fs_writefile_file_data_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>The options argument may include an AbortSignal to abort an ongoing writeFile request.</p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>data</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>data</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v10.10.0</td>
-<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
-</tbody></table>
-</details>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent[]></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a>.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the filenames returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the filenames returned will be passed as <code>Buffer</code> objects.</p>
-<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the result will contain
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a> objects.</p>
-<h2><code>fs.readFile(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readfile_path_options_callback" id="fs_fs_readfile_path_options_callback">#</a></span></h2>
-<div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
+<td><p>The <code>data</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v7.4.0</td>
+<td><p>The <code>data</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
 <tr><td>v7.0.0</td>
 <td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v5.1.0</td>
-<td><p>The <code>callback</code> will always be called with <code>null</code> as the <code>error</code> parameter in case of success.</p></td></tr>
 <tr><td>v5.0.0</td>
-<td><p>The <code>path</code> parameter can be a file descriptor now.</p></td></tr>
+<td><p>The <code>file</code> parameter can be a file descriptor now.</p></td></tr>
 <tr><td>v0.1.29</td>
 <td><p><span>Added in: v0.1.29</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
+<li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> allows aborting an in-progress writeFile</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 </li>
 </ul>
-<p>Asynchronously reads the entire contents of a file.</p>
-<pre><code class="language-js">fs.readFile(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
+<p>When <code>file</code> is a filename, asynchronously writes data to the file, replacing the
+file if it already exists. <code>data</code> can be a string or a buffer.</p>
+<p>When <code>file</code> is a file descriptor, the behavior is similar to calling
+<code>fs.write()</code> directly (which is recommended). See the notes below on using
+a file descriptor.</p>
+<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<p>If <code>data</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { writeFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">const</span> data = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Hello Node.js'</span>));
+<span class="hljs-title function_">writeFile</span>(<span class="hljs-string">'message.txt'</span>, data, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(data);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The file has been saved!'</span>);
 });</code></pre>
-<p>The callback is passed two arguments <code>(err, data)</code>, where <code>data</code> is the
-contents of the file.</p>
-<p>If no encoding is specified, then the raw buffer is returned.</p>
 <p>If <code>options</code> is a string, then it specifies the encoding:</p>
-<pre><code class="language-js">fs.readFile(<span class="hljs-string">'/etc/passwd'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
-<p>When the path is a directory, the behavior of <code>fs.readFile()</code> and
-<a href="#fs_fs_readfilesync_path_options"><code>fs.readFileSync()</code></a> is platform-specific. On macOS, Linux, and Windows, an
-error will be returned. On FreeBSD, a representation of the directory's contents
-will be returned.</p>
-<pre><code class="language-js"><span class="hljs-comment">// macOS, Linux, and Windows</span>
-fs.readFile(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
-  <span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]</span>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { writeFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">writeFile</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'Hello Node.js'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
+<p>It is unsafe to use <code>fs.writeFile()</code> multiple times on the same file without
+waiting for the callback. For this scenario, <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> is
+recommended.</p>
+<p>Similarly to <code>fs.readFile</code> - <code>fs.writeFile</code> is a convenience method that
+performs multiple <code>write</code> calls internally to write the buffer passed to it.
+For performance sensitive code consider using <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>It is possible to use an <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> to cancel an <code>fs.writeFile()</code>.
+Cancelation is "best effort", and some amount of data is likely still
+to be written.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { writeFile } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">const</span> controller = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> { signal } = controller;
+<span class="hljs-keyword">const</span> data = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'Hello Node.js'</span>));
+<span class="hljs-title function_">writeFile</span>(<span class="hljs-string">'message.txt'</span>, data, { signal }, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-comment">// When a request is aborted - the callback is called with an AbortError</span>
 });
+<span class="hljs-comment">// When the request should be aborted</span>
+controller.<span class="hljs-title function_">abort</span>();</code></pre>
+<p>Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering <code>fs.writeFile</code> performs.</p>
+<h5>Using <code>fs.writeFile()</code> with file descriptors<span><a class="mark" href="#fs_using_fs_writefile_with_file_descriptors" id="fs_using_fs_writefile_with_file_descriptors">#</a></span></h5>
+<p>When <code>file</code> is a file descriptor, the behavior is almost identical to directly
+calling <code>fs.write()</code> like:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { write } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">//  FreeBSD</span>
-fs.readFile(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-function">(<span class="hljs-params">err, data</span>) =></span> {
-  <span class="hljs-comment">// => null, &#x3C;data></span>
-});</code></pre>
-<p>The <code>fs.readFile()</code> function buffers the entire file. To minimize memory costs,
-when possible prefer streaming via <code>fs.createReadStream()</code>.</p>
-<h3>File descriptors<span><a class="mark" href="#fs_file_descriptors_1" id="fs_file_descriptors_1">#</a></span></h3>
-<ol>
-<li>Any specified file descriptor has to support reading.</li>
-<li>If a file descriptor is specified as the <code>path</code>, it will not be closed
-automatically.</li>
-<li>The reading will begin at the current position. For example, if the file
-already had <code>'Hello World</code>' and six bytes are read with the file descriptor,
-the call to <code>fs.readFile()</code> with the same file descriptor, would give
-<code>'World'</code>, rather than <code>'Hello World'</code>.</li>
-</ol>
-<h2><code>fs.readFileSync(path[, options])</code><span><a class="mark" href="#fs_fs_readfilesync_path_options" id="fs_fs_readfilesync_path_options">#</a></span></h2>
+<span class="hljs-title function_">write</span>(fd, <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(data, options.<span class="hljs-property">encoding</span>), callback);</code></pre>
+<p>The difference from directly calling <code>fs.write()</code> is that under some unusual
+conditions, <code>fs.write()</code> might write only part of the buffer and need to be
+retried to write the remaining data, whereas <code>fs.writeFile()</code> retries until
+the data is entirely written (or an error occurs).</p>
+<p>The implications of this are a common source of confusion. In
+the file descriptor case, the file is not replaced! The data is not necessarily
+written to the beginning of the file, and the file's original data may remain
+before and/or after the newly written data.</p>
+<p>For example, if <code>fs.writeFile()</code> is called twice in a row, first to write the
+string <code>'Hello'</code>, then to write the string <code>', World'</code>, the file would contain
+<code>'Hello, World'</code>, and might contain some of the file's original data (depending
+on the size of the original file, and the position of the file descriptor). If
+a file name had been used instead of a descriptor, the file would be guaranteed
+to contain only <code>', World'</code>.</p>
+<h4><code>fs.writev(fd, buffers[, position], callback)</code><span><a class="mark" href="#fs_fs_writev_fd_buffers_position_callback" id="fs_fs_writev_fd_buffers_position_callback">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.9.0</span>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
+</ul>
+</li>
+</ul>
+<p>Write an array of <code>ArrayBufferView</code>s to the file specified by <code>fd</code> using
+<code>writev()</code>.</p>
+<p><code>position</code> is the offset from the beginning of the file where this data
+should be written. If <code>typeof position !== 'number'</code>, the data will be written
+at the current position.</p>
+<p>The callback will be given three arguments: <code>err</code>, <code>bytesWritten</code>, and
+<code>buffers</code>. <code>bytesWritten</code> is how many bytes were written from <code>buffers</code>.</p>
+<p>If this method is <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed, it returns a promise for an
+<code>Object</code> with <code>bytesWritten</code> and <code>buffers</code> properties.</p>
+<p>It is unsafe to use <code>fs.writev()</code> multiple times on the same file without
+waiting for the callback. For this scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
+<p>On Linux, positional writes don't work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.</p>
+</section><section><h3>Synchronous API<span><a class="mark" href="#fs_synchronous_api" id="fs_synchronous_api">#</a></span></h3>
+<p>The synchronous APIs perform all operations synchronously, blocking the
+event loop until the operation completes or fails.</p>
+<h4><code>fs.accessSync(path[, mode])</code><span><a class="mark" href="#fs_fs_accesssync_path_mode" id="fs_fs_accesssync_path_mode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.11.15</td>
+<td><p><span>Added in: v0.11.15</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>fs.constants.F_OK</code></li>
+</ul>
+<p>Synchronously tests a user's permissions for the file or directory specified
+by <code>path</code>. The <code>mode</code> argument is an optional integer that specifies the
+accessibility checks to be performed. Check <a href="#fs_file_access_constants">File access constants</a> for
+possible values of <code>mode</code>. It is possible to create a mask consisting of
+the bitwise OR of two or more values
+(e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>
+<p>If any of the accessibility checks fail, an <code>Error</code> will be thrown. Otherwise,
+the method will return <code>undefined</code>.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { accessSync, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">accessSync</span>(<span class="hljs-string">'etc/passwd'</span>, constants.<span class="hljs-property">R_OK</span> | constants.<span class="hljs-property">W_OK</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'can read/write'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'no access!'</span>);
+}</code></pre>
+<h4><code>fs.appendFileSync(path, data[, options])</code><span><a class="mark" href="#fs_fs_appendfilesync_path_data_options" id="fs_fs_appendfilesync_path_data_options">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.0.0</td>
+<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
 <tr><td>v5.0.0</td>
-<td><p>The <code>path</code> parameter can be a file descriptor now.</p></td></tr>
-<tr><td>v0.1.8</td>
-<td><p><span>Added in: v0.1.8</span></p></td></tr>
+<td><p>The <code>file</code> parameter can be a file descriptor now.</p></td></tr>
+<tr><td>v0.6.7</td>
+<td><p><span>Added in: v0.6.7</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> filename or file descriptor</li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'a'</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Returns the contents of the <code>path</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile()</code></a>.</p>
-<p>If the <code>encoding</code> option is specified then this function returns a
-string. Otherwise it returns a buffer.</p>
-<p>Similar to <a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile()</code></a>, when the path is a directory, the behavior of
-<code>fs.readFileSync()</code> is platform-specific.</p>
-<pre><code class="language-js"><span class="hljs-comment">// macOS, Linux, and Windows</span>
-fs.readFileSync(<span class="hljs-string">'&#x3C;directory>'</span>);
-<span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]</span>
+<p>Synchronously append data to a file, creating the file if it does not yet
+exist. <code>data</code> can be a string or a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { appendFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
-<span class="hljs-comment">//  FreeBSD</span>
-fs.readFileSync(<span class="hljs-string">'&#x3C;directory>'</span>); <span class="hljs-comment">// => &#x3C;data></span></code></pre>
-<h2><code>fs.readlink(path[, options], callback)</code><span><a class="mark" href="#fs_fs_readlink_path_options_callback" id="fs_fs_readlink_path_options_callback">#</a></span></h2>
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">appendFileSync</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The "data to append" was appended to file!'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">/* Handle the error */</span>
+}</code></pre>
+<p>If <code>options</code> is a string, then it specifies the encoding:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { appendFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">appendFileSync</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>);</code></pre>
+<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened
+for appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will
+not be closed automatically.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { openSync, closeSync, appendFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">let</span> fd;
+
+<span class="hljs-keyword">try</span> {
+  fd = <span class="hljs-title function_">openSync</span>(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'a'</span>);
+  <span class="hljs-title function_">appendFileSync</span>(fd, <span class="hljs-string">'data to append'</span>, <span class="hljs-string">'utf8'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-comment">/* Handle the error */</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">if</span> (fd !== <span class="hljs-literal">undefined</span>)
+    <span class="hljs-title function_">closeSync</span>(fd);
+}</code></pre>
+<h4><code>fs.chmodSync(path, mode)</code><span><a class="mark" href="#fs_fs_chmodsync_path_mode" id="fs_fs_chmodsync_path_mode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.6.7</td>
+<td><p><span>Added in: v0.6.7</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>linkString</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-</ul>
-</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a>. The callback gets two arguments <code>(err, linkString)</code>.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the link path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the link path returned will be passed as a <code>Buffer</code> object.</p>
-<h2><code>fs.readlinkSync(path[, options])</code><span><a class="mark" href="#fs_fs_readlinksync_path_options" id="fs_fs_readlinksync_path_options">#</a></span></h2>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_chmod_path_mode_callback"><code>fs.chmod()</code></a>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.chownSync(path, uid, gid)</code><span><a class="mark" href="#fs_fs_chownsync_path_uid_gid" id="fs_fs_chownsync_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.97</td>
+<td><p><span>Added in: v0.1.97</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<p>Synchronously changes owner and group of a file. Returns <code>undefined</code>.
+This is the synchronous version of <a href="#fs_fs_chown_path_uid_gid_callback"><code>fs.chown()</code></a>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.closeSync(fd)</code><span><a class="mark" href="#fs_fs_closesync_fd" id="fs_fs_closesync_fd">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.21</span>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a>. Returns the symbolic link's string value.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the link path returned will be passed as a <code>Buffer</code> object.</p>
-<h2><code>fs.readSync(fd, buffer, offset, length, position)</code><span><a class="mark" href="#fs_fs_readsync_fd_buffer_offset_length_position" id="fs_fs_readsync_fd_buffer_offset_length_position">#</a></span></h2>
+<p>Closes the file descriptor. Returns <code>undefined</code>.</p>
+<p>Calling <code>fs.closeSync()</code> on any file descriptor (<code>fd</code>) that is currently in use
+through any other <code>fs</code> operation may lead to undefined behavior.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/close.2.html"><code>close(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.copyFileSync(src, dest[, mode])</code><span><a class="mark" href="#fs_fs_copyfilesync_src_dest_mode" id="fs_fs_copyfilesync_src_dest_mode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.10.0</td>
-<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
-<tr><td>v6.0.0</td>
-<td><p>The <code>length</code> parameter can now be <code>0</code>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
+<tr><td>v8.5.0</td>
+<td><p><span>Added in: v8.5.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
+<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
 </ul>
-<p>Returns the number of <code>bytesRead</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a>.</p>
-<h2><code>fs.readSync(fd, buffer, [options])</code><span><a class="mark" href="#fs_fs_readsync_fd_buffer_options" id="fs_fs_readsync_fd_buffer_options">#</a></span></h2>
+<p>Synchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
+already exists. Returns <code>undefined</code>. Node.js makes no guarantees about the
+atomicity of the copy operation. If an error occurs after the destination file
+has been opened for writing, Node.js will attempt to remove the destination.</p>
+<p><code>mode</code> is an optional integer that specifies the behavior
+of the copy operation. It is possible to create a mask consisting of the bitwise
+OR of two or more values (e.g.
+<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
+<ul>
+<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already
+exists.</li>
+<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a
+copy-on-write reflink. If the platform does not support copy-on-write, then a
+fallback copy mechanism is used.</li>
+<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
+create a copy-on-write reflink. If the platform does not support
+copy-on-write, then the operation will fail.</li>
+</ul>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { copyFileSync, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
+<span class="hljs-title function_">copyFileSync</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'source.txt was copied to destination.txt'</span>);
+
+<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
+<span class="hljs-title function_">copyFileSync</span>(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, constants.<span class="hljs-property">COPYFILE_EXCL</span>);</code></pre>
+<h4><code>fs.existsSync(path)</code><span><a class="mark" href="#fs_fs_existssync_path" id="fs_fs_existssync_path">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
-<td><p>Options object can be passed in to make offset, length and position optional</p></td></tr>
-<tr><td>v12.17.0</td>
-<td><p><span>Added in: v12.17.0</span></p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.length</code></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Returns the number of <code>bytesRead</code>.</p>
-<p>Similar to the above <code>fs.readSync</code> function, this version takes an optional <code>options</code> object.
-If no <code>options</code> object is specified, it will default with the above values.</p>
+<p>Returns <code>true</code> if the path exists, <code>false</code> otherwise.</p>
 <p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a>.</p>
-<h2><code>fs.readv(fd, buffers[, position], callback)</code><span><a class="mark" href="#fs_fs_readv_fd_buffers_position_callback" id="fs_fs_readv_fd_buffers_position_callback">#</a></span></h2>
+this API: <a href="#fs_fs_exists_path_callback"><code>fs.exists()</code></a>.</p>
+<p><code>fs.exists()</code> is deprecated, but <code>fs.existsSync()</code> is not. The <code>callback</code>
+parameter to <code>fs.exists()</code> accepts parameters that are inconsistent with other
+Node.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { existsSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">if</span> (<span class="hljs-title function_">existsSync</span>(<span class="hljs-string">'/etc/passwd'</span>))
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The path exists.'</span>);</code></pre>
+<h4><code>fs.fchmodSync(fd, mode)</code><span><a class="mark" href="#fs_fs_fchmodsync_fd_mode" id="fs_fs_fchmodsync_fd_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v0.4.7</span>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>bytesRead</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-</li>
+<p>Sets the permissions on the file. Returns <code>undefined</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fchmod.2.html"><code>fchmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fchownSync(fd, uid, gid)</code><span><a class="mark" href="#fs_fs_fchownsync_fd_uid_gid" id="fs_fs_fchownsync_fd_uid_gid">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.7</span>
+</div>
+<ul>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new owner's user id.</li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new group's group id.</li>
 </ul>
-<p>Read from a file specified by <code>fd</code> and write to an array of <code>ArrayBufferView</code>s
-using <code>readv()</code>.</p>
-<p><code>position</code> is the offset from the beginning of the file from where data
-should be read. If <code>typeof position !== 'number'</code>, the data will be read
-from the current position.</p>
-<p>The callback will be given three arguments: <code>err</code>, <code>bytesRead</code>, and
-<code>buffers</code>. <code>bytesRead</code> is how many bytes were read from the file.</p>
-<p>If this method is invoked as its <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
-a <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> and <code>buffers</code> properties.</p>
-<h2><code>fs.readvSync(fd, buffers[, position])</code><span><a class="mark" href="#fs_fs_readvsync_fd_buffers_position" id="fs_fs_readvsync_fd_buffers_position">#</a></span></h2>
+<p>Sets the owner of the file. Returns <code>undefined</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fchown.2.html"><code>fchown(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fdatasyncSync(fd)</code><span><a class="mark" href="#fs_fs_fdatasyncsync_fd" id="fs_fs_fdatasyncsync_fd">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v0.1.96</span>
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes read.</li>
 </ul>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv()</code></a>.</p>
-<h2><code>fs.realpath(path[, options], callback)</code><span><a class="mark" href="#fs_fs_realpath_path_options_callback" id="fs_fs_realpath_path_options_callback">#</a></span></h2>
+<p>Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+<a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a> documentation for details. Returns <code>undefined</code>.</p>
+<h4><code>fs.fstatSync(fd[, options])</code><span><a class="mark" href="#fs_fs_fstatsync_fd_options" id="fs_fs_fstatsync_fd_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v8.0.0</td>
-<td><p>Pipe/Socket resolve support was added.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v6.4.0</td>
-<td><p>Calling <code>realpath</code> now works again for various edge cases on Windows.</p></td></tr>
-<tr><td>v6.0.0</td>
-<td><p>The <code>cache</code> parameter was removed.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v0.1.95</td>
+<td><p><span>Added in: v0.1.95</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>resolvedPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
+<li>Returns: <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Asynchronously computes the canonical pathname by resolving <code>.</code>, <code>..</code> and
-symbolic links.</p>
-<p>A canonical pathname is not necessarily unique. Hard links and bind mounts can
-expose a file system entity through many pathnames.</p>
-<p>This function behaves like <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a>, with some exceptions:</p>
-<ol>
-<li>
-<p>No case conversion is performed on case-insensitive file systems.</p>
-</li>
-<li>
-<p>The maximum number of symbolic links is platform-independent and generally
-(much) higher than what the native <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a> implementation supports.</p>
-</li>
-</ol>
-<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>. May use <code>process.cwd</code>
-to resolve relative paths.</p>
-<p>Only paths that can be converted to UTF8 strings are supported.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the path returned will be passed as a <code>Buffer</code> object.</p>
-<p>If <code>path</code> resolves to a socket or a pipe, the function will return a system
-dependent name for that object.</p>
-<h2><code>fs.realpath.native(path[, options], callback)</code><span><a class="mark" href="#fs_fs_realpath_native_path_options_callback" id="fs_fs_realpath_native_path_options_callback">#</a></span></h2>
+<p>Retrieves the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the file descriptor.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/fstat.2.html"><code>fstat(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.fsyncSync(fd)</code><span><a class="mark" href="#fs_fs_fsyncsync_fd" id="fs_fs_fsyncsync_fd">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v9.2.0</span>
+<span>Added in: v0.1.96</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<p>Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a> documentation for more detail. Returns <code>undefined</code>.</p>
+<h4><code>fs.ftruncateSync(fd[, len])</code><span><a class="mark" href="#fs_fs_ftruncatesync_fd_len" id="fs_fs_ftruncatesync_fd_len">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.8.6</span>
+</div>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>resolvedPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-</ul>
-</li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a>.</p>
-<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>.</p>
-<p>Only paths that can be converted to UTF8 strings are supported.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the path returned will be passed as a <code>Buffer</code> object.</p>
-<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
-be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
-this restriction.</p>
-<h2><code>fs.realpathSync(path[, options])</code><span><a class="mark" href="#fs_fs_realpathsync_path_options" id="fs_fs_realpathsync_path_options">#</a></span></h2>
+<p>Truncates the file descriptor. Returns <code>undefined</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_ftruncate_fd_len_callback"><code>fs.ftruncate()</code></a>.</p>
+<h4><code>fs.futimesSync(fd, atime, mtime)</code><span><a class="mark" href="#fs_fs_futimessync_fd_atime_mtime" id="fs_fs_futimessync_fd_atime_mtime">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v8.0.0</td>
-<td><p>Pipe/Socket resolve support was added.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v6.4.0</td>
-<td><p>Calling <code>realpathSync</code> now works again for various edge cases on Windows.</p></td></tr>
-<tr><td>v6.0.0</td>
-<td><p>The <code>cache</code> parameter was removed.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<tr><td>v4.1.0</td>
+<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
+<tr><td>v0.4.2</td>
+<td><p><span>Added in: v0.4.2</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>Returns the resolved pathname.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_realpath_path_options_callback"><code>fs.realpath()</code></a>.</p>
-<h2><code>fs.realpathSync.native(path[, options])</code><span><a class="mark" href="#fs_fs_realpathsync_native_path_options" id="fs_fs_realpathsync_native_path_options">#</a></span></h2>
+<p>Synchronous version of <a href="#fs_fs_futimes_fd_atime_mtime_callback"><code>fs.futimes()</code></a>. Returns <code>undefined</code>.</p>
+<h4><code>fs.lchmodSync(path, mode)</code><span><a class="mark" href="#fs_fs_lchmodsync_path_mode" id="fs_fs_lchmodsync_path_mode">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v9.2.0</span>
+<span>Deprecated since: v0.4.7</span>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a>.</p>
-<p>Only paths that can be converted to UTF8 strings are supported.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
-the path returned will be passed as a <code>Buffer</code> object.</p>
-<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
-be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
-this restriction.</p>
-<h2><code>fs.rename(oldPath, newPath, callback)</code><span><a class="mark" href="#fs_fs_rename_oldpath_newpath_callback" id="fs_fs_rename_oldpath_newpath_callback">#</a></span></h2>
+<p>Changes the permissions on a symbolic link. Returns <code>undefined</code>.</p>
+<p>This method is only implemented on macOS.</p>
+<p>See the POSIX <a href="https://www.freebsd.org/cgi/man.cgi?query=lchmod&#x26;sektion=2"><code>lchmod(2)</code></a> documentation for more detail.</p>
+<h4><code>fs.lchownSync(path, uid, gid)</code><span><a class="mark" href="#fs_fs_lchownsync_path_uid_gid" id="fs_fs_lchownsync_path_uid_gid">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>oldPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.0.2</td>
-<td><p><span>Added in: v0.0.2</span></p></td></tr>
+<tr><td>v10.6.0</td>
+<td><p>This API is no longer deprecated.</p></td></tr>
+<tr><td>v0.4.7</td>
+<td><p>Documentation-only deprecation.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new owner's user id.</li>
+<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The file's new group's group id.</li>
 </ul>
-</li>
+<p>Set the owner for the path. Returns <code>undefined</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/lchown.2.html"><code>lchown(2)</code></a> documentation for more details.</p>
+<h4><code>fs.lutimesSync(path, atime, mtime)</code><span><a class="mark" href="#fs_fs_lutimessync_path_atime_mtime" id="fs_fs_lutimessync_path_atime_mtime">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.5.0, v12.19.0</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>Asynchronously rename file at <code>oldPath</code> to the pathname provided
-as <code>newPath</code>. In the case that <code>newPath</code> already exists, it will
-be overwritten. If there is a directory at <code>newPath</code>, an error will
-be raised instead. No arguments other than a possible exception are
-given to the completion callback.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>.</p>
-<pre><code class="language-js">fs.rename(<span class="hljs-string">'oldFile.txt'</span>, <span class="hljs-string">'newFile.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Rename complete!'</span>);
-});</code></pre>
-<h2><code>fs.renameSync(oldPath, newPath)</code><span><a class="mark" href="#fs_fs_renamesync_oldpath_newpath" id="fs_fs_renamesync_oldpath_newpath">#</a></span></h2>
+<p>Change the file system timestamps of the symbolic link referenced by <code>path</code>.
+Returns <code>undefined</code>, or throws an exception when parameters are incorrect or
+the operation fails. This is the synchronous version of <a href="#fs_fs_lutimes_path_atime_mtime_callback"><code>fs.lutimes()</code></a>.</p>
+<h4><code>fs.linkSync(existingPath, newPath)</code><span><a class="mark" href="#fs_fs_linksync_existingpath_newpath" id="fs_fs_linksync_existingpath_newpath">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>oldPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
+<td><p>The <code>existingPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.rmdir(path[, options], callback)</code><span><a class="mark" href="#fs_fs_rmdir_path_options_callback" id="fs_fs_rmdir_path_options_callback">#</a></span></h2>
+<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX
+<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a> documentation for more detail. Returns <code>undefined</code>.</p>
+<h4><code>fs.lstatSync(path[, options])</code><span><a class="mark" href="#fs_fs_lstatsync_path_options" id="fs_fs_lstatsync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
-<tr><td>v12.10.0</td>
-<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>Accepts a <code>throwIfNoEntry</code> option to specify whether an exception should be thrown if the entry does not exist.</p></td></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameters can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.0.2</td>
-<td><p><span>Added in: v0.0.2</span></p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.30</td>
+<td><p><span>Added in: v0.1.30</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Recursive removal is experimental.</div><p></p>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
-<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
-backoff wait of <code>retryDelay</code> ms longer on each try. This option represents the
-number of retries. This option is ignored if the <code>recursive</code> option is not
-<code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
-recursive mode, errors are not reported if <code>path</code> does not exist, and
-operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
-<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
-retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
-<strong>Default:</strong> <code>100</code>.</li>
-</ul>
-</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>throwIfNoEntry</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether an exception will be thrown
+if no file system entry exists, rather than returning <code>undefined</code>.
+<strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
+<li>Returns: <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/rmdir.2.html"><code>rmdir(2)</code></a>. No arguments other than a possible exception are given
-to the completion callback.</p>
-<p>Using <code>fs.rmdir()</code> on a file (not a directory) results in an <code>ENOENT</code> error on
-Windows and an <code>ENOTDIR</code> error on POSIX.</p>
-<h2><code>fs.rmdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_rmdirsync_path_options" id="fs_fs_rmdirsync_path_options">#</a></span></h2>
+<p>Retrieves the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the symbolic link referred to by <code>path</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a> documentation for more details.</p>
+<h4><code>fs.mkdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_mkdirsync_path_options" id="fs_fs_mkdirsync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
-<tr><td>v12.10.0</td>
-<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
+<tr><td>v13.11.0, v12.17.0</td>
+<td><p>In <code>recursive</code> mode, the first created path is returned now.</p></td></tr>
+<tr><td>v10.12.0</td>
+<td><p>The second argument can now be an <code>options</code> object with <code>recursive</code> and <code>mode</code> properties.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameters can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
 <tr><td>v0.1.21</td>
 <td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Recursive removal is experimental.</div><p></p>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
 <ul>
-<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
-<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
-backoff wait of <code>retryDelay</code> ms longer on each try. This option represents the
-number of retries. This option is ignored if the <code>recursive</code> option is not
-<code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
-recursive mode, errors are not reported if <code>path</code> does not exist, and
-operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
-<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
-retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
-<strong>Default:</strong> <code>100</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
 </ul>
 </li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/rmdir.2.html"><code>rmdir(2)</code></a>. Returns <code>undefined</code>.</p>
-<p>Using <code>fs.rmdirSync()</code> on a file (not a directory) results in an <code>ENOENT</code> error
-on Windows and an <code>ENOTDIR</code> error on POSIX.</p>
-<h2><code>fs.stat(path[, options], callback)</code><span><a class="mark" href="#fs_fs_stat_path_options_callback" id="fs_fs_stat_path_options_callback">#</a></span></h2>
+<p>Synchronously creates a directory. Returns <code>undefined</code>, or if <code>recursive</code> is
+<code>true</code>, the first directory path created.
+This is the synchronous version of <a href="#fs_fs_mkdir_path_options_callback"><code>fs.mkdir()</code></a>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/mkdir.2.html"><code>mkdir(2)</code></a> documentation for more details.</p>
+<h4><code>fs.mkdtempSync(prefix[, options])</code><span><a class="mark" href="#fs_fs_mkdtempsync_prefix_options" id="fs_fs_mkdtempsync_prefix_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.0.2</td>
-<td><p><span>Added in: v0.0.2</span></p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>prefix</code> parameter now accepts an empty string.</p></td></tr>
+<tr><td>v5.10.0</td>
+<td><p><span>Added in: v5.10.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
-</ul>
-</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>stats</code> <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
 </li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/stat.2.html"><code>stat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where
-<code>stats</code> is an <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object.</p>
-<p>In case of an error, the <code>err.code</code> will be one of <a href="errors.html#errors_common_system_errors">Common System Errors</a>.</p>
-<p>Using <code>fs.stat()</code> to check for the existence of a file before calling
-<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended.
-Instead, user code should open/read/write the file directly and handle the
-error raised if the file is not available.</p>
-<p>To check if a file exists without manipulating it afterwards, <a href="#fs_fs_access_path_mode_callback"><code>fs.access()</code></a>
-is recommended.</p>
-<p>For example, given the following directory structure:</p>
-<pre><code class="language-text">- txtDir
--- file.txt
-- app.js</code></pre>
-<p>The next program will check for the stats of the given paths:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-
-<span class="hljs-keyword">const</span> pathsToCheck = [<span class="hljs-string">'./txtDir'</span>, <span class="hljs-string">'./txtDir/file.txt'</span>];
-
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; pathsToCheck.length; i++) {
-  fs.stat(pathsToCheck[i], <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">err, stats</span>) </span>{
-    <span class="hljs-built_in">console</span>.log(stats.isDirectory());
-    <span class="hljs-built_in">console</span>.log(stats);
-  });
-}</code></pre>
-<p>The resulting output will resemble:</p>
-<pre><code class="language-console">true
-Stats {
-  dev: 16777220,
-  mode: 16877,
-  nlink: 3,
-  uid: 501,
-  gid: 20,
-  rdev: 0,
-  blksize: 4096,
-  ino: 14214262,
-  size: 96,
-  blocks: 0,
-  atimeMs: 1561174653071.963,
-  mtimeMs: 1561174614583.3518,
-  ctimeMs: 1561174626623.5366,
-  birthtimeMs: 1561174126937.2893,
-  atime: 2019-06-22T03:37:33.072Z,
-  mtime: 2019-06-22T03:36:54.583Z,
-  ctime: 2019-06-22T03:37:06.624Z,
-  birthtime: 2019-06-22T03:28:46.937Z
-}
-false
-Stats {
-  dev: 16777220,
-  mode: 33188,
-  nlink: 1,
-  uid: 501,
-  gid: 20,
-  rdev: 0,
-  blksize: 4096,
-  ino: 14214074,
-  size: 8,
-  blocks: 8,
-  atimeMs: 1561174616618.8555,
-  mtimeMs: 1561174614584,
-  ctimeMs: 1561174614583.8145,
-  birthtimeMs: 1561174007710.7478,
-  atime: 2019-06-22T03:36:56.619Z,
-  mtime: 2019-06-22T03:36:54.584Z,
-  ctime: 2019-06-22T03:36:54.584Z,
-  birthtime: 2019-06-22T03:26:47.711Z
-}</code></pre>
-<h2><code>fs.statSync(path[, options])</code><span><a class="mark" href="#fs_fs_statsync_path_options" id="fs_fs_statsync_path_options">#</a></span></h2>
+<p>Returns the created directory path.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_mkdtemp_prefix_options_callback"><code>fs.mkdtemp()</code></a>.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use.</p>
+<h4><code>fs.opendirSync(path[, options])</code><span><a class="mark" href="#fs_fs_opendirsync_path_options" id="fs_fs_opendirsync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.21</td>
-<td><p><span>Added in: v0.1.21</span></p></td></tr>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
+<tr><td>v12.12.0</td>
+<td><p><span>Added in: v12.12.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -3878,586 +4712,461 @@ Stats {
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
+internally when reading from the directory. Higher values lead to better
+performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
 </ul>
 </li>
-<li>Returns: <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
+<li>Returns: <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a></li>
 </ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/stat.2.html"><code>stat(2)</code></a>.</p>
-<h2><code>fs.symlink(target, path[, type], callback)</code><span><a class="mark" href="#fs_fs_symlink_target_path_type_callback" id="fs_fs_symlink_target_path_type_callback">#</a></span></h2>
+<p>Synchronously open a directory. See <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a>.</p>
+<p>Creates an <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>, which contains all further functions for reading from
+and cleaning up the directory.</p>
+<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
+directory and subsequent read operations.</p>
+<h4><code>fs.openSync(path[, flags[, mode]])</code><span><a class="mark" href="#fs_fs_opensync_path_flags_mode" id="fs_fs_opensync_path_flags_mode">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.0.0</td>
-<td><p>If the <code>type</code> argument is left undefined, Node will autodetect <code>target</code> type and automatically select <code>dir</code> or <code>file</code></p></td></tr>
+<tr><td>v11.1.0</td>
+<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
+<tr><td>v9.9.0</td>
+<td><p>The <code>as</code> and <code>as+</code> flags are supported now.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>target</code> and <code>path</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-</ul>
-</li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>'r'</code>.
+See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.</li>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/symlink.2.html"><code>symlink(2)</code></a> which creates the link called <code>path</code> pointing to
-<code>target</code>. No arguments other than a possible exception are given to the
-completion callback.</p>
-<p>The <code>type</code> argument is only available on Windows and ignored on other platforms.
-It can be set to <code>'dir'</code>, <code>'file'</code>, or <code>'junction'</code>. If the <code>type</code> argument is
-not set, Node.js will autodetect <code>target</code> type and use <code>'file'</code> or <code>'dir'</code>. If
-the <code>target</code> does not exist, <code>'file'</code> will be used. Windows junction points
-require the destination path to be absolute. When using <code>'junction'</code>, the
-<code>target</code> argument will automatically be normalized to absolute path.</p>
-<p>Relative targets are relative to the link’s parent directory.</p>
-<pre><code class="language-js">fs.symlink(<span class="hljs-string">'./mew'</span>, <span class="hljs-string">'./example/mewtwo'</span>, callback);</code></pre>
-<p>The above example creates a symbolic link <code>mewtwo</code> in the <code>example</code> which points
-to <code>mew</code> in the same directory:</p>
-<pre><code class="language-bash">$ tree example/
-example/
-├── mew
-└── mewtwo -> ./mew</code></pre>
-<h2><code>fs.symlinkSync(target, path[, type])</code><span><a class="mark" href="#fs_fs_symlinksync_target_path_type" id="fs_fs_symlinksync_target_path_type">#</a></span></h2>
+<p>Returns an integer representing the file descriptor.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>.</p>
+<h4><code>fs.readdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_readdirsync_path_options" id="fs_fs_readdirsync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.0.0</td>
-<td><p>If the <code>type</code> argument is left undefined, Node will autodetect <code>target</code> type and automatically select <code>dir</code> or <code>file</code></p></td></tr>
+<tr><td>v10.10.0</td>
+<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>target</code> and <code>path</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
 </ul>
-<p>Returns <code>undefined</code>.</p>
-<p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink()</code></a>.</p>
-<h2><code>fs.truncate(path[, len], callback)</code><span><a class="mark" href="#fs_fs_truncate_path_len_callback" id="fs_fs_truncate_path_len_callback">#</a></span></h2>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent[]></a></li>
+</ul>
+<p>Reads the contents of the directory.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> documentation for more details.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the filenames returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the filenames returned will be passed as <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> objects.</p>
+<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the result will contain
+<a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> objects.</p>
+<h4><code>fs.readFileSync(path[, options])</code><span><a class="mark" href="#fs_fs_readfilesync_path_options" id="fs_fs_readfilesync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.8.6</td>
-<td><p><span>Added in: v0.8.6</span></p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v5.0.0</td>
+<td><p>The <code>path</code> parameter can be a file descriptor now.</p></td></tr>
+<tr><td>v0.1.8</td>
+<td><p><span>Added in: v0.1.8</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
+<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
 </ul>
 </li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/truncate.2.html"><code>truncate(2)</code></a>. No arguments other than a possible exception are
-given to the completion callback. A file descriptor can also be passed as the
-first argument. In this case, <code>fs.ftruncate()</code> is called.</p>
-<p>Passing a file descriptor is deprecated and may result in an error being thrown
-in the future.</p>
-<h2><code>fs.truncateSync(path[, len])</code><span><a class="mark" href="#fs_fs_truncatesync_path_len" id="fs_fs_truncatesync_path_len">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.8.6</span>
-</div>
-<ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/truncate.2.html"><code>truncate(2)</code></a>. Returns <code>undefined</code>. A file descriptor can also be
-passed as the first argument. In this case, <code>fs.ftruncateSync()</code> is called.</p>
-<p>Passing a file descriptor is deprecated and may result in an error being thrown
-in the future.</p>
-<h2><code>fs.unlink(path, callback)</code><span><a class="mark" href="#fs_fs_unlink_path_callback" id="fs_fs_unlink_path_callback">#</a></span></h2>
+<p>Returns the contents of the <code>path</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile()</code></a>.</p>
+<p>If the <code>encoding</code> option is specified then this function returns a
+string. Otherwise it returns a buffer.</p>
+<p>Similar to <a href="#fs_fs_readfile_path_options_callback"><code>fs.readFile()</code></a>, when the path is a directory, the behavior of
+<code>fs.readFileSync()</code> is platform-specific.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// macOS, Linux, and Windows</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'&#x3C;directory>'</span>);
+<span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]</span>
+
+<span class="hljs-comment">//  FreeBSD</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'&#x3C;directory>'</span>); <span class="hljs-comment">// => &#x3C;data></span></code></pre>
+<h4><code>fs.readlinkSync(path[, options])</code><span><a class="mark" href="#fs_fs_readlinksync_path_options" id="fs_fs_readlinksync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.0.2</td>
-<td><p><span>Added in: v0.0.2</span></p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
 </li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Asynchronously removes a file or symbolic link. No arguments other than a
-possible exception are given to the completion callback.</p>
-<pre><code class="language-js"><span class="hljs-comment">// Assuming that 'path/file.txt' is a regular file.</span>
-fs.unlink(<span class="hljs-string">'path/file.txt'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'path/file.txt was deleted'</span>);
-});</code></pre>
-<p><code>fs.unlink()</code> will not work on a directory, empty or otherwise. To remove a
-directory, use <a href="#fs_fs_rmdir_path_options_callback"><code>fs.rmdir()</code></a>.</p>
-<p>See also: <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>.</p>
-<h2><code>fs.unlinkSync(path)</code><span><a class="mark" href="#fs_fs_unlinksync_path" id="fs_fs_unlinksync_path">#</a></span></h2>
+<p>Returns the symbolic link's string value.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a> documentation for more details.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the link path returned will be passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<h4><code>fs.readSync(fd, buffer, offset, length, position)</code><span><a class="mark" href="#fs_fs_readsync_fd_buffer_offset_length_position" id="fs_fs_readsync_fd_buffer_offset_length_position">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v10.10.0</td>
+<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
+<tr><td>v6.0.0</td>
+<td><p>The <code>length</code> parameter can now be <code>0</code>.</p></td></tr>
 <tr><td>v0.1.21</td>
 <td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-</ul>
-<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>. Returns <code>undefined</code>.</p>
-<h2><code>fs.unwatchFile(filename[, listener])</code><span><a class="mark" href="#fs_fs_unwatchfile_filename_listener" id="fs_fs_unwatchfile_filename_listener">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v0.1.31</span>
-</div>
-<ul>
-<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional, a listener previously attached using
-<code>fs.watchFile()</code></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>Stop watching for changes on <code>filename</code>. If <code>listener</code> is specified, only that
-particular listener is removed. Otherwise, <em>all</em> listeners are removed,
-effectively stopping watching of <code>filename</code>.</p>
-<p>Calling <code>fs.unwatchFile()</code> with a filename that is not being watched is a
-no-op, not an error.</p>
-<p>Using <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile()</code> and
-<code>fs.unwatchFile()</code>. <code>fs.watch()</code> should be used instead of <code>fs.watchFile()</code>
-and <code>fs.unwatchFile()</code> when possible.</p>
-<h2><code>fs.utimes(path, atime, mtime, callback)</code><span><a class="mark" href="#fs_fs_utimes_path_atime_mtime_callback" id="fs_fs_utimes_path_atime_mtime_callback">#</a></span></h2>
+<p>Returns the number of <code>bytesRead</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a>.</p>
+<h4><code>fs.readSync(fd, buffer, [options])</code><span><a class="mark" href="#fs_fs_readsync_fd_buffer_options" id="fs_fs_readsync_fd_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v8.0.0</td>
-<td><p><code>NaN</code>, <code>Infinity</code>, and <code>-Infinity</code> are no longer valid time specifiers.</p></td></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v4.1.0</td>
-<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
-<tr><td>v0.4.2</td>
-<td><p><span>Added in: v0.4.2</span></p></td></tr>
+<tr><td>v13.13.0, v12.17.0</td>
+<td><p><span>Added in: v13.13.0, v12.17.0</span></p></td></tr>
+<tr><td>v13.13.0, v12.17.0</td>
+<td><p>Options object can be passed in to make offset, length and position optional.</p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
+<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.byteLength</code></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> <strong>Default:</strong> <code>null</code></li>
 </ul>
 </li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>
-<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>
+<p>Returns the number of <code>bytesRead</code>.</p>
+<p>Similar to the above <code>fs.readSync</code> function, this version takes an optional <code>options</code> object.
+If no <code>options</code> object is specified, it will default with the above values.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_read_fd_buffer_offset_length_position_callback"><code>fs.read()</code></a>.</p>
+<h4><code>fs.readvSync(fd, buffers[, position])</code><span><a class="mark" href="#fs_fs_readvsync_fd_buffers_position" id="fs_fs_readvsync_fd_buffers_position">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.13.0, v12.17.0</span>
+</div>
 <ul>
-<li>Values can be either numbers representing Unix epoch time in seconds,
-<code>Date</code>s, or a numeric string like <code>'123456789.0'</code>.</li>
-<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or
-<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
+<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes read.</li>
 </ul>
-<h2><code>fs.utimesSync(path, atime, mtime)</code><span><a class="mark" href="#fs_fs_utimessync_path_atime_mtime" id="fs_fs_utimessync_path_atime_mtime">#</a></span></h2>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_readv_fd_buffers_position_callback"><code>fs.readv()</code></a>.</p>
+<h4><code>fs.realpathSync(path[, options])</code><span><a class="mark" href="#fs_fs_realpathsync_path_options" id="fs_fs_realpathsync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v8.0.0</td>
-<td><p><code>NaN</code>, <code>Infinity</code>, and <code>-Infinity</code> are no longer valid time specifiers.</p></td></tr>
+<td><p>Pipe/Socket resolve support was added.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v4.1.0</td>
-<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
-<tr><td>v0.4.2</td>
-<td><p><span>Added in: v0.4.2</span></p></td></tr>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v6.4.0</td>
+<td><p>Calling <code>realpathSync</code> now works again for various edge cases on Windows.</p></td></tr>
+<tr><td>v6.0.0</td>
+<td><p>The <code>cache</code> parameter was removed.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
-<p>Returns <code>undefined</code>.</p>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+</ul>
+<p>Returns the resolved pathname.</p>
 <p>For detailed information, see the documentation of the asynchronous version of
-this API: <a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>.</p>
-<h2><code>fs.watch(filename[, options][, listener])</code><span><a class="mark" href="#fs_fs_watch_filename_options_listener" id="fs_fs_watch_filename_options_listener">#</a></span></h2>
+this API: <a href="#fs_fs_realpath_path_options_callback"><code>fs.realpath()</code></a>.</p>
+<h4><code>fs.realpathSync.native(path[, options])</code><span><a class="mark" href="#fs_fs_realpathsync_native_path_options" id="fs_fs_realpathsync_native_path_options">#</a></span></h4>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v7.6.0</td>
-<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The passed <code>options</code> object will never be modified.</p></td></tr>
-<tr><td>v0.5.10</td>
-<td><p><span>Added in: v0.5.10</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v9.2.0</span>
 </div>
 <ul>
-<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>persistent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether the process should continue to run
-as long as files are being watched. <strong>Default:</strong> <code>true</code>.</li>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether all subdirectories should be
-watched, or only the current directory. This applies when a directory is
-specified, and only on supported platforms (See <a href="#fs_caveats">Caveats</a>). <strong>Default:</strong>
-<code>false</code>.</li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Specifies the character encoding to be used for the
- filename passed to the listener. <strong>Default:</strong> <code>'utf8'</code>.</li>
-</ul>
-</li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a> <strong>Default:</strong> <code>undefined</code>
-<ul>
-<li><code>eventType</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
 </ul>
 </li>
-<li>Returns: <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
-</ul>
-<p>Watch for changes on <code>filename</code>, where <code>filename</code> is either a file or a
-directory.</p>
-<p>The second argument is optional. If <code>options</code> is provided as a string, it
-specifies the <code>encoding</code>. Otherwise <code>options</code> should be passed as an object.</p>
-<p>The listener callback gets two arguments <code>(eventType, filename)</code>. <code>eventType</code>
-is either <code>'rename'</code> or <code>'change'</code>, and <code>filename</code> is the name of the file
-which triggered the event.</p>
-<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or
-disappears in the directory.</p>
-<p>The listener callback is attached to the <code>'change'</code> event fired by
-<a href="#fs_class_fs_fswatcher"><code>fs.FSWatcher</code></a>, but it is not the same thing as the <code>'change'</code> value of
-<code>eventType</code>.</p>
-<h3>Caveats<span><a class="mark" href="#fs_caveats" id="fs_caveats">#</a></span></h3>
-
-<p>The <code>fs.watch</code> API is not 100% consistent across platforms, and is
-unavailable in some situations.</p>
-<p>The recursive option is only supported on macOS and Windows.</p>
-<p>On Windows, no events will be emitted if the watched directory is moved or
-renamed. An <code>EPERM</code> error is reported when the watched directory is deleted.</p>
-<h4>Availability<span><a class="mark" href="#fs_availability" id="fs_availability">#</a></span></h4>
-
-<p>This feature depends on the underlying operating system providing a way
-to be notified of filesystem changes.</p>
-<ul>
-<li>On Linux systems, this uses <a href="https://man7.org/linux/man-pages/man7/inotify.7.html"><code>inotify(7)</code></a>.</li>
-<li>On BSD systems, this uses <a href="https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2"><code>kqueue(2)</code></a>.</li>
-<li>On macOS, this uses <a href="https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2"><code>kqueue(2)</code></a> for files and <a href="https://developer.apple.com/documentation/coreservices/file_system_events"><code>FSEvents</code></a> for
-directories.</li>
-<li>On SunOS systems (including Solaris and SmartOS), this uses <a href="https://illumos.org/man/port_create"><code>event ports</code></a>.</li>
-<li>On Windows systems, this feature depends on <a href="https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw"><code>ReadDirectoryChangesW</code></a>.</li>
-<li>On Aix systems, this feature depends on <a href="https://www.ibm.com/developerworks/aix/library/au-aix_event_infrastructure/"><code>AHAFS</code></a>, which must be enabled.</li>
-<li>On IBM i systems, this feature is not supported.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>If the underlying functionality is not available for some reason, then
-<code>fs.watch()</code> will not be able to function and may thrown an exception.
-For example, watching files or directories can be unreliable, and in some
-cases impossible, on network file systems (NFS, SMB, etc) or host file systems
-when using virtualization software such as Vagrant or Docker.</p>
-<p>It is still possible to use <code>fs.watchFile()</code>, which uses stat polling, but
-this method is slower and less reliable.</p>
-<h4>Inodes<span><a class="mark" href="#fs_inodes" id="fs_inodes">#</a></span></h4>
-
-<p>On Linux and macOS systems, <code>fs.watch()</code> resolves the path to an <a href="https://en.wikipedia.org/wiki/Inode">inode</a> and
-watches the inode. If the watched path is deleted and recreated, it is assigned
-a new inode. The watch will emit an event for the delete but will continue
-watching the <em>original</em> inode. Events for the new inode will not be emitted.
-This is expected behavior.</p>
-<p>AIX files retain the same inode for the lifetime of a file. Saving and closing a
-watched file on AIX will result in two notifications (one for adding new
-content, and one for truncation).</p>
-<h4>Filename argument<span><a class="mark" href="#fs_filename_argument" id="fs_filename_argument">#</a></span></h4>
-
-<p>Providing <code>filename</code> argument in the callback is only supported on Linux,
-macOS, Windows, and AIX. Even on supported platforms, <code>filename</code> is not always
-guaranteed to be provided. Therefore, don't assume that <code>filename</code> argument is
-always provided in the callback, and have some fallback logic if it is <code>null</code>.</p>
-<pre><code class="language-js">fs.watch(<span class="hljs-string">'somedir'</span>, <span class="hljs-function">(<span class="hljs-params">eventType, filename</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`event type is: <span class="hljs-subst">${eventType}</span>`</span>);
-  <span class="hljs-keyword">if</span> (filename) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`filename provided: <span class="hljs-subst">${filename}</span>`</span>);
-  } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'filename not provided'</span>);
-  }
-});</code></pre>
-<h2><code>fs.watchFile(filename[, options], listener)</code><span><a class="mark" href="#fs_fs_watchfile_filename_options_listener" id="fs_fs_watchfile_filename_options_listener">#</a></span></h2>
+<p>Synchronous <a href="http://man7.org/linux/man-pages/man3/realpath.3.html"><code>realpath(3)</code></a>.</p>
+<p>Only paths that can be converted to UTF8 strings are supported.</p>
+<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
+object with an <code>encoding</code> property specifying the character encoding to use for
+the path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,
+the path returned will be passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> object.</p>
+<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
+be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
+this restriction.</p>
+<h4><code>fs.renameSync(oldPath, newPath)</code><span><a class="mark" href="#fs_fs_renamesync_oldpath_newpath" id="fs_fs_renamesync_oldpath_newpath">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>oldPath</code> and <code>newPath</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+</ul>
+<p>Renames the file from <code>oldPath</code> to <code>newPath</code>. Returns <code>undefined</code>.</p>
+<p>See the POSIX <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a> documentation for more details.</p>
+<h4><code>fs.rmdirSync(path[, options])</code><span><a class="mark" href="#fs_fs_rmdirsync_path_options" id="fs_fs_rmdirsync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>The <code>bigint</code> option is now supported.</p></td></tr>
+<tr><td>v14.14.0</td>
+<td><p>The <code>recursive</code> option is deprecated, use <code>fs.rmSync</code> instead.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
+<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
+<tr><td>v12.10.0</td>
+<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
 <tr><td>v7.6.0</td>
-<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
-<tr><td>v0.1.31</td>
-<td><p><span>Added in: v0.1.31</span></p></td></tr>
+<td><p>The <code>path</code> parameters can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-<li><code>persistent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>true</code></li>
-<li><code>interval</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>5007</code></li>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js retries the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode, errors are not reported if <code>path</code> does not exist, and
+operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
 </ul>
 </li>
-<li><code>listener</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+</ul>
+<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/rmdir.2.html"><code>rmdir(2)</code></a>. Returns <code>undefined</code>.</p>
+<p>Using <code>fs.rmdirSync()</code> on a file (not a directory) results in an <code>ENOENT</code> error
+on Windows and an <code>ENOTDIR</code> error on POSIX.</p>
+<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command
+<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in
+the future.</p>
+<h4><code>fs.rmSync(path[, options])</code><span><a class="mark" href="#fs_fs_rmsync_path_options" id="fs_fs_rmsync_path_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.14.0</span>
+</div>
 <ul>
-<li><code>current</code> <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
-<li><code>previous</code> <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>force</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, exceptions will be ignored if <code>path</code> does
+not exist. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
+<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
+backoff wait of <code>retryDelay</code> milliseconds longer on each try. This option
+represents the number of retries. This option is ignored if the <code>recursive</code>
+option is not <code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
+recursive mode operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
+retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
+<strong>Default:</strong> <code>100</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
-</ul>
-<p>Watch for changes on <code>filename</code>. The callback <code>listener</code> will be called each
-time the file is accessed.</p>
-<p>The <code>options</code> argument may be omitted. If provided, it should be an object. The
-<code>options</code> object may contain a boolean named <code>persistent</code> that indicates
-whether the process should continue to run as long as files are being watched.
-The <code>options</code> object may specify an <code>interval</code> property indicating how often the
-target should be polled in milliseconds.</p>
-<p>The <code>listener</code> gets two arguments the current stat object and the previous
-stat object:</p>
-<pre><code class="language-js">fs.watchFile(<span class="hljs-string">'message.text'</span>, <span class="hljs-function">(<span class="hljs-params">curr, prev</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`the current mtime is: <span class="hljs-subst">${curr.mtime}</span>`</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`the previous mtime was: <span class="hljs-subst">${prev.mtime}</span>`</span>);
-});</code></pre>
-<p>These stat objects are instances of <code>fs.Stat</code>. If the <code>bigint</code> option is <code>true</code>,
-the numeric values in these objects are specified as <code>BigInt</code>s.</p>
-<p>To be notified when the file was modified, not just accessed, it is necessary
-to compare <code>curr.mtime</code> and <code>prev.mtime</code>.</p>
-<p>When an <code>fs.watchFile</code> operation results in an <code>ENOENT</code> error, it
-will invoke the listener once, with all the fields zeroed (or, for dates, the
-Unix Epoch). If the file is created later on, the listener will be called
-again, with the latest stat objects. This is a change in functionality since
-v0.10.</p>
-<p>Using <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile</code> and
-<code>fs.unwatchFile</code>. <code>fs.watch</code> should be used instead of <code>fs.watchFile</code> and
-<code>fs.unwatchFile</code> when possible.</p>
-<p>When a file being watched by <code>fs.watchFile()</code> disappears and reappears,
-then the contents of <code>previous</code> in the second callback event (the file's
-reappearance) will be the same as the contents of <code>previous</code> in the first
-callback event (its disappearance).</p>
-<p>This happens when:</p>
-<ul>
-<li>the file is deleted, followed by a restore</li>
-<li>the file is renamed and then renamed a second time back to its original name</li>
 </ul>
-<h2><code>fs.write(fd, buffer[, offset[, length[, position]]], callback)</code><span><a class="mark" href="#fs_fs_write_fd_buffer_offset_length_position_callback" id="fs_fs_write_fd_buffer_offset_length_position_callback">#</a></span></h2>
+<p>Synchronously removes files and directories (modeled on the standard POSIX <code>rm</code>
+utility). Returns <code>undefined</code>.</p>
+<h4><code>fs.statSync(path[, options])</code><span><a class="mark" href="#fs_fs_statsync_path_options" id="fs_fs_statsync_path_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.10.0</td>
-<td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code></p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.4.0</td>
-<td><p>The <code>buffer</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
-<tr><td>v7.2.0</td>
-<td><p>The <code>offset</code> and <code>length</code> parameters are optional now.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.0.2</td>
-<td><p><span>Added in: v0.0.2</span></p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>Accepts a <code>throwIfNoEntry</code> option to specify whether an exception should be thrown if the entry does not exist.</p></td></tr>
+<tr><td>v10.5.0</td>
+<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
+<a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>throwIfNoEntry</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether an exception will be thrown
+if no file system entry exists, rather than returning <code>undefined</code>.
+<strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
+<li>Returns: <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a></li>
 </ul>
-<p>Write <code>buffer</code> to the file specified by <code>fd</code>.</p>
-<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is
-an integer specifying the number of bytes to write.</p>
-<p><code>position</code> refers to the offset from the beginning of the file where this data
-should be written. If <code>typeof position !== 'number'</code>, the data will be written
-at the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
-<p>The callback will be given three arguments <code>(err, bytesWritten, buffer)</code> where
-<code>bytesWritten</code> specifies how many <em>bytes</em> were written from <code>buffer</code>.</p>
-<p>If this method is invoked as its <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed version, it returns
-a <code>Promise</code> for an <code>Object</code> with <code>bytesWritten</code> and <code>buffer</code> properties.</p>
-<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting
-for the callback. For this scenario, <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> is
-recommended.</p>
-<p>On Linux, positional writes don't work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<h2><code>fs.write(fd, string[, position[, encoding]], callback)</code><span><a class="mark" href="#fs_fs_write_fd_string_position_encoding_callback" id="fs_fs_write_fd_string_position_encoding_callback">#</a></span></h2>
+<p>Retrieves the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> for the path.</p>
+<h4><code>fs.symlinkSync(target, path[, type])</code><span><a class="mark" href="#fs_fs_symlinksync_target_path_type" id="fs_fs_symlinksync_target_path_type">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.2.0</td>
-<td><p>The <code>position</code> parameter is optional now.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v0.11.5</td>
-<td><p><span>Added in: v0.11.5</span></p></td></tr>
+<tr><td>v12.0.0</td>
+<td><p>If the <code>type</code> argument is left undefined, Node will autodetect <code>target</code> type and automatically select <code>dir</code> or <code>file</code>.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>target</code> and <code>path</code> parameters can be WHATWG <code>URL</code> objects using <code>file:</code> protocol. Support is currently still <em>experimental</em>.</p></td></tr>
+<tr><td>v0.1.31</td>
+<td><p><span>Added in: v0.1.31</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>written</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-</li>
+<p>Returns <code>undefined</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_symlink_target_path_type_callback"><code>fs.symlink()</code></a>.</p>
+<h4><code>fs.truncateSync(path[, len])</code><span><a class="mark" href="#fs_fs_truncatesync_path_len" id="fs_fs_truncatesync_path_len">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.8.6</span>
+</div>
+<ul>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
 </ul>
-<p>Write <code>string</code> to the file specified by <code>fd</code>. If <code>string</code> is not a string, then
-the value will be coerced to one.</p>
-<p><code>position</code> refers to the offset from the beginning of the file where this data
-should be written. If <code>typeof position !== 'number'</code> the data will be written at
-the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
-<p><code>encoding</code> is the expected string encoding.</p>
-<p>The callback will receive the arguments <code>(err, written, string)</code> where <code>written</code>
-specifies how many <em>bytes</em> the passed string required to be written. Bytes
-written is not necessarily the same as string characters written. See
-<a href="buffer.html#buffer_static_method_buffer_bytelength_string_encoding"><code>Buffer.byteLength</code></a>.</p>
-<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting
-for the callback. For this scenario, <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> is
-recommended.</p>
-<p>On Linux, positional writes don't work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<p>On Windows, if the file descriptor is connected to the console (e.g. <code>fd == 1</code>
-or <code>stdout</code>) a string containing non-ASCII characters will not be rendered
-properly by default, regardless of the encoding used.
-It is possible to configure the console to render UTF-8 properly by changing the
-active codepage with the <code>chcp 65001</code> command. See the <a href="https://ss64.com/nt/chcp.html">chcp</a> docs for more
-details.</p>
-<h2><code>fs.writeFile(file, data[, options], callback)</code><span><a class="mark" href="#fs_fs_writefile_file_data_options_callback" id="fs_fs_writefile_file_data_options_callback">#</a></span></h2>
+<p>Truncates the file. Returns <code>undefined</code>. A file descriptor can also be
+passed as the first argument. In this case, <code>fs.ftruncateSync()</code> is called.</p>
+<p>Passing a file descriptor is deprecated and may result in an error being thrown
+in the future.</p>
+<h4><code>fs.unlinkSync(path)</code><span><a class="mark" href="#fs_fs_unlinksync_path" id="fs_fs_unlinksync_path">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.10.0</td>
-<td><p>The <code>data</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will throw a <code>TypeError</code> at runtime.</p></td></tr>
-<tr><td>v7.4.0</td>
-<td><p>The <code>data</code> parameter can now be a <code>Uint8Array</code>.</p></td></tr>
-<tr><td>v7.0.0</td>
-<td><p>The <code>callback</code> parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013.</p></td></tr>
-<tr><td>v5.0.0</td>
-<td><p>The <code>file</code> parameter can be a file descriptor now.</p></td></tr>
-<tr><td>v0.1.29</td>
-<td><p><span>Added in: v0.1.29</span></p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
-<li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
 </ul>
-</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<p>Synchronous <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>. Returns <code>undefined</code>.</p>
+<h4><code>fs.utimesSync(path, atime, mtime)</code><span><a class="mark" href="#fs_fs_utimessync_path_atime_mtime" id="fs_fs_utimessync_path_atime_mtime">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v8.0.0</td>
+<td><p><code>NaN</code>, <code>Infinity</code>, and <code>-Infinity</code> are no longer valid time specifiers.</p></td></tr>
+<tr><td>v7.6.0</td>
+<td><p>The <code>path</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
+<tr><td>v4.1.0</td>
+<td><p>Numeric strings, <code>NaN</code> and <code>Infinity</code> are now allowed time specifiers.</p></td></tr>
+<tr><td>v0.4.2</td>
+<td><p><span>Added in: v0.4.2</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
 <ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-</ul>
-</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
+<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>When <code>file</code> is a filename, asynchronously writes data to the file, replacing the
-file if it already exists.  <code>data</code> can be a string or a buffer.</p>
-<p>When <code>file</code> is a file descriptor, the behavior is similar to calling
-<code>fs.write()</code> directly (which is recommended). See the notes below on using
-a file descriptor.</p>
-<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> data = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(Buffer.from(<span class="hljs-string">'Hello Node.js'</span>));
-fs.writeFile(<span class="hljs-string">'message.txt'</span>, data, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The file has been saved!'</span>);
-});</code></pre>
-<p>If <code>options</code> is a string, then it specifies the encoding:</p>
-<pre><code class="language-js">fs.writeFile(<span class="hljs-string">'message.txt'</span>, <span class="hljs-string">'Hello Node.js'</span>, <span class="hljs-string">'utf8'</span>, callback);</code></pre>
-<p>It is unsafe to use <code>fs.writeFile()</code> multiple times on the same file without
-waiting for the callback. For this scenario, <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> is
-recommended.</p>
-<h3>Using <code>fs.writeFile()</code> with file descriptors<span><a class="mark" href="#fs_using_fs_writefile_with_file_descriptors" id="fs_using_fs_writefile_with_file_descriptors">#</a></span></h3>
-<p>When <code>file</code> is a file descriptor, the behavior is almost identical to directly
-calling <code>fs.write()</code> like:</p>
-<pre><code class="language-js">fs.write(fd, Buffer.from(data, options.encoding), callback);</code></pre>
-<p>The difference from directly calling <code>fs.write()</code> is that under some unusual
-conditions, <code>fs.write()</code> may write only part of the buffer and will need to be
-retried to write the remaining data, whereas <code>fs.writeFile()</code> will retry until
-the data is entirely written (or an error occurs).</p>
-<p>The implications of this are a common source of confusion. In
-the file descriptor case, the file is not replaced! The data is not necessarily
-written to the beginning of the file, and the file's original data may remain
-before and/or after the newly written data.</p>
-<p>For example, if <code>fs.writeFile()</code> is called twice in a row, first to write the
-string <code>'Hello'</code>, then to write the string <code>', World'</code>, the file would contain
-<code>'Hello, World'</code>, and might contain some of the file's original data (depending
-on the size of the original file, and the position of the file descriptor). If
-a file name had been used instead of a descriptor, the file would be guaranteed
-to contain only <code>', World'</code>.</p>
-<h2><code>fs.writeFileSync(file, data[, options])</code><span><a class="mark" href="#fs_fs_writefilesync_file_data_options" id="fs_fs_writefilesync_file_data_options">#</a></span></h2>
+<p>Returns <code>undefined</code>.</p>
+<p>For detailed information, see the documentation of the asynchronous version of
+this API: <a href="#fs_fs_utimes_path_atime_mtime_callback"><code>fs.utimes()</code></a>.</p>
+<h4><code>fs.writeFileSync(file, data[, options])</code><span><a class="mark" href="#fs_fs_writefilesync_file_data_options" id="fs_fs_writefilesync_file_data_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>data</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>data</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>data</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v7.4.0</td>
@@ -4471,7 +5180,7 @@ to contain only <code>', World'</code>.</p>
 </div>
 <ul>
 <li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> filename or file descriptor</li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
 <ul>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
@@ -4481,13 +5190,21 @@ to contain only <code>', World'</code>.</p>
 </li>
 </ul>
 <p>Returns <code>undefined</code>.</p>
+<p>If <code>data</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
+<p>The <code>mode</code> option only affects the newly created file. See <a href="#fs_fs_open_path_flags_mode_callback"><code>fs.open()</code></a>
+for more details.</p>
 <p>For detailed information, see the documentation of the asynchronous version of
 this API: <a href="#fs_fs_writefile_file_data_options_callback"><code>fs.writeFile()</code></a>.</p>
-<h2><code>fs.writeSync(fd, buffer[, offset[, length[, position]]])</code><span><a class="mark" href="#fs_fs_writesync_fd_buffer_offset_length_position" id="fs_fs_writesync_fd_buffer_offset_length_position">#</a></span></h2>
+<h4><code>fs.writeSync(fd, buffer[, offset[, length[, position]]])</code><span><a class="mark" href="#fs_fs_writesync_fd_buffer_offset_length_position" id="fs_fs_writesync_fd_buffer_offset_length_position">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>buffer</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>buffer</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>The <code>buffer</code> parameter can now be any <code>TypedArray</code> or a <code>DataView</code>.</p></td></tr>
 <tr><td>v7.4.0</td>
@@ -4501,19 +5218,25 @@ this API: <a href="#fs_fs_writefile_file_data_options_callback"><code>fs.writeFi
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
+<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes written.</li>
 </ul>
+<p>If <code>buffer</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
 <p>For detailed information, see the documentation of the asynchronous version of
 this API: <a href="#fs_fs_write_fd_buffer_offset_length_position_callback"><code>fs.write(fd, buffer...)</code></a>.</p>
-<h2><code>fs.writeSync(fd, string[, position[, encoding]])</code><span><a class="mark" href="#fs_fs_writesync_fd_string_position_encoding" id="fs_fs_writesync_fd_string_position_encoding">#</a></span></h2>
+<h4><code>fs.writeSync(fd, string[, position[, encoding]])</code><span><a class="mark" href="#fs_fs_writesync_fd_string_position_encoding" id="fs_fs_writesync_fd_string_position_encoding">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.12.0</td>
+<td><p>The <code>string</code> parameter will stringify an object with an explicit <code>toString</code> function.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>string</code> parameter won't coerce unsupported input to strings anymore.</p></td></tr>
 <tr><td>v7.2.0</td>
 <td><p>The <code>position</code> parameter is optional now.</p></td></tr>
 <tr><td>v0.11.5</td>
@@ -4523,44 +5246,16 @@ this API: <a href="#fs_fs_write_fd_buffer_offset_length_position_callback"><code
 </div>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of bytes written.</li>
 </ul>
+<p>If <code>string</code> is a plain object, it must have an own (not inherited) <code>toString</code>
+function property.</p>
 <p>For detailed information, see the documentation of the asynchronous version of
 this API: <a href="#fs_fs_write_fd_string_position_encoding_callback"><code>fs.write(fd, string...)</code></a>.</p>
-<h2><code>fs.writev(fd, buffers[, position], callback)</code><span><a class="mark" href="#fs_fs_writev_fd_buffers_position_callback" id="fs_fs_writev_fd_buffers_position_callback">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.9.0</span>
-</div>
-<ul>
-<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>bytesWritten</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-</ul>
-</li>
-</ul>
-<p>Write an array of <code>ArrayBufferView</code>s to the file specified by <code>fd</code> using
-<code>writev()</code>.</p>
-<p><code>position</code> is the offset from the beginning of the file where this data
-should be written. If <code>typeof position !== 'number'</code>, the data will be written
-at the current position.</p>
-<p>The callback will be given three arguments: <code>err</code>, <code>bytesWritten</code>, and
-<code>buffers</code>. <code>bytesWritten</code> is how many bytes were written from <code>buffers</code>.</p>
-<p>If this method is <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>ed, it returns a <code>Promise</code> for an
-<code>Object</code> with <code>bytesWritten</code> and <code>buffers</code> properties.</p>
-<p>It is unsafe to use <code>fs.writev()</code> multiple times on the same file without
-waiting for the callback. For this scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
-<p>On Linux, positional writes don't work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<h2><code>fs.writevSync(fd, buffers[, position])</code><span><a class="mark" href="#fs_fs_writevsync_fd_buffers_position" id="fs_fs_writevsync_fd_buffers_position">#</a></span></h2>
+<h4><code>fs.writevSync(fd, buffers[, position])</code><span><a class="mark" href="#fs_fs_writevsync_fd_buffers_position" id="fs_fs_writevsync_fd_buffers_position">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -4572,975 +5267,786 @@ the end of the file.</p>
 </ul>
 <p>For detailed information, see the documentation of the asynchronous version of
 this API: <a href="#fs_fs_writev_fd_buffers_position_callback"><code>fs.writev()</code></a>.</p>
-<h2><code>fs</code> Promises API<span><a class="mark" href="#fs_fs_promises_api" id="fs_fs_promises_api">#</a></span></h2>
-<p>The <code>fs.promises</code> API provides an alternative set of asynchronous file system
-methods that return <code>Promise</code> objects rather than using callbacks. The
-API is accessible via <code>require('fs').promises</code>.</p>
-<h3>Class: <code>FileHandle</code><span><a class="mark" href="#fs_class_filehandle" id="fs_class_filehandle">#</a></span></h3>
+</section><section><h3>Common Objects<span><a class="mark" href="#fs_common_objects" id="fs_common_objects">#</a></span></h3>
+<p>The common objects are shared by all of the file system API variants
+(promise, callback, and synchronous).</p>
+<h4>Class: <code>fs.Dir</code><span><a class="mark" href="#fs_class_fs_dir" id="fs_class_fs_dir">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v12.12.0</span>
 </div>
-<p>A <code>FileHandle</code> object is a wrapper for a numeric file descriptor.
-Instances of <code>FileHandle</code> are distinct from numeric file descriptors
-in that they provide an object oriented API for working with files.</p>
-<p>If a <code>FileHandle</code> is not closed using the
-<code>filehandle.close()</code> method, it might automatically close the file descriptor
-and will emit a process warning, thereby helping to prevent memory leaks.
-Please do not rely on this behavior because it is unreliable and
-the file may not be closed. Instead, always explicitly close <code>FileHandle</code>s.
-Node.js may change this behavior in the future.</p>
-<p>Instances of the <code>FileHandle</code> object are created internally by the
-<code>fsPromises.open()</code> method.</p>
-<p>Unlike the callback-based API (<code>fs.fstat()</code>, <code>fs.fchown()</code>, <code>fs.fchmod()</code>, and
-so on), a numeric file descriptor is not used by the promise-based API. Instead,
-the promise-based API uses the <code>FileHandle</code> class in order to help avoid
-accidental leaking of unclosed file descriptors after a <code>Promise</code> is resolved or
-rejected.</p>
-<h4><code>filehandle.appendFile(data, options)</code><span><a class="mark" href="#fs_filehandle_appendfile_data_options" id="fs_filehandle_appendfile_data_options">#</a></span></h4>
+<p>A class representing a directory stream.</p>
+<p>Created by <a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir()</code></a>, <a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync()</code></a>, or
+<a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir()</code></a>.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { opendir } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">const</span> dir = <span class="hljs-keyword">await</span> <span class="hljs-title function_">opendir</span>(<span class="hljs-string">'./'</span>);
+  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> dirent <span class="hljs-keyword">of</span> dir)
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(dirent.<span class="hljs-property">name</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+}</code></pre>
+<p>When using the async iterator, the <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a> object will be automatically
+closed after the iterator exits.</p>
+<h5><code>dir.close()</code><span><a class="mark" href="#fs_dir_close" id="fs_dir_close">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v12.12.0</span>
 </div>
 <ul>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Alias of <a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile()</code></a>.</p>
-<p>When operating on file handles, the mode cannot be changed from what it was set
-to with <a href="#fs_fspromises_open_path_flags_mode"><code>fsPromises.open()</code></a>. Therefore, this is equivalent to
-<a href="#fs_filehandle_writefile_data_options"><code>filehandle.writeFile()</code></a>.</p>
-<h4><code>filehandle.chmod(mode)</code><span><a class="mark" href="#fs_filehandle_chmod_mode" id="fs_filehandle_chmod_mode">#</a></span></h4>
+<p>Asynchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.</p>
+<p>A promise is returned that will be resolved after the resource has been
+closed.</p>
+<h5><code>dir.close(callback)</code><span><a class="mark" href="#fs_dir_close_callback" id="fs_dir_close_callback">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v12.12.0</span>
 </div>
 <ul>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
-<p>Modifies the permissions on the file. The <code>Promise</code> is resolved with no
-arguments upon success.</p>
-<h4><code>filehandle.chown(uid, gid)</code><span><a class="mark" href="#fs_filehandle_chown_uid_gid" id="fs_filehandle_chown_uid_gid">#</a></span></h4>
+</li>
+</ul>
+<p>Asynchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.</p>
+<p>The <code>callback</code> will be called after the resource handle has been closed.</p>
+<h5><code>dir.closeSync()</code><span><a class="mark" href="#fs_dir_closesync" id="fs_dir_closesync">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v12.12.0</span>
 </div>
-<ul>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
-</ul>
-<p>Changes the ownership of the file then resolves the <code>Promise</code> with no arguments
-upon success.</p>
-<h4><code>filehandle.close()</code><span><a class="mark" href="#fs_filehandle_close" id="fs_filehandle_close">#</a></span></h4>
+<p>Synchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.</p>
+<h5><code>dir.path</code><span><a class="mark" href="#fs_dir_path" id="fs_dir_path">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v12.12.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> A <code>Promise</code> that will be resolved once the underlying
-file descriptor is closed, or will be rejected if an error occurs while
-closing.</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>Closes the file descriptor.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).promises;
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">openAndClose</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">let</span> filehandle;
-  <span class="hljs-keyword">try</span> {
-    filehandle = <span class="hljs-keyword">await</span> fsPromises.open(<span class="hljs-string">'thefile.txt'</span>, <span class="hljs-string">'r'</span>);
-  } <span class="hljs-keyword">finally</span> {
-    <span class="hljs-keyword">if</span> (filehandle !== <span class="hljs-literal">undefined</span>)
-      <span class="hljs-keyword">await</span> filehandle.close();
-  }
-}</code></pre>
-<h4><code>filehandle.datasync()</code><span><a class="mark" href="#fs_filehandle_datasync" id="fs_filehandle_datasync">#</a></span></h4>
+<p>The read-only path of this directory as was provided to <a href="#fs_fs_opendir_path_options_callback"><code>fs.opendir()</code></a>,
+<a href="#fs_fs_opendirsync_path_options"><code>fs.opendirSync()</code></a>, or <a href="#fs_fspromises_opendir_path_options"><code>fsPromises.opendir()</code></a>.</p>
+<h5><code>dir.read()</code><span><a class="mark" href="#fs_dir_read" id="fs_dir_read">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v12.12.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> containing <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fdatasync.2.html"><code>fdatasync(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon
-success.</p>
-<h4><code>filehandle.fd</code><span><a class="mark" href="#fs_filehandle_fd" id="fs_filehandle_fd">#</a></span></h4>
+<p>Asynchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
+<a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>.</p>
+<p>A promise is returned that will be resolved with an <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>, or <code>null</code>
+if there are no more directory entries to read.</p>
+<p>Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.</p>
+<h5><code>dir.read(callback)</code><span><a class="mark" href="#fs_dir_read_callback" id="fs_dir_read_callback">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v12.12.0</span>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The numeric file descriptor managed by the <code>FileHandle</code> object.</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>dirent</code> <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
+</ul>
+</li>
 </ul>
-<h4><code>filehandle.read(buffer, offset, length, position)</code><span><a class="mark" href="#fs_filehandle_read_buffer_offset_length_position" id="fs_filehandle_read_buffer_offset_length_position">#</a></span></h4>
+<p>Asynchronously read the next directory entry via <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> as an
+<a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>.</p>
+<p>After the read is completed, the <code>callback</code> will be called with an
+<a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>, or <code>null</code> if there are no more directory entries to read.</p>
+<p>Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.</p>
+<h5><code>dir.readSync()</code><span><a class="mark" href="#fs_dir_readsync" id="fs_dir_readsync">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v12.12.0</span>
 </div>
 <ul>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a></li>
 </ul>
-<p>Read data from the file.</p>
-<p><code>buffer</code> is the buffer that the data will be written to.</p>
-<p><code>offset</code> is the offset in the buffer to start writing at.</p>
-<p><code>length</code> is an integer specifying the number of bytes to read.</p>
-<p><code>position</code> is an argument specifying where to begin reading from in the file.
-If <code>position</code> is <code>null</code>, data will be read from the current file position,
-and the file position will be updated.
-If <code>position</code> is an integer, the file position will remain unchanged.</p>
-<p>Following successful read, the <code>Promise</code> is resolved with an object with a
-<code>bytesRead</code> property specifying the number of bytes read, and a <code>buffer</code>
-property that is a reference to the passed in <code>buffer</code> argument.</p>
-<h4><code>filehandle.read(options)</code><span><a class="mark" href="#fs_filehandle_read_options" id="fs_filehandle_read_options">#</a></span></h4>
+<p>Synchronously read the next directory entry as an <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>. See the
+POSIX <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> documentation for more detail.</p>
+<p>If there are no more directory entries to read, <code>null</code> will be returned.</p>
+<p>Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.</p>
+<h5><code>dir[Symbol.asyncIterator]()</code><span><a class="mark" href="#fs_dir_symbol_asynciterator" id="fs_dir_symbol_asynciterator">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v12.12.0</span>
 </div>
 <ul>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a> <strong>Default:</strong> <code>Buffer.alloc(16384)</code></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>buffer.length</code></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>null</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterator-interface" class="type">&#x3C;AsyncIterator></a> of <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a></li>
 </ul>
-<h4><code>filehandle.readFile(options)</code><span><a class="mark" href="#fs_filehandle_readfile_options" id="fs_filehandle_readfile_options">#</a></span></h4>
+<p>Asynchronously iterates over the directory until all entries have
+been read. Refer to the POSIX <a href="http://man7.org/linux/man-pages/man3/readdir.3.html"><code>readdir(3)</code></a> documentation for more detail.</p>
+<p>Entries returned by the async iterator are always an <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a>.
+The <code>null</code> case from <code>dir.read()</code> is handled internally.</p>
+<p>See <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a> for an example.</p>
+<p>Directory entries returned by this iterator are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.</p>
+<h4>Class: <code>fs.Dirent</code><span><a class="mark" href="#fs_class_fs_dirent" id="fs_class_fs_dirent">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v10.10.0</span>
+</div>
+<p>A representation of a directory entry, which can be a file or a subdirectory
+within the directory, as returned by reading from an <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a>. The
+directory entry is a combination of the file name and file type pairs.</p>
+<p>Additionally, when <a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir()</code></a> or <a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync()</code></a> is called with
+the <code>withFileTypes</code> option set to <code>true</code>, the resulting array is filled with
+<a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> objects, rather than strings or <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>s.</p>
+<h5><code>dirent.isBlockDevice()</code><span><a class="mark" href="#fs_dirent_isblockdevice" id="fs_dirent_isblockdevice">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v10.10.0</span>
 </div>
 <ul>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronously reads the entire contents of a file.</p>
-<p>The <code>Promise</code> is resolved with the contents of the file. If no encoding is
-specified (using <code>options.encoding</code>), the data is returned as a <code>Buffer</code>
-object. Otherwise, the data will be a string.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>The <code>FileHandle</code> has to support reading.</p>
-<p>If one or more <code>filehandle.read()</code> calls are made on a file handle and then a
-<code>filehandle.readFile()</code> call is made, the data will be read from the current
-position till the end of the file. It doesn't always read from the beginning
-of the file.</p>
-<h4><code>filehandle.readv(buffers[, position])</code><span><a class="mark" href="#fs_filehandle_readv_buffers_position" id="fs_filehandle_readv_buffers_position">#</a></span></h4>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a block device.</p>
+<h5><code>dirent.isCharacterDevice()</code><span><a class="mark" href="#fs_dirent_ischaracterdevice" id="fs_dirent_ischaracterdevice">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v10.10.0</span>
 </div>
 <ul>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Read from a file and write to an array of <code>ArrayBufferView</code>s</p>
-<p>The <code>Promise</code> is resolved with an object containing a <code>bytesRead</code> property
-identifying the number of bytes read, and a <code>buffers</code> property containing
-a reference to the <code>buffers</code> input.</p>
-<p><code>position</code> is the offset from the beginning of the file where this data
-should be read from. If <code>typeof position !== 'number'</code>, the data will be read
-from the current position.</p>
-<h4><code>filehandle.stat([options])</code><span><a class="mark" href="#fs_filehandle_stat_options" id="fs_filehandle_stat_options">#</a></span></h4>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a character device.</p>
+<h5><code>dirent.isDirectory()</code><span><a class="mark" href="#fs_dirent_isdirectory" id="fs_dirent_isdirectory">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v10.10.0</span>
 </div>
 <ul>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Retrieves the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> for the file.</p>
-<h4><code>filehandle.sync()</code><span><a class="mark" href="#fs_filehandle_sync" id="fs_filehandle_sync">#</a></span></h4>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a file system
+directory.</p>
+<h5><code>dirent.isFIFO()</code><span><a class="mark" href="#fs_dirent_isfifo" id="fs_dirent_isfifo">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v10.10.0</span>
 </div>
 <ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/fsync.2.html"><code>fsync(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon
-success.</p>
-<h4><code>filehandle.truncate(len)</code><span><a class="mark" href="#fs_filehandle_truncate_len" id="fs_filehandle_truncate_len">#</a></span></h4>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a first-in-first-out
+(FIFO) pipe.</p>
+<h5><code>dirent.isFile()</code><span><a class="mark" href="#fs_dirent_isfile" id="fs_dirent_isfile">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v10.10.0</span>
 </div>
 <ul>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Truncates the file then resolves the <code>Promise</code> with no arguments upon success.</p>
-<p>If the file was larger than <code>len</code> bytes, only the first <code>len</code> bytes will be
-retained in the file.</p>
-<p>For example, the following program retains only the first four bytes of the
-file:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fsPromises = fs.promises;
-
-<span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-<span class="hljs-comment">// Prints: Node.js</span>
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">doTruncate</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">let</span> filehandle = <span class="hljs-literal">null</span>;
-  <span class="hljs-keyword">try</span> {
-    filehandle = <span class="hljs-keyword">await</span> fsPromises.open(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
-    <span class="hljs-keyword">await</span> filehandle.truncate(<span class="hljs-number">4</span>);
-  } <span class="hljs-keyword">finally</span> {
-    <span class="hljs-keyword">if</span> (filehandle) {
-      <span class="hljs-comment">// Close the file if it is opened.</span>
-      <span class="hljs-keyword">await</span> filehandle.close();
-    }
-  }
-  <span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));  <span class="hljs-comment">// Prints: Node</span>
-}
-
-doTruncate().catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the
-extended part is filled with null bytes (<code>'\0'</code>):</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fsPromises = fs.promises;
-
-<span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));
-<span class="hljs-comment">// Prints: Node.js</span>
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">doTruncate</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">let</span> filehandle = <span class="hljs-literal">null</span>;
-  <span class="hljs-keyword">try</span> {
-    filehandle = <span class="hljs-keyword">await</span> fsPromises.open(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'r+'</span>);
-    <span class="hljs-keyword">await</span> filehandle.truncate(<span class="hljs-number">10</span>);
-  } <span class="hljs-keyword">finally</span> {
-    <span class="hljs-keyword">if</span> (filehandle) {
-      <span class="hljs-comment">// Close the file if it is opened.</span>
-      <span class="hljs-keyword">await</span> filehandle.close();
-    }
-  }
-  <span class="hljs-built_in">console</span>.log(fs.readFileSync(<span class="hljs-string">'temp.txt'</span>, <span class="hljs-string">'utf8'</span>));  <span class="hljs-comment">// Prints Node.js\0\0\0</span>
-}
-
-doTruncate().catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<p>The last three bytes are null bytes (<code>'\0'</code>), to compensate the over-truncation.</p>
-<h4><code>filehandle.utimes(atime, mtime)</code><span><a class="mark" href="#fs_filehandle_utimes_atime_mtime" id="fs_filehandle_utimes_atime_mtime">#</a></span></h4>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a regular file.</p>
+<h5><code>dirent.isSocket()</code><span><a class="mark" href="#fs_dirent_issocket" id="fs_dirent_issocket">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v10.10.0</span>
 </div>
 <ul>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Change the file system timestamps of the object referenced by the <code>FileHandle</code>
-then resolves the <code>Promise</code> with no arguments upon success.</p>
-<p>This function does not work on AIX versions before 7.1, it will resolve the
-<code>Promise</code> with an error using code <code>UV_ENOSYS</code>.</p>
-<h4><code>filehandle.write(buffer[, offset[, length[, position]]])</code><span><a class="mark" href="#fs_filehandle_write_buffer_offset_length_position" id="fs_filehandle_write_buffer_offset_length_position">#</a></span></h4>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a socket.</p>
+<h5><code>dirent.isSymbolicLink()</code><span><a class="mark" href="#fs_dirent_issymboliclink" id="fs_dirent_issymboliclink">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v10.10.0</span>
 </div>
 <ul>
-<li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
-<li><code>offset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Write <code>buffer</code> to the file.</p>
-<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property
-identifying the number of bytes written, and a <code>buffer</code> property containing
-a reference to the <code>buffer</code> written.</p>
-<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is
-an integer specifying the number of bytes to write.</p>
-<p><code>position</code> refers to the offset from the beginning of the file where this data
-should be written. If <code>typeof position !== 'number'</code>, the data will be written
-at the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
-<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file
-without waiting for the <code>Promise</code> to be resolved (or rejected). For this
-scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
-<p>On Linux, positional writes do not work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<h4><code>filehandle.write(string[, position[, encoding]])</code><span><a class="mark" href="#fs_filehandle_write_string_position_encoding" id="fs_filehandle_write_string_position_encoding">#</a></span></h4>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object describes a symbolic link.</p>
+<h5><code>dirent.name</code><span><a class="mark" href="#fs_dirent_name" id="fs_dirent_name">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v10.10.0</span>
 </div>
 <ul>
-<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Write <code>string</code> to the file. If <code>string</code> is not a string, then
-the value will be coerced to one.</p>
-<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property
-identifying the number of bytes written, and a <code>buffer</code> property containing
-a reference to the <code>string</code> written.</p>
-<p><code>position</code> refers to the offset from the beginning of the file where this data
-should be written. If the type of <code>position</code> is not a <code>number</code> the data
-will be written at the current position. See <a href="http://man7.org/linux/man-pages/man2/pwrite.2.html"><code>pwrite(2)</code></a>.</p>
-<p><code>encoding</code> is the expected string encoding.</p>
-<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file
-without waiting for the <code>Promise</code> to be resolved (or rejected). For this
-scenario, use <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>.</p>
-<p>On Linux, positional writes do not work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<h4><code>filehandle.writeFile(data, options)</code><span><a class="mark" href="#fs_filehandle_writefile_data_options" id="fs_filehandle_writefile_data_options">#</a></span></h4>
+<p>The file name that this <a href="fs.html#fs_class_fs_dirent" class="type">&#x3C;fs.Dirent></a> object refers to. The type of this
+value is determined by the <code>options.encoding</code> passed to <a href="#fs_fs_readdir_path_options_callback"><code>fs.readdir()</code></a> or
+<a href="#fs_fs_readdirsync_path_options"><code>fs.readdirSync()</code></a>.</p>
+<h4>Class: <code>fs.FSWatcher</code><span><a class="mark" href="#fs_class_fs_fswatcher" id="fs_class_fs_fswatcher">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.5.8</span>
 </div>
 <ul>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Extends <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
-<p>Asynchronously writes data to a file, replacing the file if it already exists.
-<code>data</code> can be a string or a buffer. The <code>Promise</code> will be resolved with no
-arguments upon success.</p>
-<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>The <code>FileHandle</code> has to support writing.</p>
-<p>It is unsafe to use <code>filehandle.writeFile()</code> multiple times on the same file
-without waiting for the <code>Promise</code> to be resolved (or rejected).</p>
-<p>If one or more <code>filehandle.write()</code> calls are made on a file handle and then a
-<code>filehandle.writeFile()</code> call is made, the data will be written from the
-current position till the end of the file. It doesn't always write from the
-beginning of the file.</p>
-<h4><code>filehandle.writev(buffers[, position])</code><span><a class="mark" href="#fs_filehandle_writev_buffers_position" id="fs_filehandle_writev_buffers_position">#</a></span></h4>
+<p>A successful call to <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a> method will return a new <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a>
+object.</p>
+<p>All <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> objects emit a <code>'change'</code> event whenever a specific watched
+file is modified.</p>
+<h5>Event: <code>'change'</code><span><a class="mark" href="#fs_event_change" id="fs_event_change">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.9.0</span>
+<span>Added in: v0.5.8</span>
 </div>
 <ul>
-<li><code>buffers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView" class="type">&#x3C;ArrayBufferView[]></a></li>
-<li><code>position</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>eventType</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The type of change event that has occurred</li>
+<li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The filename that changed (if relevant/available)</li>
 </ul>
-<p>Write an array of <code>ArrayBufferView</code>s to the file.</p>
-<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property
-identifying the number of bytes written, and a <code>buffers</code> property containing
-a reference to the <code>buffers</code> input.</p>
-<p><code>position</code> is the offset from the beginning of the file where this data
-should be written. If <code>typeof position !== 'number'</code>, the data will be written
-at the current position.</p>
-<p>It is unsafe to call <code>writev()</code> multiple times on the same file without waiting
-for the previous operation to complete.</p>
-<p>On Linux, positional writes don't work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.</p>
-<h3><code>fsPromises.access(path[, mode])</code><span><a class="mark" href="#fs_fspromises_access_path_mode" id="fs_fspromises_access_path_mode">#</a></span></h3>
+<p>Emitted when something changes in a watched directory or file.
+See more details in <a href="#fs_fs_watch_filename_options_listener"><code>fs.watch()</code></a>.</p>
+<p>The <code>filename</code> argument may not be provided depending on operating system
+support. If <code>filename</code> is provided, it will be provided as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> if
+<code>fs.watch()</code> is called with its <code>encoding</code> option set to <code>'buffer'</code>, otherwise
+<code>filename</code> will be a UTF-8 string.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { watch } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// Example when handled through fs.watch() listener</span>
+<span class="hljs-title function_">watch</span>(<span class="hljs-string">'./tmp'</span>, { <span class="hljs-attr">encoding</span>: <span class="hljs-string">'buffer'</span> }, <span class="hljs-function">(<span class="hljs-params">eventType, filename</span>) =></span> {
+  <span class="hljs-keyword">if</span> (filename) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(filename);
+    <span class="hljs-comment">// Prints: &#x3C;Buffer ...></span>
+  }
+});</code></pre>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close" id="fs_event_close">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
+<p>Emitted when the watcher stops watching for changes. The closed
+<a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object is no longer usable in the event handler.</p>
+<h5>Event: <code>'error'</code><span><a class="mark" href="#fs_event_error" id="fs_event_error">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.5.8</span>
+</div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>fs.constants.F_OK</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
-<p>Tests a user's permissions for the file or directory specified by <code>path</code>.
-The <code>mode</code> argument is an optional integer that specifies the accessibility
-checks to be performed. Check <a href="#fs_file_access_constants">File access constants</a> for possible values
-of <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of
-two or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>
-<p>If the accessibility check is successful, the <code>Promise</code> is resolved with no
-value. If any of the accessibility checks fail, the <code>Promise</code> is rejected
-with an <code>Error</code> object. The following example checks if the file
-<code>/etc/passwd</code> can be read and written by the current process.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fsPromises = fs.promises;
-
-fsPromises.access(<span class="hljs-string">'/etc/passwd'</span>, fs.constants.R_OK | fs.constants.W_OK)
-  .then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'can access'</span>))
-  .catch(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'cannot access'</span>));</code></pre>
-<p>Using <code>fsPromises.access()</code> to check for the accessibility of a file before
-calling <code>fsPromises.open()</code> is not recommended. Doing so introduces a race
-condition, since other processes may change the file's state between the two
-calls. Instead, user code should open/read/write the file directly and handle
-the error raised if the file is not accessible.</p>
-<h3><code>fsPromises.appendFile(path, data[, options])</code><span><a class="mark" href="#fs_fspromises_appendfile_path_data_options" id="fs_fspromises_appendfile_path_data_options">#</a></span></h3>
+<p>Emitted when an error occurs while watching the file. The errored
+<a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object is no longer usable in the event handler.</p>
+<h5><code>watcher.close()</code><span><a class="mark" href="#fs_watcher_close" id="fs_watcher_close">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.5.8</span>
+</div>
+<p>Stop watching for changes on the given <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a>. Once stopped, the
+<a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object is no longer usable.</p>
+<h5><code>watcher.ref()</code><span><a class="mark" href="#fs_watcher_ref" id="fs_watcher_ref">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.3.0, v12.20.0</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'a'</code>.</li>
+<li>Returns: <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the
+<a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> is active. Calling <code>watcher.ref()</code> multiple times will have
+no effect.</p>
+<p>By default, all <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> objects are "ref'ed", making it normally
+unnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been
+called previously.</p>
+<h5><code>watcher.unref()</code><span><a class="mark" href="#fs_watcher_unref" id="fs_watcher_unref">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.3.0, v12.20.0</span>
+</div>
+<ul>
+<li>Returns: <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a></li>
 </ul>
-<p>Asynchronously append data to a file, creating the file if it does not yet
-exist. <code>data</code> can be a string or a <a href="buffer.html#buffer_buffer"><code>Buffer</code></a>. The <code>Promise</code> will be
-resolved with no arguments upon success.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>The <code>path</code> may be specified as a <code>FileHandle</code> that has been opened
-for appending (using <code>fsPromises.open()</code>).</p>
-<h3><code>fsPromises.chmod(path, mode)</code><span><a class="mark" href="#fs_fspromises_chmod_path_mode" id="fs_fspromises_chmod_path_mode">#</a></span></h3>
+<p>When called, the active <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object will not require the Node.js
+event loop to remain active. If there is no other activity keeping the
+event loop running, the process may exit before the <a href="fs.html#fs_class_fs_fswatcher" class="type">&#x3C;fs.FSWatcher></a> object's
+callback is invoked. Calling <code>watcher.unref()</code> multiple times will have
+no effect.</p>
+<h4>Class: <code>fs.StatWatcher</code><span><a class="mark" href="#fs_class_fs_statwatcher" id="fs_class_fs_statwatcher">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v14.3.0, v12.20.0</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Extends <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
-<p>Changes the permissions of a file then resolves the <code>Promise</code> with no
-arguments upon succces.</p>
-<h3><code>fsPromises.chown(path, uid, gid)</code><span><a class="mark" href="#fs_fspromises_chown_path_uid_gid" id="fs_fspromises_chown_path_uid_gid">#</a></span></h3>
+<p>A successful call to <code>fs.watchFile()</code> method will return a new <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a>
+object.</p>
+<h5><code>watcher.ref()</code><span><a class="mark" href="#fs_watcher_ref_1" id="fs_watcher_ref_1">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v14.3.0, v12.20.0</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
 </ul>
-<p>Changes the ownership of a file then resolves the <code>Promise</code> with no arguments
-upon success.</p>
-<h3><code>fsPromises.copyFile(src, dest[, flags])</code><span><a class="mark" href="#fs_fspromises_copyfile_src_dest_flags" id="fs_fspromises_copyfile_src_dest_flags">#</a></span></h3>
+<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the
+<a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a> is active. Calling <code>watcher.ref()</code> multiple times will have
+no effect.</p>
+<p>By default, all <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a> objects are "ref'ed", making it normally
+unnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been
+called previously.</p>
+<h5><code>watcher.unref()</code><span><a class="mark" href="#fs_watcher_unref_1" id="fs_watcher_unref_1">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v14.0.0</td>
-<td><p>Changed 'flags' argument to 'mode' and imposed stricter type validation.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v14.3.0, v12.20.0</span>
 </div>
 <ul>
-<li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> source filename to copy</li>
-<li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> destination filename of the copy operation</li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> modifiers for copy operation. <strong>Default:</strong> <code>0</code>.</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a></li>
 </ul>
-<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it
-already exists. The <code>Promise</code> will be resolved with no arguments upon success.</p>
-<p>Node.js makes no guarantees about the atomicity of the copy operation. If an
-error occurs after the destination file has been opened for writing, Node.js
-will attempt to remove the destination.</p>
-<p><code>flags</code> is an optional integer that specifies the behavior
-of the copy operation. It is possible to create a mask consisting of the bitwise
-OR of two or more values (e.g.
-<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>
+<p>When called, the active <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a> object will not require the Node.js
+event loop to remain active. If there is no other activity keeping the
+event loop running, the process may exit before the <a href="fs.html#fs_class_fs_statwatcher" class="type">&#x3C;fs.StatWatcher></a> object's
+callback is invoked. Calling <code>watcher.unref()</code> multiple times will have
+no effect.</p>
+<h4>Class: <code>fs.ReadStream</code><span><a class="mark" href="#fs_class_fs_readstream" id="fs_class_fs_readstream">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
 <ul>
-<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already
-exists.</li>
-<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a
-copy-on-write reflink. If the platform does not support copy-on-write, then a
-fallback copy mechanism is used.</li>
-<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.</li>
+<li>Extends: <a href="stream.html#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fsPromises = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>).promises;
-
-<span class="hljs-comment">// destination.txt will be created or overwritten by default.</span>
-fsPromises.copyFile(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>)
-  .then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'source.txt was copied to destination.txt'</span>))
-  .catch(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The file could not be copied'</span>));</code></pre>
-<p>If the third argument is a number, then it specifies <code>flags</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> fsPromises = fs.promises;
-<span class="hljs-keyword">const</span> { COPYFILE_EXCL } = fs.constants;
-
-<span class="hljs-comment">// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.</span>
-fsPromises.copyFile(<span class="hljs-string">'source.txt'</span>, <span class="hljs-string">'destination.txt'</span>, COPYFILE_EXCL)
-  .then(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'source.txt was copied to destination.txt'</span>))
-  .catch(<span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'The file could not be copied'</span>));</code></pre>
-<h3><code>fsPromises.lchmod(path, mode)</code><span><a class="mark" href="#fs_fspromises_lchmod_path_mode" id="fs_fspromises_lchmod_path_mode">#</a></span></h3>
+<p>Instances of <a href="fs.html#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a> are created and returned using the
+<a href="#fs_fs_createreadstream_path_options"><code>fs.createReadStream()</code></a> function.</p>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close_1" id="fs_event_close_1">#</a></span></h5>
 <div class="api_metadata">
-<span>Deprecated since: v10.0.0</span>
+<span>Added in: v0.1.93</span>
+</div>
+<p>Emitted when the <a href="fs.html#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a>'s underlying file descriptor has been closed.</p>
+<h5>Event: <code>'open'</code><span><a class="mark" href="#fs_event_open" id="fs_event_open">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Integer file descriptor used by the <a href="fs.html#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a>.</li>
 </ul>
-<p>Changes the permissions on a symbolic link then resolves the <code>Promise</code> with
-no arguments upon success. This method is only implemented on macOS.</p>
-<h3><code>fsPromises.lchown(path, uid, gid)</code><span><a class="mark" href="#fs_fspromises_lchown_path_uid_gid" id="fs_fspromises_lchown_path_uid_gid">#</a></span></h3>
+<p>Emitted when the <a href="fs.html#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a>'s file descriptor has been opened.</p>
+<h5>Event: <code>'ready'</code><span><a class="mark" href="#fs_event_ready" id="fs_event_ready">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.6.0</td>
-<td><p>This API is no longer deprecated.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v9.11.0</span>
+</div>
+<p>Emitted when the <a href="fs.html#fs_class_fs_readstream" class="type">&#x3C;fs.ReadStream></a> is ready to be used.</p>
+<p>Fires immediately after <code>'open'</code>.</p>
+<h5><code>readStream.bytesRead</code><span><a class="mark" href="#fs_readstream_bytesread" id="fs_readstream_bytesread">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v6.4.0</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>uid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li><code>gid</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>Changes the ownership on a symbolic link then resolves the <code>Promise</code> with
-no arguments upon success.</p>
-<h3><code>fsPromises.lutimes(path, atime, mtime)</code><span><a class="mark" href="#fs_fspromises_lutimes_path_atime_mtime" id="fs_fspromises_lutimes_path_atime_mtime">#</a></span></h3>
+<p>The number of bytes that have been read so far.</p>
+<h5><code>readStream.path</code><span><a class="mark" href="#fs_readstream_path" id="fs_readstream_path">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v0.1.93</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Changes the access and modification times of a file in the same way as
-<a href="#fs_fspromises_utimes_path_atime_mtime"><code>fsPromises.utimes()</code></a>, with the difference that if the path refers to a
-symbolic link, then the link is not dereferenced: instead, the timestamps of
-the symbolic link itself are changed.</p>
-<p>Upon success, the <code>Promise</code> is resolved without arguments.</p>
-<h3><code>fsPromises.link(existingPath, newPath)</code><span><a class="mark" href="#fs_fspromises_link_existingpath_newpath" id="fs_fspromises_link_existingpath_newpath">#</a></span></h3>
+<p>The path to the file the stream is reading from as specified in the first
+argument to <code>fs.createReadStream()</code>. If <code>path</code> is passed as a string, then
+<code>readStream.path</code> will be a string. If <code>path</code> is passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>, then
+<code>readStream.path</code> will be a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<h5><code>readStream.pending</code><span><a class="mark" href="#fs_readstream_pending" id="fs_readstream_pending">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v11.2.0, v10.16.0</span>
 </div>
 <ul>
-<li><code>existingPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon success.</p>
-<h3><code>fsPromises.lstat(path[, options])</code><span><a class="mark" href="#fs_fspromises_lstat_path_options" id="fs_fspromises_lstat_path_options">#</a></span></h3>
+<p>This property is <code>true</code> if the underlying file has not been opened yet,
+i.e. before the <code>'ready'</code> event is emitted.</p>
+<h4>Class: <code>fs.Stats</code><span><a class="mark" href="#fs_class_fs_stats" id="fs_class_fs_stats">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
+<tr><td>v8.1.0</td>
+<td><p>Added times as numbers.</p></td></tr>
+<tr><td>v0.1.21</td>
+<td><p><span>Added in: v0.1.21</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
+<p>A <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object provides information about a file.</p>
+<p>Objects returned from <a href="#fs_fs_stat_path_options_callback"><code>fs.stat()</code></a>, <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a> and <a href="#fs_fs_fstat_fd_options_callback"><code>fs.fstat()</code></a> and
+their synchronous counterparts are of this type.
+If <code>bigint</code> in the <code>options</code> passed to those methods is true, the numeric values
+will be <code>bigint</code> instead of <code>number</code>, and the object will contain additional
+nanosecond-precision properties suffixed with <code>Ns</code>.</p>
+<pre><code class="language-console">Stats {
+  dev: 2114,
+  ino: 48064969,
+  mode: 33188,
+  nlink: 1,
+  uid: 85,
+  gid: 100,
+  rdev: 0,
+  size: 527,
+  blksize: 4096,
+  blocks: 8,
+  atimeMs: 1318289051000.1,
+  mtimeMs: 1318289051000.1,
+  ctimeMs: 1318289051000.1,
+  birthtimeMs: 1318289051000.1,
+  atime: Mon, 10 Oct 2011 23:24:11 GMT,
+  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
+  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
+  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }</code></pre>
+<p><code>bigint</code> version:</p>
+<pre><code class="language-console">BigIntStats {
+  dev: 2114n,
+  ino: 48064969n,
+  mode: 33188n,
+  nlink: 1n,
+  uid: 85n,
+  gid: 100n,
+  rdev: 0n,
+  size: 527n,
+  blksize: 4096n,
+  blocks: 8n,
+  atimeMs: 1318289051000n,
+  mtimeMs: 1318289051000n,
+  ctimeMs: 1318289051000n,
+  birthtimeMs: 1318289051000n,
+  atimeNs: 1318289051000000000n,
+  mtimeNs: 1318289051000000000n,
+  ctimeNs: 1318289051000000000n,
+  birthtimeNs: 1318289051000000000n,
+  atime: Mon, 10 Oct 2011 23:24:11 GMT,
+  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
+  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
+  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }</code></pre>
+<h5><code>stats.isBlockDevice()</code><span><a class="mark" href="#fs_stats_isblockdevice" id="fs_stats_isblockdevice">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.10</span>
+</div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a block device.</p>
+<h5><code>stats.isCharacterDevice()</code><span><a class="mark" href="#fs_stats_ischaracterdevice" id="fs_stats_ischaracterdevice">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.10</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/lstat.2.html"><code>lstat(2)</code></a>. The <code>Promise</code> is resolved with the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object
-for the given symbolic link <code>path</code>.</p>
-<h3><code>fsPromises.mkdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_mkdir_path_options" id="fs_fspromises_mkdir_path_options">#</a></span></h3>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a character device.</p>
+<h5><code>stats.isDirectory()</code><span><a class="mark" href="#fs_stats_isdirectory" id="fs_stats_isdirectory">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.1.10</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a>
-<ul>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Not supported on Windows. <strong>Default:</strong> <code>0o777</code>.</li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronously creates a directory then resolves the <code>Promise</code> with either no
-arguments, or the first directory path created if <code>recursive</code> is <code>true</code>.</p>
-<p>The optional <code>options</code> argument can be an integer specifying mode (permission
-and sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>
-property indicating whether parent directories should be created. Calling
-<code>fsPromises.mkdir()</code> when <code>path</code> is a directory that exists results in a
-rejection only when <code>recursive</code> is false.</p>
-<h3><code>fsPromises.mkdtemp(prefix[, options])</code><span><a class="mark" href="#fs_fspromises_mkdtemp_prefix_options" id="fs_fspromises_mkdtemp_prefix_options">#</a></span></h3>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a file system directory.</p>
+<p>If the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object was obtained from <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a>, this method will
+always return <code>false</code>. This is because <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a> returns information
+about a symbolic link itself and not the path it resolves to.</p>
+<h5><code>stats.isFIFO()</code><span><a class="mark" href="#fs_stats_isfifo" id="fs_stats_isfifo">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.1.10</span>
 </div>
 <ul>
-<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Creates a unique temporary directory and resolves the <code>Promise</code> with the created
-directory path. A unique directory name is generated by appending six random
-characters to the end of the provided <code>prefix</code>. Due to platform
-inconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,
-notably the BSDs, can return more than six random characters, and replace
-trailing <code>X</code> characters in <code>prefix</code> with random characters.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use.</p>
-<pre><code class="language-js">fsPromises.mkdtemp(path.join(os.tmpdir(), <span class="hljs-string">'foo-'</span>))
-  .catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<p>The <code>fsPromises.mkdtemp()</code> method will append the six randomly selected
-characters directly to the <code>prefix</code> string. For instance, given a directory
-<code>/tmp</code>, if the intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the
-<code>prefix</code> must end with a trailing platform-specific path separator
-(<code>require('path').sep</code>).</p>
-<h3><code>fsPromises.open(path, flags[, mode])</code><span><a class="mark" href="#fs_fspromises_open_path_flags_mode" id="fs_fspromises_open_path_flags_mode">#</a></span></h3>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a first-in-first-out (FIFO)
+pipe.</p>
+<h5><code>stats.isFile()</code><span><a class="mark" href="#fs_stats_isfile" id="fs_stats_isfile">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.1.0</td>
-<td><p>The <code>flags</code> argument is now optional and defaults to <code>'r'</code>.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v0.1.10</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>.
-<strong>Default:</strong> <code>'r'</code>.</li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code> (readable and writable)</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronous file open that returns a <code>Promise</code> that, when resolved, yields a
-<code>FileHandle</code> object. See <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a>.</p>
-<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was
-created.</p>
-<p>Some characters (<code>&#x3C; > : " / \ | ? *</code>) are reserved under Windows as documented
-by <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains
-a colon, Node.js will open a file system stream, as described by
-<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams">this MSDN page</a>.</p>
-<h3><code>fsPromises.opendir(path[, options])</code><span><a class="mark" href="#fs_fspromises_opendir_path_options" id="fs_fspromises_opendir_path_options">#</a></span></h3>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a regular file.</p>
+<h5><code>stats.isSocket()</code><span><a class="mark" href="#fs_stats_issocket" id="fs_stats_issocket">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>bufferSize</code> option was introduced.</p></td></tr>
-<tr><td>v12.12.0</td>
-<td><p><span>Added in: v12.12.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v0.1.10</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>bufferSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Number of directory entries that are buffered
-internally when reading from the directory. Higher values lead to better
-performance but higher memory usage. <strong>Default:</strong> <code>32</code></li>
-</ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> containing <a href="fs.html#fs_class_fs_dir" class="type">&#x3C;fs.Dir></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Asynchronously open a directory. See <a href="http://man7.org/linux/man-pages/man3/opendir.3.html"><code>opendir(3)</code></a>.</p>
-<p>Creates an <a href="#fs_class_fs_dir"><code>fs.Dir</code></a>, which contains all further functions for reading from
-and cleaning up the directory.</p>
-<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the
-directory and subsequent read operations.</p>
-<p>Example using async iteration:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">print</span>(<span class="hljs-params">path</span>) </span>{
-  <span class="hljs-keyword">const</span> dir = <span class="hljs-keyword">await</span> fs.promises.opendir(path);
-  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> dirent <span class="hljs-keyword">of</span> dir) {
-    <span class="hljs-built_in">console</span>.log(dirent.name);
-  }
-}
-print(<span class="hljs-string">'./'</span>).catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<h3><code>fsPromises.readdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_readdir_path_options" id="fs_fspromises_readdir_path_options">#</a></span></h3>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a socket.</p>
+<h5><code>stats.isSymbolicLink()</code><span><a class="mark" href="#fs_stats_issymboliclink" id="fs_stats_issymboliclink">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.11.0</td>
-<td><p>New option <code>withFileTypes</code> was added.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v0.1.10</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object describes a symbolic link.</p>
+<p>This method is only valid when using <a href="#fs_fs_lstat_path_options_callback"><code>fs.lstat()</code></a>.</p>
+<h5><code>stats.dev</code><span><a class="mark" href="#fs_stats_dev" id="fs_stats_dev">#</a></span></h5>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>withFileTypes</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>The numeric identifier of the device containing the file.</p>
+<h5><code>stats.ino</code><span><a class="mark" href="#fs_stats_ino" id="fs_stats_ino">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Reads the contents of a directory then resolves the <code>Promise</code> with an array
-of the names of the files in the directory excluding <code>'.'</code> and <code>'..'</code>.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the filenames. If the <code>encoding</code> is set to <code>'buffer'</code>, the filenames returned
-will be passed as <code>Buffer</code> objects.</p>
-<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the resolved array will contain
-<a href="#fs_class_fs_dirent"><code>fs.Dirent</code></a> objects.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">print</span>(<span class="hljs-params">path</span>) </span>{
-  <span class="hljs-keyword">const</span> files = <span class="hljs-keyword">await</span> fs.promises.readdir(path);
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> file <span class="hljs-keyword">of</span> files) {
-    <span class="hljs-built_in">console</span>.log(file);
-  }
-}
-print(<span class="hljs-string">'./'</span>).catch(<span class="hljs-built_in">console</span>.error);</code></pre>
-<h3><code>fsPromises.readFile(path[, options])</code><span><a class="mark" href="#fs_fspromises_readfile_path_options" id="fs_fspromises_readfile_path_options">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
+<p>The file system specific "Inode" number for the file.</p>
+<h5><code>stats.mode</code><span><a class="mark" href="#fs_stats_mode" id="fs_stats_mode">#</a></span></h5>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>A bit-field describing the file type and mode.</p>
+<h5><code>stats.nlink</code><span><a class="mark" href="#fs_stats_nlink" id="fs_stats_nlink">#</a></span></h5>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>null</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'r'</code>.</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>The number of hard-links that exist for the file.</p>
+<h5><code>stats.uid</code><span><a class="mark" href="#fs_stats_uid" id="fs_stats_uid">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Asynchronously reads the entire contents of a file.</p>
-<p>The <code>Promise</code> is resolved with the contents of the file. If no encoding is
-specified (using <code>options.encoding</code>), the data is returned as a <code>Buffer</code>
-object. Otherwise, the data will be a string.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>When the <code>path</code> is a directory, the behavior of <code>fsPromises.readFile()</code> is
-platform-specific. On macOS, Linux, and Windows, the promise will be rejected
-with an error. On FreeBSD, a representation of the directory's contents will be
-returned.</p>
-<p>Any specified <code>FileHandle</code> has to support reading.</p>
-<h3><code>fsPromises.readlink(path[, options])</code><span><a class="mark" href="#fs_fspromises_readlink_path_options" id="fs_fspromises_readlink_path_options">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
+<p>The numeric user identifier of the user that owns the file (POSIX).</p>
+<h5><code>stats.gid</code><span><a class="mark" href="#fs_stats_gid" id="fs_stats_gid">#</a></span></h5>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The numeric group identifier of the group that owns the file (POSIX).</p>
+<h5><code>stats.rdev</code><span><a class="mark" href="#fs_stats_rdev" id="fs_stats_rdev">#</a></span></h5>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>A numeric device identifier if the file represents a device.</p>
+<h5><code>stats.size</code><span><a class="mark" href="#fs_stats_size" id="fs_stats_size">#</a></span></h5>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/readlink.2.html"><code>readlink(2)</code></a>. The <code>Promise</code> is resolved with the <code>linkString</code> upon
-success.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>, the link path
-returned will be passed as a <code>Buffer</code> object.</p>
-<h3><code>fsPromises.realpath(path[, options])</code><span><a class="mark" href="#fs_fspromises_realpath_path_options" id="fs_fspromises_realpath_path_options">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v10.0.0</span>
-</div>
+<p>The size of the file in bytes.</p>
+<h5><code>stats.blksize</code><span><a class="mark" href="#fs_stats_blksize" id="fs_stats_blksize">#</a></span></h5>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The file system block size for i/o operations.</p>
+<h5><code>stats.blocks</code><span><a class="mark" href="#fs_stats_blocks" id="fs_stats_blocks">#</a></span></h5>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'utf8'</code></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>The number of blocks allocated for this file.</p>
+<h5><code>stats.atimeMs</code><span><a class="mark" href="#fs_stats_atimems" id="fs_stats_atimems">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v8.1.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Determines the actual location of <code>path</code> using the same semantics as the
-<code>fs.realpath.native()</code> function then resolves the <code>Promise</code> with the resolved
-path.</p>
-<p>Only paths that can be converted to UTF8 strings are supported.</p>
-<p>The optional <code>options</code> argument can be a string specifying an encoding, or an
-object with an <code>encoding</code> property specifying the character encoding to use for
-the path. If the <code>encoding</code> is set to <code>'buffer'</code>, the path returned will be
-passed as a <code>Buffer</code> object.</p>
-<p>On Linux, when Node.js is linked against musl libc, the procfs file system must
-be mounted on <code>/proc</code> in order for this function to work. Glibc does not have
-this restriction.</p>
-<h3><code>fsPromises.rename(oldPath, newPath)</code><span><a class="mark" href="#fs_fspromises_rename_oldpath_newpath" id="fs_fspromises_rename_oldpath_newpath">#</a></span></h3>
+<p>The timestamp indicating the last time this file was accessed expressed in
+milliseconds since the POSIX Epoch.</p>
+<h5><code>stats.mtimeMs</code><span><a class="mark" href="#fs_stats_mtimems" id="fs_stats_mtimems">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v8.1.0</span>
 </div>
 <ul>
-<li><code>oldPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>newPath</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Renames <code>oldPath</code> to <code>newPath</code> and resolves the <code>Promise</code> with no arguments
-upon success.</p>
-<h3><code>fsPromises.rmdir(path[, options])</code><span><a class="mark" href="#fs_fspromises_rmdir_path_options" id="fs_fspromises_rmdir_path_options">#</a></span></h3>
+<p>The timestamp indicating the last time this file was modified expressed in
+milliseconds since the POSIX Epoch.</p>
+<h5><code>stats.ctimeMs</code><span><a class="mark" href="#fs_stats_ctimems" id="fs_stats_ctimems">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>maxBusyTries</code> option is renamed to <code>maxRetries</code>, and its default is 0. The <code>emfileWait</code> option has been removed, and <code>EMFILE</code> errors use the same retry logic as other errors. The <code>retryDelay</code> option is now supported. <code>ENFILE</code> errors are now retried.</p></td></tr>
-<tr><td>v12.10.0</td>
-<td><p>The <code>recursive</code>, <code>maxBusyTries</code>, and <code>emfileWait</code> options are now supported.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v8.1.0</span>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Recursive removal is experimental.</div><p></p>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>The timestamp indicating the last time the file status was changed expressed
+in milliseconds since the POSIX Epoch.</p>
+<h5><code>stats.birthtimeMs</code><span><a class="mark" href="#fs_stats_birthtimems" id="fs_stats_birthtimems">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v8.1.0</span>
+</div>
 <ul>
-<li><code>maxRetries</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> If an <code>EBUSY</code>, <code>EMFILE</code>, <code>ENFILE</code>, <code>ENOTEMPTY</code>, or
-<code>EPERM</code> error is encountered, Node.js will retry the operation with a linear
-backoff wait of <code>retryDelay</code> ms longer on each try. This option represents the
-number of retries. This option is ignored if the <code>recursive</code> option is not
-<code>true</code>. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>recursive</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, perform a recursive directory removal. In
-recursive mode, errors are not reported if <code>path</code> does not exist, and
-operations are retried on failure. <strong>Default:</strong> <code>false</code>.</li>
-<li><code>retryDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The amount of time in milliseconds to wait between
-retries. This option is ignored if the <code>recursive</code> option is not <code>true</code>.
-<strong>Default:</strong> <code>100</code>.</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>The timestamp indicating the creation time of this file expressed in
+milliseconds since the POSIX Epoch.</p>
+<h5><code>stats.atimeNs</code><span><a class="mark" href="#fs_stats_atimens" id="fs_stats_atimens">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.10.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-<p>Removes the directory identified by <code>path</code> then resolves the <code>Promise</code> with
-no arguments upon success.</p>
-<p>Using <code>fsPromises.rmdir()</code> on a file (not a directory) results in the
-<code>Promise</code> being rejected with an <code>ENOENT</code> error on Windows and an <code>ENOTDIR</code>
-error on POSIX.</p>
-<h3><code>fsPromises.stat(path[, options])</code><span><a class="mark" href="#fs_fspromises_stat_path_options" id="fs_fspromises_stat_path_options">#</a></span></h3>
+<p>Only present when <code>bigint: true</code> is passed into the method that generates
+the object.
+The timestamp indicating the last time this file was accessed expressed in
+nanoseconds since the POSIX Epoch.</p>
+<h5><code>stats.mtimeNs</code><span><a class="mark" href="#fs_stats_mtimens" id="fs_stats_mtimens">#</a></span></h5>
 <div class="api_metadata">
-<details class="changelog"><summary>History</summary>
-<table>
-<tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v10.5.0</td>
-<td><p>Accepts an additional <code>options</code> object to specify whether the numeric values returned should be bigint.</p></td></tr>
-<tr><td>v10.0.0</td>
-<td><p><span>Added in: v10.0.0</span></p></td></tr>
-</tbody></table>
-</details>
+<span>Added in: v12.10.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>Only present when <code>bigint: true</code> is passed into the method that generates
+the object.
+The timestamp indicating the last time this file was modified expressed in
+nanoseconds since the POSIX Epoch.</p>
+<h5><code>stats.ctimeNs</code><span><a class="mark" href="#fs_stats_ctimens" id="fs_stats_ctimens">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.10.0</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
+</ul>
+<p>Only present when <code>bigint: true</code> is passed into the method that generates
+the object.
+The timestamp indicating the last time the file status was changed expressed
+in nanoseconds since the POSIX Epoch.</p>
+<h5><code>stats.birthtimeNs</code><span><a class="mark" href="#fs_stats_birthtimens" id="fs_stats_birthtimens">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v12.10.0</span>
+</div>
 <ul>
-<li><code>bigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the numeric values in the returned
-<a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object should be <code>bigint</code>. <strong>Default:</strong> <code>false</code>.</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a></li>
 </ul>
-</li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<p>Only present when <code>bigint: true</code> is passed into the method that generates
+the object.
+The timestamp indicating the creation time of this file expressed in
+nanoseconds since the POSIX Epoch.</p>
+<h5><code>stats.atime</code><span><a class="mark" href="#fs_stats_atime" id="fs_stats_atime">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.11.13</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>The <code>Promise</code> is resolved with the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object for the given <code>path</code>.</p>
-<h3><code>fsPromises.symlink(target, path[, type])</code><span><a class="mark" href="#fs_fspromises_symlink_target_path_type" id="fs_fspromises_symlink_target_path_type">#</a></span></h3>
+<p>The timestamp indicating the last time this file was accessed.</p>
+<h5><code>stats.mtime</code><span><a class="mark" href="#fs_stats_mtime" id="fs_stats_mtime">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.11.13</span>
 </div>
 <ul>
-<li><code>target</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default:</strong> <code>'file'</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>Creates a symbolic link then resolves the <code>Promise</code> with no arguments upon
-success.</p>
-<p>The <code>type</code> argument is only used on Windows platforms and can be one of <code>'dir'</code>,
-<code>'file'</code>, or <code>'junction'</code>. Windows junction points require the destination path
-to be absolute. When using <code>'junction'</code>, the <code>target</code> argument will
-automatically be normalized to absolute path.</p>
-<h3><code>fsPromises.truncate(path[, len])</code><span><a class="mark" href="#fs_fspromises_truncate_path_len" id="fs_fspromises_truncate_path_len">#</a></span></h3>
+<p>The timestamp indicating the last time this file was modified.</p>
+<h5><code>stats.ctime</code><span><a class="mark" href="#fs_stats_ctime" id="fs_stats_ctime">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.11.13</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>len</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0</code></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
 </ul>
-<p>Truncates the <code>path</code> then resolves the <code>Promise</code> with no arguments upon
-success. The <code>path</code> <em>must</em> be a string or <code>Buffer</code>.</p>
-<h3><code>fsPromises.unlink(path)</code><span><a class="mark" href="#fs_fspromises_unlink_path" id="fs_fspromises_unlink_path">#</a></span></h3>
+<p>The timestamp indicating the last time the file status was changed.</p>
+<h5><code>stats.birthtime</code><span><a class="mark" href="#fs_stats_birthtime" id="fs_stats_birthtime">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.11.13</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
+</ul>
+<p>The timestamp indicating the creation time of this file.</p>
+<h5>Stat time values<span><a class="mark" href="#fs_stat_time_values" id="fs_stat_time_values">#</a></span></h5>
+<p>The <code>atimeMs</code>, <code>mtimeMs</code>, <code>ctimeMs</code>, <code>birthtimeMs</code> properties are
+numeric values that hold the corresponding times in milliseconds. Their
+precision is platform specific. When <code>bigint: true</code> is passed into the
+method that generates the object, the properties will be <a href="https://tc39.github.io/proposal-bigint">bigints</a>,
+otherwise they will be <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type">numbers</a>.</p>
+<p>The <code>atimeNs</code>, <code>mtimeNs</code>, <code>ctimeNs</code>, <code>birthtimeNs</code> properties are
+<a href="https://tc39.github.io/proposal-bigint">bigints</a> that hold the corresponding times in nanoseconds. They are
+only present when <code>bigint: true</code> is passed into the method that generates
+the object. Their precision is platform specific.</p>
+<p><code>atime</code>, <code>mtime</code>, <code>ctime</code>, and <code>birthtime</code> are
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a> object alternate representations of the various times. The
+<code>Date</code> and number values are not connected. Assigning a new number value, or
+mutating the <code>Date</code> value, will not be reflected in the corresponding alternate
+representation.</p>
+<p>The times in the stat object have the following semantics:</p>
+<ul>
+<li><code>atime</code> "Access Time": Time when file data last accessed. Changed
+by the <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/read.2.html"><code>read(2)</code></a> system calls.</li>
+<li><code>mtime</code> "Modified Time": Time when file data last modified.
+Changed by the <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/write.2.html"><code>write(2)</code></a> system calls.</li>
+<li><code>ctime</code> "Change Time": Time when file status was last changed
+(inode data modification). Changed by the <a href="http://man7.org/linux/man-pages/man2/chmod.2.html"><code>chmod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/chown.2.html"><code>chown(2)</code></a>,
+<a href="http://man7.org/linux/man-pages/man2/link.2.html"><code>link(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/mknod.2.html"><code>mknod(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/rename.2.html"><code>rename(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>, <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a>,
+<a href="http://man7.org/linux/man-pages/man2/read.2.html"><code>read(2)</code></a>, and <a href="http://man7.org/linux/man-pages/man2/write.2.html"><code>write(2)</code></a> system calls.</li>
+<li><code>birthtime</code> "Birth Time": Time of file creation. Set once when the
+file is created. On filesystems where birthtime is not available,
+this field may instead hold either the <code>ctime</code> or
+<code>1970-01-01T00:00Z</code> (ie, Unix epoch timestamp <code>0</code>). This value may be greater
+than <code>atime</code> or <code>mtime</code> in this case. On Darwin and other FreeBSD variants,
+also set if the <code>atime</code> is explicitly set to an earlier value than the current
+<code>birthtime</code> using the <a href="http://man7.org/linux/man-pages/man2/utimes.2.html"><code>utimes(2)</code></a> system call.</li>
 </ul>
-<p>Asynchronous <a href="http://man7.org/linux/man-pages/man2/unlink.2.html"><code>unlink(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon
-success.</p>
-<h3><code>fsPromises.utimes(path, atime, mtime)</code><span><a class="mark" href="#fs_fspromises_utimes_path_atime_mtime" id="fs_fspromises_utimes_path_atime_mtime">#</a></span></h3>
+<p>Prior to Node.js 0.12, the <code>ctime</code> held the <code>birthtime</code> on Windows systems. As
+of 0.12, <code>ctime</code> is not "creation time", and on Unix systems, it never was.</p>
+<h4>Class: <code>fs.WriteStream</code><span><a class="mark" href="#fs_class_fs_writestream" id="fs_class_fs_writestream">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v0.1.93</span>
 </div>
 <ul>
-<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a></li>
-<li><code>atime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li><code>mtime</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date" class="type">&#x3C;Date></a></li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Extends <a href="stream.html#stream_class_stream_writable" class="type">&#x3C;stream.Writable></a></li>
 </ul>
-<p>Change the file system timestamps of the object referenced by <code>path</code> then
-resolves the <code>Promise</code> with no arguments upon success.</p>
-<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>
+<p>Instances of <a href="fs.html#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> are created and returned using the
+<a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a> function.</p>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#fs_event_close_2" id="fs_event_close_2">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
+<p>Emitted when the <a href="fs.html#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a>'s underlying file descriptor has been closed.</p>
+<h5>Event: <code>'open'</code><span><a class="mark" href="#fs_event_open_1" id="fs_event_open_1">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
 <ul>
-<li>Values can be either numbers representing Unix epoch time, <code>Date</code>s, or a
-numeric string like <code>'123456789.0'</code>.</li>
-<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or
-<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>
+<li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Integer file descriptor used by the <a href="fs.html#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a>.</li>
 </ul>
-<h3><code>fsPromises.writeFile(file, data[, options])</code><span><a class="mark" href="#fs_fspromises_writefile_file_data_options" id="fs_fspromises_writefile_file_data_options">#</a></span></h3>
+<p>Emitted when the <a href="fs.html#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a>'s file is opened.</p>
+<h5>Event: <code>'ready'</code><span><a class="mark" href="#fs_event_ready_1" id="fs_event_ready_1">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v9.11.0</span>
+</div>
+<p>Emitted when the <a href="fs.html#fs_class_fs_writestream" class="type">&#x3C;fs.WriteStream></a> is ready to be used.</p>
+<p>Fires immediately after <code>'open'</code>.</p>
+<h5><code>writeStream.bytesWritten</code><span><a class="mark" href="#fs_writestream_byteswritten" id="fs_writestream_byteswritten">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.4.7</span>
+</div>
+<p>The number of bytes written so far. Does not include data that is still queued
+for writing.</p>
+<h5><code>writeStream.close([callback])</code><span><a class="mark" href="#fs_writestream_close_callback" id="fs_writestream_close_callback">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.9.4</span>
 </div>
 <ul>
-<li><code>file</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> | <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> filename or <code>FileHandle</code></li>
-<li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
-<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> <strong>Default:</strong> <code>0o666</code></li>
-<li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> See <a href="#fs_file_system_flags">support of file system <code>flags</code></a>. <strong>Default:</strong> <code>'w'</code>.</li>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
-<p>Asynchronously writes data to a file, replacing the file if it already exists.
-<code>data</code> can be a string or a buffer. The <code>Promise</code> will be resolved with no
-arguments upon success.</p>
-<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>
-<p>If <code>options</code> is a string, then it specifies the encoding.</p>
-<p>Any specified <code>FileHandle</code> has to support writing.</p>
-<p>It is unsafe to use <code>fsPromises.writeFile()</code> multiple times on the same file
-without waiting for the <code>Promise</code> to be resolved (or rejected).</p>
-<h2>FS constants<span><a class="mark" href="#fs_fs_constants_1" id="fs_fs_constants_1">#</a></span></h2>
+<p>Closes <code>writeStream</code>. Optionally accepts a
+callback that will be executed once the <code>writeStream</code>
+is closed.</p>
+<h5><code>writeStream.path</code><span><a class="mark" href="#fs_writestream_path" id="fs_writestream_path">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v0.1.93</span>
+</div>
+<p>The path to the file the stream is writing to as specified in the first
+argument to <a href="#fs_fs_createwritestream_path_options"><code>fs.createWriteStream()</code></a>. If <code>path</code> is passed as a string, then
+<code>writeStream.path</code> will be a string. If <code>path</code> is passed as a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>, then
+<code>writeStream.path</code> will be a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>.</p>
+<h5><code>writeStream.pending</code><span><a class="mark" href="#fs_writestream_pending" id="fs_writestream_pending">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v11.2.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>This property is <code>true</code> if the underlying file has not been opened yet,
+i.e. before the <code>'ready'</code> event is emitted.</p>
+<h4><code>fs.constants</code><span><a class="mark" href="#fs_fs_constants" id="fs_fs_constants">#</a></span></h4>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+</ul>
+<p>Returns an object containing commonly used constants for file system
+operations.</p>
+<h5>FS constants<span><a class="mark" href="#fs_fs_constants_1" id="fs_fs_constants_1">#</a></span></h5>
 <p>The following constants are exported by <code>fs.constants</code>.</p>
 <p>Not every constant will be available on every operating system.</p>
 <p>To use more than one constant, use the bitwise OR <code>|</code> operator.</p>
 <p>Example:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, constants } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
 
 <span class="hljs-keyword">const</span> {
-  O_RDWR,
-  O_CREAT,
-  O_EXCL
-} = fs.constants;
+  <span class="hljs-variable constant_">O_RDWR</span>,
+  <span class="hljs-variable constant_">O_CREAT</span>,
+  <span class="hljs-variable constant_">O_EXCL</span>
+} = constants;
 
-fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT | O_EXCL, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'/path/to/my/file'</span>, <span class="hljs-variable constant_">O_RDWR</span> | <span class="hljs-variable constant_">O_CREAT</span> | <span class="hljs-variable constant_">O_EXCL</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
-<h3>File access constants<span><a class="mark" href="#fs_file_access_constants" id="fs_file_access_constants">#</a></span></h3>
+<h6>File access constants<span><a class="mark" href="#fs_file_access_constants" id="fs_file_access_constants">#</a></span></h6>
 <p>The following constants are meant for use with <a href="#fs_fs_access_path_mode_callback"><code>fs.access()</code></a>.</p>
 <table>
   <tbody><tr>
@@ -5569,8 +6075,8 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     (will behave like <code>fs.constants.F_OK</code>).</td>
   </tr>
 </tbody></table>
-<h3>File copy constants<span><a class="mark" href="#fs_file_copy_constants" id="fs_file_copy_constants">#</a></span></h3>
-<p>The following constants are meant for use with <a href="#fs_fs_copyfile_src_dest_flags_callback"><code>fs.copyFile()</code></a>.</p>
+<h6>File copy constants<span><a class="mark" href="#fs_file_copy_constants" id="fs_file_copy_constants">#</a></span></h6>
+<p>The following constants are meant for use with <a href="#fs_fs_copyfile_src_dest_mode_callback"><code>fs.copyFile()</code></a>.</p>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -5594,7 +6100,7 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     copy-on-write, then the operation will fail with an error.</td>
   </tr>
 </tbody></table>
-<h3>File open constants<span><a class="mark" href="#fs_file_open_constants" id="fs_file_open_constants">#</a></span></h3>
+<h6>File open constants<span><a class="mark" href="#fs_file_open_constants" id="fs_file_open_constants">#</a></span></h6>
 <p>The following constants are meant for use with <code>fs.open()</code>.</p>
 <table>
   <tbody><tr>
@@ -5685,8 +6191,8 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     this flag is ignored.</td>
   </tr>
 </tbody></table>
-<h3>File type constants<span><a class="mark" href="#fs_file_type_constants" id="fs_file_type_constants">#</a></span></h3>
-<p>The following constants are meant for use with the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object's
+<h6>File type constants<span><a class="mark" href="#fs_file_type_constants" id="fs_file_type_constants">#</a></span></h6>
+<p>The following constants are meant for use with the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object's
 <code>mode</code> property for determining a file's type.</p>
 <table>
   <tbody><tr>
@@ -5726,8 +6232,8 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     <td>File type constant for a socket.</td>
   </tr>
 </tbody></table>
-<h3>File mode constants<span><a class="mark" href="#fs_file_mode_constants" id="fs_file_mode_constants">#</a></span></h3>
-<p>The following constants are meant for use with the <a href="#fs_class_fs_stats"><code>fs.Stats</code></a> object's
+<h6>File mode constants<span><a class="mark" href="#fs_file_mode_constants" id="fs_file_mode_constants">#</a></span></h6>
+<p>The following constants are meant for use with the <a href="fs.html#fs_class_fs_stats" class="type">&#x3C;fs.Stats></a> object's
 <code>mode</code> property for determining the access permissions for a file.</p>
 <table>
   <tbody><tr>
@@ -5783,7 +6289,244 @@ fs.open(<span class="hljs-string">'/path/to/my/file'</span>, O_RDWR | O_CREAT |
     <td>File mode indicating executable by others.</td>
   </tr>
 </tbody></table>
-<h2>File system flags<span><a class="mark" href="#fs_file_system_flags" id="fs_file_system_flags">#</a></span></h2>
+</section><section><h3>Notes<span><a class="mark" href="#fs_notes" id="fs_notes">#</a></span></h3>
+<h4>Ordering of callback and promise-based operations<span><a class="mark" href="#fs_ordering_of_callback_and_promise_based_operations" id="fs_ordering_of_callback_and_promise_based_operations">#</a></span></h4>
+<p>Because they are executed asynchronously by the underlying thread pool,
+there is no guaranteed ordering when using either the callback or
+promise-based methods.</p>
+<p>For example, the following is prone to error because the <code>fs.stat()</code>
+operation might complete before the <code>fs.rename()</code> operation:</p>
+<pre><code class="language-js">fs.<span class="hljs-title function_">rename</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'renamed complete'</span>);
+});
+fs.<span class="hljs-title function_">stat</span>(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+});</code></pre>
+<p>It is important to correctly order the operations by awaiting the results
+of one before invoking the other:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { rename, stat } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">const</span> <span class="hljs-keyword">from</span> = <span class="hljs-string">'/tmp/hello'</span>;
+<span class="hljs-keyword">const</span> to = <span class="hljs-string">'/tmp/world'</span>;
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">rename</span>(<span class="hljs-keyword">from</span>, to);
+  <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> <span class="hljs-title function_">stat</span>(to);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+} <span class="hljs-keyword">catch</span> (error) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'there was an error:'</span>, error.<span class="hljs-property">message</span>);
+}</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { rename, stat } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);
+
+(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"><span class="hljs-keyword">from</span>, to</span>) {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">rename</span>(<span class="hljs-keyword">from</span>, to);
+    <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> <span class="hljs-title function_">stat</span>(to);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+  } <span class="hljs-keyword">catch</span> (error) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'there was an error:'</span>, error.<span class="hljs-property">message</span>);
+  }
+})(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>);</code></pre>
+<p>Or, when using the callback APIs, move the <code>fs.stat()</code> call into the callback
+of the <code>fs.rename()</code> operation:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { rename, stat } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">rename</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-title function_">stat</span>(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+  });
+});</code><code class="language-js cjs"><span class="hljs-keyword">const</span> { rename, stat } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs/promises'</span>);
+
+<span class="hljs-title function_">rename</span>(<span class="hljs-string">'/tmp/hello'</span>, <span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-title function_">stat</span>(<span class="hljs-string">'/tmp/world'</span>, <span class="hljs-function">(<span class="hljs-params">err, stats</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`stats: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(stats)}</span>`</span>);
+  });
+});</code></pre>
+<h4>File paths<span><a class="mark" href="#fs_file_paths" id="fs_file_paths">#</a></span></h4>
+<p>Most <code>fs</code> operations accept file paths that may be specified in the form of
+a string, a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a>, or a <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> object using the <code>file:</code> protocol.</p>
+<h5>String paths<span><a class="mark" href="#fs_string_paths" id="fs_string_paths">#</a></span></h5>
+<p>String form paths are interpreted as UTF-8 character sequences identifying
+the absolute or relative filename. Relative paths will be resolved relative
+to the current working directory as determined by calling <code>process.cwd()</code>.</p>
+<p>Example using an absolute path on POSIX:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> fd;
+<span class="hljs-keyword">try</span> {
+  fd = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>);
+  <span class="hljs-comment">// Do something with the file</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> fd.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<p>Example using a relative path on POSIX (relative to <code>process.cwd()</code>):</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> fd;
+<span class="hljs-keyword">try</span> {
+  fd = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'file.txt'</span>, <span class="hljs-string">'r'</span>);
+  <span class="hljs-comment">// Do something with the file</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> fd.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<h5>File URL paths<span><a class="mark" href="#fs_file_url_paths" id="fs_file_url_paths">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v7.6.0</span>
+</div>
+<p>For most <code>fs</code> module functions, the <code>path</code> or <code>filename</code> argument may be passed
+as a <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> object using the <code>file:</code> protocol.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///tmp/hello'</span>));</code></pre>
+<p><code>file:</code> URLs are always absolute paths.</p>
+<h6>Platform-specific considerations<span><a class="mark" href="#fs_platform_specific_considerations" id="fs_platform_specific_considerations">#</a></span></h6>
+<p>On Windows, <code>file:</code> <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s with a host name convert to UNC paths, while <code>file:</code>
+<a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s with drive letters convert to local absolute paths. <code>file:</code> <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s
+without a host name nor a drive letter will result in an error:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// On Windows :</span>
+
+<span class="hljs-comment">// - WHATWG file URLs with hostname convert to UNC path</span>
+<span class="hljs-comment">// file://hostname/p/a/t/h/file => \\hostname\p\a\t\h\file</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file://hostname/p/a/t/h/file'</span>));
+
+<span class="hljs-comment">// - WHATWG file URLs with drive letters convert to absolute path</span>
+<span class="hljs-comment">// file:///C:/tmp/hello => C:\tmp\hello</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/tmp/hello'</span>));
+
+<span class="hljs-comment">// - WHATWG file URLs without hostname must have a drive letters</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///notdriveletter/p/a/t/h/file'</span>));
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///c/p/a/t/h/file'</span>));
+<span class="hljs-comment">// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute</span></code></pre>
+<p><code>file:</code> <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s with drive letters must use <code>:</code> as a separator just after
+the drive letter. Using another separator will result in an error.</p>
+<p>On all other platforms, <code>file:</code> <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s with a host name are unsupported and
+will result in an error:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-comment">// On other platforms:</span>
+
+<span class="hljs-comment">// - WHATWG file URLs with hostname are unsupported</span>
+<span class="hljs-comment">// file://hostname/p/a/t/h/file => throw!</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file://hostname/p/a/t/h/file'</span>));
+<span class="hljs-comment">// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute</span>
+
+<span class="hljs-comment">// - WHATWG file URLs convert to absolute path</span>
+<span class="hljs-comment">// file:///tmp/hello => /tmp/hello</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///tmp/hello'</span>));</code></pre>
+<p>A <code>file:</code> <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> having encoded slash characters will result in an error on all
+platforms:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// On Windows</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/p/a/t/h/%2F'</span>));
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/p/a/t/h/%2f'</span>));
+<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+\ or / characters */</span>
+
+<span class="hljs-comment">// On POSIX</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///p/a/t/h/%2F'</span>));
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///p/a/t/h/%2f'</span>));
+<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+/ characters */</span></code></pre>
+<p>On Windows, <code>file:</code> <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a>s having encoded backslash will result in an error:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { readFileSync } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-comment">// On Windows</span>
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/path/%5C'</span>));
+<span class="hljs-title function_">readFileSync</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/path/%5c'</span>));
+<span class="hljs-comment">/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+\ or / characters */</span></code></pre>
+<h5>Buffer paths<span><a class="mark" href="#fs_buffer_paths" id="fs_buffer_paths">#</a></span></h5>
+<p>Paths specified using a <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> are useful primarily on certain POSIX
+operating systems that treat file paths as opaque byte sequences. On such
+systems, it is possible for a single file path to contain sub-sequences that
+use multiple character encodings. As with string paths, <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> paths may
+be relative or absolute:</p>
+<p>Example using an absolute path on POSIX:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> fd;
+<span class="hljs-keyword">try</span> {
+  fd = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'/open/some/file.txt'</span>), <span class="hljs-string">'r'</span>);
+  <span class="hljs-comment">// Do something with the file</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> fd.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<h5>Per-drive working directories on Windows<span><a class="mark" href="#fs_per_drive_working_directories_on_windows" id="fs_per_drive_working_directories_on_windows">#</a></span></h5>
+<p>On Windows, Node.js follows the concept of per-drive working directory. This
+behavior can be observed when using a drive path without a backslash. For
+example <code>fs.readdirSync('C:\\')</code> can potentially return a different result than
+<code>fs.readdirSync('C:')</code>. For more information, see
+<a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths">this MSDN page</a>.</p>
+<h4>File descriptors<span><a class="mark" href="#fs_file_descriptors_1" id="fs_file_descriptors_1">#</a></span></h4>
+<p>On POSIX systems, for every process, the kernel maintains a table of currently
+open files and resources. Each open file is assigned a simple numeric
+identifier called a <em>file descriptor</em>. At the system-level, all file system
+operations use these file descriptors to identify and track each specific
+file. Windows systems use a different but conceptually similar mechanism for
+tracking resources. To simplify things for users, Node.js abstracts away the
+differences between operating systems and assigns all open files a numeric file
+descriptor.</p>
+<p>The callback-based <code>fs.open()</code>, and synchronous <code>fs.openSync()</code> methods open a
+file and allocate a new file descriptor. Once allocated, the file descriptor may
+be used to read data from, write data to, or request information about the file.</p>
+<p>Operating systems limit the number of file descriptors that may be open
+at any given time so it is critical to close the descriptor when operations
+are completed. Failure to do so will result in a memory leak that will
+eventually cause an application to crash.</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open, close, fstat } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">closeFd</span>(<span class="hljs-params">fd</span>) {
+  <span class="hljs-title function_">close</span>(fd, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  });
+}
+
+<span class="hljs-title function_">open</span>(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-title function_">fstat</span>(fd, <span class="hljs-function">(<span class="hljs-params">err, stat</span>) =></span> {
+      <span class="hljs-keyword">if</span> (err) {
+        <span class="hljs-title function_">closeFd</span>(fd);
+        <span class="hljs-keyword">throw</span> err;
+      }
+
+      <span class="hljs-comment">// use stat</span>
+
+      <span class="hljs-title function_">closeFd</span>(fd);
+    });
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-title function_">closeFd</span>(fd);
+    <span class="hljs-keyword">throw</span> err;
+  }
+});</code></pre>
+<p>The promise-based APIs use a <a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a> object in place of the numeric
+file descriptor. These objects are better managed by the system to ensure
+that resources are not leaked. However, it is still required that they are
+closed when operations are completed:</p>
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { open } <span class="hljs-keyword">from</span> <span class="hljs-string">'fs/promises'</span>;
+
+<span class="hljs-keyword">let</span> file;
+<span class="hljs-keyword">try</span> {
+  file = <span class="hljs-keyword">await</span> <span class="hljs-title function_">open</span>(<span class="hljs-string">'/open/some/file.txt'</span>, <span class="hljs-string">'r'</span>);
+  <span class="hljs-keyword">const</span> stat = <span class="hljs-keyword">await</span> file.<span class="hljs-title function_">stat</span>();
+  <span class="hljs-comment">// use stat</span>
+} <span class="hljs-keyword">finally</span> {
+  <span class="hljs-keyword">await</span> file.<span class="hljs-title function_">close</span>();
+}</code></pre>
+<h4>Threadpool usage<span><a class="mark" href="#fs_threadpool_usage" id="fs_threadpool_usage">#</a></span></h4>
+<p>All callback and promise-based file system APIs ( with the exception of
+<code>fs.FSWatcher()</code>) use libuv's threadpool. This can have surprising and negative
+performance implications for some applications. See the
+<a href="cli.html#cli_uv_threadpool_size_size"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>
+<h4>File system flags<span><a class="mark" href="#fs_file_system_flags" id="fs_file_system_flags">#</a></span></h4>
 <p>The following flags are available wherever the <code>flag</code> option takes a
 string.</p>
 <ul>
@@ -5849,33 +6592,69 @@ or <code>O_EXCL|O_CREAT</code> to <code>CREATE_NEW</code>, as accepted by <code>
 <p>The exclusive flag <code>'x'</code> (<code>O_EXCL</code> flag in <a href="http://man7.org/linux/man-pages/man2/open.2.html"><code>open(2)</code></a>) causes the operation to
 return an error if the path already exists. On POSIX, if the path is a symbolic
 link, using <code>O_EXCL</code> returns an error even if the link is to a path that does
-not exist. The exclusive flag may or may not work with network file systems.</p>
+not exist. The exclusive flag might not work with network file systems.</p>
 <p>On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
 the end of the file.</p>
-<p>Modifying a file rather than replacing it may require a flags mode of <code>'r+'</code>
-rather than the default mode <code>'w'</code>.</p>
+<p>Modifying a file rather than replacing it may require the <code>flag</code> option to be
+set to <code>'r+'</code> rather than the default <code>'w'</code>.</p>
 <p>The behavior of some flags are platform-specific. As such, opening a directory
 on macOS and Linux with the <code>'a+'</code> flag, as in the example below, will return an
 error. In contrast, on Windows and FreeBSD, a file descriptor or a <code>FileHandle</code>
 will be returned.</p>
 <pre><code class="language-js"><span class="hljs-comment">// macOS and Linux</span>
-fs.open(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-string">'a+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+fs.<span class="hljs-title function_">open</span>(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-string">'a+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-comment">// => [Error: EISDIR: illegal operation on a directory, open &#x3C;directory>]</span>
 });
 
 <span class="hljs-comment">// Windows and FreeBSD</span>
-fs.open(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-string">'a+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
+fs.<span class="hljs-title function_">open</span>(<span class="hljs-string">'&#x3C;directory>'</span>, <span class="hljs-string">'a+'</span>, <span class="hljs-function">(<span class="hljs-params">err, fd</span>) =></span> {
   <span class="hljs-comment">// => null, &#x3C;fd></span>
 });</code></pre>
 <p>On Windows, opening an existing hidden file using the <code>'w'</code> flag (either
 through <code>fs.open()</code> or <code>fs.writeFile()</code> or <code>fsPromises.open()</code>) will fail with
 <code>EPERM</code>. Existing hidden files can be opened for writing with the <code>'r+'</code> flag.</p>
 <p>A call to <code>fs.ftruncate()</code> or <code>filehandle.truncate()</code> can be used to reset
-the file contents.</p>
+the file contents.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/fs.json b/doc/api/fs.json
index 1fe8ce0d8433068029e606225e1f14c6c3569558..608dbc25484ed8cbf743a7f03701ede0764ab284 100644
--- a/doc/api/fs.json
+++ b/doc/api/fs.json
@@ -8,76 +8,58 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/fs.js\">lib/fs.js</a></p>\n<p>The <code>fs</code> module enables interacting with the file system in a\nway modeled on standard POSIX functions.</p>\n<p>To use this module:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n</code></pre>\n<p>All file system operations have synchronous, callback, and promise-based\nforms.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/fs.js\">lib/fs.js</a></p>\n<p>The <code>fs</code> module enables interacting with the file system in a\nway modeled on standard POSIX functions.</p>\n<p>To use the promise-based APIs:</p>\n<pre><code class=\"language-mjs\">import * as fs from 'fs/promises';\n</code></pre>\n<pre><code class=\"language-cjs\">const fs = require('fs/promises');\n</code></pre>\n<p>To use the callback and sync APIs:</p>\n<pre><code class=\"language-mjs\">import * as fs from 'fs';\n</code></pre>\n<pre><code class=\"language-cjs\">const fs = require('fs');\n</code></pre>\n<p>All file system operations have synchronous, callback, and promise-based\nforms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).</p>",
       "modules": [
         {
-          "textRaw": "Synchronous example",
-          "name": "synchronous_example",
-          "desc": "<p>The synchronous form blocks the Node.js event loop and further JavaScript\nexecution until the operation is complete. Exceptions are thrown immediately\nand can be handled using <code>try…catch</code>, or can be allowed to bubble up.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\ntry {\n  fs.unlinkSync('/tmp/hello');\n  console.log('successfully deleted /tmp/hello');\n} catch (err) {\n  // handle the error\n}\n</code></pre>",
+          "textRaw": "Promise example",
+          "name": "promise_example",
+          "desc": "<p>Promise-based operations return a promise that is fulfilled when the\nasynchronous operation is complete.</p>\n<pre><code class=\"language-mjs\">import { unlink } from 'fs/promises';\n\ntry {\n  await unlink('/tmp/hello');\n  console.log('successfully deleted /tmp/hello');\n} catch (error) {\n  console.error('there was an error:', error.message);\n}\n</code></pre>\n<pre><code class=\"language-cjs\">const { unlink } = require('fs/promises');\n\n(async function(path) {\n  try {\n    await unlink(path);\n    console.log(`successfully deleted ${path}`);\n  } catch (error) {\n    console.error('there was an error:', error.message);\n  }\n})('/tmp/hello');\n</code></pre>",
           "type": "module",
-          "displayName": "Synchronous example"
+          "displayName": "Promise example"
         },
         {
           "textRaw": "Callback example",
           "name": "callback_example",
-          "desc": "<p>The callback form takes a completion callback function as its last\nargument and invokes the operation asynchronously. The arguments passed to\nthe completion callback depend on the method, but the first argument is always\nreserved for an exception. If the operation is completed successfully, then\nthe first argument is <code>null</code> or <code>undefined</code>.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nfs.unlink('/tmp/hello', (err) => {\n  if (err) throw err;\n  console.log('successfully deleted /tmp/hello');\n});\n</code></pre>",
+          "desc": "<p>The callback form takes a completion callback function as its last\nargument and invokes the operation asynchronously. The arguments passed to\nthe completion callback depend on the method, but the first argument is always\nreserved for an exception. If the operation is completed successfully, then\nthe first argument is <code>null</code> or <code>undefined</code>.</p>\n<pre><code class=\"language-mjs\">import { unlink } from 'fs';\n\nunlink('/tmp/hello', (err) => {\n  if (err) throw err;\n  console.log('successfully deleted /tmp/hello');\n});\n</code></pre>\n<pre><code class=\"language-cjs\">const { unlink } = require('fs');\n\nunlink('/tmp/hello', (err) => {\n  if (err) throw err;\n  console.log('successfully deleted /tmp/hello');\n});\n</code></pre>\n<p>The callback-based versions of the <code>fs</code> module APIs are preferable over\nthe use of the promise APIs when maximal performance (both in terms of\nexecution time and memory allocation are required).</p>",
           "type": "module",
           "displayName": "Callback example"
         },
         {
-          "textRaw": "Promise example",
-          "name": "promise_example",
-          "desc": "<p>Promise-based operations return a <code>Promise</code> that is resolved when the\nasynchronous operation is complete.</p>\n<pre><code class=\"language-js\">const fs = require('fs').promises;\n\n(async function(path) {\n  try {\n    await fs.unlink(path);\n    console.log(`successfully deleted ${path}`);\n  } catch (error) {\n    console.error('there was an error:', error.message);\n  }\n})('/tmp/hello');\n</code></pre>",
-          "type": "module",
-          "displayName": "Promise example"
-        },
-        {
-          "textRaw": "Ordering of callback and promise-based operations",
-          "name": "ordering_of_callback_and_promise-based_operations",
-          "desc": "<p>There is no guaranteed ordering when using either the callback or\npromise-based methods. For example, the following is prone to error\nbecause the <code>fs.stat()</code> operation might complete before the <code>fs.rename()</code>\noperation:</p>\n<pre><code class=\"language-js\">fs.rename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  console.log('renamed complete');\n});\nfs.stat('/tmp/world', (err, stats) => {\n  if (err) throw err;\n  console.log(`stats: ${JSON.stringify(stats)}`);\n});\n</code></pre>\n<p>To correctly order the operations, move the <code>fs.stat()</code> call into the callback\nof the <code>fs.rename()</code> operation:</p>\n<pre><code class=\"language-js\">fs.rename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  fs.stat('/tmp/world', (err, stats) => {\n    if (err) throw err;\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  });\n});\n</code></pre>\n<p>Or, use the promise-based API:</p>\n<pre><code class=\"language-js\">const fs = require('fs').promises;\n\n(async function(from, to) {\n  try {\n    await fs.rename(from, to);\n    const stats = await fs.stat(to);\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  } catch (error) {\n    console.error('there was an error:', error.message);\n  }\n})('/tmp/hello', '/tmp/world');\n</code></pre>",
+          "textRaw": "Synchronous example",
+          "name": "synchronous_example",
+          "desc": "<p>The synchronous APIs block the Node.js event loop and further JavaScript\nexecution until the operation is complete. Exceptions are thrown immediately\nand can be handled using <code>try…catch</code>, or can be allowed to bubble up.</p>\n<pre><code class=\"language-mjs\">import { unlinkSync } from 'fs';\n\ntry {\n  unlinkSync('/tmp/hello');\n  console.log('successfully deleted /tmp/hello');\n} catch (err) {\n  // handle the error\n}\n</code></pre>\n<pre><code class=\"language-cjs\">const { unlinkSync } = require('fs');\n\ntry {\n  unlinkSync('/tmp/hello');\n  console.log('successfully deleted /tmp/hello');\n} catch (err) {\n  // handle the error\n}\n</code></pre>",
           "type": "module",
-          "displayName": "Ordering of callback and promise-based operations"
+          "displayName": "Synchronous example"
         },
         {
-          "textRaw": "File paths",
-          "name": "file_paths",
-          "desc": "<p>Most <code>fs</code> operations accept filepaths that may be specified in the form of\na string, a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object using the <code>file:</code> protocol.</p>\n<p>String form paths are interpreted as UTF-8 character sequences identifying\nthe absolute or relative filename. Relative paths will be resolved relative\nto the current working directory as determined by calling <code>process.cwd()</code>.</p>\n<p>Example using an absolute path on POSIX:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nfs.open('/open/some/file.txt', 'r', (err, fd) => {\n  if (err) throw err;\n  fs.close(fd, (err) => {\n    if (err) throw err;\n  });\n});\n</code></pre>\n<p>Example using a relative path on POSIX (relative to <code>process.cwd()</code>):</p>\n<pre><code class=\"language-js\">fs.open('file.txt', 'r', (err, fd) => {\n  if (err) throw err;\n  fs.close(fd, (err) => {\n    if (err) throw err;\n  });\n});\n</code></pre>\n<p>Paths specified using a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a> are useful primarily on certain POSIX\noperating systems that treat file paths as opaque byte sequences. On such\nsystems, it is possible for a single file path to contain sub-sequences that\nuse multiple character encodings. As with string paths, <code>Buffer</code> paths may\nbe relative or absolute:</p>\n<p>Example using an absolute path on POSIX:</p>\n<pre><code class=\"language-js\">fs.open(Buffer.from('/open/some/file.txt'), 'r', (err, fd) => {\n  if (err) throw err;\n  fs.close(fd, (err) => {\n    if (err) throw err;\n  });\n});\n</code></pre>\n<p>On Windows, Node.js follows the concept of per-drive working directory. This\nbehavior can be observed when using a drive path without a backslash. For\nexample <code>fs.readdirSync('C:\\\\')</code> can potentially return a different result than\n<code>fs.readdirSync('C:')</code>. For more information, see\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths\">this MSDN page</a>.</p>",
-          "modules": [
-            {
-              "textRaw": "URL object support",
-              "name": "url_object_support",
-              "meta": {
-                "added": [
-                  "v7.6.0"
+          "textRaw": "Promises API",
+          "name": "promises_api",
+          "meta": {
+            "added": [
+              "v10.0.0"
+            ],
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31553",
+                "description": "Exposed as `require('fs/promises')`."
+              },
+              {
+                "version": [
+                  "v11.14.0",
+                  "v10.17.0"
                 ],
-                "changes": []
+                "pr-url": "https://github.com/nodejs/node/pull/26581",
+                "description": "This API is no longer experimental."
               },
-              "desc": "<p>For most <code>fs</code> module functions, the <code>path</code> or <code>filename</code> argument may be passed\nas a WHATWG <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. Only <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> objects using the <code>file:</code> protocol\nare supported.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fileUrl = new URL('file:///tmp/hello');\n\nfs.readFileSync(fileUrl);\n</code></pre>\n<p><code>file:</code> URLs are always absolute paths.</p>\n<p>Using WHATWG <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> objects might introduce platform-specific behaviors.</p>\n<p>On Windows, <code>file:</code> URLs with a host name convert to UNC paths, while <code>file:</code>\nURLs with drive letters convert to local absolute paths. <code>file:</code> URLs without a\nhost name nor a drive letter will result in a throw:</p>\n<pre><code class=\"language-js\">// On Windows :\n\n// - WHATWG file URLs with hostname convert to UNC path\n// file://hostname/p/a/t/h/file => \\\\hostname\\p\\a\\t\\h\\file\nfs.readFileSync(new URL('file://hostname/p/a/t/h/file'));\n\n// - WHATWG file URLs with drive letters convert to absolute path\n// file:///C:/tmp/hello => C:\\tmp\\hello\nfs.readFileSync(new URL('file:///C:/tmp/hello'));\n\n// - WHATWG file URLs without hostname must have a drive letters\nfs.readFileSync(new URL('file:///notdriveletter/p/a/t/h/file'));\nfs.readFileSync(new URL('file:///c/p/a/t/h/file'));\n// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute\n</code></pre>\n<p><code>file:</code> URLs with drive letters must use <code>:</code> as a separator just after\nthe drive letter. Using another separator will result in a throw.</p>\n<p>On all other platforms, <code>file:</code> URLs with a host name are unsupported and will\nresult in a throw:</p>\n<pre><code class=\"language-js\">// On other platforms:\n\n// - WHATWG file URLs with hostname are unsupported\n// file://hostname/p/a/t/h/file => throw!\nfs.readFileSync(new URL('file://hostname/p/a/t/h/file'));\n// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute\n\n// - WHATWG file URLs convert to absolute path\n// file:///tmp/hello => /tmp/hello\nfs.readFileSync(new URL('file:///tmp/hello'));\n</code></pre>\n<p>A <code>file:</code> URL having encoded slash characters will result in a throw on all\nplatforms:</p>\n<pre><code class=\"language-js\">// On Windows\nfs.readFileSync(new URL('file:///C:/p/a/t/h/%2F'));\nfs.readFileSync(new URL('file:///C:/p/a/t/h/%2f'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n\\ or / characters */\n\n// On POSIX\nfs.readFileSync(new URL('file:///p/a/t/h/%2F'));\nfs.readFileSync(new URL('file:///p/a/t/h/%2f'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n/ characters */\n</code></pre>\n<p>On Windows, <code>file:</code> URLs having encoded backslash will result in a throw:</p>\n<pre><code class=\"language-js\">// On Windows\nfs.readFileSync(new URL('file:///C:/path/%5C'));\nfs.readFileSync(new URL('file:///C:/path/%5c'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n\\ or / characters */\n</code></pre>",
-              "type": "module",
-              "displayName": "URL object support"
-            }
-          ],
-          "type": "module",
-          "displayName": "File paths"
-        },
-        {
-          "textRaw": "File descriptors",
-          "name": "file_descriptors",
-          "desc": "<p>On POSIX systems, for every process, the kernel maintains a table of currently\nopen files and resources. Each open file is assigned a simple numeric\nidentifier called a <em>file descriptor</em>. At the system-level, all file system\noperations use these file descriptors to identify and track each specific\nfile. Windows systems use a different but conceptually similar mechanism for\ntracking resources. To simplify things for users, Node.js abstracts away the\nspecific differences between operating systems and assigns all open files a\nnumeric file descriptor.</p>\n<p>The <code>fs.open()</code> method is used to allocate a new file descriptor. Once\nallocated, the file descriptor may be used to read data from, write data to,\nor request information about the file.</p>\n<pre><code class=\"language-js\">fs.open('/open/some/file.txt', 'r', (err, fd) => {\n  if (err) throw err;\n  fs.fstat(fd, (err, stat) => {\n    if (err) throw err;\n    // use stat\n\n    // always close the file descriptor!\n    fs.close(fd, (err) => {\n      if (err) throw err;\n    });\n  });\n});\n</code></pre>\n<p>Most operating systems limit the number of file descriptors that may be open\nat any given time so it is critical to close the descriptor when operations\nare completed. Failure to do so will result in a memory leak that will\neventually cause an application to crash.</p>",
-          "type": "module",
-          "displayName": "File descriptors"
-        },
-        {
-          "textRaw": "Threadpool usage",
-          "name": "threadpool_usage",
-          "desc": "<p>All file system APIs except <code>fs.FSWatcher()</code> and those that are explicitly\nsynchronous use libuv's threadpool, which can have surprising and negative\nperformance implications for some applications. See the\n<a href=\"cli.html#cli_uv_threadpool_size_size\"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>",
-          "type": "module",
-          "displayName": "Threadpool usage"
-        },
-        {
-          "textRaw": "`fs` Promises API",
-          "name": "`fs`_promises_api",
-          "desc": "<p>The <code>fs.promises</code> API provides an alternative set of asynchronous file system\nmethods that return <code>Promise</code> objects rather than using callbacks. The\nAPI is accessible via <code>require('fs').promises</code>.</p>",
+              {
+                "version": "v10.1.0",
+                "pr-url": "https://github.com/nodejs/node/pull/20504",
+                "description": "The API is accessible via `require('fs').promises` only."
+              }
+            ]
+          },
+          "desc": "<p>The <code>fs/promises</code> API provides asynchronous file system methods that return\npromises.</p>\n<p>The promise APIs use the underlying Node.js threadpool to perform file\nsystem operations off the event loop thread. These operations are not\nsynchronized or threadsafe. Care must be taken when performing multiple\nconcurrent modifications on the same file or data corruption may occur.</p>",
           "classes": [
             {
               "textRaw": "Class: `FileHandle`",
@@ -89,10 +71,10 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A <code>FileHandle</code> object is a wrapper for a numeric file descriptor.\nInstances of <code>FileHandle</code> are distinct from numeric file descriptors\nin that they provide an object oriented API for working with files.</p>\n<p>If a <code>FileHandle</code> is not closed using the\n<code>filehandle.close()</code> method, it might automatically close the file descriptor\nand will emit a process warning, thereby helping to prevent memory leaks.\nPlease do not rely on this behavior because it is unreliable and\nthe file may not be closed. Instead, always explicitly close <code>FileHandle</code>s.\nNode.js may change this behavior in the future.</p>\n<p>Instances of the <code>FileHandle</code> object are created internally by the\n<code>fsPromises.open()</code> method.</p>\n<p>Unlike the callback-based API (<code>fs.fstat()</code>, <code>fs.fchown()</code>, <code>fs.fchmod()</code>, and\nso on), a numeric file descriptor is not used by the promise-based API. Instead,\nthe promise-based API uses the <code>FileHandle</code> class in order to help avoid\naccidental leaking of unclosed file descriptors after a <code>Promise</code> is resolved or\nrejected.</p>",
+              "desc": "<p>A <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> object is an object wrapper for a numeric file descriptor.</p>\n<p>Instances of the <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> object are created by the <code>fsPromises.open()</code>\nmethod.</p>\n<p>All <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> objects are <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a>s.</p>\n<p>If a <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> is not closed using the <code>filehandle.close()</code> method, it will\ntry to automatically close the file descriptor and emit a process warning,\nhelping to prevent memory leaks. Please do not rely on this behavior because\nit can be unreliable and the file may not be closed. Instead, always explicitly\nclose <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a>s. Node.js may change this behavior in the future.</p>",
               "methods": [
                 {
-                  "textRaw": "`filehandle.appendFile(data, options)`",
+                  "textRaw": "`filehandle.appendFile(data[, options])`",
                   "type": "method",
                   "name": "appendFile",
                   "meta": {
@@ -104,15 +86,16 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": [
                         {
-                          "textRaw": "`data` {string|Buffer}",
+                          "textRaw": "`data` {string|Buffer|TypedArray|DataView}",
                           "name": "data",
-                          "type": "string|Buffer"
+                          "type": "string|Buffer|TypedArray|DataView"
                         },
                         {
                           "textRaw": "`options` {Object|string}",
@@ -145,20 +128,22 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": [
                         {
-                          "textRaw": "`mode` {integer}",
+                          "textRaw": "`mode` {integer} the file mode bit mask.",
                           "name": "mode",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "the file mode bit mask."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Modifies the permissions on the file. The <code>Promise</code> is resolved with no\narguments upon success.</p>"
+                  "desc": "<p>Modifies the permissions on the file. See <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>.</p>"
                 },
                 {
                   "textRaw": "`filehandle.chown(uid, gid)`",
@@ -173,25 +158,28 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": [
                         {
-                          "textRaw": "`uid` {integer}",
+                          "textRaw": "`uid` {integer} The file's new owner's user id.",
                           "name": "uid",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The file's new owner's user id."
                         },
                         {
-                          "textRaw": "`gid` {integer}",
+                          "textRaw": "`gid` {integer} The file's new group's group id.",
                           "name": "gid",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The file's new group's group id."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Changes the ownership of the file then resolves the <code>Promise</code> with no arguments\nupon success.</p>"
+                  "desc": "<p>Changes the ownership of the file. A wrapper for <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>.</p>"
                 },
                 {
                   "textRaw": "`filehandle.close()`",
@@ -206,15 +194,15 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise} A `Promise` that will be resolved once the underlying file descriptor is closed, or will be rejected if an error occurs while closing.",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
                         "type": "Promise",
-                        "desc": "A `Promise` that will be resolved once the underlying file descriptor is closed, or will be rejected if an error occurs while closing."
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": []
                     }
                   ],
-                  "desc": "<p>Closes the file descriptor.</p>\n<pre><code class=\"language-js\">const fsPromises = require('fs').promises;\nasync function openAndClose() {\n  let filehandle;\n  try {\n    filehandle = await fsPromises.open('thefile.txt', 'r');\n  } finally {\n    if (filehandle !== undefined)\n      await filehandle.close();\n  }\n}\n</code></pre>"
+                  "desc": "<p>Closes the file handle after waiting for any pending operation on the handle to\ncomplete.</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet filehandle;\ntry {\n  filehandle = await open('thefile.txt', 'r');\n} finally {\n  await filehandle?.close();\n}\n</code></pre>"
                 },
                 {
                   "textRaw": "`filehandle.datasync()`",
@@ -229,14 +217,15 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": []
                     }
                   ],
-                  "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon\nsuccess.</p>"
+                  "desc": "<p>Forces all currently queued I/O operations associated with the file to the\noperating system's synchronized I/O completion state. Refer to the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a> documentation for details.</p>\n<p>Unlike <code>filehandle.sync</code> this method does not flush modified metadata.</p>"
                 },
                 {
                   "textRaw": "`filehandle.read(buffer, offset, length, position)`",
@@ -251,42 +240,64 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills upon success with an object with two properties:",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills upon success with an object with two properties:",
+                        "options": [
+                          {
+                            "textRaw": "`bytesRead` {integer} The number of bytes read",
+                            "name": "bytesRead",
+                            "type": "integer",
+                            "desc": "The number of bytes read"
+                          },
+                          {
+                            "textRaw": "`buffer` {Buffer|TypedArray|DataView} A reference to the passed in `buffer` argument.",
+                            "name": "buffer",
+                            "type": "Buffer|TypedArray|DataView",
+                            "desc": "A reference to the passed in `buffer` argument."
+                          }
+                        ]
                       },
                       "params": [
                         {
-                          "textRaw": "`buffer` {Buffer|Uint8Array}",
+                          "textRaw": "`buffer` {Buffer|TypedArray|DataView} A buffer that will be filled with the file data read.",
                           "name": "buffer",
-                          "type": "Buffer|Uint8Array"
+                          "type": "Buffer|TypedArray|DataView",
+                          "desc": "A buffer that will be filled with the file data read."
                         },
                         {
-                          "textRaw": "`offset` {integer}",
+                          "textRaw": "`offset` {integer} The location in the buffer at which to start filling. **Default:** `0`",
                           "name": "offset",
-                          "type": "integer"
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "The location in the buffer at which to start filling."
                         },
                         {
-                          "textRaw": "`length` {integer}",
+                          "textRaw": "`length` {integer} The number of bytes to read. **Default:** `buffer.byteLength`",
                           "name": "length",
-                          "type": "integer"
+                          "type": "integer",
+                          "default": "`buffer.byteLength`",
+                          "desc": "The number of bytes to read."
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an integer, the current file position will remain unchanged.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an integer, the current file position will remain unchanged."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Read data from the file.</p>\n<p><code>buffer</code> is the buffer that the data will be written to.</p>\n<p><code>offset</code> is the offset in the buffer to start writing at.</p>\n<p><code>length</code> is an integer specifying the number of bytes to read.</p>\n<p><code>position</code> is an argument specifying where to begin reading from in the file.\nIf <code>position</code> is <code>null</code>, data will be read from the current file position,\nand the file position will be updated.\nIf <code>position</code> is an integer, the file position will remain unchanged.</p>\n<p>Following successful read, the <code>Promise</code> is resolved with an object with a\n<code>bytesRead</code> property specifying the number of bytes read, and a <code>buffer</code>\nproperty that is a reference to the passed in <code>buffer</code> argument.</p>"
+                  "desc": "<p>Reads data from the file and stores that in the given buffer.</p>\n<p>If the file is not modified concurrently, the end-of-file is reached when the\nnumber of bytes read is zero.</p>"
                 },
                 {
-                  "textRaw": "`filehandle.read(options)`",
+                  "textRaw": "`filehandle.read([options])`",
                   "type": "method",
                   "name": "read",
                   "meta": {
                     "added": [
+                      "v13.11.0",
                       "v12.17.0"
                     ],
                     "changes": []
@@ -294,9 +305,24 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills upon success with an object with two properties:",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills upon success with an object with two properties:",
+                        "options": [
+                          {
+                            "textRaw": "`bytesRead` {integer} The number of bytes read",
+                            "name": "bytesRead",
+                            "type": "integer",
+                            "desc": "The number of bytes read"
+                          },
+                          {
+                            "textRaw": "`buffer` {Buffer|TypedArray|DataView} A reference to the passed in `buffer` argument.",
+                            "name": "buffer",
+                            "type": "Buffer|TypedArray|DataView",
+                            "desc": "A reference to the passed in `buffer` argument."
+                          }
+                        ]
                       },
                       "params": [
                         {
@@ -305,34 +331,39 @@
                           "type": "Object",
                           "options": [
                             {
-                              "textRaw": "`buffer` {Buffer|Uint8Array} **Default:** `Buffer.alloc(16384)`",
+                              "textRaw": "`buffer` {Buffer|TypedArray|DataView} A buffer that will be filled with the file data read. **Default:** `Buffer.alloc(16384)`",
                               "name": "buffer",
-                              "type": "Buffer|Uint8Array",
-                              "default": "`Buffer.alloc(16384)`"
+                              "type": "Buffer|TypedArray|DataView",
+                              "default": "`Buffer.alloc(16384)`",
+                              "desc": "A buffer that will be filled with the file data read."
                             },
                             {
-                              "textRaw": "`offset` {integer} **Default:** `0`",
+                              "textRaw": "`offset` {integer} The location in the buffer at which to start filling. **Default:** `0`",
                               "name": "offset",
                               "type": "integer",
-                              "default": "`0`"
+                              "default": "`0`",
+                              "desc": "The location in the buffer at which to start filling."
                             },
                             {
-                              "textRaw": "`length` {integer} **Default:** `buffer.length`",
+                              "textRaw": "`length` {integer} The number of bytes to read. **Default:** `buffer.byteLength`",
                               "name": "length",
                               "type": "integer",
-                              "default": "`buffer.length`"
+                              "default": "`buffer.byteLength`",
+                              "desc": "The number of bytes to read."
                             },
                             {
-                              "textRaw": "`position` {integer} **Default:** `null`",
+                              "textRaw": "`position` {integer} The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an integer, the current file position will remain unchanged. **Default:**: `null`",
                               "name": "position",
                               "type": "integer",
-                              "default": "`null`"
+                              "default": ": `null`",
+                              "desc": "The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an integer, the current file position will remain unchanged."
                             }
                           ]
                         }
                       ]
                     }
-                  ]
+                  ],
+                  "desc": "<p>Reads data from the file and stores that in the given buffer.</p>\n<p>If the file is not modified concurrently, the end-of-file is reached when the\nnumber of bytes read is zero.</p>"
                 },
                 {
                   "textRaw": "`filehandle.readFile(options)`",
@@ -347,9 +378,10 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills upon a successful read with the contents of the file. If no encoding is specified (using `options.encoding`), the data is returned as a {Buffer} object. Otherwise, the data will be a string.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills upon a successful read with the contents of the file. If no encoding is specified (using `options.encoding`), the data is returned as a {Buffer} object. Otherwise, the data will be a string."
                       },
                       "params": [
                         {
@@ -362,13 +394,19 @@
                               "name": "encoding",
                               "type": "string|null",
                               "default": "`null`"
+                            },
+                            {
+                              "textRaw": "`signal` {AbortSignal} allows aborting an in-progress readFile",
+                              "name": "signal",
+                              "type": "AbortSignal",
+                              "desc": "allows aborting an in-progress readFile"
                             }
                           ]
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<p>The <code>Promise</code> is resolved with the contents of the file. If no encoding is\nspecified (using <code>options.encoding</code>), the data is returned as a <code>Buffer</code>\nobject. Otherwise, the data will be a string.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>The <code>FileHandle</code> has to support reading.</p>\n<p>If one or more <code>filehandle.read()</code> calls are made on a file handle and then a\n<code>filehandle.readFile()</code> call is made, the data will be read from the current\nposition till the end of the file. It doesn't always read from the beginning\nof the file.</p>"
+                  "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>\n<p>The <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> has to support reading.</p>\n<p>If one or more <code>filehandle.read()</code> calls are made on a file handle and then a\n<code>filehandle.readFile()</code> call is made, the data will be read from the current\nposition till the end of the file. It doesn't always read from the beginning\nof the file.</p>"
                 },
                 {
                   "textRaw": "`filehandle.readv(buffers[, position])`",
@@ -376,6 +414,7 @@
                   "name": "readv",
                   "meta": {
                     "added": [
+                      "v13.13.0",
                       "v12.17.0"
                     ],
                     "changes": []
@@ -383,25 +422,41 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills upon success an object containing two properties:",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills upon success an object containing two properties:",
+                        "options": [
+                          {
+                            "textRaw": "`bytesRead` {integer} the number of bytes read",
+                            "name": "bytesRead",
+                            "type": "integer",
+                            "desc": "the number of bytes read"
+                          },
+                          {
+                            "textRaw": "`buffers` {Buffer[]|TypedArray[]|DataView[]} property containing a reference to the `buffers` input.",
+                            "name": "buffers",
+                            "type": "Buffer[]|TypedArray[]|DataView[]",
+                            "desc": "property containing a reference to the `buffers` input."
+                          }
+                        ]
                       },
                       "params": [
                         {
-                          "textRaw": "`buffers` {ArrayBufferView[]}",
+                          "textRaw": "`buffers` {Buffer[]|TypedArray[]|DataView[]}",
                           "name": "buffers",
-                          "type": "ArrayBufferView[]"
+                          "type": "Buffer[]|TypedArray[]|DataView[]"
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The offset from the beginning of the file where the data should be read from. If `position` is not a `number`, the data will be read from the current position.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The offset from the beginning of the file where the data should be read from. If `position` is not a `number`, the data will be read from the current position."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Read from a file and write to an array of <code>ArrayBufferView</code>s</p>\n<p>The <code>Promise</code> is resolved with an object containing a <code>bytesRead</code> property\nidentifying the number of bytes read, and a <code>buffers</code> property containing\na reference to the <code>buffers</code> input.</p>\n<p><code>position</code> is the offset from the beginning of the file where this data\nshould be read from. If <code>typeof position !== 'number'</code>, the data will be read\nfrom the current position.</p>"
+                  "desc": "<p>Read from a file and write to an array of <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView\" class=\"type\">&lt;ArrayBufferView&gt;</a>s</p>"
                 },
                 {
                   "textRaw": "`filehandle.stat([options])`",
@@ -422,9 +477,10 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with an {fs.Stats} for the file.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with an {fs.Stats} for the file."
                       },
                       "params": [
                         {
@@ -433,18 +489,17 @@
                           "type": "Object",
                           "options": [
                             {
-                              "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
+                              "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
                               "name": "bigint",
                               "type": "boolean",
                               "default": "`false`",
-                              "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                              "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
                             }
                           ]
                         }
                       ]
                     }
-                  ],
-                  "desc": "<p>Retrieves the <a href=\"#fs_class_fs_stats\"><code>fs.Stats</code></a> for the file.</p>"
+                  ]
                 },
                 {
                   "textRaw": "`filehandle.sync()`",
@@ -459,14 +514,15 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fufills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fufills with `undefined` upon success."
                       },
                       "params": []
                     }
                   ],
-                  "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon\nsuccess.</p>"
+                  "desc": "<p>Request that all data for the open file descriptor is flushed to the storage\ndevice. The specific implementation is operating system and device specific.\nRefer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a> documentation for more detail.</p>"
                 },
                 {
                   "textRaw": "`filehandle.truncate(len)`",
@@ -481,9 +537,10 @@
                   "signatures": [
                     {
                       "return": {
-                        "textRaw": "Returns: {Promise}",
+                        "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                         "name": "return",
-                        "type": "Promise"
+                        "type": "Promise",
+                        "desc": "Fulfills with `undefined` upon success."
                       },
                       "params": [
                         {
@@ -495,7 +552,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Truncates the file then resolves the <code>Promise</code> with no arguments upon success.</p>\n<p>If the file was larger than <code>len</code> bytes, only the first <code>len</code> bytes will be\nretained in the file.</p>\n<p>For example, the following program retains only the first four bytes of the\nfile:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fsPromises = fs.promises;\n\nconsole.log(fs.readFileSync('temp.txt', 'utf8'));\n// Prints: Node.js\n\nasync function doTruncate() {\n  let filehandle = null;\n  try {\n    filehandle = await fsPromises.open('temp.txt', 'r+');\n    await filehandle.truncate(4);\n  } finally {\n    if (filehandle) {\n      // Close the file if it is opened.\n      await filehandle.close();\n    }\n  }\n  console.log(fs.readFileSync('temp.txt', 'utf8'));  // Prints: Node\n}\n\ndoTruncate().catch(console.error);\n</code></pre>\n<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the\nextended part is filled with null bytes (<code>'\\0'</code>):</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fsPromises = fs.promises;\n\nconsole.log(fs.readFileSync('temp.txt', 'utf8'));\n// Prints: Node.js\n\nasync function doTruncate() {\n  let filehandle = null;\n  try {\n    filehandle = await fsPromises.open('temp.txt', 'r+');\n    await filehandle.truncate(10);\n  } finally {\n    if (filehandle) {\n      // Close the file if it is opened.\n      await filehandle.close();\n    }\n  }\n  console.log(fs.readFileSync('temp.txt', 'utf8'));  // Prints Node.js\\0\\0\\0\n}\n\ndoTruncate().catch(console.error);\n</code></pre>\n<p>The last three bytes are null bytes (<code>'\\0'</code>), to compensate the over-truncation.</p>"
+                  "desc": "<p>Truncates the file.</p>\n<p>If the file was larger than <code>len</code> bytes, only the first <code>len</code> bytes will be\nretained in the file.</p>\n<p>The following example retains only the first four bytes of the file:</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet filehandle = null;\ntry {\n  filehandle = await open('temp.txt', 'r+');\n  await filehandle.truncate(4);\n} finally {\n  await filehandle?.close();\n}\n</code></pre>\n<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the\nextended part is filled with null bytes (<code>'\\0'</code>):</p>\n<p>If <code>len</code> is negative then <code>0</code> will be used.</p>"
                 },
                 {
                   "textRaw": "`filehandle.utimes(atime, mtime)`",
@@ -528,7 +585,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Change the file system timestamps of the object referenced by the <code>FileHandle</code>\nthen resolves the <code>Promise</code> with no arguments upon success.</p>\n<p>This function does not work on AIX versions before 7.1, it will resolve the\n<code>Promise</code> with an error using code <code>UV_ENOSYS</code>.</p>"
+                  "desc": "<p>Change the file system timestamps of the object referenced by the <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a>\nthen resolves the promise with no arguments upon success.</p>\n<p>This function does not work on AIX versions before 7.1, it will reject the\npromise with an error using code <code>UV_ENOSYS</code>.</p>"
                 },
                 {
                   "textRaw": "`filehandle.write(buffer[, offset[, length[, position]]])`",
@@ -538,7 +595,18 @@
                     "added": [
                       "v10.0.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v14.12.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/34993",
+                        "description": "The `buffer` parameter will stringify an object with an explicit `toString` function."
+                      },
+                      {
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/31030",
+                        "description": "The `buffer` parameter won't coerce unsupported input to buffers anymore."
+                      }
+                    ]
                   },
                   "signatures": [
                     {
@@ -549,29 +617,34 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`buffer` {Buffer|Uint8Array}",
+                          "textRaw": "`buffer` {Buffer|TypedArray|DataView|string|Object}",
                           "name": "buffer",
-                          "type": "Buffer|Uint8Array"
+                          "type": "Buffer|TypedArray|DataView|string|Object"
                         },
                         {
-                          "textRaw": "`offset` {integer}",
+                          "textRaw": "`offset` {integer} The start position from within `buffer` where the data to write begins. **Default:** `0`",
                           "name": "offset",
-                          "type": "integer"
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "The start position from within `buffer` where the data to write begins."
                         },
                         {
-                          "textRaw": "`length` {integer}",
+                          "textRaw": "`length` {integer} The number of bytes from `buffer` to write. **Default:** `buffer.byteLength`",
                           "name": "length",
-                          "type": "integer"
+                          "type": "integer",
+                          "default": "`buffer.byteLength`",
+                          "desc": "The number of bytes from `buffer` to write."
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The offset from the beginning of the file where the data from `buffer` should be written. If `position` is not a `number`, the data will be written at the current position. See the POSIX pwrite(2) documentation for more detail.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The offset from the beginning of the file where the data from `buffer` should be written. If `position` is not a `number`, the data will be written at the current position. See the POSIX pwrite(2) documentation for more detail."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Write <code>buffer</code> to the file.</p>\n<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property\nidentifying the number of bytes written, and a <code>buffer</code> property containing\na reference to the <code>buffer</code> written.</p>\n<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is\nan integer specifying the number of bytes to write.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file\nwithout waiting for the <code>Promise</code> to be resolved (or rejected). For this\nscenario, use <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes do not work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+                  "desc": "<p>Write <code>buffer</code> to the file.</p>\n<p>If <code>buffer</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<p>The promise is resolved with an object containing two properties:</p>\n<ul>\n<li><code>bytesWritten</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> the number of bytes written</li>\n<li><code>buffer</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\" class=\"type\">&lt;TypedArray&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\" class=\"type\">&lt;DataView&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> a reference to the\n<code>buffer</code> written.</li>\n</ul>\n<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file\nwithout waiting for the promise to be resolved (or rejected). For this\nscenario, use <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes do not work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
                 },
                 {
                   "textRaw": "`filehandle.write(string[, position[, encoding]])`",
@@ -581,7 +654,18 @@
                     "added": [
                       "v10.0.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v14.12.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/34993",
+                        "description": "The `string` parameter will stringify an object with an explicit `toString` function."
+                      },
+                      {
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/31030",
+                        "description": "The `string` parameter won't coerce unsupported input to strings anymore."
+                      }
+                    ]
                   },
                   "signatures": [
                     {
@@ -592,25 +676,27 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`string` {string}",
+                          "textRaw": "`string` {string|Object}",
                           "name": "string",
-                          "type": "string"
+                          "type": "string|Object"
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The offset from the beginning of the file where the data from `string` should be written. If `position` is not a `number` the data will be written at the current position. See the POSIX pwrite(2) documentation for more detail.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The offset from the beginning of the file where the data from `string` should be written. If `position` is not a `number` the data will be written at the current position. See the POSIX pwrite(2) documentation for more detail."
                         },
                         {
-                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "textRaw": "`encoding` {string} The expected string encoding. **Default:** `'utf8'`",
                           "name": "encoding",
                           "type": "string",
-                          "default": "`'utf8'`"
+                          "default": "`'utf8'`",
+                          "desc": "The expected string encoding."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Write <code>string</code> to the file. If <code>string</code> is not a string, then\nthe value will be coerced to one.</p>\n<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property\nidentifying the number of bytes written, and a <code>buffer</code> property containing\na reference to the <code>string</code> written.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If the type of <code>position</code> is not a <code>number</code> the data\nwill be written at the current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p><code>encoding</code> is the expected string encoding.</p>\n<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file\nwithout waiting for the <code>Promise</code> to be resolved (or rejected). For this\nscenario, use <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes do not work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+                  "desc": "<p>Write <code>string</code> to the file. If <code>string</code> is not a string, or an object with an\nown <code>toString</code> function property, the promise is rejected with an error.</p>\n<p>The promise is resolved with an object containing two properties:</p>\n<ul>\n<li><code>bytesWritten</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> the number of bytes written</li>\n<li><code>buffer</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> a reference to the <code>string</code> written.</li>\n</ul>\n<p>It is unsafe to use <code>filehandle.write()</code> multiple times on the same file\nwithout waiting for the promise to be resolved (or rejected). For this\nscenario, use <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes do not work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
                 },
                 {
                   "textRaw": "`filehandle.writeFile(data, options)`",
@@ -620,7 +706,23 @@
                     "added": [
                       "v10.0.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v14.18.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/37490",
+                        "description": "The `data` argument supports `AsyncIterable`, `Iterable` and `Stream`."
+                      },
+                      {
+                        "version": "v14.12.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/34993",
+                        "description": "The `data` parameter will stringify an object with an explicit `toString` function."
+                      },
+                      {
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/31030",
+                        "description": "The `data` parameter won't coerce unsupported input to strings anymore."
+                      }
+                    ]
                   },
                   "signatures": [
                     {
@@ -631,9 +733,9 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`data` {string|Buffer|Uint8Array}",
+                          "textRaw": "`data` {string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable |Stream}",
                           "name": "data",
-                          "type": "string|Buffer|Uint8Array"
+                          "type": "string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable |Stream"
                         },
                         {
                           "textRaw": "`options` {Object|string}",
@@ -641,17 +743,18 @@
                           "type": "Object|string",
                           "options": [
                             {
-                              "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                              "textRaw": "`encoding` {string|null} The expected character encoding when `data` is a string. **Default:** `'utf8'`",
                               "name": "encoding",
                               "type": "string|null",
-                              "default": "`'utf8'`"
+                              "default": "`'utf8'`",
+                              "desc": "The expected character encoding when `data` is a string."
                             }
                           ]
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Asynchronously writes data to a file, replacing the file if it already exists.\n<code>data</code> can be a string or a buffer. The <code>Promise</code> will be resolved with no\narguments upon success.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>The <code>FileHandle</code> has to support writing.</p>\n<p>It is unsafe to use <code>filehandle.writeFile()</code> multiple times on the same file\nwithout waiting for the <code>Promise</code> to be resolved (or rejected).</p>\n<p>If one or more <code>filehandle.write()</code> calls are made on a file handle and then a\n<code>filehandle.writeFile()</code> call is made, the data will be written from the\ncurrent position till the end of the file. It doesn't always write from the\nbeginning of the file.</p>"
+                  "desc": "<p>Asynchronously writes data to a file, replacing the file if it already exists.\n<code>data</code> can be a string, a buffer, an <a href=\"https://tc39.github.io/ecma262/#sec-asynciterable-interface\" class=\"type\">&lt;AsyncIterable&gt;</a> or <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol\" class=\"type\">&lt;Iterable&gt;</a> object, or an\nobject with an own <code>toString</code> function\nproperty. The promise is resolved with no arguments upon success.</p>\n<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>\n<p>The <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> has to support writing.</p>\n<p>It is unsafe to use <code>filehandle.writeFile()</code> multiple times on the same file\nwithout waiting for the promise to be resolved (or rejected).</p>\n<p>If one or more <code>filehandle.write()</code> calls are made on a file handle and then a\n<code>filehandle.writeFile()</code> call is made, the data will be written from the\ncurrent position till the end of the file. It doesn't always write from the\nbeginning of the file.</p>"
                 },
                 {
                   "textRaw": "`filehandle.writev(buffers[, position])`",
@@ -672,24 +775,25 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`buffers` {ArrayBufferView[]}",
+                          "textRaw": "`buffers` {Buffer[]|TypedArray[]|DataView[]}",
                           "name": "buffers",
-                          "type": "ArrayBufferView[]"
+                          "type": "Buffer[]|TypedArray[]|DataView[]"
                         },
                         {
-                          "textRaw": "`position` {integer}",
+                          "textRaw": "`position` {integer} The offset from the beginning of the file where the data from `buffers` should be written. If `position` is not a `number`, the data will be written at the current position.",
                           "name": "position",
-                          "type": "integer"
+                          "type": "integer",
+                          "desc": "The offset from the beginning of the file where the data from `buffers` should be written. If `position` is not a `number`, the data will be written at the current position."
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>Write an array of <code>ArrayBufferView</code>s to the file.</p>\n<p>The <code>Promise</code> is resolved with an object containing a <code>bytesWritten</code> property\nidentifying the number of bytes written, and a <code>buffers</code> property containing\na reference to the <code>buffers</code> input.</p>\n<p><code>position</code> is the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position.</p>\n<p>It is unsafe to call <code>writev()</code> multiple times on the same file without waiting\nfor the previous operation to complete.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+                  "desc": "<p>Write an array of <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView\" class=\"type\">&lt;ArrayBufferView&gt;</a>s to the file.</p>\n<p>The promise is resolved with an object containing a two properties:</p>\n<ul>\n<li><code>bytesWritten</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;integer&gt;</a> the number of bytes written</li>\n<li><code>buffers</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\" class=\"type\">&lt;TypedArray[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\" class=\"type\">&lt;DataView[]&gt;</a> a reference to the <code>buffers</code>\ninput.</li>\n</ul>\n<p>It is unsafe to call <code>writev()</code> multiple times on the same file without waiting\nfor the promise to be resolved (or rejected).</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
                 }
               ],
               "properties": [
                 {
-                  "textRaw": "`fd` {number} The numeric file descriptor managed by the `FileHandle` object.",
+                  "textRaw": "`fd` {number} The numeric file descriptor managed by the {FileHandle} object.",
                   "type": "number",
                   "name": "fd",
                   "meta": {
@@ -698,7 +802,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "The numeric file descriptor managed by the `FileHandle` object."
+                  "desc": "The numeric file descriptor managed by the {FileHandle} object."
                 }
               ]
             }
@@ -717,9 +821,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -736,7 +841,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Tests a user's permissions for the file or directory specified by <code>path</code>.\nThe <code>mode</code> argument is an optional integer that specifies the accessibility\nchecks to be performed. Check <a href=\"#fs_file_access_constants\">File access constants</a> for possible values\nof <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of\ntwo or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>If the accessibility check is successful, the <code>Promise</code> is resolved with no\nvalue. If any of the accessibility checks fail, the <code>Promise</code> is rejected\nwith an <code>Error</code> object. The following example checks if the file\n<code>/etc/passwd</code> can be read and written by the current process.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fsPromises = fs.promises;\n\nfsPromises.access('/etc/passwd', fs.constants.R_OK | fs.constants.W_OK)\n  .then(() => console.log('can access'))\n  .catch(() => console.error('cannot access'));\n</code></pre>\n<p>Using <code>fsPromises.access()</code> to check for the accessibility of a file before\ncalling <code>fsPromises.open()</code> is not recommended. Doing so introduces a race\ncondition, since other processes may change the file's state between the two\ncalls. Instead, user code should open/read/write the file directly and handle\nthe error raised if the file is not accessible.</p>"
+              "desc": "<p>Tests a user's permissions for the file or directory specified by <code>path</code>.\nThe <code>mode</code> argument is an optional integer that specifies the accessibility\nchecks to be performed. Check <a href=\"#fs_file_access_constants\">File access constants</a> for possible values\nof <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of\ntwo or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>If the accessibility check is successful, the promise is resolved with no\nvalue. If any of the accessibility checks fail, the promise is rejected\nwith an <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\" class=\"type\">&lt;Error&gt;</a> object. The following example checks if the file\n<code>/etc/passwd</code> can be read and written by the current process.</p>\n<pre><code class=\"language-mjs\">import { access } from 'fs/promises';\nimport { constants } from 'fs';\n\ntry {\n  await access('/etc/passwd', constants.R_OK | constants.W_OK);\n  console.log('can access');\n} catch {\n  console.error('cannot access');\n}\n</code></pre>\n<p>Using <code>fsPromises.access()</code> to check for the accessibility of a file before\ncalling <code>fsPromises.open()</code> is not recommended. Doing so introduces a race\ncondition, since other processes may change the file's state between the two\ncalls. Instead, user code should open/read/write the file directly and handle\nthe error raised if the file is not accessible.</p>"
             },
             {
               "textRaw": "`fsPromises.appendFile(path, data[, options])`",
@@ -751,16 +856,17 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
-                      "textRaw": "`path` {string|Buffer|URL|FileHandle} filename or `FileHandle`",
+                      "textRaw": "`path` {string|Buffer|URL|FileHandle} filename or {FileHandle}",
                       "name": "path",
                       "type": "string|Buffer|URL|FileHandle",
-                      "desc": "filename or `FileHandle`"
+                      "desc": "filename or {FileHandle}"
                     },
                     {
                       "textRaw": "`data` {string|Buffer}",
@@ -796,7 +902,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>. The <code>Promise</code> will be\nresolved with no arguments upon success.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>The <code>path</code> may be specified as a <code>FileHandle</code> that has been opened\nfor appending (using <code>fsPromises.open()</code>).</p>"
+              "desc": "<p>Asynchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>If <code>options</code> is a string, then it specifies the <code>encoding</code>.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<p>The <code>path</code> may be specified as a <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> that has been opened\nfor appending (using <code>fsPromises.open()</code>).</p>"
             },
             {
               "textRaw": "`fsPromises.chmod(path, mode)`",
@@ -811,9 +917,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -829,7 +936,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the permissions of a file then resolves the <code>Promise</code> with no\narguments upon succces.</p>"
+              "desc": "<p>Changes the permissions of a file.</p>"
             },
             {
               "textRaw": "`fsPromises.chown(path, uid, gid)`",
@@ -844,9 +951,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -867,10 +975,10 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the ownership of a file then resolves the <code>Promise</code> with no arguments\nupon success.</p>"
+              "desc": "<p>Changes the ownership of a file.</p>"
             },
             {
-              "textRaw": "`fsPromises.copyFile(src, dest[, flags])`",
+              "textRaw": "`fsPromises.copyFile(src, dest[, mode])`",
               "type": "method",
               "name": "copyFile",
               "meta": {
@@ -888,9 +996,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -906,16 +1015,33 @@
                       "desc": "destination filename of the copy operation"
                     },
                     {
-                      "textRaw": "`flags` {number} modifiers for copy operation. **Default:** `0`.",
-                      "name": "flags",
-                      "type": "number",
+                      "textRaw": "`mode` {integer} Optional modifiers that specify the behavior of the copy operation. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g. `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`) **Default:** `0`.",
+                      "name": "mode",
+                      "type": "integer",
                       "default": "`0`",
-                      "desc": "modifiers for copy operation."
+                      "desc": "Optional modifiers that specify the behavior of the copy operation. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g. `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`)",
+                      "options": [
+                        {
+                          "textRaw": "`fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already exists.",
+                          "name": "fs.constants.COPYFILE_EXCL",
+                          "desc": "The copy operation will fail if `dest` already exists."
+                        },
+                        {
+                          "textRaw": "`fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a copy-on-write reflink. If the platform does not support copy-on-write, then a fallback copy mechanism is used.",
+                          "name": "fs.constants.COPYFILE_FICLONE",
+                          "desc": "The copy operation will attempt to create a copy-on-write reflink. If the platform does not support copy-on-write, then a fallback copy mechanism is used."
+                        },
+                        {
+                          "textRaw": "`fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to create a copy-on-write reflink. If the platform does not support copy-on-write, then the operation will fail.",
+                          "name": "fs.constants.COPYFILE_FICLONE_FORCE",
+                          "desc": "The copy operation will attempt to create a copy-on-write reflink. If the platform does not support copy-on-write, then the operation will fail."
+                        }
+                      ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. The <code>Promise</code> will be resolved with no arguments upon success.</p>\n<p>Node.js makes no guarantees about the atomicity of the copy operation. If an\nerror occurs after the destination file has been opened for writing, Node.js\nwill attempt to remove the destination.</p>\n<p><code>flags</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support copy-on-write,\nthen the operation will fail.</li>\n</ul>\n<pre><code class=\"language-js\">const fsPromises = require('fs').promises;\n\n// destination.txt will be created or overwritten by default.\nfsPromises.copyFile('source.txt', 'destination.txt')\n  .then(() => console.log('source.txt was copied to destination.txt'))\n  .catch(() => console.log('The file could not be copied'));\n</code></pre>\n<p>If the third argument is a number, then it specifies <code>flags</code>:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst fsPromises = fs.promises;\nconst { COPYFILE_EXCL } = fs.constants;\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\nfsPromises.copyFile('source.txt', 'destination.txt', COPYFILE_EXCL)\n  .then(() => console.log('source.txt was copied to destination.txt'))\n  .catch(() => console.log('The file could not be copied'));\n</code></pre>"
+              "desc": "<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists.</p>\n<p>No guarantees are made about the atomicity of the copy operation. If an\nerror occurs after the destination file has been opened for writing, an attempt\nwill be made to remove the destination.</p>\n<pre><code class=\"language-mjs\">import { constants } from 'fs';\nimport { copyFile } from 'fs/promises';\n\ntry {\n  await copyFile('source.txt', 'destination.txt');\n  console.log('source.txt was copied to destination.txt');\n} catch {\n  console.log('The file could not be copied');\n}\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\ntry {\n  await copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL);\n  console.log('source.txt was copied to destination.txt');\n} catch {\n  console.log('The file could not be copied');\n}\n</code></pre>"
             },
             {
               "textRaw": "`fsPromises.lchmod(path, mode)`",
@@ -930,9 +1056,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -948,7 +1075,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the permissions on a symbolic link then resolves the <code>Promise</code> with\nno arguments upon success. This method is only implemented on macOS.</p>"
+              "desc": "<p>Changes the permissions on a symbolic link.</p>\n<p>This method is only implemented on macOS.</p>"
             },
             {
               "textRaw": "`fsPromises.lchown(path, uid, gid)`",
@@ -969,9 +1096,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -992,7 +1120,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the ownership on a symbolic link then resolves the <code>Promise</code> with\nno arguments upon success.</p>"
+              "desc": "<p>Changes the ownership on a symbolic link.</p>"
             },
             {
               "textRaw": "`fsPromises.lutimes(path, atime, mtime)`",
@@ -1000,6 +1128,7 @@
               "name": "lutimes",
               "meta": {
                 "added": [
+                  "v14.5.0",
                   "v12.19.0"
                 ],
                 "changes": []
@@ -1007,9 +1136,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1030,7 +1160,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Changes the access and modification times of a file in the same way as\n<a href=\"#fs_fspromises_utimes_path_atime_mtime\"><code>fsPromises.utimes()</code></a>, with the difference that if the path refers to a\nsymbolic link, then the link is not dereferenced: instead, the timestamps of\nthe symbolic link itself are changed.</p>\n<p>Upon success, the <code>Promise</code> is resolved without arguments.</p>"
+              "desc": "<p>Changes the access and modification times of a file in the same way as\n<a href=\"#fs_fspromises_utimes_path_atime_mtime\"><code>fsPromises.utimes()</code></a>, with the difference that if the path refers to a\nsymbolic link, then the link is not dereferenced: instead, the timestamps of\nthe symbolic link itself are changed.</p>"
             },
             {
               "textRaw": "`fsPromises.link(existingPath, newPath)`",
@@ -1045,9 +1175,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1063,7 +1194,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon success.</p>"
+              "desc": "<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a> documentation for more detail.</p>"
             },
             {
               "textRaw": "`fsPromises.lstat(path[, options])`",
@@ -1084,9 +1215,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the {fs.Stats} object for the given symbolic link `path`.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the {fs.Stats} object for the given symbolic link `path`."
                   },
                   "params": [
                     {
@@ -1100,18 +1232,18 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
                           "name": "bigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a>. The <code>Promise</code> is resolved with the <a href=\"#fs_class_fs_stats\"><code>fs.Stats</code></a> object\nfor the given symbolic link <code>path</code>.</p>"
+              "desc": "<p>Equivalent to <a href=\"#fs_fspromises_stat_path_options\"><code>fsPromises.stat()</code></a> unless <code>path</code> refers to a symbolic link,\nin which case the link itself is stat-ed, not the file that it refers to.\nRefer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a> document for more detail.</p>"
             },
             {
               "textRaw": "`fsPromises.mkdir(path[, options])`",
@@ -1126,9 +1258,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Upon success, fulfills with `undefined` if `recursive` is `false`, or the first directory path created if `recursive` is `true`.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Upon success, fulfills with `undefined` if `recursive` is `false`, or the first directory path created if `recursive` is `true`."
                   },
                   "params": [
                     {
@@ -1159,7 +1292,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously creates a directory then resolves the <code>Promise</code> with either no\narguments, or the first directory path created if <code>recursive</code> is <code>true</code>.</p>\n<p>The optional <code>options</code> argument can be an integer specifying mode (permission\nand sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>\nproperty indicating whether parent directories should be created. Calling\n<code>fsPromises.mkdir()</code> when <code>path</code> is a directory that exists results in a\nrejection only when <code>recursive</code> is false.</p>"
+              "desc": "<p>Asynchronously creates a directory.</p>\n<p>The optional <code>options</code> argument can be an integer specifying <code>mode</code> (permission\nand sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>\nproperty indicating whether parent directories should be created. Calling\n<code>fsPromises.mkdir()</code> when <code>path</code> is a directory that exists results in a\nrejection only when <code>recursive</code> is false.</p>"
             },
             {
               "textRaw": "`fsPromises.mkdtemp(prefix[, options])`",
@@ -1169,14 +1302,21 @@
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/39028",
+                    "description": "The `prefix` parameter now accepts an empty string."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with a string containing the filesystem path of the newly created temporary directory.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with a string containing the filesystem path of the newly created temporary directory."
                   },
                   "params": [
                     {
@@ -1200,7 +1340,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Creates a unique temporary directory and resolves the <code>Promise</code> with the created\ndirectory path. A unique directory name is generated by appending six random\ncharacters to the end of the provided <code>prefix</code>. Due to platform\ninconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,\nnotably the BSDs, can return more than six random characters, and replace\ntrailing <code>X</code> characters in <code>prefix</code> with random characters.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>\n<pre><code class=\"language-js\">fsPromises.mkdtemp(path.join(os.tmpdir(), 'foo-'))\n  .catch(console.error);\n</code></pre>\n<p>The <code>fsPromises.mkdtemp()</code> method will append the six randomly selected\ncharacters directly to the <code>prefix</code> string. For instance, given a directory\n<code>/tmp</code>, if the intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the\n<code>prefix</code> must end with a trailing platform-specific path separator\n(<code>require('path').sep</code>).</p>"
+              "desc": "<p>Creates a unique temporary directory. A unique directory name is generated by\nappending six random characters to the end of the provided <code>prefix</code>. Due to\nplatform inconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some\nplatforms, notably the BSDs, can return more than six random characters, and\nreplace trailing <code>X</code> characters in <code>prefix</code> with random characters.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>\n<pre><code class=\"language-mjs\">import { mkdtemp } from 'fs/promises';\n\ntry {\n  await mkdtemp(path.join(os.tmpdir(), 'foo-'));\n} catch (err) {\n  console.error(err);\n}\n</code></pre>\n<p>The <code>fsPromises.mkdtemp()</code> method will append the six randomly selected\ncharacters directly to the <code>prefix</code> string. For instance, given a directory\n<code>/tmp</code>, if the intention is to create a temporary directory <em>within</em> <code>/tmp</code>, the\n<code>prefix</code> must end with a trailing platform-specific path separator\n(<code>require('path').sep</code>).</p>"
             },
             {
               "textRaw": "`fsPromises.open(path, flags[, mode])`",
@@ -1221,9 +1361,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with a {FileHandle} object.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with a {FileHandle} object."
                   },
                   "params": [
                     {
@@ -1239,15 +1380,16 @@
                       "desc": "See [support of file system `flags`][]."
                     },
                     {
-                      "textRaw": "`mode` {string|integer} **Default:** `0o666` (readable and writable)",
+                      "textRaw": "`mode` {string|integer} Sets the file mode (permission and sticky bits) if the file is created. **Default:** `0o666` (readable and writable)",
                       "name": "mode",
                       "type": "string|integer",
-                      "default": "`0o666` (readable and writable)"
+                      "default": "`0o666` (readable and writable)",
+                      "desc": "Sets the file mode (permission and sticky bits) if the file is created."
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous file open that returns a <code>Promise</code> that, when resolved, yields a\n<code>FileHandle</code> object. See <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was\ncreated.</p>\n<p>Some characters (<code>&#x3C; > : \" / \\ | ? *</code>) are reserved under Windows as documented\nby <a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file\">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains\na colon, Node.js will open a file system stream, as described by\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams\">this MSDN page</a>.</p>"
+              "desc": "<p>Opens a <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a>.</p>\n<p>Refer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a> documentation for more detail.</p>\n<p>Some characters (<code>&#x3C; > : \" / \\ | ? *</code>) are reserved under Windows as documented\nby <a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file\">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains\na colon, Node.js will open a file system stream, as described by\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams\">this MSDN page</a>.</p>"
             },
             {
               "textRaw": "`fsPromises.opendir(path[, options])`",
@@ -1259,7 +1401,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.1.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30114",
                     "description": "The `bufferSize` option was introduced."
                   }
@@ -1268,10 +1413,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise} containing {fs.Dir}",
+                    "textRaw": "Returns: {Promise} Fulfills with an {fs.Dir}.",
                     "name": "return",
                     "type": "Promise",
-                    "desc": "containing {fs.Dir}"
+                    "desc": "Fulfills with an {fs.Dir}."
                   },
                   "params": [
                     {
@@ -1302,7 +1447,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously open a directory. See <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a>.</p>\n<p>Creates an <a href=\"#fs_class_fs_dir\"><code>fs.Dir</code></a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>\n<p>Example using async iteration:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nasync function print(path) {\n  const dir = await fs.promises.opendir(path);\n  for await (const dirent of dir) {\n    console.log(dirent.name);\n  }\n}\nprint('./').catch(console.error);\n</code></pre>"
+              "desc": "<p>Asynchronously open a directory for iterative scanning. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a> documentation for more detail.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>\n<p>Example using async iteration:</p>\n<pre><code class=\"language-mjs\">import { opendir } from 'fs/promises';\n\ntry {\n  const dir = await opendir('./');\n  for await (const dirent of dir)\n    console.log(dirent.name);\n} catch (err) {\n  console.error(err);\n}\n</code></pre>\n<p>When using the async iterator, the <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a> object will be automatically\nclosed after the iterator exits.</p>"
             },
             {
               "textRaw": "`fsPromises.readdir(path[, options])`",
@@ -1323,9 +1468,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with an array of the names of the files in the directory excluding `'.'` and `'..'`.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with an array of the names of the files in the directory excluding `'.'` and `'..'`."
                   },
                   "params": [
                     {
@@ -1355,7 +1501,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Reads the contents of a directory then resolves the <code>Promise</code> with an array\nof the names of the files in the directory excluding <code>'.'</code> and <code>'..'</code>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames. If the <code>encoding</code> is set to <code>'buffer'</code>, the filenames returned\nwill be passed as <code>Buffer</code> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the resolved array will contain\n<a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a> objects.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nasync function print(path) {\n  const files = await fs.promises.readdir(path);\n  for (const file of files) {\n    console.log(file);\n  }\n}\nprint('./').catch(console.error);\n</code></pre>"
+              "desc": "<p>Reads the contents of a directory.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames. If the <code>encoding</code> is set to <code>'buffer'</code>, the filenames returned\nwill be passed as <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the resolved array will contain\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> objects.</p>\n<pre><code class=\"language-mjs\">import { readdir } from 'fs/promises';\n\ntry {\n  const files = await readdir(path);\n  for (const file of files)\n    console.log(file);\n} catch (err) {\n  console.error(err);\n}\n</code></pre>"
             },
             {
               "textRaw": "`fsPromises.readFile(path[, options])`",
@@ -1365,14 +1511,21 @@
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35911",
+                    "description": "The options argument may include an AbortSignal to abort an ongoing readFile request."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the contents of the file.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the contents of the file."
                   },
                   "params": [
                     {
@@ -1398,13 +1551,19 @@
                           "type": "string",
                           "default": "`'r'`",
                           "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting an in-progress readFile",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting an in-progress readFile"
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<p>The <code>Promise</code> is resolved with the contents of the file. If no encoding is\nspecified (using <code>options.encoding</code>), the data is returned as a <code>Buffer</code>\nobject. Otherwise, the data will be a string.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>When the <code>path</code> is a directory, the behavior of <code>fsPromises.readFile()</code> is\nplatform-specific. On macOS, Linux, and Windows, the promise will be rejected\nwith an error. On FreeBSD, a representation of the directory's contents will be\nreturned.</p>\n<p>Any specified <code>FileHandle</code> has to support reading.</p>"
+              "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<p>If no encoding is specified (using <code>options.encoding</code>), the data is returned\nas a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object. Otherwise, the data will be a string.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>When the <code>path</code> is a directory, the behavior of <code>fsPromises.readFile()</code> is\nplatform-specific. On macOS, Linux, and Windows, the promise will be rejected\nwith an error. On FreeBSD, a representation of the directory's contents will be\nreturned.</p>\n<p>It is possible to abort an ongoing <code>readFile</code> using an <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a>. If a\nrequest is aborted the promise returned is rejected with an <code>AbortError</code>:</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs/promises';\n\ntry {\n  const controller = new AbortController();\n  const { signal } = controller;\n  const promise = readFile(fileName, { signal });\n\n  // Abort the request before the promise settles.\n  controller.abort();\n\n  await promise;\n} catch (err) {\n  // When a request is aborted - err is an AbortError\n  console.error(err);\n}\n</code></pre>\n<p>Aborting an ongoing request does not abort individual operating\nsystem requests but rather the internal buffering <code>fs.readFile</code> performs.</p>\n<p>Any specified <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> has to support reading.</p>"
             },
             {
               "textRaw": "`fsPromises.readlink(path[, options])`",
@@ -1419,9 +1578,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the `linkString` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the `linkString` upon success."
                   },
                   "params": [
                     {
@@ -1445,7 +1605,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a>. The <code>Promise</code> is resolved with the <code>linkString</code> upon\nsuccess.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>, the link path\nreturned will be passed as a <code>Buffer</code> object.</p>"
+              "desc": "<p>Reads the contents of the symbolic link referred to by <code>path</code>. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a> documentation for more detail. The promise is resolved with the\n<code>linkString</code> upon success.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>, the link path\nreturned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>"
             },
             {
               "textRaw": "`fsPromises.realpath(path[, options])`",
@@ -1460,9 +1620,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the resolved path upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the resolved path upon success."
                   },
                   "params": [
                     {
@@ -1486,7 +1647,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Determines the actual location of <code>path</code> using the same semantics as the\n<code>fs.realpath.native()</code> function then resolves the <code>Promise</code> with the resolved\npath.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path. If the <code>encoding</code> is set to <code>'buffer'</code>, the path returned will be\npassed as a <code>Buffer</code> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
+              "desc": "<p>Determines the actual location of <code>path</code> using the same semantics as the\n<code>fs.realpath.native()</code> function.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path. If the <code>encoding</code> is set to <code>'buffer'</code>, the path returned will be\npassed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
             },
             {
               "textRaw": "`fsPromises.rename(oldPath, newPath)`",
@@ -1501,9 +1662,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1519,7 +1681,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Renames <code>oldPath</code> to <code>newPath</code> and resolves the <code>Promise</code> with no arguments\nupon success.</p>"
+              "desc": "<p>Renames <code>oldPath</code> to <code>newPath</code>.</p>"
             },
             {
               "textRaw": "`fsPromises.rmdir(path[, options])`",
@@ -1531,7 +1693,15 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.0",
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35579",
+                    "description": "The `recursive` option is deprecated, use `fsPromises.rm` instead."
+                  },
+                  {
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30644",
                     "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
                   },
@@ -1542,14 +1712,13 @@
                   }
                 ]
               },
-              "stability": 1,
-              "stabilityText": "Recursive removal is experimental.",
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1563,11 +1732,11 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
                           "name": "maxRetries",
                           "type": "integer",
                           "default": "`0`",
-                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
                         },
                         {
                           "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
@@ -1588,7 +1757,71 @@
                   ]
                 }
               ],
-              "desc": "<p>Removes the directory identified by <code>path</code> then resolves the <code>Promise</code> with\nno arguments upon success.</p>\n<p>Using <code>fsPromises.rmdir()</code> on a file (not a directory) results in the\n<code>Promise</code> being rejected with an <code>ENOENT</code> error on Windows and an <code>ENOTDIR</code>\nerror on POSIX.</p>"
+              "desc": "<p>Removes the directory identified by <code>path</code>.</p>\n<p>Using <code>fsPromises.rmdir()</code> on a file (not a directory) results in the\npromise being rejected with an <code>ENOENT</code> error on Windows and an <code>ENOTDIR</code>\nerror on POSIX.</p>\n<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command\n<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths\nthat represent files will be deleted. The permissive behavior of the\n<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in\nthe future.</p>"
+            },
+            {
+              "textRaw": "`fsPromises.rm(path[, options])`",
+              "type": "method",
+              "name": "rm",
+              "meta": {
+                "added": [
+                  "v14.14.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
+                    "name": "return",
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`force` {boolean} When `true`, exceptions will be ignored if `path` does not exist. **Default:** `false`.",
+                          "name": "force",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "When `true`, exceptions will be ignored if `path` does not exist."
+                        },
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive directory removal. In recursive mode operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Removes files and directories (modeled on the standard POSIX <code>rm</code> utility).</p>"
             },
             {
               "textRaw": "`fsPromises.stat(path[, options])`",
@@ -1609,9 +1842,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with the {fs.Stats} object for the given `path`.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with the {fs.Stats} object for the given `path`."
                   },
                   "params": [
                     {
@@ -1625,18 +1859,17 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
                           "name": "bigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
                         }
                       ]
                     }
                   ]
                 }
-              ],
-              "desc": "<p>The <code>Promise</code> is resolved with the <a href=\"#fs_class_fs_stats\"><code>fs.Stats</code></a> object for the given <code>path</code>.</p>"
+              ]
             },
             {
               "textRaw": "`fsPromises.symlink(target, path[, type])`",
@@ -1651,9 +1884,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1675,7 +1909,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Creates a symbolic link then resolves the <code>Promise</code> with no arguments upon\nsuccess.</p>\n<p>The <code>type</code> argument is only used on Windows platforms and can be one of <code>'dir'</code>,\n<code>'file'</code>, or <code>'junction'</code>. Windows junction points require the destination path\nto be absolute. When using <code>'junction'</code>, the <code>target</code> argument will\nautomatically be normalized to absolute path.</p>"
+              "desc": "<p>Creates a symbolic link.</p>\n<p>The <code>type</code> argument is only used on Windows platforms and can be one of <code>'dir'</code>,\n<code>'file'</code>, or <code>'junction'</code>. Windows junction points require the destination path\nto be absolute. When using <code>'junction'</code>, the <code>target</code> argument will\nautomatically be normalized to absolute path.</p>"
             },
             {
               "textRaw": "`fsPromises.truncate(path[, len])`",
@@ -1690,9 +1924,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1709,7 +1944,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Truncates the <code>path</code> then resolves the <code>Promise</code> with no arguments upon\nsuccess. The <code>path</code> <em>must</em> be a string or <code>Buffer</code>.</p>"
+              "desc": "<p>Truncates (shortens or extends the length) of the content at <code>path</code> to <code>len</code>\nbytes.</p>"
             },
             {
               "textRaw": "`fsPromises.unlink(path)`",
@@ -1724,9 +1959,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1737,7 +1973,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>. The <code>Promise</code> is resolved with no arguments upon\nsuccess.</p>"
+              "desc": "<p>If <code>path</code> refers to a symbolic link, then the link is removed without affecting\nthe file or directory to which that link refers. If the <code>path</code> refers to a file\npath that is not a symbolic link, the file is deleted. See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>\ndocumentation for more detail.</p>"
             },
             {
               "textRaw": "`fsPromises.utimes(path, atime, mtime)`",
@@ -1752,9 +1988,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1775,24 +2012,123 @@
                   ]
                 }
               ],
-              "desc": "<p>Change the file system timestamps of the object referenced by <code>path</code> then\nresolves the <code>Promise</code> with no arguments upon success.</p>\n<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>\n<ul>\n<li>Values can be either numbers representing Unix epoch time, <code>Date</code>s, or a\nnumeric string like <code>'123456789.0'</code>.</li>\n<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or\n<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>\n</ul>"
+              "desc": "<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>\n<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>\n<ul>\n<li>Values can be either numbers representing Unix epoch time, <code>Date</code>s, or a\nnumeric string like <code>'123456789.0'</code>.</li>\n<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or\n<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>\n</ul>"
             },
             {
-              "textRaw": "`fsPromises.writeFile(file, data[, options])`",
+              "textRaw": "`fsPromises.watch(filename[, options])`",
               "type": "method",
-              "name": "writeFile",
+              "name": "watch",
               "meta": {
                 "added": [
-                  "v10.0.0"
+                  "v14.18.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {AsyncIterator} of objects with the properties:",
+                    "name": "return",
+                    "type": "AsyncIterator",
+                    "desc": "of objects with the properties:",
+                    "options": [
+                      {
+                        "textRaw": "`eventType` {string} The type of change",
+                        "name": "eventType",
+                        "type": "string",
+                        "desc": "The type of change"
+                      },
+                      {
+                        "textRaw": "`filename` {string|Buffer} The name of the file changed.",
+                        "name": "filename",
+                        "type": "string|Buffer",
+                        "desc": "The name of the file changed."
+                      }
+                    ]
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`filename` {string|Buffer|URL}",
+                      "name": "filename",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`persistent` {boolean} Indicates whether the process should continue to run as long as files are being watched. **Default:** `true`.",
+                          "name": "persistent",
+                          "type": "boolean",
+                          "default": "`true`",
+                          "desc": "Indicates whether the process should continue to run as long as files are being watched."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [caveats][]). **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [caveats][])."
+                        },
+                        {
+                          "textRaw": "`encoding` {string} Specifies the character encoding to be used for the filename passed to the listener. **Default:** `'utf8'`.",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`",
+                          "desc": "Specifies the character encoding to be used for the filename passed to the listener."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} An {AbortSignal} used to signal when the watcher should stop.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "An {AbortSignal} used to signal when the watcher should stop."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns an async iterator that watches for changes on <code>filename</code>, where <code>filename</code>\nis either a file or a directory.</p>\n<pre><code class=\"language-js\">const { watch } = require('fs/promises');\n\nconst ac = new AbortController();\nconst { signal } = ac;\nsetTimeout(() => ac.abort(), 10000);\n\n(async () => {\n  try {\n    const watcher = watch(__filename, { signal });\n    for await (const event of watcher)\n      console.log(event);\n  } catch (err) {\n    if (err.name === 'AbortError')\n      return;\n    throw err;\n  }\n})();\n</code></pre>\n<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or\ndisappears in the directory.</p>\n<p>All the <a href=\"#fs_caveats\">caveats</a> for <code>fs.watch()</code> also apply to <code>fsPromises.watch()</code>.</p>"
+            },
+            {
+              "textRaw": "`fsPromises.writeFile(file, data[, options])`",
+              "type": "method",
+              "name": "writeFile",
+              "meta": {
+                "added": [
+                  "v10.0.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37490",
+                    "description": "The `data` argument supports `AsyncIterable`, `Iterable` and `Stream`."
+                  },
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35993",
+                    "description": "The options argument may include an AbortSignal to abort an ongoing writeFile request."
+                  },
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `data` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `data` parameter won't coerce unsupported input to strings anymore."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -1802,9 +2138,9 @@
                       "desc": "filename or `FileHandle`"
                     },
                     {
-                      "textRaw": "`data` {string|Buffer|Uint8Array}",
+                      "textRaw": "`data` {string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable |Stream}",
                       "name": "data",
-                      "type": "string|Buffer|Uint8Array"
+                      "type": "string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable |Stream"
                     },
                     {
                       "textRaw": "`options` {Object|string}",
@@ -1829,118 +2165,64 @@
                           "type": "string",
                           "default": "`'w'`",
                           "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting an in-progress writeFile",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting an in-progress writeFile"
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously writes data to a file, replacing the file if it already exists.\n<code>data</code> can be a string or a buffer. The <code>Promise</code> will be resolved with no\narguments upon success.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>Any specified <code>FileHandle</code> has to support writing.</p>\n<p>It is unsafe to use <code>fsPromises.writeFile()</code> multiple times on the same file\nwithout waiting for the <code>Promise</code> to be resolved (or rejected).</p>"
-            }
-          ],
-          "type": "module",
-          "displayName": "`fs` Promises API"
-        },
-        {
-          "textRaw": "FS constants",
-          "name": "fs_constants",
-          "desc": "<p>The following constants are exported by <code>fs.constants</code>.</p>\n<p>Not every constant will be available on every operating system.</p>\n<p>To use more than one constant, use the bitwise OR <code>|</code> operator.</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nconst {\n  O_RDWR,\n  O_CREAT,\n  O_EXCL\n} = fs.constants;\n\nfs.open('/path/to/my/file', O_RDWR | O_CREAT | O_EXCL, (err, fd) => {\n  // ...\n});\n</code></pre>",
-          "modules": [
-            {
-              "textRaw": "File access constants",
-              "name": "file_access_constants",
-              "desc": "<p>The following constants are meant for use with <a href=\"#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>F_OK</code></td>\n    <td>Flag indicating that the file is visible to the calling process.\n     This is useful for determining if a file exists, but says nothing\n     about <code>rwx</code> permissions. Default if no mode is specified.</td>\n  </tr>\n  <tr>\n    <td><code>R_OK</code></td>\n    <td>Flag indicating that the file can be read by the calling process.</td>\n  </tr>\n  <tr>\n    <td><code>W_OK</code></td>\n    <td>Flag indicating that the file can be written by the calling\n    process.</td>\n  </tr>\n  <tr>\n    <td><code>X_OK</code></td>\n    <td>Flag indicating that the file can be executed by the calling\n    process. This has no effect on Windows\n    (will behave like <code>fs.constants.F_OK</code>).</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File access constants"
-            },
-            {
-              "textRaw": "File copy constants",
-              "name": "file_copy_constants",
-              "desc": "<p>The following constants are meant for use with <a href=\"#fs_fs_copyfile_src_dest_flags_callback\"><code>fs.copyFile()</code></a>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_EXCL</code></td>\n    <td>If present, the copy operation will fail with an error if the\n    destination path already exists.</td>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_FICLONE</code></td>\n    <td>If present, the copy operation will attempt to create a\n    copy-on-write reflink. If the underlying platform does not support\n    copy-on-write, then a fallback copy mechanism is used.</td>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_FICLONE_FORCE</code></td>\n    <td>If present, the copy operation will attempt to create a\n    copy-on-write reflink. If the underlying platform does not support\n    copy-on-write, then the operation will fail with an error.</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File copy constants"
-            },
-            {
-              "textRaw": "File open constants",
-              "name": "file_open_constants",
-              "desc": "<p>The following constants are meant for use with <code>fs.open()</code>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>O_RDONLY</code></td>\n    <td>Flag indicating to open a file for read-only access.</td>\n  </tr>\n  <tr>\n    <td><code>O_WRONLY</code></td>\n    <td>Flag indicating to open a file for write-only access.</td>\n  </tr>\n  <tr>\n    <td><code>O_RDWR</code></td>\n    <td>Flag indicating to open a file for read-write access.</td>\n  </tr>\n  <tr>\n    <td><code>O_CREAT</code></td>\n    <td>Flag indicating to create the file if it does not already exist.</td>\n  </tr>\n  <tr>\n    <td><code>O_EXCL</code></td>\n    <td>Flag indicating that opening a file should fail if the\n    <code>O_CREAT</code> flag is set and the file already exists.</td>\n  </tr>\n  <tr>\n    <td><code>O_NOCTTY</code></td>\n    <td>Flag indicating that if path identifies a terminal device, opening the\n    path shall not cause that terminal to become the controlling terminal for\n    the process (if the process does not already have one).</td>\n  </tr>\n  <tr>\n    <td><code>O_TRUNC</code></td>\n    <td>Flag indicating that if the file exists and is a regular file, and the\n    file is opened successfully for write access, its length shall be truncated\n    to zero.</td>\n  </tr>\n  <tr>\n    <td><code>O_APPEND</code></td>\n    <td>Flag indicating that data will be appended to the end of the file.</td>\n  </tr>\n  <tr>\n    <td><code>O_DIRECTORY</code></td>\n    <td>Flag indicating that the open should fail if the path is not a\n    directory.</td>\n  </tr>\n  <tr>\n  <td><code>O_NOATIME</code></td>\n    <td>Flag indicating reading accesses to the file system will no longer\n    result in an update to the <code>atime</code> information associated with\n    the file. This flag is available on Linux operating systems only.</td>\n  </tr>\n  <tr>\n    <td><code>O_NOFOLLOW</code></td>\n    <td>Flag indicating that the open should fail if the path is a symbolic\n    link.</td>\n  </tr>\n  <tr>\n    <td><code>O_SYNC</code></td>\n    <td>Flag indicating that the file is opened for synchronized I/O with write\n    operations waiting for file integrity.</td>\n  </tr>\n  <tr>\n    <td><code>O_DSYNC</code></td>\n    <td>Flag indicating that the file is opened for synchronized I/O with write\n    operations waiting for data integrity.</td>\n  </tr>\n  <tr>\n    <td><code>O_SYMLINK</code></td>\n    <td>Flag indicating to open the symbolic link itself rather than the\n    resource it is pointing to.</td>\n  </tr>\n  <tr>\n    <td><code>O_DIRECT</code></td>\n    <td>When set, an attempt will be made to minimize caching effects of file\n    I/O.</td>\n  </tr>\n  <tr>\n    <td><code>O_NONBLOCK</code></td>\n    <td>Flag indicating to open the file in nonblocking mode when possible.</td>\n  </tr>\n  <tr>\n    <td><code>UV_FS_O_FILEMAP</code></td>\n    <td>When set, a memory file mapping is used to access the file. This flag\n    is available on Windows operating systems only. On other operating systems,\n    this flag is ignored.</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File open constants"
-            },
-            {
-              "textRaw": "File type constants",
-              "name": "file_type_constants",
-              "desc": "<p>The following constants are meant for use with the <a href=\"#fs_class_fs_stats\"><code>fs.Stats</code></a> object's\n<code>mode</code> property for determining a file's type.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>S_IFMT</code></td>\n    <td>Bit mask used to extract the file type code.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFREG</code></td>\n    <td>File type constant for a regular file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFDIR</code></td>\n    <td>File type constant for a directory.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFCHR</code></td>\n    <td>File type constant for a character-oriented device file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFBLK</code></td>\n    <td>File type constant for a block-oriented device file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFIFO</code></td>\n    <td>File type constant for a FIFO/pipe.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFLNK</code></td>\n    <td>File type constant for a symbolic link.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFSOCK</code></td>\n    <td>File type constant for a socket.</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File type constants"
-            },
-            {
-              "textRaw": "File mode constants",
-              "name": "file_mode_constants",
-              "desc": "<p>The following constants are meant for use with the <a href=\"#fs_class_fs_stats\"><code>fs.Stats</code></a> object's\n<code>mode</code> property for determining the access permissions for a file.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>S_IRWXU</code></td>\n    <td>File mode indicating readable, writable, and executable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRUSR</code></td>\n    <td>File mode indicating readable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWUSR</code></td>\n    <td>File mode indicating writable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXUSR</code></td>\n    <td>File mode indicating executable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRWXG</code></td>\n    <td>File mode indicating readable, writable, and executable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRGRP</code></td>\n    <td>File mode indicating readable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWGRP</code></td>\n    <td>File mode indicating writable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXGRP</code></td>\n    <td>File mode indicating executable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRWXO</code></td>\n    <td>File mode indicating readable, writable, and executable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IROTH</code></td>\n    <td>File mode indicating readable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWOTH</code></td>\n    <td>File mode indicating writable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXOTH</code></td>\n    <td>File mode indicating executable by others.</td>\n  </tr>\n</table>",
-              "type": "module",
-              "displayName": "File mode constants"
+              "desc": "<p>Asynchronously writes data to a file, replacing the file if it already exists.\n<code>data</code> can be a string, a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>, or, an object with an own (not inherited)\n<code>toString</code> function property.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<p>Any specified <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> has to support writing.</p>\n<p>It is unsafe to use <code>fsPromises.writeFile()</code> multiple times on the same file\nwithout waiting for the promise to be settled.</p>\n<p>Similarly to <code>fsPromises.readFile</code> - <code>fsPromises.writeFile</code> is a convenience\nmethod that performs multiple <code>write</code> calls internally to write the buffer\npassed to it. For performance sensitive code consider using\n<a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>It is possible to use an <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> to cancel an <code>fsPromises.writeFile()</code>.\nCancelation is \"best effort\", and some amount of data is likely still\nto be written.</p>\n<pre><code class=\"language-mjs\">import { writeFile } from 'fs/promises';\n\ntry {\n  const controller = new AbortController();\n  const { signal } = controller;\n  const data = new Uint8Array(Buffer.from('Hello Node.js'));\n  const promise = writeFile('message.txt', data, { signal });\n\n  // Abort the request before the promise settles.\n  controller.abort();\n\n  await promise;\n} catch (err) {\n  // When a request is aborted - err is an AbortError\n  console.error(err);\n}\n</code></pre>\n<p>Aborting an ongoing request does not abort individual operating\nsystem requests but rather the internal buffering <code>fs.writeFile</code> performs.</p>"
             }
           ],
           "type": "module",
-          "displayName": "FS constants"
+          "displayName": "Promises API"
         },
         {
-          "textRaw": "File system flags",
-          "name": "file_system_flags",
-          "desc": "<p>The following flags are available wherever the <code>flag</code> option takes a\nstring.</p>\n<ul>\n<li>\n<p><code>'a'</code>: Open file for appending.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'ax'</code>: Like <code>'a'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'a+'</code>: Open file for reading and appending.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'ax+'</code>: Like <code>'a+'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'as'</code>: Open file for appending in synchronous mode.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'as+'</code>: Open file for reading and appending in synchronous mode.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'r'</code>: Open file for reading.\nAn exception occurs if the file does not exist.</p>\n</li>\n<li>\n<p><code>'r+'</code>: Open file for reading and writing.\nAn exception occurs if the file does not exist.</p>\n</li>\n<li>\n<p><code>'rs+'</code>: Open file for reading and writing in synchronous mode. Instructs\nthe operating system to bypass the local file system cache.</p>\n<p>This is primarily useful for opening files on NFS mounts as it allows\nskipping the potentially stale local cache. It has a very real impact on\nI/O performance so using this flag is not recommended unless it is needed.</p>\n<p>This doesn't turn <code>fs.open()</code> or <code>fsPromises.open()</code> into a synchronous\nblocking call. If synchronous operation is desired, something like\n<code>fs.openSync()</code> should be used.</p>\n</li>\n<li>\n<p><code>'w'</code>: Open file for writing.\nThe file is created (if it does not exist) or truncated (if it exists).</p>\n</li>\n<li>\n<p><code>'wx'</code>: Like <code>'w'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'w+'</code>: Open file for reading and writing.\nThe file is created (if it does not exist) or truncated (if it exists).</p>\n</li>\n<li>\n<p><code>'wx+'</code>: Like <code>'w+'</code> but fails if the path exists.</p>\n</li>\n</ul>\n<p><code>flag</code> can also be a number as documented by <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>; commonly used constants\nare available from <code>fs.constants</code>. On Windows, flags are translated to\ntheir equivalent ones where applicable, e.g. <code>O_WRONLY</code> to <code>FILE_GENERIC_WRITE</code>,\nor <code>O_EXCL|O_CREAT</code> to <code>CREATE_NEW</code>, as accepted by <code>CreateFileW</code>.</p>\n<p>The exclusive flag <code>'x'</code> (<code>O_EXCL</code> flag in <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>) causes the operation to\nreturn an error if the path already exists. On POSIX, if the path is a symbolic\nlink, using <code>O_EXCL</code> returns an error even if the link is to a path that does\nnot exist. The exclusive flag may or may not work with network file systems.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>\n<p>Modifying a file rather than replacing it may require a flags mode of <code>'r+'</code>\nrather than the default mode <code>'w'</code>.</p>\n<p>The behavior of some flags are platform-specific. As such, opening a directory\non macOS and Linux with the <code>'a+'</code> flag, as in the example below, will return an\nerror. In contrast, on Windows and FreeBSD, a file descriptor or a <code>FileHandle</code>\nwill be returned.</p>\n<pre><code class=\"language-js\">// macOS and Linux\nfs.open('&#x3C;directory>', 'a+', (err, fd) => {\n  // => [Error: EISDIR: illegal operation on a directory, open &#x3C;directory>]\n});\n\n// Windows and FreeBSD\nfs.open('&#x3C;directory>', 'a+', (err, fd) => {\n  // => null, &#x3C;fd>\n});\n</code></pre>\n<p>On Windows, opening an existing hidden file using the <code>'w'</code> flag (either\nthrough <code>fs.open()</code> or <code>fs.writeFile()</code> or <code>fsPromises.open()</code>) will fail with\n<code>EPERM</code>. Existing hidden files can be opened for writing with the <code>'r+'</code> flag.</p>\n<p>A call to <code>fs.ftruncate()</code> or <code>filehandle.truncate()</code> can be used to reset\nthe file contents.</p>",
-          "type": "module",
-          "displayName": "File system flags"
-        }
-      ],
-      "classes": [
-        {
-          "textRaw": "Class: `fs.Dir`",
-          "type": "class",
-          "name": "fs.Dir",
-          "meta": {
-            "added": [
-              "v12.12.0"
-            ],
-            "changes": []
-          },
-          "desc": "<p>A class representing a directory stream.</p>\n<p>Created by <a href=\"#fs_fs_opendir_path_options_callback\"><code>fs.opendir()</code></a>, <a href=\"#fs_fs_opendirsync_path_options\"><code>fs.opendirSync()</code></a>, or\n<a href=\"#fs_fspromises_opendir_path_options\"><code>fsPromises.opendir()</code></a>.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nasync function print(path) {\n  const dir = await fs.promises.opendir(path);\n  for await (const dirent of dir) {\n    console.log(dirent.name);\n  }\n}\nprint('./').catch(console.error);\n</code></pre>",
+          "textRaw": "Callback API",
+          "name": "callback_api",
+          "desc": "<p>The callback APIs perform all operations asynchronously, without blocking the\nevent loop, then invoke a callback function upon completion or error.</p>\n<p>The callback APIs use the underlying Node.js threadpool to perform file\nsystem operations off the event loop thread. These operations are not\nsynchronized or threadsafe. Care must be taken when performing multiple\nconcurrent modifications on the same file or data corruption may occur.</p>",
           "methods": [
             {
-              "textRaw": "`dir.close()`",
+              "textRaw": "`fs.access(path[, mode], callback)`",
               "type": "method",
-              "name": "close",
+              "name": "access",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.11.15"
                 ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {Promise}",
-                    "name": "return",
-                    "type": "Promise"
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
                   },
-                  "params": []
-                }
-              ],
-              "desc": "<p>Asynchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>\n<p>A <code>Promise</code> is returned that will be resolved after the resource has been\nclosed.</p>"
-            },
-            {
-              "textRaw": "`dir.close(callback)`",
-              "type": "method",
-              "name": "close",
-              "meta": {
-                "added": [
-                  "v12.12.0"
-                ],
-                "changes": []
+                  {
+                    "version": "v6.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/6534",
+                    "description": "The constants like `fs.R_OK`, etc which were present directly on `fs` were moved into `fs.constants` as a soft deprecation. Thus for Node.js `< v6.3.0` use `fs` to access those constants, or do something like `(fs.constants || fs).R_OK` to work with all versions."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {integer} **Default:** `fs.constants.F_OK`",
+                      "name": "mode",
+                      "type": "integer",
+                      "default": "`fs.constants.F_OK`"
+                    },
                     {
                       "textRaw": "`callback` {Function}",
                       "name": "callback",
@@ -1956,61 +2238,135 @@
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>\n<p>The <code>callback</code> will be called after the resource handle has been closed.</p>"
+              "desc": "<p>Tests a user's permissions for the file or directory specified by <code>path</code>.\nThe <code>mode</code> argument is an optional integer that specifies the accessibility\nchecks to be performed. Check <a href=\"#fs_file_access_constants\">File access constants</a> for possible values\nof <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of\ntwo or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>The final argument, <code>callback</code>, is a callback function that is invoked with\na possible error argument. If any of the accessibility checks fail, the error\nargument will be an <code>Error</code> object. The following examples check if\n<code>package.json</code> exists, and if it is readable or writable.</p>\n<pre><code class=\"language-mjs\">import { access, constants } from 'fs';\n\nconst file = 'package.json';\n\n// Check if the file exists in the current directory.\naccess(file, constants.F_OK, (err) => {\n  console.log(`${file} ${err ? 'does not exist' : 'exists'}`);\n});\n\n// Check if the file is readable.\naccess(file, constants.R_OK, (err) => {\n  console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);\n});\n\n// Check if the file is writable.\naccess(file, constants.W_OK, (err) => {\n  console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);\n});\n\n// Check if the file exists in the current directory, and if it is writable.\naccess(file, constants.F_OK | constants.W_OK, (err) => {\n  if (err) {\n    console.error(\n      `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`);\n  } else {\n    console.log(`${file} exists, and it is writable`);\n  }\n});\n</code></pre>\n<p>Do not use <code>fs.access()</code> to check for the accessibility of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code>. Doing\nso introduces a race condition, since other processes may change the file's\nstate between the two calls. Instead, user code should open/read/write the\nfile directly and handle the error raised if the file is not accessible.</p>\n<p><strong>write (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { access, open, close } from 'fs';\n\naccess('myfile', (err) => {\n  if (!err) {\n    console.error('myfile already exists');\n    return;\n  }\n\n  open('myfile', 'wx', (err, fd) => {\n    if (err) throw err;\n\n    try {\n      writeMyData(fd);\n    } finally {\n      close(fd, (err) => {\n        if (err) throw err;\n      });\n    }\n  });\n});\n</code></pre>\n<p><strong>write (RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close } from 'fs';\n\nopen('myfile', 'wx', (err, fd) => {\n  if (err) {\n    if (err.code === 'EEXIST') {\n      console.error('myfile already exists');\n      return;\n    }\n\n    throw err;\n  }\n\n  try {\n    writeMyData(fd);\n  } finally {\n    close(fd, (err) => {\n      if (err) throw err;\n    });\n  }\n});\n</code></pre>\n<p><strong>read (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { access, open, close } from 'fs';\naccess('myfile', (err) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  open('myfile', 'r', (err, fd) => {\n    if (err) throw err;\n\n    try {\n      readMyData(fd);\n    } finally {\n      close(fd, (err) => {\n        if (err) throw err;\n      });\n    }\n  });\n});\n</code></pre>\n<p><strong>read (RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close } from 'fs';\n\nopen('myfile', 'r', (err, fd) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  try {\n    readMyData(fd);\n  } finally {\n    close(fd, (err) => {\n      if (err) throw err;\n    });\n  }\n});\n</code></pre>\n<p>The \"not recommended\" examples above check for accessibility and then use the\nfile; the \"recommended\" examples are better because they use the file directly\nand handle the error, if any.</p>\n<p>In general, check for the accessibility of a file only if the file will not be\nused directly, for example when its accessibility is a signal from another\nprocess.</p>\n<p>On Windows, access-control policies (ACLs) on a directory may limit access to\na file or directory. The <code>fs.access()</code> function, however, does not check the\nACL and therefore may report that a path is accessible even if the ACL restricts\nthe user from reading or writing to it.</p>"
             },
             {
-              "textRaw": "`dir.closeSync()`",
+              "textRaw": "`fs.appendFile(path, data[, options], callback)`",
               "type": "method",
-              "name": "closeSync",
+              "name": "appendFile",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.6.7"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `file` parameter can be a file descriptor now."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL|number} filename or file descriptor",
+                      "name": "path",
+                      "type": "string|Buffer|URL|number",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`data` {string|Buffer}",
+                      "name": "data",
+                      "type": "string|Buffer"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'a'`",
+                          "desc": "See [support of file system `flags`][]."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Synchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>"
+              "desc": "<p>Asynchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<pre><code class=\"language-mjs\">import { appendFile } from 'fs';\n\nappendFile('message.txt', 'data to append', (err) => {\n  if (err) throw err;\n  console.log('The \"data to append\" was appended to file!');\n});\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-mjs\">import { appendFile } from 'fs';\n\nappendFile('message.txt', 'data to append', 'utf8', callback);\n</code></pre>\n<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened\nfor appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will\nnot be closed automatically.</p>\n<pre><code class=\"language-mjs\">import { open, close, appendFile } from 'fs';\n\nfunction closeFd(fd) {\n  close(fd, (err) => {\n    if (err) throw err;\n  });\n}\n\nopen('message.txt', 'a', (err, fd) => {\n  if (err) throw err;\n\n  try {\n    appendFile(fd, 'data to append', 'utf8', (err) => {\n      closeFd(fd);\n      if (err) throw err;\n    });\n  } catch (err) {\n    closeFd(fd);\n    throw err;\n  }\n});\n</code></pre>"
             },
             {
-              "textRaw": "`dir.read()`",
+              "textRaw": "`fs.chmod(path, mode, callback)`",
               "type": "method",
-              "name": "read",
+              "name": "chmod",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.1.30"
                 ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {Promise} containing {fs.Dirent|null}",
-                    "name": "return",
-                    "type": "Promise",
-                    "desc": "containing {fs.Dirent|null}"
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
                   },
-                  "params": []
-                }
-              ],
-              "desc": "<p>Asynchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a>.</p>\n<p>After the read is completed, a <code>Promise</code> is returned that will be resolved with\nan <a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a>, or <code>null</code> if there are no more directory entries to read.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory may or may not be\nincluded in the iteration results.</p>"
-            },
-            {
-              "textRaw": "`dir.read(callback)`",
-              "type": "method",
-              "name": "read",
-              "meta": {
-                "added": [
-                  "v12.12.0"
-                ],
-                "changes": []
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer}",
+                      "name": "mode",
+                      "type": "string|integer"
+                    },
                     {
                       "textRaw": "`callback` {Function}",
                       "name": "callback",
@@ -2020,6118 +2376,6579 @@
                           "textRaw": "`err` {Error}",
                           "name": "err",
                           "type": "Error"
-                        },
-                        {
-                          "textRaw": "`dirent` {fs.Dirent|null}",
-                          "name": "dirent",
-                          "type": "fs.Dirent|null"
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Asynchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a>.</p>\n<p>After the read is completed, the <code>callback</code> will be called with an\n<a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a>, or <code>null</code> if there are no more directory entries to read.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory may or may not be\nincluded in the iteration results.</p>"
+              "desc": "<p>Asynchronously changes the permissions of a file. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a> documentation for more detail.</p>\n<pre><code class=\"language-mjs\">import { chmod } from 'fs';\n\nchmod('my_file.txt', 0o775, (err) => {\n  if (err) throw err;\n  console.log('The permissions for file \"my_file.txt\" have been changed!');\n});\n</code></pre>",
+              "modules": [
+                {
+                  "textRaw": "File modes",
+                  "name": "file_modes",
+                  "desc": "<p>The <code>mode</code> argument used in both the <code>fs.chmod()</code> and <code>fs.chmodSync()</code>\nmethods is a numeric bitmask created using a logical OR of the following\nconstants:</p>\n<table>\n<thead>\n<tr>\n<th>Constant</th>\n<th>Octal</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>fs.constants.S_IRUSR</code></td>\n<td><code>0o400</code></td>\n<td>read by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWUSR</code></td>\n<td><code>0o200</code></td>\n<td>write by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXUSR</code></td>\n<td><code>0o100</code></td>\n<td>execute/search by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IRGRP</code></td>\n<td><code>0o40</code></td>\n<td>read by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWGRP</code></td>\n<td><code>0o20</code></td>\n<td>write by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXGRP</code></td>\n<td><code>0o10</code></td>\n<td>execute/search by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IROTH</code></td>\n<td><code>0o4</code></td>\n<td>read by others</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWOTH</code></td>\n<td><code>0o2</code></td>\n<td>write by others</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXOTH</code></td>\n<td><code>0o1</code></td>\n<td>execute/search by others</td>\n</tr>\n</tbody>\n</table>\n<p>An easier method of constructing the <code>mode</code> is to use a sequence of three\noctal digits (e.g. <code>765</code>). The left-most digit (<code>7</code> in the example), specifies\nthe permissions for the file owner. The middle digit (<code>6</code> in the example),\nspecifies permissions for the group. The right-most digit (<code>5</code> in the example),\nspecifies the permissions for others.</p>\n<table>\n<thead>\n<tr>\n<th>Number</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>7</code></td>\n<td>read, write, and execute</td>\n</tr>\n<tr>\n<td><code>6</code></td>\n<td>read and write</td>\n</tr>\n<tr>\n<td><code>5</code></td>\n<td>read and execute</td>\n</tr>\n<tr>\n<td><code>4</code></td>\n<td>read only</td>\n</tr>\n<tr>\n<td><code>3</code></td>\n<td>write and execute</td>\n</tr>\n<tr>\n<td><code>2</code></td>\n<td>write only</td>\n</tr>\n<tr>\n<td><code>1</code></td>\n<td>execute only</td>\n</tr>\n<tr>\n<td><code>0</code></td>\n<td>no permission</td>\n</tr>\n</tbody>\n</table>\n<p>For example, the octal value <code>0o765</code> means:</p>\n<ul>\n<li>The owner may read, write and execute the file.</li>\n<li>The group may read and write the file.</li>\n<li>Others may read and execute the file.</li>\n</ul>\n<p>When using raw numbers where file modes are expected, any value larger than\n<code>0o777</code> may result in platform-specific behaviors that are not supported to work\nconsistently. Therefore constants like <code>S_ISVTX</code>, <code>S_ISGID</code> or <code>S_ISUID</code> are not\nexposed in <code>fs.constants</code>.</p>\n<p>Caveats: on Windows only the write permission can be changed, and the\ndistinction among the permissions of group, owner or others is not\nimplemented.</p>",
+                  "type": "module",
+                  "displayName": "File modes"
+                }
+              ]
             },
             {
-              "textRaw": "`dir.readSync()`",
+              "textRaw": "`fs.chown(path, uid, gid, callback)`",
               "type": "method",
-              "name": "readSync",
+              "name": "chown",
               "meta": {
                 "added": [
-                  "v12.12.0"
+                  "v0.1.97"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {fs.Dirent|null}",
-                    "name": "return",
-                    "type": "fs.Dirent|null"
-                  },
-                  "params": []
-                }
-              ],
-              "desc": "<p>Synchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a>.</p>\n<p>If there are no more directory entries to read, <code>null</code> will be returned.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory may or may not be\nincluded in the iteration results.</p>"
-            },
-            {
-              "textRaw": "`dir[Symbol.asyncIterator]()`",
-              "type": "method",
-              "name": "[Symbol.asyncIterator]",
-              "meta": {
-                "added": [
-                  "v12.12.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {AsyncIterator} of {fs.Dirent}",
-                    "name": "return",
-                    "type": "AsyncIterator",
-                    "desc": "of {fs.Dirent}"
-                  },
-                  "params": []
-                }
-              ],
-              "desc": "<p>Asynchronously iterates over the directory via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> until all entries have\nbeen read.</p>\n<p>Entries returned by the async iterator are always an <a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a>.\nThe <code>null</code> case from <code>dir.read()</code> is handled internally.</p>\n<p>See <a href=\"#fs_class_fs_dir\"><code>fs.Dir</code></a> for an example.</p>\n<p>Directory entries returned by this iterator are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory may or may not be\nincluded in the iteration results.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`path` {string}",
-              "type": "string",
-              "name": "path",
-              "meta": {
-                "added": [
-                  "v12.12.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The read-only path of this directory as was provided to <a href=\"#fs_fs_opendir_path_options_callback\"><code>fs.opendir()</code></a>,\n<a href=\"#fs_fs_opendirsync_path_options\"><code>fs.opendirSync()</code></a>, or <a href=\"#fs_fspromises_opendir_path_options\"><code>fsPromises.opendir()</code></a>.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.Dirent`",
-          "type": "class",
-          "name": "fs.Dirent",
-          "meta": {
-            "added": [
-              "v10.10.0"
-            ],
-            "changes": []
-          },
-          "desc": "<p>A representation of a directory entry, which can be a file or a subdirectory\nwithin the directory, as returned by reading from an <a href=\"#fs_class_fs_dir\"><code>fs.Dir</code></a>. The\ndirectory entry is a combination of the file name and file type pairs.</p>\n<p>Additionally, when <a href=\"#fs_fs_readdir_path_options_callback\"><code>fs.readdir()</code></a> or <a href=\"#fs_fs_readdirsync_path_options\"><code>fs.readdirSync()</code></a> is called with\nthe <code>withFileTypes</code> option set to <code>true</code>, the resulting array is filled with\n<code>fs.Dirent</code> objects, rather than strings or <code>Buffers</code>.</p>",
-          "methods": [
-            {
-              "textRaw": "`dirent.isBlockDevice()`",
-              "type": "method",
-              "name": "isBlockDevice",
-              "meta": {
-                "added": [
-                  "v10.10.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`uid` {integer}",
+                      "name": "uid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`gid` {integer}",
+                      "name": "gid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a block device.</p>"
+              "desc": "<p>Asynchronously changes owner and group of a file. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`dirent.isCharacterDevice()`",
+              "textRaw": "`fs.close(fd[, callback])`",
               "type": "method",
-              "name": "isCharacterDevice",
+              "name": "close",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37174",
+                    "description": "A default callback is now used if one is not provided."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a character device.</p>"
+              "desc": "<p>Closes the file descriptor. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>Calling <code>fs.close()</code> on any file descriptor (<code>fd</code>) that is currently in use\nthrough any other <code>fs</code> operation may lead to undefined behavior.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/close.2.html\"><code>close(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`dirent.isDirectory()`",
+              "textRaw": "`fs.copyFile(src, dest[, mode], callback)`",
               "type": "method",
-              "name": "isDirectory",
+              "name": "copyFile",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v8.5.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27044",
+                    "description": "Changed 'flags' argument to 'mode' and imposed stricter type validation."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`src` {string|Buffer|URL} source filename to copy",
+                      "name": "src",
+                      "type": "string|Buffer|URL",
+                      "desc": "source filename to copy"
+                    },
+                    {
+                      "textRaw": "`dest` {string|Buffer|URL} destination filename of the copy operation",
+                      "name": "dest",
+                      "type": "string|Buffer|URL",
+                      "desc": "destination filename of the copy operation"
+                    },
+                    {
+                      "textRaw": "`mode` {integer} modifiers for copy operation. **Default:** `0`.",
+                      "name": "mode",
+                      "type": "integer",
+                      "default": "`0`",
+                      "desc": "modifiers for copy operation."
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function"
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a file system\ndirectory.</p>"
+              "desc": "<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. No arguments other than a possible exception are given to the\ncallback function. Node.js makes no guarantees about the atomicity of the copy\noperation. If an error occurs after the destination file has been opened for\nwriting, Node.js will attempt to remove the destination.</p>\n<p><code>mode</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support\ncopy-on-write, then the operation will fail.</li>\n</ul>\n<pre><code class=\"language-mjs\">import { copyFile, constants } from 'fs';\n\nfunction callback(err) {\n  if (err) throw err;\n  console.log('source.txt was copied to destination.txt');\n}\n\n// destination.txt will be created or overwritten by default.\ncopyFile('source.txt', 'destination.txt', callback);\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\ncopyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL, callback);\n</code></pre>"
             },
             {
-              "textRaw": "`dirent.isFIFO()`",
+              "textRaw": "`fs.createReadStream(path[, options])`",
               "type": "method",
-              "name": "isFIFO",
+              "name": "createReadStream",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31408",
+                    "description": "Change `emitClose` default to `true`."
+                  },
+                  {
+                    "version": [
+                      "v13.6.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29083",
+                    "description": "The `fs` options allow overriding the used `fs` implementation."
+                  },
+                  {
+                    "version": "v12.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29212",
+                    "description": "Enable `emitClose` option."
+                  },
+                  {
+                    "version": "v11.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/19898",
+                    "description": "Impose new restrictions on `start` and `end`, throwing more appropriate errors in cases when we cannot reasonably handle the input values."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  },
+                  {
+                    "version": "v2.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/1845",
+                    "description": "The passed `options` object can be a string now."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {boolean}",
+                    "textRaw": "Returns: {fs.ReadStream} See [Readable Stream][].",
                     "name": "return",
-                    "type": "boolean"
+                    "type": "fs.ReadStream",
+                    "desc": "See [Readable Stream][]."
                   },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`flags` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
+                          "name": "flags",
+                          "type": "string",
+                          "default": "`'r'`",
+                          "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `null`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`fd` {integer} **Default:** `null`",
+                          "name": "fd",
+                          "type": "integer",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`autoClose` {boolean} **Default:** `true`",
+                          "name": "autoClose",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`emitClose` {boolean} **Default:** `true`",
+                          "name": "emitClose",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`start` {integer}",
+                          "name": "start",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`end` {integer} **Default:** `Infinity`",
+                          "name": "end",
+                          "type": "integer",
+                          "default": "`Infinity`"
+                        },
+                        {
+                          "textRaw": "`highWaterMark` {integer} **Default:** `64 * 1024`",
+                          "name": "highWaterMark",
+                          "type": "integer",
+                          "default": "`64 * 1024`"
+                        },
+                        {
+                          "textRaw": "`fs` {Object|null} **Default:** `null`",
+                          "name": "fs",
+                          "type": "Object|null",
+                          "default": "`null`"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a first-in-first-out\n(FIFO) pipe.</p>"
+              "desc": "<p>Unlike the 16 kb default <code>highWaterMark</code> for a readable stream, the stream\nreturned by this method has a default <code>highWaterMark</code> of 64 kb.</p>\n<p><code>options</code> can include <code>start</code> and <code>end</code> values to read a range of bytes from\nthe file instead of the entire file. Both <code>start</code> and <code>end</code> are inclusive and\nstart counting at 0, allowed values are in the\n[0, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\"><code>Number.MAX_SAFE_INTEGER</code></a>] range. If <code>fd</code> is specified and <code>start</code> is\nomitted or <code>undefined</code>, <code>fs.createReadStream()</code> reads sequentially from the\ncurrent file position. The <code>encoding</code> can be any one of those accepted by\n<a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>If <code>fd</code> is specified, <code>ReadStream</code> will ignore the <code>path</code> argument and will use\nthe specified file descriptor. This means that no <code>'open'</code> event will be\nemitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s should be passed to\n<a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>If <code>fd</code> points to a character device that only supports blocking reads\n(such as keyboard or sound card), read operations do not finish until data is\navailable. This can prevent the process from exiting and the stream from\nclosing naturally.</p>\n<p>By default, the stream will emit a <code>'close'</code> event after it has been\ndestroyed, like most <code>Readable</code> streams.  Set the <code>emitClose</code> option to\n<code>false</code> to change this behavior.</p>\n<p>By providing the <code>fs</code> option, it is possible to override the corresponding <code>fs</code>\nimplementations for <code>open</code>, <code>read</code>, and <code>close</code>. When providing the <code>fs</code> option,\noverrides for <code>open</code>, <code>read</code>, and <code>close</code> are required.</p>\n<pre><code class=\"language-mjs\">import { createReadStream } from 'fs';\n\n// Create a stream from some character device.\nconst stream = createReadStream('/dev/input/event0');\nsetTimeout(() => {\n  stream.close(); // This may not close the stream.\n  // Artificially marking end-of-stream, as if the underlying resource had\n  // indicated end-of-file by itself, allows the stream to close.\n  // This does not cancel pending read operations, and if there is such an\n  // operation, the process may still not be able to exit successfully\n  // until it finishes.\n  stream.push(null);\n  stream.read(0);\n}, 100);\n</code></pre>\n<p>If <code>autoClose</code> is false, then the file descriptor won't be closed, even if\nthere's an error. It is the application's responsibility to close it and make\nsure there's no file descriptor leak. If <code>autoClose</code> is set to true (default\nbehavior), on <code>'error'</code> or <code>'end'</code> the file descriptor will be closed\nautomatically.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the\nfile was created.</p>\n<p>An example to read the last 10 bytes of a file which is 100 bytes long:</p>\n<pre><code class=\"language-mjs\">import { createReadStream } from 'fs';\n\ncreateReadStream('sample.txt', { start: 90, end: 99 });\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>"
             },
             {
-              "textRaw": "`dirent.isFile()`",
+              "textRaw": "`fs.createWriteStream(path[, options])`",
               "type": "method",
-              "name": "isFile",
+              "name": "createWriteStream",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31408",
+                    "description": "Change `emitClose` default to `true`."
+                  },
+                  {
+                    "version": [
+                      "v13.6.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/29083",
+                    "description": "The `fs` options allow overriding the used `fs` implementation."
+                  },
+                  {
+                    "version": "v12.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29212",
+                    "description": "Enable `emitClose` option."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  },
+                  {
+                    "version": "v5.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3679",
+                    "description": "The `autoClose` option is supported now."
+                  },
+                  {
+                    "version": "v2.3.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/1845",
+                    "description": "The passed `options` object can be a string now."
+                  }
+                ]
               },
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {boolean}",
+                    "textRaw": "Returns: {fs.WriteStream} See [Writable Stream][].",
                     "name": "return",
-                    "type": "boolean"
+                    "type": "fs.WriteStream",
+                    "desc": "See [Writable Stream][]."
                   },
-                  "params": []
-                }
-              ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a regular file.</p>"
-            },
-            {
-              "textRaw": "`dirent.isSocket()`",
-              "type": "method",
-              "name": "isSocket",
-              "meta": {
-                "added": [
-                  "v10.10.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`flags` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
+                          "name": "flags",
+                          "type": "string",
+                          "default": "`'w'`",
+                          "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`fd` {integer} **Default:** `null`",
+                          "name": "fd",
+                          "type": "integer",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`autoClose` {boolean} **Default:** `true`",
+                          "name": "autoClose",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`emitClose` {boolean} **Default:** `true`",
+                          "name": "emitClose",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`start` {integer}",
+                          "name": "start",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`fs` {Object|null} **Default:** `null`",
+                          "name": "fs",
+                          "type": "Object|null",
+                          "default": "`null`"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a socket.</p>"
+              "desc": "<p><code>options</code> may also include a <code>start</code> option to allow writing data at some\nposition past the beginning of the file, allowed values are in the\n[0, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\"><code>Number.MAX_SAFE_INTEGER</code></a>] range. Modifying a file rather than replacing\nit may require the <code>flags</code> option to be set to <code>r+</code> rather than the default <code>w</code>.\nThe <code>encoding</code> can be any one of those accepted by <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>If <code>autoClose</code> is set to true (default behavior) on <code>'error'</code> or <code>'finish'</code>\nthe file descriptor will be closed automatically. If <code>autoClose</code> is false,\nthen the file descriptor won't be closed, even if there's an error.\nIt is the application's responsibility to close it and make sure there's no\nfile descriptor leak.</p>\n<p>By default, the stream will emit a <code>'close'</code> event after it has been\ndestroyed, like most <code>Writable</code> streams.  Set the <code>emitClose</code> option to\n<code>false</code> to change this behavior.</p>\n<p>By providing the <code>fs</code> option it is possible to override the corresponding <code>fs</code>\nimplementations for <code>open</code>, <code>write</code>, <code>writev</code> and <code>close</code>. Overriding <code>write()</code>\nwithout <code>writev()</code> can reduce performance as some optimizations (<code>_writev()</code>)\nwill be disabled. When providing the <code>fs</code> option,  overrides for <code>open</code>,\n<code>close</code>, and at least one of <code>write</code> and <code>writev</code> are required.</p>\n<p>Like <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a>, if <code>fd</code> is specified, <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a> will ignore the\n<code>path</code> argument and will use the specified file descriptor. This means that no\n<code>'open'</code> event will be emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s\nshould be passed to <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>"
             },
             {
-              "textRaw": "`dirent.isSymbolicLink()`",
+              "textRaw": "`fs.exists(path, callback)`",
               "type": "method",
-              "name": "isSymbolicLink",
-              "meta": {
-                "added": [
-                  "v10.10.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
-                }
-              ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Dirent</code> object describes a symbolic link.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`name` {string|Buffer}",
-              "type": "string|Buffer",
-              "name": "name",
+              "name": "exists",
               "meta": {
                 "added": [
-                  "v10.10.0"
+                  "v0.0.2"
                 ],
-                "changes": []
-              },
-              "desc": "<p>The file name that this <code>fs.Dirent</code> object refers to. The type of this\nvalue is determined by the <code>options.encoding</code> passed to <a href=\"#fs_fs_readdir_path_options_callback\"><code>fs.readdir()</code></a> or\n<a href=\"#fs_fs_readdirsync_path_options\"><code>fs.readdirSync()</code></a>.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.FSWatcher`",
-          "type": "class",
-          "name": "fs.FSWatcher",
-          "meta": {
-            "added": [
-              "v0.5.8"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>A successful call to <a href=\"#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> method will return a new <code>fs.FSWatcher</code>\nobject.</p>\n<p>All <code>fs.FSWatcher</code> objects emit a <code>'change'</code> event whenever a specific watched\nfile is modified.</p>",
-          "events": [
-            {
-              "textRaw": "Event: `'change'`",
-              "type": "event",
-              "name": "change",
-              "meta": {
-                "added": [
-                  "v0.5.8"
+                "deprecated": [
+                  "v1.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`eventType` {string} The type of change event that has occurred",
-                  "name": "eventType",
-                  "type": "string",
-                  "desc": "The type of change event that has occurred"
-                },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use [`fs.stat()`][] or [`fs.access()`][] instead.",
+              "signatures": [
                 {
-                  "textRaw": "`filename` {string|Buffer} The filename that changed (if relevant/available)",
-                  "name": "filename",
-                  "type": "string|Buffer",
-                  "desc": "The filename that changed (if relevant/available)"
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`exists` {boolean}",
+                          "name": "exists",
+                          "type": "boolean"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted when something changes in a watched directory or file.\nSee more details in <a href=\"#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a>.</p>\n<p>The <code>filename</code> argument may not be provided depending on operating system\nsupport. If <code>filename</code> is provided, it will be provided as a <code>Buffer</code> if\n<code>fs.watch()</code> is called with its <code>encoding</code> option set to <code>'buffer'</code>, otherwise\n<code>filename</code> will be a UTF-8 string.</p>\n<pre><code class=\"language-js\">// Example when handled through fs.watch() listener\nfs.watch('./tmp', { encoding: 'buffer' }, (eventType, filename) => {\n  if (filename) {\n    console.log(filename);\n    // Prints: &#x3C;Buffer ...>\n  }\n});\n</code></pre>"
-            },
-            {
-              "textRaw": "Event: `'close'`",
-              "type": "event",
-              "name": "close",
-              "meta": {
-                "added": [
-                  "v10.0.0"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Emitted when the watcher stops watching for changes. The closed\n<code>fs.FSWatcher</code> object is no longer usable in the event handler.</p>"
+              "desc": "<p>Test whether or not the given path exists by checking with the file system.\nThen call the <code>callback</code> argument with either true or false:</p>\n<pre><code class=\"language-mjs\">import { exists } from 'fs';\n\nexists('/etc/passwd', (e) => {\n  console.log(e ? 'it exists' : 'no passwd!');\n});\n</code></pre>\n<p><strong>The parameters for this callback are not consistent with other Node.js\ncallbacks.</strong> Normally, the first parameter to a Node.js callback is an <code>err</code>\nparameter, optionally followed by other parameters. The <code>fs.exists()</code> callback\nhas only one boolean parameter. This is one reason <code>fs.access()</code> is recommended\ninstead of <code>fs.exists()</code>.</p>\n<p>Using <code>fs.exists()</code> to check for the existence of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended. Doing\nso introduces a race condition, since other processes may change the file's\nstate between the two calls. Instead, user code should open/read/write the\nfile directly and handle the error raised if the file does not exist.</p>\n<p><strong>write (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { exists, open, close } from 'fs';\n\nexists('myfile', (e) => {\n  if (e) {\n    console.error('myfile already exists');\n  } else {\n    open('myfile', 'wx', (err, fd) => {\n      if (err) throw err;\n\n      try {\n        writeMyData(fd);\n      } finally {\n        close(fd, (err) => {\n          if (err) throw err;\n        });\n      }\n    });\n  }\n});\n</code></pre>\n<p><strong>write (RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close } from 'fs';\nopen('myfile', 'wx', (err, fd) => {\n  if (err) {\n    if (err.code === 'EEXIST') {\n      console.error('myfile already exists');\n      return;\n    }\n\n    throw err;\n  }\n\n  try {\n    writeMyData(fd);\n  } finally {\n    close(fd, (err) => {\n      if (err) throw err;\n    });\n  }\n});\n</code></pre>\n<p><strong>read (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close, exists } from 'fs';\n\nexists('myfile', (e) => {\n  if (e) {\n    open('myfile', 'r', (err, fd) => {\n      if (err) throw err;\n\n      try {\n        readMyData(fd);\n      } finally {\n        close(fd, (err) => {\n          if (err) throw err;\n        });\n      }\n    });\n  } else {\n    console.error('myfile does not exist');\n  }\n});\n</code></pre>\n<p><strong>read (RECOMMENDED)</strong></p>\n<pre><code class=\"language-mjs\">import { open, close } from 'fs';\n\nopen('myfile', 'r', (err, fd) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  try {\n    readMyData(fd);\n  } finally {\n    close(fd, (err) => {\n      if (err) throw err;\n    });\n  }\n});\n</code></pre>\n<p>The \"not recommended\" examples above check for existence and then use the\nfile; the \"recommended\" examples are better because they use the file directly\nand handle the error, if any.</p>\n<p>In general, check for the existence of a file only if the file won’t be\nused directly, for example when its existence is a signal from another\nprocess.</p>"
             },
             {
-              "textRaw": "Event: `'error'`",
-              "type": "event",
-              "name": "error",
+              "textRaw": "`fs.fchmod(fd, mode, callback)`",
+              "type": "method",
+              "name": "fchmod",
               "meta": {
                 "added": [
-                  "v0.5.8"
+                  "v0.4.7"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "params": [
+              "signatures": [
                 {
-                  "textRaw": "`error` {Error}",
-                  "name": "error",
-                  "type": "Error"
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer}",
+                      "name": "mode",
+                      "type": "string|integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted when an error occurs while watching the file. The errored\n<code>fs.FSWatcher</code> object is no longer usable in the event handler.</p>"
-            }
-          ],
-          "methods": [
+              "desc": "<p>Sets the permissions on the file. No arguments other than a possible exception\nare given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fchmod.2.html\"><code>fchmod(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "textRaw": "`watcher.close()`",
+              "textRaw": "`fs.fchown(fd, uid, gid, callback)`",
               "type": "method",
-              "name": "close",
+              "name": "fchown",
               "meta": {
                 "added": [
-                  "v0.5.8"
+                  "v0.4.7"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`uid` {integer}",
+                      "name": "uid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`gid` {integer}",
+                      "name": "gid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Stop watching for changes on the given <code>fs.FSWatcher</code>. Once stopped, the\n<code>fs.FSWatcher</code> object is no longer usable.</p>"
+              "desc": "<p>Sets the owner of the file. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fchown.2.html\"><code>fchown(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`watcher.ref()`",
+              "textRaw": "`fs.fdatasync(fd, callback)`",
               "type": "method",
-              "name": "ref",
+              "name": "fdatasync",
               "meta": {
                 "added": [
-                  "v12.20.0"
+                  "v0.1.96"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {fs.FSWatcher}",
-                    "name": "return",
-                    "type": "fs.FSWatcher"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the\n<code>FSWatcher</code> is active. Calling <code>watcher.ref()</code> multiple times will have\nno effect.</p>\n<p>By default, all <code>FSWatcher</code> objects are \"ref'ed\", making it normally\nunnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been\ncalled previously.</p>"
+              "desc": "<p>Forces all currently queued I/O operations associated with the file to the\noperating system's synchronized I/O completion state. Refer to the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a> documentation for details. No arguments other than a possible\nexception are given to the completion callback.</p>"
             },
             {
-              "textRaw": "`watcher.unref()`",
+              "textRaw": "`fs.fstat(fd[, options], callback)`",
               "type": "method",
-              "name": "unref",
+              "name": "fstat",
               "meta": {
                 "added": [
-                  "v12.20.0"
+                  "v0.1.95"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {fs.FSWatcher}",
-                    "name": "return",
-                    "type": "fs.FSWatcher"
-                  },
-                  "params": []
-                }
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`stats` {fs.Stats}",
+                          "name": "stats",
+                          "type": "fs.Stats"
+                        }
+                      ]
+                    }
+                  ]
+                }
               ],
-              "desc": "<p>When called, the active <code>FSWatcher</code> object will not require the Node.js\nevent loop to remain active. If there is no other activity keeping the\nevent loop running, the process may exit before the <code>FSWatcher</code> object's\ncallback is invoked. Calling <code>watcher.unref()</code> multiple times will have\nno effect.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.StatWatcher`",
-          "type": "class",
-          "name": "fs.StatWatcher",
-          "meta": {
-            "added": [
-              "v12.20.0"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>A successful call to <code>fs.watchFile()</code> method will return a new <code>fs.StatWatcher</code>\nobject.</p>",
-          "methods": [
+              "desc": "<p>Invokes the callback with the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the file descriptor.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fstat.2.html\"><code>fstat(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "textRaw": "`watcher.ref()`",
+              "textRaw": "`fs.fsync(fd, callback)`",
               "type": "method",
-              "name": "ref",
+              "name": "fsync",
               "meta": {
                 "added": [
-                  "v12.20.0"
+                  "v0.1.96"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {fs.StatWatcher}",
-                    "name": "return",
-                    "type": "fs.StatWatcher"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the\n<code>StatWatcher</code> is active. Calling <code>watcher.ref()</code> multiple times will have\nno effect.</p>\n<p>By default, all <code>StatWatcher</code> objects are \"ref'ed\", making it normally\nunnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been\ncalled previously.</p>"
+              "desc": "<p>Request that all data for the open file descriptor is flushed to the storage\ndevice. The specific implementation is operating system and device specific.\nRefer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a> documentation for more detail. No arguments other\nthan a possible exception are given to the completion callback.</p>"
             },
             {
-              "textRaw": "`watcher.unref()`",
+              "textRaw": "`fs.ftruncate(fd[, len], callback)`",
               "type": "method",
-              "name": "unref",
+              "name": "ftruncate",
               "meta": {
                 "added": [
-                  "v12.20.0"
+                  "v0.8.6"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {fs.StatWatcher}",
-                    "name": "return",
-                    "type": "fs.StatWatcher"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`len` {integer} **Default:** `0`",
+                      "name": "len",
+                      "type": "integer",
+                      "default": "`0`"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>When called, the active <code>StatWatcher</code> object will not require the Node.js\nevent loop to remain active. If there is no other activity keeping the\nevent loop running, the process may exit before the <code>StatWatcher</code> object's\ncallback is invoked. Calling <code>watcher.unref()</code> multiple times will have\nno effect.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.ReadStream`",
-          "type": "class",
-          "name": "fs.ReadStream",
-          "meta": {
-            "added": [
-              "v0.1.93"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_readable\" class=\"type\">&lt;stream.Readable&gt;</a></li>\n</ul>\n<p>Instances of <code>fs.ReadStream</code> are created and returned using the\n<a href=\"#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a> function.</p>",
-          "events": [
-            {
-              "textRaw": "Event: `'close'`",
-              "type": "event",
-              "name": "close",
-              "meta": {
-                "added": [
-                  "v0.1.93"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Emitted when the <code>fs.ReadStream</code>'s underlying file descriptor has been closed.</p>"
+              "desc": "<p>Truncates the file descriptor. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/ftruncate.2.html\"><code>ftruncate(2)</code></a> documentation for more detail.</p>\n<p>If the file referred to by the file descriptor was larger than <code>len</code> bytes, only\nthe first <code>len</code> bytes will be retained in the file.</p>\n<p>For example, the following program retains only the first four bytes of the\nfile:</p>\n<pre><code class=\"language-mjs\">import { open, close, ftruncate } from 'fs';\n\nfunction closeFd(fd) {\n  close(fd, (err) => {\n    if (err) throw err;\n  });\n}\n\nopen('temp.txt', 'r+', (err, fd) => {\n  if (err) throw err;\n\n  try {\n    ftruncate(fd, 4, (err) => {\n      closeFd(fd);\n      if (err) throw err;\n    });\n  } catch (err) {\n    closeFd(fd);\n    if (err) throw err;\n  }\n});\n</code></pre>\n<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the\nextended part is filled with null bytes (<code>'\\0'</code>):</p>\n<p>If <code>len</code> is negative then <code>0</code> will be used.</p>"
             },
             {
-              "textRaw": "Event: `'open'`",
-              "type": "event",
-              "name": "open",
+              "textRaw": "`fs.futimes(fd, atime, mtime, callback)`",
+              "type": "method",
+              "name": "futimes",
               "meta": {
                 "added": [
-                  "v0.1.93"
+                  "v0.4.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v4.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/2387",
+                    "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
+                  }
+                ]
               },
-              "params": [
+              "signatures": [
                 {
-                  "textRaw": "`fd` {integer} Integer file descriptor used by the `ReadStream`.",
-                  "name": "fd",
-                  "type": "integer",
-                  "desc": "Integer file descriptor used by the `ReadStream`."
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted when the <code>fs.ReadStream</code>'s file descriptor has been opened.</p>"
-            },
-            {
-              "textRaw": "Event: `'ready'`",
-              "type": "event",
-              "name": "ready",
-              "meta": {
-                "added": [
-                  "v9.11.0"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Emitted when the <code>fs.ReadStream</code> is ready to be used.</p>\n<p>Fires immediately after <code>'open'</code>.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`bytesRead` {number}",
-              "type": "number",
-              "name": "bytesRead",
-              "meta": {
-                "added": [
-                  "v6.4.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The number of bytes that have been read so far.</p>"
-            },
-            {
-              "textRaw": "`path` {string|Buffer}",
-              "type": "string|Buffer",
-              "name": "path",
-              "meta": {
-                "added": [
-                  "v0.1.93"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The path to the file the stream is reading from as specified in the first\nargument to <code>fs.createReadStream()</code>. If <code>path</code> is passed as a string, then\n<code>readStream.path</code> will be a string. If <code>path</code> is passed as a <code>Buffer</code>, then\n<code>readStream.path</code> will be a <code>Buffer</code>.</p>"
+              "desc": "<p>Change the file system timestamps of the object referenced by the supplied file\ndescriptor. See <a href=\"#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>.</p>\n<p>This function does not work on AIX versions before 7.1, it will return the\nerror <code>UV_ENOSYS</code>.</p>"
             },
             {
-              "textRaw": "`pending` {boolean}",
-              "type": "boolean",
-              "name": "pending",
-              "meta": {
-                "added": [
-                  "v11.2.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>This property is <code>true</code> if the underlying file has not been opened yet,\ni.e. before the <code>'ready'</code> event is emitted.</p>"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.Stats`",
-          "type": "class",
-          "name": "fs.Stats",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v8.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/13173",
-                "description": "Added times as numbers."
-              }
-            ]
-          },
-          "desc": "<p>A <code>fs.Stats</code> object provides information about a file.</p>\n<p>Objects returned from <a href=\"#fs_fs_stat_path_options_callback\"><code>fs.stat()</code></a>, <a href=\"#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a> and <a href=\"#fs_fs_fstat_fd_options_callback\"><code>fs.fstat()</code></a> and\ntheir synchronous counterparts are of this type.\nIf <code>bigint</code> in the <code>options</code> passed to those methods is true, the numeric values\nwill be <code>bigint</code> instead of <code>number</code>, and the object will contain additional\nnanosecond-precision properties suffixed with <code>Ns</code>.</p>\n<pre><code class=\"language-console\">Stats {\n  dev: 2114,\n  ino: 48064969,\n  mode: 33188,\n  nlink: 1,\n  uid: 85,\n  gid: 100,\n  rdev: 0,\n  size: 527,\n  blksize: 4096,\n  blocks: 8,\n  atimeMs: 1318289051000.1,\n  mtimeMs: 1318289051000.1,\n  ctimeMs: 1318289051000.1,\n  birthtimeMs: 1318289051000.1,\n  atime: Mon, 10 Oct 2011 23:24:11 GMT,\n  mtime: Mon, 10 Oct 2011 23:24:11 GMT,\n  ctime: Mon, 10 Oct 2011 23:24:11 GMT,\n  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }\n</code></pre>\n<p><code>bigint</code> version:</p>\n<pre><code class=\"language-console\">BigIntStats {\n  dev: 2114n,\n  ino: 48064969n,\n  mode: 33188n,\n  nlink: 1n,\n  uid: 85n,\n  gid: 100n,\n  rdev: 0n,\n  size: 527n,\n  blksize: 4096n,\n  blocks: 8n,\n  atimeMs: 1318289051000n,\n  mtimeMs: 1318289051000n,\n  ctimeMs: 1318289051000n,\n  birthtimeMs: 1318289051000n,\n  atimeNs: 1318289051000000000n,\n  mtimeNs: 1318289051000000000n,\n  ctimeNs: 1318289051000000000n,\n  birthtimeNs: 1318289051000000000n,\n  atime: Mon, 10 Oct 2011 23:24:11 GMT,\n  mtime: Mon, 10 Oct 2011 23:24:11 GMT,\n  ctime: Mon, 10 Oct 2011 23:24:11 GMT,\n  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }\n</code></pre>",
-          "methods": [
-            {
-              "textRaw": "`stats.isBlockDevice()`",
+              "textRaw": "`fs.lchmod(path, mode, callback)`",
               "type": "method",
-              "name": "isBlockDevice",
+              "name": "lchmod",
               "meta": {
-                "added": [
-                  "v0.1.10"
+                "deprecated": [
+                  "v0.4.7"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`mode` {integer}",
+                      "name": "mode",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a block device.</p>"
+              "desc": "<p>Changes the permissions on a symbolic link. No arguments other than a possible\nexception are given to the completion callback.</p>\n<p>This method is only implemented on macOS.</p>\n<p>See the POSIX <a href=\"https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2\"><code>lchmod(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`stats.isCharacterDevice()`",
+              "textRaw": "`fs.lchown(path, uid, gid, callback)`",
               "type": "method",
-              "name": "isCharacterDevice",
+              "name": "lchown",
               "meta": {
-                "added": [
-                  "v0.1.10"
-                ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/21498",
+                    "description": "This API is no longer deprecated."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v0.4.7",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`uid` {integer}",
+                      "name": "uid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`gid` {integer}",
+                      "name": "gid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a character device.</p>"
+              "desc": "<p>Set the owner of the symbolic link. No arguments other than a possible\nexception are given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lchown.2.html\"><code>lchown(2)</code></a> documentation for more detail.</p>"
             },
             {
-              "textRaw": "`stats.isDirectory()`",
+              "textRaw": "`fs.lutimes(path, atime, mtime, callback)`",
               "type": "method",
-              "name": "isDirectory",
+              "name": "lutimes",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v14.5.0",
+                  "v12.19.0"
                 ],
                 "changes": []
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a file system directory.</p>"
+              "desc": "<p>Changes the access and modification times of a file in the same way as\n<a href=\"#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>, with the difference that if the path refers to a symbolic\nlink, then the link is not dereferenced: instead, the timestamps of the\nsymbolic link itself are changed.</p>\n<p>No arguments other than a possible exception are given to the completion\ncallback.</p>"
             },
             {
-              "textRaw": "`stats.isFIFO()`",
+              "textRaw": "`fs.link(existingPath, newPath, callback)`",
               "type": "method",
-              "name": "isFIFO",
+              "name": "link",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `existingPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`existingPath` {string|Buffer|URL}",
+                      "name": "existingPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`newPath` {string|Buffer|URL}",
+                      "name": "newPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a first-in-first-out (FIFO)\npipe.</p>"
+              "desc": "<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a> documentation for more detail. No arguments other than a possible\nexception are given to the completion callback.</p>"
             },
             {
-              "textRaw": "`stats.isFile()`",
+              "textRaw": "`fs.lstat(path[, options], callback)`",
               "type": "method",
-              "name": "isFile",
+              "name": "lstat",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v0.1.30"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`stats` {fs.Stats}",
+                          "name": "stats",
+                          "type": "fs.Stats"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a regular file.</p>"
+              "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the symbolic link referred to by the path.\nThe callback gets two arguments <code>(err, stats)</code> where <code>stats</code> is a <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a>\nobject. <code>lstat()</code> is identical to <code>stat()</code>, except that if <code>path</code> is a symbolic\nlink, then the link itself is stat-ed, not the file that it refers to.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a> documentation for more details.</p>"
             },
             {
-              "textRaw": "`stats.isSocket()`",
+              "textRaw": "`fs.mkdir(path[, options], callback)`",
               "type": "method",
-              "name": "isSocket",
+              "name": "mkdir",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v0.1.8"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.11.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31530",
+                    "description": "In `recursive` mode, the callback now receives the first created path as an argument."
+                  },
+                  {
+                    "version": "v10.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/21875",
+                    "description": "The second argument can now be an `options` object with `recursive` and `mode` properties."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object|integer}",
+                      "name": "options",
+                      "type": "Object|integer",
+                      "options": [
+                        {
+                          "textRaw": "`recursive` {boolean} **Default:** `false`",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`"
+                        },
+                        {
+                          "textRaw": "`mode` {string|integer} Not supported on Windows. **Default:** `0o777`.",
+                          "name": "mode",
+                          "type": "string|integer",
+                          "default": "`0o777`",
+                          "desc": "Not supported on Windows."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a socket.</p>"
+              "desc": "<p>Asynchronously creates a directory.</p>\n<p>The callback is given a possible exception and, if <code>recursive</code> is <code>true</code>, the\nfirst directory path created, <code>(err, [path])</code>.\n<code>path</code> can still be <code>undefined</code> when <code>recursive</code> is <code>true</code>, if no directory was\ncreated.</p>\n<p>The optional <code>options</code> argument can be an integer specifying <code>mode</code> (permission\nand sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>\nproperty indicating whether parent directories should be created. Calling\n<code>fs.mkdir()</code> when <code>path</code> is a directory that exists results in an error only\nwhen <code>recursive</code> is false.</p>\n<pre><code class=\"language-mjs\">import { mkdir } from 'fs';\n\n// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.\nmkdir('/tmp/a/apple', { recursive: true }, (err) => {\n  if (err) throw err;\n});\n</code></pre>\n<p>On Windows, using <code>fs.mkdir()</code> on the root directory even with recursion will\nresult in an error:</p>\n<pre><code class=\"language-mjs\">import { mkdir } from 'fs';\n\nmkdir('/', { recursive: true }, (err) => {\n  // => [Error: EPERM: operation not permitted, mkdir 'C:\\']\n});\n</code></pre>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/mkdir.2.html\"><code>mkdir(2)</code></a> documentation for more details.</p>"
             },
             {
-              "textRaw": "`stats.isSymbolicLink()`",
+              "textRaw": "`fs.mkdtemp(prefix[, options], callback)`",
               "type": "method",
-              "name": "isSymbolicLink",
+              "name": "mkdtemp",
               "meta": {
                 "added": [
-                  "v0.1.10"
+                  "v5.10.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/39028",
+                    "description": "The `prefix` parameter now accepts an empty string."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v6.2.1",
+                    "pr-url": "https://github.com/nodejs/node/pull/6828",
+                    "description": "The `callback` parameter is optional now."
+                  }
+                ]
               },
               "signatures": [
                 {
-                  "return": {
-                    "textRaw": "Returns: {boolean}",
-                    "name": "return",
-                    "type": "boolean"
-                  },
-                  "params": []
-                }
-              ],
-              "desc": "<p>Returns <code>true</code> if the <code>fs.Stats</code> object describes a symbolic link.</p>\n<p>This method is only valid when using <a href=\"#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a>.</p>"
-            }
-          ],
-          "properties": [
-            {
-              "textRaw": "`dev` {number|bigint}",
-              "type": "number|bigint",
-              "name": "dev",
-              "desc": "<p>The numeric identifier of the device containing the file.</p>"
-            },
-            {
-              "textRaw": "`ino` {number|bigint}",
-              "type": "number|bigint",
-              "name": "ino",
-              "desc": "<p>The file system specific \"Inode\" number for the file.</p>"
-            },
-            {
-              "textRaw": "`mode` {number|bigint}",
-              "type": "number|bigint",
-              "name": "mode",
-              "desc": "<p>A bit-field describing the file type and mode.</p>"
-            },
-            {
-              "textRaw": "`nlink` {number|bigint}",
-              "type": "number|bigint",
-              "name": "nlink",
-              "desc": "<p>The number of hard-links that exist for the file.</p>"
-            },
-            {
-              "textRaw": "`uid` {number|bigint}",
-              "type": "number|bigint",
-              "name": "uid",
-              "desc": "<p>The numeric user identifier of the user that owns the file (POSIX).</p>"
-            },
-            {
-              "textRaw": "`gid` {number|bigint}",
-              "type": "number|bigint",
-              "name": "gid",
-              "desc": "<p>The numeric group identifier of the group that owns the file (POSIX).</p>"
-            },
-            {
-              "textRaw": "`rdev` {number|bigint}",
-              "type": "number|bigint",
-              "name": "rdev",
-              "desc": "<p>A numeric device identifier if the file represents a device.</p>"
-            },
-            {
-              "textRaw": "`size` {number|bigint}",
-              "type": "number|bigint",
-              "name": "size",
-              "desc": "<p>The size of the file in bytes.</p>"
-            },
-            {
-              "textRaw": "`blksize` {number|bigint}",
-              "type": "number|bigint",
-              "name": "blksize",
-              "desc": "<p>The file system block size for i/o operations.</p>"
-            },
-            {
-              "textRaw": "`blocks` {number|bigint}",
-              "type": "number|bigint",
-              "name": "blocks",
-              "desc": "<p>The number of blocks allocated for this file.</p>"
-            },
-            {
-              "textRaw": "`atimeMs` {number|bigint}",
-              "type": "number|bigint",
-              "name": "atimeMs",
-              "meta": {
-                "added": [
-                  "v8.1.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The timestamp indicating the last time this file was accessed expressed in\nmilliseconds since the POSIX Epoch.</p>"
-            },
-            {
-              "textRaw": "`mtimeMs` {number|bigint}",
-              "type": "number|bigint",
-              "name": "mtimeMs",
-              "meta": {
-                "added": [
-                  "v8.1.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The timestamp indicating the last time this file was modified expressed in\nmilliseconds since the POSIX Epoch.</p>"
-            },
-            {
-              "textRaw": "`ctimeMs` {number|bigint}",
-              "type": "number|bigint",
-              "name": "ctimeMs",
-              "meta": {
-                "added": [
-                  "v8.1.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The timestamp indicating the last time the file status was changed expressed\nin milliseconds since the POSIX Epoch.</p>"
+                  "params": [
+                    {
+                      "textRaw": "`prefix` {string}",
+                      "name": "prefix",
+                      "type": "string"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`directory` {string}",
+                          "name": "directory",
+                          "type": "string"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Creates a unique temporary directory.</p>\n<p>Generates six random characters to be appended behind a required\n<code>prefix</code> to create a unique temporary directory. Due to platform\ninconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,\nnotably the BSDs, can return more than six random characters, and replace\ntrailing <code>X</code> characters in <code>prefix</code> with random characters.</p>\n<p>The created directory path is passed as a string to the callback's second\nparameter.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>\n<pre><code class=\"language-mjs\">import { mkdtemp } from 'fs';\n\nmkdtemp(path.join(os.tmpdir(), 'foo-'), (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Prints: /tmp/foo-itXde2 or C:\\Users\\...\\AppData\\Local\\Temp\\foo-itXde2\n});\n</code></pre>\n<p>The <code>fs.mkdtemp()</code> method will append the six randomly selected characters\ndirectly to the <code>prefix</code> string. For instance, given a directory <code>/tmp</code>, if the\nintention is to create a temporary directory <em>within</em> <code>/tmp</code>, the <code>prefix</code>\nmust end with a trailing platform-specific path separator\n(<code>require('path').sep</code>).</p>\n<pre><code class=\"language-mjs\">import { tmpdir } from 'os';\nimport { mkdtemp } from 'fs';\n\n// The parent directory for the new temporary directory\nconst tmpDir = tmpdir();\n\n// This method is *INCORRECT*:\nmkdtemp(tmpDir, (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Will print something similar to `/tmpabc123`.\n  // A new temporary directory is created at the file system root\n  // rather than *within* the /tmp directory.\n});\n\n// This method is *CORRECT*:\nimport { sep } from 'path';\nmkdtemp(`${tmpDir}${sep}`, (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Will print something similar to `/tmp/abc123`.\n  // A new temporary directory is created within\n  // the /tmp directory.\n});\n</code></pre>"
             },
             {
-              "textRaw": "`birthtimeMs` {number|bigint}",
-              "type": "number|bigint",
-              "name": "birthtimeMs",
+              "textRaw": "`fs.open(path[, flags[, mode]], callback)`",
+              "type": "method",
+              "name": "open",
               "meta": {
                 "added": [
-                  "v8.1.0"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v11.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23767",
+                    "description": "The `flags` argument is now optional and defaults to `'r'`."
+                  },
+                  {
+                    "version": "v9.9.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/18801",
+                    "description": "The `as` and `as+` flags are supported now."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the creation time of this file expressed in\nmilliseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`flags` {string|number} See [support of file system `flags`][]. **Default:** `'r'`.",
+                      "name": "flags",
+                      "type": "string|number",
+                      "default": "`'r'`",
+                      "desc": "See [support of file system `flags`][]."
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer} **Default:** `0o666` (readable and writable)",
+                      "name": "mode",
+                      "type": "string|integer",
+                      "default": "`0o666` (readable and writable)"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`fd` {integer}",
+                          "name": "fd",
+                          "type": "integer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronous file open. See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a> documentation for more details.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was\ncreated. On Windows, only the write permission can be manipulated; see\n<a href=\"#fs_fs_chmod_path_mode_callback\"><code>fs.chmod()</code></a>.</p>\n<p>The callback gets two arguments <code>(err, fd)</code>.</p>\n<p>Some characters (<code>&#x3C; > : \" / \\ | ? *</code>) are reserved under Windows as documented\nby <a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file\">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains\na colon, Node.js will open a file system stream, as described by\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams\">this MSDN page</a>.</p>\n<p>Functions based on <code>fs.open()</code> exhibit this behavior as well:\n<code>fs.writeFile()</code>, <code>fs.readFile()</code>, etc.</p>"
             },
             {
-              "textRaw": "`atimeNs` {bigint}",
-              "type": "bigint",
-              "name": "atimeNs",
+              "textRaw": "`fs.opendir(path[, options], callback)`",
+              "type": "method",
+              "name": "opendir",
               "meta": {
                 "added": [
-                  "v12.10.0"
+                  "v12.12.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.1.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30114",
+                    "description": "The `bufferSize` option was introduced."
+                  }
+                ]
               },
-              "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time this file was accessed expressed in\nnanoseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`bufferSize` {number} Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. **Default:** `32`",
+                          "name": "bufferSize",
+                          "type": "number",
+                          "default": "`32`",
+                          "desc": "Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`dir` {fs.Dir}",
+                          "name": "dir",
+                          "type": "fs.Dir"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously open a directory. See the POSIX <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a> documentation for\nmore details.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>"
             },
             {
-              "textRaw": "`mtimeNs` {bigint}",
-              "type": "bigint",
-              "name": "mtimeNs",
+              "textRaw": "`fs.read(fd, buffer, offset, length, position, callback)`",
+              "type": "method",
+              "name": "read",
               "meta": {
                 "added": [
-                  "v12.10.0"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `buffer` parameter can now be any `TypedArray`, or a `DataView`."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `buffer` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4518",
+                    "description": "The `length` parameter can now be `0`."
+                  }
+                ]
               },
-              "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time this file was modified expressed in\nnanoseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView} The buffer that the data will be written to. **Default:** `Buffer.alloc(16384)`",
+                      "name": "buffer",
+                      "type": "Buffer|TypedArray|DataView",
+                      "default": "`Buffer.alloc(16384)`",
+                      "desc": "The buffer that the data will be written to."
+                    },
+                    {
+                      "textRaw": "`offset` {integer} The position in `buffer` to write the data to. **Default:** `0`",
+                      "name": "offset",
+                      "type": "integer",
+                      "default": "`0`",
+                      "desc": "The position in `buffer` to write the data to."
+                    },
+                    {
+                      "textRaw": "`length` {integer} The number of bytes to read. **Default:** `buffer.byteLength`",
+                      "name": "length",
+                      "type": "integer",
+                      "default": "`buffer.byteLength`",
+                      "desc": "The number of bytes to read."
+                    },
+                    {
+                      "textRaw": "`position` {integer|bigint} Specifies where to begin reading from in the file. If `position` is `null` or `-1 `, data will be read from the current file position, and the file position will be updated. If `position` is an integer, the file position will be unchanged.",
+                      "name": "position",
+                      "type": "integer|bigint",
+                      "desc": "Specifies where to begin reading from in the file. If `position` is `null` or `-1 `, data will be read from the current file position, and the file position will be updated. If `position` is an integer, the file position will be unchanged."
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesRead` {integer}",
+                          "name": "bytesRead",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffer` {Buffer}",
+                          "name": "buffer",
+                          "type": "Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Read data from the file specified by <code>fd</code>.</p>\n<p>The callback is given the three arguments, <code>(err, bytesRead, buffer)</code>.</p>\n<p>If the file is not modified concurrently, the end-of-file is reached when the\nnumber of bytes read is zero.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na promise for an <code>Object</code> with <code>bytesRead</code> and <code>buffer</code> properties.</p>"
             },
             {
-              "textRaw": "`ctimeNs` {bigint}",
-              "type": "bigint",
-              "name": "ctimeNs",
+              "textRaw": "`fs.read(fd, [options,] callback)`",
+              "type": "method",
+              "name": "read",
               "meta": {
                 "added": [
-                  "v12.10.0"
+                  "v13.11.0",
+                  "v12.17.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.11.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31402",
+                    "description": "Options object can be passed in to make Buffer, offset, length and position optional."
+                  }
+                ]
               },
-              "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time the file status was changed expressed\nin nanoseconds since the POSIX Epoch.</p>"
-            },
-            {
-              "textRaw": "`birthtimeNs` {bigint}",
-              "type": "bigint",
-              "name": "birthtimeNs",
-              "meta": {
-                "added": [
-                  "v12.10.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the creation time of this file expressed in\nnanoseconds since the POSIX Epoch.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`buffer` {Buffer|TypedArray|DataView} **Default:** `Buffer.alloc(16384)`",
+                          "name": "buffer",
+                          "type": "Buffer|TypedArray|DataView",
+                          "default": "`Buffer.alloc(16384)`"
+                        },
+                        {
+                          "textRaw": "`offset` {integer} **Default:** `0`",
+                          "name": "offset",
+                          "type": "integer",
+                          "default": "`0`"
+                        },
+                        {
+                          "textRaw": "`length` {integer} **Default:** `buffer.byteLength`",
+                          "name": "length",
+                          "type": "integer",
+                          "default": "`buffer.byteLength`"
+                        },
+                        {
+                          "textRaw": "`position` {integer|bigint} **Default:** `null`",
+                          "name": "position",
+                          "type": "integer|bigint",
+                          "default": "`null`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesRead` {integer}",
+                          "name": "bytesRead",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffer` {Buffer}",
+                          "name": "buffer",
+                          "type": "Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Similar to the <a href=\"#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a> function, this version takes an optional\n<code>options</code> object. If no <code>options</code> object is specified, it will default with the\nabove values.</p>"
             },
             {
-              "textRaw": "`atime` {Date}",
-              "type": "Date",
-              "name": "atime",
+              "textRaw": "`fs.readdir(path[, options], callback)`",
+              "type": "method",
+              "name": "readdir",
               "meta": {
                 "added": [
-                  "v0.11.13"
+                  "v0.1.8"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22020",
+                    "description": "New option `withFileTypes` was added."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/5616",
+                    "description": "The `options` parameter was added."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the last time this file was accessed.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`withFileTypes` {boolean} **Default:** `false`",
+                          "name": "withFileTypes",
+                          "type": "boolean",
+                          "default": "`false`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`files` {string[]|Buffer[]|fs.Dirent[]}",
+                          "name": "files",
+                          "type": "string[]|Buffer[]|fs.Dirent[]"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Reads the contents of a directory. The callback gets two arguments <code>(err, files)</code>\nwhere <code>files</code> is an array of the names of the files in the directory excluding\n<code>'.'</code> and <code>'..'</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> documentation for more details.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe filenames returned will be passed as <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the <code>files</code> array will contain\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> objects.</p>"
             },
             {
-              "textRaw": "`mtime` {Date}",
-              "type": "Date",
-              "name": "mtime",
+              "textRaw": "`fs.readFile(path[, options], callback)`",
+              "type": "method",
+              "name": "readFile",
               "meta": {
                 "added": [
-                  "v0.11.13"
+                  "v0.1.29"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35911",
+                    "description": "The options argument may include an AbortSignal to abort an ongoing readFile request."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v5.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3740",
+                    "description": "The `callback` will always be called with `null` as the `error` parameter in case of success."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `path` parameter can be a file descriptor now."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the last time this file was modified.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL|integer} filename or file descriptor",
+                      "name": "path",
+                      "type": "string|Buffer|URL|integer",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `null`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'r'`",
+                          "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting an in-progress readFile",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting an in-progress readFile"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`data` {string|Buffer}",
+                          "name": "data",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs';\n\nreadFile('/etc/passwd', (err, data) => {\n  if (err) throw err;\n  console.log(data);\n});\n</code></pre>\n<p>The callback is passed two arguments <code>(err, data)</code>, where <code>data</code> is the\ncontents of the file.</p>\n<p>If no encoding is specified, then the raw buffer is returned.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs';\n\nreadFile('/etc/passwd', 'utf8', callback);\n</code></pre>\n<p>When the path is a directory, the behavior of <code>fs.readFile()</code> and\n<a href=\"#fs_fs_readfilesync_path_options\"><code>fs.readFileSync()</code></a> is platform-specific. On macOS, Linux, and Windows, an\nerror will be returned. On FreeBSD, a representation of the directory's contents\nwill be returned.</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs';\n\n// macOS, Linux, and Windows\nreadFile('&#x3C;directory>', (err, data) => {\n  // => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]\n});\n\n//  FreeBSD\nreadFile('&#x3C;directory>', (err, data) => {\n  // => null, &#x3C;data>\n});\n</code></pre>\n<p>It is possible to abort an ongoing request using an <code>AbortSignal</code>. If a\nrequest is aborted the callback is called with an <code>AbortError</code>:</p>\n<pre><code class=\"language-mjs\">import { readFile } from 'fs';\n\nconst controller = new AbortController();\nconst signal = controller.signal;\nreadFile(fileInfo[0].name, { signal }, (err, buf) => {\n  // ...\n});\n// When you want to abort the request\ncontroller.abort();\n</code></pre>\n<p>The <code>fs.readFile()</code> function buffers the entire file. To minimize memory costs,\nwhen possible prefer streaming via <code>fs.createReadStream()</code>.</p>\n<p>Aborting an ongoing request does not abort individual operating\nsystem requests but rather the internal buffering <code>fs.readFile</code> performs.</p>",
+              "modules": [
+                {
+                  "textRaw": "File descriptors",
+                  "name": "file_descriptors",
+                  "desc": "<ol>\n<li>Any specified file descriptor has to support reading.</li>\n<li>If a file descriptor is specified as the <code>path</code>, it will not be closed\nautomatically.</li>\n<li>The reading will begin at the current position. For example, if the file\nalready had <code>'Hello World</code>' and six bytes are read with the file descriptor,\nthe call to <code>fs.readFile()</code> with the same file descriptor, would give\n<code>'World'</code>, rather than <code>'Hello World'</code>.</li>\n</ol>",
+                  "type": "module",
+                  "displayName": "File descriptors"
+                },
+                {
+                  "textRaw": "Performance Considerations",
+                  "name": "performance_considerations",
+                  "desc": "<p>The <code>fs.readFile()</code> method asynchronously reads the contents of a file into\nmemory one chunk at a time, allowing the event loop to turn between each chunk.\nThis allows the read operation to have less impact on other activity that may\nbe using the underlying libuv thread pool but means that it will take longer\nto read a complete file into memory.</p>\n<p>The additional read overhead can vary broadly on different systems and depends\non the type of file being read. If the file type is not a regular file (a pipe\nfor instance) and Node.js is unable to determine an actual file size, each read\noperation will load on 64kb of data. For regular files, each read will process\n512kb of data.</p>\n<p>For applications that require as-fast-as-possible reading of file contents, it\nis better to use <code>fs.read()</code> directly and for application code to manage\nreading the full contents of the file itself.</p>\n<p>The Node.js GitHub issue <a href=\"https://github.com/nodejs/node/issues/25741\">#25741</a> provides more information and a detailed\nanalysis on the performance of <code>fs.readFile()</code> for multiple file sizes in\ndifferent Node.js versions.</p>",
+                  "type": "module",
+                  "displayName": "Performance Considerations"
+                }
+              ]
             },
             {
-              "textRaw": "`ctime` {Date}",
-              "type": "Date",
-              "name": "ctime",
+              "textRaw": "`fs.readlink(path[, options], callback)`",
+              "type": "method",
+              "name": "readlink",
               "meta": {
                 "added": [
-                  "v0.11.13"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "desc": "<p>The timestamp indicating the last time the file status was changed.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`linkString` {string|Buffer}",
+                          "name": "linkString",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Reads the contents of the symbolic link referred to by <code>path</code>. The callback gets\ntwo arguments <code>(err, linkString)</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a> documentation for more details.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe link path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>"
             },
             {
-              "textRaw": "`birthtime` {Date}",
-              "type": "Date",
-              "name": "birthtime",
+              "textRaw": "`fs.readv(fd, buffers[, position], callback)`",
+              "type": "method",
+              "name": "readv",
               "meta": {
                 "added": [
-                  "v0.11.13"
+                  "v13.13.0",
+                  "v12.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The timestamp indicating the creation time of this file.</p>"
-            }
-          ],
-          "modules": [
-            {
-              "textRaw": "Stat time values",
-              "name": "stat_time_values",
-              "desc": "<p>The <code>atimeMs</code>, <code>mtimeMs</code>, <code>ctimeMs</code>, <code>birthtimeMs</code> properties are\nnumeric values that hold the corresponding times in milliseconds. Their\nprecision is platform specific. When <code>bigint: true</code> is passed into the\nmethod that generates the object, the properties will be <a href=\"https://tc39.github.io/proposal-bigint\">bigints</a>,\notherwise they will be <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\">numbers</a>.</p>\n<p>The <code>atimeNs</code>, <code>mtimeNs</code>, <code>ctimeNs</code>, <code>birthtimeNs</code> properties are\n<a href=\"https://tc39.github.io/proposal-bigint\">bigints</a> that hold the corresponding times in nanoseconds. They are\nonly present when <code>bigint: true</code> is passed into the method that generates\nthe object. Their precision is platform specific.</p>\n<p><code>atime</code>, <code>mtime</code>, <code>ctime</code>, and <code>birthtime</code> are\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date\"><code>Date</code></a> object alternate representations of the various times. The\n<code>Date</code> and number values are not connected. Assigning a new number value, or\nmutating the <code>Date</code> value, will not be reflected in the corresponding alternate\nrepresentation.</p>\n<p>The times in the stat object have the following semantics:</p>\n<ul>\n<li><code>atime</code> \"Access Time\": Time when file data last accessed. Changed\nby the <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/read.2.html\"><code>read(2)</code></a> system calls.</li>\n<li><code>mtime</code> \"Modified Time\": Time when file data last modified.\nChanged by the <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/write.2.html\"><code>write(2)</code></a> system calls.</li>\n<li><code>ctime</code> \"Change Time\": Time when file status was last changed\n(inode data modification). Changed by the <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>,\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>,\n<a href=\"http://man7.org/linux/man-pages/man2/read.2.html\"><code>read(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/write.2.html\"><code>write(2)</code></a> system calls.</li>\n<li><code>birthtime</code> \"Birth Time\": Time of file creation. Set once when the\nfile is created. On filesystems where birthtime is not available,\nthis field may instead hold either the <code>ctime</code> or\n<code>1970-01-01T00:00Z</code> (ie, Unix epoch timestamp <code>0</code>). This value may be greater\nthan <code>atime</code> or <code>mtime</code> in this case. On Darwin and other FreeBSD variants,\nalso set if the <code>atime</code> is explicitly set to an earlier value than the current\n<code>birthtime</code> using the <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a> system call.</li>\n</ul>\n<p>Prior to Node.js 0.12, the <code>ctime</code> held the <code>birthtime</code> on Windows systems. As\nof 0.12, <code>ctime</code> is not \"creation time\", and on Unix systems, it never was.</p>",
-              "type": "module",
-              "displayName": "Stat time values"
-            }
-          ]
-        },
-        {
-          "textRaw": "Class: `fs.WriteStream`",
-          "type": "class",
-          "name": "fs.WriteStream",
-          "meta": {
-            "added": [
-              "v0.1.93"
-            ],
-            "changes": []
-          },
-          "desc": "<ul>\n<li>Extends <a href=\"stream.html#stream_class_stream_writable\" class=\"type\">&lt;stream.Writable&gt;</a></li>\n</ul>\n<p>Instances of <code>fs.WriteStream</code> are created and returned using the\n<a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> function.</p>",
-          "events": [
-            {
-              "textRaw": "Event: `'close'`",
-              "type": "event",
-              "name": "close",
-              "meta": {
-                "added": [
-                  "v0.1.93"
-                ],
-                "changes": []
-              },
-              "params": [],
-              "desc": "<p>Emitted when the <code>WriteStream</code>'s underlying file descriptor has been closed.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffers` {ArrayBufferView[]}",
+                      "name": "buffers",
+                      "type": "ArrayBufferView[]"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesRead` {integer}",
+                          "name": "bytesRead",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffers` {ArrayBufferView[]}",
+                          "name": "buffers",
+                          "type": "ArrayBufferView[]"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Read from a file specified by <code>fd</code> and write to an array of <code>ArrayBufferView</code>s\nusing <code>readv()</code>.</p>\n<p><code>position</code> is the offset from the beginning of the file from where data\nshould be read. If <code>typeof position !== 'number'</code>, the data will be read\nfrom the current position.</p>\n<p>The callback will be given three arguments: <code>err</code>, <code>bytesRead</code>, and\n<code>buffers</code>. <code>bytesRead</code> is how many bytes were read from the file.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na promise for an <code>Object</code> with <code>bytesRead</code> and <code>buffers</code> properties.</p>"
             },
             {
-              "textRaw": "Event: `'open'`",
-              "type": "event",
-              "name": "open",
+              "textRaw": "`fs.realpath(path[, options], callback)`",
+              "type": "method",
+              "name": "realpath",
               "meta": {
                 "added": [
-                  "v0.1.93"
+                  "v0.1.31"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/13028",
+                    "description": "Pipe/Socket resolve support was added."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v6.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7899",
+                    "description": "Calling `realpath` now works again for various edge cases on Windows."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3594",
+                    "description": "The `cache` parameter was removed."
+                  }
+                ]
               },
-              "params": [
+              "signatures": [
                 {
-                  "textRaw": "`fd` {integer} Integer file descriptor used by the `WriteStream`.",
-                  "name": "fd",
-                  "type": "integer",
-                  "desc": "Integer file descriptor used by the `WriteStream`."
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`resolvedPath` {string|Buffer}",
+                          "name": "resolvedPath",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
                 }
               ],
-              "desc": "<p>Emitted when the <code>WriteStream</code>'s file is opened.</p>"
+              "desc": "<p>Asynchronously computes the canonical pathname by resolving <code>.</code>, <code>..</code> and\nsymbolic links.</p>\n<p>A canonical pathname is not necessarily unique. Hard links and bind mounts can\nexpose a file system entity through many pathnames.</p>\n<p>This function behaves like <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>, with some exceptions:</p>\n<ol>\n<li>\n<p>No case conversion is performed on case-insensitive file systems.</p>\n</li>\n<li>\n<p>The maximum number of symbolic links is platform-independent and generally\n(much) higher than what the native <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a> implementation supports.</p>\n</li>\n</ol>\n<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>. May use <code>process.cwd</code>\nto resolve relative paths.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>\n<p>If <code>path</code> resolves to a socket or a pipe, the function will return a system\ndependent name for that object.</p>"
             },
             {
-              "textRaw": "Event: `'ready'`",
-              "type": "event",
-              "name": "ready",
+              "textRaw": "`fs.realpath.native(path[, options], callback)`",
+              "type": "method",
+              "name": "native",
               "meta": {
                 "added": [
-                  "v9.11.0"
+                  "v9.2.0"
                 ],
                 "changes": []
               },
-              "params": [],
-              "desc": "<p>Emitted when the <code>fs.WriteStream</code> is ready to be used.</p>\n<p>Fires immediately after <code>'open'</code>.</p>"
-            }
-          ],
-          "properties": [
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`resolvedPath` {string|Buffer}",
+                          "name": "resolvedPath",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>.</p>\n<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
+            },
             {
-              "textRaw": "`writeStream.bytesWritten`",
-              "name": "bytesWritten",
+              "textRaw": "`fs.rename(oldPath, newPath, callback)`",
+              "type": "method",
+              "name": "rename",
               "meta": {
                 "added": [
-                  "v0.4.7"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `oldPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "desc": "<p>The number of bytes written so far. Does not include data that is still queued\nfor writing.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`oldPath` {string|Buffer|URL}",
+                      "name": "oldPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`newPath` {string|Buffer|URL}",
+                      "name": "newPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously rename file at <code>oldPath</code> to the pathname provided\nas <code>newPath</code>. In the case that <code>newPath</code> already exists, it will\nbe overwritten. If there is a directory at <code>newPath</code>, an error will\nbe raised instead. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>.</p>\n<pre><code class=\"language-mjs\">import { rename } from 'fs';\n\nrename('oldFile.txt', 'newFile.txt', (err) => {\n  if (err) throw err;\n  console.log('Rename complete!');\n});\n</code></pre>"
             },
             {
-              "textRaw": "`writeStream.path`",
-              "name": "path",
+              "textRaw": "`fs.rmdir(path[, options], callback)`",
+              "type": "method",
+              "name": "rmdir",
               "meta": {
                 "added": [
-                  "v0.1.93"
+                  "v0.0.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35579",
+                    "description": "The `recursive` option is deprecated, use `fs.rm` instead."
+                  },
+                  {
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30644",
+                    "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
+                  },
+                  {
+                    "version": "v12.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29168",
+                    "description": "The `recursive`, `maxBusyTries`, and `emfileWait` options are now supported."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameters can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              "desc": "<p>The path to the file the stream is writing to as specified in the first\nargument to <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>. If <code>path</code> is passed as a string, then\n<code>writeStream.path</code> will be a string. If <code>path</code> is passed as a <code>Buffer</code>, then\n<code>writeStream.path</code> will be a <code>Buffer</code>.</p>"
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/rmdir.2.html\"><code>rmdir(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>\n<p>Using <code>fs.rmdir()</code> on a file (not a directory) results in an <code>ENOENT</code> error on\nWindows and an <code>ENOTDIR</code> error on POSIX.</p>\n<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command\n<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths\nthat represent files will be deleted. The permissive behavior of the\n<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in\nthe future.</p>"
             },
             {
-              "textRaw": "`pending` {boolean}",
-              "type": "boolean",
-              "name": "pending",
+              "textRaw": "`fs.rm(path[, options], callback)`",
+              "type": "method",
+              "name": "rm",
               "meta": {
                 "added": [
-                  "v11.2.0"
+                  "v14.14.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>This property is <code>true</code> if the underlying file has not been opened yet,\ni.e. before the <code>'ready'</code> event is emitted.</p>"
-            }
-          ]
-        }
-      ],
-      "methods": [
-        {
-          "textRaw": "`fs.access(path[, mode], callback)`",
-          "type": "method",
-          "name": "access",
-          "meta": {
-            "added": [
-              "v0.11.15"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v6.3.0",
-                "pr-url": "https://github.com/nodejs/node/pull/6534",
-                "description": "The constants like `fs.R_OK`, etc which were present directly on `fs` were moved into `fs.constants` as a soft deprecation. Thus for Node.js `< v6.3.0` use `fs` to access those constants, or do something like `(fs.constants || fs).R_OK` to work with all versions."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {integer} **Default:** `fs.constants.F_OK`",
-                  "name": "mode",
-                  "type": "integer",
-                  "default": "`fs.constants.F_OK`"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`force` {boolean} When `true`, exceptions will be ignored if `path` does not exist. **Default:** `false`.",
+                          "name": "force",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "When `true`, exceptions will be ignored if `path` does not exist."
+                        },
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive removal. In recursive mode operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive removal. In recursive mode operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Tests a user's permissions for the file or directory specified by <code>path</code>.\nThe <code>mode</code> argument is an optional integer that specifies the accessibility\nchecks to be performed. Check <a href=\"#fs_file_access_constants\">File access constants</a> for possible values\nof <code>mode</code>. It is possible to create a mask consisting of the bitwise OR of\ntwo or more values (e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>The final argument, <code>callback</code>, is a callback function that is invoked with\na possible error argument. If any of the accessibility checks fail, the error\nargument will be an <code>Error</code> object. The following examples check if\n<code>package.json</code> exists, and if it is readable or writable.</p>\n<pre><code class=\"language-js\">const file = 'package.json';\n\n// Check if the file exists in the current directory.\nfs.access(file, fs.constants.F_OK, (err) => {\n  console.log(`${file} ${err ? 'does not exist' : 'exists'}`);\n});\n\n// Check if the file is readable.\nfs.access(file, fs.constants.R_OK, (err) => {\n  console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);\n});\n\n// Check if the file is writable.\nfs.access(file, fs.constants.W_OK, (err) => {\n  console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);\n});\n\n// Check if the file exists in the current directory, and if it is writable.\nfs.access(file, fs.constants.F_OK | fs.constants.W_OK, (err) => {\n  if (err) {\n    console.error(\n      `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`);\n  } else {\n    console.log(`${file} exists, and it is writable`);\n  }\n});\n</code></pre>\n<p>Do not use <code>fs.access()</code> to check for the accessibility of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code>. Doing\nso introduces a race condition, since other processes may change the file's\nstate between the two calls. Instead, user code should open/read/write the\nfile directly and handle the error raised if the file is not accessible.</p>\n<p><strong>write (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.access('myfile', (err) => {\n  if (!err) {\n    console.error('myfile already exists');\n    return;\n  }\n\n  fs.open('myfile', 'wx', (err, fd) => {\n    if (err) throw err;\n    writeMyData(fd);\n  });\n});\n</code></pre>\n<p><strong>write (RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.open('myfile', 'wx', (err, fd) => {\n  if (err) {\n    if (err.code === 'EEXIST') {\n      console.error('myfile already exists');\n      return;\n    }\n\n    throw err;\n  }\n\n  writeMyData(fd);\n});\n</code></pre>\n<p><strong>read (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.access('myfile', (err) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  fs.open('myfile', 'r', (err, fd) => {\n    if (err) throw err;\n    readMyData(fd);\n  });\n});\n</code></pre>\n<p><strong>read (RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.open('myfile', 'r', (err, fd) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  readMyData(fd);\n});\n</code></pre>\n<p>The \"not recommended\" examples above check for accessibility and then use the\nfile; the \"recommended\" examples are better because they use the file directly\nand handle the error, if any.</p>\n<p>In general, check for the accessibility of a file only if the file will not be\nused directly, for example when its accessibility is a signal from another\nprocess.</p>\n<p>On Windows, access-control policies (ACLs) on a directory may limit access to\na file or directory. The <code>fs.access()</code> function, however, does not check the\nACL and therefore may report that a path is accessible even if the ACL restricts\nthe user from reading or writing to it.</p>"
-        },
-        {
-          "textRaw": "`fs.accessSync(path[, mode])`",
-          "type": "method",
-          "name": "accessSync",
-          "meta": {
-            "added": [
-              "v0.11.15"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Asynchronously removes files and directories (modeled on the standard POSIX <code>rm</code>\nutility). No arguments other than a possible exception are given to the\ncompletion callback.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {integer} **Default:** `fs.constants.F_OK`",
-                  "name": "mode",
-                  "type": "integer",
-                  "default": "`fs.constants.F_OK`"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously tests a user's permissions for the file or directory specified\nby <code>path</code>. The <code>mode</code> argument is an optional integer that specifies the\naccessibility checks to be performed. Check <a href=\"#fs_file_access_constants\">File access constants</a> for\npossible values of <code>mode</code>. It is possible to create a mask consisting of\nthe bitwise OR of two or more values\n(e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>If any of the accessibility checks fail, an <code>Error</code> will be thrown. Otherwise,\nthe method will return <code>undefined</code>.</p>\n<pre><code class=\"language-js\">try {\n  fs.accessSync('etc/passwd', fs.constants.R_OK | fs.constants.W_OK);\n  console.log('can read/write');\n} catch (err) {\n  console.error('no access!');\n}\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.appendFile(path, data[, options], callback)`",
-          "type": "method",
-          "name": "appendFile",
-          "meta": {
-            "added": [
-              "v0.6.7"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
+              "textRaw": "`fs.stat(path[, options], callback)`",
+              "type": "method",
+              "name": "stat",
+              "meta": {
+                "added": [
+                  "v0.0.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `file` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL|number} filename or file descriptor",
-                  "name": "path",
-                  "type": "string|Buffer|URL|number",
-                  "desc": "filename or file descriptor"
-                },
-                {
-                  "textRaw": "`data` {string|Buffer}",
-                  "name": "data",
-                  "type": "string|Buffer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        }
+                      ]
                     },
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'a'`",
-                      "desc": "See [support of file system `flags`][]."
-                    }
-                  ]
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`stats` {fs.Stats}",
+                          "name": "stats",
+                          "type": "fs.Stats"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>.</p>\n<pre><code class=\"language-js\">fs.appendFile('message.txt', 'data to append', (err) => {\n  if (err) throw err;\n  console.log('The \"data to append\" was appended to file!');\n});\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-js\">fs.appendFile('message.txt', 'data to append', 'utf8', callback);\n</code></pre>\n<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened\nfor appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will\nnot be closed automatically.</p>\n<pre><code class=\"language-js\">fs.open('message.txt', 'a', (err, fd) => {\n  if (err) throw err;\n  fs.appendFile(fd, 'data to append', 'utf8', (err) => {\n    fs.close(fd, (err) => {\n      if (err) throw err;\n    });\n    if (err) throw err;\n  });\n});\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.appendFileSync(path, data[, options])`",
-          "type": "method",
-          "name": "appendFileSync",
-          "meta": {
-            "added": [
-              "v0.6.7"
-            ],
-            "changes": [
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
-              },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `file` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/stat.2.html\"><code>stat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where\n<code>stats</code> is an <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object.</p>\n<p>In case of an error, the <code>err.code</code> will be one of <a href=\"errors.html#errors_common_system_errors\">Common System Errors</a>.</p>\n<p>Using <code>fs.stat()</code> to check for the existence of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended.\nInstead, user code should open/read/write the file directly and handle the\nerror raised if the file is not available.</p>\n<p>To check if a file exists without manipulating it afterwards, <a href=\"#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a>\nis recommended.</p>\n<p>For example, given the following directory structure:</p>\n<pre><code class=\"language-text\">- txtDir\n-- file.txt\n- app.js\n</code></pre>\n<p>The next program will check for the stats of the given paths:</p>\n<pre><code class=\"language-mjs\">import { stat } from 'fs';\n\nconst pathsToCheck = ['./txtDir', './txtDir/file.txt'];\n\nfor (let i = 0; i &#x3C; pathsToCheck.length; i++) {\n  stat(pathsToCheck[i], (err, stats) => {\n    console.log(stats.isDirectory());\n    console.log(stats);\n  });\n}\n</code></pre>\n<p>The resulting output will resemble:</p>\n<pre><code class=\"language-console\">true\nStats {\n  dev: 16777220,\n  mode: 16877,\n  nlink: 3,\n  uid: 501,\n  gid: 20,\n  rdev: 0,\n  blksize: 4096,\n  ino: 14214262,\n  size: 96,\n  blocks: 0,\n  atimeMs: 1561174653071.963,\n  mtimeMs: 1561174614583.3518,\n  ctimeMs: 1561174626623.5366,\n  birthtimeMs: 1561174126937.2893,\n  atime: 2019-06-22T03:37:33.072Z,\n  mtime: 2019-06-22T03:36:54.583Z,\n  ctime: 2019-06-22T03:37:06.624Z,\n  birthtime: 2019-06-22T03:28:46.937Z\n}\nfalse\nStats {\n  dev: 16777220,\n  mode: 33188,\n  nlink: 1,\n  uid: 501,\n  gid: 20,\n  rdev: 0,\n  blksize: 4096,\n  ino: 14214074,\n  size: 8,\n  blocks: 8,\n  atimeMs: 1561174616618.8555,\n  mtimeMs: 1561174614584,\n  ctimeMs: 1561174614583.8145,\n  birthtimeMs: 1561174007710.7478,\n  atime: 2019-06-22T03:36:56.619Z,\n  mtime: 2019-06-22T03:36:54.584Z,\n  ctime: 2019-06-22T03:36:54.584Z,\n  birthtime: 2019-06-22T03:26:47.711Z\n}\n</code></pre>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL|number} filename or file descriptor",
-                  "name": "path",
-                  "type": "string|Buffer|URL|number",
-                  "desc": "filename or file descriptor"
-                },
-                {
-                  "textRaw": "`data` {string|Buffer}",
-                  "name": "data",
-                  "type": "string|Buffer"
-                },
+              "textRaw": "`fs.symlink(target, path[, type], callback)`",
+              "type": "method",
+              "name": "symlink",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v12.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23724",
+                    "description": "If the `type` argument is left undefined, Node will autodetect `target` type and automatically select `dir` or `file`."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `target` and `path` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
+                      "textRaw": "`target` {string|Buffer|URL}",
+                      "name": "target",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'a'`",
-                      "desc": "See [support of file system `flags`][]."
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>.</p>\n<pre><code class=\"language-js\">try {\n  fs.appendFileSync('message.txt', 'data to append');\n  console.log('The \"data to append\" was appended to file!');\n} catch (err) {\n  /* Handle the error */\n}\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-js\">fs.appendFileSync('message.txt', 'data to append', 'utf8');\n</code></pre>\n<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened\nfor appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will\nnot be closed automatically.</p>\n<pre><code class=\"language-js\">let fd;\n\ntry {\n  fd = fs.openSync('message.txt', 'a');\n  fs.appendFileSync(fd, 'data to append', 'utf8');\n} catch (err) {\n  /* Handle the error */\n} finally {\n  if (fd !== undefined)\n    fs.closeSync(fd);\n}\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.chmod(path, mode, callback)`",
-          "type": "method",
-          "name": "chmod",
-          "meta": {
-            "added": [
-              "v0.1.30"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {string|integer}",
-                  "name": "mode",
-                  "type": "string|integer"
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                      "textRaw": "`type` {string}",
+                      "name": "type",
+                      "type": "string"
+                    },
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously changes the permissions of a file. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>.</p>\n<pre><code class=\"language-js\">fs.chmod('my_file.txt', 0o775, (err) => {\n  if (err) throw err;\n  console.log('The permissions for file \"my_file.txt\" have been changed!');\n});\n</code></pre>",
-          "modules": [
-            {
-              "textRaw": "File modes",
-              "name": "file_modes",
-              "desc": "<p>The <code>mode</code> argument used in both the <code>fs.chmod()</code> and <code>fs.chmodSync()</code>\nmethods is a numeric bitmask created using a logical OR of the following\nconstants:</p>\n<table>\n<thead>\n<tr>\n<th>Constant</th>\n<th>Octal</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>fs.constants.S_IRUSR</code></td>\n<td><code>0o400</code></td>\n<td>read by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWUSR</code></td>\n<td><code>0o200</code></td>\n<td>write by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXUSR</code></td>\n<td><code>0o100</code></td>\n<td>execute/search by owner</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IRGRP</code></td>\n<td><code>0o40</code></td>\n<td>read by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWGRP</code></td>\n<td><code>0o20</code></td>\n<td>write by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXGRP</code></td>\n<td><code>0o10</code></td>\n<td>execute/search by group</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IROTH</code></td>\n<td><code>0o4</code></td>\n<td>read by others</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IWOTH</code></td>\n<td><code>0o2</code></td>\n<td>write by others</td>\n</tr>\n<tr>\n<td><code>fs.constants.S_IXOTH</code></td>\n<td><code>0o1</code></td>\n<td>execute/search by others</td>\n</tr>\n</tbody>\n</table>\n<p>An easier method of constructing the <code>mode</code> is to use a sequence of three\noctal digits (e.g. <code>765</code>). The left-most digit (<code>7</code> in the example), specifies\nthe permissions for the file owner. The middle digit (<code>6</code> in the example),\nspecifies permissions for the group. The right-most digit (<code>5</code> in the example),\nspecifies the permissions for others.</p>\n<table>\n<thead>\n<tr>\n<th>Number</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>7</code></td>\n<td>read, write, and execute</td>\n</tr>\n<tr>\n<td><code>6</code></td>\n<td>read and write</td>\n</tr>\n<tr>\n<td><code>5</code></td>\n<td>read and execute</td>\n</tr>\n<tr>\n<td><code>4</code></td>\n<td>read only</td>\n</tr>\n<tr>\n<td><code>3</code></td>\n<td>write and execute</td>\n</tr>\n<tr>\n<td><code>2</code></td>\n<td>write only</td>\n</tr>\n<tr>\n<td><code>1</code></td>\n<td>execute only</td>\n</tr>\n<tr>\n<td><code>0</code></td>\n<td>no permission</td>\n</tr>\n</tbody>\n</table>\n<p>For example, the octal value <code>0o765</code> means:</p>\n<ul>\n<li>The owner may read, write and execute the file.</li>\n<li>The group may read and write the file.</li>\n<li>Others may read and execute the file.</li>\n</ul>\n<p>When using raw numbers where file modes are expected, any value larger than\n<code>0o777</code> may result in platform-specific behaviors that are not supported to work\nconsistently. Therefore constants like <code>S_ISVTX</code>, <code>S_ISGID</code> or <code>S_ISUID</code> are not\nexposed in <code>fs.constants</code>.</p>\n<p>Caveats: on Windows only the write permission can be changed, and the\ndistinction among the permissions of group, owner or others is not\nimplemented.</p>",
-              "type": "module",
-              "displayName": "File modes"
-            }
-          ]
-        },
-        {
-          "textRaw": "`fs.chmodSync(path, mode)`",
-          "type": "method",
-          "name": "chmodSync",
-          "meta": {
-            "added": [
-              "v0.6.7"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Creates the link called <code>path</code> pointing to <code>target</code>. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/symlink.2.html\"><code>symlink(2)</code></a> documentation for more details.</p>\n<p>The <code>type</code> argument is only available on Windows and ignored on other platforms.\nIt can be set to <code>'dir'</code>, <code>'file'</code>, or <code>'junction'</code>. If the <code>type</code> argument is\nnot set, Node.js will autodetect <code>target</code> type and use <code>'file'</code> or <code>'dir'</code>. If\nthe <code>target</code> does not exist, <code>'file'</code> will be used. Windows junction points\nrequire the destination path to be absolute. When using <code>'junction'</code>, the\n<code>target</code> argument will automatically be normalized to absolute path.</p>\n<p>Relative targets are relative to the link’s parent directory.</p>\n<pre><code class=\"language-mjs\">import { symlink } from 'fs';\n\nsymlink('./mew', './example/mewtwo', callback);\n</code></pre>\n<p>The above example creates a symbolic link <code>mewtwo</code> in the <code>example</code> which points\nto <code>mew</code> in the same directory:</p>\n<pre><code class=\"language-bash\">$ tree example/\nexample/\n├── mew\n└── mewtwo -> ./mew\n</code></pre>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {string|integer}",
-                  "name": "mode",
-                  "type": "string|integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_chmod_path_mode_callback\"><code>fs.chmod()</code></a>.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.chown(path, uid, gid, callback)`",
-          "type": "method",
-          "name": "chown",
-          "meta": {
-            "added": [
-              "v0.1.97"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
+              "textRaw": "`fs.truncate(path[, len], callback)`",
+              "type": "method",
+              "name": "truncate",
+              "meta": {
+                "added": [
+                  "v0.8.6"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`len` {integer} **Default:** `0`",
+                      "name": "len",
+                      "type": "integer",
+                      "default": "`0`"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously changes owner and group of a file. No arguments other than a\npossible exception are given to the completion callback.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.chownSync(path, uid, gid)`",
-          "type": "method",
-          "name": "chownSync",
-          "meta": {
-            "added": [
-              "v0.1.97"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Truncates the file. No arguments other than a possible exception are\ngiven to the completion callback. A file descriptor can also be passed as the\nfirst argument. In this case, <code>fs.ftruncate()</code> is called.</p>\n<pre><code class=\"language-mjs\">import { truncate } from 'fs';\n// Assuming that 'path/file.txt' is a regular file.\ntruncate('path/file.txt', (err) => {\n  if (err) throw err;\n  console.log('path/file.txt was truncated');\n});\n</code></pre>\n<pre><code class=\"language-cjs\">const { truncate } = require('fs');\n// Assuming that 'path/file.txt' is a regular file.\ntruncate('path/file.txt', (err) => {\n  if (err) throw err;\n  console.log('path/file.txt was truncated');\n});\n</code></pre>\n<p>Passing a file descriptor is deprecated and may result in an error being thrown\nin the future.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/truncate.2.html\"><code>truncate(2)</code></a> documentation for more details.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously changes owner and group of a file. Returns <code>undefined</code>.\nThis is the synchronous version of <a href=\"#fs_fs_chown_path_uid_gid_callback\"><code>fs.chown()</code></a>.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.close(fd, callback)`",
-          "type": "method",
-          "name": "close",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+              "textRaw": "`fs.unlink(path, callback)`",
+              "type": "method",
+              "name": "unlink",
+              "meta": {
+                "added": [
+                  "v0.0.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/close.2.html\"><code>close(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>\n<p>Calling <code>fs.close()</code> on any file descriptor (<code>fd</code>) that is currently in use\nthrough any other <code>fs</code> operation may lead to undefined behavior.</p>"
-        },
-        {
-          "textRaw": "`fs.closeSync(fd)`",
-          "type": "method",
-          "name": "closeSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/close.2.html\"><code>close(2)</code></a>. Returns <code>undefined</code>.</p>\n<p>Calling <code>fs.closeSync()</code> on any file descriptor (<code>fd</code>) that is currently in use\nthrough any other <code>fs</code> operation may lead to undefined behavior.</p>"
-        },
-        {
-          "textRaw": "`fs.copyFile(src, dest[, flags], callback)`",
-          "type": "method",
-          "name": "copyFile",
-          "meta": {
-            "added": [
-              "v8.5.0"
-            ],
-            "changes": [
-              {
-                "version": "v14.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/27044",
-                "description": "Changed 'flags' argument to 'mode' and imposed stricter type validation."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`src` {string|Buffer|URL} source filename to copy",
-                  "name": "src",
-                  "type": "string|Buffer|URL",
-                  "desc": "source filename to copy"
-                },
-                {
-                  "textRaw": "`dest` {string|Buffer|URL} destination filename of the copy operation",
-                  "name": "dest",
-                  "type": "string|Buffer|URL",
-                  "desc": "destination filename of the copy operation"
-                },
-                {
-                  "textRaw": "`flags` {number} modifiers for copy operation. **Default:** `0`.",
-                  "name": "flags",
-                  "type": "number",
-                  "default": "`0`",
-                  "desc": "modifiers for copy operation."
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. No arguments other than a possible exception are given to the\ncallback function. Node.js makes no guarantees about the atomicity of the copy\noperation. If an error occurs after the destination file has been opened for\nwriting, Node.js will attempt to remove the destination.</p>\n<p><code>flags</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support copy-on-write,\nthen the operation will fail.</li>\n</ul>\n<pre><code class=\"language-js\">const fs = require('fs');\n\n// destination.txt will be created or overwritten by default.\nfs.copyFile('source.txt', 'destination.txt', (err) => {\n  if (err) throw err;\n  console.log('source.txt was copied to destination.txt');\n});\n</code></pre>\n<p>If the third argument is a number, then it specifies <code>flags</code>:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst { COPYFILE_EXCL } = fs.constants;\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\nfs.copyFile('source.txt', 'destination.txt', COPYFILE_EXCL, callback);\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.copyFileSync(src, dest[, flags])`",
-          "type": "method",
-          "name": "copyFileSync",
-          "meta": {
-            "added": [
-              "v8.5.0"
-            ],
-            "changes": [
-              {
-                "version": "v14.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/27044",
-                "description": "Changed 'flags' argument to 'mode' and imposed stricter type validation."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`src` {string|Buffer|URL} source filename to copy",
-                  "name": "src",
-                  "type": "string|Buffer|URL",
-                  "desc": "source filename to copy"
-                },
-                {
-                  "textRaw": "`dest` {string|Buffer|URL} destination filename of the copy operation",
-                  "name": "dest",
-                  "type": "string|Buffer|URL",
-                  "desc": "destination filename of the copy operation"
-                },
-                {
-                  "textRaw": "`flags` {number} modifiers for copy operation. **Default:** `0`.",
-                  "name": "flags",
-                  "type": "number",
-                  "default": "`0`",
-                  "desc": "modifiers for copy operation."
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. Returns <code>undefined</code>. Node.js makes no guarantees about the\natomicity of the copy operation. If an error occurs after the destination file\nhas been opened for writing, Node.js will attempt to remove the destination.</p>\n<p><code>flags</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support copy-on-write,\nthen the operation will fail.</li>\n</ul>\n<pre><code class=\"language-js\">const fs = require('fs');\n\n// destination.txt will be created or overwritten by default.\nfs.copyFileSync('source.txt', 'destination.txt');\nconsole.log('source.txt was copied to destination.txt');\n</code></pre>\n<p>If the third argument is a number, then it specifies <code>flags</code>:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst { COPYFILE_EXCL } = fs.constants;\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\nfs.copyFileSync('source.txt', 'destination.txt', COPYFILE_EXCL);\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.createReadStream(path[, options])`",
-          "type": "method",
-          "name": "createReadStream",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v12.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29212",
-                "description": "Enable `emitClose` option."
-              },
-              {
-                "version": "v11.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/19898",
-                "description": "Impose new restrictions on `start` and `end`, throwing more appropriate errors in cases when we cannot reasonably handle the input values."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
-              },
-              {
-                "version": "v2.3.0",
-                "pr-url": "https://github.com/nodejs/node/pull/1845",
-                "description": "The passed `options` object can be a string now."
-              },
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29083",
-                "description": "The `fs` options allow overriding the used `fs` implementation."
-              }
-            ]
-          },
-          "signatures": [
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Asynchronously removes a file or symbolic link. No arguments other than a\npossible exception are given to the completion callback.</p>\n<pre><code class=\"language-mjs\">import { unlink } from 'fs';\n// Assuming that 'path/file.txt' is a regular file.\nunlink('path/file.txt', (err) => {\n  if (err) throw err;\n  console.log('path/file.txt was deleted');\n});\n</code></pre>\n<p><code>fs.unlink()</code> will not work on a directory, empty or otherwise. To remove a\ndirectory, use <a href=\"#fs_fs_rmdir_path_options_callback\"><code>fs.rmdir()</code></a>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a> documentation for more details.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.ReadStream} See [Readable Stream][].",
-                "name": "return",
-                "type": "fs.ReadStream",
-                "desc": "See [Readable Stream][]."
+              "textRaw": "`fs.unwatchFile(filename[, listener])`",
+              "type": "method",
+              "name": "unwatchFile",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`flags` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
-                      "name": "flags",
-                      "type": "string",
-                      "default": "`'r'`",
-                      "desc": "See [support of file system `flags`][]."
+                      "textRaw": "`filename` {string|Buffer|URL}",
+                      "name": "filename",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`encoding` {string} **Default:** `null`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`null`"
-                    },
+                      "textRaw": "`listener` {Function} Optional, a listener previously attached using `fs.watchFile()`",
+                      "name": "listener",
+                      "type": "Function",
+                      "desc": "Optional, a listener previously attached using `fs.watchFile()`"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Stop watching for changes on <code>filename</code>. If <code>listener</code> is specified, only that\nparticular listener is removed. Otherwise, <em>all</em> listeners are removed,\neffectively stopping watching of <code>filename</code>.</p>\n<p>Calling <code>fs.unwatchFile()</code> with a filename that is not being watched is a\nno-op, not an error.</p>\n<p>Using <a href=\"#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile()</code> and\n<code>fs.unwatchFile()</code>. <code>fs.watch()</code> should be used instead of <code>fs.watchFile()</code>\nand <code>fs.unwatchFile()</code> when possible.</p>"
+            },
+            {
+              "textRaw": "`fs.utimes(path, atime, mtime, callback)`",
+              "type": "method",
+              "name": "utimes",
+              "meta": {
+                "added": [
+                  "v0.4.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/11919",
+                    "description": "`NaN`, `Infinity`, and `-Infinity` are no longer valid time specifiers."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v4.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/2387",
+                    "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "params": [
                     {
-                      "textRaw": "`fd` {integer} **Default:** `null`",
-                      "name": "fd",
-                      "type": "integer",
-                      "default": "`null`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
                     },
                     {
-                      "textRaw": "`autoClose` {boolean} **Default:** `true`",
-                      "name": "autoClose",
-                      "type": "boolean",
-                      "default": "`true`"
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
                     },
                     {
-                      "textRaw": "`emitClose` {boolean} **Default:** `false`",
-                      "name": "emitClose",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>\n<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>\n<ul>\n<li>Values can be either numbers representing Unix epoch time in seconds,\n<code>Date</code>s, or a numeric string like <code>'123456789.0'</code>.</li>\n<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or\n<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>\n</ul>"
+            },
+            {
+              "textRaw": "`fs.watch(filename[, options][, listener])`",
+              "type": "method",
+              "name": "watch",
+              "meta": {
+                "added": [
+                  "v0.5.10"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37190",
+                    "description": "Added support for closing the watcher with an AbortSignal."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `filename` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {fs.FSWatcher}",
+                    "name": "return",
+                    "type": "fs.FSWatcher"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`filename` {string|Buffer|URL}",
+                      "name": "filename",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`start` {integer}",
-                      "name": "start",
-                      "type": "integer"
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`persistent` {boolean} Indicates whether the process should continue to run as long as files are being watched. **Default:** `true`.",
+                          "name": "persistent",
+                          "type": "boolean",
+                          "default": "`true`",
+                          "desc": "Indicates whether the process should continue to run as long as files are being watched."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [caveats][]). **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [caveats][])."
+                        },
+                        {
+                          "textRaw": "`encoding` {string} Specifies the character encoding to be used for the filename passed to the listener. **Default:** `'utf8'`.",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`",
+                          "desc": "Specifies the character encoding to be used for the filename passed to the listener."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows closing the watcher with an AbortSignal.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows closing the watcher with an AbortSignal."
+                        }
+                      ]
                     },
                     {
-                      "textRaw": "`end` {integer} **Default:** `Infinity`",
-                      "name": "end",
-                      "type": "integer",
-                      "default": "`Infinity`"
+                      "textRaw": "`listener` {Function|undefined} **Default:** `undefined`",
+                      "name": "listener",
+                      "type": "Function|undefined",
+                      "default": "`undefined`",
+                      "options": [
+                        {
+                          "textRaw": "`eventType` {string}",
+                          "name": "eventType",
+                          "type": "string"
+                        },
+                        {
+                          "textRaw": "`filename` {string|Buffer}",
+                          "name": "filename",
+                          "type": "string|Buffer"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Watch for changes on <code>filename</code>, where <code>filename</code> is either a file or a\ndirectory.</p>\n<p>The second argument is optional. If <code>options</code> is provided as a string, it\nspecifies the <code>encoding</code>. Otherwise <code>options</code> should be passed as an object.</p>\n<p>The listener callback gets two arguments <code>(eventType, filename)</code>. <code>eventType</code>\nis either <code>'rename'</code> or <code>'change'</code>, and <code>filename</code> is the name of the file\nwhich triggered the event.</p>\n<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or\ndisappears in the directory.</p>\n<p>The listener callback is attached to the <code>'change'</code> event fired by\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a>, but it is not the same thing as the <code>'change'</code> value of\n<code>eventType</code>.</p>\n<p>If a <code>signal</code> is passed, aborting the corresponding AbortController will close\nthe returned <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a>.</p>",
+              "miscs": [
+                {
+                  "textRaw": "Caveats",
+                  "name": "Caveats",
+                  "type": "misc",
+                  "desc": "<p>The <code>fs.watch</code> API is not 100% consistent across platforms, and is\nunavailable in some situations.</p>\n<p>The recursive option is only supported on macOS and Windows.\nAn <code>ERR_FEATURE_UNAVAILABLE_ON_PLATFORM</code> exception will be thrown\nwhen the option is used on a platform that does not support it.</p>\n<p>On Windows, no events will be emitted if the watched directory is moved or\nrenamed. An <code>EPERM</code> error is reported when the watched directory is deleted.</p>",
+                  "miscs": [
+                    {
+                      "textRaw": "Availability",
+                      "name": "Availability",
+                      "type": "misc",
+                      "desc": "<p>This feature depends on the underlying operating system providing a way\nto be notified of filesystem changes.</p>\n<ul>\n<li>On Linux systems, this uses <a href=\"https://man7.org/linux/man-pages/man7/inotify.7.html\"><code>inotify(7)</code></a>.</li>\n<li>On BSD systems, this uses <a href=\"https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2\"><code>kqueue(2)</code></a>.</li>\n<li>On macOS, this uses <a href=\"https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2\"><code>kqueue(2)</code></a> for files and <a href=\"https://developer.apple.com/documentation/coreservices/file_system_events\"><code>FSEvents</code></a> for\ndirectories.</li>\n<li>On SunOS systems (including Solaris and SmartOS), this uses <a href=\"https://illumos.org/man/port_create\"><code>event ports</code></a>.</li>\n<li>On Windows systems, this feature depends on <a href=\"https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw\"><code>ReadDirectoryChangesW</code></a>.</li>\n<li>On AIX systems, this feature depends on <a href=\"https://developer.ibm.com/articles/au-aix_event_infrastructure/\"><code>AHAFS</code></a>, which must be enabled.</li>\n<li>On IBM i systems, this feature is not supported.</li>\n</ul>\n<p>If the underlying functionality is not available for some reason, then\n<code>fs.watch()</code> will not be able to function and may throw an exception.\nFor example, watching files or directories can be unreliable, and in some\ncases impossible, on network file systems (NFS, SMB, etc) or host file systems\nwhen using virtualization software such as Vagrant or Docker.</p>\n<p>It is still possible to use <code>fs.watchFile()</code>, which uses stat polling, but\nthis method is slower and less reliable.</p>"
                     },
                     {
-                      "textRaw": "`highWaterMark` {integer} **Default:** `64 * 1024`",
-                      "name": "highWaterMark",
-                      "type": "integer",
-                      "default": "`64 * 1024`"
+                      "textRaw": "Inodes",
+                      "name": "Inodes",
+                      "type": "misc",
+                      "desc": "<p>On Linux and macOS systems, <code>fs.watch()</code> resolves the path to an <a href=\"https://en.wikipedia.org/wiki/Inode\">inode</a> and\nwatches the inode. If the watched path is deleted and recreated, it is assigned\na new inode. The watch will emit an event for the delete but will continue\nwatching the <em>original</em> inode. Events for the new inode will not be emitted.\nThis is expected behavior.</p>\n<p>AIX files retain the same inode for the lifetime of a file. Saving and closing a\nwatched file on AIX will result in two notifications (one for adding new\ncontent, and one for truncation).</p>"
                     },
                     {
-                      "textRaw": "`fs` {Object|null} **Default:** `null`",
-                      "name": "fs",
-                      "type": "Object|null",
-                      "default": "`null`"
+                      "textRaw": "Filename argument",
+                      "name": "Filename argument",
+                      "type": "misc",
+                      "desc": "<p>Providing <code>filename</code> argument in the callback is only supported on Linux,\nmacOS, Windows, and AIX. Even on supported platforms, <code>filename</code> is not always\nguaranteed to be provided. Therefore, don't assume that <code>filename</code> argument is\nalways provided in the callback, and have some fallback logic if it is <code>null</code>.</p>\n<pre><code class=\"language-mjs\">import { watch } from 'fs';\nwatch('somedir', (eventType, filename) => {\n  console.log(`event type is: ${eventType}`);\n  if (filename) {\n    console.log(`filename provided: ${filename}`);\n  } else {\n    console.log('filename not provided');\n  }\n});\n</code></pre>"
                     }
                   ]
                 }
               ]
-            }
-          ],
-          "desc": "<p>Unlike the 16 kb default <code>highWaterMark</code> for a readable stream, the stream\nreturned by this method has a default <code>highWaterMark</code> of 64 kb.</p>\n<p><code>options</code> can include <code>start</code> and <code>end</code> values to read a range of bytes from\nthe file instead of the entire file. Both <code>start</code> and <code>end</code> are inclusive and\nstart counting at 0, allowed values are in the\n[0, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\"><code>Number.MAX_SAFE_INTEGER</code></a>] range. If <code>fd</code> is specified and <code>start</code> is\nomitted or <code>undefined</code>, <code>fs.createReadStream()</code> reads sequentially from the\ncurrent file position. The <code>encoding</code> can be any one of those accepted by\n<a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>.</p>\n<p>If <code>fd</code> is specified, <code>ReadStream</code> will ignore the <code>path</code> argument and will use\nthe specified file descriptor. This means that no <code>'open'</code> event will be\nemitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s should be passed to\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.</p>\n<p>If <code>fd</code> points to a character device that only supports blocking reads\n(such as keyboard or sound card), read operations do not finish until data is\navailable. This can prevent the process from exiting and the stream from\nclosing naturally.</p>\n<p>By default, the stream will not emit a <code>'close'</code> event after it has been\ndestroyed. This is the opposite of the default for other <code>Readable</code> streams.\nSet the <code>emitClose</code> option to <code>true</code> to change this behavior.</p>\n<p>By providing the <code>fs</code> option, it is possible to override the corresponding <code>fs</code>\nimplementations for <code>open</code>, <code>read</code>, and <code>close</code>. When providing the <code>fs</code> option,\noverrides for <code>open</code>, <code>read</code>, and <code>close</code> are required.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n// Create a stream from some character device.\nconst stream = fs.createReadStream('/dev/input/event0');\nsetTimeout(() => {\n  stream.close(); // This may not close the stream.\n  // Artificially marking end-of-stream, as if the underlying resource had\n  // indicated end-of-file by itself, allows the stream to close.\n  // This does not cancel pending read operations, and if there is such an\n  // operation, the process may still not be able to exit successfully\n  // until it finishes.\n  stream.push(null);\n  stream.read(0);\n}, 100);\n</code></pre>\n<p>If <code>autoClose</code> is false, then the file descriptor won't be closed, even if\nthere's an error. It is the application's responsibility to close it and make\nsure there's no file descriptor leak. If <code>autoClose</code> is set to true (default\nbehavior), on <code>'error'</code> or <code>'end'</code> the file descriptor will be closed\nautomatically.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the\nfile was created.</p>\n<p>An example to read the last 10 bytes of a file which is 100 bytes long:</p>\n<pre><code class=\"language-js\">fs.createReadStream('sample.txt', { start: 90, end: 99 });\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>"
-        },
-        {
-          "textRaw": "`fs.createWriteStream(path[, options])`",
-          "type": "method",
-          "name": "createWriteStream",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v12.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29212",
-                "description": "Enable `emitClose` option."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
-              },
-              {
-                "version": "v5.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3679",
-                "description": "The `autoClose` option is supported now."
-              },
-              {
-                "version": "v2.3.0",
-                "pr-url": "https://github.com/nodejs/node/pull/1845",
-                "description": "The passed `options` object can be a string now."
-              },
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/v12.17.0",
-                "description": "The `fs` options allow overriding the used `fs` implementation."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.WriteStream} See [Writable Stream][].",
-                "name": "return",
-                "type": "fs.WriteStream",
-                "desc": "See [Writable Stream][]."
+              "textRaw": "`fs.watchFile(filename[, options], listener)`",
+              "type": "method",
+              "name": "watchFile",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "The `bigint` option is now supported."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `filename` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "params": [
+              "signatures": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+                  "return": {
+                    "textRaw": "Returns: {fs.StatWatcher}",
+                    "name": "return",
+                    "type": "fs.StatWatcher"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`filename` {string|Buffer|URL}",
+                      "name": "filename",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} **Default:** `false`",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`"
+                        },
+                        {
+                          "textRaw": "`persistent` {boolean} **Default:** `true`",
+                          "name": "persistent",
+                          "type": "boolean",
+                          "default": "`true`"
+                        },
+                        {
+                          "textRaw": "`interval` {integer} **Default:** `5007`",
+                          "name": "interval",
+                          "type": "integer",
+                          "default": "`5007`"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`listener` {Function}",
+                      "name": "listener",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`current` {fs.Stats}",
+                          "name": "current",
+                          "type": "fs.Stats"
+                        },
+                        {
+                          "textRaw": "`previous` {fs.Stats}",
+                          "name": "previous",
+                          "type": "fs.Stats"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Watch for changes on <code>filename</code>. The callback <code>listener</code> will be called each\ntime the file is accessed.</p>\n<p>The <code>options</code> argument may be omitted. If provided, it should be an object. The\n<code>options</code> object may contain a boolean named <code>persistent</code> that indicates\nwhether the process should continue to run as long as files are being watched.\nThe <code>options</code> object may specify an <code>interval</code> property indicating how often the\ntarget should be polled in milliseconds.</p>\n<p>The <code>listener</code> gets two arguments the current stat object and the previous\nstat object:</p>\n<pre><code class=\"language-mjs\">import { watchFile } from 'fs';\n\nwatchFile('message.text', (curr, prev) => {\n  console.log(`the current mtime is: ${curr.mtime}`);\n  console.log(`the previous mtime was: ${prev.mtime}`);\n});\n</code></pre>\n<p>These stat objects are instances of <code>fs.Stat</code>. If the <code>bigint</code> option is <code>true</code>,\nthe numeric values in these objects are specified as <code>BigInt</code>s.</p>\n<p>To be notified when the file was modified, not just accessed, it is necessary\nto compare <code>curr.mtime</code> and <code>prev.mtime</code>.</p>\n<p>When an <code>fs.watchFile</code> operation results in an <code>ENOENT</code> error, it\nwill invoke the listener once, with all the fields zeroed (or, for dates, the\nUnix Epoch). If the file is created later on, the listener will be called\nagain, with the latest stat objects. This is a change in functionality since\nv0.10.</p>\n<p>Using <a href=\"#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile</code> and\n<code>fs.unwatchFile</code>. <code>fs.watch</code> should be used instead of <code>fs.watchFile</code> and\n<code>fs.unwatchFile</code> when possible.</p>\n<p>When a file being watched by <code>fs.watchFile()</code> disappears and reappears,\nthen the contents of <code>previous</code> in the second callback event (the file's\nreappearance) will be the same as the contents of <code>previous</code> in the first\ncallback event (its disappearance).</p>\n<p>This happens when:</p>\n<ul>\n<li>the file is deleted, followed by a restore</li>\n<li>the file is renamed and then renamed a second time back to its original name</li>\n</ul>"
+            },
+            {
+              "textRaw": "`fs.write(fd, buffer[, offset[, length[, position]]], callback)`",
+              "type": "method",
+              "name": "write",
+              "meta": {
+                "added": [
+                  "v0.0.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `buffer` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `buffer` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `buffer` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v7.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7856",
+                    "description": "The `offset` and `length` parameters are optional now."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
-                    {
-                      "textRaw": "`flags` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
-                      "name": "flags",
-                      "type": "string",
-                      "default": "`'w'`",
-                      "desc": "See [support of file system `flags`][]."
-                    },
-                    {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    },
+                  "params": [
                     {
-                      "textRaw": "`fd` {integer} **Default:** `null`",
+                      "textRaw": "`fd` {integer}",
                       "name": "fd",
-                      "type": "integer",
-                      "default": "`null`"
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView|string|Object}",
+                      "name": "buffer",
+                      "type": "Buffer|TypedArray|DataView|string|Object"
                     },
                     {
-                      "textRaw": "`autoClose` {boolean} **Default:** `true`",
-                      "name": "autoClose",
-                      "type": "boolean",
-                      "default": "`true`"
+                      "textRaw": "`offset` {integer}",
+                      "name": "offset",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`emitClose` {boolean} **Default:** `false`",
-                      "name": "emitClose",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`length` {integer}",
+                      "name": "length",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`start` {integer}",
-                      "name": "start",
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
                       "type": "integer"
                     },
                     {
-                      "textRaw": "`fs` {Object|null} **Default:** `null`",
-                      "name": "fs",
-                      "type": "Object|null",
-                      "default": "`null`"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p><code>options</code> may also include a <code>start</code> option to allow writing data at\nsome position past the beginning of the file, allowed values are in the\n[0, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\"><code>Number.MAX_SAFE_INTEGER</code></a>] range. Modifying a file rather\nthan replacing it may require a <code>flags</code> mode of <code>r+</code> rather than the\ndefault mode <code>w</code>. The <code>encoding</code> can be any one of those accepted by\n<a href=\"buffer.html#buffer_buffer\"><code>Buffer</code></a>.</p>\n<p>If <code>autoClose</code> is set to true (default behavior) on <code>'error'</code> or <code>'finish'</code>\nthe file descriptor will be closed automatically. If <code>autoClose</code> is false,\nthen the file descriptor won't be closed, even if there's an error.\nIt is the application's responsibility to close it and make sure there's no\nfile descriptor leak.</p>\n<p>By default, the stream will not emit a <code>'close'</code> event after it has been\ndestroyed. This is the opposite of the default for other <code>Writable</code> streams.\nSet the <code>emitClose</code> option to <code>true</code> to change this behavior.</p>\n<p>By providing the <code>fs</code> option it is possible to override the corresponding <code>fs</code>\nimplementations for <code>open</code>, <code>write</code>, <code>writev</code> and <code>close</code>. Overriding <code>write()</code>\nwithout <code>writev()</code> can reduce performance as some optimizations (<code>_writev()</code>)\nwill be disabled. When providing the <code>fs</code> option,  overrides for <code>open</code>,\n<code>close</code>, and at least one of <code>write</code> and <code>writev</code> are required.</p>\n<p>Like <a href=\"#fs_class_fs_readstream\"><code>ReadStream</code></a>, if <code>fd</code> is specified, <a href=\"#fs_class_fs_writestream\"><code>WriteStream</code></a> will ignore the\n<code>path</code> argument and will use the specified file descriptor. This means that no\n<code>'open'</code> event will be emitted. <code>fd</code> should be blocking; non-blocking <code>fd</code>s\nshould be passed to <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding.</p>"
-        },
-        {
-          "textRaw": "`fs.exists(path, callback)`",
-          "type": "method",
-          "name": "exists",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ],
-            "deprecated": [
-              "v1.0.0"
-            ]
-          },
-          "stability": 0,
-          "stabilityText": "Deprecated: Use [`fs.stat()`][] or [`fs.access()`][] instead.",
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`exists` {boolean}",
-                      "name": "exists",
-                      "type": "boolean"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesWritten` {integer}",
+                          "name": "bytesWritten",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
+                          "name": "buffer",
+                          "type": "Buffer|TypedArray|DataView"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Test whether or not the given path exists by checking with the file system.\nThen call the <code>callback</code> argument with either true or false:</p>\n<pre><code class=\"language-js\">fs.exists('/etc/passwd', (exists) => {\n  console.log(exists ? 'it\\'s there' : 'no passwd!');\n});\n</code></pre>\n<p><strong>The parameters for this callback are not consistent with other Node.js\ncallbacks.</strong> Normally, the first parameter to a Node.js callback is an <code>err</code>\nparameter, optionally followed by other parameters. The <code>fs.exists()</code> callback\nhas only one boolean parameter. This is one reason <code>fs.access()</code> is recommended\ninstead of <code>fs.exists()</code>.</p>\n<p>Using <code>fs.exists()</code> to check for the existence of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended. Doing\nso introduces a race condition, since other processes may change the file's\nstate between the two calls. Instead, user code should open/read/write the\nfile directly and handle the error raised if the file does not exist.</p>\n<p><strong>write (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.exists('myfile', (exists) => {\n  if (exists) {\n    console.error('myfile already exists');\n  } else {\n    fs.open('myfile', 'wx', (err, fd) => {\n      if (err) throw err;\n      writeMyData(fd);\n    });\n  }\n});\n</code></pre>\n<p><strong>write (RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.open('myfile', 'wx', (err, fd) => {\n  if (err) {\n    if (err.code === 'EEXIST') {\n      console.error('myfile already exists');\n      return;\n    }\n\n    throw err;\n  }\n\n  writeMyData(fd);\n});\n</code></pre>\n<p><strong>read (NOT RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.exists('myfile', (exists) => {\n  if (exists) {\n    fs.open('myfile', 'r', (err, fd) => {\n      if (err) throw err;\n      readMyData(fd);\n    });\n  } else {\n    console.error('myfile does not exist');\n  }\n});\n</code></pre>\n<p><strong>read (RECOMMENDED)</strong></p>\n<pre><code class=\"language-js\">fs.open('myfile', 'r', (err, fd) => {\n  if (err) {\n    if (err.code === 'ENOENT') {\n      console.error('myfile does not exist');\n      return;\n    }\n\n    throw err;\n  }\n\n  readMyData(fd);\n});\n</code></pre>\n<p>The \"not recommended\" examples above check for existence and then use the\nfile; the \"recommended\" examples are better because they use the file directly\nand handle the error, if any.</p>\n<p>In general, check for the existence of a file only if the file won’t be\nused directly, for example when its existence is a signal from another\nprocess.</p>"
-        },
-        {
-          "textRaw": "`fs.existsSync(path)`",
-          "type": "method",
-          "name": "existsSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Write <code>buffer</code> to the file specified by <code>fd</code>. If <code>buffer</code> is a normal object, it\nmust have an own <code>toString</code> function property.</p>\n<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is\nan integer specifying the number of bytes to write.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p>The callback will be given three arguments <code>(err, bytesWritten, buffer)</code> where\n<code>bytesWritten</code> specifies how many <em>bytes</em> were written from <code>buffer</code>.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na promise for an <code>Object</code> with <code>bytesWritten</code> and <code>buffer</code> properties.</p>\n<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting\nfor the callback. For this scenario, <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {boolean}",
-                "name": "return",
-                "type": "boolean"
-              },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns <code>true</code> if the path exists, <code>false</code> otherwise.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"fs.html#fs_fs_exists_path_callback\"><code>fs.exists()</code></a>.</p>\n<p><code>fs.exists()</code> is deprecated, but <code>fs.existsSync()</code> is not. The <code>callback</code>\nparameter to <code>fs.exists()</code> accepts parameters that are inconsistent with other\nNode.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>\n<pre><code class=\"language-js\">if (fs.existsSync('/etc/passwd')) {\n  console.log('The path exists.');\n}\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.fchmod(fd, mode, callback)`",
-          "type": "method",
-          "name": "fchmod",
-          "meta": {
-            "added": [
-              "v0.4.7"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+              "textRaw": "`fs.write(fd, string[, position[, encoding]], callback)`",
+              "type": "method",
+              "name": "write",
+              "meta": {
+                "added": [
+                  "v0.11.5"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `string` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `string` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7856",
+                    "description": "The `position` parameter is optional now."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`mode` {string|integer}",
-                  "name": "mode",
-                  "type": "string|integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`string` {string|Object}",
+                      "name": "string",
+                      "type": "string|Object"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                      "name": "encoding",
+                      "type": "string",
+                      "default": "`'utf8'`"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`written` {integer}",
+                          "name": "written",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`string` {string}",
+                          "name": "string",
+                          "type": "string"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fchmod.2.html\"><code>fchmod(2)</code></a>. No arguments other than a possible exception\nare given to the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.fchmodSync(fd, mode)`",
-          "type": "method",
-          "name": "fchmodSync",
-          "meta": {
-            "added": [
-              "v0.4.7"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Write <code>string</code> to the file specified by <code>fd</code>. If <code>string</code> is not a string, or an\nobject with an own <code>toString</code> function property, then an exception is thrown.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code> the data will be written at\nthe current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p><code>encoding</code> is the expected string encoding.</p>\n<p>The callback will receive the arguments <code>(err, written, string)</code> where <code>written</code>\nspecifies how many <em>bytes</em> the passed string required to be written. Bytes\nwritten is not necessarily the same as string characters written. See\n<a href=\"buffer.html#buffer_static_method_buffer_bytelength_string_encoding\"><code>Buffer.byteLength</code></a>.</p>\n<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting\nfor the callback. For this scenario, <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>\n<p>On Windows, if the file descriptor is connected to the console (e.g. <code>fd == 1</code>\nor <code>stdout</code>) a string containing non-ASCII characters will not be rendered\nproperly by default, regardless of the encoding used.\nIt is possible to configure the console to render UTF-8 properly by changing the\nactive codepage with the <code>chcp 65001</code> command. See the <a href=\"https://ss64.com/nt/chcp.html\">chcp</a> docs for more\ndetails.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`mode` {string|integer}",
-                  "name": "mode",
-                  "type": "string|integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fchmod.2.html\"><code>fchmod(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.fchown(fd, uid, gid, callback)`",
-          "type": "method",
-          "name": "fchown",
-          "meta": {
-            "added": [
-              "v0.4.7"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+              "textRaw": "`fs.writeFile(file, data[, options], callback)`",
+              "type": "method",
+              "name": "writeFile",
+              "meta": {
+                "added": [
+                  "v0.1.29"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35993",
+                    "description": "The options argument may include an AbortSignal to abort an ongoing writeFile request."
+                  },
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `data` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `data` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `data` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/12562",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `data` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7897",
+                    "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `file` parameter can be a file descriptor now."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
+                    {
+                      "textRaw": "`file` {string|Buffer|URL|integer} filename or file descriptor",
+                      "name": "file",
+                      "type": "string|Buffer|URL|integer",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`data` {string|Buffer|TypedArray|DataView|Object}",
+                      "name": "data",
+                      "type": "string|Buffer|TypedArray|DataView|Object"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'w'`",
+                          "desc": "See [support of file system `flags`][]."
+                        },
+                        {
+                          "textRaw": "`signal` {AbortSignal} allows aborting an in-progress writeFile",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "allows aborting an in-progress writeFile"
+                        }
+                      ]
+                    },
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fchown.2.html\"><code>fchown(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.fchownSync(fd, uid, gid)`",
-          "type": "method",
-          "name": "fchownSync",
-          "meta": {
-            "added": [
-              "v0.4.7"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
+              ],
+              "desc": "<p>When <code>file</code> is a filename, asynchronously writes data to the file, replacing the\nfile if it already exists. <code>data</code> can be a string or a buffer.</p>\n<p>When <code>file</code> is a file descriptor, the behavior is similar to calling\n<code>fs.write()</code> directly (which is recommended). See the notes below on using\na file descriptor.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<p>If <code>data</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<pre><code class=\"language-mjs\">import { writeFile } from 'fs';\n\nconst data = new Uint8Array(Buffer.from('Hello Node.js'));\nwriteFile('message.txt', data, (err) => {\n  if (err) throw err;\n  console.log('The file has been saved!');\n});\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-mjs\">import { writeFile } from 'fs';\n\nwriteFile('message.txt', 'Hello Node.js', 'utf8', callback);\n</code></pre>\n<p>It is unsafe to use <code>fs.writeFile()</code> multiple times on the same file without\nwaiting for the callback. For this scenario, <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>Similarly to <code>fs.readFile</code> - <code>fs.writeFile</code> is a convenience method that\nperforms multiple <code>write</code> calls internally to write the buffer passed to it.\nFor performance sensitive code consider using <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>It is possible to use an <a href=\"globals.html#globals_class_abortsignal\" class=\"type\">&lt;AbortSignal&gt;</a> to cancel an <code>fs.writeFile()</code>.\nCancelation is \"best effort\", and some amount of data is likely still\nto be written.</p>\n<pre><code class=\"language-mjs\">import { writeFile } from 'fs';\n\nconst controller = new AbortController();\nconst { signal } = controller;\nconst data = new Uint8Array(Buffer.from('Hello Node.js'));\nwriteFile('message.txt', data, { signal }, (err) => {\n  // When a request is aborted - the callback is called with an AbortError\n});\n// When the request should be aborted\ncontroller.abort();\n</code></pre>\n<p>Aborting an ongoing request does not abort individual operating\nsystem requests but rather the internal buffering <code>fs.writeFile</code> performs.</p>",
+              "modules": [
                 {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
+                  "textRaw": "Using `fs.writeFile()` with file descriptors",
+                  "name": "using_`fs.writefile()`_with_file_descriptors",
+                  "desc": "<p>When <code>file</code> is a file descriptor, the behavior is almost identical to directly\ncalling <code>fs.write()</code> like:</p>\n<pre><code class=\"language-mjs\">import { write } from 'fs';\n\nwrite(fd, Buffer.from(data, options.encoding), callback);\n</code></pre>\n<p>The difference from directly calling <code>fs.write()</code> is that under some unusual\nconditions, <code>fs.write()</code> might write only part of the buffer and need to be\nretried to write the remaining data, whereas <code>fs.writeFile()</code> retries until\nthe data is entirely written (or an error occurs).</p>\n<p>The implications of this are a common source of confusion. In\nthe file descriptor case, the file is not replaced! The data is not necessarily\nwritten to the beginning of the file, and the file's original data may remain\nbefore and/or after the newly written data.</p>\n<p>For example, if <code>fs.writeFile()</code> is called twice in a row, first to write the\nstring <code>'Hello'</code>, then to write the string <code>', World'</code>, the file would contain\n<code>'Hello, World'</code>, and might contain some of the file's original data (depending\non the size of the original file, and the position of the file descriptor). If\na file name had been used instead of a descriptor, the file would be guaranteed\nto contain only <code>', World'</code>.</p>",
+                  "type": "module",
+                  "displayName": "Using `fs.writeFile()` with file descriptors"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fchown.2.html\"><code>fchown(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.fdatasync(fd, callback)`",
-          "type": "method",
-          "name": "fdatasync",
-          "meta": {
-            "added": [
-              "v0.1.96"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.writev(fd, buffers[, position], callback)`",
+              "type": "method",
+              "name": "writev",
+              "meta": {
+                "added": [
+                  "v12.9.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffers` {ArrayBufferView[]}",
+                      "name": "buffers",
+                      "type": "ArrayBufferView[]"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`bytesWritten` {integer}",
+                          "name": "bytesWritten",
+                          "type": "integer"
+                        },
+                        {
+                          "textRaw": "`buffers` {ArrayBufferView[]}",
+                          "name": "buffers",
+                          "type": "ArrayBufferView[]"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
+              ],
+              "desc": "<p>Write an array of <code>ArrayBufferView</code>s to the file specified by <code>fd</code> using\n<code>writev()</code>.</p>\n<p><code>position</code> is the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position.</p>\n<p>The callback will be given three arguments: <code>err</code>, <code>bytesWritten</code>, and\n<code>buffers</code>. <code>bytesWritten</code> is how many bytes were written from <code>buffers</code>.</p>\n<p>If this method is <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed, it returns a promise for an\n<code>Object</code> with <code>bytesWritten</code> and <code>buffers</code> properties.</p>\n<p>It is unsafe to use <code>fs.writev()</code> multiple times on the same file without\nwaiting for the callback. For this scenario, use <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
             }
           ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a>. No arguments other than a possible exception are\ngiven to the completion callback.</p>"
+          "type": "module",
+          "displayName": "Callback API"
         },
         {
-          "textRaw": "`fs.fdatasyncSync(fd)`",
-          "type": "method",
-          "name": "fdatasyncSync",
-          "meta": {
-            "added": [
-              "v0.1.96"
-            ],
-            "changes": []
-          },
-          "signatures": [
+          "textRaw": "Synchronous API",
+          "name": "synchronous_api",
+          "desc": "<p>The synchronous APIs perform all operations synchronously, blocking the\nevent loop until the operation completes or fails.</p>",
+          "methods": [
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.fstat(fd[, options], callback)`",
-          "type": "method",
-          "name": "fstat",
-          "meta": {
-            "added": [
-              "v0.1.95"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+              "textRaw": "`fs.accessSync(path[, mode])`",
+              "type": "method",
+              "name": "accessSync",
+              "meta": {
+                "added": [
+                  "v0.11.15"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "`mode` {integer} **Default:** `fs.constants.F_OK`",
+                      "name": "mode",
+                      "type": "integer",
+                      "default": "`fs.constants.F_OK`"
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Synchronously tests a user's permissions for the file or directory specified\nby <code>path</code>. The <code>mode</code> argument is an optional integer that specifies the\naccessibility checks to be performed. Check <a href=\"#fs_file_access_constants\">File access constants</a> for\npossible values of <code>mode</code>. It is possible to create a mask consisting of\nthe bitwise OR of two or more values\n(e.g. <code>fs.constants.W_OK | fs.constants.R_OK</code>).</p>\n<p>If any of the accessibility checks fail, an <code>Error</code> will be thrown. Otherwise,\nthe method will return <code>undefined</code>.</p>\n<pre><code class=\"language-mjs\">import { accessSync, constants } from 'fs';\n\ntry {\n  accessSync('etc/passwd', constants.R_OK | constants.W_OK);\n  console.log('can read/write');\n} catch (err) {\n  console.error('no access!');\n}\n</code></pre>"
+            },
+            {
+              "textRaw": "`fs.appendFileSync(path, data[, options])`",
+              "type": "method",
+              "name": "appendFileSync",
+              "meta": {
+                "added": [
+                  "v0.6.7"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7831",
+                    "description": "The passed `options` object will never be modified."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `file` parameter can be a file descriptor now."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL|number} filename or file descriptor",
+                      "name": "path",
+                      "type": "string|Buffer|URL|number",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`data` {string|Buffer}",
+                      "name": "data",
+                      "type": "string|Buffer"
                     },
                     {
-                      "textRaw": "`stats` {fs.Stats}",
-                      "name": "stats",
-                      "type": "fs.Stats"
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'a'`",
+                          "desc": "See [support of file system `flags`][]."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fstat.2.html\"><code>fstat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where\n<code>stats</code> is an <a href=\"#fs_class_fs_stats\"><code>fs.Stats</code></a> object. <code>fstat()</code> is identical to <a href=\"fs.html#fs_fs_stat_path_options_callback\"><code>stat()</code></a>,\nexcept that the file to be stat-ed is specified by the file descriptor <code>fd</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.fstatSync(fd[, options])`",
-          "type": "method",
-          "name": "fstatSync",
-          "meta": {
-            "added": [
-              "v0.1.95"
-            ],
-            "changes": [
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously append data to a file, creating the file if it does not yet\nexist. <code>data</code> can be a string or a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<pre><code class=\"language-mjs\">import { appendFileSync } from 'fs';\n\ntry {\n  appendFileSync('message.txt', 'data to append');\n  console.log('The \"data to append\" was appended to file!');\n} catch (err) {\n  /* Handle the error */\n}\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-mjs\">import { appendFileSync } from 'fs';\n\nappendFileSync('message.txt', 'data to append', 'utf8');\n</code></pre>\n<p>The <code>path</code> may be specified as a numeric file descriptor that has been opened\nfor appending (using <code>fs.open()</code> or <code>fs.openSync()</code>). The file descriptor will\nnot be closed automatically.</p>\n<pre><code class=\"language-mjs\">import { openSync, closeSync, appendFileSync } from 'fs';\n\nlet fd;\n\ntry {\n  fd = openSync('message.txt', 'a');\n  appendFileSync(fd, 'data to append', 'utf8');\n} catch (err) {\n  /* Handle the error */\n} finally {\n  if (fd !== undefined)\n    closeSync(fd);\n}\n</code></pre>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.Stats}",
-                "name": "return",
-                "type": "fs.Stats"
+              "textRaw": "`fs.chmodSync(path, mode)`",
+              "type": "method",
+              "name": "chmodSync",
+              "meta": {
+                "added": [
+                  "v0.6.7"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "`mode` {string|integer}",
+                      "name": "mode",
+                      "type": "string|integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fstat.2.html\"><code>fstat(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.fsync(fd, callback)`",
-          "type": "method",
-          "name": "fsync",
-          "meta": {
-            "added": [
-              "v0.1.96"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_chmod_path_mode_callback\"><code>fs.chmod()</code></a>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.chownSync(path, uid, gid)`",
+              "type": "method",
+              "name": "chownSync",
+              "meta": {
+                "added": [
+                  "v0.1.97"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`uid` {integer}",
+                      "name": "uid",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`gid` {integer}",
+                      "name": "gid",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.fsyncSync(fd)`",
-          "type": "method",
-          "name": "fsyncSync",
-          "meta": {
-            "added": [
-              "v0.1.96"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously changes owner and group of a file. Returns <code>undefined</code>.\nThis is the synchronous version of <a href=\"#fs_fs_chown_path_uid_gid_callback\"><code>fs.chown()</code></a>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.ftruncate(fd[, len], callback)`",
-          "type": "method",
-          "name": "ftruncate",
-          "meta": {
-            "added": [
-              "v0.8.6"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+              "textRaw": "`fs.closeSync(fd)`",
+              "type": "method",
+              "name": "closeSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": []
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`len` {integer} **Default:** `0`",
-                  "name": "len",
-                  "type": "integer",
-                  "default": "`0`"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/ftruncate.2.html\"><code>ftruncate(2)</code></a>. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>If the file referred to by the file descriptor was larger than <code>len</code> bytes, only\nthe first <code>len</code> bytes will be retained in the file.</p>\n<p>For example, the following program retains only the first four bytes of the\nfile:</p>\n<pre><code class=\"language-js\">console.log(fs.readFileSync('temp.txt', 'utf8'));\n// Prints: Node.js\n\n// get the file descriptor of the file to be truncated\nconst fd = fs.openSync('temp.txt', 'r+');\n\n// Truncate the file to first four bytes\nfs.ftruncate(fd, 4, (err) => {\n  assert.ifError(err);\n  console.log(fs.readFileSync('temp.txt', 'utf8'));\n});\n// Prints: Node\n</code></pre>\n<p>If the file previously was shorter than <code>len</code> bytes, it is extended, and the\nextended part is filled with null bytes (<code>'\\0'</code>):</p>\n<pre><code class=\"language-js\">console.log(fs.readFileSync('temp.txt', 'utf8'));\n// Prints: Node.js\n\n// get the file descriptor of the file to be truncated\nconst fd = fs.openSync('temp.txt', 'r+');\n\n// Truncate the file to 10 bytes, whereas the actual size is 7 bytes\nfs.ftruncate(fd, 10, (err) => {\n  assert.ifError(err);\n  console.log(fs.readFileSync('temp.txt'));\n});\n// Prints: &#x3C;Buffer 4e 6f 64 65 2e 6a 73 00 00 00>\n// ('Node.js\\0\\0\\0' in UTF8)\n</code></pre>\n<p>The last three bytes are null bytes (<code>'\\0'</code>), to compensate the over-truncation.</p>"
-        },
-        {
-          "textRaw": "`fs.ftruncateSync(fd[, len])`",
-          "type": "method",
-          "name": "ftruncateSync",
-          "meta": {
-            "added": [
-              "v0.8.6"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Closes the file descriptor. Returns <code>undefined</code>.</p>\n<p>Calling <code>fs.closeSync()</code> on any file descriptor (<code>fd</code>) that is currently in use\nthrough any other <code>fs</code> operation may lead to undefined behavior.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/close.2.html\"><code>close(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`len` {integer} **Default:** `0`",
-                  "name": "len",
-                  "type": "integer",
-                  "default": "`0`"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_ftruncate_fd_len_callback\"><code>fs.ftruncate()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.futimes(fd, atime, mtime, callback)`",
-          "type": "method",
-          "name": "futimes",
-          "meta": {
-            "added": [
-              "v0.4.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+              "textRaw": "`fs.copyFileSync(src, dest[, mode])`",
+              "type": "method",
+              "name": "copyFileSync",
+              "meta": {
+                "added": [
+                  "v8.5.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27044",
+                    "description": "Changed 'flags' argument to 'mode' and imposed stricter type validation."
+                  }
+                ]
               },
-              {
-                "version": "v4.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2387",
-                "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
-                {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`src` {string|Buffer|URL} source filename to copy",
+                      "name": "src",
+                      "type": "string|Buffer|URL",
+                      "desc": "source filename to copy"
+                    },
+                    {
+                      "textRaw": "`dest` {string|Buffer|URL} destination filename of the copy operation",
+                      "name": "dest",
+                      "type": "string|Buffer|URL",
+                      "desc": "destination filename of the copy operation"
+                    },
+                    {
+                      "textRaw": "`mode` {integer} modifiers for copy operation. **Default:** `0`.",
+                      "name": "mode",
+                      "type": "integer",
+                      "default": "`0`",
+                      "desc": "modifiers for copy operation."
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Change the file system timestamps of the object referenced by the supplied file\ndescriptor. See <a href=\"#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>.</p>\n<p>This function does not work on AIX versions before 7.1, it will return the\nerror <code>UV_ENOSYS</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.futimesSync(fd, atime, mtime)`",
-          "type": "method",
-          "name": "futimesSync",
-          "meta": {
-            "added": [
-              "v0.4.2"
-            ],
-            "changes": [
-              {
-                "version": "v4.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2387",
-                "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously copies <code>src</code> to <code>dest</code>. By default, <code>dest</code> is overwritten if it\nalready exists. Returns <code>undefined</code>. Node.js makes no guarantees about the\natomicity of the copy operation. If an error occurs after the destination file\nhas been opened for writing, Node.js will attempt to remove the destination.</p>\n<p><code>mode</code> is an optional integer that specifies the behavior\nof the copy operation. It is possible to create a mask consisting of the bitwise\nOR of two or more values (e.g.\n<code>fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE</code>).</p>\n<ul>\n<li><code>fs.constants.COPYFILE_EXCL</code>: The copy operation will fail if <code>dest</code> already\nexists.</li>\n<li><code>fs.constants.COPYFILE_FICLONE</code>: The copy operation will attempt to create a\ncopy-on-write reflink. If the platform does not support copy-on-write, then a\nfallback copy mechanism is used.</li>\n<li><code>fs.constants.COPYFILE_FICLONE_FORCE</code>: The copy operation will attempt to\ncreate a copy-on-write reflink. If the platform does not support\ncopy-on-write, then the operation will fail.</li>\n</ul>\n<pre><code class=\"language-mjs\">import { copyFileSync, constants } from 'fs';\n\n// destination.txt will be created or overwritten by default.\ncopyFileSync('source.txt', 'destination.txt');\nconsole.log('source.txt was copied to destination.txt');\n\n// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.\ncopyFileSync('source.txt', 'destination.txt', constants.COPYFILE_EXCL);\n</code></pre>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
-                {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous version of <a href=\"#fs_fs_futimes_fd_atime_mtime_callback\"><code>fs.futimes()</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.lchmod(path, mode, callback)`",
-          "type": "method",
-          "name": "lchmod",
-          "meta": {
-            "deprecated": [
-              "v0.4.7"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
+              "textRaw": "`fs.existsSync(path)`",
+              "type": "method",
+              "name": "existsSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {integer}",
-                  "name": "mode",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2\"><code>lchmod(2)</code></a>. No arguments other than a possible exception\nare given to the completion callback.</p>\n<p>Only available on macOS.</p>"
-        },
-        {
-          "textRaw": "`fs.lchmodSync(path, mode)`",
-          "type": "method",
-          "name": "lchmodSync",
-          "meta": {
-            "deprecated": [
-              "v0.4.7"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns <code>true</code> if the path exists, <code>false</code> otherwise.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_exists_path_callback\"><code>fs.exists()</code></a>.</p>\n<p><code>fs.exists()</code> is deprecated, but <code>fs.existsSync()</code> is not. The <code>callback</code>\nparameter to <code>fs.exists()</code> accepts parameters that are inconsistent with other\nNode.js callbacks. <code>fs.existsSync()</code> does not use a callback.</p>\n<pre><code class=\"language-mjs\">import { existsSync } from 'fs';\n\nif (existsSync('/etc/passwd'))\n  console.log('The path exists.');\n</code></pre>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`mode` {integer}",
-                  "name": "mode",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2\"><code>lchmod(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.lchown(path, uid, gid, callback)`",
-          "type": "method",
-          "name": "lchown",
-          "meta": {
-            "changes": [
-              {
-                "version": "v10.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/21498",
-                "description": "This API is no longer deprecated."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
+              "textRaw": "`fs.fchmodSync(fd, mode)`",
+              "type": "method",
+              "name": "fchmodSync",
+              "meta": {
+                "added": [
+                  "v0.4.7"
+                ],
+                "changes": []
               },
-              {
-                "version": "v0.4.7",
-                "description": "Documentation-only deprecation."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer}",
+                      "name": "mode",
+                      "type": "string|integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/lchown.2.html\"><code>lchown(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.lchownSync(path, uid, gid)`",
-          "type": "method",
-          "name": "lchownSync",
-          "meta": {
-            "changes": [
-              {
-                "version": "v10.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/21498",
-                "description": "This API is no longer deprecated."
-              },
-              {
-                "version": "v0.4.7",
-                "description": "Documentation-only deprecation."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Sets the permissions on the file. Returns <code>undefined</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fchmod.2.html\"><code>fchmod(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`uid` {integer}",
-                  "name": "uid",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.fchownSync(fd, uid, gid)`",
+              "type": "method",
+              "name": "fchownSync",
+              "meta": {
+                "added": [
+                  "v0.4.7"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`gid` {integer}",
-                  "name": "gid",
-                  "type": "integer"
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`uid` {integer} The file's new owner's user id.",
+                      "name": "uid",
+                      "type": "integer",
+                      "desc": "The file's new owner's user id."
+                    },
+                    {
+                      "textRaw": "`gid` {integer} The file's new group's group id.",
+                      "name": "gid",
+                      "type": "integer",
+                      "desc": "The file's new group's group id."
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/lchown.2.html\"><code>lchown(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.lutimes(path, atime, mtime, callback)`",
-          "type": "method",
-          "name": "lutimes",
-          "meta": {
-            "added": [
-              "v12.19.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Sets the owner of the file. Returns <code>undefined</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fchown.2.html\"><code>fchown(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
-                {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
-                },
+              "textRaw": "`fs.fdatasyncSync(fd)`",
+              "type": "method",
+              "name": "fdatasyncSync",
+              "meta": {
+                "added": [
+                  "v0.1.96"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Changes the access and modification times of a file in the same way as\n<a href=\"#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>, with the difference that if the path refers to a symbolic\nlink, then the link is not dereferenced: instead, the timestamps of the\nsymbolic link itself are changed.</p>\n<p>No arguments other than a possible exception are given to the completion\ncallback.</p>"
-        },
-        {
-          "textRaw": "`fs.lutimesSync(path, atime, mtime)`",
-          "type": "method",
-          "name": "lutimesSync",
-          "meta": {
-            "added": [
-              "v12.19.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Forces all currently queued I/O operations associated with the file to the\noperating system's synchronized I/O completion state. Refer to the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/fdatasync.2.html\"><code>fdatasync(2)</code></a> documentation for details. Returns <code>undefined</code>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
+              "textRaw": "`fs.fstatSync(fd[, options])`",
+              "type": "method",
+              "name": "fstatSync",
+              "meta": {
+                "added": [
+                  "v0.1.95"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
+                  "return": {
+                    "textRaw": "Returns: {fs.Stats}",
+                    "name": "return",
+                    "type": "fs.Stats"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        }
+                      ]
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Change the file system timestamps of the symbolic link referenced by <code>path</code>.\nReturns <code>undefined</code>, or throws an exception when parameters are incorrect or\nthe operation fails. This is the synchronous version of <a href=\"#fs_fs_lutimes_path_atime_mtime_callback\"><code>fs.lutimes()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.link(existingPath, newPath, callback)`",
-          "type": "method",
-          "name": "link",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `existingPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the file descriptor.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fstat.2.html\"><code>fstat(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`existingPath` {string|Buffer|URL}",
-                  "name": "existingPath",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`newPath` {string|Buffer|URL}",
-                  "name": "newPath",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.fsyncSync(fd)`",
+              "type": "method",
+              "name": "fsyncSync",
+              "meta": {
+                "added": [
+                  "v0.1.96"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>. No arguments other than a possible exception are given to\nthe completion callback.</p>"
-        },
-        {
-          "textRaw": "`fs.linkSync(existingPath, newPath)`",
-          "type": "method",
-          "name": "linkSync",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `existingPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Request that all data for the open file descriptor is flushed to the storage\ndevice. The specific implementation is operating system and device specific.\nRefer to the POSIX <a href=\"http://man7.org/linux/man-pages/man2/fsync.2.html\"><code>fsync(2)</code></a> documentation for more detail. Returns <code>undefined</code>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`existingPath` {string|Buffer|URL}",
-                  "name": "existingPath",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.ftruncateSync(fd[, len])`",
+              "type": "method",
+              "name": "ftruncateSync",
+              "meta": {
+                "added": [
+                  "v0.8.6"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`newPath` {string|Buffer|URL}",
-                  "name": "newPath",
-                  "type": "string|Buffer|URL"
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`len` {integer} **Default:** `0`",
+                      "name": "len",
+                      "type": "integer",
+                      "default": "`0`"
+                    }
+                  ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.lstat(path[, options], callback)`",
-          "type": "method",
-          "name": "lstat",
-          "meta": {
-            "added": [
-              "v0.1.30"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Truncates the file descriptor. Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_ftruncate_fd_len_callback\"><code>fs.ftruncate()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.futimesSync(fd, atime, mtime)`",
+              "type": "method",
+              "name": "futimesSync",
+              "meta": {
+                "added": [
+                  "v0.4.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v4.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/2387",
+                    "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
+                    },
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Synchronous version of <a href=\"#fs_fs_futimes_fd_atime_mtime_callback\"><code>fs.futimes()</code></a>. Returns <code>undefined</code>.</p>"
+            },
+            {
+              "textRaw": "`fs.lchmodSync(path, mode)`",
+              "type": "method",
+              "name": "lchmodSync",
+              "meta": {
+                "deprecated": [
+                  "v0.4.7"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`stats` {fs.Stats}",
-                      "name": "stats",
-                      "type": "fs.Stats"
+                      "textRaw": "`mode` {integer}",
+                      "name": "mode",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where\n<code>stats</code> is a <a href=\"#fs_class_fs_stats\"><code>fs.Stats</code></a> object. <code>lstat()</code> is identical to <code>stat()</code>,\nexcept that if <code>path</code> is a symbolic link, then the link itself is stat-ed,\nnot the file that it refers to.</p>"
-        },
-        {
-          "textRaw": "`fs.lstatSync(path[, options])`",
-          "type": "method",
-          "name": "lstatSync",
-          "meta": {
-            "added": [
-              "v0.1.30"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Changes the permissions on a symbolic link. Returns <code>undefined</code>.</p>\n<p>This method is only implemented on macOS.</p>\n<p>See the POSIX <a href=\"https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2\"><code>lchmod(2)</code></a> documentation for more detail.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.Stats}",
-                "name": "return",
-                "type": "fs.Stats"
+              "textRaw": "`fs.lchownSync(path, uid, gid)`",
+              "type": "method",
+              "name": "lchownSync",
+              "meta": {
+                "changes": [
+                  {
+                    "version": "v10.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/21498",
+                    "description": "This API is no longer deprecated."
+                  },
+                  {
+                    "version": "v0.4.7",
+                    "description": "Documentation-only deprecation."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`uid` {integer} The file's new owner's user id.",
+                      "name": "uid",
+                      "type": "integer",
+                      "desc": "The file's new owner's user id."
+                    },
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "textRaw": "`gid` {integer} The file's new group's group id.",
+                      "name": "gid",
+                      "type": "integer",
+                      "desc": "The file's new group's group id."
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.mkdir(path[, options], callback)`",
-          "type": "method",
-          "name": "mkdir",
-          "meta": {
-            "added": [
-              "v0.1.8"
-            ],
-            "changes": [
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/31530",
-                "description": "In `recursive` mode, the callback now receives the first created path as an argument."
-              },
-              {
-                "version": "v10.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/21875",
-                "description": "The second argument can now be an `options` object with `recursive` and `mode` properties."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Set the owner for the path. Returns <code>undefined</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lchown.2.html\"><code>lchown(2)</code></a> documentation for more details.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.lutimesSync(path, atime, mtime)`",
+              "type": "method",
+              "name": "lutimesSync",
+              "meta": {
+                "added": [
+                  "v14.5.0",
+                  "v12.19.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|integer}",
-                  "name": "options",
-                  "type": "Object|integer",
-                  "options": [
+                  "params": [
+                    {
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
                     {
-                      "textRaw": "`recursive` {boolean} **Default:** `false`",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
                     },
                     {
-                      "textRaw": "`mode` {string|integer} Not supported on Windows. **Default:** `0o777`.",
-                      "name": "mode",
-                      "type": "string|integer",
-                      "default": "`0o777`",
-                      "desc": "Not supported on Windows."
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Change the file system timestamps of the symbolic link referenced by <code>path</code>.\nReturns <code>undefined</code>, or throws an exception when parameters are incorrect or\nthe operation fails. This is the synchronous version of <a href=\"#fs_fs_lutimes_path_atime_mtime_callback\"><code>fs.lutimes()</code></a>.</p>"
+            },
+            {
+              "textRaw": "`fs.linkSync(existingPath, newPath)`",
+              "type": "method",
+              "name": "linkSync",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `existingPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`existingPath` {string|Buffer|URL}",
+                      "name": "existingPath",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`newPath` {string|Buffer|URL}",
+                      "name": "newPath",
+                      "type": "string|Buffer|URL"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously creates a directory.</p>\n<p>The callback is given a possible exception and, if <code>recursive</code> is <code>true</code>, the\nfirst directory path created, <code>(err, [path])</code>.</p>\n<p>The optional <code>options</code> argument can be an integer specifying mode (permission\nand sticky bits), or an object with a <code>mode</code> property and a <code>recursive</code>\nproperty indicating whether parent directories should be created. Calling\n<code>fs.mkdir()</code> when <code>path</code> is a directory that exists results in an error only\nwhen <code>recursive</code> is false.</p>\n<pre><code class=\"language-js\">// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.\nfs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {\n  if (err) throw err;\n});\n</code></pre>\n<p>On Windows, using <code>fs.mkdir()</code> on the root directory even with recursion will\nresult in an error:</p>\n<pre><code class=\"language-js\">fs.mkdir('/', { recursive: true }, (err) => {\n  // => [Error: EPERM: operation not permitted, mkdir 'C:\\']\n});\n</code></pre>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/mkdir.2.html\"><code>mkdir(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.mkdirSync(path[, options])`",
-          "type": "method",
-          "name": "mkdirSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/31530",
-                "description": "In `recursive` mode, the first created path is returned now."
-              },
-              {
-                "version": "v10.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/21875",
-                "description": "The second argument can now be an `options` object with `recursive` and `mode` properties."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Creates a new link from the <code>existingPath</code> to the <code>newPath</code>. See the POSIX\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a> documentation for more detail. Returns <code>undefined</code>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string|undefined}",
-                "name": "return",
-                "type": "string|undefined"
+              "textRaw": "`fs.lstatSync(path[, options])`",
+              "type": "method",
+              "name": "lstatSync",
+              "meta": {
+                "added": [
+                  "v0.1.30"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33716",
+                    "description": "Accepts a `throwIfNoEntry` option to specify whether an exception should be thrown if the entry does not exist."
+                  },
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|integer}",
-                  "name": "options",
-                  "type": "Object|integer",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {fs.Stats}",
+                    "name": "return",
+                    "type": "fs.Stats"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`recursive` {boolean} **Default:** `false`",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`mode` {string|integer} Not supported on Windows. **Default:** `0o777`.",
-                      "name": "mode",
-                      "type": "string|integer",
-                      "default": "`0o777`",
-                      "desc": "Not supported on Windows."
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        },
+                        {
+                          "textRaw": "`throwIfNoEntry` {boolean} Whether an exception will be thrown if no file system entry exists, rather than returning `undefined`. **Default:** `true`.",
+                          "name": "throwIfNoEntry",
+                          "type": "boolean",
+                          "default": "`true`",
+                          "desc": "Whether an exception will be thrown if no file system entry exists, rather than returning `undefined`."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously creates a directory. Returns <code>undefined</code>, or if <code>recursive</code> is\n<code>true</code>, the first directory path created.\nThis is the synchronous version of <a href=\"#fs_fs_mkdir_path_options_callback\"><code>fs.mkdir()</code></a>.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/mkdir.2.html\"><code>mkdir(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.mkdtemp(prefix[, options], callback)`",
-          "type": "method",
-          "name": "mkdtemp",
-          "meta": {
-            "added": [
-              "v5.10.0"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v6.2.1",
-                "pr-url": "https://github.com/nodejs/node/pull/6828",
-                "description": "The `callback` parameter is optional now."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the symbolic link referred to by <code>path</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/lstat.2.html\"><code>lstat(2)</code></a> documentation for more details.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`prefix` {string}",
-                  "name": "prefix",
-                  "type": "string"
-                },
+              "textRaw": "`fs.mkdirSync(path[, options])`",
+              "type": "method",
+              "name": "mkdirSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.11.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31530",
+                    "description": "In `recursive` mode, the first created path is returned now."
+                  },
+                  {
+                    "version": "v10.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/21875",
+                    "description": "The second argument can now be an `options` object with `recursive` and `mode` properties."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string|undefined}",
+                    "name": "return",
+                    "type": "string|undefined"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object|integer}",
+                      "name": "options",
+                      "type": "Object|integer",
+                      "options": [
+                        {
+                          "textRaw": "`recursive` {boolean} **Default:** `false`",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`"
+                        },
+                        {
+                          "textRaw": "`mode` {string|integer} Not supported on Windows. **Default:** `0o777`.",
+                          "name": "mode",
+                          "type": "string|integer",
+                          "default": "`0o777`",
+                          "desc": "Not supported on Windows."
+                        }
+                      ]
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Synchronously creates a directory. Returns <code>undefined</code>, or if <code>recursive</code> is\n<code>true</code>, the first directory path created.\nThis is the synchronous version of <a href=\"#fs_fs_mkdir_path_options_callback\"><code>fs.mkdir()</code></a>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/mkdir.2.html\"><code>mkdir(2)</code></a> documentation for more details.</p>"
+            },
+            {
+              "textRaw": "`fs.mkdtempSync(prefix[, options])`",
+              "type": "method",
+              "name": "mkdtempSync",
+              "meta": {
+                "added": [
+                  "v5.10.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/39028",
+                    "description": "The `prefix` parameter now accepts an empty string."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string}",
+                    "name": "return",
+                    "type": "string"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`prefix` {string}",
+                      "name": "prefix",
+                      "type": "string"
                     },
                     {
-                      "textRaw": "`directory` {string}",
-                      "name": "directory",
-                      "type": "string"
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Creates a unique temporary directory.</p>\n<p>Generates six random characters to be appended behind a required\n<code>prefix</code> to create a unique temporary directory. Due to platform\ninconsistencies, avoid trailing <code>X</code> characters in <code>prefix</code>. Some platforms,\nnotably the BSDs, can return more than six random characters, and replace\ntrailing <code>X</code> characters in <code>prefix</code> with random characters.</p>\n<p>The created directory path is passed as a string to the callback's second\nparameter.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>\n<pre><code class=\"language-js\">fs.mkdtemp(path.join(os.tmpdir(), 'foo-'), (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Prints: /tmp/foo-itXde2 or C:\\Users\\...\\AppData\\Local\\Temp\\foo-itXde2\n});\n</code></pre>\n<p>The <code>fs.mkdtemp()</code> method will append the six randomly selected characters\ndirectly to the <code>prefix</code> string. For instance, given a directory <code>/tmp</code>, if the\nintention is to create a temporary directory <em>within</em> <code>/tmp</code>, the <code>prefix</code>\nmust end with a trailing platform-specific path separator\n(<code>require('path').sep</code>).</p>\n<pre><code class=\"language-js\">// The parent directory for the new temporary directory\nconst tmpDir = os.tmpdir();\n\n// This method is *INCORRECT*:\nfs.mkdtemp(tmpDir, (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Will print something similar to `/tmpabc123`.\n  // A new temporary directory is created at the file system root\n  // rather than *within* the /tmp directory.\n});\n\n// This method is *CORRECT*:\nconst { sep } = require('path');\nfs.mkdtemp(`${tmpDir}${sep}`, (err, directory) => {\n  if (err) throw err;\n  console.log(directory);\n  // Will print something similar to `/tmp/abc123`.\n  // A new temporary directory is created within\n  // the /tmp directory.\n});\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.mkdtempSync(prefix[, options])`",
-          "type": "method",
-          "name": "mkdtempSync",
-          "meta": {
-            "added": [
-              "v5.10.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns the created directory path.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_mkdtemp_prefix_options_callback\"><code>fs.mkdtemp()</code></a>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string}",
-                "name": "return",
-                "type": "string"
+              "textRaw": "`fs.opendirSync(path[, options])`",
+              "type": "method",
+              "name": "opendirSync",
+              "meta": {
+                "added": [
+                  "v12.12.0"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.1.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30114",
+                    "description": "The `bufferSize` option was introduced."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`prefix` {string}",
-                  "name": "prefix",
-                  "type": "string"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {fs.Dir}",
+                    "name": "return",
+                    "type": "fs.Dir"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`bufferSize` {number} Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. **Default:** `32`",
+                          "name": "bufferSize",
+                          "type": "number",
+                          "default": "`32`",
+                          "desc": "Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the created directory path.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_mkdtemp_prefix_options_callback\"><code>fs.mkdtemp()</code></a>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use.</p>"
-        },
-        {
-          "textRaw": "`fs.open(path[, flags[, mode]], callback)`",
-          "type": "method",
-          "name": "open",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v11.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23767",
-                "description": "The `flags` argument is now optional and defaults to `'r'`."
-              },
-              {
-                "version": "v9.9.0",
-                "pr-url": "https://github.com/nodejs/node/pull/18801",
-                "description": "The `as` and `as+` modes are supported now."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously open a directory. See <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a>.</p>\n<p>Creates an <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`flags` {string|number} See [support of file system `flags`][]. **Default:** `'r'`.",
-                  "name": "flags",
-                  "type": "string|number",
-                  "default": "`'r'`",
-                  "desc": "See [support of file system `flags`][]."
-                },
-                {
-                  "textRaw": "`mode` {string|integer} **Default:** `0o666` (readable and writable)",
-                  "name": "mode",
-                  "type": "string|integer",
-                  "default": "`0o666` (readable and writable)"
-                },
+              "textRaw": "`fs.openSync(path[, flags[, mode]])`",
+              "type": "method",
+              "name": "openSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v11.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23767",
+                    "description": "The `flags` argument is now optional and defaults to `'r'`."
+                  },
+                  {
+                    "version": "v9.9.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/18801",
+                    "description": "The `as` and `as+` flags are supported now."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number}",
+                    "name": "return",
+                    "type": "number"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`fd` {integer}",
-                      "name": "fd",
-                      "type": "integer"
+                      "textRaw": "`flags` {string|number} **Default:** `'r'`. See [support of file system `flags`][].",
+                      "name": "flags",
+                      "type": "string|number",
+                      "default": "`'r'`. See [support of file system `flags`][]"
+                    },
+                    {
+                      "textRaw": "`mode` {string|integer} **Default:** `0o666`",
+                      "name": "mode",
+                      "type": "string|integer",
+                      "default": "`0o666`"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous file open. See <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>.</p>\n<p><code>mode</code> sets the file mode (permission and sticky bits), but only if the file was\ncreated. On Windows, only the write permission can be manipulated; see\n<a href=\"#fs_fs_chmod_path_mode_callback\"><code>fs.chmod()</code></a>.</p>\n<p>The callback gets two arguments <code>(err, fd)</code>.</p>\n<p>Some characters (<code>&#x3C; > : \" / \\ | ? *</code>) are reserved under Windows as documented\nby <a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file\">Naming Files, Paths, and Namespaces</a>. Under NTFS, if the filename contains\na colon, Node.js will open a file system stream, as described by\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams\">this MSDN page</a>.</p>\n<p>Functions based on <code>fs.open()</code> exhibit this behavior as well:\n<code>fs.writeFile()</code>, <code>fs.readFile()</code>, etc.</p>"
-        },
-        {
-          "textRaw": "`fs.opendir(path[, options], callback)`",
-          "type": "method",
-          "name": "opendir",
-          "meta": {
-            "added": [
-              "v12.12.0"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30114",
-                "description": "The `bufferSize` option was introduced."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns an integer representing the file descriptor.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.readdirSync(path[, options])`",
+              "type": "method",
+              "name": "readdirSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22020",
+                    "description": "New option `withFileTypes` was added."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string[]|Buffer[]|fs.Dirent[]}",
+                    "name": "return",
+                    "type": "string[]|Buffer[]|fs.Dirent[]"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`bufferSize` {number} Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. **Default:** `32`",
-                      "name": "bufferSize",
-                      "type": "number",
-                      "default": "`32`",
-                      "desc": "Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage."
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`withFileTypes` {boolean} **Default:** `false`",
+                          "name": "withFileTypes",
+                          "type": "boolean",
+                          "default": "`false`"
+                        }
+                      ]
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Reads the contents of the directory.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> documentation for more details.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe filenames returned will be passed as <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the result will contain\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> objects.</p>"
+            },
+            {
+              "textRaw": "`fs.readFileSync(path[, options])`",
+              "type": "method",
+              "name": "readFileSync",
+              "meta": {
+                "added": [
+                  "v0.1.8"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `path` parameter can be a file descriptor now."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string|Buffer}",
+                    "name": "return",
+                    "type": "string|Buffer"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL|integer} filename or file descriptor",
+                      "name": "path",
+                      "type": "string|Buffer|URL|integer",
+                      "desc": "filename or file descriptor"
                     },
                     {
-                      "textRaw": "`dir` {fs.Dir}",
-                      "name": "dir",
-                      "type": "fs.Dir"
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `null`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`null`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'r'`",
+                          "desc": "See [support of file system `flags`][]."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously open a directory. See <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a>.</p>\n<p>Creates an <a href=\"#fs_class_fs_dir\"><code>fs.Dir</code></a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>"
-        },
-        {
-          "textRaw": "`fs.opendirSync(path[, options])`",
-          "type": "method",
-          "name": "opendirSync",
-          "meta": {
-            "added": [
-              "v12.12.0"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30114",
-                "description": "The `bufferSize` option was introduced."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns the contents of the <code>path</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_readfile_path_options_callback\"><code>fs.readFile()</code></a>.</p>\n<p>If the <code>encoding</code> option is specified then this function returns a\nstring. Otherwise it returns a buffer.</p>\n<p>Similar to <a href=\"#fs_fs_readfile_path_options_callback\"><code>fs.readFile()</code></a>, when the path is a directory, the behavior of\n<code>fs.readFileSync()</code> is platform-specific.</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n\n// macOS, Linux, and Windows\nreadFileSync('&#x3C;directory>');\n// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]\n\n//  FreeBSD\nreadFileSync('&#x3C;directory>'); // => &#x3C;data>\n</code></pre>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.Dir}",
-                "name": "return",
-                "type": "fs.Dir"
+              "textRaw": "`fs.readlinkSync(path[, options])`",
+              "type": "method",
+              "name": "readlinkSync",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string|Buffer}",
+                    "name": "return",
+                    "type": "string|Buffer"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`bufferSize` {number} Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. **Default:** `32`",
-                      "name": "bufferSize",
-                      "type": "number",
-                      "default": "`32`",
-                      "desc": "Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage."
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronously open a directory. See <a href=\"http://man7.org/linux/man-pages/man3/opendir.3.html\"><code>opendir(3)</code></a>.</p>\n<p>Creates an <a href=\"#fs_class_fs_dir\"><code>fs.Dir</code></a>, which contains all further functions for reading from\nand cleaning up the directory.</p>\n<p>The <code>encoding</code> option sets the encoding for the <code>path</code> while opening the\ndirectory and subsequent read operations.</p>"
-        },
-        {
-          "textRaw": "`fs.openSync(path[, flags, mode])`",
-          "type": "method",
-          "name": "openSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v11.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23767",
-                "description": "The `flags` argument is now optional and defaults to `'r'`."
-              },
-              {
-                "version": "v9.9.0",
-                "pr-url": "https://github.com/nodejs/node/pull/18801",
-                "description": "The `as` and `as+` modes are supported now."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns the symbolic link's string value.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a> documentation for more details.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe link path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {number}",
-                "name": "return",
-                "type": "number"
-              },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`flags` {string|number} **Default:** `'r'`. See [support of file system `flags`][].",
-                  "name": "flags",
-                  "type": "string|number",
-                  "default": "`'r'`. See [support of file system `flags`][]"
-                },
-                {
-                  "textRaw": "`mode` {string|integer} **Default:** `0o666`",
-                  "name": "mode",
-                  "type": "string|integer",
-                  "default": "`0o666`"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns an integer representing the file descriptor.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.read(fd, buffer, offset, length, position, callback)`",
-          "type": "method",
-          "name": "read",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `buffer` parameter can now be any `TypedArray`, or a `DataView`."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `buffer` parameter can now be a `Uint8Array`."
+              "textRaw": "`fs.readSync(fd, buffer, offset, length, position)`",
+              "type": "method",
+              "name": "readSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4518",
+                    "description": "The `length` parameter can now be `0`."
+                  }
+                ]
               },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/4518",
-                "description": "The `length` parameter can now be `0`."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
-                },
-                {
-                  "textRaw": "`offset` {integer}",
-                  "name": "offset",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`length` {integer}",
-                  "name": "length",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                  "return": {
+                    "textRaw": "Returns: {number}",
+                    "name": "return",
+                    "type": "number"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`bytesRead` {integer}",
-                      "name": "bytesRead",
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
                       "type": "integer"
                     },
                     {
-                      "textRaw": "`buffer` {Buffer}",
-                      "name": "buffer",
-                      "type": "Buffer"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Read data from the file specified by <code>fd</code>.</p>\n<p><code>buffer</code> is the buffer that the data (read from the fd) will be written to.</p>\n<p><code>offset</code> is the offset in the buffer to start writing at.</p>\n<p><code>length</code> is an integer specifying the number of bytes to read.</p>\n<p><code>position</code> is an argument specifying where to begin reading from in the file.\nIf <code>position</code> is <code>null</code>, data will be read from the current file position,\nand the file position will be updated.\nIf <code>position</code> is an integer, the file position will remain unchanged.</p>\n<p>The callback is given the three arguments, <code>(err, bytesRead, buffer)</code>.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> and <code>buffer</code> properties.</p>"
-        },
-        {
-          "textRaw": "`fs.read(fd, [options,] callback)`",
-          "type": "method",
-          "name": "read",
-          "meta": {
-            "added": [
-              "v12.17.0"
-            ],
-            "changes": [
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/31402",
-                "description": "Options object can be passed in to make Buffer, offset, length and position optional"
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`buffer` {Buffer|TypedArray|DataView} **Default:** `Buffer.alloc(16384)`",
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
                       "name": "buffer",
-                      "type": "Buffer|TypedArray|DataView",
-                      "default": "`Buffer.alloc(16384)`"
+                      "type": "Buffer|TypedArray|DataView"
                     },
                     {
-                      "textRaw": "`offset` {integer} **Default:** `0`",
+                      "textRaw": "`offset` {integer}",
                       "name": "offset",
-                      "type": "integer",
-                      "default": "`0`"
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`length` {integer} **Default:** `buffer.length`",
+                      "textRaw": "`length` {integer}",
                       "name": "length",
-                      "type": "integer",
-                      "default": "`buffer.length`"
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`position` {integer} **Default:** `null`",
+                      "textRaw": "`position` {integer|bigint}",
                       "name": "position",
-                      "type": "integer",
-                      "default": "`null`"
+                      "type": "integer|bigint"
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Returns the number of <code>bytesRead</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a>.</p>"
+            },
+            {
+              "textRaw": "`fs.readSync(fd, buffer, [options])`",
+              "type": "method",
+              "name": "readSync",
+              "meta": {
+                "added": [
+                  "v13.13.0",
+                  "v12.17.0"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.13.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/32460",
+                    "description": "Options object can be passed in to make offset, length and position optional."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                  "return": {
+                    "textRaw": "Returns: {number}",
+                    "name": "return",
+                    "type": "number"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`bytesRead` {integer}",
-                      "name": "bytesRead",
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
                       "type": "integer"
                     },
                     {
-                      "textRaw": "`buffer` {Buffer}",
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
                       "name": "buffer",
-                      "type": "Buffer"
+                      "type": "Buffer|TypedArray|DataView"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`offset` {integer} **Default:** `0`",
+                          "name": "offset",
+                          "type": "integer",
+                          "default": "`0`"
+                        },
+                        {
+                          "textRaw": "`length` {integer} **Default:** `buffer.byteLength`",
+                          "name": "length",
+                          "type": "integer",
+                          "default": "`buffer.byteLength`"
+                        },
+                        {
+                          "textRaw": "`position` {integer|bigint} **Default:** `null`",
+                          "name": "position",
+                          "type": "integer|bigint",
+                          "default": "`null`"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Similar to the above <code>fs.read</code> function, this version takes an optional <code>options</code> object.\nIf no <code>options</code> object is specified, it will default with the above values.</p>"
-        },
-        {
-          "textRaw": "`fs.readdir(path[, options], callback)`",
-          "type": "method",
-          "name": "readdir",
-          "meta": {
-            "added": [
-              "v0.1.8"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22020",
-                "description": "New option `withFileTypes` was added."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/5616",
-                "description": "The `options` parameter was added."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns the number of <code>bytesRead</code>.</p>\n<p>Similar to the above <code>fs.readSync</code> function, this version takes an optional <code>options</code> object.\nIf no <code>options</code> object is specified, it will default with the above values.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.readvSync(fd, buffers[, position])`",
+              "type": "method",
+              "name": "readvSync",
+              "meta": {
+                "added": [
+                  "v13.13.0",
+                  "v12.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number} The number of bytes read.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The number of bytes read."
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`withFileTypes` {boolean} **Default:** `false`",
-                      "name": "withFileTypes",
-                      "type": "boolean",
-                      "default": "`false`"
-                    }
-                  ]
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`buffers` {ArrayBufferView[]}",
+                      "name": "buffers",
+                      "type": "ArrayBufferView[]"
                     },
                     {
-                      "textRaw": "`files` {string[]|Buffer[]|fs.Dirent[]}",
-                      "name": "files",
-                      "type": "string[]|Buffer[]|fs.Dirent[]"
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a>. Reads the contents of a directory.\nThe callback gets two arguments <code>(err, files)</code> where <code>files</code> is an array of\nthe names of the files in the directory excluding <code>'.'</code> and <code>'..'</code>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe filenames returned will be passed as <code>Buffer</code> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the <code>files</code> array will contain\n<a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a> objects.</p>"
-        },
-        {
-          "textRaw": "`fs.readdirSync(path[, options])`",
-          "type": "method",
-          "name": "readdirSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22020",
-                "description": "New option `withFileTypes` was added."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_readv_fd_buffers_position_callback\"><code>fs.readv()</code></a>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string[]|Buffer[]|fs.Dirent[]}",
-                "name": "return",
-                "type": "string[]|Buffer[]|fs.Dirent[]"
+              "textRaw": "`fs.realpathSync(path[, options])`",
+              "type": "method",
+              "name": "realpathSync",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/13028",
+                    "description": "Pipe/Socket resolve support was added."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v6.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7899",
+                    "description": "Calling `realpathSync` now works again for various edge cases on Windows."
+                  },
+                  {
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3594",
+                    "description": "The `cache` parameter was removed."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string|Buffer}",
+                    "name": "return",
+                    "type": "string|Buffer"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`withFileTypes` {boolean} **Default:** `false`",
-                      "name": "withFileTypes",
-                      "type": "boolean",
-                      "default": "`false`"
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe filenames returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe filenames returned will be passed as <code>Buffer</code> objects.</p>\n<p>If <code>options.withFileTypes</code> is set to <code>true</code>, the result will contain\n<a href=\"#fs_class_fs_dirent\"><code>fs.Dirent</code></a> objects.</p>"
-        },
-        {
-          "textRaw": "`fs.readFile(path[, options], callback)`",
-          "type": "method",
-          "name": "readFile",
-          "meta": {
-            "added": [
-              "v0.1.29"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v5.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3740",
-                "description": "The `callback` will always be called with `null` as the `error` parameter in case of success."
-              },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `path` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns the resolved pathname.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_realpath_path_options_callback\"><code>fs.realpath()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL|integer} filename or file descriptor",
-                  "name": "path",
-                  "type": "string|Buffer|URL|integer",
-                  "desc": "filename or file descriptor"
-                },
+              "textRaw": "`fs.realpathSync.native(path[, options])`",
+              "type": "method",
+              "name": "native",
+              "meta": {
+                "added": [
+                  "v9.2.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {string|Buffer}",
+                    "name": "return",
+                    "type": "string|Buffer"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `null`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`null`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'r'`",
-                      "desc": "See [support of file system `flags`][]."
+                      "textRaw": "`options` {string|Object}",
+                      "name": "options",
+                      "type": "string|Object",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string",
+                          "default": "`'utf8'`"
+                        }
+                      ]
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
+            },
+            {
+              "textRaw": "`fs.renameSync(oldPath, newPath)`",
+              "type": "method",
+              "name": "renameSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `oldPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`oldPath` {string|Buffer|URL}",
+                      "name": "oldPath",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`data` {string|Buffer}",
-                      "name": "data",
-                      "type": "string|Buffer"
+                      "textRaw": "`newPath` {string|Buffer|URL}",
+                      "name": "newPath",
+                      "type": "string|Buffer|URL"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously reads the entire contents of a file.</p>\n<pre><code class=\"language-js\">fs.readFile('/etc/passwd', (err, data) => {\n  if (err) throw err;\n  console.log(data);\n});\n</code></pre>\n<p>The callback is passed two arguments <code>(err, data)</code>, where <code>data</code> is the\ncontents of the file.</p>\n<p>If no encoding is specified, then the raw buffer is returned.</p>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-js\">fs.readFile('/etc/passwd', 'utf8', callback);\n</code></pre>\n<p>When the path is a directory, the behavior of <code>fs.readFile()</code> and\n<a href=\"#fs_fs_readfilesync_path_options\"><code>fs.readFileSync()</code></a> is platform-specific. On macOS, Linux, and Windows, an\nerror will be returned. On FreeBSD, a representation of the directory's contents\nwill be returned.</p>\n<pre><code class=\"language-js\">// macOS, Linux, and Windows\nfs.readFile('&#x3C;directory>', (err, data) => {\n  // => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]\n});\n\n//  FreeBSD\nfs.readFile('&#x3C;directory>', (err, data) => {\n  // => null, &#x3C;data>\n});\n</code></pre>\n<p>The <code>fs.readFile()</code> function buffers the entire file. To minimize memory costs,\nwhen possible prefer streaming via <code>fs.createReadStream()</code>.</p>",
-          "modules": [
-            {
-              "textRaw": "File descriptors",
-              "name": "file_descriptors",
-              "desc": "<ol>\n<li>Any specified file descriptor has to support reading.</li>\n<li>If a file descriptor is specified as the <code>path</code>, it will not be closed\nautomatically.</li>\n<li>The reading will begin at the current position. For example, if the file\nalready had <code>'Hello World</code>' and six bytes are read with the file descriptor,\nthe call to <code>fs.readFile()</code> with the same file descriptor, would give\n<code>'World'</code>, rather than <code>'Hello World'</code>.</li>\n</ol>",
-              "type": "module",
-              "displayName": "File descriptors"
-            }
-          ]
-        },
-        {
-          "textRaw": "`fs.readFileSync(path[, options])`",
-          "type": "method",
-          "name": "readFileSync",
-          "meta": {
-            "added": [
-              "v0.1.8"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `path` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Renames the file from <code>oldPath</code> to <code>newPath</code>. Returns <code>undefined</code>.</p>\n<p>See the POSIX <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a> documentation for more details.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string|Buffer}",
-                "name": "return",
-                "type": "string|Buffer"
+              "textRaw": "`fs.rmdirSync(path[, options])`",
+              "type": "method",
+              "name": "rmdirSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35579",
+                    "description": "The `recursive` option is deprecated, use `fs.rmSync` instead."
+                  },
+                  {
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30644",
+                    "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
+                  },
+                  {
+                    "version": "v12.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29168",
+                    "description": "The `recursive`, `maxBusyTries`, and `emfileWait` options are now supported."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameters can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL|integer} filename or file descriptor",
-                  "name": "path",
-                  "type": "string|Buffer|URL|integer",
-                  "desc": "filename or file descriptor"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string|null} **Default:** `null`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`null`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'r'`",
-                      "desc": "See [support of file system `flags`][]."
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js retries the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the contents of the <code>path</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_readfile_path_options_callback\"><code>fs.readFile()</code></a>.</p>\n<p>If the <code>encoding</code> option is specified then this function returns a\nstring. Otherwise it returns a buffer.</p>\n<p>Similar to <a href=\"#fs_fs_readfile_path_options_callback\"><code>fs.readFile()</code></a>, when the path is a directory, the behavior of\n<code>fs.readFileSync()</code> is platform-specific.</p>\n<pre><code class=\"language-js\">// macOS, Linux, and Windows\nfs.readFileSync('&#x3C;directory>');\n// => [Error: EISDIR: illegal operation on a directory, read &#x3C;directory>]\n\n//  FreeBSD\nfs.readFileSync('&#x3C;directory>'); // => &#x3C;data>\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.readlink(path[, options], callback)`",
-          "type": "method",
-          "name": "readlink",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/rmdir.2.html\"><code>rmdir(2)</code></a>. Returns <code>undefined</code>.</p>\n<p>Using <code>fs.rmdirSync()</code> on a file (not a directory) results in an <code>ENOENT</code> error\non Windows and an <code>ENOTDIR</code> error on POSIX.</p>\n<p>Setting <code>recursive</code> to <code>true</code> results in behavior similar to the Unix command\n<code>rm -rf</code>: an error will not be raised for paths that do not exist, and paths\nthat represent files will be deleted. The permissive behavior of the\n<code>recursive</code> option is deprecated, <code>ENOTDIR</code> and <code>ENOENT</code> will be thrown in\nthe future.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
-                    }
-                  ]
-                },
+              "textRaw": "`fs.rmSync(path[, options])`",
+              "type": "method",
+              "name": "rmSync",
+              "meta": {
+                "added": [
+                  "v14.14.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`linkString` {string|Buffer}",
-                      "name": "linkString",
-                      "type": "string|Buffer"
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`force` {boolean} When `true`, exceptions will be ignored if `path` does not exist. **Default:** `false`.",
+                          "name": "force",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "When `true`, exceptions will be ignored if `path` does not exist."
+                        },
+                        {
+                          "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
+                          "name": "maxRetries",
+                          "type": "integer",
+                          "default": "`0`",
+                          "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` milliseconds longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
+                        },
+                        {
+                          "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode operations are retried on failure. **Default:** `false`.",
+                          "name": "recursive",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "If `true`, perform a recursive directory removal. In recursive mode operations are retried on failure."
+                        },
+                        {
+                          "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
+                          "name": "retryDelay",
+                          "type": "integer",
+                          "default": "`100`",
+                          "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a>. The callback gets two arguments <code>(err, linkString)</code>.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe link path returned will be passed as a <code>Buffer</code> object.</p>"
-        },
-        {
-          "textRaw": "`fs.readlinkSync(path[, options])`",
-          "type": "method",
-          "name": "readlinkSync",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Synchronously removes files and directories (modeled on the standard POSIX <code>rm</code>\nutility). Returns <code>undefined</code>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string|Buffer}",
-                "name": "return",
-                "type": "string|Buffer"
+              "textRaw": "`fs.statSync(path[, options])`",
+              "type": "method",
+              "name": "statSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33716",
+                    "description": "Accepts a `throwIfNoEntry` option to specify whether an exception should be thrown if the entry does not exist."
+                  },
+                  {
+                    "version": "v10.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/20220",
+                    "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {fs.Stats}",
+                    "name": "return",
+                    "type": "fs.Stats"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
+                    },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`bigint` {boolean} Whether the numeric values in the returned {fs.Stats} object should be `bigint`. **Default:** `false`.",
+                          "name": "bigint",
+                          "type": "boolean",
+                          "default": "`false`",
+                          "desc": "Whether the numeric values in the returned {fs.Stats} object should be `bigint`."
+                        },
+                        {
+                          "textRaw": "`throwIfNoEntry` {boolean} Whether an exception will be thrown if no file system entry exists, rather than returning `undefined`. **Default:** `true`.",
+                          "name": "throwIfNoEntry",
+                          "type": "boolean",
+                          "default": "`true`",
+                          "desc": "Whether an exception will be thrown if no file system entry exists, rather than returning `undefined`."
+                        }
+                      ]
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/readlink.2.html\"><code>readlink(2)</code></a>. Returns the symbolic link's string value.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe link path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe link path returned will be passed as a <code>Buffer</code> object.</p>"
-        },
-        {
-          "textRaw": "`fs.readSync(fd, buffer, offset, length, position)`",
-          "type": "method",
-          "name": "readSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
-              },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/4518",
-                "description": "The `length` parameter can now be `0`."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {number}",
-                "name": "return",
-                "type": "number"
-              },
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
-                },
-                {
-                  "textRaw": "`offset` {integer}",
-                  "name": "offset",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`length` {integer}",
-                  "name": "length",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the number of <code>bytesRead</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.readSync(fd, buffer, [options])`",
-          "type": "method",
-          "name": "readSync",
-          "meta": {
-            "added": [
-              "v12.17.0"
-            ],
-            "changes": [
-              {
-                "version": "v12.17.0",
-                "pr-url": "https://github.com/nodejs/node/pull/32460",
-                "description": "Options object can be passed in to make offset, length and position optional"
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Retrieves the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> for the path.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {number}",
-                "name": "return",
-                "type": "number"
+              "textRaw": "`fs.symlinkSync(target, path[, type])`",
+              "type": "method",
+              "name": "symlinkSync",
+              "meta": {
+                "added": [
+                  "v0.1.31"
+                ],
+                "changes": [
+                  {
+                    "version": "v12.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/23724",
+                    "description": "If the `type` argument is left undefined, Node will autodetect `target` type and automatically select `dir` or `file`."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `target` and `path` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`offset` {integer} **Default:** `0`",
-                      "name": "offset",
-                      "type": "integer",
-                      "default": "`0`"
+                      "textRaw": "`target` {string|Buffer|URL}",
+                      "name": "target",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`length` {integer} **Default:** `buffer.length`",
-                      "name": "length",
-                      "type": "integer",
-                      "default": "`buffer.length`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`position` {integer} **Default:** `null`",
-                      "name": "position",
-                      "type": "integer",
-                      "default": "`null`"
+                      "textRaw": "`type` {string}",
+                      "name": "type",
+                      "type": "string"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the number of <code>bytesRead</code>.</p>\n<p>Similar to the above <code>fs.readSync</code> function, this version takes an optional <code>options</code> object.\nIf no <code>options</code> object is specified, it will default with the above values.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_read_fd_buffer_offset_length_position_callback\"><code>fs.read()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.readv(fd, buffers[, position], callback)`",
-          "type": "method",
-          "name": "readv",
-          "meta": {
-            "added": [
-              "v12.17.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_symlink_target_path_type_callback\"><code>fs.symlink()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffers` {ArrayBufferView[]}",
-                  "name": "buffers",
-                  "type": "ArrayBufferView[]"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
+              "textRaw": "`fs.truncateSync(path[, len])`",
+              "type": "method",
+              "name": "truncateSync",
+              "meta": {
+                "added": [
+                  "v0.8.6"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                  "params": [
                     {
-                      "textRaw": "`bytesRead` {integer}",
-                      "name": "bytesRead",
-                      "type": "integer"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`buffers` {ArrayBufferView[]}",
-                      "name": "buffers",
-                      "type": "ArrayBufferView[]"
+                      "textRaw": "`len` {integer} **Default:** `0`",
+                      "name": "len",
+                      "type": "integer",
+                      "default": "`0`"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Read from a file specified by <code>fd</code> and write to an array of <code>ArrayBufferView</code>s\nusing <code>readv()</code>.</p>\n<p><code>position</code> is the offset from the beginning of the file from where data\nshould be read. If <code>typeof position !== 'number'</code>, the data will be read\nfrom the current position.</p>\n<p>The callback will be given three arguments: <code>err</code>, <code>bytesRead</code>, and\n<code>buffers</code>. <code>bytesRead</code> is how many bytes were read from the file.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>bytesRead</code> and <code>buffers</code> properties.</p>"
-        },
-        {
-          "textRaw": "`fs.readvSync(fd, buffers[, position])`",
-          "type": "method",
-          "name": "readvSync",
-          "meta": {
-            "added": [
-              "v12.17.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {number} The number of bytes read.",
-                "name": "return",
-                "type": "number",
-                "desc": "The number of bytes read."
-              },
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffers` {ArrayBufferView[]}",
-                  "name": "buffers",
-                  "type": "ArrayBufferView[]"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_readv_fd_buffers_position_callback\"><code>fs.readv()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.realpath(path[, options], callback)`",
-          "type": "method",
-          "name": "realpath",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v8.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/13028",
-                "description": "Pipe/Socket resolve support was added."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v6.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7899",
-                "description": "Calling `realpath` now works again for various edge cases on Windows."
-              },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3594",
-                "description": "The `cache` parameter was removed."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Truncates the file. Returns <code>undefined</code>. A file descriptor can also be\npassed as the first argument. In this case, <code>fs.ftruncateSync()</code> is called.</p>\n<p>Passing a file descriptor is deprecated and may result in an error being thrown\nin the future.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.unlinkSync(path)`",
+              "type": "method",
+              "name": "unlinkSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>. Returns <code>undefined</code>.</p>"
+            },
+            {
+              "textRaw": "`fs.utimesSync(path, atime, mtime)`",
+              "type": "method",
+              "name": "utimesSync",
+              "meta": {
+                "added": [
+                  "v0.4.2"
+                ],
+                "changes": [
+                  {
+                    "version": "v8.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/11919",
+                    "description": "`NaN`, `Infinity`, and `-Infinity` are no longer valid time specifiers."
+                  },
+                  {
+                    "version": "v7.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10739",
+                    "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol."
+                  },
+                  {
+                    "version": "v4.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/2387",
+                    "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`path` {string|Buffer|URL}",
+                      "name": "path",
+                      "type": "string|Buffer|URL"
                     },
                     {
-                      "textRaw": "`resolvedPath` {string|Buffer}",
-                      "name": "resolvedPath",
-                      "type": "string|Buffer"
+                      "textRaw": "`atime` {number|string|Date}",
+                      "name": "atime",
+                      "type": "number|string|Date"
+                    },
+                    {
+                      "textRaw": "`mtime` {number|string|Date}",
+                      "name": "mtime",
+                      "type": "number|string|Date"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously computes the canonical pathname by resolving <code>.</code>, <code>..</code> and\nsymbolic links.</p>\n<p>A canonical pathname is not necessarily unique. Hard links and bind mounts can\nexpose a file system entity through many pathnames.</p>\n<p>This function behaves like <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>, with some exceptions:</p>\n<ol>\n<li>\n<p>No case conversion is performed on case-insensitive file systems.</p>\n</li>\n<li>\n<p>The maximum number of symbolic links is platform-independent and generally\n(much) higher than what the native <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a> implementation supports.</p>\n</li>\n</ol>\n<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>. May use <code>process.cwd</code>\nto resolve relative paths.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <code>Buffer</code> object.</p>\n<p>If <code>path</code> resolves to a socket or a pipe, the function will return a system\ndependent name for that object.</p>"
-        },
-        {
-          "textRaw": "`fs.realpath.native(path[, options], callback)`",
-          "type": "method",
-          "name": "native",
-          "meta": {
-            "added": [
-              "v9.2.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>.</p>"
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "textRaw": "`fs.writeFileSync(file, data[, options])`",
+              "type": "method",
+              "name": "writeFileSync",
+              "meta": {
+                "added": [
+                  "v0.1.29"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `data` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `data` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `data` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `data` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v5.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/3163",
+                    "description": "The `file` parameter can be a file descriptor now."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`file` {string|Buffer|URL|integer} filename or file descriptor",
+                      "name": "file",
+                      "type": "string|Buffer|URL|integer",
+                      "desc": "filename or file descriptor"
+                    },
+                    {
+                      "textRaw": "`data` {string|Buffer|TypedArray|DataView|Object}",
+                      "name": "data",
+                      "type": "string|Buffer|TypedArray|DataView|Object"
+                    },
+                    {
+                      "textRaw": "`options` {Object|string}",
+                      "name": "options",
+                      "type": "Object|string",
+                      "options": [
+                        {
+                          "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
+                          "name": "encoding",
+                          "type": "string|null",
+                          "default": "`'utf8'`"
+                        },
+                        {
+                          "textRaw": "`mode` {integer} **Default:** `0o666`",
+                          "name": "mode",
+                          "type": "integer",
+                          "default": "`0o666`"
+                        },
+                        {
+                          "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
+                          "name": "flag",
+                          "type": "string",
+                          "default": "`'w'`",
+                          "desc": "See [support of file system `flags`][]."
+                        }
+                      ]
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Returns <code>undefined</code>.</p>\n<p>If <code>data</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<p>The <code>mode</code> option only affects the newly created file. See <a href=\"#fs_fs_open_path_flags_mode_callback\"><code>fs.open()</code></a>\nfor more details.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_writefile_file_data_options_callback\"><code>fs.writeFile()</code></a>.</p>"
+            },
+            {
+              "textRaw": "`fs.writeSync(fd, buffer[, offset[, length[, position]]])`",
+              "type": "method",
+              "name": "writeSync",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `buffer` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `buffer` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v10.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/22150",
+                    "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
+                  },
+                  {
+                    "version": "v7.4.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/10382",
+                    "description": "The `buffer` parameter can now be a `Uint8Array`."
+                  },
+                  {
+                    "version": "v7.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7856",
+                    "description": "The `offset` and `length` parameters are optional now."
+                  }
+                ]
+              },
+              "signatures": [
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number} The number of bytes written.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The number of bytes written."
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
                     },
                     {
-                      "textRaw": "`resolvedPath` {string|Buffer}",
-                      "name": "resolvedPath",
-                      "type": "string|Buffer"
+                      "textRaw": "`buffer` {Buffer|TypedArray|DataView|string|Object}",
+                      "name": "buffer",
+                      "type": "Buffer|TypedArray|DataView|string|Object"
+                    },
+                    {
+                      "textRaw": "`offset` {integer}",
+                      "name": "offset",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`length` {integer}",
+                      "name": "length",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>.</p>\n<p>The <code>callback</code> gets two arguments <code>(err, resolvedPath)</code>.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path passed to the callback. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <code>Buffer</code> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
-        },
-        {
-          "textRaw": "`fs.realpathSync(path[, options])`",
-          "type": "method",
-          "name": "realpathSync",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v8.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/13028",
-                "description": "Pipe/Socket resolve support was added."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v6.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7899",
-                "description": "Calling `realpathSync` now works again for various edge cases on Windows."
-              },
-              {
-                "version": "v6.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3594",
-                "description": "The `cache` parameter was removed."
-              }
-            ]
-          },
-          "signatures": [
+              ],
+              "desc": "<p>If <code>buffer</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_write_fd_buffer_offset_length_position_callback\"><code>fs.write(fd, buffer...)</code></a>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string|Buffer}",
-                "name": "return",
-                "type": "string|Buffer"
+              "textRaw": "`fs.writeSync(fd, string[, position[, encoding]])`",
+              "type": "method",
+              "name": "writeSync",
+              "meta": {
+                "added": [
+                  "v0.11.5"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.12.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34993",
+                    "description": "The `string` parameter will stringify an object with an explicit `toString` function."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31030",
+                    "description": "The `string` parameter won't coerce unsupported input to strings anymore."
+                  },
+                  {
+                    "version": "v7.2.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/7856",
+                    "description": "The `position` parameter is optional now."
+                  }
+                ]
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number} The number of bytes written.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The number of bytes written."
+                  },
+                  "params": [
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`string` {string|Object}",
+                      "name": "string",
+                      "type": "string|Object"
+                    },
+                    {
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`encoding` {string}",
                       "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "type": "string"
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns the resolved pathname.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_realpath_path_options_callback\"><code>fs.realpath()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.realpathSync.native(path[, options])`",
-          "type": "method",
-          "name": "native",
-          "meta": {
-            "added": [
-              "v9.2.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+              ],
+              "desc": "<p>If <code>string</code> is a plain object, it must have an own (not inherited) <code>toString</code>\nfunction property.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_write_fd_string_position_encoding_callback\"><code>fs.write(fd, string...)</code></a>.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {string|Buffer}",
-                "name": "return",
-                "type": "string|Buffer"
+              "textRaw": "`fs.writevSync(fd, buffers[, position])`",
+              "type": "method",
+              "name": "writevSync",
+              "meta": {
+                "added": [
+                  "v12.9.0"
+                ],
+                "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              "signatures": [
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number} The number of bytes written.",
+                    "name": "return",
+                    "type": "number",
+                    "desc": "The number of bytes written."
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`fd` {integer}",
+                      "name": "fd",
+                      "type": "integer"
+                    },
+                    {
+                      "textRaw": "`buffers` {ArrayBufferView[]}",
+                      "name": "buffers",
+                      "type": "ArrayBufferView[]"
+                    },
                     {
-                      "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`"
+                      "textRaw": "`position` {integer}",
+                      "name": "position",
+                      "type": "integer"
                     }
                   ]
                 }
-              ]
+              ],
+              "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_writev_fd_buffers_position_callback\"><code>fs.writev()</code></a>.</p>"
             }
           ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man3/realpath.3.html\"><code>realpath(3)</code></a>.</p>\n<p>Only paths that can be converted to UTF8 strings are supported.</p>\n<p>The optional <code>options</code> argument can be a string specifying an encoding, or an\nobject with an <code>encoding</code> property specifying the character encoding to use for\nthe path returned. If the <code>encoding</code> is set to <code>'buffer'</code>,\nthe path returned will be passed as a <code>Buffer</code> object.</p>\n<p>On Linux, when Node.js is linked against musl libc, the procfs file system must\nbe mounted on <code>/proc</code> in order for this function to work. Glibc does not have\nthis restriction.</p>"
+          "type": "module",
+          "displayName": "Synchronous API"
         },
         {
-          "textRaw": "`fs.rename(oldPath, newPath, callback)`",
-          "type": "method",
-          "name": "rename",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `oldPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+          "textRaw": "Common Objects",
+          "name": "common_objects",
+          "desc": "<p>The common objects are shared by all of the file system API variants\n(promise, callback, and synchronous).</p>",
+          "classes": [
             {
-              "params": [
+              "textRaw": "Class: `fs.Dir`",
+              "type": "class",
+              "name": "fs.Dir",
+              "meta": {
+                "added": [
+                  "v12.12.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>A class representing a directory stream.</p>\n<p>Created by <a href=\"#fs_fs_opendir_path_options_callback\"><code>fs.opendir()</code></a>, <a href=\"#fs_fs_opendirsync_path_options\"><code>fs.opendirSync()</code></a>, or\n<a href=\"#fs_fspromises_opendir_path_options\"><code>fsPromises.opendir()</code></a>.</p>\n<pre><code class=\"language-mjs\">import { opendir } from 'fs/promises';\n\ntry {\n  const dir = await opendir('./');\n  for await (const dirent of dir)\n    console.log(dirent.name);\n} catch (err) {\n  console.error(err);\n}\n</code></pre>\n<p>When using the async iterator, the <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a> object will be automatically\nclosed after the iterator exits.</p>",
+              "methods": [
                 {
-                  "textRaw": "`oldPath` {string|Buffer|URL}",
-                  "name": "oldPath",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`dir.close()`",
+                  "type": "method",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {Promise}",
+                        "name": "return",
+                        "type": "Promise"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Asynchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>\n<p>A promise is returned that will be resolved after the resource has been\nclosed.</p>"
                 },
                 {
-                  "textRaw": "`newPath` {string|Buffer|URL}",
-                  "name": "newPath",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`dir.close(callback)`",
+                  "type": "method",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`callback` {Function}",
+                          "name": "callback",
+                          "type": "Function",
+                          "options": [
+                            {
+                              "textRaw": "`err` {Error}",
+                              "name": "err",
+                              "type": "Error"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Asynchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>\n<p>The <code>callback</code> will be called after the resource handle has been closed.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "`dir.closeSync()`",
+                  "type": "method",
+                  "name": "closeSync",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "params": []
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously rename file at <code>oldPath</code> to the pathname provided\nas <code>newPath</code>. In the case that <code>newPath</code> already exists, it will\nbe overwritten. If there is a directory at <code>newPath</code>, an error will\nbe raised instead. No arguments other than a possible exception are\ngiven to the completion callback.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>.</p>\n<pre><code class=\"language-js\">fs.rename('oldFile.txt', 'newFile.txt', (err) => {\n  if (err) throw err;\n  console.log('Rename complete!');\n});\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.renameSync(oldPath, newPath)`",
-          "type": "method",
-          "name": "renameSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `oldPath` and `newPath` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`oldPath` {string|Buffer|URL}",
-                  "name": "oldPath",
-                  "type": "string|Buffer|URL"
+                  ],
+                  "desc": "<p>Synchronously close the directory's underlying resource handle.\nSubsequent reads will result in errors.</p>"
                 },
                 {
-                  "textRaw": "`newPath` {string|Buffer|URL}",
-                  "name": "newPath",
-                  "type": "string|Buffer|URL"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.rmdir(path[, options], callback)`",
-          "type": "method",
-          "name": "rmdir",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30644",
-                "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
-              },
-              {
-                "version": "v12.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29168",
-                "description": "The `recursive`, `maxBusyTries`, and `emfileWait` options are now supported."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameters can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "stability": 1,
-          "stabilityText": "Recursive removal is experimental.",
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`dir.read()`",
+                  "type": "method",
+                  "name": "read",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {Promise} containing {fs.Dirent|null}",
+                        "name": "return",
+                        "type": "Promise",
+                        "desc": "containing {fs.Dirent|null}"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Asynchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>.</p>\n<p>A promise is returned that will be resolved with an <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>, or <code>null</code>\nif there are no more directory entries to read.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory might not be\nincluded in the iteration results.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
-                      "name": "maxRetries",
-                      "type": "integer",
-                      "default": "`0`",
-                      "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
-                    },
-                    {
-                      "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure."
-                    },
+                  "textRaw": "`dir.read(callback)`",
+                  "type": "method",
+                  "name": "read",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
-                      "name": "retryDelay",
-                      "type": "integer",
-                      "default": "`100`",
-                      "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                      "params": [
+                        {
+                          "textRaw": "`callback` {Function}",
+                          "name": "callback",
+                          "type": "Function",
+                          "options": [
+                            {
+                              "textRaw": "`err` {Error}",
+                              "name": "err",
+                              "type": "Error"
+                            },
+                            {
+                              "textRaw": "`dirent` {fs.Dirent|null}",
+                              "name": "dirent",
+                              "type": "fs.Dirent|null"
+                            }
+                          ]
+                        }
+                      ]
                     }
-                  ]
+                  ],
+                  "desc": "<p>Asynchronously read the next directory entry via <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> as an\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>.</p>\n<p>After the read is completed, the <code>callback</code> will be called with an\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>, or <code>null</code> if there are no more directory entries to read.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory might not be\nincluded in the iteration results.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "`dir.readSync()`",
+                  "type": "method",
+                  "name": "readSync",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "return": {
+                        "textRaw": "Returns: {fs.Dirent|null}",
+                        "name": "return",
+                        "type": "fs.Dirent|null"
+                      },
+                      "params": []
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/rmdir.2.html\"><code>rmdir(2)</code></a>. No arguments other than a possible exception are given\nto the completion callback.</p>\n<p>Using <code>fs.rmdir()</code> on a file (not a directory) results in an <code>ENOENT</code> error on\nWindows and an <code>ENOTDIR</code> error on POSIX.</p>"
-        },
-        {
-          "textRaw": "`fs.rmdirSync(path[, options])`",
-          "type": "method",
-          "name": "rmdirSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v12.16.0",
-                "pr-url": "https://github.com/nodejs/node/pull/30644",
-                "description": "The `maxBusyTries` option is renamed to `maxRetries`, and its default is 0. The `emfileWait` option has been removed, and `EMFILE` errors use the same retry logic as other errors. The `retryDelay` option is now supported. `ENFILE` errors are now retried."
-              },
-              {
-                "version": "v12.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/29168",
-                "description": "The `recursive`, `maxBusyTries`, and `emfileWait` options are now supported."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameters can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "stability": 1,
-          "stabilityText": "Recursive removal is experimental.",
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  ],
+                  "desc": "<p>Synchronously read the next directory entry as an <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>. See the\nPOSIX <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> documentation for more detail.</p>\n<p>If there are no more directory entries to read, <code>null</code> will be returned.</p>\n<p>Directory entries returned by this function are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory might not be\nincluded in the iteration results.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`. **Default:** `0`.",
-                      "name": "maxRetries",
-                      "type": "integer",
-                      "default": "`0`",
-                      "desc": "If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or `EPERM` error is encountered, Node.js will retry the operation with a linear backoff wait of `retryDelay` ms longer on each try. This option represents the number of retries. This option is ignored if the `recursive` option is not `true`."
-                    },
-                    {
-                      "textRaw": "`recursive` {boolean} If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure. **Default:** `false`.",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "If `true`, perform a recursive directory removal. In recursive mode, errors are not reported if `path` does not exist, and operations are retried on failure."
-                    },
+                  "textRaw": "`dir[Symbol.asyncIterator]()`",
+                  "type": "method",
+                  "name": "[Symbol.asyncIterator]",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`retryDelay` {integer} The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`. **Default:** `100`.",
-                      "name": "retryDelay",
-                      "type": "integer",
-                      "default": "`100`",
-                      "desc": "The amount of time in milliseconds to wait between retries. This option is ignored if the `recursive` option is not `true`."
+                      "return": {
+                        "textRaw": "Returns: {AsyncIterator} of {fs.Dirent}",
+                        "name": "return",
+                        "type": "AsyncIterator",
+                        "desc": "of {fs.Dirent}"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Asynchronously iterates over the directory until all entries have\nbeen read. Refer to the POSIX <a href=\"http://man7.org/linux/man-pages/man3/readdir.3.html\"><code>readdir(3)</code></a> documentation for more detail.</p>\n<p>Entries returned by the async iterator are always an <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a>.\nThe <code>null</code> case from <code>dir.read()</code> is handled internally.</p>\n<p>See <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a> for an example.</p>\n<p>Directory entries returned by this iterator are in no particular order as\nprovided by the operating system's underlying directory mechanisms.\nEntries added or removed while iterating over the directory might not be\nincluded in the iteration results.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`path` {string}",
+                  "type": "string",
+                  "name": "path",
+                  "meta": {
+                    "added": [
+                      "v12.12.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The read-only path of this directory as was provided to <a href=\"#fs_fs_opendir_path_options_callback\"><code>fs.opendir()</code></a>,\n<a href=\"#fs_fs_opendirsync_path_options\"><code>fs.opendirSync()</code></a>, or <a href=\"#fs_fspromises_opendir_path_options\"><code>fsPromises.opendir()</code></a>.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/rmdir.2.html\"><code>rmdir(2)</code></a>. Returns <code>undefined</code>.</p>\n<p>Using <code>fs.rmdirSync()</code> on a file (not a directory) results in an <code>ENOENT</code> error\non Windows and an <code>ENOTDIR</code> error on POSIX.</p>"
-        },
-        {
-          "textRaw": "`fs.stat(path[, options], callback)`",
-          "type": "method",
-          "name": "stat",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "params": [
+              "textRaw": "Class: `fs.Dirent`",
+              "type": "class",
+              "name": "fs.Dirent",
+              "meta": {
+                "added": [
+                  "v10.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>A representation of a directory entry, which can be a file or a subdirectory\nwithin the directory, as returned by reading from an <a href=\"fs.html#fs_class_fs_dir\" class=\"type\">&lt;fs.Dir&gt;</a>. The\ndirectory entry is a combination of the file name and file type pairs.</p>\n<p>Additionally, when <a href=\"#fs_fs_readdir_path_options_callback\"><code>fs.readdir()</code></a> or <a href=\"#fs_fs_readdirsync_path_options\"><code>fs.readdirSync()</code></a> is called with\nthe <code>withFileTypes</code> option set to <code>true</code>, the resulting array is filled with\n<a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> objects, rather than strings or <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>s.</p>",
+              "methods": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`dirent.isBlockDevice()`",
+                  "type": "method",
+                  "name": "isBlockDevice",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a block device.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "textRaw": "`dirent.isCharacterDevice()`",
+                  "type": "method",
+                  "name": "isCharacterDevice",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a character device.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
+                  "textRaw": "`dirent.isDirectory()`",
+                  "type": "method",
+                  "name": "isDirectory",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`stats` {fs.Stats}",
-                      "name": "stats",
-                      "type": "fs.Stats"
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/stat.2.html\"><code>stat(2)</code></a>. The callback gets two arguments <code>(err, stats)</code> where\n<code>stats</code> is an <a href=\"#fs_class_fs_stats\"><code>fs.Stats</code></a> object.</p>\n<p>In case of an error, the <code>err.code</code> will be one of <a href=\"errors.html#errors_common_system_errors\">Common System Errors</a>.</p>\n<p>Using <code>fs.stat()</code> to check for the existence of a file before calling\n<code>fs.open()</code>, <code>fs.readFile()</code> or <code>fs.writeFile()</code> is not recommended.\nInstead, user code should open/read/write the file directly and handle the\nerror raised if the file is not available.</p>\n<p>To check if a file exists without manipulating it afterwards, <a href=\"#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a>\nis recommended.</p>\n<p>For example, given the following directory structure:</p>\n<pre><code class=\"language-text\">- txtDir\n-- file.txt\n- app.js\n</code></pre>\n<p>The next program will check for the stats of the given paths:</p>\n<pre><code class=\"language-js\">const fs = require('fs');\n\nconst pathsToCheck = ['./txtDir', './txtDir/file.txt'];\n\nfor (let i = 0; i &#x3C; pathsToCheck.length; i++) {\n  fs.stat(pathsToCheck[i], function(err, stats) {\n    console.log(stats.isDirectory());\n    console.log(stats);\n  });\n}\n</code></pre>\n<p>The resulting output will resemble:</p>\n<pre><code class=\"language-console\">true\nStats {\n  dev: 16777220,\n  mode: 16877,\n  nlink: 3,\n  uid: 501,\n  gid: 20,\n  rdev: 0,\n  blksize: 4096,\n  ino: 14214262,\n  size: 96,\n  blocks: 0,\n  atimeMs: 1561174653071.963,\n  mtimeMs: 1561174614583.3518,\n  ctimeMs: 1561174626623.5366,\n  birthtimeMs: 1561174126937.2893,\n  atime: 2019-06-22T03:37:33.072Z,\n  mtime: 2019-06-22T03:36:54.583Z,\n  ctime: 2019-06-22T03:37:06.624Z,\n  birthtime: 2019-06-22T03:28:46.937Z\n}\nfalse\nStats {\n  dev: 16777220,\n  mode: 33188,\n  nlink: 1,\n  uid: 501,\n  gid: 20,\n  rdev: 0,\n  blksize: 4096,\n  ino: 14214074,\n  size: 8,\n  blocks: 8,\n  atimeMs: 1561174616618.8555,\n  mtimeMs: 1561174614584,\n  ctimeMs: 1561174614583.8145,\n  birthtimeMs: 1561174007710.7478,\n  atime: 2019-06-22T03:36:56.619Z,\n  mtime: 2019-06-22T03:36:54.584Z,\n  ctime: 2019-06-22T03:36:54.584Z,\n  birthtime: 2019-06-22T03:26:47.711Z\n}\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.statSync(path[, options])`",
-          "type": "method",
-          "name": "statSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "Accepts an additional `options` object to specify whether the numeric values returned should be bigint."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {fs.Stats}",
-                "name": "return",
-                "type": "fs.Stats"
-              },
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a file system\ndirectory.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "textRaw": "`dirent.isFIFO()`",
+                  "type": "method",
+                  "name": "isFIFO",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`bigint` {boolean} Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`. **Default:** `false`.",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Whether the numeric values in the returned [`fs.Stats`][] object should be `bigint`."
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/stat.2.html\"><code>stat(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.symlink(target, path[, type], callback)`",
-          "type": "method",
-          "name": "symlink",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `target` and `path` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v12.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23724",
-                "description": "If the `type` argument is left undefined, Node will autodetect `target` type and automatically select `dir` or `file`"
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`target` {string|Buffer|URL}",
-                  "name": "target",
-                  "type": "string|Buffer|URL"
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a first-in-first-out\n(FIFO) pipe.</p>"
                 },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`dirent.isFile()`",
+                  "type": "method",
+                  "name": "isFile",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a regular file.</p>"
                 },
                 {
-                  "textRaw": "`type` {string}",
-                  "name": "type",
-                  "type": "string"
+                  "textRaw": "`dirent.isSocket()`",
+                  "type": "method",
+                  "name": "isSocket",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a socket.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "`dirent.isSymbolicLink()`",
+                  "type": "method",
+                  "name": "isSymbolicLink",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object describes a symbolic link.</p>"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/symlink.2.html\"><code>symlink(2)</code></a> which creates the link called <code>path</code> pointing to\n<code>target</code>. No arguments other than a possible exception are given to the\ncompletion callback.</p>\n<p>The <code>type</code> argument is only available on Windows and ignored on other platforms.\nIt can be set to <code>'dir'</code>, <code>'file'</code>, or <code>'junction'</code>. If the <code>type</code> argument is\nnot set, Node.js will autodetect <code>target</code> type and use <code>'file'</code> or <code>'dir'</code>. If\nthe <code>target</code> does not exist, <code>'file'</code> will be used. Windows junction points\nrequire the destination path to be absolute. When using <code>'junction'</code>, the\n<code>target</code> argument will automatically be normalized to absolute path.</p>\n<p>Relative targets are relative to the link’s parent directory.</p>\n<pre><code class=\"language-js\">fs.symlink('./mew', './example/mewtwo', callback);\n</code></pre>\n<p>The above example creates a symbolic link <code>mewtwo</code> in the <code>example</code> which points\nto <code>mew</code> in the same directory:</p>\n<pre><code class=\"language-bash\">$ tree example/\nexample/\n├── mew\n└── mewtwo -> ./mew\n</code></pre>"
-        },
-        {
-          "textRaw": "`fs.symlinkSync(target, path[, type])`",
-          "type": "method",
-          "name": "symlinkSync",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `target` and `path` parameters can be WHATWG `URL` objects using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v12.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23724",
-                "description": "If the `type` argument is left undefined, Node will autodetect `target` type and automatically select `dir` or `file`"
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`target` {string|Buffer|URL}",
-                  "name": "target",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
+              ],
+              "properties": [
                 {
-                  "textRaw": "`type` {string}",
-                  "name": "type",
-                  "type": "string"
+                  "textRaw": "`name` {string|Buffer}",
+                  "type": "string|Buffer",
+                  "name": "name",
+                  "meta": {
+                    "added": [
+                      "v10.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The file name that this <a href=\"fs.html#fs_class_fs_dirent\" class=\"type\">&lt;fs.Dirent&gt;</a> object refers to. The type of this\nvalue is determined by the <code>options.encoding</code> passed to <a href=\"#fs_fs_readdir_path_options_callback\"><code>fs.readdir()</code></a> or\n<a href=\"#fs_fs_readdirsync_path_options\"><code>fs.readdirSync()</code></a>.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_symlink_target_path_type_callback\"><code>fs.symlink()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.truncate(path[, len], callback)`",
-          "type": "method",
-          "name": "truncate",
-          "meta": {
-            "added": [
-              "v0.8.6"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "params": [
+              "textRaw": "Class: `fs.FSWatcher`",
+              "type": "class",
+              "name": "fs.FSWatcher",
+              "meta": {
+                "added": [
+                  "v0.5.8"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Extends <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>A successful call to <a href=\"#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> method will return a new <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a>\nobject.</p>\n<p>All <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> objects emit a <code>'change'</code> event whenever a specific watched\nfile is modified.</p>",
+              "events": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "Event: `'change'`",
+                  "type": "event",
+                  "name": "change",
+                  "meta": {
+                    "added": [
+                      "v0.5.8"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`eventType` {string} The type of change event that has occurred",
+                      "name": "eventType",
+                      "type": "string",
+                      "desc": "The type of change event that has occurred"
+                    },
+                    {
+                      "textRaw": "`filename` {string|Buffer} The filename that changed (if relevant/available)",
+                      "name": "filename",
+                      "type": "string|Buffer",
+                      "desc": "The filename that changed (if relevant/available)"
+                    }
+                  ],
+                  "desc": "<p>Emitted when something changes in a watched directory or file.\nSee more details in <a href=\"#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a>.</p>\n<p>The <code>filename</code> argument may not be provided depending on operating system\nsupport. If <code>filename</code> is provided, it will be provided as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> if\n<code>fs.watch()</code> is called with its <code>encoding</code> option set to <code>'buffer'</code>, otherwise\n<code>filename</code> will be a UTF-8 string.</p>\n<pre><code class=\"language-mjs\">import { watch } from 'fs';\n// Example when handled through fs.watch() listener\nwatch('./tmp', { encoding: 'buffer' }, (eventType, filename) => {\n  if (filename) {\n    console.log(filename);\n    // Prints: &#x3C;Buffer ...>\n  }\n});\n</code></pre>"
                 },
                 {
-                  "textRaw": "`len` {integer} **Default:** `0`",
-                  "name": "len",
-                  "type": "integer",
-                  "default": "`0`"
+                  "textRaw": "Event: `'close'`",
+                  "type": "event",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v10.0.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the watcher stops watching for changes. The closed\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object is no longer usable in the event handler.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "Event: `'error'`",
+                  "type": "event",
+                  "name": "error",
+                  "meta": {
+                    "added": [
+                      "v0.5.8"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
+                      "textRaw": "`error` {Error}",
+                      "name": "error",
                       "type": "Error"
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronous <a href=\"http://man7.org/linux/man-pages/man2/truncate.2.html\"><code>truncate(2)</code></a>. No arguments other than a possible exception are\ngiven to the completion callback. A file descriptor can also be passed as the\nfirst argument. In this case, <code>fs.ftruncate()</code> is called.</p>\n<p>Passing a file descriptor is deprecated and may result in an error being thrown\nin the future.</p>"
-        },
-        {
-          "textRaw": "`fs.truncateSync(path[, len])`",
-          "type": "method",
-          "name": "truncateSync",
-          "meta": {
-            "added": [
-              "v0.8.6"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`len` {integer} **Default:** `0`",
-                  "name": "len",
-                  "type": "integer",
-                  "default": "`0`"
+                  ],
+                  "desc": "<p>Emitted when an error occurs while watching the file. The errored\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object is no longer usable in the event handler.</p>"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/truncate.2.html\"><code>truncate(2)</code></a>. Returns <code>undefined</code>. A file descriptor can also be\npassed as the first argument. In this case, <code>fs.ftruncateSync()</code> is called.</p>\n<p>Passing a file descriptor is deprecated and may result in an error being thrown\nin the future.</p>"
-        },
-        {
-          "textRaw": "`fs.unlink(path, callback)`",
-          "type": "method",
-          "name": "unlink",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+              ],
+              "methods": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`watcher.close()`",
+                  "type": "method",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v0.5.8"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Stop watching for changes on the given <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a>. Once stopped, the\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object is no longer usable.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "`watcher.ref()`",
+                  "type": "method",
+                  "name": "ref",
+                  "meta": {
+                    "added": [
+                      "v14.3.0",
+                      "v12.20.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "return": {
+                        "textRaw": "Returns: {fs.FSWatcher}",
+                        "name": "return",
+                        "type": "fs.FSWatcher"
+                      },
+                      "params": []
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Asynchronously removes a file or symbolic link. No arguments other than a\npossible exception are given to the completion callback.</p>\n<pre><code class=\"language-js\">// Assuming that 'path/file.txt' is a regular file.\nfs.unlink('path/file.txt', (err) => {\n  if (err) throw err;\n  console.log('path/file.txt was deleted');\n});\n</code></pre>\n<p><code>fs.unlink()</code> will not work on a directory, empty or otherwise. To remove a\ndirectory, use <a href=\"#fs_fs_rmdir_path_options_callback\"><code>fs.rmdir()</code></a>.</p>\n<p>See also: <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.unlinkSync(path)`",
-          "type": "method",
-          "name": "unlinkSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  ],
+                  "desc": "<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the\n<a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> is active. Calling <code>watcher.ref()</code> multiple times will have\nno effect.</p>\n<p>By default, all <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> objects are \"ref'ed\", making it normally\nunnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been\ncalled previously.</p>"
+                },
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`watcher.unref()`",
+                  "type": "method",
+                  "name": "unref",
+                  "meta": {
+                    "added": [
+                      "v14.3.0",
+                      "v12.20.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {fs.FSWatcher}",
+                        "name": "return",
+                        "type": "fs.FSWatcher"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>When called, the active <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object will not require the Node.js\nevent loop to remain active. If there is no other activity keeping the\nevent loop running, the process may exit before the <a href=\"fs.html#fs_class_fs_fswatcher\" class=\"type\">&lt;fs.FSWatcher&gt;</a> object's\ncallback is invoked. Calling <code>watcher.unref()</code> multiple times will have\nno effect.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Synchronous <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>. Returns <code>undefined</code>.</p>"
-        },
-        {
-          "textRaw": "`fs.unwatchFile(filename[, listener])`",
-          "type": "method",
-          "name": "unwatchFile",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": []
-          },
-          "signatures": [
+            },
             {
-              "params": [
+              "textRaw": "Class: `fs.StatWatcher`",
+              "type": "class",
+              "name": "fs.StatWatcher",
+              "meta": {
+                "added": [
+                  "v14.3.0",
+                  "v12.20.0"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Extends <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>A successful call to <code>fs.watchFile()</code> method will return a new <a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a>\nobject.</p>",
+              "methods": [
                 {
-                  "textRaw": "`filename` {string|Buffer|URL}",
-                  "name": "filename",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`watcher.ref()`",
+                  "type": "method",
+                  "name": "ref",
+                  "meta": {
+                    "added": [
+                      "v14.3.0",
+                      "v12.20.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {fs.StatWatcher}",
+                        "name": "return",
+                        "type": "fs.StatWatcher"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>When called, requests that the Node.js event loop <em>not</em> exit so long as the\n<a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a> is active. Calling <code>watcher.ref()</code> multiple times will have\nno effect.</p>\n<p>By default, all <a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a> objects are \"ref'ed\", making it normally\nunnecessary to call <code>watcher.ref()</code> unless <code>watcher.unref()</code> had been\ncalled previously.</p>"
                 },
                 {
-                  "textRaw": "`listener` {Function} Optional, a listener previously attached using `fs.watchFile()`",
-                  "name": "listener",
-                  "type": "Function",
-                  "desc": "Optional, a listener previously attached using `fs.watchFile()`"
+                  "textRaw": "`watcher.unref()`",
+                  "type": "method",
+                  "name": "unref",
+                  "meta": {
+                    "added": [
+                      "v14.3.0",
+                      "v12.20.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {fs.StatWatcher}",
+                        "name": "return",
+                        "type": "fs.StatWatcher"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>When called, the active <a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a> object will not require the Node.js\nevent loop to remain active. If there is no other activity keeping the\nevent loop running, the process may exit before the <a href=\"fs.html#fs_class_fs_statwatcher\" class=\"type\">&lt;fs.StatWatcher&gt;</a> object's\ncallback is invoked. Calling <code>watcher.unref()</code> multiple times will have\nno effect.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Stop watching for changes on <code>filename</code>. If <code>listener</code> is specified, only that\nparticular listener is removed. Otherwise, <em>all</em> listeners are removed,\neffectively stopping watching of <code>filename</code>.</p>\n<p>Calling <code>fs.unwatchFile()</code> with a filename that is not being watched is a\nno-op, not an error.</p>\n<p>Using <a href=\"#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile()</code> and\n<code>fs.unwatchFile()</code>. <code>fs.watch()</code> should be used instead of <code>fs.watchFile()</code>\nand <code>fs.unwatchFile()</code> when possible.</p>"
-        },
-        {
-          "textRaw": "`fs.utimes(path, atime, mtime, callback)`",
-          "type": "method",
-          "name": "utimes",
-          "meta": {
-            "added": [
-              "v0.4.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v8.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/11919",
-                "description": "`NaN`, `Infinity`, and `-Infinity` are no longer valid time specifiers."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v4.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2387",
-                "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "params": [
-                {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
-                },
-                {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
-                },
+              "textRaw": "Class: `fs.ReadStream`",
+              "type": "class",
+              "name": "fs.ReadStream",
+              "meta": {
+                "added": [
+                  "v0.1.93"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_class_stream_readable\" class=\"type\">&lt;stream.Readable&gt;</a></li>\n</ul>\n<p>Instances of <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a> are created and returned using the\n<a href=\"#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a> function.</p>",
+              "events": [
                 {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
+                  "textRaw": "Event: `'close'`",
+                  "type": "event",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a>'s underlying file descriptor has been closed.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+                  "textRaw": "Event: `'open'`",
+                  "type": "event",
+                  "name": "open",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "`fd` {integer} Integer file descriptor used by the {fs.ReadStream}.",
+                      "name": "fd",
+                      "type": "integer",
+                      "desc": "Integer file descriptor used by the {fs.ReadStream}."
                     }
-                  ]
+                  ],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a>'s file descriptor has been opened.</p>"
+                },
+                {
+                  "textRaw": "Event: `'ready'`",
+                  "type": "event",
+                  "name": "ready",
+                  "meta": {
+                    "added": [
+                      "v9.11.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_readstream\" class=\"type\">&lt;fs.ReadStream&gt;</a> is ready to be used.</p>\n<p>Fires immediately after <code>'open'</code>.</p>"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Change the file system timestamps of the object referenced by <code>path</code>.</p>\n<p>The <code>atime</code> and <code>mtime</code> arguments follow these rules:</p>\n<ul>\n<li>Values can be either numbers representing Unix epoch time in seconds,\n<code>Date</code>s, or a numeric string like <code>'123456789.0'</code>.</li>\n<li>If the value can not be converted to a number, or is <code>NaN</code>, <code>Infinity</code> or\n<code>-Infinity</code>, an <code>Error</code> will be thrown.</li>\n</ul>"
-        },
-        {
-          "textRaw": "`fs.utimesSync(path, atime, mtime)`",
-          "type": "method",
-          "name": "utimesSync",
-          "meta": {
-            "added": [
-              "v0.4.2"
-            ],
-            "changes": [
-              {
-                "version": "v8.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/11919",
-                "description": "`NaN`, `Infinity`, and `-Infinity` are no longer valid time specifiers."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `path` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v4.1.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2387",
-                "description": "Numeric strings, `NaN` and `Infinity` are now allowed time specifiers."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+              ],
+              "properties": [
                 {
-                  "textRaw": "`path` {string|Buffer|URL}",
-                  "name": "path",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`bytesRead` {number}",
+                  "type": "number",
+                  "name": "bytesRead",
+                  "meta": {
+                    "added": [
+                      "v6.4.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The number of bytes that have been read so far.</p>"
                 },
                 {
-                  "textRaw": "`atime` {number|string|Date}",
-                  "name": "atime",
-                  "type": "number|string|Date"
+                  "textRaw": "`path` {string|Buffer}",
+                  "type": "string|Buffer",
+                  "name": "path",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The path to the file the stream is reading from as specified in the first\nargument to <code>fs.createReadStream()</code>. If <code>path</code> is passed as a string, then\n<code>readStream.path</code> will be a string. If <code>path</code> is passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>, then\n<code>readStream.path</code> will be a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>"
                 },
                 {
-                  "textRaw": "`mtime` {number|string|Date}",
-                  "name": "mtime",
-                  "type": "number|string|Date"
+                  "textRaw": "`pending` {boolean}",
+                  "type": "boolean",
+                  "name": "pending",
+                  "meta": {
+                    "added": [
+                      "v11.2.0",
+                      "v10.16.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This property is <code>true</code> if the underlying file has not been opened yet,\ni.e. before the <code>'ready'</code> event is emitted.</p>"
                 }
               ]
-            }
-          ],
-          "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_utimes_path_atime_mtime_callback\"><code>fs.utimes()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.watch(filename[, options][, listener])`",
-          "type": "method",
-          "name": "watch",
-          "meta": {
-            "added": [
-              "v0.5.10"
-            ],
-            "changes": [
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `filename` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7831",
-                "description": "The passed `options` object will never be modified."
-              }
-            ]
-          },
-          "signatures": [
+            },
             {
-              "return": {
-                "textRaw": "Returns: {fs.FSWatcher}",
-                "name": "return",
-                "type": "fs.FSWatcher"
+              "textRaw": "Class: `fs.Stats`",
+              "type": "class",
+              "name": "fs.Stats",
+              "meta": {
+                "added": [
+                  "v0.1.21"
+                ],
+                "changes": [
+                  {
+                    "version": "v8.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/13173",
+                    "description": "Added times as numbers."
+                  }
+                ]
               },
-              "params": [
+              "desc": "<p>A <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object provides information about a file.</p>\n<p>Objects returned from <a href=\"#fs_fs_stat_path_options_callback\"><code>fs.stat()</code></a>, <a href=\"#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a> and <a href=\"#fs_fs_fstat_fd_options_callback\"><code>fs.fstat()</code></a> and\ntheir synchronous counterparts are of this type.\nIf <code>bigint</code> in the <code>options</code> passed to those methods is true, the numeric values\nwill be <code>bigint</code> instead of <code>number</code>, and the object will contain additional\nnanosecond-precision properties suffixed with <code>Ns</code>.</p>\n<pre><code class=\"language-console\">Stats {\n  dev: 2114,\n  ino: 48064969,\n  mode: 33188,\n  nlink: 1,\n  uid: 85,\n  gid: 100,\n  rdev: 0,\n  size: 527,\n  blksize: 4096,\n  blocks: 8,\n  atimeMs: 1318289051000.1,\n  mtimeMs: 1318289051000.1,\n  ctimeMs: 1318289051000.1,\n  birthtimeMs: 1318289051000.1,\n  atime: Mon, 10 Oct 2011 23:24:11 GMT,\n  mtime: Mon, 10 Oct 2011 23:24:11 GMT,\n  ctime: Mon, 10 Oct 2011 23:24:11 GMT,\n  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }\n</code></pre>\n<p><code>bigint</code> version:</p>\n<pre><code class=\"language-console\">BigIntStats {\n  dev: 2114n,\n  ino: 48064969n,\n  mode: 33188n,\n  nlink: 1n,\n  uid: 85n,\n  gid: 100n,\n  rdev: 0n,\n  size: 527n,\n  blksize: 4096n,\n  blocks: 8n,\n  atimeMs: 1318289051000n,\n  mtimeMs: 1318289051000n,\n  ctimeMs: 1318289051000n,\n  birthtimeMs: 1318289051000n,\n  atimeNs: 1318289051000000000n,\n  mtimeNs: 1318289051000000000n,\n  ctimeNs: 1318289051000000000n,\n  birthtimeNs: 1318289051000000000n,\n  atime: Mon, 10 Oct 2011 23:24:11 GMT,\n  mtime: Mon, 10 Oct 2011 23:24:11 GMT,\n  ctime: Mon, 10 Oct 2011 23:24:11 GMT,\n  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }\n</code></pre>",
+              "methods": [
+                {
+                  "textRaw": "`stats.isBlockDevice()`",
+                  "type": "method",
+                  "name": "isBlockDevice",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a block device.</p>"
+                },
                 {
-                  "textRaw": "`filename` {string|Buffer|URL}",
-                  "name": "filename",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`stats.isCharacterDevice()`",
+                  "type": "method",
+                  "name": "isCharacterDevice",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a character device.</p>"
                 },
                 {
-                  "textRaw": "`options` {string|Object}",
-                  "name": "options",
-                  "type": "string|Object",
-                  "options": [
+                  "textRaw": "`stats.isDirectory()`",
+                  "type": "method",
+                  "name": "isDirectory",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`persistent` {boolean} Indicates whether the process should continue to run as long as files are being watched. **Default:** `true`.",
-                      "name": "persistent",
-                      "type": "boolean",
-                      "default": "`true`",
-                      "desc": "Indicates whether the process should continue to run as long as files are being watched."
-                    },
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a file system directory.</p>\n<p>If the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object was obtained from <a href=\"#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a>, this method will\nalways return <code>false</code>. This is because <a href=\"#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a> returns information\nabout a symbolic link itself and not the path it resolves to.</p>"
+                },
+                {
+                  "textRaw": "`stats.isFIFO()`",
+                  "type": "method",
+                  "name": "isFIFO",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`recursive` {boolean} Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [Caveats][]). **Default:** `false`.",
-                      "name": "recursive",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Indicates whether all subdirectories should be watched, or only the current directory. This applies when a directory is specified, and only on supported platforms (See [Caveats][])."
-                    },
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a first-in-first-out (FIFO)\npipe.</p>"
+                },
+                {
+                  "textRaw": "`stats.isFile()`",
+                  "type": "method",
+                  "name": "isFile",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`encoding` {string} Specifies the character encoding to be used for the filename passed to the listener. **Default:** `'utf8'`.",
-                      "name": "encoding",
-                      "type": "string",
-                      "default": "`'utf8'`",
-                      "desc": "Specifies the character encoding to be used for the filename passed to the listener."
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a regular file.</p>"
                 },
                 {
-                  "textRaw": "`listener` {Function|undefined} **Default:** `undefined`",
-                  "name": "listener",
-                  "type": "Function|undefined",
-                  "default": "`undefined`",
-                  "options": [
+                  "textRaw": "`stats.isSocket()`",
+                  "type": "method",
+                  "name": "isSocket",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`eventType` {string}",
-                      "name": "eventType",
-                      "type": "string"
-                    },
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a socket.</p>"
+                },
+                {
+                  "textRaw": "`stats.isSymbolicLink()`",
+                  "type": "method",
+                  "name": "isSymbolicLink",
+                  "meta": {
+                    "added": [
+                      "v0.1.10"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
                     {
-                      "textRaw": "`filename` {string|Buffer}",
-                      "name": "filename",
-                      "type": "string|Buffer"
+                      "return": {
+                        "textRaw": "Returns: {boolean}",
+                        "name": "return",
+                        "type": "boolean"
+                      },
+                      "params": []
                     }
-                  ]
+                  ],
+                  "desc": "<p>Returns <code>true</code> if the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object describes a symbolic link.</p>\n<p>This method is only valid when using <a href=\"#fs_fs_lstat_path_options_callback\"><code>fs.lstat()</code></a>.</p>"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Watch for changes on <code>filename</code>, where <code>filename</code> is either a file or a\ndirectory.</p>\n<p>The second argument is optional. If <code>options</code> is provided as a string, it\nspecifies the <code>encoding</code>. Otherwise <code>options</code> should be passed as an object.</p>\n<p>The listener callback gets two arguments <code>(eventType, filename)</code>. <code>eventType</code>\nis either <code>'rename'</code> or <code>'change'</code>, and <code>filename</code> is the name of the file\nwhich triggered the event.</p>\n<p>On most platforms, <code>'rename'</code> is emitted whenever a filename appears or\ndisappears in the directory.</p>\n<p>The listener callback is attached to the <code>'change'</code> event fired by\n<a href=\"#fs_class_fs_fswatcher\"><code>fs.FSWatcher</code></a>, but it is not the same thing as the <code>'change'</code> value of\n<code>eventType</code>.</p>",
-          "miscs": [
-            {
-              "textRaw": "Caveats",
-              "name": "Caveats",
-              "type": "misc",
-              "desc": "<p>The <code>fs.watch</code> API is not 100% consistent across platforms, and is\nunavailable in some situations.</p>\n<p>The recursive option is only supported on macOS and Windows.</p>\n<p>On Windows, no events will be emitted if the watched directory is moved or\nrenamed. An <code>EPERM</code> error is reported when the watched directory is deleted.</p>",
-              "miscs": [
+              ],
+              "properties": [
                 {
-                  "textRaw": "Availability",
-                  "name": "Availability",
-                  "type": "misc",
-                  "desc": "<p>This feature depends on the underlying operating system providing a way\nto be notified of filesystem changes.</p>\n<ul>\n<li>On Linux systems, this uses <a href=\"https://man7.org/linux/man-pages/man7/inotify.7.html\"><code>inotify(7)</code></a>.</li>\n<li>On BSD systems, this uses <a href=\"https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2\"><code>kqueue(2)</code></a>.</li>\n<li>On macOS, this uses <a href=\"https://www.freebsd.org/cgi/man.cgi?query=kqueue&#x26;sektion=2\"><code>kqueue(2)</code></a> for files and <a href=\"https://developer.apple.com/documentation/coreservices/file_system_events\"><code>FSEvents</code></a> for\ndirectories.</li>\n<li>On SunOS systems (including Solaris and SmartOS), this uses <a href=\"https://illumos.org/man/port_create\"><code>event ports</code></a>.</li>\n<li>On Windows systems, this feature depends on <a href=\"https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw\"><code>ReadDirectoryChangesW</code></a>.</li>\n<li>On Aix systems, this feature depends on <a href=\"https://www.ibm.com/developerworks/aix/library/au-aix_event_infrastructure/\"><code>AHAFS</code></a>, which must be enabled.</li>\n<li>On IBM i systems, this feature is not supported.</li>\n</ul>\n<p>If the underlying functionality is not available for some reason, then\n<code>fs.watch()</code> will not be able to function and may thrown an exception.\nFor example, watching files or directories can be unreliable, and in some\ncases impossible, on network file systems (NFS, SMB, etc) or host file systems\nwhen using virtualization software such as Vagrant or Docker.</p>\n<p>It is still possible to use <code>fs.watchFile()</code>, which uses stat polling, but\nthis method is slower and less reliable.</p>"
+                  "textRaw": "`dev` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "dev",
+                  "desc": "<p>The numeric identifier of the device containing the file.</p>"
                 },
                 {
-                  "textRaw": "Inodes",
-                  "name": "Inodes",
-                  "type": "misc",
-                  "desc": "<p>On Linux and macOS systems, <code>fs.watch()</code> resolves the path to an <a href=\"https://en.wikipedia.org/wiki/Inode\">inode</a> and\nwatches the inode. If the watched path is deleted and recreated, it is assigned\na new inode. The watch will emit an event for the delete but will continue\nwatching the <em>original</em> inode. Events for the new inode will not be emitted.\nThis is expected behavior.</p>\n<p>AIX files retain the same inode for the lifetime of a file. Saving and closing a\nwatched file on AIX will result in two notifications (one for adding new\ncontent, and one for truncation).</p>"
+                  "textRaw": "`ino` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "ino",
+                  "desc": "<p>The file system specific \"Inode\" number for the file.</p>"
                 },
                 {
-                  "textRaw": "Filename argument",
-                  "name": "Filename argument",
-                  "type": "misc",
-                  "desc": "<p>Providing <code>filename</code> argument in the callback is only supported on Linux,\nmacOS, Windows, and AIX. Even on supported platforms, <code>filename</code> is not always\nguaranteed to be provided. Therefore, don't assume that <code>filename</code> argument is\nalways provided in the callback, and have some fallback logic if it is <code>null</code>.</p>\n<pre><code class=\"language-js\">fs.watch('somedir', (eventType, filename) => {\n  console.log(`event type is: ${eventType}`);\n  if (filename) {\n    console.log(`filename provided: ${filename}`);\n  } else {\n    console.log('filename not provided');\n  }\n});\n</code></pre>"
-                }
-              ]
-            }
-          ]
-        },
-        {
-          "textRaw": "`fs.watchFile(filename[, options], listener)`",
-          "type": "method",
-          "name": "watchFile",
-          "meta": {
-            "added": [
-              "v0.1.31"
-            ],
-            "changes": [
-              {
-                "version": "v10.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/20220",
-                "description": "The `bigint` option is now supported."
-              },
-              {
-                "version": "v7.6.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10739",
-                "description": "The `filename` parameter can be a WHATWG `URL` object using `file:` protocol. Support is currently still *experimental*."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {fs.StatWatcher}",
-                "name": "return",
-                "type": "fs.StatWatcher"
-              },
-              "params": [
+                  "textRaw": "`mode` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "mode",
+                  "desc": "<p>A bit-field describing the file type and mode.</p>"
+                },
                 {
-                  "textRaw": "`filename` {string|Buffer|URL}",
-                  "name": "filename",
-                  "type": "string|Buffer|URL"
+                  "textRaw": "`nlink` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "nlink",
+                  "desc": "<p>The number of hard-links that exist for the file.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`bigint` {boolean} **Default:** `false`",
-                      "name": "bigint",
-                      "type": "boolean",
-                      "default": "`false`"
-                    },
-                    {
-                      "textRaw": "`persistent` {boolean} **Default:** `true`",
-                      "name": "persistent",
-                      "type": "boolean",
-                      "default": "`true`"
-                    },
-                    {
-                      "textRaw": "`interval` {integer} **Default:** `5007`",
-                      "name": "interval",
-                      "type": "integer",
-                      "default": "`5007`"
-                    }
-                  ]
+                  "textRaw": "`uid` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "uid",
+                  "desc": "<p>The numeric user identifier of the user that owns the file (POSIX).</p>"
                 },
                 {
-                  "textRaw": "`listener` {Function}",
-                  "name": "listener",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`current` {fs.Stats}",
-                      "name": "current",
-                      "type": "fs.Stats"
-                    },
-                    {
-                      "textRaw": "`previous` {fs.Stats}",
-                      "name": "previous",
-                      "type": "fs.Stats"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Watch for changes on <code>filename</code>. The callback <code>listener</code> will be called each\ntime the file is accessed.</p>\n<p>The <code>options</code> argument may be omitted. If provided, it should be an object. The\n<code>options</code> object may contain a boolean named <code>persistent</code> that indicates\nwhether the process should continue to run as long as files are being watched.\nThe <code>options</code> object may specify an <code>interval</code> property indicating how often the\ntarget should be polled in milliseconds.</p>\n<p>The <code>listener</code> gets two arguments the current stat object and the previous\nstat object:</p>\n<pre><code class=\"language-js\">fs.watchFile('message.text', (curr, prev) => {\n  console.log(`the current mtime is: ${curr.mtime}`);\n  console.log(`the previous mtime was: ${prev.mtime}`);\n});\n</code></pre>\n<p>These stat objects are instances of <code>fs.Stat</code>. If the <code>bigint</code> option is <code>true</code>,\nthe numeric values in these objects are specified as <code>BigInt</code>s.</p>\n<p>To be notified when the file was modified, not just accessed, it is necessary\nto compare <code>curr.mtime</code> and <code>prev.mtime</code>.</p>\n<p>When an <code>fs.watchFile</code> operation results in an <code>ENOENT</code> error, it\nwill invoke the listener once, with all the fields zeroed (or, for dates, the\nUnix Epoch). If the file is created later on, the listener will be called\nagain, with the latest stat objects. This is a change in functionality since\nv0.10.</p>\n<p>Using <a href=\"#fs_fs_watch_filename_options_listener\"><code>fs.watch()</code></a> is more efficient than <code>fs.watchFile</code> and\n<code>fs.unwatchFile</code>. <code>fs.watch</code> should be used instead of <code>fs.watchFile</code> and\n<code>fs.unwatchFile</code> when possible.</p>\n<p>When a file being watched by <code>fs.watchFile()</code> disappears and reappears,\nthen the contents of <code>previous</code> in the second callback event (the file's\nreappearance) will be the same as the contents of <code>previous</code> in the first\ncallback event (its disappearance).</p>\n<p>This happens when:</p>\n<ul>\n<li>the file is deleted, followed by a restore</li>\n<li>the file is renamed and then renamed a second time back to its original name</li>\n</ul>"
-        },
-        {
-          "textRaw": "`fs.write(fd, buffer[, offset[, length[, position]]], callback)`",
-          "type": "method",
-          "name": "write",
-          "meta": {
-            "added": [
-              "v0.0.2"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`"
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `buffer` parameter can now be a `Uint8Array`."
-              },
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7856",
-                "description": "The `offset` and `length` parameters are optional now."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  "textRaw": "`gid` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "gid",
+                  "desc": "<p>The numeric group identifier of the group that owns the file (POSIX).</p>"
+                },
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "textRaw": "`rdev` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "rdev",
+                  "desc": "<p>A numeric device identifier if the file represents a device.</p>"
                 },
                 {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
+                  "textRaw": "`size` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "size",
+                  "desc": "<p>The size of the file in bytes.</p>"
                 },
                 {
-                  "textRaw": "`offset` {integer}",
-                  "name": "offset",
-                  "type": "integer"
+                  "textRaw": "`blksize` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "blksize",
+                  "desc": "<p>The file system block size for i/o operations.</p>"
                 },
                 {
-                  "textRaw": "`length` {integer}",
-                  "name": "length",
-                  "type": "integer"
+                  "textRaw": "`blocks` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "blocks",
+                  "desc": "<p>The number of blocks allocated for this file.</p>"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
+                  "textRaw": "`atimeMs` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "atimeMs",
+                  "meta": {
+                    "added": [
+                      "v8.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time this file was accessed expressed in\nmilliseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
-                    {
-                      "textRaw": "`bytesWritten` {integer}",
-                      "name": "bytesWritten",
-                      "type": "integer"
-                    },
-                    {
-                      "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                      "name": "buffer",
-                      "type": "Buffer|TypedArray|DataView"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Write <code>buffer</code> to the file specified by <code>fd</code>.</p>\n<p><code>offset</code> determines the part of the buffer to be written, and <code>length</code> is\nan integer specifying the number of bytes to write.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p>The callback will be given three arguments <code>(err, bytesWritten, buffer)</code> where\n<code>bytesWritten</code> specifies how many <em>bytes</em> were written from <code>buffer</code>.</p>\n<p>If this method is invoked as its <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed version, it returns\na <code>Promise</code> for an <code>Object</code> with <code>bytesWritten</code> and <code>buffer</code> properties.</p>\n<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting\nfor the callback. For this scenario, <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
-        },
-        {
-          "textRaw": "`fs.write(fd, string[, position[, encoding]], callback)`",
-          "type": "method",
-          "name": "write",
-          "meta": {
-            "added": [
-              "v0.11.5"
-            ],
-            "changes": [
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7856",
-                "description": "The `position` parameter is optional now."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  "textRaw": "`mtimeMs` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "mtimeMs",
+                  "meta": {
+                    "added": [
+                      "v8.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time this file was modified expressed in\nmilliseconds since the POSIX Epoch.</p>"
+                },
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "textRaw": "`ctimeMs` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "ctimeMs",
+                  "meta": {
+                    "added": [
+                      "v8.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time the file status was changed expressed\nin milliseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`string` {string}",
-                  "name": "string",
-                  "type": "string"
+                  "textRaw": "`birthtimeMs` {number|bigint}",
+                  "type": "number|bigint",
+                  "name": "birthtimeMs",
+                  "meta": {
+                    "added": [
+                      "v8.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the creation time of this file expressed in\nmilliseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
+                  "textRaw": "`atimeNs` {bigint}",
+                  "type": "bigint",
+                  "name": "atimeNs",
+                  "meta": {
+                    "added": [
+                      "v12.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time this file was accessed expressed in\nnanoseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`encoding` {string} **Default:** `'utf8'`",
-                  "name": "encoding",
-                  "type": "string",
-                  "default": "`'utf8'`"
+                  "textRaw": "`mtimeNs` {bigint}",
+                  "type": "bigint",
+                  "name": "mtimeNs",
+                  "meta": {
+                    "added": [
+                      "v12.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time this file was modified expressed in\nnanoseconds since the POSIX Epoch.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    },
-                    {
-                      "textRaw": "`written` {integer}",
-                      "name": "written",
-                      "type": "integer"
-                    },
-                    {
-                      "textRaw": "`string` {string}",
-                      "name": "string",
-                      "type": "string"
-                    }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Write <code>string</code> to the file specified by <code>fd</code>. If <code>string</code> is not a string, then\nthe value will be coerced to one.</p>\n<p><code>position</code> refers to the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code> the data will be written at\nthe current position. See <a href=\"http://man7.org/linux/man-pages/man2/pwrite.2.html\"><code>pwrite(2)</code></a>.</p>\n<p><code>encoding</code> is the expected string encoding.</p>\n<p>The callback will receive the arguments <code>(err, written, string)</code> where <code>written</code>\nspecifies how many <em>bytes</em> the passed string required to be written. Bytes\nwritten is not necessarily the same as string characters written. See\n<a href=\"buffer.html#buffer_static_method_buffer_bytelength_string_encoding\"><code>Buffer.byteLength</code></a>.</p>\n<p>It is unsafe to use <code>fs.write()</code> multiple times on the same file without waiting\nfor the callback. For this scenario, <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>\n<p>On Windows, if the file descriptor is connected to the console (e.g. <code>fd == 1</code>\nor <code>stdout</code>) a string containing non-ASCII characters will not be rendered\nproperly by default, regardless of the encoding used.\nIt is possible to configure the console to render UTF-8 properly by changing the\nactive codepage with the <code>chcp 65001</code> command. See the <a href=\"https://ss64.com/nt/chcp.html\">chcp</a> docs for more\ndetails.</p>"
-        },
-        {
-          "textRaw": "`fs.writeFile(file, data[, options], callback)`",
-          "type": "method",
-          "name": "writeFile",
-          "meta": {
-            "added": [
-              "v0.1.29"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `data` parameter can now be any `TypedArray` or a `DataView`."
-              },
-              {
-                "version": "v10.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/12562",
-                "description": "The `callback` parameter is no longer optional. Not passing it will throw a `TypeError` at runtime."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `data` parameter can now be a `Uint8Array`."
-              },
-              {
-                "version": "v7.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7897",
-                "description": "The `callback` parameter is no longer optional. Not passing it will emit a deprecation warning with id DEP0013."
-              },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `file` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
+                  "textRaw": "`ctimeNs` {bigint}",
+                  "type": "bigint",
+                  "name": "ctimeNs",
+                  "meta": {
+                    "added": [
+                      "v12.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the last time the file status was changed expressed\nin nanoseconds since the POSIX Epoch.</p>"
+                },
+                {
+                  "textRaw": "`birthtimeNs` {bigint}",
+                  "type": "bigint",
+                  "name": "birthtimeNs",
+                  "meta": {
+                    "added": [
+                      "v12.10.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Only present when <code>bigint: true</code> is passed into the method that generates\nthe object.\nThe timestamp indicating the creation time of this file expressed in\nnanoseconds since the POSIX Epoch.</p>"
+                },
                 {
-                  "textRaw": "`file` {string|Buffer|URL|integer} filename or file descriptor",
-                  "name": "file",
-                  "type": "string|Buffer|URL|integer",
-                  "desc": "filename or file descriptor"
+                  "textRaw": "`atime` {Date}",
+                  "type": "Date",
+                  "name": "atime",
+                  "meta": {
+                    "added": [
+                      "v0.11.13"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time this file was accessed.</p>"
                 },
                 {
-                  "textRaw": "`data` {string|Buffer|TypedArray|DataView}",
-                  "name": "data",
-                  "type": "string|Buffer|TypedArray|DataView"
+                  "textRaw": "`mtime` {Date}",
+                  "type": "Date",
+                  "name": "mtime",
+                  "meta": {
+                    "added": [
+                      "v0.11.13"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time this file was modified.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
-                    },
-                    {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
-                      "type": "integer",
-                      "default": "`0o666`"
-                    },
-                    {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'w'`",
-                      "desc": "See [support of file system `flags`][]."
-                    }
-                  ]
+                  "textRaw": "`ctime` {Date}",
+                  "type": "Date",
+                  "name": "ctime",
+                  "meta": {
+                    "added": [
+                      "v0.11.13"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the last time the file status was changed.</p>"
                 },
                 {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
-                    {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
-                    }
-                  ]
+                  "textRaw": "`birthtime` {Date}",
+                  "type": "Date",
+                  "name": "birthtime",
+                  "meta": {
+                    "added": [
+                      "v0.11.13"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The timestamp indicating the creation time of this file.</p>"
+                }
+              ],
+              "modules": [
+                {
+                  "textRaw": "Stat time values",
+                  "name": "stat_time_values",
+                  "desc": "<p>The <code>atimeMs</code>, <code>mtimeMs</code>, <code>ctimeMs</code>, <code>birthtimeMs</code> properties are\nnumeric values that hold the corresponding times in milliseconds. Their\nprecision is platform specific. When <code>bigint: true</code> is passed into the\nmethod that generates the object, the properties will be <a href=\"https://tc39.github.io/proposal-bigint\">bigints</a>,\notherwise they will be <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\">numbers</a>.</p>\n<p>The <code>atimeNs</code>, <code>mtimeNs</code>, <code>ctimeNs</code>, <code>birthtimeNs</code> properties are\n<a href=\"https://tc39.github.io/proposal-bigint\">bigints</a> that hold the corresponding times in nanoseconds. They are\nonly present when <code>bigint: true</code> is passed into the method that generates\nthe object. Their precision is platform specific.</p>\n<p><code>atime</code>, <code>mtime</code>, <code>ctime</code>, and <code>birthtime</code> are\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date\"><code>Date</code></a> object alternate representations of the various times. The\n<code>Date</code> and number values are not connected. Assigning a new number value, or\nmutating the <code>Date</code> value, will not be reflected in the corresponding alternate\nrepresentation.</p>\n<p>The times in the stat object have the following semantics:</p>\n<ul>\n<li><code>atime</code> \"Access Time\": Time when file data last accessed. Changed\nby the <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/read.2.html\"><code>read(2)</code></a> system calls.</li>\n<li><code>mtime</code> \"Modified Time\": Time when file data last modified.\nChanged by the <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/write.2.html\"><code>write(2)</code></a> system calls.</li>\n<li><code>ctime</code> \"Change Time\": Time when file status was last changed\n(inode data modification). Changed by the <a href=\"http://man7.org/linux/man-pages/man2/chmod.2.html\"><code>chmod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/chown.2.html\"><code>chown(2)</code></a>,\n<a href=\"http://man7.org/linux/man-pages/man2/link.2.html\"><code>link(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/mknod.2.html\"><code>mknod(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/rename.2.html\"><code>rename(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/unlink.2.html\"><code>unlink(2)</code></a>, <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a>,\n<a href=\"http://man7.org/linux/man-pages/man2/read.2.html\"><code>read(2)</code></a>, and <a href=\"http://man7.org/linux/man-pages/man2/write.2.html\"><code>write(2)</code></a> system calls.</li>\n<li><code>birthtime</code> \"Birth Time\": Time of file creation. Set once when the\nfile is created. On filesystems where birthtime is not available,\nthis field may instead hold either the <code>ctime</code> or\n<code>1970-01-01T00:00Z</code> (ie, Unix epoch timestamp <code>0</code>). This value may be greater\nthan <code>atime</code> or <code>mtime</code> in this case. On Darwin and other FreeBSD variants,\nalso set if the <code>atime</code> is explicitly set to an earlier value than the current\n<code>birthtime</code> using the <a href=\"http://man7.org/linux/man-pages/man2/utimes.2.html\"><code>utimes(2)</code></a> system call.</li>\n</ul>\n<p>Prior to Node.js 0.12, the <code>ctime</code> held the <code>birthtime</code> on Windows systems. As\nof 0.12, <code>ctime</code> is not \"creation time\", and on Unix systems, it never was.</p>",
+                  "type": "module",
+                  "displayName": "Stat time values"
                 }
               ]
-            }
-          ],
-          "desc": "<p>When <code>file</code> is a filename, asynchronously writes data to the file, replacing the\nfile if it already exists.  <code>data</code> can be a string or a buffer.</p>\n<p>When <code>file</code> is a file descriptor, the behavior is similar to calling\n<code>fs.write()</code> directly (which is recommended). See the notes below on using\na file descriptor.</p>\n<p>The <code>encoding</code> option is ignored if <code>data</code> is a buffer.</p>\n<pre><code class=\"language-js\">const data = new Uint8Array(Buffer.from('Hello Node.js'));\nfs.writeFile('message.txt', data, (err) => {\n  if (err) throw err;\n  console.log('The file has been saved!');\n});\n</code></pre>\n<p>If <code>options</code> is a string, then it specifies the encoding:</p>\n<pre><code class=\"language-js\">fs.writeFile('message.txt', 'Hello Node.js', 'utf8', callback);\n</code></pre>\n<p>It is unsafe to use <code>fs.writeFile()</code> multiple times on the same file without\nwaiting for the callback. For this scenario, <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> is\nrecommended.</p>",
-          "modules": [
+            },
             {
-              "textRaw": "Using `fs.writeFile()` with file descriptors",
-              "name": "using_`fs.writefile()`_with_file_descriptors",
-              "desc": "<p>When <code>file</code> is a file descriptor, the behavior is almost identical to directly\ncalling <code>fs.write()</code> like:</p>\n<pre><code class=\"language-js\">fs.write(fd, Buffer.from(data, options.encoding), callback);\n</code></pre>\n<p>The difference from directly calling <code>fs.write()</code> is that under some unusual\nconditions, <code>fs.write()</code> may write only part of the buffer and will need to be\nretried to write the remaining data, whereas <code>fs.writeFile()</code> will retry until\nthe data is entirely written (or an error occurs).</p>\n<p>The implications of this are a common source of confusion. In\nthe file descriptor case, the file is not replaced! The data is not necessarily\nwritten to the beginning of the file, and the file's original data may remain\nbefore and/or after the newly written data.</p>\n<p>For example, if <code>fs.writeFile()</code> is called twice in a row, first to write the\nstring <code>'Hello'</code>, then to write the string <code>', World'</code>, the file would contain\n<code>'Hello, World'</code>, and might contain some of the file's original data (depending\non the size of the original file, and the position of the file descriptor). If\na file name had been used instead of a descriptor, the file would be guaranteed\nto contain only <code>', World'</code>.</p>",
-              "type": "module",
-              "displayName": "Using `fs.writeFile()` with file descriptors"
-            }
-          ]
-        },
-        {
-          "textRaw": "`fs.writeFileSync(file, data[, options])`",
-          "type": "method",
-          "name": "writeFileSync",
-          "meta": {
-            "added": [
-              "v0.1.29"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `data` parameter can now be any `TypedArray` or a `DataView`."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `data` parameter can now be a `Uint8Array`."
+              "textRaw": "Class: `fs.WriteStream`",
+              "type": "class",
+              "name": "fs.WriteStream",
+              "meta": {
+                "added": [
+                  "v0.1.93"
+                ],
+                "changes": []
               },
-              {
-                "version": "v5.0.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3163",
-                "description": "The `file` parameter can be a file descriptor now."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "params": [
-                {
-                  "textRaw": "`file` {string|Buffer|URL|integer} filename or file descriptor",
-                  "name": "file",
-                  "type": "string|Buffer|URL|integer",
-                  "desc": "filename or file descriptor"
-                },
+              "desc": "<ul>\n<li>Extends <a href=\"stream.html#stream_class_stream_writable\" class=\"type\">&lt;stream.Writable&gt;</a></li>\n</ul>\n<p>Instances of <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a> are created and returned using the\n<a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a> function.</p>",
+              "events": [
                 {
-                  "textRaw": "`data` {string|Buffer|TypedArray|DataView}",
-                  "name": "data",
-                  "type": "string|Buffer|TypedArray|DataView"
+                  "textRaw": "Event: `'close'`",
+                  "type": "event",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a>'s underlying file descriptor has been closed.</p>"
                 },
                 {
-                  "textRaw": "`options` {Object|string}",
-                  "name": "options",
-                  "type": "Object|string",
-                  "options": [
-                    {
-                      "textRaw": "`encoding` {string|null} **Default:** `'utf8'`",
-                      "name": "encoding",
-                      "type": "string|null",
-                      "default": "`'utf8'`"
-                    },
+                  "textRaw": "Event: `'open'`",
+                  "type": "event",
+                  "name": "open",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
                     {
-                      "textRaw": "`mode` {integer} **Default:** `0o666`",
-                      "name": "mode",
+                      "textRaw": "`fd` {integer} Integer file descriptor used by the {fs.WriteStream}.",
+                      "name": "fd",
                       "type": "integer",
-                      "default": "`0o666`"
-                    },
-                    {
-                      "textRaw": "`flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.",
-                      "name": "flag",
-                      "type": "string",
-                      "default": "`'w'`",
-                      "desc": "See [support of file system `flags`][]."
+                      "desc": "Integer file descriptor used by the {fs.WriteStream}."
                     }
-                  ]
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Returns <code>undefined</code>.</p>\n<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_writefile_file_data_options_callback\"><code>fs.writeFile()</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.writeSync(fd, buffer[, offset[, length[, position]]])`",
-          "type": "method",
-          "name": "writeSync",
-          "meta": {
-            "added": [
-              "v0.1.21"
-            ],
-            "changes": [
-              {
-                "version": "v10.10.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22150",
-                "description": "The `buffer` parameter can now be any `TypedArray` or a `DataView`."
-              },
-              {
-                "version": "v7.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10382",
-                "description": "The `buffer` parameter can now be a `Uint8Array`."
-              },
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7856",
-                "description": "The `offset` and `length` parameters are optional now."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {number} The number of bytes written.",
-                "name": "return",
-                "type": "number",
-                "desc": "The number of bytes written."
-              },
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffer` {Buffer|TypedArray|DataView}",
-                  "name": "buffer",
-                  "type": "Buffer|TypedArray|DataView"
-                },
-                {
-                  "textRaw": "`offset` {integer}",
-                  "name": "offset",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`length` {integer}",
-                  "name": "length",
-                  "type": "integer"
+                  ],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a>'s file is opened.</p>"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
+                  "textRaw": "Event: `'ready'`",
+                  "type": "event",
+                  "name": "ready",
+                  "meta": {
+                    "added": [
+                      "v9.11.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>Emitted when the <a href=\"fs.html#fs_class_fs_writestream\" class=\"type\">&lt;fs.WriteStream&gt;</a> is ready to be used.</p>\n<p>Fires immediately after <code>'open'</code>.</p>"
                 }
-              ]
-            }
-          ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_write_fd_buffer_offset_length_position_callback\"><code>fs.write(fd, buffer...)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.writeSync(fd, string[, position[, encoding]])`",
-          "type": "method",
-          "name": "writeSync",
-          "meta": {
-            "added": [
-              "v0.11.5"
-            ],
-            "changes": [
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/7856",
-                "description": "The `position` parameter is optional now."
-              }
-            ]
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {number} The number of bytes written.",
-                "name": "return",
-                "type": "number",
-                "desc": "The number of bytes written."
-              },
-              "params": [
+              ],
+              "properties": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "textRaw": "`writeStream.bytesWritten`",
+                  "name": "bytesWritten",
+                  "meta": {
+                    "added": [
+                      "v0.4.7"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The number of bytes written so far. Does not include data that is still queued\nfor writing.</p>"
                 },
                 {
-                  "textRaw": "`string` {string}",
-                  "name": "string",
-                  "type": "string"
+                  "textRaw": "`writeStream.path`",
+                  "name": "path",
+                  "meta": {
+                    "added": [
+                      "v0.1.93"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>The path to the file the stream is writing to as specified in the first\nargument to <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>. If <code>path</code> is passed as a string, then\n<code>writeStream.path</code> will be a string. If <code>path</code> is passed as a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>, then\n<code>writeStream.path</code> will be a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>.</p>"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
+                  "textRaw": "`pending` {boolean}",
+                  "type": "boolean",
+                  "name": "pending",
+                  "meta": {
+                    "added": [
+                      "v11.2.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>This property is <code>true</code> if the underlying file has not been opened yet,\ni.e. before the <code>'ready'</code> event is emitted.</p>"
+                }
+              ],
+              "methods": [
                 {
-                  "textRaw": "`encoding` {string}",
-                  "name": "encoding",
-                  "type": "string"
+                  "textRaw": "`writeStream.close([callback])`",
+                  "type": "method",
+                  "name": "close",
+                  "meta": {
+                    "added": [
+                      "v0.9.4"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`callback` {Function}",
+                          "name": "callback",
+                          "type": "Function",
+                          "options": [
+                            {
+                              "textRaw": "`err` {Error}",
+                              "name": "err",
+                              "type": "Error"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Closes <code>writeStream</code>. Optionally accepts a\ncallback that will be executed once the <code>writeStream</code>\nis closed.</p>"
                 }
               ]
             }
           ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_write_fd_string_position_encoding_callback\"><code>fs.write(fd, string...)</code></a>.</p>"
-        },
-        {
-          "textRaw": "`fs.writev(fd, buffers[, position], callback)`",
-          "type": "method",
-          "name": "writev",
-          "meta": {
-            "added": [
-              "v12.9.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+          "properties": [
             {
-              "params": [
-                {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`buffers` {ArrayBufferView[]}",
-                  "name": "buffers",
-                  "type": "ArrayBufferView[]"
-                },
-                {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
-                },
-                {
-                  "textRaw": "`callback` {Function}",
-                  "name": "callback",
-                  "type": "Function",
-                  "options": [
+              "textRaw": "`constants` {Object}",
+              "type": "Object",
+              "name": "constants",
+              "desc": "<p>Returns an object containing commonly used constants for file system\noperations.</p>",
+              "modules": [
+                {
+                  "textRaw": "FS constants",
+                  "name": "fs_constants",
+                  "desc": "<p>The following constants are exported by <code>fs.constants</code>.</p>\n<p>Not every constant will be available on every operating system.</p>\n<p>To use more than one constant, use the bitwise OR <code>|</code> operator.</p>\n<p>Example:</p>\n<pre><code class=\"language-mjs\">import { open, constants } from 'fs';\n\nconst {\n  O_RDWR,\n  O_CREAT,\n  O_EXCL\n} = constants;\n\nopen('/path/to/my/file', O_RDWR | O_CREAT | O_EXCL, (err, fd) => {\n  // ...\n});\n</code></pre>",
+                  "modules": [
+                    {
+                      "textRaw": "File access constants",
+                      "name": "file_access_constants",
+                      "desc": "<p>The following constants are meant for use with <a href=\"#fs_fs_access_path_mode_callback\"><code>fs.access()</code></a>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>F_OK</code></td>\n    <td>Flag indicating that the file is visible to the calling process.\n     This is useful for determining if a file exists, but says nothing\n     about <code>rwx</code> permissions. Default if no mode is specified.</td>\n  </tr>\n  <tr>\n    <td><code>R_OK</code></td>\n    <td>Flag indicating that the file can be read by the calling process.</td>\n  </tr>\n  <tr>\n    <td><code>W_OK</code></td>\n    <td>Flag indicating that the file can be written by the calling\n    process.</td>\n  </tr>\n  <tr>\n    <td><code>X_OK</code></td>\n    <td>Flag indicating that the file can be executed by the calling\n    process. This has no effect on Windows\n    (will behave like <code>fs.constants.F_OK</code>).</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File access constants"
+                    },
                     {
-                      "textRaw": "`err` {Error}",
-                      "name": "err",
-                      "type": "Error"
+                      "textRaw": "File copy constants",
+                      "name": "file_copy_constants",
+                      "desc": "<p>The following constants are meant for use with <a href=\"#fs_fs_copyfile_src_dest_mode_callback\"><code>fs.copyFile()</code></a>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_EXCL</code></td>\n    <td>If present, the copy operation will fail with an error if the\n    destination path already exists.</td>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_FICLONE</code></td>\n    <td>If present, the copy operation will attempt to create a\n    copy-on-write reflink. If the underlying platform does not support\n    copy-on-write, then a fallback copy mechanism is used.</td>\n  </tr>\n  <tr>\n    <td><code>COPYFILE_FICLONE_FORCE</code></td>\n    <td>If present, the copy operation will attempt to create a\n    copy-on-write reflink. If the underlying platform does not support\n    copy-on-write, then the operation will fail with an error.</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File copy constants"
                     },
                     {
-                      "textRaw": "`bytesWritten` {integer}",
-                      "name": "bytesWritten",
-                      "type": "integer"
+                      "textRaw": "File open constants",
+                      "name": "file_open_constants",
+                      "desc": "<p>The following constants are meant for use with <code>fs.open()</code>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>O_RDONLY</code></td>\n    <td>Flag indicating to open a file for read-only access.</td>\n  </tr>\n  <tr>\n    <td><code>O_WRONLY</code></td>\n    <td>Flag indicating to open a file for write-only access.</td>\n  </tr>\n  <tr>\n    <td><code>O_RDWR</code></td>\n    <td>Flag indicating to open a file for read-write access.</td>\n  </tr>\n  <tr>\n    <td><code>O_CREAT</code></td>\n    <td>Flag indicating to create the file if it does not already exist.</td>\n  </tr>\n  <tr>\n    <td><code>O_EXCL</code></td>\n    <td>Flag indicating that opening a file should fail if the\n    <code>O_CREAT</code> flag is set and the file already exists.</td>\n  </tr>\n  <tr>\n    <td><code>O_NOCTTY</code></td>\n    <td>Flag indicating that if path identifies a terminal device, opening the\n    path shall not cause that terminal to become the controlling terminal for\n    the process (if the process does not already have one).</td>\n  </tr>\n  <tr>\n    <td><code>O_TRUNC</code></td>\n    <td>Flag indicating that if the file exists and is a regular file, and the\n    file is opened successfully for write access, its length shall be truncated\n    to zero.</td>\n  </tr>\n  <tr>\n    <td><code>O_APPEND</code></td>\n    <td>Flag indicating that data will be appended to the end of the file.</td>\n  </tr>\n  <tr>\n    <td><code>O_DIRECTORY</code></td>\n    <td>Flag indicating that the open should fail if the path is not a\n    directory.</td>\n  </tr>\n  <tr>\n  <td><code>O_NOATIME</code></td>\n    <td>Flag indicating reading accesses to the file system will no longer\n    result in an update to the <code>atime</code> information associated with\n    the file. This flag is available on Linux operating systems only.</td>\n  </tr>\n  <tr>\n    <td><code>O_NOFOLLOW</code></td>\n    <td>Flag indicating that the open should fail if the path is a symbolic\n    link.</td>\n  </tr>\n  <tr>\n    <td><code>O_SYNC</code></td>\n    <td>Flag indicating that the file is opened for synchronized I/O with write\n    operations waiting for file integrity.</td>\n  </tr>\n  <tr>\n    <td><code>O_DSYNC</code></td>\n    <td>Flag indicating that the file is opened for synchronized I/O with write\n    operations waiting for data integrity.</td>\n  </tr>\n  <tr>\n    <td><code>O_SYMLINK</code></td>\n    <td>Flag indicating to open the symbolic link itself rather than the\n    resource it is pointing to.</td>\n  </tr>\n  <tr>\n    <td><code>O_DIRECT</code></td>\n    <td>When set, an attempt will be made to minimize caching effects of file\n    I/O.</td>\n  </tr>\n  <tr>\n    <td><code>O_NONBLOCK</code></td>\n    <td>Flag indicating to open the file in nonblocking mode when possible.</td>\n  </tr>\n  <tr>\n    <td><code>UV_FS_O_FILEMAP</code></td>\n    <td>When set, a memory file mapping is used to access the file. This flag\n    is available on Windows operating systems only. On other operating systems,\n    this flag is ignored.</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File open constants"
                     },
                     {
-                      "textRaw": "`buffers` {ArrayBufferView[]}",
-                      "name": "buffers",
-                      "type": "ArrayBufferView[]"
+                      "textRaw": "File type constants",
+                      "name": "file_type_constants",
+                      "desc": "<p>The following constants are meant for use with the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object's\n<code>mode</code> property for determining a file's type.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>S_IFMT</code></td>\n    <td>Bit mask used to extract the file type code.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFREG</code></td>\n    <td>File type constant for a regular file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFDIR</code></td>\n    <td>File type constant for a directory.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFCHR</code></td>\n    <td>File type constant for a character-oriented device file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFBLK</code></td>\n    <td>File type constant for a block-oriented device file.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFIFO</code></td>\n    <td>File type constant for a FIFO/pipe.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFLNK</code></td>\n    <td>File type constant for a symbolic link.</td>\n  </tr>\n  <tr>\n    <td><code>S_IFSOCK</code></td>\n    <td>File type constant for a socket.</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File type constants"
+                    },
+                    {
+                      "textRaw": "File mode constants",
+                      "name": "file_mode_constants",
+                      "desc": "<p>The following constants are meant for use with the <a href=\"fs.html#fs_class_fs_stats\" class=\"type\">&lt;fs.Stats&gt;</a> object's\n<code>mode</code> property for determining the access permissions for a file.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>S_IRWXU</code></td>\n    <td>File mode indicating readable, writable, and executable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRUSR</code></td>\n    <td>File mode indicating readable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWUSR</code></td>\n    <td>File mode indicating writable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXUSR</code></td>\n    <td>File mode indicating executable by owner.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRWXG</code></td>\n    <td>File mode indicating readable, writable, and executable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRGRP</code></td>\n    <td>File mode indicating readable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWGRP</code></td>\n    <td>File mode indicating writable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXGRP</code></td>\n    <td>File mode indicating executable by group.</td>\n  </tr>\n  <tr>\n    <td><code>S_IRWXO</code></td>\n    <td>File mode indicating readable, writable, and executable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IROTH</code></td>\n    <td>File mode indicating readable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IWOTH</code></td>\n    <td>File mode indicating writable by others.</td>\n  </tr>\n  <tr>\n    <td><code>S_IXOTH</code></td>\n    <td>File mode indicating executable by others.</td>\n  </tr>\n</table>",
+                      "type": "module",
+                      "displayName": "File mode constants"
                     }
-                  ]
+                  ],
+                  "type": "module",
+                  "displayName": "FS constants"
                 }
               ]
             }
           ],
-          "desc": "<p>Write an array of <code>ArrayBufferView</code>s to the file specified by <code>fd</code> using\n<code>writev()</code>.</p>\n<p><code>position</code> is the offset from the beginning of the file where this data\nshould be written. If <code>typeof position !== 'number'</code>, the data will be written\nat the current position.</p>\n<p>The callback will be given three arguments: <code>err</code>, <code>bytesWritten</code>, and\n<code>buffers</code>. <code>bytesWritten</code> is how many bytes were written from <code>buffers</code>.</p>\n<p>If this method is <a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>ed, it returns a <code>Promise</code> for an\n<code>Object</code> with <code>bytesWritten</code> and <code>buffers</code> properties.</p>\n<p>It is unsafe to use <code>fs.writev()</code> multiple times on the same file without\nwaiting for the callback. For this scenario, use <a href=\"#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>"
+          "type": "module",
+          "displayName": "Common Objects"
         },
         {
-          "textRaw": "`fs.writevSync(fd, buffers[, position])`",
-          "type": "method",
-          "name": "writevSync",
-          "meta": {
-            "added": [
-              "v12.9.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
+          "textRaw": "Notes",
+          "name": "notes",
+          "modules": [
             {
-              "return": {
-                "textRaw": "Returns: {number} The number of bytes written.",
-                "name": "return",
-                "type": "number",
-                "desc": "The number of bytes written."
-              },
-              "params": [
+              "textRaw": "Ordering of callback and promise-based operations",
+              "name": "ordering_of_callback_and_promise-based_operations",
+              "desc": "<p>Because they are executed asynchronously by the underlying thread pool,\nthere is no guaranteed ordering when using either the callback or\npromise-based methods.</p>\n<p>For example, the following is prone to error because the <code>fs.stat()</code>\noperation might complete before the <code>fs.rename()</code> operation:</p>\n<pre><code class=\"language-js\">fs.rename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  console.log('renamed complete');\n});\nfs.stat('/tmp/world', (err, stats) => {\n  if (err) throw err;\n  console.log(`stats: ${JSON.stringify(stats)}`);\n});\n</code></pre>\n<p>It is important to correctly order the operations by awaiting the results\nof one before invoking the other:</p>\n<pre><code class=\"language-mjs\">import { rename, stat } from 'fs/promises';\n\nconst from = '/tmp/hello';\nconst to = '/tmp/world';\n\ntry {\n  await rename(from, to);\n  const stats = await stat(to);\n  console.log(`stats: ${JSON.stringify(stats)}`);\n} catch (error) {\n  console.error('there was an error:', error.message);\n}\n</code></pre>\n<pre><code class=\"language-cjs\">const { rename, stat } = require('fs/promises');\n\n(async function(from, to) {\n  try {\n    await rename(from, to);\n    const stats = await stat(to);\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  } catch (error) {\n    console.error('there was an error:', error.message);\n  }\n})('/tmp/hello', '/tmp/world');\n</code></pre>\n<p>Or, when using the callback APIs, move the <code>fs.stat()</code> call into the callback\nof the <code>fs.rename()</code> operation:</p>\n<pre><code class=\"language-mjs\">import { rename, stat } from 'fs';\n\nrename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  stat('/tmp/world', (err, stats) => {\n    if (err) throw err;\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  });\n});\n</code></pre>\n<pre><code class=\"language-cjs\">const { rename, stat } = require('fs/promises');\n\nrename('/tmp/hello', '/tmp/world', (err) => {\n  if (err) throw err;\n  stat('/tmp/world', (err, stats) => {\n    if (err) throw err;\n    console.log(`stats: ${JSON.stringify(stats)}`);\n  });\n});\n</code></pre>",
+              "type": "module",
+              "displayName": "Ordering of callback and promise-based operations"
+            },
+            {
+              "textRaw": "File paths",
+              "name": "file_paths",
+              "desc": "<p>Most <code>fs</code> operations accept file paths that may be specified in the form of\na string, a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a>, or a <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a> object using the <code>file:</code> protocol.</p>",
+              "modules": [
                 {
-                  "textRaw": "`fd` {integer}",
-                  "name": "fd",
-                  "type": "integer"
+                  "textRaw": "String paths",
+                  "name": "string_paths",
+                  "desc": "<p>String form paths are interpreted as UTF-8 character sequences identifying\nthe absolute or relative filename. Relative paths will be resolved relative\nto the current working directory as determined by calling <code>process.cwd()</code>.</p>\n<p>Example using an absolute path on POSIX:</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet fd;\ntry {\n  fd = await open('/open/some/file.txt', 'r');\n  // Do something with the file\n} finally {\n  await fd.close();\n}\n</code></pre>\n<p>Example using a relative path on POSIX (relative to <code>process.cwd()</code>):</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet fd;\ntry {\n  fd = await open('file.txt', 'r');\n  // Do something with the file\n} finally {\n  await fd.close();\n}\n</code></pre>",
+                  "type": "module",
+                  "displayName": "String paths"
+                },
+                {
+                  "textRaw": "File URL paths",
+                  "name": "file_url_paths",
+                  "meta": {
+                    "added": [
+                      "v7.6.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>For most <code>fs</code> module functions, the <code>path</code> or <code>filename</code> argument may be passed\nas a <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a> object using the <code>file:</code> protocol.</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n\nreadFileSync(new URL('file:///tmp/hello'));\n</code></pre>\n<p><code>file:</code> URLs are always absolute paths.</p>",
+                  "modules": [
+                    {
+                      "textRaw": "Platform-specific considerations",
+                      "name": "platform-specific_considerations",
+                      "desc": "<p>On Windows, <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s with a host name convert to UNC paths, while <code>file:</code>\n<a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s with drive letters convert to local absolute paths. <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s\nwithout a host name nor a drive letter will result in an error:</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n// On Windows :\n\n// - WHATWG file URLs with hostname convert to UNC path\n// file://hostname/p/a/t/h/file => \\\\hostname\\p\\a\\t\\h\\file\nreadFileSync(new URL('file://hostname/p/a/t/h/file'));\n\n// - WHATWG file URLs with drive letters convert to absolute path\n// file:///C:/tmp/hello => C:\\tmp\\hello\nreadFileSync(new URL('file:///C:/tmp/hello'));\n\n// - WHATWG file URLs without hostname must have a drive letters\nreadFileSync(new URL('file:///notdriveletter/p/a/t/h/file'));\nreadFileSync(new URL('file:///c/p/a/t/h/file'));\n// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute\n</code></pre>\n<p><code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s with drive letters must use <code>:</code> as a separator just after\nthe drive letter. Using another separator will result in an error.</p>\n<p>On all other platforms, <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s with a host name are unsupported and\nwill result in an error:</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n// On other platforms:\n\n// - WHATWG file URLs with hostname are unsupported\n// file://hostname/p/a/t/h/file => throw!\nreadFileSync(new URL('file://hostname/p/a/t/h/file'));\n// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute\n\n// - WHATWG file URLs convert to absolute path\n// file:///tmp/hello => /tmp/hello\nreadFileSync(new URL('file:///tmp/hello'));\n</code></pre>\n<p>A <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a> having encoded slash characters will result in an error on all\nplatforms:</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n\n// On Windows\nreadFileSync(new URL('file:///C:/p/a/t/h/%2F'));\nreadFileSync(new URL('file:///C:/p/a/t/h/%2f'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n\\ or / characters */\n\n// On POSIX\nreadFileSync(new URL('file:///p/a/t/h/%2F'));\nreadFileSync(new URL('file:///p/a/t/h/%2f'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n/ characters */\n</code></pre>\n<p>On Windows, <code>file:</code> <a href=\"url.html#url_the_whatwg_url_api\" class=\"type\">&lt;URL&gt;</a>s having encoded backslash will result in an error:</p>\n<pre><code class=\"language-mjs\">import { readFileSync } from 'fs';\n\n// On Windows\nreadFileSync(new URL('file:///C:/path/%5C'));\nreadFileSync(new URL('file:///C:/path/%5c'));\n/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded\n\\ or / characters */\n</code></pre>",
+                      "type": "module",
+                      "displayName": "Platform-specific considerations"
+                    }
+                  ],
+                  "type": "module",
+                  "displayName": "File URL paths"
                 },
                 {
-                  "textRaw": "`buffers` {ArrayBufferView[]}",
-                  "name": "buffers",
-                  "type": "ArrayBufferView[]"
+                  "textRaw": "Buffer paths",
+                  "name": "buffer_paths",
+                  "desc": "<p>Paths specified using a <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> are useful primarily on certain POSIX\noperating systems that treat file paths as opaque byte sequences. On such\nsystems, it is possible for a single file path to contain sub-sequences that\nuse multiple character encodings. As with string paths, <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> paths may\nbe relative or absolute:</p>\n<p>Example using an absolute path on POSIX:</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet fd;\ntry {\n  fd = await open(Buffer.from('/open/some/file.txt'), 'r');\n  // Do something with the file\n} finally {\n  await fd.close();\n}\n</code></pre>",
+                  "type": "module",
+                  "displayName": "Buffer paths"
                 },
                 {
-                  "textRaw": "`position` {integer}",
-                  "name": "position",
-                  "type": "integer"
+                  "textRaw": "Per-drive working directories on Windows",
+                  "name": "per-drive_working_directories_on_windows",
+                  "desc": "<p>On Windows, Node.js follows the concept of per-drive working directory. This\nbehavior can be observed when using a drive path without a backslash. For\nexample <code>fs.readdirSync('C:\\\\')</code> can potentially return a different result than\n<code>fs.readdirSync('C:')</code>. For more information, see\n<a href=\"https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths\">this MSDN page</a>.</p>",
+                  "type": "module",
+                  "displayName": "Per-drive working directories on Windows"
                 }
-              ]
+              ],
+              "type": "module",
+              "displayName": "File paths"
+            },
+            {
+              "textRaw": "File descriptors",
+              "name": "file_descriptors",
+              "desc": "<p>On POSIX systems, for every process, the kernel maintains a table of currently\nopen files and resources. Each open file is assigned a simple numeric\nidentifier called a <em>file descriptor</em>. At the system-level, all file system\noperations use these file descriptors to identify and track each specific\nfile. Windows systems use a different but conceptually similar mechanism for\ntracking resources. To simplify things for users, Node.js abstracts away the\ndifferences between operating systems and assigns all open files a numeric file\ndescriptor.</p>\n<p>The callback-based <code>fs.open()</code>, and synchronous <code>fs.openSync()</code> methods open a\nfile and allocate a new file descriptor. Once allocated, the file descriptor may\nbe used to read data from, write data to, or request information about the file.</p>\n<p>Operating systems limit the number of file descriptors that may be open\nat any given time so it is critical to close the descriptor when operations\nare completed. Failure to do so will result in a memory leak that will\neventually cause an application to crash.</p>\n<pre><code class=\"language-mjs\">import { open, close, fstat } from 'fs';\n\nfunction closeFd(fd) {\n  close(fd, (err) => {\n    if (err) throw err;\n  });\n}\n\nopen('/open/some/file.txt', 'r', (err, fd) => {\n  if (err) throw err;\n  try {\n    fstat(fd, (err, stat) => {\n      if (err) {\n        closeFd(fd);\n        throw err;\n      }\n\n      // use stat\n\n      closeFd(fd);\n    });\n  } catch (err) {\n    closeFd(fd);\n    throw err;\n  }\n});\n</code></pre>\n<p>The promise-based APIs use a <a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a> object in place of the numeric\nfile descriptor. These objects are better managed by the system to ensure\nthat resources are not leaked. However, it is still required that they are\nclosed when operations are completed:</p>\n<pre><code class=\"language-mjs\">import { open } from 'fs/promises';\n\nlet file;\ntry {\n  file = await open('/open/some/file.txt', 'r');\n  const stat = await file.stat();\n  // use stat\n} finally {\n  await file.close();\n}\n</code></pre>",
+              "type": "module",
+              "displayName": "File descriptors"
+            },
+            {
+              "textRaw": "Threadpool usage",
+              "name": "threadpool_usage",
+              "desc": "<p>All callback and promise-based file system APIs ( with the exception of\n<code>fs.FSWatcher()</code>) use libuv's threadpool. This can have surprising and negative\nperformance implications for some applications. See the\n<a href=\"cli.html#cli_uv_threadpool_size_size\"><code>UV_THREADPOOL_SIZE</code></a> documentation for more information.</p>",
+              "type": "module",
+              "displayName": "Threadpool usage"
+            },
+            {
+              "textRaw": "File system flags",
+              "name": "file_system_flags",
+              "desc": "<p>The following flags are available wherever the <code>flag</code> option takes a\nstring.</p>\n<ul>\n<li>\n<p><code>'a'</code>: Open file for appending.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'ax'</code>: Like <code>'a'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'a+'</code>: Open file for reading and appending.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'ax+'</code>: Like <code>'a+'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'as'</code>: Open file for appending in synchronous mode.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'as+'</code>: Open file for reading and appending in synchronous mode.\nThe file is created if it does not exist.</p>\n</li>\n<li>\n<p><code>'r'</code>: Open file for reading.\nAn exception occurs if the file does not exist.</p>\n</li>\n<li>\n<p><code>'r+'</code>: Open file for reading and writing.\nAn exception occurs if the file does not exist.</p>\n</li>\n<li>\n<p><code>'rs+'</code>: Open file for reading and writing in synchronous mode. Instructs\nthe operating system to bypass the local file system cache.</p>\n<p>This is primarily useful for opening files on NFS mounts as it allows\nskipping the potentially stale local cache. It has a very real impact on\nI/O performance so using this flag is not recommended unless it is needed.</p>\n<p>This doesn't turn <code>fs.open()</code> or <code>fsPromises.open()</code> into a synchronous\nblocking call. If synchronous operation is desired, something like\n<code>fs.openSync()</code> should be used.</p>\n</li>\n<li>\n<p><code>'w'</code>: Open file for writing.\nThe file is created (if it does not exist) or truncated (if it exists).</p>\n</li>\n<li>\n<p><code>'wx'</code>: Like <code>'w'</code> but fails if the path exists.</p>\n</li>\n<li>\n<p><code>'w+'</code>: Open file for reading and writing.\nThe file is created (if it does not exist) or truncated (if it exists).</p>\n</li>\n<li>\n<p><code>'wx+'</code>: Like <code>'w+'</code> but fails if the path exists.</p>\n</li>\n</ul>\n<p><code>flag</code> can also be a number as documented by <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>; commonly used constants\nare available from <code>fs.constants</code>. On Windows, flags are translated to\ntheir equivalent ones where applicable, e.g. <code>O_WRONLY</code> to <code>FILE_GENERIC_WRITE</code>,\nor <code>O_EXCL|O_CREAT</code> to <code>CREATE_NEW</code>, as accepted by <code>CreateFileW</code>.</p>\n<p>The exclusive flag <code>'x'</code> (<code>O_EXCL</code> flag in <a href=\"http://man7.org/linux/man-pages/man2/open.2.html\"><code>open(2)</code></a>) causes the operation to\nreturn an error if the path already exists. On POSIX, if the path is a symbolic\nlink, using <code>O_EXCL</code> returns an error even if the link is to a path that does\nnot exist. The exclusive flag might not work with network file systems.</p>\n<p>On Linux, positional writes don't work when the file is opened in append mode.\nThe kernel ignores the position argument and always appends the data to\nthe end of the file.</p>\n<p>Modifying a file rather than replacing it may require the <code>flag</code> option to be\nset to <code>'r+'</code> rather than the default <code>'w'</code>.</p>\n<p>The behavior of some flags are platform-specific. As such, opening a directory\non macOS and Linux with the <code>'a+'</code> flag, as in the example below, will return an\nerror. In contrast, on Windows and FreeBSD, a file descriptor or a <code>FileHandle</code>\nwill be returned.</p>\n<pre><code class=\"language-js\">// macOS and Linux\nfs.open('&#x3C;directory>', 'a+', (err, fd) => {\n  // => [Error: EISDIR: illegal operation on a directory, open &#x3C;directory>]\n});\n\n// Windows and FreeBSD\nfs.open('&#x3C;directory>', 'a+', (err, fd) => {\n  // => null, &#x3C;fd>\n});\n</code></pre>\n<p>On Windows, opening an existing hidden file using the <code>'w'</code> flag (either\nthrough <code>fs.open()</code> or <code>fs.writeFile()</code> or <code>fsPromises.open()</code>) will fail with\n<code>EPERM</code>. Existing hidden files can be opened for writing with the <code>'r+'</code> flag.</p>\n<p>A call to <code>fs.ftruncate()</code> or <code>filehandle.truncate()</code> can be used to reset\nthe file contents.</p>",
+              "type": "module",
+              "displayName": "File system flags"
             }
           ],
-          "desc": "<p>For detailed information, see the documentation of the asynchronous version of\nthis API: <a href=\"#fs_fs_writev_fd_buffers_position_callback\"><code>fs.writev()</code></a>.</p>"
-        }
-      ],
-      "properties": [
-        {
-          "textRaw": "`constants` {Object}",
-          "type": "Object",
-          "name": "constants",
-          "desc": "<p>Returns an object containing commonly used constants for file system\noperations. The specific constants currently defined are described in\n<a href=\"#fs_fs_constants_1\">FS constants</a>.</p>"
+          "type": "module",
+          "displayName": "Notes"
         }
       ],
       "type": "module",
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 778c6f3ff59630c0e3ed99ecdb1008334792cbd3..88cbbb4afbc1708ab4f50ace013a3436c77badfc 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -11,60 +11,51 @@
 The `fs` module enables interacting with the file system in a
 way modeled on standard POSIX functions.
 
-To use this module:
+To use the promise-based APIs:
 
-```js
-const fs = require('fs');
+```mjs
+import * as fs from 'fs/promises';
 ```
 
-All file system operations have synchronous, callback, and promise-based
-forms.
+```cjs
+const fs = require('fs/promises');
+```
 
-## Synchronous example
+To use the callback and sync APIs:
 
-The synchronous form blocks the Node.js event loop and further JavaScript
-execution until the operation is complete. Exceptions are thrown immediately
-and can be handled using `try…catch`, or can be allowed to bubble up.
+```mjs
+import * as fs from 'fs';
+```
 
-```js
+```cjs
 const fs = require('fs');
-
-try {
-  fs.unlinkSync('/tmp/hello');
-  console.log('successfully deleted /tmp/hello');
-} catch (err) {
-  // handle the error
-}
 ```
 
-## Callback example
+All file system operations have synchronous, callback, and promise-based
+forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).
 
-The callback form takes a completion callback function as its last
-argument and invokes the operation asynchronously. The arguments passed to
-the completion callback depend on the method, but the first argument is always
-reserved for an exception. If the operation is completed successfully, then
-the first argument is `null` or `undefined`.
+## Promise example
 
-```js
-const fs = require('fs');
+Promise-based operations return a promise that is fulfilled when the
+asynchronous operation is complete.
 
-fs.unlink('/tmp/hello', (err) => {
-  if (err) throw err;
+```mjs
+import { unlink } from 'fs/promises';
+
+try {
+  await unlink('/tmp/hello');
   console.log('successfully deleted /tmp/hello');
-});
+} catch (error) {
+  console.error('there was an error:', error.message);
+}
 ```
 
-## Promise example
-
-Promise-based operations return a `Promise` that is resolved when the
-asynchronous operation is complete.
-
-```js
-const fs = require('fs').promises;
+```cjs
+const { unlink } = require('fs/promises');
 
 (async function(path) {
   try {
-    await fs.unlink(path);
+    await unlink(path);
     console.log(`successfully deleted ${path}`);
   } catch (error) {
     console.error('there was an error:', error.message);
@@ -72,1092 +63,1289 @@ const fs = require('fs').promises;
 })('/tmp/hello');
 ```
 
-## Ordering of callback and promise-based operations
+## Callback example
 
-There is no guaranteed ordering when using either the callback or
-promise-based methods. For example, the following is prone to error
-because the `fs.stat()` operation might complete before the `fs.rename()`
-operation:
+The callback form takes a completion callback function as its last
+argument and invokes the operation asynchronously. The arguments passed to
+the completion callback depend on the method, but the first argument is always
+reserved for an exception. If the operation is completed successfully, then
+the first argument is `null` or `undefined`.
 
-```js
-fs.rename('/tmp/hello', '/tmp/world', (err) => {
-  if (err) throw err;
-  console.log('renamed complete');
-});
-fs.stat('/tmp/world', (err, stats) => {
+```mjs
+import { unlink } from 'fs';
+
+unlink('/tmp/hello', (err) => {
   if (err) throw err;
-  console.log(`stats: ${JSON.stringify(stats)}`);
+  console.log('successfully deleted /tmp/hello');
 });
 ```
 
-To correctly order the operations, move the `fs.stat()` call into the callback
-of the `fs.rename()` operation:
+```cjs
+const { unlink } = require('fs');
 
-```js
-fs.rename('/tmp/hello', '/tmp/world', (err) => {
+unlink('/tmp/hello', (err) => {
   if (err) throw err;
-  fs.stat('/tmp/world', (err, stats) => {
-    if (err) throw err;
-    console.log(`stats: ${JSON.stringify(stats)}`);
-  });
+  console.log('successfully deleted /tmp/hello');
 });
 ```
 
-Or, use the promise-based API:
-
-```js
-const fs = require('fs').promises;
-
-(async function(from, to) {
-  try {
-    await fs.rename(from, to);
-    const stats = await fs.stat(to);
-    console.log(`stats: ${JSON.stringify(stats)}`);
-  } catch (error) {
-    console.error('there was an error:', error.message);
-  }
-})('/tmp/hello', '/tmp/world');
-```
-
-## File paths
-
-Most `fs` operations accept filepaths that may be specified in the form of
-a string, a [`Buffer`][], or a [`URL`][] object using the `file:` protocol.
-
-String form paths are interpreted as UTF-8 character sequences identifying
-the absolute or relative filename. Relative paths will be resolved relative
-to the current working directory as determined by calling `process.cwd()`.
-
-Example using an absolute path on POSIX:
+The callback-based versions of the `fs` module APIs are preferable over
+the use of the promise APIs when maximal performance (both in terms of
+execution time and memory allocation are required).
 
-```js
-const fs = require('fs');
+## Synchronous example
 
-fs.open('/open/some/file.txt', 'r', (err, fd) => {
-  if (err) throw err;
-  fs.close(fd, (err) => {
-    if (err) throw err;
-  });
-});
-```
+The synchronous APIs block the Node.js event loop and further JavaScript
+execution until the operation is complete. Exceptions are thrown immediately
+and can be handled using `try…catch`, or can be allowed to bubble up.
 
-Example using a relative path on POSIX (relative to `process.cwd()`):
+```mjs
+import { unlinkSync } from 'fs';
 
-```js
-fs.open('file.txt', 'r', (err, fd) => {
-  if (err) throw err;
-  fs.close(fd, (err) => {
-    if (err) throw err;
-  });
-});
+try {
+  unlinkSync('/tmp/hello');
+  console.log('successfully deleted /tmp/hello');
+} catch (err) {
+  // handle the error
+}
 ```
 
-Paths specified using a [`Buffer`][] are useful primarily on certain POSIX
-operating systems that treat file paths as opaque byte sequences. On such
-systems, it is possible for a single file path to contain sub-sequences that
-use multiple character encodings. As with string paths, `Buffer` paths may
-be relative or absolute:
-
-Example using an absolute path on POSIX:
+```cjs
+const { unlinkSync } = require('fs');
 
-```js
-fs.open(Buffer.from('/open/some/file.txt'), 'r', (err, fd) => {
-  if (err) throw err;
-  fs.close(fd, (err) => {
-    if (err) throw err;
-  });
-});
+try {
+  unlinkSync('/tmp/hello');
+  console.log('successfully deleted /tmp/hello');
+} catch (err) {
+  // handle the error
+}
 ```
 
-On Windows, Node.js follows the concept of per-drive working directory. This
-behavior can be observed when using a drive path without a backslash. For
-example `fs.readdirSync('C:\\')` can potentially return a different result than
-`fs.readdirSync('C:')`. For more information, see
-[this MSDN page][MSDN-Rel-Path].
+## Promises API
+<!-- YAML
+added: v10.0.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31553
+    description: Exposed as `require('fs/promises')`.
+  - version:
+    - v11.14.0
+    - v10.17.0
+    pr-url: https://github.com/nodejs/node/pull/26581
+    description: This API is no longer experimental.
+  - version: v10.1.0
+    pr-url: https://github.com/nodejs/node/pull/20504
+    description: The API is accessible via `require('fs').promises` only.
+-->
+
+The `fs/promises` API provides asynchronous file system methods that return
+promises.
+
+The promise APIs use the underlying Node.js threadpool to perform file
+system operations off the event loop thread. These operations are not
+synchronized or threadsafe. Care must be taken when performing multiple
+concurrent modifications on the same file or data corruption may occur.
 
-### URL object support
+### Class: `FileHandle`
 <!-- YAML
-added: v7.6.0
+added: v10.0.0
 -->
-For most `fs` module functions, the `path` or `filename` argument may be passed
-as a WHATWG [`URL`][] object. Only [`URL`][] objects using the `file:` protocol
-are supported.
 
-```js
-const fs = require('fs');
-const fileUrl = new URL('file:///tmp/hello');
+A {FileHandle} object is an object wrapper for a numeric file descriptor.
 
-fs.readFileSync(fileUrl);
-```
+Instances of the {FileHandle} object are created by the `fsPromises.open()`
+method.
 
-`file:` URLs are always absolute paths.
+All {FileHandle} objects are {EventEmitter}s.
 
-Using WHATWG [`URL`][] objects might introduce platform-specific behaviors.
+If a {FileHandle} is not closed using the `filehandle.close()` method, it will
+try to automatically close the file descriptor and emit a process warning,
+helping to prevent memory leaks. Please do not rely on this behavior because
+it can be unreliable and the file may not be closed. Instead, always explicitly
+close {FileHandle}s. Node.js may change this behavior in the future.
 
-On Windows, `file:` URLs with a host name convert to UNC paths, while `file:`
-URLs with drive letters convert to local absolute paths. `file:` URLs without a
-host name nor a drive letter will result in a throw:
+#### `filehandle.appendFile(data[, options])`
+<!-- YAML
+added: v10.0.0
+-->
 
-```js
-// On Windows :
+* `data` {string|Buffer|TypedArray|DataView}
+* `options` {Object|string}
+  * `encoding` {string|null} **Default:** `'utf8'`
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-// - WHATWG file URLs with hostname convert to UNC path
-// file://hostname/p/a/t/h/file => \\hostname\p\a\t\h\file
-fs.readFileSync(new URL('file://hostname/p/a/t/h/file'));
+Alias of [`filehandle.writeFile()`][].
 
-// - WHATWG file URLs with drive letters convert to absolute path
-// file:///C:/tmp/hello => C:\tmp\hello
-fs.readFileSync(new URL('file:///C:/tmp/hello'));
+When operating on file handles, the mode cannot be changed from what it was set
+to with [`fsPromises.open()`][]. Therefore, this is equivalent to
+[`filehandle.writeFile()`][].
 
-// - WHATWG file URLs without hostname must have a drive letters
-fs.readFileSync(new URL('file:///notdriveletter/p/a/t/h/file'));
-fs.readFileSync(new URL('file:///c/p/a/t/h/file'));
-// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute
-```
+#### `filehandle.chmod(mode)`
+<!-- YAML
+added: v10.0.0
+-->
 
-`file:` URLs with drive letters must use `:` as a separator just after
-the drive letter. Using another separator will result in a throw.
+* `mode` {integer} the file mode bit mask.
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-On all other platforms, `file:` URLs with a host name are unsupported and will
-result in a throw:
+Modifies the permissions on the file. See chmod(2).
 
-```js
-// On other platforms:
+#### `filehandle.chown(uid, gid)`
+<!-- YAML
+added: v10.0.0
+-->
 
-// - WHATWG file URLs with hostname are unsupported
-// file://hostname/p/a/t/h/file => throw!
-fs.readFileSync(new URL('file://hostname/p/a/t/h/file'));
-// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute
+* `uid` {integer} The file's new owner's user id.
+* `gid` {integer} The file's new group's group id.
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-// - WHATWG file URLs convert to absolute path
-// file:///tmp/hello => /tmp/hello
-fs.readFileSync(new URL('file:///tmp/hello'));
-```
+Changes the ownership of the file. A wrapper for chown(2).
 
-A `file:` URL having encoded slash characters will result in a throw on all
-platforms:
+#### `filehandle.close()`
+<!-- YAML
+added: v10.0.0
+-->
 
-```js
-// On Windows
-fs.readFileSync(new URL('file:///C:/p/a/t/h/%2F'));
-fs.readFileSync(new URL('file:///C:/p/a/t/h/%2f'));
-/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-\ or / characters */
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-// On POSIX
-fs.readFileSync(new URL('file:///p/a/t/h/%2F'));
-fs.readFileSync(new URL('file:///p/a/t/h/%2f'));
-/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-/ characters */
-```
+Closes the file handle after waiting for any pending operation on the handle to
+complete.
 
-On Windows, `file:` URLs having encoded backslash will result in a throw:
+```mjs
+import { open } from 'fs/promises';
 
-```js
-// On Windows
-fs.readFileSync(new URL('file:///C:/path/%5C'));
-fs.readFileSync(new URL('file:///C:/path/%5c'));
-/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
-\ or / characters */
+let filehandle;
+try {
+  filehandle = await open('thefile.txt', 'r');
+} finally {
+  await filehandle?.close();
+}
 ```
 
-## File descriptors
-
-On POSIX systems, for every process, the kernel maintains a table of currently
-open files and resources. Each open file is assigned a simple numeric
-identifier called a *file descriptor*. At the system-level, all file system
-operations use these file descriptors to identify and track each specific
-file. Windows systems use a different but conceptually similar mechanism for
-tracking resources. To simplify things for users, Node.js abstracts away the
-specific differences between operating systems and assigns all open files a
-numeric file descriptor.
-
-The `fs.open()` method is used to allocate a new file descriptor. Once
-allocated, the file descriptor may be used to read data from, write data to,
-or request information about the file.
+#### `filehandle.datasync()`
+<!-- YAML
+added: v10.0.0
+-->
 
-```js
-fs.open('/open/some/file.txt', 'r', (err, fd) => {
-  if (err) throw err;
-  fs.fstat(fd, (err, stat) => {
-    if (err) throw err;
-    // use stat
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-    // always close the file descriptor!
-    fs.close(fd, (err) => {
-      if (err) throw err;
-    });
-  });
-});
-```
+Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+fdatasync(2) documentation for details.
 
-Most operating systems limit the number of file descriptors that may be open
-at any given time so it is critical to close the descriptor when operations
-are completed. Failure to do so will result in a memory leak that will
-eventually cause an application to crash.
+Unlike `filehandle.sync` this method does not flush modified metadata.
 
-## Threadpool usage
+#### `filehandle.fd`
+<!-- YAML
+added: v10.0.0
+-->
 
-All file system APIs except `fs.FSWatcher()` and those that are explicitly
-synchronous use libuv's threadpool, which can have surprising and negative
-performance implications for some applications. See the
-[`UV_THREADPOOL_SIZE`][] documentation for more information.
+* {number} The numeric file descriptor managed by the {FileHandle} object.
 
-## Class: `fs.Dir`
+#### `filehandle.read(buffer, offset, length, position)`
 <!-- YAML
-added: v12.12.0
+added: v10.0.0
 -->
 
-A class representing a directory stream.
+* `buffer` {Buffer|TypedArray|DataView} A buffer that will be filled with the
+  file data read.
+* `offset` {integer} The location in the buffer at which to start filling.
+  **Default:** `0`
+* `length` {integer} The number of bytes to read. **Default:**
+  `buffer.byteLength`
+* `position` {integer} The location where to begin reading data from the
+  file. If `null`, data will be read from the current file position, and
+  the position will be updated. If `position` is an integer, the current
+  file position will remain unchanged.
+* Returns: {Promise} Fulfills upon success with an object with two properties:
+  * `bytesRead` {integer} The number of bytes read
+  * `buffer` {Buffer|TypedArray|DataView} A reference to the passed in `buffer`
+    argument.
 
-Created by [`fs.opendir()`][], [`fs.opendirSync()`][], or
-[`fsPromises.opendir()`][].
+Reads data from the file and stores that in the given buffer.
 
-```js
-const fs = require('fs');
+If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.
 
-async function print(path) {
-  const dir = await fs.promises.opendir(path);
-  for await (const dirent of dir) {
-    console.log(dirent.name);
-  }
-}
-print('./').catch(console.error);
-```
+#### `filehandle.read([options])`
+<!-- YAML
+added:
+ - v13.11.0
+ - v12.17.0
+-->
+* `options` {Object}
+  * `buffer` {Buffer|TypedArray|DataView} A buffer that will be filled with the
+    file data read. **Default:** `Buffer.alloc(16384)`
+  * `offset` {integer} The location in the buffer at which to start filling.
+    **Default:** `0`
+  * `length` {integer} The number of bytes to read. **Default:**
+    `buffer.byteLength`
+  * `position` {integer} The location where to begin reading data from the
+    file. If `null`, data will be read from the current file position, and
+    the position will be updated. If `position` is an integer, the current
+    file position will remain unchanged. **Default:**: `null`
+* Returns: {Promise} Fulfills upon success with an object with two properties:
+  * `bytesRead` {integer} The number of bytes read
+  * `buffer` {Buffer|TypedArray|DataView} A reference to the passed in `buffer`
+    argument.
+
+Reads data from the file and stores that in the given buffer.
+
+If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.
 
-### `dir.close()`
+#### `filehandle.readFile(options)`
 <!-- YAML
-added: v12.12.0
+added: v10.0.0
 -->
 
-* Returns: {Promise}
+* `options` {Object|string}
+  * `encoding` {string|null} **Default:** `null`
+  * `signal` {AbortSignal} allows aborting an in-progress readFile
+* Returns: {Promise} Fulfills upon a successful read with the contents of the
+  file. If no encoding is specified (using `options.encoding`), the data is
+  returned as a {Buffer} object. Otherwise, the data will be a string.
 
-Asynchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.
+Asynchronously reads the entire contents of a file.
 
-A `Promise` is returned that will be resolved after the resource has been
-closed.
+If `options` is a string, then it specifies the `encoding`.
+
+The {FileHandle} has to support reading.
 
-### `dir.close(callback)`
+If one or more `filehandle.read()` calls are made on a file handle and then a
+`filehandle.readFile()` call is made, the data will be read from the current
+position till the end of the file. It doesn't always read from the beginning
+of the file.
+
+#### `filehandle.readv(buffers[, position])`
 <!-- YAML
-added: v12.12.0
+added:
+ - v13.13.0
+ - v12.17.0
 -->
 
-* `callback` {Function}
-  * `err` {Error}
-
-Asynchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.
+* `buffers` {Buffer[]|TypedArray[]|DataView[]}
+* `position` {integer} The offset from the beginning of the file where the data
+  should be read from. If `position` is not a `number`, the data will be read
+  from the current position.
+* Returns: {Promise} Fulfills upon success an object containing two properties:
+  * `bytesRead` {integer} the number of bytes read
+  * `buffers` {Buffer[]|TypedArray[]|DataView[]} property containing
+    a reference to the `buffers` input.
 
-The `callback` will be called after the resource handle has been closed.
+Read from a file and write to an array of {ArrayBufferView}s
 
-### `dir.closeSync()`
+#### `filehandle.stat([options])`
 <!-- YAML
-added: v12.12.0
--->
+added: v10.0.0
+changes:
+  - version: v10.5.0
+    pr-url: https://github.com/nodejs/node/pull/20220
+    description: Accepts an additional `options` object to specify whether
+                 the numeric values returned should be bigint.
+-->
 
-Synchronously close the directory's underlying resource handle.
-Subsequent reads will result in errors.
+* `options` {Object}
+  * `bigint` {boolean} Whether the numeric values in the returned
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
+* Returns: {Promise} Fulfills with an {fs.Stats} for the file.
 
-### `dir.path`
+#### `filehandle.sync()`
 <!-- YAML
-added: v12.12.0
+added: v10.0.0
 -->
 
-* {string}
+* Returns: {Promise} Fufills with `undefined` upon success.
 
-The read-only path of this directory as was provided to [`fs.opendir()`][],
-[`fs.opendirSync()`][], or [`fsPromises.opendir()`][].
+Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX fsync(2) documentation for more detail.
 
-### `dir.read()`
+#### `filehandle.truncate(len)`
 <!-- YAML
-added: v12.12.0
+added: v10.0.0
 -->
 
-* Returns: {Promise} containing {fs.Dirent|null}
-
-Asynchronously read the next directory entry via readdir(3) as an
-[`fs.Dirent`][].
+* `len` {integer} **Default:** `0`
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-After the read is completed, a `Promise` is returned that will be resolved with
-an [`fs.Dirent`][], or `null` if there are no more directory entries to read.
+Truncates the file.
 
-Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.
+If the file was larger than `len` bytes, only the first `len` bytes will be
+retained in the file.
 
-### `dir.read(callback)`
-<!-- YAML
-added: v12.12.0
--->
+The following example retains only the first four bytes of the file:
 
-* `callback` {Function}
-  * `err` {Error}
-  * `dirent` {fs.Dirent|null}
+```mjs
+import { open } from 'fs/promises';
 
-Asynchronously read the next directory entry via readdir(3) as an
-[`fs.Dirent`][].
+let filehandle = null;
+try {
+  filehandle = await open('temp.txt', 'r+');
+  await filehandle.truncate(4);
+} finally {
+  await filehandle?.close();
+}
+```
 
-After the read is completed, the `callback` will be called with an
-[`fs.Dirent`][], or `null` if there are no more directory entries to read.
+If the file previously was shorter than `len` bytes, it is extended, and the
+extended part is filled with null bytes (`'\0'`):
 
-Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.
+If `len` is negative then `0` will be used.
 
-### `dir.readSync()`
+#### `filehandle.utimes(atime, mtime)`
 <!-- YAML
-added: v12.12.0
+added: v10.0.0
 -->
 
-* Returns: {fs.Dirent|null}
-
-Synchronously read the next directory entry via readdir(3) as an
-[`fs.Dirent`][].
+* `atime` {number|string|Date}
+* `mtime` {number|string|Date}
+* Returns: {Promise}
 
-If there are no more directory entries to read, `null` will be returned.
+Change the file system timestamps of the object referenced by the {FileHandle}
+then resolves the promise with no arguments upon success.
 
-Directory entries returned by this function are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.
+This function does not work on AIX versions before 7.1, it will reject the
+promise with an error using code `UV_ENOSYS`.
 
-### `dir[Symbol.asyncIterator]()`
+#### `filehandle.write(buffer[, offset[, length[, position]]])`
 <!-- YAML
-added: v12.12.0
--->
-
-* Returns: {AsyncIterator} of {fs.Dirent}
-
-Asynchronously iterates over the directory via readdir(3) until all entries have
-been read.
+added: v10.0.0
+changes:
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `buffer` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `buffer` parameter won't coerce unsupported input to
+                 buffers anymore.
+-->
+
+* `buffer` {Buffer|TypedArray|DataView|string|Object}
+* `offset` {integer} The start position from within `buffer` where the data
+  to write begins. **Default:** `0`
+* `length` {integer} The number of bytes from `buffer` to write. **Default:**
+  `buffer.byteLength`
+* `position` {integer} The offset from the beginning of the file where the
+  data from `buffer` should be written. If `position` is not a `number`,
+  the data will be written at the current position. See the POSIX pwrite(2)
+  documentation for more detail.
+* Returns: {Promise}
 
-Entries returned by the async iterator are always an [`fs.Dirent`][].
-The `null` case from `dir.read()` is handled internally.
+Write `buffer` to the file.
 
-See [`fs.Dir`][] for an example.
+If `buffer` is a plain object, it must have an own (not inherited) `toString`
+function property.
 
-Directory entries returned by this iterator are in no particular order as
-provided by the operating system's underlying directory mechanisms.
-Entries added or removed while iterating over the directory may or may not be
-included in the iteration results.
+The promise is resolved with an object containing two properties:
 
-## Class: `fs.Dirent`
-<!-- YAML
-added: v10.10.0
--->
+* `bytesWritten` {integer} the number of bytes written
+* `buffer` {Buffer|TypedArray|DataView|string|Object} a reference to the
+  `buffer` written.
 
-A representation of a directory entry, which can be a file or a subdirectory
-within the directory, as returned by reading from an [`fs.Dir`][]. The
-directory entry is a combination of the file name and file type pairs.
+It is unsafe to use `filehandle.write()` multiple times on the same file
+without waiting for the promise to be resolved (or rejected). For this
+scenario, use [`fs.createWriteStream()`][].
 
-Additionally, when [`fs.readdir()`][] or [`fs.readdirSync()`][] is called with
-the `withFileTypes` option set to `true`, the resulting array is filled with
-`fs.Dirent` objects, rather than strings or `Buffers`.
+On Linux, positional writes do not work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.
 
-### `dirent.isBlockDevice()`
+#### `filehandle.write(string[, position[, encoding]])`
 <!-- YAML
-added: v10.10.0
+added: v10.0.0
+changes:
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `string` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `string` parameter won't coerce unsupported input to
+                 strings anymore.
 -->
 
-* Returns: {boolean}
-
-Returns `true` if the `fs.Dirent` object describes a block device.
-
-### `dirent.isCharacterDevice()`
-<!-- YAML
-added: v10.10.0
--->
+* `string` {string|Object}
+* `position` {integer} The offset from the beginning of the file where the
+  data from `string` should be written. If `position` is not a `number` the
+  data will be written at the current position. See the POSIX pwrite(2)
+  documentation for more detail.
+* `encoding` {string} The expected string encoding. **Default:** `'utf8'`
+* Returns: {Promise}
 
-* Returns: {boolean}
+Write `string` to the file. If `string` is not a string, or an object with an
+own `toString` function property, the promise is rejected with an error.
 
-Returns `true` if the `fs.Dirent` object describes a character device.
+The promise is resolved with an object containing two properties:
 
-### `dirent.isDirectory()`
-<!-- YAML
-added: v10.10.0
--->
+* `bytesWritten` {integer} the number of bytes written
+* `buffer` {string|Object} a reference to the `string` written.
 
-* Returns: {boolean}
+It is unsafe to use `filehandle.write()` multiple times on the same file
+without waiting for the promise to be resolved (or rejected). For this
+scenario, use [`fs.createWriteStream()`][].
 
-Returns `true` if the `fs.Dirent` object describes a file system
-directory.
+On Linux, positional writes do not work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.
 
-### `dirent.isFIFO()`
+#### `filehandle.writeFile(data, options)`
 <!-- YAML
-added: v10.10.0
+added: v10.0.0
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37490
+    description: The `data` argument supports `AsyncIterable`, `Iterable` and `Stream`.
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `data` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `data` parameter won't coerce unsupported input to
+                 strings anymore.
 -->
 
-* Returns: {boolean}
+* `data` {string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable
+  |Stream}
+* `options` {Object|string}
+  * `encoding` {string|null} The expected character encoding when `data` is a
+    string. **Default:** `'utf8'`
+* Returns: {Promise}
 
-Returns `true` if the `fs.Dirent` object describes a first-in-first-out
-(FIFO) pipe.
+Asynchronously writes data to a file, replacing the file if it already exists.
+`data` can be a string, a buffer, an {AsyncIterable} or {Iterable} object, or an
+object with an own `toString` function
+property. The promise is resolved with no arguments upon success.
 
-### `dirent.isFile()`
-<!-- YAML
-added: v10.10.0
--->
+If `options` is a string, then it specifies the `encoding`.
 
-* Returns: {boolean}
+The {FileHandle} has to support writing.
+
+It is unsafe to use `filehandle.writeFile()` multiple times on the same file
+without waiting for the promise to be resolved (or rejected).
 
-Returns `true` if the `fs.Dirent` object describes a regular file.
+If one or more `filehandle.write()` calls are made on a file handle and then a
+`filehandle.writeFile()` call is made, the data will be written from the
+current position till the end of the file. It doesn't always write from the
+beginning of the file.
 
-### `dirent.isSocket()`
+#### `filehandle.writev(buffers[, position])`
 <!-- YAML
-added: v10.10.0
+added: v12.9.0
 -->
 
-* Returns: {boolean}
+* `buffers` {Buffer[]|TypedArray[]|DataView[]}
+* `position` {integer} The offset from the beginning of the file where the
+  data from `buffers` should be written. If `position` is not a `number`,
+  the data will be written at the current position.
+* Returns: {Promise}
 
-Returns `true` if the `fs.Dirent` object describes a socket.
+Write an array of {ArrayBufferView}s to the file.
 
-### `dirent.isSymbolicLink()`
-<!-- YAML
-added: v10.10.0
--->
+The promise is resolved with an object containing a two properties:
 
-* Returns: {boolean}
+* `bytesWritten` {integer} the number of bytes written
+* `buffers` {Buffer[]|TypedArray[]|DataView[]} a reference to the `buffers`
+  input.
+
+It is unsafe to call `writev()` multiple times on the same file without waiting
+for the promise to be resolved (or rejected).
 
-Returns `true` if the `fs.Dirent` object describes a symbolic link.
+On Linux, positional writes don't work when the file is opened in append mode.
+The kernel ignores the position argument and always appends the data to
+the end of the file.
 
-### `dirent.name`
+### `fsPromises.access(path[, mode])`
 <!-- YAML
-added: v10.10.0
+added: v10.0.0
 -->
 
-* {string|Buffer}
+* `path` {string|Buffer|URL}
+* `mode` {integer} **Default:** `fs.constants.F_OK`
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-The file name that this `fs.Dirent` object refers to. The type of this
-value is determined by the `options.encoding` passed to [`fs.readdir()`][] or
-[`fs.readdirSync()`][].
+Tests a user's permissions for the file or directory specified by `path`.
+The `mode` argument is an optional integer that specifies the accessibility
+checks to be performed. Check [File access constants][] for possible values
+of `mode`. It is possible to create a mask consisting of the bitwise OR of
+two or more values (e.g. `fs.constants.W_OK | fs.constants.R_OK`).
 
-## Class: `fs.FSWatcher`
-<!-- YAML
-added: v0.5.8
--->
+If the accessibility check is successful, the promise is resolved with no
+value. If any of the accessibility checks fail, the promise is rejected
+with an {Error} object. The following example checks if the file
+`/etc/passwd` can be read and written by the current process.
 
-* Extends {EventEmitter}
+```mjs
+import { access } from 'fs/promises';
+import { constants } from 'fs';
 
-A successful call to [`fs.watch()`][] method will return a new `fs.FSWatcher`
-object.
+try {
+  await access('/etc/passwd', constants.R_OK | constants.W_OK);
+  console.log('can access');
+} catch {
+  console.error('cannot access');
+}
+```
 
-All `fs.FSWatcher` objects emit a `'change'` event whenever a specific watched
-file is modified.
+Using `fsPromises.access()` to check for the accessibility of a file before
+calling `fsPromises.open()` is not recommended. Doing so introduces a race
+condition, since other processes may change the file's state between the two
+calls. Instead, user code should open/read/write the file directly and handle
+the error raised if the file is not accessible.
 
-### Event: `'change'`
+### `fsPromises.appendFile(path, data[, options])`
 <!-- YAML
-added: v0.5.8
+added: v10.0.0
 -->
 
-* `eventType` {string} The type of change event that has occurred
-* `filename` {string|Buffer} The filename that changed (if relevant/available)
+* `path` {string|Buffer|URL|FileHandle} filename or {FileHandle}
+* `data` {string|Buffer}
+* `options` {Object|string}
+  * `encoding` {string|null} **Default:** `'utf8'`
+  * `mode` {integer} **Default:** `0o666`
+  * `flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-Emitted when something changes in a watched directory or file.
-See more details in [`fs.watch()`][].
+Asynchronously append data to a file, creating the file if it does not yet
+exist. `data` can be a string or a {Buffer}.
 
-The `filename` argument may not be provided depending on operating system
-support. If `filename` is provided, it will be provided as a `Buffer` if
-`fs.watch()` is called with its `encoding` option set to `'buffer'`, otherwise
-`filename` will be a UTF-8 string.
+If `options` is a string, then it specifies the `encoding`.
 
-```js
-// Example when handled through fs.watch() listener
-fs.watch('./tmp', { encoding: 'buffer' }, (eventType, filename) => {
-  if (filename) {
-    console.log(filename);
-    // Prints: <Buffer ...>
-  }
-});
-```
+The `mode` option only affects the newly created file. See [`fs.open()`][]
+for more details.
+
+The `path` may be specified as a {FileHandle} that has been opened
+for appending (using `fsPromises.open()`).
 
-### Event: `'close'`
+### `fsPromises.chmod(path, mode)`
 <!-- YAML
 added: v10.0.0
 -->
 
-Emitted when the watcher stops watching for changes. The closed
-`fs.FSWatcher` object is no longer usable in the event handler.
+* `path` {string|Buffer|URL}
+* `mode` {string|integer}
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-### Event: `'error'`
+Changes the permissions of a file.
+
+### `fsPromises.chown(path, uid, gid)`
 <!-- YAML
-added: v0.5.8
+added: v10.0.0
 -->
 
-* `error` {Error}
+* `path` {string|Buffer|URL}
+* `uid` {integer}
+* `gid` {integer}
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-Emitted when an error occurs while watching the file. The errored
-`fs.FSWatcher` object is no longer usable in the event handler.
+Changes the ownership of a file.
 
-### `watcher.close()`
+### `fsPromises.copyFile(src, dest[, mode])`
 <!-- YAML
-added: v0.5.8
+added: v10.0.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/27044
+    description: Changed 'flags' argument to 'mode' and imposed
+                 stricter type validation.
 -->
 
-Stop watching for changes on the given `fs.FSWatcher`. Once stopped, the
-`fs.FSWatcher` object is no longer usable.
+* `src` {string|Buffer|URL} source filename to copy
+* `dest` {string|Buffer|URL} destination filename of the copy operation
+* `mode` {integer} Optional modifiers that specify the behavior of the copy
+  operation. It is possible to create a mask consisting of the bitwise OR of
+  two or more values (e.g.
+  `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`)
+  **Default:** `0`.
+  * `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest`
+    already exists.
+  * `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create
+    a copy-on-write reflink. If the platform does not support copy-on-write,
+    then a fallback copy mechanism is used.
+  * `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to
+    create a copy-on-write reflink. If the platform does not support
+    copy-on-write, then the operation will fail.
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-### `watcher.ref()`
-<!-- YAML
-added: v12.20.0
--->
+Asynchronously copies `src` to `dest`. By default, `dest` is overwritten if it
+already exists.
 
-* Returns: {fs.FSWatcher}
+No guarantees are made about the atomicity of the copy operation. If an
+error occurs after the destination file has been opened for writing, an attempt
+will be made to remove the destination.
 
-When called, requests that the Node.js event loop *not* exit so long as the
-`FSWatcher` is active. Calling `watcher.ref()` multiple times will have
-no effect.
+```mjs
+import { constants } from 'fs';
+import { copyFile } from 'fs/promises';
 
-By default, all `FSWatcher` objects are "ref'ed", making it normally
-unnecessary to call `watcher.ref()` unless `watcher.unref()` had been
-called previously.
+try {
+  await copyFile('source.txt', 'destination.txt');
+  console.log('source.txt was copied to destination.txt');
+} catch {
+  console.log('The file could not be copied');
+}
+
+// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
+try {
+  await copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL);
+  console.log('source.txt was copied to destination.txt');
+} catch {
+  console.log('The file could not be copied');
+}
+```
 
-### `watcher.unref()`
+### `fsPromises.lchmod(path, mode)`
 <!-- YAML
-added: v12.20.0
+deprecated: v10.0.0
 -->
 
-* Returns: {fs.FSWatcher}
+* `path` {string|Buffer|URL}
+* `mode` {integer}
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-When called, the active `FSWatcher` object will not require the Node.js
-event loop to remain active. If there is no other activity keeping the
-event loop running, the process may exit before the `FSWatcher` object's
-callback is invoked. Calling `watcher.unref()` multiple times will have
-no effect.
+Changes the permissions on a symbolic link.
+
+This method is only implemented on macOS.
 
-## Class: `fs.StatWatcher`
+### `fsPromises.lchown(path, uid, gid)`
 <!-- YAML
-added: v12.20.0
+added: v10.0.0
+changes:
+  - version: v10.6.0
+    pr-url: https://github.com/nodejs/node/pull/21498
+    description: This API is no longer deprecated.
 -->
 
-* Extends {EventEmitter}
+* `path` {string|Buffer|URL}
+* `uid` {integer}
+* `gid` {integer}
+* Returns: {Promise}  Fulfills with `undefined` upon success.
 
-A successful call to `fs.watchFile()` method will return a new `fs.StatWatcher`
-object.
+Changes the ownership on a symbolic link.
 
-### `watcher.ref()`
+### `fsPromises.lutimes(path, atime, mtime)`
 <!-- YAML
-added: v12.20.0
+added:
+  - v14.5.0
+  - v12.19.0
 -->
 
-* Returns: {fs.StatWatcher}
-
-When called, requests that the Node.js event loop *not* exit so long as the
-`StatWatcher` is active. Calling `watcher.ref()` multiple times will have
-no effect.
+* `path` {string|Buffer|URL}
+* `atime` {number|string|Date}
+* `mtime` {number|string|Date}
+* Returns: {Promise}  Fulfills with `undefined` upon success.
 
-By default, all `StatWatcher` objects are "ref'ed", making it normally
-unnecessary to call `watcher.ref()` unless `watcher.unref()` had been
-called previously.
+Changes the access and modification times of a file in the same way as
+[`fsPromises.utimes()`][], with the difference that if the path refers to a
+symbolic link, then the link is not dereferenced: instead, the timestamps of
+the symbolic link itself are changed.
 
-### `watcher.unref()`
+### `fsPromises.link(existingPath, newPath)`
 <!-- YAML
-added: v12.20.0
+added: v10.0.0
 -->
 
-* Returns: {fs.StatWatcher}
+* `existingPath` {string|Buffer|URL}
+* `newPath` {string|Buffer|URL}
+* Returns: {Promise}  Fulfills with `undefined` upon success.
 
-When called, the active `StatWatcher` object will not require the Node.js
-event loop to remain active. If there is no other activity keeping the
-event loop running, the process may exit before the `StatWatcher` object's
-callback is invoked. Calling `watcher.unref()` multiple times will have
-no effect.
+Creates a new link from the `existingPath` to the `newPath`. See the POSIX
+link(2) documentation for more detail.
 
-## Class: `fs.ReadStream`
+### `fsPromises.lstat(path[, options])`
 <!-- YAML
-added: v0.1.93
+added: v10.0.0
+changes:
+  - version: v10.5.0
+    pr-url: https://github.com/nodejs/node/pull/20220
+    description: Accepts an additional `options` object to specify whether
+                 the numeric values returned should be bigint.
 -->
 
-* Extends: {stream.Readable}
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `bigint` {boolean} Whether the numeric values in the returned
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
+* Returns: {Promise}  Fulfills with the {fs.Stats} object for the given
+  symbolic link `path`.
 
-Instances of `fs.ReadStream` are created and returned using the
-[`fs.createReadStream()`][] function.
+Equivalent to [`fsPromises.stat()`][] unless `path` refers to a symbolic link,
+in which case the link itself is stat-ed, not the file that it refers to.
+Refer to the POSIX lstat(2) document for more detail.
 
-### Event: `'close'`
+### `fsPromises.mkdir(path[, options])`
 <!-- YAML
-added: v0.1.93
+added: v10.0.0
 -->
 
-Emitted when the `fs.ReadStream`'s underlying file descriptor has been closed.
-
-### Event: `'open'`
-<!-- YAML
-added: v0.1.93
--->
+* `path` {string|Buffer|URL}
+* `options` {Object|integer}
+  * `recursive` {boolean} **Default:** `false`
+  * `mode` {string|integer} Not supported on Windows. **Default:** `0o777`.
+* Returns: {Promise} Upon success, fulfills with `undefined` if `recursive`
+  is `false`, or the first directory path created if `recursive` is `true`.
 
-* `fd` {integer} Integer file descriptor used by the `ReadStream`.
+Asynchronously creates a directory.
 
-Emitted when the `fs.ReadStream`'s file descriptor has been opened.
+The optional `options` argument can be an integer specifying `mode` (permission
+and sticky bits), or an object with a `mode` property and a `recursive`
+property indicating whether parent directories should be created. Calling
+`fsPromises.mkdir()` when `path` is a directory that exists results in a
+rejection only when `recursive` is false.
 
-### Event: `'ready'`
+### `fsPromises.mkdtemp(prefix[, options])`
 <!-- YAML
-added: v9.11.0
+added: v10.0.0
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/39028
+    description: The `prefix` parameter now accepts an empty string.
 -->
 
-Emitted when the `fs.ReadStream` is ready to be used.
+* `prefix` {string}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+* Returns: {Promise}  Fulfills with a string containing the filesystem path
+  of the newly created temporary directory.
 
-Fires immediately after `'open'`.
+Creates a unique temporary directory. A unique directory name is generated by
+appending six random characters to the end of the provided `prefix`. Due to
+platform inconsistencies, avoid trailing `X` characters in `prefix`. Some
+platforms, notably the BSDs, can return more than six random characters, and
+replace trailing `X` characters in `prefix` with random characters.
 
-### `readStream.bytesRead`
-<!-- YAML
-added: v6.4.0
--->
+The optional `options` argument can be a string specifying an encoding, or an
+object with an `encoding` property specifying the character encoding to use.
 
-* {number}
+```mjs
+import { mkdtemp } from 'fs/promises';
 
-The number of bytes that have been read so far.
+try {
+  await mkdtemp(path.join(os.tmpdir(), 'foo-'));
+} catch (err) {
+  console.error(err);
+}
+```
+
+The `fsPromises.mkdtemp()` method will append the six randomly selected
+characters directly to the `prefix` string. For instance, given a directory
+`/tmp`, if the intention is to create a temporary directory *within* `/tmp`, the
+`prefix` must end with a trailing platform-specific path separator
+(`require('path').sep`).
 
-### `readStream.path`
+### `fsPromises.open(path, flags[, mode])`
 <!-- YAML
-added: v0.1.93
+added: v10.0.0
+changes:
+  - version: v11.1.0
+    pr-url: https://github.com/nodejs/node/pull/23767
+    description: The `flags` argument is now optional and defaults to `'r'`.
 -->
 
-* {string|Buffer}
-
-The path to the file the stream is reading from as specified in the first
-argument to `fs.createReadStream()`. If `path` is passed as a string, then
-`readStream.path` will be a string. If `path` is passed as a `Buffer`, then
-`readStream.path` will be a `Buffer`.
+* `path` {string|Buffer|URL}
+* `flags` {string|number} See [support of file system `flags`][].
+  **Default:** `'r'`.
+* `mode` {string|integer} Sets the file mode (permission and sticky bits)
+  if the file is created. **Default:** `0o666` (readable and writable)
+* Returns: {Promise} Fulfills with a {FileHandle} object.
 
-### `readStream.pending`
-<!-- YAML
-added: v11.2.0
--->
+Opens a {FileHandle}.
 
-* {boolean}
+Refer to the POSIX open(2) documentation for more detail.
 
-This property is `true` if the underlying file has not been opened yet,
-i.e. before the `'ready'` event is emitted.
+Some characters (`< > : " / \ | ? *`) are reserved under Windows as documented
+by [Naming Files, Paths, and Namespaces][]. Under NTFS, if the filename contains
+a colon, Node.js will open a file system stream, as described by
+[this MSDN page][MSDN-Using-Streams].
 
-## Class: `fs.Stats`
+### `fsPromises.opendir(path[, options])`
 <!-- YAML
-added: v0.1.21
+added: v12.12.0
 changes:
-  - version: v8.1.0
-    pr-url: https://github.com/nodejs/node/pull/13173
-    description: Added times as numbers.
+  - version:
+     - v13.1.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/30114
+    description: The `bufferSize` option was introduced.
 -->
 
-A `fs.Stats` object provides information about a file.
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `encoding` {string|null} **Default:** `'utf8'`
+  * `bufferSize` {number} Number of directory entries that are buffered
+    internally when reading from the directory. Higher values lead to better
+    performance but higher memory usage. **Default:** `32`
+* Returns: {Promise}  Fulfills with an {fs.Dir}.
 
-Objects returned from [`fs.stat()`][], [`fs.lstat()`][] and [`fs.fstat()`][] and
-their synchronous counterparts are of this type.
-If `bigint` in the `options` passed to those methods is true, the numeric values
-will be `bigint` instead of `number`, and the object will contain additional
-nanosecond-precision properties suffixed with `Ns`.
+Asynchronously open a directory for iterative scanning. See the POSIX
+opendir(3) documentation for more detail.
 
-```console
-Stats {
-  dev: 2114,
-  ino: 48064969,
-  mode: 33188,
-  nlink: 1,
-  uid: 85,
-  gid: 100,
-  rdev: 0,
-  size: 527,
-  blksize: 4096,
-  blocks: 8,
-  atimeMs: 1318289051000.1,
-  mtimeMs: 1318289051000.1,
-  ctimeMs: 1318289051000.1,
-  birthtimeMs: 1318289051000.1,
-  atime: Mon, 10 Oct 2011 23:24:11 GMT,
-  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
-  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
-  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
-```
+Creates an {fs.Dir}, which contains all further functions for reading from
+and cleaning up the directory.
 
-`bigint` version:
+The `encoding` option sets the encoding for the `path` while opening the
+directory and subsequent read operations.
 
-```console
-BigIntStats {
-  dev: 2114n,
-  ino: 48064969n,
-  mode: 33188n,
-  nlink: 1n,
-  uid: 85n,
-  gid: 100n,
-  rdev: 0n,
-  size: 527n,
-  blksize: 4096n,
-  blocks: 8n,
-  atimeMs: 1318289051000n,
-  mtimeMs: 1318289051000n,
-  ctimeMs: 1318289051000n,
-  birthtimeMs: 1318289051000n,
-  atimeNs: 1318289051000000000n,
-  mtimeNs: 1318289051000000000n,
-  ctimeNs: 1318289051000000000n,
-  birthtimeNs: 1318289051000000000n,
-  atime: Mon, 10 Oct 2011 23:24:11 GMT,
-  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
-  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
-  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
+Example using async iteration:
+
+```mjs
+import { opendir } from 'fs/promises';
+
+try {
+  const dir = await opendir('./');
+  for await (const dirent of dir)
+    console.log(dirent.name);
+} catch (err) {
+  console.error(err);
+}
 ```
 
-### `stats.isBlockDevice()`
+When using the async iterator, the {fs.Dir} object will be automatically
+closed after the iterator exits.
+
+### `fsPromises.readdir(path[, options])`
 <!-- YAML
-added: v0.1.10
+added: v10.0.0
+changes:
+  - version: v10.11.0
+    pr-url: https://github.com/nodejs/node/pull/22020
+    description: New option `withFileTypes` was added.
 -->
 
-* Returns: {boolean}
+* `path` {string|Buffer|URL}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+  * `withFileTypes` {boolean} **Default:** `false`
+* Returns: {Promise}  Fulfills with an array of the names of the files in
+  the directory excluding `'.'` and `'..'`.
 
-Returns `true` if the `fs.Stats` object describes a block device.
+Reads the contents of a directory.
 
-### `stats.isCharacterDevice()`
-<!-- YAML
-added: v0.1.10
--->
+The optional `options` argument can be a string specifying an encoding, or an
+object with an `encoding` property specifying the character encoding to use for
+the filenames. If the `encoding` is set to `'buffer'`, the filenames returned
+will be passed as {Buffer} objects.
 
-* Returns: {boolean}
+If `options.withFileTypes` is set to `true`, the resolved array will contain
+{fs.Dirent} objects.
+
+```mjs
+import { readdir } from 'fs/promises';
 
-Returns `true` if the `fs.Stats` object describes a character device.
+try {
+  const files = await readdir(path);
+  for (const file of files)
+    console.log(file);
+} catch (err) {
+  console.error(err);
+}
+```
 
-### `stats.isDirectory()`
+### `fsPromises.readFile(path[, options])`
 <!-- YAML
-added: v0.1.10
+added: v10.0.0
+changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/35911
+    description: The options argument may include an AbortSignal to abort an
+                 ongoing readFile request.
 -->
 
-* Returns: {boolean}
+* `path` {string|Buffer|URL|FileHandle} filename or `FileHandle`
+* `options` {Object|string}
+  * `encoding` {string|null} **Default:** `null`
+  * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
+  * `signal` {AbortSignal} allows aborting an in-progress readFile
+* Returns: {Promise}  Fulfills with the contents of the file.
 
-Returns `true` if the `fs.Stats` object describes a file system directory.
+Asynchronously reads the entire contents of a file.
 
-### `stats.isFIFO()`
-<!-- YAML
-added: v0.1.10
--->
+If no encoding is specified (using `options.encoding`), the data is returned
+as a {Buffer} object. Otherwise, the data will be a string.
 
-* Returns: {boolean}
+If `options` is a string, then it specifies the encoding.
 
-Returns `true` if the `fs.Stats` object describes a first-in-first-out (FIFO)
-pipe.
+When the `path` is a directory, the behavior of `fsPromises.readFile()` is
+platform-specific. On macOS, Linux, and Windows, the promise will be rejected
+with an error. On FreeBSD, a representation of the directory's contents will be
+returned.
 
-### `stats.isFile()`
-<!-- YAML
-added: v0.1.10
--->
+It is possible to abort an ongoing `readFile` using an {AbortSignal}. If a
+request is aborted the promise returned is rejected with an `AbortError`:
 
-* Returns: {boolean}
+```mjs
+import { readFile } from 'fs/promises';
 
-Returns `true` if the `fs.Stats` object describes a regular file.
+try {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const promise = readFile(fileName, { signal });
 
-### `stats.isSocket()`
-<!-- YAML
-added: v0.1.10
--->
+  // Abort the request before the promise settles.
+  controller.abort();
 
-* Returns: {boolean}
+  await promise;
+} catch (err) {
+  // When a request is aborted - err is an AbortError
+  console.error(err);
+}
+```
+
+Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering `fs.readFile` performs.
 
-Returns `true` if the `fs.Stats` object describes a socket.
+Any specified {FileHandle} has to support reading.
 
-### `stats.isSymbolicLink()`
+### `fsPromises.readlink(path[, options])`
 <!-- YAML
-added: v0.1.10
+added: v10.0.0
 -->
+* `path` {string|Buffer|URL}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+* Returns: {Promise} Fulfills with the `linkString` upon success.
 
-* Returns: {boolean}
+Reads the contents of the symbolic link referred to by `path`. See the POSIX
+readlink(2) documentation for more detail. The promise is resolved with the
+`linkString` upon success.
 
-Returns `true` if the `fs.Stats` object describes a symbolic link.
+The optional `options` argument can be a string specifying an encoding, or an
+object with an `encoding` property specifying the character encoding to use for
+the link path returned. If the `encoding` is set to `'buffer'`, the link path
+returned will be passed as a {Buffer} object.
 
-This method is only valid when using [`fs.lstat()`][].
+### `fsPromises.realpath(path[, options])`
+<!-- YAML
+added: v10.0.0
+-->
 
-### `stats.dev`
+* `path` {string|Buffer|URL}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+* Returns: {Promise}  Fulfills with the resolved path upon success.
 
-* {number|bigint}
+Determines the actual location of `path` using the same semantics as the
+`fs.realpath.native()` function.
 
-The numeric identifier of the device containing the file.
+Only paths that can be converted to UTF8 strings are supported.
 
-### `stats.ino`
-
-* {number|bigint}
-
-The file system specific "Inode" number for the file.
-
-### `stats.mode`
-
-* {number|bigint}
-
-A bit-field describing the file type and mode.
-
-### `stats.nlink`
-
-* {number|bigint}
-
-The number of hard-links that exist for the file.
-
-### `stats.uid`
-
-* {number|bigint}
-
-The numeric user identifier of the user that owns the file (POSIX).
-
-### `stats.gid`
-
-* {number|bigint}
-
-The numeric group identifier of the group that owns the file (POSIX).
-
-### `stats.rdev`
-
-* {number|bigint}
-
-A numeric device identifier if the file represents a device.
+The optional `options` argument can be a string specifying an encoding, or an
+object with an `encoding` property specifying the character encoding to use for
+the path. If the `encoding` is set to `'buffer'`, the path returned will be
+passed as a {Buffer} object.
 
-### `stats.size`
+On Linux, when Node.js is linked against musl libc, the procfs file system must
+be mounted on `/proc` in order for this function to work. Glibc does not have
+this restriction.
 
-* {number|bigint}
+### `fsPromises.rename(oldPath, newPath)`
+<!-- YAML
+added: v10.0.0
+-->
 
-The size of the file in bytes.
+* `oldPath` {string|Buffer|URL}
+* `newPath` {string|Buffer|URL}
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-### `stats.blksize`
+Renames `oldPath` to `newPath`.
 
-* {number|bigint}
+### `fsPromises.rmdir(path[, options])`
+<!-- YAML
+added: v10.0.0
+changes:
+  - version: v14.14.0
+    pr-url: https://github.com/nodejs/node/pull/35579
+    description: The `recursive` option is deprecated, use `fsPromises.rm` instead.
+  - version:
+     - v13.3.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/30644
+    description: The `maxBusyTries` option is renamed to `maxRetries`, and its
+                 default is 0. The `emfileWait` option has been removed, and
+                 `EMFILE` errors use the same retry logic as other errors. The
+                 `retryDelay` option is now supported. `ENFILE` errors are now
+                 retried.
+  - version: v12.10.0
+    pr-url: https://github.com/nodejs/node/pull/29168
+    description: The `recursive`, `maxBusyTries`, and `emfileWait` options are
+                  now supported.
+-->
 
-The file system block size for i/o operations.
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+    `EPERM` error is encountered, Node.js retries the operation with a linear
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
+  * `recursive` {boolean} If `true`, perform a recursive directory removal. In
+    recursive mode, errors are not reported if `path` does not exist, and
+    operations are retried on failure. **Default:** `false`.
+  * `retryDelay` {integer} The amount of time in milliseconds to wait between
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-### `stats.blocks`
+Removes the directory identified by `path`.
 
-* {number|bigint}
+Using `fsPromises.rmdir()` on a file (not a directory) results in the
+promise being rejected with an `ENOENT` error on Windows and an `ENOTDIR`
+error on POSIX.
 
-The number of blocks allocated for this file.
+Setting `recursive` to `true` results in behavior similar to the Unix command
+`rm -rf`: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+`recursive` option is deprecated, `ENOTDIR` and `ENOENT` will be thrown in
+the future.
 
-### `stats.atimeMs`
+### `fsPromises.rm(path[, options])`
 <!-- YAML
-added: v8.1.0
+added: v14.14.0
 -->
 
-* {number|bigint}
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `force` {boolean} When `true`, exceptions will be ignored if `path` does
+    not exist. **Default:** `false`.
+  * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+    `EPERM` error is encountered, Node.js will retry the operation with a linear
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
+  * `recursive` {boolean} If `true`, perform a recursive directory removal. In
+    recursive mode operations are retried on failure. **Default:** `false`.
+  * `retryDelay` {integer} The amount of time in milliseconds to wait between
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-The timestamp indicating the last time this file was accessed expressed in
-milliseconds since the POSIX Epoch.
+Removes files and directories (modeled on the standard POSIX `rm` utility).
 
-### `stats.mtimeMs`
+### `fsPromises.stat(path[, options])`
 <!-- YAML
-added: v8.1.0
+added: v10.0.0
+changes:
+  - version: v10.5.0
+    pr-url: https://github.com/nodejs/node/pull/20220
+    description: Accepts an additional `options` object to specify whether
+                 the numeric values returned should be bigint.
 -->
 
-* {number|bigint}
-
-The timestamp indicating the last time this file was modified expressed in
-milliseconds since the POSIX Epoch.
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `bigint` {boolean} Whether the numeric values in the returned
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
+* Returns: {Promise}  Fulfills with the {fs.Stats} object for the
+  given `path`.
 
-### `stats.ctimeMs`
+### `fsPromises.symlink(target, path[, type])`
 <!-- YAML
-added: v8.1.0
+added: v10.0.0
 -->
 
-* {number|bigint}
-
-The timestamp indicating the last time the file status was changed expressed
-in milliseconds since the POSIX Epoch.
-
-### `stats.birthtimeMs`
-<!-- YAML
-added: v8.1.0
--->
+* `target` {string|Buffer|URL}
+* `path` {string|Buffer|URL}
+* `type` {string} **Default:** `'file'`
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-* {number|bigint}
+Creates a symbolic link.
 
-The timestamp indicating the creation time of this file expressed in
-milliseconds since the POSIX Epoch.
+The `type` argument is only used on Windows platforms and can be one of `'dir'`,
+`'file'`, or `'junction'`. Windows junction points require the destination path
+to be absolute. When using `'junction'`, the `target` argument will
+automatically be normalized to absolute path.
 
-### `stats.atimeNs`
+### `fsPromises.truncate(path[, len])`
 <!-- YAML
-added: v12.10.0
+added: v10.0.0
 -->
 
-* {bigint}
+* `path` {string|Buffer|URL}
+* `len` {integer} **Default:** `0`
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-Only present when `bigint: true` is passed into the method that generates
-the object.
-The timestamp indicating the last time this file was accessed expressed in
-nanoseconds since the POSIX Epoch.
+Truncates (shortens or extends the length) of the content at `path` to `len`
+bytes.
 
-### `stats.mtimeNs`
+### `fsPromises.unlink(path)`
 <!-- YAML
-added: v12.10.0
+added: v10.0.0
 -->
 
-* {bigint}
+* `path` {string|Buffer|URL}
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-Only present when `bigint: true` is passed into the method that generates
-the object.
-The timestamp indicating the last time this file was modified expressed in
-nanoseconds since the POSIX Epoch.
+If `path` refers to a symbolic link, then the link is removed without affecting
+the file or directory to which that link refers. If the `path` refers to a file
+path that is not a symbolic link, the file is deleted. See the POSIX unlink(2)
+documentation for more detail.
 
-### `stats.ctimeNs`
+### `fsPromises.utimes(path, atime, mtime)`
 <!-- YAML
-added: v12.10.0
+added: v10.0.0
 -->
 
-* {bigint}
-
-Only present when `bigint: true` is passed into the method that generates
-the object.
-The timestamp indicating the last time the file status was changed expressed
-in nanoseconds since the POSIX Epoch.
+* `path` {string|Buffer|URL}
+* `atime` {number|string|Date}
+* `mtime` {number|string|Date}
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-### `stats.birthtimeNs`
-<!-- YAML
-added: v12.10.0
--->
+Change the file system timestamps of the object referenced by `path`.
 
-* {bigint}
+The `atime` and `mtime` arguments follow these rules:
 
-Only present when `bigint: true` is passed into the method that generates
-the object.
-The timestamp indicating the creation time of this file expressed in
-nanoseconds since the POSIX Epoch.
+* Values can be either numbers representing Unix epoch time, `Date`s, or a
+  numeric string like `'123456789.0'`.
+* If the value can not be converted to a number, or is `NaN`, `Infinity` or
+  `-Infinity`, an `Error` will be thrown.
 
-### `stats.atime`
+### `fsPromises.watch(filename[, options])`
 <!-- YAML
-added: v0.11.13
+added: v14.18.0
 -->
 
-* {Date}
-
-The timestamp indicating the last time this file was accessed.
+* `filename` {string|Buffer|URL}
+* `options` {string|Object}
+  * `persistent` {boolean} Indicates whether the process should continue to run
+    as long as files are being watched. **Default:** `true`.
+  * `recursive` {boolean} Indicates whether all subdirectories should be
+    watched, or only the current directory. This applies when a directory is
+    specified, and only on supported platforms (See [caveats][]). **Default:**
+    `false`.
+  * `encoding` {string} Specifies the character encoding to be used for the
+     filename passed to the listener. **Default:** `'utf8'`.
+  * `signal` {AbortSignal} An {AbortSignal} used to signal when the watcher
+    should stop.
+* Returns: {AsyncIterator} of objects with the properties:
+  * `eventType` {string} The type of change
+  * `filename` {string|Buffer} The name of the file changed.
 
-### `stats.mtime`
-<!-- YAML
-added: v0.11.13
--->
+Returns an async iterator that watches for changes on `filename`, where `filename`
+is either a file or a directory.
 
-* {Date}
+```js
+const { watch } = require('fs/promises');
 
-The timestamp indicating the last time this file was modified.
+const ac = new AbortController();
+const { signal } = ac;
+setTimeout(() => ac.abort(), 10000);
 
-### `stats.ctime`
-<!-- YAML
-added: v0.11.13
--->
+(async () => {
+  try {
+    const watcher = watch(__filename, { signal });
+    for await (const event of watcher)
+      console.log(event);
+  } catch (err) {
+    if (err.name === 'AbortError')
+      return;
+    throw err;
+  }
+})();
+```
 
-* {Date}
+On most platforms, `'rename'` is emitted whenever a filename appears or
+disappears in the directory.
 
-The timestamp indicating the last time the file status was changed.
+All the [caveats][] for `fs.watch()` also apply to `fsPromises.watch()`.
 
-### `stats.birthtime`
+### `fsPromises.writeFile(file, data[, options])`
 <!-- YAML
-added: v0.11.13
+added: v10.0.0
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37490
+    description: The `data` argument supports `AsyncIterable`, `Iterable` and `Stream`.
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/35993
+    description: The options argument may include an AbortSignal to abort an
+                 ongoing writeFile request.
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `data` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `data` parameter won't coerce unsupported input to
+                 strings anymore.
 -->
 
-* {Date}
+* `file` {string|Buffer|URL|FileHandle} filename or `FileHandle`
+* `data` {string|Buffer|TypedArray|DataView|Object|AsyncIterable|Iterable
+  |Stream}
+* `options` {Object|string}
+  * `encoding` {string|null} **Default:** `'utf8'`
+  * `mode` {integer} **Default:** `0o666`
+  * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
+  * `signal` {AbortSignal} allows aborting an in-progress writeFile
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
-The timestamp indicating the creation time of this file.
+Asynchronously writes data to a file, replacing the file if it already exists.
+`data` can be a string, a {Buffer}, or, an object with an own (not inherited)
+`toString` function property.
 
-### Stat time values
+The `encoding` option is ignored if `data` is a buffer.
 
-The `atimeMs`, `mtimeMs`, `ctimeMs`, `birthtimeMs` properties are
-numeric values that hold the corresponding times in milliseconds. Their
-precision is platform specific. When `bigint: true` is passed into the
-method that generates the object, the properties will be [bigints][],
-otherwise they will be [numbers][MDN-Number].
+If `options` is a string, then it specifies the encoding.
 
-The `atimeNs`, `mtimeNs`, `ctimeNs`, `birthtimeNs` properties are
-[bigints][] that hold the corresponding times in nanoseconds. They are
-only present when `bigint: true` is passed into the method that generates
-the object. Their precision is platform specific.
+The `mode` option only affects the newly created file. See [`fs.open()`][]
+for more details.
 
-`atime`, `mtime`, `ctime`, and `birthtime` are
-[`Date`][MDN-Date] object alternate representations of the various times. The
-`Date` and number values are not connected. Assigning a new number value, or
-mutating the `Date` value, will not be reflected in the corresponding alternate
-representation.
+Any specified {FileHandle} has to support writing.
 
-The times in the stat object have the following semantics:
+It is unsafe to use `fsPromises.writeFile()` multiple times on the same file
+without waiting for the promise to be settled.
 
-* `atime` "Access Time": Time when file data last accessed. Changed
-  by the mknod(2), utimes(2), and read(2) system calls.
-* `mtime` "Modified Time": Time when file data last modified.
-  Changed by the mknod(2), utimes(2), and write(2) system calls.
-* `ctime` "Change Time": Time when file status was last changed
-  (inode data modification). Changed by the chmod(2), chown(2),
-  link(2), mknod(2), rename(2), unlink(2), utimes(2),
-  read(2), and write(2) system calls.
-* `birthtime` "Birth Time": Time of file creation. Set once when the
-  file is created. On filesystems where birthtime is not available,
-  this field may instead hold either the `ctime` or
-  `1970-01-01T00:00Z` (ie, Unix epoch timestamp `0`). This value may be greater
-  than `atime` or `mtime` in this case. On Darwin and other FreeBSD variants,
-  also set if the `atime` is explicitly set to an earlier value than the current
-  `birthtime` using the utimes(2) system call.
+Similarly to `fsPromises.readFile` - `fsPromises.writeFile` is a convenience
+method that performs multiple `write` calls internally to write the buffer
+passed to it. For performance sensitive code consider using
+[`fs.createWriteStream()`][].
 
-Prior to Node.js 0.12, the `ctime` held the `birthtime` on Windows systems. As
-of 0.12, `ctime` is not "creation time", and on Unix systems, it never was.
+It is possible to use an {AbortSignal} to cancel an `fsPromises.writeFile()`.
+Cancelation is "best effort", and some amount of data is likely still
+to be written.
 
-## Class: `fs.WriteStream`
-<!-- YAML
-added: v0.1.93
--->
+```mjs
+import { writeFile } from 'fs/promises';
 
-* Extends {stream.Writable}
+try {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const data = new Uint8Array(Buffer.from('Hello Node.js'));
+  const promise = writeFile('message.txt', data, { signal });
 
-Instances of `fs.WriteStream` are created and returned using the
-[`fs.createWriteStream()`][] function.
+  // Abort the request before the promise settles.
+  controller.abort();
 
-### Event: `'close'`
-<!-- YAML
-added: v0.1.93
--->
+  await promise;
+} catch (err) {
+  // When a request is aborted - err is an AbortError
+  console.error(err);
+}
+```
 
-Emitted when the `WriteStream`'s underlying file descriptor has been closed.
+Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering `fs.writeFile` performs.
 
-### Event: `'open'`
-<!-- YAML
-added: v0.1.93
--->
+## Callback API
 
-* `fd` {integer} Integer file descriptor used by the `WriteStream`.
+The callback APIs perform all operations asynchronously, without blocking the
+event loop, then invoke a callback function upon completion or error.
 
-Emitted when the `WriteStream`'s file is opened.
+The callback APIs use the underlying Node.js threadpool to perform file
+system operations off the event loop thread. These operations are not
+synchronized or threadsafe. Care must be taken when performing multiple
+concurrent modifications on the same file or data corruption may occur.
 
-### Event: `'ready'`
-<!-- YAML
-added: v9.11.0
--->
-
-Emitted when the `fs.WriteStream` is ready to be used.
-
-Fires immediately after `'open'`.
-
-### `writeStream.bytesWritten`
-<!-- YAML
-added: v0.4.7
--->
-
-The number of bytes written so far. Does not include data that is still queued
-for writing.
-
-### `writeStream.path`
-<!-- YAML
-added: v0.1.93
--->
-
-The path to the file the stream is writing to as specified in the first
-argument to [`fs.createWriteStream()`][]. If `path` is passed as a string, then
-`writeStream.path` will be a string. If `path` is passed as a `Buffer`, then
-`writeStream.path` will be a `Buffer`.
-
-### `writeStream.pending`
-<!-- YAML
-added: v11.2.0
--->
-
-* {boolean}
-
-This property is `true` if the underlying file has not been opened yet,
-i.e. before the `'ready'` event is emitted.
-
-## `fs.access(path[, mode], callback)`
+### `fs.access(path[, mode], callback)`
 <!-- YAML
 added: v0.11.15
 changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v6.3.0
     pr-url: https://github.com/nodejs/node/pull/6534
     description: The constants like `fs.R_OK`, etc which were present directly
@@ -1184,26 +1372,28 @@ a possible error argument. If any of the accessibility checks fail, the error
 argument will be an `Error` object. The following examples check if
 `package.json` exists, and if it is readable or writable.
 
-```js
+```mjs
+import { access, constants } from 'fs';
+
 const file = 'package.json';
 
 // Check if the file exists in the current directory.
-fs.access(file, fs.constants.F_OK, (err) => {
+access(file, constants.F_OK, (err) => {
   console.log(`${file} ${err ? 'does not exist' : 'exists'}`);
 });
 
 // Check if the file is readable.
-fs.access(file, fs.constants.R_OK, (err) => {
+access(file, constants.R_OK, (err) => {
   console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);
 });
 
 // Check if the file is writable.
-fs.access(file, fs.constants.W_OK, (err) => {
+access(file, constants.W_OK, (err) => {
   console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);
 });
 
 // Check if the file exists in the current directory, and if it is writable.
-fs.access(file, fs.constants.F_OK | fs.constants.W_OK, (err) => {
+access(file, constants.F_OK | constants.W_OK, (err) => {
   if (err) {
     console.error(
       `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`);
@@ -1221,24 +1411,35 @@ file directly and handle the error raised if the file is not accessible.
 
 **write (NOT RECOMMENDED)**
 
-```js
-fs.access('myfile', (err) => {
+```mjs
+import { access, open, close } from 'fs';
+
+access('myfile', (err) => {
   if (!err) {
     console.error('myfile already exists');
     return;
   }
 
-  fs.open('myfile', 'wx', (err, fd) => {
+  open('myfile', 'wx', (err, fd) => {
     if (err) throw err;
-    writeMyData(fd);
+
+    try {
+      writeMyData(fd);
+    } finally {
+      close(fd, (err) => {
+        if (err) throw err;
+      });
+    }
   });
 });
 ```
 
 **write (RECOMMENDED)**
 
-```js
-fs.open('myfile', 'wx', (err, fd) => {
+```mjs
+import { open, close } from 'fs';
+
+open('myfile', 'wx', (err, fd) => {
   if (err) {
     if (err.code === 'EEXIST') {
       console.error('myfile already exists');
@@ -1248,14 +1449,21 @@ fs.open('myfile', 'wx', (err, fd) => {
     throw err;
   }
 
-  writeMyData(fd);
+  try {
+    writeMyData(fd);
+  } finally {
+    close(fd, (err) => {
+      if (err) throw err;
+    });
+  }
 });
 ```
 
 **read (NOT RECOMMENDED)**
 
-```js
-fs.access('myfile', (err) => {
+```mjs
+import { access, open, close } from 'fs';
+access('myfile', (err) => {
   if (err) {
     if (err.code === 'ENOENT') {
       console.error('myfile does not exist');
@@ -1265,17 +1473,26 @@ fs.access('myfile', (err) => {
     throw err;
   }
 
-  fs.open('myfile', 'r', (err, fd) => {
+  open('myfile', 'r', (err, fd) => {
     if (err) throw err;
-    readMyData(fd);
+
+    try {
+      readMyData(fd);
+    } finally {
+      close(fd, (err) => {
+        if (err) throw err;
+      });
+    }
   });
 });
 ```
 
 **read (RECOMMENDED)**
 
-```js
-fs.open('myfile', 'r', (err, fd) => {
+```mjs
+import { open, close } from 'fs';
+
+open('myfile', 'r', (err, fd) => {
   if (err) {
     if (err.code === 'ENOENT') {
       console.error('myfile does not exist');
@@ -1285,7 +1502,13 @@ fs.open('myfile', 'r', (err, fd) => {
     throw err;
   }
 
-  readMyData(fd);
+  try {
+    readMyData(fd);
+  } finally {
+    close(fd, (err) => {
+      if (err) throw err;
+    });
+  }
 });
 ```
 
@@ -1302,39 +1525,7 @@ a file or directory. The `fs.access()` function, however, does not check the
 ACL and therefore may report that a path is accessible even if the ACL restricts
 the user from reading or writing to it.
 
-## `fs.accessSync(path[, mode])`
-<!-- YAML
-added: v0.11.15
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-* `mode` {integer} **Default:** `fs.constants.F_OK`
-
-Synchronously tests a user's permissions for the file or directory specified
-by `path`. The `mode` argument is an optional integer that specifies the
-accessibility checks to be performed. Check [File access constants][] for
-possible values of `mode`. It is possible to create a mask consisting of
-the bitwise OR of two or more values
-(e.g. `fs.constants.W_OK | fs.constants.R_OK`).
-
-If any of the accessibility checks fail, an `Error` will be thrown. Otherwise,
-the method will return `undefined`.
-
-```js
-try {
-  fs.accessSync('etc/passwd', fs.constants.R_OK | fs.constants.W_OK);
-  console.log('can read/write');
-} catch (err) {
-  console.error('no access!');
-}
-```
-
-## `fs.appendFile(path, data[, options], callback)`
+### `fs.appendFile(path, data[, options], callback)`
 <!-- YAML
 added: v0.6.7
 changes:
@@ -1364,10 +1555,15 @@ changes:
   * `err` {Error}
 
 Asynchronously append data to a file, creating the file if it does not yet
-exist. `data` can be a string or a [`Buffer`][].
+exist. `data` can be a string or a {Buffer}.
 
-```js
-fs.appendFile('message.txt', 'data to append', (err) => {
+The `mode` option only affects the newly created file. See [`fs.open()`][]
+for more details.
+
+```mjs
+import { appendFile } from 'fs';
+
+appendFile('message.txt', 'data to append', (err) => {
   if (err) throw err;
   console.log('The "data to append" was appended to file!');
 });
@@ -1375,82 +1571,41 @@ fs.appendFile('message.txt', 'data to append', (err) => {
 
 If `options` is a string, then it specifies the encoding:
 
-```js
-fs.appendFile('message.txt', 'data to append', 'utf8', callback);
+```mjs
+import { appendFile } from 'fs';
+
+appendFile('message.txt', 'data to append', 'utf8', callback);
 ```
 
 The `path` may be specified as a numeric file descriptor that has been opened
 for appending (using `fs.open()` or `fs.openSync()`). The file descriptor will
 not be closed automatically.
 
-```js
-fs.open('message.txt', 'a', (err, fd) => {
-  if (err) throw err;
-  fs.appendFile(fd, 'data to append', 'utf8', (err) => {
-    fs.close(fd, (err) => {
-      if (err) throw err;
-    });
+```mjs
+import { open, close, appendFile } from 'fs';
+
+function closeFd(fd) {
+  close(fd, (err) => {
     if (err) throw err;
   });
-});
-```
-
-## `fs.appendFileSync(path, data[, options])`
-<!-- YAML
-added: v0.6.7
-changes:
-  - version: v7.0.0
-    pr-url: https://github.com/nodejs/node/pull/7831
-    description: The passed `options` object will never be modified.
-  - version: v5.0.0
-    pr-url: https://github.com/nodejs/node/pull/3163
-    description: The `file` parameter can be a file descriptor now.
--->
-
-* `path` {string|Buffer|URL|number} filename or file descriptor
-* `data` {string|Buffer}
-* `options` {Object|string}
-  * `encoding` {string|null} **Default:** `'utf8'`
-  * `mode` {integer} **Default:** `0o666`
-  * `flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.
-
-Synchronously append data to a file, creating the file if it does not yet
-exist. `data` can be a string or a [`Buffer`][].
-
-```js
-try {
-  fs.appendFileSync('message.txt', 'data to append');
-  console.log('The "data to append" was appended to file!');
-} catch (err) {
-  /* Handle the error */
 }
-```
-
-If `options` is a string, then it specifies the encoding:
-
-```js
-fs.appendFileSync('message.txt', 'data to append', 'utf8');
-```
-
-The `path` may be specified as a numeric file descriptor that has been opened
-for appending (using `fs.open()` or `fs.openSync()`). The file descriptor will
-not be closed automatically.
 
-```js
-let fd;
+open('message.txt', 'a', (err, fd) => {
+  if (err) throw err;
 
-try {
-  fd = fs.openSync('message.txt', 'a');
-  fs.appendFileSync(fd, 'data to append', 'utf8');
-} catch (err) {
-  /* Handle the error */
-} finally {
-  if (fd !== undefined)
-    fs.closeSync(fd);
-}
+  try {
+    appendFile(fd, 'data to append', 'utf8', (err) => {
+      closeFd(fd);
+      if (err) throw err;
+    });
+  } catch (err) {
+    closeFd(fd);
+    throw err;
+  }
+});
 ```
 
-## `fs.chmod(path, mode, callback)`
+### `fs.chmod(path, mode, callback)`
 <!-- YAML
 added: v0.1.30
 changes:
@@ -1461,7 +1616,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -1476,16 +1631,18 @@ changes:
 Asynchronously changes the permissions of a file. No arguments other than a
 possible exception are given to the completion callback.
 
-See also: chmod(2).
+See the POSIX chmod(2) documentation for more detail.
 
-```js
-fs.chmod('my_file.txt', 0o775, (err) => {
+```mjs
+import { chmod } from 'fs';
+
+chmod('my_file.txt', 0o775, (err) => {
   if (err) throw err;
   console.log('The permissions for file "my_file.txt" have been changed!');
 });
 ```
 
-### File modes
+#### File modes
 
 The `mode` argument used in both the `fs.chmod()` and `fs.chmodSync()`
 methods is a numeric bitmask created using a logical OR of the following
@@ -1509,16 +1666,16 @@ the permissions for the file owner. The middle digit (`6` in the example),
 specifies permissions for the group. The right-most digit (`5` in the example),
 specifies the permissions for others.
 
-| Number  |       Description        |
-| ------- | ------------------------ |
-|   `7`   | read, write, and execute |
-|   `6`   | read and write           |
-|   `5`   | read and execute         |
-|   `4`   | read only                |
-|   `3`   | write and execute        |
-|   `2`   | write only               |
-|   `1`   | execute only             |
-|   `0`   | no permission            |
+| Number | Description              |
+| ------ | ------------------------ |
+| `7`    | read, write, and execute |
+| `6`    | read and write           |
+| `5`    | read and execute         |
+| `4`    | read only                |
+| `3`    | write and execute        |
+| `2`    | write only               |
+| `1`    | execute only             |
+| `0`    | no permission            |
 
 For example, the octal value `0o765` means:
 
@@ -1535,25 +1692,7 @@ Caveats: on Windows only the write permission can be changed, and the
 distinction among the permissions of group, owner or others is not
 implemented.
 
-## `fs.chmodSync(path, mode)`
-<!-- YAML
-added: v0.6.7
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-* `mode` {string|integer}
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.chmod()`][].
-
-See also: chmod(2).
-
-## `fs.chown(path, uid, gid, callback)`
+### `fs.chown(path, uid, gid, callback)`
 <!-- YAML
 added: v0.1.97
 changes:
@@ -1564,7 +1703,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -1580,31 +1719,15 @@ changes:
 Asynchronously changes owner and group of a file. No arguments other than a
 possible exception are given to the completion callback.
 
-See also: chown(2).
-
-## `fs.chownSync(path, uid, gid)`
-<!-- YAML
-added: v0.1.97
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-* `uid` {integer}
-* `gid` {integer}
-
-Synchronously changes owner and group of a file. Returns `undefined`.
-This is the synchronous version of [`fs.chown()`][].
-
-See also: chown(2).
+See the POSIX chown(2) documentation for more detail.
 
-## `fs.close(fd, callback)`
+### `fs.close(fd[, callback])`
 <!-- YAML
 added: v0.0.2
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37174
+    description: A default callback is now used if one is not provided.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -1619,33 +1742,15 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous close(2). No arguments other than a possible exception are given
-to the completion callback.
+Closes the file descriptor. No arguments other than a possible exception are
+given to the completion callback.
 
 Calling `fs.close()` on any file descriptor (`fd`) that is currently in use
 through any other `fs` operation may lead to undefined behavior.
 
-## `fs.closeSync(fd)`
-<!-- YAML
-added: v0.1.21
--->
-
-* `fd` {integer}
-
-Synchronous close(2). Returns `undefined`.
-
-Calling `fs.closeSync()` on any file descriptor (`fd`) that is currently in use
-through any other `fs` operation may lead to undefined behavior.
-
-## `fs.constants`
-
-* {Object}
-
-Returns an object containing commonly used constants for file system
-operations. The specific constants currently defined are described in
-[FS constants][].
+See the POSIX close(2) documentation for more detail.
 
-## `fs.copyFile(src, dest[, flags], callback)`
+### `fs.copyFile(src, dest[, mode], callback)`
 <!-- YAML
 added: v8.5.0
 changes:
@@ -1657,7 +1762,7 @@ changes:
 
 * `src` {string|Buffer|URL} source filename to copy
 * `dest` {string|Buffer|URL} destination filename of the copy operation
-* `flags` {number} modifiers for copy operation. **Default:** `0`.
+* `mode` {integer} modifiers for copy operation. **Default:** `0`.
 * `callback` {Function}
 
 Asynchronously copies `src` to `dest`. By default, `dest` is overwritten if it
@@ -1666,95 +1771,48 @@ callback function. Node.js makes no guarantees about the atomicity of the copy
 operation. If an error occurs after the destination file has been opened for
 writing, Node.js will attempt to remove the destination.
 
-`flags` is an optional integer that specifies the behavior
+`mode` is an optional integer that specifies the behavior
 of the copy operation. It is possible to create a mask consisting of the bitwise
 OR of two or more values (e.g.
 `fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`).
 
 * `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already
-exists.
+  exists.
 * `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a
-copy-on-write reflink. If the platform does not support copy-on-write, then a
-fallback copy mechanism is used.
+  copy-on-write reflink. If the platform does not support copy-on-write, then a
+  fallback copy mechanism is used.
 * `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.
+  create a copy-on-write reflink. If the platform does not support
+  copy-on-write, then the operation will fail.
 
-```js
-const fs = require('fs');
+```mjs
+import { copyFile, constants } from 'fs';
 
-// destination.txt will be created or overwritten by default.
-fs.copyFile('source.txt', 'destination.txt', (err) => {
+function callback(err) {
   if (err) throw err;
   console.log('source.txt was copied to destination.txt');
-});
-```
-
-If the third argument is a number, then it specifies `flags`:
-
-```js
-const fs = require('fs');
-const { COPYFILE_EXCL } = fs.constants;
-
-// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
-fs.copyFile('source.txt', 'destination.txt', COPYFILE_EXCL, callback);
-```
-
-## `fs.copyFileSync(src, dest[, flags])`
-<!-- YAML
-added: v8.5.0
-changes:
-  - version: v14.0.0
-    pr-url: https://github.com/nodejs/node/pull/27044
-    description: Changed 'flags' argument to 'mode' and imposed
-                 stricter type validation.
--->
-
-* `src` {string|Buffer|URL} source filename to copy
-* `dest` {string|Buffer|URL} destination filename of the copy operation
-* `flags` {number} modifiers for copy operation. **Default:** `0`.
-
-Synchronously copies `src` to `dest`. By default, `dest` is overwritten if it
-already exists. Returns `undefined`. Node.js makes no guarantees about the
-atomicity of the copy operation. If an error occurs after the destination file
-has been opened for writing, Node.js will attempt to remove the destination.
-
-`flags` is an optional integer that specifies the behavior
-of the copy operation. It is possible to create a mask consisting of the bitwise
-OR of two or more values (e.g.
-`fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`).
-
-* `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already
-exists.
-* `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a
-copy-on-write reflink. If the platform does not support copy-on-write, then a
-fallback copy mechanism is used.
-* `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.
-
-```js
-const fs = require('fs');
+}
 
 // destination.txt will be created or overwritten by default.
-fs.copyFileSync('source.txt', 'destination.txt');
-console.log('source.txt was copied to destination.txt');
-```
-
-If the third argument is a number, then it specifies `flags`:
-
-```js
-const fs = require('fs');
-const { COPYFILE_EXCL } = fs.constants;
+copyFile('source.txt', 'destination.txt', callback);
 
 // By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
-fs.copyFileSync('source.txt', 'destination.txt', COPYFILE_EXCL);
+copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL, callback);
 ```
 
-## `fs.createReadStream(path[, options])`
+### `fs.createReadStream(path[, options])`
 <!-- YAML
 added: v0.1.31
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31408
+    description: Change `emitClose` default to `true`.
+  - version:
+     - v13.6.0
+     - v12.17.0
+    pr-url: https://github.com/nodejs/node/pull/29083
+    description: The `fs` options allow overriding the used `fs`
+                 implementation.
   - version: v12.10.0
     pr-url: https://github.com/nodejs/node/pull/29212
     description: Enable `emitClose` option.
@@ -1766,28 +1824,24 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
+                 `file:` protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7831
     description: The passed `options` object will never be modified.
   - version: v2.3.0
     pr-url: https://github.com/nodejs/node/pull/1845
     description: The passed `options` object can be a string now.
-  - version: v12.17.0
-    pr-url: https://github.com/nodejs/node/pull/29083
-    description: The `fs` options allow overriding the used `fs`
-                 implementation.
 -->
 
 * `path` {string|Buffer|URL}
 * `options` {string|Object}
   * `flags` {string} See [support of file system `flags`][]. **Default:**
-  `'r'`.
+    `'r'`.
   * `encoding` {string} **Default:** `null`
   * `fd` {integer} **Default:** `null`
   * `mode` {integer} **Default:** `0o666`
   * `autoClose` {boolean} **Default:** `true`
-  * `emitClose` {boolean} **Default:** `false`
+  * `emitClose` {boolean} **Default:** `true`
   * `start` {integer}
   * `end` {integer} **Default:** `Infinity`
   * `highWaterMark` {integer} **Default:** `64 * 1024`
@@ -1803,30 +1857,31 @@ start counting at 0, allowed values are in the
 [0, [`Number.MAX_SAFE_INTEGER`][]] range. If `fd` is specified and `start` is
 omitted or `undefined`, `fs.createReadStream()` reads sequentially from the
 current file position. The `encoding` can be any one of those accepted by
-[`Buffer`][].
+{Buffer}.
 
 If `fd` is specified, `ReadStream` will ignore the `path` argument and will use
 the specified file descriptor. This means that no `'open'` event will be
 emitted. `fd` should be blocking; non-blocking `fd`s should be passed to
-[`net.Socket`][].
+{net.Socket}.
 
 If `fd` points to a character device that only supports blocking reads
 (such as keyboard or sound card), read operations do not finish until data is
 available. This can prevent the process from exiting and the stream from
 closing naturally.
 
-By default, the stream will not emit a `'close'` event after it has been
-destroyed. This is the opposite of the default for other `Readable` streams.
-Set the `emitClose` option to `true` to change this behavior.
+By default, the stream will emit a `'close'` event after it has been
+destroyed, like most `Readable` streams.  Set the `emitClose` option to
+`false` to change this behavior.
 
 By providing the `fs` option, it is possible to override the corresponding `fs`
 implementations for `open`, `read`, and `close`. When providing the `fs` option,
 overrides for `open`, `read`, and `close` are required.
 
-```js
-const fs = require('fs');
+```mjs
+import { createReadStream } from 'fs';
+
 // Create a stream from some character device.
-const stream = fs.createReadStream('/dev/input/event0');
+const stream = createReadStream('/dev/input/event0');
 setTimeout(() => {
   stream.close(); // This may not close the stream.
   // Artificially marking end-of-stream, as if the underlying resource had
@@ -1850,23 +1905,34 @@ file was created.
 
 An example to read the last 10 bytes of a file which is 100 bytes long:
 
-```js
-fs.createReadStream('sample.txt', { start: 90, end: 99 });
+```mjs
+import { createReadStream } from 'fs';
+
+createReadStream('sample.txt', { start: 90, end: 99 });
 ```
 
 If `options` is a string, then it specifies the encoding.
 
-## `fs.createWriteStream(path[, options])`
+### `fs.createWriteStream(path[, options])`
 <!-- YAML
 added: v0.1.31
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31408
+    description: Change `emitClose` default to `true`.
+  - version:
+     - v13.6.0
+     - v12.17.0
+    pr-url: https://github.com/nodejs/node/pull/29083
+    description: The `fs` options allow overriding the used `fs`
+                 implementation.
   - version: v12.10.0
     pr-url: https://github.com/nodejs/node/pull/29212
     description: Enable `emitClose` option.
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
+                 `file:` protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7831
     description: The passed `options` object will never be modified.
@@ -1876,31 +1942,26 @@ changes:
   - version: v2.3.0
     pr-url: https://github.com/nodejs/node/pull/1845
     description: The passed `options` object can be a string now.
-  - version: v12.17.0
-    pr-url: https://github.com/nodejs/node/pull/v12.17.0
-    description: The `fs` options allow overriding the used `fs`
-                 implementation.
 -->
 
 * `path` {string|Buffer|URL}
 * `options` {string|Object}
   * `flags` {string} See [support of file system `flags`][]. **Default:**
-  `'w'`.
+    `'w'`.
   * `encoding` {string} **Default:** `'utf8'`
   * `fd` {integer} **Default:** `null`
   * `mode` {integer} **Default:** `0o666`
   * `autoClose` {boolean} **Default:** `true`
-  * `emitClose` {boolean} **Default:** `false`
+  * `emitClose` {boolean} **Default:** `true`
   * `start` {integer}
   * `fs` {Object|null} **Default:** `null`
 * Returns: {fs.WriteStream} See [Writable Stream][].
 
-`options` may also include a `start` option to allow writing data at
-some position past the beginning of the file, allowed values are in the
-[0, [`Number.MAX_SAFE_INTEGER`][]] range. Modifying a file rather
-than replacing it may require a `flags` mode of `r+` rather than the
-default mode `w`. The `encoding` can be any one of those accepted by
-[`Buffer`][].
+`options` may also include a `start` option to allow writing data at some
+position past the beginning of the file, allowed values are in the
+[0, [`Number.MAX_SAFE_INTEGER`][]] range. Modifying a file rather than replacing
+it may require the `flags` option to be set to `r+` rather than the default `w`.
+The `encoding` can be any one of those accepted by {Buffer}.
 
 If `autoClose` is set to true (default behavior) on `'error'` or `'finish'`
 the file descriptor will be closed automatically. If `autoClose` is false,
@@ -1908,9 +1969,9 @@ then the file descriptor won't be closed, even if there's an error.
 It is the application's responsibility to close it and make sure there's no
 file descriptor leak.
 
-By default, the stream will not emit a `'close'` event after it has been
-destroyed. This is the opposite of the default for other `Writable` streams.
-Set the `emitClose` option to `true` to change this behavior.
+By default, the stream will emit a `'close'` event after it has been
+destroyed, like most `Writable` streams.  Set the `emitClose` option to
+`false` to change this behavior.
 
 By providing the `fs` option it is possible to override the corresponding `fs`
 implementations for `open`, `write`, `writev` and `close`. Overriding `write()`
@@ -1918,22 +1979,22 @@ without `writev()` can reduce performance as some optimizations (`_writev()`)
 will be disabled. When providing the `fs` option,  overrides for `open`,
 `close`, and at least one of `write` and `writev` are required.
 
-Like [`ReadStream`][], if `fd` is specified, [`WriteStream`][] will ignore the
+Like {fs.ReadStream}, if `fd` is specified, {fs.WriteStream} will ignore the
 `path` argument and will use the specified file descriptor. This means that no
 `'open'` event will be emitted. `fd` should be blocking; non-blocking `fd`s
-should be passed to [`net.Socket`][].
+should be passed to {net.Socket}.
 
 If `options` is a string, then it specifies the encoding.
 
-## `fs.exists(path, callback)`
+### `fs.exists(path, callback)`
 <!-- YAML
 added: v0.0.2
+deprecated: v1.0.0
 changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
-deprecated: v1.0.0
+                 `file:` protocol.
 -->
 
 > Stability: 0 - Deprecated: Use [`fs.stat()`][] or [`fs.access()`][] instead.
@@ -1945,9 +2006,11 @@ deprecated: v1.0.0
 Test whether or not the given path exists by checking with the file system.
 Then call the `callback` argument with either true or false:
 
-```js
-fs.exists('/etc/passwd', (exists) => {
-  console.log(exists ? 'it\'s there' : 'no passwd!');
+```mjs
+import { exists } from 'fs';
+
+exists('/etc/passwd', (e) => {
+  console.log(e ? 'it exists' : 'no passwd!');
 });
 ```
 
@@ -1965,14 +2028,23 @@ file directly and handle the error raised if the file does not exist.
 
 **write (NOT RECOMMENDED)**
 
-```js
-fs.exists('myfile', (exists) => {
-  if (exists) {
+```mjs
+import { exists, open, close } from 'fs';
+
+exists('myfile', (e) => {
+  if (e) {
     console.error('myfile already exists');
   } else {
-    fs.open('myfile', 'wx', (err, fd) => {
+    open('myfile', 'wx', (err, fd) => {
       if (err) throw err;
-      writeMyData(fd);
+
+      try {
+        writeMyData(fd);
+      } finally {
+        close(fd, (err) => {
+          if (err) throw err;
+        });
+      }
     });
   }
 });
@@ -1980,8 +2052,9 @@ fs.exists('myfile', (exists) => {
 
 **write (RECOMMENDED)**
 
-```js
-fs.open('myfile', 'wx', (err, fd) => {
+```mjs
+import { open, close } from 'fs';
+open('myfile', 'wx', (err, fd) => {
   if (err) {
     if (err.code === 'EEXIST') {
       console.error('myfile already exists');
@@ -1991,18 +2064,33 @@ fs.open('myfile', 'wx', (err, fd) => {
     throw err;
   }
 
-  writeMyData(fd);
+  try {
+    writeMyData(fd);
+  } finally {
+    close(fd, (err) => {
+      if (err) throw err;
+    });
+  }
 });
 ```
 
 **read (NOT RECOMMENDED)**
 
-```js
-fs.exists('myfile', (exists) => {
-  if (exists) {
-    fs.open('myfile', 'r', (err, fd) => {
+```mjs
+import { open, close, exists } from 'fs';
+
+exists('myfile', (e) => {
+  if (e) {
+    open('myfile', 'r', (err, fd) => {
       if (err) throw err;
-      readMyData(fd);
+
+      try {
+        readMyData(fd);
+      } finally {
+        close(fd, (err) => {
+          if (err) throw err;
+        });
+      }
     });
   } else {
     console.error('myfile does not exist');
@@ -2012,8 +2100,10 @@ fs.exists('myfile', (exists) => {
 
 **read (RECOMMENDED)**
 
-```js
-fs.open('myfile', 'r', (err, fd) => {
+```mjs
+import { open, close } from 'fs';
+
+open('myfile', 'r', (err, fd) => {
   if (err) {
     if (err.code === 'ENOENT') {
       console.error('myfile does not exist');
@@ -2023,7 +2113,13 @@ fs.open('myfile', 'r', (err, fd) => {
     throw err;
   }
 
-  readMyData(fd);
+  try {
+    readMyData(fd);
+  } finally {
+    close(fd, (err) => {
+      if (err) throw err;
+    });
+  }
 });
 ```
 
@@ -2035,35 +2131,7 @@ In general, check for the existence of a file only if the file won’t be
 used directly, for example when its existence is a signal from another
 process.
 
-## `fs.existsSync(path)`
-<!-- YAML
-added: v0.1.21
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-* Returns: {boolean}
-
-Returns `true` if the path exists, `false` otherwise.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.exists()`][].
-
-`fs.exists()` is deprecated, but `fs.existsSync()` is not. The `callback`
-parameter to `fs.exists()` accepts parameters that are inconsistent with other
-Node.js callbacks. `fs.existsSync()` does not use a callback.
-
-```js
-if (fs.existsSync('/etc/passwd')) {
-  console.log('The path exists.');
-}
-```
-
-## `fs.fchmod(fd, mode, callback)`
+### `fs.fchmod(fd, mode, callback)`
 <!-- YAML
 added: v0.4.7
 changes:
@@ -2082,20 +2150,12 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous fchmod(2). No arguments other than a possible exception
+Sets the permissions on the file. No arguments other than a possible exception
 are given to the completion callback.
 
-## `fs.fchmodSync(fd, mode)`
-<!-- YAML
-added: v0.4.7
--->
-
-* `fd` {integer}
-* `mode` {string|integer}
-
-Synchronous fchmod(2). Returns `undefined`.
+See the POSIX fchmod(2) documentation for more detail.
 
-## `fs.fchown(fd, uid, gid, callback)`
+### `fs.fchown(fd, uid, gid, callback)`
 <!-- YAML
 added: v0.4.7
 changes:
@@ -2115,21 +2175,12 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous fchown(2). No arguments other than a possible exception are given
-to the completion callback.
-
-## `fs.fchownSync(fd, uid, gid)`
-<!-- YAML
-added: v0.4.7
--->
-
-* `fd` {integer}
-* `uid` {integer}
-* `gid` {integer}
+Sets the owner of the file. No arguments other than a possible exception are
+given to the completion callback.
 
-Synchronous fchown(2). Returns `undefined`.
+See the POSIX fchown(2) documentation for more detail.
 
-## `fs.fdatasync(fd, callback)`
+### `fs.fdatasync(fd, callback)`
 <!-- YAML
 added: v0.1.96
 changes:
@@ -2147,22 +2198,19 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous fdatasync(2). No arguments other than a possible exception are
-given to the completion callback.
-
-## `fs.fdatasyncSync(fd)`
-<!-- YAML
-added: v0.1.96
--->
-
-* `fd` {integer}
-
-Synchronous fdatasync(2). Returns `undefined`.
+Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+fdatasync(2) documentation for details. No arguments other than a possible
+exception are given to the completion callback.
 
-## `fs.fstat(fd[, options], callback)`
+### `fs.fstat(fd[, options], callback)`
 <!-- YAML
 added: v0.1.95
 changes:
+  - version: v10.5.0
+    pr-url: https://github.com/nodejs/node/pull/20220
+    description: Accepts an additional `options` object to specify whether
+                 the numeric values returned should be bigint.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -2171,43 +2219,21 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
                  it will emit a deprecation warning with id DEP0013.
-  - version: v10.5.0
-    pr-url: https://github.com/nodejs/node/pull/20220
-    description: Accepts an additional `options` object to specify whether
-                 the numeric values returned should be bigint.
 -->
 
 * `fd` {integer}
 * `options` {Object}
   * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
 * `callback` {Function}
   * `err` {Error}
   * `stats` {fs.Stats}
 
-Asynchronous fstat(2). The callback gets two arguments `(err, stats)` where
-`stats` is an [`fs.Stats`][] object. `fstat()` is identical to [`stat()`][],
-except that the file to be stat-ed is specified by the file descriptor `fd`.
-
-## `fs.fstatSync(fd[, options])`
-<!-- YAML
-added: v0.1.95
-changes:
-  - version: v10.5.0
-    pr-url: https://github.com/nodejs/node/pull/20220
-    description: Accepts an additional `options` object to specify whether
-                 the numeric values returned should be bigint.
--->
-
-* `fd` {integer}
-* `options` {Object}
-  * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
-* Returns: {fs.Stats}
+Invokes the callback with the {fs.Stats} for the file descriptor.
 
-Synchronous fstat(2).
+See the POSIX fstat(2) documentation for more detail.
 
-## `fs.fsync(fd, callback)`
+### `fs.fsync(fd, callback)`
 <!-- YAML
 added: v0.1.96
 changes:
@@ -2225,19 +2251,12 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous fsync(2). No arguments other than a possible exception are given
-to the completion callback.
-
-## `fs.fsyncSync(fd)`
-<!-- YAML
-added: v0.1.96
--->
-
-* `fd` {integer}
-
-Synchronous fsync(2). Returns `undefined`.
+Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX fsync(2) documentation for more detail. No arguments other
+than a possible exception are given to the completion callback.
 
-## `fs.ftruncate(fd[, len], callback)`
+### `fs.ftruncate(fd[, len], callback)`
 <!-- YAML
 added: v0.8.6
 changes:
@@ -2256,65 +2275,47 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous ftruncate(2). No arguments other than a possible exception are
+Truncates the file descriptor. No arguments other than a possible exception are
 given to the completion callback.
 
+See the POSIX ftruncate(2) documentation for more detail.
+
 If the file referred to by the file descriptor was larger than `len` bytes, only
 the first `len` bytes will be retained in the file.
 
 For example, the following program retains only the first four bytes of the
 file:
 
-```js
-console.log(fs.readFileSync('temp.txt', 'utf8'));
-// Prints: Node.js
+```mjs
+import { open, close, ftruncate } from 'fs';
+
+function closeFd(fd) {
+  close(fd, (err) => {
+    if (err) throw err;
+  });
+}
 
-// get the file descriptor of the file to be truncated
-const fd = fs.openSync('temp.txt', 'r+');
+open('temp.txt', 'r+', (err, fd) => {
+  if (err) throw err;
 
-// Truncate the file to first four bytes
-fs.ftruncate(fd, 4, (err) => {
-  assert.ifError(err);
-  console.log(fs.readFileSync('temp.txt', 'utf8'));
+  try {
+    ftruncate(fd, 4, (err) => {
+      closeFd(fd);
+      if (err) throw err;
+    });
+  } catch (err) {
+    closeFd(fd);
+    if (err) throw err;
+  }
 });
-// Prints: Node
 ```
 
 If the file previously was shorter than `len` bytes, it is extended, and the
 extended part is filled with null bytes (`'\0'`):
 
-```js
-console.log(fs.readFileSync('temp.txt', 'utf8'));
-// Prints: Node.js
-
-// get the file descriptor of the file to be truncated
-const fd = fs.openSync('temp.txt', 'r+');
-
-// Truncate the file to 10 bytes, whereas the actual size is 7 bytes
-fs.ftruncate(fd, 10, (err) => {
-  assert.ifError(err);
-  console.log(fs.readFileSync('temp.txt'));
-});
-// Prints: <Buffer 4e 6f 64 65 2e 6a 73 00 00 00>
-// ('Node.js\0\0\0' in UTF8)
-```
-
-The last three bytes are null bytes (`'\0'`), to compensate the over-truncation.
-
-## `fs.ftruncateSync(fd[, len])`
-<!-- YAML
-added: v0.8.6
--->
-
-* `fd` {integer}
-* `len` {integer} **Default:** `0`
-
-Returns `undefined`.
+If `len` is negative then `0` will be used.
 
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.ftruncate()`][].
-
-## `fs.futimes(fd, atime, mtime, callback)`
+### `fs.futimes(fd, atime, mtime, callback)`
 <!-- YAML
 added: v0.4.2
 changes:
@@ -2344,23 +2345,7 @@ descriptor. See [`fs.utimes()`][].
 This function does not work on AIX versions before 7.1, it will return the
 error `UV_ENOSYS`.
 
-## `fs.futimesSync(fd, atime, mtime)`
-<!-- YAML
-added: v0.4.2
-changes:
-  - version: v4.1.0
-    pr-url: https://github.com/nodejs/node/pull/2387
-    description: Numeric strings, `NaN` and `Infinity` are now allowed
-                 time specifiers.
--->
-
-* `fd` {integer}
-* `atime` {number|string|Date}
-* `mtime` {number|string|Date}
-
-Synchronous version of [`fs.futimes()`][]. Returns `undefined`.
-
-## `fs.lchmod(path, mode, callback)`
+### `fs.lchmod(path, mode, callback)`
 <!-- YAML
 deprecated: v0.4.7
 changes:
@@ -2379,22 +2364,14 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous lchmod(2). No arguments other than a possible exception
-are given to the completion callback.
-
-Only available on macOS.
+Changes the permissions on a symbolic link. No arguments other than a possible
+exception are given to the completion callback.
 
-## `fs.lchmodSync(path, mode)`
-<!-- YAML
-deprecated: v0.4.7
--->
-
-* `path` {string|Buffer|URL}
-* `mode` {integer}
+This method is only implemented on macOS.
 
-Synchronous lchmod(2). Returns `undefined`.
+See the POSIX lchmod(2) documentation for more detail.
 
-## `fs.lchown(path, uid, gid, callback)`
+### `fs.lchown(path, uid, gid, callback)`
 <!-- YAML
 changes:
   - version: v10.6.0
@@ -2418,28 +2395,16 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous lchown(2). No arguments other than a possible exception are given
-to the completion callback.
-
-## `fs.lchownSync(path, uid, gid)`
-<!-- YAML
-changes:
-  - version: v10.6.0
-    pr-url: https://github.com/nodejs/node/pull/21498
-    description: This API is no longer deprecated.
-  - version: v0.4.7
-    description: Documentation-only deprecation.
--->
-
-* `path` {string|Buffer|URL}
-* `uid` {integer}
-* `gid` {integer}
+Set the owner of the symbolic link. No arguments other than a possible
+exception are given to the completion callback.
 
-Synchronous lchown(2). Returns `undefined`.
+See the POSIX lchown(2) documentation for more detail.
 
-## `fs.lutimes(path, atime, mtime, callback)`
+### `fs.lutimes(path, atime, mtime, callback)`
 <!-- YAML
-added: v12.19.0
+added:
+  - v14.5.0
+  - v12.19.0
 -->
 
 * `path` {string|Buffer|URL}
@@ -2456,20 +2421,7 @@ symbolic link itself are changed.
 No arguments other than a possible exception are given to the completion
 callback.
 
-## `fs.lutimesSync(path, atime, mtime)`
-<!-- YAML
-added: v12.19.0
--->
-
-* `path` {string|Buffer|URL}
-* `atime` {number|string|Date}
-* `mtime` {number|string|Date}
-
-Change the file system timestamps of the symbolic link referenced by `path`.
-Returns `undefined`, or throws an exception when parameters are incorrect or
-the operation fails. This is the synchronous version of [`fs.lutimes()`][].
-
-## `fs.link(existingPath, newPath, callback)`
+### `fs.link(existingPath, newPath, callback)`
 <!-- YAML
 added: v0.1.31
 changes:
@@ -2493,29 +2445,18 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous link(2). No arguments other than a possible exception are given to
-the completion callback.
-
-## `fs.linkSync(existingPath, newPath)`
-<!-- YAML
-added: v0.1.31
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `existingPath` and `newPath` parameters can be WHATWG
-                 `URL` objects using `file:` protocol. Support is currently
-                 still *experimental*.
--->
-
-* `existingPath` {string|Buffer|URL}
-* `newPath` {string|Buffer|URL}
+Creates a new link from the `existingPath` to the `newPath`. See the POSIX
+link(2) documentation for more detail. No arguments other than a possible
+exception are given to the completion callback.
 
-Synchronous link(2). Returns `undefined`.
-
-## `fs.lstat(path[, options], callback)`
+### `fs.lstat(path[, options], callback)`
 <!-- YAML
 added: v0.1.30
 changes:
+  - version: v10.5.0
+    pr-url: https://github.com/nodejs/node/pull/20220
+    description: Accepts an additional `options` object to specify whether
+                 the numeric values returned should be bigint.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -2523,57 +2464,35 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
                  it will emit a deprecation warning with id DEP0013.
-  - version: v10.5.0
-    pr-url: https://github.com/nodejs/node/pull/20220
-    description: Accepts an additional `options` object to specify whether
-                 the numeric values returned should be bigint.
 -->
 
 * `path` {string|Buffer|URL}
 * `options` {Object}
   * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
 * `callback` {Function}
   * `err` {Error}
   * `stats` {fs.Stats}
 
-Asynchronous lstat(2). The callback gets two arguments `(err, stats)` where
-`stats` is a [`fs.Stats`][] object. `lstat()` is identical to `stat()`,
-except that if `path` is a symbolic link, then the link itself is stat-ed,
-not the file that it refers to.
-
-## `fs.lstatSync(path[, options])`
-<!-- YAML
-added: v0.1.30
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
-  - version: v10.5.0
-    pr-url: https://github.com/nodejs/node/pull/20220
-    description: Accepts an additional `options` object to specify whether
-                 the numeric values returned should be bigint.
--->
-
-* `path` {string|Buffer|URL}
-* `options` {Object}
-  * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
-* Returns: {fs.Stats}
+Retrieves the {fs.Stats} for the symbolic link referred to by the path.
+The callback gets two arguments `(err, stats)` where `stats` is a {fs.Stats}
+object. `lstat()` is identical to `stat()`, except that if `path` is a symbolic
+link, then the link itself is stat-ed, not the file that it refers to.
 
-Synchronous lstat(2).
+See the POSIX lstat(2) documentation for more details.
 
-## `fs.mkdir(path[, options], callback)`
+### `fs.mkdir(path[, options], callback)`
 <!-- YAML
 added: v0.1.8
 changes:
-  - version: v12.17.0
+  - version:
+     - v13.11.0
+     - v12.17.0
     pr-url: https://github.com/nodejs/node/pull/31530
     description: In `recursive` mode, the callback now receives the first
                  created path as an argument.
@@ -2588,7 +2507,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -2606,16 +2525,20 @@ Asynchronously creates a directory.
 
 The callback is given a possible exception and, if `recursive` is `true`, the
 first directory path created, `(err, [path])`.
+`path` can still be `undefined` when `recursive` is `true`, if no directory was
+created.
 
-The optional `options` argument can be an integer specifying mode (permission
+The optional `options` argument can be an integer specifying `mode` (permission
 and sticky bits), or an object with a `mode` property and a `recursive`
 property indicating whether parent directories should be created. Calling
 `fs.mkdir()` when `path` is a directory that exists results in an error only
 when `recursive` is false.
 
-```js
+```mjs
+import { mkdir } from 'fs';
+
 // Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.
-fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
+mkdir('/tmp/a/apple', { recursive: true }, (err) => {
   if (err) throw err;
 });
 ```
@@ -2623,47 +2546,23 @@ fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
 On Windows, using `fs.mkdir()` on the root directory even with recursion will
 result in an error:
 
-```js
-fs.mkdir('/', { recursive: true }, (err) => {
+```mjs
+import { mkdir } from 'fs';
+
+mkdir('/', { recursive: true }, (err) => {
   // => [Error: EPERM: operation not permitted, mkdir 'C:\']
 });
 ```
 
-See also: mkdir(2).
+See the POSIX mkdir(2) documentation for more details.
 
-## `fs.mkdirSync(path[, options])`
+### `fs.mkdtemp(prefix[, options], callback)`
 <!-- YAML
-added: v0.1.21
-changes:
-  - version: v12.17.0
-    pr-url: https://github.com/nodejs/node/pull/31530
-    description: In `recursive` mode, the first created path is returned now.
-  - version: v10.12.0
-    pr-url: https://github.com/nodejs/node/pull/21875
-    description: The second argument can now be an `options` object with
-                 `recursive` and `mode` properties.
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-* `options` {Object|integer}
-  * `recursive` {boolean} **Default:** `false`
-  * `mode` {string|integer} Not supported on Windows. **Default:** `0o777`.
-* Returns: {string|undefined}
-
-Synchronously creates a directory. Returns `undefined`, or if `recursive` is
-`true`, the first directory path created.
-This is the synchronous version of [`fs.mkdir()`][].
-
-See also: mkdir(2).
-
-## `fs.mkdtemp(prefix[, options], callback)`
-<!-- YAML
-added: v5.10.0
+added: v5.10.0
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/39028
+    description: The `prefix` parameter now accepts an empty string.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -2698,8 +2597,10 @@ parameter.
 The optional `options` argument can be a string specifying an encoding, or an
 object with an `encoding` property specifying the character encoding to use.
 
-```js
-fs.mkdtemp(path.join(os.tmpdir(), 'foo-'), (err, directory) => {
+```mjs
+import { mkdtemp } from 'fs';
+
+mkdtemp(path.join(os.tmpdir(), 'foo-'), (err, directory) => {
   if (err) throw err;
   console.log(directory);
   // Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2
@@ -2712,12 +2613,15 @@ intention is to create a temporary directory *within* `/tmp`, the `prefix`
 must end with a trailing platform-specific path separator
 (`require('path').sep`).
 
-```js
+```mjs
+import { tmpdir } from 'os';
+import { mkdtemp } from 'fs';
+
 // The parent directory for the new temporary directory
-const tmpDir = os.tmpdir();
+const tmpDir = tmpdir();
 
 // This method is *INCORRECT*:
-fs.mkdtemp(tmpDir, (err, directory) => {
+mkdtemp(tmpDir, (err, directory) => {
   if (err) throw err;
   console.log(directory);
   // Will print something similar to `/tmpabc123`.
@@ -2726,8 +2630,8 @@ fs.mkdtemp(tmpDir, (err, directory) => {
 });
 
 // This method is *CORRECT*:
-const { sep } = require('path');
-fs.mkdtemp(`${tmpDir}${sep}`, (err, directory) => {
+import { sep } from 'path';
+mkdtemp(`${tmpDir}${sep}`, (err, directory) => {
   if (err) throw err;
   console.log(directory);
   // Will print something similar to `/tmp/abc123`.
@@ -2736,25 +2640,7 @@ fs.mkdtemp(`${tmpDir}${sep}`, (err, directory) => {
 });
 ```
 
-## `fs.mkdtempSync(prefix[, options])`
-<!-- YAML
-added: v5.10.0
--->
-
-* `prefix` {string}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-* Returns: {string}
-
-Returns the created directory path.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.mkdtemp()`][].
-
-The optional `options` argument can be a string specifying an encoding, or an
-object with an `encoding` property specifying the character encoding to use.
-
-## `fs.open(path[, flags[, mode]], callback)`
+### `fs.open(path[, flags[, mode]], callback)`
 <!-- YAML
 added: v0.0.2
 changes:
@@ -2763,11 +2649,11 @@ changes:
     description: The `flags` argument is now optional and defaults to `'r'`.
   - version: v9.9.0
     pr-url: https://github.com/nodejs/node/pull/18801
-    description: The `as` and `as+` modes are supported now.
+    description: The `as` and `as+` flags are supported now.
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
 -->
 
 * `path` {string|Buffer|URL}
@@ -2778,7 +2664,7 @@ changes:
   * `err` {Error}
   * `fd` {integer}
 
-Asynchronous file open. See open(2).
+Asynchronous file open. See the POSIX open(2) documentation for more details.
 
 `mode` sets the file mode (permission and sticky bits), but only if the file was
 created. On Windows, only the write permission can be manipulated; see
@@ -2794,11 +2680,13 @@ a colon, Node.js will open a file system stream, as described by
 Functions based on `fs.open()` exhibit this behavior as well:
 `fs.writeFile()`, `fs.readFile()`, etc.
 
-## `fs.opendir(path[, options], callback)`
+### `fs.opendir(path[, options], callback)`
 <!-- YAML
 added: v12.12.0
 changes:
-  - version: v12.16.0
+  - version:
+     - v13.1.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30114
     description: The `bufferSize` option was introduced.
 -->
@@ -2813,67 +2701,16 @@ changes:
   * `err` {Error}
   * `dir` {fs.Dir}
 
-Asynchronously open a directory. See opendir(3).
-
-Creates an [`fs.Dir`][], which contains all further functions for reading from
-and cleaning up the directory.
-
-The `encoding` option sets the encoding for the `path` while opening the
-directory and subsequent read operations.
-
-## `fs.opendirSync(path[, options])`
-<!-- YAML
-added: v12.12.0
-changes:
-  - version: v12.16.0
-    pr-url: https://github.com/nodejs/node/pull/30114
-    description: The `bufferSize` option was introduced.
--->
-
-* `path` {string|Buffer|URL}
-* `options` {Object}
-  * `encoding` {string|null} **Default:** `'utf8'`
-  * `bufferSize` {number} Number of directory entries that are buffered
-    internally when reading from the directory. Higher values lead to better
-    performance but higher memory usage. **Default:** `32`
-* Returns: {fs.Dir}
-
-Synchronously open a directory. See opendir(3).
+Asynchronously open a directory. See the POSIX opendir(3) documentation for
+more details.
 
-Creates an [`fs.Dir`][], which contains all further functions for reading from
+Creates an {fs.Dir}, which contains all further functions for reading from
 and cleaning up the directory.
 
 The `encoding` option sets the encoding for the `path` while opening the
 directory and subsequent read operations.
 
-## `fs.openSync(path[, flags, mode])`
-<!-- YAML
-added: v0.1.21
-changes:
-  - version: v11.1.0
-    pr-url: https://github.com/nodejs/node/pull/23767
-    description: The `flags` argument is now optional and defaults to `'r'`.
-  - version: v9.9.0
-    pr-url: https://github.com/nodejs/node/pull/18801
-    description: The `as` and `as+` modes are supported now.
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-* `flags` {string|number} **Default:** `'r'`.
-   See [support of file system `flags`][].
-* `mode` {string|integer} **Default:** `0o666`
-* Returns: {number}
-
-Returns an integer representing the file descriptor.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.open()`][].
-
-## `fs.read(fd, buffer, offset, length, position, callback)`
+### `fs.read(fd, buffer, offset, length, position, callback)`
 <!-- YAML
 added: v0.0.2
 changes:
@@ -2890,10 +2727,16 @@ changes:
 -->
 
 * `fd` {integer}
-* `buffer` {Buffer|TypedArray|DataView}
-* `offset` {integer}
-* `length` {integer}
-* `position` {integer}
+* `buffer` {Buffer|TypedArray|DataView} The buffer that the data will be
+  written to. **Default:** `Buffer.alloc(16384)`
+* `offset` {integer} The position in `buffer` to write the data to. **Default:**
+  `0`
+* `length` {integer} The number of bytes to read. **Default:**
+  `buffer.byteLength`
+* `position` {integer|bigint} Specifies where to begin reading from in the
+  file. If `position` is `null` or `-1 `, data will be read from the current
+  file position, and the file position will be updated. If `position` is an
+  integer, the file position will be unchanged.
 * `callback` {Function}
   * `err` {Error}
   * `bytesRead` {integer}
@@ -2901,46 +2744,43 @@ changes:
 
 Read data from the file specified by `fd`.
 
-`buffer` is the buffer that the data (read from the fd) will be written to.
-
-`offset` is the offset in the buffer to start writing at.
-
-`length` is an integer specifying the number of bytes to read.
-
-`position` is an argument specifying where to begin reading from in the file.
-If `position` is `null`, data will be read from the current file position,
-and the file position will be updated.
-If `position` is an integer, the file position will remain unchanged.
-
 The callback is given the three arguments, `(err, bytesRead, buffer)`.
 
+If the file is not modified concurrently, the end-of-file is reached when the
+number of bytes read is zero.
+
 If this method is invoked as its [`util.promisify()`][]ed version, it returns
-a `Promise` for an `Object` with `bytesRead` and `buffer` properties.
+a promise for an `Object` with `bytesRead` and `buffer` properties.
 
-## `fs.read(fd, [options,] callback)`
+### `fs.read(fd, [options,] callback)`
 <!-- YAML
-added: v12.17.0
+added:
+ - v13.11.0
+ - v12.17.0
 changes:
-  - version: v12.17.0
+  - version:
+     - v13.11.0
+     - v12.17.0
     pr-url: https://github.com/nodejs/node/pull/31402
     description: Options object can be passed in
-                 to make Buffer, offset, length and position optional
+                 to make Buffer, offset, length and position optional.
 -->
 * `fd` {integer}
 * `options` {Object}
   * `buffer` {Buffer|TypedArray|DataView} **Default:** `Buffer.alloc(16384)`
   * `offset` {integer} **Default:** `0`
-  * `length` {integer} **Default:** `buffer.length`
-  * `position` {integer} **Default:** `null`
+  * `length` {integer} **Default:** `buffer.byteLength`
+  * `position` {integer|bigint} **Default:** `null`
 * `callback` {Function}
   * `err` {Error}
   * `bytesRead` {integer}
   * `buffer` {Buffer}
 
-Similar to the above `fs.read` function, this version takes an optional `options` object.
-If no `options` object is specified, it will default with the above values.
+Similar to the [`fs.read()`][] function, this version takes an optional
+`options` object. If no `options` object is specified, it will default with the
+above values.
 
-## `fs.readdir(path[, options], callback)`
+### `fs.readdir(path[, options], callback)`
 <!-- YAML
 added: v0.1.8
 changes:
@@ -2954,7 +2794,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -2972,51 +2812,28 @@ changes:
   * `err` {Error}
   * `files` {string[]|Buffer[]|fs.Dirent[]}
 
-Asynchronous readdir(3). Reads the contents of a directory.
-The callback gets two arguments `(err, files)` where `files` is an array of
-the names of the files in the directory excluding `'.'` and `'..'`.
+Reads the contents of a directory. The callback gets two arguments `(err, files)`
+where `files` is an array of the names of the files in the directory excluding
+`'.'` and `'..'`.
+
+See the POSIX readdir(3) documentation for more details.
 
 The optional `options` argument can be a string specifying an encoding, or an
 object with an `encoding` property specifying the character encoding to use for
 the filenames passed to the callback. If the `encoding` is set to `'buffer'`,
-the filenames returned will be passed as `Buffer` objects.
+the filenames returned will be passed as {Buffer} objects.
 
 If `options.withFileTypes` is set to `true`, the `files` array will contain
-[`fs.Dirent`][] objects.
-
-## `fs.readdirSync(path[, options])`
-<!-- YAML
-added: v0.1.21
-changes:
-  - version: v10.10.0
-    pr-url: https://github.com/nodejs/node/pull/22020
-    description: New option `withFileTypes` was added.
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-  * `withFileTypes` {boolean} **Default:** `false`
-* Returns: {string[]|Buffer[]|fs.Dirent[]}
-
-Synchronous readdir(3).
-
-The optional `options` argument can be a string specifying an encoding, or an
-object with an `encoding` property specifying the character encoding to use for
-the filenames returned. If the `encoding` is set to `'buffer'`,
-the filenames returned will be passed as `Buffer` objects.
-
-If `options.withFileTypes` is set to `true`, the result will contain
-[`fs.Dirent`][] objects.
+{fs.Dirent} objects.
 
-## `fs.readFile(path[, options], callback)`
+### `fs.readFile(path[, options], callback)`
 <!-- YAML
 added: v0.1.29
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/35911
+    description: The options argument may include an AbortSignal to abort an
+                 ongoing readFile request.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -3024,7 +2841,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -3042,14 +2859,17 @@ changes:
 * `options` {Object|string}
   * `encoding` {string|null} **Default:** `null`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
+  * `signal` {AbortSignal} allows aborting an in-progress readFile
 * `callback` {Function}
   * `err` {Error}
   * `data` {string|Buffer}
 
 Asynchronously reads the entire contents of a file.
 
-```js
-fs.readFile('/etc/passwd', (err, data) => {
+```mjs
+import { readFile } from 'fs';
+
+readFile('/etc/passwd', (err, data) => {
   if (err) throw err;
   console.log(data);
 });
@@ -3062,8 +2882,10 @@ If no encoding is specified, then the raw buffer is returned.
 
 If `options` is a string, then it specifies the encoding:
 
-```js
-fs.readFile('/etc/passwd', 'utf8', callback);
+```mjs
+import { readFile } from 'fs';
+
+readFile('/etc/passwd', 'utf8', callback);
 ```
 
 When the path is a directory, the behavior of `fs.readFile()` and
@@ -3071,71 +2893,74 @@ When the path is a directory, the behavior of `fs.readFile()` and
 error will be returned. On FreeBSD, a representation of the directory's contents
 will be returned.
 
-```js
+```mjs
+import { readFile } from 'fs';
+
 // macOS, Linux, and Windows
-fs.readFile('<directory>', (err, data) => {
+readFile('<directory>', (err, data) => {
   // => [Error: EISDIR: illegal operation on a directory, read <directory>]
 });
 
 //  FreeBSD
-fs.readFile('<directory>', (err, data) => {
+readFile('<directory>', (err, data) => {
   // => null, <data>
 });
 ```
 
+It is possible to abort an ongoing request using an `AbortSignal`. If a
+request is aborted the callback is called with an `AbortError`:
+
+```mjs
+import { readFile } from 'fs';
+
+const controller = new AbortController();
+const signal = controller.signal;
+readFile(fileInfo[0].name, { signal }, (err, buf) => {
+  // ...
+});
+// When you want to abort the request
+controller.abort();
+```
+
 The `fs.readFile()` function buffers the entire file. To minimize memory costs,
 when possible prefer streaming via `fs.createReadStream()`.
 
-### File descriptors
+Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering `fs.readFile` performs.
+
+#### File descriptors
 
 1. Any specified file descriptor has to support reading.
 2. If a file descriptor is specified as the `path`, it will not be closed
-automatically.
+   automatically.
 3. The reading will begin at the current position. For example, if the file
-already had `'Hello World`' and six bytes are read with the file descriptor,
-the call to `fs.readFile()` with the same file descriptor, would give
-`'World'`, rather than `'Hello World'`.
-
-## `fs.readFileSync(path[, options])`
-<!-- YAML
-added: v0.1.8
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
-  - version: v5.0.0
-    pr-url: https://github.com/nodejs/node/pull/3163
-    description: The `path` parameter can be a file descriptor now.
--->
-
-* `path` {string|Buffer|URL|integer} filename or file descriptor
-* `options` {Object|string}
-  * `encoding` {string|null} **Default:** `null`
-  * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
-* Returns: {string|Buffer}
+   already had `'Hello World`' and six bytes are read with the file descriptor,
+   the call to `fs.readFile()` with the same file descriptor, would give
+   `'World'`, rather than `'Hello World'`.
 
-Returns the contents of the `path`.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.readFile()`][].
+#### Performance Considerations
 
-If the `encoding` option is specified then this function returns a
-string. Otherwise it returns a buffer.
+The `fs.readFile()` method asynchronously reads the contents of a file into
+memory one chunk at a time, allowing the event loop to turn between each chunk.
+This allows the read operation to have less impact on other activity that may
+be using the underlying libuv thread pool but means that it will take longer
+to read a complete file into memory.
 
-Similar to [`fs.readFile()`][], when the path is a directory, the behavior of
-`fs.readFileSync()` is platform-specific.
+The additional read overhead can vary broadly on different systems and depends
+on the type of file being read. If the file type is not a regular file (a pipe
+for instance) and Node.js is unable to determine an actual file size, each read
+operation will load on 64kb of data. For regular files, each read will process
+512kb of data.
 
-```js
-// macOS, Linux, and Windows
-fs.readFileSync('<directory>');
-// => [Error: EISDIR: illegal operation on a directory, read <directory>]
+For applications that require as-fast-as-possible reading of file contents, it
+is better to use `fs.read()` directly and for application code to manage
+reading the full contents of the file itself.
 
-//  FreeBSD
-fs.readFileSync('<directory>'); // => <data>
-```
+The Node.js GitHub issue [#25741][] provides more information and a detailed
+analysis on the performance of `fs.readFile()` for multiple file sizes in
+different Node.js versions.
 
-## `fs.readlink(path[, options], callback)`
+### `fs.readlink(path[, options], callback)`
 <!-- YAML
 added: v0.1.31
 changes:
@@ -3146,7 +2971,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -3160,90 +2985,21 @@ changes:
   * `err` {Error}
   * `linkString` {string|Buffer}
 
-Asynchronous readlink(2). The callback gets two arguments `(err,
-linkString)`.
-
-The optional `options` argument can be a string specifying an encoding, or an
-object with an `encoding` property specifying the character encoding to use for
-the link path passed to the callback. If the `encoding` is set to `'buffer'`,
-the link path returned will be passed as a `Buffer` object.
-
-## `fs.readlinkSync(path[, options])`
-<!-- YAML
-added: v0.1.31
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-* Returns: {string|Buffer}
+Reads the contents of the symbolic link referred to by `path`. The callback gets
+two arguments `(err, linkString)`.
 
-Synchronous readlink(2). Returns the symbolic link's string value.
+See the POSIX readlink(2) documentation for more details.
 
 The optional `options` argument can be a string specifying an encoding, or an
 object with an `encoding` property specifying the character encoding to use for
-the link path returned. If the `encoding` is set to `'buffer'`,
-the link path returned will be passed as a `Buffer` object.
-
-## `fs.readSync(fd, buffer, offset, length, position)`
-<!-- YAML
-added: v0.1.21
-changes:
-  - version: v10.10.0
-    pr-url: https://github.com/nodejs/node/pull/22150
-    description: The `buffer` parameter can now be any `TypedArray` or a
-                 `DataView`.
-  - version: v6.0.0
-    pr-url: https://github.com/nodejs/node/pull/4518
-    description: The `length` parameter can now be `0`.
--->
-
-* `fd` {integer}
-* `buffer` {Buffer|TypedArray|DataView}
-* `offset` {integer}
-* `length` {integer}
-* `position` {integer}
-* Returns: {number}
-
-Returns the number of `bytesRead`.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.read()`][].
-
-## `fs.readSync(fd, buffer, [options])`
-<!-- YAML
-added: v12.17.0
-changes:
-  - version: v12.17.0
-    pr-url: https://github.com/nodejs/node/pull/32460
-    description: Options object can be passed in
-                 to make offset, length and position optional
--->
-
-* `fd` {integer}
-* `buffer` {Buffer|TypedArray|DataView}
-* `options` {Object}
-  * `offset` {integer} **Default:** `0`
-  * `length` {integer} **Default:** `buffer.length`
-  * `position` {integer} **Default:** `null`
-* Returns: {number}
-
-Returns the number of `bytesRead`.
-
-Similar to the above `fs.readSync` function, this version takes an optional `options` object.
-If no `options` object is specified, it will default with the above values.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.read()`][].
+the link path passed to the callback. If the `encoding` is set to `'buffer'`,
+the link path returned will be passed as a {Buffer} object.
 
-## `fs.readv(fd, buffers[, position], callback)`
+### `fs.readv(fd, buffers[, position], callback)`
 <!-- YAML
-added: v12.17.0
+added:
+ - v13.13.0
+ - v12.17.0
 -->
 
 * `fd` {integer}
@@ -3265,22 +3021,9 @@ The callback will be given three arguments: `err`, `bytesRead`, and
 `buffers`. `bytesRead` is how many bytes were read from the file.
 
 If this method is invoked as its [`util.promisify()`][]ed version, it returns
-a `Promise` for an `Object` with `bytesRead` and `buffers` properties.
-
-## `fs.readvSync(fd, buffers[, position])`
-<!-- YAML
-added: v12.17.0
--->
-
-* `fd` {integer}
-* `buffers` {ArrayBufferView[]}
-* `position` {integer}
-* Returns: {number} The number of bytes read.
+a promise for an `Object` with `bytesRead` and `buffers` properties.
 
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.readv()`][].
-
-## `fs.realpath(path[, options], callback)`
+### `fs.realpath(path[, options], callback)`
 <!-- YAML
 added: v0.1.31
 changes:
@@ -3294,7 +3037,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
+                 `file:` protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -3336,12 +3079,12 @@ Only paths that can be converted to UTF8 strings are supported.
 The optional `options` argument can be a string specifying an encoding, or an
 object with an `encoding` property specifying the character encoding to use for
 the path passed to the callback. If the `encoding` is set to `'buffer'`,
-the path returned will be passed as a `Buffer` object.
+the path returned will be passed as a {Buffer} object.
 
 If `path` resolves to a socket or a pipe, the function will return a system
 dependent name for that object.
 
-## `fs.realpath.native(path[, options], callback)`
+### `fs.realpath.native(path[, options], callback)`
 <!-- YAML
 added: v9.2.0
 -->
@@ -3362,82 +3105,29 @@ Only paths that can be converted to UTF8 strings are supported.
 The optional `options` argument can be a string specifying an encoding, or an
 object with an `encoding` property specifying the character encoding to use for
 the path passed to the callback. If the `encoding` is set to `'buffer'`,
-the path returned will be passed as a `Buffer` object.
+the path returned will be passed as a {Buffer} object.
 
 On Linux, when Node.js is linked against musl libc, the procfs file system must
 be mounted on `/proc` in order for this function to work. Glibc does not have
 this restriction.
 
-## `fs.realpathSync(path[, options])`
+### `fs.rename(oldPath, newPath, callback)`
 <!-- YAML
-added: v0.1.31
+added: v0.0.2
 changes:
-  - version: v8.0.0
-    pr-url: https://github.com/nodejs/node/pull/13028
-    description: Pipe/Socket resolve support was added.
+  - version: v10.0.0
+    pr-url: https://github.com/nodejs/node/pull/12562
+    description: The `callback` parameter is no longer optional. Not passing
+                 it will throw a `TypeError` at runtime.
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
-  - version: v6.4.0
-    pr-url: https://github.com/nodejs/node/pull/7899
-    description: Calling `realpathSync` now works again for various edge cases
-                 on Windows.
-  - version: v6.0.0
-    pr-url: https://github.com/nodejs/node/pull/3594
-    description: The `cache` parameter was removed.
--->
-
-* `path` {string|Buffer|URL}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-* Returns: {string|Buffer}
-
-Returns the resolved pathname.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.realpath()`][].
-
-## `fs.realpathSync.native(path[, options])`
-<!-- YAML
-added: v9.2.0
--->
-
-* `path` {string|Buffer|URL}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-* Returns: {string|Buffer}
-
-Synchronous realpath(3).
-
-Only paths that can be converted to UTF8 strings are supported.
-
-The optional `options` argument can be a string specifying an encoding, or an
-object with an `encoding` property specifying the character encoding to use for
-the path returned. If the `encoding` is set to `'buffer'`,
-the path returned will be passed as a `Buffer` object.
-
-On Linux, when Node.js is linked against musl libc, the procfs file system must
-be mounted on `/proc` in order for this function to work. Glibc does not have
-this restriction.
-
-## `fs.rename(oldPath, newPath, callback)`
-<!-- YAML
-added: v0.0.2
-changes:
-  - version: v10.0.0
-    pr-url: https://github.com/nodejs/node/pull/12562
-    description: The `callback` parameter is no longer optional. Not passing
-                 it will throw a `TypeError` at runtime.
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `oldPath` and `newPath` parameters can be WHATWG `URL`
-                 objects using `file:` protocol. Support is currently still
-                 *experimental*.
-  - version: v7.0.0
-    pr-url: https://github.com/nodejs/node/pull/7897
-    description: The `callback` parameter is no longer optional. Not passing
-                 it will emit a deprecation warning with id DEP0013.
+    description: The `oldPath` and `newPath` parameters can be WHATWG `URL`
+                 objects using `file:` protocol. Support is currently still
+                 *experimental*.
+  - version: v7.0.0
+    pr-url: https://github.com/nodejs/node/pull/7897
+    description: The `callback` parameter is no longer optional. Not passing
+                 it will emit a deprecation warning with id DEP0013.
 -->
 
 * `oldPath` {string|Buffer|URL}
@@ -3453,34 +3143,25 @@ given to the completion callback.
 
 See also: rename(2).
 
-```js
-fs.rename('oldFile.txt', 'newFile.txt', (err) => {
+```mjs
+import { rename } from 'fs';
+
+rename('oldFile.txt', 'newFile.txt', (err) => {
   if (err) throw err;
   console.log('Rename complete!');
 });
 ```
 
-## `fs.renameSync(oldPath, newPath)`
-<!-- YAML
-added: v0.1.21
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `oldPath` and `newPath` parameters can be WHATWG `URL`
-                 objects using `file:` protocol. Support is currently still
-                 *experimental*.
--->
-
-* `oldPath` {string|Buffer|URL}
-* `newPath` {string|Buffer|URL}
-
-Synchronous rename(2). Returns `undefined`.
-
-## `fs.rmdir(path[, options], callback)`
+### `fs.rmdir(path[, options], callback)`
 <!-- YAML
 added: v0.0.2
 changes:
-  - version: v12.16.0
+  - version: v14.14.0
+    pr-url: https://github.com/nodejs/node/pull/35579
+    description: The `recursive` option is deprecated, use `fs.rm` instead.
+  - version:
+     - v13.3.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30644
     description: The `maxBusyTries` option is renamed to `maxRetries`, and its
                  default is 0. The `emfileWait` option has been removed, and
@@ -3498,28 +3179,26 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameters can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
+                 `file:` protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
                  it will emit a deprecation warning with id DEP0013.
 -->
 
-> Stability: 1 - Recursive removal is experimental.
-
 * `path` {string|Buffer|URL}
 * `options` {Object}
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
-  `EPERM` error is encountered, Node.js will retry the operation with a linear
-  backoff wait of `retryDelay` ms longer on each try. This option represents the
-  number of retries. This option is ignored if the `recursive` option is not
-  `true`. **Default:** `0`.
+    `EPERM` error is encountered, Node.js retries the operation with a linear
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
-  recursive mode, errors are not reported if `path` does not exist, and
-  operations are retried on failure. **Default:** `false`.
+    recursive mode, errors are not reported if `path` does not exist, and
+    operations are retried on failure. **Default:** `false`.
   * `retryDelay` {integer} The amount of time in milliseconds to wait between
-  retries. This option is ignored if the `recursive` option is not `true`.
-  **Default:** `100`.
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
 * `callback` {Function}
   * `err` {Error}
 
@@ -3529,52 +3208,46 @@ to the completion callback.
 Using `fs.rmdir()` on a file (not a directory) results in an `ENOENT` error on
 Windows and an `ENOTDIR` error on POSIX.
 
-## `fs.rmdirSync(path[, options])`
+Setting `recursive` to `true` results in behavior similar to the Unix command
+`rm -rf`: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+`recursive` option is deprecated, `ENOTDIR` and `ENOENT` will be thrown in
+the future.
+
+### `fs.rm(path[, options], callback)`
 <!-- YAML
-added: v0.1.21
-changes:
-  - version: v12.16.0
-    pr-url: https://github.com/nodejs/node/pull/30644
-    description: The `maxBusyTries` option is renamed to `maxRetries`, and its
-                 default is 0. The `emfileWait` option has been removed, and
-                 `EMFILE` errors use the same retry logic as other errors. The
-                 `retryDelay` option is now supported. `ENFILE` errors are now
-                 retried.
-  - version: v12.10.0
-    pr-url: https://github.com/nodejs/node/pull/29168
-    description: The `recursive`, `maxBusyTries`, and `emfileWait` options are
-                 now supported.
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameters can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
+added: v14.14.0
 -->
 
-> Stability: 1 - Recursive removal is experimental.
-
 * `path` {string|Buffer|URL}
 * `options` {Object}
+  * `force` {boolean} When `true`, exceptions will be ignored if `path` does
+    not exist. **Default:** `false`.
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
-  `EPERM` error is encountered, Node.js will retry the operation with a linear
-  backoff wait of `retryDelay` ms longer on each try. This option represents the
-  number of retries. This option is ignored if the `recursive` option is not
-  `true`. **Default:** `0`.
-  * `recursive` {boolean} If `true`, perform a recursive directory removal. In
-  recursive mode, errors are not reported if `path` does not exist, and
-  operations are retried on failure. **Default:** `false`.
+    `EPERM` error is encountered, Node.js will retry the operation with a linear
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
+  * `recursive` {boolean} If `true`, perform a recursive removal. In
+    recursive mode operations are retried on failure. **Default:** `false`.
   * `retryDelay` {integer} The amount of time in milliseconds to wait between
-  retries. This option is ignored if the `recursive` option is not `true`.
-  **Default:** `100`.
-
-Synchronous rmdir(2). Returns `undefined`.
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
+* `callback` {Function}
+  * `err` {Error}
 
-Using `fs.rmdirSync()` on a file (not a directory) results in an `ENOENT` error
-on Windows and an `ENOTDIR` error on POSIX.
+Asynchronously removes files and directories (modeled on the standard POSIX `rm`
+utility). No arguments other than a possible exception are given to the
+completion callback.
 
-## `fs.stat(path[, options], callback)`
+### `fs.stat(path[, options], callback)`
 <!-- YAML
 added: v0.0.2
 changes:
+  - version: v10.5.0
+    pr-url: https://github.com/nodejs/node/pull/20220
+    description: Accepts an additional `options` object to specify whether
+                 the numeric values returned should be bigint.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -3582,27 +3255,23 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
                  it will emit a deprecation warning with id DEP0013.
-  - version: v10.5.0
-    pr-url: https://github.com/nodejs/node/pull/20220
-    description: Accepts an additional `options` object to specify whether
-                 the numeric values returned should be bigint.
 -->
 
 * `path` {string|Buffer|URL}
 * `options` {Object}
   * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
 * `callback` {Function}
   * `err` {Error}
   * `stats` {fs.Stats}
 
 Asynchronous stat(2). The callback gets two arguments `(err, stats)` where
-`stats` is an [`fs.Stats`][] object.
+`stats` is an {fs.Stats} object.
 
 In case of an error, the `err.code` will be one of [Common System Errors][].
 
@@ -3624,13 +3293,13 @@ For example, given the following directory structure:
 
 The next program will check for the stats of the given paths:
 
-```js
-const fs = require('fs');
+```mjs
+import { stat } from 'fs';
 
 const pathsToCheck = ['./txtDir', './txtDir/file.txt'];
 
 for (let i = 0; i < pathsToCheck.length; i++) {
-  fs.stat(pathsToCheck[i], function(err, stats) {
+  stat(pathsToCheck[i], (err, stats) => {
     console.log(stats.isDirectory());
     console.log(stats);
   });
@@ -3684,41 +3353,19 @@ Stats {
 }
 ```
 
-## `fs.statSync(path[, options])`
-<!-- YAML
-added: v0.1.21
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
-  - version: v10.5.0
-    pr-url: https://github.com/nodejs/node/pull/20220
-    description: Accepts an additional `options` object to specify whether
-                 the numeric values returned should be bigint.
--->
-
-* `path` {string|Buffer|URL}
-* `options` {Object}
-  * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
-* Returns: {fs.Stats}
-
-Synchronous stat(2).
-
-## `fs.symlink(target, path[, type], callback)`
+### `fs.symlink(target, path[, type], callback)`
 <!-- YAML
 added: v0.1.31
 changes:
+  - version: v12.0.0
+    pr-url: https://github.com/nodejs/node/pull/23724
+    description: If the `type` argument is left undefined, Node will autodetect
+                 `target` type and automatically select `dir` or `file`.
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `target` and `path` parameters can be WHATWG `URL` objects
                  using `file:` protocol. Support is currently still
                  *experimental*.
-  - version: v12.0.0
-    pr-url: https://github.com/nodejs/node/pull/23724
-    description: If the `type` argument is left undefined, Node will autodetect
-                 `target` type and automatically select `dir` or `file`
 -->
 
 * `target` {string|Buffer|URL}
@@ -3727,9 +3374,10 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous symlink(2) which creates the link called `path` pointing to
-`target`. No arguments other than a possible exception are given to the
-completion callback.
+Creates the link called `path` pointing to `target`. No arguments other than a
+possible exception are given to the completion callback.
+
+See the POSIX symlink(2) documentation for more details.
 
 The `type` argument is only available on Windows and ignored on other platforms.
 It can be set to `'dir'`, `'file'`, or `'junction'`. If the `type` argument is
@@ -3740,8 +3388,10 @@ require the destination path to be absolute. When using `'junction'`, the
 
 Relative targets are relative to the link’s parent directory.
 
-```js
-fs.symlink('./mew', './example/mewtwo', callback);
+```mjs
+import { symlink } from 'fs';
+
+symlink('./mew', './example/mewtwo', callback);
 ```
 
 The above example creates a symbolic link `mewtwo` in the `example` which points
@@ -3754,31 +3404,7 @@ example/
 └── mewtwo -> ./mew
 ```
 
-## `fs.symlinkSync(target, path[, type])`
-<!-- YAML
-added: v0.1.31
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `target` and `path` parameters can be WHATWG `URL` objects
-                 using `file:` protocol. Support is currently still
-                 *experimental*.
-  - version: v12.0.0
-    pr-url: https://github.com/nodejs/node/pull/23724
-    description: If the `type` argument is left undefined, Node will autodetect
-                 `target` type and automatically select `dir` or `file`
--->
-
-* `target` {string|Buffer|URL}
-* `path` {string|Buffer|URL}
-* `type` {string}
-
-Returns `undefined`.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.symlink()`][].
-
-## `fs.truncate(path[, len], callback)`
+### `fs.truncate(path[, len], callback)`
 <!-- YAML
 added: v0.8.6
 changes:
@@ -3797,28 +3423,34 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous truncate(2). No arguments other than a possible exception are
+Truncates the file. No arguments other than a possible exception are
 given to the completion callback. A file descriptor can also be passed as the
 first argument. In this case, `fs.ftruncate()` is called.
 
-Passing a file descriptor is deprecated and may result in an error being thrown
-in the future.
-
-## `fs.truncateSync(path[, len])`
-<!-- YAML
-added: v0.8.6
--->
-
-* `path` {string|Buffer|URL}
-* `len` {integer} **Default:** `0`
+```mjs
+import { truncate } from 'fs';
+// Assuming that 'path/file.txt' is a regular file.
+truncate('path/file.txt', (err) => {
+  if (err) throw err;
+  console.log('path/file.txt was truncated');
+});
+```
 
-Synchronous truncate(2). Returns `undefined`. A file descriptor can also be
-passed as the first argument. In this case, `fs.ftruncateSync()` is called.
+```cjs
+const { truncate } = require('fs');
+// Assuming that 'path/file.txt' is a regular file.
+truncate('path/file.txt', (err) => {
+  if (err) throw err;
+  console.log('path/file.txt was truncated');
+});
+```
 
 Passing a file descriptor is deprecated and may result in an error being thrown
 in the future.
 
-## `fs.unlink(path, callback)`
+See the POSIX truncate(2) documentation for more details.
+
+### `fs.unlink(path, callback)`
 <!-- YAML
 added: v0.0.2
 changes:
@@ -3829,7 +3461,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -3843,9 +3475,10 @@ changes:
 Asynchronously removes a file or symbolic link. No arguments other than a
 possible exception are given to the completion callback.
 
-```js
+```mjs
+import { unlink } from 'fs';
 // Assuming that 'path/file.txt' is a regular file.
-fs.unlink('path/file.txt', (err) => {
+unlink('path/file.txt', (err) => {
   if (err) throw err;
   console.log('path/file.txt was deleted');
 });
@@ -3854,23 +3487,9 @@ fs.unlink('path/file.txt', (err) => {
 `fs.unlink()` will not work on a directory, empty or otherwise. To remove a
 directory, use [`fs.rmdir()`][].
 
-See also: unlink(2).
-
-## `fs.unlinkSync(path)`
-<!-- YAML
-added: v0.1.21
-changes:
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
--->
-
-* `path` {string|Buffer|URL}
-
-Synchronous unlink(2). Returns `undefined`.
+See the POSIX unlink(2) documentation for more details.
 
-## `fs.unwatchFile(filename[, listener])`
+### `fs.unwatchFile(filename[, listener])`
 <!-- YAML
 added: v0.1.31
 -->
@@ -3890,7 +3509,7 @@ Using [`fs.watch()`][] is more efficient than `fs.watchFile()` and
 `fs.unwatchFile()`. `fs.watch()` should be used instead of `fs.watchFile()`
 and `fs.unwatchFile()` when possible.
 
-## `fs.utimes(path, atime, mtime, callback)`
+### `fs.utimes(path, atime, mtime, callback)`
 <!-- YAML
 added: v0.4.2
 changes:
@@ -3905,7 +3524,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
+                 protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7897
     description: The `callback` parameter is no longer optional. Not passing
@@ -3931,41 +3550,17 @@ The `atime` and `mtime` arguments follow these rules:
 * If the value can not be converted to a number, or is `NaN`, `Infinity` or
   `-Infinity`, an `Error` will be thrown.
 
-## `fs.utimesSync(path, atime, mtime)`
-<!-- YAML
-added: v0.4.2
-changes:
-  - version: v8.0.0
-    pr-url: https://github.com/nodejs/node/pull/11919
-    description: "`NaN`, `Infinity`, and `-Infinity` are no longer valid time
-                 specifiers."
-  - version: v7.6.0
-    pr-url: https://github.com/nodejs/node/pull/10739
-    description: The `path` parameter can be a WHATWG `URL` object using `file:`
-                 protocol. Support is currently still *experimental*.
-  - version: v4.1.0
-    pr-url: https://github.com/nodejs/node/pull/2387
-    description: Numeric strings, `NaN` and `Infinity` are now allowed
-                 time specifiers.
--->
-
-* `path` {string|Buffer|URL}
-* `atime` {number|string|Date}
-* `mtime` {number|string|Date}
-
-Returns `undefined`.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.utimes()`][].
-
-## `fs.watch(filename[, options][, listener])`
+### `fs.watch(filename[, options][, listener])`
 <!-- YAML
 added: v0.5.10
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37190
+    description: Added support for closing the watcher with an AbortSignal.
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `filename` parameter can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
+                 `file:` protocol.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7831
     description: The passed `options` object will never be modified.
@@ -3977,10 +3572,11 @@ changes:
     as long as files are being watched. **Default:** `true`.
   * `recursive` {boolean} Indicates whether all subdirectories should be
     watched, or only the current directory. This applies when a directory is
-    specified, and only on supported platforms (See [Caveats][]). **Default:**
+    specified, and only on supported platforms (See [caveats][]). **Default:**
     `false`.
   * `encoding` {string} Specifies the character encoding to be used for the
      filename passed to the listener. **Default:** `'utf8'`.
+  * `signal` {AbortSignal} allows closing the watcher with an AbortSignal.
 * `listener` {Function|undefined} **Default:** `undefined`
   * `eventType` {string}
   * `filename` {string|Buffer}
@@ -4000,10 +3596,13 @@ On most platforms, `'rename'` is emitted whenever a filename appears or
 disappears in the directory.
 
 The listener callback is attached to the `'change'` event fired by
-[`fs.FSWatcher`][], but it is not the same thing as the `'change'` value of
+{fs.FSWatcher}, but it is not the same thing as the `'change'` value of
 `eventType`.
 
-### Caveats
+If a `signal` is passed, aborting the corresponding AbortController will close
+the returned {fs.FSWatcher}.
+
+#### Caveats
 
 <!--type=misc-->
 
@@ -4011,11 +3610,13 @@ The `fs.watch` API is not 100% consistent across platforms, and is
 unavailable in some situations.
 
 The recursive option is only supported on macOS and Windows.
+An `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM` exception will be thrown
+when the option is used on a platform that does not support it.
 
 On Windows, no events will be emitted if the watched directory is moved or
 renamed. An `EPERM` error is reported when the watched directory is deleted.
 
-#### Availability
+##### Availability
 
 <!--type=misc-->
 
@@ -4028,11 +3629,11 @@ to be notified of filesystem changes.
   directories.
 * On SunOS systems (including Solaris and SmartOS), this uses [`event ports`][].
 * On Windows systems, this feature depends on [`ReadDirectoryChangesW`][].
-* On Aix systems, this feature depends on [`AHAFS`][], which must be enabled.
+* On AIX systems, this feature depends on [`AHAFS`][], which must be enabled.
 * On IBM i systems, this feature is not supported.
 
 If the underlying functionality is not available for some reason, then
-`fs.watch()` will not be able to function and may thrown an exception.
+`fs.watch()` will not be able to function and may throw an exception.
 For example, watching files or directories can be unreliable, and in some
 cases impossible, on network file systems (NFS, SMB, etc) or host file systems
 when using virtualization software such as Vagrant or Docker.
@@ -4040,7 +3641,7 @@ when using virtualization software such as Vagrant or Docker.
 It is still possible to use `fs.watchFile()`, which uses stat polling, but
 this method is slower and less reliable.
 
-#### Inodes
+##### Inodes
 
 <!--type=misc-->
 
@@ -4054,7 +3655,7 @@ AIX files retain the same inode for the lifetime of a file. Saving and closing a
 watched file on AIX will result in two notifications (one for adding new
 content, and one for truncation).
 
-#### Filename argument
+##### Filename argument
 
 <!--type=misc-->
 
@@ -4063,8 +3664,9 @@ macOS, Windows, and AIX. Even on supported platforms, `filename` is not always
 guaranteed to be provided. Therefore, don't assume that `filename` argument is
 always provided in the callback, and have some fallback logic if it is `null`.
 
-```js
-fs.watch('somedir', (eventType, filename) => {
+```mjs
+import { watch } from 'fs';
+watch('somedir', (eventType, filename) => {
   console.log(`event type is: ${eventType}`);
   if (filename) {
     console.log(`filename provided: ${filename}`);
@@ -4074,7 +3676,7 @@ fs.watch('somedir', (eventType, filename) => {
 });
 ```
 
-## `fs.watchFile(filename[, options], listener)`
+### `fs.watchFile(filename[, options], listener)`
 <!-- YAML
 added: v0.1.31
 changes:
@@ -4084,7 +3686,7 @@ changes:
   - version: v7.6.0
     pr-url: https://github.com/nodejs/node/pull/10739
     description: The `filename` parameter can be a WHATWG `URL` object using
-                 `file:` protocol. Support is currently still *experimental*.
+                 `file:` protocol.
 -->
 
 * `filename` {string|Buffer|URL}
@@ -4109,8 +3711,10 @@ target should be polled in milliseconds.
 The `listener` gets two arguments the current stat object and the previous
 stat object:
 
-```js
-fs.watchFile('message.text', (curr, prev) => {
+```mjs
+import { watchFile } from 'fs';
+
+watchFile('message.text', (curr, prev) => {
   console.log(`the current mtime is: ${curr.mtime}`);
   console.log(`the previous mtime was: ${prev.mtime}`);
 });
@@ -4142,14 +3746,22 @@ This happens when:
 * the file is deleted, followed by a restore
 * the file is renamed and then renamed a second time back to its original name
 
-## `fs.write(fd, buffer[, offset[, length[, position]]], callback)`
+### `fs.write(fd, buffer[, offset[, length[, position]]], callback)`
 <!-- YAML
 added: v0.0.2
 changes:
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `buffer` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `buffer` parameter won't coerce unsupported input to
+                 strings anymore.
   - version: v10.10.0
     pr-url: https://github.com/nodejs/node/pull/22150
     description: The `buffer` parameter can now be any `TypedArray` or a
-                 `DataView`
+                 `DataView`.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -4167,7 +3779,7 @@ changes:
 -->
 
 * `fd` {integer}
-* `buffer` {Buffer|TypedArray|DataView}
+* `buffer` {Buffer|TypedArray|DataView|string|Object}
 * `offset` {integer}
 * `length` {integer}
 * `position` {integer}
@@ -4176,7 +3788,8 @@ changes:
   * `bytesWritten` {integer}
   * `buffer` {Buffer|TypedArray|DataView}
 
-Write `buffer` to the file specified by `fd`.
+Write `buffer` to the file specified by `fd`. If `buffer` is a normal object, it
+must have an own `toString` function property.
 
 `offset` determines the part of the buffer to be written, and `length` is
 an integer specifying the number of bytes to write.
@@ -4189,7 +3802,7 @@ The callback will be given three arguments `(err, bytesWritten, buffer)` where
 `bytesWritten` specifies how many _bytes_ were written from `buffer`.
 
 If this method is invoked as its [`util.promisify()`][]ed version, it returns
-a `Promise` for an `Object` with `bytesWritten` and `buffer` properties.
+a promise for an `Object` with `bytesWritten` and `buffer` properties.
 
 It is unsafe to use `fs.write()` multiple times on the same file without waiting
 for the callback. For this scenario, [`fs.createWriteStream()`][] is
@@ -4199,10 +3812,18 @@ On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
 the end of the file.
 
-## `fs.write(fd, string[, position[, encoding]], callback)`
+### `fs.write(fd, string[, position[, encoding]], callback)`
 <!-- YAML
 added: v0.11.5
 changes:
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `string` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `string` parameter won't coerce unsupported input to
+                 strings anymore.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -4217,7 +3838,7 @@ changes:
 -->
 
 * `fd` {integer}
-* `string` {string}
+* `string` {string|Object}
 * `position` {integer}
 * `encoding` {string} **Default:** `'utf8'`
 * `callback` {Function}
@@ -4225,8 +3846,8 @@ changes:
   * `written` {integer}
   * `string` {string}
 
-Write `string` to the file specified by `fd`. If `string` is not a string, then
-the value will be coerced to one.
+Write `string` to the file specified by `fd`. If `string` is not a string, or an
+object with an own `toString` function property, then an exception is thrown.
 
 `position` refers to the offset from the beginning of the file where this data
 should be written. If `typeof position !== 'number'` the data will be written at
@@ -4254,10 +3875,22 @@ It is possible to configure the console to render UTF-8 properly by changing the
 active codepage with the `chcp 65001` command. See the [chcp][] docs for more
 details.
 
-## `fs.writeFile(file, data[, options], callback)`
+### `fs.writeFile(file, data[, options], callback)`
 <!-- YAML
 added: v0.1.29
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/35993
+    description: The options argument may include an AbortSignal to abort an
+                 ongoing writeFile request.
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `data` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `data` parameter won't coerce unsupported input to
+                 strings anymore.
   - version: v10.10.0
     pr-url: https://github.com/nodejs/node/pull/22150
     description: The `data` parameter can now be any `TypedArray` or a
@@ -4279,16 +3912,17 @@ changes:
 -->
 
 * `file` {string|Buffer|URL|integer} filename or file descriptor
-* `data` {string|Buffer|TypedArray|DataView}
+* `data` {string|Buffer|TypedArray|DataView|Object}
 * `options` {Object|string}
   * `encoding` {string|null} **Default:** `'utf8'`
   * `mode` {integer} **Default:** `0o666`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
+  * `signal` {AbortSignal} allows aborting an in-progress writeFile
 * `callback` {Function}
   * `err` {Error}
 
 When `file` is a filename, asynchronously writes data to the file, replacing the
-file if it already exists.  `data` can be a string or a buffer.
+file if it already exists. `data` can be a string or a buffer.
 
 When `file` is a file descriptor, the behavior is similar to calling
 `fs.write()` directly (which is recommended). See the notes below on using
@@ -4296,9 +3930,17 @@ a file descriptor.
 
 The `encoding` option is ignored if `data` is a buffer.
 
-```js
+The `mode` option only affects the newly created file. See [`fs.open()`][]
+for more details.
+
+If `data` is a plain object, it must have an own (not inherited) `toString`
+function property.
+
+```mjs
+import { writeFile } from 'fs';
+
 const data = new Uint8Array(Buffer.from('Hello Node.js'));
-fs.writeFile('message.txt', data, (err) => {
+writeFile('message.txt', data, (err) => {
   if (err) throw err;
   console.log('The file has been saved!');
 });
@@ -4306,26 +3948,54 @@ fs.writeFile('message.txt', data, (err) => {
 
 If `options` is a string, then it specifies the encoding:
 
-```js
-fs.writeFile('message.txt', 'Hello Node.js', 'utf8', callback);
+```mjs
+import { writeFile } from 'fs';
+
+writeFile('message.txt', 'Hello Node.js', 'utf8', callback);
 ```
 
 It is unsafe to use `fs.writeFile()` multiple times on the same file without
 waiting for the callback. For this scenario, [`fs.createWriteStream()`][] is
 recommended.
 
-### Using `fs.writeFile()` with file descriptors
+Similarly to `fs.readFile` - `fs.writeFile` is a convenience method that
+performs multiple `write` calls internally to write the buffer passed to it.
+For performance sensitive code consider using [`fs.createWriteStream()`][].
+
+It is possible to use an {AbortSignal} to cancel an `fs.writeFile()`.
+Cancelation is "best effort", and some amount of data is likely still
+to be written.
+
+```mjs
+import { writeFile } from 'fs';
+
+const controller = new AbortController();
+const { signal } = controller;
+const data = new Uint8Array(Buffer.from('Hello Node.js'));
+writeFile('message.txt', data, { signal }, (err) => {
+  // When a request is aborted - the callback is called with an AbortError
+});
+// When the request should be aborted
+controller.abort();
+```
+
+Aborting an ongoing request does not abort individual operating
+system requests but rather the internal buffering `fs.writeFile` performs.
+
+#### Using `fs.writeFile()` with file descriptors
 
 When `file` is a file descriptor, the behavior is almost identical to directly
 calling `fs.write()` like:
 
-```js
-fs.write(fd, Buffer.from(data, options.encoding), callback);
+```mjs
+import { write } from 'fs';
+
+write(fd, Buffer.from(data, options.encoding), callback);
 ```
 
 The difference from directly calling `fs.write()` is that under some unusual
-conditions, `fs.write()` may write only part of the buffer and will need to be
-retried to write the remaining data, whereas `fs.writeFile()` will retry until
+conditions, `fs.write()` might write only part of the buffer and need to be
+retried to write the remaining data, whereas `fs.writeFile()` retries until
 the data is entirely written (or an error occurs).
 
 The implications of this are a common source of confusion. In
@@ -4340,90 +4010,18 @@ on the size of the original file, and the position of the file descriptor). If
 a file name had been used instead of a descriptor, the file would be guaranteed
 to contain only `', World'`.
 
-## `fs.writeFileSync(file, data[, options])`
+### `fs.writev(fd, buffers[, position], callback)`
 <!-- YAML
-added: v0.1.29
-changes:
-  - version: v10.10.0
-    pr-url: https://github.com/nodejs/node/pull/22150
-    description: The `data` parameter can now be any `TypedArray` or a
-                 `DataView`.
-  - version: v7.4.0
-    pr-url: https://github.com/nodejs/node/pull/10382
-    description: The `data` parameter can now be a `Uint8Array`.
-  - version: v5.0.0
-    pr-url: https://github.com/nodejs/node/pull/3163
-    description: The `file` parameter can be a file descriptor now.
+added: v12.9.0
 -->
 
-* `file` {string|Buffer|URL|integer} filename or file descriptor
-* `data` {string|Buffer|TypedArray|DataView}
-* `options` {Object|string}
-  * `encoding` {string|null} **Default:** `'utf8'`
-  * `mode` {integer} **Default:** `0o666`
-  * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
-
-Returns `undefined`.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.writeFile()`][].
-
-## `fs.writeSync(fd, buffer[, offset[, length[, position]]])`
-<!-- YAML
-added: v0.1.21
-changes:
-  - version: v10.10.0
-    pr-url: https://github.com/nodejs/node/pull/22150
-    description: The `buffer` parameter can now be any `TypedArray` or a
-                 `DataView`.
-  - version: v7.4.0
-    pr-url: https://github.com/nodejs/node/pull/10382
-    description: The `buffer` parameter can now be a `Uint8Array`.
-  - version: v7.2.0
-    pr-url: https://github.com/nodejs/node/pull/7856
-    description: The `offset` and `length` parameters are optional now.
--->
-
-* `fd` {integer}
-* `buffer` {Buffer|TypedArray|DataView}
-* `offset` {integer}
-* `length` {integer}
-* `position` {integer}
-* Returns: {number} The number of bytes written.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.write(fd, buffer...)`][].
-
-## `fs.writeSync(fd, string[, position[, encoding]])`
-<!-- YAML
-added: v0.11.5
-changes:
-  - version: v7.2.0
-    pr-url: https://github.com/nodejs/node/pull/7856
-    description: The `position` parameter is optional now.
--->
-
-* `fd` {integer}
-* `string` {string}
-* `position` {integer}
-* `encoding` {string}
-* Returns: {number} The number of bytes written.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.write(fd, string...)`][].
-
-## `fs.writev(fd, buffers[, position], callback)`
-<!-- YAML
-added: v12.9.0
--->
-
-* `fd` {integer}
-* `buffers` {ArrayBufferView[]}
-* `position` {integer}
-* `callback` {Function}
-  * `err` {Error}
-  * `bytesWritten` {integer}
-  * `buffers` {ArrayBufferView[]}
+* `fd` {integer}
+* `buffers` {ArrayBufferView[]}
+* `position` {integer}
+* `callback` {Function}
+  * `err` {Error}
+  * `bytesWritten` {integer}
+  * `buffers` {ArrayBufferView[]}
 
 Write an array of `ArrayBufferView`s to the file specified by `fd` using
 `writev()`.
@@ -4435,7 +4033,7 @@ at the current position.
 The callback will be given three arguments: `err`, `bytesWritten`, and
 `buffers`. `bytesWritten` is how many bytes were written from `buffers`.
 
-If this method is [`util.promisify()`][]ed, it returns a `Promise` for an
+If this method is [`util.promisify()`][]ed, it returns a promise for an
 `Object` with `bytesWritten` and `buffers` properties.
 
 It is unsafe to use `fs.writev()` multiple times on the same file without
@@ -4445,215 +4043,272 @@ On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
 the end of the file.
 
-## `fs.writevSync(fd, buffers[, position])`
-<!-- YAML
-added: v12.9.0
--->
-
-* `fd` {integer}
-* `buffers` {ArrayBufferView[]}
-* `position` {integer}
-* Returns: {number} The number of bytes written.
-
-For detailed information, see the documentation of the asynchronous version of
-this API: [`fs.writev()`][].
-
-## `fs` Promises API
+## Synchronous API
 
-The `fs.promises` API provides an alternative set of asynchronous file system
-methods that return `Promise` objects rather than using callbacks. The
-API is accessible via `require('fs').promises`.
+The synchronous APIs perform all operations synchronously, blocking the
+event loop until the operation completes or fails.
 
-### Class: `FileHandle`
+### `fs.accessSync(path[, mode])`
 <!-- YAML
-added: v10.0.0
+added: v0.11.15
+changes:
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
 -->
 
-A `FileHandle` object is a wrapper for a numeric file descriptor.
-Instances of `FileHandle` are distinct from numeric file descriptors
-in that they provide an object oriented API for working with files.
+* `path` {string|Buffer|URL}
+* `mode` {integer} **Default:** `fs.constants.F_OK`
+
+Synchronously tests a user's permissions for the file or directory specified
+by `path`. The `mode` argument is an optional integer that specifies the
+accessibility checks to be performed. Check [File access constants][] for
+possible values of `mode`. It is possible to create a mask consisting of
+the bitwise OR of two or more values
+(e.g. `fs.constants.W_OK | fs.constants.R_OK`).
 
-If a `FileHandle` is not closed using the
-`filehandle.close()` method, it might automatically close the file descriptor
-and will emit a process warning, thereby helping to prevent memory leaks.
-Please do not rely on this behavior because it is unreliable and
-the file may not be closed. Instead, always explicitly close `FileHandle`s.
-Node.js may change this behavior in the future.
+If any of the accessibility checks fail, an `Error` will be thrown. Otherwise,
+the method will return `undefined`.
 
-Instances of the `FileHandle` object are created internally by the
-`fsPromises.open()` method.
+```mjs
+import { accessSync, constants } from 'fs';
 
-Unlike the callback-based API (`fs.fstat()`, `fs.fchown()`, `fs.fchmod()`, and
-so on), a numeric file descriptor is not used by the promise-based API. Instead,
-the promise-based API uses the `FileHandle` class in order to help avoid
-accidental leaking of unclosed file descriptors after a `Promise` is resolved or
-rejected.
+try {
+  accessSync('etc/passwd', constants.R_OK | constants.W_OK);
+  console.log('can read/write');
+} catch (err) {
+  console.error('no access!');
+}
+```
 
-#### `filehandle.appendFile(data, options)`
+### `fs.appendFileSync(path, data[, options])`
 <!-- YAML
-added: v10.0.0
+added: v0.6.7
+changes:
+  - version: v7.0.0
+    pr-url: https://github.com/nodejs/node/pull/7831
+    description: The passed `options` object will never be modified.
+  - version: v5.0.0
+    pr-url: https://github.com/nodejs/node/pull/3163
+    description: The `file` parameter can be a file descriptor now.
 -->
 
+* `path` {string|Buffer|URL|number} filename or file descriptor
 * `data` {string|Buffer}
 * `options` {Object|string}
   * `encoding` {string|null} **Default:** `'utf8'`
-* Returns: {Promise}
-
-Alias of [`filehandle.writeFile()`][].
+  * `mode` {integer} **Default:** `0o666`
+  * `flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.
 
-When operating on file handles, the mode cannot be changed from what it was set
-to with [`fsPromises.open()`][]. Therefore, this is equivalent to
-[`filehandle.writeFile()`][].
+Synchronously append data to a file, creating the file if it does not yet
+exist. `data` can be a string or a {Buffer}.
 
-#### `filehandle.chmod(mode)`
-<!-- YAML
-added: v10.0.0
--->
+The `mode` option only affects the newly created file. See [`fs.open()`][]
+for more details.
 
-* `mode` {integer}
-* Returns: {Promise}
+```mjs
+import { appendFileSync } from 'fs';
 
-Modifies the permissions on the file. The `Promise` is resolved with no
-arguments upon success.
+try {
+  appendFileSync('message.txt', 'data to append');
+  console.log('The "data to append" was appended to file!');
+} catch (err) {
+  /* Handle the error */
+}
+```
 
-#### `filehandle.chown(uid, gid)`
-<!-- YAML
-added: v10.0.0
--->
+If `options` is a string, then it specifies the encoding:
 
-* `uid` {integer}
-* `gid` {integer}
-* Returns: {Promise}
+```mjs
+import { appendFileSync } from 'fs';
 
-Changes the ownership of the file then resolves the `Promise` with no arguments
-upon success.
+appendFileSync('message.txt', 'data to append', 'utf8');
+```
 
-#### `filehandle.close()`
-<!-- YAML
-added: v10.0.0
--->
+The `path` may be specified as a numeric file descriptor that has been opened
+for appending (using `fs.open()` or `fs.openSync()`). The file descriptor will
+not be closed automatically.
 
-* Returns: {Promise} A `Promise` that will be resolved once the underlying
-  file descriptor is closed, or will be rejected if an error occurs while
-  closing.
+```mjs
+import { openSync, closeSync, appendFileSync } from 'fs';
 
-Closes the file descriptor.
+let fd;
 
-```js
-const fsPromises = require('fs').promises;
-async function openAndClose() {
-  let filehandle;
-  try {
-    filehandle = await fsPromises.open('thefile.txt', 'r');
-  } finally {
-    if (filehandle !== undefined)
-      await filehandle.close();
-  }
+try {
+  fd = openSync('message.txt', 'a');
+  appendFileSync(fd, 'data to append', 'utf8');
+} catch (err) {
+  /* Handle the error */
+} finally {
+  if (fd !== undefined)
+    closeSync(fd);
 }
 ```
 
-#### `filehandle.datasync()`
+### `fs.chmodSync(path, mode)`
 <!-- YAML
-added: v10.0.0
+added: v0.6.7
+changes:
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
 -->
 
-* Returns: {Promise}
+* `path` {string|Buffer|URL}
+* `mode` {string|integer}
 
-Asynchronous fdatasync(2). The `Promise` is resolved with no arguments upon
-success.
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.chmod()`][].
 
-#### `filehandle.fd`
+See the POSIX chmod(2) documentation for more detail.
+
+### `fs.chownSync(path, uid, gid)`
 <!-- YAML
-added: v10.0.0
+added: v0.1.97
+changes:
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
 -->
 
-* {number} The numeric file descriptor managed by the `FileHandle` object.
+* `path` {string|Buffer|URL}
+* `uid` {integer}
+* `gid` {integer}
 
-#### `filehandle.read(buffer, offset, length, position)`
+Synchronously changes owner and group of a file. Returns `undefined`.
+This is the synchronous version of [`fs.chown()`][].
+
+See the POSIX chown(2) documentation for more detail.
+
+### `fs.closeSync(fd)`
 <!-- YAML
-added: v10.0.0
+added: v0.1.21
 -->
 
-* `buffer` {Buffer|Uint8Array}
-* `offset` {integer}
-* `length` {integer}
-* `position` {integer}
-* Returns: {Promise}
+* `fd` {integer}
+
+Closes the file descriptor. Returns `undefined`.
+
+Calling `fs.closeSync()` on any file descriptor (`fd`) that is currently in use
+through any other `fs` operation may lead to undefined behavior.
+
+See the POSIX close(2) documentation for more detail.
+
+### `fs.copyFileSync(src, dest[, mode])`
+<!-- YAML
+added: v8.5.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/27044
+    description: Changed 'flags' argument to 'mode' and imposed
+                 stricter type validation.
+-->
 
-Read data from the file.
+* `src` {string|Buffer|URL} source filename to copy
+* `dest` {string|Buffer|URL} destination filename of the copy operation
+* `mode` {integer} modifiers for copy operation. **Default:** `0`.
 
-`buffer` is the buffer that the data will be written to.
+Synchronously copies `src` to `dest`. By default, `dest` is overwritten if it
+already exists. Returns `undefined`. Node.js makes no guarantees about the
+atomicity of the copy operation. If an error occurs after the destination file
+has been opened for writing, Node.js will attempt to remove the destination.
 
-`offset` is the offset in the buffer to start writing at.
+`mode` is an optional integer that specifies the behavior
+of the copy operation. It is possible to create a mask consisting of the bitwise
+OR of two or more values (e.g.
+`fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`).
 
-`length` is an integer specifying the number of bytes to read.
+* `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already
+  exists.
+* `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a
+  copy-on-write reflink. If the platform does not support copy-on-write, then a
+  fallback copy mechanism is used.
+* `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to
+  create a copy-on-write reflink. If the platform does not support
+  copy-on-write, then the operation will fail.
 
-`position` is an argument specifying where to begin reading from in the file.
-If `position` is `null`, data will be read from the current file position,
-and the file position will be updated.
-If `position` is an integer, the file position will remain unchanged.
+```mjs
+import { copyFileSync, constants } from 'fs';
 
-Following successful read, the `Promise` is resolved with an object with a
-`bytesRead` property specifying the number of bytes read, and a `buffer`
-property that is a reference to the passed in `buffer` argument.
+// destination.txt will be created or overwritten by default.
+copyFileSync('source.txt', 'destination.txt');
+console.log('source.txt was copied to destination.txt');
 
-#### `filehandle.read(options)`
-<!-- YAML
-added: v12.17.0
--->
-* `options` {Object}
-  * `buffer` {Buffer|Uint8Array} **Default:** `Buffer.alloc(16384)`
-  * `offset` {integer} **Default:** `0`
-  * `length` {integer} **Default:** `buffer.length`
-  * `position` {integer} **Default:** `null`
-* Returns: {Promise}
+// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
+copyFileSync('source.txt', 'destination.txt', constants.COPYFILE_EXCL);
+```
 
-#### `filehandle.readFile(options)`
+### `fs.existsSync(path)`
 <!-- YAML
-added: v10.0.0
+added: v0.1.21
+changes:
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using
+                 `file:` protocol.
 -->
 
-* `options` {Object|string}
-  * `encoding` {string|null} **Default:** `null`
-* Returns: {Promise}
+* `path` {string|Buffer|URL}
+* Returns: {boolean}
 
-Asynchronously reads the entire contents of a file.
+Returns `true` if the path exists, `false` otherwise.
 
-The `Promise` is resolved with the contents of the file. If no encoding is
-specified (using `options.encoding`), the data is returned as a `Buffer`
-object. Otherwise, the data will be a string.
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.exists()`][].
 
-If `options` is a string, then it specifies the encoding.
+`fs.exists()` is deprecated, but `fs.existsSync()` is not. The `callback`
+parameter to `fs.exists()` accepts parameters that are inconsistent with other
+Node.js callbacks. `fs.existsSync()` does not use a callback.
 
-The `FileHandle` has to support reading.
+```mjs
+import { existsSync } from 'fs';
 
-If one or more `filehandle.read()` calls are made on a file handle and then a
-`filehandle.readFile()` call is made, the data will be read from the current
-position till the end of the file. It doesn't always read from the beginning
-of the file.
+if (existsSync('/etc/passwd'))
+  console.log('The path exists.');
+```
 
-#### `filehandle.readv(buffers[, position])`
+### `fs.fchmodSync(fd, mode)`
 <!-- YAML
-added: v12.17.0
+added: v0.4.7
 -->
 
-* `buffers` {ArrayBufferView[]}
-* `position` {integer}
-* Returns: {Promise}
+* `fd` {integer}
+* `mode` {string|integer}
 
-Read from a file and write to an array of `ArrayBufferView`s
+Sets the permissions on the file. Returns `undefined`.
 
-The `Promise` is resolved with an object containing a `bytesRead` property
-identifying the number of bytes read, and a `buffers` property containing
-a reference to the `buffers` input.
+See the POSIX fchmod(2) documentation for more detail.
 
-`position` is the offset from the beginning of the file where this data
-should be read from. If `typeof position !== 'number'`, the data will be read
-from the current position.
+### `fs.fchownSync(fd, uid, gid)`
+<!-- YAML
+added: v0.4.7
+-->
 
-#### `filehandle.stat([options])`
+* `fd` {integer}
+* `uid` {integer} The file's new owner's user id.
+* `gid` {integer} The file's new group's group id.
+
+Sets the owner of the file. Returns `undefined`.
+
+See the POSIX fchown(2) documentation for more detail.
+
+### `fs.fdatasyncSync(fd)`
 <!-- YAML
-added: v10.0.0
+added: v0.1.96
+-->
+
+* `fd` {integer}
+
+Forces all currently queued I/O operations associated with the file to the
+operating system's synchronized I/O completion state. Refer to the POSIX
+fdatasync(2) documentation for details. Returns `undefined`.
+
+### `fs.fstatSync(fd[, options])`
+<!-- YAML
+added: v0.1.95
 changes:
   - version: v10.5.0
     pr-url: https://github.com/nodejs/node/pull/20220
@@ -4661,822 +4316,1690 @@ changes:
                  the numeric values returned should be bigint.
 -->
 
+* `fd` {integer}
 * `options` {Object}
   * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
-* Returns: {Promise}
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
+* Returns: {fs.Stats}
 
-Retrieves the [`fs.Stats`][] for the file.
+Retrieves the {fs.Stats} for the file descriptor.
 
-#### `filehandle.sync()`
+See the POSIX fstat(2) documentation for more detail.
+
+### `fs.fsyncSync(fd)`
 <!-- YAML
-added: v10.0.0
+added: v0.1.96
 -->
 
-* Returns: {Promise}
+* `fd` {integer}
 
-Asynchronous fsync(2). The `Promise` is resolved with no arguments upon
-success.
+Request that all data for the open file descriptor is flushed to the storage
+device. The specific implementation is operating system and device specific.
+Refer to the POSIX fsync(2) documentation for more detail. Returns `undefined`.
 
-#### `filehandle.truncate(len)`
+### `fs.ftruncateSync(fd[, len])`
 <!-- YAML
-added: v10.0.0
+added: v0.8.6
 -->
 
+* `fd` {integer}
 * `len` {integer} **Default:** `0`
-* Returns: {Promise}
 
-Truncates the file then resolves the `Promise` with no arguments upon success.
+Truncates the file descriptor. Returns `undefined`.
 
-If the file was larger than `len` bytes, only the first `len` bytes will be
-retained in the file.
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.ftruncate()`][].
 
-For example, the following program retains only the first four bytes of the
-file:
+### `fs.futimesSync(fd, atime, mtime)`
+<!-- YAML
+added: v0.4.2
+changes:
+  - version: v4.1.0
+    pr-url: https://github.com/nodejs/node/pull/2387
+    description: Numeric strings, `NaN` and `Infinity` are now allowed
+                 time specifiers.
+-->
 
-```js
-const fs = require('fs');
-const fsPromises = fs.promises;
+* `fd` {integer}
+* `atime` {number|string|Date}
+* `mtime` {number|string|Date}
 
-console.log(fs.readFileSync('temp.txt', 'utf8'));
-// Prints: Node.js
+Synchronous version of [`fs.futimes()`][]. Returns `undefined`.
 
-async function doTruncate() {
-  let filehandle = null;
-  try {
-    filehandle = await fsPromises.open('temp.txt', 'r+');
-    await filehandle.truncate(4);
-  } finally {
-    if (filehandle) {
-      // Close the file if it is opened.
-      await filehandle.close();
-    }
-  }
-  console.log(fs.readFileSync('temp.txt', 'utf8'));  // Prints: Node
-}
+### `fs.lchmodSync(path, mode)`
+<!-- YAML
+deprecated: v0.4.7
+-->
 
-doTruncate().catch(console.error);
-```
+* `path` {string|Buffer|URL}
+* `mode` {integer}
 
-If the file previously was shorter than `len` bytes, it is extended, and the
-extended part is filled with null bytes (`'\0'`):
+Changes the permissions on a symbolic link. Returns `undefined`.
 
-```js
-const fs = require('fs');
-const fsPromises = fs.promises;
+This method is only implemented on macOS.
 
-console.log(fs.readFileSync('temp.txt', 'utf8'));
-// Prints: Node.js
+See the POSIX lchmod(2) documentation for more detail.
 
-async function doTruncate() {
-  let filehandle = null;
-  try {
-    filehandle = await fsPromises.open('temp.txt', 'r+');
-    await filehandle.truncate(10);
-  } finally {
-    if (filehandle) {
-      // Close the file if it is opened.
-      await filehandle.close();
-    }
-  }
-  console.log(fs.readFileSync('temp.txt', 'utf8'));  // Prints Node.js\0\0\0
-}
+### `fs.lchownSync(path, uid, gid)`
+<!-- YAML
+changes:
+  - version: v10.6.0
+    pr-url: https://github.com/nodejs/node/pull/21498
+    description: This API is no longer deprecated.
+  - version: v0.4.7
+    description: Documentation-only deprecation.
+-->
 
-doTruncate().catch(console.error);
-```
+* `path` {string|Buffer|URL}
+* `uid` {integer} The file's new owner's user id.
+* `gid` {integer} The file's new group's group id.
 
-The last three bytes are null bytes (`'\0'`), to compensate the over-truncation.
+Set the owner for the path. Returns `undefined`.
 
-#### `filehandle.utimes(atime, mtime)`
+See the POSIX lchown(2) documentation for more details.
+
+### `fs.lutimesSync(path, atime, mtime)`
 <!-- YAML
-added: v10.0.0
+added:
+  - v14.5.0
+  - v12.19.0
 -->
 
+* `path` {string|Buffer|URL}
 * `atime` {number|string|Date}
 * `mtime` {number|string|Date}
-* Returns: {Promise}
 
-Change the file system timestamps of the object referenced by the `FileHandle`
-then resolves the `Promise` with no arguments upon success.
-
-This function does not work on AIX versions before 7.1, it will resolve the
-`Promise` with an error using code `UV_ENOSYS`.
+Change the file system timestamps of the symbolic link referenced by `path`.
+Returns `undefined`, or throws an exception when parameters are incorrect or
+the operation fails. This is the synchronous version of [`fs.lutimes()`][].
 
-#### `filehandle.write(buffer[, offset[, length[, position]]])`
+### `fs.linkSync(existingPath, newPath)`
 <!-- YAML
-added: v10.0.0
+added: v0.1.31
+changes:
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `existingPath` and `newPath` parameters can be WHATWG
+                 `URL` objects using `file:` protocol. Support is currently
+                 still *experimental*.
 -->
 
-* `buffer` {Buffer|Uint8Array}
-* `offset` {integer}
-* `length` {integer}
-* `position` {integer}
-* Returns: {Promise}
-
-Write `buffer` to the file.
+* `existingPath` {string|Buffer|URL}
+* `newPath` {string|Buffer|URL}
 
-The `Promise` is resolved with an object containing a `bytesWritten` property
-identifying the number of bytes written, and a `buffer` property containing
-a reference to the `buffer` written.
+Creates a new link from the `existingPath` to the `newPath`. See the POSIX
+link(2) documentation for more detail. Returns `undefined`.
 
-`offset` determines the part of the buffer to be written, and `length` is
-an integer specifying the number of bytes to write.
+### `fs.lstatSync(path[, options])`
+<!-- YAML
+added: v0.1.30
+changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/33716
+    description: Accepts a `throwIfNoEntry` option to specify whether
+                 an exception should be thrown if the entry does not exist.
+  - version: v10.5.0
+    pr-url: https://github.com/nodejs/node/pull/20220
+    description: Accepts an additional `options` object to specify whether
+                 the numeric values returned should be bigint.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
+-->
 
-`position` refers to the offset from the beginning of the file where this data
-should be written. If `typeof position !== 'number'`, the data will be written
-at the current position. See pwrite(2).
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `bigint` {boolean} Whether the numeric values in the returned
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
+  * `throwIfNoEntry` {boolean} Whether an exception will be thrown
+    if no file system entry exists, rather than returning `undefined`.
+    **Default:** `true`.
+* Returns: {fs.Stats}
 
-It is unsafe to use `filehandle.write()` multiple times on the same file
-without waiting for the `Promise` to be resolved (or rejected). For this
-scenario, use [`fs.createWriteStream()`][].
+Retrieves the {fs.Stats} for the symbolic link referred to by `path`.
 
-On Linux, positional writes do not work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.
+See the POSIX lstat(2) documentation for more details.
 
-#### `filehandle.write(string[, position[, encoding]])`
+### `fs.mkdirSync(path[, options])`
 <!-- YAML
-added: v10.0.0
+added: v0.1.21
+changes:
+  - version:
+     - v13.11.0
+     - v12.17.0
+    pr-url: https://github.com/nodejs/node/pull/31530
+    description: In `recursive` mode, the first created path is returned now.
+  - version: v10.12.0
+    pr-url: https://github.com/nodejs/node/pull/21875
+    description: The second argument can now be an `options` object with
+                 `recursive` and `mode` properties.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
 -->
 
-* `string` {string}
-* `position` {integer}
-* `encoding` {string} **Default:** `'utf8'`
-* Returns: {Promise}
+* `path` {string|Buffer|URL}
+* `options` {Object|integer}
+  * `recursive` {boolean} **Default:** `false`
+  * `mode` {string|integer} Not supported on Windows. **Default:** `0o777`.
+* Returns: {string|undefined}
 
-Write `string` to the file. If `string` is not a string, then
-the value will be coerced to one.
+Synchronously creates a directory. Returns `undefined`, or if `recursive` is
+`true`, the first directory path created.
+This is the synchronous version of [`fs.mkdir()`][].
 
-The `Promise` is resolved with an object containing a `bytesWritten` property
-identifying the number of bytes written, and a `buffer` property containing
-a reference to the `string` written.
+See the POSIX mkdir(2) documentation for more details.
 
-`position` refers to the offset from the beginning of the file where this data
-should be written. If the type of `position` is not a `number` the data
-will be written at the current position. See pwrite(2).
+### `fs.mkdtempSync(prefix[, options])`
+<!-- YAML
+added: v5.10.0
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/39028
+    description: The `prefix` parameter now accepts an empty string.
+-->
 
-`encoding` is the expected string encoding.
+* `prefix` {string}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+* Returns: {string}
 
-It is unsafe to use `filehandle.write()` multiple times on the same file
-without waiting for the `Promise` to be resolved (or rejected). For this
-scenario, use [`fs.createWriteStream()`][].
+Returns the created directory path.
 
-On Linux, positional writes do not work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.mkdtemp()`][].
 
-#### `filehandle.writeFile(data, options)`
+The optional `options` argument can be a string specifying an encoding, or an
+object with an `encoding` property specifying the character encoding to use.
+
+### `fs.opendirSync(path[, options])`
 <!-- YAML
-added: v10.0.0
+added: v12.12.0
+changes:
+  - version:
+     - v13.1.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/30114
+    description: The `bufferSize` option was introduced.
 -->
 
-* `data` {string|Buffer|Uint8Array}
-* `options` {Object|string}
+* `path` {string|Buffer|URL}
+* `options` {Object}
   * `encoding` {string|null} **Default:** `'utf8'`
-* Returns: {Promise}
+  * `bufferSize` {number} Number of directory entries that are buffered
+    internally when reading from the directory. Higher values lead to better
+    performance but higher memory usage. **Default:** `32`
+* Returns: {fs.Dir}
 
-Asynchronously writes data to a file, replacing the file if it already exists.
-`data` can be a string or a buffer. The `Promise` will be resolved with no
-arguments upon success.
+Synchronously open a directory. See opendir(3).
 
-The `encoding` option is ignored if `data` is a buffer.
+Creates an {fs.Dir}, which contains all further functions for reading from
+and cleaning up the directory.
 
-If `options` is a string, then it specifies the encoding.
+The `encoding` option sets the encoding for the `path` while opening the
+directory and subsequent read operations.
 
-The `FileHandle` has to support writing.
+### `fs.openSync(path[, flags[, mode]])`
+<!-- YAML
+added: v0.1.21
+changes:
+  - version: v11.1.0
+    pr-url: https://github.com/nodejs/node/pull/23767
+    description: The `flags` argument is now optional and defaults to `'r'`.
+  - version: v9.9.0
+    pr-url: https://github.com/nodejs/node/pull/18801
+    description: The `as` and `as+` flags are supported now.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
+-->
 
-It is unsafe to use `filehandle.writeFile()` multiple times on the same file
-without waiting for the `Promise` to be resolved (or rejected).
+* `path` {string|Buffer|URL}
+* `flags` {string|number} **Default:** `'r'`.
+   See [support of file system `flags`][].
+* `mode` {string|integer} **Default:** `0o666`
+* Returns: {number}
 
-If one or more `filehandle.write()` calls are made on a file handle and then a
-`filehandle.writeFile()` call is made, the data will be written from the
-current position till the end of the file. It doesn't always write from the
-beginning of the file.
+Returns an integer representing the file descriptor.
 
-#### `filehandle.writev(buffers[, position])`
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.open()`][].
+
+### `fs.readdirSync(path[, options])`
 <!-- YAML
-added: v12.9.0
+added: v0.1.21
+changes:
+  - version: v10.10.0
+    pr-url: https://github.com/nodejs/node/pull/22020
+    description: New option `withFileTypes` was added.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
 -->
 
-* `buffers` {ArrayBufferView[]}
-* `position` {integer}
-* Returns: {Promise}
-
-Write an array of `ArrayBufferView`s to the file.
+* `path` {string|Buffer|URL}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+  * `withFileTypes` {boolean} **Default:** `false`
+* Returns: {string[]|Buffer[]|fs.Dirent[]}
 
-The `Promise` is resolved with an object containing a `bytesWritten` property
-identifying the number of bytes written, and a `buffers` property containing
-a reference to the `buffers` input.
+Reads the contents of the directory.
 
-`position` is the offset from the beginning of the file where this data
-should be written. If `typeof position !== 'number'`, the data will be written
-at the current position.
+See the POSIX readdir(3) documentation for more details.
 
-It is unsafe to call `writev()` multiple times on the same file without waiting
-for the previous operation to complete.
+The optional `options` argument can be a string specifying an encoding, or an
+object with an `encoding` property specifying the character encoding to use for
+the filenames returned. If the `encoding` is set to `'buffer'`,
+the filenames returned will be passed as {Buffer} objects.
 
-On Linux, positional writes don't work when the file is opened in append mode.
-The kernel ignores the position argument and always appends the data to
-the end of the file.
+If `options.withFileTypes` is set to `true`, the result will contain
+{fs.Dirent} objects.
 
-### `fsPromises.access(path[, mode])`
+### `fs.readFileSync(path[, options])`
 <!-- YAML
-added: v10.0.0
+added: v0.1.8
+changes:
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
+  - version: v5.0.0
+    pr-url: https://github.com/nodejs/node/pull/3163
+    description: The `path` parameter can be a file descriptor now.
 -->
 
-* `path` {string|Buffer|URL}
-* `mode` {integer} **Default:** `fs.constants.F_OK`
-* Returns: {Promise}
-
-Tests a user's permissions for the file or directory specified by `path`.
-The `mode` argument is an optional integer that specifies the accessibility
-checks to be performed. Check [File access constants][] for possible values
-of `mode`. It is possible to create a mask consisting of the bitwise OR of
-two or more values (e.g. `fs.constants.W_OK | fs.constants.R_OK`).
-
-If the accessibility check is successful, the `Promise` is resolved with no
-value. If any of the accessibility checks fail, the `Promise` is rejected
-with an `Error` object. The following example checks if the file
-`/etc/passwd` can be read and written by the current process.
-
-```js
-const fs = require('fs');
-const fsPromises = fs.promises;
+* `path` {string|Buffer|URL|integer} filename or file descriptor
+* `options` {Object|string}
+  * `encoding` {string|null} **Default:** `null`
+  * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
+* Returns: {string|Buffer}
 
-fsPromises.access('/etc/passwd', fs.constants.R_OK | fs.constants.W_OK)
-  .then(() => console.log('can access'))
-  .catch(() => console.error('cannot access'));
-```
+Returns the contents of the `path`.
 
-Using `fsPromises.access()` to check for the accessibility of a file before
-calling `fsPromises.open()` is not recommended. Doing so introduces a race
-condition, since other processes may change the file's state between the two
-calls. Instead, user code should open/read/write the file directly and handle
-the error raised if the file is not accessible.
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.readFile()`][].
 
-### `fsPromises.appendFile(path, data[, options])`
-<!-- YAML
-added: v10.0.0
--->
+If the `encoding` option is specified then this function returns a
+string. Otherwise it returns a buffer.
 
-* `path` {string|Buffer|URL|FileHandle} filename or `FileHandle`
-* `data` {string|Buffer}
-* `options` {Object|string}
-  * `encoding` {string|null} **Default:** `'utf8'`
-  * `mode` {integer} **Default:** `0o666`
-  * `flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.
-* Returns: {Promise}
+Similar to [`fs.readFile()`][], when the path is a directory, the behavior of
+`fs.readFileSync()` is platform-specific.
 
-Asynchronously append data to a file, creating the file if it does not yet
-exist. `data` can be a string or a [`Buffer`][]. The `Promise` will be
-resolved with no arguments upon success.
+```mjs
+import { readFileSync } from 'fs';
 
-If `options` is a string, then it specifies the encoding.
+// macOS, Linux, and Windows
+readFileSync('<directory>');
+// => [Error: EISDIR: illegal operation on a directory, read <directory>]
 
-The `path` may be specified as a `FileHandle` that has been opened
-for appending (using `fsPromises.open()`).
+//  FreeBSD
+readFileSync('<directory>'); // => <data>
+```
 
-### `fsPromises.chmod(path, mode)`
+### `fs.readlinkSync(path[, options])`
 <!-- YAML
-added: v10.0.0
+added: v0.1.31
+changes:
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
 -->
 
 * `path` {string|Buffer|URL}
-* `mode` {string|integer}
-* Returns: {Promise}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+* Returns: {string|Buffer}
 
-Changes the permissions of a file then resolves the `Promise` with no
-arguments upon succces.
+Returns the symbolic link's string value.
 
-### `fsPromises.chown(path, uid, gid)`
+See the POSIX readlink(2) documentation for more details.
+
+The optional `options` argument can be a string specifying an encoding, or an
+object with an `encoding` property specifying the character encoding to use for
+the link path returned. If the `encoding` is set to `'buffer'`,
+the link path returned will be passed as a {Buffer} object.
+
+### `fs.readSync(fd, buffer, offset, length, position)`
 <!-- YAML
-added: v10.0.0
+added: v0.1.21
+changes:
+  - version: v10.10.0
+    pr-url: https://github.com/nodejs/node/pull/22150
+    description: The `buffer` parameter can now be any `TypedArray` or a
+                 `DataView`.
+  - version: v6.0.0
+    pr-url: https://github.com/nodejs/node/pull/4518
+    description: The `length` parameter can now be `0`.
 -->
 
-* `path` {string|Buffer|URL}
-* `uid` {integer}
-* `gid` {integer}
-* Returns: {Promise}
+* `fd` {integer}
+* `buffer` {Buffer|TypedArray|DataView}
+* `offset` {integer}
+* `length` {integer}
+* `position` {integer|bigint}
+* Returns: {number}
+
+Returns the number of `bytesRead`.
 
-Changes the ownership of a file then resolves the `Promise` with no arguments
-upon success.
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.read()`][].
 
-### `fsPromises.copyFile(src, dest[, flags])`
+### `fs.readSync(fd, buffer, [options])`
 <!-- YAML
-added: v10.0.0
+added:
+ - v13.13.0
+ - v12.17.0
 changes:
-  - version: v14.0.0
-    pr-url: https://github.com/nodejs/node/pull/27044
-    description: Changed 'flags' argument to 'mode' and imposed
-                 stricter type validation.
+  - version:
+     - v13.13.0
+     - v12.17.0
+    pr-url: https://github.com/nodejs/node/pull/32460
+    description: Options object can be passed in
+                 to make offset, length and position optional.
 -->
 
-* `src` {string|Buffer|URL} source filename to copy
-* `dest` {string|Buffer|URL} destination filename of the copy operation
-* `flags` {number} modifiers for copy operation. **Default:** `0`.
-* Returns: {Promise}
+* `fd` {integer}
+* `buffer` {Buffer|TypedArray|DataView}
+* `options` {Object}
+  * `offset` {integer} **Default:** `0`
+  * `length` {integer} **Default:** `buffer.byteLength`
+  * `position` {integer|bigint} **Default:** `null`
+* Returns: {number}
 
-Asynchronously copies `src` to `dest`. By default, `dest` is overwritten if it
-already exists. The `Promise` will be resolved with no arguments upon success.
+Returns the number of `bytesRead`.
 
-Node.js makes no guarantees about the atomicity of the copy operation. If an
-error occurs after the destination file has been opened for writing, Node.js
-will attempt to remove the destination.
+Similar to the above `fs.readSync` function, this version takes an optional `options` object.
+If no `options` object is specified, it will default with the above values.
 
-`flags` is an optional integer that specifies the behavior
-of the copy operation. It is possible to create a mask consisting of the bitwise
-OR of two or more values (e.g.
-`fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE`).
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.read()`][].
 
-* `fs.constants.COPYFILE_EXCL`: The copy operation will fail if `dest` already
-exists.
-* `fs.constants.COPYFILE_FICLONE`: The copy operation will attempt to create a
-copy-on-write reflink. If the platform does not support copy-on-write, then a
-fallback copy mechanism is used.
-* `fs.constants.COPYFILE_FICLONE_FORCE`: The copy operation will attempt to
-create a copy-on-write reflink. If the platform does not support copy-on-write,
-then the operation will fail.
+### `fs.readvSync(fd, buffers[, position])`
+<!-- YAML
+added:
+ - v13.13.0
+ - v12.17.0
+-->
 
-```js
-const fsPromises = require('fs').promises;
+* `fd` {integer}
+* `buffers` {ArrayBufferView[]}
+* `position` {integer}
+* Returns: {number} The number of bytes read.
 
-// destination.txt will be created or overwritten by default.
-fsPromises.copyFile('source.txt', 'destination.txt')
-  .then(() => console.log('source.txt was copied to destination.txt'))
-  .catch(() => console.log('The file could not be copied'));
-```
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.readv()`][].
 
-If the third argument is a number, then it specifies `flags`:
+### `fs.realpathSync(path[, options])`
+<!-- YAML
+added: v0.1.31
+changes:
+  - version: v8.0.0
+    pr-url: https://github.com/nodejs/node/pull/13028
+    description: Pipe/Socket resolve support was added.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using
+                 `file:` protocol.
+  - version: v6.4.0
+    pr-url: https://github.com/nodejs/node/pull/7899
+    description: Calling `realpathSync` now works again for various edge cases
+                 on Windows.
+  - version: v6.0.0
+    pr-url: https://github.com/nodejs/node/pull/3594
+    description: The `cache` parameter was removed.
+-->
 
-```js
-const fs = require('fs');
-const fsPromises = fs.promises;
-const { COPYFILE_EXCL } = fs.constants;
+* `path` {string|Buffer|URL}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+* Returns: {string|Buffer}
 
-// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
-fsPromises.copyFile('source.txt', 'destination.txt', COPYFILE_EXCL)
-  .then(() => console.log('source.txt was copied to destination.txt'))
-  .catch(() => console.log('The file could not be copied'));
-```
+Returns the resolved pathname.
 
-### `fsPromises.lchmod(path, mode)`
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.realpath()`][].
+
+### `fs.realpathSync.native(path[, options])`
 <!-- YAML
-deprecated: v10.0.0
+added: v9.2.0
 -->
 
 * `path` {string|Buffer|URL}
-* `mode` {integer}
-* Returns: {Promise}
+* `options` {string|Object}
+  * `encoding` {string} **Default:** `'utf8'`
+* Returns: {string|Buffer}
 
-Changes the permissions on a symbolic link then resolves the `Promise` with
-no arguments upon success. This method is only implemented on macOS.
+Synchronous realpath(3).
 
-### `fsPromises.lchown(path, uid, gid)`
+Only paths that can be converted to UTF8 strings are supported.
+
+The optional `options` argument can be a string specifying an encoding, or an
+object with an `encoding` property specifying the character encoding to use for
+the path returned. If the `encoding` is set to `'buffer'`,
+the path returned will be passed as a {Buffer} object.
+
+On Linux, when Node.js is linked against musl libc, the procfs file system must
+be mounted on `/proc` in order for this function to work. Glibc does not have
+this restriction.
+
+### `fs.renameSync(oldPath, newPath)`
 <!-- YAML
-added: v10.0.0
+added: v0.1.21
 changes:
-  - version: v10.6.0
-    pr-url: https://github.com/nodejs/node/pull/21498
-    description: This API is no longer deprecated.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `oldPath` and `newPath` parameters can be WHATWG `URL`
+                 objects using `file:` protocol. Support is currently still
+                 *experimental*.
 -->
 
-* `path` {string|Buffer|URL}
-* `uid` {integer}
-* `gid` {integer}
-* Returns: {Promise}
+* `oldPath` {string|Buffer|URL}
+* `newPath` {string|Buffer|URL}
 
-Changes the ownership on a symbolic link then resolves the `Promise` with
-no arguments upon success.
+Renames the file from `oldPath` to `newPath`. Returns `undefined`.
 
-### `fsPromises.lutimes(path, atime, mtime)`
+See the POSIX rename(2) documentation for more details.
+
+### `fs.rmdirSync(path[, options])`
 <!-- YAML
-added: v12.19.0
+added: v0.1.21
+changes:
+  - version: v14.14.0
+    pr-url: https://github.com/nodejs/node/pull/35579
+    description: The `recursive` option is deprecated, use `fs.rmSync` instead.
+  - version:
+     - v13.3.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/30644
+    description: The `maxBusyTries` option is renamed to `maxRetries`, and its
+                 default is 0. The `emfileWait` option has been removed, and
+                 `EMFILE` errors use the same retry logic as other errors. The
+                 `retryDelay` option is now supported. `ENFILE` errors are now
+                 retried.
+  - version: v12.10.0
+    pr-url: https://github.com/nodejs/node/pull/29168
+    description: The `recursive`, `maxBusyTries`, and `emfileWait` options are
+                 now supported.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameters can be a WHATWG `URL` object using
+                 `file:` protocol.
 -->
 
 * `path` {string|Buffer|URL}
-* `atime` {number|string|Date}
-* `mtime` {number|string|Date}
-* Returns: {Promise}
+* `options` {Object}
+  * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+    `EPERM` error is encountered, Node.js retries the operation with a linear
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
+  * `recursive` {boolean} If `true`, perform a recursive directory removal. In
+    recursive mode, errors are not reported if `path` does not exist, and
+    operations are retried on failure. **Default:** `false`.
+  * `retryDelay` {integer} The amount of time in milliseconds to wait between
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
 
-Changes the access and modification times of a file in the same way as
-[`fsPromises.utimes()`][], with the difference that if the path refers to a
-symbolic link, then the link is not dereferenced: instead, the timestamps of
-the symbolic link itself are changed.
+Synchronous rmdir(2). Returns `undefined`.
+
+Using `fs.rmdirSync()` on a file (not a directory) results in an `ENOENT` error
+on Windows and an `ENOTDIR` error on POSIX.
 
-Upon success, the `Promise` is resolved without arguments.
+Setting `recursive` to `true` results in behavior similar to the Unix command
+`rm -rf`: an error will not be raised for paths that do not exist, and paths
+that represent files will be deleted. The permissive behavior of the
+`recursive` option is deprecated, `ENOTDIR` and `ENOENT` will be thrown in
+the future.
 
-### `fsPromises.link(existingPath, newPath)`
+### `fs.rmSync(path[, options])`
 <!-- YAML
-added: v10.0.0
+added: v14.14.0
 -->
 
-* `existingPath` {string|Buffer|URL}
-* `newPath` {string|Buffer|URL}
-* Returns: {Promise}
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `force` {boolean} When `true`, exceptions will be ignored if `path` does
+    not exist. **Default:** `false`.
+  * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+    `EPERM` error is encountered, Node.js will retry the operation with a linear
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
+  * `recursive` {boolean} If `true`, perform a recursive directory removal. In
+    recursive mode operations are retried on failure. **Default:** `false`.
+  * `retryDelay` {integer} The amount of time in milliseconds to wait between
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
 
-Asynchronous link(2). The `Promise` is resolved with no arguments upon success.
+Synchronously removes files and directories (modeled on the standard POSIX `rm`
+utility). Returns `undefined`.
 
-### `fsPromises.lstat(path[, options])`
+### `fs.statSync(path[, options])`
 <!-- YAML
-added: v10.0.0
+added: v0.1.21
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/33716
+    description: Accepts a `throwIfNoEntry` option to specify whether
+                 an exception should be thrown if the entry does not exist.
   - version: v10.5.0
     pr-url: https://github.com/nodejs/node/pull/20220
     description: Accepts an additional `options` object to specify whether
                  the numeric values returned should be bigint.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
 -->
 
 * `path` {string|Buffer|URL}
 * `options` {Object}
   * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
-* Returns: {Promise}
+    {fs.Stats} object should be `bigint`. **Default:** `false`.
+  * `throwIfNoEntry` {boolean} Whether an exception will be thrown
+    if no file system entry exists, rather than returning `undefined`.
+    **Default:** `true`.
+* Returns: {fs.Stats}
 
-Asynchronous lstat(2). The `Promise` is resolved with the [`fs.Stats`][] object
-for the given symbolic link `path`.
+Retrieves the {fs.Stats} for the path.
 
-### `fsPromises.mkdir(path[, options])`
+### `fs.symlinkSync(target, path[, type])`
 <!-- YAML
-added: v10.0.0
--->
-
+added: v0.1.31
+changes:
+  - version: v12.0.0
+    pr-url: https://github.com/nodejs/node/pull/23724
+    description: If the `type` argument is left undefined, Node will autodetect
+                 `target` type and automatically select `dir` or `file`.
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `target` and `path` parameters can be WHATWG `URL` objects
+                 using `file:` protocol. Support is currently still
+                 *experimental*.
+-->
+
+* `target` {string|Buffer|URL}
 * `path` {string|Buffer|URL}
-* `options` {Object|integer}
-  * `recursive` {boolean} **Default:** `false`
-  * `mode` {string|integer} Not supported on Windows. **Default:** `0o777`.
-* Returns: {Promise}
+* `type` {string}
 
-Asynchronously creates a directory then resolves the `Promise` with either no
-arguments, or the first directory path created if `recursive` is `true`.
+Returns `undefined`.
 
-The optional `options` argument can be an integer specifying mode (permission
-and sticky bits), or an object with a `mode` property and a `recursive`
-property indicating whether parent directories should be created. Calling
-`fsPromises.mkdir()` when `path` is a directory that exists results in a
-rejection only when `recursive` is false.
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.symlink()`][].
 
-### `fsPromises.mkdtemp(prefix[, options])`
+### `fs.truncateSync(path[, len])`
 <!-- YAML
-added: v10.0.0
+added: v0.8.6
 -->
 
-* `prefix` {string}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-* Returns: {Promise}
+* `path` {string|Buffer|URL}
+* `len` {integer} **Default:** `0`
 
-Creates a unique temporary directory and resolves the `Promise` with the created
-directory path. A unique directory name is generated by appending six random
-characters to the end of the provided `prefix`. Due to platform
-inconsistencies, avoid trailing `X` characters in `prefix`. Some platforms,
-notably the BSDs, can return more than six random characters, and replace
-trailing `X` characters in `prefix` with random characters.
+Truncates the file. Returns `undefined`. A file descriptor can also be
+passed as the first argument. In this case, `fs.ftruncateSync()` is called.
 
-The optional `options` argument can be a string specifying an encoding, or an
-object with an `encoding` property specifying the character encoding to use.
+Passing a file descriptor is deprecated and may result in an error being thrown
+in the future.
 
-```js
-fsPromises.mkdtemp(path.join(os.tmpdir(), 'foo-'))
-  .catch(console.error);
-```
+### `fs.unlinkSync(path)`
+<!-- YAML
+added: v0.1.21
+changes:
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
+-->
 
-The `fsPromises.mkdtemp()` method will append the six randomly selected
-characters directly to the `prefix` string. For instance, given a directory
-`/tmp`, if the intention is to create a temporary directory *within* `/tmp`, the
-`prefix` must end with a trailing platform-specific path separator
-(`require('path').sep`).
+* `path` {string|Buffer|URL}
 
-### `fsPromises.open(path, flags[, mode])`
+Synchronous unlink(2). Returns `undefined`.
+
+### `fs.utimesSync(path, atime, mtime)`
 <!-- YAML
-added: v10.0.0
+added: v0.4.2
 changes:
-  - version: v11.1.0
-    pr-url: https://github.com/nodejs/node/pull/23767
-    description: The `flags` argument is now optional and defaults to `'r'`.
+  - version: v8.0.0
+    pr-url: https://github.com/nodejs/node/pull/11919
+    description: "`NaN`, `Infinity`, and `-Infinity` are no longer valid time
+                 specifiers."
+  - version: v7.6.0
+    pr-url: https://github.com/nodejs/node/pull/10739
+    description: The `path` parameter can be a WHATWG `URL` object using `file:`
+                 protocol.
+  - version: v4.1.0
+    pr-url: https://github.com/nodejs/node/pull/2387
+    description: Numeric strings, `NaN` and `Infinity` are now allowed
+                 time specifiers.
+-->
+
+* `path` {string|Buffer|URL}
+* `atime` {number|string|Date}
+* `mtime` {number|string|Date}
+
+Returns `undefined`.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.utimes()`][].
+
+### `fs.writeFileSync(file, data[, options])`
+<!-- YAML
+added: v0.1.29
+changes:
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `data` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `data` parameter won't coerce unsupported input to
+                 strings anymore.
+  - version: v10.10.0
+    pr-url: https://github.com/nodejs/node/pull/22150
+    description: The `data` parameter can now be any `TypedArray` or a
+                 `DataView`.
+  - version: v7.4.0
+    pr-url: https://github.com/nodejs/node/pull/10382
+    description: The `data` parameter can now be a `Uint8Array`.
+  - version: v5.0.0
+    pr-url: https://github.com/nodejs/node/pull/3163
+    description: The `file` parameter can be a file descriptor now.
+-->
+
+* `file` {string|Buffer|URL|integer} filename or file descriptor
+* `data` {string|Buffer|TypedArray|DataView|Object}
+* `options` {Object|string}
+  * `encoding` {string|null} **Default:** `'utf8'`
+  * `mode` {integer} **Default:** `0o666`
+  * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
+
+Returns `undefined`.
+
+If `data` is a plain object, it must have an own (not inherited) `toString`
+function property.
+
+The `mode` option only affects the newly created file. See [`fs.open()`][]
+for more details.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.writeFile()`][].
+
+### `fs.writeSync(fd, buffer[, offset[, length[, position]]])`
+<!-- YAML
+added: v0.1.21
+changes:
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `buffer` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `buffer` parameter won't coerce unsupported input to
+                 strings anymore.
+  - version: v10.10.0
+    pr-url: https://github.com/nodejs/node/pull/22150
+    description: The `buffer` parameter can now be any `TypedArray` or a
+                 `DataView`.
+  - version: v7.4.0
+    pr-url: https://github.com/nodejs/node/pull/10382
+    description: The `buffer` parameter can now be a `Uint8Array`.
+  - version: v7.2.0
+    pr-url: https://github.com/nodejs/node/pull/7856
+    description: The `offset` and `length` parameters are optional now.
+-->
+
+* `fd` {integer}
+* `buffer` {Buffer|TypedArray|DataView|string|Object}
+* `offset` {integer}
+* `length` {integer}
+* `position` {integer}
+* Returns: {number} The number of bytes written.
+
+If `buffer` is a plain object, it must have an own (not inherited) `toString`
+function property.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.write(fd, buffer...)`][].
+
+### `fs.writeSync(fd, string[, position[, encoding]])`
+<!-- YAML
+added: v0.11.5
+changes:
+  - version: v14.12.0
+    pr-url: https://github.com/nodejs/node/pull/34993
+    description: The `string` parameter will stringify an object with an
+                 explicit `toString` function.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31030
+    description: The `string` parameter won't coerce unsupported input to
+                 strings anymore.
+  - version: v7.2.0
+    pr-url: https://github.com/nodejs/node/pull/7856
+    description: The `position` parameter is optional now.
+-->
+
+* `fd` {integer}
+* `string` {string|Object}
+* `position` {integer}
+* `encoding` {string}
+* Returns: {number} The number of bytes written.
+
+If `string` is a plain object, it must have an own (not inherited) `toString`
+function property.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.write(fd, string...)`][].
+
+### `fs.writevSync(fd, buffers[, position])`
+<!-- YAML
+added: v12.9.0
+-->
+
+* `fd` {integer}
+* `buffers` {ArrayBufferView[]}
+* `position` {integer}
+* Returns: {number} The number of bytes written.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.writev()`][].
+
+## Common Objects
+
+The common objects are shared by all of the file system API variants
+(promise, callback, and synchronous).
+
+### Class: `fs.Dir`
+<!-- YAML
+added: v12.12.0
+-->
+
+A class representing a directory stream.
+
+Created by [`fs.opendir()`][], [`fs.opendirSync()`][], or
+[`fsPromises.opendir()`][].
+
+```mjs
+import { opendir } from 'fs/promises';
+
+try {
+  const dir = await opendir('./');
+  for await (const dirent of dir)
+    console.log(dirent.name);
+} catch (err) {
+  console.error(err);
+}
+```
+
+When using the async iterator, the {fs.Dir} object will be automatically
+closed after the iterator exits.
+
+#### `dir.close()`
+<!-- YAML
+added: v12.12.0
+-->
+
+* Returns: {Promise}
+
+Asynchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.
+
+A promise is returned that will be resolved after the resource has been
+closed.
+
+#### `dir.close(callback)`
+<!-- YAML
+added: v12.12.0
+-->
+
+* `callback` {Function}
+  * `err` {Error}
+
+Asynchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.
+
+The `callback` will be called after the resource handle has been closed.
+
+#### `dir.closeSync()`
+<!-- YAML
+added: v12.12.0
+-->
+
+Synchronously close the directory's underlying resource handle.
+Subsequent reads will result in errors.
+
+#### `dir.path`
+<!-- YAML
+added: v12.12.0
+-->
+
+* {string}
+
+The read-only path of this directory as was provided to [`fs.opendir()`][],
+[`fs.opendirSync()`][], or [`fsPromises.opendir()`][].
+
+#### `dir.read()`
+<!-- YAML
+added: v12.12.0
+-->
+
+* Returns: {Promise} containing {fs.Dirent|null}
+
+Asynchronously read the next directory entry via readdir(3) as an
+{fs.Dirent}.
+
+A promise is returned that will be resolved with an {fs.Dirent}, or `null`
+if there are no more directory entries to read.
+
+Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.
+
+#### `dir.read(callback)`
+<!-- YAML
+added: v12.12.0
 -->
 
-* `path` {string|Buffer|URL}
-* `flags` {string|number} See [support of file system `flags`][].
-  **Default:** `'r'`.
-* `mode` {string|integer} **Default:** `0o666` (readable and writable)
-* Returns: {Promise}
+* `callback` {Function}
+  * `err` {Error}
+  * `dirent` {fs.Dirent|null}
+
+Asynchronously read the next directory entry via readdir(3) as an
+{fs.Dirent}.
+
+After the read is completed, the `callback` will be called with an
+{fs.Dirent}, or `null` if there are no more directory entries to read.
+
+Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.
+
+#### `dir.readSync()`
+<!-- YAML
+added: v12.12.0
+-->
+
+* Returns: {fs.Dirent|null}
+
+Synchronously read the next directory entry as an {fs.Dirent}. See the
+POSIX readdir(3) documentation for more detail.
+
+If there are no more directory entries to read, `null` will be returned.
+
+Directory entries returned by this function are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.
+
+#### `dir[Symbol.asyncIterator]()`
+<!-- YAML
+added: v12.12.0
+-->
+
+* Returns: {AsyncIterator} of {fs.Dirent}
+
+Asynchronously iterates over the directory until all entries have
+been read. Refer to the POSIX readdir(3) documentation for more detail.
+
+Entries returned by the async iterator are always an {fs.Dirent}.
+The `null` case from `dir.read()` is handled internally.
+
+See {fs.Dir} for an example.
+
+Directory entries returned by this iterator are in no particular order as
+provided by the operating system's underlying directory mechanisms.
+Entries added or removed while iterating over the directory might not be
+included in the iteration results.
+
+### Class: `fs.Dirent`
+<!-- YAML
+added: v10.10.0
+-->
+
+A representation of a directory entry, which can be a file or a subdirectory
+within the directory, as returned by reading from an {fs.Dir}. The
+directory entry is a combination of the file name and file type pairs.
+
+Additionally, when [`fs.readdir()`][] or [`fs.readdirSync()`][] is called with
+the `withFileTypes` option set to `true`, the resulting array is filled with
+{fs.Dirent} objects, rather than strings or {Buffer}s.
+
+#### `dirent.isBlockDevice()`
+<!-- YAML
+added: v10.10.0
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Dirent} object describes a block device.
+
+#### `dirent.isCharacterDevice()`
+<!-- YAML
+added: v10.10.0
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Dirent} object describes a character device.
+
+#### `dirent.isDirectory()`
+<!-- YAML
+added: v10.10.0
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Dirent} object describes a file system
+directory.
+
+#### `dirent.isFIFO()`
+<!-- YAML
+added: v10.10.0
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Dirent} object describes a first-in-first-out
+(FIFO) pipe.
+
+#### `dirent.isFile()`
+<!-- YAML
+added: v10.10.0
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Dirent} object describes a regular file.
+
+#### `dirent.isSocket()`
+<!-- YAML
+added: v10.10.0
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Dirent} object describes a socket.
+
+#### `dirent.isSymbolicLink()`
+<!-- YAML
+added: v10.10.0
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Dirent} object describes a symbolic link.
+
+#### `dirent.name`
+<!-- YAML
+added: v10.10.0
+-->
+
+* {string|Buffer}
+
+The file name that this {fs.Dirent} object refers to. The type of this
+value is determined by the `options.encoding` passed to [`fs.readdir()`][] or
+[`fs.readdirSync()`][].
+
+### Class: `fs.FSWatcher`
+<!-- YAML
+added: v0.5.8
+-->
+
+* Extends {EventEmitter}
+
+A successful call to [`fs.watch()`][] method will return a new {fs.FSWatcher}
+object.
+
+All {fs.FSWatcher} objects emit a `'change'` event whenever a specific watched
+file is modified.
+
+#### Event: `'change'`
+<!-- YAML
+added: v0.5.8
+-->
+
+* `eventType` {string} The type of change event that has occurred
+* `filename` {string|Buffer} The filename that changed (if relevant/available)
+
+Emitted when something changes in a watched directory or file.
+See more details in [`fs.watch()`][].
+
+The `filename` argument may not be provided depending on operating system
+support. If `filename` is provided, it will be provided as a {Buffer} if
+`fs.watch()` is called with its `encoding` option set to `'buffer'`, otherwise
+`filename` will be a UTF-8 string.
+
+```mjs
+import { watch } from 'fs';
+// Example when handled through fs.watch() listener
+watch('./tmp', { encoding: 'buffer' }, (eventType, filename) => {
+  if (filename) {
+    console.log(filename);
+    // Prints: <Buffer ...>
+  }
+});
+```
+
+#### Event: `'close'`
+<!-- YAML
+added: v10.0.0
+-->
+
+Emitted when the watcher stops watching for changes. The closed
+{fs.FSWatcher} object is no longer usable in the event handler.
+
+#### Event: `'error'`
+<!-- YAML
+added: v0.5.8
+-->
+
+* `error` {Error}
+
+Emitted when an error occurs while watching the file. The errored
+{fs.FSWatcher} object is no longer usable in the event handler.
+
+#### `watcher.close()`
+<!-- YAML
+added: v0.5.8
+-->
+
+Stop watching for changes on the given {fs.FSWatcher}. Once stopped, the
+{fs.FSWatcher} object is no longer usable.
+
+#### `watcher.ref()`
+<!-- YAML
+added:
+  - v14.3.0
+  - v12.20.0
+-->
+
+* Returns: {fs.FSWatcher}
+
+When called, requests that the Node.js event loop *not* exit so long as the
+{fs.FSWatcher} is active. Calling `watcher.ref()` multiple times will have
+no effect.
+
+By default, all {fs.FSWatcher} objects are "ref'ed", making it normally
+unnecessary to call `watcher.ref()` unless `watcher.unref()` had been
+called previously.
+
+#### `watcher.unref()`
+<!-- YAML
+added:
+  - v14.3.0
+  - v12.20.0
+-->
+
+* Returns: {fs.FSWatcher}
+
+When called, the active {fs.FSWatcher} object will not require the Node.js
+event loop to remain active. If there is no other activity keeping the
+event loop running, the process may exit before the {fs.FSWatcher} object's
+callback is invoked. Calling `watcher.unref()` multiple times will have
+no effect.
+
+### Class: `fs.StatWatcher`
+<!-- YAML
+added:
+  - v14.3.0
+  - v12.20.0
+-->
+
+* Extends {EventEmitter}
+
+A successful call to `fs.watchFile()` method will return a new {fs.StatWatcher}
+object.
+
+#### `watcher.ref()`
+<!-- YAML
+added:
+  - v14.3.0
+  - v12.20.0
+-->
+
+* Returns: {fs.StatWatcher}
+
+When called, requests that the Node.js event loop *not* exit so long as the
+{fs.StatWatcher} is active. Calling `watcher.ref()` multiple times will have
+no effect.
+
+By default, all {fs.StatWatcher} objects are "ref'ed", making it normally
+unnecessary to call `watcher.ref()` unless `watcher.unref()` had been
+called previously.
+
+#### `watcher.unref()`
+<!-- YAML
+added:
+  - v14.3.0
+  - v12.20.0
+-->
+
+* Returns: {fs.StatWatcher}
+
+When called, the active {fs.StatWatcher} object will not require the Node.js
+event loop to remain active. If there is no other activity keeping the
+event loop running, the process may exit before the {fs.StatWatcher} object's
+callback is invoked. Calling `watcher.unref()` multiple times will have
+no effect.
+
+### Class: `fs.ReadStream`
+<!-- YAML
+added: v0.1.93
+-->
+
+* Extends: {stream.Readable}
+
+Instances of {fs.ReadStream} are created and returned using the
+[`fs.createReadStream()`][] function.
+
+#### Event: `'close'`
+<!-- YAML
+added: v0.1.93
+-->
+
+Emitted when the {fs.ReadStream}'s underlying file descriptor has been closed.
+
+#### Event: `'open'`
+<!-- YAML
+added: v0.1.93
+-->
+
+* `fd` {integer} Integer file descriptor used by the {fs.ReadStream}.
+
+Emitted when the {fs.ReadStream}'s file descriptor has been opened.
+
+#### Event: `'ready'`
+<!-- YAML
+added: v9.11.0
+-->
+
+Emitted when the {fs.ReadStream} is ready to be used.
+
+Fires immediately after `'open'`.
+
+#### `readStream.bytesRead`
+<!-- YAML
+added: v6.4.0
+-->
+
+* {number}
+
+The number of bytes that have been read so far.
+
+#### `readStream.path`
+<!-- YAML
+added: v0.1.93
+-->
+
+* {string|Buffer}
+
+The path to the file the stream is reading from as specified in the first
+argument to `fs.createReadStream()`. If `path` is passed as a string, then
+`readStream.path` will be a string. If `path` is passed as a {Buffer}, then
+`readStream.path` will be a {Buffer}.
+
+#### `readStream.pending`
+<!-- YAML
+added:
+ - v11.2.0
+ - v10.16.0
+-->
+
+* {boolean}
+
+This property is `true` if the underlying file has not been opened yet,
+i.e. before the `'ready'` event is emitted.
+
+### Class: `fs.Stats`
+<!-- YAML
+added: v0.1.21
+changes:
+  - version: v8.1.0
+    pr-url: https://github.com/nodejs/node/pull/13173
+    description: Added times as numbers.
+-->
+
+A {fs.Stats} object provides information about a file.
+
+Objects returned from [`fs.stat()`][], [`fs.lstat()`][] and [`fs.fstat()`][] and
+their synchronous counterparts are of this type.
+If `bigint` in the `options` passed to those methods is true, the numeric values
+will be `bigint` instead of `number`, and the object will contain additional
+nanosecond-precision properties suffixed with `Ns`.
+
+```console
+Stats {
+  dev: 2114,
+  ino: 48064969,
+  mode: 33188,
+  nlink: 1,
+  uid: 85,
+  gid: 100,
+  rdev: 0,
+  size: 527,
+  blksize: 4096,
+  blocks: 8,
+  atimeMs: 1318289051000.1,
+  mtimeMs: 1318289051000.1,
+  ctimeMs: 1318289051000.1,
+  birthtimeMs: 1318289051000.1,
+  atime: Mon, 10 Oct 2011 23:24:11 GMT,
+  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
+  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
+  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
+```
+
+`bigint` version:
+
+```console
+BigIntStats {
+  dev: 2114n,
+  ino: 48064969n,
+  mode: 33188n,
+  nlink: 1n,
+  uid: 85n,
+  gid: 100n,
+  rdev: 0n,
+  size: 527n,
+  blksize: 4096n,
+  blocks: 8n,
+  atimeMs: 1318289051000n,
+  mtimeMs: 1318289051000n,
+  ctimeMs: 1318289051000n,
+  birthtimeMs: 1318289051000n,
+  atimeNs: 1318289051000000000n,
+  mtimeNs: 1318289051000000000n,
+  ctimeNs: 1318289051000000000n,
+  birthtimeNs: 1318289051000000000n,
+  atime: Mon, 10 Oct 2011 23:24:11 GMT,
+  mtime: Mon, 10 Oct 2011 23:24:11 GMT,
+  ctime: Mon, 10 Oct 2011 23:24:11 GMT,
+  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
+```
+
+#### `stats.isBlockDevice()`
+<!-- YAML
+added: v0.1.10
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Stats} object describes a block device.
+
+#### `stats.isCharacterDevice()`
+<!-- YAML
+added: v0.1.10
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Stats} object describes a character device.
+
+#### `stats.isDirectory()`
+<!-- YAML
+added: v0.1.10
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Stats} object describes a file system directory.
+
+If the {fs.Stats} object was obtained from [`fs.lstat()`][], this method will
+always return `false`. This is because [`fs.lstat()`][] returns information
+about a symbolic link itself and not the path it resolves to.
+
+#### `stats.isFIFO()`
+<!-- YAML
+added: v0.1.10
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Stats} object describes a first-in-first-out (FIFO)
+pipe.
+
+#### `stats.isFile()`
+<!-- YAML
+added: v0.1.10
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Stats} object describes a regular file.
+
+#### `stats.isSocket()`
+<!-- YAML
+added: v0.1.10
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Stats} object describes a socket.
+
+#### `stats.isSymbolicLink()`
+<!-- YAML
+added: v0.1.10
+-->
+
+* Returns: {boolean}
+
+Returns `true` if the {fs.Stats} object describes a symbolic link.
+
+This method is only valid when using [`fs.lstat()`][].
+
+#### `stats.dev`
+
+* {number|bigint}
+
+The numeric identifier of the device containing the file.
+
+#### `stats.ino`
+
+* {number|bigint}
+
+The file system specific "Inode" number for the file.
+
+#### `stats.mode`
+
+* {number|bigint}
+
+A bit-field describing the file type and mode.
+
+#### `stats.nlink`
+
+* {number|bigint}
+
+The number of hard-links that exist for the file.
+
+#### `stats.uid`
+
+* {number|bigint}
+
+The numeric user identifier of the user that owns the file (POSIX).
+
+#### `stats.gid`
+
+* {number|bigint}
+
+The numeric group identifier of the group that owns the file (POSIX).
+
+#### `stats.rdev`
+
+* {number|bigint}
+
+A numeric device identifier if the file represents a device.
+
+#### `stats.size`
+
+* {number|bigint}
+
+The size of the file in bytes.
+
+#### `stats.blksize`
+
+* {number|bigint}
+
+The file system block size for i/o operations.
 
-Asynchronous file open that returns a `Promise` that, when resolved, yields a
-`FileHandle` object. See open(2).
+#### `stats.blocks`
 
-`mode` sets the file mode (permission and sticky bits), but only if the file was
-created.
+* {number|bigint}
 
-Some characters (`< > : " / \ | ? *`) are reserved under Windows as documented
-by [Naming Files, Paths, and Namespaces][]. Under NTFS, if the filename contains
-a colon, Node.js will open a file system stream, as described by
-[this MSDN page][MSDN-Using-Streams].
+The number of blocks allocated for this file.
 
-### `fsPromises.opendir(path[, options])`
+#### `stats.atimeMs`
 <!-- YAML
-added: v12.12.0
-changes:
-  - version: v12.16.0
-    pr-url: https://github.com/nodejs/node/pull/30114
-    description: The `bufferSize` option was introduced.
+added: v8.1.0
 -->
 
-* `path` {string|Buffer|URL}
-* `options` {Object}
-  * `encoding` {string|null} **Default:** `'utf8'`
-  * `bufferSize` {number} Number of directory entries that are buffered
-    internally when reading from the directory. Higher values lead to better
-    performance but higher memory usage. **Default:** `32`
-* Returns: {Promise} containing {fs.Dir}
+* {number|bigint}
 
-Asynchronously open a directory. See opendir(3).
+The timestamp indicating the last time this file was accessed expressed in
+milliseconds since the POSIX Epoch.
 
-Creates an [`fs.Dir`][], which contains all further functions for reading from
-and cleaning up the directory.
+#### `stats.mtimeMs`
+<!-- YAML
+added: v8.1.0
+-->
 
-The `encoding` option sets the encoding for the `path` while opening the
-directory and subsequent read operations.
+* {number|bigint}
 
-Example using async iteration:
+The timestamp indicating the last time this file was modified expressed in
+milliseconds since the POSIX Epoch.
 
-```js
-const fs = require('fs');
+#### `stats.ctimeMs`
+<!-- YAML
+added: v8.1.0
+-->
 
-async function print(path) {
-  const dir = await fs.promises.opendir(path);
-  for await (const dirent of dir) {
-    console.log(dirent.name);
-  }
-}
-print('./').catch(console.error);
-```
+* {number|bigint}
 
-### `fsPromises.readdir(path[, options])`
+The timestamp indicating the last time the file status was changed expressed
+in milliseconds since the POSIX Epoch.
+
+#### `stats.birthtimeMs`
 <!-- YAML
-added: v10.0.0
-changes:
-  - version: v10.11.0
-    pr-url: https://github.com/nodejs/node/pull/22020
-    description: New option `withFileTypes` was added.
+added: v8.1.0
 -->
 
-* `path` {string|Buffer|URL}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-  * `withFileTypes` {boolean} **Default:** `false`
-* Returns: {Promise}
-
-Reads the contents of a directory then resolves the `Promise` with an array
-of the names of the files in the directory excluding `'.'` and `'..'`.
+* {number|bigint}
 
-The optional `options` argument can be a string specifying an encoding, or an
-object with an `encoding` property specifying the character encoding to use for
-the filenames. If the `encoding` is set to `'buffer'`, the filenames returned
-will be passed as `Buffer` objects.
+The timestamp indicating the creation time of this file expressed in
+milliseconds since the POSIX Epoch.
 
-If `options.withFileTypes` is set to `true`, the resolved array will contain
-[`fs.Dirent`][] objects.
+#### `stats.atimeNs`
+<!-- YAML
+added: v12.10.0
+-->
 
-```js
-const fs = require('fs');
+* {bigint}
 
-async function print(path) {
-  const files = await fs.promises.readdir(path);
-  for (const file of files) {
-    console.log(file);
-  }
-}
-print('./').catch(console.error);
-```
+Only present when `bigint: true` is passed into the method that generates
+the object.
+The timestamp indicating the last time this file was accessed expressed in
+nanoseconds since the POSIX Epoch.
 
-### `fsPromises.readFile(path[, options])`
+#### `stats.mtimeNs`
 <!-- YAML
-added: v10.0.0
+added: v12.10.0
 -->
 
-* `path` {string|Buffer|URL|FileHandle} filename or `FileHandle`
-* `options` {Object|string}
-  * `encoding` {string|null} **Default:** `null`
-  * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
-* Returns: {Promise}
-
-Asynchronously reads the entire contents of a file.
+* {bigint}
 
-The `Promise` is resolved with the contents of the file. If no encoding is
-specified (using `options.encoding`), the data is returned as a `Buffer`
-object. Otherwise, the data will be a string.
+Only present when `bigint: true` is passed into the method that generates
+the object.
+The timestamp indicating the last time this file was modified expressed in
+nanoseconds since the POSIX Epoch.
 
-If `options` is a string, then it specifies the encoding.
+#### `stats.ctimeNs`
+<!-- YAML
+added: v12.10.0
+-->
 
-When the `path` is a directory, the behavior of `fsPromises.readFile()` is
-platform-specific. On macOS, Linux, and Windows, the promise will be rejected
-with an error. On FreeBSD, a representation of the directory's contents will be
-returned.
+* {bigint}
 
-Any specified `FileHandle` has to support reading.
+Only present when `bigint: true` is passed into the method that generates
+the object.
+The timestamp indicating the last time the file status was changed expressed
+in nanoseconds since the POSIX Epoch.
 
-### `fsPromises.readlink(path[, options])`
+#### `stats.birthtimeNs`
 <!-- YAML
-added: v10.0.0
+added: v12.10.0
 -->
 
-* `path` {string|Buffer|URL}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-* Returns: {Promise}
-
-Asynchronous readlink(2). The `Promise` is resolved with the `linkString` upon
-success.
+* {bigint}
 
-The optional `options` argument can be a string specifying an encoding, or an
-object with an `encoding` property specifying the character encoding to use for
-the link path returned. If the `encoding` is set to `'buffer'`, the link path
-returned will be passed as a `Buffer` object.
+Only present when `bigint: true` is passed into the method that generates
+the object.
+The timestamp indicating the creation time of this file expressed in
+nanoseconds since the POSIX Epoch.
 
-### `fsPromises.realpath(path[, options])`
+#### `stats.atime`
 <!-- YAML
-added: v10.0.0
+added: v0.11.13
 -->
 
-* `path` {string|Buffer|URL}
-* `options` {string|Object}
-  * `encoding` {string} **Default:** `'utf8'`
-* Returns: {Promise}
+* {Date}
 
-Determines the actual location of `path` using the same semantics as the
-`fs.realpath.native()` function then resolves the `Promise` with the resolved
-path.
+The timestamp indicating the last time this file was accessed.
 
-Only paths that can be converted to UTF8 strings are supported.
+#### `stats.mtime`
+<!-- YAML
+added: v0.11.13
+-->
 
-The optional `options` argument can be a string specifying an encoding, or an
-object with an `encoding` property specifying the character encoding to use for
-the path. If the `encoding` is set to `'buffer'`, the path returned will be
-passed as a `Buffer` object.
+* {Date}
 
-On Linux, when Node.js is linked against musl libc, the procfs file system must
-be mounted on `/proc` in order for this function to work. Glibc does not have
-this restriction.
+The timestamp indicating the last time this file was modified.
 
-### `fsPromises.rename(oldPath, newPath)`
+#### `stats.ctime`
 <!-- YAML
-added: v10.0.0
+added: v0.11.13
 -->
 
-* `oldPath` {string|Buffer|URL}
-* `newPath` {string|Buffer|URL}
-* Returns: {Promise}
+* {Date}
 
-Renames `oldPath` to `newPath` and resolves the `Promise` with no arguments
-upon success.
+The timestamp indicating the last time the file status was changed.
 
-### `fsPromises.rmdir(path[, options])`
+#### `stats.birthtime`
 <!-- YAML
-added: v10.0.0
-changes:
-  - version: v12.16.0
-    pr-url: https://github.com/nodejs/node/pull/30644
-    description: The `maxBusyTries` option is renamed to `maxRetries`, and its
-                 default is 0. The `emfileWait` option has been removed, and
-                 `EMFILE` errors use the same retry logic as other errors. The
-                 `retryDelay` option is now supported. `ENFILE` errors are now
-                 retried.
-  - version: v12.10.0
-    pr-url: https://github.com/nodejs/node/pull/29168
-    description: The `recursive`, `maxBusyTries`, and `emfileWait` options are
-                  now supported.
+added: v0.11.13
 -->
 
-> Stability: 1 - Recursive removal is experimental.
+* {Date}
 
-* `path` {string|Buffer|URL}
-* `options` {Object}
-  * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
-  `EPERM` error is encountered, Node.js will retry the operation with a linear
-  backoff wait of `retryDelay` ms longer on each try. This option represents the
-  number of retries. This option is ignored if the `recursive` option is not
-  `true`. **Default:** `0`.
-  * `recursive` {boolean} If `true`, perform a recursive directory removal. In
-  recursive mode, errors are not reported if `path` does not exist, and
-  operations are retried on failure. **Default:** `false`.
-  * `retryDelay` {integer} The amount of time in milliseconds to wait between
-  retries. This option is ignored if the `recursive` option is not `true`.
-  **Default:** `100`.
-* Returns: {Promise}
+The timestamp indicating the creation time of this file.
 
-Removes the directory identified by `path` then resolves the `Promise` with
-no arguments upon success.
+#### Stat time values
 
-Using `fsPromises.rmdir()` on a file (not a directory) results in the
-`Promise` being rejected with an `ENOENT` error on Windows and an `ENOTDIR`
-error on POSIX.
+The `atimeMs`, `mtimeMs`, `ctimeMs`, `birthtimeMs` properties are
+numeric values that hold the corresponding times in milliseconds. Their
+precision is platform specific. When `bigint: true` is passed into the
+method that generates the object, the properties will be [bigints][],
+otherwise they will be [numbers][MDN-Number].
 
-### `fsPromises.stat(path[, options])`
-<!-- YAML
-added: v10.0.0
-changes:
-  - version: v10.5.0
-    pr-url: https://github.com/nodejs/node/pull/20220
-    description: Accepts an additional `options` object to specify whether
-                 the numeric values returned should be bigint.
--->
+The `atimeNs`, `mtimeNs`, `ctimeNs`, `birthtimeNs` properties are
+[bigints][] that hold the corresponding times in nanoseconds. They are
+only present when `bigint: true` is passed into the method that generates
+the object. Their precision is platform specific.
 
-* `path` {string|Buffer|URL}
-* `options` {Object}
-  * `bigint` {boolean} Whether the numeric values in the returned
-    [`fs.Stats`][] object should be `bigint`. **Default:** `false`.
-* Returns: {Promise}
+`atime`, `mtime`, `ctime`, and `birthtime` are
+[`Date`][MDN-Date] object alternate representations of the various times. The
+`Date` and number values are not connected. Assigning a new number value, or
+mutating the `Date` value, will not be reflected in the corresponding alternate
+representation.
 
-The `Promise` is resolved with the [`fs.Stats`][] object for the given `path`.
+The times in the stat object have the following semantics:
 
-### `fsPromises.symlink(target, path[, type])`
+* `atime` "Access Time": Time when file data last accessed. Changed
+  by the mknod(2), utimes(2), and read(2) system calls.
+* `mtime` "Modified Time": Time when file data last modified.
+  Changed by the mknod(2), utimes(2), and write(2) system calls.
+* `ctime` "Change Time": Time when file status was last changed
+  (inode data modification). Changed by the chmod(2), chown(2),
+  link(2), mknod(2), rename(2), unlink(2), utimes(2),
+  read(2), and write(2) system calls.
+* `birthtime` "Birth Time": Time of file creation. Set once when the
+  file is created. On filesystems where birthtime is not available,
+  this field may instead hold either the `ctime` or
+  `1970-01-01T00:00Z` (ie, Unix epoch timestamp `0`). This value may be greater
+  than `atime` or `mtime` in this case. On Darwin and other FreeBSD variants,
+  also set if the `atime` is explicitly set to an earlier value than the current
+  `birthtime` using the utimes(2) system call.
+
+Prior to Node.js 0.12, the `ctime` held the `birthtime` on Windows systems. As
+of 0.12, `ctime` is not "creation time", and on Unix systems, it never was.
+
+### Class: `fs.WriteStream`
 <!-- YAML
-added: v10.0.0
+added: v0.1.93
 -->
 
-* `target` {string|Buffer|URL}
-* `path` {string|Buffer|URL}
-* `type` {string} **Default:** `'file'`
-* Returns: {Promise}
-
-Creates a symbolic link then resolves the `Promise` with no arguments upon
-success.
+* Extends {stream.Writable}
 
-The `type` argument is only used on Windows platforms and can be one of `'dir'`,
-`'file'`, or `'junction'`. Windows junction points require the destination path
-to be absolute. When using `'junction'`, the `target` argument will
-automatically be normalized to absolute path.
+Instances of {fs.WriteStream} are created and returned using the
+[`fs.createWriteStream()`][] function.
 
-### `fsPromises.truncate(path[, len])`
+#### Event: `'close'`
 <!-- YAML
-added: v10.0.0
+added: v0.1.93
 -->
 
-* `path` {string|Buffer|URL}
-* `len` {integer} **Default:** `0`
-* Returns: {Promise}
+Emitted when the {fs.WriteStream}'s underlying file descriptor has been closed.
+
+#### Event: `'open'`
+<!-- YAML
+added: v0.1.93
+-->
 
-Truncates the `path` then resolves the `Promise` with no arguments upon
-success. The `path` *must* be a string or `Buffer`.
+* `fd` {integer} Integer file descriptor used by the {fs.WriteStream}.
 
-### `fsPromises.unlink(path)`
+Emitted when the {fs.WriteStream}'s file is opened.
+
+#### Event: `'ready'`
 <!-- YAML
-added: v10.0.0
+added: v9.11.0
 -->
 
-* `path` {string|Buffer|URL}
-* Returns: {Promise}
+Emitted when the {fs.WriteStream} is ready to be used.
 
-Asynchronous unlink(2). The `Promise` is resolved with no arguments upon
-success.
+Fires immediately after `'open'`.
 
-### `fsPromises.utimes(path, atime, mtime)`
+#### `writeStream.bytesWritten`
 <!-- YAML
-added: v10.0.0
+added: v0.4.7
 -->
 
-* `path` {string|Buffer|URL}
-* `atime` {number|string|Date}
-* `mtime` {number|string|Date}
-* Returns: {Promise}
+The number of bytes written so far. Does not include data that is still queued
+for writing.
 
-Change the file system timestamps of the object referenced by `path` then
-resolves the `Promise` with no arguments upon success.
+#### `writeStream.close([callback])`
+<!-- YAML
+added: v0.9.4
+-->
 
-The `atime` and `mtime` arguments follow these rules:
+* `callback` {Function}
+  * `err` {Error}
 
-* Values can be either numbers representing Unix epoch time, `Date`s, or a
-  numeric string like `'123456789.0'`.
-* If the value can not be converted to a number, or is `NaN`, `Infinity` or
-  `-Infinity`, an `Error` will be thrown.
+Closes `writeStream`. Optionally accepts a
+callback that will be executed once the `writeStream`
+is closed.
 
-### `fsPromises.writeFile(file, data[, options])`
+#### `writeStream.path`
 <!-- YAML
-added: v10.0.0
+added: v0.1.93
 -->
 
-* `file` {string|Buffer|URL|FileHandle} filename or `FileHandle`
-* `data` {string|Buffer|Uint8Array}
-* `options` {Object|string}
-  * `encoding` {string|null} **Default:** `'utf8'`
-  * `mode` {integer} **Default:** `0o666`
-  * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
-* Returns: {Promise}
+The path to the file the stream is writing to as specified in the first
+argument to [`fs.createWriteStream()`][]. If `path` is passed as a string, then
+`writeStream.path` will be a string. If `path` is passed as a {Buffer}, then
+`writeStream.path` will be a {Buffer}.
 
-Asynchronously writes data to a file, replacing the file if it already exists.
-`data` can be a string or a buffer. The `Promise` will be resolved with no
-arguments upon success.
+#### `writeStream.pending`
+<!-- YAML
+added: v11.2.0
+-->
 
-The `encoding` option is ignored if `data` is a buffer.
+* {boolean}
 
-If `options` is a string, then it specifies the encoding.
+This property is `true` if the underlying file has not been opened yet,
+i.e. before the `'ready'` event is emitted.
 
-Any specified `FileHandle` has to support writing.
+### `fs.constants`
 
-It is unsafe to use `fsPromises.writeFile()` multiple times on the same file
-without waiting for the `Promise` to be resolved (or rejected).
+* {Object}
+
+Returns an object containing commonly used constants for file system
+operations.
 
-## FS constants
+#### FS constants
 
 The following constants are exported by `fs.constants`.
 
@@ -5486,21 +6009,21 @@ To use more than one constant, use the bitwise OR `|` operator.
 
 Example:
 
-```js
-const fs = require('fs');
+```mjs
+import { open, constants } from 'fs';
 
 const {
   O_RDWR,
   O_CREAT,
   O_EXCL
-} = fs.constants;
+} = constants;
 
-fs.open('/path/to/my/file', O_RDWR | O_CREAT | O_EXCL, (err, fd) => {
+open('/path/to/my/file', O_RDWR | O_CREAT | O_EXCL, (err, fd) => {
   // ...
 });
 ```
 
-### File access constants
+##### File access constants
 
 The following constants are meant for use with [`fs.access()`][].
 
@@ -5532,7 +6055,7 @@ The following constants are meant for use with [`fs.access()`][].
   </tr>
 </table>
 
-### File copy constants
+##### File copy constants
 
 The following constants are meant for use with [`fs.copyFile()`][].
 
@@ -5560,7 +6083,7 @@ The following constants are meant for use with [`fs.copyFile()`][].
   </tr>
 </table>
 
-### File open constants
+##### File open constants
 
 The following constants are meant for use with `fs.open()`.
 
@@ -5654,9 +6177,9 @@ The following constants are meant for use with `fs.open()`.
   </tr>
 </table>
 
-### File type constants
+##### File type constants
 
-The following constants are meant for use with the [`fs.Stats`][] object's
+The following constants are meant for use with the {fs.Stats} object's
 `mode` property for determining a file's type.
 
 <table>
@@ -5698,9 +6221,9 @@ The following constants are meant for use with the [`fs.Stats`][] object's
   </tr>
 </table>
 
-### File mode constants
+##### File mode constants
 
-The following constants are meant for use with the [`fs.Stats`][] object's
+The following constants are meant for use with the {fs.Stats} object's
 `mode` property for determining the access permissions for a file.
 
 <table>
@@ -5758,7 +6281,321 @@ The following constants are meant for use with the [`fs.Stats`][] object's
   </tr>
 </table>
 
-## File system flags
+## Notes
+
+### Ordering of callback and promise-based operations
+
+Because they are executed asynchronously by the underlying thread pool,
+there is no guaranteed ordering when using either the callback or
+promise-based methods.
+
+For example, the following is prone to error because the `fs.stat()`
+operation might complete before the `fs.rename()` operation:
+
+```js
+fs.rename('/tmp/hello', '/tmp/world', (err) => {
+  if (err) throw err;
+  console.log('renamed complete');
+});
+fs.stat('/tmp/world', (err, stats) => {
+  if (err) throw err;
+  console.log(`stats: ${JSON.stringify(stats)}`);
+});
+```
+
+It is important to correctly order the operations by awaiting the results
+of one before invoking the other:
+
+```mjs
+import { rename, stat } from 'fs/promises';
+
+const from = '/tmp/hello';
+const to = '/tmp/world';
+
+try {
+  await rename(from, to);
+  const stats = await stat(to);
+  console.log(`stats: ${JSON.stringify(stats)}`);
+} catch (error) {
+  console.error('there was an error:', error.message);
+}
+```
+
+```cjs
+const { rename, stat } = require('fs/promises');
+
+(async function(from, to) {
+  try {
+    await rename(from, to);
+    const stats = await stat(to);
+    console.log(`stats: ${JSON.stringify(stats)}`);
+  } catch (error) {
+    console.error('there was an error:', error.message);
+  }
+})('/tmp/hello', '/tmp/world');
+```
+
+Or, when using the callback APIs, move the `fs.stat()` call into the callback
+of the `fs.rename()` operation:
+
+```mjs
+import { rename, stat } from 'fs';
+
+rename('/tmp/hello', '/tmp/world', (err) => {
+  if (err) throw err;
+  stat('/tmp/world', (err, stats) => {
+    if (err) throw err;
+    console.log(`stats: ${JSON.stringify(stats)}`);
+  });
+});
+```
+
+```cjs
+const { rename, stat } = require('fs/promises');
+
+rename('/tmp/hello', '/tmp/world', (err) => {
+  if (err) throw err;
+  stat('/tmp/world', (err, stats) => {
+    if (err) throw err;
+    console.log(`stats: ${JSON.stringify(stats)}`);
+  });
+});
+```
+
+### File paths
+
+Most `fs` operations accept file paths that may be specified in the form of
+a string, a {Buffer}, or a {URL} object using the `file:` protocol.
+
+#### String paths
+
+String form paths are interpreted as UTF-8 character sequences identifying
+the absolute or relative filename. Relative paths will be resolved relative
+to the current working directory as determined by calling `process.cwd()`.
+
+Example using an absolute path on POSIX:
+
+```mjs
+import { open } from 'fs/promises';
+
+let fd;
+try {
+  fd = await open('/open/some/file.txt', 'r');
+  // Do something with the file
+} finally {
+  await fd.close();
+}
+```
+
+Example using a relative path on POSIX (relative to `process.cwd()`):
+
+```mjs
+import { open } from 'fs/promises';
+
+let fd;
+try {
+  fd = await open('file.txt', 'r');
+  // Do something with the file
+} finally {
+  await fd.close();
+}
+```
+
+#### File URL paths
+<!-- YAML
+added: v7.6.0
+-->
+For most `fs` module functions, the `path` or `filename` argument may be passed
+as a {URL} object using the `file:` protocol.
+
+```mjs
+import { readFileSync } from 'fs';
+
+readFileSync(new URL('file:///tmp/hello'));
+```
+
+`file:` URLs are always absolute paths.
+
+##### Platform-specific considerations
+
+On Windows, `file:` {URL}s with a host name convert to UNC paths, while `file:`
+{URL}s with drive letters convert to local absolute paths. `file:` {URL}s
+without a host name nor a drive letter will result in an error:
+
+```mjs
+import { readFileSync } from 'fs';
+// On Windows :
+
+// - WHATWG file URLs with hostname convert to UNC path
+// file://hostname/p/a/t/h/file => \\hostname\p\a\t\h\file
+readFileSync(new URL('file://hostname/p/a/t/h/file'));
+
+// - WHATWG file URLs with drive letters convert to absolute path
+// file:///C:/tmp/hello => C:\tmp\hello
+readFileSync(new URL('file:///C:/tmp/hello'));
+
+// - WHATWG file URLs without hostname must have a drive letters
+readFileSync(new URL('file:///notdriveletter/p/a/t/h/file'));
+readFileSync(new URL('file:///c/p/a/t/h/file'));
+// TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must be absolute
+```
+
+`file:` {URL}s with drive letters must use `:` as a separator just after
+the drive letter. Using another separator will result in an error.
+
+On all other platforms, `file:` {URL}s with a host name are unsupported and
+will result in an error:
+
+```mjs
+import { readFileSync } from 'fs';
+// On other platforms:
+
+// - WHATWG file URLs with hostname are unsupported
+// file://hostname/p/a/t/h/file => throw!
+readFileSync(new URL('file://hostname/p/a/t/h/file'));
+// TypeError [ERR_INVALID_FILE_URL_PATH]: must be absolute
+
+// - WHATWG file URLs convert to absolute path
+// file:///tmp/hello => /tmp/hello
+readFileSync(new URL('file:///tmp/hello'));
+```
+
+A `file:` {URL} having encoded slash characters will result in an error on all
+platforms:
+
+```mjs
+import { readFileSync } from 'fs';
+
+// On Windows
+readFileSync(new URL('file:///C:/p/a/t/h/%2F'));
+readFileSync(new URL('file:///C:/p/a/t/h/%2f'));
+/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+\ or / characters */
+
+// On POSIX
+readFileSync(new URL('file:///p/a/t/h/%2F'));
+readFileSync(new URL('file:///p/a/t/h/%2f'));
+/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+/ characters */
+```
+
+On Windows, `file:` {URL}s having encoded backslash will result in an error:
+
+```mjs
+import { readFileSync } from 'fs';
+
+// On Windows
+readFileSync(new URL('file:///C:/path/%5C'));
+readFileSync(new URL('file:///C:/path/%5c'));
+/* TypeError [ERR_INVALID_FILE_URL_PATH]: File URL path must not include encoded
+\ or / characters */
+```
+
+#### Buffer paths
+
+Paths specified using a {Buffer} are useful primarily on certain POSIX
+operating systems that treat file paths as opaque byte sequences. On such
+systems, it is possible for a single file path to contain sub-sequences that
+use multiple character encodings. As with string paths, {Buffer} paths may
+be relative or absolute:
+
+Example using an absolute path on POSIX:
+
+```mjs
+import { open } from 'fs/promises';
+
+let fd;
+try {
+  fd = await open(Buffer.from('/open/some/file.txt'), 'r');
+  // Do something with the file
+} finally {
+  await fd.close();
+}
+```
+
+#### Per-drive working directories on Windows
+
+On Windows, Node.js follows the concept of per-drive working directory. This
+behavior can be observed when using a drive path without a backslash. For
+example `fs.readdirSync('C:\\')` can potentially return a different result than
+`fs.readdirSync('C:')`. For more information, see
+[this MSDN page][MSDN-Rel-Path].
+
+### File descriptors
+
+On POSIX systems, for every process, the kernel maintains a table of currently
+open files and resources. Each open file is assigned a simple numeric
+identifier called a *file descriptor*. At the system-level, all file system
+operations use these file descriptors to identify and track each specific
+file. Windows systems use a different but conceptually similar mechanism for
+tracking resources. To simplify things for users, Node.js abstracts away the
+differences between operating systems and assigns all open files a numeric file
+descriptor.
+
+The callback-based `fs.open()`, and synchronous `fs.openSync()` methods open a
+file and allocate a new file descriptor. Once allocated, the file descriptor may
+be used to read data from, write data to, or request information about the file.
+
+Operating systems limit the number of file descriptors that may be open
+at any given time so it is critical to close the descriptor when operations
+are completed. Failure to do so will result in a memory leak that will
+eventually cause an application to crash.
+
+```mjs
+import { open, close, fstat } from 'fs';
+
+function closeFd(fd) {
+  close(fd, (err) => {
+    if (err) throw err;
+  });
+}
+
+open('/open/some/file.txt', 'r', (err, fd) => {
+  if (err) throw err;
+  try {
+    fstat(fd, (err, stat) => {
+      if (err) {
+        closeFd(fd);
+        throw err;
+      }
+
+      // use stat
+
+      closeFd(fd);
+    });
+  } catch (err) {
+    closeFd(fd);
+    throw err;
+  }
+});
+```
+
+The promise-based APIs use a {FileHandle} object in place of the numeric
+file descriptor. These objects are better managed by the system to ensure
+that resources are not leaked. However, it is still required that they are
+closed when operations are completed:
+
+```mjs
+import { open } from 'fs/promises';
+
+let file;
+try {
+  file = await open('/open/some/file.txt', 'r');
+  const stat = await file.stat();
+  // use stat
+} finally {
+  await file.close();
+}
+```
+
+### Threadpool usage
+
+All callback and promise-based file system APIs ( with the exception of
+`fs.FSWatcher()`) use libuv's threadpool. This can have surprising and negative
+performance implications for some applications. See the
+[`UV_THREADPOOL_SIZE`][] documentation for more information.
+
+### File system flags
 
 The following flags are available wherever the `flag` option takes a
 string.
@@ -5802,7 +6639,7 @@ string.
 * `'wx'`: Like `'w'` but fails if the path exists.
 
 * `'w+'`: Open file for reading and writing.
-The file is created (if it does not exist) or truncated (if it exists).
+  The file is created (if it does not exist) or truncated (if it exists).
 
 * `'wx+'`: Like `'w+'` but fails if the path exists.
 
@@ -5814,14 +6651,14 @@ or `O_EXCL|O_CREAT` to `CREATE_NEW`, as accepted by `CreateFileW`.
 The exclusive flag `'x'` (`O_EXCL` flag in open(2)) causes the operation to
 return an error if the path already exists. On POSIX, if the path is a symbolic
 link, using `O_EXCL` returns an error even if the link is to a path that does
-not exist. The exclusive flag may or may not work with network file systems.
+not exist. The exclusive flag might not work with network file systems.
 
 On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
 the end of the file.
 
-Modifying a file rather than replacing it may require a flags mode of `'r+'`
-rather than the default mode `'w'`.
+Modifying a file rather than replacing it may require the `flag` option to be
+set to `'r+'` rather than the default `'w'`.
 
 The behavior of some flags are platform-specific. As such, opening a directory
 on macOS and Linux with the `'a+'` flag, as in the example below, will return an
@@ -5847,30 +6684,31 @@ through `fs.open()` or `fs.writeFile()` or `fsPromises.open()`) will fail with
 A call to `fs.ftruncate()` or `filehandle.truncate()` can be used to reset
 the file contents.
 
-[`AHAFS`]: https://www.ibm.com/developerworks/aix/library/au-aix_event_infrastructure/
-[`Buffer.byteLength`]: buffer.html#buffer_static_method_buffer_bytelength_string_encoding
-[`Buffer`]: buffer.html#buffer_buffer
+[#25741]: https://github.com/nodejs/node/issues/25741
+[Common System Errors]: errors.md#errors_common_system_errors
+[File access constants]: #fs_file_access_constants
+[MDN-Date]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
+[MDN-Number]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type
+[MSDN-Rel-Path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths
+[MSDN-Using-Streams]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams
+[Naming Files, Paths, and Namespaces]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file
+[Readable Stream]: stream.md#stream_class_stream_readable
+[Writable Stream]: stream.md#stream_class_stream_writable
+[`AHAFS`]: https://developer.ibm.com/articles/au-aix_event_infrastructure/
+[`Buffer.byteLength`]: buffer.md#buffer_static_method_buffer_bytelength_string_encoding
 [`FSEvents`]: https://developer.apple.com/documentation/coreservices/file_system_events
 [`Number.MAX_SAFE_INTEGER`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
 [`ReadDirectoryChangesW`]: https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw
-[`ReadStream`]: #fs_class_fs_readstream
-[Readable Stream]: stream.html#stream_class_stream_readable
-[`URL`]: url.html#url_the_whatwg_url_api
-[`UV_THREADPOOL_SIZE`]: cli.html#cli_uv_threadpool_size_size
-[`WriteStream`]: #fs_class_fs_writestream
+[`UV_THREADPOOL_SIZE`]: cli.md#cli_uv_threadpool_size_size
 [`event ports`]: https://illumos.org/man/port_create
 [`filehandle.writeFile()`]: #fs_filehandle_writefile_data_options
-[`fs.Dir`]: #fs_class_fs_dir
-[`fs.Dirent`]: #fs_class_fs_dirent
-[`fs.FSWatcher`]: #fs_class_fs_fswatcher
-[`fs.Stats`]: #fs_class_fs_stats
 [`fs.access()`]: #fs_fs_access_path_mode_callback
 [`fs.chmod()`]: #fs_fs_chmod_path_mode_callback
 [`fs.chown()`]: #fs_fs_chown_path_uid_gid_callback
-[`fs.copyFile()`]: #fs_fs_copyfile_src_dest_flags_callback
+[`fs.copyFile()`]: #fs_fs_copyfile_src_dest_mode_callback
 [`fs.createReadStream()`]: #fs_fs_createreadstream_path_options
 [`fs.createWriteStream()`]: #fs_fs_createwritestream_path_options
-[`fs.exists()`]: fs.html#fs_fs_exists_path_callback
+[`fs.exists()`]: #fs_fs_exists_path_callback
 [`fs.fstat()`]: #fs_fs_fstat_fd_options_callback
 [`fs.ftruncate()`]: #fs_fs_ftruncate_fd_len_callback
 [`fs.futimes()`]: #fs_fs_futimes_fd_atime_mtime_callback
@@ -5899,23 +6737,13 @@ the file contents.
 [`fs.writev()`]: #fs_fs_writev_fd_buffers_position_callback
 [`fsPromises.open()`]: #fs_fspromises_open_path_flags_mode
 [`fsPromises.opendir()`]: #fs_fspromises_opendir_path_options
+[`fsPromises.stat()`]: #fs_fspromises_stat_path_options
 [`fsPromises.utimes()`]: #fs_fspromises_utimes_path_atime_mtime
 [`inotify(7)`]: https://man7.org/linux/man-pages/man7/inotify.7.html
 [`kqueue(2)`]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2
-[`net.Socket`]: net.html#net_class_net_socket
-[`stat()`]: fs.html#fs_fs_stat_path_options_callback
-[`util.promisify()`]: util.html#util_util_promisify_original
-[Caveats]: #fs_caveats
-[Common System Errors]: errors.html#errors_common_system_errors
-[FS constants]: #fs_fs_constants_1
-[File access constants]: #fs_file_access_constants
-[MDN-Date]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
-[MDN-Number]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type
-[MSDN-Rel-Path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths
-[MSDN-Using-Streams]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams
-[Naming Files, Paths, and Namespaces]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file
+[`util.promisify()`]: util.md#util_util_promisify_original
 [bigints]: https://tc39.github.io/proposal-bigint
+[caveats]: #fs_caveats
 [chcp]: https://ss64.com/nt/chcp.html
 [inode]: https://en.wikipedia.org/wiki/Inode
 [support of file system `flags`]: #fs_file_system_flags
-[Writable Stream]: #stream_class_stream_writable
diff --git a/doc/api/globals.html b/doc/api/globals.html
index 31bf6997f2e0dcc3d0521631b9254cd9e663e8ba..8a421b021946cf8feb83469e4e015a8601054777 100644
--- a/doc/api/globals.html
+++ b/doc/api/globals.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Global objects | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Global objects | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="globals" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/globals.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/globals.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/globals.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/globals.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/globals.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/globals.html">13.x</a></li>
@@ -118,17 +133,29 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/globals.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/globals.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/globals.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#globals_global_objects">Global objects</a>
 <ul>
+<li><span class="stability_1"><a href="#globals_class_abortcontroller">Class: <code>AbortController</code></a></span>
+<ul>
+<li><a href="#globals_abortcontroller_abort"><code>abortController.abort()</code></a></li>
+<li><a href="#globals_abortcontroller_signal"><code>abortController.signal</code></a></li>
+<li><a href="#globals_class_abortsignal">Class: <code>AbortSignal</code></a>
+<ul>
+<li><a href="#globals_static_method_abortsignal_abort">Static method: <code>AbortSignal.abort()</code></a></li>
+<li><a href="#globals_event_abort">Event: <code>'abort'</code></a></li>
+<li><a href="#globals_abortsignal_aborted"><code>abortSignal.aborted</code></a></li>
+<li><a href="#globals_abortsignal_onabort"><code>abortSignal.onabort</code></a></li>
+</ul>
+</li>
+</ul>
+</li>
 <li><a href="#globals_class_buffer">Class: <code>Buffer</code></a></li>
 <li><a href="#globals_dirname"><code>__dirname</code></a></li>
 <li><a href="#globals_filename"><code>__filename</code></a></li>
@@ -152,11 +179,10 @@
 <li><a href="#globals_webassembly"><code>WebAssembly</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Global objects<span><a class="mark" href="#globals_global_objects" id="globals_global_objects">#</a></span></h1>
+        <h2>Global objects<span><a class="mark" href="#globals_global_objects" id="globals_global_objects">#</a></span></h2>
 
 
 <p>These objects are available in all modules. The following variables may appear
@@ -172,7 +198,97 @@ to be global but are not. They exist only in the scope of modules, see the
 <p>The objects listed here are specific to Node.js. There are <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects">built-in objects</a>
 that are part of the JavaScript language itself, which are also globally
 accessible.</p>
-<h2>Class: <code>Buffer</code><span><a class="mark" href="#globals_class_buffer" id="globals_class_buffer">#</a></span></h2>
+<section><h3>Class: <code>AbortController</code><span><a class="mark" href="#globals_class_abortcontroller" id="globals_class_abortcontroller">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+
+<p>A utility class used to signal cancelation in selected <code>Promise</code>-based APIs.
+The API is based on the Web API <a href="https://developer.mozilla.org/en-US/docs/Web/API/AbortController"><code>AbortController</code></a>.</p>
+<p>To use, launch Node.js using the <code>--experimental-abortcontroller</code> flag.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+
+ac.<span class="hljs-property">signal</span>.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'abort'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Aborted!'</span>),
+                           { <span class="hljs-attr">once</span>: <span class="hljs-literal">true</span> });
+
+ac.<span class="hljs-title function_">abort</span>();
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(ac.<span class="hljs-property">signal</span>.<span class="hljs-property">aborted</span>);  <span class="hljs-comment">// Prints True</span></code></pre>
+<h4><code>abortController.abort()</code><span><a class="mark" href="#globals_abortcontroller_abort" id="globals_abortcontroller_abort">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>Triggers the abort signal, causing the <code>abortController.signal</code> to emit
+the <code>'abort'</code> event.</p>
+<h4><code>abortController.signal</code><span><a class="mark" href="#globals_abortcontroller_signal" id="globals_abortcontroller_signal">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Type: <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a></li>
+</ul>
+<h4>Class: <code>AbortSignal</code><span><a class="mark" href="#globals_class_abortsignal" id="globals_class_abortsignal">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Extends: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a></li>
+</ul>
+<p>The <code>AbortSignal</code> is used to notify observers when the
+<code>abortController.abort()</code> method is called.</p>
+<h5>Static method: <code>AbortSignal.abort()</code><span><a class="mark" href="#globals_static_method_abortsignal_abort" id="globals_static_method_abortsignal_abort">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Returns: <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a></li>
+</ul>
+<p>Returns a new already aborted <code>AbortSignal</code>.</p>
+<h5>Event: <code>'abort'</code><span><a class="mark" href="#globals_event_abort" id="globals_event_abort">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<p>The <code>'abort'</code> event is emitted when the <code>abortController.abort()</code> method
+is called. The callback is invoked with a single object argument with a
+single <code>type</code> property set to <code>'abort'</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+
+<span class="hljs-comment">// Use either the onabort property...</span>
+ac.<span class="hljs-property">signal</span>.<span class="hljs-property">onabort</span> = <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'aborted!'</span>);
+
+<span class="hljs-comment">// Or the EventTarget API...</span>
+ac.<span class="hljs-property">signal</span>.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'abort'</span>, <span class="hljs-function">(<span class="hljs-params">event</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(event.<span class="hljs-property">type</span>);  <span class="hljs-comment">// Prints 'abort'</span>
+}, { <span class="hljs-attr">once</span>: <span class="hljs-literal">true</span> });
+
+ac.<span class="hljs-title function_">abort</span>();</code></pre>
+<p>The <code>AbortController</code> with which the <code>AbortSignal</code> is associated will only
+ever trigger the <code>'abort'</code> event once. We recommended that code check
+that the <code>abortSignal.aborted</code> attribute is <code>false</code> before adding an <code>'abort'</code>
+event listener.</p>
+<p>Any event listeners attached to the <code>AbortSignal</code> should use the
+<code>{ once: true }</code> option (or, if using the <code>EventEmitter</code> APIs to attach a
+listener, use the <code>once()</code> method) to ensure that the event listener is
+removed as soon as the <code>'abort'</code> event is handled. Failure to do so may
+result in memory leaks.</p>
+<h5><code>abortSignal.aborted</code><span><a class="mark" href="#globals_abortsignal_aborted" id="globals_abortsignal_aborted">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> True after the <code>AbortController</code> has been aborted.</li>
+</ul>
+<h5><code>abortSignal.onabort</code><span><a class="mark" href="#globals_abortsignal_onabort" id="globals_abortsignal_onabort">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+</ul>
+<p>An optional callback function that may be set by user code to be notified
+when the <code>abortController.abort()</code> function has been called.</p>
+</section><section><h3>Class: <code>Buffer</code><span><a class="mark" href="#globals_class_buffer" id="globals_class_buffer">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.103</span>
 </div>
@@ -181,29 +297,29 @@ accessible.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <p>Used to handle binary data. See the <a href="buffer.html">buffer section</a>.</p>
-<h2><code>__dirname</code><span><a class="mark" href="#globals_dirname" id="globals_dirname">#</a></span></h2>
+</section><section><h3><code>__dirname</code><span><a class="mark" href="#globals_dirname" id="globals_dirname">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="modules.html#modules_dirname"><code>__dirname</code></a>.</p>
-<h2><code>__filename</code><span><a class="mark" href="#globals_filename" id="globals_filename">#</a></span></h2>
+</section><section><h3><code>__filename</code><span><a class="mark" href="#globals_filename" id="globals_filename">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="modules.html#modules_filename"><code>__filename</code></a>.</p>
-<h2><code>clearImmediate(immediateObject)</code><span><a class="mark" href="#globals_clearimmediate_immediateobject" id="globals_clearimmediate_immediateobject">#</a></span></h2>
+</section><section><h3><code>clearImmediate(immediateObject)</code><span><a class="mark" href="#globals_clearimmediate_immediateobject" id="globals_clearimmediate_immediateobject">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
 
 <p><a href="timers.html#timers_clearimmediate_immediate"><code>clearImmediate</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>clearInterval(intervalObject)</code><span><a class="mark" href="#globals_clearinterval_intervalobject" id="globals_clearinterval_intervalobject">#</a></span></h2>
+</section><section><h3><code>clearInterval(intervalObject)</code><span><a class="mark" href="#globals_clearinterval_intervalobject" id="globals_clearinterval_intervalobject">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 
 <p><a href="timers.html#timers_clearinterval_timeout"><code>clearInterval</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>clearTimeout(timeoutObject)</code><span><a class="mark" href="#globals_cleartimeout_timeoutobject" id="globals_cleartimeout_timeoutobject">#</a></span></h2>
+</section><section><h3><code>clearTimeout(timeoutObject)</code><span><a class="mark" href="#globals_cleartimeout_timeoutobject" id="globals_cleartimeout_timeoutobject">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 
 <p><a href="timers.html#timers_cleartimeout_timeout"><code>clearTimeout</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>console</code><span><a class="mark" href="#globals_console" id="globals_console">#</a></span></h2>
+</section><section><h3><code>console</code><span><a class="mark" href="#globals_console" id="globals_console">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -212,9 +328,9 @@ accessible.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>Used to print to stdout and stderr. See the <a href="console.html"><code>console</code></a> section.</p>
-<h2><code>exports</code><span><a class="mark" href="#globals_exports" id="globals_exports">#</a></span></h2>
+</section><section><h3><code>exports</code><span><a class="mark" href="#globals_exports" id="globals_exports">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="modules.html#modules_exports"><code>exports</code></a>.</p>
-<h2><code>global</code><span><a class="mark" href="#globals_global" id="globals_global">#</a></span></h2>
+</section><section><h3><code>global</code><span><a class="mark" href="#globals_global" id="globals_global">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -226,9 +342,9 @@ accessible.</p>
 within the browser <code>var something</code> will define a new global variable. In
 Node.js this is different. The top-level scope is not the global scope;
 <code>var something</code> inside a Node.js module will be local to that module.</p>
-<h2><code>module</code><span><a class="mark" href="#globals_module" id="globals_module">#</a></span></h2>
+</section><section><h3><code>module</code><span><a class="mark" href="#globals_module" id="globals_module">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="modules.html#modules_module"><code>module</code></a>.</p>
-<h2><code>process</code><span><a class="mark" href="#globals_process" id="globals_process">#</a></span></h2>
+</section><section><h3><code>process</code><span><a class="mark" href="#globals_process" id="globals_process">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.7</span>
 </div>
@@ -237,7 +353,7 @@ Node.js this is different. The top-level scope is not the global scope;
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>The process object. See the <a href="process.html#process_process"><code>process</code> object</a> section.</p>
-<h2><code>queueMicrotask(callback)</code><span><a class="mark" href="#globals_queuemicrotask_callback" id="globals_queuemicrotask_callback">#</a></span></h2>
+</section><section><h3><code>queueMicrotask(callback)</code><span><a class="mark" href="#globals_queuemicrotask_callback" id="globals_queuemicrotask_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
@@ -257,64 +373,64 @@ within each turn of the Node.js event loop.</p>
 <span class="hljs-comment">// `process.nextTick()` here would result in the 'load' event always emitting</span>
 <span class="hljs-comment">// before any other promise jobs.</span>
 
-DataHandler.prototype.load = <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">load</span>(<span class="hljs-params">key</span>) </span>{
-  <span class="hljs-keyword">const</span> hit = <span class="hljs-built_in">this</span>._cache.get(url);
+<span class="hljs-title class_">DataHandler</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">load</span> = <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">load</span>(<span class="hljs-params">key</span>) {
+  <span class="hljs-keyword">const</span> hit = <span class="hljs-variable language_">this</span>.<span class="hljs-property">_cache</span>.<span class="hljs-title function_">get</span>(key);
   <span class="hljs-keyword">if</span> (hit !== <span class="hljs-literal">undefined</span>) {
-    queueMicrotask(<span class="hljs-function">() =></span> {
-      <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'load'</span>, hit);
+    <span class="hljs-title function_">queueMicrotask</span>(<span class="hljs-function">() =></span> {
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'load'</span>, hit);
     });
     <span class="hljs-keyword">return</span>;
   }
 
-  <span class="hljs-keyword">const</span> data = <span class="hljs-keyword">await</span> fetchData(key);
-  <span class="hljs-built_in">this</span>._cache.set(url, data);
-  <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'load'</span>, data);
+  <span class="hljs-keyword">const</span> data = <span class="hljs-keyword">await</span> <span class="hljs-title function_">fetchData</span>(key);
+  <span class="hljs-variable language_">this</span>.<span class="hljs-property">_cache</span>.<span class="hljs-title function_">set</span>(key, data);
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'load'</span>, data);
 };</code></pre>
-<h2><code>require()</code><span><a class="mark" href="#globals_require" id="globals_require">#</a></span></h2>
+</section><section><h3><code>require()</code><span><a class="mark" href="#globals_require" id="globals_require">#</a></span></h3>
 <p>This variable may appear to be global but is not. See <a href="modules.html#modules_require_id"><code>require()</code></a>.</p>
-<h2><code>setImmediate(callback[, ...args])</code><span><a class="mark" href="#globals_setimmediate_callback_args" id="globals_setimmediate_callback_args">#</a></span></h2>
+</section><section><h3><code>setImmediate(callback[, ...args])</code><span><a class="mark" href="#globals_setimmediate_callback_args" id="globals_setimmediate_callback_args">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
 
 <p><a href="timers.html#timers_setimmediate_callback_args"><code>setImmediate</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>setInterval(callback, delay[, ...args])</code><span><a class="mark" href="#globals_setinterval_callback_delay_args" id="globals_setinterval_callback_delay_args">#</a></span></h2>
+</section><section><h3><code>setInterval(callback, delay[, ...args])</code><span><a class="mark" href="#globals_setinterval_callback_delay_args" id="globals_setinterval_callback_delay_args">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 
 <p><a href="timers.html#timers_setinterval_callback_delay_args"><code>setInterval</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>setTimeout(callback, delay[, ...args])</code><span><a class="mark" href="#globals_settimeout_callback_delay_args" id="globals_settimeout_callback_delay_args">#</a></span></h2>
+</section><section><h3><code>setTimeout(callback, delay[, ...args])</code><span><a class="mark" href="#globals_settimeout_callback_delay_args" id="globals_settimeout_callback_delay_args">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 
 <p><a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout</code></a> is described in the <a href="timers.html">timers</a> section.</p>
-<h2><code>TextDecoder</code><span><a class="mark" href="#globals_textdecoder" id="globals_textdecoder">#</a></span></h2>
+</section><section><h3><code>TextDecoder</code><span><a class="mark" href="#globals_textdecoder" id="globals_textdecoder">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
 
 <p>The WHATWG <code>TextDecoder</code> class. See the <a href="util.html#util_class_util_textdecoder"><code>TextDecoder</code></a> section.</p>
-<h2><code>TextEncoder</code><span><a class="mark" href="#globals_textencoder" id="globals_textencoder">#</a></span></h2>
+</section><section><h3><code>TextEncoder</code><span><a class="mark" href="#globals_textencoder" id="globals_textencoder">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
 
 <p>The WHATWG <code>TextEncoder</code> class. See the <a href="util.html#util_class_util_textencoder"><code>TextEncoder</code></a> section.</p>
-<h2><code>URL</code><span><a class="mark" href="#globals_url" id="globals_url">#</a></span></h2>
+</section><section><h3><code>URL</code><span><a class="mark" href="#globals_url" id="globals_url">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 
 <p>The WHATWG <code>URL</code> class. See the <a href="url.html#url_class_url"><code>URL</code></a> section.</p>
-<h2><code>URLSearchParams</code><span><a class="mark" href="#globals_urlsearchparams" id="globals_urlsearchparams">#</a></span></h2>
+</section><section><h3><code>URLSearchParams</code><span><a class="mark" href="#globals_urlsearchparams" id="globals_urlsearchparams">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 
 <p>The WHATWG <code>URLSearchParams</code> class. See the <a href="url.html#url_class_urlsearchparams"><code>URLSearchParams</code></a> section.</p>
-<h2><code>WebAssembly</code><span><a class="mark" href="#globals_webassembly" id="globals_webassembly">#</a></span></h2>
+</section><section><h3><code>WebAssembly</code><span><a class="mark" href="#globals_webassembly" id="globals_webassembly">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -324,10 +440,46 @@ DataHandler.prototype.load = <span class="hljs-keyword">async</span> <span class
 </ul>
 <p>The object that acts as the namespace for all W3C
 <a href="https://webassembly.org">WebAssembly</a> related functionality. See the
-<a href="https://developer.mozilla.org/en-US/docs/WebAssembly">Mozilla Developer Network</a> for usage and compatibility.</p>
+<a href="https://developer.mozilla.org/en-US/docs/WebAssembly">Mozilla Developer Network</a> for usage and compatibility.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/globals.json b/doc/api/globals.json
index 63d679c31e6b93cb9fe0e7827696b40024c62160..566fb87c3479a4245818644052ea3570799e95b2 100644
--- a/doc/api/globals.json
+++ b/doc/api/globals.json
@@ -3,6 +3,131 @@
   "source": "doc/api/globals.md",
   "introduced_in": "v0.10.0",
   "globals": [
+    {
+      "textRaw": "Class: `AbortController`",
+      "type": "global",
+      "name": "AbortController",
+      "meta": {
+        "added": [
+          "v14.17.0"
+        ],
+        "changes": []
+      },
+      "stability": 1,
+      "stabilityText": "Experimental",
+      "desc": "<p>A utility class used to signal cancelation in selected <code>Promise</code>-based APIs.\nThe API is based on the Web API <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/AbortController\"><code>AbortController</code></a>.</p>\n<p>To use, launch Node.js using the <code>--experimental-abortcontroller</code> flag.</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\n\nac.signal.addEventListener('abort', () => console.log('Aborted!'),\n                           { once: true });\n\nac.abort();\n\nconsole.log(ac.signal.aborted);  // Prints True\n</code></pre>",
+      "methods": [
+        {
+          "textRaw": "`abortController.abort()`",
+          "type": "method",
+          "name": "abort",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<p>Triggers the abort signal, causing the <code>abortController.signal</code> to emit\nthe <code>'abort'</code> event.</p>"
+        }
+      ],
+      "properties": [
+        {
+          "textRaw": "`signal` Type: {AbortSignal}",
+          "type": "AbortSignal",
+          "name": "Type",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          }
+        }
+      ],
+      "classes": [
+        {
+          "textRaw": "Class: `AbortSignal`",
+          "type": "class",
+          "name": "AbortSignal",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventtarget\" class=\"type\">&lt;EventTarget&gt;</a></li>\n</ul>\n<p>The <code>AbortSignal</code> is used to notify observers when the\n<code>abortController.abort()</code> method is called.</p>",
+          "classMethods": [
+            {
+              "textRaw": "Static method: `AbortSignal.abort()`",
+              "type": "classMethod",
+              "name": "abort",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {AbortSignal}",
+                    "name": "return",
+                    "type": "AbortSignal"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns a new already aborted <code>AbortSignal</code>.</p>"
+            }
+          ],
+          "events": [
+            {
+              "textRaw": "Event: `'abort'`",
+              "type": "event",
+              "name": "abort",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>The <code>'abort'</code> event is emitted when the <code>abortController.abort()</code> method\nis called. The callback is invoked with a single object argument with a\nsingle <code>type</code> property set to <code>'abort'</code>:</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\n\n// Use either the onabort property...\nac.signal.onabort = () => console.log('aborted!');\n\n// Or the EventTarget API...\nac.signal.addEventListener('abort', (event) => {\n  console.log(event.type);  // Prints 'abort'\n}, { once: true });\n\nac.abort();\n</code></pre>\n<p>The <code>AbortController</code> with which the <code>AbortSignal</code> is associated will only\never trigger the <code>'abort'</code> event once. We recommended that code check\nthat the <code>abortSignal.aborted</code> attribute is <code>false</code> before adding an <code>'abort'</code>\nevent listener.</p>\n<p>Any event listeners attached to the <code>AbortSignal</code> should use the\n<code>{ once: true }</code> option (or, if using the <code>EventEmitter</code> APIs to attach a\nlistener, use the <code>once()</code> method) to ensure that the event listener is\nremoved as soon as the <code>'abort'</code> event is handled. Failure to do so may\nresult in memory leaks.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`aborted` Type: {boolean} True after the `AbortController` has been aborted.",
+              "type": "boolean",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "True after the `AbortController` has been aborted."
+            },
+            {
+              "textRaw": "`onabort` Type: {Function}",
+              "type": "Function",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>An optional callback function that may be set by user code to be notified\nwhen the <code>abortController.abort()</code> function has been called.</p>"
+            }
+          ]
+        }
+      ]
+    },
     {
       "textRaw": "Class: `Buffer`",
       "type": "global",
@@ -97,7 +222,7 @@
         ],
         "changes": []
       },
-      "desc": "<ul>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a> Function to be queued.</li>\n</ul>\n<p>The <code>queueMicrotask()</code> method queues a microtask to invoke <code>callback</code>. If\n<code>callback</code> throws an exception, the <a href=\"process.html#process_process\"><code>process</code> object</a> <code>'uncaughtException'</code>\nevent will be emitted.</p>\n<p>The microtask queue is managed by V8 and may be used in a similar manner to\nthe <a href=\"process.html#process_process_nexttick_callback_args\"><code>process.nextTick()</code></a> queue, which is managed by Node.js. The\n<code>process.nextTick()</code> queue is always processed before the microtask queue\nwithin each turn of the Node.js event loop.</p>\n<pre><code class=\"language-js\">// Here, `queueMicrotask()` is used to ensure the 'load' event is always\n// emitted asynchronously, and therefore consistently. Using\n// `process.nextTick()` here would result in the 'load' event always emitting\n// before any other promise jobs.\n\nDataHandler.prototype.load = async function load(key) {\n  const hit = this._cache.get(url);\n  if (hit !== undefined) {\n    queueMicrotask(() => {\n      this.emit('load', hit);\n    });\n    return;\n  }\n\n  const data = await fetchData(key);\n  this._cache.set(url, data);\n  this.emit('load', data);\n};\n</code></pre>"
+      "desc": "<ul>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a> Function to be queued.</li>\n</ul>\n<p>The <code>queueMicrotask()</code> method queues a microtask to invoke <code>callback</code>. If\n<code>callback</code> throws an exception, the <a href=\"process.html#process_process\"><code>process</code> object</a> <code>'uncaughtException'</code>\nevent will be emitted.</p>\n<p>The microtask queue is managed by V8 and may be used in a similar manner to\nthe <a href=\"process.html#process_process_nexttick_callback_args\"><code>process.nextTick()</code></a> queue, which is managed by Node.js. The\n<code>process.nextTick()</code> queue is always processed before the microtask queue\nwithin each turn of the Node.js event loop.</p>\n<pre><code class=\"language-js\">// Here, `queueMicrotask()` is used to ensure the 'load' event is always\n// emitted asynchronously, and therefore consistently. Using\n// `process.nextTick()` here would result in the 'load' event always emitting\n// before any other promise jobs.\n\nDataHandler.prototype.load = async function load(key) {\n  const hit = this._cache.get(key);\n  if (hit !== undefined) {\n    queueMicrotask(() => {\n      this.emit('load', hit);\n    });\n    return;\n  }\n\n  const data = await fetchData(key);\n  this._cache.set(key, data);\n  this.emit('load', data);\n};\n</code></pre>"
     },
     {
       "textRaw": "`setImmediate(callback[, ...args])`",
@@ -217,6 +342,131 @@
       "type": "misc",
       "desc": "<p>These objects are available in all modules. The following variables may appear\nto be global but are not. They exist only in the scope of modules, see the\n<a href=\"modules.html\">module system documentation</a>:</p>\n<ul>\n<li><a href=\"modules.html#modules_dirname\"><code>__dirname</code></a></li>\n<li><a href=\"modules.html#modules_filename\"><code>__filename</code></a></li>\n<li><a href=\"modules.html#modules_exports\"><code>exports</code></a></li>\n<li><a href=\"modules.html#modules_module\"><code>module</code></a></li>\n<li><a href=\"modules.html#modules_require_id\"><code>require()</code></a></li>\n</ul>\n<p>The objects listed here are specific to Node.js. There are <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects\">built-in objects</a>\nthat are part of the JavaScript language itself, which are also globally\naccessible.</p>",
       "globals": [
+        {
+          "textRaw": "Class: `AbortController`",
+          "type": "global",
+          "name": "AbortController",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "desc": "<p>A utility class used to signal cancelation in selected <code>Promise</code>-based APIs.\nThe API is based on the Web API <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/AbortController\"><code>AbortController</code></a>.</p>\n<p>To use, launch Node.js using the <code>--experimental-abortcontroller</code> flag.</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\n\nac.signal.addEventListener('abort', () => console.log('Aborted!'),\n                           { once: true });\n\nac.abort();\n\nconsole.log(ac.signal.aborted);  // Prints True\n</code></pre>",
+          "methods": [
+            {
+              "textRaw": "`abortController.abort()`",
+              "type": "method",
+              "name": "abort",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Triggers the abort signal, causing the <code>abortController.signal</code> to emit\nthe <code>'abort'</code> event.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`signal` Type: {AbortSignal}",
+              "type": "AbortSignal",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              }
+            }
+          ],
+          "classes": [
+            {
+              "textRaw": "Class: `AbortSignal`",
+              "type": "class",
+              "name": "AbortSignal",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventtarget\" class=\"type\">&lt;EventTarget&gt;</a></li>\n</ul>\n<p>The <code>AbortSignal</code> is used to notify observers when the\n<code>abortController.abort()</code> method is called.</p>",
+              "classMethods": [
+                {
+                  "textRaw": "Static method: `AbortSignal.abort()`",
+                  "type": "classMethod",
+                  "name": "abort",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "return": {
+                        "textRaw": "Returns: {AbortSignal}",
+                        "name": "return",
+                        "type": "AbortSignal"
+                      },
+                      "params": []
+                    }
+                  ],
+                  "desc": "<p>Returns a new already aborted <code>AbortSignal</code>.</p>"
+                }
+              ],
+              "events": [
+                {
+                  "textRaw": "Event: `'abort'`",
+                  "type": "event",
+                  "name": "abort",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [],
+                  "desc": "<p>The <code>'abort'</code> event is emitted when the <code>abortController.abort()</code> method\nis called. The callback is invoked with a single object argument with a\nsingle <code>type</code> property set to <code>'abort'</code>:</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\n\n// Use either the onabort property...\nac.signal.onabort = () => console.log('aborted!');\n\n// Or the EventTarget API...\nac.signal.addEventListener('abort', (event) => {\n  console.log(event.type);  // Prints 'abort'\n}, { once: true });\n\nac.abort();\n</code></pre>\n<p>The <code>AbortController</code> with which the <code>AbortSignal</code> is associated will only\never trigger the <code>'abort'</code> event once. We recommended that code check\nthat the <code>abortSignal.aborted</code> attribute is <code>false</code> before adding an <code>'abort'</code>\nevent listener.</p>\n<p>Any event listeners attached to the <code>AbortSignal</code> should use the\n<code>{ once: true }</code> option (or, if using the <code>EventEmitter</code> APIs to attach a\nlistener, use the <code>once()</code> method) to ensure that the event listener is\nremoved as soon as the <code>'abort'</code> event is handled. Failure to do so may\nresult in memory leaks.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`aborted` Type: {boolean} True after the `AbortController` has been aborted.",
+                  "type": "boolean",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "True after the `AbortController` has been aborted."
+                },
+                {
+                  "textRaw": "`onabort` Type: {Function}",
+                  "type": "Function",
+                  "name": "Type",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>An optional callback function that may be set by user code to be notified\nwhen the <code>abortController.abort()</code> function has been called.</p>"
+                }
+              ]
+            }
+          ]
+        },
         {
           "textRaw": "Class: `Buffer`",
           "type": "global",
@@ -311,7 +561,7 @@
             ],
             "changes": []
           },
-          "desc": "<ul>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a> Function to be queued.</li>\n</ul>\n<p>The <code>queueMicrotask()</code> method queues a microtask to invoke <code>callback</code>. If\n<code>callback</code> throws an exception, the <a href=\"process.html#process_process\"><code>process</code> object</a> <code>'uncaughtException'</code>\nevent will be emitted.</p>\n<p>The microtask queue is managed by V8 and may be used in a similar manner to\nthe <a href=\"process.html#process_process_nexttick_callback_args\"><code>process.nextTick()</code></a> queue, which is managed by Node.js. The\n<code>process.nextTick()</code> queue is always processed before the microtask queue\nwithin each turn of the Node.js event loop.</p>\n<pre><code class=\"language-js\">// Here, `queueMicrotask()` is used to ensure the 'load' event is always\n// emitted asynchronously, and therefore consistently. Using\n// `process.nextTick()` here would result in the 'load' event always emitting\n// before any other promise jobs.\n\nDataHandler.prototype.load = async function load(key) {\n  const hit = this._cache.get(url);\n  if (hit !== undefined) {\n    queueMicrotask(() => {\n      this.emit('load', hit);\n    });\n    return;\n  }\n\n  const data = await fetchData(key);\n  this._cache.set(url, data);\n  this.emit('load', data);\n};\n</code></pre>"
+          "desc": "<ul>\n<li><code>callback</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\" class=\"type\">&lt;Function&gt;</a> Function to be queued.</li>\n</ul>\n<p>The <code>queueMicrotask()</code> method queues a microtask to invoke <code>callback</code>. If\n<code>callback</code> throws an exception, the <a href=\"process.html#process_process\"><code>process</code> object</a> <code>'uncaughtException'</code>\nevent will be emitted.</p>\n<p>The microtask queue is managed by V8 and may be used in a similar manner to\nthe <a href=\"process.html#process_process_nexttick_callback_args\"><code>process.nextTick()</code></a> queue, which is managed by Node.js. The\n<code>process.nextTick()</code> queue is always processed before the microtask queue\nwithin each turn of the Node.js event loop.</p>\n<pre><code class=\"language-js\">// Here, `queueMicrotask()` is used to ensure the 'load' event is always\n// emitted asynchronously, and therefore consistently. Using\n// `process.nextTick()` here would result in the 'load' event always emitting\n// before any other promise jobs.\n\nDataHandler.prototype.load = async function load(key) {\n  const hit = this._cache.get(key);\n  if (hit !== undefined) {\n    queueMicrotask(() => {\n      this.emit('load', hit);\n    });\n    return;\n  }\n\n  const data = await fetchData(key);\n  this._cache.set(key, data);\n  this.emit('load', data);\n};\n</code></pre>"
         },
         {
           "textRaw": "`setImmediate(callback[, ...args])`",
diff --git a/doc/api/globals.md b/doc/api/globals.md
index 4e2e362bcdeb5bca2125cf0ff6eafc03d74b60ea..a824f50899bd975ef60e0730c46f7ce61e91126e 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -17,6 +17,116 @@ The objects listed here are specific to Node.js. There are [built-in objects][]
 that are part of the JavaScript language itself, which are also globally
 accessible.
 
+## Class: `AbortController`
+<!-- YAML
+added: v14.17.0
+-->
+
+> Stability: 1 - Experimental
+
+<!-- type=global -->
+
+A utility class used to signal cancelation in selected `Promise`-based APIs.
+The API is based on the Web API [`AbortController`][].
+
+To use, launch Node.js using the `--experimental-abortcontroller` flag.
+
+```js
+const ac = new AbortController();
+
+ac.signal.addEventListener('abort', () => console.log('Aborted!'),
+                           { once: true });
+
+ac.abort();
+
+console.log(ac.signal.aborted);  // Prints True
+```
+
+### `abortController.abort()`
+<!-- YAML
+added: v14.17.0
+-->
+
+Triggers the abort signal, causing the `abortController.signal` to emit
+the `'abort'` event.
+
+### `abortController.signal`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Type: {AbortSignal}
+
+### Class: `AbortSignal`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Extends: {EventTarget}
+
+The `AbortSignal` is used to notify observers when the
+`abortController.abort()` method is called.
+
+#### Static method: `AbortSignal.abort()`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Returns: {AbortSignal}
+
+Returns a new already aborted `AbortSignal`.
+
+#### Event: `'abort'`
+<!-- YAML
+added: v14.17.0
+-->
+
+The `'abort'` event is emitted when the `abortController.abort()` method
+is called. The callback is invoked with a single object argument with a
+single `type` property set to `'abort'`:
+
+```js
+const ac = new AbortController();
+
+// Use either the onabort property...
+ac.signal.onabort = () => console.log('aborted!');
+
+// Or the EventTarget API...
+ac.signal.addEventListener('abort', (event) => {
+  console.log(event.type);  // Prints 'abort'
+}, { once: true });
+
+ac.abort();
+```
+
+The `AbortController` with which the `AbortSignal` is associated will only
+ever trigger the `'abort'` event once. We recommended that code check
+that the `abortSignal.aborted` attribute is `false` before adding an `'abort'`
+event listener.
+
+Any event listeners attached to the `AbortSignal` should use the
+`{ once: true }` option (or, if using the `EventEmitter` APIs to attach a
+listener, use the `once()` method) to ensure that the event listener is
+removed as soon as the `'abort'` event is handled. Failure to do so may
+result in memory leaks.
+
+#### `abortSignal.aborted`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Type: {boolean} True after the `AbortController` has been aborted.
+
+#### `abortSignal.onabort`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Type: {Function}
+
+An optional callback function that may be set by user code to be notified
+when the `abortController.abort()` function has been called.
+
 ## Class: `Buffer`
 <!-- YAML
 added: v0.1.103
@@ -132,7 +242,7 @@ within each turn of the Node.js event loop.
 // before any other promise jobs.
 
 DataHandler.prototype.load = async function load(key) {
-  const hit = this._cache.get(url);
+  const hit = this._cache.get(key);
   if (hit !== undefined) {
     queueMicrotask(() => {
       this.emit('load', hit);
@@ -141,7 +251,7 @@ DataHandler.prototype.load = async function load(key) {
   }
 
   const data = await fetchData(key);
-  this._cache.set(url, data);
+  this._cache.set(key, data);
   this.emit('load', data);
 };
 ```
@@ -226,27 +336,28 @@ The object that acts as the namespace for all W3C
 [WebAssembly][webassembly-org] related functionality. See the
 [Mozilla Developer Network][webassembly-mdn] for usage and compatibility.
 
-[`TextDecoder`]: util.html#util_class_util_textdecoder
-[`TextEncoder`]: util.html#util_class_util_textencoder
-[`URLSearchParams`]: url.html#url_class_urlsearchparams
-[`URL`]: url.html#url_class_url
-[`__dirname`]: modules.html#modules_dirname
-[`__filename`]: modules.html#modules_filename
-[`clearImmediate`]: timers.html#timers_clearimmediate_immediate
-[`clearInterval`]: timers.html#timers_clearinterval_timeout
-[`clearTimeout`]: timers.html#timers_cleartimeout_timeout
-[`console`]: console.html
-[`exports`]: modules.html#modules_exports
-[`module`]: modules.html#modules_module
-[`process.nextTick()`]: process.html#process_process_nexttick_callback_args
-[`process` object]: process.html#process_process
-[`require()`]: modules.html#modules_require_id
-[`setImmediate`]: timers.html#timers_setimmediate_callback_args
-[`setInterval`]: timers.html#timers_setinterval_callback_delay_args
-[`setTimeout`]: timers.html#timers_settimeout_callback_delay_args
-[buffer section]: buffer.html
+[`AbortController`]: https://developer.mozilla.org/en-US/docs/Web/API/AbortController
+[`TextDecoder`]: util.md#util_class_util_textdecoder
+[`TextEncoder`]: util.md#util_class_util_textencoder
+[`URLSearchParams`]: url.md#url_class_urlsearchparams
+[`URL`]: url.md#url_class_url
+[`__dirname`]: modules.md#modules_dirname
+[`__filename`]: modules.md#modules_filename
+[`clearImmediate`]: timers.md#timers_clearimmediate_immediate
+[`clearInterval`]: timers.md#timers_clearinterval_timeout
+[`clearTimeout`]: timers.md#timers_cleartimeout_timeout
+[`console`]: console.md
+[`exports`]: modules.md#modules_exports
+[`module`]: modules.md#modules_module
+[`process.nextTick()`]: process.md#process_process_nexttick_callback_args
+[`process` object]: process.md#process_process
+[`require()`]: modules.md#modules_require_id
+[`setImmediate`]: timers.md#timers_setimmediate_callback_args
+[`setInterval`]: timers.md#timers_setinterval_callback_delay_args
+[`setTimeout`]: timers.md#timers_settimeout_callback_delay_args
+[buffer section]: buffer.md
 [built-in objects]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
-[module system documentation]: modules.html
-[timers]: timers.html
+[module system documentation]: modules.md
+[timers]: timers.md
 [webassembly-mdn]: https://developer.mozilla.org/en-US/docs/WebAssembly
 [webassembly-org]: https://webassembly.org
diff --git a/doc/api/http.html b/doc/api/http.html
index 29039fe7fb5284b8a14d5aed514b89dc4d2a2d8f..3380cc15a36866774b776f4ad274dcc7180dc8f3 100644
--- a/doc/api/http.html
+++ b/doc/api/http.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>HTTP | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>HTTP | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="http" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/http.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/http.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/http.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/http.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/http.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/http.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/http.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/http.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/http.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#http_http">HTTP</a></span>
 <ul>
 <li><a href="#http_class_http_agent">Class: <code>http.Agent</code></a>
@@ -155,13 +168,19 @@
 <li><a href="#http_event_socket">Event: <code>'socket'</code></a></li>
 <li><a href="#http_event_timeout">Event: <code>'timeout'</code></a></li>
 <li><a href="#http_event_upgrade">Event: <code>'upgrade'</code></a></li>
-<li><a href="#http_request_abort"><code>request.abort()</code></a></li>
+<li><span class="stability_0"><a href="#http_request_abort"><code>request.abort()</code></a></span></li>
 <li><a href="#http_request_aborted"><code>request.aborted</code></a></li>
-<li><a href="#http_request_connection"><code>request.connection</code></a></li>
+<li><span class="stability_0"><a href="#http_request_connection"><code>request.connection</code></a></span></li>
 <li><a href="#http_request_end_data_encoding_callback"><code>request.end([data[, encoding]][, callback])</code></a></li>
+<li><a href="#http_request_destroy_error"><code>request.destroy([error])</code></a>
+<ul>
+<li><a href="#http_request_destroyed"><code>request.destroyed</code></a></li>
+</ul>
+</li>
 <li><span class="stability_0"><a href="#http_request_finished"><code>request.finished</code></a></span></li>
 <li><a href="#http_request_flushheaders"><code>request.flushHeaders()</code></a></li>
 <li><a href="#http_request_getheader_name"><code>request.getHeader(name)</code></a></li>
+<li><a href="#http_request_getrawheadernames"><code>request.getRawHeaderNames()</code></a></li>
 <li><a href="#http_request_maxheaderscount"><code>request.maxHeadersCount</code></a></li>
 <li><a href="#http_request_path"><code>request.path</code></a></li>
 <li><a href="#http_request_method"><code>request.method</code></a></li>
@@ -194,6 +213,7 @@
 <li><a href="#http_server_listen"><code>server.listen()</code></a></li>
 <li><a href="#http_server_listening"><code>server.listening</code></a></li>
 <li><a href="#http_server_maxheaderscount"><code>server.maxHeadersCount</code></a></li>
+<li><a href="#http_server_requesttimeout"><code>server.requestTimeout</code></a></li>
 <li><a href="#http_server_settimeout_msecs_callback"><code>server.setTimeout([msecs][, callback])</code></a></li>
 <li><a href="#http_server_timeout"><code>server.timeout</code></a></li>
 <li><a href="#http_server_keepalivetimeout"><code>server.keepAliveTimeout</code></a></li>
@@ -204,7 +224,7 @@
 <li><a href="#http_event_close_1">Event: <code>'close'</code></a></li>
 <li><a href="#http_event_finish">Event: <code>'finish'</code></a></li>
 <li><a href="#http_response_addtrailers_headers"><code>response.addTrailers(headers)</code></a></li>
-<li><a href="#http_response_connection"><code>response.connection</code></a></li>
+<li><span class="stability_0"><a href="#http_response_connection"><code>response.connection</code></a></span></li>
 <li><a href="#http_response_cork"><code>response.cork()</code></a></li>
 <li><a href="#http_response_end_data_encoding_callback"><code>response.end([data[, encoding]][, callback])</code></a></li>
 <li><span class="stability_0"><a href="#http_response_finished"><code>response.finished</code></a></span></li>
@@ -250,6 +270,37 @@
 <li><a href="#http_message_url"><code>message.url</code></a></li>
 </ul>
 </li>
+<li><a href="#http_class_http_outgoingmessage">Class: <code>http.OutgoingMessage</code></a>
+<ul>
+<li><a href="#http_event_drain">Event: <code>drain</code></a></li>
+<li><a href="#http_event_finish_1">Event: <code>finish</code></a></li>
+<li><a href="#http_event_prefinish">Event: <code>prefinish</code></a></li>
+<li><a href="#http_outgoingmessage_addtrailers_headers"><code>outgoingMessage.addTrailers(headers)</code></a></li>
+<li><span class="stability_0"><a href="#http_outgoingmessage_connection"><code>outgoingMessage.connection</code></a></span></li>
+<li><a href="#http_outgoingmessage_cork"><code>outgoingMessage.cork()</code></a></li>
+<li><a href="#http_outgoingmessage_destroy_error"><code>outgoingMessage.destroy([error])</code></a></li>
+<li><a href="#http_outgoingmessage_end_chunk_encoding_callback"><code>outgoingMessage.end(chunk[, encoding][, callback])</code></a></li>
+<li><a href="#http_outgoingmessage_flushheaders"><code>outgoingMessage.flushHeaders()</code></a></li>
+<li><a href="#http_outgoingmessage_getheader_name"><code>outgoingMessage.getHeader(name)</code></a></li>
+<li><a href="#http_outgoingmessage_getheadernames"><code>outgoingMessage.getHeaderNames()</code></a></li>
+<li><a href="#http_outgoingmessage_getheaders"><code>outgoingMessage.getHeaders()</code></a></li>
+<li><a href="#http_outgoingmessage_hasheader_name"><code>outgoingMessage.hasHeader(name)</code></a></li>
+<li><a href="#http_outgoingmessage_headerssent"><code>outgoingMessage.headersSent</code></a></li>
+<li><a href="#http_outgoingmessage_pipe"><code>outgoingMessage.pipe()</code></a></li>
+<li><a href="#http_outgoingmessage_removeheader"><code>outgoingMessage.removeHeader()</code></a></li>
+<li><a href="#http_outgoingmessage_setheader_name_value"><code>outgoingMessage.setHeader(name, value)</code></a></li>
+<li><a href="#http_outgoingmessage_settimeout_msesc_callback"><code>outgoingMessage.setTimeout(msesc[, callback])</code></a></li>
+<li><a href="#http_outgoingmessage_socket"><code>outgoingMessage.socket</code></a></li>
+<li><a href="#http_outgoingmessage_uncork"><code>outgoingMessage.uncork()</code></a></li>
+<li><a href="#http_outgoingmessage_writablecorked"><code>outgoingMessage.writableCorked</code></a></li>
+<li><a href="#http_outgoingmessage_writableended"><code>outgoingMessage.writableEnded</code></a></li>
+<li><a href="#http_outgoingmessage_writablefinished"><code>outgoingMessage.writableFinished</code></a></li>
+<li><a href="#http_outgoingmessage_writablehighwatermark"><code>outgoingMessage.writableHighWaterMark</code></a></li>
+<li><a href="#http_outgoingmessage_writablelength"><code>outgoingMessage.writableLength</code></a></li>
+<li><a href="#http_outgoingmessage_writableobjectmode"><code>outgoingMessage.writableObjectMode</code></a></li>
+<li><a href="#http_outgoingmessage_write_chunk_encoding_callback"><code>outgoingMessage.write(chunk[, encoding][, callback])</code></a></li>
+</ul>
+</li>
 <li><a href="#http_http_methods"><code>http.METHODS</code></a></li>
 <li><a href="#http_http_status_codes"><code>http.STATUS_CODES</code></a></li>
 <li><a href="#http_http_createserver_options_requestlistener"><code>http.createServer([options][, requestListener])</code></a></li>
@@ -259,16 +310,17 @@
 <li><a href="#http_http_maxheadersize"><code>http.maxHeaderSize</code></a></li>
 <li><a href="#http_http_request_options_callback"><code>http.request(options[, callback])</code></a></li>
 <li><a href="#http_http_request_url_options_callback"><code>http.request(url[, options][, callback])</code></a></li>
+<li><a href="#http_http_validateheadername_name"><code>http.validateHeaderName(name)</code></a></li>
+<li><a href="#http_http_validateheadervalue_name_value"><code>http.validateHeaderValue(name, value)</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>HTTP<span><a class="mark" href="#http_http" id="http_http">#</a></span></h1>
+        <h2>HTTP<span><a class="mark" href="#http_http" id="http_http">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/http.js">lib/http.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/http.js">lib/http.js</a></p>
 <p>To use the HTTP server and client one must <code>require('http')</code>.</p>
 <p>The HTTP interfaces in Node.js are designed to support many features
 of the protocol which have been traditionally difficult to use.
@@ -299,7 +351,7 @@ list like the following:</p>
   <span class="hljs-string">'CONNECTION'</span>, <span class="hljs-string">'keep-alive'</span>,
   <span class="hljs-string">'Host'</span>, <span class="hljs-string">'mysite.com'</span>,
   <span class="hljs-string">'accepT'</span>, <span class="hljs-string">'*/*'</span> ]</code></pre>
-<h2>Class: <code>http.Agent</code><span><a class="mark" href="#http_class_http_agent" id="http_class_http_agent">#</a></span></h2>
+<section><h3>Class: <code>http.Agent</code><span><a class="mark" href="#http_class_http_agent" id="http_class_http_agent">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -327,17 +379,17 @@ longer in use, because unused sockets consume OS resources.</p>
 a <code>'close'</code> event or an <code>'agentRemove'</code> event. When intending to keep one
 HTTP request open for a long time without keeping it in the agent, something
 like the following may be done:</p>
-<pre><code class="language-js">http.get(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<pre><code class="language-js">http.<span class="hljs-title function_">get</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// Do stuff</span>
-}).on(<span class="hljs-string">'socket'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  socket.emit(<span class="hljs-string">'agentRemove'</span>);
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'socket'</span>, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  socket.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'agentRemove'</span>);
 });</code></pre>
 <p>An agent may also be used for an individual request. By providing
 <code>{agent: false}</code> as an option to the <code>http.get()</code> or <code>http.request()</code>
 functions, a one-time use <code>Agent</code> with default options will be used
 for the client connection.</p>
 <p><code>agent:false</code>:</p>
-<pre><code class="language-js">http.get({
+<pre><code class="language-js">http.<span class="hljs-title function_">get</span>({
   <span class="hljs-attr">hostname</span>: <span class="hljs-string">'localhost'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">80</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
@@ -345,15 +397,17 @@ for the client connection.</p>
 }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// Do stuff with response</span>
 });</code></pre>
-<h3><code>new Agent([options])</code><span><a class="mark" href="#http_new_agent_options" id="http_new_agent_options">#</a></span></h3>
+<h4><code>new Agent([options])</code><span><a class="mark" href="#http_new_agent_options" id="http_new_agent_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.20.0</td>
-<td><p>Add <code>scheduling</code> option to specify the free socket scheduling strategy.</p></td></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.17.0</td>
+<td><p>Change the default scheduling from 'fifo' to 'lifo'.</p></td></tr>
+<tr><td>v14.5.0</td>
 <td><p>Add <code>maxTotalSockets</code> option to agent constructor.</p></td></tr>
+<tr><td>v14.5.0</td>
+<td><p>Add <code>scheduling</code> option to specify the free socket scheduling strategy.</p></td></tr>
 <tr><td>v0.3.4</td>
 <td><p><span>Added in: v0.3.4</span></p></td></tr>
 </tbody></table>
@@ -375,8 +429,14 @@ options are respectively set to <code>false</code> and <code>Infinity</code>, in
 the <a href="net.html#net_socket_setkeepalive_enable_initialdelay">initial delay</a>
 for TCP Keep-Alive packets. Ignored when the
 <code>keepAlive</code> option is <code>false</code> or <code>undefined</code>. <strong>Default:</strong> <code>1000</code>.</li>
-<li><code>maxSockets</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Maximum number of sockets to allow per
-host. Each request will use a new socket until the maximum is reached.
+<li><code>maxSockets</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Maximum number of sockets to allow per host.
+If the same host opens multiple concurrent connections, each request
+will use new socket until the <code>maxSockets</code> value is reached.
+If the host attempts to open more connections than <code>maxSockets</code>,
+the additional requests will enter into a pending request queue, and
+will enter active connection state when an existing connection terminates.
+This makes sure there are at most <code>maxSockets</code> active connections at
+any point in time, from a given host.
 <strong>Default:</strong> <code>Infinity</code>.</li>
 <li><code>maxTotalSockets</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Maximum number of sockets allowed for
 all hosts in total. Each request will use a new socket
@@ -396,7 +456,7 @@ by the server due to inactivity.
 In case of a high rate of request per second,
 the <code>'fifo'</code> scheduling will maximize the number of open sockets,
 while the <code>'lifo'</code> scheduling will keep it as low as possible.
-<strong>Default:</strong> <code>'fifo'</code>.</li>
+<strong>Default:</strong> <code>'lifo'</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Socket timeout in milliseconds.
 This will set the timeout when the socket is created.</li>
 </ul>
@@ -407,10 +467,10 @@ This will set the timeout when the socket is created.</li>
 of these values set to their respective defaults.</p>
 <p>To configure any of them, a custom <a href="#http_class_http_agent"><code>http.Agent</code></a> instance must be created.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> keepAliveAgent = <span class="hljs-keyword">new</span> http.Agent({ <span class="hljs-attr">keepAlive</span>: <span class="hljs-literal">true</span> });
-options.agent = keepAliveAgent;
-http.request(options, onResponseCallback);</code></pre>
-<h3><code>agent.createConnection(options[, callback])</code><span><a class="mark" href="#http_agent_createconnection_options_callback" id="http_agent_createconnection_options_callback">#</a></span></h3>
+<span class="hljs-keyword">const</span> keepAliveAgent = <span class="hljs-keyword">new</span> http.<span class="hljs-title class_">Agent</span>({ <span class="hljs-attr">keepAlive</span>: <span class="hljs-literal">true</span> });
+options.<span class="hljs-property">agent</span> = keepAliveAgent;
+http.<span class="hljs-title function_">request</span>(options, onResponseCallback);</code></pre>
+<h4><code>agent.createConnection(options[, callback])</code><span><a class="mark" href="#http_agent_createconnection_options_callback" id="http_agent_createconnection_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -429,7 +489,7 @@ socket/stream from this function, or by passing the socket/stream to <code>callb
 a subclass of <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specifies a socket
 type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
 <p><code>callback</code> has a signature of <code>(err, stream)</code>.</p>
-<h3><code>agent.keepSocketAlive(socket)</code><span><a class="mark" href="#http_agent_keepsocketalive_socket" id="http_agent_keepsocketalive_socket">#</a></span></h3>
+<h4><code>agent.keepSocketAlive(socket)</code><span><a class="mark" href="#http_agent_keepsocketalive_socket" id="http_agent_keepsocketalive_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.1.0</span>
 </div>
@@ -438,15 +498,15 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 </ul>
 <p>Called when <code>socket</code> is detached from a request and could be persisted by the
 <code>Agent</code>. Default behavior is to:</p>
-<pre><code class="language-js">socket.setKeepAlive(<span class="hljs-literal">true</span>, <span class="hljs-built_in">this</span>.keepAliveMsecs);
-socket.unref();
+<pre><code class="language-js">socket.<span class="hljs-title function_">setKeepAlive</span>(<span class="hljs-literal">true</span>, <span class="hljs-variable language_">this</span>.<span class="hljs-property">keepAliveMsecs</span>);
+socket.<span class="hljs-title function_">unref</span>();
 <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;</code></pre>
 <p>This method can be overridden by a particular <code>Agent</code> subclass. If this
 method returns a falsy value, the socket will be destroyed instead of persisting
 it for use with the next request.</p>
 <p>The <code>socket</code> argument can be an instance of <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>, a subclass of
 <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>.</p>
-<h3><code>agent.reuseSocket(socket, request)</code><span><a class="mark" href="#http_agent_reusesocket_socket_request" id="http_agent_reusesocket_socket_request">#</a></span></h3>
+<h4><code>agent.reuseSocket(socket, request)</code><span><a class="mark" href="#http_agent_reusesocket_socket_request" id="http_agent_reusesocket_socket_request">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.1.0</span>
 </div>
@@ -456,21 +516,21 @@ it for use with the next request.</p>
 </ul>
 <p>Called when <code>socket</code> is attached to <code>request</code> after being persisted because of
 the keep-alive options. Default behavior is to:</p>
-<pre><code class="language-js">socket.ref();</code></pre>
+<pre><code class="language-js">socket.<span class="hljs-title function_">ref</span>();</code></pre>
 <p>This method can be overridden by a particular <code>Agent</code> subclass.</p>
 <p>The <code>socket</code> argument can be an instance of <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>, a subclass of
 <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>.</p>
-<h3><code>agent.destroy()</code><span><a class="mark" href="#http_agent_destroy" id="http_agent_destroy">#</a></span></h3>
+<h4><code>agent.destroy()</code><span><a class="mark" href="#http_agent_destroy" id="http_agent_destroy">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
 <p>Destroy any sockets that are currently in use by the agent.</p>
 <p>It is usually not necessary to do this. However, if using an
 agent with <code>keepAlive</code> enabled, then it is best to explicitly shut down
-the agent when it will no longer be used. Otherwise,
-sockets may hang open for quite a long time before the server
+the agent when it is no longer needed. Otherwise,
+sockets might stay open for quite a long time before the server
 terminates them.</p>
-<h3><code>agent.freeSockets</code><span><a class="mark" href="#http_agent_freesockets" id="http_agent_freesockets">#</a></span></h3>
+<h4><code>agent.freeSockets</code><span><a class="mark" href="#http_agent_freesockets" id="http_agent_freesockets">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -481,7 +541,7 @@ terminates them.</p>
 the agent when <code>keepAlive</code> is enabled. Do not modify.</p>
 <p>Sockets in the <code>freeSockets</code> list will be automatically destroyed and
 removed from the array on <code>'timeout'</code>.</p>
-<h3><code>agent.getName(options)</code><span><a class="mark" href="#http_agent_getname_options" id="http_agent_getname_options">#</a></span></h3>
+<h4><code>agent.getName(options)</code><span><a class="mark" href="#http_agent_getname_options" id="http_agent_getname_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -503,7 +563,7 @@ connection can be reused. For an HTTP agent, this returns
 <code>host:port:localAddress</code> or <code>host:port:localAddress:family</code>. For an HTTPS agent,
 the name includes the CA, cert, ciphers, and other HTTPS/TLS-specific options
 that determine socket reusability.</p>
-<h3><code>agent.maxFreeSockets</code><span><a class="mark" href="#http_agent_maxfreesockets" id="http_agent_maxfreesockets">#</a></span></h3>
+<h4><code>agent.maxFreeSockets</code><span><a class="mark" href="#http_agent_maxfreesockets" id="http_agent_maxfreesockets">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.7</span>
 </div>
@@ -513,7 +573,7 @@ that determine socket reusability.</p>
 <p>By default set to 256. For agents with <code>keepAlive</code> enabled, this
 sets the maximum number of sockets that will be left open in the free
 state.</p>
-<h3><code>agent.maxSockets</code><span><a class="mark" href="#http_agent_maxsockets" id="http_agent_maxsockets">#</a></span></h3>
+<h4><code>agent.maxSockets</code><span><a class="mark" href="#http_agent_maxsockets" id="http_agent_maxsockets">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.6</span>
 </div>
@@ -522,16 +582,16 @@ state.</p>
 </ul>
 <p>By default set to <code>Infinity</code>. Determines how many concurrent sockets the agent
 can have open per origin. Origin is the returned value of <a href="#http_agent_getname_options"><code>agent.getName()</code></a>.</p>
-<h3><code>agent.maxTotalSockets</code><span><a class="mark" href="#http_agent_maxtotalsockets" id="http_agent_maxtotalsockets">#</a></span></h3>
+<h4><code>agent.maxTotalSockets</code><span><a class="mark" href="#http_agent_maxtotalsockets" id="http_agent_maxtotalsockets">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>By default set to <code>Infinity</code>. Determines how many concurrent sockets the agent
 can have open. Unlike <code>maxSockets</code>, this parameter applies across all origins.</p>
-<h3><code>agent.requests</code><span><a class="mark" href="#http_agent_requests" id="http_agent_requests">#</a></span></h3>
+<h4><code>agent.requests</code><span><a class="mark" href="#http_agent_requests" id="http_agent_requests">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -540,7 +600,7 @@ can have open. Unlike <code>maxSockets</code>, this parameter applies across all
 </ul>
 <p>An object which contains queues of requests that have not yet been assigned to
 sockets. Do not modify.</p>
-<h3><code>agent.sockets</code><span><a class="mark" href="#http_agent_sockets" id="http_agent_sockets">#</a></span></h3>
+<h4><code>agent.sockets</code><span><a class="mark" href="#http_agent_sockets" id="http_agent_sockets">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.6</span>
 </div>
@@ -549,7 +609,7 @@ sockets. Do not modify.</p>
 </ul>
 <p>An object which contains arrays of sockets currently in use by the
 agent. Do not modify.</p>
-<h2>Class: <code>http.ClientRequest</code><span><a class="mark" href="#http_class_http_clientrequest" id="http_class_http_clientrequest">#</a></span></h2>
+</section><section><h3>Class: <code>http.ClientRequest</code><span><a class="mark" href="#http_class_http_clientrequest" id="http_class_http_clientrequest">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
@@ -580,13 +640,13 @@ the data is read it will consume memory that can eventually lead to a
 <code>'aborted'</code> event.</p>
 <p>Node.js does not check whether Content-Length and the length of the
 body which has been transmitted are equal or not.</p>
-<h3>Event: <code>'abort'</code><span><a class="mark" href="#http_event_abort" id="http_event_abort">#</a></span></h3>
+<h4>Event: <code>'abort'</code><span><a class="mark" href="#http_event_abort" id="http_event_abort">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.4.1</span>
 </div>
 <p>Emitted when the request has been aborted by the client. This event is only
 emitted on the first call to <code>abort()</code>.</p>
-<h3>Event: <code>'connect'</code><span><a class="mark" href="#http_event_connect" id="http_event_connect">#</a></span></h3>
+<h4>Event: <code>'connect'</code><span><a class="mark" href="#http_event_connect" id="http_event_connect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -604,28 +664,28 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 <p>A client and server pair demonstrating how to listen for the <code>'connect'</code> event:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 <span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-<span class="hljs-keyword">const</span> { URL } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-variable constant_">URL</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
 
 <span class="hljs-comment">// Create an HTTP tunneling proxy</span>
-<span class="hljs-keyword">const</span> proxy = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
-  res.end(<span class="hljs-string">'okay'</span>);
+<span class="hljs-keyword">const</span> proxy = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'okay'</span>);
 });
-proxy.on(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">req, clientSocket, head</span>) =></span> {
+proxy.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">req, clientSocket, head</span>) =></span> {
   <span class="hljs-comment">// Connect to an origin server</span>
-  <span class="hljs-keyword">const</span> { port, hostname } = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">`http://<span class="hljs-subst">${req.url}</span>`</span>);
-  <span class="hljs-keyword">const</span> serverSocket = net.connect(port || <span class="hljs-number">80</span>, hostname, <span class="hljs-function">() =></span> {
-    clientSocket.write(<span class="hljs-string">'HTTP/1.1 200 Connection Established\r\n'</span> +
+  <span class="hljs-keyword">const</span> { port, hostname } = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">`http://<span class="hljs-subst">${req.url}</span>`</span>);
+  <span class="hljs-keyword">const</span> serverSocket = net.<span class="hljs-title function_">connect</span>(port || <span class="hljs-number">80</span>, hostname, <span class="hljs-function">() =></span> {
+    clientSocket.<span class="hljs-title function_">write</span>(<span class="hljs-string">'HTTP/1.1 200 Connection Established\r\n'</span> +
                     <span class="hljs-string">'Proxy-agent: Node.js-Proxy\r\n'</span> +
                     <span class="hljs-string">'\r\n'</span>);
-    serverSocket.write(head);
-    serverSocket.pipe(clientSocket);
-    clientSocket.pipe(serverSocket);
+    serverSocket.<span class="hljs-title function_">write</span>(head);
+    serverSocket.<span class="hljs-title function_">pipe</span>(clientSocket);
+    clientSocket.<span class="hljs-title function_">pipe</span>(serverSocket);
   });
 });
 
 <span class="hljs-comment">// Now that proxy is running</span>
-proxy.listen(<span class="hljs-number">1337</span>, <span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-function">() =></span> {
+proxy.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>, <span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-function">() =></span> {
 
   <span class="hljs-comment">// Make a request to a tunneling proxy</span>
   <span class="hljs-keyword">const</span> options = {
@@ -635,33 +695,33 @@ proxy.listen(<span class="hljs-number">1337</span>, <span class="hljs-string">'1
     <span class="hljs-attr">path</span>: <span class="hljs-string">'www.google.com:80'</span>
   };
 
-  <span class="hljs-keyword">const</span> req = http.request(options);
-  req.end();
+  <span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options);
+  req.<span class="hljs-title function_">end</span>();
 
-  req.on(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">res, socket, head</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'got connected!'</span>);
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">res, socket, head</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'got connected!'</span>);
 
     <span class="hljs-comment">// Make a request over an HTTP tunnel</span>
-    socket.write(<span class="hljs-string">'GET / HTTP/1.1\r\n'</span> +
+    socket.<span class="hljs-title function_">write</span>(<span class="hljs-string">'GET / HTTP/1.1\r\n'</span> +
                  <span class="hljs-string">'Host: www.google.com:80\r\n'</span> +
                  <span class="hljs-string">'Connection: close\r\n'</span> +
                  <span class="hljs-string">'\r\n'</span>);
-    socket.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-      <span class="hljs-built_in">console</span>.log(chunk.toString());
+    socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk.<span class="hljs-title function_">toString</span>());
     });
-    socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-      proxy.close();
+    socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+      proxy.<span class="hljs-title function_">close</span>();
     });
   });
 });</code></pre>
-<h3>Event: <code>'continue'</code><span><a class="mark" href="#http_event_continue" id="http_event_continue">#</a></span></h3>
+<h4>Event: <code>'continue'</code><span><a class="mark" href="#http_event_continue" id="http_event_continue">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
 <p>Emitted when the server sends a '100 Continue' HTTP response, usually because
 the request contained 'Expect: 100-continue'. This is an instruction that
 the client should send the request body.</p>
-<h3>Event: <code>'information'</code><span><a class="mark" href="#http_event_information" id="http_event_information">#</a></span></h3>
+<h4>Event: <code>'information'</code><span><a class="mark" href="#http_event_information" id="http_event_information">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -691,17 +751,17 @@ and array with the raw header names followed by their respective values.</p>
 };
 
 <span class="hljs-comment">// Make a request</span>
-<span class="hljs-keyword">const</span> req = http.request(options);
-req.end();
+<span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options);
+req.<span class="hljs-title function_">end</span>();
 
-req.on(<span class="hljs-string">'information'</span>, <span class="hljs-function">(<span class="hljs-params">info</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Got information prior to main response: <span class="hljs-subst">${info.statusCode}</span>`</span>);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'information'</span>, <span class="hljs-function">(<span class="hljs-params">info</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Got information prior to main response: <span class="hljs-subst">${info.statusCode}</span>`</span>);
 });</code></pre>
 <p>101 Upgrade statuses do not fire this event due to their break from the
 traditional HTTP request/response chain, such as web sockets, in-place TLS
 upgrades, or HTTP 2.0. To be notified of 101 Upgrade notices, listen for the
 <a href="#http_event_upgrade"><code>'upgrade'</code></a> event instead.</p>
-<h3>Event: <code>'response'</code><span><a class="mark" href="#http_event_response" id="http_event_response">#</a></span></h3>
+<h4>Event: <code>'response'</code><span><a class="mark" href="#http_event_response" id="http_event_response">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.0</span>
 </div>
@@ -710,7 +770,7 @@ upgrades, or HTTP 2.0. To be notified of 101 Upgrade notices, listen for the
 </ul>
 <p>Emitted when a response is received to this request. This event is emitted only
 once.</p>
-<h3>Event: <code>'socket'</code><span><a class="mark" href="#http_event_socket" id="http_event_socket">#</a></span></h3>
+<h4>Event: <code>'socket'</code><span><a class="mark" href="#http_event_socket" id="http_event_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.3</span>
 </div>
@@ -720,14 +780,14 @@ once.</p>
 <p>This event is guaranteed to be passed an instance of the <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specifies a socket
 type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3>Event: <code>'timeout'</code><span><a class="mark" href="#http_event_timeout" id="http_event_timeout">#</a></span></h3>
+<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http_event_timeout" id="http_event_timeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.8</span>
 </div>
 <p>Emitted when the underlying socket times out from inactivity. This only notifies
 that the socket has been idle. The request must be aborted manually.</p>
 <p>See also: <a href="#http_request_settimeout_timeout_callback"><code>request.setTimeout()</code></a>.</p>
-<h3>Event: <code>'upgrade'</code><span><a class="mark" href="#http_event_upgrade" id="http_event_upgrade">#</a></span></h3>
+<h4>Event: <code>'upgrade'</code><span><a class="mark" href="#http_event_upgrade" id="http_event_upgrade">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.94</span>
 </div>
@@ -747,21 +807,21 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 
 <span class="hljs-comment">// Create an HTTP server</span>
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
-  res.end(<span class="hljs-string">'okay'</span>);
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'okay'</span>);
 });
-server.on(<span class="hljs-string">'upgrade'</span>, <span class="hljs-function">(<span class="hljs-params">req, socket, head</span>) =></span> {
-  socket.write(<span class="hljs-string">'HTTP/1.1 101 Web Socket Protocol Handshake\r\n'</span> +
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'upgrade'</span>, <span class="hljs-function">(<span class="hljs-params">req, socket, head</span>) =></span> {
+  socket.<span class="hljs-title function_">write</span>(<span class="hljs-string">'HTTP/1.1 101 Web Socket Protocol Handshake\r\n'</span> +
                <span class="hljs-string">'Upgrade: WebSocket\r\n'</span> +
                <span class="hljs-string">'Connection: Upgrade\r\n'</span> +
                <span class="hljs-string">'\r\n'</span>);
 
-  socket.pipe(socket); <span class="hljs-comment">// echo back</span>
+  socket.<span class="hljs-title function_">pipe</span>(socket); <span class="hljs-comment">// echo back</span>
 });
 
 <span class="hljs-comment">// Now that server is running</span>
-server.listen(<span class="hljs-number">1337</span>, <span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-function">() =></span> {
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>, <span class="hljs-string">'127.0.0.1'</span>, <span class="hljs-function">() =></span> {
 
   <span class="hljs-comment">// make a request</span>
   <span class="hljs-keyword">const</span> options = {
@@ -773,22 +833,23 @@ server.listen(<span class="hljs-number">1337</span>, <span class="hljs-string">'
     }
   };
 
-  <span class="hljs-keyword">const</span> req = http.request(options);
-  req.end();
+  <span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options);
+  req.<span class="hljs-title function_">end</span>();
 
-  req.on(<span class="hljs-string">'upgrade'</span>, <span class="hljs-function">(<span class="hljs-params">res, socket, upgradeHead</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'got upgraded!'</span>);
-    socket.end();
-    process.exit(<span class="hljs-number">0</span>);
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'upgrade'</span>, <span class="hljs-function">(<span class="hljs-params">res, socket, upgradeHead</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'got upgraded!'</span>);
+    socket.<span class="hljs-title function_">end</span>();
+    process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">0</span>);
   });
 });</code></pre>
-<h3><code>request.abort()</code><span><a class="mark" href="#http_request_abort" id="http_request_abort">#</a></span></h3>
+<h4><code>request.abort()</code><span><a class="mark" href="#http_request_abort" id="http_request_abort">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.3.8</span>
+<span>Added in: v0.3.8</span><span>Deprecated since: v14.1.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#http_request_destroy_error"><code>request.destroy()</code></a> instead.</div><p></p>
 <p>Marks the request as aborting. Calling this will cause remaining data
 in the response to be dropped and the socket to be destroyed.</p>
-<h3><code>request.aborted</code><span><a class="mark" href="#http_request_aborted" id="http_request_aborted">#</a></span></h3>
+<h4><code>request.aborted</code><span><a class="mark" href="#http_request_aborted" id="http_request_aborted">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -805,15 +866,16 @@ in the response to be dropped and the socket to be destroyed.</p>
 </ul>
 <p>The <code>request.aborted</code> property will be <code>true</code> if the request has
 been aborted.</p>
-<h3><code>request.connection</code><span><a class="mark" href="#http_request_connection" id="http_request_connection">#</a></span></h3>
+<h4><code>request.connection</code><span><a class="mark" href="#http_request_connection" id="http_request_connection">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.3.0</span>
+<span>Added in: v0.3.0</span><span>Deprecated since: v13.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http_request_socket"><code>request.socket</code></a>.</div><p></p>
 <ul>
 <li><a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a></li>
 </ul>
 <p>See <a href="#http_request_socket"><code>request.socket</code></a>.</p>
-<h3><code>request.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http_request_end_data_encoding_callback" id="http_request_end_data_encoding_callback">#</a></span></h3>
+<h4><code>request.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http_request_end_data_encoding_callback" id="http_request_end_data_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -838,9 +900,38 @@ chunked, this will send the terminating <code>'0\r\n\r\n'</code>.</p>
 <a href="#http_request_write_chunk_encoding_callback"><code>request.write(data, encoding)</code></a> followed by <code>request.end(callback)</code>.</p>
 <p>If <code>callback</code> is specified, it will be called when the request stream
 is finished.</p>
-<h3><code>request.finished</code><span><a class="mark" href="#http_request_finished" id="http_request_finished">#</a></span></h3>
+<h4><code>request.destroy([error])</code><span><a class="mark" href="#http_request_destroy_error" id="http_request_destroy_error">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.5.0</td>
+<td><p>The function returns <code>this</code> for consistency with other Readable streams.</p></td></tr>
+<tr><td>v0.3.0</td>
+<td><p><span>Added in: v0.3.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Optional, an error to emit with <code>'error'</code> event.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Destroy the request. Optionally emit an <code>'error'</code> event,
+and emit a <code>'close'</code> event. Calling this will cause remaining data
+in the response to be dropped and the socket to be destroyed.</p>
+<p>See <a href="stream.html#stream_writable_destroy_error"><code>writable.destroy()</code></a> for further details.</p>
+<h5><code>request.destroyed</code><span><a class="mark" href="#http_request_destroyed" id="http_request_destroyed">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.1.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Is <code>true</code> after <a href="#http_request_destroy_error"><code>request.destroy()</code></a> has been called.</p>
+<p>See <a href="stream.html#stream_writable_destroyed"><code>writable.destroyed</code></a> for further details.</p>
+<h4><code>request.finished</code><span><a class="mark" href="#http_request_finished" id="http_request_finished">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.0.1</span><span>Deprecated since: v12.16.0</span>
+<span>Added in: v0.0.1</span><span>Deprecated since: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http_request_writableended"><code>request.writableEnded</code></a>.</div><p></p>
 <ul>
@@ -849,7 +940,7 @@ is finished.</p>
 <p>The <code>request.finished</code> property will be <code>true</code> if <a href="#http_request_end_data_encoding_callback"><code>request.end()</code></a>
 has been called. <code>request.end()</code> will automatically be called if the
 request was initiated via <a href="#http_http_get_options_callback"><code>http.get()</code></a>.</p>
-<h3><code>request.flushHeaders()</code><span><a class="mark" href="#http_request_flushheaders" id="http_request_flushheaders">#</a></span></h3>
+<h4><code>request.flushHeaders()</code><span><a class="mark" href="#http_request_flushheaders" id="http_request_flushheaders">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
@@ -860,7 +951,7 @@ then tries to pack the request headers and data into a single TCP packet.</p>
 <p>That's usually desired (it saves a TCP round-trip), but not when the first
 data is not sent until possibly much later. <code>request.flushHeaders()</code> bypasses
 the optimization and kickstarts the request.</p>
-<h3><code>request.getHeader(name)</code><span><a class="mark" href="#http_request_getheader_name" id="http_request_getheader_name">#</a></span></h3>
+<h4><code>request.getHeader(name)</code><span><a class="mark" href="#http_request_getheader_name" id="http_request_getheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
@@ -871,49 +962,63 @@ the optimization and kickstarts the request.</p>
 <p>Reads out a header on the request. The name is case-insensitive.
 The type of the return value depends on the arguments provided to
 <a href="#http_request_setheader_name_value"><code>request.setHeader()</code></a>.</p>
-<pre><code class="language-js">request.setHeader(<span class="hljs-string">'content-type'</span>, <span class="hljs-string">'text/html'</span>);
-request.setHeader(<span class="hljs-string">'Content-Length'</span>, Buffer.byteLength(body));
-request.setHeader(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);
-<span class="hljs-keyword">const</span> contentType = request.getHeader(<span class="hljs-string">'Content-Type'</span>);
+<pre><code class="language-js">request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'content-type'</span>, <span class="hljs-string">'text/html'</span>);
+request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Length'</span>, <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(body));
+request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);
+<span class="hljs-keyword">const</span> contentType = request.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'Content-Type'</span>);
 <span class="hljs-comment">// 'contentType' is 'text/html'</span>
-<span class="hljs-keyword">const</span> contentLength = request.getHeader(<span class="hljs-string">'Content-Length'</span>);
+<span class="hljs-keyword">const</span> contentLength = request.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'Content-Length'</span>);
 <span class="hljs-comment">// 'contentLength' is of type number</span>
-<span class="hljs-keyword">const</span> cookie = request.getHeader(<span class="hljs-string">'Cookie'</span>);
+<span class="hljs-keyword">const</span> cookie = request.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'Cookie'</span>);
 <span class="hljs-comment">// 'cookie' is of type string[]</span></code></pre>
-<h3><code>request.maxHeadersCount</code><span><a class="mark" href="#http_request_maxheaderscount" id="http_request_maxheaderscount">#</a></span></h3>
+<h4><code>request.getRawHeaderNames()</code><span><a class="mark" href="#http_request_getrawheadernames" id="http_request_getrawheadernames">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>Returns an array containing the unique names of the current outgoing raw
+headers. Header names are returned with their exact casing being set.</p>
+<pre><code class="language-js">request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+
+<span class="hljs-keyword">const</span> headerNames = request.<span class="hljs-title function_">getRawHeaderNames</span>();
+<span class="hljs-comment">// headerNames === ['Foo', 'Set-Cookie']</span></code></pre>
+<h4><code>request.maxHeadersCount</code><span><a class="mark" href="#http_request_maxheaderscount" id="http_request_maxheaderscount">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>2000</code></li>
 </ul>
 <p>Limits maximum response headers count. If set to 0, no limit will be applied.</p>
-<h3><code>request.path</code><span><a class="mark" href="#http_request_path" id="http_request_path">#</a></span></h3>
+<h4><code>request.path</code><span><a class="mark" href="#http_request_path" id="http_request_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The request path.</li>
 </ul>
-<h3><code>request.method</code><span><a class="mark" href="#http_request_method" id="http_request_method">#</a></span></h3>
+<h4><code>request.method</code><span><a class="mark" href="#http_request_method" id="http_request_method">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.97</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The request method.</li>
 </ul>
-<h3><code>request.host</code><span><a class="mark" href="#http_request_host" id="http_request_host">#</a></span></h3>
+<h4><code>request.host</code><span><a class="mark" href="#http_request_host" id="http_request_host">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The request host.</li>
 </ul>
-<h3><code>request.protocol</code><span><a class="mark" href="#http_request_protocol" id="http_request_protocol">#</a></span></h3>
+<h4><code>request.protocol</code><span><a class="mark" href="#http_request_protocol" id="http_request_protocol">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The request protocol.</li>
 </ul>
-<h3><code>request.removeHeader(name)</code><span><a class="mark" href="#http_request_removeheader_name" id="http_request_removeheader_name">#</a></span></h3>
+<h4><code>request.removeHeader(name)</code><span><a class="mark" href="#http_request_removeheader_name" id="http_request_removeheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
@@ -921,10 +1026,10 @@ request.setHeader(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Removes a header that's already defined into headers object.</p>
-<pre><code class="language-js">request.removeHeader(<span class="hljs-string">'Content-Type'</span>);</code></pre>
-<h3><code>request.reusedSocket</code><span><a class="mark" href="#http_request_reusedsocket" id="http_request_reusedsocket">#</a></span></h3>
+<pre><code class="language-js">request.<span class="hljs-title function_">removeHeader</span>(<span class="hljs-string">'Content-Type'</span>);</code></pre>
+<h4><code>request.reusedSocket</code><span><a class="mark" href="#http_request_reusedsocket" id="http_request_reusedsocket">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether the request is send through a reused socket.</li>
@@ -936,16 +1041,16 @@ may run into a 'ECONNRESET' error.</p>
 
 <span class="hljs-comment">// Server has a 5 seconds keep-alive timeout by default</span>
 http
-  .createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-    res.write(<span class="hljs-string">'hello\n'</span>);
-    res.end();
+  .<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+    res.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello\n'</span>);
+    res.<span class="hljs-title function_">end</span>();
   })
-  .listen(<span class="hljs-number">3000</span>);
+  .<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);
 
 <span class="hljs-built_in">setInterval</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Adapting a keep-alive agent</span>
-  http.get(<span class="hljs-string">'http://localhost:3000'</span>, { agent }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-    res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  http.<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:3000'</span>, { agent }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+    res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
       <span class="hljs-comment">// Do nothing</span>
     });
   });
@@ -953,23 +1058,23 @@ http
 <p>By marking a request whether it reused socket or not, we can do
 automatic error retry base on it.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> agent = <span class="hljs-keyword">new</span> http.Agent({ <span class="hljs-attr">keepAlive</span>: <span class="hljs-literal">true</span> });
+<span class="hljs-keyword">const</span> agent = <span class="hljs-keyword">new</span> http.<span class="hljs-title class_">Agent</span>({ <span class="hljs-attr">keepAlive</span>: <span class="hljs-literal">true</span> });
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">retriableRequest</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">retriableRequest</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">const</span> req = http
-    .get(<span class="hljs-string">'http://localhost:3000'</span>, { agent }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+    .<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:3000'</span>, { agent }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
       <span class="hljs-comment">// ...</span>
     })
-    .on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    .<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
       <span class="hljs-comment">// Check if retry is needed</span>
-      <span class="hljs-keyword">if</span> (req.reusedSocket &#x26;&#x26; err.code === <span class="hljs-string">'ECONNRESET'</span>) {
-        retriableRequest();
+      <span class="hljs-keyword">if</span> (req.<span class="hljs-property">reusedSocket</span> &#x26;&#x26; err.<span class="hljs-property">code</span> === <span class="hljs-string">'ECONNRESET'</span>) {
+        <span class="hljs-title function_">retriableRequest</span>();
       }
     });
 }
 
-retriableRequest();</code></pre>
-<h3><code>request.setHeader(name, value)</code><span><a class="mark" href="#http_request_setheader_name_value" id="http_request_setheader_name_value">#</a></span></h3>
+<span class="hljs-title function_">retriableRequest</span>();</code></pre>
+<h4><code>request.setHeader(name, value)</code><span><a class="mark" href="#http_request_setheader_name_value" id="http_request_setheader_name_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
@@ -983,10 +1088,10 @@ here to send multiple headers with the same name. Non-string values will be
 stored without modification. Therefore, <a href="#http_request_getheader_name"><code>request.getHeader()</code></a> may return
 non-string values. However, the non-string values will be converted to strings
 for network transmission.</p>
-<pre><code class="language-js">request.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'application/json'</span>);</code></pre>
+<pre><code class="language-js">request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'application/json'</span>);</code></pre>
 <p>or</p>
-<pre><code class="language-js">request.setHeader(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
-<h3><code>request.setNoDelay([noDelay])</code><span><a class="mark" href="#http_request_setnodelay_nodelay" id="http_request_setnodelay_nodelay">#</a></span></h3>
+<pre><code class="language-js">request.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
+<h4><code>request.setNoDelay([noDelay])</code><span><a class="mark" href="#http_request_setnodelay_nodelay" id="http_request_setnodelay_nodelay">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -995,7 +1100,7 @@ for network transmission.</p>
 </ul>
 <p>Once a socket is assigned to this request and is connected
 <a href="net.html#net_socket_setnodelay_nodelay"><code>socket.setNoDelay()</code></a> will be called.</p>
-<h3><code>request.setSocketKeepAlive([enable][, initialDelay])</code><span><a class="mark" href="#http_request_setsocketkeepalive_enable_initialdelay" id="http_request_setsocketkeepalive_enable_initialdelay">#</a></span></h3>
+<h4><code>request.setSocketKeepAlive([enable][, initialDelay])</code><span><a class="mark" href="#http_request_setsocketkeepalive_enable_initialdelay" id="http_request_setsocketkeepalive_enable_initialdelay">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -1005,7 +1110,7 @@ for network transmission.</p>
 </ul>
 <p>Once a socket is assigned to this request and is connected
 <a href="net.html#net_socket_setkeepalive_enable_initialdelay"><code>socket.setKeepAlive()</code></a> will be called.</p>
-<h3><code>request.setTimeout(timeout[, callback])</code><span><a class="mark" href="#http_request_settimeout_timeout_callback" id="http_request_settimeout_timeout_callback">#</a></span></h3>
+<h4><code>request.setTimeout(timeout[, callback])</code><span><a class="mark" href="#http_request_settimeout_timeout_callback" id="http_request_settimeout_timeout_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1025,7 +1130,7 @@ Same as binding to the <code>'timeout'</code> event.</li>
 </ul>
 <p>Once a socket is assigned to this request and is connected
 <a href="net.html#net_socket_settimeout_timeout_callback"><code>socket.setTimeout()</code></a> will be called.</p>
-<h3><code>request.socket</code><span><a class="mark" href="#http_request_socket" id="http_request_socket">#</a></span></h3>
+<h4><code>request.socket</code><span><a class="mark" href="#http_request_socket" id="http_request_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1034,24 +1139,23 @@ Same as binding to the <code>'timeout'</code> event.</li>
 </ul>
 <p>Reference to the underlying socket. Usually users will not want to access
 this property. In particular, the socket will not emit <code>'readable'</code> events
-because of how the protocol parser attaches to the socket. The <code>socket</code>
-may also be accessed via <code>request.connection</code>.</p>
+because of how the protocol parser attaches to the socket.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">host</span>: <span class="hljs-string">'www.google.com'</span>,
 };
-<span class="hljs-keyword">const</span> req = http.get(options);
-req.end();
-req.once(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-keyword">const</span> ip = req.socket.localAddress;
-  <span class="hljs-keyword">const</span> port = req.socket.localPort;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
+<span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">get</span>(options);
+req.<span class="hljs-title function_">end</span>();
+req.<span class="hljs-title function_">once</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-keyword">const</span> ip = req.<span class="hljs-property">socket</span>.<span class="hljs-property">localAddress</span>;
+  <span class="hljs-keyword">const</span> port = req.<span class="hljs-property">socket</span>.<span class="hljs-property">localPort</span>;
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
   <span class="hljs-comment">// Consume response object</span>
 });</code></pre>
 <p>This property is guaranteed to be an instance of the <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specified a socket
 type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3><code>request.writableEnded</code><span><a class="mark" href="#http_request_writableended" id="http_request_writableended">#</a></span></h3>
+<h4><code>request.writableEnded</code><span><a class="mark" href="#http_request_writableended" id="http_request_writableended">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -1061,7 +1165,7 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 <p>Is <code>true</code> after <a href="#http_request_end_data_encoding_callback"><code>request.end()</code></a> has been called. This property
 does not indicate whether the data has been flushed, for this use
 <a href="#http_request_writablefinished"><code>request.writableFinished</code></a> instead.</p>
-<h3><code>request.writableFinished</code><span><a class="mark" href="#http_request_writablefinished" id="http_request_writablefinished">#</a></span></h3>
+<h4><code>request.writableFinished</code><span><a class="mark" href="#http_request_writablefinished" id="http_request_writablefinished">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
@@ -1070,7 +1174,7 @@ does not indicate whether the data has been flushed, for this use
 </ul>
 <p>Is <code>true</code> if all data has been flushed to the underlying system, immediately
 before the <a href="#http_event_finish"><code>'finish'</code></a> event is emitted.</p>
-<h3><code>request.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_request_write_chunk_encoding_callback" id="http_request_write_chunk_encoding_callback">#</a></span></h3>
+<h4><code>request.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_request_write_chunk_encoding_callback" id="http_request_write_chunk_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.29</span>
 </div>
@@ -1080,11 +1184,11 @@ before the <a href="#http_event_finish"><code>'finish'</code></a> event is emitt
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Sends a chunk of the body. By calling this method
-many times, a request body can be sent to a
-server. In that case, it is suggested to use the
-<code>['Transfer-Encoding', 'chunked']</code> header line when
-creating the request.</p>
+<p>Sends a chunk of the body. This method can be called multiple times. If no
+<code>Content-Length</code> is set, data will automatically be encoded in HTTP Chunked
+transfer encoding, so that server knows when the data ends. The
+<code>Transfer-Encoding: chunked</code> header is added. Calling <a href="#http_request_end_data_encoding_callback"><code>request.end()</code></a>
+is necessary to finish sending the request.</p>
 <p>The <code>encoding</code> argument is optional and only applies when <code>chunk</code> is a string.
 Defaults to <code>'utf8'</code>.</p>
 <p>The <code>callback</code> argument is optional and will be called when this chunk of data
@@ -1094,14 +1198,14 @@ buffer. Returns <code>false</code> if all or part of the data was queued in user
 <code>'drain'</code> will be emitted when the buffer is free again.</p>
 <p>When <code>write</code> function is called with empty string or buffer, it does
 nothing and waits for more input.</p>
-<h2>Class: <code>http.Server</code><span><a class="mark" href="#http_class_http_server" id="http_class_http_server">#</a></span></h2>
+</section><section><h3>Class: <code>http.Server</code><span><a class="mark" href="#http_class_http_server" id="http_class_http_server">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
 <ul>
 <li>Extends: <a href="net.html#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
-<h3>Event: <code>'checkContinue'</code><span><a class="mark" href="#http_event_checkcontinue" id="http_event_checkcontinue">#</a></span></h3>
+<h4>Event: <code>'checkContinue'</code><span><a class="mark" href="#http_event_checkcontinue" id="http_event_checkcontinue">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1118,7 +1222,7 @@ HTTP response (e.g. 400 Bad Request) if the client should not continue to send
 the request body.</p>
 <p>When this event is emitted and handled, the <a href="#http_event_request"><code>'request'</code></a> event will
 not be emitted.</p>
-<h3>Event: <code>'checkExpectation'</code><span><a class="mark" href="#http_event_checkexpectation" id="http_event_checkexpectation">#</a></span></h3>
+<h4>Event: <code>'checkExpectation'</code><span><a class="mark" href="#http_event_checkexpectation" id="http_event_checkexpectation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.5.0</span>
 </div>
@@ -1131,7 +1235,7 @@ value is not <code>100-continue</code>. If this event is not listened for, the s
 automatically respond with a <code>417 Expectation Failed</code> as appropriate.</p>
 <p>When this event is emitted and handled, the <a href="#http_event_request"><code>'request'</code></a> event will
 not be emitted.</p>
-<h3>Event: <code>'clientError'</code><span><a class="mark" href="#http_event_clienterror" id="http_event_clienterror">#</a></span></h3>
+<h4>Event: <code>'clientError'</code><span><a class="mark" href="#http_event_clienterror" id="http_event_clienterror">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1165,13 +1269,13 @@ written data it is immediately destroyed.</p>
 <p><code>socket</code> is the <a href="net.html#net_class_net_socket"><code>net.Socket</code></a> object that the error originated from.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.end();
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">end</span>();
 });
-server.on(<span class="hljs-string">'clientError'</span>, <span class="hljs-function">(<span class="hljs-params">err, socket</span>) =></span> {
-  socket.end(<span class="hljs-string">'HTTP/1.1 400 Bad Request\r\n\r\n'</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'clientError'</span>, <span class="hljs-function">(<span class="hljs-params">err, socket</span>) =></span> {
+  socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'HTTP/1.1 400 Bad Request\r\n\r\n'</span>);
 });
-server.listen(<span class="hljs-number">8000</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
 <p>When the <code>'clientError'</code> event occurs, there is no <code>request</code> or <code>response</code>
 object, so any HTTP response sent, including response headers and payload,
 <em>must</em> be written directly to the <code>socket</code> object. Care must be taken to
@@ -1186,19 +1290,19 @@ correctly;</li>
 has already been destroyed, like in case of <code>ECONNRESET</code> errors. Before
 trying to send data to the socket, it is better to check that it is still
 writable.</p>
-<pre><code class="language-js">server.on(<span class="hljs-string">'clientError'</span>, <span class="hljs-function">(<span class="hljs-params">err, socket</span>) =></span> {
-  <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ECONNRESET'</span> || !socket.writable) {
+<pre><code class="language-js">server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'clientError'</span>, <span class="hljs-function">(<span class="hljs-params">err, socket</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ECONNRESET'</span> || !socket.<span class="hljs-property">writable</span>) {
     <span class="hljs-keyword">return</span>;
   }
 
-  socket.end(<span class="hljs-string">'HTTP/1.1 400 Bad Request\r\n\r\n'</span>);
+  socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'HTTP/1.1 400 Bad Request\r\n\r\n'</span>);
 });</code></pre>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#http_event_close" id="http_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#http_event_close" id="http_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.4</span>
 </div>
 <p>Emitted when the server closes.</p>
-<h3>Event: <code>'connect'</code><span><a class="mark" href="#http_event_connect_1" id="http_event_connect_1">#</a></span></h3>
+<h4>Event: <code>'connect'</code><span><a class="mark" href="#http_event_connect_1" id="http_event_connect_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -1217,7 +1321,7 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 <p>After this event is emitted, the request's socket will not have a <code>'data'</code>
 event listener, meaning it will need to be bound in order to handle data
 sent to the server on that socket.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#http_event_connection" id="http_event_connection">#</a></span></h3>
+<h4>Event: <code>'connection'</code><span><a class="mark" href="#http_event_connection" id="http_event_connection">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.0</span>
 </div>
@@ -1228,7 +1332,7 @@ sent to the server on that socket.</p>
 typically an object of type <a href="net.html#net_class_net_socket"><code>net.Socket</code></a>. Usually users will not want to
 access this event. In particular, the socket will not emit <code>'readable'</code> events
 because of how the protocol parser attaches to the socket. The <code>socket</code> can
-also be accessed at <code>request.connection</code>.</p>
+also be accessed at <code>request.socket</code>.</p>
 <p>This event can also be explicitly emitted by users to inject connections
 into the HTTP server. In that case, any <a href="stream.html#stream_class_stream_duplex"><code>Duplex</code></a> stream can be passed.</p>
 <p>If <code>socket.setTimeout()</code> is called here, the timeout will be replaced with
@@ -1237,7 +1341,7 @@ into the HTTP server. In that case, any <a href="stream.html#stream_class_stream
 <p>This event is guaranteed to be passed an instance of the <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specifies a socket
 type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3>Event: <code>'request'</code><span><a class="mark" href="#http_event_request" id="http_event_request">#</a></span></h3>
+<h4>Event: <code>'request'</code><span><a class="mark" href="#http_event_request" id="http_event_request">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.0</span>
 </div>
@@ -1247,7 +1351,7 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 </ul>
 <p>Emitted each time there is a request. There may be multiple requests
 per connection (in the case of HTTP Keep-Alive connections).</p>
-<h3>Event: <code>'upgrade'</code><span><a class="mark" href="#http_event_upgrade_1" id="http_event_upgrade_1">#</a></span></h3>
+<h4>Event: <code>'upgrade'</code><span><a class="mark" href="#http_event_upgrade_1" id="http_event_upgrade_1">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1273,7 +1377,7 @@ sent to the server on that socket.</p>
 <p>This event is guaranteed to be passed an instance of the <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specifies a socket
 type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3><code>server.close([callback])</code><span><a class="mark" href="#http_server_close_callback" id="http_server_close_callback">#</a></span></h3>
+<h4><code>server.close([callback])</code><span><a class="mark" href="#http_server_close_callback" id="http_server_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1281,9 +1385,9 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <p>Stops the server from accepting new connections. See <a href="net.html#net_server_close_callback"><code>net.Server.close()</code></a>.</p>
-<h3><code>server.headersTimeout</code><span><a class="mark" href="#http_server_headerstimeout" id="http_server_headerstimeout">#</a></span></h3>
+<h4><code>server.headersTimeout</code><span><a class="mark" href="#http_server_headerstimeout" id="http_server_headerstimeout">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.3.0</span>
+<span>Added in: v11.3.0, v10.14.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>60000</code></li>
@@ -1299,18 +1403,17 @@ passed since the connection was established. If the check fails, a <code>'timeou
 event is emitted on the server object, and (by default) the socket is destroyed.
 See <a href="#http_server_timeout"><code>server.timeout</code></a> for more information on how timeout behavior can be
 customized.</p>
-<p>A value of <code>0</code> will disable the HTTP headers timeout check.</p>
-<h3><code>server.listen()</code><span><a class="mark" href="#http_server_listen" id="http_server_listen">#</a></span></h3>
+<h4><code>server.listen()</code><span><a class="mark" href="#http_server_listen" id="http_server_listen">#</a></span></h4>
 <p>Starts the HTTP server listening for connections.
 This method is identical to <a href="net.html#net_server_listen"><code>server.listen()</code></a> from <a href="net.html#net_class_net_server"><code>net.Server</code></a>.</p>
-<h3><code>server.listening</code><span><a class="mark" href="#http_server_listening" id="http_server_listening">#</a></span></h3>
+<h4><code>server.listening</code><span><a class="mark" href="#http_server_listening" id="http_server_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.7.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether or not the server is listening for connections.</li>
 </ul>
-<h3><code>server.maxHeadersCount</code><span><a class="mark" href="#http_server_maxheaderscount" id="http_server_maxheaderscount">#</a></span></h3>
+<h4><code>server.maxHeadersCount</code><span><a class="mark" href="#http_server_maxheaderscount" id="http_server_maxheaderscount">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -1318,12 +1421,34 @@ This method is identical to <a href="net.html#net_server_listen"><code>server.li
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>2000</code></li>
 </ul>
 <p>Limits maximum incoming headers count. If set to 0, no limit will be applied.</p>
-<h3><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http_server_settimeout_msecs_callback" id="http_server_settimeout_msecs_callback">#</a></span></h3>
+<h4><code>server.requestTimeout</code><span><a class="mark" href="#http_server_requesttimeout" id="http_server_requesttimeout">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.9.12</span>
+<span>Added in: v14.11.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>0</code></li>
+</ul>
+<p>Sets the timeout value in milliseconds for receiving the entire request from
+the client.</p>
+<p>If the timeout expires, the server responds with status 408 without
+forwarding the request to the request listener and then closes the connection.</p>
+<p>It must be set to a non-zero value (e.g. 120 seconds) to protect against
+potential Denial-of-Service attacks in case the server is deployed without a
+reverse proxy in front.</p>
+<h4><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http_server_settimeout_msecs_callback" id="http_server_settimeout_msecs_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v0.9.12</td>
+<td><p><span>Added in: v0.9.12</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>msecs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>120000</code> (2 minutes)</li>
+<li><code>msecs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> 0 (no timeout)</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li>Returns: <a href="http.html#http_class_http_server" class="type">&#x3C;http.Server></a></li>
 </ul>
@@ -1332,26 +1457,30 @@ the Server object, passing the socket as an argument, if a timeout
 occurs.</p>
 <p>If there is a <code>'timeout'</code> event listener on the Server object, then it
 will be called with the timed-out socket as an argument.</p>
-<p>By default, the Server's timeout value is 2 minutes, and sockets are
-destroyed automatically if they time out. However, if a callback is assigned
-to the Server's <code>'timeout'</code> event, timeouts must be handled explicitly.</p>
-<p>To change the default timeout use the <a href="cli.html#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout</code></a>
-flag.</p>
-<h3><code>server.timeout</code><span><a class="mark" href="#http_server_timeout" id="http_server_timeout">#</a></span></h3>
+<p>By default, the Server does not timeout sockets. However, if a callback
+is assigned to the Server's <code>'timeout'</code> event, timeouts must be handled
+explicitly.</p>
+<h4><code>server.timeout</code><span><a class="mark" href="#http_server_timeout" id="http_server_timeout">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.9.12</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v0.9.12</td>
+<td><p><span>Added in: v0.9.12</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Timeout in milliseconds. <strong>Default:</strong> <code>120000</code> (2 minutes).</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Timeout in milliseconds. <strong>Default:</strong> 0 (no timeout)</li>
 </ul>
 <p>The number of milliseconds of inactivity before a socket is presumed
 to have timed out.</p>
 <p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>
 <p>The socket timeout logic is set up on connection, so changing this
 value only affects new connections to the server, not any existing connections.</p>
-<p>To change the default timeout use the <a href="cli.html#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout</code></a>
-flag.</p>
-<h3><code>server.keepAliveTimeout</code><span><a class="mark" href="#http_server_keepalivetimeout" id="http_server_keepalivetimeout">#</a></span></h3>
+<h4><code>server.keepAliveTimeout</code><span><a class="mark" href="#http_server_keepalivetimeout" id="http_server_keepalivetimeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -1369,7 +1498,7 @@ A value of <code>0</code> makes the http server behave similarly to Node.js vers
 to 8.0.0, which did not have a keep-alive timeout.</p>
 <p>The socket timeout logic is set up on connection, so changing this value only
 affects new connections to the server, not any existing connections.</p>
-<h2>Class: <code>http.ServerResponse</code><span><a class="mark" href="#http_class_http_serverresponse" id="http_class_http_serverresponse">#</a></span></h2>
+</section><section><h3>Class: <code>http.ServerResponse</code><span><a class="mark" href="#http_class_http_serverresponse" id="http_class_http_serverresponse">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
@@ -1378,13 +1507,13 @@ affects new connections to the server, not any existing connections.</p>
 </ul>
 <p>This object is created internally by an HTTP server, not by the user. It is
 passed as the second parameter to the <a href="#http_event_request"><code>'request'</code></a> event.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#http_event_close_1" id="http_event_close_1">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#http_event_close_1" id="http_event_close_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.7</span>
 </div>
-<p>Indicates that the the response is completed, or its underlying connection was
+<p>Indicates that the response is completed, or its underlying connection was
 terminated prematurely (before the response completion).</p>
-<h3>Event: <code>'finish'</code><span><a class="mark" href="#http_event_finish" id="http_event_finish">#</a></span></h3>
+<h4>Event: <code>'finish'</code><span><a class="mark" href="#http_event_finish" id="http_event_finish">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.6</span>
 </div>
@@ -1392,7 +1521,7 @@ terminated prematurely (before the response completion).</p>
 emitted when the last segment of the response headers and body have been
 handed off to the operating system for transmission over the network. It
 does not imply that the client has received anything yet.</p>
-<h3><code>response.addTrailers(headers)</code><span><a class="mark" href="#http_response_addtrailers_headers" id="http_response_addtrailers_headers">#</a></span></h3>
+<h4><code>response.addTrailers(headers)</code><span><a class="mark" href="#http_response_addtrailers_headers" id="http_response_addtrailers_headers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1406,27 +1535,28 @@ response; if it is not (e.g. if the request was HTTP/1.0), they will
 be silently discarded.</p>
 <p>HTTP requires the <code>Trailer</code> header to be sent in order to
 emit trailers, with a list of the header fields in its value. E.g.,</p>
-<pre><code class="language-js">response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span>,
+<pre><code class="language-js">response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span>,
                           <span class="hljs-string">'Trailer'</span>: <span class="hljs-string">'Content-MD5'</span> });
-response.write(fileData);
-response.addTrailers({ <span class="hljs-string">'Content-MD5'</span>: <span class="hljs-string">'7895bf4b8828b55ceaf47747b4bca667'</span> });
-response.end();</code></pre>
+response.<span class="hljs-title function_">write</span>(fileData);
+response.<span class="hljs-title function_">addTrailers</span>({ <span class="hljs-string">'Content-MD5'</span>: <span class="hljs-string">'7895bf4b8828b55ceaf47747b4bca667'</span> });
+response.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
-<h3><code>response.connection</code><span><a class="mark" href="#http_response_connection" id="http_response_connection">#</a></span></h3>
+<h4><code>response.connection</code><span><a class="mark" href="#http_response_connection" id="http_response_connection">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.3.0</span>
+<span>Added in: v0.3.0</span><span>Deprecated since: v13.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http_response_socket"><code>response.socket</code></a>.</div><p></p>
 <ul>
 <li><a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a></li>
 </ul>
 <p>See <a href="#http_response_socket"><code>response.socket</code></a>.</p>
-<h3><code>response.cork()</code><span><a class="mark" href="#http_response_cork" id="http_response_cork">#</a></span></h3>
+<h4><code>response.cork()</code><span><a class="mark" href="#http_response_cork" id="http_response_cork">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <p>See <a href="stream.html#stream_writable_cork"><code>writable.cork()</code></a>.</p>
-<h3><code>response.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http_response_end_data_encoding_callback" id="http_response_end_data_encoding_callback">#</a></span></h3>
+<h4><code>response.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http_response_end_data_encoding_callback" id="http_response_end_data_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1451,9 +1581,9 @@ The method, <code>response.end()</code>, MUST be called on each response.</p>
 <a href="#http_response_write_chunk_encoding_callback"><code>response.write(data, encoding)</code></a> followed by <code>response.end(callback)</code>.</p>
 <p>If <code>callback</code> is specified, it will be called when the response stream
 is finished.</p>
-<h3><code>response.finished</code><span><a class="mark" href="#http_response_finished" id="http_response_finished">#</a></span></h3>
+<h4><code>response.finished</code><span><a class="mark" href="#http_response_finished" id="http_response_finished">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.0.2</span><span>Deprecated since: v12.16.0</span>
+<span>Added in: v0.0.2</span><span>Deprecated since: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http_response_writableended"><code>response.writableEnded</code></a>.</div><p></p>
 <ul>
@@ -1461,12 +1591,12 @@ is finished.</p>
 </ul>
 <p>The <code>response.finished</code> property will be <code>true</code> if <a href="#http_response_end_data_encoding_callback"><code>response.end()</code></a>
 has been called.</p>
-<h3><code>response.flushHeaders()</code><span><a class="mark" href="#http_response_flushheaders" id="http_response_flushheaders">#</a></span></h3>
+<h4><code>response.flushHeaders()</code><span><a class="mark" href="#http_response_flushheaders" id="http_response_flushheaders">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.6.0</span>
 </div>
 <p>Flushes the response headers. See also: <a href="#http_request_flushheaders"><code>request.flushHeaders()</code></a>.</p>
-<h3><code>response.getHeader(name)</code><span><a class="mark" href="#http_response_getheader_name" id="http_response_getheader_name">#</a></span></h3>
+<h4><code>response.getHeader(name)</code><span><a class="mark" href="#http_response_getheader_name" id="http_response_getheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
@@ -1477,16 +1607,16 @@ has been called.</p>
 <p>Reads out a header that's already been queued but not sent to the client.
 The name is case-insensitive. The type of the return value depends
 on the arguments provided to <a href="#http_response_setheader_name_value"><code>response.setHeader()</code></a>.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
-response.setHeader(<span class="hljs-string">'Content-Length'</span>, Buffer.byteLength(body));
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);
-<span class="hljs-keyword">const</span> contentType = response.getHeader(<span class="hljs-string">'content-type'</span>);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Length'</span>, <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(body));
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);
+<span class="hljs-keyword">const</span> contentType = response.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'content-type'</span>);
 <span class="hljs-comment">// contentType is 'text/html'</span>
-<span class="hljs-keyword">const</span> contentLength = response.getHeader(<span class="hljs-string">'Content-Length'</span>);
+<span class="hljs-keyword">const</span> contentLength = response.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'Content-Length'</span>);
 <span class="hljs-comment">// contentLength is of type number</span>
-<span class="hljs-keyword">const</span> setCookie = response.getHeader(<span class="hljs-string">'set-cookie'</span>);
+<span class="hljs-keyword">const</span> setCookie = response.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'set-cookie'</span>);
 <span class="hljs-comment">// setCookie is of type string[]</span></code></pre>
-<h3><code>response.getHeaderNames()</code><span><a class="mark" href="#http_response_getheadernames" id="http_response_getheadernames">#</a></span></h3>
+<h4><code>response.getHeaderNames()</code><span><a class="mark" href="#http_response_getheadernames" id="http_response_getheadernames">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -1495,12 +1625,12 @@ response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="
 </ul>
 <p>Returns an array containing the unique names of the current outgoing headers.
 All header names are lowercase.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
 
-<span class="hljs-keyword">const</span> headerNames = response.getHeaderNames();
+<span class="hljs-keyword">const</span> headerNames = response.<span class="hljs-title function_">getHeaderNames</span>();
 <span class="hljs-comment">// headerNames === ['foo', 'set-cookie']</span></code></pre>
-<h3><code>response.getHeaders()</code><span><a class="mark" href="#http_response_getheaders" id="http_response_getheaders">#</a></span></h3>
+<h4><code>response.getHeaders()</code><span><a class="mark" href="#http_response_getheaders" id="http_response_getheaders">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -1516,12 +1646,12 @@ are lowercase.</p>
 prototypically inherit from the JavaScript <code>Object</code>. This means that typical
 <code>Object</code> methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>, and others
 are not defined and <em>will not work</em>.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
 
-<span class="hljs-keyword">const</span> headers = response.getHeaders();
+<span class="hljs-keyword">const</span> headers = response.<span class="hljs-title function_">getHeaders</span>();
 <span class="hljs-comment">// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }</span></code></pre>
-<h3><code>response.hasHeader(name)</code><span><a class="mark" href="#http_response_hasheader_name" id="http_response_hasheader_name">#</a></span></h3>
+<h4><code>response.hasHeader(name)</code><span><a class="mark" href="#http_response_hasheader_name" id="http_response_hasheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.7.0</span>
 </div>
@@ -1531,8 +1661,8 @@ response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="
 </ul>
 <p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the
 outgoing headers. The header name matching is case-insensitive.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = response.hasHeader(<span class="hljs-string">'content-type'</span>);</code></pre>
-<h3><code>response.headersSent</code><span><a class="mark" href="#http_response_headerssent" id="http_response_headerssent">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = response.<span class="hljs-title function_">hasHeader</span>(<span class="hljs-string">'content-type'</span>);</code></pre>
+<h4><code>response.headersSent</code><span><a class="mark" href="#http_response_headerssent" id="http_response_headerssent">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -1540,7 +1670,7 @@ outgoing headers. The header name matching is case-insensitive.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Boolean (read-only). True if headers were sent, false otherwise.</p>
-<h3><code>response.removeHeader(name)</code><span><a class="mark" href="#http_response_removeheader_name" id="http_response_removeheader_name">#</a></span></h3>
+<h4><code>response.removeHeader(name)</code><span><a class="mark" href="#http_response_removeheader_name" id="http_response_removeheader_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
@@ -1548,8 +1678,8 @@ outgoing headers. The header name matching is case-insensitive.</p>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Removes a header that's queued for implicit sending.</p>
-<pre><code class="language-js">response.removeHeader(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
-<h3><code>response.sendDate</code><span><a class="mark" href="#http_response_senddate" id="http_response_senddate">#</a></span></h3>
+<pre><code class="language-js">response.<span class="hljs-title function_">removeHeader</span>(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
+<h4><code>response.sendDate</code><span><a class="mark" href="#http_response_senddate" id="http_response_senddate">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
@@ -1560,34 +1690,37 @@ outgoing headers. The header name matching is case-insensitive.</p>
 the response if it is not already present in the headers. Defaults to true.</p>
 <p>This should only be disabled for testing; HTTP requires the Date header
 in responses.</p>
-<h3><code>response.setHeader(name, value)</code><span><a class="mark" href="#http_response_setheader_name_value" id="http_response_setheader_name_value">#</a></span></h3>
+<h4><code>response.setHeader(name, value)</code><span><a class="mark" href="#http_response_setheader_name_value" id="http_response_setheader_name_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
+<li>Returns: <a href="http.html#http_class_http_serverresponse" class="type">&#x3C;http.ServerResponse></a></li>
 </ul>
+<p>Returns the response object.</p>
 <p>Sets a single header value for implicit headers. If this header already exists
 in the to-be-sent headers, its value will be replaced. Use an array of strings
 here to send multiple headers with the same name. Non-string values will be
 stored without modification. Therefore, <a href="#http_response_getheader_name"><code>response.getHeader()</code></a> may return
 non-string values. However, the non-string values will be converted to strings
-for network transmission.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);</code></pre>
+for network transmission. The same response object is returned to the caller,
+to enable call chaining.</p>
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);</code></pre>
 <p>or</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
 <p>When headers have been set with <a href="#http_response_setheader_name_value"><code>response.setHeader()</code></a>, they will be merged
 with any headers passed to <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a>, with the headers passed
 to <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> given precedence.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Returns content-type = text/plain</span>
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
 <p>If <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> method is called and this method has not been
 called, it will directly write the supplied header values onto the network
@@ -1595,7 +1728,7 @@ channel without caching internally, and the <a href="#http_response_getheader_na
 header will not yield the expected result. If progressive population of headers
 is desired with potential future retrieval and modification, use
 <a href="#http_response_setheader_name_value"><code>response.setHeader()</code></a> instead of <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a>.</p>
-<h3><code>response.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http_response_settimeout_msecs_callback" id="http_response_settimeout_msecs_callback">#</a></span></h3>
+<h4><code>response.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http_response_settimeout_msecs_callback" id="http_response_settimeout_msecs_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.12</span>
 </div>
@@ -1611,7 +1744,7 @@ the response object.</p>
 the server, then sockets are destroyed when they time out. If a handler is
 assigned to the request, the response, or the server's <code>'timeout'</code> events,
 timed out sockets must be handled explicitly.</p>
-<h3><code>response.socket</code><span><a class="mark" href="#http_response_socket" id="http_response_socket">#</a></span></h3>
+<h4><code>response.socket</code><span><a class="mark" href="#http_response_socket" id="http_response_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1621,18 +1754,17 @@ timed out sockets must be handled explicitly.</p>
 <p>Reference to the underlying socket. Usually users will not want to access
 this property. In particular, the socket will not emit <code>'readable'</code> events
 because of how the protocol parser attaches to the socket. After
-<code>response.end()</code>, the property is nulled. The <code>socket</code> may also be accessed
-via <code>response.connection</code>.</p>
+<code>response.end()</code>, the property is nulled.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  <span class="hljs-keyword">const</span> ip = res.socket.remoteAddress;
-  <span class="hljs-keyword">const</span> port = res.socket.remotePort;
-  res.end(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
-}).listen(<span class="hljs-number">3000</span>);</code></pre>
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  <span class="hljs-keyword">const</span> ip = res.<span class="hljs-property">socket</span>.<span class="hljs-property">remoteAddress</span>;
+  <span class="hljs-keyword">const</span> port = res.<span class="hljs-property">socket</span>.<span class="hljs-property">remotePort</span>;
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);</code></pre>
 <p>This property is guaranteed to be an instance of the <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specified a socket
 type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3><code>response.statusCode</code><span><a class="mark" href="#http_response_statuscode" id="http_response_statuscode">#</a></span></h3>
+<h4><code>response.statusCode</code><span><a class="mark" href="#http_response_statuscode" id="http_response_statuscode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
@@ -1642,10 +1774,10 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 <p>When using implicit headers (not calling <a href="#http_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> explicitly),
 this property controls the status code that will be sent to the client when
 the headers get flushed.</p>
-<pre><code class="language-js">response.statusCode = <span class="hljs-number">404</span>;</code></pre>
+<pre><code class="language-js">response.<span class="hljs-property">statusCode</span> = <span class="hljs-number">404</span>;</code></pre>
 <p>After response header was sent to the client, this property indicates the
 status code which was sent out.</p>
-<h3><code>response.statusMessage</code><span><a class="mark" href="#http_response_statusmessage" id="http_response_statusmessage">#</a></span></h3>
+<h4><code>response.statusMessage</code><span><a class="mark" href="#http_response_statusmessage" id="http_response_statusmessage">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -1656,15 +1788,15 @@ status code which was sent out.</p>
 this property controls the status message that will be sent to the client when
 the headers get flushed. If this is left as <code>undefined</code> then the standard
 message for the status code will be used.</p>
-<pre><code class="language-js">response.statusMessage = <span class="hljs-string">'Not found'</span>;</code></pre>
+<pre><code class="language-js">response.<span class="hljs-property">statusMessage</span> = <span class="hljs-string">'Not found'</span>;</code></pre>
 <p>After response header was sent to the client, this property indicates the
 status message which was sent out.</p>
-<h3><code>response.uncork()</code><span><a class="mark" href="#http_response_uncork" id="http_response_uncork">#</a></span></h3>
+<h4><code>response.uncork()</code><span><a class="mark" href="#http_response_uncork" id="http_response_uncork">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <p>See <a href="stream.html#stream_writable_uncork"><code>writable.uncork()</code></a>.</p>
-<h3><code>response.writableEnded</code><span><a class="mark" href="#http_response_writableended" id="http_response_writableended">#</a></span></h3>
+<h4><code>response.writableEnded</code><span><a class="mark" href="#http_response_writableended" id="http_response_writableended">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -1674,7 +1806,7 @@ status message which was sent out.</p>
 <p>Is <code>true</code> after <a href="#http_response_end_data_encoding_callback"><code>response.end()</code></a> has been called. This property
 does not indicate whether the data has been flushed, for this use
 <a href="#http_response_writablefinished"><code>response.writableFinished</code></a> instead.</p>
-<h3><code>response.writableFinished</code><span><a class="mark" href="#http_response_writablefinished" id="http_response_writablefinished">#</a></span></h3>
+<h4><code>response.writableFinished</code><span><a class="mark" href="#http_response_writablefinished" id="http_response_writablefinished">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
@@ -1683,7 +1815,7 @@ does not indicate whether the data has been flushed, for this use
 </ul>
 <p>Is <code>true</code> if all data has been flushed to the underlying system, immediately
 before the <a href="#http_event_finish"><code>'finish'</code></a> event is emitted.</p>
-<h3><code>response.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_response_write_chunk_encoding_callback" id="http_response_write_chunk_encoding_callback">#</a></span></h3>
+<h4><code>response.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_response_write_chunk_encoding_callback" id="http_response_write_chunk_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.29</span>
 </div>
@@ -1713,19 +1845,21 @@ first chunk of the body.</p>
 <p>Returns <code>true</code> if the entire data was flushed successfully to the kernel
 buffer. Returns <code>false</code> if all or part of the data was queued in user memory.
 <code>'drain'</code> will be emitted when the buffer is free again.</p>
-<h3><code>response.writeContinue()</code><span><a class="mark" href="#http_response_writecontinue" id="http_response_writecontinue">#</a></span></h3>
+<h4><code>response.writeContinue()</code><span><a class="mark" href="#http_response_writecontinue" id="http_response_writecontinue">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
 <p>Sends a HTTP/1.1 100 Continue message to the client, indicating that
 the request body should be sent. See the <a href="#http_event_checkcontinue"><code>'checkContinue'</code></a> event on
 <code>Server</code>.</p>
-<h3><code>response.writeHead(statusCode[, statusMessage][, headers])</code><span><a class="mark" href="#http_response_writehead_statuscode_statusmessage_headers" id="http_response_writehead_statuscode_statusmessage_headers">#</a></span></h3>
+<h4><code>response.writeHead(statusCode[, statusMessage][, headers])</code><span><a class="mark" href="#http_response_writehead_statuscode_statusmessage_headers" id="http_response_writehead_statuscode_statusmessage_headers">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.10.0</td>
+<tr><td>v14.14.0</td>
+<td><p>Allow passing headers as an array.</p></td></tr>
+<tr><td>v11.10.0, v10.17.0</td>
 <td><p>Return <code>this</code> from <code>writeHead()</code> to allow chaining with <code>end()</code>.</p></td></tr>
 <tr><td>v5.11.0, v4.4.5</td>
 <td><p>A <code>RangeError</code> is thrown if <code>statusCode</code> is not a number in the range <code>[100, 999]</code>.</p></td></tr>
@@ -1737,21 +1871,25 @@ the request body should be sent. See the <a href="#http_event_checkcontinue"><co
 <ul>
 <li><code>statusCode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 <li><code>statusMessage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>headers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+<li><code>headers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
 <li>Returns: <a href="http.html#http_class_http_serverresponse" class="type">&#x3C;http.ServerResponse></a></li>
 </ul>
 <p>Sends a response header to the request. The status code is a 3-digit HTTP
 status code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.
 Optionally one can give a human-readable <code>statusMessage</code> as the second
 argument.</p>
+<p><code>headers</code> may be an <code>Array</code> where the keys and values are in the same list.
+It is <em>not</em> a list of tuples. So, the even-numbered offsets are key values,
+and the odd-numbered offsets are the associated values. The array is in the same
+format as <code>request.rawHeaders</code>.</p>
 <p>Returns a reference to the <code>ServerResponse</code>, so that calls can be chained.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> body = <span class="hljs-string">'hello world'</span>;
 response
-  .writeHead(<span class="hljs-number">200</span>, {
-    <span class="hljs-string">'Content-Length'</span>: Buffer.byteLength(body),
+  .<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, {
+    <span class="hljs-string">'Content-Length'</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(body),
     <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span>
   })
-  .end(body);</code></pre>
+  .<span class="hljs-title function_">end</span>(body);</code></pre>
 <p>This method must only be called once on a message and it must
 be called before <a href="#http_response_end_data_encoding_callback"><code>response.end()</code></a> is called.</p>
 <p>If <a href="#http_response_write_chunk_encoding_callback"><code>response.write()</code></a> or <a href="#http_response_end_data_encoding_callback"><code>response.end()</code></a> are called before calling
@@ -1766,11 +1904,11 @@ will not yield the expected result. If progressive population of headers is
 desired with potential future retrieval and modification, use
 <a href="#http_response_setheader_name_value"><code>response.setHeader()</code></a> instead.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Returns content-type = text/plain</span>
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
 <p><code>Content-Length</code> is given in bytes, not characters. Use
 <a href="buffer.html#buffer_static_method_buffer_bytelength_string_encoding"><code>Buffer.byteLength()</code></a> to determine the length of the body in bytes. Node.js
@@ -1778,18 +1916,18 @@ does not check whether <code>Content-Length</code> and the length of the body wh
 been transmitted are equal or not.</p>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
-<h3><code>response.writeProcessing()</code><span><a class="mark" href="#http_response_writeprocessing" id="http_response_writeprocessing">#</a></span></h3>
+<h4><code>response.writeProcessing()</code><span><a class="mark" href="#http_response_writeprocessing" id="http_response_writeprocessing">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 <p>Sends a HTTP/1.1 102 Processing message to the client, indicating that
 the request body should be sent.</p>
-<h2>Class: <code>http.IncomingMessage</code><span><a class="mark" href="#http_class_http_incomingmessage" id="http_class_http_incomingmessage">#</a></span></h2>
+</section><section><h3>Class: <code>http.IncomingMessage</code><span><a class="mark" href="#http_class_http_incomingmessage" id="http_class_http_incomingmessage">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.1.0, v12.16.0</td>
 <td><p>The <code>readableHighWaterMark</code> value mirrors that of the socket.</p></td></tr>
 <tr><td>v0.1.17</td>
 <td><p><span>Added in: v0.1.17</span></p></td></tr>
@@ -1803,17 +1941,17 @@ the request body should be sent.</p>
 <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a> and passed as the first argument to the <a href="#http_event_request"><code>'request'</code></a>
 and <a href="#http_event_response"><code>'response'</code></a> event respectively. It may be used to access response
 status, headers and data.</p>
-<h3>Event: <code>'aborted'</code><span><a class="mark" href="#http_event_aborted" id="http_event_aborted">#</a></span></h3>
+<h4>Event: <code>'aborted'</code><span><a class="mark" href="#http_event_aborted" id="http_event_aborted">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.8</span>
 </div>
 <p>Emitted when the request has been aborted.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#http_event_close_2" id="http_event_close_2">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#http_event_close_2" id="http_event_close_2">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.2</span>
 </div>
 <p>Indicates that the underlying connection was closed.</p>
-<h3><code>message.aborted</code><span><a class="mark" href="#http_message_aborted" id="http_message_aborted">#</a></span></h3>
+<h4><code>message.aborted</code><span><a class="mark" href="#http_message_aborted" id="http_message_aborted">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.1.0</span>
 </div>
@@ -1822,7 +1960,7 @@ status, headers and data.</p>
 </ul>
 <p>The <code>message.aborted</code> property will be <code>true</code> if the request has
 been aborted.</p>
-<h3><code>message.complete</code><span><a class="mark" href="#http_message_complete" id="http_message_complete">#</a></span></h3>
+<h4><code>message.complete</code><span><a class="mark" href="#http_message_complete" id="http_message_complete">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1833,24 +1971,24 @@ been aborted.</p>
 been received and successfully parsed.</p>
 <p>This property is particularly useful as a means of determining if a client or
 server fully transmitted a message before a connection was terminated:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> req = http.request({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>({
   <span class="hljs-attr">host</span>: <span class="hljs-string">'127.0.0.1'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">8080</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'POST'</span>
 }, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  res.resume();
-  res.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-keyword">if</span> (!res.complete)
-      <span class="hljs-built_in">console</span>.error(
+  res.<span class="hljs-title function_">resume</span>();
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-keyword">if</span> (!res.<span class="hljs-property">complete</span>)
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(
         <span class="hljs-string">'The connection was terminated while the message was still being sent'</span>);
   });
 });</code></pre>
-<h3><code>message.destroy([error])</code><span><a class="mark" href="#http_message_destroy_error" id="http_message_destroy_error">#</a></span></h3>
+<h4><code>message.destroy([error])</code><span><a class="mark" href="#http_message_destroy_error" id="http_message_destroy_error">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>The function returns <code>this</code> for consistency with other Readable streams.</p></td></tr>
 <tr><td>v0.3.0</td>
 <td><p><span>Added in: v0.3.0</span></p></td></tr>
@@ -1864,7 +2002,7 @@ server fully transmitted a message before a connection was terminated:</p>
 <p>Calls <code>destroy()</code> on the socket that received the <code>IncomingMessage</code>. If <code>error</code>
 is provided, an <code>'error'</code> event is emitted on the socket and <code>error</code> is passed
 as an argument to any listeners on the event.</p>
-<h3><code>message.headers</code><span><a class="mark" href="#http_message_headers" id="http_message_headers">#</a></span></h3>
+<h4><code>message.headers</code><span><a class="mark" href="#http_message_headers" id="http_message_headers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.5</span>
 </div>
@@ -1878,7 +2016,7 @@ as an argument to any listeners on the event.</p>
 <span class="hljs-comment">// { 'user-agent': 'curl/7.22.0',</span>
 <span class="hljs-comment">//   host: '127.0.0.1:8000',</span>
 <span class="hljs-comment">//   accept: '*/*' }</span>
-<span class="hljs-built_in">console</span>.log(request.headers);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(request.<span class="hljs-property">headers</span>);</code></pre>
 <p>Duplicates in raw headers are handled in the following ways, depending on the
 header name:</p>
 <ul>
@@ -1890,7 +2028,7 @@ header name:</p>
 <li>For duplicate <code>cookie</code> headers, the values are joined together with '; '.</li>
 <li>For all other headers, the values are joined together with ', '.</li>
 </ul>
-<h3><code>message.httpVersion</code><span><a class="mark" href="#http_message_httpversion" id="http_message_httpversion">#</a></span></h3>
+<h4><code>message.httpVersion</code><span><a class="mark" href="#http_message_httpversion" id="http_message_httpversion">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.1</span>
 </div>
@@ -1902,7 +2040,7 @@ client response, the HTTP version of the connected-to server.
 Probably either <code>'1.1'</code> or <code>'1.0'</code>.</p>
 <p>Also <code>message.httpVersionMajor</code> is the first integer and
 <code>message.httpVersionMinor</code> is the second.</p>
-<h3><code>message.method</code><span><a class="mark" href="#http_message_method" id="http_message_method">#</a></span></h3>
+<h4><code>message.method</code><span><a class="mark" href="#http_message_method" id="http_message_method">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.1</span>
 </div>
@@ -1911,7 +2049,7 @@ Probably either <code>'1.1'</code> or <code>'1.0'</code>.</p>
 </ul>
 <p><strong>Only valid for request obtained from <a href="#http_class_http_server"><code>http.Server</code></a>.</strong></p>
 <p>The request method as a string. Read only. Examples: <code>'GET'</code>, <code>'DELETE'</code>.</p>
-<h3><code>message.rawHeaders</code><span><a class="mark" href="#http_message_rawheaders" id="http_message_rawheaders">#</a></span></h3>
+<h4><code>message.rawHeaders</code><span><a class="mark" href="#http_message_rawheaders" id="http_message_rawheaders">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.6</span>
 </div>
@@ -1933,8 +2071,8 @@ odd-numbered offsets are the associated values.</p>
 <span class="hljs-comment">//   '127.0.0.1:8000',</span>
 <span class="hljs-comment">//   'ACCEPT',</span>
 <span class="hljs-comment">//   '*/*' ]</span>
-<span class="hljs-built_in">console</span>.log(request.rawHeaders);</code></pre>
-<h3><code>message.rawTrailers</code><span><a class="mark" href="#http_message_rawtrailers" id="http_message_rawtrailers">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(request.<span class="hljs-property">rawHeaders</span>);</code></pre>
+<h4><code>message.rawTrailers</code><span><a class="mark" href="#http_message_rawtrailers" id="http_message_rawtrailers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.6</span>
 </div>
@@ -1943,7 +2081,7 @@ odd-numbered offsets are the associated values.</p>
 </ul>
 <p>The raw request/response trailer keys and values exactly as they were
 received. Only populated at the <code>'end'</code> event.</p>
-<h3><code>message.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http_message_settimeout_msecs_callback" id="http_message_settimeout_msecs_callback">#</a></span></h3>
+<h4><code>message.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http_message_settimeout_msecs_callback" id="http_message_settimeout_msecs_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -1952,8 +2090,8 @@ received. Only populated at the <code>'end'</code> event.</p>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li>Returns: <a href="http.html#http_class_http_incomingmessage" class="type">&#x3C;http.IncomingMessage></a></li>
 </ul>
-<p>Calls <code>message.connection.setTimeout(msecs, callback)</code>.</p>
-<h3><code>message.socket</code><span><a class="mark" href="#http_message_socket" id="http_message_socket">#</a></span></h3>
+<p>Calls <code>message.socket.setTimeout(msecs, callback)</code>.</p>
+<h4><code>message.socket</code><span><a class="mark" href="#http_message_socket" id="http_message_socket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1966,7 +2104,7 @@ client's authentication details.</p>
 <p>This property is guaranteed to be an instance of the <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> class,
 a subclass of <a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a>, unless the user specified a socket
 type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a>.</p>
-<h3><code>message.statusCode</code><span><a class="mark" href="#http_message_statuscode" id="http_message_statuscode">#</a></span></h3>
+<h4><code>message.statusCode</code><span><a class="mark" href="#http_message_statuscode" id="http_message_statuscode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.1</span>
 </div>
@@ -1975,7 +2113,7 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 </ul>
 <p><strong>Only valid for response obtained from <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>.</strong></p>
 <p>The 3-digit HTTP response status code. E.G. <code>404</code>.</p>
-<h3><code>message.statusMessage</code><span><a class="mark" href="#http_message_statusmessage" id="http_message_statusmessage">#</a></span></h3>
+<h4><code>message.statusMessage</code><span><a class="mark" href="#http_message_statusmessage" id="http_message_statusmessage">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.10</span>
 </div>
@@ -1984,7 +2122,7 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 </ul>
 <p><strong>Only valid for response obtained from <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>.</strong></p>
 <p>The HTTP response status message (reason phrase). E.G. <code>OK</code> or <code>Internal Server Error</code>.</p>
-<h3><code>message.trailers</code><span><a class="mark" href="#http_message_trailers" id="http_message_trailers">#</a></span></h3>
+<h4><code>message.trailers</code><span><a class="mark" href="#http_message_trailers" id="http_message_trailers">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1992,7 +2130,7 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>The request/response trailers object. Only populated at the <code>'end'</code> event.</p>
-<h3><code>message.url</code><span><a class="mark" href="#http_message_url" id="http_message_url">#</a></span></h3>
+<h4><code>message.url</code><span><a class="mark" href="#http_message_url" id="http_message_url">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -2002,14 +2140,14 @@ type other than <a href="net.html#net_class_net_socket" class="type">&#x3C;net.S
 <p><strong>Only valid for request obtained from <a href="#http_class_http_server"><code>http.Server</code></a>.</strong></p>
 <p>Request URL string. This contains only the URL that is present in the actual
 HTTP request. Take the following request:</p>
-<pre><code class="language-http"><span class="hljs-keyword">GET</span> <span class="hljs-string">/status?name=ryan</span> HTTP/1.1
-<span class="hljs-attribute">Accept</span>: text/plain</code></pre>
+<pre><code class="language-http"><span class="hljs-keyword">GET</span> <span class="hljs-string">/status?name=ryan</span> <span class="hljs-meta">HTTP/1.1</span>
+<span class="hljs-attribute">Accept</span><span class="hljs-punctuation">: </span>text/plain</code></pre>
 <p>To parse the URL into its parts:</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> URL(request.url, <span class="hljs-string">`http://<span class="hljs-subst">${request.headers.host}</span>`</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(request.<span class="hljs-property">url</span>, <span class="hljs-string">`http://<span class="hljs-subst">${request.headers.host}</span>`</span>);</code></pre>
 <p>When <code>request.url</code> is <code>'/status?name=ryan'</code> and
 <code>request.headers.host</code> is <code>'localhost:3000'</code>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> new URL(request.url, `http://<span class="hljs-variable">${request.headers.host}</span>`)</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">new URL(request.url, `http://<span class="hljs-variable">${request.headers.host}</span>`)</span>
 URL {
   href: 'http://localhost:3000/status?name=ryan',
   origin: 'http://localhost:3000',
@@ -2024,7 +2162,323 @@ URL {
   searchParams: URLSearchParams { 'name' => 'ryan' },
   hash: ''
 }</code></pre>
-<h2><code>http.METHODS</code><span><a class="mark" href="#http_http_methods" id="http_http_methods">#</a></span></h2>
+</section><section><h3>Class: <code>http.OutgoingMessage</code><span><a class="mark" href="#http_class_http_outgoingmessage" id="http_class_http_outgoingmessage">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v0.1.17</span>
+</div>
+<ul>
+<li>Extends: <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a></li>
+</ul>
+<p>This class serves as the parent class of <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>
+and <a href="#http_class_http_serverresponse"><code>http.ServerResponse</code></a>. It is an abstract of outgoing message from
+the perspective of the participants of HTTP transaction.</p>
+<h4>Event: <code>drain</code><span><a class="mark" href="#http_event_drain" id="http_event_drain">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.6</span>
+</div>
+<p>Emitted when the buffer of the message is free again.</p>
+<h4>Event: <code>finish</code><span><a class="mark" href="#http_event_finish_1" id="http_event_finish_1">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.1.17</span>
+</div>
+<p>Emitted when the transmission is finished successfully.</p>
+<h4>Event: <code>prefinish</code><span><a class="mark" href="#http_event_prefinish" id="http_event_prefinish">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.11.6</span>
+</div>
+<p>Emitted when <code>outgoingMessage.end</code> was called.
+When the event is emitted, all data has been processed but not necessarily
+completely flushed.</p>
+<h4><code>outgoingMessage.addTrailers(headers)</code><span><a class="mark" href="#http_outgoingmessage_addtrailers_headers" id="http_outgoingmessage_addtrailers_headers">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span>
+</div>
+<ul>
+<li><code>headers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+</ul>
+<p>Adds HTTP trailers (headers but at the end of the message) to the message.</p>
+<p>Trailers are <strong>only</strong> be emitted if the message is chunked encoded. If not,
+the trailer will be silently discarded.</p>
+<p>HTTP requires the  <code>Trailer</code> header to be sent to emit trailers,
+with a list of header fields in its value, e.g.</p>
+<pre><code class="language-js">message.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain'</span>,
+                         <span class="hljs-string">'Trailer'</span>: <span class="hljs-string">'Content-MD5'</span> });
+message.<span class="hljs-title function_">write</span>(fileData);
+message.<span class="hljs-title function_">addTrailers</span>({ <span class="hljs-string">'Content-MD5'</span>: <span class="hljs-string">'7895bf4b8828b55ceaf47747b4bca667'</span> });
+message.<span class="hljs-title function_">end</span>();</code></pre>
+<p>Attempting to set a header field name or value that contains invalid characters
+will result in a <code>TypeError</code> being thrown.</p>
+<h4><code>outgoingMessage.connection</code><span><a class="mark" href="#http_outgoingmessage_connection" id="http_outgoingmessage_connection">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span><span>Deprecated since: v14.17.1</span>
+</div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#http_outgoingmessage_socket"><code>outgoingMessage.socket</code></a> instead.</div><p></p>
+<p>Aliases of <code>outgoingMessage.socket</code></p>
+<h4><code>outgoingMessage.cork()</code><span><a class="mark" href="#http_outgoingmessage_cork" id="http_outgoingmessage_cork">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.0.0</span>
+</div>
+<p>See <a href="stream.html#stream_writable_cork"><code>writable.cork()</code></a>.</p>
+<h4><code>outgoingMessage.destroy([error])</code><span><a class="mark" href="#http_outgoingmessage_destroy_error" id="http_outgoingmessage_destroy_error">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span>
+</div>
+<ul>
+<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Optional, an error to emit with <code>error</code> event</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Destroys the message. Once a socket is associated with the message
+and is connected, that socket will be destroyed as well.</p>
+<h4><code>outgoingMessage.end(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_outgoingmessage_end_chunk_encoding_callback" id="http_outgoingmessage_end_chunk_encoding_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v0.11.6</td>
+<td><p>add <code>callback</code> argument.</p></td></tr>
+<tr><td>v0.1.90</td>
+<td><p><span>Added in: v0.1.90</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>chunk</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Optional, <strong>Default</strong>: <code>utf-8</code></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Finishes the outgoing message. If any parts of the body are unsent, it will
+flush them to the underlying system. If the message is chunked, it will
+send the terminating chunk <code>0\r\n\r\n</code>, and send the trailer (if any).</p>
+<p>If <code>chunk</code> is specified, it is equivalent to call
+<code>outgoingMessage.write(chunk, encoding)</code>, followed by
+<code>outgoingMessage.end(callback)</code>.</p>
+<p>If <code>callback</code> is provided, it will be called when the message is finished.
+(equivalent to the callback to event <code>finish</code>)</p>
+<h4><code>outgoingMessage.flushHeaders()</code><span><a class="mark" href="#http_outgoingmessage_flushheaders" id="http_outgoingmessage_flushheaders">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v1.6.0</span>
+</div>
+<p>Compulsorily flushes the message headers</p>
+<p>For efficiency reason, Node.js normally buffers the message headers
+until <code>outgoingMessage.end()</code> is called or the first chunk of message data
+is written. It then tries to pack the headers and data into a single TCP
+packet.</p>
+<p>It is usually desired (it saves a TCP round-trip), but not when the first
+data is not sent until possibly much later. <code>outgoingMessage.flushHeaders()</code>
+bypasses the optimization and kickstarts the request.</p>
+<h4><code>outgoingMessage.getHeader(name)</code><span><a class="mark" href="#http_outgoingmessage_getheader_name" id="http_outgoingmessage_getheader_name">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Name of header</li>
+<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
+</ul>
+<p>Gets the value of HTTP header with the given name. If such a name doesn't
+exist in message, it will be <code>undefined</code>.</p>
+<h4><code>outgoingMessage.getHeaderNames()</code><span><a class="mark" href="#http_outgoingmessage_getheadernames" id="http_outgoingmessage_getheadernames">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v8.0.0</span>
+</div>
+<ul>
+<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>Returns an array of names of headers of the outgoing outgoingMessage. All
+names are lowercase.</p>
+<h4><code>outgoingMessage.getHeaders()</code><span><a class="mark" href="#http_outgoingmessage_getheaders" id="http_outgoingmessage_getheaders">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v8.0.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+</ul>
+<p>Returns a shallow copy of the current outgoing headers. Since a shallow
+copy is used, array values may be mutated without additional calls to
+various header-related HTTP module methods. The keys of the returned
+object are the header names and the values are the respective header
+values. All header names are lowercase.</p>
+<p>The object returned by the <code>outgoingMessage.getHeaders()</code> method does
+not prototypically inherit from the JavaScript Object. This means that
+typical Object methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>,
+and others are not defined and will not work.</p>
+<pre><code class="language-js">outgoingMessage.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+outgoingMessage.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+
+<span class="hljs-keyword">const</span> headers = outgoingMessage.<span class="hljs-title function_">getHeaders</span>();
+<span class="hljs-comment">// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }</span></code></pre>
+<h4><code>outgoingMessage.hasHeader(name)</code><span><a class="mark" href="#http_outgoingmessage_hasheader_name" id="http_outgoingmessage_hasheader_name">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v8.0.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the
+outgoing headers. The header name is case-insensitive.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = outgoingMessage.<span class="hljs-title function_">hasHeader</span>(<span class="hljs-string">'content-type'</span>);</code></pre>
+<h4><code>outgoingMessage.headersSent</code><span><a class="mark" href="#http_outgoingmessage_headerssent" id="http_outgoingmessage_headerssent">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.9.3</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Read-only. <code>true</code> if the headers were sent, otherwise <code>false</code>.</p>
+<h4><code>outgoingMessage.pipe()</code><span><a class="mark" href="#http_outgoingmessage_pipe" id="http_outgoingmessage_pipe">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v9.0.0</span>
+</div>
+<p>Overrides the pipe method of legacy <code>Stream</code> which is the parent class of
+<code>http.outgoingMessage</code>.</p>
+<p>Since <code>OutgoingMessage</code> should be a write-only stream,
+call this function will throw an <code>Error</code>. Thus, it disabled the pipe method
+it inherits from <code>Stream</code>.</p>
+<p>The User should not call this function directly.</p>
+<h4><code>outgoingMessage.removeHeader()</code><span><a class="mark" href="#http_outgoingmessage_removeheader" id="http_outgoingmessage_removeheader">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.0</span>
+</div>
+<p>Removes a header that is queued for implicit sending.</p>
+<pre><code class="language-js">outgoingMessage.<span class="hljs-title function_">removeHeader</span>(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
+<h4><code>outgoingMessage.setHeader(name, value)</code><span><a class="mark" href="#http_outgoingmessage_setheader_name_value" id="http_outgoingmessage_setheader_name_value">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Header name</li>
+<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Header value</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Sets a single header value for the header object.</p>
+<h4><code>outgoingMessage.setTimeout(msesc[, callback])</code><span><a class="mark" href="#http_outgoingmessage_settimeout_msesc_callback" id="http_outgoingmessage_settimeout_msesc_callback">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.9.12</span>
+</div>
+<ul>
+<li><code>msesc</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional function to be called when a timeout</li>
+</ul>
+<p>occurs, Same as binding to the <code>timeout</code> event.</p>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
+</ul>
+<p>Once a socket is associated with the message and is connected,
+<a href="net.html#net_socket_settimeout_timeout_callback"><code>socket.setTimeout()</code></a> will be called with <code>msecs</code> as the first parameter.</p>
+<h4><code>outgoingMessage.socket</code><span><a class="mark" href="#http_outgoingmessage_socket" id="http_outgoingmessage_socket">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.3.0</span>
+</div>
+<ul>
+<li><a href="stream.html#stream_class_stream_duplex" class="type">&#x3C;stream.Duplex></a></li>
+</ul>
+<p>Reference to the underlying socket. Usually, users will not want to access
+this property.</p>
+<p>After calling <code>outgoingMessage.end()</code>, this property will be nulled.</p>
+<h4><code>outgoingMessage.uncork()</code><span><a class="mark" href="#http_outgoingmessage_uncork" id="http_outgoingmessage_uncork">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.0.0</span>
+</div>
+<p>See <a href="stream.html#stream_writable_uncork"><code>writable.uncork()</code></a></p>
+<h4><code>outgoingMessage.writableCorked</code><span><a class="mark" href="#http_outgoingmessage_writablecorked" id="http_outgoingmessage_writablecorked">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>This <code>outgoingMessage.writableCorked</code> will return the time how many
+<code>outgoingMessage.cork()</code> have been called.</p>
+<h4><code>outgoingMessage.writableEnded</code><span><a class="mark" href="#http_outgoingmessage_writableended" id="http_outgoingmessage_writableended">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Readonly, <code>true</code> if <code>outgoingMessage.end()</code> has been called. Noted that
+this property does not reflect whether the data has been flush. For that
+purpose, use <code>message.writableFinished</code> instead.</p>
+<h4><code>outgoingMessage.writableFinished</code><span><a class="mark" href="#http_outgoingmessage_writablefinished" id="http_outgoingmessage_writablefinished">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Readonly. <code>true</code> if all data has been flushed to the underlying system.</p>
+<h4><code>outgoingMessage.writableHighWaterMark</code><span><a class="mark" href="#http_outgoingmessage_writablehighwatermark" id="http_outgoingmessage_writablehighwatermark">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>This <code>outgoingMessage.writableHighWaterMark</code> will be the <code>highWaterMark</code> of
+underlying socket if socket exists. Else, it would be the default
+<code>highWaterMark</code>.</p>
+<p><code>highWaterMark</code> is the maximum amount of data that can be potentially
+buffered by the socket.</p>
+<h4><code>outgoingMessage.writableLength</code><span><a class="mark" href="#http_outgoingmessage_writablelength" id="http_outgoingmessage_writablelength">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>Readonly, This <code>outgoingMessage.writableLength</code> contains the number of
+bytes (or objects) in the buffer ready to send.</p>
+<h4><code>outgoingMessage.writableObjectMode</code><span><a class="mark" href="#http_outgoingmessage_writableobjectmode" id="http_outgoingmessage_writableobjectmode">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v13.0.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Readonly, always returns <code>false</code>.</p>
+<h4><code>outgoingMessage.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http_outgoingmessage_write_chunk_encoding_callback" id="http_outgoingmessage_write_chunk_encoding_callback">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v0.11.6</td>
+<td><p>add <code>callback</code> argument.</p></td></tr>
+<tr><td>v0.1.29</td>
+<td><p><span>Added in: v0.1.29</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><code>chunk</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> <strong>Default</strong>: <code>utf-8</code></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>If this method is called and the header is not sent, it will call
+<code>this._implicitHeader</code> to flush implicit header.
+If the message should not have a body (indicated by <code>this._hasBody</code>),
+the call is ignored and <code>chunk</code> will not be sent. It could be useful
+when handling a particular message which must not include a body.
+e.g. response to <code>HEAD</code> request, <code>204</code> and <code>304</code> response.</p>
+<p><code>chunk</code> can be a string or a buffer. When <code>chunk</code> is a string, the
+<code>encoding</code> parameter specifies how to encode <code>chunk</code> into a byte stream.
+<code>callback</code> will be called when the <code>chunk</code> is flushed.</p>
+<p>If the message is transferred in chucked encoding
+(indicated by <code>this.chunkedEncoding</code>), <code>chunk</code> will be flushed as
+one chunk among a stream of chunks. Otherwise, it will be flushed as the
+body of message.</p>
+<p>This method handles the raw body of the HTTP message and has nothing to do
+with higher-level multi-part body encodings that may be used.</p>
+<p>If it is the first call to this method of a message, it will send the
+buffered header first, then flush the <code>chunk</code> as described above.</p>
+<p>The second and successive calls to this method will assume the data
+will be streamed and send the new data separately. It means that the response
+is buffered up to the first chunk of the body.</p>
+<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel
+buffer. Returns <code>false</code> if all or part of the data was queued in the user
+memory. Event <code>drain</code> will be emitted when the buffer is free again.</p>
+</section><section><h3><code>http.METHODS</code><span><a class="mark" href="#http_http_methods" id="http_http_methods">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -2032,7 +2486,7 @@ URL {
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
 <p>A list of the HTTP methods that are supported by the parser.</p>
-<h2><code>http.STATUS_CODES</code><span><a class="mark" href="#http_http_status_codes" id="http_http_status_codes">#</a></span></h2>
+</section><section><h3><code>http.STATUS_CODES</code><span><a class="mark" href="#http_http_status_codes" id="http_http_status_codes">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.22</span>
 </div>
@@ -2041,12 +2495,14 @@ URL {
 </ul>
 <p>A collection of all the standard HTTP response status codes, and the
 short description of each. For example, <code>http.STATUS_CODES[404] === 'Not Found'</code>.</p>
-<h2><code>http.createServer([options][, requestListener])</code><span><a class="mark" href="#http_http_createserver_options_requestlistener" id="http_http_createserver_options_requestlistener">#</a></span></h2>
+</section><section><h3><code>http.createServer([options][, requestListener])</code><span><a class="mark" href="#http_http_createserver_options_requestlistener" id="http_http_createserver_options_requestlistener">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.15.0</td>
+<tr><td>v13.3.0</td>
+<td><p>The <code>maxHeaderSize</code> option is supported now.</p></td></tr>
+<tr><td>v13.8.0, v12.15.0, v10.19.0</td>
 <td><p>The <code>insecureHTTPParser</code> option is supported now.</p></td></tr>
 <tr><td>v9.6.0, v8.12.0</td>
 <td><p>The <code>options</code> argument is supported now.</p></td></tr>
@@ -2069,6 +2525,10 @@ to be used. Useful for extending the original <code>ServerResponse</code>. <stro
 invalid HTTP headers when <code>true</code>. Using the insecure parser should be
 avoided. See <a href="cli.html#cli_insecure_http_parser"><code>--insecure-http-parser</code></a> for more information.
 <strong>Default:</strong> <code>false</code></li>
+<li><code>maxHeaderSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Optionally overrides the value of
+<a href="cli.html#cli_max_http_header_size_size"><code>--max-http-header-size</code></a> for requests received by this server, i.e.
+the maximum length of request headers in bytes.
+<strong>Default:</strong> 16384 (16KB).</li>
 </ul>
 </li>
 <li>
@@ -2081,8 +2541,33 @@ avoided. See <a href="cli.html#cli_insecure_http_parser"><code>--insecure-http-p
 <p>Returns a new instance of <a href="#http_class_http_server"><code>http.Server</code></a>.</p>
 <p>The <code>requestListener</code> is a function which is automatically
 added to the <a href="#http_event_request"><code>'request'</code></a> event.</p>
-<h2><code>http.get(options[, callback])</code><span><a class="mark" href="#http_http_get_options_callback" id="http_http_get_options_callback">#</a></span></h2>
-<h2><code>http.get(url[, options][, callback])</code><span><a class="mark" href="#http_http_get_url_options_callback" id="http_http_get_url_options_callback">#</a></span></h2>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><pre><code class="language-js cjs"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-comment">// Create a local server to receive data from</span>
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
+    <span class="hljs-attr">data</span>: <span class="hljs-string">'Hello World!'</span>
+  }));
+});
+
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre><code class="language-js cjs"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-comment">// Create a local server to receive data from</span>
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>();
+
+<span class="hljs-comment">// Listen to the request event</span>
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'request'</span>, <span class="hljs-function">(<span class="hljs-params">request, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
+    <span class="hljs-attr">data</span>: <span class="hljs-string">'Hello World!'</span>
+  }));
+});
+
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
+</section><section><h3><code>http.get(options[, callback])</code><span><a class="mark" href="#http_http_get_options_callback" id="http_http_get_options_callback">#</a></span></h3>
+</section><section><h3><code>http.get(url[, options][, callback])</code><span><a class="mark" href="#http_http_get_url_options_callback" id="http_http_get_url_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2112,42 +2597,52 @@ data for reasons stated in <a href="#http_class_http_clientrequest"><code>http.C
 <p>The <code>callback</code> is invoked with a single argument that is an instance of
 <a href="#http_class_http_incomingmessage"><code>http.IncomingMessage</code></a>.</p>
 <p>JSON fetching example:</p>
-<pre><code class="language-js">http.get(<span class="hljs-string">'http://nodejs.org/dist/index.json'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<pre><code class="language-js">http.<span class="hljs-title function_">get</span>(<span class="hljs-string">'http://localhost:8000/'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-keyword">const</span> { statusCode } = res;
-  <span class="hljs-keyword">const</span> contentType = res.headers[<span class="hljs-string">'content-type'</span>];
+  <span class="hljs-keyword">const</span> contentType = res.<span class="hljs-property">headers</span>[<span class="hljs-string">'content-type'</span>];
 
   <span class="hljs-keyword">let</span> error;
   <span class="hljs-comment">// Any 2xx status code signals a successful response but</span>
   <span class="hljs-comment">// here we're only checking for 200.</span>
   <span class="hljs-keyword">if</span> (statusCode !== <span class="hljs-number">200</span>) {
-    error = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Request Failed.\n'</span> +
+    error = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Request Failed.\n'</span> +
                       <span class="hljs-string">`Status Code: <span class="hljs-subst">${statusCode}</span>`</span>);
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!<span class="hljs-regexp">/^application\/json/</span>.test(contentType)) {
-    error = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Invalid content-type.\n'</span> +
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!<span class="hljs-regexp">/^application\/json/</span>.<span class="hljs-title function_">test</span>(contentType)) {
+    error = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Invalid content-type.\n'</span> +
                       <span class="hljs-string">`Expected application/json but received <span class="hljs-subst">${contentType}</span>`</span>);
   }
   <span class="hljs-keyword">if</span> (error) {
-    <span class="hljs-built_in">console</span>.error(error.message);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(error.<span class="hljs-property">message</span>);
     <span class="hljs-comment">// Consume response data to free up memory</span>
-    res.resume();
+    res.<span class="hljs-title function_">resume</span>();
     <span class="hljs-keyword">return</span>;
   }
 
-  res.setEncoding(<span class="hljs-string">'utf8'</span>);
+  res.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
   <span class="hljs-keyword">let</span> rawData = <span class="hljs-string">''</span>;
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { rawData += chunk; });
-  res.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { rawData += chunk; });
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-keyword">try</span> {
-      <span class="hljs-keyword">const</span> parsedData = <span class="hljs-built_in">JSON</span>.parse(rawData);
-      <span class="hljs-built_in">console</span>.log(parsedData);
+      <span class="hljs-keyword">const</span> parsedData = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(rawData);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(parsedData);
     } <span class="hljs-keyword">catch</span> (e) {
-      <span class="hljs-built_in">console</span>.error(e.message);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(e.<span class="hljs-property">message</span>);
     }
   });
-}).on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`Got error: <span class="hljs-subst">${e.message}</span>`</span>);
-});</code></pre>
-<h2><code>http.globalAgent</code><span><a class="mark" href="#http_http_globalagent" id="http_http_globalagent">#</a></span></h2>
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`Got error: <span class="hljs-subst">${e.message}</span>`</span>);
+});
+
+<span class="hljs-comment">// Create a local server to receive data from</span>
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
+    <span class="hljs-attr">data</span>: <span class="hljs-string">'Hello World!'</span>
+  }));
+});
+
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
+</section><section><h3><code>http.globalAgent</code><span><a class="mark" href="#http_http_globalagent" id="http_http_globalagent">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -2156,22 +2651,30 @@ data for reasons stated in <a href="#http_class_http_clientrequest"><code>http.C
 </ul>
 <p>Global instance of <code>Agent</code> which is used as the default for all HTTP client
 requests.</p>
-<h2><code>http.maxHeaderSize</code><span><a class="mark" href="#http_http_maxheadersize" id="http_http_maxheadersize">#</a></span></h2>
+</section><section><h3><code>http.maxHeaderSize</code><span><a class="mark" href="#http_http_maxheadersize" id="http_http_maxheadersize">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.6.0</span>
+<span>Added in: v11.6.0, v10.15.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Read-only property specifying the maximum allowed size of HTTP headers in bytes.
 Defaults to 8KB. Configurable using the <a href="cli.html#cli_max_http_header_size_size"><code>--max-http-header-size</code></a> CLI option.</p>
-<h2><code>http.request(options[, callback])</code><span><a class="mark" href="#http_http_request_options_callback" id="http_http_request_options_callback">#</a></span></h2>
-<h2><code>http.request(url[, options][, callback])</code><span><a class="mark" href="#http_http_request_url_options_callback" id="http_http_request_url_options_callback">#</a></span></h2>
+<p>This can be overridden for servers and client requests by passing the
+<code>maxHeaderSize</code> option.</p>
+</section><section><h3><code>http.request(options[, callback])</code><span><a class="mark" href="#http_http_request_options_callback" id="http_http_request_options_callback">#</a></span></h3>
+</section><section><h3><code>http.request(url[, options][, callback])</code><span><a class="mark" href="#http_http_request_url_options_callback" id="http_http_request_url_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.15.0</td>
+<tr><td>v14.18.0</td>
+<td><p>When using a <code>URL</code> object parsed username and password will now be properly URI decoded.</p></td></tr>
+<tr><td>v14.17.0</td>
+<td><p>It is possible to abort a request with an AbortSignal.</p></td></tr>
+<tr><td>v13.3.0</td>
+<td><p>The <code>maxHeaderSize</code> option is supported now.</p></td></tr>
+<tr><td>v13.8.0, v12.15.0, v10.19.0</td>
 <td><p>The <code>insecureHTTPParser</code> option is supported now.</p></td></tr>
 <tr><td>v10.9.0</td>
 <td><p>The <code>url</code> parameter can now be passed along with a separate <code>options</code> object.</p></td></tr>
@@ -2207,6 +2710,7 @@ details. Any <a href="stream.html#stream_class_stream_duplex"><code>Duplex</code
 <code>hostname</code>. Valid values are <code>4</code> or <code>6</code>. When unspecified, both IP v4 and
 v6 will be used.</li>
 <li><code>headers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> An object containing request headers.</li>
+<li><code>hints</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Optional <a href="dns.html#dns_supported_getaddrinfo_flags"><code>dns.lookup()</code> hints</a>.</li>
 <li><code>host</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A domain name or IP address of the server to issue the
 request to. <strong>Default:</strong> <code>'localhost'</code>.</li>
 <li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Alias for <code>host</code>. To support <a href="url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a>,
@@ -2216,7 +2720,12 @@ invalid HTTP headers when <code>true</code>. Using the insecure parser should be
 avoided. See <a href="cli.html#cli_insecure_http_parser"><code>--insecure-http-parser</code></a> for more information.
 <strong>Default:</strong> <code>false</code></li>
 <li><code>localAddress</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Local interface to bind for network connections.</li>
+<li><code>localPort</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Local port to connect from.</li>
 <li><code>lookup</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Custom lookup function. <strong>Default:</strong> <a href="dns.html#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>.</li>
+<li><code>maxHeaderSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Optionally overrides the value of
+<a href="cli.html#cli_max_http_header_size_size"><code>--max-http-header-size</code></a> for requests received from the server, i.e.
+the maximum length of response headers in bytes.
+<strong>Default:</strong> 16384 (16KB).</li>
 <li><code>method</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A string specifying the HTTP request method. <strong>Default:</strong>
 <code>'GET'</code>.</li>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Request path. Should include query string if any.
@@ -2232,6 +2741,8 @@ else <code>80</code>.</li>
 or <code>port</code> is specified, those specify a TCP Socket).</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a>: A number specifying the socket timeout in milliseconds.
 This will set the timeout before the socket is connected.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a>: An AbortSignal that may be used to abort an ongoing
+request.</li>
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
@@ -2249,7 +2760,9 @@ the <a href="#http_event_response"><code>'response'</code></a> event.</p>
 <p><code>http.request()</code> returns an instance of the <a href="#http_class_http_clientrequest"><code>http.ClientRequest</code></a>
 class. The <code>ClientRequest</code> instance is a writable stream. If one needs to
 upload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> postData = querystring.stringify({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-keyword">const</span> postData = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
   <span class="hljs-string">'msg'</span>: <span class="hljs-string">'Hello World!'</span>
 });
 
@@ -2259,30 +2772,30 @@ upload a file with a POST request, then write to the <code>ClientRequest</code>
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/upload'</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'POST'</span>,
   <span class="hljs-attr">headers</span>: {
-    <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/x-www-form-urlencoded'</span>,
-    <span class="hljs-string">'Content-Length'</span>: Buffer.byteLength(postData)
+    <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span>,
+    <span class="hljs-string">'Content-Length'</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(postData)
   }
 };
 
-<span class="hljs-keyword">const</span> req = http.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`STATUS: <span class="hljs-subst">${res.statusCode}</span>`</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`HEADERS: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(res.headers)}</span>`</span>);
-  res.setEncoding(<span class="hljs-string">'utf8'</span>);
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`BODY: <span class="hljs-subst">${chunk}</span>`</span>);
+<span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`STATUS: <span class="hljs-subst">${res.statusCode}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`HEADERS: <span class="hljs-subst">${<span class="hljs-built_in">JSON</span>.stringify(res.headers)}</span>`</span>);
+  res.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`BODY: <span class="hljs-subst">${chunk}</span>`</span>);
   });
-  res.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'No more data in response.'</span>);
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'No more data in response.'</span>);
   });
 });
 
-req.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`problem with request: <span class="hljs-subst">${e.message}</span>`</span>);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`problem with request: <span class="hljs-subst">${e.message}</span>`</span>);
 });
 
 <span class="hljs-comment">// Write data to request body</span>
-req.write(postData);
-req.end();</code></pre>
+req.<span class="hljs-title function_">write</span>(postData);
+req.<span class="hljs-title function_">end</span>();</code></pre>
 <p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one
 must always call <code>req.end()</code> to signify the end of the request -
 even if there is no data being written to the request body.</p>
@@ -2311,9 +2824,9 @@ to compute basic authentication.</p>
 </li>
 </ul>
 <p>Example using a <a href="url.html#url_the_whatwg_url_api"><code>URL</code></a> as <code>options</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> options = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http://abc:xyz@example.com'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> options = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http://abc:xyz@example.com'</span>);
 
-<span class="hljs-keyword">const</span> req = http.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<span class="hljs-keyword">const</span> req = http.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>In a successful request, the following events will be emitted in the following
@@ -2336,8 +2849,68 @@ instance, in most redirects)</li>
 <li><code>'error'</code></li>
 <li><code>'close'</code></li>
 </ul>
-<p>If <code>req.abort()</code> is called before the connection succeeds, the following events
-will be emitted in the following order:</p>
+<p>In the case of a premature connection close before the response is received,
+the following events will be emitted in the following order:</p>
+<ul>
+<li><code>'socket'</code></li>
+<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code
+<code>'ECONNRESET'</code></li>
+<li><code>'close'</code></li>
+</ul>
+<p>In the case of a premature connection close after the response is received,
+the following events will be emitted in the following order:</p>
+<ul>
+<li><code>'socket'</code></li>
+<li><code>'response'</code>
+<ul>
+<li><code>'data'</code> any number of times, on the <code>res</code> object</li>
+</ul>
+</li>
+<li>(connection closed here)</li>
+<li><code>'aborted'</code> on the <code>res</code> object</li>
+<li><code>'close'</code></li>
+<li><code>'close'</code> on the <code>res</code> object</li>
+</ul>
+<p>If <code>req.destroy()</code> is called before a socket is assigned, the following
+events will be emitted in the following order:</p>
+<ul>
+<li>(<code>req.destroy()</code> called here)</li>
+<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code
+<code>'ECONNRESET'</code></li>
+<li><code>'close'</code></li>
+</ul>
+<p>If <code>req.destroy()</code> is called before the connection succeeds, the following
+events will be emitted in the following order:</p>
+<ul>
+<li><code>'socket'</code></li>
+<li>(<code>req.destroy()</code> called here)</li>
+<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code
+<code>'ECONNRESET'</code></li>
+<li><code>'close'</code></li>
+</ul>
+<p>If <code>req.destroy()</code> is called after the response is received, the following
+events will be emitted in the following order:</p>
+<ul>
+<li><code>'socket'</code></li>
+<li><code>'response'</code>
+<ul>
+<li><code>'data'</code> any number of times, on the <code>res</code> object</li>
+</ul>
+</li>
+<li>(<code>req.destroy()</code> called here)</li>
+<li><code>'aborted'</code> on the <code>res</code> object</li>
+<li><code>'close'</code></li>
+<li><code>'close'</code> on the <code>res</code> object</li>
+</ul>
+<p>If <code>req.abort()</code> is called before a socket is assigned, the following
+events will be emitted in the following order:</p>
+<ul>
+<li>(<code>req.abort()</code> called here)</li>
+<li><code>'abort'</code></li>
+<li><code>'close'</code></li>
+</ul>
+<p>If <code>req.abort()</code> is called before the connection succeeds, the following
+events will be emitted in the following order:</p>
 <ul>
 <li><code>'socket'</code></li>
 <li>(<code>req.abort()</code> called here)</li>
@@ -2346,8 +2919,8 @@ will be emitted in the following order:</p>
 <code>'ECONNRESET'</code></li>
 <li><code>'close'</code></li>
 </ul>
-<p>If <code>req.abort()</code> is called after the response is received, the following events
-will be emitted in the following order:</p>
+<p>If <code>req.abort()</code> is called after the response is received, the following
+events will be emitted in the following order:</p>
 <ul>
 <li><code>'socket'</code></li>
 <li><code>'response'</code>
@@ -2359,14 +2932,111 @@ will be emitted in the following order:</p>
 <li><code>'abort'</code></li>
 <li><code>'aborted'</code> on the <code>res</code> object</li>
 <li><code>'close'</code></li>
-<li><code>'end'</code> on the <code>res</code> object</li>
 <li><code>'close'</code> on the <code>res</code> object</li>
 </ul>
 <p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will
 not abort the request or do anything besides add a <code>'timeout'</code> event.</p>
+<p>Passing an <code>AbortSignal</code> and then calling <code>abort</code> on the corresponding
+<code>AbortController</code> will behave the same way as calling <code>.destroy()</code> on the
+request itself.</p>
+</section><section><h3><code>http.validateHeaderName(name)</code><span><a class="mark" href="#http_http_validateheadername_name" id="http_http_validateheadername_name">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.3.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Performs the low-level validations on the provided <code>name</code> that are done when
+<code>res.setHeader(name, value)</code> is called.</p>
+<p>Passing illegal value as <code>name</code> will result in a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> being thrown,
+identified by <code>code: 'ERR_INVALID_HTTP_TOKEN'</code>.</p>
+<p>It is not necessary to use this method before passing headers to an HTTP request
+or response. The HTTP module will automatically validate such headers.
+Examples:</p>
+<p>Example:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { validateHeaderName } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">validateHeaderName</span>(<span class="hljs-string">''</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  err <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">TypeError</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">code</span>; <span class="hljs-comment">// --> 'ERR_INVALID_HTTP_TOKEN'</span>
+  err.<span class="hljs-property">message</span>; <span class="hljs-comment">// --> 'Header name must be a valid HTTP token [""]'</span>
+}</code></pre>
+</section><section><h3><code>http.validateHeaderValue(name, value)</code><span><a class="mark" href="#http_http_validateheadervalue_name_value" id="http_http_validateheadervalue_name_value">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.3.0</span>
+</div>
+<ul>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
+</ul>
+<p>Performs the low-level validations on the provided <code>value</code> that are done when
+<code>res.setHeader(name, value)</code> is called.</p>
+<p>Passing illegal value as <code>value</code> will result in a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
+<ul>
+<li>Undefined value error is identified by <code>code: 'ERR_HTTP_INVALID_HEADER_VALUE'</code>.</li>
+<li>Invalid value character error is identified by <code>code: 'ERR_INVALID_CHAR'</code>.</li>
+</ul>
+<p>It is not necessary to use this method before passing headers to an HTTP request
+or response. The HTTP module will automatically validate such headers.</p>
+<p>Examples:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { validateHeaderValue } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">validateHeaderValue</span>(<span class="hljs-string">'x-my-header'</span>, <span class="hljs-literal">undefined</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  err <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">TypeError</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">code</span> === <span class="hljs-string">'ERR_HTTP_INVALID_HEADER_VALUE'</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">message</span>; <span class="hljs-comment">// --> 'Invalid value "undefined" for header "x-my-header"'</span>
+}
+
+<span class="hljs-keyword">try</span> {
+  <span class="hljs-title function_">validateHeaderValue</span>(<span class="hljs-string">'x-my-header'</span>, <span class="hljs-string">'oʊmɪɡə'</span>);
+} <span class="hljs-keyword">catch</span> (err) {
+  err <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">TypeError</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">code</span> === <span class="hljs-string">'ERR_INVALID_CHAR'</span>; <span class="hljs-comment">// --> true</span>
+  err.<span class="hljs-property">message</span>; <span class="hljs-comment">// --> 'Invalid character in header content ["x-my-header"]'</span>
+}</code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/http.json b/doc/api/http.json
index 8b6ec78f45c0e47717bf99e7642ee1ecaa5cbf7d..4d7a943a63d7754c7dedcc2d7c35a5a93f323280 100644
--- a/doc/api/http.json
+++ b/doc/api/http.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/http.js\">lib/http.js</a></p>\n<p>To use the HTTP server and client one must <code>require('http')</code>.</p>\n<p>The HTTP interfaces in Node.js are designed to support many features\nof the protocol which have been traditionally difficult to use.\nIn particular, large, possibly chunk-encoded, messages. The interface is\ncareful to never buffer entire requests or responses, so the\nuser is able to stream data.</p>\n<p>HTTP message headers are represented by an object like this:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{ 'content-length': '123',\n  'content-type': 'text/plain',\n  'connection': 'keep-alive',\n  'host': 'mysite.com',\n  'accept': '*/*' }\n</code></pre>\n<p>Keys are lowercased. Values are not modified.</p>\n<p>In order to support the full spectrum of possible HTTP applications, the Node.js\nHTTP API is very low-level. It deals with stream handling and message\nparsing only. It parses a message into headers and body but it does not\nparse the actual headers or the body.</p>\n<p>See <a href=\"#http_message_headers\"><code>message.headers</code></a> for details on how duplicate headers are handled.</p>\n<p>The raw headers as they were received are retained in the <code>rawHeaders</code>\nproperty, which is an array of <code>[key, value, key2, value2, ...]</code>. For\nexample, the previous message header object might have a <code>rawHeaders</code>\nlist like the following:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[ 'ConTent-Length', '123456',\n  'content-LENGTH', '123',\n  'content-type', 'text/plain',\n  'CONNECTION', 'keep-alive',\n  'Host', 'mysite.com',\n  'accepT', '*/*' ]\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/http.js\">lib/http.js</a></p>\n<p>To use the HTTP server and client one must <code>require('http')</code>.</p>\n<p>The HTTP interfaces in Node.js are designed to support many features\nof the protocol which have been traditionally difficult to use.\nIn particular, large, possibly chunk-encoded, messages. The interface is\ncareful to never buffer entire requests or responses, so the\nuser is able to stream data.</p>\n<p>HTTP message headers are represented by an object like this:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{ 'content-length': '123',\n  'content-type': 'text/plain',\n  'connection': 'keep-alive',\n  'host': 'mysite.com',\n  'accept': '*/*' }\n</code></pre>\n<p>Keys are lowercased. Values are not modified.</p>\n<p>In order to support the full spectrum of possible HTTP applications, the Node.js\nHTTP API is very low-level. It deals with stream handling and message\nparsing only. It parses a message into headers and body but it does not\nparse the actual headers or the body.</p>\n<p>See <a href=\"#http_message_headers\"><code>message.headers</code></a> for details on how duplicate headers are handled.</p>\n<p>The raw headers as they were received are retained in the <code>rawHeaders</code>\nproperty, which is an array of <code>[key, value, key2, value2, ...]</code>. For\nexample, the previous message header object might have a <code>rawHeaders</code>\nlist like the following:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[ 'ConTent-Length', '123456',\n  'content-LENGTH', '123',\n  'content-type', 'text/plain',\n  'CONNECTION', 'keep-alive',\n  'Host', 'mysite.com',\n  'accepT', '*/*' ]\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `http.Agent`",
@@ -123,7 +123,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Destroy any sockets that are currently in use by the agent.</p>\n<p>It is usually not necessary to do this. However, if using an\nagent with <code>keepAlive</code> enabled, then it is best to explicitly shut down\nthe agent when it will no longer be used. Otherwise,\nsockets may hang open for quite a long time before the server\nterminates them.</p>"
+              "desc": "<p>Destroy any sockets that are currently in use by the agent.</p>\n<p>It is usually not necessary to do this. However, if using an\nagent with <code>keepAlive</code> enabled, then it is best to explicitly shut down\nthe agent when it is no longer needed. Otherwise,\nsockets might stay open for quite a long time before the server\nterminates them.</p>"
             },
             {
               "textRaw": "`agent.getName(options)`",
@@ -224,7 +224,7 @@
               "name": "maxTotalSockets",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -272,18 +272,18 @@
                       "desc": "Keep sockets around even when there are no outstanding requests, so they can be used for future requests without having to reestablish a TCP connection. Not to be confused with the `keep-alive` value of the `Connection` header. The `Connection: keep-alive` header is always sent when using an agent except when the `Connection` header is explicitly specified or when the `keepAlive` and `maxSockets` options are respectively set to `false` and `Infinity`, in which case `Connection: close` will be used."
                     },
                     {
-                      "textRaw": "`keepAliveMsecs` {number} When using the `keepAlive` option, specifies the [initial delay](net.html#net_socket_setkeepalive_enable_initialdelay) for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`. **Default:** `1000`.",
+                      "textRaw": "`keepAliveMsecs` {number} When using the `keepAlive` option, specifies the [initial delay](net.md#net_socket_setkeepalive_enable_initialdelay) for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`. **Default:** `1000`.",
                       "name": "keepAliveMsecs",
                       "type": "number",
                       "default": "`1000`",
-                      "desc": "When using the `keepAlive` option, specifies the [initial delay](net.html#net_socket_setkeepalive_enable_initialdelay) for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`."
+                      "desc": "When using the `keepAlive` option, specifies the [initial delay](net.md#net_socket_setkeepalive_enable_initialdelay) for TCP Keep-Alive packets. Ignored when the `keepAlive` option is `false` or `undefined`."
                     },
                     {
-                      "textRaw": "`maxSockets` {number} Maximum number of sockets to allow per host. Each request will use a new socket until the maximum is reached. **Default:** `Infinity`.",
+                      "textRaw": "`maxSockets` {number} Maximum number of sockets to allow per host. If the same host opens multiple concurrent connections, each request will use new socket until the `maxSockets` value is reached. If the host attempts to open more connections than `maxSockets`, the additional requests will enter into a pending request queue, and will enter active connection state when an existing connection terminates. This makes sure there are at most `maxSockets` active connections at any point in time, from a given host. **Default:** `Infinity`.",
                       "name": "maxSockets",
                       "type": "number",
                       "default": "`Infinity`",
-                      "desc": "Maximum number of sockets to allow per host. Each request will use a new socket until the maximum is reached."
+                      "desc": "Maximum number of sockets to allow per host. If the same host opens multiple concurrent connections, each request will use new socket until the `maxSockets` value is reached. If the host attempts to open more connections than `maxSockets`, the additional requests will enter into a pending request queue, and will enter active connection state when an existing connection terminates. This makes sure there are at most `maxSockets` active connections at any point in time, from a given host."
                     },
                     {
                       "textRaw": "`maxTotalSockets` {number} Maximum number of sockets allowed for all hosts in total. Each request will use a new socket until the maximum is reached. **Default:** `Infinity`.",
@@ -300,10 +300,10 @@
                       "desc": "Maximum number of sockets to leave open in a free state. Only relevant if `keepAlive` is set to `true`."
                     },
                     {
-                      "textRaw": "`scheduling` {string} Scheduling strategy to apply when picking the next free socket to use. It can be `'fifo'` or `'lifo'`. The main difference between the two scheduling strategies is that `'lifo'` selects the most recently used socket, while `'fifo'` selects the least recently used socket. In case of a low rate of request per second, the `'lifo'` scheduling will lower the risk of picking a socket that might have been closed by the server due to inactivity. In case of a high rate of request per second, the `'fifo'` scheduling will maximize the number of open sockets, while the `'lifo'` scheduling will keep it as low as possible. **Default:** `'fifo'`.",
+                      "textRaw": "`scheduling` {string} Scheduling strategy to apply when picking the next free socket to use. It can be `'fifo'` or `'lifo'`. The main difference between the two scheduling strategies is that `'lifo'` selects the most recently used socket, while `'fifo'` selects the least recently used socket. In case of a low rate of request per second, the `'lifo'` scheduling will lower the risk of picking a socket that might have been closed by the server due to inactivity. In case of a high rate of request per second, the `'fifo'` scheduling will maximize the number of open sockets, while the `'lifo'` scheduling will keep it as low as possible. **Default:** `'lifo'`.",
                       "name": "scheduling",
                       "type": "string",
-                      "default": "`'fifo'`",
+                      "default": "`'lifo'`",
                       "desc": "Scheduling strategy to apply when picking the next free socket to use. It can be `'fifo'` or `'lifo'`. The main difference between the two scheduling strategies is that `'lifo'` selects the most recently used socket, while `'fifo'` selects the least recently used socket. In case of a low rate of request per second, the `'lifo'` scheduling will lower the risk of picking a socket that might have been closed by the server due to inactivity. In case of a high rate of request per second, the `'fifo'` scheduling will maximize the number of open sockets, while the `'lifo'` scheduling will keep it as low as possible."
                     },
                     {
@@ -532,8 +532,13 @@
                 "added": [
                   "v0.3.8"
                 ],
+                "deprecated": [
+                  "v14.1.0"
+                ],
                 "changes": []
               },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use [`request.destroy()`][] instead.",
               "signatures": [
                 {
                   "params": []
@@ -585,6 +590,55 @@
               ],
               "desc": "<p>Finishes sending the request. If any parts of the body are\nunsent, it will flush them to the stream. If the request is\nchunked, this will send the terminating <code>'0\\r\\n\\r\\n'</code>.</p>\n<p>If <code>data</code> is specified, it is equivalent to calling\n<a href=\"#http_request_write_chunk_encoding_callback\"><code>request.write(data, encoding)</code></a> followed by <code>request.end(callback)</code>.</p>\n<p>If <code>callback</code> is specified, it will be called when the request stream\nis finished.</p>"
             },
+            {
+              "textRaw": "`request.destroy([error])`",
+              "type": "method",
+              "name": "destroy",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32789",
+                    "description": "The function returns `this` for consistency with other Readable streams."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {this}",
+                    "name": "return",
+                    "type": "this"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`error` {Error} Optional, an error to emit with `'error'` event.",
+                      "name": "error",
+                      "type": "Error",
+                      "desc": "Optional, an error to emit with `'error'` event."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Destroy the request. Optionally emit an <code>'error'</code> event,\nand emit a <code>'close'</code> event. Calling this will cause remaining data\nin the response to be dropped and the socket to be destroyed.</p>\n<p>See <a href=\"stream.html#stream_writable_destroy_error\"><code>writable.destroy()</code></a> for further details.</p>",
+              "properties": [
+                {
+                  "textRaw": "`destroyed` {boolean}",
+                  "type": "boolean",
+                  "name": "destroyed",
+                  "meta": {
+                    "added": [
+                      "v14.1.0"
+                    ],
+                    "changes": []
+                  },
+                  "desc": "<p>Is <code>true</code> after <a href=\"#http_request_destroy_error\"><code>request.destroy()</code></a> has been called.</p>\n<p>See <a href=\"stream.html#stream_writable_destroyed\"><code>writable.destroyed</code></a> for further details.</p>"
+                }
+              ]
+            },
             {
               "textRaw": "`request.flushHeaders()`",
               "type": "method",
@@ -630,6 +684,28 @@
               ],
               "desc": "<p>Reads out a header on the request. The name is case-insensitive.\nThe type of the return value depends on the arguments provided to\n<a href=\"#http_request_setheader_name_value\"><code>request.setHeader()</code></a>.</p>\n<pre><code class=\"language-js\">request.setHeader('content-type', 'text/html');\nrequest.setHeader('Content-Length', Buffer.byteLength(body));\nrequest.setHeader('Cookie', ['type=ninja', 'language=javascript']);\nconst contentType = request.getHeader('Content-Type');\n// 'contentType' is 'text/html'\nconst contentLength = request.getHeader('Content-Length');\n// 'contentLength' is of type number\nconst cookie = request.getHeader('Cookie');\n// 'cookie' is of type string[]\n</code></pre>"
             },
+            {
+              "textRaw": "`request.getRawHeaderNames()`",
+              "type": "method",
+              "name": "getRawHeaderNames",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {string[]}",
+                    "name": "return",
+                    "type": "string[]"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns an array containing the unique names of the current outgoing raw\nheaders. Header names are returned with their exact casing being set.</p>\n<pre><code class=\"language-js\">request.setHeader('Foo', 'bar');\nrequest.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);\n\nconst headerNames = request.getRawHeaderNames();\n// headerNames === ['Foo', 'Set-Cookie']\n</code></pre>"
+            },
             {
               "textRaw": "`request.removeHeader(name)`",
               "type": "method",
@@ -809,7 +885,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Sends a chunk of the body. By calling this method\nmany times, a request body can be sent to a\nserver. In that case, it is suggested to use the\n<code>['Transfer-Encoding', 'chunked']</code> header line when\ncreating the request.</p>\n<p>The <code>encoding</code> argument is optional and only applies when <code>chunk</code> is a string.\nDefaults to <code>'utf8'</code>.</p>\n<p>The <code>callback</code> argument is optional and will be called when this chunk of data\nis flushed, but only if the chunk is non-empty.</p>\n<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel\nbuffer. Returns <code>false</code> if all or part of the data was queued in user memory.\n<code>'drain'</code> will be emitted when the buffer is free again.</p>\n<p>When <code>write</code> function is called with empty string or buffer, it does\nnothing and waits for more input.</p>"
+              "desc": "<p>Sends a chunk of the body. This method can be called multiple times. If no\n<code>Content-Length</code> is set, data will automatically be encoded in HTTP Chunked\ntransfer encoding, so that server knows when the data ends. The\n<code>Transfer-Encoding: chunked</code> header is added. Calling <a href=\"#http_request_end_data_encoding_callback\"><code>request.end()</code></a>\nis necessary to finish sending the request.</p>\n<p>The <code>encoding</code> argument is optional and only applies when <code>chunk</code> is a string.\nDefaults to <code>'utf8'</code>.</p>\n<p>The <code>callback</code> argument is optional and will be called when this chunk of data\nis flushed, but only if the chunk is non-empty.</p>\n<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel\nbuffer. Returns <code>false</code> if all or part of the data was queued in user memory.\n<code>'drain'</code> will be emitted when the buffer is free again.</p>\n<p>When <code>write</code> function is called with empty string or buffer, it does\nnothing and waits for more input.</p>"
             }
           ],
           "properties": [
@@ -839,8 +915,13 @@
                 "added": [
                   "v0.3.0"
                 ],
+                "deprecated": [
+                  "v13.0.0"
+                ],
                 "changes": []
               },
+              "stability": 0,
+              "stabilityText": "Deprecated. Use [`request.socket`][].",
               "desc": "<p>See <a href=\"#http_request_socket\"><code>request.socket</code></a>.</p>"
             },
             {
@@ -852,6 +933,7 @@
                   "v0.0.1"
                 ],
                 "deprecated": [
+                  "v13.4.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -897,7 +979,7 @@
               "name": "host",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -909,7 +991,7 @@
               "name": "protocol",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -921,6 +1003,7 @@
               "name": "reusedSocket",
               "meta": {
                 "added": [
+                  "v13.0.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -938,7 +1021,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Reference to the underlying socket. Usually users will not want to access\nthis property. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. The <code>socket</code>\nmay also be accessed via <code>request.connection</code>.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst options = {\n  host: 'www.google.com',\n};\nconst req = http.get(options);\nreq.end();\nreq.once('response', (res) => {\n  const ip = req.socket.localAddress;\n  const port = req.socket.localPort;\n  console.log(`Your IP address is ${ip} and your source port is ${port}.`);\n  // Consume response object\n});\n</code></pre>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "desc": "<p>Reference to the underlying socket. Usually users will not want to access\nthis property. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst options = {\n  host: 'www.google.com',\n};\nconst req = http.get(options);\nreq.end();\nreq.once('response', (res) => {\n  const ip = req.socket.localAddress;\n  const port = req.socket.localPort;\n  console.log(`Your IP address is ${ip} and your source port is ${port}.`);\n  // Consume response object\n});\n</code></pre>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
             },
             {
               "textRaw": "`writableEnded` {boolean}",
@@ -1036,9 +1119,9 @@
                 ],
                 "changes": [
                   {
-                    "version": "v6.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/4557",
-                    "description": "The default action of calling `.destroy()` on the `socket` will no longer take place if there are listeners attached for `'clientError'`."
+                    "version": "v12.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/25605",
+                    "description": "The default behavior will return a 431 Request Header Fields Too Large if a HPE_HEADER_OVERFLOW error occurs."
                   },
                   {
                     "version": "v9.4.0",
@@ -1046,9 +1129,9 @@
                     "description": "The `rawPacket` is the current buffer that just parsed. Adding this buffer to the error object of `'clientError'` event is to make it possible that developers can log the broken packet."
                   },
                   {
-                    "version": "v12.0.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/25605",
-                    "description": "The default behavior will return a 431 Request Header Fields Too Large if a HPE_HEADER_OVERFLOW error occurs."
+                    "version": "v6.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/4557",
+                    "description": "The default action of calling `.destroy()` on the `socket` will no longer take place if there are listeners attached for `'clientError'`."
                   }
                 ]
               },
@@ -1128,7 +1211,7 @@
                   "type": "stream.Duplex"
                 }
               ],
-              "desc": "<p>This event is emitted when a new TCP stream is established. <code>socket</code> is\ntypically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>. Usually users will not want to\naccess this event. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. The <code>socket</code> can\nalso be accessed at <code>request.connection</code>.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>\n<p>If <code>socket.setTimeout()</code> is called here, the timeout will be replaced with\n<code>server.keepAliveTimeout</code> when the socket has served a request (if\n<code>server.keepAliveTimeout</code> is non-zero).</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "desc": "<p>This event is emitted when a new TCP stream is established. <code>socket</code> is\ntypically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>. Usually users will not want to\naccess this event. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. The <code>socket</code> can\nalso be accessed at <code>request.socket</code>.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>\n<p>If <code>socket.setTimeout()</code> is called here, the timeout will be replaced with\n<code>server.keepAliveTimeout</code> when the socket has served a request (if\n<code>server.keepAliveTimeout</code> is non-zero).</p>\n<p>This event is guaranteed to be passed an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specifies a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
             },
             {
               "textRaw": "Event: `'request'`",
@@ -1165,7 +1248,7 @@
                 "changes": [
                   {
                     "version": "v10.0.0",
-                    "pr-url": "v10.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/19981",
                     "description": "Not listening to this event no longer causes the socket to be destroyed if a client sends an Upgrade header."
                   }
                 ]
@@ -1236,7 +1319,13 @@
                 "added": [
                   "v0.9.12"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27558",
+                    "description": "The default timeout changed from 120s to 0 (no timeout)."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -1247,10 +1336,10 @@
                   },
                   "params": [
                     {
-                      "textRaw": "`msecs` {number} **Default:** `120000` (2 minutes)",
+                      "textRaw": "`msecs` {number} **Default:** 0 (no timeout)",
                       "name": "msecs",
                       "type": "number",
-                      "default": "`120000` (2 minutes)"
+                      "default": "0 (no timeout)"
                     },
                     {
                       "textRaw": "`callback` {Function}",
@@ -1260,7 +1349,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Sets the timeout value for sockets, and emits a <code>'timeout'</code> event on\nthe Server object, passing the socket as an argument, if a timeout\noccurs.</p>\n<p>If there is a <code>'timeout'</code> event listener on the Server object, then it\nwill be called with the timed-out socket as an argument.</p>\n<p>By default, the Server's timeout value is 2 minutes, and sockets are\ndestroyed automatically if they time out. However, if a callback is assigned\nto the Server's <code>'timeout'</code> event, timeouts must be handled explicitly.</p>\n<p>To change the default timeout use the <a href=\"cli.html#cli_http_server_default_timeout_milliseconds\"><code>--http-server-default-timeout</code></a>\nflag.</p>"
+              "desc": "<p>Sets the timeout value for sockets, and emits a <code>'timeout'</code> event on\nthe Server object, passing the socket as an argument, if a timeout\noccurs.</p>\n<p>If there is a <code>'timeout'</code> event listener on the Server object, then it\nwill be called with the timed-out socket as an argument.</p>\n<p>By default, the Server does not timeout sockets. However, if a callback\nis assigned to the Server's <code>'timeout'</code> event, timeouts must be handled\nexplicitly.</p>"
             }
           ],
           "properties": [
@@ -1270,12 +1359,13 @@
               "name": "headersTimeout",
               "meta": {
                 "added": [
-                  "v11.3.0"
+                  "v11.3.0",
+                  "v10.14.0"
                 ],
                 "changes": []
               },
               "default": "`60000`",
-              "desc": "<p>Limit the amount of time the parser will wait to receive the complete HTTP\nheaders.</p>\n<p>In case of inactivity, the rules defined in <a href=\"#http_server_timeout\"><code>server.timeout</code></a> apply. However,\nthat inactivity based timeout would still allow the connection to be kept open\nif the headers are being sent very slowly (by default, up to a byte per 2\nminutes). In order to prevent this, whenever header data arrives an additional\ncheck is made that more than <code>server.headersTimeout</code> milliseconds has not\npassed since the connection was established. If the check fails, a <code>'timeout'</code>\nevent is emitted on the server object, and (by default) the socket is destroyed.\nSee <a href=\"#http_server_timeout\"><code>server.timeout</code></a> for more information on how timeout behavior can be\ncustomized.</p>\n<p>A value of <code>0</code> will disable the HTTP headers timeout check.</p>"
+              "desc": "<p>Limit the amount of time the parser will wait to receive the complete HTTP\nheaders.</p>\n<p>In case of inactivity, the rules defined in <a href=\"#http_server_timeout\"><code>server.timeout</code></a> apply. However,\nthat inactivity based timeout would still allow the connection to be kept open\nif the headers are being sent very slowly (by default, up to a byte per 2\nminutes). In order to prevent this, whenever header data arrives an additional\ncheck is made that more than <code>server.headersTimeout</code> milliseconds has not\npassed since the connection was established. If the check fails, a <code>'timeout'</code>\nevent is emitted on the server object, and (by default) the socket is destroyed.\nSee <a href=\"#http_server_timeout\"><code>server.timeout</code></a> for more information on how timeout behavior can be\ncustomized.</p>"
             },
             {
               "textRaw": "`listening` {boolean} Indicates whether or not the server is listening for connections.",
@@ -1303,17 +1393,36 @@
               "desc": "<p>Limits maximum incoming headers count. If set to 0, no limit will be applied.</p>"
             },
             {
-              "textRaw": "`timeout` {number} Timeout in milliseconds. **Default:** `120000` (2 minutes).",
+              "textRaw": "`requestTimeout` {number} **Default:** `0`",
+              "type": "number",
+              "name": "requestTimeout",
+              "meta": {
+                "added": [
+                  "v14.11.0"
+                ],
+                "changes": []
+              },
+              "default": "`0`",
+              "desc": "<p>Sets the timeout value in milliseconds for receiving the entire request from\nthe client.</p>\n<p>If the timeout expires, the server responds with status 408 without\nforwarding the request to the request listener and then closes the connection.</p>\n<p>It must be set to a non-zero value (e.g. 120 seconds) to protect against\npotential Denial-of-Service attacks in case the server is deployed without a\nreverse proxy in front.</p>"
+            },
+            {
+              "textRaw": "`timeout` {number} Timeout in milliseconds. **Default:** 0 (no timeout)",
               "type": "number",
               "name": "timeout",
               "meta": {
                 "added": [
                   "v0.9.12"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27558",
+                    "description": "The default timeout changed from 120s to 0 (no timeout)."
+                  }
+                ]
               },
-              "default": "`120000` (2 minutes)",
-              "desc": "<p>The number of milliseconds of inactivity before a socket is presumed\nto have timed out.</p>\n<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>\n<p>The socket timeout logic is set up on connection, so changing this\nvalue only affects new connections to the server, not any existing connections.</p>\n<p>To change the default timeout use the <a href=\"cli.html#cli_http_server_default_timeout_milliseconds\"><code>--http-server-default-timeout</code></a>\nflag.</p>",
+              "default": "0 (no timeout)",
+              "desc": "<p>The number of milliseconds of inactivity before a socket is presumed\nto have timed out.</p>\n<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>\n<p>The socket timeout logic is set up on connection, so changing this\nvalue only affects new connections to the server, not any existing connections.</p>",
               "shortDesc": "Timeout in milliseconds."
             },
             {
@@ -1355,7 +1464,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>Indicates that the the response is completed, or its underlying connection was\nterminated prematurely (before the response completion).</p>"
+              "desc": "<p>Indicates that the response is completed, or its underlying connection was\nterminated prematurely (before the response completion).</p>"
             },
             {
               "textRaw": "Event: `'finish'`",
@@ -1401,6 +1510,7 @@
               "name": "cork",
               "meta": {
                 "added": [
+                  "v13.2.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -1608,6 +1718,11 @@
               },
               "signatures": [
                 {
+                  "return": {
+                    "textRaw": "Returns: {http.ServerResponse}",
+                    "name": "return",
+                    "type": "http.ServerResponse"
+                  },
                   "params": [
                     {
                       "textRaw": "`name` {string}",
@@ -1622,7 +1737,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Sets a single header value for implicit headers. If this header already exists\nin the to-be-sent headers, its value will be replaced. Use an array of strings\nhere to send multiple headers with the same name. Non-string values will be\nstored without modification. Therefore, <a href=\"#http_response_getheader_name\"><code>response.getHeader()</code></a> may return\nnon-string values. However, the non-string values will be converted to strings\nfor network transmission.</p>\n<pre><code class=\"language-js\">response.setHeader('Content-Type', 'text/html');\n</code></pre>\n<p>or</p>\n<pre><code class=\"language-js\">response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>\n<p>When headers have been set with <a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('ok');\n});\n</code></pre>\n<p>If <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> method is called and this method has not been\ncalled, it will directly write the supplied header values onto the network\nchannel without caching internally, and the <a href=\"#http_response_getheader_name\"><code>response.getHeader()</code></a> on the\nheader will not yield the expected result. If progressive population of headers\nis desired with potential future retrieval and modification, use\n<a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a> instead of <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>.</p>"
+              "desc": "<p>Returns the response object.</p>\n<p>Sets a single header value for implicit headers. If this header already exists\nin the to-be-sent headers, its value will be replaced. Use an array of strings\nhere to send multiple headers with the same name. Non-string values will be\nstored without modification. Therefore, <a href=\"#http_response_getheader_name\"><code>response.getHeader()</code></a> may return\nnon-string values. However, the non-string values will be converted to strings\nfor network transmission. The same response object is returned to the caller,\nto enable call chaining.</p>\n<pre><code class=\"language-js\">response.setHeader('Content-Type', 'text/html');\n</code></pre>\n<p>or</p>\n<pre><code class=\"language-js\">response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>\n<p>When headers have been set with <a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('ok');\n});\n</code></pre>\n<p>If <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> method is called and this method has not been\ncalled, it will directly write the supplied header values onto the network\nchannel without caching internally, and the <a href=\"#http_response_getheader_name\"><code>response.getHeader()</code></a> on the\nheader will not yield the expected result. If progressive population of headers\nis desired with potential future retrieval and modification, use\n<a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a> instead of <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>.</p>"
             },
             {
               "textRaw": "`response.setTimeout(msecs[, callback])`",
@@ -1663,6 +1778,7 @@
               "name": "uncork",
               "meta": {
                 "added": [
+                  "v13.2.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -1740,12 +1856,23 @@
                 ],
                 "changes": [
                   {
-                    "version": "v11.10.0",
+                    "version": "v14.14.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/35274",
+                    "description": "Allow passing headers as an array."
+                  },
+                  {
+                    "version": [
+                      "v11.10.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/25974",
                     "description": "Return `this` from `writeHead()` to allow chaining with `end()`."
                   },
                   {
-                    "version": "v5.11.0, v4.4.5",
+                    "version": [
+                      "v5.11.0",
+                      "v4.4.5"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/6291",
                     "description": "A `RangeError` is thrown if `statusCode` is not a number in the range `[100, 999]`."
                   }
@@ -1770,14 +1897,14 @@
                       "type": "string"
                     },
                     {
-                      "textRaw": "`headers` {Object}",
+                      "textRaw": "`headers` {Object|Array}",
                       "name": "headers",
-                      "type": "Object"
+                      "type": "Object|Array"
                     }
                   ]
                 }
               ],
-              "desc": "<p>Sends a response header to the request. The status code is a 3-digit HTTP\nstatus code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.\nOptionally one can give a human-readable <code>statusMessage</code> as the second\nargument.</p>\n<p>Returns a reference to the <code>ServerResponse</code>, so that calls can be chained.</p>\n<pre><code class=\"language-js\">const body = 'hello world';\nresponse\n  .writeHead(200, {\n    'Content-Length': Buffer.byteLength(body),\n    'Content-Type': 'text/plain'\n  })\n  .end(body);\n</code></pre>\n<p>This method must only be called once on a message and it must\nbe called before <a href=\"#http_response_end_data_encoding_callback\"><code>response.end()</code></a> is called.</p>\n<p>If <a href=\"#http_response_write_chunk_encoding_callback\"><code>response.write()</code></a> or <a href=\"#http_response_end_data_encoding_callback\"><code>response.end()</code></a> are called before calling\nthis, the implicit/mutable headers will be calculated and call this function.</p>\n<p>When headers have been set with <a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<p>If this method is called and <a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a> has not been called,\nit will directly write the supplied header values onto the network channel\nwithout caching internally, and the <a href=\"#http_response_getheader_name\"><code>response.getHeader()</code></a> on the header\nwill not yield the expected result. If progressive population of headers is\ndesired with potential future retrieval and modification, use\n<a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a> instead.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('ok');\n});\n</code></pre>\n<p><code>Content-Length</code> is given in bytes, not characters. Use\n<a href=\"buffer.html#buffer_static_method_buffer_bytelength_string_encoding\"><code>Buffer.byteLength()</code></a> to determine the length of the body in bytes. Node.js\ndoes not check whether <code>Content-Length</code> and the length of the body which has\nbeen transmitted are equal or not.</p>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
+              "desc": "<p>Sends a response header to the request. The status code is a 3-digit HTTP\nstatus code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.\nOptionally one can give a human-readable <code>statusMessage</code> as the second\nargument.</p>\n<p><code>headers</code> may be an <code>Array</code> where the keys and values are in the same list.\nIt is <em>not</em> a list of tuples. So, the even-numbered offsets are key values,\nand the odd-numbered offsets are the associated values. The array is in the same\nformat as <code>request.rawHeaders</code>.</p>\n<p>Returns a reference to the <code>ServerResponse</code>, so that calls can be chained.</p>\n<pre><code class=\"language-js\">const body = 'hello world';\nresponse\n  .writeHead(200, {\n    'Content-Length': Buffer.byteLength(body),\n    'Content-Type': 'text/plain'\n  })\n  .end(body);\n</code></pre>\n<p>This method must only be called once on a message and it must\nbe called before <a href=\"#http_response_end_data_encoding_callback\"><code>response.end()</code></a> is called.</p>\n<p>If <a href=\"#http_response_write_chunk_encoding_callback\"><code>response.write()</code></a> or <a href=\"#http_response_end_data_encoding_callback\"><code>response.end()</code></a> are called before calling\nthis, the implicit/mutable headers will be calculated and call this function.</p>\n<p>When headers have been set with <a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"#http_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<p>If this method is called and <a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a> has not been called,\nit will directly write the supplied header values onto the network channel\nwithout caching internally, and the <a href=\"#http_response_getheader_name\"><code>response.getHeader()</code></a> on the header\nwill not yield the expected result. If progressive population of headers is\ndesired with potential future retrieval and modification, use\n<a href=\"#http_response_setheader_name_value\"><code>response.setHeader()</code></a> instead.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\n  res.end('ok');\n});\n</code></pre>\n<p><code>Content-Length</code> is given in bytes, not characters. Use\n<a href=\"buffer.html#buffer_static_method_buffer_bytelength_string_encoding\"><code>Buffer.byteLength()</code></a> to determine the length of the body in bytes. Node.js\ndoes not check whether <code>Content-Length</code> and the length of the body which has\nbeen transmitted are equal or not.</p>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
             },
             {
               "textRaw": "`response.writeProcessing()`",
@@ -1806,8 +1933,13 @@
                 "added": [
                   "v0.3.0"
                 ],
+                "deprecated": [
+                  "v13.0.0"
+                ],
                 "changes": []
               },
+              "stability": 0,
+              "stabilityText": "Deprecated. Use [`response.socket`][].",
               "desc": "<p>See <a href=\"#http_response_socket\"><code>response.socket</code></a>.</p>"
             },
             {
@@ -1819,6 +1951,7 @@
                   "v0.0.2"
                 ],
                 "deprecated": [
+                  "v13.4.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -1861,7 +1994,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Reference to the underlying socket. Usually users will not want to access\nthis property. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. After\n<code>response.end()</code>, the property is nulled. The <code>socket</code> may also be accessed\nvia <code>response.connection</code>.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst server = http.createServer((req, res) => {\n  const ip = res.socket.remoteAddress;\n  const port = res.socket.remotePort;\n  res.end(`Your IP address is ${ip} and your source port is ${port}.`);\n}).listen(3000);\n</code></pre>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
+              "desc": "<p>Reference to the underlying socket. Usually users will not want to access\nthis property. In particular, the socket will not emit <code>'readable'</code> events\nbecause of how the protocol parser attaches to the socket. After\n<code>response.end()</code>, the property is nulled.</p>\n<pre><code class=\"language-js\">const http = require('http');\nconst server = http.createServer((req, res) => {\n  const ip = res.socket.remoteAddress;\n  const port = res.socket.remotePort;\n  res.end(`Your IP address is ${ip} and your source port is ${port}.`);\n}).listen(3000);\n</code></pre>\n<p>This property is guaranteed to be an instance of the <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a> class,\na subclass of <a href=\"stream.html#stream_class_stream_duplex\" class=\"type\">&lt;stream.Duplex&gt;</a>, unless the user specified a socket\ntype other than <a href=\"net.html#net_class_net_socket\" class=\"type\">&lt;net.Socket&gt;</a>.</p>"
             },
             {
               "textRaw": "`statusCode` {number} **Default:** `200`",
@@ -1924,7 +2057,10 @@
             ],
             "changes": [
               {
-                "version": "v12.16.0",
+                "version": [
+                  "v13.1.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/30135",
                 "description": "The `readableHighWaterMark` value mirrors that of the socket."
               }
@@ -2116,7 +2252,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32789",
                     "description": "The function returns `this` for consistency with other Readable streams."
                   }
@@ -2171,128 +2307,708 @@
                   ]
                 }
               ],
-              "desc": "<p>Calls <code>message.connection.setTimeout(msecs, callback)</code>.</p>"
+              "desc": "<p>Calls <code>message.socket.setTimeout(msecs, callback)</code>.</p>"
             }
           ]
-        }
-      ],
-      "properties": [
-        {
-          "textRaw": "`METHODS` {string[]}",
-          "type": "string[]",
-          "name": "METHODS",
-          "meta": {
-            "added": [
-              "v0.11.8"
-            ],
-            "changes": []
-          },
-          "desc": "<p>A list of the HTTP methods that are supported by the parser.</p>"
-        },
-        {
-          "textRaw": "`STATUS_CODES` {Object}",
-          "type": "Object",
-          "name": "STATUS_CODES",
-          "meta": {
-            "added": [
-              "v0.1.22"
-            ],
-            "changes": []
-          },
-          "desc": "<p>A collection of all the standard HTTP response status codes, and the\nshort description of each. For example, <code>http.STATUS_CODES[404] === 'Not Found'</code>.</p>"
-        },
-        {
-          "textRaw": "`globalAgent` {http.Agent}",
-          "type": "http.Agent",
-          "name": "globalAgent",
-          "meta": {
-            "added": [
-              "v0.5.9"
-            ],
-            "changes": []
-          },
-          "desc": "<p>Global instance of <code>Agent</code> which is used as the default for all HTTP client\nrequests.</p>"
         },
         {
-          "textRaw": "`maxHeaderSize` {number}",
-          "type": "number",
-          "name": "maxHeaderSize",
+          "textRaw": "Class: `http.OutgoingMessage`",
+          "type": "class",
+          "name": "http.OutgoingMessage",
           "meta": {
             "added": [
-              "v11.6.0"
+              "v0.1.17"
             ],
             "changes": []
           },
-          "desc": "<p>Read-only property specifying the maximum allowed size of HTTP headers in bytes.\nDefaults to 8KB. Configurable using the <a href=\"cli.html#cli_max_http_header_size_size\"><code>--max-http-header-size</code></a> CLI option.</p>"
-        }
-      ],
-      "methods": [
-        {
-          "textRaw": "`http.createServer([options][, requestListener])`",
-          "type": "method",
-          "name": "createServer",
-          "meta": {
-            "added": [
-              "v0.1.13"
-            ],
-            "changes": [
-              {
-                "version": "v12.15.0",
-                "pr-url": "https://github.com/nodejs/node/pull/31448",
-                "description": "The `insecureHTTPParser` option is supported now."
+          "desc": "<ul>\n<li>Extends: <a href=\"stream.html#stream_stream\" class=\"type\">&lt;Stream&gt;</a></li>\n</ul>\n<p>This class serves as the parent class of <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nand <a href=\"#http_class_http_serverresponse\"><code>http.ServerResponse</code></a>. It is an abstract of outgoing message from\nthe perspective of the participants of HTTP transaction.</p>",
+          "events": [
+            {
+              "textRaw": "Event: `drain`",
+              "type": "event",
+              "name": "drain`",
+              "meta": {
+                "added": [
+                  "v0.3.6"
+                ],
+                "changes": []
               },
-              {
-                "version": "v9.6.0, v8.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/15752",
-                "description": "The `options` argument is supported now."
-              }
-            ]
-          },
-          "signatures": [
+              "params": [],
+              "desc": "<p>Emitted when the buffer of the message is free again.</p>"
+            },
             {
-              "return": {
-                "textRaw": "Returns: {http.Server}",
-                "name": "return",
-                "type": "http.Server"
+              "textRaw": "Event: `finish`",
+              "type": "event",
+              "name": "finish`",
+              "meta": {
+                "added": [
+                  "v0.1.17"
+                ],
+                "changes": []
               },
-              "params": [
+              "params": [],
+              "desc": "<p>Emitted when the transmission is finished successfully.</p>"
+            },
+            {
+              "textRaw": "Event: `prefinish`",
+              "type": "event",
+              "name": "prefinish`",
+              "meta": {
+                "added": [
+                  "v0.11.6"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>Emitted when <code>outgoingMessage.end</code> was called.\nWhen the event is emitted, all data has been processed but not necessarily\ncompletely flushed.</p>"
+            }
+          ],
+          "methods": [
+            {
+              "textRaw": "`outgoingMessage.addTrailers(headers)`",
+              "type": "method",
+              "name": "addTrailers",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
-                    {
-                      "textRaw": "`IncomingMessage` {http.IncomingMessage} Specifies the `IncomingMessage` class to be used. Useful for extending the original `IncomingMessage`. **Default:** `IncomingMessage`.",
-                      "name": "IncomingMessage",
-                      "type": "http.IncomingMessage",
-                      "default": "`IncomingMessage`",
-                      "desc": "Specifies the `IncomingMessage` class to be used. Useful for extending the original `IncomingMessage`."
-                    },
-                    {
-                      "textRaw": "`ServerResponse` {http.ServerResponse} Specifies the `ServerResponse` class to be used. Useful for extending the original `ServerResponse`. **Default:** `ServerResponse`.",
-                      "name": "ServerResponse",
-                      "type": "http.ServerResponse",
-                      "default": "`ServerResponse`",
-                      "desc": "Specifies the `ServerResponse` class to be used. Useful for extending the original `ServerResponse`."
-                    },
+                  "params": [
                     {
-                      "textRaw": "`insecureHTTPParser` {boolean} Use an insecure HTTP parser that accepts invalid HTTP headers when `true`. Using the insecure parser should be avoided. See [`--insecure-http-parser`][] for more information. **Default:** `false`",
-                      "name": "insecureHTTPParser",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "Use an insecure HTTP parser that accepts invalid HTTP headers when `true`. Using the insecure parser should be avoided. See [`--insecure-http-parser`][] for more information."
+                      "textRaw": "`headers` {Object}",
+                      "name": "headers",
+                      "type": "Object"
                     }
                   ]
-                },
+                }
+              ],
+              "desc": "<p>Adds HTTP trailers (headers but at the end of the message) to the message.</p>\n<p>Trailers are <strong>only</strong> be emitted if the message is chunked encoded. If not,\nthe trailer will be silently discarded.</p>\n<p>HTTP requires the  <code>Trailer</code> header to be sent to emit trailers,\nwith a list of header fields in its value, e.g.</p>\n<pre><code class=\"language-js\">message.writeHead(200, { 'Content-Type': 'text/plain',\n                         'Trailer': 'Content-MD5' });\nmessage.write(fileData);\nmessage.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' });\nmessage.end();\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <code>TypeError</code> being thrown.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.cork()`",
+              "type": "method",
+              "name": "cork",
+              "meta": {
+                "added": [
+                  "v14.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`requestListener` {Function}",
-                  "name": "requestListener",
-                  "type": "Function"
+                  "params": []
                 }
-              ]
-            }
-          ],
-          "desc": "<p>Returns a new instance of <a href=\"#http_class_http_server\"><code>http.Server</code></a>.</p>\n<p>The <code>requestListener</code> is a function which is automatically\nadded to the <a href=\"#http_event_request\"><code>'request'</code></a> event.</p>"
+              ],
+              "desc": "<p>See <a href=\"stream.html#stream_writable_cork\"><code>writable.cork()</code></a>.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.destroy([error])`",
+              "type": "method",
+              "name": "destroy",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {this}",
+                    "name": "return",
+                    "type": "this"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`error` {Error} Optional, an error to emit with `error` event",
+                      "name": "error",
+                      "type": "Error",
+                      "desc": "Optional, an error to emit with `error` event"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Destroys the message. Once a socket is associated with the message\nand is connected, that socket will be destroyed as well.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.end(chunk[, encoding][, callback])`",
+              "type": "method",
+              "name": "end",
+              "meta": {
+                "added": [
+                  "v0.1.90"
+                ],
+                "changes": [
+                  {
+                    "version": "v0.11.6",
+                    "description": "add `callback` argument."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {this}",
+                    "name": "return",
+                    "type": "this"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`chunk` {string | Buffer}",
+                      "name": "chunk",
+                      "type": "string | Buffer"
+                    },
+                    {
+                      "textRaw": "`encoding` {string} Optional, **Default**: `utf-8`",
+                      "name": "encoding",
+                      "type": "string",
+                      "desc": "Optional, **Default**: `utf-8`"
+                    },
+                    {
+                      "textRaw": "`callback` {Function} Optional",
+                      "name": "callback",
+                      "type": "Function",
+                      "desc": "Optional"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Finishes the outgoing message. If any parts of the body are unsent, it will\nflush them to the underlying system. If the message is chunked, it will\nsend the terminating chunk <code>0\\r\\n\\r\\n</code>, and send the trailer (if any).</p>\n<p>If <code>chunk</code> is specified, it is equivalent to call\n<code>outgoingMessage.write(chunk, encoding)</code>, followed by\n<code>outgoingMessage.end(callback)</code>.</p>\n<p>If <code>callback</code> is provided, it will be called when the message is finished.\n(equivalent to the callback to event <code>finish</code>)</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.flushHeaders()`",
+              "type": "method",
+              "name": "flushHeaders",
+              "meta": {
+                "added": [
+                  "v1.6.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Compulsorily flushes the message headers</p>\n<p>For efficiency reason, Node.js normally buffers the message headers\nuntil <code>outgoingMessage.end()</code> is called or the first chunk of message data\nis written. It then tries to pack the headers and data into a single TCP\npacket.</p>\n<p>It is usually desired (it saves a TCP round-trip), but not when the first\ndata is not sent until possibly much later. <code>outgoingMessage.flushHeaders()</code>\nbypasses the optimization and kickstarts the request.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.getHeader(name)`",
+              "type": "method",
+              "name": "getHeader",
+              "meta": {
+                "added": [
+                  "v0.4.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns {string | undefined}",
+                    "name": "return",
+                    "type": "string | undefined"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`name` {string} Name of header",
+                      "name": "name",
+                      "type": "string",
+                      "desc": "Name of header"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Gets the value of HTTP header with the given name. If such a name doesn't\nexist in message, it will be <code>undefined</code>.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.getHeaderNames()`",
+              "type": "method",
+              "name": "getHeaderNames",
+              "meta": {
+                "added": [
+                  "v8.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns {string[]}",
+                    "name": "return",
+                    "type": "string[]"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns an array of names of headers of the outgoing outgoingMessage. All\nnames are lowercase.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.getHeaders()`",
+              "type": "method",
+              "name": "getHeaders",
+              "meta": {
+                "added": [
+                  "v8.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Object}",
+                    "name": "return",
+                    "type": "Object"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Returns a shallow copy of the current outgoing headers. Since a shallow\ncopy is used, array values may be mutated without additional calls to\nvarious header-related HTTP module methods. The keys of the returned\nobject are the header names and the values are the respective header\nvalues. All header names are lowercase.</p>\n<p>The object returned by the <code>outgoingMessage.getHeaders()</code> method does\nnot prototypically inherit from the JavaScript Object. This means that\ntypical Object methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>,\nand others are not defined and will not work.</p>\n<pre><code class=\"language-js\">outgoingMessage.setHeader('Foo', 'bar');\noutgoingMessage.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);\n\nconst headers = outgoingMessage.getHeaders();\n// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }\n</code></pre>"
+            },
+            {
+              "textRaw": "`outgoingMessage.hasHeader(name)`",
+              "type": "method",
+              "name": "hasHeader",
+              "meta": {
+                "added": [
+                  "v8.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`name` {string}",
+                      "name": "name",
+                      "type": "string"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the\noutgoing headers. The header name is case-insensitive.</p>\n<pre><code class=\"language-js\">const hasContentType = outgoingMessage.hasHeader('content-type');\n</code></pre>"
+            },
+            {
+              "textRaw": "`outgoingMessage.pipe()`",
+              "type": "method",
+              "name": "pipe",
+              "meta": {
+                "added": [
+                  "v9.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Overrides the pipe method of legacy <code>Stream</code> which is the parent class of\n<code>http.outgoingMessage</code>.</p>\n<p>Since <code>OutgoingMessage</code> should be a write-only stream,\ncall this function will throw an <code>Error</code>. Thus, it disabled the pipe method\nit inherits from <code>Stream</code>.</p>\n<p>The User should not call this function directly.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.removeHeader()`",
+              "type": "method",
+              "name": "removeHeader",
+              "meta": {
+                "added": [
+                  "v0.4.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>Removes a header that is queued for implicit sending.</p>\n<pre><code class=\"language-js\">outgoingMessage.removeHeader('Content-Encoding');\n</code></pre>"
+            },
+            {
+              "textRaw": "`outgoingMessage.setHeader(name, value)`",
+              "type": "method",
+              "name": "setHeader",
+              "meta": {
+                "added": [
+                  "v0.4.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {this}",
+                    "name": "return",
+                    "type": "this"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`name` {string} Header name",
+                      "name": "name",
+                      "type": "string",
+                      "desc": "Header name"
+                    },
+                    {
+                      "textRaw": "`value` {string} Header value",
+                      "name": "value",
+                      "type": "string",
+                      "desc": "Header value"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Sets a single header value for the header object.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.setTimeout(msesc[, callback])`",
+              "type": "method",
+              "name": "setTimeout",
+              "meta": {
+                "added": [
+                  "v0.9.12"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`msesc` {number}",
+                      "name": "msesc",
+                      "type": "number"
+                    },
+                    {
+                      "textRaw": "`callback` {Function} Optional function to be called when a timeout",
+                      "name": "callback",
+                      "type": "Function",
+                      "desc": "Optional function to be called when a timeout"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>occurs, Same as binding to the <code>timeout</code> event.</p>\n<ul>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this\" class=\"type\">&lt;this&gt;</a></li>\n</ul>\n<p>Once a socket is associated with the message and is connected,\n<a href=\"net.html#net_socket_settimeout_timeout_callback\"><code>socket.setTimeout()</code></a> will be called with <code>msecs</code> as the first parameter.</p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.uncork()`",
+              "type": "method",
+              "name": "uncork",
+              "meta": {
+                "added": [
+                  "v14.0.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>See <a href=\"stream.html#stream_writable_uncork\"><code>writable.uncork()</code></a></p>"
+            },
+            {
+              "textRaw": "`outgoingMessage.write(chunk[, encoding][, callback])`",
+              "type": "method",
+              "name": "write",
+              "meta": {
+                "added": [
+                  "v0.1.29"
+                ],
+                "changes": [
+                  {
+                    "version": "v0.11.6",
+                    "description": "add `callback` argument."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`chunk` {string | Buffer}",
+                      "name": "chunk",
+                      "type": "string | Buffer"
+                    },
+                    {
+                      "textRaw": "`encoding` {string} **Default**: `utf-8`",
+                      "name": "encoding",
+                      "type": "string",
+                      "desc": "**Default**: `utf-8`"
+                    },
+                    {
+                      "textRaw": "`callback` {Function}",
+                      "name": "callback",
+                      "type": "Function"
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>If this method is called and the header is not sent, it will call\n<code>this._implicitHeader</code> to flush implicit header.\nIf the message should not have a body (indicated by <code>this._hasBody</code>),\nthe call is ignored and <code>chunk</code> will not be sent. It could be useful\nwhen handling a particular message which must not include a body.\ne.g. response to <code>HEAD</code> request, <code>204</code> and <code>304</code> response.</p>\n<p><code>chunk</code> can be a string or a buffer. When <code>chunk</code> is a string, the\n<code>encoding</code> parameter specifies how to encode <code>chunk</code> into a byte stream.\n<code>callback</code> will be called when the <code>chunk</code> is flushed.</p>\n<p>If the message is transferred in chucked encoding\n(indicated by <code>this.chunkedEncoding</code>), <code>chunk</code> will be flushed as\none chunk among a stream of chunks. Otherwise, it will be flushed as the\nbody of message.</p>\n<p>This method handles the raw body of the HTTP message and has nothing to do\nwith higher-level multi-part body encodings that may be used.</p>\n<p>If it is the first call to this method of a message, it will send the\nbuffered header first, then flush the <code>chunk</code> as described above.</p>\n<p>The second and successive calls to this method will assume the data\nwill be streamed and send the new data separately. It means that the response\nis buffered up to the first chunk of the body.</p>\n<p>Returns <code>true</code> if the entire data was flushed successfully to the kernel\nbuffer. Returns <code>false</code> if all or part of the data was queued in the user\nmemory. Event <code>drain</code> will be emitted when the buffer is free again.</p>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`outgoingMessage.connection`",
+              "name": "connection",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "deprecated": [
+                  "v14.17.1"
+                ],
+                "changes": []
+              },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use [`outgoingMessage.socket`][] instead.",
+              "desc": "<p>Aliases of <code>outgoingMessage.socket</code></p>"
+            },
+            {
+              "textRaw": "`headersSent` {boolean}",
+              "type": "boolean",
+              "name": "headersSent",
+              "meta": {
+                "added": [
+                  "v0.9.3"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Read-only. <code>true</code> if the headers were sent, otherwise <code>false</code>.</p>"
+            },
+            {
+              "textRaw": "`socket` {stream.Duplex}",
+              "type": "stream.Duplex",
+              "name": "socket",
+              "meta": {
+                "added": [
+                  "v0.3.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Reference to the underlying socket. Usually, users will not want to access\nthis property.</p>\n<p>After calling <code>outgoingMessage.end()</code>, this property will be nulled.</p>"
+            },
+            {
+              "textRaw": "`writableCorked` {number}",
+              "type": "number",
+              "name": "writableCorked",
+              "meta": {
+                "added": [
+                  "v14.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>This <code>outgoingMessage.writableCorked</code> will return the time how many\n<code>outgoingMessage.cork()</code> have been called.</p>"
+            },
+            {
+              "textRaw": "`writableEnded` {boolean}",
+              "type": "boolean",
+              "name": "writableEnded",
+              "meta": {
+                "added": [
+                  "v13.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Readonly, <code>true</code> if <code>outgoingMessage.end()</code> has been called. Noted that\nthis property does not reflect whether the data has been flush. For that\npurpose, use <code>message.writableFinished</code> instead.</p>"
+            },
+            {
+              "textRaw": "`writableFinished` {boolean}",
+              "type": "boolean",
+              "name": "writableFinished",
+              "meta": {
+                "added": [
+                  "v13.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Readonly. <code>true</code> if all data has been flushed to the underlying system.</p>"
+            },
+            {
+              "textRaw": "`writableHighWaterMark` {number}",
+              "type": "number",
+              "name": "writableHighWaterMark",
+              "meta": {
+                "added": [
+                  "v13.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>This <code>outgoingMessage.writableHighWaterMark</code> will be the <code>highWaterMark</code> of\nunderlying socket if socket exists. Else, it would be the default\n<code>highWaterMark</code>.</p>\n<p><code>highWaterMark</code> is the maximum amount of data that can be potentially\nbuffered by the socket.</p>"
+            },
+            {
+              "textRaw": "`writableLength` {number}",
+              "type": "number",
+              "name": "writableLength",
+              "meta": {
+                "added": [
+                  "v13.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Readonly, This <code>outgoingMessage.writableLength</code> contains the number of\nbytes (or objects) in the buffer ready to send.</p>"
+            },
+            {
+              "textRaw": "`writableObjectMode` {boolean}",
+              "type": "boolean",
+              "name": "writableObjectMode",
+              "meta": {
+                "added": [
+                  "v13.0.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Readonly, always returns <code>false</code>.</p>"
+            }
+          ]
+        }
+      ],
+      "properties": [
+        {
+          "textRaw": "`METHODS` {string[]}",
+          "type": "string[]",
+          "name": "METHODS",
+          "meta": {
+            "added": [
+              "v0.11.8"
+            ],
+            "changes": []
+          },
+          "desc": "<p>A list of the HTTP methods that are supported by the parser.</p>"
+        },
+        {
+          "textRaw": "`STATUS_CODES` {Object}",
+          "type": "Object",
+          "name": "STATUS_CODES",
+          "meta": {
+            "added": [
+              "v0.1.22"
+            ],
+            "changes": []
+          },
+          "desc": "<p>A collection of all the standard HTTP response status codes, and the\nshort description of each. For example, <code>http.STATUS_CODES[404] === 'Not Found'</code>.</p>"
+        },
+        {
+          "textRaw": "`globalAgent` {http.Agent}",
+          "type": "http.Agent",
+          "name": "globalAgent",
+          "meta": {
+            "added": [
+              "v0.5.9"
+            ],
+            "changes": []
+          },
+          "desc": "<p>Global instance of <code>Agent</code> which is used as the default for all HTTP client\nrequests.</p>"
+        },
+        {
+          "textRaw": "`maxHeaderSize` {number}",
+          "type": "number",
+          "name": "maxHeaderSize",
+          "meta": {
+            "added": [
+              "v11.6.0",
+              "v10.15.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>Read-only property specifying the maximum allowed size of HTTP headers in bytes.\nDefaults to 8KB. Configurable using the <a href=\"cli.html#cli_max_http_header_size_size\"><code>--max-http-header-size</code></a> CLI option.</p>\n<p>This can be overridden for servers and client requests by passing the\n<code>maxHeaderSize</code> option.</p>"
+        }
+      ],
+      "methods": [
+        {
+          "textRaw": "`http.createServer([options][, requestListener])`",
+          "type": "method",
+          "name": "createServer",
+          "meta": {
+            "added": [
+              "v0.1.13"
+            ],
+            "changes": [
+              {
+                "version": [
+                  "v13.8.0",
+                  "v12.15.0",
+                  "v10.19.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/31448",
+                "description": "The `insecureHTTPParser` option is supported now."
+              },
+              {
+                "version": "v13.3.0",
+                "pr-url": "https://github.com/nodejs/node/pull/30570",
+                "description": "The `maxHeaderSize` option is supported now."
+              },
+              {
+                "version": [
+                  "v9.6.0",
+                  "v8.12.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/15752",
+                "description": "The `options` argument is supported now."
+              }
+            ]
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {http.Server}",
+                "name": "return",
+                "type": "http.Server"
+              },
+              "params": [
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`IncomingMessage` {http.IncomingMessage} Specifies the `IncomingMessage` class to be used. Useful for extending the original `IncomingMessage`. **Default:** `IncomingMessage`.",
+                      "name": "IncomingMessage",
+                      "type": "http.IncomingMessage",
+                      "default": "`IncomingMessage`",
+                      "desc": "Specifies the `IncomingMessage` class to be used. Useful for extending the original `IncomingMessage`."
+                    },
+                    {
+                      "textRaw": "`ServerResponse` {http.ServerResponse} Specifies the `ServerResponse` class to be used. Useful for extending the original `ServerResponse`. **Default:** `ServerResponse`.",
+                      "name": "ServerResponse",
+                      "type": "http.ServerResponse",
+                      "default": "`ServerResponse`",
+                      "desc": "Specifies the `ServerResponse` class to be used. Useful for extending the original `ServerResponse`."
+                    },
+                    {
+                      "textRaw": "`insecureHTTPParser` {boolean} Use an insecure HTTP parser that accepts invalid HTTP headers when `true`. Using the insecure parser should be avoided. See [`--insecure-http-parser`][] for more information. **Default:** `false`",
+                      "name": "insecureHTTPParser",
+                      "type": "boolean",
+                      "default": "`false`",
+                      "desc": "Use an insecure HTTP parser that accepts invalid HTTP headers when `true`. Using the insecure parser should be avoided. See [`--insecure-http-parser`][] for more information."
+                    },
+                    {
+                      "textRaw": "`maxHeaderSize` {number} Optionally overrides the value of [`--max-http-header-size`][] for requests received by this server, i.e. the maximum length of request headers in bytes. **Default:** 16384 (16KB).",
+                      "name": "maxHeaderSize",
+                      "type": "number",
+                      "default": "16384 (16KB)",
+                      "desc": "Optionally overrides the value of [`--max-http-header-size`][] for requests received by this server, i.e. the maximum length of request headers in bytes."
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`requestListener` {Function}",
+                  "name": "requestListener",
+                  "type": "Function"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Returns a new instance of <a href=\"#http_class_http_server\"><code>http.Server</code></a>.</p>\n<p>The <code>requestListener</code> is a function which is automatically\nadded to the <a href=\"#http_event_request\"><code>'request'</code></a> event.</p>\n<pre><code class=\"language-cjs\">const http = require('http');\n\n// Create a local server to receive data from\nconst server = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'application/json' });\n  res.end(JSON.stringify({\n    data: 'Hello World!'\n  }));\n});\n\nserver.listen(8000);\n</code></pre>\n<pre><code class=\"language-cjs\">const http = require('http');\n\n// Create a local server to receive data from\nconst server = http.createServer();\n\n// Listen to the request event\nserver.on('request', (request, res) => {\n  res.writeHead(200, { 'Content-Type': 'application/json' });\n  res.end(JSON.stringify({\n    data: 'Hello World!'\n  }));\n});\n\nserver.listen(8000);\n</code></pre>"
         },
         {
           "textRaw": "`http.get(options[, callback])`",
@@ -2342,7 +3058,7 @@
               ]
             }
           ],
-          "desc": "<p>Since most requests are GET requests without bodies, Node.js provides this\nconvenience method. The only difference between this method and\n<a href=\"#http_http_request_options_callback\"><code>http.request()</code></a> is that it sets the method to GET and calls <code>req.end()</code>\nautomatically. The callback must take care to consume the response\ndata for reasons stated in <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> section.</p>\n<p>The <code>callback</code> is invoked with a single argument that is an instance of\n<a href=\"#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>JSON fetching example:</p>\n<pre><code class=\"language-js\">http.get('http://nodejs.org/dist/index.json', (res) => {\n  const { statusCode } = res;\n  const contentType = res.headers['content-type'];\n\n  let error;\n  // Any 2xx status code signals a successful response but\n  // here we're only checking for 200.\n  if (statusCode !== 200) {\n    error = new Error('Request Failed.\\n' +\n                      `Status Code: ${statusCode}`);\n  } else if (!/^application\\/json/.test(contentType)) {\n    error = new Error('Invalid content-type.\\n' +\n                      `Expected application/json but received ${contentType}`);\n  }\n  if (error) {\n    console.error(error.message);\n    // Consume response data to free up memory\n    res.resume();\n    return;\n  }\n\n  res.setEncoding('utf8');\n  let rawData = '';\n  res.on('data', (chunk) => { rawData += chunk; });\n  res.on('end', () => {\n    try {\n      const parsedData = JSON.parse(rawData);\n      console.log(parsedData);\n    } catch (e) {\n      console.error(e.message);\n    }\n  });\n}).on('error', (e) => {\n  console.error(`Got error: ${e.message}`);\n});\n</code></pre>"
+          "desc": "<p>Since most requests are GET requests without bodies, Node.js provides this\nconvenience method. The only difference between this method and\n<a href=\"#http_http_request_options_callback\"><code>http.request()</code></a> is that it sets the method to GET and calls <code>req.end()</code>\nautomatically. The callback must take care to consume the response\ndata for reasons stated in <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> section.</p>\n<p>The <code>callback</code> is invoked with a single argument that is an instance of\n<a href=\"#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>JSON fetching example:</p>\n<pre><code class=\"language-js\">http.get('http://localhost:8000/', (res) => {\n  const { statusCode } = res;\n  const contentType = res.headers['content-type'];\n\n  let error;\n  // Any 2xx status code signals a successful response but\n  // here we're only checking for 200.\n  if (statusCode !== 200) {\n    error = new Error('Request Failed.\\n' +\n                      `Status Code: ${statusCode}`);\n  } else if (!/^application\\/json/.test(contentType)) {\n    error = new Error('Invalid content-type.\\n' +\n                      `Expected application/json but received ${contentType}`);\n  }\n  if (error) {\n    console.error(error.message);\n    // Consume response data to free up memory\n    res.resume();\n    return;\n  }\n\n  res.setEncoding('utf8');\n  let rawData = '';\n  res.on('data', (chunk) => { rawData += chunk; });\n  res.on('end', () => {\n    try {\n      const parsedData = JSON.parse(rawData);\n      console.log(parsedData);\n    } catch (e) {\n      console.error(e.message);\n    }\n  });\n}).on('error', (e) => {\n  console.error(`Got error: ${e.message}`);\n});\n\n// Create a local server to receive data from\nconst server = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'application/json' });\n  res.end(JSON.stringify({\n    data: 'Hello World!'\n  }));\n});\n\nserver.listen(8000);\n</code></pre>"
         },
         {
           "textRaw": "`http.get(url[, options][, callback])`",
@@ -2392,7 +3108,7 @@
               ]
             }
           ],
-          "desc": "<p>Since most requests are GET requests without bodies, Node.js provides this\nconvenience method. The only difference between this method and\n<a href=\"#http_http_request_options_callback\"><code>http.request()</code></a> is that it sets the method to GET and calls <code>req.end()</code>\nautomatically. The callback must take care to consume the response\ndata for reasons stated in <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> section.</p>\n<p>The <code>callback</code> is invoked with a single argument that is an instance of\n<a href=\"#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>JSON fetching example:</p>\n<pre><code class=\"language-js\">http.get('http://nodejs.org/dist/index.json', (res) => {\n  const { statusCode } = res;\n  const contentType = res.headers['content-type'];\n\n  let error;\n  // Any 2xx status code signals a successful response but\n  // here we're only checking for 200.\n  if (statusCode !== 200) {\n    error = new Error('Request Failed.\\n' +\n                      `Status Code: ${statusCode}`);\n  } else if (!/^application\\/json/.test(contentType)) {\n    error = new Error('Invalid content-type.\\n' +\n                      `Expected application/json but received ${contentType}`);\n  }\n  if (error) {\n    console.error(error.message);\n    // Consume response data to free up memory\n    res.resume();\n    return;\n  }\n\n  res.setEncoding('utf8');\n  let rawData = '';\n  res.on('data', (chunk) => { rawData += chunk; });\n  res.on('end', () => {\n    try {\n      const parsedData = JSON.parse(rawData);\n      console.log(parsedData);\n    } catch (e) {\n      console.error(e.message);\n    }\n  });\n}).on('error', (e) => {\n  console.error(`Got error: ${e.message}`);\n});\n</code></pre>"
+          "desc": "<p>Since most requests are GET requests without bodies, Node.js provides this\nconvenience method. The only difference between this method and\n<a href=\"#http_http_request_options_callback\"><code>http.request()</code></a> is that it sets the method to GET and calls <code>req.end()</code>\nautomatically. The callback must take care to consume the response\ndata for reasons stated in <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a> section.</p>\n<p>The <code>callback</code> is invoked with a single argument that is an instance of\n<a href=\"#http_class_http_incomingmessage\"><code>http.IncomingMessage</code></a>.</p>\n<p>JSON fetching example:</p>\n<pre><code class=\"language-js\">http.get('http://localhost:8000/', (res) => {\n  const { statusCode } = res;\n  const contentType = res.headers['content-type'];\n\n  let error;\n  // Any 2xx status code signals a successful response but\n  // here we're only checking for 200.\n  if (statusCode !== 200) {\n    error = new Error('Request Failed.\\n' +\n                      `Status Code: ${statusCode}`);\n  } else if (!/^application\\/json/.test(contentType)) {\n    error = new Error('Invalid content-type.\\n' +\n                      `Expected application/json but received ${contentType}`);\n  }\n  if (error) {\n    console.error(error.message);\n    // Consume response data to free up memory\n    res.resume();\n    return;\n  }\n\n  res.setEncoding('utf8');\n  let rawData = '';\n  res.on('data', (chunk) => { rawData += chunk; });\n  res.on('end', () => {\n    try {\n      const parsedData = JSON.parse(rawData);\n      console.log(parsedData);\n    } catch (e) {\n      console.error(e.message);\n    }\n  });\n}).on('error', (e) => {\n  console.error(`Got error: ${e.message}`);\n});\n\n// Create a local server to receive data from\nconst server = http.createServer((req, res) => {\n  res.writeHead(200, { 'Content-Type': 'application/json' });\n  res.end(JSON.stringify({\n    data: 'Hello World!'\n  }));\n});\n\nserver.listen(8000);\n</code></pre>"
         },
         {
           "textRaw": "`http.request(options[, callback])`",
@@ -2404,10 +3120,29 @@
             ],
             "changes": [
               {
-                "version": "v12.15.0",
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/39310",
+                "description": "When using a `URL` object parsed username and password will now be properly URI decoded."
+              },
+              {
+                "version": "v14.17.0",
+                "pr-url": "https://github.com/nodejs/node/pull/36048",
+                "description": "It is possible to abort a request with an AbortSignal."
+              },
+              {
+                "version": [
+                  "v13.8.0",
+                  "v12.15.0",
+                  "v10.19.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/31448",
                 "description": "The `insecureHTTPParser` option is supported now."
               },
+              {
+                "version": "v13.3.0",
+                "pr-url": "https://github.com/nodejs/node/pull/30570",
+                "description": "The `maxHeaderSize` option is supported now."
+              },
               {
                 "version": "v10.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/21616",
@@ -2492,6 +3227,12 @@
                       "type": "Object",
                       "desc": "An object containing request headers."
                     },
+                    {
+                      "textRaw": "`hints` {number} Optional [`dns.lookup()` hints][].",
+                      "name": "hints",
+                      "type": "number",
+                      "desc": "Optional [`dns.lookup()` hints][]."
+                    },
                     {
                       "textRaw": "`host` {string} A domain name or IP address of the server to issue the request to. **Default:** `'localhost'`.",
                       "name": "host",
@@ -2518,6 +3259,12 @@
                       "type": "string",
                       "desc": "Local interface to bind for network connections."
                     },
+                    {
+                      "textRaw": "`localPort` {number} Local port to connect from.",
+                      "name": "localPort",
+                      "type": "number",
+                      "desc": "Local port to connect from."
+                    },
                     {
                       "textRaw": "`lookup` {Function} Custom lookup function. **Default:** [`dns.lookup()`][].",
                       "name": "lookup",
@@ -2525,6 +3272,13 @@
                       "default": "[`dns.lookup()`][]",
                       "desc": "Custom lookup function."
                     },
+                    {
+                      "textRaw": "`maxHeaderSize` {number} Optionally overrides the value of [`--max-http-header-size`][] for requests received from the server, i.e. the maximum length of response headers in bytes. **Default:** 16384 (16KB).",
+                      "name": "maxHeaderSize",
+                      "type": "number",
+                      "default": "16384 (16KB)",
+                      "desc": "Optionally overrides the value of [`--max-http-header-size`][] for requests received from the server, i.e. the maximum length of response headers in bytes."
+                    },
                     {
                       "textRaw": "`method` {string} A string specifying the HTTP request method. **Default:** `'GET'`.",
                       "name": "method",
@@ -2570,6 +3324,12 @@
                       "name": "timeout",
                       "type": "number",
                       "desc": ": A number specifying the socket timeout in milliseconds. This will set the timeout before the socket is connected."
+                    },
+                    {
+                      "textRaw": "`signal` {AbortSignal}: An AbortSignal that may be used to abort an ongoing request.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": ": An AbortSignal that may be used to abort an ongoing request."
                     }
                   ]
                 },
@@ -2581,7 +3341,7 @@
               ]
             }
           ],
-          "desc": "<p>Node.js maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.</p>\n<p><code>url</code> can be a string or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>url</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p>If both <code>url</code> and <code>options</code> are specified, the objects are merged, with the\n<code>options</code> properties taking precedence.</p>\n<p>The optional <code>callback</code> parameter will be added as a one-time listener for\nthe <a href=\"#http_event_response\"><code>'response'</code></a> event.</p>\n<p><code>http.request()</code> returns an instance of the <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const postData = querystring.stringify({\n  'msg': 'Hello World!'\n});\n\nconst options = {\n  hostname: 'www.google.com',\n  port: 80,\n  path: '/upload',\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/x-www-form-urlencoded',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n};\n\nconst req = http.request(options, (res) => {\n  console.log(`STATUS: ${res.statusCode}`);\n  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);\n  res.setEncoding('utf8');\n  res.on('data', (chunk) => {\n    console.log(`BODY: ${chunk}`);\n  });\n  res.on('end', () => {\n    console.log('No more data in response.');\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(`problem with request: ${e.message}`);\n});\n\n// Write data to request body\nreq.write(postData);\nreq.end();\n</code></pre>\n<p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one\nmust always call <code>req.end()</code> to signify the end of the request -\neven if there is no data being written to the request body.</p>\n<p>If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an <code>'error'</code> event is emitted\non the returned request object. As with all <code>'error'</code> events, if no listeners\nare registered the error will be thrown.</p>\n<p>There are a few special headers that should be noted.</p>\n<ul>\n<li>\n<p>Sending a 'Connection: keep-alive' will notify Node.js that the connection to\nthe server should be persisted until the next request.</p>\n</li>\n<li>\n<p>Sending a 'Content-Length' header will disable the default chunked encoding.</p>\n</li>\n<li>\n<p>Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', both a timeout and a listener\nfor the <code>'continue'</code> event should be set. See RFC 2616 Section 8.2.3 for more\ninformation.</p>\n</li>\n<li>\n<p>Sending an Authorization header will override using the <code>auth</code> option\nto compute basic authentication.</p>\n</li>\n</ul>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('http://abc:xyz@example.com');\n\nconst req = http.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>In a successful request, the following events will be emitted in the following\norder:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object\n(<code>'data'</code> will not be emitted at all if the response body is empty, for\ninstance, in most redirects)</li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n</ul>\n</li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a connection error, the following events will be emitted:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called before the connection succeeds, the following events\nwill be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called after the response is received, the following events\nwill be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will\nnot abort the request or do anything besides add a <code>'timeout'</code> event.</p>"
+          "desc": "<p>Node.js maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.</p>\n<p><code>url</code> can be a string or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>url</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p>If both <code>url</code> and <code>options</code> are specified, the objects are merged, with the\n<code>options</code> properties taking precedence.</p>\n<p>The optional <code>callback</code> parameter will be added as a one-time listener for\nthe <a href=\"#http_event_response\"><code>'response'</code></a> event.</p>\n<p><code>http.request()</code> returns an instance of the <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst postData = JSON.stringify({\n  'msg': 'Hello World!'\n});\n\nconst options = {\n  hostname: 'www.google.com',\n  port: 80,\n  path: '/upload',\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/json',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n};\n\nconst req = http.request(options, (res) => {\n  console.log(`STATUS: ${res.statusCode}`);\n  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);\n  res.setEncoding('utf8');\n  res.on('data', (chunk) => {\n    console.log(`BODY: ${chunk}`);\n  });\n  res.on('end', () => {\n    console.log('No more data in response.');\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(`problem with request: ${e.message}`);\n});\n\n// Write data to request body\nreq.write(postData);\nreq.end();\n</code></pre>\n<p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one\nmust always call <code>req.end()</code> to signify the end of the request -\neven if there is no data being written to the request body.</p>\n<p>If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an <code>'error'</code> event is emitted\non the returned request object. As with all <code>'error'</code> events, if no listeners\nare registered the error will be thrown.</p>\n<p>There are a few special headers that should be noted.</p>\n<ul>\n<li>\n<p>Sending a 'Connection: keep-alive' will notify Node.js that the connection to\nthe server should be persisted until the next request.</p>\n</li>\n<li>\n<p>Sending a 'Content-Length' header will disable the default chunked encoding.</p>\n</li>\n<li>\n<p>Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', both a timeout and a listener\nfor the <code>'continue'</code> event should be set. See RFC 2616 Section 8.2.3 for more\ninformation.</p>\n</li>\n<li>\n<p>Sending an Authorization header will override using the <code>auth</code> option\nto compute basic authentication.</p>\n</li>\n</ul>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('http://abc:xyz@example.com');\n\nconst req = http.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>In a successful request, the following events will be emitted in the following\norder:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object\n(<code>'data'</code> will not be emitted at all if the response body is empty, for\ninstance, in most redirects)</li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n</ul>\n</li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a connection error, the following events will be emitted:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a premature connection close before the response is received,\nthe following events will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a premature connection close after the response is received,\nthe following events will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(connection closed here)</li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>If <code>req.destroy()</code> is called before a socket is assigned, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.destroy()</code> is called before the connection succeeds, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.destroy()</code> is called after the response is received, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>If <code>req.abort()</code> is called before a socket is assigned, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called before the connection succeeds, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called after the response is received, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will\nnot abort the request or do anything besides add a <code>'timeout'</code> event.</p>\n<p>Passing an <code>AbortSignal</code> and then calling <code>abort</code> on the corresponding\n<code>AbortController</code> will behave the same way as calling <code>.destroy()</code> on the\nrequest itself.</p>"
         },
         {
           "textRaw": "`http.request(url[, options][, callback])`",
@@ -2593,10 +3353,29 @@
             ],
             "changes": [
               {
-                "version": "v12.15.0",
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/39310",
+                "description": "When using a `URL` object parsed username and password will now be properly URI decoded."
+              },
+              {
+                "version": "v14.17.0",
+                "pr-url": "https://github.com/nodejs/node/pull/36048",
+                "description": "It is possible to abort a request with an AbortSignal."
+              },
+              {
+                "version": [
+                  "v13.8.0",
+                  "v12.15.0",
+                  "v10.19.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/31448",
                 "description": "The `insecureHTTPParser` option is supported now."
               },
+              {
+                "version": "v13.3.0",
+                "pr-url": "https://github.com/nodejs/node/pull/30570",
+                "description": "The `maxHeaderSize` option is supported now."
+              },
               {
                 "version": "v10.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/21616",
@@ -2681,6 +3460,12 @@
                       "type": "Object",
                       "desc": "An object containing request headers."
                     },
+                    {
+                      "textRaw": "`hints` {number} Optional [`dns.lookup()` hints][].",
+                      "name": "hints",
+                      "type": "number",
+                      "desc": "Optional [`dns.lookup()` hints][]."
+                    },
                     {
                       "textRaw": "`host` {string} A domain name or IP address of the server to issue the request to. **Default:** `'localhost'`.",
                       "name": "host",
@@ -2707,6 +3492,12 @@
                       "type": "string",
                       "desc": "Local interface to bind for network connections."
                     },
+                    {
+                      "textRaw": "`localPort` {number} Local port to connect from.",
+                      "name": "localPort",
+                      "type": "number",
+                      "desc": "Local port to connect from."
+                    },
                     {
                       "textRaw": "`lookup` {Function} Custom lookup function. **Default:** [`dns.lookup()`][].",
                       "name": "lookup",
@@ -2714,6 +3505,13 @@
                       "default": "[`dns.lookup()`][]",
                       "desc": "Custom lookup function."
                     },
+                    {
+                      "textRaw": "`maxHeaderSize` {number} Optionally overrides the value of [`--max-http-header-size`][] for requests received from the server, i.e. the maximum length of response headers in bytes. **Default:** 16384 (16KB).",
+                      "name": "maxHeaderSize",
+                      "type": "number",
+                      "default": "16384 (16KB)",
+                      "desc": "Optionally overrides the value of [`--max-http-header-size`][] for requests received from the server, i.e. the maximum length of response headers in bytes."
+                    },
                     {
                       "textRaw": "`method` {string} A string specifying the HTTP request method. **Default:** `'GET'`.",
                       "name": "method",
@@ -2759,6 +3557,12 @@
                       "name": "timeout",
                       "type": "number",
                       "desc": ": A number specifying the socket timeout in milliseconds. This will set the timeout before the socket is connected."
+                    },
+                    {
+                      "textRaw": "`signal` {AbortSignal}: An AbortSignal that may be used to abort an ongoing request.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": ": An AbortSignal that may be used to abort an ongoing request."
                     }
                   ]
                 },
@@ -2770,7 +3574,58 @@
               ]
             }
           ],
-          "desc": "<p>Node.js maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.</p>\n<p><code>url</code> can be a string or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>url</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p>If both <code>url</code> and <code>options</code> are specified, the objects are merged, with the\n<code>options</code> properties taking precedence.</p>\n<p>The optional <code>callback</code> parameter will be added as a one-time listener for\nthe <a href=\"#http_event_response\"><code>'response'</code></a> event.</p>\n<p><code>http.request()</code> returns an instance of the <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const postData = querystring.stringify({\n  'msg': 'Hello World!'\n});\n\nconst options = {\n  hostname: 'www.google.com',\n  port: 80,\n  path: '/upload',\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/x-www-form-urlencoded',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n};\n\nconst req = http.request(options, (res) => {\n  console.log(`STATUS: ${res.statusCode}`);\n  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);\n  res.setEncoding('utf8');\n  res.on('data', (chunk) => {\n    console.log(`BODY: ${chunk}`);\n  });\n  res.on('end', () => {\n    console.log('No more data in response.');\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(`problem with request: ${e.message}`);\n});\n\n// Write data to request body\nreq.write(postData);\nreq.end();\n</code></pre>\n<p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one\nmust always call <code>req.end()</code> to signify the end of the request -\neven if there is no data being written to the request body.</p>\n<p>If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an <code>'error'</code> event is emitted\non the returned request object. As with all <code>'error'</code> events, if no listeners\nare registered the error will be thrown.</p>\n<p>There are a few special headers that should be noted.</p>\n<ul>\n<li>\n<p>Sending a 'Connection: keep-alive' will notify Node.js that the connection to\nthe server should be persisted until the next request.</p>\n</li>\n<li>\n<p>Sending a 'Content-Length' header will disable the default chunked encoding.</p>\n</li>\n<li>\n<p>Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', both a timeout and a listener\nfor the <code>'continue'</code> event should be set. See RFC 2616 Section 8.2.3 for more\ninformation.</p>\n</li>\n<li>\n<p>Sending an Authorization header will override using the <code>auth</code> option\nto compute basic authentication.</p>\n</li>\n</ul>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('http://abc:xyz@example.com');\n\nconst req = http.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>In a successful request, the following events will be emitted in the following\norder:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object\n(<code>'data'</code> will not be emitted at all if the response body is empty, for\ninstance, in most redirects)</li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n</ul>\n</li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a connection error, the following events will be emitted:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called before the connection succeeds, the following events\nwill be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called after the response is received, the following events\nwill be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will\nnot abort the request or do anything besides add a <code>'timeout'</code> event.</p>"
+          "desc": "<p>Node.js maintains several connections per server to make HTTP requests.\nThis function allows one to transparently issue requests.</p>\n<p><code>url</code> can be a string or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>url</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p>If both <code>url</code> and <code>options</code> are specified, the objects are merged, with the\n<code>options</code> properties taking precedence.</p>\n<p>The optional <code>callback</code> parameter will be added as a one-time listener for\nthe <a href=\"#http_event_response\"><code>'response'</code></a> event.</p>\n<p><code>http.request()</code> returns an instance of the <a href=\"#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst postData = JSON.stringify({\n  'msg': 'Hello World!'\n});\n\nconst options = {\n  hostname: 'www.google.com',\n  port: 80,\n  path: '/upload',\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/json',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n};\n\nconst req = http.request(options, (res) => {\n  console.log(`STATUS: ${res.statusCode}`);\n  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);\n  res.setEncoding('utf8');\n  res.on('data', (chunk) => {\n    console.log(`BODY: ${chunk}`);\n  });\n  res.on('end', () => {\n    console.log('No more data in response.');\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(`problem with request: ${e.message}`);\n});\n\n// Write data to request body\nreq.write(postData);\nreq.end();\n</code></pre>\n<p>In the example <code>req.end()</code> was called. With <code>http.request()</code> one\nmust always call <code>req.end()</code> to signify the end of the request -\neven if there is no data being written to the request body.</p>\n<p>If any error is encountered during the request (be that with DNS resolution,\nTCP level errors, or actual HTTP parse errors) an <code>'error'</code> event is emitted\non the returned request object. As with all <code>'error'</code> events, if no listeners\nare registered the error will be thrown.</p>\n<p>There are a few special headers that should be noted.</p>\n<ul>\n<li>\n<p>Sending a 'Connection: keep-alive' will notify Node.js that the connection to\nthe server should be persisted until the next request.</p>\n</li>\n<li>\n<p>Sending a 'Content-Length' header will disable the default chunked encoding.</p>\n</li>\n<li>\n<p>Sending an 'Expect' header will immediately send the request headers.\nUsually, when sending 'Expect: 100-continue', both a timeout and a listener\nfor the <code>'continue'</code> event should be set. See RFC 2616 Section 8.2.3 for more\ninformation.</p>\n</li>\n<li>\n<p>Sending an Authorization header will override using the <code>auth</code> option\nto compute basic authentication.</p>\n</li>\n</ul>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('http://abc:xyz@example.com');\n\nconst req = http.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>In a successful request, the following events will be emitted in the following\norder:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object\n(<code>'data'</code> will not be emitted at all if the response body is empty, for\ninstance, in most redirects)</li>\n<li><code>'end'</code> on the <code>res</code> object</li>\n</ul>\n</li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a connection error, the following events will be emitted:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a premature connection close before the response is received,\nthe following events will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>In the case of a premature connection close after the response is received,\nthe following events will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(connection closed here)</li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>If <code>req.destroy()</code> is called before a socket is assigned, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.destroy()</code> is called before the connection succeeds, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.destroy()</code> is called after the response is received, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.destroy()</code> called here)</li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>If <code>req.abort()</code> is called before a socket is assigned, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called before the connection succeeds, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'error'</code> with an error with message <code>'Error: socket hang up'</code> and code\n<code>'ECONNRESET'</code></li>\n<li><code>'close'</code></li>\n</ul>\n<p>If <code>req.abort()</code> is called after the response is received, the following\nevents will be emitted in the following order:</p>\n<ul>\n<li><code>'socket'</code></li>\n<li><code>'response'</code>\n<ul>\n<li><code>'data'</code> any number of times, on the <code>res</code> object</li>\n</ul>\n</li>\n<li>(<code>req.abort()</code> called here)</li>\n<li><code>'abort'</code></li>\n<li><code>'aborted'</code> on the <code>res</code> object</li>\n<li><code>'close'</code></li>\n<li><code>'close'</code> on the <code>res</code> object</li>\n</ul>\n<p>Setting the <code>timeout</code> option or using the <code>setTimeout()</code> function will\nnot abort the request or do anything besides add a <code>'timeout'</code> event.</p>\n<p>Passing an <code>AbortSignal</code> and then calling <code>abort</code> on the corresponding\n<code>AbortController</code> will behave the same way as calling <code>.destroy()</code> on the\nrequest itself.</p>"
+        },
+        {
+          "textRaw": "`http.validateHeaderName(name)`",
+          "type": "method",
+          "name": "validateHeaderName",
+          "meta": {
+            "added": [
+              "v14.3.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`name` {string}",
+                  "name": "name",
+                  "type": "string"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Performs the low-level validations on the provided <code>name</code> that are done when\n<code>res.setHeader(name, value)</code> is called.</p>\n<p>Passing illegal value as <code>name</code> will result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown,\nidentified by <code>code: 'ERR_INVALID_HTTP_TOKEN'</code>.</p>\n<p>It is not necessary to use this method before passing headers to an HTTP request\nor response. The HTTP module will automatically validate such headers.\nExamples:</p>\n<p>Example:</p>\n<pre><code class=\"language-js\">const { validateHeaderName } = require('http');\n\ntry {\n  validateHeaderName('');\n} catch (err) {\n  err instanceof TypeError; // --> true\n  err.code; // --> 'ERR_INVALID_HTTP_TOKEN'\n  err.message; // --> 'Header name must be a valid HTTP token [\"\"]'\n}\n</code></pre>"
+        },
+        {
+          "textRaw": "`http.validateHeaderValue(name, value)`",
+          "type": "method",
+          "name": "validateHeaderValue",
+          "meta": {
+            "added": [
+              "v14.3.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`name` {string}",
+                  "name": "name",
+                  "type": "string"
+                },
+                {
+                  "textRaw": "`value` {any}",
+                  "name": "value",
+                  "type": "any"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Performs the low-level validations on the provided <code>value</code> that are done when\n<code>res.setHeader(name, value)</code> is called.</p>\n<p>Passing illegal value as <code>value</code> will result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>\n<ul>\n<li>Undefined value error is identified by <code>code: 'ERR_HTTP_INVALID_HEADER_VALUE'</code>.</li>\n<li>Invalid value character error is identified by <code>code: 'ERR_INVALID_CHAR'</code>.</li>\n</ul>\n<p>It is not necessary to use this method before passing headers to an HTTP request\nor response. The HTTP module will automatically validate such headers.</p>\n<p>Examples:</p>\n<pre><code class=\"language-js\">const { validateHeaderValue } = require('http');\n\ntry {\n  validateHeaderValue('x-my-header', undefined);\n} catch (err) {\n  err instanceof TypeError; // --> true\n  err.code === 'ERR_HTTP_INVALID_HEADER_VALUE'; // --> true\n  err.message; // --> 'Invalid value \"undefined\" for header \"x-my-header\"'\n}\n\ntry {\n  validateHeaderValue('x-my-header', 'oʊmɪɡə');\n} catch (err) {\n  err instanceof TypeError; // --> true\n  err.code === 'ERR_INVALID_CHAR'; // --> true\n  err.message; // --> 'Invalid character in header content [\"x-my-header\"]'\n}\n</code></pre>"
         }
       ],
       "type": "module",
diff --git a/doc/api/http.md b/doc/api/http.md
index ff33288e7292082d0eb09a12592d3c425c506c93..5f6d3804eedcf5c9f2f2ebf85bdca7bade6fd9f3 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -113,10 +113,13 @@ http.get({
 <!-- YAML
 added: v0.3.4
 changes:
-  - version: v12.19.0
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/36685
+    description: Change the default scheduling from 'fifo' to 'lifo'.
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33617
     description: Add `maxTotalSockets` option to agent constructor.
-  - version: v12.20.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33278
     description: Add `scheduling` option to specify the free socket
                  scheduling strategy.
@@ -133,11 +136,17 @@ changes:
     options are respectively set to `false` and `Infinity`, in which case
     `Connection: close` will be used. **Default:** `false`.
   * `keepAliveMsecs` {number} When using the `keepAlive` option, specifies
-    the [initial delay](net.html#net_socket_setkeepalive_enable_initialdelay)
+    the [initial delay](net.md#net_socket_setkeepalive_enable_initialdelay)
     for TCP Keep-Alive packets. Ignored when the
     `keepAlive` option is `false` or `undefined`. **Default:** `1000`.
-  * `maxSockets` {number} Maximum number of sockets to allow per
-    host. Each request will use a new socket until the maximum is reached.
+  * `maxSockets` {number} Maximum number of sockets to allow per host.
+     If the same host opens multiple concurrent connections, each request
+     will use new socket until the `maxSockets` value is reached.
+     If the host attempts to open more connections than `maxSockets`,
+     the additional requests will enter into a pending request queue, and
+     will enter active connection state when an existing connection terminates.
+     This makes sure there are at most `maxSockets` active connections at
+     any point in time, from a given host.
     **Default:** `Infinity`.
   * `maxTotalSockets` {number} Maximum number of sockets allowed for
     all hosts in total. Each request will use a new socket
@@ -157,7 +166,7 @@ changes:
     In case of a high rate of request per second,
     the `'fifo'` scheduling will maximize the number of open sockets,
     while the `'lifo'` scheduling will keep it as low as possible.
-    **Default:** `'fifo'`.
+    **Default:** `'lifo'`.
   * `timeout` {number} Socket timeout in milliseconds.
     This will set the timeout when the socket is created.
 
@@ -251,8 +260,8 @@ Destroy any sockets that are currently in use by the agent.
 
 It is usually not necessary to do this. However, if using an
 agent with `keepAlive` enabled, then it is best to explicitly shut down
-the agent when it will no longer be used. Otherwise,
-sockets may hang open for quite a long time before the server
+the agent when it is no longer needed. Otherwise,
+sockets might stay open for quite a long time before the server
 terminates them.
 
 ### `agent.freeSockets`
@@ -311,7 +320,7 @@ can have open per origin. Origin is the returned value of [`agent.getName()`][].
 
 ### `agent.maxTotalSockets`
 <!-- YAML
-added: v12.19.0
+added: v14.5.0
 -->
 
 * {number}
@@ -604,8 +613,11 @@ server.listen(1337, '127.0.0.1', () => {
 ### `request.abort()`
 <!-- YAML
 added: v0.3.8
+deprecated: v14.1.0
 -->
 
+> Stability: 0 - Deprecated: Use [`request.destroy()`][] instead.
+
 Marks the request as aborting. Calling this will cause remaining data
 in the response to be dropped and the socket to be destroyed.
 
@@ -626,8 +638,11 @@ been aborted.
 ### `request.connection`
 <!-- YAML
 added: v0.3.0
+deprecated: v13.0.0
 -->
 
+> Stability: 0 - Deprecated. Use [`request.socket`][].
+
 * {stream.Duplex}
 
 See [`request.socket`][].
@@ -656,10 +671,42 @@ If `data` is specified, it is equivalent to calling
 If `callback` is specified, it will be called when the request stream
 is finished.
 
+### `request.destroy([error])`
+<!-- YAML
+added: v0.3.0
+changes:
+  - version: v14.5.0
+    pr-url: https://github.com/nodejs/node/pull/32789
+    description: The function returns `this` for consistency with other Readable
+                 streams.
+-->
+
+* `error` {Error} Optional, an error to emit with `'error'` event.
+* Returns: {this}
+
+Destroy the request. Optionally emit an `'error'` event,
+and emit a `'close'` event. Calling this will cause remaining data
+in the response to be dropped and the socket to be destroyed.
+
+See [`writable.destroy()`][] for further details.
+
+#### `request.destroyed`
+<!-- YAML
+added: v14.1.0
+-->
+
+* {boolean}
+
+Is `true` after [`request.destroy()`][] has been called.
+
+See [`writable.destroyed`][] for further details.
+
 ### `request.finished`
 <!-- YAML
 added: v0.0.1
-deprecated: v12.16.0
+deprecated:
+ - v13.4.0
+ - v12.16.0
 -->
 
 > Stability: 0 - Deprecated. Use [`request.writableEnded`][].
@@ -709,6 +756,24 @@ const cookie = request.getHeader('Cookie');
 // 'cookie' is of type string[]
 ```
 
+### `request.getRawHeaderNames()`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Returns: {string[]}
+
+Returns an array containing the unique names of the current outgoing raw
+headers. Header names are returned with their exact casing being set.
+
+```js
+request.setHeader('Foo', 'bar');
+request.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);
+
+const headerNames = request.getRawHeaderNames();
+// headerNames === ['Foo', 'Set-Cookie']
+```
+
 ### `request.maxHeadersCount`
 
 * {number} **Default:** `2000`
@@ -731,14 +796,14 @@ added: v0.1.97
 
 ### `request.host`
 <!-- YAML
-added: v12.19.0
+added: v14.5.0
 -->
 
 * {string} The request host.
 
 ### `request.protocol`
 <!-- YAML
-added: v12.19.0
+added: v14.5.0
 -->
 
 * {string} The request protocol.
@@ -757,9 +822,10 @@ request.removeHeader('Content-Type');
 ```
 
 ### `request.reusedSocket`
-
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.0.0
+ - v12.16.0
 -->
 
 * {boolean} Whether the request is send through a reused socket.
@@ -884,8 +950,7 @@ added: v0.3.0
 
 Reference to the underlying socket. Usually users will not want to access
 this property. In particular, the socket will not emit `'readable'` events
-because of how the protocol parser attaches to the socket. The `socket`
-may also be accessed via `request.connection`.
+because of how the protocol parser attaches to the socket.
 
 ```js
 const http = require('http');
@@ -937,11 +1002,11 @@ added: v0.1.29
 * `callback` {Function}
 * Returns: {boolean}
 
-Sends a chunk of the body. By calling this method
-many times, a request body can be sent to a
-server. In that case, it is suggested to use the
-`['Transfer-Encoding', 'chunked']` header line when
-creating the request.
+Sends a chunk of the body. This method can be called multiple times. If no
+`Content-Length` is set, data will automatically be encoded in HTTP Chunked
+transfer encoding, so that server knows when the data ends. The
+`Transfer-Encoding: chunked` header is added. Calling [`request.end()`][]
+is necessary to finish sending the request.
 
 The `encoding` argument is optional and only applies when `chunk` is a string.
 Defaults to `'utf8'`.
@@ -1002,20 +1067,20 @@ not be emitted.
 <!-- YAML
 added: v0.1.94
 changes:
-  - version: v6.0.0
-    pr-url: https://github.com/nodejs/node/pull/4557
-    description: The default action of calling `.destroy()` on the `socket`
-                 will no longer take place if there are listeners attached
-                 for `'clientError'`.
+  - version: v12.0.0
+    pr-url: https://github.com/nodejs/node/pull/25605
+    description: The default behavior will return a 431 Request Header
+                 Fields Too Large if a HPE_HEADER_OVERFLOW error occurs.
   - version: v9.4.0
     pr-url: https://github.com/nodejs/node/pull/17672
     description: The `rawPacket` is the current buffer that just parsed. Adding
                  this buffer to the error object of `'clientError'` event is to
                  make it possible that developers can log the broken packet.
-  - version: v12.0.0
-    pr-url: https://github.com/nodejs/node/pull/25605
-    description: The default behavior will return a 431 Request Header
-                 Fields Too Large if a HPE_HEADER_OVERFLOW error occurs.
+  - version: v6.0.0
+    pr-url: https://github.com/nodejs/node/pull/4557
+    description: The default action of calling `.destroy()` on the `socket`
+                 will no longer take place if there are listeners attached
+                 for `'clientError'`.
 -->
 
 * `exception` {Error}
@@ -1115,7 +1180,7 @@ This event is emitted when a new TCP stream is established. `socket` is
 typically an object of type [`net.Socket`][]. Usually users will not want to
 access this event. In particular, the socket will not emit `'readable'` events
 because of how the protocol parser attaches to the socket. The `socket` can
-also be accessed at `request.connection`.
+also be accessed at `request.socket`.
 
 This event can also be explicitly emitted by users to inject connections
 into the HTTP server. In that case, any [`Duplex`][] stream can be passed.
@@ -1144,7 +1209,7 @@ per connection (in the case of HTTP Keep-Alive connections).
 added: v0.1.94
 changes:
   - version: v10.0.0
-    pr-url: v10.0.0
+    pr-url: https://github.com/nodejs/node/pull/19981
     description: Not listening to this event no longer causes the socket
                  to be destroyed if a client sends an Upgrade header.
 -->
@@ -1176,7 +1241,9 @@ Stops the server from accepting new connections. See [`net.Server.close()`][].
 
 ### `server.headersTimeout`
 <!-- YAML
-added: v11.3.0
+added:
+ - v11.3.0
+ - v10.14.0
 -->
 
 * {number} **Default:** `60000`
@@ -1194,8 +1261,6 @@ event is emitted on the server object, and (by default) the socket is destroyed.
 See [`server.timeout`][] for more information on how timeout behavior can be
 customized.
 
-A value of `0` will disable the HTTP headers timeout check.
-
 ### `server.listen()`
 
 Starts the HTTP server listening for connections.
@@ -1217,12 +1282,33 @@ added: v0.7.0
 
 Limits maximum incoming headers count. If set to 0, no limit will be applied.
 
+### `server.requestTimeout`
+<!-- YAML
+added: v14.11.0
+-->
+
+* {number} **Default:** `0`
+
+Sets the timeout value in milliseconds for receiving the entire request from
+the client.
+
+If the timeout expires, the server responds with status 408 without
+forwarding the request to the request listener and then closes the connection.
+
+It must be set to a non-zero value (e.g. 120 seconds) to protect against
+potential Denial-of-Service attacks in case the server is deployed without a
+reverse proxy in front.
+
 ### `server.setTimeout([msecs][, callback])`
 <!-- YAML
 added: v0.9.12
+changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27558
+    description: The default timeout changed from 120s to 0 (no timeout).
 -->
 
-* `msecs` {number} **Default:** `120000` (2 minutes)
+* `msecs` {number} **Default:** 0 (no timeout)
 * `callback` {Function}
 * Returns: {http.Server}
 
@@ -1233,19 +1319,20 @@ occurs.
 If there is a `'timeout'` event listener on the Server object, then it
 will be called with the timed-out socket as an argument.
 
-By default, the Server's timeout value is 2 minutes, and sockets are
-destroyed automatically if they time out. However, if a callback is assigned
-to the Server's `'timeout'` event, timeouts must be handled explicitly.
-
-To change the default timeout use the [`--http-server-default-timeout`][]
-flag.
+By default, the Server does not timeout sockets. However, if a callback
+is assigned to the Server's `'timeout'` event, timeouts must be handled
+explicitly.
 
 ### `server.timeout`
 <!-- YAML
 added: v0.9.12
+changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27558
+    description: The default timeout changed from 120s to 0 (no timeout).
 -->
 
-* {number} Timeout in milliseconds. **Default:** `120000` (2 minutes).
+* {number} Timeout in milliseconds. **Default:** 0 (no timeout)
 
 The number of milliseconds of inactivity before a socket is presumed
 to have timed out.
@@ -1255,9 +1342,6 @@ A value of `0` will disable the timeout behavior on incoming connections.
 The socket timeout logic is set up on connection, so changing this
 value only affects new connections to the server, not any existing connections.
 
-To change the default timeout use the [`--http-server-default-timeout`][]
-flag.
-
 ### `server.keepAliveTimeout`
 <!-- YAML
 added: v8.0.0
@@ -1294,7 +1378,7 @@ passed as the second parameter to the [`'request'`][] event.
 added: v0.6.7
 -->
 
-Indicates that the the response is completed, or its underlying connection was
+Indicates that the response is completed, or its underlying connection was
 terminated prematurely (before the response completion).
 
 ### Event: `'finish'`
@@ -1338,15 +1422,20 @@ will result in a [`TypeError`][] being thrown.
 ### `response.connection`
 <!-- YAML
 added: v0.3.0
+deprecated: v13.0.0
 -->
 
+> Stability: 0 - Deprecated. Use [`response.socket`][].
+
 * {stream.Duplex}
 
 See [`response.socket`][].
 
 ### `response.cork()`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.2.0
+ - v12.16.0
 -->
 
 See [`writable.cork()`][].
@@ -1378,7 +1467,9 @@ is finished.
 ### `response.finished`
 <!-- YAML
 added: v0.0.2
-deprecated: v12.16.0
+deprecated:
+ - v13.4.0
+ - v12.16.0
 -->
 
 > Stability: 0 - Deprecated. Use [`response.writableEnded`][].
@@ -1520,13 +1611,17 @@ added: v0.4.0
 
 * `name` {string}
 * `value` {any}
+* Returns: {http.ServerResponse}
+
+Returns the response object.
 
 Sets a single header value for implicit headers. If this header already exists
 in the to-be-sent headers, its value will be replaced. Use an array of strings
 here to send multiple headers with the same name. Non-string values will be
 stored without modification. Therefore, [`response.getHeader()`][] may return
 non-string values. However, the non-string values will be converted to strings
-for network transmission.
+for network transmission. The same response object is returned to the caller,
+to enable call chaining.
 
 ```js
 response.setHeader('Content-Type', 'text/html');
@@ -1590,8 +1685,7 @@ added: v0.3.0
 Reference to the underlying socket. Usually users will not want to access
 this property. In particular, the socket will not emit `'readable'` events
 because of how the protocol parser attaches to the socket. After
-`response.end()`, the property is nulled. The `socket` may also be accessed
-via `response.connection`.
+`response.end()`, the property is nulled.
 
 ```js
 const http = require('http');
@@ -1645,7 +1739,9 @@ status message which was sent out.
 
 ### `response.uncork()`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.2.0
+ - v12.16.0
 -->
 
 See [`writable.uncork()`][].
@@ -1721,11 +1817,18 @@ the request body should be sent. See the [`'checkContinue'`][] event on
 <!-- YAML
 added: v0.1.30
 changes:
-  - version: v11.10.0
+  - version: v14.14.0
+    pr-url: https://github.com/nodejs/node/pull/35274
+    description: Allow passing headers as an array.
+  - version:
+     - v11.10.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/25974
     description: Return `this` from `writeHead()` to allow chaining with
                  `end()`.
-  - version: v5.11.0, v4.4.5
+  - version:
+    - v5.11.0
+    - v4.4.5
     pr-url: https://github.com/nodejs/node/pull/6291
     description: A `RangeError` is thrown if `statusCode` is not a number in
                  the range `[100, 999]`.
@@ -1733,7 +1836,7 @@ changes:
 
 * `statusCode` {number}
 * `statusMessage` {string}
-* `headers` {Object}
+* `headers` {Object|Array}
 * Returns: {http.ServerResponse}
 
 Sends a response header to the request. The status code is a 3-digit HTTP
@@ -1741,6 +1844,11 @@ status code, like `404`. The last argument, `headers`, are the response headers.
 Optionally one can give a human-readable `statusMessage` as the second
 argument.
 
+`headers` may be an `Array` where the keys and values are in the same list.
+It is *not* a list of tuples. So, the even-numbered offsets are key values,
+and the odd-numbered offsets are the associated values. The array is in the same
+format as `request.rawHeaders`.
+
 Returns a reference to the `ServerResponse`, so that calls can be chained.
 
 ```js
@@ -1800,7 +1908,9 @@ the request body should be sent.
 <!-- YAML
 added: v0.1.17
 changes:
-  - version: v12.16.0
+  - version:
+     - v13.1.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30135
     description: The `readableHighWaterMark` value mirrors that of the socket.
 -->
@@ -1868,7 +1978,7 @@ const req = http.request({
 <!-- YAML
 added: v0.3.0
 changes:
-  - version: v12.19.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/32789
     description: The function returns `this` for consistency with other Readable
                  streams.
@@ -1905,9 +2015,9 @@ Duplicates in raw headers are handled in the following ways, depending on the
 header name:
 
 * Duplicates of `age`, `authorization`, `content-length`, `content-type`,
-`etag`, `expires`, `from`, `host`, `if-modified-since`, `if-unmodified-since`,
-`last-modified`, `location`, `max-forwards`, `proxy-authorization`, `referer`,
-`retry-after`, `server`, or `user-agent` are discarded.
+  `etag`, `expires`, `from`, `host`, `if-modified-since`, `if-unmodified-since`,
+  `last-modified`, `location`, `max-forwards`, `proxy-authorization`, `referer`,
+  `retry-after`, `server`, or `user-agent` are discarded.
 * `set-cookie` is always an array. Duplicates are added to the array.
 * For duplicate `cookie` headers, the values are joined together with '; '.
 * For all other headers, the values are joined together with ', '.
@@ -1985,7 +2095,7 @@ added: v0.5.9
 * `callback` {Function}
 * Returns: {http.IncomingMessage}
 
-Calls `message.connection.setTimeout(msecs, callback)`.
+Calls `message.socket.setTimeout(msecs, callback)`.
 
 ### `message.socket`
 <!-- YAML
@@ -2080,6 +2190,378 @@ URL {
 }
 ```
 
+## Class: `http.OutgoingMessage`
+<!-- YAML
+added: v0.1.17
+-->
+
+* Extends: {Stream}
+
+This class serves as the parent class of [`http.ClientRequest`][]
+and [`http.ServerResponse`][]. It is an abstract of outgoing message from
+the perspective of the participants of HTTP transaction.
+
+### Event: `drain`
+<!-- YAML
+added: v0.3.6
+-->
+
+Emitted when the buffer of the message is free again.
+
+### Event: `finish`
+<!-- YAML
+added: v0.1.17
+-->
+
+Emitted when the transmission is finished successfully.
+
+### Event: `prefinish`
+<!-- YAML
+added: v0.11.6
+-->
+
+Emitted when `outgoingMessage.end` was called.
+When the event is emitted, all data has been processed but not necessarily
+completely flushed.
+
+### `outgoingMessage.addTrailers(headers)`
+<!-- YAML
+added: v0.3.0
+-->
+
+* `headers` {Object}
+
+Adds HTTP trailers (headers but at the end of the message) to the message.
+
+Trailers are **only** be emitted if the message is chunked encoded. If not,
+the trailer will be silently discarded.
+
+HTTP requires the  `Trailer` header to be sent to emit trailers,
+with a list of header fields in its value, e.g.
+
+```js
+message.writeHead(200, { 'Content-Type': 'text/plain',
+                         'Trailer': 'Content-MD5' });
+message.write(fileData);
+message.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' });
+message.end();
+```
+
+Attempting to set a header field name or value that contains invalid characters
+will result in a `TypeError` being thrown.
+
+### `outgoingMessage.connection`
+<!-- YAML
+added: v0.3.0
+deprecated: v14.17.1
+-->
+
+> Stability: 0 - Deprecated: Use [`outgoingMessage.socket`][] instead.
+
+Aliases of `outgoingMessage.socket`
+### `outgoingMessage.cork()`
+<!-- YAML
+added: v14.0.0
+-->
+
+See [`writable.cork()`][].
+
+### `outgoingMessage.destroy([error])`
+<!-- YAML
+added: v0.3.0
+-->
+
+* `error` {Error} Optional, an error to emit with `error` event
+* Returns: {this}
+
+Destroys the message. Once a socket is associated with the message
+and is connected, that socket will be destroyed as well.
+
+### `outgoingMessage.end(chunk[, encoding][, callback])`
+<!-- YAML
+added: v0.1.90
+changes:
+  - version: v0.11.6
+    description: add `callback` argument.
+-->
+
+* `chunk` {string | Buffer}
+* `encoding` {string} Optional, **Default**: `utf-8`
+* `callback` {Function} Optional
+* Returns: {this}
+
+Finishes the outgoing message. If any parts of the body are unsent, it will
+flush them to the underlying system. If the message is chunked, it will
+send the terminating chunk `0\r\n\r\n`, and send the trailer (if any).
+
+If `chunk` is specified, it is equivalent to call
+`outgoingMessage.write(chunk, encoding)`, followed by
+`outgoingMessage.end(callback)`.
+
+If `callback` is provided, it will be called when the message is finished.
+(equivalent to the callback to event `finish`)
+
+### `outgoingMessage.flushHeaders()`
+<!-- YAML
+added: v1.6.0
+-->
+
+Compulsorily flushes the message headers
+
+For efficiency reason, Node.js normally buffers the message headers
+until `outgoingMessage.end()` is called or the first chunk of message data
+is written. It then tries to pack the headers and data into a single TCP
+packet.
+
+It is usually desired (it saves a TCP round-trip), but not when the first
+data is not sent until possibly much later. `outgoingMessage.flushHeaders()`
+bypasses the optimization and kickstarts the request.
+
+### `outgoingMessage.getHeader(name)`
+<!-- YAML
+added: v0.4.0
+-->
+
+* `name` {string} Name of header
+* Returns {string | undefined}
+
+Gets the value of HTTP header with the given name. If such a name doesn't
+exist in message, it will be `undefined`.
+
+### `outgoingMessage.getHeaderNames()`
+<!-- YAML
+added: v8.0.0
+-->
+
+* Returns {string[]}
+
+Returns an array of names of headers of the outgoing outgoingMessage. All
+names are lowercase.
+
+### `outgoingMessage.getHeaders()`
+<!-- YAML
+added:  v8.0.0
+-->
+
+* Returns: {Object}
+
+Returns a shallow copy of the current outgoing headers. Since a shallow
+copy is used, array values may be mutated without additional calls to
+various header-related HTTP module methods. The keys of the returned
+object are the header names and the values are the respective header
+values. All header names are lowercase.
+
+The object returned by the `outgoingMessage.getHeaders()` method does
+not prototypically inherit from the JavaScript Object. This means that
+typical Object methods such as `obj.toString()`, `obj.hasOwnProperty()`,
+and others are not defined and will not work.
+
+```js
+outgoingMessage.setHeader('Foo', 'bar');
+outgoingMessage.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);
+
+const headers = outgoingMessage.getHeaders();
+// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }
+```
+
+### `outgoingMessage.hasHeader(name)`
+<!-- YAML
+added:  v8.0.0
+-->
+
+* `name` {string}
+* Returns {boolean}
+
+Returns `true` if the header identified by `name` is currently set in the
+outgoing headers. The header name is case-insensitive.
+
+```js
+const hasContentType = outgoingMessage.hasHeader('content-type');
+```
+
+### `outgoingMessage.headersSent`
+<!-- YAML
+added: v0.9.3
+-->
+
+* {boolean}
+
+Read-only. `true` if the headers were sent, otherwise `false`.
+
+### `outgoingMessage.pipe()`
+<!-- YAML
+added: v9.0.0
+-->
+
+Overrides the pipe method of legacy `Stream` which is the parent class of
+`http.outgoingMessage`.
+
+Since `OutgoingMessage` should be a write-only stream,
+call this function will throw an `Error`. Thus, it disabled the pipe method
+it inherits from `Stream`.
+
+The User should not call this function directly.
+
+### `outgoingMessage.removeHeader()`
+<!-- YAML
+added:  v0.4.0
+-->
+
+Removes a header that is queued for implicit sending.
+
+```js
+outgoingMessage.removeHeader('Content-Encoding');
+```
+
+### `outgoingMessage.setHeader(name, value)`
+<!-- YAML
+added: v0.4.0
+-->
+
+* `name` {string} Header name
+* `value` {string} Header value
+* Returns: {this}
+
+Sets a single header value for the header object.
+
+### `outgoingMessage.setTimeout(msesc[, callback])`
+<!-- YAML
+added: v0.9.12
+-->
+
+* `msesc` {number}
+* `callback` {Function} Optional function to be called when a timeout
+occurs, Same as binding to the `timeout` event.
+* Returns: {this}
+
+Once a socket is associated with the message and is connected,
+[`socket.setTimeout()`][] will be called with `msecs` as the first parameter.
+
+### `outgoingMessage.socket`
+<!-- YAML
+added: v0.3.0
+-->
+
+* {stream.Duplex}
+
+Reference to the underlying socket. Usually, users will not want to access
+this property.
+
+After calling `outgoingMessage.end()`, this property will be nulled.
+
+### `outgoingMessage.uncork()`
+<!-- YAML
+added: v14.0.0
+-->
+
+See [`writable.uncork()`][]
+
+### `outgoingMessage.writableCorked`
+<!-- YAML
+added: v14.0.0
+-->
+
+* {number}
+
+This `outgoingMessage.writableCorked` will return the time how many
+`outgoingMessage.cork()` have been called.
+
+### `outgoingMessage.writableEnded`
+<!-- YAML
+added: v13.0.0
+-->
+
+* {boolean}
+
+Readonly, `true` if `outgoingMessage.end()` has been called. Noted that
+this property does not reflect whether the data has been flush. For that
+purpose, use `message.writableFinished` instead.
+
+### `outgoingMessage.writableFinished`
+<!-- YAML
+added: v13.0.0
+-->
+
+* {boolean}
+
+Readonly. `true` if all data has been flushed to the underlying system.
+
+### `outgoingMessage.writableHighWaterMark`
+<!-- YAML
+added: v13.0.0
+-->
+
+* {number}
+
+This `outgoingMessage.writableHighWaterMark` will be the `highWaterMark` of
+underlying socket if socket exists. Else, it would be the default
+`highWaterMark`.
+
+`highWaterMark` is the maximum amount of data that can be potentially
+buffered by the socket.
+
+### `outgoingMessage.writableLength`
+<!-- YAML
+added: v13.0.0
+-->
+
+* {number}
+
+Readonly, This `outgoingMessage.writableLength` contains the number of
+bytes (or objects) in the buffer ready to send.
+
+### `outgoingMessage.writableObjectMode`
+<!-- YAML
+added: v13.0.0
+-->
+
+* {boolean}
+
+Readonly, always returns `false`.
+
+### `outgoingMessage.write(chunk[, encoding][, callback])`
+<!-- YAML
+added: v0.1.29
+changes:
+  - version: v0.11.6
+    description: add `callback` argument.
+-->
+
+* `chunk` {string | Buffer}
+* `encoding` {string} **Default**: `utf-8`
+* `callback` {Function}
+* Returns {boolean}
+
+If this method is called and the header is not sent, it will call
+`this._implicitHeader` to flush implicit header.
+If the message should not have a body (indicated by `this._hasBody`),
+the call is ignored and `chunk` will not be sent. It could be useful
+when handling a particular message which must not include a body.
+e.g. response to `HEAD` request, `204` and `304` response.
+
+`chunk` can be a string or a buffer. When `chunk` is a string, the
+`encoding` parameter specifies how to encode `chunk` into a byte stream.
+`callback` will be called when the `chunk` is flushed.
+
+If the message is transferred in chucked encoding
+(indicated by `this.chunkedEncoding`), `chunk` will be flushed as
+one chunk among a stream of chunks. Otherwise, it will be flushed as the
+body of message.
+
+This method handles the raw body of the HTTP message and has nothing to do
+with higher-level multi-part body encodings that may be used.
+
+If it is the first call to this method of a message, it will send the
+buffered header first, then flush the `chunk` as described above.
+
+The second and successive calls to this method will assume the data
+will be streamed and send the new data separately. It means that the response
+is buffered up to the first chunk of the body.
+
+Returns `true` if the entire data was flushed successfully to the kernel
+buffer. Returns `false` if all or part of the data was queued in the user
+memory. Event `drain` will be emitted when the buffer is free again.
+
 ## `http.METHODS`
 <!-- YAML
 added: v0.11.8
@@ -2104,10 +2586,18 @@ Found'`.
 <!-- YAML
 added: v0.1.13
 changes:
-  - version: v12.15.0
+  - version:
+     - v13.8.0
+     - v12.15.0
+     - v10.19.0
     pr-url: https://github.com/nodejs/node/pull/31448
     description: The `insecureHTTPParser` option is supported now.
-  - version: v9.6.0, v8.12.0
+  - version: v13.3.0
+    pr-url: https://github.com/nodejs/node/pull/30570
+    description: The `maxHeaderSize` option is supported now.
+  - version:
+    - v9.6.0
+    - v8.12.0
     pr-url: https://github.com/nodejs/node/pull/15752
     description: The `options` argument is supported now.
 -->
@@ -2123,6 +2613,10 @@ changes:
     invalid HTTP headers when `true`. Using the insecure parser should be
     avoided. See [`--insecure-http-parser`][] for more information.
     **Default:** `false`
+  * `maxHeaderSize` {number} Optionally overrides the value of
+    [`--max-http-header-size`][] for requests received by this server, i.e.
+    the maximum length of request headers in bytes.
+    **Default:** 16384 (16KB).
 * `requestListener` {Function}
 
 * Returns: {http.Server}
@@ -2132,6 +2626,37 @@ Returns a new instance of [`http.Server`][].
 The `requestListener` is a function which is automatically
 added to the [`'request'`][] event.
 
+```cjs
+const http = require('http');
+
+// Create a local server to receive data from
+const server = http.createServer((req, res) => {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({
+    data: 'Hello World!'
+  }));
+});
+
+server.listen(8000);
+```
+
+```cjs
+const http = require('http');
+
+// Create a local server to receive data from
+const server = http.createServer();
+
+// Listen to the request event
+server.on('request', (request, res) => {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({
+    data: 'Hello World!'
+  }));
+});
+
+server.listen(8000);
+```
+
 ## `http.get(options[, callback])`
 ## `http.get(url[, options][, callback])`
 <!-- YAML
@@ -2165,7 +2690,7 @@ The `callback` is invoked with a single argument that is an instance of
 JSON fetching example:
 
 ```js
-http.get('http://nodejs.org/dist/index.json', (res) => {
+http.get('http://localhost:8000/', (res) => {
   const { statusCode } = res;
   const contentType = res.headers['content-type'];
 
@@ -2200,6 +2725,16 @@ http.get('http://nodejs.org/dist/index.json', (res) => {
 }).on('error', (e) => {
   console.error(`Got error: ${e.message}`);
 });
+
+// Create a local server to receive data from
+const server = http.createServer((req, res) => {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({
+    data: 'Hello World!'
+  }));
+});
+
+server.listen(8000);
 ```
 
 ## `http.globalAgent`
@@ -2214,7 +2749,9 @@ requests.
 
 ## `http.maxHeaderSize`
 <!-- YAML
-added: v11.6.0
+added:
+ - v11.6.0
+ - v10.15.0
 -->
 
 * {number}
@@ -2222,14 +2759,30 @@ added: v11.6.0
 Read-only property specifying the maximum allowed size of HTTP headers in bytes.
 Defaults to 8KB. Configurable using the [`--max-http-header-size`][] CLI option.
 
+This can be overridden for servers and client requests by passing the
+`maxHeaderSize` option.
+
 ## `http.request(options[, callback])`
 ## `http.request(url[, options][, callback])`
 <!-- YAML
 added: v0.3.6
 changes:
-  - version: v12.15.0
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/39310
+    description: When using a `URL` object parsed username and
+                 password will now be properly URI decoded.
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/36048
+    description: It is possible to abort a request with an AbortSignal.
+  - version:
+     - v13.8.0
+     - v12.15.0
+     - v10.19.0
     pr-url: https://github.com/nodejs/node/pull/31448
     description: The `insecureHTTPParser` option is supported now.
+  - version: v13.3.0
+    pr-url: https://github.com/nodejs/node/pull/30570
+    description: The `maxHeaderSize` option is supported now.
   - version: v10.9.0
     pr-url: https://github.com/nodejs/node/pull/21616
     description: The `url` parameter can now be passed along with a separate
@@ -2259,6 +2812,7 @@ changes:
     `hostname`. Valid values are `4` or `6`. When unspecified, both IP v4 and
     v6 will be used.
   * `headers` {Object} An object containing request headers.
+  * `hints` {number} Optional [`dns.lookup()` hints][].
   * `host` {string} A domain name or IP address of the server to issue the
     request to. **Default:** `'localhost'`.
   * `hostname` {string} Alias for `host`. To support [`url.parse()`][],
@@ -2268,7 +2822,12 @@ changes:
     avoided. See [`--insecure-http-parser`][] for more information.
     **Default:** `false`
   * `localAddress` {string} Local interface to bind for network connections.
+  * `localPort` {number} Local port to connect from.
   * `lookup` {Function} Custom lookup function. **Default:** [`dns.lookup()`][].
+  * `maxHeaderSize` {number} Optionally overrides the value of
+    [`--max-http-header-size`][] for requests received from the server, i.e.
+    the maximum length of response headers in bytes.
+    **Default:** 16384 (16KB).
   * `method` {string} A string specifying the HTTP request method. **Default:**
     `'GET'`.
   * `path` {string} Request path. Should include query string if any.
@@ -2284,6 +2843,8 @@ changes:
      or `port` is specified, those specify a TCP Socket).
   * `timeout` {number}: A number specifying the socket timeout in milliseconds.
     This will set the timeout before the socket is connected.
+  * `signal` {AbortSignal}: An AbortSignal that may be used to abort an ongoing
+    request.
 * `callback` {Function}
 * Returns: {http.ClientRequest}
 
@@ -2305,7 +2866,9 @@ class. The `ClientRequest` instance is a writable stream. If one needs to
 upload a file with a POST request, then write to the `ClientRequest` object.
 
 ```js
-const postData = querystring.stringify({
+const http = require('http');
+
+const postData = JSON.stringify({
   'msg': 'Hello World!'
 });
 
@@ -2315,7 +2878,7 @@ const options = {
   path: '/upload',
   method: 'POST',
   headers: {
-    'Content-Type': 'application/x-www-form-urlencoded',
+    'Content-Type': 'application/json',
     'Content-Length': Buffer.byteLength(postData)
   }
 };
@@ -2392,8 +2955,62 @@ In the case of a connection error, the following events will be emitted:
 * `'error'`
 * `'close'`
 
-If `req.abort()` is called before the connection succeeds, the following events
-will be emitted in the following order:
+In the case of a premature connection close before the response is received,
+the following events will be emitted in the following order:
+
+* `'socket'`
+* `'error'` with an error with message `'Error: socket hang up'` and code
+  `'ECONNRESET'`
+* `'close'`
+
+In the case of a premature connection close after the response is received,
+the following events will be emitted in the following order:
+
+* `'socket'`
+* `'response'`
+  * `'data'` any number of times, on the `res` object
+* (connection closed here)
+* `'aborted'` on the `res` object
+* `'close'`
+* `'close'` on the `res` object
+
+If `req.destroy()` is called before a socket is assigned, the following
+events will be emitted in the following order:
+
+* (`req.destroy()` called here)
+* `'error'` with an error with message `'Error: socket hang up'` and code
+  `'ECONNRESET'`
+* `'close'`
+
+If `req.destroy()` is called before the connection succeeds, the following
+events will be emitted in the following order:
+
+* `'socket'`
+* (`req.destroy()` called here)
+* `'error'` with an error with message `'Error: socket hang up'` and code
+  `'ECONNRESET'`
+* `'close'`
+
+If `req.destroy()` is called after the response is received, the following
+events will be emitted in the following order:
+
+* `'socket'`
+* `'response'`
+  * `'data'` any number of times, on the `res` object
+* (`req.destroy()` called here)
+* `'aborted'` on the `res` object
+* `'close'`
+* `'close'` on the `res` object
+
+If `req.abort()` is called before a socket is assigned, the following
+events will be emitted in the following order:
+
+* (`req.abort()` called here)
+* `'abort'`
+* `'close'`
+
+If `req.abort()` is called before the connection succeeds, the following
+events will be emitted in the following order:
 
 * `'socket'`
 * (`req.abort()` called here)
@@ -2402,8 +3019,8 @@ will be emitted in the following order:
   `'ECONNRESET'`
 * `'close'`
 
-If `req.abort()` is called after the response is received, the following events
-will be emitted in the following order:
+If `req.abort()` is called after the response is received, the following
+events will be emitted in the following order:
 
 * `'socket'`
 * `'response'`
@@ -2412,73 +3029,151 @@ will be emitted in the following order:
 * `'abort'`
 * `'aborted'` on the `res` object
 * `'close'`
-* `'end'` on the `res` object
 * `'close'` on the `res` object
 
 Setting the `timeout` option or using the `setTimeout()` function will
 not abort the request or do anything besides add a `'timeout'` event.
 
-[`--http-server-default-timeout`]: cli.html#cli_http_server_default_timeout_milliseconds
-[`--insecure-http-parser`]: cli.html#cli_insecure_http_parser
-[`--max-http-header-size`]: cli.html#cli_max_http_header_size_size
+Passing an `AbortSignal` and then calling `abort` on the corresponding
+`AbortController` will behave the same way as calling `.destroy()` on the
+request itself.
+
+## `http.validateHeaderName(name)`
+<!-- YAML
+added: v14.3.0
+-->
+
+* `name` {string}
+
+Performs the low-level validations on the provided `name` that are done when
+`res.setHeader(name, value)` is called.
+
+Passing illegal value as `name` will result in a [`TypeError`][] being thrown,
+identified by `code: 'ERR_INVALID_HTTP_TOKEN'`.
+
+It is not necessary to use this method before passing headers to an HTTP request
+or response. The HTTP module will automatically validate such headers.
+Examples:
+
+Example:
+```js
+const { validateHeaderName } = require('http');
+
+try {
+  validateHeaderName('');
+} catch (err) {
+  err instanceof TypeError; // --> true
+  err.code; // --> 'ERR_INVALID_HTTP_TOKEN'
+  err.message; // --> 'Header name must be a valid HTTP token [""]'
+}
+```
+
+## `http.validateHeaderValue(name, value)`
+<!-- YAML
+added: v14.3.0
+-->
+
+* `name` {string}
+* `value` {any}
+
+Performs the low-level validations on the provided `value` that are done when
+`res.setHeader(name, value)` is called.
+
+Passing illegal value as `value` will result in a [`TypeError`][] being thrown.
+* Undefined value error is identified by `code: 'ERR_HTTP_INVALID_HEADER_VALUE'`.
+* Invalid value character error is identified by `code: 'ERR_INVALID_CHAR'`.
+
+It is not necessary to use this method before passing headers to an HTTP request
+or response. The HTTP module will automatically validate such headers.
+
+Examples:
+
+```js
+const { validateHeaderValue } = require('http');
+
+try {
+  validateHeaderValue('x-my-header', undefined);
+} catch (err) {
+  err instanceof TypeError; // --> true
+  err.code === 'ERR_HTTP_INVALID_HEADER_VALUE'; // --> true
+  err.message; // --> 'Invalid value "undefined" for header "x-my-header"'
+}
+
+try {
+  validateHeaderValue('x-my-header', 'oʊmɪɡə');
+} catch (err) {
+  err instanceof TypeError; // --> true
+  err.code === 'ERR_INVALID_CHAR'; // --> true
+  err.message; // --> 'Invalid character in header content ["x-my-header"]'
+}
+```
+
 [`'checkContinue'`]: #http_event_checkcontinue
+[`'finish'`]: #http_event_finish
 [`'request'`]: #http_event_request
 [`'response'`]: #http_event_response
 [`'upgrade'`]: #http_event_upgrade
+[`--insecure-http-parser`]: cli.md#cli_insecure_http_parser
+[`--max-http-header-size`]: cli.md#cli_max_http_header_size_size
 [`Agent`]: #http_class_http_agent
-[`Buffer.byteLength()`]: buffer.html#buffer_static_method_buffer_bytelength_string_encoding
-[`Duplex`]: stream.html#stream_class_stream_duplex
-[`TypeError`]: errors.html#errors_class_typeerror
-[`URL`]: url.html#url_the_whatwg_url_api
+[`Buffer.byteLength()`]: buffer.md#buffer_static_method_buffer_bytelength_string_encoding
+[`Duplex`]: stream.md#stream_class_stream_duplex
+[`HPE_HEADER_OVERFLOW`]: errors.md#errors_hpe_header_overflow
+[`TypeError`]: errors.md#errors_class_typeerror
+[`URL`]: url.md#url_the_whatwg_url_api
 [`agent.createConnection()`]: #http_agent_createconnection_options_callback
 [`agent.getName()`]: #http_agent_getname_options
 [`destroy()`]: #http_agent_destroy
-[`dns.lookup()`]: dns.html#dns_dns_lookup_hostname_options_callback
-[`'finish'`]: #http_event_finish
+[`dns.lookup()`]: dns.md#dns_dns_lookup_hostname_options_callback
+[`dns.lookup()` hints]: dns.md#dns_supported_getaddrinfo_flags
 [`getHeader(name)`]: #http_request_getheader_name
 [`http.Agent`]: #http_class_http_agent
 [`http.ClientRequest`]: #http_class_http_clientrequest
 [`http.IncomingMessage`]: #http_class_http_incomingmessage
+[`http.ServerResponse`]: #http_class_http_serverresponse
 [`http.Server`]: #http_class_http_server
 [`http.get()`]: #http_http_get_options_callback
 [`http.globalAgent`]: #http_http_globalagent
 [`http.request()`]: #http_http_request_options_callback
 [`message.headers`]: #http_message_headers
-[`net.Server.close()`]: net.html#net_server_close_callback
-[`net.Server`]: net.html#net_class_net_server
-[`net.Socket`]: net.html#net_class_net_socket
-[`net.createConnection()`]: net.html#net_net_createconnection_options_connectlistener
-[`new URL()`]: url.html#url_new_url_input_base
+[`net.Server.close()`]: net.md#net_server_close_callback
+[`net.Server`]: net.md#net_class_net_server
+[`net.Socket`]: net.md#net_class_net_socket
+[`net.createConnection()`]: net.md#net_net_createconnection_options_connectlistener
+[`new URL()`]: url.md#url_new_url_input_base
+[`outgoingMessage.socket`]: #http_outgoingmessage_socket
 [`removeHeader(name)`]: #http_request_removeheader_name
+[`request.destroy()`]: #http_request_destroy_error
 [`request.end()`]: #http_request_end_data_encoding_callback
 [`request.flushHeaders()`]: #http_request_flushheaders
 [`request.getHeader()`]: #http_request_getheader_name
 [`request.setHeader()`]: #http_request_setheader_name_value
 [`request.setTimeout()`]: #http_request_settimeout_timeout_callback
-[`request.socket.getPeerCertificate()`]: tls.html#tls_tlssocket_getpeercertificate_detailed
+[`request.socket.getPeerCertificate()`]: tls.md#tls_tlssocket_getpeercertificate_detailed
 [`request.socket`]: #http_request_socket
-[`request.writableFinished`]: #http_request_writablefinished
 [`request.writableEnded`]: #http_request_writableended
+[`request.writableFinished`]: #http_request_writablefinished
 [`request.write(data, encoding)`]: #http_request_write_chunk_encoding_callback
 [`response.end()`]: #http_response_end_data_encoding_callback
 [`response.getHeader()`]: #http_response_getheader_name
 [`response.setHeader()`]: #http_response_setheader_name_value
 [`response.socket`]: #http_response_socket
-[`response.writableFinished`]: #http_response_writablefinished
 [`response.writableEnded`]: #http_response_writableended
+[`response.writableFinished`]: #http_response_writablefinished
 [`response.write()`]: #http_response_write_chunk_encoding_callback
 [`response.write(data, encoding)`]: #http_response_write_chunk_encoding_callback
 [`response.writeContinue()`]: #http_response_writecontinue
 [`response.writeHead()`]: #http_response_writehead_statuscode_statusmessage_headers
-[`server.listen()`]: net.html#net_server_listen
+[`server.listen()`]: net.md#net_server_listen
 [`server.timeout`]: #http_server_timeout
 [`setHeader(name, value)`]: #http_request_setheader_name_value
-[`socket.connect()`]: net.html#net_socket_connect_options_connectlistener
-[`socket.setKeepAlive()`]: net.html#net_socket_setkeepalive_enable_initialdelay
-[`socket.setNoDelay()`]: net.html#net_socket_setnodelay_nodelay
-[`socket.setTimeout()`]: net.html#net_socket_settimeout_timeout_callback
-[`socket.unref()`]: net.html#net_socket_unref
-[`url.parse()`]: url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost
-[`HPE_HEADER_OVERFLOW`]: errors.html#errors_hpe_header_overflow
-[`writable.cork()`]: stream.html#stream_writable_cork
-[`writable.uncork()`]: stream.html#stream_writable_uncork
+[`socket.connect()`]: net.md#net_socket_connect_options_connectlistener
+[`socket.setKeepAlive()`]: net.md#net_socket_setkeepalive_enable_initialdelay
+[`socket.setNoDelay()`]: net.md#net_socket_setnodelay_nodelay
+[`socket.setTimeout()`]: net.md#net_socket_settimeout_timeout_callback
+[`socket.unref()`]: net.md#net_socket_unref
+[`url.parse()`]: url.md#url_url_parse_urlstring_parsequerystring_slashesdenotehost
+[`writable.cork()`]: stream.md#stream_writable_cork
+[`writable.destroy()`]: stream.md#stream_writable_destroy_error
+[`writable.destroyed`]: stream.md#stream_writable_destroyed
+[`writable.uncork()`]: stream.md#stream_writable_uncork
diff --git a/doc/api/http2.html b/doc/api/http2.html
index 66231b1a71b5bf9b3fa37d56f90ea283ef2cbd8d..befa53bc99b134276e651862ea4c4ae50cb5128d 100644
--- a/doc/api/http2.html
+++ b/doc/api/http2.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>HTTP/2 | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>HTTP/2 | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="http2" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/http2.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/http2.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/http2.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/http2.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/http2.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/http2.html">13.x</a></li>
@@ -112,15 +127,13 @@
 <li><a href="https://nodejs.org/docs/latest-v8.x/api/http2.html">8.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/http2.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/http2.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#http2_http_2">HTTP/2</a></span>
 <ul>
 <li><a href="#http2_core_api">Core API</a>
@@ -154,6 +167,7 @@
 <li><a href="#http2_http2session_ping_payload_callback"><code>http2session.ping([payload, ]callback)</code></a></li>
 <li><a href="#http2_http2session_ref"><code>http2session.ref()</code></a></li>
 <li><a href="#http2_http2session_remotesettings"><code>http2session.remoteSettings</code></a></li>
+<li><a href="#http2_http2session_setlocalwindowsize_windowsize"><code>http2session.setLocalWindowSize(windowSize)</code></a></li>
 <li><a href="#http2_http2session_settimeout_msecs_callback"><code>http2session.setTimeout(msecs, callback)</code></a></li>
 <li><a href="#http2_http2session_socket"><code>http2session.socket</code></a></li>
 <li><a href="#http2_http2session_state"><code>http2session.state</code></a></li>
@@ -233,10 +247,7 @@
 <li><a href="#http2_class_http2server">Class: <code>Http2Server</code></a>
 <ul>
 <li><a href="#http2_event_checkcontinue">Event: <code>'checkContinue'</code></a></li>
-</ul>
-</li>
-<li><a href="#http2_event_connection">Event: <code>'connection'</code></a>
-<ul>
+<li><a href="#http2_event_connection">Event: <code>'connection'</code></a></li>
 <li><a href="#http2_event_request">Event: <code>'request'</code></a></li>
 <li><a href="#http2_event_session">Event: <code>'session'</code></a></li>
 <li><a href="#http2_event_sessionerror">Event: <code>'sessionError'</code></a></li>
@@ -244,15 +255,14 @@
 <li><a href="#http2_event_timeout_2">Event: <code>'timeout'</code></a></li>
 <li><a href="#http2_server_close_callback"><code>server.close([callback])</code></a></li>
 <li><a href="#http2_server_settimeout_msecs_callback"><code>server.setTimeout([msecs][, callback])</code></a></li>
+<li><a href="#http2_server_timeout"><code>server.timeout</code></a></li>
+<li><a href="#http2_server_updatesettings_settings"><code>server.updateSettings([settings])</code></a></li>
 </ul>
 </li>
 <li><a href="#http2_class_http2secureserver">Class: <code>Http2SecureServer</code></a>
 <ul>
 <li><a href="#http2_event_checkcontinue_1">Event: <code>'checkContinue'</code></a></li>
-</ul>
-</li>
-<li><a href="#http2_event_connection_1">Event: <code>'connection'</code></a>
-<ul>
+<li><a href="#http2_event_connection_1">Event: <code>'connection'</code></a></li>
 <li><a href="#http2_event_request_1">Event: <code>'request'</code></a></li>
 <li><a href="#http2_event_session_1">Event: <code>'session'</code></a></li>
 <li><a href="#http2_event_sessionerror_1">Event: <code>'sessionError'</code></a></li>
@@ -261,6 +271,8 @@
 <li><a href="#http2_event_unknownprotocol">Event: <code>'unknownProtocol'</code></a></li>
 <li><a href="#http2_server_close_callback_1"><code>server.close([callback])</code></a></li>
 <li><a href="#http2_server_settimeout_msecs_callback_1"><code>server.setTimeout([msecs][, callback])</code></a></li>
+<li><a href="#http2_server_timeout_1"><code>server.timeout</code></a></li>
+<li><a href="#http2_server_updatesettings_settings_1"><code>server.updateSettings([settings])</code></a></li>
 </ul>
 </li>
 <li><a href="#http2_http2_createserver_options_onrequesthandler"><code>http2.createServer(options[, onRequestHandler])</code></a></li>
@@ -274,9 +286,13 @@
 <li><a href="#http2_http2_getdefaultsettings"><code>http2.getDefaultSettings()</code></a></li>
 <li><a href="#http2_http2_getpackedsettings_settings"><code>http2.getPackedSettings([settings])</code></a></li>
 <li><a href="#http2_http2_getunpackedsettings_buf"><code>http2.getUnpackedSettings(buf)</code></a></li>
-<li><a href="#http2_headers_object">Headers object</a></li>
+<li><a href="#http2_http2_sensitiveheaders"><code>http2.sensitiveHeaders</code></a></li>
+<li><a href="#http2_headers_object">Headers object</a>
+<ul>
+<li><a href="#http2_sensitive_headers">Sensitive headers</a></li>
+</ul>
+</li>
 <li><a href="#http2_settings_object">Settings object</a></li>
-<li><a href="#http2_using_options_selectpadding">Using <code>options.selectPadding()</code></a></li>
 <li><a href="#http2_error_handling">Error handling</a></li>
 <li><a href="#http2_invalid_character_handling_in_header_names_and_values">Invalid character handling in header names and values</a></li>
 <li><a href="#http2_push_streams_on_the_client">Push streams on the client</a></li>
@@ -294,6 +310,7 @@
 <li><a href="#http2_request_aborted"><code>request.aborted</code></a></li>
 <li><a href="#http2_request_authority"><code>request.authority</code></a></li>
 <li><a href="#http2_request_complete"><code>request.complete</code></a></li>
+<li><span class="stability_0"><a href="#http2_request_connection"><code>request.connection</code></a></span></li>
 <li><a href="#http2_request_destroy_error"><code>request.destroy([error])</code></a></li>
 <li><a href="#http2_request_headers"><code>request.headers</code></a></li>
 <li><a href="#http2_request_httpversion"><code>request.httpVersion</code></a></li>
@@ -313,7 +330,8 @@
 <li><a href="#http2_event_close_3">Event: <code>'close'</code></a></li>
 <li><a href="#http2_event_finish">Event: <code>'finish'</code></a></li>
 <li><a href="#http2_response_addtrailers_headers"><code>response.addTrailers(headers)</code></a></li>
-<li><a href="#http2_response_connection"><code>response.connection</code></a></li>
+<li><span class="stability_0"><a href="#http2_response_connection"><code>response.connection</code></a></span></li>
+<li><a href="#http2_response_createpushresponse_headers_callback"><code>response.createPushResponse(headers, callback)</code></a></li>
 <li><a href="#http2_response_end_data_encoding_callback"><code>response.end([data[, encoding]][, callback])</code></a></li>
 <li><span class="stability_0"><a href="#http2_response_finished"><code>response.finished</code></a></span></li>
 <li><a href="#http2_response_getheader_name"><code>response.getHeader(name)</code></a></li>
@@ -333,7 +351,6 @@
 <li><a href="#http2_response_write_chunk_encoding_callback"><code>response.write(chunk[, encoding][, callback])</code></a></li>
 <li><a href="#http2_response_writecontinue"><code>response.writeContinue()</code></a></li>
 <li><a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead(statusCode[, statusMessage][, headers])</code></a></li>
-<li><a href="#http2_response_createpushresponse_headers_callback"><code>response.createPushResponse(headers, callback)</code></a></li>
 </ul>
 </li>
 </ul>
@@ -341,15 +358,16 @@
 <li><a href="#http2_collecting_http_2_performance_metrics">Collecting HTTP/2 performance metrics</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>HTTP/2<span><a class="mark" href="#http2_http_2" id="http2_http_2">#</a></span></h1>
+        <h2>HTTP/2<span><a class="mark" href="#http2_http_2" id="http2_http_2">#</a></span></h2>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>It is possible to abort a request with an AbortSignal.</p></td></tr>
 <tr><td>v10.10.0</td>
 <td><p>HTTP/2 is now Stable. Previously, it had been Experimental.</p></td></tr>
 <tr><td>v8.4.0</td>
@@ -359,11 +377,11 @@
 </div>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/http2.js">lib/http2.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/http2.js">lib/http2.js</a></p>
 <p>The <code>http2</code> module provides an implementation of the <a href="https://tools.ietf.org/html/rfc7540">HTTP/2</a> protocol. It
 can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);</code></pre>
-<h2>Core API<span><a class="mark" href="#http2_core_api" id="http2_core_api">#</a></span></h2>
+<section><h3>Core API<span><a class="mark" href="#http2_core_api" id="http2_core_api">#</a></span></h3>
 <p>The Core API provides a low-level interface designed specifically around
 support for HTTP/2 protocol features. It is specifically <em>not</em> designed for
 compatibility with the existing <a href="http.html">HTTP/1</a> module API. However,
@@ -371,7 +389,7 @@ the <a href="#http2_compatibility_api">Compatibility API</a> is.</p>
 <p>The <code>http2</code> Core API is much more symmetric between client and server than the
 <code>http</code> API. For instance, most events, like <code>'error'</code>, <code>'connect'</code> and
 <code>'stream'</code>, can be emitted either by client-side code or server-side code.</p>
-<h3>Server-side example<span><a class="mark" href="#http2_server_side_example" id="http2_server_side_example">#</a></span></h3>
+<h4>Server-side example<span><a class="mark" href="#http2_server_side_example" id="http2_server_side_example">#</a></span></h4>
 <p>The following illustrates a simple HTTP/2 server using the Core API.
 Since there are no browsers known that support
 <a href="https://http2.github.io/faq/#does-http2-require-encryption">unencrypted HTTP/2</a>, the use of
@@ -380,51 +398,51 @@ with browser clients.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> server = http2.createSecureServer({
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'localhost-privkey.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'localhost-cert.pem'</span>)
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>({
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'localhost-privkey.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'localhost-cert.pem'</span>)
 });
-server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-built_in">console</span>.error(err));
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err));
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
   <span class="hljs-comment">// stream is a Duplex</span>
-  stream.respond({
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
   });
-  stream.end(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
 });
 
-server.listen(<span class="hljs-number">8443</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8443</span>);</code></pre>
 <p>To generate the certificate and key for this example, run:</p>
 <pre><code class="language-bash">openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj <span class="hljs-string">'/CN=localhost'</span> \
   -keyout localhost-privkey.pem -out localhost-cert.pem</code></pre>
-<h3>Client-side example<span><a class="mark" href="#http2_client_side_example" id="http2_client_side_example">#</a></span></h3>
+<h4>Client-side example<span><a class="mark" href="#http2_client_side_example" id="http2_client_side_example">#</a></span></h4>
 <p>The following illustrates an HTTP/2 client:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://localhost:8443'</span>, {
-  <span class="hljs-attr">ca</span>: fs.readFileSync(<span class="hljs-string">'localhost-cert.pem'</span>)
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://localhost:8443'</span>, {
+  <span class="hljs-attr">ca</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'localhost-cert.pem'</span>)
 });
-client.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-built_in">console</span>.error(err));
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err));
 
-<span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
 
-req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
   <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> name <span class="hljs-keyword">in</span> headers) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${name}</span>: <span class="hljs-subst">${headers[name]}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${name}</span>: <span class="hljs-subst">${headers[name]}</span>`</span>);
   }
 });
 
-req.setEncoding(<span class="hljs-string">'utf8'</span>);
+req.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
 <span class="hljs-keyword">let</span> data = <span class="hljs-string">''</span>;
-req.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { data += chunk; });
-req.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`\n<span class="hljs-subst">${data}</span>`</span>);
-  client.close();
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { data += chunk; });
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`\n<span class="hljs-subst">${data}</span>`</span>);
+  client.<span class="hljs-title function_">close</span>();
 });
-req.end();</code></pre>
-<h3>Class: <code>Http2Session</code><span><a class="mark" href="#http2_class_http2session" id="http2_class_http2session">#</a></span></h3>
+req.<span class="hljs-title function_">end</span>();</code></pre>
+<h4>Class: <code>Http2Session</code><span><a class="mark" href="#http2_class_http2session" id="http2_class_http2session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -445,7 +463,7 @@ actions typically taken through interactions with either the <code>Http2Server</
 <code>Http2Session</code> instances are created by the <code>Http2Server</code> instance when a
 new HTTP/2 connection is received. Client-side <code>Http2Session</code> instances are
 created using the <code>http2.connect()</code> method.</p>
-<h4><code>Http2Session</code> and sockets<span><a class="mark" href="#http2_http2session_and_sockets" id="http2_http2session_and_sockets">#</a></span></h4>
+<h5><code>Http2Session</code> and sockets<span><a class="mark" href="#http2_http2session_and_sockets" id="http2_http2session_and_sockets">#</a></span></h5>
 <p>Every <code>Http2Session</code> instance is associated with exactly one <a href="net.html#net_class_net_socket"><code>net.Socket</code></a> or
 <a href="tls.html#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> when it is created. When either the <code>Socket</code> or the
 <code>Http2Session</code> are destroyed, both will be destroyed.</p>
@@ -456,13 +474,13 @@ put the HTTP/2 session into an indeterminate state causing the session and
 the socket to become unusable.</p>
 <p>Once a <code>Socket</code> has been bound to an <code>Http2Session</code>, user code should rely
 solely on the API of the <code>Http2Session</code>.</p>
-<h4>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close" id="http2_event_close">#</a></span></h4>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close" id="http2_event_close">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'close'</code> event is emitted once the <code>Http2Session</code> has been destroyed. Its
 listener does not expect any arguments.</p>
-<h4>Event: <code>'connect'</code><span><a class="mark" href="#http2_event_connect" id="http2_event_connect">#</a></span></h4>
+<h5>Event: <code>'connect'</code><span><a class="mark" href="#http2_event_connect" id="http2_event_connect">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -473,7 +491,7 @@ listener does not expect any arguments.</p>
 <p>The <code>'connect'</code> event is emitted once the <code>Http2Session</code> has been successfully
 connected to the remote peer and communication may begin.</p>
 <p>User code will typically not listen for this event directly.</p>
-<h4>Event: <code>'error'</code><span><a class="mark" href="#http2_event_error" id="http2_event_error">#</a></span></h4>
+<h5>Event: <code>'error'</code><span><a class="mark" href="#http2_event_error" id="http2_event_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -482,7 +500,7 @@ connected to the remote peer and communication may begin.</p>
 </ul>
 <p>The <code>'error'</code> event is emitted when an error occurs during the processing of
 an <code>Http2Session</code>.</p>
-<h4>Event: <code>'frameError'</code><span><a class="mark" href="#http2_event_frameerror" id="http2_event_frameerror">#</a></span></h4>
+<h5>Event: <code>'frameError'</code><span><a class="mark" href="#http2_event_frameerror" id="http2_event_frameerror">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -500,7 +518,7 @@ with a specific <code>Http2Stream</code>, an attempt to emit a <code>'frameError
 closed and destroyed immediately following the <code>'frameError'</code> event. If the
 event is not associated with a stream, the <code>Http2Session</code> will be shut down
 immediately following the <code>'frameError'</code> event.</p>
-<h4>Event: <code>'goaway'</code><span><a class="mark" href="#http2_event_goaway" id="http2_event_goaway">#</a></span></h4>
+<h5>Event: <code>'goaway'</code><span><a class="mark" href="#http2_event_goaway" id="http2_event_goaway">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -514,7 +532,7 @@ frame, a <code>Buffer</code> instance will be passed containing that data.</li>
 <p>The <code>'goaway'</code> event is emitted when a <code>GOAWAY</code> frame is received.</p>
 <p>The <code>Http2Session</code> instance will be shut down automatically when the <code>'goaway'</code>
 event is emitted.</p>
-<h4>Event: <code>'localSettings'</code><span><a class="mark" href="#http2_event_localsettings" id="http2_event_localsettings">#</a></span></h4>
+<h5>Event: <code>'localSettings'</code><span><a class="mark" href="#http2_event_localsettings" id="http2_event_localsettings">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -525,12 +543,12 @@ event is emitted.</p>
 has been received.</p>
 <p>When using <code>http2session.settings()</code> to submit new settings, the modified
 settings do not take effect until the <code>'localSettings'</code> event is emitted.</p>
-<pre><code class="language-js">session.settings({ <span class="hljs-attr">enablePush</span>: <span class="hljs-literal">false</span> });
+<pre><code class="language-js">session.<span class="hljs-title function_">settings</span>({ <span class="hljs-attr">enablePush</span>: <span class="hljs-literal">false</span> });
 
-session.on(<span class="hljs-string">'localSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
+session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'localSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
   <span class="hljs-comment">/* Use the new settings */</span>
 });</code></pre>
-<h4>Event: <code>'ping'</code><span><a class="mark" href="#http2_event_ping" id="http2_event_ping">#</a></span></h4>
+<h5>Event: <code>'ping'</code><span><a class="mark" href="#http2_event_ping" id="http2_event_ping">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -539,7 +557,7 @@ session.on(<span class="hljs-string">'localSettings'</span>, <span class="hljs-f
 </ul>
 <p>The <code>'ping'</code> event is emitted whenever a <code>PING</code> frame is received from the
 connected peer.</p>
-<h4>Event: <code>'remoteSettings'</code><span><a class="mark" href="#http2_event_remotesettings" id="http2_event_remotesettings">#</a></span></h4>
+<h5>Event: <code>'remoteSettings'</code><span><a class="mark" href="#http2_event_remotesettings" id="http2_event_remotesettings">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -548,10 +566,10 @@ connected peer.</p>
 </ul>
 <p>The <code>'remoteSettings'</code> event is emitted when a new <code>SETTINGS</code> frame is received
 from the connected peer.</p>
-<pre><code class="language-js">session.on(<span class="hljs-string">'remoteSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
+<pre><code class="language-js">session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'remoteSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
   <span class="hljs-comment">/* Use the new settings */</span>
 });</code></pre>
-<h4>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream" id="http2_event_stream">#</a></span></h4>
+<h5>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream" id="http2_event_stream">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -564,16 +582,16 @@ their respective values.</li>
 </ul>
 <p>The <code>'stream'</code> event is emitted when a new <code>Http2Stream</code> is created.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-session.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
+session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
   <span class="hljs-keyword">const</span> method = headers[<span class="hljs-string">':method'</span>];
   <span class="hljs-keyword">const</span> path = headers[<span class="hljs-string">':path'</span>];
   <span class="hljs-comment">// ...</span>
-  stream.respond({
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>,
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   });
-  stream.write(<span class="hljs-string">'hello '</span>);
-  stream.end(<span class="hljs-string">'world'</span>);
+  stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello '</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'world'</span>);
 });</code></pre>
 <p>On the server side, user code will typically not listen for this event directly,
 and would instead register a handler for the <code>'stream'</code> event emitted by the
@@ -582,22 +600,22 @@ and would instead register a handler for the <code>'stream'</code> event emitted
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
 <span class="hljs-comment">// Create an unencrypted HTTP/2 server</span>
-<span class="hljs-keyword">const</span> server = http2.createServer();
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
-  stream.respond({
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
   });
-  stream.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> <span class="hljs-built_in">console</span>.error(error));
-  stream.end(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(error));
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
 });
 
-server.listen(<span class="hljs-number">80</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">80</span>);</code></pre>
 <p>Even though HTTP/2 streams and network sockets are not in a 1:1 correspondence,
 a network error will destroy each individual stream and must be handled on the
 stream level, as shown above.</p>
-<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout" id="http2_event_timeout">#</a></span></h4>
+<h5>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout" id="http2_event_timeout">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -605,9 +623,9 @@ stream level, as shown above.</p>
 for this <code>Http2Session</code>, the <code>'timeout'</code> event is emitted if there is no
 activity on the <code>Http2Session</code> after the configured number of milliseconds.
 Its listener does not expect any arguments.</p>
-<pre><code class="language-js">session.setTimeout(<span class="hljs-number">2000</span>);
-session.on(<span class="hljs-string">'timeout'</span>, <span class="hljs-function">() =></span> { <span class="hljs-comment">/* .. */</span> });</code></pre>
-<h4><code>http2session.alpnProtocol</code><span><a class="mark" href="#http2_http2session_alpnprotocol" id="http2_http2session_alpnprotocol">#</a></span></h4>
+<pre><code class="language-js">session.<span class="hljs-built_in">setTimeout</span>(<span class="hljs-number">2000</span>);
+session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'timeout'</span>, <span class="hljs-function">() =></span> { <span class="hljs-comment">/* .. */</span> });</code></pre>
+<h5><code>http2session.alpnProtocol</code><span><a class="mark" href="#http2_http2session_alpnprotocol" id="http2_http2session_alpnprotocol">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -618,7 +636,7 @@ session.on(<span class="hljs-string">'timeout'</span>, <span class="hljs-functio
 socket, <code>h2c</code> if the <code>Http2Session</code> is not connected to a <code>TLSSocket</code>, or
 will return the value of the connected <code>TLSSocket</code>'s own <code>alpnProtocol</code>
 property.</p>
-<h4><code>http2session.close([callback])</code><span><a class="mark" href="#http2_http2session_close_callback" id="http2_http2session_close_callback">#</a></span></h4>
+<h5><code>http2session.close([callback])</code><span><a class="mark" href="#http2_http2session_close_callback" id="http2_http2session_close_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -631,7 +649,7 @@ created. Once closed, <code>http2session.destroy()</code> <em>might</em> be call
 are no open <code>Http2Stream</code> instances.</p>
 <p>If specified, the <code>callback</code> function is registered as a handler for the
 <code>'close'</code> event.</p>
-<h4><code>http2session.closed</code><span><a class="mark" href="#http2_http2session_closed" id="http2_http2session_closed">#</a></span></h4>
+<h5><code>http2session.closed</code><span><a class="mark" href="#http2_http2session_closed" id="http2_http2session_closed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -640,7 +658,7 @@ are no open <code>Http2Stream</code> instances.</p>
 </ul>
 <p>Will be <code>true</code> if this <code>Http2Session</code> instance has been closed, otherwise
 <code>false</code>.</p>
-<h4><code>http2session.connecting</code><span><a class="mark" href="#http2_http2session_connecting" id="http2_http2session_connecting">#</a></span></h4>
+<h5><code>http2session.connecting</code><span><a class="mark" href="#http2_http2session_connecting" id="http2_http2session_connecting">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -650,7 +668,7 @@ are no open <code>Http2Stream</code> instances.</p>
 <p>Will be <code>true</code> if this <code>Http2Session</code> instance is still connecting, will be set
 to <code>false</code> before emitting <code>connect</code> event and/or calling the <code>http2.connect</code>
 callback.</p>
-<h4><code>http2session.destroy([error][, code])</code><span><a class="mark" href="#http2_http2session_destroy_error_code" id="http2_http2session_destroy_error_code">#</a></span></h4>
+<h5><code>http2session.destroy([error][, code])</code><span><a class="mark" href="#http2_http2session_destroy_error_code" id="http2_http2session_destroy_error_code">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -668,7 +686,7 @@ is not undefined, an <code>'error'</code> event will be emitted immediately befo
 <code>'close'</code> event.</p>
 <p>If there are any remaining open <code>Http2Streams</code> associated with the
 <code>Http2Session</code>, those will also be destroyed.</p>
-<h4><code>http2session.destroyed</code><span><a class="mark" href="#http2_http2session_destroyed" id="http2_http2session_destroyed">#</a></span></h4>
+<h5><code>http2session.destroyed</code><span><a class="mark" href="#http2_http2session_destroyed" id="http2_http2session_destroyed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -677,7 +695,7 @@ is not undefined, an <code>'error'</code> event will be emitted immediately befo
 </ul>
 <p>Will be <code>true</code> if this <code>Http2Session</code> instance has been destroyed and must no
 longer be used, otherwise <code>false</code>.</p>
-<h4><code>http2session.encrypted</code><span><a class="mark" href="#http2_http2session_encrypted" id="http2_http2session_encrypted">#</a></span></h4>
+<h5><code>http2session.encrypted</code><span><a class="mark" href="#http2_http2session_encrypted" id="http2_http2session_encrypted">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -688,7 +706,7 @@ longer be used, otherwise <code>false</code>.</p>
 connected, <code>true</code> if the <code>Http2Session</code> is connected with a <code>TLSSocket</code>,
 and <code>false</code> if the <code>Http2Session</code> is connected to any other kind of socket
 or stream.</p>
-<h4><code>http2session.goaway([code[, lastStreamID[, opaqueData]]])</code><span><a class="mark" href="#http2_http2session_goaway_code_laststreamid_opaquedata" id="http2_http2session_goaway_code_laststreamid_opaquedata">#</a></span></h4>
+<h5><code>http2session.goaway([code[, lastStreamID[, opaqueData]]])</code><span><a class="mark" href="#http2_http2session_goaway_code_laststreamid_opaquedata" id="http2_http2session_goaway_code_laststreamid_opaquedata">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -700,7 +718,7 @@ instance containing additional data to be carried within the <code>GOAWAY</code>
 </ul>
 <p>Transmits a <code>GOAWAY</code> frame to the connected peer <em>without</em> shutting down the
 <code>Http2Session</code>.</p>
-<h4><code>http2session.localSettings</code><span><a class="mark" href="#http2_http2session_localsettings" id="http2_http2session_localsettings">#</a></span></h4>
+<h5><code>http2session.localSettings</code><span><a class="mark" href="#http2_http2session_localsettings" id="http2_http2session_localsettings">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -709,7 +727,7 @@ instance containing additional data to be carried within the <code>GOAWAY</code>
 </ul>
 <p>A prototype-less object describing the current local settings of this
 <code>Http2Session</code>. The local settings are local to <em>this</em> <code>Http2Session</code> instance.</p>
-<h4><code>http2session.originSet</code><span><a class="mark" href="#http2_http2session_originset" id="http2_http2session_originset">#</a></span></h4>
+<h5><code>http2session.originSet</code><span><a class="mark" href="#http2_http2session_originset" id="http2_http2session_originset">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -720,7 +738,7 @@ instance containing additional data to be carried within the <code>GOAWAY</code>
 will return an <code>Array</code> of origins for which the <code>Http2Session</code> may be
 considered authoritative.</p>
 <p>The <code>originSet</code> property is only available when using a secure TLS connection.</p>
-<h4><code>http2session.pendingSettingsAck</code><span><a class="mark" href="#http2_http2session_pendingsettingsack" id="http2_http2session_pendingsettingsack">#</a></span></h4>
+<h5><code>http2session.pendingSettingsAck</code><span><a class="mark" href="#http2_http2session_pendingsettingsack" id="http2_http2session_pendingsettingsack">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -731,7 +749,7 @@ considered authoritative.</p>
 a sent <code>SETTINGS</code> frame. Will be <code>true</code> after calling the
 <code>http2session.settings()</code> method. Will be <code>false</code> once all sent <code>SETTINGS</code>
 frames have been acknowledged.</p>
-<h4><code>http2session.ping([payload, ]callback)</code><span><a class="mark" href="#http2_http2session_ping_payload_callback" id="http2_http2session_ping_payload_callback">#</a></span></h4>
+<h5><code>http2session.ping([payload, ]callback)</code><span><a class="mark" href="#http2_http2session_ping_payload_callback" id="http2_http2session_ping_payload_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.9.3</span>
 </div>
@@ -753,21 +771,21 @@ be <code>null</code> if the <code>PING</code> was successfully acknowledged, a <
 that reports the number of milliseconds elapsed since the ping was sent and the
 acknowledgment was received, and a <code>Buffer</code> containing the 8-byte <code>PING</code>
 payload.</p>
-<pre><code class="language-js">session.ping(Buffer.from(<span class="hljs-string">'abcdefgh'</span>), <span class="hljs-function">(<span class="hljs-params">err, duration, payload</span>) =></span> {
+<pre><code class="language-js">session.<span class="hljs-title function_">ping</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'abcdefgh'</span>), <span class="hljs-function">(<span class="hljs-params">err, duration, payload</span>) =></span> {
   <span class="hljs-keyword">if</span> (!err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Ping acknowledged in <span class="hljs-subst">${duration}</span> milliseconds`</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`With payload '<span class="hljs-subst">${payload.toString()}</span>'`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Ping acknowledged in <span class="hljs-subst">${duration}</span> milliseconds`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`With payload '<span class="hljs-subst">${payload.toString()}</span>'`</span>);
   }
 });</code></pre>
 <p>If the <code>payload</code> argument is not specified, the default payload will be the
 64-bit timestamp (little endian) marking the start of the <code>PING</code> duration.</p>
-<h4><code>http2session.ref()</code><span><a class="mark" href="#http2_http2session_ref" id="http2_http2session_ref">#</a></span></h4>
+<h5><code>http2session.ref()</code><span><a class="mark" href="#http2_http2session_ref" id="http2_http2session_ref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
 <p>Calls <a href="net.html#net_socket_ref"><code>ref()</code></a> on this <code>Http2Session</code>
 instance's underlying <a href="net.html#net_class_net_socket"><code>net.Socket</code></a>.</p>
-<h4><code>http2session.remoteSettings</code><span><a class="mark" href="#http2_http2session_remotesettings" id="http2_http2session_remotesettings">#</a></span></h4>
+<h5><code>http2session.remoteSettings</code><span><a class="mark" href="#http2_http2session_remotesettings" id="http2_http2session_remotesettings">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -776,7 +794,26 @@ instance's underlying <a href="net.html#net_class_net_socket"><code>net.Socket</
 </ul>
 <p>A prototype-less object describing the current remote settings of this
 <code>Http2Session</code>. The remote settings are set by the <em>connected</em> HTTP/2 peer.</p>
-<h4><code>http2session.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_http2session_settimeout_msecs_callback" id="http2_http2session_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>http2session.setLocalWindowSize(windowSize)</code><span><a class="mark" href="#http2_http2session_setlocalwindowsize_windowsize" id="http2_http2session_setlocalwindowsize_windowsize">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>windowSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>Sets the local endpoint's window size.
+The <code>windowSize</code> is the total window size to set, not
+the delta.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
+
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+<span class="hljs-keyword">const</span> expectedWindowSize = <span class="hljs-number">2</span> ** <span class="hljs-number">20</span>;
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'connect'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
+
+  <span class="hljs-comment">// Set local window size to be 2 ** 20</span>
+  session.<span class="hljs-title function_">setLocalWindowSize</span>(expectedWindowSize);
+});</code></pre>
+<h5><code>http2session.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_http2session_settimeout_msecs_callback" id="http2_http2session_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -787,7 +824,7 @@ instance's underlying <a href="net.html#net_class_net_socket"><code>net.Socket</
 <p>Used to set a callback function that is called when there is no activity on
 the <code>Http2Session</code> after <code>msecs</code> milliseconds. The given <code>callback</code> is
 registered as a listener on the <code>'timeout'</code> event.</p>
-<h4><code>http2session.socket</code><span><a class="mark" href="#http2_http2session_socket" id="http2_http2session_socket">#</a></span></h4>
+<h5><code>http2session.socket</code><span><a class="mark" href="#http2_http2session_socket" id="http2_http2session_socket">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -801,7 +838,7 @@ an error with code <code>ERR_HTTP2_NO_SOCKET_MANIPULATION</code>. See
 <a href="#http2_http2session_and_sockets"><code>Http2Session</code> and Sockets</a> for more information.</p>
 <p><code>setTimeout</code> method will be called on this <code>Http2Session</code>.</p>
 <p>All other interactions will be routed directly to the socket.</p>
-<h4><code>http2session.state</code><span><a class="mark" href="#http2_http2session_state" id="http2_http2session_state">#</a></span></h4>
+<h5><code>http2session.state</code><span><a class="mark" href="#http2_http2session_state" id="http2_http2session_state">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -832,7 +869,7 @@ inbound header compression state table.</li>
 </li>
 </ul>
 <p>An object describing the current status of this <code>Http2Session</code>.</p>
-<h4><code>http2session.settings([settings][, callback])</code><span><a class="mark" href="#http2_http2session_settings_settings_callback" id="http2_http2session_settings_settings_callback">#</a></span></h4>
+<h5><code>http2session.settings([settings][, callback])</code><span><a class="mark" href="#http2_http2session_settings_settings_callback" id="http2_http2session_settings_settings_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -855,7 +892,7 @@ settings.</p>
 <p>The new settings will not become effective until the <code>SETTINGS</code> acknowledgment
 is received and the <code>'localSettings'</code> event is emitted. It is possible to send
 multiple <code>SETTINGS</code> frames while acknowledgment is still pending.</p>
-<h4><code>http2session.type</code><span><a class="mark" href="#http2_http2session_type" id="http2_http2session_type">#</a></span></h4>
+<h5><code>http2session.type</code><span><a class="mark" href="#http2_http2session_type" id="http2_http2session_type">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -866,20 +903,20 @@ multiple <code>SETTINGS</code> frames while acknowledgment is still pending.</p>
 <code>http2.constants.NGHTTP2_SESSION_SERVER</code> if this <code>Http2Session</code> instance is a
 server, and <code>http2.constants.NGHTTP2_SESSION_CLIENT</code> if the instance is a
 client.</p>
-<h4><code>http2session.unref()</code><span><a class="mark" href="#http2_http2session_unref" id="http2_http2session_unref">#</a></span></h4>
+<h5><code>http2session.unref()</code><span><a class="mark" href="#http2_http2session_unref" id="http2_http2session_unref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
 <p>Calls <a href="net.html#net_socket_unref"><code>unref()</code></a> on this <code>Http2Session</code>
 instance's underlying <a href="net.html#net_class_net_socket"><code>net.Socket</code></a>.</p>
-<h3>Class: <code>ServerHttp2Session</code><span><a class="mark" href="#http2_class_serverhttp2session" id="http2_class_serverhttp2session">#</a></span></h3>
+<h4>Class: <code>ServerHttp2Session</code><span><a class="mark" href="#http2_class_serverhttp2session" id="http2_class_serverhttp2session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <ul>
 <li>Extends: <a href="http2.html#http2_class_http2session" class="type">&#x3C;Http2Session></a></li>
 </ul>
-<h4><code>serverhttp2session.altsvc(alt, originOrStream)</code><span><a class="mark" href="#http2_serverhttp2session_altsvc_alt_originorstream" id="http2_serverhttp2session_altsvc_alt_originorstream">#</a></span></h4>
+<h5><code>serverhttp2session.altsvc(alt, originOrStream)</code><span><a class="mark" href="#http2_serverhttp2session_altsvc_alt_originorstream" id="http2_serverhttp2session_altsvc_alt_originorstream">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -894,15 +931,15 @@ property.</li>
 <p>Submits an <code>ALTSVC</code> frame (as defined by <a href="https://tools.ietf.org/html/rfc7838">RFC 7838</a>) to the connected client.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
   <span class="hljs-comment">// Set altsvc for origin https://example.org:80</span>
-  session.altsvc(<span class="hljs-string">'h2=":8000"'</span>, <span class="hljs-string">'https://example.org:80'</span>);
+  session.<span class="hljs-title function_">altsvc</span>(<span class="hljs-string">'h2=":8000"'</span>, <span class="hljs-string">'https://example.org:80'</span>);
 });
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
   <span class="hljs-comment">// Set altsvc for a specific stream</span>
-  stream.session.altsvc(<span class="hljs-string">'h2=":8000"'</span>, stream.id);
+  stream.<span class="hljs-property">session</span>.<span class="hljs-title function_">altsvc</span>(<span class="hljs-string">'h2=":8000"'</span>, stream.<span class="hljs-property">id</span>);
 });</code></pre>
 <p>Sending an <code>ALTSVC</code> frame with a specific stream ID indicates that the alternate
 service is associated with the origin of the given <code>Http2Stream</code>.</p>
@@ -919,7 +956,7 @@ cannot be parsed as a URL or if a valid origin cannot be derived.</p>
 <code>originOrStream</code>, in which case the value of the <code>origin</code> property will be
 used. The value of the <code>origin</code> property <em>must</em> be a properly serialized
 ASCII origin.</p>
-<h4>Specifying alternative services<span><a class="mark" href="#http2_specifying_alternative_services" id="http2_specifying_alternative_services">#</a></span></h4>
+<h5>Specifying alternative services<span><a class="mark" href="#http2_specifying_alternative_services" id="http2_specifying_alternative_services">#</a></span></h5>
 <p>The format of the <code>alt</code> parameter is strictly defined by <a href="https://tools.ietf.org/html/rfc7838">RFC 7838</a> as an
 ASCII string containing a comma-delimited list of "alternative" protocols
 associated with a specific host and port.</p>
@@ -931,7 +968,7 @@ host and port <em>must</em> be contained within the quote (<code>"</code>) chara
 <a href="https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids">ALPN Protocol ID</a>.</p>
 <p>The syntax of these values is not validated by the Node.js implementation and
 are passed through as provided by the user or received from the peer.</p>
-<h4><code>serverhttp2session.origin(...origins)</code><span><a class="mark" href="#http2_serverhttp2session_origin_origins" id="http2_serverhttp2session_origin_origins">#</a></span></h4>
+<h5><code>serverhttp2session.origin(...origins)</code><span><a class="mark" href="#http2_serverhttp2session_origin_origins" id="http2_serverhttp2session_origin_origins">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -943,14 +980,14 @@ separate arguments.</li>
 to advertise the set of origins for which the server is capable of providing
 authoritative responses.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> options = getSecureOptionsSomehow();
-<span class="hljs-keyword">const</span> server = http2.createSecureServer(options);
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond();
-  stream.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> options = <span class="hljs-title function_">getSecureOptionsSomehow</span>();
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>(options);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>();
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });
-server.on(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
-  session.origin(<span class="hljs-string">'https://example.com'</span>, <span class="hljs-string">'https://example.org'</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
+  session.<span class="hljs-title function_">origin</span>(<span class="hljs-string">'https://example.com'</span>, <span class="hljs-string">'https://example.org'</span>);
 });</code></pre>
 <p>When a string is passed as an <code>origin</code>, it will be parsed as a URL and the
 origin will be derived. For instance, the origin for the HTTP URL
@@ -964,21 +1001,21 @@ ASCII origin.</p>
 <p>Alternatively, the <code>origins</code> option may be used when creating a new HTTP/2
 server using the <code>http2.createSecureServer()</code> method:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> options = getSecureOptionsSomehow();
-options.origins = [<span class="hljs-string">'https://example.com'</span>, <span class="hljs-string">'https://example.org'</span>];
-<span class="hljs-keyword">const</span> server = http2.createSecureServer(options);
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond();
-  stream.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> options = <span class="hljs-title function_">getSecureOptionsSomehow</span>();
+options.<span class="hljs-property">origins</span> = [<span class="hljs-string">'https://example.com'</span>, <span class="hljs-string">'https://example.org'</span>];
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>(options);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>();
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
-<h3>Class: <code>ClientHttp2Session</code><span><a class="mark" href="#http2_class_clienthttp2session" id="http2_class_clienthttp2session">#</a></span></h3>
+<h4>Class: <code>ClientHttp2Session</code><span><a class="mark" href="#http2_class_clienthttp2session" id="http2_class_clienthttp2session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <ul>
 <li>Extends: <a href="http2.html#http2_class_http2session" class="type">&#x3C;Http2Session></a></li>
 </ul>
-<h4>Event: <code>'altsvc'</code><span><a class="mark" href="#http2_event_altsvc" id="http2_event_altsvc">#</a></span></h4>
+<h5>Event: <code>'altsvc'</code><span><a class="mark" href="#http2_event_altsvc" id="http2_event_altsvc">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -992,14 +1029,14 @@ the client. The event is emitted with the <code>ALTSVC</code> value, origin, and
 ID. If no <code>origin</code> is provided in the <code>ALTSVC</code> frame, <code>origin</code> will
 be an empty string.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://example.org'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://example.org'</span>);
 
-client.on(<span class="hljs-string">'altsvc'</span>, <span class="hljs-function">(<span class="hljs-params">alt, origin, streamId</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(alt);
-  <span class="hljs-built_in">console</span>.log(origin);
-  <span class="hljs-built_in">console</span>.log(streamId);
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'altsvc'</span>, <span class="hljs-function">(<span class="hljs-params">alt, origin, streamId</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(alt);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(origin);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(streamId);
 });</code></pre>
-<h4>Event: <code>'origin'</code><span><a class="mark" href="#http2_event_origin" id="http2_event_origin">#</a></span></h4>
+<h5>Event: <code>'origin'</code><span><a class="mark" href="#http2_event_origin" id="http2_event_origin">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -1011,14 +1048,14 @@ the client. The event is emitted with an array of <code>origin</code> strings. T
 <code>http2session.originSet</code> will be updated to include the received
 origins.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://example.org'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://example.org'</span>);
 
-client.on(<span class="hljs-string">'origin'</span>, <span class="hljs-function">(<span class="hljs-params">origins</span>) =></span> {
-  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; origins.length; n++)
-    <span class="hljs-built_in">console</span>.log(origins[n]);
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'origin'</span>, <span class="hljs-function">(<span class="hljs-params">origins</span>) =></span> {
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; origins.<span class="hljs-property">length</span>; n++)
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(origins[n]);
 });</code></pre>
 <p>The <code>'origin'</code> event is only emitted when using a secure TLS connection.</p>
-<h4><code>clienthttp2session.request(headers[, options])</code><span><a class="mark" href="#http2_clienthttp2session_request_headers_options" id="http2_clienthttp2session_request_headers_options">#</a></span></h4>
+<h5><code>clienthttp2session.request(headers[, options])</code><span><a class="mark" href="#http2_clienthttp2session_request_headers_options" id="http2_clienthttp2session_request_headers_options">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1043,6 +1080,8 @@ to other streams with the same <code>parent</code>. The value is a number betwee
 and <code>256</code> (inclusive).</li>
 <li><code>waitForTrailers</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, the <code>Http2Stream</code> will emit the
 <code>'wantTrailers'</code> event after the final <code>DATA</code> frame has been sent.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> An AbortSignal that may be used to abort an ongoing
+request.</li>
 </ul>
 </li>
 <li>
@@ -1055,17 +1094,17 @@ HTTP/2 request to the connected server.</p>
 <p>This method is only available if <code>http2session.type</code> is equal to
 <code>http2.constants.NGHTTP2_SESSION_CLIENT</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> clientSession = http2.connect(<span class="hljs-string">'https://localhost:1234'</span>);
+<span class="hljs-keyword">const</span> clientSession = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://localhost:1234'</span>);
 <span class="hljs-keyword">const</span> {
   HTTP2_HEADER_PATH,
   HTTP2_HEADER_STATUS
-} = http2.constants;
+} = http2.<span class="hljs-property">constants</span>;
 
-<span class="hljs-keyword">const</span> req = clientSession.request({ [HTTP2_HEADER_PATH]: <span class="hljs-string">'/'</span> });
-req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers[HTTP2_HEADER_STATUS]);
-  req.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-comment">/* .. */</span> });
-  req.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> { <span class="hljs-comment">/* .. */</span> });
+<span class="hljs-keyword">const</span> req = clientSession.<span class="hljs-title function_">request</span>({ [HTTP2_HEADER_PATH]: <span class="hljs-string">'/'</span> });
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers[HTTP2_HEADER_STATUS]);
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-comment">/* .. */</span> });
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> { <span class="hljs-comment">/* .. */</span> });
 });</code></pre>
 <p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event
 is emitted immediately after queuing the last chunk of payload data to be sent.
@@ -1075,13 +1114,16 @@ headers to the peer.</p>
 close when the final <code>DATA</code> frame is transmitted. User code must call either
 <code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the
 <code>Http2Stream</code>.</p>
+<p>When <code>options.signal</code> is set with an <code>AbortSignal</code> and then <code>abort</code> on the
+corresponding <code>AbortController</code> is called, the request will emit an <code>'error'</code>
+event with an <code>AbortError</code> error.</p>
 <p>The <code>:method</code> and <code>:path</code> pseudo-headers are not specified within <code>headers</code>,
 they respectively default to:</p>
 <ul>
 <li><code>:method</code> = <code>'GET'</code></li>
 <li><code>:path</code> = <code>/</code></li>
 </ul>
-<h3>Class: <code>Http2Stream</code><span><a class="mark" href="#http2_class_http2stream" id="http2_class_http2stream">#</a></span></h3>
+<h4>Class: <code>Http2Stream</code><span><a class="mark" href="#http2_class_http2stream" id="http2_class_http2stream">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1109,12 +1151,12 @@ is used to receive data sent by the connected peer.</p>
 practice, it is recommended that when using an <code>Http2Stream</code> to send text,
 the <code>'content-type'</code> header should be set and should identify the character
 encoding used.</p>
-<pre><code class="language-js">stream.respond({
+<pre><code class="language-js">stream.<span class="hljs-title function_">respond</span>({
   <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
   <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
 });</code></pre>
-<h4><code>Http2Stream</code> Lifecycle<span><a class="mark" href="#http2_http2stream_lifecycle" id="http2_http2stream_lifecycle">#</a></span></h4>
-<h5>Creation<span><a class="mark" href="#http2_creation" id="http2_creation">#</a></span></h5>
+<h5><code>Http2Stream</code> Lifecycle<span><a class="mark" href="#http2_http2stream_lifecycle" id="http2_http2stream_lifecycle">#</a></span></h5>
+<h6>Creation<span><a class="mark" href="#http2_creation" id="http2_creation">#</a></span></h6>
 <p>On the server side, instances of <a href="#http2_class_serverhttp2stream"><code>ServerHttp2Stream</code></a> are created either
 when:</p>
 <ul>
@@ -1130,7 +1172,7 @@ will be buffered until the <code>'ready'</code> event is emitted. User code shou
 if ever, need to handle the <code>'ready'</code> event directly. The ready status of an
 <code>Http2Stream</code> can be determined by checking the value of <code>http2stream.id</code>. If
 the value is <code>undefined</code>, the stream is not yet ready for use.</p>
-<h5>Destruction<span><a class="mark" href="#http2_destruction" id="http2_destruction">#</a></span></h5>
+<h6>Destruction<span><a class="mark" href="#http2_destruction" id="http2_destruction">#</a></span></h6>
 <p>All <a href="#http2_class_http2stream"><code>Http2Stream</code></a> instances are destroyed either when:</p>
 <ul>
 <li>An <code>RST_STREAM</code> frame for the stream is received by the connected peer,
@@ -1150,7 +1192,7 @@ with an <code>Error</code> passed as the first argument.</p>
 property will be <code>true</code> and the <code>http2stream.rstCode</code> property will specify the
 <code>RST_STREAM</code> error code. The <code>Http2Stream</code> instance is no longer usable once
 destroyed.</p>
-<h4>Event: <code>'aborted'</code><span><a class="mark" href="#http2_event_aborted" id="http2_event_aborted">#</a></span></h4>
+<h5>Event: <code>'aborted'</code><span><a class="mark" href="#http2_event_aborted" id="http2_event_aborted">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1159,7 +1201,7 @@ abnormally aborted in mid-communication.
 Its listener does not expect any arguments.</p>
 <p>The <code>'aborted'</code> event will only be emitted if the <code>Http2Stream</code> writable side
 has not been ended.</p>
-<h4>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_1" id="http2_event_close_1">#</a></span></h4>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_1" id="http2_event_close_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1168,7 +1210,7 @@ this event is emitted, the <code>Http2Stream</code> instance is no longer usable
 <p>The HTTP/2 error code used when closing the stream can be retrieved using
 the <code>http2stream.rstCode</code> property. If the code is any value other than
 <code>NGHTTP2_NO_ERROR</code> (<code>0</code>), an <code>'error'</code> event will have also been emitted.</p>
-<h4>Event: <code>'error'</code><span><a class="mark" href="#http2_event_error_1" id="http2_event_error_1">#</a></span></h4>
+<h5>Event: <code>'error'</code><span><a class="mark" href="#http2_event_error_1" id="http2_event_error_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1177,7 +1219,7 @@ the <code>http2stream.rstCode</code> property. If the code is any value other th
 </ul>
 <p>The <code>'error'</code> event is emitted when an error occurs during the processing of
 an <code>Http2Stream</code>.</p>
-<h4>Event: <code>'frameError'</code><span><a class="mark" href="#http2_event_frameerror_1" id="http2_event_frameerror_1">#</a></span></h4>
+<h5>Event: <code>'frameError'</code><span><a class="mark" href="#http2_event_frameerror_1" id="http2_event_frameerror_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1192,14 +1234,14 @@ send a frame. When invoked, the handler function will receive an integer
 argument identifying the frame type, and an integer argument identifying the
 error code. The <code>Http2Stream</code> instance will be destroyed immediately after the
 <code>'frameError'</code> event is emitted.</p>
-<h4>Event: <code>'ready'</code><span><a class="mark" href="#http2_event_ready" id="http2_event_ready">#</a></span></h4>
+<h5>Event: <code>'ready'</code><span><a class="mark" href="#http2_event_ready" id="http2_event_ready">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'ready'</code> event is emitted when the <code>Http2Stream</code> has been opened, has
 been assigned an <code>id</code>, and can be used. The listener does not expect any
 arguments.</p>
-<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_1" id="http2_event_timeout_1">#</a></span></h4>
+<h5>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_1" id="http2_event_timeout_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1207,7 +1249,7 @@ arguments.</p>
 <code>Http2Stream</code> within the number of milliseconds set using
 <code>http2stream.setTimeout()</code>.
 Its listener does not expect any arguments.</p>
-<h4>Event: <code>'trailers'</code><span><a class="mark" href="#http2_event_trailers" id="http2_event_trailers">#</a></span></h4>
+<h5>Event: <code>'trailers'</code><span><a class="mark" href="#http2_event_trailers" id="http2_event_trailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1221,10 +1263,10 @@ trailing header fields is received. The listener callback is passed the
 <p>This event might not be emitted if <code>http2stream.end()</code> is called
 before trailers are received and the incoming data is not being read or
 listened for.</p>
-<pre><code class="language-js">stream.on(<span class="hljs-string">'trailers'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers);
+<pre><code class="language-js">stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'trailers'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers);
 });</code></pre>
-<h4>Event: <code>'wantTrailers'</code><span><a class="mark" href="#http2_event_wanttrailers" id="http2_event_wanttrailers">#</a></span></h4>
+<h5>Event: <code>'wantTrailers'</code><span><a class="mark" href="#http2_event_wanttrailers" id="http2_event_wanttrailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1232,7 +1274,7 @@ listened for.</p>
 final <code>DATA</code> frame to be sent on a frame and the <code>Http2Stream</code> is ready to send
 trailing headers. When initiating a request or response, the <code>waitForTrailers</code>
 option must be set for this event to be emitted.</p>
-<h4><code>http2stream.aborted</code><span><a class="mark" href="#http2_http2stream_aborted" id="http2_http2stream_aborted">#</a></span></h4>
+<h5><code>http2stream.aborted</code><span><a class="mark" href="#http2_http2stream_aborted" id="http2_http2stream_aborted">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1241,16 +1283,16 @@ option must be set for this event to be emitted.</p>
 </ul>
 <p>Set to <code>true</code> if the <code>Http2Stream</code> instance was aborted abnormally. When set,
 the <code>'aborted'</code> event will have been emitted.</p>
-<h4><code>http2stream.bufferSize</code><span><a class="mark" href="#http2_http2stream_buffersize" id="http2_http2stream_buffersize">#</a></span></h4>
+<h5><code>http2stream.bufferSize</code><span><a class="mark" href="#http2_http2stream_buffersize" id="http2_http2stream_buffersize">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v11.2.0</span>
+<span>Added in: v11.2.0, v10.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>This property shows the number of characters currently buffered to be written.
 See <a href="net.html#net_socket_buffersize"><code>net.Socket.bufferSize</code></a> for details.</p>
-<h4><code>http2stream.close(code[, callback])</code><span><a class="mark" href="#http2_http2stream_close_code_callback" id="http2_http2stream_close_code_callback">#</a></span></h4>
+<h5><code>http2stream.close(code[, callback])</code><span><a class="mark" href="#http2_http2stream_close_code_callback" id="http2_http2stream_close_code_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1262,7 +1304,7 @@ See <a href="net.html#net_socket_buffersize"><code>net.Socket.bufferSize</code><
 </ul>
 <p>Closes the <code>Http2Stream</code> instance by sending an <code>RST_STREAM</code> frame to the
 connected HTTP/2 peer.</p>
-<h4><code>http2stream.closed</code><span><a class="mark" href="#http2_http2stream_closed" id="http2_http2stream_closed">#</a></span></h4>
+<h5><code>http2stream.closed</code><span><a class="mark" href="#http2_http2stream_closed" id="http2_http2stream_closed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -1270,7 +1312,7 @@ connected HTTP/2 peer.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Set to <code>true</code> if the <code>Http2Stream</code> instance has been closed.</p>
-<h4><code>http2stream.destroyed</code><span><a class="mark" href="#http2_http2stream_destroyed" id="http2_http2stream_destroyed">#</a></span></h4>
+<h5><code>http2stream.destroyed</code><span><a class="mark" href="#http2_http2stream_destroyed" id="http2_http2stream_destroyed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1279,7 +1321,7 @@ connected HTTP/2 peer.</p>
 </ul>
 <p>Set to <code>true</code> if the <code>Http2Stream</code> instance has been destroyed and is no longer
 usable.</p>
-<h4><code>http2stream.endAfterHeaders</code><span><a class="mark" href="#http2_http2stream_endafterheaders" id="http2_http2stream_endafterheaders">#</a></span></h4>
+<h5><code>http2stream.endAfterHeaders</code><span><a class="mark" href="#http2_http2stream_endafterheaders" id="http2_http2stream_endafterheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.11.0</span>
 </div>
@@ -1289,7 +1331,7 @@ usable.</p>
 <p>Set the <code>true</code> if the <code>END_STREAM</code> flag was set in the request or response
 HEADERS frame received, indicating that no additional data should be received
 and the readable side of the <code>Http2Stream</code> will be closed.</p>
-<h4><code>http2stream.id</code><span><a class="mark" href="#http2_http2stream_id" id="http2_http2stream_id">#</a></span></h4>
+<h5><code>http2stream.id</code><span><a class="mark" href="#http2_http2stream_id" id="http2_http2stream_id">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1298,7 +1340,7 @@ and the readable side of the <code>Http2Stream</code> will be closed.</p>
 </ul>
 <p>The numeric stream identifier of this <code>Http2Stream</code> instance. Set to <code>undefined</code>
 if the stream identifier has not yet been assigned.</p>
-<h4><code>http2stream.pending</code><span><a class="mark" href="#http2_http2stream_pending" id="http2_http2stream_pending">#</a></span></h4>
+<h5><code>http2stream.pending</code><span><a class="mark" href="#http2_http2stream_pending" id="http2_http2stream_pending">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -1307,7 +1349,7 @@ if the stream identifier has not yet been assigned.</p>
 </ul>
 <p>Set to <code>true</code> if the <code>Http2Stream</code> instance has not yet been assigned a
 numeric stream identifier.</p>
-<h4><code>http2stream.priority(options)</code><span><a class="mark" href="#http2_http2stream_priority_options" id="http2_http2stream_priority_options">#</a></span></h4>
+<h5><code>http2stream.priority(options)</code><span><a class="mark" href="#http2_http2stream_priority_options" id="http2_http2stream_priority_options">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1329,18 +1371,18 @@ sending a <code>PRIORITY</code> frame to the connected peer.</li>
 </li>
 </ul>
 <p>Updates the priority for this <code>Http2Stream</code> instance.</p>
-<h4><code>http2stream.rstCode</code><span><a class="mark" href="#http2_http2stream_rstcode" id="http2_http2stream_rstcode">#</a></span></h4>
+<h5><code>http2stream.rstCode</code><span><a class="mark" href="#http2_http2stream_rstcode" id="http2_http2stream_rstcode">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>Set to the <code>RST_STREAM</code> <a href="#error_codes">error code</a> reported when the <code>Http2Stream</code> is
+<p>Set to the <code>RST_STREAM</code> <a href="#http2_error_codes_for_rst_stream_and_goaway">error code</a> reported when the <code>Http2Stream</code> is
 destroyed after either receiving an <code>RST_STREAM</code> frame from the connected peer,
 calling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>. Will be
 <code>undefined</code> if the <code>Http2Stream</code> has not been closed.</p>
-<h4><code>http2stream.sentHeaders</code><span><a class="mark" href="#http2_http2stream_sentheaders" id="http2_http2stream_sentheaders">#</a></span></h4>
+<h5><code>http2stream.sentHeaders</code><span><a class="mark" href="#http2_http2stream_sentheaders" id="http2_http2stream_sentheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.5.0</span>
 </div>
@@ -1348,7 +1390,7 @@ calling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>.
 <li><a href="http2.html#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a></li>
 </ul>
 <p>An object containing the outbound headers sent for this <code>Http2Stream</code>.</p>
-<h4><code>http2stream.sentInfoHeaders</code><span><a class="mark" href="#http2_http2stream_sentinfoheaders" id="http2_http2stream_sentinfoheaders">#</a></span></h4>
+<h5><code>http2stream.sentInfoHeaders</code><span><a class="mark" href="#http2_http2stream_sentinfoheaders" id="http2_http2stream_sentinfoheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.5.0</span>
 </div>
@@ -1357,7 +1399,7 @@ calling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>.
 </ul>
 <p>An array of objects containing the outbound informational (additional) headers
 sent for this <code>Http2Stream</code>.</p>
-<h4><code>http2stream.sentTrailers</code><span><a class="mark" href="#http2_http2stream_senttrailers" id="http2_http2stream_senttrailers">#</a></span></h4>
+<h5><code>http2stream.sentTrailers</code><span><a class="mark" href="#http2_http2stream_senttrailers" id="http2_http2stream_senttrailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.5.0</span>
 </div>
@@ -1365,7 +1407,7 @@ sent for this <code>Http2Stream</code>.</p>
 <li><a href="http2.html#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a></li>
 </ul>
 <p>An object containing the outbound trailers sent for this <code>HttpStream</code>.</p>
-<h4><code>http2stream.session</code><span><a class="mark" href="#http2_http2stream_session" id="http2_http2stream_session">#</a></span></h4>
+<h5><code>http2stream.session</code><span><a class="mark" href="#http2_http2stream_session" id="http2_http2stream_session">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1374,7 +1416,7 @@ sent for this <code>Http2Stream</code>.</p>
 </ul>
 <p>A reference to the <code>Http2Session</code> instance that owns this <code>Http2Stream</code>. The
 value will be <code>undefined</code> after the <code>Http2Stream</code> instance is destroyed.</p>
-<h4><code>http2stream.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_http2stream_settimeout_msecs_callback" id="http2_http2stream_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>http2stream.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_http2stream_settimeout_msecs_callback" id="http2_http2stream_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1383,13 +1425,13 @@ value will be <code>undefined</code> after the <code>Http2Stream</code> instance
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'http://example.org:8000'</span>);
-<span class="hljs-keyword">const</span> { NGHTTP2_CANCEL } = http2.constants;
-<span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'http://example.org:8000'</span>);
+<span class="hljs-keyword">const</span> { NGHTTP2_CANCEL } = http2.<span class="hljs-property">constants</span>;
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
 
 <span class="hljs-comment">// Cancel the stream if there's no activity after 5 seconds</span>
-req.setTimeout(<span class="hljs-number">5000</span>, <span class="hljs-function">() =></span> req.close(NGHTTP2_CANCEL));</code></pre>
-<h4><code>http2stream.state</code><span><a class="mark" href="#http2_http2stream_state" id="http2_http2stream_state">#</a></span></h4>
+req.<span class="hljs-built_in">setTimeout</span>(<span class="hljs-number">5000</span>, <span class="hljs-function">() =></span> req.<span class="hljs-title function_">close</span>(NGHTTP2_CANCEL));</code></pre>
+<h5><code>http2stream.state</code><span><a class="mark" href="#http2_http2stream_state" id="http2_http2stream_state">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1413,7 +1455,7 @@ instances that depend on this <code>Http2Stream</code> as specified using
 </li>
 </ul>
 <p>A current state of this <code>Http2Stream</code>.</p>
-<h4><code>http2stream.sendTrailers(headers)</code><span><a class="mark" href="#http2_http2stream_sendtrailers_headers" id="http2_http2stream_sendtrailers_headers">#</a></span></h4>
+<h5><code>http2stream.sendTrailers(headers)</code><span><a class="mark" href="#http2_http2stream_sendtrailers_headers" id="http2_http2stream_sendtrailers_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1427,17 +1469,17 @@ request or sending a response, the <code>options.waitForTrailers</code> option m
 in order to keep the <code>Http2Stream</code> open after the final <code>DATA</code> frame so that
 trailers can be sent.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond(<span class="hljs-literal">undefined</span>, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
-  stream.on(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
-    stream.sendTrailers({ <span class="hljs-attr">xyz</span>: <span class="hljs-string">'abc'</span> });
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>(<span class="hljs-literal">undefined</span>, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">sendTrailers</span>({ <span class="hljs-attr">xyz</span>: <span class="hljs-string">'abc'</span> });
   });
-  stream.end(<span class="hljs-string">'Hello World'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Hello World'</span>);
 });</code></pre>
 <p>The HTTP/1 specification forbids trailers from containing HTTP/2 pseudo-header
 fields (e.g. <code>':method'</code>, <code>':path'</code>, etc).</p>
-<h3>Class: <code>ClientHttp2Stream</code><span><a class="mark" href="#http2_class_clienthttp2stream" id="http2_class_clienthttp2stream">#</a></span></h3>
+<h4>Class: <code>ClientHttp2Stream</code><span><a class="mark" href="#http2_class_clienthttp2stream" id="http2_class_clienthttp2stream">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1448,14 +1490,14 @@ fields (e.g. <code>':method'</code>, <code>':path'</code>, etc).</p>
 used exclusively on HTTP/2 Clients. <code>Http2Stream</code> instances on the client
 provide events such as <code>'response'</code> and <code>'push'</code> that are only relevant on
 the client.</p>
-<h4>Event: <code>'continue'</code><span><a class="mark" href="#http2_event_continue" id="http2_event_continue">#</a></span></h4>
+<h5>Event: <code>'continue'</code><span><a class="mark" href="#http2_event_continue" id="http2_event_continue">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>Emitted when the server sends a <code>100 Continue</code> status, usually because
 the request contained <code>Expect: 100-continue</code>. This is an instruction that
 the client should send the request body.</p>
-<h4>Event: <code>'headers'</code><span><a class="mark" href="#http2_event_headers" id="http2_event_headers">#</a></span></h4>
+<h5>Event: <code>'headers'</code><span><a class="mark" href="#http2_event_headers" id="http2_event_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1463,20 +1505,20 @@ the client should send the request body.</p>
 for a stream, such as when a block of <code>1xx</code> informational headers is received.
 The listener callback is passed the <a href="#http2_headers_object">HTTP/2 Headers Object</a> and flags
 associated with the headers.</p>
-<pre><code class="language-js">stream.on(<span class="hljs-string">'headers'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers);
+<pre><code class="language-js">stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'headers'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers);
 });</code></pre>
-<h4>Event: <code>'push'</code><span><a class="mark" href="#http2_event_push" id="http2_event_push">#</a></span></h4>
+<h5>Event: <code>'push'</code><span><a class="mark" href="#http2_event_push" id="http2_event_push">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'push'</code> event is emitted when response headers for a Server Push stream
 are received. The listener callback is passed the <a href="#http2_headers_object">HTTP/2 Headers Object</a> and
 flags associated with the headers.</p>
-<pre><code class="language-js">stream.on(<span class="hljs-string">'push'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers);
+<pre><code class="language-js">stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'push'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers);
 });</code></pre>
-<h4>Event: <code>'response'</code><span><a class="mark" href="#http2_event_response" id="http2_event_response">#</a></span></h4>
+<h5>Event: <code>'response'</code><span><a class="mark" href="#http2_event_response" id="http2_event_response">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1485,12 +1527,12 @@ received for this stream from the connected HTTP/2 server. The listener is
 invoked with two arguments: an <code>Object</code> containing the received
 <a href="#http2_headers_object">HTTP/2 Headers Object</a>, and flags associated with the headers.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://localhost'</span>);
-<span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
-req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers[<span class="hljs-string">':status'</span>]);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://localhost'</span>);
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers, flags</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers[<span class="hljs-string">':status'</span>]);
 });</code></pre>
-<h3>Class: <code>ServerHttp2Stream</code><span><a class="mark" href="#http2_class_serverhttp2stream" id="http2_class_serverhttp2stream">#</a></span></h3>
+<h4>Class: <code>ServerHttp2Stream</code><span><a class="mark" href="#http2_class_serverhttp2stream" id="http2_class_serverhttp2stream">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1501,7 +1543,7 @@ req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">
 used exclusively on HTTP/2 Servers. <code>Http2Stream</code> instances on the server
 provide additional methods such as <code>http2stream.pushStream()</code> and
 <code>http2stream.respond()</code> that are only relevant on the server.</p>
-<h4><code>http2stream.additionalHeaders(headers)</code><span><a class="mark" href="#http2_http2stream_additionalheaders_headers" id="http2_http2stream_additionalheaders_headers">#</a></span></h4>
+<h5><code>http2stream.additionalHeaders(headers)</code><span><a class="mark" href="#http2_http2stream_additionalheaders_headers" id="http2_http2stream_additionalheaders_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1509,7 +1551,7 @@ provide additional methods such as <code>http2stream.pushStream()</code> and
 <li><code>headers</code> <a href="http2.html#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a></li>
 </ul>
 <p>Sends an additional informational <code>HEADERS</code> frame to the connected HTTP/2 peer.</p>
-<h4><code>http2stream.headersSent</code><span><a class="mark" href="#http2_http2stream_headerssent" id="http2_http2stream_headerssent">#</a></span></h4>
+<h5><code>http2stream.headersSent</code><span><a class="mark" href="#http2_http2stream_headerssent" id="http2_http2stream_headerssent">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1517,7 +1559,7 @@ provide additional methods such as <code>http2stream.pushStream()</code> and
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>True if headers were sent, false otherwise (read-only).</p>
-<h4><code>http2stream.pushAllowed</code><span><a class="mark" href="#http2_http2stream_pushallowed" id="http2_http2stream_pushallowed">#</a></span></h4>
+<h5><code>http2stream.pushAllowed</code><span><a class="mark" href="#http2_http2stream_pushallowed" id="http2_http2stream_pushallowed">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1528,7 +1570,7 @@ provide additional methods such as <code>http2stream.pushStream()</code> and
 client's most recent <code>SETTINGS</code> frame. Will be <code>true</code> if the remote peer
 accepts push streams, <code>false</code> otherwise. Settings are the same for every
 <code>Http2Stream</code> in the same <code>Http2Session</code>.</p>
-<h4><code>http2stream.pushStream(headers[, options], callback)</code><span><a class="mark" href="#http2_http2stream_pushstream_headers_options_callback" id="http2_http2stream_pushstream_headers_options_callback">#</a></span></h4>
+<h5><code>http2stream.pushStream(headers[, options], callback)</code><span><a class="mark" href="#http2_http2stream_pushstream_headers_options_callback" id="http2_http2stream_pushstream_headers_options_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1558,28 +1600,28 @@ initiated with.</li>
 instance created for the push stream passed as the second argument, or an
 <code>Error</code> passed as the first argument.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
-  stream.pushStream({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> }, <span class="hljs-function">(<span class="hljs-params">err, pushStream, headers</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
+  stream.<span class="hljs-title function_">pushStream</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> }, <span class="hljs-function">(<span class="hljs-params">err, pushStream, headers</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-    pushStream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
-    pushStream.end(<span class="hljs-string">'some pushed data'</span>);
+    pushStream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
+    pushStream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'some pushed data'</span>);
   });
-  stream.end(<span class="hljs-string">'some data'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'some data'</span>);
 });</code></pre>
 <p>Setting the weight of a push stream is not allowed in the <code>HEADERS</code> frame. Pass
 a <code>weight</code> value to <code>http2stream.priority</code> with the <code>silent</code> option set to
 <code>true</code> to enable server-side bandwidth balancing between concurrent streams.</p>
 <p>Calling <code>http2stream.pushStream()</code> from within a pushed stream is not permitted
 and will throw an error.</p>
-<h4><code>http2stream.respond([headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respond_headers_options" id="http2_http2stream_respond_headers_options">#</a></span></h4>
+<h5><code>http2stream.respond([headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respond_headers_options" id="http2_http2stream_respond_headers_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
-<td><p>Allow explicity setting date headers.</p></td></tr>
+<tr><td>v14.5.0</td>
+<td><p>Allow explicitly setting date headers.</p></td></tr>
 <tr><td>v8.4.0</td>
 <td><p><span>Added in: v8.4.0</span></p></td></tr>
 </tbody></table>
@@ -1597,10 +1639,10 @@ include payload data.</li>
 </li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
-  stream.end(<span class="hljs-string">'some data'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> });
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'some data'</span>);
 });</code></pre>
 <p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event
 will be emitted immediately after queuing the last chunk of payload data to be
@@ -1611,21 +1653,21 @@ close when the final <code>DATA</code> frame is transmitted. User code must call
 <code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the
 <code>Http2Stream</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> }, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
-  stream.on(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
-    stream.sendTrailers({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span> }, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">sendTrailers</span>({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
   });
-  stream.end(<span class="hljs-string">'some data'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'some data'</span>);
 });</code></pre>
-<h4><code>http2stream.respondWithFD(fd[, headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respondwithfd_fd_headers_options" id="http2_http2stream_respondwithfd_fd_headers_options">#</a></span></h4>
+<h5><code>http2stream.respondWithFD(fd[, headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respondwithfd_fd_headers_options" id="http2_http2stream_respondwithfd_fd_headers_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
-<td><p>Allow explicity setting date headers.</p></td></tr>
+<tr><td>v14.5.0</td>
+<td><p>Allow explicitly setting date headers.</p></td></tr>
 <tr><td>v12.12.0</td>
 <td><p>The <code>fd</code> option may now be a <code>FileHandle</code>.</p></td></tr>
 <tr><td>v10.0.0</td>
@@ -1657,18 +1699,18 @@ automatically.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'/some/file'</span>, <span class="hljs-string">'r'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-keyword">const</span> fd = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'/some/file'</span>, <span class="hljs-string">'r'</span>);
 
-  <span class="hljs-keyword">const</span> stat = fs.fstatSync(fd);
+  <span class="hljs-keyword">const</span> stat = fs.<span class="hljs-title function_">fstatSync</span>(fd);
   <span class="hljs-keyword">const</span> headers = {
-    <span class="hljs-string">'content-length'</span>: stat.size,
-    <span class="hljs-string">'last-modified'</span>: stat.mtime.toUTCString(),
+    <span class="hljs-string">'content-length'</span>: stat.<span class="hljs-property">size</span>,
+    <span class="hljs-string">'last-modified'</span>: stat.<span class="hljs-property">mtime</span>.<span class="hljs-title function_">toUTCString</span>(),
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   };
-  stream.respondWithFD(fd, headers);
-  stream.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> fs.closeSync(fd));
+  stream.<span class="hljs-title function_">respondWithFD</span>(fd, headers);
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> fs.<span class="hljs-title function_">closeSync</span>(fd));
 });</code></pre>
 <p>The optional <code>options.statCheck</code> function may be specified to give user code
 an opportunity to set additional content headers based on the <code>fs.Stat</code> details
@@ -1694,30 +1736,30 @@ close when the final <code>DATA</code> frame is transmitted. User code <em>must<
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'/some/file'</span>, <span class="hljs-string">'r'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-keyword">const</span> fd = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'/some/file'</span>, <span class="hljs-string">'r'</span>);
 
-  <span class="hljs-keyword">const</span> stat = fs.fstatSync(fd);
+  <span class="hljs-keyword">const</span> stat = fs.<span class="hljs-title function_">fstatSync</span>(fd);
   <span class="hljs-keyword">const</span> headers = {
-    <span class="hljs-string">'content-length'</span>: stat.size,
-    <span class="hljs-string">'last-modified'</span>: stat.mtime.toUTCString(),
+    <span class="hljs-string">'content-length'</span>: stat.<span class="hljs-property">size</span>,
+    <span class="hljs-string">'last-modified'</span>: stat.<span class="hljs-property">mtime</span>.<span class="hljs-title function_">toUTCString</span>(),
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   };
-  stream.respondWithFD(fd, headers, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
-  stream.on(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
-    stream.sendTrailers({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
+  stream.<span class="hljs-title function_">respondWithFD</span>(fd, headers, { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">sendTrailers</span>({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
   });
 
-  stream.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> fs.closeSync(fd));
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> fs.<span class="hljs-title function_">closeSync</span>(fd));
 });</code></pre>
-<h4><code>http2stream.respondWithFile(path[, headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respondwithfile_path_headers_options" id="http2_http2stream_respondwithfile_path_headers_options">#</a></span></h4>
+<h5><code>http2stream.respondWithFile(path[, headers[, options]])</code><span><a class="mark" href="#http2_http2stream_respondwithfile_path_headers_options" id="http2_http2stream_respondwithfile_path_headers_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
-<td><p>Allow explicity setting date headers.</p></td></tr>
+<tr><td>v14.5.0</td>
+<td><p>Allow explicitly setting date headers.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Any readable file, not necessarily a regular file, is supported now.</p></td></tr>
 <tr><td>v8.4.0</td>
@@ -1753,22 +1795,29 @@ code. If the <code>onError</code> callback is defined, then it will be called. O
 the stream will be destroyed.</p>
 <p>Example using a file path:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">statCheck</span>(<span class="hljs-params">stat, headers</span>) </span>{
-    headers[<span class="hljs-string">'last-modified'</span>] = stat.mtime.toUTCString();
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">statCheck</span>(<span class="hljs-params">stat, headers</span>) {
+    headers[<span class="hljs-string">'last-modified'</span>] = stat.<span class="hljs-property">mtime</span>.<span class="hljs-title function_">toUTCString</span>();
   }
 
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">onError</span>(<span class="hljs-params">err</span>) </span>{
-    <span class="hljs-keyword">if</span> (err.code === <span class="hljs-string">'ENOENT'</span>) {
-      stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">404</span> });
-    } <span class="hljs-keyword">else</span> {
-      stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">500</span> });
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">onError</span>(<span class="hljs-params">err</span>) {
+    <span class="hljs-comment">// stream.respond() can throw if the stream has been destroyed by</span>
+    <span class="hljs-comment">// the other side.</span>
+    <span class="hljs-keyword">try</span> {
+      <span class="hljs-keyword">if</span> (err.<span class="hljs-property">code</span> === <span class="hljs-string">'ENOENT'</span>) {
+        stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">404</span> });
+      } <span class="hljs-keyword">else</span> {
+        stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">500</span> });
+      }
+    } <span class="hljs-keyword">catch</span> (err) {
+      <span class="hljs-comment">// Perform actual error handling.</span>
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(err);
     }
-    stream.end();
+    stream.<span class="hljs-title function_">end</span>();
   }
 
-  stream.respondWithFile(<span class="hljs-string">'/some/file'</span>,
+  stream.<span class="hljs-title function_">respondWithFile</span>(<span class="hljs-string">'/some/file'</span>,
                          { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> },
                          { statCheck, onError });
 });</code></pre>
@@ -1777,14 +1826,14 @@ by returning <code>false</code>. For instance, a conditional request may check t
 results to determine if the file has been modified to return an appropriate
 <code>304</code> response:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">statCheck</span>(<span class="hljs-params">stat, headers</span>) </span>{
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">statCheck</span>(<span class="hljs-params">stat, headers</span>) {
     <span class="hljs-comment">// Check the stat here...</span>
-    stream.respond({ <span class="hljs-string">':status'</span>: <span class="hljs-number">304</span> });
+    stream.<span class="hljs-title function_">respond</span>({ <span class="hljs-string">':status'</span>: <span class="hljs-number">304</span> });
     <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>; <span class="hljs-comment">// Cancel the send operation</span>
   }
-  stream.respondWithFile(<span class="hljs-string">'/some/file'</span>,
+  stream.<span class="hljs-title function_">respondWithFile</span>(<span class="hljs-string">'/some/file'</span>,
                          { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> },
                          { statCheck });
 });</code></pre>
@@ -1804,16 +1853,16 @@ close when the final <code>DATA</code> frame is transmitted. User code must call
 <code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the
 <code>Http2Stream</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
-  stream.respondWithFile(<span class="hljs-string">'/some/file'</span>,
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream</span>) =></span> {
+  stream.<span class="hljs-title function_">respondWithFile</span>(<span class="hljs-string">'/some/file'</span>,
                          { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> },
                          { <span class="hljs-attr">waitForTrailers</span>: <span class="hljs-literal">true</span> });
-  stream.on(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
-    stream.sendTrailers({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'wantTrailers'</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">sendTrailers</span>({ <span class="hljs-attr">ABC</span>: <span class="hljs-string">'some value to send'</span> });
   });
 });</code></pre>
-<h3>Class: <code>Http2Server</code><span><a class="mark" href="#http2_class_http2server" id="http2_class_http2server">#</a></span></h3>
+<h4>Class: <code>Http2Server</code><span><a class="mark" href="#http2_class_http2server" id="http2_class_http2server">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1823,7 +1872,7 @@ server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function"
 <p>Instances of <code>Http2Server</code> are created using the <code>http2.createServer()</code>
 function. The <code>Http2Server</code> class is not exported directly by the <code>http2</code>
 module.</p>
-<h4>Event: <code>'checkContinue'</code><span><a class="mark" href="#http2_event_checkcontinue" id="http2_event_checkcontinue">#</a></span></h4>
+<h5>Event: <code>'checkContinue'</code><span><a class="mark" href="#http2_event_checkcontinue" id="http2_event_checkcontinue">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -1842,7 +1891,7 @@ HTTP response (e.g. 400 Bad Request) if the client should not continue to send
 the request body.</p>
 <p>When this event is emitted and handled, the <a href="#http2_event_request"><code>'request'</code></a> event will
 not be emitted.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#http2_event_connection" id="http2_event_connection">#</a></span></h3>
+<h5>Event: <code>'connection'</code><span><a class="mark" href="#http2_event_connection" id="http2_event_connection">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1854,7 +1903,7 @@ typically an object of type <a href="net.html#net_class_net_socket"><code>net.So
 access this event.</p>
 <p>This event can also be explicitly emitted by users to inject connections
 into the HTTP server. In that case, any <a href="stream.html#stream_class_stream_duplex"><code>Duplex</code></a> stream can be passed.</p>
-<h4>Event: <code>'request'</code><span><a class="mark" href="#http2_event_request" id="http2_event_request">#</a></span></h4>
+<h5>Event: <code>'request'</code><span><a class="mark" href="#http2_event_request" id="http2_event_request">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1864,54 +1913,68 @@ into the HTTP server. In that case, any <a href="stream.html#stream_class_stream
 </ul>
 <p>Emitted each time there is a request. There may be multiple requests
 per session. See the <a href="#http2_compatibility_api">Compatibility API</a>.</p>
-<h4>Event: <code>'session'</code><span><a class="mark" href="#http2_event_session" id="http2_event_session">#</a></span></h4>
+<h5>Event: <code>'session'</code><span><a class="mark" href="#http2_event_session" id="http2_event_session">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'session'</code> event is emitted when a new <code>Http2Session</code> is created by the
 <code>Http2Server</code>.</p>
-<h4>Event: <code>'sessionError'</code><span><a class="mark" href="#http2_event_sessionerror" id="http2_event_sessionerror">#</a></span></h4>
+<h5>Event: <code>'sessionError'</code><span><a class="mark" href="#http2_event_sessionerror" id="http2_event_sessionerror">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'sessionError'</code> event is emitted when an <code>'error'</code> event is emitted by
 an <code>Http2Session</code> object associated with the <code>Http2Server</code>.</p>
-<h4>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream_1" id="http2_event_stream_1">#</a></span></h4>
+<h5>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream_1" id="http2_event_stream_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
+<ul>
+<li><code>stream</code> <a href="http2.html#http2_class_http2stream" class="type">&#x3C;Http2Stream></a> A reference to the stream</li>
+<li><code>headers</code> <a href="http2.html#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a> An object describing the headers</li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The associated numeric flags</li>
+<li><code>rawHeaders</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> An array containing the raw header names followed by
+their respective values.</li>
+</ul>
 <p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by
 an <code>Http2Session</code> associated with the server.</p>
+<p>See also <a href="#http2_event_stream"><code>Http2Session</code>'s <code>'stream'</code> event</a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> {
   HTTP2_HEADER_METHOD,
   HTTP2_HEADER_PATH,
   HTTP2_HEADER_STATUS,
   HTTP2_HEADER_CONTENT_TYPE
-} = http2.constants;
+} = http2.<span class="hljs-property">constants</span>;
 
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
   <span class="hljs-keyword">const</span> method = headers[HTTP2_HEADER_METHOD];
   <span class="hljs-keyword">const</span> path = headers[HTTP2_HEADER_PATH];
   <span class="hljs-comment">// ...</span>
-  stream.respond({
+  stream.<span class="hljs-title function_">respond</span>({
     [HTTP2_HEADER_STATUS]: <span class="hljs-number">200</span>,
     [HTTP2_HEADER_CONTENT_TYPE]: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   });
-  stream.write(<span class="hljs-string">'hello '</span>);
-  stream.end(<span class="hljs-string">'world'</span>);
+  stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello '</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'world'</span>);
 });</code></pre>
-<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_2" id="http2_event_timeout_2">#</a></span></h4>
+<h5>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_2" id="http2_event_timeout_2">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.4.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v8.4.0</td>
+<td><p><span>Added in: v8.4.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for
 a given number of milliseconds set using <code>http2server.setTimeout()</code>.
-<strong>Default:</strong> 2 minutes.</p>
-<p>To change the default timeout use the <a href="cli.html#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout</code></a>
-flag.</p>
-<h4><code>server.close([callback])</code><span><a class="mark" href="#http2_server_close_callback" id="http2_server_close_callback">#</a></span></h4>
+<strong>Default:</strong> 0 (no timeout)</p>
+<h5><code>server.close([callback])</code><span><a class="mark" href="#http2_server_close_callback" id="http2_server_close_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1925,12 +1988,20 @@ all active sessions.</p>
 <p>If <code>callback</code> is provided, it is not invoked until all active sessions have been
 closed, although the server has already stopped allowing new sessions. See
 <a href="net.html#net_server_close_callback"><code>net.Server.close()</code></a> for more details.</p>
-<h4><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http2_server_settimeout_msecs_callback" id="http2_server_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http2_server_settimeout_msecs_callback" id="http2_server_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.4.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v8.4.0</td>
+<td><p><span>Added in: v8.4.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>msecs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>120000</code> (2 minutes)</li>
+<li><code>msecs</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> 0 (no timeout)</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li>Returns: <a href="http2.html#http2_class_http2server" class="type">&#x3C;Http2Server></a></li>
 </ul>
@@ -1938,11 +2009,39 @@ closed, although the server has already stopped allowing new sessions. See
 and sets a callback function that is called when there is no activity
 on the <code>Http2Server</code> after <code>msecs</code> milliseconds.</p>
 <p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>
-<p>In case of no callback function were assigned, a new <code>ERR_INVALID_CALLBACK</code>
+<p>In case if <code>callback</code> is not a function, a new <code>ERR_INVALID_CALLBACK</code>
 error will be thrown.</p>
-<p>To change the default timeout use the <a href="cli.html#cli_http_server_default_timeout_milliseconds"><code>--http-server-default-timeout</code></a>
-flag.</p>
-<h3>Class: <code>Http2SecureServer</code><span><a class="mark" href="#http2_class_http2secureserver" id="http2_class_http2secureserver">#</a></span></h3>
+<h5><code>server.timeout</code><span><a class="mark" href="#http2_server_timeout" id="http2_server_timeout">#</a></span></h5>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v8.4.0</td>
+<td><p><span>Added in: v8.4.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Timeout in milliseconds. <strong>Default:</strong> 0 (no timeout)</li>
+</ul>
+<p>The number of milliseconds of inactivity before a socket is presumed
+to have timed out.</p>
+<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>
+<p>The socket timeout logic is set up on connection, so changing this
+value only affects new connections to the server, not any existing connections.</p>
+<h5><code>server.updateSettings([settings])</code><span><a class="mark" href="#http2_server_updatesettings_settings" id="http2_server_updatesettings_settings">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>settings</code> <a href="http2.html#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a></li>
+</ul>
+<p>Used to update the server with the provided settings.</p>
+<p>Throws <code>ERR_HTTP2_INVALID_SETTING_VALUE</code> for invalid <code>settings</code> values.</p>
+<p>Throws <code>ERR_INVALID_ARG_TYPE</code> for invalid <code>settings</code> argument.</p>
+<h4>Class: <code>Http2SecureServer</code><span><a class="mark" href="#http2_class_http2secureserver" id="http2_class_http2secureserver">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1952,7 +2051,7 @@ flag.</p>
 <p>Instances of <code>Http2SecureServer</code> are created using the
 <code>http2.createSecureServer()</code> function. The <code>Http2SecureServer</code> class is not
 exported directly by the <code>http2</code> module.</p>
-<h4>Event: <code>'checkContinue'</code><span><a class="mark" href="#http2_event_checkcontinue_1" id="http2_event_checkcontinue_1">#</a></span></h4>
+<h5>Event: <code>'checkContinue'</code><span><a class="mark" href="#http2_event_checkcontinue_1" id="http2_event_checkcontinue_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -1971,7 +2070,7 @@ HTTP response (e.g. 400 Bad Request) if the client should not continue to send
 the request body.</p>
 <p>When this event is emitted and handled, the <a href="#http2_event_request"><code>'request'</code></a> event will
 not be emitted.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#http2_event_connection_1" id="http2_event_connection_1">#</a></span></h3>
+<h5>Event: <code>'connection'</code><span><a class="mark" href="#http2_event_connection_1" id="http2_event_connection_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1983,7 +2082,7 @@ handshake begins. <code>socket</code> is typically an object of type <a href="ne
 Usually users will not want to access this event.</p>
 <p>This event can also be explicitly emitted by users to inject connections
 into the HTTP server. In that case, any <a href="stream.html#stream_class_stream_duplex"><code>Duplex</code></a> stream can be passed.</p>
-<h4>Event: <code>'request'</code><span><a class="mark" href="#http2_event_request_1" id="http2_event_request_1">#</a></span></h4>
+<h5>Event: <code>'request'</code><span><a class="mark" href="#http2_event_request_1" id="http2_event_request_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -1993,54 +2092,62 @@ into the HTTP server. In that case, any <a href="stream.html#stream_class_stream
 </ul>
 <p>Emitted each time there is a request. There may be multiple requests
 per session. See the <a href="#http2_compatibility_api">Compatibility API</a>.</p>
-<h4>Event: <code>'session'</code><span><a class="mark" href="#http2_event_session_1" id="http2_event_session_1">#</a></span></h4>
+<h5>Event: <code>'session'</code><span><a class="mark" href="#http2_event_session_1" id="http2_event_session_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'session'</code> event is emitted when a new <code>Http2Session</code> is created by the
 <code>Http2SecureServer</code>.</p>
-<h4>Event: <code>'sessionError'</code><span><a class="mark" href="#http2_event_sessionerror_1" id="http2_event_sessionerror_1">#</a></span></h4>
+<h5>Event: <code>'sessionError'</code><span><a class="mark" href="#http2_event_sessionerror_1" id="http2_event_sessionerror_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'sessionError'</code> event is emitted when an <code>'error'</code> event is emitted by
 an <code>Http2Session</code> object associated with the <code>Http2SecureServer</code>.</p>
-<h4>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream_2" id="http2_event_stream_2">#</a></span></h4>
+<h5>Event: <code>'stream'</code><span><a class="mark" href="#http2_event_stream_2" id="http2_event_stream_2">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
+<ul>
+<li><code>stream</code> <a href="http2.html#http2_class_http2stream" class="type">&#x3C;Http2Stream></a> A reference to the stream</li>
+<li><code>headers</code> <a href="http2.html#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a> An object describing the headers</li>
+<li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The associated numeric flags</li>
+<li><code>rawHeaders</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> An array containing the raw header names followed by
+their respective values.</li>
+</ul>
 <p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by
 an <code>Http2Session</code> associated with the server.</p>
+<p>See also <a href="#http2_event_stream"><code>Http2Session</code>'s <code>'stream'</code> event</a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> {
   HTTP2_HEADER_METHOD,
   HTTP2_HEADER_PATH,
   HTTP2_HEADER_STATUS,
   HTTP2_HEADER_CONTENT_TYPE
-} = http2.constants;
+} = http2.<span class="hljs-property">constants</span>;
 
-<span class="hljs-keyword">const</span> options = getOptionsSomehow();
+<span class="hljs-keyword">const</span> options = <span class="hljs-title function_">getOptionsSomehow</span>();
 
-<span class="hljs-keyword">const</span> server = http2.createSecureServer(options);
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>(options);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers, flags</span>) =></span> {
   <span class="hljs-keyword">const</span> method = headers[HTTP2_HEADER_METHOD];
   <span class="hljs-keyword">const</span> path = headers[HTTP2_HEADER_PATH];
   <span class="hljs-comment">// ...</span>
-  stream.respond({
+  stream.<span class="hljs-title function_">respond</span>({
     [HTTP2_HEADER_STATUS]: <span class="hljs-number">200</span>,
     [HTTP2_HEADER_CONTENT_TYPE]: <span class="hljs-string">'text/plain; charset=utf-8'</span>
   });
-  stream.write(<span class="hljs-string">'hello '</span>);
-  stream.end(<span class="hljs-string">'world'</span>);
+  stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello '</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'world'</span>);
 });</code></pre>
-<h4>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_3" id="http2_event_timeout_3">#</a></span></h4>
+<h5>Event: <code>'timeout'</code><span><a class="mark" href="#http2_event_timeout_3" id="http2_event_timeout_3">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for
 a given number of milliseconds set using <code>http2secureServer.setTimeout()</code>.
 <strong>Default:</strong> 2 minutes.</p>
-<h4>Event: <code>'unknownProtocol'</code><span><a class="mark" href="#http2_event_unknownprotocol" id="http2_event_unknownprotocol">#</a></span></h4>
+<h5>Event: <code>'unknownProtocol'</code><span><a class="mark" href="#http2_event_unknownprotocol" id="http2_event_unknownprotocol">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2050,7 +2157,7 @@ receives the socket for handling. If no listener is registered for this event,
 the connection is terminated. A timeout may be specified using the
 <code>'unknownProtocolTimeout'</code> option passed to <a href="#http2_http2_createsecureserver_options_onrequesthandler"><code>http2.createSecureServer()</code></a>.
 See the <a href="#http2_compatibility_api">Compatibility API</a>.</p>
-<h4><code>server.close([callback])</code><span><a class="mark" href="#http2_server_close_callback_1" id="http2_server_close_callback_1">#</a></span></h4>
+<h5><code>server.close([callback])</code><span><a class="mark" href="#http2_server_close_callback_1" id="http2_server_close_callback_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2064,7 +2171,7 @@ all active sessions.</p>
 <p>If <code>callback</code> is provided, it is not invoked until all active sessions have been
 closed, although the server has already stopped allowing new sessions. See
 <a href="tls.html#tls_server_close_callback"><code>tls.Server.close()</code></a> for more details.</p>
-<h4><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http2_server_settimeout_msecs_callback_1" id="http2_server_settimeout_msecs_callback_1">#</a></span></h4>
+<h5><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#http2_server_settimeout_msecs_callback_1" id="http2_server_settimeout_msecs_callback_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2077,23 +2184,55 @@ closed, although the server has already stopped allowing new sessions. See
 and sets a callback function that is called when there is no activity
 on the <code>Http2SecureServer</code> after <code>msecs</code> milliseconds.</p>
 <p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>
-<p>In case of no callback function were assigned, a new <code>ERR_INVALID_CALLBACK</code>
+<p>In case if <code>callback</code> is not a function, a new <code>ERR_INVALID_CALLBACK</code>
 error will be thrown.</p>
-<h3><code>http2.createServer(options[, onRequestHandler])</code><span><a class="mark" href="#http2_http2_createserver_options_onrequesthandler" id="http2_http2_createserver_options_onrequesthandler">#</a></span></h3>
+<h5><code>server.timeout</code><span><a class="mark" href="#http2_server_timeout_1" id="http2_server_timeout_1">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.21.0</td>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v8.4.0</td>
+<td><p><span>Added in: v8.4.0</span></p></td></tr>
+</tbody></table>
+</details>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Timeout in milliseconds. <strong>Default:</strong> 0 (no timeout)</li>
+</ul>
+<p>The number of milliseconds of inactivity before a socket is presumed
+to have timed out.</p>
+<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>
+<p>The socket timeout logic is set up on connection, so changing this
+value only affects new connections to the server, not any existing connections.</p>
+<h5><code>server.updateSettings([settings])</code><span><a class="mark" href="#http2_server_updatesettings_settings_1" id="http2_server_updatesettings_settings_1">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><code>settings</code> <a href="http2.html#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a></li>
+</ul>
+<p>Used to update the server with the provided settings.</p>
+<p>Throws <code>ERR_HTTP2_INVALID_SETTING_VALUE</code> for invalid <code>settings</code> values.</p>
+<p>Throws <code>ERR_INVALID_ARG_TYPE</code> for invalid <code>settings</code> argument.</p>
+<h4><code>http2.createServer(options[, onRequestHandler])</code><span><a class="mark" href="#http2_http2_createserver_options_onrequesthandler" id="http2_http2_createserver_options_onrequesthandler">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.16.0</td>
 <td><p>Added <code>unknownProtocolTimeout</code> option with a default of 10000.</p></td></tr>
-<tr><td>v12.18.0</td>
-<td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.0.0</td>
+<td><p>The <code>PADDING_STRATEGY_CALLBACK</code> has been made equivalent to providing <code>PADDING_STRATEGY_ALIGNED</code> and <code>selectPadding</code> has been removed.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>Added <code>maxSessionRejectedStreams</code> option with a default of 100.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>Added <code>maxSessionInvalidFrames</code> option with a default of 1000.</p></td></tr>
 <tr><td>v12.4.0</td>
 <td><p>The <code>options</code> parameter now supports <code>net.createServer()</code> options.</p></td></tr>
+<tr><td>v14.4.0, v12.18.0, v10.21.0</td>
+<td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
 <tr><td>v9.6.0</td>
 <td><p>Added the <code>Http1IncomingMessage</code> and <code>Http1ServerResponse</code> option.</p></td></tr>
 <tr><td>v8.9.3</td>
@@ -2135,21 +2274,16 @@ and the stream being closed and destroyed.</li>
 padding to use for <code>HEADERS</code> and <code>DATA</code> frames. <strong>Default:</strong>
 <code>http2.constants.PADDING_STRATEGY_NONE</code>. Value may be one of:
 <ul>
-<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: Specifies that no padding is
-to be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: Specifies that the maximum
-amount of padding, as determined by the internal implementation, is to
-be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_CALLBACK</code>: Specifies that the user
-provided <code>options.selectPadding()</code> callback is to be used to determine
-the amount of padding.</li>
-<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Will <em>attempt</em> to apply
-enough padding to ensure that the total frame length, including the
-9-byte header, is a multiple of 8. For each frame, however, there is a
-maximum allowed number of padding bytes that is determined by current
-flow control state and settings. If this maximum is less than the
-calculated amount needed to ensure alignment, the maximum will be used
-and the total frame length will <em>not</em> necessarily be aligned at 8 bytes.</li>
+<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: No padding is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: The maximum amount of padding,
+determined by the internal implementation, is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Attempts to apply enough
+padding to ensure that the total frame length, including the 9-byte
+header, is a multiple of 8. For each frame, there is a maximum allowed
+number of padding bytes that is determined by current flow control state
+and settings. If this maximum is less than the calculated amount needed to
+ensure alignment, the maximum is used and the total frame length is not
+necessarily aligned at 8 bytes.</li>
 </ul>
 </li>
 <li><code>peerMaxConcurrentStreams</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the maximum number of concurrent
@@ -2165,9 +2299,6 @@ Each rejection is associated with an <code>NGHTTP2_ENHANCE_YOUR_CALM</code>
 error that should tell the peer to not open any more streams, continuing
 to open streams is therefore regarded as a sign of a misbehaving peer.
 <strong>Default:</strong> <code>100</code>.</li>
-<li><code>selectPadding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> When <code>options.paddingStrategy</code> is equal to
-<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, provides the callback function
-used to determine the padding. See <a href="#http2_using_options_selectpadding">Using <code>options.selectPadding()</code></a>.</li>
 <li><code>settings</code> <a href="http2.html#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a> The initial settings to send to the
 remote peer upon connection.</li>
 <li><code>Http1IncomingMessage</code> <a href="http.html#http_class_http_incomingmessage" class="type">&#x3C;http.IncomingMessage></a> Specifies the
@@ -2206,30 +2337,32 @@ with browser clients.</p>
 <span class="hljs-comment">// Since there are no browsers known that support</span>
 <span class="hljs-comment">// unencrypted HTTP/2, the use of `http2.createSecureServer()`</span>
 <span class="hljs-comment">// is necessary when communicating with browser clients.</span>
-<span class="hljs-keyword">const</span> server = http2.createServer();
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
-  stream.respond({
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
   });
-  stream.end(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
 });
 
-server.listen(<span class="hljs-number">80</span>);</code></pre>
-<h3><code>http2.createSecureServer(options[, onRequestHandler])</code><span><a class="mark" href="#http2_http2_createsecureserver_options_onrequesthandler" id="http2_http2_createsecureserver_options_onrequesthandler">#</a></span></h3>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">80</span>);</code></pre>
+<h4><code>http2.createSecureServer(options[, onRequestHandler])</code><span><a class="mark" href="#http2_http2_createsecureserver_options_onrequesthandler" id="http2_http2_createsecureserver_options_onrequesthandler">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.21.0</td>
+<tr><td>v14.16.0</td>
 <td><p>Added <code>unknownProtocolTimeout</code> option with a default of 10000.</p></td></tr>
-<tr><td>v12.18.0</td>
-<td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.0.0</td>
+<td><p>The <code>PADDING_STRATEGY_CALLBACK</code> has been made equivalent to providing <code>PADDING_STRATEGY_ALIGNED</code> and <code>selectPadding</code> has been removed.</p></td></tr>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>Added <code>maxSessionRejectedStreams</code> option with a default of 100.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.3.0, v12.16.0</td>
 <td><p>Added <code>maxSessionInvalidFrames</code> option with a default of 1000.</p></td></tr>
+<tr><td>v14.4.0, v12.18.0, v10.21.0</td>
+<td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
 <tr><td>v10.12.0</td>
 <td><p>Added the <code>origins</code> option to automatically send an <code>ORIGIN</code> frame on <code>Http2Session</code> startup.</p></td></tr>
 <tr><td>v8.9.3</td>
@@ -2275,21 +2408,16 @@ and the stream being closed and destroyed.</li>
 padding to use for <code>HEADERS</code> and <code>DATA</code> frames. <strong>Default:</strong>
 <code>http2.constants.PADDING_STRATEGY_NONE</code>. Value may be one of:
 <ul>
-<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: Specifies that no padding is
-to be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: Specifies that the maximum
-amount of padding, as determined by the internal implementation, is to
-be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_CALLBACK</code>: Specifies that the user
-provided <code>options.selectPadding()</code> callback is to be used to determine
-the amount of padding.</li>
-<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Will <em>attempt</em> to apply
-enough padding to ensure that the total frame length, including the
-9-byte header, is a multiple of 8. For each frame, however, there is a
-maximum allowed number of padding bytes that is determined by current
-flow control state and settings. If this maximum is less than the
-calculated amount needed to ensure alignment, the maximum will be used
-and the total frame length will <em>not</em> necessarily be aligned at 8 bytes.</li>
+<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: No padding is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: The maximum amount of padding,
+determined by the internal implementation, is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Attempts to apply enough
+padding to ensure that the total frame length, including the
+9-byte header, is a multiple of 8. For each frame, there is a maximum
+allowed number of padding bytes that is determined by current flow control
+state and settings. If this maximum is less than the calculated amount
+needed to ensure alignment, the maximum is used and the total frame length
+is not necessarily aligned at 8 bytes.</li>
 </ul>
 </li>
 <li><code>peerMaxConcurrentStreams</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the maximum number of concurrent
@@ -2305,9 +2433,6 @@ Each rejection is associated with an <code>NGHTTP2_ENHANCE_YOUR_CALM</code>
 error that should tell the peer to not open any more streams, continuing
 to open streams is therefore regarded as a sign of a misbehaving peer.
 <strong>Default:</strong> <code>100</code>.</li>
-<li><code>selectPadding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> When <code>options.paddingStrategy</code> is equal to
-<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, provides the callback function
-used to determine the padding. See <a href="#http2_using_options_selectpadding">Using <code>options.selectPadding()</code></a>.</li>
 <li><code>settings</code> <a href="http2.html#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a> The initial settings to send to the
 remote peer upon connection.</li>
 <li>...: Any <a href="tls.html#tls_tls_createserver_options_secureconnectionlistener"><code>tls.createServer()</code></a> options can be provided. For
@@ -2329,30 +2454,32 @@ instances.</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">const</span> options = {
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'server-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'server-cert.pem'</span>)
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-cert.pem'</span>)
 };
 
 <span class="hljs-comment">// Create a secure HTTP/2 server</span>
-<span class="hljs-keyword">const</span> server = http2.createSecureServer(options);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createSecureServer</span>(options);
 
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
-  stream.respond({
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+  stream.<span class="hljs-title function_">respond</span>({
     <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text/html; charset=utf-8'</span>,
     <span class="hljs-string">':status'</span>: <span class="hljs-number">200</span>
   });
-  stream.end(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
+  stream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'&#x3C;h1>Hello World&#x3C;/h1>'</span>);
 });
 
-server.listen(<span class="hljs-number">80</span>);</code></pre>
-<h3><code>http2.connect(authority[, options][, listener])</code><span><a class="mark" href="#http2_http2_connect_authority_options_listener" id="http2_http2_connect_authority_options_listener">#</a></span></h3>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">80</span>);</code></pre>
+<h4><code>http2.connect(authority[, options][, listener])</code><span><a class="mark" href="#http2_http2_connect_authority_options_listener" id="http2_http2_connect_authority_options_listener">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.21.0</td>
+<tr><td>v14.16.0</td>
 <td><p>Added <code>unknownProtocolTimeout</code> option with a default of 10000.</p></td></tr>
-<tr><td>v12.18.0</td>
+<tr><td>v13.0.0</td>
+<td><p>The <code>PADDING_STRATEGY_CALLBACK</code> has been made equivalent to providing <code>PADDING_STRATEGY_ALIGNED</code> and <code>selectPadding</code> has been removed.</p></td></tr>
+<tr><td>v14.4.0, v12.18.0, v10.21.0</td>
 <td><p>Added <code>maxSettings</code> option with a default of 32.</p></td></tr>
 <tr><td>v8.9.3</td>
 <td><p>Added the <code>maxOutstandingPings</code> option with a default limit of 10.</p></td></tr>
@@ -2394,7 +2521,7 @@ unacknowledged pings. <strong>Default:</strong> <code>10</code>.</li>
 streams the client will accept at any given time. Once the current number of
 currently reserved push streams exceeds reaches this limit, new push streams
 sent by the server will be automatically rejected. The minimum allowed value
-is 0. The maximum allowed value is 2<sup>32</sup>-1. A negative value sets
+is 0. The maximum allowed value is 22<sup>32</sup>-1. A negative value sets
 this option to the maximum allowed value. <strong>Default:</strong> <code>200</code>.</li>
 <li><code>maxSendHeaderBlockLength</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the maximum allowed size for a
 serialized, compressed block of headers. Attempts to send headers that
@@ -2404,30 +2531,22 @@ and the stream being closed and destroyed.</li>
 padding to use for <code>HEADERS</code> and <code>DATA</code> frames. <strong>Default:</strong>
 <code>http2.constants.PADDING_STRATEGY_NONE</code>. Value may be one of:
 <ul>
-<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: Specifies that no padding is
-to be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: Specifies that the maximum
-amount of padding, as determined by the internal implementation, is to
-be applied.</li>
-<li><code>http2.constants.PADDING_STRATEGY_CALLBACK</code>: Specifies that the user
-provided <code>options.selectPadding()</code> callback is to be used to determine
-the amount of padding.</li>
-<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Will <em>attempt</em> to apply
-enough padding to ensure that the total frame length, including the
-9-byte header, is a multiple of 8. For each frame, however, there is a
-maximum allowed number of padding bytes that is determined by current
-flow control state and settings. If this maximum is less than the
-calculated amount needed to ensure alignment, the maximum will be used
-and the total frame length will <em>not</em> necessarily be aligned at 8 bytes.</li>
+<li><code>http2.constants.PADDING_STRATEGY_NONE</code>: No padding is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_MAX</code>: The maximum amount of padding,
+determined by the internal implementation, is applied.</li>
+<li><code>http2.constants.PADDING_STRATEGY_ALIGNED</code>: Attempts to apply enough
+padding to ensure that the total frame length, including the
+9-byte header, is a multiple of 8. For each frame, there is a maximum
+allowed number of padding bytes that is determined by current flow control
+state and settings. If this maximum is less than the calculated amount
+needed to ensure alignment, the maximum is used and the total frame length
+is not necessarily aligned at 8 bytes.</li>
 </ul>
 </li>
 <li><code>peerMaxConcurrentStreams</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Sets the maximum number of concurrent
 streams for the remote peer as if a <code>SETTINGS</code> frame had been received. Will
 be overridden if the remote peer sets its own value for
 <code>maxConcurrentStreams</code>. <strong>Default:</strong> <code>100</code>.</li>
-<li><code>selectPadding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> When <code>options.paddingStrategy</code> is equal to
-<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, provides the callback function
-used to determine the padding. See <a href="#http2_using_options_selectpadding">Using <code>options.selectPadding()</code></a>.</li>
 <li><code>protocol</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The protocol to connect with, if not set in the
 <code>authority</code>. Value may be either <code>'http:'</code> or <code>'https:'</code>. <strong>Default:</strong>
 <code>'https:'</code></li>
@@ -2449,17 +2568,16 @@ the socket has not been destroyed by that time the server will destroy it.
 </ul>
 <p>Returns a <code>ClientHttp2Session</code> instance.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'https://localhost:1234'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'https://localhost:1234'</span>);
 
 <span class="hljs-comment">/* Use the client */</span>
 
-client.close();</code></pre>
-<h3><code>http2.constants</code><span><a class="mark" href="#http2_http2_constants" id="http2_http2_constants">#</a></span></h3>
+client.<span class="hljs-title function_">close</span>();</code></pre>
+<h4><code>http2.constants</code><span><a class="mark" href="#http2_http2_constants" id="http2_http2_constants">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
-<h4>Error codes for <code>RST_STREAM</code> and <code>GOAWAY</code><span><a class="mark" href="#http2_error_codes_for_rst_stream_and_goaway" id="http2_error_codes_for_rst_stream_and_goaway">#</a></span></h4>
-<p><a id="error_codes"></a></p>
+<h5>Error codes for <code>RST_STREAM</code> and <code>GOAWAY</code><span><a class="mark" href="#http2_error_codes_for_rst_stream_and_goaway" id="http2_error_codes_for_rst_stream_and_goaway">#</a></span></h5>
 
 
 
@@ -2543,7 +2661,7 @@ client.close();</code></pre>
 <table><thead><tr><th>Value</th><th>Name</th><th>Constant</th></tr></thead><tbody><tr><td><code>0x00</code></td><td>No Error</td><td><code>http2.constants.NGHTTP2_NO_ERROR</code></td></tr><tr><td><code>0x01</code></td><td>Protocol Error</td><td><code>http2.constants.NGHTTP2_PROTOCOL_ERROR</code></td></tr><tr><td><code>0x02</code></td><td>Internal Error</td><td><code>http2.constants.NGHTTP2_INTERNAL_ERROR</code></td></tr><tr><td><code>0x03</code></td><td>Flow Control Error</td><td><code>http2.constants.NGHTTP2_FLOW_CONTROL_ERROR</code></td></tr><tr><td><code>0x04</code></td><td>Settings Timeout</td><td><code>http2.constants.NGHTTP2_SETTINGS_TIMEOUT</code></td></tr><tr><td><code>0x05</code></td><td>Stream Closed</td><td><code>http2.constants.NGHTTP2_STREAM_CLOSED</code></td></tr><tr><td><code>0x06</code></td><td>Frame Size Error</td><td><code>http2.constants.NGHTTP2_FRAME_SIZE_ERROR</code></td></tr><tr><td><code>0x07</code></td><td>Refused Stream</td><td><code>http2.constants.NGHTTP2_REFUSED_STREAM</code></td></tr><tr><td><code>0x08</code></td><td>Cancel</td><td><code>http2.constants.NGHTTP2_CANCEL</code></td></tr><tr><td><code>0x09</code></td><td>Compression Error</td><td><code>http2.constants.NGHTTP2_COMPRESSION_ERROR</code></td></tr><tr><td><code>0x0a</code></td><td>Connect Error</td><td><code>http2.constants.NGHTTP2_CONNECT_ERROR</code></td></tr><tr><td><code>0x0b</code></td><td>Enhance Your Calm</td><td><code>http2.constants.NGHTTP2_ENHANCE_YOUR_CALM</code></td></tr><tr><td><code>0x0c</code></td><td>Inadequate Security</td><td><code>http2.constants.NGHTTP2_INADEQUATE_SECURITY</code></td></tr><tr><td><code>0x0d</code></td><td>HTTP/1.1 Required</td><td><code>http2.constants.NGHTTP2_HTTP_1_1_REQUIRED</code></td></tr></tbody></table>
 <p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for
 a given number of milliseconds set using <code>http2server.setTimeout()</code>.</p>
-<h3><code>http2.getDefaultSettings()</code><span><a class="mark" href="#http2_http2_getdefaultsettings" id="http2_http2_getdefaultsettings">#</a></span></h3>
+<h4><code>http2.getDefaultSettings()</code><span><a class="mark" href="#http2_http2_getdefaultsettings" id="http2_http2_getdefaultsettings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2553,7 +2671,7 @@ a given number of milliseconds set using <code>http2server.setTimeout()</code>.<
 <p>Returns an object containing the default settings for an <code>Http2Session</code>
 instance. This method returns a new object instance every time it is called
 so instances returned may be safely modified for use.</p>
-<h3><code>http2.getPackedSettings([settings])</code><span><a class="mark" href="#http2_http2_getpackedsettings_settings" id="http2_http2_getpackedsettings_settings">#</a></span></h3>
+<h4><code>http2.getPackedSettings([settings])</code><span><a class="mark" href="#http2_http2_getpackedsettings_settings" id="http2_http2_getpackedsettings_settings">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2566,21 +2684,31 @@ HTTP/2 settings as specified in the <a href="https://tools.ietf.org/html/rfc7540
 for use with the <code>HTTP2-Settings</code> header field.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
-<span class="hljs-keyword">const</span> packed = http2.getPackedSettings({ <span class="hljs-attr">enablePush</span>: <span class="hljs-literal">false</span> });
+<span class="hljs-keyword">const</span> packed = http2.<span class="hljs-title function_">getPackedSettings</span>({ <span class="hljs-attr">enablePush</span>: <span class="hljs-literal">false</span> });
 
-<span class="hljs-built_in">console</span>.log(packed.toString(<span class="hljs-string">'base64'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(packed.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'base64'</span>));
 <span class="hljs-comment">// Prints: AAIAAAAA</span></code></pre>
-<h3><code>http2.getUnpackedSettings(buf)</code><span><a class="mark" href="#http2_http2_getunpackedsettings_buf" id="http2_http2_getunpackedsettings_buf">#</a></span></h3>
+<h4><code>http2.getUnpackedSettings(buf)</code><span><a class="mark" href="#http2_http2_getunpackedsettings_buf" id="http2_http2_getunpackedsettings_buf">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <ul>
-<li><code>buf</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a> The packed settings.</li>
+<li><code>buf</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> The packed settings.</li>
 <li>Returns: <a href="http2.html#http2_settings_object" class="type">&#x3C;HTTP/2 Settings Object></a></li>
 </ul>
 <p>Returns a <a href="#http2_settings_object">HTTP/2 Settings Object</a> containing the deserialized settings from
 the given <code>Buffer</code> as generated by <code>http2.getPackedSettings()</code>.</p>
-<h3>Headers object<span><a class="mark" href="#http2_headers_object" id="http2_headers_object">#</a></span></h3>
+<h4><code>http2.sensitiveHeaders</code><span><a class="mark" href="#http2_http2_sensitiveheaders" id="http2_http2_sensitiveheaders">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a></li>
+</ul>
+<p>This symbol can be set as a property on the HTTP/2 headers object with an array
+value in order to provide a list of headers considered sensitive.
+See <a href="#http2_sensitive_headers">Sensitive headers</a> for more details.</p>
+<h4>Headers object<span><a class="mark" href="#http2_headers_object" id="http2_headers_object">#</a></span></h4>
 <p>Headers are represented as own-properties on JavaScript objects. The property
 keys will be serialized to lower-case. Property values should be strings (if
 they are not they will be coerced to strings) or an <code>Array</code> of strings (in order
@@ -2591,7 +2719,7 @@ to send more than one value per header field).</p>
   <span class="hljs-string">'ABC'</span>: [<span class="hljs-string">'has'</span>, <span class="hljs-string">'more'</span>, <span class="hljs-string">'than'</span>, <span class="hljs-string">'one'</span>, <span class="hljs-string">'value'</span>]
 };
 
-stream.respond(headers);</code></pre>
+stream.<span class="hljs-title function_">respond</span>(headers);</code></pre>
 <p>Header objects passed to callback functions will have a <code>null</code> prototype. This
 means that normal JavaScript object methods such as
 <code>Object.prototype.toString()</code> and <code>Object.prototype.hasOwnProperty()</code> will
@@ -2614,12 +2742,31 @@ discarded.</li>
 <li>For all other headers, the values are joined together with ', '.</li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer();
-server.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers[<span class="hljs-string">':path'</span>]);
-  <span class="hljs-built_in">console</span>.log(headers.ABC);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers[<span class="hljs-string">':path'</span>]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers.<span class="hljs-property">ABC</span>);
 });</code></pre>
-<h3>Settings object<span><a class="mark" href="#http2_settings_object" id="http2_settings_object">#</a></span></h3>
+<h5>Sensitive headers<span><a class="mark" href="#http2_sensitive_headers" id="http2_sensitive_headers">#</a></span></h5>
+<p>HTTP2 headers can be marked as sensitive, which means that the HTTP/2
+header compression algorithm will never index them. This can make sense for
+header values with low entropy and that may be considered valuable to an
+attacker, for example <code>Cookie</code> or <code>Authorization</code>. To achieve this, add
+the header name to the <code>[http2.sensitiveHeaders]</code> property as an array:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> headers = {
+  <span class="hljs-string">':status'</span>: <span class="hljs-string">'200'</span>,
+  <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'text-plain'</span>,
+  <span class="hljs-string">'cookie'</span>: <span class="hljs-string">'some-cookie'</span>,
+  <span class="hljs-string">'other-sensitive-header'</span>: <span class="hljs-string">'very secret data'</span>,
+  [http2.<span class="hljs-property">sensitiveHeaders</span>]: [<span class="hljs-string">'cookie'</span>, <span class="hljs-string">'other-sensitive-header'</span>]
+};
+
+stream.<span class="hljs-title function_">respond</span>(headers);</code></pre>
+<p>For some headers, such as <code>Authorization</code> and short <code>Cookie</code> headers,
+this flag is set automatically.</p>
+<p>This property is also set for received headers. It will contain the names of
+all headers marked as sensitive, including ones marked that way automatically.</p>
+<h4>Settings object<span><a class="mark" href="#http2_settings_object" id="http2_settings_object">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2643,7 +2790,7 @@ properties.</p>
 <ul>
 <li><code>headerTableSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the maximum number of bytes used for
 header compression. The minimum allowed value is 0. The maximum allowed value
-is 2<sup>32</sup>-1. <strong>Default:</strong> <code>4096</code>.</li>
+is 22<sup>32</sup>-1. <strong>Default:</strong> <code>4096</code>.</li>
 <li><code>enablePush</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Specifies <code>true</code> if HTTP/2 Push Streams are to be
 permitted on the <code>Http2Session</code> instances. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>initialWindowSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the <em>sender's</em> initial window size in
@@ -2651,7 +2798,7 @@ bytes for stream-level flow control. The minimum allowed value is 0. The
 maximum allowed value is 2<sup>32</sup>-1. <strong>Default:</strong> <code>65535</code>.</li>
 <li><code>maxFrameSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the size in bytes of the largest frame
 payload. The minimum allowed value is 16,384. The maximum allowed value is
-2<sup>24</sup>-1. <strong>Default:</strong> <code>16384</code>.</li>
+22<sup>24</sup>-1. <strong>Default:</strong> <code>16384</code>.</li>
 <li><code>maxConcurrentStreams</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the maximum number of concurrent
 streams permitted on an <code>Http2Session</code>. There is no default value which
 implies, at least theoretically, 2<sup>32</sup>-1 streams may be open
@@ -2660,7 +2807,7 @@ is 0. The maximum allowed value is 2<sup>32</sup>-1. <strong>Default:</strong>
 <code>4294967295</code>.</li>
 <li><code>maxHeaderListSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the maximum size (uncompressed octets)
 of header list that will be accepted. The minimum allowed value is 0. The
-maximum allowed value is 2<sup>32</sup>-1. <strong>Default:</strong> <code>65535</code>.</li>
+maximum allowed value is 22<sup>32</sup>-1. <strong>Default:</strong> <code>65535</code>.</li>
 <li><code>maxHeaderSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Alias for <code>maxHeaderListSize</code>.</li>
 <li><code>enableConnectProtocol</code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Specifies <code>true</code> if the "Extended Connect
 Protocol" defined by <a href="https://tools.ietf.org/html/rfc8441">RFC 8441</a> is to be enabled. This setting is only
@@ -2669,24 +2816,7 @@ has been enabled for a given <code>Http2Session</code>, it cannot be disabled.
 <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 <p>All additional properties on the settings object are ignored.</p>
-<h3>Using <code>options.selectPadding()</code><span><a class="mark" href="#http2_using_options_selectpadding" id="http2_using_options_selectpadding">#</a></span></h3>
-<p>When <code>options.paddingStrategy</code> is equal to
-<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, the HTTP/2 implementation will
-consult the <code>options.selectPadding()</code> callback function, if provided, to
-determine the specific amount of padding to use per <code>HEADERS</code> and <code>DATA</code> frame.</p>
-<p>The <code>options.selectPadding()</code> function receives two numeric arguments,
-<code>frameLen</code> and <code>maxFrameLen</code> and must return a number <code>N</code> such that
-<code>frameLen &#x3C;= N &#x3C;= maxFrameLen</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer({
-  <span class="hljs-attr">paddingStrategy</span>: http2.constants.PADDING_STRATEGY_CALLBACK,
-  selectPadding(frameLen, maxFrameLen) {
-    <span class="hljs-keyword">return</span> maxFrameLen;
-  }
-});</code></pre>
-<p>The <code>options.selectPadding()</code> function is invoked once for <em>every</em> <code>HEADERS</code> and
-<code>DATA</code> frame. This has a definite noticeable impact on performance.</p>
-<h3>Error handling<span><a class="mark" href="#http2_error_handling" id="http2_error_handling">#</a></span></h3>
+<h4>Error handling<span><a class="mark" href="#http2_error_handling" id="http2_error_handling">#</a></span></h4>
 <p>There are several types of error conditions that may arise when using the
 <code>http2</code> module:</p>
 <p>Validation errors occur when an incorrect argument, option, or setting value is
@@ -2702,7 +2832,7 @@ reported via an <code>'error'</code> event on the <code>Http2Session</code> or H
 These will be reported using either a synchronous <code>throw</code> or via an <code>'error'</code>
 event on the <code>Http2Stream</code>, <code>Http2Session</code> or HTTP/2 Server objects, depending
 on where and when the error occurs.</p>
-<h3>Invalid character handling in header names and values<span><a class="mark" href="#http2_invalid_character_handling_in_header_names_and_values" id="http2_invalid_character_handling_in_header_names_and_values">#</a></span></h3>
+<h4>Invalid character handling in header names and values<span><a class="mark" href="#http2_invalid_character_handling_in_header_names_and_values" id="http2_invalid_character_handling_in_header_names_and_values">#</a></span></h4>
 <p>The HTTP/2 implementation applies stricter handling of invalid characters in
 HTTP header names and values than the HTTP/1 implementation.</p>
 <p>Header field names are <em>case-insensitive</em> and are transmitted over the wire
@@ -2717,85 +2847,85 @@ stream to be closed with a protocol error being reported.</p>
 <p>Header field values are handled with more leniency but <em>should</em> not contain
 new-line or carriage return characters and <em>should</em> be limited to US-ASCII
 characters, per the requirements of the HTTP specification.</p>
-<h3>Push streams on the client<span><a class="mark" href="#http2_push_streams_on_the_client" id="http2_push_streams_on_the_client">#</a></span></h3>
+<h4>Push streams on the client<span><a class="mark" href="#http2_push_streams_on_the_client" id="http2_push_streams_on_the_client">#</a></span></h4>
 <p>To receive pushed streams on the client, set a listener for the <code>'stream'</code>
 event on the <code>ClientHttp2Session</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'http://localhost'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'http://localhost'</span>);
 
-client.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">pushedStream, requestHeaders</span>) =></span> {
-  pushedStream.on(<span class="hljs-string">'push'</span>, <span class="hljs-function">(<span class="hljs-params">responseHeaders</span>) =></span> {
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">pushedStream, requestHeaders</span>) =></span> {
+  pushedStream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'push'</span>, <span class="hljs-function">(<span class="hljs-params">responseHeaders</span>) =></span> {
     <span class="hljs-comment">// Process response headers</span>
   });
-  pushedStream.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-comment">/* handle pushed data */</span> });
+  pushedStream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-comment">/* handle pushed data */</span> });
 });
 
-<span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });</code></pre>
-<h3>Supporting the <code>CONNECT</code> method<span><a class="mark" href="#http2_supporting_the_connect_method" id="http2_supporting_the_connect_method">#</a></span></h3>
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':path'</span>: <span class="hljs-string">'/'</span> });</code></pre>
+<h4>Supporting the <code>CONNECT</code> method<span><a class="mark" href="#http2_supporting_the_connect_method" id="http2_supporting_the_connect_method">#</a></span></h4>
 <p>The <code>CONNECT</code> method is used to allow an HTTP/2 server to be used as a proxy
 for TCP/IP connections.</p>
 <p>A simple TCP Server:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
 
-<span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+<span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
   <span class="hljs-keyword">let</span> name = <span class="hljs-string">''</span>;
-  socket.setEncoding(<span class="hljs-string">'utf8'</span>);
-  socket.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> name += chunk);
-  socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> socket.end(<span class="hljs-string">`hello <span class="hljs-subst">${name}</span>`</span>));
+  socket.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> name += chunk);
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">`hello <span class="hljs-subst">${name}</span>`</span>));
 });
 
-server.listen(<span class="hljs-number">8000</span>);</code></pre>
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
 <p>An HTTP/2 CONNECT proxy:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> { NGHTTP2_REFUSED_STREAM } = http2.constants;
+<span class="hljs-keyword">const</span> { NGHTTP2_REFUSED_STREAM } = http2.<span class="hljs-property">constants</span>;
 <span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
 
-<span class="hljs-keyword">const</span> proxy = http2.createServer();
-proxy.on(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
+<span class="hljs-keyword">const</span> proxy = http2.<span class="hljs-title function_">createServer</span>();
+proxy.<span class="hljs-title function_">on</span>(<span class="hljs-string">'stream'</span>, <span class="hljs-function">(<span class="hljs-params">stream, headers</span>) =></span> {
   <span class="hljs-keyword">if</span> (headers[<span class="hljs-string">':method'</span>] !== <span class="hljs-string">'CONNECT'</span>) {
     <span class="hljs-comment">// Only accept CONNECT requests</span>
-    stream.close(NGHTTP2_REFUSED_STREAM);
+    stream.<span class="hljs-title function_">close</span>(NGHTTP2_REFUSED_STREAM);
     <span class="hljs-keyword">return</span>;
   }
-  <span class="hljs-keyword">const</span> auth = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">`tcp://<span class="hljs-subst">${headers[<span class="hljs-string">':authority'</span>]}</span>`</span>);
+  <span class="hljs-keyword">const</span> auth = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">`tcp://<span class="hljs-subst">${headers[<span class="hljs-string">':authority'</span>]}</span>`</span>);
   <span class="hljs-comment">// It's a very good idea to verify that hostname and port are</span>
   <span class="hljs-comment">// things this proxy should be connecting to.</span>
-  <span class="hljs-keyword">const</span> socket = net.connect(auth.port, auth.hostname, <span class="hljs-function">() =></span> {
-    stream.respond();
-    socket.pipe(stream);
-    stream.pipe(socket);
+  <span class="hljs-keyword">const</span> socket = net.<span class="hljs-title function_">connect</span>(auth.<span class="hljs-property">port</span>, auth.<span class="hljs-property">hostname</span>, <span class="hljs-function">() =></span> {
+    stream.<span class="hljs-title function_">respond</span>();
+    socket.<span class="hljs-title function_">pipe</span>(stream);
+    stream.<span class="hljs-title function_">pipe</span>(socket);
   });
-  socket.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
-    stream.close(http2.constants.NGHTTP2_CONNECT_ERROR);
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
+    stream.<span class="hljs-title function_">close</span>(http2.<span class="hljs-property">constants</span>.<span class="hljs-property">NGHTTP2_CONNECT_ERROR</span>);
   });
 });
 
-proxy.listen(<span class="hljs-number">8001</span>);</code></pre>
+proxy.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8001</span>);</code></pre>
 <p>An HTTP/2 CONNECT client:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'http://localhost:8001'</span>);
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'http://localhost:8001'</span>);
 
 <span class="hljs-comment">// Must not specify the ':path' and ':scheme' headers</span>
 <span class="hljs-comment">// for CONNECT requests or an error will be thrown.</span>
-<span class="hljs-keyword">const</span> req = client.request({
+<span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({
   <span class="hljs-string">':method'</span>: <span class="hljs-string">'CONNECT'</span>,
   <span class="hljs-string">':authority'</span>: <span class="hljs-string">`localhost:<span class="hljs-subst">${port}</span>`</span>
 });
 
-req.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(headers[http2.constants.HTTP2_HEADER_STATUS]);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">headers</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(headers[http2.<span class="hljs-property">constants</span>.<span class="hljs-property">HTTP2_HEADER_STATUS</span>]);
 });
 <span class="hljs-keyword">let</span> data = <span class="hljs-string">''</span>;
-req.setEncoding(<span class="hljs-string">'utf8'</span>);
-req.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> data += chunk);
-req.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The server says: <span class="hljs-subst">${data}</span>`</span>);
-  client.close();
+req.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> data += chunk);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The server says: <span class="hljs-subst">${data}</span>`</span>);
+  client.<span class="hljs-title function_">close</span>();
 });
-req.end(<span class="hljs-string">'Jane'</span>);</code></pre>
-<h3>The extended <code>CONNECT</code> protocol<span><a class="mark" href="#http2_the_extended_connect_protocol" id="http2_the_extended_connect_protocol">#</a></span></h3>
+req.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Jane'</span>);</code></pre>
+<h4>The extended <code>CONNECT</code> protocol<span><a class="mark" href="#http2_the_extended_connect_protocol" id="http2_the_extended_connect_protocol">#</a></span></h4>
 <p><a href="https://tools.ietf.org/html/rfc8441">RFC 8441</a> defines an "Extended CONNECT Protocol" extension to HTTP/2 that
 may be used to bootstrap the use of an <code>Http2Stream</code> using the <code>CONNECT</code>
 method as a tunnel for other communication protocols (such as WebSockets).</p>
@@ -2803,19 +2933,19 @@ method as a tunnel for other communication protocols (such as WebSockets).</p>
 the <code>enableConnectProtocol</code> setting:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> settings = { <span class="hljs-attr">enableConnectProtocol</span>: <span class="hljs-literal">true</span> };
-<span class="hljs-keyword">const</span> server = http2.createServer({ settings });</code></pre>
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>({ settings });</code></pre>
 <p>Once the client receives the <code>SETTINGS</code> frame from the server indicating that
 the extended CONNECT may be used, it may send <code>CONNECT</code> requests that use the
 <code>':protocol'</code> HTTP/2 pseudo-header:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> client = http2.connect(<span class="hljs-string">'http://localhost:8080'</span>);
-client.on(<span class="hljs-string">'remoteSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
-  <span class="hljs-keyword">if</span> (settings.enableConnectProtocol) {
-    <span class="hljs-keyword">const</span> req = client.request({ <span class="hljs-string">':method'</span>: <span class="hljs-string">'CONNECT'</span>, <span class="hljs-string">':protocol'</span>: <span class="hljs-string">'foo'</span> });
+<span class="hljs-keyword">const</span> client = http2.<span class="hljs-title function_">connect</span>(<span class="hljs-string">'http://localhost:8080'</span>);
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'remoteSettings'</span>, <span class="hljs-function">(<span class="hljs-params">settings</span>) =></span> {
+  <span class="hljs-keyword">if</span> (settings.<span class="hljs-property">enableConnectProtocol</span>) {
+    <span class="hljs-keyword">const</span> req = client.<span class="hljs-title function_">request</span>({ <span class="hljs-string">':method'</span>: <span class="hljs-string">'CONNECT'</span>, <span class="hljs-string">':protocol'</span>: <span class="hljs-string">'foo'</span> });
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h2>Compatibility API<span><a class="mark" href="#http2_compatibility_api" id="http2_compatibility_api">#</a></span></h2>
+</section><section><h3>Compatibility API<span><a class="mark" href="#http2_compatibility_api" id="http2_compatibility_api">#</a></span></h3>
 <p>The Compatibility API has the goal of providing a similar developer experience
 of HTTP/1 when using HTTP/2, making it possible to develop applications
 that support both <a href="http.html">HTTP/1</a> and HTTP/2. This API targets only the
@@ -2825,11 +2955,11 @@ different implementation.</p>
 <p>The following example creates an HTTP/2 server using the compatibility
 API:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
 <p>In order to create a mixed <a href="https.html">HTTPS</a> and HTTP/2 server, refer to the
 <a href="#http2_alpn_negotiation">ALPN negotiation</a> section.
@@ -2838,7 +2968,7 @@ Upgrading from non-tls HTTP/1 servers is not supported.</p>
 <a href="#http2_class_http2_http2serverresponse"><code>Http2ServerResponse</code></a>. They aim at API compatibility with HTTP/1, but
 they do not hide the differences between the protocols. As an example,
 the status message for HTTP codes is ignored.</p>
-<h3>ALPN negotiation<span><a class="mark" href="#http2_alpn_negotiation" id="http2_alpn_negotiation">#</a></span></h3>
+<h4>ALPN negotiation<span><a class="mark" href="#http2_alpn_negotiation" id="http2_alpn_negotiation">#</a></span></h4>
 <p>ALPN negotiation allows supporting both <a href="https.html">HTTPS</a> and HTTP/2 over
 the same socket. The <code>req</code> and <code>res</code> objects can be either HTTP/1 or
 HTTP/2, and an application <strong>must</strong> restrict itself to the public API of
@@ -2848,27 +2978,27 @@ features of HTTP/2.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { createSecureServer } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
 <span class="hljs-keyword">const</span> { readFileSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> cert = readFileSync(<span class="hljs-string">'./cert.pem'</span>);
-<span class="hljs-keyword">const</span> key = readFileSync(<span class="hljs-string">'./key.pem'</span>);
+<span class="hljs-keyword">const</span> cert = <span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'./cert.pem'</span>);
+<span class="hljs-keyword">const</span> key = <span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'./key.pem'</span>);
 
-<span class="hljs-keyword">const</span> server = createSecureServer(
+<span class="hljs-keyword">const</span> server = <span class="hljs-title function_">createSecureServer</span>(
   { cert, key, <span class="hljs-attr">allowHTTP1</span>: <span class="hljs-literal">true</span> },
   onRequest
-).listen(<span class="hljs-number">4443</span>);
+).<span class="hljs-title function_">listen</span>(<span class="hljs-number">4443</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">onRequest</span>(<span class="hljs-params">req, res</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">onRequest</span>(<span class="hljs-params">req, res</span>) {
   <span class="hljs-comment">// Detects if it is a HTTPS request or HTTP/2</span>
-  <span class="hljs-keyword">const</span> { <span class="hljs-attr">socket</span>: { alpnProtocol } } = req.httpVersion === <span class="hljs-string">'2.0'</span> ?
-    req.stream.session : req;
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'application/json'</span> });
-  res.end(<span class="hljs-built_in">JSON</span>.stringify({
+  <span class="hljs-keyword">const</span> { <span class="hljs-attr">socket</span>: { alpnProtocol } } = req.<span class="hljs-property">httpVersion</span> === <span class="hljs-string">'2.0'</span> ?
+    req.<span class="hljs-property">stream</span>.<span class="hljs-property">session</span> : req;
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'content-type'</span>: <span class="hljs-string">'application/json'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>({
     alpnProtocol,
-    <span class="hljs-attr">httpVersion</span>: req.httpVersion
+    <span class="hljs-attr">httpVersion</span>: req.<span class="hljs-property">httpVersion</span>
   }));
 }</code></pre>
 <p>The <code>'request'</code> event works identically on both <a href="https.html">HTTPS</a> and
 HTTP/2.</p>
-<h3>Class: <code>http2.Http2ServerRequest</code><span><a class="mark" href="#http2_class_http2_http2serverrequest" id="http2_class_http2_http2serverrequest">#</a></span></h3>
+<h4>Class: <code>http2.Http2ServerRequest</code><span><a class="mark" href="#http2_class_http2_http2serverrequest" id="http2_class_http2_http2serverrequest">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2879,7 +3009,7 @@ HTTP/2.</p>
 <a href="#http2_class_http2secureserver"><code>http2.SecureServer</code></a> and passed as the first argument to the
 <a href="#http2_event_request"><code>'request'</code></a> event. It may be used to access a request status, headers, and
 data.</p>
-<h4>Event: <code>'aborted'</code><span><a class="mark" href="#http2_event_aborted_1" id="http2_event_aborted_1">#</a></span></h4>
+<h5>Event: <code>'aborted'</code><span><a class="mark" href="#http2_event_aborted_1" id="http2_event_aborted_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2887,13 +3017,13 @@ data.</p>
 abnormally aborted in mid-communication.</p>
 <p>The <code>'aborted'</code> event will only be emitted if the <code>Http2ServerRequest</code> writable
 side has not been ended.</p>
-<h4>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_2" id="http2_event_close_2">#</a></span></h4>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_2" id="http2_event_close_2">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>Indicates that the underlying <a href="#http2_class_http2stream"><code>Http2Stream</code></a> was closed.
 Just like <code>'end'</code>, this event occurs only once per response.</p>
-<h4><code>request.aborted</code><span><a class="mark" href="#http2_request_aborted" id="http2_request_aborted">#</a></span></h4>
+<h5><code>request.aborted</code><span><a class="mark" href="#http2_request_aborted" id="http2_request_aborted">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.1.0</span>
 </div>
@@ -2902,7 +3032,7 @@ Just like <code>'end'</code>, this event occurs only once per response.</p>
 </ul>
 <p>The <code>request.aborted</code> property will be <code>true</code> if the request has
 been aborted.</p>
-<h4><code>request.authority</code><span><a class="mark" href="#http2_request_authority" id="http2_request_authority">#</a></span></h4>
+<h5><code>request.authority</code><span><a class="mark" href="#http2_request_authority" id="http2_request_authority">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2911,7 +3041,7 @@ been aborted.</p>
 </ul>
 <p>The request authority pseudo header field. It can also be accessed via
 <code>req.headers[':authority']</code>.</p>
-<h4><code>request.complete</code><span><a class="mark" href="#http2_request_complete" id="http2_request_complete">#</a></span></h4>
+<h5><code>request.complete</code><span><a class="mark" href="#http2_request_complete" id="http2_request_complete">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v12.10.0</span>
 </div>
@@ -2920,7 +3050,16 @@ been aborted.</p>
 </ul>
 <p>The <code>request.complete</code> property will be <code>true</code> if the request has
 been completed, aborted, or destroyed.</p>
-<h4><code>request.destroy([error])</code><span><a class="mark" href="#http2_request_destroy_error" id="http2_request_destroy_error">#</a></span></h4>
+<h5><code>request.connection</code><span><a class="mark" href="#http2_request_connection" id="http2_request_connection">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v8.4.0</span><span>Deprecated since: v13.0.0</span>
+</div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http2_request_socket"><code>request.socket</code></a>.</div><p></p>
+<ul>
+<li><a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> | <a href="tls.html#tls_class_tls_tlssocket" class="type">&#x3C;tls.TLSSocket></a></li>
+</ul>
+<p>See <a href="#http2_request_socket"><code>request.socket</code></a>.</p>
+<h5><code>request.destroy([error])</code><span><a class="mark" href="#http2_request_destroy_error" id="http2_request_destroy_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2931,7 +3070,7 @@ been completed, aborted, or destroyed.</p>
 the <a href="#http2_class_http2_http2serverrequest"><code>Http2ServerRequest</code></a>. If <code>error</code> is provided, an <code>'error'</code> event
 is emitted and <code>error</code> is passed as an argument to any listeners on the event.</p>
 <p>It does nothing if the stream was already destroyed.</p>
-<h4><code>request.headers</code><span><a class="mark" href="#http2_request_headers" id="http2_request_headers">#</a></span></h4>
+<h5><code>request.headers</code><span><a class="mark" href="#http2_request_headers" id="http2_request_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2945,16 +3084,16 @@ is emitted and <code>error</code> is passed as an argument to any listeners on t
 <span class="hljs-comment">// { 'user-agent': 'curl/7.22.0',</span>
 <span class="hljs-comment">//   host: '127.0.0.1:8000',</span>
 <span class="hljs-comment">//   accept: '*/*' }</span>
-<span class="hljs-built_in">console</span>.log(request.headers);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(request.<span class="hljs-property">headers</span>);</code></pre>
 <p>See <a href="#http2_headers_object">HTTP/2 Headers Object</a>.</p>
 <p>In HTTP/2, the request path, host name, protocol, and method are represented as
 special headers prefixed with the <code>:</code> character (e.g. <code>':path'</code>). These special
 headers will be included in the <code>request.headers</code> object. Care must be taken not
 to inadvertently modify these special headers or errors may occur. For instance,
 removing all headers from the request will cause errors to occur:</p>
-<pre><code class="language-js">removeAllHeaders(request.headers);
-assert(request.url);   <span class="hljs-comment">// Fails because the :path header has been removed</span></code></pre>
-<h4><code>request.httpVersion</code><span><a class="mark" href="#http2_request_httpversion" id="http2_request_httpversion">#</a></span></h4>
+<pre><code class="language-js"><span class="hljs-title function_">removeAllHeaders</span>(request.<span class="hljs-property">headers</span>);
+<span class="hljs-title function_">assert</span>(request.<span class="hljs-property">url</span>);   <span class="hljs-comment">// Fails because the :path header has been removed</span></code></pre>
+<h5><code>request.httpVersion</code><span><a class="mark" href="#http2_request_httpversion" id="http2_request_httpversion">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2966,7 +3105,7 @@ client response, the HTTP version of the connected-to server. Returns
 <code>'2.0'</code>.</p>
 <p>Also <code>message.httpVersionMajor</code> is the first integer and
 <code>message.httpVersionMinor</code> is the second.</p>
-<h4><code>request.method</code><span><a class="mark" href="#http2_request_method" id="http2_request_method">#</a></span></h4>
+<h5><code>request.method</code><span><a class="mark" href="#http2_request_method" id="http2_request_method">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2974,7 +3113,7 @@ client response, the HTTP version of the connected-to server. Returns
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The request method as a string. Read-only. Examples: <code>'GET'</code>, <code>'DELETE'</code>.</p>
-<h4><code>request.rawHeaders</code><span><a class="mark" href="#http2_request_rawheaders" id="http2_request_rawheaders">#</a></span></h4>
+<h5><code>request.rawHeaders</code><span><a class="mark" href="#http2_request_rawheaders" id="http2_request_rawheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -2996,8 +3135,8 @@ odd-numbered offsets are the associated values.</p>
 <span class="hljs-comment">//   '127.0.0.1:8000',</span>
 <span class="hljs-comment">//   'ACCEPT',</span>
 <span class="hljs-comment">//   '*/*' ]</span>
-<span class="hljs-built_in">console</span>.log(request.rawHeaders);</code></pre>
-<h4><code>request.rawTrailers</code><span><a class="mark" href="#http2_request_rawtrailers" id="http2_request_rawtrailers">#</a></span></h4>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(request.<span class="hljs-property">rawHeaders</span>);</code></pre>
+<h5><code>request.rawTrailers</code><span><a class="mark" href="#http2_request_rawtrailers" id="http2_request_rawtrailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3006,7 +3145,7 @@ odd-numbered offsets are the associated values.</p>
 </ul>
 <p>The raw request/response trailer keys and values exactly as they were
 received. Only populated at the <code>'end'</code> event.</p>
-<h4><code>request.scheme</code><span><a class="mark" href="#http2_request_scheme" id="http2_request_scheme">#</a></span></h4>
+<h5><code>request.scheme</code><span><a class="mark" href="#http2_request_scheme" id="http2_request_scheme">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3015,7 +3154,7 @@ received. Only populated at the <code>'end'</code> event.</p>
 </ul>
 <p>The request scheme pseudo header field indicating the scheme
 portion of the target URL.</p>
-<h4><code>request.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_request_settimeout_msecs_callback" id="http2_request_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>request.setTimeout(msecs, callback)</code><span><a class="mark" href="#http2_request_settimeout_msecs_callback" id="http2_request_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3031,7 +3170,7 @@ the response object.</p>
 the server, then <a href="#http2_class_http2stream"><code>Http2Stream</code></a>s are destroyed when they time out. If a
 handler is assigned to the request, the response, or the server's <code>'timeout'</code>
 events, timed out sockets must be handled explicitly.</p>
-<h4><code>request.socket</code><span><a class="mark" href="#http2_request_socket" id="http2_request_socket">#</a></span></h4>
+<h5><code>request.socket</code><span><a class="mark" href="#http2_request_socket" id="http2_request_socket">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3051,7 +3190,7 @@ more information.</p>
 <p>All other interactions will be routed directly to the socket. With TLS support,
 use <a href="tls.html#tls_tlssocket_getpeercertificate_detailed"><code>request.socket.getPeerCertificate()</code></a> to obtain the client's
 authentication details.</p>
-<h4><code>request.stream</code><span><a class="mark" href="#http2_request_stream" id="http2_request_stream">#</a></span></h4>
+<h5><code>request.stream</code><span><a class="mark" href="#http2_request_stream" id="http2_request_stream">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3059,7 +3198,7 @@ authentication details.</p>
 <li><a href="http2.html#http2_class_http2stream" class="type">&#x3C;Http2Stream></a></li>
 </ul>
 <p>The <a href="#http2_class_http2stream"><code>Http2Stream</code></a> object backing the request.</p>
-<h4><code>request.trailers</code><span><a class="mark" href="#http2_request_trailers" id="http2_request_trailers">#</a></span></h4>
+<h5><code>request.trailers</code><span><a class="mark" href="#http2_request_trailers" id="http2_request_trailers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3067,7 +3206,7 @@ authentication details.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>The request/response trailers object. Only populated at the <code>'end'</code> event.</p>
-<h4><code>request.url</code><span><a class="mark" href="#http2_request_url" id="http2_request_url">#</a></span></h4>
+<h5><code>request.url</code><span><a class="mark" href="#http2_request_url" id="http2_request_url">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3076,47 +3215,29 @@ authentication details.</p>
 </ul>
 <p>Request URL string. This contains only the URL that is present in the actual
 HTTP request. If the request is:</p>
-<pre><code class="language-http"><span class="hljs-keyword">GET</span> <span class="hljs-string">/status?name=ryan</span> HTTP/1.1
-<span class="hljs-attribute">Accept</span>: text/plain</code></pre>
+<pre><code class="language-http"><span class="hljs-keyword">GET</span> <span class="hljs-string">/status?name=ryan</span> <span class="hljs-meta">HTTP/1.1</span>
+<span class="hljs-attribute">Accept</span><span class="hljs-punctuation">: </span>text/plain</code></pre>
 <p>Then <code>request.url</code> will be:</p>
 <!-- eslint-disable semi -->
 <pre><code class="language-js"><span class="hljs-string">'/status?name=ryan'</span></code></pre>
-<p>To parse the url into its parts, <code>require('url').parse(request.url)</code>
-can be used:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> require(<span class="hljs-string">'url'</span>).parse(<span class="hljs-string">'/status?name=ryan'</span>)</span>
-Url {
-  protocol: null,
-  slashes: null,
-  auth: null,
-  host: null,
-  port: null,
-  hostname: null,
-  hash: null,
-  search: '?name=ryan',
-  query: 'name=ryan',
+<p>To parse the url into its parts, <code>new URL()</code> can be used:</p>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">new URL(<span class="hljs-string">'/status?name=ryan'</span>, <span class="hljs-string">'http://example.com'</span>)</span>
+URL {
+  href: 'http://example.com/status?name=ryan',
+  origin: 'http://example.com',
+  protocol: 'http:',
+  username: '',
+  password: '',
+  host: 'example.com',
+  hostname: 'example.com',
+  port: '',
   pathname: '/status',
-  path: '/status?name=ryan',
-  href: '/status?name=ryan' }</code></pre>
-<p>To obtain the parameters from the query string, use the
-<code>require('querystring').parse()</code> function or pass
-<code>true</code> as the second argument to <code>require('url').parse()</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> require(<span class="hljs-string">'url'</span>).parse(<span class="hljs-string">'/status?name=ryan'</span>, <span class="hljs-literal">true</span>)</span>
-Url {
-  protocol: null,
-  slashes: null,
-  auth: null,
-  host: null,
-  port: null,
-  hostname: null,
-  hash: null,
   search: '?name=ryan',
-  query: { name: 'ryan' },
-  pathname: '/status',
-  path: '/status?name=ryan',
-  href: '/status?name=ryan' }</code></pre>
-<h3>Class: <code>http2.Http2ServerResponse</code><span><a class="mark" href="#http2_class_http2_http2serverresponse" id="http2_class_http2_http2serverresponse">#</a></span></h3>
+  searchParams: URLSearchParams { 'name' => 'ryan' },
+  hash: ''
+}</code></pre>
+<h4>Class: <code>http2.Http2ServerResponse</code><span><a class="mark" href="#http2_class_http2_http2serverresponse" id="http2_class_http2_http2serverresponse">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3125,13 +3246,13 @@ Url {
 </ul>
 <p>This object is created internally by an HTTP server, not by the user. It is
 passed as the second parameter to the <a href="#http2_event_request"><code>'request'</code></a> event.</p>
-<h4>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_3" id="http2_event_close_3">#</a></span></h4>
+<h5>Event: <code>'close'</code><span><a class="mark" href="#http2_event_close_3" id="http2_event_close_3">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>Indicates that the underlying <a href="#http2_class_http2stream"><code>Http2Stream</code></a> was terminated before
 <a href="#http2_response_end_data_encoding_callback"><code>response.end()</code></a> was called or able to flush.</p>
-<h4>Event: <code>'finish'</code><span><a class="mark" href="#http2_event_finish" id="http2_event_finish">#</a></span></h4>
+<h5>Event: <code>'finish'</code><span><a class="mark" href="#http2_event_finish" id="http2_event_finish">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3140,7 +3261,7 @@ emitted when the last segment of the response headers and body have been
 handed off to the HTTP/2 multiplexing for transmission over the network. It
 does not imply that the client has received anything yet.</p>
 <p>After this event, no more events will be emitted on the response object.</p>
-<h4><code>response.addTrailers(headers)</code><span><a class="mark" href="#http2_response_addtrailers_headers" id="http2_response_addtrailers_headers">#</a></span></h4>
+<h5><code>response.addTrailers(headers)</code><span><a class="mark" href="#http2_response_addtrailers_headers" id="http2_response_addtrailers_headers">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3151,15 +3272,37 @@ does not imply that the client has received anything yet.</p>
 message) to the response.</p>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
-<h4><code>response.connection</code><span><a class="mark" href="#http2_response_connection" id="http2_response_connection">#</a></span></h4>
+<h5><code>response.connection</code><span><a class="mark" href="#http2_response_connection" id="http2_response_connection">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.4.0</span>
+<span>Added in: v8.4.0</span><span>Deprecated since: v13.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http2_response_socket"><code>response.socket</code></a>.</div><p></p>
 <ul>
 <li><a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> | <a href="tls.html#tls_class_tls_tlssocket" class="type">&#x3C;tls.TLSSocket></a></li>
 </ul>
 <p>See <a href="#http2_response_socket"><code>response.socket</code></a>.</p>
-<h4><code>response.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http2_response_end_data_encoding_callback" id="http2_response_end_data_encoding_callback">#</a></span></h4>
+<h5><code>response.createPushResponse(headers, callback)</code><span><a class="mark" href="#http2_response_createpushresponse_headers_callback" id="http2_response_createpushresponse_headers_callback">#</a></span></h5>
+<div class="api_metadata">
+<span>Added in: v8.4.0</span>
+</div>
+<ul>
+<li><code>headers</code> <a href="http2.html#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a> An object describing the headers</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called once <code>http2stream.pushStream()</code> is finished,
+or either when the attempt to create the pushed <code>Http2Stream</code> has failed or
+has been rejected, or the state of <code>Http2ServerRequest</code> is closed prior to
+calling the <code>http2stream.pushStream()</code> method
+<ul>
+<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>res</code> <a href="http2.html#http2_class_http2_http2serverresponse" class="type">&#x3C;http2.Http2ServerResponse></a> The newly-created <code>Http2ServerResponse</code>
+object</li>
+</ul>
+</li>
+</ul>
+<p>Call <a href="#http2_http2stream_pushstream_headers_options_callback"><code>http2stream.pushStream()</code></a> with the given headers, and wrap the
+given <a href="#http2_class_http2stream"><code>Http2Stream</code></a> on a newly created <code>Http2ServerResponse</code> as the callback
+parameter if successful. When <code>Http2ServerRequest</code> is closed, the callback is
+called with an error <code>ERR_HTTP2_INVALID_STREAM</code>.</p>
+<h5><code>response.end([data[, encoding]][, callback])</code><span><a class="mark" href="#http2_response_end_data_encoding_callback" id="http2_response_end_data_encoding_callback">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -3184,9 +3327,9 @@ The method, <code>response.end()</code>, MUST be called on each response.</p>
 <a href="http.html#http_response_write_chunk_encoding_callback"><code>response.write(data, encoding)</code></a> followed by <code>response.end(callback)</code>.</p>
 <p>If <code>callback</code> is specified, it will be called when the response stream
 is finished.</p>
-<h4><code>response.finished</code><span><a class="mark" href="#http2_response_finished" id="http2_response_finished">#</a></span></h4>
+<h5><code>response.finished</code><span><a class="mark" href="#http2_response_finished" id="http2_response_finished">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v8.4.0</span><span>Deprecated since: v12.16.0</span>
+<span>Added in: v8.4.0</span><span>Deprecated since: v13.4.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated. Use <a href="#http2_response_writableended"><code>response.writableEnded</code></a>.</div><p></p>
 <ul>
@@ -3194,7 +3337,7 @@ is finished.</p>
 </ul>
 <p>Boolean value that indicates whether the response has completed. Starts
 as <code>false</code>. After <a href="#http2_response_end_data_encoding_callback"><code>response.end()</code></a> executes, the value will be <code>true</code>.</p>
-<h4><code>response.getHeader(name)</code><span><a class="mark" href="#http2_response_getheader_name" id="http2_response_getheader_name">#</a></span></h4>
+<h5><code>response.getHeader(name)</code><span><a class="mark" href="#http2_response_getheader_name" id="http2_response_getheader_name">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3204,8 +3347,8 @@ as <code>false</code>. After <a href="#http2_response_end_data_encoding_callback
 </ul>
 <p>Reads out a header that has already been queued but not sent to the client.
 The name is case-insensitive.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> contentType = response.getHeader(<span class="hljs-string">'content-type'</span>);</code></pre>
-<h4><code>response.getHeaderNames()</code><span><a class="mark" href="#http2_response_getheadernames" id="http2_response_getheadernames">#</a></span></h4>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> contentType = response.<span class="hljs-title function_">getHeader</span>(<span class="hljs-string">'content-type'</span>);</code></pre>
+<h5><code>response.getHeaderNames()</code><span><a class="mark" href="#http2_response_getheadernames" id="http2_response_getheadernames">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3214,12 +3357,12 @@ The name is case-insensitive.</p>
 </ul>
 <p>Returns an array containing the unique names of the current outgoing headers.
 All header names are lowercase.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
 
-<span class="hljs-keyword">const</span> headerNames = response.getHeaderNames();
+<span class="hljs-keyword">const</span> headerNames = response.<span class="hljs-title function_">getHeaderNames</span>();
 <span class="hljs-comment">// headerNames === ['foo', 'set-cookie']</span></code></pre>
-<h4><code>response.getHeaders()</code><span><a class="mark" href="#http2_response_getheaders" id="http2_response_getheaders">#</a></span></h4>
+<h5><code>response.getHeaders()</code><span><a class="mark" href="#http2_response_getheaders" id="http2_response_getheaders">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3235,12 +3378,12 @@ are lowercase.</p>
 prototypically inherit from the JavaScript <code>Object</code>. This means that typical
 <code>Object</code> methods such as <code>obj.toString()</code>, <code>obj.hasOwnProperty()</code>, and others
 are not defined and <em>will not work</em>.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
-response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Foo'</span>, <span class="hljs-string">'bar'</span>);
+response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'foo=bar'</span>, <span class="hljs-string">'bar=baz'</span>]);
 
-<span class="hljs-keyword">const</span> headers = response.getHeaders();
+<span class="hljs-keyword">const</span> headers = response.<span class="hljs-title function_">getHeaders</span>();
 <span class="hljs-comment">// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }</span></code></pre>
-<h4><code>response.hasHeader(name)</code><span><a class="mark" href="#http2_response_hasheader_name" id="http2_response_hasheader_name">#</a></span></h4>
+<h5><code>response.hasHeader(name)</code><span><a class="mark" href="#http2_response_hasheader_name" id="http2_response_hasheader_name">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3250,8 +3393,8 @@ response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="
 </ul>
 <p>Returns <code>true</code> if the header identified by <code>name</code> is currently set in the
 outgoing headers. The header name matching is case-insensitive.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = response.hasHeader(<span class="hljs-string">'content-type'</span>);</code></pre>
-<h4><code>response.headersSent</code><span><a class="mark" href="#http2_response_headerssent" id="http2_response_headerssent">#</a></span></h4>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasContentType = response.<span class="hljs-title function_">hasHeader</span>(<span class="hljs-string">'content-type'</span>);</code></pre>
+<h5><code>response.headersSent</code><span><a class="mark" href="#http2_response_headerssent" id="http2_response_headerssent">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3259,7 +3402,7 @@ outgoing headers. The header name matching is case-insensitive.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>True if headers were sent, false otherwise (read-only).</p>
-<h4><code>response.removeHeader(name)</code><span><a class="mark" href="#http2_response_removeheader_name" id="http2_response_removeheader_name">#</a></span></h4>
+<h5><code>response.removeHeader(name)</code><span><a class="mark" href="#http2_response_removeheader_name" id="http2_response_removeheader_name">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3267,8 +3410,8 @@ outgoing headers. The header name matching is case-insensitive.</p>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Removes a header that has been queued for implicit sending.</p>
-<pre><code class="language-js">response.removeHeader(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
-<h4><code>response.sendDate</code><span><a class="mark" href="#http2_response_senddate" id="http2_response_senddate">#</a></span></h4>
+<pre><code class="language-js">response.<span class="hljs-title function_">removeHeader</span>(<span class="hljs-string">'Content-Encoding'</span>);</code></pre>
+<h5><code>response.sendDate</code><span><a class="mark" href="#http2_response_senddate" id="http2_response_senddate">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3279,7 +3422,7 @@ outgoing headers. The header name matching is case-insensitive.</p>
 the response if it is not already present in the headers. Defaults to true.</p>
 <p>This should only be disabled for testing; HTTP requires the Date header
 in responses.</p>
-<h4><code>response.setHeader(name, value)</code><span><a class="mark" href="#http2_response_setheader_name_value" id="http2_response_setheader_name_value">#</a></span></h4>
+<h5><code>response.setHeader(name, value)</code><span><a class="mark" href="#http2_response_setheader_name_value" id="http2_response_setheader_name_value">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3290,22 +3433,22 @@ in responses.</p>
 <p>Sets a single header value for implicit headers. If this header already exists
 in the to-be-sent headers, its value will be replaced. Use an array of strings
 here to send multiple headers with the same name.</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);</code></pre>
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);</code></pre>
 <p>or</p>
-<pre><code class="language-js">response.setHeader(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
+<pre><code class="language-js">response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Set-Cookie'</span>, [<span class="hljs-string">'type=ninja'</span>, <span class="hljs-string">'language=javascript'</span>]);</code></pre>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
 <p>When headers have been set with <a href="#http2_response_setheader_name_value"><code>response.setHeader()</code></a>, they will be merged
 with any headers passed to <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a>, with the headers passed
 to <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> given precedence.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Returns content-type = text/plain</span>
-<span class="hljs-keyword">const</span> server = http2.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
-<h4><code>response.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http2_response_settimeout_msecs_callback" id="http2_response_settimeout_msecs_callback">#</a></span></h4>
+<h5><code>response.setTimeout(msecs[, callback])</code><span><a class="mark" href="#http2_response_settimeout_msecs_callback" id="http2_response_settimeout_msecs_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3321,7 +3464,7 @@ the response object.</p>
 the server, then <a href="#http2_class_http2stream"><code>Http2Stream</code></a>s are destroyed when they time out. If a
 handler is assigned to the request, the response, or the server's <code>'timeout'</code>
 events, timed out sockets must be handled explicitly.</p>
-<h4><code>response.socket</code><span><a class="mark" href="#http2_response_socket" id="http2_response_socket">#</a></span></h4>
+<h5><code>response.socket</code><span><a class="mark" href="#http2_response_socket" id="http2_response_socket">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3340,12 +3483,12 @@ set on <code>response.stream</code>.</p>
 more information.</p>
 <p>All other interactions will be routed directly to the socket.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http2 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http2'</span>);
-<span class="hljs-keyword">const</span> server = http2.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  <span class="hljs-keyword">const</span> ip = req.socket.remoteAddress;
-  <span class="hljs-keyword">const</span> port = req.socket.remotePort;
-  res.end(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
-}).listen(<span class="hljs-number">3000</span>);</code></pre>
-<h4><code>response.statusCode</code><span><a class="mark" href="#http2_response_statuscode" id="http2_response_statuscode">#</a></span></h4>
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  <span class="hljs-keyword">const</span> ip = req.<span class="hljs-property">socket</span>.<span class="hljs-property">remoteAddress</span>;
+  <span class="hljs-keyword">const</span> port = req.<span class="hljs-property">socket</span>.<span class="hljs-property">remotePort</span>;
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">`Your IP address is <span class="hljs-subst">${ip}</span> and your source port is <span class="hljs-subst">${port}</span>.`</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">3000</span>);</code></pre>
+<h5><code>response.statusCode</code><span><a class="mark" href="#http2_response_statuscode" id="http2_response_statuscode">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3355,10 +3498,10 @@ more information.</p>
 <p>When using implicit headers (not calling <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> explicitly),
 this property controls the status code that will be sent to the client when
 the headers get flushed.</p>
-<pre><code class="language-js">response.statusCode = <span class="hljs-number">404</span>;</code></pre>
+<pre><code class="language-js">response.<span class="hljs-property">statusCode</span> = <span class="hljs-number">404</span>;</code></pre>
 <p>After response header was sent to the client, this property indicates the
 status code which was sent out.</p>
-<h4><code>response.statusMessage</code><span><a class="mark" href="#http2_response_statusmessage" id="http2_response_statusmessage">#</a></span></h4>
+<h5><code>response.statusMessage</code><span><a class="mark" href="#http2_response_statusmessage" id="http2_response_statusmessage">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3367,7 +3510,7 @@ status code which was sent out.</p>
 </ul>
 <p>Status message is not supported by HTTP/2 (RFC 7540 8.1.2.4). It returns
 an empty string.</p>
-<h4><code>response.stream</code><span><a class="mark" href="#http2_response_stream" id="http2_response_stream">#</a></span></h4>
+<h5><code>response.stream</code><span><a class="mark" href="#http2_response_stream" id="http2_response_stream">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3375,7 +3518,7 @@ an empty string.</p>
 <li><a href="http2.html#http2_class_http2stream" class="type">&#x3C;Http2Stream></a></li>
 </ul>
 <p>The <a href="#http2_class_http2stream"><code>Http2Stream</code></a> object backing the response.</p>
-<h4><code>response.writableEnded</code><span><a class="mark" href="#http2_response_writableended" id="http2_response_writableended">#</a></span></h4>
+<h5><code>response.writableEnded</code><span><a class="mark" href="#http2_response_writableended" id="http2_response_writableended">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -3385,7 +3528,7 @@ an empty string.</p>
 <p>Is <code>true</code> after <a href="#http2_response_end_data_encoding_callback"><code>response.end()</code></a> has been called. This property
 does not indicate whether the data has been flushed, for this use
 <a href="stream.html#stream_writable_writablefinished"><code>writable.writableFinished</code></a> instead.</p>
-<h4><code>response.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http2_response_write_chunk_encoding_callback" id="http2_response_write_chunk_encoding_callback">#</a></span></h4>
+<h5><code>response.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#http2_response_write_chunk_encoding_callback" id="http2_response_write_chunk_encoding_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
@@ -3416,19 +3559,19 @@ first chunk of the body.</p>
 <p>Returns <code>true</code> if the entire data was flushed successfully to the kernel
 buffer. Returns <code>false</code> if all or part of the data was queued in user memory.
 <code>'drain'</code> will be emitted when the buffer is free again.</p>
-<h4><code>response.writeContinue()</code><span><a class="mark" href="#http2_response_writecontinue" id="http2_response_writecontinue">#</a></span></h4>
+<h5><code>response.writeContinue()</code><span><a class="mark" href="#http2_response_writecontinue" id="http2_response_writecontinue">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>Sends a status <code>100 Continue</code> to the client, indicating that the request body
 should be sent. See the <a href="#http2_event_checkcontinue"><code>'checkContinue'</code></a> event on <code>Http2Server</code> and
 <code>Http2SecureServer</code>.</p>
-<h4><code>response.writeHead(statusCode[, statusMessage][, headers])</code><span><a class="mark" href="#http2_response_writehead_statuscode_statusmessage_headers" id="http2_response_writehead_statuscode_statusmessage_headers">#</a></span></h4>
+<h5><code>response.writeHead(statusCode[, statusMessage][, headers])</code><span><a class="mark" href="#http2_response_writehead_statuscode_statusmessage_headers" id="http2_response_writehead_statuscode_statusmessage_headers">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.10.0</td>
+<tr><td>v11.10.0, v10.17.0</td>
 <td><p>Return <code>this</code> from <code>writeHead()</code> to allow chaining with <code>end()</code>.</p></td></tr>
 <tr><td>v8.4.0</td>
 <td><p><span>Added in: v8.4.0</span></p></td></tr>
@@ -3449,9 +3592,10 @@ passed as the second argument. However, because the <code>statusMessage</code> h
 meaning within HTTP/2, the argument will have no effect and a process warning
 will be emitted.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> body = <span class="hljs-string">'hello world'</span>;
-response.writeHead(<span class="hljs-number">200</span>, {
-  <span class="hljs-string">'Content-Length'</span>: Buffer.byteLength(body),
-  <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });</code></pre>
+response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, {
+  <span class="hljs-string">'Content-Length'</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">byteLength</span>(body),
+  <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span>,
+});</code></pre>
 <p><code>Content-Length</code> is given in bytes not characters. The
 <code>Buffer.byteLength()</code> API may be used to determine the number of bytes in a
 given encoding. On outbound messages, Node.js does not check if Content-Length
@@ -3466,49 +3610,29 @@ this, the implicit/mutable headers will be calculated and call this function.</p
 with any headers passed to <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a>, with the headers passed
 to <a href="#http2_response_writehead_statuscode_statusmessage_headers"><code>response.writeHead()</code></a> given precedence.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Returns content-type = text/plain</span>
-<span class="hljs-keyword">const</span> server = http2.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);
-  res.setHeader(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
-  res.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
-  res.end(<span class="hljs-string">'ok'</span>);
+<span class="hljs-keyword">const</span> server = http2.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/html; charset=utf-8'</span>);
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'X-Foo'</span>, <span class="hljs-string">'bar'</span>);
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'text/plain; charset=utf-8'</span> });
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'ok'</span>);
 });</code></pre>
 <p>Attempting to set a header field name or value that contains invalid characters
 will result in a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> being thrown.</p>
-<h4><code>response.createPushResponse(headers, callback)</code><span><a class="mark" href="#http2_response_createpushresponse_headers_callback" id="http2_response_createpushresponse_headers_callback">#</a></span></h4>
-<div class="api_metadata">
-<span>Added in: v8.4.0</span>
-</div>
-<ul>
-<li><code>headers</code> <a href="http2.html#http2_headers_object" class="type">&#x3C;HTTP/2 Headers Object></a> An object describing the headers</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called once <code>http2stream.pushStream()</code> is finished,
-or either when the attempt to create the pushed <code>Http2Stream</code> has failed or
-has been rejected, or the state of <code>Http2ServerRequest</code> is closed prior to
-calling the <code>http2stream.pushStream()</code> method
-<ul>
-<li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li><code>stream</code> <a href="http2.html#http2_class_serverhttp2stream" class="type">&#x3C;ServerHttp2Stream></a> The newly-created <code>ServerHttp2Stream</code> object</li>
-</ul>
-</li>
-</ul>
-<p>Call <a href="#http2_http2stream_pushstream_headers_options_callback"><code>http2stream.pushStream()</code></a> with the given headers, and wrap the
-given <a href="#http2_class_http2stream"><code>Http2Stream</code></a> on a newly created <code>Http2ServerResponse</code> as the callback
-parameter if successful. When <code>Http2ServerRequest</code> is closed, the callback is
-called with an error <code>ERR_HTTP2_INVALID_STREAM</code>.</p>
-<h2>Collecting HTTP/2 performance metrics<span><a class="mark" href="#http2_collecting_http_2_performance_metrics" id="http2_collecting_http_2_performance_metrics">#</a></span></h2>
+</section><section><h3>Collecting HTTP/2 performance metrics<span><a class="mark" href="#http2_collecting_http_2_performance_metrics" id="http2_collecting_http_2_performance_metrics">#</a></span></h3>
 <p>The <a href="perf_hooks.html">Performance Observer</a> API can be used to collect basic performance
 metrics for each <code>Http2Session</code> and <code>Http2Stream</code> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { PerformanceObserver } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">PerformanceObserver</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">items</span>) =></span> {
-  <span class="hljs-keyword">const</span> entry = items.getEntries()[<span class="hljs-number">0</span>];
-  <span class="hljs-built_in">console</span>.log(entry.entryType);  <span class="hljs-comment">// prints 'http2'</span>
-  <span class="hljs-keyword">if</span> (entry.name === <span class="hljs-string">'Http2Session'</span>) {
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">items</span>) =></span> {
+  <span class="hljs-keyword">const</span> entry = items.<span class="hljs-title function_">getEntries</span>()[<span class="hljs-number">0</span>];
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(entry.<span class="hljs-property">entryType</span>);  <span class="hljs-comment">// prints 'http2'</span>
+  <span class="hljs-keyword">if</span> (entry.<span class="hljs-property">name</span> === <span class="hljs-string">'Http2Session'</span>) {
     <span class="hljs-comment">// Entry contains statistics about the Http2Session</span>
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (entry.name === <span class="hljs-string">'Http2Stream'</span>) {
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (entry.<span class="hljs-property">name</span> === <span class="hljs-string">'Http2Stream'</span>) {
     <span class="hljs-comment">// Entry contains statistics about the Http2Stream</span>
   }
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'http2'</span>] });</code></pre>
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'http2'</span>] });</code></pre>
 <p>The <code>entryType</code> property of the <code>PerformanceEntry</code> will be equal to <code>'http2'</code>.</p>
 <p>The <code>name</code> property of the <code>PerformanceEntry</code> will be equal to either
 <code>'Http2Stream'</code> or <code>'Http2Session'</code>.</p>
@@ -3546,10 +3670,46 @@ all <code>Http2Stream</code> instances.</li>
 the <code>Http2Session</code>.</li>
 <li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'server'</code> or <code>'client'</code> to identify the type of
 <code>Http2Session</code>.</li>
-</ul>
+</ul></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/http2.json b/doc/api/http2.json
index 665721e33ebe7d4f49f87324f1f5c184ae6d8936..e20375b74bde649c5775853b0ad0d18404f3a9c0 100644
--- a/doc/api/http2.json
+++ b/doc/api/http2.json
@@ -10,6 +10,11 @@
           "v8.4.0"
         ],
         "changes": [
+          {
+            "version": "v14.17.0",
+            "pr-url": "https://github.com/nodejs/node/pull/36070",
+            "description": "It is possible to abort a request with an AbortSignal."
+          },
           {
             "version": "v10.10.0",
             "pr-url": "https://github.com/nodejs/node/pull/22466",
@@ -20,7 +25,7 @@
       "introduced_in": "v8.4.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/http2.js\">lib/http2.js</a></p>\n<p>The <code>http2</code> module provides an implementation of the <a href=\"https://tools.ietf.org/html/rfc7540\">HTTP/2</a> protocol. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/http2.js\">lib/http2.js</a></p>\n<p>The <code>http2</code> module provides an implementation of the <a href=\"https://tools.ietf.org/html/rfc7540\">HTTP/2</a> protocol. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Core API",
@@ -45,6 +50,15 @@
               "textRaw": "Headers object",
               "name": "headers_object",
               "desc": "<p>Headers are represented as own-properties on JavaScript objects. The property\nkeys will be serialized to lower-case. Property values should be strings (if\nthey are not they will be coerced to strings) or an <code>Array</code> of strings (in order\nto send more than one value per header field).</p>\n<pre><code class=\"language-js\">const headers = {\n  ':status': '200',\n  'content-type': 'text-plain',\n  'ABC': ['has', 'more', 'than', 'one', 'value']\n};\n\nstream.respond(headers);\n</code></pre>\n<p>Header objects passed to callback functions will have a <code>null</code> prototype. This\nmeans that normal JavaScript object methods such as\n<code>Object.prototype.toString()</code> and <code>Object.prototype.hasOwnProperty()</code> will\nnot work.</p>\n<p>For incoming headers:</p>\n<ul>\n<li>The <code>:status</code> header is converted to <code>number</code>.</li>\n<li>Duplicates of <code>:status</code>, <code>:method</code>, <code>:authority</code>, <code>:scheme</code>, <code>:path</code>,\n<code>:protocol</code>, <code>age</code>, <code>authorization</code>, <code>access-control-allow-credentials</code>,\n<code>access-control-max-age</code>, <code>access-control-request-method</code>, <code>content-encoding</code>,\n<code>content-language</code>, <code>content-length</code>, <code>content-location</code>, <code>content-md5</code>,\n<code>content-range</code>, <code>content-type</code>, <code>date</code>, <code>dnt</code>, <code>etag</code>, <code>expires</code>, <code>from</code>,\n<code>if-match</code>, <code>if-modified-since</code>, <code>if-none-match</code>, <code>if-range</code>,\n<code>if-unmodified-since</code>, <code>last-modified</code>, <code>location</code>, <code>max-forwards</code>,\n<code>proxy-authorization</code>, <code>range</code>, <code>referer</code>,<code>retry-after</code>, <code>tk</code>,\n<code>upgrade-insecure-requests</code>, <code>user-agent</code> or <code>x-content-type-options</code> are\ndiscarded.</li>\n<li><code>set-cookie</code> is always an array. Duplicates are added to the array.</li>\n<li>For duplicate <code>cookie</code> headers, the values are joined together with '; '.</li>\n<li>For all other headers, the values are joined together with ', '.</li>\n</ul>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream, headers) => {\n  console.log(headers[':path']);\n  console.log(headers.ABC);\n});\n</code></pre>",
+              "modules": [
+                {
+                  "textRaw": "Sensitive headers",
+                  "name": "sensitive_headers",
+                  "desc": "<p>HTTP2 headers can be marked as sensitive, which means that the HTTP/2\nheader compression algorithm will never index them. This can make sense for\nheader values with low entropy and that may be considered valuable to an\nattacker, for example <code>Cookie</code> or <code>Authorization</code>. To achieve this, add\nthe header name to the <code>[http2.sensitiveHeaders]</code> property as an array:</p>\n<pre><code class=\"language-js\">const headers = {\n  ':status': '200',\n  'content-type': 'text-plain',\n  'cookie': 'some-cookie',\n  'other-sensitive-header': 'very secret data',\n  [http2.sensitiveHeaders]: ['cookie', 'other-sensitive-header']\n};\n\nstream.respond(headers);\n</code></pre>\n<p>For some headers, such as <code>Authorization</code> and short <code>Cookie</code> headers,\nthis flag is set automatically.</p>\n<p>This property is also set for received headers. It will contain the names of\nall headers marked as sensitive, including ones marked that way automatically.</p>",
+                  "type": "module",
+                  "displayName": "Sensitive headers"
+                }
+              ],
               "type": "module",
               "displayName": "Headers object"
             },
@@ -72,13 +86,6 @@
               "type": "module",
               "displayName": "Settings object"
             },
-            {
-              "textRaw": "Using `options.selectPadding()`",
-              "name": "using_`options.selectpadding()`",
-              "desc": "<p>When <code>options.paddingStrategy</code> is equal to\n<code>http2.constants.PADDING_STRATEGY_CALLBACK</code>, the HTTP/2 implementation will\nconsult the <code>options.selectPadding()</code> callback function, if provided, to\ndetermine the specific amount of padding to use per <code>HEADERS</code> and <code>DATA</code> frame.</p>\n<p>The <code>options.selectPadding()</code> function receives two numeric arguments,\n<code>frameLen</code> and <code>maxFrameLen</code> and must return a number <code>N</code> such that\n<code>frameLen &#x3C;= N &#x3C;= maxFrameLen</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer({\n  paddingStrategy: http2.constants.PADDING_STRATEGY_CALLBACK,\n  selectPadding(frameLen, maxFrameLen) {\n    return maxFrameLen;\n  }\n});\n</code></pre>\n<p>The <code>options.selectPadding()</code> function is invoked once for <em>every</em> <code>HEADERS</code> and\n<code>DATA</code> frame. This has a definite noticeable impact on performance.</p>",
-              "type": "module",
-              "displayName": "Using `options.selectPadding()`"
-            },
             {
               "textRaw": "Error handling",
               "name": "error_handling",
@@ -655,6 +662,29 @@
                   ],
                   "desc": "<p>Calls <a href=\"net.html#net_socket_ref\"><code>ref()</code></a> on this <code>Http2Session</code>\ninstance's underlying <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.</p>"
                 },
+                {
+                  "textRaw": "`http2session.setLocalWindowSize(windowSize)`",
+                  "type": "method",
+                  "name": "setLocalWindowSize",
+                  "meta": {
+                    "added": [
+                      "v14.18.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`windowSize` {number}",
+                          "name": "windowSize",
+                          "type": "number"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Sets the local endpoint's window size.\nThe <code>windowSize</code> is the total window size to set, not\nthe delta.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\n\nconst server = http2.createServer();\nconst expectedWindowSize = 2 ** 20;\nserver.on('connect', (session) => {\n\n  // Set local window size to be 2 ** 20\n  session.setLocalWindowSize(expectedWindowSize);\n});\n</code></pre>"
+                },
                 {
                   "textRaw": "`http2session.setTimeout(msecs, callback)`",
                   "type": "method",
@@ -946,13 +976,19 @@
                               "name": "waitForTrailers",
                               "type": "boolean",
                               "desc": "When `true`, the `Http2Stream` will emit the `'wantTrailers'` event after the final `DATA` frame has been sent."
+                            },
+                            {
+                              "textRaw": "`signal` {AbortSignal} An AbortSignal that may be used to abort an ongoing request.",
+                              "name": "signal",
+                              "type": "AbortSignal",
+                              "desc": "An AbortSignal that may be used to abort an ongoing request."
                             }
                           ]
                         }
                       ]
                     }
                   ],
-                  "desc": "<p>For HTTP/2 Client <code>Http2Session</code> instances only, the <code>http2session.request()</code>\ncreates and returns an <code>Http2Stream</code> instance that can be used to send an\nHTTP/2 request to the connected server.</p>\n<p>This method is only available if <code>http2session.type</code> is equal to\n<code>http2.constants.NGHTTP2_SESSION_CLIENT</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst clientSession = http2.connect('https://localhost:1234');\nconst {\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS\n} = http2.constants;\n\nconst req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });\nreq.on('response', (headers) => {\n  console.log(headers[HTTP2_HEADER_STATUS]);\n  req.on('data', (chunk) => { /* .. */ });\n  req.on('end', () => { /* .. */ });\n});\n</code></pre>\n<p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event\nis emitted immediately after queuing the last chunk of payload data to be sent.\nThe <code>http2stream.sendTrailers()</code> method can then be called to send trailing\nheaders to the peer.</p>\n<p>When <code>options.waitForTrailers</code> is set, the <code>Http2Stream</code> will not automatically\nclose when the final <code>DATA</code> frame is transmitted. User code must call either\n<code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the\n<code>Http2Stream</code>.</p>\n<p>The <code>:method</code> and <code>:path</code> pseudo-headers are not specified within <code>headers</code>,\nthey respectively default to:</p>\n<ul>\n<li><code>:method</code> = <code>'GET'</code></li>\n<li><code>:path</code> = <code>/</code></li>\n</ul>"
+                  "desc": "<p>For HTTP/2 Client <code>Http2Session</code> instances only, the <code>http2session.request()</code>\ncreates and returns an <code>Http2Stream</code> instance that can be used to send an\nHTTP/2 request to the connected server.</p>\n<p>This method is only available if <code>http2session.type</code> is equal to\n<code>http2.constants.NGHTTP2_SESSION_CLIENT</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst clientSession = http2.connect('https://localhost:1234');\nconst {\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS\n} = http2.constants;\n\nconst req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });\nreq.on('response', (headers) => {\n  console.log(headers[HTTP2_HEADER_STATUS]);\n  req.on('data', (chunk) => { /* .. */ });\n  req.on('end', () => { /* .. */ });\n});\n</code></pre>\n<p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event\nis emitted immediately after queuing the last chunk of payload data to be sent.\nThe <code>http2stream.sendTrailers()</code> method can then be called to send trailing\nheaders to the peer.</p>\n<p>When <code>options.waitForTrailers</code> is set, the <code>Http2Stream</code> will not automatically\nclose when the final <code>DATA</code> frame is transmitted. User code must call either\n<code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the\n<code>Http2Stream</code>.</p>\n<p>When <code>options.signal</code> is set with an <code>AbortSignal</code> and then <code>abort</code> on the\ncorresponding <code>AbortController</code> is called, the request will emit an <code>'error'</code>\nevent with an <code>AbortError</code> error.</p>\n<p>The <code>:method</code> and <code>:path</code> pseudo-headers are not specified within <code>headers</code>,\nthey respectively default to:</p>\n<ul>\n<li><code>:method</code> = <code>'GET'</code></li>\n<li><code>:path</code> = <code>/</code></li>\n</ul>"
                 }
               ]
             },
@@ -1154,7 +1190,8 @@
                   "name": "bufferSize",
                   "meta": {
                     "added": [
-                      "v11.2.0"
+                      "v11.2.0",
+                      "v10.16.0"
                     ],
                     "changes": []
                   },
@@ -1230,7 +1267,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Set to the <code>RST_STREAM</code> <a href=\"#error_codes\">error code</a> reported when the <code>Http2Stream</code> is\ndestroyed after either receiving an <code>RST_STREAM</code> frame from the connected peer,\ncalling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>. Will be\n<code>undefined</code> if the <code>Http2Stream</code> has not been closed.</p>"
+                  "desc": "<p>Set to the <code>RST_STREAM</code> <a href=\"#http2_error_codes_for_rst_stream_and_goaway\">error code</a> reported when the <code>Http2Stream</code> is\ndestroyed after either receiving an <code>RST_STREAM</code> frame from the connected peer,\ncalling <code>http2stream.close()</code>, or <code>http2stream.destroy()</code>. Will be\n<code>undefined</code> if the <code>Http2Stream</code> has not been closed.</p>"
                 },
                 {
                   "textRaw": "`sentHeaders` {HTTP/2 Headers Object}",
@@ -1606,9 +1643,9 @@
                     ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.5.0",
                         "pr-url": "https://github.com/nodejs/node/pull/33160",
-                        "description": "Allow explicity setting date headers."
+                        "description": "Allow explicitly setting date headers."
                       }
                     ]
                   },
@@ -1654,9 +1691,9 @@
                     ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.5.0",
                         "pr-url": "https://github.com/nodejs/node/pull/33160",
-                        "description": "Allow explicity setting date headers."
+                        "description": "Allow explicitly setting date headers."
                       },
                       {
                         "version": "v12.12.0",
@@ -1729,9 +1766,9 @@
                     ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.5.0",
                         "pr-url": "https://github.com/nodejs/node/pull/33160",
-                        "description": "Allow explicity setting date headers."
+                        "description": "Allow explicitly setting date headers."
                       },
                       {
                         "version": "v10.0.0",
@@ -1792,7 +1829,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Sends a regular file as the response. The <code>path</code> must specify a regular file\nor an <code>'error'</code> event will be emitted on the <code>Http2Stream</code> object.</p>\n<p>When used, the <code>Http2Stream</code> object's <code>Duplex</code> interface will be closed\nautomatically.</p>\n<p>The optional <code>options.statCheck</code> function may be specified to give user code\nan opportunity to set additional content headers based on the <code>fs.Stat</code> details\nof the given file:</p>\n<p>If an error occurs while attempting to read the file data, the <code>Http2Stream</code>\nwill be closed using an <code>RST_STREAM</code> frame using the standard <code>INTERNAL_ERROR</code>\ncode. If the <code>onError</code> callback is defined, then it will be called. Otherwise\nthe stream will be destroyed.</p>\n<p>Example using a file path:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  function statCheck(stat, headers) {\n    headers['last-modified'] = stat.mtime.toUTCString();\n  }\n\n  function onError(err) {\n    if (err.code === 'ENOENT') {\n      stream.respond({ ':status': 404 });\n    } else {\n      stream.respond({ ':status': 500 });\n    }\n    stream.end();\n  }\n\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { statCheck, onError });\n});\n</code></pre>\n<p>The <code>options.statCheck</code> function may also be used to cancel the send operation\nby returning <code>false</code>. For instance, a conditional request may check the stat\nresults to determine if the file has been modified to return an appropriate\n<code>304</code> response:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  function statCheck(stat, headers) {\n    // Check the stat here...\n    stream.respond({ ':status': 304 });\n    return false; // Cancel the send operation\n  }\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { statCheck });\n});\n</code></pre>\n<p>The <code>content-length</code> header field will be automatically set.</p>\n<p>The <code>offset</code> and <code>length</code> options may be used to limit the response to a\nspecific range subset. This can be used, for instance, to support HTTP Range\nrequests.</p>\n<p>The <code>options.onError</code> function may also be used to handle all the errors\nthat could happen before the delivery of the file is initiated. The\ndefault behavior is to destroy the stream.</p>\n<p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event\nwill be emitted immediately after queuing the last chunk of payload data to be\nsent. The <code>http2stream.sendTrailers()</code> method can then be used to sent trailing\nheader fields to the peer.</p>\n<p>When <code>options.waitForTrailers</code> is set, the <code>Http2Stream</code> will not automatically\nclose when the final <code>DATA</code> frame is transmitted. User code must call either\n<code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the\n<code>Http2Stream</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { waitForTrailers: true });\n  stream.on('wantTrailers', () => {\n    stream.sendTrailers({ ABC: 'some value to send' });\n  });\n});\n</code></pre>"
+                  "desc": "<p>Sends a regular file as the response. The <code>path</code> must specify a regular file\nor an <code>'error'</code> event will be emitted on the <code>Http2Stream</code> object.</p>\n<p>When used, the <code>Http2Stream</code> object's <code>Duplex</code> interface will be closed\nautomatically.</p>\n<p>The optional <code>options.statCheck</code> function may be specified to give user code\nan opportunity to set additional content headers based on the <code>fs.Stat</code> details\nof the given file:</p>\n<p>If an error occurs while attempting to read the file data, the <code>Http2Stream</code>\nwill be closed using an <code>RST_STREAM</code> frame using the standard <code>INTERNAL_ERROR</code>\ncode. If the <code>onError</code> callback is defined, then it will be called. Otherwise\nthe stream will be destroyed.</p>\n<p>Example using a file path:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  function statCheck(stat, headers) {\n    headers['last-modified'] = stat.mtime.toUTCString();\n  }\n\n  function onError(err) {\n    // stream.respond() can throw if the stream has been destroyed by\n    // the other side.\n    try {\n      if (err.code === 'ENOENT') {\n        stream.respond({ ':status': 404 });\n      } else {\n        stream.respond({ ':status': 500 });\n      }\n    } catch (err) {\n      // Perform actual error handling.\n      console.log(err);\n    }\n    stream.end();\n  }\n\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { statCheck, onError });\n});\n</code></pre>\n<p>The <code>options.statCheck</code> function may also be used to cancel the send operation\nby returning <code>false</code>. For instance, a conditional request may check the stat\nresults to determine if the file has been modified to return an appropriate\n<code>304</code> response:</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  function statCheck(stat, headers) {\n    // Check the stat here...\n    stream.respond({ ':status': 304 });\n    return false; // Cancel the send operation\n  }\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { statCheck });\n});\n</code></pre>\n<p>The <code>content-length</code> header field will be automatically set.</p>\n<p>The <code>offset</code> and <code>length</code> options may be used to limit the response to a\nspecific range subset. This can be used, for instance, to support HTTP Range\nrequests.</p>\n<p>The <code>options.onError</code> function may also be used to handle all the errors\nthat could happen before the delivery of the file is initiated. The\ndefault behavior is to destroy the stream.</p>\n<p>When the <code>options.waitForTrailers</code> option is set, the <code>'wantTrailers'</code> event\nwill be emitted immediately after queuing the last chunk of payload data to be\nsent. The <code>http2stream.sendTrailers()</code> method can then be used to sent trailing\nheader fields to the peer.</p>\n<p>When <code>options.waitForTrailers</code> is set, the <code>Http2Stream</code> will not automatically\nclose when the final <code>DATA</code> frame is transmitted. User code must call either\n<code>http2stream.sendTrailers()</code> or <code>http2stream.close()</code> to close the\n<code>Http2Stream</code>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst server = http2.createServer();\nserver.on('stream', (stream) => {\n  stream.respondWithFile('/some/file',\n                         { 'content-type': 'text/plain; charset=utf-8' },\n                         { waitForTrailers: true });\n  stream.on('wantTrailers', () => {\n    stream.sendTrailers({ ABC: 'some value to send' });\n  });\n});\n</code></pre>"
                 }
               ],
               "properties": [
@@ -1857,68 +1894,26 @@
                     }
                   ],
                   "desc": "<p>If a <a href=\"#http2_event_request\"><code>'request'</code></a> listener is registered or <a href=\"#http2_http2_createserver_options_onrequesthandler\"><code>http2.createServer()</code></a> is\nsupplied a callback function, the <code>'checkContinue'</code> event is emitted each time\na request with an HTTP <code>Expect: 100-continue</code> is received. If this event is\nnot listened for, the server will automatically respond with a status\n<code>100 Continue</code> as appropriate.</p>\n<p>Handling this event involves calling <a href=\"#http2_response_writecontinue\"><code>response.writeContinue()</code></a> if the\nclient should continue to send the request body, or generating an appropriate\nHTTP response (e.g. 400 Bad Request) if the client should not continue to send\nthe request body.</p>\n<p>When this event is emitted and handled, the <a href=\"#http2_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
-                }
-              ]
-            },
-            {
-              "textRaw": "Class: `Http2SecureServer`",
-              "type": "class",
-              "name": "Http2SecureServer",
-              "meta": {
-                "added": [
-                  "v8.4.0"
-                ],
-                "changes": []
-              },
-              "desc": "<ul>\n<li>Extends: <a href=\"tls.html#tls_class_tls_server\" class=\"type\">&lt;tls.Server&gt;</a></li>\n</ul>\n<p>Instances of <code>Http2SecureServer</code> are created using the\n<code>http2.createSecureServer()</code> function. The <code>Http2SecureServer</code> class is not\nexported directly by the <code>http2</code> module.</p>",
-              "events": [
+                },
                 {
-                  "textRaw": "Event: `'checkContinue'`",
+                  "textRaw": "Event: `'connection'`",
                   "type": "event",
-                  "name": "checkContinue",
+                  "name": "connection",
                   "meta": {
                     "added": [
-                      "v8.5.0"
+                      "v8.4.0"
                     ],
                     "changes": []
                   },
                   "params": [
                     {
-                      "textRaw": "`request` {http2.Http2ServerRequest}",
-                      "name": "request",
-                      "type": "http2.Http2ServerRequest"
-                    },
-                    {
-                      "textRaw": "`response` {http2.Http2ServerResponse}",
-                      "name": "response",
-                      "type": "http2.Http2ServerResponse"
+                      "textRaw": "`socket` {stream.Duplex}",
+                      "name": "socket",
+                      "type": "stream.Duplex"
                     }
                   ],
-                  "desc": "<p>If a <a href=\"#http2_event_request\"><code>'request'</code></a> listener is registered or <a href=\"#http2_http2_createsecureserver_options_onrequesthandler\"><code>http2.createSecureServer()</code></a>\nis supplied a callback function, the <code>'checkContinue'</code> event is emitted each\ntime a request with an HTTP <code>Expect: 100-continue</code> is received. If this event\nis not listened for, the server will automatically respond with a status\n<code>100 Continue</code> as appropriate.</p>\n<p>Handling this event involves calling <a href=\"#http2_response_writecontinue\"><code>response.writeContinue()</code></a> if the\nclient should continue to send the request body, or generating an appropriate\nHTTP response (e.g. 400 Bad Request) if the client should not continue to send\nthe request body.</p>\n<p>When this event is emitted and handled, the <a href=\"#http2_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
-                }
-              ]
-            }
-          ],
-          "events": [
-            {
-              "textRaw": "Event: `'connection'`",
-              "type": "event",
-              "name": "connection",
-              "meta": {
-                "added": [
-                  "v8.4.0"
-                ],
-                "changes": []
-              },
-              "params": [
-                {
-                  "textRaw": "`socket` {stream.Duplex}",
-                  "name": "socket",
-                  "type": "stream.Duplex"
-                }
-              ],
-              "desc": "<p>This event is emitted when a new TCP stream is established. <code>socket</code> is\ntypically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>. Usually users will not want to\naccess this event.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>",
-              "events": [
+                  "desc": "<p>This event is emitted when a new TCP stream is established. <code>socket</code> is\ntypically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>. Usually users will not want to\naccess this event.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>"
+                },
                 {
                   "textRaw": "Event: `'request'`",
                   "type": "event",
@@ -1979,8 +1974,33 @@
                     ],
                     "changes": []
                   },
-                  "params": [],
-                  "desc": "<p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by\nan <code>Http2Session</code> associated with the server.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst {\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_CONTENT_TYPE\n} = http2.constants;\n\nconst server = http2.createServer();\nserver.on('stream', (stream, headers, flags) => {\n  const method = headers[HTTP2_HEADER_METHOD];\n  const path = headers[HTTP2_HEADER_PATH];\n  // ...\n  stream.respond({\n    [HTTP2_HEADER_STATUS]: 200,\n    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8'\n  });\n  stream.write('hello ');\n  stream.end('world');\n});\n</code></pre>"
+                  "params": [
+                    {
+                      "textRaw": "`stream` {Http2Stream} A reference to the stream",
+                      "name": "stream",
+                      "type": "Http2Stream",
+                      "desc": "A reference to the stream"
+                    },
+                    {
+                      "textRaw": "`headers` {HTTP/2 Headers Object} An object describing the headers",
+                      "name": "headers",
+                      "type": "HTTP/2 Headers Object",
+                      "desc": "An object describing the headers"
+                    },
+                    {
+                      "textRaw": "`flags` {number} The associated numeric flags",
+                      "name": "flags",
+                      "type": "number",
+                      "desc": "The associated numeric flags"
+                    },
+                    {
+                      "textRaw": "`rawHeaders` {Array} An array containing the raw header names followed by their respective values.",
+                      "name": "rawHeaders",
+                      "type": "Array",
+                      "desc": "An array containing the raw header names followed by their respective values."
+                    }
+                  ],
+                  "desc": "<p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by\nan <code>Http2Session</code> associated with the server.</p>\n<p>See also <a href=\"#http2_event_stream\"><code>Http2Session</code>'s <code>'stream'</code> event</a>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst {\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_CONTENT_TYPE\n} = http2.constants;\n\nconst server = http2.createServer();\nserver.on('stream', (stream, headers, flags) => {\n  const method = headers[HTTP2_HEADER_METHOD];\n  const path = headers[HTTP2_HEADER_PATH];\n  // ...\n  stream.respond({\n    [HTTP2_HEADER_STATUS]: 200,\n    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8'\n  });\n  stream.write('hello ');\n  stream.end('world');\n});\n</code></pre>"
                 },
                 {
                   "textRaw": "Event: `'timeout'`",
@@ -1990,10 +2010,16 @@
                     "added": [
                       "v8.4.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v13.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/27558",
+                        "description": "The default timeout changed from 120s to 0 (no timeout)."
+                      }
+                    ]
                   },
                   "params": [],
-                  "desc": "<p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for\na given number of milliseconds set using <code>http2server.setTimeout()</code>.\n<strong>Default:</strong> 2 minutes.</p>\n<p>To change the default timeout use the <a href=\"cli.html#cli_http_server_default_timeout_milliseconds\"><code>--http-server-default-timeout</code></a>\nflag.</p>"
+                  "desc": "<p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for\na given number of milliseconds set using <code>http2server.setTimeout()</code>.\n<strong>Default:</strong> 0 (no timeout)</p>"
                 }
               ],
               "methods": [
@@ -2028,7 +2054,13 @@
                     "added": [
                       "v8.4.0"
                     ],
-                    "changes": []
+                    "changes": [
+                      {
+                        "version": "v13.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/27558",
+                        "description": "The default timeout changed from 120s to 0 (no timeout)."
+                      }
+                    ]
                   },
                   "signatures": [
                     {
@@ -2039,10 +2071,10 @@
                       },
                       "params": [
                         {
-                          "textRaw": "`msecs` {number} **Default:** `120000` (2 minutes)",
+                          "textRaw": "`msecs` {number} **Default:** 0 (no timeout)",
                           "name": "msecs",
                           "type": "number",
-                          "default": "`120000` (2 minutes)"
+                          "default": "0 (no timeout)"
                         },
                         {
                           "textRaw": "`callback` {Function}",
@@ -2052,29 +2084,110 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Used to set the timeout value for http2 server requests,\nand sets a callback function that is called when there is no activity\non the <code>Http2Server</code> after <code>msecs</code> milliseconds.</p>\n<p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>\n<p>In case of no callback function were assigned, a new <code>ERR_INVALID_CALLBACK</code>\nerror will be thrown.</p>\n<p>To change the default timeout use the <a href=\"cli.html#cli_http_server_default_timeout_milliseconds\"><code>--http-server-default-timeout</code></a>\nflag.</p>"
+                  "desc": "<p>Used to set the timeout value for http2 server requests,\nand sets a callback function that is called when there is no activity\non the <code>Http2Server</code> after <code>msecs</code> milliseconds.</p>\n<p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>\n<p>In case if <code>callback</code> is not a function, a new <code>ERR_INVALID_CALLBACK</code>\nerror will be thrown.</p>"
+                },
+                {
+                  "textRaw": "`server.updateSettings([settings])`",
+                  "type": "method",
+                  "name": "updateSettings",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`settings` {HTTP/2 Settings Object}",
+                          "name": "settings",
+                          "type": "HTTP/2 Settings Object"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Used to update the server with the provided settings.</p>\n<p>Throws <code>ERR_HTTP2_INVALID_SETTING_VALUE</code> for invalid <code>settings</code> values.</p>\n<p>Throws <code>ERR_INVALID_ARG_TYPE</code> for invalid <code>settings</code> argument.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`timeout` {number} Timeout in milliseconds. **Default:** 0 (no timeout)",
+                  "type": "number",
+                  "name": "timeout",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "changes": [
+                      {
+                        "version": "v13.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/27558",
+                        "description": "The default timeout changed from 120s to 0 (no timeout)."
+                      }
+                    ]
+                  },
+                  "default": "0 (no timeout)",
+                  "desc": "<p>The number of milliseconds of inactivity before a socket is presumed\nto have timed out.</p>\n<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>\n<p>The socket timeout logic is set up on connection, so changing this\nvalue only affects new connections to the server, not any existing connections.</p>",
+                  "shortDesc": "Timeout in milliseconds."
                 }
               ]
             },
             {
-              "textRaw": "Event: `'connection'`",
-              "type": "event",
-              "name": "connection",
+              "textRaw": "Class: `Http2SecureServer`",
+              "type": "class",
+              "name": "Http2SecureServer",
               "meta": {
                 "added": [
                   "v8.4.0"
                 ],
                 "changes": []
               },
-              "params": [
-                {
-                  "textRaw": "`socket` {stream.Duplex}",
-                  "name": "socket",
-                  "type": "stream.Duplex"
-                }
-              ],
-              "desc": "<p>This event is emitted when a new TCP stream is established, before the TLS\nhandshake begins. <code>socket</code> is typically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.\nUsually users will not want to access this event.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>",
+              "desc": "<ul>\n<li>Extends: <a href=\"tls.html#tls_class_tls_server\" class=\"type\">&lt;tls.Server&gt;</a></li>\n</ul>\n<p>Instances of <code>Http2SecureServer</code> are created using the\n<code>http2.createSecureServer()</code> function. The <code>Http2SecureServer</code> class is not\nexported directly by the <code>http2</code> module.</p>",
               "events": [
+                {
+                  "textRaw": "Event: `'checkContinue'`",
+                  "type": "event",
+                  "name": "checkContinue",
+                  "meta": {
+                    "added": [
+                      "v8.5.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`request` {http2.Http2ServerRequest}",
+                      "name": "request",
+                      "type": "http2.Http2ServerRequest"
+                    },
+                    {
+                      "textRaw": "`response` {http2.Http2ServerResponse}",
+                      "name": "response",
+                      "type": "http2.Http2ServerResponse"
+                    }
+                  ],
+                  "desc": "<p>If a <a href=\"#http2_event_request\"><code>'request'</code></a> listener is registered or <a href=\"#http2_http2_createsecureserver_options_onrequesthandler\"><code>http2.createSecureServer()</code></a>\nis supplied a callback function, the <code>'checkContinue'</code> event is emitted each\ntime a request with an HTTP <code>Expect: 100-continue</code> is received. If this event\nis not listened for, the server will automatically respond with a status\n<code>100 Continue</code> as appropriate.</p>\n<p>Handling this event involves calling <a href=\"#http2_response_writecontinue\"><code>response.writeContinue()</code></a> if the\nclient should continue to send the request body, or generating an appropriate\nHTTP response (e.g. 400 Bad Request) if the client should not continue to send\nthe request body.</p>\n<p>When this event is emitted and handled, the <a href=\"#http2_event_request\"><code>'request'</code></a> event will\nnot be emitted.</p>"
+                },
+                {
+                  "textRaw": "Event: `'connection'`",
+                  "type": "event",
+                  "name": "connection",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "changes": []
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`socket` {stream.Duplex}",
+                      "name": "socket",
+                      "type": "stream.Duplex"
+                    }
+                  ],
+                  "desc": "<p>This event is emitted when a new TCP stream is established, before the TLS\nhandshake begins. <code>socket</code> is typically an object of type <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>.\nUsually users will not want to access this event.</p>\n<p>This event can also be explicitly emitted by users to inject connections\ninto the HTTP server. In that case, any <a href=\"stream.html#stream_class_stream_duplex\"><code>Duplex</code></a> stream can be passed.</p>"
+                },
                 {
                   "textRaw": "Event: `'request'`",
                   "type": "event",
@@ -2135,8 +2248,33 @@
                     ],
                     "changes": []
                   },
-                  "params": [],
-                  "desc": "<p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by\nan <code>Http2Session</code> associated with the server.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst {\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_CONTENT_TYPE\n} = http2.constants;\n\nconst options = getOptionsSomehow();\n\nconst server = http2.createSecureServer(options);\nserver.on('stream', (stream, headers, flags) => {\n  const method = headers[HTTP2_HEADER_METHOD];\n  const path = headers[HTTP2_HEADER_PATH];\n  // ...\n  stream.respond({\n    [HTTP2_HEADER_STATUS]: 200,\n    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8'\n  });\n  stream.write('hello ');\n  stream.end('world');\n});\n</code></pre>"
+                  "params": [
+                    {
+                      "textRaw": "`stream` {Http2Stream} A reference to the stream",
+                      "name": "stream",
+                      "type": "Http2Stream",
+                      "desc": "A reference to the stream"
+                    },
+                    {
+                      "textRaw": "`headers` {HTTP/2 Headers Object} An object describing the headers",
+                      "name": "headers",
+                      "type": "HTTP/2 Headers Object",
+                      "desc": "An object describing the headers"
+                    },
+                    {
+                      "textRaw": "`flags` {number} The associated numeric flags",
+                      "name": "flags",
+                      "type": "number",
+                      "desc": "The associated numeric flags"
+                    },
+                    {
+                      "textRaw": "`rawHeaders` {Array} An array containing the raw header names followed by their respective values.",
+                      "name": "rawHeaders",
+                      "type": "Array",
+                      "desc": "An array containing the raw header names followed by their respective values."
+                    }
+                  ],
+                  "desc": "<p>The <code>'stream'</code> event is emitted when a <code>'stream'</code> event has been emitted by\nan <code>Http2Session</code> associated with the server.</p>\n<p>See also <a href=\"#http2_event_stream\"><code>Http2Session</code>'s <code>'stream'</code> event</a>.</p>\n<pre><code class=\"language-js\">const http2 = require('http2');\nconst {\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_CONTENT_TYPE\n} = http2.constants;\n\nconst options = getOptionsSomehow();\n\nconst server = http2.createSecureServer(options);\nserver.on('stream', (stream, headers, flags) => {\n  const method = headers[HTTP2_HEADER_METHOD];\n  const path = headers[HTTP2_HEADER_PATH];\n  // ...\n  stream.respond({\n    [HTTP2_HEADER_STATUS]: 200,\n    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8'\n  });\n  stream.write('hello ');\n  stream.end('world');\n});\n</code></pre>"
                 },
                 {
                   "textRaw": "Event: `'timeout'`",
@@ -2221,7 +2359,52 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Used to set the timeout value for http2 secure server requests,\nand sets a callback function that is called when there is no activity\non the <code>Http2SecureServer</code> after <code>msecs</code> milliseconds.</p>\n<p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>\n<p>In case of no callback function were assigned, a new <code>ERR_INVALID_CALLBACK</code>\nerror will be thrown.</p>"
+                  "desc": "<p>Used to set the timeout value for http2 secure server requests,\nand sets a callback function that is called when there is no activity\non the <code>Http2SecureServer</code> after <code>msecs</code> milliseconds.</p>\n<p>The given callback is registered as a listener on the <code>'timeout'</code> event.</p>\n<p>In case if <code>callback</code> is not a function, a new <code>ERR_INVALID_CALLBACK</code>\nerror will be thrown.</p>"
+                },
+                {
+                  "textRaw": "`server.updateSettings([settings])`",
+                  "type": "method",
+                  "name": "updateSettings",
+                  "meta": {
+                    "added": [
+                      "v14.17.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`settings` {HTTP/2 Settings Object}",
+                          "name": "settings",
+                          "type": "HTTP/2 Settings Object"
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Used to update the server with the provided settings.</p>\n<p>Throws <code>ERR_HTTP2_INVALID_SETTING_VALUE</code> for invalid <code>settings</code> values.</p>\n<p>Throws <code>ERR_INVALID_ARG_TYPE</code> for invalid <code>settings</code> argument.</p>"
+                }
+              ],
+              "properties": [
+                {
+                  "textRaw": "`timeout` {number} Timeout in milliseconds. **Default:** 0 (no timeout)",
+                  "type": "number",
+                  "name": "timeout",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "changes": [
+                      {
+                        "version": "v13.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/27558",
+                        "description": "The default timeout changed from 120s to 0 (no timeout)."
+                      }
+                    ]
+                  },
+                  "default": "0 (no timeout)",
+                  "desc": "<p>The number of milliseconds of inactivity before a socket is presumed\nto have timed out.</p>\n<p>A value of <code>0</code> will disable the timeout behavior on incoming connections.</p>\n<p>The socket timeout logic is set up on connection, so changing this\nvalue only affects new connections to the server, not any existing connections.</p>",
+                  "shortDesc": "Timeout in milliseconds."
                 }
               ]
             }
@@ -2237,32 +2420,51 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.21.0",
+                    "version": "v14.16.0",
                     "pr-url": "https://github.com/nodejs-private/node-private/pull/250",
                     "description": "Added `unknownProtocolTimeout` option with a default of 10000."
                   },
                   {
                     "version": [
-                      "v12.18.0"
+                      "v14.4.0",
+                      "v12.18.0",
+                      "v10.21.0"
                     ],
-                    "pr-url": "https://github.com/nodejs-private/node-private/pull/206",
+                    "commit": "3948830ce6408be620b09a70bf66158623022af0",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/204",
                     "description": "Added `maxSettings` option with a default of 32."
                   },
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30534",
                     "description": "Added `maxSessionRejectedStreams` option with a default of 100."
                   },
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30534",
                     "description": "Added `maxSessionInvalidFrames` option with a default of 1000."
                   },
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29144",
+                    "description": "The `PADDING_STRATEGY_CALLBACK` has been made equivalent to providing `PADDING_STRATEGY_ALIGNED` and `selectPadding` has been removed."
+                  },
                   {
                     "version": "v12.4.0",
                     "pr-url": "https://github.com/nodejs/node/pull/27782",
                     "description": "The `options` parameter now supports `net.createServer()` options."
                   },
+                  {
+                    "version": "v9.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/15752",
+                    "description": "Added the `Http1IncomingMessage` and `Http1ServerResponse` option."
+                  },
                   {
                     "version": "v8.9.3",
                     "pr-url": "https://github.com/nodejs/node/pull/17105",
@@ -2272,11 +2474,6 @@
                     "version": "v8.9.3",
                     "pr-url": "https://github.com/nodejs/node/pull/16676",
                     "description": "Added the `maxHeaderListPairs` option with a default limit of 128 header pairs."
-                  },
-                  {
-                    "version": "v9.6.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/15752",
-                    "description": "Added the `Http1IncomingMessage` and `Http1ServerResponse` option."
                   }
                 ]
               },
@@ -2342,24 +2539,19 @@
                           "desc": "The strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.",
                           "options": [
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_NONE",
-                              "desc": "Specifies that no padding is to be applied."
+                              "desc": "No padding is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding, determined by the internal implementation, is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_MAX",
-                              "desc": "Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied."
+                              "desc": "The maximum amount of padding, determined by the internal implementation, is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding.",
-                              "name": "http2.constants.PADDING_STRATEGY_CALLBACK",
-                              "desc": "Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding."
-                            },
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes.",
                               "name": "http2.constants.PADDING_STRATEGY_ALIGNED",
-                              "desc": "Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes."
+                              "desc": "Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes."
                             }
                           ]
                         },
@@ -2384,12 +2576,6 @@
                           "default": "`100`",
                           "desc": "Sets the maximum number of rejected upon creation streams that will be tolerated before the session is closed. Each rejection is associated with an `NGHTTP2_ENHANCE_YOUR_CALM` error that should tell the peer to not open any more streams, continuing to open streams is therefore regarded as a sign of a misbehaving peer."
                         },
-                        {
-                          "textRaw": "`selectPadding` {Function} When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][].",
-                          "name": "selectPadding",
-                          "type": "Function",
-                          "desc": "When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][]."
-                        },
                         {
                           "textRaw": "`settings` {HTTP/2 Settings Object} The initial settings to send to the remote peer upon connection.",
                           "name": "settings",
@@ -2459,27 +2645,41 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.21.0",
+                    "version": "v14.16.0",
                     "pr-url": "https://github.com/nodejs-private/node-private/pull/250",
                     "description": "Added `unknownProtocolTimeout` option with a default of 10000."
                   },
                   {
                     "version": [
-                      "v12.18.0"
+                      "v14.4.0",
+                      "v12.18.0",
+                      "v10.21.0"
                     ],
-                    "pr-url": "https://github.com/nodejs-private/node-private/pull/206",
+                    "commit": "3948830ce6408be620b09a70bf66158623022af0",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/204",
                     "description": "Added `maxSettings` option with a default of 32."
                   },
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30534",
                     "description": "Added `maxSessionRejectedStreams` option with a default of 100."
                   },
                   {
-                    "version": "v12.16.0",
+                    "version": [
+                      "v13.3.0",
+                      "v12.16.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/30534",
                     "description": "Added `maxSessionInvalidFrames` option with a default of 1000."
                   },
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29144",
+                    "description": "The `PADDING_STRATEGY_CALLBACK` has been made equivalent to providing `PADDING_STRATEGY_ALIGNED` and `selectPadding` has been removed."
+                  },
                   {
                     "version": "v10.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22956",
@@ -2566,24 +2766,19 @@
                           "desc": "Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.",
                           "options": [
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_NONE",
-                              "desc": "Specifies that no padding is to be applied."
+                              "desc": "No padding is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding, determined by the internal implementation, is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_MAX",
-                              "desc": "Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied."
+                              "desc": "The maximum amount of padding, determined by the internal implementation, is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding.",
-                              "name": "http2.constants.PADDING_STRATEGY_CALLBACK",
-                              "desc": "Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding."
-                            },
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes.",
                               "name": "http2.constants.PADDING_STRATEGY_ALIGNED",
-                              "desc": "Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes."
+                              "desc": "Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes."
                             }
                           ]
                         },
@@ -2608,12 +2803,6 @@
                           "default": "`100`",
                           "desc": "Sets the maximum number of rejected upon creation streams that will be tolerated before the session is closed. Each rejection is associated with an `NGHTTP2_ENHANCE_YOUR_CALM` error that should tell the peer to not open any more streams, continuing to open streams is therefore regarded as a sign of a misbehaving peer."
                         },
-                        {
-                          "textRaw": "`selectPadding` {Function} When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][].",
-                          "name": "selectPadding",
-                          "type": "Function",
-                          "desc": "When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][]."
-                        },
                         {
                           "textRaw": "`settings` {HTTP/2 Settings Object} The initial settings to send to the remote peer upon connection.",
                           "name": "settings",
@@ -2661,17 +2850,25 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.21.0",
+                    "version": "v14.16.0",
                     "pr-url": "https://github.com/nodejs-private/node-private/pull/250",
                     "description": "Added `unknownProtocolTimeout` option with a default of 10000."
                   },
                   {
                     "version": [
-                      "v12.18.0"
+                      "v14.4.0",
+                      "v12.18.0",
+                      "v10.21.0"
                     ],
-                    "pr-url": "https://github.com/nodejs-private/node-private/pull/206",
+                    "commit": "3948830ce6408be620b09a70bf66158623022af0",
+                    "pr-url": "https://github.com/nodejs-private/node-private/pull/204",
                     "description": "Added `maxSettings` option with a default of 32."
                   },
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/29144",
+                    "description": "The `PADDING_STRATEGY_CALLBACK` has been made equivalent to providing `PADDING_STRATEGY_ALIGNED` and `selectPadding` has been removed."
+                  },
                   {
                     "version": "v8.9.3",
                     "pr-url": "https://github.com/nodejs/node/pull/17105",
@@ -2759,24 +2956,19 @@
                           "desc": "Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.",
                           "options": [
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_NONE",
-                              "desc": "Specifies that no padding is to be applied."
+                              "desc": "No padding is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding, determined by the internal implementation, is applied.",
                               "name": "http2.constants.PADDING_STRATEGY_MAX",
-                              "desc": "Specifies that the maximum amount of padding, as determined by the internal implementation, is to be applied."
-                            },
-                            {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding.",
-                              "name": "http2.constants.PADDING_STRATEGY_CALLBACK",
-                              "desc": "Specifies that the user provided `options.selectPadding()` callback is to be used to determine the amount of padding."
+                              "desc": "The maximum amount of padding, determined by the internal implementation, is applied."
                             },
                             {
-                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes.",
+                              "textRaw": "`http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes.",
                               "name": "http2.constants.PADDING_STRATEGY_ALIGNED",
-                              "desc": "Will *attempt* to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, however, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum will be used and the total frame length will *not* necessarily be aligned at 8 bytes."
+                              "desc": "Attempts to apply enough padding to ensure that the total frame length, including the 9-byte header, is a multiple of 8. For each frame, there is a maximum allowed number of padding bytes that is determined by current flow control state and settings. If this maximum is less than the calculated amount needed to ensure alignment, the maximum is used and the total frame length is not necessarily aligned at 8 bytes."
                             }
                           ]
                         },
@@ -2787,12 +2979,6 @@
                           "default": "`100`",
                           "desc": "Sets the maximum number of concurrent streams for the remote peer as if a `SETTINGS` frame had been received. Will be overridden if the remote peer sets its own value for `maxConcurrentStreams`."
                         },
-                        {
-                          "textRaw": "`selectPadding` {Function} When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][].",
-                          "name": "selectPadding",
-                          "type": "Function",
-                          "desc": "When `options.paddingStrategy` is equal to `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function used to determine the padding. See [Using `options.selectPadding()`][]."
-                        },
                         {
                           "textRaw": "`protocol` {string} The protocol to connect with, if not set in the `authority`. Value may be either `'http:'` or `'https:'`. **Default:** `'https:'`",
                           "name": "protocol",
@@ -2906,9 +3092,9 @@
                   },
                   "params": [
                     {
-                      "textRaw": "`buf` {Buffer|Uint8Array} The packed settings.",
+                      "textRaw": "`buf` {Buffer|TypedArray} The packed settings.",
                       "name": "buf",
-                      "type": "Buffer|Uint8Array",
+                      "type": "Buffer|TypedArray",
                       "desc": "The packed settings."
                     }
                   ]
@@ -2931,11 +3117,23 @@
                 {
                   "textRaw": "Error codes for `RST_STREAM` and `GOAWAY`",
                   "name": "error_codes_for_`rst_stream`_and_`goaway`",
-                  "desc": "<p><a id=\"error_codes\"></a></p>\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Name</th>\n<th>Constant</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>0x00</code></td>\n<td>No Error</td>\n<td><code>http2.constants.NGHTTP2_NO_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x01</code></td>\n<td>Protocol Error</td>\n<td><code>http2.constants.NGHTTP2_PROTOCOL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x02</code></td>\n<td>Internal Error</td>\n<td><code>http2.constants.NGHTTP2_INTERNAL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x03</code></td>\n<td>Flow Control Error</td>\n<td><code>http2.constants.NGHTTP2_FLOW_CONTROL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x04</code></td>\n<td>Settings Timeout</td>\n<td><code>http2.constants.NGHTTP2_SETTINGS_TIMEOUT</code></td>\n</tr>\n<tr>\n<td><code>0x05</code></td>\n<td>Stream Closed</td>\n<td><code>http2.constants.NGHTTP2_STREAM_CLOSED</code></td>\n</tr>\n<tr>\n<td><code>0x06</code></td>\n<td>Frame Size Error</td>\n<td><code>http2.constants.NGHTTP2_FRAME_SIZE_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x07</code></td>\n<td>Refused Stream</td>\n<td><code>http2.constants.NGHTTP2_REFUSED_STREAM</code></td>\n</tr>\n<tr>\n<td><code>0x08</code></td>\n<td>Cancel</td>\n<td><code>http2.constants.NGHTTP2_CANCEL</code></td>\n</tr>\n<tr>\n<td><code>0x09</code></td>\n<td>Compression Error</td>\n<td><code>http2.constants.NGHTTP2_COMPRESSION_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x0a</code></td>\n<td>Connect Error</td>\n<td><code>http2.constants.NGHTTP2_CONNECT_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x0b</code></td>\n<td>Enhance Your Calm</td>\n<td><code>http2.constants.NGHTTP2_ENHANCE_YOUR_CALM</code></td>\n</tr>\n<tr>\n<td><code>0x0c</code></td>\n<td>Inadequate Security</td>\n<td><code>http2.constants.NGHTTP2_INADEQUATE_SECURITY</code></td>\n</tr>\n<tr>\n<td><code>0x0d</code></td>\n<td>HTTP/1.1 Required</td>\n<td><code>http2.constants.NGHTTP2_HTTP_1_1_REQUIRED</code></td>\n</tr>\n</tbody>\n</table>\n<p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for\na given number of milliseconds set using <code>http2server.setTimeout()</code>.</p>",
+                  "desc": "<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Name</th>\n<th>Constant</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>0x00</code></td>\n<td>No Error</td>\n<td><code>http2.constants.NGHTTP2_NO_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x01</code></td>\n<td>Protocol Error</td>\n<td><code>http2.constants.NGHTTP2_PROTOCOL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x02</code></td>\n<td>Internal Error</td>\n<td><code>http2.constants.NGHTTP2_INTERNAL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x03</code></td>\n<td>Flow Control Error</td>\n<td><code>http2.constants.NGHTTP2_FLOW_CONTROL_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x04</code></td>\n<td>Settings Timeout</td>\n<td><code>http2.constants.NGHTTP2_SETTINGS_TIMEOUT</code></td>\n</tr>\n<tr>\n<td><code>0x05</code></td>\n<td>Stream Closed</td>\n<td><code>http2.constants.NGHTTP2_STREAM_CLOSED</code></td>\n</tr>\n<tr>\n<td><code>0x06</code></td>\n<td>Frame Size Error</td>\n<td><code>http2.constants.NGHTTP2_FRAME_SIZE_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x07</code></td>\n<td>Refused Stream</td>\n<td><code>http2.constants.NGHTTP2_REFUSED_STREAM</code></td>\n</tr>\n<tr>\n<td><code>0x08</code></td>\n<td>Cancel</td>\n<td><code>http2.constants.NGHTTP2_CANCEL</code></td>\n</tr>\n<tr>\n<td><code>0x09</code></td>\n<td>Compression Error</td>\n<td><code>http2.constants.NGHTTP2_COMPRESSION_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x0a</code></td>\n<td>Connect Error</td>\n<td><code>http2.constants.NGHTTP2_CONNECT_ERROR</code></td>\n</tr>\n<tr>\n<td><code>0x0b</code></td>\n<td>Enhance Your Calm</td>\n<td><code>http2.constants.NGHTTP2_ENHANCE_YOUR_CALM</code></td>\n</tr>\n<tr>\n<td><code>0x0c</code></td>\n<td>Inadequate Security</td>\n<td><code>http2.constants.NGHTTP2_INADEQUATE_SECURITY</code></td>\n</tr>\n<tr>\n<td><code>0x0d</code></td>\n<td>HTTP/1.1 Required</td>\n<td><code>http2.constants.NGHTTP2_HTTP_1_1_REQUIRED</code></td>\n</tr>\n</tbody>\n</table>\n<p>The <code>'timeout'</code> event is emitted when there is no activity on the Server for\na given number of milliseconds set using <code>http2server.setTimeout()</code>.</p>",
                   "type": "module",
                   "displayName": "Error codes for `RST_STREAM` and `GOAWAY`"
                 }
               ]
+            },
+            {
+              "textRaw": "`sensitiveHeaders` {symbol}",
+              "type": "symbol",
+              "name": "sensitiveHeaders",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>This symbol can be set as a property on the HTTP/2 headers object with an array\nvalue in order to provide a list of headers considered sensitive.\nSee <a href=\"#http2_sensitive_headers\">Sensitive headers</a> for more details.</p>"
             }
           ],
           "type": "module",
@@ -3031,6 +3229,23 @@
                   },
                   "desc": "<p>The <code>request.complete</code> property will be <code>true</code> if the request has\nbeen completed, aborted, or destroyed.</p>"
                 },
+                {
+                  "textRaw": "`connection` {net.Socket|tls.TLSSocket}",
+                  "type": "net.Socket|tls.TLSSocket",
+                  "name": "connection",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "deprecated": [
+                      "v13.0.0"
+                    ],
+                    "changes": []
+                  },
+                  "stability": 0,
+                  "stabilityText": "Deprecated. Use [`request.socket`][].",
+                  "desc": "<p>See <a href=\"#http2_request_socket\"><code>request.socket</code></a>.</p>"
+                },
                 {
                   "textRaw": "`headers` {Object}",
                   "type": "Object",
@@ -3149,7 +3364,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Request URL string. This contains only the URL that is present in the actual\nHTTP request. If the request is:</p>\n<pre><code class=\"language-http\">GET /status?name=ryan HTTP/1.1\nAccept: text/plain\n</code></pre>\n<p>Then <code>request.url</code> will be:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">'/status?name=ryan'\n</code></pre>\n<p>To parse the url into its parts, <code>require('url').parse(request.url)</code>\ncan be used:</p>\n<pre><code class=\"language-console\">$ node\n> require('url').parse('/status?name=ryan')\nUrl {\n  protocol: null,\n  slashes: null,\n  auth: null,\n  host: null,\n  port: null,\n  hostname: null,\n  hash: null,\n  search: '?name=ryan',\n  query: 'name=ryan',\n  pathname: '/status',\n  path: '/status?name=ryan',\n  href: '/status?name=ryan' }\n</code></pre>\n<p>To obtain the parameters from the query string, use the\n<code>require('querystring').parse()</code> function or pass\n<code>true</code> as the second argument to <code>require('url').parse()</code>.</p>\n<pre><code class=\"language-console\">$ node\n> require('url').parse('/status?name=ryan', true)\nUrl {\n  protocol: null,\n  slashes: null,\n  auth: null,\n  host: null,\n  port: null,\n  hostname: null,\n  hash: null,\n  search: '?name=ryan',\n  query: { name: 'ryan' },\n  pathname: '/status',\n  path: '/status?name=ryan',\n  href: '/status?name=ryan' }\n</code></pre>"
+                  "desc": "<p>Request URL string. This contains only the URL that is present in the actual\nHTTP request. If the request is:</p>\n<pre><code class=\"language-http\">GET /status?name=ryan HTTP/1.1\nAccept: text/plain\n</code></pre>\n<p>Then <code>request.url</code> will be:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">'/status?name=ryan'\n</code></pre>\n<p>To parse the url into its parts, <code>new URL()</code> can be used:</p>\n<pre><code class=\"language-console\">$ node\n> new URL('/status?name=ryan', 'http://example.com')\nURL {\n  href: 'http://example.com/status?name=ryan',\n  origin: 'http://example.com',\n  protocol: 'http:',\n  username: '',\n  password: '',\n  host: 'example.com',\n  hostname: 'example.com',\n  port: '',\n  pathname: '/status',\n  search: '?name=ryan',\n  searchParams: URLSearchParams { 'name' => 'ryan' },\n  hash: ''\n}\n</code></pre>"
                 }
               ],
               "methods": [
@@ -3274,6 +3489,49 @@
                   ],
                   "desc": "<p>This method adds HTTP trailing headers (a header but at the end of the\nmessage) to the response.</p>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
                 },
+                {
+                  "textRaw": "`response.createPushResponse(headers, callback)`",
+                  "type": "method",
+                  "name": "createPushResponse",
+                  "meta": {
+                    "added": [
+                      "v8.4.0"
+                    ],
+                    "changes": []
+                  },
+                  "signatures": [
+                    {
+                      "params": [
+                        {
+                          "textRaw": "`headers` {HTTP/2 Headers Object} An object describing the headers",
+                          "name": "headers",
+                          "type": "HTTP/2 Headers Object",
+                          "desc": "An object describing the headers"
+                        },
+                        {
+                          "textRaw": "`callback` {Function} Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method",
+                          "name": "callback",
+                          "type": "Function",
+                          "desc": "Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method",
+                          "options": [
+                            {
+                              "textRaw": "`err` {Error}",
+                              "name": "err",
+                              "type": "Error"
+                            },
+                            {
+                              "textRaw": "`res` {http2.Http2ServerResponse} The newly-created `Http2ServerResponse` object",
+                              "name": "res",
+                              "type": "http2.Http2ServerResponse",
+                              "desc": "The newly-created `Http2ServerResponse` object"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ],
+                  "desc": "<p>Call <a href=\"#http2_http2stream_pushstream_headers_options_callback\"><code>http2stream.pushStream()</code></a> with the given headers, and wrap the\ngiven <a href=\"#http2_class_http2stream\"><code>Http2Stream</code></a> on a newly created <code>Http2ServerResponse</code> as the callback\nparameter if successful. When <code>Http2ServerRequest</code> is closed, the callback is\ncalled with an error <code>ERR_HTTP2_INVALID_STREAM</code>.</p>"
+                },
                 {
                   "textRaw": "`response.end([data[, encoding]][, callback])`",
                   "type": "method",
@@ -3567,7 +3825,10 @@
                     ],
                     "changes": [
                       {
-                        "version": "v11.10.0",
+                        "version": [
+                          "v11.10.0",
+                          "v10.17.0"
+                        ],
                         "pr-url": "https://github.com/nodejs/node/pull/25974",
                         "description": "Return `this` from `writeHead()` to allow chaining with `end()`."
                       }
@@ -3599,50 +3860,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Sends a response header to the request. The status code is a 3-digit HTTP\nstatus code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.</p>\n<p>Returns a reference to the <code>Http2ServerResponse</code>, so that calls can be chained.</p>\n<p>For compatibility with <a href=\"http.html\">HTTP/1</a>, a human-readable <code>statusMessage</code> may be\npassed as the second argument. However, because the <code>statusMessage</code> has no\nmeaning within HTTP/2, the argument will have no effect and a process warning\nwill be emitted.</p>\n<pre><code class=\"language-js\">const body = 'hello world';\nresponse.writeHead(200, {\n  'Content-Length': Buffer.byteLength(body),\n  'Content-Type': 'text/plain; charset=utf-8' });\n</code></pre>\n<p><code>Content-Length</code> is given in bytes not characters. The\n<code>Buffer.byteLength()</code> API may be used to determine the number of bytes in a\ngiven encoding. On outbound messages, Node.js does not check if Content-Length\nand the length of the body being transmitted are equal or not. However, when\nreceiving messages, Node.js will automatically reject messages when the\n<code>Content-Length</code> does not match the actual payload size.</p>\n<p>This method may be called at most one time on a message before\n<a href=\"#http2_response_end_data_encoding_callback\"><code>response.end()</code></a> is called.</p>\n<p>If <a href=\"#http2_response_write_chunk_encoding_callback\"><code>response.write()</code></a> or <a href=\"#http2_response_end_data_encoding_callback\"><code>response.end()</code></a> are called before calling\nthis, the implicit/mutable headers will be calculated and call this function.</p>\n<p>When headers have been set with <a href=\"#http2_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"#http2_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"#http2_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http2.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html; charset=utf-8');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });\n  res.end('ok');\n});\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
-                },
-                {
-                  "textRaw": "`response.createPushResponse(headers, callback)`",
-                  "type": "method",
-                  "name": "createPushResponse",
-                  "meta": {
-                    "added": [
-                      "v8.4.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "params": [
-                        {
-                          "textRaw": "`headers` {HTTP/2 Headers Object} An object describing the headers",
-                          "name": "headers",
-                          "type": "HTTP/2 Headers Object",
-                          "desc": "An object describing the headers"
-                        },
-                        {
-                          "textRaw": "`callback` {Function} Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method",
-                          "name": "callback",
-                          "type": "Function",
-                          "desc": "Called once `http2stream.pushStream()` is finished, or either when the attempt to create the pushed `Http2Stream` has failed or has been rejected, or the state of `Http2ServerRequest` is closed prior to calling the `http2stream.pushStream()` method",
-                          "options": [
-                            {
-                              "textRaw": "`err` {Error}",
-                              "name": "err",
-                              "type": "Error"
-                            },
-                            {
-                              "textRaw": "`stream` {ServerHttp2Stream} The newly-created `ServerHttp2Stream` object",
-                              "name": "stream",
-                              "type": "ServerHttp2Stream",
-                              "desc": "The newly-created `ServerHttp2Stream` object"
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  ],
-                  "desc": "<p>Call <a href=\"#http2_http2stream_pushstream_headers_options_callback\"><code>http2stream.pushStream()</code></a> with the given headers, and wrap the\ngiven <a href=\"#http2_class_http2stream\"><code>Http2Stream</code></a> on a newly created <code>Http2ServerResponse</code> as the callback\nparameter if successful. When <code>Http2ServerRequest</code> is closed, the callback is\ncalled with an error <code>ERR_HTTP2_INVALID_STREAM</code>.</p>"
+                  "desc": "<p>Sends a response header to the request. The status code is a 3-digit HTTP\nstatus code, like <code>404</code>. The last argument, <code>headers</code>, are the response headers.</p>\n<p>Returns a reference to the <code>Http2ServerResponse</code>, so that calls can be chained.</p>\n<p>For compatibility with <a href=\"http.html\">HTTP/1</a>, a human-readable <code>statusMessage</code> may be\npassed as the second argument. However, because the <code>statusMessage</code> has no\nmeaning within HTTP/2, the argument will have no effect and a process warning\nwill be emitted.</p>\n<pre><code class=\"language-js\">const body = 'hello world';\nresponse.writeHead(200, {\n  'Content-Length': Buffer.byteLength(body),\n  'Content-Type': 'text/plain; charset=utf-8',\n});\n</code></pre>\n<p><code>Content-Length</code> is given in bytes not characters. The\n<code>Buffer.byteLength()</code> API may be used to determine the number of bytes in a\ngiven encoding. On outbound messages, Node.js does not check if Content-Length\nand the length of the body being transmitted are equal or not. However, when\nreceiving messages, Node.js will automatically reject messages when the\n<code>Content-Length</code> does not match the actual payload size.</p>\n<p>This method may be called at most one time on a message before\n<a href=\"#http2_response_end_data_encoding_callback\"><code>response.end()</code></a> is called.</p>\n<p>If <a href=\"#http2_response_write_chunk_encoding_callback\"><code>response.write()</code></a> or <a href=\"#http2_response_end_data_encoding_callback\"><code>response.end()</code></a> are called before calling\nthis, the implicit/mutable headers will be calculated and call this function.</p>\n<p>When headers have been set with <a href=\"#http2_response_setheader_name_value\"><code>response.setHeader()</code></a>, they will be merged\nwith any headers passed to <a href=\"#http2_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a>, with the headers passed\nto <a href=\"#http2_response_writehead_statuscode_statusmessage_headers\"><code>response.writeHead()</code></a> given precedence.</p>\n<pre><code class=\"language-js\">// Returns content-type = text/plain\nconst server = http2.createServer((req, res) => {\n  res.setHeader('Content-Type', 'text/html; charset=utf-8');\n  res.setHeader('X-Foo', 'bar');\n  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });\n  res.end('ok');\n});\n</code></pre>\n<p>Attempting to set a header field name or value that contains invalid characters\nwill result in a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> being thrown.</p>"
                 }
               ],
               "properties": [
@@ -3654,8 +3872,13 @@
                     "added": [
                       "v8.4.0"
                     ],
+                    "deprecated": [
+                      "v13.0.0"
+                    ],
                     "changes": []
                   },
+                  "stability": 0,
+                  "stabilityText": "Deprecated. Use [`response.socket`][].",
                   "desc": "<p>See <a href=\"#http2_response_socket\"><code>response.socket</code></a>.</p>"
                 },
                 {
@@ -3667,6 +3890,7 @@
                       "v8.4.0"
                     ],
                     "deprecated": [
+                      "v13.4.0",
                       "v12.16.0"
                     ],
                     "changes": []
diff --git a/doc/api/http2.md b/doc/api/http2.md
index 0aa5cfe3caef8ddad99cc686fff435dd4f49dedf..7270d3afa8e9bbff73f2579959ec00192e48e3ef 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -2,6 +2,9 @@
 <!-- YAML
 added: v8.4.0
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/36070
+    description: It is possible to abort a request with an AbortSignal.
   - version: v10.10.0
     pr-url: https://github.com/nodejs/node/pull/22466
     description: HTTP/2 is now Stable. Previously, it had been Experimental.
@@ -515,6 +518,29 @@ added: v8.4.0
 A prototype-less object describing the current remote settings of this
 `Http2Session`. The remote settings are set by the *connected* HTTP/2 peer.
 
+#### `http2session.setLocalWindowSize(windowSize)`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `windowSize` {number}
+
+Sets the local endpoint's window size.
+The `windowSize` is the total window size to set, not
+the delta.
+
+```js
+const http2 = require('http2');
+
+const server = http2.createServer();
+const expectedWindowSize = 2 ** 20;
+server.on('connect', (session) => {
+
+  // Set local window size to be 2 ** 20
+  session.setLocalWindowSize(expectedWindowSize);
+});
+```
+
 #### `http2session.setTimeout(msecs, callback)`
 <!-- YAML
 added: v8.4.0
@@ -819,6 +845,8 @@ added: v8.4.0
     and `256` (inclusive).
   * `waitForTrailers` {boolean} When `true`, the `Http2Stream` will emit the
     `'wantTrailers'` event after the final `DATA` frame has been sent.
+  * `signal` {AbortSignal} An AbortSignal that may be used to abort an ongoing
+    request.
 
 * Returns: {ClientHttp2Stream}
 
@@ -855,6 +883,10 @@ close when the final `DATA` frame is transmitted. User code must call either
 `http2stream.sendTrailers()` or `http2stream.close()` to close the
 `Http2Stream`.
 
+When `options.signal` is set with an `AbortSignal` and then `abort` on the
+corresponding `AbortController` is called, the request will emit an `'error'`
+event with an `AbortError` error.
+
 The `:method` and `:path` pseudo-headers are not specified within `headers`,
 they respectively default to:
 
@@ -1059,7 +1091,9 @@ the `'aborted'` event will have been emitted.
 
 #### `http2stream.bufferSize`
 <!-- YAML
-added: v11.2.0
+added:
+ - v11.2.0
+ - v10.16.0
 -->
 
 * {number}
@@ -1400,7 +1434,7 @@ added: v8.4.0
   * `err` {Error}
   * `pushStream` {ServerHttp2Stream} The returned `pushStream` object.
   * `headers` {HTTP/2 Headers Object} Headers object the `pushStream` was
-  initiated with.
+    initiated with.
 
 Initiates a push stream. The callback is invoked with the new `Http2Stream`
 instance created for the push stream passed as the second argument, or an
@@ -1431,9 +1465,9 @@ and will throw an error.
 <!-- YAML
 added: v8.4.0
 changes:
-  - version: v12.19.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33160
-    description: Allow explicity setting date headers.
+    description: Allow explicitly setting date headers.
 -->
 
 * `headers` {HTTP/2 Headers Object}
@@ -1478,9 +1512,9 @@ server.on('stream', (stream) => {
 <!-- YAML
 added: v8.4.0
 changes:
-  - version: v12.19.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33160
-    description: Allow explicity setting date headers.
+    description: Allow explicitly setting date headers.
   - version: v12.12.0
     pr-url: https://github.com/nodejs/node/pull/29876
     description: The `fd` option may now be a `FileHandle`.
@@ -1579,9 +1613,9 @@ server.on('stream', (stream) => {
 <!-- YAML
 added: v8.4.0
 changes:
-  - version: v12.19.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33160
-    description: Allow explicity setting date headers.
+    description: Allow explicitly setting date headers.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/18936
     description: Any readable file, not necessarily a
@@ -1625,10 +1659,17 @@ server.on('stream', (stream) => {
   }
 
   function onError(err) {
-    if (err.code === 'ENOENT') {
-      stream.respond({ ':status': 404 });
-    } else {
-      stream.respond({ ':status': 500 });
+    // stream.respond() can throw if the stream has been destroyed by
+    // the other side.
+    try {
+      if (err.code === 'ENOENT') {
+        stream.respond({ ':status': 404 });
+      } else {
+        stream.respond({ ':status': 500 });
+      }
+    } catch (err) {
+      // Perform actual error handling.
+      console.log(err);
     }
     stream.end();
   }
@@ -1725,7 +1766,7 @@ the request body.
 When this event is emitted and handled, the [`'request'`][] event will
 not be emitted.
 
-### Event: `'connection'`
+#### Event: `'connection'`
 <!-- YAML
 added: v8.4.0
 -->
@@ -1771,9 +1812,17 @@ an `Http2Session` object associated with the `Http2Server`.
 added: v8.4.0
 -->
 
+* `stream` {Http2Stream} A reference to the stream
+* `headers` {HTTP/2 Headers Object} An object describing the headers
+* `flags` {number} The associated numeric flags
+* `rawHeaders` {Array} An array containing the raw header names followed by
+  their respective values.
+
 The `'stream'` event is emitted when a `'stream'` event has been emitted by
 an `Http2Session` associated with the server.
 
+See also [`Http2Session`'s `'stream'` event][].
+
 ```js
 const http2 = require('http2');
 const {
@@ -1800,14 +1849,15 @@ server.on('stream', (stream, headers, flags) => {
 #### Event: `'timeout'`
 <!-- YAML
 added: v8.4.0
+changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27558
+    description: The default timeout changed from 120s to 0 (no timeout).
 -->
 
 The `'timeout'` event is emitted when there is no activity on the Server for
 a given number of milliseconds set using `http2server.setTimeout()`.
-**Default:** 2 minutes.
-
-To change the default timeout use the [`--http-server-default-timeout`][]
-flag.
+**Default:** 0 (no timeout)
 
 #### `server.close([callback])`
 <!-- YAML
@@ -1828,9 +1878,13 @@ closed, although the server has already stopped allowing new sessions. See
 #### `server.setTimeout([msecs][, callback])`
 <!-- YAML
 added: v8.4.0
+changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27558
+    description: The default timeout changed from 120s to 0 (no timeout).
 -->
 
-* `msecs` {number} **Default:** `120000` (2 minutes)
+* `msecs` {number} **Default:** 0 (no timeout)
 * `callback` {Function}
 * Returns: {Http2Server}
 
@@ -1840,11 +1894,40 @@ on the `Http2Server` after `msecs` milliseconds.
 
 The given callback is registered as a listener on the `'timeout'` event.
 
-In case of no callback function were assigned, a new `ERR_INVALID_CALLBACK`
+In case if `callback` is not a function, a new `ERR_INVALID_CALLBACK`
 error will be thrown.
 
-To change the default timeout use the [`--http-server-default-timeout`][]
-flag.
+#### `server.timeout`
+<!-- YAML
+added: v8.4.0
+changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27558
+    description: The default timeout changed from 120s to 0 (no timeout).
+-->
+
+* {number} Timeout in milliseconds. **Default:** 0 (no timeout)
+
+The number of milliseconds of inactivity before a socket is presumed
+to have timed out.
+
+A value of `0` will disable the timeout behavior on incoming connections.
+
+The socket timeout logic is set up on connection, so changing this
+value only affects new connections to the server, not any existing connections.
+
+#### `server.updateSettings([settings])`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `settings` {HTTP/2 Settings Object}
+
+Used to update the server with the provided settings.
+
+Throws `ERR_HTTP2_INVALID_SETTING_VALUE` for invalid `settings` values.
+
+Throws `ERR_INVALID_ARG_TYPE` for invalid `settings` argument.
 
 ### Class: `Http2SecureServer`
 <!-- YAML
@@ -1879,7 +1962,7 @@ the request body.
 When this event is emitted and handled, the [`'request'`][] event will
 not be emitted.
 
-### Event: `'connection'`
+#### Event: `'connection'`
 <!-- YAML
 added: v8.4.0
 -->
@@ -1925,9 +2008,17 @@ an `Http2Session` object associated with the `Http2SecureServer`.
 added: v8.4.0
 -->
 
+* `stream` {Http2Stream} A reference to the stream
+* `headers` {HTTP/2 Headers Object} An object describing the headers
+* `flags` {number} The associated numeric flags
+* `rawHeaders` {Array} An array containing the raw header names followed by
+  their respective values.
+
 The `'stream'` event is emitted when a `'stream'` event has been emitted by
 an `Http2Session` associated with the server.
 
+See also [`Http2Session`'s `'stream'` event][].
+
 ```js
 const http2 = require('http2');
 const {
@@ -2005,30 +2096,78 @@ on the `Http2SecureServer` after `msecs` milliseconds.
 
 The given callback is registered as a listener on the `'timeout'` event.
 
-In case of no callback function were assigned, a new `ERR_INVALID_CALLBACK`
+In case if `callback` is not a function, a new `ERR_INVALID_CALLBACK`
 error will be thrown.
 
+#### `server.timeout`
+<!-- YAML
+added: v8.4.0
+changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27558
+    description: The default timeout changed from 120s to 0 (no timeout).
+-->
+
+* {number} Timeout in milliseconds. **Default:** 0 (no timeout)
+
+The number of milliseconds of inactivity before a socket is presumed
+to have timed out.
+
+A value of `0` will disable the timeout behavior on incoming connections.
+
+The socket timeout logic is set up on connection, so changing this
+value only affects new connections to the server, not any existing connections.
+
+#### `server.updateSettings([settings])`
+<!-- YAML
+added: v14.17.0
+-->
+
+* `settings` {HTTP/2 Settings Object}
+
+Used to update the server with the provided settings.
+
+Throws `ERR_HTTP2_INVALID_SETTING_VALUE` for invalid `settings` values.
+
+Throws `ERR_INVALID_ARG_TYPE` for invalid `settings` argument.
+
 ### `http2.createServer(options[, onRequestHandler])`
 <!-- YAML
 added: v8.4.0
 changes:
-  - version: v12.21.0
+  - version: v14.16.0
     pr-url: https://github.com/nodejs-private/node-private/pull/250
     description: Added `unknownProtocolTimeout` option with a default of 10000.
   - version:
+     - v14.4.0
      - v12.18.0
-    pr-url: https://github.com/nodejs-private/node-private/pull/206
+     - v10.21.0
+    commit: 3948830ce6408be620b09a70bf66158623022af0
+    pr-url: https://github.com/nodejs-private/node-private/pull/204
     description: Added `maxSettings` option with a default of 32.
-  - version: v12.16.0
+  - version:
+     - v13.3.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30534
     description: Added `maxSessionRejectedStreams` option with a default of 100.
-  - version: v12.16.0
+  - version:
+     - v13.3.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30534
     description: Added `maxSessionInvalidFrames` option with a default of 1000.
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/29144
+    description: The `PADDING_STRATEGY_CALLBACK` has been made equivalent to
+                 providing `PADDING_STRATEGY_ALIGNED` and `selectPadding`
+                 has been removed.
   - version: v12.4.0
     pr-url: https://github.com/nodejs/node/pull/27782
     description: The `options` parameter now supports `net.createServer()`
                  options.
+  - version: v9.6.0
+    pr-url: https://github.com/nodejs/node/pull/15752
+    description: Added the `Http1IncomingMessage` and `Http1ServerResponse`
+                 option.
   - version: v8.9.3
     pr-url: https://github.com/nodejs/node/pull/17105
     description: Added the `maxOutstandingPings` option with a default limit of
@@ -2037,10 +2176,6 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/16676
     description: Added the `maxHeaderListPairs` option with a default limit of
                  128 header pairs.
-  - version: v9.6.0
-    pr-url: https://github.com/nodejs/node/pull/15752
-    description: Added the `Http1IncomingMessage` and `Http1ServerResponse`
-                 option.
 -->
 
 * `options` {Object}
@@ -2070,21 +2205,16 @@ changes:
   * `paddingStrategy` {number} The strategy used for determining the amount of
     padding to use for `HEADERS` and `DATA` frames. **Default:**
     `http2.constants.PADDING_STRATEGY_NONE`. Value may be one of:
-    * `http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is
-      to be applied.
-    * `http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum
-      amount of padding, as determined by the internal implementation, is to
-      be applied.
-    * `http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user
-      provided `options.selectPadding()` callback is to be used to determine
-      the amount of padding.
-    * `http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply
-      enough padding to ensure that the total frame length, including the
-      9-byte header, is a multiple of 8. For each frame, however, there is a
-      maximum allowed number of padding bytes that is determined by current
-      flow control state and settings. If this maximum is less than the
-      calculated amount needed to ensure alignment, the maximum will be used
-      and the total frame length will *not* necessarily be aligned at 8 bytes.
+    * `http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.
+    * `http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding,
+      determined by the internal implementation, is applied.
+    * `http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough
+      padding to ensure that the total frame length, including the 9-byte
+      header, is a multiple of 8. For each frame, there is a maximum allowed
+      number of padding bytes that is determined by current flow control state
+      and settings. If this maximum is less than the calculated amount needed to
+      ensure alignment, the maximum is used and the total frame length is not
+      necessarily aligned at 8 bytes.
   * `peerMaxConcurrentStreams` {number} Sets the maximum number of concurrent
     streams for the remote peer as if a `SETTINGS` frame had been received. Will
     be overridden if the remote peer sets its own value for
@@ -2098,9 +2228,6 @@ changes:
     error that should tell the peer to not open any more streams, continuing
     to open streams is therefore regarded as a sign of a misbehaving peer.
     **Default:** `100`.
-  * `selectPadding` {Function} When `options.paddingStrategy` is equal to
-    `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function
-    used to determine the padding. See [Using `options.selectPadding()`][].
   * `settings` {HTTP/2 Settings Object} The initial settings to send to the
     remote peer upon connection.
   * `Http1IncomingMessage` {http.IncomingMessage} Specifies the
@@ -2157,19 +2284,31 @@ server.listen(80);
 <!-- YAML
 added: v8.4.0
 changes:
-  - version: v12.21.0
+  - version: v14.16.0
     pr-url: https://github.com/nodejs-private/node-private/pull/250
     description: Added `unknownProtocolTimeout` option with a default of 10000.
   - version:
+     - v14.4.0
      - v12.18.0
-    pr-url: https://github.com/nodejs-private/node-private/pull/206
+     - v10.21.0
+    commit: 3948830ce6408be620b09a70bf66158623022af0
+    pr-url: https://github.com/nodejs-private/node-private/pull/204
     description: Added `maxSettings` option with a default of 32.
-  - version: v12.16.0
+  - version:
+     - v13.3.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30534
     description: Added `maxSessionRejectedStreams` option with a default of 100.
-  - version: v12.16.0
+  - version:
+     - v13.3.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30534
     description: Added `maxSessionInvalidFrames` option with a default of 1000.
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/29144
+    description: The `PADDING_STRATEGY_CALLBACK` has been made equivalent to
+                 providing `PADDING_STRATEGY_ALIGNED` and `selectPadding`
+                 has been removed.
   - version: v10.12.0
     pr-url: https://github.com/nodejs/node/pull/22956
     description: Added the `origins` option to automatically send an `ORIGIN`
@@ -2215,21 +2354,16 @@ changes:
   * `paddingStrategy` {number} Strategy used for determining the amount of
     padding to use for `HEADERS` and `DATA` frames. **Default:**
     `http2.constants.PADDING_STRATEGY_NONE`. Value may be one of:
-    * `http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is
-      to be applied.
-    * `http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum
-      amount of padding, as determined by the internal implementation, is to
-      be applied.
-    * `http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user
-      provided `options.selectPadding()` callback is to be used to determine
-      the amount of padding.
-    * `http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply
-      enough padding to ensure that the total frame length, including the
-      9-byte header, is a multiple of 8. For each frame, however, there is a
-      maximum allowed number of padding bytes that is determined by current
-      flow control state and settings. If this maximum is less than the
-      calculated amount needed to ensure alignment, the maximum will be used
-      and the total frame length will *not* necessarily be aligned at 8 bytes.
+    * `http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.
+    * `http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding,
+      determined by the internal implementation, is applied.
+    * `http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough
+      padding to ensure that the total frame length, including the
+      9-byte header, is a multiple of 8. For each frame, there is a maximum
+      allowed number of padding bytes that is determined by current flow control
+      state and settings. If this maximum is less than the calculated amount
+      needed to ensure alignment, the maximum is used and the total frame length
+      is not necessarily aligned at 8 bytes.
   * `peerMaxConcurrentStreams` {number} Sets the maximum number of concurrent
     streams for the remote peer as if a `SETTINGS` frame had been received. Will
     be overridden if the remote peer sets its own value for
@@ -2243,9 +2377,6 @@ changes:
     error that should tell the peer to not open any more streams, continuing
     to open streams is therefore regarded as a sign of a misbehaving peer.
     **Default:** `100`.
-  * `selectPadding` {Function} When `options.paddingStrategy` is equal to
-    `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function
-    used to determine the padding. See [Using `options.selectPadding()`][].
   * `settings` {HTTP/2 Settings Object} The initial settings to send to the
     remote peer upon connection.
   * ...: Any [`tls.createServer()`][] options can be provided. For
@@ -2289,13 +2420,21 @@ server.listen(80);
 <!-- YAML
 added: v8.4.0
 changes:
-  - version: v12.21.0
+  - version: v14.16.0
     pr-url: https://github.com/nodejs-private/node-private/pull/250
     description: Added `unknownProtocolTimeout` option with a default of 10000.
   - version:
+     - v14.4.0
      - v12.18.0
-    pr-url: https://github.com/nodejs-private/node-private/pull/206
+     - v10.21.0
+    commit: 3948830ce6408be620b09a70bf66158623022af0
+    pr-url: https://github.com/nodejs-private/node-private/pull/204
     description: Added `maxSettings` option with a default of 32.
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/29144
+    description: The `PADDING_STRATEGY_CALLBACK` has been made equivalent to
+                 providing `PADDING_STRATEGY_ALIGNED` and `selectPadding`
+                 has been removed.
   - version: v8.9.3
     pr-url: https://github.com/nodejs/node/pull/17105
     description: Added the `maxOutstandingPings` option with a default limit of
@@ -2344,28 +2483,20 @@ changes:
   * `paddingStrategy` {number} Strategy used for determining the amount of
     padding to use for `HEADERS` and `DATA` frames. **Default:**
     `http2.constants.PADDING_STRATEGY_NONE`. Value may be one of:
-    * `http2.constants.PADDING_STRATEGY_NONE`: Specifies that no padding is
-      to be applied.
-    * `http2.constants.PADDING_STRATEGY_MAX`: Specifies that the maximum
-      amount of padding, as determined by the internal implementation, is to
-      be applied.
-    * `http2.constants.PADDING_STRATEGY_CALLBACK`: Specifies that the user
-      provided `options.selectPadding()` callback is to be used to determine
-      the amount of padding.
-    * `http2.constants.PADDING_STRATEGY_ALIGNED`: Will *attempt* to apply
-      enough padding to ensure that the total frame length, including the
-      9-byte header, is a multiple of 8. For each frame, however, there is a
-      maximum allowed number of padding bytes that is determined by current
-      flow control state and settings. If this maximum is less than the
-      calculated amount needed to ensure alignment, the maximum will be used
-      and the total frame length will *not* necessarily be aligned at 8 bytes.
+    * `http2.constants.PADDING_STRATEGY_NONE`: No padding is applied.
+    * `http2.constants.PADDING_STRATEGY_MAX`: The maximum amount of padding,
+      determined by the internal implementation, is applied.
+    * `http2.constants.PADDING_STRATEGY_ALIGNED`: Attempts to apply enough
+      padding to ensure that the total frame length, including the
+      9-byte header, is a multiple of 8. For each frame, there is a maximum
+      allowed number of padding bytes that is determined by current flow control
+      state and settings. If this maximum is less than the calculated amount
+      needed to ensure alignment, the maximum is used and the total frame length
+      is not necessarily aligned at 8 bytes.
   * `peerMaxConcurrentStreams` {number} Sets the maximum number of concurrent
     streams for the remote peer as if a `SETTINGS` frame had been received. Will
     be overridden if the remote peer sets its own value for
     `maxConcurrentStreams`. **Default:** `100`.
-  * `selectPadding` {Function} When `options.paddingStrategy` is equal to
-    `http2.constants.PADDING_STRATEGY_CALLBACK`, provides the callback function
-    used to determine the padding. See [Using `options.selectPadding()`][].
   * `protocol` {string} The protocol to connect with, if not set in the
     `authority`. Value may be either `'http:'` or `'https:'`. **Default:**
     `'https:'`
@@ -2400,7 +2531,6 @@ added: v8.4.0
 -->
 
 #### Error codes for `RST_STREAM` and `GOAWAY`
-<a id="error_codes"></a>
 
 | Value  | Name                | Constant                                      |
 |--------|---------------------|-----------------------------------------------|
@@ -2459,12 +2589,23 @@ console.log(packed.toString('base64'));
 added: v8.4.0
 -->
 
-* `buf` {Buffer|Uint8Array} The packed settings.
+* `buf` {Buffer|TypedArray} The packed settings.
 * Returns: {HTTP/2 Settings Object}
 
 Returns a [HTTP/2 Settings Object][] containing the deserialized settings from
 the given `Buffer` as generated by `http2.getPackedSettings()`.
 
+### `http2.sensitiveHeaders`
+<!-- YAML
+added: v14.18.0
+-->
+
+* {symbol}
+
+This symbol can be set as a property on the HTTP/2 headers object with an array
+value in order to provide a list of headers considered sensitive.
+See [Sensitive headers][] for more details.
+
 ### Headers object
 
 Headers are represented as own-properties on JavaScript objects. The property
@@ -2513,6 +2654,32 @@ server.on('stream', (stream, headers) => {
 });
 ```
 
+#### Sensitive headers
+
+HTTP2 headers can be marked as sensitive, which means that the HTTP/2
+header compression algorithm will never index them. This can make sense for
+header values with low entropy and that may be considered valuable to an
+attacker, for example `Cookie` or `Authorization`. To achieve this, add
+the header name to the `[http2.sensitiveHeaders]` property as an array:
+
+```js
+const headers = {
+  ':status': '200',
+  'content-type': 'text-plain',
+  'cookie': 'some-cookie',
+  'other-sensitive-header': 'very secret data',
+  [http2.sensitiveHeaders]: ['cookie', 'other-sensitive-header']
+};
+
+stream.respond(headers);
+```
+
+For some headers, such as `Authorization` and short `Cookie` headers,
+this flag is set automatically.
+
+This property is also set for received headers. It will contain the names of
+all headers marked as sensitive, including ones marked that way automatically.
+
 ### Settings object
 <!-- YAML
 added: v8.4.0
@@ -2561,30 +2728,6 @@ properties.
 
 All additional properties on the settings object are ignored.
 
-### Using `options.selectPadding()`
-
-When `options.paddingStrategy` is equal to
-`http2.constants.PADDING_STRATEGY_CALLBACK`, the HTTP/2 implementation will
-consult the `options.selectPadding()` callback function, if provided, to
-determine the specific amount of padding to use per `HEADERS` and `DATA` frame.
-
-The `options.selectPadding()` function receives two numeric arguments,
-`frameLen` and `maxFrameLen` and must return a number `N` such that
-`frameLen <= N <= maxFrameLen`.
-
-```js
-const http2 = require('http2');
-const server = http2.createServer({
-  paddingStrategy: http2.constants.PADDING_STRATEGY_CALLBACK,
-  selectPadding(frameLen, maxFrameLen) {
-    return maxFrameLen;
-  }
-});
-```
-
-The `options.selectPadding()` function is invoked once for *every* `HEADERS` and
-`DATA` frame. This has a definite noticeable impact on performance.
-
 ### Error handling
 
 There are several types of error conditions that may arise when using the
@@ -2884,6 +3027,18 @@ added: v12.10.0
 The `request.complete` property will be `true` if the request has
 been completed, aborted, or destroyed.
 
+#### `request.connection`
+<!-- YAML
+added: v8.4.0
+deprecated: v13.0.0
+-->
+
+> Stability: 0 - Deprecated. Use [`request.socket`][].
+
+* {net.Socket|tls.TLSSocket}
+
+See [`request.socket`][].
+
 #### `request.destroy([error])`
 <!-- YAML
 added: v8.4.0
@@ -3086,47 +3241,25 @@ Then `request.url` will be:
 '/status?name=ryan'
 ```
 
-To parse the url into its parts, `require('url').parse(request.url)`
-can be used:
+To parse the url into its parts, `new URL()` can be used:
 
 ```console
 $ node
-> require('url').parse('/status?name=ryan')
-Url {
-  protocol: null,
-  slashes: null,
-  auth: null,
-  host: null,
-  port: null,
-  hostname: null,
-  hash: null,
-  search: '?name=ryan',
-  query: 'name=ryan',
+> new URL('/status?name=ryan', 'http://example.com')
+URL {
+  href: 'http://example.com/status?name=ryan',
+  origin: 'http://example.com',
+  protocol: 'http:',
+  username: '',
+  password: '',
+  host: 'example.com',
+  hostname: 'example.com',
+  port: '',
   pathname: '/status',
-  path: '/status?name=ryan',
-  href: '/status?name=ryan' }
-```
-
-To obtain the parameters from the query string, use the
-`require('querystring').parse()` function or pass
-`true` as the second argument to `require('url').parse()`.
-
-```console
-$ node
-> require('url').parse('/status?name=ryan', true)
-Url {
-  protocol: null,
-  slashes: null,
-  auth: null,
-  host: null,
-  port: null,
-  hostname: null,
-  hash: null,
   search: '?name=ryan',
-  query: { name: 'ryan' },
-  pathname: '/status',
-  path: '/status?name=ryan',
-  href: '/status?name=ryan' }
+  searchParams: URLSearchParams { 'name' => 'ryan' },
+  hash: ''
+}
 ```
 
 ### Class: `http2.Http2ServerResponse`
@@ -3175,12 +3308,34 @@ will result in a [`TypeError`][] being thrown.
 #### `response.connection`
 <!-- YAML
 added: v8.4.0
+deprecated: v13.0.0
 -->
 
+> Stability: 0 - Deprecated. Use [`response.socket`][].
+
 * {net.Socket|tls.TLSSocket}
 
 See [`response.socket`][].
 
+#### `response.createPushResponse(headers, callback)`
+<!-- YAML
+added: v8.4.0
+-->
+
+* `headers` {HTTP/2 Headers Object} An object describing the headers
+* `callback` {Function} Called once `http2stream.pushStream()` is finished,
+  or either when the attempt to create the pushed `Http2Stream` has failed or
+  has been rejected, or the state of `Http2ServerRequest` is closed prior to
+  calling the `http2stream.pushStream()` method
+  * `err` {Error}
+  * `res` {http2.Http2ServerResponse} The newly-created `Http2ServerResponse`
+    object
+
+Call [`http2stream.pushStream()`][] with the given headers, and wrap the
+given [`Http2Stream`][] on a newly created `Http2ServerResponse` as the callback
+parameter if successful. When `Http2ServerRequest` is closed, the callback is
+called with an error `ERR_HTTP2_INVALID_STREAM`.
+
 #### `response.end([data[, encoding]][, callback])`
 <!-- YAML
 added: v8.4.0
@@ -3208,7 +3363,9 @@ is finished.
 #### `response.finished`
 <!-- YAML
 added: v8.4.0
-deprecated: v12.16.0
+deprecated:
+ - v13.4.0
+ - v12.16.0
 -->
 
 > Stability: 0 - Deprecated. Use [`response.writableEnded`][].
@@ -3516,7 +3673,9 @@ should be sent. See the [`'checkContinue'`][] event on `Http2Server` and
 <!-- YAML
 added: v8.4.0
 changes:
-  - version: v11.10.0
+  - version:
+     - v11.10.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/25974
     description: Return `this` from `writeHead()` to allow chaining with
                  `end()`.
@@ -3541,7 +3700,8 @@ will be emitted.
 const body = 'hello world';
 response.writeHead(200, {
   'Content-Length': Buffer.byteLength(body),
-  'Content-Type': 'text/plain; charset=utf-8' });
+  'Content-Type': 'text/plain; charset=utf-8',
+});
 ```
 
 `Content-Length` is given in bytes not characters. The
@@ -3574,24 +3734,6 @@ const server = http2.createServer((req, res) => {
 Attempting to set a header field name or value that contains invalid characters
 will result in a [`TypeError`][] being thrown.
 
-#### `response.createPushResponse(headers, callback)`
-<!-- YAML
-added: v8.4.0
--->
-
-* `headers` {HTTP/2 Headers Object} An object describing the headers
-* `callback` {Function} Called once `http2stream.pushStream()` is finished,
-  or either when the attempt to create the pushed `Http2Stream` has failed or
-  has been rejected, or the state of `Http2ServerRequest` is closed prior to
-  calling the `http2stream.pushStream()` method
-  * `err` {Error}
-  * `stream` {ServerHttp2Stream} The newly-created `ServerHttp2Stream` object
-
-Call [`http2stream.pushStream()`][] with the given headers, and wrap the
-given [`Http2Stream`][] on a newly created `Http2ServerResponse` as the callback
-parameter if successful. When `Http2ServerRequest` is closed, the callback is
-called with an error `ERR_HTTP2_INVALID_STREAM`.
-
 ## Collecting HTTP/2 performance metrics
 
 The [Performance Observer][] API can be used to collect basic performance
@@ -3652,60 +3794,61 @@ following additional properties:
 * `type` {string} Either `'server'` or `'client'` to identify the type of
   `Http2Session`.
 
-[`--http-server-default-timeout`]: cli.html#cli_http_server_default_timeout_milliseconds
 [ALPN Protocol ID]: https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
 [ALPN negotiation]: #http2_alpn_negotiation
 [Compatibility API]: #http2_compatibility_api
-[HTTP/1]: http.html
+[HTTP/1]: http.md
+[HTTP/2]: https://tools.ietf.org/html/rfc7540
 [HTTP/2 Headers Object]: #http2_headers_object
 [HTTP/2 Settings Object]: #http2_settings_object
 [HTTP/2 Unencrypted]: https://http2.github.io/faq/#does-http2-require-encryption
-[HTTP/2]: https://tools.ietf.org/html/rfc7540
-[HTTPS]: https.html
-[Performance Observer]: perf_hooks.html
+[HTTPS]: https.md
+[Performance Observer]: perf_hooks.md
 [RFC 7838]: https://tools.ietf.org/html/rfc7838
 [RFC 8336]: https://tools.ietf.org/html/rfc8336
 [RFC 8441]: https://tools.ietf.org/html/rfc8441
-[Using `options.selectPadding()`]: #http2_using_options_selectpadding
+[Sensitive headers]: #http2_sensitive_headers
 [`'checkContinue'`]: #http2_event_checkcontinue
 [`'connect'`]: #http2_event_connect
 [`'request'`]: #http2_event_request
 [`'unknownProtocol'`]: #http2_event_unknownprotocol
 [`ClientHttp2Stream`]: #http2_class_clienthttp2stream
-[`Duplex`]: stream.html#stream_class_stream_duplex
+[`Duplex`]: stream.md#stream_class_stream_duplex
 [`Http2ServerRequest`]: #http2_class_http2_http2serverrequest
 [`Http2ServerResponse`]: #http2_class_http2_http2serverresponse
 [`Http2Session` and Sockets]: #http2_http2session_and_sockets
+[`Http2Session`'s `'stream'` event]: #http2_event_stream
 [`Http2Stream`]: #http2_class_http2stream
 [`ServerHttp2Stream`]: #http2_class_serverhttp2stream
-[`TypeError`]: errors.html#errors_class_typeerror
-[`http.ClientRequest#maxHeadersCount`]: http.html#http_request_maxheaderscount
-[`http.Server#maxHeadersCount`]: http.html#http_server_maxheaderscount
+[`TypeError`]: errors.md#errors_class_typeerror
+[`http.ClientRequest#maxHeadersCount`]: http.md#http_request_maxheaderscount
+[`http.Server#maxHeadersCount`]: http.md#http_server_maxheaderscount
 [`http2.SecureServer`]: #http2_class_http2secureserver
 [`http2.Server`]: #http2_class_http2server
 [`http2.createSecureServer()`]: #http2_http2_createsecureserver_options_onrequesthandler
 [`http2.createServer()`]: #http2_http2_createserver_options_onrequesthandler
 [`http2session.close()`]: #http2_http2session_close_callback
 [`http2stream.pushStream()`]: #http2_http2stream_pushstream_headers_options_callback
-[`net.createServer()`]: net.html#net_net_createserver_options_connectionlistener
-[`net.Server.close()`]: net.html#net_server_close_callback
-[`net.Socket.bufferSize`]: net.html#net_socket_buffersize
-[`net.Socket.prototype.ref()`]: net.html#net_socket_ref
-[`net.Socket.prototype.unref()`]: net.html#net_socket_unref
-[`net.Socket`]: net.html#net_class_net_socket
-[`net.connect()`]: net.html#net_net_connect
-[`request.socket.getPeerCertificate()`]: tls.html#tls_tlssocket_getpeercertificate_detailed
+[`net.Server.close()`]: net.md#net_server_close_callback
+[`net.Socket.bufferSize`]: net.md#net_socket_buffersize
+[`net.Socket.prototype.ref()`]: net.md#net_socket_ref
+[`net.Socket.prototype.unref()`]: net.md#net_socket_unref
+[`net.Socket`]: net.md#net_class_net_socket
+[`net.connect()`]: net.md#net_net_connect
+[`net.createServer()`]: net.md#net_net_createserver_options_connectionlistener
+[`request.socket.getPeerCertificate()`]: tls.md#tls_tlssocket_getpeercertificate_detailed
+[`request.socket`]: #http2_request_socket
 [`response.end()`]: #http2_response_end_data_encoding_callback
 [`response.setHeader()`]: #http2_response_setheader_name_value
 [`response.socket`]: #http2_response_socket
 [`response.writableEnded`]: #http2_response_writableended
 [`response.write()`]: #http2_response_write_chunk_encoding_callback
-[`response.write(data, encoding)`]: http.html#http_response_write_chunk_encoding_callback
+[`response.write(data, encoding)`]: http.md#http_response_write_chunk_encoding_callback
 [`response.writeContinue()`]: #http2_response_writecontinue
 [`response.writeHead()`]: #http2_response_writehead_statuscode_statusmessage_headers
-[`tls.Server.close()`]: tls.html#tls_server_close_callback
-[`tls.TLSSocket`]: tls.html#tls_class_tls_tlssocket
-[`tls.connect()`]: tls.html#tls_tls_connect_options_callback
-[`tls.createServer()`]: tls.html#tls_tls_createserver_options_secureconnectionlistener
-[error code]: #error_codes
-[`writable.writableFinished`]: stream.html#stream_writable_writablefinished
+[`tls.Server.close()`]: tls.md#tls_server_close_callback
+[`tls.TLSSocket`]: tls.md#tls_class_tls_tlssocket
+[`tls.connect()`]: tls.md#tls_tls_connect_options_callback
+[`tls.createServer()`]: tls.md#tls_tls_createserver_options_secureconnectionlistener
+[`writable.writableFinished`]: stream.md#stream_writable_writablefinished
+[error code]: #http2_error_codes_for_rst_stream_and_goaway
diff --git a/doc/api/https.html b/doc/api/https.html
index 98a8d8942de4667613ddbf87afecde43250ebde0..89812fdb89484caa8717bf84354eefd9d754cbdd 100644
--- a/doc/api/https.html
+++ b/doc/api/https.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>HTTPS | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>HTTPS | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="https" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/https.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/https.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/https.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/https.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/https.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/https.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/https.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/https.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/https.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#https_https">HTTPS</a></span>
 <ul>
 <li><a href="#https_class_https_agent">Class: <code>https.Agent</code></a>
@@ -144,6 +157,7 @@
 <li><a href="#https_server_headerstimeout"><code>server.headersTimeout</code></a></li>
 <li><a href="#https_server_listen"><code>server.listen()</code></a></li>
 <li><a href="#https_server_maxheaderscount"><code>server.maxHeadersCount</code></a></li>
+<li><a href="#https_server_requesttimeout"><code>server.requestTimeout</code></a></li>
 <li><a href="#https_server_settimeout_msecs_callback"><code>server.setTimeout([msecs][, callback])</code></a></li>
 <li><a href="#https_server_timeout"><code>server.timeout</code></a></li>
 <li><a href="#https_server_keepalivetimeout"><code>server.keepAliveTimeout</code></a></li>
@@ -157,17 +171,16 @@
 <li><a href="#https_https_request_url_options_callback"><code>https.request(url[, options][, callback])</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>HTTPS<span><a class="mark" href="#https_https" id="https_https">#</a></span></h1>
+        <h2>HTTPS<span><a class="mark" href="#https_https" id="https_https">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/https.js">lib/https.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/https.js">lib/https.js</a></p>
 <p>HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
 separate module.</p>
-<h2>Class: <code>https.Agent</code><span><a class="mark" href="#https_class_https_agent" id="https_class_https_agent">#</a></span></h2>
+<section><h3>Class: <code>https.Agent</code><span><a class="mark" href="#https_class_https_agent" id="https_class_https_agent">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -183,7 +196,7 @@ separate module.</p>
 </div>
 <p>An <a href="#https_class_https_agent"><code>Agent</code></a> object for HTTPS similar to <a href="http.html#http_class_http_agent"><code>http.Agent</code></a>. See
 <a href="#https_https_request_options_callback"><code>https.request()</code></a> for more information.</p>
-<h3><code>new Agent([options])</code><span><a class="mark" href="#https_new_agent_options" id="https_new_agent_options">#</a></span></h3>
+<h4><code>new Agent([options])</code><span><a class="mark" href="#https_new_agent_options" id="https_new_agent_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -194,9 +207,8 @@ separate module.</p>
 </details>
 </div>
 <ul>
-<li>
-<p><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Set of configurable options to set on the agent.
-Can have the same fields as for <a href="http.html#http_new_agent_options"><code>http.Agent(options)</code></a>, and</p>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Set of configurable options to set on the agent.
+Can have the same fields as for <a href="http.html#http_new_agent_options"><code>http.Agent(options)</code></a>, and
 <ul>
 <li>
 <p><code>maxCachedSessions</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> maximum number of TLS cached sessions.
@@ -214,9 +226,9 @@ extension).</p>
 </ul>
 </li>
 </ul>
-<h4>Event: <code>'keylog'</code><span><a class="mark" href="#https_event_keylog" id="https_event_keylog">#</a></span></h4>
+<h5>Event: <code>'keylog'</code><span><a class="mark" href="#https_event_keylog" id="https_event_keylog">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>line</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> Line of ASCII text, in NSS <code>SSLKEYLOGFILE</code> format.</li>
@@ -231,10 +243,10 @@ for each socket.</p>
 <p>A typical use case is to append received lines to a common text file, which is
 later used by software (such as Wireshark) to decrypt the traffic:</p>
 <pre><code class="language-js"><span class="hljs-comment">// ...</span>
-https.globalAgent.on(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line, tlsSocket</span>) =></span> {
-  fs.appendFileSync(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, line, { <span class="hljs-attr">mode</span>: <span class="hljs-number">0o600</span> });
+https.<span class="hljs-property">globalAgent</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line, tlsSocket</span>) =></span> {
+  fs.<span class="hljs-title function_">appendFileSync</span>(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, line, { <span class="hljs-attr">mode</span>: <span class="hljs-number">0o600</span> });
 });</code></pre>
-<h2>Class: <code>https.Server</code><span><a class="mark" href="#https_class_https_server" id="https_class_https_server">#</a></span></h2>
+</section><section><h3>Class: <code>https.Server</code><span><a class="mark" href="#https_class_https_server" id="https_class_https_server">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -242,7 +254,7 @@ https.globalAgent.on(<span class="hljs-string">'keylog'</span>, <span class="hlj
 <li>Extends: <a href="tls.html#tls_class_tls_server" class="type">&#x3C;tls.Server></a></li>
 </ul>
 <p>See <a href="http.html#http_class_http_server"><code>http.Server</code></a> for more information.</p>
-<h3><code>server.close([callback])</code><span><a class="mark" href="#https_server_close_callback" id="https_server_close_callback">#</a></span></h3>
+<h4><code>server.close([callback])</code><span><a class="mark" href="#https_server_close_callback" id="https_server_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -251,7 +263,7 @@ https.globalAgent.on(<span class="hljs-string">'keylog'</span>, <span class="hlj
 <li>Returns: <a href="https.html#https_class_https_server" class="type">&#x3C;https.Server></a></li>
 </ul>
 <p>See <a href="http.html#http_server_close_callback"><code>server.close()</code></a> from the HTTP module for details.</p>
-<h3><code>server.headersTimeout</code><span><a class="mark" href="#https_server_headerstimeout" id="https_server_headerstimeout">#</a></span></h3>
+<h4><code>server.headersTimeout</code><span><a class="mark" href="#https_server_headerstimeout" id="https_server_headerstimeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.3.0</span>
 </div>
@@ -259,15 +271,23 @@ https.globalAgent.on(<span class="hljs-string">'keylog'</span>, <span class="hlj
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>60000</code></li>
 </ul>
 <p>See <a href="http.html#http_server_headerstimeout"><code>http.Server#headersTimeout</code></a>.</p>
-<h3><code>server.listen()</code><span><a class="mark" href="#https_server_listen" id="https_server_listen">#</a></span></h3>
+<h4><code>server.listen()</code><span><a class="mark" href="#https_server_listen" id="https_server_listen">#</a></span></h4>
 <p>Starts the HTTPS server listening for encrypted connections.
 This method is identical to <a href="net.html#net_server_listen"><code>server.listen()</code></a> from <a href="net.html#net_class_net_server"><code>net.Server</code></a>.</p>
-<h3><code>server.maxHeadersCount</code><span><a class="mark" href="#https_server_maxheaderscount" id="https_server_maxheaderscount">#</a></span></h3>
+<h4><code>server.maxHeadersCount</code><span><a class="mark" href="#https_server_maxheaderscount" id="https_server_maxheaderscount">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>2000</code></li>
 </ul>
 <p>See <a href="http.html#http_server_maxheaderscount"><code>http.Server#maxHeadersCount</code></a>.</p>
-<h3><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#https_server_settimeout_msecs_callback" id="https_server_settimeout_msecs_callback">#</a></span></h3>
+<h4><code>server.requestTimeout</code><span><a class="mark" href="#https_server_requesttimeout" id="https_server_requesttimeout">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.11.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>0</code></li>
+</ul>
+<p>See <a href="http.html#http_server_requesttimeout"><code>http.Server#requestTimeout</code></a>.</p>
+<h4><code>server.setTimeout([msecs][, callback])</code><span><a class="mark" href="#https_server_settimeout_msecs_callback" id="https_server_settimeout_msecs_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -277,15 +297,23 @@ This method is identical to <a href="net.html#net_server_listen"><code>server.li
 <li>Returns: <a href="https.html#https_class_https_server" class="type">&#x3C;https.Server></a></li>
 </ul>
 <p>See <a href="http.html#http_server_settimeout_msecs_callback"><code>http.Server#setTimeout()</code></a>.</p>
-<h3><code>server.timeout</code><span><a class="mark" href="#https_server_timeout" id="https_server_timeout">#</a></span></h3>
+<h4><code>server.timeout</code><span><a class="mark" href="#https_server_timeout" id="https_server_timeout">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.11.2</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>The default timeout changed from 120s to 0 (no timeout).</p></td></tr>
+<tr><td>v0.11.2</td>
+<td><p><span>Added in: v0.11.2</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>120000</code> (2 minutes)</li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> 0 (no timeout)</li>
 </ul>
 <p>See <a href="http.html#http_server_timeout"><code>http.Server#timeout</code></a>.</p>
-<h3><code>server.keepAliveTimeout</code><span><a class="mark" href="#https_server_keepalivetimeout" id="https_server_keepalivetimeout">#</a></span></h3>
+<h4><code>server.keepAliveTimeout</code><span><a class="mark" href="#https_server_keepalivetimeout" id="https_server_keepalivetimeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -293,7 +321,7 @@ This method is identical to <a href="net.html#net_server_listen"><code>server.li
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> <strong>Default:</strong> <code>5000</code> (5 seconds)</li>
 </ul>
 <p>See <a href="http.html#http_server_keepalivetimeout"><code>http.Server#keepAliveTimeout</code></a>.</p>
-<h2><code>https.createServer([options][, requestListener])</code><span><a class="mark" href="#https_https_createserver_options_requestlistener" id="https_https_createserver_options_requestlistener">#</a></span></h2>
+</section><section><h3><code>https.createServer([options][, requestListener])</code><span><a class="mark" href="#https_https_createserver_options_requestlistener" id="https_https_createserver_options_requestlistener">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -308,29 +336,29 @@ This method is identical to <a href="net.html#net_server_listen"><code>server.li
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">const</span> options = {
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>)
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>)
 };
 
-https.createServer(options, <span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.writeHead(<span class="hljs-number">200</span>);
-  res.end(<span class="hljs-string">'hello world\n'</span>);
-}).listen(<span class="hljs-number">8000</span>);</code></pre>
+https.<span class="hljs-title function_">createServer</span>(options, <span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'hello world\n'</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
 <p>Or</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> https = <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">const</span> options = {
-  <span class="hljs-attr">pfx</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/test_cert.pfx'</span>),
+  <span class="hljs-attr">pfx</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/test_cert.pfx'</span>),
   <span class="hljs-attr">passphrase</span>: <span class="hljs-string">'sample'</span>
 };
 
-https.createServer(options, <span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.writeHead(<span class="hljs-number">200</span>);
-  res.end(<span class="hljs-string">'hello world\n'</span>);
-}).listen(<span class="hljs-number">8000</span>);</code></pre>
-<h2><code>https.get(options[, callback])</code><span><a class="mark" href="#https_https_get_options_callback" id="https_https_get_options_callback">#</a></span></h2>
-<h2><code>https.get(url[, options][, callback])</code><span><a class="mark" href="#https_https_get_url_options_callback" id="https_https_get_url_options_callback">#</a></span></h2>
+https.<span class="hljs-title function_">createServer</span>(options, <span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>);
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'hello world\n'</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>);</code></pre>
+</section><section><h3><code>https.get(options[, callback])</code><span><a class="mark" href="#https_https_get_options_callback" id="https_https_get_options_callback">#</a></span></h3>
+</section><section><h3><code>https.get(url[, options][, callback])</code><span><a class="mark" href="#https_https_get_url_options_callback" id="https_https_get_url_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -356,28 +384,32 @@ string, it is automatically parsed with <a href="url.html#url_new_url_input_base
 object, it will be automatically converted to an ordinary <code>options</code> object.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> https = <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);
 
-https.get(<span class="hljs-string">'https://encrypted.google.com/'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'statusCode:'</span>, res.statusCode);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'headers:'</span>, res.headers);
+https.<span class="hljs-title function_">get</span>(<span class="hljs-string">'https://encrypted.google.com/'</span>, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'statusCode:'</span>, res.<span class="hljs-property">statusCode</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'headers:'</span>, res.<span class="hljs-property">headers</span>);
 
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {
-    process.stdout.write(d);
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {
+    process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">write</span>(d);
   });
 
-}).on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(e);
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(e);
 });</code></pre>
-<h2><code>https.globalAgent</code><span><a class="mark" href="#https_https_globalagent" id="https_https_globalagent">#</a></span></h2>
+</section><section><h3><code>https.globalAgent</code><span><a class="mark" href="#https_https_globalagent" id="https_https_globalagent">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
 <p>Global instance of <a href="#https_class_https_agent"><code>https.Agent</code></a> for all HTTPS client requests.</p>
-<h2><code>https.request(options[, callback])</code><span><a class="mark" href="#https_https_request_options_callback" id="https_https_request_options_callback">#</a></span></h2>
-<h2><code>https.request(url[, options][, callback])</code><span><a class="mark" href="#https_https_request_url_options_callback" id="https_https_request_url_options_callback">#</a></span></h2>
+</section><section><h3><code>https.request(options[, callback])</code><span><a class="mark" href="#https_https_request_options_callback" id="https_https_request_options_callback">#</a></span></h3>
+</section><section><h3><code>https.request(url[, options][, callback])</code><span><a class="mark" href="#https_https_request_url_options_callback" id="https_https_request_url_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>When using a <code>URL</code> object parsed username and password will now be properly URI decoded.</p></td></tr>
+<tr><td>v14.1.0</td>
+<td><p>The <code>highWaterMark</code> option is accepted now.</p></td></tr>
 <tr><td>v10.9.0</td>
 <td><p>The <code>url</code> parameter can now be passed along with a separate <code>options</code> object.</p></td></tr>
 <tr><td>v9.3.0</td>
@@ -400,15 +432,20 @@ https.get(<span class="hljs-string">'https://encrypted.google.com/'</span>, <spa
 </ul>
 </li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
+<li>Returns: <a href="http.html#http_class_http_clientrequest" class="type">&#x3C;http.ClientRequest></a></li>
 </ul>
 <p>Makes a request to a secure web server.</p>
 <p>The following additional <code>options</code> from <a href="tls.html#tls_tls_connect_options_callback"><code>tls.connect()</code></a> are also accepted:
 <code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,
 <code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,
-<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>.</p>
+<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>,
+<code>highWaterMark</code>.</p>
 <p><code>options</code> can be an object, a string, or a <a href="url.html#url_the_whatwg_url_api"><code>URL</code></a> object. If <code>options</code> is a
 string, it is automatically parsed with <a href="url.html#url_new_url_input_base"><code>new URL()</code></a>. If it is a <a href="url.html#url_the_whatwg_url_api"><code>URL</code></a>
 object, it will be automatically converted to an ordinary <code>options</code> object.</p>
+<p><code>https.request()</code> returns an instance of the <a href="http.html#http_class_http_clientrequest"><code>http.ClientRequest</code></a>
+class. The <code>ClientRequest</code> instance is a writable stream. If one needs to
+upload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> https = <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);
 
 <span class="hljs-keyword">const</span> options = {
@@ -418,31 +455,31 @@ object, it will be automatically converted to an ordinary <code>options</code> o
   <span class="hljs-attr">method</span>: <span class="hljs-string">'GET'</span>
 };
 
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'statusCode:'</span>, res.statusCode);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'headers:'</span>, res.headers);
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'statusCode:'</span>, res.<span class="hljs-property">statusCode</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'headers:'</span>, res.<span class="hljs-property">headers</span>);
 
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {
-    process.stdout.write(d);
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {
+    process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">write</span>(d);
   });
 });
 
-req.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(e);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(e);
 });
-req.end();</code></pre>
+req.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Example using options from <a href="tls.html#tls_tls_connect_options_callback"><code>tls.connect()</code></a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">hostname</span>: <span class="hljs-string">'encrypted.google.com'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">443</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'GET'</span>,
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>)
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>)
 };
-options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
+options.<span class="hljs-property">agent</span> = <span class="hljs-keyword">new</span> https.<span class="hljs-title class_">Agent</span>(options);
 
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>Alternatively, opt out of connection pooling by not using an <a href="#https_class_https_agent"><code>Agent</code></a>.</p>
@@ -451,18 +488,18 @@ options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
   <span class="hljs-attr">port</span>: <span class="hljs-number">443</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'GET'</span>,
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>),
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'test/fixtures/keys/agent2-cert.pem'</span>),
   <span class="hljs-attr">agent</span>: <span class="hljs-literal">false</span>
 };
 
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>Example using a <a href="url.html#url_the_whatwg_url_api"><code>URL</code></a> as <code>options</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> options = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> options = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
 
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
   <span class="hljs-comment">// ...</span>
 });</code></pre>
 <p>Example pinning on certificate fingerprint, or the public key (similar to
@@ -471,38 +508,38 @@ options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
 <span class="hljs-keyword">const</span> https = <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">sha256</span>(<span class="hljs-params">s</span>) </span>{
-  <span class="hljs-keyword">return</span> crypto.createHash(<span class="hljs-string">'sha256'</span>).update(s).digest(<span class="hljs-string">'base64'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">sha256</span>(<span class="hljs-params">s</span>) {
+  <span class="hljs-keyword">return</span> crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>).<span class="hljs-title function_">update</span>(s).<span class="hljs-title function_">digest</span>(<span class="hljs-string">'base64'</span>);
 }
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-attr">hostname</span>: <span class="hljs-string">'github.com'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">443</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">method</span>: <span class="hljs-string">'GET'</span>,
-  <span class="hljs-attr">checkServerIdentity</span>: <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">host, cert</span>) </span>{
+  <span class="hljs-attr">checkServerIdentity</span>: <span class="hljs-keyword">function</span>(<span class="hljs-params">host, cert</span>) {
     <span class="hljs-comment">// Make sure the certificate is issued to the host we are connected to</span>
-    <span class="hljs-keyword">const</span> err = tls.checkServerIdentity(host, cert);
+    <span class="hljs-keyword">const</span> err = tls.<span class="hljs-title function_">checkServerIdentity</span>(host, cert);
     <span class="hljs-keyword">if</span> (err) {
       <span class="hljs-keyword">return</span> err;
     }
 
     <span class="hljs-comment">// Pin the public key, similar to HPKP pin-sha25 pinning</span>
     <span class="hljs-keyword">const</span> pubkey256 = <span class="hljs-string">'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU='</span>;
-    <span class="hljs-keyword">if</span> (sha256(cert.pubkey) !== pubkey256) {
+    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">sha256</span>(cert.<span class="hljs-property">pubkey</span>) !== pubkey256) {
       <span class="hljs-keyword">const</span> msg = <span class="hljs-string">'Certificate verification error: '</span> +
         <span class="hljs-string">`The public key of '<span class="hljs-subst">${cert.subject.CN}</span>' `</span> +
         <span class="hljs-string">'does not match our pinned fingerprint'</span>;
-      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(msg);
+      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(msg);
     }
 
     <span class="hljs-comment">// Pin the exact certificate, rather than the pub key</span>
     <span class="hljs-keyword">const</span> cert256 = <span class="hljs-string">'25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:'</span> +
       <span class="hljs-string">'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16'</span>;
-    <span class="hljs-keyword">if</span> (cert.fingerprint256 !== cert256) {
+    <span class="hljs-keyword">if</span> (cert.<span class="hljs-property">fingerprint256</span> !== cert256) {
       <span class="hljs-keyword">const</span> msg = <span class="hljs-string">'Certificate verification error: '</span> +
         <span class="hljs-string">`The certificate of '<span class="hljs-subst">${cert.subject.CN}</span>' `</span> +
         <span class="hljs-string">'does not match our pinned fingerprint'</span>;
-      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(msg);
+      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(msg);
     }
 
     <span class="hljs-comment">// This loop is informational only.</span>
@@ -511,33 +548,33 @@ options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
     <span class="hljs-comment">// internet, while pinning the public key of the service in sensitive</span>
     <span class="hljs-comment">// environments.</span>
     <span class="hljs-keyword">do</span> {
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Subject Common Name:'</span>, cert.subject.CN);
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'  Certificate SHA256 fingerprint:'</span>, cert.fingerprint256);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Subject Common Name:'</span>, cert.<span class="hljs-property">subject</span>.<span class="hljs-property">CN</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'  Certificate SHA256 fingerprint:'</span>, cert.<span class="hljs-property">fingerprint256</span>);
 
-      hash = crypto.createHash(<span class="hljs-string">'sha256'</span>);
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'  Public key ping-sha256:'</span>, sha256(cert.pubkey));
+      hash = crypto.<span class="hljs-title function_">createHash</span>(<span class="hljs-string">'sha256'</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'  Public key ping-sha256:'</span>, <span class="hljs-title function_">sha256</span>(cert.<span class="hljs-property">pubkey</span>));
 
-      lastprint256 = cert.fingerprint256;
-      cert = cert.issuerCertificate;
-    } <span class="hljs-keyword">while</span> (cert.fingerprint256 !== lastprint256);
+      lastprint256 = cert.<span class="hljs-property">fingerprint256</span>;
+      cert = cert.<span class="hljs-property">issuerCertificate</span>;
+    } <span class="hljs-keyword">while</span> (cert.<span class="hljs-property">fingerprint256</span> !== lastprint256);
 
   },
 };
 
-options.agent = <span class="hljs-keyword">new</span> https.Agent(options);
-<span class="hljs-keyword">const</span> req = https.request(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'All OK. Server matched our pinned cert or public key'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'statusCode:'</span>, res.statusCode);
+options.<span class="hljs-property">agent</span> = <span class="hljs-keyword">new</span> https.<span class="hljs-title class_">Agent</span>(options);
+<span class="hljs-keyword">const</span> req = https.<span class="hljs-title function_">request</span>(options, <span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'All OK. Server matched our pinned cert or public key'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'statusCode:'</span>, res.<span class="hljs-property">statusCode</span>);
   <span class="hljs-comment">// Print the HPKP values</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'headers:'</span>, res.headers[<span class="hljs-string">'public-key-pins'</span>]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'headers:'</span>, res.<span class="hljs-property">headers</span>[<span class="hljs-string">'public-key-pins'</span>]);
 
-  res.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {});
+  res.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">d</span>) =></span> {});
 });
 
-req.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(e.message);
+req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(e.<span class="hljs-property">message</span>);
 });
-req.end();</code></pre>
+req.<span class="hljs-title function_">end</span>();</code></pre>
 <p>Outputs for example:</p>
 <pre><code class="language-text">Subject Common Name: github.com
   Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16
@@ -550,10 +587,46 @@ Subject Common Name: DigiCert High Assurance EV Root CA
   Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=
 All OK. Server matched our pinned cert or public key
 statusCode: 200
-headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho="; pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4="; pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains</code></pre>
+headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho="; pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4="; pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains</code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/https.json b/doc/api/https.json
index 3754a5f2c1caaf9e9bda9e605223b8d1db80e668..92f47ac17064d405b377142445c495fa3fac9c4f 100644
--- a/doc/api/https.json
+++ b/doc/api/https.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/https.js\">lib/https.js</a></p>\n<p>HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a\nseparate module.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/https.js\">lib/https.js</a></p>\n<p>HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a\nseparate module.</p>",
       "classes": [
         {
           "textRaw": "Class: `https.Agent`",
@@ -19,15 +19,15 @@
               "v0.4.5"
             ],
             "changes": [
-              {
-                "version": "v2.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/2228",
-                "description": "parameter `maxCachedSessions` added to `options` for TLS sessions reuse."
-              },
               {
                 "version": "v5.3.0",
                 "pr-url": "https://github.com/nodejs/node/pull/4252",
                 "description": "support `0` `maxCachedSessions` to disable TLS session caching."
+              },
+              {
+                "version": "v2.5.0",
+                "pr-url": "https://github.com/nodejs/node/pull/2228",
+                "description": "parameter `maxCachedSessions` added to `options` for TLS sessions reuse."
               }
             ]
           },
@@ -169,16 +169,35 @@
               "desc": "<p>See <a href=\"http.html#http_server_maxheaderscount\"><code>http.Server#maxHeadersCount</code></a>.</p>"
             },
             {
-              "textRaw": "`timeout` {number} **Default:** `120000` (2 minutes)",
+              "textRaw": "`requestTimeout` {number} **Default:** `0`",
+              "type": "number",
+              "name": "requestTimeout",
+              "meta": {
+                "added": [
+                  "v14.11.0"
+                ],
+                "changes": []
+              },
+              "default": "`0`",
+              "desc": "<p>See <a href=\"http.html#http_server_requesttimeout\"><code>http.Server#requestTimeout</code></a>.</p>"
+            },
+            {
+              "textRaw": "`timeout` {number} **Default:** 0 (no timeout)",
               "type": "number",
               "name": "timeout",
               "meta": {
                 "added": [
                   "v0.11.2"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v13.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/27558",
+                    "description": "The default timeout changed from 120s to 0 (no timeout)."
+                  }
+                ]
               },
-              "default": "`120000` (2 minutes)",
+              "default": "0 (no timeout)",
               "desc": "<p>See <a href=\"http.html#http_server_timeout\"><code>http.Server#timeout</code></a>.</p>"
             },
             {
@@ -332,6 +351,16 @@
               "v0.3.6"
             ],
             "changes": [
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/39310",
+                "description": "When using a `URL` object parsed username and password will now be properly URI decoded."
+              },
+              {
+                "version": "v14.1.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32786",
+                "description": "The `highWaterMark` option is accepted now."
+              },
               {
                 "version": "v10.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/21616",
@@ -351,6 +380,11 @@
           },
           "signatures": [
             {
+              "return": {
+                "textRaw": "Returns: {http.ClientRequest}",
+                "name": "return",
+                "type": "http.ClientRequest"
+              },
               "params": [
                 {
                   "textRaw": "`url` {string | URL}",
@@ -388,7 +422,7 @@
               ]
             }
           ],
-          "desc": "<p>Makes a request to a secure web server.</p>\n<p>The following additional <code>options</code> from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a> are also accepted:\n<code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,\n<code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,\n<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>.</p>\n<p><code>options</code> can be an object, a string, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>options</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<pre><code class=\"language-js\">const https = require('https');\n\nconst options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET'\n};\n\nconst req = https.request(options, (res) => {\n  console.log('statusCode:', res.statusCode);\n  console.log('headers:', res.headers);\n\n  res.on('data', (d) => {\n    process.stdout.write(d);\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(e);\n});\nreq.end();\n</code></pre>\n<p>Example using options from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>:</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Alternatively, opt out of connection pooling by not using an <a href=\"#https_class_https_agent\"><code>Agent</code></a>.</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),\n  agent: false\n};\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('https://abc:xyz@example.com');\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example pinning on certificate fingerprint, or the public key (similar to\n<code>pin-sha256</code>):</p>\n<pre><code class=\"language-js\">const tls = require('tls');\nconst https = require('https');\nconst crypto = require('crypto');\n\nfunction sha256(s) {\n  return crypto.createHash('sha256').update(s).digest('base64');\n}\nconst options = {\n  hostname: 'github.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  checkServerIdentity: function(host, cert) {\n    // Make sure the certificate is issued to the host we are connected to\n    const err = tls.checkServerIdentity(host, cert);\n    if (err) {\n      return err;\n    }\n\n    // Pin the public key, similar to HPKP pin-sha25 pinning\n    const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';\n    if (sha256(cert.pubkey) !== pubkey256) {\n      const msg = 'Certificate verification error: ' +\n        `The public key of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // Pin the exact certificate, rather than the pub key\n    const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +\n      'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';\n    if (cert.fingerprint256 !== cert256) {\n      const msg = 'Certificate verification error: ' +\n        `The certificate of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // This loop is informational only.\n    // Print the certificate and public key fingerprints of all certs in the\n    // chain. Its common to pin the public key of the issuer on the public\n    // internet, while pinning the public key of the service in sensitive\n    // environments.\n    do {\n      console.log('Subject Common Name:', cert.subject.CN);\n      console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);\n\n      hash = crypto.createHash('sha256');\n      console.log('  Public key ping-sha256:', sha256(cert.pubkey));\n\n      lastprint256 = cert.fingerprint256;\n      cert = cert.issuerCertificate;\n    } while (cert.fingerprint256 !== lastprint256);\n\n  },\n};\n\noptions.agent = new https.Agent(options);\nconst req = https.request(options, (res) => {\n  console.log('All OK. Server matched our pinned cert or public key');\n  console.log('statusCode:', res.statusCode);\n  // Print the HPKP values\n  console.log('headers:', res.headers['public-key-pins']);\n\n  res.on('data', (d) => {});\n});\n\nreq.on('error', (e) => {\n  console.error(e.message);\n});\nreq.end();\n</code></pre>\n<p>Outputs for example:</p>\n<pre><code class=\"language-text\">Subject Common Name: github.com\n  Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16\n  Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=\nSubject Common Name: DigiCert SHA2 Extended Validation Server CA\n  Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A\n  Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\nSubject Common Name: DigiCert High Assurance EV Root CA\n  Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF\n  Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\nAll OK. Server matched our pinned cert or public key\nstatusCode: 200\nheaders: max-age=0; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains\n</code></pre>"
+          "desc": "<p>Makes a request to a secure web server.</p>\n<p>The following additional <code>options</code> from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a> are also accepted:\n<code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,\n<code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,\n<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>,\n<code>highWaterMark</code>.</p>\n<p><code>options</code> can be an object, a string, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>options</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p><code>https.request()</code> returns an instance of the <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const https = require('https');\n\nconst options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET'\n};\n\nconst req = https.request(options, (res) => {\n  console.log('statusCode:', res.statusCode);\n  console.log('headers:', res.headers);\n\n  res.on('data', (d) => {\n    process.stdout.write(d);\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(e);\n});\nreq.end();\n</code></pre>\n<p>Example using options from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>:</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Alternatively, opt out of connection pooling by not using an <a href=\"#https_class_https_agent\"><code>Agent</code></a>.</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),\n  agent: false\n};\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('https://abc:xyz@example.com');\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example pinning on certificate fingerprint, or the public key (similar to\n<code>pin-sha256</code>):</p>\n<pre><code class=\"language-js\">const tls = require('tls');\nconst https = require('https');\nconst crypto = require('crypto');\n\nfunction sha256(s) {\n  return crypto.createHash('sha256').update(s).digest('base64');\n}\nconst options = {\n  hostname: 'github.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  checkServerIdentity: function(host, cert) {\n    // Make sure the certificate is issued to the host we are connected to\n    const err = tls.checkServerIdentity(host, cert);\n    if (err) {\n      return err;\n    }\n\n    // Pin the public key, similar to HPKP pin-sha25 pinning\n    const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';\n    if (sha256(cert.pubkey) !== pubkey256) {\n      const msg = 'Certificate verification error: ' +\n        `The public key of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // Pin the exact certificate, rather than the pub key\n    const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +\n      'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';\n    if (cert.fingerprint256 !== cert256) {\n      const msg = 'Certificate verification error: ' +\n        `The certificate of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // This loop is informational only.\n    // Print the certificate and public key fingerprints of all certs in the\n    // chain. Its common to pin the public key of the issuer on the public\n    // internet, while pinning the public key of the service in sensitive\n    // environments.\n    do {\n      console.log('Subject Common Name:', cert.subject.CN);\n      console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);\n\n      hash = crypto.createHash('sha256');\n      console.log('  Public key ping-sha256:', sha256(cert.pubkey));\n\n      lastprint256 = cert.fingerprint256;\n      cert = cert.issuerCertificate;\n    } while (cert.fingerprint256 !== lastprint256);\n\n  },\n};\n\noptions.agent = new https.Agent(options);\nconst req = https.request(options, (res) => {\n  console.log('All OK. Server matched our pinned cert or public key');\n  console.log('statusCode:', res.statusCode);\n  // Print the HPKP values\n  console.log('headers:', res.headers['public-key-pins']);\n\n  res.on('data', (d) => {});\n});\n\nreq.on('error', (e) => {\n  console.error(e.message);\n});\nreq.end();\n</code></pre>\n<p>Outputs for example:</p>\n<pre><code class=\"language-text\">Subject Common Name: github.com\n  Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16\n  Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=\nSubject Common Name: DigiCert SHA2 Extended Validation Server CA\n  Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A\n  Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\nSubject Common Name: DigiCert High Assurance EV Root CA\n  Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF\n  Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\nAll OK. Server matched our pinned cert or public key\nstatusCode: 200\nheaders: max-age=0; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains\n</code></pre>"
         },
         {
           "textRaw": "`https.request(url[, options][, callback])`",
@@ -399,6 +433,16 @@
               "v0.3.6"
             ],
             "changes": [
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/39310",
+                "description": "When using a `URL` object parsed username and password will now be properly URI decoded."
+              },
+              {
+                "version": "v14.1.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32786",
+                "description": "The `highWaterMark` option is accepted now."
+              },
               {
                 "version": "v10.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/21616",
@@ -418,6 +462,11 @@
           },
           "signatures": [
             {
+              "return": {
+                "textRaw": "Returns: {http.ClientRequest}",
+                "name": "return",
+                "type": "http.ClientRequest"
+              },
               "params": [
                 {
                   "textRaw": "`url` {string | URL}",
@@ -455,7 +504,7 @@
               ]
             }
           ],
-          "desc": "<p>Makes a request to a secure web server.</p>\n<p>The following additional <code>options</code> from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a> are also accepted:\n<code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,\n<code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,\n<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>.</p>\n<p><code>options</code> can be an object, a string, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>options</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<pre><code class=\"language-js\">const https = require('https');\n\nconst options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET'\n};\n\nconst req = https.request(options, (res) => {\n  console.log('statusCode:', res.statusCode);\n  console.log('headers:', res.headers);\n\n  res.on('data', (d) => {\n    process.stdout.write(d);\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(e);\n});\nreq.end();\n</code></pre>\n<p>Example using options from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>:</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Alternatively, opt out of connection pooling by not using an <a href=\"#https_class_https_agent\"><code>Agent</code></a>.</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),\n  agent: false\n};\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('https://abc:xyz@example.com');\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example pinning on certificate fingerprint, or the public key (similar to\n<code>pin-sha256</code>):</p>\n<pre><code class=\"language-js\">const tls = require('tls');\nconst https = require('https');\nconst crypto = require('crypto');\n\nfunction sha256(s) {\n  return crypto.createHash('sha256').update(s).digest('base64');\n}\nconst options = {\n  hostname: 'github.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  checkServerIdentity: function(host, cert) {\n    // Make sure the certificate is issued to the host we are connected to\n    const err = tls.checkServerIdentity(host, cert);\n    if (err) {\n      return err;\n    }\n\n    // Pin the public key, similar to HPKP pin-sha25 pinning\n    const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';\n    if (sha256(cert.pubkey) !== pubkey256) {\n      const msg = 'Certificate verification error: ' +\n        `The public key of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // Pin the exact certificate, rather than the pub key\n    const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +\n      'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';\n    if (cert.fingerprint256 !== cert256) {\n      const msg = 'Certificate verification error: ' +\n        `The certificate of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // This loop is informational only.\n    // Print the certificate and public key fingerprints of all certs in the\n    // chain. Its common to pin the public key of the issuer on the public\n    // internet, while pinning the public key of the service in sensitive\n    // environments.\n    do {\n      console.log('Subject Common Name:', cert.subject.CN);\n      console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);\n\n      hash = crypto.createHash('sha256');\n      console.log('  Public key ping-sha256:', sha256(cert.pubkey));\n\n      lastprint256 = cert.fingerprint256;\n      cert = cert.issuerCertificate;\n    } while (cert.fingerprint256 !== lastprint256);\n\n  },\n};\n\noptions.agent = new https.Agent(options);\nconst req = https.request(options, (res) => {\n  console.log('All OK. Server matched our pinned cert or public key');\n  console.log('statusCode:', res.statusCode);\n  // Print the HPKP values\n  console.log('headers:', res.headers['public-key-pins']);\n\n  res.on('data', (d) => {});\n});\n\nreq.on('error', (e) => {\n  console.error(e.message);\n});\nreq.end();\n</code></pre>\n<p>Outputs for example:</p>\n<pre><code class=\"language-text\">Subject Common Name: github.com\n  Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16\n  Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=\nSubject Common Name: DigiCert SHA2 Extended Validation Server CA\n  Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A\n  Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\nSubject Common Name: DigiCert High Assurance EV Root CA\n  Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF\n  Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\nAll OK. Server matched our pinned cert or public key\nstatusCode: 200\nheaders: max-age=0; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains\n</code></pre>"
+          "desc": "<p>Makes a request to a secure web server.</p>\n<p>The following additional <code>options</code> from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a> are also accepted:\n<code>ca</code>, <code>cert</code>, <code>ciphers</code>, <code>clientCertEngine</code>, <code>crl</code>, <code>dhparam</code>, <code>ecdhCurve</code>,\n<code>honorCipherOrder</code>, <code>key</code>, <code>passphrase</code>, <code>pfx</code>, <code>rejectUnauthorized</code>,\n<code>secureOptions</code>, <code>secureProtocol</code>, <code>servername</code>, <code>sessionIdContext</code>,\n<code>highWaterMark</code>.</p>\n<p><code>options</code> can be an object, a string, or a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> object. If <code>options</code> is a\nstring, it is automatically parsed with <a href=\"url.html#url_new_url_input_base\"><code>new URL()</code></a>. If it is a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a>\nobject, it will be automatically converted to an ordinary <code>options</code> object.</p>\n<p><code>https.request()</code> returns an instance of the <a href=\"http.html#http_class_http_clientrequest\"><code>http.ClientRequest</code></a>\nclass. The <code>ClientRequest</code> instance is a writable stream. If one needs to\nupload a file with a POST request, then write to the <code>ClientRequest</code> object.</p>\n<pre><code class=\"language-js\">const https = require('https');\n\nconst options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET'\n};\n\nconst req = https.request(options, (res) => {\n  console.log('statusCode:', res.statusCode);\n  console.log('headers:', res.headers);\n\n  res.on('data', (d) => {\n    process.stdout.write(d);\n  });\n});\n\nreq.on('error', (e) => {\n  console.error(e);\n});\nreq.end();\n</code></pre>\n<p>Example using options from <a href=\"tls.html#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>:</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')\n};\noptions.agent = new https.Agent(options);\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Alternatively, opt out of connection pooling by not using an <a href=\"#https_class_https_agent\"><code>Agent</code></a>.</p>\n<pre><code class=\"language-js\">const options = {\n  hostname: 'encrypted.google.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),\n  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),\n  agent: false\n};\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example using a <a href=\"url.html#url_the_whatwg_url_api\"><code>URL</code></a> as <code>options</code>:</p>\n<pre><code class=\"language-js\">const options = new URL('https://abc:xyz@example.com');\n\nconst req = https.request(options, (res) => {\n  // ...\n});\n</code></pre>\n<p>Example pinning on certificate fingerprint, or the public key (similar to\n<code>pin-sha256</code>):</p>\n<pre><code class=\"language-js\">const tls = require('tls');\nconst https = require('https');\nconst crypto = require('crypto');\n\nfunction sha256(s) {\n  return crypto.createHash('sha256').update(s).digest('base64');\n}\nconst options = {\n  hostname: 'github.com',\n  port: 443,\n  path: '/',\n  method: 'GET',\n  checkServerIdentity: function(host, cert) {\n    // Make sure the certificate is issued to the host we are connected to\n    const err = tls.checkServerIdentity(host, cert);\n    if (err) {\n      return err;\n    }\n\n    // Pin the public key, similar to HPKP pin-sha25 pinning\n    const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';\n    if (sha256(cert.pubkey) !== pubkey256) {\n      const msg = 'Certificate verification error: ' +\n        `The public key of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // Pin the exact certificate, rather than the pub key\n    const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +\n      'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';\n    if (cert.fingerprint256 !== cert256) {\n      const msg = 'Certificate verification error: ' +\n        `The certificate of '${cert.subject.CN}' ` +\n        'does not match our pinned fingerprint';\n      return new Error(msg);\n    }\n\n    // This loop is informational only.\n    // Print the certificate and public key fingerprints of all certs in the\n    // chain. Its common to pin the public key of the issuer on the public\n    // internet, while pinning the public key of the service in sensitive\n    // environments.\n    do {\n      console.log('Subject Common Name:', cert.subject.CN);\n      console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);\n\n      hash = crypto.createHash('sha256');\n      console.log('  Public key ping-sha256:', sha256(cert.pubkey));\n\n      lastprint256 = cert.fingerprint256;\n      cert = cert.issuerCertificate;\n    } while (cert.fingerprint256 !== lastprint256);\n\n  },\n};\n\noptions.agent = new https.Agent(options);\nconst req = https.request(options, (res) => {\n  console.log('All OK. Server matched our pinned cert or public key');\n  console.log('statusCode:', res.statusCode);\n  // Print the HPKP values\n  console.log('headers:', res.headers['public-key-pins']);\n\n  res.on('data', (d) => {});\n});\n\nreq.on('error', (e) => {\n  console.error(e.message);\n});\nreq.end();\n</code></pre>\n<p>Outputs for example:</p>\n<pre><code class=\"language-text\">Subject Common Name: github.com\n  Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16\n  Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=\nSubject Common Name: DigiCert SHA2 Extended Validation Server CA\n  Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A\n  Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\nSubject Common Name: DigiCert High Assurance EV Root CA\n  Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF\n  Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\nAll OK. Server matched our pinned cert or public key\nstatusCode: 200\nheaders: max-age=0; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains\n</code></pre>"
         }
       ],
       "properties": [
diff --git a/doc/api/https.md b/doc/api/https.md
index 146ee82815fe10415b35f3fff5545fedbb1867eb..785a066cc25710327b13a998c4d4b112b4454b6d 100644
--- a/doc/api/https.md
+++ b/doc/api/https.md
@@ -13,13 +13,13 @@ separate module.
 <!-- YAML
 added: v0.4.5
 changes:
+  - version: v5.3.0
+    pr-url: https://github.com/nodejs/node/pull/4252
+    description: support `0` `maxCachedSessions` to disable TLS session caching.
   - version: v2.5.0
     pr-url: https://github.com/nodejs/node/pull/2228
     description: parameter `maxCachedSessions` added to `options` for TLS
                  sessions reuse.
-  - version: v5.3.0
-    pr-url: https://github.com/nodejs/node/pull/4252
-    description: support `0` `maxCachedSessions` to disable TLS session caching.
 -->
 
 An [`Agent`][] object for HTTPS similar to [`http.Agent`][]. See
@@ -49,7 +49,9 @@ changes:
 
 #### Event: `'keylog'`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.2.0
+ - v12.16.0
 -->
 
 * `line` {Buffer} Line of ASCII text, in NSS `SSLKEYLOGFILE` format.
@@ -111,6 +113,15 @@ This method is identical to [`server.listen()`][] from [`net.Server`][].
 
 See [`http.Server#maxHeadersCount`][].
 
+### `server.requestTimeout`
+<!-- YAML
+added: v14.11.0
+-->
+
+* {number} **Default:** `0`
+
+See [`http.Server#requestTimeout`][].
+
 ### `server.setTimeout([msecs][, callback])`
 <!-- YAML
 added: v0.11.2
@@ -125,9 +136,13 @@ See [`http.Server#setTimeout()`][].
 ### `server.timeout`
 <!-- YAML
 added: v0.11.2
+changes:
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27558
+    description: The default timeout changed from 120s to 0 (no timeout).
 -->
 
-* {number} **Default:** `120000` (2 minutes)
+* {number} **Default:** 0 (no timeout)
 
 See [`http.Server#timeout`][].
 
@@ -146,7 +161,7 @@ added: v0.3.4
 -->
 
 * `options` {Object} Accepts `options` from [`tls.createServer()`][],
- [`tls.createSecureContext()`][] and [`http.createServer()`][].
+  [`tls.createSecureContext()`][] and [`http.createServer()`][].
 * `requestListener` {Function} A listener to be added to the `'request'` event.
 * Returns: {https.Server}
 
@@ -236,6 +251,13 @@ Global instance of [`https.Agent`][] for all HTTPS client requests.
 <!-- YAML
 added: v0.3.6
 changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/39310
+    description: When using a `URL` object parsed username
+                 and password will now be properly URI decoded.
+  - version: v14.1.0
+    pr-url: https://github.com/nodejs/node/pull/32786
+    description: The `highWaterMark` option is accepted now.
   - version: v10.9.0
     pr-url: https://github.com/nodejs/node/pull/21616
     description: The `url` parameter can now be passed along with a separate
@@ -255,18 +277,24 @@ changes:
   * `port` **Default:** `443`
   * `agent` **Default:** `https.globalAgent`
 * `callback` {Function}
+* Returns: {http.ClientRequest}
 
 Makes a request to a secure web server.
 
 The following additional `options` from [`tls.connect()`][] are also accepted:
 `ca`, `cert`, `ciphers`, `clientCertEngine`, `crl`, `dhparam`, `ecdhCurve`,
 `honorCipherOrder`, `key`, `passphrase`, `pfx`, `rejectUnauthorized`,
-`secureOptions`, `secureProtocol`, `servername`, `sessionIdContext`.
+`secureOptions`, `secureProtocol`, `servername`, `sessionIdContext`,
+`highWaterMark`.
 
 `options` can be an object, a string, or a [`URL`][] object. If `options` is a
 string, it is automatically parsed with [`new URL()`][]. If it is a [`URL`][]
 object, it will be automatically converted to an ordinary `options` object.
 
+`https.request()` returns an instance of the [`http.ClientRequest`][]
+class. The `ClientRequest` instance is a writable stream. If one needs to
+upload a file with a POST request, then write to the `ClientRequest` object.
+
 ```js
 const https = require('https');
 
@@ -433,26 +461,28 @@ headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; p
 ```
 
 [`Agent`]: #https_class_https_agent
-[`URL`]: url.html#url_the_whatwg_url_api
-[`http.Agent`]: http.html#http_class_http_agent
-[`http.Agent(options)`]: http.html#http_new_agent_options
-[`http.Server#headersTimeout`]: http.html#http_server_headerstimeout
-[`http.Server#keepAliveTimeout`]: http.html#http_server_keepalivetimeout
-[`http.Server#maxHeadersCount`]: http.html#http_server_maxheaderscount
-[`http.Server#setTimeout()`]: http.html#http_server_settimeout_msecs_callback
-[`http.Server#timeout`]: http.html#http_server_timeout
-[`http.Server`]: http.html#http_class_http_server
-[`http.close()`]: http.html#http_server_close_callback
-[`http.createServer()`]: http.html#http_http_createserver_options_requestlistener
-[`http.get()`]: http.html#http_http_get_options_callback
-[`http.request()`]: http.html#http_http_request_options_callback
+[`Session Resumption`]: tls.md#tls_session_resumption
+[`URL`]: url.md#url_the_whatwg_url_api
+[`http.Agent(options)`]: http.md#http_new_agent_options
+[`http.Agent`]: http.md#http_class_http_agent
+[`http.ClientRequest`]: http.md#http_class_http_clientrequest
+[`http.Server#headersTimeout`]: http.md#http_server_headerstimeout
+[`http.Server#keepAliveTimeout`]: http.md#http_server_keepalivetimeout
+[`http.Server#maxHeadersCount`]: http.md#http_server_maxheaderscount
+[`http.Server#requestTimeout`]: http.md#http_server_requesttimeout
+[`http.Server#setTimeout()`]: http.md#http_server_settimeout_msecs_callback
+[`http.Server#timeout`]: http.md#http_server_timeout
+[`http.Server`]: http.md#http_class_http_server
+[`http.close()`]: http.md#http_server_close_callback
+[`http.createServer()`]: http.md#http_http_createserver_options_requestlistener
+[`http.get()`]: http.md#http_http_get_options_callback
+[`http.request()`]: http.md#http_http_request_options_callback
 [`https.Agent`]: #https_class_https_agent
 [`https.request()`]: #https_https_request_options_callback
-[`net.Server`]: net.html#net_class_net_server
-[`new URL()`]: url.html#url_new_url_input_base
-[`server.listen()`]: net.html#net_server_listen
-[`tls.connect()`]: tls.html#tls_tls_connect_options_callback
-[`tls.createSecureContext()`]: tls.html#tls_tls_createsecurecontext_options
-[`tls.createServer()`]: tls.html#tls_tls_createserver_options_secureconnectionlistener
-[`Session Resumption`]: tls.html#tls_session_resumption
+[`net.Server`]: net.md#net_class_net_server
+[`new URL()`]: url.md#url_new_url_input_base
+[`server.listen()`]: net.md#net_server_listen
+[`tls.connect()`]: tls.md#tls_tls_connect_options_callback
+[`tls.createSecureContext()`]: tls.md#tls_tls_createsecurecontext_options
+[`tls.createServer()`]: tls.md#tls_tls_createserver_options_secureconnectionlistener
 [sni wiki]: https://en.wikipedia.org/wiki/Server_Name_Indication
diff --git a/doc/api/index.html b/doc/api/index.html
index 82a0f63e54f088c22aa494645d2eb054c6470671..088885761d1cb299cec41f32685d7578350074e1 100644
--- a/doc/api/index.html
+++ b/doc/api/index.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Index | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Index | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="index" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/index.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/index.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/index.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/index.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/index.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/index.html">13.x</a></li>
@@ -118,21 +133,18 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/index.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/index.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/index.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        
-      </div>
+      <!-- TOC -->
 
       <div id="apicontent">
         <!--
   NB(chrisdickinson): if you move this file, be sure to update
-  tools/doc/html.js to point at the new location.
+  tools/doc/html.mjs to point at the new location.
 -->
 <!--introduced_in=v0.10.0-->
 <ul>
@@ -144,16 +156,17 @@
 <li><a href="assert.html">Assertion testing</a></li>
 <li><a href="async_hooks.html">Async hooks</a></li>
 <li><a href="buffer.html">Buffer</a></li>
-<li><a href="addons.html">C++ Addons</a></li>
-<li><a href="n-api.html">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html">C++ Embedder API</a></li>
-<li><a href="child_process.html">Child Processes</a></li>
+<li><a href="addons.html">C++ addons</a></li>
+<li><a href="n-api.html">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html">C++ embedder API</a></li>
+<li><a href="child_process.html">Child processes</a></li>
 <li><a href="cluster.html">Cluster</a></li>
-<li><a href="cli.html">Command line options</a></li>
+<li><a href="cli.html">Command-line options</a></li>
 <li><a href="console.html">Console</a></li>
 <li><a href="crypto.html">Crypto</a></li>
 <li><a href="debugger.html">Debugger</a></li>
 <li><a href="deprecations.html">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html">Diagnostics Channel</a></li>
 <li><a href="dns.html">DNS</a></li>
 <li><a href="domain.html">Domain</a></li>
 <li><a href="errors.html">Errors</a></li>
@@ -203,5 +216,41 @@
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/index.md b/doc/api/index.md
index 1363822450ec274192baa9ccdb3a4d276b9f791b..ed254a734751598922690480bcb92ebce2da591d 100644
--- a/doc/api/index.md
+++ b/doc/api/index.md
@@ -1,68 +1,69 @@
 <!--
   NB(chrisdickinson): if you move this file, be sure to update
-  tools/doc/html.js to point at the new location.
+  tools/doc/html.mjs to point at the new location.
 -->
 
 <!--introduced_in=v0.10.0-->
 
-* [About this documentation](documentation.html)
-* [Usage and example](synopsis.html)
+* [About this documentation](documentation.md)
+* [Usage and example](synopsis.md)
 
 <hr class="line"/>
 
-* [Assertion testing](assert.html)
-* [Async hooks](async_hooks.html)
-* [Buffer](buffer.html)
-* [C++ Addons](addons.html)
-* [C/C++ Addons with N-API](n-api.html)
-* [C++ Embedder API](embedding.html)
-* [Child Processes](child_process.html)
-* [Cluster](cluster.html)
-* [Command line options](cli.html)
-* [Console](console.html)
-* [Crypto](crypto.html)
-* [Debugger](debugger.html)
-* [Deprecated APIs](deprecations.html)
-* [DNS](dns.html)
-* [Domain](domain.html)
-* [Errors](errors.html)
-* [Events](events.html)
-* [File system](fs.html)
-* [Globals](globals.html)
-* [HTTP](http.html)
-* [HTTP/2](http2.html)
-* [HTTPS](https.html)
-* [Inspector](inspector.html)
-* [Internationalization](intl.html)
-* [Modules: CommonJS modules](modules.html)
-* [Modules: ECMAScript modules](esm.html)
-* [Modules: `module` API](module.html)
-* [Modules: Packages](packages.html)
-* [Net](net.html)
-* [OS](os.html)
-* [Path](path.html)
-* [Performance hooks](perf_hooks.html)
-* [Policies](policy.html)
-* [Process](process.html)
-* [Punycode](punycode.html)
-* [Query strings](querystring.html)
-* [Readline](readline.html)
-* [REPL](repl.html)
-* [Report](report.html)
-* [Stream](stream.html)
-* [String decoder](string_decoder.html)
-* [Timers](timers.html)
-* [TLS/SSL](tls.html)
-* [Trace events](tracing.html)
-* [TTY](tty.html)
-* [UDP/datagram](dgram.html)
-* [URL](url.html)
-* [Utilities](util.html)
-* [V8](v8.html)
-* [VM](vm.html)
-* [WASI](wasi.html)
-* [Worker threads](worker_threads.html)
-* [Zlib](zlib.html)
+* [Assertion testing](assert.md)
+* [Async hooks](async_hooks.md)
+* [Buffer](buffer.md)
+* [C++ addons](addons.md)
+* [C/C++ addons with Node-API](n-api.md)
+* [C++ embedder API](embedding.md)
+* [Child processes](child_process.md)
+* [Cluster](cluster.md)
+* [Command-line options](cli.md)
+* [Console](console.md)
+* [Crypto](crypto.md)
+* [Debugger](debugger.md)
+* [Deprecated APIs](deprecations.md)
+* [Diagnostics Channel](diagnostics_channel.md)
+* [DNS](dns.md)
+* [Domain](domain.md)
+* [Errors](errors.md)
+* [Events](events.md)
+* [File system](fs.md)
+* [Globals](globals.md)
+* [HTTP](http.md)
+* [HTTP/2](http2.md)
+* [HTTPS](https.md)
+* [Inspector](inspector.md)
+* [Internationalization](intl.md)
+* [Modules: CommonJS modules](modules.md)
+* [Modules: ECMAScript modules](esm.md)
+* [Modules: `module` API](module.md)
+* [Modules: Packages](packages.md)
+* [Net](net.md)
+* [OS](os.md)
+* [Path](path.md)
+* [Performance hooks](perf_hooks.md)
+* [Policies](policy.md)
+* [Process](process.md)
+* [Punycode](punycode.md)
+* [Query strings](querystring.md)
+* [Readline](readline.md)
+* [REPL](repl.md)
+* [Report](report.md)
+* [Stream](stream.md)
+* [String decoder](string_decoder.md)
+* [Timers](timers.md)
+* [TLS/SSL](tls.md)
+* [Trace events](tracing.md)
+* [TTY](tty.md)
+* [UDP/datagram](dgram.md)
+* [URL](url.md)
+* [Utilities](util.md)
+* [V8](v8.md)
+* [VM](vm.md)
+* [WASI](wasi.md)
+* [Worker threads](worker_threads.md)
+* [Zlib](zlib.md)
 
 <hr class="line"/>
 
diff --git a/doc/api/inspector.html b/doc/api/inspector.html
index 0e419bd62b859eed791b41d228ec0a515c2b82db..c93c8f93591a710493838066a0e30132e8b8fda3 100644
--- a/doc/api/inspector.html
+++ b/doc/api/inspector.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Inspector | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Inspector | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="inspector" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/inspector.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/inspector.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/inspector.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/inspector.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/inspector.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/inspector.html">13.x</a></li>
@@ -112,16 +127,14 @@
 <li><a href="https://nodejs.org/docs/latest-v8.x/api/inspector.html">8.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/inspector.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/inspector.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
-<li><span class="stability_1"><a href="#inspector_inspector">Inspector</a></span>
+      <details id="toc" open><summary>Table of contents</summary><ul>
+<li><span class="stability_2"><a href="#inspector_inspector">Inspector</a></span>
 <ul>
 <li><a href="#inspector_inspector_close"><code>inspector.close()</code></a></li>
 <li><a href="#inspector_inspector_console"><code>inspector.console</code></a></li>
@@ -147,27 +160,26 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Inspector<span><a class="mark" href="#inspector_inspector" id="inspector_inspector">#</a></span></h1>
+        <h2>Inspector<span><a class="mark" href="#inspector_inspector" id="inspector_inspector">#</a></span></h2>
 
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/inspector.js">lib/inspector.js</a></p>
+<p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/inspector.js">lib/inspector.js</a></p>
 <p>The <code>inspector</code> module provides an API for interacting with the V8 inspector.</p>
 <p>It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> inspector = <span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>);</code></pre>
-<h2><code>inspector.close()</code><span><a class="mark" href="#inspector_inspector_close" id="inspector_inspector_close">#</a></span></h2>
+<section><h3><code>inspector.close()</code><span><a class="mark" href="#inspector_inspector_close" id="inspector_inspector_close">#</a></span></h3>
 <p>Deactivate the inspector. Blocks until there are no active connections.</p>
-<h2><code>inspector.console</code><span><a class="mark" href="#inspector_inspector_console" id="inspector_inspector_console">#</a></span></h2>
+</section><section><h3><code>inspector.console</code><span><a class="mark" href="#inspector_inspector_console" id="inspector_inspector_console">#</a></span></h3>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> An object to send messages to the remote inspector console.</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>).console.log(<span class="hljs-string">'a message'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>).<span class="hljs-property">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a message'</span>);</code></pre>
 <p>The inspector console does not have API parity with Node.js
 console.</p>
-<h2><code>inspector.open([port[, host[, wait]]])</code><span><a class="mark" href="#inspector_inspector_open_port_host_wait" id="inspector_inspector_open_port_host_wait">#</a></span></h2>
+</section><section><h3><code>inspector.open([port[, host[, wait]]])</code><span><a class="mark" href="#inspector_inspector_open_port_host_wait" id="inspector_inspector_open_port_host_wait">#</a></span></h3>
 <ul>
 <li><code>port</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Port to listen on for inspector connections. Optional.
 <strong>Default:</strong> what was specified on the CLI.</li>
@@ -182,44 +194,44 @@ started.</p>
 and flow control has been passed to the debugger client.</p>
 <p>See the <a href="cli.html#inspector_security">security warning</a> regarding the <code>host</code>
 parameter usage.</p>
-<h2><code>inspector.url()</code><span><a class="mark" href="#inspector_inspector_url" id="inspector_inspector_url">#</a></span></h2>
+</section><section><h3><code>inspector.url()</code><span><a class="mark" href="#inspector_inspector_url" id="inspector_inspector_url">#</a></span></h3>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
 </ul>
 <p>Return the URL of the active inspector, or <code>undefined</code> if there is none.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --inspect -p <span class="hljs-string">'inspector.url()'</span></span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --inspect -p <span class="hljs-string">'inspector.url()'</span></span>
 Debugger listening on ws://127.0.0.1:9229/166e272e-7a30-4d09-97ce-f1c012b43c34
 For help see https://nodejs.org/en/docs/inspector
 ws://127.0.0.1:9229/166e272e-7a30-4d09-97ce-f1c012b43c34
 <span class="hljs-meta">
-$</span><span class="bash"> node --inspect=localhost:3000 -p <span class="hljs-string">'inspector.url()'</span></span>
+$ </span><span class="language-bash">node --inspect=localhost:3000 -p <span class="hljs-string">'inspector.url()'</span></span>
 Debugger listening on ws://localhost:3000/51cf8d0e-3c36-4c59-8efd-54519839e56a
 For help see https://nodejs.org/en/docs/inspector
 ws://localhost:3000/51cf8d0e-3c36-4c59-8efd-54519839e56a
 <span class="hljs-meta">
-$</span><span class="bash"> node -p <span class="hljs-string">'inspector.url()'</span></span>
+$ </span><span class="language-bash">node -p <span class="hljs-string">'inspector.url()'</span></span>
 undefined</code></pre>
-<h2><code>inspector.waitForDebugger()</code><span><a class="mark" href="#inspector_inspector_waitfordebugger" id="inspector_inspector_waitfordebugger">#</a></span></h2>
+</section><section><h3><code>inspector.waitForDebugger()</code><span><a class="mark" href="#inspector_inspector_waitfordebugger" id="inspector_inspector_waitfordebugger">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
 <p>Blocks until a client (existing or connected later) has sent
 <code>Runtime.runIfWaitingForDebugger</code> command.</p>
 <p>An exception will be thrown if there is no active inspector.</p>
-<h2>Class: <code>inspector.Session</code><span><a class="mark" href="#inspector_class_inspector_session" id="inspector_class_inspector_session">#</a></span></h2>
+</section><section><h3>Class: <code>inspector.Session</code><span><a class="mark" href="#inspector_class_inspector_session" id="inspector_class_inspector_session">#</a></span></h3>
 <ul>
 <li>Extends: <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
 <p>The <code>inspector.Session</code> is used for dispatching messages to the V8 inspector
 back-end and receiving message responses and notifications.</p>
-<h3><code>new inspector.Session()</code><span><a class="mark" href="#inspector_new_inspector_session" id="inspector_new_inspector_session">#</a></span></h3>
+<h4><code>new inspector.Session()</code><span><a class="mark" href="#inspector_new_inspector_session" id="inspector_new_inspector_session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>Create a new instance of the <code>inspector.Session</code> class. The inspector session
 needs to be connected through <a href="#inspector_session_connect"><code>session.connect()</code></a> before the messages
 can be dispatched to the inspector backend.</p>
-<h3>Event: <code>'inspectorNotification'</code><span><a class="mark" href="#inspector_event_inspectornotification" id="inspector_event_inspectornotification">#</a></span></h3>
+<h4>Event: <code>'inspectorNotification'</code><span><a class="mark" href="#inspector_event_inspectornotification" id="inspector_event_inspectornotification">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -227,11 +239,11 @@ can be dispatched to the inspector backend.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The notification message object</li>
 </ul>
 <p>Emitted when any notification from the V8 Inspector is received.</p>
-<pre><code class="language-js">session.on(<span class="hljs-string">'inspectorNotification'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(message.method));
+<pre><code class="language-js">session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'inspectorNotification'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message.<span class="hljs-property">method</span>));
 <span class="hljs-comment">// Debugger.paused</span>
 <span class="hljs-comment">// Debugger.resumed</span></code></pre>
 <p>It is also possible to subscribe only to notifications with specific method:</p>
-<h3>Event: <code>&#x3C;inspector-protocol-method></code>;<span><a class="mark" href="#inspector_event_inspector_protocol_method" id="inspector_event_inspector_protocol_method">#</a></span></h3>
+<h4>Event: <code>&#x3C;inspector-protocol-method></code>;<span><a class="mark" href="#inspector_event_inspector_protocol_method" id="inspector_event_inspector_protocol_method">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -243,22 +255,22 @@ to the <code>&#x3C;inspector-protocol-method></code> value.</p>
 <p>The following snippet installs a listener on the <a href="https://chromedevtools.github.io/devtools-protocol/v8/Debugger#event-paused"><code>'Debugger.paused'</code></a>
 event, and prints the reason for program suspension whenever program
 execution is suspended (through breakpoints, for example):</p>
-<pre><code class="language-js">session.on(<span class="hljs-string">'Debugger.paused'</span>, <span class="hljs-function">(<span class="hljs-params">{ params }</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(params.hitBreakpoints);
+<pre><code class="language-js">session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'Debugger.paused'</span>, <span class="hljs-function">(<span class="hljs-params">{ params }</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-property">hitBreakpoints</span>);
 });
 <span class="hljs-comment">// [ '/the/file/that/has/the/breakpoint.js:11:0' ]</span></code></pre>
-<h3><code>session.connect()</code><span><a class="mark" href="#inspector_session_connect" id="inspector_session_connect">#</a></span></h3>
+<h4><code>session.connect()</code><span><a class="mark" href="#inspector_session_connect" id="inspector_session_connect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>Connects a session to the inspector back-end.</p>
-<h3><code>session.connectToMainThread()</code><span><a class="mark" href="#inspector_session_connecttomainthread" id="inspector_session_connecttomainthread">#</a></span></h3>
+<h4><code>session.connectToMainThread()</code><span><a class="mark" href="#inspector_session_connecttomainthread" id="inspector_session_connecttomainthread">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.11.0</span>
 </div>
 <p>Connects a session to the main thread inspector back-end. An exception will
 be thrown if this API was not called on a Worker thread.</p>
-<h3><code>session.disconnect()</code><span><a class="mark" href="#inspector_session_disconnect" id="inspector_session_disconnect">#</a></span></h3>
+<h4><code>session.disconnect()</code><span><a class="mark" href="#inspector_session_disconnect" id="inspector_session_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -266,7 +278,7 @@ be thrown if this API was not called on a Worker thread.</p>
 with an error. <a href="#inspector_session_connect"><code>session.connect()</code></a> will need to be called to be able to send
 messages again. Reconnected session will lose all inspector state, such as
 enabled agents or configured breakpoints.</p>
-<h3><code>session.post(method[, params][, callback])</code><span><a class="mark" href="#inspector_session_post_method_params_callback" id="inspector_session_post_method_params_callback">#</a></span></h3>
+<h4><code>session.post(method[, params][, callback])</code><span><a class="mark" href="#inspector_session_post_method_params_callback" id="inspector_session_post_method_params_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -278,8 +290,8 @@ enabled agents or configured breakpoints.</p>
 <p>Posts a message to the inspector back-end. <code>callback</code> will be notified when
 a response is received. <code>callback</code> is a function that accepts two optional
 arguments: error and message-specific result.</p>
-<pre><code class="language-js">session.post(<span class="hljs-string">'Runtime.evaluate'</span>, { <span class="hljs-attr">expression</span>: <span class="hljs-string">'2 + 2'</span> },
-             <span class="hljs-function">(<span class="hljs-params">error, { result }</span>) =></span> <span class="hljs-built_in">console</span>.log(result));
+<pre><code class="language-js">session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'Runtime.evaluate'</span>, { <span class="hljs-attr">expression</span>: <span class="hljs-string">'2 + 2'</span> },
+             <span class="hljs-function">(<span class="hljs-params">error, { result }</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result));
 <span class="hljs-comment">// Output: { type: 'number', value: 4, description: '4' }</span></code></pre>
 <p>The latest version of the V8 inspector protocol is published on the
 <a href="https://chromedevtools.github.io/devtools-protocol/v8/">Chrome DevTools Protocol Viewer</a>.</p>
@@ -287,51 +299,87 @@ arguments: error and message-specific result.</p>
 by V8. Chrome DevTools Protocol domain provides an interface for interacting
 with one of the runtime agents used to inspect the application state and listen
 to the run-time events.</p>
-<h2>Example usage<span><a class="mark" href="#inspector_example_usage" id="inspector_example_usage">#</a></span></h2>
+</section><section><h3>Example usage<span><a class="mark" href="#inspector_example_usage" id="inspector_example_usage">#</a></span></h3>
 <p>Apart from the debugger, various V8 Profilers are available through the DevTools
 protocol.</p>
-<h3>CPU profiler<span><a class="mark" href="#inspector_cpu_profiler" id="inspector_cpu_profiler">#</a></span></h3>
+<h4>CPU profiler<span><a class="mark" href="#inspector_cpu_profiler" id="inspector_cpu_profiler">#</a></span></h4>
 <p>Here's an example showing how to use the <a href="https://chromedevtools.github.io/devtools-protocol/v8/Profiler">CPU Profiler</a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> inspector = <span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> session = <span class="hljs-keyword">new</span> inspector.Session();
-session.connect();
+<span class="hljs-keyword">const</span> session = <span class="hljs-keyword">new</span> inspector.<span class="hljs-title class_">Session</span>();
+session.<span class="hljs-title function_">connect</span>();
 
-session.post(<span class="hljs-string">'Profiler.enable'</span>, <span class="hljs-function">() =></span> {
-  session.post(<span class="hljs-string">'Profiler.start'</span>, <span class="hljs-function">() =></span> {
+session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'Profiler.enable'</span>, <span class="hljs-function">() =></span> {
+  session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'Profiler.start'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-comment">// Invoke business logic under measurement here...</span>
 
     <span class="hljs-comment">// some time later...</span>
-    session.post(<span class="hljs-string">'Profiler.stop'</span>, <span class="hljs-function">(<span class="hljs-params">err, { profile }</span>) =></span> {
+    session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'Profiler.stop'</span>, <span class="hljs-function">(<span class="hljs-params">err, { profile }</span>) =></span> {
       <span class="hljs-comment">// Write profile to disk, upload, etc.</span>
       <span class="hljs-keyword">if</span> (!err) {
-        fs.writeFileSync(<span class="hljs-string">'./profile.cpuprofile'</span>, <span class="hljs-built_in">JSON</span>.stringify(profile));
+        fs.<span class="hljs-title function_">writeFileSync</span>(<span class="hljs-string">'./profile.cpuprofile'</span>, <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(profile));
       }
     });
   });
 });</code></pre>
-<h3>Heap profiler<span><a class="mark" href="#inspector_heap_profiler" id="inspector_heap_profiler">#</a></span></h3>
+<h4>Heap profiler<span><a class="mark" href="#inspector_heap_profiler" id="inspector_heap_profiler">#</a></span></h4>
 <p>Here's an example showing how to use the <a href="https://chromedevtools.github.io/devtools-protocol/v8/HeapProfiler">Heap Profiler</a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> inspector = <span class="hljs-built_in">require</span>(<span class="hljs-string">'inspector'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> session = <span class="hljs-keyword">new</span> inspector.Session();
+<span class="hljs-keyword">const</span> session = <span class="hljs-keyword">new</span> inspector.<span class="hljs-title class_">Session</span>();
 
-<span class="hljs-keyword">const</span> fd = fs.openSync(<span class="hljs-string">'profile.heapsnapshot'</span>, <span class="hljs-string">'w'</span>);
+<span class="hljs-keyword">const</span> fd = fs.<span class="hljs-title function_">openSync</span>(<span class="hljs-string">'profile.heapsnapshot'</span>, <span class="hljs-string">'w'</span>);
 
-session.connect();
+session.<span class="hljs-title function_">connect</span>();
 
-session.on(<span class="hljs-string">'HeapProfiler.addHeapSnapshotChunk'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
-  fs.writeSync(fd, m.params.chunk);
+session.<span class="hljs-title function_">on</span>(<span class="hljs-string">'HeapProfiler.addHeapSnapshotChunk'</span>, <span class="hljs-function">(<span class="hljs-params">m</span>) =></span> {
+  fs.<span class="hljs-title function_">writeSync</span>(fd, m.<span class="hljs-property">params</span>.<span class="hljs-property">chunk</span>);
 });
 
-session.post(<span class="hljs-string">'HeapProfiler.takeHeapSnapshot'</span>, <span class="hljs-literal">null</span>, <span class="hljs-function">(<span class="hljs-params">err, r</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'HeapProfiler.takeHeapSnapshot done:'</span>, err, r);
-  session.disconnect();
-  fs.closeSync(fd);
-});</code></pre>
+session.<span class="hljs-title function_">post</span>(<span class="hljs-string">'HeapProfiler.takeHeapSnapshot'</span>, <span class="hljs-literal">null</span>, <span class="hljs-function">(<span class="hljs-params">err, r</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'HeapProfiler.takeHeapSnapshot done:'</span>, err, r);
+  session.<span class="hljs-title function_">disconnect</span>();
+  fs.<span class="hljs-title function_">closeSync</span>(fd);
+});</code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/inspector.json b/doc/api/inspector.json
index 2ab3bdeb9b23b4c870b28d02e79950973338e149..18fe78575626dd7006ef7d0a02e5d4f24ed489cd 100644
--- a/doc/api/inspector.json
+++ b/doc/api/inspector.json
@@ -6,9 +6,9 @@
       "textRaw": "Inspector",
       "name": "inspector",
       "introduced_in": "v8.0.0",
-      "stability": 1,
-      "stabilityText": "Experimental",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/inspector.js\">lib/inspector.js</a></p>\n<p>The <code>inspector</code> module provides an API for interacting with the V8 inspector.</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const inspector = require('inspector');\n</code></pre>",
+      "stability": 2,
+      "stabilityText": "Stable",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/inspector.js\">lib/inspector.js</a></p>\n<p>The <code>inspector</code> module provides an API for interacting with the V8 inspector.</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const inspector = require('inspector');\n</code></pre>",
       "methods": [
         {
           "textRaw": "`inspector.close()`",
diff --git a/doc/api/inspector.md b/doc/api/inspector.md
index 7dc359a0185404de723dc2b87bedf5c628493ab1..aa41556adc9a11a8aad404d6af8e2f515dfdd967 100644
--- a/doc/api/inspector.md
+++ b/doc/api/inspector.md
@@ -2,7 +2,7 @@
 
 <!--introduced_in=v8.0.0-->
 
-> Stability: 1 - Experimental
+> Stability: 2 - Stable
 
 <!-- source_link=lib/inspector.js -->
 
@@ -45,7 +45,7 @@ started.
 If wait is `true`, will block until a client has connected to the inspect port
 and flow control has been passed to the debugger client.
 
-See the [security warning](cli.html#inspector_security) regarding the `host`
+See the [security warning](cli.md#inspector_security) regarding the `host`
 parameter usage.
 
 ## `inspector.url()`
diff --git a/doc/api/intl.html b/doc/api/intl.html
index 0e0be7fb3dd806b9889917400285fb83bb190872..91d752e8a3cbcfe4d9c8f321b4d3fd8a11cab41d 100644
--- a/doc/api/intl.html
+++ b/doc/api/intl.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Internationalization support | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Internationalization support | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="intl" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/intl.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/intl.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/intl.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/intl.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/intl.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/intl.html">13.x</a></li>
@@ -112,15 +127,13 @@
 <li><a href="https://nodejs.org/docs/latest-v8.x/api/intl.html">8.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/intl.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/intl.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#intl_internationalization_support">Internationalization support</a>
 <ul>
 <li><a href="#intl_options_for_building_node_js">Options for building Node.js</a>
@@ -138,11 +151,10 @@
 <li><a href="#intl_detecting_internationalization_support">Detecting internationalization support</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Internationalization support<span><a class="mark" href="#intl_internationalization_support" id="intl_internationalization_support">#</a></span></h1>
+        <h2>Internationalization support<span><a class="mark" href="#intl_internationalization_support" id="intl_internationalization_support">#</a></span></h2>
 
 
 <p>Node.js has many features that make it easier to write internationalized
@@ -170,22 +182,21 @@ Specification</a> (aka ECMA-402):
 <li><a href="util.html#util_class_util_textdecoder"><code>require('util').TextDecoder</code></a></li>
 <li><a href="https://github.com/tc39/proposal-regexp-unicode-property-escapes"><code>RegExp</code> Unicode Property Escapes</a></li>
 </ul>
-<p>Node.js (and its underlying V8 engine) uses <a href="http://site.icu-project.org/">ICU</a> to implement these features
-in native C/C++ code. However, some of them require a very large ICU data file
-in order to support all locales of the world. Because it is expected that most
-Node.js users will make use of only a small portion of ICU functionality, only
-a subset of the full ICU data set is provided by Node.js by default. Several
-options are provided for customizing and expanding the ICU data set either when
+<p>Node.js and the underlying V8 engine use
+<a href="http://site.icu-project.org/">International Components for Unicode (ICU)</a> to implement these features
+in native C/C++ code. The full ICU data set is provided by Node.js by default.
+However, due to the size of the ICU data file, several
+options are provided for customizing the ICU data set either when
 building or running Node.js.</p>
-<h2>Options for building Node.js<span><a class="mark" href="#intl_options_for_building_node_js" id="intl_options_for_building_node_js">#</a></span></h2>
+<section><h3>Options for building Node.js<span><a class="mark" href="#intl_options_for_building_node_js" id="intl_options_for_building_node_js">#</a></span></h3>
 <p>To control how ICU is used in Node.js, four <code>configure</code> options are available
 during compilation. Additional details on how to compile Node.js are documented
-in <a href="https://github.com/nodejs/node/blob/master/BUILDING.md">BUILDING.md</a>.</p>
+in <a href="https://github.com/nodejs/node/blob/HEAD/BUILDING.md">BUILDING.md</a>.</p>
 <ul>
 <li><code>--with-intl=none</code>/<code>--without-intl</code></li>
 <li><code>--with-intl=system-icu</code></li>
-<li><code>--with-intl=small-icu</code> (default)</li>
-<li><code>--with-intl=full-icu</code></li>
+<li><code>--with-intl=small-icu</code></li>
+<li><code>--with-intl=full-icu</code> (default)</li>
 </ul>
 <p>An overview of available Node.js and JavaScript features for each <code>configure</code>
 option:</p>
@@ -285,15 +296,15 @@ option:</p>
 
 
 
-<table><thead><tr><th></th><th><code>none</code></th><th><code>system-icu</code></th><th><code>small-icu</code></th><th><code>full-icu</code></th></tr></thead><tbody><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize"><code>String.prototype.normalize()</code></a></td><td>none (function is no-op)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><code>String.prototype.to*Case()</code></td><td>full</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl"><code>Intl</code></a></td><td>none (object does not exist)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare"><code>String.prototype.localeCompare()</code></a></td><td>partial (not locale-aware)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><code>String.prototype.toLocale*Case()</code></td><td>partial (not locale-aware)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString"><code>Number.prototype.toLocaleString()</code></a></td><td>partial (not locale-aware)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><code>Date.prototype.toLocale*String()</code></td><td>partial (not locale-aware)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><a href="url.html#url_the_whatwg_url_api">WHATWG URL Parser</a></td><td>partial (no IDN support)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="buffer.html#buffer_buffer_transcode_source_fromenc_toenc"><code>require('buffer').transcode()</code></a></td><td>none (function does not exist)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="repl.html#repl_repl">REPL</a></td><td>partial (inaccurate line editing)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="util.html#util_class_util_textdecoder"><code>require('util').TextDecoder</code></a></td><td>partial (basic encodings support)</td><td>partial/full (depends on OS)</td><td>partial (Unicode-only)</td><td>full</td></tr><tr><td><a href="https://github.com/tc39/proposal-regexp-unicode-property-escapes"><code>RegExp</code> Unicode Property Escapes</a></td><td>none (invalid <code>RegExp</code> error)</td><td>full</td><td>full</td><td>full</td></tr></tbody></table>
+<table><thead><tr><th>Feature</th><th><code>none</code></th><th><code>system-icu</code></th><th><code>small-icu</code></th><th><code>full-icu</code></th></tr></thead><tbody><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize"><code>String.prototype.normalize()</code></a></td><td>none (function is no-op)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><code>String.prototype.to*Case()</code></td><td>full</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl"><code>Intl</code></a></td><td>none (object does not exist)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare"><code>String.prototype.localeCompare()</code></a></td><td>partial (not locale-aware)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><code>String.prototype.toLocale*Case()</code></td><td>partial (not locale-aware)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString"><code>Number.prototype.toLocaleString()</code></a></td><td>partial (not locale-aware)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><code>Date.prototype.toLocale*String()</code></td><td>partial (not locale-aware)</td><td>partial/full (depends on OS)</td><td>partial (English-only)</td><td>full</td></tr><tr><td><a href="url.html#url_the_whatwg_url_api">WHATWG URL Parser</a></td><td>partial (no IDN support)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="buffer.html#buffer_buffer_transcode_source_fromenc_toenc"><code>require('buffer').transcode()</code></a></td><td>none (function does not exist)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="repl.html#repl_repl">REPL</a></td><td>partial (inaccurate line editing)</td><td>full</td><td>full</td><td>full</td></tr><tr><td><a href="util.html#util_class_util_textdecoder"><code>require('util').TextDecoder</code></a></td><td>partial (basic encodings support)</td><td>partial/full (depends on OS)</td><td>partial (Unicode-only)</td><td>full</td></tr><tr><td><a href="https://github.com/tc39/proposal-regexp-unicode-property-escapes"><code>RegExp</code> Unicode Property Escapes</a></td><td>none (invalid <code>RegExp</code> error)</td><td>full</td><td>full</td><td>full</td></tr></tbody></table>
 <p>The "(not locale-aware)" designation denotes that the function carries out its
 operation just like the non-<code>Locale</code> version of the function, if one
 exists. For example, under <code>none</code> mode, <code>Date.prototype.toLocaleString()</code>'s
 operation is identical to that of <code>Date.prototype.toString()</code>.</p>
-<h3>Disable all internationalization features (<code>none</code>)<span><a class="mark" href="#intl_disable_all_internationalization_features_none" id="intl_disable_all_internationalization_features_none">#</a></span></h3>
-<p>If this option is chosen, most internationalization features mentioned above
-will be <strong>unavailable</strong> in the resulting <code>node</code> binary.</p>
-<h3>Build with a pre-installed ICU (<code>system-icu</code>)<span><a class="mark" href="#intl_build_with_a_pre_installed_icu_system_icu" id="intl_build_with_a_pre_installed_icu_system_icu">#</a></span></h3>
+<h4>Disable all internationalization features (<code>none</code>)<span><a class="mark" href="#intl_disable_all_internationalization_features_none" id="intl_disable_all_internationalization_features_none">#</a></span></h4>
+<p>If this option is chosen, ICU is disabled and most internationalization
+features mentioned above will be <strong>unavailable</strong> in the resulting <code>node</code> binary.</p>
+<h4>Build with a pre-installed ICU (<code>system-icu</code>)<span><a class="mark" href="#intl_build_with_a_pre_installed_icu_system_icu" id="intl_build_with_a_pre_installed_icu_system_icu">#</a></span></h4>
 <p>Node.js can link against an ICU build already installed on the system. In fact,
 most Linux distributions already come with ICU installed, and this option would
 make it possible to reuse the same set of data used by other components in the
@@ -304,7 +315,7 @@ supported under <code>system-icu</code>. Features that require ICU locale data i
 addition, such as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat"><code>Intl.DateTimeFormat</code></a> <em>may</em> be fully or partially
 supported, depending on the completeness of the ICU data installed on the
 system.</p>
-<h3>Embed a limited set of ICU data (<code>small-icu</code>)<span><a class="mark" href="#intl_embed_a_limited_set_of_icu_data_small_icu" id="intl_embed_a_limited_set_of_icu_data_small_icu">#</a></span></h3>
+<h4>Embed a limited set of ICU data (<code>small-icu</code>)<span><a class="mark" href="#intl_embed_a_limited_set_of_icu_data_small_icu" id="intl_embed_a_limited_set_of_icu_data_small_icu">#</a></span></h4>
 <p>This option makes the resulting binary link against the ICU library statically,
 and includes a subset of ICU data (typically only the English locale) within
 the <code>node</code> executable.</p>
@@ -312,19 +323,17 @@ the <code>node</code> executable.</p>
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize"><code>String.prototype.normalize()</code></a> and the <a href="url.html#url_the_whatwg_url_api">WHATWG URL parser</a>, are fully
 supported under <code>small-icu</code>. Features that require ICU locale data in addition,
 such as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat"><code>Intl.DateTimeFormat</code></a>, generally only work with the English locale:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> january = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>(<span class="hljs-number">9e8</span>);
-<span class="hljs-keyword">const</span> english = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Intl</span>.DateTimeFormat(<span class="hljs-string">'en'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
-<span class="hljs-keyword">const</span> spanish = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Intl</span>.DateTimeFormat(<span class="hljs-string">'es'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> january = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>(<span class="hljs-number">9e8</span>);
+<span class="hljs-keyword">const</span> english = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Intl</span>.<span class="hljs-title class_">DateTimeFormat</span>(<span class="hljs-string">'en'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
+<span class="hljs-keyword">const</span> spanish = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Intl</span>.<span class="hljs-title class_">DateTimeFormat</span>(<span class="hljs-string">'es'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
 
-<span class="hljs-built_in">console</span>.log(english.format(january));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(english.<span class="hljs-title function_">format</span>(january));
 <span class="hljs-comment">// Prints "January"</span>
-<span class="hljs-built_in">console</span>.log(spanish.format(january));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(spanish.<span class="hljs-title function_">format</span>(january));
 <span class="hljs-comment">// Prints "M01" on small-icu</span>
 <span class="hljs-comment">// Should print "enero"</span></code></pre>
-<p>This mode provides a good balance between features and binary size, and it is
-the default behavior if no <code>--with-intl</code> flag is passed. The official binaries
-are also built in this mode.</p>
-<h4>Providing ICU data at runtime<span><a class="mark" href="#intl_providing_icu_data_at_runtime" id="intl_providing_icu_data_at_runtime">#</a></span></h4>
+<p>This mode provides a balance between features and binary size.</p>
+<h5>Providing ICU data at runtime<span><a class="mark" href="#intl_providing_icu_data_at_runtime" id="intl_providing_icu_data_at_runtime">#</a></span></h5>
 <p>If the <code>small-icu</code> option is used, one can still provide additional locale data
 at runtime so that the JS methods would work for all ICU locales. Assuming the
 data file is stored at <code>/some/directory</code>, it can be made available to ICU
@@ -352,25 +361,26 @@ appropriate data file. After installing the module through <code>npm i full-icu<
 the data file will be available at <code>./node_modules/full-icu</code>. This path can be
 then passed either to <code>NODE_ICU_DATA</code> or <code>--icu-data-dir</code> as shown above to
 enable full <code>Intl</code> support.</p>
-<h3>Embed the entire ICU (<code>full-icu</code>)<span><a class="mark" href="#intl_embed_the_entire_icu_full_icu" id="intl_embed_the_entire_icu_full_icu">#</a></span></h3>
+<h4>Embed the entire ICU (<code>full-icu</code>)<span><a class="mark" href="#intl_embed_the_entire_icu_full_icu" id="intl_embed_the_entire_icu_full_icu">#</a></span></h4>
 <p>This option makes the resulting binary link against ICU statically and include
 a full set of ICU data. A binary created this way has no further external
-dependencies and supports all locales, but might be rather large. See
-<a href="https://github.com/nodejs/node/blob/master/BUILDING.md#build-with-full-icu-support-all-locales-supported-by-icu">BUILDING.md</a> on how to compile a binary using this mode.</p>
-<h2>Detecting internationalization support<span><a class="mark" href="#intl_detecting_internationalization_support" id="intl_detecting_internationalization_support">#</a></span></h2>
+dependencies and supports all locales, but might be rather large. This is
+the default behavior if no <code>--with-intl</code> flag is passed. The official binaries
+are also built in this mode.</p>
+</section><section><h3>Detecting internationalization support<span><a class="mark" href="#intl_detecting_internationalization_support" id="intl_detecting_internationalization_support">#</a></span></h3>
 <p>To verify that ICU is enabled at all (<code>system-icu</code>, <code>small-icu</code>, or
 <code>full-icu</code>), simply checking the existence of <code>Intl</code> should suffice:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hasICU = <span class="hljs-keyword">typeof</span> <span class="hljs-built_in">Intl</span> === <span class="hljs-string">'object'</span>;</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasICU = <span class="hljs-keyword">typeof</span> <span class="hljs-title class_">Intl</span> === <span class="hljs-string">'object'</span>;</code></pre>
 <p>Alternatively, checking for <code>process.versions.icu</code>, a property defined only
 when ICU is enabled, works too:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> hasICU = <span class="hljs-keyword">typeof</span> process.versions.icu === <span class="hljs-string">'string'</span>;</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> hasICU = <span class="hljs-keyword">typeof</span> process.<span class="hljs-property">versions</span>.<span class="hljs-property">icu</span> === <span class="hljs-string">'string'</span>;</code></pre>
 <p>To check for support for a non-English locale (i.e. <code>full-icu</code> or
 <code>system-icu</code>), <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat"><code>Intl.DateTimeFormat</code></a> can be a good distinguishing factor:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> hasFullICU = (<span class="hljs-function">() =></span> {
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">const</span> january = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>(<span class="hljs-number">9e8</span>);
-    <span class="hljs-keyword">const</span> spanish = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Intl</span>.DateTimeFormat(<span class="hljs-string">'es'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
-    <span class="hljs-keyword">return</span> spanish.format(january) === <span class="hljs-string">'enero'</span>;
+    <span class="hljs-keyword">const</span> january = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>(<span class="hljs-number">9e8</span>);
+    <span class="hljs-keyword">const</span> spanish = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Intl</span>.<span class="hljs-title class_">DateTimeFormat</span>(<span class="hljs-string">'es'</span>, { <span class="hljs-attr">month</span>: <span class="hljs-string">'long'</span> });
+    <span class="hljs-keyword">return</span> spanish.<span class="hljs-title function_">format</span>(january) === <span class="hljs-string">'enero'</span>;
   } <span class="hljs-keyword">catch</span> (err) {
     <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
   }
@@ -380,12 +390,48 @@ to be helpful:</p>
 <ul>
 <li><a href="https://github.com/srl295/btest402">btest402</a>: Generally used to check whether Node.js with <code>Intl</code> support is
 built correctly.</li>
-<li><a href="https://github.com/tc39/test262/tree/master/test/intl402">Test262</a>: ECMAScript's official conformance test suite includes a section
+<li><a href="https://github.com/tc39/test262/tree/HEAD/test/intl402">Test262</a>: ECMAScript's official conformance test suite includes a section
 dedicated to ECMA-402.</li>
-</ul>
+</ul></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/intl.json b/doc/api/intl.json
index 100796808e06fd4f3f3f41152f0200adeb5a4e9a..17085abf86ee3c84f9f698d8812f71ce41ae6068 100644
--- a/doc/api/intl.json
+++ b/doc/api/intl.json
@@ -8,17 +8,17 @@
       "name": "Internationalization support",
       "introduced_in": "v8.2.0",
       "type": "misc",
-      "desc": "<p>Node.js has many features that make it easier to write internationalized\nprograms. Some of them are:</p>\n<ul>\n<li>Locale-sensitive or Unicode-aware functions in the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language\nSpecification</a>:\n<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a></li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase\"><code>String.prototype.toLowerCase()</code></a></li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase\"><code>String.prototype.toUpperCase()</code></a></li>\n</ul>\n</li>\n<li>All functionality described in the <a href=\"https://tc39.github.io/ecma402/\">ECMAScript Internationalization API\nSpecification</a> (aka ECMA-402):\n<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\"><code>Intl</code></a> object</li>\n<li>Locale-sensitive methods like <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\"><code>String.prototype.localeCompare()</code></a> and\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString\"><code>Date.prototype.toLocaleString()</code></a></li>\n</ul>\n</li>\n<li>The <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL parser</a>'s <a href=\"https://en.wikipedia.org/wiki/Internationalized_domain_name\">internationalized domain names</a> (IDNs) support</li>\n<li><a href=\"buffer.html#buffer_buffer_transcode_source_fromenc_toenc\"><code>require('buffer').transcode()</code></a></li>\n<li>More accurate <a href=\"repl.html#repl_repl\">REPL</a> line editing</li>\n<li><a href=\"util.html#util_class_util_textdecoder\"><code>require('util').TextDecoder</code></a></li>\n<li><a href=\"https://github.com/tc39/proposal-regexp-unicode-property-escapes\"><code>RegExp</code> Unicode Property Escapes</a></li>\n</ul>\n<p>Node.js (and its underlying V8 engine) uses <a href=\"http://site.icu-project.org/\">ICU</a> to implement these features\nin native C/C++ code. However, some of them require a very large ICU data file\nin order to support all locales of the world. Because it is expected that most\nNode.js users will make use of only a small portion of ICU functionality, only\na subset of the full ICU data set is provided by Node.js by default. Several\noptions are provided for customizing and expanding the ICU data set either when\nbuilding or running Node.js.</p>",
+      "desc": "<p>Node.js has many features that make it easier to write internationalized\nprograms. Some of them are:</p>\n<ul>\n<li>Locale-sensitive or Unicode-aware functions in the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language\nSpecification</a>:\n<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a></li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase\"><code>String.prototype.toLowerCase()</code></a></li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase\"><code>String.prototype.toUpperCase()</code></a></li>\n</ul>\n</li>\n<li>All functionality described in the <a href=\"https://tc39.github.io/ecma402/\">ECMAScript Internationalization API\nSpecification</a> (aka ECMA-402):\n<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\"><code>Intl</code></a> object</li>\n<li>Locale-sensitive methods like <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\"><code>String.prototype.localeCompare()</code></a> and\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString\"><code>Date.prototype.toLocaleString()</code></a></li>\n</ul>\n</li>\n<li>The <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL parser</a>'s <a href=\"https://en.wikipedia.org/wiki/Internationalized_domain_name\">internationalized domain names</a> (IDNs) support</li>\n<li><a href=\"buffer.html#buffer_buffer_transcode_source_fromenc_toenc\"><code>require('buffer').transcode()</code></a></li>\n<li>More accurate <a href=\"repl.html#repl_repl\">REPL</a> line editing</li>\n<li><a href=\"util.html#util_class_util_textdecoder\"><code>require('util').TextDecoder</code></a></li>\n<li><a href=\"https://github.com/tc39/proposal-regexp-unicode-property-escapes\"><code>RegExp</code> Unicode Property Escapes</a></li>\n</ul>\n<p>Node.js and the underlying V8 engine use\n<a href=\"http://site.icu-project.org/\">International Components for Unicode (ICU)</a> to implement these features\nin native C/C++ code. The full ICU data set is provided by Node.js by default.\nHowever, due to the size of the ICU data file, several\noptions are provided for customizing the ICU data set either when\nbuilding or running Node.js.</p>",
       "miscs": [
         {
           "textRaw": "Options for building Node.js",
           "name": "options_for_building_node.js",
-          "desc": "<p>To control how ICU is used in Node.js, four <code>configure</code> options are available\nduring compilation. Additional details on how to compile Node.js are documented\nin <a href=\"https://github.com/nodejs/node/blob/master/BUILDING.md\">BUILDING.md</a>.</p>\n<ul>\n<li><code>--with-intl=none</code>/<code>--without-intl</code></li>\n<li><code>--with-intl=system-icu</code></li>\n<li><code>--with-intl=small-icu</code> (default)</li>\n<li><code>--with-intl=full-icu</code></li>\n</ul>\n<p>An overview of available Node.js and JavaScript features for each <code>configure</code>\noption:</p>\n<table>\n<thead>\n<tr>\n<th></th>\n<th><code>none</code></th>\n<th><code>system-icu</code></th>\n<th><code>small-icu</code></th>\n<th><code>full-icu</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a></td>\n<td>none (function is no-op)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>String.prototype.to*Case()</code></td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\"><code>Intl</code></a></td>\n<td>none (object does not exist)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\"><code>String.prototype.localeCompare()</code></a></td>\n<td>partial (not locale-aware)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>String.prototype.toLocale*Case()</code></td>\n<td>partial (not locale-aware)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString\"><code>Number.prototype.toLocaleString()</code></a></td>\n<td>partial (not locale-aware)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>Date.prototype.toLocale*String()</code></td>\n<td>partial (not locale-aware)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL Parser</a></td>\n<td>partial (no IDN support)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"buffer.html#buffer_buffer_transcode_source_fromenc_toenc\"><code>require('buffer').transcode()</code></a></td>\n<td>none (function does not exist)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"repl.html#repl_repl\">REPL</a></td>\n<td>partial (inaccurate line editing)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"util.html#util_class_util_textdecoder\"><code>require('util').TextDecoder</code></a></td>\n<td>partial (basic encodings support)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (Unicode-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://github.com/tc39/proposal-regexp-unicode-property-escapes\"><code>RegExp</code> Unicode Property Escapes</a></td>\n<td>none (invalid <code>RegExp</code> error)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n</tbody>\n</table>\n<p>The \"(not locale-aware)\" designation denotes that the function carries out its\noperation just like the non-<code>Locale</code> version of the function, if one\nexists. For example, under <code>none</code> mode, <code>Date.prototype.toLocaleString()</code>'s\noperation is identical to that of <code>Date.prototype.toString()</code>.</p>",
+          "desc": "<p>To control how ICU is used in Node.js, four <code>configure</code> options are available\nduring compilation. Additional details on how to compile Node.js are documented\nin <a href=\"https://github.com/nodejs/node/blob/HEAD/BUILDING.md\">BUILDING.md</a>.</p>\n<ul>\n<li><code>--with-intl=none</code>/<code>--without-intl</code></li>\n<li><code>--with-intl=system-icu</code></li>\n<li><code>--with-intl=small-icu</code></li>\n<li><code>--with-intl=full-icu</code> (default)</li>\n</ul>\n<p>An overview of available Node.js and JavaScript features for each <code>configure</code>\noption:</p>\n<table>\n<thead>\n<tr>\n<th>Feature</th>\n<th><code>none</code></th>\n<th><code>system-icu</code></th>\n<th><code>small-icu</code></th>\n<th><code>full-icu</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a></td>\n<td>none (function is no-op)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>String.prototype.to*Case()</code></td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\"><code>Intl</code></a></td>\n<td>none (object does not exist)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\"><code>String.prototype.localeCompare()</code></a></td>\n<td>partial (not locale-aware)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>String.prototype.toLocale*Case()</code></td>\n<td>partial (not locale-aware)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString\"><code>Number.prototype.toLocaleString()</code></a></td>\n<td>partial (not locale-aware)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><code>Date.prototype.toLocale*String()</code></td>\n<td>partial (not locale-aware)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (English-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL Parser</a></td>\n<td>partial (no IDN support)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"buffer.html#buffer_buffer_transcode_source_fromenc_toenc\"><code>require('buffer').transcode()</code></a></td>\n<td>none (function does not exist)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"repl.html#repl_repl\">REPL</a></td>\n<td>partial (inaccurate line editing)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"util.html#util_class_util_textdecoder\"><code>require('util').TextDecoder</code></a></td>\n<td>partial (basic encodings support)</td>\n<td>partial/full (depends on OS)</td>\n<td>partial (Unicode-only)</td>\n<td>full</td>\n</tr>\n<tr>\n<td><a href=\"https://github.com/tc39/proposal-regexp-unicode-property-escapes\"><code>RegExp</code> Unicode Property Escapes</a></td>\n<td>none (invalid <code>RegExp</code> error)</td>\n<td>full</td>\n<td>full</td>\n<td>full</td>\n</tr>\n</tbody>\n</table>\n<p>The \"(not locale-aware)\" designation denotes that the function carries out its\noperation just like the non-<code>Locale</code> version of the function, if one\nexists. For example, under <code>none</code> mode, <code>Date.prototype.toLocaleString()</code>'s\noperation is identical to that of <code>Date.prototype.toString()</code>.</p>",
           "modules": [
             {
               "textRaw": "Disable all internationalization features (`none`)",
               "name": "disable_all_internationalization_features_(`none`)",
-              "desc": "<p>If this option is chosen, most internationalization features mentioned above\nwill be <strong>unavailable</strong> in the resulting <code>node</code> binary.</p>",
+              "desc": "<p>If this option is chosen, ICU is disabled and most internationalization\nfeatures mentioned above will be <strong>unavailable</strong> in the resulting <code>node</code> binary.</p>",
               "type": "module",
               "displayName": "Disable all internationalization features (`none`)"
             },
@@ -32,7 +32,7 @@
             {
               "textRaw": "Embed a limited set of ICU data (`small-icu`)",
               "name": "embed_a_limited_set_of_icu_data_(`small-icu`)",
-              "desc": "<p>This option makes the resulting binary link against the ICU library statically,\nand includes a subset of ICU data (typically only the English locale) within\nthe <code>node</code> executable.</p>\n<p>Functionalities that only require the ICU library itself, such as\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a> and the <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL parser</a>, are fully\nsupported under <code>small-icu</code>. Features that require ICU locale data in addition,\nsuch as <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\"><code>Intl.DateTimeFormat</code></a>, generally only work with the English locale:</p>\n<pre><code class=\"language-js\">const january = new Date(9e8);\nconst english = new Intl.DateTimeFormat('en', { month: 'long' });\nconst spanish = new Intl.DateTimeFormat('es', { month: 'long' });\n\nconsole.log(english.format(january));\n// Prints \"January\"\nconsole.log(spanish.format(january));\n// Prints \"M01\" on small-icu\n// Should print \"enero\"\n</code></pre>\n<p>This mode provides a good balance between features and binary size, and it is\nthe default behavior if no <code>--with-intl</code> flag is passed. The official binaries\nare also built in this mode.</p>",
+              "desc": "<p>This option makes the resulting binary link against the ICU library statically,\nand includes a subset of ICU data (typically only the English locale) within\nthe <code>node</code> executable.</p>\n<p>Functionalities that only require the ICU library itself, such as\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\"><code>String.prototype.normalize()</code></a> and the <a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL parser</a>, are fully\nsupported under <code>small-icu</code>. Features that require ICU locale data in addition,\nsuch as <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\"><code>Intl.DateTimeFormat</code></a>, generally only work with the English locale:</p>\n<pre><code class=\"language-js\">const january = new Date(9e8);\nconst english = new Intl.DateTimeFormat('en', { month: 'long' });\nconst spanish = new Intl.DateTimeFormat('es', { month: 'long' });\n\nconsole.log(english.format(january));\n// Prints \"January\"\nconsole.log(spanish.format(january));\n// Prints \"M01\" on small-icu\n// Should print \"enero\"\n</code></pre>\n<p>This mode provides a balance between features and binary size.</p>",
               "modules": [
                 {
                   "textRaw": "Providing ICU data at runtime",
@@ -48,7 +48,7 @@
             {
               "textRaw": "Embed the entire ICU (`full-icu`)",
               "name": "embed_the_entire_icu_(`full-icu`)",
-              "desc": "<p>This option makes the resulting binary link against ICU statically and include\na full set of ICU data. A binary created this way has no further external\ndependencies and supports all locales, but might be rather large. See\n<a href=\"https://github.com/nodejs/node/blob/master/BUILDING.md#build-with-full-icu-support-all-locales-supported-by-icu\">BUILDING.md</a> on how to compile a binary using this mode.</p>",
+              "desc": "<p>This option makes the resulting binary link against ICU statically and include\na full set of ICU data. A binary created this way has no further external\ndependencies and supports all locales, but might be rather large. This is\nthe default behavior if no <code>--with-intl</code> flag is passed. The official binaries\nare also built in this mode.</p>",
               "type": "module",
               "displayName": "Embed the entire ICU (`full-icu`)"
             }
@@ -59,7 +59,7 @@
         {
           "textRaw": "Detecting internationalization support",
           "name": "detecting_internationalization_support",
-          "desc": "<p>To verify that ICU is enabled at all (<code>system-icu</code>, <code>small-icu</code>, or\n<code>full-icu</code>), simply checking the existence of <code>Intl</code> should suffice:</p>\n<pre><code class=\"language-js\">const hasICU = typeof Intl === 'object';\n</code></pre>\n<p>Alternatively, checking for <code>process.versions.icu</code>, a property defined only\nwhen ICU is enabled, works too:</p>\n<pre><code class=\"language-js\">const hasICU = typeof process.versions.icu === 'string';\n</code></pre>\n<p>To check for support for a non-English locale (i.e. <code>full-icu</code> or\n<code>system-icu</code>), <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\"><code>Intl.DateTimeFormat</code></a> can be a good distinguishing factor:</p>\n<pre><code class=\"language-js\">const hasFullICU = (() => {\n  try {\n    const january = new Date(9e8);\n    const spanish = new Intl.DateTimeFormat('es', { month: 'long' });\n    return spanish.format(january) === 'enero';\n  } catch (err) {\n    return false;\n  }\n})();\n</code></pre>\n<p>For more verbose tests for <code>Intl</code> support, the following resources may be found\nto be helpful:</p>\n<ul>\n<li><a href=\"https://github.com/srl295/btest402\">btest402</a>: Generally used to check whether Node.js with <code>Intl</code> support is\nbuilt correctly.</li>\n<li><a href=\"https://github.com/tc39/test262/tree/master/test/intl402\">Test262</a>: ECMAScript's official conformance test suite includes a section\ndedicated to ECMA-402.</li>\n</ul>",
+          "desc": "<p>To verify that ICU is enabled at all (<code>system-icu</code>, <code>small-icu</code>, or\n<code>full-icu</code>), simply checking the existence of <code>Intl</code> should suffice:</p>\n<pre><code class=\"language-js\">const hasICU = typeof Intl === 'object';\n</code></pre>\n<p>Alternatively, checking for <code>process.versions.icu</code>, a property defined only\nwhen ICU is enabled, works too:</p>\n<pre><code class=\"language-js\">const hasICU = typeof process.versions.icu === 'string';\n</code></pre>\n<p>To check for support for a non-English locale (i.e. <code>full-icu</code> or\n<code>system-icu</code>), <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\"><code>Intl.DateTimeFormat</code></a> can be a good distinguishing factor:</p>\n<pre><code class=\"language-js\">const hasFullICU = (() => {\n  try {\n    const january = new Date(9e8);\n    const spanish = new Intl.DateTimeFormat('es', { month: 'long' });\n    return spanish.format(january) === 'enero';\n  } catch (err) {\n    return false;\n  }\n})();\n</code></pre>\n<p>For more verbose tests for <code>Intl</code> support, the following resources may be found\nto be helpful:</p>\n<ul>\n<li><a href=\"https://github.com/srl295/btest402\">btest402</a>: Generally used to check whether Node.js with <code>Intl</code> support is\nbuilt correctly.</li>\n<li><a href=\"https://github.com/tc39/test262/tree/HEAD/test/intl402\">Test262</a>: ECMAScript's official conformance test suite includes a section\ndedicated to ECMA-402.</li>\n</ul>",
           "type": "misc",
           "displayName": "Detecting internationalization support"
         }
diff --git a/doc/api/intl.md b/doc/api/intl.md
index 31f2dd95e7584ae014ae6bb0ce6cbbc9291caee1..015872330c9433df24ed0dc9c25ff61ba71e45b6 100644
--- a/doc/api/intl.md
+++ b/doc/api/intl.md
@@ -22,12 +22,11 @@ programs. Some of them are:
 * [`require('util').TextDecoder`][]
 * [`RegExp` Unicode Property Escapes][]
 
-Node.js (and its underlying V8 engine) uses [ICU][] to implement these features
-in native C/C++ code. However, some of them require a very large ICU data file
-in order to support all locales of the world. Because it is expected that most
-Node.js users will make use of only a small portion of ICU functionality, only
-a subset of the full ICU data set is provided by Node.js by default. Several
-options are provided for customizing and expanding the ICU data set either when
+Node.js and the underlying V8 engine use
+[International Components for Unicode (ICU)][ICU] to implement these features
+in native C/C++ code. The full ICU data set is provided by Node.js by default.
+However, due to the size of the ICU data file, several
+options are provided for customizing the ICU data set either when
 building or running Node.js.
 
 ## Options for building Node.js
@@ -38,13 +37,13 @@ in [BUILDING.md][].
 
 * `--with-intl=none`/`--without-intl`
 * `--with-intl=system-icu`
-* `--with-intl=small-icu` (default)
-* `--with-intl=full-icu`
+* `--with-intl=small-icu`
+* `--with-intl=full-icu` (default)
 
 An overview of available Node.js and JavaScript features for each `configure`
 option:
 
-|                                         | `none`                            | `system-icu`                 | `small-icu`            | `full-icu` |
+| Feature                                 | `none`                            | `system-icu`                 | `small-icu`            | `full-icu` |
 |-----------------------------------------|-----------------------------------|------------------------------|------------------------|------------|
 | [`String.prototype.normalize()`][]      | none (function is no-op)          | full                         | full                   | full       |
 | `String.prototype.to*Case()`            | full                              | full                         | full                   | full       |
@@ -66,8 +65,8 @@ operation is identical to that of `Date.prototype.toString()`.
 
 ### Disable all internationalization features (`none`)
 
-If this option is chosen, most internationalization features mentioned above
-will be **unavailable** in the resulting `node` binary.
+If this option is chosen, ICU is disabled and most internationalization
+features mentioned above will be **unavailable** in the resulting `node` binary.
 
 ### Build with a pre-installed ICU (`system-icu`)
 
@@ -106,9 +105,7 @@ console.log(spanish.format(january));
 // Should print "enero"
 ```
 
-This mode provides a good balance between features and binary size, and it is
-the default behavior if no `--with-intl` flag is passed. The official binaries
-are also built in this mode.
+This mode provides a balance between features and binary size.
 
 #### Providing ICU data at runtime
 
@@ -149,8 +146,9 @@ enable full `Intl` support.
 
 This option makes the resulting binary link against ICU statically and include
 a full set of ICU data. A binary created this way has no further external
-dependencies and supports all locales, but might be rather large. See
-[BUILDING.md][BUILDING.md#full-icu] on how to compile a binary using this mode.
+dependencies and supports all locales, but might be rather large. This is
+the default behavior if no `--with-intl` flag is passed. The official binaries
+are also built in this mode.
 
 ## Detecting internationalization support
 
@@ -192,27 +190,26 @@ to be helpful:
   dedicated to ECMA-402.
 
 ["ICU Data"]: http://userguide.icu-project.org/icudata
-[`--icu-data-dir`]: cli.html#cli_icu_data_dir_file
+[BUILDING.md]: https://github.com/nodejs/node/blob/HEAD/BUILDING.md
+[ECMA-262]: https://tc39.github.io/ecma262/
+[ECMA-402]: https://tc39.github.io/ecma402/
+[ICU]: http://site.icu-project.org/
+[REPL]: repl.md#repl_repl
+[Test262]: https://github.com/tc39/test262/tree/HEAD/test/intl402
+[WHATWG URL parser]: url.md#url_the_whatwg_url_api
+[`--icu-data-dir`]: cli.md#cli_icu_data_dir_file
 [`Date.prototype.toLocaleString()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
 [`Intl.DateTimeFormat`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
 [`Intl`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl
-[`NODE_ICU_DATA`]: cli.html#cli_node_icu_data_file
+[`NODE_ICU_DATA`]: cli.md#cli_node_icu_data_file
 [`Number.prototype.toLocaleString()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
 [`RegExp` Unicode Property Escapes]: https://github.com/tc39/proposal-regexp-unicode-property-escapes
 [`String.prototype.localeCompare()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare
 [`String.prototype.normalize()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize
 [`String.prototype.toLowerCase()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase
 [`String.prototype.toUpperCase()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase
-[`require('buffer').transcode()`]: buffer.html#buffer_buffer_transcode_source_fromenc_toenc
-[`require('util').TextDecoder`]: util.html#util_class_util_textdecoder
-[BUILDING.md#full-icu]: https://github.com/nodejs/node/blob/master/BUILDING.md#build-with-full-icu-support-all-locales-supported-by-icu
-[BUILDING.md]: https://github.com/nodejs/node/blob/master/BUILDING.md
-[ECMA-262]: https://tc39.github.io/ecma262/
-[ECMA-402]: https://tc39.github.io/ecma402/
-[ICU]: http://site.icu-project.org/
-[REPL]: repl.html#repl_repl
-[Test262]: https://github.com/tc39/test262/tree/master/test/intl402
-[WHATWG URL parser]: url.html#url_the_whatwg_url_api
+[`require('buffer').transcode()`]: buffer.md#buffer_buffer_transcode_source_fromenc_toenc
+[`require('util').TextDecoder`]: util.md#util_class_util_textdecoder
 [btest402]: https://github.com/srl295/btest402
 [full-icu]: https://www.npmjs.com/package/full-icu
 [internationalized domain names]: https://en.wikipedia.org/wiki/Internationalized_domain_name
diff --git a/doc/api/module.html b/doc/api/module.html
index 8c09b9ba67f6123b1b9d6e09b211c42d46b21f3b..d1a344f6738e604deb125c5bc2f6ae87fbddcd4d 100644
--- a/doc/api/module.html
+++ b/doc/api/module.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Modules: module API | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Modules: module API | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="module" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,32 +115,21 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/module.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/module.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/module.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/module.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/module.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/module.html">13.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v12.x/api/module.html">12.x <b>LTS</b></a></li>
-<li><a href="https://nodejs.org/docs/latest-v11.x/api/module.html">11.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v10.x/api/module.html">10.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v9.x/api/module.html">9.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v8.x/api/module.html">8.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v7.x/api/module.html">7.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v6.x/api/module.html">6.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v5.x/api/module.html">5.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v4.x/api/module.html">4.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v0.12.x/api/module.html">0.12.x</a></li>
-<li><a href="https://nodejs.org/docs/latest-v0.10.x/api/module.html">0.10.x</a></li></ol>
+<li><a href="https://nodejs.org/docs/latest-v12.x/api/module.html">12.x <b>LTS</b></a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/module.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/module.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#module_modules_module_api">Modules: <code>module</code> API</a>
 <ul>
 <li><a href="#module_the_module_object">The <code>Module</code> object</a>
@@ -139,7 +142,7 @@
 </li>
 <li><span class="stability_1"><a href="#module_source_map_v3_support">Source map v3 support</a></span>
 <ul>
-<li><a href="#module_module_findsourcemap_path_error"><code>module.findSourceMap(path[, error])</code></a></li>
+<li><a href="#module_module_findsourcemap_path"><code>module.findSourceMap(path)</code></a></li>
 <li><a href="#module_class_module_sourcemap">Class: <code>module.SourceMap</code></a>
 <ul>
 <li><a href="#module_new_sourcemap_payload"><code>new SourceMap(payload)</code></a></li>
@@ -151,20 +154,22 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Modules: <code>module</code> API<span><a class="mark" href="#module_modules_module_api" id="module_modules_module_api">#</a></span></h1>
+        <h2>Modules: <code>module</code> API<span><a class="mark" href="#module_modules_module_api" id="module_modules_module_api">#</a></span></h2>
 
-<h2>The <code>Module</code> object<span><a class="mark" href="#module_the_module_object" id="module_the_module_object">#</a></span></h2>
+<div class="api_metadata">
+<span>Added in: v0.3.7</span>
+</div>
+<section><h3>The <code>Module</code> object<span><a class="mark" href="#module_the_module_object" id="module_the_module_object">#</a></span></h3>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>Provides general utility methods when interacting with instances of
 <code>Module</code>, the <a href="modules.html#modules_the_module_object"><code>module</code></a> variable often seen in <a href="modules.html">CommonJS</a> modules. Accessed
 via <code>import 'module'</code> or <code>require('module')</code>.</p>
-<h3><code>module.builtinModules</code><span><a class="mark" href="#module_module_builtinmodules" id="module_module_builtinmodules">#</a></span></h3>
+<h4><code>module.builtinModules</code><span><a class="mark" href="#module_module_builtinmodules" id="module_module_builtinmodules">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.3.0, v8.10.0, v6.13.0</span>
 </div>
@@ -174,14 +179,14 @@ via <code>import 'module'</code> or <code>require('module')</code>.</p>
 <p>A list of the names of all modules provided by Node.js. Can be used to verify
 if a module is maintained by a third party or not.</p>
 <p><code>module</code> in this context isn't the same object that's provided
-by the <a href="modules_cjs.html#modules_cjs_the_module_wrapper">module wrapper</a>. To access it, require the <code>Module</code> module:</p>
-<pre><code class="language-js"><span class="hljs-comment">// module.mjs</span>
+by the <a href="modules.html#modules_the_module_wrapper">module wrapper</a>. To access it, require the <code>Module</code> module:</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-comment">// module.mjs</span>
 <span class="hljs-comment">// In an ECMAScript module</span>
-<span class="hljs-keyword">import</span> { builtinModules <span class="hljs-keyword">as</span> builtin } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;</code></pre>
-<pre><code class="language-js"><span class="hljs-comment">// module.cjs</span>
+<span class="hljs-keyword">import</span> { builtinModules <span class="hljs-keyword">as</span> builtin } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;</code><code class="language-js cjs"><span class="hljs-comment">// module.cjs</span>
 <span class="hljs-comment">// In a CommonJS module</span>
-<span class="hljs-keyword">const</span> builtin = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>).builtinModules;</code></pre>
-<h3><code>module.createRequire(filename)</code><span><a class="mark" href="#module_module_createrequire_filename" id="module_module_createrequire_filename">#</a></span></h3>
+<span class="hljs-keyword">const</span> builtin = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>).<span class="hljs-property">builtinModules</span>;</code></pre>
+<h4><code>module.createRequire(filename)</code><span><a class="mark" href="#module_module_createrequire_filename" id="module_module_createrequire_filename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.2.0</span>
 </div>
@@ -191,12 +196,12 @@ function. Must be a file URL object, file URL string, or absolute path
 string.</li>
 <li>Returns: <a href="modules.html#modules_require_id" class="type">&#x3C;require></a> Require function</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> { createRequire } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
-<span class="hljs-keyword">const</span> <span class="hljs-built_in">require</span> = createRequire(<span class="hljs-keyword">import</span>.meta.url);
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> { createRequire } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;
+<span class="hljs-keyword">const</span> <span class="hljs-built_in">require</span> = <span class="hljs-title function_">createRequire</span>(<span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>);
 
 <span class="hljs-comment">// sibling-module.js is a CommonJS module.</span>
 <span class="hljs-keyword">const</span> siblingModule = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./sibling-module'</span>);</code></pre>
-<h3><code>module.createRequireFromPath(filename)</code><span><a class="mark" href="#module_module_createrequirefrompath_filename" id="module_module_createrequirefrompath_filename">#</a></span></h3>
+<h4><code>module.createRequireFromPath(filename)</code><span><a class="mark" href="#module_module_createrequirefrompath_filename" id="module_module_createrequirefrompath_filename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span><span>Deprecated since: v12.2.0</span>
 </div>
@@ -207,11 +212,11 @@ function.</li>
 <li>Returns: <a href="modules.html#modules_require_id" class="type">&#x3C;require></a> Require function</li>
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { createRequireFromPath } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);
-<span class="hljs-keyword">const</span> requireUtil = createRequireFromPath(<span class="hljs-string">'../src/utils/'</span>);
+<span class="hljs-keyword">const</span> requireUtil = <span class="hljs-title function_">createRequireFromPath</span>(<span class="hljs-string">'../src/utils/'</span>);
 
 <span class="hljs-comment">// Require `../src/utils/some-tool`</span>
 requireUtil(<span class="hljs-string">'./some-tool'</span>);</code></pre>
-<h3><code>module.syncBuiltinESMExports()</code><span><a class="mark" href="#module_module_syncbuiltinesmexports" id="module_module_syncbuiltinesmexports">#</a></span></h3>
+<h4><code>module.syncBuiltinESMExports()</code><span><a class="mark" href="#module_module_syncbuiltinesmexports" id="module_module_syncbuiltinesmexports">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.12.0</span>
 </div>
@@ -219,24 +224,32 @@ requireUtil(<span class="hljs-string">'./some-tool'</span>);</code></pre>
 builtin <a href="esm.html">ES Modules</a> to match the properties of the <a href="modules.html">CommonJS</a> exports. It
 does not add or remove exported names from the <a href="esm.html">ES Modules</a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+<span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 <span class="hljs-keyword">const</span> { syncBuiltinESMExports } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);
 
-fs.readFile = <span class="hljs-literal">null</span>;
+fs.<span class="hljs-property">readFile</span> = newAPI;
 
-<span class="hljs-keyword">delete</span> fs.readFileSync;
+<span class="hljs-keyword">delete</span> fs.<span class="hljs-property">readFileSync</span>;
 
-fs.newAPI = <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">newAPI</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">newAPI</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// ...</span>
-};
+}
+
+fs.<span class="hljs-property">newAPI</span> = newAPI;
 
-syncBuiltinESMExports();
+<span class="hljs-title function_">syncBuiltinESMExports</span>();
 
-<span class="hljs-keyword">import</span>(<span class="hljs-string">'fs'</span>).then(<span class="hljs-function">(<span class="hljs-params">esmFS</span>) =></span> {
-  assert.strictEqual(esmFS.readFile, <span class="hljs-literal">null</span>);
-  assert.strictEqual(<span class="hljs-string">'readFileSync'</span> <span class="hljs-keyword">in</span> fs, <span class="hljs-literal">true</span>);
-  assert.strictEqual(esmFS.newAPI, <span class="hljs-literal">undefined</span>);
+<span class="hljs-title function_">import</span>(<span class="hljs-string">'fs'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">esmFS</span>) =></span> {
+  <span class="hljs-comment">// It syncs the existing readFile property with the new value</span>
+  assert.<span class="hljs-title function_">strictEqual</span>(esmFS.<span class="hljs-property">readFile</span>, newAPI);
+  <span class="hljs-comment">// readFileSync has been deleted from the required fs</span>
+  assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-string">'readFileSync'</span> <span class="hljs-keyword">in</span> fs, <span class="hljs-literal">false</span>);
+  <span class="hljs-comment">// syncBuiltinESMExports() does not remove readFileSync from esmFS</span>
+  assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-string">'readFileSync'</span> <span class="hljs-keyword">in</span> esmFS, <span class="hljs-literal">true</span>);
+  <span class="hljs-comment">// syncBuiltinESMExports() does not add names</span>
+  assert.<span class="hljs-title function_">strictEqual</span>(esmFS.<span class="hljs-property">newAPI</span>, <span class="hljs-literal">undefined</span>);
 });</code></pre>
-<h2>Source map v3 support<span><a class="mark" href="#module_source_map_v3_support" id="module_source_map_v3_support">#</a></span></h2>
+</section><section><h3>Source map v3 support<span><a class="mark" href="#module_source_map_v3_support" id="module_source_map_v3_support">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v13.7.0, v12.17.0</span>
 </div>
@@ -247,33 +260,29 @@ populated when source map parsing is enabled and
 <p>To enable source map parsing, Node.js must be run with the flag
 <a href="cli.html#cli_enable_source_maps"><code>--enable-source-maps</code></a>, or with code coverage enabled by setting
 <a href="cli.html#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE=dir</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-comment">// module.mjs</span>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-comment">// module.mjs</span>
 <span class="hljs-comment">// In an ECMAScript module</span>
-<span class="hljs-keyword">import</span> { findSourceMap, SourceMap } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;</code></pre>
-<pre><code class="language-js"><span class="hljs-comment">// module.cjs</span>
+<span class="hljs-keyword">import</span> { findSourceMap, <span class="hljs-title class_">SourceMap</span> } <span class="hljs-keyword">from</span> <span class="hljs-string">'module'</span>;</code><code class="language-js cjs"><span class="hljs-comment">// module.cjs</span>
 <span class="hljs-comment">// In a CommonJS module</span>
-<span class="hljs-keyword">const</span> { findSourceMap, SourceMap } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);</code></pre>
-<h3><code>module.findSourceMap(path[, error])</code><span><a class="mark" href="#module_module_findsourcemap_path_error" id="module_module_findsourcemap_path_error">#</a></span></h3>
+<span class="hljs-keyword">const</span> { findSourceMap, <span class="hljs-title class_">SourceMap</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);</code></pre>
+<!-- Anchors to make sure old links find a target -->
+<p><a id="module_module_findsourcemap_path_error"></a></p>
+<h4><code>module.findSourceMap(path)</code><span><a class="mark" href="#module_module_findsourcemap_path" id="module_module_findsourcemap_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v13.7.0, v12.17.0</span>
 </div>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
-<li>Returns: <a href="modules_module.html#modules_module_class_module_sourcemap" class="type">&#x3C;module.SourceMap></a></li>
+<li>Returns: <a href="module.html#module_class_module_sourcemap" class="type">&#x3C;module.SourceMap></a></li>
 </ul>
 <p><code>path</code> is the resolved path for the file for which a corresponding source map
 should be fetched.</p>
-<p>The <code>error</code> instance should be passed as the second parameter to <code>findSourceMap</code>
-in exceptional flows, such as when an overridden
-<a href="https://v8.dev/docs/stack-trace-api#customizing-stack-traces"><code>Error.prepareStackTrace(error, trace)</code></a> is invoked. Modules are not added to
-the module cache until they are successfully loaded. In these cases, source maps
-are associated with the <code>error</code> instance along with the <code>path</code>.</p>
-<h3>Class: <code>module.SourceMap</code><span><a class="mark" href="#module_class_module_sourcemap" id="module_class_module_sourcemap">#</a></span></h3>
+<h4>Class: <code>module.SourceMap</code><span><a class="mark" href="#module_class_module_sourcemap" id="module_class_module_sourcemap">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v13.7.0, v12.17.0</span>
 </div>
-<h4><code>new SourceMap(payload)</code><span><a class="mark" href="#module_new_sourcemap_payload" id="module_new_sourcemap_payload">#</a></span></h4>
+<h5><code>new SourceMap(payload)</code><span><a class="mark" href="#module_new_sourcemap_payload" id="module_new_sourcemap_payload">#</a></span></h5>
 <ul>
 <li><code>payload</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
@@ -288,12 +297,12 @@ are associated with the <code>error</code> instance along with the <code>path</c
 <li><code>mappings</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>sourceRoot</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<h4><code>sourceMap.payload</code><span><a class="mark" href="#module_sourcemap_payload" id="module_sourcemap_payload">#</a></span></h4>
+<h5><code>sourceMap.payload</code><span><a class="mark" href="#module_sourcemap_payload" id="module_sourcemap_payload">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>Getter for the payload used to construct the <a href="#module_class_module_sourcemap"><code>SourceMap</code></a> instance.</p>
-<h4><code>sourceMap.findEntry(lineNumber, columnNumber)</code><span><a class="mark" href="#module_sourcemap_findentry_linenumber_columnnumber" id="module_sourcemap_findentry_linenumber_columnnumber">#</a></span></h4>
+<h5><code>sourceMap.findEntry(lineNumber, columnNumber)</code><span><a class="mark" href="#module_sourcemap_findentry_linenumber_columnnumber" id="module_sourcemap_findentry_linenumber_columnnumber">#</a></span></h5>
 <ul>
 <li><code>lineNumber</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 <li><code>columnNumber</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
@@ -308,10 +317,47 @@ consists of the following keys:</p>
 <li>originalSource: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>originalLine: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 <li>originalColumn: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
+<li>name: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/module.json b/doc/api/module.json
index e24be3c6a9ddd75dca65d8e5fdcef17583e599f2..846798fcd64aaecf08d1e3df972b8402d4f344b9 100644
--- a/doc/api/module.json
+++ b/doc/api/module.json
@@ -5,7 +5,13 @@
     {
       "textRaw": "Modules: `module` API",
       "name": "modules:_`module`_api",
-      "introduced_in": "v0.3.7",
+      "introduced_in": "v12.20.0",
+      "meta": {
+        "added": [
+          "v0.3.7"
+        ],
+        "changes": []
+      },
       "modules": [
         {
           "textRaw": "The `Module` object",
@@ -24,7 +30,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>A list of the names of all modules provided by Node.js. Can be used to verify\nif a module is maintained by a third party or not.</p>\n<p><code>module</code> in this context isn't the same object that's provided\nby the <a href=\"modules_cjs.html#modules_cjs_the_module_wrapper\">module wrapper</a>. To access it, require the <code>Module</code> module:</p>\n<pre><code class=\"language-js\">// module.mjs\n// In an ECMAScript module\nimport { builtinModules as builtin } from 'module';\n</code></pre>\n<pre><code class=\"language-js\">// module.cjs\n// In a CommonJS module\nconst builtin = require('module').builtinModules;\n</code></pre>"
+              "desc": "<p>A list of the names of all modules provided by Node.js. Can be used to verify\nif a module is maintained by a third party or not.</p>\n<p><code>module</code> in this context isn't the same object that's provided\nby the <a href=\"modules.html#modules_the_module_wrapper\">module wrapper</a>. To access it, require the <code>Module</code> module:</p>\n<pre><code class=\"language-mjs\">// module.mjs\n// In an ECMAScript module\nimport { builtinModules as builtin } from 'module';\n</code></pre>\n<pre><code class=\"language-cjs\">// module.cjs\n// In a CommonJS module\nconst builtin = require('module').builtinModules;\n</code></pre>"
             }
           ],
           "methods": [
@@ -56,7 +62,7 @@
                   ]
                 }
               ],
-              "desc": "<pre><code class=\"language-js\">import { createRequire } from 'module';\nconst require = createRequire(import.meta.url);\n\n// sibling-module.js is a CommonJS module.\nconst siblingModule = require('./sibling-module');\n</code></pre>"
+              "desc": "<pre><code class=\"language-mjs\">import { createRequire } from 'module';\nconst require = createRequire(import.meta.url);\n\n// sibling-module.js is a CommonJS module.\nconst siblingModule = require('./sibling-module');\n</code></pre>"
             },
             {
               "textRaw": "`module.createRequireFromPath(filename)`",
@@ -108,7 +114,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>The <code>module.syncBuiltinESMExports()</code> method updates all the live bindings for\nbuiltin <a href=\"esm.html\">ES Modules</a> to match the properties of the <a href=\"modules.html\">CommonJS</a> exports. It\ndoes not add or remove exported names from the <a href=\"esm.html\">ES Modules</a>.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst { syncBuiltinESMExports } = require('module');\n\nfs.readFile = null;\n\ndelete fs.readFileSync;\n\nfs.newAPI = function newAPI() {\n  // ...\n};\n\nsyncBuiltinESMExports();\n\nimport('fs').then((esmFS) => {\n  assert.strictEqual(esmFS.readFile, null);\n  assert.strictEqual('readFileSync' in fs, true);\n  assert.strictEqual(esmFS.newAPI, undefined);\n});\n</code></pre>"
+              "desc": "<p>The <code>module.syncBuiltinESMExports()</code> method updates all the live bindings for\nbuiltin <a href=\"esm.html\">ES Modules</a> to match the properties of the <a href=\"modules.html\">CommonJS</a> exports. It\ndoes not add or remove exported names from the <a href=\"esm.html\">ES Modules</a>.</p>\n<pre><code class=\"language-js\">const fs = require('fs');\nconst assert = require('assert');\nconst { syncBuiltinESMExports } = require('module');\n\nfs.readFile = newAPI;\n\ndelete fs.readFileSync;\n\nfunction newAPI() {\n  // ...\n}\n\nfs.newAPI = newAPI;\n\nsyncBuiltinESMExports();\n\nimport('fs').then((esmFS) => {\n  // It syncs the existing readFile property with the new value\n  assert.strictEqual(esmFS.readFile, newAPI);\n  // readFileSync has been deleted from the required fs\n  assert.strictEqual('readFileSync' in fs, false);\n  // syncBuiltinESMExports() does not remove readFileSync from esmFS\n  assert.strictEqual('readFileSync' in esmFS, true);\n  // syncBuiltinESMExports() does not add names\n  assert.strictEqual(esmFS.newAPI, undefined);\n});\n</code></pre>"
             }
           ],
           "type": "module",
@@ -126,10 +132,10 @@
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p>Helpers for interacting with the source map cache. This cache is\npopulated when source map parsing is enabled and\n<a href=\"https://sourcemaps.info/spec.html#h.lmz475t4mvbx\">source map include directives</a> are found in a modules' footer.</p>\n<p>To enable source map parsing, Node.js must be run with the flag\n<a href=\"cli.html#cli_enable_source_maps\"><code>--enable-source-maps</code></a>, or with code coverage enabled by setting\n<a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE=dir</code></a>.</p>\n<pre><code class=\"language-js\">// module.mjs\n// In an ECMAScript module\nimport { findSourceMap, SourceMap } from 'module';\n</code></pre>\n<pre><code class=\"language-js\">// module.cjs\n// In a CommonJS module\nconst { findSourceMap, SourceMap } = require('module');\n</code></pre>",
+          "desc": "<p>Helpers for interacting with the source map cache. This cache is\npopulated when source map parsing is enabled and\n<a href=\"https://sourcemaps.info/spec.html#h.lmz475t4mvbx\">source map include directives</a> are found in a modules' footer.</p>\n<p>To enable source map parsing, Node.js must be run with the flag\n<a href=\"cli.html#cli_enable_source_maps\"><code>--enable-source-maps</code></a>, or with code coverage enabled by setting\n<a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE=dir</code></a>.</p>\n<pre><code class=\"language-mjs\">// module.mjs\n// In an ECMAScript module\nimport { findSourceMap, SourceMap } from 'module';\n</code></pre>\n<pre><code class=\"language-cjs\">// module.cjs\n// In a CommonJS module\nconst { findSourceMap, SourceMap } = require('module');\n</code></pre>\n<!-- Anchors to make sure old links find a target -->\n<p><a id=\"module_module_findsourcemap_path_error\"></a></p>",
           "methods": [
             {
-              "textRaw": "`module.findSourceMap(path[, error])`",
+              "textRaw": "`module.findSourceMap(path)`",
               "type": "method",
               "name": "findSourceMap",
               "meta": {
@@ -151,16 +157,11 @@
                       "textRaw": "`path` {string}",
                       "name": "path",
                       "type": "string"
-                    },
-                    {
-                      "textRaw": "`error` {Error}",
-                      "name": "error",
-                      "type": "Error"
                     }
                   ]
                 }
               ],
-              "desc": "<p><code>path</code> is the resolved path for the file for which a corresponding source map\nshould be fetched.</p>\n<p>The <code>error</code> instance should be passed as the second parameter to <code>findSourceMap</code>\nin exceptional flows, such as when an overridden\n<a href=\"https://v8.dev/docs/stack-trace-api#customizing-stack-traces\"><code>Error.prepareStackTrace(error, trace)</code></a> is invoked. Modules are not added to\nthe module cache until they are successfully loaded. In these cases, source maps\nare associated with the <code>error</code> instance along with the <code>path</code>.</p>"
+              "desc": "<p><code>path</code> is the resolved path for the file for which a corresponding source map\nshould be fetched.</p>"
             }
           ],
           "classes": [
@@ -209,7 +210,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>Given a line number and column number in the generated source file, returns\nan object representing the position in the original file. The object returned\nconsists of the following keys:</p>\n<ul>\n<li>generatedLine: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>generatedColumn: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>originalSource: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li>originalLine: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>originalColumn: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>"
+                  "desc": "<p>Given a line number and column number in the generated source file, returns\nan object representing the position in the original file. The object returned\nconsists of the following keys:</p>\n<ul>\n<li>generatedLine: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>generatedColumn: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>originalSource: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li>originalLine: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>originalColumn: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li>name: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>"
                 }
               ],
               "signatures": [
diff --git a/doc/api/module.md b/doc/api/module.md
index d0d454ba69714957ef50162a35b4c62483396ace..65744b68d95a8e694e69e354acf89a9dd19ee41c 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -1,6 +1,9 @@
 # Modules: `module` API
 
-<!--introduced_in=v0.3.7-->
+<!--introduced_in=v12.20.0-->
+<!-- YAML
+added: v0.3.7
+-->
 
 ## The `Module` object
 
@@ -26,13 +29,13 @@ if a module is maintained by a third party or not.
 `module` in this context isn't the same object that's provided
 by the [module wrapper][]. To access it, require the `Module` module:
 
-```js
+```mjs
 // module.mjs
 // In an ECMAScript module
 import { builtinModules as builtin } from 'module';
 ```
 
-```js
+```cjs
 // module.cjs
 // In a CommonJS module
 const builtin = require('module').builtinModules;
@@ -48,7 +51,7 @@ added: v12.2.0
   string.
 * Returns: {require} Require function
 
-```js
+```mjs
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
@@ -87,21 +90,29 @@ does not add or remove exported names from the [ES Modules][].
 
 ```js
 const fs = require('fs');
+const assert = require('assert');
 const { syncBuiltinESMExports } = require('module');
 
-fs.readFile = null;
+fs.readFile = newAPI;
 
 delete fs.readFileSync;
 
-fs.newAPI = function newAPI() {
+function newAPI() {
   // ...
-};
+}
+
+fs.newAPI = newAPI;
 
 syncBuiltinESMExports();
 
 import('fs').then((esmFS) => {
-  assert.strictEqual(esmFS.readFile, null);
-  assert.strictEqual('readFileSync' in fs, true);
+  // It syncs the existing readFile property with the new value
+  assert.strictEqual(esmFS.readFile, newAPI);
+  // readFileSync has been deleted from the required fs
+  assert.strictEqual('readFileSync' in fs, false);
+  // syncBuiltinESMExports() does not remove readFileSync from esmFS
+  assert.strictEqual('readFileSync' in esmFS, true);
+  // syncBuiltinESMExports() does not add names
   assert.strictEqual(esmFS.newAPI, undefined);
 });
 ```
@@ -123,19 +134,22 @@ To enable source map parsing, Node.js must be run with the flag
 [`--enable-source-maps`][], or with code coverage enabled by setting
 [`NODE_V8_COVERAGE=dir`][].
 
-```js
+```mjs
 // module.mjs
 // In an ECMAScript module
 import { findSourceMap, SourceMap } from 'module';
 ```
 
-```js
+```cjs
 // module.cjs
 // In a CommonJS module
 const { findSourceMap, SourceMap } = require('module');
 ```
 
-### `module.findSourceMap(path[, error])`
+<!-- Anchors to make sure old links find a target -->
+<a id="module_module_findsourcemap_path_error"></a>
+### `module.findSourceMap(path)`
+
 <!-- YAML
 added:
  - v13.7.0
@@ -143,18 +157,11 @@ added:
 -->
 
 * `path` {string}
-* `error` {Error}
 * Returns: {module.SourceMap}
 
 `path` is the resolved path for the file for which a corresponding source map
 should be fetched.
 
-The `error` instance should be passed as the second parameter to `findSourceMap`
-in exceptional flows, such as when an overridden
-[`Error.prepareStackTrace(error, trace)`][] is invoked. Modules are not added to
-the module cache until they are successfully loaded. In these cases, source maps
-are associated with the `error` instance along with the `path`.
-
 ### Class: `module.SourceMap`
 <!-- YAML
 added:
@@ -199,15 +206,15 @@ consists of the following keys:
 * originalSource: {string}
 * originalLine: {number}
 * originalColumn: {number}
+* name: {string}
 
-[CommonJS]: modules.html
-[ES Modules]: esm.html
+[CommonJS]: modules.md
+[ES Modules]: esm.md
 [Source map v3 format]: https://sourcemaps.info/spec.html#h.mofvlxcwqzej
+[`--enable-source-maps`]: cli.md#cli_enable_source_maps
+[`NODE_V8_COVERAGE=dir`]: cli.md#cli_node_v8_coverage_dir
 [`SourceMap`]: #module_class_module_sourcemap
 [`createRequire()`]: #module_module_createrequire_filename
-[`module`]: modules.html#modules_the_module_object
-[module wrapper]: modules_cjs.html#modules_cjs_the_module_wrapper
+[`module`]: modules.md#modules_the_module_object
+[module wrapper]: modules.md#modules_the_module_wrapper
 [source map include directives]: https://sourcemaps.info/spec.html#h.lmz475t4mvbx
-[`--enable-source-maps`]: cli.html#cli_enable_source_maps
-[`NODE_V8_COVERAGE=dir`]: cli.html#cli_node_v8_coverage_dir
-[`Error.prepareStackTrace(error, trace)`]: https://v8.dev/docs/stack-trace-api#customizing-stack-traces
diff --git a/doc/api/modules.html b/doc/api/modules.html
index 36ef41dca737964332abfcafecbbddb63ce987bf..45ecf1360349651cd8cdf14284371bef1ddd5f84 100644
--- a/doc/api/modules.html
+++ b/doc/api/modules.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Modules: CommonJS modules | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Modules: CommonJS modules | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="modules" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/modules.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/modules.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/modules.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/modules.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/modules.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/modules.html">13.x</a></li>
@@ -118,20 +133,18 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/modules.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/modules.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/modules.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#modules_modules_commonjs_modules">Modules: CommonJS modules</a></span>
 <ul>
 <li><a href="#modules_accessing_the_main_module">Accessing the main module</a></li>
-<li><a href="#modules_addenda_package_manager_tips">Addenda: Package manager tips</a></li>
-<li><a href="#modules_addenda_the_mjs_extension">Addenda: The <code>.mjs</code> extension</a></li>
+<li><a href="#modules_package_manager_tips">Package manager tips</a></li>
+<li><a href="#modules_the_mjs_extension">The <code>.mjs</code> extension</a></li>
 <li><a href="#modules_all_together">All together...</a></li>
 <li><a href="#modules_caching">Caching</a>
 <ul>
@@ -175,6 +188,7 @@
 </li>
 <li><a href="#modules_module_filename"><code>module.filename</code></a></li>
 <li><a href="#modules_module_id"><code>module.id</code></a></li>
+<li><a href="#modules_module_ispreloading"><code>module.isPreloading</code></a></li>
 <li><a href="#modules_module_loaded"><code>module.loaded</code></a></li>
 <li><span class="stability_0"><a href="#modules_module_parent"><code>module.parent</code></a></span></li>
 <li><a href="#modules_module_path"><code>module.path</code></a></li>
@@ -186,26 +200,25 @@
 <li><a href="#modules_source_map_v3_support">Source map v3 support</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Modules: CommonJS modules<span><a class="mark" href="#modules_modules_commonjs_modules" id="modules_modules_commonjs_modules">#</a></span></h1>
+        <h2>Modules: CommonJS modules<span><a class="mark" href="#modules_modules_commonjs_modules" id="modules_modules_commonjs_modules">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
 <p>In the Node.js module system, each file is treated as a separate module. For
 example, consider a file named <code>foo.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> circle = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./circle.js'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The area of a circle of radius 4 is <span class="hljs-subst">${circle.area(<span class="hljs-number">4</span>)}</span>`</span>);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The area of a circle of radius 4 is <span class="hljs-subst">${circle.area(<span class="hljs-number">4</span>)}</span>`</span>);</code></pre>
 <p>On the first line, <code>foo.js</code> loads the module <code>circle.js</code> that is in the same
 directory as <code>foo.js</code>.</p>
 <p>Here are the contents of <code>circle.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { PI } = <span class="hljs-built_in">Math</span>;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-variable constant_">PI</span> } = <span class="hljs-title class_">Math</span>;
 
-<span class="hljs-built_in">exports</span>.area = <span class="hljs-function">(<span class="hljs-params">r</span>) =></span> PI * r ** <span class="hljs-number">2</span>;
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">area</span> = <span class="hljs-function">(<span class="hljs-params">r</span>) =></span> <span class="hljs-variable constant_">PI</span> * r ** <span class="hljs-number">2</span>;
 
-<span class="hljs-built_in">exports</span>.circumference = <span class="hljs-function">(<span class="hljs-params">r</span>) =></span> <span class="hljs-number">2</span> * PI * r;</code></pre>
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">circumference</span> = <span class="hljs-function">(<span class="hljs-params">r</span>) =></span> <span class="hljs-number">2</span> * <span class="hljs-variable constant_">PI</span> * r;</code></pre>
 <p>The module <code>circle.js</code> has exported the functions <code>area()</code> and
 <code>circumference()</code>. Functions and objects are added to the root of a module
 by specifying additional properties on the special <code>exports</code> object.</p>
@@ -215,22 +228,22 @@ In this example, the variable <code>PI</code> is private to <code>circle.js</cod
 <p>The <code>module.exports</code> property can be assigned a new value (such as a function
 or object).</p>
 <p>Below, <code>bar.js</code> makes use of the <code>square</code> module, which exports a Square class:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> Square = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./square.js'</span>);
-<span class="hljs-keyword">const</span> mySquare = <span class="hljs-keyword">new</span> Square(<span class="hljs-number">2</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The area of mySquare is <span class="hljs-subst">${mySquare.area()}</span>`</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">Square</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./square.js'</span>);
+<span class="hljs-keyword">const</span> mySquare = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Square</span>(<span class="hljs-number">2</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The area of mySquare is <span class="hljs-subst">${mySquare.area()}</span>`</span>);</code></pre>
 <p>The <code>square</code> module is defined in <code>square.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Assigning to exports will not modify module, must use module.exports</span>
-<span class="hljs-built_in">module</span>.exports = <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Square</span> </span>{
-  <span class="hljs-keyword">constructor</span>(width) {
-    <span class="hljs-built_in">this</span>.width = width;
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-keyword">class</span> <span class="hljs-title class_">Square</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">width</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">width</span> = width;
   }
 
-  area() {
-    <span class="hljs-keyword">return</span> <span class="hljs-built_in">this</span>.width ** <span class="hljs-number">2</span>;
+  <span class="hljs-title function_">area</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">width</span> ** <span class="hljs-number">2</span>;
   }
 };</code></pre>
 <p>The module system is implemented in the <code>require('module')</code> module.</p>
-<h2>Accessing the main module<span><a class="mark" href="#modules_accessing_the_main_module" id="modules_accessing_the_main_module">#</a></span></h2>
+<section><h3>Accessing the main module<span><a class="mark" href="#modules_accessing_the_main_module" id="modules_accessing_the_main_module">#</a></span></h3>
 
 <p>When a file is run directly from Node.js, <code>require.main</code> is set to its
 <code>module</code>. That means that it is possible to determine whether a file has been
@@ -240,7 +253,7 @@ run directly by testing <code>require.main === module</code>.</p>
 <p>Because <code>module</code> provides a <code>filename</code> property (normally equivalent to
 <code>__filename</code>), the entry point of the current application can be obtained
 by checking <code>require.main.filename</code>.</p>
-<h2>Addenda: Package manager tips<span><a class="mark" href="#modules_addenda_package_manager_tips" id="modules_addenda_package_manager_tips">#</a></span></h2>
+</section><section><h3>Package manager tips<span><a class="mark" href="#modules_package_manager_tips" id="modules_package_manager_tips">#</a></span></h3>
 
 <p>The semantics of the Node.js <code>require()</code> function were designed to be general
 enough to support reasonable directory structures. Package manager programs
@@ -283,18 +296,18 @@ also add the <code>/usr/lib/node_modules</code> folder to the <code>$NODE_PATH</
 variable. Since the module lookups using <code>node_modules</code> folders are all
 relative, and based on the real path of the files making the calls to
 <code>require()</code>, the packages themselves can be anywhere.</p>
-<h2>Addenda: The <code>.mjs</code> extension<span><a class="mark" href="#modules_addenda_the_mjs_extension" id="modules_addenda_the_mjs_extension">#</a></span></h2>
+</section><section><h3>The <code>.mjs</code> extension<span><a class="mark" href="#modules_the_mjs_extension" id="modules_the_mjs_extension">#</a></span></h3>
 <p>It is not possible to <code>require()</code> files that have the <code>.mjs</code> extension.
 Attempting to do so will throw <a href="errors.html#errors_err_require_esm">an error</a>. The <code>.mjs</code> extension is
 reserved for <a href="esm.html">ECMAScript Modules</a> which cannot be loaded via <code>require()</code>.
 See <a href="esm.html">ECMAScript Modules</a> for more details.</p>
-<h2>All together...<span><a class="mark" href="#modules_all_together" id="modules_all_together">#</a></span></h2>
+</section><section><h3>All together...<span><a class="mark" href="#modules_all_together" id="modules_all_together">#</a></span></h3>
 
 <p>To get the exact filename that will be loaded when <code>require()</code> is called, use
 the <code>require.resolve()</code> function.</p>
 <p>Putting together all of the above, here is the high-level algorithm
 in pseudocode of what <code>require()</code> does:</p>
-<pre><code class="language-text">require(X) from module at path Y
+<pre>require(X) from module at path Y
 1. If X is a core module,
    a. return the core module
    b. STOP
@@ -355,7 +368,7 @@ LOAD_PACKAGE_IMPORTS(X, DIR)
 2. If no scope was found, return.
 3. If the SCOPE/package.json "imports" is null or undefined, return.
 4. let MATCH = PACKAGE_IMPORTS_RESOLVE(X, pathToFileURL(SCOPE),
-  ["node", "require"]) defined in the ESM resolver.
+  ["node", "require"]) <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 5. RESOLVE_ESM_MATCH(MATCH).
 
 LOAD_PACKAGE_EXPORTS(X, DIR)
@@ -366,7 +379,7 @@ LOAD_PACKAGE_EXPORTS(X, DIR)
 3. Parse DIR/NAME/package.json, and look for "exports" field.
 4. If "exports" is null or undefined, return.
 5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(DIR/NAME), "." + SUBPATH,
-   `package.json` "exports", ["node", "require"]) defined in the ESM resolver.
+   `package.json` "exports", ["node", "require"]) <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 6. RESOLVE_ESM_MATCH(MATCH)
 
 LOAD_PACKAGE_SELF(X, DIR)
@@ -376,7 +389,7 @@ LOAD_PACKAGE_SELF(X, DIR)
 4. If the SCOPE/package.json "name" is not the first segment of X, return.
 5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(SCOPE),
    "." + X.slice("name".length), `package.json` "exports", ["node", "require"])
-   defined in the ESM resolver.
+   <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 6. RESOLVE_ESM_MATCH(MATCH)
 
 RESOLVE_ESM_MATCH(MATCH)
@@ -388,8 +401,9 @@ RESOLVE_ESM_MATCH(MATCH)
 4. Otherwise, if EXACT is false,
    a. LOAD_AS_FILE(RESOLVED_PATH)
    b. LOAD_AS_DIRECTORY(RESOLVED_PATH)
-5. THROW "not found"</code></pre>
-<h2>Caching<span><a class="mark" href="#modules_caching" id="modules_caching">#</a></span></h2>
+5. THROW "not found"
+</pre>
+</section><section><h3>Caching<span><a class="mark" href="#modules_caching" id="modules_caching">#</a></span></h3>
 
 <p>Modules are cached after the first time they are loaded. This means (among other
 things) that every call to <code>require('foo')</code> will get exactly the same object
@@ -400,7 +414,7 @@ important feature. With it, "partially done" objects can be returned, thus
 allowing transitive dependencies to be loaded even when they would cause cycles.</p>
 <p>To have a module execute code multiple times, export a function, and call that
 function.</p>
-<h3>Module caching caveats<span><a class="mark" href="#modules_module_caching_caveats" id="modules_module_caching_caveats">#</a></span></h3>
+<h4>Module caching caveats<span><a class="mark" href="#modules_module_caching_caveats" id="modules_module_caching_caveats">#</a></span></h4>
 
 <p>Modules are cached based on their resolved filename. Since modules may resolve
 to a different filename based on the location of the calling module (loading
@@ -411,8 +425,17 @@ resolved filenames can point to the same file, but the cache will still treat
 them as different modules and will reload the file multiple times. For example,
 <code>require('./foo')</code> and <code>require('./FOO')</code> return two different objects,
 irrespective of whether or not <code>./foo</code> and <code>./FOO</code> are the same file.</p>
-<h2>Core modules<span><a class="mark" href="#modules_core_modules" id="modules_core_modules">#</a></span></h2>
+</section><section><h3>Core modules<span><a class="mark" href="#modules_core_modules" id="modules_core_modules">#</a></span></h3>
 
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Added <code>node:</code> import support to <code>require(...)</code>.</p></td></tr>
+</tbody></table>
+</details>
+</div>
 <p>Node.js has several modules compiled into the binary. These modules are
 described in greater detail elsewhere in this documentation.</p>
 <p>The core modules are defined within the Node.js source and are located in the
@@ -420,30 +443,34 @@ described in greater detail elsewhere in this documentation.</p>
 <p>Core modules are always preferentially loaded if their identifier is
 passed to <code>require()</code>. For instance, <code>require('http')</code> will always
 return the built in HTTP module, even if there is a file by that name.</p>
-<h2>Cycles<span><a class="mark" href="#modules_cycles" id="modules_cycles">#</a></span></h2>
+<p>Core modules can also be identified using the <code>node:</code> prefix, in which case
+it bypasses the <code>require</code> cache. For instance, <code>require('node:http')</code> will
+always return the built in HTTP module, even if there is <code>require.cache</code> entry
+by that name.</p>
+</section><section><h3>Cycles<span><a class="mark" href="#modules_cycles" id="modules_cycles">#</a></span></h3>
 
 <p>When there are circular <code>require()</code> calls, a module might not have finished
 executing when it is returned.</p>
 <p>Consider this situation:</p>
 <p><code>a.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'a starting'</span>);
-<span class="hljs-built_in">exports</span>.done = <span class="hljs-literal">false</span>;
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a starting'</span>);
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">done</span> = <span class="hljs-literal">false</span>;
 <span class="hljs-keyword">const</span> b = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./b.js'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'in a, b.done = %j'</span>, b.done);
-<span class="hljs-built_in">exports</span>.done = <span class="hljs-literal">true</span>;
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'a done'</span>);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'in a, b.done = %j'</span>, b.<span class="hljs-property">done</span>);
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">done</span> = <span class="hljs-literal">true</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'a done'</span>);</code></pre>
 <p><code>b.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'b starting'</span>);
-<span class="hljs-built_in">exports</span>.done = <span class="hljs-literal">false</span>;
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'b starting'</span>);
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">done</span> = <span class="hljs-literal">false</span>;
 <span class="hljs-keyword">const</span> a = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./a.js'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'in b, a.done = %j'</span>, a.done);
-<span class="hljs-built_in">exports</span>.done = <span class="hljs-literal">true</span>;
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'b done'</span>);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'in b, a.done = %j'</span>, a.<span class="hljs-property">done</span>);
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">done</span> = <span class="hljs-literal">true</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'b done'</span>);</code></pre>
 <p><code>main.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'main starting'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'main starting'</span>);
 <span class="hljs-keyword">const</span> a = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./a.js'</span>);
 <span class="hljs-keyword">const</span> b = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./b.js'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'in main, a.done = %j, b.done = %j'</span>, a.done, b.done);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'in main, a.done = %j, b.done = %j'</span>, a.<span class="hljs-property">done</span>, b.<span class="hljs-property">done</span>);</code></pre>
 <p>When <code>main.js</code> loads <code>a.js</code>, then <code>a.js</code> in turn loads <code>b.js</code>. At that
 point, <code>b.js</code> tries to load <code>a.js</code>. In order to prevent an infinite
 loop, an <strong>unfinished copy</strong> of the <code>a.js</code> exports object is returned to the
@@ -451,7 +478,7 @@ loop, an <strong>unfinished copy</strong> of the <code>a.js</code> exports objec
 provided to the <code>a.js</code> module.</p>
 <p>By the time <code>main.js</code> has loaded both modules, they're both finished.
 The output of this program would thus be:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node main.js</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node main.js</span>
 main starting
 a starting
 b starting
@@ -462,7 +489,7 @@ a done
 in main, a.done = true, b.done = true</code></pre>
 <p>Careful planning is required to allow cyclic module dependencies to work
 correctly within an application.</p>
-<h2>File modules<span><a class="mark" href="#modules_file_modules" id="modules_file_modules">#</a></span></h2>
+</section><section><h3>File modules<span><a class="mark" href="#modules_file_modules" id="modules_file_modules">#</a></span></h3>
 
 <p>If the exact filename is not found, then Node.js will attempt to load the
 required filename with the added extensions: <code>.js</code>, <code>.json</code>, and finally
@@ -480,7 +507,7 @@ example, <code>require('/home/marco/foo.js')</code> will load the file at
 either be a core module or is loaded from a <code>node_modules</code> folder.</p>
 <p>If the given path does not exist, <code>require()</code> will throw an <a href="errors.html#errors_class_error"><code>Error</code></a> with its
 <code>code</code> property set to <code>'MODULE_NOT_FOUND'</code>.</p>
-<h2>Folders as modules<span><a class="mark" href="#modules_folders_as_modules" id="modules_folders_as_modules">#</a></span></h2>
+</section><section><h3>Folders as modules<span><a class="mark" href="#modules_folders_as_modules" id="modules_folders_as_modules">#</a></span></h3>
 
 <p>It is convenient to organize programs and libraries into self-contained
 directories, and then provide a single entry point to those directories.
@@ -489,8 +516,8 @@ an argument.</p>
 <p>The first is to create a <a href="packages.html#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file in the root of the folder,
 which specifies a <code>main</code> module. An example <a href="packages.html#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file might
 look like this:</p>
-<pre><code class="language-json">{ <span class="hljs-attr">"name"</span> : <span class="hljs-string">"some-library"</span>,
-  <span class="hljs-attr">"main"</span> : <span class="hljs-string">"./lib/some-library.js"</span> }</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span> <span class="hljs-attr">"name"</span> <span class="hljs-punctuation">:</span> <span class="hljs-string">"some-library"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span> <span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/some-library.js"</span> <span class="hljs-punctuation">}</span></code></pre>
 <p>If this was in a folder at <code>./some-library</code>, then
 <code>require('./some-library')</code> would attempt to load
 <code>./some-library/lib/some-library.js</code>.</p>
@@ -507,7 +534,7 @@ example, then <code>require('./some-library')</code> would attempt to load:</p>
 <p>If these attempts fail, then Node.js will report the entire module as missing
 with the default error:</p>
 <pre><code class="language-console">Error: Cannot find module 'some-library'</code></pre>
-<h2>Loading from <code>node_modules</code> folders<span><a class="mark" href="#modules_loading_from_node_modules_folders" id="modules_loading_from_node_modules_folders">#</a></span></h2>
+</section><section><h3>Loading from <code>node_modules</code> folders<span><a class="mark" href="#modules_loading_from_node_modules_folders" id="modules_loading_from_node_modules_folders">#</a></span></h3>
 
 <p>If the module identifier passed to <code>require()</code> is not a
 <a href="#modules_core_modules">core</a> module, and does not begin with <code>'/'</code>, <code>'../'</code>, or
@@ -533,7 +560,7 @@ module by including a path suffix after the module name. For instance
 <code>require('example-module/path/to/file')</code> would resolve <code>path/to/file</code>
 relative to where <code>example-module</code> is located. The suffixed path follows the
 same module resolution semantics.</p>
-<h2>Loading from the global folders<span><a class="mark" href="#modules_loading_from_the_global_folders" id="modules_loading_from_the_global_folders">#</a></span></h2>
+</section><section><h3>Loading from the global folders<span><a class="mark" href="#modules_loading_from_the_global_folders" id="modules_loading_from_the_global_folders">#</a></span></h3>
 
 <p>If the <code>NODE_PATH</code> environment variable is set to a colon-delimited list
 of absolute paths, then Node.js will search those paths for modules if they
@@ -558,11 +585,11 @@ configured <code>node_prefix</code>.</p>
 <p>These are mostly for historic reasons.</p>
 <p>It is strongly encouraged to place dependencies in the local <code>node_modules</code>
 folder. These will be loaded faster, and more reliably.</p>
-<h2>The module wrapper<span><a class="mark" href="#modules_the_module_wrapper" id="modules_the_module_wrapper">#</a></span></h2>
+</section><section><h3>The module wrapper<span><a class="mark" href="#modules_the_module_wrapper" id="modules_the_module_wrapper">#</a></span></h3>
 
 <p>Before a module's code is executed, Node.js will wrap it with a function
 wrapper that looks like the following:</p>
-<pre><code class="language-js">(<span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">exports, require, module, __filename, __dirname</span>) </span>{
+<pre><code class="language-js">(<span class="hljs-keyword">function</span>(<span class="hljs-params"><span class="hljs-built_in">exports</span>, <span class="hljs-built_in">require</span>, <span class="hljs-variable language_">module</span>, __filename, __dirname</span>) {
 <span class="hljs-comment">// Module code actually lives in here</span>
 });</code></pre>
 <p>By doing this, Node.js achieves a few things:</p>
@@ -579,8 +606,8 @@ module's absolute filename and directory path.</li>
 </ul>
 </li>
 </ul>
-<h2>The module scope<span><a class="mark" href="#modules_the_module_scope" id="modules_the_module_scope">#</a></span></h2>
-<h3><code>__dirname</code><span><a class="mark" href="#modules_dirname" id="modules_dirname">#</a></span></h3>
+</section><section><h3>The module scope<span><a class="mark" href="#modules_the_module_scope" id="modules_the_module_scope">#</a></span></h3>
+<h4><code>__dirname</code><span><a class="mark" href="#modules_dirname" id="modules_dirname">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
@@ -591,11 +618,11 @@ module's absolute filename and directory path.</li>
 <p>The directory name of the current module. This is the same as the
 <a href="path.html#path_path_dirname_path"><code>path.dirname()</code></a> of the <a href="#modules_filename"><code>__filename</code></a>.</p>
 <p>Example: running <code>node example.js</code> from <code>/Users/mjr</code></p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(__dirname);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(__dirname);
 <span class="hljs-comment">// Prints: /Users/mjr</span>
-<span class="hljs-built_in">console</span>.log(path.dirname(__filename));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(path.<span class="hljs-title function_">dirname</span>(__filename));
 <span class="hljs-comment">// Prints: /Users/mjr</span></code></pre>
-<h3><code>__filename</code><span><a class="mark" href="#modules_filename" id="modules_filename">#</a></span></h3>
+<h4><code>__filename</code><span><a class="mark" href="#modules_filename" id="modules_filename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
@@ -610,9 +637,9 @@ command line.</p>
 <p>See <a href="#modules_dirname"><code>__dirname</code></a> for the directory name of the current module.</p>
 <p>Examples:</p>
 <p>Running <code>node example.js</code> from <code>/Users/mjr</code></p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(__filename);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(__filename);
 <span class="hljs-comment">// Prints: /Users/mjr/example.js</span>
-<span class="hljs-built_in">console</span>.log(__dirname);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(__dirname);
 <span class="hljs-comment">// Prints: /Users/mjr</span></code></pre>
 <p>Given two modules: <code>a</code> and <code>b</code>, where <code>b</code> is a dependency of
 <code>a</code> and there is a directory structure of:</p>
@@ -623,7 +650,7 @@ command line.</p>
 <p>References to <code>__filename</code> within <code>b.js</code> will return
 <code>/Users/mjr/app/node_modules/b/b.js</code> while references to <code>__filename</code> within
 <code>a.js</code> will return <code>/Users/mjr/app/a.js</code>.</p>
-<h3><code>exports</code><span><a class="mark" href="#modules_exports" id="modules_exports">#</a></span></h3>
+<h4><code>exports</code><span><a class="mark" href="#modules_exports" id="modules_exports">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.12</span>
 </div>
@@ -634,7 +661,7 @@ command line.</p>
 <p>A reference to the <code>module.exports</code> that is shorter to type.
 See the section about the <a href="#modules_exports_shortcut">exports shortcut</a> for details on when to use
 <code>exports</code> and when to use <code>module.exports</code>.</p>
-<h3><code>module</code><span><a class="mark" href="#modules_module" id="modules_module">#</a></span></h3>
+<h4><code>module</code><span><a class="mark" href="#modules_module" id="modules_module">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -645,7 +672,7 @@ See the section about the <a href="#modules_exports_shortcut">exports shortcut</
 <p>A reference to the current module, see the section about the
 <a href="#modules_the_module_object"><code>module</code> object</a>. In particular, <code>module.exports</code> is used for defining what
 a module exports and makes available through <code>require()</code>.</p>
-<h3><code>require(id)</code><span><a class="mark" href="#modules_require_id" id="modules_require_id">#</a></span></h3>
+<h4><code>require(id)</code><span><a class="mark" href="#modules_require_id" id="modules_require_id">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.13</span>
 </div>
@@ -670,7 +697,7 @@ Windows in the same way they would on Unix systems.</p>
 
 <span class="hljs-comment">// Importing a module from node_modules or Node.js built-in module:</span>
 <span class="hljs-keyword">const</span> crypto = <span class="hljs-built_in">require</span>(<span class="hljs-string">'crypto'</span>);</code></pre>
-<h4><code>require.cache</code><span><a class="mark" href="#modules_require_cache" id="modules_require_cache">#</a></span></h4>
+<h5><code>require.cache</code><span><a class="mark" href="#modules_require_cache" id="modules_require_cache">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -683,9 +710,18 @@ This does not apply to <a href="addons.html">native addons</a>, for which reload
 error.</p>
 <p>Adding or replacing entries is also possible. This cache is checked before
 native modules and if a name matching a native module is added to the cache,
-no require call is
-going to receive the native module anymore. Use with care!</p>
-<h4><code>require.extensions</code><span><a class="mark" href="#modules_require_extensions" id="modules_require_extensions">#</a></span></h4>
+only <code>node:</code>-prefixed require calls are going to receive the native module.
+Use with care!</p>
+<!-- eslint-disable node-core/no-duplicate-requires -->
+<pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
+<span class="hljs-keyword">const</span> realFs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+
+<span class="hljs-keyword">const</span> fakeFs = {};
+<span class="hljs-built_in">require</span>.<span class="hljs-property">cache</span>.<span class="hljs-property">fs</span> = { <span class="hljs-attr">exports</span>: fakeFs };
+
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>), fakeFs);
+assert.<span class="hljs-title function_">strictEqual</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'node:fs'</span>), realFs);</code></pre>
+<h5><code>require.extensions</code><span><a class="mark" href="#modules_require_extensions" id="modules_require_extensions">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span><span>Deprecated since: v0.10.6</span>
 </div>
@@ -695,14 +731,14 @@ going to receive the native module anymore. Use with care!</p>
 </ul>
 <p>Instruct <code>require</code> on how to handle certain file extensions.</p>
 <p>Process files with the extension <code>.sjs</code> as <code>.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>.extensions[<span class="hljs-string">'.sjs'</span>] = <span class="hljs-built_in">require</span>.extensions[<span class="hljs-string">'.js'</span>];</code></pre>
+<pre><code class="language-js"><span class="hljs-built_in">require</span>.<span class="hljs-property">extensions</span>[<span class="hljs-string">'.sjs'</span>] = <span class="hljs-built_in">require</span>.<span class="hljs-property">extensions</span>[<span class="hljs-string">'.js'</span>];</code></pre>
 <p><strong>Deprecated.</strong> In the past, this list has been used to load non-JavaScript
 modules into Node.js by compiling them on-demand. However, in practice, there
 are much better ways to do this, such as loading modules via some other Node.js
 program, or compiling them to JavaScript ahead of time.</p>
 <p>Avoid using <code>require.extensions</code>. Use could cause subtle bugs and resolving the
 extensions gets slower with each registered extension.</p>
-<h4><code>require.main</code><span><a class="mark" href="#modules_require_main" id="modules_require_main">#</a></span></h4>
+<h5><code>require.main</code><span><a class="mark" href="#modules_require_main" id="modules_require_main">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
@@ -713,10 +749,10 @@ extensions gets slower with each registered extension.</p>
 process launched.
 See <a href="#modules_accessing_the_main_module">"Accessing the main module"</a>.</p>
 <p>In <code>entry.js</code> script:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">require</span>.main);</code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-built_in">require</span>.<span class="hljs-property">main</span>);</code></pre>
 <pre><code class="language-bash">node entry.js</code></pre>
 <!-- eslint-skip -->
-<pre><code class="language-js">Module {
+<pre><code class="language-js"><span class="hljs-title class_">Module</span> {
   <span class="hljs-attr">id</span>: <span class="hljs-string">'.'</span>,
   <span class="hljs-attr">path</span>: <span class="hljs-string">'/absolute/path/to'</span>,
   <span class="hljs-attr">exports</span>: {},
@@ -729,7 +765,7 @@ See <a href="#modules_accessing_the_main_module">"Accessing the main module"</a>
      <span class="hljs-string">'/absolute/path/node_modules'</span>,
      <span class="hljs-string">'/absolute/node_modules'</span>,
      <span class="hljs-string">'/node_modules'</span> ] }</code></pre>
-<h4><code>require.resolve(request[, options])</code><span><a class="mark" href="#modules_require_resolve_request_options" id="modules_require_resolve_request_options">#</a></span></h4>
+<h5><code>require.resolve(request[, options])</code><span><a class="mark" href="#modules_require_resolve_request_options" id="modules_require_resolve_request_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -758,7 +794,7 @@ is checked from this location.</li>
 <p>Use the internal <code>require()</code> machinery to look up the location of a module,
 but rather than loading the module, just return the resolved filename.</p>
 <p>If the module can not be found, a <code>MODULE_NOT_FOUND</code> error is thrown.</p>
-<h5><code>require.resolve.paths(request)</code><span><a class="mark" href="#modules_require_resolve_paths_request" id="modules_require_resolve_paths_request">#</a></span></h5>
+<h6><code>require.resolve.paths(request)</code><span><a class="mark" href="#modules_require_resolve_paths_request" id="modules_require_resolve_paths_request">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v8.9.0</span>
 </div>
@@ -769,7 +805,7 @@ but rather than loading the module, just return the resolved filename.</p>
 <p>Returns an array containing the paths searched during resolution of <code>request</code> or
 <code>null</code> if the <code>request</code> string references a core module, for example <code>http</code> or
 <code>fs</code>.</p>
-<h2>The <code>module</code> object<span><a class="mark" href="#modules_the_module_object" id="modules_the_module_object">#</a></span></h2>
+</section><section><h3>The <code>module</code> object<span><a class="mark" href="#modules_the_module_object" id="modules_the_module_object">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -782,7 +818,7 @@ but rather than loading the module, just return the resolved filename.</p>
 representing the current module. For convenience, <code>module.exports</code> is
 also accessible via the <code>exports</code> module-global. <code>module</code> is not actually
 a global but rather local to each module.</p>
-<h3><code>module.children</code><span><a class="mark" href="#modules_module_children" id="modules_module_children">#</a></span></h3>
+<h4><code>module.children</code><span><a class="mark" href="#modules_module_children" id="modules_module_children">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -790,7 +826,7 @@ a global but rather local to each module.</p>
 <li><a href="modules.html#modules_the_module_object" class="type">&#x3C;module[]></a></li>
 </ul>
 <p>The module objects required for the first time by this one.</p>
-<h3><code>module.exports</code><span><a class="mark" href="#modules_module_exports" id="modules_module_exports">#</a></span></h3>
+<h4><code>module.exports</code><span><a class="mark" href="#modules_module_exports" id="modules_module_exports">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -803,30 +839,30 @@ this, assign the desired export object to <code>module.exports</code>. Assigning
 the desired object to <code>exports</code> will simply rebind the local <code>exports</code> variable,
 which is probably not what is desired.</p>
 <p>For example, suppose we were making a module called <code>a.js</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-built_in">module</span>.exports = <span class="hljs-keyword">new</span> EventEmitter();
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">EventEmitter</span>();
 
 <span class="hljs-comment">// Do some work, and after some time emit</span>
 <span class="hljs-comment">// the 'ready' event from the module itself.</span>
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">module</span>.exports.emit(<span class="hljs-string">'ready'</span>);
+  <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'ready'</span>);
 }, <span class="hljs-number">1000</span>);</code></pre>
 <p>Then in another file we could do:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> a = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./a'</span>);
-a.on(<span class="hljs-string">'ready'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'module "a" is ready'</span>);
+a.<span class="hljs-title function_">on</span>(<span class="hljs-string">'ready'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'module "a" is ready'</span>);
 });</code></pre>
 <p>Assignment to <code>module.exports</code> must be done immediately. It cannot be
 done in any callbacks. This does not work:</p>
 <p><code>x.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">module</span>.exports = { <span class="hljs-attr">a</span>: <span class="hljs-string">'hello'</span> };
+  <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = { <span class="hljs-attr">a</span>: <span class="hljs-string">'hello'</span> };
 }, <span class="hljs-number">0</span>);</code></pre>
 <p><code>y.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> x = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./x'</span>);
-<span class="hljs-built_in">console</span>.log(x.a);</code></pre>
-<h4><code>exports</code> shortcut<span><a class="mark" href="#modules_exports_shortcut" id="modules_exports_shortcut">#</a></span></h4>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(x.<span class="hljs-property">a</span>);</code></pre>
+<h5><code>exports</code> shortcut<span><a class="mark" href="#modules_exports_shortcut" id="modules_exports_shortcut">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -835,31 +871,31 @@ assigned the value of <code>module.exports</code> before the module is evaluated
 <p>It allows a shortcut, so that <code>module.exports.f = ...</code> can be written more
 succinctly as <code>exports.f = ...</code>. However, be aware that like any variable, if a
 new value is assigned to <code>exports</code>, it is no longer bound to <code>module.exports</code>:</p>
-<pre><code class="language-js"><span class="hljs-built_in">module</span>.exports.hello = <span class="hljs-literal">true</span>; <span class="hljs-comment">// Exported from require of module</span>
+<pre><code class="language-js"><span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-property">hello</span> = <span class="hljs-literal">true</span>; <span class="hljs-comment">// Exported from require of module</span>
 <span class="hljs-built_in">exports</span> = { <span class="hljs-attr">hello</span>: <span class="hljs-literal">false</span> };  <span class="hljs-comment">// Not exported, only available in the module</span></code></pre>
 <p>When the <code>module.exports</code> property is being completely replaced by a new
 object, it is common to also reassign <code>exports</code>:</p>
 <!-- eslint-disable func-name-matching -->
-<pre><code class="language-js"><span class="hljs-built_in">module</span>.exports = <span class="hljs-built_in">exports</span> = <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">Constructor</span>(<span class="hljs-params"></span>) </span>{
+<pre><code class="language-js"><span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-built_in">exports</span> = <span class="hljs-keyword">function</span> <span class="hljs-title function_">Constructor</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// ... etc.</span>
 };</code></pre>
 <p>To illustrate the behavior, imagine this hypothetical implementation of
 <code>require()</code>, which is quite similar to what is actually done by <code>require()</code>:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">require</span>(<span class="hljs-params"><span class="hljs-regexp">/* ... */</span></span>) </span>{
-  <span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = { <span class="hljs-attr">exports</span>: {} };
-  (<span class="hljs-function">(<span class="hljs-params"><span class="hljs-built_in">module</span>, <span class="hljs-built_in">exports</span></span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">require</span>(<span class="hljs-params"><span class="hljs-comment">/* ... */</span></span>) {
+  <span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = { <span class="hljs-attr">exports</span>: {} };
+  (<span class="hljs-function">(<span class="hljs-params"><span class="hljs-variable language_">module</span>, <span class="hljs-built_in">exports</span></span>) =></span> {
     <span class="hljs-comment">// Module code here. In this example, define a function.</span>
-    <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">someFunc</span>(<span class="hljs-params"></span>) </span>{}
+    <span class="hljs-keyword">function</span> <span class="hljs-title function_">someFunc</span>(<span class="hljs-params"></span>) {}
     <span class="hljs-built_in">exports</span> = someFunc;
     <span class="hljs-comment">// At this point, exports is no longer a shortcut to module.exports, and</span>
     <span class="hljs-comment">// this module will still export an empty default object.</span>
-    <span class="hljs-built_in">module</span>.exports = someFunc;
+    <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = someFunc;
     <span class="hljs-comment">// At this point, the module will now export someFunc, instead of the</span>
     <span class="hljs-comment">// default object.</span>
-  })(<span class="hljs-built_in">module</span>, <span class="hljs-built_in">module</span>.exports);
-  <span class="hljs-keyword">return</span> <span class="hljs-built_in">module</span>.exports;
+  })(<span class="hljs-variable language_">module</span>, <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>);
+  <span class="hljs-keyword">return</span> <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>;
 }</code></pre>
-<h3><code>module.filename</code><span><a class="mark" href="#modules_module_filename" id="modules_module_filename">#</a></span></h3>
+<h4><code>module.filename</code><span><a class="mark" href="#modules_module_filename" id="modules_module_filename">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -867,7 +903,7 @@ object, it is common to also reassign <code>exports</code>:</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The fully resolved filename of the module.</p>
-<h3><code>module.id</code><span><a class="mark" href="#modules_module_id" id="modules_module_id">#</a></span></h3>
+<h4><code>module.id</code><span><a class="mark" href="#modules_module_id" id="modules_module_id">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -876,7 +912,15 @@ object, it is common to also reassign <code>exports</code>:</p>
 </ul>
 <p>The identifier for the module. Typically this is the fully resolved
 filename.</p>
-<h3><code>module.loaded</code><span><a class="mark" href="#modules_module_loaded" id="modules_module_loaded">#</a></span></h3>
+<h4><code>module.isPreloading</code><span><a class="mark" href="#modules_module_ispreloading" id="modules_module_ispreloading">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the module is running during the Node.js preload
+phase.</li>
+</ul>
+<h4><code>module.loaded</code><span><a class="mark" href="#modules_module_loaded" id="modules_module_loaded">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -885,9 +929,9 @@ filename.</p>
 </ul>
 <p>Whether or not the module is done loading, or is in the process of
 loading.</p>
-<h3><code>module.parent</code><span><a class="mark" href="#modules_module_parent" id="modules_module_parent">#</a></span></h3>
+<h4><code>module.parent</code><span><a class="mark" href="#modules_module_parent" id="modules_module_parent">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.16</span><span>Deprecated since: v12.19.0, v14.6.0</span>
+<span>Added in: v0.1.16</span><span>Deprecated since: v14.6.0, v12.19.0</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Please use <a href="#modules_require_main"><code>require.main</code></a> and
 <a href="#modules_module_children"><code>module.children</code></a> instead.</div><p></p>
@@ -897,7 +941,7 @@ loading.</p>
 <p>The module that first required this one, or <code>null</code> if the current module is the
 entry point of the current process, or <code>undefined</code> if the module was loaded by
 something that is not a CommonJS module (E.G.: REPL or <code>import</code>).</p>
-<h3><code>module.path</code><span><a class="mark" href="#modules_module_path" id="modules_module_path">#</a></span></h3>
+<h4><code>module.path</code><span><a class="mark" href="#modules_module_path" id="modules_module_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.14.0</span>
 </div>
@@ -906,7 +950,7 @@ something that is not a CommonJS module (E.G.: REPL or <code>import</code>).</p>
 </ul>
 <p>The directory name of the module. This is usually the same as the
 <a href="path.html#path_path_dirname_path"><code>path.dirname()</code></a> of the <a href="#modules_module_id"><code>module.id</code></a>.</p>
-<h3><code>module.paths</code><span><a class="mark" href="#modules_module_paths" id="modules_module_paths">#</a></span></h3>
+<h4><code>module.paths</code><span><a class="mark" href="#modules_module_paths" id="modules_module_paths">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.4.0</span>
 </div>
@@ -914,7 +958,7 @@ something that is not a CommonJS module (E.G.: REPL or <code>import</code>).</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
 <p>The search paths for the module.</p>
-<h3><code>module.require(id)</code><span><a class="mark" href="#modules_module_require_id" id="modules_module_require_id">#</a></span></h3>
+<h4><code>module.require(id)</code><span><a class="mark" href="#modules_module_require_id" id="modules_module_require_id">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.1</span>
 </div>
@@ -928,7 +972,7 @@ something that is not a CommonJS module (E.G.: REPL or <code>import</code>).</p>
 Since <code>require()</code> returns the <code>module.exports</code>, and the <code>module</code> is typically
 <em>only</em> available within a specific module's code, it must be explicitly exported
 in order to be used.</p>
-<h2>The <code>Module</code> object<span><a class="mark" href="#modules_the_module_object_1" id="modules_the_module_object_1">#</a></span></h2>
+</section><section><h3>The <code>Module</code> object<span><a class="mark" href="#modules_the_module_object_1" id="modules_the_module_object_1">#</a></span></h3>
 <p>This section was moved to
 <a href="module.html#module_the_module_object">Modules: <code>module</code> core module</a>.</p>
 <!-- Anchors to make sure old links find a target -->
@@ -938,12 +982,12 @@ in order to be used.</p>
 <li><a id="modules_module_createrequirefrompath_filename" href="module.html#module_module_createrequirefrompath_filename"><code>module.createRequireFromPath(filename)</code></a></li>
 <li><a id="modules_module_syncbuiltinesmexports" href="module.html#module_module_syncbuiltinesmexports"><code>module.syncBuiltinESMExports()</code></a></li>
 </ul>
-<h2>Source map v3 support<span><a class="mark" href="#modules_source_map_v3_support" id="modules_source_map_v3_support">#</a></span></h2>
+</section><section><h3>Source map v3 support<span><a class="mark" href="#modules_source_map_v3_support" id="modules_source_map_v3_support">#</a></span></h3>
 <p>This section was moved to
 <a href="module.html#module_source_map_v3_support">Modules: <code>module</code> core module</a>.</p>
 <!-- Anchors to make sure old links find a target -->
 <ul>
-<li><a id="modules_module_findsourcemap_path_error" href="module.html#module_module_findsourcemap_path_error"><code>module.findSourceMap(path[, error])</code></a></li>
+<li><a id="modules_module_findsourcemap_path_error" href="module.html#module_module_findsourcemap_path"><code>module.findSourceMap(path)</code></a></li>
 <li><a id="modules_class_module_sourcemap" href="module.html#module_class_module_sourcemap">Class: <code>module.SourceMap</code></a>
 <ul>
 <li><a id="modules_new_sourcemap_payload" href="module.html#module_new_sourcemap_payload"><code>new SourceMap(payload)</code></a></li>
@@ -951,10 +995,46 @@ in order to be used.</p>
 <li><a id="modules_sourcemap_findentry_linenumber_columnnumber" href="module.html#module_sourcemap_findentry_linenumber_columnnumber"><code>sourceMap.findEntry(lineNumber, columnNumber)</code></a></li>
 </ul>
 </li>
-</ul>
+</ul></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/modules.json b/doc/api/modules.json
index 14b5b3b1bb7e2f807fa9da66867c19d6ac97b2ab..1a85b9756697a4362beb06ccb3ead148727ac5b7 100644
--- a/doc/api/modules.json
+++ b/doc/api/modules.json
@@ -17,8 +17,8 @@
           "desc": "<p>When a file is run directly from Node.js, <code>require.main</code> is set to its\n<code>module</code>. That means that it is possible to determine whether a file has been\nrun directly by testing <code>require.main === module</code>.</p>\n<p>For a file <code>foo.js</code>, this will be <code>true</code> if run via <code>node foo.js</code>, but\n<code>false</code> if run by <code>require('./foo')</code>.</p>\n<p>Because <code>module</code> provides a <code>filename</code> property (normally equivalent to\n<code>__filename</code>), the entry point of the current application can be obtained\nby checking <code>require.main.filename</code>.</p>"
         },
         {
-          "textRaw": "Addenda: Package manager tips",
-          "name": "Addenda: Package manager tips",
+          "textRaw": "Package manager tips",
+          "name": "Package manager tips",
           "type": "misc",
           "desc": "<p>The semantics of the Node.js <code>require()</code> function were designed to be general\nenough to support reasonable directory structures. Package manager programs\nsuch as <code>dpkg</code>, <code>rpm</code>, and <code>npm</code> will hopefully find it possible to build\nnative packages from Node.js modules without modification.</p>\n<p>Below we give a suggested directory structure that could work:</p>\n<p>Let's say that we wanted to have the folder at\n<code>/usr/lib/node/&#x3C;some-package>/&#x3C;some-version></code> hold the contents of a\nspecific version of a package.</p>\n<p>Packages can depend on one another. In order to install package <code>foo</code>, it\nmay be necessary to install a specific version of package <code>bar</code>. The <code>bar</code>\npackage may itself have dependencies, and in some cases, these may even collide\nor form cyclic dependencies.</p>\n<p>Because Node.js looks up the <code>realpath</code> of any modules it loads (that is, it\nresolves symlinks) and then <a href=\"#modules_loading_from_node_modules_folders\">looks for their dependencies in <code>node_modules</code> folders</a>,\nthis situation can be resolved with the following architecture:</p>\n<ul>\n<li><code>/usr/lib/node/foo/1.2.3/</code>: Contents of the <code>foo</code> package, version 1.2.3.</li>\n<li><code>/usr/lib/node/bar/4.3.2/</code>: Contents of the <code>bar</code> package that <code>foo</code> depends\non.</li>\n<li><code>/usr/lib/node/foo/1.2.3/node_modules/bar</code>: Symbolic link to\n<code>/usr/lib/node/bar/4.3.2/</code>.</li>\n<li><code>/usr/lib/node/bar/4.3.2/node_modules/*</code>: Symbolic links to the packages that\n<code>bar</code> depends on.</li>\n</ul>\n<p>Thus, even if a cycle is encountered, or if there are dependency\nconflicts, every module will be able to get a version of its dependency\nthat it can use.</p>\n<p>When the code in the <code>foo</code> package does <code>require('bar')</code>, it will get the\nversion that is symlinked into <code>/usr/lib/node/foo/1.2.3/node_modules/bar</code>.\nThen, when the code in the <code>bar</code> package calls <code>require('quux')</code>, it'll get\nthe version that is symlinked into\n<code>/usr/lib/node/bar/4.3.2/node_modules/quux</code>.</p>\n<p>Furthermore, to make the module lookup process even more optimal, rather\nthan putting packages directly in <code>/usr/lib/node</code>, we could put them in\n<code>/usr/lib/node_modules/&#x3C;name>/&#x3C;version></code>. Then Node.js will not bother\nlooking for missing dependencies in <code>/usr/node_modules</code> or <code>/node_modules</code>.</p>\n<p>In order to make modules available to the Node.js REPL, it might be useful to\nalso add the <code>/usr/lib/node_modules</code> folder to the <code>$NODE_PATH</code> environment\nvariable. Since the module lookups using <code>node_modules</code> folders are all\nrelative, and based on the real path of the files making the calls to\n<code>require()</code>, the packages themselves can be anywhere.</p>"
         },
@@ -26,7 +26,7 @@
           "textRaw": "All together...",
           "name": "All together...",
           "type": "misc",
-          "desc": "<p>To get the exact filename that will be loaded when <code>require()</code> is called, use\nthe <code>require.resolve()</code> function.</p>\n<p>Putting together all of the above, here is the high-level algorithm\nin pseudocode of what <code>require()</code> does:</p>\n<pre><code class=\"language-text\">require(X) from module at path Y\n1. If X is a core module,\n   a. return the core module\n   b. STOP\n2. If X begins with '/'\n   a. set Y to be the filesystem root\n3. If X begins with './' or '/' or '../'\n   a. LOAD_AS_FILE(Y + X)\n   b. LOAD_AS_DIRECTORY(Y + X)\n   c. THROW \"not found\"\n4. If X begins with '#'\n   a. LOAD_PACKAGE_IMPORTS(X, dirname(Y))\n5. LOAD_PACKAGE_SELF(X, dirname(Y))\n6. LOAD_NODE_MODULES(X, dirname(Y))\n7. THROW \"not found\"\n\nLOAD_AS_FILE(X)\n1. If X is a file, load X as its file extension format. STOP\n2. If X.js is a file, load X.js as JavaScript text. STOP\n3. If X.json is a file, parse X.json to a JavaScript Object. STOP\n4. If X.node is a file, load X.node as binary addon. STOP\n\nLOAD_INDEX(X)\n1. If X/index.js is a file, load X/index.js as JavaScript text. STOP\n2. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP\n3. If X/index.node is a file, load X/index.node as binary addon. STOP\n\nLOAD_AS_DIRECTORY(X)\n1. If X/package.json is a file,\n   a. Parse X/package.json, and look for \"main\" field.\n   b. If \"main\" is a falsy value, GOTO 2.\n   c. let M = X + (json main field)\n   d. LOAD_AS_FILE(M)\n   e. LOAD_INDEX(M)\n   f. LOAD_INDEX(X) DEPRECATED\n   g. THROW \"not found\"\n2. LOAD_INDEX(X)\n\nLOAD_NODE_MODULES(X, START)\n1. let DIRS = NODE_MODULES_PATHS(START)\n2. for each DIR in DIRS:\n   a. LOAD_PACKAGE_EXPORTS(X, DIR)\n   b. LOAD_AS_FILE(DIR/X)\n   c. LOAD_AS_DIRECTORY(DIR/X)\n\nNODE_MODULES_PATHS(START)\n1. let PARTS = path split(START)\n2. let I = count of PARTS - 1\n3. let DIRS = [GLOBAL_FOLDERS]\n4. while I >= 0,\n   a. if PARTS[I] = \"node_modules\" CONTINUE\n   b. DIR = path join(PARTS[0 .. I] + \"node_modules\")\n   c. DIRS = DIRS + DIR\n   d. let I = I - 1\n5. return DIRS\n\nLOAD_PACKAGE_IMPORTS(X, DIR)\n1. Find the closest package scope SCOPE to DIR.\n2. If no scope was found, return.\n3. If the SCOPE/package.json \"imports\" is null or undefined, return.\n4. let MATCH = PACKAGE_IMPORTS_RESOLVE(X, pathToFileURL(SCOPE),\n  [\"node\", \"require\"]) defined in the ESM resolver.\n5. RESOLVE_ESM_MATCH(MATCH).\n\nLOAD_PACKAGE_EXPORTS(X, DIR)\n1. Try to interpret X as a combination of NAME and SUBPATH where the name\n   may have a @scope/ prefix and the subpath begins with a slash (`/`).\n2. If X does not match this pattern or DIR/NAME/package.json is not a file,\n   return.\n3. Parse DIR/NAME/package.json, and look for \"exports\" field.\n4. If \"exports\" is null or undefined, return.\n5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(DIR/NAME), \".\" + SUBPATH,\n   `package.json` \"exports\", [\"node\", \"require\"]) defined in the ESM resolver.\n6. RESOLVE_ESM_MATCH(MATCH)\n\nLOAD_PACKAGE_SELF(X, DIR)\n1. Find the closest package scope SCOPE to DIR.\n2. If no scope was found, return.\n3. If the SCOPE/package.json \"exports\" is null or undefined, return.\n4. If the SCOPE/package.json \"name\" is not the first segment of X, return.\n5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(SCOPE),\n   \".\" + X.slice(\"name\".length), `package.json` \"exports\", [\"node\", \"require\"])\n   defined in the ESM resolver.\n6. RESOLVE_ESM_MATCH(MATCH)\n\nRESOLVE_ESM_MATCH(MATCH)\n1. let { RESOLVED, EXACT } = MATCH\n2. let RESOLVED_PATH = fileURLToPath(RESOLVED)\n3. If EXACT is true,\n   a. If the file at RESOLVED_PATH exists, load RESOLVED_PATH as its extension\n      format. STOP\n4. Otherwise, if EXACT is false,\n   a. LOAD_AS_FILE(RESOLVED_PATH)\n   b. LOAD_AS_DIRECTORY(RESOLVED_PATH)\n5. THROW \"not found\"\n</code></pre>"
+          "desc": "<p>To get the exact filename that will be loaded when <code>require()</code> is called, use\nthe <code>require.resolve()</code> function.</p>\n<p>Putting together all of the above, here is the high-level algorithm\nin pseudocode of what <code>require()</code> does:</p>\n<pre>\nrequire(X) from module at path Y\n1. If X is a core module,\n   a. return the core module\n   b. STOP\n2. If X begins with '/'\n   a. set Y to be the filesystem root\n3. If X begins with './' or '/' or '../'\n   a. LOAD_AS_FILE(Y + X)\n   b. LOAD_AS_DIRECTORY(Y + X)\n   c. THROW \"not found\"\n4. If X begins with '#'\n   a. LOAD_PACKAGE_IMPORTS(X, dirname(Y))\n5. LOAD_PACKAGE_SELF(X, dirname(Y))\n6. LOAD_NODE_MODULES(X, dirname(Y))\n7. THROW \"not found\"\n\nLOAD_AS_FILE(X)\n1. If X is a file, load X as its file extension format. STOP\n2. If X.js is a file, load X.js as JavaScript text. STOP\n3. If X.json is a file, parse X.json to a JavaScript Object. STOP\n4. If X.node is a file, load X.node as binary addon. STOP\n\nLOAD_INDEX(X)\n1. If X/index.js is a file, load X/index.js as JavaScript text. STOP\n2. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP\n3. If X/index.node is a file, load X/index.node as binary addon. STOP\n\nLOAD_AS_DIRECTORY(X)\n1. If X/package.json is a file,\n   a. Parse X/package.json, and look for \"main\" field.\n   b. If \"main\" is a falsy value, GOTO 2.\n   c. let M = X + (json main field)\n   d. LOAD_AS_FILE(M)\n   e. LOAD_INDEX(M)\n   f. LOAD_INDEX(X) DEPRECATED\n   g. THROW \"not found\"\n2. LOAD_INDEX(X)\n\nLOAD_NODE_MODULES(X, START)\n1. let DIRS = NODE_MODULES_PATHS(START)\n2. for each DIR in DIRS:\n   a. LOAD_PACKAGE_EXPORTS(X, DIR)\n   b. LOAD_AS_FILE(DIR/X)\n   c. LOAD_AS_DIRECTORY(DIR/X)\n\nNODE_MODULES_PATHS(START)\n1. let PARTS = path split(START)\n2. let I = count of PARTS - 1\n3. let DIRS = [GLOBAL_FOLDERS]\n4. while I >= 0,\n   a. if PARTS[I] = \"node_modules\" CONTINUE\n   b. DIR = path join(PARTS[0 .. I] + \"node_modules\")\n   c. DIRS = DIRS + DIR\n   d. let I = I - 1\n5. return DIRS\n\nLOAD_PACKAGE_IMPORTS(X, DIR)\n1. Find the closest package scope SCOPE to DIR.\n2. If no scope was found, return.\n3. If the SCOPE/package.json \"imports\" is null or undefined, return.\n4. let MATCH = PACKAGE_IMPORTS_RESOLVE(X, pathToFileURL(SCOPE),\n  [\"node\", \"require\"]) <a href=\"esm.md#resolver-algorithm-specification\">defined in the ESM resolver</a>.\n5. RESOLVE_ESM_MATCH(MATCH).\n\nLOAD_PACKAGE_EXPORTS(X, DIR)\n1. Try to interpret X as a combination of NAME and SUBPATH where the name\n   may have a @scope/ prefix and the subpath begins with a slash (`/`).\n2. If X does not match this pattern or DIR/NAME/package.json is not a file,\n   return.\n3. Parse DIR/NAME/package.json, and look for \"exports\" field.\n4. If \"exports\" is null or undefined, return.\n5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(DIR/NAME), \".\" + SUBPATH,\n   `package.json` \"exports\", [\"node\", \"require\"]) <a href=\"esm.md#resolver-algorithm-specification\">defined in the ESM resolver</a>.\n6. RESOLVE_ESM_MATCH(MATCH)\n\nLOAD_PACKAGE_SELF(X, DIR)\n1. Find the closest package scope SCOPE to DIR.\n2. If no scope was found, return.\n3. If the SCOPE/package.json \"exports\" is null or undefined, return.\n4. If the SCOPE/package.json \"name\" is not the first segment of X, return.\n5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(SCOPE),\n   \".\" + X.slice(\"name\".length), `package.json` \"exports\", [\"node\", \"require\"])\n   <a href=\"esm.md#resolver-algorithm-specification\">defined in the ESM resolver</a>.\n6. RESOLVE_ESM_MATCH(MATCH)\n\nRESOLVE_ESM_MATCH(MATCH)\n1. let { RESOLVED, EXACT } = MATCH\n2. let RESOLVED_PATH = fileURLToPath(RESOLVED)\n3. If EXACT is true,\n   a. If the file at RESOLVED_PATH exists, load RESOLVED_PATH as its extension\n      format. STOP\n4. Otherwise, if EXACT is false,\n   a. LOAD_AS_FILE(RESOLVED_PATH)\n   b. LOAD_AS_DIRECTORY(RESOLVED_PATH)\n5. THROW \"not found\"\n</pre>"
         },
         {
           "textRaw": "Caching",
@@ -46,7 +46,16 @@
           "textRaw": "Core modules",
           "name": "Core modules",
           "type": "misc",
-          "desc": "<p>Node.js has several modules compiled into the binary. These modules are\ndescribed in greater detail elsewhere in this documentation.</p>\n<p>The core modules are defined within the Node.js source and are located in the\n<code>lib/</code> folder.</p>\n<p>Core modules are always preferentially loaded if their identifier is\npassed to <code>require()</code>. For instance, <code>require('http')</code> will always\nreturn the built in HTTP module, even if there is a file by that name.</p>"
+          "meta": {
+            "changes": [
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/37246",
+                "description": "Added `node:` import support to `require(...)`."
+              }
+            ]
+          },
+          "desc": "<p>Node.js has several modules compiled into the binary. These modules are\ndescribed in greater detail elsewhere in this documentation.</p>\n<p>The core modules are defined within the Node.js source and are located in the\n<code>lib/</code> folder.</p>\n<p>Core modules are always preferentially loaded if their identifier is\npassed to <code>require()</code>. For instance, <code>require('http')</code> will always\nreturn the built in HTTP module, even if there is a file by that name.</p>\n<p>Core modules can also be identified using the <code>node:</code> prefix, in which case\nit bypasses the <code>require</code> cache. For instance, <code>require('node:http')</code> will\nalways return the built in HTTP module, even if there is <code>require.cache</code> entry\nby that name.</p>"
         },
         {
           "textRaw": "Cycles",
@@ -87,11 +96,11 @@
       ],
       "modules": [
         {
-          "textRaw": "Addenda: The `.mjs` extension",
-          "name": "addenda:_the_`.mjs`_extension",
+          "textRaw": "The `.mjs` extension",
+          "name": "the_`.mjs`_extension",
           "desc": "<p>It is not possible to <code>require()</code> files that have the <code>.mjs</code> extension.\nAttempting to do so will throw <a href=\"errors.html#errors_err_require_esm\">an error</a>. The <code>.mjs</code> extension is\nreserved for <a href=\"esm.html\">ECMAScript Modules</a> which cannot be loaded via <code>require()</code>.\nSee <a href=\"esm.html\">ECMAScript Modules</a> for more details.</p>",
           "type": "module",
-          "displayName": "Addenda: The `.mjs` extension"
+          "displayName": "The `.mjs` extension"
         },
         {
           "textRaw": "The module scope",
@@ -167,7 +176,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Modules are cached in this object when they are required. By deleting a key\nvalue from this object, the next <code>require</code> will reload the module.\nThis does not apply to <a href=\"addons.html\">native addons</a>, for which reloading will result in an\nerror.</p>\n<p>Adding or replacing entries is also possible. This cache is checked before\nnative modules and if a name matching a native module is added to the cache,\nno require call is\ngoing to receive the native module anymore. Use with care!</p>"
+                  "desc": "<p>Modules are cached in this object when they are required. By deleting a key\nvalue from this object, the next <code>require</code> will reload the module.\nThis does not apply to <a href=\"addons.html\">native addons</a>, for which reloading will result in an\nerror.</p>\n<p>Adding or replacing entries is also possible. This cache is checked before\nnative modules and if a name matching a native module is added to the cache,\nonly <code>node:</code>-prefixed require calls are going to receive the native module.\nUse with care!</p>\n<!-- eslint-disable node-core/no-duplicate-requires -->\n<pre><code class=\"language-js\">const assert = require('assert');\nconst realFs = require('fs');\n\nconst fakeFs = {};\nrequire.cache.fs = { exports: fakeFs };\n\nassert.strictEqual(require('fs'), fakeFs);\nassert.strictEqual(require('node:fs'), realFs);\n</code></pre>"
                 },
                 {
                   "textRaw": "`extensions` {Object}",
@@ -295,11 +304,20 @@
         {
           "textRaw": "Source map v3 support",
           "name": "source_map_v3_support",
-          "desc": "<p>This section was moved to\n<a href=\"module.html#module_source_map_v3_support\">Modules: <code>module</code> core module</a>.</p>\n<!-- Anchors to make sure old links find a target -->\n<ul>\n<li><a id=\"modules_module_findsourcemap_path_error\" href=\"module.html#module_module_findsourcemap_path_error\"><code>module.findSourceMap(path[, error])</code></a></li>\n<li><a id=\"modules_class_module_sourcemap\" href=\"module.html#module_class_module_sourcemap\">Class: <code>module.SourceMap</code></a>\n<ul>\n<li><a id=\"modules_new_sourcemap_payload\" href=\"module.html#module_new_sourcemap_payload\"><code>new SourceMap(payload)</code></a></li>\n<li><a id=\"modules_sourcemap_payload\" href=\"module.html#module_sourcemap_payload\"><code>sourceMap.payload</code></a></li>\n<li><a id=\"modules_sourcemap_findentry_linenumber_columnnumber\" href=\"module.html#module_sourcemap_findentry_linenumber_columnnumber\"><code>sourceMap.findEntry(lineNumber, columnNumber)</code></a></li>\n</ul>\n</li>\n</ul>",
+          "desc": "<p>This section was moved to\n<a href=\"module.html#module_source_map_v3_support\">Modules: <code>module</code> core module</a>.</p>\n<!-- Anchors to make sure old links find a target -->\n<ul>\n<li><a id=\"modules_module_findsourcemap_path_error\" href=\"module.html#module_module_findsourcemap_path\"><code>module.findSourceMap(path)</code></a></li>\n<li><a id=\"modules_class_module_sourcemap\" href=\"module.html#module_class_module_sourcemap\">Class: <code>module.SourceMap</code></a>\n<ul>\n<li><a id=\"modules_new_sourcemap_payload\" href=\"module.html#module_new_sourcemap_payload\"><code>new SourceMap(payload)</code></a></li>\n<li><a id=\"modules_sourcemap_payload\" href=\"module.html#module_sourcemap_payload\"><code>sourceMap.payload</code></a></li>\n<li><a id=\"modules_sourcemap_findentry_linenumber_columnnumber\" href=\"module.html#module_sourcemap_findentry_linenumber_columnnumber\"><code>sourceMap.findEntry(lineNumber, columnNumber)</code></a></li>\n</ul>\n</li>\n</ul>",
           "type": "module",
           "displayName": "Source map v3 support"
         }
       ],
+      "meta": {
+        "changes": [
+          {
+            "version": "v14.18.0",
+            "pr-url": "https://github.com/nodejs/node/pull/37246",
+            "description": "Added `node:` import support to `require(...)`."
+          }
+        ]
+      },
       "vars": [
         {
           "textRaw": "The `module` object",
@@ -376,6 +394,18 @@
               },
               "desc": "<p>The identifier for the module. Typically this is the fully resolved\nfilename.</p>"
             },
+            {
+              "textRaw": "`isPreloading` Type: {boolean} `true` if the module is running during the Node.js preload phase.",
+              "type": "boolean",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "desc": "`true` if the module is running during the Node.js preload phase."
+            },
             {
               "textRaw": "`loaded` {boolean}",
               "type": "boolean",
@@ -397,8 +427,8 @@
                   "v0.1.16"
                 ],
                 "deprecated": [
-                  "v12.19.0",
-                  "v14.6.0"
+                  "v14.6.0",
+                  "v12.19.0"
                 ],
                 "changes": []
               },
diff --git a/doc/api/modules.md b/doc/api/modules.md
index 6c790e2e6291b7e1074f45e16a17e27bba7cdd45..6c86efc3ad1f41729aec39f6d957d090a85d2abb 100644
--- a/doc/api/modules.md
+++ b/doc/api/modules.md
@@ -78,7 +78,7 @@ Because `module` provides a `filename` property (normally equivalent to
 `__filename`), the entry point of the current application can be obtained
 by checking `require.main.filename`.
 
-## Addenda: Package manager tips
+## Package manager tips
 
 <!-- type=misc -->
 
@@ -131,7 +131,7 @@ variable. Since the module lookups using `node_modules` folders are all
 relative, and based on the real path of the files making the calls to
 `require()`, the packages themselves can be anywhere.
 
-## Addenda: The `.mjs` extension
+## The `.mjs` extension
 
 It is not possible to `require()` files that have the `.mjs` extension.
 Attempting to do so will throw [an error][]. The `.mjs` extension is
@@ -148,7 +148,7 @@ the `require.resolve()` function.
 Putting together all of the above, here is the high-level algorithm
 in pseudocode of what `require()` does:
 
-```text
+<pre>
 require(X) from module at path Y
 1. If X is a core module,
    a. return the core module
@@ -210,7 +210,7 @@ LOAD_PACKAGE_IMPORTS(X, DIR)
 2. If no scope was found, return.
 3. If the SCOPE/package.json "imports" is null or undefined, return.
 4. let MATCH = PACKAGE_IMPORTS_RESOLVE(X, pathToFileURL(SCOPE),
-  ["node", "require"]) defined in the ESM resolver.
+  ["node", "require"]) <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 5. RESOLVE_ESM_MATCH(MATCH).
 
 LOAD_PACKAGE_EXPORTS(X, DIR)
@@ -221,7 +221,7 @@ LOAD_PACKAGE_EXPORTS(X, DIR)
 3. Parse DIR/NAME/package.json, and look for "exports" field.
 4. If "exports" is null or undefined, return.
 5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(DIR/NAME), "." + SUBPATH,
-   `package.json` "exports", ["node", "require"]) defined in the ESM resolver.
+   `package.json` "exports", ["node", "require"]) <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 6. RESOLVE_ESM_MATCH(MATCH)
 
 LOAD_PACKAGE_SELF(X, DIR)
@@ -231,7 +231,7 @@ LOAD_PACKAGE_SELF(X, DIR)
 4. If the SCOPE/package.json "name" is not the first segment of X, return.
 5. let MATCH = PACKAGE_EXPORTS_RESOLVE(pathToFileURL(SCOPE),
    "." + X.slice("name".length), `package.json` "exports", ["node", "require"])
-   defined in the ESM resolver.
+   <a href="esm.md#resolver-algorithm-specification">defined in the ESM resolver</a>.
 6. RESOLVE_ESM_MATCH(MATCH)
 
 RESOLVE_ESM_MATCH(MATCH)
@@ -244,7 +244,7 @@ RESOLVE_ESM_MATCH(MATCH)
    a. LOAD_AS_FILE(RESOLVED_PATH)
    b. LOAD_AS_DIRECTORY(RESOLVED_PATH)
 5. THROW "not found"
-```
+</pre>
 
 ## Caching
 
@@ -280,6 +280,12 @@ irrespective of whether or not `./foo` and `./FOO` are the same file.
 ## Core modules
 
 <!--type=misc-->
+<!-- YAML
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37246
+    description: Added `node:` import support to `require(...)`.
+-->
 
 Node.js has several modules compiled into the binary. These modules are
 described in greater detail elsewhere in this documentation.
@@ -291,6 +297,11 @@ Core modules are always preferentially loaded if their identifier is
 passed to `require()`. For instance, `require('http')` will always
 return the built in HTTP module, even if there is a file by that name.
 
+Core modules can also be identified using the `node:` prefix, in which case
+it bypasses the `require` cache. For instance, `require('node:http')` will
+always return the built in HTTP module, even if there is `require.cache` entry
+by that name.
+
 ## Cycles
 
 <!--type=misc-->
@@ -503,7 +514,7 @@ wrapper that looks like the following:
 By doing this, Node.js achieves a few things:
 
 * It keeps top-level variables (defined with `var`, `const` or `let`) scoped to
-the module rather than the global object.
+  the module rather than the global object.
 * It helps to provide some global-looking variables that are actually specific
   to the module, such as:
   * The `module` and `exports` objects that the implementor can use to export
@@ -642,8 +653,20 @@ error.
 
 Adding or replacing entries is also possible. This cache is checked before
 native modules and if a name matching a native module is added to the cache,
-no require call is
-going to receive the native module anymore. Use with care!
+only `node:`-prefixed require calls are going to receive the native module.
+Use with care!
+
+<!-- eslint-disable node-core/no-duplicate-requires -->
+```js
+const assert = require('assert');
+const realFs = require('fs');
+
+const fakeFs = {};
+require.cache.fs = { exports: fakeFs };
+
+assert.strictEqual(require('fs'), fakeFs);
+assert.strictEqual(require('node:fs'), realFs);
+```
 
 #### `require.extensions`
 <!-- YAML
@@ -889,6 +912,14 @@ added: v0.1.16
 The identifier for the module. Typically this is the fully resolved
 filename.
 
+### `module.isPreloading`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Type: {boolean} `true` if the module is running during the Node.js preload
+  phase.
+
 ### `module.loaded`
 <!-- YAML
 added: v0.1.16
@@ -903,8 +934,8 @@ loading.
 <!-- YAML
 added: v0.1.16
 deprecated:
-  - v12.19.0
   - v14.6.0
+  - v12.19.0
 -->
 
 > Stability: 0 - Deprecated: Please use [`require.main`][] and
@@ -954,7 +985,7 @@ in order to be used.
 ## The `Module` object
 
 This section was moved to
-[Modules: `module` core module](module.html#module_the_module_object).
+[Modules: `module` core module](module.md#module_the_module_object).
 
 <!-- Anchors to make sure old links find a target -->
 * <a id="modules_module_builtinmodules" href="module.html#module_module_builtinmodules">`module.builtinModules`</a>
@@ -965,28 +996,28 @@ This section was moved to
 ## Source map v3 support
 
 This section was moved to
-[Modules: `module` core module](module.html#module_source_map_v3_support).
+[Modules: `module` core module](module.md#module_source_map_v3_support).
 
 <!-- Anchors to make sure old links find a target -->
-* <a id="modules_module_findsourcemap_path_error" href="module.html#module_module_findsourcemap_path_error">`module.findSourceMap(path[, error])`</a>
+* <a id="modules_module_findsourcemap_path_error" href="module.html#module_module_findsourcemap_path">`module.findSourceMap(path)`</a>
 * <a id="modules_class_module_sourcemap" href="module.html#module_class_module_sourcemap">Class: `module.SourceMap`</a>
   * <a id="modules_new_sourcemap_payload" href="module.html#module_new_sourcemap_payload">`new SourceMap(payload)`</a>
   * <a id="modules_sourcemap_payload" href="module.html#module_sourcemap_payload">`sourceMap.payload`</a>
   * <a id="modules_sourcemap_findentry_linenumber_columnnumber" href="module.html#module_sourcemap_findentry_linenumber_columnnumber">`sourceMap.findEntry(lineNumber, columnNumber)`</a>
 
+[ECMAScript Modules]: esm.md
 [GLOBAL_FOLDERS]: #modules_loading_from_the_global_folders
-[`Error`]: errors.html#errors_class_error
+[`"main"`]: packages.md#packages_main
+[`Error`]: errors.md#errors_class_error
 [`__dirname`]: #modules_dirname
 [`__filename`]: #modules_filename
-[`module` object]: #modules_the_module_object
-[`module.id`]: #modules_module_id
 [`module.children`]: #modules_module_children
-[`path.dirname()`]: path.html#path_path_dirname_path
-[ECMAScript Modules]: esm.html
-[an error]: errors.html#errors_err_require_esm
+[`module.id`]: #modules_module_id
+[`module` object]: #modules_the_module_object
+[`package.json`]: packages.md#packages_node_js_package_json_field_definitions
+[`path.dirname()`]: path.md#path_path_dirname_path
+[`require.main`]: #modules_require_main
+[an error]: errors.md#errors_err_require_esm
 [exports shortcut]: #modules_exports_shortcut
 [module resolution]: #modules_all_together
-[native addons]: addons.html
-[`require.main`]: #modules_require_main
-[`package.json`]: packages.html#packages_node_js_package_json_field_definitions
-[`"main"`]: packages.html#packages_main
+[native addons]: addons.md
diff --git a/doc/api/n-api.html b/doc/api/n-api.html
index 64e4b5251eea313d36964bda5aceed346fc77781..c65b04220fecf4aad00fbe797821d7289352dc7e 100644
--- a/doc/api/n-api.html
+++ b/doc/api/n-api.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>N-API | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Node-API | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api active">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api active">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="n-api" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/n-api.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/n-api.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/n-api.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/n-api.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/n-api.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/n-api.html">13.x</a></li>
@@ -112,16 +127,14 @@
 <li><a href="https://nodejs.org/docs/latest-v8.x/api/n-api.html">8.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/n-api.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/n-api.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
-<li><span class="stability_2"><a href="#n_api_n_api">N-API</a></span>
+      <details id="toc" open><summary>Table of contents</summary><ul>
+<li><span class="stability_2"><a href="#n_api_node_api">Node-API</a></span>
 <ul>
 <li><a href="#n_api_implications_of_abi_stability">Implications of ABI stability</a></li>
 <li><a href="#n_api_building">Building</a>
@@ -142,14 +155,14 @@
 </ul>
 </li>
 <li><a href="#n_api_usage">Usage</a></li>
-<li><a href="#n_api_n_api_version_matrix">N-API version matrix</a></li>
+<li><a href="#n_api_node_api_version_matrix">Node-API version matrix</a></li>
 <li><a href="#n_api_environment_life_cycle_apis">Environment life cycle APIs</a>
 <ul>
 <li><a href="#n_api_napi_set_instance_data">napi_set_instance_data</a></li>
 <li><a href="#n_api_napi_get_instance_data">napi_get_instance_data</a></li>
 </ul>
 </li>
-<li><a href="#n_api_basic_n_api_data_types">Basic N-API data types</a>
+<li><a href="#n_api_basic_node_api_data_types">Basic Node-API data types</a>
 <ul>
 <li><a href="#n_api_napi_status">napi_status</a></li>
 <li><a href="#n_api_napi_extended_error_info">napi_extended_error_info</a></li>
@@ -158,7 +171,7 @@
 <li><a href="#n_api_napi_threadsafe_function">napi_threadsafe_function</a></li>
 <li><a href="#n_api_napi_threadsafe_function_release_mode">napi_threadsafe_function_release_mode</a></li>
 <li><a href="#n_api_napi_threadsafe_function_call_mode">napi_threadsafe_function_call_mode</a></li>
-<li><a href="#n_api_n_api_memory_management_types">N-API memory management types</a>
+<li><a href="#n_api_node_api_memory_management_types">Node-API memory management types</a>
 <ul>
 <li><a href="#n_api_napi_handle_scope">napi_handle_scope</a></li>
 <li><a href="#n_api_napi_escapable_handle_scope">napi_escapable_handle_scope</a></li>
@@ -167,7 +180,7 @@
 <li><a href="#n_api_napi_async_cleanup_hook_handle">napi_async_cleanup_hook_handle</a></li>
 </ul>
 </li>
-<li><a href="#n_api_n_api_callback_types">N-API callback types</a>
+<li><a href="#n_api_node_api_callback_types">Node-API callback types</a>
 <ul>
 <li><a href="#n_api_napi_callback_info">napi_callback_info</a></li>
 <li><a href="#n_api_napi_callback">napi_callback</a></li>
@@ -268,7 +281,7 @@
 <li><a href="#n_api_napi_create_dataview">napi_create_dataview</a></li>
 </ul>
 </li>
-<li><a href="#n_api_functions_to_convert_from_c_types_to_n_api">Functions to convert from C types to N-API</a>
+<li><a href="#n_api_functions_to_convert_from_c_types_to_node_api">Functions to convert from C types to Node-API</a>
 <ul>
 <li><a href="#n_api_napi_create_int32">napi_create_int32</a></li>
 <li><a href="#n_api_napi_create_uint32">napi_create_uint32</a></li>
@@ -282,7 +295,7 @@
 <li><a href="#n_api_napi_create_string_utf8">napi_create_string_utf8</a></li>
 </ul>
 </li>
-<li><a href="#n_api_functions_to_convert_from_n_api_to_c_types">Functions to convert from N-API to C types</a>
+<li><a href="#n_api_functions_to_convert_from_node_api_to_c_types">Functions to convert from Node-API to C types</a>
 <ul>
 <li><a href="#n_api_napi_get_array_length">napi_get_array_length</a></li>
 <li><a href="#n_api_napi_get_arraybuffer_info">napi_get_arraybuffer_info</a></li>
@@ -450,32 +463,30 @@
 <li><span class="stability_1"><a href="#n_api_node_api_get_module_file_name">node_api_get_module_file_name</a></span></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>N-API<span><a class="mark" href="#n_api_n_api" id="n_api_n_api">#</a></span></h1>
+        <h2>Node-API<span><a class="mark" href="#n_api_node_api" id="n_api_node_api">#</a></span></h2>
 
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p>N-API (pronounced N as in the letter, followed by API)
-is an API for building native Addons. It is independent from
-the underlying JavaScript runtime (for example, V8) and is maintained as part of
-Node.js itself. This API will be Application Binary Interface (ABI) stable
-across versions of Node.js. It is intended to insulate Addons from
-changes in the underlying JavaScript engine and allow modules
+<p>Node-API (formerly N-API) is an API for building native Addons. It is
+independent from the underlying JavaScript runtime (for example, V8) and is
+maintained as part of Node.js itself. This API will be Application Binary
+Interface (ABI) stable across versions of Node.js. It is intended to insulate
+addons from changes in the underlying JavaScript engine and allow modules
 compiled for one major version to run on later major versions of Node.js without
 recompilation. The <a href="https://nodejs.org/en/docs/guides/abi-stability/">ABI Stability</a> guide provides a more in-depth explanation.</p>
 <p>Addons are built/packaged with the same approach/tools outlined in the section
 titled <a href="addons.html">C++ Addons</a>. The only difference is the set of APIs that are used by
 the native code. Instead of using the V8 or <a href="https://github.com/nodejs/nan">Native Abstractions for Node.js</a>
-APIs, the functions available in the N-API are used.</p>
-<p>APIs exposed by N-API are generally used to create and manipulate
+APIs, the functions available in Node-API are used.</p>
+<p>APIs exposed by Node-API are generally used to create and manipulate
 JavaScript values. Concepts and operations generally map to ideas specified
 in the ECMA-262 Language Specification. The APIs have the following
 properties:</p>
 <ul>
-<li>All N-API calls return a status code of type <code>napi_status</code>. This
+<li>All Node-API calls return a status code of type <code>napi_status</code>. This
 status indicates whether the API call succeeded or failed.</li>
 <li>The API's return value is passed via an out parameter.</li>
 <li>All JavaScript values are abstracted behind an opaque type named
@@ -484,75 +495,75 @@ status indicates whether the API call succeeded or failed.</li>
 using <code>napi_get_last_error_info</code>. More information can be found in the error
 handling section <a href="#n_api_error_handling">Error handling</a>.</li>
 </ul>
-<p>The N-API is a C API that ensures ABI stability across Node.js versions
+<p>Node-API is a C API that ensures ABI stability across Node.js versions
 and different compiler levels. A C++ API can be easier to use.
 To support using C++, the project maintains a
 C++ wrapper module called <a href="https://github.com/nodejs/node-addon-api"><code>node-addon-api</code></a>.
 This wrapper provides an inlineable C++ API. Binaries built
-with <code>node-addon-api</code> will depend on the symbols for the N-API C-based
+with <code>node-addon-api</code> will depend on the symbols for the Node-API C-based
 functions exported by Node.js. <code>node-addon-api</code> is a more
-efficient way to write code that calls N-API. Take, for example, the
+efficient way to write code that calls Node-API. Take, for example, the
 following <code>node-addon-api</code> code. The first section shows the
 <code>node-addon-api</code> code and the second section shows what actually gets
 used in the addon.</p>
-<pre><code class="language-cpp">Object obj = Object::New(env);
-obj[<span class="hljs-string">"foo"</span>] = String::New(env, <span class="hljs-string">"bar"</span>);</code></pre>
+<pre><code class="language-cpp">Object obj = Object::<span class="hljs-built_in">New</span>(env);
+obj[<span class="hljs-string">"foo"</span>] = String::<span class="hljs-built_in">New</span>(env, <span class="hljs-string">"bar"</span>);</code></pre>
 <pre><code class="language-cpp">napi_status status;
-napi_value object, <span class="hljs-built_in">string</span>;
-status = napi_create_object(env, &#x26;object);
+napi_value object, string;
+status = <span class="hljs-built_in">napi_create_object</span>(env, &#x26;object);
 <span class="hljs-keyword">if</span> (status != napi_ok) {
-  napi_throw_error(env, ...);
+  <span class="hljs-built_in">napi_throw_error</span>(env, ...);
   <span class="hljs-keyword">return</span>;
 }
 
-status = napi_create_string_utf8(env, <span class="hljs-string">"bar"</span>, NAPI_AUTO_LENGTH, &#x26;<span class="hljs-built_in">string</span>);
+status = <span class="hljs-built_in">napi_create_string_utf8</span>(env, <span class="hljs-string">"bar"</span>, NAPI_AUTO_LENGTH, &#x26;string);
 <span class="hljs-keyword">if</span> (status != napi_ok) {
-  napi_throw_error(env, ...);
+  <span class="hljs-built_in">napi_throw_error</span>(env, ...);
   <span class="hljs-keyword">return</span>;
 }
 
-status = napi_set_named_property(env, object, <span class="hljs-string">"foo"</span>, <span class="hljs-built_in">string</span>);
+status = <span class="hljs-built_in">napi_set_named_property</span>(env, object, <span class="hljs-string">"foo"</span>, string);
 <span class="hljs-keyword">if</span> (status != napi_ok) {
-  napi_throw_error(env, ...);
+  <span class="hljs-built_in">napi_throw_error</span>(env, ...);
   <span class="hljs-keyword">return</span>;
 }</code></pre>
 <p>The end result is that the addon only uses the exported C APIs. As a result,
 it still gets the benefits of the ABI stability provided by the C API.</p>
 <p>When using <code>node-addon-api</code> instead of the C APIs, start with the API <a href="https://github.com/nodejs/node-addon-api#api-documentation">docs</a>
 for <code>node-addon-api</code>.</p>
-<p>The <a href="https://nodejs.github.io/node-addon-examples/">N-API Resource</a> offers an
-excellent orientation and tips for developers just getting started with N-API
-and <code>node-addon-api</code>.</p>
-<h2>Implications of ABI stability<span><a class="mark" href="#n_api_implications_of_abi_stability" id="n_api_implications_of_abi_stability">#</a></span></h2>
-<p>Although N-API provides an ABI stability guarantee, other parts of Node.js do
+<p>The <a href="https://nodejs.github.io/node-addon-examples/">Node-API Resource</a> offers
+an excellent orientation and tips for developers just getting started with
+Node-API and <code>node-addon-api</code>.</p>
+<section><h3>Implications of ABI stability<span><a class="mark" href="#n_api_implications_of_abi_stability" id="n_api_implications_of_abi_stability">#</a></span></h3>
+<p>Although Node-API provides an ABI stability guarantee, other parts of Node.js do
 not, and any external libraries used from the addon may not. In particular,
 none of the following APIs provide an ABI stability guarantee across major
 versions:</p>
 <ul>
 <li>
 <p>the Node.js C++ APIs available via any of</p>
-<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_buffer.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_version.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_object_wrap.h></span></span></code></pre>
+<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_buffer.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_version.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_object_wrap.h></span></span></code></pre>
 </li>
 <li>
 <p>the libuv APIs which are also included with Node.js and available via</p>
-<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;uv.h></span></span></code></pre>
+<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;uv.h></span></span></code></pre>
 </li>
 <li>
 <p>the V8 API available via</p>
-<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;v8.h></span></span></code></pre>
+<pre><code class="language-cpp"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;v8.h></span></span></code></pre>
 </li>
 </ul>
 <p>Thus, for an addon to remain ABI-compatible across Node.js major versions, it
-must use N-API exclusively by restricting itself to using</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span></code></pre>
+must use Node-API exclusively by restricting itself to using</p>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span></code></pre>
 <p>and by checking, for all external libraries that it uses, that the external
-library makes ABI stability guarantees similar to N-API.</p>
-<h2>Building<span><a class="mark" href="#n_api_building" id="n_api_building">#</a></span></h2>
+library makes ABI stability guarantees similar to Node-API.</p>
+</section><section><h3>Building<span><a class="mark" href="#n_api_building" id="n_api_building">#</a></span></h3>
 <p>Unlike modules written in JavaScript, developing and deploying Node.js
-native addons using N-API requires an additional set of tools. Besides the
+native addons using Node-API requires an additional set of tools. Besides the
 basic tools required to develop for Node.js, the native addon developer
 requires a toolchain that can compile C and C++ code into a binary. In
 addition, depending upon how the native addon is deployed, the <em>user</em> of
@@ -571,198 +582,215 @@ IDE. The following command installs the necessary toolchain:</p>
 <pre><code class="language-bash">npm install --global windows-build-tools</code></pre>
 <p>The sections below describe the additional tools available for developing
 and deploying Node.js native addons.</p>
-<h3>Build tools<span><a class="mark" href="#n_api_build_tools" id="n_api_build_tools">#</a></span></h3>
+<h4>Build tools<span><a class="mark" href="#n_api_build_tools" id="n_api_build_tools">#</a></span></h4>
 <p>Both the tools listed here require that <em>users</em> of the native
 addon have a C/C++ toolchain installed in order to successfully install
 the native addon.</p>
-<h4>node-gyp<span><a class="mark" href="#n_api_node_gyp" id="n_api_node_gyp">#</a></span></h4>
-<p><a href="https://github.com/nodejs/node-gyp">node-gyp</a> is a build system based on Google's <a href="https://gyp.gsrc.io">GYP</a> tool and comes
-bundled with npm. GYP, and therefore node-gyp, requires that Python be
-installed.</p>
+<h5>node-gyp<span><a class="mark" href="#n_api_node_gyp" id="n_api_node_gyp">#</a></span></h5>
+<p><a href="https://github.com/nodejs/node-gyp">node-gyp</a> is a build system based on the <a href="https://github.com/nodejs/gyp-next">gyp-next</a> fork of
+Google's <a href="https://gyp.gsrc.io">GYP</a> tool and comes bundled with npm. GYP, and therefore node-gyp,
+requires that Python be installed.</p>
 <p>Historically, node-gyp has been the tool of choice for building native
 addons. It has widespread adoption and documentation. However, some
 developers have run into limitations in node-gyp.</p>
-<h4>CMake.js<span><a class="mark" href="#n_api_cmake_js" id="n_api_cmake_js">#</a></span></h4>
+<h5>CMake.js<span><a class="mark" href="#n_api_cmake_js" id="n_api_cmake_js">#</a></span></h5>
 <p><a href="https://github.com/cmake-js/cmake-js">CMake.js</a> is an alternative build system based on <a href="https://cmake.org">CMake</a>.</p>
 <p>CMake.js is a good choice for projects that already use CMake or for
 developers affected by limitations in node-gyp.</p>
-<h3>Uploading precompiled binaries<span><a class="mark" href="#n_api_uploading_precompiled_binaries" id="n_api_uploading_precompiled_binaries">#</a></span></h3>
+<h4>Uploading precompiled binaries<span><a class="mark" href="#n_api_uploading_precompiled_binaries" id="n_api_uploading_precompiled_binaries">#</a></span></h4>
 <p>The three tools listed here permit native addon developers and maintainers
 to create and upload binaries to public or private servers. These tools are
 typically integrated with CI/CD build systems like <a href="https://travis-ci.org">Travis CI</a> and
 <a href="https://www.appveyor.com">AppVeyor</a> to build and upload binaries for a variety of platforms and
 architectures. These binaries are then available for download by users who
 do not need to have a C/C++ toolchain installed.</p>
-<h4>node-pre-gyp<span><a class="mark" href="#n_api_node_pre_gyp" id="n_api_node_pre_gyp">#</a></span></h4>
+<h5>node-pre-gyp<span><a class="mark" href="#n_api_node_pre_gyp" id="n_api_node_pre_gyp">#</a></span></h5>
 <p><a href="https://github.com/mapbox/node-pre-gyp">node-pre-gyp</a> is a tool based on node-gyp that adds the ability to
 upload binaries to a server of the developer's choice. node-pre-gyp has
 particularly good support for uploading binaries to Amazon S3.</p>
-<h4>prebuild<span><a class="mark" href="#n_api_prebuild" id="n_api_prebuild">#</a></span></h4>
+<h5>prebuild<span><a class="mark" href="#n_api_prebuild" id="n_api_prebuild">#</a></span></h5>
 <p><a href="https://github.com/prebuild/prebuild">prebuild</a> is a tool that supports builds using either node-gyp or
 CMake.js. Unlike node-pre-gyp which supports a variety of servers, prebuild
 uploads binaries only to <a href="https://help.github.com/en/github/administering-a-repository/about-releases">GitHub releases</a>. prebuild is a good choice for
 GitHub projects using CMake.js.</p>
-<h4>prebuildify<span><a class="mark" href="#n_api_prebuildify" id="n_api_prebuildify">#</a></span></h4>
+<h5>prebuildify<span><a class="mark" href="#n_api_prebuildify" id="n_api_prebuildify">#</a></span></h5>
 <p><a href="https://github.com/prebuild/prebuildify">prebuildify</a> is a tool based on node-gyp. The advantage of prebuildify is
 that the built binaries are bundled with the native module when it's
 uploaded to npm. The binaries are downloaded from npm and are immediately
 available to the module user when the native module is installed.</p>
-<h2>Usage<span><a class="mark" href="#n_api_usage" id="n_api_usage">#</a></span></h2>
-<p>In order to use the N-API functions, include the file <a href="https://github.com/nodejs/node/blob/master/src/node_api.h"><code>node_api.h</code></a> which is
-located in the src directory in the node development tree:</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span></code></pre>
+</section><section><h3>Usage<span><a class="mark" href="#n_api_usage" id="n_api_usage">#</a></span></h3>
+<p>In order to use the Node-API functions, include the file <a href="https://github.com/nodejs/node/blob/HEAD/src/node_api.h"><code>node_api.h</code></a> which
+is located in the src directory in the node development tree:</p>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span></code></pre>
 <p>This will opt into the default <code>NAPI_VERSION</code> for the given release of Node.js.
-In order to ensure compatibility with specific versions of N-API, the version
+In order to ensure compatibility with specific versions of Node-API, the version
 can be specified explicitly when including the header:</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> NAPI_VERSION 3</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span></code></pre>
-<p>This restricts the N-API surface to just the functionality that was available in
-the specified (and earlier) versions.</p>
-<p>Some of the N-API surface is experimental and requires explicit opt-in:</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> NAPI_EXPERIMENTAL</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span></code></pre>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">define</span> NAPI_VERSION 3</span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span></code></pre>
+<p>This restricts the Node-API surface to just the functionality that was available
+in the specified (and earlier) versions.</p>
+<p>Some of the Node-API surface is experimental and requires explicit opt-in:</p>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">define</span> NAPI_EXPERIMENTAL</span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span></code></pre>
 <p>In this case the entire API surface, including any experimental APIs, will be
 available to the module code.</p>
-<h2>N-API version matrix<span><a class="mark" href="#n_api_n_api_version_matrix" id="n_api_n_api_version_matrix">#</a></span></h2>
-<p>N-API versions are additive and versioned independently from Node.js.
+</section><section><h3>Node-API version matrix<span><a class="mark" href="#n_api_node_api_version_matrix" id="n_api_node_api_version_matrix">#</a></span></h3>
+<p>Node-API versions are additive and versioned independently from Node.js.
 Version 4 is an extension to version 3 in that it has all of the APIs
 from version 3 with some additions. This means that it is not necessary
 to recompile for new versions of Node.js which are
 listed as supporting a later version.</p>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-<table><thead><tr><th></th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th><th>6</th></tr></thead><tbody><tr><td>v6.x</td><td></td><td></td><td>v6.14.2*</td><td></td><td></td><td></td></tr><tr><td>v8.x</td><td>v8.0.0*</td><td>v8.10.0*</td><td>v8.11.2</td><td>v8.16.0</td><td></td><td></td></tr><tr><td>v9.x</td><td>v9.0.0*</td><td>v9.3.0*</td><td>v9.11.0*</td><td></td><td></td><td></td></tr><tr><td>v10.x</td><td>v10.0.0</td><td>v10.0.0</td><td>v10.0.0</td><td>v10.16.0</td><td>v10.17.0</td><td>v10.20.0</td></tr><tr><td>v11.x</td><td>v11.0.0</td><td>v11.0.0</td><td>v11.0.0</td><td>v11.8.0</td><td></td><td></td></tr><tr><td>v12.x</td><td>v12.0.0</td><td>v12.0.0</td><td>v12.0.0</td><td>v12.0.0</td><td>v12.11.0</td><td>v12.17.0</td></tr><tr><td>v13.x</td><td>v13.0.0</td><td>v13.0.0</td><td>v13.0.0</td><td>v13.0.0</td><td>v13.0.0</td><td></td></tr><tr><td>v14.x</td><td>v14.0.0</td><td>v14.0.0</td><td>v14.0.0</td><td>v14.0.0</td><td>v14.0.0</td><td>v14.0.0</td></tr></tbody></table>
-<p>* Indicates that the N-API version was released as experimental</p>
-<p>Each API documented for N-API will have a header named <code>added in:</code>, and APIs
-which are stable will have the additional header <code>N-API version:</code>.
+<!-- For accessibility purposes, this table needs row headers. That means we
+     can't do it in markdown. Hence, the raw HTML. -->
+<table>
+  <tbody><tr>
+    <td></td>
+    <th scope="col">1</th>
+    <th scope="col">2</th>
+    <th scope="col">3</th>
+  </tr>
+  <tr>
+    <th scope="row">v6.x</th>
+    <td></td>
+    <td></td>
+    <td>v6.14.2*</td>
+  </tr>
+  <tr>
+    <th scope="row">v8.x</th>
+    <td>v8.6.0**</td>
+    <td>v8.10.0*</td>
+    <td>v8.11.2</td>
+  </tr>
+  <tr>
+    <th scope="row">v9.x</th>
+    <td>v9.0.0*</td>
+    <td>v9.3.0*</td>
+    <td>v9.11.0*</td>
+  </tr>
+  <tr>
+    <th scope="row">≥ v10.x</th>
+    <td>all releases</td>
+    <td>all releases</td>
+    <td>all releases</td>
+  </tr>
+</tbody></table>
+<table>
+  <tbody><tr>
+    <td></td>
+    <th scope="col">4</th>
+    <th scope="col">5</th>
+    <th scope="col">6</th>
+    <th scope="col">7</th>
+    <th scope="col">8</th>
+  </tr>
+  <tr>
+    <th scope="row">v10.x</th>
+    <td>v10.16.0</td>
+    <td>v10.17.0</td>
+    <td>v10.20.0</td>
+    <td>v10.23.0</td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v11.x</th>
+    <td>v11.8.0</td>
+    <td></td>
+    <td></td>
+    <td></td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v12.x</th>
+    <td>v12.0.0</td>
+    <td>v12.11.0</td>
+    <td>v12.17.0</td>
+    <td>v12.19.0</td>
+    <td>v12.22.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v13.x</th>
+    <td>v13.0.0</td>
+    <td>v13.0.0</td>
+    <td></td>
+    <td></td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v14.x</th>
+    <td>v14.0.0</td>
+    <td>v14.0.0</td>
+    <td>v14.0.0</td>
+    <td>v14.12.0</td>
+    <td>v14.17.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v15.x</th>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.12.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v16.x</th>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+  </tr>
+</tbody></table>
+<p>* Node-API was experimental.</p>
+<p>** Node.js 8.0.0 included Node-API as experimental. It was released as
+Node-API version 1 but continued to evolve until Node.js 8.6.0. The API is
+different in versions prior to Node.js 8.6.0. We recommend Node-API version 3 or
+later.</p>
+<p>Each API documented for Node-API will have a header named <code>added in:</code>, and APIs
+which are stable will have the additional header <code>Node-API version:</code>.
 APIs are directly usable when using a Node.js version which supports
-the N-API version shown in <code>N-API version:</code> or higher.
+the Node-API version shown in <code>Node-API version:</code> or higher.
 When using a Node.js version that does not support the
-<code>N-API version:</code> listed or if there is no <code>N-API version:</code> listed,
+<code>Node-API version:</code> listed or if there is no <code>Node-API version:</code> listed,
 then the API will only be available if
 <code>#define NAPI_EXPERIMENTAL</code> precedes the inclusion of <code>node_api.h</code>
 or <code>js_native_api.h</code>. If an API appears not to be available on
 a version of Node.js which is later than the one shown in <code>added in:</code> then
 this is most likely the reason for the apparent absence.</p>
-<p>The N-APIs associated strictly with accessing ECMAScript features from native
+<p>The Node-APIs associated strictly with accessing ECMAScript features from native
 code can be found separately in <code>js_native_api.h</code> and <code>js_native_api_types.h</code>.
 The APIs defined in these headers are included in <code>node_api.h</code> and
 <code>node_api_types.h</code>. The headers are structured in this way in order to allow
-implementations of N-API outside of Node.js. For those implementations the
+implementations of Node-API outside of Node.js. For those implementations the
 Node.js specific APIs may not be applicable.</p>
 <p>The Node.js-specific parts of an addon can be separated from the code that
 exposes the actual functionality to the JavaScript environment so that the
-latter may be used with multiple implementations of N-API. In the example below,
-<code>addon.c</code> and <code>addon.h</code> refer only to <code>js_native_api.h</code>. This ensures that
-<code>addon.c</code> can be reused to compile against either the Node.js implementation of
-N-API or any implementation of N-API outside of Node.js.</p>
+latter may be used with multiple implementations of Node-API. In the example
+below, <code>addon.c</code> and <code>addon.h</code> refer only to <code>js_native_api.h</code>. This ensures
+that <code>addon.c</code> can be reused to compile against either the Node.js
+implementation of Node-API or any implementation of Node-API outside of Node.js.</p>
 <p><code>addon_node.c</code> is a separate file that contains the Node.js specific entry point
 to the addon and which instantiates the addon by calling into <code>addon.c</code> when the
 addon is loaded into a Node.js environment.</p>
 <pre><code class="language-c"><span class="hljs-comment">// addon.h</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">ifndef</span> _ADDON_H_</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> _ADDON_H_</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;js_native_api.h></span></span>
-<span class="hljs-function">napi_value <span class="hljs-title">create_addon</span><span class="hljs-params">(napi_env env)</span></span>;
-<span class="hljs-meta">#<span class="hljs-meta-keyword">endif</span>  <span class="hljs-comment">// _ADDON_H_</span></span></code></pre>
+<span class="hljs-meta">#<span class="hljs-keyword">ifndef</span> _ADDON_H_</span>
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> _ADDON_H_</span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;js_native_api.h></span></span>
+napi_value <span class="hljs-title function_">create_addon</span><span class="hljs-params">(napi_env env)</span>;
+<span class="hljs-meta">#<span class="hljs-keyword">endif</span>  <span class="hljs-comment">// _ADDON_H_</span></span></code></pre>
 <pre><code class="language-c"><span class="hljs-comment">// addon.c</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"addon.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"addon.h"</span></span>
 
-<span class="hljs-meta">#<span class="hljs-meta-keyword">define</span> NAPI_CALL(env, call)                                      \
+<span class="hljs-meta">#<span class="hljs-keyword">define</span> NAPI_CALL(env, call)                                      \
   do {                                                            \
     napi_status status = (call);                                  \
-    <span class="hljs-meta-keyword">if</span> (status != napi_ok) {                                      \
+    <span class="hljs-keyword">if</span> (status != napi_ok) {                                      \
       const napi_extended_error_info* error_info = NULL;          \
       napi_get_last_error_info((env), &#x26;error_info);               \
       bool is_pending;                                            \
       napi_is_exception_pending((env), &#x26;is_pending);              \
-      <span class="hljs-meta-keyword">if</span> (!is_pending) {                                          \
+      <span class="hljs-keyword">if</span> (!is_pending) {                                          \
         const char* message = (error_info->error_message == NULL) \
-            ? <span class="hljs-meta-string">"empty error message"</span>                               \
+            ? <span class="hljs-string">"empty error message"</span>                               \
             : error_info->error_message;                          \
         napi_throw_error((env), NULL, message);                   \
         return NULL;                                              \
@@ -770,13 +798,13 @@ addon is loaded into a Node.js environment.</p>
     }                                                             \
   } while(0)</span>
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> napi_value
-<span class="hljs-title">DoSomethingUseful</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
+<span class="hljs-keyword">static</span> napi_value
+<span class="hljs-title function_">DoSomethingUseful</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
   <span class="hljs-comment">// Do something useful.</span>
   <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
 }
 
-<span class="hljs-function">napi_value <span class="hljs-title">create_addon</span><span class="hljs-params">(napi_env env)</span> </span>{
+napi_value <span class="hljs-title function_">create_addon</span><span class="hljs-params">(napi_env env)</span> {
   napi_value result;
   NAPI_CALL(env, napi_create_object(env, &#x26;result));
 
@@ -796,8 +824,8 @@ addon is loaded into a Node.js environment.</p>
   <span class="hljs-keyword">return</span> result;
 }</code></pre>
 <pre><code class="language-c"><span class="hljs-comment">// addon_node.c</span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;node_api.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">"addon.h"</span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;node_api.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">"addon.h"</span></span>
 
 NAPI_MODULE_INIT() {
   <span class="hljs-comment">// This function body is expected to return a `napi_value`.</span>
@@ -805,7 +833,7 @@ NAPI_MODULE_INIT() {
   <span class="hljs-comment">// the body, as they are provided by the definition of `NAPI_MODULE_INIT()`.</span>
   <span class="hljs-keyword">return</span> create_addon(env);
 }</code></pre>
-<h2>Environment life cycle APIs<span><a class="mark" href="#n_api_environment_life_cycle_apis" id="n_api_environment_life_cycle_apis">#</a></span></h2>
+</section><section><h3>Environment life cycle APIs<span><a class="mark" href="#n_api_environment_life_cycle_apis" id="n_api_environment_life_cycle_apis">#</a></span></h3>
 <p><a href="https://tc39.es/ecma262/#sec-agents">Section 8.7</a> of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a> defines the concept
 of an "Agent" as a self-contained environment in which JavaScript code runs.
 Multiple such Agents may be started and terminated either concurrently or in
@@ -824,19 +852,19 @@ multiple threads.</p>
 <p>Native addons may need to allocate global state which they use during
 their entire life cycle such that the state must be unique to each instance of
 the addon.</p>
-<p>To this end, N-API provides a way to allocate data such that its life cycle is
-tied to the life cycle of the Agent.</p>
-<h3>napi_set_instance_data<span><a class="mark" href="#n_api_napi_set_instance_data" id="n_api_napi_set_instance_data">#</a></span></h3>
+<p>To this end, Node-API provides a way to allocate data such that its life cycle
+is tied to the life cycle of the Agent.</p>
+<h4>napi_set_instance_data<span><a class="mark" href="#n_api_napi_set_instance_data" id="n_api_napi_set_instance_data">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.8.0</span>
+<span>Added in: v12.8.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_set_instance_data</span><span class="hljs-params">(napi_env env,
-                                   <span class="hljs-keyword">void</span>* data,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_set_instance_data</span><span class="hljs-params">(napi_env env,
+                                   <span class="hljs-type">void</span>* data,
                                    napi_finalize finalize_cb,
-                                   <span class="hljs-keyword">void</span>* finalize_hint)</span></span>;</code></pre>
+                                   <span class="hljs-type">void</span>* finalize_hint)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] data</code>: The data item to make available to bindings of this instance.</li>
 <li><code>[in] finalize_cb</code>: The function to call when the environment is being torn
 down. The function receives <code>data</code> so that it might free it.
@@ -850,15 +878,15 @@ be retrieved using <code>napi_get_instance_data()</code>. Any existing data asso
 the currently running Agent which was set by means of a previous call to
 <code>napi_set_instance_data()</code> will be overwritten. If a <code>finalize_cb</code> was provided
 by the previous call, it will not be called.</p>
-<h3>napi_get_instance_data<span><a class="mark" href="#n_api_napi_get_instance_data" id="n_api_napi_get_instance_data">#</a></span></h3>
+<h4>napi_get_instance_data<span><a class="mark" href="#n_api_napi_get_instance_data" id="n_api_napi_get_instance_data">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.8.0</span>
+<span>Added in: v12.8.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_instance_data</span><span class="hljs-params">(napi_env env,
-                                   <span class="hljs-keyword">void</span>** data)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_instance_data</span><span class="hljs-params">(napi_env env,
+                                   <span class="hljs-type">void</span>** data)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[out] data</code>: The data item that was previously associated with the currently
 running Agent by a call to <code>napi_set_instance_data()</code>.</li>
 </ul>
@@ -866,18 +894,18 @@ running Agent by a call to <code>napi_set_instance_data()</code>.</li>
 <p>This API retrieves data that was previously associated with the currently
 running Agent via <code>napi_set_instance_data()</code>. If no data is set, the call will
 succeed and <code>data</code> will be set to <code>NULL</code>.</p>
-<h2>Basic N-API data types<span><a class="mark" href="#n_api_basic_n_api_data_types" id="n_api_basic_n_api_data_types">#</a></span></h2>
-<p>N-API exposes the following fundamental datatypes as abstractions that are
+</section><section><h3>Basic Node-API data types<span><a class="mark" href="#n_api_basic_node_api_data_types" id="n_api_basic_node_api_data_types">#</a></span></h3>
+<p>Node-API exposes the following fundamental datatypes as abstractions that are
 consumed by the various APIs. These APIs should be treated as opaque,
-introspectable only with other N-API calls.</p>
-<h3>napi_status<span><a class="mark" href="#n_api_napi_status" id="n_api_napi_status">#</a></span></h3>
+introspectable only with other Node-API calls.</p>
+<h4>napi_status<span><a class="mark" href="#n_api_napi_status" id="n_api_napi_status">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<p>Integral status code indicating the success or failure of a N-API call.
+<p>Integral status code indicating the success or failure of a Node-API call.
 Currently, the following status codes are supported.</p>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_ok,
   napi_invalid_arg,
   napi_object_expected,
@@ -899,18 +927,19 @@ Currently, the following status codes are supported.</p>
   napi_date_expected,
   napi_arraybuffer_expected,
   napi_detachable_arraybuffer_expected,
+  napi_would_deadlock,  <span class="hljs-comment">/* unused */</span>
 } napi_status;</code></pre>
 <p>If additional information is required upon an API returning a failed status,
 it can be obtained by calling <code>napi_get_last_error_info</code>.</p>
-<h3>napi_extended_error_info<span><a class="mark" href="#n_api_napi_extended_error_info" id="n_api_napi_extended_error_info">#</a></span></h3>
+<h4>napi_extended_error_info<span><a class="mark" href="#n_api_napi_extended_error_info" id="n_api_napi_extended_error_info">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> {</span>
-  <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* error_message;
-  <span class="hljs-keyword">void</span>* engine_reserved;
-  <span class="hljs-keyword">uint32_t</span> engine_error_code;
+  <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* error_message;
+  <span class="hljs-type">void</span>* engine_reserved;
+  <span class="hljs-type">uint32_t</span> engine_error_code;
   napi_status error_code;
 } napi_extended_error_info;</code></pre>
 <ul>
@@ -920,24 +949,24 @@ the error.</li>
 not implemented for any VM.</li>
 <li><code>engine_error_code</code>: VM-specific error code. This is currently
 not implemented for any VM.</li>
-<li><code>error_code</code>: The N-API status code that originated with the last error.</li>
+<li><code>error_code</code>: The Node-API status code that originated with the last error.</li>
 </ul>
 <p>See the <a href="#n_api_error_handling">Error handling</a> section for additional information.</p>
-<h3>napi_env<span><a class="mark" href="#n_api_napi_env" id="n_api_napi_env">#</a></span></h3>
-<p><code>napi_env</code> is used to represent a context that the underlying N-API
+<h4>napi_env<span><a class="mark" href="#n_api_napi_env" id="n_api_napi_env">#</a></span></h4>
+<p><code>napi_env</code> is used to represent a context that the underlying Node-API
 implementation can use to persist VM-specific state. This structure is passed
 to native functions when they're invoked, and it must be passed back when
-making N-API calls. Specifically, the same <code>napi_env</code> that was passed in when
+making Node-API calls. Specifically, the same <code>napi_env</code> that was passed in when
 the initial native function was called must be passed to any subsequent
-nested N-API calls. Caching the <code>napi_env</code> for the purpose of general reuse,
+nested Node-API calls. Caching the <code>napi_env</code> for the purpose of general reuse,
 and passing the <code>napi_env</code> between instances of the same addon running on
 different <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads is not allowed. The <code>napi_env</code> becomes invalid
 when an instance of a native addon is unloaded. Notification of this event is
 delivered through the callbacks given to <a href="#n_api_napi_add_env_cleanup_hook"><code>napi_add_env_cleanup_hook</code></a> and
 <a href="#n_api_napi_set_instance_data"><code>napi_set_instance_data</code></a>.</p>
-<h3>napi_value<span><a class="mark" href="#n_api_napi_value" id="n_api_napi_value">#</a></span></h3>
+<h4>napi_value<span><a class="mark" href="#n_api_napi_value" id="n_api_napi_value">#</a></span></h4>
 <p>This is an opaque pointer that is used to represent a JavaScript value.</p>
-<h3>napi_threadsafe_function<span><a class="mark" href="#n_api_napi_threadsafe_function" id="n_api_napi_threadsafe_function">#</a></span></h3>
+<h4>napi_threadsafe_function<span><a class="mark" href="#n_api_napi_threadsafe_function" id="n_api_napi_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
@@ -945,7 +974,7 @@ delivered through the callbacks given to <a href="#n_api_napi_add_env_cleanup_ho
 <p>This is an opaque pointer that represents a JavaScript function which can be
 called asynchronously from multiple threads via
 <code>napi_call_threadsafe_function()</code>.</p>
-<h3>napi_threadsafe_function_release_mode<span><a class="mark" href="#n_api_napi_threadsafe_function_release_mode" id="n_api_napi_threadsafe_function_release_mode">#</a></span></h3>
+<h4>napi_threadsafe_function_release_mode<span><a class="mark" href="#n_api_napi_threadsafe_function_release_mode" id="n_api_napi_threadsafe_function_release_mode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
@@ -954,11 +983,11 @@ called asynchronously from multiple threads via
 the thread-safe function is to be closed immediately (<code>napi_tsfn_abort</code>) or
 merely released (<code>napi_tsfn_release</code>) and thus available for subsequent use via
 <code>napi_acquire_threadsafe_function()</code> and <code>napi_call_threadsafe_function()</code>.</p>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_tsfn_release,
   napi_tsfn_abort
 } napi_threadsafe_function_release_mode;</code></pre>
-<h3>napi_threadsafe_function_call_mode<span><a class="mark" href="#n_api_napi_threadsafe_function_call_mode" id="n_api_napi_threadsafe_function_call_mode">#</a></span></h3>
+<h4>napi_threadsafe_function_call_mode<span><a class="mark" href="#n_api_napi_threadsafe_function_call_mode" id="n_api_napi_threadsafe_function_call_mode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
@@ -966,17 +995,17 @@ merely released (<code>napi_tsfn_release</code>) and thus available for subseque
 <p>A value to be given to <code>napi_call_threadsafe_function()</code> to indicate whether
 the call should block whenever the queue associated with the thread-safe
 function is full.</p>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_tsfn_nonblocking,
   napi_tsfn_blocking
 } napi_threadsafe_function_call_mode;</code></pre>
-<h3>N-API memory management types<span><a class="mark" href="#n_api_n_api_memory_management_types" id="n_api_n_api_memory_management_types">#</a></span></h3>
-<h4>napi_handle_scope<span><a class="mark" href="#n_api_napi_handle_scope" id="n_api_napi_handle_scope">#</a></span></h4>
+<h4>Node-API memory management types<span><a class="mark" href="#n_api_node_api_memory_management_types" id="n_api_node_api_memory_management_types">#</a></span></h4>
+<h5>napi_handle_scope<span><a class="mark" href="#n_api_napi_handle_scope" id="n_api_napi_handle_scope">#</a></span></h5>
 <p>This is an abstraction used to control and modify the lifetime of objects
-created within a particular scope. In general, N-API values are created within
-the context of a handle scope. When a native method is called from
+created within a particular scope. In general, Node-API values are created
+within the context of a handle scope. When a native method is called from
 JavaScript, a default handle scope will exist. If the user does not explicitly
-create a new handle scope, N-API values will be created in the default handle
+create a new handle scope, Node-API values will be created in the default handle
 scope. For any invocations of code outside the execution of a native method
 (for instance, during a libuv callback invocation), the module is required to
 create a scope before invoking any functions that can result in the creation
@@ -986,14 +1015,14 @@ using <a href="#n_api_napi_close_handle_scope"><code>napi_close_handle_scope</co
 that all <code>napi_value</code>s created during the lifetime of the handle scope are no
 longer referenced from the current stack frame.</p>
 <p>For more details, review the <a href="#n_api_object_lifetime_management">Object lifetime management</a>.</p>
-<h4>napi_escapable_handle_scope<span><a class="mark" href="#n_api_napi_escapable_handle_scope" id="n_api_napi_escapable_handle_scope">#</a></span></h4>
+<h5>napi_escapable_handle_scope<span><a class="mark" href="#n_api_napi_escapable_handle_scope" id="n_api_napi_escapable_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <p>Escapable handle scopes are a special type of handle scope to return values
 created within a particular handle scope to a parent scope.</p>
-<h4>napi_ref<span><a class="mark" href="#n_api_napi_ref" id="n_api_napi_ref">#</a></span></h4>
+<h5>napi_ref<span><a class="mark" href="#n_api_napi_ref" id="n_api_napi_ref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
@@ -1002,9 +1031,9 @@ created within a particular handle scope to a parent scope.</p>
 users to manage the lifetimes of JavaScript values, including defining their
 minimum lifetimes explicitly.</p>
 <p>For more details, review the <a href="#n_api_object_lifetime_management">Object lifetime management</a>.</p>
-<h4>napi_type_tag<span><a class="mark" href="#n_api_napi_type_tag" id="n_api_napi_type_tag">#</a></span></h4>
+<h5>napi_type_tag<span><a class="mark" href="#n_api_napi_type_tag" id="n_api_napi_type_tag">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0, v12.19.0</span>
 <span>N-API version: 8</span>
 </div>
 <p>A 128-bit value stored as two unsigned 64-bit integers. It serves as a UUID
@@ -1016,18 +1045,18 @@ because it ensures that the pointer retrieved from a wrapped object can be
 safely cast to the native type corresponding to the type tag that had been
 previously applied to the JavaScript object.</p>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> {</span>
-  <span class="hljs-keyword">uint64_t</span> lower;
-  <span class="hljs-keyword">uint64_t</span> upper;
+  <span class="hljs-type">uint64_t</span> lower;
+  <span class="hljs-type">uint64_t</span> upper;
 } napi_type_tag;</code></pre>
-<h4>napi_async_cleanup_hook_handle<span><a class="mark" href="#n_api_napi_async_cleanup_hook_handle" id="n_api_napi_async_cleanup_hook_handle">#</a></span></h4>
+<h5>napi_async_cleanup_hook_handle<span><a class="mark" href="#n_api_napi_async_cleanup_hook_handle" id="n_api_napi_async_cleanup_hook_handle">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.10.0</span>
 </div>
 <p>An opaque value returned by <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a>. It must be passed
 to <a href="#n_api_napi_remove_async_cleanup_hook"><code>napi_remove_async_cleanup_hook</code></a> when the chain of asynchronous cleanup
 events completes.</p>
-<h3>N-API callback types<span><a class="mark" href="#n_api_n_api_callback_types" id="n_api_n_api_callback_types">#</a></span></h3>
-<h4>napi_callback_info<span><a class="mark" href="#n_api_napi_callback_info" id="n_api_napi_callback_info">#</a></span></h4>
+<h4>Node-API callback types<span><a class="mark" href="#n_api_node_api_callback_types" id="n_api_node_api_callback_types">#</a></span></h4>
+<h5>napi_callback_info<span><a class="mark" href="#n_api_napi_callback_info" id="n_api_napi_callback_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
@@ -1035,18 +1064,18 @@ events completes.</p>
 <p>Opaque datatype that is passed to a callback function. It can be used for
 getting additional information about the context in which the callback was
 invoked.</p>
-<h4>napi_callback<span><a class="mark" href="#n_api_napi_callback" id="n_api_napi_callback">#</a></span></h4>
+<h5>napi_callback<span><a class="mark" href="#n_api_napi_callback" id="n_api_napi_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <p>Function pointer type for user-provided native functions which are to be
-exposed to JavaScript via N-API. Callback functions should satisfy the
+exposed to JavaScript via Node-API. Callback functions should satisfy the
 following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">napi_value</span> <span class="hljs-params">(*napi_callback)</span><span class="hljs-params">(napi_env, napi_callback_info)</span></span>;</code></pre>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">napi_value</span> <span class="hljs-params">(*napi_callback)</span><span class="hljs-params">(napi_env, napi_callback_info)</span>;</code></pre>
 <p>Unless for reasons discussed in <a href="#n_api_object_lifetime_management">Object Lifetime Management</a>, creating a
 handle and/or callback scope inside a <code>napi_callback</code> is not necessary.</p>
-<h4>napi_finalize<span><a class="mark" href="#n_api_napi_finalize" id="n_api_napi_finalize">#</a></span></h4>
+<h5>napi_finalize<span><a class="mark" href="#n_api_napi_finalize" id="n_api_napi_finalize">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
@@ -1057,36 +1086,36 @@ object with which it was associated with, has been garbage-collected. The user
 must provide a function satisfying the following signature which would get
 called upon the object's collection. Currently, <code>napi_finalize</code> can be used for
 finding out when objects that have external data are collected.</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_finalize)</span><span class="hljs-params">(napi_env env,
-                              <span class="hljs-keyword">void</span>* finalize_data,
-                              <span class="hljs-keyword">void</span>* finalize_hint)</span></span>;</code></pre>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_finalize)</span><span class="hljs-params">(napi_env env,
+                              <span class="hljs-type">void</span>* finalize_data,
+                              <span class="hljs-type">void</span>* finalize_hint)</span>;</code></pre>
 <p>Unless for reasons discussed in <a href="#n_api_object_lifetime_management">Object Lifetime Management</a>, creating a
 handle and/or callback scope inside the function body is not necessary.</p>
-<h4>napi_async_execute_callback<span><a class="mark" href="#n_api_napi_async_execute_callback" id="n_api_napi_async_execute_callback">#</a></span></h4>
+<h5>napi_async_execute_callback<span><a class="mark" href="#n_api_napi_async_execute_callback" id="n_api_napi_async_execute_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <p>Function pointer used with functions that support asynchronous
 operations. Callback functions must satisfy the following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_execute_callback)</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
-<p>Implementations of this function must avoid making N-API calls that execute
-JavaScript or interact with JavaScript objects. N-API calls should be in the
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_execute_callback)</span><span class="hljs-params">(napi_env env, <span class="hljs-type">void</span>* data)</span>;</code></pre>
+<p>Implementations of this function must avoid making Node-API calls that execute
+JavaScript or interact with JavaScript objects. Node-API calls should be in the
 <code>napi_async_complete_callback</code> instead. Do not use the <code>napi_env</code> parameter as
 it will likely result in execution of JavaScript.</p>
-<h4>napi_async_complete_callback<span><a class="mark" href="#n_api_napi_async_complete_callback" id="n_api_napi_async_complete_callback">#</a></span></h4>
+<h5>napi_async_complete_callback<span><a class="mark" href="#n_api_napi_async_complete_callback" id="n_api_napi_async_complete_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
 <p>Function pointer used with functions that support asynchronous
 operations. Callback functions must satisfy the following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_complete_callback)</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_complete_callback)</span><span class="hljs-params">(napi_env env,
                                              napi_status status,
-                                             <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
+                                             <span class="hljs-type">void</span>* data)</span>;</code></pre>
 <p>Unless for reasons discussed in <a href="#n_api_object_lifetime_management">Object Lifetime Management</a>, creating a
 handle and/or callback scope inside the function body is not necessary.</p>
-<h4>napi_threadsafe_function_call_js<span><a class="mark" href="#n_api_napi_threadsafe_function_call_js" id="n_api_napi_threadsafe_function_call_js">#</a></span></h4>
+<h5>napi_threadsafe_function_call_js<span><a class="mark" href="#n_api_napi_threadsafe_function_call_js" id="n_api_napi_threadsafe_function_call_js">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
@@ -1099,14 +1128,14 @@ make the call into JavaScript.</p>
 <p>The data arriving from the secondary thread via the queue is given in the <code>data</code>
 parameter and the JavaScript function to call is given in the <code>js_callback</code>
 parameter.</p>
-<p>N-API sets up the environment prior to calling this callback, so it is
+<p>Node-API sets up the environment prior to calling this callback, so it is
 sufficient to call the JavaScript function via <code>napi_call_function</code> rather than
 via <code>napi_make_callback</code>.</p>
 <p>Callback functions must satisfy the following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_threadsafe_function_call_js)</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_threadsafe_function_call_js)</span><span class="hljs-params">(napi_env env,
                                                  napi_value js_callback,
-                                                 <span class="hljs-keyword">void</span>* context,
-                                                 <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
+                                                 <span class="hljs-type">void</span>* context,
+                                                 <span class="hljs-type">void</span>* data)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment to use for API calls, or <code>NULL</code> if the thread-safe
 function is being torn down and <code>data</code> may need to be freed.</li>
@@ -1117,22 +1146,22 @@ may also be <code>NULL</code> if the thread-safe function was created without
 <li><code>[in] context</code>: The optional data with which the thread-safe function was
 created.</li>
 <li><code>[in] data</code>: Data created by the secondary thread. It is the responsibility of
-the callback to convert this native data to JavaScript values (with N-API
+the callback to convert this native data to JavaScript values (with Node-API
 functions) that can be passed as parameters when <code>js_callback</code> is invoked.
 This pointer is managed entirely by the threads and this callback. Thus this
 callback should free the data.</li>
 </ul>
 <p>Unless for reasons discussed in <a href="#n_api_object_lifetime_management">Object Lifetime Management</a>, creating a
 handle and/or callback scope inside the function body is not necessary.</p>
-<h4>napi_async_cleanup_hook<span><a class="mark" href="#n_api_napi_async_cleanup_hook" id="n_api_napi_async_cleanup_hook">#</a></span></h4>
+<h5>napi_async_cleanup_hook<span><a class="mark" href="#n_api_napi_async_cleanup_hook" id="n_api_napi_async_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.10.0</span>
 </div>
 <p>Function pointer used with <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a>. It will be called
 when the environment is being torn down.</p>
 <p>Callback functions must satisfy the following signature:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_cleanup_hook)</span><span class="hljs-params">(napi_async_cleanup_hook_handle handle,
-                                        <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_cleanup_hook)</span><span class="hljs-params">(napi_async_cleanup_hook_handle handle,
+                                        <span class="hljs-type">void</span>* data)</span>;</code></pre>
 <ul>
 <li><code>[in] handle</code>: The handle that must be passed to
 <a href="#n_api_napi_remove_async_cleanup_hook"><code>napi_remove_async_cleanup_hook</code></a> after completion of the asynchronous
@@ -1142,11 +1171,11 @@ cleanup.</li>
 <p>The body of the function should initiate the asynchronous cleanup actions at the
 end of which <code>handle</code> must be passed in a call to
 <a href="#n_api_napi_remove_async_cleanup_hook"><code>napi_remove_async_cleanup_hook</code></a>.</p>
-<h2>Error handling<span><a class="mark" href="#n_api_error_handling" id="n_api_error_handling">#</a></span></h2>
-<p>N-API uses both return values and JavaScript exceptions for error handling.
+</section><section><h3>Error handling<span><a class="mark" href="#n_api_error_handling" id="n_api_error_handling">#</a></span></h3>
+<p>Node-API uses both return values and JavaScript exceptions for error handling.
 The following sections explain the approach for each case.</p>
-<h3>Return values<span><a class="mark" href="#n_api_return_values" id="n_api_return_values">#</a></span></h3>
-<p>All of the N-API functions share the same error handling pattern. The
+<h4>Return values<span><a class="mark" href="#n_api_return_values" id="n_api_return_values">#</a></span></h4>
+<p>All of the Node-API functions share the same error handling pattern. The
 return type of all API functions is <code>napi_status</code>.</p>
 <p>The return value will be <code>napi_ok</code> if the request was successful and
 no uncaught JavaScript exception was thrown. If an error occurred AND
@@ -1171,30 +1200,30 @@ The format of the <code>napi_extended_error_info</code> structure is as follows:
 <span>N-API version: 1</span>
 </div>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> <span class="hljs-title">napi_extended_error_info</span> {</span>
-  <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* error_message;
-  <span class="hljs-keyword">void</span>* engine_reserved;
-  <span class="hljs-keyword">uint32_t</span> engine_error_code;
+  <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* error_message;
+  <span class="hljs-type">void</span>* engine_reserved;
+  <span class="hljs-type">uint32_t</span> engine_error_code;
   napi_status error_code;
 };</code></pre>
 <ul>
 <li><code>error_message</code>: Textual representation of the error that occurred.</li>
 <li><code>engine_reserved</code>: Opaque handle reserved for engine use only.</li>
 <li><code>engine_error_code</code>: VM specific error code.</li>
-<li><code>error_code</code>: n-api status code for the last error.</li>
+<li><code>error_code</code>: Node-API status code for the last error.</li>
 </ul>
 <p><a href="#n_api_napi_get_last_error_info"><code>napi_get_last_error_info</code></a> returns the information for the last
-N-API call that was made.</p>
+Node-API call that was made.</p>
 <p>Do not rely on the content or format of any of the extended information as it
 is not subject to SemVer and may change at any time. It is intended only for
 logging purposes.</p>
-<h4>napi_get_last_error_info<span><a class="mark" href="#n_api_napi_get_last_error_info" id="n_api_napi_get_last_error_info">#</a></span></h4>
+<h5>napi_get_last_error_info<span><a class="mark" href="#n_api_napi_get_last_error_info" id="n_api_napi_get_last_error_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status
-<span class="hljs-title">napi_get_last_error_info</span><span class="hljs-params">(napi_env env,
-                         <span class="hljs-keyword">const</span> napi_extended_error_info** result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status
+<span class="hljs-title function_">napi_get_last_error_info</span><span class="hljs-params">(napi_env env,
+                         <span class="hljs-keyword">const</span> napi_extended_error_info** result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: The <code>napi_extended_error_info</code> structure with more
@@ -1204,13 +1233,13 @@ information about the error.</li>
 <p>This API retrieves a <code>napi_extended_error_info</code> structure with information
 about the last error that occurred.</p>
 <p>The content of the <code>napi_extended_error_info</code> returned is only valid up until
-an n-api function is called on the same <code>env</code>.</p>
+a Node-API function is called on the same <code>env</code>.</p>
 <p>Do not rely on the content or format of any of the extended information as it
 is not subject to SemVer and may change at any time. It is intended only for
 logging purposes.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h3>Exceptions<span><a class="mark" href="#n_api_exceptions" id="n_api_exceptions">#</a></span></h3>
-<p>Any N-API function call may result in a pending JavaScript exception. This is
+<h4>Exceptions<span><a class="mark" href="#n_api_exceptions" id="n_api_exceptions">#</a></span></h4>
+<p>Any Node-API function call may result in a pending JavaScript exception. This is
 the case for any of the API functions, even those that may not cause the
 execution of JavaScript.</p>
 <p>If the <code>napi_status</code> returned by a function is <code>napi_ok</code> then no
@@ -1219,10 +1248,10 @@ exception is pending and no additional action is required. If the
 <code>napi_pending_exception</code>, in order to try to recover and continue
 instead of simply returning immediately, <a href="#n_api_napi_is_exception_pending"><code>napi_is_exception_pending</code></a>
 must be called in order to determine if an exception is pending or not.</p>
-<p>In many cases when an N-API function is called and an exception is
+<p>In many cases when a Node-API function is called and an exception is
 already pending, the function will return immediately with a
 <code>napi_status</code> of <code>napi_pending_exception</code>. However, this is not the case
-for all functions. N-API allows a subset of the functions to be
+for all functions. Node-API allows a subset of the functions to be
 called to allow for some minimal cleanup before returning to JavaScript.
 In that case, <code>napi_status</code> will reflect the status for the function. It
 will not reflect previous pending exceptions. To avoid confusion, check
@@ -1231,7 +1260,7 @@ the error status after every function call.</p>
 <p>The first approach is to do any appropriate cleanup and then return so that
 execution will return to JavaScript. As part of the transition back to
 JavaScript, the exception will be thrown at the point in the JavaScript
-code where the native method was invoked. The behavior of most N-API calls
+code where the native method was invoked. The behavior of most Node-API calls
 is unspecified while an exception is pending, and many will simply return
 <code>napi_pending_exception</code>, so do as little as possible and then return to
 JavaScript where the exception can be handled.</p>
@@ -1244,7 +1273,7 @@ clear the exception. On success, result will contain the handle to
 the last JavaScript <code>Object</code> thrown. If it is determined, after
 retrieving the exception, the exception cannot be handled after all
 it can be re-thrown it with <a href="#n_api_napi_throw"><code>napi_throw</code></a> where error is the
-JavaScript <code>Error</code> object to be thrown.</p>
+JavaScript value to be thrown.</p>
 <p>The following utility functions are also available in case native code
 needs to throw an exception or determine if a <code>napi_value</code> is an instance
 of a JavaScript <code>Error</code> object: <a href="#n_api_napi_throw_error"><code>napi_throw_error</code></a>,
@@ -1260,7 +1289,7 @@ generated internally. The goal is for applications to use these
 error codes for all error checking. The associated error messages
 will remain, but will only be meant to be used for logging and
 display with the expectation that the message can change without
-SemVer applying. In order to support this model with N-API, both
+SemVer applying. In order to support this model with Node-API, both
 in internal functionality and for module specific functionality
 (as its good practice), the <code>throw_</code> and <code>create_</code> functions
 take an optional code parameter which is the string for the code
@@ -1272,26 +1301,26 @@ the name associated with the error is also updated to be:</p>
 and <code>code</code> is the code that was provided. For example, if the code
 is <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the name will be:</p>
 <pre><code class="language-text">TypeError [ERR_ERROR_1]</code></pre>
-<h4>napi_throw<span><a class="mark" href="#n_api_napi_throw" id="n_api_napi_throw">#</a></span></h4>
+<h5>napi_throw<span><a class="mark" href="#n_api_napi_throw" id="n_api_napi_throw">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_throw</span><span class="hljs-params">(napi_env env, napi_value error)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_throw</span><span class="hljs-params">(napi_env env, napi_value error)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] error</code>: The JavaScript value to be thrown.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API throws the JavaScript value provided.</p>
-<h4>napi_throw_error<span><a class="mark" href="#n_api_napi_throw_error" id="n_api_napi_throw_error">#</a></span></h4>
+<h5>napi_throw_error<span><a class="mark" href="#n_api_napi_throw_error" id="n_api_napi_throw_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_throw_error</span><span class="hljs-params">(napi_env env,
-                                         <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* code,
-                                         <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* msg)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_throw_error</span><span class="hljs-params">(napi_env env,
+                                         <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* code,
+                                         <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* msg)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional error code to be set on the error.</li>
@@ -1299,14 +1328,14 @@ is <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API throws a JavaScript <code>Error</code> with the text provided.</p>
-<h4>napi_throw_type_error<span><a class="mark" href="#n_api_napi_throw_type_error" id="n_api_napi_throw_type_error">#</a></span></h4>
+<h5>napi_throw_type_error<span><a class="mark" href="#n_api_napi_throw_type_error" id="n_api_napi_throw_type_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_throw_type_error</span><span class="hljs-params">(napi_env env,
-                                              <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* code,
-                                              <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* msg)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_throw_type_error</span><span class="hljs-params">(napi_env env,
+                                              <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* code,
+                                              <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* msg)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional error code to be set on the error.</li>
@@ -1314,14 +1343,14 @@ is <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API throws a JavaScript <code>TypeError</code> with the text provided.</p>
-<h4>napi_throw_range_error<span><a class="mark" href="#n_api_napi_throw_range_error" id="n_api_napi_throw_range_error">#</a></span></h4>
+<h5>napi_throw_range_error<span><a class="mark" href="#n_api_napi_throw_range_error" id="n_api_napi_throw_range_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_throw_range_error</span><span class="hljs-params">(napi_env env,
-                                               <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* code,
-                                               <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* msg)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_throw_range_error</span><span class="hljs-params">(napi_env env,
+                                               <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* code,
+                                               <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* msg)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional error code to be set on the error.</li>
@@ -1329,14 +1358,14 @@ is <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API throws a JavaScript <code>RangeError</code> with the text provided.</p>
-<h4>napi_is_error<span><a class="mark" href="#n_api_napi_is_error" id="n_api_napi_is_error">#</a></span></h4>
+<h5>napi_is_error<span><a class="mark" href="#n_api_napi_is_error" id="n_api_napi_is_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_is_error</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_is_error</span><span class="hljs-params">(napi_env env,
                                       napi_value value,
-                                      <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                      <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The <code>napi_value</code> to be checked.</li>
@@ -1345,112 +1374,112 @@ an error, false otherwise.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API queries a <code>napi_value</code> to check if it represents an error object.</p>
-<h4>napi_create_error<span><a class="mark" href="#n_api_napi_create_error" id="n_api_napi_create_error">#</a></span></h4>
+<h5>napi_create_error<span><a class="mark" href="#n_api_napi_create_error" id="n_api_napi_create_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_create_error</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_create_error</span><span class="hljs-params">(napi_env env,
                                           napi_value code,
                                           napi_value msg,
-                                          napi_value* result)</span></span>;</code></pre>
+                                          napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be
 associated with the error.</li>
-<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as
+<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as
 the message for the <code>Error</code>.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns a JavaScript <code>Error</code> with the text provided.</p>
-<h4>napi_create_type_error<span><a class="mark" href="#n_api_napi_create_type_error" id="n_api_napi_create_type_error">#</a></span></h4>
+<h5>napi_create_type_error<span><a class="mark" href="#n_api_napi_create_type_error" id="n_api_napi_create_type_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_create_type_error</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_create_type_error</span><span class="hljs-params">(napi_env env,
                                                napi_value code,
                                                napi_value msg,
-                                               napi_value* result)</span></span>;</code></pre>
+                                               napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be
 associated with the error.</li>
-<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as
+<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as
 the message for the <code>Error</code>.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns a JavaScript <code>TypeError</code> with the text provided.</p>
-<h4>napi_create_range_error<span><a class="mark" href="#n_api_napi_create_range_error" id="n_api_napi_create_range_error">#</a></span></h4>
+<h5>napi_create_range_error<span><a class="mark" href="#n_api_napi_create_range_error" id="n_api_napi_create_range_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_create_range_error</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_create_range_error</span><span class="hljs-params">(napi_env env,
                                                 napi_value code,
                                                 napi_value msg,
-                                                napi_value* result)</span></span>;</code></pre>
+                                                napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be
 associated with the error.</li>
-<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as
+<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as
 the message for the <code>Error</code>.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns a JavaScript <code>RangeError</code> with the text provided.</p>
-<h4>napi_get_and_clear_last_exception<span><a class="mark" href="#n_api_napi_get_and_clear_last_exception" id="n_api_napi_get_and_clear_last_exception">#</a></span></h4>
+<h5>napi_get_and_clear_last_exception<span><a class="mark" href="#n_api_napi_get_and_clear_last_exception" id="n_api_napi_get_and_clear_last_exception">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_and_clear_last_exception</span><span class="hljs-params">(napi_env env,
-                                              napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_and_clear_last_exception</span><span class="hljs-params">(napi_env env,
+                                              napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: The exception if one is pending, <code>NULL</code> otherwise.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_is_exception_pending<span><a class="mark" href="#n_api_napi_is_exception_pending" id="n_api_napi_is_exception_pending">#</a></span></h4>
+<h5>napi_is_exception_pending<span><a class="mark" href="#n_api_napi_is_exception_pending" id="n_api_napi_is_exception_pending">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_exception_pending</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_exception_pending</span><span class="hljs-params">(napi_env env, <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: Boolean value that is set to true if an exception is pending.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_fatal_exception<span><a class="mark" href="#n_api_napi_fatal_exception" id="n_api_napi_fatal_exception">#</a></span></h4>
+<h5>napi_fatal_exception<span><a class="mark" href="#n_api_napi_fatal_exception" id="n_api_napi_fatal_exception">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v9.10.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_fatal_exception</span><span class="hljs-params">(napi_env env, napi_value err)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_fatal_exception</span><span class="hljs-params">(napi_env env, napi_value err)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] err</code>: The error that is passed to <code>'uncaughtException'</code>.</li>
 </ul>
 <p>Trigger an <code>'uncaughtException'</code> in JavaScript. Useful if an async
 callback throws an exception with no way to recover.</p>
-<h3>Fatal errors<span><a class="mark" href="#n_api_fatal_errors" id="n_api_fatal_errors">#</a></span></h3>
+<h4>Fatal errors<span><a class="mark" href="#n_api_fatal_errors" id="n_api_fatal_errors">#</a></span></h4>
 <p>In the event of an unrecoverable error in a native module, a fatal error can be
 thrown to immediately terminate the process.</p>
-<h4>napi_fatal_error<span><a class="mark" href="#n_api_napi_fatal_error" id="n_api_napi_fatal_error">#</a></span></h4>
+<h5>napi_fatal_error<span><a class="mark" href="#n_api_napi_fatal_error" id="n_api_napi_fatal_error">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_NO_RETURN <span class="hljs-keyword">void</span> <span class="hljs-title">napi_fatal_error</span><span class="hljs-params">(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* location,
-                                                 <span class="hljs-keyword">size_t</span> location_len,
-                                                 <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* message,
-                                                 <span class="hljs-keyword">size_t</span> message_len)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_NO_RETURN <span class="hljs-type">void</span> <span class="hljs-title function_">napi_fatal_error</span><span class="hljs-params">(<span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* location,
+                                     <span class="hljs-type">size_t</span> location_len,
+                                     <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* message,
+                                     <span class="hljs-type">size_t</span> message_len)</span>;</code></pre>
 <ul>
 <li><code>[in] location</code>: Optional location at which the error occurred.</li>
 <li><code>[in] location_len</code>: The length of the location in bytes, or
@@ -1461,8 +1490,8 @@ if it is null-terminated.</li>
 </ul>
 <p>The function call does not return, the process will be terminated.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h2>Object lifetime management<span><a class="mark" href="#n_api_object_lifetime_management" id="n_api_object_lifetime_management">#</a></span></h2>
-<p>As N-API calls are made, handles to objects in the heap for the underlying
+</section><section><h3>Object lifetime management<span><a class="mark" href="#n_api_object_lifetime_management" id="n_api_object_lifetime_management">#</a></span></h3>
+<p>As Node-API calls are made, handles to objects in the heap for the underlying
 VM may be returned as <code>napi_values</code>. These handles must hold the
 objects 'live' until they are no longer required by the native code,
 otherwise the objects could be collected before the native code was
@@ -1474,13 +1503,13 @@ remain valid and the objects associated with these handles will be
 held live for the lifespan of the native method call.</p>
 <p>In many cases, however, it is necessary that the handles remain valid for
 either a shorter or longer lifespan than that of the native method.
-The sections which follow describe the N-API functions that can be used
+The sections which follow describe the Node-API functions that can be used
 to change the handle lifespan from the default.</p>
-<h3>Making handle lifespan shorter than that of the native method<span><a class="mark" href="#n_api_making_handle_lifespan_shorter_than_that_of_the_native_method" id="n_api_making_handle_lifespan_shorter_than_that_of_the_native_method">#</a></span></h3>
+<h4>Making handle lifespan shorter than that of the native method<span><a class="mark" href="#n_api_making_handle_lifespan_shorter_than_that_of_the_native_method" id="n_api_making_handle_lifespan_shorter_than_that_of_the_native_method">#</a></span></h4>
 <p>It is often necessary to make the lifespan of handles shorter than
 the lifespan of a native method. For example, consider a native method
 that has a loop which iterates through the elements in a large array:</p>
-<pre><code class="language-c"><span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000000</span>; i++) {
+<pre><code class="language-c"><span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000000</span>; i++) {
   napi_value result;
   napi_status status = napi_get_element(env, object, i, &#x26;result);
   <span class="hljs-keyword">if</span> (status != napi_ok) {
@@ -1492,12 +1521,12 @@ that has a loop which iterates through the elements in a large array:</p>
 substantial resources. In addition, even though the native code could only
 use the most recent handle, all of the associated objects would also be
 kept alive since they all share the same scope.</p>
-<p>To handle this case, N-API provides the ability to establish a new 'scope' to
+<p>To handle this case, Node-API provides the ability to establish a new 'scope' to
 which newly created handles will be associated. Once those handles
 are no longer required, the scope can be 'closed' and any handles associated
 with the scope are invalidated. The methods available to open/close scopes are
 <a href="#n_api_napi_open_handle_scope"><code>napi_open_handle_scope</code></a> and <a href="#n_api_napi_close_handle_scope"><code>napi_close_handle_scope</code></a>.</p>
-<p>N-API only supports a single nested hierarchy of scopes. There is only one
+<p>Node-API only supports a single nested hierarchy of scopes. There is only one
 active scope at any time, and all new handles will be associated with that
 scope while it is active. Scopes must be closed in the reverse order from
 which they are opened. In addition, all scopes created within a native method
@@ -1505,7 +1534,7 @@ must be closed before returning from that method.</p>
 <p>Taking the earlier example, adding calls to <a href="#n_api_napi_open_handle_scope"><code>napi_open_handle_scope</code></a> and
 <a href="#n_api_napi_close_handle_scope"><code>napi_close_handle_scope</code></a> would ensure that at most a single handle
 is valid throughout the execution of the loop:</p>
-<pre><code class="language-c"><span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000000</span>; i++) {
+<pre><code class="language-c"><span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000000</span>; i++) {
   napi_handle_scope scope;
   napi_status status = napi_open_handle_scope(env, &#x26;scope);
   <span class="hljs-keyword">if</span> (status != napi_ok) {
@@ -1523,8 +1552,8 @@ is valid throughout the execution of the loop:</p>
   }
 }</code></pre>
 <p>When nesting scopes, there are cases where a handle from an
-inner scope needs to live beyond the lifespan of that scope. N-API supports an
-'escapable scope' in order to support this case. An escapable scope
+inner scope needs to live beyond the lifespan of that scope. Node-API supports
+an 'escapable scope' in order to support this case. An escapable scope
 allows one handle to be 'promoted' so that it 'escapes' the
 current scope and the lifespan of the handle changes from the current
 scope to that of the outer scope.</p>
@@ -1533,26 +1562,26 @@ scope to that of the outer scope.</p>
 <a href="#n_api_napi_close_escapable_handle_scope"><code>napi_close_escapable_handle_scope</code></a>.</p>
 <p>The request to promote a handle is made through <a href="#n_api_napi_escape_handle"><code>napi_escape_handle</code></a> which
 can only be called once.</p>
-<h4>napi_open_handle_scope<span><a class="mark" href="#n_api_napi_open_handle_scope" id="n_api_napi_open_handle_scope">#</a></span></h4>
+<h5>napi_open_handle_scope<span><a class="mark" href="#n_api_napi_open_handle_scope" id="n_api_napi_open_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_open_handle_scope</span><span class="hljs-params">(napi_env env,
-                                               napi_handle_scope* result)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_open_handle_scope</span><span class="hljs-params">(napi_env env,
+                                               napi_handle_scope* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the new scope.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API opens a new scope.</p>
-<h4>napi_close_handle_scope<span><a class="mark" href="#n_api_napi_close_handle_scope" id="n_api_napi_close_handle_scope">#</a></span></h4>
+<h5>napi_close_handle_scope<span><a class="mark" href="#n_api_napi_close_handle_scope" id="n_api_napi_close_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_close_handle_scope</span><span class="hljs-params">(napi_env env,
-                                                napi_handle_scope scope)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_close_handle_scope</span><span class="hljs-params">(napi_env env,
+                                                napi_handle_scope scope)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] scope</code>: <code>napi_value</code> representing the scope to be closed.</li>
@@ -1561,14 +1590,14 @@ can only be called once.</p>
 <p>This API closes the scope passed in. Scopes must be closed in the
 reverse order from which they were created.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_open_escapable_handle_scope<span><a class="mark" href="#n_api_napi_open_escapable_handle_scope" id="n_api_napi_open_escapable_handle_scope">#</a></span></h4>
+<h5>napi_open_escapable_handle_scope<span><a class="mark" href="#n_api_napi_open_escapable_handle_scope" id="n_api_napi_open_escapable_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-    <span class="hljs-title">napi_open_escapable_handle_scope</span><span class="hljs-params">(napi_env env,
-                                     napi_handle_scope* result)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+    <span class="hljs-title function_">napi_open_escapable_handle_scope</span><span class="hljs-params">(napi_env env,
+                                     napi_handle_scope* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing the new scope.</li>
@@ -1576,14 +1605,14 @@ reverse order from which they were created.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API opens a new scope from which one object can be promoted
 to the outer scope.</p>
-<h4>napi_close_escapable_handle_scope<span><a class="mark" href="#n_api_napi_close_escapable_handle_scope" id="n_api_napi_close_escapable_handle_scope">#</a></span></h4>
+<h5>napi_close_escapable_handle_scope<span><a class="mark" href="#n_api_napi_close_escapable_handle_scope" id="n_api_napi_close_escapable_handle_scope">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-    <span class="hljs-title">napi_close_escapable_handle_scope</span><span class="hljs-params">(napi_env env,
-                                      napi_handle_scope scope)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+    <span class="hljs-title function_">napi_close_escapable_handle_scope</span><span class="hljs-params">(napi_env env,
+                                      napi_handle_scope scope)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] scope</code>: <code>napi_value</code> representing the scope to be closed.</li>
@@ -1592,15 +1621,15 @@ to the outer scope.</p>
 <p>This API closes the scope passed in. Scopes must be closed in the
 reverse order from which they were created.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_escape_handle<span><a class="mark" href="#n_api_napi_escape_handle" id="n_api_napi_escape_handle">#</a></span></h4>
+<h5>napi_escape_handle<span><a class="mark" href="#n_api_napi_escape_handle" id="n_api_napi_escape_handle">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_escape_handle</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_escape_handle</span><span class="hljs-params">(napi_env env,
                                napi_escapable_handle_scope scope,
                                napi_value escapee,
-                               napi_value* result)</span></span>;</code></pre>
+                               napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] scope</code>: <code>napi_value</code> representing the current scope.</li>
@@ -1614,7 +1643,7 @@ in the outer scope.</li>
 for the lifetime of the outer scope. It can only be called once per scope.
 If it is called more than once an error will be returned.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h3>References to objects with a lifespan longer than that of the native method<span><a class="mark" href="#n_api_references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method" id="n_api_references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method">#</a></span></h3>
+<h4>References to objects with a lifespan longer than that of the native method<span><a class="mark" href="#n_api_references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method" id="n_api_references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method">#</a></span></h4>
 <p>In some cases an addon will need to be able to create and reference objects
 with a lifespan longer than that of a single native method invocation. For
 example, to create a constructor and later use that constructor
@@ -1624,7 +1653,7 @@ would not be possible with a normal handle returned as a <code>napi_value</code>
 described in the earlier section. The lifespan of a normal handle is
 managed by scopes and all scopes must be closed before the end of a native
 method.</p>
-<p>N-API provides methods to create persistent references to an object.
+<p>Node-API provides methods to create persistent references to an object.
 Each persistent reference has an associated count with a value of 0
 or higher. The count determines if the reference will keep
 the corresponding object live. References with a count of 0 do not
@@ -1638,24 +1667,24 @@ for a reference is 0, all subsequent calls to
 get the object associated with the reference <a href="#n_api_napi_get_reference_value"><code>napi_get_reference_value</code></a>
 will return <code>NULL</code> for the returned <code>napi_value</code>. An attempt to call
 <a href="#n_api_napi_reference_ref"><code>napi_reference_ref</code></a> for a reference whose object has been collected
-will result in an error.</p>
+results in an error.</p>
 <p>References must be deleted once they are no longer required by the addon. When
-a reference is deleted it will no longer prevent the corresponding object from
-being collected. Failure to delete a persistent reference will result in
+a reference is deleted, it will no longer prevent the corresponding object from
+being collected. Failure to delete a persistent reference results in
 a 'memory leak' with both the native memory for the persistent reference and
 the corresponding object on the heap being retained forever.</p>
 <p>There can be multiple persistent references created which refer to the same
 object, each of which will either keep the object live or not based on its
 individual count.</p>
-<h4>napi_create_reference<span><a class="mark" href="#n_api_napi_create_reference" id="n_api_napi_create_reference">#</a></span></h4>
+<h5>napi_create_reference<span><a class="mark" href="#n_api_napi_create_reference" id="n_api_napi_create_reference">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_create_reference</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_create_reference</span><span class="hljs-params">(napi_env env,
                                               napi_value value,
-                                              <span class="hljs-keyword">uint32_t</span> initial_refcount,
-                                              napi_ref* result)</span></span>;</code></pre>
+                                              <span class="hljs-type">uint32_t</span> initial_refcount,
+                                              napi_ref* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing the <code>Object</code> to which we want a
@@ -1666,12 +1695,12 @@ reference.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API create a new reference with the specified reference count
 to the <code>Object</code> passed in.</p>
-<h4>napi_delete_reference<span><a class="mark" href="#n_api_napi_delete_reference" id="n_api_napi_delete_reference">#</a></span></h4>
+<h5>napi_delete_reference<span><a class="mark" href="#n_api_napi_delete_reference" id="n_api_napi_delete_reference">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_delete_reference</span><span class="hljs-params">(napi_env env, napi_ref ref)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_delete_reference</span><span class="hljs-params">(napi_env env, napi_ref ref)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] ref</code>: <code>napi_ref</code> to be deleted.</li>
@@ -1679,14 +1708,14 @@ to the <code>Object</code> passed in.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API deletes the reference passed in.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h4>napi_reference_ref<span><a class="mark" href="#n_api_napi_reference_ref" id="n_api_napi_reference_ref">#</a></span></h4>
+<h5>napi_reference_ref<span><a class="mark" href="#n_api_napi_reference_ref" id="n_api_napi_reference_ref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_reference_ref</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_reference_ref</span><span class="hljs-params">(napi_env env,
                                            napi_ref ref,
-                                           <span class="hljs-keyword">uint32_t</span>* result)</span></span>;</code></pre>
+                                           <span class="hljs-type">uint32_t</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] ref</code>: <code>napi_ref</code> for which the reference count will be incremented.</li>
@@ -1695,14 +1724,14 @@ to the <code>Object</code> passed in.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API increments the reference count for the reference
 passed in and returns the resulting reference count.</p>
-<h4>napi_reference_unref<span><a class="mark" href="#n_api_napi_reference_unref" id="n_api_napi_reference_unref">#</a></span></h4>
+<h5>napi_reference_unref<span><a class="mark" href="#n_api_napi_reference_unref" id="n_api_napi_reference_unref">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_reference_unref</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_reference_unref</span><span class="hljs-params">(napi_env env,
                                              napi_ref ref,
-                                             <span class="hljs-keyword">uint32_t</span>* result)</span></span>;</code></pre>
+                                             <span class="hljs-type">uint32_t</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] ref</code>: <code>napi_ref</code> for which the reference count will be decremented.</li>
@@ -1711,14 +1740,14 @@ passed in and returns the resulting reference count.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API decrements the reference count for the reference
 passed in and returns the resulting reference count.</p>
-<h4>napi_get_reference_value<span><a class="mark" href="#n_api_napi_get_reference_value" id="n_api_napi_get_reference_value">#</a></span></h4>
+<h5>napi_get_reference_value<span><a class="mark" href="#n_api_napi_get_reference_value" id="n_api_napi_get_reference_value">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_get_reference_value</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_get_reference_value</span><span class="hljs-params">(napi_env env,
                                                  napi_ref ref,
-                                                 napi_value* result)</span></span>;</code></pre>
+                                                 napi_value* result)</span>;</code></pre>
 <p>the <code>napi_value passed</code> in or out of these methods is a handle to the
 object to which the reference is related.</p>
 <ul>
@@ -1731,21 +1760,21 @@ object to which the reference is related.</p>
 <p>If still valid, this API returns the <code>napi_value</code> representing the
 JavaScript <code>Object</code> associated with the <code>napi_ref</code>. Otherwise, result
 will be <code>NULL</code>.</p>
-<h3>Cleanup on exit of the current Node.js instance<span><a class="mark" href="#n_api_cleanup_on_exit_of_the_current_node_js_instance" id="n_api_cleanup_on_exit_of_the_current_node_js_instance">#</a></span></h3>
+<h4>Cleanup on exit of the current Node.js instance<span><a class="mark" href="#n_api_cleanup_on_exit_of_the_current_node_js_instance" id="n_api_cleanup_on_exit_of_the_current_node_js_instance">#</a></span></h4>
 <p>While a Node.js process typically releases all its resources when exiting,
 embedders of Node.js, or future Worker support, may require addons to register
 clean-up hooks that will be run once the current Node.js instance exits.</p>
-<p>N-API provides functions for registering and un-registering such callbacks.
+<p>Node-API provides functions for registering and un-registering such callbacks.
 When those callbacks are run, all resources that are being held by the addon
 should be freed up.</p>
-<h4>napi_add_env_cleanup_hook<span><a class="mark" href="#n_api_napi_add_env_cleanup_hook" id="n_api_napi_add_env_cleanup_hook">#</a></span></h4>
+<h5>napi_add_env_cleanup_hook<span><a class="mark" href="#n_api_napi_add_env_cleanup_hook" id="n_api_napi_add_env_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.2.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NODE_EXTERN napi_status <span class="hljs-title">napi_add_env_cleanup_hook</span><span class="hljs-params">(napi_env env,
-                                                  <span class="hljs-keyword">void</span> (*fun)(<span class="hljs-keyword">void</span>* arg),
-                                                  <span class="hljs-keyword">void</span>* arg)</span></span>;</code></pre>
+<pre><code class="language-c">NODE_EXTERN napi_status <span class="hljs-title function_">napi_add_env_cleanup_hook</span><span class="hljs-params">(napi_env env,
+                                                  <span class="hljs-type">void</span> (*fun)(<span class="hljs-type">void</span>* arg),
+                                                  <span class="hljs-type">void</span>* arg)</span>;</code></pre>
 <p>Registers <code>fun</code> as a function to be run with the <code>arg</code> parameter once the
 current Node.js environment exits.</p>
 <p>A function can safely be specified multiple times with different
@@ -1758,37 +1787,37 @@ will be called first.</p>
 Typically, that happens when the resource for which this hook was added
 is being torn down anyway.</p>
 <p>For asynchronous cleanup, <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a> is available.</p>
-<h4>napi_remove_env_cleanup_hook<span><a class="mark" href="#n_api_napi_remove_env_cleanup_hook" id="n_api_napi_remove_env_cleanup_hook">#</a></span></h4>
+<h5>napi_remove_env_cleanup_hook<span><a class="mark" href="#n_api_napi_remove_env_cleanup_hook" id="n_api_napi_remove_env_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.2.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_remove_env_cleanup_hook</span><span class="hljs-params">(napi_env env,
-                                                     <span class="hljs-keyword">void</span> (*fun)(<span class="hljs-keyword">void</span>* arg),
-                                                     <span class="hljs-keyword">void</span>* arg)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_remove_env_cleanup_hook</span><span class="hljs-params">(napi_env env,
+                                                     <span class="hljs-type">void</span> (*fun)(<span class="hljs-type">void</span>* arg),
+                                                     <span class="hljs-type">void</span>* arg)</span>;</code></pre>
 <p>Unregisters <code>fun</code> as a function to be run with the <code>arg</code> parameter once the
 current Node.js environment exits. Both the argument and the function value
 need to be exact matches.</p>
 <p>The function must have originally been registered
 with <code>napi_add_env_cleanup_hook</code>, otherwise the process will abort.</p>
-<h4>napi_add_async_cleanup_hook<span><a class="mark" href="#n_api_napi_add_async_cleanup_hook" id="n_api_napi_add_async_cleanup_hook">#</a></span></h4>
+<h5>napi_add_async_cleanup_hook<span><a class="mark" href="#n_api_napi_add_async_cleanup_hook" id="n_api_napi_add_async_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>Changed signature of the <code>hook</code> callback.</p></td></tr>
-<tr><td>v12.19.0</td>
-<td><p><span>Added in: v12.19.0</span></p></td></tr>
+<tr><td>v14.8.0, v12.19.0</td>
+<td><p><span>Added in: v14.8.0, v12.19.0</span></p></td></tr>
 </tbody></table>
 </details>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_add_async_cleanup_hook</span><span class="hljs-params">(
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_add_async_cleanup_hook</span><span class="hljs-params">(
     napi_env env,
     napi_async_cleanup_hook hook,
-    <span class="hljs-keyword">void</span>* arg,
-    napi_async_cleanup_hook_handle* remove_handle)</span></span>;</code></pre>
+    <span class="hljs-type">void</span>* arg,
+    napi_async_cleanup_hook_handle* remove_handle)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] hook</code>: The function pointer to call at environment teardown.</li>
@@ -1806,20 +1835,20 @@ that must later be passed to <a href="#n_api_napi_remove_async_cleanup_hook"><co
 regardless of whether the hook has already been invoked.
 Typically, that happens when the resource for which this hook was added
 is being torn down anyway.</p>
-<h4>napi_remove_async_cleanup_hook<span><a class="mark" href="#n_api_napi_remove_async_cleanup_hook" id="n_api_napi_remove_async_cleanup_hook">#</a></span></h4>
+<h5>napi_remove_async_cleanup_hook<span><a class="mark" href="#n_api_napi_remove_async_cleanup_hook" id="n_api_napi_remove_async_cleanup_hook">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.10.0</td>
 <td><p>Removed <code>env</code> parameter.</p></td></tr>
-<tr><td>v12.19.0</td>
-<td><p><span>Added in: v12.19.0</span></p></td></tr>
+<tr><td>v14.8.0</td>
+<td><p><span>Added in: v14.8.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_remove_async_cleanup_hook</span><span class="hljs-params">(
-    napi_async_cleanup_hook_handle remove_handle)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_remove_async_cleanup_hook</span><span class="hljs-params">(
+    napi_async_cleanup_hook_handle remove_handle)</span>;</code></pre>
 <ul>
 <li><code>[in] remove_handle</code>: The handle to an asynchronous cleanup hook that was
 created with <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a>.</li>
@@ -1828,22 +1857,22 @@ created with <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_c
 the hook from being executed, unless it has already started executing.
 This must be called on any <code>napi_async_cleanup_hook_handle</code> value obtained
 from <a href="#n_api_napi_add_async_cleanup_hook"><code>napi_add_async_cleanup_hook</code></a>.</p>
-<h2>Module registration<span><a class="mark" href="#n_api_module_registration" id="n_api_module_registration">#</a></span></h2>
-<p>N-API modules are registered in a manner similar to other modules
+</section><section><h3>Module registration<span><a class="mark" href="#n_api_module_registration" id="n_api_module_registration">#</a></span></h3>
+<p>Node-API modules are registered in a manner similar to other modules
 except that instead of using the <code>NODE_MODULE</code> macro the following
 is used:</p>
 <pre><code class="language-c">NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)</code></pre>
-<p>The next difference is the signature for the <code>Init</code> method. For a N-API
+<p>The next difference is the signature for the <code>Init</code> method. For a Node-API
 module it is as follows:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span></span>;</code></pre>
+<pre><code class="language-c">napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span>;</code></pre>
 <p>The return value from <code>Init</code> is treated as the <code>exports</code> object for the module.
 The <code>Init</code> method is passed an empty object via the <code>exports</code> parameter as a
 convenience. If <code>Init</code> returns <code>NULL</code>, the parameter passed as <code>exports</code> is
-exported by the module. N-API modules cannot modify the <code>module</code> object but can
-specify anything as the <code>exports</code> property of the module.</p>
+exported by the module. Node-API modules cannot modify the <code>module</code> object but
+can specify anything as the <code>exports</code> property of the module.</p>
 <p>To add the method <code>hello</code> as a function so that it can be called as a method
 provided by the addon:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> </span>{
+<pre><code class="language-c">napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> {
   napi_status status;
   napi_property_descriptor desc = {
     <span class="hljs-string">"hello"</span>,
@@ -1860,7 +1889,7 @@ provided by the addon:</p>
   <span class="hljs-keyword">return</span> exports;
 }</code></pre>
 <p>To set a function to be returned by the <code>require()</code> for the addon:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> </span>{
+<pre><code class="language-c">napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> {
   napi_value method;
   napi_status status;
   status = napi_create_function(env, <span class="hljs-string">"exports"</span>, NAPI_AUTO_LENGTH, Method, <span class="hljs-literal">NULL</span>, &#x26;method);
@@ -1870,7 +1899,7 @@ provided by the addon:</p>
 <p>To define a class so that new instances can be created (often used with
 <a href="#n_api_object_wrap">Object wrap</a>):</p>
 <pre><code class="language-c"><span class="hljs-comment">// <span class="hljs-doctag">NOTE:</span> partial example, not all referenced code is included</span>
-<span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> </span>{
+napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> {
   napi_status status;
   napi_property_descriptor properties[] = {
     { <span class="hljs-string">"value"</span>, <span class="hljs-literal">NULL</span>, <span class="hljs-literal">NULL</span>, GetValue, SetValue, <span class="hljs-literal">NULL</span>, napi_writable | napi_configurable, <span class="hljs-literal">NULL</span> },
@@ -1891,8 +1920,8 @@ provided by the addon:</p>
 
   <span class="hljs-keyword">return</span> exports;
 }</code></pre>
-<p>If the module will be loaded multiple times during the lifetime of the Node.js
-process, use the <code>NAPI_MODULE_INIT</code> macro to initialize the module:</p>
+<p>You can also use the <code>NAPI_MODULE_INIT</code> macro, which acts as a shorthand
+for <code>NAPI_MODULE</code> and defining an <code>Init</code> function:</p>
 <pre><code class="language-c">NAPI_MODULE_INIT() {
   napi_value answer;
   napi_status result;
@@ -1905,41 +1934,38 @@ process, use the <code>NAPI_MODULE_INIT</code> macro to initialize the module:</
 
   <span class="hljs-keyword">return</span> exports;
 }</code></pre>
-<p>This macro includes <code>NAPI_MODULE</code>, and declares an <code>Init</code> function with a
-special name and with visibility beyond the addon. This will allow Node.js to
-initialize the module even if it is loaded multiple times.</p>
-<p>There are a few design considerations when declaring a module that may be loaded
-multiple times. The documentation of <a href="addons.html#addons_context_aware_addons">context-aware addons</a> provides more
-details.</p>
+<p>All Node-API addons are context-aware, meaning they may be loaded multiple
+times. There are a few design considerations when declaring such a module.
+The documentation on <a href="addons.html#addons_context_aware_addons">context-aware addons</a> provides more details.</p>
 <p>The variables <code>env</code> and <code>exports</code> will be available inside the function body
 following the macro invocation.</p>
 <p>For more details on setting properties on objects, see the section on
 <a href="#n_api_working_with_javascript_properties">Working with JavaScript properties</a>.</p>
 <p>For more details on building addon modules in general, refer to the existing
 API.</p>
-<h2>Working with JavaScript values<span><a class="mark" href="#n_api_working_with_javascript_values" id="n_api_working_with_javascript_values">#</a></span></h2>
-<p>N-API exposes a set of APIs to create all types of JavaScript values.
+</section><section><h3>Working with JavaScript values<span><a class="mark" href="#n_api_working_with_javascript_values" id="n_api_working_with_javascript_values">#</a></span></h3>
+<p>Node-API exposes a set of APIs to create all types of JavaScript values.
 Some of these types are documented under <a href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Section 6</a>
 of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>.</p>
 <p>Fundamentally, these APIs are used to do one of the following:</p>
 <ol>
 <li>Create a new JavaScript object</li>
-<li>Convert from a primitive C type to an N-API value</li>
-<li>Convert from N-API value to a primitive C type</li>
+<li>Convert from a primitive C type to a Node-API value</li>
+<li>Convert from Node-API value to a primitive C type</li>
 <li>Get global instances including <code>undefined</code> and <code>null</code></li>
 </ol>
-<p>N-API values are represented by the type <code>napi_value</code>.
-Any N-API call that requires a JavaScript value takes in a <code>napi_value</code>.
+<p>Node-API values are represented by the type <code>napi_value</code>.
+Any Node-API call that requires a JavaScript value takes in a <code>napi_value</code>.
 In some cases, the API does check the type of the <code>napi_value</code> up-front.
 However, for better performance, it's better for the caller to make sure that
 the <code>napi_value</code> in question is of the JavaScript type expected by the API.</p>
-<h3>Enum types<span><a class="mark" href="#n_api_enum_types" id="n_api_enum_types">#</a></span></h3>
-<h4>napi_key_collection_mode<span><a class="mark" href="#n_api_napi_key_collection_mode" id="n_api_napi_key_collection_mode">#</a></span></h4>
+<h4>Enum types<span><a class="mark" href="#n_api_enum_types" id="n_api_enum_types">#</a></span></h4>
+<h5>napi_key_collection_mode<span><a class="mark" href="#n_api_napi_key_collection_mode" id="n_api_napi_key_collection_mode">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_key_include_prototypes,
   napi_key_own_only
 } napi_key_collection_mode;</code></pre>
@@ -1948,12 +1974,12 @@ the <code>napi_value</code> in question is of the JavaScript type expected by th
 <p><code>napi_key_own_only</code> limits the collected properties to the given
 object only. <code>napi_key_include_prototypes</code> will include all keys
 of the objects's prototype chain as well.</p>
-<h4>napi_key_filter<span><a class="mark" href="#n_api_napi_key_filter" id="n_api_napi_key_filter">#</a></span></h4>
+<h5>napi_key_filter<span><a class="mark" href="#n_api_napi_key_filter" id="n_api_napi_key_filter">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_key_all_properties = <span class="hljs-number">0</span>,
   napi_key_writable = <span class="hljs-number">1</span>,
   napi_key_enumerable = <span class="hljs-number">1</span> &#x3C;&#x3C; <span class="hljs-number">1</span>,
@@ -1962,20 +1988,20 @@ of the objects's prototype chain as well.</p>
   napi_key_skip_symbols = <span class="hljs-number">1</span> &#x3C;&#x3C; <span class="hljs-number">4</span>
 } napi_key_filter;</code></pre>
 <p>Property filter bits. They can be or'ed to build a composite filter.</p>
-<h4>napi_key_conversion<span><a class="mark" href="#n_api_napi_key_conversion" id="n_api_napi_key_conversion">#</a></span></h4>
+<h5>napi_key_conversion<span><a class="mark" href="#n_api_napi_key_conversion" id="n_api_napi_key_conversion">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_key_keep_numbers,
   napi_key_numbers_to_strings
 } napi_key_conversion;</code></pre>
 <p><code>napi_key_numbers_to_strings</code> will convert integer indices to
 strings. <code>napi_key_keep_numbers</code> will return numbers for integer
 indices.</p>
-<h4>napi_valuetype<span><a class="mark" href="#n_api_napi_valuetype" id="n_api_napi_valuetype">#</a></span></h4>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<h5>napi_valuetype<span><a class="mark" href="#n_api_napi_valuetype" id="n_api_napi_valuetype">#</a></span></h5>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   <span class="hljs-comment">// ES6 types (corresponds to typeof)</span>
   napi_undefined,
   napi_null,
@@ -1994,8 +2020,8 @@ In addition to types in that section, <code>napi_valuetype</code> can also repre
 <code>Function</code>s and <code>Object</code>s with external data.</p>
 <p>A JavaScript value of type <code>napi_external</code> appears in JavaScript as a plain
 object such that no properties can be set on it, and no prototype.</p>
-<h4>napi_typedarray_type<span><a class="mark" href="#n_api_napi_typedarray_type" id="n_api_napi_typedarray_type">#</a></span></h4>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<h5>napi_typedarray_type<span><a class="mark" href="#n_api_napi_typedarray_type" id="n_api_napi_typedarray_type">#</a></span></h5>
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_int8_array,
   napi_uint8_array,
   napi_uint8_clamped_array,
@@ -2011,36 +2037,36 @@ object such that no properties can be set on it, and no prototype.</p>
 <p>This represents the underlying binary scalar datatype of the <code>TypedArray</code>.
 Elements of this enum correspond to
 <a href="https://tc39.github.io/ecma262/#sec-typedarray-objects">Section 22.2</a> of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>.</p>
-<h3>Object creation functions<span><a class="mark" href="#n_api_object_creation_functions" id="n_api_object_creation_functions">#</a></span></h3>
-<h4>napi_create_array<span><a class="mark" href="#n_api_napi_create_array" id="n_api_napi_create_array">#</a></span></h4>
+<h4>Object creation functions<span><a class="mark" href="#n_api_object_creation_functions" id="n_api_object_creation_functions">#</a></span></h4>
+<h5>napi_create_array<span><a class="mark" href="#n_api_napi_create_array" id="n_api_napi_create_array">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_array</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_array</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns an N-API value corresponding to a JavaScript <code>Array</code> type.
+<p>This API returns a Node-API value corresponding to a JavaScript <code>Array</code> type.
 JavaScript arrays are described in
 <a href="https://tc39.github.io/ecma262/#sec-array-objects">Section 22.1</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_array_with_length<span><a class="mark" href="#n_api_napi_create_array_with_length" id="n_api_napi_create_array_with_length">#</a></span></h4>
+<h5>napi_create_array_with_length<span><a class="mark" href="#n_api_napi_create_array_with_length" id="n_api_napi_create_array_with_length">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_array_with_length</span><span class="hljs-params">(napi_env env,
-                                          <span class="hljs-keyword">size_t</span> length,
-                                          napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_array_with_length</span><span class="hljs-params">(napi_env env,
+                                          <span class="hljs-type">size_t</span> length,
+                                          napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] length</code>: The initial length of the <code>Array</code>.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns an N-API value corresponding to a JavaScript <code>Array</code> type.
+<p>This API returns a Node-API value corresponding to a JavaScript <code>Array</code> type.
 The <code>Array</code>'s length property is set to the passed-in length parameter.
 However, the underlying buffer is not guaranteed to be pre-allocated by the VM
 when the array is created. That behavior is left to the underlying VM
@@ -2049,15 +2075,15 @@ directly read and/or written via C, consider using
 <a href="#n_api_napi_create_external_arraybuffer"><code>napi_create_external_arraybuffer</code></a>.</p>
 <p>JavaScript arrays are described in
 <a href="https://tc39.github.io/ecma262/#sec-array-objects">Section 22.1</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_arraybuffer<span><a class="mark" href="#n_api_napi_create_arraybuffer" id="n_api_napi_create_arraybuffer">#</a></span></h4>
+<h5>napi_create_arraybuffer<span><a class="mark" href="#n_api_napi_create_arraybuffer" id="n_api_napi_create_arraybuffer">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_arraybuffer</span><span class="hljs-params">(napi_env env,
-                                    <span class="hljs-keyword">size_t</span> byte_length,
-                                    <span class="hljs-keyword">void</span>** data,
-                                    napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_arraybuffer</span><span class="hljs-params">(napi_env env,
+                                    <span class="hljs-type">size_t</span> byte_length,
+                                    <span class="hljs-type">void</span>** data,
+                                    napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] length</code>: The length in bytes of the array buffer to create.</li>
@@ -2065,7 +2091,7 @@ directly read and/or written via C, consider using
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns an N-API value corresponding to a JavaScript <code>ArrayBuffer</code>.
+<p>This API returns a Node-API value corresponding to a JavaScript <code>ArrayBuffer</code>.
 <code>ArrayBuffer</code>s are used to represent fixed-length binary data buffers. They are
 normally used as a backing-buffer for <code>TypedArray</code> objects.
 The <code>ArrayBuffer</code> allocated will have an underlying byte buffer whose size is
@@ -2076,15 +2102,15 @@ written to directly from native code. To write to this buffer from JavaScript,
 a typed array or <code>DataView</code> object would need to be created.</p>
 <p>JavaScript <code>ArrayBuffer</code> objects are described in
 <a href="https://tc39.github.io/ecma262/#sec-arraybuffer-objects">Section 24.1</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_buffer<span><a class="mark" href="#n_api_napi_create_buffer" id="n_api_napi_create_buffer">#</a></span></h4>
+<h5>napi_create_buffer<span><a class="mark" href="#n_api_napi_create_buffer" id="n_api_napi_create_buffer">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_buffer</span><span class="hljs-params">(napi_env env,
-                               <span class="hljs-keyword">size_t</span> size,
-                               <span class="hljs-keyword">void</span>** data,
-                               napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_buffer</span><span class="hljs-params">(napi_env env,
+                               <span class="hljs-type">size_t</span> size,
+                               <span class="hljs-type">void</span>** data,
+                               napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] size</code>: Size in bytes of the underlying buffer.</li>
@@ -2094,16 +2120,16 @@ a typed array or <code>DataView</code> object would need to be created.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API allocates a <code>node::Buffer</code> object. While this is still a
 fully-supported data structure, in most cases using a <code>TypedArray</code> will suffice.</p>
-<h4>napi_create_buffer_copy<span><a class="mark" href="#n_api_napi_create_buffer_copy" id="n_api_napi_create_buffer_copy">#</a></span></h4>
+<h5>napi_create_buffer_copy<span><a class="mark" href="#n_api_napi_create_buffer_copy" id="n_api_napi_create_buffer_copy">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_buffer_copy</span><span class="hljs-params">(napi_env env,
-                                    <span class="hljs-keyword">size_t</span> length,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">void</span>* data,
-                                    <span class="hljs-keyword">void</span>** result_data,
-                                    napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_buffer_copy</span><span class="hljs-params">(napi_env env,
+                                    <span class="hljs-type">size_t</span> length,
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">void</span>* data,
+                                    <span class="hljs-type">void</span>** result_data,
+                                    napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] size</code>: Size in bytes of the input buffer (should be the same as the size
@@ -2116,14 +2142,14 @@ of the new buffer).</li>
 <p>This API allocates a <code>node::Buffer</code> object and initializes it with data copied
 from the passed-in buffer. While this is still a fully-supported data
 structure, in most cases using a <code>TypedArray</code> will suffice.</p>
-<h4>napi_create_date<span><a class="mark" href="#n_api_napi_create_date" id="n_api_napi_create_date">#</a></span></h4>
+<h5>napi_create_date<span><a class="mark" href="#n_api_napi_create_date" id="n_api_napi_create_date">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v11.11.0</span>
+<span>Added in: v11.11.0, v10.17.0</span>
 <span>N-API version: 5</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_date</span><span class="hljs-params">(napi_env env,
-                             <span class="hljs-keyword">double</span> time,
-                             napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_date</span><span class="hljs-params">(napi_env env,
+                             <span class="hljs-type">double</span> time,
+                             napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] time</code>: ECMAScript time value in milliseconds since 01 January, 1970 UTC.</li>
@@ -2135,16 +2161,16 @@ ECMAScript aligns with POSIX time specification.</p>
 <p>This API allocates a JavaScript <code>Date</code> object.</p>
 <p>JavaScript <code>Date</code> objects are described in
 <a href="https://tc39.github.io/ecma262/#sec-date-objects">Section 20.3</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_external<span><a class="mark" href="#n_api_napi_create_external" id="n_api_napi_create_external">#</a></span></h4>
+<h5>napi_create_external<span><a class="mark" href="#n_api_napi_create_external" id="n_api_napi_create_external">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_external</span><span class="hljs-params">(napi_env env,
-                                 <span class="hljs-keyword">void</span>* data,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_external</span><span class="hljs-params">(napi_env env,
+                                 <span class="hljs-type">void</span>* data,
                                  napi_finalize finalize_cb,
-                                 <span class="hljs-keyword">void</span>* finalize_hint,
-                                 napi_value* result)</span></span></code></pre>
+                                 <span class="hljs-type">void</span>* finalize_hint,
+                                 napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] data</code>: Raw pointer to the external data.</li>
@@ -2169,18 +2195,18 @@ object just created is ready for garbage collection. It is similar to
 <p>The created value is not an object, and therefore does not support additional
 properties. It is considered a distinct value type: calling <code>napi_typeof()</code> with
 an external value yields <code>napi_external</code>.</p>
-<h4>napi_create_external_arraybuffer<span><a class="mark" href="#n_api_napi_create_external_arraybuffer" id="n_api_napi_create_external_arraybuffer">#</a></span></h4>
+<h5>napi_create_external_arraybuffer<span><a class="mark" href="#n_api_napi_create_external_arraybuffer" id="n_api_napi_create_external_arraybuffer">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status
-<span class="hljs-title">napi_create_external_arraybuffer</span><span class="hljs-params">(napi_env env,
-                                 <span class="hljs-keyword">void</span>* external_data,
-                                 <span class="hljs-keyword">size_t</span> byte_length,
+<pre><code class="language-c">napi_status
+<span class="hljs-title function_">napi_create_external_arraybuffer</span><span class="hljs-params">(napi_env env,
+                                 <span class="hljs-type">void</span>* external_data,
+                                 <span class="hljs-type">size_t</span> byte_length,
                                  napi_finalize finalize_cb,
-                                 <span class="hljs-keyword">void</span>* finalize_hint,
-                                 napi_value* result)</span></span></code></pre>
+                                 <span class="hljs-type">void</span>* finalize_hint,
+                                 napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] external_data</code>: Pointer to the underlying byte buffer of the
@@ -2193,7 +2219,7 @@ collection.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns an N-API value corresponding to a JavaScript <code>ArrayBuffer</code>.
+<p>This API returns a Node-API value corresponding to a JavaScript <code>ArrayBuffer</code>.
 The underlying byte buffer of the <code>ArrayBuffer</code> is externally allocated and
 managed. The caller must ensure that the byte buffer remains valid until the
 finalize callback is called.</p>
@@ -2207,17 +2233,17 @@ object just created is ready for garbage collection. It is similar to
 </ul>
 <p>JavaScript <code>ArrayBuffer</code>s are described in
 <a href="https://tc39.github.io/ecma262/#sec-arraybuffer-objects">Section 24.1</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_external_buffer<span><a class="mark" href="#n_api_napi_create_external_buffer" id="n_api_napi_create_external_buffer">#</a></span></h4>
+<h5>napi_create_external_buffer<span><a class="mark" href="#n_api_napi_create_external_buffer" id="n_api_napi_create_external_buffer">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_external_buffer</span><span class="hljs-params">(napi_env env,
-                                        <span class="hljs-keyword">size_t</span> length,
-                                        <span class="hljs-keyword">void</span>* data,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_external_buffer</span><span class="hljs-params">(napi_env env,
+                                        <span class="hljs-type">size_t</span> length,
+                                        <span class="hljs-type">void</span>* data,
                                         napi_finalize finalize_cb,
-                                        <span class="hljs-keyword">void</span>* finalize_hint,
-                                        napi_value* result)</span></span></code></pre>
+                                        <span class="hljs-type">void</span>* finalize_hint,
+                                        napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] length</code>: Size in bytes of the input buffer (should be the same as the
@@ -2242,12 +2268,12 @@ object just created is ready for garbage collection. It is similar to
 <li>the object created by the API can be used with <code>napi_wrap()</code>.</li>
 </ul>
 <p>For Node.js >=4 <code>Buffers</code> are <code>Uint8Array</code>s.</p>
-<h4>napi_create_object<span><a class="mark" href="#n_api_napi_create_object" id="n_api_napi_create_object">#</a></span></h4>
+<h5>napi_create_object<span><a class="mark" href="#n_api_napi_create_object" id="n_api_napi_create_object">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_object</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_object</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Object</code>.</li>
@@ -2257,35 +2283,35 @@ object just created is ready for garbage collection. It is similar to
 It is the equivalent of doing <code>new Object()</code> in JavaScript.</p>
 <p>The JavaScript <code>Object</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-object-type">Section 6.1.7</a> of the
 ECMAScript Language Specification.</p>
-<h4>napi_create_symbol<span><a class="mark" href="#n_api_napi_create_symbol" id="n_api_napi_create_symbol">#</a></span></h4>
+<h5>napi_create_symbol<span><a class="mark" href="#n_api_napi_create_symbol" id="n_api_napi_create_symbol">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_symbol</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_symbol</span><span class="hljs-params">(napi_env env,
                                napi_value description,
-                               napi_value* result)</span></span></code></pre>
+                               napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] description</code>: Optional <code>napi_value</code> which refers to a JavaScript
-<code>String</code> to be set as the description for the symbol.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Symbol</code>.</li>
+<code>string</code> to be set as the description for the symbol.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>symbol</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API creates a JavaScript <code>Symbol</code> object from a UTF8-encoded C string.</p>
-<p>The JavaScript <code>Symbol</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-symbol-objects">Section 19.4</a>
+<p>This API creates a JavaScript <code>symbol</code> value from a UTF8-encoded C string.</p>
+<p>The JavaScript <code>symbol</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-symbol-objects">Section 19.4</a>
 of the ECMAScript Language Specification.</p>
-<h4>napi_create_typedarray<span><a class="mark" href="#n_api_napi_create_typedarray" id="n_api_napi_create_typedarray">#</a></span></h4>
+<h5>napi_create_typedarray<span><a class="mark" href="#n_api_napi_create_typedarray" id="n_api_napi_create_typedarray">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_typedarray</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_typedarray</span><span class="hljs-params">(napi_env env,
                                    napi_typedarray_type type,
-                                   <span class="hljs-keyword">size_t</span> length,
+                                   <span class="hljs-type">size_t</span> length,
                                    napi_value arraybuffer,
-                                   <span class="hljs-keyword">size_t</span> byte_offset,
-                                   napi_value* result)</span></span></code></pre>
+                                   <span class="hljs-type">size_t</span> byte_offset,
+                                   napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] type</code>: Scalar datatype of the elements within the <code>TypedArray</code>.</li>
@@ -2305,16 +2331,16 @@ be &#x3C;= the size in bytes of the array passed in. If not, a <code>RangeError<
 is raised.</p>
 <p>JavaScript <code>TypedArray</code> objects are described in
 <a href="https://tc39.github.io/ecma262/#sec-typedarray-objects">Section 22.2</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_dataview<span><a class="mark" href="#n_api_napi_create_dataview" id="n_api_napi_create_dataview">#</a></span></h4>
+<h5>napi_create_dataview<span><a class="mark" href="#n_api_napi_create_dataview" id="n_api_napi_create_dataview">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_dataview</span><span class="hljs-params">(napi_env env,
-                                 <span class="hljs-keyword">size_t</span> byte_length,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_dataview</span><span class="hljs-params">(napi_env env,
+                                 <span class="hljs-type">size_t</span> byte_length,
                                  napi_value arraybuffer,
-                                 <span class="hljs-keyword">size_t</span> byte_offset,
-                                 napi_value* result)</span></span></code></pre>
+                                 <span class="hljs-type">size_t</span> byte_offset,
+                                 napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] length</code>: Number of elements in the <code>DataView</code>.</li>
@@ -2332,82 +2358,82 @@ size in bytes of the array passed in. If not, a <code>RangeError</code> exceptio
 raised.</p>
 <p>JavaScript <code>DataView</code> objects are described in
 <a href="https://tc39.github.io/ecma262/#sec-dataview-objects">Section 24.3</a> of the ECMAScript Language Specification.</p>
-<h3>Functions to convert from C types to N-API<span><a class="mark" href="#n_api_functions_to_convert_from_c_types_to_n_api" id="n_api_functions_to_convert_from_c_types_to_n_api">#</a></span></h3>
-<h4>napi_create_int32<span><a class="mark" href="#n_api_napi_create_int32" id="n_api_napi_create_int32">#</a></span></h4>
+<h4>Functions to convert from C types to Node-API<span><a class="mark" href="#n_api_functions_to_convert_from_c_types_to_node_api" id="n_api_functions_to_convert_from_c_types_to_node_api">#</a></span></h4>
+<h5>napi_create_int32<span><a class="mark" href="#n_api_napi_create_int32" id="n_api_napi_create_int32">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_int32</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">int32_t</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_int32</span><span class="hljs-params">(napi_env env, <span class="hljs-type">int32_t</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to convert from the C <code>int32_t</code> type to the JavaScript
-<code>Number</code> type.</p>
-<p>The JavaScript <code>Number</code> type is described in
+<code>number</code> type.</p>
+<p>The JavaScript <code>number</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_uint32<span><a class="mark" href="#n_api_napi_create_uint32" id="n_api_napi_create_uint32">#</a></span></h4>
+<h5>napi_create_uint32<span><a class="mark" href="#n_api_napi_create_uint32" id="n_api_napi_create_uint32">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_uint32</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">uint32_t</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_uint32</span><span class="hljs-params">(napi_env env, <span class="hljs-type">uint32_t</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Unsigned integer value to be represented in JavaScript.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to convert from the C <code>uint32_t</code> type to the JavaScript
-<code>Number</code> type.</p>
-<p>The JavaScript <code>Number</code> type is described in
+<code>number</code> type.</p>
+<p>The JavaScript <code>number</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_int64<span><a class="mark" href="#n_api_napi_create_int64" id="n_api_napi_create_int64">#</a></span></h4>
+<h5>napi_create_int64<span><a class="mark" href="#n_api_napi_create_int64" id="n_api_napi_create_int64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_int64</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">int64_t</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_int64</span><span class="hljs-params">(napi_env env, <span class="hljs-type">int64_t</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to convert from the C <code>int64_t</code> type to the JavaScript
-<code>Number</code> type.</p>
-<p>The JavaScript <code>Number</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a>
+<code>number</code> type.</p>
+<p>The JavaScript <code>number</code> type is described in <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a>
 of the ECMAScript Language Specification. Note the complete range of <code>int64_t</code>
 cannot be represented with full precision in JavaScript. Integer values
 outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_safe_integer"><code>Number.MIN_SAFE_INTEGER</code></a> <code>-(2**53 - 1)</code> -
 <a href="https://tc39.github.io/ecma262/#sec-number.max_safe_integer"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose precision.</p>
-<h4>napi_create_double<span><a class="mark" href="#n_api_napi_create_double" id="n_api_napi_create_double">#</a></span></h4>
+<h5>napi_create_double<span><a class="mark" href="#n_api_napi_create_double" id="n_api_napi_create_double">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_double</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">double</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_double</span><span class="hljs-params">(napi_env env, <span class="hljs-type">double</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Double-precision value to be represented in JavaScript.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to convert from the C <code>double</code> type to the JavaScript
-<code>Number</code> type.</p>
-<p>The JavaScript <code>Number</code> type is described in
+<code>number</code> type.</p>
+<p>The JavaScript <code>number</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">Section 6.1.6</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_bigint_int64<span><a class="mark" href="#n_api_napi_create_bigint_int64" id="n_api_napi_create_bigint_int64">#</a></span></h4>
+<h5>napi_create_bigint_int64<span><a class="mark" href="#n_api_napi_create_bigint_int64" id="n_api_napi_create_bigint_int64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_bigint_int64</span><span class="hljs-params">(napi_env env,
-                                     <span class="hljs-keyword">int64_t</span> value,
-                                     napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_bigint_int64</span><span class="hljs-params">(napi_env env,
+                                     <span class="hljs-type">int64_t</span> value,
+                                     napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>
@@ -2415,14 +2441,14 @@ outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_saf
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API converts the C <code>int64_t</code> type to the JavaScript <code>BigInt</code> type.</p>
-<h4>napi_create_bigint_uint64<span><a class="mark" href="#n_api_napi_create_bigint_uint64" id="n_api_napi_create_bigint_uint64">#</a></span></h4>
+<h5>napi_create_bigint_uint64<span><a class="mark" href="#n_api_napi_create_bigint_uint64" id="n_api_napi_create_bigint_uint64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_bigint_uint64</span><span class="hljs-params">(napi_env env,
-                                      <span class="hljs-keyword">uint64_t</span> value,
-                                      napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_bigint_uint64</span><span class="hljs-params">(napi_env env,
+                                      <span class="hljs-type">uint64_t</span> value,
+                                      napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: Unsigned integer value to be represented in JavaScript.</li>
@@ -2430,16 +2456,16 @@ outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_saf
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API converts the C <code>uint64_t</code> type to the JavaScript <code>BigInt</code> type.</p>
-<h4>napi_create_bigint_words<span><a class="mark" href="#n_api_napi_create_bigint_words" id="n_api_napi_create_bigint_words">#</a></span></h4>
+<h5>napi_create_bigint_words<span><a class="mark" href="#n_api_napi_create_bigint_words" id="n_api_napi_create_bigint_words">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_bigint_words</span><span class="hljs-params">(napi_env env,
-                                     <span class="hljs-keyword">int</span> sign_bit,
-                                     <span class="hljs-keyword">size_t</span> word_count,
-                                     <span class="hljs-keyword">const</span> <span class="hljs-keyword">uint64_t</span>* words,
-                                     napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_bigint_words</span><span class="hljs-params">(napi_env env,
+                                     <span class="hljs-type">int</span> sign_bit,
+                                     <span class="hljs-type">size_t</span> word_count,
+                                     <span class="hljs-keyword">const</span> <span class="hljs-type">uint64_t</span>* words,
+                                     napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] sign_bit</code>: Determines if the resulting <code>BigInt</code> will be positive or
@@ -2453,78 +2479,78 @@ negative.</li>
 value.</p>
 <p>The resulting <code>BigInt</code> is calculated as: (–1)<sup><code>sign_bit</code></sup> (<code>words[0]</code>
 × (2<sup>64</sup>)<sup>0</sup> + <code>words[1]</code> × (2<sup>64</sup>)<sup>1</sup> + …)</p>
-<h4>napi_create_string_latin1<span><a class="mark" href="#n_api_napi_create_string_latin1" id="n_api_napi_create_string_latin1">#</a></span></h4>
+<h5>napi_create_string_latin1<span><a class="mark" href="#n_api_napi_create_string_latin1" id="n_api_napi_create_string_latin1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_string_latin1</span><span class="hljs-params">(napi_env env,
-                                      <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* str,
-                                      <span class="hljs-keyword">size_t</span> length,
-                                      napi_value* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_string_latin1</span><span class="hljs-params">(napi_env env,
+                                      <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* str,
+                                      <span class="hljs-type">size_t</span> length,
+                                      napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] str</code>: Character buffer representing an ISO-8859-1-encoded string.</li>
 <li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it
 is null-terminated.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API creates a JavaScript <code>String</code> object from an ISO-8859-1-encoded C
+<p>This API creates a JavaScript <code>string</code> value from an ISO-8859-1-encoded C
 string. The native string is copied.</p>
-<p>The JavaScript <code>String</code> type is described in
+<p>The JavaScript <code>string</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type">Section 6.1.4</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_string_utf16<span><a class="mark" href="#n_api_napi_create_string_utf16" id="n_api_napi_create_string_utf16">#</a></span></h4>
+<h5>napi_create_string_utf16<span><a class="mark" href="#n_api_napi_create_string_utf16" id="n_api_napi_create_string_utf16">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_string_utf16</span><span class="hljs-params">(napi_env env,
-                                     <span class="hljs-keyword">const</span> <span class="hljs-keyword">char16_t</span>* str,
-                                     <span class="hljs-keyword">size_t</span> length,
-                                     napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_string_utf16</span><span class="hljs-params">(napi_env env,
+                                     <span class="hljs-keyword">const</span> <span class="hljs-type">char16_t</span>* str,
+                                     <span class="hljs-type">size_t</span> length,
+                                     napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] str</code>: Character buffer representing a UTF16-LE-encoded string.</li>
 <li><code>[in] length</code>: The length of the string in two-byte code units, or
 <code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API creates a JavaScript <code>String</code> object from a UTF16-LE-encoded C string.
+<p>This API creates a JavaScript <code>string</code> value from a UTF16-LE-encoded C string.
 The native string is copied.</p>
-<p>The JavaScript <code>String</code> type is described in
+<p>The JavaScript <code>string</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type">Section 6.1.4</a> of the ECMAScript Language Specification.</p>
-<h4>napi_create_string_utf8<span><a class="mark" href="#n_api_napi_create_string_utf8" id="n_api_napi_create_string_utf8">#</a></span></h4>
+<h5>napi_create_string_utf8<span><a class="mark" href="#n_api_napi_create_string_utf8" id="n_api_napi_create_string_utf8">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_string_utf8</span><span class="hljs-params">(napi_env env,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* str,
-                                    <span class="hljs-keyword">size_t</span> length,
-                                    napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_string_utf8</span><span class="hljs-params">(napi_env env,
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* str,
+                                    <span class="hljs-type">size_t</span> length,
+                                    napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] str</code>: Character buffer representing a UTF8-encoded string.</li>
 <li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it
 is null-terminated.</li>
-<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>
+<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API creates a JavaScript <code>String</code> object from a UTF8-encoded C string.
+<p>This API creates a JavaScript <code>string</code> value from a UTF8-encoded C string.
 The native string is copied.</p>
-<p>The JavaScript <code>String</code> type is described in
+<p>The JavaScript <code>string</code> type is described in
 <a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type">Section 6.1.4</a> of the ECMAScript Language Specification.</p>
-<h3>Functions to convert from N-API to C types<span><a class="mark" href="#n_api_functions_to_convert_from_n_api_to_c_types" id="n_api_functions_to_convert_from_n_api_to_c_types">#</a></span></h3>
-<h4>napi_get_array_length<span><a class="mark" href="#n_api_napi_get_array_length" id="n_api_napi_get_array_length">#</a></span></h4>
+<h4>Functions to convert from Node-API to C types<span><a class="mark" href="#n_api_functions_to_convert_from_node_api_to_c_types" id="n_api_functions_to_convert_from_node_api_to_c_types">#</a></span></h4>
+<h5>napi_get_array_length<span><a class="mark" href="#n_api_napi_get_array_length" id="n_api_napi_get_array_length">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_array_length</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_array_length</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  <span class="hljs-keyword">uint32_t</span>* result)</span></span></code></pre>
+                                  <span class="hljs-type">uint32_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing the JavaScript <code>Array</code> whose length is
@@ -2535,15 +2561,15 @@ being queried.</li>
 <p>This API returns the length of an array.</p>
 <p><code>Array</code> length is described in <a href="https://tc39.github.io/ecma262/#sec-properties-of-array-instances-length">Section 22.1.4.1</a> of the ECMAScript Language
 Specification.</p>
-<h4>napi_get_arraybuffer_info<span><a class="mark" href="#n_api_napi_get_arraybuffer_info" id="n_api_napi_get_arraybuffer_info">#</a></span></h4>
+<h5>napi_get_arraybuffer_info<span><a class="mark" href="#n_api_napi_get_arraybuffer_info" id="n_api_napi_get_arraybuffer_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_arraybuffer_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_arraybuffer_info</span><span class="hljs-params">(napi_env env,
                                       napi_value arraybuffer,
-                                      <span class="hljs-keyword">void</span>** data,
-                                      <span class="hljs-keyword">size_t</span>* byte_length)</span></span></code></pre>
+                                      <span class="hljs-type">void</span>** data,
+                                      <span class="hljs-type">size_t</span>* byte_length)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] arraybuffer</code>: <code>napi_value</code> representing the <code>ArrayBuffer</code> being queried.</li>
@@ -2561,15 +2587,15 @@ possible safe way to use this API is in conjunction with
 lifetime of the <code>ArrayBuffer</code>. It's also safe to use the returned data buffer
 within the same callback as long as there are no calls to other APIs that might
 trigger a GC.</p>
-<h4>napi_get_buffer_info<span><a class="mark" href="#n_api_napi_get_buffer_info" id="n_api_napi_get_buffer_info">#</a></span></h4>
+<h5>napi_get_buffer_info<span><a class="mark" href="#n_api_napi_get_buffer_info" id="n_api_napi_get_buffer_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_buffer_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_buffer_info</span><span class="hljs-params">(napi_env env,
                                  napi_value value,
-                                 <span class="hljs-keyword">void</span>** data,
-                                 <span class="hljs-keyword">size_t</span>* length)</span></span></code></pre>
+                                 <span class="hljs-type">void</span>** data,
+                                 <span class="hljs-type">size_t</span>* length)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing the <code>node::Buffer</code> being queried.</li>
@@ -2582,14 +2608,14 @@ If length is <code>0</code>, this may be <code>NULL</code> or any other pointer
 and it's length.</p>
 <p><em>Warning</em>: Use caution while using this API since the underlying data buffer's
 lifetime is not guaranteed if it's managed by the VM.</p>
-<h4>napi_get_prototype<span><a class="mark" href="#n_api_napi_get_prototype" id="n_api_napi_get_prototype">#</a></span></h4>
+<h5>napi_get_prototype<span><a class="mark" href="#n_api_napi_get_prototype" id="n_api_napi_get_prototype">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_prototype</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_prototype</span><span class="hljs-params">(napi_env env,
                                napi_value object,
-                               napi_value* result)</span></span></code></pre>
+                               napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] object</code>: <code>napi_value</code> representing JavaScript <code>Object</code> whose prototype
@@ -2598,18 +2624,18 @@ not the same as the function's <code>prototype</code> property).</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing prototype of the given object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<h4>napi_get_typedarray_info<span><a class="mark" href="#n_api_napi_get_typedarray_info" id="n_api_napi_get_typedarray_info">#</a></span></h4>
+<h5>napi_get_typedarray_info<span><a class="mark" href="#n_api_napi_get_typedarray_info" id="n_api_napi_get_typedarray_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_typedarray_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_typedarray_info</span><span class="hljs-params">(napi_env env,
                                      napi_value typedarray,
                                      napi_typedarray_type* type,
-                                     <span class="hljs-keyword">size_t</span>* length,
-                                     <span class="hljs-keyword">void</span>** data,
+                                     <span class="hljs-type">size_t</span>* length,
+                                     <span class="hljs-type">void</span>** data,
                                      napi_value* arraybuffer,
-                                     <span class="hljs-keyword">size_t</span>* byte_offset)</span></span></code></pre>
+                                     <span class="hljs-type">size_t</span>* byte_offset)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] typedarray</code>: <code>napi_value</code> representing the <code>TypedArray</code> whose
@@ -2631,22 +2657,22 @@ in the array. Therefore, the first byte of the native array would be at
 <p>This API returns various properties of a typed array.</p>
 <p><em>Warning</em>: Use caution while using this API since the underlying data buffer
 is managed by the VM.</p>
-<h4>napi_get_dataview_info<span><a class="mark" href="#n_api_napi_get_dataview_info" id="n_api_napi_get_dataview_info">#</a></span></h4>
+<h5>napi_get_dataview_info<span><a class="mark" href="#n_api_napi_get_dataview_info" id="n_api_napi_get_dataview_info">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_dataview_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_dataview_info</span><span class="hljs-params">(napi_env env,
                                    napi_value dataview,
-                                   <span class="hljs-keyword">size_t</span>* byte_length,
-                                   <span class="hljs-keyword">void</span>** data,
+                                   <span class="hljs-type">size_t</span>* byte_length,
+                                   <span class="hljs-type">void</span>** data,
                                    napi_value* arraybuffer,
-                                   <span class="hljs-keyword">size_t</span>* byte_offset)</span></span></code></pre>
+                                   <span class="hljs-type">size_t</span>* byte_offset)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] dataview</code>: <code>napi_value</code> representing the <code>DataView</code> whose
 properties to query.</li>
-<li><code>[out] byte_length</code>: <code>Number</code> of bytes in the <code>DataView</code>.</li>
+<li><code>[out] byte_length</code>: Number of bytes in the <code>DataView</code>.</li>
 <li><code>[out] data</code>: The data buffer underlying the <code>DataView</code>.
 If byte_length is <code>0</code>, this may be <code>NULL</code> or any other pointer value.</li>
 <li><code>[out] arraybuffer</code>: <code>ArrayBuffer</code> underlying the <code>DataView</code>.</li>
@@ -2655,14 +2681,14 @@ to start projecting the <code>DataView</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns various properties of a <code>DataView</code>.</p>
-<h4>napi_get_date_value<span><a class="mark" href="#n_api_napi_get_date_value" id="n_api_napi_get_date_value">#</a></span></h4>
+<h5>napi_get_date_value<span><a class="mark" href="#n_api_napi_get_date_value" id="n_api_napi_get_date_value">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v11.11.0</span>
+<span>Added in: v11.11.0, v10.17.0</span>
 <span>N-API version: 5</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_date_value</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_date_value</span><span class="hljs-params">(napi_env env,
                                 napi_value value,
-                                <span class="hljs-keyword">double</span>* result)</span></span></code></pre>
+                                <span class="hljs-type">double</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing a JavaScript <code>Date</code>.</li>
@@ -2675,12 +2701,12 @@ ECMAScript aligns with POSIX time specification.</p>
 in it returns <code>napi_date_expected</code>.</p>
 <p>This API returns the C double primitive of time value for the given JavaScript
 <code>Date</code>.</p>
-<h4>napi_get_value_bool<span><a class="mark" href="#n_api_napi_get_value_bool" id="n_api_napi_get_value_bool">#</a></span></h4>
+<h5>napi_get_value_bool<span><a class="mark" href="#n_api_napi_get_value_bool" id="n_api_napi_get_value_bool">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_bool</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_bool</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Boolean</code>.</li>
@@ -2691,33 +2717,33 @@ in it returns <code>napi_date_expected</code>.</p>
 passed in it returns <code>napi_boolean_expected</code>.</p>
 <p>This API returns the C boolean primitive equivalent of the given JavaScript
 <code>Boolean</code>.</p>
-<h4>napi_get_value_double<span><a class="mark" href="#n_api_napi_get_value_double" id="n_api_napi_get_value_double">#</a></span></h4>
+<h5>napi_get_value_double<span><a class="mark" href="#n_api_napi_get_value_double" id="n_api_napi_get_value_double">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_double</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_double</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  <span class="hljs-keyword">double</span>* result)</span></span></code></pre>
+                                  <span class="hljs-type">double</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>
+<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>
 <li><code>[out] result</code>: C double primitive equivalent of the given JavaScript
-<code>Number</code>.</li>
+<code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code> is passed
 in it returns <code>napi_number_expected</code>.</p>
 <p>This API returns the C double primitive equivalent of the given JavaScript
-<code>Number</code>.</p>
-<h4>napi_get_value_bigint_int64<span><a class="mark" href="#n_api_napi_get_value_bigint_int64" id="n_api_napi_get_value_bigint_int64">#</a></span></h4>
+<code>number</code>.</p>
+<h5>napi_get_value_bigint_int64<span><a class="mark" href="#n_api_napi_get_value_bigint_int64" id="n_api_napi_get_value_bigint_int64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_bigint_int64</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_bigint_int64</span><span class="hljs-params">(napi_env env,
                                         napi_value value,
-                                        <span class="hljs-keyword">int64_t</span>* result,
-                                        <span class="hljs-keyword">bool</span>* lossless)</span></span>;</code></pre>
+                                        <span class="hljs-type">int64_t</span>* result,
+                                        <span class="hljs-type">bool</span>* lossless)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>BigInt</code>.</li>
@@ -2730,15 +2756,15 @@ losslessly.</li>
 returns <code>napi_bigint_expected</code>.</p>
 <p>This API returns the C <code>int64_t</code> primitive equivalent of the given JavaScript
 <code>BigInt</code>. If needed it will truncate the value, setting <code>lossless</code> to <code>false</code>.</p>
-<h4>napi_get_value_bigint_uint64<span><a class="mark" href="#n_api_napi_get_value_bigint_uint64" id="n_api_napi_get_value_bigint_uint64">#</a></span></h4>
+<h5>napi_get_value_bigint_uint64<span><a class="mark" href="#n_api_napi_get_value_bigint_uint64" id="n_api_napi_get_value_bigint_uint64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_bigint_uint64</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_bigint_uint64</span><span class="hljs-params">(napi_env env,
                                         napi_value value,
-                                        <span class="hljs-keyword">uint64_t</span>* result,
-                                        <span class="hljs-keyword">bool</span>* lossless)</span></span>;</code></pre>
+                                        <span class="hljs-type">uint64_t</span>* result,
+                                        <span class="hljs-type">bool</span>* lossless)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>BigInt</code>.</li>
@@ -2751,16 +2777,16 @@ losslessly.</li>
 returns <code>napi_bigint_expected</code>.</p>
 <p>This API returns the C <code>uint64_t</code> primitive equivalent of the given JavaScript
 <code>BigInt</code>. If needed it will truncate the value, setting <code>lossless</code> to <code>false</code>.</p>
-<h4>napi_get_value_bigint_words<span><a class="mark" href="#n_api_napi_get_value_bigint_words" id="n_api_napi_get_value_bigint_words">#</a></span></h4>
+<h5>napi_get_value_bigint_words<span><a class="mark" href="#n_api_napi_get_value_bigint_words" id="n_api_napi_get_value_bigint_words">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 <span>N-API version: 6</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_bigint_words</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_bigint_words</span><span class="hljs-params">(napi_env env,
                                         napi_value value,
-                                        <span class="hljs-keyword">int</span>* sign_bit,
-                                        <span class="hljs-keyword">size_t</span>* word_count,
-                                        <span class="hljs-keyword">uint64_t</span>* words)</span></span>;</code></pre>
+                                        <span class="hljs-type">int</span>* sign_bit,
+                                        <span class="hljs-type">size_t</span>* word_count,
+                                        <span class="hljs-type">uint64_t</span>* words)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>BigInt</code>.</li>
@@ -2775,14 +2801,14 @@ would be needed to store this <code>BigInt</code>.</li>
 <p>This API converts a single <code>BigInt</code> value into a sign bit, 64-bit little-endian
 array, and the number of elements in the array. <code>sign_bit</code> and <code>words</code> may be
 both set to <code>NULL</code>, in order to get only <code>word_count</code>.</p>
-<h4>napi_get_value_external<span><a class="mark" href="#n_api_napi_get_value_external" id="n_api_napi_get_value_external">#</a></span></h4>
+<h5>napi_get_value_external<span><a class="mark" href="#n_api_napi_get_value_external" id="n_api_napi_get_value_external">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_external</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_external</span><span class="hljs-params">(napi_env env,
                                     napi_value value,
-                                    <span class="hljs-keyword">void</span>** result)</span></span></code></pre>
+                                    <span class="hljs-type">void</span>** result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript external value.</li>
@@ -2792,133 +2818,136 @@ both set to <code>NULL</code>, in order to get only <code>word_count</code>.</p>
 passed in it returns <code>napi_invalid_arg</code>.</p>
 <p>This API retrieves the external data pointer that was previously passed to
 <code>napi_create_external()</code>.</p>
-<h4>napi_get_value_int32<span><a class="mark" href="#n_api_napi_get_value_int32" id="n_api_napi_get_value_int32">#</a></span></h4>
+<h5>napi_get_value_int32<span><a class="mark" href="#n_api_napi_get_value_int32" id="n_api_napi_get_value_int32">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_int32</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_int32</span><span class="hljs-params">(napi_env env,
                                  napi_value value,
-                                 <span class="hljs-keyword">int32_t</span>* result)</span></span></code></pre>
+                                 <span class="hljs-type">int32_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>
+<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>
 <li><code>[out] result</code>: C <code>int32</code> primitive equivalent of the given JavaScript
-<code>Number</code>.</li>
+<code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>
 is passed in <code>napi_number_expected</code>.</p>
 <p>This API returns the C <code>int32</code> primitive equivalent
-of the given JavaScript <code>Number</code>.</p>
+of the given JavaScript <code>number</code>.</p>
 <p>If the number exceeds the range of the 32 bit integer, then the result is
 truncated to the equivalent of the bottom 32 bits. This can result in a large
 positive number becoming a negative number if the value is > 2<sup>31</sup> - 1.</p>
 <p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the
 result to zero.</p>
-<h4>napi_get_value_int64<span><a class="mark" href="#n_api_napi_get_value_int64" id="n_api_napi_get_value_int64">#</a></span></h4>
+<h5>napi_get_value_int64<span><a class="mark" href="#n_api_napi_get_value_int64" id="n_api_napi_get_value_int64">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_int64</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_int64</span><span class="hljs-params">(napi_env env,
                                  napi_value value,
-                                 <span class="hljs-keyword">int64_t</span>* result)</span></span></code></pre>
+                                 <span class="hljs-type">int64_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>
+<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>
 <li><code>[out] result</code>: C <code>int64</code> primitive equivalent of the given JavaScript
-<code>Number</code>.</li>
+<code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>
 is passed in it returns <code>napi_number_expected</code>.</p>
 <p>This API returns the C <code>int64</code> primitive equivalent of the given JavaScript
-<code>Number</code>.</p>
-<p><code>Number</code> values outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_safe_integer"><code>Number.MIN_SAFE_INTEGER</code></a>
+<code>number</code>.</p>
+<p><code>number</code> values outside the range of <a href="https://tc39.github.io/ecma262/#sec-number.min_safe_integer"><code>Number.MIN_SAFE_INTEGER</code></a>
 <code>-(2**53 - 1)</code> - <a href="https://tc39.github.io/ecma262/#sec-number.max_safe_integer"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose
 precision.</p>
 <p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the
 result to zero.</p>
-<h4>napi_get_value_string_latin1<span><a class="mark" href="#n_api_napi_get_value_string_latin1" id="n_api_napi_get_value_string_latin1">#</a></span></h4>
+<h5>napi_get_value_string_latin1<span><a class="mark" href="#n_api_napi_get_value_string_latin1" id="n_api_napi_get_value_string_latin1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_string_latin1</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_string_latin1</span><span class="hljs-params">(napi_env env,
                                          napi_value value,
-                                         <span class="hljs-keyword">char</span>* buf,
-                                         <span class="hljs-keyword">size_t</span> bufsize,
-                                         <span class="hljs-keyword">size_t</span>* result)</span></span></code></pre>
+                                         <span class="hljs-type">char</span>* buf,
+                                         <span class="hljs-type">size_t</span> bufsize,
+                                         <span class="hljs-type">size_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>
 <li><code>[in] buf</code>: Buffer to write the ISO-8859-1-encoded string into. If <code>NULL</code> is
-passed in, the length of the string (in bytes) is returned.</li>
+passed in, the length of the string in bytes and excluding the null terminator
+is returned in <code>result</code>.</li>
 <li><code>[in] bufsize</code>: Size of the destination buffer. When this value is
-insufficient, the returned string will be truncated.</li>
+insufficient, the returned string is truncated and null-terminated.</li>
 <li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null
 terminator.</li>
 </ul>
-<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>
+<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>
 is passed in it returns <code>napi_string_expected</code>.</p>
 <p>This API returns the ISO-8859-1-encoded string corresponding the value passed
 in.</p>
-<h4>napi_get_value_string_utf8<span><a class="mark" href="#n_api_napi_get_value_string_utf8" id="n_api_napi_get_value_string_utf8">#</a></span></h4>
+<h5>napi_get_value_string_utf8<span><a class="mark" href="#n_api_napi_get_value_string_utf8" id="n_api_napi_get_value_string_utf8">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_string_utf8</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_string_utf8</span><span class="hljs-params">(napi_env env,
                                        napi_value value,
-                                       <span class="hljs-keyword">char</span>* buf,
-                                       <span class="hljs-keyword">size_t</span> bufsize,
-                                       <span class="hljs-keyword">size_t</span>* result)</span></span></code></pre>
+                                       <span class="hljs-type">char</span>* buf,
+                                       <span class="hljs-type">size_t</span> bufsize,
+                                       <span class="hljs-type">size_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>
 <li><code>[in] buf</code>: Buffer to write the UTF8-encoded string into. If <code>NULL</code> is passed
-in, the length of the string (in bytes) is returned.</li>
+in, the length of the string in bytes and excluding the null terminator is
+returned in <code>result</code>.</li>
 <li><code>[in] bufsize</code>: Size of the destination buffer. When this value is
-insufficient, the returned string will be truncated.</li>
+insufficient, the returned string is truncated and null-terminated.</li>
 <li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null
 terminator.</li>
 </ul>
-<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>
+<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>
 is passed in it returns <code>napi_string_expected</code>.</p>
 <p>This API returns the UTF8-encoded string corresponding the value passed in.</p>
-<h4>napi_get_value_string_utf16<span><a class="mark" href="#n_api_napi_get_value_string_utf16" id="n_api_napi_get_value_string_utf16">#</a></span></h4>
+<h5>napi_get_value_string_utf16<span><a class="mark" href="#n_api_napi_get_value_string_utf16" id="n_api_napi_get_value_string_utf16">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_string_utf16</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_string_utf16</span><span class="hljs-params">(napi_env env,
                                         napi_value value,
-                                        <span class="hljs-keyword">char16_t</span>* buf,
-                                        <span class="hljs-keyword">size_t</span> bufsize,
-                                        <span class="hljs-keyword">size_t</span>* result)</span></span></code></pre>
+                                        <span class="hljs-type">char16_t</span>* buf,
+                                        <span class="hljs-type">size_t</span> bufsize,
+                                        <span class="hljs-type">size_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>
 <li><code>[in] buf</code>: Buffer to write the UTF16-LE-encoded string into. If <code>NULL</code> is
-passed in, the length of the string (in 2-byte code units) is returned.</li>
+passed in, the length of the string in 2-byte code units and excluding the
+null terminator is returned.</li>
 <li><code>[in] bufsize</code>: Size of the destination buffer. When this value is
-insufficient, the returned string will be truncated.</li>
+insufficient, the returned string is truncated and null-terminated.</li>
 <li><code>[out] result</code>: Number of 2-byte code units copied into the buffer, excluding
 the null terminator.</li>
 </ul>
-<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>
+<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>
 is passed in it returns <code>napi_string_expected</code>.</p>
 <p>This API returns the UTF16-encoded string corresponding the value passed in.</p>
-<h4>napi_get_value_uint32<span><a class="mark" href="#n_api_napi_get_value_uint32" id="n_api_napi_get_value_uint32">#</a></span></h4>
+<h5>napi_get_value_uint32<span><a class="mark" href="#n_api_napi_get_value_uint32" id="n_api_napi_get_value_uint32">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_value_uint32</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_value_uint32</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  <span class="hljs-keyword">uint32_t</span>* result)</span></span></code></pre>
+                                  <span class="hljs-type">uint32_t</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>
+<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>
 <li><code>[out] result</code>: C primitive equivalent of the given <code>napi_value</code> as a
 <code>uint32_t</code>.</li>
 </ul>
@@ -2926,13 +2955,13 @@ is passed in it returns <code>napi_string_expected</code>.</p>
 is passed in it returns <code>napi_number_expected</code>.</p>
 <p>This API returns the C primitive equivalent of the given <code>napi_value</code> as a
 <code>uint32_t</code>.</p>
-<h3>Functions to get global instances<span><a class="mark" href="#n_api_functions_to_get_global_instances" id="n_api_functions_to_get_global_instances">#</a></span></h3>
-<h4>napi_get_boolean<span><a class="mark" href="#n_api_napi_get_boolean" id="n_api_napi_get_boolean">#</a></span></h4>
+<h4>Functions to get global instances<span><a class="mark" href="#n_api_functions_to_get_global_instances" id="n_api_functions_to_get_global_instances">#</a></span></h4>
+<h5>napi_get_boolean<span><a class="mark" href="#n_api_napi_get_boolean" id="n_api_napi_get_boolean">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_boolean</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">bool</span> value, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_boolean</span><span class="hljs-params">(napi_env env, <span class="hljs-type">bool</span> value, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The value of the boolean to retrieve.</li>
@@ -2942,61 +2971,61 @@ retrieve.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API is used to return the JavaScript singleton object that is used to
 represent the given boolean value.</p>
-<h4>napi_get_global<span><a class="mark" href="#n_api_napi_get_global" id="n_api_napi_get_global">#</a></span></h4>
+<h5>napi_get_global<span><a class="mark" href="#n_api_napi_get_global" id="n_api_napi_get_global">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_global</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_global</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing JavaScript <code>global</code> object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns the <code>global</code> object.</p>
-<h4>napi_get_null<span><a class="mark" href="#n_api_napi_get_null" id="n_api_napi_get_null">#</a></span></h4>
+<h5>napi_get_null<span><a class="mark" href="#n_api_napi_get_null" id="n_api_napi_get_null">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_null</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_null</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing JavaScript <code>null</code> object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns the <code>null</code> object.</p>
-<h4>napi_get_undefined<span><a class="mark" href="#n_api_napi_get_undefined" id="n_api_napi_get_undefined">#</a></span></h4>
+<h5>napi_get_undefined<span><a class="mark" href="#n_api_napi_get_undefined" id="n_api_napi_get_undefined">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_undefined</span><span class="hljs-params">(napi_env env, napi_value* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_undefined</span><span class="hljs-params">(napi_env env, napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] result</code>: <code>napi_value</code> representing JavaScript Undefined value.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns the Undefined object.</p>
-<h2>Working with JavaScript values and abstract operations<span><a class="mark" href="#n_api_working_with_javascript_values_and_abstract_operations" id="n_api_working_with_javascript_values_and_abstract_operations">#</a></span></h2>
-<p>N-API exposes a set of APIs to perform some abstract operations on JavaScript
+</section><section><h3>Working with JavaScript values and abstract operations<span><a class="mark" href="#n_api_working_with_javascript_values_and_abstract_operations" id="n_api_working_with_javascript_values_and_abstract_operations">#</a></span></h3>
+<p>Node-API exposes a set of APIs to perform some abstract operations on JavaScript
 values. Some of these operations are documented under <a href="https://tc39.github.io/ecma262/#sec-abstract-operations">Section 7</a>
 of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>.</p>
 <p>These APIs support doing one of the following:</p>
 <ol>
-<li>Coerce JavaScript values to specific JavaScript types (such as <code>Number</code> or
-<code>String</code>).</li>
+<li>Coerce JavaScript values to specific JavaScript types (such as <code>number</code> or
+<code>string</code>).</li>
 <li>Check the type of a JavaScript value.</li>
 <li>Check for equality between two JavaScript values.</li>
 </ol>
-<h3>napi_coerce_to_bool<span><a class="mark" href="#n_api_napi_coerce_to_bool" id="n_api_napi_coerce_to_bool">#</a></span></h3>
+<h4>napi_coerce_to_bool<span><a class="mark" href="#n_api_napi_coerce_to_bool" id="n_api_napi_coerce_to_bool">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_coerce_to_bool</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_coerce_to_bool</span><span class="hljs-params">(napi_env env,
                                 napi_value value,
-                                napi_value* result)</span></span></code></pre>
+                                napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to coerce.</li>
@@ -3006,31 +3035,31 @@ of the <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specificati
 <p>This API implements the abstract operation <code>ToBoolean()</code> as defined in
 <a href="https://tc39.github.io/ecma262/#sec-toboolean">Section 7.1.2</a> of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>
-<h3>napi_coerce_to_number<span><a class="mark" href="#n_api_napi_coerce_to_number" id="n_api_napi_coerce_to_number">#</a></span></h3>
+<h4>napi_coerce_to_number<span><a class="mark" href="#n_api_napi_coerce_to_number" id="n_api_napi_coerce_to_number">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_coerce_to_number</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_coerce_to_number</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  napi_value* result)</span></span></code></pre>
+                                  napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to coerce.</li>
-<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>Number</code>.</li>
+<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>number</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API implements the abstract operation <code>ToNumber()</code> as defined in
 <a href="https://tc39.github.io/ecma262/#sec-tonumber">Section 7.1.3</a> of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>
-<h3>napi_coerce_to_object<span><a class="mark" href="#n_api_napi_coerce_to_object" id="n_api_napi_coerce_to_object">#</a></span></h3>
+<h4>napi_coerce_to_object<span><a class="mark" href="#n_api_napi_coerce_to_object" id="n_api_napi_coerce_to_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_coerce_to_object</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_coerce_to_object</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  napi_value* result)</span></span></code></pre>
+                                  napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to coerce.</li>
@@ -3040,29 +3069,29 @@ This API can be re-entrant if getters are defined on the passed-in <code>Object<
 <p>This API implements the abstract operation <code>ToObject()</code> as defined in
 <a href="https://tc39.github.io/ecma262/#sec-toobject">Section 7.1.13</a> of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>
-<h3>napi_coerce_to_string<span><a class="mark" href="#n_api_napi_coerce_to_string" id="n_api_napi_coerce_to_string">#</a></span></h3>
+<h4>napi_coerce_to_string<span><a class="mark" href="#n_api_napi_coerce_to_string" id="n_api_napi_coerce_to_string">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_coerce_to_string</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_coerce_to_string</span><span class="hljs-params">(napi_env env,
                                   napi_value value,
-                                  napi_value* result)</span></span></code></pre>
+                                  napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to coerce.</li>
-<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>String</code>.</li>
+<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>string</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API implements the abstract operation <code>ToString()</code> as defined in
 <a href="https://tc39.github.io/ecma262/#sec-toobject">Section 7.1.13</a> of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>
-<h3>napi_typeof<span><a class="mark" href="#n_api_napi_typeof" id="n_api_napi_typeof">#</a></span></h3>
+<h4>napi_typeof<span><a class="mark" href="#n_api_napi_typeof" id="n_api_napi_typeof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_typeof</span><span class="hljs-params">(napi_env env, napi_value value, napi_valuetype* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_typeof</span><span class="hljs-params">(napi_env env, napi_value value, napi_valuetype* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value whose type to query.</li>
@@ -3082,15 +3111,15 @@ Specification. However, there are some differences:</p>
 <code>object</code>.</li>
 </ol>
 <p>If <code>value</code> has a type that is invalid, an error is returned.</p>
-<h3>napi_instanceof<span><a class="mark" href="#n_api_napi_instanceof" id="n_api_napi_instanceof">#</a></span></h3>
+<h4>napi_instanceof<span><a class="mark" href="#n_api_napi_instanceof" id="n_api_napi_instanceof">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_instanceof</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_instanceof</span><span class="hljs-params">(napi_env env,
                             napi_value object,
                             napi_value constructor,
-                            <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+                            <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] object</code>: The JavaScript value to check.</li>
@@ -3102,12 +3131,12 @@ is true.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API represents invoking the <code>instanceof</code> Operator on the object as
 defined in <a href="https://tc39.github.io/ecma262/#sec-instanceofoperator">Section 12.10.4</a> of the ECMAScript Language Specification.</p>
-<h3>napi_is_array<span><a class="mark" href="#n_api_napi_is_array" id="n_api_napi_is_array">#</a></span></h3>
+<h4>napi_is_array<span><a class="mark" href="#n_api_napi_is_array" id="n_api_napi_is_array">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_array</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_array</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -3116,12 +3145,12 @@ defined in <a href="https://tc39.github.io/ecma262/#sec-instanceofoperator">Sect
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API represents invoking the <code>IsArray</code> operation on the object
 as defined in <a href="https://tc39.github.io/ecma262/#sec-isarray">Section 7.2.2</a> of the ECMAScript Language Specification.</p>
-<h3>napi_is_arraybuffer<span><a class="mark" href="#n_api_napi_is_arraybuffer" id="n_api_napi_is_arraybuffer">#</a></span></h3>
+<h4>napi_is_arraybuffer<span><a class="mark" href="#n_api_napi_is_arraybuffer" id="n_api_napi_is_arraybuffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_arraybuffer</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_arraybuffer</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -3129,12 +3158,12 @@ as defined in <a href="https://tc39.github.io/ecma262/#sec-isarray">Section 7.2.
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is an array buffer.</p>
-<h3>napi_is_buffer<span><a class="mark" href="#n_api_napi_is_buffer" id="n_api_napi_is_buffer">#</a></span></h3>
+<h4>napi_is_buffer<span><a class="mark" href="#n_api_napi_is_buffer" id="n_api_napi_is_buffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_buffer</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_buffer</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -3143,12 +3172,12 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is a buffer.</p>
-<h3>napi_is_date<span><a class="mark" href="#n_api_napi_is_date" id="n_api_napi_is_date">#</a></span></h3>
+<h4>napi_is_date<span><a class="mark" href="#n_api_napi_is_date" id="n_api_napi_is_date">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.11.0</span>
+<span>Added in: v11.11.0, v10.17.0</span>
 <span>N-API version: 5</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_date</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_date</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -3157,12 +3186,12 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is a date.</p>
-<h3>napi_is_error<span><a class="mark" href="#n_api_napi_is_error_1" id="n_api_napi_is_error_1">#</a></span></h3>
+<h4>napi_is_error<span><a class="mark" href="#n_api_napi_is_error_1" id="n_api_napi_is_error_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_error</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_error</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -3170,12 +3199,12 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is an <code>Error</code>.</p>
-<h3>napi_is_typedarray<span><a class="mark" href="#n_api_napi_is_typedarray" id="n_api_napi_is_typedarray">#</a></span></h3>
+<h4>napi_is_typedarray<span><a class="mark" href="#n_api_napi_is_typedarray" id="n_api_napi_is_typedarray">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_typedarray</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_typedarray</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -3183,12 +3212,12 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is a typed array.</p>
-<h3>napi_is_dataview<span><a class="mark" href="#n_api_napi_is_dataview" id="n_api_napi_is_dataview">#</a></span></h3>
+<h4>napi_is_dataview<span><a class="mark" href="#n_api_napi_is_dataview" id="n_api_napi_is_dataview">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_dataview</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_dataview</span><span class="hljs-params">(napi_env env, napi_value value, <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The JavaScript value to check.</li>
@@ -3196,15 +3225,15 @@ object.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in is a <code>DataView</code>.</p>
-<h3>napi_strict_equals<span><a class="mark" href="#n_api_napi_strict_equals" id="n_api_napi_strict_equals">#</a></span></h3>
+<h4>napi_strict_equals<span><a class="mark" href="#n_api_napi_strict_equals" id="n_api_napi_strict_equals">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_strict_equals</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_strict_equals</span><span class="hljs-params">(napi_env env,
                                napi_value lhs,
                                napi_value rhs,
-                               <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+                               <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] lhs</code>: The JavaScript value to check.</li>
@@ -3214,13 +3243,13 @@ object.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API represents the invocation of the Strict Equality algorithm as
 defined in <a href="https://tc39.github.io/ecma262/#sec-strict-equality-comparison">Section 7.2.14</a> of the ECMAScript Language Specification.</p>
-<h3>napi_detach_arraybuffer<span><a class="mark" href="#n_api_napi_detach_arraybuffer" id="n_api_napi_detach_arraybuffer">#</a></span></h3>
+<h4>napi_detach_arraybuffer<span><a class="mark" href="#n_api_napi_detach_arraybuffer" id="n_api_napi_detach_arraybuffer">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0, v10.22.0</span>
 <span>N-API version: 7</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_detach_arraybuffer</span><span class="hljs-params">(napi_env env,
-                                    napi_value arraybuffer)</span></span></code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_detach_arraybuffer</span><span class="hljs-params">(napi_env env,
+                                    napi_value arraybuffer)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] arraybuffer</code>: The JavaScript <code>ArrayBuffer</code> to be detached.</li>
@@ -3233,14 +3262,14 @@ detachable. For example, V8 requires that the <code>ArrayBuffer</code> be extern
 that is, created with <a href="#n_api_napi_create_external_arraybuffer"><code>napi_create_external_arraybuffer</code></a>.</p>
 <p>This API represents the invocation of the <code>ArrayBuffer</code> detach operation as
 defined in <a href="https://tc39.es/ecma262/#sec-detacharraybuffer">Section 24.1.1.3</a> of the ECMAScript Language Specification.</p>
-<h3>napi_is_detached_arraybuffer<span><a class="mark" href="#n_api_napi_is_detached_arraybuffer" id="n_api_napi_is_detached_arraybuffer">#</a></span></h3>
+<h4>napi_is_detached_arraybuffer<span><a class="mark" href="#n_api_napi_is_detached_arraybuffer" id="n_api_napi_is_detached_arraybuffer">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0, v10.22.0</span>
 <span>N-API version: 7</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_detached_arraybuffer</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_detached_arraybuffer</span><span class="hljs-params">(napi_env env,
                                          napi_value arraybuffer,
-                                         <span class="hljs-keyword">bool</span>* result)</span></span></code></pre>
+                                         <span class="hljs-type">bool</span>* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] arraybuffer</code>: The JavaScript <code>ArrayBuffer</code> to be checked.</li>
@@ -3251,21 +3280,21 @@ defined in <a href="https://tc39.es/ecma262/#sec-detacharraybuffer">Section 24.1
 <p>This API represents the invocation of the <code>ArrayBuffer</code> <code>IsDetachedBuffer</code>
 operation as defined in <a href="https://tc39.es/ecma262/#sec-isdetachedbuffer">Section 24.1.1.2</a> of the ECMAScript Language
 Specification.</p>
-<h2>Working with JavaScript properties<span><a class="mark" href="#n_api_working_with_javascript_properties" id="n_api_working_with_javascript_properties">#</a></span></h2>
-<p>N-API exposes a set of APIs to get and set properties on JavaScript
+</section><section><h3>Working with JavaScript properties<span><a class="mark" href="#n_api_working_with_javascript_properties" id="n_api_working_with_javascript_properties">#</a></span></h3>
+<p>Node-API exposes a set of APIs to get and set properties on JavaScript
 objects. Some of these types are documented under <a href="https://tc39.github.io/ecma262/#sec-abstract-operations">Section 7</a> of the
 <a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>.</p>
 <p>Properties in JavaScript are represented as a tuple of a key and a value.
-Fundamentally, all property keys in N-API can be represented in one of the
+Fundamentally, all property keys in Node-API can be represented in one of the
 following forms:</p>
 <ul>
 <li>Named: a simple UTF8-encoded string</li>
 <li>Integer-Indexed: an index value represented by <code>uint32_t</code></li>
-<li>JavaScript value: these are represented in N-API by <code>napi_value</code>. This can
-be a <code>napi_value</code> representing a <code>String</code>, <code>Number</code>, or <code>Symbol</code>.</li>
+<li>JavaScript value: these are represented in Node-API by <code>napi_value</code>. This can
+be a <code>napi_value</code> representing a <code>string</code>, <code>number</code>, or <code>symbol</code>.</li>
 </ul>
-<p>N-API values are represented by the type <code>napi_value</code>.
-Any N-API call that requires a JavaScript value takes in a <code>napi_value</code>.
+<p>Node-API values are represented by the type <code>napi_value</code>.
+Any Node-API call that requires a JavaScript value takes in a <code>napi_value</code>.
 However, it's the caller's responsibility to make sure that the
 <code>napi_value</code> in question is of the JavaScript type expected by the API.</p>
 <p>The APIs documented in this section provide a simple interface to
@@ -3273,8 +3302,8 @@ get and set properties on arbitrary JavaScript objects represented by
 <code>napi_value</code>.</p>
 <p>For instance, consider the following JavaScript code snippet:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> obj = {};
-obj.myProp = <span class="hljs-number">123</span>;</code></pre>
-<p>The equivalent can be done using N-API values with the following snippet:</p>
+obj.<span class="hljs-property">myProp</span> = <span class="hljs-number">123</span>;</code></pre>
+<p>The equivalent can be done using Node-API values with the following snippet:</p>
 <pre><code class="language-c">napi_status status = napi_generic_failure;
 
 <span class="hljs-comment">// const obj = {}</span>
@@ -3293,7 +3322,7 @@ status = napi_set_named_property(env, obj, <span class="hljs-string">"myProp"</s
 JavaScript snippet:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> arr = [];
 arr[<span class="hljs-number">123</span>] = <span class="hljs-string">'hello'</span>;</code></pre>
-<p>The equivalent can be done using N-API values with the following snippet:</p>
+<p>The equivalent can be done using Node-API values with the following snippet:</p>
 <pre><code class="language-c">napi_status status = napi_generic_failure;
 
 <span class="hljs-comment">// const arr = [];</span>
@@ -3312,7 +3341,7 @@ status = napi_set_element(env, arr, <span class="hljs-number">123</span>, value)
 Consider the following JavaScript snippet:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> arr = [];
 <span class="hljs-keyword">const</span> value = arr[<span class="hljs-number">123</span>];</code></pre>
-<p>The following is the approximate equivalent of the N-API counterpart:</p>
+<p>The following is the approximate equivalent of the Node-API counterpart:</p>
 <pre><code class="language-c">napi_status status = napi_generic_failure;
 
 <span class="hljs-comment">// const arr = []</span>
@@ -3326,11 +3355,11 @@ status = napi_get_element(env, arr, <span class="hljs-number">123</span>, &#x26;
 <p>Finally, multiple properties can also be defined on an object for performance
 reasons. Consider the following JavaScript:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> obj = {};
-<span class="hljs-built_in">Object</span>.defineProperties(obj, {
+<span class="hljs-title class_">Object</span>.<span class="hljs-title function_">defineProperties</span>(obj, {
   <span class="hljs-string">'foo'</span>: { <span class="hljs-attr">value</span>: <span class="hljs-number">123</span>, <span class="hljs-attr">writable</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">configurable</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">enumerable</span>: <span class="hljs-literal">true</span> },
   <span class="hljs-string">'bar'</span>: { <span class="hljs-attr">value</span>: <span class="hljs-number">456</span>, <span class="hljs-attr">writable</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">configurable</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">enumerable</span>: <span class="hljs-literal">true</span> }
 });</code></pre>
-<p>The following is the approximate equivalent of the N-API counterpart:</p>
+<p>The following is the approximate equivalent of the Node-API counterpart:</p>
 <pre><code class="language-c">napi_status status = napi_status_generic_failure;
 
 <span class="hljs-comment">// const obj = {};</span>
@@ -3355,18 +3384,18 @@ status = napi_define_properties(env,
                                 <span class="hljs-keyword">sizeof</span>(descriptors) / <span class="hljs-keyword">sizeof</span>(descriptors[<span class="hljs-number">0</span>]),
                                 descriptors);
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> status;</code></pre>
-<h3>Structures<span><a class="mark" href="#n_api_structures" id="n_api_structures">#</a></span></h3>
-<h4>napi_property_attributes<span><a class="mark" href="#n_api_napi_property_attributes" id="n_api_napi_property_attributes">#</a></span></h4>
+<h4>Structures<span><a class="mark" href="#n_api_structures" id="n_api_structures">#</a></span></h4>
+<h5>napi_property_attributes<span><a class="mark" href="#n_api_napi_property_attributes" id="n_api_napi_property_attributes">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.20.0</td>
-<td><p>added <code>napi_default_method</code> and <code>napi_default_property</code></p></td></tr>
+<tr><td>v14.12.0</td>
+<td><p>added <code>napi_default_method</code> and <code>napi_default_property</code>.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-keyword">enum</span> {
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">enum</span> {</span>
   napi_default = <span class="hljs-number">0</span>,
   napi_writable = <span class="hljs-number">1</span> &#x3C;&#x3C; <span class="hljs-number">0</span>,
   napi_enumerable = <span class="hljs-number">1</span> &#x3C;&#x3C; <span class="hljs-number">1</span>,
@@ -3380,7 +3409,7 @@ status = napi_define_properties(env,
   napi_default_method = napi_writable | napi_configurable,
 
   <span class="hljs-comment">// Default for object properties, like in JS obj[prop].</span>
-  napi_default_property = napi_writable |
+  napi_default_jsproperty = napi_writable |
                           napi_enumerable |
                           napi_configurable,
 } napi_property_attributes;</code></pre>
@@ -3399,15 +3428,15 @@ property is read only, not enumerable and not configurable.</li>
 <li><code>napi_static</code>: The property will be defined as a static property on a class as
 opposed to an instance property, which is the default. This is used only by
 <a href="#n_api_napi_define_class"><code>napi_define_class</code></a>. It is ignored by <code>napi_define_properties</code>.</li>
-<li><code>napi_default_method</code>: The property is configureable, writeable but not
-enumerable like a method in a JS class.</li>
-<li><code>napi_default_property</code>: The property is writable, enumerable and configurable
-like a property set via JS code <code>obj.key = value</code>.</li>
+<li><code>napi_default_method</code>: Like a method in a JS class, the property is
+configurable and writeable, but not enumerable.</li>
+<li><code>napi_default_jsproperty</code>: Like a property set via assignment in JavaScript,
+the property is writable, enumerable, and configurable.</li>
 </ul>
-<h4>napi_property_descriptor<span><a class="mark" href="#n_api_napi_property_descriptor" id="n_api_napi_property_descriptor">#</a></span></h4>
+<h5>napi_property_descriptor<span><a class="mark" href="#n_api_napi_property_descriptor" id="n_api_napi_property_descriptor">#</a></span></h5>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> {</span>
   <span class="hljs-comment">// One of utf8name or name should be NULL.</span>
-  <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8name;
+  <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8name;
   napi_value name;
 
   napi_callback method;
@@ -3416,10 +3445,10 @@ like a property set via JS code <code>obj.key = value</code>.</li>
   napi_value value;
 
   napi_property_attributes attributes;
-  <span class="hljs-keyword">void</span>* data;
+  <span class="hljs-type">void</span>* data;
 } napi_property_descriptor;</code></pre>
 <ul>
-<li><code>utf8name</code>: Optional <code>String</code> describing the key for the property,
+<li><code>utf8name</code>: Optional string describing the key for the property,
 encoded as UTF8. One of <code>utf8name</code> or <code>name</code> must be provided for the
 property.</li>
 <li><code>name</code>: Optional <code>napi_value</code> that points to a JavaScript string or symbol
@@ -3432,12 +3461,12 @@ property is a data property. If this is passed in, set <code>getter</code>, <cod
 If this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members
 won't be used). The given function is called implicitly by the runtime when
 the property is accessed from JavaScript code (or if a get on the property is
-performed using a N-API call). <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
+performed using a Node-API call). <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
 <li><code>setter</code>: A function to call when a set access of the property is performed.
 If this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members
 won't be used). The given function is called implicitly by the runtime when
 the property is set from JavaScript code (or if a set on the property is
-performed using a N-API call). <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
+performed using a Node-API call). <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
 <li><code>method</code>: Set this to make the property descriptor object's <code>value</code>
 property to be a JavaScript function represented by <code>method</code>. If this is
 passed in, set <code>value</code>, <code>getter</code> and <code>setter</code> to <code>NULL</code> (since these members
@@ -3447,17 +3476,17 @@ won't be used). <a href="#n_api_napi_callback"><code>napi_callback</code></a> pr
 <li><code>data</code>: The callback data passed into <code>method</code>, <code>getter</code> and <code>setter</code> if this
 function is invoked.</li>
 </ul>
-<h3>Functions<span><a class="mark" href="#n_api_functions" id="n_api_functions">#</a></span></h3>
-<h4>napi_get_property_names<span><a class="mark" href="#n_api_napi_get_property_names" id="n_api_napi_get_property_names">#</a></span></h4>
+<h4>Functions<span><a class="mark" href="#n_api_functions" id="n_api_functions">#</a></span></h4>
+<h5>napi_get_property_names<span><a class="mark" href="#n_api_napi_get_property_names" id="n_api_napi_get_property_names">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_property_names</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_property_names</span><span class="hljs-params">(napi_env env,
                                     napi_value object,
-                                    napi_value* result)</span></span>;</code></pre>
+                                    napi_value* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the properties.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values
 that represent the property names of the object. The API can be used to
@@ -3468,9 +3497,9 @@ and <a href="#n_api_napi_get_element"><code>napi_get_element</code></a>.</li>
 <p>This API returns the names of the enumerable properties of <code>object</code> as an array
 of strings. The properties of <code>object</code> whose key is a symbol will not be
 included.</p>
-<h4>napi_get_all_property_names<span><a class="mark" href="#n_api_napi_get_all_property_names" id="n_api_napi_get_all_property_names">#</a></span></h4>
+<h5>napi_get_all_property_names<span><a class="mark" href="#n_api_napi_get_all_property_names" id="n_api_napi_get_all_property_names">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0, v10.20.0</span>
 <span>N-API version: 6</span>
 </div>
 <pre><code class="language-c">napi_get_all_property_names(napi_env env,
@@ -3480,81 +3509,81 @@ included.</p>
                             napi_key_conversion key_conversion,
                             napi_value* result);</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the properties.</li>
 <li><code>[in] key_mode</code>: Whether to retrieve prototype properties as well.</li>
 <li><code>[in] key_filter</code>: Which properties to retrieve
 (enumerable/readable/writable).</li>
 <li><code>[in] key_conversion</code>: Whether to convert numbered property keys to strings.</li>
 <li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values
-that represent the property names of the object. <a href="#n_api_napi_get_array_length"><code>napi_get_array_length</code></a> and
-<a href="#n_api_napi_get_element"><code>napi_get_element</code></a> can be used to iterate over <code>result</code>.</li>
+that represent the property names of the object. <a href="#n_api_napi_get_array_length"><code>napi_get_array_length</code></a>
+and <a href="#n_api_napi_get_element"><code>napi_get_element</code></a> can be used to iterate over <code>result</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns an array containing the names of the available properties
 of this object.</p>
-<h4>napi_set_property<span><a class="mark" href="#n_api_napi_set_property" id="n_api_napi_set_property">#</a></span></h4>
+<h5>napi_set_property<span><a class="mark" href="#n_api_napi_set_property" id="n_api_napi_set_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_set_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_set_property</span><span class="hljs-params">(napi_env env,
                               napi_value object,
                               napi_value key,
-                              napi_value value)</span></span>;</code></pre>
+                              napi_value value)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object on which to set the property.</li>
 <li><code>[in] key</code>: The name of the property to set.</li>
 <li><code>[in] value</code>: The property value.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API set a property on the <code>Object</code> passed in.</p>
-<h4>napi_get_property<span><a class="mark" href="#n_api_napi_get_property" id="n_api_napi_get_property">#</a></span></h4>
+<h5>napi_get_property<span><a class="mark" href="#n_api_napi_get_property" id="n_api_napi_get_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_property</span><span class="hljs-params">(napi_env env,
                               napi_value object,
                               napi_value key,
-                              napi_value* result)</span></span>;</code></pre>
+                              napi_value* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the property.</li>
 <li><code>[in] key</code>: The name of the property to retrieve.</li>
 <li><code>[out] result</code>: The value of the property.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API gets the requested property from the <code>Object</code> passed in.</p>
-<h4>napi_has_property<span><a class="mark" href="#n_api_napi_has_property" id="n_api_napi_has_property">#</a></span></h4>
+<h5>napi_has_property<span><a class="mark" href="#n_api_napi_has_property" id="n_api_napi_has_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_has_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_has_property</span><span class="hljs-params">(napi_env env,
                               napi_value object,
                               napi_value key,
-                              <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                              <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] key</code>: The name of the property whose existence to check.</li>
 <li><code>[out] result</code>: Whether the property exists on the object or not.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in has the named property.</p>
-<h4>napi_delete_property<span><a class="mark" href="#n_api_napi_delete_property" id="n_api_napi_delete_property">#</a></span></h4>
+<h5>napi_delete_property<span><a class="mark" href="#n_api_napi_delete_property" id="n_api_napi_delete_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_delete_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_delete_property</span><span class="hljs-params">(napi_env env,
                                  napi_value object,
                                  napi_value key,
-                                 <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                 <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] key</code>: The name of the property to delete.</li>
 <li><code>[out] result</code>: Whether the property deletion succeeded or not. <code>result</code> can
@@ -3562,36 +3591,36 @@ optionally be ignored by passing <code>NULL</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API attempts to delete the <code>key</code> own property from <code>object</code>.</p>
-<h4>napi_has_own_property<span><a class="mark" href="#n_api_napi_has_own_property" id="n_api_napi_has_own_property">#</a></span></h4>
+<h5>napi_has_own_property<span><a class="mark" href="#n_api_napi_has_own_property" id="n_api_napi_has_own_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_has_own_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_has_own_property</span><span class="hljs-params">(napi_env env,
                                   napi_value object,
                                   napi_value key,
-                                  <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                  <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] key</code>: The name of the own property whose existence to check.</li>
 <li><code>[out] result</code>: Whether the own property exists on the object or not.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API checks if the <code>Object</code> passed in has the named own property. <code>key</code> must
-be a string or a <code>Symbol</code>, or an error will be thrown. N-API will not perform
-any conversion between data types.</p>
-<h4>napi_set_named_property<span><a class="mark" href="#n_api_napi_set_named_property" id="n_api_napi_set_named_property">#</a></span></h4>
+be a <code>string</code> or a <code>symbol</code>, or an error will be thrown. Node-API will not
+perform any conversion between data types.</p>
+<h5>napi_set_named_property<span><a class="mark" href="#n_api_napi_set_named_property" id="n_api_napi_set_named_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_set_named_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_set_named_property</span><span class="hljs-params">(napi_env env,
                                     napi_value object,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8Name,
-                                    napi_value value)</span></span>;</code></pre>
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8Name,
+                                    napi_value value)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object on which to set the property.</li>
 <li><code>[in] utf8Name</code>: The name of the property to set.</li>
 <li><code>[in] value</code>: The property value.</li>
@@ -3599,17 +3628,17 @@ any conversion between data types.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This method is equivalent to calling <a href="#n_api_napi_set_property"><code>napi_set_property</code></a> with a <code>napi_value</code>
 created from the string passed in as <code>utf8Name</code>.</p>
-<h4>napi_get_named_property<span><a class="mark" href="#n_api_napi_get_named_property" id="n_api_napi_get_named_property">#</a></span></h4>
+<h5>napi_get_named_property<span><a class="mark" href="#n_api_napi_get_named_property" id="n_api_napi_get_named_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_named_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_named_property</span><span class="hljs-params">(napi_env env,
                                     napi_value object,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8Name,
-                                    napi_value* result)</span></span>;</code></pre>
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8Name,
+                                    napi_value* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the property.</li>
 <li><code>[in] utf8Name</code>: The name of the property to get.</li>
 <li><code>[out] result</code>: The value of the property.</li>
@@ -3617,17 +3646,17 @@ created from the string passed in as <code>utf8Name</code>.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This method is equivalent to calling <a href="#n_api_napi_get_property"><code>napi_get_property</code></a> with a <code>napi_value</code>
 created from the string passed in as <code>utf8Name</code>.</p>
-<h4>napi_has_named_property<span><a class="mark" href="#n_api_napi_has_named_property" id="n_api_napi_has_named_property">#</a></span></h4>
+<h5>napi_has_named_property<span><a class="mark" href="#n_api_napi_has_named_property" id="n_api_napi_has_named_property">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_has_named_property</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_has_named_property</span><span class="hljs-params">(napi_env env,
                                     napi_value object,
-                                    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8Name,
-                                    <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                    <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8Name,
+                                    <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] utf8Name</code>: The name of the property whose existence to check.</li>
 <li><code>[out] result</code>: Whether the property exists on the object or not.</li>
@@ -3635,51 +3664,51 @@ created from the string passed in as <code>utf8Name</code>.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This method is equivalent to calling <a href="#n_api_napi_has_property"><code>napi_has_property</code></a> with a <code>napi_value</code>
 created from the string passed in as <code>utf8Name</code>.</p>
-<h4>napi_set_element<span><a class="mark" href="#n_api_napi_set_element" id="n_api_napi_set_element">#</a></span></h4>
+<h5>napi_set_element<span><a class="mark" href="#n_api_napi_set_element" id="n_api_napi_set_element">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_set_element</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_set_element</span><span class="hljs-params">(napi_env env,
                              napi_value object,
-                             <span class="hljs-keyword">uint32_t</span> index,
-                             napi_value value)</span></span>;</code></pre>
+                             <span class="hljs-type">uint32_t</span> index,
+                             napi_value value)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to set the properties.</li>
 <li><code>[in] index</code>: The index of the property to set.</li>
 <li><code>[in] value</code>: The property value.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API sets and element on the <code>Object</code> passed in.</p>
-<h4>napi_get_element<span><a class="mark" href="#n_api_napi_get_element" id="n_api_napi_get_element">#</a></span></h4>
+<h5>napi_get_element<span><a class="mark" href="#n_api_napi_get_element" id="n_api_napi_get_element">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_element</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_element</span><span class="hljs-params">(napi_env env,
                              napi_value object,
-                             <span class="hljs-keyword">uint32_t</span> index,
-                             napi_value* result)</span></span>;</code></pre>
+                             <span class="hljs-type">uint32_t</span> index,
+                             napi_value* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the property.</li>
 <li><code>[in] index</code>: The index of the property to get.</li>
 <li><code>[out] result</code>: The value of the property.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API gets the element at the requested index.</p>
-<h4>napi_has_element<span><a class="mark" href="#n_api_napi_has_element" id="n_api_napi_has_element">#</a></span></h4>
+<h5>napi_has_element<span><a class="mark" href="#n_api_napi_has_element" id="n_api_napi_has_element">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_has_element</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_has_element</span><span class="hljs-params">(napi_env env,
                              napi_value object,
-                             <span class="hljs-keyword">uint32_t</span> index,
-                             <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                             <span class="hljs-type">uint32_t</span> index,
+                             <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] index</code>: The index of the property whose existence to check.</li>
 <li><code>[out] result</code>: Whether the property exists on the object or not.</li>
@@ -3687,17 +3716,17 @@ created from the string passed in as <code>utf8Name</code>.</p>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns if the <code>Object</code> passed in has an element at the
 requested index.</p>
-<h4>napi_delete_element<span><a class="mark" href="#n_api_napi_delete_element" id="n_api_napi_delete_element">#</a></span></h4>
+<h5>napi_delete_element<span><a class="mark" href="#n_api_napi_delete_element" id="n_api_napi_delete_element">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_delete_element</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_delete_element</span><span class="hljs-params">(napi_env env,
                                 napi_value object,
-                                <span class="hljs-keyword">uint32_t</span> index,
-                                <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                <span class="hljs-type">uint32_t</span> index,
+                                <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to query.</li>
 <li><code>[in] index</code>: The index of the property to delete.</li>
 <li><code>[out] result</code>: Whether the element deletion succeeded or not. <code>result</code> can
@@ -3705,17 +3734,17 @@ optionally be ignored by passing <code>NULL</code>.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API attempts to delete the specified <code>index</code> from <code>object</code>.</p>
-<h4>napi_define_properties<span><a class="mark" href="#n_api_napi_define_properties" id="n_api_napi_define_properties">#</a></span></h4>
+<h5>napi_define_properties<span><a class="mark" href="#n_api_napi_define_properties" id="n_api_napi_define_properties">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_define_properties</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_define_properties</span><span class="hljs-params">(napi_env env,
                                    napi_value object,
-                                   <span class="hljs-keyword">size_t</span> property_count,
-                                   <span class="hljs-keyword">const</span> napi_property_descriptor* properties)</span></span>;</code></pre>
+                                   <span class="hljs-type">size_t</span> property_count,
+                                   <span class="hljs-keyword">const</span> napi_property_descriptor* properties)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object from which to retrieve the properties.</li>
 <li><code>[in] property_count</code>: The number of elements in the <code>properties</code> array.</li>
 <li><code>[in] properties</code>: The array of property descriptors.</li>
@@ -3727,15 +3756,15 @@ object. The properties are defined using property descriptors (see
 this API will set the properties on the object one at a time, as defined by
 <code>DefineOwnProperty()</code> (described in <a href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc">Section 9.1.6</a> of the ECMA-262
 specification).</p>
-<h4>napi_object_freeze<span><a class="mark" href="#n_api_napi_object_freeze" id="n_api_napi_object_freeze">#</a></span></h4>
+<h5>napi_object_freeze<span><a class="mark" href="#n_api_napi_object_freeze" id="n_api_napi_object_freeze">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v14.14.0, v12.20.0</span>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_object_freeze</span><span class="hljs-params">(napi_env env,
-                               napi_value object)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_object_freeze</span><span class="hljs-params">(napi_env env,
+                               napi_value object)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to freeze.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
@@ -3746,15 +3775,15 @@ properties, and prevents the values of existing properties from being changed.
 It also prevents the object's prototype from being changed. This is described
 in <a href="https://tc39.es/ecma262/#sec-object.freeze">Section 19.1.2.6</a> of the
 ECMA-262 specification.</p>
-<h4>napi_object_seal<span><a class="mark" href="#n_api_napi_object_seal" id="n_api_napi_object_seal">#</a></span></h4>
+<h5>napi_object_seal<span><a class="mark" href="#n_api_napi_object_seal" id="n_api_napi_object_seal">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.20.0</span>
+<span>Added in: v14.14.0, v12.20.0</span>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_object_seal</span><span class="hljs-params">(napi_env env,
-                             napi_value object)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_object_seal</span><span class="hljs-params">(napi_env env,
+                             napi_value object)</span>;</code></pre>
 <ul>
-<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>
+<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>
 <li><code>[in] object</code>: The object to seal.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
@@ -3762,9 +3791,9 @@ ECMA-262 specification.</p>
 added to it, as well as marking all existing properties as non-configurable.
 This is described in <a href="https://tc39.es/ecma262/#sec-object.seal">Section 19.1.2.20</a>
 of the ECMA-262 specification.</p>
-<h2>Working with JavaScript functions<span><a class="mark" href="#n_api_working_with_javascript_functions" id="n_api_working_with_javascript_functions">#</a></span></h2>
-<p>N-API provides a set of APIs that allow JavaScript code to
-call back into native code. N-API APIs that support calling back
+</section><section><h3>Working with JavaScript functions<span><a class="mark" href="#n_api_working_with_javascript_functions" id="n_api_working_with_javascript_functions">#</a></span></h3>
+<p>Node-API provides a set of APIs that allow JavaScript code to
+call back into native code. Node-APIs that support calling back
 into native code take in a callback functions represented by
 the <code>napi_callback</code> type. When the JavaScript VM calls back to
 native code, the <code>napi_callback</code> function provided is invoked. The APIs
@@ -3775,7 +3804,7 @@ following:</p>
 <li>Get the arguments passed into the callback.</li>
 <li>Return a <code>napi_value</code> back from the callback.</li>
 </ul>
-<p>Additionally, N-API provides a set of functions which allow calling
+<p>Additionally, Node-API provides a set of functions which allow calling
 JavaScript functions from native code. One can either call a function
 like a regular JavaScript function call, or as a constructor
 function.</p>
@@ -3783,20 +3812,20 @@ function.</p>
 <code>napi_property_descriptor</code> items can be associated with <code>object</code> and freed
 whenever <code>object</code> is garbage-collected by passing both <code>object</code> and the data to
 <a href="#n_api_napi_add_finalizer"><code>napi_add_finalizer</code></a>.</p>
-<h3>napi_call_function<span><a class="mark" href="#n_api_napi_call_function" id="n_api_napi_call_function">#</a></span></h3>
+<h4>napi_call_function<span><a class="mark" href="#n_api_napi_call_function" id="n_api_napi_call_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_call_function</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_call_function</span><span class="hljs-params">(napi_env env,
                                            napi_value recv,
                                            napi_value func,
-                                           <span class="hljs-keyword">size_t</span> argc,
+                                           <span class="hljs-type">size_t</span> argc,
                                            <span class="hljs-keyword">const</span> napi_value* argv,
-                                           napi_value* result)</span></span>;</code></pre>
+                                           napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] recv</code>: The <code>this</code> object passed to the called function.</li>
+<li><code>[in] recv</code>: The <code>this</code> value passed to the called function.</li>
 <li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>
 <li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>
 <li><code>[in] argv</code>: Array of <code>napi_values</code> representing JavaScript values passed in
@@ -3810,7 +3839,7 @@ native code <em>into</em> JavaScript. For the special case of calling into JavaS
 after an async operation, see <a href="#n_api_napi_make_callback"><code>napi_make_callback</code></a>.</p>
 <p>A sample use case might look as follows. Consider the following JavaScript
 snippet:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">AddTwo</span>(<span class="hljs-params">num</span>) </span>{
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">AddTwo</span>(<span class="hljs-params">num</span>) {
   <span class="hljs-keyword">return</span> num + <span class="hljs-number">2</span>;
 }</code></pre>
 <p>Then, the above function can be invoked from a native add-on using the
@@ -3828,7 +3857,7 @@ status = napi_create_int32(env, <span class="hljs-number">1337</span>, &#x26;arg
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span>;
 
 napi_value* argv = &#x26;arg;
-<span class="hljs-keyword">size_t</span> argc = <span class="hljs-number">1</span>;
+<span class="hljs-type">size_t</span> argc = <span class="hljs-number">1</span>;
 
 <span class="hljs-comment">// AddTwo(arg);</span>
 napi_value return_val;
@@ -3836,20 +3865,20 @@ status = napi_call_function(env, global, add_two, argc, argv, &#x26;return_val);
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span>;
 
 <span class="hljs-comment">// Convert the result back to a native type</span>
-<span class="hljs-keyword">int32_t</span> result;
+<span class="hljs-type">int32_t</span> result;
 status = napi_get_value_int32(env, return_val, &#x26;result);
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span>;</code></pre>
-<h3>napi_create_function<span><a class="mark" href="#n_api_napi_create_function" id="n_api_napi_create_function">#</a></span></h3>
+<h4>napi_create_function<span><a class="mark" href="#n_api_napi_create_function" id="n_api_napi_create_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_function</span><span class="hljs-params">(napi_env env,
-                                 <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8name,
-                                 <span class="hljs-keyword">size_t</span> length,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_function</span><span class="hljs-params">(napi_env env,
+                                 <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8name,
+                                 <span class="hljs-type">size_t</span> length,
                                  napi_callback cb,
-                                 <span class="hljs-keyword">void</span>* data,
-                                 napi_value* result)</span></span>;</code></pre>
+                                 <span class="hljs-type">void</span>* data,
+                                 napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] utf8Name</code>: The name of the function encoded as UTF8. This is visible
@@ -3873,12 +3902,12 @@ to JavaScript, in order for the function to be accessible from script.</p>
 <p>In order to expose a function as part of the
 add-on's module exports, set the newly created function on the exports
 object. A sample module might look as follows:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_value <span class="hljs-title">SayHello</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
+<pre><code class="language-c">napi_value <span class="hljs-title function_">SayHello</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
   <span class="hljs-built_in">printf</span>(<span class="hljs-string">"Hello\n"</span>);
   <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
 }
 
-<span class="hljs-function">napi_value <span class="hljs-title">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> </span>{
+napi_value <span class="hljs-title function_">Init</span><span class="hljs-params">(napi_env env, napi_value exports)</span> {
   napi_status status;
 
   napi_value fn;
@@ -3894,7 +3923,7 @@ object. A sample module might look as follows:</p>
 NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)</code></pre>
 <p>Given the above code, the add-on can be used from JavaScript as follows:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> myaddon = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./addon'</span>);
-myaddon.sayHello();</code></pre>
+myaddon.<span class="hljs-title function_">sayHello</span>();</code></pre>
 <p>The string passed to <code>require()</code> is the name of the target in <code>binding.gyp</code>
 responsible for creating the <code>.node</code> file.</p>
 <p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> parameter can
@@ -3903,22 +3932,22 @@ be associated with the resulting JavaScript function (which is returned in the
 passing both the JavaScript function and the data to <a href="#n_api_napi_add_finalizer"><code>napi_add_finalizer</code></a>.</p>
 <p>JavaScript <code>Function</code>s are described in <a href="https://tc39.github.io/ecma262/#sec-function-objects">Section 19.2</a> of the ECMAScript
 Language Specification.</p>
-<h3>napi_get_cb_info<span><a class="mark" href="#n_api_napi_get_cb_info" id="n_api_napi_get_cb_info">#</a></span></h3>
+<h4>napi_get_cb_info<span><a class="mark" href="#n_api_napi_get_cb_info" id="n_api_napi_get_cb_info">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_cb_info</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_cb_info</span><span class="hljs-params">(napi_env env,
                              napi_callback_info cbinfo,
-                             <span class="hljs-keyword">size_t</span>* argc,
+                             <span class="hljs-type">size_t</span>* argc,
                              napi_value* argv,
                              napi_value* thisArg,
-                             <span class="hljs-keyword">void</span>** data)</span></span></code></pre>
+                             <span class="hljs-type">void</span>** data)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] cbinfo</code>: The callback info passed into the callback function.</li>
-<li><code>[in-out] argc</code>: Specifies the size of the provided <code>argv</code> array and receives
-the actual count of arguments.</li>
+<li><code>[in-out] argc</code>: Specifies the length of the provided <code>argv</code> array and
+receives the actual count of arguments.</li>
 <li><code>[out] argv</code>: Buffer to which the <code>napi_value</code> representing the arguments are
 copied. If there are more arguments than the provided count, only the
 requested number of arguments are copied. If there are fewer arguments
@@ -3930,14 +3959,14 @@ that represent <code>undefined</code>.</li>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This method is used within a callback function to retrieve details about the
 call like the arguments and the <code>this</code> pointer from a given callback info.</p>
-<h3>napi_get_new_target<span><a class="mark" href="#n_api_napi_get_new_target" id="n_api_napi_get_new_target">#</a></span></h3>
+<h4>napi_get_new_target<span><a class="mark" href="#n_api_napi_get_new_target" id="n_api_napi_get_new_target">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.6.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_new_target</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_new_target</span><span class="hljs-params">(napi_env env,
                                 napi_callback_info cbinfo,
-                                napi_value* result)</span></span></code></pre>
+                                napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] cbinfo</code>: The callback info passed into the callback function.</li>
@@ -3946,16 +3975,16 @@ call like the arguments and the <code>this</code> pointer from a given callback
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API returns the <code>new.target</code> of the constructor call. If the current
 callback is not a constructor call, the result is <code>NULL</code>.</p>
-<h3>napi_new_instance<span><a class="mark" href="#n_api_napi_new_instance" id="n_api_napi_new_instance">#</a></span></h3>
+<h4>napi_new_instance<span><a class="mark" href="#n_api_napi_new_instance" id="n_api_napi_new_instance">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_new_instance</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_new_instance</span><span class="hljs-params">(napi_env env,
                               napi_value cons,
-                              <span class="hljs-keyword">size_t</span> argc,
+                              <span class="hljs-type">size_t</span> argc,
                               napi_value* argv,
-                              napi_value* result)</span></span></code></pre>
+                              napi_value* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] cons</code>: <code>napi_value</code> representing the JavaScript function to be invoked
@@ -3969,13 +3998,13 @@ which in this case is the constructed object.</li>
 <p>This method is used to instantiate a new JavaScript value using a given
 <code>napi_value</code> that represents the constructor for the object. For example,
 consider the following snippet:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyObject</span>(<span class="hljs-params">param</span>) </span>{
-  <span class="hljs-built_in">this</span>.param = param;
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">MyObject</span>(<span class="hljs-params">param</span>) {
+  <span class="hljs-variable language_">this</span>.<span class="hljs-property">param</span> = param;
 }
 
 <span class="hljs-keyword">const</span> arg = <span class="hljs-string">'hello'</span>;
-<span class="hljs-keyword">const</span> value = <span class="hljs-keyword">new</span> MyObject(arg);</code></pre>
-<p>The following can be approximated in N-API using the following snippet:</p>
+<span class="hljs-keyword">const</span> value = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyObject</span>(arg);</code></pre>
+<p>The following can be approximated in Node-API using the following snippet:</p>
 <pre><code class="language-c"><span class="hljs-comment">// Get the constructor function MyObject</span>
 napi_value global, constructor, arg, value;
 napi_status status = napi_get_global(env, &#x26;global);
@@ -3989,13 +4018,13 @@ status = napi_create_string_utf8(env, <span class="hljs-string">"hello"</span>,
 <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span>;
 
 napi_value* argv = &#x26;arg;
-<span class="hljs-keyword">size_t</span> argc = <span class="hljs-number">1</span>;
+<span class="hljs-type">size_t</span> argc = <span class="hljs-number">1</span>;
 
 <span class="hljs-comment">// const value = new MyObject(arg)</span>
 status = napi_new_instance(env, constructor, argc, argv, &#x26;value);</code></pre>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<h2>Object wrap<span><a class="mark" href="#n_api_object_wrap" id="n_api_object_wrap">#</a></span></h2>
-<p>N-API offers a way to "wrap" C++ classes and instances so that the class
+</section><section><h3>Object wrap<span><a class="mark" href="#n_api_object_wrap" id="n_api_object_wrap">#</a></span></h3>
+<p>Node-API offers a way to "wrap" C++ classes and instances so that the class
 constructor and methods can be called from JavaScript.</p>
 <ol>
 <li>The <a href="#n_api_napi_define_class"><code>napi_define_class</code></a> API defines a JavaScript class with constructor,
@@ -4016,7 +4045,7 @@ reference to the class constructor for later <code>instanceof</code> checks.</p>
 <pre><code class="language-c">napi_value MyClass_constructor = <span class="hljs-literal">NULL</span>;
 status = napi_get_reference_value(env, MyClass::es_constructor, &#x26;MyClass_constructor);
 assert(napi_ok == status);
-<span class="hljs-keyword">bool</span> is_instance = <span class="hljs-literal">false</span>;
+<span class="hljs-type">bool</span> is_instance = <span class="hljs-literal">false</span>;
 status = napi_instanceof(env, es_this, MyClass_constructor, &#x26;is_instance);
 assert(napi_ok == status);
 <span class="hljs-keyword">if</span> (is_instance) {
@@ -4034,10 +4063,10 @@ cases there is a chance that they may be unwrapped incorrectly.</p>
 
 <span class="hljs-comment">// `openDatabase()` returns a JavaScript object that wraps a native database</span>
 <span class="hljs-comment">// handle.</span>
-<span class="hljs-keyword">const</span> dbHandle = myAddon.openDatabase();
+<span class="hljs-keyword">const</span> dbHandle = myAddon.<span class="hljs-title function_">openDatabase</span>();
 
 <span class="hljs-comment">// `query()` returns a JavaScript object that wraps a native query handle.</span>
-<span class="hljs-keyword">const</span> queryHandle = myAddon.query(dbHandle, <span class="hljs-string">'Gimme ALL the things!'</span>);
+<span class="hljs-keyword">const</span> queryHandle = myAddon.<span class="hljs-title function_">query</span>(dbHandle, <span class="hljs-string">'Gimme ALL the things!'</span>);
 
 <span class="hljs-comment">// There is an accidental error in the line below. The first parameter to</span>
 <span class="hljs-comment">// `myAddon.queryHasRecords()` should be the database handle (`dbHandle`), not</span>
@@ -4046,7 +4075,7 @@ cases there is a chance that they may be unwrapped incorrectly.</p>
 <span class="hljs-comment">//</span>
 <span class="hljs-comment">// myAddon.queryHasRecords(dbHandle, queryHandle)</span>
 <span class="hljs-comment">//</span>
-<span class="hljs-keyword">while</span> (myAddon.queryHasRecords(queryHandle, dbHandle)) {
+<span class="hljs-keyword">while</span> (myAddon.<span class="hljs-title function_">queryHasRecords</span>(queryHandle, dbHandle)) {
   <span class="hljs-comment">// retrieve records</span>
 }</code></pre>
 <p>In the above example <code>myAddon.queryHasRecords()</code> is a method that accepts two
@@ -4070,8 +4099,8 @@ set to the prototype of the constructor for query handle instances. In this
 case, the database handle instance can appear as a query handle instance, and it
 will pass the <code>napi_instanceof()</code> test for a query handle instance, while still
 containing a pointer to a database handle.</p>
-<p>To this end, N-API provides type-tagging capabilities.</p>
-<p>A type tag is a 128-bit integer unique to the addon. N-API provides the
+<p>To this end, Node-API provides type-tagging capabilities.</p>
+<p>A type tag is a 128-bit integer unique to the addon. Node-API provides the
 <code>napi_type_tag</code> structure for storing a type tag. When such a value is passed
 along with a JavaScript object stored in a <code>napi_value</code> to
 <code>napi_type_tag_object()</code>, the JavaScript object will be "marked" with the
@@ -4098,8 +4127,8 @@ illustrates the use of <code>napi_type_tag_object()</code> and
   <span class="hljs-number">0x9c73317f9fad44a3</span>, <span class="hljs-number">0x93c3920bf3b0ad6a</span>
 };
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> napi_value
-<span class="hljs-title">openDatabase</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
+<span class="hljs-keyword">static</span> napi_value
+<span class="hljs-title function_">openDatabase</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
   napi_status status;
   napi_value result;
 
@@ -4125,12 +4154,12 @@ illustrates the use of <code>napi_type_tag_object()</code> and
 <span class="hljs-comment">// we can use `napi_check_object_type_tag()` to ensure that it is indeed such a</span>
 <span class="hljs-comment">// handle.</span>
 
-<span class="hljs-function"><span class="hljs-keyword">static</span> napi_value
-<span class="hljs-title">query</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
+<span class="hljs-keyword">static</span> napi_value
+<span class="hljs-title function_">query</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
   napi_status status;
-  <span class="hljs-keyword">size_t</span> argc = <span class="hljs-number">2</span>;
+  <span class="hljs-type">size_t</span> argc = <span class="hljs-number">2</span>;
   napi_value argv[<span class="hljs-number">2</span>];
-  <span class="hljs-keyword">bool</span> is_db_handle;
+  <span class="hljs-type">bool</span> is_db_handle;
 
   status = napi_get_cb_info(env, info, &#x26;argc, argv, <span class="hljs-literal">NULL</span>, <span class="hljs-literal">NULL</span>);
   <span class="hljs-keyword">if</span> (status != napi_ok) <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
@@ -4149,29 +4178,30 @@ illustrates the use of <code>napi_type_tag_object()</code> and
     <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
   }
 }</code></pre>
-<h3>napi_define_class<span><a class="mark" href="#n_api_napi_define_class" id="n_api_napi_define_class">#</a></span></h3>
+<h4>napi_define_class<span><a class="mark" href="#n_api_napi_define_class" id="n_api_napi_define_class">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_define_class</span><span class="hljs-params">(napi_env env,
-                              <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* utf8name,
-                              <span class="hljs-keyword">size_t</span> length,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_define_class</span><span class="hljs-params">(napi_env env,
+                              <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* utf8name,
+                              <span class="hljs-type">size_t</span> length,
                               napi_callback constructor,
-                              <span class="hljs-keyword">void</span>* data,
-                              <span class="hljs-keyword">size_t</span> property_count,
+                              <span class="hljs-type">void</span>* data,
+                              <span class="hljs-type">size_t</span> property_count,
                               <span class="hljs-keyword">const</span> napi_property_descriptor* properties,
-                              napi_value* result)</span></span>;</code></pre>
+                              napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[in] utf8name</code>: Name of the JavaScript constructor function; this is
-not required to be the same as the C++ class name, though it is recommended
-for clarity.</li>
+<li><code>[in] utf8name</code>: Name of the JavaScript constructor function; When wrapping a
+C++ class, we recommend for clarity that this name be the same as that of
+the C++ class.</li>
 <li><code>[in] length</code>: The length of the <code>utf8name</code> in bytes, or <code>NAPI_AUTO_LENGTH</code>
 if it is null-terminated.</li>
 <li><code>[in] constructor</code>: Callback function that handles constructing instances
-of the class. This should be a static method on the class, not an actual
-C++ constructor function. <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
+of the class. When wrapping a C++ class, this method must be a static member
+with the <a href="#n_api_napi_callback"><code>napi_callback</code></a> signature. A C++ class constructor cannot be
+used. <a href="#n_api_napi_callback"><code>napi_callback</code></a> provides more details.</li>
 <li><code>[in] data</code>: Optional data to be passed to the constructor callback as
 the <code>data</code> property of the callback info.</li>
 <li><code>[in] property_count</code>: Number of items in the <code>properties</code> array argument.</li>
@@ -4182,42 +4212,48 @@ See <code>napi_property_descriptor</code>.</li>
 the class.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>Defines a JavaScript class that corresponds to a C++ class, including:</p>
-<ul>
-<li>A JavaScript constructor function that has the class name and invokes the
-provided C++ constructor callback.</li>
-<li>Properties on the constructor function corresponding to <em>static</em> data
-properties, accessors, and methods of the C++ class (defined by
-property descriptors with the <code>napi_static</code> attribute).</li>
-<li>Properties on the constructor function's <code>prototype</code> object corresponding to
-<em>non-static</em> data properties, accessors, and methods of the C++ class
-(defined by property descriptors without the <code>napi_static</code> attribute).</li>
-</ul>
-<p>The C++ constructor callback should be a static method on the class that calls
-the actual class constructor, then wraps the new C++ instance in a JavaScript
-object, and returns the wrapper object. See <code>napi_wrap()</code> for details.</p>
+<p>Defines a JavaScript class, including:</p>
+<ul>
+<li>A JavaScript constructor function that has the class name. When wrapping a
+corresponding C++ class, the callback passed via <code>constructor</code> can be used to
+instantiate a new C++ class instance, which can then be placed inside the
+JavaScript object instance being constructed using <a href="#n_api_napi_wrap"><code>napi_wrap</code></a>.</li>
+<li>Properties on the constructor function whose implementation can call
+corresponding <em>static</em> data properties, accessors, and methods of the C++
+class (defined by property descriptors with the <code>napi_static</code> attribute).</li>
+<li>Properties on the constructor function's <code>prototype</code> object. When wrapping a
+C++ class, <em>non-static</em> data properties, accessors, and methods of the C++
+class can be called from the static functions given in the property
+descriptors without the <code>napi_static</code> attribute after retrieving the C++ class
+instance placed inside the JavaScript object instance by using
+<a href="#n_api_napi_unwrap"><code>napi_unwrap</code></a>.</li>
+</ul>
+<p>When wrapping a C++ class, the C++ constructor callback passed via <code>constructor</code>
+should be a static method on the class that calls the actual class constructor,
+then wraps the new C++ instance in a JavaScript object, and returns the wrapper
+object. See <a href="#n_api_napi_wrap"><code>napi_wrap</code></a> for details.</p>
 <p>The JavaScript constructor function returned from <a href="#n_api_napi_define_class"><code>napi_define_class</code></a> is
-often saved and used later, to construct new instances of the class from native
-code, and/or check whether provided values are instances of the class. In that
-case, to prevent the function value from being garbage-collected, create a
-persistent reference to it using <a href="#n_api_napi_create_reference"><code>napi_create_reference</code></a> and ensure the
-reference count is kept >= 1.</p>
+often saved and used later to construct new instances of the class from native
+code, and/or to check whether provided values are instances of the class. In
+that case, to prevent the function value from being garbage-collected, a
+strong persistent reference to it can be created using
+<a href="#n_api_napi_create_reference"><code>napi_create_reference</code></a>, ensuring that the reference count is kept >= 1.</p>
 <p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> parameter or via
 the <code>data</code> field of the <code>napi_property_descriptor</code> array items can be associated
 with the resulting JavaScript constructor (which is returned in the <code>result</code>
 parameter) and freed whenever the class is garbage-collected by passing both
 the JavaScript function and the data to <a href="#n_api_napi_add_finalizer"><code>napi_add_finalizer</code></a>.</p>
-<h3>napi_wrap<span><a class="mark" href="#n_api_napi_wrap" id="n_api_napi_wrap">#</a></span></h3>
+<h4>napi_wrap<span><a class="mark" href="#n_api_napi_wrap" id="n_api_napi_wrap">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_wrap</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_wrap</span><span class="hljs-params">(napi_env env,
                       napi_value js_object,
-                      <span class="hljs-keyword">void</span>* native_object,
+                      <span class="hljs-type">void</span>* native_object,
                       napi_finalize finalize_cb,
-                      <span class="hljs-keyword">void</span>* finalize_hint,
-                      napi_ref* result)</span></span>;</code></pre>
+                      <span class="hljs-type">void</span>* finalize_hint,
+                      napi_ref* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The JavaScript object that will be the wrapper for the
@@ -4255,14 +4291,14 @@ required in order to enable correct disposal of the reference.</p>
 <p>Calling <code>napi_wrap()</code> a second time on an object will return an error. To
 associate another native instance with the object, use <code>napi_remove_wrap()</code>
 first.</p>
-<h3>napi_unwrap<span><a class="mark" href="#n_api_napi_unwrap" id="n_api_napi_unwrap">#</a></span></h3>
+<h4>napi_unwrap<span><a class="mark" href="#n_api_napi_unwrap" id="n_api_napi_unwrap">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_unwrap</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_unwrap</span><span class="hljs-params">(napi_env env,
                         napi_value js_object,
-                        <span class="hljs-keyword">void</span>** result)</span></span>;</code></pre>
+                        <span class="hljs-type">void</span>** result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The object associated with the native instance.</li>
@@ -4276,14 +4312,14 @@ corresponding <code>napi_callback</code> is invoked. If the callback is for an i
 method or accessor, then the <code>this</code> argument to the callback is the wrapper
 object; the wrapped C++ instance that is the target of the call can be obtained
 then by calling <code>napi_unwrap()</code> on the wrapper object.</p>
-<h3>napi_remove_wrap<span><a class="mark" href="#n_api_napi_remove_wrap" id="n_api_napi_remove_wrap">#</a></span></h3>
+<h4>napi_remove_wrap<span><a class="mark" href="#n_api_napi_remove_wrap" id="n_api_napi_remove_wrap">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_remove_wrap</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_remove_wrap</span><span class="hljs-params">(napi_env env,
                              napi_value js_object,
-                             <span class="hljs-keyword">void</span>** result)</span></span>;</code></pre>
+                             <span class="hljs-type">void</span>** result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The object associated with the native instance.</li>
@@ -4294,14 +4330,14 @@ then by calling <code>napi_unwrap()</code> on the wrapper object.</p>
 object <code>js_object</code> using <code>napi_wrap()</code> and removes the wrapping. If a finalize
 callback was associated with the wrapping, it will no longer be called when the
 JavaScript object becomes garbage-collected.</p>
-<h3>napi_type_tag_object<span><a class="mark" href="#n_api_napi_type_tag_object" id="n_api_napi_type_tag_object">#</a></span></h3>
+<h4>napi_type_tag_object<span><a class="mark" href="#n_api_napi_type_tag_object" id="n_api_napi_type_tag_object">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0, v12.19.0</span>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_type_tag_object</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_type_tag_object</span><span class="hljs-params">(napi_env env,
                                  napi_value js_object,
-                                 <span class="hljs-keyword">const</span> napi_type_tag* type_tag)</span></span>;</code></pre>
+                                 <span class="hljs-keyword">const</span> napi_type_tag* type_tag)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The JavaScript object to be marked.</li>
@@ -4314,15 +4350,15 @@ attached to the object with one owned by the addon to ensure that the object
 has the right type.</p>
 <p>If the object already has an associated type tag, this API will return
 <code>napi_invalid_arg</code>.</p>
-<h3>napi_check_object_type_tag<span><a class="mark" href="#n_api_napi_check_object_type_tag" id="n_api_napi_check_object_type_tag">#</a></span></h3>
+<h4>napi_check_object_type_tag<span><a class="mark" href="#n_api_napi_check_object_type_tag" id="n_api_napi_check_object_type_tag">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.8.0, v12.19.0</span>
 <span>N-API version: 8</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_check_object_type_tag</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_check_object_type_tag</span><span class="hljs-params">(napi_env env,
                                        napi_value js_object,
                                        <span class="hljs-keyword">const</span> napi_type_tag* type_tag,
-                                       <span class="hljs-keyword">bool</span>* result)</span></span>;</code></pre>
+                                       <span class="hljs-type">bool</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The JavaScript object whose type tag to examine.</li>
@@ -4335,17 +4371,17 @@ object. <code>false</code> is also returned if no type tag was found on the obje
 <code>js_object</code>. If no tag is found on <code>js_object</code> or, if a tag is found but it does
 not match <code>type_tag</code>, then <code>result</code> is set to <code>false</code>. If a tag is found and it
 matches <code>type_tag</code>, then <code>result</code> is set to <code>true</code>.</p>
-<h3>napi_add_finalizer<span><a class="mark" href="#n_api_napi_add_finalizer" id="n_api_napi_add_finalizer">#</a></span></h3>
+<h4>napi_add_finalizer<span><a class="mark" href="#n_api_napi_add_finalizer" id="n_api_napi_add_finalizer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 5</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_add_finalizer</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_add_finalizer</span><span class="hljs-params">(napi_env env,
                                napi_value js_object,
-                               <span class="hljs-keyword">void</span>* native_object,
+                               <span class="hljs-type">void</span>* native_object,
                                napi_finalize finalize_cb,
-                               <span class="hljs-keyword">void</span>* finalize_hint,
-                               napi_ref* result)</span></span>;</code></pre>
+                               <span class="hljs-type">void</span>* finalize_hint,
+                               napi_ref* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] js_object</code>: The JavaScript object to which the native data will be
@@ -4375,45 +4411,45 @@ attach each of them to the JavaScript object, and</li>
 invocation. If it is deleted before then, then the finalize callback may never
 be invoked. Therefore, when obtaining a reference a finalize callback is also
 required in order to enable correct disposal of the reference.</p>
-<h2>Simple asynchronous operations<span><a class="mark" href="#n_api_simple_asynchronous_operations" id="n_api_simple_asynchronous_operations">#</a></span></h2>
+</section><section><h3>Simple asynchronous operations<span><a class="mark" href="#n_api_simple_asynchronous_operations" id="n_api_simple_asynchronous_operations">#</a></span></h3>
 <p>Addon modules often need to leverage async helpers from libuv as part of their
 implementation. This allows them to schedule work to be executed asynchronously
 so that their methods can return in advance of the work being completed. This
 allows them to avoid blocking overall execution of the Node.js application.</p>
-<p>N-API provides an ABI-stable interface for these
+<p>Node-API provides an ABI-stable interface for these
 supporting functions which covers the most common asynchronous use cases.</p>
-<p>N-API defines the <code>napi_async_work</code> structure which is used to manage
+<p>Node-API defines the <code>napi_async_work</code> structure which is used to manage
 asynchronous workers. Instances are created/deleted with
 <a href="#n_api_napi_create_async_work"><code>napi_create_async_work</code></a> and <a href="#n_api_napi_delete_async_work"><code>napi_delete_async_work</code></a>.</p>
 <p>The <code>execute</code> and <code>complete</code> callbacks are functions that will be
 invoked when the executor is ready to execute and when it completes its
 task respectively.</p>
-<p>The <code>execute</code> function should avoid making any N-API calls
+<p>The <code>execute</code> function should avoid making any Node-API calls
 that could result in the execution of JavaScript or interaction with
-JavaScript objects. Most often, any code that needs to make N-API
+JavaScript objects. Most often, any code that needs to make Node-API
 calls should be made in <code>complete</code> callback instead.
 Avoid using the <code>napi_env</code> parameter in the execute callback as
 it will likely execute JavaScript.</p>
 <p>These functions implement the following interfaces:</p>
-<pre><code class="language-c"><span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_execute_callback)</span><span class="hljs-params">(napi_env env,
-                                            <span class="hljs-keyword">void</span>* data)</span></span>;
-<span class="hljs-function"><span class="hljs-keyword">typedef</span> <span class="hljs-title">void</span> <span class="hljs-params">(*napi_async_complete_callback)</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_execute_callback)</span><span class="hljs-params">(napi_env env,
+                                            <span class="hljs-type">void</span>* data)</span>;
+<span class="hljs-keyword">typedef</span> <span class="hljs-title function_">void</span> <span class="hljs-params">(*napi_async_complete_callback)</span><span class="hljs-params">(napi_env env,
                                              napi_status status,
-                                             <span class="hljs-keyword">void</span>* data)</span></span>;</code></pre>
+                                             <span class="hljs-type">void</span>* data)</span>;</code></pre>
 <p>When these methods are invoked, the <code>data</code> parameter passed will be the
 addon-provided <code>void*</code> data that was passed into the
 <code>napi_create_async_work</code> call.</p>
 <p>Once created the async worker can be queued
 for execution using the <a href="#n_api_napi_queue_async_work"><code>napi_queue_async_work</code></a> function:</p>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_queue_async_work</span><span class="hljs-params">(napi_env env,
-                                  napi_async_work work)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_queue_async_work</span><span class="hljs-params">(napi_env env,
+                                  napi_async_work work)</span>;</code></pre>
 <p><a href="#n_api_napi_cancel_async_work"><code>napi_cancel_async_work</code></a> can be used if the work needs
 to be cancelled before the work has started execution.</p>
 <p>After calling <a href="#n_api_napi_cancel_async_work"><code>napi_cancel_async_work</code></a>, the <code>complete</code> callback
 will be invoked with a status value of <code>napi_cancelled</code>.
 The work should not be deleted before the <code>complete</code>
 callback invocation, even when it was cancelled.</p>
-<h3>napi_create_async_work<span><a class="mark" href="#n_api_napi_create_async_work" id="n_api_napi_create_async_work">#</a></span></h3>
+<h4>napi_create_async_work<span><a class="mark" href="#n_api_napi_create_async_work" id="n_api_napi_create_async_work">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -4426,13 +4462,13 @@ callback invocation, even when it was cancelled.</p>
 </details>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_async_work</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_async_work</span><span class="hljs-params">(napi_env env,
                                    napi_value async_resource,
                                    napi_value async_resource_name,
                                    napi_async_execute_callback execute,
                                    napi_async_complete_callback complete,
-                                   <span class="hljs-keyword">void</span>* data,
-                                   napi_async_work* result)</span></span>;</code></pre>
+                                   <span class="hljs-type">void</span>* data,
+                                   napi_async_work* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] async_resource</code>: An optional object associated with the async work
@@ -4460,13 +4496,13 @@ required.</p>
 representative of the type of async work being performed. It is also recommended
 to apply namespacing to the identifier, e.g. by including the module name. See
 the <a href="async_hooks.html#async_hooks_type"><code>async_hooks</code> documentation</a> for more information.</p>
-<h3>napi_delete_async_work<span><a class="mark" href="#n_api_napi_delete_async_work" id="n_api_napi_delete_async_work">#</a></span></h3>
+<h4>napi_delete_async_work<span><a class="mark" href="#n_api_napi_delete_async_work" id="n_api_napi_delete_async_work">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_delete_async_work</span><span class="hljs-params">(napi_env env,
-                                   napi_async_work work)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_delete_async_work</span><span class="hljs-params">(napi_env env,
+                                   napi_async_work work)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] work</code>: The handle returned by the call to <code>napi_create_async_work</code>.</li>
@@ -4474,13 +4510,13 @@ the <a href="async_hooks.html#async_hooks_type"><code>async_hooks</code> documen
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API frees a previously allocated work object.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h3>napi_queue_async_work<span><a class="mark" href="#n_api_napi_queue_async_work" id="n_api_napi_queue_async_work">#</a></span></h3>
+<h4>napi_queue_async_work<span><a class="mark" href="#n_api_napi_queue_async_work" id="n_api_napi_queue_async_work">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_queue_async_work</span><span class="hljs-params">(napi_env env,
-                                  napi_async_work work)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_queue_async_work</span><span class="hljs-params">(napi_env env,
+                                  napi_async_work work)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] work</code>: The handle returned by the call to <code>napi_create_async_work</code>.</li>
@@ -4489,13 +4525,13 @@ the <a href="async_hooks.html#async_hooks_type"><code>async_hooks</code> documen
 <p>This API requests that the previously allocated work be scheduled
 for execution. Once it returns successfully, this API must not be called again
 with the same <code>napi_async_work</code> item or the result will be undefined.</p>
-<h3>napi_cancel_async_work<span><a class="mark" href="#n_api_napi_cancel_async_work" id="n_api_napi_cancel_async_work">#</a></span></h3>
+<h4>napi_cancel_async_work<span><a class="mark" href="#n_api_napi_cancel_async_work" id="n_api_napi_cancel_async_work">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_cancel_async_work</span><span class="hljs-params">(napi_env env,
-                                   napi_async_work work)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_cancel_async_work</span><span class="hljs-params">(napi_env env,
+                                   napi_async_work work)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] work</code>: The handle returned by the call to <code>napi_create_async_work</code>.</li>
@@ -4508,49 +4544,59 @@ the <code>complete</code> callback will be invoked with a status value of
 <code>napi_cancelled</code>. The work should not be deleted before the <code>complete</code>
 callback invocation, even if it has been successfully cancelled.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h2>Custom asynchronous operations<span><a class="mark" href="#n_api_custom_asynchronous_operations" id="n_api_custom_asynchronous_operations">#</a></span></h2>
+</section><section><h3>Custom asynchronous operations<span><a class="mark" href="#n_api_custom_asynchronous_operations" id="n_api_custom_asynchronous_operations">#</a></span></h3>
 <p>The simple asynchronous work APIs above may not be appropriate for every
 scenario. When using any other asynchronous mechanism, the following APIs
 are necessary to ensure an asynchronous operation is properly tracked by
 the runtime.</p>
-<h3>napi_async_init<span><a class="mark" href="#n_api_napi_async_init" id="n_api_napi_async_init">#</a></span></h3>
+<h4>napi_async_init<span><a class="mark" href="#n_api_napi_async_init" id="n_api_napi_async_init">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.6.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_async_init</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_async_init</span><span class="hljs-params">(napi_env env,
                             napi_value async_resource,
                             napi_value async_resource_name,
-                            napi_async_context* result)</span></span></code></pre>
+                            napi_async_context* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] async_resource</code>: Object associated with the async work
-that will be passed to possible <code>async_hooks</code> <a href="async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a>.
-In order to retain ABI compatibility with previous versions,
-passing <code>NULL</code> for <code>async_resource</code> will not result in an error, however,
-this will result incorrect operation of async hooks for the
-napi_async_context created. Potential issues include
-loss of async context when using the AsyncLocalStorage API.</li>
-<li><code>[in] async_resource_name</code>: Identifier for the kind of resource
-that is being provided for diagnostic information exposed by the
-<code>async_hooks</code> API.</li>
+that will be passed to possible <code>async_hooks</code> <a href="async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a> and can be
+accessed by <a href="async_hooks.html#async_hooks_async_hooks_executionasyncresource"><code>async_hooks.executionAsyncResource()</code></a>.</li>
+<li><code>[in] async_resource_name</code>: Identifier for the kind of resource that is being
+provided for diagnostic information exposed by the <code>async_hooks</code> API.</li>
 <li><code>[out] result</code>: The initialized async context.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<h3>napi_async_destroy<span><a class="mark" href="#n_api_napi_async_destroy" id="n_api_napi_async_destroy">#</a></span></h3>
+<p>The <code>async_resource</code> object needs to be kept alive until
+<a href="#n_api_napi_async_destroy"><code>napi_async_destroy</code></a> to keep <code>async_hooks</code> related API acts correctly. In
+order to retain ABI compatibility with previous versions, <code>napi_async_context</code>s
+are not maintaining the strong reference to the <code>async_resource</code> objects to
+avoid introducing causing memory leaks. However, if the <code>async_resource</code> is
+garbage collected by JavaScript engine before the <code>napi_async_context</code> was
+destroyed by <code>napi_async_destroy</code>, calling <code>napi_async_context</code> related APIs
+like <a href="#n_api_napi_open_callback_scope"><code>napi_open_callback_scope</code></a> and <a href="#n_api_napi_make_callback"><code>napi_make_callback</code></a> can cause
+problems like loss of async context when using the <code>AsyncLocalStoage</code> API.</p>
+<p>In order to retain ABI compatibility with previous versions, passing <code>NULL</code>
+for <code>async_resource</code> does not result in an error. However, this is not
+recommended as this will result poor results with  <code>async_hooks</code>
+<a href="async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a> and <code>async_hooks.executionAsyncResource()</code> as the resource is
+now required by the underlying <code>async_hooks</code> implementation in order to provide
+the linkage between async callbacks.</p>
+<h4>napi_async_destroy<span><a class="mark" href="#n_api_napi_async_destroy" id="n_api_napi_async_destroy">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.6.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_async_destroy</span><span class="hljs-params">(napi_env env,
-                               napi_async_context async_context)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_async_destroy</span><span class="hljs-params">(napi_env env,
+                               napi_async_context async_context)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] async_context</code>: The async context to be destroyed.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h3>napi_make_callback<span><a class="mark" href="#n_api_napi_make_callback" id="n_api_napi_make_callback">#</a></span></h3>
+<h4>napi_make_callback<span><a class="mark" href="#n_api_napi_make_callback" id="n_api_napi_make_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -4563,21 +4609,23 @@ that is being provided for diagnostic information exposed by the
 </details>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_make_callback</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_make_callback</span><span class="hljs-params">(napi_env env,
                                            napi_async_context async_context,
                                            napi_value recv,
                                            napi_value func,
-                                           <span class="hljs-keyword">size_t</span> argc,
+                                           <span class="hljs-type">size_t</span> argc,
                                            <span class="hljs-keyword">const</span> napi_value* argv,
-                                           napi_value* result)</span></span>;</code></pre>
+                                           napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] async_context</code>: Context for the async operation that is
 invoking the callback. This should normally be a value previously
-obtained from <a href="#n_api_napi_async_init"><code>napi_async_init</code></a>. However <code>NULL</code> is also allowed,
-which indicates the current async context (if any) is to be used
-for the callback.</li>
-<li><code>[in] recv</code>: The <code>this</code> object passed to the called function.</li>
+obtained from <a href="#n_api_napi_async_init"><code>napi_async_init</code></a>.
+In order to retain ABI compatibility with previous versions, passing <code>NULL</code>
+for <code>async_context</code> does not result in an error. However, this results
+in incorrect operation of async hooks. Potential issues include loss of
+async context when using the <code>AsyncLocalStorage</code> API.</li>
+<li><code>[in] recv</code>: The <code>this</code> value passed to the called function.</li>
 <li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>
 <li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>
 <li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the
@@ -4598,56 +4646,58 @@ may be required when implementing custom async behavior that does not use
 <code>napi_create_async_work</code>.</p>
 <p>Any <code>process.nextTick</code>s or Promises scheduled on the microtask queue by
 JavaScript during the callback are ran before returning back to C/C++.</p>
-<h3>napi_open_callback_scope<span><a class="mark" href="#n_api_napi_open_callback_scope" id="n_api_napi_open_callback_scope">#</a></span></h3>
+<h4>napi_open_callback_scope<span><a class="mark" href="#n_api_napi_open_callback_scope" id="n_api_napi_open_callback_scope">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_open_callback_scope</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_open_callback_scope</span><span class="hljs-params">(napi_env env,
                                                  napi_value resource_object,
                                                  napi_async_context context,
-                                                 napi_callback_scope* result)</span></span></code></pre>
+                                                 napi_callback_scope* result)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] resource_object</code>: An object associated with the async work
-that will be passed to possible <code>async_hooks</code> <a href="async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a>.</li>
+that will be passed to possible <code>async_hooks</code> <a href="async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource"><code>init</code> hooks</a>. This
+parameter has been deprecated and is ignored at runtime. Use the
+<code>async_resource</code> parameter in <a href="#n_api_napi_async_init"><code>napi_async_init</code></a> instead.</li>
 <li><code>[in] context</code>: Context for the async operation that is invoking the callback.
 This should be a value previously obtained from <a href="#n_api_napi_async_init"><code>napi_async_init</code></a>.</li>
 <li><code>[out] result</code>: The newly created scope.</li>
 </ul>
 <p>There are cases (for example, resolving promises) where it is
 necessary to have the equivalent of the scope associated with a callback
-in place when making certain N-API calls. If there is no other script on
+in place when making certain Node-API calls. If there is no other script on
 the stack the <a href="#n_api_napi_open_callback_scope"><code>napi_open_callback_scope</code></a> and
 <a href="#n_api_napi_close_callback_scope"><code>napi_close_callback_scope</code></a> functions can be used to open/close
 the required scope.</p>
-<h3>napi_close_callback_scope<span><a class="mark" href="#n_api_napi_close_callback_scope" id="n_api_napi_close_callback_scope">#</a></span></h3>
+<h4>napi_close_callback_scope<span><a class="mark" href="#n_api_napi_close_callback_scope" id="n_api_napi_close_callback_scope">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 <span>N-API version: 3</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_close_callback_scope</span><span class="hljs-params">(napi_env env,
-                                                  napi_callback_scope scope)</span></span></code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_close_callback_scope</span><span class="hljs-params">(napi_env env,
+                                                  napi_callback_scope scope)</span></code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] scope</code>: The scope to be closed.</li>
 </ul>
 <p>This API can be called even if there is a pending JavaScript exception.</p>
-<h2>Version management<span><a class="mark" href="#n_api_version_management" id="n_api_version_management">#</a></span></h2>
-<h3>napi_get_node_version<span><a class="mark" href="#n_api_napi_get_node_version" id="n_api_napi_get_node_version">#</a></span></h3>
+</section><section><h3>Version management<span><a class="mark" href="#n_api_version_management" id="n_api_version_management">#</a></span></h3>
+<h4>napi_get_node_version<span><a class="mark" href="#n_api_napi_get_node_version" id="n_api_napi_get_node_version">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 <span>N-API version: 1</span>
 </div>
 <pre><code class="language-c"><span class="hljs-keyword">typedef</span> <span class="hljs-class"><span class="hljs-keyword">struct</span> {</span>
-  <span class="hljs-keyword">uint32_t</span> major;
-  <span class="hljs-keyword">uint32_t</span> minor;
-  <span class="hljs-keyword">uint32_t</span> patch;
-  <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* release;
+  <span class="hljs-type">uint32_t</span> major;
+  <span class="hljs-type">uint32_t</span> minor;
+  <span class="hljs-type">uint32_t</span> patch;
+  <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>* release;
 } napi_node_version;
 
-<span class="hljs-function">napi_status <span class="hljs-title">napi_get_node_version</span><span class="hljs-params">(napi_env env,
-                                  <span class="hljs-keyword">const</span> napi_node_version** version)</span></span>;</code></pre>
+napi_status <span class="hljs-title function_">napi_get_node_version</span><span class="hljs-params">(napi_env env,
+                                  <span class="hljs-keyword">const</span> napi_node_version** version)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] version</code>: A pointer to version information for Node.js itself.</li>
@@ -4657,20 +4707,20 @@ the required scope.</p>
 version of Node.js that is currently running, and the <code>release</code> field with the
 value of <a href="process.html#process_process_release"><code>process.release.name</code></a>.</p>
 <p>The returned buffer is statically allocated and does not need to be freed.</p>
-<h3>napi_get_version<span><a class="mark" href="#n_api_napi_get_version" id="n_api_napi_get_version">#</a></span></h3>
+<h4>napi_get_version<span><a class="mark" href="#n_api_napi_get_version" id="n_api_napi_get_version">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_get_version</span><span class="hljs-params">(napi_env env,
-                             <span class="hljs-keyword">uint32_t</span>* result)</span></span>;</code></pre>
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_get_version</span><span class="hljs-params">(napi_env env,
+                             <span class="hljs-type">uint32_t</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
-<li><code>[out] result</code>: The highest version of N-API supported.</li>
+<li><code>[out] result</code>: The highest version of Node-API supported.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
-<p>This API returns the highest N-API version supported by the
-Node.js runtime. N-API is planned to be additive such that
+<p>This API returns the highest Node-API version supported by the
+Node.js runtime. Node-API is planned to be additive such that
 newer releases of Node.js may support additional API functions.
 In order to allow an addon to use a newer function when running with
 versions of Node.js that support it, while providing
@@ -4683,15 +4733,15 @@ support it:</p>
 <li>If the function is not available, provide an alternate implementation
 that does not use the function.</li>
 </ul>
-<h2>Memory management<span><a class="mark" href="#n_api_memory_management" id="n_api_memory_management">#</a></span></h2>
-<h3>napi_adjust_external_memory<span><a class="mark" href="#n_api_napi_adjust_external_memory" id="n_api_napi_adjust_external_memory">#</a></span></h3>
+</section><section><h3>Memory management<span><a class="mark" href="#n_api_memory_management" id="n_api_memory_management">#</a></span></h3>
+<h4>napi_adjust_external_memory<span><a class="mark" href="#n_api_napi_adjust_external_memory" id="n_api_napi_adjust_external_memory">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_adjust_external_memory</span><span class="hljs-params">(napi_env env,
-                                                    <span class="hljs-keyword">int64_t</span> change_in_bytes,
-                                                    <span class="hljs-keyword">int64_t</span>* result)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_adjust_external_memory</span><span class="hljs-params">(napi_env env,
+                                                    <span class="hljs-type">int64_t</span> change_in_bytes,
+                                                    <span class="hljs-type">int64_t</span>* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] change_in_bytes</code>: The change in externally allocated memory that is kept
@@ -4704,8 +4754,8 @@ memory that is kept alive by JavaScript objects (i.e. a JavaScript object
 that points to its own memory allocated by a native module). Registering
 externally allocated memory will trigger global garbage collections more
 often than it would otherwise.</p>
-<h2>Promises<span><a class="mark" href="#n_api_promises" id="n_api_promises">#</a></span></h2>
-<p>N-API provides facilities for creating <code>Promise</code> objects as described in
+</section><section><h3>Promises<span><a class="mark" href="#n_api_promises" id="n_api_promises">#</a></span></h3>
+<p>Node-API provides facilities for creating <code>Promise</code> objects as described in
 <a href="https://tc39.github.io/ecma262/#sec-promise-objects">Section 25.4</a> of the ECMA specification. It implements promises as a pair of
 objects. When a promise is created by <code>napi_create_promise()</code>, a "deferred"
 object is created and returned alongside the <code>Promise</code>. The deferred object is
@@ -4750,14 +4800,14 @@ status = napi_get_undefined(env, &#x26;undefined);
 
 <span class="hljs-comment">// At this point the deferred has been freed, so we should assign NULL to it.</span>
 deferred = <span class="hljs-literal">NULL</span>;</code></pre>
-<h3>napi_create_promise<span><a class="mark" href="#n_api_napi_create_promise" id="n_api_napi_create_promise">#</a></span></h3>
+<h4>napi_create_promise<span><a class="mark" href="#n_api_napi_create_promise" id="n_api_napi_create_promise">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_create_promise</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_create_promise</span><span class="hljs-params">(napi_env env,
                                 napi_deferred* deferred,
-                                napi_value* promise)</span></span>;</code></pre>
+                                napi_value* promise)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] deferred</code>: A newly created deferred object which can later be passed to
@@ -4767,14 +4817,14 @@ the associated promise.</li>
 </ul>
 <p>Returns <code>napi_ok</code> if the API succeeded.</p>
 <p>This API creates a deferred object and a JavaScript promise.</p>
-<h3>napi_resolve_deferred<span><a class="mark" href="#n_api_napi_resolve_deferred" id="n_api_napi_resolve_deferred">#</a></span></h3>
+<h4>napi_resolve_deferred<span><a class="mark" href="#n_api_napi_resolve_deferred" id="n_api_napi_resolve_deferred">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_resolve_deferred</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_resolve_deferred</span><span class="hljs-params">(napi_env env,
                                   napi_deferred deferred,
-                                  napi_value resolution)</span></span>;</code></pre>
+                                  napi_value resolution)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] deferred</code>: The deferred object whose associated promise to resolve.</li>
@@ -4787,14 +4837,14 @@ effectively means that the promise must have been created using
 <code>napi_create_promise()</code> and the deferred object returned from that call must
 have been retained in order to be passed to this API.</p>
 <p>The deferred object is freed upon successful completion.</p>
-<h3>napi_reject_deferred<span><a class="mark" href="#n_api_napi_reject_deferred" id="n_api_napi_reject_deferred">#</a></span></h3>
+<h4>napi_reject_deferred<span><a class="mark" href="#n_api_napi_reject_deferred" id="n_api_napi_reject_deferred">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_reject_deferred</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_reject_deferred</span><span class="hljs-params">(napi_env env,
                                  napi_deferred deferred,
-                                 napi_value rejection)</span></span>;</code></pre>
+                                 napi_value rejection)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] deferred</code>: The deferred object whose associated promise to resolve.</li>
@@ -4807,31 +4857,31 @@ effectively means that the promise must have been created using
 <code>napi_create_promise()</code> and the deferred object returned from that call must
 have been retained in order to be passed to this API.</p>
 <p>The deferred object is freed upon successful completion.</p>
-<h3>napi_is_promise<span><a class="mark" href="#n_api_napi_is_promise" id="n_api_napi_is_promise">#</a></span></h3>
+<h4>napi_is_promise<span><a class="mark" href="#n_api_napi_is_promise" id="n_api_napi_is_promise">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">napi_status <span class="hljs-title">napi_is_promise</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">napi_status <span class="hljs-title function_">napi_is_promise</span><span class="hljs-params">(napi_env env,
                             napi_value value,
-                            <span class="hljs-keyword">bool</span>* is_promise)</span></span>;</code></pre>
+                            <span class="hljs-type">bool</span>* is_promise)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] value</code>: The value to examine</li>
 <li><code>[out] is_promise</code>: Flag indicating whether <code>promise</code> is a native promise
 object (that is, a promise object created by the underlying engine).</li>
 </ul>
-<h2>Script execution<span><a class="mark" href="#n_api_script_execution" id="n_api_script_execution">#</a></span></h2>
-<p>N-API provides an API for executing a string containing JavaScript using the
+</section><section><h3>Script execution<span><a class="mark" href="#n_api_script_execution" id="n_api_script_execution">#</a></span></h3>
+<p>Node-API provides an API for executing a string containing JavaScript using the
 underlying JavaScript engine.</p>
-<h3>napi_run_script<span><a class="mark" href="#n_api_napi_run_script" id="n_api_napi_run_script">#</a></span></h3>
+<h4>napi_run_script<span><a class="mark" href="#n_api_napi_run_script" id="n_api_napi_run_script">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 <span>N-API version: 1</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_run_script</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_run_script</span><span class="hljs-params">(napi_env env,
                                         napi_value script,
-                                        napi_value* result)</span></span>;</code></pre>
+                                        napi_value* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] script</code>: A JavaScript string containing the script to execute.</li>
@@ -4850,23 +4900,23 @@ made using <code>let</code> and <code>const</code> will be visible globally, but
 to the <a href="globals.html#globals_global"><code>global</code></a> object.</li>
 <li>The value of <code>this</code> is <a href="globals.html#globals_global"><code>global</code></a> within the script.</li>
 </ul>
-<h2>libuv event loop<span><a class="mark" href="#n_api_libuv_event_loop" id="n_api_libuv_event_loop">#</a></span></h2>
-<p>N-API provides a function for getting the current event loop associated with
+</section><section><h3>libuv event loop<span><a class="mark" href="#n_api_libuv_event_loop" id="n_api_libuv_event_loop">#</a></span></h3>
+<p>Node-API provides a function for getting the current event loop associated with
 a specific <code>napi_env</code>.</p>
-<h3>napi_get_uv_event_loop<span><a class="mark" href="#n_api_napi_get_uv_event_loop" id="n_api_napi_get_uv_event_loop">#</a></span></h3>
+<h4>napi_get_uv_event_loop<span><a class="mark" href="#n_api_napi_get_uv_event_loop" id="n_api_napi_get_uv_event_loop">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v8.10.0, v9.3.0</span>
+<span>Added in: v9.3.0, v8.10.0</span>
 <span>N-API version: 2</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status <span class="hljs-title">napi_get_uv_event_loop</span><span class="hljs-params">(napi_env env,
-                                               struct uv_loop_s** loop)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status <span class="hljs-title function_">napi_get_uv_event_loop</span><span class="hljs-params">(napi_env env,
+                                               <span class="hljs-keyword">struct</span> uv_loop_s** loop)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[out] loop</code>: The current libuv loop instance.</li>
 </ul>
-<h2>Asynchronous thread-safe function calls<span><a class="mark" href="#n_api_asynchronous_thread_safe_function_calls" id="n_api_asynchronous_thread_safe_function_calls">#</a></span></h2>
+</section><section><h3>Asynchronous thread-safe function calls<span><a class="mark" href="#n_api_asynchronous_thread_safe_function_calls" id="n_api_asynchronous_thread_safe_function_calls">#</a></span></h3>
 <p>JavaScript functions can normally only be called from a native addon's main
-thread. If an addon creates additional threads, then N-API functions that
+thread. If an addon creates additional threads, then Node-API functions that
 require a <code>napi_env</code>, <code>napi_value</code>, or <code>napi_ref</code> must not be called from those
 threads.</p>
 <p>When an addon has additional threads and JavaScript functions need to be invoked
@@ -4891,7 +4941,7 @@ completes.</strong></p>
 <p>The <code>context</code> given during the call to <code>napi_create_threadsafe_function()</code> can
 be retrieved from any thread with a call to
 <code>napi_get_threadsafe_function_context()</code>.</p>
-<h3>Calling a thread-safe function<span><a class="mark" href="#n_api_calling_a_thread_safe_function" id="n_api_calling_a_thread_safe_function">#</a></span></h3>
+<h4>Calling a thread-safe function<span><a class="mark" href="#n_api_calling_a_thread_safe_function" id="n_api_calling_a_thread_safe_function">#</a></span></h4>
 <p><code>napi_call_threadsafe_function()</code> can be used for initiating a call into
 JavaScript. <code>napi_call_threadsafe_function()</code> accepts a parameter which controls
 whether the API behaves blockingly. If set to <code>napi_tsfn_nonblocking</code>, the API
@@ -4900,6 +4950,9 @@ preventing data from being successfully added to the queue. If set to
 <code>napi_tsfn_blocking</code>, the API blocks until space becomes available in the queue.
 <code>napi_call_threadsafe_function()</code> never blocks if the thread-safe function was
 created with a maximum queue size of 0.</p>
+<p><code>napi_call_threadsafe_function()</code> should not be called with <code>napi_tsfn_blocking</code>
+from a JavaScript thread, because, if the queue is full, it may cause the
+JavaScript thread to deadlock.</p>
 <p>The actual call into JavaScript is controlled by the callback given via the
 <code>call_js_cb</code> parameter. <code>call_js_cb</code> is invoked on the main thread once for each
 value that was placed into the queue by a successful call to
@@ -4915,8 +4968,8 @@ to indicate that calls into JavaScript are no longer possible, while items
 remain in the queue that may need to be freed. This normally occurs when the
 Node.js process exits while there is a thread-safe function still active.</p>
 <p>It is not necessary to call into JavaScript via <code>napi_make_callback()</code> because
-N-API runs <code>call_js_cb</code> in a context appropriate for callbacks.</p>
-<h3>Reference counting of thread-safe functions<span><a class="mark" href="#n_api_reference_counting_of_thread_safe_functions" id="n_api_reference_counting_of_thread_safe_functions">#</a></span></h3>
+Node-API runs <code>call_js_cb</code> in a context appropriate for callbacks.</p>
+<h4>Reference counting of thread-safe functions<span><a class="mark" href="#n_api_reference_counting_of_thread_safe_functions" id="n_api_reference_counting_of_thread_safe_functions">#</a></span></h4>
 <p>Threads can be added to and removed from a <code>napi_threadsafe_function</code> object
 during its existence. Thus, in addition to specifying an initial number of
 threads upon creation, <code>napi_acquire_threadsafe_function</code> can be called to
@@ -4955,7 +5008,7 @@ used as a criterion for terminating the thread. <strong>Upon receiving a return
 of <code>napi_closing</code> from <code>napi_call_threadsafe_function()</code> a thread must not use
 the thread-safe function anymore because it is no longer guaranteed to
 be allocated.</strong></p>
-<h3>Deciding whether to keep the process running<span><a class="mark" href="#n_api_deciding_whether_to_keep_the_process_running" id="n_api_deciding_whether_to_keep_the_process_running">#</a></span></h3>
+<h4>Deciding whether to keep the process running<span><a class="mark" href="#n_api_deciding_whether_to_keep_the_process_running" id="n_api_deciding_whether_to_keep_the_process_running">#</a></span></h4>
 <p>Similarly to libuv handles, thread-safe functions can be "referenced" and
 "unreferenced". A "referenced" thread-safe function will cause the event loop on
 the thread on which it is created to remain alive until the thread-safe function
@@ -4965,12 +5018,12 @@ prevent the event loop from exiting. The APIs <code>napi_ref_threadsafe_function
 <p>Neither does <code>napi_unref_threadsafe_function</code> mark the thread-safe functions as
 able to be destroyed nor does <code>napi_ref_threadsafe_function</code> prevent it from
 being destroyed.</p>
-<h3>napi_create_threadsafe_function<span><a class="mark" href="#n_api_napi_create_threadsafe_function" id="n_api_napi_create_threadsafe_function">#</a></span></h3>
+<h4>napi_create_threadsafe_function<span><a class="mark" href="#n_api_napi_create_threadsafe_function" id="n_api_napi_create_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.6.0</td>
+<tr><td>v12.6.0, v10.17.0</td>
 <td><p>Made <code>func</code> parameter optional with custom <code>call_js_cb</code>.</p></td></tr>
 <tr><td>v10.6.0</td>
 <td><p><span>Added in: v10.6.0</span></p></td></tr>
@@ -4978,18 +5031,18 @@ being destroyed.</p>
 </details>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_create_threadsafe_function</span><span class="hljs-params">(napi_env env,
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_create_threadsafe_function</span><span class="hljs-params">(napi_env env,
                                 napi_value func,
                                 napi_value async_resource,
                                 napi_value async_resource_name,
-                                <span class="hljs-keyword">size_t</span> max_queue_size,
-                                <span class="hljs-keyword">size_t</span> initial_thread_count,
-                                <span class="hljs-keyword">void</span>* thread_finalize_data,
+                                <span class="hljs-type">size_t</span> max_queue_size,
+                                <span class="hljs-type">size_t</span> initial_thread_count,
+                                <span class="hljs-type">void</span>* thread_finalize_data,
                                 napi_finalize thread_finalize_cb,
-                                <span class="hljs-keyword">void</span>* context,
+                                <span class="hljs-type">void</span>* context,
                                 napi_threadsafe_function_call_js call_js_cb,
-                                napi_threadsafe_function* result)</span></span>;</code></pre>
+                                napi_threadsafe_function* result)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] func</code>: An optional JavaScript function to call from another thread. It
@@ -5015,28 +5068,38 @@ parameters and with <code>undefined</code> as its <code>this</code> value.
 <a href="#n_api_napi_threadsafe_function_call_js"><code>napi_threadsafe_function_call_js</code></a> provides more details.</li>
 <li><code>[out] result</code>: The asynchronous thread-safe JavaScript function.</li>
 </ul>
-<h3>napi_get_threadsafe_function_context<span><a class="mark" href="#n_api_napi_get_threadsafe_function_context" id="n_api_napi_get_threadsafe_function_context">#</a></span></h3>
+<h4>napi_get_threadsafe_function_context<span><a class="mark" href="#n_api_napi_get_threadsafe_function_context" id="n_api_napi_get_threadsafe_function_context">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_get_threadsafe_function_context</span><span class="hljs-params">(napi_threadsafe_function func,
-                                     <span class="hljs-keyword">void</span>** result)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_get_threadsafe_function_context</span><span class="hljs-params">(napi_threadsafe_function func,
+                                     <span class="hljs-type">void</span>** result)</span>;</code></pre>
 <ul>
 <li><code>[in] func</code>: The thread-safe function for which to retrieve the context.</li>
 <li><code>[out] result</code>: The location where to store the context.</li>
 </ul>
 <p>This API may be called from any thread which makes use of <code>func</code>.</p>
-<h3>napi_call_threadsafe_function<span><a class="mark" href="#n_api_napi_call_threadsafe_function" id="n_api_napi_call_threadsafe_function">#</a></span></h3>
+<h4>napi_call_threadsafe_function<span><a class="mark" href="#n_api_napi_call_threadsafe_function" id="n_api_napi_call_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.6.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.5.0</td>
+<td><p>Support for <code>napi_would_deadlock</code> has been reverted.</p></td></tr>
+<tr><td>v14.1.0</td>
+<td><p>Return <code>napi_would_deadlock</code> when called with <code>napi_tsfn_blocking</code> from the main thread or a worker thread and the queue is full.</p></td></tr>
+<tr><td>v10.6.0</td>
+<td><p><span>Added in: v10.6.0</span></p></td></tr>
+</tbody></table>
+</details>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_call_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func,
-                              <span class="hljs-keyword">void</span>* data,
-                              napi_threadsafe_function_call_mode is_blocking)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_call_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func,
+                              <span class="hljs-type">void</span>* data,
+                              napi_threadsafe_function_call_mode is_blocking)</span>;</code></pre>
 <ul>
 <li><code>[in] func</code>: The asynchronous thread-safe JavaScript function to invoke.</li>
 <li><code>[in] data</code>: Data to send into JavaScript via the callback <code>call_js_cb</code>
@@ -5046,17 +5109,20 @@ indicate that the call should block if the queue is full or
 <code>napi_tsfn_nonblocking</code> to indicate that the call should return immediately
 with a status of <code>napi_queue_full</code> whenever the queue is full.</li>
 </ul>
+<p>This API should not be called with <code>napi_tsfn_blocking</code> from a JavaScript
+thread, because, if the queue is full, it may cause the JavaScript thread to
+deadlock.</p>
 <p>This API will return <code>napi_closing</code> if <code>napi_release_threadsafe_function()</code> was
 called with <code>abort</code> set to <code>napi_tsfn_abort</code> from any thread. The value is only
 added to the queue if the API returns <code>napi_ok</code>.</p>
 <p>This API may be called from any thread which makes use of <code>func</code>.</p>
-<h3>napi_acquire_threadsafe_function<span><a class="mark" href="#n_api_napi_acquire_threadsafe_function" id="n_api_napi_acquire_threadsafe_function">#</a></span></h3>
+<h4>napi_acquire_threadsafe_function<span><a class="mark" href="#n_api_napi_acquire_threadsafe_function" id="n_api_napi_acquire_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_acquire_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_acquire_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func)</span>;</code></pre>
 <ul>
 <li><code>[in] func</code>: The asynchronous thread-safe JavaScript function to start making
 use of.</li>
@@ -5066,14 +5132,14 @@ function APIs to indicate that it will be making use of <code>func</code>. This
 <code>func</code> from being destroyed when all other threads have stopped making use of
 it.</p>
 <p>This API may be called from any thread which will start making use of <code>func</code>.</p>
-<h3>napi_release_threadsafe_function<span><a class="mark" href="#n_api_napi_release_threadsafe_function" id="n_api_napi_release_threadsafe_function">#</a></span></h3>
+<h4>napi_release_threadsafe_function<span><a class="mark" href="#n_api_napi_release_threadsafe_function" id="n_api_napi_release_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_release_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func,
-                                 napi_threadsafe_function_release_mode mode)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_release_threadsafe_function</span><span class="hljs-params">(napi_threadsafe_function func,
+                                 napi_threadsafe_function_release_mode mode)</span>;</code></pre>
 <ul>
 <li><code>[in] func</code>: The asynchronous thread-safe JavaScript function whose reference
 count to decrement.</li>
@@ -5089,13 +5155,13 @@ values will be placed in the queue.</li>
 to any thread-safe APIs after having called this API has undefined results, as
 <code>func</code> may have been destroyed.</p>
 <p>This API may be called from any thread which will stop making use of <code>func</code>.</p>
-<h3>napi_ref_threadsafe_function<span><a class="mark" href="#n_api_napi_ref_threadsafe_function" id="n_api_napi_ref_threadsafe_function">#</a></span></h3>
+<h4>napi_ref_threadsafe_function<span><a class="mark" href="#n_api_napi_ref_threadsafe_function" id="n_api_napi_ref_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_ref_threadsafe_function</span><span class="hljs-params">(napi_env env, napi_threadsafe_function func)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_ref_threadsafe_function</span><span class="hljs-params">(napi_env env, napi_threadsafe_function func)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] func</code>: The thread-safe function to reference.</li>
@@ -5108,13 +5174,13 @@ able to be destroyed nor does <code>napi_ref_threadsafe_function</code> prevent
 being destroyed. <code>napi_acquire_threadsafe_function</code> and
 <code>napi_release_threadsafe_function</code> are available for that purpose.</p>
 <p>This API may only be called from the main thread.</p>
-<h3>napi_unref_threadsafe_function<span><a class="mark" href="#n_api_napi_unref_threadsafe_function" id="n_api_napi_unref_threadsafe_function">#</a></span></h3>
+<h4>napi_unref_threadsafe_function<span><a class="mark" href="#n_api_napi_unref_threadsafe_function" id="n_api_napi_unref_threadsafe_function">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 <span>N-API version: 4</span>
 </div>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">napi_unref_threadsafe_function</span><span class="hljs-params">(napi_env env, napi_threadsafe_function func)</span></span>;</code></pre>
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">napi_unref_threadsafe_function</span><span class="hljs-params">(napi_env env, napi_threadsafe_function func)</span>;</code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
 <li><code>[in] func</code>: The thread-safe function to unreference.</li>
@@ -5123,14 +5189,14 @@ being destroyed. <code>napi_acquire_threadsafe_function</code> and
 may exit before <code>func</code> is destroyed. Similar to <a href="https://docs.libuv.org/en/v1.x/handle.html#c.uv_unref"><code>uv_unref</code></a> it is also
 idempotent.</p>
 <p>This API may only be called from the main thread.</p>
-<h2>Miscellaneous utilities<span><a class="mark" href="#n_api_miscellaneous_utilities" id="n_api_miscellaneous_utilities">#</a></span></h2>
-<h2>node_api_get_module_file_name<span><a class="mark" href="#n_api_node_api_get_module_file_name" id="n_api_node_api_get_module_file_name">#</a></span></h2>
+</section><section><h3>Miscellaneous utilities<span><a class="mark" href="#n_api_miscellaneous_utilities" id="n_api_miscellaneous_utilities">#</a></span></h3>
+</section><section><h3>node_api_get_module_file_name<span><a class="mark" href="#n_api_node_api_get_module_file_name" id="n_api_node_api_get_module_file_name">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.22.0</span>
+<span>Added in: v14.18.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<pre><code class="language-c"><span class="hljs-function">NAPI_EXTERN napi_status
-<span class="hljs-title">node_api_get_module_file_name</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>** result)</span></span>;
+<pre><code class="language-c">NAPI_EXTERN napi_status
+<span class="hljs-title function_">node_api_get_module_file_name</span><span class="hljs-params">(napi_env env, <span class="hljs-keyword">const</span> <span class="hljs-type">char</span>** result)</span>;
 </code></pre>
 <ul>
 <li><code>[in] env</code>: The environment that the API is invoked under.</li>
@@ -5140,10 +5206,46 @@ file system it will start with <code>file://</code>. The string is null-terminat
 owned by <code>env</code> and must thus not be modified or freed.</li>
 </ul>
 <p><code>result</code> may be an empty string if the add-on loading process fails to establish
-the add-on's file name during loading.</p>
+the add-on's file name during loading.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/n-api.json b/doc/api/n-api.json
index e7e626e223156d54f7f1ab1e8db33e031794ce3f..83dfab4745646b4fa8a2ac4005588aa1c3a6a14f 100644
--- a/doc/api/n-api.json
+++ b/doc/api/n-api.json
@@ -6,25 +6,25 @@
   "stabilityText": "Stable",
   "miscs": [
     {
-      "textRaw": "N-API",
-      "name": "N-API",
+      "textRaw": "Node-API",
+      "name": "Node-API",
       "introduced_in": "v8.0.0",
       "type": "misc",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p>N-API (pronounced N as in the letter, followed by API)\nis an API for building native Addons. It is independent from\nthe underlying JavaScript runtime (for example, V8) and is maintained as part of\nNode.js itself. This API will be Application Binary Interface (ABI) stable\nacross versions of Node.js. It is intended to insulate Addons from\nchanges in the underlying JavaScript engine and allow modules\ncompiled for one major version to run on later major versions of Node.js without\nrecompilation. The <a href=\"https://nodejs.org/en/docs/guides/abi-stability/\">ABI Stability</a> guide provides a more in-depth explanation.</p>\n<p>Addons are built/packaged with the same approach/tools outlined in the section\ntitled <a href=\"addons.html\">C++ Addons</a>. The only difference is the set of APIs that are used by\nthe native code. Instead of using the V8 or <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a>\nAPIs, the functions available in the N-API are used.</p>\n<p>APIs exposed by N-API are generally used to create and manipulate\nJavaScript values. Concepts and operations generally map to ideas specified\nin the ECMA-262 Language Specification. The APIs have the following\nproperties:</p>\n<ul>\n<li>All N-API calls return a status code of type <code>napi_status</code>. This\nstatus indicates whether the API call succeeded or failed.</li>\n<li>The API's return value is passed via an out parameter.</li>\n<li>All JavaScript values are abstracted behind an opaque type named\n<code>napi_value</code>.</li>\n<li>In case of an error status code, additional information can be obtained\nusing <code>napi_get_last_error_info</code>. More information can be found in the error\nhandling section <a href=\"#n_api_error_handling\">Error handling</a>.</li>\n</ul>\n<p>The N-API is a C API that ensures ABI stability across Node.js versions\nand different compiler levels. A C++ API can be easier to use.\nTo support using C++, the project maintains a\nC++ wrapper module called <a href=\"https://github.com/nodejs/node-addon-api\"><code>node-addon-api</code></a>.\nThis wrapper provides an inlineable C++ API. Binaries built\nwith <code>node-addon-api</code> will depend on the symbols for the N-API C-based\nfunctions exported by Node.js. <code>node-addon-api</code> is a more\nefficient way to write code that calls N-API. Take, for example, the\nfollowing <code>node-addon-api</code> code. The first section shows the\n<code>node-addon-api</code> code and the second section shows what actually gets\nused in the addon.</p>\n<pre><code class=\"language-cpp\">Object obj = Object::New(env);\nobj[\"foo\"] = String::New(env, \"bar\");\n</code></pre>\n<pre><code class=\"language-cpp\">napi_status status;\nnapi_value object, string;\nstatus = napi_create_object(env, &#x26;object);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n\nstatus = napi_create_string_utf8(env, \"bar\", NAPI_AUTO_LENGTH, &#x26;string);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n\nstatus = napi_set_named_property(env, object, \"foo\", string);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n</code></pre>\n<p>The end result is that the addon only uses the exported C APIs. As a result,\nit still gets the benefits of the ABI stability provided by the C API.</p>\n<p>When using <code>node-addon-api</code> instead of the C APIs, start with the API <a href=\"https://github.com/nodejs/node-addon-api#api-documentation\">docs</a>\nfor <code>node-addon-api</code>.</p>\n<p>The <a href=\"https://nodejs.github.io/node-addon-examples/\">N-API Resource</a> offers an\nexcellent orientation and tips for developers just getting started with N-API\nand <code>node-addon-api</code>.</p>",
+      "desc": "<p>Node-API (formerly N-API) is an API for building native Addons. It is\nindependent from the underlying JavaScript runtime (for example, V8) and is\nmaintained as part of Node.js itself. This API will be Application Binary\nInterface (ABI) stable across versions of Node.js. It is intended to insulate\naddons from changes in the underlying JavaScript engine and allow modules\ncompiled for one major version to run on later major versions of Node.js without\nrecompilation. The <a href=\"https://nodejs.org/en/docs/guides/abi-stability/\">ABI Stability</a> guide provides a more in-depth explanation.</p>\n<p>Addons are built/packaged with the same approach/tools outlined in the section\ntitled <a href=\"addons.html\">C++ Addons</a>. The only difference is the set of APIs that are used by\nthe native code. Instead of using the V8 or <a href=\"https://github.com/nodejs/nan\">Native Abstractions for Node.js</a>\nAPIs, the functions available in Node-API are used.</p>\n<p>APIs exposed by Node-API are generally used to create and manipulate\nJavaScript values. Concepts and operations generally map to ideas specified\nin the ECMA-262 Language Specification. The APIs have the following\nproperties:</p>\n<ul>\n<li>All Node-API calls return a status code of type <code>napi_status</code>. This\nstatus indicates whether the API call succeeded or failed.</li>\n<li>The API's return value is passed via an out parameter.</li>\n<li>All JavaScript values are abstracted behind an opaque type named\n<code>napi_value</code>.</li>\n<li>In case of an error status code, additional information can be obtained\nusing <code>napi_get_last_error_info</code>. More information can be found in the error\nhandling section <a href=\"#n_api_error_handling\">Error handling</a>.</li>\n</ul>\n<p>Node-API is a C API that ensures ABI stability across Node.js versions\nand different compiler levels. A C++ API can be easier to use.\nTo support using C++, the project maintains a\nC++ wrapper module called <a href=\"https://github.com/nodejs/node-addon-api\"><code>node-addon-api</code></a>.\nThis wrapper provides an inlineable C++ API. Binaries built\nwith <code>node-addon-api</code> will depend on the symbols for the Node-API C-based\nfunctions exported by Node.js. <code>node-addon-api</code> is a more\nefficient way to write code that calls Node-API. Take, for example, the\nfollowing <code>node-addon-api</code> code. The first section shows the\n<code>node-addon-api</code> code and the second section shows what actually gets\nused in the addon.</p>\n<pre><code class=\"language-cpp\">Object obj = Object::New(env);\nobj[\"foo\"] = String::New(env, \"bar\");\n</code></pre>\n<pre><code class=\"language-cpp\">napi_status status;\nnapi_value object, string;\nstatus = napi_create_object(env, &#x26;object);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n\nstatus = napi_create_string_utf8(env, \"bar\", NAPI_AUTO_LENGTH, &#x26;string);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n\nstatus = napi_set_named_property(env, object, \"foo\", string);\nif (status != napi_ok) {\n  napi_throw_error(env, ...);\n  return;\n}\n</code></pre>\n<p>The end result is that the addon only uses the exported C APIs. As a result,\nit still gets the benefits of the ABI stability provided by the C API.</p>\n<p>When using <code>node-addon-api</code> instead of the C APIs, start with the API <a href=\"https://github.com/nodejs/node-addon-api#api-documentation\">docs</a>\nfor <code>node-addon-api</code>.</p>\n<p>The <a href=\"https://nodejs.github.io/node-addon-examples/\">Node-API Resource</a> offers\nan excellent orientation and tips for developers just getting started with\nNode-API and <code>node-addon-api</code>.</p>",
       "miscs": [
         {
           "textRaw": "Implications of ABI stability",
           "name": "implications_of_abi_stability",
-          "desc": "<p>Although N-API provides an ABI stability guarantee, other parts of Node.js do\nnot, and any external libraries used from the addon may not. In particular,\nnone of the following APIs provide an ABI stability guarantee across major\nversions:</p>\n<ul>\n<li>\n<p>the Node.js C++ APIs available via any of</p>\n<pre><code class=\"language-cpp\">#include &#x3C;node.h>\n#include &#x3C;node_buffer.h>\n#include &#x3C;node_version.h>\n#include &#x3C;node_object_wrap.h>\n</code></pre>\n</li>\n<li>\n<p>the libuv APIs which are also included with Node.js and available via</p>\n<pre><code class=\"language-cpp\">#include &#x3C;uv.h>\n</code></pre>\n</li>\n<li>\n<p>the V8 API available via</p>\n<pre><code class=\"language-cpp\">#include &#x3C;v8.h>\n</code></pre>\n</li>\n</ul>\n<p>Thus, for an addon to remain ABI-compatible across Node.js major versions, it\nmust use N-API exclusively by restricting itself to using</p>\n<pre><code class=\"language-c\">#include &#x3C;node_api.h>\n</code></pre>\n<p>and by checking, for all external libraries that it uses, that the external\nlibrary makes ABI stability guarantees similar to N-API.</p>",
+          "desc": "<p>Although Node-API provides an ABI stability guarantee, other parts of Node.js do\nnot, and any external libraries used from the addon may not. In particular,\nnone of the following APIs provide an ABI stability guarantee across major\nversions:</p>\n<ul>\n<li>\n<p>the Node.js C++ APIs available via any of</p>\n<pre><code class=\"language-cpp\">#include &#x3C;node.h>\n#include &#x3C;node_buffer.h>\n#include &#x3C;node_version.h>\n#include &#x3C;node_object_wrap.h>\n</code></pre>\n</li>\n<li>\n<p>the libuv APIs which are also included with Node.js and available via</p>\n<pre><code class=\"language-cpp\">#include &#x3C;uv.h>\n</code></pre>\n</li>\n<li>\n<p>the V8 API available via</p>\n<pre><code class=\"language-cpp\">#include &#x3C;v8.h>\n</code></pre>\n</li>\n</ul>\n<p>Thus, for an addon to remain ABI-compatible across Node.js major versions, it\nmust use Node-API exclusively by restricting itself to using</p>\n<pre><code class=\"language-c\">#include &#x3C;node_api.h>\n</code></pre>\n<p>and by checking, for all external libraries that it uses, that the external\nlibrary makes ABI stability guarantees similar to Node-API.</p>",
           "type": "misc",
           "displayName": "Implications of ABI stability"
         },
         {
           "textRaw": "Building",
           "name": "building",
-          "desc": "<p>Unlike modules written in JavaScript, developing and deploying Node.js\nnative addons using N-API requires an additional set of tools. Besides the\nbasic tools required to develop for Node.js, the native addon developer\nrequires a toolchain that can compile C and C++ code into a binary. In\naddition, depending upon how the native addon is deployed, the <em>user</em> of\nthe native addon will also need to have a C/C++ toolchain installed.</p>\n<p>For Linux developers, the necessary C/C++ toolchain packages are readily\navailable. <a href=\"https://gcc.gnu.org\">GCC</a> is widely used in the Node.js community to build and\ntest across a variety of platforms. For many developers, the <a href=\"https://llvm.org\">LLVM</a>\ncompiler infrastructure is also a good choice.</p>\n<p>For Mac developers, <a href=\"https://developer.apple.com/xcode/\">Xcode</a> offers all the required compiler tools.\nHowever, it is not necessary to install the entire Xcode IDE. The following\ncommand installs the necessary toolchain:</p>\n<pre><code class=\"language-bash\">xcode-select --install\n</code></pre>\n<p>For Windows developers, <a href=\"https://visualstudio.microsoft.com\">Visual Studio</a> offers all the required compiler\ntools. However, it is not necessary to install the entire Visual Studio\nIDE. The following command installs the necessary toolchain:</p>\n<pre><code class=\"language-bash\">npm install --global windows-build-tools\n</code></pre>\n<p>The sections below describe the additional tools available for developing\nand deploying Node.js native addons.</p>",
+          "desc": "<p>Unlike modules written in JavaScript, developing and deploying Node.js\nnative addons using Node-API requires an additional set of tools. Besides the\nbasic tools required to develop for Node.js, the native addon developer\nrequires a toolchain that can compile C and C++ code into a binary. In\naddition, depending upon how the native addon is deployed, the <em>user</em> of\nthe native addon will also need to have a C/C++ toolchain installed.</p>\n<p>For Linux developers, the necessary C/C++ toolchain packages are readily\navailable. <a href=\"https://gcc.gnu.org\">GCC</a> is widely used in the Node.js community to build and\ntest across a variety of platforms. For many developers, the <a href=\"https://llvm.org\">LLVM</a>\ncompiler infrastructure is also a good choice.</p>\n<p>For Mac developers, <a href=\"https://developer.apple.com/xcode/\">Xcode</a> offers all the required compiler tools.\nHowever, it is not necessary to install the entire Xcode IDE. The following\ncommand installs the necessary toolchain:</p>\n<pre><code class=\"language-bash\">xcode-select --install\n</code></pre>\n<p>For Windows developers, <a href=\"https://visualstudio.microsoft.com\">Visual Studio</a> offers all the required compiler\ntools. However, it is not necessary to install the entire Visual Studio\nIDE. The following command installs the necessary toolchain:</p>\n<pre><code class=\"language-bash\">npm install --global windows-build-tools\n</code></pre>\n<p>The sections below describe the additional tools available for developing\nand deploying Node.js native addons.</p>",
           "modules": [
             {
               "textRaw": "Build tools",
@@ -34,7 +34,7 @@
                 {
                   "textRaw": "node-gyp",
                   "name": "node-gyp",
-                  "desc": "<p><a href=\"https://github.com/nodejs/node-gyp\">node-gyp</a> is a build system based on Google's <a href=\"https://gyp.gsrc.io\">GYP</a> tool and comes\nbundled with npm. GYP, and therefore node-gyp, requires that Python be\ninstalled.</p>\n<p>Historically, node-gyp has been the tool of choice for building native\naddons. It has widespread adoption and documentation. However, some\ndevelopers have run into limitations in node-gyp.</p>",
+                  "desc": "<p><a href=\"https://github.com/nodejs/node-gyp\">node-gyp</a> is a build system based on the <a href=\"https://github.com/nodejs/gyp-next\">gyp-next</a> fork of\nGoogle's <a href=\"https://gyp.gsrc.io\">GYP</a> tool and comes bundled with npm. GYP, and therefore node-gyp,\nrequires that Python be installed.</p>\n<p>Historically, node-gyp has been the tool of choice for building native\naddons. It has widespread adoption and documentation. However, some\ndevelopers have run into limitations in node-gyp.</p>",
                   "type": "module",
                   "displayName": "node-gyp"
                 }
@@ -86,35 +86,36 @@
         {
           "textRaw": "Usage",
           "name": "usage",
-          "desc": "<p>In order to use the N-API functions, include the file <a href=\"https://github.com/nodejs/node/blob/master/src/node_api.h\"><code>node_api.h</code></a> which is\nlocated in the src directory in the node development tree:</p>\n<pre><code class=\"language-c\">#include &#x3C;node_api.h>\n</code></pre>\n<p>This will opt into the default <code>NAPI_VERSION</code> for the given release of Node.js.\nIn order to ensure compatibility with specific versions of N-API, the version\ncan be specified explicitly when including the header:</p>\n<pre><code class=\"language-c\">#define NAPI_VERSION 3\n#include &#x3C;node_api.h>\n</code></pre>\n<p>This restricts the N-API surface to just the functionality that was available in\nthe specified (and earlier) versions.</p>\n<p>Some of the N-API surface is experimental and requires explicit opt-in:</p>\n<pre><code class=\"language-c\">#define NAPI_EXPERIMENTAL\n#include &#x3C;node_api.h>\n</code></pre>\n<p>In this case the entire API surface, including any experimental APIs, will be\navailable to the module code.</p>",
+          "desc": "<p>In order to use the Node-API functions, include the file <a href=\"https://github.com/nodejs/node/blob/HEAD/src/node_api.h\"><code>node_api.h</code></a> which\nis located in the src directory in the node development tree:</p>\n<pre><code class=\"language-c\">#include &#x3C;node_api.h>\n</code></pre>\n<p>This will opt into the default <code>NAPI_VERSION</code> for the given release of Node.js.\nIn order to ensure compatibility with specific versions of Node-API, the version\ncan be specified explicitly when including the header:</p>\n<pre><code class=\"language-c\">#define NAPI_VERSION 3\n#include &#x3C;node_api.h>\n</code></pre>\n<p>This restricts the Node-API surface to just the functionality that was available\nin the specified (and earlier) versions.</p>\n<p>Some of the Node-API surface is experimental and requires explicit opt-in:</p>\n<pre><code class=\"language-c\">#define NAPI_EXPERIMENTAL\n#include &#x3C;node_api.h>\n</code></pre>\n<p>In this case the entire API surface, including any experimental APIs, will be\navailable to the module code.</p>",
           "type": "misc",
           "displayName": "Usage"
         },
         {
-          "textRaw": "N-API version matrix",
-          "name": "n-api_version_matrix",
-          "desc": "<p>N-API versions are additive and versioned independently from Node.js.\nVersion 4 is an extension to version 3 in that it has all of the APIs\nfrom version 3 with some additions. This means that it is not necessary\nto recompile for new versions of Node.js which are\nlisted as supporting a later version.</p>\n<table>\n<thead>\n<tr>\n<th></th>\n<th>1</th>\n<th>2</th>\n<th>3</th>\n<th>4</th>\n<th>5</th>\n<th>6</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>v6.x</td>\n<td></td>\n<td></td>\n<td>v6.14.2*</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>v8.x</td>\n<td>v8.0.0*</td>\n<td>v8.10.0*</td>\n<td>v8.11.2</td>\n<td>v8.16.0</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>v9.x</td>\n<td>v9.0.0*</td>\n<td>v9.3.0*</td>\n<td>v9.11.0*</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>v10.x</td>\n<td>v10.0.0</td>\n<td>v10.0.0</td>\n<td>v10.0.0</td>\n<td>v10.16.0</td>\n<td>v10.17.0</td>\n<td>v10.20.0</td>\n</tr>\n<tr>\n<td>v11.x</td>\n<td>v11.0.0</td>\n<td>v11.0.0</td>\n<td>v11.0.0</td>\n<td>v11.8.0</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>v12.x</td>\n<td>v12.0.0</td>\n<td>v12.0.0</td>\n<td>v12.0.0</td>\n<td>v12.0.0</td>\n<td>v12.11.0</td>\n<td>v12.17.0</td>\n</tr>\n<tr>\n<td>v13.x</td>\n<td>v13.0.0</td>\n<td>v13.0.0</td>\n<td>v13.0.0</td>\n<td>v13.0.0</td>\n<td>v13.0.0</td>\n<td></td>\n</tr>\n<tr>\n<td>v14.x</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n<td>v14.0.0</td>\n</tr>\n</tbody>\n</table>\n<p>* Indicates that the N-API version was released as experimental</p>\n<p>Each API documented for N-API will have a header named <code>added in:</code>, and APIs\nwhich are stable will have the additional header <code>N-API version:</code>.\nAPIs are directly usable when using a Node.js version which supports\nthe N-API version shown in <code>N-API version:</code> or higher.\nWhen using a Node.js version that does not support the\n<code>N-API version:</code> listed or if there is no <code>N-API version:</code> listed,\nthen the API will only be available if\n<code>#define NAPI_EXPERIMENTAL</code> precedes the inclusion of <code>node_api.h</code>\nor <code>js_native_api.h</code>. If an API appears not to be available on\na version of Node.js which is later than the one shown in <code>added in:</code> then\nthis is most likely the reason for the apparent absence.</p>\n<p>The N-APIs associated strictly with accessing ECMAScript features from native\ncode can be found separately in <code>js_native_api.h</code> and <code>js_native_api_types.h</code>.\nThe APIs defined in these headers are included in <code>node_api.h</code> and\n<code>node_api_types.h</code>. The headers are structured in this way in order to allow\nimplementations of N-API outside of Node.js. For those implementations the\nNode.js specific APIs may not be applicable.</p>\n<p>The Node.js-specific parts of an addon can be separated from the code that\nexposes the actual functionality to the JavaScript environment so that the\nlatter may be used with multiple implementations of N-API. In the example below,\n<code>addon.c</code> and <code>addon.h</code> refer only to <code>js_native_api.h</code>. This ensures that\n<code>addon.c</code> can be reused to compile against either the Node.js implementation of\nN-API or any implementation of N-API outside of Node.js.</p>\n<p><code>addon_node.c</code> is a separate file that contains the Node.js specific entry point\nto the addon and which instantiates the addon by calling into <code>addon.c</code> when the\naddon is loaded into a Node.js environment.</p>\n<pre><code class=\"language-c\">// addon.h\n#ifndef _ADDON_H_\n#define _ADDON_H_\n#include &#x3C;js_native_api.h>\nnapi_value create_addon(napi_env env);\n#endif  // _ADDON_H_\n</code></pre>\n<pre><code class=\"language-c\">// addon.c\n#include \"addon.h\"\n\n#define NAPI_CALL(env, call)                                      \\\n  do {                                                            \\\n    napi_status status = (call);                                  \\\n    if (status != napi_ok) {                                      \\\n      const napi_extended_error_info* error_info = NULL;          \\\n      napi_get_last_error_info((env), &#x26;error_info);               \\\n      bool is_pending;                                            \\\n      napi_is_exception_pending((env), &#x26;is_pending);              \\\n      if (!is_pending) {                                          \\\n        const char* message = (error_info->error_message == NULL) \\\n            ? \"empty error message\"                               \\\n            : error_info->error_message;                          \\\n        napi_throw_error((env), NULL, message);                   \\\n        return NULL;                                              \\\n      }                                                           \\\n    }                                                             \\\n  } while(0)\n\nstatic napi_value\nDoSomethingUseful(napi_env env, napi_callback_info info) {\n  // Do something useful.\n  return NULL;\n}\n\nnapi_value create_addon(napi_env env) {\n  napi_value result;\n  NAPI_CALL(env, napi_create_object(env, &#x26;result));\n\n  napi_value exported_function;\n  NAPI_CALL(env, napi_create_function(env,\n                                      \"doSomethingUseful\",\n                                      NAPI_AUTO_LENGTH,\n                                      DoSomethingUseful,\n                                      NULL,\n                                      &#x26;exported_function));\n\n  NAPI_CALL(env, napi_set_named_property(env,\n                                         result,\n                                         \"doSomethingUseful\",\n                                         exported_function));\n\n  return result;\n}\n</code></pre>\n<pre><code class=\"language-c\">// addon_node.c\n#include &#x3C;node_api.h>\n#include \"addon.h\"\n\nNAPI_MODULE_INIT() {\n  // This function body is expected to return a `napi_value`.\n  // The variables `napi_env env` and `napi_value exports` may be used within\n  // the body, as they are provided by the definition of `NAPI_MODULE_INIT()`.\n  return create_addon(env);\n}\n</code></pre>",
+          "textRaw": "Node-API version matrix",
+          "name": "node-api_version_matrix",
+          "desc": "<p>Node-API versions are additive and versioned independently from Node.js.\nVersion 4 is an extension to version 3 in that it has all of the APIs\nfrom version 3 with some additions. This means that it is not necessary\nto recompile for new versions of Node.js which are\nlisted as supporting a later version.</p>\n<!-- For accessibility purposes, this table needs row headers. That means we\n     can't do it in markdown. Hence, the raw HTML. -->\n<table>\n  <tr>\n    <td></td>\n    <th scope=\"col\">1</th>\n    <th scope=\"col\">2</th>\n    <th scope=\"col\">3</th>\n  </tr>\n  <tr>\n    <th scope=\"row\">v6.x</th>\n    <td></td>\n    <td></td>\n    <td>v6.14.2*</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v8.x</th>\n    <td>v8.6.0**</td>\n    <td>v8.10.0*</td>\n    <td>v8.11.2</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v9.x</th>\n    <td>v9.0.0*</td>\n    <td>v9.3.0*</td>\n    <td>v9.11.0*</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">≥ v10.x</th>\n    <td>all releases</td>\n    <td>all releases</td>\n    <td>all releases</td>\n  </tr>\n</table>\n<table>\n  <tr>\n    <td></td>\n    <th scope=\"col\">4</th>\n    <th scope=\"col\">5</th>\n    <th scope=\"col\">6</th>\n    <th scope=\"col\">7</th>\n    <th scope=\"col\">8</th>\n  </tr>\n  <tr>\n    <th scope=\"row\">v10.x</th>\n    <td>v10.16.0</td>\n    <td>v10.17.0</td>\n    <td>v10.20.0</td>\n    <td>v10.23.0</td>\n    <td></td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v11.x</th>\n    <td>v11.8.0</td>\n    <td></td>\n    <td></td>\n    <td></td>\n    <td></td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v12.x</th>\n    <td>v12.0.0</td>\n    <td>v12.11.0</td>\n    <td>v12.17.0</td>\n    <td>v12.19.0</td>\n    <td>v12.22.0</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v13.x</th>\n    <td>v13.0.0</td>\n    <td>v13.0.0</td>\n    <td></td>\n    <td></td>\n    <td></td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v14.x</th>\n    <td>v14.0.0</td>\n    <td>v14.0.0</td>\n    <td>v14.0.0</td>\n    <td>v14.12.0</td>\n    <td>v14.17.0</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v15.x</th>\n    <td>v15.0.0</td>\n    <td>v15.0.0</td>\n    <td>v15.0.0</td>\n    <td>v15.0.0</td>\n    <td>v15.12.0</td>\n  </tr>\n  <tr>\n    <th scope=\"row\">v16.x</th>\n    <td>v16.0.0</td>\n    <td>v16.0.0</td>\n    <td>v16.0.0</td>\n    <td>v16.0.0</td>\n    <td>v16.0.0</td>\n  </tr>\n</table>\n<p>* Node-API was experimental.</p>\n<p>** Node.js 8.0.0 included Node-API as experimental. It was released as\nNode-API version 1 but continued to evolve until Node.js 8.6.0. The API is\ndifferent in versions prior to Node.js 8.6.0. We recommend Node-API version 3 or\nlater.</p>\n<p>Each API documented for Node-API will have a header named <code>added in:</code>, and APIs\nwhich are stable will have the additional header <code>Node-API version:</code>.\nAPIs are directly usable when using a Node.js version which supports\nthe Node-API version shown in <code>Node-API version:</code> or higher.\nWhen using a Node.js version that does not support the\n<code>Node-API version:</code> listed or if there is no <code>Node-API version:</code> listed,\nthen the API will only be available if\n<code>#define NAPI_EXPERIMENTAL</code> precedes the inclusion of <code>node_api.h</code>\nor <code>js_native_api.h</code>. If an API appears not to be available on\na version of Node.js which is later than the one shown in <code>added in:</code> then\nthis is most likely the reason for the apparent absence.</p>\n<p>The Node-APIs associated strictly with accessing ECMAScript features from native\ncode can be found separately in <code>js_native_api.h</code> and <code>js_native_api_types.h</code>.\nThe APIs defined in these headers are included in <code>node_api.h</code> and\n<code>node_api_types.h</code>. The headers are structured in this way in order to allow\nimplementations of Node-API outside of Node.js. For those implementations the\nNode.js specific APIs may not be applicable.</p>\n<p>The Node.js-specific parts of an addon can be separated from the code that\nexposes the actual functionality to the JavaScript environment so that the\nlatter may be used with multiple implementations of Node-API. In the example\nbelow, <code>addon.c</code> and <code>addon.h</code> refer only to <code>js_native_api.h</code>. This ensures\nthat <code>addon.c</code> can be reused to compile against either the Node.js\nimplementation of Node-API or any implementation of Node-API outside of Node.js.</p>\n<p><code>addon_node.c</code> is a separate file that contains the Node.js specific entry point\nto the addon and which instantiates the addon by calling into <code>addon.c</code> when the\naddon is loaded into a Node.js environment.</p>\n<pre><code class=\"language-c\">// addon.h\n#ifndef _ADDON_H_\n#define _ADDON_H_\n#include &#x3C;js_native_api.h>\nnapi_value create_addon(napi_env env);\n#endif  // _ADDON_H_\n</code></pre>\n<pre><code class=\"language-c\">// addon.c\n#include \"addon.h\"\n\n#define NAPI_CALL(env, call)                                      \\\n  do {                                                            \\\n    napi_status status = (call);                                  \\\n    if (status != napi_ok) {                                      \\\n      const napi_extended_error_info* error_info = NULL;          \\\n      napi_get_last_error_info((env), &#x26;error_info);               \\\n      bool is_pending;                                            \\\n      napi_is_exception_pending((env), &#x26;is_pending);              \\\n      if (!is_pending) {                                          \\\n        const char* message = (error_info->error_message == NULL) \\\n            ? \"empty error message\"                               \\\n            : error_info->error_message;                          \\\n        napi_throw_error((env), NULL, message);                   \\\n        return NULL;                                              \\\n      }                                                           \\\n    }                                                             \\\n  } while(0)\n\nstatic napi_value\nDoSomethingUseful(napi_env env, napi_callback_info info) {\n  // Do something useful.\n  return NULL;\n}\n\nnapi_value create_addon(napi_env env) {\n  napi_value result;\n  NAPI_CALL(env, napi_create_object(env, &#x26;result));\n\n  napi_value exported_function;\n  NAPI_CALL(env, napi_create_function(env,\n                                      \"doSomethingUseful\",\n                                      NAPI_AUTO_LENGTH,\n                                      DoSomethingUseful,\n                                      NULL,\n                                      &#x26;exported_function));\n\n  NAPI_CALL(env, napi_set_named_property(env,\n                                         result,\n                                         \"doSomethingUseful\",\n                                         exported_function));\n\n  return result;\n}\n</code></pre>\n<pre><code class=\"language-c\">// addon_node.c\n#include &#x3C;node_api.h>\n#include \"addon.h\"\n\nNAPI_MODULE_INIT() {\n  // This function body is expected to return a `napi_value`.\n  // The variables `napi_env env` and `napi_value exports` may be used within\n  // the body, as they are provided by the definition of `NAPI_MODULE_INIT()`.\n  return create_addon(env);\n}\n</code></pre>",
           "type": "misc",
-          "displayName": "N-API version matrix"
+          "displayName": "Node-API version matrix"
         },
         {
           "textRaw": "Environment life cycle APIs",
           "name": "environment_life_cycle_apis",
-          "desc": "<p><a href=\"https://tc39.es/ecma262/#sec-agents\">Section 8.7</a> of the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a> defines the concept\nof an \"Agent\" as a self-contained environment in which JavaScript code runs.\nMultiple such Agents may be started and terminated either concurrently or in\nsequence by the process.</p>\n<p>A Node.js environment corresponds to an ECMAScript Agent. In the main process,\nan environment is created at startup, and additional environments can be created\non separate threads to serve as <a href=\"https://nodejs.org/api/worker_threads.html\">worker threads</a>. When Node.js is embedded in\nanother application, the main thread of the application may also construct and\ndestroy a Node.js environment multiple times during the life cycle of the\napplication process such that each Node.js environment created by the\napplication may, in turn, during its life cycle create and destroy additional\nenvironments as worker threads.</p>\n<p>From the perspective of a native addon this means that the bindings it provides\nmay be called multiple times, from multiple contexts, and even concurrently from\nmultiple threads.</p>\n<p>Native addons may need to allocate global state which they use during\ntheir entire life cycle such that the state must be unique to each instance of\nthe addon.</p>\n<p>To this end, N-API provides a way to allocate data such that its life cycle is\ntied to the life cycle of the Agent.</p>",
+          "desc": "<p><a href=\"https://tc39.es/ecma262/#sec-agents\">Section 8.7</a> of the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a> defines the concept\nof an \"Agent\" as a self-contained environment in which JavaScript code runs.\nMultiple such Agents may be started and terminated either concurrently or in\nsequence by the process.</p>\n<p>A Node.js environment corresponds to an ECMAScript Agent. In the main process,\nan environment is created at startup, and additional environments can be created\non separate threads to serve as <a href=\"https://nodejs.org/api/worker_threads.html\">worker threads</a>. When Node.js is embedded in\nanother application, the main thread of the application may also construct and\ndestroy a Node.js environment multiple times during the life cycle of the\napplication process such that each Node.js environment created by the\napplication may, in turn, during its life cycle create and destroy additional\nenvironments as worker threads.</p>\n<p>From the perspective of a native addon this means that the bindings it provides\nmay be called multiple times, from multiple contexts, and even concurrently from\nmultiple threads.</p>\n<p>Native addons may need to allocate global state which they use during\ntheir entire life cycle such that the state must be unique to each instance of\nthe addon.</p>\n<p>To this end, Node-API provides a way to allocate data such that its life cycle\nis tied to the life cycle of the Agent.</p>",
           "modules": [
             {
               "textRaw": "napi_set_instance_data",
               "name": "napi_set_instance_data",
               "meta": {
                 "added": [
-                  "v12.8.0"
+                  "v12.8.0",
+                  "v10.20.0"
                 ],
                 "napiVersion": [
                   6
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_set_instance_data(napi_env env,\n                                   void* data,\n                                   napi_finalize finalize_cb,\n                                   void* finalize_hint);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] data</code>: The data item to make available to bindings of this instance.</li>\n<li><code>[in] finalize_cb</code>: The function to call when the environment is being torn\ndown. The function receives <code>data</code> so that it might free it.\n<a href=\"#n_api_napi_finalize\"><code>napi_finalize</code></a> provides more details.</li>\n<li><code>[in] finalize_hint</code>: Optional hint to pass to the finalize callback during\ncollection.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API associates <code>data</code> with the currently running Agent. <code>data</code> can later\nbe retrieved using <code>napi_get_instance_data()</code>. Any existing data associated with\nthe currently running Agent which was set by means of a previous call to\n<code>napi_set_instance_data()</code> will be overwritten. If a <code>finalize_cb</code> was provided\nby the previous call, it will not be called.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_set_instance_data(napi_env env,\n                                   void* data,\n                                   napi_finalize finalize_cb,\n                                   void* finalize_hint);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] data</code>: The data item to make available to bindings of this instance.</li>\n<li><code>[in] finalize_cb</code>: The function to call when the environment is being torn\ndown. The function receives <code>data</code> so that it might free it.\n<a href=\"#n_api_napi_finalize\"><code>napi_finalize</code></a> provides more details.</li>\n<li><code>[in] finalize_hint</code>: Optional hint to pass to the finalize callback during\ncollection.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API associates <code>data</code> with the currently running Agent. <code>data</code> can later\nbe retrieved using <code>napi_get_instance_data()</code>. Any existing data associated with\nthe currently running Agent which was set by means of a previous call to\n<code>napi_set_instance_data()</code> will be overwritten. If a <code>finalize_cb</code> was provided\nby the previous call, it will not be called.</p>",
               "type": "module",
               "displayName": "napi_set_instance_data"
             },
@@ -123,14 +124,15 @@
               "name": "napi_get_instance_data",
               "meta": {
                 "added": [
-                  "v12.8.0"
+                  "v12.8.0",
+                  "v10.20.0"
                 ],
                 "napiVersion": [
                   6
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_get_instance_data(napi_env env,\n                                   void** data);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[out] data</code>: The data item that was previously associated with the currently\nrunning Agent by a call to <code>napi_set_instance_data()</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API retrieves data that was previously associated with the currently\nrunning Agent via <code>napi_set_instance_data()</code>. If no data is set, the call will\nsucceed and <code>data</code> will be set to <code>NULL</code>.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_get_instance_data(napi_env env,\n                                   void** data);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[out] data</code>: The data item that was previously associated with the currently\nrunning Agent by a call to <code>napi_set_instance_data()</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API retrieves data that was previously associated with the currently\nrunning Agent via <code>napi_set_instance_data()</code>. If no data is set, the call will\nsucceed and <code>data</code> will be set to <code>NULL</code>.</p>",
               "type": "module",
               "displayName": "napi_get_instance_data"
             }
@@ -139,9 +141,9 @@
           "displayName": "Environment life cycle APIs"
         },
         {
-          "textRaw": "Basic N-API data types",
-          "name": "basic_n-api_data_types",
-          "desc": "<p>N-API exposes the following fundamental datatypes as abstractions that are\nconsumed by the various APIs. These APIs should be treated as opaque,\nintrospectable only with other N-API calls.</p>",
+          "textRaw": "Basic Node-API data types",
+          "name": "basic_node-api_data_types",
+          "desc": "<p>Node-API exposes the following fundamental datatypes as abstractions that are\nconsumed by the various APIs. These APIs should be treated as opaque,\nintrospectable only with other Node-API calls.</p>",
           "modules": [
             {
               "textRaw": "napi_status",
@@ -155,7 +157,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>Integral status code indicating the success or failure of a N-API call.\nCurrently, the following status codes are supported.</p>\n<pre><code class=\"language-c\">typedef enum {\n  napi_ok,\n  napi_invalid_arg,\n  napi_object_expected,\n  napi_string_expected,\n  napi_name_expected,\n  napi_function_expected,\n  napi_number_expected,\n  napi_boolean_expected,\n  napi_array_expected,\n  napi_generic_failure,\n  napi_pending_exception,\n  napi_cancelled,\n  napi_escape_called_twice,\n  napi_handle_scope_mismatch,\n  napi_callback_scope_mismatch,\n  napi_queue_full,\n  napi_closing,\n  napi_bigint_expected,\n  napi_date_expected,\n  napi_arraybuffer_expected,\n  napi_detachable_arraybuffer_expected,\n} napi_status;\n</code></pre>\n<p>If additional information is required upon an API returning a failed status,\nit can be obtained by calling <code>napi_get_last_error_info</code>.</p>",
+              "desc": "<p>Integral status code indicating the success or failure of a Node-API call.\nCurrently, the following status codes are supported.</p>\n<pre><code class=\"language-c\">typedef enum {\n  napi_ok,\n  napi_invalid_arg,\n  napi_object_expected,\n  napi_string_expected,\n  napi_name_expected,\n  napi_function_expected,\n  napi_number_expected,\n  napi_boolean_expected,\n  napi_array_expected,\n  napi_generic_failure,\n  napi_pending_exception,\n  napi_cancelled,\n  napi_escape_called_twice,\n  napi_handle_scope_mismatch,\n  napi_callback_scope_mismatch,\n  napi_queue_full,\n  napi_closing,\n  napi_bigint_expected,\n  napi_date_expected,\n  napi_arraybuffer_expected,\n  napi_detachable_arraybuffer_expected,\n  napi_would_deadlock,  /* unused */\n} napi_status;\n</code></pre>\n<p>If additional information is required upon an API returning a failed status,\nit can be obtained by calling <code>napi_get_last_error_info</code>.</p>",
               "type": "module",
               "displayName": "napi_status"
             },
@@ -171,14 +173,14 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">typedef struct {\n  const char* error_message;\n  void* engine_reserved;\n  uint32_t engine_error_code;\n  napi_status error_code;\n} napi_extended_error_info;\n</code></pre>\n<ul>\n<li><code>error_message</code>: UTF8-encoded string containing a VM-neutral description of\nthe error.</li>\n<li><code>engine_reserved</code>: Reserved for VM-specific error details. This is currently\nnot implemented for any VM.</li>\n<li><code>engine_error_code</code>: VM-specific error code. This is currently\nnot implemented for any VM.</li>\n<li><code>error_code</code>: The N-API status code that originated with the last error.</li>\n</ul>\n<p>See the <a href=\"#n_api_error_handling\">Error handling</a> section for additional information.</p>",
+              "desc": "<pre><code class=\"language-c\">typedef struct {\n  const char* error_message;\n  void* engine_reserved;\n  uint32_t engine_error_code;\n  napi_status error_code;\n} napi_extended_error_info;\n</code></pre>\n<ul>\n<li><code>error_message</code>: UTF8-encoded string containing a VM-neutral description of\nthe error.</li>\n<li><code>engine_reserved</code>: Reserved for VM-specific error details. This is currently\nnot implemented for any VM.</li>\n<li><code>engine_error_code</code>: VM-specific error code. This is currently\nnot implemented for any VM.</li>\n<li><code>error_code</code>: The Node-API status code that originated with the last error.</li>\n</ul>\n<p>See the <a href=\"#n_api_error_handling\">Error handling</a> section for additional information.</p>",
               "type": "module",
               "displayName": "napi_extended_error_info"
             },
             {
               "textRaw": "napi_env",
               "name": "napi_env",
-              "desc": "<p><code>napi_env</code> is used to represent a context that the underlying N-API\nimplementation can use to persist VM-specific state. This structure is passed\nto native functions when they're invoked, and it must be passed back when\nmaking N-API calls. Specifically, the same <code>napi_env</code> that was passed in when\nthe initial native function was called must be passed to any subsequent\nnested N-API calls. Caching the <code>napi_env</code> for the purpose of general reuse,\nand passing the <code>napi_env</code> between instances of the same addon running on\ndifferent <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads is not allowed. The <code>napi_env</code> becomes invalid\nwhen an instance of a native addon is unloaded. Notification of this event is\ndelivered through the callbacks given to <a href=\"#n_api_napi_add_env_cleanup_hook\"><code>napi_add_env_cleanup_hook</code></a> and\n<a href=\"#n_api_napi_set_instance_data\"><code>napi_set_instance_data</code></a>.</p>",
+              "desc": "<p><code>napi_env</code> is used to represent a context that the underlying Node-API\nimplementation can use to persist VM-specific state. This structure is passed\nto native functions when they're invoked, and it must be passed back when\nmaking Node-API calls. Specifically, the same <code>napi_env</code> that was passed in when\nthe initial native function was called must be passed to any subsequent\nnested Node-API calls. Caching the <code>napi_env</code> for the purpose of general reuse,\nand passing the <code>napi_env</code> between instances of the same addon running on\ndifferent <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads is not allowed. The <code>napi_env</code> becomes invalid\nwhen an instance of a native addon is unloaded. Notification of this event is\ndelivered through the callbacks given to <a href=\"#n_api_napi_add_env_cleanup_hook\"><code>napi_add_env_cleanup_hook</code></a> and\n<a href=\"#n_api_napi_set_instance_data\"><code>napi_set_instance_data</code></a>.</p>",
               "type": "module",
               "displayName": "napi_env"
             },
@@ -238,13 +240,13 @@
               "displayName": "napi_threadsafe_function_call_mode"
             },
             {
-              "textRaw": "N-API memory management types",
-              "name": "n-api_memory_management_types",
+              "textRaw": "Node-API memory management types",
+              "name": "node-api_memory_management_types",
               "modules": [
                 {
                   "textRaw": "napi_handle_scope",
                   "name": "napi_handle_scope",
-                  "desc": "<p>This is an abstraction used to control and modify the lifetime of objects\ncreated within a particular scope. In general, N-API values are created within\nthe context of a handle scope. When a native method is called from\nJavaScript, a default handle scope will exist. If the user does not explicitly\ncreate a new handle scope, N-API values will be created in the default handle\nscope. For any invocations of code outside the execution of a native method\n(for instance, during a libuv callback invocation), the module is required to\ncreate a scope before invoking any functions that can result in the creation\nof JavaScript values.</p>\n<p>Handle scopes are created using <a href=\"#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and are destroyed\nusing <a href=\"#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a>. Closing the scope can indicate to the GC\nthat all <code>napi_value</code>s created during the lifetime of the handle scope are no\nlonger referenced from the current stack frame.</p>\n<p>For more details, review the <a href=\"#n_api_object_lifetime_management\">Object lifetime management</a>.</p>",
+                  "desc": "<p>This is an abstraction used to control and modify the lifetime of objects\ncreated within a particular scope. In general, Node-API values are created\nwithin the context of a handle scope. When a native method is called from\nJavaScript, a default handle scope will exist. If the user does not explicitly\ncreate a new handle scope, Node-API values will be created in the default handle\nscope. For any invocations of code outside the execution of a native method\n(for instance, during a libuv callback invocation), the module is required to\ncreate a scope before invoking any functions that can result in the creation\nof JavaScript values.</p>\n<p>Handle scopes are created using <a href=\"#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and are destroyed\nusing <a href=\"#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a>. Closing the scope can indicate to the GC\nthat all <code>napi_value</code>s created during the lifetime of the handle scope are no\nlonger referenced from the current stack frame.</p>\n<p>For more details, review the <a href=\"#n_api_object_lifetime_management\">Object lifetime management</a>.</p>",
                   "type": "module",
                   "displayName": "napi_handle_scope"
                 },
@@ -285,6 +287,7 @@
                   "name": "napi_type_tag",
                   "meta": {
                     "added": [
+                      "v14.8.0",
                       "v12.19.0"
                     ],
                     "napiVersion": [
@@ -301,7 +304,7 @@
                   "name": "napi_async_cleanup_hook_handle",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.10.0"
                     ],
                     "changes": []
                   },
@@ -311,11 +314,11 @@
                 }
               ],
               "type": "module",
-              "displayName": "N-API memory management types"
+              "displayName": "Node-API memory management types"
             },
             {
-              "textRaw": "N-API callback types",
-              "name": "n-api_callback_types",
+              "textRaw": "Node-API callback types",
+              "name": "node-api_callback_types",
               "modules": [
                 {
                   "textRaw": "napi_callback_info",
@@ -345,7 +348,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Function pointer type for user-provided native functions which are to be\nexposed to JavaScript via N-API. Callback functions should satisfy the\nfollowing signature:</p>\n<pre><code class=\"language-c\">typedef napi_value (*napi_callback)(napi_env, napi_callback_info);\n</code></pre>\n<p>Unless for reasons discussed in <a href=\"#n_api_object_lifetime_management\">Object Lifetime Management</a>, creating a\nhandle and/or callback scope inside a <code>napi_callback</code> is not necessary.</p>",
+                  "desc": "<p>Function pointer type for user-provided native functions which are to be\nexposed to JavaScript via Node-API. Callback functions should satisfy the\nfollowing signature:</p>\n<pre><code class=\"language-c\">typedef napi_value (*napi_callback)(napi_env, napi_callback_info);\n</code></pre>\n<p>Unless for reasons discussed in <a href=\"#n_api_object_lifetime_management\">Object Lifetime Management</a>, creating a\nhandle and/or callback scope inside a <code>napi_callback</code> is not necessary.</p>",
                   "type": "module",
                   "displayName": "napi_callback"
                 },
@@ -377,7 +380,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Function pointer used with functions that support asynchronous\noperations. Callback functions must satisfy the following signature:</p>\n<pre><code class=\"language-c\">typedef void (*napi_async_execute_callback)(napi_env env, void* data);\n</code></pre>\n<p>Implementations of this function must avoid making N-API calls that execute\nJavaScript or interact with JavaScript objects. N-API calls should be in the\n<code>napi_async_complete_callback</code> instead. Do not use the <code>napi_env</code> parameter as\nit will likely result in execution of JavaScript.</p>",
+                  "desc": "<p>Function pointer used with functions that support asynchronous\noperations. Callback functions must satisfy the following signature:</p>\n<pre><code class=\"language-c\">typedef void (*napi_async_execute_callback)(napi_env env, void* data);\n</code></pre>\n<p>Implementations of this function must avoid making Node-API calls that execute\nJavaScript or interact with JavaScript objects. Node-API calls should be in the\n<code>napi_async_complete_callback</code> instead. Do not use the <code>napi_env</code> parameter as\nit will likely result in execution of JavaScript.</p>",
                   "type": "module",
                   "displayName": "napi_async_execute_callback"
                 },
@@ -409,7 +412,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<p>Function pointer used with asynchronous thread-safe function calls. The callback\nwill be called on the main thread. Its purpose is to use a data item arriving\nvia the queue from one of the secondary threads to construct the parameters\nnecessary for a call into JavaScript, usually via <code>napi_call_function</code>, and then\nmake the call into JavaScript.</p>\n<p>The data arriving from the secondary thread via the queue is given in the <code>data</code>\nparameter and the JavaScript function to call is given in the <code>js_callback</code>\nparameter.</p>\n<p>N-API sets up the environment prior to calling this callback, so it is\nsufficient to call the JavaScript function via <code>napi_call_function</code> rather than\nvia <code>napi_make_callback</code>.</p>\n<p>Callback functions must satisfy the following signature:</p>\n<pre><code class=\"language-c\">typedef void (*napi_threadsafe_function_call_js)(napi_env env,\n                                                 napi_value js_callback,\n                                                 void* context,\n                                                 void* data);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment to use for API calls, or <code>NULL</code> if the thread-safe\nfunction is being torn down and <code>data</code> may need to be freed.</li>\n<li><code>[in] js_callback</code>: The JavaScript function to call, or <code>NULL</code> if the\nthread-safe function is being torn down and <code>data</code> may need to be freed. It\nmay also be <code>NULL</code> if the thread-safe function was created without\n<code>js_callback</code>.</li>\n<li><code>[in] context</code>: The optional data with which the thread-safe function was\ncreated.</li>\n<li><code>[in] data</code>: Data created by the secondary thread. It is the responsibility of\nthe callback to convert this native data to JavaScript values (with N-API\nfunctions) that can be passed as parameters when <code>js_callback</code> is invoked.\nThis pointer is managed entirely by the threads and this callback. Thus this\ncallback should free the data.</li>\n</ul>\n<p>Unless for reasons discussed in <a href=\"#n_api_object_lifetime_management\">Object Lifetime Management</a>, creating a\nhandle and/or callback scope inside the function body is not necessary.</p>",
+                  "desc": "<p>Function pointer used with asynchronous thread-safe function calls. The callback\nwill be called on the main thread. Its purpose is to use a data item arriving\nvia the queue from one of the secondary threads to construct the parameters\nnecessary for a call into JavaScript, usually via <code>napi_call_function</code>, and then\nmake the call into JavaScript.</p>\n<p>The data arriving from the secondary thread via the queue is given in the <code>data</code>\nparameter and the JavaScript function to call is given in the <code>js_callback</code>\nparameter.</p>\n<p>Node-API sets up the environment prior to calling this callback, so it is\nsufficient to call the JavaScript function via <code>napi_call_function</code> rather than\nvia <code>napi_make_callback</code>.</p>\n<p>Callback functions must satisfy the following signature:</p>\n<pre><code class=\"language-c\">typedef void (*napi_threadsafe_function_call_js)(napi_env env,\n                                                 napi_value js_callback,\n                                                 void* context,\n                                                 void* data);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment to use for API calls, or <code>NULL</code> if the thread-safe\nfunction is being torn down and <code>data</code> may need to be freed.</li>\n<li><code>[in] js_callback</code>: The JavaScript function to call, or <code>NULL</code> if the\nthread-safe function is being torn down and <code>data</code> may need to be freed. It\nmay also be <code>NULL</code> if the thread-safe function was created without\n<code>js_callback</code>.</li>\n<li><code>[in] context</code>: The optional data with which the thread-safe function was\ncreated.</li>\n<li><code>[in] data</code>: Data created by the secondary thread. It is the responsibility of\nthe callback to convert this native data to JavaScript values (with Node-API\nfunctions) that can be passed as parameters when <code>js_callback</code> is invoked.\nThis pointer is managed entirely by the threads and this callback. Thus this\ncallback should free the data.</li>\n</ul>\n<p>Unless for reasons discussed in <a href=\"#n_api_object_lifetime_management\">Object Lifetime Management</a>, creating a\nhandle and/or callback scope inside the function body is not necessary.</p>",
                   "type": "module",
                   "displayName": "napi_threadsafe_function_call_js"
                 },
@@ -418,7 +421,7 @@
                   "name": "napi_async_cleanup_hook",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.10.0"
                     ],
                     "changes": []
                   },
@@ -428,16 +431,16 @@
                 }
               ],
               "type": "module",
-              "displayName": "N-API callback types"
+              "displayName": "Node-API callback types"
             }
           ],
           "type": "misc",
-          "displayName": "Basic N-API data types"
+          "displayName": "Basic Node-API data types"
         },
         {
           "textRaw": "Error handling",
           "name": "error_handling",
-          "desc": "<p>N-API uses both return values and JavaScript exceptions for error handling.\nThe following sections explain the approach for each case.</p>",
+          "desc": "<p>Node-API uses both return values and JavaScript exceptions for error handling.\nThe following sections explain the approach for each case.</p>",
           "modules": [
             {
               "textRaw": "Return values",
@@ -451,7 +454,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<p>All of the N-API functions share the same error handling pattern. The\nreturn type of all API functions is <code>napi_status</code>.</p>\n<p>The return value will be <code>napi_ok</code> if the request was successful and\nno uncaught JavaScript exception was thrown. If an error occurred AND\nan exception was thrown, the <code>napi_status</code> value for the error\nwill be returned. If an exception was thrown, and no error occurred,\n<code>napi_pending_exception</code> will be returned.</p>\n<p>In cases where a return value other than <code>napi_ok</code> or\n<code>napi_pending_exception</code> is returned, <a href=\"#n_api_napi_is_exception_pending\"><code>napi_is_exception_pending</code></a>\nmust be called to check if an exception is pending.\nSee the section on exceptions for more details.</p>\n<p>The full set of possible <code>napi_status</code> values is defined\nin <code>napi_api_types.h</code>.</p>\n<p>The <code>napi_status</code> return value provides a VM-independent representation of\nthe error which occurred. In some cases it is useful to be able to get\nmore detailed information, including a string representing the error as well as\nVM (engine)-specific information.</p>\n<p>In order to retrieve this information <a href=\"#n_api_napi_get_last_error_info\"><code>napi_get_last_error_info</code></a>\nis provided which returns a <code>napi_extended_error_info</code> structure.\nThe format of the <code>napi_extended_error_info</code> structure is as follows:</p>\n<pre><code class=\"language-c\">typedef struct napi_extended_error_info {\n  const char* error_message;\n  void* engine_reserved;\n  uint32_t engine_error_code;\n  napi_status error_code;\n};\n</code></pre>\n<ul>\n<li><code>error_message</code>: Textual representation of the error that occurred.</li>\n<li><code>engine_reserved</code>: Opaque handle reserved for engine use only.</li>\n<li><code>engine_error_code</code>: VM specific error code.</li>\n<li><code>error_code</code>: n-api status code for the last error.</li>\n</ul>\n<p><a href=\"#n_api_napi_get_last_error_info\"><code>napi_get_last_error_info</code></a> returns the information for the last\nN-API call that was made.</p>\n<p>Do not rely on the content or format of any of the extended information as it\nis not subject to SemVer and may change at any time. It is intended only for\nlogging purposes.</p>",
+              "desc": "<p>All of the Node-API functions share the same error handling pattern. The\nreturn type of all API functions is <code>napi_status</code>.</p>\n<p>The return value will be <code>napi_ok</code> if the request was successful and\nno uncaught JavaScript exception was thrown. If an error occurred AND\nan exception was thrown, the <code>napi_status</code> value for the error\nwill be returned. If an exception was thrown, and no error occurred,\n<code>napi_pending_exception</code> will be returned.</p>\n<p>In cases where a return value other than <code>napi_ok</code> or\n<code>napi_pending_exception</code> is returned, <a href=\"#n_api_napi_is_exception_pending\"><code>napi_is_exception_pending</code></a>\nmust be called to check if an exception is pending.\nSee the section on exceptions for more details.</p>\n<p>The full set of possible <code>napi_status</code> values is defined\nin <code>napi_api_types.h</code>.</p>\n<p>The <code>napi_status</code> return value provides a VM-independent representation of\nthe error which occurred. In some cases it is useful to be able to get\nmore detailed information, including a string representing the error as well as\nVM (engine)-specific information.</p>\n<p>In order to retrieve this information <a href=\"#n_api_napi_get_last_error_info\"><code>napi_get_last_error_info</code></a>\nis provided which returns a <code>napi_extended_error_info</code> structure.\nThe format of the <code>napi_extended_error_info</code> structure is as follows:</p>\n<pre><code class=\"language-c\">typedef struct napi_extended_error_info {\n  const char* error_message;\n  void* engine_reserved;\n  uint32_t engine_error_code;\n  napi_status error_code;\n};\n</code></pre>\n<ul>\n<li><code>error_message</code>: Textual representation of the error that occurred.</li>\n<li><code>engine_reserved</code>: Opaque handle reserved for engine use only.</li>\n<li><code>engine_error_code</code>: VM specific error code.</li>\n<li><code>error_code</code>: Node-API status code for the last error.</li>\n</ul>\n<p><a href=\"#n_api_napi_get_last_error_info\"><code>napi_get_last_error_info</code></a> returns the information for the last\nNode-API call that was made.</p>\n<p>Do not rely on the content or format of any of the extended information as it\nis not subject to SemVer and may change at any time. It is intended only for\nlogging purposes.</p>",
               "modules": [
                 {
                   "textRaw": "napi_get_last_error_info",
@@ -465,7 +468,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status\nnapi_get_last_error_info(napi_env env,\n                         const napi_extended_error_info** result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[out] result</code>: The <code>napi_extended_error_info</code> structure with more\ninformation about the error.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API retrieves a <code>napi_extended_error_info</code> structure with information\nabout the last error that occurred.</p>\n<p>The content of the <code>napi_extended_error_info</code> returned is only valid up until\nan n-api function is called on the same <code>env</code>.</p>\n<p>Do not rely on the content or format of any of the extended information as it\nis not subject to SemVer and may change at any time. It is intended only for\nlogging purposes.</p>\n<p>This API can be called even if there is a pending JavaScript exception.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status\nnapi_get_last_error_info(napi_env env,\n                         const napi_extended_error_info** result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[out] result</code>: The <code>napi_extended_error_info</code> structure with more\ninformation about the error.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API retrieves a <code>napi_extended_error_info</code> structure with information\nabout the last error that occurred.</p>\n<p>The content of the <code>napi_extended_error_info</code> returned is only valid up until\na Node-API function is called on the same <code>env</code>.</p>\n<p>Do not rely on the content or format of any of the extended information as it\nis not subject to SemVer and may change at any time. It is intended only for\nlogging purposes.</p>\n<p>This API can be called even if there is a pending JavaScript exception.</p>",
                   "type": "module",
                   "displayName": "napi_get_last_error_info"
                 }
@@ -476,7 +479,7 @@
             {
               "textRaw": "Exceptions",
               "name": "exceptions",
-              "desc": "<p>Any N-API function call may result in a pending JavaScript exception. This is\nthe case for any of the API functions, even those that may not cause the\nexecution of JavaScript.</p>\n<p>If the <code>napi_status</code> returned by a function is <code>napi_ok</code> then no\nexception is pending and no additional action is required. If the\n<code>napi_status</code> returned is anything other than <code>napi_ok</code> or\n<code>napi_pending_exception</code>, in order to try to recover and continue\ninstead of simply returning immediately, <a href=\"#n_api_napi_is_exception_pending\"><code>napi_is_exception_pending</code></a>\nmust be called in order to determine if an exception is pending or not.</p>\n<p>In many cases when an N-API function is called and an exception is\nalready pending, the function will return immediately with a\n<code>napi_status</code> of <code>napi_pending_exception</code>. However, this is not the case\nfor all functions. N-API allows a subset of the functions to be\ncalled to allow for some minimal cleanup before returning to JavaScript.\nIn that case, <code>napi_status</code> will reflect the status for the function. It\nwill not reflect previous pending exceptions. To avoid confusion, check\nthe error status after every function call.</p>\n<p>When an exception is pending one of two approaches can be employed.</p>\n<p>The first approach is to do any appropriate cleanup and then return so that\nexecution will return to JavaScript. As part of the transition back to\nJavaScript, the exception will be thrown at the point in the JavaScript\ncode where the native method was invoked. The behavior of most N-API calls\nis unspecified while an exception is pending, and many will simply return\n<code>napi_pending_exception</code>, so do as little as possible and then return to\nJavaScript where the exception can be handled.</p>\n<p>The second approach is to try to handle the exception. There will be cases\nwhere the native code can catch the exception, take the appropriate action,\nand then continue. This is only recommended in specific cases\nwhere it is known that the exception can be safely handled. In these\ncases <a href=\"#n_api_napi_get_and_clear_last_exception\"><code>napi_get_and_clear_last_exception</code></a> can be used to get and\nclear the exception. On success, result will contain the handle to\nthe last JavaScript <code>Object</code> thrown. If it is determined, after\nretrieving the exception, the exception cannot be handled after all\nit can be re-thrown it with <a href=\"#n_api_napi_throw\"><code>napi_throw</code></a> where error is the\nJavaScript <code>Error</code> object to be thrown.</p>\n<p>The following utility functions are also available in case native code\nneeds to throw an exception or determine if a <code>napi_value</code> is an instance\nof a JavaScript <code>Error</code> object: <a href=\"#n_api_napi_throw_error\"><code>napi_throw_error</code></a>,\n<a href=\"#n_api_napi_throw_type_error\"><code>napi_throw_type_error</code></a>, <a href=\"#n_api_napi_throw_range_error\"><code>napi_throw_range_error</code></a> and\n<a href=\"#n_api_napi_is_error\"><code>napi_is_error</code></a>.</p>\n<p>The following utility functions are also available in case native\ncode needs to create an <code>Error</code> object: <a href=\"#n_api_napi_create_error\"><code>napi_create_error</code></a>,\n<a href=\"#n_api_napi_create_type_error\"><code>napi_create_type_error</code></a>, and <a href=\"#n_api_napi_create_range_error\"><code>napi_create_range_error</code></a>,\nwhere result is the <code>napi_value</code> that refers to the newly created\nJavaScript <code>Error</code> object.</p>\n<p>The Node.js project is adding error codes to all of the errors\ngenerated internally. The goal is for applications to use these\nerror codes for all error checking. The associated error messages\nwill remain, but will only be meant to be used for logging and\ndisplay with the expectation that the message can change without\nSemVer applying. In order to support this model with N-API, both\nin internal functionality and for module specific functionality\n(as its good practice), the <code>throw_</code> and <code>create_</code> functions\ntake an optional code parameter which is the string for the code\nto be added to the error object. If the optional parameter is <code>NULL</code>\nthen no code will be associated with the error. If a code is provided,\nthe name associated with the error is also updated to be:</p>\n<pre><code class=\"language-text\">originalName [code]\n</code></pre>\n<p>where <code>originalName</code> is the original name associated with the error\nand <code>code</code> is the code that was provided. For example, if the code\nis <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the name will be:</p>\n<pre><code class=\"language-text\">TypeError [ERR_ERROR_1]\n</code></pre>",
+              "desc": "<p>Any Node-API function call may result in a pending JavaScript exception. This is\nthe case for any of the API functions, even those that may not cause the\nexecution of JavaScript.</p>\n<p>If the <code>napi_status</code> returned by a function is <code>napi_ok</code> then no\nexception is pending and no additional action is required. If the\n<code>napi_status</code> returned is anything other than <code>napi_ok</code> or\n<code>napi_pending_exception</code>, in order to try to recover and continue\ninstead of simply returning immediately, <a href=\"#n_api_napi_is_exception_pending\"><code>napi_is_exception_pending</code></a>\nmust be called in order to determine if an exception is pending or not.</p>\n<p>In many cases when a Node-API function is called and an exception is\nalready pending, the function will return immediately with a\n<code>napi_status</code> of <code>napi_pending_exception</code>. However, this is not the case\nfor all functions. Node-API allows a subset of the functions to be\ncalled to allow for some minimal cleanup before returning to JavaScript.\nIn that case, <code>napi_status</code> will reflect the status for the function. It\nwill not reflect previous pending exceptions. To avoid confusion, check\nthe error status after every function call.</p>\n<p>When an exception is pending one of two approaches can be employed.</p>\n<p>The first approach is to do any appropriate cleanup and then return so that\nexecution will return to JavaScript. As part of the transition back to\nJavaScript, the exception will be thrown at the point in the JavaScript\ncode where the native method was invoked. The behavior of most Node-API calls\nis unspecified while an exception is pending, and many will simply return\n<code>napi_pending_exception</code>, so do as little as possible and then return to\nJavaScript where the exception can be handled.</p>\n<p>The second approach is to try to handle the exception. There will be cases\nwhere the native code can catch the exception, take the appropriate action,\nand then continue. This is only recommended in specific cases\nwhere it is known that the exception can be safely handled. In these\ncases <a href=\"#n_api_napi_get_and_clear_last_exception\"><code>napi_get_and_clear_last_exception</code></a> can be used to get and\nclear the exception. On success, result will contain the handle to\nthe last JavaScript <code>Object</code> thrown. If it is determined, after\nretrieving the exception, the exception cannot be handled after all\nit can be re-thrown it with <a href=\"#n_api_napi_throw\"><code>napi_throw</code></a> where error is the\nJavaScript value to be thrown.</p>\n<p>The following utility functions are also available in case native code\nneeds to throw an exception or determine if a <code>napi_value</code> is an instance\nof a JavaScript <code>Error</code> object: <a href=\"#n_api_napi_throw_error\"><code>napi_throw_error</code></a>,\n<a href=\"#n_api_napi_throw_type_error\"><code>napi_throw_type_error</code></a>, <a href=\"#n_api_napi_throw_range_error\"><code>napi_throw_range_error</code></a> and\n<a href=\"#n_api_napi_is_error\"><code>napi_is_error</code></a>.</p>\n<p>The following utility functions are also available in case native\ncode needs to create an <code>Error</code> object: <a href=\"#n_api_napi_create_error\"><code>napi_create_error</code></a>,\n<a href=\"#n_api_napi_create_type_error\"><code>napi_create_type_error</code></a>, and <a href=\"#n_api_napi_create_range_error\"><code>napi_create_range_error</code></a>,\nwhere result is the <code>napi_value</code> that refers to the newly created\nJavaScript <code>Error</code> object.</p>\n<p>The Node.js project is adding error codes to all of the errors\ngenerated internally. The goal is for applications to use these\nerror codes for all error checking. The associated error messages\nwill remain, but will only be meant to be used for logging and\ndisplay with the expectation that the message can change without\nSemVer applying. In order to support this model with Node-API, both\nin internal functionality and for module specific functionality\n(as its good practice), the <code>throw_</code> and <code>create_</code> functions\ntake an optional code parameter which is the string for the code\nto be added to the error object. If the optional parameter is <code>NULL</code>\nthen no code will be associated with the error. If a code is provided,\nthe name associated with the error is also updated to be:</p>\n<pre><code class=\"language-text\">originalName [code]\n</code></pre>\n<p>where <code>originalName</code> is the original name associated with the error\nand <code>code</code> is the code that was provided. For example, if the code\nis <code>'ERR_ERROR_1'</code> and a <code>TypeError</code> is being created the name will be:</p>\n<pre><code class=\"language-text\">TypeError [ERR_ERROR_1]\n</code></pre>",
               "modules": [
                 {
                   "textRaw": "napi_throw",
@@ -570,7 +573,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_error(napi_env env,\n                                          napi_value code,\n                                          napi_value msg,\n                                          napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>Error</code> with the text provided.</p>",
+                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_error(napi_env env,\n                                          napi_value code,\n                                          napi_value msg,\n                                          napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>Error</code> with the text provided.</p>",
                   "type": "module",
                   "displayName": "napi_create_error"
                 },
@@ -586,7 +589,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_type_error(napi_env env,\n                                               napi_value code,\n                                               napi_value msg,\n                                               napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>TypeError</code> with the text provided.</p>",
+                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_type_error(napi_env env,\n                                               napi_value code,\n                                               napi_value msg,\n                                               napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>TypeError</code> with the text provided.</p>",
                   "type": "module",
                   "displayName": "napi_create_type_error"
                 },
@@ -602,7 +605,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_range_error(napi_env env,\n                                                napi_value code,\n                                                napi_value msg,\n                                                napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>String</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>RangeError</code> with the text provided.</p>",
+                  "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_create_range_error(napi_env env,\n                                                napi_value code,\n                                                napi_value msg,\n                                                napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] code</code>: Optional <code>napi_value</code> with the string for the error code to be\nassociated with the error.</li>\n<li><code>[in] msg</code>: <code>napi_value</code> that references a JavaScript <code>string</code> to be used as\nthe message for the <code>Error</code>.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the error created.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a JavaScript <code>RangeError</code> with the text provided.</p>",
                   "type": "module",
                   "displayName": "napi_create_range_error"
                 },
@@ -675,7 +678,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">NAPI_NO_RETURN void napi_fatal_error(const char* location,\n                                                 size_t location_len,\n                                                 const char* message,\n                                                 size_t message_len);\n</code></pre>\n<ul>\n<li><code>[in] location</code>: Optional location at which the error occurred.</li>\n<li><code>[in] location_len</code>: The length of the location in bytes, or\n<code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>\n<li><code>[in] message</code>: The message associated with the error.</li>\n<li><code>[in] message_len</code>: The length of the message in bytes, or <code>NAPI_AUTO_LENGTH</code>\nif it is null-terminated.</li>\n</ul>\n<p>The function call does not return, the process will be terminated.</p>\n<p>This API can be called even if there is a pending JavaScript exception.</p>",
+                  "desc": "<pre><code class=\"language-c\">NAPI_NO_RETURN void napi_fatal_error(const char* location,\n                                     size_t location_len,\n                                     const char* message,\n                                     size_t message_len);\n</code></pre>\n<ul>\n<li><code>[in] location</code>: Optional location at which the error occurred.</li>\n<li><code>[in] location_len</code>: The length of the location in bytes, or\n<code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>\n<li><code>[in] message</code>: The message associated with the error.</li>\n<li><code>[in] message_len</code>: The length of the message in bytes, or <code>NAPI_AUTO_LENGTH</code>\nif it is null-terminated.</li>\n</ul>\n<p>The function call does not return, the process will be terminated.</p>\n<p>This API can be called even if there is a pending JavaScript exception.</p>",
                   "type": "module",
                   "displayName": "napi_fatal_error"
                 }
@@ -690,12 +693,12 @@
         {
           "textRaw": "Object lifetime management",
           "name": "object_lifetime_management",
-          "desc": "<p>As N-API calls are made, handles to objects in the heap for the underlying\nVM may be returned as <code>napi_values</code>. These handles must hold the\nobjects 'live' until they are no longer required by the native code,\notherwise the objects could be collected before the native code was\nfinished using them.</p>\n<p>As object handles are returned they are associated with a\n'scope'. The lifespan for the default scope is tied to the lifespan\nof the native method call. The result is that, by default, handles\nremain valid and the objects associated with these handles will be\nheld live for the lifespan of the native method call.</p>\n<p>In many cases, however, it is necessary that the handles remain valid for\neither a shorter or longer lifespan than that of the native method.\nThe sections which follow describe the N-API functions that can be used\nto change the handle lifespan from the default.</p>",
+          "desc": "<p>As Node-API calls are made, handles to objects in the heap for the underlying\nVM may be returned as <code>napi_values</code>. These handles must hold the\nobjects 'live' until they are no longer required by the native code,\notherwise the objects could be collected before the native code was\nfinished using them.</p>\n<p>As object handles are returned they are associated with a\n'scope'. The lifespan for the default scope is tied to the lifespan\nof the native method call. The result is that, by default, handles\nremain valid and the objects associated with these handles will be\nheld live for the lifespan of the native method call.</p>\n<p>In many cases, however, it is necessary that the handles remain valid for\neither a shorter or longer lifespan than that of the native method.\nThe sections which follow describe the Node-API functions that can be used\nto change the handle lifespan from the default.</p>",
           "modules": [
             {
               "textRaw": "Making handle lifespan shorter than that of the native method",
               "name": "making_handle_lifespan_shorter_than_that_of_the_native_method",
-              "desc": "<p>It is often necessary to make the lifespan of handles shorter than\nthe lifespan of a native method. For example, consider a native method\nthat has a loop which iterates through the elements in a large array:</p>\n<pre><code class=\"language-c\">for (int i = 0; i &#x3C; 1000000; i++) {\n  napi_value result;\n  napi_status status = napi_get_element(env, object, i, &#x26;result);\n  if (status != napi_ok) {\n    break;\n  }\n  // do something with element\n}\n</code></pre>\n<p>This would result in a large number of handles being created, consuming\nsubstantial resources. In addition, even though the native code could only\nuse the most recent handle, all of the associated objects would also be\nkept alive since they all share the same scope.</p>\n<p>To handle this case, N-API provides the ability to establish a new 'scope' to\nwhich newly created handles will be associated. Once those handles\nare no longer required, the scope can be 'closed' and any handles associated\nwith the scope are invalidated. The methods available to open/close scopes are\n<a href=\"#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and <a href=\"#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a>.</p>\n<p>N-API only supports a single nested hierarchy of scopes. There is only one\nactive scope at any time, and all new handles will be associated with that\nscope while it is active. Scopes must be closed in the reverse order from\nwhich they are opened. In addition, all scopes created within a native method\nmust be closed before returning from that method.</p>\n<p>Taking the earlier example, adding calls to <a href=\"#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and\n<a href=\"#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a> would ensure that at most a single handle\nis valid throughout the execution of the loop:</p>\n<pre><code class=\"language-c\">for (int i = 0; i &#x3C; 1000000; i++) {\n  napi_handle_scope scope;\n  napi_status status = napi_open_handle_scope(env, &#x26;scope);\n  if (status != napi_ok) {\n    break;\n  }\n  napi_value result;\n  status = napi_get_element(env, object, i, &#x26;result);\n  if (status != napi_ok) {\n    break;\n  }\n  // do something with element\n  status = napi_close_handle_scope(env, scope);\n  if (status != napi_ok) {\n    break;\n  }\n}\n</code></pre>\n<p>When nesting scopes, there are cases where a handle from an\ninner scope needs to live beyond the lifespan of that scope. N-API supports an\n'escapable scope' in order to support this case. An escapable scope\nallows one handle to be 'promoted' so that it 'escapes' the\ncurrent scope and the lifespan of the handle changes from the current\nscope to that of the outer scope.</p>\n<p>The methods available to open/close escapable scopes are\n<a href=\"#n_api_napi_open_escapable_handle_scope\"><code>napi_open_escapable_handle_scope</code></a> and\n<a href=\"#n_api_napi_close_escapable_handle_scope\"><code>napi_close_escapable_handle_scope</code></a>.</p>\n<p>The request to promote a handle is made through <a href=\"#n_api_napi_escape_handle\"><code>napi_escape_handle</code></a> which\ncan only be called once.</p>",
+              "desc": "<p>It is often necessary to make the lifespan of handles shorter than\nthe lifespan of a native method. For example, consider a native method\nthat has a loop which iterates through the elements in a large array:</p>\n<pre><code class=\"language-c\">for (int i = 0; i &#x3C; 1000000; i++) {\n  napi_value result;\n  napi_status status = napi_get_element(env, object, i, &#x26;result);\n  if (status != napi_ok) {\n    break;\n  }\n  // do something with element\n}\n</code></pre>\n<p>This would result in a large number of handles being created, consuming\nsubstantial resources. In addition, even though the native code could only\nuse the most recent handle, all of the associated objects would also be\nkept alive since they all share the same scope.</p>\n<p>To handle this case, Node-API provides the ability to establish a new 'scope' to\nwhich newly created handles will be associated. Once those handles\nare no longer required, the scope can be 'closed' and any handles associated\nwith the scope are invalidated. The methods available to open/close scopes are\n<a href=\"#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and <a href=\"#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a>.</p>\n<p>Node-API only supports a single nested hierarchy of scopes. There is only one\nactive scope at any time, and all new handles will be associated with that\nscope while it is active. Scopes must be closed in the reverse order from\nwhich they are opened. In addition, all scopes created within a native method\nmust be closed before returning from that method.</p>\n<p>Taking the earlier example, adding calls to <a href=\"#n_api_napi_open_handle_scope\"><code>napi_open_handle_scope</code></a> and\n<a href=\"#n_api_napi_close_handle_scope\"><code>napi_close_handle_scope</code></a> would ensure that at most a single handle\nis valid throughout the execution of the loop:</p>\n<pre><code class=\"language-c\">for (int i = 0; i &#x3C; 1000000; i++) {\n  napi_handle_scope scope;\n  napi_status status = napi_open_handle_scope(env, &#x26;scope);\n  if (status != napi_ok) {\n    break;\n  }\n  napi_value result;\n  status = napi_get_element(env, object, i, &#x26;result);\n  if (status != napi_ok) {\n    break;\n  }\n  // do something with element\n  status = napi_close_handle_scope(env, scope);\n  if (status != napi_ok) {\n    break;\n  }\n}\n</code></pre>\n<p>When nesting scopes, there are cases where a handle from an\ninner scope needs to live beyond the lifespan of that scope. Node-API supports\nan 'escapable scope' in order to support this case. An escapable scope\nallows one handle to be 'promoted' so that it 'escapes' the\ncurrent scope and the lifespan of the handle changes from the current\nscope to that of the outer scope.</p>\n<p>The methods available to open/close escapable scopes are\n<a href=\"#n_api_napi_open_escapable_handle_scope\"><code>napi_open_escapable_handle_scope</code></a> and\n<a href=\"#n_api_napi_close_escapable_handle_scope\"><code>napi_close_escapable_handle_scope</code></a>.</p>\n<p>The request to promote a handle is made through <a href=\"#n_api_napi_escape_handle\"><code>napi_escape_handle</code></a> which\ncan only be called once.</p>",
               "modules": [
                 {
                   "textRaw": "napi_open_handle_scope",
@@ -784,7 +787,7 @@
             {
               "textRaw": "References to objects with a lifespan longer than that of the native method",
               "name": "references_to_objects_with_a_lifespan_longer_than_that_of_the_native_method",
-              "desc": "<p>In some cases an addon will need to be able to create and reference objects\nwith a lifespan longer than that of a single native method invocation. For\nexample, to create a constructor and later use that constructor\nin a request to creates instances, it must be possible to reference\nthe constructor object across many different instance creation requests. This\nwould not be possible with a normal handle returned as a <code>napi_value</code> as\ndescribed in the earlier section. The lifespan of a normal handle is\nmanaged by scopes and all scopes must be closed before the end of a native\nmethod.</p>\n<p>N-API provides methods to create persistent references to an object.\nEach persistent reference has an associated count with a value of 0\nor higher. The count determines if the reference will keep\nthe corresponding object live. References with a count of 0 do not\nprevent the object from being collected and are often called 'weak'\nreferences. Any count greater than 0 will prevent the object\nfrom being collected.</p>\n<p>References can be created with an initial reference count. The count can\nthen be modified through <a href=\"#n_api_napi_reference_ref\"><code>napi_reference_ref</code></a> and\n<a href=\"#n_api_napi_reference_unref\"><code>napi_reference_unref</code></a>. If an object is collected while the count\nfor a reference is 0, all subsequent calls to\nget the object associated with the reference <a href=\"#n_api_napi_get_reference_value\"><code>napi_get_reference_value</code></a>\nwill return <code>NULL</code> for the returned <code>napi_value</code>. An attempt to call\n<a href=\"#n_api_napi_reference_ref\"><code>napi_reference_ref</code></a> for a reference whose object has been collected\nwill result in an error.</p>\n<p>References must be deleted once they are no longer required by the addon. When\na reference is deleted it will no longer prevent the corresponding object from\nbeing collected. Failure to delete a persistent reference will result in\na 'memory leak' with both the native memory for the persistent reference and\nthe corresponding object on the heap being retained forever.</p>\n<p>There can be multiple persistent references created which refer to the same\nobject, each of which will either keep the object live or not based on its\nindividual count.</p>",
+              "desc": "<p>In some cases an addon will need to be able to create and reference objects\nwith a lifespan longer than that of a single native method invocation. For\nexample, to create a constructor and later use that constructor\nin a request to creates instances, it must be possible to reference\nthe constructor object across many different instance creation requests. This\nwould not be possible with a normal handle returned as a <code>napi_value</code> as\ndescribed in the earlier section. The lifespan of a normal handle is\nmanaged by scopes and all scopes must be closed before the end of a native\nmethod.</p>\n<p>Node-API provides methods to create persistent references to an object.\nEach persistent reference has an associated count with a value of 0\nor higher. The count determines if the reference will keep\nthe corresponding object live. References with a count of 0 do not\nprevent the object from being collected and are often called 'weak'\nreferences. Any count greater than 0 will prevent the object\nfrom being collected.</p>\n<p>References can be created with an initial reference count. The count can\nthen be modified through <a href=\"#n_api_napi_reference_ref\"><code>napi_reference_ref</code></a> and\n<a href=\"#n_api_napi_reference_unref\"><code>napi_reference_unref</code></a>. If an object is collected while the count\nfor a reference is 0, all subsequent calls to\nget the object associated with the reference <a href=\"#n_api_napi_get_reference_value\"><code>napi_get_reference_value</code></a>\nwill return <code>NULL</code> for the returned <code>napi_value</code>. An attempt to call\n<a href=\"#n_api_napi_reference_ref\"><code>napi_reference_ref</code></a> for a reference whose object has been collected\nresults in an error.</p>\n<p>References must be deleted once they are no longer required by the addon. When\na reference is deleted, it will no longer prevent the corresponding object from\nbeing collected. Failure to delete a persistent reference results in\na 'memory leak' with both the native memory for the persistent reference and\nthe corresponding object on the heap being retained forever.</p>\n<p>There can be multiple persistent references created which refer to the same\nobject, each of which will either keep the object live or not based on its\nindividual count.</p>",
               "modules": [
                 {
                   "textRaw": "napi_create_reference",
@@ -873,7 +876,7 @@
             {
               "textRaw": "Cleanup on exit of the current Node.js instance",
               "name": "cleanup_on_exit_of_the_current_node.js_instance",
-              "desc": "<p>While a Node.js process typically releases all its resources when exiting,\nembedders of Node.js, or future Worker support, may require addons to register\nclean-up hooks that will be run once the current Node.js instance exits.</p>\n<p>N-API provides functions for registering and un-registering such callbacks.\nWhen those callbacks are run, all resources that are being held by the addon\nshould be freed up.</p>",
+              "desc": "<p>While a Node.js process typically releases all its resources when exiting,\nembedders of Node.js, or future Worker support, may require addons to register\nclean-up hooks that will be run once the current Node.js instance exits.</p>\n<p>Node-API provides functions for registering and un-registering such callbacks.\nWhen those callbacks are run, all resources that are being held by the addon\nshould be freed up.</p>",
               "modules": [
                 {
                   "textRaw": "napi_add_env_cleanup_hook",
@@ -912,17 +915,18 @@
                   "name": "napi_add_async_cleanup_hook",
                   "meta": {
                     "added": [
+                      "v14.8.0",
                       "v12.19.0"
                     ],
+                    "napiVersion": [
+                      8
+                    ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.10.0",
                         "pr-url": "https://github.com/nodejs/node/pull/34819",
                         "description": "Changed signature of the `hook` callback."
                       }
-                    ],
-                    "napiVersion": [
-                      8
                     ]
                   },
                   "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_add_async_cleanup_hook(\n    napi_env env,\n    napi_async_cleanup_hook hook,\n    void* arg,\n    napi_async_cleanup_hook_handle* remove_handle);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] hook</code>: The function pointer to call at environment teardown.</li>\n<li><code>[in] arg</code>: The pointer to pass to <code>hook</code> when it gets called.</li>\n<li><code>[out] remove_handle</code>: Optional handle that refers to the asynchronous cleanup\nhook.</li>\n</ul>\n<p>Registers <code>hook</code>, which is a function of type <a href=\"#n_api_napi_async_cleanup_hook\"><code>napi_async_cleanup_hook</code></a>, as\na function to be run with the <code>remove_handle</code> and <code>arg</code> parameters once the\ncurrent Node.js environment exits.</p>\n<p>Unlike <a href=\"#n_api_napi_add_env_cleanup_hook\"><code>napi_add_env_cleanup_hook</code></a>, the hook is allowed to be asynchronous.</p>\n<p>Otherwise, behavior generally matches that of <a href=\"#n_api_napi_add_env_cleanup_hook\"><code>napi_add_env_cleanup_hook</code></a>.</p>\n<p>If <code>remove_handle</code> is not <code>NULL</code>, an opaque value will be stored in it\nthat must later be passed to <a href=\"#n_api_napi_remove_async_cleanup_hook\"><code>napi_remove_async_cleanup_hook</code></a>,\nregardless of whether the hook has already been invoked.\nTypically, that happens when the resource for which this hook was added\nis being torn down anyway.</p>",
@@ -934,11 +938,11 @@
                   "name": "napi_remove_async_cleanup_hook",
                   "meta": {
                     "added": [
-                      "v12.19.0"
+                      "v14.8.0"
                     ],
                     "changes": [
                       {
-                        "version": "v12.19.0",
+                        "version": "v14.10.0",
                         "pr-url": "https://github.com/nodejs/node/pull/34819",
                         "description": "Removed `env` parameter."
                       }
@@ -959,14 +963,14 @@
         {
           "textRaw": "Module registration",
           "name": "module_registration",
-          "desc": "<p>N-API modules are registered in a manner similar to other modules\nexcept that instead of using the <code>NODE_MODULE</code> macro the following\nis used:</p>\n<pre><code class=\"language-c\">NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)\n</code></pre>\n<p>The next difference is the signature for the <code>Init</code> method. For a N-API\nmodule it is as follows:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports);\n</code></pre>\n<p>The return value from <code>Init</code> is treated as the <code>exports</code> object for the module.\nThe <code>Init</code> method is passed an empty object via the <code>exports</code> parameter as a\nconvenience. If <code>Init</code> returns <code>NULL</code>, the parameter passed as <code>exports</code> is\nexported by the module. N-API modules cannot modify the <code>module</code> object but can\nspecify anything as the <code>exports</code> property of the module.</p>\n<p>To add the method <code>hello</code> as a function so that it can be called as a method\nprovided by the addon:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_property_descriptor desc = {\n    \"hello\",\n    NULL,\n    Method,\n    NULL,\n    NULL,\n    NULL,\n    napi_writable | napi_enumerable | napi_configurable,\n    NULL\n  };\n  status = napi_define_properties(env, exports, 1, &#x26;desc);\n  if (status != napi_ok) return NULL;\n  return exports;\n}\n</code></pre>\n<p>To set a function to be returned by the <code>require()</code> for the addon:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports) {\n  napi_value method;\n  napi_status status;\n  status = napi_create_function(env, \"exports\", NAPI_AUTO_LENGTH, Method, NULL, &#x26;method);\n  if (status != napi_ok) return NULL;\n  return method;\n}\n</code></pre>\n<p>To define a class so that new instances can be created (often used with\n<a href=\"#n_api_object_wrap\">Object wrap</a>):</p>\n<pre><code class=\"language-c\">// NOTE: partial example, not all referenced code is included\nnapi_value Init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_property_descriptor properties[] = {\n    { \"value\", NULL, NULL, GetValue, SetValue, NULL, napi_writable | napi_configurable, NULL },\n    DECLARE_NAPI_METHOD(\"plusOne\", PlusOne),\n    DECLARE_NAPI_METHOD(\"multiply\", Multiply),\n  };\n\n  napi_value cons;\n  status =\n      napi_define_class(env, \"MyObject\", New, NULL, 3, properties, &#x26;cons);\n  if (status != napi_ok) return NULL;\n\n  status = napi_create_reference(env, cons, 1, &#x26;constructor);\n  if (status != napi_ok) return NULL;\n\n  status = napi_set_named_property(env, exports, \"MyObject\", cons);\n  if (status != napi_ok) return NULL;\n\n  return exports;\n}\n</code></pre>\n<p>If the module will be loaded multiple times during the lifetime of the Node.js\nprocess, use the <code>NAPI_MODULE_INIT</code> macro to initialize the module:</p>\n<pre><code class=\"language-c\">NAPI_MODULE_INIT() {\n  napi_value answer;\n  napi_status result;\n\n  status = napi_create_int64(env, 42, &#x26;answer);\n  if (status != napi_ok) return NULL;\n\n  status = napi_set_named_property(env, exports, \"answer\", answer);\n  if (status != napi_ok) return NULL;\n\n  return exports;\n}\n</code></pre>\n<p>This macro includes <code>NAPI_MODULE</code>, and declares an <code>Init</code> function with a\nspecial name and with visibility beyond the addon. This will allow Node.js to\ninitialize the module even if it is loaded multiple times.</p>\n<p>There are a few design considerations when declaring a module that may be loaded\nmultiple times. The documentation of <a href=\"addons.html#addons_context_aware_addons\">context-aware addons</a> provides more\ndetails.</p>\n<p>The variables <code>env</code> and <code>exports</code> will be available inside the function body\nfollowing the macro invocation.</p>\n<p>For more details on setting properties on objects, see the section on\n<a href=\"#n_api_working_with_javascript_properties\">Working with JavaScript properties</a>.</p>\n<p>For more details on building addon modules in general, refer to the existing\nAPI.</p>",
+          "desc": "<p>Node-API modules are registered in a manner similar to other modules\nexcept that instead of using the <code>NODE_MODULE</code> macro the following\nis used:</p>\n<pre><code class=\"language-c\">NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)\n</code></pre>\n<p>The next difference is the signature for the <code>Init</code> method. For a Node-API\nmodule it is as follows:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports);\n</code></pre>\n<p>The return value from <code>Init</code> is treated as the <code>exports</code> object for the module.\nThe <code>Init</code> method is passed an empty object via the <code>exports</code> parameter as a\nconvenience. If <code>Init</code> returns <code>NULL</code>, the parameter passed as <code>exports</code> is\nexported by the module. Node-API modules cannot modify the <code>module</code> object but\ncan specify anything as the <code>exports</code> property of the module.</p>\n<p>To add the method <code>hello</code> as a function so that it can be called as a method\nprovided by the addon:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_property_descriptor desc = {\n    \"hello\",\n    NULL,\n    Method,\n    NULL,\n    NULL,\n    NULL,\n    napi_writable | napi_enumerable | napi_configurable,\n    NULL\n  };\n  status = napi_define_properties(env, exports, 1, &#x26;desc);\n  if (status != napi_ok) return NULL;\n  return exports;\n}\n</code></pre>\n<p>To set a function to be returned by the <code>require()</code> for the addon:</p>\n<pre><code class=\"language-c\">napi_value Init(napi_env env, napi_value exports) {\n  napi_value method;\n  napi_status status;\n  status = napi_create_function(env, \"exports\", NAPI_AUTO_LENGTH, Method, NULL, &#x26;method);\n  if (status != napi_ok) return NULL;\n  return method;\n}\n</code></pre>\n<p>To define a class so that new instances can be created (often used with\n<a href=\"#n_api_object_wrap\">Object wrap</a>):</p>\n<pre><code class=\"language-c\">// NOTE: partial example, not all referenced code is included\nnapi_value Init(napi_env env, napi_value exports) {\n  napi_status status;\n  napi_property_descriptor properties[] = {\n    { \"value\", NULL, NULL, GetValue, SetValue, NULL, napi_writable | napi_configurable, NULL },\n    DECLARE_NAPI_METHOD(\"plusOne\", PlusOne),\n    DECLARE_NAPI_METHOD(\"multiply\", Multiply),\n  };\n\n  napi_value cons;\n  status =\n      napi_define_class(env, \"MyObject\", New, NULL, 3, properties, &#x26;cons);\n  if (status != napi_ok) return NULL;\n\n  status = napi_create_reference(env, cons, 1, &#x26;constructor);\n  if (status != napi_ok) return NULL;\n\n  status = napi_set_named_property(env, exports, \"MyObject\", cons);\n  if (status != napi_ok) return NULL;\n\n  return exports;\n}\n</code></pre>\n<p>You can also use the <code>NAPI_MODULE_INIT</code> macro, which acts as a shorthand\nfor <code>NAPI_MODULE</code> and defining an <code>Init</code> function:</p>\n<pre><code class=\"language-c\">NAPI_MODULE_INIT() {\n  napi_value answer;\n  napi_status result;\n\n  status = napi_create_int64(env, 42, &#x26;answer);\n  if (status != napi_ok) return NULL;\n\n  status = napi_set_named_property(env, exports, \"answer\", answer);\n  if (status != napi_ok) return NULL;\n\n  return exports;\n}\n</code></pre>\n<p>All Node-API addons are context-aware, meaning they may be loaded multiple\ntimes. There are a few design considerations when declaring such a module.\nThe documentation on <a href=\"addons.html#addons_context_aware_addons\">context-aware addons</a> provides more details.</p>\n<p>The variables <code>env</code> and <code>exports</code> will be available inside the function body\nfollowing the macro invocation.</p>\n<p>For more details on setting properties on objects, see the section on\n<a href=\"#n_api_working_with_javascript_properties\">Working with JavaScript properties</a>.</p>\n<p>For more details on building addon modules in general, refer to the existing\nAPI.</p>",
           "type": "misc",
           "displayName": "Module registration"
         },
         {
           "textRaw": "Working with JavaScript values",
           "name": "working_with_javascript_values",
-          "desc": "<p>N-API exposes a set of APIs to create all types of JavaScript values.\nSome of these types are documented under <a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\">Section 6</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>Fundamentally, these APIs are used to do one of the following:</p>\n<ol>\n<li>Create a new JavaScript object</li>\n<li>Convert from a primitive C type to an N-API value</li>\n<li>Convert from N-API value to a primitive C type</li>\n<li>Get global instances including <code>undefined</code> and <code>null</code></li>\n</ol>\n<p>N-API values are represented by the type <code>napi_value</code>.\nAny N-API call that requires a JavaScript value takes in a <code>napi_value</code>.\nIn some cases, the API does check the type of the <code>napi_value</code> up-front.\nHowever, for better performance, it's better for the caller to make sure that\nthe <code>napi_value</code> in question is of the JavaScript type expected by the API.</p>",
+          "desc": "<p>Node-API exposes a set of APIs to create all types of JavaScript values.\nSome of these types are documented under <a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\">Section 6</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>Fundamentally, these APIs are used to do one of the following:</p>\n<ol>\n<li>Create a new JavaScript object</li>\n<li>Convert from a primitive C type to a Node-API value</li>\n<li>Convert from Node-API value to a primitive C type</li>\n<li>Get global instances including <code>undefined</code> and <code>null</code></li>\n</ol>\n<p>Node-API values are represented by the type <code>napi_value</code>.\nAny Node-API call that requires a JavaScript value takes in a <code>napi_value</code>.\nIn some cases, the API does check the type of the <code>napi_value</code> up-front.\nHowever, for better performance, it's better for the caller to make sure that\nthe <code>napi_value</code> in question is of the JavaScript type expected by the API.</p>",
           "modules": [
             {
               "textRaw": "Enum types",
@@ -977,7 +981,8 @@
                   "name": "napi_key_collection_mode",
                   "meta": {
                     "added": [
-                      "v12.17.0"
+                      "v13.7.0",
+                      "v10.20.0"
                     ],
                     "napiVersion": [
                       6
@@ -993,7 +998,8 @@
                   "name": "napi_key_filter",
                   "meta": {
                     "added": [
-                      "v12.17.0"
+                      "v13.7.0",
+                      "v10.20.0"
                     ],
                     "napiVersion": [
                       6
@@ -1009,7 +1015,8 @@
                   "name": "napi_key_conversion",
                   "meta": {
                     "added": [
-                      "v12.17.0"
+                      "v13.7.0",
+                      "v10.20.0"
                     ],
                     "napiVersion": [
                       6
@@ -1054,7 +1061,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_array(napi_env env, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an N-API value corresponding to a JavaScript <code>Array</code> type.\nJavaScript arrays are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-array-objects\">Section 22.1</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_array(napi_env env, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a Node-API value corresponding to a JavaScript <code>Array</code> type.\nJavaScript arrays are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-array-objects\">Section 22.1</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_array"
                 },
@@ -1070,7 +1077,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_array_with_length(napi_env env,\n                                          size_t length,\n                                          napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] length</code>: The initial length of the <code>Array</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an N-API value corresponding to a JavaScript <code>Array</code> type.\nThe <code>Array</code>'s length property is set to the passed-in length parameter.\nHowever, the underlying buffer is not guaranteed to be pre-allocated by the VM\nwhen the array is created. That behavior is left to the underlying VM\nimplementation. If the buffer must be a contiguous block of memory that can be\ndirectly read and/or written via C, consider using\n<a href=\"#n_api_napi_create_external_arraybuffer\"><code>napi_create_external_arraybuffer</code></a>.</p>\n<p>JavaScript arrays are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-array-objects\">Section 22.1</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_array_with_length(napi_env env,\n                                          size_t length,\n                                          napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] length</code>: The initial length of the <code>Array</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Array</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a Node-API value corresponding to a JavaScript <code>Array</code> type.\nThe <code>Array</code>'s length property is set to the passed-in length parameter.\nHowever, the underlying buffer is not guaranteed to be pre-allocated by the VM\nwhen the array is created. That behavior is left to the underlying VM\nimplementation. If the buffer must be a contiguous block of memory that can be\ndirectly read and/or written via C, consider using\n<a href=\"#n_api_napi_create_external_arraybuffer\"><code>napi_create_external_arraybuffer</code></a>.</p>\n<p>JavaScript arrays are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-array-objects\">Section 22.1</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_array_with_length"
                 },
@@ -1086,7 +1093,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_arraybuffer(napi_env env,\n                                    size_t byte_length,\n                                    void** data,\n                                    napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] length</code>: The length in bytes of the array buffer to create.</li>\n<li><code>[out] data</code>: Pointer to the underlying byte buffer of the <code>ArrayBuffer</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an N-API value corresponding to a JavaScript <code>ArrayBuffer</code>.\n<code>ArrayBuffer</code>s are used to represent fixed-length binary data buffers. They are\nnormally used as a backing-buffer for <code>TypedArray</code> objects.\nThe <code>ArrayBuffer</code> allocated will have an underlying byte buffer whose size is\ndetermined by the <code>length</code> parameter that's passed in.\nThe underlying buffer is optionally returned back to the caller in case the\ncaller wants to directly manipulate the buffer. This buffer can only be\nwritten to directly from native code. To write to this buffer from JavaScript,\na typed array or <code>DataView</code> object would need to be created.</p>\n<p>JavaScript <code>ArrayBuffer</code> objects are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-arraybuffer-objects\">Section 24.1</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_arraybuffer(napi_env env,\n                                    size_t byte_length,\n                                    void** data,\n                                    napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] length</code>: The length in bytes of the array buffer to create.</li>\n<li><code>[out] data</code>: Pointer to the underlying byte buffer of the <code>ArrayBuffer</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a Node-API value corresponding to a JavaScript <code>ArrayBuffer</code>.\n<code>ArrayBuffer</code>s are used to represent fixed-length binary data buffers. They are\nnormally used as a backing-buffer for <code>TypedArray</code> objects.\nThe <code>ArrayBuffer</code> allocated will have an underlying byte buffer whose size is\ndetermined by the <code>length</code> parameter that's passed in.\nThe underlying buffer is optionally returned back to the caller in case the\ncaller wants to directly manipulate the buffer. This buffer can only be\nwritten to directly from native code. To write to this buffer from JavaScript,\na typed array or <code>DataView</code> object would need to be created.</p>\n<p>JavaScript <code>ArrayBuffer</code> objects are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-arraybuffer-objects\">Section 24.1</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_arraybuffer"
                 },
@@ -1127,7 +1134,8 @@
                   "name": "napi_create_date",
                   "meta": {
                     "added": [
-                      "v11.11.0"
+                      "v11.11.0",
+                      "v10.17.0"
                     ],
                     "napiVersion": [
                       5
@@ -1166,7 +1174,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status\nnapi_create_external_arraybuffer(napi_env env,\n                                 void* external_data,\n                                 size_t byte_length,\n                                 napi_finalize finalize_cb,\n                                 void* finalize_hint,\n                                 napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] external_data</code>: Pointer to the underlying byte buffer of the\n<code>ArrayBuffer</code>.</li>\n<li><code>[in] byte_length</code>: The length in bytes of the underlying buffer.</li>\n<li><code>[in] finalize_cb</code>: Optional callback to call when the <code>ArrayBuffer</code> is being\ncollected. <a href=\"#n_api_napi_finalize\"><code>napi_finalize</code></a> provides more details.</li>\n<li><code>[in] finalize_hint</code>: Optional hint to pass to the finalize callback during\ncollection.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an N-API value corresponding to a JavaScript <code>ArrayBuffer</code>.\nThe underlying byte buffer of the <code>ArrayBuffer</code> is externally allocated and\nmanaged. The caller must ensure that the byte buffer remains valid until the\nfinalize callback is called.</p>\n<p>The API adds a <code>napi_finalize</code> callback which will be called when the JavaScript\nobject just created is ready for garbage collection. It is similar to\n<code>napi_wrap()</code> except that:</p>\n<ul>\n<li>the native data cannot be retrieved later using <code>napi_unwrap()</code>,</li>\n<li>nor can it be removed later using <code>napi_remove_wrap()</code>, and</li>\n<li>the object created by the API can be used with <code>napi_wrap()</code>.</li>\n</ul>\n<p>JavaScript <code>ArrayBuffer</code>s are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-arraybuffer-objects\">Section 24.1</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status\nnapi_create_external_arraybuffer(napi_env env,\n                                 void* external_data,\n                                 size_t byte_length,\n                                 napi_finalize finalize_cb,\n                                 void* finalize_hint,\n                                 napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] external_data</code>: Pointer to the underlying byte buffer of the\n<code>ArrayBuffer</code>.</li>\n<li><code>[in] byte_length</code>: The length in bytes of the underlying buffer.</li>\n<li><code>[in] finalize_cb</code>: Optional callback to call when the <code>ArrayBuffer</code> is being\ncollected. <a href=\"#n_api_napi_finalize\"><code>napi_finalize</code></a> provides more details.</li>\n<li><code>[in] finalize_hint</code>: Optional hint to pass to the finalize callback during\ncollection.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>ArrayBuffer</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns a Node-API value corresponding to a JavaScript <code>ArrayBuffer</code>.\nThe underlying byte buffer of the <code>ArrayBuffer</code> is externally allocated and\nmanaged. The caller must ensure that the byte buffer remains valid until the\nfinalize callback is called.</p>\n<p>The API adds a <code>napi_finalize</code> callback which will be called when the JavaScript\nobject just created is ready for garbage collection. It is similar to\n<code>napi_wrap()</code> except that:</p>\n<ul>\n<li>the native data cannot be retrieved later using <code>napi_unwrap()</code>,</li>\n<li>nor can it be removed later using <code>napi_remove_wrap()</code>, and</li>\n<li>the object created by the API can be used with <code>napi_wrap()</code>.</li>\n</ul>\n<p>JavaScript <code>ArrayBuffer</code>s are described in\n<a href=\"https://tc39.github.io/ecma262/#sec-arraybuffer-objects\">Section 24.1</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_external_arraybuffer"
                 },
@@ -1214,7 +1222,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_symbol(napi_env env,\n                               napi_value description,\n                               napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] description</code>: Optional <code>napi_value</code> which refers to a JavaScript\n<code>String</code> to be set as the description for the symbol.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Symbol</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>Symbol</code> object from a UTF8-encoded C string.</p>\n<p>The JavaScript <code>Symbol</code> type is described in <a href=\"https://tc39.github.io/ecma262/#sec-symbol-objects\">Section 19.4</a>\nof the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_symbol(napi_env env,\n                               napi_value description,\n                               napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] description</code>: Optional <code>napi_value</code> which refers to a JavaScript\n<code>string</code> to be set as the description for the symbol.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>symbol</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>symbol</code> value from a UTF8-encoded C string.</p>\n<p>The JavaScript <code>symbol</code> type is described in <a href=\"https://tc39.github.io/ecma262/#sec-symbol-objects\">Section 19.4</a>\nof the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_symbol"
                 },
@@ -1255,8 +1263,8 @@
               "displayName": "Object creation functions"
             },
             {
-              "textRaw": "Functions to convert from C types to N-API",
-              "name": "functions_to_convert_from_c_types_to_n-api",
+              "textRaw": "Functions to convert from C types to Node-API",
+              "name": "functions_to_convert_from_c_types_to_node-api",
               "modules": [
                 {
                   "textRaw": "napi_create_int32",
@@ -1270,7 +1278,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>int32_t</code> type to the JavaScript\n<code>Number</code> type.</p>\n<p>The JavaScript <code>Number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>int32_t</code> type to the JavaScript\n<code>number</code> type.</p>\n<p>The JavaScript <code>number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_int32"
                 },
@@ -1286,7 +1294,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Unsigned integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>uint32_t</code> type to the JavaScript\n<code>Number</code> type.</p>\n<p>The JavaScript <code>Number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Unsigned integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>uint32_t</code> type to the JavaScript\n<code>number</code> type.</p>\n<p>The JavaScript <code>number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_uint32"
                 },
@@ -1302,7 +1310,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>int64_t</code> type to the JavaScript\n<code>Number</code> type.</p>\n<p>The JavaScript <code>Number</code> type is described in <a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a>\nof the ECMAScript Language Specification. Note the complete range of <code>int64_t</code>\ncannot be represented with full precision in JavaScript. Integer values\noutside the range of <a href=\"https://tc39.github.io/ecma262/#sec-number.min_safe_integer\"><code>Number.MIN_SAFE_INTEGER</code></a> <code>-(2**53 - 1)</code> -\n<a href=\"https://tc39.github.io/ecma262/#sec-number.max_safe_integer\"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose precision.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Integer value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>int64_t</code> type to the JavaScript\n<code>number</code> type.</p>\n<p>The JavaScript <code>number</code> type is described in <a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a>\nof the ECMAScript Language Specification. Note the complete range of <code>int64_t</code>\ncannot be represented with full precision in JavaScript. Integer values\noutside the range of <a href=\"https://tc39.github.io/ecma262/#sec-number.min_safe_integer\"><code>Number.MIN_SAFE_INTEGER</code></a> <code>-(2**53 - 1)</code> -\n<a href=\"https://tc39.github.io/ecma262/#sec-number.max_safe_integer\"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose precision.</p>",
                   "type": "module",
                   "displayName": "napi_create_int64"
                 },
@@ -1318,7 +1326,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_double(napi_env env, double value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Double-precision value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>double</code> type to the JavaScript\n<code>Number</code> type.</p>\n<p>The JavaScript <code>Number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_double(napi_env env, double value, napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: Double-precision value to be represented in JavaScript.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API is used to convert from the C <code>double</code> type to the JavaScript\n<code>number</code> type.</p>\n<p>The JavaScript <code>number</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type\">Section 6.1.6</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_double"
                 },
@@ -1382,7 +1390,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_latin1(napi_env env,\n                                      const char* str,\n                                      size_t length,\n                                      napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing an ISO-8859-1-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it\nis null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>String</code> object from an ISO-8859-1-encoded C\nstring. The native string is copied.</p>\n<p>The JavaScript <code>String</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_latin1(napi_env env,\n                                      const char* str,\n                                      size_t length,\n                                      napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing an ISO-8859-1-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it\nis null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>string</code> value from an ISO-8859-1-encoded C\nstring. The native string is copied.</p>\n<p>The JavaScript <code>string</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_string_latin1"
                 },
@@ -1398,7 +1406,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_utf16(napi_env env,\n                                     const char16_t* str,\n                                     size_t length,\n                                     napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing a UTF16-LE-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in two-byte code units, or\n<code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>String</code> object from a UTF16-LE-encoded C string.\nThe native string is copied.</p>\n<p>The JavaScript <code>String</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_utf16(napi_env env,\n                                     const char16_t* str,\n                                     size_t length,\n                                     napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing a UTF16-LE-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in two-byte code units, or\n<code>NAPI_AUTO_LENGTH</code> if it is null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>string</code> value from a UTF16-LE-encoded C string.\nThe native string is copied.</p>\n<p>The JavaScript <code>string</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_string_utf16"
                 },
@@ -1414,17 +1422,17 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_utf8(napi_env env,\n                                    const char* str,\n                                    size_t length,\n                                    napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing a UTF8-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it\nis null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>String</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>String</code> object from a UTF8-encoded C string.\nThe native string is copied.</p>\n<p>The JavaScript <code>String</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_create_string_utf8(napi_env env,\n                                    const char* str,\n                                    size_t length,\n                                    napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] str</code>: Character buffer representing a UTF8-encoded string.</li>\n<li><code>[in] length</code>: The length of the string in bytes, or <code>NAPI_AUTO_LENGTH</code> if it\nis null-terminated.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing a JavaScript <code>string</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API creates a JavaScript <code>string</code> value from a UTF8-encoded C string.\nThe native string is copied.</p>\n<p>The JavaScript <code>string</code> type is described in\n<a href=\"https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type\">Section 6.1.4</a> of the ECMAScript Language Specification.</p>",
                   "type": "module",
                   "displayName": "napi_create_string_utf8"
                 }
               ],
               "type": "module",
-              "displayName": "Functions to convert from C types to N-API"
+              "displayName": "Functions to convert from C types to Node-API"
             },
             {
-              "textRaw": "Functions to convert from N-API to C types",
-              "name": "functions_to_convert_from_n-api_to_c_types",
+              "textRaw": "Functions to convert from Node-API to C types",
+              "name": "functions_to_convert_from_node-api_to_c_types",
               "modules": [
                 {
                   "textRaw": "napi_get_array_length",
@@ -1518,7 +1526,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_dataview_info(napi_env env,\n                                   napi_value dataview,\n                                   size_t* byte_length,\n                                   void** data,\n                                   napi_value* arraybuffer,\n                                   size_t* byte_offset)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] dataview</code>: <code>napi_value</code> representing the <code>DataView</code> whose\nproperties to query.</li>\n<li><code>[out] byte_length</code>: <code>Number</code> of bytes in the <code>DataView</code>.</li>\n<li><code>[out] data</code>: The data buffer underlying the <code>DataView</code>.\nIf byte_length is <code>0</code>, this may be <code>NULL</code> or any other pointer value.</li>\n<li><code>[out] arraybuffer</code>: <code>ArrayBuffer</code> underlying the <code>DataView</code>.</li>\n<li><code>[out] byte_offset</code>: The byte offset within the data buffer from which\nto start projecting the <code>DataView</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns various properties of a <code>DataView</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_dataview_info(napi_env env,\n                                   napi_value dataview,\n                                   size_t* byte_length,\n                                   void** data,\n                                   napi_value* arraybuffer,\n                                   size_t* byte_offset)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] dataview</code>: <code>napi_value</code> representing the <code>DataView</code> whose\nproperties to query.</li>\n<li><code>[out] byte_length</code>: Number of bytes in the <code>DataView</code>.</li>\n<li><code>[out] data</code>: The data buffer underlying the <code>DataView</code>.\nIf byte_length is <code>0</code>, this may be <code>NULL</code> or any other pointer value.</li>\n<li><code>[out] arraybuffer</code>: <code>ArrayBuffer</code> underlying the <code>DataView</code>.</li>\n<li><code>[out] byte_offset</code>: The byte offset within the data buffer from which\nto start projecting the <code>DataView</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns various properties of a <code>DataView</code>.</p>",
                   "type": "module",
                   "displayName": "napi_get_dataview_info"
                 },
@@ -1527,7 +1535,8 @@
                   "name": "napi_get_date_value",
                   "meta": {
                     "added": [
-                      "v11.11.0"
+                      "v11.11.0",
+                      "v10.17.0"
                     ],
                     "napiVersion": [
                       5
@@ -1566,7 +1575,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_double(napi_env env,\n                                  napi_value value,\n                                  double* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>\n<li><code>[out] result</code>: C double primitive equivalent of the given JavaScript\n<code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code> is passed\nin it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C double primitive equivalent of the given JavaScript\n<code>Number</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_double(napi_env env,\n                                  napi_value value,\n                                  double* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>\n<li><code>[out] result</code>: C double primitive equivalent of the given JavaScript\n<code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code> is passed\nin it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C double primitive equivalent of the given JavaScript\n<code>number</code>.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_double"
                 },
@@ -1646,7 +1655,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_int32(napi_env env,\n                                 napi_value value,\n                                 int32_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>\n<li><code>[out] result</code>: C <code>int32</code> primitive equivalent of the given JavaScript\n<code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in <code>napi_number_expected</code>.</p>\n<p>This API returns the C <code>int32</code> primitive equivalent\nof the given JavaScript <code>Number</code>.</p>\n<p>If the number exceeds the range of the 32 bit integer, then the result is\ntruncated to the equivalent of the bottom 32 bits. This can result in a large\npositive number becoming a negative number if the value is > 2<sup>31</sup> - 1.</p>\n<p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the\nresult to zero.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_int32(napi_env env,\n                                 napi_value value,\n                                 int32_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>\n<li><code>[out] result</code>: C <code>int32</code> primitive equivalent of the given JavaScript\n<code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in <code>napi_number_expected</code>.</p>\n<p>This API returns the C <code>int32</code> primitive equivalent\nof the given JavaScript <code>number</code>.</p>\n<p>If the number exceeds the range of the 32 bit integer, then the result is\ntruncated to the equivalent of the bottom 32 bits. This can result in a large\npositive number becoming a negative number if the value is > 2<sup>31</sup> - 1.</p>\n<p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the\nresult to zero.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_int32"
                 },
@@ -1662,7 +1671,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_int64(napi_env env,\n                                 napi_value value,\n                                 int64_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>\n<li><code>[out] result</code>: C <code>int64</code> primitive equivalent of the given JavaScript\n<code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C <code>int64</code> primitive equivalent of the given JavaScript\n<code>Number</code>.</p>\n<p><code>Number</code> values outside the range of <a href=\"https://tc39.github.io/ecma262/#sec-number.min_safe_integer\"><code>Number.MIN_SAFE_INTEGER</code></a>\n<code>-(2**53 - 1)</code> - <a href=\"https://tc39.github.io/ecma262/#sec-number.max_safe_integer\"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose\nprecision.</p>\n<p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the\nresult to zero.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_int64(napi_env env,\n                                 napi_value value,\n                                 int64_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>\n<li><code>[out] result</code>: C <code>int64</code> primitive equivalent of the given JavaScript\n<code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C <code>int64</code> primitive equivalent of the given JavaScript\n<code>number</code>.</p>\n<p><code>number</code> values outside the range of <a href=\"https://tc39.github.io/ecma262/#sec-number.min_safe_integer\"><code>Number.MIN_SAFE_INTEGER</code></a>\n<code>-(2**53 - 1)</code> - <a href=\"https://tc39.github.io/ecma262/#sec-number.max_safe_integer\"><code>Number.MAX_SAFE_INTEGER</code></a> <code>(2**53 - 1)</code> will lose\nprecision.</p>\n<p>Non-finite number values (<code>NaN</code>, <code>+Infinity</code>, or <code>-Infinity</code>) set the\nresult to zero.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_int64"
                 },
@@ -1678,7 +1687,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_latin1(napi_env env,\n                                         napi_value value,\n                                         char* buf,\n                                         size_t bufsize,\n                                         size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the ISO-8859-1-encoded string into. If <code>NULL</code> is\npassed in, the length of the string (in bytes) is returned.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string will be truncated.</li>\n<li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null\nterminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the ISO-8859-1-encoded string corresponding the value passed\nin.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_latin1(napi_env env,\n                                         napi_value value,\n                                         char* buf,\n                                         size_t bufsize,\n                                         size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the ISO-8859-1-encoded string into. If <code>NULL</code> is\npassed in, the length of the string in bytes and excluding the null terminator\nis returned in <code>result</code>.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string is truncated and null-terminated.</li>\n<li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null\nterminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the ISO-8859-1-encoded string corresponding the value passed\nin.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_string_latin1"
                 },
@@ -1694,7 +1703,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_utf8(napi_env env,\n                                       napi_value value,\n                                       char* buf,\n                                       size_t bufsize,\n                                       size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the UTF8-encoded string into. If <code>NULL</code> is passed\nin, the length of the string (in bytes) is returned.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string will be truncated.</li>\n<li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null\nterminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the UTF8-encoded string corresponding the value passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_utf8(napi_env env,\n                                       napi_value value,\n                                       char* buf,\n                                       size_t bufsize,\n                                       size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the UTF8-encoded string into. If <code>NULL</code> is passed\nin, the length of the string in bytes and excluding the null terminator is\nreturned in <code>result</code>.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string is truncated and null-terminated.</li>\n<li><code>[out] result</code>: Number of bytes copied into the buffer, excluding the null\nterminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the UTF8-encoded string corresponding the value passed in.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_string_utf8"
                 },
@@ -1710,7 +1719,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_utf16(napi_env env,\n                                        napi_value value,\n                                        char16_t* buf,\n                                        size_t bufsize,\n                                        size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the UTF16-LE-encoded string into. If <code>NULL</code> is\npassed in, the length of the string (in 2-byte code units) is returned.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string will be truncated.</li>\n<li><code>[out] result</code>: Number of 2-byte code units copied into the buffer, excluding\nthe null terminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>String</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the UTF16-encoded string corresponding the value passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_string_utf16(napi_env env,\n                                        napi_value value,\n                                        char16_t* buf,\n                                        size_t bufsize,\n                                        size_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript string.</li>\n<li><code>[in] buf</code>: Buffer to write the UTF16-LE-encoded string into. If <code>NULL</code> is\npassed in, the length of the string in 2-byte code units and excluding the\nnull terminator is returned.</li>\n<li><code>[in] bufsize</code>: Size of the destination buffer. When this value is\ninsufficient, the returned string is truncated and null-terminated.</li>\n<li><code>[out] result</code>: Number of 2-byte code units copied into the buffer, excluding\nthe null terminator.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-<code>string</code> <code>napi_value</code>\nis passed in it returns <code>napi_string_expected</code>.</p>\n<p>This API returns the UTF16-encoded string corresponding the value passed in.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_string_utf16"
                 },
@@ -1726,13 +1735,13 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_uint32(napi_env env,\n                                  napi_value value,\n                                  uint32_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>Number</code>.</li>\n<li><code>[out] result</code>: C primitive equivalent of the given <code>napi_value</code> as a\n<code>uint32_t</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C primitive equivalent of the given <code>napi_value</code> as a\n<code>uint32_t</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_value_uint32(napi_env env,\n                                  napi_value value,\n                                  uint32_t* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: <code>napi_value</code> representing JavaScript <code>number</code>.</li>\n<li><code>[out] result</code>: C primitive equivalent of the given <code>napi_value</code> as a\n<code>uint32_t</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded. If a non-number <code>napi_value</code>\nis passed in it returns <code>napi_number_expected</code>.</p>\n<p>This API returns the C primitive equivalent of the given <code>napi_value</code> as a\n<code>uint32_t</code>.</p>",
                   "type": "module",
                   "displayName": "napi_get_value_uint32"
                 }
               ],
               "type": "module",
-              "displayName": "Functions to convert from N-API to C types"
+              "displayName": "Functions to convert from Node-API to C types"
             },
             {
               "textRaw": "Functions to get global instances",
@@ -1813,7 +1822,7 @@
         {
           "textRaw": "Working with JavaScript values and abstract operations",
           "name": "working_with_javascript_values_and_abstract_operations",
-          "desc": "<p>N-API exposes a set of APIs to perform some abstract operations on JavaScript\nvalues. Some of these operations are documented under <a href=\"https://tc39.github.io/ecma262/#sec-abstract-operations\">Section 7</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>These APIs support doing one of the following:</p>\n<ol>\n<li>Coerce JavaScript values to specific JavaScript types (such as <code>Number</code> or\n<code>String</code>).</li>\n<li>Check the type of a JavaScript value.</li>\n<li>Check for equality between two JavaScript values.</li>\n</ol>",
+          "desc": "<p>Node-API exposes a set of APIs to perform some abstract operations on JavaScript\nvalues. Some of these operations are documented under <a href=\"https://tc39.github.io/ecma262/#sec-abstract-operations\">Section 7</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>These APIs support doing one of the following:</p>\n<ol>\n<li>Coerce JavaScript values to specific JavaScript types (such as <code>number</code> or\n<code>string</code>).</li>\n<li>Check the type of a JavaScript value.</li>\n<li>Check for equality between two JavaScript values.</li>\n</ol>",
           "modules": [
             {
               "textRaw": "napi_coerce_to_bool",
@@ -1843,7 +1852,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_coerce_to_number(napi_env env,\n                                  napi_value value,\n                                  napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: The JavaScript value to coerce.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>Number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API implements the abstract operation <code>ToNumber()</code> as defined in\n<a href=\"https://tc39.github.io/ecma262/#sec-tonumber\">Section 7.1.3</a> of the ECMAScript Language Specification.\nThis API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_coerce_to_number(napi_env env,\n                                  napi_value value,\n                                  napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: The JavaScript value to coerce.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>number</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API implements the abstract operation <code>ToNumber()</code> as defined in\n<a href=\"https://tc39.github.io/ecma262/#sec-tonumber\">Section 7.1.3</a> of the ECMAScript Language Specification.\nThis API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>",
               "type": "module",
               "displayName": "napi_coerce_to_number"
             },
@@ -1875,7 +1884,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_coerce_to_string(napi_env env,\n                                  napi_value value,\n                                  napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: The JavaScript value to coerce.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>String</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API implements the abstract operation <code>ToString()</code> as defined in\n<a href=\"https://tc39.github.io/ecma262/#sec-toobject\">Section 7.1.13</a> of the ECMAScript Language Specification.\nThis API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_coerce_to_string(napi_env env,\n                                  napi_value value,\n                                  napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] value</code>: The JavaScript value to coerce.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the coerced JavaScript <code>string</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API implements the abstract operation <code>ToString()</code> as defined in\n<a href=\"https://tc39.github.io/ecma262/#sec-toobject\">Section 7.1.13</a> of the ECMAScript Language Specification.\nThis API can be re-entrant if getters are defined on the passed-in <code>Object</code>.</p>",
               "type": "module",
               "displayName": "napi_coerce_to_string"
             },
@@ -1964,7 +1973,8 @@
               "name": "napi_is_date",
               "meta": {
                 "added": [
-                  "v11.11.0"
+                  "v11.11.0",
+                  "v10.17.0"
                 ],
                 "napiVersion": [
                   5
@@ -2044,7 +2054,9 @@
               "name": "napi_detach_arraybuffer",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.0.0",
+                  "v12.16.0",
+                  "v10.22.0"
                 ],
                 "napiVersion": [
                   7
@@ -2060,7 +2072,9 @@
               "name": "napi_is_detached_arraybuffer",
               "meta": {
                 "added": [
-                  "v12.16.0"
+                  "v13.3.0",
+                  "v12.16.0",
+                  "v10.22.0"
                 ],
                 "napiVersion": [
                   7
@@ -2078,7 +2092,7 @@
         {
           "textRaw": "Working with JavaScript properties",
           "name": "working_with_javascript_properties",
-          "desc": "<p>N-API exposes a set of APIs to get and set properties on JavaScript\nobjects. Some of these types are documented under <a href=\"https://tc39.github.io/ecma262/#sec-abstract-operations\">Section 7</a> of the\n<a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>Properties in JavaScript are represented as a tuple of a key and a value.\nFundamentally, all property keys in N-API can be represented in one of the\nfollowing forms:</p>\n<ul>\n<li>Named: a simple UTF8-encoded string</li>\n<li>Integer-Indexed: an index value represented by <code>uint32_t</code></li>\n<li>JavaScript value: these are represented in N-API by <code>napi_value</code>. This can\nbe a <code>napi_value</code> representing a <code>String</code>, <code>Number</code>, or <code>Symbol</code>.</li>\n</ul>\n<p>N-API values are represented by the type <code>napi_value</code>.\nAny N-API call that requires a JavaScript value takes in a <code>napi_value</code>.\nHowever, it's the caller's responsibility to make sure that the\n<code>napi_value</code> in question is of the JavaScript type expected by the API.</p>\n<p>The APIs documented in this section provide a simple interface to\nget and set properties on arbitrary JavaScript objects represented by\n<code>napi_value</code>.</p>\n<p>For instance, consider the following JavaScript code snippet:</p>\n<pre><code class=\"language-js\">const obj = {};\nobj.myProp = 123;\n</code></pre>\n<p>The equivalent can be done using N-API values with the following snippet:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const obj = {}\nnapi_value obj, value;\nstatus = napi_create_object(env, &#x26;obj);\nif (status != napi_ok) return status;\n\n// Create a napi_value for 123\nstatus = napi_create_int32(env, 123, &#x26;value);\nif (status != napi_ok) return status;\n\n// obj.myProp = 123\nstatus = napi_set_named_property(env, obj, \"myProp\", value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Indexed properties can be set in a similar manner. Consider the following\nJavaScript snippet:</p>\n<pre><code class=\"language-js\">const arr = [];\narr[123] = 'hello';\n</code></pre>\n<p>The equivalent can be done using N-API values with the following snippet:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const arr = [];\nnapi_value arr, value;\nstatus = napi_create_array(env, &#x26;arr);\nif (status != napi_ok) return status;\n\n// Create a napi_value for 'hello'\nstatus = napi_create_string_utf8(env, \"hello\", NAPI_AUTO_LENGTH, &#x26;value);\nif (status != napi_ok) return status;\n\n// arr[123] = 'hello';\nstatus = napi_set_element(env, arr, 123, value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Properties can be retrieved using the APIs described in this section.\nConsider the following JavaScript snippet:</p>\n<pre><code class=\"language-js\">const arr = [];\nconst value = arr[123];\n</code></pre>\n<p>The following is the approximate equivalent of the N-API counterpart:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const arr = []\nnapi_value arr, value;\nstatus = napi_create_array(env, &#x26;arr);\nif (status != napi_ok) return status;\n\n// const value = arr[123]\nstatus = napi_get_element(env, arr, 123, &#x26;value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Finally, multiple properties can also be defined on an object for performance\nreasons. Consider the following JavaScript:</p>\n<pre><code class=\"language-js\">const obj = {};\nObject.defineProperties(obj, {\n  'foo': { value: 123, writable: true, configurable: true, enumerable: true },\n  'bar': { value: 456, writable: true, configurable: true, enumerable: true }\n});\n</code></pre>\n<p>The following is the approximate equivalent of the N-API counterpart:</p>\n<pre><code class=\"language-c\">napi_status status = napi_status_generic_failure;\n\n// const obj = {};\nnapi_value obj;\nstatus = napi_create_object(env, &#x26;obj);\nif (status != napi_ok) return status;\n\n// Create napi_values for 123 and 456\nnapi_value fooValue, barValue;\nstatus = napi_create_int32(env, 123, &#x26;fooValue);\nif (status != napi_ok) return status;\nstatus = napi_create_int32(env, 456, &#x26;barValue);\nif (status != napi_ok) return status;\n\n// Set the properties\nnapi_property_descriptor descriptors[] = {\n  { \"foo\", NULL, NULL, NULL, NULL, fooValue, napi_writable | napi_configurable, NULL },\n  { \"bar\", NULL, NULL, NULL, NULL, barValue, napi_writable | napi_configurable, NULL }\n}\nstatus = napi_define_properties(env,\n                                obj,\n                                sizeof(descriptors) / sizeof(descriptors[0]),\n                                descriptors);\nif (status != napi_ok) return status;\n</code></pre>",
+          "desc": "<p>Node-API exposes a set of APIs to get and set properties on JavaScript\nobjects. Some of these types are documented under <a href=\"https://tc39.github.io/ecma262/#sec-abstract-operations\">Section 7</a> of the\n<a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</p>\n<p>Properties in JavaScript are represented as a tuple of a key and a value.\nFundamentally, all property keys in Node-API can be represented in one of the\nfollowing forms:</p>\n<ul>\n<li>Named: a simple UTF8-encoded string</li>\n<li>Integer-Indexed: an index value represented by <code>uint32_t</code></li>\n<li>JavaScript value: these are represented in Node-API by <code>napi_value</code>. This can\nbe a <code>napi_value</code> representing a <code>string</code>, <code>number</code>, or <code>symbol</code>.</li>\n</ul>\n<p>Node-API values are represented by the type <code>napi_value</code>.\nAny Node-API call that requires a JavaScript value takes in a <code>napi_value</code>.\nHowever, it's the caller's responsibility to make sure that the\n<code>napi_value</code> in question is of the JavaScript type expected by the API.</p>\n<p>The APIs documented in this section provide a simple interface to\nget and set properties on arbitrary JavaScript objects represented by\n<code>napi_value</code>.</p>\n<p>For instance, consider the following JavaScript code snippet:</p>\n<pre><code class=\"language-js\">const obj = {};\nobj.myProp = 123;\n</code></pre>\n<p>The equivalent can be done using Node-API values with the following snippet:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const obj = {}\nnapi_value obj, value;\nstatus = napi_create_object(env, &#x26;obj);\nif (status != napi_ok) return status;\n\n// Create a napi_value for 123\nstatus = napi_create_int32(env, 123, &#x26;value);\nif (status != napi_ok) return status;\n\n// obj.myProp = 123\nstatus = napi_set_named_property(env, obj, \"myProp\", value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Indexed properties can be set in a similar manner. Consider the following\nJavaScript snippet:</p>\n<pre><code class=\"language-js\">const arr = [];\narr[123] = 'hello';\n</code></pre>\n<p>The equivalent can be done using Node-API values with the following snippet:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const arr = [];\nnapi_value arr, value;\nstatus = napi_create_array(env, &#x26;arr);\nif (status != napi_ok) return status;\n\n// Create a napi_value for 'hello'\nstatus = napi_create_string_utf8(env, \"hello\", NAPI_AUTO_LENGTH, &#x26;value);\nif (status != napi_ok) return status;\n\n// arr[123] = 'hello';\nstatus = napi_set_element(env, arr, 123, value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Properties can be retrieved using the APIs described in this section.\nConsider the following JavaScript snippet:</p>\n<pre><code class=\"language-js\">const arr = [];\nconst value = arr[123];\n</code></pre>\n<p>The following is the approximate equivalent of the Node-API counterpart:</p>\n<pre><code class=\"language-c\">napi_status status = napi_generic_failure;\n\n// const arr = []\nnapi_value arr, value;\nstatus = napi_create_array(env, &#x26;arr);\nif (status != napi_ok) return status;\n\n// const value = arr[123]\nstatus = napi_get_element(env, arr, 123, &#x26;value);\nif (status != napi_ok) return status;\n</code></pre>\n<p>Finally, multiple properties can also be defined on an object for performance\nreasons. Consider the following JavaScript:</p>\n<pre><code class=\"language-js\">const obj = {};\nObject.defineProperties(obj, {\n  'foo': { value: 123, writable: true, configurable: true, enumerable: true },\n  'bar': { value: 456, writable: true, configurable: true, enumerable: true }\n});\n</code></pre>\n<p>The following is the approximate equivalent of the Node-API counterpart:</p>\n<pre><code class=\"language-c\">napi_status status = napi_status_generic_failure;\n\n// const obj = {};\nnapi_value obj;\nstatus = napi_create_object(env, &#x26;obj);\nif (status != napi_ok) return status;\n\n// Create napi_values for 123 and 456\nnapi_value fooValue, barValue;\nstatus = napi_create_int32(env, 123, &#x26;fooValue);\nif (status != napi_ok) return status;\nstatus = napi_create_int32(env, 456, &#x26;barValue);\nif (status != napi_ok) return status;\n\n// Set the properties\nnapi_property_descriptor descriptors[] = {\n  { \"foo\", NULL, NULL, NULL, NULL, fooValue, napi_writable | napi_configurable, NULL },\n  { \"bar\", NULL, NULL, NULL, NULL, barValue, napi_writable | napi_configurable, NULL }\n}\nstatus = napi_define_properties(env,\n                                obj,\n                                sizeof(descriptors) / sizeof(descriptors[0]),\n                                descriptors);\nif (status != napi_ok) return status;\n</code></pre>",
           "modules": [
             {
               "textRaw": "Structures",
@@ -2090,20 +2104,20 @@
                   "meta": {
                     "changes": [
                       {
-                        "version": "v12.20.0",
+                        "version": "v14.12.0",
                         "pr-url": "https://github.com/nodejs/node/pull/35214",
-                        "description": "added `napi_default_method` and `napi_default_property`"
+                        "description": "added `napi_default_method` and `napi_default_property`."
                       }
                     ]
                   },
-                  "desc": "<pre><code class=\"language-c\">typedef enum {\n  napi_default = 0,\n  napi_writable = 1 &#x3C;&#x3C; 0,\n  napi_enumerable = 1 &#x3C;&#x3C; 1,\n  napi_configurable = 1 &#x3C;&#x3C; 2,\n\n  // Used with napi_define_class to distinguish static properties\n  // from instance properties. Ignored by napi_define_properties.\n  napi_static = 1 &#x3C;&#x3C; 10,\n\n  // Default for class methods.\n  napi_default_method = napi_writable | napi_configurable,\n\n  // Default for object properties, like in JS obj[prop].\n  napi_default_property = napi_writable |\n                          napi_enumerable |\n                          napi_configurable,\n} napi_property_attributes;\n</code></pre>\n<p><code>napi_property_attributes</code> are flags used to control the behavior of properties\nset on a JavaScript object. Other than <code>napi_static</code> they correspond to the\nattributes listed in <a href=\"https://tc39.github.io/ecma262/#table-2\">Section 6.1.7.1</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.\nThey can be one or more of the following bitflags:</p>\n<ul>\n<li><code>napi_default</code>: No explicit attributes are set on the property. By default, a\nproperty is read only, not enumerable and not configurable.</li>\n<li><code>napi_writable</code>: The property is writable.</li>\n<li><code>napi_enumerable</code>: The property is enumerable.</li>\n<li><code>napi_configurable</code>: The property is configurable as defined in\n<a href=\"https://tc39.github.io/ecma262/#table-2\">Section 6.1.7.1</a> of the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</li>\n<li><code>napi_static</code>: The property will be defined as a static property on a class as\nopposed to an instance property, which is the default. This is used only by\n<a href=\"#n_api_napi_define_class\"><code>napi_define_class</code></a>. It is ignored by <code>napi_define_properties</code>.</li>\n<li><code>napi_default_method</code>: The property is configureable, writeable but not\nenumerable like a method in a JS class.</li>\n<li><code>napi_default_property</code>: The property is writable, enumerable and configurable\nlike a property set via JS code <code>obj.key = value</code>.</li>\n</ul>",
+                  "desc": "<pre><code class=\"language-c\">typedef enum {\n  napi_default = 0,\n  napi_writable = 1 &#x3C;&#x3C; 0,\n  napi_enumerable = 1 &#x3C;&#x3C; 1,\n  napi_configurable = 1 &#x3C;&#x3C; 2,\n\n  // Used with napi_define_class to distinguish static properties\n  // from instance properties. Ignored by napi_define_properties.\n  napi_static = 1 &#x3C;&#x3C; 10,\n\n  // Default for class methods.\n  napi_default_method = napi_writable | napi_configurable,\n\n  // Default for object properties, like in JS obj[prop].\n  napi_default_jsproperty = napi_writable |\n                          napi_enumerable |\n                          napi_configurable,\n} napi_property_attributes;\n</code></pre>\n<p><code>napi_property_attributes</code> are flags used to control the behavior of properties\nset on a JavaScript object. Other than <code>napi_static</code> they correspond to the\nattributes listed in <a href=\"https://tc39.github.io/ecma262/#table-2\">Section 6.1.7.1</a>\nof the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.\nThey can be one or more of the following bitflags:</p>\n<ul>\n<li><code>napi_default</code>: No explicit attributes are set on the property. By default, a\nproperty is read only, not enumerable and not configurable.</li>\n<li><code>napi_writable</code>: The property is writable.</li>\n<li><code>napi_enumerable</code>: The property is enumerable.</li>\n<li><code>napi_configurable</code>: The property is configurable as defined in\n<a href=\"https://tc39.github.io/ecma262/#table-2\">Section 6.1.7.1</a> of the <a href=\"https://tc39.github.io/ecma262/\">ECMAScript Language Specification</a>.</li>\n<li><code>napi_static</code>: The property will be defined as a static property on a class as\nopposed to an instance property, which is the default. This is used only by\n<a href=\"#n_api_napi_define_class\"><code>napi_define_class</code></a>. It is ignored by <code>napi_define_properties</code>.</li>\n<li><code>napi_default_method</code>: Like a method in a JS class, the property is\nconfigurable and writeable, but not enumerable.</li>\n<li><code>napi_default_jsproperty</code>: Like a property set via assignment in JavaScript,\nthe property is writable, enumerable, and configurable.</li>\n</ul>",
                   "type": "module",
                   "displayName": "napi_property_attributes"
                 },
                 {
                   "textRaw": "napi_property_descriptor",
                   "name": "napi_property_descriptor",
-                  "desc": "<pre><code class=\"language-c\">typedef struct {\n  // One of utf8name or name should be NULL.\n  const char* utf8name;\n  napi_value name;\n\n  napi_callback method;\n  napi_callback getter;\n  napi_callback setter;\n  napi_value value;\n\n  napi_property_attributes attributes;\n  void* data;\n} napi_property_descriptor;\n</code></pre>\n<ul>\n<li><code>utf8name</code>: Optional <code>String</code> describing the key for the property,\nencoded as UTF8. One of <code>utf8name</code> or <code>name</code> must be provided for the\nproperty.</li>\n<li><code>name</code>: Optional <code>napi_value</code> that points to a JavaScript string or symbol\nto be used as the key for the property. One of <code>utf8name</code> or <code>name</code> must\nbe provided for the property.</li>\n<li><code>value</code>: The value that's retrieved by a get access of the property if the\nproperty is a data property. If this is passed in, set <code>getter</code>, <code>setter</code>,\n<code>method</code> and <code>data</code> to <code>NULL</code> (since these members won't be used).</li>\n<li><code>getter</code>: A function to call when a get access of the property is performed.\nIf this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members\nwon't be used). The given function is called implicitly by the runtime when\nthe property is accessed from JavaScript code (or if a get on the property is\nperformed using a N-API call). <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>setter</code>: A function to call when a set access of the property is performed.\nIf this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members\nwon't be used). The given function is called implicitly by the runtime when\nthe property is set from JavaScript code (or if a set on the property is\nperformed using a N-API call). <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>method</code>: Set this to make the property descriptor object's <code>value</code>\nproperty to be a JavaScript function represented by <code>method</code>. If this is\npassed in, set <code>value</code>, <code>getter</code> and <code>setter</code> to <code>NULL</code> (since these members\nwon't be used). <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>attributes</code>: The attributes associated with the particular property. See\n<a href=\"#n_api_napi_property_attributes\"><code>napi_property_attributes</code></a>.</li>\n<li><code>data</code>: The callback data passed into <code>method</code>, <code>getter</code> and <code>setter</code> if this\nfunction is invoked.</li>\n</ul>",
+                  "desc": "<pre><code class=\"language-c\">typedef struct {\n  // One of utf8name or name should be NULL.\n  const char* utf8name;\n  napi_value name;\n\n  napi_callback method;\n  napi_callback getter;\n  napi_callback setter;\n  napi_value value;\n\n  napi_property_attributes attributes;\n  void* data;\n} napi_property_descriptor;\n</code></pre>\n<ul>\n<li><code>utf8name</code>: Optional string describing the key for the property,\nencoded as UTF8. One of <code>utf8name</code> or <code>name</code> must be provided for the\nproperty.</li>\n<li><code>name</code>: Optional <code>napi_value</code> that points to a JavaScript string or symbol\nto be used as the key for the property. One of <code>utf8name</code> or <code>name</code> must\nbe provided for the property.</li>\n<li><code>value</code>: The value that's retrieved by a get access of the property if the\nproperty is a data property. If this is passed in, set <code>getter</code>, <code>setter</code>,\n<code>method</code> and <code>data</code> to <code>NULL</code> (since these members won't be used).</li>\n<li><code>getter</code>: A function to call when a get access of the property is performed.\nIf this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members\nwon't be used). The given function is called implicitly by the runtime when\nthe property is accessed from JavaScript code (or if a get on the property is\nperformed using a Node-API call). <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>setter</code>: A function to call when a set access of the property is performed.\nIf this is passed in, set <code>value</code> and <code>method</code> to <code>NULL</code> (since these members\nwon't be used). The given function is called implicitly by the runtime when\nthe property is set from JavaScript code (or if a set on the property is\nperformed using a Node-API call). <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>method</code>: Set this to make the property descriptor object's <code>value</code>\nproperty to be a JavaScript function represented by <code>method</code>. If this is\npassed in, set <code>value</code>, <code>getter</code> and <code>setter</code> to <code>NULL</code> (since these members\nwon't be used). <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>attributes</code>: The attributes associated with the particular property. See\n<a href=\"#n_api_napi_property_attributes\"><code>napi_property_attributes</code></a>.</li>\n<li><code>data</code>: The callback data passed into <code>method</code>, <code>getter</code> and <code>setter</code> if this\nfunction is invoked.</li>\n</ul>",
                   "type": "module",
                   "displayName": "napi_property_descriptor"
                 }
@@ -2127,7 +2141,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_property_names(napi_env env,\n                                    napi_value object,\n                                    napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values\nthat represent the property names of the object. The API can be used to\niterate over <code>result</code> using <a href=\"#n_api_napi_get_array_length\"><code>napi_get_array_length</code></a>\nand <a href=\"#n_api_napi_get_element\"><code>napi_get_element</code></a>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns the names of the enumerable properties of <code>object</code> as an array\nof strings. The properties of <code>object</code> whose key is a symbol will not be\nincluded.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_property_names(napi_env env,\n                                    napi_value object,\n                                    napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values\nthat represent the property names of the object. The API can be used to\niterate over <code>result</code> using <a href=\"#n_api_napi_get_array_length\"><code>napi_get_array_length</code></a>\nand <a href=\"#n_api_napi_get_element\"><code>napi_get_element</code></a>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns the names of the enumerable properties of <code>object</code> as an array\nof strings. The properties of <code>object</code> whose key is a symbol will not be\nincluded.</p>",
                   "type": "module",
                   "displayName": "napi_get_property_names"
                 },
@@ -2136,14 +2150,15 @@
                   "name": "napi_get_all_property_names",
                   "meta": {
                     "added": [
-                      "v12.17.0"
+                      "v13.7.0",
+                      "v10.20.0"
                     ],
                     "napiVersion": [
                       6
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_get_all_property_names(napi_env env,\n                            napi_value object,\n                            napi_key_collection_mode key_mode,\n                            napi_key_filter key_filter,\n                            napi_key_conversion key_conversion,\n                            napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[in] key_mode</code>: Whether to retrieve prototype properties as well.</li>\n<li><code>[in] key_filter</code>: Which properties to retrieve\n(enumerable/readable/writable).</li>\n<li><code>[in] key_conversion</code>: Whether to convert numbered property keys to strings.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values\nthat represent the property names of the object. <a href=\"#n_api_napi_get_array_length\"><code>napi_get_array_length</code></a> and\n<a href=\"#n_api_napi_get_element\"><code>napi_get_element</code></a> can be used to iterate over <code>result</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an array containing the names of the available properties\nof this object.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_get_all_property_names(napi_env env,\n                            napi_value object,\n                            napi_key_collection_mode key_mode,\n                            napi_key_filter key_filter,\n                            napi_key_conversion key_conversion,\n                            napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[in] key_mode</code>: Whether to retrieve prototype properties as well.</li>\n<li><code>[in] key_filter</code>: Which properties to retrieve\n(enumerable/readable/writable).</li>\n<li><code>[in] key_conversion</code>: Whether to convert numbered property keys to strings.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing an array of JavaScript values\nthat represent the property names of the object. <a href=\"#n_api_napi_get_array_length\"><code>napi_get_array_length</code></a>\nand <a href=\"#n_api_napi_get_element\"><code>napi_get_element</code></a> can be used to iterate over <code>result</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns an array containing the names of the available properties\nof this object.</p>",
                   "type": "module",
                   "displayName": "napi_get_all_property_names"
                 },
@@ -2159,7 +2174,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object on which to set the property.</li>\n<li><code>[in] key</code>: The name of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API set a property on the <code>Object</code> passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object on which to set the property.</li>\n<li><code>[in] key</code>: The name of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API set a property on the <code>Object</code> passed in.</p>",
                   "type": "module",
                   "displayName": "napi_set_property"
                 },
@@ -2175,7 +2190,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] key</code>: The name of the property to retrieve.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API gets the requested property from the <code>Object</code> passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] key</code>: The name of the property to retrieve.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API gets the requested property from the <code>Object</code> passed in.</p>",
                   "type": "module",
                   "displayName": "napi_get_property"
                 },
@@ -2191,7 +2206,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API checks if the <code>Object</code> passed in has the named property.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_property(napi_env env,\n                              napi_value object,\n                              napi_value key,\n                              bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API checks if the <code>Object</code> passed in has the named property.</p>",
                   "type": "module",
                   "displayName": "napi_has_property"
                 },
@@ -2207,7 +2222,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_delete_property(napi_env env,\n                                 napi_value object,\n                                 napi_value key,\n                                 bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the property to delete.</li>\n<li><code>[out] result</code>: Whether the property deletion succeeded or not. <code>result</code> can\noptionally be ignored by passing <code>NULL</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API attempts to delete the <code>key</code> own property from <code>object</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_delete_property(napi_env env,\n                                 napi_value object,\n                                 napi_value key,\n                                 bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the property to delete.</li>\n<li><code>[out] result</code>: Whether the property deletion succeeded or not. <code>result</code> can\noptionally be ignored by passing <code>NULL</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API attempts to delete the <code>key</code> own property from <code>object</code>.</p>",
                   "type": "module",
                   "displayName": "napi_delete_property"
                 },
@@ -2223,7 +2238,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_own_property(napi_env env,\n                                  napi_value object,\n                                  napi_value key,\n                                  bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the own property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the own property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API checks if the <code>Object</code> passed in has the named own property. <code>key</code> must\nbe a string or a <code>Symbol</code>, or an error will be thrown. N-API will not perform\nany conversion between data types.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_own_property(napi_env env,\n                                  napi_value object,\n                                  napi_value key,\n                                  bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] key</code>: The name of the own property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the own property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API checks if the <code>Object</code> passed in has the named own property. <code>key</code> must\nbe a <code>string</code> or a <code>symbol</code>, or an error will be thrown. Node-API will not\nperform any conversion between data types.</p>",
                   "type": "module",
                   "displayName": "napi_has_own_property"
                 },
@@ -2239,7 +2254,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object on which to set the property.</li>\n<li><code>[in] utf8Name</code>: The name of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"#n_api_napi_set_property\"><code>napi_set_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object on which to set the property.</li>\n<li><code>[in] utf8Name</code>: The name of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"#n_api_napi_set_property\"><code>napi_set_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
                   "type": "module",
                   "displayName": "napi_set_named_property"
                 },
@@ -2255,7 +2270,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] utf8Name</code>: The name of the property to get.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"#n_api_napi_get_property\"><code>napi_get_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] utf8Name</code>: The name of the property to get.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"#n_api_napi_get_property\"><code>napi_get_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
                   "type": "module",
                   "displayName": "napi_get_named_property"
                 },
@@ -2271,7 +2286,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] utf8Name</code>: The name of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"#n_api_napi_has_property\"><code>napi_has_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_named_property(napi_env env,\n                                    napi_value object,\n                                    const char* utf8Name,\n                                    bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] utf8Name</code>: The name of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is equivalent to calling <a href=\"#n_api_napi_has_property\"><code>napi_has_property</code></a> with a <code>napi_value</code>\ncreated from the string passed in as <code>utf8Name</code>.</p>",
                   "type": "module",
                   "displayName": "napi_has_named_property"
                 },
@@ -2287,7 +2302,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to set the properties.</li>\n<li><code>[in] index</code>: The index of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API sets and element on the <code>Object</code> passed in.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_set_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             napi_value value);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to set the properties.</li>\n<li><code>[in] index</code>: The index of the property to set.</li>\n<li><code>[in] value</code>: The property value.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API sets and element on the <code>Object</code> passed in.</p>",
                   "type": "module",
                   "displayName": "napi_set_element"
                 },
@@ -2303,7 +2318,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] index</code>: The index of the property to get.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API gets the element at the requested index.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_get_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the property.</li>\n<li><code>[in] index</code>: The index of the property to get.</li>\n<li><code>[out] result</code>: The value of the property.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API gets the element at the requested index.</p>",
                   "type": "module",
                   "displayName": "napi_get_element"
                 },
@@ -2319,7 +2334,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] index</code>: The index of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns if the <code>Object</code> passed in has an element at the\nrequested index.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_has_element(napi_env env,\n                             napi_value object,\n                             uint32_t index,\n                             bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] index</code>: The index of the property whose existence to check.</li>\n<li><code>[out] result</code>: Whether the property exists on the object or not.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns if the <code>Object</code> passed in has an element at the\nrequested index.</p>",
                   "type": "module",
                   "displayName": "napi_has_element"
                 },
@@ -2335,7 +2350,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_delete_element(napi_env env,\n                                napi_value object,\n                                uint32_t index,\n                                bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] index</code>: The index of the property to delete.</li>\n<li><code>[out] result</code>: Whether the element deletion succeeded or not. <code>result</code> can\noptionally be ignored by passing <code>NULL</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API attempts to delete the specified <code>index</code> from <code>object</code>.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_delete_element(napi_env env,\n                                napi_value object,\n                                uint32_t index,\n                                bool* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to query.</li>\n<li><code>[in] index</code>: The index of the property to delete.</li>\n<li><code>[out] result</code>: Whether the element deletion succeeded or not. <code>result</code> can\noptionally be ignored by passing <code>NULL</code>.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API attempts to delete the specified <code>index</code> from <code>object</code>.</p>",
                   "type": "module",
                   "displayName": "napi_delete_element"
                 },
@@ -2351,7 +2366,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_define_properties(napi_env env,\n                                   napi_value object,\n                                   size_t property_count,\n                                   const napi_property_descriptor* properties);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[in] property_count</code>: The number of elements in the <code>properties</code> array.</li>\n<li><code>[in] properties</code>: The array of property descriptors.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows the efficient definition of multiple properties on a given\nobject. The properties are defined using property descriptors (see\n<a href=\"#n_api_napi_property_descriptor\"><code>napi_property_descriptor</code></a>). Given an array of such property descriptors,\nthis API will set the properties on the object one at a time, as defined by\n<code>DefineOwnProperty()</code> (described in <a href=\"https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc\">Section 9.1.6</a> of the ECMA-262\nspecification).</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_define_properties(napi_env env,\n                                   napi_value object,\n                                   size_t property_count,\n                                   const napi_property_descriptor* properties);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object from which to retrieve the properties.</li>\n<li><code>[in] property_count</code>: The number of elements in the <code>properties</code> array.</li>\n<li><code>[in] properties</code>: The array of property descriptors.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows the efficient definition of multiple properties on a given\nobject. The properties are defined using property descriptors (see\n<a href=\"#n_api_napi_property_descriptor\"><code>napi_property_descriptor</code></a>). Given an array of such property descriptors,\nthis API will set the properties on the object one at a time, as defined by\n<code>DefineOwnProperty()</code> (described in <a href=\"https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc\">Section 9.1.6</a> of the ECMA-262\nspecification).</p>",
                   "type": "module",
                   "displayName": "napi_define_properties"
                 },
@@ -2360,6 +2375,7 @@
                   "name": "napi_object_freeze",
                   "meta": {
                     "added": [
+                      "v14.14.0",
                       "v12.20.0"
                     ],
                     "napiVersion": [
@@ -2367,7 +2383,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_object_freeze(napi_env env,\n                               napi_value object);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to freeze.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method freezes a given object. This prevents new properties from\nbeing added to it, existing properties from being removed, prevents\nchanging the enumerability, configurability, or writability of existing\nproperties, and prevents the values of existing properties from being changed.\nIt also prevents the object's prototype from being changed. This is described\nin <a href=\"https://tc39.es/ecma262/#sec-object.freeze\">Section 19.1.2.6</a> of the\nECMA-262 specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_object_freeze(napi_env env,\n                               napi_value object);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to freeze.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method freezes a given object. This prevents new properties from\nbeing added to it, existing properties from being removed, prevents\nchanging the enumerability, configurability, or writability of existing\nproperties, and prevents the values of existing properties from being changed.\nIt also prevents the object's prototype from being changed. This is described\nin <a href=\"https://tc39.es/ecma262/#sec-object.freeze\">Section 19.1.2.6</a> of the\nECMA-262 specification.</p>",
                   "type": "module",
                   "displayName": "napi_object_freeze"
                 },
@@ -2376,6 +2392,7 @@
                   "name": "napi_object_seal",
                   "meta": {
                     "added": [
+                      "v14.14.0",
                       "v12.20.0"
                     ],
                     "napiVersion": [
@@ -2383,7 +2400,7 @@
                     ],
                     "changes": []
                   },
-                  "desc": "<pre><code class=\"language-c\">napi_status napi_object_seal(napi_env env,\n                             napi_value object);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the N-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to seal.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method seals a given object. This prevents new properties from being\nadded to it, as well as marking all existing properties as non-configurable.\nThis is described in <a href=\"https://tc39.es/ecma262/#sec-object.seal\">Section 19.1.2.20</a>\nof the ECMA-262 specification.</p>",
+                  "desc": "<pre><code class=\"language-c\">napi_status napi_object_seal(napi_env env,\n                             napi_value object);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the Node-API call is invoked under.</li>\n<li><code>[in] object</code>: The object to seal.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method seals a given object. This prevents new properties from being\nadded to it, as well as marking all existing properties as non-configurable.\nThis is described in <a href=\"https://tc39.es/ecma262/#sec-object.seal\">Section 19.1.2.20</a>\nof the ECMA-262 specification.</p>",
                   "type": "module",
                   "displayName": "napi_object_seal"
                 }
@@ -2398,7 +2415,7 @@
         {
           "textRaw": "Working with JavaScript functions",
           "name": "working_with_javascript_functions",
-          "desc": "<p>N-API provides a set of APIs that allow JavaScript code to\ncall back into native code. N-API APIs that support calling back\ninto native code take in a callback functions represented by\nthe <code>napi_callback</code> type. When the JavaScript VM calls back to\nnative code, the <code>napi_callback</code> function provided is invoked. The APIs\ndocumented in this section allow the callback function to do the\nfollowing:</p>\n<ul>\n<li>Get information about the context in which the callback was invoked.</li>\n<li>Get the arguments passed into the callback.</li>\n<li>Return a <code>napi_value</code> back from the callback.</li>\n</ul>\n<p>Additionally, N-API provides a set of functions which allow calling\nJavaScript functions from native code. One can either call a function\nlike a regular JavaScript function call, or as a constructor\nfunction.</p>\n<p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> field of the\n<code>napi_property_descriptor</code> items can be associated with <code>object</code> and freed\nwhenever <code>object</code> is garbage-collected by passing both <code>object</code> and the data to\n<a href=\"#n_api_napi_add_finalizer\"><code>napi_add_finalizer</code></a>.</p>",
+          "desc": "<p>Node-API provides a set of APIs that allow JavaScript code to\ncall back into native code. Node-APIs that support calling back\ninto native code take in a callback functions represented by\nthe <code>napi_callback</code> type. When the JavaScript VM calls back to\nnative code, the <code>napi_callback</code> function provided is invoked. The APIs\ndocumented in this section allow the callback function to do the\nfollowing:</p>\n<ul>\n<li>Get information about the context in which the callback was invoked.</li>\n<li>Get the arguments passed into the callback.</li>\n<li>Return a <code>napi_value</code> back from the callback.</li>\n</ul>\n<p>Additionally, Node-API provides a set of functions which allow calling\nJavaScript functions from native code. One can either call a function\nlike a regular JavaScript function call, or as a constructor\nfunction.</p>\n<p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> field of the\n<code>napi_property_descriptor</code> items can be associated with <code>object</code> and freed\nwhenever <code>object</code> is garbage-collected by passing both <code>object</code> and the data to\n<a href=\"#n_api_napi_add_finalizer\"><code>napi_add_finalizer</code></a>.</p>",
           "modules": [
             {
               "textRaw": "napi_call_function",
@@ -2412,7 +2429,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_call_function(napi_env env,\n                                           napi_value recv,\n                                           napi_value func,\n                                           size_t argc,\n                                           const napi_value* argv,\n                                           napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] recv</code>: The <code>this</code> object passed to the called function.</li>\n<li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of <code>napi_values</code> representing JavaScript values passed in\nas arguments to the function.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows a JavaScript function object to be called from a native\nadd-on. This is the primary mechanism of calling back <em>from</em> the add-on's\nnative code <em>into</em> JavaScript. For the special case of calling into JavaScript\nafter an async operation, see <a href=\"#n_api_napi_make_callback\"><code>napi_make_callback</code></a>.</p>\n<p>A sample use case might look as follows. Consider the following JavaScript\nsnippet:</p>\n<pre><code class=\"language-js\">function AddTwo(num) {\n  return num + 2;\n}\n</code></pre>\n<p>Then, the above function can be invoked from a native add-on using the\nfollowing code:</p>\n<pre><code class=\"language-c\">// Get the function named \"AddTwo\" on the global object\nnapi_value global, add_two, arg;\nnapi_status status = napi_get_global(env, &#x26;global);\nif (status != napi_ok) return;\n\nstatus = napi_get_named_property(env, global, \"AddTwo\", &#x26;add_two);\nif (status != napi_ok) return;\n\n// const arg = 1337\nstatus = napi_create_int32(env, 1337, &#x26;arg);\nif (status != napi_ok) return;\n\nnapi_value* argv = &#x26;arg;\nsize_t argc = 1;\n\n// AddTwo(arg);\nnapi_value return_val;\nstatus = napi_call_function(env, global, add_two, argc, argv, &#x26;return_val);\nif (status != napi_ok) return;\n\n// Convert the result back to a native type\nint32_t result;\nstatus = napi_get_value_int32(env, return_val, &#x26;result);\nif (status != napi_ok) return;\n</code></pre>",
+              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_call_function(napi_env env,\n                                           napi_value recv,\n                                           napi_value func,\n                                           size_t argc,\n                                           const napi_value* argv,\n                                           napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] recv</code>: The <code>this</code> value passed to the called function.</li>\n<li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of <code>napi_values</code> representing JavaScript values passed in\nas arguments to the function.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows a JavaScript function object to be called from a native\nadd-on. This is the primary mechanism of calling back <em>from</em> the add-on's\nnative code <em>into</em> JavaScript. For the special case of calling into JavaScript\nafter an async operation, see <a href=\"#n_api_napi_make_callback\"><code>napi_make_callback</code></a>.</p>\n<p>A sample use case might look as follows. Consider the following JavaScript\nsnippet:</p>\n<pre><code class=\"language-js\">function AddTwo(num) {\n  return num + 2;\n}\n</code></pre>\n<p>Then, the above function can be invoked from a native add-on using the\nfollowing code:</p>\n<pre><code class=\"language-c\">// Get the function named \"AddTwo\" on the global object\nnapi_value global, add_two, arg;\nnapi_status status = napi_get_global(env, &#x26;global);\nif (status != napi_ok) return;\n\nstatus = napi_get_named_property(env, global, \"AddTwo\", &#x26;add_two);\nif (status != napi_ok) return;\n\n// const arg = 1337\nstatus = napi_create_int32(env, 1337, &#x26;arg);\nif (status != napi_ok) return;\n\nnapi_value* argv = &#x26;arg;\nsize_t argc = 1;\n\n// AddTwo(arg);\nnapi_value return_val;\nstatus = napi_call_function(env, global, add_two, argc, argv, &#x26;return_val);\nif (status != napi_ok) return;\n\n// Convert the result back to a native type\nint32_t result;\nstatus = napi_get_value_int32(env, return_val, &#x26;result);\nif (status != napi_ok) return;\n</code></pre>",
               "type": "module",
               "displayName": "napi_call_function"
             },
@@ -2444,7 +2461,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_get_cb_info(napi_env env,\n                             napi_callback_info cbinfo,\n                             size_t* argc,\n                             napi_value* argv,\n                             napi_value* thisArg,\n                             void** data)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] cbinfo</code>: The callback info passed into the callback function.</li>\n<li><code>[in-out] argc</code>: Specifies the size of the provided <code>argv</code> array and receives\nthe actual count of arguments.</li>\n<li><code>[out] argv</code>: Buffer to which the <code>napi_value</code> representing the arguments are\ncopied. If there are more arguments than the provided count, only the\nrequested number of arguments are copied. If there are fewer arguments\nprovided than claimed, the rest of <code>argv</code> is filled with <code>napi_value</code> values\nthat represent <code>undefined</code>.</li>\n<li><code>[out] this</code>: Receives the JavaScript <code>this</code> argument for the call.</li>\n<li><code>[out] data</code>: Receives the data pointer for the callback.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is used within a callback function to retrieve details about the\ncall like the arguments and the <code>this</code> pointer from a given callback info.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_get_cb_info(napi_env env,\n                             napi_callback_info cbinfo,\n                             size_t* argc,\n                             napi_value* argv,\n                             napi_value* thisArg,\n                             void** data)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] cbinfo</code>: The callback info passed into the callback function.</li>\n<li><code>[in-out] argc</code>: Specifies the length of the provided <code>argv</code> array and\nreceives the actual count of arguments.</li>\n<li><code>[out] argv</code>: Buffer to which the <code>napi_value</code> representing the arguments are\ncopied. If there are more arguments than the provided count, only the\nrequested number of arguments are copied. If there are fewer arguments\nprovided than claimed, the rest of <code>argv</code> is filled with <code>napi_value</code> values\nthat represent <code>undefined</code>.</li>\n<li><code>[out] this</code>: Receives the JavaScript <code>this</code> argument for the call.</li>\n<li><code>[out] data</code>: Receives the data pointer for the callback.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method is used within a callback function to retrieve details about the\ncall like the arguments and the <code>this</code> pointer from a given callback info.</p>",
               "type": "module",
               "displayName": "napi_get_cb_info"
             },
@@ -2476,7 +2493,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_new_instance(napi_env env,\n                              napi_value cons,\n                              size_t argc,\n                              napi_value* argv,\n                              napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] cons</code>: <code>napi_value</code> representing the JavaScript function to be invoked\nas a constructor.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the\narguments to the constructor.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned,\nwhich in this case is the constructed object.</li>\n</ul>\n<p>This method is used to instantiate a new JavaScript value using a given\n<code>napi_value</code> that represents the constructor for the object. For example,\nconsider the following snippet:</p>\n<pre><code class=\"language-js\">function MyObject(param) {\n  this.param = param;\n}\n\nconst arg = 'hello';\nconst value = new MyObject(arg);\n</code></pre>\n<p>The following can be approximated in N-API using the following snippet:</p>\n<pre><code class=\"language-c\">// Get the constructor function MyObject\nnapi_value global, constructor, arg, value;\nnapi_status status = napi_get_global(env, &#x26;global);\nif (status != napi_ok) return;\n\nstatus = napi_get_named_property(env, global, \"MyObject\", &#x26;constructor);\nif (status != napi_ok) return;\n\n// const arg = \"hello\"\nstatus = napi_create_string_utf8(env, \"hello\", NAPI_AUTO_LENGTH, &#x26;arg);\nif (status != napi_ok) return;\n\nnapi_value* argv = &#x26;arg;\nsize_t argc = 1;\n\n// const value = new MyObject(arg)\nstatus = napi_new_instance(env, constructor, argc, argv, &#x26;value);\n</code></pre>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_new_instance(napi_env env,\n                              napi_value cons,\n                              size_t argc,\n                              napi_value* argv,\n                              napi_value* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] cons</code>: <code>napi_value</code> representing the JavaScript function to be invoked\nas a constructor.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the\narguments to the constructor.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned,\nwhich in this case is the constructed object.</li>\n</ul>\n<p>This method is used to instantiate a new JavaScript value using a given\n<code>napi_value</code> that represents the constructor for the object. For example,\nconsider the following snippet:</p>\n<pre><code class=\"language-js\">function MyObject(param) {\n  this.param = param;\n}\n\nconst arg = 'hello';\nconst value = new MyObject(arg);\n</code></pre>\n<p>The following can be approximated in Node-API using the following snippet:</p>\n<pre><code class=\"language-c\">// Get the constructor function MyObject\nnapi_value global, constructor, arg, value;\nnapi_status status = napi_get_global(env, &#x26;global);\nif (status != napi_ok) return;\n\nstatus = napi_get_named_property(env, global, \"MyObject\", &#x26;constructor);\nif (status != napi_ok) return;\n\n// const arg = \"hello\"\nstatus = napi_create_string_utf8(env, \"hello\", NAPI_AUTO_LENGTH, &#x26;arg);\nif (status != napi_ok) return;\n\nnapi_value* argv = &#x26;arg;\nsize_t argc = 1;\n\n// const value = new MyObject(arg)\nstatus = napi_new_instance(env, constructor, argc, argv, &#x26;value);\n</code></pre>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>",
               "type": "module",
               "displayName": "napi_new_instance"
             }
@@ -2487,7 +2504,7 @@
         {
           "textRaw": "Object wrap",
           "name": "object_wrap",
-          "desc": "<p>N-API offers a way to \"wrap\" C++ classes and instances so that the class\nconstructor and methods can be called from JavaScript.</p>\n<ol>\n<li>The <a href=\"#n_api_napi_define_class\"><code>napi_define_class</code></a> API defines a JavaScript class with constructor,\nstatic properties and methods, and instance properties and methods that\ncorrespond to the C++ class.</li>\n<li>When JavaScript code invokes the constructor, the constructor callback\nuses <a href=\"#n_api_napi_wrap\"><code>napi_wrap</code></a> to wrap a new C++ instance in a JavaScript object,\nthen returns the wrapper object.</li>\n<li>When JavaScript code invokes a method or property accessor on the class,\nthe corresponding <code>napi_callback</code> C++ function is invoked. For an instance\ncallback, <a href=\"#n_api_napi_unwrap\"><code>napi_unwrap</code></a> obtains the C++ instance that is the target of\nthe call.</li>\n</ol>\n<p>For wrapped objects it may be difficult to distinguish between a function\ncalled on a class prototype and a function called on an instance of a class.\nA common pattern used to address this problem is to save a persistent\nreference to the class constructor for later <code>instanceof</code> checks.</p>\n<pre><code class=\"language-c\">napi_value MyClass_constructor = NULL;\nstatus = napi_get_reference_value(env, MyClass::es_constructor, &#x26;MyClass_constructor);\nassert(napi_ok == status);\nbool is_instance = false;\nstatus = napi_instanceof(env, es_this, MyClass_constructor, &#x26;is_instance);\nassert(napi_ok == status);\nif (is_instance) {\n  // napi_unwrap() ...\n} else {\n  // otherwise...\n}\n</code></pre>\n<p>The reference must be freed once it is no longer needed.</p>\n<p>There are occasions where <code>napi_instanceof()</code> is insufficient for ensuring that\na JavaScript object is a wrapper for a certain native type. This is the case\nespecially when wrapped JavaScript objects are passed back into the addon via\nstatic methods rather than as the <code>this</code> value of prototype methods. In such\ncases there is a chance that they may be unwrapped incorrectly.</p>\n<pre><code class=\"language-js\">const myAddon = require('./build/Release/my_addon.node');\n\n// `openDatabase()` returns a JavaScript object that wraps a native database\n// handle.\nconst dbHandle = myAddon.openDatabase();\n\n// `query()` returns a JavaScript object that wraps a native query handle.\nconst queryHandle = myAddon.query(dbHandle, 'Gimme ALL the things!');\n\n// There is an accidental error in the line below. The first parameter to\n// `myAddon.queryHasRecords()` should be the database handle (`dbHandle`), not\n// the query handle (`query`), so the correct condition for the while-loop\n// should be\n//\n// myAddon.queryHasRecords(dbHandle, queryHandle)\n//\nwhile (myAddon.queryHasRecords(queryHandle, dbHandle)) {\n  // retrieve records\n}\n</code></pre>\n<p>In the above example <code>myAddon.queryHasRecords()</code> is a method that accepts two\narguments. The first is a database handle and the second is a query handle.\nInternally, it unwraps the first argument and casts the resulting pointer to a\nnative database handle. It then unwraps the second argument and casts the\nresulting pointer to a query handle. If the arguments are passed in the wrong\norder, the casts will work, however, there is a good chance that the underlying\ndatabase operation will fail, or will even cause an invalid memory access.</p>\n<p>To ensure that the pointer retrieved from the first argument is indeed a pointer\nto a database handle and, similarly, that the pointer retrieved from the second\nargument is indeed a pointer to a query handle, the implementation of\n<code>queryHasRecords()</code> has to perform a type validation. Retaining the JavaScript\nclass constructor from which the database handle was instantiated and the\nconstructor from which the query handle was instantiated in <code>napi_ref</code>s can\nhelp, because <code>napi_instanceof()</code> can then be used to ensure that the instances\npassed into <code>queryHashRecords()</code> are indeed of the correct type.</p>\n<p>Unfortunately, <code>napi_instanceof()</code> does not protect against prototype\nmanipulation. For example, the prototype of the database handle instance can be\nset to the prototype of the constructor for query handle instances. In this\ncase, the database handle instance can appear as a query handle instance, and it\nwill pass the <code>napi_instanceof()</code> test for a query handle instance, while still\ncontaining a pointer to a database handle.</p>\n<p>To this end, N-API provides type-tagging capabilities.</p>\n<p>A type tag is a 128-bit integer unique to the addon. N-API provides the\n<code>napi_type_tag</code> structure for storing a type tag. When such a value is passed\nalong with a JavaScript object stored in a <code>napi_value</code> to\n<code>napi_type_tag_object()</code>, the JavaScript object will be \"marked\" with the\ntype tag. The \"mark\" is invisible on the JavaScript side. When a JavaScript\nobject arrives into a native binding, <code>napi_check_object_type_tag()</code> can be used\nalong with the original type tag to determine whether the JavaScript object was\npreviously \"marked\" with the type tag. This creates a type-checking capability\nof a higher fidelity than <code>napi_instanceof()</code> can provide, because such type-\ntagging survives prototype manipulation and addon unloading/reloading.</p>\n<p>Continuing the above example, the following skeleton addon implementation\nillustrates the use of <code>napi_type_tag_object()</code> and\n<code>napi_check_object_type_tag()</code>.</p>\n<pre><code class=\"language-c\">// This value is the type tag for a database handle. The command\n//\n//   uuidgen | sed -r -e 's/-//g' -e 's/(.{16})(.*)/0x\\1, 0x\\2/'\n//\n// can be used to obtain the two values with which to initialize the structure.\nstatic const napi_type_tag DatabaseHandleTypeTag = {\n  0x1edf75a38336451d, 0xa5ed9ce2e4c00c38\n};\n\n// This value is the type tag for a query handle.\nstatic const napi_type_tag QueryHandleTypeTag = {\n  0x9c73317f9fad44a3, 0x93c3920bf3b0ad6a\n};\n\nstatic napi_value\nopenDatabase(napi_env env, napi_callback_info info) {\n  napi_status status;\n  napi_value result;\n\n  // Perform the underlying action which results in a database handle.\n  DatabaseHandle* dbHandle = open_database();\n\n  // Create a new, empty JS object.\n  status = napi_create_object(env, &#x26;result);\n  if (status != napi_ok) return NULL;\n\n  // Tag the object to indicate that it holds a pointer to a `DatabaseHandle`.\n  status = napi_type_tag_object(env, result, &#x26;DatabaseHandleTypeTag);\n  if (status != napi_ok) return NULL;\n\n  // Store the pointer to the `DatabaseHandle` structure inside the JS object.\n  status = napi_wrap(env, result, dbHandle, NULL, NULL, NULL);\n  if (status != napi_ok) return NULL;\n\n  return result;\n}\n\n// Later when we receive a JavaScript object purporting to be a database handle\n// we can use `napi_check_object_type_tag()` to ensure that it is indeed such a\n// handle.\n\nstatic napi_value\nquery(napi_env env, napi_callback_info info) {\n  napi_status status;\n  size_t argc = 2;\n  napi_value argv[2];\n  bool is_db_handle;\n\n  status = napi_get_cb_info(env, info, &#x26;argc, argv, NULL, NULL);\n  if (status != napi_ok) return NULL;\n\n  // Check that the object passed as the first parameter has the previously\n  // applied tag.\n  status = napi_check_object_type_tag(env,\n                                      argv[0],\n                                      &#x26;DatabaseHandleTypeTag,\n                                      &#x26;is_db_handle);\n  if (status != napi_ok) return NULL;\n\n  // Throw a `TypeError` if it doesn't.\n  if (!is_db_handle) {\n    // Throw a TypeError.\n    return NULL;\n  }\n}\n</code></pre>",
+          "desc": "<p>Node-API offers a way to \"wrap\" C++ classes and instances so that the class\nconstructor and methods can be called from JavaScript.</p>\n<ol>\n<li>The <a href=\"#n_api_napi_define_class\"><code>napi_define_class</code></a> API defines a JavaScript class with constructor,\nstatic properties and methods, and instance properties and methods that\ncorrespond to the C++ class.</li>\n<li>When JavaScript code invokes the constructor, the constructor callback\nuses <a href=\"#n_api_napi_wrap\"><code>napi_wrap</code></a> to wrap a new C++ instance in a JavaScript object,\nthen returns the wrapper object.</li>\n<li>When JavaScript code invokes a method or property accessor on the class,\nthe corresponding <code>napi_callback</code> C++ function is invoked. For an instance\ncallback, <a href=\"#n_api_napi_unwrap\"><code>napi_unwrap</code></a> obtains the C++ instance that is the target of\nthe call.</li>\n</ol>\n<p>For wrapped objects it may be difficult to distinguish between a function\ncalled on a class prototype and a function called on an instance of a class.\nA common pattern used to address this problem is to save a persistent\nreference to the class constructor for later <code>instanceof</code> checks.</p>\n<pre><code class=\"language-c\">napi_value MyClass_constructor = NULL;\nstatus = napi_get_reference_value(env, MyClass::es_constructor, &#x26;MyClass_constructor);\nassert(napi_ok == status);\nbool is_instance = false;\nstatus = napi_instanceof(env, es_this, MyClass_constructor, &#x26;is_instance);\nassert(napi_ok == status);\nif (is_instance) {\n  // napi_unwrap() ...\n} else {\n  // otherwise...\n}\n</code></pre>\n<p>The reference must be freed once it is no longer needed.</p>\n<p>There are occasions where <code>napi_instanceof()</code> is insufficient for ensuring that\na JavaScript object is a wrapper for a certain native type. This is the case\nespecially when wrapped JavaScript objects are passed back into the addon via\nstatic methods rather than as the <code>this</code> value of prototype methods. In such\ncases there is a chance that they may be unwrapped incorrectly.</p>\n<pre><code class=\"language-js\">const myAddon = require('./build/Release/my_addon.node');\n\n// `openDatabase()` returns a JavaScript object that wraps a native database\n// handle.\nconst dbHandle = myAddon.openDatabase();\n\n// `query()` returns a JavaScript object that wraps a native query handle.\nconst queryHandle = myAddon.query(dbHandle, 'Gimme ALL the things!');\n\n// There is an accidental error in the line below. The first parameter to\n// `myAddon.queryHasRecords()` should be the database handle (`dbHandle`), not\n// the query handle (`query`), so the correct condition for the while-loop\n// should be\n//\n// myAddon.queryHasRecords(dbHandle, queryHandle)\n//\nwhile (myAddon.queryHasRecords(queryHandle, dbHandle)) {\n  // retrieve records\n}\n</code></pre>\n<p>In the above example <code>myAddon.queryHasRecords()</code> is a method that accepts two\narguments. The first is a database handle and the second is a query handle.\nInternally, it unwraps the first argument and casts the resulting pointer to a\nnative database handle. It then unwraps the second argument and casts the\nresulting pointer to a query handle. If the arguments are passed in the wrong\norder, the casts will work, however, there is a good chance that the underlying\ndatabase operation will fail, or will even cause an invalid memory access.</p>\n<p>To ensure that the pointer retrieved from the first argument is indeed a pointer\nto a database handle and, similarly, that the pointer retrieved from the second\nargument is indeed a pointer to a query handle, the implementation of\n<code>queryHasRecords()</code> has to perform a type validation. Retaining the JavaScript\nclass constructor from which the database handle was instantiated and the\nconstructor from which the query handle was instantiated in <code>napi_ref</code>s can\nhelp, because <code>napi_instanceof()</code> can then be used to ensure that the instances\npassed into <code>queryHashRecords()</code> are indeed of the correct type.</p>\n<p>Unfortunately, <code>napi_instanceof()</code> does not protect against prototype\nmanipulation. For example, the prototype of the database handle instance can be\nset to the prototype of the constructor for query handle instances. In this\ncase, the database handle instance can appear as a query handle instance, and it\nwill pass the <code>napi_instanceof()</code> test for a query handle instance, while still\ncontaining a pointer to a database handle.</p>\n<p>To this end, Node-API provides type-tagging capabilities.</p>\n<p>A type tag is a 128-bit integer unique to the addon. Node-API provides the\n<code>napi_type_tag</code> structure for storing a type tag. When such a value is passed\nalong with a JavaScript object stored in a <code>napi_value</code> to\n<code>napi_type_tag_object()</code>, the JavaScript object will be \"marked\" with the\ntype tag. The \"mark\" is invisible on the JavaScript side. When a JavaScript\nobject arrives into a native binding, <code>napi_check_object_type_tag()</code> can be used\nalong with the original type tag to determine whether the JavaScript object was\npreviously \"marked\" with the type tag. This creates a type-checking capability\nof a higher fidelity than <code>napi_instanceof()</code> can provide, because such type-\ntagging survives prototype manipulation and addon unloading/reloading.</p>\n<p>Continuing the above example, the following skeleton addon implementation\nillustrates the use of <code>napi_type_tag_object()</code> and\n<code>napi_check_object_type_tag()</code>.</p>\n<pre><code class=\"language-c\">// This value is the type tag for a database handle. The command\n//\n//   uuidgen | sed -r -e 's/-//g' -e 's/(.{16})(.*)/0x\\1, 0x\\2/'\n//\n// can be used to obtain the two values with which to initialize the structure.\nstatic const napi_type_tag DatabaseHandleTypeTag = {\n  0x1edf75a38336451d, 0xa5ed9ce2e4c00c38\n};\n\n// This value is the type tag for a query handle.\nstatic const napi_type_tag QueryHandleTypeTag = {\n  0x9c73317f9fad44a3, 0x93c3920bf3b0ad6a\n};\n\nstatic napi_value\nopenDatabase(napi_env env, napi_callback_info info) {\n  napi_status status;\n  napi_value result;\n\n  // Perform the underlying action which results in a database handle.\n  DatabaseHandle* dbHandle = open_database();\n\n  // Create a new, empty JS object.\n  status = napi_create_object(env, &#x26;result);\n  if (status != napi_ok) return NULL;\n\n  // Tag the object to indicate that it holds a pointer to a `DatabaseHandle`.\n  status = napi_type_tag_object(env, result, &#x26;DatabaseHandleTypeTag);\n  if (status != napi_ok) return NULL;\n\n  // Store the pointer to the `DatabaseHandle` structure inside the JS object.\n  status = napi_wrap(env, result, dbHandle, NULL, NULL, NULL);\n  if (status != napi_ok) return NULL;\n\n  return result;\n}\n\n// Later when we receive a JavaScript object purporting to be a database handle\n// we can use `napi_check_object_type_tag()` to ensure that it is indeed such a\n// handle.\n\nstatic napi_value\nquery(napi_env env, napi_callback_info info) {\n  napi_status status;\n  size_t argc = 2;\n  napi_value argv[2];\n  bool is_db_handle;\n\n  status = napi_get_cb_info(env, info, &#x26;argc, argv, NULL, NULL);\n  if (status != napi_ok) return NULL;\n\n  // Check that the object passed as the first parameter has the previously\n  // applied tag.\n  status = napi_check_object_type_tag(env,\n                                      argv[0],\n                                      &#x26;DatabaseHandleTypeTag,\n                                      &#x26;is_db_handle);\n  if (status != napi_ok) return NULL;\n\n  // Throw a `TypeError` if it doesn't.\n  if (!is_db_handle) {\n    // Throw a TypeError.\n    return NULL;\n  }\n}\n</code></pre>",
           "modules": [
             {
               "textRaw": "napi_define_class",
@@ -2501,7 +2518,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_define_class(napi_env env,\n                              const char* utf8name,\n                              size_t length,\n                              napi_callback constructor,\n                              void* data,\n                              size_t property_count,\n                              const napi_property_descriptor* properties,\n                              napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] utf8name</code>: Name of the JavaScript constructor function; this is\nnot required to be the same as the C++ class name, though it is recommended\nfor clarity.</li>\n<li><code>[in] length</code>: The length of the <code>utf8name</code> in bytes, or <code>NAPI_AUTO_LENGTH</code>\nif it is null-terminated.</li>\n<li><code>[in] constructor</code>: Callback function that handles constructing instances\nof the class. This should be a static method on the class, not an actual\nC++ constructor function. <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>[in] data</code>: Optional data to be passed to the constructor callback as\nthe <code>data</code> property of the callback info.</li>\n<li><code>[in] property_count</code>: Number of items in the <code>properties</code> array argument.</li>\n<li><code>[in] properties</code>: Array of property descriptors describing static and\ninstance data properties, accessors, and methods on the class\nSee <code>napi_property_descriptor</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing the constructor function for\nthe class.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>Defines a JavaScript class that corresponds to a C++ class, including:</p>\n<ul>\n<li>A JavaScript constructor function that has the class name and invokes the\nprovided C++ constructor callback.</li>\n<li>Properties on the constructor function corresponding to <em>static</em> data\nproperties, accessors, and methods of the C++ class (defined by\nproperty descriptors with the <code>napi_static</code> attribute).</li>\n<li>Properties on the constructor function's <code>prototype</code> object corresponding to\n<em>non-static</em> data properties, accessors, and methods of the C++ class\n(defined by property descriptors without the <code>napi_static</code> attribute).</li>\n</ul>\n<p>The C++ constructor callback should be a static method on the class that calls\nthe actual class constructor, then wraps the new C++ instance in a JavaScript\nobject, and returns the wrapper object. See <code>napi_wrap()</code> for details.</p>\n<p>The JavaScript constructor function returned from <a href=\"#n_api_napi_define_class\"><code>napi_define_class</code></a> is\noften saved and used later, to construct new instances of the class from native\ncode, and/or check whether provided values are instances of the class. In that\ncase, to prevent the function value from being garbage-collected, create a\npersistent reference to it using <a href=\"#n_api_napi_create_reference\"><code>napi_create_reference</code></a> and ensure the\nreference count is kept >= 1.</p>\n<p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> parameter or via\nthe <code>data</code> field of the <code>napi_property_descriptor</code> array items can be associated\nwith the resulting JavaScript constructor (which is returned in the <code>result</code>\nparameter) and freed whenever the class is garbage-collected by passing both\nthe JavaScript function and the data to <a href=\"#n_api_napi_add_finalizer\"><code>napi_add_finalizer</code></a>.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_define_class(napi_env env,\n                              const char* utf8name,\n                              size_t length,\n                              napi_callback constructor,\n                              void* data,\n                              size_t property_count,\n                              const napi_property_descriptor* properties,\n                              napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] utf8name</code>: Name of the JavaScript constructor function; When wrapping a\nC++ class, we recommend for clarity that this name be the same as that of\nthe C++ class.</li>\n<li><code>[in] length</code>: The length of the <code>utf8name</code> in bytes, or <code>NAPI_AUTO_LENGTH</code>\nif it is null-terminated.</li>\n<li><code>[in] constructor</code>: Callback function that handles constructing instances\nof the class. When wrapping a C++ class, this method must be a static member\nwith the <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> signature. A C++ class constructor cannot be\nused. <a href=\"#n_api_napi_callback\"><code>napi_callback</code></a> provides more details.</li>\n<li><code>[in] data</code>: Optional data to be passed to the constructor callback as\nthe <code>data</code> property of the callback info.</li>\n<li><code>[in] property_count</code>: Number of items in the <code>properties</code> array argument.</li>\n<li><code>[in] properties</code>: Array of property descriptors describing static and\ninstance data properties, accessors, and methods on the class\nSee <code>napi_property_descriptor</code>.</li>\n<li><code>[out] result</code>: A <code>napi_value</code> representing the constructor function for\nthe class.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>Defines a JavaScript class, including:</p>\n<ul>\n<li>A JavaScript constructor function that has the class name. When wrapping a\ncorresponding C++ class, the callback passed via <code>constructor</code> can be used to\ninstantiate a new C++ class instance, which can then be placed inside the\nJavaScript object instance being constructed using <a href=\"#n_api_napi_wrap\"><code>napi_wrap</code></a>.</li>\n<li>Properties on the constructor function whose implementation can call\ncorresponding <em>static</em> data properties, accessors, and methods of the C++\nclass (defined by property descriptors with the <code>napi_static</code> attribute).</li>\n<li>Properties on the constructor function's <code>prototype</code> object. When wrapping a\nC++ class, <em>non-static</em> data properties, accessors, and methods of the C++\nclass can be called from the static functions given in the property\ndescriptors without the <code>napi_static</code> attribute after retrieving the C++ class\ninstance placed inside the JavaScript object instance by using\n<a href=\"#n_api_napi_unwrap\"><code>napi_unwrap</code></a>.</li>\n</ul>\n<p>When wrapping a C++ class, the C++ constructor callback passed via <code>constructor</code>\nshould be a static method on the class that calls the actual class constructor,\nthen wraps the new C++ instance in a JavaScript object, and returns the wrapper\nobject. See <a href=\"#n_api_napi_wrap\"><code>napi_wrap</code></a> for details.</p>\n<p>The JavaScript constructor function returned from <a href=\"#n_api_napi_define_class\"><code>napi_define_class</code></a> is\noften saved and used later to construct new instances of the class from native\ncode, and/or to check whether provided values are instances of the class. In\nthat case, to prevent the function value from being garbage-collected, a\nstrong persistent reference to it can be created using\n<a href=\"#n_api_napi_create_reference\"><code>napi_create_reference</code></a>, ensuring that the reference count is kept >= 1.</p>\n<p>Any non-<code>NULL</code> data which is passed to this API via the <code>data</code> parameter or via\nthe <code>data</code> field of the <code>napi_property_descriptor</code> array items can be associated\nwith the resulting JavaScript constructor (which is returned in the <code>result</code>\nparameter) and freed whenever the class is garbage-collected by passing both\nthe JavaScript function and the data to <a href=\"#n_api_napi_add_finalizer\"><code>napi_add_finalizer</code></a>.</p>",
               "type": "module",
               "displayName": "napi_define_class"
             },
@@ -2558,6 +2575,7 @@
               "name": "napi_type_tag_object",
               "meta": {
                 "added": [
+                  "v14.8.0",
                   "v12.19.0"
                 ],
                 "napiVersion": [
@@ -2574,6 +2592,7 @@
               "name": "napi_check_object_type_tag",
               "meta": {
                 "added": [
+                  "v14.8.0",
                   "v12.19.0"
                 ],
                 "napiVersion": [
@@ -2608,7 +2627,7 @@
         {
           "textRaw": "Simple asynchronous operations",
           "name": "simple_asynchronous_operations",
-          "desc": "<p>Addon modules often need to leverage async helpers from libuv as part of their\nimplementation. This allows them to schedule work to be executed asynchronously\nso that their methods can return in advance of the work being completed. This\nallows them to avoid blocking overall execution of the Node.js application.</p>\n<p>N-API provides an ABI-stable interface for these\nsupporting functions which covers the most common asynchronous use cases.</p>\n<p>N-API defines the <code>napi_async_work</code> structure which is used to manage\nasynchronous workers. Instances are created/deleted with\n<a href=\"#n_api_napi_create_async_work\"><code>napi_create_async_work</code></a> and <a href=\"#n_api_napi_delete_async_work\"><code>napi_delete_async_work</code></a>.</p>\n<p>The <code>execute</code> and <code>complete</code> callbacks are functions that will be\ninvoked when the executor is ready to execute and when it completes its\ntask respectively.</p>\n<p>The <code>execute</code> function should avoid making any N-API calls\nthat could result in the execution of JavaScript or interaction with\nJavaScript objects. Most often, any code that needs to make N-API\ncalls should be made in <code>complete</code> callback instead.\nAvoid using the <code>napi_env</code> parameter in the execute callback as\nit will likely execute JavaScript.</p>\n<p>These functions implement the following interfaces:</p>\n<pre><code class=\"language-c\">typedef void (*napi_async_execute_callback)(napi_env env,\n                                            void* data);\ntypedef void (*napi_async_complete_callback)(napi_env env,\n                                             napi_status status,\n                                             void* data);\n</code></pre>\n<p>When these methods are invoked, the <code>data</code> parameter passed will be the\naddon-provided <code>void*</code> data that was passed into the\n<code>napi_create_async_work</code> call.</p>\n<p>Once created the async worker can be queued\nfor execution using the <a href=\"#n_api_napi_queue_async_work\"><code>napi_queue_async_work</code></a> function:</p>\n<pre><code class=\"language-c\">napi_status napi_queue_async_work(napi_env env,\n                                  napi_async_work work);\n</code></pre>\n<p><a href=\"#n_api_napi_cancel_async_work\"><code>napi_cancel_async_work</code></a> can be used if the work needs\nto be cancelled before the work has started execution.</p>\n<p>After calling <a href=\"#n_api_napi_cancel_async_work\"><code>napi_cancel_async_work</code></a>, the <code>complete</code> callback\nwill be invoked with a status value of <code>napi_cancelled</code>.\nThe work should not be deleted before the <code>complete</code>\ncallback invocation, even when it was cancelled.</p>",
+          "desc": "<p>Addon modules often need to leverage async helpers from libuv as part of their\nimplementation. This allows them to schedule work to be executed asynchronously\nso that their methods can return in advance of the work being completed. This\nallows them to avoid blocking overall execution of the Node.js application.</p>\n<p>Node-API provides an ABI-stable interface for these\nsupporting functions which covers the most common asynchronous use cases.</p>\n<p>Node-API defines the <code>napi_async_work</code> structure which is used to manage\nasynchronous workers. Instances are created/deleted with\n<a href=\"#n_api_napi_create_async_work\"><code>napi_create_async_work</code></a> and <a href=\"#n_api_napi_delete_async_work\"><code>napi_delete_async_work</code></a>.</p>\n<p>The <code>execute</code> and <code>complete</code> callbacks are functions that will be\ninvoked when the executor is ready to execute and when it completes its\ntask respectively.</p>\n<p>The <code>execute</code> function should avoid making any Node-API calls\nthat could result in the execution of JavaScript or interaction with\nJavaScript objects. Most often, any code that needs to make Node-API\ncalls should be made in <code>complete</code> callback instead.\nAvoid using the <code>napi_env</code> parameter in the execute callback as\nit will likely execute JavaScript.</p>\n<p>These functions implement the following interfaces:</p>\n<pre><code class=\"language-c\">typedef void (*napi_async_execute_callback)(napi_env env,\n                                            void* data);\ntypedef void (*napi_async_complete_callback)(napi_env env,\n                                             napi_status status,\n                                             void* data);\n</code></pre>\n<p>When these methods are invoked, the <code>data</code> parameter passed will be the\naddon-provided <code>void*</code> data that was passed into the\n<code>napi_create_async_work</code> call.</p>\n<p>Once created the async worker can be queued\nfor execution using the <a href=\"#n_api_napi_queue_async_work\"><code>napi_queue_async_work</code></a> function:</p>\n<pre><code class=\"language-c\">napi_status napi_queue_async_work(napi_env env,\n                                  napi_async_work work);\n</code></pre>\n<p><a href=\"#n_api_napi_cancel_async_work\"><code>napi_cancel_async_work</code></a> can be used if the work needs\nto be cancelled before the work has started execution.</p>\n<p>After calling <a href=\"#n_api_napi_cancel_async_work\"><code>napi_cancel_async_work</code></a>, the <code>complete</code> callback\nwill be invoked with a status value of <code>napi_cancelled</code>.\nThe work should not be deleted before the <code>complete</code>\ncallback invocation, even when it was cancelled.</p>",
           "modules": [
             {
               "textRaw": "napi_create_async_work",
@@ -2701,7 +2720,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_async_init(napi_env env,\n                            napi_value async_resource,\n                            napi_value async_resource_name,\n                            napi_async_context* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] async_resource</code>: Object associated with the async work\nthat will be passed to possible <code>async_hooks</code> <a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a>.\nIn order to retain ABI compatibility with previous versions,\npassing <code>NULL</code> for <code>async_resource</code> will not result in an error, however,\nthis will result incorrect operation of async hooks for the\nnapi_async_context created. Potential issues include\nloss of async context when using the AsyncLocalStorage API.</li>\n<li><code>[in] async_resource_name</code>: Identifier for the kind of resource\nthat is being provided for diagnostic information exposed by the\n<code>async_hooks</code> API.</li>\n<li><code>[out] result</code>: The initialized async context.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_async_init(napi_env env,\n                            napi_value async_resource,\n                            napi_value async_resource_name,\n                            napi_async_context* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] async_resource</code>: Object associated with the async work\nthat will be passed to possible <code>async_hooks</code> <a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a> and can be\naccessed by <a href=\"async_hooks.html#async_hooks_async_hooks_executionasyncresource\"><code>async_hooks.executionAsyncResource()</code></a>.</li>\n<li><code>[in] async_resource_name</code>: Identifier for the kind of resource that is being\nprovided for diagnostic information exposed by the <code>async_hooks</code> API.</li>\n<li><code>[out] result</code>: The initialized async context.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>The <code>async_resource</code> object needs to be kept alive until\n<a href=\"#n_api_napi_async_destroy\"><code>napi_async_destroy</code></a> to keep <code>async_hooks</code> related API acts correctly. In\norder to retain ABI compatibility with previous versions, <code>napi_async_context</code>s\nare not maintaining the strong reference to the <code>async_resource</code> objects to\navoid introducing causing memory leaks. However, if the <code>async_resource</code> is\ngarbage collected by JavaScript engine before the <code>napi_async_context</code> was\ndestroyed by <code>napi_async_destroy</code>, calling <code>napi_async_context</code> related APIs\nlike <a href=\"#n_api_napi_open_callback_scope\"><code>napi_open_callback_scope</code></a> and <a href=\"#n_api_napi_make_callback\"><code>napi_make_callback</code></a> can cause\nproblems like loss of async context when using the <code>AsyncLocalStoage</code> API.</p>\n<p>In order to retain ABI compatibility with previous versions, passing <code>NULL</code>\nfor <code>async_resource</code> does not result in an error. However, this is not\nrecommended as this will result poor results with  <code>async_hooks</code>\n<a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a> and <code>async_hooks.executionAsyncResource()</code> as the resource is\nnow required by the underlying <code>async_hooks</code> implementation in order to provide\nthe linkage between async callbacks.</p>",
               "type": "module",
               "displayName": "napi_async_init"
             },
@@ -2734,11 +2753,12 @@
                 "changes": [
                   {
                     "version": "v8.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/15189",
                     "description": "Added `async_context` parameter."
                   }
                 ]
               },
-              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_make_callback(napi_env env,\n                                           napi_async_context async_context,\n                                           napi_value recv,\n                                           napi_value func,\n                                           size_t argc,\n                                           const napi_value* argv,\n                                           napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] async_context</code>: Context for the async operation that is\ninvoking the callback. This should normally be a value previously\nobtained from <a href=\"#n_api_napi_async_init\"><code>napi_async_init</code></a>. However <code>NULL</code> is also allowed,\nwhich indicates the current async context (if any) is to be used\nfor the callback.</li>\n<li><code>[in] recv</code>: The <code>this</code> object passed to the called function.</li>\n<li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the\narguments to the function.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows a JavaScript function object to be called from a native\nadd-on. This API is similar to <code>napi_call_function</code>. However, it is used to call\n<em>from</em> native code back <em>into</em> JavaScript <em>after</em> returning from an async\noperation (when there is no other script on the stack). It is a fairly simple\nwrapper around <code>node::MakeCallback</code>.</p>\n<p>Note it is <em>not</em> necessary to use <code>napi_make_callback</code> from within a\n<code>napi_async_complete_callback</code>; in that situation the callback's async\ncontext has already been set up, so a direct call to <code>napi_call_function</code>\nis sufficient and appropriate. Use of the <code>napi_make_callback</code> function\nmay be required when implementing custom async behavior that does not use\n<code>napi_create_async_work</code>.</p>\n<p>Any <code>process.nextTick</code>s or Promises scheduled on the microtask queue by\nJavaScript during the callback are ran before returning back to C/C++.</p>",
+              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_make_callback(napi_env env,\n                                           napi_async_context async_context,\n                                           napi_value recv,\n                                           napi_value func,\n                                           size_t argc,\n                                           const napi_value* argv,\n                                           napi_value* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] async_context</code>: Context for the async operation that is\ninvoking the callback. This should normally be a value previously\nobtained from <a href=\"#n_api_napi_async_init\"><code>napi_async_init</code></a>.\nIn order to retain ABI compatibility with previous versions, passing <code>NULL</code>\nfor <code>async_context</code> does not result in an error. However, this results\nin incorrect operation of async hooks. Potential issues include loss of\nasync context when using the <code>AsyncLocalStorage</code> API.</li>\n<li><code>[in] recv</code>: The <code>this</code> value passed to the called function.</li>\n<li><code>[in] func</code>: <code>napi_value</code> representing the JavaScript function to be invoked.</li>\n<li><code>[in] argc</code>: The count of elements in the <code>argv</code> array.</li>\n<li><code>[in] argv</code>: Array of JavaScript values as <code>napi_value</code> representing the\narguments to the function.</li>\n<li><code>[out] result</code>: <code>napi_value</code> representing the JavaScript object returned.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This method allows a JavaScript function object to be called from a native\nadd-on. This API is similar to <code>napi_call_function</code>. However, it is used to call\n<em>from</em> native code back <em>into</em> JavaScript <em>after</em> returning from an async\noperation (when there is no other script on the stack). It is a fairly simple\nwrapper around <code>node::MakeCallback</code>.</p>\n<p>Note it is <em>not</em> necessary to use <code>napi_make_callback</code> from within a\n<code>napi_async_complete_callback</code>; in that situation the callback's async\ncontext has already been set up, so a direct call to <code>napi_call_function</code>\nis sufficient and appropriate. Use of the <code>napi_make_callback</code> function\nmay be required when implementing custom async behavior that does not use\n<code>napi_create_async_work</code>.</p>\n<p>Any <code>process.nextTick</code>s or Promises scheduled on the microtask queue by\nJavaScript during the callback are ran before returning back to C/C++.</p>",
               "type": "module",
               "displayName": "napi_make_callback"
             },
@@ -2754,7 +2774,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,\n                                                 napi_value resource_object,\n                                                 napi_async_context context,\n                                                 napi_callback_scope* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] resource_object</code>: An object associated with the async work\nthat will be passed to possible <code>async_hooks</code> <a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a>.</li>\n<li><code>[in] context</code>: Context for the async operation that is invoking the callback.\nThis should be a value previously obtained from <a href=\"#n_api_napi_async_init\"><code>napi_async_init</code></a>.</li>\n<li><code>[out] result</code>: The newly created scope.</li>\n</ul>\n<p>There are cases (for example, resolving promises) where it is\nnecessary to have the equivalent of the scope associated with a callback\nin place when making certain N-API calls. If there is no other script on\nthe stack the <a href=\"#n_api_napi_open_callback_scope\"><code>napi_open_callback_scope</code></a> and\n<a href=\"#n_api_napi_close_callback_scope\"><code>napi_close_callback_scope</code></a> functions can be used to open/close\nthe required scope.</p>",
+              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,\n                                                 napi_value resource_object,\n                                                 napi_async_context context,\n                                                 napi_callback_scope* result)\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[in] resource_object</code>: An object associated with the async work\nthat will be passed to possible <code>async_hooks</code> <a href=\"async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource\"><code>init</code> hooks</a>. This\nparameter has been deprecated and is ignored at runtime. Use the\n<code>async_resource</code> parameter in <a href=\"#n_api_napi_async_init\"><code>napi_async_init</code></a> instead.</li>\n<li><code>[in] context</code>: Context for the async operation that is invoking the callback.\nThis should be a value previously obtained from <a href=\"#n_api_napi_async_init\"><code>napi_async_init</code></a>.</li>\n<li><code>[out] result</code>: The newly created scope.</li>\n</ul>\n<p>There are cases (for example, resolving promises) where it is\nnecessary to have the equivalent of the scope associated with a callback\nin place when making certain Node-API calls. If there is no other script on\nthe stack the <a href=\"#n_api_napi_open_callback_scope\"><code>napi_open_callback_scope</code></a> and\n<a href=\"#n_api_napi_close_callback_scope\"><code>napi_close_callback_scope</code></a> functions can be used to open/close\nthe required scope.</p>",
               "type": "module",
               "displayName": "napi_open_callback_scope"
             },
@@ -2810,7 +2830,7 @@
                 ],
                 "changes": []
               },
-              "desc": "<pre><code class=\"language-c\">napi_status napi_get_version(napi_env env,\n                             uint32_t* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[out] result</code>: The highest version of N-API supported.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns the highest N-API version supported by the\nNode.js runtime. N-API is planned to be additive such that\nnewer releases of Node.js may support additional API functions.\nIn order to allow an addon to use a newer function when running with\nversions of Node.js that support it, while providing\nfallback behavior when running with Node.js versions that don't\nsupport it:</p>\n<ul>\n<li>Call <code>napi_get_version()</code> to determine if the API is available.</li>\n<li>If available, dynamically load a pointer to the function using <code>uv_dlsym()</code>.</li>\n<li>Use the dynamically loaded pointer to invoke the function.</li>\n<li>If the function is not available, provide an alternate implementation\nthat does not use the function.</li>\n</ul>",
+              "desc": "<pre><code class=\"language-c\">napi_status napi_get_version(napi_env env,\n                             uint32_t* result);\n</code></pre>\n<ul>\n<li><code>[in] env</code>: The environment that the API is invoked under.</li>\n<li><code>[out] result</code>: The highest version of Node-API supported.</li>\n</ul>\n<p>Returns <code>napi_ok</code> if the API succeeded.</p>\n<p>This API returns the highest Node-API version supported by the\nNode.js runtime. Node-API is planned to be additive such that\nnewer releases of Node.js may support additional API functions.\nIn order to allow an addon to use a newer function when running with\nversions of Node.js that support it, while providing\nfallback behavior when running with Node.js versions that don't\nsupport it:</p>\n<ul>\n<li>Call <code>napi_get_version()</code> to determine if the API is available.</li>\n<li>If available, dynamically load a pointer to the function using <code>uv_dlsym()</code>.</li>\n<li>Use the dynamically loaded pointer to invoke the function.</li>\n<li>If the function is not available, provide an alternate implementation\nthat does not use the function.</li>\n</ul>",
               "type": "module",
               "displayName": "napi_get_version"
             }
@@ -2845,7 +2865,7 @@
         {
           "textRaw": "Promises",
           "name": "promises",
-          "desc": "<p>N-API provides facilities for creating <code>Promise</code> objects as described in\n<a href=\"https://tc39.github.io/ecma262/#sec-promise-objects\">Section 25.4</a> of the ECMA specification. It implements promises as a pair of\nobjects. When a promise is created by <code>napi_create_promise()</code>, a \"deferred\"\nobject is created and returned alongside the <code>Promise</code>. The deferred object is\nbound to the created <code>Promise</code> and is the only means to resolve or reject the\n<code>Promise</code> using <code>napi_resolve_deferred()</code> or <code>napi_reject_deferred()</code>. The\ndeferred object that is created by <code>napi_create_promise()</code> is freed by\n<code>napi_resolve_deferred()</code> or <code>napi_reject_deferred()</code>. The <code>Promise</code> object may\nbe returned to JavaScript where it can be used in the usual fashion.</p>\n<p>For example, to create a promise and pass it to an asynchronous worker:</p>\n<pre><code class=\"language-c\">napi_deferred deferred;\nnapi_value promise;\nnapi_status status;\n\n// Create the promise.\nstatus = napi_create_promise(env, &#x26;deferred, &#x26;promise);\nif (status != napi_ok) return NULL;\n\n// Pass the deferred to a function that performs an asynchronous action.\ndo_something_asynchronous(deferred);\n\n// Return the promise to JS\nreturn promise;\n</code></pre>\n<p>The above function <code>do_something_asynchronous()</code> would perform its asynchronous\naction and then it would resolve or reject the deferred, thereby concluding the\npromise and freeing the deferred:</p>\n<pre><code class=\"language-c\">napi_deferred deferred;\nnapi_value undefined;\nnapi_status status;\n\n// Create a value with which to conclude the deferred.\nstatus = napi_get_undefined(env, &#x26;undefined);\nif (status != napi_ok) return NULL;\n\n// Resolve or reject the promise associated with the deferred depending on\n// whether the asynchronous action succeeded.\nif (asynchronous_action_succeeded) {\n  status = napi_resolve_deferred(env, deferred, undefined);\n} else {\n  status = napi_reject_deferred(env, deferred, undefined);\n}\nif (status != napi_ok) return NULL;\n\n// At this point the deferred has been freed, so we should assign NULL to it.\ndeferred = NULL;\n</code></pre>",
+          "desc": "<p>Node-API provides facilities for creating <code>Promise</code> objects as described in\n<a href=\"https://tc39.github.io/ecma262/#sec-promise-objects\">Section 25.4</a> of the ECMA specification. It implements promises as a pair of\nobjects. When a promise is created by <code>napi_create_promise()</code>, a \"deferred\"\nobject is created and returned alongside the <code>Promise</code>. The deferred object is\nbound to the created <code>Promise</code> and is the only means to resolve or reject the\n<code>Promise</code> using <code>napi_resolve_deferred()</code> or <code>napi_reject_deferred()</code>. The\ndeferred object that is created by <code>napi_create_promise()</code> is freed by\n<code>napi_resolve_deferred()</code> or <code>napi_reject_deferred()</code>. The <code>Promise</code> object may\nbe returned to JavaScript where it can be used in the usual fashion.</p>\n<p>For example, to create a promise and pass it to an asynchronous worker:</p>\n<pre><code class=\"language-c\">napi_deferred deferred;\nnapi_value promise;\nnapi_status status;\n\n// Create the promise.\nstatus = napi_create_promise(env, &#x26;deferred, &#x26;promise);\nif (status != napi_ok) return NULL;\n\n// Pass the deferred to a function that performs an asynchronous action.\ndo_something_asynchronous(deferred);\n\n// Return the promise to JS\nreturn promise;\n</code></pre>\n<p>The above function <code>do_something_asynchronous()</code> would perform its asynchronous\naction and then it would resolve or reject the deferred, thereby concluding the\npromise and freeing the deferred:</p>\n<pre><code class=\"language-c\">napi_deferred deferred;\nnapi_value undefined;\nnapi_status status;\n\n// Create a value with which to conclude the deferred.\nstatus = napi_get_undefined(env, &#x26;undefined);\nif (status != napi_ok) return NULL;\n\n// Resolve or reject the promise associated with the deferred depending on\n// whether the asynchronous action succeeded.\nif (asynchronous_action_succeeded) {\n  status = napi_resolve_deferred(env, deferred, undefined);\n} else {\n  status = napi_reject_deferred(env, deferred, undefined);\n}\nif (status != napi_ok) return NULL;\n\n// At this point the deferred has been freed, so we should assign NULL to it.\ndeferred = NULL;\n</code></pre>",
           "modules": [
             {
               "textRaw": "napi_create_promise",
@@ -2918,7 +2938,7 @@
         {
           "textRaw": "Script execution",
           "name": "script_execution",
-          "desc": "<p>N-API provides an API for executing a string containing JavaScript using the\nunderlying JavaScript engine.</p>",
+          "desc": "<p>Node-API provides an API for executing a string containing JavaScript using the\nunderlying JavaScript engine.</p>",
           "modules": [
             {
               "textRaw": "napi_run_script",
@@ -2943,15 +2963,15 @@
         {
           "textRaw": "libuv event loop",
           "name": "libuv_event_loop",
-          "desc": "<p>N-API provides a function for getting the current event loop associated with\na specific <code>napi_env</code>.</p>",
+          "desc": "<p>Node-API provides a function for getting the current event loop associated with\na specific <code>napi_env</code>.</p>",
           "modules": [
             {
               "textRaw": "napi_get_uv_event_loop",
               "name": "napi_get_uv_event_loop",
               "meta": {
                 "added": [
-                  "v8.10.0",
-                  "v9.3.0"
+                  "v9.3.0",
+                  "v8.10.0"
                 ],
                 "napiVersion": [
                   2
@@ -2969,12 +2989,12 @@
         {
           "textRaw": "Asynchronous thread-safe function calls",
           "name": "asynchronous_thread-safe_function_calls",
-          "desc": "<p>JavaScript functions can normally only be called from a native addon's main\nthread. If an addon creates additional threads, then N-API functions that\nrequire a <code>napi_env</code>, <code>napi_value</code>, or <code>napi_ref</code> must not be called from those\nthreads.</p>\n<p>When an addon has additional threads and JavaScript functions need to be invoked\nbased on the processing completed by those threads, those threads must\ncommunicate with the addon's main thread so that the main thread can invoke the\nJavaScript function on their behalf. The thread-safe function APIs provide an\neasy way to do this.</p>\n<p>These APIs provide the type <code>napi_threadsafe_function</code> as well as APIs to\ncreate, destroy, and call objects of this type.\n<code>napi_create_threadsafe_function()</code> creates a persistent reference to a\n<code>napi_value</code> that holds a JavaScript function which can be called from multiple\nthreads. The calls happen asynchronously. This means that values with which the\nJavaScript callback is to be called will be placed in a queue, and, for each\nvalue in the queue, a call will eventually be made to the JavaScript function.</p>\n<p>Upon creation of a <code>napi_threadsafe_function</code> a <code>napi_finalize</code> callback can be\nprovided. This callback will be invoked on the main thread when the thread-safe\nfunction is about to be destroyed. It receives the context and the finalize data\ngiven during construction, and provides an opportunity for cleaning up after the\nthreads e.g. by calling <code>uv_thread_join()</code>. <strong>Aside from the main loop thread,\nno threads should be using the thread-safe function after the finalize callback\ncompletes.</strong></p>\n<p>The <code>context</code> given during the call to <code>napi_create_threadsafe_function()</code> can\nbe retrieved from any thread with a call to\n<code>napi_get_threadsafe_function_context()</code>.</p>",
+          "desc": "<p>JavaScript functions can normally only be called from a native addon's main\nthread. If an addon creates additional threads, then Node-API functions that\nrequire a <code>napi_env</code>, <code>napi_value</code>, or <code>napi_ref</code> must not be called from those\nthreads.</p>\n<p>When an addon has additional threads and JavaScript functions need to be invoked\nbased on the processing completed by those threads, those threads must\ncommunicate with the addon's main thread so that the main thread can invoke the\nJavaScript function on their behalf. The thread-safe function APIs provide an\neasy way to do this.</p>\n<p>These APIs provide the type <code>napi_threadsafe_function</code> as well as APIs to\ncreate, destroy, and call objects of this type.\n<code>napi_create_threadsafe_function()</code> creates a persistent reference to a\n<code>napi_value</code> that holds a JavaScript function which can be called from multiple\nthreads. The calls happen asynchronously. This means that values with which the\nJavaScript callback is to be called will be placed in a queue, and, for each\nvalue in the queue, a call will eventually be made to the JavaScript function.</p>\n<p>Upon creation of a <code>napi_threadsafe_function</code> a <code>napi_finalize</code> callback can be\nprovided. This callback will be invoked on the main thread when the thread-safe\nfunction is about to be destroyed. It receives the context and the finalize data\ngiven during construction, and provides an opportunity for cleaning up after the\nthreads e.g. by calling <code>uv_thread_join()</code>. <strong>Aside from the main loop thread,\nno threads should be using the thread-safe function after the finalize callback\ncompletes.</strong></p>\n<p>The <code>context</code> given during the call to <code>napi_create_threadsafe_function()</code> can\nbe retrieved from any thread with a call to\n<code>napi_get_threadsafe_function_context()</code>.</p>",
           "modules": [
             {
               "textRaw": "Calling a thread-safe function",
               "name": "calling_a_thread-safe_function",
-              "desc": "<p><code>napi_call_threadsafe_function()</code> can be used for initiating a call into\nJavaScript. <code>napi_call_threadsafe_function()</code> accepts a parameter which controls\nwhether the API behaves blockingly. If set to <code>napi_tsfn_nonblocking</code>, the API\nbehaves non-blockingly, returning <code>napi_queue_full</code> if the queue was full,\npreventing data from being successfully added to the queue. If set to\n<code>napi_tsfn_blocking</code>, the API blocks until space becomes available in the queue.\n<code>napi_call_threadsafe_function()</code> never blocks if the thread-safe function was\ncreated with a maximum queue size of 0.</p>\n<p>The actual call into JavaScript is controlled by the callback given via the\n<code>call_js_cb</code> parameter. <code>call_js_cb</code> is invoked on the main thread once for each\nvalue that was placed into the queue by a successful call to\n<code>napi_call_threadsafe_function()</code>. If such a callback is not given, a default\ncallback will be used, and the resulting JavaScript call will have no arguments.\nThe <code>call_js_cb</code> callback receives the JavaScript function to call as a\n<code>napi_value</code> in its parameters, as well as the <code>void*</code> context pointer used when\ncreating the <code>napi_threadsafe_function</code>, and the next data pointer that was\ncreated by one of the secondary threads. The callback can then use an API such\nas <code>napi_call_function()</code> to call into JavaScript.</p>\n<p>The callback may also be invoked with <code>env</code> and <code>call_js_cb</code> both set to <code>NULL</code>\nto indicate that calls into JavaScript are no longer possible, while items\nremain in the queue that may need to be freed. This normally occurs when the\nNode.js process exits while there is a thread-safe function still active.</p>\n<p>It is not necessary to call into JavaScript via <code>napi_make_callback()</code> because\nN-API runs <code>call_js_cb</code> in a context appropriate for callbacks.</p>",
+              "desc": "<p><code>napi_call_threadsafe_function()</code> can be used for initiating a call into\nJavaScript. <code>napi_call_threadsafe_function()</code> accepts a parameter which controls\nwhether the API behaves blockingly. If set to <code>napi_tsfn_nonblocking</code>, the API\nbehaves non-blockingly, returning <code>napi_queue_full</code> if the queue was full,\npreventing data from being successfully added to the queue. If set to\n<code>napi_tsfn_blocking</code>, the API blocks until space becomes available in the queue.\n<code>napi_call_threadsafe_function()</code> never blocks if the thread-safe function was\ncreated with a maximum queue size of 0.</p>\n<p><code>napi_call_threadsafe_function()</code> should not be called with <code>napi_tsfn_blocking</code>\nfrom a JavaScript thread, because, if the queue is full, it may cause the\nJavaScript thread to deadlock.</p>\n<p>The actual call into JavaScript is controlled by the callback given via the\n<code>call_js_cb</code> parameter. <code>call_js_cb</code> is invoked on the main thread once for each\nvalue that was placed into the queue by a successful call to\n<code>napi_call_threadsafe_function()</code>. If such a callback is not given, a default\ncallback will be used, and the resulting JavaScript call will have no arguments.\nThe <code>call_js_cb</code> callback receives the JavaScript function to call as a\n<code>napi_value</code> in its parameters, as well as the <code>void*</code> context pointer used when\ncreating the <code>napi_threadsafe_function</code>, and the next data pointer that was\ncreated by one of the secondary threads. The callback can then use an API such\nas <code>napi_call_function()</code> to call into JavaScript.</p>\n<p>The callback may also be invoked with <code>env</code> and <code>call_js_cb</code> both set to <code>NULL</code>\nto indicate that calls into JavaScript are no longer possible, while items\nremain in the queue that may need to be freed. This normally occurs when the\nNode.js process exits while there is a thread-safe function still active.</p>\n<p>It is not necessary to call into JavaScript via <code>napi_make_callback()</code> because\nNode-API runs <code>call_js_cb</code> in a context appropriate for callbacks.</p>",
               "type": "module",
               "displayName": "Calling a thread-safe function"
             },
@@ -3004,7 +3024,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.6.0",
+                    "version": [
+                      "v12.6.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/27791",
                     "description": "Made `func` parameter optional with custom `call_js_cb`."
                   }
@@ -3040,9 +3063,20 @@
                 "napiVersion": [
                   4
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.5.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33453",
+                    "description": "Support for `napi_would_deadlock` has been reverted."
+                  },
+                  {
+                    "version": "v14.1.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32689",
+                    "description": "Return `napi_would_deadlock` when called with `napi_tsfn_blocking` from the main thread or a worker thread and the queue is full."
+                  }
+                ]
               },
-              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status\nnapi_call_threadsafe_function(napi_threadsafe_function func,\n                              void* data,\n                              napi_threadsafe_function_call_mode is_blocking);\n</code></pre>\n<ul>\n<li><code>[in] func</code>: The asynchronous thread-safe JavaScript function to invoke.</li>\n<li><code>[in] data</code>: Data to send into JavaScript via the callback <code>call_js_cb</code>\nprovided during the creation of the thread-safe JavaScript function.</li>\n<li><code>[in] is_blocking</code>: Flag whose value can be either <code>napi_tsfn_blocking</code> to\nindicate that the call should block if the queue is full or\n<code>napi_tsfn_nonblocking</code> to indicate that the call should return immediately\nwith a status of <code>napi_queue_full</code> whenever the queue is full.</li>\n</ul>\n<p>This API will return <code>napi_closing</code> if <code>napi_release_threadsafe_function()</code> was\ncalled with <code>abort</code> set to <code>napi_tsfn_abort</code> from any thread. The value is only\nadded to the queue if the API returns <code>napi_ok</code>.</p>\n<p>This API may be called from any thread which makes use of <code>func</code>.</p>",
+              "desc": "<pre><code class=\"language-c\">NAPI_EXTERN napi_status\nnapi_call_threadsafe_function(napi_threadsafe_function func,\n                              void* data,\n                              napi_threadsafe_function_call_mode is_blocking);\n</code></pre>\n<ul>\n<li><code>[in] func</code>: The asynchronous thread-safe JavaScript function to invoke.</li>\n<li><code>[in] data</code>: Data to send into JavaScript via the callback <code>call_js_cb</code>\nprovided during the creation of the thread-safe JavaScript function.</li>\n<li><code>[in] is_blocking</code>: Flag whose value can be either <code>napi_tsfn_blocking</code> to\nindicate that the call should block if the queue is full or\n<code>napi_tsfn_nonblocking</code> to indicate that the call should return immediately\nwith a status of <code>napi_queue_full</code> whenever the queue is full.</li>\n</ul>\n<p>This API should not be called with <code>napi_tsfn_blocking</code> from a JavaScript\nthread, because, if the queue is full, it may cause the JavaScript thread to\ndeadlock.</p>\n<p>This API will return <code>napi_closing</code> if <code>napi_release_threadsafe_function()</code> was\ncalled with <code>abort</code> set to <code>napi_tsfn_abort</code> from any thread. The value is only\nadded to the queue if the API returns <code>napi_ok</code>.</p>\n<p>This API may be called from any thread which makes use of <code>func</code>.</p>",
               "type": "module",
               "displayName": "napi_call_threadsafe_function"
             },
@@ -3119,7 +3153,7 @@
           "name": "miscellaneous_utilities",
           "meta": {
             "added": [
-              "v12.22.0"
+              "v14.18.0"
             ],
             "changes": []
           },
@@ -3134,7 +3168,7 @@
           "name": "node_api_get_module_file_name",
           "meta": {
             "added": [
-              "v12.22.0"
+              "v14.18.0"
             ],
             "changes": []
           },
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index a55bffd3fab47838bda1222469239224e0eadaed..2dc473dca16513a3c5b56124776b890699803df7 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1,30 +1,29 @@
-# N-API
+# Node-API
 
 <!--introduced_in=v8.0.0-->
 <!-- type=misc -->
 
 > Stability: 2 - Stable
 
-N-API (pronounced N as in the letter, followed by API)
-is an API for building native Addons. It is independent from
-the underlying JavaScript runtime (for example, V8) and is maintained as part of
-Node.js itself. This API will be Application Binary Interface (ABI) stable
-across versions of Node.js. It is intended to insulate Addons from
-changes in the underlying JavaScript engine and allow modules
+Node-API (formerly N-API) is an API for building native Addons. It is
+independent from the underlying JavaScript runtime (for example, V8) and is
+maintained as part of Node.js itself. This API will be Application Binary
+Interface (ABI) stable across versions of Node.js. It is intended to insulate
+addons from changes in the underlying JavaScript engine and allow modules
 compiled for one major version to run on later major versions of Node.js without
 recompilation. The [ABI Stability][] guide provides a more in-depth explanation.
 
 Addons are built/packaged with the same approach/tools outlined in the section
 titled [C++ Addons][]. The only difference is the set of APIs that are used by
 the native code. Instead of using the V8 or [Native Abstractions for Node.js][]
-APIs, the functions available in the N-API are used.
+APIs, the functions available in Node-API are used.
 
-APIs exposed by N-API are generally used to create and manipulate
+APIs exposed by Node-API are generally used to create and manipulate
 JavaScript values. Concepts and operations generally map to ideas specified
 in the ECMA-262 Language Specification. The APIs have the following
 properties:
 
-* All N-API calls return a status code of type `napi_status`. This
+* All Node-API calls return a status code of type `napi_status`. This
   status indicates whether the API call succeeded or failed.
 * The API's return value is passed via an out parameter.
 * All JavaScript values are abstracted behind an opaque type named
@@ -33,14 +32,14 @@ properties:
   using `napi_get_last_error_info`. More information can be found in the error
   handling section [Error handling][].
 
-The N-API is a C API that ensures ABI stability across Node.js versions
+Node-API is a C API that ensures ABI stability across Node.js versions
 and different compiler levels. A C++ API can be easier to use.
 To support using C++, the project maintains a
 C++ wrapper module called [`node-addon-api`][].
 This wrapper provides an inlineable C++ API. Binaries built
-with `node-addon-api` will depend on the symbols for the N-API C-based
+with `node-addon-api` will depend on the symbols for the Node-API C-based
 functions exported by Node.js. `node-addon-api` is a more
-efficient way to write code that calls N-API. Take, for example, the
+efficient way to write code that calls Node-API. Take, for example, the
 following `node-addon-api` code. The first section shows the
 `node-addon-api` code and the second section shows what actually gets
 used in the addon.
@@ -78,13 +77,13 @@ it still gets the benefits of the ABI stability provided by the C API.
 When using `node-addon-api` instead of the C APIs, start with the API [docs][]
 for `node-addon-api`.
 
-The [N-API Resource](https://nodejs.github.io/node-addon-examples/) offers an
-excellent orientation and tips for developers just getting started with N-API
-and `node-addon-api`.
+The [Node-API Resource](https://nodejs.github.io/node-addon-examples/) offers
+an excellent orientation and tips for developers just getting started with
+Node-API and `node-addon-api`.
 
 ## Implications of ABI stability
 
-Although N-API provides an ABI stability guarantee, other parts of Node.js do
+Although Node-API provides an ABI stability guarantee, other parts of Node.js do
 not, and any external libraries used from the addon may not. In particular,
 none of the following APIs provide an ABI stability guarantee across major
 versions:
@@ -111,19 +110,19 @@ versions:
     ```
 
 Thus, for an addon to remain ABI-compatible across Node.js major versions, it
-must use N-API exclusively by restricting itself to using
+must use Node-API exclusively by restricting itself to using
 
 ```c
 #include <node_api.h>
 ```
 
 and by checking, for all external libraries that it uses, that the external
-library makes ABI stability guarantees similar to N-API.
+library makes ABI stability guarantees similar to Node-API.
 
 ## Building
 
 Unlike modules written in JavaScript, developing and deploying Node.js
-native addons using N-API requires an additional set of tools. Besides the
+native addons using Node-API requires an additional set of tools. Besides the
 basic tools required to develop for Node.js, the native addon developer
 requires a toolchain that can compile C and C++ code into a binary. In
 addition, depending upon how the native addon is deployed, the *user* of
@@ -161,9 +160,9 @@ the native addon.
 
 #### node-gyp
 
-[node-gyp][] is a build system based on Google's [GYP][] tool and comes
-bundled with npm. GYP, and therefore node-gyp, requires that Python be
-installed.
+[node-gyp][] is a build system based on the [gyp-next][] fork of
+Google's [GYP][] tool and comes bundled with npm. GYP, and therefore node-gyp,
+requires that Python be installed.
 
 Historically, node-gyp has been the tool of choice for building native
 addons. It has widespread adoption and documentation. However, some
@@ -207,15 +206,15 @@ available to the module user when the native module is installed.
 
 ## Usage
 
-In order to use the N-API functions, include the file [`node_api.h`][] which is
-located in the src directory in the node development tree:
+In order to use the Node-API functions, include the file [`node_api.h`][] which
+is located in the src directory in the node development tree:
 
 ```c
 #include <node_api.h>
 ```
 
 This will opt into the default `NAPI_VERSION` for the given release of Node.js.
-In order to ensure compatibility with specific versions of N-API, the version
+In order to ensure compatibility with specific versions of Node-API, the version
 can be specified explicitly when including the header:
 
 ```c
@@ -223,10 +222,10 @@ can be specified explicitly when including the header:
 #include <node_api.h>
 ```
 
-This restricts the N-API surface to just the functionality that was available in
-the specified (and earlier) versions.
+This restricts the Node-API surface to just the functionality that was available
+in the specified (and earlier) versions.
 
-Some of the N-API surface is experimental and requires explicit opt-in:
+Some of the Node-API surface is experimental and requires explicit opt-in:
 
 ```c
 #define NAPI_EXPERIMENTAL
@@ -236,52 +235,149 @@ Some of the N-API surface is experimental and requires explicit opt-in:
 In this case the entire API surface, including any experimental APIs, will be
 available to the module code.
 
-## N-API version matrix
+## Node-API version matrix
 
-N-API versions are additive and versioned independently from Node.js.
+Node-API versions are additive and versioned independently from Node.js.
 Version 4 is an extension to version 3 in that it has all of the APIs
 from version 3 with some additions. This means that it is not necessary
 to recompile for new versions of Node.js which are
 listed as supporting a later version.
 
-|       | 1       | 2        | 3        | 4        | 5         | 6         |
-|-------|---------|----------|----------|----------|-----------|-----------|
-| v6.x  |         |          | v6.14.2* |          |           |           |
-| v8.x  | v8.0.0* | v8.10.0* | v8.11.2  | v8.16.0  |           |           |
-| v9.x  | v9.0.0* | v9.3.0*  | v9.11.0* |          |           |           |
-| v10.x | v10.0.0 | v10.0.0  | v10.0.0  | v10.16.0 | v10.17.0  | v10.20.0  |
-| v11.x | v11.0.0 | v11.0.0  | v11.0.0  | v11.8.0  |           |           |
-| v12.x | v12.0.0 | v12.0.0  | v12.0.0  | v12.0.0  | v12.11.0  | v12.17.0  |
-| v13.x | v13.0.0 | v13.0.0  | v13.0.0  | v13.0.0  | v13.0.0   |           |
-| v14.x | v14.0.0 | v14.0.0  | v14.0.0  | v14.0.0  | v14.0.0   | v14.0.0   |
-
-\* Indicates that the N-API version was released as experimental
-
-Each API documented for N-API will have a header named `added in:`, and APIs
-which are stable will have the additional header `N-API version:`.
+<!-- For accessibility purposes, this table needs row headers. That means we
+     can't do it in markdown. Hence, the raw HTML. -->
+
+<table>
+  <tr>
+    <td></td>
+    <th scope="col">1</th>
+    <th scope="col">2</th>
+    <th scope="col">3</th>
+  </tr>
+  <tr>
+    <th scope="row">v6.x</th>
+    <td></td>
+    <td></td>
+    <td>v6.14.2*</td>
+  </tr>
+  <tr>
+    <th scope="row">v8.x</th>
+    <td>v8.6.0**</td>
+    <td>v8.10.0*</td>
+    <td>v8.11.2</td>
+  </tr>
+  <tr>
+    <th scope="row">v9.x</th>
+    <td>v9.0.0*</td>
+    <td>v9.3.0*</td>
+    <td>v9.11.0*</td>
+  </tr>
+  <tr>
+    <th scope="row">≥ v10.x</th>
+    <td>all releases</td>
+    <td>all releases</td>
+    <td>all releases</td>
+  </tr>
+</table>
+
+<table>
+  <tr>
+    <td></td>
+    <th scope="col">4</th>
+    <th scope="col">5</th>
+    <th scope="col">6</th>
+    <th scope="col">7</th>
+    <th scope="col">8</th>
+  </tr>
+  <tr>
+    <th scope="row">v10.x</th>
+    <td>v10.16.0</td>
+    <td>v10.17.0</td>
+    <td>v10.20.0</td>
+    <td>v10.23.0</td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v11.x</th>
+    <td>v11.8.0</td>
+    <td></td>
+    <td></td>
+    <td></td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v12.x</th>
+    <td>v12.0.0</td>
+    <td>v12.11.0</td>
+    <td>v12.17.0</td>
+    <td>v12.19.0</td>
+    <td>v12.22.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v13.x</th>
+    <td>v13.0.0</td>
+    <td>v13.0.0</td>
+    <td></td>
+    <td></td>
+    <td></td>
+  </tr>
+  <tr>
+    <th scope="row">v14.x</th>
+    <td>v14.0.0</td>
+    <td>v14.0.0</td>
+    <td>v14.0.0</td>
+    <td>v14.12.0</td>
+    <td>v14.17.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v15.x</th>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.0.0</td>
+    <td>v15.12.0</td>
+  </tr>
+  <tr>
+    <th scope="row">v16.x</th>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+    <td>v16.0.0</td>
+  </tr>
+</table>
+
+\* Node-API was experimental.
+
+\*\* Node.js 8.0.0 included Node-API as experimental. It was released as
+Node-API version 1 but continued to evolve until Node.js 8.6.0. The API is
+different in versions prior to Node.js 8.6.0. We recommend Node-API version 3 or
+later.
+
+Each API documented for Node-API will have a header named `added in:`, and APIs
+which are stable will have the additional header `Node-API version:`.
 APIs are directly usable when using a Node.js version which supports
-the N-API version shown in `N-API version:` or higher.
+the Node-API version shown in `Node-API version:` or higher.
 When using a Node.js version that does not support the
-`N-API version:` listed or if there is no `N-API version:` listed,
+`Node-API version:` listed or if there is no `Node-API version:` listed,
 then the API will only be available if
 `#define NAPI_EXPERIMENTAL` precedes the inclusion of `node_api.h`
 or `js_native_api.h`. If an API appears not to be available on
 a version of Node.js which is later than the one shown in `added in:` then
 this is most likely the reason for the apparent absence.
 
-The N-APIs associated strictly with accessing ECMAScript features from native
+The Node-APIs associated strictly with accessing ECMAScript features from native
 code can be found separately in `js_native_api.h` and `js_native_api_types.h`.
 The APIs defined in these headers are included in `node_api.h` and
 `node_api_types.h`. The headers are structured in this way in order to allow
-implementations of N-API outside of Node.js. For those implementations the
+implementations of Node-API outside of Node.js. For those implementations the
 Node.js specific APIs may not be applicable.
 
 The Node.js-specific parts of an addon can be separated from the code that
 exposes the actual functionality to the JavaScript environment so that the
-latter may be used with multiple implementations of N-API. In the example below,
-`addon.c` and `addon.h` refer only to `js_native_api.h`. This ensures that
-`addon.c` can be reused to compile against either the Node.js implementation of
-N-API or any implementation of N-API outside of Node.js.
+latter may be used with multiple implementations of Node-API. In the example
+below, `addon.c` and `addon.h` refer only to `js_native_api.h`. This ensures
+that `addon.c` can be reused to compile against either the Node.js
+implementation of Node-API or any implementation of Node-API outside of Node.js.
 
 `addon_node.c` is a separate file that contains the Node.js specific entry point
 to the addon and which instantiates the addon by calling into `addon.c` when the
@@ -382,12 +478,14 @@ Native addons may need to allocate global state which they use during
 their entire life cycle such that the state must be unique to each instance of
 the addon.
 
-To this end, N-API provides a way to allocate data such that its life cycle is
-tied to the life cycle of the Agent.
+To this end, Node-API provides a way to allocate data such that its life cycle
+is tied to the life cycle of the Agent.
 
 ### napi_set_instance_data
 <!-- YAML
-added: v12.8.0
+added:
+ - v12.8.0
+ - v10.20.0
 napiVersion: 6
 -->
 
@@ -398,7 +496,7 @@ napi_status napi_set_instance_data(napi_env env,
                                    void* finalize_hint);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] data`: The data item to make available to bindings of this instance.
 * `[in] finalize_cb`: The function to call when the environment is being torn
   down. The function receives `data` so that it might free it.
@@ -416,7 +514,9 @@ by the previous call, it will not be called.
 
 ### napi_get_instance_data
 <!-- YAML
-added: v12.8.0
+added:
+ - v12.8.0
+ - v10.20.0
 napiVersion: 6
 -->
 
@@ -425,7 +525,7 @@ napi_status napi_get_instance_data(napi_env env,
                                    void** data);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[out] data`: The data item that was previously associated with the currently
   running Agent by a call to `napi_set_instance_data()`.
 
@@ -435,18 +535,18 @@ This API retrieves data that was previously associated with the currently
 running Agent via `napi_set_instance_data()`. If no data is set, the call will
 succeed and `data` will be set to `NULL`.
 
-## Basic N-API data types
+## Basic Node-API data types
 
-N-API exposes the following fundamental datatypes as abstractions that are
+Node-API exposes the following fundamental datatypes as abstractions that are
 consumed by the various APIs. These APIs should be treated as opaque,
-introspectable only with other N-API calls.
+introspectable only with other Node-API calls.
 
 ### napi_status
 <!-- YAML
 added: v8.0.0
 napiVersion: 1
 -->
-Integral status code indicating the success or failure of a N-API call.
+Integral status code indicating the success or failure of a Node-API call.
 Currently, the following status codes are supported.
 
 ```c
@@ -472,6 +572,7 @@ typedef enum {
   napi_date_expected,
   napi_arraybuffer_expected,
   napi_detachable_arraybuffer_expected,
+  napi_would_deadlock,  /* unused */
 } napi_status;
 ```
 
@@ -499,18 +600,18 @@ typedef struct {
   not implemented for any VM.
 * `engine_error_code`: VM-specific error code. This is currently
   not implemented for any VM.
-* `error_code`: The N-API status code that originated with the last error.
+* `error_code`: The Node-API status code that originated with the last error.
 
 See the [Error handling][] section for additional information.
 
 ### napi_env
 
-`napi_env` is used to represent a context that the underlying N-API
+`napi_env` is used to represent a context that the underlying Node-API
 implementation can use to persist VM-specific state. This structure is passed
 to native functions when they're invoked, and it must be passed back when
-making N-API calls. Specifically, the same `napi_env` that was passed in when
+making Node-API calls. Specifically, the same `napi_env` that was passed in when
 the initial native function was called must be passed to any subsequent
-nested N-API calls. Caching the `napi_env` for the purpose of general reuse,
+nested Node-API calls. Caching the `napi_env` for the purpose of general reuse,
 and passing the `napi_env` between instances of the same addon running on
 different [`Worker`][] threads is not allowed. The `napi_env` becomes invalid
 when an instance of a native addon is unloaded. Notification of this event is
@@ -566,14 +667,14 @@ typedef enum {
 } napi_threadsafe_function_call_mode;
 ```
 
-### N-API memory management types
+### Node-API memory management types
 #### napi_handle_scope
 
 This is an abstraction used to control and modify the lifetime of objects
-created within a particular scope. In general, N-API values are created within
-the context of a handle scope. When a native method is called from
+created within a particular scope. In general, Node-API values are created
+within the context of a handle scope. When a native method is called from
 JavaScript, a default handle scope will exist. If the user does not explicitly
-create a new handle scope, N-API values will be created in the default handle
+create a new handle scope, Node-API values will be created in the default handle
 scope. For any invocations of code outside the execution of a native method
 (for instance, during a libuv callback invocation), the module is required to
 create a scope before invoking any functions that can result in the creation
@@ -607,7 +708,9 @@ For more details, review the [Object lifetime management][].
 
 #### napi_type_tag
 <!-- YAML
-added: v12.19.0
+added:
+  - v14.8.0
+  - v12.19.0
 napiVersion: 8
 -->
 
@@ -629,14 +732,14 @@ typedef struct {
 
 #### napi_async_cleanup_hook_handle
 <!-- YAML
-added: v12.19.0
+added: v14.10.0
 -->
 
 An opaque value returned by [`napi_add_async_cleanup_hook`][]. It must be passed
 to [`napi_remove_async_cleanup_hook`][] when the chain of asynchronous cleanup
 events completes.
 
-### N-API callback types
+### Node-API callback types
 
 #### napi_callback_info
 <!-- YAML
@@ -653,7 +756,7 @@ added: v8.0.0
 napiVersion: 1
 -->
 Function pointer type for user-provided native functions which are to be
-exposed to JavaScript via N-API. Callback functions should satisfy the
+exposed to JavaScript via Node-API. Callback functions should satisfy the
 following signature:
 
 ```c
@@ -696,8 +799,8 @@ operations. Callback functions must satisfy the following signature:
 typedef void (*napi_async_execute_callback)(napi_env env, void* data);
 ```
 
-Implementations of this function must avoid making N-API calls that execute
-JavaScript or interact with JavaScript objects. N-API calls should be in the
+Implementations of this function must avoid making Node-API calls that execute
+JavaScript or interact with JavaScript objects. Node-API calls should be in the
 `napi_async_complete_callback` instead. Do not use the `napi_env` parameter as
 it will likely result in execution of JavaScript.
 
@@ -734,7 +837,7 @@ The data arriving from the secondary thread via the queue is given in the `data`
 parameter and the JavaScript function to call is given in the `js_callback`
 parameter.
 
-N-API sets up the environment prior to calling this callback, so it is
+Node-API sets up the environment prior to calling this callback, so it is
 sufficient to call the JavaScript function via `napi_call_function` rather than
 via `napi_make_callback`.
 
@@ -756,7 +859,7 @@ typedef void (*napi_threadsafe_function_call_js)(napi_env env,
 * `[in] context`: The optional data with which the thread-safe function was
   created.
 * `[in] data`: Data created by the secondary thread. It is the responsibility of
-  the callback to convert this native data to JavaScript values (with N-API
+  the callback to convert this native data to JavaScript values (with Node-API
   functions) that can be passed as parameters when `js_callback` is invoked.
   This pointer is managed entirely by the threads and this callback. Thus this
   callback should free the data.
@@ -766,7 +869,7 @@ handle and/or callback scope inside the function body is not necessary.
 
 #### napi_async_cleanup_hook
 <!-- YAML
-added: v12.19.0
+added: v14.10.0
 -->
 
 Function pointer used with [`napi_add_async_cleanup_hook`][]. It will be called
@@ -780,8 +883,8 @@ typedef void (*napi_async_cleanup_hook)(napi_async_cleanup_hook_handle handle,
 ```
 
 * `[in] handle`: The handle that must be passed to
-[`napi_remove_async_cleanup_hook`][] after completion of the asynchronous
-cleanup.
+  [`napi_remove_async_cleanup_hook`][] after completion of the asynchronous
+  cleanup.
 * `[in] data`: The data that was passed to [`napi_add_async_cleanup_hook`][].
 
 The body of the function should initiate the asynchronous cleanup actions at the
@@ -790,12 +893,12 @@ end of which `handle` must be passed in a call to
 
 ## Error handling
 
-N-API uses both return values and JavaScript exceptions for error handling.
+Node-API uses both return values and JavaScript exceptions for error handling.
 The following sections explain the approach for each case.
 
 ### Return values
 
-All of the N-API functions share the same error handling pattern. The
+All of the Node-API functions share the same error handling pattern. The
 return type of all API functions is `napi_status`.
 
 The return value will be `napi_ok` if the request was successful and
@@ -838,10 +941,10 @@ typedef struct napi_extended_error_info {
 * `error_message`: Textual representation of the error that occurred.
 * `engine_reserved`: Opaque handle reserved for engine use only.
 * `engine_error_code`: VM specific error code.
-* `error_code`: n-api status code for the last error.
+* `error_code`: Node-API status code for the last error.
 
 [`napi_get_last_error_info`][] returns the information for the last
-N-API call that was made.
+Node-API call that was made.
 
 Do not rely on the content or format of any of the extended information as it
 is not subject to SemVer and may change at any time. It is intended only for
@@ -861,7 +964,7 @@ napi_get_last_error_info(napi_env env,
 
 * `[in] env`: The environment that the API is invoked under.
 * `[out] result`: The `napi_extended_error_info` structure with more
-information about the error.
+  information about the error.
 
 Returns `napi_ok` if the API succeeded.
 
@@ -869,7 +972,7 @@ This API retrieves a `napi_extended_error_info` structure with information
 about the last error that occurred.
 
 The content of the `napi_extended_error_info` returned is only valid up until
-an n-api function is called on the same `env`.
+a Node-API function is called on the same `env`.
 
 Do not rely on the content or format of any of the extended information as it
 is not subject to SemVer and may change at any time. It is intended only for
@@ -879,7 +982,7 @@ This API can be called even if there is a pending JavaScript exception.
 
 ### Exceptions
 
-Any N-API function call may result in a pending JavaScript exception. This is
+Any Node-API function call may result in a pending JavaScript exception. This is
 the case for any of the API functions, even those that may not cause the
 execution of JavaScript.
 
@@ -890,10 +993,10 @@ exception is pending and no additional action is required. If the
 instead of simply returning immediately, [`napi_is_exception_pending`][]
 must be called in order to determine if an exception is pending or not.
 
-In many cases when an N-API function is called and an exception is
+In many cases when a Node-API function is called and an exception is
 already pending, the function will return immediately with a
 `napi_status` of `napi_pending_exception`. However, this is not the case
-for all functions. N-API allows a subset of the functions to be
+for all functions. Node-API allows a subset of the functions to be
 called to allow for some minimal cleanup before returning to JavaScript.
 In that case, `napi_status` will reflect the status for the function. It
 will not reflect previous pending exceptions. To avoid confusion, check
@@ -904,7 +1007,7 @@ When an exception is pending one of two approaches can be employed.
 The first approach is to do any appropriate cleanup and then return so that
 execution will return to JavaScript. As part of the transition back to
 JavaScript, the exception will be thrown at the point in the JavaScript
-code where the native method was invoked. The behavior of most N-API calls
+code where the native method was invoked. The behavior of most Node-API calls
 is unspecified while an exception is pending, and many will simply return
 `napi_pending_exception`, so do as little as possible and then return to
 JavaScript where the exception can be handled.
@@ -918,7 +1021,7 @@ clear the exception. On success, result will contain the handle to
 the last JavaScript `Object` thrown. If it is determined, after
 retrieving the exception, the exception cannot be handled after all
 it can be re-thrown it with [`napi_throw`][] where error is the
-JavaScript `Error` object to be thrown.
+JavaScript value to be thrown.
 
 The following utility functions are also available in case native code
 needs to throw an exception or determine if a `napi_value` is an instance
@@ -937,7 +1040,7 @@ generated internally. The goal is for applications to use these
 error codes for all error checking. The associated error messages
 will remain, but will only be meant to be used for logging and
 display with the expectation that the message can change without
-SemVer applying. In order to support this model with N-API, both
+SemVer applying. In order to support this model with Node-API, both
 in internal functionality and for module specific functionality
 (as its good practice), the `throw_` and `create_` functions
 take an optional code parameter which is the string for the code
@@ -1071,7 +1174,7 @@ NAPI_EXTERN napi_status napi_create_error(napi_env env,
 * `[in] env`: The environment that the API is invoked under.
 * `[in] code`: Optional `napi_value` with the string for the error code to be
   associated with the error.
-* `[in] msg`: `napi_value` that references a JavaScript `String` to be used as
+* `[in] msg`: `napi_value` that references a JavaScript `string` to be used as
   the message for the `Error`.
 * `[out] result`: `napi_value` representing the error created.
 
@@ -1095,7 +1198,7 @@ NAPI_EXTERN napi_status napi_create_type_error(napi_env env,
 * `[in] env`: The environment that the API is invoked under.
 * `[in] code`: Optional `napi_value` with the string for the error code to be
   associated with the error.
-* `[in] msg`: `napi_value` that references a JavaScript `String` to be used as
+* `[in] msg`: `napi_value` that references a JavaScript `string` to be used as
   the message for the `Error`.
 * `[out] result`: `napi_value` representing the error created.
 
@@ -1119,7 +1222,7 @@ NAPI_EXTERN napi_status napi_create_range_error(napi_env env,
 * `[in] env`: The environment that the API is invoked under.
 * `[in] code`: Optional `napi_value` with the string for the error code to be
   associated with the error.
-* `[in] msg`: `napi_value` that references a JavaScript `String` to be used as
+* `[in] msg`: `napi_value` that references a JavaScript `string` to be used as
   the message for the `Error`.
 * `[out] result`: `napi_value` representing the error created.
 
@@ -1191,9 +1294,9 @@ napiVersion: 1
 
 ```c
 NAPI_NO_RETURN void napi_fatal_error(const char* location,
-                                                 size_t location_len,
-                                                 const char* message,
-                                                 size_t message_len);
+                                     size_t location_len,
+                                     const char* message,
+                                     size_t message_len);
 ```
 
 * `[in] location`: Optional location at which the error occurred.
@@ -1209,7 +1312,7 @@ This API can be called even if there is a pending JavaScript exception.
 
 ## Object lifetime management
 
-As N-API calls are made, handles to objects in the heap for the underlying
+As Node-API calls are made, handles to objects in the heap for the underlying
 VM may be returned as `napi_values`. These handles must hold the
 objects 'live' until they are no longer required by the native code,
 otherwise the objects could be collected before the native code was
@@ -1223,7 +1326,7 @@ held live for the lifespan of the native method call.
 
 In many cases, however, it is necessary that the handles remain valid for
 either a shorter or longer lifespan than that of the native method.
-The sections which follow describe the N-API functions that can be used
+The sections which follow describe the Node-API functions that can be used
 to change the handle lifespan from the default.
 
 ### Making handle lifespan shorter than that of the native method
@@ -1247,13 +1350,13 @@ substantial resources. In addition, even though the native code could only
 use the most recent handle, all of the associated objects would also be
 kept alive since they all share the same scope.
 
-To handle this case, N-API provides the ability to establish a new 'scope' to
+To handle this case, Node-API provides the ability to establish a new 'scope' to
 which newly created handles will be associated. Once those handles
 are no longer required, the scope can be 'closed' and any handles associated
 with the scope are invalidated. The methods available to open/close scopes are
 [`napi_open_handle_scope`][] and [`napi_close_handle_scope`][].
 
-N-API only supports a single nested hierarchy of scopes. There is only one
+Node-API only supports a single nested hierarchy of scopes. There is only one
 active scope at any time, and all new handles will be associated with that
 scope while it is active. Scopes must be closed in the reverse order from
 which they are opened. In addition, all scopes created within a native method
@@ -1284,8 +1387,8 @@ for (int i = 0; i < 1000000; i++) {
 ```
 
 When nesting scopes, there are cases where a handle from an
-inner scope needs to live beyond the lifespan of that scope. N-API supports an
-'escapable scope' in order to support this case. An escapable scope
+inner scope needs to live beyond the lifespan of that scope. Node-API supports
+an 'escapable scope' in order to support this case. An escapable scope
 allows one handle to be 'promoted' so that it 'escapes' the
 current scope and the lifespan of the handle changes from the current
 scope to that of the outer scope.
@@ -1418,7 +1521,7 @@ described in the earlier section. The lifespan of a normal handle is
 managed by scopes and all scopes must be closed before the end of a native
 method.
 
-N-API provides methods to create persistent references to an object.
+Node-API provides methods to create persistent references to an object.
 Each persistent reference has an associated count with a value of 0
 or higher. The count determines if the reference will keep
 the corresponding object live. References with a count of 0 do not
@@ -1433,11 +1536,11 @@ for a reference is 0, all subsequent calls to
 get the object associated with the reference [`napi_get_reference_value`][]
 will return `NULL` for the returned `napi_value`. An attempt to call
 [`napi_reference_ref`][] for a reference whose object has been collected
-will result in an error.
+results in an error.
 
 References must be deleted once they are no longer required by the addon. When
-a reference is deleted it will no longer prevent the corresponding object from
-being collected. Failure to delete a persistent reference will result in
+a reference is deleted, it will no longer prevent the corresponding object from
+being collected. Failure to delete a persistent reference results in
 a 'memory leak' with both the native memory for the persistent reference and
 the corresponding object on the heap being retained forever.
 
@@ -1562,7 +1665,7 @@ While a Node.js process typically releases all its resources when exiting,
 embedders of Node.js, or future Worker support, may require addons to register
 clean-up hooks that will be run once the current Node.js instance exits.
 
-N-API provides functions for registering and un-registering such callbacks.
+Node-API provides functions for registering and un-registering such callbacks.
 When those callbacks are run, all resources that are being held by the addon
 should be freed up.
 
@@ -1616,12 +1719,14 @@ with `napi_add_env_cleanup_hook`, otherwise the process will abort.
 
 #### napi_add_async_cleanup_hook
 <!-- YAML
-added: v12.19.0
+added:
+  - v14.8.0
+  - v12.19.0
+napiVersion: 8
 changes:
-  - version: v12.19.0
+  - version: v14.10.0
     pr-url: https://github.com/nodejs/node/pull/34819
     description: Changed signature of the `hook` callback.
-napiVersion: 8
 -->
 
 ```c
@@ -1636,7 +1741,7 @@ NAPI_EXTERN napi_status napi_add_async_cleanup_hook(
 * `[in] hook`: The function pointer to call at environment teardown.
 * `[in] arg`: The pointer to pass to `hook` when it gets called.
 * `[out] remove_handle`: Optional handle that refers to the asynchronous cleanup
-hook.
+  hook.
 
 Registers `hook`, which is a function of type [`napi_async_cleanup_hook`][], as
 a function to be run with the `remove_handle` and `arg` parameters once the
@@ -1654,9 +1759,9 @@ is being torn down anyway.
 
 #### napi_remove_async_cleanup_hook
 <!-- YAML
-added: v12.19.0
+added: v14.8.0
 changes:
-  - version: v12.19.0
+  - version: v14.10.0
     pr-url: https://github.com/nodejs/node/pull/34819
     description: Removed `env` parameter.
 -->
@@ -1667,7 +1772,7 @@ NAPI_EXTERN napi_status napi_remove_async_cleanup_hook(
 ```
 
 * `[in] remove_handle`: The handle to an asynchronous cleanup hook that was
-created with [`napi_add_async_cleanup_hook`][].
+  created with [`napi_add_async_cleanup_hook`][].
 
 Unregisters the cleanup hook corresponding to `remove_handle`. This will prevent
 the hook from being executed, unless it has already started executing.
@@ -1675,7 +1780,7 @@ This must be called on any `napi_async_cleanup_hook_handle` value obtained
 from [`napi_add_async_cleanup_hook`][].
 
 ## Module registration
-N-API modules are registered in a manner similar to other modules
+Node-API modules are registered in a manner similar to other modules
 except that instead of using the `NODE_MODULE` macro the following
 is used:
 
@@ -1683,7 +1788,7 @@ is used:
 NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
 ```
 
-The next difference is the signature for the `Init` method. For a N-API
+The next difference is the signature for the `Init` method. For a Node-API
 module it is as follows:
 
 ```c
@@ -1693,8 +1798,8 @@ napi_value Init(napi_env env, napi_value exports);
 The return value from `Init` is treated as the `exports` object for the module.
 The `Init` method is passed an empty object via the `exports` parameter as a
 convenience. If `Init` returns `NULL`, the parameter passed as `exports` is
-exported by the module. N-API modules cannot modify the `module` object but can
-specify anything as the `exports` property of the module.
+exported by the module. Node-API modules cannot modify the `module` object but
+can specify anything as the `exports` property of the module.
 
 To add the method `hello` as a function so that it can be called as a method
 provided by the addon:
@@ -1758,8 +1863,8 @@ napi_value Init(napi_env env, napi_value exports) {
 }
 ```
 
-If the module will be loaded multiple times during the lifetime of the Node.js
-process, use the `NAPI_MODULE_INIT` macro to initialize the module:
+You can also use the `NAPI_MODULE_INIT` macro, which acts as a shorthand
+for `NAPI_MODULE` and defining an `Init` function:
 
 ```c
 NAPI_MODULE_INIT() {
@@ -1776,13 +1881,9 @@ NAPI_MODULE_INIT() {
 }
 ```
 
-This macro includes `NAPI_MODULE`, and declares an `Init` function with a
-special name and with visibility beyond the addon. This will allow Node.js to
-initialize the module even if it is loaded multiple times.
-
-There are a few design considerations when declaring a module that may be loaded
-multiple times. The documentation of [context-aware addons][] provides more
-details.
+All Node-API addons are context-aware, meaning they may be loaded multiple
+times. There are a few design considerations when declaring such a module.
+The documentation on [context-aware addons][] provides more details.
 
 The variables `env` and `exports` will be available inside the function body
 following the macro invocation.
@@ -1794,19 +1895,19 @@ For more details on building addon modules in general, refer to the existing
 API.
 
 ## Working with JavaScript values
-N-API exposes a set of APIs to create all types of JavaScript values.
+Node-API exposes a set of APIs to create all types of JavaScript values.
 Some of these types are documented under [Section 6][]
 of the [ECMAScript Language Specification][].
 
 Fundamentally, these APIs are used to do one of the following:
 
 1. Create a new JavaScript object
-2. Convert from a primitive C type to an N-API value
-3. Convert from N-API value to a primitive C type
+2. Convert from a primitive C type to a Node-API value
+3. Convert from Node-API value to a primitive C type
 4. Get global instances including `undefined` and `null`
 
-N-API values are represented by the type `napi_value`.
-Any N-API call that requires a JavaScript value takes in a `napi_value`.
+Node-API values are represented by the type `napi_value`.
+Any Node-API call that requires a JavaScript value takes in a `napi_value`.
 In some cases, the API does check the type of the `napi_value` up-front.
 However, for better performance, it's better for the caller to make sure that
 the `napi_value` in question is of the JavaScript type expected by the API.
@@ -1814,7 +1915,9 @@ the `napi_value` in question is of the JavaScript type expected by the API.
 ### Enum types
 #### napi_key_collection_mode
 <!-- YAML
-added: v12.17.0
+added:
+ - v13.7.0
+ - v10.20.0
 napiVersion: 6
 -->
 
@@ -1835,7 +1938,9 @@ of the objects's prototype chain as well.
 
 #### napi_key_filter
 <!-- YAML
-added: v12.17.0
+added:
+ - v13.7.0
+ - v10.20.0
 napiVersion: 6
 -->
 
@@ -1854,7 +1959,9 @@ Property filter bits. They can be or'ed to build a composite filter.
 
 #### napi_key_conversion
 <!-- YAML
-added: v12.17.0
+added:
+ - v13.7.0
+ - v10.20.0
 napiVersion: 6
 -->
 
@@ -1928,12 +2035,12 @@ napiVersion: 1
 napi_status napi_create_array(napi_env env, napi_value* result)
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[out] result`: A `napi_value` representing a JavaScript `Array`.
 
 Returns `napi_ok` if the API succeeded.
 
-This API returns an N-API value corresponding to a JavaScript `Array` type.
+This API returns a Node-API value corresponding to a JavaScript `Array` type.
 JavaScript arrays are described in
 [Section 22.1][] of the ECMAScript Language Specification.
 
@@ -1955,7 +2062,7 @@ napi_status napi_create_array_with_length(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
-This API returns an N-API value corresponding to a JavaScript `Array` type.
+This API returns a Node-API value corresponding to a JavaScript `Array` type.
 The `Array`'s length property is set to the passed-in length parameter.
 However, the underlying buffer is not guaranteed to be pre-allocated by the VM
 when the array is created. That behavior is left to the underlying VM
@@ -1986,7 +2093,7 @@ napi_status napi_create_arraybuffer(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
-This API returns an N-API value corresponding to a JavaScript `ArrayBuffer`.
+This API returns a Node-API value corresponding to a JavaScript `ArrayBuffer`.
 `ArrayBuffer`s are used to represent fixed-length binary data buffers. They are
 normally used as a backing-buffer for `TypedArray` objects.
 The `ArrayBuffer` allocated will have an underlying byte buffer whose size is
@@ -2051,7 +2158,9 @@ structure, in most cases using a `TypedArray` will suffice.
 
 #### napi_create_date
 <!-- YAML
-added: v11.11.0
+added:
+ - v11.11.0
+ - v10.17.0
 napiVersion: 5
 -->
 
@@ -2143,7 +2252,7 @@ napi_create_external_arraybuffer(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
-This API returns an N-API value corresponding to a JavaScript `ArrayBuffer`.
+This API returns a Node-API value corresponding to a JavaScript `ArrayBuffer`.
 The underlying byte buffer of the `ArrayBuffer` is externally allocated and
 managed. The caller must ensure that the byte buffer remains valid until the
 finalize callback is called.
@@ -2235,14 +2344,14 @@ napi_status napi_create_symbol(napi_env env,
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] description`: Optional `napi_value` which refers to a JavaScript
-  `String` to be set as the description for the symbol.
-* `[out] result`: A `napi_value` representing a JavaScript `Symbol`.
+  `string` to be set as the description for the symbol.
+* `[out] result`: A `napi_value` representing a JavaScript `symbol`.
 
 Returns `napi_ok` if the API succeeded.
 
-This API creates a JavaScript `Symbol` object from a UTF8-encoded C string.
+This API creates a JavaScript `symbol` value from a UTF8-encoded C string.
 
-The JavaScript `Symbol` type is described in [Section 19.4][]
+The JavaScript `symbol` type is described in [Section 19.4][]
 of the ECMAScript Language Specification.
 
 #### napi_create_typedarray
@@ -2316,7 +2425,7 @@ raised.
 JavaScript `DataView` objects are described in
 [Section 24.3][] of the ECMAScript Language Specification.
 
-### Functions to convert from C types to N-API
+### Functions to convert from C types to Node-API
 #### napi_create_int32
 <!-- YAML
 added: v8.4.0
@@ -2329,14 +2438,14 @@ napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: Integer value to be represented in JavaScript.
-* `[out] result`: A `napi_value` representing a JavaScript `Number`.
+* `[out] result`: A `napi_value` representing a JavaScript `number`.
 
 Returns `napi_ok` if the API succeeded.
 
 This API is used to convert from the C `int32_t` type to the JavaScript
-`Number` type.
+`number` type.
 
-The JavaScript `Number` type is described in
+The JavaScript `number` type is described in
 [Section 6.1.6][] of the ECMAScript Language Specification.
 
 #### napi_create_uint32
@@ -2351,14 +2460,14 @@ napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result)
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: Unsigned integer value to be represented in JavaScript.
-* `[out] result`: A `napi_value` representing a JavaScript `Number`.
+* `[out] result`: A `napi_value` representing a JavaScript `number`.
 
 Returns `napi_ok` if the API succeeded.
 
 This API is used to convert from the C `uint32_t` type to the JavaScript
-`Number` type.
+`number` type.
 
-The JavaScript `Number` type is described in
+The JavaScript `number` type is described in
 [Section 6.1.6][] of the ECMAScript Language Specification.
 
 #### napi_create_int64
@@ -2373,14 +2482,14 @@ napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: Integer value to be represented in JavaScript.
-* `[out] result`: A `napi_value` representing a JavaScript `Number`.
+* `[out] result`: A `napi_value` representing a JavaScript `number`.
 
 Returns `napi_ok` if the API succeeded.
 
 This API is used to convert from the C `int64_t` type to the JavaScript
-`Number` type.
+`number` type.
 
-The JavaScript `Number` type is described in [Section 6.1.6][]
+The JavaScript `number` type is described in [Section 6.1.6][]
 of the ECMAScript Language Specification. Note the complete range of `int64_t`
 cannot be represented with full precision in JavaScript. Integer values
 outside the range of [`Number.MIN_SAFE_INTEGER`][] `-(2**53 - 1)` -
@@ -2398,14 +2507,14 @@ napi_status napi_create_double(napi_env env, double value, napi_value* result)
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: Double-precision value to be represented in JavaScript.
-* `[out] result`: A `napi_value` representing a JavaScript `Number`.
+* `[out] result`: A `napi_value` representing a JavaScript `number`.
 
 Returns `napi_ok` if the API succeeded.
 
 This API is used to convert from the C `double` type to the JavaScript
-`Number` type.
+`number` type.
 
-The JavaScript `Number` type is described in
+The JavaScript `number` type is described in
 [Section 6.1.6][] of the ECMAScript Language Specification.
 
 #### napi_create_bigint_int64
@@ -2494,14 +2603,14 @@ napi_status napi_create_string_latin1(napi_env env,
 * `[in] str`: Character buffer representing an ISO-8859-1-encoded string.
 * `[in] length`: The length of the string in bytes, or `NAPI_AUTO_LENGTH` if it
   is null-terminated.
-* `[out] result`: A `napi_value` representing a JavaScript `String`.
+* `[out] result`: A `napi_value` representing a JavaScript `string`.
 
 Returns `napi_ok` if the API succeeded.
 
-This API creates a JavaScript `String` object from an ISO-8859-1-encoded C
+This API creates a JavaScript `string` value from an ISO-8859-1-encoded C
 string. The native string is copied.
 
-The JavaScript `String` type is described in
+The JavaScript `string` type is described in
 [Section 6.1.4][] of the ECMAScript Language Specification.
 
 #### napi_create_string_utf16
@@ -2521,14 +2630,14 @@ napi_status napi_create_string_utf16(napi_env env,
 * `[in] str`: Character buffer representing a UTF16-LE-encoded string.
 * `[in] length`: The length of the string in two-byte code units, or
   `NAPI_AUTO_LENGTH` if it is null-terminated.
-* `[out] result`: A `napi_value` representing a JavaScript `String`.
+* `[out] result`: A `napi_value` representing a JavaScript `string`.
 
 Returns `napi_ok` if the API succeeded.
 
-This API creates a JavaScript `String` object from a UTF16-LE-encoded C string.
+This API creates a JavaScript `string` value from a UTF16-LE-encoded C string.
 The native string is copied.
 
-The JavaScript `String` type is described in
+The JavaScript `string` type is described in
 [Section 6.1.4][] of the ECMAScript Language Specification.
 
 #### napi_create_string_utf8
@@ -2548,17 +2657,17 @@ napi_status napi_create_string_utf8(napi_env env,
 * `[in] str`: Character buffer representing a UTF8-encoded string.
 * `[in] length`: The length of the string in bytes, or `NAPI_AUTO_LENGTH` if it
   is null-terminated.
-* `[out] result`: A `napi_value` representing a JavaScript `String`.
+* `[out] result`: A `napi_value` representing a JavaScript `string`.
 
 Returns `napi_ok` if the API succeeded.
 
-This API creates a JavaScript `String` object from a UTF8-encoded C string.
+This API creates a JavaScript `string` value from a UTF8-encoded C string.
 The native string is copied.
 
-The JavaScript `String` type is described in
+The JavaScript `string` type is described in
 [Section 6.1.4][] of the ECMAScript Language Specification.
 
-### Functions to convert from N-API to C types
+### Functions to convert from Node-API to C types
 #### napi_get_array_length
 <!-- YAML
 added: v8.0.0
@@ -2719,7 +2828,7 @@ napi_status napi_get_dataview_info(napi_env env,
 * `[in] env`: The environment that the API is invoked under.
 * `[in] dataview`: `napi_value` representing the `DataView` whose
   properties to query.
-* `[out] byte_length`: `Number` of bytes in the `DataView`.
+* `[out] byte_length`: Number of bytes in the `DataView`.
 * `[out] data`: The data buffer underlying the `DataView`.
   If byte_length is `0`, this may be `NULL` or any other pointer value.
 * `[out] arraybuffer`: `ArrayBuffer` underlying the `DataView`.
@@ -2732,7 +2841,9 @@ This API returns various properties of a `DataView`.
 
 #### napi_get_date_value
 <!-- YAML
-added: v11.11.0
+added:
+ - v11.11.0
+ - v10.17.0
 napiVersion: 5
 -->
 
@@ -2790,15 +2901,15 @@ napi_status napi_get_value_double(napi_env env,
 ```
 
 * `[in] env`: The environment that the API is invoked under.
-* `[in] value`: `napi_value` representing JavaScript `Number`.
+* `[in] value`: `napi_value` representing JavaScript `number`.
 * `[out] result`: C double primitive equivalent of the given JavaScript
-  `Number`.
+  `number`.
 
 Returns `napi_ok` if the API succeeded. If a non-number `napi_value` is passed
 in it returns `napi_number_expected`.
 
 This API returns the C double primitive equivalent of the given JavaScript
-`Number`.
+`number`.
 
 #### napi_get_value_bigint_int64
 <!-- YAML
@@ -2916,15 +3027,15 @@ napi_status napi_get_value_int32(napi_env env,
 ```
 
 * `[in] env`: The environment that the API is invoked under.
-* `[in] value`: `napi_value` representing JavaScript `Number`.
+* `[in] value`: `napi_value` representing JavaScript `number`.
 * `[out] result`: C `int32` primitive equivalent of the given JavaScript
-  `Number`.
+  `number`.
 
 Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
 is passed in `napi_number_expected`.
 
 This API returns the C `int32` primitive equivalent
-of the given JavaScript `Number`.
+of the given JavaScript `number`.
 
 If the number exceeds the range of the 32 bit integer, then the result is
 truncated to the equivalent of the bottom 32 bits. This can result in a large
@@ -2946,17 +3057,17 @@ napi_status napi_get_value_int64(napi_env env,
 ```
 
 * `[in] env`: The environment that the API is invoked under.
-* `[in] value`: `napi_value` representing JavaScript `Number`.
+* `[in] value`: `napi_value` representing JavaScript `number`.
 * `[out] result`: C `int64` primitive equivalent of the given JavaScript
-  `Number`.
+  `number`.
 
 Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
 is passed in it returns `napi_number_expected`.
 
 This API returns the C `int64` primitive equivalent of the given JavaScript
-`Number`.
+`number`.
 
-`Number` values outside the range of [`Number.MIN_SAFE_INTEGER`][]
+`number` values outside the range of [`Number.MIN_SAFE_INTEGER`][]
 `-(2**53 - 1)` - [`Number.MAX_SAFE_INTEGER`][] `(2**53 - 1)` will lose
 precision.
 
@@ -2980,13 +3091,14 @@ napi_status napi_get_value_string_latin1(napi_env env,
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: `napi_value` representing JavaScript string.
 * `[in] buf`: Buffer to write the ISO-8859-1-encoded string into. If `NULL` is
-  passed in, the length of the string (in bytes) is returned.
+  passed in, the length of the string in bytes and excluding the null terminator
+  is returned in `result`.
 * `[in] bufsize`: Size of the destination buffer. When this value is
-  insufficient, the returned string will be truncated.
+  insufficient, the returned string is truncated and null-terminated.
 * `[out] result`: Number of bytes copied into the buffer, excluding the null
   terminator.
 
-Returns `napi_ok` if the API succeeded. If a non-`String` `napi_value`
+Returns `napi_ok` if the API succeeded. If a non-`string` `napi_value`
 is passed in it returns `napi_string_expected`.
 
 This API returns the ISO-8859-1-encoded string corresponding the value passed
@@ -3009,13 +3121,14 @@ napi_status napi_get_value_string_utf8(napi_env env,
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: `napi_value` representing JavaScript string.
 * `[in] buf`: Buffer to write the UTF8-encoded string into. If `NULL` is passed
-  in, the length of the string (in bytes) is returned.
+  in, the length of the string in bytes and excluding the null terminator is
+  returned in `result`.
 * `[in] bufsize`: Size of the destination buffer. When this value is
-  insufficient, the returned string will be truncated.
+  insufficient, the returned string is truncated and null-terminated.
 * `[out] result`: Number of bytes copied into the buffer, excluding the null
   terminator.
 
-Returns `napi_ok` if the API succeeded. If a non-`String` `napi_value`
+Returns `napi_ok` if the API succeeded. If a non-`string` `napi_value`
 is passed in it returns `napi_string_expected`.
 
 This API returns the UTF8-encoded string corresponding the value passed in.
@@ -3037,13 +3150,14 @@ napi_status napi_get_value_string_utf16(napi_env env,
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: `napi_value` representing JavaScript string.
 * `[in] buf`: Buffer to write the UTF16-LE-encoded string into. If `NULL` is
-  passed in, the length of the string (in 2-byte code units) is returned.
+  passed in, the length of the string in 2-byte code units and excluding the
+  null terminator is returned.
 * `[in] bufsize`: Size of the destination buffer. When this value is
-  insufficient, the returned string will be truncated.
+  insufficient, the returned string is truncated and null-terminated.
 * `[out] result`: Number of 2-byte code units copied into the buffer, excluding
   the null terminator.
 
-Returns `napi_ok` if the API succeeded. If a non-`String` `napi_value`
+Returns `napi_ok` if the API succeeded. If a non-`string` `napi_value`
 is passed in it returns `napi_string_expected`.
 
 This API returns the UTF16-encoded string corresponding the value passed in.
@@ -3061,7 +3175,7 @@ napi_status napi_get_value_uint32(napi_env env,
 ```
 
 * `[in] env`: The environment that the API is invoked under.
-* `[in] value`: `napi_value` representing JavaScript `Number`.
+* `[in] value`: `napi_value` representing JavaScript `number`.
 * `[out] result`: C primitive equivalent of the given `napi_value` as a
   `uint32_t`.
 
@@ -3145,14 +3259,14 @@ This API returns the Undefined object.
 
 ## Working with JavaScript values and abstract operations
 
-N-API exposes a set of APIs to perform some abstract operations on JavaScript
+Node-API exposes a set of APIs to perform some abstract operations on JavaScript
 values. Some of these operations are documented under [Section 7][]
 of the [ECMAScript Language Specification][].
 
 These APIs support doing one of the following:
 
-1. Coerce JavaScript values to specific JavaScript types (such as `Number` or
-   `String`).
+1. Coerce JavaScript values to specific JavaScript types (such as `number` or
+   `string`).
 2. Check the type of a JavaScript value.
 3. Check for equality between two JavaScript values.
 
@@ -3192,7 +3306,7 @@ napi_status napi_coerce_to_number(napi_env env,
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: The JavaScript value to coerce.
-* `[out] result`: `napi_value` representing the coerced JavaScript `Number`.
+* `[out] result`: `napi_value` representing the coerced JavaScript `number`.
 
 Returns `napi_ok` if the API succeeded.
 
@@ -3236,7 +3350,7 @@ napi_status napi_coerce_to_string(napi_env env,
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] value`: The JavaScript value to coerce.
-* `[out] result`: `napi_value` representing the coerced JavaScript `String`.
+* `[out] result`: `napi_value` representing the coerced JavaScript `string`.
 
 Returns `napi_ok` if the API succeeded.
 
@@ -3261,7 +3375,7 @@ napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result)
 Returns `napi_ok` if the API succeeded.
 
 * `napi_invalid_arg` if the type of `value` is not a known ECMAScript type and
- `value` is not an External value.
+  `value` is not an External value.
 
 This API represents behavior similar to invoking the `typeof` Operator on
 the object as defined in [Section 12.5.5][] of the ECMAScript Language
@@ -3356,7 +3470,9 @@ This API checks if the `Object` passed in is a buffer.
 
 ### napi_is_date
 <!-- YAML
-added: v11.11.0
+added:
+ - v11.11.0
+ - v10.17.0
 napiVersion: 5
 -->
 
@@ -3452,7 +3568,10 @@ defined in [Section 7.2.14][] of the ECMAScript Language Specification.
 
 ### napi_detach_arraybuffer
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.0.0
+ - v12.16.0
+ - v10.22.0
 napiVersion: 7
 -->
 
@@ -3477,7 +3596,10 @@ defined in [Section 24.1.1.3][] of the ECMAScript Language Specification.
 
 ### napi_is_detached_arraybuffer
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.3.0
+ - v12.16.0
+ - v10.22.0
 napiVersion: 7
 -->
 
@@ -3501,21 +3623,21 @@ Specification.
 
 ## Working with JavaScript properties
 
-N-API exposes a set of APIs to get and set properties on JavaScript
+Node-API exposes a set of APIs to get and set properties on JavaScript
 objects. Some of these types are documented under [Section 7][] of the
 [ECMAScript Language Specification][].
 
 Properties in JavaScript are represented as a tuple of a key and a value.
-Fundamentally, all property keys in N-API can be represented in one of the
+Fundamentally, all property keys in Node-API can be represented in one of the
 following forms:
 
 * Named: a simple UTF8-encoded string
 * Integer-Indexed: an index value represented by `uint32_t`
-* JavaScript value: these are represented in N-API by `napi_value`. This can
-  be a `napi_value` representing a `String`, `Number`, or `Symbol`.
+* JavaScript value: these are represented in Node-API by `napi_value`. This can
+  be a `napi_value` representing a `string`, `number`, or `symbol`.
 
-N-API values are represented by the type `napi_value`.
-Any N-API call that requires a JavaScript value takes in a `napi_value`.
+Node-API values are represented by the type `napi_value`.
+Any Node-API call that requires a JavaScript value takes in a `napi_value`.
 However, it's the caller's responsibility to make sure that the
 `napi_value` in question is of the JavaScript type expected by the API.
 
@@ -3530,7 +3652,7 @@ const obj = {};
 obj.myProp = 123;
 ```
 
-The equivalent can be done using N-API values with the following snippet:
+The equivalent can be done using Node-API values with the following snippet:
 
 ```c
 napi_status status = napi_generic_failure;
@@ -3557,7 +3679,7 @@ const arr = [];
 arr[123] = 'hello';
 ```
 
-The equivalent can be done using N-API values with the following snippet:
+The equivalent can be done using Node-API values with the following snippet:
 
 ```c
 napi_status status = napi_generic_failure;
@@ -3584,7 +3706,7 @@ const arr = [];
 const value = arr[123];
 ```
 
-The following is the approximate equivalent of the N-API counterpart:
+The following is the approximate equivalent of the Node-API counterpart:
 
 ```c
 napi_status status = napi_generic_failure;
@@ -3610,7 +3732,7 @@ Object.defineProperties(obj, {
 });
 ```
 
-The following is the approximate equivalent of the N-API counterpart:
+The following is the approximate equivalent of the Node-API counterpart:
 
 ```c
 napi_status status = napi_status_generic_failure;
@@ -3643,9 +3765,9 @@ if (status != napi_ok) return status;
 #### napi_property_attributes
 <!-- YAML
 changes:
- - version: v12.20.0
+ - version: v14.12.0
    pr-url: https://github.com/nodejs/node/pull/35214
-   description: added `napi_default_method` and `napi_default_property`
+   description: added `napi_default_method` and `napi_default_property`.
 -->
 
 ```c
@@ -3663,7 +3785,7 @@ typedef enum {
   napi_default_method = napi_writable | napi_configurable,
 
   // Default for object properties, like in JS obj[prop].
-  napi_default_property = napi_writable |
+  napi_default_jsproperty = napi_writable |
                           napi_enumerable |
                           napi_configurable,
 } napi_property_attributes;
@@ -3684,10 +3806,10 @@ They can be one or more of the following bitflags:
 * `napi_static`: The property will be defined as a static property on a class as
   opposed to an instance property, which is the default. This is used only by
   [`napi_define_class`][]. It is ignored by `napi_define_properties`.
-* `napi_default_method`: The property is configureable, writeable but not
-  enumerable like a method in a JS class.
-* `napi_default_property`: The property is writable, enumerable and configurable
-  like a property set via JS code `obj.key = value`.
+* `napi_default_method`: Like a method in a JS class, the property is
+  configurable and writeable, but not enumerable.
+* `napi_default_jsproperty`: Like a property set via assignment in JavaScript,
+  the property is writable, enumerable, and configurable.
 
 #### napi_property_descriptor
 
@@ -3707,7 +3829,7 @@ typedef struct {
 } napi_property_descriptor;
 ```
 
-* `utf8name`: Optional `String` describing the key for the property,
+* `utf8name`: Optional string describing the key for the property,
   encoded as UTF8. One of `utf8name` or `name` must be provided for the
   property.
 * `name`: Optional `napi_value` that points to a JavaScript string or symbol
@@ -3720,12 +3842,12 @@ typedef struct {
   If this is passed in, set `value` and `method` to `NULL` (since these members
   won't be used). The given function is called implicitly by the runtime when
   the property is accessed from JavaScript code (or if a get on the property is
-  performed using a N-API call). [`napi_callback`][] provides more details.
+  performed using a Node-API call). [`napi_callback`][] provides more details.
 * `setter`: A function to call when a set access of the property is performed.
   If this is passed in, set `value` and `method` to `NULL` (since these members
   won't be used). The given function is called implicitly by the runtime when
   the property is set from JavaScript code (or if a set on the property is
-  performed using a N-API call). [`napi_callback`][] provides more details.
+  performed using a Node-API call). [`napi_callback`][] provides more details.
 * `method`: Set this to make the property descriptor object's `value`
   property to be a JavaScript function represented by `method`. If this is
   passed in, set `value`, `getter` and `setter` to `NULL` (since these members
@@ -3748,7 +3870,7 @@ napi_status napi_get_property_names(napi_env env,
                                     napi_value* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object from which to retrieve the properties.
 * `[out] result`: A `napi_value` representing an array of JavaScript values
   that represent the property names of the object. The API can be used to
@@ -3763,7 +3885,9 @@ included.
 
 #### napi_get_all_property_names
 <!-- YAML
-added: v12.17.0
+added:
+ - v13.7.0
+ - v10.20.0
 napiVersion: 6
 -->
 
@@ -3776,15 +3900,15 @@ napi_get_all_property_names(napi_env env,
                             napi_value* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object from which to retrieve the properties.
 * `[in] key_mode`: Whether to retrieve prototype properties as well.
 * `[in] key_filter`: Which properties to retrieve
-(enumerable/readable/writable).
+  (enumerable/readable/writable).
 * `[in] key_conversion`: Whether to convert numbered property keys to strings.
 * `[out] result`: A `napi_value` representing an array of JavaScript values
-that represent the property names of the object. [`napi_get_array_length`][] and
-[`napi_get_element`][] can be used to iterate over `result`.
+  that represent the property names of the object. [`napi_get_array_length`][]
+  and [`napi_get_element`][] can be used to iterate over `result`.
 
 Returns `napi_ok` if the API succeeded.
 
@@ -3804,7 +3928,7 @@ napi_status napi_set_property(napi_env env,
                               napi_value value);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object on which to set the property.
 * `[in] key`: The name of the property to set.
 * `[in] value`: The property value.
@@ -3826,7 +3950,7 @@ napi_status napi_get_property(napi_env env,
                               napi_value* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object from which to retrieve the property.
 * `[in] key`: The name of the property to retrieve.
 * `[out] result`: The value of the property.
@@ -3848,7 +3972,7 @@ napi_status napi_has_property(napi_env env,
                               bool* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object to query.
 * `[in] key`: The name of the property whose existence to check.
 * `[out] result`: Whether the property exists on the object or not.
@@ -3870,7 +3994,7 @@ napi_status napi_delete_property(napi_env env,
                                  bool* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object to query.
 * `[in] key`: The name of the property to delete.
 * `[out] result`: Whether the property deletion succeeded or not. `result` can
@@ -3893,7 +4017,7 @@ napi_status napi_has_own_property(napi_env env,
                                   bool* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object to query.
 * `[in] key`: The name of the own property whose existence to check.
 * `[out] result`: Whether the own property exists on the object or not.
@@ -3901,8 +4025,8 @@ napi_status napi_has_own_property(napi_env env,
 Returns `napi_ok` if the API succeeded.
 
 This API checks if the `Object` passed in has the named own property. `key` must
-be a string or a `Symbol`, or an error will be thrown. N-API will not perform
-any conversion between data types.
+be a `string` or a `symbol`, or an error will be thrown. Node-API will not
+perform any conversion between data types.
 
 #### napi_set_named_property
 <!-- YAML
@@ -3917,7 +4041,7 @@ napi_status napi_set_named_property(napi_env env,
                                     napi_value value);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object on which to set the property.
 * `[in] utf8Name`: The name of the property to set.
 * `[in] value`: The property value.
@@ -3940,7 +4064,7 @@ napi_status napi_get_named_property(napi_env env,
                                     napi_value* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object from which to retrieve the property.
 * `[in] utf8Name`: The name of the property to get.
 * `[out] result`: The value of the property.
@@ -3963,7 +4087,7 @@ napi_status napi_has_named_property(napi_env env,
                                     bool* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object to query.
 * `[in] utf8Name`: The name of the property whose existence to check.
 * `[out] result`: Whether the property exists on the object or not.
@@ -3986,7 +4110,7 @@ napi_status napi_set_element(napi_env env,
                              napi_value value);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object from which to set the properties.
 * `[in] index`: The index of the property to set.
 * `[in] value`: The property value.
@@ -4008,7 +4132,7 @@ napi_status napi_get_element(napi_env env,
                              napi_value* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object from which to retrieve the property.
 * `[in] index`: The index of the property to get.
 * `[out] result`: The value of the property.
@@ -4030,7 +4154,7 @@ napi_status napi_has_element(napi_env env,
                              bool* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object to query.
 * `[in] index`: The index of the property whose existence to check.
 * `[out] result`: Whether the property exists on the object or not.
@@ -4053,7 +4177,7 @@ napi_status napi_delete_element(napi_env env,
                                 bool* result);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object to query.
 * `[in] index`: The index of the property to delete.
 * `[out] result`: Whether the element deletion succeeded or not. `result` can
@@ -4076,7 +4200,7 @@ napi_status napi_define_properties(napi_env env,
                                    const napi_property_descriptor* properties);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object from which to retrieve the properties.
 * `[in] property_count`: The number of elements in the `properties` array.
 * `[in] properties`: The array of property descriptors.
@@ -4092,7 +4216,9 @@ specification).
 
 #### napi_object_freeze
 <!-- YAML
-added: v12.20.0
+added:
+  - v14.14.0
+  - v12.20.0
 napiVersion: 8
 -->
 
@@ -4101,7 +4227,7 @@ napi_status napi_object_freeze(napi_env env,
                                napi_value object);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object to freeze.
 
 Returns `napi_ok` if the API succeeded.
@@ -4116,7 +4242,9 @@ ECMA-262 specification.
 
 #### napi_object_seal
 <!-- YAML
-added: v12.20.0
+added:
+  - v14.14.0
+  - v12.20.0
 napiVersion: 8
 -->
 
@@ -4125,7 +4253,7 @@ napi_status napi_object_seal(napi_env env,
                              napi_value object);
 ```
 
-* `[in] env`: The environment that the N-API call is invoked under.
+* `[in] env`: The environment that the Node-API call is invoked under.
 * `[in] object`: The object to seal.
 
 Returns `napi_ok` if the API succeeded.
@@ -4137,8 +4265,8 @@ of the ECMA-262 specification.
 
 ## Working with JavaScript functions
 
-N-API provides a set of APIs that allow JavaScript code to
-call back into native code. N-API APIs that support calling back
+Node-API provides a set of APIs that allow JavaScript code to
+call back into native code. Node-APIs that support calling back
 into native code take in a callback functions represented by
 the `napi_callback` type. When the JavaScript VM calls back to
 native code, the `napi_callback` function provided is invoked. The APIs
@@ -4149,7 +4277,7 @@ following:
 * Get the arguments passed into the callback.
 * Return a `napi_value` back from the callback.
 
-Additionally, N-API provides a set of functions which allow calling
+Additionally, Node-API provides a set of functions which allow calling
 JavaScript functions from native code. One can either call a function
 like a regular JavaScript function call, or as a constructor
 function.
@@ -4175,7 +4303,7 @@ NAPI_EXTERN napi_status napi_call_function(napi_env env,
 ```
 
 * `[in] env`: The environment that the API is invoked under.
-* `[in] recv`: The `this` object passed to the called function.
+* `[in] recv`: The `this` value passed to the called function.
 * `[in] func`: `napi_value` representing the JavaScript function to be invoked.
 * `[in] argc`: The count of elements in the `argv` array.
 * `[in] argv`: Array of `napi_values` representing JavaScript values passed in
@@ -4326,8 +4454,8 @@ napi_status napi_get_cb_info(napi_env env,
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] cbinfo`: The callback info passed into the callback function.
-* `[in-out] argc`: Specifies the size of the provided `argv` array and receives
-  the actual count of arguments.
+* `[in-out] argc`: Specifies the length of the provided `argv` array and
+  receives the actual count of arguments.
 * `[out] argv`: Buffer to which the `napi_value` representing the arguments are
   copied. If there are more arguments than the provided count, only the
   requested number of arguments are copied. If there are fewer arguments
@@ -4398,7 +4526,7 @@ const arg = 'hello';
 const value = new MyObject(arg);
 ```
 
-The following can be approximated in N-API using the following snippet:
+The following can be approximated in Node-API using the following snippet:
 
 ```c
 // Get the constructor function MyObject
@@ -4424,7 +4552,7 @@ Returns `napi_ok` if the API succeeded.
 
 ## Object wrap
 
-N-API offers a way to "wrap" C++ classes and instances so that the class
+Node-API offers a way to "wrap" C++ classes and instances so that the class
 constructor and methods can be called from JavaScript.
 
 1. The [`napi_define_class`][] API defines a JavaScript class with constructor,
@@ -4511,9 +4639,9 @@ case, the database handle instance can appear as a query handle instance, and it
 will pass the `napi_instanceof()` test for a query handle instance, while still
 containing a pointer to a database handle.
 
-To this end, N-API provides type-tagging capabilities.
+To this end, Node-API provides type-tagging capabilities.
 
-A type tag is a 128-bit integer unique to the addon. N-API provides the
+A type tag is a 128-bit integer unique to the addon. Node-API provides the
 `napi_type_tag` structure for storing a type tag. When such a value is passed
 along with a JavaScript object stored in a `napi_value` to
 `napi_type_tag_object()`, the JavaScript object will be "marked" with the
@@ -4614,14 +4742,15 @@ napi_status napi_define_class(napi_env env,
 ```
 
 * `[in] env`: The environment that the API is invoked under.
-* `[in] utf8name`: Name of the JavaScript constructor function; this is
-  not required to be the same as the C++ class name, though it is recommended
-  for clarity.
+* `[in] utf8name`: Name of the JavaScript constructor function; When wrapping a
+  C++ class, we recommend for clarity that this name be the same as that of
+  the C++ class.
 * `[in] length`: The length of the `utf8name` in bytes, or `NAPI_AUTO_LENGTH`
   if it is null-terminated.
 * `[in] constructor`: Callback function that handles constructing instances
-  of the class. This should be a static method on the class, not an actual
-  C++ constructor function. [`napi_callback`][] provides more details.
+  of the class. When wrapping a C++ class, this method must be a static member
+  with the [`napi_callback`][] signature. A C++ class constructor cannot be
+  used. [`napi_callback`][] provides more details.
 * `[in] data`: Optional data to be passed to the constructor callback as
   the `data` property of the callback info.
 * `[in] property_count`: Number of items in the `properties` array argument.
@@ -4633,27 +4762,33 @@ napi_status napi_define_class(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
-Defines a JavaScript class that corresponds to a C++ class, including:
-
-* A JavaScript constructor function that has the class name and invokes the
-  provided C++ constructor callback.
-* Properties on the constructor function corresponding to _static_ data
-  properties, accessors, and methods of the C++ class (defined by
-  property descriptors with the `napi_static` attribute).
-* Properties on the constructor function's `prototype` object corresponding to
-  _non-static_ data properties, accessors, and methods of the C++ class
-  (defined by property descriptors without the `napi_static` attribute).
-
-The C++ constructor callback should be a static method on the class that calls
-the actual class constructor, then wraps the new C++ instance in a JavaScript
-object, and returns the wrapper object. See `napi_wrap()` for details.
+Defines a JavaScript class, including:
+
+* A JavaScript constructor function that has the class name. When wrapping a
+  corresponding C++ class, the callback passed via `constructor` can be used to
+  instantiate a new C++ class instance, which can then be placed inside the
+  JavaScript object instance being constructed using [`napi_wrap`][].
+* Properties on the constructor function whose implementation can call
+  corresponding _static_ data properties, accessors, and methods of the C++
+  class (defined by property descriptors with the `napi_static` attribute).
+* Properties on the constructor function's `prototype` object. When wrapping a
+  C++ class, _non-static_ data properties, accessors, and methods of the C++
+  class can be called from the static functions given in the property
+  descriptors without the `napi_static` attribute after retrieving the C++ class
+  instance placed inside the JavaScript object instance by using
+  [`napi_unwrap`][].
+
+When wrapping a C++ class, the C++ constructor callback passed via `constructor`
+should be a static method on the class that calls the actual class constructor,
+then wraps the new C++ instance in a JavaScript object, and returns the wrapper
+object. See [`napi_wrap`][] for details.
 
 The JavaScript constructor function returned from [`napi_define_class`][] is
-often saved and used later, to construct new instances of the class from native
-code, and/or check whether provided values are instances of the class. In that
-case, to prevent the function value from being garbage-collected, create a
-persistent reference to it using [`napi_create_reference`][] and ensure the
-reference count is kept >= 1.
+often saved and used later to construct new instances of the class from native
+code, and/or to check whether provided values are instances of the class. In
+that case, to prevent the function value from being garbage-collected, a
+strong persistent reference to it can be created using
+[`napi_create_reference`][], ensuring that the reference count is kept >= 1.
 
 Any non-`NULL` data which is passed to this API via the `data` parameter or via
 the `data` field of the `napi_property_descriptor` array items can be associated
@@ -4771,7 +4906,9 @@ JavaScript object becomes garbage-collected.
 
 ### napi_type_tag_object
 <!-- YAML
-added: v12.19.0
+added:
+  - v14.8.0
+  - v12.19.0
 napiVersion: 8
 -->
 
@@ -4797,7 +4934,9 @@ If the object already has an associated type tag, this API will return
 
 ### napi_check_object_type_tag
 <!-- YAML
-added: v12.19.0
+added:
+  - v14.8.0
+  - v12.19.0
 napiVersion: 8
 -->
 
@@ -4812,7 +4951,7 @@ napi_status napi_check_object_type_tag(napi_env env,
 * `[in] js_object`: The JavaScript object whose type tag to examine.
 * `[in] type_tag`: The tag with which to compare any tag found on the object.
 * `[out] result`: Whether the type tag given matched the type tag on the
-object. `false` is also returned if no type tag was found on the object.
+  object. `false` is also returned if no type tag was found on the object.
 
 Returns `napi_ok` if the API succeeded.
 
@@ -4874,10 +5013,10 @@ implementation. This allows them to schedule work to be executed asynchronously
 so that their methods can return in advance of the work being completed. This
 allows them to avoid blocking overall execution of the Node.js application.
 
-N-API provides an ABI-stable interface for these
+Node-API provides an ABI-stable interface for these
 supporting functions which covers the most common asynchronous use cases.
 
-N-API defines the `napi_async_work` structure which is used to manage
+Node-API defines the `napi_async_work` structure which is used to manage
 asynchronous workers. Instances are created/deleted with
 [`napi_create_async_work`][] and [`napi_delete_async_work`][].
 
@@ -4885,9 +5024,9 @@ The `execute` and `complete` callbacks are functions that will be
 invoked when the executor is ready to execute and when it completes its
 task respectively.
 
-The `execute` function should avoid making any N-API calls
+The `execute` function should avoid making any Node-API calls
 that could result in the execution of JavaScript or interaction with
-JavaScript objects. Most often, any code that needs to make N-API
+JavaScript objects. Most often, any code that needs to make Node-API
 calls should be made in `complete` callback instead.
 Avoid using the `napi_env` parameter in the execute callback as
 it will likely execute JavaScript.
@@ -5059,19 +5198,31 @@ napi_status napi_async_init(napi_env env,
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] async_resource`: Object associated with the async work
-  that will be passed to possible `async_hooks` [`init` hooks][].
-  In order to retain ABI compatibility with previous versions,
-  passing `NULL` for `async_resource` will not result in an error, however,
-  this will result incorrect operation of async hooks for the
-  napi_async_context created. Potential issues include
-  loss of async context when using the AsyncLocalStorage API.
-* `[in] async_resource_name`: Identifier for the kind of resource
-  that is being provided for diagnostic information exposed by the
-  `async_hooks` API.
+  that will be passed to possible `async_hooks` [`init` hooks][] and can be
+  accessed by [`async_hooks.executionAsyncResource()`][].
+* `[in] async_resource_name`: Identifier for the kind of resource that is being
+  provided for diagnostic information exposed by the `async_hooks` API.
 * `[out] result`: The initialized async context.
 
 Returns `napi_ok` if the API succeeded.
 
+The `async_resource` object needs to be kept alive until
+[`napi_async_destroy`][] to keep `async_hooks` related API acts correctly. In
+order to retain ABI compatibility with previous versions, `napi_async_context`s
+are not maintaining the strong reference to the `async_resource` objects to
+avoid introducing causing memory leaks. However, if the `async_resource` is
+garbage collected by JavaScript engine before the `napi_async_context` was
+destroyed by `napi_async_destroy`, calling `napi_async_context` related APIs
+like [`napi_open_callback_scope`][] and [`napi_make_callback`][] can cause
+problems like loss of async context when using the `AsyncLocalStoage` API.
+
+In order to retain ABI compatibility with previous versions, passing `NULL`
+for `async_resource` does not result in an error. However, this is not
+recommended as this will result poor results with  `async_hooks`
+[`init` hooks][] and `async_hooks.executionAsyncResource()` as the resource is
+now required by the underlying `async_hooks` implementation in order to provide
+the linkage between async callbacks.
+
 ### napi_async_destroy
 <!-- YAML
 added: v8.6.0
@@ -5096,6 +5247,7 @@ added: v8.0.0
 napiVersion: 1
 changes:
   - version: v8.6.0
+    pr-url: https://github.com/nodejs/node/pull/15189
     description: Added `async_context` parameter.
 -->
 
@@ -5112,10 +5264,12 @@ NAPI_EXTERN napi_status napi_make_callback(napi_env env,
 * `[in] env`: The environment that the API is invoked under.
 * `[in] async_context`: Context for the async operation that is
    invoking the callback. This should normally be a value previously
-   obtained from [`napi_async_init`][]. However `NULL` is also allowed,
-   which indicates the current async context (if any) is to be used
-   for the callback.
-* `[in] recv`: The `this` object passed to the called function.
+   obtained from [`napi_async_init`][].
+   In order to retain ABI compatibility with previous versions, passing `NULL`
+   for `async_context` does not result in an error. However, this results
+   in incorrect operation of async hooks. Potential issues include loss of
+   async context when using the `AsyncLocalStorage` API.
+* `[in] recv`: The `this` value passed to the called function.
 * `[in] func`: `napi_value` representing the JavaScript function to be invoked.
 * `[in] argc`: The count of elements in the `argv` array.
 * `[in] argv`: Array of JavaScript values as `napi_value` representing the
@@ -5155,14 +5309,16 @@ NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,
 
 * `[in] env`: The environment that the API is invoked under.
 * `[in] resource_object`: An object associated with the async work
-  that will be passed to possible `async_hooks` [`init` hooks][].
+  that will be passed to possible `async_hooks` [`init` hooks][]. This
+  parameter has been deprecated and is ignored at runtime. Use the
+  `async_resource` parameter in [`napi_async_init`][] instead.
 * `[in] context`: Context for the async operation that is invoking the callback.
   This should be a value previously obtained from [`napi_async_init`][].
 * `[out] result`: The newly created scope.
 
 There are cases (for example, resolving promises) where it is
 necessary to have the equivalent of the scope associated with a callback
-in place when making certain N-API calls. If there is no other script on
+in place when making certain Node-API calls. If there is no other script on
 the stack the [`napi_open_callback_scope`][] and
 [`napi_close_callback_scope`][] functions can be used to open/close
 the required scope.
@@ -5226,12 +5382,12 @@ napi_status napi_get_version(napi_env env,
 ```
 
 * `[in] env`: The environment that the API is invoked under.
-* `[out] result`: The highest version of N-API supported.
+* `[out] result`: The highest version of Node-API supported.
 
 Returns `napi_ok` if the API succeeded.
 
-This API returns the highest N-API version supported by the
-Node.js runtime. N-API is planned to be additive such that
+This API returns the highest Node-API version supported by the
+Node.js runtime. Node-API is planned to be additive such that
 newer releases of Node.js may support additional API functions.
 In order to allow an addon to use a newer function when running with
 versions of Node.js that support it, while providing
@@ -5273,7 +5429,7 @@ often than it would otherwise.
 
 ## Promises
 
-N-API provides facilities for creating `Promise` objects as described in
+Node-API provides facilities for creating `Promise` objects as described in
 [Section 25.4][] of the ECMA specification. It implements promises as a pair of
 objects. When a promise is created by `napi_create_promise()`, a "deferred"
 object is created and returned alongside the `Promise`. The deferred object is
@@ -5418,7 +5574,7 @@ napi_status napi_is_promise(napi_env env,
 
 ## Script execution
 
-N-API provides an API for executing a string containing JavaScript using the
+Node-API provides an API for executing a string containing JavaScript using the
 underlying JavaScript engine.
 
 ### napi_run_script
@@ -5452,14 +5608,14 @@ the following caveats:
 
 ## libuv event loop
 
-N-API provides a function for getting the current event loop associated with
+Node-API provides a function for getting the current event loop associated with
 a specific `napi_env`.
 
 ### napi_get_uv_event_loop
 <!-- YAML
 added:
-  - v8.10.0
   - v9.3.0
+  - v8.10.0
 napiVersion: 2
 -->
 
@@ -5474,7 +5630,7 @@ NAPI_EXTERN napi_status napi_get_uv_event_loop(napi_env env,
 ## Asynchronous thread-safe function calls
 
 JavaScript functions can normally only be called from a native addon's main
-thread. If an addon creates additional threads, then N-API functions that
+thread. If an addon creates additional threads, then Node-API functions that
 require a `napi_env`, `napi_value`, or `napi_ref` must not be called from those
 threads.
 
@@ -5515,6 +5671,10 @@ preventing data from being successfully added to the queue. If set to
 `napi_call_threadsafe_function()` never blocks if the thread-safe function was
 created with a maximum queue size of 0.
 
+`napi_call_threadsafe_function()` should not be called with `napi_tsfn_blocking`
+from a JavaScript thread, because, if the queue is full, it may cause the
+JavaScript thread to deadlock.
+
 The actual call into JavaScript is controlled by the callback given via the
 `call_js_cb` parameter. `call_js_cb` is invoked on the main thread once for each
 value that was placed into the queue by a successful call to
@@ -5532,7 +5692,7 @@ remain in the queue that may need to be freed. This normally occurs when the
 Node.js process exits while there is a thread-safe function still active.
 
 It is not necessary to call into JavaScript via `napi_make_callback()` because
-N-API runs `call_js_cb` in a context appropriate for callbacks.
+Node-API runs `call_js_cb` in a context appropriate for callbacks.
 
 ### Reference counting of thread-safe functions
 
@@ -5597,7 +5757,9 @@ being destroyed.
 added: v10.6.0
 napiVersion: 4
 changes:
-  - version: v12.6.0
+  - version:
+     - v12.6.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/27791
     description: Made `func` parameter optional with custom `call_js_cb`.
 -->
@@ -5664,6 +5826,15 @@ This API may be called from any thread which makes use of `func`.
 <!-- YAML
 added: v10.6.0
 napiVersion: 4
+changes:
+  - version: v14.5.0
+    pr-url: https://github.com/nodejs/node/pull/33453
+    description: Support for `napi_would_deadlock` has been reverted.
+  - version: v14.1.0
+    pr-url: https://github.com/nodejs/node/pull/32689
+    description: Return `napi_would_deadlock` when called with
+                 `napi_tsfn_blocking` from the main thread or a worker thread
+                 and the queue is full.
 -->
 
 ```c
@@ -5681,6 +5852,10 @@ napi_call_threadsafe_function(napi_threadsafe_function func,
   `napi_tsfn_nonblocking` to indicate that the call should return immediately
   with a status of `napi_queue_full` whenever the queue is full.
 
+This API should not be called with `napi_tsfn_blocking` from a JavaScript
+thread, because, if the queue is full, it may cause the JavaScript thread to
+deadlock.
+
 This API will return `napi_closing` if `napi_release_threadsafe_function()` was
 called with `abort` set to `napi_tsfn_abort` from any thread. The value is only
 added to the queue if the API returns `napi_ok`.
@@ -5790,7 +5965,7 @@ This API may only be called from the main thread.
 ## node_api_get_module_file_name
 
 <!-- YAML
-added: v12.22.0
+added: v14.18.0
 -->
 
 > Stability: 1 - Experimental
@@ -5812,9 +5987,9 @@ the add-on's file name during loading.
 
 [ABI Stability]: https://nodejs.org/en/docs/guides/abi-stability/
 [AppVeyor]: https://www.appveyor.com
-[C++ Addons]: addons.html
-[CMake.js]: https://github.com/cmake-js/cmake-js
+[C++ Addons]: addons.md
 [CMake]: https://cmake.org
+[CMake.js]: https://github.com/cmake-js/cmake-js
 [ECMAScript Language Specification]: https://tc39.github.io/ecma262/
 [Error handling]: #n_api_error_handling
 [GCC]: https://gcc.gnu.org
@@ -5829,42 +6004,44 @@ the add-on's file name during loading.
 [Section 19.2]: https://tc39.github.io/ecma262/#sec-function-objects
 [Section 19.4]: https://tc39.github.io/ecma262/#sec-symbol-objects
 [Section 20.3]: https://tc39.github.io/ecma262/#sec-date-objects
-[Section 22.1.4.1]: https://tc39.github.io/ecma262/#sec-properties-of-array-instances-length
 [Section 22.1]: https://tc39.github.io/ecma262/#sec-array-objects
+[Section 22.1.4.1]: https://tc39.github.io/ecma262/#sec-properties-of-array-instances-length
 [Section 22.2]: https://tc39.github.io/ecma262/#sec-typedarray-objects
 [Section 24.1]: https://tc39.github.io/ecma262/#sec-arraybuffer-objects
+[Section 24.1.1.2]: https://tc39.es/ecma262/#sec-isdetachedbuffer
 [Section 24.1.1.3]: https://tc39.es/ecma262/#sec-detacharraybuffer
 [Section 24.3]: https://tc39.github.io/ecma262/#sec-dataview-objects
 [Section 25.4]: https://tc39.github.io/ecma262/#sec-promise-objects
+[Section 6]: https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values
+[Section 6.1]: https://tc39.github.io/ecma262/#sec-ecmascript-language-types
 [Section 6.1.4]: https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type
 [Section 6.1.6]: https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type
-[Section 6.1.7.1]: https://tc39.github.io/ecma262/#table-2
 [Section 6.1.7]: https://tc39.github.io/ecma262/#sec-object-type
-[Section 6.1]: https://tc39.github.io/ecma262/#sec-ecmascript-language-types
-[Section 6]: https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values
+[Section 6.1.7.1]: https://tc39.github.io/ecma262/#table-2
+[Section 7]: https://tc39.github.io/ecma262/#sec-abstract-operations
 [Section 7.1.13]: https://tc39.github.io/ecma262/#sec-toobject
 [Section 7.1.2]: https://tc39.github.io/ecma262/#sec-toboolean
 [Section 7.1.3]: https://tc39.github.io/ecma262/#sec-tonumber
 [Section 7.2.14]: https://tc39.github.io/ecma262/#sec-strict-equality-comparison
 [Section 7.2.2]: https://tc39.github.io/ecma262/#sec-isarray
-[Section 7]: https://tc39.github.io/ecma262/#sec-abstract-operations
 [Section 8.7]: https://tc39.es/ecma262/#sec-agents
 [Section 9.1.6]: https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc
-[Section 24.1.1.2]: https://tc39.es/ecma262/#sec-isdetachedbuffer
 [Travis CI]: https://travis-ci.org
 [Visual Studio]: https://visualstudio.microsoft.com
 [Working with JavaScript properties]: #n_api_working_with_javascript_properties
 [Xcode]: https://developer.apple.com/xcode/
 [`Number.MAX_SAFE_INTEGER`]: https://tc39.github.io/ecma262/#sec-number.max_safe_integer
 [`Number.MIN_SAFE_INTEGER`]: https://tc39.github.io/ecma262/#sec-number.min_safe_integer
-[`Worker`]: worker_threads.html#worker_threads_class_worker
-[`global`]: globals.html#globals_global
-[`init` hooks]: async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource
+[`Worker`]: worker_threads.md#worker_threads_class_worker
+[`async_hooks.executionAsyncResource()`]: async_hooks.md#async_hooks_async_hooks_executionasyncresource
+[`global`]: globals.md#globals_global
+[`init` hooks]: async_hooks.md#async_hooks_init_asyncid_type_triggerasyncid_resource
 [`napi_add_async_cleanup_hook`]: #n_api_napi_add_async_cleanup_hook
 [`napi_add_env_cleanup_hook`]: #n_api_napi_add_env_cleanup_hook
 [`napi_add_finalizer`]: #n_api_napi_add_finalizer
 [`napi_async_cleanup_hook`]: #n_api_napi_async_cleanup_hook
 [`napi_async_complete_callback`]: #n_api_napi_async_complete_callback
+[`napi_async_destroy`]: #n_api_napi_async_destroy
 [`napi_async_init`]: #n_api_napi_async_init
 [`napi_callback`]: #n_api_napi_callback
 [`napi_cancel_async_work`]: #n_api_napi_cancel_async_work
@@ -5914,15 +6091,16 @@ the add-on's file name during loading.
 [`napi_unwrap`]: #n_api_napi_unwrap
 [`napi_wrap`]: #n_api_napi_wrap
 [`node-addon-api`]: https://github.com/nodejs/node-addon-api
-[`node_api.h`]: https://github.com/nodejs/node/blob/master/src/node_api.h
-[`process.release`]: process.html#process_process_release
+[`node_api.h`]: https://github.com/nodejs/node/blob/HEAD/src/node_api.h
+[`process.release`]: process.md#process_process_release
 [`uv_ref`]: https://docs.libuv.org/en/v1.x/handle.html#c.uv_ref
 [`uv_unref`]: https://docs.libuv.org/en/v1.x/handle.html#c.uv_unref
-[async_hooks `type`]: async_hooks.html#async_hooks_type
-[context-aware addons]: addons.html#addons_context_aware_addons
+[async_hooks `type`]: async_hooks.md#async_hooks_type
+[context-aware addons]: addons.md#addons_context_aware_addons
 [docs]: https://github.com/nodejs/node-addon-api#api-documentation
-[global scope]: globals.html
-[module scope]: modules.html#modules_the_module_scope
+[global scope]: globals.md
+[gyp-next]: https://github.com/nodejs/gyp-next
+[module scope]: modules.md#modules_the_module_scope
 [node-gyp]: https://github.com/nodejs/node-gyp
 [node-pre-gyp]: https://github.com/mapbox/node-pre-gyp
 [prebuild]: https://github.com/prebuild/prebuild
diff --git a/doc/api/net.html b/doc/api/net.html
index 72255febf5a41adfedfca8b4bdcb0b9850c9a63b..cee3e68f8b93b2728b3407f1457fb22de0dd5bf8 100644
--- a/doc/api/net.html
+++ b/doc/api/net.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Net | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Net | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="net" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/net.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/net.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/net.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/net.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/net.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/net.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/net.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/net.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/net.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#net_net">Net</a></span>
 <ul>
 <li><a href="#net_ipc_support">IPC support</a>
@@ -134,6 +147,24 @@
 <li><a href="#net_identifying_paths_for_ipc_connections">Identifying paths for IPC connections</a></li>
 </ul>
 </li>
+<li><a href="#net_class_net_blocklist">Class: <code>net.BlockList</code></a>
+<ul>
+<li><a href="#net_blocklist_addaddress_address_type"><code>blockList.addAddress(address[, type])</code></a></li>
+<li><a href="#net_blocklist_addrange_start_end_type"><code>blockList.addRange(start, end[, type])</code></a></li>
+<li><a href="#net_blocklist_addsubnet_net_prefix_type"><code>blockList.addSubnet(net, prefix[, type])</code></a></li>
+<li><a href="#net_blocklist_check_address_type"><code>blockList.check(address[, type])</code></a></li>
+<li><a href="#net_blocklist_rules"><code>blockList.rules</code></a></li>
+</ul>
+</li>
+<li><a href="#net_class_net_socketaddress">Class: <code>net.SocketAddress</code></a>
+<ul>
+<li><a href="#net_new_net_socketaddress_options"><code>new net.SocketAddress([options])</code></a></li>
+<li><a href="#net_socketaddress_address"><code>socketaddress.address</code></a></li>
+<li><a href="#net_socketaddress_family"><code>socketaddress.family</code></a></li>
+<li><a href="#net_socketaddress_flowlabel"><code>socketaddress.flowlabel</code></a></li>
+<li><a href="#net_socketaddress_port"><code>socketaddress.port</code></a></li>
+</ul>
+</li>
 <li><a href="#net_class_net_server">Class: <code>net.Server</code></a>
 <ul>
 <li><a href="#net_new_net_server_options_connectionlistener"><code>new net.Server([options][, connectionListener])</code></a></li>
@@ -172,7 +203,7 @@
 <li><a href="#net_event_ready">Event: <code>'ready'</code></a></li>
 <li><a href="#net_event_timeout">Event: <code>'timeout'</code></a></li>
 <li><a href="#net_socket_address"><code>socket.address()</code></a></li>
-<li><a href="#net_socket_buffersize"><code>socket.bufferSize</code></a></li>
+<li><span class="stability_0"><a href="#net_socket_buffersize"><code>socket.bufferSize</code></a></span></li>
 <li><a href="#net_socket_bytesread"><code>socket.bytesRead</code></a></li>
 <li><a href="#net_socket_byteswritten"><code>socket.bytesWritten</code></a></li>
 <li><a href="#net_socket_connect"><code>socket.connect()</code></a>
@@ -199,8 +230,10 @@
 <li><a href="#net_socket_setkeepalive_enable_initialdelay"><code>socket.setKeepAlive([enable][, initialDelay])</code></a></li>
 <li><a href="#net_socket_setnodelay_nodelay"><code>socket.setNoDelay([noDelay])</code></a></li>
 <li><a href="#net_socket_settimeout_timeout_callback"><code>socket.setTimeout(timeout[, callback])</code></a></li>
+<li><a href="#net_socket_timeout"><code>socket.timeout</code></a></li>
 <li><a href="#net_socket_unref"><code>socket.unref()</code></a></li>
 <li><a href="#net_socket_write_data_encoding_callback"><code>socket.write(data[, encoding][, callback])</code></a></li>
+<li><a href="#net_socket_readystate"><code>socket.readyState</code></a></li>
 </ul>
 </li>
 <li><a href="#net_net_connect"><code>net.connect()</code></a>
@@ -223,24 +256,23 @@
 <li><a href="#net_net_isipv6_input"><code>net.isIPv6(input)</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Net<span><a class="mark" href="#net_net" id="net_net">#</a></span></h1>
+        <h2>Net<span><a class="mark" href="#net_net" id="net_net">#</a></span></h2>
 
 <!--lint disable maximum-line-length-->
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/net.js">lib/net.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/net.js">lib/net.js</a></p>
 <p>The <code>net</code> module provides an asynchronous network API for creating stream-based
 TCP or <a href="#net_ipc_support">IPC</a> servers (<a href="#net_net_createserver_options_connectionlistener"><code>net.createServer()</code></a>) and clients
 (<a href="#net_net_createconnection"><code>net.createConnection()</code></a>).</p>
 <p>It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);</code></pre>
-<h2>IPC support<span><a class="mark" href="#net_ipc_support" id="net_ipc_support">#</a></span></h2>
+<section><h3>IPC support<span><a class="mark" href="#net_ipc_support" id="net_ipc_support">#</a></span></h3>
 <p>The <code>net</code> module supports IPC with named pipes on Windows, and Unix domain
 sockets on other operating systems.</p>
-<h3>Identifying paths for IPC connections<span><a class="mark" href="#net_identifying_paths_for_ipc_connections" id="net_identifying_paths_for_ipc_connections">#</a></span></h3>
+<h4>Identifying paths for IPC connections<span><a class="mark" href="#net_identifying_paths_for_ipc_connections" id="net_identifying_paths_for_ipc_connections">#</a></span></h4>
 <p><a href="#net_net_connect"><code>net.connect()</code></a>, <a href="#net_net_createconnection"><code>net.createConnection()</code></a>, <a href="#net_server_listen"><code>server.listen()</code></a> and
 <a href="#net_socket_connect"><code>socket.connect()</code></a> take a <code>path</code> parameter to identify IPC endpoints.</p>
 <p>On Unix, the local domain is also known as the Unix domain. The path is a
@@ -263,9 +295,128 @@ Unlike Unix domain sockets, Windows will close and remove the pipe when the
 owning process exits.</p>
 <p>JavaScript string escaping requires paths to be specified with extra backslash
 escaping such as:</p>
-<pre><code class="language-js">net.createServer().listen(
-  path.join(<span class="hljs-string">'\\\\?\\pipe'</span>, process.cwd(), <span class="hljs-string">'myctl'</span>));</code></pre>
-<h2>Class: <code>net.Server</code><span><a class="mark" href="#net_class_net_server" id="net_class_net_server">#</a></span></h2>
+<pre><code class="language-js">net.<span class="hljs-title function_">createServer</span>().<span class="hljs-title function_">listen</span>(
+  path.<span class="hljs-title function_">join</span>(<span class="hljs-string">'\\\\?\\pipe'</span>, process.<span class="hljs-title function_">cwd</span>(), <span class="hljs-string">'myctl'</span>));</code></pre>
+</section><section><h3>Class: <code>net.BlockList</code><span><a class="mark" href="#net_class_net_blocklist" id="net_class_net_blocklist">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>The <code>BlockList</code> object can be used with some network APIs to specify rules for
+disabling inbound or outbound access to specific IP addresses, IP ranges, or
+IP subnets.</p>
+<h4><code>blockList.addAddress(address[, type])</code><span><a class="mark" href="#net_blocklist_addaddress_address_type" id="net_blocklist_addaddress_address_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>address</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="net.html#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> An IPv4 or IPv6 address.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>. <strong>Default:</strong> <code>'ipv4'</code>.</li>
+</ul>
+<p>Adds a rule to block the given IP address.</p>
+<h4><code>blockList.addRange(start, end[, type])</code><span><a class="mark" href="#net_blocklist_addrange_start_end_type" id="net_blocklist_addrange_start_end_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>start</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="net.html#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> The starting IPv4 or IPv6 address in the
+range.</li>
+<li><code>end</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="net.html#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> The ending IPv4 or IPv6 address in the range.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>. <strong>Default:</strong> <code>'ipv4'</code>.</li>
+</ul>
+<p>Adds a rule to block a range of IP addresses from <code>start</code> (inclusive) to
+<code>end</code> (inclusive).</p>
+<h4><code>blockList.addSubnet(net, prefix[, type])</code><span><a class="mark" href="#net_blocklist_addsubnet_net_prefix_type" id="net_blocklist_addsubnet_net_prefix_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>net</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="net.html#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> The network IPv4 or IPv6 address.</li>
+<li><code>prefix</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of CIDR prefix bits. For IPv4, this
+must be a value between <code>0</code> and <code>32</code>. For IPv6, this must be between
+<code>0</code> and <code>128</code>.</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>. <strong>Default</strong>: <code>'ipv4'</code>.</li>
+</ul>
+<p>Adds a rule to block a range of IP addresses specified as a subnet mask.</p>
+<h4><code>blockList.check(address[, type])</code><span><a class="mark" href="#net_blocklist_check_address_type" id="net_blocklist_check_address_type">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>address</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="net.html#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a> The IP address to check</li>
+<li><code>type</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>. <strong>Default:</strong> <code>'ipv4'</code>.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Returns <code>true</code> if the given IP address matches any of the rules added to the
+<code>BlockList</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> blockList = <span class="hljs-keyword">new</span> net.<span class="hljs-title class_">BlockList</span>();
+blockList.<span class="hljs-title function_">addAddress</span>(<span class="hljs-string">'123.123.123.123'</span>);
+blockList.<span class="hljs-title function_">addRange</span>(<span class="hljs-string">'10.0.0.1'</span>, <span class="hljs-string">'10.0.0.10'</span>);
+blockList.<span class="hljs-title function_">addSubnet</span>(<span class="hljs-string">'8592:757c:efae:4e45::'</span>, <span class="hljs-number">64</span>, <span class="hljs-string">'ipv6'</span>);
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'123.123.123.123'</span>));  <span class="hljs-comment">// Prints: true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'10.0.0.3'</span>));  <span class="hljs-comment">// Prints: true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'222.111.111.222'</span>));  <span class="hljs-comment">// Prints: false</span>
+
+<span class="hljs-comment">// IPv6 notation for IPv4 addresses works:</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'::ffff:7b7b:7b7b'</span>, <span class="hljs-string">'ipv6'</span>)); <span class="hljs-comment">// Prints: true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(blockList.<span class="hljs-title function_">check</span>(<span class="hljs-string">'::ffff:123.123.123.123'</span>, <span class="hljs-string">'ipv6'</span>)); <span class="hljs-comment">// Prints: true</span></code></pre>
+<h4><code>blockList.rules</code><span><a class="mark" href="#net_blocklist_rules" id="net_blocklist_rules">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>The list of rules added to the blocklist.</p>
+</section><section><h3>Class: <code>net.SocketAddress</code><span><a class="mark" href="#net_class_net_socketaddress" id="net_class_net_socketaddress">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<h4><code>new net.SocketAddress([options])</code><span><a class="mark" href="#net_new_net_socketaddress_options" id="net_new_net_socketaddress_options">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>address</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The network address as either an IPv4 or IPv6 string.
+<strong>Default</strong>: <code>'127.0.0.1'</code> if <code>family</code> is <code>'ipv4'</code>; <code>'::'</code> if <code>family</code> is
+<code>'ipv6'</code>.</li>
+<li><code>family</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> One of either <code>'ipv4'</code> or 'ipv6'<code>. **Default**: </code>'ipv4'`.</li>
+<li><code>flowlabel</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> An IPv6 flow-label used only if <code>family</code> is <code>'ipv6'</code>.</li>
+<li><code>port</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> An IP port.</li>
+</ul>
+</li>
+</ul>
+<h4><code>socketaddress.address</code><span><a class="mark" href="#net_socketaddress_address" id="net_socketaddress_address">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<h4><code>socketaddress.family</code><span><a class="mark" href="#net_socketaddress_family" id="net_socketaddress_family">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'ipv4'</code> or <code>'ipv6'</code>.</li>
+</ul>
+<h4><code>socketaddress.flowlabel</code><span><a class="mark" href="#net_socketaddress_flowlabel" id="net_socketaddress_flowlabel">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<h4><code>socketaddress.port</code><span><a class="mark" href="#net_socketaddress_port" id="net_socketaddress_port">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Type <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+</section><section><h3>Class: <code>net.Server</code><span><a class="mark" href="#net_class_net_server" id="net_class_net_server">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -273,7 +424,7 @@ escaping such as:</p>
 <li>Extends: <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
 </ul>
 <p>This class is used to create a TCP or <a href="#net_ipc_support">IPC</a> server.</p>
-<h3><code>new net.Server([options][, connectionListener])</code><span><a class="mark" href="#net_new_net_server_options_connectionlistener" id="net_new_net_server_options_connectionlistener">#</a></span></h3>
+<h4><code>new net.Server([options][, connectionListener])</code><span><a class="mark" href="#net_new_net_server_options_connectionlistener" id="net_new_net_server_options_connectionlistener">#</a></span></h4>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> See
 <a href="#net_net_createserver_options_connectionlistener"><code>net.createServer([options][, connectionListener])</code></a>.</li>
@@ -282,13 +433,13 @@ escaping such as:</p>
 <li>Returns: <a href="net.html#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
 <p><code>net.Server</code> is an <a href="events.html#events_class_eventemitter"><code>EventEmitter</code></a> with the following events:</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#net_event_close" id="net_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#net_event_close" id="net_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
 <p>Emitted when the server closes. If connections exist, this
 event is not emitted until all connections are ended.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#net_event_connection" id="net_event_connection">#</a></span></h3>
+<h4>Event: <code>'connection'</code><span><a class="mark" href="#net_event_connection" id="net_event_connection">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -297,7 +448,7 @@ event is not emitted until all connections are ended.</p>
 </ul>
 <p>Emitted when a new connection is made. <code>socket</code> is an instance of
 <code>net.Socket</code>.</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#net_event_error" id="net_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#net_event_error" id="net_event_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -308,12 +459,12 @@ event is not emitted until all connections are ended.</p>
 event will <strong>not</strong> be emitted directly following this event unless
 <a href="#net_server_close_callback"><code>server.close()</code></a> is manually called. See the example in discussion of
 <a href="#net_server_listen"><code>server.listen()</code></a>.</p>
-<h3>Event: <code>'listening'</code><span><a class="mark" href="#net_event_listening" id="net_event_listening">#</a></span></h3>
+<h4>Event: <code>'listening'</code><span><a class="mark" href="#net_event_listening" id="net_event_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <p>Emitted when the server has been bound after calling <a href="#net_server_listen"><code>server.listen()</code></a>.</p>
-<h3><code>server.address()</code><span><a class="mark" href="#net_server_address" id="net_server_address">#</a></span></h3>
+<h4><code>server.address()</code><span><a class="mark" href="#net_server_address" id="net_server_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -326,20 +477,20 @@ as reported by the operating system if listening on an IP socket
 <code>{ port: 12346, family: 'IPv4', address: '127.0.0.1' }</code>.</p>
 <p>For a server listening on a pipe or Unix domain socket, the name is returned
 as a string.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  socket.end(<span class="hljs-string">'goodbye\n'</span>);
-}).on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<pre><code class="language-js"><span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'goodbye\n'</span>);
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-comment">// Handle errors here.</span>
   <span class="hljs-keyword">throw</span> err;
 });
 
 <span class="hljs-comment">// Grab an arbitrary unused port.</span>
-server.listen(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'opened server on'</span>, server.address());
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'opened server on'</span>, server.<span class="hljs-title function_">address</span>());
 });</code></pre>
 <p><code>server.address()</code> returns <code>null</code> before the <code>'listening'</code> event has been
 emitted or after calling <code>server.close()</code>.</p>
-<h3><code>server.close([callback])</code><span><a class="mark" href="#net_server_close_callback" id="net_server_close_callback">#</a></span></h3>
+<h4><code>server.close([callback])</code><span><a class="mark" href="#net_server_close_callback" id="net_server_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -353,7 +504,7 @@ when all connections are ended and the server emits a <a href="#net_event_close"
 The optional <code>callback</code> will be called once the <code>'close'</code> event occurs. Unlike
 that event, it will be called with an <code>Error</code> as its only argument if the server
 was not open when it was closed.</p>
-<h3><code>server.connections</code><span><a class="mark" href="#net_server_connections" id="net_server_connections">#</a></span></h3>
+<h4><code>server.connections</code><span><a class="mark" href="#net_server_connections" id="net_server_connections">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.2.0</span><span>Deprecated since: v0.9.7</span>
 </div>
@@ -365,7 +516,7 @@ was not open when it was closed.</p>
 <p>This becomes <code>null</code> when sending a socket to a child with
 <a href="child_process.html#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>. To poll forks and get current number of active
 connections, use asynchronous <a href="#net_server_getconnections_callback"><code>server.getConnections()</code></a> instead.</p>
-<h3><code>server.getConnections(callback)</code><span><a class="mark" href="#net_server_getconnections_callback" id="net_server_getconnections_callback">#</a></span></h3>
+<h4><code>server.getConnections(callback)</code><span><a class="mark" href="#net_server_getconnections_callback" id="net_server_getconnections_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.7</span>
 </div>
@@ -376,10 +527,11 @@ connections, use asynchronous <a href="#net_server_getconnections_callback"><cod
 <p>Asynchronously get the number of concurrent connections on the server. Works
 when sockets were sent to forks.</p>
 <p>Callback should take two arguments <code>err</code> and <code>count</code>.</p>
-<h3><code>server.listen()</code><span><a class="mark" href="#net_server_listen" id="net_server_listen">#</a></span></h3>
+<h4><code>server.listen()</code><span><a class="mark" href="#net_server_listen" id="net_server_listen">#</a></span></h4>
 <p>Start a server listening for connections. A <code>net.Server</code> can be a TCP or
 an <a href="#net_ipc_support">IPC</a> server depending on what it listens to.</p>
 <p>Possible signatures:</p>
+<!--lint disable no-undefined-references-->
 <ul>
 <li><a href="#net_server_listen_handle_backlog_callback"><code>server.listen(handle[, backlog][, callback])</code></a></li>
 <li><a href="#net_server_listen_options_callback"><code>server.listen(options[, callback])</code></a></li>
@@ -391,6 +543,7 @@ for <a href="#net_ipc_support">IPC</a> servers</li>
 for TCP servers
 </li>
 </ul>
+<!--lint enable no-undefined-references-->
 <p>This function is asynchronous. When the server starts listening, the
 <a href="#net_event_listening"><code>'listening'</code></a> event will be emitted. The last parameter <code>callback</code>
 will be added as a listener for the <a href="#net_event_listening"><code>'listening'</code></a> event.</p>
@@ -407,16 +560,16 @@ called. Otherwise, an <code>ERR_SERVER_ALREADY_LISTEN</code> error will be throw
 This happens when another server is already listening on the requested
 <code>port</code>/<code>path</code>/<code>handle</code>. One way to handle this would be to retry
 after a certain amount of time:</p>
-<pre><code class="language-js">server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
-  <span class="hljs-keyword">if</span> (e.code === <span class="hljs-string">'EADDRINUSE'</span>) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Address in use, retrying...'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">e</span>) =></span> {
+  <span class="hljs-keyword">if</span> (e.<span class="hljs-property">code</span> === <span class="hljs-string">'EADDRINUSE'</span>) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Address in use, retrying...'</span>);
     <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-      server.close();
-      server.listen(PORT, HOST);
+      server.<span class="hljs-title function_">close</span>();
+      server.<span class="hljs-title function_">listen</span>(<span class="hljs-variable constant_">PORT</span>, <span class="hljs-variable constant_">HOST</span>);
     }, <span class="hljs-number">1000</span>);
   }
 });</code></pre>
-<h4><code>server.listen(handle[, backlog][, callback])</code><span><a class="mark" href="#net_server_listen_handle_backlog_callback" id="net_server_listen_handle_backlog_callback">#</a></span></h4>
+<h5><code>server.listen(handle[, backlog][, callback])</code><span><a class="mark" href="#net_server_listen_handle_backlog_callback" id="net_server_listen_handle_backlog_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -432,7 +585,7 @@ already been bound to a port, a Unix domain socket, or a Windows named pipe.</p>
 underlying <code>_handle</code> member), or an object with an <code>fd</code> member that is a
 valid file descriptor.</p>
 <p>Listening on a file descriptor is not supported on Windows.</p>
-<h4><code>server.listen(options[, callback])</code><span><a class="mark" href="#net_server_listen_options_callback" id="net_server_listen_options_callback">#</a></span></h4>
+<h5><code>server.listen(options[, callback])</code><span><a class="mark" href="#net_server_listen_options_callback" id="net_server_listen_options_callback">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -467,18 +620,20 @@ disable dual-stack support, i.e., binding to host <code>::</code> won't make
 functions.</li>
 <li>Returns: <a href="net.html#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
+<!--lint disable no-undefined-references-->
 <p>If <code>port</code> is specified, it behaves the same as
 <a href="#net_server_listen_port_host_backlog_callback">
 <code>server.listen([port[, host[, backlog]]][, callback])</code></a>.
 Otherwise, if <code>path</code> is specified, it behaves the same as
 <a href="#net_server_listen_path_backlog_callback"><code>server.listen(path[, backlog][, callback])</code></a>.
 If none of them is specified, an error will be thrown.</p>
+<!--lint enable no-undefined-references-->
 <p>If <code>exclusive</code> is <code>false</code> (default), then cluster workers will use the same
 underlying handle, allowing connection handling duties to be shared. When
 <code>exclusive</code> is <code>true</code>, the handle is not shared, and attempted port sharing
 results in an error. An example which listens on an exclusive port is
 shown below.</p>
-<pre><code class="language-js">server.listen({
+<pre><code class="language-js">server.<span class="hljs-title function_">listen</span>({
   <span class="hljs-attr">host</span>: <span class="hljs-string">'localhost'</span>,
   <span class="hljs-attr">port</span>: <span class="hljs-number">80</span>,
   <span class="hljs-attr">exclusive</span>: <span class="hljs-literal">true</span>
@@ -486,7 +641,7 @@ shown below.</p>
 <p>Starting an IPC server as root may cause the server path to be inaccessible for
 unprivileged users. Using <code>readableAll</code> and <code>writableAll</code> will make the server
 accessible for all users.</p>
-<h4><code>server.listen(path[, backlog][, callback])</code><span><a class="mark" href="#net_server_listen_path_backlog_callback" id="net_server_listen_path_backlog_callback">#</a></span></h4>
+<h5><code>server.listen(path[, backlog][, callback])</code><span><a class="mark" href="#net_server_listen_path_backlog_callback" id="net_server_listen_path_backlog_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -498,7 +653,7 @@ accessible for all users.</p>
 <li>Returns: <a href="net.html#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
 <p>Start an <a href="#net_ipc_support">IPC</a> server listening for connections on the given <code>path</code>.</p>
-<h4><code>server.listen([port[, host[, backlog]]][, callback])</code><span><a class="mark" href="#net_server_listen_port_host_backlog_callback" id="net_server_listen_port_host_backlog_callback">#</a></span></h4>
+<h5><code>server.listen([port[, host[, backlog]]][, callback])</code><span><a class="mark" href="#net_server_listen_port_host_backlog_callback" id="net_server_listen_port_host_backlog_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -519,14 +674,14 @@ after the <a href="#net_event_listening"><code>'listening'</code></a> event has
 <p>In most operating systems, listening to the <a href="https://en.wikipedia.org/wiki/IPv6_address#Unspecified_address">unspecified IPv6 address</a> (<code>::</code>)
 may cause the <code>net.Server</code> to also listen on the <a href="https://en.wikipedia.org/wiki/0.0.0.0">unspecified IPv4 address</a>
 (<code>0.0.0.0</code>).</p>
-<h3><code>server.listening</code><span><a class="mark" href="#net_server_listening" id="net_server_listening">#</a></span></h3>
+<h4><code>server.listening</code><span><a class="mark" href="#net_server_listening" id="net_server_listening">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.7.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether or not the server is listening for connections.</li>
 </ul>
-<h3><code>server.maxConnections</code><span><a class="mark" href="#net_server_maxconnections" id="net_server_maxconnections">#</a></span></h3>
+<h4><code>server.maxConnections</code><span><a class="mark" href="#net_server_maxconnections" id="net_server_maxconnections">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.2.0</span>
 </div>
@@ -537,7 +692,7 @@ may cause the <code>net.Server</code> to also listen on the <a href="https://en.
 high.</p>
 <p>It is not recommended to use this option once a socket has been sent to a child
 with <a href="child_process.html#child_process_child_process_fork_modulepath_args_options"><code>child_process.fork()</code></a>.</p>
-<h3><code>server.ref()</code><span><a class="mark" href="#net_server_ref" id="net_server_ref">#</a></span></h3>
+<h4><code>server.ref()</code><span><a class="mark" href="#net_server_ref" id="net_server_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -547,7 +702,7 @@ with <a href="child_process.html#child_process_child_process_fork_modulepath_arg
 <p>Opposite of <code>unref()</code>, calling <code>ref()</code> on a previously <code>unref</code>ed server will
 <em>not</em> let the program exit if it's the only server left (the default behavior).
 If the server is <code>ref</code>ed calling <code>ref()</code> again will have no effect.</p>
-<h3><code>server.unref()</code><span><a class="mark" href="#net_server_unref" id="net_server_unref">#</a></span></h3>
+<h4><code>server.unref()</code><span><a class="mark" href="#net_server_unref" id="net_server_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -557,7 +712,7 @@ If the server is <code>ref</code>ed calling <code>ref()</code> again will have n
 <p>Calling <code>unref()</code> on a server will allow the program to exit if this is the only
 active server in the event system. If the server is already <code>unref</code>ed calling
 <code>unref()</code> again will have no effect.</p>
-<h2>Class: <code>net.Socket</code><span><a class="mark" href="#net_class_net_socket" id="net_class_net_socket">#</a></span></h2>
+</section><section><h3>Class: <code>net.Socket</code><span><a class="mark" href="#net_class_net_socket" id="net_class_net_socket">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -574,7 +729,7 @@ so the user can use it to talk to the server.</p>
 is received. For example, it is passed to the listeners of a
 <a href="#net_event_connection"><code>'connection'</code></a> event emitted on a <a href="#net_class_net_server"><code>net.Server</code></a>, so the user can use
 it to interact with the client.</p>
-<h3><code>new net.Socket([options])</code><span><a class="mark" href="#net_new_net_socket_options" id="net_new_net_socket_options">#</a></span></h3>
+<h4><code>new net.Socket([options])</code><span><a class="mark" href="#net_new_net_socket_options" id="net_new_net_socket_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -583,9 +738,10 @@ it to interact with the client.</p>
 <ul>
 <li><code>fd</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> If specified, wrap around an existing socket with
 the given file descriptor, otherwise a new socket will be created.</li>
-<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether half-opened TCP connections
-are allowed. See <a href="#net_net_createserver_options_connectionlistener"><code>net.createServer()</code></a> and the <a href="#net_event_end"><code>'end'</code></a> event
-for details. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If set to <code>false</code>, then the socket will
+automatically end the writable side when the readable side ends. See
+<a href="#net_net_createserver_options_connectionlistener"><code>net.createServer()</code></a> and the <a href="#net_event_end"><code>'end'</code></a> event for details. <strong>Default:</strong>
+<code>false</code>.</li>
 <li><code>readable</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Allow reads on the socket when an <code>fd</code> is passed,
 otherwise ignored. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>writable</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Allow writes on the socket when an <code>fd</code> is passed,
@@ -597,7 +753,7 @@ otherwise ignored. <strong>Default:</strong> <code>false</code>.</li>
 <p>Creates a new socket object.</p>
 <p>The newly created socket can be either a TCP socket or a streaming <a href="#net_ipc_support">IPC</a>
 endpoint, depending on what it <a href="#net_socket_connect"><code>connect()</code></a> to.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#net_event_close_1" id="net_event_close_1">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#net_event_close_1" id="net_event_close_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -606,13 +762,13 @@ endpoint, depending on what it <a href="#net_socket_connect"><code>connect()</co
 </ul>
 <p>Emitted once the socket is fully closed. The argument <code>hadError</code> is a boolean
 which says if the socket was closed due to a transmission error.</p>
-<h3>Event: <code>'connect'</code><span><a class="mark" href="#net_event_connect" id="net_event_connect">#</a></span></h3>
+<h4>Event: <code>'connect'</code><span><a class="mark" href="#net_event_connect" id="net_event_connect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <p>Emitted when a socket connection is successfully established.
 See <a href="#net_net_createconnection"><code>net.createConnection()</code></a>.</p>
-<h3>Event: <code>'data'</code><span><a class="mark" href="#net_event_data" id="net_event_data">#</a></span></h3>
+<h4>Event: <code>'data'</code><span><a class="mark" href="#net_event_data" id="net_event_data">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -623,26 +779,26 @@ See <a href="#net_net_createconnection"><code>net.createConnection()</code></a>.
 <code>String</code>. Encoding of data is set by <a href="#net_socket_setencoding_encoding"><code>socket.setEncoding()</code></a>.</p>
 <p>The data will be lost if there is no listener when a <code>Socket</code>
 emits a <code>'data'</code> event.</p>
-<h3>Event: <code>'drain'</code><span><a class="mark" href="#net_event_drain" id="net_event_drain">#</a></span></h3>
+<h4>Event: <code>'drain'</code><span><a class="mark" href="#net_event_drain" id="net_event_drain">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <p>Emitted when the write buffer becomes empty. Can be used to throttle uploads.</p>
 <p>See also: the return values of <code>socket.write()</code>.</p>
-<h3>Event: <code>'end'</code><span><a class="mark" href="#net_event_end" id="net_event_end">#</a></span></h3>
+<h4>Event: <code>'end'</code><span><a class="mark" href="#net_event_end" id="net_event_end">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
-<p>Emitted when the other end of the socket sends a FIN packet, thus ending the
-readable side of the socket.</p>
-<p>By default (<code>allowHalfOpen</code> is <code>false</code>) the socket will send a FIN packet
-back and destroy its file descriptor once it has written out its pending
-write queue. However, if <code>allowHalfOpen</code> is set to <code>true</code>, the socket will
-not automatically <a href="#net_socket_end_data_encoding_callback"><code>end()</code></a> its writable side, allowing the
-user to write arbitrary amounts of data. The user must call
+<p>Emitted when the other end of the socket signals the end of transmission, thus
+ending the readable side of the socket.</p>
+<p>By default (<code>allowHalfOpen</code> is <code>false</code>) the socket will send an end of
+transmission packet back and destroy its file descriptor once it has written out
+its pending write queue. However, if <code>allowHalfOpen</code> is set to <code>true</code>, the
+socket will not automatically <a href="#net_socket_end_data_encoding_callback"><code>end()</code></a> its writable side,
+allowing the user to write arbitrary amounts of data. The user must call
 <a href="#net_socket_end_data_encoding_callback"><code>end()</code></a> explicitly to close the connection (i.e. sending a
 FIN packet back).</p>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#net_event_error_1" id="net_event_error_1">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#net_event_error_1" id="net_event_error_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -651,7 +807,7 @@ FIN packet back).</p>
 </ul>
 <p>Emitted when an error occurs. The <code>'close'</code> event will be called directly
 following this event.</p>
-<h3>Event: <code>'lookup'</code><span><a class="mark" href="#net_event_lookup" id="net_event_lookup">#</a></span></h3>
+<h4>Event: <code>'lookup'</code><span><a class="mark" href="#net_event_lookup" id="net_event_lookup">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -671,20 +827,20 @@ Not applicable to Unix sockets.</p>
 <li><code>family</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> The address type. See <a href="dns.html#dns_dns_lookup_hostname_options_callback"><code>dns.lookup()</code></a>.</li>
 <li><code>host</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The host name.</li>
 </ul>
-<h3>Event: <code>'ready'</code><span><a class="mark" href="#net_event_ready" id="net_event_ready">#</a></span></h3>
+<h4>Event: <code>'ready'</code><span><a class="mark" href="#net_event_ready" id="net_event_ready">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.11.0</span>
 </div>
 <p>Emitted when a socket is ready to be used.</p>
 <p>Triggered immediately after <code>'connect'</code>.</p>
-<h3>Event: <code>'timeout'</code><span><a class="mark" href="#net_event_timeout" id="net_event_timeout">#</a></span></h3>
+<h4>Event: <code>'timeout'</code><span><a class="mark" href="#net_event_timeout" id="net_event_timeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
 <p>Emitted if the socket times out from inactivity. This is only to notify that
 the socket has been idle. The user must manually close the connection.</p>
 <p>See also: <a href="#net_socket_settimeout_timeout_callback"><code>socket.setTimeout()</code></a>.</p>
-<h3><code>socket.address()</code><span><a class="mark" href="#net_socket_address" id="net_socket_address">#</a></span></h3>
+<h4><code>socket.address()</code><span><a class="mark" href="#net_socket_address" id="net_socket_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -694,10 +850,11 @@ the socket has been idle. The user must manually close the connection.</p>
 <p>Returns the bound <code>address</code>, the address <code>family</code> name and <code>port</code> of the
 socket as reported by the operating system:
 <code>{ port: 12346, family: 'IPv4', address: '127.0.0.1' }</code></p>
-<h3><code>socket.bufferSize</code><span><a class="mark" href="#net_socket_buffersize" id="net_socket_buffersize">#</a></span></h3>
+<h4><code>socket.bufferSize</code><span><a class="mark" href="#net_socket_buffersize" id="net_socket_buffersize">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.3.8</span>
+<span>Added in: v0.3.8</span><span>Deprecated since: v14.6.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="stream.html#stream_writable_writablelength"><code>writable.writableLength</code></a> instead.</div><p></p>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
@@ -713,7 +870,7 @@ socket and send it out over the wire when it is possible.</p>
 Users who experience large or growing <code>bufferSize</code> should attempt to
 "throttle" the data flows in their program with
 <a href="#net_socket_pause"><code>socket.pause()</code></a> and <a href="#net_socket_resume"><code>socket.resume()</code></a>.</p>
-<h3><code>socket.bytesRead</code><span><a class="mark" href="#net_socket_bytesread" id="net_socket_bytesread">#</a></span></h3>
+<h4><code>socket.bytesRead</code><span><a class="mark" href="#net_socket_bytesread" id="net_socket_bytesread">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.3</span>
 </div>
@@ -721,7 +878,7 @@ Users who experience large or growing <code>bufferSize</code> should attempt to
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The amount of received bytes.</p>
-<h3><code>socket.bytesWritten</code><span><a class="mark" href="#net_socket_byteswritten" id="net_socket_byteswritten">#</a></span></h3>
+<h4><code>socket.bytesWritten</code><span><a class="mark" href="#net_socket_byteswritten" id="net_socket_byteswritten">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.3</span>
 </div>
@@ -729,7 +886,7 @@ Users who experience large or growing <code>bufferSize</code> should attempt to
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The amount of bytes sent.</p>
-<h3><code>socket.connect()</code><span><a class="mark" href="#net_socket_connect" id="net_socket_connect">#</a></span></h3>
+<h4><code>socket.connect()</code><span><a class="mark" href="#net_socket_connect" id="net_socket_connect">#</a></span></h4>
 <p>Initiate a connection on a given socket.</p>
 <p>Possible signatures:</p>
 <ul>
@@ -749,7 +906,7 @@ for the <a href="#net_event_connect"><code>'connect'</code></a> event <strong>on
 <p>This function should only be used for reconnecting a socket after
 <code>'close'</code> has been emitted or otherwise it may lead to undefined
 behavior.</p>
-<h4><code>socket.connect(options[, connectListener])</code><span><a class="mark" href="#net_socket_connect_options_connectlistener" id="net_socket_connect_options_connectlistener">#</a></span></h4>
+<h5><code>socket.connect(options[, connectListener])</code><span><a class="mark" href="#net_socket_connect_options_connectlistener" id="net_socket_connect_options_connectlistener">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -812,18 +969,18 @@ global context.</li>
 </ul>
 <p>Following is an example of a client using the <code>onread</code> option:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-net.connect({
+net.<span class="hljs-title function_">connect</span>({
   <span class="hljs-attr">port</span>: <span class="hljs-number">80</span>,
   <span class="hljs-attr">onread</span>: {
     <span class="hljs-comment">// Reuses a 4KiB Buffer for every read from the socket.</span>
-    <span class="hljs-attr">buffer</span>: Buffer.alloc(<span class="hljs-number">4</span> * <span class="hljs-number">1024</span>),
-    <span class="hljs-attr">callback</span>: <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">nread, buf</span>) </span>{
+    <span class="hljs-attr">buffer</span>: <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">alloc</span>(<span class="hljs-number">4</span> * <span class="hljs-number">1024</span>),
+    <span class="hljs-attr">callback</span>: <span class="hljs-keyword">function</span>(<span class="hljs-params">nread, buf</span>) {
       <span class="hljs-comment">// Received data is available in `buf` from 0 to `nread`.</span>
-      <span class="hljs-built_in">console</span>.log(buf.toString(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, nread));
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'utf8'</span>, <span class="hljs-number">0</span>, nread));
     }
   }
 });</code></pre>
-<h4><code>socket.connect(path[, connectListener])</code><span><a class="mark" href="#net_socket_connect_path_connectlistener" id="net_socket_connect_path_connectlistener">#</a></span></h4>
+<h5><code>socket.connect(path[, connectListener])</code><span><a class="mark" href="#net_socket_connect_path_connectlistener" id="net_socket_connect_path_connectlistener">#</a></span></h5>
 <ul>
 <li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Path the client should connect to. See
 <a href="#net_identifying_paths_for_ipc_connections">Identifying paths for IPC connections</a>.</li>
@@ -835,7 +992,7 @@ methods. Will be added as a listener for the <a href="#net_event_connect"><code>
 <p>Alias to
 <a href="#net_socket_connect_options_connectlistener"><code>socket.connect(options[, connectListener])</code></a>
 called with <code>{ path: path }</code> as <code>options</code>.</p>
-<h4><code>socket.connect(port[, host][, connectListener])</code><span><a class="mark" href="#net_socket_connect_port_host_connectlistener" id="net_socket_connect_port_host_connectlistener">#</a></span></h4>
+<h5><code>socket.connect(port[, host][, connectListener])</code><span><a class="mark" href="#net_socket_connect_port_host_connectlistener" id="net_socket_connect_port_host_connectlistener">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -850,7 +1007,7 @@ methods. Will be added as a listener for the <a href="#net_event_connect"><code>
 <p>Alias to
 <a href="#net_socket_connect_options_connectlistener"><code>socket.connect(options[, connectListener])</code></a>
 called with <code>{port: port, host: host}</code> as <code>options</code>.</p>
-<h3><code>socket.connecting</code><span><a class="mark" href="#net_socket_connecting" id="net_socket_connecting">#</a></span></h3>
+<h4><code>socket.connecting</code><span><a class="mark" href="#net_socket_connecting" id="net_socket_connecting">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.1.0</span>
 </div>
@@ -864,7 +1021,7 @@ connected, then it is set to <code>false</code> and the <code>'connect'</code> e
 that the
 <a href="#net_socket_connect_options_connectlistener"><code>socket.connect(options[, connectListener])</code></a>
 callback is a listener for the <code>'connect'</code> event.</p>
-<h3><code>socket.destroy([error])</code><span><a class="mark" href="#net_socket_destroy_error" id="net_socket_destroy_error">#</a></span></h3>
+<h4><code>socket.destroy([error])</code><span><a class="mark" href="#net_socket_destroy_error" id="net_socket_destroy_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -875,13 +1032,13 @@ callback is a listener for the <code>'connect'</code> event.</p>
 <p>Ensures that no more I/O activity happens on this socket.
 Destroys the stream and closes the connection.</p>
 <p>See <a href="stream.html#stream_writable_destroy_error"><code>writable.destroy()</code></a> for further details.</p>
-<h3><code>socket.destroyed</code><span><a class="mark" href="#net_socket_destroyed" id="net_socket_destroyed">#</a></span></h3>
+<h4><code>socket.destroyed</code><span><a class="mark" href="#net_socket_destroyed" id="net_socket_destroyed">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates if the connection is destroyed or not. Once a
 connection is destroyed no further data can be transferred using it.</li>
 </ul>
 <p>See <a href="stream.html#stream_writable_destroyed"><code>writable.destroyed</code></a> for further details.</p>
-<h3><code>socket.end([data[, encoding]][, callback])</code><span><a class="mark" href="#net_socket_end_data_encoding_callback" id="net_socket_end_data_encoding_callback">#</a></span></h3>
+<h4><code>socket.end([data[, encoding]][, callback])</code><span><a class="mark" href="#net_socket_end_data_encoding_callback" id="net_socket_end_data_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -894,7 +1051,7 @@ connection is destroyed no further data can be transferred using it.</li>
 <p>Half-closes the socket. i.e., it sends a FIN packet. It is possible the
 server will still send some data.</p>
 <p>See <a href="stream.html#stream_writable_end_chunk_encoding_callback"><code>writable.end()</code></a> for further details.</p>
-<h3><code>socket.localAddress</code><span><a class="mark" href="#net_socket_localaddress" id="net_socket_localaddress">#</a></span></h3>
+<h4><code>socket.localAddress</code><span><a class="mark" href="#net_socket_localaddress" id="net_socket_localaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.6</span>
 </div>
@@ -905,7 +1062,7 @@ server will still send some data.</p>
 connecting on. For example, in a server listening on <code>'0.0.0.0'</code>, if a client
 connects on <code>'192.168.1.1'</code>, the value of <code>socket.localAddress</code> would be
 <code>'192.168.1.1'</code>.</p>
-<h3><code>socket.localPort</code><span><a class="mark" href="#net_socket_localport" id="net_socket_localport">#</a></span></h3>
+<h4><code>socket.localPort</code><span><a class="mark" href="#net_socket_localport" id="net_socket_localport">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.6</span>
 </div>
@@ -913,15 +1070,15 @@ connects on <code>'192.168.1.1'</code>, the value of <code>socket.localAddress</
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The numeric representation of the local port. For example, <code>80</code> or <code>21</code>.</p>
-<h3><code>socket.pause()</code><span><a class="mark" href="#net_socket_pause" id="net_socket_pause">#</a></span></h3>
+<h4><code>socket.pause()</code><span><a class="mark" href="#net_socket_pause" id="net_socket_pause">#</a></span></h4>
 <ul>
 <li>Returns: <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> The socket itself.</li>
 </ul>
 <p>Pauses the reading of data. That is, <a href="#net_event_data"><code>'data'</code></a> events will not be emitted.
 Useful to throttle back an upload.</p>
-<h3><code>socket.pending</code><span><a class="mark" href="#net_socket_pending" id="net_socket_pending">#</a></span></h3>
+<h4><code>socket.pending</code><span><a class="mark" href="#net_socket_pending" id="net_socket_pending">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.2.0</span>
+<span>Added in: v11.2.0, v10.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
@@ -929,7 +1086,7 @@ Useful to throttle back an upload.</p>
 <p>This is <code>true</code> if the socket is not connected yet, either because <code>.connect()</code>
 has not yet been called or because it is still in the process of connecting
 (see <a href="#net_socket_connecting"><code>socket.connecting</code></a>).</p>
-<h3><code>socket.ref()</code><span><a class="mark" href="#net_socket_ref" id="net_socket_ref">#</a></span></h3>
+<h4><code>socket.ref()</code><span><a class="mark" href="#net_socket_ref" id="net_socket_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -939,7 +1096,7 @@ has not yet been called or because it is still in the process of connecting
 <p>Opposite of <code>unref()</code>, calling <code>ref()</code> on a previously <code>unref</code>ed socket will
 <em>not</em> let the program exit if it's the only socket left (the default behavior).
 If the socket is <code>ref</code>ed calling <code>ref</code> again will have no effect.</p>
-<h3><code>socket.remoteAddress</code><span><a class="mark" href="#net_socket_remoteaddress" id="net_socket_remoteaddress">#</a></span></h3>
+<h4><code>socket.remoteAddress</code><span><a class="mark" href="#net_socket_remoteaddress" id="net_socket_remoteaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -949,7 +1106,7 @@ If the socket is <code>ref</code>ed calling <code>ref</code> again will have no
 <p>The string representation of the remote IP address. For example,
 <code>'74.125.127.100'</code> or <code>'2001:4860:a005::68'</code>. Value may be <code>undefined</code> if
 the socket is destroyed (for example, if the client disconnected).</p>
-<h3><code>socket.remoteFamily</code><span><a class="mark" href="#net_socket_remotefamily" id="net_socket_remotefamily">#</a></span></h3>
+<h4><code>socket.remoteFamily</code><span><a class="mark" href="#net_socket_remotefamily" id="net_socket_remotefamily">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -957,7 +1114,7 @@ the socket is destroyed (for example, if the client disconnected).</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The string representation of the remote IP family. <code>'IPv4'</code> or <code>'IPv6'</code>.</p>
-<h3><code>socket.remotePort</code><span><a class="mark" href="#net_socket_remoteport" id="net_socket_remoteport">#</a></span></h3>
+<h4><code>socket.remotePort</code><span><a class="mark" href="#net_socket_remoteport" id="net_socket_remoteport">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -965,12 +1122,12 @@ the socket is destroyed (for example, if the client disconnected).</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The numeric representation of the remote port. For example, <code>80</code> or <code>21</code>.</p>
-<h3><code>socket.resume()</code><span><a class="mark" href="#net_socket_resume" id="net_socket_resume">#</a></span></h3>
+<h4><code>socket.resume()</code><span><a class="mark" href="#net_socket_resume" id="net_socket_resume">#</a></span></h4>
 <ul>
 <li>Returns: <a href="net.html#net_class_net_socket" class="type">&#x3C;net.Socket></a> The socket itself.</li>
 </ul>
 <p>Resumes reading after a call to <a href="#net_socket_pause"><code>socket.pause()</code></a>.</p>
-<h3><code>socket.setEncoding([encoding])</code><span><a class="mark" href="#net_socket_setencoding_encoding" id="net_socket_setencoding_encoding">#</a></span></h3>
+<h4><code>socket.setEncoding([encoding])</code><span><a class="mark" href="#net_socket_setencoding_encoding" id="net_socket_setencoding_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -980,9 +1137,17 @@ the socket is destroyed (for example, if the client disconnected).</p>
 </ul>
 <p>Set the encoding for the socket as a <a href="stream.html#stream_class_stream_readable">Readable Stream</a>. See
 <a href="stream.html#stream_readable_setencoding_encoding"><code>readable.setEncoding()</code></a> for more information.</p>
-<h3><code>socket.setKeepAlive([enable][, initialDelay])</code><span><a class="mark" href="#net_socket_setkeepalive_enable_initialdelay" id="net_socket_setkeepalive_enable_initialdelay">#</a></span></h3>
+<h4><code>socket.setKeepAlive([enable][, initialDelay])</code><span><a class="mark" href="#net_socket_setkeepalive_enable_initialdelay" id="net_socket_setkeepalive_enable_initialdelay">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.92</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.12.0, v12.17.0</td>
+<td><p>New defaults for <code>TCP_KEEPCNT</code> and <code>TCP_KEEPINTVL</code> socket options were added.</p></td></tr>
+<tr><td>v0.1.92</td>
+<td><p><span>Added in: v0.1.92</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>enable</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
@@ -995,7 +1160,14 @@ delay before the first keepalive probe is sent on an idle socket.</p>
 data packet received and the first keepalive probe. Setting <code>0</code> for
 <code>initialDelay</code> will leave the value unchanged from the default
 (or previous) setting.</p>
-<h3><code>socket.setNoDelay([noDelay])</code><span><a class="mark" href="#net_socket_setnodelay_nodelay" id="net_socket_setnodelay_nodelay">#</a></span></h3>
+<p>Enabling the keep-alive functionality will set the following socket options:</p>
+<ul>
+<li><code>SO_KEEPALIVE=1</code></li>
+<li><code>TCP_KEEPIDLE=initialDelay</code></li>
+<li><code>TCP_KEEPCNT=10</code></li>
+<li><code>TCP_KEEPINTVL=1</code></li>
+</ul>
+<h4><code>socket.setNoDelay([noDelay])</code><span><a class="mark" href="#net_socket_setnodelay_nodelay" id="net_socket_setnodelay_nodelay">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1010,7 +1182,7 @@ to optimize throughput at the expense of latency.</p>
 <p>Passing <code>true</code> for <code>noDelay</code> or not passing an argument will disable Nagle's
 algorithm for the socket. Passing <code>false</code> for <code>noDelay</code> will enable Nagle's
 algorithm.</p>
-<h3><code>socket.setTimeout(timeout[, callback])</code><span><a class="mark" href="#net_socket_settimeout_timeout_callback" id="net_socket_settimeout_timeout_callback">#</a></span></h3>
+<h4><code>socket.setTimeout(timeout[, callback])</code><span><a class="mark" href="#net_socket_settimeout_timeout_callback" id="net_socket_settimeout_timeout_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1024,15 +1196,24 @@ the socket. By default <code>net.Socket</code> do not have a timeout.</p>
 <p>When an idle timeout is triggered the socket will receive a <a href="#net_event_timeout"><code>'timeout'</code></a>
 event but the connection will not be severed. The user must manually call
 <a href="#net_socket_end_data_encoding_callback"><code>socket.end()</code></a> or <a href="#net_socket_destroy_error"><code>socket.destroy()</code></a> to end the connection.</p>
-<pre><code class="language-js">socket.setTimeout(<span class="hljs-number">3000</span>);
-socket.on(<span class="hljs-string">'timeout'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'socket timeout'</span>);
-  socket.end();
+<pre><code class="language-js">socket.<span class="hljs-built_in">setTimeout</span>(<span class="hljs-number">3000</span>);
+socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'timeout'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'socket timeout'</span>);
+  socket.<span class="hljs-title function_">end</span>();
 });</code></pre>
 <p>If <code>timeout</code> is 0, then the existing idle timeout is disabled.</p>
 <p>The optional <code>callback</code> parameter will be added as a one-time listener for the
 <a href="#net_event_timeout"><code>'timeout'</code></a> event.</p>
-<h3><code>socket.unref()</code><span><a class="mark" href="#net_socket_unref" id="net_socket_unref">#</a></span></h3>
+<h4><code>socket.timeout</code><span><a class="mark" href="#net_socket_timeout" id="net_socket_timeout">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v10.7.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
+</ul>
+<p>The socket timeout in milliseconds as set by <a href="#net_socket_settimeout_timeout_callback"><code>socket.setTimeout()</code></a>.
+It is <code>undefined</code> if a timeout has not been set.</p>
+<h4><code>socket.unref()</code><span><a class="mark" href="#net_socket_unref" id="net_socket_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -1042,7 +1223,7 @@ socket.on(<span class="hljs-string">'timeout'</span>, <span class="hljs-function
 <p>Calling <code>unref()</code> on a socket will allow the program to exit if this is the only
 active socket in the event system. If the socket is already <code>unref</code>ed calling
 <code>unref()</code> again will have no effect.</p>
-<h3><code>socket.write(data[, encoding][, callback])</code><span><a class="mark" href="#net_socket_write_data_encoding_callback" id="net_socket_write_data_encoding_callback">#</a></span></h3>
+<h4><code>socket.write(data[, encoding][, callback])</code><span><a class="mark" href="#net_socket_write_data_encoding_callback" id="net_socket_write_data_encoding_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1061,7 +1242,21 @@ buffer. Returns <code>false</code> if all or part of the data was queued in user
 written out, which may not be immediately.</p>
 <p>See <code>Writable</code> stream <a href="stream.html#stream_writable_write_chunk_encoding_callback"><code>write()</code></a> method for more
 information.</p>
-<h2><code>net.connect()</code><span><a class="mark" href="#net_net_connect" id="net_net_connect">#</a></span></h2>
+<h4><code>socket.readyState</code><span><a class="mark" href="#net_socket_readystate" id="net_socket_readystate">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.5.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>This property represents the state of the connection as a string.</p>
+<ul>
+<li>If the stream is connecting <code>socket.readyState</code> is <code>opening</code>.</li>
+<li>If the stream is readable and writable, it is <code>open</code>.</li>
+<li>If the stream is readable and not writable, it is <code>readOnly</code>.</li>
+<li>If the stream is not readable and writable, it is <code>writeOnly</code>.</li>
+</ul>
+</section><section><h3><code>net.connect()</code><span><a class="mark" href="#net_net_connect" id="net_net_connect">#</a></span></h3>
 <p>Aliases to
 <a href="#net_net_createconnection"><code>net.createConnection()</code></a>.</p>
 <p>Possible signatures:</p>
@@ -1072,7 +1267,7 @@ connections.</li>
 <li><a href="#net_net_connect_port_host_connectlistener"><code>net.connect(port[, host][, connectListener])</code></a>
 for TCP connections.</li>
 </ul>
-<h3><code>net.connect(options[, connectListener])</code><span><a class="mark" href="#net_net_connect_options_connectlistener" id="net_net_connect_options_connectlistener">#</a></span></h3>
+<h4><code>net.connect(options[, connectListener])</code><span><a class="mark" href="#net_net_connect_options_connectlistener" id="net_net_connect_options_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -1083,7 +1278,7 @@ for TCP connections.</li>
 </ul>
 <p>Alias to
 <a href="#net_net_createconnection_options_connectlistener"><code>net.createConnection(options[, connectListener])</code></a>.</p>
-<h3><code>net.connect(path[, connectListener])</code><span><a class="mark" href="#net_net_connect_path_connectlistener" id="net_net_connect_path_connectlistener">#</a></span></h3>
+<h4><code>net.connect(path[, connectListener])</code><span><a class="mark" href="#net_net_connect_path_connectlistener" id="net_net_connect_path_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1094,7 +1289,7 @@ for TCP connections.</li>
 </ul>
 <p>Alias to
 <a href="#net_net_createconnection_path_connectlistener"><code>net.createConnection(path[, connectListener])</code></a>.</p>
-<h3><code>net.connect(port[, host][, connectListener])</code><span><a class="mark" href="#net_net_connect_port_host_connectlistener" id="net_net_connect_port_host_connectlistener">#</a></span></h3>
+<h4><code>net.connect(port[, host][, connectListener])</code><span><a class="mark" href="#net_net_connect_port_host_connectlistener" id="net_net_connect_port_host_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1106,7 +1301,7 @@ for TCP connections.</li>
 </ul>
 <p>Alias to
 <a href="#net_net_createconnection_port_host_connectlistener"><code>net.createConnection(port[, host][, connectListener])</code></a>.</p>
-<h2><code>net.createConnection()</code><span><a class="mark" href="#net_net_createconnection" id="net_net_createconnection">#</a></span></h2>
+</section><section><h3><code>net.createConnection()</code><span><a class="mark" href="#net_net_createconnection" id="net_net_createconnection">#</a></span></h3>
 <p>A factory function, which creates a new <a href="#net_class_net_socket"><code>net.Socket</code></a>,
 immediately initiates connection with <a href="#net_socket_connect"><code>socket.connect()</code></a>,
 then returns the <code>net.Socket</code> that starts the connection.</p>
@@ -1122,7 +1317,7 @@ for <a href="#net_ipc_support">IPC</a> connections.</li>
 for TCP connections.</li>
 </ul>
 <p>The <a href="#net_net_connect"><code>net.connect()</code></a> function is an alias to this function.</p>
-<h3><code>net.createConnection(options[, connectListener])</code><span><a class="mark" href="#net_net_createconnection_options_connectlistener" id="net_net_createconnection_options_connectlistener">#</a></span></h3>
+<h4><code>net.createConnection(options[, connectListener])</code><span><a class="mark" href="#net_net_createconnection_options_connectlistener" id="net_net_createconnection_options_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1148,21 +1343,21 @@ it starts the connection.</li>
 <p>Following is an example of a client of the echo server described
 in the <a href="#net_net_createserver_options_connectionlistener"><code>net.createServer()</code></a> section:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-<span class="hljs-keyword">const</span> client = net.createConnection({ <span class="hljs-attr">port</span>: <span class="hljs-number">8124</span> }, <span class="hljs-function">() =></span> {
+<span class="hljs-keyword">const</span> client = net.<span class="hljs-title function_">createConnection</span>({ <span class="hljs-attr">port</span>: <span class="hljs-number">8124</span> }, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// 'connect' listener.</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'connected to server!'</span>);
-  client.write(<span class="hljs-string">'world!\r\n'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'connected to server!'</span>);
+  client.<span class="hljs-title function_">write</span>(<span class="hljs-string">'world!\r\n'</span>);
 });
-client.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(data.toString());
-  client.end();
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-title function_">toString</span>());
+  client.<span class="hljs-title function_">end</span>();
 });
-client.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'disconnected from server'</span>);
+client.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'disconnected from server'</span>);
 });</code></pre>
 <p>To connect on the socket <code>/tmp/echo.sock</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> client = net.createConnection({ <span class="hljs-attr">path</span>: <span class="hljs-string">'/tmp/echo.sock'</span> });</code></pre>
-<h3><code>net.createConnection(path[, connectListener])</code><span><a class="mark" href="#net_net_createconnection_path_connectlistener" id="net_net_createconnection_path_connectlistener">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> client = net.<span class="hljs-title function_">createConnection</span>({ <span class="hljs-attr">path</span>: <span class="hljs-string">'/tmp/echo.sock'</span> });</code></pre>
+<h4><code>net.createConnection(path[, connectListener])</code><span><a class="mark" href="#net_net_createconnection_path_connectlistener" id="net_net_createconnection_path_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1181,7 +1376,7 @@ See <a href="#net_identifying_paths_for_ipc_connections">Identifying paths for I
 immediately initiates connection with
 <a href="#net_socket_connect_path_connectlistener"><code>socket.connect(path[, connectListener])</code></a>,
 then returns the <code>net.Socket</code> that starts the connection.</p>
-<h3><code>net.createConnection(port[, host][, connectListener])</code><span><a class="mark" href="#net_net_createconnection_port_host_connectlistener" id="net_net_createconnection_port_host_connectlistener">#</a></span></h3>
+<h4><code>net.createConnection(port[, host][, connectListener])</code><span><a class="mark" href="#net_net_createconnection_port_host_connectlistener" id="net_net_createconnection_port_host_connectlistener">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.90</span>
 </div>
@@ -1202,15 +1397,16 @@ then returns the <code>net.Socket</code> that starts the connection.</p>
 immediately initiates connection with
 <a href="#net_socket_connect_port_host_connectlistener"><code>socket.connect(port[, host][, connectListener])</code></a>,
 then returns the <code>net.Socket</code> that starts the connection.</p>
-<h2><code>net.createServer([options][, connectionListener])</code><span><a class="mark" href="#net_net_createserver_options_connectionlistener" id="net_net_createserver_options_connectionlistener">#</a></span></h2>
+</section><section><h3><code>net.createServer([options][, connectionListener])</code><span><a class="mark" href="#net_net_createserver_options_connectionlistener" id="net_net_createserver_options_connectionlistener">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether half-opened TCP
-connections are allowed. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If set to <code>false</code>, then the socket will
+automatically end the writable side when the readable side ends.
+<strong>Default:</strong> <code>false</code>.</li>
 <li><code>pauseOnConnect</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates whether the socket should be
 paused on incoming connections. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
@@ -1221,10 +1417,12 @@ paused on incoming connections. <strong>Default:</strong> <code>false</code>.</l
 </ul>
 <p>Creates a new TCP or <a href="#net_ipc_support">IPC</a> server.</p>
 <p>If <code>allowHalfOpen</code> is set to <code>true</code>, when the other end of the socket
-sends a FIN packet, the server will only send a FIN packet back when
-<a href="#net_socket_end_data_encoding_callback"><code>socket.end()</code></a> is explicitly called, until then the connection is
-half-closed (non-readable but still writable). See <a href="#net_event_end"><code>'end'</code></a> event
-and <a href="https://tools.ietf.org/html/rfc1122">RFC 1122</a> (section 4.2.2.13) for more information.</p>
+signals the end of transmission, the server will only send back the end of
+transmission when <a href="#net_socket_end_data_encoding_callback"><code>socket.end()</code></a> is explicitly called. For example, in the
+context of TCP, when a FIN packed is received, a FIN packed is sent
+back only when <a href="#net_socket_end_data_encoding_callback"><code>socket.end()</code></a> is explicitly called. Until then the
+connection is half-closed (non-readable but still writable). See <a href="#net_event_end"><code>'end'</code></a>
+event and <a href="https://tools.ietf.org/html/rfc1122">RFC 1122</a> (section 4.2.2.13) for more information.</p>
 <p>If <code>pauseOnConnect</code> is set to <code>true</code>, then the socket associated with each
 incoming connection will be paused, and no data will be read from its handle.
 This allows connections to be passed between processes without any data being
@@ -1235,30 +1433,30 @@ read by the original process. To begin reading data from a paused socket, call
 <p>Here is an example of an TCP echo server which listens for connections
 on port 8124:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> net = <span class="hljs-built_in">require</span>(<span class="hljs-string">'net'</span>);
-<span class="hljs-keyword">const</span> server = net.createServer(<span class="hljs-function">(<span class="hljs-params">c</span>) =></span> {
+<span class="hljs-keyword">const</span> server = net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">c</span>) =></span> {
   <span class="hljs-comment">// 'connection' listener.</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'client connected'</span>);
-  c.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'client disconnected'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'client connected'</span>);
+  c.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'client disconnected'</span>);
   });
-  c.write(<span class="hljs-string">'hello\r\n'</span>);
-  c.pipe(c);
+  c.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello\r\n'</span>);
+  c.<span class="hljs-title function_">pipe</span>(c);
 });
-server.on(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">throw</span> err;
 });
-server.listen(<span class="hljs-number">8124</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server bound'</span>);
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8124</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server bound'</span>);
 });</code></pre>
 <p>Test this by using <code>telnet</code>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> telnet localhost 8124</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">telnet localhost 8124</span></code></pre>
 <p>To listen on the socket <code>/tmp/echo.sock</code>:</p>
-<pre><code class="language-js">server.listen(<span class="hljs-string">'/tmp/echo.sock'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server bound'</span>);
+<pre><code class="language-js">server.<span class="hljs-title function_">listen</span>(<span class="hljs-string">'/tmp/echo.sock'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server bound'</span>);
 });</code></pre>
 <p>Use <code>nc</code> to connect to a Unix domain socket server:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> nc -U /tmp/echo.sock</span></code></pre>
-<h2><code>net.isIP(input)</code><span><a class="mark" href="#net_net_isip_input" id="net_net_isip_input">#</a></span></h2>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">nc -U /tmp/echo.sock</span></code></pre>
+</section><section><h3><code>net.isIP(input)</code><span><a class="mark" href="#net_net_isip_input" id="net_net_isip_input">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1269,7 +1467,7 @@ server.listen(<span class="hljs-number">8124</span>, <span class="hljs-function"
 <p>Tests if input is an IP address. Returns <code>0</code> for invalid strings,
 returns <code>4</code> for IP version 4 addresses, and returns <code>6</code> for IP version 6
 addresses.</p>
-<h2><code>net.isIPv4(input)</code><span><a class="mark" href="#net_net_isipv4_input" id="net_net_isipv4_input">#</a></span></h2>
+</section><section><h3><code>net.isIPv4(input)</code><span><a class="mark" href="#net_net_isipv4_input" id="net_net_isipv4_input">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1278,7 +1476,7 @@ addresses.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if input is a version 4 IP address, otherwise returns <code>false</code>.</p>
-<h2><code>net.isIPv6(input)</code><span><a class="mark" href="#net_net_isipv6_input" id="net_net_isipv6_input">#</a></span></h2>
+</section><section><h3><code>net.isIPv6(input)</code><span><a class="mark" href="#net_net_isipv6_input" id="net_net_isipv6_input">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -1286,10 +1484,46 @@ addresses.</p>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Returns <code>true</code> if input is a version 6 IP address, otherwise returns <code>false</code>.</p>
+<p>Returns <code>true</code> if input is a version 6 IP address, otherwise returns <code>false</code>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/net.json b/doc/api/net.json
index 6a857b6bd4605a5d39a90c4ab25595bbeb185015..818e5cfc72cb3c2e16be1d85d554fadbf81b981d 100644
--- a/doc/api/net.json
+++ b/doc/api/net.json
@@ -6,7 +6,7 @@
       "textRaw": "Net",
       "name": "net",
       "introduced_in": "v0.10.0",
-      "desc": "<!--lint disable maximum-line-length-->\n<blockquote>\n<p>Stability: 2 - Stable</p>\n</blockquote>\n<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/net.js\">lib/net.js</a></p>\n<p>The <code>net</code> module provides an asynchronous network API for creating stream-based\nTCP or <a href=\"#net_ipc_support\">IPC</a> servers (<a href=\"#net_net_createserver_options_connectionlistener\"><code>net.createServer()</code></a>) and clients\n(<a href=\"#net_net_createconnection\"><code>net.createConnection()</code></a>).</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const net = require('net');\n</code></pre>",
+      "desc": "<!--lint disable maximum-line-length-->\n<blockquote>\n<p>Stability: 2 - Stable</p>\n</blockquote>\n<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/net.js\">lib/net.js</a></p>\n<p>The <code>net</code> module provides an asynchronous network API for creating stream-based\nTCP or <a href=\"#net_ipc_support\">IPC</a> servers (<a href=\"#net_net_createserver_options_connectionlistener\"><code>net.createServer()</code></a>) and clients\n(<a href=\"#net_net_createconnection\"><code>net.createConnection()</code></a>).</p>\n<p>It can be accessed using:</p>\n<pre><code class=\"language-js\">const net = require('net');\n</code></pre>",
       "modules": [
         {
           "textRaw": "IPC support",
@@ -26,6 +26,270 @@
         }
       ],
       "classes": [
+        {
+          "textRaw": "Class: `net.BlockList`",
+          "type": "class",
+          "name": "net.BlockList",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>The <code>BlockList</code> object can be used with some network APIs to specify rules for\ndisabling inbound or outbound access to specific IP addresses, IP ranges, or\nIP subnets.</p>",
+          "methods": [
+            {
+              "textRaw": "`blockList.addAddress(address[, type])`",
+              "type": "method",
+              "name": "addAddress",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`address` {string|net.SocketAddress} An IPv4 or IPv6 address.",
+                      "name": "address",
+                      "type": "string|net.SocketAddress",
+                      "desc": "An IPv4 or IPv6 address."
+                    },
+                    {
+                      "textRaw": "`type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.",
+                      "name": "type",
+                      "type": "string",
+                      "default": "`'ipv4'`",
+                      "desc": "Either `'ipv4'` or `'ipv6'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Adds a rule to block the given IP address.</p>"
+            },
+            {
+              "textRaw": "`blockList.addRange(start, end[, type])`",
+              "type": "method",
+              "name": "addRange",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`start` {string|net.SocketAddress} The starting IPv4 or IPv6 address in the range.",
+                      "name": "start",
+                      "type": "string|net.SocketAddress",
+                      "desc": "The starting IPv4 or IPv6 address in the range."
+                    },
+                    {
+                      "textRaw": "`end` {string|net.SocketAddress} The ending IPv4 or IPv6 address in the range.",
+                      "name": "end",
+                      "type": "string|net.SocketAddress",
+                      "desc": "The ending IPv4 or IPv6 address in the range."
+                    },
+                    {
+                      "textRaw": "`type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.",
+                      "name": "type",
+                      "type": "string",
+                      "default": "`'ipv4'`",
+                      "desc": "Either `'ipv4'` or `'ipv6'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Adds a rule to block a range of IP addresses from <code>start</code> (inclusive) to\n<code>end</code> (inclusive).</p>"
+            },
+            {
+              "textRaw": "`blockList.addSubnet(net, prefix[, type])`",
+              "type": "method",
+              "name": "addSubnet",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": [
+                    {
+                      "textRaw": "`net` {string|net.SocketAddress} The network IPv4 or IPv6 address.",
+                      "name": "net",
+                      "type": "string|net.SocketAddress",
+                      "desc": "The network IPv4 or IPv6 address."
+                    },
+                    {
+                      "textRaw": "`prefix` {number} The number of CIDR prefix bits. For IPv4, this must be a value between `0` and `32`. For IPv6, this must be between `0` and `128`.",
+                      "name": "prefix",
+                      "type": "number",
+                      "desc": "The number of CIDR prefix bits. For IPv4, this must be a value between `0` and `32`. For IPv6, this must be between `0` and `128`."
+                    },
+                    {
+                      "textRaw": "`type` {string} Either `'ipv4'` or `'ipv6'`. **Default**: `'ipv4'`.",
+                      "name": "type",
+                      "type": "string",
+                      "desc": "Either `'ipv4'` or `'ipv6'`. **Default**: `'ipv4'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Adds a rule to block a range of IP addresses specified as a subnet mask.</p>"
+            },
+            {
+              "textRaw": "`blockList.check(address[, type])`",
+              "type": "method",
+              "name": "check",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`address` {string|net.SocketAddress} The IP address to check",
+                      "name": "address",
+                      "type": "string|net.SocketAddress",
+                      "desc": "The IP address to check"
+                    },
+                    {
+                      "textRaw": "`type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.",
+                      "name": "type",
+                      "type": "string",
+                      "default": "`'ipv4'`",
+                      "desc": "Either `'ipv4'` or `'ipv6'`."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>Returns <code>true</code> if the given IP address matches any of the rules added to the\n<code>BlockList</code>.</p>\n<pre><code class=\"language-js\">const blockList = new net.BlockList();\nblockList.addAddress('123.123.123.123');\nblockList.addRange('10.0.0.1', '10.0.0.10');\nblockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');\n\nconsole.log(blockList.check('123.123.123.123'));  // Prints: true\nconsole.log(blockList.check('10.0.0.3'));  // Prints: true\nconsole.log(blockList.check('222.111.111.222'));  // Prints: false\n\n// IPv6 notation for IPv4 addresses works:\nconsole.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true\nconsole.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true\n</code></pre>"
+            }
+          ],
+          "properties": [
+            {
+              "textRaw": "`rules` Type: {string[]}",
+              "type": "string[]",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The list of rules added to the blocklist.</p>"
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `net.SocketAddress`",
+          "type": "class",
+          "name": "net.SocketAddress",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "properties": [
+            {
+              "textRaw": "`address` Type {string}",
+              "type": "string",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "Either `'ipv4'` or `'ipv6'`."
+            },
+            {
+              "textRaw": "`family` Type {string} Either `'ipv4'` or `'ipv6'`.",
+              "type": "string",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "desc": "Either `'ipv4'` or `'ipv6'`."
+            },
+            {
+              "textRaw": "`flowlabel` Type {number}",
+              "type": "number",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              }
+            },
+            {
+              "textRaw": "`port` Type {number}",
+              "type": "number",
+              "name": "Type",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              }
+            }
+          ],
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`address` {string} The network address as either an IPv4 or IPv6 string. **Default**: `'127.0.0.1'` if `family` is `'ipv4'`; `'::'` if `family` is `'ipv6'`.",
+                      "name": "address",
+                      "type": "string",
+                      "desc": "The network address as either an IPv4 or IPv6 string. **Default**: `'127.0.0.1'` if `family` is `'ipv4'`; `'::'` if `family` is `'ipv6'`."
+                    },
+                    {
+                      "textRaw": "`family` {string} One of either `'ipv4'` or 'ipv6'`. **Default**: `'ipv4'`.",
+                      "name": "family",
+                      "type": "string",
+                      "desc": "One of either `'ipv4'` or 'ipv6'`. **Default**: `'ipv4'`."
+                    },
+                    {
+                      "textRaw": "`flowlabel` {number} An IPv6 flow-label used only if `family` is `'ipv6'`.",
+                      "name": "flowlabel",
+                      "type": "number",
+                      "desc": "An IPv6 flow-label used only if `family` is `'ipv6'`."
+                    },
+                    {
+                      "textRaw": "`port` {number} An IP port.",
+                      "name": "port",
+                      "type": "number",
+                      "desc": "An IP port."
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
         {
           "textRaw": "Class: `net.Server`",
           "type": "class",
@@ -191,7 +455,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Start a server listening for connections. A <code>net.Server</code> can be a TCP or\nan <a href=\"#net_ipc_support\">IPC</a> server depending on what it listens to.</p>\n<p>Possible signatures:</p>\n<ul>\n<li><a href=\"#net_server_listen_handle_backlog_callback\"><code>server.listen(handle[, backlog][, callback])</code></a></li>\n<li><a href=\"#net_server_listen_options_callback\"><code>server.listen(options[, callback])</code></a></li>\n<li><a href=\"#net_server_listen_path_backlog_callback\"><code>server.listen(path[, backlog][, callback])</code></a>\nfor <a href=\"#net_ipc_support\">IPC</a> servers</li>\n<li>\n<a href=\"#net_server_listen_port_host_backlog_callback\">\n<code>server.listen([port[, host[, backlog]]][, callback])</code></a>\nfor TCP servers\n</li>\n</ul>\n<p>This function is asynchronous. When the server starts listening, the\n<a href=\"#net_event_listening\"><code>'listening'</code></a> event will be emitted. The last parameter <code>callback</code>\nwill be added as a listener for the <a href=\"#net_event_listening\"><code>'listening'</code></a> event.</p>\n<p>All <code>listen()</code> methods can take a <code>backlog</code> parameter to specify the maximum\nlength of the queue of pending connections. The actual length will be determined\nby the OS through sysctl settings such as <code>tcp_max_syn_backlog</code> and <code>somaxconn</code>\non Linux. The default value of this parameter is 511 (not 512).</p>\n<p>All <a href=\"#net_class_net_socket\"><code>net.Socket</code></a> are set to <code>SO_REUSEADDR</code> (see <a href=\"https://man7.org/linux/man-pages/man7/socket.7.html\"><code>socket(7)</code></a> for\ndetails).</p>\n<p>The <code>server.listen()</code> method can be called again if and only if there was an\nerror during the first <code>server.listen()</code> call or <code>server.close()</code> has been\ncalled. Otherwise, an <code>ERR_SERVER_ALREADY_LISTEN</code> error will be thrown.</p>\n<p>One of the most common errors raised when listening is <code>EADDRINUSE</code>.\nThis happens when another server is already listening on the requested\n<code>port</code>/<code>path</code>/<code>handle</code>. One way to handle this would be to retry\nafter a certain amount of time:</p>\n<pre><code class=\"language-js\">server.on('error', (e) => {\n  if (e.code === 'EADDRINUSE') {\n    console.log('Address in use, retrying...');\n    setTimeout(() => {\n      server.close();\n      server.listen(PORT, HOST);\n    }, 1000);\n  }\n});\n</code></pre>",
+              "desc": "<p>Start a server listening for connections. A <code>net.Server</code> can be a TCP or\nan <a href=\"#net_ipc_support\">IPC</a> server depending on what it listens to.</p>\n<p>Possible signatures:</p>\n<!--lint disable no-undefined-references-->\n<ul>\n<li><a href=\"#net_server_listen_handle_backlog_callback\"><code>server.listen(handle[, backlog][, callback])</code></a></li>\n<li><a href=\"#net_server_listen_options_callback\"><code>server.listen(options[, callback])</code></a></li>\n<li><a href=\"#net_server_listen_path_backlog_callback\"><code>server.listen(path[, backlog][, callback])</code></a>\nfor <a href=\"#net_ipc_support\">IPC</a> servers</li>\n<li>\n<a href=\"#net_server_listen_port_host_backlog_callback\">\n<code>server.listen([port[, host[, backlog]]][, callback])</code></a>\nfor TCP servers\n</li>\n</ul>\n<!--lint enable no-undefined-references-->\n<p>This function is asynchronous. When the server starts listening, the\n<a href=\"#net_event_listening\"><code>'listening'</code></a> event will be emitted. The last parameter <code>callback</code>\nwill be added as a listener for the <a href=\"#net_event_listening\"><code>'listening'</code></a> event.</p>\n<p>All <code>listen()</code> methods can take a <code>backlog</code> parameter to specify the maximum\nlength of the queue of pending connections. The actual length will be determined\nby the OS through sysctl settings such as <code>tcp_max_syn_backlog</code> and <code>somaxconn</code>\non Linux. The default value of this parameter is 511 (not 512).</p>\n<p>All <a href=\"#net_class_net_socket\"><code>net.Socket</code></a> are set to <code>SO_REUSEADDR</code> (see <a href=\"https://man7.org/linux/man-pages/man7/socket.7.html\"><code>socket(7)</code></a> for\ndetails).</p>\n<p>The <code>server.listen()</code> method can be called again if and only if there was an\nerror during the first <code>server.listen()</code> call or <code>server.close()</code> has been\ncalled. Otherwise, an <code>ERR_SERVER_ALREADY_LISTEN</code> error will be thrown.</p>\n<p>One of the most common errors raised when listening is <code>EADDRINUSE</code>.\nThis happens when another server is already listening on the requested\n<code>port</code>/<code>path</code>/<code>handle</code>. One way to handle this would be to retry\nafter a certain amount of time:</p>\n<pre><code class=\"language-js\">server.on('error', (e) => {\n  if (e.code === 'EADDRINUSE') {\n    console.log('Address in use, retrying...');\n    setTimeout(() => {\n      server.close();\n      server.listen(PORT, HOST);\n    }, 1000);\n  }\n});\n</code></pre>",
               "methods": [
                 {
                   "textRaw": "`server.listen(handle[, backlog][, callback])`",
@@ -322,7 +586,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>If <code>port</code> is specified, it behaves the same as\n<a href=\"#net_server_listen_port_host_backlog_callback\">\n<code>server.listen([port[, host[, backlog]]][, callback])</code></a>.\nOtherwise, if <code>path</code> is specified, it behaves the same as\n<a href=\"#net_server_listen_path_backlog_callback\"><code>server.listen(path[, backlog][, callback])</code></a>.\nIf none of them is specified, an error will be thrown.</p>\n<p>If <code>exclusive</code> is <code>false</code> (default), then cluster workers will use the same\nunderlying handle, allowing connection handling duties to be shared. When\n<code>exclusive</code> is <code>true</code>, the handle is not shared, and attempted port sharing\nresults in an error. An example which listens on an exclusive port is\nshown below.</p>\n<pre><code class=\"language-js\">server.listen({\n  host: 'localhost',\n  port: 80,\n  exclusive: true\n});\n</code></pre>\n<p>Starting an IPC server as root may cause the server path to be inaccessible for\nunprivileged users. Using <code>readableAll</code> and <code>writableAll</code> will make the server\naccessible for all users.</p>"
+                  "desc": "<!--lint disable no-undefined-references-->\n<p>If <code>port</code> is specified, it behaves the same as\n<a href=\"#net_server_listen_port_host_backlog_callback\">\n<code>server.listen([port[, host[, backlog]]][, callback])</code></a>.\nOtherwise, if <code>path</code> is specified, it behaves the same as\n<a href=\"#net_server_listen_path_backlog_callback\"><code>server.listen(path[, backlog][, callback])</code></a>.\nIf none of them is specified, an error will be thrown.</p>\n<!--lint enable no-undefined-references-->\n<p>If <code>exclusive</code> is <code>false</code> (default), then cluster workers will use the same\nunderlying handle, allowing connection handling duties to be shared. When\n<code>exclusive</code> is <code>true</code>, the handle is not shared, and attempted port sharing\nresults in an error. An example which listens on an exclusive port is\nshown below.</p>\n<pre><code class=\"language-js\">server.listen({\n  host: 'localhost',\n  port: 80,\n  exclusive: true\n});\n</code></pre>\n<p>Starting an IPC server as root may cause the server path to be inaccessible for\nunprivileged users. Using <code>readableAll</code> and <code>writableAll</code> will make the server\naccessible for all users.</p>"
                 },
                 {
                   "textRaw": "`server.listen(path[, backlog][, callback])`",
@@ -612,7 +876,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>Emitted when the other end of the socket sends a FIN packet, thus ending the\nreadable side of the socket.</p>\n<p>By default (<code>allowHalfOpen</code> is <code>false</code>) the socket will send a FIN packet\nback and destroy its file descriptor once it has written out its pending\nwrite queue. However, if <code>allowHalfOpen</code> is set to <code>true</code>, the socket will\nnot automatically <a href=\"#net_socket_end_data_encoding_callback\"><code>end()</code></a> its writable side, allowing the\nuser to write arbitrary amounts of data. The user must call\n<a href=\"#net_socket_end_data_encoding_callback\"><code>end()</code></a> explicitly to close the connection (i.e. sending a\nFIN packet back).</p>"
+              "desc": "<p>Emitted when the other end of the socket signals the end of transmission, thus\nending the readable side of the socket.</p>\n<p>By default (<code>allowHalfOpen</code> is <code>false</code>) the socket will send an end of\ntransmission packet back and destroy its file descriptor once it has written out\nits pending write queue. However, if <code>allowHalfOpen</code> is set to <code>true</code>, the\nsocket will not automatically <a href=\"#net_socket_end_data_encoding_callback\"><code>end()</code></a> its writable side,\nallowing the user to write arbitrary amounts of data. The user must call\n<a href=\"#net_socket_end_data_encoding_callback\"><code>end()</code></a> explicitly to close the connection (i.e. sending a\nFIN packet back).</p>"
             },
             {
               "textRaw": "Event: `'error'`",
@@ -1001,7 +1265,16 @@
                 "added": [
                   "v0.1.92"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v13.12.0",
+                      "v12.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/32204",
+                    "description": "New defaults for `TCP_KEEPCNT` and `TCP_KEEPINTVL` socket options were added."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -1027,7 +1300,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Enable/disable keep-alive functionality, and optionally set the initial\ndelay before the first keepalive probe is sent on an idle socket.</p>\n<p>Set <code>initialDelay</code> (in milliseconds) to set the delay between the last\ndata packet received and the first keepalive probe. Setting <code>0</code> for\n<code>initialDelay</code> will leave the value unchanged from the default\n(or previous) setting.</p>"
+              "desc": "<p>Enable/disable keep-alive functionality, and optionally set the initial\ndelay before the first keepalive probe is sent on an idle socket.</p>\n<p>Set <code>initialDelay</code> (in milliseconds) to set the delay between the last\ndata packet received and the first keepalive probe. Setting <code>0</code> for\n<code>initialDelay</code> will leave the value unchanged from the default\n(or previous) setting.</p>\n<p>Enabling the keep-alive functionality will set the following socket options:</p>\n<ul>\n<li><code>SO_KEEPALIVE=1</code></li>\n<li><code>TCP_KEEPIDLE=initialDelay</code></li>\n<li><code>TCP_KEEPCNT=10</code></li>\n<li><code>TCP_KEEPINTVL=1</code></li>\n</ul>"
             },
             {
               "textRaw": "`socket.setNoDelay([noDelay])`",
@@ -1166,8 +1439,13 @@
                 "added": [
                   "v0.3.8"
                 ],
+                "deprecated": [
+                  "v14.6.0"
+                ],
                 "changes": []
               },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use [`writable.writableLength`][] instead.",
               "desc": "<p>This property shows the number of characters buffered for writing. The buffer\nmay contain strings whose length after encoding is not yet known. So this number\nis only an approximation of the number of bytes in the buffer.</p>\n<p><code>net.Socket</code> has the property that <code>socket.write()</code> always works. This is to\nhelp users get up and running quickly. The computer cannot always keep up\nwith the amount of data that is written to a socket. The network connection\nsimply might be too slow. Node.js will internally queue up the data written to a\nsocket and send it out over the wire when it is possible.</p>\n<p>The consequence of this internal buffering is that memory may grow.\nUsers who experience large or growing <code>bufferSize</code> should attempt to\n\"throttle\" the data flows in their program with\n<a href=\"#net_socket_pause\"><code>socket.pause()</code></a> and <a href=\"#net_socket_resume\"><code>socket.resume()</code></a>.</p>"
             },
             {
@@ -1243,7 +1521,8 @@
               "name": "pending",
               "meta": {
                 "added": [
-                  "v11.2.0"
+                  "v11.2.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -1284,6 +1563,30 @@
                 "changes": []
               },
               "desc": "<p>The numeric representation of the remote port. For example, <code>80</code> or <code>21</code>.</p>"
+            },
+            {
+              "textRaw": "`timeout` {number|undefined}",
+              "type": "number|undefined",
+              "name": "timeout",
+              "meta": {
+                "added": [
+                  "v10.7.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The socket timeout in milliseconds as set by <a href=\"#net_socket_settimeout_timeout_callback\"><code>socket.setTimeout()</code></a>.\nIt is <code>undefined</code> if a timeout has not been set.</p>"
+            },
+            {
+              "textRaw": "`readyState` {string}",
+              "type": "string",
+              "name": "readyState",
+              "meta": {
+                "added": [
+                  "v0.5.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>This property represents the state of the connection as a string.</p>\n<ul>\n<li>If the stream is connecting <code>socket.readyState</code> is <code>opening</code>.</li>\n<li>If the stream is readable and writable, it is <code>open</code>.</li>\n<li>If the stream is readable and not writable, it is <code>readOnly</code>.</li>\n<li>If the stream is not readable and writable, it is <code>writeOnly</code>.</li>\n</ul>"
             }
           ],
           "signatures": [
@@ -1307,11 +1610,11 @@
                       "desc": "If specified, wrap around an existing socket with the given file descriptor, otherwise a new socket will be created."
                     },
                     {
-                      "textRaw": "`allowHalfOpen` {boolean} Indicates whether half-opened TCP connections are allowed. See [`net.createServer()`][] and the [`'end'`][] event for details. **Default:** `false`.",
+                      "textRaw": "`allowHalfOpen` {boolean} If set to `false`, then the socket will automatically end the writable side when the readable side ends. See [`net.createServer()`][] and the [`'end'`][] event for details. **Default:** `false`.",
                       "name": "allowHalfOpen",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "Indicates whether half-opened TCP connections are allowed. See [`net.createServer()`][] and the [`'end'`][] event for details."
+                      "desc": "If set to `false`, then the socket will automatically end the writable side when the readable side ends. See [`net.createServer()`][] and the [`'end'`][] event for details."
                     },
                     {
                       "textRaw": "`readable` {boolean} Allow reads on the socket when an `fd` is passed, otherwise ignored. **Default:** `false`.",
@@ -1605,11 +1908,11 @@
                   "type": "Object",
                   "options": [
                     {
-                      "textRaw": "`allowHalfOpen` {boolean} Indicates whether half-opened TCP connections are allowed. **Default:** `false`.",
+                      "textRaw": "`allowHalfOpen` {boolean} If set to `false`, then the socket will automatically end the writable side when the readable side ends. **Default:** `false`.",
                       "name": "allowHalfOpen",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "Indicates whether half-opened TCP connections are allowed."
+                      "desc": "If set to `false`, then the socket will automatically end the writable side when the readable side ends."
                     },
                     {
                       "textRaw": "`pauseOnConnect` {boolean} Indicates whether the socket should be paused on incoming connections. **Default:** `false`.",
@@ -1629,7 +1932,7 @@
               ]
             }
           ],
-          "desc": "<p>Creates a new TCP or <a href=\"#net_ipc_support\">IPC</a> server.</p>\n<p>If <code>allowHalfOpen</code> is set to <code>true</code>, when the other end of the socket\nsends a FIN packet, the server will only send a FIN packet back when\n<a href=\"#net_socket_end_data_encoding_callback\"><code>socket.end()</code></a> is explicitly called, until then the connection is\nhalf-closed (non-readable but still writable). See <a href=\"#net_event_end\"><code>'end'</code></a> event\nand <a href=\"https://tools.ietf.org/html/rfc1122\">RFC 1122</a> (section 4.2.2.13) for more information.</p>\n<p>If <code>pauseOnConnect</code> is set to <code>true</code>, then the socket associated with each\nincoming connection will be paused, and no data will be read from its handle.\nThis allows connections to be passed between processes without any data being\nread by the original process. To begin reading data from a paused socket, call\n<a href=\"#net_socket_resume\"><code>socket.resume()</code></a>.</p>\n<p>The server can be a TCP server or an <a href=\"#net_ipc_support\">IPC</a> server, depending on what it\n<a href=\"#net_server_listen\"><code>listen()</code></a> to.</p>\n<p>Here is an example of an TCP echo server which listens for connections\non port 8124:</p>\n<pre><code class=\"language-js\">const net = require('net');\nconst server = net.createServer((c) => {\n  // 'connection' listener.\n  console.log('client connected');\n  c.on('end', () => {\n    console.log('client disconnected');\n  });\n  c.write('hello\\r\\n');\n  c.pipe(c);\n});\nserver.on('error', (err) => {\n  throw err;\n});\nserver.listen(8124, () => {\n  console.log('server bound');\n});\n</code></pre>\n<p>Test this by using <code>telnet</code>:</p>\n<pre><code class=\"language-console\">$ telnet localhost 8124\n</code></pre>\n<p>To listen on the socket <code>/tmp/echo.sock</code>:</p>\n<pre><code class=\"language-js\">server.listen('/tmp/echo.sock', () => {\n  console.log('server bound');\n});\n</code></pre>\n<p>Use <code>nc</code> to connect to a Unix domain socket server:</p>\n<pre><code class=\"language-console\">$ nc -U /tmp/echo.sock\n</code></pre>"
+          "desc": "<p>Creates a new TCP or <a href=\"#net_ipc_support\">IPC</a> server.</p>\n<p>If <code>allowHalfOpen</code> is set to <code>true</code>, when the other end of the socket\nsignals the end of transmission, the server will only send back the end of\ntransmission when <a href=\"#net_socket_end_data_encoding_callback\"><code>socket.end()</code></a> is explicitly called. For example, in the\ncontext of TCP, when a FIN packed is received, a FIN packed is sent\nback only when <a href=\"#net_socket_end_data_encoding_callback\"><code>socket.end()</code></a> is explicitly called. Until then the\nconnection is half-closed (non-readable but still writable). See <a href=\"#net_event_end\"><code>'end'</code></a>\nevent and <a href=\"https://tools.ietf.org/html/rfc1122\">RFC 1122</a> (section 4.2.2.13) for more information.</p>\n<p>If <code>pauseOnConnect</code> is set to <code>true</code>, then the socket associated with each\nincoming connection will be paused, and no data will be read from its handle.\nThis allows connections to be passed between processes without any data being\nread by the original process. To begin reading data from a paused socket, call\n<a href=\"#net_socket_resume\"><code>socket.resume()</code></a>.</p>\n<p>The server can be a TCP server or an <a href=\"#net_ipc_support\">IPC</a> server, depending on what it\n<a href=\"#net_server_listen\"><code>listen()</code></a> to.</p>\n<p>Here is an example of an TCP echo server which listens for connections\non port 8124:</p>\n<pre><code class=\"language-js\">const net = require('net');\nconst server = net.createServer((c) => {\n  // 'connection' listener.\n  console.log('client connected');\n  c.on('end', () => {\n    console.log('client disconnected');\n  });\n  c.write('hello\\r\\n');\n  c.pipe(c);\n});\nserver.on('error', (err) => {\n  throw err;\n});\nserver.listen(8124, () => {\n  console.log('server bound');\n});\n</code></pre>\n<p>Test this by using <code>telnet</code>:</p>\n<pre><code class=\"language-console\">$ telnet localhost 8124\n</code></pre>\n<p>To listen on the socket <code>/tmp/echo.sock</code>:</p>\n<pre><code class=\"language-js\">server.listen('/tmp/echo.sock', () => {\n  console.log('server bound');\n});\n</code></pre>\n<p>Use <code>nc</code> to connect to a Unix domain socket server:</p>\n<pre><code class=\"language-console\">$ nc -U /tmp/echo.sock\n</code></pre>"
         },
         {
           "textRaw": "`net.isIP(input)`",
diff --git a/doc/api/net.md b/doc/api/net.md
index 956bed6c706a8a47903d1a634df17d480f2d4de6..abf57a570c30cb1bcddb338647d22152fec9d7ff 100644
--- a/doc/api/net.md
+++ b/doc/api/net.md
@@ -55,6 +55,132 @@ net.createServer().listen(
   path.join('\\\\?\\pipe', process.cwd(), 'myctl'));
 ```
 
+## Class: `net.BlockList`
+<!-- YAML
+added: v14.18.0
+-->
+
+The `BlockList` object can be used with some network APIs to specify rules for
+disabling inbound or outbound access to specific IP addresses, IP ranges, or
+IP subnets.
+
+### `blockList.addAddress(address[, type])`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `address` {string|net.SocketAddress} An IPv4 or IPv6 address.
+* `type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.
+
+Adds a rule to block the given IP address.
+
+### `blockList.addRange(start, end[, type])`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `start` {string|net.SocketAddress} The starting IPv4 or IPv6 address in the
+  range.
+* `end` {string|net.SocketAddress} The ending IPv4 or IPv6 address in the range.
+* `type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.
+
+Adds a rule to block a range of IP addresses from `start` (inclusive) to
+`end` (inclusive).
+
+### `blockList.addSubnet(net, prefix[, type])`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `net` {string|net.SocketAddress} The network IPv4 or IPv6 address.
+* `prefix` {number} The number of CIDR prefix bits. For IPv4, this
+  must be a value between `0` and `32`. For IPv6, this must be between
+  `0` and `128`.
+* `type` {string} Either `'ipv4'` or `'ipv6'`. **Default**: `'ipv4'`.
+
+Adds a rule to block a range of IP addresses specified as a subnet mask.
+
+### `blockList.check(address[, type])`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `address` {string|net.SocketAddress} The IP address to check
+* `type` {string} Either `'ipv4'` or `'ipv6'`. **Default:** `'ipv4'`.
+* Returns: {boolean}
+
+Returns `true` if the given IP address matches any of the rules added to the
+`BlockList`.
+
+```js
+const blockList = new net.BlockList();
+blockList.addAddress('123.123.123.123');
+blockList.addRange('10.0.0.1', '10.0.0.10');
+blockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');
+
+console.log(blockList.check('123.123.123.123'));  // Prints: true
+console.log(blockList.check('10.0.0.3'));  // Prints: true
+console.log(blockList.check('222.111.111.222'));  // Prints: false
+
+// IPv6 notation for IPv4 addresses works:
+console.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true
+console.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true
+```
+
+### `blockList.rules`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Type: {string[]}
+
+The list of rules added to the blocklist.
+
+## Class: `net.SocketAddress`
+<!-- YAML
+added: v14.18.0
+-->
+### `new net.SocketAddress([options])`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `options` {Object}
+  * `address` {string} The network address as either an IPv4 or IPv6 string.
+    **Default**: `'127.0.0.1'` if `family` is `'ipv4'`; `'::'` if `family` is
+    `'ipv6'`.
+  * `family` {string} One of either `'ipv4'` or 'ipv6'`. **Default**: `'ipv4'`.
+  * `flowlabel` {number} An IPv6 flow-label used only if `family` is `'ipv6'`.
+  * `port` {number} An IP port.
+
+### `socketaddress.address`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Type {string}
+
+### `socketaddress.family`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Type {string} Either `'ipv4'` or `'ipv6'`.
+
+### `socketaddress.flowlabel`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Type {number}
+
+### `socketaddress.port`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Type {number}
+
 ## Class: `net.Server`
 <!-- YAML
 added: v0.1.90
@@ -194,6 +320,7 @@ an [IPC][] server depending on what it listens to.
 
 Possible signatures:
 
+<!--lint disable no-undefined-references-->
 * [`server.listen(handle[, backlog][, callback])`][`server.listen(handle)`]
 * [`server.listen(options[, callback])`][`server.listen(options)`]
 * [`server.listen(path[, backlog][, callback])`][`server.listen(path)`]
@@ -201,6 +328,7 @@ Possible signatures:
 * <a href="#net_server_listen_port_host_backlog_callback">
   <code>server.listen([port[, host[, backlog]]][, callback])</code></a>
   for TCP servers
+<!--lint enable no-undefined-references-->
 
 This function is asynchronous. When the server starts listening, the
 [`'listening'`][] event will be emitted. The last parameter `callback`
@@ -282,12 +410,14 @@ changes:
   functions.
 * Returns: {net.Server}
 
+<!--lint disable no-undefined-references-->
 If `port` is specified, it behaves the same as
 <a href="#net_server_listen_port_host_backlog_callback">
 <code>server.listen([port[, host[, backlog]]][, callback])</code></a>.
 Otherwise, if `path` is specified, it behaves the same as
 [`server.listen(path[, backlog][, callback])`][`server.listen(path)`].
 If none of them is specified, an error will be thrown.
+<!--lint enable no-undefined-references-->
 
 If `exclusive` is `false` (default), then cluster workers will use the same
 underlying handle, allowing connection handling duties to be shared. When
@@ -415,9 +545,10 @@ added: v0.3.4
 * `options` {Object} Available options are:
   * `fd` {number} If specified, wrap around an existing socket with
     the given file descriptor, otherwise a new socket will be created.
-  * `allowHalfOpen` {boolean} Indicates whether half-opened TCP connections
-    are allowed. See [`net.createServer()`][] and the [`'end'`][] event
-    for details. **Default:** `false`.
+  * `allowHalfOpen` {boolean} If set to `false`, then the socket will
+    automatically end the writable side when the readable side ends. See
+    [`net.createServer()`][] and the [`'end'`][] event for details. **Default:**
+    `false`.
   * `readable` {boolean} Allow reads on the socket when an `fd` is passed,
     otherwise ignored. **Default:** `false`.
   * `writable` {boolean} Allow writes on the socket when an `fd` is passed,
@@ -474,14 +605,14 @@ See also: the return values of `socket.write()`.
 added: v0.1.90
 -->
 
-Emitted when the other end of the socket sends a FIN packet, thus ending the
-readable side of the socket.
+Emitted when the other end of the socket signals the end of transmission, thus
+ending the readable side of the socket.
 
-By default (`allowHalfOpen` is `false`) the socket will send a FIN packet
-back and destroy its file descriptor once it has written out its pending
-write queue. However, if `allowHalfOpen` is set to `true`, the socket will
-not automatically [`end()`][`socket.end()`] its writable side, allowing the
-user to write arbitrary amounts of data. The user must call
+By default (`allowHalfOpen` is `false`) the socket will send an end of
+transmission packet back and destroy its file descriptor once it has written out
+its pending write queue. However, if `allowHalfOpen` is set to `true`, the
+socket will not automatically [`end()`][`socket.end()`] its writable side,
+allowing the user to write arbitrary amounts of data. The user must call
 [`end()`][`socket.end()`] explicitly to close the connection (i.e. sending a
 FIN packet back).
 
@@ -545,8 +676,12 @@ socket as reported by the operating system:
 ### `socket.bufferSize`
 <!-- YAML
 added: v0.3.8
+deprecated:
+  - v14.6.0
 -->
 
+> Stability: 0 - Deprecated: Use [`writable.writableLength`][] instead.
+
 * {integer}
 
 This property shows the number of characters buffered for writing. The buffer
@@ -793,7 +928,9 @@ Useful to throttle back an upload.
 
 ### `socket.pending`
 <!-- YAML
-added: v11.2.0
+added:
+ - v11.2.0
+ - v10.16.0
 -->
 
 * {boolean}
@@ -862,6 +999,12 @@ Set the encoding for the socket as a [Readable Stream][]. See
 ### `socket.setKeepAlive([enable][, initialDelay])`
 <!-- YAML
 added: v0.1.92
+changes:
+  - version:
+    - v13.12.0
+    - v12.17.0
+    pr-url: https://github.com/nodejs/node/pull/32204
+    description: New defaults for `TCP_KEEPCNT` and `TCP_KEEPINTVL` socket options were added.
 -->
 
 * `enable` {boolean} **Default:** `false`
@@ -876,6 +1019,12 @@ data packet received and the first keepalive probe. Setting `0` for
 `initialDelay` will leave the value unchanged from the default
 (or previous) setting.
 
+Enabling the keep-alive functionality will set the following socket options:
+* `SO_KEEPALIVE=1`
+* `TCP_KEEPIDLE=initialDelay`
+* `TCP_KEEPCNT=10`
+* `TCP_KEEPINTVL=1`
+
 ### `socket.setNoDelay([noDelay])`
 <!-- YAML
 added: v0.1.90
@@ -924,6 +1073,16 @@ If `timeout` is 0, then the existing idle timeout is disabled.
 The optional `callback` parameter will be added as a one-time listener for the
 [`'timeout'`][] event.
 
+### `socket.timeout`
+<!-- YAML
+added: v10.7.0
+-->
+
+* {number|undefined}
+
+The socket timeout in milliseconds as set by [`socket.setTimeout()`][].
+It is `undefined` if a timeout has not been set.
+
 ### `socket.unref()`
 <!-- YAML
 added: v0.9.1
@@ -958,6 +1117,20 @@ written out, which may not be immediately.
 See `Writable` stream [`write()`][stream_writable_write] method for more
 information.
 
+### `socket.readyState`
+<!-- YAML
+added: v0.5.0
+-->
+
+* {string}
+
+This property represents the state of the connection as a string.
+
+* If the stream is connecting `socket.readyState` is `opening`.
+* If the stream is readable and writable, it is `open`.
+* If the stream is readable and not writable, it is `readOnly`.
+* If the stream is not readable and writable, it is `writeOnly`.
+
 ## `net.connect()`
 
 Aliases to
@@ -1127,8 +1300,9 @@ added: v0.5.0
 -->
 
 * `options` {Object}
-  * `allowHalfOpen` {boolean} Indicates whether half-opened TCP
-    connections are allowed. **Default:** `false`.
+  * `allowHalfOpen` {boolean} If set to `false`, then the socket will
+    automatically end the writable side when the readable side ends.
+    **Default:** `false`.
   * `pauseOnConnect` {boolean} Indicates whether the socket should be
     paused on incoming connections. **Default:** `false`.
 * `connectionListener` {Function} Automatically set as a listener for the
@@ -1138,10 +1312,12 @@ added: v0.5.0
 Creates a new TCP or [IPC][] server.
 
 If `allowHalfOpen` is set to `true`, when the other end of the socket
-sends a FIN packet, the server will only send a FIN packet back when
-[`socket.end()`][] is explicitly called, until then the connection is
-half-closed (non-readable but still writable). See [`'end'`][] event
-and [RFC 1122][half-closed] (section 4.2.2.13) for more information.
+signals the end of transmission, the server will only send back the end of
+transmission when [`socket.end()`][] is explicitly called. For example, in the
+context of TCP, when a FIN packed is received, a FIN packed is sent
+back only when [`socket.end()`][] is explicitly called. Until then the
+connection is half-closed (non-readable but still writable). See [`'end'`][]
+event and [RFC 1122][half-closed] (section 4.2.2.13) for more information.
 
 If `pauseOnConnect` is set to `true`, then the socket associated with each
 incoming connection will be paused, and no data will be read from its handle.
@@ -1228,7 +1404,7 @@ Returns `true` if input is a version 6 IP address, otherwise returns `false`.
 
 [IPC]: #net_ipc_support
 [Identifying paths for IPC connections]: #net_identifying_paths_for_ipc_connections
-[Readable Stream]: stream.html#stream_class_stream_readable
+[Readable Stream]: stream.md#stream_class_stream_readable
 [`'close'`]: #net_event_close
 [`'connect'`]: #net_event_connect
 [`'connection'`]: #net_event_connection
@@ -1238,10 +1414,10 @@ Returns `true` if input is a version 6 IP address, otherwise returns `false`.
 [`'error'`]: #net_event_error_1
 [`'listening'`]: #net_event_listening
 [`'timeout'`]: #net_event_timeout
-[`EventEmitter`]: events.html#events_class_eventemitter
-[`child_process.fork()`]: child_process.html#child_process_child_process_fork_modulepath_args_options
-[`dns.lookup()` hints]: dns.html#dns_supported_getaddrinfo_flags
-[`dns.lookup()`]: dns.html#dns_dns_lookup_hostname_options_callback
+[`EventEmitter`]: events.md#events_class_eventemitter
+[`child_process.fork()`]: child_process.md#child_process_child_process_fork_modulepath_args_options
+[`dns.lookup()`]: dns.md#dns_dns_lookup_hostname_options_callback
+[`dns.lookup()` hints]: dns.md#dns_supported_getaddrinfo_flags
 [`net.Server`]: #net_class_net_server
 [`net.Socket`]: #net_class_net_socket
 [`net.connect()`]: #net_net_connect
@@ -1254,7 +1430,7 @@ Returns `true` if input is a version 6 IP address, otherwise returns `false`.
 [`net.createConnection(port, host)`]: #net_net_createconnection_port_host_connectlistener
 [`net.createServer()`]: #net_net_createserver_options_connectionlistener
 [`new net.Socket(options)`]: #net_new_net_socket_options
-[`readable.setEncoding()`]: stream.html#stream_readable_setencoding_encoding
+[`readable.setEncoding()`]: stream.md#stream_readable_setencoding_encoding
 [`server.close()`]: #net_server_close_callback
 [`server.getConnections()`]: #net_server_getconnections_callback
 [`server.listen()`]: #net_server_listen
@@ -1274,10 +1450,11 @@ Returns `true` if input is a version 6 IP address, otherwise returns `false`.
 [`socket.setEncoding()`]: #net_socket_setencoding_encoding
 [`socket.setTimeout()`]: #net_socket_settimeout_timeout_callback
 [`socket.setTimeout(timeout)`]: #net_socket_settimeout_timeout_callback
-[`writable.destroyed`]: stream.html#stream_writable_destroyed
-[`writable.destroy()`]: stream.html#stream_writable_destroy_error
-[`writable.end()`]: stream.html#stream_writable_end_chunk_encoding_callback
+[`writable.destroy()`]: stream.md#stream_writable_destroy_error
+[`writable.destroyed`]: stream.md#stream_writable_destroyed
+[`writable.end()`]: stream.md#stream_writable_end_chunk_encoding_callback
+[`writable.writableLength`]: stream.md#stream_writable_writablelength
 [half-closed]: https://tools.ietf.org/html/rfc1122
-[stream_writable_write]: stream.html#stream_writable_write_chunk_encoding_callback
+[stream_writable_write]: stream.md#stream_writable_write_chunk_encoding_callback
 [unspecified IPv4 address]: https://en.wikipedia.org/wiki/0.0.0.0
 [unspecified IPv6 address]: https://en.wikipedia.org/wiki/IPv6_address#Unspecified_address
diff --git a/doc/api/os.html b/doc/api/os.html
index e3ad9211ebfa5d1ed545250536c431e5ff795262..93f8d7aac849714d9330910b8c339bc228cd3ac8 100644
--- a/doc/api/os.html
+++ b/doc/api/os.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>OS | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>OS | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="os" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/os.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/os.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/os.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/os.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/os.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/os.html">13.x</a></li>
@@ -118,21 +133,20 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/os.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/os.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/os.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#os_os">OS</a></span>
 <ul>
 <li><a href="#os_os_eol"><code>os.EOL</code></a></li>
 <li><a href="#os_os_arch"><code>os.arch()</code></a></li>
 <li><a href="#os_os_constants"><code>os.constants</code></a></li>
 <li><a href="#os_os_cpus"><code>os.cpus()</code></a></li>
+<li><a href="#os_os_devnull"><code>os.devNull</code></a></li>
 <li><a href="#os_os_endianness"><code>os.endianness()</code></a></li>
 <li><a href="#os_os_freemem"><code>os.freemem()</code></a></li>
 <li><a href="#os_os_getpriority_pid"><code>os.getPriority([pid])</code></a></li>
@@ -165,18 +179,17 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>OS<span><a class="mark" href="#os_os" id="os_os">#</a></span></h1>
+        <h2>OS<span><a class="mark" href="#os_os" id="os_os">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/os.js">lib/os.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/os.js">lib/os.js</a></p>
 <p>The <code>os</code> module provides operating system-related utility methods and
 properties. It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> os = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>);</code></pre>
-<h2><code>os.EOL</code><span><a class="mark" href="#os_os_eol" id="os_os_eol">#</a></span></h2>
+<section><h3><code>os.EOL</code><span><a class="mark" href="#os_os_eol" id="os_os_eol">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.8</span>
 </div>
@@ -188,7 +201,7 @@ properties. It can be accessed using:</p>
 <li><code>\n</code> on POSIX</li>
 <li><code>\r\n</code> on Windows</li>
 </ul>
-<h2><code>os.arch()</code><span><a class="mark" href="#os_os_arch" id="os_os_arch">#</a></span></h2>
+</section><section><h3><code>os.arch()</code><span><a class="mark" href="#os_os_arch" id="os_os_arch">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -199,7 +212,7 @@ properties. It can be accessed using:</p>
 compiled. Possible values are <code>'arm'</code>, <code>'arm64'</code>, <code>'ia32'</code>, <code>'mips'</code>,
 <code>'mipsel'</code>, <code>'ppc'</code>, <code>'ppc64'</code>, <code>'s390'</code>, <code>'s390x'</code>, <code>'x32'</code>, and <code>'x64'</code>.</p>
 <p>The return value is equivalent to <a href="process.html#process_process_arch"><code>process.arch</code></a>.</p>
-<h2><code>os.constants</code><span><a class="mark" href="#os_os_constants" id="os_os_constants">#</a></span></h2>
+</section><section><h3><code>os.constants</code><span><a class="mark" href="#os_os_constants" id="os_os_constants">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.3.0</span>
 </div>
@@ -209,7 +222,7 @@ compiled. Possible values are <code>'arm'</code>, <code>'arm64'</code>, <code>'i
 <p>Contains commonly used operating system-specific constants for error codes,
 process signals, and so on. The specific constants defined are described in
 <a href="#os_os_constants_1">OS constants</a>.</p>
-<h2><code>os.cpus()</code><span><a class="mark" href="#os_os_cpus" id="os_os_cpus">#</a></span></h2>
+</section><section><h3><code>os.cpus()</code><span><a class="mark" href="#os_os_cpus" id="os_os_cpus">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -276,11 +289,23 @@ process signals, and so on. The specific constants defined are described in
       <span class="hljs-attr">idle</span>: <span class="hljs-number">1070905480</span>,
       <span class="hljs-attr">irq</span>: <span class="hljs-number">20</span>
     }
-  }
+  },
 ]</code></pre>
 <p><code>nice</code> values are POSIX-only. On Windows, the <code>nice</code> values of all processors
 are always 0.</p>
-<h2><code>os.endianness()</code><span><a class="mark" href="#os_os_endianness" id="os_os_endianness">#</a></span></h2>
+</section><section><h3><code>os.devNull</code><span><a class="mark" href="#os_os_devnull" id="os_os_devnull">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>The platform-specific file path of the null device.</p>
+<ul>
+<li><code>\\.\nul</code> on Windows</li>
+<li><code>/dev/null</code> on POSIX</li>
+</ul>
+</section><section><h3><code>os.endianness()</code><span><a class="mark" href="#os_os_endianness" id="os_os_endianness">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -290,7 +315,7 @@ are always 0.</p>
 <p>Returns a string identifying the endianness of the CPU for which the Node.js
 binary was compiled.</p>
 <p>Possible values are <code>'BE'</code> for big endian and <code>'LE'</code> for little endian.</p>
-<h2><code>os.freemem()</code><span><a class="mark" href="#os_os_freemem" id="os_os_freemem">#</a></span></h2>
+</section><section><h3><code>os.freemem()</code><span><a class="mark" href="#os_os_freemem" id="os_os_freemem">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -298,7 +323,7 @@ binary was compiled.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Returns the amount of free system memory in bytes as an integer.</p>
-<h2><code>os.getPriority([pid])</code><span><a class="mark" href="#os_os_getpriority_pid" id="os_os_getpriority_pid">#</a></span></h2>
+</section><section><h3><code>os.getPriority([pid])</code><span><a class="mark" href="#os_os_getpriority_pid" id="os_os_getpriority_pid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.10.0</span>
 </div>
@@ -309,7 +334,7 @@ binary was compiled.</p>
 </ul>
 <p>Returns the scheduling priority for the process specified by <code>pid</code>. If <code>pid</code> is
 not provided or is <code>0</code>, the priority of the current process is returned.</p>
-<h2><code>os.homedir()</code><span><a class="mark" href="#os_os_homedir" id="os_os_homedir">#</a></span></h2>
+</section><section><h3><code>os.homedir()</code><span><a class="mark" href="#os_os_homedir" id="os_os_homedir">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.3.0</span>
 </div>
@@ -321,7 +346,7 @@ not provided or is <code>0</code>, the priority of the current process is return
 uses the <a href="https://en.wikipedia.org/wiki/User_identifier#Effective_user_ID">effective UID</a> to look up the user's home directory.</p>
 <p>On Windows, it uses the <code>USERPROFILE</code> environment variable if defined.
 Otherwise it uses the path to the profile directory of the current user.</p>
-<h2><code>os.hostname()</code><span><a class="mark" href="#os_os_hostname" id="os_os_hostname">#</a></span></h2>
+</section><section><h3><code>os.hostname()</code><span><a class="mark" href="#os_os_hostname" id="os_os_hostname">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -329,7 +354,7 @@ Otherwise it uses the path to the profile directory of the current user.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Returns the host name of the operating system as a string.</p>
-<h2><code>os.loadavg()</code><span><a class="mark" href="#os_os_loadavg" id="os_os_loadavg">#</a></span></h2>
+</section><section><h3><code>os.loadavg()</code><span><a class="mark" href="#os_os_loadavg" id="os_os_loadavg">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -341,7 +366,7 @@ Otherwise it uses the path to the profile directory of the current user.</p>
 system and expressed as a fractional number.</p>
 <p>The load average is a Unix-specific concept. On Windows, the return value is
 always <code>[0, 0, 0]</code>.</p>
-<h2><code>os.networkInterfaces()</code><span><a class="mark" href="#os_os_networkinterfaces" id="os_os_networkinterfaces">#</a></span></h2>
+</section><section><h3><code>os.networkInterfaces()</code><span><a class="mark" href="#os_os_networkinterfaces" id="os_os_networkinterfaces">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span>
 </div>
@@ -407,7 +432,7 @@ to <code>null</code>.</li>
     }
   ]
 }</code></pre>
-<h2><code>os.platform()</code><span><a class="mark" href="#os_os_platform" id="os_os_platform">#</a></span></h2>
+</section><section><h3><code>os.platform()</code><span><a class="mark" href="#os_os_platform" id="os_os_platform">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -419,8 +444,8 @@ at compile time. Possible values are <code>'aix'</code>, <code>'darwin'</code>,
 <code>'linux'</code>, <code>'openbsd'</code>, <code>'sunos'</code>, and <code>'win32'</code>.</p>
 <p>The return value is equivalent to <a href="process.html#process_process_platform"><code>process.platform</code></a>.</p>
 <p>The value <code>'android'</code> may also be returned if Node.js is built on the Android
-operating system. <a href="https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os">Android support is experimental</a>.</p>
-<h2><code>os.release()</code><span><a class="mark" href="#os_os_release" id="os_os_release">#</a></span></h2>
+operating system. <a href="https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os">Android support is experimental</a>.</p>
+</section><section><h3><code>os.release()</code><span><a class="mark" href="#os_os_release" id="os_os_release">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -431,7 +456,7 @@ operating system. <a href="https://github.com/nodejs/node/blob/master/BUILDING.m
 <p>On POSIX systems, the operating system release is determined by calling
 <a href="https://linux.die.net/man/3/uname"><code>uname(3)</code></a>. On Windows, <code>GetVersionExW()</code> is used. See
 <a href="https://en.wikipedia.org/wiki/Uname#Examples">https://en.wikipedia.org/wiki/Uname#Examples</a> for more information.</p>
-<h2><code>os.setPriority([pid, ]priority)</code><span><a class="mark" href="#os_os_setpriority_pid_priority" id="os_os_setpriority_pid_priority">#</a></span></h2>
+</section><section><h3><code>os.setPriority([pid, ]priority)</code><span><a class="mark" href="#os_os_setpriority_pid_priority" id="os_os_setpriority_pid_priority">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.10.0</span>
 </div>
@@ -451,13 +476,13 @@ confusion, set <code>priority</code> to one of the priority constants.</p>
 <p>On Windows, setting priority to <code>PRIORITY_HIGHEST</code> requires elevated user
 privileges. Otherwise the set priority will be silently reduced to
 <code>PRIORITY_HIGH</code>.</p>
-<h2><code>os.tmpdir()</code><span><a class="mark" href="#os_os_tmpdir" id="os_os_tmpdir">#</a></span></h2>
+</section><section><h3><code>os.tmpdir()</code><span><a class="mark" href="#os_os_tmpdir" id="os_os_tmpdir">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v2.0.0</td>
-<td><p>This function is now cross-platform consistent and no longer returns a path with a trailing slash on any platform</p></td></tr>
+<td><p>This function is now cross-platform consistent and no longer returns a path with a trailing slash on any platform.</p></td></tr>
 <tr><td>v0.9.9</td>
 <td><p><span>Added in: v0.9.9</span></p></td></tr>
 </tbody></table>
@@ -468,7 +493,7 @@ privileges. Otherwise the set priority will be silently reduced to
 </ul>
 <p>Returns the operating system's default directory for temporary files as a
 string.</p>
-<h2><code>os.totalmem()</code><span><a class="mark" href="#os_os_totalmem" id="os_os_totalmem">#</a></span></h2>
+</section><section><h3><code>os.totalmem()</code><span><a class="mark" href="#os_os_totalmem" id="os_os_totalmem">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -476,7 +501,7 @@ string.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Returns the total amount of system memory in bytes as an integer.</p>
-<h2><code>os.type()</code><span><a class="mark" href="#os_os_type" id="os_os_type">#</a></span></h2>
+</section><section><h3><code>os.type()</code><span><a class="mark" href="#os_os_type" id="os_os_type">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
@@ -487,7 +512,7 @@ string.</p>
 returns <code>'Linux'</code> on Linux, <code>'Darwin'</code> on macOS, and <code>'Windows_NT'</code> on Windows.</p>
 <p>See <a href="https://en.wikipedia.org/wiki/Uname#Examples">https://en.wikipedia.org/wiki/Uname#Examples</a> for additional information
 about the output of running <a href="https://linux.die.net/man/3/uname"><code>uname(3)</code></a> on various operating systems.</p>
-<h2><code>os.uptime()</code><span><a class="mark" href="#os_os_uptime" id="os_os_uptime">#</a></span></h2>
+</section><section><h3><code>os.uptime()</code><span><a class="mark" href="#os_os_uptime" id="os_os_uptime">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -503,7 +528,7 @@ about the output of running <a href="https://linux.die.net/man/3/uname"><code>un
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Returns the system uptime in number of seconds.</p>
-<h2><code>os.userInfo([options])</code><span><a class="mark" href="#os_os_userinfo_options" id="os_os_userinfo_options">#</a></span></h2>
+</section><section><h3><code>os.userInfo([options])</code><span><a class="mark" href="#os_os_userinfo_options" id="os_os_userinfo_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -526,9 +551,9 @@ system. This differs from the result of <code>os.homedir()</code>, which queries
 environment variables for the home directory before falling back to the
 operating system response.</p>
 <p>Throws a <a href="errors.html#errors_class_systemerror"><code>SystemError</code></a> if a user has no <code>username</code> or <code>homedir</code>.</p>
-<h2><code>os.version()</code><span><a class="mark" href="#os_os_version" id="os_os_version">#</a></span></h2>
+</section><section><h3><code>os.version()</code><span><a class="mark" href="#os_os_version" id="os_os_version">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.11.0</span>
 </div>
 <ul>
 <li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -538,10 +563,10 @@ operating system response.</p>
 <a href="https://linux.die.net/man/3/uname"><code>uname(3)</code></a>. On Windows, <code>RtlGetVersion()</code> is used, and if it is not
 available, <code>GetVersionExW()</code> will be used. See
 <a href="https://en.wikipedia.org/wiki/Uname#Examples">https://en.wikipedia.org/wiki/Uname#Examples</a> for more information.</p>
-<h2>OS constants<span><a class="mark" href="#os_os_constants_1" id="os_os_constants_1">#</a></span></h2>
+</section><section><h3>OS constants<span><a class="mark" href="#os_os_constants_1" id="os_os_constants_1">#</a></span></h3>
 <p>The following constants are exported by <code>os.constants</code>.</p>
 <p>Not all constants will be available on every operating system.</p>
-<h3>Signal constants<span><a class="mark" href="#os_signal_constants" id="os_signal_constants">#</a></span></h3>
+<h4>Signal constants<span><a class="mark" href="#os_signal_constants" id="os_signal_constants">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -565,7 +590,7 @@ available, <code>GetVersionExW()</code> will be used. See
   <tr>
     <td><code>SIGINT</code></td>
     <td>Sent to indicate when a user wishes to interrupt a process
-    (<code>(Ctrl+C)</code>).</td>
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>).</td>
   </tr>
   <tr>
     <td><code>SIGQUIT</code></td>
@@ -712,9 +737,9 @@ available, <code>GetVersionExW()</code> will be used. See
     <td>Synonym for <code>SIGSYS</code></td>
   </tr>
 </tbody></table>
-<h3>Error constants<span><a class="mark" href="#os_error_constants" id="os_error_constants">#</a></span></h3>
+<h4>Error constants<span><a class="mark" href="#os_error_constants" id="os_error_constants">#</a></span></h4>
 <p>The following error constants are exported by <code>os.constants.errno</code>.</p>
-<h4>POSIX error constants<span><a class="mark" href="#os_posix_error_constants" id="os_posix_error_constants">#</a></span></h4>
+<h5>POSIX error constants<span><a class="mark" href="#os_posix_error_constants" id="os_posix_error_constants">#</a></span></h5>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -1044,7 +1069,7 @@ available, <code>GetVersionExW()</code> will be used. See
     <td>Indicates an improper link.
   </td></tr>
 </tbody></table>
-<h4>Windows-specific error constants<span><a class="mark" href="#os_windows_specific_error_constants" id="os_windows_specific_error_constants">#</a></span></h4>
+<h5>Windows-specific error constants<span><a class="mark" href="#os_windows_specific_error_constants" id="os_windows_specific_error_constants">#</a></span></h5>
 <p>The following error codes are specific to the Windows operating system.</p>
 <table>
   <tbody><tr>
@@ -1286,7 +1311,7 @@ available, <code>GetVersionExW()</code> will be used. See
     <td>Indicates that a database query was refused.</td>
   </tr>
 </tbody></table>
-<h3>dlopen constants<span><a class="mark" href="#os_dlopen_constants" id="os_dlopen_constants">#</a></span></h3>
+<h4>dlopen constants<span><a class="mark" href="#os_dlopen_constants" id="os_dlopen_constants">#</a></span></h4>
 <p>If available on the operating system, the following constants
 are exported in <code>os.constants.dlopen</code>. See <a href="http://man7.org/linux/man-pages/man3/dlopen.3.html"><code>dlopen(3)</code></a> for detailed
 information.</p>
@@ -1320,7 +1345,7 @@ information.</p>
     symbols from previously loaded libraries.</td>
   </tr>
 </tbody></table>
-<h3>Priority constants<span><a class="mark" href="#os_priority_constants" id="os_priority_constants">#</a></span></h3>
+<h4>Priority constants<span><a class="mark" href="#os_priority_constants" id="os_priority_constants">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.10.0</span>
 </div>
@@ -1371,7 +1396,7 @@ information.</p>
     <code>-20</code> on all other platforms.</td>
   </tr>
 </tbody></table>
-<h3>libuv constants<span><a class="mark" href="#os_libuv_constants" id="os_libuv_constants">#</a></span></h3>
+<h4>libuv constants<span><a class="mark" href="#os_libuv_constants" id="os_libuv_constants">#</a></span></h4>
 <table>
   <tbody><tr>
     <th>Constant</th>
@@ -1381,10 +1406,46 @@ information.</p>
     <td><code>UV_UDP_REUSEADDR</code></td>
     <td></td>
   </tr>
-</tbody></table>
+</tbody></table></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/os.json b/doc/api/os.json
index a01b4b97be60a9f927bc9abea7d72597a1977da9..74342810c5a682026345cb4db6d7d37dc7a11cd2 100644
--- a/doc/api/os.json
+++ b/doc/api/os.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/os.js\">lib/os.js</a></p>\n<p>The <code>os</code> module provides operating system-related utility methods and\nproperties. It can be accessed using:</p>\n<pre><code class=\"language-js\">const os = require('os');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/os.js\">lib/os.js</a></p>\n<p>The <code>os</code> module provides operating system-related utility methods and\nproperties. It can be accessed using:</p>\n<pre><code class=\"language-js\">const os = require('os');\n</code></pre>",
       "properties": [
         {
           "textRaw": "`EOL` {string}",
@@ -33,6 +33,18 @@
             "changes": []
           },
           "desc": "<p>Contains commonly used operating system-specific constants for error codes,\nprocess signals, and so on. The specific constants defined are described in\n<a href=\"#os_os_constants_1\">OS constants</a>.</p>"
+        },
+        {
+          "textRaw": "`devNull` {string}",
+          "type": "string",
+          "name": "devNull",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>The platform-specific file path of the null device.</p>\n<ul>\n<li><code>\\\\.\\nul</code> on Windows</li>\n<li><code>/dev/null</code> on POSIX</li>\n</ul>"
         }
       ],
       "methods": [
@@ -78,7 +90,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns an array of objects containing information about each logical CPU core.</p>\n<p>The properties included on each object include:</p>\n<ul>\n<li><code>model</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>speed</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> (in MHz)</li>\n<li><code>times</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>user</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in user mode.</li>\n<li><code>nice</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in nice mode.</li>\n<li><code>sys</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in sys mode.</li>\n<li><code>idle</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in idle mode.</li>\n<li><code>irq</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in irq mode.</li>\n</ul>\n</li>\n</ul>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 252020,\n      nice: 0,\n      sys: 30340,\n      idle: 1070356870,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 306960,\n      nice: 0,\n      sys: 26980,\n      idle: 1071569080,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 248450,\n      nice: 0,\n      sys: 21750,\n      idle: 1070919370,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 256880,\n      nice: 0,\n      sys: 19430,\n      idle: 1070905480,\n      irq: 20\n    }\n  }\n]\n</code></pre>\n<p><code>nice</code> values are POSIX-only. On Windows, the <code>nice</code> values of all processors\nare always 0.</p>"
+          "desc": "<p>Returns an array of objects containing information about each logical CPU core.</p>\n<p>The properties included on each object include:</p>\n<ul>\n<li><code>model</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>speed</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> (in MHz)</li>\n<li><code>times</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a>\n<ul>\n<li><code>user</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in user mode.</li>\n<li><code>nice</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in nice mode.</li>\n<li><code>sys</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in sys mode.</li>\n<li><code>idle</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in idle mode.</li>\n<li><code>irq</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The number of milliseconds the CPU has spent in irq mode.</li>\n</ul>\n</li>\n</ul>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">[\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 252020,\n      nice: 0,\n      sys: 30340,\n      idle: 1070356870,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 306960,\n      nice: 0,\n      sys: 26980,\n      idle: 1071569080,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 248450,\n      nice: 0,\n      sys: 21750,\n      idle: 1070919370,\n      irq: 0\n    }\n  },\n  {\n    model: 'Intel(R) Core(TM) i7 CPU         860  @ 2.80GHz',\n    speed: 2926,\n    times: {\n      user: 256880,\n      nice: 0,\n      sys: 19430,\n      idle: 1070905480,\n      irq: 20\n    }\n  },\n]\n</code></pre>\n<p><code>nice</code> values are POSIX-only. On Windows, the <code>nice</code> values of all processors\nare always 0.</p>"
         },
         {
           "textRaw": "`os.endianness()`",
@@ -261,7 +273,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns a string identifying the operating system platform. The value is set\nat compile time. Possible values are <code>'aix'</code>, <code>'darwin'</code>, <code>'freebsd'</code>,\n<code>'linux'</code>, <code>'openbsd'</code>, <code>'sunos'</code>, and <code>'win32'</code>.</p>\n<p>The return value is equivalent to <a href=\"process.html#process_process_platform\"><code>process.platform</code></a>.</p>\n<p>The value <code>'android'</code> may also be returned if Node.js is built on the Android\noperating system. <a href=\"https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os\">Android support is experimental</a>.</p>"
+          "desc": "<p>Returns a string identifying the operating system platform. The value is set\nat compile time. Possible values are <code>'aix'</code>, <code>'darwin'</code>, <code>'freebsd'</code>,\n<code>'linux'</code>, <code>'openbsd'</code>, <code>'sunos'</code>, and <code>'win32'</code>.</p>\n<p>The return value is equivalent to <a href=\"process.html#process_process_platform\"><code>process.platform</code></a>.</p>\n<p>The value <code>'android'</code> may also be returned if Node.js is built on the Android\noperating system. <a href=\"https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os\">Android support is experimental</a>.</p>"
         },
         {
           "textRaw": "`os.release()`",
@@ -327,7 +339,7 @@
               {
                 "version": "v2.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/747",
-                "description": "This function is now cross-platform consistent and no longer returns a path with a trailing slash on any platform"
+                "description": "This function is now cross-platform consistent and no longer returns a path with a trailing slash on any platform."
               }
             ]
           },
@@ -458,7 +470,7 @@
           "name": "version",
           "meta": {
             "added": [
-              "v12.17.0"
+              "v13.11.0"
             ],
             "changes": []
           },
@@ -493,7 +505,7 @@
                   }
                 ]
               },
-              "desc": "<p>The following signal constants are exported by <code>os.constants.signals</code>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>SIGHUP</code></td>\n    <td>Sent to indicate when a controlling terminal is closed or a parent\n    process exits.</td>\n  </tr>\n  <tr>\n    <td><code>SIGINT</code></td>\n    <td>Sent to indicate when a user wishes to interrupt a process\n    (<code>(Ctrl+C)</code>).</td>\n  </tr>\n  <tr>\n    <td><code>SIGQUIT</code></td>\n    <td>Sent to indicate when a user wishes to terminate a process and perform a\n    core dump.</td>\n  </tr>\n  <tr>\n    <td><code>SIGILL</code></td>\n    <td>Sent to a process to notify that it has attempted to perform an illegal,\n    malformed, unknown, or privileged instruction.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTRAP</code></td>\n    <td>Sent to a process when an exception has occurred.</td>\n  </tr>\n  <tr>\n    <td><code>SIGABRT</code></td>\n    <td>Sent to a process to request that it abort.</td>\n  </tr>\n  <tr>\n    <td><code>SIGIOT</code></td>\n    <td>Synonym for <code>SIGABRT</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGBUS</code></td>\n    <td>Sent to a process to notify that it has caused a bus error.</td>\n  </tr>\n  <tr>\n    <td><code>SIGFPE</code></td>\n    <td>Sent to a process to notify that it has performed an illegal arithmetic\n    operation.</td>\n  </tr>\n  <tr>\n    <td><code>SIGKILL</code></td>\n    <td>Sent to a process to terminate it immediately.</td>\n  </tr>\n  <tr>\n    <td><code>SIGUSR1</code> <code>SIGUSR2</code></td>\n    <td>Sent to a process to identify user-defined conditions.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSEGV</code></td>\n    <td>Sent to a process to notify of a segmentation fault.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPIPE</code></td>\n    <td>Sent to a process when it has attempted to write to a disconnected\n    pipe.</td>\n  </tr>\n  <tr>\n    <td><code>SIGALRM</code></td>\n    <td>Sent to a process when a system timer elapses.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTERM</code></td>\n    <td>Sent to a process to request termination.</td>\n  </tr>\n  <tr>\n    <td><code>SIGCHLD</code></td>\n    <td>Sent to a process when a child process terminates.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSTKFLT</code></td>\n    <td>Sent to a process to indicate a stack fault on a coprocessor.</td>\n  </tr>\n  <tr>\n    <td><code>SIGCONT</code></td>\n    <td>Sent to instruct the operating system to continue a paused process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSTOP</code></td>\n    <td>Sent to instruct the operating system to halt a process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTSTP</code></td>\n    <td>Sent to a process to request it to stop.</td>\n  </tr>\n  <tr>\n    <td><code>SIGBREAK</code></td>\n    <td>Sent to indicate when a user wishes to interrupt a process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTTIN</code></td>\n    <td>Sent to a process when it reads from the TTY while in the\n    background.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTTOU</code></td>\n    <td>Sent to a process when it writes to the TTY while in the\n    background.</td>\n  </tr>\n  <tr>\n    <td><code>SIGURG</code></td>\n    <td>Sent to a process when a socket has urgent data to read.</td>\n  </tr>\n  <tr>\n    <td><code>SIGXCPU</code></td>\n    <td>Sent to a process when it has exceeded its limit on CPU usage.</td>\n  </tr>\n  <tr>\n    <td><code>SIGXFSZ</code></td>\n    <td>Sent to a process when it grows a file larger than the maximum\n    allowed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGVTALRM</code></td>\n    <td>Sent to a process when a virtual timer has elapsed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPROF</code></td>\n    <td>Sent to a process when a system timer has elapsed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGWINCH</code></td>\n    <td>Sent to a process when the controlling terminal has changed its\n    size.</td>\n  </tr>\n  <tr>\n    <td><code>SIGIO</code></td>\n    <td>Sent to a process when I/O is available.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPOLL</code></td>\n    <td>Synonym for <code>SIGIO</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGLOST</code></td>\n    <td>Sent to a process when a file lock has been lost.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPWR</code></td>\n    <td>Sent to a process to notify of a power failure.</td>\n  </tr>\n  <tr>\n    <td><code>SIGINFO</code></td>\n    <td>Synonym for <code>SIGPWR</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGSYS</code></td>\n    <td>Sent to a process to notify of a bad argument.</td>\n  </tr>\n  <tr>\n    <td><code>SIGUNUSED</code></td>\n    <td>Synonym for <code>SIGSYS</code></td>\n  </tr>\n</table>",
+              "desc": "<p>The following signal constants are exported by <code>os.constants.signals</code>.</p>\n<table>\n  <tr>\n    <th>Constant</th>\n    <th>Description</th>\n  </tr>\n  <tr>\n    <td><code>SIGHUP</code></td>\n    <td>Sent to indicate when a controlling terminal is closed or a parent\n    process exits.</td>\n  </tr>\n  <tr>\n    <td><code>SIGINT</code></td>\n    <td>Sent to indicate when a user wishes to interrupt a process\n    (<kbd>Ctrl</kbd>+<kbd>C</kbd>).</td>\n  </tr>\n  <tr>\n    <td><code>SIGQUIT</code></td>\n    <td>Sent to indicate when a user wishes to terminate a process and perform a\n    core dump.</td>\n  </tr>\n  <tr>\n    <td><code>SIGILL</code></td>\n    <td>Sent to a process to notify that it has attempted to perform an illegal,\n    malformed, unknown, or privileged instruction.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTRAP</code></td>\n    <td>Sent to a process when an exception has occurred.</td>\n  </tr>\n  <tr>\n    <td><code>SIGABRT</code></td>\n    <td>Sent to a process to request that it abort.</td>\n  </tr>\n  <tr>\n    <td><code>SIGIOT</code></td>\n    <td>Synonym for <code>SIGABRT</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGBUS</code></td>\n    <td>Sent to a process to notify that it has caused a bus error.</td>\n  </tr>\n  <tr>\n    <td><code>SIGFPE</code></td>\n    <td>Sent to a process to notify that it has performed an illegal arithmetic\n    operation.</td>\n  </tr>\n  <tr>\n    <td><code>SIGKILL</code></td>\n    <td>Sent to a process to terminate it immediately.</td>\n  </tr>\n  <tr>\n    <td><code>SIGUSR1</code> <code>SIGUSR2</code></td>\n    <td>Sent to a process to identify user-defined conditions.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSEGV</code></td>\n    <td>Sent to a process to notify of a segmentation fault.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPIPE</code></td>\n    <td>Sent to a process when it has attempted to write to a disconnected\n    pipe.</td>\n  </tr>\n  <tr>\n    <td><code>SIGALRM</code></td>\n    <td>Sent to a process when a system timer elapses.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTERM</code></td>\n    <td>Sent to a process to request termination.</td>\n  </tr>\n  <tr>\n    <td><code>SIGCHLD</code></td>\n    <td>Sent to a process when a child process terminates.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSTKFLT</code></td>\n    <td>Sent to a process to indicate a stack fault on a coprocessor.</td>\n  </tr>\n  <tr>\n    <td><code>SIGCONT</code></td>\n    <td>Sent to instruct the operating system to continue a paused process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGSTOP</code></td>\n    <td>Sent to instruct the operating system to halt a process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTSTP</code></td>\n    <td>Sent to a process to request it to stop.</td>\n  </tr>\n  <tr>\n    <td><code>SIGBREAK</code></td>\n    <td>Sent to indicate when a user wishes to interrupt a process.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTTIN</code></td>\n    <td>Sent to a process when it reads from the TTY while in the\n    background.</td>\n  </tr>\n  <tr>\n    <td><code>SIGTTOU</code></td>\n    <td>Sent to a process when it writes to the TTY while in the\n    background.</td>\n  </tr>\n  <tr>\n    <td><code>SIGURG</code></td>\n    <td>Sent to a process when a socket has urgent data to read.</td>\n  </tr>\n  <tr>\n    <td><code>SIGXCPU</code></td>\n    <td>Sent to a process when it has exceeded its limit on CPU usage.</td>\n  </tr>\n  <tr>\n    <td><code>SIGXFSZ</code></td>\n    <td>Sent to a process when it grows a file larger than the maximum\n    allowed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGVTALRM</code></td>\n    <td>Sent to a process when a virtual timer has elapsed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPROF</code></td>\n    <td>Sent to a process when a system timer has elapsed.</td>\n  </tr>\n  <tr>\n    <td><code>SIGWINCH</code></td>\n    <td>Sent to a process when the controlling terminal has changed its\n    size.</td>\n  </tr>\n  <tr>\n    <td><code>SIGIO</code></td>\n    <td>Sent to a process when I/O is available.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPOLL</code></td>\n    <td>Synonym for <code>SIGIO</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGLOST</code></td>\n    <td>Sent to a process when a file lock has been lost.</td>\n  </tr>\n  <tr>\n    <td><code>SIGPWR</code></td>\n    <td>Sent to a process to notify of a power failure.</td>\n  </tr>\n  <tr>\n    <td><code>SIGINFO</code></td>\n    <td>Synonym for <code>SIGPWR</code></td>\n  </tr>\n  <tr>\n    <td><code>SIGSYS</code></td>\n    <td>Sent to a process to notify of a bad argument.</td>\n  </tr>\n  <tr>\n    <td><code>SIGUNUSED</code></td>\n    <td>Synonym for <code>SIGSYS</code></td>\n  </tr>\n</table>",
               "type": "module",
               "displayName": "Signal constants"
             },
diff --git a/doc/api/os.md b/doc/api/os.md
index 4bde3f6dc27847ded810986101c68af1c9e17ef3..f9812d4a8490b4f4fad4471e4b38bf6133b14ad7 100644
--- a/doc/api/os.md
+++ b/doc/api/os.md
@@ -115,13 +115,25 @@ The properties included on each object include:
       idle: 1070905480,
       irq: 20
     }
-  }
+  },
 ]
 ```
 
 `nice` values are POSIX-only. On Windows, the `nice` values of all processors
 are always 0.
 
+## `os.devNull`
+<!-- YAML
+added: v14.18.0
+-->
+
+* {string}
+
+The platform-specific file path of the null device.
+
+* `\\.\nul` on Windows
+* `/dev/null` on POSIX
+
 ## `os.endianness()`
 <!-- YAML
 added: v0.9.4
@@ -324,7 +336,7 @@ changes:
   - version: v2.0.0
     pr-url: https://github.com/nodejs/node/pull/747
     description: This function is now cross-platform consistent and no longer
-                 returns a path with a trailing slash on any platform
+                 returns a path with a trailing slash on any platform.
 -->
 
 * Returns: {string}
@@ -393,7 +405,7 @@ Throws a [`SystemError`][] if a user has no `username` or `homedir`.
 
 ## `os.version()`
 <!-- YAML
-added: v12.17.0
+added: v13.11.0
 -->
 
 * Returns {string}
@@ -434,7 +446,7 @@ The following signal constants are exported by `os.constants.signals`.
   <tr>
     <td><code>SIGINT</code></td>
     <td>Sent to indicate when a user wishes to interrupt a process
-    (<code>(Ctrl+C)</code>).</td>
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>).</td>
   </tr>
   <tr>
     <td><code>SIGQUIT</code></td>
@@ -1267,9 +1279,9 @@ The following process scheduling constants are exported by
   </tr>
 </table>
 
-[`SystemError`]: errors.html#errors_class_systemerror
-[`process.arch`]: process.html#process_process_arch
-[`process.platform`]: process.html#process_process_platform
-[`uname(3)`]: https://linux.die.net/man/3/uname
-[Android building]: https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os
+[Android building]: https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os
 [EUID]: https://en.wikipedia.org/wiki/User_identifier#Effective_user_ID
+[`SystemError`]: errors.md#errors_class_systemerror
+[`process.arch`]: process.md#process_process_arch
+[`process.platform`]: process.md#process_process_platform
+[`uname(3)`]: https://linux.die.net/man/3/uname
diff --git a/doc/api/packages.html b/doc/api/packages.html
index c44228be6ee74d00525bda5314f0abd68a37754b..84639599e1ec354ba54f48f10540988ef753e2d1 100644
--- a/doc/api/packages.html
+++ b/doc/api/packages.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Modules: Packages | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Modules: Packages | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="packages" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -99,15 +113,23 @@
               <a href="packages.json">View as JSON</a>
             </li>
             
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/packages.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+    <li class="version-picker">
+      <a href="#">View another version <span>&#x25bc;</span></a>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/packages.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/packages.html">16.x <b>LTS</b></a></li>
+<li><a href="https://nodejs.org/docs/latest-v15.x/api/packages.html">15.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v14.x/api/packages.html">14.x <b>LTS</b></a></li>
+<li><a href="https://nodejs.org/docs/latest-v13.x/api/packages.html">13.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v12.x/api/packages.html">12.x <b>LTS</b></a></li></ol>
+    </li>
+  
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/packages.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#packages_modules_packages">Modules: Packages</a>
 <ul>
 <li><a href="#packages_introduction">Introduction</a></li>
@@ -127,6 +149,7 @@
 <li><a href="#packages_conditional_exports">Conditional exports</a></li>
 <li><a href="#packages_nested_conditions">Nested conditions</a></li>
 <li><a href="#packages_resolving_user_conditions">Resolving user conditions</a></li>
+<li><a href="#packages_conditions_definitions">Conditions Definitions</a></li>
 <li><a href="#packages_self_referencing_a_package_using_its_name">Self-referencing a package using its name</a></li>
 </ul>
 </li>
@@ -144,31 +167,31 @@
 <li><a href="#packages_node_js_package_json_field_definitions">Node.js <code>package.json</code> field definitions</a>
 <ul>
 <li><a href="#packages_name"><code>"name"</code></a></li>
+<li><a href="#packages_main"><code>"main"</code></a></li>
 <li><a href="#packages_type"><code>"type"</code></a></li>
 <li><a href="#packages_exports"><code>"exports"</code></a></li>
-<li><a href="#packages_main"><code>"main"</code></a></li>
-<li><span class="stability_1"><a href="#packages_imports"><code>"imports"</code></a></span></li>
+<li><a href="#packages_imports"><code>"imports"</code></a></li>
 </ul>
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Modules: Packages<span><a class="mark" href="#packages_modules_packages" id="packages_modules_packages">#</a></span></h1>
+        <h2>Modules: Packages<span><a class="mark" href="#packages_modules_packages" id="packages_modules_packages">#</a></span></h2>
+
 
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.20.0</td>
+<tr><td>v14.13.0</td>
 <td><p>Add support for <code>"exports"</code> patterns.</p></td></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.6.0, v12.19.0</td>
 <td><p>Add package <code>"imports"</code> field.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.7.0, v12.16.0</td>
 <td><p>Unflag conditional exports.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.6.0, v12.16.0</td>
 <td><p>Unflag self-referencing a package using its name.</p></td></tr>
 <tr><td>v12.7.0</td>
 <td><p>Introduce <code>"exports"</code> <code>package.json</code> field as a more powerful alternative to the classic <code>"main"</code> field.</p></td></tr>
@@ -177,14 +200,14 @@
 </tbody></table>
 </details>
 </div>
-<h2>Introduction<span><a class="mark" href="#packages_introduction" id="packages_introduction">#</a></span></h2>
+<section><h3>Introduction<span><a class="mark" href="#packages_introduction" id="packages_introduction">#</a></span></h3>
 <p>A package is a folder tree described by a <code>package.json</code> file. The package
 consists of the folder containing the <code>package.json</code> file and all subfolders
 until the next folder containing another <code>package.json</code> file, or a folder
 named <code>node_modules</code>.</p>
 <p>This page provides guidance for package authors writing <code>package.json</code> files
 along with a reference for the <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> fields defined by Node.js.</p>
-<h2>Determining module system<span><a class="mark" href="#packages_determining_module_system" id="packages_determining_module_system">#</a></span></h2>
+</section><section><h3>Determining module system<span><a class="mark" href="#packages_determining_module_system" id="packages_determining_module_system">#</a></span></h3>
 <p>Node.js will treat the following as <a href="esm.html">ES modules</a> when passed to <code>node</code> as the
 initial input, or when referenced by <code>import</code> statements within ES module code:</p>
 <ul>
@@ -225,7 +248,7 @@ all sources are CommonJS. Being explicit about the <code>type</code> of the pack
 future-proof the package in case the default type of Node.js ever changes, and
 it will also make things easier for build tools and loaders to determine how the
 files in the package should be interpreted.</p>
-<h3><code>package.json</code> and file extensions<span><a class="mark" href="#packages_package_json_and_file_extensions" id="packages_package_json_and_file_extensions">#</a></span></h3>
+<h4><code>package.json</code> and file extensions<span><a class="mark" href="#packages_package_json_and_file_extensions" id="packages_package_json_and_file_extensions">#</a></span></h4>
 <p>Within a package, the <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> <a href="#packages_type"><code>"type"</code></a> field defines how
 Node.js should interpret <code>.js</code> files. If a <code>package.json</code> file does not have a
 <code>"type"</code> field, <code>.js</code> files are treated as <a href="modules.html">CommonJS</a>.</p>
@@ -272,7 +295,10 @@ extension (since both <code>.js</code> and <code>.cjs</code> files are treated a
 <code>"commonjs"</code> package).</p>
 </li>
 </ul>
-<h3><code>--input-type</code> flag<span><a class="mark" href="#packages_input_type_flag" id="packages_input_type_flag">#</a></span></h3>
+<h4><code>--input-type</code> flag<span><a class="mark" href="#packages_input_type_flag" id="packages_input_type_flag">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.0.0</span>
+</div>
 <p>Strings passed in as an argument to <code>--eval</code> (or <code>-e</code>), or piped to <code>node</code> via
 <code>STDIN</code>, are treated as <a href="esm.html">ES modules</a> when the <code>--input-type=module</code> flag
 is set.</p>
@@ -282,7 +308,7 @@ is set.</p>
 <p>For completeness there is also <code>--input-type=commonjs</code>, for explicitly running
 string input as CommonJS. This is the default behavior if <code>--input-type</code> is
 unspecified.</p>
-<h2>Package entry points<span><a class="mark" href="#packages_package_entry_points" id="packages_package_entry_points">#</a></span></h2>
+</section><section><h3>Package entry points<span><a class="mark" href="#packages_package_entry_points" id="packages_package_entry_points">#</a></span></h3>
 <p>In a package’s <code>package.json</code> file, two fields can define entry points for a
 package: <a href="#packages_main"><code>"main"</code></a> and <a href="#packages_exports"><code>"exports"</code></a>. The <a href="#packages_main"><code>"main"</code></a> field is supported
 in all versions of Node.js, but its capabilities are limited: it only defines
@@ -312,46 +338,46 @@ previously supported entry point is exported. It is best to explicitly specify
 entry points so that the package’s public API is well-defined. For example,
 a project that previous exported <code>main</code>, <code>lib</code>,
 <code>feature</code>, and the <code>package.json</code> could use the following <code>package.exports</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"name"</span>: <span class="hljs-string">"my-mod"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib"</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib/index"</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib/index.js"</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./feature"</span>: <span class="hljs-string">"./feature/index.js"</span>,
-    <span class="hljs-attr">"./feature/index.js"</span>: <span class="hljs-string">"./feature/index.js"</span>,
-    <span class="hljs-attr">"./package.json"</span>: <span class="hljs-string">"./package.json"</span>
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"my-mod"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib/index"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib/index.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature/index.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./package.json"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./package.json"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Alternatively a project could choose to export entire folders:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"name"</span>: <span class="hljs-string">"my-mod"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib"</span>: <span class="hljs-string">"./lib/index.js"</span>,
-    <span class="hljs-attr">"./lib/*"</span>: <span class="hljs-string">"./lib/*.js"</span>,
-    <span class="hljs-attr">"./feature"</span>: <span class="hljs-string">"./feature/index.js"</span>,
-    <span class="hljs-attr">"./feature/*"</span>: <span class="hljs-string">"./feature/*.js"</span>,
-    <span class="hljs-attr">"./package.json"</span>: <span class="hljs-string">"./package.json"</span>
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"my-mod"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./lib/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./lib/*.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature/index.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature/*.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./package.json"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./package.json"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>As a last resort, package encapsulation can be disabled entirely by creating an
 export for the root of the package <code>"./*": "./*"</code>. This exposes every file
 in the package at the cost of disabling the encapsulation and potential tooling
 benefits this provides. As the ES Module loader in Node.js enforces the use of
-<a href="esm.md#esm_mandatory_file_extensions">the full specifier path</a>, exporting the root rather than being explicit
+<a href="esm.html#esm_mandatory_file_extensions">the full specifier path</a>, exporting the root rather than being explicit
 about entry is less expressive than either of the prior examples. Not only
 is encapsulation lost but module consumers are unable to
 <code>import feature from 'my-mod/feature'</code> as they need to provide the full
 path <code>import feature from 'my-mod/feature/index.js</code>.</p>
-<h3>Main entry point export<span><a class="mark" href="#packages_main_entry_point_export" id="packages_main_entry_point_export">#</a></span></h3>
+<h4>Main entry point export<span><a class="mark" href="#packages_main_entry_point_export" id="packages_main_entry_point_export">#</a></span></h4>
 <p>To set the main entry point for a package, it is advisable to define both
 <a href="#packages_exports"><code>"exports"</code></a> and <a href="#packages_main"><code>"main"</code></a> in the package’s <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>,
-  <span class="hljs-attr">"exports"</span>: <span class="hljs-string">"./main.js"</span>
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>When the <a href="#packages_exports"><code>"exports"</code></a> field is defined, all subpaths of the package are
 encapsulated and no longer available to importers. For example,
 <code>require('pkg/subpath.js')</code> throws an <a href="errors.html#errors_err_package_path_not_exported"><code>ERR_PACKAGE_PATH_NOT_EXPORTED</code></a>
@@ -361,26 +387,30 @@ about package interfaces for tools and when handling semver upgrades for a
 package. It is not a strong encapsulation since a direct require of any
 absolute subpath of the package such as
 <code>require('/path/to/node_modules/pkg/subpath.js')</code> will still load <code>subpath.js</code>.</p>
-<h3>Subpath exports<span><a class="mark" href="#packages_subpath_exports" id="packages_subpath_exports">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<h4>Subpath exports<span><a class="mark" href="#packages_subpath_exports" id="packages_subpath_exports">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.7.0</span>
+</div>
 <p>When using the <a href="#packages_exports"><code>"exports"</code></a> field, custom subpaths can be defined along
 with the main entry point by treating the main entry point as the
 <code>"."</code> subpath:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./main.js"</span>,
-    <span class="hljs-attr">"./submodule"</span>: <span class="hljs-string">"./src/submodule.js"</span>
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./submodule"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./src/submodule.js"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Now only the defined subpath in <a href="#packages_exports"><code>"exports"</code></a> can be imported by a consumer:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> submodule <span class="hljs-keyword">from</span> <span class="hljs-string">'es-module-package/submodule'</span>;
 <span class="hljs-comment">// Loads ./node_modules/es-module-package/src/submodule.js</span></code></pre>
 <p>While other subpaths will error:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> submodule <span class="hljs-keyword">from</span> <span class="hljs-string">'es-module-package/private-module.js'</span>;
 <span class="hljs-comment">// Throws ERR_PACKAGE_PATH_NOT_EXPORTED</span></code></pre>
-<h3>Subpath imports<span><a class="mark" href="#packages_subpath_imports" id="packages_subpath_imports">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<h4>Subpath imports<span><a class="mark" href="#packages_subpath_imports" id="packages_subpath_imports">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.6.0, v12.19.0</span>
+</div>
 <p>In addition to the <a href="#packages_exports"><code>"exports"</code></a> field, it is possible to define internal
 package import maps that only apply to import specifiers from within the package
 itself.</p>
@@ -389,17 +419,17 @@ disambiguated from package specifiers.</p>
 <p>For example, the imports field can be used to gain the benefits of conditional
 exports for internal modules:</p>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"imports"</span>: {
-    <span class="hljs-attr">"#dep"</span>: {
-      <span class="hljs-attr">"node"</span>: <span class="hljs-string">"dep-node-native"</span>,
-      <span class="hljs-attr">"default"</span>: <span class="hljs-string">"./dep-polyfill.js"</span>
-    }
-  },
-  <span class="hljs-attr">"dependencies"</span>: {
-    <span class="hljs-attr">"dep-node-native"</span>: <span class="hljs-string">"^1.0.0"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"imports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"#dep"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"dep-node-native"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"default"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./dep-polyfill.js"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"dep-node-native"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"^1.0.0"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>where <code>import '#dep'</code> does not get the resolution of the external package
 <code>dep-node-native</code> (including its exports in turn), and instead gets the local
 file <code>./dep-polyfill.js</code> relative to the package in other environments.</p>
@@ -407,22 +437,26 @@ file <code>./dep-polyfill.js</code> relative to the package in other environment
 packages.</p>
 <p>The resolution rules for the imports field are otherwise
 analogous to the exports field.</p>
-<h3>Subpath patterns<span><a class="mark" href="#packages_subpath_patterns" id="packages_subpath_patterns">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<h4>Subpath patterns<span><a class="mark" href="#packages_subpath_patterns" id="packages_subpath_patterns">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.13.0, v12.20.0</span>
+</div>
 <p>For packages with a small number of exports or imports, we recommend
 explicitly listing each exports subpath entry. But for packages that have
 large numbers of subpaths, this might cause <code>package.json</code> bloat and
 maintenance issues.</p>
 <p>For these use cases, subpath export patterns can be used instead:</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/es-module-package/package.json</span>
-{
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"./features/*"</span>: <span class="hljs-string">"./src/features/*.js"</span>
-  },
-  <span class="hljs-attr">"imports"</span>: {
-    <span class="hljs-attr">"#internal/*"</span>: <span class="hljs-string">"./src/internal/*.js"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./features/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./src/features/*.js"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"imports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"#internal/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./src/internal/*.js"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p><strong><code>*</code> maps expose nested subpaths as it is a string replacement syntax
+only.</strong></p>
 <p>The left hand matching pattern must always end in <code>*</code>. All instances of <code>*</code> on
 the right hand side will then be replaced with this value, including if it
 contains any <code>/</code> separators.</p>
@@ -442,37 +476,62 @@ patterns since the individual exports for a package can be determined by
 treating the right hand side target pattern as a <code>**</code> glob against the list of
 files within the package. Because <code>node_modules</code> paths are forbidden in exports
 targets, this expansion is dependent on only the files of the package itself.</p>
-<h3>Exports sugar<span><a class="mark" href="#packages_exports_sugar" id="packages_exports_sugar">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>To exclude private subfolders from patterns, <code>null</code> targets can be used:</p>
+<pre><code class="language-json"><span class="hljs-comment">// ./node_modules/es-module-package/package.json</span>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./features/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./src/features/*.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./features/private-internal/*"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">null</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">import</span> featureInternal <span class="hljs-keyword">from</span> <span class="hljs-string">'es-module-package/features/private-internal/m'</span>;
+<span class="hljs-comment">// Throws: ERR_PACKAGE_PATH_NOT_EXPORTED</span>
+
+<span class="hljs-keyword">import</span> featureX <span class="hljs-keyword">from</span> <span class="hljs-string">'es-module-package/features/x'</span>;
+<span class="hljs-comment">// Loads ./node_modules/es-module-package/src/features/x.js</span></code></pre>
+<h4>Exports sugar<span><a class="mark" href="#packages_exports_sugar" id="packages_exports_sugar">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v12.11.0</span>
+</div>
 <p>If the <code>"."</code> export is the only export, the <a href="#packages_exports"><code>"exports"</code></a> field provides sugar
 for this case being the direct <a href="#packages_exports"><code>"exports"</code></a> field value.</p>
 <p>If the <code>"."</code> export has a fallback array or string value, then the
 <a href="#packages_exports"><code>"exports"</code></a> field can be set to this value directly.</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./main.js"</span>
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>can be written:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"exports"</span>: <span class="hljs-string">"./main.js"</span>
-}</code></pre>
-<h3>Conditional exports<span><a class="mark" href="#packages_conditional_exports" id="packages_conditional_exports">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h4>Conditional exports<span><a class="mark" href="#packages_conditional_exports" id="packages_conditional_exports">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p><span>Added in: v13.2.0, v12.16.0</span></p></td></tr>
+<tr><td>v13.7.0, v12.16.0</td>
+<td><p>Unflag conditional exports.</p></td></tr>
+</tbody></table>
+</details>
+</div>
 <p>Conditional exports provide a way to map to different paths depending on
 certain conditions. They are supported for both CommonJS and ES module imports.</p>
 <p>For example, a package that wants to provide different ES module exports for
 <code>require()</code> and <code>import</code> can be written:</p>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main-require.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"import"</span>: <span class="hljs-string">"./main-module.js"</span>,
-    <span class="hljs-attr">"require"</span>: <span class="hljs-string">"./main-require.cjs"</span>
-  },
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>
-}</code></pre>
-<p>Node.js supports the following conditions out of the box:</p>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main-require.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main-module.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"require"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main-require.cjs"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>Node.js implements the following conditions:</p>
 <ul>
 <li><code>"import"</code> - matches when the package is loaded via <code>import</code> or
 <code>import()</code>, or via any top-level import or resolve operation by the
@@ -494,23 +553,19 @@ or ES module file. <em>This condition should always come last.</em></li>
 matching, earlier entries have higher priority and take precedence over later
 entries. <em>The general rule is that conditions should be from most specific to
 least specific in object order</em>.</p>
-<p>Other conditions such as <code>"browser"</code>, <code>"electron"</code>, <code>"deno"</code>, <code>"react-native"</code>,
-etc., are unknown to Node.js, and thus ignored. Runtimes or tools other than
-Node.js can use them at their discretion. Further restrictions, definitions, or
-guidance on condition names might occur in the future.</p>
 <p>Using the <code>"import"</code> and <code>"require"</code> conditions can lead to some hazards,
 which are further explained in <a href="#packages_dual_commonjs_es_module_packages">the dual CommonJS/ES module packages section</a>.</p>
 <p>Conditional exports can also be extended to exports subpaths, for example:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./main.js"</span>,
-    <span class="hljs-attr">"./feature"</span>: {
-      <span class="hljs-attr">"node"</span>: <span class="hljs-string">"./feature-node.js"</span>,
-      <span class="hljs-attr">"default"</span>: <span class="hljs-string">"./feature.js"</span>
-    }
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./feature"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature-node.js"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"default"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature.js"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Defines a package where <code>require('pkg/feature')</code> and <code>import 'pkg/feature'</code>
 could provide different implementations between Node.js and other JS
 environments.</p>
@@ -521,26 +576,28 @@ these JS environments from having to pretend to be existing environments in
 order to support packages with conditional exports. For this reason, using
 <code>"node"</code> and <code>"default"</code> condition branches is usually preferable to using
 <code>"node"</code> and <code>"browser"</code> condition branches.</p>
-<h3>Nested conditions<span><a class="mark" href="#packages_nested_conditions" id="packages_nested_conditions">#</a></span></h3>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<h4>Nested conditions<span><a class="mark" href="#packages_nested_conditions" id="packages_nested_conditions">#</a></span></h4>
 <p>In addition to direct mappings, Node.js also supports nested condition objects.</p>
 <p>For example, to define a package that only has dual mode entry points for
 use in Node.js but not the browser:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"node"</span>: {
-      <span class="hljs-attr">"import"</span>: <span class="hljs-string">"./feature-node.mjs"</span>,
-      <span class="hljs-attr">"require"</span>: <span class="hljs-string">"./feature-node.cjs"</span>
-    },
-    <span class="hljs-attr">"default"</span>: <span class="hljs-string">"./feature.mjs"</span>,
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature-node.mjs"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"require"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature-node.cjs"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"default"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./feature.mjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Conditions continue to be matched in order as with flat conditions. If
 a nested conditional does not have any mapping it will continue checking
 the remaining conditions of the parent condition. In this way nested
 conditions behave analogously to nested JavaScript <code>if</code> statements.</p>
-<h3>Resolving user conditions<span><a class="mark" href="#packages_resolving_user_conditions" id="packages_resolving_user_conditions">#</a></span></h3>
+<h4>Resolving user conditions<span><a class="mark" href="#packages_resolving_user_conditions" id="packages_resolving_user_conditions">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.9.0, v12.19.0</span>
+</div>
 <p>When running Node.js, custom user conditions can be added with the
 <code>--conditions</code> flag:</p>
 <pre><code class="language-bash">node --conditions=development main.js</code></pre>
@@ -548,18 +605,68 @@ conditions behave analogously to nested JavaScript <code>if</code> statements.</
 exports, while resolving the existing <code>"node"</code>, <code>"default"</code>, <code>"import"</code>, and
 <code>"require"</code> conditions as appropriate.</p>
 <p>Any number of custom conditions can be set with repeat flags.</p>
-<h3>Self-referencing a package using its name<span><a class="mark" href="#packages_self_referencing_a_package_using_its_name" id="packages_self_referencing_a_package_using_its_name">#</a></span></h3>
+<h4>Conditions Definitions<span><a class="mark" href="#packages_conditions_definitions" id="packages_conditions_definitions">#</a></span></h4>
+<p>The <code>"import"</code>, <code>"require"</code>, <code>"node"</code> and <code>"default"</code> conditions are defined
+and implemented in Node.js core,
+<a href="#packages_conditional_exports">as specified above</a>.</p>
+<p>Other condition strings are unknown to Node.js and thus ignored by default.
+Runtimes or tools other than Node.js can use them at their discretion.</p>
+<p>These user conditions can be enabled in Node.js via the <a href="#packages_resolving_user_conditions"><code>--conditions</code>
+flag</a>.</p>
+<p>The following condition definitions are currently endorsed by Node.js:</p>
+<ul>
+<li><code>"browser"</code> - any environment which implements a standard subset of global
+browser APIs available from JavaScript in web browsers, including the DOM
+APIs.</li>
+<li><code>"development"</code> - can be used to define a development-only environment
+entry point. <em>Must always be mutually exclusive with <code>"production"</code>.</em></li>
+<li><code>"production"</code> - can be used to define a production environment entry
+point. <em>Must always be mutually exclusive with <code>"development"</code>.</em></li>
+</ul>
+<p>The above user conditions can be enabled in Node.js via the <a href="#packages_resolving_user_conditions"><code>--conditions</code>
+flag</a>.</p>
+<p>Platform specific conditions such as <code>"deno"</code>, <code>"electron"</code>, or <code>"react-native"</code>
+may be used, but while there remain no implementation or integration intent
+from these platforms, the above are not explicitly endorsed by Node.js.</p>
+<p>New conditions definitions may be added to this list by creating a pull request
+to the <a href="https://github.com/nodejs/node/blob/HEAD/doc/api/packages.md#conditions-definitions">Node.js documentation for this section</a>. The requirements for listing
+a new condition definition here are that:</p>
+<ul>
+<li>The definition should be clear and unambiguous for all implementers.</li>
+<li>The use case for why the condition is needed should be clearly justified.</li>
+<li>There should exist sufficient existing implementation usage.</li>
+<li>The condition name should not conflict with another condition definition or
+condition in wide usage.</li>
+<li>The listing of the condition definition should provide a coordination
+benefit to the ecosystem that wouldn't otherwise be possible. For example,
+this would not necessarily be the case for company-specific or
+application-specific conditions.</li>
+</ul>
+<p>The above definitions may be moved to a dedicated conditions registry in due
+course.</p>
+<h4>Self-referencing a package using its name<span><a class="mark" href="#packages_self_referencing_a_package_using_its_name" id="packages_self_referencing_a_package_using_its_name">#</a></span></h4>
+<div class="api_metadata">
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p><span>Added in: v13.1.0, v12.16.0</span></p></td></tr>
+<tr><td>v13.6.0, v12.16.0</td>
+<td><p>Unflag self-referencing a package using its name.</p></td></tr>
+</tbody></table>
+</details>
+</div>
 <p>Within a package, the values defined in the package’s
 <code>package.json</code> <a href="#packages_exports"><code>"exports"</code></a> field can be referenced via the package’s name.
 For example, assuming the <code>package.json</code> is:</p>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"name"</span>: <span class="hljs-string">"a-package"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./main.mjs"</span>,
-    <span class="hljs-attr">"./foo"</span>: <span class="hljs-string">"./foo.js"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"a-package"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.mjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./foo"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./foo.js"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Then any module <em>in that package</em> can reference an export in the package itself:</p>
 <pre><code class="language-js"><span class="hljs-comment">// ./a-module.mjs</span>
 <span class="hljs-keyword">import</span> { something } <span class="hljs-keyword">from</span> <span class="hljs-string">'a-package'</span>; <span class="hljs-comment">// Imports "something" from ./main.mjs.</span></code></pre>
@@ -575,9 +682,22 @@ error:</p>
 <span class="hljs-keyword">import</span> { another } <span class="hljs-keyword">from</span> <span class="hljs-string">'a-package/m.mjs'</span>;</code></pre>
 <p>Self-referencing is also available when using <code>require</code>, both in an ES module,
 and in a CommonJS one. For example, this code will also work:</p>
-<pre><code class="language-js"><span class="hljs-comment">// ./a-module.js</span>
+<pre><code class="language-js cjs"><span class="hljs-comment">// ./a-module.js</span>
 <span class="hljs-keyword">const</span> { something } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'a-package/foo'</span>); <span class="hljs-comment">// Loads from ./foo.js.</span></code></pre>
-<h2>Dual CommonJS/ES module packages<span><a class="mark" href="#packages_dual_commonjs_es_module_packages" id="packages_dual_commonjs_es_module_packages">#</a></span></h2>
+<p>Finally, self-referencing also works with scoped packages. For example, this
+code will also work:</p>
+<pre><code class="language-json"><span class="hljs-comment">// package.json</span>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"@my/package"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><pre><code class="language-js cjs"><span class="hljs-comment">// ./index.js</span>
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-number">42</span>;</code></pre><code class="language-js cjs"><span class="hljs-comment">// ./other.js</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-built_in">require</span>(<span class="hljs-string">'@my/package'</span>));</code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node other.js</span>
+42</code></pre>
+</section><section><h3>Dual CommonJS/ES module packages<span><a class="mark" href="#packages_dual_commonjs_es_module_packages" id="packages_dual_commonjs_es_module_packages">#</a></span></h3>
 <p>Prior to the introduction of support for ES modules in Node.js, it was a common
 pattern for package authors to include both CommonJS and ES module JavaScript
 sources in their package, with <code>package.json</code> <a href="#packages_main"><code>"main"</code></a> specifying the
@@ -593,7 +713,7 @@ exports</a>). Unlike in the scenario where <code>"module"</code> is only used by
 or ES module files are transpiled into CommonJS on the fly before evaluation by
 Node.js, the files referenced by the ES module entry point are evaluated as ES
 modules.</p>
-<h3>Dual package hazard<span><a class="mark" href="#packages_dual_package_hazard" id="packages_dual_package_hazard">#</a></span></h3>
+<h4>Dual package hazard<span><a class="mark" href="#packages_dual_package_hazard" id="packages_dual_package_hazard">#</a></span></h4>
 <p>When an application is using a package that provides both CommonJS and ES module
 sources, there is a risk of certain bugs if both versions of the package get
 loaded. This potential comes from the fact that the <code>pkgInstance</code> created by
@@ -613,7 +733,7 @@ the other. This differs from how <code>import</code> and <code>require</code> st
 all-CommonJS or all-ES module environments, respectively, and therefore is
 surprising to users. It also differs from the behavior users are familiar with
 when using transpilation via tools like <a href="https://babeljs.io/">Babel</a> or <a href="https://github.com/standard-things/esm#readme"><code>esm</code></a>.</p>
-<h3>Writing dual packages while avoiding or minimizing hazards<span><a class="mark" href="#packages_writing_dual_packages_while_avoiding_or_minimizing_hazards" id="packages_writing_dual_packages_while_avoiding_or_minimizing_hazards">#</a></span></h3>
+<h4>Writing dual packages while avoiding or minimizing hazards<span><a class="mark" href="#packages_writing_dual_packages_while_avoiding_or_minimizing_hazards" id="packages_writing_dual_packages_while_avoiding_or_minimizing_hazards">#</a></span></h4>
 <p>First, the hazard described in the previous section occurs when a package
 contains both CommonJS and ES module sources and both sources are provided for
 use in Node.js, either via separate main entry points or exported paths. A
@@ -641,30 +761,30 @@ than <code>import pkg from 'pkg'; pkg.name</code>.</li>
 browsers.</li>
 <li>The hazards described in the previous section are avoided or minimized.</li>
 </ol>
-<h4>Approach #1: Use an ES module wrapper<span><a class="mark" href="#packages_approach_1_use_an_es_module_wrapper" id="packages_approach_1_use_an_es_module_wrapper">#</a></span></h4>
+<h5>Approach #1: Use an ES module wrapper<span><a class="mark" href="#packages_approach_1_use_an_es_module_wrapper" id="packages_approach_1_use_an_es_module_wrapper">#</a></span></h5>
 <p>Write the package in CommonJS or transpile ES module sources into CommonJS, and
 create an ES module wrapper file that defines the named exports. Using
 <a href="#packages_conditional_exports">Conditional exports</a>, the ES module wrapper is used for <code>import</code> and the
 CommonJS entry point for <code>require</code>.</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/pkg/package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>,
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./index.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"import"</span>: <span class="hljs-string">"./wrapper.mjs"</span>,
-    <span class="hljs-attr">"require"</span>: <span class="hljs-string">"./index.cjs"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./wrapper.mjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"require"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>The preceding example uses explicit extensions <code>.mjs</code> and <code>.cjs</code>.
 If your files use the <code>.js</code> extension, <code>"type": "module"</code> will cause such files
 to be treated as ES modules, just as <code>"type": "commonjs"</code> would cause them
 to be treated as CommonJS.
-See <a href="#esm_enabling">Enabling</a>.</p>
-<pre><code class="language-js"><span class="hljs-comment">// ./node_modules/pkg/index.cjs</span>
-<span class="hljs-built_in">exports</span>.name = <span class="hljs-string">'value'</span>;</code></pre>
+See <a href="esm.html#esm_enabling">Enabling</a>.</p>
+<pre><code class="language-js cjs"><span class="hljs-comment">// ./node_modules/pkg/index.cjs</span>
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">name</span> = <span class="hljs-string">'value'</span>;</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// ./node_modules/pkg/wrapper.mjs</span>
 <span class="hljs-keyword">import</span> cjsModule <span class="hljs-keyword">from</span> <span class="hljs-string">'./index.cjs'</span>;
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> name = cjsModule.name;</code></pre>
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> name = cjsModule.<span class="hljs-property">name</span>;</code></pre>
 <p>In this example, the <code>name</code> from <code>import { name } from 'pkg'</code> is the same
 singleton as the <code>name</code> from <code>const { name } = require('pkg')</code>. Therefore <code>===</code>
 returns <code>true</code> when comparing the two <code>name</code>s and the divergent specifier hazard
@@ -675,7 +795,7 @@ or if support in the wrapper for the <code>import pkg from 'pkg'</code> pattern
 then the wrapper would instead be written to export the default optionally
 along with any named exports as well:</p>
 <pre><code class="language-js"><span class="hljs-keyword">import</span> cjsModule <span class="hljs-keyword">from</span> <span class="hljs-string">'./index.cjs'</span>;
-<span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> name = cjsModule.name;
+<span class="hljs-keyword">export</span> <span class="hljs-keyword">const</span> name = cjsModule.<span class="hljs-property">name</span>;
 <span class="hljs-keyword">export</span> <span class="hljs-keyword">default</span> cjsModule;</code></pre>
 <p>This approach is appropriate for any of the following use cases:</p>
 <ul>
@@ -699,26 +819,26 @@ application, such as by dependencies; or if the CommonJS version can be loaded
 but doesn’t affect the ES module version (for example, because the package is
 stateless):</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/pkg/package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>,
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./index.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./index.cjs"</span>,
-    <span class="hljs-attr">"./module"</span>: <span class="hljs-string">"./wrapper.mjs"</span>
-  }
-}</code></pre>
-<h4>Approach #2: Isolate state<span><a class="mark" href="#packages_approach_2_isolate_state" id="packages_approach_2_isolate_state">#</a></span></h4>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./module"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./wrapper.mjs"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h5>Approach #2: Isolate state<span><a class="mark" href="#packages_approach_2_isolate_state" id="packages_approach_2_isolate_state">#</a></span></h5>
 <p>A <a href="#packages_node_js_package_json_field_definitions"><code>package.json</code></a> file can define the separate CommonJS and ES module entry
 points directly:</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/pkg/package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>,
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./index.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"import"</span>: <span class="hljs-string">"./index.mjs"</span>,
-    <span class="hljs-attr">"require"</span>: <span class="hljs-string">"./index.cjs"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.mjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"require"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>This can be done if both the CommonJS and ES module versions of the package are
 equivalent, for example because one is the transpiled output of the other; and
 the package’s management of state is carefully isolated (or the package is
@@ -738,8 +858,8 @@ CommonJS and ES module instances of the package:</p>
 <p>If possible, contain all state within an instantiated object. JavaScript’s
 <code>Date</code>, for example, needs to be instantiated to contain state; if it were a
 package, it would be used like this:</p>
-<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-built_in">Date</span> <span class="hljs-keyword">from</span> <span class="hljs-string">'date'</span>;
-<span class="hljs-keyword">const</span> someDate = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>();
+<pre><code class="language-js"><span class="hljs-keyword">import</span> <span class="hljs-title class_">Date</span> <span class="hljs-keyword">from</span> <span class="hljs-string">'date'</span>;
+<span class="hljs-keyword">const</span> someDate = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>();
 <span class="hljs-comment">// someDate contains state; Date does not</span></code></pre>
 <p>The <code>new</code> keyword isn’t required; a package’s function can return a new
 object, or modify a passed-in object, to keep the state external to the
@@ -749,9 +869,9 @@ package.</p>
 <p>Isolate the state in one or more CommonJS files that are shared between the
 CommonJS and ES module versions of the package. For example, if the CommonJS
 and ES module entry points are <code>index.cjs</code> and <code>index.mjs</code>, respectively:</p>
-<pre><code class="language-js"><span class="hljs-comment">// ./node_modules/pkg/index.cjs</span>
+<pre><code class="language-js cjs"><span class="hljs-comment">// ./node_modules/pkg/index.cjs</span>
 <span class="hljs-keyword">const</span> state = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./state.cjs'</span>);
-<span class="hljs-built_in">module</span>.exports.state = state;</code></pre>
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-property">state</span> = state;</code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// ./node_modules/pkg/index.mjs</span>
 <span class="hljs-keyword">import</span> state <span class="hljs-keyword">from</span> <span class="hljs-string">'./state.cjs'</span>;
 <span class="hljs-keyword">export</span> {
@@ -781,15 +901,15 @@ execution between the CommonJS and ES module versions of a package.</p>
 conditional exports for consumers could be to add an export, e.g.
 <code>"./module"</code>, to point to an all-ES module-syntax version of the package:</p>
 <pre><code class="language-json"><span class="hljs-comment">// ./node_modules/pkg/package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>,
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./index.cjs"</span>,
-  <span class="hljs-attr">"exports"</span>: {
-    <span class="hljs-attr">"."</span>: <span class="hljs-string">"./index.cjs"</span>,
-    <span class="hljs-attr">"./module"</span>: <span class="hljs-string">"./index.mjs"</span>
-  }
-}</code></pre>
-<h2>Node.js <code>package.json</code> field definitions<span><a class="mark" href="#packages_node_js_package_json_field_definitions" id="packages_node_js_package_json_field_definitions">#</a></span></h2>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"."</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.cjs"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./module"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.mjs"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+</section><section><h3>Node.js <code>package.json</code> field definitions<span><a class="mark" href="#packages_node_js_package_json_field_definitions" id="packages_node_js_package_json_field_definitions">#</a></span></h3>
 <p>This section describes the fields used by the Node.js runtime. Other tools (such
 as <a href="https://docs.npmjs.com/creating-a-package-json-file">npm</a>) use
 additional fields which are ignored by Node.js and not documented here.</p>
@@ -797,44 +917,60 @@ additional fields which are ignored by Node.js and not documented here.</p>
 <ul>
 <li><a href="#packages_name"><code>"name"</code></a> - Relevant when using named imports within a package. Also used
 by package managers as the name of the package.</li>
+<li><a href="#packages_main"><code>"main"</code></a> - The default module when loading the package, if exports is not
+specified, and in versions of Node.js prior to the introduction of exports.</li>
 <li><a href="#packages_type"><code>"type"</code></a> - The package type determining whether to load <code>.js</code> files as
 CommonJS or ES modules.</li>
 <li><a href="#packages_exports"><code>"exports"</code></a> - Package exports and conditional exports. When present,
 limits which submodules can be loaded from within the package.</li>
-<li><a href="#packages_main"><code>"main"</code></a> - The default module when loading the package, if exports is not
-specified, and in versions of Node.js prior to the introduction of exports.</li>
 <li><a href="#packages_imports"><code>"imports"</code></a> - Package imports, for use by modules within the package
 itself.</li>
 </ul>
-<h3><code>"name"</code><span><a class="mark" href="#packages_name" id="packages_name">#</a></span></h3>
+<h4><code>"name"</code><span><a class="mark" href="#packages_name" id="packages_name">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.1.0, v12.16.0</td>
+<td><p><span>Added in: v13.1.0, v12.16.0</span></p></td></tr>
+<tr><td>v13.6.0, v12.16.0</td>
 <td><p>Remove the <code>--experimental-resolve-self</code> option.</p></td></tr>
-<tr><td>v12.16.0</td>
-<td><p><span>Added in: v12.16.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
 <ul>
 <li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"name"</span>: <span class="hljs-string">"package-name"</span>
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"package-name"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>The <code>"name"</code> field defines your package’s name. Publishing to the
 <em>npm</em> registry requires a name that satisfies
 <a href="https://docs.npmjs.com/files/package.json#name">certain requirements</a>.</p>
 <p>The <code>"name"</code> field can be used in addition to the <a href="#packages_exports"><code>"exports"</code></a> field to
 <a href="#packages_self_referencing_a_package_using_its_name">self-reference</a> a package using its name.</p>
-<h3><code>"type"</code><span><a class="mark" href="#packages_type" id="packages_type">#</a></span></h3>
+<h4><code>"main"</code><span><a class="mark" href="#packages_main" id="packages_main">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v0.4.0</span>
+</div>
+<ul>
+<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"main"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./main.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>The <code>"main"</code> field defines the script that is used when the <a href="modules.html#modules_folders_as_modules">package directory
+is loaded via <code>require()</code></a>. Its value
+is a path.</p>
+<pre><code class="language-js cjs"><span class="hljs-built_in">require</span>(<span class="hljs-string">'./path/to/directory'</span>); <span class="hljs-comment">// This resolves to ./path/to/directory/main.js.</span></code></pre>
+<p>When a package has an <a href="#packages_exports"><code>"exports"</code></a> field, this will take precedence over the
+<code>"main"</code> field when importing the package by name.</p>
+<h4><code>"type"</code><span><a class="mark" href="#packages_type" id="packages_type">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.2.0, v12.17.0</td>
 <td><p>Unflag <code>--experimental-modules</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p><span>Added in: v12.0.0</span></p></td></tr>
@@ -853,9 +989,9 @@ itself.</li>
 when searching in the current folder, that folder’s parent, and so on up
 until a node_modules folder or the volume root is reached.</p>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"type"</span>: <span class="hljs-string">"module"</span>
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"module"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <pre><code class="language-bash"><span class="hljs-comment"># In same folder as preceding package.json</span>
 node my-app.js <span class="hljs-comment"># Runs as ES module</span></code></pre>
 <p>If the nearest parent <code>package.json</code> lacks a <code>"type"</code> field, or contains
@@ -868,19 +1004,19 @@ parent <code>package.json</code> contains <code>"type": "module"</code>.</p>
 <span class="hljs-keyword">import</span> <span class="hljs-string">'./startup.js'</span>; <span class="hljs-comment">// Loaded as ES module because of package.json</span></code></pre>
 <p>Regardless of the value of the <code>"type"</code> field, <code>.mjs</code> files are always treated
 as ES modules and <code>.cjs</code> files are always treated as CommonJS.</p>
-<h3><code>"exports"</code><span><a class="mark" href="#packages_exports" id="packages_exports">#</a></span></h3>
+<h4><code>"exports"</code><span><a class="mark" href="#packages_exports" id="packages_exports">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.20.0</td>
+<tr><td>v14.13.0, v12.20.0</td>
 <td><p>Add support for <code>"exports"</code> patterns.</p></td></tr>
-<tr><td>v12.16.0</td>
-<td><p>Implement conditional exports.</p></td></tr>
-<tr><td>v12.16.0</td>
-<td><p>Remove the <code>--experimental-conditional-exports</code> option.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.7.0, v12.16.0</td>
 <td><p>Implement logical conditional exports ordering.</p></td></tr>
+<tr><td>v13.7.0, v12.16.0</td>
+<td><p>Remove the <code>--experimental-conditional-exports</code> option.</p></td></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>Implement conditional exports.</p></td></tr>
 <tr><td>v12.7.0</td>
 <td><p><span>Added in: v12.7.0</span></p></td></tr>
 </tbody></table>
@@ -889,9 +1025,9 @@ as ES modules and <code>.cjs</code> files are always treated as CommonJS.</p>
 <ul>
 <li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"exports"</span>: <span class="hljs-string">"./index.js"</span>
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"exports"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./index.js"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>The <code>"exports"</code> field allows defining the <a href="#packages_package_entry_points">entry points</a> of a package when
 imported by name loaded either via a <code>node_modules</code> lookup or a
 <a href="#packages_self_referencing_a_package_using_its_name">self-reference</a> to its own name. It is supported in Node.js 12+ as an
@@ -902,48 +1038,67 @@ package entry points per environment, including whether the package is
 referenced via <code>require</code> or via <code>import</code>.</p>
 <p>All paths defined in the <code>"exports"</code> must be relative file URLs starting with
 <code>./</code>.</p>
-<h3><code>"main"</code><span><a class="mark" href="#packages_main" id="packages_main">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v0.4.0</span>
-</div>
-<ul>
-<li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-</ul>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"main"</span>: <span class="hljs-string">"./main.js"</span>
-}</code></pre>
-<p>The <code>"main"</code> field defines the script that is used when the <a href="modules.html#modules_folders_as_modules">package directory
-is loaded via <code>require()</code></a>. Its value
-is interpreted as a path.</p>
-<pre><code class="language-js"><span class="hljs-built_in">require</span>(<span class="hljs-string">'./path/to/directory'</span>); <span class="hljs-comment">// This resolves to ./path/to/directory/main.js.</span></code></pre>
-<p>When a package has an <a href="#packages_exports"><code>"exports"</code></a> field, this will take precedence over the
-<code>"main"</code> field when importing the package by name.</p>
-<h3><code>"imports"</code><span><a class="mark" href="#packages_imports" id="packages_imports">#</a></span></h3>
+<h4><code>"imports"</code><span><a class="mark" href="#packages_imports" id="packages_imports">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.6.0, v12.19.0</span>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <ul>
 <li>Type: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <pre><code class="language-json"><span class="hljs-comment">// package.json</span>
-{
-  <span class="hljs-attr">"imports"</span>: {
-    <span class="hljs-attr">"#dep"</span>: {
-      <span class="hljs-attr">"node"</span>: <span class="hljs-string">"dep-node-native"</span>,
-      <span class="hljs-attr">"default"</span>: <span class="hljs-string">"./dep-polyfill.js"</span>
-    }
-  },
-  <span class="hljs-attr">"dependencies"</span>: {
-    <span class="hljs-attr">"dep-node-native"</span>: <span class="hljs-string">"^1.0.0"</span>
-  }
-}</code></pre>
+<span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"imports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"#dep"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"dep-node-native"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"default"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./dep-polyfill.js"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"dep-node-native"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"^1.0.0"</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Entries in the imports field must be strings starting with <code>#</code>.</p>
 <p>Import maps permit mapping to external packages.</p>
-<p>This field defines <a href="#packages_subpath_imports">subpath imports</a> for the current package.</p>
+<p>This field defines <a href="#packages_subpath_imports">subpath imports</a> for the current package.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/packages.json b/doc/api/packages.json
index 0056e8765732d1d25a795a62a1e678293a659852..50a7c1a84580d40638562654a34ee2c32d300cb4 100644
--- a/doc/api/packages.json
+++ b/doc/api/packages.json
@@ -1,20 +1,27 @@
 {
   "type": "module",
   "source": "doc/api/packages.md",
+  "introduced_in": "v12.20.0",
   "meta": {
     "changes": [
       {
-        "version": "v12.20.0",
+        "version": [
+          "v14.13.0"
+        ],
         "pr-url": "https://github.com/nodejs/node/pull/34718",
         "description": "Add support for `\"exports\"` patterns."
       },
       {
-        "version": "v12.19.0",
+        "version": [
+          "v14.6.0",
+          "v12.19.0"
+        ],
         "pr-url": "https://github.com/nodejs/node/pull/34117",
         "description": "Add package `\"imports\"` field."
       },
       {
         "version": [
+          "v13.7.0",
           "v12.16.0"
         ],
         "pr-url": "https://github.com/nodejs/node/pull/31001",
@@ -22,6 +29,7 @@
       },
       {
         "version": [
+          "v13.6.0",
           "v12.16.0"
         ],
         "pr-url": "https://github.com/nodejs/node/pull/31002",
@@ -43,21 +51,28 @@
     {
       "textRaw": "Modules: Packages",
       "name": "Modules: Packages",
+      "introduced_in": "v12.20.0",
       "type": "misc",
       "meta": {
         "changes": [
           {
-            "version": "v12.20.0",
+            "version": [
+              "v14.13.0"
+            ],
             "pr-url": "https://github.com/nodejs/node/pull/34718",
             "description": "Add support for `\"exports\"` patterns."
           },
           {
-            "version": "v12.19.0",
+            "version": [
+              "v14.6.0",
+              "v12.19.0"
+            ],
             "pr-url": "https://github.com/nodejs/node/pull/34117",
             "description": "Add package `\"imports\"` field."
           },
           {
             "version": [
+              "v13.7.0",
               "v12.16.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/31001",
@@ -65,6 +80,7 @@
           },
           {
             "version": [
+              "v13.6.0",
               "v12.16.0"
             ],
             "pr-url": "https://github.com/nodejs/node/pull/31002",
@@ -105,6 +121,12 @@
             {
               "textRaw": "`--input-type` flag",
               "name": "`--input-type`_flag",
+              "meta": {
+                "added": [
+                  "v12.0.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>Strings passed in as an argument to <code>--eval</code> (or <code>-e</code>), or piped to <code>node</code> via\n<code>STDIN</code>, are treated as <a href=\"esm.html\">ES modules</a> when the <code>--input-type=module</code> flag\nis set.</p>\n<pre><code class=\"language-bash\">node --input-type=module --eval \"import { sep } from 'path'; console.log(sep);\"\n\necho \"import { sep } from 'path'; console.log(sep);\" | node --input-type=module\n</code></pre>\n<p>For completeness there is also <code>--input-type=commonjs</code>, for explicitly running\nstring input as CommonJS. This is the default behavior if <code>--input-type</code> is\nunspecified.</p>",
               "type": "module",
               "displayName": "`--input-type` flag"
@@ -116,7 +138,7 @@
         {
           "textRaw": "Package entry points",
           "name": "package_entry_points",
-          "desc": "<p>In a package’s <code>package.json</code> file, two fields can define entry points for a\npackage: <a href=\"#packages_main\"><code>\"main\"</code></a> and <a href=\"#packages_exports\"><code>\"exports\"</code></a>. The <a href=\"#packages_main\"><code>\"main\"</code></a> field is supported\nin all versions of Node.js, but its capabilities are limited: it only defines\nthe main entry point of the package.</p>\n<p>The <a href=\"#packages_exports\"><code>\"exports\"</code></a> field provides an alternative to <a href=\"#packages_main\"><code>\"main\"</code></a> where the\npackage main entry point can be defined while also encapsulating the package,\n<strong>preventing any other entry points besides those defined in <a href=\"#packages_exports\"><code>\"exports\"</code></a></strong>.\nThis encapsulation allows module authors to define a public interface for\ntheir package.</p>\n<p>If both <a href=\"#packages_exports\"><code>\"exports\"</code></a> and <a href=\"#packages_main\"><code>\"main\"</code></a> are defined, the <a href=\"#packages_exports\"><code>\"exports\"</code></a> field\ntakes precedence over <a href=\"#packages_main\"><code>\"main\"</code></a>. <a href=\"#packages_exports\"><code>\"exports\"</code></a> are not specific to ES\nmodules or CommonJS; <a href=\"#packages_main\"><code>\"main\"</code></a> is overridden by <a href=\"#packages_exports\"><code>\"exports\"</code></a> if it\nexists. As such <a href=\"#packages_main\"><code>\"main\"</code></a> cannot be used as a fallback for CommonJS but it\ncan be used as a fallback for legacy versions of Node.js that do not support the\n<a href=\"#packages_exports\"><code>\"exports\"</code></a> field.</p>\n<p><a href=\"#packages_conditional_exports\">Conditional exports</a> can be used within <a href=\"#packages_exports\"><code>\"exports\"</code></a> to define different\npackage entry points per environment, including whether the package is\nreferenced via <code>require</code> or via <code>import</code>. For more information about supporting\nboth CommonJS and ES Modules in a single package please consult\n<a href=\"#packages_dual_commonjs_es_module_packages\">the dual CommonJS/ES module packages section</a>.</p>\n<p><strong>Warning</strong>: Introducing the <a href=\"#packages_exports\"><code>\"exports\"</code></a> field prevents consumers of a\npackage from using any entry points that are not defined, including the\n<a href=\"#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> (e.g. <code>require('your-package/package.json')</code>. <strong>This will\nlikely be a breaking change.</strong></p>\n<p>To make the introduction of <a href=\"#packages_exports\"><code>\"exports\"</code></a> non-breaking, ensure that every\npreviously supported entry point is exported. It is best to explicitly specify\nentry points so that the package’s public API is well-defined. For example,\na project that previous exported <code>main</code>, <code>lib</code>,\n<code>feature</code>, and the <code>package.json</code> could use the following <code>package.exports</code>:</p>\n<pre><code class=\"language-json\">{\n  \"name\": \"my-mod\",\n  \"exports\": {\n    \".\": \"./lib/index.js\",\n    \"./lib\": \"./lib/index.js\",\n    \"./lib/index\": \"./lib/index.js\",\n    \"./lib/index.js\": \"./lib/index.js\",\n    \"./feature\": \"./feature/index.js\",\n    \"./feature/index.js\": \"./feature/index.js\",\n    \"./package.json\": \"./package.json\"\n  }\n}\n</code></pre>\n<p>Alternatively a project could choose to export entire folders:</p>\n<pre><code class=\"language-json\">{\n  \"name\": \"my-mod\",\n  \"exports\": {\n    \".\": \"./lib/index.js\",\n    \"./lib\": \"./lib/index.js\",\n    \"./lib/*\": \"./lib/*.js\",\n    \"./feature\": \"./feature/index.js\",\n    \"./feature/*\": \"./feature/*.js\",\n    \"./package.json\": \"./package.json\"\n  }\n}\n</code></pre>\n<p>As a last resort, package encapsulation can be disabled entirely by creating an\nexport for the root of the package <code>\"./*\": \"./*\"</code>. This exposes every file\nin the package at the cost of disabling the encapsulation and potential tooling\nbenefits this provides. As the ES Module loader in Node.js enforces the use of\n<a href=\"esm.md#esm_mandatory_file_extensions\">the full specifier path</a>, exporting the root rather than being explicit\nabout entry is less expressive than either of the prior examples. Not only\nis encapsulation lost but module consumers are unable to\n<code>import feature from 'my-mod/feature'</code> as they need to provide the full\npath <code>import feature from 'my-mod/feature/index.js</code>.</p>",
+          "desc": "<p>In a package’s <code>package.json</code> file, two fields can define entry points for a\npackage: <a href=\"#packages_main\"><code>\"main\"</code></a> and <a href=\"#packages_exports\"><code>\"exports\"</code></a>. The <a href=\"#packages_main\"><code>\"main\"</code></a> field is supported\nin all versions of Node.js, but its capabilities are limited: it only defines\nthe main entry point of the package.</p>\n<p>The <a href=\"#packages_exports\"><code>\"exports\"</code></a> field provides an alternative to <a href=\"#packages_main\"><code>\"main\"</code></a> where the\npackage main entry point can be defined while also encapsulating the package,\n<strong>preventing any other entry points besides those defined in <a href=\"#packages_exports\"><code>\"exports\"</code></a></strong>.\nThis encapsulation allows module authors to define a public interface for\ntheir package.</p>\n<p>If both <a href=\"#packages_exports\"><code>\"exports\"</code></a> and <a href=\"#packages_main\"><code>\"main\"</code></a> are defined, the <a href=\"#packages_exports\"><code>\"exports\"</code></a> field\ntakes precedence over <a href=\"#packages_main\"><code>\"main\"</code></a>. <a href=\"#packages_exports\"><code>\"exports\"</code></a> are not specific to ES\nmodules or CommonJS; <a href=\"#packages_main\"><code>\"main\"</code></a> is overridden by <a href=\"#packages_exports\"><code>\"exports\"</code></a> if it\nexists. As such <a href=\"#packages_main\"><code>\"main\"</code></a> cannot be used as a fallback for CommonJS but it\ncan be used as a fallback for legacy versions of Node.js that do not support the\n<a href=\"#packages_exports\"><code>\"exports\"</code></a> field.</p>\n<p><a href=\"#packages_conditional_exports\">Conditional exports</a> can be used within <a href=\"#packages_exports\"><code>\"exports\"</code></a> to define different\npackage entry points per environment, including whether the package is\nreferenced via <code>require</code> or via <code>import</code>. For more information about supporting\nboth CommonJS and ES Modules in a single package please consult\n<a href=\"#packages_dual_commonjs_es_module_packages\">the dual CommonJS/ES module packages section</a>.</p>\n<p><strong>Warning</strong>: Introducing the <a href=\"#packages_exports\"><code>\"exports\"</code></a> field prevents consumers of a\npackage from using any entry points that are not defined, including the\n<a href=\"#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> (e.g. <code>require('your-package/package.json')</code>. <strong>This will\nlikely be a breaking change.</strong></p>\n<p>To make the introduction of <a href=\"#packages_exports\"><code>\"exports\"</code></a> non-breaking, ensure that every\npreviously supported entry point is exported. It is best to explicitly specify\nentry points so that the package’s public API is well-defined. For example,\na project that previous exported <code>main</code>, <code>lib</code>,\n<code>feature</code>, and the <code>package.json</code> could use the following <code>package.exports</code>:</p>\n<pre><code class=\"language-json\">{\n  \"name\": \"my-mod\",\n  \"exports\": {\n    \".\": \"./lib/index.js\",\n    \"./lib\": \"./lib/index.js\",\n    \"./lib/index\": \"./lib/index.js\",\n    \"./lib/index.js\": \"./lib/index.js\",\n    \"./feature\": \"./feature/index.js\",\n    \"./feature/index.js\": \"./feature/index.js\",\n    \"./package.json\": \"./package.json\"\n  }\n}\n</code></pre>\n<p>Alternatively a project could choose to export entire folders:</p>\n<pre><code class=\"language-json\">{\n  \"name\": \"my-mod\",\n  \"exports\": {\n    \".\": \"./lib/index.js\",\n    \"./lib\": \"./lib/index.js\",\n    \"./lib/*\": \"./lib/*.js\",\n    \"./feature\": \"./feature/index.js\",\n    \"./feature/*\": \"./feature/*.js\",\n    \"./package.json\": \"./package.json\"\n  }\n}\n</code></pre>\n<p>As a last resort, package encapsulation can be disabled entirely by creating an\nexport for the root of the package <code>\"./*\": \"./*\"</code>. This exposes every file\nin the package at the cost of disabling the encapsulation and potential tooling\nbenefits this provides. As the ES Module loader in Node.js enforces the use of\n<a href=\"esm.html#esm_mandatory_file_extensions\">the full specifier path</a>, exporting the root rather than being explicit\nabout entry is less expressive than either of the prior examples. Not only\nis encapsulation lost but module consumers are unable to\n<code>import feature from 'my-mod/feature'</code> as they need to provide the full\npath <code>import feature from 'my-mod/feature/index.js</code>.</p>",
           "modules": [
             {
               "textRaw": "Main entry point export",
@@ -128,8 +150,12 @@
             {
               "textRaw": "Subpath exports",
               "name": "subpath_exports",
-              "stability": 1,
-              "stabilityText": "Experimental",
+              "meta": {
+                "added": [
+                  "v12.7.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>When using the <a href=\"#packages_exports\"><code>\"exports\"</code></a> field, custom subpaths can be defined along\nwith the main entry point by treating the main entry point as the\n<code>\".\"</code> subpath:</p>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\",\n  \"exports\": {\n    \".\": \"./main.js\",\n    \"./submodule\": \"./src/submodule.js\"\n  }\n}\n</code></pre>\n<p>Now only the defined subpath in <a href=\"#packages_exports\"><code>\"exports\"</code></a> can be imported by a consumer:</p>\n<pre><code class=\"language-js\">import submodule from 'es-module-package/submodule';\n// Loads ./node_modules/es-module-package/src/submodule.js\n</code></pre>\n<p>While other subpaths will error:</p>\n<pre><code class=\"language-js\">import submodule from 'es-module-package/private-module.js';\n// Throws ERR_PACKAGE_PATH_NOT_EXPORTED\n</code></pre>",
               "type": "module",
               "displayName": "Subpath exports"
@@ -137,8 +163,13 @@
             {
               "textRaw": "Subpath imports",
               "name": "subpath_imports",
-              "stability": 1,
-              "stabilityText": "Experimental",
+              "meta": {
+                "added": [
+                  "v14.6.0",
+                  "v12.19.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>In addition to the <a href=\"#packages_exports\"><code>\"exports\"</code></a> field, it is possible to define internal\npackage import maps that only apply to import specifiers from within the package\nitself.</p>\n<p>Entries in the imports field must always start with <code>#</code> to ensure they are\ndisambiguated from package specifiers.</p>\n<p>For example, the imports field can be used to gain the benefits of conditional\nexports for internal modules:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"imports\": {\n    \"#dep\": {\n      \"node\": \"dep-node-native\",\n      \"default\": \"./dep-polyfill.js\"\n    }\n  },\n  \"dependencies\": {\n    \"dep-node-native\": \"^1.0.0\"\n  }\n}\n</code></pre>\n<p>where <code>import '#dep'</code> does not get the resolution of the external package\n<code>dep-node-native</code> (including its exports in turn), and instead gets the local\nfile <code>./dep-polyfill.js</code> relative to the package in other environments.</p>\n<p>Unlike the <code>\"exports\"</code> field, the <code>\"imports\"</code> field permits mapping to external\npackages.</p>\n<p>The resolution rules for the imports field are otherwise\nanalogous to the exports field.</p>",
               "type": "module",
               "displayName": "Subpath imports"
@@ -146,17 +177,26 @@
             {
               "textRaw": "Subpath patterns",
               "name": "subpath_patterns",
-              "stability": 1,
-              "stabilityText": "Experimental",
-              "desc": "<p>For packages with a small number of exports or imports, we recommend\nexplicitly listing each exports subpath entry. But for packages that have\nlarge numbers of subpaths, this might cause <code>package.json</code> bloat and\nmaintenance issues.</p>\n<p>For these use cases, subpath export patterns can be used instead:</p>\n<pre><code class=\"language-json\">// ./node_modules/es-module-package/package.json\n{\n  \"exports\": {\n    \"./features/*\": \"./src/features/*.js\"\n  },\n  \"imports\": {\n    \"#internal/*\": \"./src/internal/*.js\"\n  }\n}\n</code></pre>\n<p>The left hand matching pattern must always end in <code>*</code>. All instances of <code>*</code> on\nthe right hand side will then be replaced with this value, including if it\ncontains any <code>/</code> separators.</p>\n<pre><code class=\"language-js\">import featureX from 'es-module-package/features/x';\n// Loads ./node_modules/es-module-package/src/features/x.js\n\nimport featureY from 'es-module-package/features/y/y';\n// Loads ./node_modules/es-module-package/src/features/y/y.js\n\nimport internalZ from '#internal/z';\n// Loads ./node_modules/es-module-package/src/internal/z.js\n</code></pre>\n<p>This is a direct static replacement without any special handling for file\nextensions. In the previous example, <code>pkg/features/x.json</code> would be resolved to\n<code>./src/features/x.json.js</code> in the mapping.</p>\n<p>The property of exports being statically enumerable is maintained with exports\npatterns since the individual exports for a package can be determined by\ntreating the right hand side target pattern as a <code>**</code> glob against the list of\nfiles within the package. Because <code>node_modules</code> paths are forbidden in exports\ntargets, this expansion is dependent on only the files of the package itself.</p>",
+              "meta": {
+                "added": [
+                  "v14.13.0",
+                  "v12.20.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>For packages with a small number of exports or imports, we recommend\nexplicitly listing each exports subpath entry. But for packages that have\nlarge numbers of subpaths, this might cause <code>package.json</code> bloat and\nmaintenance issues.</p>\n<p>For these use cases, subpath export patterns can be used instead:</p>\n<pre><code class=\"language-json\">// ./node_modules/es-module-package/package.json\n{\n  \"exports\": {\n    \"./features/*\": \"./src/features/*.js\"\n  },\n  \"imports\": {\n    \"#internal/*\": \"./src/internal/*.js\"\n  }\n}\n</code></pre>\n<p><strong><code>*</code> maps expose nested subpaths as it is a string replacement syntax\nonly.</strong></p>\n<p>The left hand matching pattern must always end in <code>*</code>. All instances of <code>*</code> on\nthe right hand side will then be replaced with this value, including if it\ncontains any <code>/</code> separators.</p>\n<pre><code class=\"language-js\">import featureX from 'es-module-package/features/x';\n// Loads ./node_modules/es-module-package/src/features/x.js\n\nimport featureY from 'es-module-package/features/y/y';\n// Loads ./node_modules/es-module-package/src/features/y/y.js\n\nimport internalZ from '#internal/z';\n// Loads ./node_modules/es-module-package/src/internal/z.js\n</code></pre>\n<p>This is a direct static replacement without any special handling for file\nextensions. In the previous example, <code>pkg/features/x.json</code> would be resolved to\n<code>./src/features/x.json.js</code> in the mapping.</p>\n<p>The property of exports being statically enumerable is maintained with exports\npatterns since the individual exports for a package can be determined by\ntreating the right hand side target pattern as a <code>**</code> glob against the list of\nfiles within the package. Because <code>node_modules</code> paths are forbidden in exports\ntargets, this expansion is dependent on only the files of the package itself.</p>\n<p>To exclude private subfolders from patterns, <code>null</code> targets can be used:</p>\n<pre><code class=\"language-json\">// ./node_modules/es-module-package/package.json\n{\n  \"exports\": {\n    \"./features/*\": \"./src/features/*.js\",\n    \"./features/private-internal/*\": null\n  }\n}\n</code></pre>\n<pre><code class=\"language-js\">import featureInternal from 'es-module-package/features/private-internal/m';\n// Throws: ERR_PACKAGE_PATH_NOT_EXPORTED\n\nimport featureX from 'es-module-package/features/x';\n// Loads ./node_modules/es-module-package/src/features/x.js\n</code></pre>",
               "type": "module",
               "displayName": "Subpath patterns"
             },
             {
               "textRaw": "Exports sugar",
               "name": "exports_sugar",
-              "stability": 1,
-              "stabilityText": "Experimental",
+              "meta": {
+                "added": [
+                  "v12.11.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>If the <code>\".\"</code> export is the only export, the <a href=\"#packages_exports\"><code>\"exports\"</code></a> field provides sugar\nfor this case being the direct <a href=\"#packages_exports\"><code>\"exports\"</code></a> field value.</p>\n<p>If the <code>\".\"</code> export has a fallback array or string value, then the\n<a href=\"#packages_exports\"><code>\"exports\"</code></a> field can be set to this value directly.</p>\n<pre><code class=\"language-json\">{\n  \"exports\": {\n    \".\": \"./main.js\"\n  }\n}\n</code></pre>\n<p>can be written:</p>\n<pre><code class=\"language-json\">{\n  \"exports\": \"./main.js\"\n}\n</code></pre>",
               "type": "module",
               "displayName": "Exports sugar"
@@ -164,17 +204,29 @@
             {
               "textRaw": "Conditional exports",
               "name": "conditional_exports",
-              "stability": 1,
-              "stabilityText": "Experimental",
-              "desc": "<p>Conditional exports provide a way to map to different paths depending on\ncertain conditions. They are supported for both CommonJS and ES module imports.</p>\n<p>For example, a package that wants to provide different ES module exports for\n<code>require()</code> and <code>import</code> can be written:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"main\": \"./main-require.cjs\",\n  \"exports\": {\n    \"import\": \"./main-module.js\",\n    \"require\": \"./main-require.cjs\"\n  },\n  \"type\": \"module\"\n}\n</code></pre>\n<p>Node.js supports the following conditions out of the box:</p>\n<ul>\n<li><code>\"import\"</code> - matches when the package is loaded via <code>import</code> or\n<code>import()</code>, or via any top-level import or resolve operation by the\nECMAScript module loader. Applies regardless of the module format of the\ntarget file. <em>Always mutually exclusive with <code>\"require\"</code>.</em></li>\n<li><code>\"require\"</code> - matches when the package is loaded via <code>require()</code>. The\nreferenced file should be loadable with <code>require()</code> although the condition\nmatches regardless of the module format of the target file. Expected\nformats include CommonJS, JSON, and native addons but not ES modules as\n<code>require()</code> doesn't support them. <em>Always mutually exclusive with\n<code>\"import\"</code>.</em></li>\n<li><code>\"node\"</code> - matches for any Node.js environment. Can be a CommonJS or ES\nmodule file. <em>This condition should always come after <code>\"import\"</code> or\n<code>\"require\"</code>.</em></li>\n<li><code>\"default\"</code> - the generic fallback that always matches. Can be a CommonJS\nor ES module file. <em>This condition should always come last.</em></li>\n</ul>\n<p>Within the <a href=\"#packages_exports\"><code>\"exports\"</code></a> object, key order is significant. During condition\nmatching, earlier entries have higher priority and take precedence over later\nentries. <em>The general rule is that conditions should be from most specific to\nleast specific in object order</em>.</p>\n<p>Other conditions such as <code>\"browser\"</code>, <code>\"electron\"</code>, <code>\"deno\"</code>, <code>\"react-native\"</code>,\netc., are unknown to Node.js, and thus ignored. Runtimes or tools other than\nNode.js can use them at their discretion. Further restrictions, definitions, or\nguidance on condition names might occur in the future.</p>\n<p>Using the <code>\"import\"</code> and <code>\"require\"</code> conditions can lead to some hazards,\nwhich are further explained in <a href=\"#packages_dual_commonjs_es_module_packages\">the dual CommonJS/ES module packages section</a>.</p>\n<p>Conditional exports can also be extended to exports subpaths, for example:</p>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\",\n  \"exports\": {\n    \".\": \"./main.js\",\n    \"./feature\": {\n      \"node\": \"./feature-node.js\",\n      \"default\": \"./feature.js\"\n    }\n  }\n}\n</code></pre>\n<p>Defines a package where <code>require('pkg/feature')</code> and <code>import 'pkg/feature'</code>\ncould provide different implementations between Node.js and other JS\nenvironments.</p>\n<p>When using environment branches, always include a <code>\"default\"</code> condition where\npossible. Providing a <code>\"default\"</code> condition ensures that any unknown JS\nenvironments are able to use this universal implementation, which helps avoid\nthese JS environments from having to pretend to be existing environments in\norder to support packages with conditional exports. For this reason, using\n<code>\"node\"</code> and <code>\"default\"</code> condition branches is usually preferable to using\n<code>\"node\"</code> and <code>\"browser\"</code> condition branches.</p>",
+              "meta": {
+                "added": [
+                  "v13.2.0",
+                  "v12.16.0"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.7.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31001",
+                    "description": "Unflag conditional exports."
+                  }
+                ]
+              },
+              "desc": "<p>Conditional exports provide a way to map to different paths depending on\ncertain conditions. They are supported for both CommonJS and ES module imports.</p>\n<p>For example, a package that wants to provide different ES module exports for\n<code>require()</code> and <code>import</code> can be written:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"main\": \"./main-require.cjs\",\n  \"exports\": {\n    \"import\": \"./main-module.js\",\n    \"require\": \"./main-require.cjs\"\n  },\n  \"type\": \"module\"\n}\n</code></pre>\n<p>Node.js implements the following conditions:</p>\n<ul>\n<li><code>\"import\"</code> - matches when the package is loaded via <code>import</code> or\n<code>import()</code>, or via any top-level import or resolve operation by the\nECMAScript module loader. Applies regardless of the module format of the\ntarget file. <em>Always mutually exclusive with <code>\"require\"</code>.</em></li>\n<li><code>\"require\"</code> - matches when the package is loaded via <code>require()</code>. The\nreferenced file should be loadable with <code>require()</code> although the condition\nmatches regardless of the module format of the target file. Expected\nformats include CommonJS, JSON, and native addons but not ES modules as\n<code>require()</code> doesn't support them. <em>Always mutually exclusive with\n<code>\"import\"</code>.</em></li>\n<li><code>\"node\"</code> - matches for any Node.js environment. Can be a CommonJS or ES\nmodule file. <em>This condition should always come after <code>\"import\"</code> or\n<code>\"require\"</code>.</em></li>\n<li><code>\"default\"</code> - the generic fallback that always matches. Can be a CommonJS\nor ES module file. <em>This condition should always come last.</em></li>\n</ul>\n<p>Within the <a href=\"#packages_exports\"><code>\"exports\"</code></a> object, key order is significant. During condition\nmatching, earlier entries have higher priority and take precedence over later\nentries. <em>The general rule is that conditions should be from most specific to\nleast specific in object order</em>.</p>\n<p>Using the <code>\"import\"</code> and <code>\"require\"</code> conditions can lead to some hazards,\nwhich are further explained in <a href=\"#packages_dual_commonjs_es_module_packages\">the dual CommonJS/ES module packages section</a>.</p>\n<p>Conditional exports can also be extended to exports subpaths, for example:</p>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\",\n  \"exports\": {\n    \".\": \"./main.js\",\n    \"./feature\": {\n      \"node\": \"./feature-node.js\",\n      \"default\": \"./feature.js\"\n    }\n  }\n}\n</code></pre>\n<p>Defines a package where <code>require('pkg/feature')</code> and <code>import 'pkg/feature'</code>\ncould provide different implementations between Node.js and other JS\nenvironments.</p>\n<p>When using environment branches, always include a <code>\"default\"</code> condition where\npossible. Providing a <code>\"default\"</code> condition ensures that any unknown JS\nenvironments are able to use this universal implementation, which helps avoid\nthese JS environments from having to pretend to be existing environments in\norder to support packages with conditional exports. For this reason, using\n<code>\"node\"</code> and <code>\"default\"</code> condition branches is usually preferable to using\n<code>\"node\"</code> and <code>\"browser\"</code> condition branches.</p>",
               "type": "module",
               "displayName": "Conditional exports"
             },
             {
               "textRaw": "Nested conditions",
               "name": "nested_conditions",
-              "stability": 1,
-              "stabilityText": "Experimental",
               "desc": "<p>In addition to direct mappings, Node.js also supports nested condition objects.</p>\n<p>For example, to define a package that only has dual mode entry points for\nuse in Node.js but not the browser:</p>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\",\n  \"exports\": {\n    \"node\": {\n      \"import\": \"./feature-node.mjs\",\n      \"require\": \"./feature-node.cjs\"\n    },\n    \"default\": \"./feature.mjs\",\n  }\n}\n</code></pre>\n<p>Conditions continue to be matched in order as with flat conditions. If\na nested conditional does not have any mapping it will continue checking\nthe remaining conditions of the parent condition. In this way nested\nconditions behave analogously to nested JavaScript <code>if</code> statements.</p>",
               "type": "module",
               "displayName": "Nested conditions"
@@ -182,14 +234,44 @@
             {
               "textRaw": "Resolving user conditions",
               "name": "resolving_user_conditions",
+              "meta": {
+                "added": [
+                  "v14.9.0",
+                  "v12.19.0"
+                ],
+                "changes": []
+              },
               "desc": "<p>When running Node.js, custom user conditions can be added with the\n<code>--conditions</code> flag:</p>\n<pre><code class=\"language-bash\">node --conditions=development main.js\n</code></pre>\n<p>which would then resolve the <code>\"development\"</code> condition in package imports and\nexports, while resolving the existing <code>\"node\"</code>, <code>\"default\"</code>, <code>\"import\"</code>, and\n<code>\"require\"</code> conditions as appropriate.</p>\n<p>Any number of custom conditions can be set with repeat flags.</p>",
               "type": "module",
               "displayName": "Resolving user conditions"
             },
+            {
+              "textRaw": "Conditions Definitions",
+              "name": "conditions_definitions",
+              "desc": "<p>The <code>\"import\"</code>, <code>\"require\"</code>, <code>\"node\"</code> and <code>\"default\"</code> conditions are defined\nand implemented in Node.js core,\n<a href=\"#packages_conditional_exports\">as specified above</a>.</p>\n<p>Other condition strings are unknown to Node.js and thus ignored by default.\nRuntimes or tools other than Node.js can use them at their discretion.</p>\n<p>These user conditions can be enabled in Node.js via the <a href=\"#packages_resolving_user_conditions\"><code>--conditions</code>\nflag</a>.</p>\n<p>The following condition definitions are currently endorsed by Node.js:</p>\n<ul>\n<li><code>\"browser\"</code> - any environment which implements a standard subset of global\nbrowser APIs available from JavaScript in web browsers, including the DOM\nAPIs.</li>\n<li><code>\"development\"</code> - can be used to define a development-only environment\nentry point. <em>Must always be mutually exclusive with <code>\"production\"</code>.</em></li>\n<li><code>\"production\"</code> - can be used to define a production environment entry\npoint. <em>Must always be mutually exclusive with <code>\"development\"</code>.</em></li>\n</ul>\n<p>The above user conditions can be enabled in Node.js via the <a href=\"#packages_resolving_user_conditions\"><code>--conditions</code>\nflag</a>.</p>\n<p>Platform specific conditions such as <code>\"deno\"</code>, <code>\"electron\"</code>, or <code>\"react-native\"</code>\nmay be used, but while there remain no implementation or integration intent\nfrom these platforms, the above are not explicitly endorsed by Node.js.</p>\n<p>New conditions definitions may be added to this list by creating a pull request\nto the <a href=\"https://github.com/nodejs/node/blob/HEAD/doc/api/packages.md#conditions-definitions\">Node.js documentation for this section</a>. The requirements for listing\na new condition definition here are that:</p>\n<ul>\n<li>The definition should be clear and unambiguous for all implementers.</li>\n<li>The use case for why the condition is needed should be clearly justified.</li>\n<li>There should exist sufficient existing implementation usage.</li>\n<li>The condition name should not conflict with another condition definition or\ncondition in wide usage.</li>\n<li>The listing of the condition definition should provide a coordination\nbenefit to the ecosystem that wouldn't otherwise be possible. For example,\nthis would not necessarily be the case for company-specific or\napplication-specific conditions.</li>\n</ul>\n<p>The above definitions may be moved to a dedicated conditions registry in due\ncourse.</p>",
+              "type": "module",
+              "displayName": "Conditions Definitions"
+            },
             {
               "textRaw": "Self-referencing a package using its name",
               "name": "self-referencing_a_package_using_its_name",
-              "desc": "<p>Within a package, the values defined in the package’s\n<code>package.json</code> <a href=\"#packages_exports\"><code>\"exports\"</code></a> field can be referenced via the package’s name.\nFor example, assuming the <code>package.json</code> is:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"name\": \"a-package\",\n  \"exports\": {\n    \".\": \"./main.mjs\",\n    \"./foo\": \"./foo.js\"\n  }\n}\n</code></pre>\n<p>Then any module <em>in that package</em> can reference an export in the package itself:</p>\n<pre><code class=\"language-js\">// ./a-module.mjs\nimport { something } from 'a-package'; // Imports \"something\" from ./main.mjs.\n</code></pre>\n<p>Self-referencing is available only if <code>package.json</code> has <a href=\"#packages_exports\"><code>\"exports\"</code></a>, and\nwill allow importing only what that <a href=\"#packages_exports\"><code>\"exports\"</code></a> (in the <code>package.json</code>)\nallows. So the code below, given the previous package, will generate a runtime\nerror:</p>\n<pre><code class=\"language-js\">// ./another-module.mjs\n\n// Imports \"another\" from ./m.mjs. Fails because\n// the \"package.json\" \"exports\" field\n// does not provide an export named \"./m.mjs\".\nimport { another } from 'a-package/m.mjs';\n</code></pre>\n<p>Self-referencing is also available when using <code>require</code>, both in an ES module,\nand in a CommonJS one. For example, this code will also work:</p>\n<pre><code class=\"language-js\">// ./a-module.js\nconst { something } = require('a-package/foo'); // Loads from ./foo.js.\n</code></pre>",
+              "meta": {
+                "added": [
+                  "v13.1.0",
+                  "v12.16.0"
+                ],
+                "changes": [
+                  {
+                    "version": [
+                      "v13.6.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/31002",
+                    "description": "Unflag self-referencing a package using its name."
+                  }
+                ]
+              },
+              "desc": "<p>Within a package, the values defined in the package’s\n<code>package.json</code> <a href=\"#packages_exports\"><code>\"exports\"</code></a> field can be referenced via the package’s name.\nFor example, assuming the <code>package.json</code> is:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"name\": \"a-package\",\n  \"exports\": {\n    \".\": \"./main.mjs\",\n    \"./foo\": \"./foo.js\"\n  }\n}\n</code></pre>\n<p>Then any module <em>in that package</em> can reference an export in the package itself:</p>\n<pre><code class=\"language-js\">// ./a-module.mjs\nimport { something } from 'a-package'; // Imports \"something\" from ./main.mjs.\n</code></pre>\n<p>Self-referencing is available only if <code>package.json</code> has <a href=\"#packages_exports\"><code>\"exports\"</code></a>, and\nwill allow importing only what that <a href=\"#packages_exports\"><code>\"exports\"</code></a> (in the <code>package.json</code>)\nallows. So the code below, given the previous package, will generate a runtime\nerror:</p>\n<pre><code class=\"language-js\">// ./another-module.mjs\n\n// Imports \"another\" from ./m.mjs. Fails because\n// the \"package.json\" \"exports\" field\n// does not provide an export named \"./m.mjs\".\nimport { another } from 'a-package/m.mjs';\n</code></pre>\n<p>Self-referencing is also available when using <code>require</code>, both in an ES module,\nand in a CommonJS one. For example, this code will also work:</p>\n<pre><code class=\"language-cjs\">// ./a-module.js\nconst { something } = require('a-package/foo'); // Loads from ./foo.js.\n</code></pre>\n<p>Finally, self-referencing also works with scoped packages. For example, this\ncode will also work:</p>\n<pre><code class=\"language-json\">// package.json\n{\n  \"name\": \"@my/package\",\n  \"exports\": \"./index.js\"\n}\n</code></pre>\n<pre><code class=\"language-cjs\">// ./index.js\nmodule.exports = 42;\n</code></pre>\n<pre><code class=\"language-cjs\">// ./other.js\nconsole.log(require('@my/package'));\n</code></pre>\n<pre><code class=\"language-console\">$ node other.js\n42\n</code></pre>",
               "type": "module",
               "displayName": "Self-referencing a package using its name"
             }
@@ -217,14 +299,14 @@
                 {
                   "textRaw": "Approach #1: Use an ES module wrapper",
                   "name": "approach_#1:_use_an_es_module_wrapper",
-                  "desc": "<p>Write the package in CommonJS or transpile ES module sources into CommonJS, and\ncreate an ES module wrapper file that defines the named exports. Using\n<a href=\"#packages_conditional_exports\">Conditional exports</a>, the ES module wrapper is used for <code>import</code> and the\nCommonJS entry point for <code>require</code>.</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \"import\": \"./wrapper.mjs\",\n    \"require\": \"./index.cjs\"\n  }\n}\n</code></pre>\n<p>The preceding example uses explicit extensions <code>.mjs</code> and <code>.cjs</code>.\nIf your files use the <code>.js</code> extension, <code>\"type\": \"module\"</code> will cause such files\nto be treated as ES modules, just as <code>\"type\": \"commonjs\"</code> would cause them\nto be treated as CommonJS.\nSee <a href=\"#esm_enabling\">Enabling</a>.</p>\n<pre><code class=\"language-js\">// ./node_modules/pkg/index.cjs\nexports.name = 'value';\n</code></pre>\n<pre><code class=\"language-js\">// ./node_modules/pkg/wrapper.mjs\nimport cjsModule from './index.cjs';\nexport const name = cjsModule.name;\n</code></pre>\n<p>In this example, the <code>name</code> from <code>import { name } from 'pkg'</code> is the same\nsingleton as the <code>name</code> from <code>const { name } = require('pkg')</code>. Therefore <code>===</code>\nreturns <code>true</code> when comparing the two <code>name</code>s and the divergent specifier hazard\nis avoided.</p>\n<p>If the module is not simply a list of named exports, but rather contains a\nunique function or object export like <code>module.exports = function () { ... }</code>,\nor if support in the wrapper for the <code>import pkg from 'pkg'</code> pattern is desired,\nthen the wrapper would instead be written to export the default optionally\nalong with any named exports as well:</p>\n<pre><code class=\"language-js\">import cjsModule from './index.cjs';\nexport const name = cjsModule.name;\nexport default cjsModule;\n</code></pre>\n<p>This approach is appropriate for any of the following use cases:</p>\n<ul>\n<li>The package is currently written in CommonJS and the author would prefer not\nto refactor it into ES module syntax, but wishes to provide named exports for\nES module consumers.</li>\n<li>The package has other packages that depend on it, and the end user might\ninstall both this package and those other packages. For example a <code>utilities</code>\npackage is used directly in an application, and a <code>utilities-plus</code> package\nadds a few more functions to <code>utilities</code>. Because the wrapper exports\nunderlying CommonJS files, it doesn’t matter if <code>utilities-plus</code> is written in\nCommonJS or ES module syntax; it will work either way.</li>\n<li>The package stores internal state, and the package author would prefer not to\nrefactor the package to isolate its state management. See the next section.</li>\n</ul>\n<p>A variant of this approach not requiring conditional exports for consumers could\nbe to add an export, e.g. <code>\"./module\"</code>, to point to an all-ES module-syntax\nversion of the package. This could be used via <code>import 'pkg/module'</code> by users\nwho are certain that the CommonJS version will not be loaded anywhere in the\napplication, such as by dependencies; or if the CommonJS version can be loaded\nbut doesn’t affect the ES module version (for example, because the package is\nstateless):</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \".\": \"./index.cjs\",\n    \"./module\": \"./wrapper.mjs\"\n  }\n}\n</code></pre>",
+                  "desc": "<p>Write the package in CommonJS or transpile ES module sources into CommonJS, and\ncreate an ES module wrapper file that defines the named exports. Using\n<a href=\"#packages_conditional_exports\">Conditional exports</a>, the ES module wrapper is used for <code>import</code> and the\nCommonJS entry point for <code>require</code>.</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \"import\": \"./wrapper.mjs\",\n    \"require\": \"./index.cjs\"\n  }\n}\n</code></pre>\n<p>The preceding example uses explicit extensions <code>.mjs</code> and <code>.cjs</code>.\nIf your files use the <code>.js</code> extension, <code>\"type\": \"module\"</code> will cause such files\nto be treated as ES modules, just as <code>\"type\": \"commonjs\"</code> would cause them\nto be treated as CommonJS.\nSee <a href=\"esm.html#esm_enabling\">Enabling</a>.</p>\n<pre><code class=\"language-cjs\">// ./node_modules/pkg/index.cjs\nexports.name = 'value';\n</code></pre>\n<pre><code class=\"language-js\">// ./node_modules/pkg/wrapper.mjs\nimport cjsModule from './index.cjs';\nexport const name = cjsModule.name;\n</code></pre>\n<p>In this example, the <code>name</code> from <code>import { name } from 'pkg'</code> is the same\nsingleton as the <code>name</code> from <code>const { name } = require('pkg')</code>. Therefore <code>===</code>\nreturns <code>true</code> when comparing the two <code>name</code>s and the divergent specifier hazard\nis avoided.</p>\n<p>If the module is not simply a list of named exports, but rather contains a\nunique function or object export like <code>module.exports = function () { ... }</code>,\nor if support in the wrapper for the <code>import pkg from 'pkg'</code> pattern is desired,\nthen the wrapper would instead be written to export the default optionally\nalong with any named exports as well:</p>\n<pre><code class=\"language-js\">import cjsModule from './index.cjs';\nexport const name = cjsModule.name;\nexport default cjsModule;\n</code></pre>\n<p>This approach is appropriate for any of the following use cases:</p>\n<ul>\n<li>The package is currently written in CommonJS and the author would prefer not\nto refactor it into ES module syntax, but wishes to provide named exports for\nES module consumers.</li>\n<li>The package has other packages that depend on it, and the end user might\ninstall both this package and those other packages. For example a <code>utilities</code>\npackage is used directly in an application, and a <code>utilities-plus</code> package\nadds a few more functions to <code>utilities</code>. Because the wrapper exports\nunderlying CommonJS files, it doesn’t matter if <code>utilities-plus</code> is written in\nCommonJS or ES module syntax; it will work either way.</li>\n<li>The package stores internal state, and the package author would prefer not to\nrefactor the package to isolate its state management. See the next section.</li>\n</ul>\n<p>A variant of this approach not requiring conditional exports for consumers could\nbe to add an export, e.g. <code>\"./module\"</code>, to point to an all-ES module-syntax\nversion of the package. This could be used via <code>import 'pkg/module'</code> by users\nwho are certain that the CommonJS version will not be loaded anywhere in the\napplication, such as by dependencies; or if the CommonJS version can be loaded\nbut doesn’t affect the ES module version (for example, because the package is\nstateless):</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \".\": \"./index.cjs\",\n    \"./module\": \"./wrapper.mjs\"\n  }\n}\n</code></pre>",
                   "type": "module",
                   "displayName": "Approach #1: Use an ES module wrapper"
                 },
                 {
                   "textRaw": "Approach #2: Isolate state",
                   "name": "approach_#2:_isolate_state",
-                  "desc": "<p>A <a href=\"#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> file can define the separate CommonJS and ES module entry\npoints directly:</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \"import\": \"./index.mjs\",\n    \"require\": \"./index.cjs\"\n  }\n}\n</code></pre>\n<p>This can be done if both the CommonJS and ES module versions of the package are\nequivalent, for example because one is the transpiled output of the other; and\nthe package’s management of state is carefully isolated (or the package is\nstateless).</p>\n<p>The reason that state is an issue is because both the CommonJS and ES module\nversions of the package might get used within an application; for example, the\nuser’s application code could <code>import</code> the ES module version while a dependency\n<code>require</code>s the CommonJS version. If that were to occur, two copies of the\npackage would be loaded in memory and therefore two separate states would be\npresent. This would likely cause hard-to-troubleshoot bugs.</p>\n<p>Aside from writing a stateless package (if JavaScript’s <code>Math</code> were a package,\nfor example, it would be stateless as all of its methods are static), there are\nsome ways to isolate state so that it’s shared between the potentially loaded\nCommonJS and ES module instances of the package:</p>\n<ol>\n<li>\n<p>If possible, contain all state within an instantiated object. JavaScript’s\n<code>Date</code>, for example, needs to be instantiated to contain state; if it were a\npackage, it would be used like this:</p>\n<pre><code class=\"language-js\">import Date from 'date';\nconst someDate = new Date();\n// someDate contains state; Date does not\n</code></pre>\n<p>The <code>new</code> keyword isn’t required; a package’s function can return a new\nobject, or modify a passed-in object, to keep the state external to the\npackage.</p>\n</li>\n<li>\n<p>Isolate the state in one or more CommonJS files that are shared between the\nCommonJS and ES module versions of the package. For example, if the CommonJS\nand ES module entry points are <code>index.cjs</code> and <code>index.mjs</code>, respectively:</p>\n<pre><code class=\"language-js\">// ./node_modules/pkg/index.cjs\nconst state = require('./state.cjs');\nmodule.exports.state = state;\n</code></pre>\n<pre><code class=\"language-js\">// ./node_modules/pkg/index.mjs\nimport state from './state.cjs';\nexport {\n  state\n};\n</code></pre>\n<p>Even if <code>pkg</code> is used via both <code>require</code> and <code>import</code> in an application (for\nexample, via <code>import</code> in application code and via <code>require</code> by a dependency)\neach reference of <code>pkg</code> will contain the same state; and modifying that\nstate from either module system will apply to both.</p>\n</li>\n</ol>\n<p>Any plugins that attach to the package’s singleton would need to separately\nattach to both the CommonJS and ES module singletons.</p>\n<p>This approach is appropriate for any of the following use cases:</p>\n<ul>\n<li>The package is currently written in ES module syntax and the package author\nwants that version to be used wherever such syntax is supported.</li>\n<li>The package is stateless or its state can be isolated without too much\ndifficulty.</li>\n<li>The package is unlikely to have other public packages that depend on it, or if\nit does, the package is stateless or has state that need not be shared between\ndependencies or with the overall application.</li>\n</ul>\n<p>Even with isolated state, there is still the cost of possible extra code\nexecution between the CommonJS and ES module versions of a package.</p>\n<p>As with the previous approach, a variant of this approach not requiring\nconditional exports for consumers could be to add an export, e.g.\n<code>\"./module\"</code>, to point to an all-ES module-syntax version of the package:</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \".\": \"./index.cjs\",\n    \"./module\": \"./index.mjs\"\n  }\n}\n</code></pre>",
+                  "desc": "<p>A <a href=\"#packages_node_js_package_json_field_definitions\"><code>package.json</code></a> file can define the separate CommonJS and ES module entry\npoints directly:</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \"import\": \"./index.mjs\",\n    \"require\": \"./index.cjs\"\n  }\n}\n</code></pre>\n<p>This can be done if both the CommonJS and ES module versions of the package are\nequivalent, for example because one is the transpiled output of the other; and\nthe package’s management of state is carefully isolated (or the package is\nstateless).</p>\n<p>The reason that state is an issue is because both the CommonJS and ES module\nversions of the package might get used within an application; for example, the\nuser’s application code could <code>import</code> the ES module version while a dependency\n<code>require</code>s the CommonJS version. If that were to occur, two copies of the\npackage would be loaded in memory and therefore two separate states would be\npresent. This would likely cause hard-to-troubleshoot bugs.</p>\n<p>Aside from writing a stateless package (if JavaScript’s <code>Math</code> were a package,\nfor example, it would be stateless as all of its methods are static), there are\nsome ways to isolate state so that it’s shared between the potentially loaded\nCommonJS and ES module instances of the package:</p>\n<ol>\n<li>\n<p>If possible, contain all state within an instantiated object. JavaScript’s\n<code>Date</code>, for example, needs to be instantiated to contain state; if it were a\npackage, it would be used like this:</p>\n<pre><code class=\"language-js\">import Date from 'date';\nconst someDate = new Date();\n// someDate contains state; Date does not\n</code></pre>\n<p>The <code>new</code> keyword isn’t required; a package’s function can return a new\nobject, or modify a passed-in object, to keep the state external to the\npackage.</p>\n</li>\n<li>\n<p>Isolate the state in one or more CommonJS files that are shared between the\nCommonJS and ES module versions of the package. For example, if the CommonJS\nand ES module entry points are <code>index.cjs</code> and <code>index.mjs</code>, respectively:</p>\n<pre><code class=\"language-cjs\">// ./node_modules/pkg/index.cjs\nconst state = require('./state.cjs');\nmodule.exports.state = state;\n</code></pre>\n<pre><code class=\"language-js\">// ./node_modules/pkg/index.mjs\nimport state from './state.cjs';\nexport {\n  state\n};\n</code></pre>\n<p>Even if <code>pkg</code> is used via both <code>require</code> and <code>import</code> in an application (for\nexample, via <code>import</code> in application code and via <code>require</code> by a dependency)\neach reference of <code>pkg</code> will contain the same state; and modifying that\nstate from either module system will apply to both.</p>\n</li>\n</ol>\n<p>Any plugins that attach to the package’s singleton would need to separately\nattach to both the CommonJS and ES module singletons.</p>\n<p>This approach is appropriate for any of the following use cases:</p>\n<ul>\n<li>The package is currently written in ES module syntax and the package author\nwants that version to be used wherever such syntax is supported.</li>\n<li>The package is stateless or its state can be isolated without too much\ndifficulty.</li>\n<li>The package is unlikely to have other public packages that depend on it, or if\nit does, the package is stateless or has state that need not be shared between\ndependencies or with the overall application.</li>\n</ul>\n<p>Even with isolated state, there is still the cost of possible extra code\nexecution between the CommonJS and ES module versions of a package.</p>\n<p>As with the previous approach, a variant of this approach not requiring\nconditional exports for consumers could be to add an export, e.g.\n<code>\"./module\"</code>, to point to an all-ES module-syntax version of the package:</p>\n<pre><code class=\"language-json\">// ./node_modules/pkg/package.json\n{\n  \"type\": \"module\",\n  \"main\": \"./index.cjs\",\n  \"exports\": {\n    \".\": \"./index.cjs\",\n    \"./module\": \"./index.mjs\"\n  }\n}\n</code></pre>",
                   "type": "module",
                   "displayName": "Approach #2: Isolate state"
                 }
@@ -239,18 +321,20 @@
         {
           "textRaw": "Node.js `package.json` field definitions",
           "name": "node.js_`package.json`_field_definitions",
-          "desc": "<p>This section describes the fields used by the Node.js runtime. Other tools (such\nas <a href=\"https://docs.npmjs.com/creating-a-package-json-file\">npm</a>) use\nadditional fields which are ignored by Node.js and not documented here.</p>\n<p>The following fields in <code>package.json</code> files are used in Node.js:</p>\n<ul>\n<li><a href=\"#packages_name\"><code>\"name\"</code></a> - Relevant when using named imports within a package. Also used\nby package managers as the name of the package.</li>\n<li><a href=\"#packages_type\"><code>\"type\"</code></a> - The package type determining whether to load <code>.js</code> files as\nCommonJS or ES modules.</li>\n<li><a href=\"#packages_exports\"><code>\"exports\"</code></a> - Package exports and conditional exports. When present,\nlimits which submodules can be loaded from within the package.</li>\n<li><a href=\"#packages_main\"><code>\"main\"</code></a> - The default module when loading the package, if exports is not\nspecified, and in versions of Node.js prior to the introduction of exports.</li>\n<li><a href=\"#packages_imports\"><code>\"imports\"</code></a> - Package imports, for use by modules within the package\nitself.</li>\n</ul>",
+          "desc": "<p>This section describes the fields used by the Node.js runtime. Other tools (such\nas <a href=\"https://docs.npmjs.com/creating-a-package-json-file\">npm</a>) use\nadditional fields which are ignored by Node.js and not documented here.</p>\n<p>The following fields in <code>package.json</code> files are used in Node.js:</p>\n<ul>\n<li><a href=\"#packages_name\"><code>\"name\"</code></a> - Relevant when using named imports within a package. Also used\nby package managers as the name of the package.</li>\n<li><a href=\"#packages_main\"><code>\"main\"</code></a> - The default module when loading the package, if exports is not\nspecified, and in versions of Node.js prior to the introduction of exports.</li>\n<li><a href=\"#packages_type\"><code>\"type\"</code></a> - The package type determining whether to load <code>.js</code> files as\nCommonJS or ES modules.</li>\n<li><a href=\"#packages_exports\"><code>\"exports\"</code></a> - Package exports and conditional exports. When present,\nlimits which submodules can be loaded from within the package.</li>\n<li><a href=\"#packages_imports\"><code>\"imports\"</code></a> - Package imports, for use by modules within the package\nitself.</li>\n</ul>",
           "modules": [
             {
               "textRaw": "`\"name\"`",
               "name": "`\"name\"`",
               "meta": {
                 "added": [
+                  "v13.1.0",
                   "v12.16.0"
                 ],
                 "changes": [
                   {
                     "version": [
+                      "v13.6.0",
                       "v12.16.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/31002",
@@ -262,6 +346,19 @@
               "type": "module",
               "displayName": "`\"name\"`"
             },
+            {
+              "textRaw": "`\"main\"`",
+              "name": "`\"main\"`",
+              "meta": {
+                "added": [
+                  "v0.4.0"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li>Type: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\"\n}\n</code></pre>\n<p>The <code>\"main\"</code> field defines the script that is used when the <a href=\"modules.html#modules_folders_as_modules\">package directory\nis loaded via <code>require()</code></a>. Its value\nis a path.</p>\n<pre><code class=\"language-cjs\">require('./path/to/directory'); // This resolves to ./path/to/directory/main.js.\n</code></pre>\n<p>When a package has an <a href=\"#packages_exports\"><code>\"exports\"</code></a> field, this will take precedence over the\n<code>\"main\"</code> field when importing the package by name.</p>",
+              "type": "module",
+              "displayName": "`\"main\"`"
+            },
             {
               "textRaw": "`\"type\"`",
               "name": "`\"type\"`",
@@ -272,6 +369,7 @@
                 "changes": [
                   {
                     "version": [
+                      "v13.2.0",
                       "v12.17.0"
                     ],
                     "pr-url": "https://github.com/nodejs/node/pull/29866",
@@ -293,31 +391,35 @@
                 "changes": [
                   {
                     "version": [
-                      "v12.16.0"
+                      "v14.13.0",
+                      "v12.20.0"
                     ],
-                    "pr-url": "https://github.com/nodejs/node/pull/29978",
-                    "description": "Implement conditional exports."
+                    "pr-url": "https://github.com/nodejs/node/pull/34718",
+                    "description": "Add support for `\"exports\"` patterns."
                   },
                   {
                     "version": [
+                      "v13.7.0",
                       "v12.16.0"
                     ],
-                    "pr-url": "https://github.com/nodejs/node/pull/31001",
-                    "description": "Remove the `--experimental-conditional-exports` option."
+                    "pr-url": "https://github.com/nodejs/node/pull/31008",
+                    "description": "Implement logical conditional exports ordering."
                   },
                   {
                     "version": [
+                      "v13.7.0",
                       "v12.16.0"
                     ],
-                    "pr-url": "https://github.com/nodejs/node/pull/31008",
-                    "description": "Implement logical conditional exports ordering."
+                    "pr-url": "https://github.com/nodejs/node/pull/31001",
+                    "description": "Remove the `--experimental-conditional-exports` option."
                   },
                   {
                     "version": [
-                      "v12.20.0"
+                      "v13.2.0",
+                      "v12.16.0"
                     ],
-                    "pr-url": "https://github.com/nodejs/node/pull/34718",
-                    "description": "Add support for `\"exports\"` patterns."
+                    "pr-url": "https://github.com/nodejs/node/pull/29978",
+                    "description": "Implement conditional exports."
                   }
                 ]
               },
@@ -325,30 +427,16 @@
               "type": "module",
               "displayName": "`\"exports\"`"
             },
-            {
-              "textRaw": "`\"main\"`",
-              "name": "`\"main\"`",
-              "meta": {
-                "added": [
-                  "v0.4.0"
-                ],
-                "changes": []
-              },
-              "desc": "<ul>\n<li>Type: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">{\n  \"main\": \"./main.js\"\n}\n</code></pre>\n<p>The <code>\"main\"</code> field defines the script that is used when the <a href=\"modules.html#modules_folders_as_modules\">package directory\nis loaded via <code>require()</code></a>. Its value\nis interpreted as a path.</p>\n<pre><code class=\"language-js\">require('./path/to/directory'); // This resolves to ./path/to/directory/main.js.\n</code></pre>\n<p>When a package has an <a href=\"#packages_exports\"><code>\"exports\"</code></a> field, this will take precedence over the\n<code>\"main\"</code> field when importing the package by name.</p>",
-              "type": "module",
-              "displayName": "`\"main\"`"
-            },
             {
               "textRaw": "`\"imports\"`",
               "name": "`\"imports\"`",
               "meta": {
                 "added": [
+                  "v14.6.0",
                   "v12.19.0"
                 ],
                 "changes": []
               },
-              "stability": 1,
-              "stabilityText": "Experimental",
               "desc": "<ul>\n<li>Type: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">// package.json\n{\n  \"imports\": {\n    \"#dep\": {\n      \"node\": \"dep-node-native\",\n      \"default\": \"./dep-polyfill.js\"\n    }\n  },\n  \"dependencies\": {\n    \"dep-node-native\": \"^1.0.0\"\n  }\n}\n</code></pre>\n<p>Entries in the imports field must be strings starting with <code>#</code>.</p>\n<p>Import maps permit mapping to external packages.</p>\n<p>This field defines <a href=\"#packages_subpath_imports\">subpath imports</a> for the current package.</p>",
               "type": "module",
               "displayName": "`\"imports\"`"
diff --git a/doc/api/packages.md b/doc/api/packages.md
index 216f6f5ba8d830453397c4bb5536bd982c023229..739db6d273e46edcd7ee9876553539eb38a17a9d 100644
--- a/doc/api/packages.md
+++ b/doc/api/packages.md
@@ -1,19 +1,25 @@
 # Modules: Packages
 
+<!--introduced_in=v12.20.0-->
 <!-- type=misc -->
 <!-- YAML
 changes:
-  - version: v12.20.0
+  - version:
+    - v14.13.0
     pr-url: https://github.com/nodejs/node/pull/34718
     description: Add support for `"exports"` patterns.
-  - version: v12.19.0
+  - version:
+    - v14.6.0
+    - v12.19.0
     pr-url: https://github.com/nodejs/node/pull/34117
     description: Add package `"imports"` field.
   - version:
+    - v13.7.0
     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/31001
     description: Unflag conditional exports.
   - version:
+    - v13.6.0
     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/31002
     description: Unflag self-referencing a package using its name.
@@ -131,6 +137,9 @@ package:
   `"commonjs"` package).
 
 ### `--input-type` flag
+<!-- YAML
+added: v12.0.0
+-->
 
 Strings passed in as an argument to `--eval` (or `-e`), or piped to `node` via
 `STDIN`, are treated as [ES modules][] when the `--input-type=module` flag
@@ -248,8 +257,9 @@ absolute subpath of the package such as
 `require('/path/to/node_modules/pkg/subpath.js')` will still load `subpath.js`.
 
 ### Subpath exports
-
-> Stability: 1 - Experimental
+<!-- YAML
+added: v12.7.0
+-->
 
 When using the [`"exports"`][] field, custom subpaths can be defined along
 with the main entry point by treating the main entry point as the
@@ -280,8 +290,11 @@ import submodule from 'es-module-package/private-module.js';
 ```
 
 ### Subpath imports
-
-> Stability: 1 - Experimental
+<!-- YAML
+added:
+  - v14.6.0
+  - v12.19.0
+-->
 
 In addition to the [`"exports"`][] field, it is possible to define internal
 package import maps that only apply to import specifiers from within the package
@@ -319,8 +332,11 @@ The resolution rules for the imports field are otherwise
 analogous to the exports field.
 
 ### Subpath patterns
-
-> Stability: 1 - Experimental
+<!-- YAML
+added:
+  - v14.13.0
+  - v12.20.0
+-->
 
 For packages with a small number of exports or imports, we recommend
 explicitly listing each exports subpath entry. But for packages that have
@@ -341,6 +357,9 @@ For these use cases, subpath export patterns can be used instead:
 }
 ```
 
+**`*` maps expose nested subpaths as it is a string replacement syntax
+only.**
+
 The left hand matching pattern must always end in `*`. All instances of `*` on
 the right hand side will then be replaced with this value, including if it
 contains any `/` separators.
@@ -366,9 +385,30 @@ treating the right hand side target pattern as a `**` glob against the list of
 files within the package. Because `node_modules` paths are forbidden in exports
 targets, this expansion is dependent on only the files of the package itself.
 
-### Exports sugar
+To exclude private subfolders from patterns, `null` targets can be used:
 
-> Stability: 1 - Experimental
+```json
+// ./node_modules/es-module-package/package.json
+{
+  "exports": {
+    "./features/*": "./src/features/*.js",
+    "./features/private-internal/*": null
+  }
+}
+```
+
+```js
+import featureInternal from 'es-module-package/features/private-internal/m';
+// Throws: ERR_PACKAGE_PATH_NOT_EXPORTED
+
+import featureX from 'es-module-package/features/x';
+// Loads ./node_modules/es-module-package/src/features/x.js
+```
+
+### Exports sugar
+<!-- YAML
+added: v12.11.0
+-->
 
 If the `"."` export is the only export, the [`"exports"`][] field provides sugar
 for this case being the direct [`"exports"`][] field value.
@@ -393,8 +433,17 @@ can be written:
 ```
 
 ### Conditional exports
-
-> Stability: 1 - Experimental
+<!-- YAML
+added:
+  - v13.2.0
+  - v12.16.0
+changes:
+  - version:
+    - v13.7.0
+    - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/31001
+    description: Unflag conditional exports.
+-->
 
 Conditional exports provide a way to map to different paths depending on
 certain conditions. They are supported for both CommonJS and ES module imports.
@@ -414,7 +463,7 @@ For example, a package that wants to provide different ES module exports for
 }
 ```
 
-Node.js supports the following conditions out of the box:
+Node.js implements the following conditions:
 
 * `"import"` - matches when the package is loaded via `import` or
    `import()`, or via any top-level import or resolve operation by the
@@ -437,11 +486,6 @@ matching, earlier entries have higher priority and take precedence over later
 entries. _The general rule is that conditions should be from most specific to
 least specific in object order_.
 
-Other conditions such as `"browser"`, `"electron"`, `"deno"`, `"react-native"`,
-etc., are unknown to Node.js, and thus ignored. Runtimes or tools other than
-Node.js can use them at their discretion. Further restrictions, definitions, or
-guidance on condition names might occur in the future.
-
 Using the `"import"` and `"require"` conditions can lead to some hazards,
 which are further explained in [the dual CommonJS/ES module packages section][].
 
@@ -474,8 +518,6 @@ order to support packages with conditional exports. For this reason, using
 
 ### Nested conditions
 
-> Stability: 1 - Experimental
-
 In addition to direct mappings, Node.js also supports nested condition objects.
 
 For example, to define a package that only has dual mode entry points for
@@ -500,6 +542,11 @@ the remaining conditions of the parent condition. In this way nested
 conditions behave analogously to nested JavaScript `if` statements.
 
 ### Resolving user conditions
+<!-- YAML
+added:
+  - v14.9.0
+  - v12.19.0
+-->
 
 When running Node.js, custom user conditions can be added with the
 `--conditions` flag:
@@ -514,7 +561,64 @@ exports, while resolving the existing `"node"`, `"default"`, `"import"`, and
 
 Any number of custom conditions can be set with repeat flags.
 
+### Conditions Definitions
+
+The `"import"`, `"require"`, `"node"` and `"default"` conditions are defined
+and implemented in Node.js core,
+[as specified above](#packages_conditional_exports).
+
+Other condition strings are unknown to Node.js and thus ignored by default.
+Runtimes or tools other than Node.js can use them at their discretion.
+
+These user conditions can be enabled in Node.js via the [`--conditions`
+flag](#packages_resolving_user_conditions).
+
+The following condition definitions are currently endorsed by Node.js:
+
+* `"browser"` - any environment which implements a standard subset of global
+   browser APIs available from JavaScript in web browsers, including the DOM
+   APIs.
+* `"development"` - can be used to define a development-only environment
+   entry point. _Must always be mutually exclusive with `"production"`._
+* `"production"` - can be used to define a production environment entry
+   point. _Must always be mutually exclusive with `"development"`._
+
+The above user conditions can be enabled in Node.js via the [`--conditions`
+flag](#packages_resolving_user_conditions).
+
+Platform specific conditions such as `"deno"`, `"electron"`, or `"react-native"`
+may be used, but while there remain no implementation or integration intent
+from these platforms, the above are not explicitly endorsed by Node.js.
+
+New conditions definitions may be added to this list by creating a pull request
+to the [Node.js documentation for this section][]. The requirements for listing
+a new condition definition here are that:
+
+* The definition should be clear and unambiguous for all implementers.
+* The use case for why the condition is needed should be clearly justified.
+* There should exist sufficient existing implementation usage.
+* The condition name should not conflict with another condition definition or
+  condition in wide usage.
+* The listing of the condition definition should provide a coordination
+  benefit to the ecosystem that wouldn't otherwise be possible. For example,
+  this would not necessarily be the case for company-specific or
+  application-specific conditions.
+
+The above definitions may be moved to a dedicated conditions registry in due
+course.
+
 ### Self-referencing a package using its name
+<!-- YAML
+added:
+  - v13.1.0
+  - v12.16.0
+changes:
+  - version:
+    - v13.6.0
+    - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/31002
+    description: Unflag self-referencing a package using its name.
+-->
 
 Within a package, the values defined in the package’s
 `package.json` [`"exports"`][] field can be referenced via the package’s name.
@@ -555,11 +659,37 @@ import { another } from 'a-package/m.mjs';
 Self-referencing is also available when using `require`, both in an ES module,
 and in a CommonJS one. For example, this code will also work:
 
-```js
+```cjs
 // ./a-module.js
 const { something } = require('a-package/foo'); // Loads from ./foo.js.
 ```
 
+Finally, self-referencing also works with scoped packages. For example, this
+code will also work:
+
+```json
+// package.json
+{
+  "name": "@my/package",
+  "exports": "./index.js"
+}
+```
+
+```cjs
+// ./index.js
+module.exports = 42;
+```
+
+```cjs
+// ./other.js
+console.log(require('@my/package'));
+```
+
+```console
+$ node other.js
+42
+```
+
 ## Dual CommonJS/ES module packages
 
 Prior to the introduction of support for ES modules in Node.js, it was a common
@@ -656,9 +786,9 @@ The preceding example uses explicit extensions `.mjs` and `.cjs`.
 If your files use the `.js` extension, `"type": "module"` will cause such files
 to be treated as ES modules, just as `"type": "commonjs"` would cause them
 to be treated as CommonJS.
-See [Enabling](#esm_enabling).
+See [Enabling](esm.md#esm_enabling).
 
-```js
+```cjs
 // ./node_modules/pkg/index.cjs
 exports.name = 'value';
 ```
@@ -771,7 +901,7 @@ CommonJS and ES module instances of the package:
    CommonJS and ES module versions of the package. For example, if the CommonJS
    and ES module entry points are `index.cjs` and `index.mjs`, respectively:
 
-    ```js
+    ```cjs
     // ./node_modules/pkg/index.cjs
     const state = require('./state.cjs');
     module.exports.state = state;
@@ -831,21 +961,23 @@ The following fields in `package.json` files are used in Node.js:
 
 * [`"name"`][] - Relevant when using named imports within a package. Also used
   by package managers as the name of the package.
+* [`"main"`][] - The default module when loading the package, if exports is not
+  specified, and in versions of Node.js prior to the introduction of exports.
 * [`"type"`][] - The package type determining whether to load `.js` files as
   CommonJS or ES modules.
 * [`"exports"`][] - Package exports and conditional exports. When present,
   limits which submodules can be loaded from within the package.
-* [`"main"`][] - The default module when loading the package, if exports is not
-  specified, and in versions of Node.js prior to the introduction of exports.
 * [`"imports"`][] - Package imports, for use by modules within the package
   itself.
 
 ### `"name"`
 <!-- YAML
 added:
+  - v13.1.0
   - v12.16.0
 changes:
   - version:
+    - v13.6.0
     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/31002
     description: Remove the `--experimental-resolve-self` option.
@@ -866,11 +998,36 @@ _npm_ registry requires a name that satisfies
 The `"name"` field can be used in addition to the [`"exports"`][] field to
 [self-reference][] a package using its name.
 
+### `"main"`
+<!-- YAML
+added: v0.4.0
+-->
+
+* Type: {string}
+
+```json
+{
+  "main": "./main.js"
+}
+```
+
+The `"main"` field defines the script that is used when the [package directory
+is loaded via `require()`](modules.md#modules_folders_as_modules). Its value
+is a path.
+
+```cjs
+require('./path/to/directory'); // This resolves to ./path/to/directory/main.js.
+```
+
+When a package has an [`"exports"`][] field, this will take precedence over the
+`"main"` field when importing the package by name.
+
 ### `"type"`
 <!-- YAML
 added: v12.0.0
 changes:
   - version:
+    - v13.2.0
     - v12.17.0
     pr-url: https://github.com/nodejs/node/pull/29866
     description: Unflag `--experimental-modules`.
@@ -922,21 +1079,25 @@ as ES modules and `.cjs` files are always treated as CommonJS.
 added: v12.7.0
 changes:
   - version:
+    - v14.13.0
+    - v12.20.0
+    pr-url: https://github.com/nodejs/node/pull/34718
+    description: Add support for `"exports"` patterns.
+  - version:
+    - v13.7.0
     - v12.16.0
-    pr-url: https://github.com/nodejs/node/pull/29978
-    description: Implement conditional exports.
+    pr-url: https://github.com/nodejs/node/pull/31008
+    description: Implement logical conditional exports ordering.
   - version:
+    - v13.7.0
     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/31001
     description: Remove the `--experimental-conditional-exports` option.
   - version:
+    - v13.2.0
     - v12.16.0
-    pr-url: https://github.com/nodejs/node/pull/31008
-    description: Implement logical conditional exports ordering.
-  - version:
-    - v12.20.0
-    pr-url: https://github.com/nodejs/node/pull/34718
-    description: Add support for `"exports"` patterns.
+    pr-url: https://github.com/nodejs/node/pull/29978
+    description: Implement conditional exports.
 -->
 
 * Type: {Object} | {string} | {string[]}
@@ -960,37 +1121,13 @@ referenced via `require` or via `import`.
 All paths defined in the `"exports"` must be relative file URLs starting with
 `./`.
 
-### `"main"`
-<!-- YAML
-added: v0.4.0
--->
-
-* Type: {string}
-
-```json
-{
-  "main": "./main.js"
-}
-```
-
-The `"main"` field defines the script that is used when the [package directory
-is loaded via `require()`](modules.html#modules_folders_as_modules). Its value
-is interpreted as a path.
-
-```js
-require('./path/to/directory'); // This resolves to ./path/to/directory/main.js.
-```
-
-When a package has an [`"exports"`][] field, this will take precedence over the
-`"main"` field when importing the package by name.
-
 ### `"imports"`
 <!-- YAML
-added: v12.19.0
+added:
+ - v14.6.0
+ - v12.19.0
 -->
 
-> Stability: 1 - Experimental
-
 * Type: {Object}
 
 ```json
@@ -1015,21 +1152,22 @@ Import maps permit mapping to external packages.
 This field defines [subpath imports][] for the current package.
 
 [Babel]: https://babeljs.io/
+[CommonJS]: modules.md
 [Conditional exports]: #packages_conditional_exports
-[CommonJS]: modules.html
-[`ERR_PACKAGE_PATH_NOT_EXPORTED`]: errors.html#errors_err_package_path_not_exported
-[ES modules]: esm.html
-[ES module]: esm.html
-[`esm`]: https://github.com/standard-things/esm#readme
+[ES module]: esm.md
+[ES modules]: esm.md
+[Node.js documentation for this section]: https://github.com/nodejs/node/blob/HEAD/doc/api/packages.md#conditions-definitions
 [`"exports"`]: #packages_exports
+[`"imports"`]: #packages_imports
 [`"main"`]: #packages_main
 [`"name"`]: #packages_name
-[`"imports"`]: #packages_imports
 [`"type"`]: #packages_type
-[entry points]: #packages_package_entry_points
+[`ERR_PACKAGE_PATH_NOT_EXPORTED`]: errors.md#errors_err_package_path_not_exported
+[`esm`]: https://github.com/standard-things/esm#readme
 [`package.json`]: #packages_node_js_package_json_field_definitions
+[entry points]: #packages_package_entry_points
 [self-reference]: #packages_self_referencing_a_package_using_its_name
 [subpath exports]: #packages_subpath_exports
 [subpath imports]: #packages_subpath_imports
-[the full specifier path]: esm.md#esm_mandatory_file_extensions
 [the dual CommonJS/ES module packages section]: #packages_dual_commonjs_es_module_packages
+[the full specifier path]: esm.md#esm_mandatory_file_extensions
diff --git a/doc/api/path.html b/doc/api/path.html
index 27b53d417a9ac93e7a44b20d058d3c0418c36256..cf6a71c97a8deb47b82e956e9d3dd2a9d6eae05f 100644
--- a/doc/api/path.html
+++ b/doc/api/path.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Path | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Path | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="path" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/path.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/path.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/path.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/path.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/path.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/path.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/path.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/path.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/path.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#path_path">Path</a></span>
 <ul>
 <li><a href="#path_windows_vs_posix">Windows vs. POSIX</a></li>
@@ -147,45 +160,44 @@
 <li><a href="#path_path_win32"><code>path.win32</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Path<span><a class="mark" href="#path_path" id="path_path">#</a></span></h1>
+        <h2>Path<span><a class="mark" href="#path_path" id="path_path">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/path.js">lib/path.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/path.js">lib/path.js</a></p>
 <p>The <code>path</code> module provides utilities for working with file and directory paths.
 It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> path = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);</code></pre>
-<h2>Windows vs. POSIX<span><a class="mark" href="#path_windows_vs_posix" id="path_windows_vs_posix">#</a></span></h2>
+<section><h3>Windows vs. POSIX<span><a class="mark" href="#path_windows_vs_posix" id="path_windows_vs_posix">#</a></span></h3>
 <p>The default operation of the <code>path</code> module varies based on the operating system
 on which a Node.js application is running. Specifically, when running on a
 Windows operating system, the <code>path</code> module will assume that Windows-style
 paths are being used.</p>
 <p>So using <code>path.basename()</code> might yield different results on POSIX and Windows:</p>
 <p>On POSIX:</p>
-<pre><code class="language-js">path.basename(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
 <span class="hljs-comment">// Returns: 'C:\\temp\\myfile.html'</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.basename(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
 <span class="hljs-comment">// Returns: 'myfile.html'</span></code></pre>
 <p>To achieve consistent results when working with Windows file paths on any
 operating system, use <a href="#path_path_win32"><code>path.win32</code></a>:</p>
 <p>On POSIX and Windows:</p>
-<pre><code class="language-js">path.win32.basename(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-property">win32</span>.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\temp\\myfile.html'</span>);
 <span class="hljs-comment">// Returns: 'myfile.html'</span></code></pre>
 <p>To achieve consistent results when working with POSIX file paths on any
 operating system, use <a href="#path_path_posix"><code>path.posix</code></a>:</p>
 <p>On POSIX and Windows:</p>
-<pre><code class="language-js">path.posix.basename(<span class="hljs-string">'/tmp/myfile.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-property">posix</span>.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'/tmp/myfile.html'</span>);
 <span class="hljs-comment">// Returns: 'myfile.html'</span></code></pre>
 <p>On Windows Node.js follows the concept of per-drive working directory.
 This behavior can be observed when using a drive path without a backslash. For
 example, <code>path.resolve('C:\\')</code> can potentially return a different result than
 <code>path.resolve('C:')</code>. For more information, see
 <a href="https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths">this MSDN page</a>.</p>
-<h2><code>path.basename(path[, ext])</code><span><a class="mark" href="#path_path_basename_path_ext" id="path_path_basename_path_ext">#</a></span></h2>
+</section><section><h3><code>path.basename(path[, ext])</code><span><a class="mark" href="#path_path_basename_path_ext" id="path_path_basename_path_ext">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -205,23 +217,23 @@ example, <code>path.resolve('C:\\')</code> can potentially return a different re
 <p>The <code>path.basename()</code> method returns the last portion of a <code>path</code>, similar to
 the Unix <code>basename</code> command. Trailing directory separators are ignored, see
 <a href="#path_path_sep"><code>path.sep</code></a>.</p>
-<pre><code class="language-js">path.basename(<span class="hljs-string">'/foo/bar/baz/asdf/quux.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'/foo/bar/baz/asdf/quux.html'</span>);
 <span class="hljs-comment">// Returns: 'quux.html'</span>
 
-path.basename(<span class="hljs-string">'/foo/bar/baz/asdf/quux.html'</span>, <span class="hljs-string">'.html'</span>);
+path.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'/foo/bar/baz/asdf/quux.html'</span>, <span class="hljs-string">'.html'</span>);
 <span class="hljs-comment">// Returns: 'quux'</span></code></pre>
 <p>Although Windows usually treats file names, including file extensions, in a
 case-insensitive manner, this function does not. For example, <code>C:\\foo.html</code> and
 <code>C:\\foo.HTML</code> refer to the same file, but <code>basename</code> treats the extension as a
 case-sensitive string:</p>
-<pre><code class="language-js">path.win32.basename(<span class="hljs-string">'C:\\foo.html'</span>, <span class="hljs-string">'.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-property">win32</span>.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\foo.html'</span>, <span class="hljs-string">'.html'</span>);
 <span class="hljs-comment">// Returns: 'foo'</span>
 
-path.win32.basename(<span class="hljs-string">'C:\\foo.HTML'</span>, <span class="hljs-string">'.html'</span>);
+path.<span class="hljs-property">win32</span>.<span class="hljs-title function_">basename</span>(<span class="hljs-string">'C:\\foo.HTML'</span>, <span class="hljs-string">'.html'</span>);
 <span class="hljs-comment">// Returns: 'foo.HTML'</span></code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string or if <code>ext</code> is given
 and is not a string.</p>
-<h2><code>path.delimiter</code><span><a class="mark" href="#path_path_delimiter" id="path_path_delimiter">#</a></span></h2>
+</section><section><h3><code>path.delimiter</code><span><a class="mark" href="#path_path_delimiter" id="path_path_delimiter">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -234,18 +246,18 @@ and is not a string.</p>
 <li><code>:</code> for POSIX</li>
 </ul>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.env.PATH);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">PATH</span>);
 <span class="hljs-comment">// Prints: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin'</span>
 
-process.env.PATH.split(path.delimiter);
+process.<span class="hljs-property">env</span>.<span class="hljs-property">PATH</span>.<span class="hljs-title function_">split</span>(path.<span class="hljs-property">delimiter</span>);
 <span class="hljs-comment">// Returns: ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.env.PATH);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">PATH</span>);
 <span class="hljs-comment">// Prints: 'C:\Windows\system32;C:\Windows;C:\Program Files\node\'</span>
 
-process.env.PATH.split(path.delimiter);
+process.<span class="hljs-property">env</span>.<span class="hljs-property">PATH</span>.<span class="hljs-title function_">split</span>(path.<span class="hljs-property">delimiter</span>);
 <span class="hljs-comment">// Returns ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\\node\\']</span></code></pre>
-<h2><code>path.dirname(path)</code><span><a class="mark" href="#path_path_dirname_path" id="path_path_dirname_path">#</a></span></h2>
+</section><section><h3><code>path.dirname(path)</code><span><a class="mark" href="#path_path_dirname_path" id="path_path_dirname_path">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -264,10 +276,10 @@ process.env.PATH.split(path.delimiter);
 <p>The <code>path.dirname()</code> method returns the directory name of a <code>path</code>, similar to
 the Unix <code>dirname</code> command. Trailing directory separators are ignored, see
 <a href="#path_path_sep"><code>path.sep</code></a>.</p>
-<pre><code class="language-js">path.dirname(<span class="hljs-string">'/foo/bar/baz/asdf/quux'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">dirname</span>(<span class="hljs-string">'/foo/bar/baz/asdf/quux'</span>);
 <span class="hljs-comment">// Returns: '/foo/bar/baz/asdf'</span></code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.extname(path)</code><span><a class="mark" href="#path_path_extname_path" id="path_path_extname_path">#</a></span></h2>
+</section><section><h3><code>path.extname(path)</code><span><a class="mark" href="#path_path_extname_path" id="path_path_extname_path">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -288,30 +300,30 @@ occurrence of the <code>.</code> (period) character to end of string in the last
 the <code>path</code>. If there is no <code>.</code> in the last portion of the <code>path</code>, or if
 there are no <code>.</code> characters other than the first character of
 the basename of <code>path</code> (see <code>path.basename()</code>) , an empty string is returned.</p>
-<pre><code class="language-js">path.extname(<span class="hljs-string">'index.html'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'index.html'</span>);
 <span class="hljs-comment">// Returns: '.html'</span>
 
-path.extname(<span class="hljs-string">'index.coffee.md'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'index.coffee.md'</span>);
 <span class="hljs-comment">// Returns: '.md'</span>
 
-path.extname(<span class="hljs-string">'index.'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'index.'</span>);
 <span class="hljs-comment">// Returns: '.'</span>
 
-path.extname(<span class="hljs-string">'index'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'index'</span>);
 <span class="hljs-comment">// Returns: ''</span>
 
-path.extname(<span class="hljs-string">'.index'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'.index'</span>);
 <span class="hljs-comment">// Returns: ''</span>
 
-path.extname(<span class="hljs-string">'.index.md'</span>);
+path.<span class="hljs-title function_">extname</span>(<span class="hljs-string">'.index.md'</span>);
 <span class="hljs-comment">// Returns: '.md'</span></code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.format(pathObject)</code><span><a class="mark" href="#path_path_format_pathobject" id="path_path_format_pathobject">#</a></span></h2>
+</section><section><h3><code>path.format(pathObject)</code><span><a class="mark" href="#path_path_format_pathobject" id="path_path_format_pathobject">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
 <ul>
-<li><code>pathObject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<li><code>pathObject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Any JavaScript object having the following properties:
 <ul>
 <li><code>dir</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>root</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -334,7 +346,7 @@ combinations where one property has priority over another:</p>
 <pre><code class="language-js"><span class="hljs-comment">// If `dir`, `root` and `base` are provided,</span>
 <span class="hljs-comment">// `${dir}${path.sep}${base}`</span>
 <span class="hljs-comment">// will be returned. `root` is ignored.</span>
-path.format({
+path.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">root</span>: <span class="hljs-string">'/ignored'</span>,
   <span class="hljs-attr">dir</span>: <span class="hljs-string">'/home/user/dir'</span>,
   <span class="hljs-attr">base</span>: <span class="hljs-string">'file.txt'</span>
@@ -344,7 +356,7 @@ path.format({
 <span class="hljs-comment">// `root` will be used if `dir` is not specified.</span>
 <span class="hljs-comment">// If only `root` is provided or `dir` is equal to `root` then the</span>
 <span class="hljs-comment">// platform separator will not be included. `ext` will be ignored.</span>
-path.format({
+path.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">root</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">base</span>: <span class="hljs-string">'file.txt'</span>,
   <span class="hljs-attr">ext</span>: <span class="hljs-string">'ignored'</span>
@@ -352,19 +364,19 @@ path.format({
 <span class="hljs-comment">// Returns: '/file.txt'</span>
 
 <span class="hljs-comment">// `name` + `ext` will be used if `base` is not specified.</span>
-path.format({
+path.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">root</span>: <span class="hljs-string">'/'</span>,
   <span class="hljs-attr">name</span>: <span class="hljs-string">'file'</span>,
   <span class="hljs-attr">ext</span>: <span class="hljs-string">'.txt'</span>
 });
 <span class="hljs-comment">// Returns: '/file.txt'</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.format({
+<pre><code class="language-js">path.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">dir</span>: <span class="hljs-string">'C:\\path\\dir'</span>,
   <span class="hljs-attr">base</span>: <span class="hljs-string">'file.txt'</span>
 });
 <span class="hljs-comment">// Returns: 'C:\\path\\dir\\file.txt'</span></code></pre>
-<h2><code>path.isAbsolute(path)</code><span><a class="mark" href="#path_path_isabsolute_path" id="path_path_isabsolute_path">#</a></span></h2>
+</section><section><h3><code>path.isAbsolute(path)</code><span><a class="mark" href="#path_path_isabsolute_path" id="path_path_isabsolute_path">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -375,20 +387,20 @@ path.format({
 <p>The <code>path.isAbsolute()</code> method determines if <code>path</code> is an absolute path.</p>
 <p>If the given <code>path</code> is a zero-length string, <code>false</code> will be returned.</p>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js">path.isAbsolute(<span class="hljs-string">'/foo/bar'</span>); <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'/baz/..'</span>);  <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'qux/'</span>);     <span class="hljs-comment">// false</span>
-path.isAbsolute(<span class="hljs-string">'.'</span>);        <span class="hljs-comment">// false</span></code></pre>
+<pre><code class="language-js">path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'/foo/bar'</span>); <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'/baz/..'</span>);  <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'qux/'</span>);     <span class="hljs-comment">// false</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'.'</span>);        <span class="hljs-comment">// false</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.isAbsolute(<span class="hljs-string">'//server'</span>);    <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'\\\\server'</span>);  <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'C:/foo/..'</span>);   <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'C:\\foo\\..'</span>); <span class="hljs-comment">// true</span>
-path.isAbsolute(<span class="hljs-string">'bar\\baz'</span>);    <span class="hljs-comment">// false</span>
-path.isAbsolute(<span class="hljs-string">'bar/baz'</span>);     <span class="hljs-comment">// false</span>
-path.isAbsolute(<span class="hljs-string">'.'</span>);           <span class="hljs-comment">// false</span></code></pre>
+<pre><code class="language-js">path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'//server'</span>);    <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'\\\\server'</span>);  <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'C:/foo/..'</span>);   <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'C:\\foo\\..'</span>); <span class="hljs-comment">// true</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'bar\\baz'</span>);    <span class="hljs-comment">// false</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'bar/baz'</span>);     <span class="hljs-comment">// false</span>
+path.<span class="hljs-title function_">isAbsolute</span>(<span class="hljs-string">'.'</span>);           <span class="hljs-comment">// false</span></code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.join([...paths])</code><span><a class="mark" href="#path_path_join_paths" id="path_path_join_paths">#</a></span></h2>
+</section><section><h3><code>path.join([...paths])</code><span><a class="mark" href="#path_path_join_paths" id="path_path_join_paths">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -401,13 +413,13 @@ platform-specific separator as a delimiter, then normalizes the resulting path.<
 <p>Zero-length <code>path</code> segments are ignored. If the joined path string is a
 zero-length string then <code>'.'</code> will be returned, representing the current
 working directory.</p>
-<pre><code class="language-js">path.join(<span class="hljs-string">'/foo'</span>, <span class="hljs-string">'bar'</span>, <span class="hljs-string">'baz/asdf'</span>, <span class="hljs-string">'quux'</span>, <span class="hljs-string">'..'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">join</span>(<span class="hljs-string">'/foo'</span>, <span class="hljs-string">'bar'</span>, <span class="hljs-string">'baz/asdf'</span>, <span class="hljs-string">'quux'</span>, <span class="hljs-string">'..'</span>);
 <span class="hljs-comment">// Returns: '/foo/bar/baz/asdf'</span>
 
-path.join(<span class="hljs-string">'foo'</span>, {}, <span class="hljs-string">'bar'</span>);
+path.<span class="hljs-title function_">join</span>(<span class="hljs-string">'foo'</span>, {}, <span class="hljs-string">'bar'</span>);
 <span class="hljs-comment">// Throws 'TypeError: Path must be a string. Received {}'</span></code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if any of the path segments is not a string.</p>
-<h2><code>path.normalize(path)</code><span><a class="mark" href="#path_path_normalize_path" id="path_path_normalize_path">#</a></span></h2>
+</section><section><h3><code>path.normalize(path)</code><span><a class="mark" href="#path_path_normalize_path" id="path_path_normalize_path">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.23</span>
 </div>
@@ -424,17 +436,17 @@ instance of the platform-specific path segment separator (<code>/</code> on POSI
 <p>If the <code>path</code> is a zero-length string, <code>'.'</code> is returned, representing the
 current working directory.</p>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js">path.normalize(<span class="hljs-string">'/foo/bar//baz/asdf/quux/..'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">normalize</span>(<span class="hljs-string">'/foo/bar//baz/asdf/quux/..'</span>);
 <span class="hljs-comment">// Returns: '/foo/bar/baz/asdf'</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.normalize(<span class="hljs-string">'C:\\temp\\\\foo\\bar\\..\\'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">normalize</span>(<span class="hljs-string">'C:\\temp\\\\foo\\bar\\..\\'</span>);
 <span class="hljs-comment">// Returns: 'C:\\temp\\foo\\'</span></code></pre>
 <p>Since Windows recognizes multiple path separators, both separators will be
 replaced by instances of the Windows preferred separator (<code>\</code>):</p>
-<pre><code class="language-js">path.win32.normalize(<span class="hljs-string">'C:////temp\\\\/\\/\\/foo/bar'</span>);
+<pre><code class="language-js">path.<span class="hljs-property">win32</span>.<span class="hljs-title function_">normalize</span>(<span class="hljs-string">'C:////temp\\\\/\\/\\/foo/bar'</span>);
 <span class="hljs-comment">// Returns: 'C:\\temp\\foo\\bar'</span></code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.parse(path)</code><span><a class="mark" href="#path_path_parse_path" id="path_path_parse_path">#</a></span></h2>
+</section><section><h3><code>path.parse(path)</code><span><a class="mark" href="#path_path_parse_path" id="path_path_parse_path">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
@@ -454,7 +466,7 @@ see <a href="#path_path_sep"><code>path.sep</code></a>.</p>
 <li><code>ext</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js">path.parse(<span class="hljs-string">'/home/user/dir/file.txt'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">parse</span>(<span class="hljs-string">'/home/user/dir/file.txt'</span>);
 <span class="hljs-comment">// Returns:</span>
 <span class="hljs-comment">// { root: '/',</span>
 <span class="hljs-comment">//   dir: '/home/user/dir',</span>
@@ -469,7 +481,7 @@ see <a href="#path_path_sep"><code>path.sep</code></a>.</p>
 └──────┴──────────────┴──────┴─────┘
 (All spaces in the "" line should be ignored. They are purely for formatting.)</code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.parse(<span class="hljs-string">'C:\\path\\dir\\file.txt'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">parse</span>(<span class="hljs-string">'C:\\path\\dir\\file.txt'</span>);
 <span class="hljs-comment">// Returns:</span>
 <span class="hljs-comment">// { root: 'C:\\',</span>
 <span class="hljs-comment">//   dir: 'C:\\path\\dir',</span>
@@ -484,7 +496,7 @@ see <a href="#path_path_sep"><code>path.sep</code></a>.</p>
 └──────┴──────────────┴──────┴─────┘
 (All spaces in the "" line should be ignored. They are purely for formatting.)</code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if <code>path</code> is not a string.</p>
-<h2><code>path.posix</code><span><a class="mark" href="#path_path_posix" id="path_path_posix">#</a></span></h2>
+</section><section><h3><code>path.posix</code><span><a class="mark" href="#path_path_posix" id="path_path_posix">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
@@ -493,7 +505,7 @@ see <a href="#path_path_sep"><code>path.sep</code></a>.</p>
 </ul>
 <p>The <code>path.posix</code> property provides access to POSIX specific implementations
 of the <code>path</code> methods.</p>
-<h2><code>path.relative(from, to)</code><span><a class="mark" href="#path_path_relative_from_to" id="path_path_relative_from_to">#</a></span></h2>
+</section><section><h3><code>path.relative(from, to)</code><span><a class="mark" href="#path_path_relative_from_to" id="path_path_relative_from_to">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -516,13 +528,13 @@ path (after calling <code>path.resolve()</code> on each), a zero-length string i
 <p>If a zero-length string is passed as <code>from</code> or <code>to</code>, the current working
 directory will be used instead of the zero-length strings.</p>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js">path.relative(<span class="hljs-string">'/data/orandea/test/aaa'</span>, <span class="hljs-string">'/data/orandea/impl/bbb'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">relative</span>(<span class="hljs-string">'/data/orandea/test/aaa'</span>, <span class="hljs-string">'/data/orandea/impl/bbb'</span>);
 <span class="hljs-comment">// Returns: '../../impl/bbb'</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js">path.relative(<span class="hljs-string">'C:\\orandea\\test\\aaa'</span>, <span class="hljs-string">'C:\\orandea\\impl\\bbb'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">relative</span>(<span class="hljs-string">'C:\\orandea\\test\\aaa'</span>, <span class="hljs-string">'C:\\orandea\\impl\\bbb'</span>);
 <span class="hljs-comment">// Returns: '..\\..\\impl\\bbb'</span></code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if either <code>from</code> or <code>to</code> is not a string.</p>
-<h2><code>path.resolve([...paths])</code><span><a class="mark" href="#path_path_resolve_paths" id="path_path_resolve_paths">#</a></span></h2>
+</section><section><h3><code>path.resolve([...paths])</code><span><a class="mark" href="#path_path_resolve_paths" id="path_path_resolve_paths">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -544,17 +556,17 @@ path is resolved to the root directory.</p>
 <p>Zero-length <code>path</code> segments are ignored.</p>
 <p>If no <code>path</code> segments are passed, <code>path.resolve()</code> will return the absolute path
 of the current working directory.</p>
-<pre><code class="language-js">path.resolve(<span class="hljs-string">'/foo/bar'</span>, <span class="hljs-string">'./baz'</span>);
+<pre><code class="language-js">path.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'/foo/bar'</span>, <span class="hljs-string">'./baz'</span>);
 <span class="hljs-comment">// Returns: '/foo/bar/baz'</span>
 
-path.resolve(<span class="hljs-string">'/foo/bar'</span>, <span class="hljs-string">'/tmp/file/'</span>);
+path.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'/foo/bar'</span>, <span class="hljs-string">'/tmp/file/'</span>);
 <span class="hljs-comment">// Returns: '/tmp/file'</span>
 
-path.resolve(<span class="hljs-string">'wwwroot'</span>, <span class="hljs-string">'static_files/png/'</span>, <span class="hljs-string">'../gif/image.gif'</span>);
+path.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'wwwroot'</span>, <span class="hljs-string">'static_files/png/'</span>, <span class="hljs-string">'../gif/image.gif'</span>);
 <span class="hljs-comment">// If the current working directory is /home/myself/node,</span>
 <span class="hljs-comment">// this returns '/home/myself/node/wwwroot/static_files/gif/image.gif'</span></code></pre>
 <p>A <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> is thrown if any of the arguments is not a string.</p>
-<h2><code>path.sep</code><span><a class="mark" href="#path_path_sep" id="path_path_sep">#</a></span></h2>
+</section><section><h3><code>path.sep</code><span><a class="mark" href="#path_path_sep" id="path_path_sep">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.9</span>
 </div>
@@ -567,15 +579,15 @@ path.resolve(<span class="hljs-string">'wwwroot'</span>, <span class="hljs-strin
 <li><code>/</code> on POSIX</li>
 </ul>
 <p>For example, on POSIX:</p>
-<pre><code class="language-js"><span class="hljs-string">'foo/bar/baz'</span>.split(path.sep);
+<pre><code class="language-js"><span class="hljs-string">'foo/bar/baz'</span>.<span class="hljs-title function_">split</span>(path.<span class="hljs-property">sep</span>);
 <span class="hljs-comment">// Returns: ['foo', 'bar', 'baz']</span></code></pre>
 <p>On Windows:</p>
-<pre><code class="language-js"><span class="hljs-string">'foo\\bar\\baz'</span>.split(path.sep);
+<pre><code class="language-js"><span class="hljs-string">'foo\\bar\\baz'</span>.<span class="hljs-title function_">split</span>(path.<span class="hljs-property">sep</span>);
 <span class="hljs-comment">// Returns: ['foo', 'bar', 'baz']</span></code></pre>
 <p>On Windows, both the forward slash (<code>/</code>) and backward slash (<code>\</code>) are accepted
 as path segment separators; however, the <code>path</code> methods only add backward
 slashes (<code>\</code>).</p>
-<h2><code>path.toNamespacedPath(path)</code><span><a class="mark" href="#path_path_tonamespacedpath_path" id="path_path_tonamespacedpath_path">#</a></span></h2>
+</section><section><h3><code>path.toNamespacedPath(path)</code><span><a class="mark" href="#path_path_tonamespacedpath_path" id="path_path_tonamespacedpath_path">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -588,7 +600,7 @@ the given <code>path</code>. If <code>path</code> is not a string, <code>path</c
 modifications.</p>
 <p>This method is meaningful only on Windows systems. On POSIX systems, the
 method is non-operational and always returns <code>path</code> without modifications.</p>
-<h2><code>path.win32</code><span><a class="mark" href="#path_path_win32" id="path_path_win32">#</a></span></h2>
+</section><section><h3><code>path.win32</code><span><a class="mark" href="#path_path_win32" id="path_path_win32">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.15</span>
 </div>
@@ -596,10 +608,46 @@ method is non-operational and always returns <code>path</code> without modificat
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p>The <code>path.win32</code> property provides access to Windows-specific implementations
-of the <code>path</code> methods.</p>
+of the <code>path</code> methods.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/path.json b/doc/api/path.json
index af74f7d6d2215d6eec2125ba913032cbfe474a8d..e07b7853b9b5111da80c3f7bfdb8a33a16e8b75c 100644
--- a/doc/api/path.json
+++ b/doc/api/path.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/path.js\">lib/path.js</a></p>\n<p>The <code>path</code> module provides utilities for working with file and directory paths.\nIt can be accessed using:</p>\n<pre><code class=\"language-js\">const path = require('path');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/path.js\">lib/path.js</a></p>\n<p>The <code>path</code> module provides utilities for working with file and directory paths.\nIt can be accessed using:</p>\n<pre><code class=\"language-js\">const path = require('path');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Windows vs. POSIX",
@@ -146,9 +146,10 @@
               },
               "params": [
                 {
-                  "textRaw": "`pathObject` {Object}",
+                  "textRaw": "`pathObject` {Object} Any JavaScript object having the following properties:",
                   "name": "pathObject",
                   "type": "Object",
+                  "desc": "Any JavaScript object having the following properties:",
                   "options": [
                     {
                       "textRaw": "`dir` {string}",
diff --git a/doc/api/path.md b/doc/api/path.md
index e78850fb7d211448e2add76d09588155b9d12b69..b2339628bc310aa5f94e3c47eb95cedbfba9eb44 100644
--- a/doc/api/path.md
+++ b/doc/api/path.md
@@ -203,7 +203,7 @@ A [`TypeError`][] is thrown if `path` is not a string.
 added: v0.11.15
 -->
 
-* `pathObject` {Object}
+* `pathObject` {Object} Any JavaScript object having the following properties:
   * `dir` {string}
   * `root` {string}
   * `base` {string}
@@ -575,10 +575,10 @@ added: v0.11.15
 The `path.win32` property provides access to Windows-specific implementations
 of the `path` methods.
 
-[`TypeError`]: errors.html#errors_class_typeerror
+[MSDN-Rel-Path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths
+[`TypeError`]: errors.md#errors_class_typeerror
 [`path.parse()`]: #path_path_parse_path
 [`path.posix`]: #path_path_posix
 [`path.sep`]: #path_path_sep
 [`path.win32`]: #path_path_win32
-[MSDN-Rel-Path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths
 [namespace-prefixed path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#namespaces
diff --git a/doc/api/perf_hooks.html b/doc/api/perf_hooks.html
index 0d7dcbe648a13fe01670a85afe8f7e48f0e94a52..1277707152ce63751374a3cfd09170fb44c37b0d 100644
--- a/doc/api/perf_hooks.html
+++ b/doc/api/perf_hooks.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Performance measurement APIs | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Performance measurement APIs | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="perf_hooks" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/perf_hooks.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/perf_hooks.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/perf_hooks.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/perf_hooks.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/perf_hooks.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/perf_hooks.html">13.x</a></li>
@@ -112,15 +127,13 @@
 <li><a href="https://nodejs.org/docs/latest-v8.x/api/perf_hooks.html">8.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/perf_hooks.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/perf_hooks.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#perf_hooks_performance_measurement_apis">Performance measurement APIs</a></span>
 <ul>
 <li><a href="#perf_hooks_perf_hooks_performance"><code>perf_hooks.performance</code></a>
@@ -133,28 +146,27 @@
 <li><a href="#perf_hooks_performance_now"><code>performance.now()</code></a></li>
 <li><a href="#perf_hooks_performance_timeorigin"><code>performance.timeOrigin</code></a></li>
 <li><a href="#perf_hooks_performance_timerify_fn"><code>performance.timerify(fn)</code></a></li>
-<li><a href="#perf_hooks_performance_eventlooputilization_util1_util2"><code>performance.eventLoopUtilization([util1][,util2])</code></a></li>
 </ul>
 </li>
 <li><a href="#perf_hooks_class_performanceentry">Class: <code>PerformanceEntry</code></a>
 <ul>
 <li><a href="#perf_hooks_performanceentry_duration"><code>performanceEntry.duration</code></a></li>
-<li><a href="#perf_hooks_performanceentry_name"><code>performanceEntry.name</code></a></li>
-<li><a href="#perf_hooks_performanceentry_starttime"><code>performanceEntry.startTime</code></a></li>
 <li><a href="#perf_hooks_performanceentry_entrytype"><code>performanceEntry.entryType</code></a></li>
+<li><a href="#perf_hooks_performanceentry_flags"><code>performanceEntry.flags</code></a></li>
+<li><a href="#perf_hooks_performanceentry_name"><code>performanceEntry.name</code></a></li>
 <li><a href="#perf_hooks_performanceentry_kind"><code>performanceEntry.kind</code></a></li>
-<li><a href="#perf_hooks_performanceentry_flags">performanceEntry.flags</a></li>
+<li><a href="#perf_hooks_performanceentry_starttime"><code>performanceEntry.startTime</code></a></li>
 </ul>
 </li>
-<li><a href="#perf_hooks_class_performancenodetiming_extends_performanceentry">Class: <code>PerformanceNodeTiming extends PerformanceEntry</code></a>
+<li><a href="#perf_hooks_class_performancenodetiming">Class: <code>PerformanceNodeTiming</code></a>
 <ul>
 <li><a href="#perf_hooks_performancenodetiming_bootstrapcomplete"><code>performanceNodeTiming.bootstrapComplete</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_environment"><code>performanceNodeTiming.environment</code></a></li>
+<li><a href="#perf_hooks_performancenodetiming_idletime"><code>performanceNodeTiming.idleTime</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_loopexit"><code>performanceNodeTiming.loopExit</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_loopstart"><code>performanceNodeTiming.loopStart</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_nodestart"><code>performanceNodeTiming.nodeStart</code></a></li>
 <li><a href="#perf_hooks_performancenodetiming_v8start"><code>performanceNodeTiming.v8Start</code></a></li>
-<li><a href="#perf_hooks_performancenodetiming_idletime"><code>performanceNodeTiming.idleTime</code></a></li>
 </ul>
 </li>
 <li><a href="#perf_hooks_class_perf_hooks_performanceobserver">Class: <code>perf_hooks.PerformanceObserver</code></a>
@@ -171,12 +183,10 @@
 <li><a href="#perf_hooks_performanceobserverentrylist_getentriesbytype_type"><code>performanceObserverEntryList.getEntriesByType(type)</code></a></li>
 </ul>
 </li>
-<li><a href="#perf_hooks_perf_hooks_monitoreventloopdelay_options"><code>perf_hooks.monitorEventLoopDelay([options])</code></a>
-<ul>
+<li><a href="#perf_hooks_perf_hooks_createhistogram_options"><code>perf_hooks.createHistogram([options])</code></a></li>
+<li><a href="#perf_hooks_perf_hooks_monitoreventloopdelay_options"><code>perf_hooks.monitorEventLoopDelay([options])</code></a></li>
 <li><a href="#perf_hooks_class_histogram">Class: <code>Histogram</code></a>
 <ul>
-<li><a href="#perf_hooks_histogram_disable"><code>histogram.disable()</code></a></li>
-<li><a href="#perf_hooks_histogram_enable"><code>histogram.enable()</code></a></li>
 <li><a href="#perf_hooks_histogram_exceeds"><code>histogram.exceeds</code></a></li>
 <li><a href="#perf_hooks_histogram_max"><code>histogram.max</code></a></li>
 <li><a href="#perf_hooks_histogram_mean"><code>histogram.mean</code></a></li>
@@ -187,6 +197,17 @@
 <li><a href="#perf_hooks_histogram_stddev"><code>histogram.stddev</code></a></li>
 </ul>
 </li>
+<li><a href="#perf_hooks_class_intervalhistogram_extends_histogram">Class: <code>IntervalHistogram extends Histogram</code></a>
+<ul>
+<li><a href="#perf_hooks_histogram_disable"><code>histogram.disable()</code></a></li>
+<li><a href="#perf_hooks_histogram_enable"><code>histogram.enable()</code></a></li>
+<li><a href="#perf_hooks_cloning_an_intervalhistogram">Cloning an <code>IntervalHistogram</code></a></li>
+</ul>
+</li>
+<li><a href="#perf_hooks_class_recordablehistogram_extends_histogram">Class: <code>RecordableHistogram extends Histogram</code></a>
+<ul>
+<li><a href="#perf_hooks_histogram_record_val"><code>histogram.record(val)</code></a></li>
+<li><a href="#perf_hooks_histogram_recorddelta"><code>histogram.recordDelta()</code></a></li>
 </ul>
 </li>
 <li><a href="#perf_hooks_examples">Examples</a>
@@ -197,14 +218,13 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Performance measurement APIs<span><a class="mark" href="#perf_hooks_performance_measurement_apis" id="perf_hooks_performance_measurement_apis">#</a></span></h1>
+        <h2>Performance measurement APIs<span><a class="mark" href="#perf_hooks_performance_measurement_apis" id="perf_hooks_performance_measurement_apis">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/perf_hooks.js">lib/perf_hooks.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/perf_hooks.js">lib/perf_hooks.js</a></p>
 <p>This module provides an implementation of a subset of the W3C
 <a href="https://w3c.github.io/perf-timing-primer/">Web Performance APIs</a> as well as additional APIs for
 Node.js-specific performance measurements.</p>
@@ -214,29 +234,29 @@ Node.js-specific performance measurements.</p>
 <li><a href="https://w3c.github.io/performance-timeline/">Performance Timeline</a></li>
 <li><a href="https://www.w3.org/TR/user-timing/">User Timing</a></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { PerformanceObserver, performance } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">PerformanceObserver</span>, performance } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">items</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(items.getEntries()[<span class="hljs-number">0</span>].duration);
-  performance.clearMarks();
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">items</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(items.<span class="hljs-title function_">getEntries</span>()[<span class="hljs-number">0</span>].<span class="hljs-property">duration</span>);
+  performance.<span class="hljs-title function_">clearMarks</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'measure'</span>] });
-performance.measure(<span class="hljs-string">'Start to Now'</span>);
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'measure'</span>] });
+performance.<span class="hljs-title function_">measure</span>(<span class="hljs-string">'Start to Now'</span>);
 
-performance.mark(<span class="hljs-string">'A'</span>);
-doSomeLongRunningProcess(<span class="hljs-function">() =></span> {
-  performance.measure(<span class="hljs-string">'A to Now'</span>, <span class="hljs-string">'A'</span>);
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'A'</span>);
+<span class="hljs-title function_">doSomeLongRunningProcess</span>(<span class="hljs-function">() =></span> {
+  performance.<span class="hljs-title function_">measure</span>(<span class="hljs-string">'A to Now'</span>, <span class="hljs-string">'A'</span>);
 
-  performance.mark(<span class="hljs-string">'B'</span>);
-  performance.measure(<span class="hljs-string">'A to B'</span>, <span class="hljs-string">'A'</span>, <span class="hljs-string">'B'</span>);
+  performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'B'</span>);
+  performance.<span class="hljs-title function_">measure</span>(<span class="hljs-string">'A to B'</span>, <span class="hljs-string">'A'</span>, <span class="hljs-string">'B'</span>);
 });</code></pre>
-<h2><code>perf_hooks.performance</code><span><a class="mark" href="#perf_hooks_perf_hooks_performance" id="perf_hooks_perf_hooks_performance">#</a></span></h2>
+<section><h3><code>perf_hooks.performance</code><span><a class="mark" href="#perf_hooks_perf_hooks_performance" id="perf_hooks_perf_hooks_performance">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>An object that can be used to collect performance metrics from the current
 Node.js instance. It is similar to <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/performance"><code>window.performance</code></a> in browsers.</p>
-<h3><code>performance.clearMarks([name])</code><span><a class="mark" href="#perf_hooks_performance_clearmarks_name" id="perf_hooks_performance_clearmarks_name">#</a></span></h3>
+<h4><code>performance.clearMarks([name])</code><span><a class="mark" href="#perf_hooks_performance_clearmarks_name" id="perf_hooks_performance_clearmarks_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -245,15 +265,15 @@ Node.js instance. It is similar to <a href="https://developer.mozilla.org/en-US/
 </ul>
 <p>If <code>name</code> is not provided, removes all <code>PerformanceMark</code> objects from the
 Performance Timeline. If <code>name</code> is provided, removes only the named mark.</p>
-<h3><code>performance.eventLoopUtilization([utilization1[, utilization2]])</code><span><a class="mark" href="#perf_hooks_performance_eventlooputilization_utilization1_utilization2" id="perf_hooks_performance_eventlooputilization_utilization1_utilization2">#</a></span></h3>
+<h4><code>performance.eventLoopUtilization([utilization1[, utilization2]])</code><span><a class="mark" href="#perf_hooks_performance_eventlooputilization_utilization1_utilization2" id="perf_hooks_performance_eventlooputilization_utilization1_utilization2">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v14.10.0, v12.19.0</span>
 </div>
 <ul>
 <li><code>utilization1</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to
-  <code>eventLoopUtilization()</code>.</li>
+<code>eventLoopUtilization()</code>.</li>
 <li><code>utilization2</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to
-  <code>eventLoopUtilization()</code> prior to <code>utilization1</code>.</li>
+<code>eventLoopUtilization()</code> prior to <code>utilization1</code>.</li>
 <li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>idle</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
@@ -267,7 +287,7 @@ cumulative duration of time the event loop has been both idle and active as a
 high resolution milliseconds timer. The <code>utilization</code> value is the calculated
 Event Loop Utilization (ELU).</p>
 <p>If bootstrapping has not yet finished on the main thread the properties have
-the value of <code>0</code>. The ELU is immediately available on <a href="worker_threads.md#worker_threads_worker_threads">Worker threads</a> since
+the value of <code>0</code>. The ELU is immediately available on <a href="worker_threads.html#worker_threads_worker_threads">Worker threads</a> since
 bootstrap happens within the event loop.</p>
 <p>Both <code>utilization1</code> and <code>utilization2</code> are optional parameters.</p>
 <p>If <code>utilization1</code> is passed, then the delta between the current call's <code>active</code>
@@ -283,13 +303,13 @@ loop has spent outside the event loop's event provider (e.g. <code>epoll_wait</c
 No other CPU idle time is taken into consideration. The following is an example
 of how a mostly idle process will have a high ELU.</p>
 <pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
-<span class="hljs-keyword">const</span> { eventLoopUtilization } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>).performance;
+<span class="hljs-keyword">const</span> { eventLoopUtilization } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>).<span class="hljs-property">performance</span>;
 <span class="hljs-keyword">const</span> { spawnSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
 
-setImmediate(<span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> elu = eventLoopUtilization();
-  spawnSync(<span class="hljs-string">'sleep'</span>, [<span class="hljs-string">'5'</span>]);
-  <span class="hljs-built_in">console</span>.log(eventLoopUtilization(elu).utilization);
+<span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">const</span> elu = <span class="hljs-title function_">eventLoopUtilization</span>();
+  <span class="hljs-title function_">spawnSync</span>(<span class="hljs-string">'sleep'</span>, [<span class="hljs-string">'5'</span>]);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">eventLoopUtilization</span>(elu).<span class="hljs-property">utilization</span>);
 });</code></pre>
 <p>Although the CPU is mostly idle while running this script, the value of
 <code>utilization</code> is <code>1</code>. This is because the call to
@@ -297,7 +317,7 @@ setImmediate(<span class="hljs-function">() =></span> {
 <p>Passing in a user-defined object instead of the result of a previous call to
 <code>eventLoopUtilization()</code> will lead to undefined behavior. The return values
 are not guaranteed to reflect any correct state of the event loop.</p>
-<h3><code>performance.mark([name])</code><span><a class="mark" href="#perf_hooks_performance_mark_name" id="perf_hooks_performance_mark_name">#</a></span></h3>
+<h4><code>performance.mark([name])</code><span><a class="mark" href="#perf_hooks_performance_mark_name" id="perf_hooks_performance_mark_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -309,12 +329,12 @@ are not guaranteed to reflect any correct state of the event loop.</p>
 <code>performanceEntry.entryType</code> is always <code>'mark'</code>, and whose
 <code>performanceEntry.duration</code> is always <code>0</code>. Performance marks are used
 to mark specific significant moments in the Performance Timeline.</p>
-<h3><code>performance.measure(name[, startMark[, endMark]])</code><span><a class="mark" href="#perf_hooks_performance_measure_name_startmark_endmark" id="perf_hooks_performance_measure_name_startmark_endmark">#</a></span></h3>
+<h4><code>performance.measure(name[, startMark[, endMark]])</code><span><a class="mark" href="#perf_hooks_performance_measure_name_startmark_endmark" id="perf_hooks_performance_measure_name_startmark_endmark">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.3</td>
+<tr><td>v14.0.0</td>
 <td><p>Make <code>startMark</code> and <code>endMark</code> parameters optional.</p></td></tr>
 <tr><td>v8.5.0</td>
 <td><p><span>Added in: v8.5.0</span></p></td></tr>
@@ -340,17 +360,17 @@ in the Performance Timeline or any of the timestamp properties provided by the
 <code>PerformanceNodeTiming</code> class. <code>endMark</code> will be <code>performance.now()</code>
 if no parameter is passed, otherwise if the named <code>endMark</code> does not exist, an
 error will be thrown.</p>
-<h3><code>performance.nodeTiming</code><span><a class="mark" href="#perf_hooks_performance_nodetiming" id="perf_hooks_performance_nodetiming">#</a></span></h3>
+<h4><code>performance.nodeTiming</code><span><a class="mark" href="#perf_hooks_performance_nodetiming" id="perf_hooks_performance_nodetiming">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <ul>
-<li><a href="perf_hooks.html#perf_hooks_class_performancenodetiming_extends_performanceentry" class="type">&#x3C;PerformanceNodeTiming></a></li>
+<li><a href="perf_hooks.html#perf_hooks_class_performancenodetiming" class="type">&#x3C;PerformanceNodeTiming></a></li>
 </ul>
 <p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
 <p>An instance of the <code>PerformanceNodeTiming</code> class that provides performance
 metrics for specific Node.js operational milestones.</p>
-<h3><code>performance.now()</code><span><a class="mark" href="#perf_hooks_performance_now" id="perf_hooks_performance_now">#</a></span></h3>
+<h4><code>performance.now()</code><span><a class="mark" href="#perf_hooks_performance_now" id="perf_hooks_performance_now">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -359,7 +379,7 @@ metrics for specific Node.js operational milestones.</p>
 </ul>
 <p>Returns the current high resolution millisecond timestamp, where 0 represents
 the start of the current <code>node</code> process.</p>
-<h3><code>performance.timeOrigin</code><span><a class="mark" href="#perf_hooks_performance_timeorigin" id="perf_hooks_performance_timeorigin">#</a></span></h3>
+<h4><code>performance.timeOrigin</code><span><a class="mark" href="#perf_hooks_performance_timeorigin" id="perf_hooks_performance_timeorigin">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -368,7 +388,7 @@ the start of the current <code>node</code> process.</p>
 </ul>
 <p>The <a href="https://w3c.github.io/hr-time/#dom-performance-timeorigin"><code>timeOrigin</code></a> specifies the high resolution millisecond timestamp at
 which the current <code>node</code> process began, measured in Unix time.</p>
-<h3><code>performance.timerify(fn)</code><span><a class="mark" href="#perf_hooks_performance_timerify_fn" id="perf_hooks_performance_timerify_fn">#</a></span></h3>
+<h4><code>performance.timerify(fn)</code><span><a class="mark" href="#perf_hooks_performance_timerify_fn" id="perf_hooks_performance_timerify_fn">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -381,77 +401,28 @@ wrapped function. A <code>PerformanceObserver</code> must be subscribed to the <
 event type in order for the timing details to be accessed.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">someFunction</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'hello world'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">someFunction</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello world'</span>);
 }
 
-<span class="hljs-keyword">const</span> wrapped = performance.timerify(someFunction);
+<span class="hljs-keyword">const</span> wrapped = performance.<span class="hljs-title function_">timerify</span>(someFunction);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(list.getEntries()[<span class="hljs-number">0</span>].duration);
-  obs.disconnect();
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(list.<span class="hljs-title function_">getEntries</span>()[<span class="hljs-number">0</span>].<span class="hljs-property">duration</span>);
+  obs.<span class="hljs-title function_">disconnect</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'function'</span>] });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'function'</span>] });
 
 <span class="hljs-comment">// A performance timeline entry will be created</span>
-wrapped();</code></pre>
-<h3><code>performance.eventLoopUtilization([util1][,util2])</code><span><a class="mark" href="#perf_hooks_performance_eventlooputilization_util1_util2" id="perf_hooks_performance_eventlooputilization_util1_util2">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.19.0</span>
-</div>
-<ul>
-<li><code>util1</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to <code>eventLoopUtilization()</code></li>
-<li><code>util2</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to <code>eventLoopUtilization()</code>
-prior to <code>util1</code></li>
-<li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
-<ul>
-<li><code>idle</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-<li><code>active</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-<li><code>utilization</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-</li>
-</ul>
-<p>The <code>eventLoopUtilization()</code> method returns an object that contains the
-cumulative duration of time the event loop has been both idle and active as a
-high resolution milliseconds timer. The <code>utilization</code> value is the calculated
-Event Loop Utilization (ELU). If bootstrapping has not yet finished, the
-properties have the value of 0.</p>
-<p><code>util1</code> and <code>util2</code> are optional parameters.</p>
-<p>If <code>util1</code> is passed then the delta between the current call's <code>active</code> and
-<code>idle</code> times are calculated and returned (similar to <a href="process.html#process_process_hrtime_time"><code>process.hrtime()</code></a>).
-Likewise the adjusted <code>utilization</code> value is calculated.</p>
-<p>If <code>util1</code> and <code>util2</code> are both passed then the calculation adjustments are
-done between the two arguments. This is a convenience option because unlike
-<a href="process.html#process_process_hrtime_time"><code>process.hrtime()</code></a> additional work is done to calculate the ELU.</p>
-<p>ELU is similar to CPU utilization except that it is calculated using high
-precision wall-clock time. It represents the percentage of time the event loop
-has spent outside the event loop's event provider (e.g. <code>epoll_wait</code>). No other
-CPU idle time is taken into consideration. The following is an example of how
-a mostly idle process will have a high ELU.</p>
-<!-- eslint-skip -->
-<pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
-<span class="hljs-keyword">const</span> { eventLoopUtilization } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>).performance;
-<span class="hljs-keyword">const</span> { spawnSync } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'child_process'</span>);
-
-setImmediate(<span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> elu = eventLoopUtilization();
-  spawnSync(<span class="hljs-string">'sleep'</span>, [<span class="hljs-string">'5'</span>]);
-  <span class="hljs-built_in">console</span>.log(eventLoopUtilization(elu).utilization);
-});</code></pre>
-<p>Although the CPU is mostly idle while running this script, the value of
-<code>utilization</code> is 1. This is because the call to <a href="child_process.html#child_process_child_process_spawnsync_command_args_options"><code>child_process.spawnSync()</code></a>
-blocks the event loop from proceeding.</p>
-<p>Passing in a user-defined object instead of the result of a previous call to
-<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values
-are not guaranteed to reflect any correct state of the event loop.</p>
-<h2>Class: <code>PerformanceEntry</code><span><a class="mark" href="#perf_hooks_class_performanceentry" id="perf_hooks_class_performanceentry">#</a></span></h2>
+<span class="hljs-title function_">wrapped</span>();</code></pre>
+</section><section><h3>Class: <code>PerformanceEntry</code><span><a class="mark" href="#perf_hooks_class_performanceentry" id="perf_hooks_class_performanceentry">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
-<h3><code>performanceEntry.duration</code><span><a class="mark" href="#perf_hooks_performanceentry_duration" id="perf_hooks_performanceentry_duration">#</a></span></h3>
+<h4><code>performanceEntry.duration</code><span><a class="mark" href="#perf_hooks_performanceentry_duration" id="perf_hooks_performanceentry_duration">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -460,41 +431,52 @@ are not guaranteed to reflect any correct state of the event loop.</p>
 </ul>
 <p>The total number of milliseconds elapsed for this entry. This value will not
 be meaningful for all Performance Entry types.</p>
-<h3><code>performanceEntry.name</code><span><a class="mark" href="#perf_hooks_performanceentry_name" id="perf_hooks_performanceentry_name">#</a></span></h3>
+<h4><code>performanceEntry.entryType</code><span><a class="mark" href="#perf_hooks_performanceentry_entrytype" id="perf_hooks_performanceentry_entrytype">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>The name of the performance entry.</p>
-<h3><code>performanceEntry.startTime</code><span><a class="mark" href="#perf_hooks_performanceentry_starttime" id="perf_hooks_performanceentry_starttime">#</a></span></h3>
+<p>The type of the performance entry. It may be one of:</p>
+<ul>
+<li><code>'node'</code> (Node.js only)</li>
+<li><code>'mark'</code> (available on the Web)</li>
+<li><code>'measure'</code> (available on the Web)</li>
+<li><code>'gc'</code> (Node.js only)</li>
+<li><code>'function'</code> (Node.js only)</li>
+<li><code>'http2'</code> (Node.js only)</li>
+<li><code>'http'</code> (Node.js only)</li>
+</ul>
+<h4><code>performanceEntry.flags</code><span><a class="mark" href="#perf_hooks_performanceentry_flags" id="perf_hooks_performanceentry_flags">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v8.5.0</span>
+<span>Added in: v13.9.0, v12.17.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p>The high resolution millisecond timestamp marking the starting time of the
-Performance Entry.</p>
-<h3><code>performanceEntry.entryType</code><span><a class="mark" href="#perf_hooks_performanceentry_entrytype" id="perf_hooks_performanceentry_entrytype">#</a></span></h3>
+<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
+<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>
+property contains additional information about garbage collection operation.
+The value may be one of:</p>
+<ul>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>
+<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>
+</ul>
+<h4><code>performanceEntry.name</code><span><a class="mark" href="#perf_hooks_performanceentry_name" id="perf_hooks_performanceentry_name">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>The type of the performance entry. It may be one of:</p>
-<ul>
-<li><code>'node'</code> (Node.js only)</li>
-<li><code>'mark'</code> (available on the Web)</li>
-<li><code>'measure'</code> (available on the Web)</li>
-<li><code>'gc'</code> (Node.js only)</li>
-<li><code>'function'</code> (Node.js only)</li>
-<li><code>'http2'</code> (Node.js only)</li>
-<li><code>'http'</code> (Node.js only)</li>
-</ul>
-<h3><code>performanceEntry.kind</code><span><a class="mark" href="#perf_hooks_performanceentry_kind" id="perf_hooks_performanceentry_kind">#</a></span></h3>
+<p>The name of the performance entry.</p>
+<h4><code>performanceEntry.kind</code><span><a class="mark" href="#perf_hooks_performanceentry_kind" id="perf_hooks_performanceentry_kind">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -511,34 +493,26 @@ The value may be one of:</p>
 <li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL</code></li>
 <li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB</code></li>
 </ul>
-<h3>performanceEntry.flags<span><a class="mark" href="#perf_hooks_performanceentry_flags" id="perf_hooks_performanceentry_flags">#</a></span></h3>
+<h4><code>performanceEntry.startTime</code><span><a class="mark" href="#perf_hooks_performanceentry_starttime" id="perf_hooks_performanceentry_starttime">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v8.5.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
-<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>
-property contains additional information about garbage collection operation.
-The value may be one of:</p>
-<ul>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>
-<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>
-</ul>
-<h2>Class: <code>PerformanceNodeTiming extends PerformanceEntry</code><span><a class="mark" href="#perf_hooks_class_performancenodetiming_extends_performanceentry" id="perf_hooks_class_performancenodetiming_extends_performanceentry">#</a></span></h2>
+<p>The high resolution millisecond timestamp marking the starting time of the
+Performance Entry.</p>
+</section><section><h3>Class: <code>PerformanceNodeTiming</code><span><a class="mark" href="#perf_hooks_class_performancenodetiming" id="perf_hooks_class_performancenodetiming">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
+<ul>
+<li>Extends: <a href="perf_hooks.html#perf_hooks_class_performanceentry" class="type">&#x3C;PerformanceEntry></a></li>
+</ul>
 <p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
 <p>Provides timing details for Node.js itself. The constructor of this class
 is not exposed to users.</p>
-<h3><code>performanceNodeTiming.bootstrapComplete</code><span><a class="mark" href="#perf_hooks_performancenodetiming_bootstrapcomplete" id="perf_hooks_performancenodetiming_bootstrapcomplete">#</a></span></h3>
+<h4><code>performanceNodeTiming.bootstrapComplete</code><span><a class="mark" href="#perf_hooks_performancenodetiming_bootstrapcomplete" id="perf_hooks_performancenodetiming_bootstrapcomplete">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -548,7 +522,7 @@ is not exposed to users.</p>
 <p>The high resolution millisecond timestamp at which the Node.js process
 completed bootstrapping. If bootstrapping has not yet finished, the property
 has the value of -1.</p>
-<h3><code>performanceNodeTiming.environment</code><span><a class="mark" href="#perf_hooks_performancenodetiming_environment" id="perf_hooks_performancenodetiming_environment">#</a></span></h3>
+<h4><code>performanceNodeTiming.environment</code><span><a class="mark" href="#perf_hooks_performancenodetiming_environment" id="perf_hooks_performancenodetiming_environment">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -557,7 +531,19 @@ has the value of -1.</p>
 </ul>
 <p>The high resolution millisecond timestamp at which the Node.js environment was
 initialized.</p>
-<h3><code>performanceNodeTiming.loopExit</code><span><a class="mark" href="#perf_hooks_performancenodetiming_loopexit" id="perf_hooks_performancenodetiming_loopexit">#</a></span></h3>
+<h4><code>performanceNodeTiming.idleTime</code><span><a class="mark" href="#perf_hooks_performancenodetiming_idletime" id="perf_hooks_performancenodetiming_idletime">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.10.0, v12.19.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<p>The high resolution millisecond timestamp of the amount of time the event loop
+has been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This
+does not take CPU usage into consideration. If the event loop has not yet
+started (e.g., in the first tick of the main script), the property has the
+value of 0.</p>
+<h4><code>performanceNodeTiming.loopExit</code><span><a class="mark" href="#perf_hooks_performancenodetiming_loopexit" id="perf_hooks_performancenodetiming_loopexit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -567,7 +553,7 @@ initialized.</p>
 <p>The high resolution millisecond timestamp at which the Node.js event loop
 exited. If the event loop has not yet exited, the property has the value of -1.
 It can only have a value of not -1 in a handler of the <a href="process.html#process_event_exit"><code>'exit'</code></a> event.</p>
-<h3><code>performanceNodeTiming.loopStart</code><span><a class="mark" href="#perf_hooks_performancenodetiming_loopstart" id="perf_hooks_performancenodetiming_loopstart">#</a></span></h3>
+<h4><code>performanceNodeTiming.loopStart</code><span><a class="mark" href="#perf_hooks_performancenodetiming_loopstart" id="perf_hooks_performancenodetiming_loopstart">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -577,7 +563,7 @@ It can only have a value of not -1 in a handler of the <a href="process.html#pro
 <p>The high resolution millisecond timestamp at which the Node.js event loop
 started. If the event loop has not yet started (e.g., in the first tick of the
 main script), the property has the value of -1.</p>
-<h3><code>performanceNodeTiming.nodeStart</code><span><a class="mark" href="#perf_hooks_performancenodetiming_nodestart" id="perf_hooks_performancenodetiming_nodestart">#</a></span></h3>
+<h4><code>performanceNodeTiming.nodeStart</code><span><a class="mark" href="#perf_hooks_performancenodetiming_nodestart" id="perf_hooks_performancenodetiming_nodestart">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -586,7 +572,7 @@ main script), the property has the value of -1.</p>
 </ul>
 <p>The high resolution millisecond timestamp at which the Node.js process was
 initialized.</p>
-<h3><code>performanceNodeTiming.v8Start</code><span><a class="mark" href="#perf_hooks_performancenodetiming_v8start" id="perf_hooks_performancenodetiming_v8start">#</a></span></h3>
+<h4><code>performanceNodeTiming.v8Start</code><span><a class="mark" href="#perf_hooks_performancenodetiming_v8start" id="perf_hooks_performancenodetiming_v8start">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -595,20 +581,8 @@ initialized.</p>
 </ul>
 <p>The high resolution millisecond timestamp at which the V8 platform was
 initialized.</p>
-<h3><code>performanceNodeTiming.idleTime</code><span><a class="mark" href="#perf_hooks_performancenodetiming_idletime" id="perf_hooks_performancenodetiming_idletime">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v12.19.0</span>
-</div>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-<p>The high resolution millisecond timestamp of the amount of time the event loop
-has been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This
-does not take CPU usage into consideration. If the event loop has not yet
-started (e.g., in the first tick of the main script), the property has the
-value of 0.</p>
-<h2>Class: <code>perf_hooks.PerformanceObserver</code><span><a class="mark" href="#perf_hooks_class_perf_hooks_performanceobserver" id="perf_hooks_class_perf_hooks_performanceobserver">#</a></span></h2>
-<h3><code>new PerformanceObserver(callback)</code><span><a class="mark" href="#perf_hooks_new_performanceobserver_callback" id="perf_hooks_new_performanceobserver_callback">#</a></span></h3>
+</section><section><h3>Class: <code>perf_hooks.PerformanceObserver</code><span><a class="mark" href="#perf_hooks_class_perf_hooks_performanceobserver" id="perf_hooks_class_perf_hooks_performanceobserver">#</a></span></h3>
+<h4><code>new PerformanceObserver(callback)</code><span><a class="mark" href="#perf_hooks_new_performanceobserver_callback" id="perf_hooks_new_performanceobserver_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -624,16 +598,16 @@ value of 0.</p>
 <code>PerformanceEntry</code> instances have been added to the Performance Timeline.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(list.getEntries());
-  observer.disconnect();
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(list.<span class="hljs-title function_">getEntries</span>());
+  observer.<span class="hljs-title function_">disconnect</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
 
-performance.mark(<span class="hljs-string">'test'</span>);</code></pre>
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'test'</span>);</code></pre>
 <p>Because <code>PerformanceObserver</code> instances introduce their own additional
 performance overhead, instances should not be left subscribed to notifications
 indefinitely. Users should disconnect observers as soon as they are no
@@ -642,12 +616,12 @@ longer needed.</p>
 notified about new <code>PerformanceEntry</code> instances. The callback receives a
 <code>PerformanceObserverEntryList</code> instance and a reference to the
 <code>PerformanceObserver</code>.</p>
-<h3><code>performanceObserver.disconnect()</code><span><a class="mark" href="#perf_hooks_performanceobserver_disconnect" id="perf_hooks_performanceobserver_disconnect">#</a></span></h3>
+<h4><code>performanceObserver.disconnect()</code><span><a class="mark" href="#perf_hooks_performanceobserver_disconnect" id="perf_hooks_performanceobserver_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>Disconnects the <code>PerformanceObserver</code> instance from all notifications.</p>
-<h3><code>performanceObserver.observe(options)</code><span><a class="mark" href="#perf_hooks_performanceobserver_observe_options" id="perf_hooks_performanceobserver_observe_options">#</a></span></h3>
+<h4><code>performanceObserver.observe(options)</code><span><a class="mark" href="#perf_hooks_performanceobserver_observe_options" id="perf_hooks_performanceobserver_observe_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -670,36 +644,36 @@ be immediate and synchronous. <strong>Default:</strong> <code>false</code>.</li>
 every <code>PerformanceEntry</code> instance:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
   <span class="hljs-comment">// Called three times synchronously. `list` contains one item.</span>
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>] });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>] });
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; <span class="hljs-number">3</span>; n++)
-  performance.mark(<span class="hljs-string">`test<span class="hljs-subst">${n}</span>`</span>);</code></pre>
+  performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">`test<span class="hljs-subst">${n}</span>`</span>);</code></pre>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
   <span class="hljs-comment">// Called once. `list` contains three items.</span>
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; <span class="hljs-number">3</span>; n++)
-  performance.mark(<span class="hljs-string">`test<span class="hljs-subst">${n}</span>`</span>);</code></pre>
-<h2>Class: <code>PerformanceObserverEntryList</code><span><a class="mark" href="#perf_hooks_class_performanceobserverentrylist" id="perf_hooks_class_performanceobserverentrylist">#</a></span></h2>
+  performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">`test<span class="hljs-subst">${n}</span>`</span>);</code></pre>
+</section><section><h3>Class: <code>PerformanceObserverEntryList</code><span><a class="mark" href="#perf_hooks_class_performanceobserverentrylist" id="perf_hooks_class_performanceobserverentrylist">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
 <p>The <code>PerformanceObserverEntryList</code> class is used to provide access to the
 <code>PerformanceEntry</code> instances passed to a <code>PerformanceObserver</code>.
 The constructor of this class is not exposed to users.</p>
-<h3><code>performanceObserverEntryList.getEntries()</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentries" id="perf_hooks_performanceobserverentrylist_getentries">#</a></span></h3>
+<h4><code>performanceObserverEntryList.getEntries()</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentries" id="perf_hooks_performanceobserverentrylist_getentries">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -708,7 +682,36 @@ The constructor of this class is not exposed to users.</p>
 </ul>
 <p>Returns a list of <code>PerformanceEntry</code> objects in chronological order
 with respect to <code>performanceEntry.startTime</code>.</p>
-<h3><code>performanceObserverEntryList.getEntriesByName(name[, type])</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentriesbyname_name_type" id="perf_hooks_performanceobserverentrylist_getentriesbyname_name_type">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  performance,
+  <span class="hljs-title class_">PerformanceObserver</span>
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">perfObserverList, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntries</span>());
+  <span class="hljs-comment">/**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 81.465639,
+   *     duration: 0
+   *   },
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 81.860064,
+   *     duration: 0
+   *   }
+   * ]
+   */</span>
+  observer.<span class="hljs-title function_">disconnect</span>();
+});
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'test'</span>);
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'meow'</span>);</code></pre>
+<h4><code>performanceObserverEntryList.getEntriesByName(name[, type])</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentriesbyname_name_type" id="perf_hooks_performanceobserverentrylist_getentriesbyname_name_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -721,7 +724,44 @@ with respect to <code>performanceEntry.startTime</code>.</p>
 with respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.name</code> is
 equal to <code>name</code>, and optionally, whose <code>performanceEntry.entryType</code> is equal to
 <code>type</code>.</p>
-<h3><code>performanceObserverEntryList.getEntriesByType(type)</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentriesbytype_type" id="perf_hooks_performanceobserverentrylist_getentriesbytype_type">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  performance,
+  <span class="hljs-title class_">PerformanceObserver</span>
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">perfObserverList, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByName</span>(<span class="hljs-string">'meow'</span>));
+  <span class="hljs-comment">/**
+   * [
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 98.545991,
+   *     duration: 0
+   *   }
+   * ]
+   */</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByName</span>(<span class="hljs-string">'nope'</span>)); <span class="hljs-comment">// []</span>
+
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByName</span>(<span class="hljs-string">'test'</span>, <span class="hljs-string">'mark'</span>));
+  <span class="hljs-comment">/**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 63.518931,
+   *     duration: 0
+   *   }
+   * ]
+   */</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByName</span>(<span class="hljs-string">'test'</span>, <span class="hljs-string">'measure'</span>)); <span class="hljs-comment">// []</span>
+  observer.<span class="hljs-title function_">disconnect</span>();
+});
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>, <span class="hljs-string">'measure'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'test'</span>);
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'meow'</span>);</code></pre>
+<h4><code>performanceObserverEntryList.getEntriesByType(type)</code><span><a class="mark" href="#perf_hooks_performanceobserverentrylist_getentriesbytype_type" id="perf_hooks_performanceobserverentrylist_getentriesbytype_type">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.5.0</span>
 </div>
@@ -732,7 +772,54 @@ equal to <code>name</code>, and optionally, whose <code>performanceEntry.entryTy
 <p>Returns a list of <code>PerformanceEntry</code> objects in chronological order
 with respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.entryType</code>
 is equal to <code>type</code>.</p>
-<h2><code>perf_hooks.monitorEventLoopDelay([options])</code><span><a class="mark" href="#perf_hooks_perf_hooks_monitoreventloopdelay_options" id="perf_hooks_perf_hooks_monitoreventloopdelay_options">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  performance,
+  <span class="hljs-title class_">PerformanceObserver</span>
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
+
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">perfObserverList, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(perfObserverList.<span class="hljs-title function_">getEntriesByType</span>(<span class="hljs-string">'mark'</span>));
+  <span class="hljs-comment">/**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 55.897834,
+   *     duration: 0
+   *   },
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 56.350146,
+   *     duration: 0
+   *   }
+   * ]
+   */</span>
+  observer.<span class="hljs-title function_">disconnect</span>();
+});
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'mark'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'test'</span>);
+performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">'meow'</span>);</code></pre>
+</section><section><h3><code>perf_hooks.createHistogram([options])</code><span><a class="mark" href="#perf_hooks_perf_hooks_createhistogram_options" id="perf_hooks_perf_hooks_createhistogram_options">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>min</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> The minimum recordable value. Must be an integer
+value greater than 0. <strong>Defaults</strong>: <code>1</code>.</li>
+<li><code>max</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> The maximum recordable value. Must be an integer
+value greater than <code>min</code>. <strong>Defaults</strong>: <code>Number.MAX_SAFE_INTEGER</code>.</li>
+<li><code>figures</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of accuracy digits. Must be a number between
+<code>1</code> and <code>5</code>. <strong>Defaults</strong>: <code>3</code>.</li>
+</ul>
+</li>
+<li>Returns <a href="perf_hooks.html#perf_hooks_class_recordablehistogram_extends_histogram" class="type">&#x3C;RecordableHistogram></a></li>
+</ul>
+<p>Returns a <a href="perf_hooks.html#perf_hooks_class_recordablehistogram_extends_histogram" class="type">&#x3C;RecordableHistogram></a>.</p>
+</section><section><h3><code>perf_hooks.monitorEventLoopDelay([options])</code><span><a class="mark" href="#perf_hooks_perf_hooks_monitoreventloopdelay_options" id="perf_hooks_perf_hooks_monitoreventloopdelay_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
 </div>
@@ -743,53 +830,32 @@ is equal to <code>type</code>.</p>
 than zero. <strong>Default:</strong> <code>10</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="perf_hooks.html#perf_hooks_class_histogram" class="type">&#x3C;Histogram></a></li>
+<li>Returns: <a href="perf_hooks.html#perf_hooks_class_intervalhistogram_extends_histogram" class="type">&#x3C;IntervalHistogram></a></li>
 </ul>
 <p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
-<p>Creates a <code>Histogram</code> object that samples and reports the event loop delay
-over time. The delays will be reported in nanoseconds.</p>
+<p>Creates an <code>IntervalHistogram</code> object that samples and reports the event loop
+delay over time. The delays will be reported in nanoseconds.</p>
 <p>Using a timer to detect approximate event loop delay works because the
 execution of timers is tied specifically to the lifecycle of the libuv
 event loop. That is, a delay in the loop will cause a delay in the execution
 of the timer, and those delays are specifically what this API is intended to
 detect.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { monitorEventLoopDelay } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
-<span class="hljs-keyword">const</span> h = monitorEventLoopDelay({ <span class="hljs-attr">resolution</span>: <span class="hljs-number">20</span> });
-h.enable();
+<span class="hljs-keyword">const</span> h = <span class="hljs-title function_">monitorEventLoopDelay</span>({ <span class="hljs-attr">resolution</span>: <span class="hljs-number">20</span> });
+h.<span class="hljs-title function_">enable</span>();
 <span class="hljs-comment">// Do something.</span>
-h.disable();
-<span class="hljs-built_in">console</span>.log(h.min);
-<span class="hljs-built_in">console</span>.log(h.max);
-<span class="hljs-built_in">console</span>.log(h.mean);
-<span class="hljs-built_in">console</span>.log(h.stddev);
-<span class="hljs-built_in">console</span>.log(h.percentiles);
-<span class="hljs-built_in">console</span>.log(h.percentile(<span class="hljs-number">50</span>));
-<span class="hljs-built_in">console</span>.log(h.percentile(<span class="hljs-number">99</span>));</code></pre>
-<h3>Class: <code>Histogram</code><span><a class="mark" href="#perf_hooks_class_histogram" id="perf_hooks_class_histogram">#</a></span></h3>
-<div class="api_metadata">
-<span>Added in: v11.10.0</span>
-</div>
-<p>Tracks the event loop delay at a given sampling rate. The constructor of
-this class not exposed to users.</p>
-<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>
-<h4><code>histogram.disable()</code><span><a class="mark" href="#perf_hooks_histogram_disable" id="perf_hooks_histogram_disable">#</a></span></h4>
+h.<span class="hljs-title function_">disable</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">min</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">max</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">mean</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">stddev</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-property">percentiles</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-title function_">percentile</span>(<span class="hljs-number">50</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(h.<span class="hljs-title function_">percentile</span>(<span class="hljs-number">99</span>));</code></pre>
+</section><section><h3>Class: <code>Histogram</code><span><a class="mark" href="#perf_hooks_class_histogram" id="perf_hooks_class_histogram">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
 </div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Disables the event loop delay sample timer. Returns <code>true</code> if the timer was
-stopped, <code>false</code> if it was already stopped.</p>
-<h4><code>histogram.enable()</code><span><a class="mark" href="#perf_hooks_histogram_enable" id="perf_hooks_histogram_enable">#</a></span></h4>
-<div class="api_metadata">
-<span>Added in: v11.10.0</span>
-</div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
-</ul>
-<p>Enables the event loop delay sample timer. Returns <code>true</code> if the timer was
-started, <code>false</code> if it was already started.</p>
 <h4><code>histogram.exceeds</code><span><a class="mark" href="#perf_hooks_histogram_exceeds" id="perf_hooks_histogram_exceeds">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
@@ -828,7 +894,7 @@ loop delay threshold.</p>
 <span>Added in: v11.10.0</span>
 </div>
 <ul>
-<li><code>percentile</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A percentile value between 1 and 100.</li>
+<li><code>percentile</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A percentile value in the range (0, 100].</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Returns the value at the given percentile.</p>
@@ -853,8 +919,49 @@ loop delay threshold.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>The standard deviation of the recorded event loop delays.</p>
-<h2>Examples<span><a class="mark" href="#perf_hooks_examples" id="perf_hooks_examples">#</a></span></h2>
-<h3>Measuring the duration of async operations<span><a class="mark" href="#perf_hooks_measuring_the_duration_of_async_operations" id="perf_hooks_measuring_the_duration_of_async_operations">#</a></span></h3>
+</section><section><h3>Class: <code>IntervalHistogram extends Histogram</code><span><a class="mark" href="#perf_hooks_class_intervalhistogram_extends_histogram" id="perf_hooks_class_intervalhistogram_extends_histogram">#</a></span></h3>
+<p>A <code>Histogram</code> that is periodically updated on a given interval.</p>
+<h4><code>histogram.disable()</code><span><a class="mark" href="#perf_hooks_histogram_disable" id="perf_hooks_histogram_disable">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v11.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Disables the update interval timer. Returns <code>true</code> if the timer was
+stopped, <code>false</code> if it was already stopped.</p>
+<h4><code>histogram.enable()</code><span><a class="mark" href="#perf_hooks_histogram_enable" id="perf_hooks_histogram_enable">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v11.10.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Enables the update interval timer. Returns <code>true</code> if the timer was
+started, <code>false</code> if it was already started.</p>
+<h4>Cloning an <code>IntervalHistogram</code><span><a class="mark" href="#perf_hooks_cloning_an_intervalhistogram" id="perf_hooks_cloning_an_intervalhistogram">#</a></span></h4>
+<p><a href="perf_hooks.html#perf_hooks_class_intervalhistogram_extends_histogram" class="type">&#x3C;IntervalHistogram></a> instances can be cloned via <a href="worker_threads.html#worker_threads_class_messageport" class="type">&#x3C;MessagePort></a>. On the receiving
+end, the histogram is cloned as a plain <a href="perf_hooks.html#perf_hooks_class_histogram" class="type">&#x3C;Histogram></a> object that does not
+implement the <code>enable()</code> and <code>disable()</code> methods.</p>
+</section><section><h3>Class: <code>RecordableHistogram extends Histogram</code><span><a class="mark" href="#perf_hooks_class_recordablehistogram_extends_histogram" id="perf_hooks_class_recordablehistogram_extends_histogram">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<h4><code>histogram.record(val)</code><span><a class="mark" href="#perf_hooks_histogram_record_val" id="perf_hooks_histogram_record_val">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>val</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> The amount to record in the histogram.</li>
+</ul>
+<h4><code>histogram.recordDelta()</code><span><a class="mark" href="#perf_hooks_histogram_recorddelta" id="perf_hooks_histogram_recorddelta">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>Calculates the amount of time (in nanoseconds) that has passed since the
+previous call to <code>recordDelta()</code> and records that amount in the histogram.</p>
+</section><section><h3>Examples<span><a class="mark" href="#perf_hooks_examples" id="perf_hooks_examples">#</a></span></h3>
+<h4>Measuring the duration of async operations<span><a class="mark" href="#perf_hooks_measuring_the_duration_of_async_operations" id="perf_hooks_measuring_the_duration_of_async_operations">#</a></span></h4>
 <p>The following example uses the <a href="async_hooks.html">Async Hooks</a> and Performance APIs to measure
 the actual duration of a Timeout operation (including the amount of time it took
 to execute the callback).</p>
@@ -862,67 +969,103 @@ to execute the callback).</p>
 <span class="hljs-keyword">const</span> async_hooks = <span class="hljs-built_in">require</span>(<span class="hljs-string">'async_hooks'</span>);
 <span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 
-<span class="hljs-keyword">const</span> set = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>();
-<span class="hljs-keyword">const</span> hook = async_hooks.createHook({
-  init(id, type) {
+<span class="hljs-keyword">const</span> set = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>();
+<span class="hljs-keyword">const</span> hook = async_hooks.<span class="hljs-title function_">createHook</span>({
+  <span class="hljs-title function_">init</span>(<span class="hljs-params">id, type</span>) {
     <span class="hljs-keyword">if</span> (type === <span class="hljs-string">'Timeout'</span>) {
-      performance.mark(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Init`</span>);
-      set.add(id);
+      performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Init`</span>);
+      set.<span class="hljs-title function_">add</span>(id);
     }
   },
-  destroy(id) {
-    <span class="hljs-keyword">if</span> (set.has(id)) {
-      set.delete(id);
-      performance.mark(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Destroy`</span>);
-      performance.measure(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>`</span>,
+  <span class="hljs-title function_">destroy</span>(<span class="hljs-params">id</span>) {
+    <span class="hljs-keyword">if</span> (set.<span class="hljs-title function_">has</span>(id)) {
+      set.<span class="hljs-title function_">delete</span>(id);
+      performance.<span class="hljs-title function_">mark</span>(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Destroy`</span>);
+      performance.<span class="hljs-title function_">measure</span>(<span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>`</span>,
                           <span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Init`</span>,
                           <span class="hljs-string">`Timeout-<span class="hljs-subst">${id}</span>-Destroy`</span>);
     }
   }
 });
-hook.enable();
+hook.<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(list.getEntries()[<span class="hljs-number">0</span>]);
-  performance.clearMarks();
-  observer.disconnect();
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list, observer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(list.<span class="hljs-title function_">getEntries</span>()[<span class="hljs-number">0</span>]);
+  performance.<span class="hljs-title function_">clearMarks</span>();
+  observer.<span class="hljs-title function_">disconnect</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'measure'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'measure'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {}, <span class="hljs-number">1000</span>);</code></pre>
-<h3>Measuring how long it takes to load dependencies<span><a class="mark" href="#perf_hooks_measuring_how_long_it_takes_to_load_dependencies" id="perf_hooks_measuring_how_long_it_takes_to_load_dependencies">#</a></span></h3>
+<h4>Measuring how long it takes to load dependencies<span><a class="mark" href="#perf_hooks_measuring_how_long_it_takes_to_load_dependencies" id="perf_hooks_measuring_how_long_it_takes_to_load_dependencies">#</a></span></h4>
 <p>The following example measures the duration of <code>require()</code> operations to load
 dependencies:</p>
 <!-- eslint-disable no-global-assign -->
 <pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
 <span class="hljs-keyword">const</span> {
   performance,
-  PerformanceObserver
+  <span class="hljs-title class_">PerformanceObserver</span>
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'perf_hooks'</span>);
 <span class="hljs-keyword">const</span> mod = <span class="hljs-built_in">require</span>(<span class="hljs-string">'module'</span>);
 
 <span class="hljs-comment">// Monkey patch the require function</span>
-mod.Module.prototype.require =
-  performance.timerify(mod.Module.prototype.require);
-<span class="hljs-built_in">require</span> = performance.timerify(<span class="hljs-built_in">require</span>);
+mod.<span class="hljs-property">Module</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">require</span> =
+  performance.<span class="hljs-title function_">timerify</span>(mod.<span class="hljs-property">Module</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">require</span>);
+<span class="hljs-built_in">require</span> = performance.<span class="hljs-title function_">timerify</span>(<span class="hljs-built_in">require</span>);
 
 <span class="hljs-comment">// Activate the observer</span>
-<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> PerformanceObserver(<span class="hljs-function">(<span class="hljs-params">list</span>) =></span> {
-  <span class="hljs-keyword">const</span> entries = list.getEntries();
-  entries.forEach(<span class="hljs-function">(<span class="hljs-params">entry</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`require('<span class="hljs-subst">${entry[<span class="hljs-number">0</span>]}</span>')`</span>, entry.duration);
+<span class="hljs-keyword">const</span> obs = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PerformanceObserver</span>(<span class="hljs-function">(<span class="hljs-params">list</span>) =></span> {
+  <span class="hljs-keyword">const</span> entries = list.<span class="hljs-title function_">getEntries</span>();
+  entries.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">entry</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`require('<span class="hljs-subst">${entry[<span class="hljs-number">0</span>]}</span>')`</span>, entry.<span class="hljs-property">duration</span>);
   });
-  obs.disconnect();
+  obs.<span class="hljs-title function_">disconnect</span>();
 });
-obs.observe({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'function'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
+obs.<span class="hljs-title function_">observe</span>({ <span class="hljs-attr">entryTypes</span>: [<span class="hljs-string">'function'</span>], <span class="hljs-attr">buffered</span>: <span class="hljs-literal">true</span> });
 
-<span class="hljs-built_in">require</span>(<span class="hljs-string">'some-module'</span>);</code></pre>
+<span class="hljs-built_in">require</span>(<span class="hljs-string">'some-module'</span>);</code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/perf_hooks.json b/doc/api/perf_hooks.json
index 6d8ff70ac1889a1d4f88364eccd41c18111a3341..113ea1034f51275f275afcb5973c8d62521491e4 100644
--- a/doc/api/perf_hooks.json
+++ b/doc/api/perf_hooks.json
@@ -8,7 +8,7 @@
       "introduced_in": "v8.5.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/perf_hooks.js\">lib/perf_hooks.js</a></p>\n<p>This module provides an implementation of a subset of the W3C\n<a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a> as well as additional APIs for\nNode.js-specific performance measurements.</p>\n<p>Node.js supports the following <a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a>:</p>\n<ul>\n<li><a href=\"https://www.w3.org/TR/hr-time-2\">High Resolution Time</a></li>\n<li><a href=\"https://w3c.github.io/performance-timeline/\">Performance Timeline</a></li>\n<li><a href=\"https://www.w3.org/TR/user-timing/\">User Timing</a></li>\n</ul>\n<pre><code class=\"language-js\">const { PerformanceObserver, performance } = require('perf_hooks');\n\nconst obs = new PerformanceObserver((items) => {\n  console.log(items.getEntries()[0].duration);\n  performance.clearMarks();\n});\nobs.observe({ entryTypes: ['measure'] });\nperformance.measure('Start to Now');\n\nperformance.mark('A');\ndoSomeLongRunningProcess(() => {\n  performance.measure('A to Now', 'A');\n\n  performance.mark('B');\n  performance.measure('A to B', 'A', 'B');\n});\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/perf_hooks.js\">lib/perf_hooks.js</a></p>\n<p>This module provides an implementation of a subset of the W3C\n<a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a> as well as additional APIs for\nNode.js-specific performance measurements.</p>\n<p>Node.js supports the following <a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a>:</p>\n<ul>\n<li><a href=\"https://www.w3.org/TR/hr-time-2\">High Resolution Time</a></li>\n<li><a href=\"https://w3c.github.io/performance-timeline/\">Performance Timeline</a></li>\n<li><a href=\"https://www.w3.org/TR/user-timing/\">User Timing</a></li>\n</ul>\n<pre><code class=\"language-js\">const { PerformanceObserver, performance } = require('perf_hooks');\n\nconst obs = new PerformanceObserver((items) => {\n  console.log(items.getEntries()[0].duration);\n  performance.clearMarks();\n});\nobs.observe({ entryTypes: ['measure'] });\nperformance.measure('Start to Now');\n\nperformance.mark('A');\ndoSomeLongRunningProcess(() => {\n  performance.measure('A to Now', 'A');\n\n  performance.mark('B');\n  performance.measure('A to B', 'A', 'B');\n});\n</code></pre>",
       "properties": [
         {
           "textRaw": "`perf_hooks.performance`",
@@ -95,7 +95,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>eventLoopUtilization()</code> method returns an object that contains the\ncumulative duration of time the event loop has been both idle and active as a\nhigh resolution milliseconds timer. The <code>utilization</code> value is the calculated\nEvent Loop Utilization (ELU).</p>\n<p>If bootstrapping has not yet finished on the main thread the properties have\nthe value of <code>0</code>. The ELU is immediately available on <a href=\"worker_threads.md#worker_threads_worker_threads\">Worker threads</a> since\nbootstrap happens within the event loop.</p>\n<p>Both <code>utilization1</code> and <code>utilization2</code> are optional parameters.</p>\n<p>If <code>utilization1</code> is passed, then the delta between the current call's <code>active</code>\nand <code>idle</code> times, as well as the corresponding <code>utilization</code> value are\ncalculated and returned (similar to <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>).</p>\n<p>If <code>utilization1</code> and <code>utilization2</code> are both passed, then the delta is\ncalculated between the two arguments. This is a convenience option because,\nunlike <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>, calculating the ELU is more complex than a\nsingle subtraction.</p>\n<p>ELU is similar to CPU utilization, except that it only measures event loop\nstatistics and not CPU usage. It represents the percentage of time the event\nloop has spent outside the event loop's event provider (e.g. <code>epoll_wait</code>).\nNo other CPU idle time is taken into consideration. The following is an example\nof how a mostly idle process will have a high ELU.</p>\n<pre><code class=\"language-js\">'use strict';\nconst { eventLoopUtilization } = require('perf_hooks').performance;\nconst { spawnSync } = require('child_process');\n\nsetImmediate(() => {\n  const elu = eventLoopUtilization();\n  spawnSync('sleep', ['5']);\n  console.log(eventLoopUtilization(elu).utilization);\n});\n</code></pre>\n<p>Although the CPU is mostly idle while running this script, the value of\n<code>utilization</code> is <code>1</code>. This is because the call to\n<a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a> blocks the event loop from proceeding.</p>\n<p>Passing in a user-defined object instead of the result of a previous call to\n<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values\nare not guaranteed to reflect any correct state of the event loop.</p>"
+              "desc": "<p>The <code>eventLoopUtilization()</code> method returns an object that contains the\ncumulative duration of time the event loop has been both idle and active as a\nhigh resolution milliseconds timer. The <code>utilization</code> value is the calculated\nEvent Loop Utilization (ELU).</p>\n<p>If bootstrapping has not yet finished on the main thread the properties have\nthe value of <code>0</code>. The ELU is immediately available on <a href=\"worker_threads.html#worker_threads_worker_threads\">Worker threads</a> since\nbootstrap happens within the event loop.</p>\n<p>Both <code>utilization1</code> and <code>utilization2</code> are optional parameters.</p>\n<p>If <code>utilization1</code> is passed, then the delta between the current call's <code>active</code>\nand <code>idle</code> times, as well as the corresponding <code>utilization</code> value are\ncalculated and returned (similar to <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>).</p>\n<p>If <code>utilization1</code> and <code>utilization2</code> are both passed, then the delta is\ncalculated between the two arguments. This is a convenience option because,\nunlike <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>, calculating the ELU is more complex than a\nsingle subtraction.</p>\n<p>ELU is similar to CPU utilization, except that it only measures event loop\nstatistics and not CPU usage. It represents the percentage of time the event\nloop has spent outside the event loop's event provider (e.g. <code>epoll_wait</code>).\nNo other CPU idle time is taken into consideration. The following is an example\nof how a mostly idle process will have a high ELU.</p>\n<pre><code class=\"language-js\">'use strict';\nconst { eventLoopUtilization } = require('perf_hooks').performance;\nconst { spawnSync } = require('child_process');\n\nsetImmediate(() => {\n  const elu = eventLoopUtilization();\n  spawnSync('sleep', ['5']);\n  console.log(eventLoopUtilization(elu).utilization);\n});\n</code></pre>\n<p>Although the CPU is mostly idle while running this script, the value of\n<code>utilization</code> is <code>1</code>. This is because the call to\n<a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a> blocks the event loop from proceeding.</p>\n<p>Passing in a user-defined object instead of the result of a previous call to\n<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values\nare not guaranteed to reflect any correct state of the event loop.</p>"
             },
             {
               "textRaw": "`performance.mark([name])`",
@@ -130,7 +130,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.3",
+                    "version": "v14.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32651",
                     "description": "Make `startMark` and `endMark` parameters optional."
                   }
@@ -205,58 +205,6 @@
                 }
               ],
               "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Wraps a function within a new function that measures the running time of the\nwrapped function. A <code>PerformanceObserver</code> must be subscribed to the <code>'function'</code>\nevent type in order for the timing details to be accessed.</p>\n<pre><code class=\"language-js\">const {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nfunction someFunction() {\n  console.log('hello world');\n}\n\nconst wrapped = performance.timerify(someFunction);\n\nconst obs = new PerformanceObserver((list) => {\n  console.log(list.getEntries()[0].duration);\n  obs.disconnect();\n});\nobs.observe({ entryTypes: ['function'] });\n\n// A performance timeline entry will be created\nwrapped();\n</code></pre>"
-            },
-            {
-              "textRaw": "`performance.eventLoopUtilization([util1][,util2])`",
-              "type": "method",
-              "name": "eventLoopUtilization",
-              "meta": {
-                "added": [
-                  "v12.19.0"
-                ],
-                "changes": []
-              },
-              "signatures": [
-                {
-                  "return": {
-                    "textRaw": "Returns {Object}",
-                    "name": "return",
-                    "type": "Object",
-                    "options": [
-                      {
-                        "textRaw": "`idle` {number}",
-                        "name": "idle",
-                        "type": "number"
-                      },
-                      {
-                        "textRaw": "`active` {number}",
-                        "name": "active",
-                        "type": "number"
-                      },
-                      {
-                        "textRaw": "`utilization` {number}",
-                        "name": "utilization",
-                        "type": "number"
-                      }
-                    ]
-                  },
-                  "params": [
-                    {
-                      "textRaw": "`util1` {Object} The result of a previous call to `eventLoopUtilization()`",
-                      "name": "util1",
-                      "type": "Object",
-                      "desc": "The result of a previous call to `eventLoopUtilization()`"
-                    },
-                    {
-                      "textRaw": "`util2` {Object} The result of a previous call to `eventLoopUtilization()` prior to `util1`",
-                      "name": "util2",
-                      "type": "Object",
-                      "desc": "The result of a previous call to `eventLoopUtilization()` prior to `util1`"
-                    }
-                  ]
-                }
-              ],
-              "desc": "<p>The <code>eventLoopUtilization()</code> method returns an object that contains the\ncumulative duration of time the event loop has been both idle and active as a\nhigh resolution milliseconds timer. The <code>utilization</code> value is the calculated\nEvent Loop Utilization (ELU). If bootstrapping has not yet finished, the\nproperties have the value of 0.</p>\n<p><code>util1</code> and <code>util2</code> are optional parameters.</p>\n<p>If <code>util1</code> is passed then the delta between the current call's <code>active</code> and\n<code>idle</code> times are calculated and returned (similar to <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>).\nLikewise the adjusted <code>utilization</code> value is calculated.</p>\n<p>If <code>util1</code> and <code>util2</code> are both passed then the calculation adjustments are\ndone between the two arguments. This is a convenience option because unlike\n<a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a> additional work is done to calculate the ELU.</p>\n<p>ELU is similar to CPU utilization except that it is calculated using high\nprecision wall-clock time. It represents the percentage of time the event loop\nhas spent outside the event loop's event provider (e.g. <code>epoll_wait</code>). No other\nCPU idle time is taken into consideration. The following is an example of how\na mostly idle process will have a high ELU.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">'use strict';\nconst { eventLoopUtilization } = require('perf_hooks').performance;\nconst { spawnSync } = require('child_process');\n\nsetImmediate(() => {\n  const elu = eventLoopUtilization();\n  spawnSync('sleep', ['5']);\n  console.log(eventLoopUtilization(elu).utilization);\n});\n</code></pre>\n<p>Although the CPU is mostly idle while running this script, the value of\n<code>utilization</code> is 1. This is because the call to <a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>\nblocks the event loop from proceeding.</p>\n<p>Passing in a user-defined object instead of the result of a previous call to\n<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values\nare not guaranteed to reflect any correct state of the event loop.</p>"
             }
           ],
           "properties": [
@@ -312,40 +260,41 @@
               "desc": "<p>The total number of milliseconds elapsed for this entry. This value will not\nbe meaningful for all Performance Entry types.</p>"
             },
             {
-              "textRaw": "`name` {string}",
+              "textRaw": "`entryType` {string}",
               "type": "string",
-              "name": "name",
+              "name": "entryType",
               "meta": {
                 "added": [
                   "v8.5.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The name of the performance entry.</p>"
+              "desc": "<p>The type of the performance entry. It may be one of:</p>\n<ul>\n<li><code>'node'</code> (Node.js only)</li>\n<li><code>'mark'</code> (available on the Web)</li>\n<li><code>'measure'</code> (available on the Web)</li>\n<li><code>'gc'</code> (Node.js only)</li>\n<li><code>'function'</code> (Node.js only)</li>\n<li><code>'http2'</code> (Node.js only)</li>\n<li><code>'http'</code> (Node.js only)</li>\n</ul>"
             },
             {
-              "textRaw": "`startTime` {number}",
+              "textRaw": "`flags` {number}",
               "type": "number",
-              "name": "startTime",
+              "name": "flags",
               "meta": {
                 "added": [
-                  "v8.5.0"
+                  "v13.9.0",
+                  "v12.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The high resolution millisecond timestamp marking the starting time of the\nPerformance Entry.</p>"
+              "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>\nproperty contains additional information about garbage collection operation.\nThe value may be one of:</p>\n<ul>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>\n</ul>"
             },
             {
-              "textRaw": "`entryType` {string}",
+              "textRaw": "`name` {string}",
               "type": "string",
-              "name": "entryType",
+              "name": "name",
               "meta": {
                 "added": [
                   "v8.5.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The type of the performance entry. It may be one of:</p>\n<ul>\n<li><code>'node'</code> (Node.js only)</li>\n<li><code>'mark'</code> (available on the Web)</li>\n<li><code>'measure'</code> (available on the Web)</li>\n<li><code>'gc'</code> (Node.js only)</li>\n<li><code>'function'</code> (Node.js only)</li>\n<li><code>'http2'</code> (Node.js only)</li>\n<li><code>'http'</code> (Node.js only)</li>\n</ul>"
+              "desc": "<p>The name of the performance entry.</p>"
             },
             {
               "textRaw": "`kind` {number}",
@@ -360,21 +309,21 @@
               "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.kind</code>\nproperty identifies the type of garbage collection operation that occurred.\nThe value may be one of:</p>\n<ul>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_MAJOR</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_MINOR</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB</code></li>\n</ul>"
             },
             {
-              "textRaw": "`flags` {number}",
+              "textRaw": "`startTime` {number}",
               "type": "number",
-              "name": "flags",
+              "name": "startTime",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v8.5.0"
                 ],
                 "changes": []
               },
-              "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>When <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>\nproperty contains additional information about garbage collection operation.\nThe value may be one of:</p>\n<ul>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>\n</ul>"
+              "desc": "<p>The high resolution millisecond timestamp marking the starting time of the\nPerformance Entry.</p>"
             }
           ]
         },
         {
-          "textRaw": "Class: `PerformanceNodeTiming extends PerformanceEntry`",
+          "textRaw": "Class: `PerformanceNodeTiming`",
           "type": "class",
           "name": "PerformanceNodeTiming",
           "meta": {
@@ -383,7 +332,7 @@
             ],
             "changes": []
           },
-          "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Provides timing details for Node.js itself. The constructor of this class\nis not exposed to users.</p>",
+          "desc": "<ul>\n<li>Extends: <a href=\"perf_hooks.html#perf_hooks_class_performanceentry\" class=\"type\">&lt;PerformanceEntry&gt;</a></li>\n</ul>\n<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Provides timing details for Node.js itself. The constructor of this class\nis not exposed to users.</p>",
           "properties": [
             {
               "textRaw": "`bootstrapComplete` {number}",
@@ -409,6 +358,19 @@
               },
               "desc": "<p>The high resolution millisecond timestamp at which the Node.js environment was\ninitialized.</p>"
             },
+            {
+              "textRaw": "`idleTime` {number}",
+              "type": "number",
+              "name": "idleTime",
+              "meta": {
+                "added": [
+                  "v14.10.0",
+                  "v12.19.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The high resolution millisecond timestamp of the amount of time the event loop\nhas been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This\ndoes not take CPU usage into consideration. If the event loop has not yet\nstarted (e.g., in the first tick of the main script), the property has the\nvalue of 0.</p>"
+            },
             {
               "textRaw": "`loopExit` {number}",
               "type": "number",
@@ -456,18 +418,6 @@
                 "changes": []
               },
               "desc": "<p>The high resolution millisecond timestamp at which the V8 platform was\ninitialized.</p>"
-            },
-            {
-              "textRaw": "`idleTime` {number}",
-              "type": "number",
-              "name": "idleTime",
-              "meta": {
-                "added": [
-                  "v12.19.0"
-                ],
-                "changes": []
-              },
-              "desc": "<p>The high resolution millisecond timestamp of the amount of time the event loop\nhas been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This\ndoes not take CPU usage into consideration. If the event loop has not yet\nstarted (e.g., in the first tick of the main script), the property has the\nvalue of 0.</p>"
             }
           ]
         },
@@ -589,7 +539,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code>.</p>"
+              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code>.</p>\n<pre><code class=\"language-js\">const {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((perfObserverList, observer) => {\n  console.log(perfObserverList.getEntries());\n  /**\n   * [\n   *   PerformanceEntry {\n   *     name: 'test',\n   *     entryType: 'mark',\n   *     startTime: 81.465639,\n   *     duration: 0\n   *   },\n   *   PerformanceEntry {\n   *     name: 'meow',\n   *     entryType: 'mark',\n   *     startTime: 81.860064,\n   *     duration: 0\n   *   }\n   * ]\n   */\n  observer.disconnect();\n});\nobs.observe({ entryTypes: ['mark'], buffered: true });\n\nperformance.mark('test');\nperformance.mark('meow');\n</code></pre>"
             },
             {
               "textRaw": "`performanceObserverEntryList.getEntriesByName(name[, type])`",
@@ -622,7 +572,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.name</code> is\nequal to <code>name</code>, and optionally, whose <code>performanceEntry.entryType</code> is equal to\n<code>type</code>.</p>"
+              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.name</code> is\nequal to <code>name</code>, and optionally, whose <code>performanceEntry.entryType</code> is equal to\n<code>type</code>.</p>\n<pre><code class=\"language-js\">const {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((perfObserverList, observer) => {\n  console.log(perfObserverList.getEntriesByName('meow'));\n  /**\n   * [\n   *   PerformanceEntry {\n   *     name: 'meow',\n   *     entryType: 'mark',\n   *     startTime: 98.545991,\n   *     duration: 0\n   *   }\n   * ]\n   */\n  console.log(perfObserverList.getEntriesByName('nope')); // []\n\n  console.log(perfObserverList.getEntriesByName('test', 'mark'));\n  /**\n   * [\n   *   PerformanceEntry {\n   *     name: 'test',\n   *     entryType: 'mark',\n   *     startTime: 63.518931,\n   *     duration: 0\n   *   }\n   * ]\n   */\n  console.log(perfObserverList.getEntriesByName('test', 'measure')); // []\n  observer.disconnect();\n});\nobs.observe({ entryTypes: ['mark', 'measure'], buffered: true });\n\nperformance.mark('test');\nperformance.mark('meow');\n</code></pre>"
             },
             {
               "textRaw": "`performanceObserverEntryList.getEntriesByType(type)`",
@@ -650,226 +600,254 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.entryType</code>\nis equal to <code>type</code>.</p>"
+              "desc": "<p>Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.entryType</code>\nis equal to <code>type</code>.</p>\n<pre><code class=\"language-js\">const {\n  performance,\n  PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((perfObserverList, observer) => {\n  console.log(perfObserverList.getEntriesByType('mark'));\n  /**\n   * [\n   *   PerformanceEntry {\n   *     name: 'test',\n   *     entryType: 'mark',\n   *     startTime: 55.897834,\n   *     duration: 0\n   *   },\n   *   PerformanceEntry {\n   *     name: 'meow',\n   *     entryType: 'mark',\n   *     startTime: 56.350146,\n   *     duration: 0\n   *   }\n   * ]\n   */\n  observer.disconnect();\n});\nobs.observe({ entryTypes: ['mark'], buffered: true });\n\nperformance.mark('test');\nperformance.mark('meow');\n</code></pre>"
             }
           ]
-        }
-      ],
-      "methods": [
+        },
         {
-          "textRaw": "`perf_hooks.monitorEventLoopDelay([options])`",
-          "type": "method",
-          "name": "monitorEventLoopDelay",
+          "textRaw": "Class: `Histogram`",
+          "type": "class",
+          "name": "Histogram",
           "meta": {
             "added": [
               "v11.10.0"
             ],
             "changes": []
           },
-          "signatures": [
+          "properties": [
             {
-              "return": {
-                "textRaw": "Returns: {Histogram}",
-                "name": "return",
-                "type": "Histogram"
+              "textRaw": "`exceeds` {number}",
+              "type": "number",
+              "name": "exceeds",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
               },
-              "params": [
+              "desc": "<p>The number of times the event loop delay exceeded the maximum 1 hour event\nloop delay threshold.</p>"
+            },
+            {
+              "textRaw": "`max` {number}",
+              "type": "number",
+              "name": "max",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The maximum recorded event loop delay.</p>"
+            },
+            {
+              "textRaw": "`mean` {number}",
+              "type": "number",
+              "name": "mean",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The mean of the recorded event loop delays.</p>"
+            },
+            {
+              "textRaw": "`min` {number}",
+              "type": "number",
+              "name": "min",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The minimum recorded event loop delay.</p>"
+            },
+            {
+              "textRaw": "`percentiles` {Map}",
+              "type": "Map",
+              "name": "percentiles",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>Returns a <code>Map</code> object detailing the accumulated percentile distribution.</p>"
+            },
+            {
+              "textRaw": "`stddev` {number}",
+              "type": "number",
+              "name": "stddev",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "desc": "<p>The standard deviation of the recorded event loop delays.</p>"
+            }
+          ],
+          "methods": [
+            {
+              "textRaw": "`histogram.percentile(percentile)`",
+              "type": "method",
+              "name": "percentile",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`options` {Object}",
-                  "name": "options",
-                  "type": "Object",
-                  "options": [
+                  "return": {
+                    "textRaw": "Returns: {number}",
+                    "name": "return",
+                    "type": "number"
+                  },
+                  "params": [
                     {
-                      "textRaw": "`resolution` {number} The sampling rate in milliseconds. Must be greater than zero. **Default:** `10`.",
-                      "name": "resolution",
+                      "textRaw": "`percentile` {number} A percentile value in the range (0, 100].",
+                      "name": "percentile",
                       "type": "number",
-                      "default": "`10`",
-                      "desc": "The sampling rate in milliseconds. Must be greater than zero."
+                      "desc": "A percentile value in the range (0, 100]."
                     }
                   ]
                 }
-              ]
-            }
-          ],
-          "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Creates a <code>Histogram</code> object that samples and reports the event loop delay\nover time. The delays will be reported in nanoseconds.</p>\n<p>Using a timer to detect approximate event loop delay works because the\nexecution of timers is tied specifically to the lifecycle of the libuv\nevent loop. That is, a delay in the loop will cause a delay in the execution\nof the timer, and those delays are specifically what this API is intended to\ndetect.</p>\n<pre><code class=\"language-js\">const { monitorEventLoopDelay } = require('perf_hooks');\nconst h = monitorEventLoopDelay({ resolution: 20 });\nh.enable();\n// Do something.\nh.disable();\nconsole.log(h.min);\nconsole.log(h.max);\nconsole.log(h.mean);\nconsole.log(h.stddev);\nconsole.log(h.percentiles);\nconsole.log(h.percentile(50));\nconsole.log(h.percentile(99));\n</code></pre>",
-          "classes": [
+              ],
+              "desc": "<p>Returns the value at the given percentile.</p>"
+            },
             {
-              "textRaw": "Class: `Histogram`",
-              "type": "class",
-              "name": "Histogram",
+              "textRaw": "`histogram.reset()`",
+              "type": "method",
+              "name": "reset",
               "meta": {
                 "added": [
                   "v11.10.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>Tracks the event loop delay at a given sampling rate. The constructor of\nthis class not exposed to users.</p>\n<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>",
-              "methods": [
+              "signatures": [
                 {
-                  "textRaw": "`histogram.disable()`",
-                  "type": "method",
-                  "name": "disable",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {boolean}",
-                        "name": "return",
-                        "type": "boolean"
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Disables the event loop delay sample timer. Returns <code>true</code> if the timer was\nstopped, <code>false</code> if it was already stopped.</p>"
-                },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Resets the collected histogram data.</p>"
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `IntervalHistogram extends Histogram`",
+          "type": "class",
+          "name": "IntervalHistogram",
+          "desc": "<p>A <code>Histogram</code> that is periodically updated on a given interval.</p>",
+          "methods": [
+            {
+              "textRaw": "`histogram.disable()`",
+              "type": "method",
+              "name": "disable",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`histogram.enable()`",
-                  "type": "method",
-                  "name": "enable",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
                   },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {boolean}",
-                        "name": "return",
-                        "type": "boolean"
-                      },
-                      "params": []
-                    }
-                  ],
-                  "desc": "<p>Enables the event loop delay sample timer. Returns <code>true</code> if the timer was\nstarted, <code>false</code> if it was already started.</p>"
-                },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Disables the update interval timer. Returns <code>true</code> if the timer was\nstopped, <code>false</code> if it was already stopped.</p>"
+            },
+            {
+              "textRaw": "`histogram.enable()`",
+              "type": "method",
+              "name": "enable",
+              "meta": {
+                "added": [
+                  "v11.10.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`histogram.percentile(percentile)`",
-                  "type": "method",
-                  "name": "percentile",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
+                  "return": {
+                    "textRaw": "Returns: {boolean}",
+                    "name": "return",
+                    "type": "boolean"
                   },
-                  "signatures": [
-                    {
-                      "return": {
-                        "textRaw": "Returns: {number}",
-                        "name": "return",
-                        "type": "number"
-                      },
-                      "params": [
-                        {
-                          "textRaw": "`percentile` {number} A percentile value between 1 and 100.",
-                          "name": "percentile",
-                          "type": "number",
-                          "desc": "A percentile value between 1 and 100."
-                        }
-                      ]
-                    }
-                  ],
-                  "desc": "<p>Returns the value at the given percentile.</p>"
-                },
+                  "params": []
+                }
+              ],
+              "desc": "<p>Enables the update interval timer. Returns <code>true</code> if the timer was\nstarted, <code>false</code> if it was already started.</p>"
+            }
+          ],
+          "modules": [
+            {
+              "textRaw": "Cloning an `IntervalHistogram`",
+              "name": "cloning_an_`intervalhistogram`",
+              "desc": "<p><a href=\"perf_hooks.html#perf_hooks_class_intervalhistogram_extends_histogram\" class=\"type\">&lt;IntervalHistogram&gt;</a> instances can be cloned via <a href=\"worker_threads.html#worker_threads_class_messageport\" class=\"type\">&lt;MessagePort&gt;</a>. On the receiving\nend, the histogram is cloned as a plain <a href=\"perf_hooks.html#perf_hooks_class_histogram\" class=\"type\">&lt;Histogram&gt;</a> object that does not\nimplement the <code>enable()</code> and <code>disable()</code> methods.</p>",
+              "type": "module",
+              "displayName": "Cloning an `IntervalHistogram`"
+            }
+          ]
+        },
+        {
+          "textRaw": "Class: `RecordableHistogram extends Histogram`",
+          "type": "class",
+          "name": "RecordableHistogram",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "methods": [
+            {
+              "textRaw": "`histogram.record(val)`",
+              "type": "method",
+              "name": "record",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`histogram.reset()`",
-                  "type": "method",
-                  "name": "reset",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "signatures": [
+                  "params": [
                     {
-                      "params": []
+                      "textRaw": "`val` {number|bigint} The amount to record in the histogram.",
+                      "name": "val",
+                      "type": "number|bigint",
+                      "desc": "The amount to record in the histogram."
                     }
-                  ],
-                  "desc": "<p>Resets the collected histogram data.</p>"
+                  ]
                 }
-              ],
-              "properties": [
-                {
-                  "textRaw": "`exceeds` {number}",
-                  "type": "number",
-                  "name": "exceeds",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The number of times the event loop delay exceeded the maximum 1 hour event\nloop delay threshold.</p>"
-                },
-                {
-                  "textRaw": "`max` {number}",
-                  "type": "number",
-                  "name": "max",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The maximum recorded event loop delay.</p>"
-                },
-                {
-                  "textRaw": "`mean` {number}",
-                  "type": "number",
-                  "name": "mean",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The mean of the recorded event loop delays.</p>"
-                },
-                {
-                  "textRaw": "`min` {number}",
-                  "type": "number",
-                  "name": "min",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The minimum recorded event loop delay.</p>"
-                },
-                {
-                  "textRaw": "`percentiles` {Map}",
-                  "type": "Map",
-                  "name": "percentiles",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>Returns a <code>Map</code> object detailing the accumulated percentile distribution.</p>"
-                },
+              ]
+            },
+            {
+              "textRaw": "`histogram.recordDelta()`",
+              "type": "method",
+              "name": "recordDelta",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
                 {
-                  "textRaw": "`stddev` {number}",
-                  "type": "number",
-                  "name": "stddev",
-                  "meta": {
-                    "added": [
-                      "v11.10.0"
-                    ],
-                    "changes": []
-                  },
-                  "desc": "<p>The standard deviation of the recorded event loop delays.</p>\n<h2>Examples</h2>"
+                  "params": []
                 }
-              ]
+              ],
+              "desc": "<p>Calculates the amount of time (in nanoseconds) that has passed since the\nprevious call to <code>recordDelta()</code> and records that amount in the histogram.</p>\n<h2>Examples</h2>"
             }
           ],
           "modules": [
@@ -890,6 +868,93 @@
           ]
         }
       ],
+      "methods": [
+        {
+          "textRaw": "`perf_hooks.createHistogram([options])`",
+          "type": "method",
+          "name": "createHistogram",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns {RecordableHistogram}",
+                "name": "return",
+                "type": "RecordableHistogram"
+              },
+              "params": [
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`min` {number|bigint} The minimum recordable value. Must be an integer value greater than 0. **Defaults**: `1`.",
+                      "name": "min",
+                      "type": "number|bigint",
+                      "desc": "The minimum recordable value. Must be an integer value greater than 0. **Defaults**: `1`."
+                    },
+                    {
+                      "textRaw": "`max` {number|bigint} The maximum recordable value. Must be an integer value greater than `min`. **Defaults**: `Number.MAX_SAFE_INTEGER`.",
+                      "name": "max",
+                      "type": "number|bigint",
+                      "desc": "The maximum recordable value. Must be an integer value greater than `min`. **Defaults**: `Number.MAX_SAFE_INTEGER`."
+                    },
+                    {
+                      "textRaw": "`figures` {number} The number of accuracy digits. Must be a number between `1` and `5`. **Defaults**: `3`.",
+                      "name": "figures",
+                      "type": "number",
+                      "desc": "The number of accuracy digits. Must be a number between `1` and `5`. **Defaults**: `3`."
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Returns a <a href=\"perf_hooks.html#perf_hooks_class_recordablehistogram_extends_histogram\" class=\"type\">&lt;RecordableHistogram&gt;</a>.</p>"
+        },
+        {
+          "textRaw": "`perf_hooks.monitorEventLoopDelay([options])`",
+          "type": "method",
+          "name": "monitorEventLoopDelay",
+          "meta": {
+            "added": [
+              "v11.10.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {IntervalHistogram}",
+                "name": "return",
+                "type": "IntervalHistogram"
+              },
+              "params": [
+                {
+                  "textRaw": "`options` {Object}",
+                  "name": "options",
+                  "type": "Object",
+                  "options": [
+                    {
+                      "textRaw": "`resolution` {number} The sampling rate in milliseconds. Must be greater than zero. **Default:** `10`.",
+                      "name": "resolution",
+                      "type": "number",
+                      "default": "`10`",
+                      "desc": "The sampling rate in milliseconds. Must be greater than zero."
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p><em>This property is an extension by Node.js. It is not available in Web browsers.</em></p>\n<p>Creates an <code>IntervalHistogram</code> object that samples and reports the event loop\ndelay over time. The delays will be reported in nanoseconds.</p>\n<p>Using a timer to detect approximate event loop delay works because the\nexecution of timers is tied specifically to the lifecycle of the libuv\nevent loop. That is, a delay in the loop will cause a delay in the execution\nof the timer, and those delays are specifically what this API is intended to\ndetect.</p>\n<pre><code class=\"language-js\">const { monitorEventLoopDelay } = require('perf_hooks');\nconst h = monitorEventLoopDelay({ resolution: 20 });\nh.enable();\n// Do something.\nh.disable();\nconsole.log(h.min);\nconsole.log(h.max);\nconsole.log(h.mean);\nconsole.log(h.stddev);\nconsole.log(h.percentiles);\nconsole.log(h.percentile(50));\nconsole.log(h.percentile(99));\n</code></pre>"
+        }
+      ],
       "type": "module",
       "displayName": "Performance measurement APIs"
     }
diff --git a/doc/api/perf_hooks.md b/doc/api/perf_hooks.md
index b9ecc848700b0d4be1ce7612a1b9fa05ac112b7b..df946236f171232124263bf2f97f7ed4695f4f12 100644
--- a/doc/api/perf_hooks.md
+++ b/doc/api/perf_hooks.md
@@ -132,7 +132,7 @@ to mark specific significant moments in the Performance Timeline.
 <!-- YAML
 added: v8.5.0
 changes:
-  - version: v12.16.3
+  - version: v14.0.0
     pr-url: https://github.com/nodejs/node/pull/32651
     description: Make `startMark` and `endMark` parameters optional.
 -->
@@ -225,62 +225,6 @@ obs.observe({ entryTypes: ['function'] });
 wrapped();
 ```
 
-### `performance.eventLoopUtilization([util1][,util2])`
-<!-- YAML
-added: v12.19.0
--->
-
-* `util1` {Object} The result of a previous call to `eventLoopUtilization()`
-* `util2` {Object} The result of a previous call to `eventLoopUtilization()`
-    prior to `util1`
-* Returns {Object}
-  * `idle` {number}
-  * `active` {number}
-  * `utilization` {number}
-
-The `eventLoopUtilization()` method returns an object that contains the
-cumulative duration of time the event loop has been both idle and active as a
-high resolution milliseconds timer. The `utilization` value is the calculated
-Event Loop Utilization (ELU). If bootstrapping has not yet finished, the
-properties have the value of 0.
-
-`util1` and `util2` are optional parameters.
-
-If `util1` is passed then the delta between the current call's `active` and
-`idle` times are calculated and returned (similar to [`process.hrtime()`][]).
-Likewise the adjusted `utilization` value is calculated.
-
-If `util1` and `util2` are both passed then the calculation adjustments are
-done between the two arguments. This is a convenience option because unlike
-[`process.hrtime()`][] additional work is done to calculate the ELU.
-
-ELU is similar to CPU utilization except that it is calculated using high
-precision wall-clock time. It represents the percentage of time the event loop
-has spent outside the event loop's event provider (e.g. `epoll_wait`). No other
-CPU idle time is taken into consideration. The following is an example of how
-a mostly idle process will have a high ELU.
-
-<!-- eslint-skip -->
-```js
-'use strict';
-const { eventLoopUtilization } = require('perf_hooks').performance;
-const { spawnSync } = require('child_process');
-
-setImmediate(() => {
-  const elu = eventLoopUtilization();
-  spawnSync('sleep', ['5']);
-  console.log(eventLoopUtilization(elu).utilization);
-});
-```
-
-Although the CPU is mostly idle while running this script, the value of
-`utilization` is 1. This is because the call to [`child_process.spawnSync()`][]
-blocks the event loop from proceeding.
-
-Passing in a user-defined object instead of the result of a previous call to
-`eventLoopUtilization()` will lead to undefined behavior. The return values
-are not guaranteed to reflect any correct state of the event loop.
-
 ## Class: `PerformanceEntry`
 <!-- YAML
 added: v8.5.0
@@ -296,41 +240,54 @@ added: v8.5.0
 The total number of milliseconds elapsed for this entry. This value will not
 be meaningful for all Performance Entry types.
 
-### `performanceEntry.name`
+### `performanceEntry.entryType`
 <!-- YAML
 added: v8.5.0
 -->
 
 * {string}
 
-The name of the performance entry.
+The type of the performance entry. It may be one of:
 
-### `performanceEntry.startTime`
+* `'node'` (Node.js only)
+* `'mark'` (available on the Web)
+* `'measure'` (available on the Web)
+* `'gc'` (Node.js only)
+* `'function'` (Node.js only)
+* `'http2'` (Node.js only)
+* `'http'` (Node.js only)
+
+### `performanceEntry.flags`
 <!-- YAML
-added: v8.5.0
+added:
+ - v13.9.0
+ - v12.17.0
 -->
 
 * {number}
 
-The high resolution millisecond timestamp marking the starting time of the
-Performance Entry.
+_This property is an extension by Node.js. It is not available in Web browsers._
 
-### `performanceEntry.entryType`
+When `performanceEntry.entryType` is equal to `'gc'`, the `performance.flags`
+property contains additional information about garbage collection operation.
+The value may be one of:
+
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE`
+
+### `performanceEntry.name`
 <!-- YAML
 added: v8.5.0
 -->
 
 * {string}
 
-The type of the performance entry. It may be one of:
-
-* `'node'` (Node.js only)
-* `'mark'` (available on the Web)
-* `'measure'` (available on the Web)
-* `'gc'` (Node.js only)
-* `'function'` (Node.js only)
-* `'http2'` (Node.js only)
-* `'http'` (Node.js only)
+The name of the performance entry.
 
 ### `performanceEntry.kind`
 <!-- YAML
@@ -350,32 +307,23 @@ The value may be one of:
 * `perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL`
 * `perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB`
 
-### performanceEntry.flags
+### `performanceEntry.startTime`
 <!-- YAML
-added: v12.17.0
+added: v8.5.0
 -->
 
 * {number}
 
-_This property is an extension by Node.js. It is not available in Web browsers._
-
-When `performanceEntry.entryType` is equal to `'gc'`, the `performance.flags`
-property contains additional information about garbage collection operation.
-The value may be one of:
-
-* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO`
-* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED`
-* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED`
-* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING`
-* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE`
-* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY`
-* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE`
+The high resolution millisecond timestamp marking the starting time of the
+Performance Entry.
 
-## Class: `PerformanceNodeTiming extends PerformanceEntry`
+## Class: `PerformanceNodeTiming`
 <!-- YAML
 added: v8.5.0
 -->
 
+* Extends: {PerformanceEntry}
+
 _This property is an extension by Node.js. It is not available in Web browsers._
 
 Provides timing details for Node.js itself. The constructor of this class
@@ -402,6 +350,21 @@ added: v8.5.0
 The high resolution millisecond timestamp at which the Node.js environment was
 initialized.
 
+### `performanceNodeTiming.idleTime`
+<!-- YAML
+added:
+  - v14.10.0
+  - v12.19.0
+-->
+
+* {number}
+
+The high resolution millisecond timestamp of the amount of time the event loop
+has been idle within the event loop's event provider (e.g. `epoll_wait`). This
+does not take CPU usage into consideration. If the event loop has not yet
+started (e.g., in the first tick of the main script), the property has the
+value of 0.
+
 ### `performanceNodeTiming.loopExit`
 <!-- YAML
 added: v8.5.0
@@ -444,19 +407,6 @@ added: v8.5.0
 The high resolution millisecond timestamp at which the V8 platform was
 initialized.
 
-### `performanceNodeTiming.idleTime`
-<!-- YAML
-added: v12.19.0
--->
-
-* {number}
-
-The high resolution millisecond timestamp of the amount of time the event loop
-has been idle within the event loop's event provider (e.g. `epoll_wait`). This
-does not take CPU usage into consideration. If the event loop has not yet
-started (e.g., in the first tick of the main script), the property has the
-value of 0.
-
 ## Class: `perf_hooks.PerformanceObserver`
 
 ### `new PerformanceObserver(callback)`
@@ -571,6 +521,38 @@ added: v8.5.0
 Returns a list of `PerformanceEntry` objects in chronological order
 with respect to `performanceEntry.startTime`.
 
+```js
+const {
+  performance,
+  PerformanceObserver
+} = require('perf_hooks');
+
+const obs = new PerformanceObserver((perfObserverList, observer) => {
+  console.log(perfObserverList.getEntries());
+  /**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 81.465639,
+   *     duration: 0
+   *   },
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 81.860064,
+   *     duration: 0
+   *   }
+   * ]
+   */
+  observer.disconnect();
+});
+obs.observe({ entryTypes: ['mark'], buffered: true });
+
+performance.mark('test');
+performance.mark('meow');
+```
+
 ### `performanceObserverEntryList.getEntriesByName(name[, type])`
 <!-- YAML
 added: v8.5.0
@@ -585,6 +567,46 @@ with respect to `performanceEntry.startTime` whose `performanceEntry.name` is
 equal to `name`, and optionally, whose `performanceEntry.entryType` is equal to
 `type`.
 
+```js
+const {
+  performance,
+  PerformanceObserver
+} = require('perf_hooks');
+
+const obs = new PerformanceObserver((perfObserverList, observer) => {
+  console.log(perfObserverList.getEntriesByName('meow'));
+  /**
+   * [
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 98.545991,
+   *     duration: 0
+   *   }
+   * ]
+   */
+  console.log(perfObserverList.getEntriesByName('nope')); // []
+
+  console.log(perfObserverList.getEntriesByName('test', 'mark'));
+  /**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 63.518931,
+   *     duration: 0
+   *   }
+   * ]
+   */
+  console.log(perfObserverList.getEntriesByName('test', 'measure')); // []
+  observer.disconnect();
+});
+obs.observe({ entryTypes: ['mark', 'measure'], buffered: true });
+
+performance.mark('test');
+performance.mark('meow');
+```
+
 ### `performanceObserverEntryList.getEntriesByType(type)`
 <!-- YAML
 added: v8.5.0
@@ -597,6 +619,54 @@ Returns a list of `PerformanceEntry` objects in chronological order
 with respect to `performanceEntry.startTime` whose `performanceEntry.entryType`
 is equal to `type`.
 
+```js
+const {
+  performance,
+  PerformanceObserver
+} = require('perf_hooks');
+
+const obs = new PerformanceObserver((perfObserverList, observer) => {
+  console.log(perfObserverList.getEntriesByType('mark'));
+  /**
+   * [
+   *   PerformanceEntry {
+   *     name: 'test',
+   *     entryType: 'mark',
+   *     startTime: 55.897834,
+   *     duration: 0
+   *   },
+   *   PerformanceEntry {
+   *     name: 'meow',
+   *     entryType: 'mark',
+   *     startTime: 56.350146,
+   *     duration: 0
+   *   }
+   * ]
+   */
+  observer.disconnect();
+});
+obs.observe({ entryTypes: ['mark'], buffered: true });
+
+performance.mark('test');
+performance.mark('meow');
+```
+
+## `perf_hooks.createHistogram([options])`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `options` {Object}
+  * `min` {number|bigint} The minimum recordable value. Must be an integer
+    value greater than 0. **Defaults**: `1`.
+  * `max` {number|bigint} The maximum recordable value. Must be an integer
+    value greater than `min`. **Defaults**: `Number.MAX_SAFE_INTEGER`.
+  * `figures` {number} The number of accuracy digits. Must be a number between
+    `1` and `5`. **Defaults**: `3`.
+* Returns {RecordableHistogram}
+
+Returns a {RecordableHistogram}.
+
 ## `perf_hooks.monitorEventLoopDelay([options])`
 <!-- YAML
 added: v11.10.0
@@ -605,12 +675,12 @@ added: v11.10.0
 * `options` {Object}
   * `resolution` {number} The sampling rate in milliseconds. Must be greater
     than zero. **Default:** `10`.
-* Returns: {Histogram}
+* Returns: {IntervalHistogram}
 
 _This property is an extension by Node.js. It is not available in Web browsers._
 
-Creates a `Histogram` object that samples and reports the event loop delay
-over time. The delays will be reported in nanoseconds.
+Creates an `IntervalHistogram` object that samples and reports the event loop
+delay over time. The delays will be reported in nanoseconds.
 
 Using a timer to detect approximate event loop delay works because the
 execution of timers is tied specifically to the lifecycle of the libuv
@@ -633,36 +703,12 @@ console.log(h.percentile(50));
 console.log(h.percentile(99));
 ```
 
-### Class: `Histogram`
+## Class: `Histogram`
 <!-- YAML
 added: v11.10.0
 -->
-Tracks the event loop delay at a given sampling rate. The constructor of
-this class not exposed to users.
 
-_This property is an extension by Node.js. It is not available in Web browsers._
-
-#### `histogram.disable()`
-<!-- YAML
-added: v11.10.0
--->
-
-* Returns: {boolean}
-
-Disables the event loop delay sample timer. Returns `true` if the timer was
-stopped, `false` if it was already stopped.
-
-#### `histogram.enable()`
-<!-- YAML
-added: v11.10.0
--->
-
-* Returns: {boolean}
-
-Enables the event loop delay sample timer. Returns `true` if the timer was
-started, `false` if it was already started.
-
-#### `histogram.exceeds`
+### `histogram.exceeds`
 <!-- YAML
 added: v11.10.0
 -->
@@ -672,7 +718,7 @@ added: v11.10.0
 The number of times the event loop delay exceeded the maximum 1 hour event
 loop delay threshold.
 
-#### `histogram.max`
+### `histogram.max`
 <!-- YAML
 added: v11.10.0
 -->
@@ -681,7 +727,7 @@ added: v11.10.0
 
 The maximum recorded event loop delay.
 
-#### `histogram.mean`
+### `histogram.mean`
 <!-- YAML
 added: v11.10.0
 -->
@@ -690,7 +736,7 @@ added: v11.10.0
 
 The mean of the recorded event loop delays.
 
-#### `histogram.min`
+### `histogram.min`
 <!-- YAML
 added: v11.10.0
 -->
@@ -699,17 +745,17 @@ added: v11.10.0
 
 The minimum recorded event loop delay.
 
-#### `histogram.percentile(percentile)`
+### `histogram.percentile(percentile)`
 <!-- YAML
 added: v11.10.0
 -->
 
-* `percentile` {number} A percentile value between 1 and 100.
+* `percentile` {number} A percentile value in the range (0, 100].
 * Returns: {number}
 
 Returns the value at the given percentile.
 
-#### `histogram.percentiles`
+### `histogram.percentiles`
 <!-- YAML
 added: v11.10.0
 -->
@@ -718,14 +764,14 @@ added: v11.10.0
 
 Returns a `Map` object detailing the accumulated percentile distribution.
 
-#### `histogram.reset()`
+### `histogram.reset()`
 <!-- YAML
 added: v11.10.0
 -->
 
 Resets the collected histogram data.
 
-#### `histogram.stddev`
+### `histogram.stddev`
 <!-- YAML
 added: v11.10.0
 -->
@@ -734,6 +780,56 @@ added: v11.10.0
 
 The standard deviation of the recorded event loop delays.
 
+## Class: `IntervalHistogram extends Histogram`
+
+A `Histogram` that is periodically updated on a given interval.
+
+### `histogram.disable()`
+<!-- YAML
+added: v11.10.0
+-->
+
+* Returns: {boolean}
+
+Disables the update interval timer. Returns `true` if the timer was
+stopped, `false` if it was already stopped.
+
+### `histogram.enable()`
+<!-- YAML
+added: v11.10.0
+-->
+
+* Returns: {boolean}
+
+Enables the update interval timer. Returns `true` if the timer was
+started, `false` if it was already started.
+
+### Cloning an `IntervalHistogram`
+
+{IntervalHistogram} instances can be cloned via {MessagePort}. On the receiving
+end, the histogram is cloned as a plain {Histogram} object that does not
+implement the `enable()` and `disable()` methods.
+
+## Class: `RecordableHistogram extends Histogram`
+<!-- YAML
+added: v14.18.0
+-->
+
+### `histogram.record(val)`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `val` {number|bigint} The amount to record in the histogram.
+
+### `histogram.recordDelta()`
+<!-- YAML
+added: v14.18.0
+-->
+
+Calculates the amount of time (in nanoseconds) that has passed since the
+previous call to `recordDelta()` and records that amount in the histogram.
+
 ## Examples
 
 ### Measuring the duration of async operations
@@ -812,14 +908,14 @@ obs.observe({ entryTypes: ['function'], buffered: true });
 require('some-module');
 ```
 
-[`'exit'`]: process.html#process_event_exit
-[`process.hrtime()`]: process.html#process_process_hrtime_time
-[`child_process.spawnSync()`]: child_process.html#child_process_child_process_spawnsync_command_args_options
-[`timeOrigin`]: https://w3c.github.io/hr-time/#dom-performance-timeorigin
-[`window.performance`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/performance
-[Async Hooks]: async_hooks.html
+[Async Hooks]: async_hooks.md
 [High Resolution Time]: https://www.w3.org/TR/hr-time-2
 [Performance Timeline]: https://w3c.github.io/performance-timeline/
-[Web Performance APIs]: https://w3c.github.io/perf-timing-primer/
 [User Timing]: https://www.w3.org/TR/user-timing/
+[Web Performance APIs]: https://w3c.github.io/perf-timing-primer/
 [Worker threads]: worker_threads.md#worker_threads_worker_threads
+[`'exit'`]: process.md#process_event_exit
+[`child_process.spawnSync()`]: child_process.md#child_process_child_process_spawnsync_command_args_options
+[`process.hrtime()`]: process.md#process_process_hrtime_time
+[`timeOrigin`]: https://w3c.github.io/hr-time/#dom-performance-timeorigin
+[`window.performance`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/performance
diff --git a/doc/api/policy.html b/doc/api/policy.html
index 549f3c5f450fe4104cf2ac254361d086e37a4f55..3c84cb6e6f19ef2be204e5978a78ef40d23f83a5 100644
--- a/doc/api/policy.html
+++ b/doc/api/policy.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Policies | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Policies | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="policy" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/policy.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/policy.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/policy.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/policy.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/policy.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/policy.html">13.x</a></li>
@@ -109,15 +124,13 @@
 <li><a href="https://nodejs.org/docs/latest-v11.x/api/policy.html">11.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/policy.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/policy.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_1"><a href="#policy_policies">Policies</a></span>
 <ul>
 <li><a href="#policy_enabling">Enabling</a></li>
@@ -130,15 +143,22 @@
 <li><a href="#policy_example_patched_dependency">Example: Patched dependency</a></li>
 </ul>
 </li>
+<li><a href="#policy_scopes">Scopes</a>
+<ul>
+<li><a href="#policy_example">Example</a></li>
+<li><a href="#policy_integrity_using_scopes">Integrity using scopes</a></li>
+<li><a href="#policy_dependency_redirection_using_scopes">Dependency redirection using scopes</a></li>
+<li><a href="#policy_example_import_maps_emulation">Example: [import maps][] emulation</a></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
-      </div>
+</li>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Policies<span><a class="mark" href="#policy_policies" id="policy_policies">#</a></span></h1>
+        <h2>Policies<span><a class="mark" href="#policy_policies" id="policy_policies">#</a></span></h2>
 
 
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
@@ -149,12 +169,12 @@ about what code Node.js is able to load. The use of policies assumes
 safe practices for the policy files such as ensuring that policy
 files cannot be overwritten by the Node.js application by using
 file permissions.</p>
-<p>A best practice would be to ensure that the policy manifest is read only for
-the running Node.js application, and that the file cannot be changed
+<p>A best practice would be to ensure that the policy manifest is read-only for
+the running Node.js application and that the file cannot be changed
 by the running Node.js application in any way. A typical setup would be to
 create the policy file as a different user id than the one running Node.js
 and granting read permissions to the user id running Node.js.</p>
-<h2>Enabling<span><a class="mark" href="#policy_enabling" id="policy_enabling">#</a></span></h2>
+<section><h3>Enabling<span><a class="mark" href="#policy_enabling" id="policy_enabling">#</a></span></h3>
 
 <p>The <code>--experimental-policy</code> flag can be used to enable features for policies
 when loading modules.</p>
@@ -168,8 +188,8 @@ the policy file itself may be provided via <code>--policy-integrity</code>.
 This allows running <code>node</code> and asserting the policy file contents
 even if the file is changed on disk.</p>
 <pre><code class="language-bash">node --experimental-policy=policy.json --policy-integrity=<span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span> app.js</code></pre>
-<h2>Features<span><a class="mark" href="#policy_features" id="policy_features">#</a></span></h2>
-<h3>Error behavior<span><a class="mark" href="#policy_error_behavior" id="policy_error_behavior">#</a></span></h3>
+</section><section><h3>Features<span><a class="mark" href="#policy_features" id="policy_features">#</a></span></h3>
+<h4>Error behavior<span><a class="mark" href="#policy_error_behavior" id="policy_error_behavior">#</a></span></h4>
 <p>When a policy check fails, Node.js by default will throw an error.
 It is possible to change the error behavior to one of a few possibilities
 by defining an "onerror" field in a policy manifest. The following values are
@@ -181,101 +201,329 @@ No cleanup code will be allowed to run.</li>
 <li><code>"throw"</code>: will throw a JS error at the site of the failure. This is the
 default.</li>
 </ul>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"onerror"</span>: <span class="hljs-string">"log"</span>,
-  <span class="hljs-attr">"resources"</span>: {
-    <span class="hljs-attr">"./app/checked.js"</span>: {
-      <span class="hljs-attr">"integrity"</span>: <span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span>
-    }
-  }
-}</code></pre>
-<h3>Integrity checks<span><a class="mark" href="#policy_integrity_checks" id="policy_integrity_checks">#</a></span></h3>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"onerror"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"log"</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/checked.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h4>Integrity checks<span><a class="mark" href="#policy_integrity_checks" id="policy_integrity_checks">#</a></span></h4>
 <p>Policy files must use integrity checks with Subresource Integrity strings
 compatible with the browser
 <a href="https://www.w3.org/TR/SRI/#the-integrity-attribute">integrity attribute</a>
 associated with absolute URLs.</p>
-<p>When using <code>require()</code> all resources involved in loading are checked for
-integrity if a policy manifest has been specified. If a resource does not match
-the integrity listed in the manifest, an error will be thrown.</p>
+<p>When using <code>require()</code> or <code>import</code> all resources involved in loading are checked
+for integrity if a policy manifest has been specified. If a resource does not
+match the integrity listed in the manifest, an error will be thrown.</p>
 <p>An example policy file that would allow loading a file <code>checked.js</code>:</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"resources"</span>: {
-    <span class="hljs-attr">"./app/checked.js"</span>: {
-      <span class="hljs-attr">"integrity"</span>: <span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span>
-    }
-  }
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/checked.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>Each resource listed in the policy manifest can be of one the following
 formats to determine its location:</p>
 <ol>
-<li>A <a href="https://url.spec.whatwg.org/#relative-url-with-fragment-string">relative url string</a> to a resource from the manifest such as <code>./resource.js</code>, <code>../resource.js</code>, or <code>/resource.js</code>.</li>
-<li>A complete url string to a resource such as <code>file:///resource.js</code>.</li>
+<li>A <a href="https://url.spec.whatwg.org/#relative-url-with-fragment-string">relative-URL string</a> to a resource from the manifest such as <code>./resource.js</code>, <code>../resource.js</code>, or <code>/resource.js</code>.</li>
+<li>A complete URL string to a resource such as <code>file:///resource.js</code>.</li>
 </ol>
 <p>When loading resources the entire URL must match including search parameters
 and hash fragment. <code>./a.js?b</code> will not be used when attempting to load
 <code>./a.js</code> and vice versa.</p>
 <p>To generate integrity strings, a script such as
-<code>printf "sha384-$(cat checked.js | openssl dgst -sha384 -binary | base64)"</code>
+<code>node -e 'process.stdout.write("sha256-");process.stdin.pipe(crypto.createHash("sha256").setEncoding("base64")).pipe(process.stdout)' &#x3C; FILE</code>
 can be used.</p>
 <p>Integrity can be specified as the boolean value <code>true</code> to accept any
 body for the resource which can be useful for local development. It is not
 recommended in production since it would allow unexpected alteration of
 resources to be considered valid.</p>
-<h3>Dependency redirection<span><a class="mark" href="#policy_dependency_redirection" id="policy_dependency_redirection">#</a></span></h3>
+<h4>Dependency redirection<span><a class="mark" href="#policy_dependency_redirection" id="policy_dependency_redirection">#</a></span></h4>
 <p>An application may need to ship patched versions of modules or to prevent
 modules from allowing all modules access to all other modules. Redirection
 can be used by intercepting attempts to load the modules wishing to be
 replaced.</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"builtins"</span>: [],
-  <span class="hljs-attr">"resources"</span>: {
-    <span class="hljs-attr">"./app/checked.js"</span>: {
-      <span class="hljs-attr">"dependencies"</span>: {
-        <span class="hljs-attr">"fs"</span>: <span class="hljs-literal">true</span>,
-        <span class="hljs-attr">"os"</span>: <span class="hljs-string">"./app/node_modules/alt-os"</span>
-      }
-    }
-  }
-}</code></pre>
-<p>The dependencies are keyed by the requested string specifier and have values
-of either <code>true</code> or a string pointing to a module that will be resolved.</p>
-<p>The specifier string does not perform any searching and must match exactly
-what is provided to the <code>require()</code>. Therefore, multiple specifiers may be
-needed in the policy if <code>require()</code> uses multiple different strings to point
-to the same module (such as excluding the extension).</p>
-<p>If the value of the redirection is <code>true</code> the default searching algorithms will
-be used to find the module.</p>
-<p>If the value of the redirection is a string, it will be resolved relative to
-the manifest and then immediately be used without searching.</p>
-<p>Any specifier string that is <code>require()</code>ed and not listed in the dependencies
-will result in an error according to the policy.</p>
-<p>Redirection will not prevent access to APIs through means such as direct access
-to <code>require.cache</code> and/or through <code>module.constructor</code> which allow access to
-loading modules. Policy redirection only affect specifiers to <code>require()</code>.
-Other means such as to prevent undesired access to APIs through variables are
-necessary to lock down that path of loading modules.</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/checked.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"fs"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"os"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/alt-os"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"http"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span> <span class="hljs-attr">"import"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span> <span class="hljs-punctuation">}</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>The dependencies are keyed by the requested specifier string and have values
+of either <code>true</code>, <code>null</code>, a string pointing to a module to be resolved,
+or a conditions object.</p>
+<p>The specifier string does not perform any searching and must match exactly what
+is provided to the <code>require()</code> or <code>import</code> except for a canonicalization step.
+Therefore, multiple specifiers may be needed in the policy if it uses multiple
+different strings to point to the same module (such as excluding the extension).</p>
+<p>Specifier strings are canonicalized but not resolved prior to be used for
+matching in order to have some compatibility with import maps, for example if a
+resource <code>file:///C:/app/server.js</code> was given the following redirection from a
+policy located at <code>file:///C:/app/policy.json</code>:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"file:///C:/app/utils.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"./utils.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./utils-v2.js"</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>Any specifier used to load <code>file:///C:/app/utils.js</code> would then be intercepted
+and redirected to <code>file:///C:/app/utils-v2.js</code> instead regardless of using an
+absolute or relative specifier. However, if a specifier that is not an absolute
+or relative URL string is used, it would not be intercepted. So, if an import
+such as <code>import('#utils')</code> was used, it would not be intercepted.</p>
+<p>If the value of the redirection is <code>true</code>, a "dependencies" field at the top of
+the policy file will be used. If that field at the top of the policy file is
+<code>true</code> the default node searching algorithms are used to find the module.</p>
+<p>If the value of the redirection is a string, it is resolved relative to
+the manifest and then immediately used without searching.</p>
+<p>Any specifier string for which resolution is attempted and that is not listed in
+the dependencies results in an error according to the policy.</p>
+<p>Redirection does not prevent access to APIs through means such as direct access
+to <code>require.cache</code> or through <code>module.constructor</code> which allow access to
+loading modules. Policy redirection only affects specifiers to <code>require()</code> and
+<code>import</code>. Other means, such as to prevent undesired access to APIs through
+variables, are necessary to lock down that path of loading modules.</p>
 <p>A boolean value of <code>true</code> for the dependencies map can be specified to allow a
 module to load any specifier without redirection. This can be useful for local
 development and may have some valid usage in production, but should be used
 only with care after auditing a module to ensure its behavior is valid.</p>
-<h4>Example: Patched dependency<span><a class="mark" href="#policy_example_patched_dependency" id="policy_example_patched_dependency">#</a></span></h4>
+<p>Similar to <code>"exports"</code> in <code>package.json</code>, dependencies can also be specified to
+be objects containing conditions which branch how dependencies are loaded. In
+the preceding example, <code>"http"</code> is allowed when the <code>"import"</code> condition is
+part of loading it.</p>
+<p>A value of <code>null</code> for the resolved value causes the resolution to fail. This
+can be used to ensure some kinds of dynamic access are explicitly prevented.</p>
+<p>Unknown values for the resolved module location cause failures but are
+not guaranteed to be forward compatible.</p>
+<h5>Example: Patched dependency<span><a class="mark" href="#policy_example_patched_dependency" id="policy_example_patched_dependency">#</a></span></h5>
 <p>Redirected dependencies can provide attenuated or modified functionality as fits
 the application. For example, log data about timing of function durations by
 wrapping the original:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> original = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fn'</span>);
-<span class="hljs-built_in">module</span>.exports = <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">fn</span>(<span class="hljs-params">...args</span>) </span>{
-  <span class="hljs-built_in">console</span>.time();
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-keyword">function</span> <span class="hljs-title function_">fn</span>(<span class="hljs-params">...args</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">time</span>();
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span>.target ?
-      <span class="hljs-built_in">Reflect</span>.construct(original, args) :
-      <span class="hljs-built_in">Reflect</span>.apply(original, <span class="hljs-built_in">this</span>, args);
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span>.<span class="hljs-property">target</span> ?
+      <span class="hljs-title class_">Reflect</span>.<span class="hljs-title function_">construct</span>(original, args) :
+      <span class="hljs-title class_">Reflect</span>.<span class="hljs-title function_">apply</span>(original, <span class="hljs-variable language_">this</span>, args);
   } <span class="hljs-keyword">finally</span> {
-    <span class="hljs-built_in">console</span>.timeEnd();
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">timeEnd</span>();
   }
 };</code></pre>
+<h4>Scopes<span><a class="mark" href="#policy_scopes" id="policy_scopes">#</a></span></h4>
+<p>Use the <code>"scopes"</code> field of a manifest to set configuration for many resources
+at once. The <code>"scopes"</code> field works by matching resources by their segments.
+If a scope or resource includes <code>"cascade": true</code>, unknown specifiers will
+be searched for in their containing scope. The containing scope for cascading
+is found by recursively reducing the resource URL by removing segments for
+<a href="https://url.spec.whatwg.org/#special-scheme">special schemes</a>, keeping trailing <code>"/"</code> suffixes, and removing the query and
+hash fragment. This leads to the eventual reduction of the URL to its origin.
+If the URL is non-special the scope will be located by the URL's origin. If no
+scope is found for the origin or in the case of opaque origins, a protocol
+string can be used as a scope. If no scope is found for the URL's protocol, a
+final empty string <code>""</code> scope will be used.</p>
+<p>Note, <code>blob:</code> URLs adopt their origin from the path they contain, and so a scope
+of <code>"blob:https://nodejs.org"</code> will have no effect since no URL can have an
+origin of <code>blob:https://nodejs.org</code>; URLs starting with
+<code>blob:https://nodejs.org/</code> will use <code>https://nodejs.org</code> for its origin and
+thus <code>https:</code> for its protocol scope. For opaque origin <code>blob:</code> URLs they will
+have <code>blob:</code> for their protocol scope since they do not adopt origins.</p>
+<h5>Example<span><a class="mark" href="#policy_example" id="policy_example">#</a></span></h5>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"file:///C:/app/"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span><span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"file:"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span><span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">""</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span><span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>Given a file located at <code>file:///C:/app/bin/main.js</code>, the following scopes would
+be checked in order:</p>
+<ol>
+<li><code>"file:///C:/app/bin/"</code></li>
+</ol>
+<p>This determines the policy for all file based resources within
+<code>"file:///C:/app/bin/"</code>. This is not in the <code>"scopes"</code> field of the policy and
+would be skipped. Adding this scope to the policy would cause it to be used
+prior to the <code>"file:///C:/app/"</code> scope.</p>
+<ol start="2">
+<li><code>"file:///C:/app/"</code></li>
+</ol>
+<p>This determines the policy for all file based resources within
+<code>"file:///C:/app/"</code>. This is in the <code>"scopes"</code> field of the policy and it would
+determine the policy for the resource at <code>file:///C:/app/bin/main.js</code>. If the
+scope has <code>"cascade": true</code>, any unsatisfied queries about the resource would
+delegate to the next relevant scope for <code>file:///C:/app/bin/main.js</code>, <code>"file:"</code>.</p>
+<ol start="3">
+<li><code>"file:///C:/"</code></li>
+</ol>
+<p>This determines the policy for all file based resources within <code>"file:///C:/"</code>.
+This is not in the <code>"scopes"</code> field of the policy and would be skipped. It would
+not be used for <code>file:///C:/app/bin/main.js</code> unless <code>"file:///"</code> is set to
+cascade or is not in the <code>"scopes"</code> of the policy.</p>
+<ol start="4">
+<li><code>"file:///"</code></li>
+</ol>
+<p>This determines the policy for all file based resources on the <code>localhost</code>. This
+is not in the <code>"scopes"</code> field of the policy and would be skipped. It would not
+be used for <code>file:///C:/app/bin/main.js</code> unless <code>"file:///"</code> is set to cascade
+or is not in the <code>"scopes"</code> of the policy.</p>
+<ol start="5">
+<li><code>"file:"</code></li>
+</ol>
+<p>This determines the policy for all file based resources. It would not be used
+for <code>file:///C:/app/bin/main.js</code> unless <code>"file:///"</code> is set to cascade or is not
+in the <code>"scopes"</code> of the policy.</p>
+<ol start="6">
+<li><code>""</code></li>
+</ol>
+<p>This determines the policy for all resources. It would not be used for
+<code>file:///C:/app/bin/main.js</code> unless <code>"file:"</code> is set to cascade.</p>
+<h5>Integrity using scopes<span><a class="mark" href="#policy_integrity_using_scopes" id="policy_integrity_using_scopes">#</a></span></h5>
+<p>Setting an integrity to <code>true</code> on a scope will set the integrity for any
+resource not found in the manifest to <code>true</code>.</p>
+<p>Setting an integrity to <code>null</code> on a scope will set the integrity for any
+resource not found in the manifest to fail matching.</p>
+<p>Not including an integrity is the same as setting the integrity to <code>null</code>.</p>
+<p><code>"cascade"</code> for integrity checks will be ignored if <code>"integrity"</code> is explicitly
+set.</p>
+<p>The following example allows loading any file:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"file:"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h5>Dependency redirection using scopes<span><a class="mark" href="#policy_dependency_redirection_using_scopes" id="policy_dependency_redirection_using_scopes">#</a></span></h5>
+<p>The following example, would allow access to <code>fs</code> for all resources within
+<code>./app/</code>:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/checked.js"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"cascade"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./app/"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"fs"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>The following example, would allow access to <code>fs</code> for all <code>data:</code> resources:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"resources"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"data:text/javascript,import('fs');"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"cascade"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"integrity"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"data:"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"fs"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<h5>Example: <a href="https://url.spec.whatwg.org/#relative-url-with-fragment-string">import maps</a> emulation<span><a class="mark" href="#policy_example_import_maps_emulation" id="policy_example_import_maps_emulation">#</a></span></h5>
+<p>Given an import map:</p>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"imports"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"react"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/react/index.js"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"./ssr/"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"react"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/server-side-react/index.js"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"scopes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">""</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"cascade"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"react"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/react/index.js"</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"./ssr/"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"cascade"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"react"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./app/node_modules/server-side-react/index.js"</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<p>Import maps assume you can get any resource by default. This means
+<code>"dependencies"</code> at the top level of the policy should be set to <code>true</code>.
+Policies require this to be opt-in since it enables all resources of the
+application cross linkage which doesn't make sense for many scenarios. They also
+assume any given scope has access to any scope above its allowed dependencies;
+all scopes emulating import maps must set <code>"cascade": true</code>.</p>
+<p>Import maps only have a single top level scope for their "imports". So for
+emulating <code>"imports"</code> use the <code>""</code> scope. For emulating <code>"scopes"</code> use the
+<code>"scopes"</code> in a similar manner to how <code>"scopes"</code> works in import maps.</p>
+<p>Caveats: Policies do not use string matching for various finding of scope. They
+do URL traversals. This means things like <code>blob:</code> and <code>data:</code> URLs might not be
+entirely interoperable between the two systems. For example import maps can
+partially match a <code>data:</code> or <code>blob:</code> URL by partitioning the URL on a <code>/</code>
+character, policies intentionally cannot. For <code>blob:</code> URLs import map scopes do
+not adopt the origin of the <code>blob:</code> URL.</p>
+<p>Additionally, import maps only work on <code>import</code> so it may be desirable to add a
+<code>"import"</code> condition to all dependency mappings.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/policy.json b/doc/api/policy.json
index 6cf2bdfa0fd4e2d0e4c84adb99bf2d8311ad6507..58115377293b624f334e766c9191c5839fb02438 100644
--- a/doc/api/policy.json
+++ b/doc/api/policy.json
@@ -12,7 +12,7 @@
       "type": "misc",
       "stability": 1,
       "stabilityText": "Experimental",
-      "desc": "<p>Node.js contains experimental support for creating policies on loading code.</p>\n<p>Policies are a security feature intended to allow guarantees\nabout what code Node.js is able to load. The use of policies assumes\nsafe practices for the policy files such as ensuring that policy\nfiles cannot be overwritten by the Node.js application by using\nfile permissions.</p>\n<p>A best practice would be to ensure that the policy manifest is read only for\nthe running Node.js application, and that the file cannot be changed\nby the running Node.js application in any way. A typical setup would be to\ncreate the policy file as a different user id than the one running Node.js\nand granting read permissions to the user id running Node.js.</p>",
+      "desc": "<p>Node.js contains experimental support for creating policies on loading code.</p>\n<p>Policies are a security feature intended to allow guarantees\nabout what code Node.js is able to load. The use of policies assumes\nsafe practices for the policy files such as ensuring that policy\nfiles cannot be overwritten by the Node.js application by using\nfile permissions.</p>\n<p>A best practice would be to ensure that the policy manifest is read-only for\nthe running Node.js application and that the file cannot be changed\nby the running Node.js application in any way. A typical setup would be to\ncreate the policy file as a different user id than the one running Node.js\nand granting read permissions to the user id running Node.js.</p>",
       "miscs": [
         {
           "textRaw": "Enabling",
@@ -34,16 +34,39 @@
             {
               "textRaw": "Integrity checks",
               "name": "integrity_checks",
-              "desc": "<p>Policy files must use integrity checks with Subresource Integrity strings\ncompatible with the browser\n<a href=\"https://www.w3.org/TR/SRI/#the-integrity-attribute\">integrity attribute</a>\nassociated with absolute URLs.</p>\n<p>When using <code>require()</code> all resources involved in loading are checked for\nintegrity if a policy manifest has been specified. If a resource does not match\nthe integrity listed in the manifest, an error will be thrown.</p>\n<p>An example policy file that would allow loading a file <code>checked.js</code>:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"integrity\": \"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0\"\n    }\n  }\n}\n</code></pre>\n<p>Each resource listed in the policy manifest can be of one the following\nformats to determine its location:</p>\n<ol>\n<li>A <a href=\"https://url.spec.whatwg.org/#relative-url-with-fragment-string\">relative url string</a> to a resource from the manifest such as <code>./resource.js</code>, <code>../resource.js</code>, or <code>/resource.js</code>.</li>\n<li>A complete url string to a resource such as <code>file:///resource.js</code>.</li>\n</ol>\n<p>When loading resources the entire URL must match including search parameters\nand hash fragment. <code>./a.js?b</code> will not be used when attempting to load\n<code>./a.js</code> and vice versa.</p>\n<p>To generate integrity strings, a script such as\n<code>printf \"sha384-$(cat checked.js | openssl dgst -sha384 -binary | base64)\"</code>\ncan be used.</p>\n<p>Integrity can be specified as the boolean value <code>true</code> to accept any\nbody for the resource which can be useful for local development. It is not\nrecommended in production since it would allow unexpected alteration of\nresources to be considered valid.</p>",
+              "desc": "<p>Policy files must use integrity checks with Subresource Integrity strings\ncompatible with the browser\n<a href=\"https://www.w3.org/TR/SRI/#the-integrity-attribute\">integrity attribute</a>\nassociated with absolute URLs.</p>\n<p>When using <code>require()</code> or <code>import</code> all resources involved in loading are checked\nfor integrity if a policy manifest has been specified. If a resource does not\nmatch the integrity listed in the manifest, an error will be thrown.</p>\n<p>An example policy file that would allow loading a file <code>checked.js</code>:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"integrity\": \"sha384-SggXRQHwCG8g+DktYYzxkXRIkTiEYWBHqev0xnpCxYlqMBufKZHAHQM3/boDaI/0\"\n    }\n  }\n}\n</code></pre>\n<p>Each resource listed in the policy manifest can be of one the following\nformats to determine its location:</p>\n<ol>\n<li>A <a href=\"https://url.spec.whatwg.org/#relative-url-with-fragment-string\">relative-URL string</a> to a resource from the manifest such as <code>./resource.js</code>, <code>../resource.js</code>, or <code>/resource.js</code>.</li>\n<li>A complete URL string to a resource such as <code>file:///resource.js</code>.</li>\n</ol>\n<p>When loading resources the entire URL must match including search parameters\nand hash fragment. <code>./a.js?b</code> will not be used when attempting to load\n<code>./a.js</code> and vice versa.</p>\n<p>To generate integrity strings, a script such as\n<code>node -e 'process.stdout.write(\"sha256-\");process.stdin.pipe(crypto.createHash(\"sha256\").setEncoding(\"base64\")).pipe(process.stdout)' &#x3C; FILE</code>\ncan be used.</p>\n<p>Integrity can be specified as the boolean value <code>true</code> to accept any\nbody for the resource which can be useful for local development. It is not\nrecommended in production since it would allow unexpected alteration of\nresources to be considered valid.</p>",
               "type": "module",
               "displayName": "Integrity checks"
             },
             {
               "textRaw": "Dependency redirection",
               "name": "dependency_redirection",
-              "desc": "<p>An application may need to ship patched versions of modules or to prevent\nmodules from allowing all modules access to all other modules. Redirection\ncan be used by intercepting attempts to load the modules wishing to be\nreplaced.</p>\n<pre><code class=\"language-json\">{\n  \"builtins\": [],\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"dependencies\": {\n        \"fs\": true,\n        \"os\": \"./app/node_modules/alt-os\"\n      }\n    }\n  }\n}\n</code></pre>\n<p>The dependencies are keyed by the requested string specifier and have values\nof either <code>true</code> or a string pointing to a module that will be resolved.</p>\n<p>The specifier string does not perform any searching and must match exactly\nwhat is provided to the <code>require()</code>. Therefore, multiple specifiers may be\nneeded in the policy if <code>require()</code> uses multiple different strings to point\nto the same module (such as excluding the extension).</p>\n<p>If the value of the redirection is <code>true</code> the default searching algorithms will\nbe used to find the module.</p>\n<p>If the value of the redirection is a string, it will be resolved relative to\nthe manifest and then immediately be used without searching.</p>\n<p>Any specifier string that is <code>require()</code>ed and not listed in the dependencies\nwill result in an error according to the policy.</p>\n<p>Redirection will not prevent access to APIs through means such as direct access\nto <code>require.cache</code> and/or through <code>module.constructor</code> which allow access to\nloading modules. Policy redirection only affect specifiers to <code>require()</code>.\nOther means such as to prevent undesired access to APIs through variables are\nnecessary to lock down that path of loading modules.</p>\n<p>A boolean value of <code>true</code> for the dependencies map can be specified to allow a\nmodule to load any specifier without redirection. This can be useful for local\ndevelopment and may have some valid usage in production, but should be used\nonly with care after auditing a module to ensure its behavior is valid.</p>\n<h4>Example: Patched dependency</h4>\n<p>Redirected dependencies can provide attenuated or modified functionality as fits\nthe application. For example, log data about timing of function durations by\nwrapping the original:</p>\n<pre><code class=\"language-js\">const original = require('fn');\nmodule.exports = function fn(...args) {\n  console.time();\n  try {\n    return new.target ?\n      Reflect.construct(original, args) :\n      Reflect.apply(original, this, args);\n  } finally {\n    console.timeEnd();\n  }\n};\n</code></pre>",
+              "desc": "<p>An application may need to ship patched versions of modules or to prevent\nmodules from allowing all modules access to all other modules. Redirection\ncan be used by intercepting attempts to load the modules wishing to be\nreplaced.</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"dependencies\": {\n        \"fs\": true,\n        \"os\": \"./app/node_modules/alt-os\",\n        \"http\": { \"import\": true }\n      }\n    }\n  }\n}\n</code></pre>\n<p>The dependencies are keyed by the requested specifier string and have values\nof either <code>true</code>, <code>null</code>, a string pointing to a module to be resolved,\nor a conditions object.</p>\n<p>The specifier string does not perform any searching and must match exactly what\nis provided to the <code>require()</code> or <code>import</code> except for a canonicalization step.\nTherefore, multiple specifiers may be needed in the policy if it uses multiple\ndifferent strings to point to the same module (such as excluding the extension).</p>\n<p>Specifier strings are canonicalized but not resolved prior to be used for\nmatching in order to have some compatibility with import maps, for example if a\nresource <code>file:///C:/app/server.js</code> was given the following redirection from a\npolicy located at <code>file:///C:/app/policy.json</code>:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"file:///C:/app/utils.js\": {\n      \"dependencies\": {\n        \"./utils.js\": \"./utils-v2.js\"\n      }\n    }\n  }\n}\n</code></pre>\n<p>Any specifier used to load <code>file:///C:/app/utils.js</code> would then be intercepted\nand redirected to <code>file:///C:/app/utils-v2.js</code> instead regardless of using an\nabsolute or relative specifier. However, if a specifier that is not an absolute\nor relative URL string is used, it would not be intercepted. So, if an import\nsuch as <code>import('#utils')</code> was used, it would not be intercepted.</p>\n<p>If the value of the redirection is <code>true</code>, a \"dependencies\" field at the top of\nthe policy file will be used. If that field at the top of the policy file is\n<code>true</code> the default node searching algorithms are used to find the module.</p>\n<p>If the value of the redirection is a string, it is resolved relative to\nthe manifest and then immediately used without searching.</p>\n<p>Any specifier string for which resolution is attempted and that is not listed in\nthe dependencies results in an error according to the policy.</p>\n<p>Redirection does not prevent access to APIs through means such as direct access\nto <code>require.cache</code> or through <code>module.constructor</code> which allow access to\nloading modules. Policy redirection only affects specifiers to <code>require()</code> and\n<code>import</code>. Other means, such as to prevent undesired access to APIs through\nvariables, are necessary to lock down that path of loading modules.</p>\n<p>A boolean value of <code>true</code> for the dependencies map can be specified to allow a\nmodule to load any specifier without redirection. This can be useful for local\ndevelopment and may have some valid usage in production, but should be used\nonly with care after auditing a module to ensure its behavior is valid.</p>\n<p>Similar to <code>\"exports\"</code> in <code>package.json</code>, dependencies can also be specified to\nbe objects containing conditions which branch how dependencies are loaded. In\nthe preceding example, <code>\"http\"</code> is allowed when the <code>\"import\"</code> condition is\npart of loading it.</p>\n<p>A value of <code>null</code> for the resolved value causes the resolution to fail. This\ncan be used to ensure some kinds of dynamic access are explicitly prevented.</p>\n<p>Unknown values for the resolved module location cause failures but are\nnot guaranteed to be forward compatible.</p>\n<h4>Example: Patched dependency</h4>\n<p>Redirected dependencies can provide attenuated or modified functionality as fits\nthe application. For example, log data about timing of function durations by\nwrapping the original:</p>\n<pre><code class=\"language-js\">const original = require('fn');\nmodule.exports = function fn(...args) {\n  console.time();\n  try {\n    return new.target ?\n      Reflect.construct(original, args) :\n      Reflect.apply(original, this, args);\n  } finally {\n    console.timeEnd();\n  }\n};\n</code></pre>",
               "type": "module",
               "displayName": "Dependency redirection"
+            },
+            {
+              "textRaw": "Scopes",
+              "name": "scopes",
+              "desc": "<p>Use the <code>\"scopes\"</code> field of a manifest to set configuration for many resources\nat once. The <code>\"scopes\"</code> field works by matching resources by their segments.\nIf a scope or resource includes <code>\"cascade\": true</code>, unknown specifiers will\nbe searched for in their containing scope. The containing scope for cascading\nis found by recursively reducing the resource URL by removing segments for\n<a href=\"https://url.spec.whatwg.org/#special-scheme\">special schemes</a>, keeping trailing <code>\"/\"</code> suffixes, and removing the query and\nhash fragment. This leads to the eventual reduction of the URL to its origin.\nIf the URL is non-special the scope will be located by the URL's origin. If no\nscope is found for the origin or in the case of opaque origins, a protocol\nstring can be used as a scope. If no scope is found for the URL's protocol, a\nfinal empty string <code>\"\"</code> scope will be used.</p>\n<p>Note, <code>blob:</code> URLs adopt their origin from the path they contain, and so a scope\nof <code>\"blob:https://nodejs.org\"</code> will have no effect since no URL can have an\norigin of <code>blob:https://nodejs.org</code>; URLs starting with\n<code>blob:https://nodejs.org/</code> will use <code>https://nodejs.org</code> for its origin and\nthus <code>https:</code> for its protocol scope. For opaque origin <code>blob:</code> URLs they will\nhave <code>blob:</code> for their protocol scope since they do not adopt origins.</p>\n<h4>Example</h4>\n<pre><code class=\"language-json\">{\n  \"scopes\": {\n    \"file:///C:/app/\": {},\n    \"file:\": {},\n    \"\": {}\n  }\n}\n</code></pre>\n<p>Given a file located at <code>file:///C:/app/bin/main.js</code>, the following scopes would\nbe checked in order:</p>\n<ol>\n<li><code>\"file:///C:/app/bin/\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources within\n<code>\"file:///C:/app/bin/\"</code>. This is not in the <code>\"scopes\"</code> field of the policy and\nwould be skipped. Adding this scope to the policy would cause it to be used\nprior to the <code>\"file:///C:/app/\"</code> scope.</p>\n<ol start=\"2\">\n<li><code>\"file:///C:/app/\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources within\n<code>\"file:///C:/app/\"</code>. This is in the <code>\"scopes\"</code> field of the policy and it would\ndetermine the policy for the resource at <code>file:///C:/app/bin/main.js</code>. If the\nscope has <code>\"cascade\": true</code>, any unsatisfied queries about the resource would\ndelegate to the next relevant scope for <code>file:///C:/app/bin/main.js</code>, <code>\"file:\"</code>.</p>\n<ol start=\"3\">\n<li><code>\"file:///C:/\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources within <code>\"file:///C:/\"</code>.\nThis is not in the <code>\"scopes\"</code> field of the policy and would be skipped. It would\nnot be used for <code>file:///C:/app/bin/main.js</code> unless <code>\"file:///\"</code> is set to\ncascade or is not in the <code>\"scopes\"</code> of the policy.</p>\n<ol start=\"4\">\n<li><code>\"file:///\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources on the <code>localhost</code>. This\nis not in the <code>\"scopes\"</code> field of the policy and would be skipped. It would not\nbe used for <code>file:///C:/app/bin/main.js</code> unless <code>\"file:///\"</code> is set to cascade\nor is not in the <code>\"scopes\"</code> of the policy.</p>\n<ol start=\"5\">\n<li><code>\"file:\"</code></li>\n</ol>\n<p>This determines the policy for all file based resources. It would not be used\nfor <code>file:///C:/app/bin/main.js</code> unless <code>\"file:///\"</code> is set to cascade or is not\nin the <code>\"scopes\"</code> of the policy.</p>\n<ol start=\"6\">\n<li><code>\"\"</code></li>\n</ol>\n<p>This determines the policy for all resources. It would not be used for\n<code>file:///C:/app/bin/main.js</code> unless <code>\"file:\"</code> is set to cascade.</p>",
+              "modules": [
+                {
+                  "textRaw": "Integrity using scopes",
+                  "name": "integrity_using_scopes",
+                  "desc": "<p>Setting an integrity to <code>true</code> on a scope will set the integrity for any\nresource not found in the manifest to <code>true</code>.</p>\n<p>Setting an integrity to <code>null</code> on a scope will set the integrity for any\nresource not found in the manifest to fail matching.</p>\n<p>Not including an integrity is the same as setting the integrity to <code>null</code>.</p>\n<p><code>\"cascade\"</code> for integrity checks will be ignored if <code>\"integrity\"</code> is explicitly\nset.</p>\n<p>The following example allows loading any file:</p>\n<pre><code class=\"language-json\">{\n  \"scopes\": {\n    \"file:\": {\n      \"integrity\": true\n    }\n  }\n}\n</code></pre>",
+                  "type": "module",
+                  "displayName": "Integrity using scopes"
+                },
+                {
+                  "textRaw": "Dependency redirection using scopes",
+                  "name": "dependency_redirection_using_scopes",
+                  "desc": "<p>The following example, would allow access to <code>fs</code> for all resources within\n<code>./app/</code>:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"./app/checked.js\": {\n      \"cascade\": true,\n      \"integrity\": true\n    }\n  },\n  \"scopes\": {\n    \"./app/\": {\n      \"dependencies\": {\n        \"fs\": true\n      }\n    }\n  }\n}\n</code></pre>\n<p>The following example, would allow access to <code>fs</code> for all <code>data:</code> resources:</p>\n<pre><code class=\"language-json\">{\n  \"resources\": {\n    \"data:text/javascript,import('fs');\": {\n      \"cascade\": true,\n      \"integrity\": true\n    }\n  },\n  \"scopes\": {\n    \"data:\": {\n      \"dependencies\": {\n        \"fs\": true\n      }\n    }\n  }\n}\n</code></pre>\n<h4>Example: <a href=\"https://url.spec.whatwg.org/#relative-url-with-fragment-string\">import maps</a> emulation</h4>\n<p>Given an import map:</p>\n<pre><code class=\"language-json\">{\n  \"imports\": {\n    \"react\": \"./app/node_modules/react/index.js\"\n  },\n  \"scopes\": {\n    \"./ssr/\": {\n      \"react\": \"./app/node_modules/server-side-react/index.js\"\n    }\n  }\n}\n</code></pre>\n<pre><code class=\"language-json\">{\n  \"dependencies\": true,\n  \"scopes\": {\n    \"\": {\n      \"cascade\": true,\n      \"dependencies\": {\n        \"react\": \"./app/node_modules/react/index.js\"\n      }\n    },\n    \"./ssr/\": {\n      \"cascade\": true,\n      \"dependencies\": {\n        \"react\": \"./app/node_modules/server-side-react/index.js\"\n      }\n    }\n  }\n}\n</code></pre>\n<p>Import maps assume you can get any resource by default. This means\n<code>\"dependencies\"</code> at the top level of the policy should be set to <code>true</code>.\nPolicies require this to be opt-in since it enables all resources of the\napplication cross linkage which doesn't make sense for many scenarios. They also\nassume any given scope has access to any scope above its allowed dependencies;\nall scopes emulating import maps must set <code>\"cascade\": true</code>.</p>\n<p>Import maps only have a single top level scope for their \"imports\". So for\nemulating <code>\"imports\"</code> use the <code>\"\"</code> scope. For emulating <code>\"scopes\"</code> use the\n<code>\"scopes\"</code> in a similar manner to how <code>\"scopes\"</code> works in import maps.</p>\n<p>Caveats: Policies do not use string matching for various finding of scope. They\ndo URL traversals. This means things like <code>blob:</code> and <code>data:</code> URLs might not be\nentirely interoperable between the two systems. For example import maps can\npartially match a <code>data:</code> or <code>blob:</code> URL by partitioning the URL on a <code>/</code>\ncharacter, policies intentionally cannot. For <code>blob:</code> URLs import map scopes do\nnot adopt the origin of the <code>blob:</code> URL.</p>\n<p>Additionally, import maps only work on <code>import</code> so it may be desirable to add a\n<code>\"import\"</code> condition to all dependency mappings.</p>",
+                  "type": "module",
+                  "displayName": "Dependency redirection using scopes"
+                }
+              ],
+              "type": "module",
+              "displayName": "Scopes"
             }
           ],
           "type": "misc",
diff --git a/doc/api/policy.md b/doc/api/policy.md
index 05918500fcac212a3725030aafa2e1248861fb62..01b3eba0a330842bde7859e1ffbfb43fb83bdeb5 100644
--- a/doc/api/policy.md
+++ b/doc/api/policy.md
@@ -15,8 +15,8 @@ safe practices for the policy files such as ensuring that policy
 files cannot be overwritten by the Node.js application by using
 file permissions.
 
-A best practice would be to ensure that the policy manifest is read only for
-the running Node.js application, and that the file cannot be changed
+A best practice would be to ensure that the policy manifest is read-only for
+the running Node.js application and that the file cannot be changed
 by the running Node.js application in any way. A typical setup would be to
 create the policy file as a different user id than the one running Node.js
 and granting read permissions to the user id running Node.js.
@@ -57,7 +57,7 @@ by defining an "onerror" field in a policy manifest. The following values are
 available to change the behavior:
 
 * `"exit"`: will exit the process immediately.
-    No cleanup code will be allowed to run.
+  No cleanup code will be allowed to run.
 * `"log"`: will log the error at the site of the failure.
 * `"throw"`: will throw a JS error at the site of the failure. This is the
   default.
@@ -80,9 +80,9 @@ compatible with the browser
 [integrity attribute](https://www.w3.org/TR/SRI/#the-integrity-attribute)
 associated with absolute URLs.
 
-When using `require()` all resources involved in loading are checked for
-integrity if a policy manifest has been specified. If a resource does not match
-the integrity listed in the manifest, an error will be thrown.
+When using `require()` or `import` all resources involved in loading are checked
+for integrity if a policy manifest has been specified. If a resource does not
+match the integrity listed in the manifest, an error will be thrown.
 
 An example policy file that would allow loading a file `checked.js`:
 
@@ -99,15 +99,15 @@ An example policy file that would allow loading a file `checked.js`:
 Each resource listed in the policy manifest can be of one the following
 formats to determine its location:
 
-1. A [relative url string][] to a resource from the manifest such as `./resource.js`, `../resource.js`, or `/resource.js`.
-2. A complete url string to a resource such as `file:///resource.js`.
+1. A [relative-URL string][] to a resource from the manifest such as `./resource.js`, `../resource.js`, or `/resource.js`.
+2. A complete URL string to a resource such as `file:///resource.js`.
 
 When loading resources the entire URL must match including search parameters
 and hash fragment. `./a.js?b` will not be used when attempting to load
 `./a.js` and vice versa.
 
 To generate integrity strings, a script such as
-`printf "sha384-$(cat checked.js | openssl dgst -sha384 -binary | base64)"`
+`node -e 'process.stdout.write("sha256-");process.stdin.pipe(crypto.createHash("sha256").setEncoding("base64")).pipe(process.stdout)' < FILE`
 can be used.
 
 Integrity can be specified as the boolean value `true` to accept any
@@ -124,46 +124,82 @@ replaced.
 
 ```json
 {
-  "builtins": [],
   "resources": {
     "./app/checked.js": {
       "dependencies": {
         "fs": true,
-        "os": "./app/node_modules/alt-os"
+        "os": "./app/node_modules/alt-os",
+        "http": { "import": true }
       }
     }
   }
 }
 ```
 
-The dependencies are keyed by the requested string specifier and have values
-of either `true` or a string pointing to a module that will be resolved.
+The dependencies are keyed by the requested specifier string and have values
+of either `true`, `null`, a string pointing to a module to be resolved,
+or a conditions object.
 
-The specifier string does not perform any searching and must match exactly
-what is provided to the `require()`. Therefore, multiple specifiers may be
-needed in the policy if `require()` uses multiple different strings to point
-to the same module (such as excluding the extension).
+The specifier string does not perform any searching and must match exactly what
+is provided to the `require()` or `import` except for a canonicalization step.
+Therefore, multiple specifiers may be needed in the policy if it uses multiple
+different strings to point to the same module (such as excluding the extension).
 
-If the value of the redirection is `true` the default searching algorithms will
-be used to find the module.
+Specifier strings are canonicalized but not resolved prior to be used for
+matching in order to have some compatibility with import maps, for example if a
+resource `file:///C:/app/server.js` was given the following redirection from a
+policy located at `file:///C:/app/policy.json`:
 
-If the value of the redirection is a string, it will be resolved relative to
-the manifest and then immediately be used without searching.
+```json
+{
+  "resources": {
+    "file:///C:/app/utils.js": {
+      "dependencies": {
+        "./utils.js": "./utils-v2.js"
+      }
+    }
+  }
+}
+```
+
+Any specifier used to load `file:///C:/app/utils.js` would then be intercepted
+and redirected to `file:///C:/app/utils-v2.js` instead regardless of using an
+absolute or relative specifier. However, if a specifier that is not an absolute
+or relative URL string is used, it would not be intercepted. So, if an import
+such as `import('#utils')` was used, it would not be intercepted.
+
+If the value of the redirection is `true`, a "dependencies" field at the top of
+the policy file will be used. If that field at the top of the policy file is
+`true` the default node searching algorithms are used to find the module.
+
+If the value of the redirection is a string, it is resolved relative to
+the manifest and then immediately used without searching.
 
-Any specifier string that is `require()`ed and not listed in the dependencies
-will result in an error according to the policy.
+Any specifier string for which resolution is attempted and that is not listed in
+the dependencies results in an error according to the policy.
 
-Redirection will not prevent access to APIs through means such as direct access
-to `require.cache` and/or through `module.constructor` which allow access to
-loading modules. Policy redirection only affect specifiers to `require()`.
-Other means such as to prevent undesired access to APIs through variables are
-necessary to lock down that path of loading modules.
+Redirection does not prevent access to APIs through means such as direct access
+to `require.cache` or through `module.constructor` which allow access to
+loading modules. Policy redirection only affects specifiers to `require()` and
+`import`. Other means, such as to prevent undesired access to APIs through
+variables, are necessary to lock down that path of loading modules.
 
 A boolean value of `true` for the dependencies map can be specified to allow a
 module to load any specifier without redirection. This can be useful for local
 development and may have some valid usage in production, but should be used
 only with care after auditing a module to ensure its behavior is valid.
 
+Similar to `"exports"` in `package.json`, dependencies can also be specified to
+be objects containing conditions which branch how dependencies are loaded. In
+the preceding example, `"http"` is allowed when the `"import"` condition is
+part of loading it.
+
+A value of `null` for the resolved value causes the resolution to fail. This
+can be used to ensure some kinds of dynamic access are explicitly prevented.
+
+Unknown values for the resolved module location cause failures but are
+not guaranteed to be forward compatible.
+
 #### Example: Patched dependency
 
 Redirected dependencies can provide attenuated or modified functionality as fits
@@ -184,4 +220,208 @@ module.exports = function fn(...args) {
 };
 ```
 
-[relative url string]: https://url.spec.whatwg.org/#relative-url-with-fragment-string
+### Scopes
+
+Use the `"scopes"` field of a manifest to set configuration for many resources
+at once. The `"scopes"` field works by matching resources by their segments.
+If a scope or resource includes `"cascade": true`, unknown specifiers will
+be searched for in their containing scope. The containing scope for cascading
+is found by recursively reducing the resource URL by removing segments for
+[special schemes][], keeping trailing `"/"` suffixes, and removing the query and
+hash fragment. This leads to the eventual reduction of the URL to its origin.
+If the URL is non-special the scope will be located by the URL's origin. If no
+scope is found for the origin or in the case of opaque origins, a protocol
+string can be used as a scope. If no scope is found for the URL's protocol, a
+final empty string `""` scope will be used.
+
+Note, `blob:` URLs adopt their origin from the path they contain, and so a scope
+of `"blob:https://nodejs.org"` will have no effect since no URL can have an
+origin of `blob:https://nodejs.org`; URLs starting with
+`blob:https://nodejs.org/` will use `https://nodejs.org` for its origin and
+thus `https:` for its protocol scope. For opaque origin `blob:` URLs they will
+have `blob:` for their protocol scope since they do not adopt origins.
+
+#### Example
+
+```json
+{
+  "scopes": {
+    "file:///C:/app/": {},
+    "file:": {},
+    "": {}
+  }
+}
+```
+
+Given a file located at `file:///C:/app/bin/main.js`, the following scopes would
+be checked in order:
+
+1. `"file:///C:/app/bin/"`
+
+This determines the policy for all file based resources within
+`"file:///C:/app/bin/"`. This is not in the `"scopes"` field of the policy and
+would be skipped. Adding this scope to the policy would cause it to be used
+prior to the `"file:///C:/app/"` scope.
+
+2. `"file:///C:/app/"`
+
+This determines the policy for all file based resources within
+`"file:///C:/app/"`. This is in the `"scopes"` field of the policy and it would
+determine the policy for the resource at `file:///C:/app/bin/main.js`. If the
+scope has `"cascade": true`, any unsatisfied queries about the resource would
+delegate to the next relevant scope for `file:///C:/app/bin/main.js`, `"file:"`.
+
+3. `"file:///C:/"`
+
+This determines the policy for all file based resources within `"file:///C:/"`.
+This is not in the `"scopes"` field of the policy and would be skipped. It would
+not be used for `file:///C:/app/bin/main.js` unless `"file:///"` is set to
+cascade or is not in the `"scopes"` of the policy.
+
+4. `"file:///"`
+
+This determines the policy for all file based resources on the `localhost`. This
+is not in the `"scopes"` field of the policy and would be skipped. It would not
+be used for `file:///C:/app/bin/main.js` unless `"file:///"` is set to cascade
+or is not in the `"scopes"` of the policy.
+
+5. `"file:"`
+
+This determines the policy for all file based resources. It would not be used
+for `file:///C:/app/bin/main.js` unless `"file:///"` is set to cascade or is not
+in the `"scopes"` of the policy.
+
+6. `""`
+
+This determines the policy for all resources. It would not be used for
+`file:///C:/app/bin/main.js` unless `"file:"` is set to cascade.
+
+#### Integrity using scopes
+
+Setting an integrity to `true` on a scope will set the integrity for any
+resource not found in the manifest to `true`.
+
+Setting an integrity to `null` on a scope will set the integrity for any
+resource not found in the manifest to fail matching.
+
+Not including an integrity is the same as setting the integrity to `null`.
+
+`"cascade"` for integrity checks will be ignored if `"integrity"` is explicitly
+set.
+
+The following example allows loading any file:
+
+```json
+{
+  "scopes": {
+    "file:": {
+      "integrity": true
+    }
+  }
+}
+```
+
+#### Dependency redirection using scopes
+
+The following example, would allow access to `fs` for all resources within
+`./app/`:
+
+```json
+{
+  "resources": {
+    "./app/checked.js": {
+      "cascade": true,
+      "integrity": true
+    }
+  },
+  "scopes": {
+    "./app/": {
+      "dependencies": {
+        "fs": true
+      }
+    }
+  }
+}
+```
+
+The following example, would allow access to `fs` for all `data:` resources:
+
+```json
+{
+  "resources": {
+    "data:text/javascript,import('fs');": {
+      "cascade": true,
+      "integrity": true
+    }
+  },
+  "scopes": {
+    "data:": {
+      "dependencies": {
+        "fs": true
+      }
+    }
+  }
+}
+```
+
+#### Example: [import maps][] emulation
+
+Given an import map:
+
+```json
+{
+  "imports": {
+    "react": "./app/node_modules/react/index.js"
+  },
+  "scopes": {
+    "./ssr/": {
+      "react": "./app/node_modules/server-side-react/index.js"
+    }
+  }
+}
+```
+
+```json
+{
+  "dependencies": true,
+  "scopes": {
+    "": {
+      "cascade": true,
+      "dependencies": {
+        "react": "./app/node_modules/react/index.js"
+      }
+    },
+    "./ssr/": {
+      "cascade": true,
+      "dependencies": {
+        "react": "./app/node_modules/server-side-react/index.js"
+      }
+    }
+  }
+}
+```
+
+Import maps assume you can get any resource by default. This means
+`"dependencies"` at the top level of the policy should be set to `true`.
+Policies require this to be opt-in since it enables all resources of the
+application cross linkage which doesn't make sense for many scenarios. They also
+assume any given scope has access to any scope above its allowed dependencies;
+all scopes emulating import maps must set `"cascade": true`.
+
+Import maps only have a single top level scope for their "imports". So for
+emulating `"imports"` use the `""` scope. For emulating `"scopes"` use the
+`"scopes"` in a similar manner to how `"scopes"` works in import maps.
+
+Caveats: Policies do not use string matching for various finding of scope. They
+do URL traversals. This means things like `blob:` and `data:` URLs might not be
+entirely interoperable between the two systems. For example import maps can
+partially match a `data:` or `blob:` URL by partitioning the URL on a `/`
+character, policies intentionally cannot. For `blob:` URLs import map scopes do
+not adopt the origin of the `blob:` URL.
+
+Additionally, import maps only work on `import` so it may be desirable to add a
+`"import"` condition to all dependency mappings.
+
+[import maps]: https://url.spec.whatwg.org/#relative-url-with-fragment-string
+[relative-url string]: https://url.spec.whatwg.org/#relative-url-with-fragment-string
+[special schemes]: https://url.spec.whatwg.org/#special-scheme
diff --git a/doc/api/process.html b/doc/api/process.html
index ab466d7084a333d5df5f1a120cfd4b14d15d3832..27f2b2a55b713d2809f14012df0a64740e687399 100644
--- a/doc/api/process.html
+++ b/doc/api/process.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Process | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Process | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="process" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/process.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/process.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/process.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/process.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/process.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/process.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/process.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/process.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/process.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#process_process">Process</a>
 <ul>
 <li><a href="#process_process_events">Process events</a>
@@ -144,9 +157,11 @@
 </li>
 <li><a href="#process_event_uncaughtexceptionmonitor">Event: <code>'uncaughtExceptionMonitor'</code></a></li>
 <li><a href="#process_event_unhandledrejection">Event: <code>'unhandledRejection'</code></a></li>
-<li><a href="#process_event_warning">Event: <code>'warning'</code></a>
+<li><a href="#process_event_warning">Event: <code>'warning'</code></a></li>
+<li><a href="#process_event_worker">Event: <code>'worker'</code></a>
 <ul>
 <li><a href="#process_emitting_custom_warnings">Emitting custom warnings</a></li>
+<li><a href="#process_node_js_warning_names">Node.js warning names</a></li>
 </ul>
 </li>
 <li><a href="#process_signal_events">Signal events</a></li>
@@ -157,7 +172,12 @@
 <li><a href="#process_process_arch"><code>process.arch</code></a></li>
 <li><a href="#process_process_argv"><code>process.argv</code></a></li>
 <li><a href="#process_process_argv0"><code>process.argv0</code></a></li>
-<li><a href="#process_process_channel"><code>process.channel</code></a></li>
+<li><a href="#process_process_channel"><code>process.channel</code></a>
+<ul>
+<li><a href="#process_process_channel_ref"><code>process.channel.ref()</code></a></li>
+<li><a href="#process_process_channel_unref"><code>process.channel.unref()</code></a></li>
+</ul>
+</li>
 <li><a href="#process_process_chdir_directory"><code>process.chdir(directory)</code></a></li>
 <li><a href="#process_process_config"><code>process.config</code></a></li>
 <li><a href="#process_process_connected"><code>process.connected</code></a></li>
@@ -183,13 +203,18 @@
 <li><a href="#process_process_getgroups"><code>process.getgroups()</code></a></li>
 <li><a href="#process_process_getuid"><code>process.getuid()</code></a></li>
 <li><a href="#process_process_hasuncaughtexceptioncapturecallback"><code>process.hasUncaughtExceptionCaptureCallback()</code></a></li>
-<li><a href="#process_process_hrtime_time"><code>process.hrtime([time])</code></a></li>
+<li><span class="stability_3"><a href="#process_process_hrtime_time"><code>process.hrtime([time])</code></a></span></li>
 <li><a href="#process_process_hrtime_bigint"><code>process.hrtime.bigint()</code></a></li>
 <li><a href="#process_process_initgroups_user_extragroup"><code>process.initgroups(user, extraGroup)</code></a></li>
 <li><a href="#process_process_kill_pid_signal"><code>process.kill(pid[, signal])</code></a></li>
-<li><a href="#process_process_mainmodule"><code>process.mainModule</code></a></li>
+<li><span class="stability_0"><a href="#process_process_mainmodule"><code>process.mainModule</code></a></span></li>
 <li><a href="#process_process_memoryusage"><code>process.memoryUsage()</code></a></li>
-<li><a href="#process_process_nexttick_callback_args"><code>process.nextTick(callback[, ...args])</code></a></li>
+<li><a href="#process_process_memoryusage_rss"><code>process.memoryUsage.rss()</code></a></li>
+<li><a href="#process_process_nexttick_callback_args"><code>process.nextTick(callback[, ...args])</code></a>
+<ul>
+<li><a href="#process_when_to_use_queuemicrotask_vs_process_nexttick">When to use <code>queueMicrotask()</code> vs. <code>process.nextTick()</code></a></li>
+</ul>
+</li>
 <li><a href="#process_process_nodeprecation"><code>process.noDeprecation</code></a></li>
 <li><a href="#process_process_pid"><code>process.pid</code></a></li>
 <li><a href="#process_process_platform"><code>process.platform</code></a></li>
@@ -201,7 +226,7 @@
 <li><a href="#process_process_report_directory"><code>process.report.directory</code></a></li>
 <li><a href="#process_process_report_filename"><code>process.report.filename</code></a></li>
 <li><a href="#process_process_report_getreport_err"><code>process.report.getReport([err])</code></a></li>
-<li><span class="stability_1"><a href="#process_process_report_reportonfatalerror"><code>process.report.reportOnFatalError</code></a></span></li>
+<li><a href="#process_process_report_reportonfatalerror"><code>process.report.reportOnFatalError</code></a></li>
 <li><a href="#process_process_report_reportonsignal"><code>process.report.reportOnSignal</code></a></li>
 <li><a href="#process_process_report_reportonuncaughtexception"><code>process.report.reportOnUncaughtException</code></a></li>
 <li><a href="#process_process_report_signal"><code>process.report.signal</code></a></li>
@@ -215,6 +240,7 @@
 <li><a href="#process_process_setgid_id"><code>process.setgid(id)</code></a></li>
 <li><a href="#process_process_setgroups_groups"><code>process.setgroups(groups)</code></a></li>
 <li><a href="#process_process_setuid_id"><code>process.setuid(id)</code></a></li>
+<li><span class="stability_1"><a href="#process_process_setsourcemapsenabled_val"><code>process.setSourceMapsEnabled(val)</code></a></span></li>
 <li><a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback(fn)</code></a></li>
 <li><a href="#process_process_stderr"><code>process.stderr</code></a>
 <ul>
@@ -243,22 +269,21 @@
 <li><a href="#process_exit_codes">Exit codes</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Process<span><a class="mark" href="#process_process" id="process_process">#</a></span></h1>
+        <h2>Process<span><a class="mark" href="#process_process" id="process_process">#</a></span></h2>
 
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/process.js">lib/process.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/process.js">lib/process.js</a></p>
 <p>The <code>process</code> object is a <code>global</code> that provides information about, and control
 over, the current Node.js process. As a global, it is always available to
 Node.js applications without using <code>require()</code>. It can also be explicitly
 accessed using <code>require()</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> process = <span class="hljs-built_in">require</span>(<span class="hljs-string">'process'</span>);</code></pre>
-<h2>Process events<span><a class="mark" href="#process_process_events" id="process_process_events">#</a></span></h2>
+<section><h3>Process events<span><a class="mark" href="#process_process_events" id="process_process_events">#</a></span></h3>
 <p>The <code>process</code> object is an instance of <a href="events.html#events_class_eventemitter"><code>EventEmitter</code></a>.</p>
-<h3>Event: <code>'beforeExit'</code><span><a class="mark" href="#process_event_beforeexit" id="process_event_beforeexit">#</a></span></h3>
+<h4>Event: <code>'beforeExit'</code><span><a class="mark" href="#process_event_beforeexit" id="process_event_beforeexit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.12</span>
 </div>
@@ -273,28 +298,28 @@ continue.</p>
 termination, such as calling <a href="#process_process_exit_code"><code>process.exit()</code></a> or uncaught exceptions.</p>
 <p>The <code>'beforeExit'</code> should <em>not</em> be used as an alternative to the <code>'exit'</code> event
 unless the intention is to schedule additional work.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'beforeExit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Process beforeExit event with code: '</span>, code);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'beforeExit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Process beforeExit event with code: '</span>, code);
 });
 
-process.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Process exit event with code: '</span>, code);
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Process exit event with code: '</span>, code);
 });
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This message is displayed first.'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This message is displayed first.'</span>);
 
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">// This message is displayed first.</span>
 <span class="hljs-comment">// Process beforeExit event with code: 0</span>
 <span class="hljs-comment">// Process exit event with code: 0</span></code></pre>
-<h3>Event: <code>'disconnect'</code><span><a class="mark" href="#process_event_disconnect" id="process_event_disconnect">#</a></span></h3>
+<h4>Event: <code>'disconnect'</code><span><a class="mark" href="#process_event_disconnect" id="process_event_disconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>If the Node.js process is spawned with an IPC channel (see the <a href="child_process.html">Child Process</a>
 and <a href="cluster.html">Cluster</a> documentation), the <code>'disconnect'</code> event will be emitted when
 the IPC channel is closed.</p>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#process_event_exit" id="process_event_exit">#</a></span></h3>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#process_event_exit" id="process_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.7</span>
 </div>
@@ -312,19 +337,19 @@ all <code>'exit'</code> listeners have finished running the Node.js process will
 <p>The listener callback function is invoked with the exit code specified either
 by the <a href="#process_process_exitcode"><code>process.exitCode</code></a> property, or the <code>exitCode</code> argument passed to the
 <a href="#process_process_exit_code"><code>process.exit()</code></a> method.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`About to exit with code: <span class="hljs-subst">${code}</span>`</span>);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`About to exit with code: <span class="hljs-subst">${code}</span>`</span>);
 });</code></pre>
 <p>Listener functions <strong>must</strong> only perform <strong>synchronous</strong> operations. The Node.js
 process will exit immediately after calling the <code>'exit'</code> event listeners
 causing any additional work still queued in the event loop to be abandoned.
 In the following example, for instance, the timeout will never occur:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
   <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This will not run'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This will not run'</span>);
   }, <span class="hljs-number">0</span>);
 });</code></pre>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#process_event_message" id="process_event_message">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#process_event_message" id="process_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.10</span>
 </div>
@@ -344,7 +369,7 @@ not be the same as what is originally sent.</p>
 process, the <code>message</code> argument can contain data that JSON is not able
 to represent.
 See <a href="child_process.html#child_process_advanced_serialization">Advanced serialization for <code>child_process</code></a> for more details.</p>
-<h3>Event: <code>'multipleResolves'</code><span><a class="mark" href="#process_event_multipleresolves" id="process_event_multipleresolves">#</a></span></h3>
+<h4>Event: <code>'multipleResolves'</code><span><a class="mark" href="#process_event_multipleresolves" id="process_event_multipleresolves">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -365,31 +390,31 @@ rejected after the original resolve.</li>
 <code>Promise</code> constructor, as multiple resolutions are silently swallowed. However,
 the occurrence of this event does not necessarily indicate an error. For
 example, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race"><code>Promise.race()</code></a> can trigger a <code>'multipleResolves'</code> event.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'multipleResolves'</span>, <span class="hljs-function">(<span class="hljs-params">type, promise, reason</span>) =></span> {
-  <span class="hljs-built_in">console</span>.error(type, promise, reason);
-  setImmediate(<span class="hljs-function">() =></span> process.exit(<span class="hljs-number">1</span>));
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'multipleResolves'</span>, <span class="hljs-function">(<span class="hljs-params">type, promise, reason</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(type, promise, reason);
+  <span class="hljs-title function_">setImmediate</span>(<span class="hljs-function">() =></span> process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">1</span>));
 });
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">main</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">main</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">await</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-      resolve(<span class="hljs-string">'First call'</span>);
-      resolve(<span class="hljs-string">'Swallowed resolve'</span>);
-      reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Swallowed reject'</span>));
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">await</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+      <span class="hljs-title function_">resolve</span>(<span class="hljs-string">'First call'</span>);
+      <span class="hljs-title function_">resolve</span>(<span class="hljs-string">'Swallowed resolve'</span>);
+      <span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Swallowed reject'</span>));
     });
   } <span class="hljs-keyword">catch</span> {
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Failed'</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Failed'</span>);
   }
 }
 
-main().then(<span class="hljs-built_in">console</span>.log);
+<span class="hljs-title function_">main</span>().<span class="hljs-title function_">then</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>);
 <span class="hljs-comment">// resolve: Promise { 'First call' } 'Swallowed resolve'</span>
 <span class="hljs-comment">// reject: Promise { 'First call' } Error: Swallowed reject</span>
 <span class="hljs-comment">//     at Promise (*)</span>
 <span class="hljs-comment">//     at new Promise (&#x3C;anonymous>)</span>
 <span class="hljs-comment">//     at main (*)</span>
 <span class="hljs-comment">// First call</span></code></pre>
-<h3>Event: <code>'rejectionHandled'</code><span><a class="mark" href="#process_event_rejectionhandled" id="process_event_rejectionhandled">#</a></span></h3>
+<h4>Event: <code>'rejectionHandled'</code><span><a class="mark" href="#process_event_rejectionhandled" id="process_event_rejectionhandled">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.4.1</span>
 </div>
@@ -414,24 +439,24 @@ unhandled exceptions grows.</p>
 <p>In asynchronous code, the <code>'unhandledRejection'</code> event is emitted when the list
 of unhandled rejections grows, and the <code>'rejectionHandled'</code> event is emitted
 when the list of unhandled rejections shrinks.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> unhandledRejections = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>();
-process.on(<span class="hljs-string">'unhandledRejection'</span>, <span class="hljs-function">(<span class="hljs-params">reason, promise</span>) =></span> {
-  unhandledRejections.set(promise, reason);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> unhandledRejections = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>();
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'unhandledRejection'</span>, <span class="hljs-function">(<span class="hljs-params">reason, promise</span>) =></span> {
+  unhandledRejections.<span class="hljs-title function_">set</span>(promise, reason);
 });
-process.on(<span class="hljs-string">'rejectionHandled'</span>, <span class="hljs-function">(<span class="hljs-params">promise</span>) =></span> {
-  unhandledRejections.delete(promise);
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'rejectionHandled'</span>, <span class="hljs-function">(<span class="hljs-params">promise</span>) =></span> {
+  unhandledRejections.<span class="hljs-title function_">delete</span>(promise);
 });</code></pre>
 <p>In this example, the <code>unhandledRejections</code> <code>Map</code> will grow and shrink over time,
 reflecting rejections that start unhandled and then become handled. It is
 possible to record such errors in an error log, either periodically (which is
 likely best for long-running application) or upon process exit (which is likely
 most convenient for scripts).</p>
-<h3>Event: <code>'uncaughtException'</code><span><a class="mark" href="#process_event_uncaughtexception" id="process_event_uncaughtexception">#</a></span></h3>
+<h4>Event: <code>'uncaughtException'</code><span><a class="mark" href="#process_event_uncaughtexception" id="process_event_uncaughtexception">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.0.0</td>
+<tr><td>v12.0.0, v10.17.0</td>
 <td><p>Added the <code>origin</code> argument.</p></td></tr>
 <tr><td>v0.1.18</td>
 <td><p><span>Added in: v0.1.18</span></p></td></tr>
@@ -443,7 +468,8 @@ most convenient for scripts).</p>
 <li><code>origin</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Indicates if the exception originates from an unhandled
 rejection or from an synchronous error. Can either be <code>'uncaughtException'</code> or
 <code>'unhandledRejection'</code>. The latter is only used in conjunction with the
-<a href="cli.html#cli_unhandled_rejections_mode"><code>--unhandled-rejections</code></a> flag set to <code>strict</code> and an unhandled rejection.</li>
+<a href="cli.html#cli_unhandled_rejections_mode"><code>--unhandled-rejections</code></a> flag set to <code>strict</code> or <code>throw</code> and
+an unhandled rejection.</li>
 </ul>
 <p>The <code>'uncaughtException'</code> event is emitted when an uncaught JavaScript
 exception bubbles all the way back to the event loop. By default, Node.js
@@ -454,25 +480,25 @@ behavior. Alternatively, change the <a href="#process_process_exitcode"><code>pr
 <code>'uncaughtException'</code> handler which will result in the process exiting with the
 provided exit code. Otherwise, in the presence of such handler the process will
 exit with 0.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'uncaughtException'</span>, <span class="hljs-function">(<span class="hljs-params">err, origin</span>) =></span> {
-  fs.writeSync(
-    process.stderr.fd,
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'uncaughtException'</span>, <span class="hljs-function">(<span class="hljs-params">err, origin</span>) =></span> {
+  fs.<span class="hljs-title function_">writeSync</span>(
+    process.<span class="hljs-property">stderr</span>.<span class="hljs-property">fd</span>,
     <span class="hljs-string">`Caught exception: <span class="hljs-subst">${err}</span>\n`</span> +
     <span class="hljs-string">`Exception origin: <span class="hljs-subst">${origin}</span>`</span>
   );
 });
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This will still run.'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This will still run.'</span>);
 }, <span class="hljs-number">500</span>);
 
 <span class="hljs-comment">// Intentionally cause an exception, but don't catch it.</span>
-nonexistentFunc();
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'This will not run.'</span>);</code></pre>
+<span class="hljs-title function_">nonexistentFunc</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'This will not run.'</span>);</code></pre>
 <p>It is possible to monitor <code>'uncaughtException'</code> events without overriding the
 default behavior to exit the process by installing a
 <code>'uncaughtExceptionMonitor'</code> listener.</p>
-<h4>Warning: Using <code>'uncaughtException'</code> correctly<span><a class="mark" href="#process_warning_using_uncaughtexception_correctly" id="process_warning_using_uncaughtexception_correctly">#</a></span></h4>
+<h5>Warning: Using <code>'uncaughtException'</code> correctly<span><a class="mark" href="#process_warning_using_uncaughtexception_correctly" id="process_warning_using_uncaughtexception_correctly">#</a></span></h5>
 <p><code>'uncaughtException'</code> is a crude mechanism for exception handling
 intended to be used only as a last resort. The event <em>should not</em> be used as
 an equivalent to <code>On Error Resume Next</code>. Unhandled exceptions inherently mean
@@ -493,30 +519,32 @@ down the process. <strong>It is not safe to resume normal operation after
 <code>'uncaughtException'</code> is emitted or not, an external monitor should be employed
 in a separate process to detect application failures and recover or restart as
 needed.</p>
-<h3>Event: <code>'uncaughtExceptionMonitor'</code><span><a class="mark" href="#process_event_uncaughtexceptionmonitor" id="process_event_uncaughtexceptionmonitor">#</a></span></h3>
+<h4>Event: <code>'uncaughtExceptionMonitor'</code><span><a class="mark" href="#process_event_uncaughtexceptionmonitor" id="process_event_uncaughtexceptionmonitor">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0</span>
 </div>
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> The uncaught exception.</li>
 <li><code>origin</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Indicates if the exception originates from an unhandled
 rejection or from synchronous errors. Can either be <code>'uncaughtException'</code> or
-<code>'unhandledRejection'</code>.</li>
+<code>'unhandledRejection'</code>. The latter is only used in conjunction with the
+<a href="cli.html#cli_unhandled_rejections_mode"><code>--unhandled-rejections</code></a> flag set to <code>strict</code> or <code>throw</code> and
+an unhandled rejection.</li>
 </ul>
 <p>The <code>'uncaughtExceptionMonitor'</code> event is emitted before an
 <code>'uncaughtException'</code> event is emitted or a hook installed via
-<a href="process.html#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> is called.</p>
+<a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> is called.</p>
 <p>Installing an <code>'uncaughtExceptionMonitor'</code> listener does not change the behavior
 once an <code>'uncaughtException'</code> event is emitted. The process will
 still crash if no <code>'uncaughtException'</code> listener is installed.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'uncaughtExceptionMonitor'</span>, <span class="hljs-function">(<span class="hljs-params">err, origin</span>) =></span> {
-  MyMonitoringTool.logSync(err, origin);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'uncaughtExceptionMonitor'</span>, <span class="hljs-function">(<span class="hljs-params">err, origin</span>) =></span> {
+  <span class="hljs-title class_">MyMonitoringTool</span>.<span class="hljs-title function_">logSync</span>(err, origin);
 });
 
 <span class="hljs-comment">// Intentionally cause an exception, but don't catch it.</span>
-nonexistentFunc();
+<span class="hljs-title function_">nonexistentFunc</span>();
 <span class="hljs-comment">// Still crashes Node.js</span></code></pre>
-<h3>Event: <code>'unhandledRejection'</code><span><a class="mark" href="#process_event_unhandledrejection" id="process_event_unhandledrejection">#</a></span></h3>
+<h4>Event: <code>'unhandledRejection'</code><span><a class="mark" href="#process_event_unhandledrejection" id="process_event_unhandledrejection">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -542,22 +570,22 @@ promises". Rejections can be caught and handled using <a href="https://developer
 are propagated through a <code>Promise</code> chain. The <code>'unhandledRejection'</code> event is
 useful for detecting and keeping track of promises that were rejected whose
 rejections have not yet been handled.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'unhandledRejection'</span>, <span class="hljs-function">(<span class="hljs-params">reason, promise</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Unhandled Rejection at:'</span>, promise, <span class="hljs-string">'reason:'</span>, reason);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'unhandledRejection'</span>, <span class="hljs-function">(<span class="hljs-params">reason, promise</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Unhandled Rejection at:'</span>, promise, <span class="hljs-string">'reason:'</span>, reason);
   <span class="hljs-comment">// Application specific logging, throwing an error, or other logic here</span>
 });
 
-somePromise.then(<span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
-  <span class="hljs-keyword">return</span> reportToUser(<span class="hljs-built_in">JSON</span>.pasre(res)); <span class="hljs-comment">// Note the typo (`pasre`)</span>
+somePromise.<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">res</span>) =></span> {
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">reportToUser</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">pasre</span>(res)); <span class="hljs-comment">// Note the typo (`pasre`)</span>
 }); <span class="hljs-comment">// No `.catch()` or `.then()`</span></code></pre>
 <p>The following will also trigger the <code>'unhandledRejection'</code> event to be
 emitted:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">SomeResource</span>(<span class="hljs-params"></span>) </span>{
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">SomeResource</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// Initially set the loaded status to a rejected promise</span>
-  <span class="hljs-built_in">this</span>.loaded = <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Resource not yet loaded!'</span>));
+  <span class="hljs-variable language_">this</span>.<span class="hljs-property">loaded</span> = <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Resource not yet loaded!'</span>));
 }
 
-<span class="hljs-keyword">const</span> resource = <span class="hljs-keyword">new</span> SomeResource();
+<span class="hljs-keyword">const</span> resource = <span class="hljs-keyword">new</span> <span class="hljs-title class_">SomeResource</span>();
 <span class="hljs-comment">// no .catch or .then on resource.loaded for at least a turn</span></code></pre>
 <p>In this example case, it is possible to track the rejection as a developer error
 as would typically be the case for other <code>'unhandledRejection'</code> events. To
@@ -565,7 +593,7 @@ address such failures, a non-operational
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch"><code>.catch(() => { })</code></a> handler may be attached to
 <code>resource.loaded</code>, which would prevent the <code>'unhandledRejection'</code> event from
 being emitted.</p>
-<h3>Event: <code>'warning'</code><span><a class="mark" href="#process_event_warning" id="process_event_warning">#</a></span></h3>
+<h4>Event: <code>'warning'</code><span><a class="mark" href="#process_event_warning" id="process_event_warning">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -585,44 +613,74 @@ conditions that are being brought to the user's attention. However, warnings
 are not part of the normal Node.js and JavaScript error handling flow.
 Node.js can emit warnings whenever it detects bad coding practices that could
 lead to sub-optimal application performance, bugs, or security vulnerabilities.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
-  <span class="hljs-built_in">console</span>.warn(warning.name);    <span class="hljs-comment">// Print the warning name</span>
-  <span class="hljs-built_in">console</span>.warn(warning.message); <span class="hljs-comment">// Print the warning message</span>
-  <span class="hljs-built_in">console</span>.warn(warning.stack);   <span class="hljs-comment">// Print the stack trace</span>
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">name</span>);    <span class="hljs-comment">// Print the warning name</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">message</span>); <span class="hljs-comment">// Print the warning message</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">stack</span>);   <span class="hljs-comment">// Print the stack trace</span>
 });</code></pre>
 <p>By default, Node.js will print process warnings to <code>stderr</code>. The <code>--no-warnings</code>
 command-line option can be used to suppress the default console output but the
 <code>'warning'</code> event will still be emitted by the <code>process</code> object.</p>
 <p>The following example illustrates the warning that is printed to <code>stderr</code> when
 too many listeners have been added to an event:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> events.defaultMaxListeners = 1;</span>
-<span class="hljs-meta">></span><span class="bash"> process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
-<span class="hljs-meta">></span><span class="bash"> process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
-<span class="hljs-meta">></span><span class="bash"> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">events.defaultMaxListeners = 1;</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
+<span class="hljs-meta">> </span><span class="language-bash">(node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak</span>
 detected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit</code></pre>
 <p>In contrast, the following example turns off the default warning output and
 adds a custom handler to the <code>'warning'</code> event:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --no-warnings</span>
-<span class="hljs-meta">></span><span class="bash"> const p = process.on(<span class="hljs-string">'warning'</span>, (warning) => console.warn(<span class="hljs-string">'Do not do that!'</span>));</span>
-<span class="hljs-meta">></span><span class="bash"> events.defaultMaxListeners = 1;</span>
-<span class="hljs-meta">></span><span class="bash"> process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
-<span class="hljs-meta">></span><span class="bash"> process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
-<span class="hljs-meta">></span><span class="bash"> Do not <span class="hljs-keyword">do</span> that!</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --no-warnings</span>
+<span class="hljs-meta">> </span><span class="language-bash">const p = process.on(<span class="hljs-string">'warning'</span>, (warning) => console.warn(<span class="hljs-string">'Do not do that!'</span>));</span>
+<span class="hljs-meta">> </span><span class="language-bash">events.defaultMaxListeners = 1;</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.on(<span class="hljs-string">'foo'</span>, () => {});</span>
+<span class="hljs-meta">> </span><span class="language-bash">Do not <span class="hljs-keyword">do</span> that!</span></code></pre>
 <p>The <code>--trace-warnings</code> command-line option can be used to have the default
 console output for warnings include the full stack trace of the warning.</p>
-<p>Launching Node.js using the <code>--throw-deprecation</code> command line flag will
+<p>Launching Node.js using the <code>--throw-deprecation</code> command-line flag will
 cause custom deprecation warnings to be thrown as exceptions.</p>
-<p>Using the <code>--trace-deprecation</code> command line flag will cause the custom
+<p>Using the <code>--trace-deprecation</code> command-line flag will cause the custom
 deprecation to be printed to <code>stderr</code> along with the stack trace.</p>
-<p>Using the <code>--no-deprecation</code> command line flag will suppress all reporting
+<p>Using the <code>--no-deprecation</code> command-line flag will suppress all reporting
 of the custom deprecation.</p>
-<p>The <code>*-deprecation</code> command line flags only affect warnings that use the name
+<p>The <code>*-deprecation</code> command-line flags only affect warnings that use the name
 <code>'DeprecationWarning'</code>.</p>
-<h4>Emitting custom warnings<span><a class="mark" href="#process_emitting_custom_warnings" id="process_emitting_custom_warnings">#</a></span></h4>
+<h4>Event: <code>'worker'</code><span><a class="mark" href="#process_event_worker" id="process_event_worker">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>worker</code> <a href="worker_threads.html#worker_threads_class_worker" class="type">&#x3C;Worker></a> The <a href="worker_threads.html#worker_threads_class_worker" class="type">&#x3C;Worker></a> that was created.</li>
+</ul>
+<p>The <code>'worker'</code> event is emitted after a new <a href="worker_threads.html#worker_threads_class_worker" class="type">&#x3C;Worker></a> thread has been created.</p>
+<h5>Emitting custom warnings<span><a class="mark" href="#process_emitting_custom_warnings" id="process_emitting_custom_warnings">#</a></span></h5>
 <p>See the <a href="#process_process_emitwarning_warning_type_code_ctor"><code>process.emitWarning()</code></a> method for issuing
 custom or application-specific warnings.</p>
-<h3>Signal events<span><a class="mark" href="#process_signal_events" id="process_signal_events">#</a></span></h3>
+<h5>Node.js warning names<span><a class="mark" href="#process_node_js_warning_names" id="process_node_js_warning_names">#</a></span></h5>
+<p>There are no strict guidelines for warning types (as identified by the <code>name</code>
+property) emitted by Node.js. New types of warnings can be added at any time.
+A few of the warning types that are most common include:</p>
+<ul>
+<li><code>'DeprecationWarning'</code> - Indicates use of a deprecated Node.js API or feature.
+Such warnings must include a <code>'code'</code> property identifying the
+<a href="deprecations.html">deprecation code</a>.</li>
+<li><code>'ExperimentalWarning'</code> - Indicates use of an experimental Node.js API or
+feature. Such features must be used with caution as they may change at any
+time and are not subject to the same strict semantic-versioning and long-term
+support policies as supported features.</li>
+<li><code>'MaxListenersExceededWarning'</code> - Indicates that too many listeners for a
+given event have been registered on either an <code>EventEmitter</code> or <code>EventTarget</code>.
+This is often an indication of a memory leak.</li>
+<li><code>'TimeoutOverflowWarning'</code> - Indicates that a numeric value that cannot fit
+within a 32-bit signed integer has been provided to either the <code>setTimeout()</code>
+or <code>setInterval()</code> functions.</li>
+<li><code>'UnsupportedWarning'</code> - Indicates use of an unsupported option or feature
+that will be ignored rather than treated as an error. One example is use of
+the HTTP response status message when using the HTTP/2 compatibility API.</li>
+</ul>
+<h4>Signal events<span><a class="mark" href="#process_signal_events" id="process_signal_events">#</a></span></h4>
 
 
 <p>Signal events will be emitted when the Node.js process receives a signal. Please
@@ -634,19 +692,19 @@ refer to <a href="http://man7.org/linux/man-pages/man7/signal.7.html"><code>sign
 <p>The name of each event will be the uppercase common name for the signal (e.g.
 <code>'SIGINT'</code> for <code>SIGINT</code> signals).</p>
 <pre><code class="language-js"><span class="hljs-comment">// Begin reading from stdin so the process does not exit.</span>
-process.stdin.resume();
+process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">resume</span>();
 
-process.on(<span class="hljs-string">'SIGINT'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Received SIGINT. Press Control-D to exit.'</span>);
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGINT'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Received SIGINT. Press Control-D to exit.'</span>);
 });
 
 <span class="hljs-comment">// Using a single function to handle multiple signals</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">handle</span>(<span class="hljs-params">signal</span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received <span class="hljs-subst">${signal}</span>`</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">handle</span>(<span class="hljs-params">signal</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received <span class="hljs-subst">${signal}</span>`</span>);
 }
 
-process.on(<span class="hljs-string">'SIGINT'</span>, handle);
-process.on(<span class="hljs-string">'SIGTERM'</span>, handle);</code></pre>
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGINT'</span>, handle);
+process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGTERM'</span>, handle);</code></pre>
 <ul>
 <li><code>'SIGUSR1'</code> is reserved by Node.js to start the <a href="debugger.html">debugger</a>. It's possible to
 install a listener but doing so might interfere with the debugger.</li>
@@ -676,11 +734,9 @@ when a readable tty is used in raw mode.</li>
 terminate Node.js on all platforms.</li>
 <li><code>'SIGSTOP'</code> cannot have a listener installed.</li>
 <li><code>'SIGBUS'</code>, <code>'SIGFPE'</code>, <code>'SIGSEGV'</code> and <code>'SIGILL'</code>, when not raised
- artificially using <a href="http://man7.org/linux/man-pages/man2/kill.2.html"><code>kill(2)</code></a>, inherently leave the process in a state from
- which it is not safe to attempt to call JS listeners. Doing so might lead to
- the process hanging in an endless loop, since listeners attached using
- <code>process.on()</code> are called asynchronously and therefore unable to correct the
-underlying problem.</li>
+artificially using <a href="http://man7.org/linux/man-pages/man2/kill.2.html"><code>kill(2)</code></a>, inherently leave the process in a state from
+which it is not safe to call JS listeners. Doing so might cause the process
+to stop responding.</li>
 <li><code>0</code> can be sent to test for the existence of a process, it has no effect if
 the process exists, but will throw an error if the process does not exist.</li>
 </ul>
@@ -694,14 +750,14 @@ the process was terminated by signal.</li>
 <li>Sending signal <code>0</code> can be used as a platform independent way to test for the
 existence of a process.</li>
 </ul>
-<h2><code>process.abort()</code><span><a class="mark" href="#process_process_abort" id="process_process_abort">#</a></span></h2>
+</section><section><h3><code>process.abort()</code><span><a class="mark" href="#process_process_abort" id="process_process_abort">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
 <p>The <code>process.abort()</code> method causes the Node.js process to exit immediately and
 generate a core file.</p>
 <p>This feature is not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.allowedNodeEnvironmentFlags</code><span><a class="mark" href="#process_process_allowednodeenvironmentflags" id="process_process_allowednodeenvironmentflags">#</a></span></h2>
+</section><section><h3><code>process.allowedNodeEnvironmentFlags</code><span><a class="mark" href="#process_process_allowednodeenvironmentflags" id="process_process_allowednodeenvironmentflags">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.10.0</span>
 </div>
@@ -731,7 +787,7 @@ e.g., <code>--stack-trace-limit=100</code>.</li>
 appear only <em>once</em>; each will begin with one or more dashes. Flags
 passed through to V8 will contain underscores instead of non-leading
 dashes:</p>
-<pre><code class="language-js">process.allowedNodeEnvironmentFlags.forEach(<span class="hljs-function">(<span class="hljs-params">flag</span>) =></span> {
+<pre><code class="language-js">process.<span class="hljs-property">allowedNodeEnvironmentFlags</span>.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">flag</span>) =></span> {
   <span class="hljs-comment">// -r</span>
   <span class="hljs-comment">// --inspect-brk</span>
   <span class="hljs-comment">// --abort_on_uncaught_exception</span>
@@ -743,7 +799,7 @@ silently.</p>
 <p>If Node.js was compiled <em>without</em> <a href="cli.html#cli_node_options_options"><code>NODE_OPTIONS</code></a> support (shown in
 <a href="#process_process_config"><code>process.config</code></a>), <code>process.allowedNodeEnvironmentFlags</code> will
 contain what <em>would have</em> been allowable.</p>
-<h2><code>process.arch</code><span><a class="mark" href="#process_process_arch" id="process_process_arch">#</a></span></h2>
+</section><section><h3><code>process.arch</code><span><a class="mark" href="#process_process_arch" id="process_process_arch">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -753,34 +809,34 @@ contain what <em>would have</em> been allowable.</p>
 <p>The operating system CPU architecture for which the Node.js binary was compiled.
 Possible values are: <code>'arm'</code>, <code>'arm64'</code>, <code>'ia32'</code>, <code>'mips'</code>,<code>'mipsel'</code>, <code>'ppc'</code>,
 <code>'ppc64'</code>, <code>'s390'</code>, <code>'s390x'</code>, <code>'x32'</code>, and <code>'x64'</code>.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`This processor architecture is <span class="hljs-subst">${process.arch}</span>`</span>);</code></pre>
-<h2><code>process.argv</code><span><a class="mark" href="#process_process_argv" id="process_process_argv">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`This processor architecture is <span class="hljs-subst">${process.arch}</span>`</span>);</code></pre>
+</section><section><h3><code>process.argv</code><span><a class="mark" href="#process_process_argv" id="process_process_argv">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.27</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
-<p>The <code>process.argv</code> property returns an array containing the command line
+<p>The <code>process.argv</code> property returns an array containing the command-line
 arguments passed when the Node.js process was launched. The first element will
 be <a href="#process_process_execpath"><code>process.execPath</code></a>. See <code>process.argv0</code> if access to the original value
 of <code>argv[0]</code> is needed. The second element will be the path to the JavaScript
-file being executed. The remaining elements will be any additional command line
+file being executed. The remaining elements will be any additional command-line
 arguments.</p>
 <p>For example, assuming the following script for <code>process-args.js</code>:</p>
 <pre><code class="language-js"><span class="hljs-comment">// print process.argv</span>
-process.argv.forEach(<span class="hljs-function">(<span class="hljs-params">val, index</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${index}</span>: <span class="hljs-subst">${val}</span>`</span>);
+process.<span class="hljs-property">argv</span>.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">val, index</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${index}</span>: <span class="hljs-subst">${val}</span>`</span>);
 });</code></pre>
 <p>Launching the Node.js process as:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node process-args.js one two=three four</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node process-args.js one two=three four</span></code></pre>
 <p>Would generate the output:</p>
 <pre><code class="language-text">0: /usr/local/bin/node
 1: /Users/mjr/work/node/process-args.js
 2: one
 3: two=three
 4: four</code></pre>
-<h2><code>process.argv0</code><span><a class="mark" href="#process_process_argv0" id="process_process_argv0">#</a></span></h2>
+</section><section><h3><code>process.argv0</code><span><a class="mark" href="#process_process_argv0" id="process_process_argv0">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.4.0</span>
 </div>
@@ -789,14 +845,22 @@ process.argv.forEach(<span class="hljs-function">(<span class="hljs-params">val,
 </ul>
 <p>The <code>process.argv0</code> property stores a read-only copy of the original value of
 <code>argv[0]</code> passed when Node.js starts.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> bash -c <span class="hljs-string">'exec -a customArgv0 ./node'</span></span>
-<span class="hljs-meta">></span><span class="bash"> process.argv[0]</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">bash -c <span class="hljs-string">'exec -a customArgv0 ./node'</span></span>
+<span class="hljs-meta">> </span><span class="language-bash">process.argv[0]</span>
 '/Volumes/code/external/node/out/Release/node'
-<span class="hljs-meta">></span><span class="bash"> process.argv0</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.argv0</span>
 'customArgv0'</code></pre>
-<h2><code>process.channel</code><span><a class="mark" href="#process_process_channel" id="process_process_channel">#</a></span></h2>
+</section><section><h3><code>process.channel</code><span><a class="mark" href="#process_process_channel" id="process_process_channel">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v7.1.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The object no longer accidentally exposes native C++ bindings.</p></td></tr>
+<tr><td>v7.1.0</td>
+<td><p><span>Added in: v7.1.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
@@ -805,7 +869,25 @@ process.argv.forEach(<span class="hljs-function">(<span class="hljs-params">val,
 <a href="child_process.html">Child Process</a> documentation), the <code>process.channel</code>
 property is a reference to the IPC channel. If no IPC channel exists, this
 property is <code>undefined</code>.</p>
-<h2><code>process.chdir(directory)</code><span><a class="mark" href="#process_process_chdir_directory" id="process_process_chdir_directory">#</a></span></h2>
+<h4><code>process.channel.ref()</code><span><a class="mark" href="#process_process_channel_ref" id="process_process_channel_ref">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v7.1.0</span>
+</div>
+<p>This method makes the IPC channel keep the event loop of the process
+running if <code>.unref()</code> has been called before.</p>
+<p>Typically, this is managed through the number of <code>'disconnect'</code> and <code>'message'</code>
+listeners on the <code>process</code> object. However, this method can be used to
+explicitly request a specific behavior.</p>
+<h4><code>process.channel.unref()</code><span><a class="mark" href="#process_process_channel_unref" id="process_process_channel_unref">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v7.1.0</span>
+</div>
+<p>This method makes the IPC channel not keep the event loop of the process
+running, and lets it finish even while the channel is open.</p>
+<p>Typically, this is managed through the number of <code>'disconnect'</code> and <code>'message'</code>
+listeners on the <code>process</code> object. However, this method can be used to
+explicitly request a specific behavior.</p>
+</section><section><h3><code>process.chdir(directory)</code><span><a class="mark" href="#process_process_chdir_directory" id="process_process_chdir_directory">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.17</span>
 </div>
@@ -815,15 +897,15 @@ property is <code>undefined</code>.</p>
 <p>The <code>process.chdir()</code> method changes the current working directory of the
 Node.js process or throws an exception if doing so fails (for instance, if
 the specified <code>directory</code> does not exist).</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Starting directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Starting directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);
 <span class="hljs-keyword">try</span> {
-  process.chdir(<span class="hljs-string">'/tmp'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);
+  process.<span class="hljs-title function_">chdir</span>(<span class="hljs-string">'/tmp'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  <span class="hljs-built_in">console</span>.error(<span class="hljs-string">`chdir: <span class="hljs-subst">${err}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">`chdir: <span class="hljs-subst">${err}</span>`</span>);
 }</code></pre>
 <p>This feature is not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.config</code><span><a class="mark" href="#process_process_config" id="process_process_config">#</a></span></h2>
+</section><section><h3><code>process.config</code><span><a class="mark" href="#process_process_config" id="process_process_config">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -864,7 +946,7 @@ running the <code>./configure</code> script.</p>
 <p>The <code>process.config</code> property is <strong>not</strong> read-only and there are existing
 modules in the ecosystem that are known to extend, modify, or entirely replace
 the value of <code>process.config</code>.</p>
-<h2><code>process.connected</code><span><a class="mark" href="#process_process_connected" id="process_process_connected">#</a></span></h2>
+</section><section><h3><code>process.connected</code><span><a class="mark" href="#process_process_connected" id="process_process_connected">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -877,7 +959,7 @@ and <a href="cluster.html">Cluster</a> documentation), the <code>process.connect
 <code>process.disconnect()</code> is called.</p>
 <p>Once <code>process.connected</code> is <code>false</code>, it is no longer possible to send messages
 over the IPC channel using <code>process.send()</code>.</p>
-<h2><code>process.cpuUsage([previousValue])</code><span><a class="mark" href="#process_process_cpuusage_previousvalue" id="process_process_cpuusage_previousvalue">#</a></span></h2>
+</section><section><h3><code>process.cpuUsage([previousValue])</code><span><a class="mark" href="#process_process_cpuusage_previousvalue" id="process_process_cpuusage_previousvalue">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.1.0</span>
 </div>
@@ -898,16 +980,16 @@ spent in user and system code respectively, and may end up being greater than
 actual elapsed time if multiple CPU cores are performing work for this process.</p>
 <p>The result of a previous call to <code>process.cpuUsage()</code> can be passed as the
 argument to the function, to get a diff reading.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> startUsage = process.cpuUsage();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> startUsage = process.<span class="hljs-title function_">cpuUsage</span>();
 <span class="hljs-comment">// { user: 38579, system: 6986 }</span>
 
 <span class="hljs-comment">// spin the CPU for 500 milliseconds</span>
-<span class="hljs-keyword">const</span> now = <span class="hljs-built_in">Date</span>.now();
-<span class="hljs-keyword">while</span> (<span class="hljs-built_in">Date</span>.now() - now &#x3C; <span class="hljs-number">500</span>);
+<span class="hljs-keyword">const</span> now = <span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>();
+<span class="hljs-keyword">while</span> (<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>() - now &#x3C; <span class="hljs-number">500</span>);
 
-<span class="hljs-built_in">console</span>.log(process.cpuUsage(startUsage));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">cpuUsage</span>(startUsage));
 <span class="hljs-comment">// { user: 514883, system: 11226 }</span></code></pre>
-<h2><code>process.cwd()</code><span><a class="mark" href="#process_process_cwd" id="process_process_cwd">#</a></span></h2>
+</section><section><h3><code>process.cwd()</code><span><a class="mark" href="#process_process_cwd" id="process_process_cwd">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.8</span>
 </div>
@@ -916,8 +998,8 @@ argument to the function, to get a diff reading.</p>
 </ul>
 <p>The <code>process.cwd()</code> method returns the current working directory of the Node.js
 process.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);</code></pre>
-<h2><code>process.debugPort</code><span><a class="mark" href="#process_process_debugport" id="process_process_debugport">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current directory: <span class="hljs-subst">${process.cwd()}</span>`</span>);</code></pre>
+</section><section><h3><code>process.debugPort</code><span><a class="mark" href="#process_process_debugport" id="process_process_debugport">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -925,8 +1007,8 @@ process.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>The port used by the Node.js debugger when enabled.</p>
-<pre><code class="language-js">process.debugPort = <span class="hljs-number">5858</span>;</code></pre>
-<h2><code>process.disconnect()</code><span><a class="mark" href="#process_process_disconnect" id="process_process_disconnect">#</a></span></h2>
+<pre><code class="language-js">process.<span class="hljs-property">debugPort</span> = <span class="hljs-number">5858</span>;</code></pre>
+</section><section><h3><code>process.disconnect()</code><span><a class="mark" href="#process_process_disconnect" id="process_process_disconnect">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.2</span>
 </div>
@@ -938,7 +1020,7 @@ once there are no other connections keeping it alive.</p>
 <a href="child_process.html#child_process_subprocess_disconnect"><code>ChildProcess.disconnect()</code></a> from the parent process.</p>
 <p>If the Node.js process was not spawned with an IPC channel,
 <code>process.disconnect()</code> will be <code>undefined</code>.</p>
-<h2><code>process.dlopen(module, filename[, flags])</code><span><a class="mark" href="#process_process_dlopen_module_filename_flags" id="process_process_dlopen_module_filename_flags">#</a></span></h2>
+</section><section><h3><code>process.dlopen(module, filename[, flags])</code><span><a class="mark" href="#process_process_dlopen_module_filename_flags" id="process_process_dlopen_module_filename_flags">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -955,28 +1037,27 @@ once there are no other connections keeping it alive.</p>
 <li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>flags</code> <a href="os.html#os_dlopen_constants" class="type">&#x3C;os.constants.dlopen></a> <strong>Default:</strong> <code>os.constants.dlopen.RTLD_LAZY</code></li>
 </ul>
-<p>The <code>process.dlopen()</code> method allows to dynamically load shared
-objects. It is primarily used by <code>require()</code> to load
-C++ Addons, and should not be used directly, except in special
-cases. In other words, <a href="globals.html#globals_require"><code>require()</code></a> should be preferred over
-<code>process.dlopen()</code>, unless there are specific reasons.</p>
+<p>The <code>process.dlopen()</code> method allows dynamically loading shared objects. It is
+primarily used by <code>require()</code> to load C++ Addons, and should not be used
+directly, except in special cases. In other words, <a href="globals.html#globals_require"><code>require()</code></a> should be
+preferred over <code>process.dlopen()</code> unless there are specific reasons such as
+custom dlopen flags or loading from ES modules.</p>
 <p>The <code>flags</code> argument is an integer that allows to specify dlopen
 behavior. See the <a href="os.html#os_dlopen_constants"><code>os.constants.dlopen</code></a> documentation for details.</p>
-<p>If there are specific reasons to use <code>process.dlopen()</code> (for instance,
-to specify dlopen flags), it's often useful to use <a href="modules.html#modules_require_resolve_request_options"><code>require.resolve()</code></a>
-to look up the module's path.</p>
-<p>An important drawback when calling <code>process.dlopen()</code> is that the <code>module</code>
-instance must be passed. Functions exported by the C++ Addon will be accessible
-via <code>module.exports</code>.</p>
-<p>The example below shows how to load a C++ Addon, named as <code>binding</code>,
-that exports a <code>foo</code> function. All the symbols will be loaded before
+<p>An important requirement when calling <code>process.dlopen()</code> is that the <code>module</code>
+instance must be passed. Functions exported by the C++ Addon are then
+accessible via <code>module.exports</code>.</p>
+<p>The example below shows how to load a C++ Addon, named <code>local.node</code>,
+that exports a <code>foo</code> function. All the symbols are loaded before
 the call returns, by passing the <code>RTLD_NOW</code> constant. In this example
 the constant is assumed to be available.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> os = <span class="hljs-built_in">require</span>(<span class="hljs-string">'os'</span>);
-process.dlopen(<span class="hljs-built_in">module</span>, <span class="hljs-built_in">require</span>.resolve(<span class="hljs-string">'binding'</span>),
-               os.constants.dlopen.RTLD_NOW);
-<span class="hljs-built_in">module</span>.exports.foo();</code></pre>
-<h2><code>process.emitWarning(warning[, options])</code><span><a class="mark" href="#process_process_emitwarning_warning_options" id="process_process_emitwarning_warning_options">#</a></span></h2>
+<span class="hljs-keyword">const</span> path = <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);
+<span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = { <span class="hljs-attr">exports</span>: {} };
+process.<span class="hljs-title function_">dlopen</span>(<span class="hljs-variable language_">module</span>, path.<span class="hljs-title function_">join</span>(__dirname, <span class="hljs-string">'local.node'</span>),
+               os.<span class="hljs-property">constants</span>.<span class="hljs-property">dlopen</span>.<span class="hljs-property">RTLD_NOW</span>);
+<span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span>.<span class="hljs-title function_">foo</span>();</code></pre>
+</section><section><h3><code>process.emitWarning(warning[, options])</code><span><a class="mark" href="#process_process_emitwarning_warning_options" id="process_process_emitwarning_warning_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -998,7 +1079,7 @@ function used to limit the generated stack trace. <strong>Default:</strong>
 specific process warnings. These can be listened for by adding a handler to the
 <a href="#process_event_warning"><code>'warning'</code></a> event.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Emit a warning with a code and additional detail.</span>
-process.emitWarning(<span class="hljs-string">'Something happened!'</span>, {
+process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Something happened!'</span>, {
   <span class="hljs-attr">code</span>: <span class="hljs-string">'MY_WARNING'</span>,
   <span class="hljs-attr">detail</span>: <span class="hljs-string">'This is some additional information'</span>
 });
@@ -1008,15 +1089,15 @@ process.emitWarning(<span class="hljs-string">'Something happened!'</span>, {
 <p>In this example, an <code>Error</code> object is generated internally by
 <code>process.emitWarning()</code> and passed through to the
 <a href="#process_event_warning"><code>'warning'</code></a> handler.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
-  <span class="hljs-built_in">console</span>.warn(warning.name);    <span class="hljs-comment">// 'Warning'</span>
-  <span class="hljs-built_in">console</span>.warn(warning.message); <span class="hljs-comment">// 'Something happened!'</span>
-  <span class="hljs-built_in">console</span>.warn(warning.code);    <span class="hljs-comment">// 'MY_WARNING'</span>
-  <span class="hljs-built_in">console</span>.warn(warning.stack);   <span class="hljs-comment">// Stack trace</span>
-  <span class="hljs-built_in">console</span>.warn(warning.detail);  <span class="hljs-comment">// 'This is some additional information'</span>
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">name</span>);    <span class="hljs-comment">// 'Warning'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">message</span>); <span class="hljs-comment">// 'Something happened!'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">code</span>);    <span class="hljs-comment">// 'MY_WARNING'</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">stack</span>);   <span class="hljs-comment">// Stack trace</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">detail</span>);  <span class="hljs-comment">// 'This is some additional information'</span>
 });</code></pre>
 <p>If <code>warning</code> is passed as an <code>Error</code> object, the <code>options</code> argument is ignored.</p>
-<h2><code>process.emitWarning(warning[, type[, code]][, ctor])</code><span><a class="mark" href="#process_process_emitwarning_warning_type_code_ctor" id="process_process_emitwarning_warning_type_code_ctor">#</a></span></h2>
+</section><section><h3><code>process.emitWarning(warning[, type[, code]][, ctor])</code><span><a class="mark" href="#process_process_emitwarning_warning_type_code_ctor" id="process_process_emitwarning_warning_type_code_ctor">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -1033,32 +1114,32 @@ function used to limit the generated stack trace. <strong>Default:</strong>
 specific process warnings. These can be listened for by adding a handler to the
 <a href="#process_event_warning"><code>'warning'</code></a> event.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Emit a warning using a string.</span>
-process.emitWarning(<span class="hljs-string">'Something happened!'</span>);
+process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Something happened!'</span>);
 <span class="hljs-comment">// Emits: (node: 56338) Warning: Something happened!</span></code></pre>
 <pre><code class="language-js"><span class="hljs-comment">// Emit a warning using a string and a type.</span>
-process.emitWarning(<span class="hljs-string">'Something Happened!'</span>, <span class="hljs-string">'CustomWarning'</span>);
+process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Something Happened!'</span>, <span class="hljs-string">'CustomWarning'</span>);
 <span class="hljs-comment">// Emits: (node:56338) CustomWarning: Something Happened!</span></code></pre>
-<pre><code class="language-js">process.emitWarning(<span class="hljs-string">'Something happened!'</span>, <span class="hljs-string">'CustomWarning'</span>, <span class="hljs-string">'WARN001'</span>);
+<pre><code class="language-js">process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Something happened!'</span>, <span class="hljs-string">'CustomWarning'</span>, <span class="hljs-string">'WARN001'</span>);
 <span class="hljs-comment">// Emits: (node:56338) [WARN001] CustomWarning: Something happened!</span></code></pre>
 <p>In each of the previous examples, an <code>Error</code> object is generated internally by
 <code>process.emitWarning()</code> and passed through to the <a href="#process_event_warning"><code>'warning'</code></a>
 handler.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
-  <span class="hljs-built_in">console</span>.warn(warning.name);
-  <span class="hljs-built_in">console</span>.warn(warning.message);
-  <span class="hljs-built_in">console</span>.warn(warning.code);
-  <span class="hljs-built_in">console</span>.warn(warning.stack);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'warning'</span>, <span class="hljs-function">(<span class="hljs-params">warning</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">name</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">message</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">code</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">warn</span>(warning.<span class="hljs-property">stack</span>);
 });</code></pre>
 <p>If <code>warning</code> is passed as an <code>Error</code> object, it will be passed through to the
 <code>'warning'</code> event handler unmodified (and the optional <code>type</code>,
 <code>code</code> and <code>ctor</code> arguments will be ignored):</p>
 <pre><code class="language-js"><span class="hljs-comment">// Emit a warning using an Error object.</span>
-<span class="hljs-keyword">const</span> myWarning = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'Something happened!'</span>);
+<span class="hljs-keyword">const</span> myWarning = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'Something happened!'</span>);
 <span class="hljs-comment">// Use the Error name property to specify the type name</span>
-myWarning.name = <span class="hljs-string">'CustomWarning'</span>;
-myWarning.code = <span class="hljs-string">'WARN001'</span>;
+myWarning.<span class="hljs-property">name</span> = <span class="hljs-string">'CustomWarning'</span>;
+myWarning.<span class="hljs-property">code</span> = <span class="hljs-string">'WARN001'</span>;
 
-process.emitWarning(myWarning);
+process.<span class="hljs-title function_">emitWarning</span>(myWarning);
 <span class="hljs-comment">// Emits: (node:56338) [WARN001] CustomWarning: Something happened!</span></code></pre>
 <p>A <code>TypeError</code> is thrown if <code>warning</code> is anything other than a string or <code>Error</code>
 object.</p>
@@ -1074,21 +1155,21 @@ warning is suppressed.</li>
 <li>If the <code>--trace-deprecation</code> command-line flag is used, the deprecation
 warning is printed to <code>stderr</code> along with the full stack trace.</li>
 </ul>
-<h3>Avoiding duplicate warnings<span><a class="mark" href="#process_avoiding_duplicate_warnings" id="process_avoiding_duplicate_warnings">#</a></span></h3>
+<h4>Avoiding duplicate warnings<span><a class="mark" href="#process_avoiding_duplicate_warnings" id="process_avoiding_duplicate_warnings">#</a></span></h4>
 <p>As a best practice, warnings should be emitted only once per process. To do
 so, it is recommended to place the <code>emitWarning()</code> behind a simple boolean
 flag as illustrated in the example below:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">emitMyWarning</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">if</span> (!emitMyWarning.warned) {
-    emitMyWarning.warned = <span class="hljs-literal">true</span>;
-    process.emitWarning(<span class="hljs-string">'Only warn once!'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">emitMyWarning</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">if</span> (!emitMyWarning.<span class="hljs-property">warned</span>) {
+    emitMyWarning.<span class="hljs-property">warned</span> = <span class="hljs-literal">true</span>;
+    process.<span class="hljs-title function_">emitWarning</span>(<span class="hljs-string">'Only warn once!'</span>);
   }
 }
-emitMyWarning();
+<span class="hljs-title function_">emitMyWarning</span>();
 <span class="hljs-comment">// Emits: (node: 56339) Warning: Only warn once!</span>
-emitMyWarning();
+<span class="hljs-title function_">emitMyWarning</span>();
 <span class="hljs-comment">// Emits nothing</span></code></pre>
-<h2><code>process.env</code><span><a class="mark" href="#process_process_env" id="process_process_env">#</a></span></h2>
+</section><section><h3><code>process.env</code><span><a class="mark" href="#process_process_env" id="process_process_env">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1125,27 +1206,27 @@ See <a href="http://man7.org/linux/man-pages/man7/environ.7.html"><code>environ(
 reflected outside the Node.js process, or (unless explicitly requested)
 to other <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.
 In other words, the following example would not work:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node -e <span class="hljs-string">'process.env.foo = "bar"'</span> &#x26;&#x26; <span class="hljs-built_in">echo</span> <span class="hljs-variable">$foo</span></span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node -e <span class="hljs-string">'process.env.foo = "bar"'</span> &#x26;&#x26; <span class="hljs-built_in">echo</span> <span class="hljs-variable">$foo</span></span></code></pre>
 <p>While the following will:</p>
-<pre><code class="language-js">process.env.foo = <span class="hljs-string">'bar'</span>;
-<span class="hljs-built_in">console</span>.log(process.env.foo);</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">env</span>.<span class="hljs-property">foo</span> = <span class="hljs-string">'bar'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">foo</span>);</code></pre>
 <p>Assigning a property on <code>process.env</code> will implicitly convert the value
 to a string. <strong>This behavior is deprecated.</strong> Future versions of Node.js may
 throw an error when the value is not a string, number, or boolean.</p>
-<pre><code class="language-js">process.env.test = <span class="hljs-literal">null</span>;
-<span class="hljs-built_in">console</span>.log(process.env.test);
+<pre><code class="language-js">process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span> = <span class="hljs-literal">null</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span>);
 <span class="hljs-comment">// => 'null'</span>
-process.env.test = <span class="hljs-literal">undefined</span>;
-<span class="hljs-built_in">console</span>.log(process.env.test);
+process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span> = <span class="hljs-literal">undefined</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span>);
 <span class="hljs-comment">// => 'undefined'</span></code></pre>
 <p>Use <code>delete</code> to delete a property from <code>process.env</code>.</p>
-<pre><code class="language-js">process.env.TEST = <span class="hljs-number">1</span>;
-<span class="hljs-keyword">delete</span> process.env.TEST;
-<span class="hljs-built_in">console</span>.log(process.env.TEST);
+<pre><code class="language-js">process.<span class="hljs-property">env</span>.<span class="hljs-property">TEST</span> = <span class="hljs-number">1</span>;
+<span class="hljs-keyword">delete</span> process.<span class="hljs-property">env</span>.<span class="hljs-property">TEST</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">TEST</span>);
 <span class="hljs-comment">// => undefined</span></code></pre>
 <p>On Windows operating systems, environment variables are case-insensitive.</p>
-<pre><code class="language-js">process.env.TEST = <span class="hljs-number">1</span>;
-<span class="hljs-built_in">console</span>.log(process.env.test);
+<pre><code class="language-js">process.<span class="hljs-property">env</span>.<span class="hljs-property">TEST</span> = <span class="hljs-number">1</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">test</span>);
 <span class="hljs-comment">// => 1</span></code></pre>
 <p>Unless explicitly specified when creating a <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> instance,
 each <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> thread has its own copy of <code>process.env</code>, based on its
@@ -1153,7 +1234,7 @@ parent thread’s <code>process.env</code>, or whatever was specified as the <co
 to the <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> constructor. Changes to <code>process.env</code> will not be visible
 across <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads, and only the main thread can make changes that
 are visible to the operating system or to native add-ons.</p>
-<h2><code>process.execArgv</code><span><a class="mark" href="#process_process_execargv" id="process_process_execargv">#</a></span></h2>
+</section><section><h3><code>process.execArgv</code><span><a class="mark" href="#process_process_execargv" id="process_process_execargv">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -1166,14 +1247,16 @@ appear in the array returned by the <a href="#process_process_argv"><code>proces
 include the Node.js executable, the name of the script, or any options following
 the script name. These options are useful in order to spawn child processes with
 the same execution environment as the parent.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --harmony script.js --version</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --harmony script.js --version</span></code></pre>
 <p>Results in <code>process.execArgv</code>:</p>
 <!-- eslint-disable semi -->
 <pre><code class="language-js">[<span class="hljs-string">'--harmony'</span>]</code></pre>
 <p>And <code>process.argv</code>:</p>
 <!-- eslint-disable semi -->
 <pre><code class="language-js">[<span class="hljs-string">'/usr/local/bin/node'</span>, <span class="hljs-string">'script.js'</span>, <span class="hljs-string">'--version'</span>]</code></pre>
-<h2><code>process.execPath</code><span><a class="mark" href="#process_process_execpath" id="process_process_execpath">#</a></span></h2>
+<p>Refer to <a href="worker_threads.html#worker_threads_new_worker_filename_options"><code>Worker</code> constructor</a> for the detailed behavior of worker
+threads with this property.</p>
+</section><section><h3><code>process.execPath</code><span><a class="mark" href="#process_process_execpath" id="process_process_execpath">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.100</span>
 </div>
@@ -1184,7 +1267,7 @@ the same execution environment as the parent.</p>
 that started the Node.js process. Symbolic links, if any, are resolved.</p>
 <!-- eslint-disable semi -->
 <pre><code class="language-js"><span class="hljs-string">'/usr/local/bin/node'</span></code></pre>
-<h2><code>process.exit([code])</code><span><a class="mark" href="#process_process_exit_code" id="process_process_exit_code">#</a></span></h2>
+</section><section><h3><code>process.exit([code])</code><span><a class="mark" href="#process_process_exit_code" id="process_process_exit_code">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.13</span>
 </div>
@@ -1197,7 +1280,7 @@ either the 'success' code <code>0</code> or the value of <code>process.exitCode<
 set. Node.js will not terminate until all the <a href="#process_event_exit"><code>'exit'</code></a> event listeners are
 called.</p>
 <p>To exit with a 'failure' code:</p>
-<pre><code class="language-js">process.exit(<span class="hljs-number">1</span>);</code></pre>
+<pre><code class="language-js">process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">1</span>);</code></pre>
 <p>The shell that executed Node.js should see the exit code as <code>1</code>.</p>
 <p>Calling <code>process.exit()</code> will force the process to exit as quickly as possible
 even if there are still asynchronous operations pending that have not yet
@@ -1211,9 +1294,9 @@ tell the process which exit code to use when the process exits gracefully.</p>
 <code>process.exit()</code> method that could lead to data printed to stdout being
 truncated and lost:</p>
 <pre><code class="language-js"><span class="hljs-comment">// This is an example of what *not* to do:</span>
-<span class="hljs-keyword">if</span> (someConditionNotMet()) {
-  printUsageToStdout();
-  process.exit(<span class="hljs-number">1</span>);
+<span class="hljs-keyword">if</span> (<span class="hljs-title function_">someConditionNotMet</span>()) {
+  <span class="hljs-title function_">printUsageToStdout</span>();
+  process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">1</span>);
 }</code></pre>
 <p>The reason this is problematic is because writes to <code>process.stdout</code> in Node.js
 are sometimes <em>asynchronous</em> and may occur over multiple ticks of the Node.js
@@ -1224,16 +1307,16 @@ event loop. Calling <code>process.exit()</code>, however, forces the process to
 scheduling any additional work for the event loop:</p>
 <pre><code class="language-js"><span class="hljs-comment">// How to properly set the exit code while letting</span>
 <span class="hljs-comment">// the process exit gracefully.</span>
-<span class="hljs-keyword">if</span> (someConditionNotMet()) {
-  printUsageToStdout();
-  process.exitCode = <span class="hljs-number">1</span>;
+<span class="hljs-keyword">if</span> (<span class="hljs-title function_">someConditionNotMet</span>()) {
+  <span class="hljs-title function_">printUsageToStdout</span>();
+  process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
 }</code></pre>
 <p>If it is necessary to terminate the Node.js process due to an error condition,
 throwing an <em>uncaught</em> error and allowing the process to terminate accordingly
 is safer than calling <code>process.exit()</code>.</p>
 <p>In <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads, this function stops the current thread rather
 than the current process.</p>
-<h2><code>process.exitCode</code><span><a class="mark" href="#process_process_exitcode" id="process_process_exitcode">#</a></span></h2>
+</section><section><h3><code>process.exitCode</code><span><a class="mark" href="#process_process_exitcode" id="process_process_exitcode">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -1245,18 +1328,18 @@ exits gracefully, or is exited via <a href="#process_process_exit_code"><code>pr
 a code.</p>
 <p>Specifying a code to <a href="#process_process_exit_code"><code>process.exit(code)</code></a> will override any
 previous setting of <code>process.exitCode</code>.</p>
-<h2><code>process.getegid()</code><span><a class="mark" href="#process_process_getegid" id="process_process_getegid">#</a></span></h2>
+</section><section><h3><code>process.getegid()</code><span><a class="mark" href="#process_process_getegid" id="process_process_getegid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
 <p>The <code>process.getegid()</code> method returns the numerical effective group identity
 of the Node.js process. (See <a href="http://man7.org/linux/man-pages/man2/getegid.2.html"><code>getegid(2)</code></a>.)</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getegid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getegid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.geteuid()</code><span><a class="mark" href="#process_process_geteuid" id="process_process_geteuid">#</a></span></h2>
+</section><section><h3><code>process.geteuid()</code><span><a class="mark" href="#process_process_geteuid" id="process_process_geteuid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
@@ -1265,12 +1348,12 @@ Android).</p>
 </ul>
 <p>The <code>process.geteuid()</code> method returns the numerical effective user identity of
 the process. (See <a href="http://man7.org/linux/man-pages/man2/geteuid.2.html"><code>geteuid(2)</code></a>.)</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.geteuid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">geteuid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.getgid()</code><span><a class="mark" href="#process_process_getgid" id="process_process_getgid">#</a></span></h2>
+</section><section><h3><code>process.getgid()</code><span><a class="mark" href="#process_process_getgid" id="process_process_getgid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.31</span>
 </div>
@@ -1279,12 +1362,12 @@ Android).</p>
 </ul>
 <p>The <code>process.getgid()</code> method returns the numerical group identity of the
 process. (See <a href="http://man7.org/linux/man-pages/man2/getgid.2.html"><code>getgid(2)</code></a>.)</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getgid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getgid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.getgroups()</code><span><a class="mark" href="#process_process_getgroups" id="process_process_getgroups">#</a></span></h2>
+</section><section><h3><code>process.getgroups()</code><span><a class="mark" href="#process_process_getgroups" id="process_process_getgroups">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1294,9 +1377,12 @@ Android).</p>
 <p>The <code>process.getgroups()</code> method returns an array with the supplementary group
 IDs. POSIX leaves it unspecified if the effective group ID is included but
 Node.js ensures it always is.</p>
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getgroups</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>()); <span class="hljs-comment">// [ 16, 21, 297 ]</span>
+}</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.getuid()</code><span><a class="mark" href="#process_process_getuid" id="process_process_getuid">#</a></span></h2>
+</section><section><h3><code>process.getuid()</code><span><a class="mark" href="#process_process_getuid" id="process_process_getuid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.28</span>
 </div>
@@ -1305,12 +1391,12 @@ Android).</p>
 </ul>
 <p>The <code>process.getuid()</code> method returns the numeric user identity of the process.
 (See <a href="http://man7.org/linux/man-pages/man2/getuid.2.html"><code>getuid(2)</code></a>.)</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getuid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getuid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).</p>
-<h2><code>process.hasUncaughtExceptionCaptureCallback()</code><span><a class="mark" href="#process_process_hasuncaughtexceptioncapturecallback" id="process_process_hasuncaughtexceptioncapturecallback">#</a></span></h2>
+</section><section><h3><code>process.hasUncaughtExceptionCaptureCallback()</code><span><a class="mark" href="#process_process_hasuncaughtexceptioncapturecallback" id="process_process_hasuncaughtexceptioncapturecallback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.3.0</span>
 </div>
@@ -1318,11 +1404,12 @@ Android).</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Indicates whether a callback has been set using
-<a href="process.html#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a>.</p>
-<h2><code>process.hrtime([time])</code><span><a class="mark" href="#process_process_hrtime_time" id="process_process_hrtime_time">#</a></span></h2>
+<a href="#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a>.</p>
+</section><section><h3><code>process.hrtime([time])</code><span><a class="mark" href="#process_process_hrtime_time" id="process_process_hrtime_time">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.6</span>
 </div>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy. Use <a href="#process_process_hrtime_bigint"><code>process.hrtime.bigint()</code></a> instead.</div><p></p>
 <ul>
 <li><code>time</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer[]></a> The result of a previous call to <code>process.hrtime()</code></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer[]></a></li>
@@ -1340,18 +1427,18 @@ user-defined array instead of the result of a previous call to
 <p>These times are relative to an arbitrary time in the
 past, and not related to the time of day and therefore not subject to clock
 drift. The primary use is for measuring performance between intervals:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> NS_PER_SEC = <span class="hljs-number">1e9</span>;
-<span class="hljs-keyword">const</span> time = process.hrtime();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-variable constant_">NS_PER_SEC</span> = <span class="hljs-number">1e9</span>;
+<span class="hljs-keyword">const</span> time = process.<span class="hljs-title function_">hrtime</span>();
 <span class="hljs-comment">// [ 1800216, 25 ]</span>
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> diff = process.hrtime(time);
+  <span class="hljs-keyword">const</span> diff = process.<span class="hljs-title function_">hrtime</span>(time);
   <span class="hljs-comment">// [ 1, 552 ]</span>
 
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Benchmark took <span class="hljs-subst">${diff[<span class="hljs-number">0</span>] * NS_PER_SEC + diff[<span class="hljs-number">1</span>]}</span> nanoseconds`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Benchmark took <span class="hljs-subst">${diff[<span class="hljs-number">0</span>] * NS_PER_SEC + diff[<span class="hljs-number">1</span>]}</span> nanoseconds`</span>);
   <span class="hljs-comment">// Benchmark took 1000000552 nanoseconds</span>
 }, <span class="hljs-number">1000</span>);</code></pre>
-<h2><code>process.hrtime.bigint()</code><span><a class="mark" href="#process_process_hrtime_bigint" id="process_process_hrtime_bigint">#</a></span></h2>
+</section><section><h3><code>process.hrtime.bigint()</code><span><a class="mark" href="#process_process_hrtime_bigint" id="process_process_hrtime_bigint">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.7.0</span>
 </div>
@@ -1363,17 +1450,17 @@ current high-resolution real time in nanoseconds as a <code>bigint</code>.</p>
 <p>Unlike <a href="#process_process_hrtime_time"><code>process.hrtime()</code></a>, it does not support an additional <code>time</code>
 argument since the difference can just be computed directly
 by subtraction of the two <code>bigint</code>s.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> start = process.hrtime.bigint();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> start = process.<span class="hljs-property">hrtime</span>.<span class="hljs-title function_">bigint</span>();
 <span class="hljs-comment">// 191051479007711n</span>
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> end = process.hrtime.bigint();
+  <span class="hljs-keyword">const</span> end = process.<span class="hljs-property">hrtime</span>.<span class="hljs-title function_">bigint</span>();
   <span class="hljs-comment">// 191052633396993n</span>
 
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Benchmark took <span class="hljs-subst">${end - start}</span> nanoseconds`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Benchmark took <span class="hljs-subst">${end - start}</span> nanoseconds`</span>);
   <span class="hljs-comment">// Benchmark took 1154389282 nanoseconds</span>
 }, <span class="hljs-number">1000</span>);</code></pre>
-<h2><code>process.initgroups(user, extraGroup)</code><span><a class="mark" href="#process_process_initgroups_user_extragroup" id="process_process_initgroups_user_extragroup">#</a></span></h2>
+</section><section><h3><code>process.initgroups(user, extraGroup)</code><span><a class="mark" href="#process_process_initgroups_user_extragroup" id="process_process_initgroups_user_extragroup">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1386,15 +1473,15 @@ the group access list, using all groups of which the user is a member. This is
 a privileged operation that requires that the Node.js process either have <code>root</code>
 access or the <code>CAP_SETGID</code> capability.</p>
 <p>Use care when dropping privileges:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.getgroups());         <span class="hljs-comment">// [ 0 ]</span>
-process.initgroups(<span class="hljs-string">'nodeuser'</span>, <span class="hljs-number">1000</span>);     <span class="hljs-comment">// switch user</span>
-<span class="hljs-built_in">console</span>.log(process.getgroups());         <span class="hljs-comment">// [ 27, 30, 46, 1000, 0 ]</span>
-process.setgid(<span class="hljs-number">1000</span>);                     <span class="hljs-comment">// drop root gid</span>
-<span class="hljs-built_in">console</span>.log(process.getgroups());         <span class="hljs-comment">// [ 27, 30, 46, 1000 ]</span></code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>());         <span class="hljs-comment">// [ 0 ]</span>
+process.<span class="hljs-title function_">initgroups</span>(<span class="hljs-string">'nodeuser'</span>, <span class="hljs-number">1000</span>);     <span class="hljs-comment">// switch user</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>());         <span class="hljs-comment">// [ 27, 30, 46, 1000, 0 ]</span>
+process.<span class="hljs-title function_">setgid</span>(<span class="hljs-number">1000</span>);                     <span class="hljs-comment">// drop root gid</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>());         <span class="hljs-comment">// [ 27, 30, 46, 1000 ]</span></code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.kill(pid[, signal])</code><span><a class="mark" href="#process_process_kill_pid_signal" id="process_process_kill_pid_signal">#</a></span></h2>
+</section><section><h3><code>process.kill(pid[, signal])</code><span><a class="mark" href="#process_process_kill_pid_signal" id="process_process_kill_pid_signal">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.0.6</span>
 </div>
@@ -1414,22 +1501,23 @@ group.</p>
 <p>Even though the name of this function is <code>process.kill()</code>, it is really just a
 signal sender, like the <code>kill</code> system call. The signal sent may do something
 other than kill the target process.</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'SIGHUP'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Got SIGHUP signal.'</span>);
+<pre><code class="language-js">process.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGHUP'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Got SIGHUP signal.'</span>);
 });
 
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Exiting.'</span>);
-  process.exit(<span class="hljs-number">0</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Exiting.'</span>);
+  process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">0</span>);
 }, <span class="hljs-number">100</span>);
 
-process.kill(process.pid, <span class="hljs-string">'SIGHUP'</span>);</code></pre>
+process.<span class="hljs-title function_">kill</span>(process.<span class="hljs-property">pid</span>, <span class="hljs-string">'SIGHUP'</span>);</code></pre>
 <p>When <code>SIGUSR1</code> is received by a Node.js process, Node.js will start the
 debugger. See <a href="#process_signal_events">Signal Events</a>.</p>
-<h2><code>process.mainModule</code><span><a class="mark" href="#process_process_mainmodule" id="process_process_mainmodule">#</a></span></h2>
+</section><section><h3><code>process.mainModule</code><span><a class="mark" href="#process_process_mainmodule" id="process_process_mainmodule">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.1.17</span>
+<span>Added in: v0.1.17</span><span>Deprecated since: v14.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="modules.html#modules_accessing_the_main_module"><code>require.main</code></a> instead.</div><p></p>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
@@ -1440,12 +1528,12 @@ modules that were required before the change occurred. Generally, it's
 safe to assume that the two refer to the same module.</p>
 <p>As with <a href="modules.html#modules_accessing_the_main_module"><code>require.main</code></a>, <code>process.mainModule</code> will be <code>undefined</code> if there
 is no entry script.</p>
-<h2><code>process.memoryUsage()</code><span><a class="mark" href="#process_process_memoryusage" id="process_process_memoryusage">#</a></span></h2>
+</section><section><h3><code>process.memoryUsage()</code><span><a class="mark" href="#process_process_memoryusage" id="process_process_memoryusage">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.9.0</td>
 <td><p>Added <code>arrayBuffers</code> to the returned object.</p></td></tr>
 <tr><td>v7.2.0</td>
 <td><p>Added <code>external</code> to the returned object.</p></td></tr>
@@ -1465,19 +1553,17 @@ is no entry script.</p>
 </ul>
 </li>
 </ul>
-<p>The <code>process.memoryUsage()</code> method returns an object describing the memory usage
-of the Node.js process measured in bytes.</p>
-<p>For example, the code:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.memoryUsage());</code></pre>
-<p>Will generate:</p>
-<!-- eslint-skip -->
-<pre><code class="language-js">{
-  <span class="hljs-attr">rss</span>: <span class="hljs-number">4935680</span>,
-  <span class="hljs-attr">heapTotal</span>: <span class="hljs-number">1826816</span>,
-  <span class="hljs-attr">heapUsed</span>: <span class="hljs-number">650472</span>,
-  <span class="hljs-attr">external</span>: <span class="hljs-number">49879</span>,
-  <span class="hljs-attr">arrayBuffers</span>: <span class="hljs-number">9386</span>
-}</code></pre>
+<p>Returns an object describing the memory usage of the Node.js process measured in
+bytes.</p>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">memoryUsage</span>());
+<span class="hljs-comment">// Prints:</span>
+<span class="hljs-comment">// {</span>
+<span class="hljs-comment">//  rss: 4935680,</span>
+<span class="hljs-comment">//  heapTotal: 1826816,</span>
+<span class="hljs-comment">//  heapUsed: 650472,</span>
+<span class="hljs-comment">//  external: 49879,</span>
+<span class="hljs-comment">//  arrayBuffers: 9386</span>
+<span class="hljs-comment">// }</span></code></pre>
 <ul>
 <li><code>heapTotal</code> and <code>heapUsed</code> refer to V8's memory usage.</li>
 <li><code>external</code> refers to the memory usage of C++ objects bound to JavaScript
@@ -1493,7 +1579,26 @@ may not be tracked in that case.</li>
 </ul>
 <p>When using <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads, <code>rss</code> will be a value that is valid for the
 entire process, while the other fields will only refer to the current thread.</p>
-<h2><code>process.nextTick(callback[, ...args])</code><span><a class="mark" href="#process_process_nexttick_callback_args" id="process_process_nexttick_callback_args">#</a></span></h2>
+<p>The <code>process.memoryUsage()</code> method iterates over each page to gather
+information about memory usage which might be slow depending on the
+program memory allocations.</p>
+</section><section><h3><code>process.memoryUsage.rss()</code><span><a class="mark" href="#process_process_memoryusage_rss" id="process_process_memoryusage_rss">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
+</ul>
+<p>The <code>process.memoryUsage.rss()</code> method returns an integer representing the
+Resident Set Size (RSS) in bytes.</p>
+<p>The Resident Set Size, is the amount of space occupied in the main
+memory device (that is a subset of the total allocated memory) for the
+process, including all C++ and JavaScript objects and code.</p>
+<p>This is the same value as the <code>rss</code> property provided by <code>process.memoryUsage()</code>
+but <code>process.memoryUsage.rss()</code> is faster.</p>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">memoryUsage</span>.<span class="hljs-title function_">rss</span>());
+<span class="hljs-comment">// 35655680</span></code></pre>
+</section><section><h3><code>process.nextTick(callback[, ...args])</code><span><a class="mark" href="#process_process_nexttick_callback_args" id="process_process_nexttick_callback_args">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1514,11 +1619,11 @@ fully drained after the current operation on the JavaScript stack runs to
 completion and before the event loop is allowed to continue. It's possible to
 create an infinite loop if one were to recursively call <code>process.nextTick()</code>.
 See the <a href="https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick">Event Loop</a> guide for more background.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">'start'</span>);
-process.nextTick(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'nextTick callback'</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'start'</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'nextTick callback'</span>);
 });
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">'scheduled'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'scheduled'</span>);
 <span class="hljs-comment">// Output:</span>
 <span class="hljs-comment">// start</span>
 <span class="hljs-comment">// scheduled</span>
@@ -1526,48 +1631,97 @@ process.nextTick(<span class="hljs-function">() =></span> {
 <p>This is important when developing APIs in order to give users the opportunity
 to assign event handlers <em>after</em> an object has been constructed but before any
 I/O has occurred:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyThing</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-built_in">this</span>.setupOptions(options);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">MyThing</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">setupOptions</span>(options);
 
-  process.nextTick(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">this</span>.startDoingStuff();
+  process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">startDoingStuff</span>();
   });
 }
 
-<span class="hljs-keyword">const</span> thing = <span class="hljs-keyword">new</span> MyThing();
-thing.getReadyForStuff();
+<span class="hljs-keyword">const</span> thing = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyThing</span>();
+thing.<span class="hljs-title function_">getReadyForStuff</span>();
 
 <span class="hljs-comment">// thing.startDoingStuff() gets called now, not before.</span></code></pre>
 <p>It is very important for APIs to be either 100% synchronous or 100%
 asynchronous. Consider this example:</p>
 <pre><code class="language-js"><span class="hljs-comment">// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">maybeSync</span>(<span class="hljs-params">arg, cb</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">maybeSync</span>(<span class="hljs-params">arg, cb</span>) {
   <span class="hljs-keyword">if</span> (arg) {
-    cb();
+    <span class="hljs-title function_">cb</span>();
     <span class="hljs-keyword">return</span>;
   }
 
-  fs.stat(<span class="hljs-string">'file'</span>, cb);
+  fs.<span class="hljs-title function_">stat</span>(<span class="hljs-string">'file'</span>, cb);
 }</code></pre>
 <p>This API is hazardous because in the following case:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> maybeTrue = <span class="hljs-built_in">Math</span>.random() > <span class="hljs-number">0.5</span>;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> maybeTrue = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">random</span>() > <span class="hljs-number">0.5</span>;
 
-maybeSync(maybeTrue, <span class="hljs-function">() =></span> {
-  foo();
+<span class="hljs-title function_">maybeSync</span>(maybeTrue, <span class="hljs-function">() =></span> {
+  <span class="hljs-title function_">foo</span>();
 });
 
-bar();</code></pre>
+<span class="hljs-title function_">bar</span>();</code></pre>
 <p>It is not clear whether <code>foo()</code> or <code>bar()</code> will be called first.</p>
 <p>The following approach is much better:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">definitelyAsync</span>(<span class="hljs-params">arg, cb</span>) </span>{
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">definitelyAsync</span>(<span class="hljs-params">arg, cb</span>) {
   <span class="hljs-keyword">if</span> (arg) {
-    process.nextTick(cb);
+    process.<span class="hljs-title function_">nextTick</span>(cb);
     <span class="hljs-keyword">return</span>;
   }
 
-  fs.stat(<span class="hljs-string">'file'</span>, cb);
+  fs.<span class="hljs-title function_">stat</span>(<span class="hljs-string">'file'</span>, cb);
 }</code></pre>
-<h2><code>process.noDeprecation</code><span><a class="mark" href="#process_process_nodeprecation" id="process_process_nodeprecation">#</a></span></h2>
+<h4>When to use <code>queueMicrotask()</code> vs. <code>process.nextTick()</code><span><a class="mark" href="#process_when_to_use_queuemicrotask_vs_process_nexttick" id="process_when_to_use_queuemicrotask_vs_process_nexttick">#</a></span></h4>
+<p>The <a href="globals.html#globals_queuemicrotask_callback"><code>queueMicrotask()</code></a> API is an alternative to <code>process.nextTick()</code> that
+also defers execution of a function using the same microtask queue used to
+execute the then, catch, and finally handlers of resolved promises. Within
+Node.js, every time the "next tick queue" is drained, the microtask queue
+is drained immediately after.</p>
+<pre><code class="language-js"><span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>().<span class="hljs-title function_">then</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-number">2</span>));
+<span class="hljs-title function_">queueMicrotask</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-number">3</span>));
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-number">1</span>));
+<span class="hljs-comment">// Output:</span>
+<span class="hljs-comment">// 1</span>
+<span class="hljs-comment">// 2</span>
+<span class="hljs-comment">// 3</span></code></pre>
+<p>For <em>most</em> userland use cases, the <code>queueMicrotask()</code> API provides a portable
+and reliable mechanism for deferring execution that works across multiple
+JavaScript platform environments and should be favored over <code>process.nextTick()</code>.
+In simple scenarios, <code>queueMicrotask()</code> can be a drop-in replacement for
+<code>process.nextTick()</code>.</p>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'start'</span>);
+<span class="hljs-title function_">queueMicrotask</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'microtask callback'</span>);
+});
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'scheduled'</span>);
+<span class="hljs-comment">// Output:</span>
+<span class="hljs-comment">// start</span>
+<span class="hljs-comment">// scheduled</span>
+<span class="hljs-comment">// microtask callback</span></code></pre>
+<p>One note-worthy difference between the two APIs is that <code>process.nextTick()</code>
+allows specifying additional values that will be passed as arguments to the
+deferred function when it is called. Achieving the same result with
+<code>queueMicrotask()</code> requires using either a closure or a bound function:</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">deferred</span>(<span class="hljs-params">a, b</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'microtask'</span>, a + b);
+}
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'start'</span>);
+<span class="hljs-title function_">queueMicrotask</span>(deferred.<span class="hljs-title function_">bind</span>(<span class="hljs-literal">undefined</span>, <span class="hljs-number">1</span>, <span class="hljs-number">2</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'scheduled'</span>);
+<span class="hljs-comment">// Output:</span>
+<span class="hljs-comment">// start</span>
+<span class="hljs-comment">// scheduled</span>
+<span class="hljs-comment">// microtask 3</span></code></pre>
+<p>There are minor differences in the way errors raised from within the next tick
+queue and microtask queue are handled. Errors thrown within a queued microtask
+callback should be handled within the queued callback when possible. If they are
+not, the <code>process.on('uncaughtException')</code> event handler can be used to capture
+and handle the errors.</p>
+<p>When in doubt, unless the specific capabilities of <code>process.nextTick()</code> are
+needed, use <code>queueMicrotask()</code>.</p>
+</section><section><h3><code>process.noDeprecation</code><span><a class="mark" href="#process_process_nodeprecation" id="process_process_nodeprecation">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
@@ -1579,7 +1733,7 @@ flag is set on the current Node.js process. See the documentation for
 the <a href="#process_event_warning"><code>'warning'</code> event</a> and the
 <a href="#process_process_emitwarning_warning_type_code_ctor"><code>emitWarning()</code> method</a> for more information about this
 flag's behavior.</p>
-<h2><code>process.pid</code><span><a class="mark" href="#process_process_pid" id="process_process_pid">#</a></span></h2>
+</section><section><h3><code>process.pid</code><span><a class="mark" href="#process_process_pid" id="process_process_pid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.15</span>
 </div>
@@ -1587,8 +1741,8 @@ flag's behavior.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>The <code>process.pid</code> property returns the PID of the process.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`This process is pid <span class="hljs-subst">${process.pid}</span>`</span>);</code></pre>
-<h2><code>process.platform</code><span><a class="mark" href="#process_process_platform" id="process_process_platform">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`This process is pid <span class="hljs-subst">${process.pid}</span>`</span>);</code></pre>
+</section><section><h3><code>process.platform</code><span><a class="mark" href="#process_process_platform" id="process_process_platform">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.16</span>
 </div>
@@ -1607,11 +1761,11 @@ system platform on which the Node.js process is running.</p>
 <li><code>'sunos'</code></li>
 <li><code>'win32'</code></li>
 </ul>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`This platform is <span class="hljs-subst">${process.platform}</span>`</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`This platform is <span class="hljs-subst">${process.platform}</span>`</span>);</code></pre>
 <p>The value <code>'android'</code> may also be returned if the Node.js is built on the
 Android operating system. However, Android support in Node.js
-<a href="https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os">is experimental</a>.</p>
-<h2><code>process.ppid</code><span><a class="mark" href="#process_process_ppid" id="process_process_ppid">#</a></span></h2>
+<a href="https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os">is experimental</a>.</p>
+</section><section><h3><code>process.ppid</code><span><a class="mark" href="#process_process_ppid" id="process_process_ppid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.2.0, v8.10.0, v6.13.0</span>
 </div>
@@ -1620,8 +1774,8 @@ Android operating system. However, Android support in Node.js
 </ul>
 <p>The <code>process.ppid</code> property returns the PID of the parent of the
 current process.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`The parent process is pid <span class="hljs-subst">${process.ppid}</span>`</span>);</code></pre>
-<h2><code>process.release</code><span><a class="mark" href="#process_process_release" id="process_process_release">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`The parent process is pid <span class="hljs-subst">${process.ppid}</span>`</span>);</code></pre>
+</section><section><h3><code>process.release</code><span><a class="mark" href="#process_process_release" id="process_process_release">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1641,8 +1795,7 @@ to the current release, including URLs for the source tarball and headers-only
 tarball.</p>
 <p><code>process.release</code> contains the following properties:</p>
 <ul>
-<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A value that will always be <code>'node'</code> for Node.js. For
-legacy io.js releases, this will be <code>'io.js'</code>.</li>
+<li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A value that will always be <code>'node'</code>.</li>
 <li><code>sourceUrl</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing
 the source code of the current release.</li>
 <li><code>headersUrl</code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing
@@ -1656,15 +1809,13 @@ builds of Node.js and will be missing on all other platforms.</em></li>
 <li><code>lts</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> a string label identifying the <a href="https://github.com/nodejs/Release">LTS</a> label for this release.
 This property only exists for LTS releases and is <code>undefined</code> for all other
 release types, including <em>Current</em> releases.
-Valid values include the LTS Release Codenames (including those
-that are no longer supported). A non-exhaustive example of
-these codenames includes:
+Valid values include the LTS Release code names (including those
+that are no longer supported).
 <ul>
 <li><code>'Dubnium'</code> for the 10.x LTS line beginning with 10.13.0.</li>
-<li><code>'Erbium'</code> for the 12.x LTS line beginning with 12.13.0.
-For other LTS Release Codenames, see <a href="https://github.com/nodejs/node/blob/master/doc/changelogs/CHANGELOG_ARCHIVE.md">Node.js Changelog Archive</a></li>
+<li><code>'Erbium'</code> for the 12.x LTS line beginning with 12.13.0.</li>
 </ul>
-</li>
+For other LTS Release code names, see <a href="https://github.com/nodejs/node/blob/HEAD/doc/changelogs/CHANGELOG_ARCHIVE.md">Node.js Changelog Archive</a></li>
 </ul>
 <!-- eslint-skip -->
 <pre><code class="language-js">{
@@ -1677,12 +1828,12 @@ For other LTS Release Codenames, see <a href="https://github.com/nodejs/node/blo
 <p>In custom builds from non-release versions of the source tree, only the
 <code>name</code> property may be present. The additional properties should not be
 relied upon to exist.</p>
-<h2><code>process.report</code><span><a class="mark" href="#process_process_report" id="process_process_report">#</a></span></h2>
+</section><section><h3><code>process.report</code><span><a class="mark" href="#process_process_report" id="process_process_report">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
@@ -1695,9 +1846,9 @@ relied upon to exist.</p>
 <p><code>process.report</code> is an object whose methods are used to generate diagnostic
 reports for the current process. Additional documentation is available in the
 <a href="report.html">report documentation</a>.</p>
-<h3><code>process.report.compact</code><span><a class="mark" href="#process_process_report_compact" id="process_process_report_compact">#</a></span></h3>
+<h4><code>process.report.compact</code><span><a class="mark" href="#process_process_report_compact" id="process_process_report_compact">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.12.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
@@ -1705,13 +1856,13 @@ reports for the current process. Additional documentation is available in the
 <p>Write reports in a compact format, single-line JSON, more easily consumable
 by log processing systems than the default multi-line format designed for
 human consumption.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Reports are compact? <span class="hljs-subst">${process.report.compact}</span>`</span>);</code></pre>
-<h3><code>process.report.directory</code><span><a class="mark" href="#process_process_report_directory" id="process_process_report_directory">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Reports are compact? <span class="hljs-subst">${process.report.compact}</span>`</span>);</code></pre>
+<h4><code>process.report.directory</code><span><a class="mark" href="#process_process_report_directory" id="process_process_report_directory">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -1724,13 +1875,13 @@ human consumption.</p>
 <p>Directory where the report is written. The default value is the empty string,
 indicating that reports are written to the current working directory of the
 Node.js process.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report directory is <span class="hljs-subst">${process.report.directory}</span>`</span>);</code></pre>
-<h3><code>process.report.filename</code><span><a class="mark" href="#process_process_report_filename" id="process_process_report_filename">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report directory is <span class="hljs-subst">${process.report.directory}</span>`</span>);</code></pre>
+<h4><code>process.report.filename</code><span><a class="mark" href="#process_process_report_filename" id="process_process_report_filename">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -1743,13 +1894,13 @@ Node.js process.</p>
 <p>Filename where the report is written. If set to the empty string, the output
 filename will be comprised of a timestamp, PID, and sequence number. The default
 value is the empty string.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report filename is <span class="hljs-subst">${process.report.filename}</span>`</span>);</code></pre>
-<h3><code>process.report.getReport([err])</code><span><a class="mark" href="#process_process_report_getreport_err" id="process_process_report_getreport_err">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report filename is <span class="hljs-subst">${process.report.filename}</span>`</span>);</code></pre>
+<h4><code>process.report.getReport([err])</code><span><a class="mark" href="#process_process_report_getreport_err" id="process_process_report_getreport_err">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
@@ -1763,30 +1914,37 @@ value is the empty string.</p>
 <p>Returns a JavaScript Object representation of a diagnostic report for the
 running process. The report's JavaScript stack trace is taken from <code>err</code>, if
 present.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> data = process.report.getReport();
-<span class="hljs-built_in">console</span>.log(data.header.nodeJsVersion);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> data = process.<span class="hljs-property">report</span>.<span class="hljs-title function_">getReport</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data.<span class="hljs-property">header</span>.<span class="hljs-property">nodejsVersion</span>);
 
 <span class="hljs-comment">// Similar to process.report.writeReport()</span>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-fs.writeFileSync(util.inspect(data), <span class="hljs-string">'my-report.log'</span>, <span class="hljs-string">'utf8'</span>);</code></pre>
+fs.<span class="hljs-title function_">writeFileSync</span>(<span class="hljs-string">'my-report.log'</span>, util.<span class="hljs-title function_">inspect</span>(data), <span class="hljs-string">'utf8'</span>);</code></pre>
 <p>Additional documentation is available in the <a href="report.html">report documentation</a>.</p>
-<h3><code>process.report.reportOnFatalError</code><span><a class="mark" href="#process_process_report_reportonfatalerror" id="process_process_report_reportonfatalerror">#</a></span></h3>
+<h4><code>process.report.reportOnFatalError</code><span><a class="mark" href="#process_process_report_reportonfatalerror" id="process_process_report_reportonfatalerror">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.12.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>This API is no longer experimental.</p></td></tr>
+<tr><td>v11.12.0</td>
+<td><p><span>Added in: v11.12.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
-<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>If <code>true</code>, a diagnostic report is generated on fatal errors, such as out of
 memory errors or failed C++ assertions.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report on fatal error: <span class="hljs-subst">${process.report.reportOnFatalError}</span>`</span>);</code></pre>
-<h3><code>process.report.reportOnSignal</code><span><a class="mark" href="#process_process_report_reportonsignal" id="process_process_report_reportonsignal">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report on fatal error: <span class="hljs-subst">${process.report.reportOnFatalError}</span>`</span>);</code></pre>
+<h4><code>process.report.reportOnSignal</code><span><a class="mark" href="#process_process_report_reportonsignal" id="process_process_report_reportonsignal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -1798,13 +1956,13 @@ memory errors or failed C++ assertions.</p>
 </ul>
 <p>If <code>true</code>, a diagnostic report is generated when the process receives the
 signal specified by <code>process.report.signal</code>.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report on signal: <span class="hljs-subst">${process.report.reportOnSignal}</span>`</span>);</code></pre>
-<h3><code>process.report.reportOnUncaughtException</code><span><a class="mark" href="#process_process_report_reportonuncaughtexception" id="process_process_report_reportonuncaughtexception">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report on signal: <span class="hljs-subst">${process.report.reportOnSignal}</span>`</span>);</code></pre>
+<h4><code>process.report.reportOnUncaughtException</code><span><a class="mark" href="#process_process_report_reportonuncaughtexception" id="process_process_report_reportonuncaughtexception">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -1815,13 +1973,13 @@ signal specified by <code>process.report.signal</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>If <code>true</code>, a diagnostic report is generated on uncaught exception.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report on exception: <span class="hljs-subst">${process.report.reportOnUncaughtException}</span>`</span>);</code></pre>
-<h3><code>process.report.signal</code><span><a class="mark" href="#process_process_report_signal" id="process_process_report_signal">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report on exception: <span class="hljs-subst">${process.report.reportOnUncaughtException}</span>`</span>);</code></pre>
+<h4><code>process.report.signal</code><span><a class="mark" href="#process_process_report_signal" id="process_process_report_signal">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.12.0</td>
 <td><p><span>Added in: v11.12.0</span></p></td></tr>
@@ -1833,13 +1991,13 @@ signal specified by <code>process.report.signal</code>.</p>
 </ul>
 <p>The signal used to trigger the creation of a diagnostic report. Defaults to
 <code>'SIGUSR2'</code>.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Report signal: <span class="hljs-subst">${process.report.signal}</span>`</span>);</code></pre>
-<h3><code>process.report.writeReport([filename][, err])</code><span><a class="mark" href="#process_process_report_writereport_filename_err" id="process_process_report_writereport_filename_err">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Report signal: <span class="hljs-subst">${process.report.signal}</span>`</span>);</code></pre>
+<h4><code>process.report.writeReport([filename][, err])</code><span><a class="mark" href="#process_process_report_writereport_filename_err" id="process_process_report_writereport_filename_err">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>This API is no longer experimental.</p></td></tr>
 <tr><td>v11.8.0</td>
 <td><p><span>Added in: v11.8.0</span></p></td></tr>
@@ -1863,9 +2021,9 @@ process, if unspecified.</p>
 <p>Writes a diagnostic report to a file. If <code>filename</code> is not provided, the default
 filename includes the date, time, PID, and a sequence number. The report's
 JavaScript stack trace is taken from <code>err</code>, if present.</p>
-<pre><code class="language-js">process.report.writeReport();</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>();</code></pre>
 <p>Additional documentation is available in the <a href="report.html">report documentation</a>.</p>
-<h2><code>process.resourceUsage()</code><span><a class="mark" href="#process_process_resourceusage" id="process_process_resourceusage">#</a></span></h2>
+</section><section><h3><code>process.resourceUsage()</code><span><a class="mark" href="#process_process_resourceusage" id="process_process_resourceusage">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v12.6.0</span>
 </div>
@@ -1916,7 +2074,7 @@ time slice. This field is not supported on Windows.</li>
 </ul>
 </li>
 </ul>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.resourceUsage());
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">resourceUsage</span>());
 <span class="hljs-comment">/*
   Will output:
   {
@@ -1938,7 +2096,7 @@ time slice. This field is not supported on Windows.</li>
     involuntaryContextSwitches: 1
   }
 */</span></code></pre>
-<h2><code>process.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#process_process_send_message_sendhandle_options_callback" id="process_process_send_message_sendhandle_options_callback">#</a></span></h2>
+</section><section><h3><code>process.send(message[, sendHandle[, options]][, callback])</code><span><a class="mark" href="#process_process_send_message_sendhandle_options_callback" id="process_process_send_message_sendhandle_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.9</span>
 </div>
@@ -1963,7 +2121,7 @@ used to send messages to the parent process. Messages will be received as a
 <code>undefined</code>.</p>
 <p>The message goes through serialization and parsing. The resulting message might
 not be the same as what is originally sent.</p>
-<h2><code>process.setegid(id)</code><span><a class="mark" href="#process_process_setegid_id" id="process_process_setegid_id">#</a></span></h2>
+</section><section><h3><code>process.setegid(id)</code><span><a class="mark" href="#process_process_setegid_id" id="process_process_setegid_id">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
@@ -1974,19 +2132,19 @@ not be the same as what is originally sent.</p>
 (See <a href="http://man7.org/linux/man-pages/man2/setegid.2.html"><code>setegid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a group
 name string. If a group name is specified, this method blocks while resolving
 the associated a numeric ID.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getegid &#x26;&#x26; process.setegid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getegid</span> &#x26;&#x26; process.<span class="hljs-property">setegid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
   <span class="hljs-keyword">try</span> {
-    process.setegid(<span class="hljs-number">501</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
+    process.<span class="hljs-title function_">setegid</span>(<span class="hljs-number">501</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New gid: <span class="hljs-subst">${process.getegid()}</span>`</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Failed to set gid: <span class="hljs-subst">${err}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set gid: <span class="hljs-subst">${err}</span>`</span>);
   }
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.seteuid(id)</code><span><a class="mark" href="#process_process_seteuid_id" id="process_process_seteuid_id">#</a></span></h2>
+</section><section><h3><code>process.seteuid(id)</code><span><a class="mark" href="#process_process_seteuid_id" id="process_process_seteuid_id">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v2.0.0</span>
 </div>
@@ -1997,19 +2155,19 @@ This feature is not available in <a href="worker_threads.html#worker_threads_cla
 (See <a href="http://man7.org/linux/man-pages/man2/seteuid.2.html"><code>seteuid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a username
 string. If a username is specified, the method blocks while resolving the
 associated numeric ID.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.geteuid &#x26;&#x26; process.seteuid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">geteuid</span> &#x26;&#x26; process.<span class="hljs-property">seteuid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
   <span class="hljs-keyword">try</span> {
-    process.seteuid(<span class="hljs-number">501</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
+    process.<span class="hljs-title function_">seteuid</span>(<span class="hljs-number">501</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New uid: <span class="hljs-subst">${process.geteuid()}</span>`</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Failed to set uid: <span class="hljs-subst">${err}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set uid: <span class="hljs-subst">${err}</span>`</span>);
   }
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.setgid(id)</code><span><a class="mark" href="#process_process_setgid_id" id="process_process_setgid_id">#</a></span></h2>
+</section><section><h3><code>process.setgid(id)</code><span><a class="mark" href="#process_process_setgid_id" id="process_process_setgid_id">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.31</span>
 </div>
@@ -2020,19 +2178,19 @@ This feature is not available in <a href="worker_threads.html#worker_threads_cla
 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html"><code>setgid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a group name
 string. If a group name is specified, this method blocks while resolving the
 associated numeric ID.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getgid &#x26;&#x26; process.setgid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getgid</span> &#x26;&#x26; process.<span class="hljs-property">setgid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
   <span class="hljs-keyword">try</span> {
-    process.setgid(<span class="hljs-number">501</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
+    process.<span class="hljs-title function_">setgid</span>(<span class="hljs-number">501</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New gid: <span class="hljs-subst">${process.getgid()}</span>`</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Failed to set gid: <span class="hljs-subst">${err}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set gid: <span class="hljs-subst">${err}</span>`</span>);
   }
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.setgroups(groups)</code><span><a class="mark" href="#process_process_setgroups_groups" id="process_process_setgroups_groups">#</a></span></h2>
+</section><section><h3><code>process.setgroups(groups)</code><span><a class="mark" href="#process_process_setgroups_groups" id="process_process_setgroups_groups">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -2042,11 +2200,19 @@ This feature is not available in <a href="worker_threads.html#worker_threads_cla
 <p>The <code>process.setgroups()</code> method sets the supplementary group IDs for the
 Node.js process. This is a privileged operation that requires the Node.js
 process to have <code>root</code> or the <code>CAP_SETGID</code> capability.</p>
-<p>The <code>groups</code> array can contain numeric group IDs, group names or both.</p>
+<p>The <code>groups</code> array can contain numeric group IDs, group names, or both.</p>
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getgroups</span> &#x26;&#x26; process.<span class="hljs-property">setgroups</span>) {
+  <span class="hljs-keyword">try</span> {
+    process.<span class="hljs-title function_">setgroups</span>([<span class="hljs-number">501</span>]);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-title function_">getgroups</span>()); <span class="hljs-comment">// new groups</span>
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set groups: <span class="hljs-subst">${err}</span>`</span>);
+  }
+}</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.setuid(id)</code><span><a class="mark" href="#process_process_setuid_id" id="process_process_setuid_id">#</a></span></h2>
+</section><section><h3><code>process.setuid(id)</code><span><a class="mark" href="#process_process_setuid_id" id="process_process_setuid_id">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.28</span>
 </div>
@@ -2057,19 +2223,33 @@ This feature is not available in <a href="worker_threads.html#worker_threads_cla
 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html"><code>setuid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a username string.
 If a username is specified, the method blocks while resolving the associated
 numeric ID.</p>
-<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.getuid &#x26;&#x26; process.setuid) {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">if</span> (process.<span class="hljs-property">getuid</span> &#x26;&#x26; process.<span class="hljs-property">setuid</span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Current uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
   <span class="hljs-keyword">try</span> {
-    process.setuid(<span class="hljs-number">501</span>);
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`New uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
+    process.<span class="hljs-title function_">setuid</span>(<span class="hljs-number">501</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`New uid: <span class="hljs-subst">${process.getuid()}</span>`</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Failed to set uid: <span class="hljs-subst">${err}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Failed to set uid: <span class="hljs-subst">${err}</span>`</span>);
   }
 }</code></pre>
 <p>This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2><code>process.setUncaughtExceptionCaptureCallback(fn)</code><span><a class="mark" href="#process_process_setuncaughtexceptioncapturecallback_fn" id="process_process_setuncaughtexceptioncapturecallback_fn">#</a></span></h2>
+</section><section><h3><code>process.setSourceMapsEnabled(val)</code><span><a class="mark" href="#process_process_setsourcemapsenabled_val" id="process_process_setsourcemapsenabled_val">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<ul>
+<li><code>val</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>This function enables or disables the <a href="https://sourcemaps.info/spec.html">Source Map v3</a> support for
+stack traces.</p>
+<p>It provides same features as launching Node.js process with commandline options
+<code>--enable-source-maps</code>.</p>
+<p>Only source maps in JavaScript files that are loaded after source maps has been
+enabled will be parsed and loaded.</p>
+</section><section><h3><code>process.setUncaughtExceptionCaptureCallback(fn)</code><span><a class="mark" href="#process_process_setuncaughtexceptioncapturecallback_fn" id="process_process_setuncaughtexceptioncapturecallback_fn">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.3.0</span>
 </div>
@@ -2082,14 +2262,15 @@ exception value itself as its first argument.</p>
 <p>If such a function is set, the <a href="#process_event_uncaughtexception"><code>'uncaughtException'</code></a> event will
 not be emitted. If <code>--abort-on-uncaught-exception</code> was passed from the
 command line or set through <a href="v8.html#v8_v8_setflagsfromstring_flags"><code>v8.setFlagsFromString()</code></a>, the process will
-not abort.</p>
+not abort. Actions configured to take place on exceptions such as report
+generations will be affected too</p>
 <p>To unset the capture function,
 <code>process.setUncaughtExceptionCaptureCallback(null)</code> may be used. Calling this
 method with a non-<code>null</code> argument while another capture function is set will
 throw an error.</p>
 <p>Using this function is mutually exclusive with using the deprecated
 <a href="domain.html"><code>domain</code></a> built-in module.</p>
-<h2><code>process.stderr</code><span><a class="mark" href="#process_process_stderr" id="process_process_stderr">#</a></span></h2>
+</section><section><h3><code>process.stderr</code><span><a class="mark" href="#process_process_stderr" id="process_process_stderr">#</a></span></h3>
 <ul>
 <li><a href="stream.html#stream_stream" class="type">&#x3C;Stream></a></li>
 </ul>
@@ -2098,15 +2279,15 @@ throw an error.</p>
 stream) unless fd <code>2</code> refers to a file, in which case it is
 a <a href="stream.html#stream_writable_streams">Writable</a> stream.</p>
 <p><code>process.stderr</code> differs from other Node.js streams in important ways. See
-<a href="process.html#process_a_note_on_process_i_o">note on process I/O</a> for more information.</p>
-<h3><code>process.stderr.fd</code><span><a class="mark" href="#process_process_stderr_fd" id="process_process_stderr_fd">#</a></span></h3>
+<a href="#process_a_note_on_process_i_o">note on process I/O</a> for more information.</p>
+<h4><code>process.stderr.fd</code><span><a class="mark" href="#process_process_stderr_fd" id="process_process_stderr_fd">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>This property refers to the value of underlying file descriptor of
 <code>process.stderr</code>. The value is fixed at <code>2</code>. In <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads,
 this field does not exist.</p>
-<h2><code>process.stdin</code><span><a class="mark" href="#process_process_stdin" id="process_process_stdin">#</a></span></h2>
+</section><section><h3><code>process.stdin</code><span><a class="mark" href="#process_process_stdin" id="process_process_stdin">#</a></span></h3>
 <ul>
 <li><a href="stream.html#stream_stream" class="type">&#x3C;Stream></a></li>
 </ul>
@@ -2121,14 +2302,14 @@ For more information see <a href="stream.html#stream_compatibility_with_older_no
 <p>In "old" streams mode the <code>stdin</code> stream is paused by default, so one
 must call <code>process.stdin.resume()</code> to read from it. Note also that calling
 <code>process.stdin.resume()</code> itself would switch stream to "old" mode.</p>
-<h3><code>process.stdin.fd</code><span><a class="mark" href="#process_process_stdin_fd" id="process_process_stdin_fd">#</a></span></h3>
+<h4><code>process.stdin.fd</code><span><a class="mark" href="#process_process_stdin_fd" id="process_process_stdin_fd">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>This property refers to the value of underlying file descriptor of
 <code>process.stdin</code>. The value is fixed at <code>0</code>. In <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads,
 this field does not exist.</p>
-<h2><code>process.stdout</code><span><a class="mark" href="#process_process_stdout" id="process_process_stdout">#</a></span></h2>
+</section><section><h3><code>process.stdout</code><span><a class="mark" href="#process_process_stdout" id="process_process_stdout">#</a></span></h3>
 <ul>
 <li><a href="stream.html#stream_stream" class="type">&#x3C;Stream></a></li>
 </ul>
@@ -2137,17 +2318,17 @@ this field does not exist.</p>
 stream) unless fd <code>1</code> refers to a file, in which case it is
 a <a href="stream.html#stream_writable_streams">Writable</a> stream.</p>
 <p>For example, to copy <code>process.stdin</code> to <code>process.stdout</code>:</p>
-<pre><code class="language-js">process.stdin.pipe(process.stdout);</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
 <p><code>process.stdout</code> differs from other Node.js streams in important ways. See
-<a href="process.html#process_a_note_on_process_i_o">note on process I/O</a> for more information.</p>
-<h3><code>process.stdout.fd</code><span><a class="mark" href="#process_process_stdout_fd" id="process_process_stdout_fd">#</a></span></h3>
+<a href="#process_a_note_on_process_i_o">note on process I/O</a> for more information.</p>
+<h4><code>process.stdout.fd</code><span><a class="mark" href="#process_process_stdout_fd" id="process_process_stdout_fd">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>This property refers to the value of underlying file descriptor of
 <code>process.stdout</code>. The value is fixed at <code>1</code>. In <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads,
 this field does not exist.</p>
-<h3>A note on process I/O<span><a class="mark" href="#process_a_note_on_process_i_o" id="process_a_note_on_process_i_o">#</a></span></h3>
+<h4>A note on process I/O<span><a class="mark" href="#process_a_note_on_process_i_o" id="process_a_note_on_process_i_o">#</a></span></h4>
 <p><code>process.stdout</code> and <code>process.stderr</code> differ from other Node.js streams in
 important ways:</p>
 <ol>
@@ -2168,7 +2349,7 @@ create backward incompatibility, but they are also expected by some users.</p>
 <code>console.error()</code> being unexpectedly interleaved, or not written at all if
 <code>process.exit()</code> is called before an asynchronous write completes. See
 <a href="#process_process_exit_code"><code>process.exit()</code></a> for more information.</p>
-<p><strong><em>Warning</em></strong>: Synchronous writes block the event loop until the write has
+<p><em><strong>Warning</strong></em>: Synchronous writes block the event loop until the write has
 completed. This can be near instantaneous in the case of output to a file, but
 under high system load, pipes that are not being read at the receiving end, or
 with slow terminals or file systems, its possible for the event loop to be
@@ -2179,16 +2360,16 @@ the process output streams.</p>
 <p>To check if a stream is connected to a <a href="tty.html#tty_tty">TTY</a> context, check the <code>isTTY</code>
 property.</p>
 <p>For instance:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node -p <span class="hljs-string">"Boolean(process.stdin.isTTY)"</span></span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node -p <span class="hljs-string">"Boolean(process.stdin.isTTY)"</span></span>
 true
-<span class="hljs-meta">$</span><span class="bash"> <span class="hljs-built_in">echo</span> <span class="hljs-string">"foo"</span> | node -p <span class="hljs-string">"Boolean(process.stdin.isTTY)"</span></span>
+<span class="hljs-meta">$ </span><span class="language-bash"><span class="hljs-built_in">echo</span> <span class="hljs-string">"foo"</span> | node -p <span class="hljs-string">"Boolean(process.stdin.isTTY)"</span></span>
 false
-<span class="hljs-meta">$</span><span class="bash"> node -p <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span></span>
+<span class="hljs-meta">$ </span><span class="language-bash">node -p <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span></span>
 true
-<span class="hljs-meta">$</span><span class="bash"> node -p <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span> | cat</span>
+<span class="hljs-meta">$ </span><span class="language-bash">node -p <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span> | cat</span>
 false</code></pre>
 <p>See the <a href="tty.html#tty_tty">TTY</a> documentation for more information.</p>
-<h2><code>process.throwDeprecation</code><span><a class="mark" href="#process_process_throwdeprecation" id="process_process_throwdeprecation">#</a></span></h2>
+</section><section><h3><code>process.throwDeprecation</code><span><a class="mark" href="#process_process_throwdeprecation" id="process_process_throwdeprecation">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.9.12</span>
 </div>
@@ -2201,20 +2382,20 @@ false</code></pre>
 warnings result in errors may be altered at runtime. See the
 documentation for the <a href="#process_event_warning"><code>'warning'</code> event</a> and the
 <a href="#process_process_emitwarning_warning_type_code_ctor"><code>emitWarning()</code> method</a> for more information.</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node --throw-deprecation -p <span class="hljs-string">"process.throwDeprecation"</span></span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node --throw-deprecation -p <span class="hljs-string">"process.throwDeprecation"</span></span>
 true
-<span class="hljs-meta">$</span><span class="bash"> node -p <span class="hljs-string">"process.throwDeprecation"</span></span>
+<span class="hljs-meta">$ </span><span class="language-bash">node -p <span class="hljs-string">"process.throwDeprecation"</span></span>
 undefined
-<span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> process.emitWarning(<span class="hljs-string">'test'</span>, <span class="hljs-string">'DeprecationWarning'</span>);</span>
+<span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.emitWarning(<span class="hljs-string">'test'</span>, <span class="hljs-string">'DeprecationWarning'</span>);</span>
 undefined
-<span class="hljs-meta">></span><span class="bash"> (node:26598) DeprecationWarning: <span class="hljs-built_in">test</span></span>
-<span class="hljs-meta">></span><span class="bash"> process.throwDeprecation = <span class="hljs-literal">true</span>;</span>
+<span class="hljs-meta">> </span><span class="language-bash">(node:26598) DeprecationWarning: <span class="hljs-built_in">test</span></span>
+<span class="hljs-meta">> </span><span class="language-bash">process.throwDeprecation = <span class="hljs-literal">true</span>;</span>
 true
-<span class="hljs-meta">></span><span class="bash"> process.emitWarning(<span class="hljs-string">'test'</span>, <span class="hljs-string">'DeprecationWarning'</span>);</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.emitWarning(<span class="hljs-string">'test'</span>, <span class="hljs-string">'DeprecationWarning'</span>);</span>
 Thrown:
 [DeprecationWarning: test] { name: 'DeprecationWarning' }</code></pre>
-<h2><code>process.title</code><span><a class="mark" href="#process_process_title" id="process_process_title">#</a></span></h2>
+</section><section><h3><code>process.title</code><span><a class="mark" href="#process_process_title" id="process_process_title">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.104</span>
 </div>
@@ -2227,7 +2408,7 @@ the current value of <code>ps</code>.</p>
 <p>When a new value is assigned, different platforms will impose different maximum
 length restrictions on the title. Usually such restrictions are quite limited.
 For instance, on Linux and macOS, <code>process.title</code> is limited to the size of the
-binary name plus the length of the command line arguments because setting the
+binary name plus the length of the command-line arguments because setting the
 <code>process.title</code> overwrites the <code>argv</code> memory of the process. Node.js v0.8
 allowed for longer process title strings by also overwriting the <code>environ</code>
 memory but that was potentially insecure and confusing in some (rather obscure)
@@ -2235,7 +2416,7 @@ cases.</p>
 <p>Assigning a value to <code>process.title</code> might not result in an accurate label
 within process manager applications such as macOS Activity Monitor or Windows
 Services Manager.</p>
-<h2><code>process.traceDeprecation</code><span><a class="mark" href="#process_process_tracedeprecation" id="process_process_tracedeprecation">#</a></span></h2>
+</section><section><h3><code>process.traceDeprecation</code><span><a class="mark" href="#process_process_tracedeprecation" id="process_process_tracedeprecation">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.8.0</span>
 </div>
@@ -2247,12 +2428,12 @@ Services Manager.</p>
 documentation for the <a href="#process_event_warning"><code>'warning'</code> event</a> and the
 <a href="#process_process_emitwarning_warning_type_code_ctor"><code>emitWarning()</code> method</a> for more information about this
 flag's behavior.</p>
-<h2><code>process.umask()</code><span><a class="mark" href="#process_process_umask" id="process_process_umask">#</a></span></h2>
+</section><section><h3><code>process.umask()</code><span><a class="mark" href="#process_process_umask" id="process_process_umask">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0, v14.0.0</td>
+<tr><td>v14.0.0, v12.19.0</td>
 <td><p>Calling <code>process.umask()</code> with no arguments is deprecated.</p></td></tr>
 <tr><td>v0.1.19</td>
 <td><p><span>Added in: v0.1.19</span></p></td></tr>
@@ -2265,7 +2446,7 @@ between threads, and is a potential security vulnerability. There is no safe,
 cross-platform alternative API.</div><p></p>
 <p><code>process.umask()</code> returns the Node.js process's file mode creation mask. Child
 processes inherit the mask from the parent process.</p>
-<h2><code>process.umask(mask)</code><span><a class="mark" href="#process_process_umask_mask" id="process_process_umask_mask">#</a></span></h2>
+</section><section><h3><code>process.umask(mask)</code><span><a class="mark" href="#process_process_umask_mask" id="process_process_umask_mask">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.19</span>
 </div>
@@ -2275,12 +2456,12 @@ processes inherit the mask from the parent process.</p>
 <p><code>process.umask(mask)</code> sets the Node.js process's file mode creation mask. Child
 processes inherit the mask from the parent process. Returns the previous mask.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> newmask = <span class="hljs-number">0o022</span>;
-<span class="hljs-keyword">const</span> oldmask = process.umask(newmask);
-<span class="hljs-built_in">console</span>.log(
+<span class="hljs-keyword">const</span> oldmask = process.<span class="hljs-title function_">umask</span>(newmask);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
   <span class="hljs-string">`Changed umask from <span class="hljs-subst">${oldmask.toString(<span class="hljs-number">8</span>)}</span> to <span class="hljs-subst">${newmask.toString(<span class="hljs-number">8</span>)}</span>`</span>
 );</code></pre>
 <p>In <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads, <code>process.umask(mask)</code> will throw an exception.</p>
-<h2><code>process.uptime()</code><span><a class="mark" href="#process_process_uptime" id="process_process_uptime">#</a></span></h2>
+</section><section><h3><code>process.uptime()</code><span><a class="mark" href="#process_process_uptime" id="process_process_uptime">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.0</span>
 </div>
@@ -2291,7 +2472,7 @@ processes inherit the mask from the parent process. Returns the previous mask.</
 process has been running.</p>
 <p>The return value includes fractions of a second. Use <code>Math.floor()</code> to get whole
 seconds.</p>
-<h2><code>process.version</code><span><a class="mark" href="#process_process_version" id="process_process_version">#</a></span></h2>
+</section><section><h3><code>process.version</code><span><a class="mark" href="#process_process_version" id="process_process_version">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.3</span>
 </div>
@@ -2299,11 +2480,11 @@ seconds.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The <code>process.version</code> property contains the Node.js version string.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Version: <span class="hljs-subst">${process.version}</span>`</span>);
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Version: <span class="hljs-subst">${process.version}</span>`</span>);
 <span class="hljs-comment">// Version: v14.8.0</span></code></pre>
 <p>To get the version string without the prepended <em>v</em>, use
 <code>process.versions.node</code>.</p>
-<h2><code>process.versions</code><span><a class="mark" href="#process_process_versions" id="process_process_versions">#</a></span></h2>
+</section><section><h3><code>process.versions</code><span><a class="mark" href="#process_process_versions" id="process_process_versions">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2324,7 +2505,7 @@ seconds.</p>
 Node.js and its dependencies. <code>process.versions.modules</code> indicates the current
 ABI version, which is increased whenever a C++ API changes. Node.js will refuse
 to load modules that were compiled against a different module ABI version.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(process.versions);</code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">versions</span>);</code></pre>
 <p>Will generate an object similar to:</p>
 <pre><code class="language-console">{ node: '11.13.0',
   v8: '7.0.276.38-node.18',
@@ -2336,13 +2517,12 @@ to load modules that were compiled against a different module ABI version.</p>
   nghttp2: '1.34.0',
   napi: '4',
   llhttp: '1.1.1',
-  http_parser: '2.8.0',
   openssl: '1.1.1b',
   cldr: '34.0',
   icu: '63.1',
   tz: '2018e',
   unicode: '11.0' }</code></pre>
-<h2>Exit codes<span><a class="mark" href="#process_exit_codes" id="process_exit_codes">#</a></span></h2>
+</section><section><h3>Exit codes<span><a class="mark" href="#process_exit_codes" id="process_exit_codes">#</a></span></h3>
 <p>Node.js will normally exit with a <code>0</code> status code when no more async
 operations are pending. The following status codes are used in other
 cases:</p>
@@ -2379,6 +2559,8 @@ when the bootstrapping function was called. This is extremely rare,
 and generally can only happen during development of Node.js itself.</li>
 <li><code>12</code> <strong>Invalid Debug Argument</strong>: The <code>--inspect</code> and/or <code>--inspect-brk</code>
 options were set, but the port number chosen was invalid or unavailable.</li>
+<li><code>13</code> <strong>Unfinished Top-Level Await</strong>: <code>await</code> was used outside of a function
+in the top-level code, but the passed <code>Promise</code> never resolved.</li>
 <li><code>>128</code> <strong>Signal Exits</strong>: If Node.js receives a fatal signal such as
 <code>SIGKILL</code> or <code>SIGHUP</code>, then its exit code will be <code>128</code> plus the
 value of the signal code. This is a standard POSIX practice, since
@@ -2386,10 +2568,46 @@ exit codes are defined to be 7-bit integers, and signal exits set
 the high-order bit, and then contain the value of the signal code.
 For example, signal <code>SIGABRT</code> has value <code>6</code>, so the expected exit
 code will be <code>128</code> + <code>6</code>, or <code>134</code>.</li>
-</ul>
+</ul></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/process.json b/doc/api/process.json
index 4e170c856d1bf41e45139f15d8dffa748c9c26b4..8fdaad49045433055421674ceb49b4a7b2f9261d 100644
--- a/doc/api/process.json
+++ b/doc/api/process.json
@@ -7,7 +7,7 @@
       "name": "Process",
       "introduced_in": "v0.10.0",
       "type": "global",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/process.js\">lib/process.js</a></p>\n<p>The <code>process</code> object is a <code>global</code> that provides information about, and control\nover, the current Node.js process. As a global, it is always available to\nNode.js applications without using <code>require()</code>. It can also be explicitly\naccessed using <code>require()</code>:</p>\n<pre><code class=\"language-js\">const process = require('process');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/process.js\">lib/process.js</a></p>\n<p>The <code>process</code> object is a <code>global</code> that provides information about, and control\nover, the current Node.js process. As a global, it is always available to\nNode.js applications without using <code>require()</code>. It can also be explicitly\naccessed using <code>require()</code>:</p>\n<pre><code class=\"language-js\">const process = require('process');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Process events",
@@ -147,7 +147,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.0.0",
+                    "version": [
+                      "v12.0.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/26599",
                     "description": "Added the `origin` argument."
                   }
@@ -161,10 +164,10 @@
                   "desc": "The uncaught exception."
                 },
                 {
-                  "textRaw": "`origin` {string} Indicates if the exception originates from an unhandled rejection or from an synchronous error. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` and an unhandled rejection.",
+                  "textRaw": "`origin` {string} Indicates if the exception originates from an unhandled rejection or from an synchronous error. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` or `throw` and an unhandled rejection.",
                   "name": "origin",
                   "type": "string",
-                  "desc": "Indicates if the exception originates from an unhandled rejection or from an synchronous error. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` and an unhandled rejection."
+                  "desc": "Indicates if the exception originates from an unhandled rejection or from an synchronous error. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` or `throw` and an unhandled rejection."
                 }
               ],
               "desc": "<p>The <code>'uncaughtException'</code> event is emitted when an uncaught JavaScript\nexception bubbles all the way back to the event loop. By default, Node.js\nhandles such exceptions by printing the stack trace to <code>stderr</code> and exiting\nwith code 1, overriding any previously set <a href=\"#process_process_exitcode\"><code>process.exitCode</code></a>.\nAdding a handler for the <code>'uncaughtException'</code> event overrides this default\nbehavior. Alternatively, change the <a href=\"#process_process_exitcode\"><code>process.exitCode</code></a> in the\n<code>'uncaughtException'</code> handler which will result in the process exiting with the\nprovided exit code. Otherwise, in the presence of such handler the process will\nexit with 0.</p>\n<pre><code class=\"language-js\">process.on('uncaughtException', (err, origin) => {\n  fs.writeSync(\n    process.stderr.fd,\n    `Caught exception: ${err}\\n` +\n    `Exception origin: ${origin}`\n  );\n});\n\nsetTimeout(() => {\n  console.log('This will still run.');\n}, 500);\n\n// Intentionally cause an exception, but don't catch it.\nnonexistentFunc();\nconsole.log('This will not run.');\n</code></pre>\n<p>It is possible to monitor <code>'uncaughtException'</code> events without overriding the\ndefault behavior to exit the process by installing a\n<code>'uncaughtExceptionMonitor'</code> listener.</p>",
@@ -184,7 +187,7 @@
               "name": "uncaughtExceptionMonitor",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.7.0"
                 ],
                 "changes": []
               },
@@ -196,13 +199,13 @@
                   "desc": "The uncaught exception."
                 },
                 {
-                  "textRaw": "`origin` {string} Indicates if the exception originates from an unhandled rejection or from synchronous errors. Can either be `'uncaughtException'` or `'unhandledRejection'`.",
+                  "textRaw": "`origin` {string} Indicates if the exception originates from an unhandled rejection or from synchronous errors. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` or `throw` and an unhandled rejection.",
                   "name": "origin",
                   "type": "string",
-                  "desc": "Indicates if the exception originates from an unhandled rejection or from synchronous errors. Can either be `'uncaughtException'` or `'unhandledRejection'`."
+                  "desc": "Indicates if the exception originates from an unhandled rejection or from synchronous errors. Can either be `'uncaughtException'` or `'unhandledRejection'`. The latter is only used in conjunction with the [`--unhandled-rejections`][] flag set to `strict` or `throw` and an unhandled rejection."
                 }
               ],
-              "desc": "<p>The <code>'uncaughtExceptionMonitor'</code> event is emitted before an\n<code>'uncaughtException'</code> event is emitted or a hook installed via\n<a href=\"process.html#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a> is called.</p>\n<p>Installing an <code>'uncaughtExceptionMonitor'</code> listener does not change the behavior\nonce an <code>'uncaughtException'</code> event is emitted. The process will\nstill crash if no <code>'uncaughtException'</code> listener is installed.</p>\n<pre><code class=\"language-js\">process.on('uncaughtExceptionMonitor', (err, origin) => {\n  MyMonitoringTool.logSync(err, origin);\n});\n\n// Intentionally cause an exception, but don't catch it.\nnonexistentFunc();\n// Still crashes Node.js\n</code></pre>"
+              "desc": "<p>The <code>'uncaughtExceptionMonitor'</code> event is emitted before an\n<code>'uncaughtException'</code> event is emitted or a hook installed via\n<a href=\"#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a> is called.</p>\n<p>Installing an <code>'uncaughtExceptionMonitor'</code> listener does not change the behavior\nonce an <code>'uncaughtException'</code> event is emitted. The process will\nstill crash if no <code>'uncaughtException'</code> listener is installed.</p>\n<pre><code class=\"language-js\">process.on('uncaughtExceptionMonitor', (err, origin) => {\n  MyMonitoringTool.logSync(err, origin);\n});\n\n// Intentionally cause an exception, but don't catch it.\nnonexistentFunc();\n// Still crashes Node.js\n</code></pre>"
             },
             {
               "textRaw": "Event: `'unhandledRejection'`",
@@ -280,7 +283,27 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>'warning'</code> event is emitted whenever Node.js emits a process warning.</p>\n<p>A process warning is similar to an error in that it describes exceptional\nconditions that are being brought to the user's attention. However, warnings\nare not part of the normal Node.js and JavaScript error handling flow.\nNode.js can emit warnings whenever it detects bad coding practices that could\nlead to sub-optimal application performance, bugs, or security vulnerabilities.</p>\n<pre><code class=\"language-js\">process.on('warning', (warning) => {\n  console.warn(warning.name);    // Print the warning name\n  console.warn(warning.message); // Print the warning message\n  console.warn(warning.stack);   // Print the stack trace\n});\n</code></pre>\n<p>By default, Node.js will print process warnings to <code>stderr</code>. The <code>--no-warnings</code>\ncommand-line option can be used to suppress the default console output but the\n<code>'warning'</code> event will still be emitted by the <code>process</code> object.</p>\n<p>The following example illustrates the warning that is printed to <code>stderr</code> when\ntoo many listeners have been added to an event:</p>\n<pre><code class=\"language-console\">$ node\n> events.defaultMaxListeners = 1;\n> process.on('foo', () => {});\n> process.on('foo', () => {});\n> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak\ndetected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit\n</code></pre>\n<p>In contrast, the following example turns off the default warning output and\nadds a custom handler to the <code>'warning'</code> event:</p>\n<pre><code class=\"language-console\">$ node --no-warnings\n> const p = process.on('warning', (warning) => console.warn('Do not do that!'));\n> events.defaultMaxListeners = 1;\n> process.on('foo', () => {});\n> process.on('foo', () => {});\n> Do not do that!\n</code></pre>\n<p>The <code>--trace-warnings</code> command-line option can be used to have the default\nconsole output for warnings include the full stack trace of the warning.</p>\n<p>Launching Node.js using the <code>--throw-deprecation</code> command line flag will\ncause custom deprecation warnings to be thrown as exceptions.</p>\n<p>Using the <code>--trace-deprecation</code> command line flag will cause the custom\ndeprecation to be printed to <code>stderr</code> along with the stack trace.</p>\n<p>Using the <code>--no-deprecation</code> command line flag will suppress all reporting\nof the custom deprecation.</p>\n<p>The <code>*-deprecation</code> command line flags only affect warnings that use the name\n<code>'DeprecationWarning'</code>.</p>",
+              "desc": "<p>The <code>'warning'</code> event is emitted whenever Node.js emits a process warning.</p>\n<p>A process warning is similar to an error in that it describes exceptional\nconditions that are being brought to the user's attention. However, warnings\nare not part of the normal Node.js and JavaScript error handling flow.\nNode.js can emit warnings whenever it detects bad coding practices that could\nlead to sub-optimal application performance, bugs, or security vulnerabilities.</p>\n<pre><code class=\"language-js\">process.on('warning', (warning) => {\n  console.warn(warning.name);    // Print the warning name\n  console.warn(warning.message); // Print the warning message\n  console.warn(warning.stack);   // Print the stack trace\n});\n</code></pre>\n<p>By default, Node.js will print process warnings to <code>stderr</code>. The <code>--no-warnings</code>\ncommand-line option can be used to suppress the default console output but the\n<code>'warning'</code> event will still be emitted by the <code>process</code> object.</p>\n<p>The following example illustrates the warning that is printed to <code>stderr</code> when\ntoo many listeners have been added to an event:</p>\n<pre><code class=\"language-console\">$ node\n> events.defaultMaxListeners = 1;\n> process.on('foo', () => {});\n> process.on('foo', () => {});\n> (node:38638) MaxListenersExceededWarning: Possible EventEmitter memory leak\ndetected. 2 foo listeners added. Use emitter.setMaxListeners() to increase limit\n</code></pre>\n<p>In contrast, the following example turns off the default warning output and\nadds a custom handler to the <code>'warning'</code> event:</p>\n<pre><code class=\"language-console\">$ node --no-warnings\n> const p = process.on('warning', (warning) => console.warn('Do not do that!'));\n> events.defaultMaxListeners = 1;\n> process.on('foo', () => {});\n> process.on('foo', () => {});\n> Do not do that!\n</code></pre>\n<p>The <code>--trace-warnings</code> command-line option can be used to have the default\nconsole output for warnings include the full stack trace of the warning.</p>\n<p>Launching Node.js using the <code>--throw-deprecation</code> command-line flag will\ncause custom deprecation warnings to be thrown as exceptions.</p>\n<p>Using the <code>--trace-deprecation</code> command-line flag will cause the custom\ndeprecation to be printed to <code>stderr</code> along with the stack trace.</p>\n<p>Using the <code>--no-deprecation</code> command-line flag will suppress all reporting\nof the custom deprecation.</p>\n<p>The <code>*-deprecation</code> command-line flags only affect warnings that use the name\n<code>'DeprecationWarning'</code>.</p>"
+            },
+            {
+              "textRaw": "Event: `'worker'`",
+              "type": "event",
+              "name": "worker",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "params": [
+                {
+                  "textRaw": "`worker` {Worker} The {Worker} that was created.",
+                  "name": "worker",
+                  "type": "Worker",
+                  "desc": "The {Worker} that was created."
+                }
+              ],
+              "desc": "<p>The <code>'worker'</code> event is emitted after a new <a href=\"worker_threads.html#worker_threads_class_worker\" class=\"type\">&lt;Worker&gt;</a> thread has been created.</p>",
               "modules": [
                 {
                   "textRaw": "Emitting custom warnings",
@@ -288,6 +311,13 @@
                   "desc": "<p>See the <a href=\"#process_process_emitwarning_warning_type_code_ctor\"><code>process.emitWarning()</code></a> method for issuing\ncustom or application-specific warnings.</p>",
                   "type": "module",
                   "displayName": "Emitting custom warnings"
+                },
+                {
+                  "textRaw": "Node.js warning names",
+                  "name": "node.js_warning_names",
+                  "desc": "<p>There are no strict guidelines for warning types (as identified by the <code>name</code>\nproperty) emitted by Node.js. New types of warnings can be added at any time.\nA few of the warning types that are most common include:</p>\n<ul>\n<li><code>'DeprecationWarning'</code> - Indicates use of a deprecated Node.js API or feature.\nSuch warnings must include a <code>'code'</code> property identifying the\n<a href=\"deprecations.html\">deprecation code</a>.</li>\n<li><code>'ExperimentalWarning'</code> - Indicates use of an experimental Node.js API or\nfeature. Such features must be used with caution as they may change at any\ntime and are not subject to the same strict semantic-versioning and long-term\nsupport policies as supported features.</li>\n<li><code>'MaxListenersExceededWarning'</code> - Indicates that too many listeners for a\ngiven event have been registered on either an <code>EventEmitter</code> or <code>EventTarget</code>.\nThis is often an indication of a memory leak.</li>\n<li><code>'TimeoutOverflowWarning'</code> - Indicates that a numeric value that cannot fit\nwithin a 32-bit signed integer has been provided to either the <code>setTimeout()</code>\nor <code>setInterval()</code> functions.</li>\n<li><code>'UnsupportedWarning'</code> - Indicates use of an unsupported option or feature\nthat will be ignored rather than treated as an error. One example is use of\nthe HTTP response status message when using the HTTP/2 compatibility API.</li>\n</ul>",
+                  "type": "module",
+                  "displayName": "Node.js warning names"
                 }
               ]
             },
@@ -296,7 +326,7 @@
               "name": "SIGINT, SIGHUP, etc.",
               "type": "event",
               "params": [],
-              "desc": "<p>Signal events will be emitted when the Node.js process receives a signal. Please\nrefer to <a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a> for a listing of standard POSIX signal names such as\n<code>'SIGINT'</code>, <code>'SIGHUP'</code>, etc.</p>\n<p>Signals are not available on <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>\n<p>The signal handler will receive the signal's name (<code>'SIGINT'</code>,\n<code>'SIGTERM'</code>, etc.) as the first argument.</p>\n<p>The name of each event will be the uppercase common name for the signal (e.g.\n<code>'SIGINT'</code> for <code>SIGINT</code> signals).</p>\n<pre><code class=\"language-js\">// Begin reading from stdin so the process does not exit.\nprocess.stdin.resume();\n\nprocess.on('SIGINT', () => {\n  console.log('Received SIGINT. Press Control-D to exit.');\n});\n\n// Using a single function to handle multiple signals\nfunction handle(signal) {\n  console.log(`Received ${signal}`);\n}\n\nprocess.on('SIGINT', handle);\nprocess.on('SIGTERM', handle);\n</code></pre>\n<ul>\n<li><code>'SIGUSR1'</code> is reserved by Node.js to start the <a href=\"debugger.html\">debugger</a>. It's possible to\ninstall a listener but doing so might interfere with the debugger.</li>\n<li><code>'SIGTERM'</code> and <code>'SIGINT'</code> have default handlers on non-Windows platforms that\nreset the terminal mode before exiting with code <code>128 + signal number</code>. If one\nof these signals has a listener installed, its default behavior will be\nremoved (Node.js will no longer exit).</li>\n<li><code>'SIGPIPE'</code> is ignored by default. It can have a listener installed.</li>\n<li><code>'SIGHUP'</code> is generated on Windows when the console window is closed, and on\nother platforms under various similar conditions. See <a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a>. It can have a\nlistener installed, however Node.js will be unconditionally terminated by\nWindows about 10 seconds later. On non-Windows platforms, the default\nbehavior of <code>SIGHUP</code> is to terminate Node.js, but once a listener has been\ninstalled its default behavior will be removed.</li>\n<li><code>'SIGTERM'</code> is not supported on Windows, it can be listened on.</li>\n<li><code>'SIGINT'</code> from the terminal is supported on all platforms, and can usually be\ngenerated with <kbd>Ctrl</kbd>+<kbd>C</kbd> (though this may be configurable).\nIt is not generated when <a href=\"tty.html#tty_readstream_setrawmode_mode\">terminal raw mode</a> is enabled and\n<kbd>Ctrl</kbd>+<kbd>C</kbd> is used.</li>\n<li><code>'SIGBREAK'</code> is delivered on Windows when <kbd>Ctrl</kbd>+<kbd>Break</kbd> is\npressed. On non-Windows platforms, it can be listened on, but there is no way\nto send or generate it.</li>\n<li><code>'SIGWINCH'</code> is delivered when the console has been resized. On Windows, this\nwill only happen on write to the console when the cursor is being moved, or\nwhen a readable tty is used in raw mode.</li>\n<li><code>'SIGKILL'</code> cannot have a listener installed, it will unconditionally\nterminate Node.js on all platforms.</li>\n<li><code>'SIGSTOP'</code> cannot have a listener installed.</li>\n<li><code>'SIGBUS'</code>, <code>'SIGFPE'</code>, <code>'SIGSEGV'</code> and <code>'SIGILL'</code>, when not raised\n artificially using <a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a>, inherently leave the process in a state from\n which it is not safe to attempt to call JS listeners. Doing so might lead to\n the process hanging in an endless loop, since listeners attached using\n <code>process.on()</code> are called asynchronously and therefore unable to correct the\nunderlying problem.</li>\n<li><code>0</code> can be sent to test for the existence of a process, it has no effect if\nthe process exists, but will throw an error if the process does not exist.</li>\n</ul>\n<p>Windows does not support signals so has no equivalent to termination by signal,\nbut Node.js offers some emulation with <a href=\"#process_process_kill_pid_signal\"><code>process.kill()</code></a>, and\n<a href=\"child_process.html#child_process_subprocess_kill_signal\"><code>subprocess.kill()</code></a>:</p>\n<ul>\n<li>Sending <code>SIGINT</code>, <code>SIGTERM</code>, and <code>SIGKILL</code> will cause the unconditional\ntermination of the target process, and afterwards, subprocess will report that\nthe process was terminated by signal.</li>\n<li>Sending signal <code>0</code> can be used as a platform independent way to test for the\nexistence of a process.</li>\n</ul>"
+              "desc": "<p>Signal events will be emitted when the Node.js process receives a signal. Please\nrefer to <a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a> for a listing of standard POSIX signal names such as\n<code>'SIGINT'</code>, <code>'SIGHUP'</code>, etc.</p>\n<p>Signals are not available on <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>\n<p>The signal handler will receive the signal's name (<code>'SIGINT'</code>,\n<code>'SIGTERM'</code>, etc.) as the first argument.</p>\n<p>The name of each event will be the uppercase common name for the signal (e.g.\n<code>'SIGINT'</code> for <code>SIGINT</code> signals).</p>\n<pre><code class=\"language-js\">// Begin reading from stdin so the process does not exit.\nprocess.stdin.resume();\n\nprocess.on('SIGINT', () => {\n  console.log('Received SIGINT. Press Control-D to exit.');\n});\n\n// Using a single function to handle multiple signals\nfunction handle(signal) {\n  console.log(`Received ${signal}`);\n}\n\nprocess.on('SIGINT', handle);\nprocess.on('SIGTERM', handle);\n</code></pre>\n<ul>\n<li><code>'SIGUSR1'</code> is reserved by Node.js to start the <a href=\"debugger.html\">debugger</a>. It's possible to\ninstall a listener but doing so might interfere with the debugger.</li>\n<li><code>'SIGTERM'</code> and <code>'SIGINT'</code> have default handlers on non-Windows platforms that\nreset the terminal mode before exiting with code <code>128 + signal number</code>. If one\nof these signals has a listener installed, its default behavior will be\nremoved (Node.js will no longer exit).</li>\n<li><code>'SIGPIPE'</code> is ignored by default. It can have a listener installed.</li>\n<li><code>'SIGHUP'</code> is generated on Windows when the console window is closed, and on\nother platforms under various similar conditions. See <a href=\"http://man7.org/linux/man-pages/man7/signal.7.html\"><code>signal(7)</code></a>. It can have a\nlistener installed, however Node.js will be unconditionally terminated by\nWindows about 10 seconds later. On non-Windows platforms, the default\nbehavior of <code>SIGHUP</code> is to terminate Node.js, but once a listener has been\ninstalled its default behavior will be removed.</li>\n<li><code>'SIGTERM'</code> is not supported on Windows, it can be listened on.</li>\n<li><code>'SIGINT'</code> from the terminal is supported on all platforms, and can usually be\ngenerated with <kbd>Ctrl</kbd>+<kbd>C</kbd> (though this may be configurable).\nIt is not generated when <a href=\"tty.html#tty_readstream_setrawmode_mode\">terminal raw mode</a> is enabled and\n<kbd>Ctrl</kbd>+<kbd>C</kbd> is used.</li>\n<li><code>'SIGBREAK'</code> is delivered on Windows when <kbd>Ctrl</kbd>+<kbd>Break</kbd> is\npressed. On non-Windows platforms, it can be listened on, but there is no way\nto send or generate it.</li>\n<li><code>'SIGWINCH'</code> is delivered when the console has been resized. On Windows, this\nwill only happen on write to the console when the cursor is being moved, or\nwhen a readable tty is used in raw mode.</li>\n<li><code>'SIGKILL'</code> cannot have a listener installed, it will unconditionally\nterminate Node.js on all platforms.</li>\n<li><code>'SIGSTOP'</code> cannot have a listener installed.</li>\n<li><code>'SIGBUS'</code>, <code>'SIGFPE'</code>, <code>'SIGSEGV'</code> and <code>'SIGILL'</code>, when not raised\nartificially using <a href=\"http://man7.org/linux/man-pages/man2/kill.2.html\"><code>kill(2)</code></a>, inherently leave the process in a state from\nwhich it is not safe to call JS listeners. Doing so might cause the process\nto stop responding.</li>\n<li><code>0</code> can be sent to test for the existence of a process, it has no effect if\nthe process exists, but will throw an error if the process does not exist.</li>\n</ul>\n<p>Windows does not support signals so has no equivalent to termination by signal,\nbut Node.js offers some emulation with <a href=\"#process_process_kill_pid_signal\"><code>process.kill()</code></a>, and\n<a href=\"child_process.html#child_process_subprocess_kill_signal\"><code>subprocess.kill()</code></a>:</p>\n<ul>\n<li>Sending <code>SIGINT</code>, <code>SIGTERM</code>, and <code>SIGKILL</code> will cause the unconditional\ntermination of the target process, and afterwards, subprocess will report that\nthe process was terminated by signal.</li>\n<li>Sending signal <code>0</code> can be used as a platform independent way to test for the\nexistence of a process.</li>\n</ul>"
             }
           ],
           "type": "module",
@@ -305,7 +335,7 @@
         {
           "textRaw": "Exit codes",
           "name": "exit_codes",
-          "desc": "<p>Node.js will normally exit with a <code>0</code> status code when no more async\noperations are pending. The following status codes are used in other\ncases:</p>\n<ul>\n<li><code>1</code> <strong>Uncaught Fatal Exception</strong>: There was an uncaught exception,\nand it was not handled by a domain or an <a href=\"#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event\nhandler.</li>\n<li><code>2</code>: Unused (reserved by Bash for builtin misuse)</li>\n<li><code>3</code> <strong>Internal JavaScript Parse Error</strong>: The JavaScript source code\ninternal in the Node.js bootstrapping process caused a parse error. This\nis extremely rare, and generally can only happen during development\nof Node.js itself.</li>\n<li><code>4</code> <strong>Internal JavaScript Evaluation Failure</strong>: The JavaScript\nsource code internal in the Node.js bootstrapping process failed to\nreturn a function value when evaluated. This is extremely rare, and\ngenerally can only happen during development of Node.js itself.</li>\n<li><code>5</code> <strong>Fatal Error</strong>: There was a fatal unrecoverable error in V8.\nTypically a message will be printed to stderr with the prefix <code>FATAL ERROR</code>.</li>\n<li><code>6</code> <strong>Non-function Internal Exception Handler</strong>: There was an\nuncaught exception, but the internal fatal exception handler\nfunction was somehow set to a non-function, and could not be called.</li>\n<li><code>7</code> <strong>Internal Exception Handler Run-Time Failure</strong>: There was an\nuncaught exception, and the internal fatal exception handler\nfunction itself threw an error while attempting to handle it. This\ncan happen, for example, if an <a href=\"#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> or\n<code>domain.on('error')</code> handler throws an error.</li>\n<li><code>8</code>: Unused. In previous versions of Node.js, exit code 8 sometimes\nindicated an uncaught exception.</li>\n<li><code>9</code> <strong>Invalid Argument</strong>: Either an unknown option was specified,\nor an option requiring a value was provided without a value.</li>\n<li><code>10</code> <strong>Internal JavaScript Run-Time Failure</strong>: The JavaScript\nsource code internal in the Node.js bootstrapping process threw an error\nwhen the bootstrapping function was called. This is extremely rare,\nand generally can only happen during development of Node.js itself.</li>\n<li><code>12</code> <strong>Invalid Debug Argument</strong>: The <code>--inspect</code> and/or <code>--inspect-brk</code>\noptions were set, but the port number chosen was invalid or unavailable.</li>\n<li><code>>128</code> <strong>Signal Exits</strong>: If Node.js receives a fatal signal such as\n<code>SIGKILL</code> or <code>SIGHUP</code>, then its exit code will be <code>128</code> plus the\nvalue of the signal code. This is a standard POSIX practice, since\nexit codes are defined to be 7-bit integers, and signal exits set\nthe high-order bit, and then contain the value of the signal code.\nFor example, signal <code>SIGABRT</code> has value <code>6</code>, so the expected exit\ncode will be <code>128</code> + <code>6</code>, or <code>134</code>.</li>\n</ul>",
+          "desc": "<p>Node.js will normally exit with a <code>0</code> status code when no more async\noperations are pending. The following status codes are used in other\ncases:</p>\n<ul>\n<li><code>1</code> <strong>Uncaught Fatal Exception</strong>: There was an uncaught exception,\nand it was not handled by a domain or an <a href=\"#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event\nhandler.</li>\n<li><code>2</code>: Unused (reserved by Bash for builtin misuse)</li>\n<li><code>3</code> <strong>Internal JavaScript Parse Error</strong>: The JavaScript source code\ninternal in the Node.js bootstrapping process caused a parse error. This\nis extremely rare, and generally can only happen during development\nof Node.js itself.</li>\n<li><code>4</code> <strong>Internal JavaScript Evaluation Failure</strong>: The JavaScript\nsource code internal in the Node.js bootstrapping process failed to\nreturn a function value when evaluated. This is extremely rare, and\ngenerally can only happen during development of Node.js itself.</li>\n<li><code>5</code> <strong>Fatal Error</strong>: There was a fatal unrecoverable error in V8.\nTypically a message will be printed to stderr with the prefix <code>FATAL ERROR</code>.</li>\n<li><code>6</code> <strong>Non-function Internal Exception Handler</strong>: There was an\nuncaught exception, but the internal fatal exception handler\nfunction was somehow set to a non-function, and could not be called.</li>\n<li><code>7</code> <strong>Internal Exception Handler Run-Time Failure</strong>: There was an\nuncaught exception, and the internal fatal exception handler\nfunction itself threw an error while attempting to handle it. This\ncan happen, for example, if an <a href=\"#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> or\n<code>domain.on('error')</code> handler throws an error.</li>\n<li><code>8</code>: Unused. In previous versions of Node.js, exit code 8 sometimes\nindicated an uncaught exception.</li>\n<li><code>9</code> <strong>Invalid Argument</strong>: Either an unknown option was specified,\nor an option requiring a value was provided without a value.</li>\n<li><code>10</code> <strong>Internal JavaScript Run-Time Failure</strong>: The JavaScript\nsource code internal in the Node.js bootstrapping process threw an error\nwhen the bootstrapping function was called. This is extremely rare,\nand generally can only happen during development of Node.js itself.</li>\n<li><code>12</code> <strong>Invalid Debug Argument</strong>: The <code>--inspect</code> and/or <code>--inspect-brk</code>\noptions were set, but the port number chosen was invalid or unavailable.</li>\n<li><code>13</code> <strong>Unfinished Top-Level Await</strong>: <code>await</code> was used outside of a function\nin the top-level code, but the passed <code>Promise</code> never resolved.</li>\n<li><code>>128</code> <strong>Signal Exits</strong>: If Node.js receives a fatal signal such as\n<code>SIGKILL</code> or <code>SIGHUP</code>, then its exit code will be <code>128</code> plus the\nvalue of the signal code. This is a standard POSIX practice, since\nexit codes are defined to be 7-bit integers, and signal exits set\nthe high-order bit, and then contain the value of the signal code.\nFor example, signal <code>SIGABRT</code> has value <code>6</code>, so the expected exit\ncode will be <code>128</code> + <code>6</code>, or <code>134</code>.</li>\n</ul>",
           "type": "module",
           "displayName": "Exit codes"
         }
@@ -469,7 +499,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>process.dlopen()</code> method allows to dynamically load shared\nobjects. It is primarily used by <code>require()</code> to load\nC++ Addons, and should not be used directly, except in special\ncases. In other words, <a href=\"globals.html#globals_require\"><code>require()</code></a> should be preferred over\n<code>process.dlopen()</code>, unless there are specific reasons.</p>\n<p>The <code>flags</code> argument is an integer that allows to specify dlopen\nbehavior. See the <a href=\"os.html#os_dlopen_constants\"><code>os.constants.dlopen</code></a> documentation for details.</p>\n<p>If there are specific reasons to use <code>process.dlopen()</code> (for instance,\nto specify dlopen flags), it's often useful to use <a href=\"modules.html#modules_require_resolve_request_options\"><code>require.resolve()</code></a>\nto look up the module's path.</p>\n<p>An important drawback when calling <code>process.dlopen()</code> is that the <code>module</code>\ninstance must be passed. Functions exported by the C++ Addon will be accessible\nvia <code>module.exports</code>.</p>\n<p>The example below shows how to load a C++ Addon, named as <code>binding</code>,\nthat exports a <code>foo</code> function. All the symbols will be loaded before\nthe call returns, by passing the <code>RTLD_NOW</code> constant. In this example\nthe constant is assumed to be available.</p>\n<pre><code class=\"language-js\">const os = require('os');\nprocess.dlopen(module, require.resolve('binding'),\n               os.constants.dlopen.RTLD_NOW);\nmodule.exports.foo();\n</code></pre>"
+          "desc": "<p>The <code>process.dlopen()</code> method allows dynamically loading shared objects. It is\nprimarily used by <code>require()</code> to load C++ Addons, and should not be used\ndirectly, except in special cases. In other words, <a href=\"globals.html#globals_require\"><code>require()</code></a> should be\npreferred over <code>process.dlopen()</code> unless there are specific reasons such as\ncustom dlopen flags or loading from ES modules.</p>\n<p>The <code>flags</code> argument is an integer that allows to specify dlopen\nbehavior. See the <a href=\"os.html#os_dlopen_constants\"><code>os.constants.dlopen</code></a> documentation for details.</p>\n<p>An important requirement when calling <code>process.dlopen()</code> is that the <code>module</code>\ninstance must be passed. Functions exported by the C++ Addon are then\naccessible via <code>module.exports</code>.</p>\n<p>The example below shows how to load a C++ Addon, named <code>local.node</code>,\nthat exports a <code>foo</code> function. All the symbols are loaded before\nthe call returns, by passing the <code>RTLD_NOW</code> constant. In this example\nthe constant is assumed to be available.</p>\n<pre><code class=\"language-js\">const os = require('os');\nconst path = require('path');\nconst module = { exports: {} };\nprocess.dlopen(module, path.join(__dirname, 'local.node'),\n               os.constants.dlopen.RTLD_NOW);\nmodule.exports.foo();\n</code></pre>"
         },
         {
           "textRaw": "`process.emitWarning(warning[, options])`",
@@ -687,7 +717,7 @@
               "params": []
             }
           ],
-          "desc": "<p>The <code>process.getgroups()</code> method returns an array with the supplementary group\nIDs. POSIX leaves it unspecified if the effective group ID is included but\nNode.js ensures it always is.</p>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).</p>"
+          "desc": "<p>The <code>process.getgroups()</code> method returns an array with the supplementary group\nIDs. POSIX leaves it unspecified if the effective group ID is included but\nNode.js ensures it always is.</p>\n<pre><code class=\"language-js\">if (process.getgroups) {\n  console.log(process.getgroups()); // [ 16, 21, 297 ]\n}\n</code></pre>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).</p>"
         },
         {
           "textRaw": "`process.getuid()`",
@@ -731,7 +761,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Indicates whether a callback has been set using\n<a href=\"process.html#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a>.</p>"
+          "desc": "<p>Indicates whether a callback has been set using\n<a href=\"#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a>.</p>"
         },
         {
           "textRaw": "`process.hrtime([time])`",
@@ -743,6 +773,8 @@
             ],
             "changes": []
           },
+          "stability": 3,
+          "stabilityText": "Legacy. Use [`process.hrtime.bigint()`][] instead.",
           "signatures": [
             {
               "return": {
@@ -855,7 +887,7 @@
             ],
             "changes": [
               {
-                "version": "v12.17.0",
+                "version": "v13.9.0",
                 "pr-url": "https://github.com/nodejs/node/pull/31550",
                 "description": "Added `arrayBuffers` to the returned object."
               },
@@ -903,7 +935,29 @@
               "params": []
             }
           ],
-          "desc": "<p>The <code>process.memoryUsage()</code> method returns an object describing the memory usage\nof the Node.js process measured in bytes.</p>\n<p>For example, the code:</p>\n<pre><code class=\"language-js\">console.log(process.memoryUsage());\n</code></pre>\n<p>Will generate:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  rss: 4935680,\n  heapTotal: 1826816,\n  heapUsed: 650472,\n  external: 49879,\n  arrayBuffers: 9386\n}\n</code></pre>\n<ul>\n<li><code>heapTotal</code> and <code>heapUsed</code> refer to V8's memory usage.</li>\n<li><code>external</code> refers to the memory usage of C++ objects bound to JavaScript\nobjects managed by V8.</li>\n<li><code>rss</code>, Resident Set Size, is the amount of space occupied in the main\nmemory device (that is a subset of the total allocated memory) for the\nprocess, including all C++ and JavaScript objects and code.</li>\n<li><code>arrayBuffers</code> refers to memory allocated for <code>ArrayBuffer</code>s and\n<code>SharedArrayBuffer</code>s, including all Node.js <a href=\"buffer.html\"><code>Buffer</code></a>s.\nThis is also included in the <code>external</code> value. When Node.js is used as an\nembedded library, this value may be <code>0</code> because allocations for <code>ArrayBuffer</code>s\nmay not be tracked in that case.</li>\n</ul>\n<p>When using <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads, <code>rss</code> will be a value that is valid for the\nentire process, while the other fields will only refer to the current thread.</p>"
+          "desc": "<p>Returns an object describing the memory usage of the Node.js process measured in\nbytes.</p>\n<pre><code class=\"language-js\">console.log(process.memoryUsage());\n// Prints:\n// {\n//  rss: 4935680,\n//  heapTotal: 1826816,\n//  heapUsed: 650472,\n//  external: 49879,\n//  arrayBuffers: 9386\n// }\n</code></pre>\n<ul>\n<li><code>heapTotal</code> and <code>heapUsed</code> refer to V8's memory usage.</li>\n<li><code>external</code> refers to the memory usage of C++ objects bound to JavaScript\nobjects managed by V8.</li>\n<li><code>rss</code>, Resident Set Size, is the amount of space occupied in the main\nmemory device (that is a subset of the total allocated memory) for the\nprocess, including all C++ and JavaScript objects and code.</li>\n<li><code>arrayBuffers</code> refers to memory allocated for <code>ArrayBuffer</code>s and\n<code>SharedArrayBuffer</code>s, including all Node.js <a href=\"buffer.html\"><code>Buffer</code></a>s.\nThis is also included in the <code>external</code> value. When Node.js is used as an\nembedded library, this value may be <code>0</code> because allocations for <code>ArrayBuffer</code>s\nmay not be tracked in that case.</li>\n</ul>\n<p>When using <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads, <code>rss</code> will be a value that is valid for the\nentire process, while the other fields will only refer to the current thread.</p>\n<p>The <code>process.memoryUsage()</code> method iterates over each page to gather\ninformation about memory usage which might be slow depending on the\nprogram memory allocations.</p>"
+        },
+        {
+          "textRaw": "`process.memoryUsage.rss()`",
+          "type": "method",
+          "name": "rss",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {integer}",
+                "name": "return",
+                "type": "integer"
+              },
+              "params": []
+            }
+          ],
+          "desc": "<p>The <code>process.memoryUsage.rss()</code> method returns an integer representing the\nResident Set Size (RSS) in bytes.</p>\n<p>The Resident Set Size, is the amount of space occupied in the main\nmemory device (that is a subset of the total allocated memory) for the\nprocess, including all C++ and JavaScript objects and code.</p>\n<p>This is the same value as the <code>rss</code> property provided by <code>process.memoryUsage()</code>\nbut <code>process.memoryUsage.rss()</code> is faster.</p>\n<pre><code class=\"language-js\">console.log(process.memoryUsage.rss());\n// 35655680\n</code></pre>"
         },
         {
           "textRaw": "`process.nextTick(callback[, ...args])`",
@@ -938,7 +992,16 @@
               ]
             }
           ],
-          "desc": "<p><code>process.nextTick()</code> adds <code>callback</code> to the \"next tick queue\". This queue is\nfully drained after the current operation on the JavaScript stack runs to\ncompletion and before the event loop is allowed to continue. It's possible to\ncreate an infinite loop if one were to recursively call <code>process.nextTick()</code>.\nSee the <a href=\"https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick\">Event Loop</a> guide for more background.</p>\n<pre><code class=\"language-js\">console.log('start');\nprocess.nextTick(() => {\n  console.log('nextTick callback');\n});\nconsole.log('scheduled');\n// Output:\n// start\n// scheduled\n// nextTick callback\n</code></pre>\n<p>This is important when developing APIs in order to give users the opportunity\nto assign event handlers <em>after</em> an object has been constructed but before any\nI/O has occurred:</p>\n<pre><code class=\"language-js\">function MyThing(options) {\n  this.setupOptions(options);\n\n  process.nextTick(() => {\n    this.startDoingStuff();\n  });\n}\n\nconst thing = new MyThing();\nthing.getReadyForStuff();\n\n// thing.startDoingStuff() gets called now, not before.\n</code></pre>\n<p>It is very important for APIs to be either 100% synchronous or 100%\nasynchronous. Consider this example:</p>\n<pre><code class=\"language-js\">// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!\nfunction maybeSync(arg, cb) {\n  if (arg) {\n    cb();\n    return;\n  }\n\n  fs.stat('file', cb);\n}\n</code></pre>\n<p>This API is hazardous because in the following case:</p>\n<pre><code class=\"language-js\">const maybeTrue = Math.random() > 0.5;\n\nmaybeSync(maybeTrue, () => {\n  foo();\n});\n\nbar();\n</code></pre>\n<p>It is not clear whether <code>foo()</code> or <code>bar()</code> will be called first.</p>\n<p>The following approach is much better:</p>\n<pre><code class=\"language-js\">function definitelyAsync(arg, cb) {\n  if (arg) {\n    process.nextTick(cb);\n    return;\n  }\n\n  fs.stat('file', cb);\n}\n</code></pre>"
+          "desc": "<p><code>process.nextTick()</code> adds <code>callback</code> to the \"next tick queue\". This queue is\nfully drained after the current operation on the JavaScript stack runs to\ncompletion and before the event loop is allowed to continue. It's possible to\ncreate an infinite loop if one were to recursively call <code>process.nextTick()</code>.\nSee the <a href=\"https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick\">Event Loop</a> guide for more background.</p>\n<pre><code class=\"language-js\">console.log('start');\nprocess.nextTick(() => {\n  console.log('nextTick callback');\n});\nconsole.log('scheduled');\n// Output:\n// start\n// scheduled\n// nextTick callback\n</code></pre>\n<p>This is important when developing APIs in order to give users the opportunity\nto assign event handlers <em>after</em> an object has been constructed but before any\nI/O has occurred:</p>\n<pre><code class=\"language-js\">function MyThing(options) {\n  this.setupOptions(options);\n\n  process.nextTick(() => {\n    this.startDoingStuff();\n  });\n}\n\nconst thing = new MyThing();\nthing.getReadyForStuff();\n\n// thing.startDoingStuff() gets called now, not before.\n</code></pre>\n<p>It is very important for APIs to be either 100% synchronous or 100%\nasynchronous. Consider this example:</p>\n<pre><code class=\"language-js\">// WARNING!  DO NOT USE!  BAD UNSAFE HAZARD!\nfunction maybeSync(arg, cb) {\n  if (arg) {\n    cb();\n    return;\n  }\n\n  fs.stat('file', cb);\n}\n</code></pre>\n<p>This API is hazardous because in the following case:</p>\n<pre><code class=\"language-js\">const maybeTrue = Math.random() > 0.5;\n\nmaybeSync(maybeTrue, () => {\n  foo();\n});\n\nbar();\n</code></pre>\n<p>It is not clear whether <code>foo()</code> or <code>bar()</code> will be called first.</p>\n<p>The following approach is much better:</p>\n<pre><code class=\"language-js\">function definitelyAsync(arg, cb) {\n  if (arg) {\n    process.nextTick(cb);\n    return;\n  }\n\n  fs.stat('file', cb);\n}\n</code></pre>",
+          "modules": [
+            {
+              "textRaw": "When to use `queueMicrotask()` vs. `process.nextTick()`",
+              "name": "when_to_use_`queuemicrotask()`_vs._`process.nexttick()`",
+              "desc": "<p>The <a href=\"globals.html#globals_queuemicrotask_callback\"><code>queueMicrotask()</code></a> API is an alternative to <code>process.nextTick()</code> that\nalso defers execution of a function using the same microtask queue used to\nexecute the then, catch, and finally handlers of resolved promises. Within\nNode.js, every time the \"next tick queue\" is drained, the microtask queue\nis drained immediately after.</p>\n<pre><code class=\"language-js\">Promise.resolve().then(() => console.log(2));\nqueueMicrotask(() => console.log(3));\nprocess.nextTick(() => console.log(1));\n// Output:\n// 1\n// 2\n// 3\n</code></pre>\n<p>For <em>most</em> userland use cases, the <code>queueMicrotask()</code> API provides a portable\nand reliable mechanism for deferring execution that works across multiple\nJavaScript platform environments and should be favored over <code>process.nextTick()</code>.\nIn simple scenarios, <code>queueMicrotask()</code> can be a drop-in replacement for\n<code>process.nextTick()</code>.</p>\n<pre><code class=\"language-js\">console.log('start');\nqueueMicrotask(() => {\n  console.log('microtask callback');\n});\nconsole.log('scheduled');\n// Output:\n// start\n// scheduled\n// microtask callback\n</code></pre>\n<p>One note-worthy difference between the two APIs is that <code>process.nextTick()</code>\nallows specifying additional values that will be passed as arguments to the\ndeferred function when it is called. Achieving the same result with\n<code>queueMicrotask()</code> requires using either a closure or a bound function:</p>\n<pre><code class=\"language-js\">function deferred(a, b) {\n  console.log('microtask', a + b);\n}\n\nconsole.log('start');\nqueueMicrotask(deferred.bind(undefined, 1, 2));\nconsole.log('scheduled');\n// Output:\n// start\n// scheduled\n// microtask 3\n</code></pre>\n<p>There are minor differences in the way errors raised from within the next tick\nqueue and microtask queue are handled. Errors thrown within a queued microtask\ncallback should be handled within the queued callback when possible. If they are\nnot, the <code>process.on('uncaughtException')</code> event handler can be used to capture\nand handle the errors.</p>\n<p>When in doubt, unless the specific capabilities of <code>process.nextTick()</code> are\nneeded, use <code>queueMicrotask()</code>.</p>",
+              "type": "module",
+              "displayName": "When to use `queueMicrotask()` vs. `process.nextTick()`"
+            }
+          ]
         },
         {
           "textRaw": "`process.resourceUsage()`",
@@ -1207,7 +1270,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>process.setgroups()</code> method sets the supplementary group IDs for the\nNode.js process. This is a privileged operation that requires the Node.js\nprocess to have <code>root</code> or the <code>CAP_SETGID</code> capability.</p>\n<p>The <code>groups</code> array can contain numeric group IDs, group names or both.</p>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).\nThis feature is not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>"
+          "desc": "<p>The <code>process.setgroups()</code> method sets the supplementary group IDs for the\nNode.js process. This is a privileged operation that requires the Node.js\nprocess to have <code>root</code> or the <code>CAP_SETGID</code> capability.</p>\n<p>The <code>groups</code> array can contain numeric group IDs, group names, or both.</p>\n<pre><code class=\"language-js\">if (process.getgroups &#x26;&#x26; process.setgroups) {\n  try {\n    process.setgroups([501]);\n    console.log(process.getgroups()); // new groups\n  } catch (err) {\n    console.log(`Failed to set groups: ${err}`);\n  }\n}\n</code></pre>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).\nThis feature is not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>"
         },
         {
           "textRaw": "`process.setuid(id)`",
@@ -1232,6 +1295,31 @@
           ],
           "desc": "<p>The <code>process.setuid(id)</code> method sets the user identity of the process. (See\n<a href=\"http://man7.org/linux/man-pages/man2/setuid.2.html\"><code>setuid(2)</code></a>.) The <code>id</code> can be passed as either a numeric ID or a username string.\nIf a username is specified, the method blocks while resolving the associated\nnumeric ID.</p>\n<pre><code class=\"language-js\">if (process.getuid &#x26;&#x26; process.setuid) {\n  console.log(`Current uid: ${process.getuid()}`);\n  try {\n    process.setuid(501);\n    console.log(`New uid: ${process.getuid()}`);\n  } catch (err) {\n    console.log(`Failed to set uid: ${err}`);\n  }\n}\n</code></pre>\n<p>This function is only available on POSIX platforms (i.e. not Windows or\nAndroid).\nThis feature is not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>"
         },
+        {
+          "textRaw": "`process.setSourceMapsEnabled(val)`",
+          "type": "method",
+          "name": "setSourceMapsEnabled",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`val` {boolean}",
+                  "name": "val",
+                  "type": "boolean"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>This function enables or disables the <a href=\"https://sourcemaps.info/spec.html\">Source Map v3</a> support for\nstack traces.</p>\n<p>It provides same features as launching Node.js process with commandline options\n<code>--enable-source-maps</code>.</p>\n<p>Only source maps in JavaScript files that are loaded after source maps has been\nenabled will be parsed and loaded.</p>"
+        },
         {
           "textRaw": "`process.setUncaughtExceptionCaptureCallback(fn)`",
           "type": "method",
@@ -1253,7 +1341,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>process.setUncaughtExceptionCaptureCallback()</code> function sets a function\nthat will be invoked when an uncaught exception occurs, which will receive the\nexception value itself as its first argument.</p>\n<p>If such a function is set, the <a href=\"#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event will\nnot be emitted. If <code>--abort-on-uncaught-exception</code> was passed from the\ncommand line or set through <a href=\"v8.html#v8_v8_setflagsfromstring_flags\"><code>v8.setFlagsFromString()</code></a>, the process will\nnot abort.</p>\n<p>To unset the capture function,\n<code>process.setUncaughtExceptionCaptureCallback(null)</code> may be used. Calling this\nmethod with a non-<code>null</code> argument while another capture function is set will\nthrow an error.</p>\n<p>Using this function is mutually exclusive with using the deprecated\n<a href=\"domain.html\"><code>domain</code></a> built-in module.</p>"
+          "desc": "<p>The <code>process.setUncaughtExceptionCaptureCallback()</code> function sets a function\nthat will be invoked when an uncaught exception occurs, which will receive the\nexception value itself as its first argument.</p>\n<p>If such a function is set, the <a href=\"#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event will\nnot be emitted. If <code>--abort-on-uncaught-exception</code> was passed from the\ncommand line or set through <a href=\"v8.html#v8_v8_setflagsfromstring_flags\"><code>v8.setFlagsFromString()</code></a>, the process will\nnot abort. Actions configured to take place on exceptions such as report\ngenerations will be affected too</p>\n<p>To unset the capture function,\n<code>process.setUncaughtExceptionCaptureCallback(null)</code> may be used. Calling this\nmethod with a non-<code>null</code> argument while another capture function is set will\nthrow an error.</p>\n<p>Using this function is mutually exclusive with using the deprecated\n<a href=\"domain.html\"><code>domain</code></a> built-in module.</p>"
         },
         {
           "textRaw": "`process.umask()`",
@@ -1266,8 +1354,8 @@
             "changes": [
               {
                 "version": [
-                  "v12.19.0",
-                  "v14.0.0"
+                  "v14.0.0",
+                  "v12.19.0"
                 ],
                 "pr-url": "https://github.com/nodejs/node/pull/32499",
                 "description": "Calling `process.umask()` with no arguments is deprecated."
@@ -1364,7 +1452,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>process.argv</code> property returns an array containing the command line\narguments passed when the Node.js process was launched. The first element will\nbe <a href=\"#process_process_execpath\"><code>process.execPath</code></a>. See <code>process.argv0</code> if access to the original value\nof <code>argv[0]</code> is needed. The second element will be the path to the JavaScript\nfile being executed. The remaining elements will be any additional command line\narguments.</p>\n<p>For example, assuming the following script for <code>process-args.js</code>:</p>\n<pre><code class=\"language-js\">// print process.argv\nprocess.argv.forEach((val, index) => {\n  console.log(`${index}: ${val}`);\n});\n</code></pre>\n<p>Launching the Node.js process as:</p>\n<pre><code class=\"language-console\">$ node process-args.js one two=three four\n</code></pre>\n<p>Would generate the output:</p>\n<pre><code class=\"language-text\">0: /usr/local/bin/node\n1: /Users/mjr/work/node/process-args.js\n2: one\n3: two=three\n4: four\n</code></pre>"
+          "desc": "<p>The <code>process.argv</code> property returns an array containing the command-line\narguments passed when the Node.js process was launched. The first element will\nbe <a href=\"#process_process_execpath\"><code>process.execPath</code></a>. See <code>process.argv0</code> if access to the original value\nof <code>argv[0]</code> is needed. The second element will be the path to the JavaScript\nfile being executed. The remaining elements will be any additional command-line\narguments.</p>\n<p>For example, assuming the following script for <code>process-args.js</code>:</p>\n<pre><code class=\"language-js\">// print process.argv\nprocess.argv.forEach((val, index) => {\n  console.log(`${index}: ${val}`);\n});\n</code></pre>\n<p>Launching the Node.js process as:</p>\n<pre><code class=\"language-console\">$ node process-args.js one two=three four\n</code></pre>\n<p>Would generate the output:</p>\n<pre><code class=\"language-text\">0: /usr/local/bin/node\n1: /Users/mjr/work/node/process-args.js\n2: one\n3: two=three\n4: four\n</code></pre>"
         },
         {
           "textRaw": "`argv0` {string}",
@@ -1386,9 +1474,51 @@
             "added": [
               "v7.1.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/30165",
+                "description": "The object no longer accidentally exposes native C++ bindings."
+              }
+            ]
           },
-          "desc": "<p>If the Node.js process was spawned with an IPC channel (see the\n<a href=\"child_process.html\">Child Process</a> documentation), the <code>process.channel</code>\nproperty is a reference to the IPC channel. If no IPC channel exists, this\nproperty is <code>undefined</code>.</p>"
+          "desc": "<p>If the Node.js process was spawned with an IPC channel (see the\n<a href=\"child_process.html\">Child Process</a> documentation), the <code>process.channel</code>\nproperty is a reference to the IPC channel. If no IPC channel exists, this\nproperty is <code>undefined</code>.</p>",
+          "methods": [
+            {
+              "textRaw": "`process.channel.ref()`",
+              "type": "method",
+              "name": "ref",
+              "meta": {
+                "added": [
+                  "v7.1.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>This method makes the IPC channel keep the event loop of the process\nrunning if <code>.unref()</code> has been called before.</p>\n<p>Typically, this is managed through the number of <code>'disconnect'</code> and <code>'message'</code>\nlisteners on the <code>process</code> object. However, this method can be used to\nexplicitly request a specific behavior.</p>"
+            },
+            {
+              "textRaw": "`process.channel.unref()`",
+              "type": "method",
+              "name": "unref",
+              "meta": {
+                "added": [
+                  "v7.1.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "params": []
+                }
+              ],
+              "desc": "<p>This method makes the IPC channel not keep the event loop of the process\nrunning, and lets it finish even while the channel is open.</p>\n<p>Typically, this is managed through the number of <code>'disconnect'</code> and <code>'message'</code>\nlisteners on the <code>process</code> object. However, this method can be used to\nexplicitly request a specific behavior.</p>"
+            }
+          ]
         },
         {
           "textRaw": "`config` {Object}",
@@ -1459,7 +1589,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>process.execArgv</code> property returns the set of Node.js-specific command-line\noptions passed when the Node.js process was launched. These options do not\nappear in the array returned by the <a href=\"#process_process_argv\"><code>process.argv</code></a> property, and do not\ninclude the Node.js executable, the name of the script, or any options following\nthe script name. These options are useful in order to spawn child processes with\nthe same execution environment as the parent.</p>\n<pre><code class=\"language-console\">$ node --harmony script.js --version\n</code></pre>\n<p>Results in <code>process.execArgv</code>:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">['--harmony']\n</code></pre>\n<p>And <code>process.argv</code>:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">['/usr/local/bin/node', 'script.js', '--version']\n</code></pre>"
+          "desc": "<p>The <code>process.execArgv</code> property returns the set of Node.js-specific command-line\noptions passed when the Node.js process was launched. These options do not\nappear in the array returned by the <a href=\"#process_process_argv\"><code>process.argv</code></a> property, and do not\ninclude the Node.js executable, the name of the script, or any options following\nthe script name. These options are useful in order to spawn child processes with\nthe same execution environment as the parent.</p>\n<pre><code class=\"language-console\">$ node --harmony script.js --version\n</code></pre>\n<p>Results in <code>process.execArgv</code>:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">['--harmony']\n</code></pre>\n<p>And <code>process.argv</code>:</p>\n<!-- eslint-disable semi -->\n<pre><code class=\"language-js\">['/usr/local/bin/node', 'script.js', '--version']\n</code></pre>\n<p>Refer to <a href=\"worker_threads.html#worker_threads_new_worker_filename_options\"><code>Worker</code> constructor</a> for the detailed behavior of worker\nthreads with this property.</p>"
         },
         {
           "textRaw": "`execPath` {string}",
@@ -1493,8 +1623,13 @@
             "added": [
               "v0.1.17"
             ],
+            "deprecated": [
+              "v14.0.0"
+            ],
             "changes": []
           },
+          "stability": 0,
+          "stabilityText": "Deprecated: Use [`require.main`][] instead.",
           "desc": "<p>The <code>process.mainModule</code> property provides an alternative way of retrieving\n<a href=\"modules.html#modules_accessing_the_main_module\"><code>require.main</code></a>. The difference is that if the main module changes at\nruntime, <a href=\"modules.html#modules_accessing_the_main_module\"><code>require.main</code></a> may still refer to the original main module in\nmodules that were required before the change occurred. Generally, it's\nsafe to assume that the two refer to the same module.</p>\n<p>As with <a href=\"modules.html#modules_accessing_the_main_module\"><code>require.main</code></a>, <code>process.mainModule</code> will be <code>undefined</code> if there\nis no entry script.</p>"
         },
         {
@@ -1531,7 +1666,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>process.platform</code> property returns a string identifying the operating\nsystem platform on which the Node.js process is running.</p>\n<p>Currently possible values are:</p>\n<ul>\n<li><code>'aix'</code></li>\n<li><code>'darwin'</code></li>\n<li><code>'freebsd'</code></li>\n<li><code>'linux'</code></li>\n<li><code>'openbsd'</code></li>\n<li><code>'sunos'</code></li>\n<li><code>'win32'</code></li>\n</ul>\n<pre><code class=\"language-js\">console.log(`This platform is ${process.platform}`);\n</code></pre>\n<p>The value <code>'android'</code> may also be returned if the Node.js is built on the\nAndroid operating system. However, Android support in Node.js\n<a href=\"https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os\">is experimental</a>.</p>"
+          "desc": "<p>The <code>process.platform</code> property returns a string identifying the operating\nsystem platform on which the Node.js process is running.</p>\n<p>Currently possible values are:</p>\n<ul>\n<li><code>'aix'</code></li>\n<li><code>'darwin'</code></li>\n<li><code>'freebsd'</code></li>\n<li><code>'linux'</code></li>\n<li><code>'openbsd'</code></li>\n<li><code>'sunos'</code></li>\n<li><code>'win32'</code></li>\n</ul>\n<pre><code class=\"language-js\">console.log(`This platform is ${process.platform}`);\n</code></pre>\n<p>The value <code>'android'</code> may also be returned if the Node.js is built on the\nAndroid operating system. However, Android support in Node.js\n<a href=\"https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os\">is experimental</a>.</p>"
         },
         {
           "textRaw": "`ppid` {integer}",
@@ -1563,7 +1698,7 @@
               }
             ]
           },
-          "desc": "<p>The <code>process.release</code> property returns an <code>Object</code> containing metadata related\nto the current release, including URLs for the source tarball and headers-only\ntarball.</p>\n<p><code>process.release</code> contains the following properties:</p>\n<ul>\n<li><code>name</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A value that will always be <code>'node'</code> for Node.js. For\nlegacy io.js releases, this will be <code>'io.js'</code>.</li>\n<li><code>sourceUrl</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing\nthe source code of the current release.</li>\n<li><code>headersUrl</code><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing\nonly the source header files for the current release. This file is\nsignificantly smaller than the full source file and can be used for compiling\nNode.js native add-ons.</li>\n<li><code>libUrl</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>node.lib</code></em> file matching the\narchitecture and version of the current release. This file is used for\ncompiling Node.js native add-ons. <em>This property is only present on Windows\nbuilds of Node.js and will be missing on all other platforms.</em></li>\n<li><code>lts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> a string label identifying the <a href=\"https://github.com/nodejs/Release\">LTS</a> label for this release.\nThis property only exists for LTS releases and is <code>undefined</code> for all other\nrelease types, including <em>Current</em> releases.\nValid values include the LTS Release Codenames (including those\nthat are no longer supported). A non-exhaustive example of\nthese codenames includes:\n<ul>\n<li><code>'Dubnium'</code> for the 10.x LTS line beginning with 10.13.0.</li>\n<li><code>'Erbium'</code> for the 12.x LTS line beginning with 12.13.0.\nFor other LTS Release Codenames, see <a href=\"https://github.com/nodejs/node/blob/master/doc/changelogs/CHANGELOG_ARCHIVE.md\">Node.js Changelog Archive</a></li>\n</ul>\n</li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  name: 'node',\n  lts: 'Erbium',\n  sourceUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1.tar.gz',\n  headersUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1-headers.tar.gz',\n  libUrl: 'https://nodejs.org/download/release/v12.18.1/win-x64/node.lib'\n}\n</code></pre>\n<p>In custom builds from non-release versions of the source tree, only the\n<code>name</code> property may be present. The additional properties should not be\nrelied upon to exist.</p>"
+          "desc": "<p>The <code>process.release</code> property returns an <code>Object</code> containing metadata related\nto the current release, including URLs for the source tarball and headers-only\ntarball.</p>\n<p><code>process.release</code> contains the following properties:</p>\n<ul>\n<li><code>name</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> A value that will always be <code>'node'</code>.</li>\n<li><code>sourceUrl</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing\nthe source code of the current release.</li>\n<li><code>headersUrl</code><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>.tar.gz</code></em> file containing\nonly the source header files for the current release. This file is\nsignificantly smaller than the full source file and can be used for compiling\nNode.js native add-ons.</li>\n<li><code>libUrl</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> an absolute URL pointing to a <em><code>node.lib</code></em> file matching the\narchitecture and version of the current release. This file is used for\ncompiling Node.js native add-ons. <em>This property is only present on Windows\nbuilds of Node.js and will be missing on all other platforms.</em></li>\n<li><code>lts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> a string label identifying the <a href=\"https://github.com/nodejs/Release\">LTS</a> label for this release.\nThis property only exists for LTS releases and is <code>undefined</code> for all other\nrelease types, including <em>Current</em> releases.\nValid values include the LTS Release code names (including those\nthat are no longer supported).\n<ul>\n<li><code>'Dubnium'</code> for the 10.x LTS line beginning with 10.13.0.</li>\n<li><code>'Erbium'</code> for the 12.x LTS line beginning with 12.13.0.</li>\n</ul>\nFor other LTS Release code names, see <a href=\"https://github.com/nodejs/node/blob/HEAD/doc/changelogs/CHANGELOG_ARCHIVE.md\">Node.js Changelog Archive</a></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  name: 'node',\n  lts: 'Erbium',\n  sourceUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1.tar.gz',\n  headersUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1-headers.tar.gz',\n  libUrl: 'https://nodejs.org/download/release/v12.18.1/win-x64/node.lib'\n}\n</code></pre>\n<p>In custom builds from non-release versions of the source tree, only the\n<code>name</code> property may be present. The additional properties should not be\nrelied upon to exist.</p>"
         },
         {
           "textRaw": "`report` {Object}",
@@ -1575,7 +1710,7 @@
             ],
             "changes": [
               {
-                "version": "v12.17.0",
+                "version": "v13.12.0",
                 "pr-url": "https://github.com/nodejs/node/pull/32242",
                 "description": "This API is no longer experimental."
               }
@@ -1589,7 +1724,7 @@
               "name": "compact",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.12.0"
                 ],
                 "changes": []
               },
@@ -1605,7 +1740,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -1623,7 +1758,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -1639,10 +1774,16 @@
                 "added": [
                   "v11.12.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": [
+                      "v14.17.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/35654",
+                    "description": "This API is no longer experimental."
+                  }
+                ]
               },
-              "stability": 1,
-              "stabilityText": "Experimental",
               "desc": "<p>If <code>true</code>, a diagnostic report is generated on fatal errors, such as out of\nmemory errors or failed C++ assertions.</p>\n<pre><code class=\"language-js\">console.log(`Report on fatal error: ${process.report.reportOnFatalError}`);\n</code></pre>"
             },
             {
@@ -1655,7 +1796,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -1673,7 +1814,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -1691,7 +1832,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -1711,7 +1852,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -1734,7 +1875,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a JavaScript Object representation of a diagnostic report for the\nrunning process. The report's JavaScript stack trace is taken from <code>err</code>, if\npresent.</p>\n<pre><code class=\"language-js\">const data = process.report.getReport();\nconsole.log(data.header.nodeJsVersion);\n\n// Similar to process.report.writeReport()\nconst fs = require('fs');\nfs.writeFileSync(util.inspect(data), 'my-report.log', 'utf8');\n</code></pre>\n<p>Additional documentation is available in the <a href=\"report.html\">report documentation</a>.</p>"
+              "desc": "<p>Returns a JavaScript Object representation of a diagnostic report for the\nrunning process. The report's JavaScript stack trace is taken from <code>err</code>, if\npresent.</p>\n<pre><code class=\"language-js\">const data = process.report.getReport();\nconsole.log(data.header.nodejsVersion);\n\n// Similar to process.report.writeReport()\nconst fs = require('fs');\nfs.writeFileSync('my-report.log', util.inspect(data), 'utf8');\n</code></pre>\n<p>Additional documentation is available in the <a href=\"report.html\">report documentation</a>.</p>"
             },
             {
               "textRaw": "`process.report.writeReport([filename][, err])`",
@@ -1746,7 +1887,7 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.17.0",
+                    "version": "v13.12.0",
                     "pr-url": "https://github.com/nodejs/node/pull/32242",
                     "description": "This API is no longer experimental."
                   }
@@ -1784,7 +1925,7 @@
           "textRaw": "`stderr` {Stream}",
           "type": "Stream",
           "name": "stderr",
-          "desc": "<p>The <code>process.stderr</code> property returns a stream connected to\n<code>stderr</code> (fd <code>2</code>). It is a <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> (which is a <a href=\"stream.html#stream_duplex_and_transform_streams\">Duplex</a>\nstream) unless fd <code>2</code> refers to a file, in which case it is\na <a href=\"stream.html#stream_writable_streams\">Writable</a> stream.</p>\n<p><code>process.stderr</code> differs from other Node.js streams in important ways. See\n<a href=\"process.html#process_a_note_on_process_i_o\">note on process I/O</a> for more information.</p>",
+          "desc": "<p>The <code>process.stderr</code> property returns a stream connected to\n<code>stderr</code> (fd <code>2</code>). It is a <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> (which is a <a href=\"stream.html#stream_duplex_and_transform_streams\">Duplex</a>\nstream) unless fd <code>2</code> refers to a file, in which case it is\na <a href=\"stream.html#stream_writable_streams\">Writable</a> stream.</p>\n<p><code>process.stderr</code> differs from other Node.js streams in important ways. See\n<a href=\"#process_a_note_on_process_i_o\">note on process I/O</a> for more information.</p>",
           "properties": [
             {
               "textRaw": "`fd` {number}",
@@ -1812,7 +1953,7 @@
           "textRaw": "`stdout` {Stream}",
           "type": "Stream",
           "name": "stdout",
-          "desc": "<p>The <code>process.stdout</code> property returns a stream connected to\n<code>stdout</code> (fd <code>1</code>). It is a <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> (which is a <a href=\"stream.html#stream_duplex_and_transform_streams\">Duplex</a>\nstream) unless fd <code>1</code> refers to a file, in which case it is\na <a href=\"stream.html#stream_writable_streams\">Writable</a> stream.</p>\n<p>For example, to copy <code>process.stdin</code> to <code>process.stdout</code>:</p>\n<pre><code class=\"language-js\">process.stdin.pipe(process.stdout);\n</code></pre>\n<p><code>process.stdout</code> differs from other Node.js streams in important ways. See\n<a href=\"process.html#process_a_note_on_process_i_o\">note on process I/O</a> for more information.</p>",
+          "desc": "<p>The <code>process.stdout</code> property returns a stream connected to\n<code>stdout</code> (fd <code>1</code>). It is a <a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> (which is a <a href=\"stream.html#stream_duplex_and_transform_streams\">Duplex</a>\nstream) unless fd <code>1</code> refers to a file, in which case it is\na <a href=\"stream.html#stream_writable_streams\">Writable</a> stream.</p>\n<p>For example, to copy <code>process.stdin</code> to <code>process.stdout</code>:</p>\n<pre><code class=\"language-js\">process.stdin.pipe(process.stdout);\n</code></pre>\n<p><code>process.stdout</code> differs from other Node.js streams in important ways. See\n<a href=\"#process_a_note_on_process_i_o\">note on process I/O</a> for more information.</p>",
           "properties": [
             {
               "textRaw": "`fd` {number}",
@@ -1825,7 +1966,7 @@
             {
               "textRaw": "A note on process I/O",
               "name": "a_note_on_process_i/o",
-              "desc": "<p><code>process.stdout</code> and <code>process.stderr</code> differ from other Node.js streams in\nimportant ways:</p>\n<ol>\n<li>They are used internally by <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> and <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a>,\nrespectively.</li>\n<li>Writes may be synchronous depending on what the stream is connected to\nand whether the system is Windows or POSIX:\n<ul>\n<li>Files: <em>synchronous</em> on Windows and POSIX</li>\n<li>TTYs (Terminals): <em>asynchronous</em> on Windows, <em>synchronous</em> on POSIX</li>\n<li>Pipes (and sockets): <em>synchronous</em> on Windows, <em>asynchronous</em> on POSIX</li>\n</ul>\n</li>\n</ol>\n<p>These behaviors are partly for historical reasons, as changing them would\ncreate backward incompatibility, but they are also expected by some users.</p>\n<p>Synchronous writes avoid problems such as output written with <code>console.log()</code> or\n<code>console.error()</code> being unexpectedly interleaved, or not written at all if\n<code>process.exit()</code> is called before an asynchronous write completes. See\n<a href=\"#process_process_exit_code\"><code>process.exit()</code></a> for more information.</p>\n<p><strong><em>Warning</em></strong>: Synchronous writes block the event loop until the write has\ncompleted. This can be near instantaneous in the case of output to a file, but\nunder high system load, pipes that are not being read at the receiving end, or\nwith slow terminals or file systems, its possible for the event loop to be\nblocked often enough and long enough to have severe negative performance\nimpacts. This may not be a problem when writing to an interactive terminal\nsession, but consider this particularly careful when doing production logging to\nthe process output streams.</p>\n<p>To check if a stream is connected to a <a href=\"tty.html#tty_tty\">TTY</a> context, check the <code>isTTY</code>\nproperty.</p>\n<p>For instance:</p>\n<pre><code class=\"language-console\">$ node -p \"Boolean(process.stdin.isTTY)\"\ntrue\n$ echo \"foo\" | node -p \"Boolean(process.stdin.isTTY)\"\nfalse\n$ node -p \"Boolean(process.stdout.isTTY)\"\ntrue\n$ node -p \"Boolean(process.stdout.isTTY)\" | cat\nfalse\n</code></pre>\n<p>See the <a href=\"tty.html#tty_tty\">TTY</a> documentation for more information.</p>",
+              "desc": "<p><code>process.stdout</code> and <code>process.stderr</code> differ from other Node.js streams in\nimportant ways:</p>\n<ol>\n<li>They are used internally by <a href=\"console.html#console_console_log_data_args\"><code>console.log()</code></a> and <a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a>,\nrespectively.</li>\n<li>Writes may be synchronous depending on what the stream is connected to\nand whether the system is Windows or POSIX:\n<ul>\n<li>Files: <em>synchronous</em> on Windows and POSIX</li>\n<li>TTYs (Terminals): <em>asynchronous</em> on Windows, <em>synchronous</em> on POSIX</li>\n<li>Pipes (and sockets): <em>synchronous</em> on Windows, <em>asynchronous</em> on POSIX</li>\n</ul>\n</li>\n</ol>\n<p>These behaviors are partly for historical reasons, as changing them would\ncreate backward incompatibility, but they are also expected by some users.</p>\n<p>Synchronous writes avoid problems such as output written with <code>console.log()</code> or\n<code>console.error()</code> being unexpectedly interleaved, or not written at all if\n<code>process.exit()</code> is called before an asynchronous write completes. See\n<a href=\"#process_process_exit_code\"><code>process.exit()</code></a> for more information.</p>\n<p><em><strong>Warning</strong></em>: Synchronous writes block the event loop until the write has\ncompleted. This can be near instantaneous in the case of output to a file, but\nunder high system load, pipes that are not being read at the receiving end, or\nwith slow terminals or file systems, its possible for the event loop to be\nblocked often enough and long enough to have severe negative performance\nimpacts. This may not be a problem when writing to an interactive terminal\nsession, but consider this particularly careful when doing production logging to\nthe process output streams.</p>\n<p>To check if a stream is connected to a <a href=\"tty.html#tty_tty\">TTY</a> context, check the <code>isTTY</code>\nproperty.</p>\n<p>For instance:</p>\n<pre><code class=\"language-console\">$ node -p \"Boolean(process.stdin.isTTY)\"\ntrue\n$ echo \"foo\" | node -p \"Boolean(process.stdin.isTTY)\"\nfalse\n$ node -p \"Boolean(process.stdout.isTTY)\"\ntrue\n$ node -p \"Boolean(process.stdout.isTTY)\" | cat\nfalse\n</code></pre>\n<p>See the <a href=\"tty.html#tty_tty\">TTY</a> documentation for more information.</p>",
               "type": "module",
               "displayName": "A note on process I/O"
             }
@@ -1853,7 +1994,7 @@
             ],
             "changes": []
           },
-          "desc": "<p>The <code>process.title</code> property returns the current process title (i.e. returns\nthe current value of <code>ps</code>). Assigning a new value to <code>process.title</code> modifies\nthe current value of <code>ps</code>.</p>\n<p>When a new value is assigned, different platforms will impose different maximum\nlength restrictions on the title. Usually such restrictions are quite limited.\nFor instance, on Linux and macOS, <code>process.title</code> is limited to the size of the\nbinary name plus the length of the command line arguments because setting the\n<code>process.title</code> overwrites the <code>argv</code> memory of the process. Node.js v0.8\nallowed for longer process title strings by also overwriting the <code>environ</code>\nmemory but that was potentially insecure and confusing in some (rather obscure)\ncases.</p>\n<p>Assigning a value to <code>process.title</code> might not result in an accurate label\nwithin process manager applications such as macOS Activity Monitor or Windows\nServices Manager.</p>"
+          "desc": "<p>The <code>process.title</code> property returns the current process title (i.e. returns\nthe current value of <code>ps</code>). Assigning a new value to <code>process.title</code> modifies\nthe current value of <code>ps</code>.</p>\n<p>When a new value is assigned, different platforms will impose different maximum\nlength restrictions on the title. Usually such restrictions are quite limited.\nFor instance, on Linux and macOS, <code>process.title</code> is limited to the size of the\nbinary name plus the length of the command-line arguments because setting the\n<code>process.title</code> overwrites the <code>argv</code> memory of the process. Node.js v0.8\nallowed for longer process title strings by also overwriting the <code>environ</code>\nmemory but that was potentially insecure and confusing in some (rather obscure)\ncases.</p>\n<p>Assigning a value to <code>process.title</code> might not result in an accurate label\nwithin process manager applications such as macOS Activity Monitor or Windows\nServices Manager.</p>"
         },
         {
           "textRaw": "`traceDeprecation` {boolean}",
@@ -1888,19 +2029,19 @@
               "v0.2.0"
             ],
             "changes": [
-              {
-                "version": "v4.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/3102",
-                "description": "The `icu` property is now supported."
-              },
               {
                 "version": "v9.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/15785",
                 "description": "The `v8` property now includes a Node.js specific suffix."
+              },
+              {
+                "version": "v4.2.0",
+                "pr-url": "https://github.com/nodejs/node/pull/3102",
+                "description": "The `icu` property is now supported."
               }
             ]
           },
-          "desc": "<p>The <code>process.versions</code> property returns an object listing the version strings of\nNode.js and its dependencies. <code>process.versions.modules</code> indicates the current\nABI version, which is increased whenever a C++ API changes. Node.js will refuse\nto load modules that were compiled against a different module ABI version.</p>\n<pre><code class=\"language-js\">console.log(process.versions);\n</code></pre>\n<p>Will generate an object similar to:</p>\n<pre><code class=\"language-console\">{ node: '11.13.0',\n  v8: '7.0.276.38-node.18',\n  uv: '1.27.0',\n  zlib: '1.2.11',\n  brotli: '1.0.7',\n  ares: '1.15.0',\n  modules: '67',\n  nghttp2: '1.34.0',\n  napi: '4',\n  llhttp: '1.1.1',\n  http_parser: '2.8.0',\n  openssl: '1.1.1b',\n  cldr: '34.0',\n  icu: '63.1',\n  tz: '2018e',\n  unicode: '11.0' }\n</code></pre>"
+          "desc": "<p>The <code>process.versions</code> property returns an object listing the version strings of\nNode.js and its dependencies. <code>process.versions.modules</code> indicates the current\nABI version, which is increased whenever a C++ API changes. Node.js will refuse\nto load modules that were compiled against a different module ABI version.</p>\n<pre><code class=\"language-js\">console.log(process.versions);\n</code></pre>\n<p>Will generate an object similar to:</p>\n<pre><code class=\"language-console\">{ node: '11.13.0',\n  v8: '7.0.276.38-node.18',\n  uv: '1.27.0',\n  zlib: '1.2.11',\n  brotli: '1.0.7',\n  ares: '1.15.0',\n  modules: '67',\n  nghttp2: '1.34.0',\n  napi: '4',\n  llhttp: '1.1.1',\n  openssl: '1.1.1b',\n  cldr: '34.0',\n  icu: '63.1',\n  tz: '2018e',\n  unicode: '11.0' }\n</code></pre>"
         }
       ]
     }
diff --git a/doc/api/process.md b/doc/api/process.md
index 00d8de8c93d3a0c1b1acfef3417eb03fa748a550..601fc892532c070d8625de12414eca5b08dff944 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -226,7 +226,9 @@ most convenient for scripts).
 <!-- YAML
 added: v0.1.18
 changes:
-  - version: v12.0.0
+  - version:
+     - v12.0.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/26599
     description: Added the `origin` argument.
 -->
@@ -235,7 +237,8 @@ changes:
 * `origin` {string} Indicates if the exception originates from an unhandled
   rejection or from an synchronous error. Can either be `'uncaughtException'` or
   `'unhandledRejection'`. The latter is only used in conjunction with the
-  [`--unhandled-rejections`][] flag set to `strict` and an unhandled rejection.
+  [`--unhandled-rejections`][] flag set to `strict` or `throw` and
+  an unhandled rejection.
 
 The `'uncaughtException'` event is emitted when an uncaught JavaScript
 exception bubbles all the way back to the event loop. By default, Node.js
@@ -298,13 +301,15 @@ needed.
 
 ### Event: `'uncaughtExceptionMonitor'`
 <!-- YAML
-added: v12.17.0
+added: v13.7.0
 -->
 
 * `err` {Error} The uncaught exception.
 * `origin` {string} Indicates if the exception originates from an unhandled
   rejection or from synchronous errors. Can either be `'uncaughtException'` or
-  `'unhandledRejection'`.
+  `'unhandledRejection'`. The latter is only used in conjunction with the
+  [`--unhandled-rejections`][] flag set to `strict` or `throw` and
+  an unhandled rejection.
 
 The `'uncaughtExceptionMonitor'` event is emitted before an
 `'uncaughtException'` event is emitted or a hook installed via
@@ -438,23 +443,55 @@ $ node --no-warnings
 The `--trace-warnings` command-line option can be used to have the default
 console output for warnings include the full stack trace of the warning.
 
-Launching Node.js using the `--throw-deprecation` command line flag will
+Launching Node.js using the `--throw-deprecation` command-line flag will
 cause custom deprecation warnings to be thrown as exceptions.
 
-Using the `--trace-deprecation` command line flag will cause the custom
+Using the `--trace-deprecation` command-line flag will cause the custom
 deprecation to be printed to `stderr` along with the stack trace.
 
-Using the `--no-deprecation` command line flag will suppress all reporting
+Using the `--no-deprecation` command-line flag will suppress all reporting
 of the custom deprecation.
 
-The `*-deprecation` command line flags only affect warnings that use the name
+The `*-deprecation` command-line flags only affect warnings that use the name
 `'DeprecationWarning'`.
 
+### Event: `'worker'`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `worker` {Worker} The {Worker} that was created.
+
+The `'worker'` event is emitted after a new {Worker} thread has been created.
+
 #### Emitting custom warnings
 
 See the [`process.emitWarning()`][process_emit_warning] method for issuing
 custom or application-specific warnings.
 
+#### Node.js warning names
+
+There are no strict guidelines for warning types (as identified by the `name`
+property) emitted by Node.js. New types of warnings can be added at any time.
+A few of the warning types that are most common include:
+
+* `'DeprecationWarning'` - Indicates use of a deprecated Node.js API or feature.
+  Such warnings must include a `'code'` property identifying the
+  [deprecation code][].
+* `'ExperimentalWarning'` - Indicates use of an experimental Node.js API or
+  feature. Such features must be used with caution as they may change at any
+  time and are not subject to the same strict semantic-versioning and long-term
+  support policies as supported features.
+* `'MaxListenersExceededWarning'` - Indicates that too many listeners for a
+  given event have been registered on either an `EventEmitter` or `EventTarget`.
+  This is often an indication of a memory leak.
+* `'TimeoutOverflowWarning'` - Indicates that a numeric value that cannot fit
+  within a 32-bit signed integer has been provided to either the `setTimeout()`
+  or `setInterval()` functions.
+* `'UnsupportedWarning'` - Indicates use of an unsupported option or feature
+  that will be ignored rather than treated as an error. One example is use of
+  the HTTP response status message when using the HTTP/2 compatibility API.
+
 ### Signal events
 
 <!--type=event-->
@@ -518,10 +555,8 @@ process.on('SIGTERM', handle);
 * `'SIGSTOP'` cannot have a listener installed.
 * `'SIGBUS'`, `'SIGFPE'`, `'SIGSEGV'` and `'SIGILL'`, when not raised
    artificially using kill(2), inherently leave the process in a state from
-   which it is not safe to attempt to call JS listeners. Doing so might lead to
-   the process hanging in an endless loop, since listeners attached using
-   `process.on()` are called asynchronously and therefore unable to correct the
-   underlying problem.
+   which it is not safe to call JS listeners. Doing so might cause the process
+   to stop responding.
 * `0` can be sent to test for the existence of a process, it has no effect if
    the process exists, but will throw an error if the process does not exist.
 
@@ -615,11 +650,11 @@ added: v0.1.27
 
 * {string[]}
 
-The `process.argv` property returns an array containing the command line
+The `process.argv` property returns an array containing the command-line
 arguments passed when the Node.js process was launched. The first element will
 be [`process.execPath`][]. See `process.argv0` if access to the original value
 of `argv[0]` is needed. The second element will be the path to the JavaScript
-file being executed. The remaining elements will be any additional command line
+file being executed. The remaining elements will be any additional command-line
 arguments.
 
 For example, assuming the following script for `process-args.js`:
@@ -668,6 +703,10 @@ $ bash -c 'exec -a customArgv0 ./node'
 ## `process.channel`
 <!-- YAML
 added: v7.1.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/30165
+    description: The object no longer accidentally exposes native C++ bindings.
 -->
 
 * {Object}
@@ -677,6 +716,30 @@ If the Node.js process was spawned with an IPC channel (see the
 property is a reference to the IPC channel. If no IPC channel exists, this
 property is `undefined`.
 
+### `process.channel.ref()`
+<!-- YAML
+added: v7.1.0
+-->
+
+This method makes the IPC channel keep the event loop of the process
+running if `.unref()` has been called before.
+
+Typically, this is managed through the number of `'disconnect'` and `'message'`
+listeners on the `process` object. However, this method can be used to
+explicitly request a specific behavior.
+
+### `process.channel.unref()`
+<!-- YAML
+added: v7.1.0
+-->
+
+This method makes the IPC channel not keep the event loop of the process
+running, and lets it finish even while the channel is open.
+
+Typically, this is managed through the number of `'disconnect'` and `'message'`
+listeners on the `process` object. However, this method can be used to
+explicitly request a specific behavior.
+
 ## `process.chdir(directory)`
 <!-- YAML
 added: v0.1.17
@@ -850,31 +913,29 @@ changes:
 * `filename` {string}
 * `flags` {os.constants.dlopen} **Default:** `os.constants.dlopen.RTLD_LAZY`
 
-The `process.dlopen()` method allows to dynamically load shared
-objects. It is primarily used by `require()` to load
-C++ Addons, and should not be used directly, except in special
-cases. In other words, [`require()`][] should be preferred over
-`process.dlopen()`, unless there are specific reasons.
+The `process.dlopen()` method allows dynamically loading shared objects. It is
+primarily used by `require()` to load C++ Addons, and should not be used
+directly, except in special cases. In other words, [`require()`][] should be
+preferred over `process.dlopen()` unless there are specific reasons such as
+custom dlopen flags or loading from ES modules.
 
 The `flags` argument is an integer that allows to specify dlopen
 behavior. See the [`os.constants.dlopen`][] documentation for details.
 
-If there are specific reasons to use `process.dlopen()` (for instance,
-to specify dlopen flags), it's often useful to use [`require.resolve()`][]
-to look up the module's path.
+An important requirement when calling `process.dlopen()` is that the `module`
+instance must be passed. Functions exported by the C++ Addon are then
+accessible via `module.exports`.
 
-An important drawback when calling `process.dlopen()` is that the `module`
-instance must be passed. Functions exported by the C++ Addon will be accessible
-via `module.exports`.
-
-The example below shows how to load a C++ Addon, named as `binding`,
-that exports a `foo` function. All the symbols will be loaded before
+The example below shows how to load a C++ Addon, named `local.node`,
+that exports a `foo` function. All the symbols are loaded before
 the call returns, by passing the `RTLD_NOW` constant. In this example
 the constant is assumed to be available.
 
 ```js
 const os = require('os');
-process.dlopen(module, require.resolve('binding'),
+const path = require('path');
+const module = { exports: {} };
+process.dlopen(module, path.join(__dirname, 'local.node'),
                os.constants.dlopen.RTLD_NOW);
 module.exports.foo();
 ```
@@ -1144,6 +1205,9 @@ And `process.argv`:
 ['/usr/local/bin/node', 'script.js', '--version']
 ```
 
+Refer to [`Worker` constructor][] for the detailed behavior of worker
+threads with this property.
+
 ## `process.execPath`
 <!-- YAML
 added: v0.1.100
@@ -1307,6 +1371,12 @@ The `process.getgroups()` method returns an array with the supplementary group
 IDs. POSIX leaves it unspecified if the effective group ID is included but
 Node.js ensures it always is.
 
+```js
+if (process.getgroups) {
+  console.log(process.getgroups()); // [ 16, 21, 297 ]
+}
+```
+
 This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 
@@ -1344,6 +1414,8 @@ Indicates whether a callback has been set using
 added: v0.7.6
 -->
 
+> Stability: 3 - Legacy. Use [`process.hrtime.bigint()`][] instead.
+
 * `time` {integer[]} The result of a previous call to `process.hrtime()`
 * Returns: {integer[]}
 
@@ -1475,8 +1547,11 @@ debugger. See [Signal Events][].
 ## `process.mainModule`
 <!-- YAML
 added: v0.1.17
+deprecated: v14.0.0
 -->
 
+> Stability: 0 - Deprecated: Use [`require.main`][] instead.
+
 * {Object}
 
 The `process.mainModule` property provides an alternative way of retrieving
@@ -1492,7 +1567,7 @@ is no entry script.
 <!-- YAML
 added: v0.1.16
 changes:
-  - version: v12.17.0
+  - version: v13.9.0
     pr-url: https://github.com/nodejs/node/pull/31550
     description: Added `arrayBuffers` to the returned object.
   - version: v7.2.0
@@ -1507,26 +1582,19 @@ changes:
   * `external` {integer}
   * `arrayBuffers` {integer}
 
-The `process.memoryUsage()` method returns an object describing the memory usage
-of the Node.js process measured in bytes.
-
-For example, the code:
+Returns an object describing the memory usage of the Node.js process measured in
+bytes.
 
 ```js
 console.log(process.memoryUsage());
-```
-
-Will generate:
-
-<!-- eslint-skip -->
-```js
-{
-  rss: 4935680,
-  heapTotal: 1826816,
-  heapUsed: 650472,
-  external: 49879,
-  arrayBuffers: 9386
-}
+// Prints:
+// {
+//  rss: 4935680,
+//  heapTotal: 1826816,
+//  heapUsed: 650472,
+//  external: 49879,
+//  arrayBuffers: 9386
+// }
 ```
 
 * `heapTotal` and `heapUsed` refer to V8's memory usage.
@@ -1544,6 +1612,32 @@ Will generate:
 When using [`Worker`][] threads, `rss` will be a value that is valid for the
 entire process, while the other fields will only refer to the current thread.
 
+The `process.memoryUsage()` method iterates over each page to gather
+information about memory usage which might be slow depending on the
+program memory allocations.
+
+## `process.memoryUsage.rss()`
+<!-- YAML
+added: v14.18.0
+-->
+
+* Returns: {integer}
+
+The `process.memoryUsage.rss()` method returns an integer representing the
+Resident Set Size (RSS) in bytes.
+
+The Resident Set Size, is the amount of space occupied in the main
+memory device (that is a subset of the total allocated memory) for the
+process, including all C++ and JavaScript objects and code.
+
+This is the same value as the `rss` property provided by `process.memoryUsage()`
+but `process.memoryUsage.rss()` is faster.
+
+```js
+console.log(process.memoryUsage.rss());
+// 35655680
+```
+
 ## `process.nextTick(callback[, ...args])`
 <!-- YAML
 added: v0.1.26
@@ -1635,6 +1729,70 @@ function definitelyAsync(arg, cb) {
 }
 ```
 
+### When to use `queueMicrotask()` vs. `process.nextTick()`
+
+The [`queueMicrotask()`][] API is an alternative to `process.nextTick()` that
+also defers execution of a function using the same microtask queue used to
+execute the then, catch, and finally handlers of resolved promises. Within
+Node.js, every time the "next tick queue" is drained, the microtask queue
+is drained immediately after.
+
+```js
+Promise.resolve().then(() => console.log(2));
+queueMicrotask(() => console.log(3));
+process.nextTick(() => console.log(1));
+// Output:
+// 1
+// 2
+// 3
+```
+
+For *most* userland use cases, the `queueMicrotask()` API provides a portable
+and reliable mechanism for deferring execution that works across multiple
+JavaScript platform environments and should be favored over `process.nextTick()`.
+In simple scenarios, `queueMicrotask()` can be a drop-in replacement for
+`process.nextTick()`.
+
+```js
+console.log('start');
+queueMicrotask(() => {
+  console.log('microtask callback');
+});
+console.log('scheduled');
+// Output:
+// start
+// scheduled
+// microtask callback
+```
+
+One note-worthy difference between the two APIs is that `process.nextTick()`
+allows specifying additional values that will be passed as arguments to the
+deferred function when it is called. Achieving the same result with
+`queueMicrotask()` requires using either a closure or a bound function:
+
+```js
+function deferred(a, b) {
+  console.log('microtask', a + b);
+}
+
+console.log('start');
+queueMicrotask(deferred.bind(undefined, 1, 2));
+console.log('scheduled');
+// Output:
+// start
+// scheduled
+// microtask 3
+```
+
+There are minor differences in the way errors raised from within the next tick
+queue and microtask queue are handled. Errors thrown within a queued microtask
+callback should be handled within the queued callback when possible. If they are
+not, the `process.on('uncaughtException')` event handler can be used to capture
+and handle the errors.
+
+When in doubt, unless the specific capabilities of `process.nextTick()` are
+needed, use `queueMicrotask()`.
+
 ## `process.noDeprecation`
 <!-- YAML
 added: v0.8.0
@@ -1723,8 +1881,7 @@ tarball.
 
 `process.release` contains the following properties:
 
-* `name` {string} A value that will always be `'node'` for Node.js. For
-  legacy io.js releases, this will be `'io.js'`.
+* `name` {string} A value that will always be `'node'`.
 * `sourceUrl` {string} an absolute URL pointing to a _`.tar.gz`_ file containing
   the source code of the current release.
 * `headersUrl`{string} an absolute URL pointing to a _`.tar.gz`_ file containing
@@ -1738,12 +1895,11 @@ tarball.
 * `lts` {string} a string label identifying the [LTS][] label for this release.
   This property only exists for LTS releases and is `undefined` for all other
   release types, including _Current_ releases.
-  Valid values include the LTS Release Codenames (including those
-  that are no longer supported). A non-exhaustive example of
-  these codenames includes:
+  Valid values include the LTS Release code names (including those
+  that are no longer supported).
   * `'Dubnium'` for the 10.x LTS line beginning with 10.13.0.
   * `'Erbium'` for the 12.x LTS line beginning with 12.13.0.
-  For other LTS Release Codenames, see [Node.js Changelog Archive](https://github.com/nodejs/node/blob/master/doc/changelogs/CHANGELOG_ARCHIVE.md)
+  For other LTS Release code names, see [Node.js Changelog Archive](https://github.com/nodejs/node/blob/HEAD/doc/changelogs/CHANGELOG_ARCHIVE.md)
 
 <!-- eslint-skip -->
 ```js
@@ -1764,7 +1920,7 @@ relied upon to exist.
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This API is no longer experimental.
 -->
@@ -1777,7 +1933,7 @@ reports for the current process. Additional documentation is available in the
 
 ### `process.report.compact`
 <!-- YAML
-added: v12.17.0
+added: v13.12.0
 -->
 
 * {boolean}
@@ -1794,7 +1950,7 @@ console.log(`Reports are compact? ${process.report.compact}`);
 <!-- YAML
 added: v11.12.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This API is no longer experimental.
 -->
@@ -1813,7 +1969,7 @@ console.log(`Report directory is ${process.report.directory}`);
 <!-- YAML
 added: v11.12.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This API is no longer experimental.
 -->
@@ -1832,7 +1988,7 @@ console.log(`Report filename is ${process.report.filename}`);
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This API is no longer experimental.
 -->
@@ -1846,11 +2002,11 @@ present.
 
 ```js
 const data = process.report.getReport();
-console.log(data.header.nodeJsVersion);
+console.log(data.header.nodejsVersion);
 
 // Similar to process.report.writeReport()
 const fs = require('fs');
-fs.writeFileSync(util.inspect(data), 'my-report.log', 'utf8');
+fs.writeFileSync('my-report.log', util.inspect(data), 'utf8');
 ```
 
 Additional documentation is available in the [report documentation][].
@@ -1858,10 +2014,13 @@ Additional documentation is available in the [report documentation][].
 ### `process.report.reportOnFatalError`
 <!-- YAML
 added: v11.12.0
+changes:
+  - version:
+     - v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/35654
+    description: This API is no longer experimental.
 -->
 
-> Stability: 1 - Experimental
-
 * {boolean}
 
 If `true`, a diagnostic report is generated on fatal errors, such as out of
@@ -1875,7 +2034,7 @@ console.log(`Report on fatal error: ${process.report.reportOnFatalError}`);
 <!-- YAML
 added: v11.12.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This API is no longer experimental.
 -->
@@ -1893,7 +2052,7 @@ console.log(`Report on signal: ${process.report.reportOnSignal}`);
 <!-- YAML
 added: v11.12.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This API is no longer experimental.
 -->
@@ -1910,7 +2069,7 @@ console.log(`Report on exception: ${process.report.reportOnUncaughtException}`);
 <!-- YAML
 added: v11.12.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This API is no longer experimental.
 -->
@@ -1928,7 +2087,7 @@ console.log(`Report signal: ${process.report.signal}`);
 <!-- YAML
 added: v11.8.0
 changes:
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/32242
     description: This API is no longer experimental.
 -->
@@ -2144,7 +2303,18 @@ The `process.setgroups()` method sets the supplementary group IDs for the
 Node.js process. This is a privileged operation that requires the Node.js
 process to have `root` or the `CAP_SETGID` capability.
 
-The `groups` array can contain numeric group IDs, group names or both.
+The `groups` array can contain numeric group IDs, group names, or both.
+
+```js
+if (process.getgroups && process.setgroups) {
+  try {
+    process.setgroups([501]);
+    console.log(process.getgroups()); // new groups
+  } catch (err) {
+    console.log(`Failed to set groups: ${err}`);
+  }
+}
+```
 
 This function is only available on POSIX platforms (i.e. not Windows or
 Android).
@@ -2178,6 +2348,24 @@ This function is only available on POSIX platforms (i.e. not Windows or
 Android).
 This feature is not available in [`Worker`][] threads.
 
+## `process.setSourceMapsEnabled(val)`
+<!-- YAML
+added: v14.18.0
+-->
+
+> Stability: 1 - Experimental
+
+* `val` {boolean}
+
+This function enables or disables the [Source Map v3][Source Map] support for
+stack traces.
+
+It provides same features as launching Node.js process with commandline options
+`--enable-source-maps`.
+
+Only source maps in JavaScript files that are loaded after source maps has been
+enabled will be parsed and loaded.
+
 ## `process.setUncaughtExceptionCaptureCallback(fn)`
 <!-- YAML
 added: v9.3.0
@@ -2192,7 +2380,8 @@ exception value itself as its first argument.
 If such a function is set, the [`'uncaughtException'`][] event will
 not be emitted. If `--abort-on-uncaught-exception` was passed from the
 command line or set through [`v8.setFlagsFromString()`][], the process will
-not abort.
+not abort. Actions configured to take place on exceptions such as report
+generations will be affected too
 
 To unset the capture function,
 `process.setUncaughtExceptionCaptureCallback(null)` may be used. Calling this
@@ -2367,7 +2556,7 @@ the current value of `ps`.
 When a new value is assigned, different platforms will impose different maximum
 length restrictions on the title. Usually such restrictions are quite limited.
 For instance, on Linux and macOS, `process.title` is limited to the size of the
-binary name plus the length of the command line arguments because setting the
+binary name plus the length of the command-line arguments because setting the
 `process.title` overwrites the `argv` memory of the process. Node.js v0.8
 allowed for longer process title strings by also overwriting the `environ`
 memory but that was potentially insecure and confusing in some (rather obscure)
@@ -2395,8 +2584,8 @@ flag's behavior.
 added: v0.1.19
 changes:
   - version:
-    - v12.19.0
     - v14.0.0
+    - v12.19.0
     pr-url: https://github.com/nodejs/node/pull/32499
     description: Calling `process.umask()` with no arguments is deprecated.
 
@@ -2464,12 +2653,12 @@ To get the version string without the prepended _v_, use
 <!-- YAML
 added: v0.2.0
 changes:
-  - version: v4.2.0
-    pr-url: https://github.com/nodejs/node/pull/3102
-    description: The `icu` property is now supported.
   - version: v9.0.0
     pr-url: https://github.com/nodejs/node/pull/15785
     description: The `v8` property now includes a Node.js specific suffix.
+  - version: v4.2.0
+    pr-url: https://github.com/nodejs/node/pull/3102
+    description: The `icu` property is now supported.
 -->
 
 * {Object}
@@ -2496,7 +2685,6 @@ Will generate an object similar to:
   nghttp2: '1.34.0',
   napi: '4',
   llhttp: '1.1.1',
-  http_parser: '2.8.0',
   openssl: '1.1.1b',
   cldr: '34.0',
   icu: '63.1',
@@ -2543,6 +2731,8 @@ cases:
   and generally can only happen during development of Node.js itself.
 * `12` **Invalid Debug Argument**: The `--inspect` and/or `--inspect-brk`
   options were set, but the port number chosen was invalid or unavailable.
+* `13` **Unfinished Top-Level Await**: `await` was used outside of a function
+  in the top-level code, but the passed `Promise` never resolved.
 * `>128` **Signal Exits**: If Node.js receives a fatal signal such as
   `SIGKILL` or `SIGHUP`, then its exit code will be `128` plus the
   value of the signal code. This is a standard POSIX practice, since
@@ -2551,24 +2741,39 @@ cases:
   For example, signal `SIGABRT` has value `6`, so the expected exit
   code will be `128` + `6`, or `134`.
 
+[Advanced serialization for `child_process`]: child_process.md#child_process_advanced_serialization
+[Android building]: https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os
+[Child Process]: child_process.md
+[Cluster]: cluster.md
+[Duplex]: stream.md#stream_duplex_and_transform_streams
+[Event Loop]: https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick
+[LTS]: https://github.com/nodejs/Release
+[Readable]: stream.md#stream_readable_streams
+[Signal Events]: #process_signal_events
+[Source Map]: https://sourcemaps.info/spec.html
+[Stream compatibility]: stream.md#stream_compatibility_with_older_node_js_versions
+[TTY]: tty.md#tty_tty
+[Writable]: stream.md#stream_writable_streams
 [`'exit'`]: #process_event_exit
-[`'message'`]: child_process.html#child_process_event_message
+[`'message'`]: child_process.md#child_process_event_message
 [`'uncaughtException'`]: #process_event_uncaughtexception
-[`--unhandled-rejections`]: cli.html#cli_unhandled_rejections_mode
-[`Buffer`]: buffer.html
-[`ChildProcess.disconnect()`]: child_process.html#child_process_subprocess_disconnect
-[`ChildProcess.send()`]: child_process.html#child_process_subprocess_send_message_sendhandle_options_callback
-[`ChildProcess`]: child_process.html#child_process_class_childprocess
-[`Error`]: errors.html#errors_class_error
-[`EventEmitter`]: events.html#events_class_eventemitter
-[`NODE_OPTIONS`]: cli.html#cli_node_options_options
-[`Worker`]: worker_threads.html#worker_threads_class_worker
-[`console.error()`]: console.html#console_console_error_data_args
-[`console.log()`]: console.html#console_console_log_data_args
-[`domain`]: domain.html
-[`net.Server`]: net.html#net_class_net_server
-[`net.Socket`]: net.html#net_class_net_socket
-[`os.constants.dlopen`]: os.html#os_dlopen_constants
+[`--unhandled-rejections`]: cli.md#cli_unhandled_rejections_mode
+[`Buffer`]: buffer.md
+[`ChildProcess.disconnect()`]: child_process.md#child_process_subprocess_disconnect
+[`ChildProcess.send()`]: child_process.md#child_process_subprocess_send_message_sendhandle_options_callback
+[`ChildProcess`]: child_process.md#child_process_class_childprocess
+[`Error`]: errors.md#errors_class_error
+[`EventEmitter`]: events.md#events_class_eventemitter
+[`NODE_OPTIONS`]: cli.md#cli_node_options_options
+[`Promise.race()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race
+[`Worker`]: worker_threads.md#worker_threads_class_worker
+[`Worker` constructor]: worker_threads.md#worker_threads_new_worker_filename_options
+[`console.error()`]: console.md#console_console_error_data_args
+[`console.log()`]: console.md#console_console_log_data_args
+[`domain`]: domain.md
+[`net.Server`]: net.md#net_class_net_server
+[`net.Socket`]: net.md#net_class_net_socket
+[`os.constants.dlopen`]: os.md#os_dlopen_constants
 [`process.argv`]: #process_process_argv
 [`process.config`]: #process_process_config
 [`process.execPath`]: #process_process_execpath
@@ -2577,34 +2782,22 @@ cases:
 [`process.hrtime()`]: #process_process_hrtime_time
 [`process.hrtime.bigint()`]: #process_process_hrtime_bigint
 [`process.kill()`]: #process_process_kill_pid_signal
-[`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
+[`process.setUncaughtExceptionCaptureCallback()`]: #process_process_setuncaughtexceptioncapturecallback_fn
 [`promise.catch()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch
-[`Promise.race()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race
-[`require()`]: globals.html#globals_require
-[`require.main`]: modules.html#modules_accessing_the_main_module
-[`require.resolve()`]: modules.html#modules_require_resolve_request_options
-[`subprocess.kill()`]: child_process.html#child_process_subprocess_kill_signal
-[`v8.setFlagsFromString()`]: v8.html#v8_v8_setflagsfromstring_flags
-[Advanced serialization for `child_process`]: child_process.html#child_process_advanced_serialization
-[Android building]: https://github.com/nodejs/node/blob/master/BUILDING.md#androidandroid-based-devices-eg-firefox-os
-[Child Process]: child_process.html
-[Cluster]: cluster.html
-[Duplex]: stream.html#stream_duplex_and_transform_streams
-[Event Loop]: https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick
-[LTS]: https://github.com/nodejs/Release
-[Readable]: stream.html#stream_readable_streams
-[`readable.read()`]: stream.html#stream_readable_read_size
-[Signal Events]: #process_signal_events
-[Stream compatibility]: stream.html#stream_compatibility_with_older_node_js_versions
-[TTY]: tty.html#tty_tty
-[Writable]: stream.html#stream_writable_streams
-[debugger]: debugger.html
-[note on process I/O]: process.html#process_a_note_on_process_i_o
+[`queueMicrotask()`]: globals.md#globals_queuemicrotask_callback
+[`readable.read()`]: stream.md#stream_readable_read_size
+[`require()`]: globals.md#globals_require
+[`require.main`]: modules.md#modules_accessing_the_main_module
+[`subprocess.kill()`]: child_process.md#child_process_subprocess_kill_signal
+[`v8.setFlagsFromString()`]: v8.md#v8_v8_setflagsfromstring_flags
+[debugger]: debugger.md
+[deprecation code]: deprecations.md
+[note on process I/O]: #process_a_note_on_process_i_o
 [process.cpuUsage]: #process_process_cpuusage_previousvalue
 [process_emit_warning]: #process_process_emitwarning_warning_type_code_ctor
 [process_warning]: #process_event_warning
-[report documentation]: report.html
-[terminal raw mode]: tty.html#tty_readstream_setrawmode_mode
+[report documentation]: report.md
+[terminal raw mode]: tty.md#tty_readstream_setrawmode_mode
 [uv_rusage_t]: https://docs.libuv.org/en/v1.x/misc.html#c.uv_rusage_t
-[wikipedia_minor_fault]: https://en.wikipedia.org/wiki/Page_fault#Minor
 [wikipedia_major_fault]: https://en.wikipedia.org/wiki/Page_fault#Major
+[wikipedia_minor_fault]: https://en.wikipedia.org/wiki/Page_fault#Minor
diff --git a/doc/api/punycode.html b/doc/api/punycode.html
index 26d0f95d85f6fc0627da5832e61940d08ecc7652..cc306731cbe00c8200880fab8f0c6f73d6d8828d 100644
--- a/doc/api/punycode.html
+++ b/doc/api/punycode.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Punycode | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Punycode | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="punycode" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/punycode.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/punycode.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/punycode.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/punycode.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/punycode.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/punycode.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/punycode.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/punycode.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/punycode.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_0"><a href="#punycode_punycode">Punycode</a></span>
 <ul>
 <li><a href="#punycode_punycode_decode_string"><code>punycode.decode(string)</code></a></li>
@@ -142,21 +155,22 @@
 <li><a href="#punycode_punycode_version"><code>punycode.version</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Punycode<span><a class="mark" href="#punycode_punycode" id="punycode_punycode">#</a></span></h1>
+        <h2>Punycode<span><a class="mark" href="#punycode_punycode" id="punycode_punycode">#</a></span></h2>
 <div class="api_metadata">
 <span>Deprecated since: v7.0.0</span>
 </div>
 
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/punycode.js">lib/punycode.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/punycode.js">lib/punycode.js</a></p>
 <p><strong>The version of the punycode module bundled in Node.js is being deprecated</strong>.
 In a future major version of Node.js this module will be removed. Users
 currently depending on the <code>punycode</code> module should switch to using the
-userland-provided <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> module instead.</p>
+userland-provided <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> module instead. For punycode-based URL
+encoding, see <a href="url.html#url_url_domaintoascii_domain"><code>url.domainToASCII</code></a> or, more generally, the
+<a href="url.html#url_the_whatwg_url_api">WHATWG URL API</a>.</p>
 <p>The <code>punycode</code> module is a bundled version of the <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> module. It
 can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> punycode = <span class="hljs-built_in">require</span>(<span class="hljs-string">'punycode'</span>);</code></pre>
@@ -172,7 +186,7 @@ to <code>'example.com'</code>) is represented by Punycode as the ASCII string
 <p>The <code>punycode</code> module is a third-party dependency used by Node.js and
 made available to developers as a convenience. Fixes or other modifications to
 the module must be directed to the <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> project.</p>
-<h2><code>punycode.decode(string)</code><span><a class="mark" href="#punycode_punycode_decode_string" id="punycode_punycode_decode_string">#</a></span></h2>
+<section><h3><code>punycode.decode(string)</code><span><a class="mark" href="#punycode_punycode_decode_string" id="punycode_punycode_decode_string">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.1</span>
 </div>
@@ -181,9 +195,9 @@ the module must be directed to the <a href="https://github.com/bestiejs/punycode
 </ul>
 <p>The <code>punycode.decode()</code> method converts a <a href="https://tools.ietf.org/html/rfc3492">Punycode</a> string of ASCII-only
 characters to the equivalent string of Unicode codepoints.</p>
-<pre><code class="language-js">punycode.decode(<span class="hljs-string">'maana-pta'</span>); <span class="hljs-comment">// 'mañana'</span>
-punycode.decode(<span class="hljs-string">'--dqo34k'</span>); <span class="hljs-comment">// '☃-⌘'</span></code></pre>
-<h2><code>punycode.encode(string)</code><span><a class="mark" href="#punycode_punycode_encode_string" id="punycode_punycode_encode_string">#</a></span></h2>
+<pre><code class="language-js">punycode.<span class="hljs-title function_">decode</span>(<span class="hljs-string">'maana-pta'</span>); <span class="hljs-comment">// 'mañana'</span>
+punycode.<span class="hljs-title function_">decode</span>(<span class="hljs-string">'--dqo34k'</span>); <span class="hljs-comment">// '☃-⌘'</span></code></pre>
+</section><section><h3><code>punycode.encode(string)</code><span><a class="mark" href="#punycode_punycode_encode_string" id="punycode_punycode_encode_string">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.1</span>
 </div>
@@ -192,9 +206,9 @@ punycode.decode(<span class="hljs-string">'--dqo34k'</span>); <span class="hljs-
 </ul>
 <p>The <code>punycode.encode()</code> method converts a string of Unicode codepoints to a
 <a href="https://tools.ietf.org/html/rfc3492">Punycode</a> string of ASCII-only characters.</p>
-<pre><code class="language-js">punycode.encode(<span class="hljs-string">'mañana'</span>); <span class="hljs-comment">// 'maana-pta'</span>
-punycode.encode(<span class="hljs-string">'☃-⌘'</span>); <span class="hljs-comment">// '--dqo34k'</span></code></pre>
-<h2><code>punycode.toASCII(domain)</code><span><a class="mark" href="#punycode_punycode_toascii_domain" id="punycode_punycode_toascii_domain">#</a></span></h2>
+<pre><code class="language-js">punycode.<span class="hljs-title function_">encode</span>(<span class="hljs-string">'mañana'</span>); <span class="hljs-comment">// 'maana-pta'</span>
+punycode.<span class="hljs-title function_">encode</span>(<span class="hljs-string">'☃-⌘'</span>); <span class="hljs-comment">// '--dqo34k'</span></code></pre>
+</section><section><h3><code>punycode.toASCII(domain)</code><span><a class="mark" href="#punycode_punycode_toascii_domain" id="punycode_punycode_toascii_domain">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.1</span>
 </div>
@@ -206,10 +220,10 @@ Internationalized Domain Name to <a href="https://tools.ietf.org/html/rfc3492">P
 domain name will be converted. Calling <code>punycode.toASCII()</code> on a string that
 already only contains ASCII characters will have no effect.</p>
 <pre><code class="language-js"><span class="hljs-comment">// encode domain names</span>
-punycode.toASCII(<span class="hljs-string">'mañana.com'</span>);  <span class="hljs-comment">// 'xn--maana-pta.com'</span>
-punycode.toASCII(<span class="hljs-string">'☃-⌘.com'</span>);   <span class="hljs-comment">// 'xn----dqo34k.com'</span>
-punycode.toASCII(<span class="hljs-string">'example.com'</span>); <span class="hljs-comment">// 'example.com'</span></code></pre>
-<h2><code>punycode.toUnicode(domain)</code><span><a class="mark" href="#punycode_punycode_tounicode_domain" id="punycode_punycode_tounicode_domain">#</a></span></h2>
+punycode.<span class="hljs-title function_">toASCII</span>(<span class="hljs-string">'mañana.com'</span>);  <span class="hljs-comment">// 'xn--maana-pta.com'</span>
+punycode.<span class="hljs-title function_">toASCII</span>(<span class="hljs-string">'☃-⌘.com'</span>);   <span class="hljs-comment">// 'xn----dqo34k.com'</span>
+punycode.<span class="hljs-title function_">toASCII</span>(<span class="hljs-string">'example.com'</span>); <span class="hljs-comment">// 'example.com'</span></code></pre>
+</section><section><h3><code>punycode.toUnicode(domain)</code><span><a class="mark" href="#punycode_punycode_tounicode_domain" id="punycode_punycode_tounicode_domain">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.1</span>
 </div>
@@ -220,14 +234,14 @@ punycode.toASCII(<span class="hljs-string">'example.com'</span>); <span class="h
 containing <a href="https://tools.ietf.org/html/rfc3492">Punycode</a> encoded characters into Unicode. Only the <a href="https://tools.ietf.org/html/rfc3492">Punycode</a>
 encoded parts of the domain name are be converted.</p>
 <pre><code class="language-js"><span class="hljs-comment">// decode domain names</span>
-punycode.toUnicode(<span class="hljs-string">'xn--maana-pta.com'</span>); <span class="hljs-comment">// 'mañana.com'</span>
-punycode.toUnicode(<span class="hljs-string">'xn----dqo34k.com'</span>);  <span class="hljs-comment">// '☃-⌘.com'</span>
-punycode.toUnicode(<span class="hljs-string">'example.com'</span>);       <span class="hljs-comment">// 'example.com'</span></code></pre>
-<h2><code>punycode.ucs2</code><span><a class="mark" href="#punycode_punycode_ucs2" id="punycode_punycode_ucs2">#</a></span></h2>
+punycode.<span class="hljs-title function_">toUnicode</span>(<span class="hljs-string">'xn--maana-pta.com'</span>); <span class="hljs-comment">// 'mañana.com'</span>
+punycode.<span class="hljs-title function_">toUnicode</span>(<span class="hljs-string">'xn----dqo34k.com'</span>);  <span class="hljs-comment">// '☃-⌘.com'</span>
+punycode.<span class="hljs-title function_">toUnicode</span>(<span class="hljs-string">'example.com'</span>);       <span class="hljs-comment">// 'example.com'</span></code></pre>
+</section><section><h3><code>punycode.ucs2</code><span><a class="mark" href="#punycode_punycode_ucs2" id="punycode_punycode_ucs2">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
-<h3><code>punycode.ucs2.decode(string)</code><span><a class="mark" href="#punycode_punycode_ucs2_decode_string" id="punycode_punycode_ucs2_decode_string">#</a></span></h3>
+<h4><code>punycode.ucs2.decode(string)</code><span><a class="mark" href="#punycode_punycode_ucs2_decode_string" id="punycode_punycode_ucs2_decode_string">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -236,10 +250,10 @@ punycode.toUnicode(<span class="hljs-string">'example.com'</span>);       <span
 </ul>
 <p>The <code>punycode.ucs2.decode()</code> method returns an array containing the numeric
 codepoint values of each Unicode symbol in the string.</p>
-<pre><code class="language-js">punycode.ucs2.decode(<span class="hljs-string">'abc'</span>); <span class="hljs-comment">// [0x61, 0x62, 0x63]</span>
+<pre><code class="language-js">punycode.<span class="hljs-property">ucs2</span>.<span class="hljs-title function_">decode</span>(<span class="hljs-string">'abc'</span>); <span class="hljs-comment">// [0x61, 0x62, 0x63]</span>
 <span class="hljs-comment">// surrogate pair for U+1D306 tetragram for centre:</span>
-punycode.ucs2.decode(<span class="hljs-string">'\uD834\uDF06'</span>); <span class="hljs-comment">// [0x1D306]</span></code></pre>
-<h3><code>punycode.ucs2.encode(codePoints)</code><span><a class="mark" href="#punycode_punycode_ucs2_encode_codepoints" id="punycode_punycode_ucs2_encode_codepoints">#</a></span></h3>
+punycode.<span class="hljs-property">ucs2</span>.<span class="hljs-title function_">decode</span>(<span class="hljs-string">'\uD834\uDF06'</span>); <span class="hljs-comment">// [0x1D306]</span></code></pre>
+<h4><code>punycode.ucs2.encode(codePoints)</code><span><a class="mark" href="#punycode_punycode_ucs2_encode_codepoints" id="punycode_punycode_ucs2_encode_codepoints">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
@@ -248,19 +262,55 @@ punycode.ucs2.decode(<span class="hljs-string">'\uD834\uDF06'</span>); <span cla
 </ul>
 <p>The <code>punycode.ucs2.encode()</code> method returns a string based on an array of
 numeric code point values.</p>
-<pre><code class="language-js">punycode.ucs2.encode([<span class="hljs-number">0x61</span>, <span class="hljs-number">0x62</span>, <span class="hljs-number">0x63</span>]); <span class="hljs-comment">// 'abc'</span>
-punycode.ucs2.encode([<span class="hljs-number">0x1D306</span>]); <span class="hljs-comment">// '\uD834\uDF06'</span></code></pre>
-<h2><code>punycode.version</code><span><a class="mark" href="#punycode_punycode_version" id="punycode_punycode_version">#</a></span></h2>
+<pre><code class="language-js">punycode.<span class="hljs-property">ucs2</span>.<span class="hljs-title function_">encode</span>([<span class="hljs-number">0x61</span>, <span class="hljs-number">0x62</span>, <span class="hljs-number">0x63</span>]); <span class="hljs-comment">// 'abc'</span>
+punycode.<span class="hljs-property">ucs2</span>.<span class="hljs-title function_">encode</span>([<span class="hljs-number">0x1D306</span>]); <span class="hljs-comment">// '\uD834\uDF06'</span></code></pre>
+</section><section><h3><code>punycode.version</code><span><a class="mark" href="#punycode_punycode_version" id="punycode_punycode_version">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.6.1</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
-<p>Returns a string identifying the current <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> version number.</p>
+<p>Returns a string identifying the current <a href="https://github.com/bestiejs/punycode.js">Punycode.js</a> version number.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/punycode.json b/doc/api/punycode.json
index b5e611d8f838a93c4531823a8bbe5ba8b77a60cc..8ddddc067de16ddfd2bf62b1339ed0f4702c1383 100644
--- a/doc/api/punycode.json
+++ b/doc/api/punycode.json
@@ -14,7 +14,7 @@
       "introduced_in": "v0.10.0",
       "stability": 0,
       "stabilityText": "Deprecated",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/punycode.js\">lib/punycode.js</a></p>\n<p><strong>The version of the punycode module bundled in Node.js is being deprecated</strong>.\nIn a future major version of Node.js this module will be removed. Users\ncurrently depending on the <code>punycode</code> module should switch to using the\nuserland-provided <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> module instead.</p>\n<p>The <code>punycode</code> module is a bundled version of the <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> module. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const punycode = require('punycode');\n</code></pre>\n<p><a href=\"https://tools.ietf.org/html/rfc3492\">Punycode</a> is a character encoding scheme defined by RFC 3492 that is\nprimarily intended for use in Internationalized Domain Names. Because host\nnames in URLs are limited to ASCII characters only, Domain Names that contain\nnon-ASCII characters must be converted into ASCII using the Punycode scheme.\nFor instance, the Japanese character that translates into the English word,\n<code>'example'</code> is <code>'例'</code>. The Internationalized Domain Name, <code>'例.com'</code> (equivalent\nto <code>'example.com'</code>) is represented by Punycode as the ASCII string\n<code>'xn--fsq.com'</code>.</p>\n<p>The <code>punycode</code> module provides a simple implementation of the Punycode standard.</p>\n<p>The <code>punycode</code> module is a third-party dependency used by Node.js and\nmade available to developers as a convenience. Fixes or other modifications to\nthe module must be directed to the <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> project.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/punycode.js\">lib/punycode.js</a></p>\n<p><strong>The version of the punycode module bundled in Node.js is being deprecated</strong>.\nIn a future major version of Node.js this module will be removed. Users\ncurrently depending on the <code>punycode</code> module should switch to using the\nuserland-provided <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> module instead. For punycode-based URL\nencoding, see <a href=\"url.html#url_url_domaintoascii_domain\"><code>url.domainToASCII</code></a> or, more generally, the\n<a href=\"url.html#url_the_whatwg_url_api\">WHATWG URL API</a>.</p>\n<p>The <code>punycode</code> module is a bundled version of the <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> module. It\ncan be accessed using:</p>\n<pre><code class=\"language-js\">const punycode = require('punycode');\n</code></pre>\n<p><a href=\"https://tools.ietf.org/html/rfc3492\">Punycode</a> is a character encoding scheme defined by RFC 3492 that is\nprimarily intended for use in Internationalized Domain Names. Because host\nnames in URLs are limited to ASCII characters only, Domain Names that contain\nnon-ASCII characters must be converted into ASCII using the Punycode scheme.\nFor instance, the Japanese character that translates into the English word,\n<code>'example'</code> is <code>'例'</code>. The Internationalized Domain Name, <code>'例.com'</code> (equivalent\nto <code>'example.com'</code>) is represented by Punycode as the ASCII string\n<code>'xn--fsq.com'</code>.</p>\n<p>The <code>punycode</code> module provides a simple implementation of the Punycode standard.</p>\n<p>The <code>punycode</code> module is a third-party dependency used by Node.js and\nmade available to developers as a convenience. Fixes or other modifications to\nthe module must be directed to the <a href=\"https://github.com/bestiejs/punycode.js\">Punycode.js</a> project.</p>",
       "methods": [
         {
           "textRaw": "`punycode.decode(string)`",
diff --git a/doc/api/punycode.md b/doc/api/punycode.md
index 620585afa484c116bf9139c72af5274dbbfe892e..c9c20ce6350c7e3bfcd0a3a692c65c2ac836eaf5 100644
--- a/doc/api/punycode.md
+++ b/doc/api/punycode.md
@@ -12,7 +12,9 @@ deprecated: v7.0.0
 **The version of the punycode module bundled in Node.js is being deprecated**.
 In a future major version of Node.js this module will be removed. Users
 currently depending on the `punycode` module should switch to using the
-userland-provided [Punycode.js][] module instead.
+userland-provided [Punycode.js][] module instead. For punycode-based URL
+encoding, see [`url.domainToASCII`][] or, more generally, the
+[WHATWG URL API][].
 
 The `punycode` module is a bundled version of the [Punycode.js][] module. It
 can be accessed using:
@@ -150,3 +152,5 @@ Returns a string identifying the current [Punycode.js][] version number.
 
 [Punycode]: https://tools.ietf.org/html/rfc3492
 [Punycode.js]: https://github.com/bestiejs/punycode.js
+[WHATWG URL API]: url.md#url_the_whatwg_url_api
+[`url.domainToASCII`]: url.md#url_url_domaintoascii_domain
diff --git a/doc/api/querystring.html b/doc/api/querystring.html
index de55d5ac30933c6b6720344413a8555fb8bf5ede..0061b04f0050551f8d7db74b78af321b4afc01a0 100644
--- a/doc/api/querystring.html
+++ b/doc/api/querystring.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Query string | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Query string | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="querystring" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/querystring.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/querystring.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/querystring.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/querystring.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/querystring.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/querystring.html">13.x</a></li>
@@ -118,16 +133,14 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/querystring.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/querystring.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/querystring.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
-<li><span class="stability_2"><a href="#querystring_query_string">Query string</a></span>
+      <details id="toc" open><summary>Table of contents</summary><ul>
+<li><span class="stability_3"><a href="#querystring_query_string">Query string</a></span>
 <ul>
 <li><a href="#querystring_querystring_decode"><code>querystring.decode()</code></a></li>
 <li><a href="#querystring_querystring_encode"><code>querystring.encode()</code></a></li>
@@ -137,29 +150,30 @@
 <li><a href="#querystring_querystring_unescape_str"><code>querystring.unescape(str)</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Query string<span><a class="mark" href="#querystring_query_string" id="querystring_query_string">#</a></span></h1>
+        <h2>Query string<span><a class="mark" href="#querystring_query_string" id="querystring_query_string">#</a></span></h2>
 
-<p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/querystring.js">lib/querystring.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/querystring.js">lib/querystring.js</a></p>
 <p>The <code>querystring</code> module provides utilities for parsing and formatting URL
 query strings. It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> querystring = <span class="hljs-built_in">require</span>(<span class="hljs-string">'querystring'</span>);</code></pre>
-<h2><code>querystring.decode()</code><span><a class="mark" href="#querystring_querystring_decode" id="querystring_querystring_decode">#</a></span></h2>
+<p>The <code>querystring</code> API is considered Legacy. While it is still maintained,
+new code should use the <a href="url.html#url_class_urlsearchparams" class="type">&#x3C;URLSearchParams></a> API instead.</p>
+<section><h3><code>querystring.decode()</code><span><a class="mark" href="#querystring_querystring_decode" id="querystring_querystring_decode">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
 <p>The <code>querystring.decode()</code> function is an alias for <code>querystring.parse()</code>.</p>
-<h2><code>querystring.encode()</code><span><a class="mark" href="#querystring_querystring_encode" id="querystring_querystring_encode">#</a></span></h2>
+</section><section><h3><code>querystring.encode()</code><span><a class="mark" href="#querystring_querystring_encode" id="querystring_querystring_encode">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
 <p>The <code>querystring.encode()</code> function is an alias for <code>querystring.stringify()</code>.</p>
-<h2><code>querystring.escape(str)</code><span><a class="mark" href="#querystring_querystring_escape_str" id="querystring_querystring_escape_str">#</a></span></h2>
+</section><section><h3><code>querystring.escape(str)</code><span><a class="mark" href="#querystring_querystring_escape_str" id="querystring_querystring_escape_str">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.25</span>
 </div>
@@ -173,7 +187,7 @@ query strings.</p>
 generally not expected to be used directly. It is exported primarily to allow
 application code to provide a replacement percent-encoding implementation if
 necessary by assigning <code>querystring.escape</code> to an alternative function.</p>
-<h2><code>querystring.parse(str[, sep[, eq[, options]]])</code><span><a class="mark" href="#querystring_querystring_parse_str_sep_eq_options" id="querystring_querystring_parse_str_sep_eq_options">#</a></span></h2>
+</section><section><h3><code>querystring.parse(str[, sep[, eq[, options]]])</code><span><a class="mark" href="#querystring_querystring_parse_str_sep_eq_options" id="querystring_querystring_parse_str_sep_eq_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -222,9 +236,9 @@ to use UTF-8 encoding. If an alternative character encoding is used, then an
 alternative <code>decodeURIComponent</code> option will need to be specified:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Assuming gbkDecodeURIComponent function already exists...</span>
 
-querystring.parse(<span class="hljs-string">'w=%D6%D0%CE%C4&#x26;foo=bar'</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>,
+querystring.<span class="hljs-title function_">parse</span>(<span class="hljs-string">'w=%D6%D0%CE%C4&#x26;foo=bar'</span>, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>,
                   { <span class="hljs-attr">decodeURIComponent</span>: gbkDecodeURIComponent });</code></pre>
-<h2><code>querystring.stringify(obj[, sep[, eq[, options]]])</code><span><a class="mark" href="#querystring_querystring_stringify_obj_sep_eq_options" id="querystring_querystring_stringify_obj_sep_eq_options">#</a></span></h2>
+</section><section><h3><code>querystring.stringify(obj[, sep[, eq[, options]]])</code><span><a class="mark" href="#querystring_querystring_stringify_obj_sep_eq_options" id="querystring_querystring_stringify_obj_sep_eq_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.25</span>
 </div>
@@ -245,21 +259,22 @@ URL-unsafe characters to percent-encoding in the query string. <strong>Default:<
 <p>The <code>querystring.stringify()</code> method produces a URL query string from a
 given <code>obj</code> by iterating through the object's "own properties".</p>
 <p>It serializes the following types of values passed in <code>obj</code>:
-<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean[]></a>
-Any other input values will be coerced to empty strings.</p>
-<pre><code class="language-js">querystring.stringify({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: [<span class="hljs-string">'qux'</span>, <span class="hljs-string">'quux'</span>], <span class="hljs-attr">corge</span>: <span class="hljs-string">''</span> });
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" class="type">&#x3C;bigint[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean[]></a>
+The numeric values must be finite. Any other input values will be coerced to
+empty strings.</p>
+<pre><code class="language-js">querystring.<span class="hljs-title function_">stringify</span>({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: [<span class="hljs-string">'qux'</span>, <span class="hljs-string">'quux'</span>], <span class="hljs-attr">corge</span>: <span class="hljs-string">''</span> });
 <span class="hljs-comment">// Returns 'foo=bar&#x26;baz=qux&#x26;baz=quux&#x26;corge='</span>
 
-querystring.stringify({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: <span class="hljs-string">'qux'</span> }, <span class="hljs-string">';'</span>, <span class="hljs-string">':'</span>);
+querystring.<span class="hljs-title function_">stringify</span>({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span>, <span class="hljs-attr">baz</span>: <span class="hljs-string">'qux'</span> }, <span class="hljs-string">';'</span>, <span class="hljs-string">':'</span>);
 <span class="hljs-comment">// Returns 'foo:bar;baz:qux'</span></code></pre>
 <p>By default, characters requiring percent-encoding within the query string will
 be encoded as UTF-8. If an alternative encoding is required, then an alternative
 <code>encodeURIComponent</code> option will need to be specified:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Assuming gbkEncodeURIComponent function already exists,</span>
 
-querystring.stringify({ <span class="hljs-attr">w</span>: <span class="hljs-string">'中文'</span>, <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span> }, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>,
+querystring.<span class="hljs-title function_">stringify</span>({ <span class="hljs-attr">w</span>: <span class="hljs-string">'中文'</span>, <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span> }, <span class="hljs-literal">null</span>, <span class="hljs-literal">null</span>,
                       { <span class="hljs-attr">encodeURIComponent</span>: gbkEncodeURIComponent });</code></pre>
-<h2><code>querystring.unescape(str)</code><span><a class="mark" href="#querystring_querystring_unescape_str" id="querystring_querystring_unescape_str">#</a></span></h2>
+</section><section><h3><code>querystring.unescape(str)</code><span><a class="mark" href="#querystring_querystring_unescape_str" id="querystring_querystring_unescape_str">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.25</span>
 </div>
@@ -274,10 +289,46 @@ application code to provide a replacement decoding implementation if
 necessary by assigning <code>querystring.unescape</code> to an alternative function.</p>
 <p>By default, the <code>querystring.unescape()</code> method will attempt to use the
 JavaScript built-in <code>decodeURIComponent()</code> method to decode. If that fails,
-a safer equivalent that does not throw on malformed URLs will be used.</p>
+a safer equivalent that does not throw on malformed URLs will be used.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/querystring.json b/doc/api/querystring.json
index ad255d3fce5d331b8a37d464d9b8f58c695f922a..9f4bb31a56bf062c0f69056d1cbf454bef11b1d4 100644
--- a/doc/api/querystring.json
+++ b/doc/api/querystring.json
@@ -6,9 +6,9 @@
       "textRaw": "Query string",
       "name": "querystring",
       "introduced_in": "v0.1.25",
-      "stability": 2,
-      "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/querystring.js\">lib/querystring.js</a></p>\n<p>The <code>querystring</code> module provides utilities for parsing and formatting URL\nquery strings. It can be accessed using:</p>\n<pre><code class=\"language-js\">const querystring = require('querystring');\n</code></pre>",
+      "stability": 3,
+      "stabilityText": "Legacy",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/querystring.js\">lib/querystring.js</a></p>\n<p>The <code>querystring</code> module provides utilities for parsing and formatting URL\nquery strings. It can be accessed using:</p>\n<pre><code class=\"language-js\">const querystring = require('querystring');\n</code></pre>\n<p>The <code>querystring</code> API is considered Legacy. While it is still maintained,\nnew code should use the <a href=\"url.html#url_class_urlsearchparams\" class=\"type\">&lt;URLSearchParams&gt;</a> API instead.</p>",
       "methods": [
         {
           "textRaw": "`querystring.decode()`",
@@ -87,7 +87,10 @@
                 "description": "The returned object no longer inherits from `Object.prototype`."
               },
               {
-                "version": "v6.0.0, v4.2.4",
+                "version": [
+                  "v6.0.0",
+                  "v4.2.4"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/3807",
                 "description": "The `eq` parameter may now have a length of more than `1`."
               }
@@ -191,7 +194,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>querystring.stringify()</code> method produces a URL query string from a\ngiven <code>obj</code> by iterating through the object's \"own properties\".</p>\n<p>It serializes the following types of values passed in <code>obj</code>:\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean[]&gt;</a>\nAny other input values will be coerced to empty strings.</p>\n<pre><code class=\"language-js\">querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' });\n// Returns 'foo=bar&#x26;baz=qux&#x26;baz=quux&#x26;corge='\n\nquerystring.stringify({ foo: 'bar', baz: 'qux' }, ';', ':');\n// Returns 'foo:bar;baz:qux'\n</code></pre>\n<p>By default, characters requiring percent-encoding within the query string will\nbe encoded as UTF-8. If an alternative encoding is required, then an alternative\n<code>encodeURIComponent</code> option will need to be specified:</p>\n<pre><code class=\"language-js\">// Assuming gbkEncodeURIComponent function already exists,\n\nquerystring.stringify({ w: '中文', foo: 'bar' }, null, null,\n                      { encodeURIComponent: gbkEncodeURIComponent });\n</code></pre>"
+          "desc": "<p>The <code>querystring.stringify()</code> method produces a URL query string from a\ngiven <code>obj</code> by iterating through the object's \"own properties\".</p>\n<p>It serializes the following types of values passed in <code>obj</code>:\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt\" class=\"type\">&lt;bigint&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt\" class=\"type\">&lt;bigint[]&gt;</a> | <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean[]&gt;</a>\nThe numeric values must be finite. Any other input values will be coerced to\nempty strings.</p>\n<pre><code class=\"language-js\">querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' });\n// Returns 'foo=bar&#x26;baz=qux&#x26;baz=quux&#x26;corge='\n\nquerystring.stringify({ foo: 'bar', baz: 'qux' }, ';', ':');\n// Returns 'foo:bar;baz:qux'\n</code></pre>\n<p>By default, characters requiring percent-encoding within the query string will\nbe encoded as UTF-8. If an alternative encoding is required, then an alternative\n<code>encodeURIComponent</code> option will need to be specified:</p>\n<pre><code class=\"language-js\">// Assuming gbkEncodeURIComponent function already exists,\n\nquerystring.stringify({ w: '中文', foo: 'bar' }, null, null,\n                      { encodeURIComponent: gbkEncodeURIComponent });\n</code></pre>"
         },
         {
           "textRaw": "`querystring.unescape(str)`",
diff --git a/doc/api/querystring.md b/doc/api/querystring.md
index 03ee78aad0a23d849c818486e98c6f1fd697fff0..4b7db7afc3b948d9e798a0ef59aa89c522099036 100644
--- a/doc/api/querystring.md
+++ b/doc/api/querystring.md
@@ -2,7 +2,7 @@
 
 <!--introduced_in=v0.1.25-->
 
-> Stability: 2 - Stable
+> Stability: 3 - Legacy
 
 <!--name=querystring-->
 
@@ -15,6 +15,9 @@ query strings. It can be accessed using:
 const querystring = require('querystring');
 ```
 
+The `querystring` API is considered Legacy. While it is still maintained,
+new code should use the {URLSearchParams} API instead.
+
 ## `querystring.decode()`
 <!-- YAML
 added: v0.1.99
@@ -55,7 +58,9 @@ changes:
   - version: v6.0.0
     pr-url: https://github.com/nodejs/node/pull/6055
     description: The returned object no longer inherits from `Object.prototype`.
-  - version: v6.0.0, v4.2.4
+  - version:
+    - v6.0.0
+    - v4.2.4
     pr-url: https://github.com/nodejs/node/pull/3807
     description: The `eq` parameter may now have a length of more than `1`.
 -->
@@ -120,8 +125,9 @@ The `querystring.stringify()` method produces a URL query string from a
 given `obj` by iterating through the object's "own properties".
 
 It serializes the following types of values passed in `obj`:
-{string|number|boolean|string[]|number[]|boolean[]}
-Any other input values will be coerced to empty strings.
+{string|number|bigint|boolean|string[]|number[]|bigint[]|boolean[]}
+The numeric values must be finite. Any other input values will be coerced to
+empty strings.
 
 ```js
 querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' });
diff --git a/doc/api/readline.html b/doc/api/readline.html
index 47fff56505794a037199e3062ea3585bc167fdca..2509fa8ccee9120b9564ed512214923fb240ad8f 100644
--- a/doc/api/readline.html
+++ b/doc/api/readline.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Readline | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Readline | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="readline" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/readline.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/readline.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/readline.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/readline.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/readline.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/readline.html">13.x</a></li>
@@ -118,21 +133,20 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/readline.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/readline.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/readline.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#readline_readline">Readline</a></span>
 <ul>
 <li><a href="#readline_class_interface">Class: <code>Interface</code></a>
 <ul>
 <li><a href="#readline_event_close">Event: <code>'close'</code></a></li>
 <li><a href="#readline_event_line">Event: <code>'line'</code></a></li>
+<li><a href="#readline_event_history">Event: <code>'history'</code></a></li>
 <li><a href="#readline_event_pause">Event: <code>'pause'</code></a></li>
 <li><a href="#readline_event_resume">Event: <code>'resume'</code></a></li>
 <li><a href="#readline_event_sigcont">Event: <code>'SIGCONT'</code></a></li>
@@ -141,13 +155,14 @@
 <li><a href="#readline_rl_close"><code>rl.close()</code></a></li>
 <li><a href="#readline_rl_pause"><code>rl.pause()</code></a></li>
 <li><a href="#readline_rl_prompt_preservecursor"><code>rl.prompt([preserveCursor])</code></a></li>
-<li><a href="#readline_rl_question_query_callback"><code>rl.question(query, callback)</code></a></li>
+<li><a href="#readline_rl_question_query_options_callback"><code>rl.question(query[, options], callback)</code></a></li>
 <li><a href="#readline_rl_resume"><code>rl.resume()</code></a></li>
 <li><a href="#readline_rl_setprompt_prompt"><code>rl.setPrompt(prompt)</code></a></li>
+<li><a href="#readline_rl_getprompt"><code>rl.getPrompt()</code></a></li>
 <li><a href="#readline_rl_write_data_key"><code>rl.write(data[, key])</code></a></li>
 <li><a href="#readline_rl_symbol_asynciterator"><code>rl[Symbol.asyncIterator]()</code></a></li>
-<li><a href="#readline_rl_line">rl.line</a></li>
-<li><a href="#readline_rl_cursor">rl.cursor</a></li>
+<li><a href="#readline_rl_line"><code>rl.line</code></a></li>
+<li><a href="#readline_rl_cursor"><code>rl.cursor</code></a></li>
 <li><a href="#readline_rl_getcursorpos"><code>rl.getCursorPos()</code></a></li>
 </ul>
 </li>
@@ -166,14 +181,13 @@
 <li><a href="#readline_tty_keybindings">TTY keybindings</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Readline<span><a class="mark" href="#readline_readline" id="readline_readline">#</a></span></h1>
+        <h2>Readline<span><a class="mark" href="#readline_readline" id="readline_readline">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/readline.js">lib/readline.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/readline.js">lib/readline.js</a></p>
 <p>The <code>readline</code> module provides an interface for reading data from a <a href="stream.html#stream_readable_streams">Readable</a>
 stream (such as <a href="process.html#process_process_stdin"><code>process.stdin</code></a>) one line at a time. It can be accessed
 using:</p>
@@ -181,21 +195,21 @@ using:</p>
 <p>The following simple example illustrates the basic use of the <code>readline</code> module.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
 
-<span class="hljs-keyword">const</span> rl = readline.createInterface({
-  <span class="hljs-attr">input</span>: process.stdin,
-  <span class="hljs-attr">output</span>: process.stdout
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
+  <span class="hljs-attr">input</span>: process.<span class="hljs-property">stdin</span>,
+  <span class="hljs-attr">output</span>: process.<span class="hljs-property">stdout</span>
 });
 
-rl.question(<span class="hljs-string">'What do you think of Node.js? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
+rl.<span class="hljs-title function_">question</span>(<span class="hljs-string">'What do you think of Node.js? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
   <span class="hljs-comment">// <span class="hljs-doctag">TODO:</span> Log the answer in a database</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Thank you for your valuable feedback: <span class="hljs-subst">${answer}</span>`</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Thank you for your valuable feedback: <span class="hljs-subst">${answer}</span>`</span>);
 
-  rl.close();
+  rl.<span class="hljs-title function_">close</span>();
 });</code></pre>
 <p>Once this code is invoked, the Node.js application will not terminate until the
 <code>readline.Interface</code> is closed because the interface waits for data to be
 received on the <code>input</code> stream.</p>
-<h2>Class: <code>Interface</code><span><a class="mark" href="#readline_class_interface" id="readline_class_interface">#</a></span></h2>
+<section><h3>Class: <code>Interface</code><span><a class="mark" href="#readline_class_interface" id="readline_class_interface">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.104</span>
 </div>
@@ -207,7 +221,7 @@ received on the <code>input</code> stream.</p>
 single <code>input</code> <a href="stream.html#stream_readable_streams">Readable</a> stream and a single <code>output</code> <a href="stream.html#stream_writable_streams">Writable</a> stream.
 The <code>output</code> stream is used to print prompts for user input that arrives on,
 and is read from, the <code>input</code> stream.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#readline_event_close" id="readline_event_close">#</a></span></h3>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#readline_event_close" id="readline_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -216,26 +230,43 @@ and is read from, the <code>input</code> stream.</p>
 <li>The <code>rl.close()</code> method is called and the <code>readline.Interface</code> instance has
 relinquished control over the <code>input</code> and <code>output</code> streams;</li>
 <li>The <code>input</code> stream receives its <code>'end'</code> event;</li>
-<li>The <code>input</code> stream receives <code>&#x3C;ctrl>-D</code> to signal end-of-transmission (EOT);</li>
-<li>The <code>input</code> stream receives <code>&#x3C;ctrl>-C</code> to signal <code>SIGINT</code> and there is no
-<code>'SIGINT'</code> event listener registered on the <code>readline.Interface</code> instance.</li>
+<li>The <code>input</code> stream receives <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal
+end-of-transmission (EOT);</li>
+<li>The <code>input</code> stream receives <kbd>Ctrl</kbd>+<kbd>C</kbd> to signal <code>SIGINT</code>
+and there is no <code>'SIGINT'</code> event listener registered on the
+<code>readline.Interface</code> instance.</li>
 </ul>
 <p>The listener function is called without passing any arguments.</p>
 <p>The <code>readline.Interface</code> instance is finished once the <code>'close'</code> event is
 emitted.</p>
-<h3>Event: <code>'line'</code><span><a class="mark" href="#readline_event_line" id="readline_event_line">#</a></span></h3>
+<h4>Event: <code>'line'</code><span><a class="mark" href="#readline_event_line" id="readline_event_line">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
 <p>The <code>'line'</code> event is emitted whenever the <code>input</code> stream receives an
 end-of-line input (<code>\n</code>, <code>\r</code>, or <code>\r\n</code>). This usually occurs when the user
-presses the <code>&#x3C;Enter></code>, or <code>&#x3C;Return></code> keys.</p>
+presses <kbd>Enter</kbd> or <kbd>Return</kbd>.</p>
 <p>The listener function is called with a string containing the single line of
 received input.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">input</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received: <span class="hljs-subst">${input}</span>`</span>);
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">input</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received: <span class="hljs-subst">${input}</span>`</span>);
+});</code></pre>
+<h4>Event: <code>'history'</code><span><a class="mark" href="#readline_event_history" id="readline_event_history">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p>The <code>'history'</code> event is emitted whenever the history array has changed.</p>
+<p>The listener function is called with an array containing the history array.
+It will reflect all changes, added lines and removed lines due to
+<code>historySize</code> and <code>removeHistoryDuplicates</code>.</p>
+<p>The primary purpose is to allow a listener to persist the history.
+It is also possible for the listener to change the history object. This
+could be useful to prevent certain lines to be added to the history, like
+a password.</p>
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'history'</span>, <span class="hljs-function">(<span class="hljs-params">history</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received: <span class="hljs-subst">${history}</span>`</span>);
 });</code></pre>
-<h3>Event: <code>'pause'</code><span><a class="mark" href="#readline_event_pause" id="readline_event_pause">#</a></span></h3>
+<h4>Event: <code>'pause'</code><span><a class="mark" href="#readline_event_pause" id="readline_event_pause">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
@@ -243,70 +274,70 @@ received input.</p>
 <ul>
 <li>The <code>input</code> stream is paused.</li>
 <li>The <code>input</code> stream is not paused and receives the <code>'SIGCONT'</code> event. (See
-events <a href="readline.html#readline_event_sigtstp"><code>'SIGTSTP'</code></a> and <a href="readline.html#readline_event_sigcont"><code>'SIGCONT'</code></a>.)</li>
+events <a href="#readline_event_sigtstp"><code>'SIGTSTP'</code></a> and <a href="#readline_event_sigcont"><code>'SIGCONT'</code></a>.)</li>
 </ul>
 <p>The listener function is called without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'pause'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Readline paused.'</span>);
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'pause'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Readline paused.'</span>);
 });</code></pre>
-<h3>Event: <code>'resume'</code><span><a class="mark" href="#readline_event_resume" id="readline_event_resume">#</a></span></h3>
+<h4>Event: <code>'resume'</code><span><a class="mark" href="#readline_event_resume" id="readline_event_resume">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
 <p>The <code>'resume'</code> event is emitted whenever the <code>input</code> stream is resumed.</p>
 <p>The listener function is called without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'resume'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Readline resumed.'</span>);
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'resume'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Readline resumed.'</span>);
 });</code></pre>
-<h3>Event: <code>'SIGCONT'</code><span><a class="mark" href="#readline_event_sigcont" id="readline_event_sigcont">#</a></span></h3>
+<h4>Event: <code>'SIGCONT'</code><span><a class="mark" href="#readline_event_sigcont" id="readline_event_sigcont">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
 <p>The <code>'SIGCONT'</code> event is emitted when a Node.js process previously moved into
-the background using <code>&#x3C;ctrl>-Z</code> (i.e. <code>SIGTSTP</code>) is then brought back to the
-foreground using <a href="http://man7.org/linux/man-pages/man1/fg.1p.html"><code>fg(1p)</code></a>.</p>
+the background using <kbd>Ctrl</kbd>+<kbd>Z</kbd> (i.e. <code>SIGTSTP</code>) is then
+brought back to the foreground using <a href="http://man7.org/linux/man-pages/man1/fg.1p.html"><code>fg(1p)</code></a>.</p>
 <p>If the <code>input</code> stream was paused <em>before</em> the <code>SIGTSTP</code> request, this event will
 not be emitted.</p>
 <p>The listener function is invoked without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'SIGCONT'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGCONT'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// `prompt` will automatically resume the stream</span>
-  rl.prompt();
+  rl.<span class="hljs-title function_">prompt</span>();
 });</code></pre>
 <p>The <code>'SIGCONT'</code> event is <em>not</em> supported on Windows.</p>
-<h3>Event: <code>'SIGINT'</code><span><a class="mark" href="#readline_event_sigint" id="readline_event_sigint">#</a></span></h3>
+<h4>Event: <code>'SIGINT'</code><span><a class="mark" href="#readline_event_sigint" id="readline_event_sigint">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
 <p>The <code>'SIGINT'</code> event is emitted whenever the <code>input</code> stream receives a
-<code>&#x3C;ctrl>-C</code> input, known typically as <code>SIGINT</code>. If there are no <code>'SIGINT'</code> event
-listeners registered when the <code>input</code> stream receives a <code>SIGINT</code>, the <code>'pause'</code>
-event will be emitted.</p>
+<kbd>Ctrl+C</kbd> input, known typically as <code>SIGINT</code>. If there are no <code>'SIGINT'</code>
+event listeners registered when the <code>input</code> stream receives a <code>SIGINT</code>, the
+<code>'pause'</code> event will be emitted.</p>
 <p>The listener function is invoked without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'SIGINT'</span>, <span class="hljs-function">() =></span> {
-  rl.question(<span class="hljs-string">'Are you sure you want to exit? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
-    <span class="hljs-keyword">if</span> (answer.match(<span class="hljs-regexp">/^y(es)?$/i</span>)) rl.pause();
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGINT'</span>, <span class="hljs-function">() =></span> {
+  rl.<span class="hljs-title function_">question</span>(<span class="hljs-string">'Are you sure you want to exit? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
+    <span class="hljs-keyword">if</span> (answer.<span class="hljs-title function_">match</span>(<span class="hljs-regexp">/^y(es)?$/i</span>)) rl.<span class="hljs-title function_">pause</span>();
   });
 });</code></pre>
-<h3>Event: <code>'SIGTSTP'</code><span><a class="mark" href="#readline_event_sigtstp" id="readline_event_sigtstp">#</a></span></h3>
+<h4>Event: <code>'SIGTSTP'</code><span><a class="mark" href="#readline_event_sigtstp" id="readline_event_sigtstp">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span>
 </div>
-<p>The <code>'SIGTSTP'</code> event is emitted when the <code>input</code> stream receives a <code>&#x3C;ctrl>-Z</code>
-input, typically known as <code>SIGTSTP</code>. If there are no <code>'SIGTSTP'</code> event listeners
-registered when the <code>input</code> stream receives a <code>SIGTSTP</code>, the Node.js process
-will be sent to the background.</p>
+<p>The <code>'SIGTSTP'</code> event is emitted when the <code>input</code> stream receives a
+<kbd>Ctrl</kbd>+<kbd>Z</kbd> input, typically known as <code>SIGTSTP</code>. If there are
+no <code>'SIGTSTP'</code> event listeners registered when the <code>input</code> stream receives a
+<code>SIGTSTP</code>, the Node.js process will be sent to the background.</p>
 <p>When the program is resumed using <a href="http://man7.org/linux/man-pages/man1/fg.1p.html"><code>fg(1p)</code></a>, the <code>'pause'</code> and <code>'SIGCONT'</code> events
 will be emitted. These can be used to resume the <code>input</code> stream.</p>
 <p>The <code>'pause'</code> and <code>'SIGCONT'</code> events will not be emitted if the <code>input</code> was
 paused before the process was sent to the background.</p>
 <p>The listener function is invoked without passing any arguments.</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'SIGTSTP'</span>, <span class="hljs-function">() =></span> {
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'SIGTSTP'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-comment">// This will override SIGTSTP and prevent the program from going to the</span>
   <span class="hljs-comment">// background.</span>
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Caught SIGTSTP.'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Caught SIGTSTP.'</span>);
 });</code></pre>
 <p>The <code>'SIGTSTP'</code> event is <em>not</em> supported on Windows.</p>
-<h3><code>rl.close()</code><span><a class="mark" href="#readline_rl_close" id="readline_rl_close">#</a></span></h3>
+<h4><code>rl.close()</code><span><a class="mark" href="#readline_rl_close" id="readline_rl_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -315,7 +346,7 @@ relinquishes control over the <code>input</code> and <code>output</code> streams
 the <code>'close'</code> event will be emitted.</p>
 <p>Calling <code>rl.close()</code> does not immediately stop other events (including <code>'line'</code>)
 from being emitted by the <code>readline.Interface</code> instance.</p>
-<h3><code>rl.pause()</code><span><a class="mark" href="#readline_rl_pause" id="readline_rl_pause">#</a></span></h3>
+<h4><code>rl.pause()</code><span><a class="mark" href="#readline_rl_pause" id="readline_rl_pause">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
@@ -323,7 +354,7 @@ from being emitted by the <code>readline.Interface</code> instance.</p>
 later if necessary.</p>
 <p>Calling <code>rl.pause()</code> does not immediately pause other events (including
 <code>'line'</code>) from being emitted by the <code>readline.Interface</code> instance.</p>
-<h3><code>rl.prompt([preserveCursor])</code><span><a class="mark" href="#readline_rl_prompt_preservecursor" id="readline_rl_prompt_preservecursor">#</a></span></h3>
+<h4><code>rl.prompt([preserveCursor])</code><span><a class="mark" href="#readline_rl_prompt_preservecursor" id="readline_rl_prompt_preservecursor">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -338,13 +369,19 @@ location at which to provide input.</p>
 paused.</p>
 <p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or
 <code>undefined</code> the prompt is not written.</p>
-<h3><code>rl.question(query, callback)</code><span><a class="mark" href="#readline_rl_question_query_callback" id="readline_rl_question_query_callback">#</a></span></h3>
+<h4><code>rl.question(query[, options], callback)</code><span><a class="mark" href="#readline_rl_question_query_options_callback" id="readline_rl_question_query_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.3</span>
 </div>
 <ul>
 <li><code>query</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A statement or query to write to <code>output</code>, prepended to the
 prompt.</li>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+<ul>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Optionally allows the <code>question()</code> to be canceled
+using an <code>AbortController</code>.</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> A callback function that is invoked with the user's
 input in response to the <code>query</code>.</li>
 </ul>
@@ -355,19 +392,47 @@ function passing the provided input as the first argument.</p>
 paused.</p>
 <p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or
 <code>undefined</code> the <code>query</code> is not written.</p>
-<p>Example usage:</p>
-<pre><code class="language-js">rl.question(<span class="hljs-string">'What is your favorite food? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Oh, so your favorite food is <span class="hljs-subst">${answer}</span>`</span>);
-});</code></pre>
 <p>The <code>callback</code> function passed to <code>rl.question()</code> does not follow the typical
 pattern of accepting an <code>Error</code> object or <code>null</code> as the first argument.
 The <code>callback</code> is called with the provided answer as the only argument.</p>
-<h3><code>rl.resume()</code><span><a class="mark" href="#readline_rl_resume" id="readline_rl_resume">#</a></span></h3>
+<p>Example usage:</p>
+<pre><code class="language-js">rl.<span class="hljs-title function_">question</span>(<span class="hljs-string">'What is your favorite food? '</span>, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Oh, so your favorite food is <span class="hljs-subst">${answer}</span>`</span>);
+});</code></pre>
+<p>Using an <code>AbortController</code> to cancel a question.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> signal = ac.<span class="hljs-property">signal</span>;
+
+rl.<span class="hljs-title function_">question</span>(<span class="hljs-string">'What is your favorite food? '</span>, { signal }, <span class="hljs-function">(<span class="hljs-params">answer</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Oh, so your favorite food is <span class="hljs-subst">${answer}</span>`</span>);
+});
+
+signal.<span class="hljs-title function_">addEventListener</span>(<span class="hljs-string">'abort'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The food question timed out'</span>);
+}, { <span class="hljs-attr">once</span>: <span class="hljs-literal">true</span> });
+
+<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> ac.<span class="hljs-title function_">abort</span>(), <span class="hljs-number">10000</span>);</code></pre>
+<p>If this method is invoked as it's util.promisify()ed version, it returns a
+Promise that fulfills with the answer. If the question is canceled using
+an <code>AbortController</code> it will reject with an <code>AbortError</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> question = util.<span class="hljs-title function_">promisify</span>(rl.<span class="hljs-property">question</span>).<span class="hljs-title function_">bind</span>(rl);
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">questionExample</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">try</span> {
+    <span class="hljs-keyword">const</span> answer = <span class="hljs-keyword">await</span> <span class="hljs-title function_">question</span>(<span class="hljs-string">'What is you favorite food? '</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Oh, so your favorite food is <span class="hljs-subst">${answer}</span>`</span>);
+  } <span class="hljs-keyword">catch</span> (err) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Question rejected'</span>, err);
+  }
+}
+<span class="hljs-title function_">questionExample</span>();</code></pre>
+<h4><code>rl.resume()</code><span><a class="mark" href="#readline_rl_resume" id="readline_rl_resume">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span>
 </div>
 <p>The <code>rl.resume()</code> method resumes the <code>input</code> stream if it has been paused.</p>
-<h3><code>rl.setPrompt(prompt)</code><span><a class="mark" href="#readline_rl_setprompt_prompt" id="readline_rl_setprompt_prompt">#</a></span></h3>
+<h4><code>rl.setPrompt(prompt)</code><span><a class="mark" href="#readline_rl_setprompt_prompt" id="readline_rl_setprompt_prompt">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -376,7 +441,15 @@ The <code>callback</code> is called with the provided answer as the only argumen
 </ul>
 <p>The <code>rl.setPrompt()</code> method sets the prompt that will be written to <code>output</code>
 whenever <code>rl.prompt()</code> is called.</p>
-<h3><code>rl.write(data[, key])</code><span><a class="mark" href="#readline_rl_write_data_key" id="readline_rl_write_data_key">#</a></span></h3>
+<h4><code>rl.getPrompt()</code><span><a class="mark" href="#readline_rl_getprompt" id="readline_rl_getprompt">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> the current prompt string</li>
+</ul>
+<p>The <code>rl.getPrompt()</code> method returns the current prompt used by <code>rl.prompt()</code>.</p>
+<h4><code>rl.write(data[, key])</code><span><a class="mark" href="#readline_rl_write_data_key" id="readline_rl_write_data_key">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -384,9 +457,9 @@ whenever <code>rl.prompt()</code> is called.</p>
 <li><code>data</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>key</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>ctrl</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <code>&#x3C;ctrl></code> key.</li>
-<li><code>meta</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <code>&#x3C;Meta></code> key.</li>
-<li><code>shift</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <code>&#x3C;Shift></code> key.</li>
+<li><code>ctrl</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <kbd>Ctrl</kbd> key.</li>
+<li><code>meta</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <kbd>Meta</kbd> key.</li>
+<li><code>shift</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> to indicate the <kbd>Shift</kbd> key.</li>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The name of the a key.</li>
 </ul>
 </li>
@@ -400,20 +473,20 @@ combinations.</p>
 paused.</p>
 <p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or
 <code>undefined</code> the <code>data</code> and <code>key</code> are not written.</p>
-<pre><code class="language-js">rl.write(<span class="hljs-string">'Delete this!'</span>);
-<span class="hljs-comment">// Simulate Ctrl+u to delete the line written previously</span>
-rl.write(<span class="hljs-literal">null</span>, { <span class="hljs-attr">ctrl</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">name</span>: <span class="hljs-string">'u'</span> });</code></pre>
+<pre><code class="language-js">rl.<span class="hljs-title function_">write</span>(<span class="hljs-string">'Delete this!'</span>);
+<span class="hljs-comment">// Simulate Ctrl+U to delete the line written previously</span>
+rl.<span class="hljs-title function_">write</span>(<span class="hljs-literal">null</span>, { <span class="hljs-attr">ctrl</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">name</span>: <span class="hljs-string">'u'</span> });</code></pre>
 <p>The <code>rl.write()</code> method will write the data to the <code>readline</code> <code>Interface</code>'s
 <code>input</code> <em>as if it were provided by the user</em>.</p>
-<h3><code>rl[Symbol.asyncIterator]()</code><span><a class="mark" href="#readline_rl_symbol_asynciterator" id="readline_rl_symbol_asynciterator">#</a></span></h3>
+<h4><code>rl[Symbol.asyncIterator]()</code><span><a class="mark" href="#readline_rl_symbol_asynciterator" id="readline_rl_symbol_asynciterator">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.14.0</td>
+<tr><td>v11.4.0, v10.16.0</td>
+<td><p><span>Added in: v11.4.0, v10.16.0</span></p></td></tr>
+<tr><td>v11.14.0, v10.17.0</td>
 <td><p>Symbol.asyncIterator support is no longer experimental.</p></td></tr>
-<tr><td>v11.4.0</td>
-<td><p><span>Added in: v11.4.0</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
@@ -429,8 +502,8 @@ stream as a string. This method allows asynchronous iteration of
 <code>readline.Interface</code> will always consume the input stream fully.</p>
 <p>Performance is not on par with the traditional <code>'line'</code> event API. Use <code>'line'</code>
 instead for performance-sensitive applications.</p>
-<pre><code class="language-js"><span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">processLineByLine</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> rl = readline.createInterface({
+<pre><code class="language-js"><span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">processLineByLine</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
     <span class="hljs-comment">// ...</span>
   });
 
@@ -439,12 +512,23 @@ instead for performance-sensitive applications.</p>
     <span class="hljs-comment">// `line`.</span>
   }
 }</code></pre>
-<h3>rl.line<span><a class="mark" href="#readline_rl_line" id="readline_rl_line">#</a></span></h3>
+<p><code>readline.createInterface()</code> will start to consume the input stream once
+invoked. Having asynchronous operations between interface creation and
+asynchronous iteration may result in missed lines.</p>
+<h4><code>rl.line</code><span><a class="mark" href="#readline_rl_line" id="readline_rl_line">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v0.1.98</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.0</td>
+<td><p>Value will always be a string, never undefined.</p></td></tr>
+<tr><td>v0.1.98</td>
+<td><p><span>Added in: v0.1.98</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type" class="type">&#x3C;undefined></a></li>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The current input data being processed by node.</p>
 <p>This can be used when collecting input from a TTY stream to retrieve the
@@ -456,17 +540,17 @@ unintended consequences if <code>rl.cursor</code> is not also controlled.</p>
 <p><strong>If not using a TTY stream for input, use the <a href="#readline_event_line"><code>'line'</code></a> event.</strong></p>
 <p>One possible use case would be as follows:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> values = [<span class="hljs-string">'lorem ipsum'</span>, <span class="hljs-string">'dolor sit amet'</span>];
-<span class="hljs-keyword">const</span> rl = readline.createInterface(process.stdin);
-<span class="hljs-keyword">const</span> showResults = debounce(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>(process.<span class="hljs-property">stdin</span>);
+<span class="hljs-keyword">const</span> showResults = <span class="hljs-title function_">debounce</span>(<span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(
     <span class="hljs-string">'\n'</span>,
-    values.filter(<span class="hljs-function">(<span class="hljs-params">val</span>) =></span> val.startsWith(rl.line)).join(<span class="hljs-string">' '</span>)
+    values.<span class="hljs-title function_">filter</span>(<span class="hljs-function">(<span class="hljs-params">val</span>) =></span> val.<span class="hljs-title function_">startsWith</span>(rl.<span class="hljs-property">line</span>)).<span class="hljs-title function_">join</span>(<span class="hljs-string">' '</span>)
   );
 }, <span class="hljs-number">300</span>);
-process.stdin.on(<span class="hljs-string">'keypress'</span>, <span class="hljs-function">(<span class="hljs-params">c, k</span>) =></span> {
-  showResults();
+process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'keypress'</span>, <span class="hljs-function">(<span class="hljs-params">c, k</span>) =></span> {
+  <span class="hljs-title function_">showResults</span>();
 });</code></pre>
-<h3>rl.cursor<span><a class="mark" href="#readline_rl_cursor" id="readline_rl_cursor">#</a></span></h3>
+<h4><code>rl.cursor</code><span><a class="mark" href="#readline_rl_cursor" id="readline_rl_cursor">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.98</span>
 </div>
@@ -478,9 +562,9 @@ process.stdin.on(<span class="hljs-string">'keypress'</span>, <span class="hljs-
 reading input from a TTY stream. The position of cursor determines the
 portion of the input string that will be modified as input is processed,
 as well as the column where the terminal caret will be rendered.</p>
-<h3><code>rl.getCursorPos()</code><span><a class="mark" href="#readline_rl_getcursorpos" id="readline_rl_getcursorpos">#</a></span></h3>
+<h4><code>rl.getCursorPos()</code><span><a class="mark" href="#readline_rl_getcursorpos" id="readline_rl_getcursorpos">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.5.0, v12.16.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -493,7 +577,7 @@ as well as the column where the terminal caret will be rendered.</p>
 <p>Returns the real position of the cursor in relation to the input
 prompt + string. Long input (wrapping) strings, as well as multiple
 line prompts are included in the calculations.</p>
-<h2><code>readline.clearLine(stream, dir[, callback])</code><span><a class="mark" href="#readline_readline_clearline_stream_dir_callback" id="readline_readline_clearline_stream_dir_callback">#</a></span></h2>
+</section><section><h3><code>readline.clearLine(stream, dir[, callback])</code><span><a class="mark" href="#readline_readline_clearline_stream_dir_callback" id="readline_readline_clearline_stream_dir_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -521,7 +605,7 @@ otherwise <code>true</code>.</li>
 </ul>
 <p>The <code>readline.clearLine()</code> method clears current line of given <a href="tty.html">TTY</a> stream
 in a specified direction identified by <code>dir</code>.</p>
-<h2><code>readline.clearScreenDown(stream[, callback])</code><span><a class="mark" href="#readline_readline_clearscreendown_stream_callback" id="readline_readline_clearscreendown_stream_callback">#</a></span></h2>
+</section><section><h3><code>readline.clearScreenDown(stream[, callback])</code><span><a class="mark" href="#readline_readline_clearscreendown_stream_callback" id="readline_readline_clearscreendown_stream_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -542,12 +626,18 @@ otherwise <code>true</code>.</li>
 </ul>
 <p>The <code>readline.clearScreenDown()</code> method clears the given <a href="tty.html">TTY</a> stream from
 the current position of the cursor down.</p>
-<h2><code>readline.createInterface(options)</code><span><a class="mark" href="#readline_readline_createinterface_options" id="readline_readline_createinterface_options">#</a></span></h2>
+</section><section><h3><code>readline.createInterface(options)</code><span><a class="mark" href="#readline_readline_createinterface_options" id="readline_readline_createinterface_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v8.3.0, 6.11.4</td>
+<tr><td>v14.18.0</td>
+<td><p>The <code>signal</code> option is supported now.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>The <code>history</code> option is supported now.</p></td></tr>
+<tr><td>v13.9.0</td>
+<td><p>The <code>tabSize</code> option is supported now.</p></td></tr>
+<tr><td>v8.3.0, v6.11.4</td>
 <td><p>Remove max limit of <code>crlfDelay</code> option.</p></td></tr>
 <tr><td>v6.6.0</td>
 <td><p>The <code>crlfDelay</code> option is supported now.</p></td></tr>
@@ -571,11 +661,18 @@ to.</li>
 <li><code>terminal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the <code>input</code> and <code>output</code> streams should be
 treated like a TTY, and have ANSI/VT100 escape codes written to it.
 <strong>Default:</strong> checking <code>isTTY</code> on the <code>output</code> stream upon instantiation.</li>
+<li><code>history</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> Initial list of history lines. This option makes sense
+only if <code>terminal</code> is set to <code>true</code> by the user or by an internal <code>output</code>
+check, otherwise the history caching mechanism is not initialized at all.
+<strong>Default:</strong> <code>[]</code>.</li>
 <li><code>historySize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Maximum number of history lines retained. To disable
 the history set this value to <code>0</code>. This option makes sense only if
 <code>terminal</code> is set to <code>true</code> by the user or by an internal <code>output</code> check,
 otherwise the history caching mechanism is not initialized at all.
 <strong>Default:</strong> <code>30</code>.</li>
+<li><code>removeHistoryDuplicates</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, when a new input line added
+to the history list duplicates an older one, this removes the older line
+from the list. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>prompt</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The prompt string to use. <strong>Default:</strong> <code>'> '</code>.</li>
 <li><code>crlfDelay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> If the delay between <code>\r</code> and <code>\n</code> exceeds
 <code>crlfDelay</code> milliseconds, both <code>\r</code> and <code>\n</code> will be treated as separate
@@ -583,34 +680,43 @@ end-of-line input. <code>crlfDelay</code> will be coerced to a number no less th
 <code>100</code>. It can be set to <code>Infinity</code>, in which case <code>\r</code> followed by <code>\n</code>
 will always be considered a single newline (which may be reasonable for
 <a href="#readline_example_read_file_stream_line_by_line">reading files</a> with <code>\r\n</code> line delimiter). <strong>Default:</strong> <code>100</code>.</li>
-<li><code>removeHistoryDuplicates</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, when a new input line added
-to the history list duplicates an older one, this removes the older line
-from the list. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>escapeCodeTimeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The duration <code>readline</code> will wait for a
 character (when reading an ambiguous key sequence in milliseconds one that
 can both form a complete key sequence using the input read so far and can
 take additional input to complete a longer key sequence).
 <strong>Default:</strong> <code>500</code>.</li>
+<li><code>tabSize</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of spaces a tab is equal to (minimum 1).
+<strong>Default:</strong> <code>8</code>.</li>
+<li><code>signal</code> <a href="globals.html#globals_class_abortsignal" class="type">&#x3C;AbortSignal></a> Allows closing the interface using an AbortSignal.
+Aborting the signal will internally call <code>close</code> on the interface.</li>
 </ul>
 </li>
+<li>Returns: <a href="readline.html#readline_class_interface" class="type">&#x3C;readline.Interface></a></li>
 </ul>
 <p>The <code>readline.createInterface()</code> method creates a new <code>readline.Interface</code>
 instance.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
-<span class="hljs-keyword">const</span> rl = readline.createInterface({
-  <span class="hljs-attr">input</span>: process.stdin,
-  <span class="hljs-attr">output</span>: process.stdout
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
+  <span class="hljs-attr">input</span>: process.<span class="hljs-property">stdin</span>,
+  <span class="hljs-attr">output</span>: process.<span class="hljs-property">stdout</span>
 });</code></pre>
 <p>Once the <code>readline.Interface</code> instance is created, the most common case is to
 listen for the <code>'line'</code> event:</p>
-<pre><code class="language-js">rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received: <span class="hljs-subst">${line}</span>`</span>);
+<pre><code class="language-js">rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received: <span class="hljs-subst">${line}</span>`</span>);
 });</code></pre>
 <p>If <code>terminal</code> is <code>true</code> for this instance then the <code>output</code> stream will get
 the best compatibility if it defines an <code>output.columns</code> property and emits
 a <code>'resize'</code> event on the <code>output</code> if or when the columns ever change
 (<a href="process.html#process_process_stdout"><code>process.stdout</code></a> does this automatically when it is a TTY).</p>
-<h3>Use of the <code>completer</code> function<span><a class="mark" href="#readline_use_of_the_completer_function" id="readline_use_of_the_completer_function">#</a></span></h3>
+<p>When creating a <code>readline.Interface</code> using <code>stdin</code> as input, the program
+will not terminate until it receives <code>EOF</code> (<kbd>Ctrl</kbd>+<kbd>D</kbd> on
+Linux/macOS, <kbd>Ctrl</kbd>+<kbd>Z</kbd> followed by <kbd>Return</kbd> on
+Windows).
+If you want your application to exit without waiting for user input, you can
+<a href="net.html#net_socket_unref"><code>unref()</code></a> the standard input stream:</p>
+<pre><code class="language-js">process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">unref</span>();</code></pre>
+<h4>Use of the <code>completer</code> function<span><a class="mark" href="#readline_use_of_the_completer_function" id="readline_use_of_the_completer_function">#</a></span></h4>
 <p>The <code>completer</code> function takes the current line entered by the user
 as an argument, and returns an <code>Array</code> with 2 entries:</p>
 <ul>
@@ -618,18 +724,18 @@ as an argument, and returns an <code>Array</code> with 2 entries:</p>
 <li>The substring that was used for the matching.</li>
 </ul>
 <p>For instance: <code>[[substr1, substr2, ...], originalsubstring]</code>.</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">completer</span>(<span class="hljs-params">line</span>) </span>{
-  <span class="hljs-keyword">const</span> completions = <span class="hljs-string">'.help .error .exit .quit .q'</span>.split(<span class="hljs-string">' '</span>);
-  <span class="hljs-keyword">const</span> hits = completions.filter(<span class="hljs-function">(<span class="hljs-params">c</span>) =></span> c.startsWith(line));
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">completer</span>(<span class="hljs-params">line</span>) {
+  <span class="hljs-keyword">const</span> completions = <span class="hljs-string">'.help .error .exit .quit .q'</span>.<span class="hljs-title function_">split</span>(<span class="hljs-string">' '</span>);
+  <span class="hljs-keyword">const</span> hits = completions.<span class="hljs-title function_">filter</span>(<span class="hljs-function">(<span class="hljs-params">c</span>) =></span> c.<span class="hljs-title function_">startsWith</span>(line));
   <span class="hljs-comment">// Show all completions if none found</span>
-  <span class="hljs-keyword">return</span> [hits.length ? hits : completions, line];
+  <span class="hljs-keyword">return</span> [hits.<span class="hljs-property">length</span> ? hits : completions, line];
 }</code></pre>
 <p>The <code>completer</code> function can be called asynchronously if it accepts two
 arguments:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">completer</span>(<span class="hljs-params">linePartial, callback</span>) </span>{
-  callback(<span class="hljs-literal">null</span>, [[<span class="hljs-string">'123'</span>], linePartial]);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">completer</span>(<span class="hljs-params">linePartial, callback</span>) {
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, [[<span class="hljs-string">'123'</span>], linePartial]);
 }</code></pre>
-<h2><code>readline.cursorTo(stream, x[, y][, callback])</code><span><a class="mark" href="#readline_readline_cursorto_stream_x_y_callback" id="readline_readline_cursorto_stream_x_y_callback">#</a></span></h2>
+</section><section><h3><code>readline.cursorTo(stream, x[, y][, callback])</code><span><a class="mark" href="#readline_readline_cursorto_stream_x_y_callback" id="readline_readline_cursorto_stream_x_y_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -652,7 +758,7 @@ otherwise <code>true</code>.</li>
 </ul>
 <p>The <code>readline.cursorTo()</code> method moves cursor to the specified position in a
 given <a href="tty.html">TTY</a> <code>stream</code>.</p>
-<h2><code>readline.emitKeypressEvents(stream[, interface])</code><span><a class="mark" href="#readline_readline_emitkeypressevents_stream_interface" id="readline_readline_emitkeypressevents_stream_interface">#</a></span></h2>
+</section><section><h3><code>readline.emitKeypressEvents(stream[, interface])</code><span><a class="mark" href="#readline_readline_emitkeypressevents_stream_interface" id="readline_readline_emitkeypressevents_stream_interface">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -668,10 +774,10 @@ autocompletion is disabled when copy-pasted input is detected.</p>
 <p>This is automatically called by any readline instance on its <code>input</code> if the
 <code>input</code> is a terminal. Closing the <code>readline</code> instance does not stop
 the <code>input</code> from emitting <code>'keypress'</code> events.</p>
-<pre><code class="language-js">readline.emitKeypressEvents(process.stdin);
-<span class="hljs-keyword">if</span> (process.stdin.isTTY)
-  process.stdin.setRawMode(<span class="hljs-literal">true</span>);</code></pre>
-<h2><code>readline.moveCursor(stream, dx, dy[, callback])</code><span><a class="mark" href="#readline_readline_movecursor_stream_dx_dy_callback" id="readline_readline_movecursor_stream_dx_dy_callback">#</a></span></h2>
+<pre><code class="language-js">readline.<span class="hljs-title function_">emitKeypressEvents</span>(process.<span class="hljs-property">stdin</span>);
+<span class="hljs-keyword">if</span> (process.<span class="hljs-property">stdin</span>.<span class="hljs-property">isTTY</span>)
+  process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">setRawMode</span>(<span class="hljs-literal">true</span>);</code></pre>
+</section><section><h3><code>readline.moveCursor(stream, dx, dy[, callback])</code><span><a class="mark" href="#readline_readline_movecursor_stream_dx_dy_callback" id="readline_readline_movecursor_stream_dx_dy_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -694,67 +800,67 @@ otherwise <code>true</code>.</li>
 </ul>
 <p>The <code>readline.moveCursor()</code> method moves the cursor <em>relative</em> to its current
 position in a given <a href="tty.html">TTY</a> <code>stream</code>.</p>
-<h2>Example: Tiny CLI<span><a class="mark" href="#readline_example_tiny_cli" id="readline_example_tiny_cli">#</a></span></h2>
+</section><section><h3>Example: Tiny CLI<span><a class="mark" href="#readline_example_tiny_cli" id="readline_example_tiny_cli">#</a></span></h3>
 <p>The following example illustrates the use of <code>readline.Interface</code> class to
 implement a small command-line interface:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
-<span class="hljs-keyword">const</span> rl = readline.createInterface({
-  <span class="hljs-attr">input</span>: process.stdin,
-  <span class="hljs-attr">output</span>: process.stdout,
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
+  <span class="hljs-attr">input</span>: process.<span class="hljs-property">stdin</span>,
+  <span class="hljs-attr">output</span>: process.<span class="hljs-property">stdout</span>,
   <span class="hljs-attr">prompt</span>: <span class="hljs-string">'OHAI> '</span>
 });
 
-rl.prompt();
+rl.<span class="hljs-title function_">prompt</span>();
 
-rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
-  <span class="hljs-keyword">switch</span> (line.trim()) {
+rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
+  <span class="hljs-keyword">switch</span> (line.<span class="hljs-title function_">trim</span>()) {
     <span class="hljs-keyword">case</span> <span class="hljs-string">'hello'</span>:
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'world!'</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'world!'</span>);
       <span class="hljs-keyword">break</span>;
-    <span class="hljs-keyword">default</span>:
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Say what? I might have heard '<span class="hljs-subst">${line.trim()}</span>'`</span>);
+    <span class="hljs-attr">default</span>:
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Say what? I might have heard '<span class="hljs-subst">${line.trim()}</span>'`</span>);
       <span class="hljs-keyword">break</span>;
   }
-  rl.prompt();
-}).on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Have a great day!'</span>);
-  process.exit(<span class="hljs-number">0</span>);
+  rl.<span class="hljs-title function_">prompt</span>();
+}).<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Have a great day!'</span>);
+  process.<span class="hljs-title function_">exit</span>(<span class="hljs-number">0</span>);
 });</code></pre>
-<h2>Example: Read file stream line-by-Line<span><a class="mark" href="#readline_example_read_file_stream_line_by_line" id="readline_example_read_file_stream_line_by_line">#</a></span></h2>
+</section><section><h3>Example: Read file stream line-by-Line<span><a class="mark" href="#readline_example_read_file_stream_line_by_line" id="readline_example_read_file_stream_line_by_line">#</a></span></h3>
 <p>A common use case for <code>readline</code> is to consume an input file one line at a
 time. The easiest way to do so is leveraging the <a href="fs.html#fs_class_fs_readstream"><code>fs.ReadStream</code></a> API as
 well as a <code>for await...of</code> loop:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">processLineByLine</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> fileStream = fs.createReadStream(<span class="hljs-string">'input.txt'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">processLineByLine</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> fileStream = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'input.txt'</span>);
 
-  <span class="hljs-keyword">const</span> rl = readline.createInterface({
+  <span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
     <span class="hljs-attr">input</span>: fileStream,
-    <span class="hljs-attr">crlfDelay</span>: <span class="hljs-literal">Infinity</span>
+    <span class="hljs-attr">crlfDelay</span>: <span class="hljs-title class_">Infinity</span>
   });
   <span class="hljs-comment">// Note: we use the crlfDelay option to recognize all instances of CR LF</span>
   <span class="hljs-comment">// ('\r\n') in input.txt as a single line break.</span>
 
   <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> line <span class="hljs-keyword">of</span> rl) {
     <span class="hljs-comment">// Each line in input.txt will be successively available here as `line`.</span>
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Line from file: <span class="hljs-subst">${line}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Line from file: <span class="hljs-subst">${line}</span>`</span>);
   }
 }
 
-processLineByLine();</code></pre>
+<span class="hljs-title function_">processLineByLine</span>();</code></pre>
 <p>Alternatively, one could use the <a href="#readline_event_line"><code>'line'</code></a> event:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> readline = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
 
-<span class="hljs-keyword">const</span> rl = readline.createInterface({
-  <span class="hljs-attr">input</span>: fs.createReadStream(<span class="hljs-string">'sample.txt'</span>),
-  <span class="hljs-attr">crlfDelay</span>: <span class="hljs-literal">Infinity</span>
+<span class="hljs-keyword">const</span> rl = readline.<span class="hljs-title function_">createInterface</span>({
+  <span class="hljs-attr">input</span>: fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'sample.txt'</span>),
+  <span class="hljs-attr">crlfDelay</span>: <span class="hljs-title class_">Infinity</span>
 });
 
-rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Line from file: <span class="hljs-subst">${line}</span>`</span>);
+rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Line from file: <span class="hljs-subst">${line}</span>`</span>);
 });</code></pre>
 <p>Currently, <code>for await...of</code> loop can be a bit slower. If <code>async</code> / <code>await</code>
 flow and speed are both essential, a mixed approach can be applied:</p>
@@ -762,25 +868,25 @@ flow and speed are both essential, a mixed approach can be applied:</p>
 <span class="hljs-keyword">const</span> { createReadStream } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { createInterface } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'readline'</span>);
 
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">processLineByLine</span>(<span class="hljs-params"></span>) </span>{
+(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">processLineByLine</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">try</span> {
-    <span class="hljs-keyword">const</span> rl = createInterface({
-      <span class="hljs-attr">input</span>: createReadStream(<span class="hljs-string">'big-file.txt'</span>),
-      <span class="hljs-attr">crlfDelay</span>: <span class="hljs-literal">Infinity</span>
+    <span class="hljs-keyword">const</span> rl = <span class="hljs-title function_">createInterface</span>({
+      <span class="hljs-attr">input</span>: <span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'big-file.txt'</span>),
+      <span class="hljs-attr">crlfDelay</span>: <span class="hljs-title class_">Infinity</span>
     });
 
-    rl.on(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
+    rl.<span class="hljs-title function_">on</span>(<span class="hljs-string">'line'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> {
       <span class="hljs-comment">// Process the line.</span>
     });
 
-    <span class="hljs-keyword">await</span> once(rl, <span class="hljs-string">'close'</span>);
+    <span class="hljs-keyword">await</span> <span class="hljs-title function_">once</span>(rl, <span class="hljs-string">'close'</span>);
 
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'File processed.'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'File processed.'</span>);
   } <span class="hljs-keyword">catch</span> (err) {
-    <span class="hljs-built_in">console</span>.error(err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
   }
 })();</code></pre>
-<h2>TTY keybindings<span><a class="mark" href="#readline_tty_keybindings" id="readline_tty_keybindings">#</a></span></h2>
+</section><section><h3>TTY keybindings<span><a class="mark" href="#readline_tty_keybindings" id="readline_tty_keybindings">#</a></span></h3>
 <table>
   <tbody><tr>
     <th>Keybindings</th>
@@ -788,124 +894,160 @@ flow and speed are both essential, a mixed approach can be applied:</p>
     <th>Notes</th>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>shift</code> + <code>backspace</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Backspace</kbd></td>
     <td>Delete line left</td>
     <td>Doesn't work on Linux, Mac and Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>shift</code> + <code>delete</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Delete</kbd></td>
     <td>Delete line right</td>
     <td>Doesn't work on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>c</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>C</kbd></td>
     <td>Emit <code>SIGINT</code> or close the readline instance</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>h</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>H</kbd></td>
     <td>Delete left</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>d</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>D</kbd></td>
     <td>Delete right or close the readline instance in case the current line is empty / EOF</td>
     <td>Doesn't work on Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>u</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>U</kbd></td>
     <td>Delete from the current position to the line start</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>k</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>K</kbd></td>
     <td>Delete from the current position to the end of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>a</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>A</kbd></td>
     <td>Go to start of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>e</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>E</kbd></td>
     <td>Go to to end of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>b</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>B</kbd></td>
     <td>Back one character</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>f</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>F</kbd></td>
     <td>Forward one character</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>l</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>L</kbd></td>
     <td>Clear screen</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>n</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>N</kbd></td>
     <td>Next history item</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>p</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>P</kbd></td>
     <td>Previous history item</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>z</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Z</kbd></td>
     <td>Moves running process into background. Type
-    <code>fg</code> and press <code>enter</code>
+    <code>fg</code> and press <kbd>Enter</kbd>
     to return.</td>
     <td>Doesn't work on Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>w</code> or <code>ctrl</code>
-    + <code>backspace</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>W</kbd> or <kbd>Ctrl</kbd>
+   +<kbd>Backspace</kbd></td>
     <td>Delete backward to a word boundary</td>
-    <td><code>ctrl</code> + <code>backspace</code> Doesn't
+    <td><kbd>Ctrl</kbd>+<kbd>Backspace</kbd> Doesn't
     work on Linux, Mac and Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>delete</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Delete</kbd></td>
     <td>Delete forward to a word boundary</td>
     <td>Doesn't work on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>left</code> or
-    <code>meta</code> + <code>b</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> or
+    <kbd>Meta</kbd>+<kbd>B</kbd></td>
     <td>Word left</td>
-    <td><code>ctrl</code> + <code>left</code> Doesn't work
+    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> Doesn't work
     on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>right</code> or
-    <code>meta</code> + <code>f</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> or
+    <kbd>Meta</kbd>+<kbd>F</kbd></td>
     <td>Word right</td>
-    <td><code>ctrl</code> + <code>right</code> Doesn't work
+    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> Doesn't work
     on Mac</td>
   </tr>
   <tr>
-    <td><code>meta</code> + <code>d</code> or <code>meta</code>
-    + <code>delete</code></td>
+    <td><kbd>Meta</kbd>+<kbd>D</kbd> or <kbd>Meta</kbd>
+   +<kbd>Delete</kbd></td>
     <td>Delete word right</td>
-    <td><code>meta</code> + <code>delete</code> Doesn't work
+    <td><kbd>Meta</kbd>+<kbd>Delete</kbd> Doesn't work
     on windows</td>
   </tr>
   <tr>
-    <td><code>meta</code> + <code>backspace</code></td>
+    <td><kbd>Meta</kbd>+<kbd>Backspace</kbd></td>
     <td>Delete word left</td>
     <td>Doesn't work on Mac</td>
   </tr>
-</tbody></table>
+</tbody></table></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/readline.json b/doc/api/readline.json
index edd7985fe929dcb73a6cec14815da88b729a0f5a..1276c5179ca9e011860b72a1e464b4fa023ca4c6 100644
--- a/doc/api/readline.json
+++ b/doc/api/readline.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/readline.js\">lib/readline.js</a></p>\n<p>The <code>readline</code> module provides an interface for reading data from a <a href=\"stream.html#stream_readable_streams\">Readable</a>\nstream (such as <a href=\"process.html#process_process_stdin\"><code>process.stdin</code></a>) one line at a time. It can be accessed\nusing:</p>\n<pre><code class=\"language-js\">const readline = require('readline');\n</code></pre>\n<p>The following simple example illustrates the basic use of the <code>readline</code> module.</p>\n<pre><code class=\"language-js\">const readline = require('readline');\n\nconst rl = readline.createInterface({\n  input: process.stdin,\n  output: process.stdout\n});\n\nrl.question('What do you think of Node.js? ', (answer) => {\n  // TODO: Log the answer in a database\n  console.log(`Thank you for your valuable feedback: ${answer}`);\n\n  rl.close();\n});\n</code></pre>\n<p>Once this code is invoked, the Node.js application will not terminate until the\n<code>readline.Interface</code> is closed because the interface waits for data to be\nreceived on the <code>input</code> stream.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/readline.js\">lib/readline.js</a></p>\n<p>The <code>readline</code> module provides an interface for reading data from a <a href=\"stream.html#stream_readable_streams\">Readable</a>\nstream (such as <a href=\"process.html#process_process_stdin\"><code>process.stdin</code></a>) one line at a time. It can be accessed\nusing:</p>\n<pre><code class=\"language-js\">const readline = require('readline');\n</code></pre>\n<p>The following simple example illustrates the basic use of the <code>readline</code> module.</p>\n<pre><code class=\"language-js\">const readline = require('readline');\n\nconst rl = readline.createInterface({\n  input: process.stdin,\n  output: process.stdout\n});\n\nrl.question('What do you think of Node.js? ', (answer) => {\n  // TODO: Log the answer in a database\n  console.log(`Thank you for your valuable feedback: ${answer}`);\n\n  rl.close();\n});\n</code></pre>\n<p>Once this code is invoked, the Node.js application will not terminate until the\n<code>readline.Interface</code> is closed because the interface waits for data to be\nreceived on the <code>input</code> stream.</p>",
       "classes": [
         {
           "textRaw": "Class: `Interface`",
@@ -33,7 +33,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'close'</code> event is emitted when one of the following occur:</p>\n<ul>\n<li>The <code>rl.close()</code> method is called and the <code>readline.Interface</code> instance has\nrelinquished control over the <code>input</code> and <code>output</code> streams;</li>\n<li>The <code>input</code> stream receives its <code>'end'</code> event;</li>\n<li>The <code>input</code> stream receives <code>&#x3C;ctrl>-D</code> to signal end-of-transmission (EOT);</li>\n<li>The <code>input</code> stream receives <code>&#x3C;ctrl>-C</code> to signal <code>SIGINT</code> and there is no\n<code>'SIGINT'</code> event listener registered on the <code>readline.Interface</code> instance.</li>\n</ul>\n<p>The listener function is called without passing any arguments.</p>\n<p>The <code>readline.Interface</code> instance is finished once the <code>'close'</code> event is\nemitted.</p>"
+              "desc": "<p>The <code>'close'</code> event is emitted when one of the following occur:</p>\n<ul>\n<li>The <code>rl.close()</code> method is called and the <code>readline.Interface</code> instance has\nrelinquished control over the <code>input</code> and <code>output</code> streams;</li>\n<li>The <code>input</code> stream receives its <code>'end'</code> event;</li>\n<li>The <code>input</code> stream receives <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal\nend-of-transmission (EOT);</li>\n<li>The <code>input</code> stream receives <kbd>Ctrl</kbd>+<kbd>C</kbd> to signal <code>SIGINT</code>\nand there is no <code>'SIGINT'</code> event listener registered on the\n<code>readline.Interface</code> instance.</li>\n</ul>\n<p>The listener function is called without passing any arguments.</p>\n<p>The <code>readline.Interface</code> instance is finished once the <code>'close'</code> event is\nemitted.</p>"
             },
             {
               "textRaw": "Event: `'line'`",
@@ -46,7 +46,20 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'line'</code> event is emitted whenever the <code>input</code> stream receives an\nend-of-line input (<code>\\n</code>, <code>\\r</code>, or <code>\\r\\n</code>). This usually occurs when the user\npresses the <code>&#x3C;Enter></code>, or <code>&#x3C;Return></code> keys.</p>\n<p>The listener function is called with a string containing the single line of\nreceived input.</p>\n<pre><code class=\"language-js\">rl.on('line', (input) => {\n  console.log(`Received: ${input}`);\n});\n</code></pre>"
+              "desc": "<p>The <code>'line'</code> event is emitted whenever the <code>input</code> stream receives an\nend-of-line input (<code>\\n</code>, <code>\\r</code>, or <code>\\r\\n</code>). This usually occurs when the user\npresses <kbd>Enter</kbd> or <kbd>Return</kbd>.</p>\n<p>The listener function is called with a string containing the single line of\nreceived input.</p>\n<pre><code class=\"language-js\">rl.on('line', (input) => {\n  console.log(`Received: ${input}`);\n});\n</code></pre>"
+            },
+            {
+              "textRaw": "Event: `'history'`",
+              "type": "event",
+              "name": "history",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "params": [],
+              "desc": "<p>The <code>'history'</code> event is emitted whenever the history array has changed.</p>\n<p>The listener function is called with an array containing the history array.\nIt will reflect all changes, added lines and removed lines due to\n<code>historySize</code> and <code>removeHistoryDuplicates</code>.</p>\n<p>The primary purpose is to allow a listener to persist the history.\nIt is also possible for the listener to change the history object. This\ncould be useful to prevent certain lines to be added to the history, like\na password.</p>\n<pre><code class=\"language-js\">rl.on('history', (history) => {\n  console.log(`Received: ${history}`);\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'pause'`",
@@ -59,7 +72,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'pause'</code> event is emitted when one of the following occur:</p>\n<ul>\n<li>The <code>input</code> stream is paused.</li>\n<li>The <code>input</code> stream is not paused and receives the <code>'SIGCONT'</code> event. (See\nevents <a href=\"readline.html#readline_event_sigtstp\"><code>'SIGTSTP'</code></a> and <a href=\"readline.html#readline_event_sigcont\"><code>'SIGCONT'</code></a>.)</li>\n</ul>\n<p>The listener function is called without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('pause', () => {\n  console.log('Readline paused.');\n});\n</code></pre>"
+              "desc": "<p>The <code>'pause'</code> event is emitted when one of the following occur:</p>\n<ul>\n<li>The <code>input</code> stream is paused.</li>\n<li>The <code>input</code> stream is not paused and receives the <code>'SIGCONT'</code> event. (See\nevents <a href=\"#readline_event_sigtstp\"><code>'SIGTSTP'</code></a> and <a href=\"#readline_event_sigcont\"><code>'SIGCONT'</code></a>.)</li>\n</ul>\n<p>The listener function is called without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('pause', () => {\n  console.log('Readline paused.');\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'resume'`",
@@ -85,7 +98,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'SIGCONT'</code> event is emitted when a Node.js process previously moved into\nthe background using <code>&#x3C;ctrl>-Z</code> (i.e. <code>SIGTSTP</code>) is then brought back to the\nforeground using <a href=\"http://man7.org/linux/man-pages/man1/fg.1p.html\"><code>fg(1p)</code></a>.</p>\n<p>If the <code>input</code> stream was paused <em>before</em> the <code>SIGTSTP</code> request, this event will\nnot be emitted.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGCONT', () => {\n  // `prompt` will automatically resume the stream\n  rl.prompt();\n});\n</code></pre>\n<p>The <code>'SIGCONT'</code> event is <em>not</em> supported on Windows.</p>"
+              "desc": "<p>The <code>'SIGCONT'</code> event is emitted when a Node.js process previously moved into\nthe background using <kbd>Ctrl</kbd>+<kbd>Z</kbd> (i.e. <code>SIGTSTP</code>) is then\nbrought back to the foreground using <a href=\"http://man7.org/linux/man-pages/man1/fg.1p.html\"><code>fg(1p)</code></a>.</p>\n<p>If the <code>input</code> stream was paused <em>before</em> the <code>SIGTSTP</code> request, this event will\nnot be emitted.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGCONT', () => {\n  // `prompt` will automatically resume the stream\n  rl.prompt();\n});\n</code></pre>\n<p>The <code>'SIGCONT'</code> event is <em>not</em> supported on Windows.</p>"
             },
             {
               "textRaw": "Event: `'SIGINT'`",
@@ -98,7 +111,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'SIGINT'</code> event is emitted whenever the <code>input</code> stream receives a\n<code>&#x3C;ctrl>-C</code> input, known typically as <code>SIGINT</code>. If there are no <code>'SIGINT'</code> event\nlisteners registered when the <code>input</code> stream receives a <code>SIGINT</code>, the <code>'pause'</code>\nevent will be emitted.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGINT', () => {\n  rl.question('Are you sure you want to exit? ', (answer) => {\n    if (answer.match(/^y(es)?$/i)) rl.pause();\n  });\n});\n</code></pre>"
+              "desc": "<p>The <code>'SIGINT'</code> event is emitted whenever the <code>input</code> stream receives a\n<kbd>Ctrl+C</kbd> input, known typically as <code>SIGINT</code>. If there are no <code>'SIGINT'</code>\nevent listeners registered when the <code>input</code> stream receives a <code>SIGINT</code>, the\n<code>'pause'</code> event will be emitted.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGINT', () => {\n  rl.question('Are you sure you want to exit? ', (answer) => {\n    if (answer.match(/^y(es)?$/i)) rl.pause();\n  });\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'SIGTSTP'`",
@@ -111,7 +124,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'SIGTSTP'</code> event is emitted when the <code>input</code> stream receives a <code>&#x3C;ctrl>-Z</code>\ninput, typically known as <code>SIGTSTP</code>. If there are no <code>'SIGTSTP'</code> event listeners\nregistered when the <code>input</code> stream receives a <code>SIGTSTP</code>, the Node.js process\nwill be sent to the background.</p>\n<p>When the program is resumed using <a href=\"http://man7.org/linux/man-pages/man1/fg.1p.html\"><code>fg(1p)</code></a>, the <code>'pause'</code> and <code>'SIGCONT'</code> events\nwill be emitted. These can be used to resume the <code>input</code> stream.</p>\n<p>The <code>'pause'</code> and <code>'SIGCONT'</code> events will not be emitted if the <code>input</code> was\npaused before the process was sent to the background.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGTSTP', () => {\n  // This will override SIGTSTP and prevent the program from going to the\n  // background.\n  console.log('Caught SIGTSTP.');\n});\n</code></pre>\n<p>The <code>'SIGTSTP'</code> event is <em>not</em> supported on Windows.</p>"
+              "desc": "<p>The <code>'SIGTSTP'</code> event is emitted when the <code>input</code> stream receives a\n<kbd>Ctrl</kbd>+<kbd>Z</kbd> input, typically known as <code>SIGTSTP</code>. If there are\nno <code>'SIGTSTP'</code> event listeners registered when the <code>input</code> stream receives a\n<code>SIGTSTP</code>, the Node.js process will be sent to the background.</p>\n<p>When the program is resumed using <a href=\"http://man7.org/linux/man-pages/man1/fg.1p.html\"><code>fg(1p)</code></a>, the <code>'pause'</code> and <code>'SIGCONT'</code> events\nwill be emitted. These can be used to resume the <code>input</code> stream.</p>\n<p>The <code>'pause'</code> and <code>'SIGCONT'</code> events will not be emitted if the <code>input</code> was\npaused before the process was sent to the background.</p>\n<p>The listener function is invoked without passing any arguments.</p>\n<pre><code class=\"language-js\">rl.on('SIGTSTP', () => {\n  // This will override SIGTSTP and prevent the program from going to the\n  // background.\n  console.log('Caught SIGTSTP.');\n});\n</code></pre>\n<p>The <code>'SIGTSTP'</code> event is <em>not</em> supported on Windows.</p>"
             }
           ],
           "methods": [
@@ -174,7 +187,7 @@
               "desc": "<p>The <code>rl.prompt()</code> method writes the <code>readline.Interface</code> instances configured\n<code>prompt</code> to a new line in <code>output</code> in order to provide a user with a new\nlocation at which to provide input.</p>\n<p>When called, <code>rl.prompt()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the prompt is not written.</p>"
             },
             {
-              "textRaw": "`rl.question(query, callback)`",
+              "textRaw": "`rl.question(query[, options], callback)`",
               "type": "method",
               "name": "question",
               "meta": {
@@ -192,6 +205,19 @@
                       "type": "string",
                       "desc": "A statement or query to write to `output`, prepended to the prompt."
                     },
+                    {
+                      "textRaw": "`options` {Object}",
+                      "name": "options",
+                      "type": "Object",
+                      "options": [
+                        {
+                          "textRaw": "`signal` {AbortSignal} Optionally allows the `question()` to be canceled using an `AbortController`.",
+                          "name": "signal",
+                          "type": "AbortSignal",
+                          "desc": "Optionally allows the `question()` to be canceled using an `AbortController`."
+                        }
+                      ]
+                    },
                     {
                       "textRaw": "`callback` {Function} A callback function that is invoked with the user's input in response to the `query`.",
                       "name": "callback",
@@ -201,7 +227,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>rl.question()</code> method displays the <code>query</code> by writing it to the <code>output</code>,\nwaits for user input to be provided on <code>input</code>, then invokes the <code>callback</code>\nfunction passing the provided input as the first argument.</p>\n<p>When called, <code>rl.question()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the <code>query</code> is not written.</p>\n<p>Example usage:</p>\n<pre><code class=\"language-js\">rl.question('What is your favorite food? ', (answer) => {\n  console.log(`Oh, so your favorite food is ${answer}`);\n});\n</code></pre>\n<p>The <code>callback</code> function passed to <code>rl.question()</code> does not follow the typical\npattern of accepting an <code>Error</code> object or <code>null</code> as the first argument.\nThe <code>callback</code> is called with the provided answer as the only argument.</p>"
+              "desc": "<p>The <code>rl.question()</code> method displays the <code>query</code> by writing it to the <code>output</code>,\nwaits for user input to be provided on <code>input</code>, then invokes the <code>callback</code>\nfunction passing the provided input as the first argument.</p>\n<p>When called, <code>rl.question()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the <code>query</code> is not written.</p>\n<p>The <code>callback</code> function passed to <code>rl.question()</code> does not follow the typical\npattern of accepting an <code>Error</code> object or <code>null</code> as the first argument.\nThe <code>callback</code> is called with the provided answer as the only argument.</p>\n<p>Example usage:</p>\n<pre><code class=\"language-js\">rl.question('What is your favorite food? ', (answer) => {\n  console.log(`Oh, so your favorite food is ${answer}`);\n});\n</code></pre>\n<p>Using an <code>AbortController</code> to cancel a question.</p>\n<pre><code class=\"language-js\">const ac = new AbortController();\nconst signal = ac.signal;\n\nrl.question('What is your favorite food? ', { signal }, (answer) => {\n  console.log(`Oh, so your favorite food is ${answer}`);\n});\n\nsignal.addEventListener('abort', () => {\n  console.log('The food question timed out');\n}, { once: true });\n\nsetTimeout(() => ac.abort(), 10000);\n</code></pre>\n<p>If this method is invoked as it's util.promisify()ed version, it returns a\nPromise that fulfills with the answer. If the question is canceled using\nan <code>AbortController</code> it will reject with an <code>AbortError</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst question = util.promisify(rl.question).bind(rl);\n\nasync function questionExample() {\n  try {\n    const answer = await question('What is you favorite food? ');\n    console.log(`Oh, so your favorite food is ${answer}`);\n  } catch (err) {\n    console.error('Question rejected', err);\n  }\n}\nquestionExample();\n</code></pre>"
             },
             {
               "textRaw": "`rl.resume()`",
@@ -243,6 +269,29 @@
               ],
               "desc": "<p>The <code>rl.setPrompt()</code> method sets the prompt that will be written to <code>output</code>\nwhenever <code>rl.prompt()</code> is called.</p>"
             },
+            {
+              "textRaw": "`rl.getPrompt()`",
+              "type": "method",
+              "name": "getPrompt",
+              "meta": {
+                "added": [
+                  "v14.17.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {string} the current prompt string",
+                    "name": "return",
+                    "type": "string",
+                    "desc": "the current prompt string"
+                  },
+                  "params": []
+                }
+              ],
+              "desc": "<p>The <code>rl.getPrompt()</code> method returns the current prompt used by <code>rl.prompt()</code>.</p>"
+            },
             {
               "textRaw": "`rl.write(data[, key])`",
               "type": "method",
@@ -267,22 +316,22 @@
                       "type": "Object",
                       "options": [
                         {
-                          "textRaw": "`ctrl` {boolean} `true` to indicate the `<ctrl>` key.",
+                          "textRaw": "`ctrl` {boolean} `true` to indicate the <kbd>Ctrl</kbd> key.",
                           "name": "ctrl",
                           "type": "boolean",
-                          "desc": "`true` to indicate the `<ctrl>` key."
+                          "desc": "`true` to indicate the <kbd>Ctrl</kbd> key."
                         },
                         {
-                          "textRaw": "`meta` {boolean} `true` to indicate the `<Meta>` key.",
+                          "textRaw": "`meta` {boolean} `true` to indicate the <kbd>Meta</kbd> key.",
                           "name": "meta",
                           "type": "boolean",
-                          "desc": "`true` to indicate the `<Meta>` key."
+                          "desc": "`true` to indicate the <kbd>Meta</kbd> key."
                         },
                         {
-                          "textRaw": "`shift` {boolean} `true` to indicate the `<Shift>` key.",
+                          "textRaw": "`shift` {boolean} `true` to indicate the <kbd>Shift</kbd> key.",
                           "name": "shift",
                           "type": "boolean",
-                          "desc": "`true` to indicate the `<Shift>` key."
+                          "desc": "`true` to indicate the <kbd>Shift</kbd> key."
                         },
                         {
                           "textRaw": "`name` {string} The name of the a key.",
@@ -295,7 +344,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>rl.write()</code> method will write either <code>data</code> or a key sequence identified\nby <code>key</code> to the <code>output</code>. The <code>key</code> argument is supported only if <code>output</code> is\na <a href=\"tty.html\">TTY</a> text terminal. See <a href=\"#readline_tty_keybindings\">TTY keybindings</a> for a list of key\ncombinations.</p>\n<p>If <code>key</code> is specified, <code>data</code> is ignored.</p>\n<p>When called, <code>rl.write()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the <code>data</code> and <code>key</code> are not written.</p>\n<pre><code class=\"language-js\">rl.write('Delete this!');\n// Simulate Ctrl+u to delete the line written previously\nrl.write(null, { ctrl: true, name: 'u' });\n</code></pre>\n<p>The <code>rl.write()</code> method will write the data to the <code>readline</code> <code>Interface</code>'s\n<code>input</code> <em>as if it were provided by the user</em>.</p>"
+              "desc": "<p>The <code>rl.write()</code> method will write either <code>data</code> or a key sequence identified\nby <code>key</code> to the <code>output</code>. The <code>key</code> argument is supported only if <code>output</code> is\na <a href=\"tty.html\">TTY</a> text terminal. See <a href=\"#readline_tty_keybindings\">TTY keybindings</a> for a list of key\ncombinations.</p>\n<p>If <code>key</code> is specified, <code>data</code> is ignored.</p>\n<p>When called, <code>rl.write()</code> will resume the <code>input</code> stream if it has been\npaused.</p>\n<p>If the <code>readline.Interface</code> was created with <code>output</code> set to <code>null</code> or\n<code>undefined</code> the <code>data</code> and <code>key</code> are not written.</p>\n<pre><code class=\"language-js\">rl.write('Delete this!');\n// Simulate Ctrl+U to delete the line written previously\nrl.write(null, { ctrl: true, name: 'u' });\n</code></pre>\n<p>The <code>rl.write()</code> method will write the data to the <code>readline</code> <code>Interface</code>'s\n<code>input</code> <em>as if it were provided by the user</em>.</p>"
             },
             {
               "textRaw": "`rl[Symbol.asyncIterator]()`",
@@ -303,11 +352,15 @@
               "name": "[Symbol.asyncIterator]",
               "meta": {
                 "added": [
-                  "v11.4.0"
+                  "v11.4.0",
+                  "v10.16.0"
                 ],
                 "changes": [
                   {
-                    "version": "v11.14.0",
+                    "version": [
+                      "v11.14.0",
+                      "v10.17.0"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/26989",
                     "description": "Symbol.asyncIterator support is no longer experimental."
                   }
@@ -323,7 +376,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Create an <code>AsyncIterator</code> object that iterates through each line in the input\nstream as a string. This method allows asynchronous iteration of\n<code>readline.Interface</code> objects through <code>for await...of</code> loops.</p>\n<p>Errors in the input stream are not forwarded.</p>\n<p>If the loop is terminated with <code>break</code>, <code>throw</code>, or <code>return</code>,\n<a href=\"#readline_rl_close\"><code>rl.close()</code></a> will be called. In other words, iterating over a\n<code>readline.Interface</code> will always consume the input stream fully.</p>\n<p>Performance is not on par with the traditional <code>'line'</code> event API. Use <code>'line'</code>\ninstead for performance-sensitive applications.</p>\n<pre><code class=\"language-js\">async function processLineByLine() {\n  const rl = readline.createInterface({\n    // ...\n  });\n\n  for await (const line of rl) {\n    // Each line in the readline input will be successively available here as\n    // `line`.\n  }\n}\n</code></pre>"
+              "desc": "<p>Create an <code>AsyncIterator</code> object that iterates through each line in the input\nstream as a string. This method allows asynchronous iteration of\n<code>readline.Interface</code> objects through <code>for await...of</code> loops.</p>\n<p>Errors in the input stream are not forwarded.</p>\n<p>If the loop is terminated with <code>break</code>, <code>throw</code>, or <code>return</code>,\n<a href=\"#readline_rl_close\"><code>rl.close()</code></a> will be called. In other words, iterating over a\n<code>readline.Interface</code> will always consume the input stream fully.</p>\n<p>Performance is not on par with the traditional <code>'line'</code> event API. Use <code>'line'</code>\ninstead for performance-sensitive applications.</p>\n<pre><code class=\"language-js\">async function processLineByLine() {\n  const rl = readline.createInterface({\n    // ...\n  });\n\n  for await (const line of rl) {\n    // Each line in the readline input will be successively available here as\n    // `line`.\n  }\n}\n</code></pre>\n<p><code>readline.createInterface()</code> will start to consume the input stream once\ninvoked. Having asynchronous operations between interface creation and\nasynchronous iteration may result in missed lines.</p>"
             },
             {
               "textRaw": "`rl.getCursorPos()`",
@@ -331,6 +384,7 @@
               "name": "getCursorPos",
               "meta": {
                 "added": [
+                  "v13.5.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -364,14 +418,20 @@
           ],
           "properties": [
             {
-              "textRaw": "`line` {string|undefined}",
-              "type": "string|undefined",
+              "textRaw": "`line` {string}",
+              "type": "string",
               "name": "line",
               "meta": {
                 "added": [
                   "v0.1.98"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/33676",
+                    "description": "Value will always be a string, never undefined."
+                  }
+                ]
               },
               "desc": "<p>The current input data being processed by node.</p>\n<p>This can be used when collecting input from a TTY stream to retrieve the\ncurrent value that has been processed thus far, prior to the <code>line</code> event\nbeing emitted. Once the <code>line</code> event has been emitted, this property will\nbe an empty string.</p>\n<p>Be aware that modifying the value during the instance runtime may have\nunintended consequences if <code>rl.cursor</code> is not also controlled.</p>\n<p><strong>If not using a TTY stream for input, use the <a href=\"#readline_event_line\"><code>'line'</code></a> event.</strong></p>\n<p>One possible use case would be as follows:</p>\n<pre><code class=\"language-js\">const values = ['lorem ipsum', 'dolor sit amet'];\nconst rl = readline.createInterface(process.stdin);\nconst showResults = debounce(() => {\n  console.log(\n    '\\n',\n    values.filter((val) => val.startsWith(rl.line)).join(' ')\n  );\n}, 300);\nprocess.stdin.on('keypress', (c, k) => {\n  showResults();\n});\n</code></pre>"
             },
@@ -505,7 +565,25 @@
             ],
             "changes": [
               {
-                "version": "v8.3.0, 6.11.4",
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/37932",
+                "description": "The `signal` option is supported now."
+              },
+              {
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/33662",
+                "description": "The `history` option is supported now."
+              },
+              {
+                "version": "v13.9.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31318",
+                "description": "The `tabSize` option is supported now."
+              },
+              {
+                "version": [
+                  "v8.3.0",
+                  "v6.11.4"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/13497",
                 "description": "Remove max limit of `crlfDelay` option."
               },
@@ -528,6 +606,11 @@
           },
           "signatures": [
             {
+              "return": {
+                "textRaw": "Returns: {readline.Interface}",
+                "name": "return",
+                "type": "readline.Interface"
+              },
               "params": [
                 {
                   "textRaw": "`options` {Object}",
@@ -559,6 +642,13 @@
                       "default": "checking `isTTY` on the `output` stream upon instantiation",
                       "desc": "`true` if the `input` and `output` streams should be treated like a TTY, and have ANSI/VT100 escape codes written to it."
                     },
+                    {
+                      "textRaw": "`history` {string[]} Initial list of history lines. This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check, otherwise the history caching mechanism is not initialized at all. **Default:** `[]`.",
+                      "name": "history",
+                      "type": "string[]",
+                      "default": "`[]`",
+                      "desc": "Initial list of history lines. This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check, otherwise the history caching mechanism is not initialized at all."
+                    },
                     {
                       "textRaw": "`historySize` {number} Maximum number of history lines retained. To disable the history set this value to `0`. This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check, otherwise the history caching mechanism is not initialized at all. **Default:** `30`.",
                       "name": "historySize",
@@ -566,6 +656,13 @@
                       "default": "`30`",
                       "desc": "Maximum number of history lines retained. To disable the history set this value to `0`. This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check, otherwise the history caching mechanism is not initialized at all."
                     },
+                    {
+                      "textRaw": "`removeHistoryDuplicates` {boolean} If `true`, when a new input line added to the history list duplicates an older one, this removes the older line from the list. **Default:** `false`.",
+                      "name": "removeHistoryDuplicates",
+                      "type": "boolean",
+                      "default": "`false`",
+                      "desc": "If `true`, when a new input line added to the history list duplicates an older one, this removes the older line from the list."
+                    },
                     {
                       "textRaw": "`prompt` {string} The prompt string to use. **Default:** `'> '`.",
                       "name": "prompt",
@@ -580,26 +677,32 @@
                       "default": "`100`",
                       "desc": "If the delay between `\\r` and `\\n` exceeds `crlfDelay` milliseconds, both `\\r` and `\\n` will be treated as separate end-of-line input. `crlfDelay` will be coerced to a number no less than `100`. It can be set to `Infinity`, in which case `\\r` followed by `\\n` will always be considered a single newline (which may be reasonable for [reading files][] with `\\r\\n` line delimiter)."
                     },
-                    {
-                      "textRaw": "`removeHistoryDuplicates` {boolean} If `true`, when a new input line added to the history list duplicates an older one, this removes the older line from the list. **Default:** `false`.",
-                      "name": "removeHistoryDuplicates",
-                      "type": "boolean",
-                      "default": "`false`",
-                      "desc": "If `true`, when a new input line added to the history list duplicates an older one, this removes the older line from the list."
-                    },
                     {
                       "textRaw": "`escapeCodeTimeout` {number} The duration `readline` will wait for a character (when reading an ambiguous key sequence in milliseconds one that can both form a complete key sequence using the input read so far and can take additional input to complete a longer key sequence). **Default:** `500`.",
                       "name": "escapeCodeTimeout",
                       "type": "number",
                       "default": "`500`",
                       "desc": "The duration `readline` will wait for a character (when reading an ambiguous key sequence in milliseconds one that can both form a complete key sequence using the input read so far and can take additional input to complete a longer key sequence)."
+                    },
+                    {
+                      "textRaw": "`tabSize` {integer} The number of spaces a tab is equal to (minimum 1). **Default:** `8`.",
+                      "name": "tabSize",
+                      "type": "integer",
+                      "default": "`8`",
+                      "desc": "The number of spaces a tab is equal to (minimum 1)."
+                    },
+                    {
+                      "textRaw": "`signal` {AbortSignal} Allows closing the interface using an AbortSignal. Aborting the signal will internally call `close` on the interface.",
+                      "name": "signal",
+                      "type": "AbortSignal",
+                      "desc": "Allows closing the interface using an AbortSignal. Aborting the signal will internally call `close` on the interface."
                     }
                   ]
                 }
               ]
             }
           ],
-          "desc": "<p>The <code>readline.createInterface()</code> method creates a new <code>readline.Interface</code>\ninstance.</p>\n<pre><code class=\"language-js\">const readline = require('readline');\nconst rl = readline.createInterface({\n  input: process.stdin,\n  output: process.stdout\n});\n</code></pre>\n<p>Once the <code>readline.Interface</code> instance is created, the most common case is to\nlisten for the <code>'line'</code> event:</p>\n<pre><code class=\"language-js\">rl.on('line', (line) => {\n  console.log(`Received: ${line}`);\n});\n</code></pre>\n<p>If <code>terminal</code> is <code>true</code> for this instance then the <code>output</code> stream will get\nthe best compatibility if it defines an <code>output.columns</code> property and emits\na <code>'resize'</code> event on the <code>output</code> if or when the columns ever change\n(<a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> does this automatically when it is a TTY).</p>",
+          "desc": "<p>The <code>readline.createInterface()</code> method creates a new <code>readline.Interface</code>\ninstance.</p>\n<pre><code class=\"language-js\">const readline = require('readline');\nconst rl = readline.createInterface({\n  input: process.stdin,\n  output: process.stdout\n});\n</code></pre>\n<p>Once the <code>readline.Interface</code> instance is created, the most common case is to\nlisten for the <code>'line'</code> event:</p>\n<pre><code class=\"language-js\">rl.on('line', (line) => {\n  console.log(`Received: ${line}`);\n});\n</code></pre>\n<p>If <code>terminal</code> is <code>true</code> for this instance then the <code>output</code> stream will get\nthe best compatibility if it defines an <code>output.columns</code> property and emits\na <code>'resize'</code> event on the <code>output</code> if or when the columns ever change\n(<a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> does this automatically when it is a TTY).</p>\n<p>When creating a <code>readline.Interface</code> using <code>stdin</code> as input, the program\nwill not terminate until it receives <code>EOF</code> (<kbd>Ctrl</kbd>+<kbd>D</kbd> on\nLinux/macOS, <kbd>Ctrl</kbd>+<kbd>Z</kbd> followed by <kbd>Return</kbd> on\nWindows).\nIf you want your application to exit without waiting for user input, you can\n<a href=\"net.html#net_socket_unref\"><code>unref()</code></a> the standard input stream:</p>\n<pre><code class=\"language-js\">process.stdin.unref();\n</code></pre>",
           "modules": [
             {
               "textRaw": "Use of the `completer` function",
@@ -745,7 +848,7 @@
         {
           "textRaw": "TTY keybindings",
           "name": "tty_keybindings",
-          "desc": "<table>\n  <tr>\n    <th>Keybindings</th>\n    <th>Description</th>\n    <th>Notes</th>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>shift</code> + <code>backspace</code></td>\n    <td>Delete line left</td>\n    <td>Doesn't work on Linux, Mac and Windows</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>shift</code> + <code>delete</code></td>\n    <td>Delete line right</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>c</code></td>\n    <td>Emit <code>SIGINT</code> or close the readline instance</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>h</code></td>\n    <td>Delete left</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>d</code></td>\n    <td>Delete right or close the readline instance in case the current line is empty / EOF</td>\n    <td>Doesn't work on Windows</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>u</code></td>\n    <td>Delete from the current position to the line start</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>k</code></td>\n    <td>Delete from the current position to the end of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>a</code></td>\n    <td>Go to start of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>e</code></td>\n    <td>Go to to end of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>b</code></td>\n    <td>Back one character</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>f</code></td>\n    <td>Forward one character</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>l</code></td>\n    <td>Clear screen</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>n</code></td>\n    <td>Next history item</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>p</code></td>\n    <td>Previous history item</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>z</code></td>\n    <td>Moves running process into background. Type\n    <code>fg</code> and press <code>enter</code>\n    to return.</td>\n    <td>Doesn't work on Windows</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>w</code> or <code>ctrl</code>\n    + <code>backspace</code></td>\n    <td>Delete backward to a word boundary</td>\n    <td><code>ctrl</code> + <code>backspace</code> Doesn't\n    work on Linux, Mac and Windows</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>delete</code></td>\n    <td>Delete forward to a word boundary</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>left</code> or\n    <code>meta</code> + <code>b</code></td>\n    <td>Word left</td>\n    <td><code>ctrl</code> + <code>left</code> Doesn't work\n    on Mac</td>\n  </tr>\n  <tr>\n    <td><code>ctrl</code> + <code>right</code> or\n    <code>meta</code> + <code>f</code></td>\n    <td>Word right</td>\n    <td><code>ctrl</code> + <code>right</code> Doesn't work\n    on Mac</td>\n  </tr>\n  <tr>\n    <td><code>meta</code> + <code>d</code> or <code>meta</code>\n    + <code>delete</code></td>\n    <td>Delete word right</td>\n    <td><code>meta</code> + <code>delete</code> Doesn't work\n    on windows</td>\n  </tr>\n  <tr>\n    <td><code>meta</code> + <code>backspace</code></td>\n    <td>Delete word left</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n</table>",
+          "desc": "<table>\n  <tr>\n    <th>Keybindings</th>\n    <th>Description</th>\n    <th>Notes</th>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Backspace</kbd></td>\n    <td>Delete line left</td>\n    <td>Doesn't work on Linux, Mac and Windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Delete</kbd></td>\n    <td>Delete line right</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>C</kbd></td>\n    <td>Emit <code>SIGINT</code> or close the readline instance</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>H</kbd></td>\n    <td>Delete left</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>D</kbd></td>\n    <td>Delete right or close the readline instance in case the current line is empty / EOF</td>\n    <td>Doesn't work on Windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>U</kbd></td>\n    <td>Delete from the current position to the line start</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>K</kbd></td>\n    <td>Delete from the current position to the end of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>A</kbd></td>\n    <td>Go to start of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>E</kbd></td>\n    <td>Go to to end of line</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>B</kbd></td>\n    <td>Back one character</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>F</kbd></td>\n    <td>Forward one character</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>L</kbd></td>\n    <td>Clear screen</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>N</kbd></td>\n    <td>Next history item</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>P</kbd></td>\n    <td>Previous history item</td>\n    <td></td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Z</kbd></td>\n    <td>Moves running process into background. Type\n    <code>fg</code> and press <kbd>Enter</kbd>\n    to return.</td>\n    <td>Doesn't work on Windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>W</kbd> or <kbd>Ctrl</kbd>\n   +<kbd>Backspace</kbd></td>\n    <td>Delete backward to a word boundary</td>\n    <td><kbd>Ctrl</kbd>+<kbd>Backspace</kbd> Doesn't\n    work on Linux, Mac and Windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Delete</kbd></td>\n    <td>Delete forward to a word boundary</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> or\n    <kbd>Meta</kbd>+<kbd>B</kbd></td>\n    <td>Word left</td>\n    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> Doesn't work\n    on Mac</td>\n  </tr>\n  <tr>\n    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> or\n    <kbd>Meta</kbd>+<kbd>F</kbd></td>\n    <td>Word right</td>\n    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> Doesn't work\n    on Mac</td>\n  </tr>\n  <tr>\n    <td><kbd>Meta</kbd>+<kbd>D</kbd> or <kbd>Meta</kbd>\n   +<kbd>Delete</kbd></td>\n    <td>Delete word right</td>\n    <td><kbd>Meta</kbd>+<kbd>Delete</kbd> Doesn't work\n    on windows</td>\n  </tr>\n  <tr>\n    <td><kbd>Meta</kbd>+<kbd>Backspace</kbd></td>\n    <td>Delete word left</td>\n    <td>Doesn't work on Mac</td>\n  </tr>\n</table>",
           "type": "module",
           "displayName": "TTY keybindings"
         }
diff --git a/doc/api/readline.md b/doc/api/readline.md
index c5829bf746629f085701fd6fa9b151e91d8f0945..e78310fcfc97e7d7aa2a381f614d274d8540b724 100644
--- a/doc/api/readline.md
+++ b/doc/api/readline.md
@@ -59,9 +59,11 @@ The `'close'` event is emitted when one of the following occur:
 * The `rl.close()` method is called and the `readline.Interface` instance has
   relinquished control over the `input` and `output` streams;
 * The `input` stream receives its `'end'` event;
-* The `input` stream receives `<ctrl>-D` to signal end-of-transmission (EOT);
-* The `input` stream receives `<ctrl>-C` to signal `SIGINT` and there is no
-  `'SIGINT'` event listener registered on the `readline.Interface` instance.
+* The `input` stream receives <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal
+  end-of-transmission (EOT);
+* The `input` stream receives <kbd>Ctrl</kbd>+<kbd>C</kbd> to signal `SIGINT`
+  and there is no `'SIGINT'` event listener registered on the
+  `readline.Interface` instance.
 
 The listener function is called without passing any arguments.
 
@@ -75,7 +77,7 @@ added: v0.1.98
 
 The `'line'` event is emitted whenever the `input` stream receives an
 end-of-line input (`\n`, `\r`, or `\r\n`). This usually occurs when the user
-presses the `<Enter>`, or `<Return>` keys.
+presses <kbd>Enter</kbd> or <kbd>Return</kbd>.
 
 The listener function is called with a string containing the single line of
 received input.
@@ -86,6 +88,28 @@ rl.on('line', (input) => {
 });
 ```
 
+### Event: `'history'`
+<!-- YAML
+added: v14.18.0
+-->
+
+The `'history'` event is emitted whenever the history array has changed.
+
+The listener function is called with an array containing the history array.
+It will reflect all changes, added lines and removed lines due to
+`historySize` and `removeHistoryDuplicates`.
+
+The primary purpose is to allow a listener to persist the history.
+It is also possible for the listener to change the history object. This
+could be useful to prevent certain lines to be added to the history, like
+a password.
+
+```js
+rl.on('history', (history) => {
+  console.log(`Received: ${history}`);
+});
+```
+
 ### Event: `'pause'`
 <!-- YAML
 added: v0.7.5
@@ -126,8 +150,8 @@ added: v0.7.5
 -->
 
 The `'SIGCONT'` event is emitted when a Node.js process previously moved into
-the background using `<ctrl>-Z` (i.e. `SIGTSTP`) is then brought back to the
-foreground using fg(1p).
+the background using <kbd>Ctrl</kbd>+<kbd>Z</kbd> (i.e. `SIGTSTP`) is then
+brought back to the foreground using fg(1p).
 
 If the `input` stream was paused *before* the `SIGTSTP` request, this event will
 not be emitted.
@@ -149,9 +173,9 @@ added: v0.3.0
 -->
 
 The `'SIGINT'` event is emitted whenever the `input` stream receives a
-`<ctrl>-C` input, known typically as `SIGINT`. If there are no `'SIGINT'` event
-listeners registered when the `input` stream receives a `SIGINT`, the `'pause'`
-event will be emitted.
+<kbd>Ctrl+C</kbd> input, known typically as `SIGINT`. If there are no `'SIGINT'`
+event listeners registered when the `input` stream receives a `SIGINT`, the
+`'pause'` event will be emitted.
 
 The listener function is invoked without passing any arguments.
 
@@ -168,10 +192,10 @@ rl.on('SIGINT', () => {
 added: v0.7.5
 -->
 
-The `'SIGTSTP'` event is emitted when the `input` stream receives a `<ctrl>-Z`
-input, typically known as `SIGTSTP`. If there are no `'SIGTSTP'` event listeners
-registered when the `input` stream receives a `SIGTSTP`, the Node.js process
-will be sent to the background.
+The `'SIGTSTP'` event is emitted when the `input` stream receives a
+<kbd>Ctrl</kbd>+<kbd>Z</kbd> input, typically known as `SIGTSTP`. If there are
+no `'SIGTSTP'` event listeners registered when the `input` stream receives a
+`SIGTSTP`, the Node.js process will be sent to the background.
 
 When the program is resumed using fg(1p), the `'pause'` and `'SIGCONT'` events
 will be emitted. These can be used to resume the `input` stream.
@@ -232,13 +256,16 @@ paused.
 If the `readline.Interface` was created with `output` set to `null` or
 `undefined` the prompt is not written.
 
-### `rl.question(query, callback)`
+### `rl.question(query[, options], callback)`
 <!-- YAML
 added: v0.3.3
 -->
 
 * `query` {string} A statement or query to write to `output`, prepended to the
   prompt.
+* `options` {Object}
+  * `signal` {AbortSignal} Optionally allows the `question()` to be canceled
+    using an `AbortController`.
 * `callback` {Function} A callback function that is invoked with the user's
   input in response to the `query`.
 
@@ -252,6 +279,10 @@ paused.
 If the `readline.Interface` was created with `output` set to `null` or
 `undefined` the `query` is not written.
 
+The `callback` function passed to `rl.question()` does not follow the typical
+pattern of accepting an `Error` object or `null` as the first argument.
+The `callback` is called with the provided answer as the only argument.
+
 Example usage:
 
 ```js
@@ -260,9 +291,41 @@ rl.question('What is your favorite food? ', (answer) => {
 });
 ```
 
-The `callback` function passed to `rl.question()` does not follow the typical
-pattern of accepting an `Error` object or `null` as the first argument.
-The `callback` is called with the provided answer as the only argument.
+Using an `AbortController` to cancel a question.
+
+```js
+const ac = new AbortController();
+const signal = ac.signal;
+
+rl.question('What is your favorite food? ', { signal }, (answer) => {
+  console.log(`Oh, so your favorite food is ${answer}`);
+});
+
+signal.addEventListener('abort', () => {
+  console.log('The food question timed out');
+}, { once: true });
+
+setTimeout(() => ac.abort(), 10000);
+```
+
+If this method is invoked as it's util.promisify()ed version, it returns a
+Promise that fulfills with the answer. If the question is canceled using
+an `AbortController` it will reject with an `AbortError`.
+
+```js
+const util = require('util');
+const question = util.promisify(rl.question).bind(rl);
+
+async function questionExample() {
+  try {
+    const answer = await question('What is you favorite food? ');
+    console.log(`Oh, so your favorite food is ${answer}`);
+  } catch (err) {
+    console.error('Question rejected', err);
+  }
+}
+questionExample();
+```
 
 ### `rl.resume()`
 <!-- YAML
@@ -281,6 +344,15 @@ added: v0.1.98
 The `rl.setPrompt()` method sets the prompt that will be written to `output`
 whenever `rl.prompt()` is called.
 
+### `rl.getPrompt()`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Returns: {string} the current prompt string
+
+The `rl.getPrompt()` method returns the current prompt used by `rl.prompt()`.
+
 ### `rl.write(data[, key])`
 <!-- YAML
 added: v0.1.98
@@ -288,9 +360,9 @@ added: v0.1.98
 
 * `data` {string}
 * `key` {Object}
-  * `ctrl` {boolean} `true` to indicate the `<ctrl>` key.
-  * `meta` {boolean} `true` to indicate the `<Meta>` key.
-  * `shift` {boolean} `true` to indicate the `<Shift>` key.
+  * `ctrl` {boolean} `true` to indicate the <kbd>Ctrl</kbd> key.
+  * `meta` {boolean} `true` to indicate the <kbd>Meta</kbd> key.
+  * `shift` {boolean} `true` to indicate the <kbd>Shift</kbd> key.
   * `name` {string} The name of the a key.
 
 The `rl.write()` method will write either `data` or a key sequence identified
@@ -308,7 +380,7 @@ If the `readline.Interface` was created with `output` set to `null` or
 
 ```js
 rl.write('Delete this!');
-// Simulate Ctrl+u to delete the line written previously
+// Simulate Ctrl+U to delete the line written previously
 rl.write(null, { ctrl: true, name: 'u' });
 ```
 
@@ -317,9 +389,13 @@ The `rl.write()` method will write the data to the `readline` `Interface`'s
 
 ### `rl[Symbol.asyncIterator]()`
 <!-- YAML
-added: v11.4.0
+added:
+ - v11.4.0
+ - v10.16.0
 changes:
-  - version: v11.14.0
+  - version:
+     - v11.14.0
+     - v10.17.0
     pr-url: https://github.com/nodejs/node/pull/26989
     description: Symbol.asyncIterator support is no longer experimental.
 -->
@@ -352,12 +428,20 @@ async function processLineByLine() {
 }
 ```
 
-### rl.line
+`readline.createInterface()` will start to consume the input stream once
+invoked. Having asynchronous operations between interface creation and
+asynchronous iteration may result in missed lines.
+
+### `rl.line`
 <!-- YAML
 added: v0.1.98
+changes:
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/33676
+    description: Value will always be a string, never undefined.
 -->
 
-* {string|undefined}
+* {string}
 
 The current input data being processed by node.
 
@@ -387,7 +471,7 @@ process.stdin.on('keypress', (c, k) => {
 });
 ```
 
-### rl.cursor
+### `rl.cursor`
 <!-- YAML
 added: v0.1.98
 -->
@@ -403,7 +487,9 @@ as well as the column where the terminal caret will be rendered.
 
 ### `rl.getCursorPos()`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.5.0
+ - v12.16.0
 -->
 
 * Returns: {Object}
@@ -458,7 +544,18 @@ the current position of the cursor down.
 <!-- YAML
 added: v0.1.98
 changes:
-  - version: v8.3.0, 6.11.4
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37932
+    description: The `signal` option is supported now.
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/33662
+    description: The `history` option is supported now.
+  - version: v13.9.0
+    pr-url: https://github.com/nodejs/node/pull/31318
+    description: The `tabSize` option is supported now.
+  - version:
+    - v8.3.0
+    - v6.11.4
     pr-url: https://github.com/nodejs/node/pull/13497
     description: Remove max limit of `crlfDelay` option.
   - version: v6.6.0
@@ -481,11 +578,18 @@ changes:
   * `terminal` {boolean} `true` if the `input` and `output` streams should be
     treated like a TTY, and have ANSI/VT100 escape codes written to it.
     **Default:** checking `isTTY` on the `output` stream upon instantiation.
+  * `history` {string[]} Initial list of history lines. This option makes sense
+    only if `terminal` is set to `true` by the user or by an internal `output`
+    check, otherwise the history caching mechanism is not initialized at all.
+    **Default:** `[]`.
   * `historySize` {number} Maximum number of history lines retained. To disable
     the history set this value to `0`. This option makes sense only if
     `terminal` is set to `true` by the user or by an internal `output` check,
     otherwise the history caching mechanism is not initialized at all.
     **Default:** `30`.
+  * `removeHistoryDuplicates` {boolean} If `true`, when a new input line added
+    to the history list duplicates an older one, this removes the older line
+    from the list. **Default:** `false`.
   * `prompt` {string} The prompt string to use. **Default:** `'> '`.
   * `crlfDelay` {number} If the delay between `\r` and `\n` exceeds
     `crlfDelay` milliseconds, both `\r` and `\n` will be treated as separate
@@ -493,14 +597,16 @@ changes:
     `100`. It can be set to `Infinity`, in which case `\r` followed by `\n`
     will always be considered a single newline (which may be reasonable for
     [reading files][] with `\r\n` line delimiter). **Default:** `100`.
-  * `removeHistoryDuplicates` {boolean} If `true`, when a new input line added
-    to the history list duplicates an older one, this removes the older line
-    from the list. **Default:** `false`.
   * `escapeCodeTimeout` {number} The duration `readline` will wait for a
     character (when reading an ambiguous key sequence in milliseconds one that
     can both form a complete key sequence using the input read so far and can
     take additional input to complete a longer key sequence).
     **Default:** `500`.
+  * `tabSize` {integer} The number of spaces a tab is equal to (minimum 1).
+    **Default:** `8`.
+  * `signal` {AbortSignal} Allows closing the interface using an AbortSignal.
+    Aborting the signal will internally call `close` on the interface.
+* Returns: {readline.Interface}
 
 The `readline.createInterface()` method creates a new `readline.Interface`
 instance.
@@ -527,6 +633,17 @@ the best compatibility if it defines an `output.columns` property and emits
 a `'resize'` event on the `output` if or when the columns ever change
 ([`process.stdout`][] does this automatically when it is a TTY).
 
+When creating a `readline.Interface` using `stdin` as input, the program
+will not terminate until it receives `EOF` (<kbd>Ctrl</kbd>+<kbd>D</kbd> on
+Linux/macOS, <kbd>Ctrl</kbd>+<kbd>Z</kbd> followed by <kbd>Return</kbd> on
+Windows).
+If you want your application to exit without waiting for user input, you can
+[`unref()`][] the standard input stream:
+
+```js
+process.stdin.unref();
+```
+
 ### Use of the `completer` function
 
 The `completer` function takes the current line entered by the user
@@ -734,131 +851,132 @@ const { createInterface } = require('readline');
     <th>Notes</th>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>shift</code> + <code>backspace</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Backspace</kbd></td>
     <td>Delete line left</td>
     <td>Doesn't work on Linux, Mac and Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>shift</code> + <code>delete</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Delete</kbd></td>
     <td>Delete line right</td>
     <td>Doesn't work on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>c</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>C</kbd></td>
     <td>Emit <code>SIGINT</code> or close the readline instance</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>h</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>H</kbd></td>
     <td>Delete left</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>d</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>D</kbd></td>
     <td>Delete right or close the readline instance in case the current line is empty / EOF</td>
     <td>Doesn't work on Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>u</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>U</kbd></td>
     <td>Delete from the current position to the line start</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>k</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>K</kbd></td>
     <td>Delete from the current position to the end of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>a</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>A</kbd></td>
     <td>Go to start of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>e</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>E</kbd></td>
     <td>Go to to end of line</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>b</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>B</kbd></td>
     <td>Back one character</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>f</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>F</kbd></td>
     <td>Forward one character</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>l</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>L</kbd></td>
     <td>Clear screen</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>n</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>N</kbd></td>
     <td>Next history item</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>p</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>P</kbd></td>
     <td>Previous history item</td>
     <td></td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>z</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Z</kbd></td>
     <td>Moves running process into background. Type
-    <code>fg</code> and press <code>enter</code>
+    <code>fg</code> and press <kbd>Enter</kbd>
     to return.</td>
     <td>Doesn't work on Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>w</code> or <code>ctrl</code>
-    + <code>backspace</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>W</kbd> or <kbd>Ctrl</kbd>
+   +<kbd>Backspace</kbd></td>
     <td>Delete backward to a word boundary</td>
-    <td><code>ctrl</code> + <code>backspace</code> Doesn't
+    <td><kbd>Ctrl</kbd>+<kbd>Backspace</kbd> Doesn't
     work on Linux, Mac and Windows</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>delete</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Delete</kbd></td>
     <td>Delete forward to a word boundary</td>
     <td>Doesn't work on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>left</code> or
-    <code>meta</code> + <code>b</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> or
+    <kbd>Meta</kbd>+<kbd>B</kbd></td>
     <td>Word left</td>
-    <td><code>ctrl</code> + <code>left</code> Doesn't work
+    <td><kbd>Ctrl</kbd>+<kbd>Left arrow</kbd> Doesn't work
     on Mac</td>
   </tr>
   <tr>
-    <td><code>ctrl</code> + <code>right</code> or
-    <code>meta</code> + <code>f</code></td>
+    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> or
+    <kbd>Meta</kbd>+<kbd>F</kbd></td>
     <td>Word right</td>
-    <td><code>ctrl</code> + <code>right</code> Doesn't work
+    <td><kbd>Ctrl</kbd>+<kbd>Right arrow</kbd> Doesn't work
     on Mac</td>
   </tr>
   <tr>
-    <td><code>meta</code> + <code>d</code> or <code>meta</code>
-    + <code>delete</code></td>
+    <td><kbd>Meta</kbd>+<kbd>D</kbd> or <kbd>Meta</kbd>
+   +<kbd>Delete</kbd></td>
     <td>Delete word right</td>
-    <td><code>meta</code> + <code>delete</code> Doesn't work
+    <td><kbd>Meta</kbd>+<kbd>Delete</kbd> Doesn't work
     on windows</td>
   </tr>
   <tr>
-    <td><code>meta</code> + <code>backspace</code></td>
+    <td><kbd>Meta</kbd>+<kbd>Backspace</kbd></td>
     <td>Delete word left</td>
     <td>Doesn't work on Mac</td>
   </tr>
 </table>
 
-[`'SIGCONT'`]: readline.html#readline_event_sigcont
-[`'SIGTSTP'`]: readline.html#readline_event_sigtstp
+[Readable]: stream.md#stream_readable_streams
+[TTY]: tty.md
+[TTY keybindings]: #readline_tty_keybindings
+[Writable]: stream.md#stream_writable_streams
+[`'SIGCONT'`]: #readline_event_sigcont
+[`'SIGTSTP'`]: #readline_event_sigtstp
 [`'line'`]: #readline_event_line
-[`fs.ReadStream`]: fs.html#fs_class_fs_readstream
-[`process.stdin`]: process.html#process_process_stdin
-[`process.stdout`]: process.html#process_process_stdout
+[`fs.ReadStream`]: fs.md#fs_class_fs_readstream
+[`process.stdin`]: process.md#process_process_stdin
+[`process.stdout`]: process.md#process_process_stdout
 [`rl.close()`]: #readline_rl_close
-[Readable]: stream.html#stream_readable_streams
-[TTY]: tty.html
-[TTY keybindings]: #readline_tty_keybindings
-[Writable]: stream.html#stream_writable_streams
+[`unref()`]: net.md#net_socket_unref
 [reading files]: #readline_example_read_file_stream_line_by_line
diff --git a/doc/api/repl.html b/doc/api/repl.html
index d9b87316c71cc7208d164447a59c84144ef7033f..cb547e9f977faf9adf40af35d8d541143c02889e 100644
--- a/doc/api/repl.html
+++ b/doc/api/repl.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>REPL | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>REPL | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="repl" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/repl.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/repl.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/repl.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/repl.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/repl.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/repl.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/repl.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/repl.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/repl.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#repl_repl">REPL</a></span>
 <ul>
 <li><a href="#repl_design_and_features">Design and features</a>
@@ -162,6 +175,7 @@
 <li><a href="#repl_replserver_setuphistory_historypath_callback"><code>replServer.setupHistory(historyPath, callback)</code></a></li>
 </ul>
 </li>
+<li><a href="#repl_repl_builtinmodules"><code>repl.builtinModules</code></a></li>
 <li><a href="#repl_repl_start_options"><code>repl.start([options])</code></a></li>
 <li><a href="#repl_the_node_js_repl">The Node.js REPL</a>
 <ul>
@@ -173,19 +187,18 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>REPL<span><a class="mark" href="#repl_repl" id="repl_repl">#</a></span></h1>
+        <h2>REPL<span><a class="mark" href="#repl_repl" id="repl_repl">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/repl.js">lib/repl.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/repl.js">lib/repl.js</a></p>
 <p>The <code>repl</code> module provides a Read-Eval-Print-Loop (REPL) implementation that
 is available both as a standalone program or includible in other applications.
 It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);</code></pre>
-<h2>Design and features<span><a class="mark" href="#repl_design_and_features" id="repl_design_and_features">#</a></span></h2>
+<section><h3>Design and features<span><a class="mark" href="#repl_design_and_features" id="repl_design_and_features">#</a></span></h3>
 <p>The <code>repl</code> module exports the <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> class. While running,
 instances of <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> will accept individual lines of user input,
 evaluate those according to a user-defined evaluation function, then output the
@@ -198,11 +211,11 @@ ANSI-styled output, saving and restoring current REPL session state, error
 recovery, and customizable evaluation functions. Terminals that do not support
 ANSI styles and Emacs-style line editing automatically fall back to a limited
 feature set.</p>
-<h3>Commands and special keys<span><a class="mark" href="#repl_commands_and_special_keys" id="repl_commands_and_special_keys">#</a></span></h3>
+<h4>Commands and special keys<span><a class="mark" href="#repl_commands_and_special_keys" id="repl_commands_and_special_keys">#</a></span></h4>
 <p>The following special commands are supported by all REPL instances:</p>
 <ul>
-<li><code>.break</code>: When in the process of inputting a multi-line expression, entering
-the <code>.break</code> command (or pressing the <code>&#x3C;ctrl>-C</code> key combination) will abort
+<li><code>.break</code>: When in the process of inputting a multi-line expression, enter
+the <code>.break</code> command (or press <kbd>Ctrl</kbd>+<kbd>C</kbd>) to abort
 further input or processing of that expression.</li>
 <li><code>.clear</code>: Resets the REPL <code>context</code> to an empty object and clears any
 multi-line expression being input.</li>
@@ -212,9 +225,10 @@ multi-line expression being input.</li>
 <code>> .save ./file/to/save.js</code></li>
 <li><code>.load</code>: Load a file into the current REPL session.
 <code>> .load ./file/to/load.js</code></li>
-<li><code>.editor</code>: Enter editor mode (<code>&#x3C;ctrl>-D</code> to finish, <code>&#x3C;ctrl>-C</code> to cancel).</li>
+<li><code>.editor</code>: Enter editor mode (<kbd>Ctrl</kbd>+<kbd>D</kbd> to finish,
+<kbd>Ctrl</kbd>+<kbd>C</kbd> to cancel).</li>
 </ul>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> .editor</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">.editor</span>
 // Entering editor mode (^D to finish, ^C to cancel)
 function welcome(name) {
   return `Hello ${name}!`;
@@ -227,62 +241,63 @@ welcome('Node.js User');
 <span class="hljs-meta">></span></code></pre>
 <p>The following key combinations in the REPL have these special effects:</p>
 <ul>
-<li><code>&#x3C;ctrl>-C</code>: When pressed once, has the same effect as the <code>.break</code> command.
+<li><kbd>Ctrl</kbd>+<kbd>C</kbd>: When pressed once, has the same effect as the
+<code>.break</code> command.
 When pressed twice on a blank line, has the same effect as the <code>.exit</code>
 command.</li>
-<li><code>&#x3C;ctrl>-D</code>: Has the same effect as the <code>.exit</code> command.</li>
-<li><code>&#x3C;tab></code>: When pressed on a blank line, displays global and local (scope)
+<li><kbd>Ctrl</kbd>+<kbd>D</kbd>: Has the same effect as the <code>.exit</code> command.</li>
+<li><kbd>Tab</kbd>: When pressed on a blank line, displays global and local (scope)
 variables. When pressed while entering other input, displays relevant
 autocompletion options.</li>
 </ul>
 <p>For key bindings related to the reverse-i-search, see <a href="#repl_reverse_i_search"><code>reverse-i-search</code></a>.
 For all other key bindings, see <a href="readline.html#readline_tty_keybindings">TTY keybindings</a>.</p>
-<h3>Default evaluation<span><a class="mark" href="#repl_default_evaluation" id="repl_default_evaluation">#</a></span></h3>
+<h4>Default evaluation<span><a class="mark" href="#repl_default_evaluation" id="repl_default_evaluation">#</a></span></h4>
 <p>By default, all instances of <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> use an evaluation function
 that evaluates JavaScript expressions and provides access to Node.js built-in
 modules. This default behavior can be overridden by passing in an alternative
 evaluation function when the <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> instance is created.</p>
-<h4>JavaScript expressions<span><a class="mark" href="#repl_javascript_expressions" id="repl_javascript_expressions">#</a></span></h4>
+<h5>JavaScript expressions<span><a class="mark" href="#repl_javascript_expressions" id="repl_javascript_expressions">#</a></span></h5>
 <p>The default evaluator supports direct evaluation of JavaScript expressions:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> 1 + 1</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">1 + 1</span>
 2
-<span class="hljs-meta">></span><span class="bash"> const m = 2</span>
+<span class="hljs-meta">> </span><span class="language-bash">const m = 2</span>
 undefined
-<span class="hljs-meta">></span><span class="bash"> m + 1</span>
+<span class="hljs-meta">> </span><span class="language-bash">m + 1</span>
 3</code></pre>
 <p>Unless otherwise scoped within blocks or functions, variables declared
 either implicitly or using the <code>const</code>, <code>let</code>, or <code>var</code> keywords
 are declared at the global scope.</p>
-<h4>Global and local scope<span><a class="mark" href="#repl_global_and_local_scope" id="repl_global_and_local_scope">#</a></span></h4>
+<h5>Global and local scope<span><a class="mark" href="#repl_global_and_local_scope" id="repl_global_and_local_scope">#</a></span></h5>
 <p>The default evaluator provides access to any variables that exist in the global
 scope. It is possible to expose a variable to the REPL explicitly by assigning
 it to the <code>context</code> object associated with each <code>REPLServer</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 <span class="hljs-keyword">const</span> msg = <span class="hljs-string">'message'</span>;
 
-repl.start(<span class="hljs-string">'> '</span>).context.m = msg;</code></pre>
+repl.<span class="hljs-title function_">start</span>(<span class="hljs-string">'> '</span>).<span class="hljs-property">context</span>.<span class="hljs-property">m</span> = msg;</code></pre>
 <p>Properties in the <code>context</code> object appear as local within the REPL:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node repl_test.js</span>
-<span class="hljs-meta">></span><span class="bash"> m</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node repl_test.js</span>
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
 'message'</code></pre>
 <p>Context properties are not read-only by default. To specify read-only globals,
 context properties must be defined using <code>Object.defineProperty()</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 <span class="hljs-keyword">const</span> msg = <span class="hljs-string">'message'</span>;
 
-<span class="hljs-keyword">const</span> r = repl.start(<span class="hljs-string">'> '</span>);
-<span class="hljs-built_in">Object</span>.defineProperty(r.context, <span class="hljs-string">'m'</span>, {
+<span class="hljs-keyword">const</span> r = repl.<span class="hljs-title function_">start</span>(<span class="hljs-string">'> '</span>);
+<span class="hljs-title class_">Object</span>.<span class="hljs-title function_">defineProperty</span>(r.<span class="hljs-property">context</span>, <span class="hljs-string">'m'</span>, {
   <span class="hljs-attr">configurable</span>: <span class="hljs-literal">false</span>,
   <span class="hljs-attr">enumerable</span>: <span class="hljs-literal">true</span>,
   <span class="hljs-attr">value</span>: msg
 });</code></pre>
-<h4>Accessing core Node.js modules<span><a class="mark" href="#repl_accessing_core_node_js_modules" id="repl_accessing_core_node_js_modules">#</a></span></h4>
+<h5>Accessing core Node.js modules<span><a class="mark" href="#repl_accessing_core_node_js_modules" id="repl_accessing_core_node_js_modules">#</a></span></h5>
 <p>The default evaluator will automatically load Node.js core modules into the
 REPL environment when used. For instance, unless otherwise declared as a
 global or scoped variable, the input <code>fs</code> will be evaluated on-demand as
 <code>global.fs = require('fs')</code>.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> fs.createReadStream(<span class="hljs-string">'./some/file'</span>);</span></code></pre>
-<h4>Global uncaught exceptions<span><a class="mark" href="#repl_global_uncaught_exceptions" id="repl_global_uncaught_exceptions">#</a></span></h4>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">fs.createReadStream(<span class="hljs-string">'./some/file'</span>);</span></code></pre>
+<h5>Global uncaught exceptions<span><a class="mark" href="#repl_global_uncaught_exceptions" id="repl_global_uncaught_exceptions">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -296,26 +311,25 @@ global or scoped variable, the input <code>fs</code> will be evaluated on-demand
 REPL session.</p>
 <p>This use of the <a href="domain.html"><code>domain</code></a> module in the REPL has these side effects:</p>
 <ul>
-<li>Uncaught exceptions only emit the <a href="process.html#process_event_uncaughtexception"><code>'uncaughtException'</code></a> event in the
+<li>
+<p>Uncaught exceptions only emit the <a href="process.html#process_event_uncaughtexception"><code>'uncaughtException'</code></a> event in the
 standalone REPL. Adding a listener for this event in a REPL within
-another Node.js program throws <a href="errors.html#errors_err_invalid_repl_input"><code>ERR_INVALID_REPL_INPUT</code></a>.</li>
-<li>Trying to use <a href="process.html#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> throws
-an <a href="errors.html#errors_err_domain_cannot_set_uncaught_exception_capture"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a> error.</li>
-</ul>
-<p>As standalone program:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'uncaughtException'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Uncaught'</span>));
+another Node.js program results in <a href="errors.html#errors_err_invalid_repl_input"><code>ERR_INVALID_REPL_INPUT</code></a>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> r = repl.<span class="hljs-title function_">start</span>();
 
-<span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'foobar'</span>);
-<span class="hljs-comment">// Uncaught</span></code></pre>
-<p>When used in another application:</p>
-<pre><code class="language-js">process.on(<span class="hljs-string">'uncaughtException'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Uncaught'</span>));
-<span class="hljs-comment">// TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`</span>
-<span class="hljs-comment">// cannot be used in the REPL</span>
+r.<span class="hljs-title function_">write</span>(<span class="hljs-string">'process.on("uncaughtException", () => console.log("Foobar"));\n'</span>);
+<span class="hljs-comment">// Output stream includes:</span>
+<span class="hljs-comment">//   TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`</span>
+<span class="hljs-comment">//   cannot be used in the REPL</span>
 
-<span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'foobar'</span>);
-<span class="hljs-comment">// Thrown:</span>
-<span class="hljs-comment">// Error: foobar</span></code></pre>
-<h4>Assignment of the <code>_</code> (underscore) variable<span><a class="mark" href="#repl_assignment_of_the_underscore_variable" id="repl_assignment_of_the_underscore_variable">#</a></span></h4>
+r.<span class="hljs-title function_">close</span>();</code></pre>
+</li>
+<li>
+<p>Trying to use <a href="process.html#process_process_setuncaughtexceptioncapturecallback_fn"><code>process.setUncaughtExceptionCaptureCallback()</code></a> throws
+an <a href="errors.html#errors_err_domain_cannot_set_uncaught_exception_capture"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a> error.</p>
+</li>
+</ul>
+<h5>Assignment of the <code>_</code> (underscore) variable<span><a class="mark" href="#repl_assignment_of_the_underscore_variable" id="repl_assignment_of_the_underscore_variable">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -328,89 +342,101 @@ an <a href="errors.html#errors_err_domain_cannot_set_uncaught_exception_capture"
 <p>The default evaluator will, by default, assign the result of the most recently
 evaluated expression to the special variable <code>_</code> (underscore).
 Explicitly setting <code>_</code> to a value will disable this behavior.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> [ <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-string">'c'</span> ]</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">[ <span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>, <span class="hljs-string">'c'</span> ]</span>
 [ 'a', 'b', 'c' ]
-<span class="hljs-meta">></span><span class="bash"> _.length</span>
+<span class="hljs-meta">> </span><span class="language-bash">_.length</span>
 3
-<span class="hljs-meta">></span><span class="bash"> _ += 1</span>
+<span class="hljs-meta">> </span><span class="language-bash">_ += 1</span>
 Expression assignment to _ now disabled.
 4
-<span class="hljs-meta">></span><span class="bash"> 1 + 1</span>
+<span class="hljs-meta">> </span><span class="language-bash">1 + 1</span>
 2
-<span class="hljs-meta">></span><span class="bash"> _</span>
+<span class="hljs-meta">> </span><span class="language-bash">_</span>
 4</code></pre>
 <p>Similarly, <code>_error</code> will refer to the last seen error, if there was any.
 Explicitly setting <code>_error</code> to a value will disable this behavior.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> throw new Error(<span class="hljs-string">'foo'</span>);</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">throw new Error(<span class="hljs-string">'foo'</span>);</span>
 Error: foo
-<span class="hljs-meta">></span><span class="bash"> _error.message</span>
+<span class="hljs-meta">> </span><span class="language-bash">_error.message</span>
 'foo'</code></pre>
-<h4><code>await</code> keyword<span><a class="mark" href="#repl_await_keyword" id="repl_await_keyword">#</a></span></h4>
-<p>With the <a href="cli.html#cli_experimental_repl_await"><code>--experimental-repl-await</code></a> command line option specified,
+<h5><code>await</code> keyword<span><a class="mark" href="#repl_await_keyword" id="repl_await_keyword">#</a></span></h5>
+<p>With the <a href="cli.html#cli_experimental_repl_await"><code>--experimental-repl-await</code></a> command-line option specified,
 experimental support for the <code>await</code> keyword is enabled.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> await Promise.resolve(123)</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">await Promise.resolve(123)</span>
 123
-<span class="hljs-meta">></span><span class="bash"> await Promise.reject(new Error(<span class="hljs-string">'REPL await'</span>))</span>
+<span class="hljs-meta">> </span><span class="language-bash">await Promise.reject(new Error(<span class="hljs-string">'REPL await'</span>))</span>
 Error: REPL await
     at repl:1:45
-<span class="hljs-meta">></span><span class="bash"> const timeout = util.promisify(setTimeout);</span>
+<span class="hljs-meta">> </span><span class="language-bash">const timeout = util.promisify(setTimeout);</span>
 undefined
-<span class="hljs-meta">></span><span class="bash"> const old = Date.now(); await timeout(1000); console.log(Date.now() - old);</span>
+<span class="hljs-meta">> </span><span class="language-bash">const old = Date.now(); await timeout(1000); console.log(Date.now() - old);</span>
 1002
 undefined</code></pre>
-<h3>Reverse-i-search<span><a class="mark" href="#repl_reverse_i_search" id="repl_reverse_i_search">#</a></span></h3>
+<p>One known limitation of using the <code>await</code> keyword in the REPL is that
+it will invalidate the lexical scoping of the <code>const</code> and <code>let</code>
+keywords.</p>
+<p>For example:</p>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">const m = await Promise.resolve(123)</span>
+undefined
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
+123
+<span class="hljs-meta">> </span><span class="language-bash">const m = await Promise.resolve(234)</span>
+undefined
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
+234</code></pre>
+<h4>Reverse-i-search<span><a class="mark" href="#repl_reverse_i_search" id="repl_reverse_i_search">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.6.0</span>
 </div>
 <p>The REPL supports bi-directional reverse-i-search similar to <a href="https://en.wikipedia.org/wiki/Z_shell">ZSH</a>. It is
-triggered with <code>&#x3C;ctrl> + R</code> to search backward and <code>&#x3C;ctrl> + S</code> to search
-forward.</p>
-<p>Duplicated history entires will be skipped.</p>
-<p>Entries are accepted as soon as any button is pressed that doesn't correspond
-with the reverse search. Cancelling is possible by pressing <code>escape</code> or
-<code>&#x3C;ctrl> + C</code>.</p>
+triggered with <kbd>Ctrl</kbd>+<kbd>R</kbd> to search backward and
+<kbd>Ctrl</kbd>+<kbd>S</kbd> to search
+forwards.</p>
+<p>Duplicated history entries will be skipped.</p>
+<p>Entries are accepted as soon as any key is pressed that doesn't correspond
+with the reverse search. Cancelling is possible by pressing <kbd>Esc</kbd> or
+<kbd>Ctrl</kbd>+<kbd>C</kbd>.</p>
 <p>Changing the direction immediately searches for the next entry in the expected
 direction from the current position on.</p>
-<h3>Custom evaluation functions<span><a class="mark" href="#repl_custom_evaluation_functions" id="repl_custom_evaluation_functions">#</a></span></h3>
+<h4>Custom evaluation functions<span><a class="mark" href="#repl_custom_evaluation_functions" id="repl_custom_evaluation_functions">#</a></span></h4>
 <p>When a new <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> is created, a custom evaluation function may be
 provided. This can be used, for instance, to implement fully customized REPL
 applications.</p>
 <p>The following illustrates a hypothetical example of a REPL that performs
 translation of text from one language to another:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
-<span class="hljs-keyword">const</span> { Translator } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'translator'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">Translator</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'translator'</span>);
 
-<span class="hljs-keyword">const</span> myTranslator = <span class="hljs-keyword">new</span> Translator(<span class="hljs-string">'en'</span>, <span class="hljs-string">'fr'</span>);
+<span class="hljs-keyword">const</span> myTranslator = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Translator</span>(<span class="hljs-string">'en'</span>, <span class="hljs-string">'fr'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) </span>{
-  callback(<span class="hljs-literal">null</span>, myTranslator.translate(cmd));
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) {
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, myTranslator.<span class="hljs-title function_">translate</span>(cmd));
 }
 
-repl.start({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span>, <span class="hljs-attr">eval</span>: myEval });</code></pre>
-<h4>Recoverable errors<span><a class="mark" href="#repl_recoverable_errors" id="repl_recoverable_errors">#</a></span></h4>
-<p>As a user is typing input into the REPL prompt, pressing the <code>&#x3C;enter></code> key will
-send the current line of input to the <code>eval</code> function. In order to support
-multi-line input, the eval function can return an instance of <code>repl.Recoverable</code>
-to the provided callback function:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) </span>{
+repl.<span class="hljs-title function_">start</span>({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span>, <span class="hljs-attr">eval</span>: myEval });</code></pre>
+<h5>Recoverable errors<span><a class="mark" href="#repl_recoverable_errors" id="repl_recoverable_errors">#</a></span></h5>
+<p>At the REPL prompt, pressing <kbd>Enter</kbd> sends the current line of input to
+the <code>eval</code> function. In order to support multi-line input, the <code>eval</code> function
+can return an instance of <code>repl.Recoverable</code> to the provided callback function:</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) {
   <span class="hljs-keyword">let</span> result;
   <span class="hljs-keyword">try</span> {
-    result = vm.runInThisContext(cmd);
+    result = vm.<span class="hljs-title function_">runInThisContext</span>(cmd);
   } <span class="hljs-keyword">catch</span> (e) {
-    <span class="hljs-keyword">if</span> (isRecoverableError(e)) {
-      <span class="hljs-keyword">return</span> callback(<span class="hljs-keyword">new</span> repl.Recoverable(e));
+    <span class="hljs-keyword">if</span> (<span class="hljs-title function_">isRecoverableError</span>(e)) {
+      <span class="hljs-keyword">return</span> <span class="hljs-title function_">callback</span>(<span class="hljs-keyword">new</span> repl.<span class="hljs-title class_">Recoverable</span>(e));
     }
   }
-  callback(<span class="hljs-literal">null</span>, result);
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, result);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">isRecoverableError</span>(<span class="hljs-params">error</span>) </span>{
-  <span class="hljs-keyword">if</span> (error.name === <span class="hljs-string">'SyntaxError'</span>) {
-    <span class="hljs-keyword">return</span> <span class="hljs-regexp">/^(Unexpected end of input|Unexpected token)/</span>.test(error.message);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">isRecoverableError</span>(<span class="hljs-params">error</span>) {
+  <span class="hljs-keyword">if</span> (error.<span class="hljs-property">name</span> === <span class="hljs-string">'SyntaxError'</span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-regexp">/^(Unexpected end of input|Unexpected token)/</span>.<span class="hljs-title function_">test</span>(error.<span class="hljs-property">message</span>);
   }
   <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
 }</code></pre>
-<h3>Customizing REPL output<span><a class="mark" href="#repl_customizing_repl_output" id="repl_customizing_repl_output">#</a></span></h3>
+<h4>Customizing REPL output<span><a class="mark" href="#repl_customizing_repl_output" id="repl_customizing_repl_output">#</a></span></h4>
 <p>By default, <a href="#repl_class_replserver"><code>repl.REPLServer</code></a> instances format output using the
 <a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a> method before writing the output to the provided <code>Writable</code>
 stream (<code>process.stdout</code> by default). The <code>showProxy</code> inspection option is set
@@ -423,9 +449,9 @@ default writer to use ANSI style codes to colorize the output from the
 REPL's <a href="util.html#util_util_inspect_object_options">inspection defaults</a> from inside the REPL by using the
 <code>inspect.replDefaults</code> property which mirrors the <code>defaultOptions</code> from
 <a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a>.</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> util.inspect.replDefaults.compact = <span class="hljs-literal">false</span>;</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">util.inspect.replDefaults.compact = <span class="hljs-literal">false</span>;</span>
 false
-<span class="hljs-meta">></span><span class="bash"> [1]</span>
+<span class="hljs-meta">> </span><span class="language-bash">[1]</span>
 [
   1
 ]
@@ -435,16 +461,16 @@ function for the <code>writer</code> option on construction. The following examp
 instance, simply converts any input text to upper case:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 
-<span class="hljs-keyword">const</span> r = repl.start({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span>, <span class="hljs-attr">eval</span>: myEval, <span class="hljs-attr">writer</span>: myWriter });
+<span class="hljs-keyword">const</span> r = repl.<span class="hljs-title function_">start</span>({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span>, <span class="hljs-attr">eval</span>: myEval, <span class="hljs-attr">writer</span>: myWriter });
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) </span>{
-  callback(<span class="hljs-literal">null</span>, cmd);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">myEval</span>(<span class="hljs-params">cmd, context, filename, callback</span>) {
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, cmd);
 }
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">myWriter</span>(<span class="hljs-params">output</span>) </span>{
-  <span class="hljs-keyword">return</span> output.toUpperCase();
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">myWriter</span>(<span class="hljs-params">output</span>) {
+  <span class="hljs-keyword">return</span> output.<span class="hljs-title function_">toUpperCase</span>();
 }</code></pre>
-<h2>Class: <code>REPLServer</code><span><a class="mark" href="#repl_class_replserver" id="repl_class_replserver">#</a></span></h2>
+</section><section><h3>Class: <code>REPLServer</code><span><a class="mark" href="#repl_class_replserver" id="repl_class_replserver">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.1.91</span>
 </div>
@@ -458,21 +484,23 @@ or directly using the JavaScript <code>new</code> keyword.</p>
 
 <span class="hljs-keyword">const</span> options = { <span class="hljs-attr">useColors</span>: <span class="hljs-literal">true</span> };
 
-<span class="hljs-keyword">const</span> firstInstance = repl.start(options);
-<span class="hljs-keyword">const</span> secondInstance = <span class="hljs-keyword">new</span> repl.REPLServer(options);</code></pre>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#repl_event_exit" id="repl_event_exit">#</a></span></h3>
+<span class="hljs-keyword">const</span> firstInstance = repl.<span class="hljs-title function_">start</span>(options);
+<span class="hljs-keyword">const</span> secondInstance = <span class="hljs-keyword">new</span> repl.<span class="hljs-title function_">REPLServer</span>(options);</code></pre>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#repl_event_exit" id="repl_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>The <code>'exit'</code> event is emitted when the REPL is exited either by receiving the
-<code>.exit</code> command as input, the user pressing <code>&#x3C;ctrl>-C</code> twice to signal <code>SIGINT</code>,
-or by pressing <code>&#x3C;ctrl>-D</code> to signal <code>'end'</code> on the input stream. The listener
+<code>.exit</code> command as input, the user pressing <kbd>Ctrl</kbd>+<kbd>C</kbd> twice
+to signal <code>SIGINT</code>,
+or by pressing <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal <code>'end'</code> on the input
+stream. The listener
 callback is invoked without any arguments.</p>
-<pre><code class="language-js">replServer.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Received "exit" event from repl!'</span>);
-  process.exit();
+<pre><code class="language-js">replServer.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Received "exit" event from repl!'</span>);
+  process.<span class="hljs-title function_">exit</span>();
 });</code></pre>
-<h3>Event: <code>'reset'</code><span><a class="mark" href="#repl_event_reset" id="repl_event_reset">#</a></span></h3>
+<h4>Event: <code>'reset'</code><span><a class="mark" href="#repl_event_reset" id="repl_event_reset">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.0</span>
 </div>
@@ -485,29 +513,29 @@ reference to the <code>context</code> object as the only argument.</p>
 state:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">initializeContext</span>(<span class="hljs-params">context</span>) </span>{
-  context.m = <span class="hljs-string">'test'</span>;
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">initializeContext</span>(<span class="hljs-params">context</span>) {
+  context.<span class="hljs-property">m</span> = <span class="hljs-string">'test'</span>;
 }
 
-<span class="hljs-keyword">const</span> r = repl.start({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span> });
-initializeContext(r.context);
+<span class="hljs-keyword">const</span> r = repl.<span class="hljs-title function_">start</span>({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span> });
+<span class="hljs-title function_">initializeContext</span>(r.<span class="hljs-property">context</span>);
 
-r.on(<span class="hljs-string">'reset'</span>, initializeContext);</code></pre>
+r.<span class="hljs-title function_">on</span>(<span class="hljs-string">'reset'</span>, initializeContext);</code></pre>
 <p>When this code is executed, the global <code>'m'</code> variable can be modified but then
 reset to its initial value using the <code>.clear</code> command:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> ./node example.js</span>
-<span class="hljs-meta">></span><span class="bash"> m</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">./node example.js</span>
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
 'test'
-<span class="hljs-meta">></span><span class="bash"> m = 1</span>
+<span class="hljs-meta">> </span><span class="language-bash">m = 1</span>
 1
-<span class="hljs-meta">></span><span class="bash"> m</span>
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
 1
-<span class="hljs-meta">></span><span class="bash"> .clear</span>
+<span class="hljs-meta">> </span><span class="language-bash">.clear</span>
 Clearing context...
-<span class="hljs-meta">></span><span class="bash"> m</span>
+<span class="hljs-meta">> </span><span class="language-bash">m</span>
 'test'
 <span class="hljs-meta">></span></code></pre>
-<h3><code>replServer.defineCommand(keyword, cmd)</code><span><a class="mark" href="#repl_replserver_definecommand_keyword_cmd" id="repl_replserver_definecommand_keyword_cmd">#</a></span></h3>
+<h4><code>replServer.defineCommand(keyword, cmd)</code><span><a class="mark" href="#repl_replserver_definecommand_keyword_cmd" id="repl_replserver_definecommand_keyword_cmd">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span>
 </div>
@@ -527,25 +555,25 @@ string argument.</li>
 <p>The following example shows two new commands added to the REPL instance:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 
-<span class="hljs-keyword">const</span> replServer = repl.start({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span> });
-replServer.defineCommand(<span class="hljs-string">'sayhello'</span>, {
+<span class="hljs-keyword">const</span> replServer = repl.<span class="hljs-title function_">start</span>({ <span class="hljs-attr">prompt</span>: <span class="hljs-string">'> '</span> });
+replServer.<span class="hljs-title function_">defineCommand</span>(<span class="hljs-string">'sayhello'</span>, {
   <span class="hljs-attr">help</span>: <span class="hljs-string">'Say hello'</span>,
-  action(name) {
-    <span class="hljs-built_in">this</span>.clearBufferedCommand();
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Hello, <span class="hljs-subst">${name}</span>!`</span>);
-    <span class="hljs-built_in">this</span>.displayPrompt();
+  <span class="hljs-title function_">action</span>(<span class="hljs-params">name</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">clearBufferedCommand</span>();
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Hello, <span class="hljs-subst">${name}</span>!`</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">displayPrompt</span>();
   }
 });
-replServer.defineCommand(<span class="hljs-string">'saybye'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">saybye</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Goodbye!'</span>);
-  <span class="hljs-built_in">this</span>.close();
+replServer.<span class="hljs-title function_">defineCommand</span>(<span class="hljs-string">'saybye'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">saybye</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Goodbye!'</span>);
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">close</span>();
 });</code></pre>
 <p>The new commands can then be used from within the REPL instance:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> .sayhello Node.js User</span>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">.sayhello Node.js User</span>
 Hello, Node.js User!
-<span class="hljs-meta">></span><span class="bash"> .saybye</span>
+<span class="hljs-meta">> </span><span class="language-bash">.saybye</span>
 Goodbye!</code></pre>
-<h3><code>replServer.displayPrompt([preserveCursor])</code><span><a class="mark" href="#repl_replserver_displayprompt_preservecursor" id="repl_replserver_displayprompt_preservecursor">#</a></span></h3>
+<h4><code>replServer.displayPrompt([preserveCursor])</code><span><a class="mark" href="#repl_replserver_displayprompt_preservecursor" id="repl_replserver_displayprompt_preservecursor">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.91</span>
 </div>
@@ -561,7 +589,7 @@ and resuming the <code>input</code> to accept new input.</p>
 <p>The <code>replServer.displayPrompt</code> method is primarily intended to be called from
 within the action function for commands registered using the
 <code>replServer.defineCommand()</code> method.</p>
-<h3><code>replServer.clearBufferedCommand()</code><span><a class="mark" href="#repl_replserver_clearbufferedcommand" id="repl_replserver_clearbufferedcommand">#</a></span></h3>
+<h4><code>replServer.clearBufferedCommand()</code><span><a class="mark" href="#repl_replserver_clearbufferedcommand" id="repl_replserver_clearbufferedcommand">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -569,7 +597,7 @@ within the action function for commands registered using the
 buffered but not yet executed. This method is primarily intended to be
 called from within the action function for commands registered using the
 <code>replServer.defineCommand()</code> method.</p>
-<h3><code>replServer.parseREPLKeyword(keyword[, rest])</code><span><a class="mark" href="#repl_replserver_parsereplkeyword_keyword_rest" id="repl_replserver_parsereplkeyword_keyword_rest">#</a></span></h3>
+<h4><code>replServer.parseREPLKeyword(keyword[, rest])</code><span><a class="mark" href="#repl_replserver_parsereplkeyword_keyword_rest" id="repl_replserver_parsereplkeyword_keyword_rest">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.8.9</span><span>Deprecated since: v9.0.0</span>
 </div>
@@ -581,7 +609,7 @@ called from within the action function for commands registered using the
 </ul>
 <p>An internal method used to parse and execute <code>REPLServer</code> keywords.
 Returns <code>true</code> if <code>keyword</code> is a valid keyword, otherwise <code>false</code>.</p>
-<h3><code>replServer.setupHistory(historyPath, callback)</code><span><a class="mark" href="#repl_replserver_setuphistory_historypath_callback" id="repl_replserver_setuphistory_historypath_callback">#</a></span></h3>
+<h4><code>replServer.setupHistory(historyPath, callback)</code><span><a class="mark" href="#repl_replserver_setuphistory_historypath_callback" id="repl_replserver_setuphistory_historypath_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
 </div>
@@ -595,16 +623,24 @@ Returns <code>true</code> if <code>keyword</code> is a valid keyword, otherwise
 </li>
 </ul>
 <p>Initializes a history log file for the REPL instance. When executing the
-Node.js binary and using the command line REPL, a history file is initialized
+Node.js binary and using the command-line REPL, a history file is initialized
 by default. However, this is not the case when creating a REPL
 programmatically. Use this method to initialize a history log file when working
 with REPL instances programmatically.</p>
-<h2><code>repl.start([options])</code><span><a class="mark" href="#repl_repl_start_options" id="repl_repl_start_options">#</a></span></h2>
+</section><section><h3><code>repl.builtinModules</code><span><a class="mark" href="#repl_repl_builtinmodules" id="repl_repl_builtinmodules">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.5.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
+</ul>
+<p>A list of the names of all Node.js modules, e.g., <code>'http'</code>.</p>
+</section><section><h3><code>repl.start([options])</code><span><a class="mark" href="#repl_repl_start_options" id="repl_repl_start_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.4.0</td>
 <td><p>The <code>preview</code> option is now available.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>The <code>terminal</code> option now follows the default description in all cases and <code>useColors</code> checks <code>hasColors()</code> if available.</p></td></tr>
@@ -649,9 +685,9 @@ sets this value to <code>true</code>. <strong>Default:</strong> <code>false</cod
 will not output the return value of a command if it evaluates to
 <code>undefined</code>. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>writer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to invoke to format the output of each
- command before writing to <code>output</code>. <strong>Default:</strong> <a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a>.</li>
+command before writing to <code>output</code>. <strong>Default:</strong> <a href="util.html#util_util_inspect_object_options"><code>util.inspect()</code></a>.</li>
 <li><code>completer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> An optional function used for custom Tab auto
- completion. See <a href="readline.html#readline_use_of_the_completer_function"><code>readline.InterfaceCompleter</code></a> for an example.</li>
+completion. See <a href="readline.html#readline_use_of_the_completer_function"><code>readline.InterfaceCompleter</code></a> for an example.</li>
 <li><code>replMode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Symbol_type" class="type">&#x3C;symbol></a> A flag that specifies whether the default evaluator
 executes all JavaScript commands in strict mode or default (sloppy) mode.
 Acceptable values are:
@@ -662,7 +698,8 @@ equivalent to prefacing every repl statement with <code>'use strict'</code>.</li
 </ul>
 </li>
 <li><code>breakEvalOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Stop evaluating the current piece of code when
-<code>SIGINT</code> is received, such as when <code>Ctrl+C</code> is pressed. This cannot be used
+<code>SIGINT</code> is received, such as when <kbd>Ctrl</kbd>+<kbd>C</kbd> is pressed.
+This cannot be used
 together with a custom <code>eval</code> function. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>preview</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Defines if the repl prints autocomplete and output
 previews or not. <strong>Default:</strong> <code>true</code> with the default eval function and
@@ -677,23 +714,23 @@ there are no previews and the value of <code>preview</code> has no effect.</li>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 
 <span class="hljs-comment">// a Unix style prompt</span>
-repl.start(<span class="hljs-string">'$ '</span>);</code></pre>
-<h2>The Node.js REPL<span><a class="mark" href="#repl_the_node_js_repl" id="repl_the_node_js_repl">#</a></span></h2>
+repl.<span class="hljs-title function_">start</span>(<span class="hljs-string">'$ '</span>);</code></pre>
+</section><section><h3>The Node.js REPL<span><a class="mark" href="#repl_the_node_js_repl" id="repl_the_node_js_repl">#</a></span></h3>
 <p>Node.js itself uses the <code>repl</code> module to provide its own interactive interface
 for executing JavaScript. This can be used by executing the Node.js binary
 without passing any arguments (or by passing the <code>-i</code> argument):</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> const a = [1, 2, 3];</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">const a = [1, 2, 3];</span>
 undefined
-<span class="hljs-meta">></span><span class="bash"> a</span>
+<span class="hljs-meta">> </span><span class="language-bash">a</span>
 [ 1, 2, 3 ]
-<span class="hljs-meta">></span><span class="bash"> a.forEach((v) => {</span>
+<span class="hljs-meta">> </span><span class="language-bash">a.forEach((v) => {</span>
 ...   console.log(v);
 ...   });
 1
 2
 3</code></pre>
-<h3>Environment variable options<span><a class="mark" href="#repl_environment_variable_options" id="repl_environment_variable_options">#</a></span></h3>
+<h4>Environment variable options<span><a class="mark" href="#repl_environment_variable_options" id="repl_environment_variable_options">#</a></span></h4>
 <p>Various behaviors of the Node.js REPL can be customized using the following
 environment variables:</p>
 <ul>
@@ -709,18 +746,18 @@ persisted if history is available. Must be a positive number.
 <li><code>NODE_REPL_MODE</code>: May be either <code>'sloppy'</code> or <code>'strict'</code>. <strong>Default:</strong>
 <code>'sloppy'</code>, which will allow non-strict mode code to be run.</li>
 </ul>
-<h3>Persistent history<span><a class="mark" href="#repl_persistent_history" id="repl_persistent_history">#</a></span></h3>
+<h4>Persistent history<span><a class="mark" href="#repl_persistent_history" id="repl_persistent_history">#</a></span></h4>
 <p>By default, the Node.js REPL will persist history between <code>node</code> REPL sessions
 by saving inputs to a <code>.node_repl_history</code> file located in the user's home
 directory. This can be disabled by setting the environment variable
 <code>NODE_REPL_HISTORY=''</code>.</p>
-<h3>Using the Node.js REPL with advanced line-editors<span><a class="mark" href="#repl_using_the_node_js_repl_with_advanced_line_editors" id="repl_using_the_node_js_repl_with_advanced_line_editors">#</a></span></h3>
+<h4>Using the Node.js REPL with advanced line-editors<span><a class="mark" href="#repl_using_the_node_js_repl_with_advanced_line_editors" id="repl_using_the_node_js_repl_with_advanced_line_editors">#</a></span></h4>
 <p>For advanced line-editors, start Node.js with the environment variable
 <code>NODE_NO_READLINE=1</code>. This will start the main and debugger REPL in canonical
 terminal settings, which will allow use with <code>rlwrap</code>.</p>
 <p>For example, the following can be added to a <code>.bashrc</code> file:</p>
 <pre><code class="language-text">alias node="env NODE_NO_READLINE=1 rlwrap node"</code></pre>
-<h3>Starting multiple REPL instances against a single running instance<span><a class="mark" href="#repl_starting_multiple_repl_instances_against_a_single_running_instance" id="repl_starting_multiple_repl_instances_against_a_single_running_instance">#</a></span></h3>
+<h4>Starting multiple REPL instances against a single running instance<span><a class="mark" href="#repl_starting_multiple_repl_instances_against_a_single_running_instance" id="repl_starting_multiple_repl_instances_against_a_single_running_instance">#</a></span></h4>
 <p>It is possible to create and run multiple REPL instances against a single
 running instance of Node.js that share a single <code>global</code> object but have
 separate I/O interfaces.</p>
@@ -730,33 +767,33 @@ socket, and a TCP socket:</p>
 <span class="hljs-keyword">const</span> repl = <span class="hljs-built_in">require</span>(<span class="hljs-string">'repl'</span>);
 <span class="hljs-keyword">let</span> connections = <span class="hljs-number">0</span>;
 
-repl.start({
+repl.<span class="hljs-title function_">start</span>({
   <span class="hljs-attr">prompt</span>: <span class="hljs-string">'Node.js via stdin> '</span>,
-  <span class="hljs-attr">input</span>: process.stdin,
-  <span class="hljs-attr">output</span>: process.stdout
+  <span class="hljs-attr">input</span>: process.<span class="hljs-property">stdin</span>,
+  <span class="hljs-attr">output</span>: process.<span class="hljs-property">stdout</span>
 });
 
-net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
   connections += <span class="hljs-number">1</span>;
-  repl.start({
+  repl.<span class="hljs-title function_">start</span>({
     <span class="hljs-attr">prompt</span>: <span class="hljs-string">'Node.js via Unix socket> '</span>,
     <span class="hljs-attr">input</span>: socket,
     <span class="hljs-attr">output</span>: socket
-  }).on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-    socket.end();
+  }).<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+    socket.<span class="hljs-title function_">end</span>();
   });
-}).listen(<span class="hljs-string">'/tmp/node-repl-sock'</span>);
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-string">'/tmp/node-repl-sock'</span>);
 
-net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
   connections += <span class="hljs-number">1</span>;
-  repl.start({
+  repl.<span class="hljs-title function_">start</span>({
     <span class="hljs-attr">prompt</span>: <span class="hljs-string">'Node.js via TCP socket> '</span>,
     <span class="hljs-attr">input</span>: socket,
     <span class="hljs-attr">output</span>: socket
-  }).on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-    socket.end();
+  }).<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+    socket.<span class="hljs-title function_">end</span>();
   });
-}).listen(<span class="hljs-number">5001</span>);</code></pre>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">5001</span>);</code></pre>
 <p>Running this application from the command line will start a REPL on stdin.
 Other REPL clients may connect through the Unix socket or TCP socket. <code>telnet</code>,
 for instance, is useful for connecting to TCP sockets, while <code>socat</code> can be used
@@ -767,10 +804,46 @@ possible to connect to a long-running Node.js process without restarting it.</p>
 a <code>net.Server</code> and <code>net.Socket</code> instance, see:
 <a href="https://gist.github.com/TooTallNate/2209310">https://gist.github.com/TooTallNate/2209310</a>.</p>
 <p>For an example of running a REPL instance over <a href="https://curl.haxx.se/docs/manpage.html"><code>curl(1)</code></a>, see:
-<a href="https://gist.github.com/TooTallNate/2053342">https://gist.github.com/TooTallNate/2053342</a>.</p>
+<a href="https://gist.github.com/TooTallNate/2053342">https://gist.github.com/TooTallNate/2053342</a>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/repl.json b/doc/api/repl.json
index 9eff9448adbea947ea5c43fa356aac990b6209e3..1dda9f31ca7f321bf8f5eefef0a252a330d297ad 100644
--- a/doc/api/repl.json
+++ b/doc/api/repl.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/repl.js\">lib/repl.js</a></p>\n<p>The <code>repl</code> module provides a Read-Eval-Print-Loop (REPL) implementation that\nis available both as a standalone program or includible in other applications.\nIt can be accessed using:</p>\n<pre><code class=\"language-js\">const repl = require('repl');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/repl.js\">lib/repl.js</a></p>\n<p>The <code>repl</code> module provides a Read-Eval-Print-Loop (REPL) implementation that\nis available both as a standalone program or includible in other applications.\nIt can be accessed using:</p>\n<pre><code class=\"language-js\">const repl = require('repl');\n</code></pre>",
       "modules": [
         {
           "textRaw": "Design and features",
@@ -18,7 +18,7 @@
             {
               "textRaw": "Commands and special keys",
               "name": "commands_and_special_keys",
-              "desc": "<p>The following special commands are supported by all REPL instances:</p>\n<ul>\n<li><code>.break</code>: When in the process of inputting a multi-line expression, entering\nthe <code>.break</code> command (or pressing the <code>&#x3C;ctrl>-C</code> key combination) will abort\nfurther input or processing of that expression.</li>\n<li><code>.clear</code>: Resets the REPL <code>context</code> to an empty object and clears any\nmulti-line expression being input.</li>\n<li><code>.exit</code>: Close the I/O stream, causing the REPL to exit.</li>\n<li><code>.help</code>: Show this list of special commands.</li>\n<li><code>.save</code>: Save the current REPL session to a file:\n<code>> .save ./file/to/save.js</code></li>\n<li><code>.load</code>: Load a file into the current REPL session.\n<code>> .load ./file/to/load.js</code></li>\n<li><code>.editor</code>: Enter editor mode (<code>&#x3C;ctrl>-D</code> to finish, <code>&#x3C;ctrl>-C</code> to cancel).</li>\n</ul>\n<pre><code class=\"language-console\">> .editor\n// Entering editor mode (^D to finish, ^C to cancel)\nfunction welcome(name) {\n  return `Hello ${name}!`;\n}\n\nwelcome('Node.js User');\n\n// ^D\n'Hello Node.js User!'\n>\n</code></pre>\n<p>The following key combinations in the REPL have these special effects:</p>\n<ul>\n<li><code>&#x3C;ctrl>-C</code>: When pressed once, has the same effect as the <code>.break</code> command.\nWhen pressed twice on a blank line, has the same effect as the <code>.exit</code>\ncommand.</li>\n<li><code>&#x3C;ctrl>-D</code>: Has the same effect as the <code>.exit</code> command.</li>\n<li><code>&#x3C;tab></code>: When pressed on a blank line, displays global and local (scope)\nvariables. When pressed while entering other input, displays relevant\nautocompletion options.</li>\n</ul>\n<p>For key bindings related to the reverse-i-search, see <a href=\"#repl_reverse_i_search\"><code>reverse-i-search</code></a>.\nFor all other key bindings, see <a href=\"readline.html#readline_tty_keybindings\">TTY keybindings</a>.</p>",
+              "desc": "<p>The following special commands are supported by all REPL instances:</p>\n<ul>\n<li><code>.break</code>: When in the process of inputting a multi-line expression, enter\nthe <code>.break</code> command (or press <kbd>Ctrl</kbd>+<kbd>C</kbd>) to abort\nfurther input or processing of that expression.</li>\n<li><code>.clear</code>: Resets the REPL <code>context</code> to an empty object and clears any\nmulti-line expression being input.</li>\n<li><code>.exit</code>: Close the I/O stream, causing the REPL to exit.</li>\n<li><code>.help</code>: Show this list of special commands.</li>\n<li><code>.save</code>: Save the current REPL session to a file:\n<code>> .save ./file/to/save.js</code></li>\n<li><code>.load</code>: Load a file into the current REPL session.\n<code>> .load ./file/to/load.js</code></li>\n<li><code>.editor</code>: Enter editor mode (<kbd>Ctrl</kbd>+<kbd>D</kbd> to finish,\n<kbd>Ctrl</kbd>+<kbd>C</kbd> to cancel).</li>\n</ul>\n<pre><code class=\"language-console\">> .editor\n// Entering editor mode (^D to finish, ^C to cancel)\nfunction welcome(name) {\n  return `Hello ${name}!`;\n}\n\nwelcome('Node.js User');\n\n// ^D\n'Hello Node.js User!'\n>\n</code></pre>\n<p>The following key combinations in the REPL have these special effects:</p>\n<ul>\n<li><kbd>Ctrl</kbd>+<kbd>C</kbd>: When pressed once, has the same effect as the\n<code>.break</code> command.\nWhen pressed twice on a blank line, has the same effect as the <code>.exit</code>\ncommand.</li>\n<li><kbd>Ctrl</kbd>+<kbd>D</kbd>: Has the same effect as the <code>.exit</code> command.</li>\n<li><kbd>Tab</kbd>: When pressed on a blank line, displays global and local (scope)\nvariables. When pressed while entering other input, displays relevant\nautocompletion options.</li>\n</ul>\n<p>For key bindings related to the reverse-i-search, see <a href=\"#repl_reverse_i_search\"><code>reverse-i-search</code></a>.\nFor all other key bindings, see <a href=\"readline.html#readline_tty_keybindings\">TTY keybindings</a>.</p>",
               "type": "module",
               "displayName": "Commands and special keys"
             },
@@ -60,7 +60,7 @@
                       }
                     ]
                   },
-                  "desc": "<p>The REPL uses the <a href=\"domain.html\"><code>domain</code></a> module to catch all uncaught exceptions for that\nREPL session.</p>\n<p>This use of the <a href=\"domain.html\"><code>domain</code></a> module in the REPL has these side effects:</p>\n<ul>\n<li>Uncaught exceptions only emit the <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event in the\nstandalone REPL. Adding a listener for this event in a REPL within\nanother Node.js program throws <a href=\"errors.html#errors_err_invalid_repl_input\"><code>ERR_INVALID_REPL_INPUT</code></a>.</li>\n<li>Trying to use <a href=\"process.html#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a> throws\nan <a href=\"errors.html#errors_err_domain_cannot_set_uncaught_exception_capture\"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a> error.</li>\n</ul>\n<p>As standalone program:</p>\n<pre><code class=\"language-js\">process.on('uncaughtException', () => console.log('Uncaught'));\n\nthrow new Error('foobar');\n// Uncaught\n</code></pre>\n<p>When used in another application:</p>\n<pre><code class=\"language-js\">process.on('uncaughtException', () => console.log('Uncaught'));\n// TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`\n// cannot be used in the REPL\n\nthrow new Error('foobar');\n// Thrown:\n// Error: foobar\n</code></pre>",
+                  "desc": "<p>The REPL uses the <a href=\"domain.html\"><code>domain</code></a> module to catch all uncaught exceptions for that\nREPL session.</p>\n<p>This use of the <a href=\"domain.html\"><code>domain</code></a> module in the REPL has these side effects:</p>\n<ul>\n<li>\n<p>Uncaught exceptions only emit the <a href=\"process.html#process_event_uncaughtexception\"><code>'uncaughtException'</code></a> event in the\nstandalone REPL. Adding a listener for this event in a REPL within\nanother Node.js program results in <a href=\"errors.html#errors_err_invalid_repl_input\"><code>ERR_INVALID_REPL_INPUT</code></a>.</p>\n<pre><code class=\"language-js\">const r = repl.start();\n\nr.write('process.on(\"uncaughtException\", () => console.log(\"Foobar\"));\\n');\n// Output stream includes:\n//   TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`\n//   cannot be used in the REPL\n\nr.close();\n</code></pre>\n</li>\n<li>\n<p>Trying to use <a href=\"process.html#process_process_setuncaughtexceptioncapturecallback_fn\"><code>process.setUncaughtExceptionCaptureCallback()</code></a> throws\nan <a href=\"errors.html#errors_err_domain_cannot_set_uncaught_exception_capture\"><code>ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE</code></a> error.</p>\n</li>\n</ul>",
                   "type": "module",
                   "displayName": "Global uncaught exceptions"
                 },
@@ -83,7 +83,7 @@
                 {
                   "textRaw": "`await` keyword",
                   "name": "`await`_keyword",
-                  "desc": "<p>With the <a href=\"cli.html#cli_experimental_repl_await\"><code>--experimental-repl-await</code></a> command line option specified,\nexperimental support for the <code>await</code> keyword is enabled.</p>\n<pre><code class=\"language-console\">> await Promise.resolve(123)\n123\n> await Promise.reject(new Error('REPL await'))\nError: REPL await\n    at repl:1:45\n> const timeout = util.promisify(setTimeout);\nundefined\n> const old = Date.now(); await timeout(1000); console.log(Date.now() - old);\n1002\nundefined\n</code></pre>",
+                  "desc": "<p>With the <a href=\"cli.html#cli_experimental_repl_await\"><code>--experimental-repl-await</code></a> command-line option specified,\nexperimental support for the <code>await</code> keyword is enabled.</p>\n<pre><code class=\"language-console\">> await Promise.resolve(123)\n123\n> await Promise.reject(new Error('REPL await'))\nError: REPL await\n    at repl:1:45\n> const timeout = util.promisify(setTimeout);\nundefined\n> const old = Date.now(); await timeout(1000); console.log(Date.now() - old);\n1002\nundefined\n</code></pre>\n<p>One known limitation of using the <code>await</code> keyword in the REPL is that\nit will invalidate the lexical scoping of the <code>const</code> and <code>let</code>\nkeywords.</p>\n<p>For example:</p>\n<pre><code class=\"language-console\">> const m = await Promise.resolve(123)\nundefined\n> m\n123\n> const m = await Promise.resolve(234)\nundefined\n> m\n234\n</code></pre>",
                   "type": "module",
                   "displayName": "`await` keyword"
                 }
@@ -96,11 +96,11 @@
               "name": "reverse-i-search",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.6.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>The REPL supports bi-directional reverse-i-search similar to <a href=\"https://en.wikipedia.org/wiki/Z_shell\">ZSH</a>. It is\ntriggered with <code>&#x3C;ctrl> + R</code> to search backward and <code>&#x3C;ctrl> + S</code> to search\nforward.</p>\n<p>Duplicated history entires will be skipped.</p>\n<p>Entries are accepted as soon as any button is pressed that doesn't correspond\nwith the reverse search. Cancelling is possible by pressing <code>escape</code> or\n<code>&#x3C;ctrl> + C</code>.</p>\n<p>Changing the direction immediately searches for the next entry in the expected\ndirection from the current position on.</p>",
+              "desc": "<p>The REPL supports bi-directional reverse-i-search similar to <a href=\"https://en.wikipedia.org/wiki/Z_shell\">ZSH</a>. It is\ntriggered with <kbd>Ctrl</kbd>+<kbd>R</kbd> to search backward and\n<kbd>Ctrl</kbd>+<kbd>S</kbd> to search\nforwards.</p>\n<p>Duplicated history entries will be skipped.</p>\n<p>Entries are accepted as soon as any key is pressed that doesn't correspond\nwith the reverse search. Cancelling is possible by pressing <kbd>Esc</kbd> or\n<kbd>Ctrl</kbd>+<kbd>C</kbd>.</p>\n<p>Changing the direction immediately searches for the next entry in the expected\ndirection from the current position on.</p>",
               "type": "module",
               "displayName": "Reverse-i-search"
             },
@@ -112,7 +112,7 @@
                 {
                   "textRaw": "Recoverable errors",
                   "name": "recoverable_errors",
-                  "desc": "<p>As a user is typing input into the REPL prompt, pressing the <code>&#x3C;enter></code> key will\nsend the current line of input to the <code>eval</code> function. In order to support\nmulti-line input, the eval function can return an instance of <code>repl.Recoverable</code>\nto the provided callback function:</p>\n<pre><code class=\"language-js\">function myEval(cmd, context, filename, callback) {\n  let result;\n  try {\n    result = vm.runInThisContext(cmd);\n  } catch (e) {\n    if (isRecoverableError(e)) {\n      return callback(new repl.Recoverable(e));\n    }\n  }\n  callback(null, result);\n}\n\nfunction isRecoverableError(error) {\n  if (error.name === 'SyntaxError') {\n    return /^(Unexpected end of input|Unexpected token)/.test(error.message);\n  }\n  return false;\n}\n</code></pre>",
+                  "desc": "<p>At the REPL prompt, pressing <kbd>Enter</kbd> sends the current line of input to\nthe <code>eval</code> function. In order to support multi-line input, the <code>eval</code> function\ncan return an instance of <code>repl.Recoverable</code> to the provided callback function:</p>\n<pre><code class=\"language-js\">function myEval(cmd, context, filename, callback) {\n  let result;\n  try {\n    result = vm.runInThisContext(cmd);\n  } catch (e) {\n    if (isRecoverableError(e)) {\n      return callback(new repl.Recoverable(e));\n    }\n  }\n  callback(null, result);\n}\n\nfunction isRecoverableError(error) {\n  if (error.name === 'SyntaxError') {\n    return /^(Unexpected end of input|Unexpected token)/.test(error.message);\n  }\n  return false;\n}\n</code></pre>",
                   "type": "module",
                   "displayName": "Recoverable errors"
                 }
@@ -193,7 +193,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'exit'</code> event is emitted when the REPL is exited either by receiving the\n<code>.exit</code> command as input, the user pressing <code>&#x3C;ctrl>-C</code> twice to signal <code>SIGINT</code>,\nor by pressing <code>&#x3C;ctrl>-D</code> to signal <code>'end'</code> on the input stream. The listener\ncallback is invoked without any arguments.</p>\n<pre><code class=\"language-js\">replServer.on('exit', () => {\n  console.log('Received \"exit\" event from repl!');\n  process.exit();\n});\n</code></pre>"
+              "desc": "<p>The <code>'exit'</code> event is emitted when the REPL is exited either by receiving the\n<code>.exit</code> command as input, the user pressing <kbd>Ctrl</kbd>+<kbd>C</kbd> twice\nto signal <code>SIGINT</code>,\nor by pressing <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal <code>'end'</code> on the input\nstream. The listener\ncallback is invoked without any arguments.</p>\n<pre><code class=\"language-js\">replServer.on('exit', () => {\n  console.log('Received \"exit\" event from repl!');\n  process.exit();\n});\n</code></pre>"
             },
             {
               "textRaw": "Event: `'reset'`",
@@ -360,11 +360,25 @@
                   ]
                 }
               ],
-              "desc": "<p>Initializes a history log file for the REPL instance. When executing the\nNode.js binary and using the command line REPL, a history file is initialized\nby default. However, this is not the case when creating a REPL\nprogrammatically. Use this method to initialize a history log file when working\nwith REPL instances programmatically.</p>"
+              "desc": "<p>Initializes a history log file for the REPL instance. When executing the\nNode.js binary and using the command-line REPL, a history file is initialized\nby default. However, this is not the case when creating a REPL\nprogrammatically. Use this method to initialize a history log file when working\nwith REPL instances programmatically.</p>"
             }
           ]
         }
       ],
+      "properties": [
+        {
+          "textRaw": "`builtinModules` {string[]}",
+          "type": "string[]",
+          "name": "builtinModules",
+          "meta": {
+            "added": [
+              "v14.5.0"
+            ],
+            "changes": []
+          },
+          "desc": "<p>A list of the names of all Node.js modules, e.g., <code>'http'</code>.</p>"
+        }
+      ],
       "methods": [
         {
           "textRaw": "`repl.start([options])`",
@@ -376,7 +390,7 @@
             ],
             "changes": [
               {
-                "version": "v12.17.0",
+                "version": "v13.4.0",
                 "pr-url": "https://github.com/nodejs/node/pull/30811",
                 "description": "The `preview` option is now available."
               },
@@ -503,11 +517,11 @@
                       ]
                     },
                     {
-                      "textRaw": "`breakEvalOnSigint` {boolean} Stop evaluating the current piece of code when `SIGINT` is received, such as when `Ctrl+C` is pressed. This cannot be used together with a custom `eval` function. **Default:** `false`.",
+                      "textRaw": "`breakEvalOnSigint` {boolean} Stop evaluating the current piece of code when `SIGINT` is received, such as when <kbd>Ctrl</kbd>+<kbd>C</kbd> is pressed. This cannot be used together with a custom `eval` function. **Default:** `false`.",
                       "name": "breakEvalOnSigint",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "Stop evaluating the current piece of code when `SIGINT` is received, such as when `Ctrl+C` is pressed. This cannot be used together with a custom `eval` function."
+                      "desc": "Stop evaluating the current piece of code when `SIGINT` is received, such as when <kbd>Ctrl</kbd>+<kbd>C</kbd> is pressed. This cannot be used together with a custom `eval` function."
                     },
                     {
                       "textRaw": "`preview` {boolean} Defines if the repl prints autocomplete and output previews or not. **Default:** `true` with the default eval function and `false` in case a custom eval function is used. If `terminal` is falsy, then there are no previews and the value of `preview` has no effect.",
diff --git a/doc/api/repl.md b/doc/api/repl.md
index 3ab7cefec280d2e87a50d1eff8aa017cdb7a0079..bc2d74edde15731a1ebed33210efe741a2bb9a6a 100644
--- a/doc/api/repl.md
+++ b/doc/api/repl.md
@@ -34,8 +34,8 @@ feature set.
 
 The following special commands are supported by all REPL instances:
 
-* `.break`: When in the process of inputting a multi-line expression, entering
-  the `.break` command (or pressing the `<ctrl>-C` key combination) will abort
+* `.break`: When in the process of inputting a multi-line expression, enter
+  the `.break` command (or press <kbd>Ctrl</kbd>+<kbd>C</kbd>) to abort
   further input or processing of that expression.
 * `.clear`: Resets the REPL `context` to an empty object and clears any
   multi-line expression being input.
@@ -45,7 +45,8 @@ The following special commands are supported by all REPL instances:
   `> .save ./file/to/save.js`
 * `.load`: Load a file into the current REPL session.
   `> .load ./file/to/load.js`
-* `.editor`: Enter editor mode (`<ctrl>-D` to finish, `<ctrl>-C` to cancel).
+* `.editor`: Enter editor mode (<kbd>Ctrl</kbd>+<kbd>D</kbd> to finish,
+  <kbd>Ctrl</kbd>+<kbd>C</kbd> to cancel).
 
 ```console
 > .editor
@@ -63,11 +64,12 @@ welcome('Node.js User');
 
 The following key combinations in the REPL have these special effects:
 
-* `<ctrl>-C`: When pressed once, has the same effect as the `.break` command.
+* <kbd>Ctrl</kbd>+<kbd>C</kbd>: When pressed once, has the same effect as the
+  `.break` command.
   When pressed twice on a blank line, has the same effect as the `.exit`
   command.
-* `<ctrl>-D`: Has the same effect as the `.exit` command.
-* `<tab>`: When pressed on a blank line, displays global and local (scope)
+* <kbd>Ctrl</kbd>+<kbd>D</kbd>: Has the same effect as the `.exit` command.
+* <kbd>Tab</kbd>: When pressed on a blank line, displays global and local (scope)
   variables. When pressed while entering other input, displays relevant
   autocompletion options.
 
@@ -161,30 +163,21 @@ This use of the [`domain`][] module in the REPL has these side effects:
 
 * Uncaught exceptions only emit the [`'uncaughtException'`][] event in the
   standalone REPL. Adding a listener for this event in a REPL within
-  another Node.js program throws [`ERR_INVALID_REPL_INPUT`][].
-* Trying to use [`process.setUncaughtExceptionCaptureCallback()`][] throws
-  an [`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`][] error.
+  another Node.js program results in [`ERR_INVALID_REPL_INPUT`][].
 
-As standalone program:
+  ```js
+  const r = repl.start();
 
-```js
-process.on('uncaughtException', () => console.log('Uncaught'));
+  r.write('process.on("uncaughtException", () => console.log("Foobar"));\n');
+  // Output stream includes:
+  //   TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`
+  //   cannot be used in the REPL
 
-throw new Error('foobar');
-// Uncaught
-```
-
-When used in another application:
-
-```js
-process.on('uncaughtException', () => console.log('Uncaught'));
-// TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`
-// cannot be used in the REPL
+  r.close();
+  ```
 
-throw new Error('foobar');
-// Thrown:
-// Error: foobar
-```
+* Trying to use [`process.setUncaughtExceptionCaptureCallback()`][] throws
+  an [`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`][] error.
 
 #### Assignment of the `_` (underscore) variable
 <!-- YAML
@@ -224,7 +217,7 @@ Error: foo
 
 #### `await` keyword
 
-With the [`--experimental-repl-await`][] command line option specified,
+With the [`--experimental-repl-await`][] command-line option specified,
 experimental support for the `await` keyword is enabled.
 
 ```console
@@ -240,20 +233,38 @@ undefined
 undefined
 ```
 
+One known limitation of using the `await` keyword in the REPL is that
+it will invalidate the lexical scoping of the `const` and `let`
+keywords.
+
+For example:
+
+```console
+> const m = await Promise.resolve(123)
+undefined
+> m
+123
+> const m = await Promise.resolve(234)
+undefined
+> m
+234
+```
+
 ### Reverse-i-search
 <!-- YAML
-added: v12.17.0
+added: v13.6.0
 -->
 
 The REPL supports bi-directional reverse-i-search similar to [ZSH][]. It is
-triggered with `<ctrl> + R` to search backward and `<ctrl> + S` to search
-forward.
+triggered with <kbd>Ctrl</kbd>+<kbd>R</kbd> to search backward and
+<kbd>Ctrl</kbd>+<kbd>S</kbd> to search
+forwards.
 
-Duplicated history entires will be skipped.
+Duplicated history entries will be skipped.
 
-Entries are accepted as soon as any button is pressed that doesn't correspond
-with the reverse search. Cancelling is possible by pressing `escape` or
-`<ctrl> + C`.
+Entries are accepted as soon as any key is pressed that doesn't correspond
+with the reverse search. Cancelling is possible by pressing <kbd>Esc</kbd> or
+<kbd>Ctrl</kbd>+<kbd>C</kbd>.
 
 Changing the direction immediately searches for the next entry in the expected
 direction from the current position on.
@@ -282,10 +293,9 @@ repl.start({ prompt: '> ', eval: myEval });
 
 #### Recoverable errors
 
-As a user is typing input into the REPL prompt, pressing the `<enter>` key will
-send the current line of input to the `eval` function. In order to support
-multi-line input, the eval function can return an instance of `repl.Recoverable`
-to the provided callback function:
+At the REPL prompt, pressing <kbd>Enter</kbd> sends the current line of input to
+the `eval` function. In order to support multi-line input, the `eval` function
+can return an instance of `repl.Recoverable` to the provided callback function:
 
 ```js
 function myEval(cmd, context, filename, callback) {
@@ -379,8 +389,10 @@ added: v0.7.7
 -->
 
 The `'exit'` event is emitted when the REPL is exited either by receiving the
-`.exit` command as input, the user pressing `<ctrl>-C` twice to signal `SIGINT`,
-or by pressing `<ctrl>-D` to signal `'end'` on the input stream. The listener
+`.exit` command as input, the user pressing <kbd>Ctrl</kbd>+<kbd>C</kbd> twice
+to signal `SIGINT`,
+or by pressing <kbd>Ctrl</kbd>+<kbd>D</kbd> to signal `'end'` on the input
+stream. The listener
 callback is invoked without any arguments.
 
 ```js
@@ -537,16 +549,25 @@ added: v11.10.0
   * `repl` {repl.REPLServer}
 
 Initializes a history log file for the REPL instance. When executing the
-Node.js binary and using the command line REPL, a history file is initialized
+Node.js binary and using the command-line REPL, a history file is initialized
 by default. However, this is not the case when creating a REPL
 programmatically. Use this method to initialize a history log file when working
 with REPL instances programmatically.
 
+## `repl.builtinModules`
+<!-- YAML
+added: v14.5.0
+-->
+
+* {string[]}
+
+A list of the names of all Node.js modules, e.g., `'http'`.
+
 ## `repl.start([options])`
 <!-- YAML
 added: v0.1.91
 changes:
-  - version: v12.17.0
+  - version: v13.4.0
     pr-url: https://github.com/nodejs/node/pull/30811
     description: The `preview` option is now available.
   - version: v12.0.0
@@ -602,7 +623,8 @@ changes:
     * `repl.REPL_MODE_STRICT` to evaluate expressions in strict mode. This is
       equivalent to prefacing every repl statement with `'use strict'`.
   * `breakEvalOnSigint` {boolean} Stop evaluating the current piece of code when
-    `SIGINT` is received, such as when `Ctrl+C` is pressed. This cannot be used
+    `SIGINT` is received, such as when <kbd>Ctrl</kbd>+<kbd>C</kbd> is pressed.
+    This cannot be used
     together with a custom `eval` function. **Default:** `false`.
   * `preview` {boolean} Defines if the repl prints autocomplete and output
     previews or not. **Default:** `true` with the default eval function and
@@ -735,18 +757,18 @@ a `net.Server` and `net.Socket` instance, see:
 For an example of running a REPL instance over [`curl(1)`][], see:
 <https://gist.github.com/TooTallNate/2053342>.
 
-[TTY keybindings]: readline.html#readline_tty_keybindings
+[TTY keybindings]: readline.md#readline_tty_keybindings
 [ZSH]: https://en.wikipedia.org/wiki/Z_shell
-[`'uncaughtException'`]: process.html#process_event_uncaughtexception
-[`--experimental-repl-await`]: cli.html#cli_experimental_repl_await
-[`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`]: errors.html#errors_err_domain_cannot_set_uncaught_exception_capture
-[`ERR_INVALID_REPL_INPUT`]: errors.html#errors_err_invalid_repl_input
+[`'uncaughtException'`]: process.md#process_event_uncaughtexception
+[`--experimental-repl-await`]: cli.md#cli_experimental_repl_await
+[`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`]: errors.md#errors_err_domain_cannot_set_uncaught_exception_capture
+[`ERR_INVALID_REPL_INPUT`]: errors.md#errors_err_invalid_repl_input
 [`curl(1)`]: https://curl.haxx.se/docs/manpage.html
-[`domain`]: domain.html
-[`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
-[`readline.InterfaceCompleter`]: readline.html#readline_use_of_the_completer_function
+[`domain`]: domain.md
+[`process.setUncaughtExceptionCaptureCallback()`]: process.md#process_process_setuncaughtexceptioncapturecallback_fn
+[`readline.InterfaceCompleter`]: readline.md#readline_use_of_the_completer_function
 [`repl.ReplServer`]: #repl_class_replserver
 [`repl.start()`]: #repl_repl_start_options
 [`reverse-i-search`]: #repl_reverse_i_search
-[`util.inspect()`]: util.html#util_util_inspect_object_options
-[stream]: stream.html
+[`util.inspect()`]: util.md#util_util_inspect_object_options
+[stream]: stream.md
diff --git a/doc/api/report.html b/doc/api/report.html
index 164150bfb08a155dc3b9c9f512bca1a27a2ae0c7..bcfa72b8700ef8110ad00573405414cab786603b 100644
--- a/doc/api/report.html
+++ b/doc/api/report.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Diagnostic report | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Diagnostic report | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="report" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/report.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/report.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/report.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/report.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/report.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/report.html">13.x</a></li>
@@ -109,15 +124,13 @@
 <li><a href="https://nodejs.org/docs/latest-v11.x/api/report.html">11.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/report.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/report.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#report_diagnostic_report">Diagnostic report</a></span>
 <ul>
 <li><a href="#report_usage">Usage</a></li>
@@ -125,11 +138,10 @@
 <li><a href="#report_interaction_with_workers">Interaction with workers</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Diagnostic report<span><a class="mark" href="#report_diagnostic_report" id="report_diagnostic_report">#</a></span></h1>
+        <h2>Diagnostic report<span><a class="mark" href="#report_diagnostic_report" id="report_diagnostic_report">#</a></span></h2>
 
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
@@ -143,374 +155,374 @@ on unhandled exceptions, fatal errors and user signals, in addition to
 triggering programmatically through API calls.</p>
 <p>A complete example report that was generated on an uncaught exception
 is provided below for reference.</p>
-<pre><code class="language-json">{
-  <span class="hljs-attr">"header"</span>: {
-    <span class="hljs-attr">"reportVersion"</span>: <span class="hljs-number">1</span>,
-    <span class="hljs-attr">"event"</span>: <span class="hljs-string">"exception"</span>,
-    <span class="hljs-attr">"trigger"</span>: <span class="hljs-string">"Exception"</span>,
-    <span class="hljs-attr">"filename"</span>: <span class="hljs-string">"report.20181221.005011.8974.0.001.json"</span>,
-    <span class="hljs-attr">"dumpEventTime"</span>: <span class="hljs-string">"2018-12-21T00:50:11Z"</span>,
-    <span class="hljs-attr">"dumpEventTimeStamp"</span>: <span class="hljs-string">"1545371411331"</span>,
-    <span class="hljs-attr">"processId"</span>: <span class="hljs-number">8974</span>,
-    <span class="hljs-attr">"cwd"</span>: <span class="hljs-string">"/home/nodeuser/project/node"</span>,
-    <span class="hljs-attr">"commandLine"</span>: [
-      <span class="hljs-string">"/home/nodeuser/project/node/out/Release/node"</span>,
-      <span class="hljs-string">"--report-uncaught-exception"</span>,
-      <span class="hljs-string">"/home/nodeuser/project/node/test/report/test-exception.js"</span>,
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+  <span class="hljs-attr">"header"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"reportVersion"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"event"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"exception"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"trigger"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Exception"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"filename"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"report.20181221.005011.8974.0.001.json"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"dumpEventTime"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"2018-12-21T00:50:11Z"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"dumpEventTimeStamp"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1545371411331"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"processId"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">8974</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cwd"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser/project/node"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"commandLine"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+      <span class="hljs-string">"/home/nodeuser/project/node/out/Release/node"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"--report-uncaught-exception"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"/home/nodeuser/project/node/test/report/test-exception.js"</span><span class="hljs-punctuation">,</span>
       <span class="hljs-string">"child"</span>
-    ],
-    <span class="hljs-attr">"nodejsVersion"</span>: <span class="hljs-string">"v12.0.0-pre"</span>,
-    <span class="hljs-attr">"glibcVersionRuntime"</span>: <span class="hljs-string">"2.17"</span>,
-    <span class="hljs-attr">"glibcVersionCompiler"</span>: <span class="hljs-string">"2.17"</span>,
-    <span class="hljs-attr">"wordSize"</span>: <span class="hljs-string">"64 bit"</span>,
-    <span class="hljs-attr">"arch"</span>: <span class="hljs-string">"x64"</span>,
-    <span class="hljs-attr">"platform"</span>: <span class="hljs-string">"linux"</span>,
-    <span class="hljs-attr">"componentVersions"</span>: {
-      <span class="hljs-attr">"node"</span>: <span class="hljs-string">"12.0.0-pre"</span>,
-      <span class="hljs-attr">"v8"</span>: <span class="hljs-string">"7.1.302.28-node.5"</span>,
-      <span class="hljs-attr">"uv"</span>: <span class="hljs-string">"1.24.1"</span>,
-      <span class="hljs-attr">"zlib"</span>: <span class="hljs-string">"1.2.11"</span>,
-      <span class="hljs-attr">"ares"</span>: <span class="hljs-string">"1.15.0"</span>,
-      <span class="hljs-attr">"modules"</span>: <span class="hljs-string">"68"</span>,
-      <span class="hljs-attr">"nghttp2"</span>: <span class="hljs-string">"1.34.0"</span>,
-      <span class="hljs-attr">"napi"</span>: <span class="hljs-string">"3"</span>,
-      <span class="hljs-attr">"llhttp"</span>: <span class="hljs-string">"1.0.1"</span>,
-      <span class="hljs-attr">"http_parser"</span>: <span class="hljs-string">"2.8.0"</span>,
-      <span class="hljs-attr">"openssl"</span>: <span class="hljs-string">"1.1.0j"</span>
-    },
-    <span class="hljs-attr">"release"</span>: {
-      <span class="hljs-attr">"name"</span>: <span class="hljs-string">"node"</span>
-    },
-    <span class="hljs-attr">"osName"</span>: <span class="hljs-string">"Linux"</span>,
-    <span class="hljs-attr">"osRelease"</span>: <span class="hljs-string">"3.10.0-862.el7.x86_64"</span>,
-    <span class="hljs-attr">"osVersion"</span>: <span class="hljs-string">"#1 SMP Wed Mar 21 18:14:51 EDT 2018"</span>,
-    <span class="hljs-attr">"osMachine"</span>: <span class="hljs-string">"x86_64"</span>,
-    <span class="hljs-attr">"cpus"</span>: [
-      {
-        <span class="hljs-attr">"model"</span>: <span class="hljs-string">"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz"</span>,
-        <span class="hljs-attr">"speed"</span>: <span class="hljs-number">2700</span>,
-        <span class="hljs-attr">"user"</span>: <span class="hljs-number">88902660</span>,
-        <span class="hljs-attr">"nice"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"sys"</span>: <span class="hljs-number">50902570</span>,
-        <span class="hljs-attr">"idle"</span>: <span class="hljs-number">241732220</span>,
-        <span class="hljs-attr">"irq"</span>: <span class="hljs-number">0</span>
-      },
-      {
-        <span class="hljs-attr">"model"</span>: <span class="hljs-string">"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz"</span>,
-        <span class="hljs-attr">"speed"</span>: <span class="hljs-number">2700</span>,
-        <span class="hljs-attr">"user"</span>: <span class="hljs-number">88902660</span>,
-        <span class="hljs-attr">"nice"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"sys"</span>: <span class="hljs-number">50902570</span>,
-        <span class="hljs-attr">"idle"</span>: <span class="hljs-number">241732220</span>,
-        <span class="hljs-attr">"irq"</span>: <span class="hljs-number">0</span>
-      }
-    ],
-    <span class="hljs-attr">"networkInterfaces"</span>: [
-      {
-        <span class="hljs-attr">"name"</span>: <span class="hljs-string">"en0"</span>,
-        <span class="hljs-attr">"internal"</span>: <span class="hljs-literal">false</span>,
-        <span class="hljs-attr">"mac"</span>: <span class="hljs-string">"13:10:de:ad:be:ef"</span>,
-        <span class="hljs-attr">"address"</span>: <span class="hljs-string">"10.0.0.37"</span>,
-        <span class="hljs-attr">"netmask"</span>: <span class="hljs-string">"255.255.255.0"</span>,
-        <span class="hljs-attr">"family"</span>: <span class="hljs-string">"IPv4"</span>
-      }
-    ],
-    <span class="hljs-attr">"host"</span>: <span class="hljs-string">"test_machine"</span>
-  },
-  <span class="hljs-attr">"javascriptStack"</span>: {
-    <span class="hljs-attr">"message"</span>: <span class="hljs-string">"Error: *** test-exception.js: throwing uncaught Error"</span>,
-    <span class="hljs-attr">"stack"</span>: [
-      <span class="hljs-string">"at myException (/home/nodeuser/project/node/test/report/test-exception.js:9:11)"</span>,
-      <span class="hljs-string">"at Object.&#x3C;anonymous> (/home/nodeuser/project/node/test/report/test-exception.js:12:3)"</span>,
-      <span class="hljs-string">"at Module._compile (internal/modules/cjs/loader.js:718:30)"</span>,
-      <span class="hljs-string">"at Object.Module._extensions..js (internal/modules/cjs/loader.js:729:10)"</span>,
-      <span class="hljs-string">"at Module.load (internal/modules/cjs/loader.js:617:32)"</span>,
-      <span class="hljs-string">"at tryModuleLoad (internal/modules/cjs/loader.js:560:12)"</span>,
-      <span class="hljs-string">"at Function.Module._load (internal/modules/cjs/loader.js:552:3)"</span>,
-      <span class="hljs-string">"at Function.Module.runMain (internal/modules/cjs/loader.js:771:12)"</span>,
+    <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"nodejsVersion"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"v12.0.0-pre"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"glibcVersionRuntime"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"2.17"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"glibcVersionCompiler"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"2.17"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"wordSize"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"64 bit"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"arch"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"x64"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"platform"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"linux"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"componentVersions"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"node"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"12.0.0-pre"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"v8"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"7.1.302.28-node.5"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"uv"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.24.1"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"zlib"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.2.11"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"ares"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.15.0"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"modules"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"68"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"nghttp2"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.34.0"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"napi"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"3"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"llhttp"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.0.1"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"openssl"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"1.1.0j"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"release"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"node"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"osName"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Linux"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"osRelease"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"3.10.0-862.el7.x86_64"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"osVersion"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"#1 SMP Wed Mar 21 18:14:51 EDT 2018"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"osMachine"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"x86_64"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cpus"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+      <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"model"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"speed"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2700</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"user"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">88902660</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"nice"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"sys"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">50902570</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"idle"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">241732220</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"irq"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"model"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"speed"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2700</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"user"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">88902660</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"nice"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"sys"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">50902570</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"idle"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">241732220</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"irq"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"networkInterfaces"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+      <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"en0"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"internal"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"mac"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"13:10:de:ad:be:ef"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"10.0.0.37"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"netmask"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"255.255.255.0"</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"family"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"IPv4"</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"host"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"test_machine"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"javascriptStack"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"message"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"Error: *** test-exception.js: throwing uncaught Error"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"stack"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+      <span class="hljs-string">"at myException (/home/nodeuser/project/node/test/report/test-exception.js:9:11)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Object.&#x3C;anonymous> (/home/nodeuser/project/node/test/report/test-exception.js:12:3)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Module._compile (internal/modules/cjs/loader.js:718:30)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Object.Module._extensions..js (internal/modules/cjs/loader.js:729:10)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Module.load (internal/modules/cjs/loader.js:617:32)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at tryModuleLoad (internal/modules/cjs/loader.js:560:12)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Function.Module._load (internal/modules/cjs/loader.js:552:3)"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-string">"at Function.Module.runMain (internal/modules/cjs/loader.js:771:12)"</span><span class="hljs-punctuation">,</span>
       <span class="hljs-string">"at executeUserCode (internal/bootstrap/node.js:332:15)"</span>
-    ]
-  },
-  <span class="hljs-attr">"nativeStack"</span>: [
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57f07a9ef"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">"report::GetNodeReport(v8::Isolate*, node::Environment*, char const*, char const*, v8::Local&#x3C;v8::String>, std::ostream&#x26;) [./node]"</span>
-    },
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57f07cf03"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">"report::GetReport(v8::FunctionCallbackInfo&#x3C;v8::Value> const&#x26;) [./node]"</span>
-    },
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57f1bccfd"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">" [./node]"</span>
-    },
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57f1be048"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">"v8::internal::Builtin_HandleApiCall(int, v8::internal::Object**, v8::internal::Isolate*) [./node]"</span>
-    },
-    {
-      <span class="hljs-attr">"pc"</span>: <span class="hljs-string">"0x000055b57feeda0e"</span>,
-      <span class="hljs-attr">"symbol"</span>: <span class="hljs-string">" [./node]"</span>
-    }
-  ],
-  <span class="hljs-attr">"javascriptHeap"</span>: {
-    <span class="hljs-attr">"totalMemory"</span>: <span class="hljs-number">6127616</span>,
-    <span class="hljs-attr">"totalCommittedMemory"</span>: <span class="hljs-number">4357352</span>,
-    <span class="hljs-attr">"usedMemory"</span>: <span class="hljs-number">3221136</span>,
-    <span class="hljs-attr">"availableMemory"</span>: <span class="hljs-number">1521370240</span>,
-    <span class="hljs-attr">"memoryLimit"</span>: <span class="hljs-number">1526909922</span>,
-    <span class="hljs-attr">"heapSpaces"</span>: {
-      <span class="hljs-attr">"read_only_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">524288</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">39208</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">515584</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">30504</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">485080</span>
-      },
-      <span class="hljs-attr">"new_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">2097152</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">2019312</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">1031168</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">985496</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">45672</span>
-      },
-      <span class="hljs-attr">"old_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">2273280</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">1769008</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">1974640</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">1725488</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">249152</span>
-      },
-      <span class="hljs-attr">"code_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">696320</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">184896</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">152128</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">152128</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">0</span>
-      },
-      <span class="hljs-attr">"map_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">536576</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">344928</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">327520</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">327520</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">0</span>
-      },
-      <span class="hljs-attr">"large_object_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">1520590336</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">1520590336</span>
-      },
-      <span class="hljs-attr">"new_large_object_space"</span>: {
-        <span class="hljs-attr">"memorySize"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"committedMemory"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"capacity"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"used"</span>: <span class="hljs-number">0</span>,
-        <span class="hljs-attr">"available"</span>: <span class="hljs-number">0</span>
-      }
-    }
-  },
-  <span class="hljs-attr">"resourceUsage"</span>: {
-    <span class="hljs-attr">"userCpuSeconds"</span>: <span class="hljs-number">0.069595</span>,
-    <span class="hljs-attr">"kernelCpuSeconds"</span>: <span class="hljs-number">0.019163</span>,
-    <span class="hljs-attr">"cpuConsumptionPercent"</span>: <span class="hljs-number">0.000000</span>,
-    <span class="hljs-attr">"maxRss"</span>: <span class="hljs-number">18079744</span>,
-    <span class="hljs-attr">"pageFaults"</span>: {
-      <span class="hljs-attr">"IORequired"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"IONotRequired"</span>: <span class="hljs-number">4610</span>
-    },
-    <span class="hljs-attr">"fsActivity"</span>: {
-      <span class="hljs-attr">"reads"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"writes"</span>: <span class="hljs-number">0</span>
-    }
-  },
-  <span class="hljs-attr">"uvthreadResourceUsage"</span>: {
-    <span class="hljs-attr">"userCpuSeconds"</span>: <span class="hljs-number">0.068457</span>,
-    <span class="hljs-attr">"kernelCpuSeconds"</span>: <span class="hljs-number">0.019127</span>,
-    <span class="hljs-attr">"cpuConsumptionPercent"</span>: <span class="hljs-number">0.000000</span>,
-    <span class="hljs-attr">"fsActivity"</span>: {
-      <span class="hljs-attr">"reads"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"writes"</span>: <span class="hljs-number">0</span>
-    }
-  },
-  <span class="hljs-attr">"libuv"</span>: [
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"async"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x0000000102910900"</span>,
-      <span class="hljs-attr">"details"</span>: <span class="hljs-string">""</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"timer"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfeab0"</span>,
-      <span class="hljs-attr">"repeat"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"firesInMsFromNow"</span>: <span class="hljs-number">94403548320796</span>,
-      <span class="hljs-attr">"expired"</span>: <span class="hljs-literal">true</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"check"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfeb48"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"idle"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfebc0"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"prepare"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfec38"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"check"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x00007fff5fbfecb0"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"async"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000000010188f2e0"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"tty"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000055b581db0e18"</span>,
-      <span class="hljs-attr">"width"</span>: <span class="hljs-number">204</span>,
-      <span class="hljs-attr">"height"</span>: <span class="hljs-number">55</span>,
-      <span class="hljs-attr">"fd"</span>: <span class="hljs-number">17</span>,
-      <span class="hljs-attr">"writeQueueSize"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"readable"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"writable"</span>: <span class="hljs-literal">true</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"signal"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">false</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000055b581d80010"</span>,
-      <span class="hljs-attr">"signum"</span>: <span class="hljs-number">28</span>,
-      <span class="hljs-attr">"signal"</span>: <span class="hljs-string">"SIGWINCH"</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"tty"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"is_referenced"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000055b581df59f8"</span>,
-      <span class="hljs-attr">"width"</span>: <span class="hljs-number">204</span>,
-      <span class="hljs-attr">"height"</span>: <span class="hljs-number">55</span>,
-      <span class="hljs-attr">"fd"</span>: <span class="hljs-number">19</span>,
-      <span class="hljs-attr">"writeQueueSize"</span>: <span class="hljs-number">0</span>,
-      <span class="hljs-attr">"readable"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"writable"</span>: <span class="hljs-literal">true</span>
-    },
-    {
-      <span class="hljs-attr">"type"</span>: <span class="hljs-string">"loop"</span>,
-      <span class="hljs-attr">"is_active"</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">"address"</span>: <span class="hljs-string">"0x000055fc7b2cb180"</span>
-    }
-  ],
-  <span class="hljs-attr">"workers"</span>: [],
-  <span class="hljs-attr">"environmentVariables"</span>: {
-    <span class="hljs-attr">"REMOTEHOST"</span>: <span class="hljs-string">"REMOVED"</span>,
-    <span class="hljs-attr">"MANPATH"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share/man:"</span>,
-    <span class="hljs-attr">"XDG_SESSION_ID"</span>: <span class="hljs-string">"66126"</span>,
-    <span class="hljs-attr">"HOSTNAME"</span>: <span class="hljs-string">"test_machine"</span>,
-    <span class="hljs-attr">"HOST"</span>: <span class="hljs-string">"test_machine"</span>,
-    <span class="hljs-attr">"TERM"</span>: <span class="hljs-string">"xterm-256color"</span>,
-    <span class="hljs-attr">"SHELL"</span>: <span class="hljs-string">"/bin/csh"</span>,
-    <span class="hljs-attr">"SSH_CLIENT"</span>: <span class="hljs-string">"REMOVED"</span>,
-    <span class="hljs-attr">"PERL5LIB"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root//usr/lib64/perl5/vendor_perl:/opt/rh/devtoolset-3/root/usr/lib/perl5:/opt/rh/devtoolset-3/root//usr/share/perl5/vendor_perl"</span>,
-    <span class="hljs-attr">"OLDPWD"</span>: <span class="hljs-string">"/home/nodeuser/project/node/src"</span>,
-    <span class="hljs-attr">"JAVACONFDIRS"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/etc/java:/etc/java"</span>,
-    <span class="hljs-attr">"SSH_TTY"</span>: <span class="hljs-string">"/dev/pts/0"</span>,
-    <span class="hljs-attr">"PCP_DIR"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root"</span>,
-    <span class="hljs-attr">"GROUP"</span>: <span class="hljs-string">"normaluser"</span>,
-    <span class="hljs-attr">"USER"</span>: <span class="hljs-string">"nodeuser"</span>,
-    <span class="hljs-attr">"LD_LIBRARY_PATH"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/lib64:/opt/rh/devtoolset-3/root/usr/lib"</span>,
-    <span class="hljs-attr">"HOSTTYPE"</span>: <span class="hljs-string">"x86_64-linux"</span>,
-    <span class="hljs-attr">"XDG_CONFIG_DIRS"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/etc/xdg:/etc/xdg"</span>,
-    <span class="hljs-attr">"MAIL"</span>: <span class="hljs-string">"/var/spool/mail/nodeuser"</span>,
-    <span class="hljs-attr">"PATH"</span>: <span class="hljs-string">"/home/nodeuser/project/node:/opt/rh/devtoolset-3/root/usr/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin"</span>,
-    <span class="hljs-attr">"PWD"</span>: <span class="hljs-string">"/home/nodeuser/project/node"</span>,
-    <span class="hljs-attr">"LANG"</span>: <span class="hljs-string">"en_US.UTF-8"</span>,
-    <span class="hljs-attr">"PS1"</span>: <span class="hljs-string">"\\u@\\h : \\[\\e[31m\\]\\w\\[\\e[m\\] >  "</span>,
-    <span class="hljs-attr">"SHLVL"</span>: <span class="hljs-string">"2"</span>,
-    <span class="hljs-attr">"HOME"</span>: <span class="hljs-string">"/home/nodeuser"</span>,
-    <span class="hljs-attr">"OSTYPE"</span>: <span class="hljs-string">"linux"</span>,
-    <span class="hljs-attr">"VENDOR"</span>: <span class="hljs-string">"unknown"</span>,
-    <span class="hljs-attr">"PYTHONPATH"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/lib64/python2.7/site-packages:/opt/rh/devtoolset-3/root/usr/lib/python2.7/site-packages"</span>,
-    <span class="hljs-attr">"MACHTYPE"</span>: <span class="hljs-string">"x86_64"</span>,
-    <span class="hljs-attr">"LOGNAME"</span>: <span class="hljs-string">"nodeuser"</span>,
-    <span class="hljs-attr">"XDG_DATA_DIRS"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share:/usr/local/share:/usr/share"</span>,
-    <span class="hljs-attr">"LESSOPEN"</span>: <span class="hljs-string">"||/usr/bin/lesspipe.sh %s"</span>,
-    <span class="hljs-attr">"INFOPATH"</span>: <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share/info"</span>,
-    <span class="hljs-attr">"XDG_RUNTIME_DIR"</span>: <span class="hljs-string">"/run/user/50141"</span>,
-    <span class="hljs-attr">"_"</span>: <span class="hljs-string">"./node"</span>
-  },
-  <span class="hljs-attr">"userLimits"</span>: {
-    <span class="hljs-attr">"core_file_size_blocks"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">""</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"data_seg_size_kbytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"file_size_blocks"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"max_locked_memory_bytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-number">65536</span>
-    },
-    <span class="hljs-attr">"max_memory_size_kbytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"open_files"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-number">4096</span>
-    },
-    <span class="hljs-attr">"stack_size_bytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"cpu_time_seconds"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    },
-    <span class="hljs-attr">"max_user_processes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-number">4127290</span>
-    },
-    <span class="hljs-attr">"virtual_memory_kbytes"</span>: {
-      <span class="hljs-attr">"soft"</span>: <span class="hljs-string">"unlimited"</span>,
-      <span class="hljs-attr">"hard"</span>: <span class="hljs-string">"unlimited"</span>
-    }
-  },
-  <span class="hljs-attr">"sharedObjects"</span>: [
-    <span class="hljs-string">"/lib64/libdl.so.2"</span>,
-    <span class="hljs-string">"/lib64/librt.so.1"</span>,
-    <span class="hljs-string">"/lib64/libstdc++.so.6"</span>,
-    <span class="hljs-string">"/lib64/libm.so.6"</span>,
-    <span class="hljs-string">"/lib64/libgcc_s.so.1"</span>,
-    <span class="hljs-string">"/lib64/libpthread.so.0"</span>,
-    <span class="hljs-string">"/lib64/libc.so.6"</span>,
+    <span class="hljs-punctuation">]</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"nativeStack"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57f07a9ef"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"report::GetNodeReport(v8::Isolate*, node::Environment*, char const*, char const*, v8::Local&#x3C;v8::String>, std::ostream&#x26;) [./node]"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57f07cf03"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"report::GetReport(v8::FunctionCallbackInfo&#x3C;v8::Value> const&#x26;) [./node]"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57f1bccfd"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">" [./node]"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57f1be048"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"v8::internal::Builtin_HandleApiCall(int, v8::internal::Object**, v8::internal::Isolate*) [./node]"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"pc"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b57feeda0e"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"symbol"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">" [./node]"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"javascriptHeap"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"totalMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">6127616</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"totalCommittedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">4357352</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"usedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">3221136</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"availableMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1521370240</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"memoryLimit"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1526909922</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"heapSpaces"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"read_only_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">524288</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">39208</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">515584</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">30504</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">485080</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"new_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2097152</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2019312</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1031168</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">985496</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">45672</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"old_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2273280</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1769008</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1974640</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1725488</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">249152</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"code_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">696320</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">184896</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">152128</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">152128</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"map_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">536576</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">344928</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">327520</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">327520</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"large_object_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1520590336</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1520590336</span>
+      <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"new_large_object_space"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+        <span class="hljs-attr">"memorySize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"committedMemory"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"capacity"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"used"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+        <span class="hljs-attr">"available"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+      <span class="hljs-punctuation">}</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"resourceUsage"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"userCpuSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.069595</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"kernelCpuSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.019163</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cpuConsumptionPercent"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.000000</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"maxRss"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">18079744</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"pageFaults"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"IORequired"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"IONotRequired"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">4610</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"fsActivity"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"reads"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writes"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"uvthreadResourceUsage"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"userCpuSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.068457</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"kernelCpuSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.019127</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cpuConsumptionPercent"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0.000000</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"fsActivity"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"reads"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writes"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"libuv"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"async"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x0000000102910900"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"details"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">""</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"timer"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfeab0"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"repeat"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"firesInMsFromNow"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">94403548320796</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"expired"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"check"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfeb48"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"idle"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfebc0"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"prepare"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfec38"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"check"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x00007fff5fbfecb0"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"async"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000000010188f2e0"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"tty"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b581db0e18"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"width"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">204</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"height"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">55</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"fd"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">17</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writeQueueSize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"readable"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writable"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"signal"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">false</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b581d80010"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"signum"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">28</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"signal"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"SIGWINCH"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"tty"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_referenced"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055b581df59f8"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"width"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">204</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"height"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">55</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"fd"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">19</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writeQueueSize"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"readable"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"writable"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"type"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"loop"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"is_active"</span><span class="hljs-punctuation">:</span> <span class="hljs-keyword">true</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"address"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"0x000055fc7b2cb180"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"loopIdleTimeSeconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">22644.8</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"workers"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span><span class="hljs-punctuation">]</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"environmentVariables"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"REMOTEHOST"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"REMOVED"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"MANPATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share/man:"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"XDG_SESSION_ID"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"66126"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"HOSTNAME"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"test_machine"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"HOST"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"test_machine"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"TERM"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"xterm-256color"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"SHELL"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/bin/csh"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"SSH_CLIENT"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"REMOVED"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PERL5LIB"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root//usr/lib64/perl5/vendor_perl:/opt/rh/devtoolset-3/root/usr/lib/perl5:/opt/rh/devtoolset-3/root//usr/share/perl5/vendor_perl"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"OLDPWD"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser/project/node/src"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"JAVACONFDIRS"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/etc/java:/etc/java"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"SSH_TTY"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/dev/pts/0"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PCP_DIR"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"GROUP"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"normaluser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"USER"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"nodeuser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"LD_LIBRARY_PATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/lib64:/opt/rh/devtoolset-3/root/usr/lib"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"HOSTTYPE"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"x86_64-linux"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"XDG_CONFIG_DIRS"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/etc/xdg:/etc/xdg"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"MAIL"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/var/spool/mail/nodeuser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser/project/node:/opt/rh/devtoolset-3/root/usr/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PWD"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser/project/node"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"LANG"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"en_US.UTF-8"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PS1"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"\\u@\\h : \\[\\e[31m\\]\\w\\[\\e[m\\] >  "</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"SHLVL"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"2"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"HOME"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/home/nodeuser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"OSTYPE"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"linux"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"VENDOR"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unknown"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"PYTHONPATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/lib64/python2.7/site-packages:/opt/rh/devtoolset-3/root/usr/lib/python2.7/site-packages"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"MACHTYPE"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"x86_64"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"LOGNAME"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"nodeuser"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"XDG_DATA_DIRS"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share:/usr/local/share:/usr/share"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"LESSOPEN"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"||/usr/bin/lesspipe.sh %s"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"INFOPATH"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/opt/rh/devtoolset-3/root/usr/share/info"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"XDG_RUNTIME_DIR"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"/run/user/50141"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"_"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"./node"</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"userLimits"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"core_file_size_blocks"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">""</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"data_seg_size_kbytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"file_size_blocks"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"max_locked_memory_bytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">65536</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"max_memory_size_kbytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"open_files"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">4096</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"stack_size_bytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"cpu_time_seconds"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"max_user_processes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">4127290</span>
+    <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"virtual_memory_kbytes"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
+      <span class="hljs-attr">"soft"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span><span class="hljs-punctuation">,</span>
+      <span class="hljs-attr">"hard"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"unlimited"</span>
+    <span class="hljs-punctuation">}</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-attr">"sharedObjects"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">[</span>
+    <span class="hljs-string">"/lib64/libdl.so.2"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/librt.so.1"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libstdc++.so.6"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libm.so.6"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libgcc_s.so.1"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libpthread.so.0"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-string">"/lib64/libc.so.6"</span><span class="hljs-punctuation">,</span>
     <span class="hljs-string">"/lib64/ld-linux-x86-64.so.2"</span>
-  ]
-}</code></pre>
-<h2>Usage<span><a class="mark" href="#report_usage" id="report_usage">#</a></span></h2>
+  <span class="hljs-punctuation">]</span>
+<span class="hljs-punctuation">}</span></code></pre>
+<section><h3>Usage<span><a class="mark" href="#report_usage" id="report_usage">#</a></span></h3>
 <pre><code class="language-bash">node --report-uncaught-exception --report-on-signal \
 --report-on-fatalerror app.js</code></pre>
 <ul>
@@ -521,9 +533,9 @@ with native stack and other runtime environment data.</p>
 </li>
 <li>
 <p><code>--report-on-signal</code> Enables report to be generated upon receiving
-the specified (or predefined) signal to the running Node.js process. (See below
-on how to modify the signal that triggers the report.) Default signal is <code>SIGUSR2</code>.
-Useful when a report needs to be triggered from another program.
+the specified (or predefined) signal to the running Node.js process. (See
+below on how to modify the signal that triggers the report.) Default signal is
+<code>SIGUSR2</code>. Useful when a report needs to be triggered from another program.
 Application monitors may leverage this feature to collect report at regular
 intervals and plot rich set of internal runtime data to their views.</p>
 </li>
@@ -535,8 +547,8 @@ flag helps to change the signal for report generation and preserve the original
 meaning of <code>SIGUSR2</code> for the said purposes.</p>
 <ul>
 <li>
-<p><code>--report-on-fatalerror</code> Enables the report to be triggered on
-fatal errors (internal errors within the Node.js runtime, such as out of memory)
+<p><code>--report-on-fatalerror</code> Enables the report to be triggered on fatal errors
+(internal errors within the Node.js runtime, such as out of memory)
 that leads to termination of the application. Useful to inspect various
 diagnostic data elements such as heap, stack, event loop state, resource
 consumption etc. to reason about the fatal error.</p>
@@ -560,41 +572,41 @@ written.</p>
 </li>
 </ul>
 <p>A report can also be triggered via an API call from a JavaScript application:</p>
-<pre><code class="language-js">process.report.writeReport();</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>();</code></pre>
 <p>This function takes an optional additional argument <code>filename</code>, which is
 the name of a file into which the report is written.</p>
-<pre><code class="language-js">process.report.writeReport(<span class="hljs-string">'./foo.json'</span>);</code></pre>
+<pre><code class="language-js">process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>(<span class="hljs-string">'./foo.json'</span>);</code></pre>
 <p>This function takes an optional additional argument <code>err</code> which is an <code>Error</code>
 object that will be used as the context for the JavaScript stack printed in the
 report. When using report to handle errors in a callback or an exception
 handler, this allows the report to include the location of the original error as
 well as where it was handled.</p>
 <pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  process.chdir(<span class="hljs-string">'/non-existent-path'</span>);
+  process.<span class="hljs-title function_">chdir</span>(<span class="hljs-string">'/non-existent-path'</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  process.report.writeReport(err);
+  process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>(err);
 }
 <span class="hljs-comment">// Any other code</span></code></pre>
 <p>If both filename and error object are passed to <code>writeReport()</code> the
 error object must be the second parameter.</p>
 <pre><code class="language-js"><span class="hljs-keyword">try</span> {
-  process.chdir(<span class="hljs-string">'/non-existent-path'</span>);
+  process.<span class="hljs-title function_">chdir</span>(<span class="hljs-string">'/non-existent-path'</span>);
 } <span class="hljs-keyword">catch</span> (err) {
-  process.report.writeReport(filename, err);
+  process.<span class="hljs-property">report</span>.<span class="hljs-title function_">writeReport</span>(filename, err);
 }
 <span class="hljs-comment">// Any other code</span></code></pre>
 <p>The content of the diagnostic report can be returned as a JavaScript Object
 via an API call from a JavaScript application:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> report = process.report.getReport();
-<span class="hljs-built_in">console</span>.log(<span class="hljs-keyword">typeof</span> report === <span class="hljs-string">'object'</span>); <span class="hljs-comment">// true</span>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> report = process.<span class="hljs-property">report</span>.<span class="hljs-title function_">getReport</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-keyword">typeof</span> report === <span class="hljs-string">'object'</span>); <span class="hljs-comment">// true</span>
 
 <span class="hljs-comment">// Similar to process.report.writeReport() output</span>
-<span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">JSON</span>.stringify(report, <span class="hljs-literal">null</span>, <span class="hljs-number">2</span>));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(report, <span class="hljs-literal">null</span>, <span class="hljs-number">2</span>));</code></pre>
 <p>This function takes an optional additional argument <code>err</code>, which is an <code>Error</code>
 object that will be used as the context for the JavaScript stack printed in the
 report.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> report = process.report.getReport(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'custom error'</span>));
-<span class="hljs-built_in">console</span>.log(<span class="hljs-keyword">typeof</span> report === <span class="hljs-string">'object'</span>); <span class="hljs-comment">// true</span></code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> report = process.<span class="hljs-property">report</span>.<span class="hljs-title function_">getReport</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'custom error'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-keyword">typeof</span> report === <span class="hljs-string">'object'</span>); <span class="hljs-comment">// true</span></code></pre>
 <p>The API versions are useful when inspecting the runtime state from within
 the application, in expectation of self-adjusting the resource consumption,
 load balancing, monitoring etc.</p>
@@ -604,8 +616,8 @@ native stack traces, a section containing V8 heap information, a section
 containing <code>libuv</code> handle information and an OS platform information section
 showing CPU and memory usage and system limits. An example report can be
 triggered using the Node.js REPL:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node</span>
-<span class="hljs-meta">></span><span class="bash"> process.report.writeReport();</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node</span>
+<span class="hljs-meta">> </span><span class="language-bash">process.report.writeReport();</span>
 Writing Node.js report to file: report.20181126.091102.8480.0.001.json
 Node.js report completed
 <span class="hljs-meta">></span></code></pre>
@@ -614,7 +626,7 @@ and the filename of the report is returned to the caller. The default filename
 includes the date, time, PID and a sequence number. The sequence number helps
 in associating the report dump with the runtime state if generated multiple
 times for the same Node.js process.</p>
-<h2>Configuration<span><a class="mark" href="#report_configuration" id="report_configuration">#</a></span></h2>
+</section><section><h3>Configuration<span><a class="mark" href="#report_configuration" id="report_configuration">#</a></span></h3>
 <p>Additional runtime configuration of report generation is available via
 the following properties of <code>process.report</code>:</p>
 <p><code>reportOnFatalError</code> triggers diagnostic reporting on fatal errors when <code>true</code>.
@@ -636,20 +648,20 @@ timestamp, PID and sequence number.</p>
 URLs are not supported. Defaults to the current working directory of the
 Node.js process.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Trigger report only on uncaught exceptions.</span>
-process.report.reportOnFatalError = <span class="hljs-literal">false</span>;
-process.report.reportOnSignal = <span class="hljs-literal">false</span>;
-process.report.reportOnUncaughtException = <span class="hljs-literal">true</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnFatalError</span> = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnSignal</span> = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnUncaughtException</span> = <span class="hljs-literal">true</span>;
 
 <span class="hljs-comment">// Trigger report for both internal errors as well as external signal.</span>
-process.report.reportOnFatalError = <span class="hljs-literal">true</span>;
-process.report.reportOnSignal = <span class="hljs-literal">true</span>;
-process.report.reportOnUncaughtException = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnFatalError</span> = <span class="hljs-literal">true</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnSignal</span> = <span class="hljs-literal">true</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnUncaughtException</span> = <span class="hljs-literal">false</span>;
 
 <span class="hljs-comment">// Change the default signal to 'SIGQUIT' and enable it.</span>
-process.report.reportOnFatalError = <span class="hljs-literal">false</span>;
-process.report.reportOnUncaughtException = <span class="hljs-literal">false</span>;
-process.report.reportOnSignal = <span class="hljs-literal">true</span>;
-process.report.signal = <span class="hljs-string">'SIGQUIT'</span>;</code></pre>
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnFatalError</span> = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnUncaughtException</span> = <span class="hljs-literal">false</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">reportOnSignal</span> = <span class="hljs-literal">true</span>;
+process.<span class="hljs-property">report</span>.<span class="hljs-property">signal</span> = <span class="hljs-string">'SIGQUIT'</span>;</code></pre>
 <p>Configuration on module initialization is also available via
 environment variables:</p>
 <pre><code class="language-bash">NODE_OPTIONS=<span class="hljs-string">"--report-uncaught-exception \
@@ -658,12 +670,12 @@ environment variables:</p>
   --report-directory=/home/nodeuser"</span></code></pre>
 <p>Specific API documentation can be found under
 <a href="process.html"><code>process API documentation</code></a> section.</p>
-<h2>Interaction with workers<span><a class="mark" href="#report_interaction_with_workers" id="report_interaction_with_workers">#</a></span></h2>
+</section><section><h3>Interaction with workers<span><a class="mark" href="#report_interaction_with_workers" id="report_interaction_with_workers">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.2</td>
+<tr><td>v13.9.0, v12.16.2</td>
 <td><p>Workers are now included in the report.</p></td></tr>
 </tbody></table>
 </details>
@@ -675,10 +687,46 @@ thread as part of the <code>workers</code> section, with each Worker generating
 in the standard report format.</p>
 <p>The thread which is generating the report will wait for the reports from Worker
 threads to finish. However, the latency for this will usually be low, as both
-running JavaScript and the event loop are interrupted to generate the report.</p>
+running JavaScript and the event loop are interrupted to generate the report.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/report.json b/doc/api/report.json
index 51a3497657bd972550c01605574280d85cc35275..5938154ecd7054b3919bad3083b5d75da096304c 100644
--- a/doc/api/report.json
+++ b/doc/api/report.json
@@ -12,12 +12,12 @@
       "type": "misc",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p>Delivers a JSON-formatted diagnostic summary, written to a file.</p>\n<p>The report is intended for development, test and production use, to capture\nand preserve information for problem determination. It includes JavaScript\nand native stack traces, heap statistics, platform information, resource\nusage etc. With the report option enabled, diagnostic reports can be triggered\non unhandled exceptions, fatal errors and user signals, in addition to\ntriggering programmatically through API calls.</p>\n<p>A complete example report that was generated on an uncaught exception\nis provided below for reference.</p>\n<pre><code class=\"language-json\">{\n  \"header\": {\n    \"reportVersion\": 1,\n    \"event\": \"exception\",\n    \"trigger\": \"Exception\",\n    \"filename\": \"report.20181221.005011.8974.0.001.json\",\n    \"dumpEventTime\": \"2018-12-21T00:50:11Z\",\n    \"dumpEventTimeStamp\": \"1545371411331\",\n    \"processId\": 8974,\n    \"cwd\": \"/home/nodeuser/project/node\",\n    \"commandLine\": [\n      \"/home/nodeuser/project/node/out/Release/node\",\n      \"--report-uncaught-exception\",\n      \"/home/nodeuser/project/node/test/report/test-exception.js\",\n      \"child\"\n    ],\n    \"nodejsVersion\": \"v12.0.0-pre\",\n    \"glibcVersionRuntime\": \"2.17\",\n    \"glibcVersionCompiler\": \"2.17\",\n    \"wordSize\": \"64 bit\",\n    \"arch\": \"x64\",\n    \"platform\": \"linux\",\n    \"componentVersions\": {\n      \"node\": \"12.0.0-pre\",\n      \"v8\": \"7.1.302.28-node.5\",\n      \"uv\": \"1.24.1\",\n      \"zlib\": \"1.2.11\",\n      \"ares\": \"1.15.0\",\n      \"modules\": \"68\",\n      \"nghttp2\": \"1.34.0\",\n      \"napi\": \"3\",\n      \"llhttp\": \"1.0.1\",\n      \"http_parser\": \"2.8.0\",\n      \"openssl\": \"1.1.0j\"\n    },\n    \"release\": {\n      \"name\": \"node\"\n    },\n    \"osName\": \"Linux\",\n    \"osRelease\": \"3.10.0-862.el7.x86_64\",\n    \"osVersion\": \"#1 SMP Wed Mar 21 18:14:51 EDT 2018\",\n    \"osMachine\": \"x86_64\",\n    \"cpus\": [\n      {\n        \"model\": \"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\",\n        \"speed\": 2700,\n        \"user\": 88902660,\n        \"nice\": 0,\n        \"sys\": 50902570,\n        \"idle\": 241732220,\n        \"irq\": 0\n      },\n      {\n        \"model\": \"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\",\n        \"speed\": 2700,\n        \"user\": 88902660,\n        \"nice\": 0,\n        \"sys\": 50902570,\n        \"idle\": 241732220,\n        \"irq\": 0\n      }\n    ],\n    \"networkInterfaces\": [\n      {\n        \"name\": \"en0\",\n        \"internal\": false,\n        \"mac\": \"13:10:de:ad:be:ef\",\n        \"address\": \"10.0.0.37\",\n        \"netmask\": \"255.255.255.0\",\n        \"family\": \"IPv4\"\n      }\n    ],\n    \"host\": \"test_machine\"\n  },\n  \"javascriptStack\": {\n    \"message\": \"Error: *** test-exception.js: throwing uncaught Error\",\n    \"stack\": [\n      \"at myException (/home/nodeuser/project/node/test/report/test-exception.js:9:11)\",\n      \"at Object.&#x3C;anonymous> (/home/nodeuser/project/node/test/report/test-exception.js:12:3)\",\n      \"at Module._compile (internal/modules/cjs/loader.js:718:30)\",\n      \"at Object.Module._extensions..js (internal/modules/cjs/loader.js:729:10)\",\n      \"at Module.load (internal/modules/cjs/loader.js:617:32)\",\n      \"at tryModuleLoad (internal/modules/cjs/loader.js:560:12)\",\n      \"at Function.Module._load (internal/modules/cjs/loader.js:552:3)\",\n      \"at Function.Module.runMain (internal/modules/cjs/loader.js:771:12)\",\n      \"at executeUserCode (internal/bootstrap/node.js:332:15)\"\n    ]\n  },\n  \"nativeStack\": [\n    {\n      \"pc\": \"0x000055b57f07a9ef\",\n      \"symbol\": \"report::GetNodeReport(v8::Isolate*, node::Environment*, char const*, char const*, v8::Local&#x3C;v8::String>, std::ostream&#x26;) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f07cf03\",\n      \"symbol\": \"report::GetReport(v8::FunctionCallbackInfo&#x3C;v8::Value> const&#x26;) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f1bccfd\",\n      \"symbol\": \" [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f1be048\",\n      \"symbol\": \"v8::internal::Builtin_HandleApiCall(int, v8::internal::Object**, v8::internal::Isolate*) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57feeda0e\",\n      \"symbol\": \" [./node]\"\n    }\n  ],\n  \"javascriptHeap\": {\n    \"totalMemory\": 6127616,\n    \"totalCommittedMemory\": 4357352,\n    \"usedMemory\": 3221136,\n    \"availableMemory\": 1521370240,\n    \"memoryLimit\": 1526909922,\n    \"heapSpaces\": {\n      \"read_only_space\": {\n        \"memorySize\": 524288,\n        \"committedMemory\": 39208,\n        \"capacity\": 515584,\n        \"used\": 30504,\n        \"available\": 485080\n      },\n      \"new_space\": {\n        \"memorySize\": 2097152,\n        \"committedMemory\": 2019312,\n        \"capacity\": 1031168,\n        \"used\": 985496,\n        \"available\": 45672\n      },\n      \"old_space\": {\n        \"memorySize\": 2273280,\n        \"committedMemory\": 1769008,\n        \"capacity\": 1974640,\n        \"used\": 1725488,\n        \"available\": 249152\n      },\n      \"code_space\": {\n        \"memorySize\": 696320,\n        \"committedMemory\": 184896,\n        \"capacity\": 152128,\n        \"used\": 152128,\n        \"available\": 0\n      },\n      \"map_space\": {\n        \"memorySize\": 536576,\n        \"committedMemory\": 344928,\n        \"capacity\": 327520,\n        \"used\": 327520,\n        \"available\": 0\n      },\n      \"large_object_space\": {\n        \"memorySize\": 0,\n        \"committedMemory\": 0,\n        \"capacity\": 1520590336,\n        \"used\": 0,\n        \"available\": 1520590336\n      },\n      \"new_large_object_space\": {\n        \"memorySize\": 0,\n        \"committedMemory\": 0,\n        \"capacity\": 0,\n        \"used\": 0,\n        \"available\": 0\n      }\n    }\n  },\n  \"resourceUsage\": {\n    \"userCpuSeconds\": 0.069595,\n    \"kernelCpuSeconds\": 0.019163,\n    \"cpuConsumptionPercent\": 0.000000,\n    \"maxRss\": 18079744,\n    \"pageFaults\": {\n      \"IORequired\": 0,\n      \"IONotRequired\": 4610\n    },\n    \"fsActivity\": {\n      \"reads\": 0,\n      \"writes\": 0\n    }\n  },\n  \"uvthreadResourceUsage\": {\n    \"userCpuSeconds\": 0.068457,\n    \"kernelCpuSeconds\": 0.019127,\n    \"cpuConsumptionPercent\": 0.000000,\n    \"fsActivity\": {\n      \"reads\": 0,\n      \"writes\": 0\n    }\n  },\n  \"libuv\": [\n    {\n      \"type\": \"async\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x0000000102910900\",\n      \"details\": \"\"\n    },\n    {\n      \"type\": \"timer\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfeab0\",\n      \"repeat\": 0,\n      \"firesInMsFromNow\": 94403548320796,\n      \"expired\": true\n    },\n    {\n      \"type\": \"check\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfeb48\"\n    },\n    {\n      \"type\": \"idle\",\n      \"is_active\": false,\n      \"is_referenced\": true,\n      \"address\": \"0x00007fff5fbfebc0\"\n    },\n    {\n      \"type\": \"prepare\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfec38\"\n    },\n    {\n      \"type\": \"check\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfecb0\"\n    },\n    {\n      \"type\": \"async\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x000000010188f2e0\"\n    },\n    {\n      \"type\": \"tty\",\n      \"is_active\": false,\n      \"is_referenced\": true,\n      \"address\": \"0x000055b581db0e18\",\n      \"width\": 204,\n      \"height\": 55,\n      \"fd\": 17,\n      \"writeQueueSize\": 0,\n      \"readable\": true,\n      \"writable\": true\n    },\n    {\n      \"type\": \"signal\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x000055b581d80010\",\n      \"signum\": 28,\n      \"signal\": \"SIGWINCH\"\n    },\n    {\n      \"type\": \"tty\",\n      \"is_active\": true,\n      \"is_referenced\": true,\n      \"address\": \"0x000055b581df59f8\",\n      \"width\": 204,\n      \"height\": 55,\n      \"fd\": 19,\n      \"writeQueueSize\": 0,\n      \"readable\": true,\n      \"writable\": true\n    },\n    {\n      \"type\": \"loop\",\n      \"is_active\": true,\n      \"address\": \"0x000055fc7b2cb180\"\n    }\n  ],\n  \"workers\": [],\n  \"environmentVariables\": {\n    \"REMOTEHOST\": \"REMOVED\",\n    \"MANPATH\": \"/opt/rh/devtoolset-3/root/usr/share/man:\",\n    \"XDG_SESSION_ID\": \"66126\",\n    \"HOSTNAME\": \"test_machine\",\n    \"HOST\": \"test_machine\",\n    \"TERM\": \"xterm-256color\",\n    \"SHELL\": \"/bin/csh\",\n    \"SSH_CLIENT\": \"REMOVED\",\n    \"PERL5LIB\": \"/opt/rh/devtoolset-3/root//usr/lib64/perl5/vendor_perl:/opt/rh/devtoolset-3/root/usr/lib/perl5:/opt/rh/devtoolset-3/root//usr/share/perl5/vendor_perl\",\n    \"OLDPWD\": \"/home/nodeuser/project/node/src\",\n    \"JAVACONFDIRS\": \"/opt/rh/devtoolset-3/root/etc/java:/etc/java\",\n    \"SSH_TTY\": \"/dev/pts/0\",\n    \"PCP_DIR\": \"/opt/rh/devtoolset-3/root\",\n    \"GROUP\": \"normaluser\",\n    \"USER\": \"nodeuser\",\n    \"LD_LIBRARY_PATH\": \"/opt/rh/devtoolset-3/root/usr/lib64:/opt/rh/devtoolset-3/root/usr/lib\",\n    \"HOSTTYPE\": \"x86_64-linux\",\n    \"XDG_CONFIG_DIRS\": \"/opt/rh/devtoolset-3/root/etc/xdg:/etc/xdg\",\n    \"MAIL\": \"/var/spool/mail/nodeuser\",\n    \"PATH\": \"/home/nodeuser/project/node:/opt/rh/devtoolset-3/root/usr/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin\",\n    \"PWD\": \"/home/nodeuser/project/node\",\n    \"LANG\": \"en_US.UTF-8\",\n    \"PS1\": \"\\\\u@\\\\h : \\\\[\\\\e[31m\\\\]\\\\w\\\\[\\\\e[m\\\\] >  \",\n    \"SHLVL\": \"2\",\n    \"HOME\": \"/home/nodeuser\",\n    \"OSTYPE\": \"linux\",\n    \"VENDOR\": \"unknown\",\n    \"PYTHONPATH\": \"/opt/rh/devtoolset-3/root/usr/lib64/python2.7/site-packages:/opt/rh/devtoolset-3/root/usr/lib/python2.7/site-packages\",\n    \"MACHTYPE\": \"x86_64\",\n    \"LOGNAME\": \"nodeuser\",\n    \"XDG_DATA_DIRS\": \"/opt/rh/devtoolset-3/root/usr/share:/usr/local/share:/usr/share\",\n    \"LESSOPEN\": \"||/usr/bin/lesspipe.sh %s\",\n    \"INFOPATH\": \"/opt/rh/devtoolset-3/root/usr/share/info\",\n    \"XDG_RUNTIME_DIR\": \"/run/user/50141\",\n    \"_\": \"./node\"\n  },\n  \"userLimits\": {\n    \"core_file_size_blocks\": {\n      \"soft\": \"\",\n      \"hard\": \"unlimited\"\n    },\n    \"data_seg_size_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"file_size_blocks\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"max_locked_memory_bytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 65536\n    },\n    \"max_memory_size_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"open_files\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 4096\n    },\n    \"stack_size_bytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"cpu_time_seconds\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"max_user_processes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 4127290\n    },\n    \"virtual_memory_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    }\n  },\n  \"sharedObjects\": [\n    \"/lib64/libdl.so.2\",\n    \"/lib64/librt.so.1\",\n    \"/lib64/libstdc++.so.6\",\n    \"/lib64/libm.so.6\",\n    \"/lib64/libgcc_s.so.1\",\n    \"/lib64/libpthread.so.0\",\n    \"/lib64/libc.so.6\",\n    \"/lib64/ld-linux-x86-64.so.2\"\n  ]\n}\n</code></pre>",
+      "desc": "<p>Delivers a JSON-formatted diagnostic summary, written to a file.</p>\n<p>The report is intended for development, test and production use, to capture\nand preserve information for problem determination. It includes JavaScript\nand native stack traces, heap statistics, platform information, resource\nusage etc. With the report option enabled, diagnostic reports can be triggered\non unhandled exceptions, fatal errors and user signals, in addition to\ntriggering programmatically through API calls.</p>\n<p>A complete example report that was generated on an uncaught exception\nis provided below for reference.</p>\n<pre><code class=\"language-json\">{\n  \"header\": {\n    \"reportVersion\": 1,\n    \"event\": \"exception\",\n    \"trigger\": \"Exception\",\n    \"filename\": \"report.20181221.005011.8974.0.001.json\",\n    \"dumpEventTime\": \"2018-12-21T00:50:11Z\",\n    \"dumpEventTimeStamp\": \"1545371411331\",\n    \"processId\": 8974,\n    \"cwd\": \"/home/nodeuser/project/node\",\n    \"commandLine\": [\n      \"/home/nodeuser/project/node/out/Release/node\",\n      \"--report-uncaught-exception\",\n      \"/home/nodeuser/project/node/test/report/test-exception.js\",\n      \"child\"\n    ],\n    \"nodejsVersion\": \"v12.0.0-pre\",\n    \"glibcVersionRuntime\": \"2.17\",\n    \"glibcVersionCompiler\": \"2.17\",\n    \"wordSize\": \"64 bit\",\n    \"arch\": \"x64\",\n    \"platform\": \"linux\",\n    \"componentVersions\": {\n      \"node\": \"12.0.0-pre\",\n      \"v8\": \"7.1.302.28-node.5\",\n      \"uv\": \"1.24.1\",\n      \"zlib\": \"1.2.11\",\n      \"ares\": \"1.15.0\",\n      \"modules\": \"68\",\n      \"nghttp2\": \"1.34.0\",\n      \"napi\": \"3\",\n      \"llhttp\": \"1.0.1\",\n      \"openssl\": \"1.1.0j\"\n    },\n    \"release\": {\n      \"name\": \"node\"\n    },\n    \"osName\": \"Linux\",\n    \"osRelease\": \"3.10.0-862.el7.x86_64\",\n    \"osVersion\": \"#1 SMP Wed Mar 21 18:14:51 EDT 2018\",\n    \"osMachine\": \"x86_64\",\n    \"cpus\": [\n      {\n        \"model\": \"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\",\n        \"speed\": 2700,\n        \"user\": 88902660,\n        \"nice\": 0,\n        \"sys\": 50902570,\n        \"idle\": 241732220,\n        \"irq\": 0\n      },\n      {\n        \"model\": \"Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz\",\n        \"speed\": 2700,\n        \"user\": 88902660,\n        \"nice\": 0,\n        \"sys\": 50902570,\n        \"idle\": 241732220,\n        \"irq\": 0\n      }\n    ],\n    \"networkInterfaces\": [\n      {\n        \"name\": \"en0\",\n        \"internal\": false,\n        \"mac\": \"13:10:de:ad:be:ef\",\n        \"address\": \"10.0.0.37\",\n        \"netmask\": \"255.255.255.0\",\n        \"family\": \"IPv4\"\n      }\n    ],\n    \"host\": \"test_machine\"\n  },\n  \"javascriptStack\": {\n    \"message\": \"Error: *** test-exception.js: throwing uncaught Error\",\n    \"stack\": [\n      \"at myException (/home/nodeuser/project/node/test/report/test-exception.js:9:11)\",\n      \"at Object.&#x3C;anonymous> (/home/nodeuser/project/node/test/report/test-exception.js:12:3)\",\n      \"at Module._compile (internal/modules/cjs/loader.js:718:30)\",\n      \"at Object.Module._extensions..js (internal/modules/cjs/loader.js:729:10)\",\n      \"at Module.load (internal/modules/cjs/loader.js:617:32)\",\n      \"at tryModuleLoad (internal/modules/cjs/loader.js:560:12)\",\n      \"at Function.Module._load (internal/modules/cjs/loader.js:552:3)\",\n      \"at Function.Module.runMain (internal/modules/cjs/loader.js:771:12)\",\n      \"at executeUserCode (internal/bootstrap/node.js:332:15)\"\n    ]\n  },\n  \"nativeStack\": [\n    {\n      \"pc\": \"0x000055b57f07a9ef\",\n      \"symbol\": \"report::GetNodeReport(v8::Isolate*, node::Environment*, char const*, char const*, v8::Local&#x3C;v8::String>, std::ostream&#x26;) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f07cf03\",\n      \"symbol\": \"report::GetReport(v8::FunctionCallbackInfo&#x3C;v8::Value> const&#x26;) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f1bccfd\",\n      \"symbol\": \" [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57f1be048\",\n      \"symbol\": \"v8::internal::Builtin_HandleApiCall(int, v8::internal::Object**, v8::internal::Isolate*) [./node]\"\n    },\n    {\n      \"pc\": \"0x000055b57feeda0e\",\n      \"symbol\": \" [./node]\"\n    }\n  ],\n  \"javascriptHeap\": {\n    \"totalMemory\": 6127616,\n    \"totalCommittedMemory\": 4357352,\n    \"usedMemory\": 3221136,\n    \"availableMemory\": 1521370240,\n    \"memoryLimit\": 1526909922,\n    \"heapSpaces\": {\n      \"read_only_space\": {\n        \"memorySize\": 524288,\n        \"committedMemory\": 39208,\n        \"capacity\": 515584,\n        \"used\": 30504,\n        \"available\": 485080\n      },\n      \"new_space\": {\n        \"memorySize\": 2097152,\n        \"committedMemory\": 2019312,\n        \"capacity\": 1031168,\n        \"used\": 985496,\n        \"available\": 45672\n      },\n      \"old_space\": {\n        \"memorySize\": 2273280,\n        \"committedMemory\": 1769008,\n        \"capacity\": 1974640,\n        \"used\": 1725488,\n        \"available\": 249152\n      },\n      \"code_space\": {\n        \"memorySize\": 696320,\n        \"committedMemory\": 184896,\n        \"capacity\": 152128,\n        \"used\": 152128,\n        \"available\": 0\n      },\n      \"map_space\": {\n        \"memorySize\": 536576,\n        \"committedMemory\": 344928,\n        \"capacity\": 327520,\n        \"used\": 327520,\n        \"available\": 0\n      },\n      \"large_object_space\": {\n        \"memorySize\": 0,\n        \"committedMemory\": 0,\n        \"capacity\": 1520590336,\n        \"used\": 0,\n        \"available\": 1520590336\n      },\n      \"new_large_object_space\": {\n        \"memorySize\": 0,\n        \"committedMemory\": 0,\n        \"capacity\": 0,\n        \"used\": 0,\n        \"available\": 0\n      }\n    }\n  },\n  \"resourceUsage\": {\n    \"userCpuSeconds\": 0.069595,\n    \"kernelCpuSeconds\": 0.019163,\n    \"cpuConsumptionPercent\": 0.000000,\n    \"maxRss\": 18079744,\n    \"pageFaults\": {\n      \"IORequired\": 0,\n      \"IONotRequired\": 4610\n    },\n    \"fsActivity\": {\n      \"reads\": 0,\n      \"writes\": 0\n    }\n  },\n  \"uvthreadResourceUsage\": {\n    \"userCpuSeconds\": 0.068457,\n    \"kernelCpuSeconds\": 0.019127,\n    \"cpuConsumptionPercent\": 0.000000,\n    \"fsActivity\": {\n      \"reads\": 0,\n      \"writes\": 0\n    }\n  },\n  \"libuv\": [\n    {\n      \"type\": \"async\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x0000000102910900\",\n      \"details\": \"\"\n    },\n    {\n      \"type\": \"timer\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfeab0\",\n      \"repeat\": 0,\n      \"firesInMsFromNow\": 94403548320796,\n      \"expired\": true\n    },\n    {\n      \"type\": \"check\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfeb48\"\n    },\n    {\n      \"type\": \"idle\",\n      \"is_active\": false,\n      \"is_referenced\": true,\n      \"address\": \"0x00007fff5fbfebc0\"\n    },\n    {\n      \"type\": \"prepare\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfec38\"\n    },\n    {\n      \"type\": \"check\",\n      \"is_active\": false,\n      \"is_referenced\": false,\n      \"address\": \"0x00007fff5fbfecb0\"\n    },\n    {\n      \"type\": \"async\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x000000010188f2e0\"\n    },\n    {\n      \"type\": \"tty\",\n      \"is_active\": false,\n      \"is_referenced\": true,\n      \"address\": \"0x000055b581db0e18\",\n      \"width\": 204,\n      \"height\": 55,\n      \"fd\": 17,\n      \"writeQueueSize\": 0,\n      \"readable\": true,\n      \"writable\": true\n    },\n    {\n      \"type\": \"signal\",\n      \"is_active\": true,\n      \"is_referenced\": false,\n      \"address\": \"0x000055b581d80010\",\n      \"signum\": 28,\n      \"signal\": \"SIGWINCH\"\n    },\n    {\n      \"type\": \"tty\",\n      \"is_active\": true,\n      \"is_referenced\": true,\n      \"address\": \"0x000055b581df59f8\",\n      \"width\": 204,\n      \"height\": 55,\n      \"fd\": 19,\n      \"writeQueueSize\": 0,\n      \"readable\": true,\n      \"writable\": true\n    },\n    {\n      \"type\": \"loop\",\n      \"is_active\": true,\n      \"address\": \"0x000055fc7b2cb180\",\n      \"loopIdleTimeSeconds\": 22644.8\n    }\n  ],\n  \"workers\": [],\n  \"environmentVariables\": {\n    \"REMOTEHOST\": \"REMOVED\",\n    \"MANPATH\": \"/opt/rh/devtoolset-3/root/usr/share/man:\",\n    \"XDG_SESSION_ID\": \"66126\",\n    \"HOSTNAME\": \"test_machine\",\n    \"HOST\": \"test_machine\",\n    \"TERM\": \"xterm-256color\",\n    \"SHELL\": \"/bin/csh\",\n    \"SSH_CLIENT\": \"REMOVED\",\n    \"PERL5LIB\": \"/opt/rh/devtoolset-3/root//usr/lib64/perl5/vendor_perl:/opt/rh/devtoolset-3/root/usr/lib/perl5:/opt/rh/devtoolset-3/root//usr/share/perl5/vendor_perl\",\n    \"OLDPWD\": \"/home/nodeuser/project/node/src\",\n    \"JAVACONFDIRS\": \"/opt/rh/devtoolset-3/root/etc/java:/etc/java\",\n    \"SSH_TTY\": \"/dev/pts/0\",\n    \"PCP_DIR\": \"/opt/rh/devtoolset-3/root\",\n    \"GROUP\": \"normaluser\",\n    \"USER\": \"nodeuser\",\n    \"LD_LIBRARY_PATH\": \"/opt/rh/devtoolset-3/root/usr/lib64:/opt/rh/devtoolset-3/root/usr/lib\",\n    \"HOSTTYPE\": \"x86_64-linux\",\n    \"XDG_CONFIG_DIRS\": \"/opt/rh/devtoolset-3/root/etc/xdg:/etc/xdg\",\n    \"MAIL\": \"/var/spool/mail/nodeuser\",\n    \"PATH\": \"/home/nodeuser/project/node:/opt/rh/devtoolset-3/root/usr/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin\",\n    \"PWD\": \"/home/nodeuser/project/node\",\n    \"LANG\": \"en_US.UTF-8\",\n    \"PS1\": \"\\\\u@\\\\h : \\\\[\\\\e[31m\\\\]\\\\w\\\\[\\\\e[m\\\\] >  \",\n    \"SHLVL\": \"2\",\n    \"HOME\": \"/home/nodeuser\",\n    \"OSTYPE\": \"linux\",\n    \"VENDOR\": \"unknown\",\n    \"PYTHONPATH\": \"/opt/rh/devtoolset-3/root/usr/lib64/python2.7/site-packages:/opt/rh/devtoolset-3/root/usr/lib/python2.7/site-packages\",\n    \"MACHTYPE\": \"x86_64\",\n    \"LOGNAME\": \"nodeuser\",\n    \"XDG_DATA_DIRS\": \"/opt/rh/devtoolset-3/root/usr/share:/usr/local/share:/usr/share\",\n    \"LESSOPEN\": \"||/usr/bin/lesspipe.sh %s\",\n    \"INFOPATH\": \"/opt/rh/devtoolset-3/root/usr/share/info\",\n    \"XDG_RUNTIME_DIR\": \"/run/user/50141\",\n    \"_\": \"./node\"\n  },\n  \"userLimits\": {\n    \"core_file_size_blocks\": {\n      \"soft\": \"\",\n      \"hard\": \"unlimited\"\n    },\n    \"data_seg_size_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"file_size_blocks\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"max_locked_memory_bytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 65536\n    },\n    \"max_memory_size_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"open_files\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 4096\n    },\n    \"stack_size_bytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"cpu_time_seconds\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    },\n    \"max_user_processes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": 4127290\n    },\n    \"virtual_memory_kbytes\": {\n      \"soft\": \"unlimited\",\n      \"hard\": \"unlimited\"\n    }\n  },\n  \"sharedObjects\": [\n    \"/lib64/libdl.so.2\",\n    \"/lib64/librt.so.1\",\n    \"/lib64/libstdc++.so.6\",\n    \"/lib64/libm.so.6\",\n    \"/lib64/libgcc_s.so.1\",\n    \"/lib64/libpthread.so.0\",\n    \"/lib64/libc.so.6\",\n    \"/lib64/ld-linux-x86-64.so.2\"\n  ]\n}\n</code></pre>",
       "miscs": [
         {
           "textRaw": "Usage",
           "name": "usage",
-          "desc": "<pre><code class=\"language-bash\">node --report-uncaught-exception --report-on-signal \\\n--report-on-fatalerror app.js\n</code></pre>\n<ul>\n<li>\n<p><code>--report-uncaught-exception</code> Enables report to be generated on\nun-caught exceptions. Useful when inspecting JavaScript stack in conjunction\nwith native stack and other runtime environment data.</p>\n</li>\n<li>\n<p><code>--report-on-signal</code> Enables report to be generated upon receiving\nthe specified (or predefined) signal to the running Node.js process. (See below\non how to modify the signal that triggers the report.) Default signal is <code>SIGUSR2</code>.\nUseful when a report needs to be triggered from another program.\nApplication monitors may leverage this feature to collect report at regular\nintervals and plot rich set of internal runtime data to their views.</p>\n</li>\n</ul>\n<p>Signal based report generation is not supported in Windows.</p>\n<p>Under normal circumstances, there is no need to modify the report triggering\nsignal. However, if <code>SIGUSR2</code> is already used for other purposes, then this\nflag helps to change the signal for report generation and preserve the original\nmeaning of <code>SIGUSR2</code> for the said purposes.</p>\n<ul>\n<li>\n<p><code>--report-on-fatalerror</code> Enables the report to be triggered on\nfatal errors (internal errors within the Node.js runtime, such as out of memory)\nthat leads to termination of the application. Useful to inspect various\ndiagnostic data elements such as heap, stack, event loop state, resource\nconsumption etc. to reason about the fatal error.</p>\n</li>\n<li>\n<p><code>--report-compact</code> Write reports in a compact format, single-line JSON, more\neasily consumable by log processing systems than the default multi-line format\ndesigned for human consumption.</p>\n</li>\n<li>\n<p><code>--report-directory</code> Location at which the report will be\ngenerated.</p>\n</li>\n<li>\n<p><code>--report-filename</code> Name of the file to which the report will be\nwritten.</p>\n</li>\n<li>\n<p><code>--report-signal</code> Sets or resets the signal for report generation\n(not supported on Windows). Default signal is <code>SIGUSR2</code>.</p>\n</li>\n</ul>\n<p>A report can also be triggered via an API call from a JavaScript application:</p>\n<pre><code class=\"language-js\">process.report.writeReport();\n</code></pre>\n<p>This function takes an optional additional argument <code>filename</code>, which is\nthe name of a file into which the report is written.</p>\n<pre><code class=\"language-js\">process.report.writeReport('./foo.json');\n</code></pre>\n<p>This function takes an optional additional argument <code>err</code> which is an <code>Error</code>\nobject that will be used as the context for the JavaScript stack printed in the\nreport. When using report to handle errors in a callback or an exception\nhandler, this allows the report to include the location of the original error as\nwell as where it was handled.</p>\n<pre><code class=\"language-js\">try {\n  process.chdir('/non-existent-path');\n} catch (err) {\n  process.report.writeReport(err);\n}\n// Any other code\n</code></pre>\n<p>If both filename and error object are passed to <code>writeReport()</code> the\nerror object must be the second parameter.</p>\n<pre><code class=\"language-js\">try {\n  process.chdir('/non-existent-path');\n} catch (err) {\n  process.report.writeReport(filename, err);\n}\n// Any other code\n</code></pre>\n<p>The content of the diagnostic report can be returned as a JavaScript Object\nvia an API call from a JavaScript application:</p>\n<pre><code class=\"language-js\">const report = process.report.getReport();\nconsole.log(typeof report === 'object'); // true\n\n// Similar to process.report.writeReport() output\nconsole.log(JSON.stringify(report, null, 2));\n</code></pre>\n<p>This function takes an optional additional argument <code>err</code>, which is an <code>Error</code>\nobject that will be used as the context for the JavaScript stack printed in the\nreport.</p>\n<pre><code class=\"language-js\">const report = process.report.getReport(new Error('custom error'));\nconsole.log(typeof report === 'object'); // true\n</code></pre>\n<p>The API versions are useful when inspecting the runtime state from within\nthe application, in expectation of self-adjusting the resource consumption,\nload balancing, monitoring etc.</p>\n<p>The content of the report consists of a header section containing the event\ntype, date, time, PID and Node.js version, sections containing JavaScript and\nnative stack traces, a section containing V8 heap information, a section\ncontaining <code>libuv</code> handle information and an OS platform information section\nshowing CPU and memory usage and system limits. An example report can be\ntriggered using the Node.js REPL:</p>\n<pre><code class=\"language-console\">$ node\n> process.report.writeReport();\nWriting Node.js report to file: report.20181126.091102.8480.0.001.json\nNode.js report completed\n>\n</code></pre>\n<p>When a report is written, start and end messages are issued to stderr\nand the filename of the report is returned to the caller. The default filename\nincludes the date, time, PID and a sequence number. The sequence number helps\nin associating the report dump with the runtime state if generated multiple\ntimes for the same Node.js process.</p>",
+          "desc": "<pre><code class=\"language-bash\">node --report-uncaught-exception --report-on-signal \\\n--report-on-fatalerror app.js\n</code></pre>\n<ul>\n<li>\n<p><code>--report-uncaught-exception</code> Enables report to be generated on\nun-caught exceptions. Useful when inspecting JavaScript stack in conjunction\nwith native stack and other runtime environment data.</p>\n</li>\n<li>\n<p><code>--report-on-signal</code> Enables report to be generated upon receiving\nthe specified (or predefined) signal to the running Node.js process. (See\nbelow on how to modify the signal that triggers the report.) Default signal is\n<code>SIGUSR2</code>. Useful when a report needs to be triggered from another program.\nApplication monitors may leverage this feature to collect report at regular\nintervals and plot rich set of internal runtime data to their views.</p>\n</li>\n</ul>\n<p>Signal based report generation is not supported in Windows.</p>\n<p>Under normal circumstances, there is no need to modify the report triggering\nsignal. However, if <code>SIGUSR2</code> is already used for other purposes, then this\nflag helps to change the signal for report generation and preserve the original\nmeaning of <code>SIGUSR2</code> for the said purposes.</p>\n<ul>\n<li>\n<p><code>--report-on-fatalerror</code> Enables the report to be triggered on fatal errors\n(internal errors within the Node.js runtime, such as out of memory)\nthat leads to termination of the application. Useful to inspect various\ndiagnostic data elements such as heap, stack, event loop state, resource\nconsumption etc. to reason about the fatal error.</p>\n</li>\n<li>\n<p><code>--report-compact</code> Write reports in a compact format, single-line JSON, more\neasily consumable by log processing systems than the default multi-line format\ndesigned for human consumption.</p>\n</li>\n<li>\n<p><code>--report-directory</code> Location at which the report will be\ngenerated.</p>\n</li>\n<li>\n<p><code>--report-filename</code> Name of the file to which the report will be\nwritten.</p>\n</li>\n<li>\n<p><code>--report-signal</code> Sets or resets the signal for report generation\n(not supported on Windows). Default signal is <code>SIGUSR2</code>.</p>\n</li>\n</ul>\n<p>A report can also be triggered via an API call from a JavaScript application:</p>\n<pre><code class=\"language-js\">process.report.writeReport();\n</code></pre>\n<p>This function takes an optional additional argument <code>filename</code>, which is\nthe name of a file into which the report is written.</p>\n<pre><code class=\"language-js\">process.report.writeReport('./foo.json');\n</code></pre>\n<p>This function takes an optional additional argument <code>err</code> which is an <code>Error</code>\nobject that will be used as the context for the JavaScript stack printed in the\nreport. When using report to handle errors in a callback or an exception\nhandler, this allows the report to include the location of the original error as\nwell as where it was handled.</p>\n<pre><code class=\"language-js\">try {\n  process.chdir('/non-existent-path');\n} catch (err) {\n  process.report.writeReport(err);\n}\n// Any other code\n</code></pre>\n<p>If both filename and error object are passed to <code>writeReport()</code> the\nerror object must be the second parameter.</p>\n<pre><code class=\"language-js\">try {\n  process.chdir('/non-existent-path');\n} catch (err) {\n  process.report.writeReport(filename, err);\n}\n// Any other code\n</code></pre>\n<p>The content of the diagnostic report can be returned as a JavaScript Object\nvia an API call from a JavaScript application:</p>\n<pre><code class=\"language-js\">const report = process.report.getReport();\nconsole.log(typeof report === 'object'); // true\n\n// Similar to process.report.writeReport() output\nconsole.log(JSON.stringify(report, null, 2));\n</code></pre>\n<p>This function takes an optional additional argument <code>err</code>, which is an <code>Error</code>\nobject that will be used as the context for the JavaScript stack printed in the\nreport.</p>\n<pre><code class=\"language-js\">const report = process.report.getReport(new Error('custom error'));\nconsole.log(typeof report === 'object'); // true\n</code></pre>\n<p>The API versions are useful when inspecting the runtime state from within\nthe application, in expectation of self-adjusting the resource consumption,\nload balancing, monitoring etc.</p>\n<p>The content of the report consists of a header section containing the event\ntype, date, time, PID and Node.js version, sections containing JavaScript and\nnative stack traces, a section containing V8 heap information, a section\ncontaining <code>libuv</code> handle information and an OS platform information section\nshowing CPU and memory usage and system limits. An example report can be\ntriggered using the Node.js REPL:</p>\n<pre><code class=\"language-console\">$ node\n> process.report.writeReport();\nWriting Node.js report to file: report.20181126.091102.8480.0.001.json\nNode.js report completed\n>\n</code></pre>\n<p>When a report is written, start and end messages are issued to stderr\nand the filename of the report is returned to the caller. The default filename\nincludes the date, time, PID and a sequence number. The sequence number helps\nin associating the report dump with the runtime state if generated multiple\ntimes for the same Node.js process.</p>",
           "type": "misc",
           "displayName": "Usage"
         },
@@ -34,7 +34,10 @@
           "meta": {
             "changes": [
               {
-                "version": "v12.16.2",
+                "version": [
+                  "v13.9.0",
+                  "v12.16.2"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/31386",
                 "description": "Workers are now included in the report."
               }
diff --git a/doc/api/report.md b/doc/api/report.md
index da96ba28cb29bcbaa7159af0a106b2080114d033..accf3ca21044fd970ae3c337e43da740e8895974 100644
--- a/doc/api/report.md
+++ b/doc/api/report.md
@@ -52,7 +52,6 @@ is provided below for reference.
       "nghttp2": "1.34.0",
       "napi": "3",
       "llhttp": "1.0.1",
-      "http_parser": "2.8.0",
       "openssl": "1.1.0j"
     },
     "release": {
@@ -293,7 +292,8 @@ is provided below for reference.
     {
       "type": "loop",
       "is_active": true,
-      "address": "0x000055fc7b2cb180"
+      "address": "0x000055fc7b2cb180",
+      "loopIdleTimeSeconds": 22644.8
     }
   ],
   "workers": [],
@@ -397,15 +397,15 @@ node --report-uncaught-exception --report-on-signal \
 ```
 
 * `--report-uncaught-exception` Enables report to be generated on
-un-caught exceptions. Useful when inspecting JavaScript stack in conjunction
-with native stack and other runtime environment data.
+  un-caught exceptions. Useful when inspecting JavaScript stack in conjunction
+  with native stack and other runtime environment data.
 
 * `--report-on-signal` Enables report to be generated upon receiving
-the specified (or predefined) signal to the running Node.js process. (See below
-on how to modify the signal that triggers the report.) Default signal is `SIGUSR2`.
-Useful when a report needs to be triggered from another program.
-Application monitors may leverage this feature to collect report at regular
-intervals and plot rich set of internal runtime data to their views.
+  the specified (or predefined) signal to the running Node.js process. (See
+  below on how to modify the signal that triggers the report.) Default signal is
+  `SIGUSR2`. Useful when a report needs to be triggered from another program.
+  Application monitors may leverage this feature to collect report at regular
+  intervals and plot rich set of internal runtime data to their views.
 
 Signal based report generation is not supported in Windows.
 
@@ -414,24 +414,24 @@ signal. However, if `SIGUSR2` is already used for other purposes, then this
 flag helps to change the signal for report generation and preserve the original
 meaning of `SIGUSR2` for the said purposes.
 
-* `--report-on-fatalerror` Enables the report to be triggered on
-fatal errors (internal errors within the Node.js runtime, such as out of memory)
-that leads to termination of the application. Useful to inspect various
-diagnostic data elements such as heap, stack, event loop state, resource
-consumption etc. to reason about the fatal error.
+* `--report-on-fatalerror` Enables the report to be triggered on fatal errors
+  (internal errors within the Node.js runtime, such as out of memory)
+  that leads to termination of the application. Useful to inspect various
+  diagnostic data elements such as heap, stack, event loop state, resource
+  consumption etc. to reason about the fatal error.
 
 * `--report-compact` Write reports in a compact format, single-line JSON, more
-easily consumable by log processing systems than the default multi-line format
-designed for human consumption.
+  easily consumable by log processing systems than the default multi-line format
+  designed for human consumption.
 
 * `--report-directory` Location at which the report will be
-generated.
+  generated.
 
 * `--report-filename` Name of the file to which the report will be
-written.
+  written.
 
 * `--report-signal` Sets or resets the signal for report generation
-(not supported on Windows). Default signal is `SIGUSR2`.
+  (not supported on Windows). Default signal is `SIGUSR2`.
 
 A report can also be triggered via an API call from a JavaScript application:
 
@@ -581,7 +581,9 @@ Specific API documentation can be found under
 ## Interaction with workers
 <!-- YAML
 changes:
-  - version: v12.16.2
+  - version:
+      - v13.9.0
+      - v12.16.2
     pr-url: https://github.com/nodejs/node/pull/31386
     description: Workers are now included in the report.
 -->
@@ -597,5 +599,5 @@ The thread which is generating the report will wait for the reports from Worker
 threads to finish. However, the latency for this will usually be low, as both
 running JavaScript and the event loop are interrupted to generate the report.
 
-[`process API documentation`]: process.html
-[`Worker`]: worker_threads.html
+[`Worker`]: worker_threads.md
+[`process API documentation`]: process.md
diff --git a/doc/api/stream.html b/doc/api/stream.html
index fb8d33a0ed8ee12769c51537f1c2858edecf3638..408ac9f09ea8b4eebebdbc22cff578a9cc541892 100644
--- a/doc/api/stream.html
+++ b/doc/api/stream.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Stream | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Stream | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="stream" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/stream.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/stream.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/stream.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/stream.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/stream.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/stream.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/stream.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/stream.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/stream.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#stream_stream">Stream</a></span>
 <ul>
 <li><a href="#stream_organization_of_this_document">Organization of this document</a></li>
@@ -160,6 +173,7 @@
 <li><a href="#stream_writable_writablefinished"><code>writable.writableFinished</code></a></li>
 <li><a href="#stream_writable_writablehighwatermark"><code>writable.writableHighWaterMark</code></a></li>
 <li><a href="#stream_writable_writablelength"><code>writable.writableLength</code></a></li>
+<li><a href="#stream_writable_writableneeddrain"><code>writable.writableNeedDrain</code></a></li>
 <li><a href="#stream_writable_writableobjectmode"><code>writable.writableObjectMode</code></a></li>
 <li><a href="#stream_writable_write_chunk_encoding_callback"><code>writable.write(chunk[, encoding][, callback])</code></a></li>
 </ul>
@@ -187,6 +201,7 @@
 <li><a href="#stream_readable_pipe_destination_options"><code>readable.pipe(destination[, options])</code></a></li>
 <li><a href="#stream_readable_read_size"><code>readable.read([size])</code></a></li>
 <li><a href="#stream_readable_readable"><code>readable.readable</code></a></li>
+<li><a href="#stream_readable_readabledidread"><code>readable.readableDidRead</code></a></li>
 <li><a href="#stream_readable_readableencoding"><code>readable.readableEncoding</code></a></li>
 <li><a href="#stream_readable_readableended"><code>readable.readableEnded</code></a></li>
 <li><a href="#stream_readable_readableflowing"><code>readable.readableFlowing</code></a></li>
@@ -214,7 +229,8 @@
 </ul>
 </li>
 <li><a href="#stream_stream_finished_stream_options_callback"><code>stream.finished(stream[, options], callback)</code></a></li>
-<li><a href="#stream_stream_pipeline_streams_callback"><code>stream.pipeline(...streams, callback)</code></a></li>
+<li><a href="#stream_stream_pipeline_source_transforms_destination_callback"><code>stream.pipeline(source[, ...transforms], destination, callback)</code></a></li>
+<li><a href="#stream_stream_pipeline_streams_callback"><code>stream.pipeline(streams, callback)</code></a></li>
 <li><a href="#stream_stream_readable_from_iterable_options"><code>stream.Readable.from(iterable, [options])</code></a></li>
 </ul>
 </li>
@@ -253,7 +269,8 @@
 <li><a href="#stream_implementing_a_transform_stream">Implementing a transform stream</a>
 <ul>
 <li><a href="#stream_new_stream_transform_options"><code>new stream.Transform([options])</code></a></li>
-<li><a href="#stream_events_finish_and_end">Events: <code>'finish'</code> and <code>'end'</code></a></li>
+<li><a href="#stream_event_end_1">Event: <code>'end'</code></a></li>
+<li><a href="#stream_event_finish_1">Event: <code>'finish'</code></a></li>
 <li><a href="#stream_transform_flush_callback"><code>transform._flush(callback)</code></a></li>
 <li><a href="#stream_transform_transform_chunk_encoding_callback"><code>transform._transform(chunk, encoding, callback)</code></a></li>
 <li><a href="#stream_class_stream_passthrough">Class: <code>stream.PassThrough</code></a></li>
@@ -278,14 +295,13 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Stream<a class="srclink" href="https://github.com/nodejs/node/blob/360a294f1f19cb8ccc9505d44a2e9efff414a5c7/lib/stream.js#L30">[src]</a><span><a class="mark" href="#stream_stream" id="stream_stream">#</a></span></h1>
+        <h2>Stream<a class="srclink" href="https://github.com/nodejs/node/blob/92df3d654b366aa115fb672756cb051d480d8acc/lib/stream.js#L28">[src]</a><span><a class="mark" href="#stream_stream" id="stream_stream">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/stream.js">lib/stream.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/stream.js">lib/stream.js</a></p>
 <p>A stream is an abstract interface for working with streaming data in Node.js.
 The <code>stream</code> module provides an API for implementing the stream interface.</p>
 <p>There are many stream objects provided by Node.js. For instance, a
@@ -297,11 +313,11 @@ are both stream instances.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> stream = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);</code></pre>
 <p>The <code>stream</code> module is useful for creating new types of stream instances. It is
 usually not necessary to use the <code>stream</code> module to consume streams.</p>
-<h2>Organization of this document<span><a class="mark" href="#stream_organization_of_this_document" id="stream_organization_of_this_document">#</a></span></h2>
+<section><h3>Organization of this document<span><a class="mark" href="#stream_organization_of_this_document" id="stream_organization_of_this_document">#</a></span></h3>
 <p>This document contains two primary sections and a third section for notes. The
 first section explains how to use existing streams within an application. The
 second section explains how to create new types of streams.</p>
-<h2>Types of streams<span><a class="mark" href="#stream_types_of_streams" id="stream_types_of_streams">#</a></span></h2>
+</section><section><h3>Types of streams<span><a class="mark" href="#stream_types_of_streams" id="stream_types_of_streams">#</a></span></h3>
 <p>There are four fundamental stream types within Node.js:</p>
 <ul>
 <li><a href="#stream_class_stream_writable"><code>Writable</code></a>: streams to which data can be written (for example,
@@ -314,9 +330,9 @@ second section explains how to create new types of streams.</p>
 is written and read (for example, <a href="zlib.html#zlib_zlib_createdeflate_options"><code>zlib.createDeflate()</code></a>).</li>
 </ul>
 <p>Additionally, this module includes the utility functions
-<a href="#stream_stream_pipeline_streams_callback"><code>stream.pipeline()</code></a>, <a href="#stream_stream_finished_stream_options_callback"><code>stream.finished()</code></a> and
+<a href="#stream_stream_pipeline_source_transforms_destination_callback"><code>stream.pipeline()</code></a>, <a href="#stream_stream_finished_stream_options_callback"><code>stream.finished()</code></a> and
 <a href="#stream_stream_readable_from_iterable_options"><code>stream.Readable.from()</code></a>.</p>
-<h3>Object mode<span><a class="mark" href="#stream_object_mode" id="stream_object_mode">#</a></span></h3>
+<h4>Object mode<span><a class="mark" href="#stream_object_mode" id="stream_object_mode">#</a></span></h4>
 <p>All streams created by Node.js APIs operate exclusively on strings and <code>Buffer</code>
 (or <code>Uint8Array</code>) objects. It is possible, however, for stream implementations
 to work with other types of JavaScript values (with the exception of <code>null</code>,
@@ -325,11 +341,10 @@ operate in "object mode".</p>
 <p>Stream instances are switched into object mode using the <code>objectMode</code> option
 when the stream is created. Attempting to switch an existing stream into
 object mode is not safe.</p>
-<h3>Buffering<span><a class="mark" href="#stream_buffering" id="stream_buffering">#</a></span></h3>
+<h4>Buffering<span><a class="mark" href="#stream_buffering" id="stream_buffering">#</a></span></h4>
 
 <p>Both <a href="#stream_class_stream_writable"><code>Writable</code></a> and <a href="#stream_class_stream_readable"><code>Readable</code></a> streams will store data in an internal
-buffer that can be retrieved using <code>writable.writableBuffer</code> or
-<code>readable.readableBuffer</code>, respectively.</p>
+buffer.</p>
 <p>The amount of data potentially buffered depends on the <code>highWaterMark</code> option
 passed into the stream's constructor. For normal streams, the <code>highWaterMark</code>
 option specifies a <a href="#stream_highwatermark_discrepancy_after_calling_readable_setencoding">total number of bytes</a>. For streams operating
@@ -365,43 +380,47 @@ consumption of data received <em>from</em> the socket and whose <code>Writable</
 writing data <em>to</em> the socket. Because data may be written to the socket at a
 faster or slower rate than data is received, each side should
 operate (and buffer) independently of the other.</p>
-<h2>API for stream consumers<span><a class="mark" href="#stream_api_for_stream_consumers" id="stream_api_for_stream_consumers">#</a></span></h2>
+<p>The mechanics of the internal buffering are an internal implementation detail
+and may be changed at any time. However, for certain advanced implementations,
+the internal buffers can be retrieved using <code>writable.writableBuffer</code> or
+<code>readable.readableBuffer</code>. Use of these undocumented properties is discouraged.</p>
+</section><section><h3>API for stream consumers<span><a class="mark" href="#stream_api_for_stream_consumers" id="stream_api_for_stream_consumers">#</a></span></h3>
 
 <p>Almost all Node.js applications, no matter how simple, use streams in some
 manner. The following is an example of using streams in a Node.js application
 that implements an HTTP server:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
   <span class="hljs-comment">// `req` is an http.IncomingMessage, which is a readable stream.</span>
   <span class="hljs-comment">// `res` is an http.ServerResponse, which is a writable stream.</span>
 
   <span class="hljs-keyword">let</span> body = <span class="hljs-string">''</span>;
   <span class="hljs-comment">// Get the data as utf8 strings.</span>
   <span class="hljs-comment">// If an encoding is not set, Buffer objects will be received.</span>
-  req.setEncoding(<span class="hljs-string">'utf8'</span>);
+  req.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
 
   <span class="hljs-comment">// Readable streams emit 'data' events once a listener is added.</span>
-  req.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
     body += chunk;
   });
 
   <span class="hljs-comment">// The 'end' event indicates that the entire body has been received.</span>
-  req.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  req.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-keyword">try</span> {
-      <span class="hljs-keyword">const</span> data = <span class="hljs-built_in">JSON</span>.parse(body);
+      <span class="hljs-keyword">const</span> data = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(body);
       <span class="hljs-comment">// Write back something interesting to the user:</span>
-      res.write(<span class="hljs-keyword">typeof</span> data);
-      res.end();
+      res.<span class="hljs-title function_">write</span>(<span class="hljs-keyword">typeof</span> data);
+      res.<span class="hljs-title function_">end</span>();
     } <span class="hljs-keyword">catch</span> (er) {
       <span class="hljs-comment">// uh oh! bad json!</span>
-      res.statusCode = <span class="hljs-number">400</span>;
-      <span class="hljs-keyword">return</span> res.end(<span class="hljs-string">`error: <span class="hljs-subst">${er.message}</span>`</span>);
+      res.<span class="hljs-property">statusCode</span> = <span class="hljs-number">400</span>;
+      <span class="hljs-keyword">return</span> res.<span class="hljs-title function_">end</span>(<span class="hljs-string">`error: <span class="hljs-subst">${er.message}</span>`</span>);
     }
   });
 });
 
-server.listen(<span class="hljs-number">1337</span>);
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);
 
 <span class="hljs-comment">// $ curl localhost:1337 -d "{}"</span>
 <span class="hljs-comment">// object</span>
@@ -423,7 +442,7 @@ are not required to implement the stream interfaces directly and will generally
 have no reason to call <code>require('stream')</code>.</p>
 <p>Developers wishing to implement new types of streams should refer to the
 section <a href="#stream_api_for_stream_implementers">API for stream implementers</a>.</p>
-<h3>Writable streams<span><a class="mark" href="#stream_writable_streams" id="stream_writable_streams">#</a></span></h3>
+<h4>Writable streams<span><a class="mark" href="#stream_writable_streams" id="stream_writable_streams">#</a></span></h4>
 <p>Writable streams are an abstraction for a <em>destination</em> to which data is
 written.</p>
 <p>Examples of <a href="#stream_class_stream_writable"><code>Writable</code></a> streams include:</p>
@@ -444,16 +463,16 @@ written.</p>
 <p>While specific instances of <a href="#stream_class_stream_writable"><code>Writable</code></a> streams may differ in various ways,
 all <code>Writable</code> streams follow the same fundamental usage pattern as illustrated
 in the example below:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myStream = getWritableStreamSomehow();
-myStream.write(<span class="hljs-string">'some data'</span>);
-myStream.write(<span class="hljs-string">'some more data'</span>);
-myStream.end(<span class="hljs-string">'done writing data'</span>);</code></pre>
-<h4>Class: <code>stream.Writable</code><span><a class="mark" href="#stream_class_stream_writable" id="stream_class_stream_writable">#</a></span></h4>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myStream = <span class="hljs-title function_">getWritableStreamSomehow</span>();
+myStream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some data'</span>);
+myStream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some more data'</span>);
+myStream.<span class="hljs-title function_">end</span>(<span class="hljs-string">'done writing data'</span>);</code></pre>
+<h5>Class: <code>stream.Writable</code><span><a class="mark" href="#stream_class_stream_writable" id="stream_class_stream_writable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 
-<h5>Event: <code>'close'</code><span><a class="mark" href="#stream_event_close" id="stream_event_close">#</a></span></h5>
+<h6>Event: <code>'close'</code><span><a class="mark" href="#stream_event_close" id="stream_event_close">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -470,7 +489,7 @@ resources (a file descriptor, for example) have been closed. The event indicates
 that no more events will be emitted, and no further computation will occur.</p>
 <p>A <a href="#stream_class_stream_writable"><code>Writable</code></a> stream will always emit the <code>'close'</code> event if it is
 created with the <code>emitClose</code> option.</p>
-<h5>Event: <code>'drain'</code><span><a class="mark" href="#stream_event_drain" id="stream_event_drain">#</a></span></h5>
+<h6>Event: <code>'drain'</code><span><a class="mark" href="#stream_event_drain" id="stream_event_drain">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -479,30 +498,30 @@ created with the <code>emitClose</code> option.</p>
 to the stream.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Write the data to the supplied writable stream one million times.</span>
 <span class="hljs-comment">// Be attentive to back-pressure.</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">writeOneMillionTimes</span>(<span class="hljs-params">writer, data, encoding, callback</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">writeOneMillionTimes</span>(<span class="hljs-params">writer, data, encoding, callback</span>) {
   <span class="hljs-keyword">let</span> i = <span class="hljs-number">1000000</span>;
-  write();
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">write</span>(<span class="hljs-params"></span>) </span>{
+  <span class="hljs-title function_">write</span>();
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">write</span>(<span class="hljs-params"></span>) {
     <span class="hljs-keyword">let</span> ok = <span class="hljs-literal">true</span>;
     <span class="hljs-keyword">do</span> {
       i--;
       <span class="hljs-keyword">if</span> (i === <span class="hljs-number">0</span>) {
         <span class="hljs-comment">// Last time!</span>
-        writer.write(data, encoding, callback);
+        writer.<span class="hljs-title function_">write</span>(data, encoding, callback);
       } <span class="hljs-keyword">else</span> {
         <span class="hljs-comment">// See if we should continue, or wait.</span>
         <span class="hljs-comment">// Don't pass the callback, because we're not done yet.</span>
-        ok = writer.write(data, encoding);
+        ok = writer.<span class="hljs-title function_">write</span>(data, encoding);
       }
     } <span class="hljs-keyword">while</span> (i > <span class="hljs-number">0</span> &#x26;&#x26; ok);
     <span class="hljs-keyword">if</span> (i > <span class="hljs-number">0</span>) {
       <span class="hljs-comment">// Had to stop early!</span>
       <span class="hljs-comment">// Write some more once it drains.</span>
-      writer.once(<span class="hljs-string">'drain'</span>, write);
+      writer.<span class="hljs-title function_">once</span>(<span class="hljs-string">'drain'</span>, write);
     }
   }
 }</code></pre>
-<h5>Event: <code>'error'</code><span><a class="mark" href="#stream_event_error" id="stream_event_error">#</a></span></h5>
+<h6>Event: <code>'error'</code><span><a class="mark" href="#stream_event_error" id="stream_event_error">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -511,24 +530,26 @@ to the stream.</p>
 </ul>
 <p>The <code>'error'</code> event is emitted if an error occurred while writing or piping
 data. The listener callback is passed a single <code>Error</code> argument when called.</p>
-<p>The stream is not closed when the <code>'error'</code> event is emitted unless the
-<a href="#stream_new_stream_writable_options"><code>autoDestroy</code></a> option was set to <code>true</code> when creating the
+<p>The stream is closed when the <code>'error'</code> event is emitted unless the
+<a href="#stream_new_stream_writable_options"><code>autoDestroy</code></a> option was set to <code>false</code> when creating the
 stream.</p>
-<h5>Event: <code>'finish'</code><span><a class="mark" href="#stream_event_finish" id="stream_event_finish">#</a></span></h5>
+<p>After <code>'error'</code>, no further events other than <code>'close'</code> <em>should</em> be emitted
+(including <code>'error'</code> events).</p>
+<h6>Event: <code>'finish'</code><span><a class="mark" href="#stream_event_finish" id="stream_event_finish">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 <p>The <code>'finish'</code> event is emitted after the <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> method
 has been called, and all data has been flushed to the underlying system.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = getWritableStreamSomehow();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = <span class="hljs-title function_">getWritableStreamSomehow</span>();
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">100</span>; i++) {
-  writer.write(<span class="hljs-string">`hello, #<span class="hljs-subst">${i}</span>!\n`</span>);
+  writer.<span class="hljs-title function_">write</span>(<span class="hljs-string">`hello, #<span class="hljs-subst">${i}</span>!\n`</span>);
 }
-writer.on(<span class="hljs-string">'finish'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'All writes are now complete.'</span>);
+writer.<span class="hljs-title function_">on</span>(<span class="hljs-string">'finish'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'All writes are now complete.'</span>);
 });
-writer.end(<span class="hljs-string">'This is the end\n'</span>);</code></pre>
-<h5>Event: <code>'pipe'</code><span><a class="mark" href="#stream_event_pipe" id="stream_event_pipe">#</a></span></h5>
+writer.<span class="hljs-title function_">end</span>(<span class="hljs-string">'This is the end\n'</span>);</code></pre>
+<h6>Event: <code>'pipe'</code><span><a class="mark" href="#stream_event_pipe" id="stream_event_pipe">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -537,14 +558,14 @@ writer.end(<span class="hljs-string">'This is the end\n'</span>);</code></pre>
 </ul>
 <p>The <code>'pipe'</code> event is emitted when the <a href="#stream_readable_pipe_destination_options"><code>stream.pipe()</code></a> method is called on
 a readable stream, adding this writable to its set of destinations.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = getWritableStreamSomehow();
-<span class="hljs-keyword">const</span> reader = getReadableStreamSomehow();
-writer.on(<span class="hljs-string">'pipe'</span>, <span class="hljs-function">(<span class="hljs-params">src</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Something is piping into the writer.'</span>);
-  assert.equal(src, reader);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = <span class="hljs-title function_">getWritableStreamSomehow</span>();
+<span class="hljs-keyword">const</span> reader = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+writer.<span class="hljs-title function_">on</span>(<span class="hljs-string">'pipe'</span>, <span class="hljs-function">(<span class="hljs-params">src</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Something is piping into the writer.'</span>);
+  assert.<span class="hljs-title function_">equal</span>(src, reader);
 });
-reader.pipe(writer);</code></pre>
-<h5>Event: <code>'unpipe'</code><span><a class="mark" href="#stream_event_unpipe" id="stream_event_unpipe">#</a></span></h5>
+reader.<span class="hljs-title function_">pipe</span>(writer);</code></pre>
+<h6>Event: <code>'unpipe'</code><span><a class="mark" href="#stream_event_unpipe" id="stream_event_unpipe">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -557,15 +578,15 @@ on a <a href="#stream_class_stream_readable"><code>Readable</code></a> stream, r
 destinations.</p>
 <p>This is also emitted in case this <a href="#stream_class_stream_writable"><code>Writable</code></a> stream emits an error when a
 <a href="#stream_class_stream_readable"><code>Readable</code></a> stream pipes into it.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = getWritableStreamSomehow();
-<span class="hljs-keyword">const</span> reader = getReadableStreamSomehow();
-writer.on(<span class="hljs-string">'unpipe'</span>, <span class="hljs-function">(<span class="hljs-params">src</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Something has stopped piping into the writer.'</span>);
-  assert.equal(src, reader);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> writer = <span class="hljs-title function_">getWritableStreamSomehow</span>();
+<span class="hljs-keyword">const</span> reader = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+writer.<span class="hljs-title function_">on</span>(<span class="hljs-string">'unpipe'</span>, <span class="hljs-function">(<span class="hljs-params">src</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Something has stopped piping into the writer.'</span>);
+  assert.<span class="hljs-title function_">equal</span>(src, reader);
 });
-reader.pipe(writer);
-reader.unpipe(writer);</code></pre>
-<h5><code>writable.cork()</code><span><a class="mark" href="#stream_writable_cork" id="stream_writable_cork">#</a></span></h5>
+reader.<span class="hljs-title function_">pipe</span>(writer);
+reader.<span class="hljs-title function_">unpipe</span>(writer);</code></pre>
+<h6><code>writable.cork()</code><span><a class="mark" href="#stream_writable_cork" id="stream_writable_cork">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -581,9 +602,17 @@ situation where data is being buffered while waiting for the first small chunk
 to be processed. However, use of <code>writable.cork()</code> without implementing
 <code>writable._writev()</code> may have an adverse effect on throughput.</p>
 <p>See also: <a href="#stream_writable_uncork"><code>writable.uncork()</code></a>, <a href="#stream_writable_writev_chunks_callback"><code>writable._writev()</code></a>.</p>
-<h5><code>writable.destroy([error])</code><span><a class="mark" href="#stream_writable_destroy_error" id="stream_writable_destroy_error">#</a></span></h5>
+<h6><code>writable.destroy([error])</code><span><a class="mark" href="#stream_writable_destroy_error" id="stream_writable_destroy_error">#</a></span></h6>
 <div class="api_metadata">
-<span>Added in: v8.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Work as a no-op on a stream that has already been destroyed.</p></td></tr>
+<tr><td>v8.0.0</td>
+<td><p><span>Added in: v8.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Optional, an error to emit with <code>'error'</code> event.</li>
@@ -596,10 +625,32 @@ an <code>ERR_STREAM_DESTROYED</code> error.
 This is a destructive and immediate way to destroy a stream. Previous calls to
 <code>write()</code> may not have drained, and may trigger an <code>ERR_STREAM_DESTROYED</code> error.
 Use <code>end()</code> instead of destroy if data should flush before close, or wait for
-the <code>'drain'</code> event before destroying the stream.
-Implementors should not override this method,
+the <code>'drain'</code> event before destroying the stream.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><pre><code class="language-js cjs"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">const</span> myStream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
+
+<span class="hljs-keyword">const</span> fooErr = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'foo error'</span>);
+myStream.<span class="hljs-title function_">destroy</span>(fooErr);
+myStream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-function">(<span class="hljs-params">fooErr</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(fooErr.<span class="hljs-property">message</span>)); <span class="hljs-comment">// foo error</span></code></pre><code class="language-js cjs"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">const</span> myStream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
+
+myStream.<span class="hljs-title function_">destroy</span>();
+myStream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, <span class="hljs-keyword">function</span> <span class="hljs-title function_">wontHappen</span>(<span class="hljs-params"></span>) {});</code></pre>
+<pre><code class="language-js cjs"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">const</span> myStream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
+myStream.<span class="hljs-title function_">destroy</span>();
+
+myStream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-function">(<span class="hljs-params">error</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(error.<span class="hljs-property">code</span>));
+<span class="hljs-comment">// ERR_STREAM_DESTROYED</span></code></pre>
+<p>Once <code>destroy()</code> has been called any further calls will be a no-op and no
+further errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>
+<p>Implementors should not override this method,
 but instead implement <a href="#stream_writable_destroy_err_callback"><code>writable._destroy()</code></a>.</p>
-<h5><code>writable.destroyed</code><span><a class="mark" href="#stream_writable_destroyed" id="stream_writable_destroyed">#</a></span></h5>
+<h6><code>writable.destroyed</code><span><a class="mark" href="#stream_writable_destroyed" id="stream_writable_destroyed">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -607,11 +658,20 @@ but instead implement <a href="#stream_writable_destroy_err_callback"><code>writ
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Is <code>true</code> after <a href="#stream_writable_destroy_error"><code>writable.destroy()</code></a> has been called.</p>
-<h5><code>writable.end([chunk[, encoding]][, callback])</code><span><a class="mark" href="#stream_writable_end_chunk_encoding_callback" id="stream_writable_end_chunk_encoding_callback">#</a></span></h5>
+<pre><code class="language-js cjs"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">const</span> myStream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myStream.<span class="hljs-property">destroyed</span>); <span class="hljs-comment">// false</span>
+myStream.<span class="hljs-title function_">destroy</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myStream.<span class="hljs-property">destroyed</span>); <span class="hljs-comment">// true</span></code></pre>
+<h6><code>writable.end([chunk[, encoding]][, callback])</code><span><a class="mark" href="#stream_writable_end_chunk_encoding_callback" id="stream_writable_end_chunk_encoding_callback">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>callback</code> is invoked if 'finish' or 'error' is emitted.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>This method now returns a reference to <code>writable</code>.</p></td></tr>
 <tr><td>v8.0.0</td>
@@ -627,23 +687,24 @@ not operating in object mode, <code>chunk</code> must be a string, <code>Buffer<
 <code>Uint8Array</code>. For object mode streams, <code>chunk</code> may be any JavaScript value
 other than <code>null</code>.</li>
 <li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The encoding if <code>chunk</code> is a string</li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional callback for when the stream is finished</li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Optional callback for when the stream finishes
+or errors</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this" class="type">&#x3C;this></a></li>
 </ul>
 <p>Calling the <code>writable.end()</code> method signals that no more data will be written
 to the <a href="#stream_class_stream_writable"><code>Writable</code></a>. The optional <code>chunk</code> and <code>encoding</code> arguments allow one
 final additional chunk of data to be written immediately before closing the
 stream. If provided, the optional <code>callback</code> function is attached as a listener
-for the <a href="#stream_event_finish"><code>'finish'</code></a> event.</p>
+for the <a href="#stream_event_finish"><code>'finish'</code></a> and the <code>'error'</code> event.</p>
 <p>Calling the <a href="#stream_writable_write_chunk_encoding_callback"><code>stream.write()</code></a> method after calling
 <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> will raise an error.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Write 'hello, ' and then end with 'world!'.</span>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> file = fs.createWriteStream(<span class="hljs-string">'example.txt'</span>);
-file.write(<span class="hljs-string">'hello, '</span>);
-file.end(<span class="hljs-string">'world!'</span>);
+<span class="hljs-keyword">const</span> file = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'example.txt'</span>);
+file.<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello, '</span>);
+file.<span class="hljs-title function_">end</span>(<span class="hljs-string">'world!'</span>);
 <span class="hljs-comment">// Writing more now is not allowed!</span></code></pre>
-<h5><code>writable.setDefaultEncoding(encoding)</code><span><a class="mark" href="#stream_writable_setdefaultencoding_encoding" id="stream_writable_setdefaultencoding_encoding">#</a></span></h5>
+<h6><code>writable.setDefaultEncoding(encoding)</code><span><a class="mark" href="#stream_writable_setdefaultencoding_encoding" id="stream_writable_setdefaultencoding_encoding">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -661,7 +722,7 @@ file.end(<span class="hljs-string">'world!'</span>);
 </ul>
 <p>The <code>writable.setDefaultEncoding()</code> method sets the default <code>encoding</code> for a
 <a href="#stream_class_stream_writable"><code>Writable</code></a> stream.</p>
-<h5><code>writable.uncork()</code><span><a class="mark" href="#stream_writable_uncork" id="stream_writable_uncork">#</a></span></h5>
+<h6><code>writable.uncork()</code><span><a class="mark" href="#stream_writable_uncork" id="stream_writable_uncork">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.11.2</span>
 </div>
@@ -671,32 +732,33 @@ file.end(<span class="hljs-string">'world!'</span>);
 of writes to a stream, it is recommended that calls to <code>writable.uncork()</code> be
 deferred using <code>process.nextTick()</code>. Doing so allows batching of all
 <code>writable.write()</code> calls that occur within a given Node.js event loop phase.</p>
-<pre><code class="language-js">stream.cork();
-stream.write(<span class="hljs-string">'some '</span>);
-stream.write(<span class="hljs-string">'data '</span>);
-process.nextTick(<span class="hljs-function">() =></span> stream.uncork());</code></pre>
+<pre><code class="language-js">stream.<span class="hljs-title function_">cork</span>();
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some '</span>);
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'data '</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> stream.<span class="hljs-title function_">uncork</span>());</code></pre>
 <p>If the <a href="#stream_writable_cork"><code>writable.cork()</code></a> method is called multiple times on a stream, the
 same number of calls to <code>writable.uncork()</code> must be called to flush the buffered
 data.</p>
-<pre><code class="language-js">stream.cork();
-stream.write(<span class="hljs-string">'some '</span>);
-stream.cork();
-stream.write(<span class="hljs-string">'data '</span>);
-process.nextTick(<span class="hljs-function">() =></span> {
-  stream.uncork();
+<pre><code class="language-js">stream.<span class="hljs-title function_">cork</span>();
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'some '</span>);
+stream.<span class="hljs-title function_">cork</span>();
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'data '</span>);
+process.<span class="hljs-title function_">nextTick</span>(<span class="hljs-function">() =></span> {
+  stream.<span class="hljs-title function_">uncork</span>();
   <span class="hljs-comment">// The data will not be flushed until uncork() is called a second time.</span>
-  stream.uncork();
+  stream.<span class="hljs-title function_">uncork</span>();
 });</code></pre>
 <p>See also: <a href="#stream_writable_cork"><code>writable.cork()</code></a>.</p>
-<h5><code>writable.writable</code><span><a class="mark" href="#stream_writable_writable" id="stream_writable_writable">#</a></span></h5>
+<h6><code>writable.writable</code><span><a class="mark" href="#stream_writable_writable" id="stream_writable_writable">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v11.4.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Is <code>true</code> if it is safe to call <a href="#stream_writable_write_chunk_encoding_callback"><code>writable.write()</code></a>.</p>
-<h5><code>writable.writableEnded</code><span><a class="mark" href="#stream_writable_writableended" id="stream_writable_writableended">#</a></span></h5>
+<p>Is <code>true</code> if it is safe to call <a href="#stream_writable_write_chunk_encoding_callback"><code>writable.write()</code></a>, which means
+the stream has not been destroyed, errored or ended.</p>
+<h6><code>writable.writableEnded</code><span><a class="mark" href="#stream_writable_writableended" id="stream_writable_writableended">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -706,16 +768,16 @@ process.nextTick(<span class="hljs-function">() =></span> {
 <p>Is <code>true</code> after <a href="#stream_writable_end_chunk_encoding_callback"><code>writable.end()</code></a> has been called. This property
 does not indicate whether the data has been flushed, for this use
 <a href="#stream_writable_writablefinished"><code>writable.writableFinished</code></a> instead.</p>
-<h5><code>writable.writableCorked</code><span><a class="mark" href="#stream_writable_writablecorked" id="stream_writable_writablecorked">#</a></span></h5>
+<h6><code>writable.writableCorked</code><span><a class="mark" href="#stream_writable_writablecorked" id="stream_writable_writablecorked">#</a></span></h6>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Number of times <a href="#stream_writable_uncork"><code>writable.uncork()</code></a> needs to be
 called in order to fully uncork the stream.</p>
-<h5><code>writable.writableFinished</code><span><a class="mark" href="#stream_writable_writablefinished" id="stream_writable_writablefinished">#</a></span></h5>
+<h6><code>writable.writableFinished</code><span><a class="mark" href="#stream_writable_writablefinished" id="stream_writable_writablefinished">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.6.0</span>
 </div>
@@ -723,7 +785,7 @@ called in order to fully uncork the stream.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Is set to <code>true</code> immediately before the <a href="#stream_event_finish"><code>'finish'</code></a> event is emitted.</p>
-<h5><code>writable.writableHighWaterMark</code><span><a class="mark" href="#stream_writable_writablehighwatermark" id="stream_writable_writablehighwatermark">#</a></span></h5>
+<h6><code>writable.writableHighWaterMark</code><span><a class="mark" href="#stream_writable_writablehighwatermark" id="stream_writable_writablehighwatermark">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.3.0</span>
 </div>
@@ -732,7 +794,7 @@ called in order to fully uncork the stream.</p>
 </ul>
 <p>Return the value of <code>highWaterMark</code> passed when constructing this
 <code>Writable</code>.</p>
-<h5><code>writable.writableLength</code><span><a class="mark" href="#stream_writable_writablelength" id="stream_writable_writablelength">#</a></span></h5>
+<h6><code>writable.writableLength</code><span><a class="mark" href="#stream_writable_writablelength" id="stream_writable_writablelength">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -742,7 +804,15 @@ called in order to fully uncork the stream.</p>
 <p>This property contains the number of bytes (or objects) in the queue
 ready to be written. The value provides introspection data regarding
 the status of the <code>highWaterMark</code>.</p>
-<h5><code>writable.writableObjectMode</code><span><a class="mark" href="#stream_writable_writableobjectmode" id="stream_writable_writableobjectmode">#</a></span></h5>
+<h6><code>writable.writableNeedDrain</code><span><a class="mark" href="#stream_writable_writableneeddrain" id="stream_writable_writableneeddrain">#</a></span></h6>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Is <code>true</code> if the stream's buffer has been full and stream will emit <code>'drain'</code>.</p>
+<h6><code>writable.writableObjectMode</code><span><a class="mark" href="#stream_writable_writableobjectmode" id="stream_writable_writableobjectmode">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
@@ -750,7 +820,7 @@ the status of the <code>highWaterMark</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Getter for the property <code>objectMode</code> of a given <code>Writable</code> stream.</p>
-<h5><code>writable.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#stream_writable_write_chunk_encoding_callback" id="stream_writable_write_chunk_encoding_callback">#</a></span></h5>
+<h6><code>writable.write(chunk[, encoding][, callback])</code><span><a class="mark" href="#stream_writable_write_chunk_encoding_callback" id="stream_writable_write_chunk_encoding_callback">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -769,8 +839,8 @@ the status of the <code>highWaterMark</code>.</p>
 not operating in object mode, <code>chunk</code> must be a string, <code>Buffer</code> or
 <code>Uint8Array</code>. For object mode streams, <code>chunk</code> may be any JavaScript value
 other than <code>null</code>.</li>
-<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The encoding, if <code>chunk</code> is a string. <strong>Default:</strong> <code>'utf8'</code></li>
-<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Callback for when this chunk of data is flushed</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Null_type" class="type">&#x3C;null></a> The encoding, if <code>chunk</code> is a string. <strong>Default:</strong> <code>'utf8'</code></li>
+<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Callback for when this chunk of data is flushed.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>false</code> if the stream wishes for the calling code to
 wait for the <code>'drain'</code> event to be emitted before continuing to write
 additional data; otherwise <code>true</code>.</li>
@@ -779,7 +849,8 @@ additional data; otherwise <code>true</code>.</li>
 supplied <code>callback</code> once the data has been fully handled. If an error
 occurs, the <code>callback</code> <em>may or may not</em> be called with the error as its
 first argument. To reliably detect write errors, add a listener for the
-<code>'error'</code> event.</p>
+<code>'error'</code> event. The <code>callback</code> is called asynchronously and before <code>'error'</code> is
+emitted.</p>
 <p>The return value is <code>true</code> if the internal buffer is less than the
 <code>highWaterMark</code> configured when the stream was created after admitting <code>chunk</code>.
 If <code>false</code> is returned, further attempts to write data to the stream should
@@ -805,20 +876,20 @@ recommended to encapsulate the logic into a <a href="#stream_class_stream_readab
 <a href="#stream_readable_pipe_destination_options"><code>stream.pipe()</code></a>. However, if calling <code>write()</code> is preferred, it is
 possible to respect backpressure and avoid memory issues using the
 <a href="#stream_event_drain"><code>'drain'</code></a> event:</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">write</span>(<span class="hljs-params">data, cb</span>) </span>{
-  <span class="hljs-keyword">if</span> (!stream.write(data)) {
-    stream.once(<span class="hljs-string">'drain'</span>, cb);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">write</span>(<span class="hljs-params">data, cb</span>) {
+  <span class="hljs-keyword">if</span> (!stream.<span class="hljs-title function_">write</span>(data)) {
+    stream.<span class="hljs-title function_">once</span>(<span class="hljs-string">'drain'</span>, cb);
   } <span class="hljs-keyword">else</span> {
-    process.nextTick(cb);
+    process.<span class="hljs-title function_">nextTick</span>(cb);
   }
 }
 
 <span class="hljs-comment">// Wait for cb to be called before doing any other write.</span>
-write(<span class="hljs-string">'hello'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Write completed, do more writes now.'</span>);
+<span class="hljs-title function_">write</span>(<span class="hljs-string">'hello'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Write completed, do more writes now.'</span>);
 });</code></pre>
 <p>A <code>Writable</code> stream in object mode will always ignore the <code>encoding</code> argument.</p>
-<h3>Readable streams<span><a class="mark" href="#stream_readable_streams" id="stream_readable_streams">#</a></span></h3>
+<h4>Readable streams<span><a class="mark" href="#stream_readable_streams" id="stream_readable_streams">#</a></span></h4>
 <p>Readable streams are an abstraction for a <em>source</em> from which data is
 consumed.</p>
 <p>Examples of <code>Readable</code> streams include:</p>
@@ -834,7 +905,7 @@ consumed.</p>
 </ul>
 <p>All <a href="#stream_class_stream_readable"><code>Readable</code></a> streams implement the interface defined by the
 <code>stream.Readable</code> class.</p>
-<h4>Two reading modes<span><a class="mark" href="#stream_two_reading_modes" id="stream_two_reading_modes">#</a></span></h4>
+<h5>Two reading modes<span><a class="mark" href="#stream_two_reading_modes" id="stream_two_reading_modes">#</a></span></h5>
 <p><code>Readable</code> streams effectively operate in one of two modes: flowing and
 paused. These modes are separate from <a href="#stream_object_mode">object mode</a>.
 A <a href="#stream_class_stream_readable"><code>Readable</code></a> stream can be in object mode or not, regardless of whether
@@ -883,7 +954,7 @@ stop flowing, and the data has to be consumed via
 <a href="#stream_readable_read_size"><code>readable.read()</code></a>. If the <a href="#stream_event_readable"><code>'readable'</code></a> event handler is
 removed, then the stream will start flowing again if there is a
 <a href="#stream_event_data"><code>'data'</code></a> event handler.</p>
-<h4>Three states<span><a class="mark" href="#stream_three_states" id="stream_three_states">#</a></span></h4>
+<h5>Three states<span><a class="mark" href="#stream_three_states" id="stream_three_states">#</a></span></h5>
 <p>The "two modes" of operation for a <code>Readable</code> stream are a simplified
 abstraction for the more complicated internal state management that is happening
 within the <code>Readable</code> stream implementation.</p>
@@ -905,20 +976,20 @@ will cause the <code>readable.readableFlowing</code> to be set as <code>false</c
 temporarily halting the flowing of events but <em>not</em> halting the generation of
 data. While in this state, attaching a listener for the <code>'data'</code> event
 will not switch <code>readable.readableFlowing</code> to <code>true</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { PassThrough, Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-<span class="hljs-keyword">const</span> pass = <span class="hljs-keyword">new</span> PassThrough();
-<span class="hljs-keyword">const</span> writable = <span class="hljs-keyword">new</span> Writable();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">PassThrough</span>, <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> pass = <span class="hljs-keyword">new</span> <span class="hljs-title class_">PassThrough</span>();
+<span class="hljs-keyword">const</span> writable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>();
 
-pass.pipe(writable);
-pass.unpipe(writable);
+pass.<span class="hljs-title function_">pipe</span>(writable);
+pass.<span class="hljs-title function_">unpipe</span>(writable);
 <span class="hljs-comment">// readableFlowing is now false.</span>
 
-pass.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-built_in">console</span>.log(chunk.toString()); });
-pass.write(<span class="hljs-string">'ok'</span>);  <span class="hljs-comment">// Will not emit 'data'.</span>
-pass.resume();     <span class="hljs-comment">// Must be called to make stream emit 'data'.</span></code></pre>
+pass.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> { <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk.<span class="hljs-title function_">toString</span>()); });
+pass.<span class="hljs-title function_">write</span>(<span class="hljs-string">'ok'</span>);  <span class="hljs-comment">// Will not emit 'data'.</span>
+pass.<span class="hljs-title function_">resume</span>();     <span class="hljs-comment">// Must be called to make stream emit 'data'.</span></code></pre>
 <p>While <code>readable.readableFlowing</code> is <code>false</code>, data may be accumulating
 within the stream's internal buffer.</p>
-<h4>Choose one API style<span><a class="mark" href="#stream_choose_one_api_style" id="stream_choose_one_api_style">#</a></span></h4>
+<h5>Choose one API style<span><a class="mark" href="#stream_choose_one_api_style" id="stream_choose_one_api_style">#</a></span></h5>
 <p>The <code>Readable</code> stream API evolved across multiple Node.js versions and provides
 multiple methods of consuming stream data. In general, developers should choose
 <em>one</em> of the methods of consuming data and <em>should never</em> use multiple methods
@@ -930,12 +1001,12 @@ implemented to provide the easiest way of consuming stream data. Developers that
 require more fine-grained control over the transfer and generation of data can
 use the <a href="events.html#events_class_eventemitter"><code>EventEmitter</code></a> and <code>readable.on('readable')</code>/<code>readable.read()</code>
 or the <code>readable.pause()</code>/<code>readable.resume()</code> APIs.</p>
-<h4>Class: <code>stream.Readable</code><span><a class="mark" href="#stream_class_stream_readable" id="stream_class_stream_readable">#</a></span></h4>
+<h5>Class: <code>stream.Readable</code><span><a class="mark" href="#stream_class_stream_readable" id="stream_class_stream_readable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 
-<h5>Event: <code>'close'</code><span><a class="mark" href="#stream_event_close_1" id="stream_event_close_1">#</a></span></h5>
+<h6>Event: <code>'close'</code><span><a class="mark" href="#stream_event_close_1" id="stream_event_close_1">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -952,7 +1023,7 @@ resources (a file descriptor, for example) have been closed. The event indicates
 that no more events will be emitted, and no further computation will occur.</p>
 <p>A <a href="#stream_class_stream_readable"><code>Readable</code></a> stream will always emit the <code>'close'</code> event if it is
 created with the <code>emitClose</code> option.</p>
-<h5>Event: <code>'data'</code><span><a class="mark" href="#stream_event_data" id="stream_event_data">#</a></span></h5>
+<h6>Event: <code>'data'</code><span><a class="mark" href="#stream_event_data" id="stream_event_data">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -975,11 +1046,11 @@ soon as it is available.</p>
 encoding has been specified for the stream using the
 <code>readable.setEncoding()</code> method; otherwise the data will be passed as a
 <code>Buffer</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
 });</code></pre>
-<h5>Event: <code>'end'</code><span><a class="mark" href="#stream_event_end" id="stream_event_end">#</a></span></h5>
+<h6>Event: <code>'end'</code><span><a class="mark" href="#stream_event_end" id="stream_event_end">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -989,14 +1060,14 @@ the stream.</p>
 consumed. This can be accomplished by switching the stream into flowing mode,
 or by calling <a href="#stream_readable_read_size"><code>stream.read()</code></a> repeatedly until all data has been
 consumed.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
 });
-readable.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'There will be no more data.'</span>);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'There will be no more data.'</span>);
 });</code></pre>
-<h5>Event: <code>'error'</code><span><a class="mark" href="#stream_event_error_1" id="stream_event_error_1">#</a></span></h5>
+<h6>Event: <code>'error'</code><span><a class="mark" href="#stream_event_error_1" id="stream_event_error_1">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1008,13 +1079,13 @@ Typically, this may occur if the underlying stream is unable to generate data
 due to an underlying internal failure, or when a stream implementation attempts
 to push an invalid chunk of data.</p>
 <p>The listener callback will be passed a single <code>Error</code> object.</p>
-<h5>Event: <code>'pause'</code><span><a class="mark" href="#stream_event_pause" id="stream_event_pause">#</a></span></h5>
+<h6>Event: <code>'pause'</code><span><a class="mark" href="#stream_event_pause" id="stream_event_pause">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 <p>The <code>'pause'</code> event is emitted when <a href="#stream_readable_pause"><code>stream.pause()</code></a> is called
 and <code>readableFlowing</code> is not <code>false</code>.</p>
-<h5>Event: <code>'readable'</code><span><a class="mark" href="#stream_event_readable" id="stream_event_readable">#</a></span></h5>
+<h6>Event: <code>'readable'</code><span><a class="mark" href="#stream_event_readable" id="stream_event_readable">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1031,13 +1102,13 @@ and <code>readableFlowing</code> is not <code>false</code>.</p>
 <p>The <code>'readable'</code> event is emitted when there is data available to be read from
 the stream. In some cases, attaching a listener for the <code>'readable'</code> event will
 cause some amount of data to be read into an internal buffer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
   <span class="hljs-comment">// There is some data to read now.</span>
   <span class="hljs-keyword">let</span> data;
 
-  <span class="hljs-keyword">while</span> (data = <span class="hljs-built_in">this</span>.read()) {
-    <span class="hljs-built_in">console</span>.log(data);
+  <span class="hljs-keyword">while</span> (data = <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">read</span>()) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
   }
 });</code></pre>
 <p>The <code>'readable'</code> event will also be emitted once the end of the stream data
@@ -1048,15 +1119,15 @@ reached. In the former case, <a href="#stream_readable_read_size"><code>stream.r
 available data. In the latter case, <a href="#stream_readable_read_size"><code>stream.read()</code></a> will return
 <code>null</code>. For instance, in the following example, <code>foo.txt</code> is an empty file:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> rr = fs.createReadStream(<span class="hljs-string">'foo.txt'</span>);
-rr.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`readable: <span class="hljs-subst">${rr.read()}</span>`</span>);
+<span class="hljs-keyword">const</span> rr = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'foo.txt'</span>);
+rr.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`readable: <span class="hljs-subst">${rr.read()}</span>`</span>);
 });
-rr.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'end'</span>);
+rr.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'end'</span>);
 });</code></pre>
 <p>The output of running this script is:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node test.js</span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node test.js</span>
 readable: null
 end</code></pre>
 <p>In general, the <code>readable.pipe()</code> and <code>'data'</code> event mechanisms are easier to
@@ -1069,15 +1140,23 @@ only when <a href="#stream_readable_read_size"><code>stream.read()</code></a> is
 If there are <code>'data'</code> listeners when <code>'readable'</code> is removed, the stream
 will start flowing, i.e. <code>'data'</code> events will be emitted without calling
 <code>.resume()</code>.</p>
-<h5>Event: <code>'resume'</code><span><a class="mark" href="#stream_event_resume" id="stream_event_resume">#</a></span></h5>
+<h6>Event: <code>'resume'</code><span><a class="mark" href="#stream_event_resume" id="stream_event_resume">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
 <p>The <code>'resume'</code> event is emitted when <a href="#stream_readable_resume"><code>stream.resume()</code></a> is
 called and <code>readableFlowing</code> is not <code>true</code>.</p>
-<h5><code>readable.destroy([error])</code><span><a class="mark" href="#stream_readable_destroy_error" id="stream_readable_destroy_error">#</a></span></h5>
+<h6><code>readable.destroy([error])</code><span><a class="mark" href="#stream_readable_destroy_error" id="stream_readable_destroy_error">#</a></span></h6>
 <div class="api_metadata">
-<span>Added in: v8.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Work as a no-op on a stream that has already been destroyed.</p></td></tr>
+<tr><td>v8.0.0</td>
+<td><p><span>Added in: v8.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Error which will be passed as payload in <code>'error'</code> event</li>
@@ -1086,10 +1165,12 @@ called and <code>readableFlowing</code> is not <code>true</code>.</p>
 <p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>
 event (unless <code>emitClose</code> is set to <code>false</code>). After this call, the readable
 stream will release any internal resources and subsequent calls to <code>push()</code>
-will be ignored.
-Implementors should not override this method, but instead implement
+will be ignored.</p>
+<p>Once <code>destroy()</code> has been called any further calls will be a no-op and no
+further errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>
+<p>Implementors should not override this method, but instead implement
 <a href="#stream_readable_destroy_err_callback"><code>readable._destroy()</code></a>.</p>
-<h5><code>readable.destroyed</code><span><a class="mark" href="#stream_readable_destroyed" id="stream_readable_destroyed">#</a></span></h5>
+<h6><code>readable.destroyed</code><span><a class="mark" href="#stream_readable_destroyed" id="stream_readable_destroyed">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -1097,7 +1178,7 @@ Implementors should not override this method, but instead implement
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Is <code>true</code> after <a href="#stream_readable_destroy_error"><code>readable.destroy()</code></a> has been called.</p>
-<h5><code>readable.isPaused()</code><span><a class="mark" href="#stream_readable_ispaused" id="stream_readable_ispaused">#</a></span></h5>
+<h6><code>readable.isPaused()</code><span><a class="mark" href="#stream_readable_ispaused" id="stream_readable_ispaused">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.11.14</span>
 </div>
@@ -1108,14 +1189,14 @@ Implementors should not override this method, but instead implement
 <code>Readable</code>. This is used primarily by the mechanism that underlies the
 <code>readable.pipe()</code> method. In most typical cases, there will be no reason to
 use this method directly.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-keyword">new</span> stream.Readable();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-keyword">new</span> stream.<span class="hljs-title class_">Readable</span>();
 
-readable.isPaused(); <span class="hljs-comment">// === false</span>
-readable.pause();
-readable.isPaused(); <span class="hljs-comment">// === true</span>
-readable.resume();
-readable.isPaused(); <span class="hljs-comment">// === false</span></code></pre>
-<h5><code>readable.pause()</code><span><a class="mark" href="#stream_readable_pause" id="stream_readable_pause">#</a></span></h5>
+readable.<span class="hljs-title function_">isPaused</span>(); <span class="hljs-comment">// === false</span>
+readable.<span class="hljs-title function_">pause</span>();
+readable.<span class="hljs-title function_">isPaused</span>(); <span class="hljs-comment">// === true</span>
+readable.<span class="hljs-title function_">resume</span>();
+readable.<span class="hljs-title function_">isPaused</span>(); <span class="hljs-comment">// === false</span></code></pre>
+<h6><code>readable.pause()</code><span><a class="mark" href="#stream_readable_pause" id="stream_readable_pause">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1125,19 +1206,19 @@ readable.isPaused(); <span class="hljs-comment">// === false</span></code></pre>
 <p>The <code>readable.pause()</code> method will cause a stream in flowing mode to stop
 emitting <a href="#stream_event_data"><code>'data'</code></a> events, switching out of flowing mode. Any data that
 becomes available will remain in the internal buffer.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
-  readable.pause();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'There will be no additional data for 1 second.'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received <span class="hljs-subst">${chunk.length}</span> bytes of data.`</span>);
+  readable.<span class="hljs-title function_">pause</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'There will be no additional data for 1 second.'</span>);
   <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Now data will start flowing again.'</span>);
-    readable.resume();
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Now data will start flowing again.'</span>);
+    readable.<span class="hljs-title function_">resume</span>();
   }, <span class="hljs-number">1000</span>);
 });</code></pre>
 <p>The <code>readable.pause()</code> method has no effect if there is a <code>'readable'</code>
 event listener.</p>
-<h5><code>readable.pipe(destination[, options])</code><span><a class="mark" href="#stream_readable_pipe_destination_options" id="stream_readable_pipe_destination_options">#</a></span></h5>
+<h6><code>readable.pipe(destination[, options])</code><span><a class="mark" href="#stream_readable_pipe_destination_options" id="stream_readable_pipe_destination_options">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1159,26 +1240,26 @@ so that the destination <code>Writable</code> stream is not overwhelmed by a fas
 <p>The following example pipes all of the data from the <code>readable</code> into a file
 named <code>file.txt</code>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'file.txt'</span>);
+<span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+<span class="hljs-keyword">const</span> writable = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'file.txt'</span>);
 <span class="hljs-comment">// All the data from readable goes into 'file.txt'.</span>
-readable.pipe(writable);</code></pre>
+readable.<span class="hljs-title function_">pipe</span>(writable);</code></pre>
 <p>It is possible to attach multiple <code>Writable</code> streams to a single <code>Readable</code>
 stream.</p>
 <p>The <code>readable.pipe()</code> method returns a reference to the <em>destination</em> stream
 making it possible to set up chains of piped streams:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> r = fs.createReadStream(<span class="hljs-string">'file.txt'</span>);
-<span class="hljs-keyword">const</span> z = zlib.createGzip();
-<span class="hljs-keyword">const</span> w = fs.createWriteStream(<span class="hljs-string">'file.txt.gz'</span>);
-r.pipe(z).pipe(w);</code></pre>
+<span class="hljs-keyword">const</span> r = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'file.txt'</span>);
+<span class="hljs-keyword">const</span> z = zlib.<span class="hljs-title function_">createGzip</span>();
+<span class="hljs-keyword">const</span> w = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'file.txt.gz'</span>);
+r.<span class="hljs-title function_">pipe</span>(z).<span class="hljs-title function_">pipe</span>(w);</code></pre>
 <p>By default, <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> is called on the destination <code>Writable</code>
 stream when the source <code>Readable</code> stream emits <a href="#stream_event_end"><code>'end'</code></a>, so that the
 destination is no longer writable. To disable this default behavior, the <code>end</code>
 option can be passed as <code>false</code>, causing the destination stream to remain open:</p>
-<pre><code class="language-js">reader.pipe(writer, { <span class="hljs-attr">end</span>: <span class="hljs-literal">false</span> });
-reader.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  writer.end(<span class="hljs-string">'Goodbye\n'</span>);
+<pre><code class="language-js">reader.<span class="hljs-title function_">pipe</span>(writer, { <span class="hljs-attr">end</span>: <span class="hljs-literal">false</span> });
+reader.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  writer.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Goodbye\n'</span>);
 });</code></pre>
 <p>One important caveat is that if the <code>Readable</code> stream emits an error during
 processing, the <code>Writable</code> destination <em>is not closed</em> automatically. If an
@@ -1186,7 +1267,7 @@ error occurs, it will be necessary to <em>manually</em> close each stream in ord
 to prevent memory leaks.</p>
 <p>The <a href="process.html#process_process_stderr"><code>process.stderr</code></a> and <a href="process.html#process_process_stdout"><code>process.stdout</code></a> <code>Writable</code> streams are never
 closed until the Node.js process exits, regardless of the specified options.</p>
-<h5><code>readable.read([size])</code><span><a class="mark" href="#stream_readable_read_size" id="stream_readable_read_size">#</a></span></h5>
+<h6><code>readable.read([size])</code><span><a class="mark" href="#stream_readable_read_size" id="stream_readable_read_size">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1205,25 +1286,25 @@ the stream has ended, in which case all of the data remaining in the internal
 buffer will be returned.</p>
 <p>If the <code>size</code> argument is not specified, all of the data contained in the
 internal buffer will be returned.</p>
-<p>The <code>size</code> argument must be less than or equal to 1 GB.</p>
+<p>The <code>size</code> argument must be less than or equal to 1 GiB.</p>
 <p>The <code>readable.read()</code> method should only be called on <code>Readable</code> streams
 operating in paused mode. In flowing mode, <code>readable.read()</code> is called
 automatically until the internal buffer is fully drained.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
 
 <span class="hljs-comment">// 'readable' may be triggered multiple times as data is buffered in</span>
-readable.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-keyword">let</span> chunk;
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Stream is readable (new data received in buffer)'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Stream is readable (new data received in buffer)'</span>);
   <span class="hljs-comment">// Use a loop to make sure we read all currently available data</span>
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = readable.read())) {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Read <span class="hljs-subst">${chunk.length}</span> bytes of data...`</span>);
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = readable.<span class="hljs-title function_">read</span>())) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Read <span class="hljs-subst">${chunk.length}</span> bytes of data...`</span>);
   }
 });
 
 <span class="hljs-comment">// 'end' will be triggered once when there is no more data available</span>
-readable.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Reached end of stream.'</span>);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Reached end of stream.'</span>);
 });</code></pre>
 <p>Each call to <code>readable.read()</code> returns a chunk of data, or <code>null</code>. The chunks
 are not concatenated. A <code>while</code> loop is necessary to consume all data
@@ -1236,15 +1317,15 @@ emitted when there is no more data to come.</p>
 to collect chunks across multiple <code>'readable'</code> events:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> chunks = [];
 
-readable.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
   <span class="hljs-keyword">let</span> chunk;
-  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = readable.read())) {
-    chunks.push(chunk);
+  <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = readable.<span class="hljs-title function_">read</span>())) {
+    chunks.<span class="hljs-title function_">push</span>(chunk);
   }
 });
 
-readable.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-keyword">const</span> content = chunks.join(<span class="hljs-string">''</span>);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-keyword">const</span> content = chunks.<span class="hljs-title function_">join</span>(<span class="hljs-string">''</span>);
 });</code></pre>
 <p>A <code>Readable</code> stream in object mode will always return a single item from
 a call to <a href="#stream_readable_read_size"><code>readable.read(size)</code></a>, regardless of the value of the
@@ -1253,15 +1334,26 @@ a call to <a href="#stream_readable_read_size"><code>readable.read(size)</code><
 also be emitted.</p>
 <p>Calling <a href="#stream_readable_read_size"><code>stream.read([size])</code></a> after the <a href="#stream_event_end"><code>'end'</code></a> event has
 been emitted will return <code>null</code>. No runtime error will be raised.</p>
-<h5><code>readable.readable</code><span><a class="mark" href="#stream_readable_readable" id="stream_readable_readable">#</a></span></h5>
+<h6><code>readable.readable</code><span><a class="mark" href="#stream_readable_readable" id="stream_readable_readable">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v11.4.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Is <code>true</code> if it is safe to call <a href="#stream_readable_read_size"><code>readable.read()</code></a>.</p>
-<h5><code>readable.readableEncoding</code><span><a class="mark" href="#stream_readable_readableencoding" id="stream_readable_readableencoding">#</a></span></h5>
+<p>Is <code>true</code> if it is safe to call <a href="#stream_readable_read_size"><code>readable.read()</code></a>, which means
+the stream has not been destroyed or emitted <code>'error'</code> or <code>'end'</code>.</p>
+<h6><code>readable.readableDidRead</code><span><a class="mark" href="#stream_readable_readabledidread" id="stream_readable_readabledidread">#</a></span></h6>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>Allows determining if the stream has been or is about to be read.
+Returns true if <code>'data'</code>, <code>'end'</code>, <code>'error'</code> or <code>'close'</code> has been
+emitted.</p>
+<h6><code>readable.readableEncoding</code><span><a class="mark" href="#stream_readable_readableencoding" id="stream_readable_readableencoding">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.7.0</span>
 </div>
@@ -1270,7 +1362,7 @@ been emitted will return <code>null</code>. No runtime error will be raised.</p>
 </ul>
 <p>Getter for the property <code>encoding</code> of a given <code>Readable</code> stream. The <code>encoding</code>
 property can be set using the <a href="#stream_readable_setencoding_encoding"><code>readable.setEncoding()</code></a> method.</p>
-<h5><code>readable.readableEnded</code><span><a class="mark" href="#stream_readable_readableended" id="stream_readable_readableended">#</a></span></h5>
+<h6><code>readable.readableEnded</code><span><a class="mark" href="#stream_readable_readableended" id="stream_readable_readableended">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.9.0</span>
 </div>
@@ -1278,7 +1370,7 @@ property can be set using the <a href="#stream_readable_setencoding_encoding"><c
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Becomes <code>true</code> when <a href="#stream_event_end"><code>'end'</code></a> event is emitted.</p>
-<h5><code>readable.readableFlowing</code><span><a class="mark" href="#stream_readable_readableflowing" id="stream_readable_readableflowing">#</a></span></h5>
+<h6><code>readable.readableFlowing</code><span><a class="mark" href="#stream_readable_readableflowing" id="stream_readable_readableflowing">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -1287,7 +1379,7 @@ property can be set using the <a href="#stream_readable_setencoding_encoding"><c
 </ul>
 <p>This property reflects the current state of a <code>Readable</code> stream as described
 in the <a href="#stream_three_states">Three states</a> section.</p>
-<h5><code>readable.readableHighWaterMark</code><span><a class="mark" href="#stream_readable_readablehighwatermark" id="stream_readable_readablehighwatermark">#</a></span></h5>
+<h6><code>readable.readableHighWaterMark</code><span><a class="mark" href="#stream_readable_readablehighwatermark" id="stream_readable_readablehighwatermark">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.3.0</span>
 </div>
@@ -1296,7 +1388,7 @@ in the <a href="#stream_three_states">Three states</a> section.</p>
 </ul>
 <p>Returns the value of <code>highWaterMark</code> passed when constructing this
 <code>Readable</code>.</p>
-<h5><code>readable.readableLength</code><span><a class="mark" href="#stream_readable_readablelength" id="stream_readable_readablelength">#</a></span></h5>
+<h6><code>readable.readableLength</code><span><a class="mark" href="#stream_readable_readablelength" id="stream_readable_readablelength">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v9.4.0</span>
 </div>
@@ -1306,7 +1398,7 @@ in the <a href="#stream_three_states">Three states</a> section.</p>
 <p>This property contains the number of bytes (or objects) in the queue
 ready to be read. The value provides introspection data regarding
 the status of the <code>highWaterMark</code>.</p>
-<h5><code>readable.readableObjectMode</code><span><a class="mark" href="#stream_readable_readableobjectmode" id="stream_readable_readableobjectmode">#</a></span></h5>
+<h6><code>readable.readableObjectMode</code><span><a class="mark" href="#stream_readable_readableobjectmode" id="stream_readable_readableobjectmode">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
@@ -1314,7 +1406,7 @@ the status of the <code>highWaterMark</code>.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Getter for the property <code>objectMode</code> of a given <code>Readable</code> stream.</p>
-<h5><code>readable.resume()</code><span><a class="mark" href="#stream_readable_resume" id="stream_readable_resume">#</a></span></h5>
+<h6><code>readable.resume()</code><span><a class="mark" href="#stream_readable_resume" id="stream_readable_resume">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1333,14 +1425,14 @@ the status of the <code>highWaterMark</code>.</p>
 resume emitting <a href="#stream_event_data"><code>'data'</code></a> events, switching the stream into flowing mode.</p>
 <p>The <code>readable.resume()</code> method can be used to fully consume the data from a
 stream without actually processing any of that data:</p>
-<pre><code class="language-js">getReadableStreamSomehow()
-  .resume()
-  .on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Reached the end, but did not read anything.'</span>);
+<pre><code class="language-js"><span class="hljs-title function_">getReadableStreamSomehow</span>()
+  .<span class="hljs-title function_">resume</span>()
+  .<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Reached the end, but did not read anything.'</span>);
   });</code></pre>
 <p>The <code>readable.resume()</code> method has no effect if there is a <code>'readable'</code>
 event listener.</p>
-<h5><code>readable.setEncoding(encoding)</code><span><a class="mark" href="#stream_readable_setencoding_encoding" id="stream_readable_setencoding_encoding">#</a></span></h5>
+<h6><code>readable.setEncoding(encoding)</code><span><a class="mark" href="#stream_readable_setencoding_encoding" id="stream_readable_setencoding_encoding">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1360,13 +1452,13 @@ string format.</p>
 <p>The <code>Readable</code> stream will properly handle multi-byte characters delivered
 through the stream that would otherwise become improperly decoded if simply
 pulled from the stream as <code>Buffer</code> objects.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-readable.setEncoding(<span class="hljs-string">'utf8'</span>);
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  assert.equal(<span class="hljs-keyword">typeof</span> chunk, <span class="hljs-string">'string'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Got %d characters of string data:'</span>, chunk.length);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+readable.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  assert.<span class="hljs-title function_">equal</span>(<span class="hljs-keyword">typeof</span> chunk, <span class="hljs-string">'string'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Got %d characters of string data:'</span>, chunk.<span class="hljs-property">length</span>);
 });</code></pre>
-<h5><code>readable.unpipe([destination])</code><span><a class="mark" href="#stream_readable_unpipe_destination" id="stream_readable_unpipe_destination">#</a></span></h5>
+<h6><code>readable.unpipe([destination])</code><span><a class="mark" href="#stream_readable_unpipe_destination" id="stream_readable_unpipe_destination">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1380,18 +1472,18 @@ using the <a href="#stream_readable_pipe_destination_options"><code>stream.pipe(
 <p>If the <code>destination</code> is specified, but no pipe is set up for it, then
 the method does nothing.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> readable = getReadableStreamSomehow();
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'file.txt'</span>);
+<span class="hljs-keyword">const</span> readable = <span class="hljs-title function_">getReadableStreamSomehow</span>();
+<span class="hljs-keyword">const</span> writable = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'file.txt'</span>);
 <span class="hljs-comment">// All the data from readable goes into 'file.txt',</span>
 <span class="hljs-comment">// but only for the first second.</span>
-readable.pipe(writable);
+readable.<span class="hljs-title function_">pipe</span>(writable);
 <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Stop writing to file.txt.'</span>);
-  readable.unpipe(writable);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Manually close the file stream.'</span>);
-  writable.end();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Stop writing to file.txt.'</span>);
+  readable.<span class="hljs-title function_">unpipe</span>(writable);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Manually close the file stream.'</span>);
+  writable.<span class="hljs-title function_">end</span>();
 }, <span class="hljs-number">1000</span>);</code></pre>
-<h5><code>readable.unshift(chunk[, encoding])</code><span><a class="mark" href="#stream_readable_unshift_chunk_encoding" id="stream_readable_unshift_chunk_encoding">#</a></span></h5>
+<h6><code>readable.unshift(chunk[, encoding])</code><span><a class="mark" href="#stream_readable_unshift_chunk_encoding" id="stream_readable_unshift_chunk_encoding">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1427,29 +1519,29 @@ section for more information.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Pull off a header delimited by \n\n.</span>
 <span class="hljs-comment">// Use unshift() if we get too much.</span>
 <span class="hljs-comment">// Call the callback with (error, header, stream).</span>
-<span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">parseHeader</span>(<span class="hljs-params">stream, callback</span>) </span>{
-  stream.on(<span class="hljs-string">'error'</span>, callback);
-  stream.on(<span class="hljs-string">'readable'</span>, onReadable);
-  <span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> StringDecoder(<span class="hljs-string">'utf8'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">parseHeader</span>(<span class="hljs-params">stream, callback</span>) {
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, callback);
+  stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, onReadable);
+  <span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringDecoder</span>(<span class="hljs-string">'utf8'</span>);
   <span class="hljs-keyword">let</span> header = <span class="hljs-string">''</span>;
-  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">onReadable</span>(<span class="hljs-params"></span>) </span>{
+  <span class="hljs-keyword">function</span> <span class="hljs-title function_">onReadable</span>(<span class="hljs-params"></span>) {
     <span class="hljs-keyword">let</span> chunk;
-    <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = stream.read())) {
-      <span class="hljs-keyword">const</span> str = decoder.write(chunk);
-      <span class="hljs-keyword">if</span> (str.match(<span class="hljs-regexp">/\n\n/</span>)) {
+    <span class="hljs-keyword">while</span> (<span class="hljs-literal">null</span> !== (chunk = stream.<span class="hljs-title function_">read</span>())) {
+      <span class="hljs-keyword">const</span> str = decoder.<span class="hljs-title function_">write</span>(chunk);
+      <span class="hljs-keyword">if</span> (str.<span class="hljs-title function_">match</span>(<span class="hljs-regexp">/\n\n/</span>)) {
         <span class="hljs-comment">// Found the header boundary.</span>
-        <span class="hljs-keyword">const</span> split = str.split(<span class="hljs-regexp">/\n\n/</span>);
-        header += split.shift();
-        <span class="hljs-keyword">const</span> remaining = split.join(<span class="hljs-string">'\n\n'</span>);
-        <span class="hljs-keyword">const</span> buf = Buffer.from(remaining, <span class="hljs-string">'utf8'</span>);
-        stream.removeListener(<span class="hljs-string">'error'</span>, callback);
+        <span class="hljs-keyword">const</span> split = str.<span class="hljs-title function_">split</span>(<span class="hljs-regexp">/\n\n/</span>);
+        header += split.<span class="hljs-title function_">shift</span>();
+        <span class="hljs-keyword">const</span> remaining = split.<span class="hljs-title function_">join</span>(<span class="hljs-string">'\n\n'</span>);
+        <span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(remaining, <span class="hljs-string">'utf8'</span>);
+        stream.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'error'</span>, callback);
         <span class="hljs-comment">// Remove the 'readable' listener before unshifting.</span>
-        stream.removeListener(<span class="hljs-string">'readable'</span>, onReadable);
-        <span class="hljs-keyword">if</span> (buf.length)
-          stream.unshift(buf);
+        stream.<span class="hljs-title function_">removeListener</span>(<span class="hljs-string">'readable'</span>, onReadable);
+        <span class="hljs-keyword">if</span> (buf.<span class="hljs-property">length</span>)
+          stream.<span class="hljs-title function_">unshift</span>(buf);
         <span class="hljs-comment">// Now the body of the message can be read from the stream.</span>
-        callback(<span class="hljs-literal">null</span>, header, stream);
+        <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, header, stream);
       } <span class="hljs-keyword">else</span> {
         <span class="hljs-comment">// Still reading the header.</span>
         header += str;
@@ -1465,7 +1557,7 @@ custom stream). Following the call to <code>readable.unshift()</code> with an im
 <a href="#stream_readable_push_chunk_encoding"><code>stream.push('')</code></a> will reset the reading state appropriately,
 however it is best to simply avoid calling <code>readable.unshift()</code> while in the
 process of performing a read.</p>
-<h5><code>readable.wrap(stream)</code><span><a class="mark" href="#stream_readable_wrap_stream" id="stream_readable_wrap_stream">#</a></span></h5>
+<h6><code>readable.wrap(stream)</code><span><a class="mark" href="#stream_readable_wrap_stream" id="stream_readable_wrap_stream">#</a></span></h6>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1482,15 +1574,15 @@ the old stream as its data source.</p>
 <p>It will rarely be necessary to use <code>readable.wrap()</code> but the method has been
 provided as a convenience for interacting with older Node.js applications and
 libraries.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { OldReader } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./old-api-module.js'</span>);
-<span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-<span class="hljs-keyword">const</span> oreader = <span class="hljs-keyword">new</span> OldReader();
-<span class="hljs-keyword">const</span> myReader = <span class="hljs-keyword">new</span> Readable().wrap(oreader);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">OldReader</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'./old-api-module.js'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> oreader = <span class="hljs-keyword">new</span> <span class="hljs-title class_">OldReader</span>();
+<span class="hljs-keyword">const</span> myReader = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Readable</span>().<span class="hljs-title function_">wrap</span>(oreader);
 
-myReader.on(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
-  myReader.read(); <span class="hljs-comment">// etc.</span>
+myReader.<span class="hljs-title function_">on</span>(<span class="hljs-string">'readable'</span>, <span class="hljs-function">() =></span> {
+  myReader.<span class="hljs-title function_">read</span>(); <span class="hljs-comment">// etc.</span>
 });</code></pre>
-<h5><code>readable[Symbol.asyncIterator]()</code><span><a class="mark" href="#stream_readable_symbol_asynciterator" id="stream_readable_symbol_asynciterator">#</a></span></h5>
+<h6><code>readable[Symbol.asyncIterator]()</code><span><a class="mark" href="#stream_readable_symbol_asynciterator" id="stream_readable_symbol_asynciterator">#</a></span></h6>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1507,24 +1599,24 @@ myReader.on(<span class="hljs-string">'readable'</span>, <span class="hljs-funct
 </ul>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">print</span>(<span class="hljs-params">readable</span>) </span>{
-  readable.setEncoding(<span class="hljs-string">'utf8'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">print</span>(<span class="hljs-params">readable</span>) {
+  readable.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
   <span class="hljs-keyword">let</span> data = <span class="hljs-string">''</span>;
   <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> chunk <span class="hljs-keyword">of</span> readable) {
     data += chunk;
   }
-  <span class="hljs-built_in">console</span>.log(data);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
 }
 
-print(fs.createReadStream(<span class="hljs-string">'file'</span>)).catch(<span class="hljs-built_in">console</span>.error);</code></pre>
+<span class="hljs-title function_">print</span>(fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'file'</span>)).<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);</code></pre>
 <p>If the loop terminates with a <code>break</code> or a <code>throw</code>, the stream will be
 destroyed. In other terms, iterating over a stream will consume the stream
 fully. The stream will be read in chunks of size equal to the <code>highWaterMark</code>
 option. In the code example above, data will be in a single chunk if the file
 has less then 64KB of data because no <code>highWaterMark</code> option is provided to
 <a href="fs.html#fs_fs_createreadstream_path_options"><code>fs.createReadStream()</code></a>.</p>
-<h3>Duplex and transform streams<span><a class="mark" href="#stream_duplex_and_transform_streams" id="stream_duplex_and_transform_streams">#</a></span></h3>
-<h4>Class: <code>stream.Duplex</code><span><a class="mark" href="#stream_class_stream_duplex" id="stream_class_stream_duplex">#</a></span></h4>
+<h4>Duplex and transform streams<span><a class="mark" href="#stream_duplex_and_transform_streams" id="stream_duplex_and_transform_streams">#</a></span></h4>
+<h5>Class: <code>stream.Duplex</code><span><a class="mark" href="#stream_class_stream_duplex" id="stream_class_stream_duplex">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1545,7 +1637,7 @@ has less then 64KB of data because no <code>highWaterMark</code> option is provi
 <li><a href="zlib.html">zlib streams</a></li>
 <li><a href="crypto.html">crypto streams</a></li>
 </ul>
-<h4>Class: <code>stream.Transform</code><span><a class="mark" href="#stream_class_stream_transform" id="stream_class_stream_transform">#</a></span></h4>
+<h5>Class: <code>stream.Transform</code><span><a class="mark" href="#stream_class_stream_transform" id="stream_class_stream_transform">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -1558,9 +1650,17 @@ implement both the <a href="#stream_class_stream_readable"><code>Readable</code>
 <li><a href="zlib.html">zlib streams</a></li>
 <li><a href="crypto.html">crypto streams</a></li>
 </ul>
-<h5><code>transform.destroy([error])</code><span><a class="mark" href="#stream_transform_destroy_error" id="stream_transform_destroy_error">#</a></span></h5>
+<h6><code>transform.destroy([error])</code><span><a class="mark" href="#stream_transform_destroy_error" id="stream_transform_destroy_error">#</a></span></h6>
 <div class="api_metadata">
-<span>Added in: v8.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>Work as a no-op on a stream that has already been destroyed.</p></td></tr>
+<tr><td>v8.0.0</td>
+<td><p><span>Added in: v8.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
@@ -1572,9 +1672,23 @@ Implementors should not override this method, but instead implement
 <a href="#stream_readable_destroy_err_callback"><code>readable._destroy()</code></a>.
 The default implementation of <code>_destroy()</code> for <code>Transform</code> also emit <code>'close'</code>
 unless <code>emitClose</code> is set in false.</p>
-<h3><code>stream.finished(stream[, options], callback)</code><span><a class="mark" href="#stream_stream_finished_stream_options_callback" id="stream_stream_finished_stream_options_callback">#</a></span></h3>
+<p>Once <code>destroy()</code> has been called, any further calls will be a no-op and no
+further errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>
+<h4><code>stream.finished(stream[, options], callback)</code><span><a class="mark" href="#stream_stream_finished_stream_options_callback" id="stream_stream_finished_stream_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>finished(stream, cb)</code> will wait for the <code>'close'</code> event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit <code>'close'</code>.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>Emitting <code>'close'</code> before <code>'end'</code> on a <code>Readable</code> stream will cause an <code>ERR_STREAM_PREMATURE_CLOSE</code> error.</p></td></tr>
+<tr><td>v14.0.0</td>
+<td><p>Callback will be invoked on streams which have already finished before the call to <code>finished(stream, cb)</code>.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>stream</code> <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a> A readable and/or writable stream.</li>
@@ -1599,56 +1713,86 @@ listeners.</li>
 or has experienced an error or a premature close event.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { finished } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> rs = fs.createReadStream(<span class="hljs-string">'archive.tar'</span>);
+<span class="hljs-keyword">const</span> rs = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'archive.tar'</span>);
 
-finished(rs, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<span class="hljs-title function_">finished</span>(rs, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Stream failed.'</span>, err);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Stream failed.'</span>, err);
   } <span class="hljs-keyword">else</span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Stream is done reading.'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Stream is done reading.'</span>);
   }
 });
 
-rs.resume(); <span class="hljs-comment">// Drain the stream.</span></code></pre>
+rs.<span class="hljs-title function_">resume</span>(); <span class="hljs-comment">// Drain the stream.</span></code></pre>
 <p>Especially useful in error handling scenarios where a stream is destroyed
 prematurely (like an aborted HTTP request), and will not emit <code>'end'</code>
 or <code>'finish'</code>.</p>
 <p>The <code>finished</code> API is promisify-able as well;</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> finished = util.promisify(stream.finished);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> finished = util.<span class="hljs-title function_">promisify</span>(stream.<span class="hljs-property">finished</span>);
 
-<span class="hljs-keyword">const</span> rs = fs.createReadStream(<span class="hljs-string">'archive.tar'</span>);
+<span class="hljs-keyword">const</span> rs = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'archive.tar'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">run</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> finished(rs);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Stream is done reading.'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">run</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">finished</span>(rs);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Stream is done reading.'</span>);
 }
 
-run().catch(<span class="hljs-built_in">console</span>.error);
-rs.resume(); <span class="hljs-comment">// Drain the stream.</span></code></pre>
+<span class="hljs-title function_">run</span>().<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);
+rs.<span class="hljs-title function_">resume</span>(); <span class="hljs-comment">// Drain the stream.</span></code></pre>
 <p><code>stream.finished()</code> leaves dangling event listeners (in particular
 <code>'error'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code>) after <code>callback</code> has been
 invoked. The reason for this is so that unexpected <code>'error'</code> events (due to
 incorrect stream implementations) do not cause unexpected crashes.
 If this is unwanted behavior then the returned cleanup function needs to be
 invoked in the callback:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> cleanup = finished(rs, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  cleanup();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> cleanup = <span class="hljs-title function_">finished</span>(rs, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-title function_">cleanup</span>();
   <span class="hljs-comment">// ...</span>
 });</code></pre>
-<h3><code>stream.pipeline(...streams, callback)</code><span><a class="mark" href="#stream_stream_pipeline_streams_callback" id="stream_stream_pipeline_streams_callback">#</a></span></h3>
+<h4><code>stream.pipeline(source[, ...transforms], destination, callback)</code><span><a class="mark" href="#stream_stream_pipeline_source_transforms_destination_callback" id="stream_stream_pipeline_source_transforms_destination_callback">#</a></span></h4>
+<h4><code>stream.pipeline(streams, callback)</code><span><a class="mark" href="#stream_stream_pipeline_streams_callback" id="stream_stream_pipeline_streams_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.0.0</td>
+<td><p>The <code>pipeline(..., cb)</code> will wait for the <code>'close'</code> event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit <code>'close'</code>.</p></td></tr>
+<tr><td>v13.10.0</td>
+<td><p>Add support for async generators.</p></td></tr>
+<tr><td>v10.0.0</td>
+<td><p><span>Added in: v10.0.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li><code>...streams</code> <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a> Two or more streams to pipe between.</li>
+<li><code>streams</code> <a href="stream.html#stream_stream" class="type">&#x3C;Stream[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable[]></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function[]></a></li>
+<li><code>source</code> <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol" class="type">&#x3C;Iterable></a> | <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a></li>
+</ul>
+</li>
+<li><code>...transforms</code> <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>source</code> <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a></li>
+<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a></li>
+</ul>
+</li>
+<li><code>destination</code> <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
+<ul>
+<li><code>source</code> <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a></li>
+<li>Returns: <a href="https://tc39.github.io/ecma262/#sec-asynciterable-interface" class="type">&#x3C;AsyncIterable></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called when the pipeline is fully done.
 <ul>
 <li><code>err</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
+<li><code>val</code> Resolved value of <code>Promise</code> returned by <code>destination</code>.</li>
 </ul>
 </li>
+<li>Returns: <a href="stream.html#stream_stream" class="type">&#x3C;Stream></a></li>
 </ul>
-<p>A module method to pipe between streams forwarding errors and properly cleaning
-up and provide a callback when the pipeline is complete.</p>
+<p>A module method to pipe between streams and generators forwarding errors and
+properly cleaning up and provide a callback when the pipeline is complete.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> zlib = <span class="hljs-built_in">require</span>(<span class="hljs-string">'zlib'</span>);
@@ -1658,31 +1802,50 @@ up and provide a callback when the pipeline is complete.</p>
 
 <span class="hljs-comment">// A pipeline to gzip a potentially huge tar file efficiently:</span>
 
-pipeline(
-  fs.createReadStream(<span class="hljs-string">'archive.tar'</span>),
-  zlib.createGzip(),
-  fs.createWriteStream(<span class="hljs-string">'archive.tar.gz'</span>),
+<span class="hljs-title function_">pipeline</span>(
+  fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'archive.tar'</span>),
+  zlib.<span class="hljs-title function_">createGzip</span>(),
+  fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'archive.tar.gz'</span>),
   <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'Pipeline failed.'</span>, err);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Pipeline failed.'</span>, err);
     } <span class="hljs-keyword">else</span> {
-      <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Pipeline succeeded.'</span>);
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Pipeline succeeded.'</span>);
     }
   }
 );</code></pre>
 <p>The <code>pipeline</code> API is promisify-able as well:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> pipeline = util.promisify(stream.pipeline);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> pipeline = util.<span class="hljs-title function_">promisify</span>(stream.<span class="hljs-property">pipeline</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">run</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">await</span> pipeline(
-    fs.createReadStream(<span class="hljs-string">'archive.tar'</span>),
-    zlib.createGzip(),
-    fs.createWriteStream(<span class="hljs-string">'archive.tar.gz'</span>)
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">run</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">pipeline</span>(
+    fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'archive.tar'</span>),
+    zlib.<span class="hljs-title function_">createGzip</span>(),
+    fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'archive.tar.gz'</span>)
+  );
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Pipeline succeeded.'</span>);
+}
+
+<span class="hljs-title function_">run</span>().<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);</code></pre>
+<p>The <code>pipeline</code> API also supports async generators:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> pipeline = util.<span class="hljs-title function_">promisify</span>(stream.<span class="hljs-property">pipeline</span>);
+<span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">run</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">pipeline</span>(
+    fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'lowercase.txt'</span>),
+    <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>* (source) {
+      source.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);  <span class="hljs-comment">// Work with strings rather than `Buffer`s.</span>
+      <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> chunk <span class="hljs-keyword">of</span> source) {
+        <span class="hljs-keyword">yield</span> chunk.<span class="hljs-title function_">toUpperCase</span>();
+      }
+    },
+    fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'uppercase.txt'</span>)
   );
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Pipeline succeeded.'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Pipeline succeeded.'</span>);
 }
 
-run().catch(<span class="hljs-built_in">console</span>.error);</code></pre>
+<span class="hljs-title function_">run</span>().<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);</code></pre>
 <p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>
 <ul>
 <li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>
@@ -1691,7 +1854,7 @@ run().catch(<span class="hljs-built_in">console</span>.error);</code></pre>
 <p><code>stream.pipeline()</code> leaves dangling event listeners on the streams
 after the <code>callback</code> has been invoked. In the case of reuse of streams after
 failure, this can cause event listener leaks and swallowed errors.</p>
-<h3><code>stream.Readable.from(iterable, [options])</code><span><a class="mark" href="#stream_stream_readable_from_iterable_options" id="stream_stream_readable_from_iterable_options">#</a></span></h3>
+<h4><code>stream.Readable.from(iterable, [options])</code><span><a class="mark" href="#stream_stream_readable_from_iterable_options" id="stream_stream_readable_from_iterable_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.3.0, v10.17.0</span>
 </div>
@@ -1705,22 +1868,22 @@ this is explicitly opted out by setting <code>options.objectMode</code> to <code
 <li>Returns: <a href="stream.html#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a></li>
 </ul>
 <p>A utility method for creating readable streams out of iterators.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> * <span class="hljs-title">generate</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> * <span class="hljs-title function_">generate</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'hello'</span>;
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'streams'</span>;
 }
 
-<span class="hljs-keyword">const</span> readable = Readable.from(generate());
+<span class="hljs-keyword">const</span> readable = <span class="hljs-title class_">Readable</span>.<span class="hljs-title function_">from</span>(<span class="hljs-title function_">generate</span>());
 
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(chunk);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk);
 });</code></pre>
 <p>Calling <code>Readable.from(string)</code> or <code>Readable.from(buffer)</code> will not have
 the strings or buffers be iterated to match the other streams semantics
 for performance reasons.</p>
-<h2>API for stream implementers<span><a class="mark" href="#stream_api_for_stream_implementers" id="stream_api_for_stream_implementers">#</a></span></h2>
+</section><section><h3>API for stream implementers<span><a class="mark" href="#stream_api_for_stream_implementers" id="stream_api_for_stream_implementers">#</a></span></h3>
 
 <p>The <code>stream</code> module API has been designed to make it possible to easily
 implement streams using JavaScript's prototypal inheritance model.</p>
@@ -1729,15 +1892,11 @@ of the four basic stream classes (<code>stream.Writable</code>, <code>stream.Rea
 <code>stream.Duplex</code>, or <code>stream.Transform</code>), making sure they call the appropriate
 parent class constructor:</p>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Writable</span> </span>{
-  <span class="hljs-keyword">constructor</span>({ highWaterMark, ...options }) {
-    <span class="hljs-built_in">super</span>({
-      highWaterMark,
-      <span class="hljs-attr">autoDestroy</span>: <span class="hljs-literal">true</span>,
-      <span class="hljs-attr">emitClose</span>: <span class="hljs-literal">true</span>
-    });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Writable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">{ highWaterMark, ...options }</span>) {
+    <span class="hljs-variable language_">super</span>({ highWaterMark });
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
@@ -1790,7 +1949,7 @@ as <code>'error'</code>, <code>'data'</code>, <code>'end'</code>, <code>'finish'
 Doing so can break current and future stream invariants leading to behavior
 and/or compatibility issues with other streams, stream utilities, and user
 expectations.</p>
-<h3>Simplified construction<span><a class="mark" href="#stream_simplified_construction" id="stream_simplified_construction">#</a></span></h3>
+<h4>Simplified construction<span><a class="mark" href="#stream_simplified_construction" id="stream_simplified_construction">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v1.2.0</span>
 </div>
@@ -1798,24 +1957,26 @@ expectations.</p>
 inheritance. This can be accomplished by directly creating instances of the
 <code>stream.Writable</code>, <code>stream.Readable</code>, <code>stream.Duplex</code> or <code>stream.Transform</code>
 objects and passing appropriate methods as constructor options.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> Writable({
-  write(chunk, encoding, callback) {
+<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>({
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h3>Implementing a writable stream<span><a class="mark" href="#stream_implementing_a_writable_stream" id="stream_implementing_a_writable_stream">#</a></span></h3>
+<h4>Implementing a writable stream<span><a class="mark" href="#stream_implementing_a_writable_stream" id="stream_implementing_a_writable_stream">#</a></span></h4>
 <p>The <code>stream.Writable</code> class is extended to implement a <a href="#stream_class_stream_writable"><code>Writable</code></a> stream.</p>
 <p>Custom <code>Writable</code> streams <em>must</em> call the <code>new stream.Writable([options])</code>
 constructor and implement the <code>writable._write()</code> and/or <code>writable._writev()</code>
 method.</p>
-<h4><code>new stream.Writable([options])</code><span><a class="mark" href="#stream_new_stream_writable_options" id="stream_new_stream_writable_options">#</a></span></h4>
+<h5><code>new stream.Writable([options])</code><span><a class="mark" href="#stream_new_stream_writable_options" id="stream_new_stream_writable_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.2.0</td>
+<tr><td>v14.0.0</td>
+<td><p>Change <code>autoDestroy</code> option default to <code>true</code>.</p></td></tr>
+<tr><td>v11.2.0, v10.16.0</td>
 <td><p>Add <code>autoDestroy</code> option to automatically <code>destroy()</code> the stream when it emits <code>'finish'</code> or errors.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>Add <code>emitClose</code> option to specify if <code>'close'</code> is emitted on destroy.</p></td></tr>
@@ -1853,42 +2014,42 @@ after it has been destroyed. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>final</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Implementation for the
 <a href="#stream_writable_final_callback"><code>stream._final()</code></a> method.</li>
 <li><code>autoDestroy</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether this stream should automatically call
-<code>.destroy()</code> on itself after ending. <strong>Default:</strong> <code>false</code>.</li>
+<code>.destroy()</code> on itself after ending. <strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
 </ul>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Writable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Writable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
     <span class="hljs-comment">// Calls the stream.Writable() constructor.</span>
-    <span class="hljs-built_in">super</span>(options);
+    <span class="hljs-variable language_">super</span>(options);
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
 <p>Or, when using pre-ES6 style constructors:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyWritable</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-keyword">if</span> (!(<span class="hljs-built_in">this</span> <span class="hljs-keyword">instanceof</span> MyWritable))
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> MyWritable(options);
-  Writable.call(<span class="hljs-built_in">this</span>, options);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyWritable</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MyWritable</span>))
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyWritable</span>(options);
+  <span class="hljs-title class_">Writable</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, options);
 }
-util.inherits(MyWritable, Writable);</code></pre>
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyWritable</span>, <span class="hljs-title class_">Writable</span>);</code></pre>
 <p>Or, using the simplified constructor approach:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> Writable({
-  write(chunk, encoding, callback) {
+<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>({
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// ...</span>
   },
-  writev(chunks, callback) {
+  <span class="hljs-title function_">writev</span>(<span class="hljs-params">chunks, callback</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h4><code>writable._write(chunk, encoding, callback)</code><span><a class="mark" href="#stream_writable_write_chunk_encoding_callback_1" id="stream_writable_write_chunk_encoding_callback_1">#</a></span></h4>
+<h5><code>writable._write(chunk, encoding, callback)</code><span><a class="mark" href="#stream_writable_write_chunk_encoding_callback_1" id="stream_writable_write_chunk_encoding_callback_1">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1919,10 +2080,11 @@ resource.</p>
 <p>This function MUST NOT be called by application code directly. It should be
 implemented by child classes, and called by the internal <code>Writable</code> class
 methods only.</p>
-<p>The <code>callback</code> method must be called to signal either that the write completed
-successfully or failed with an error. The first argument passed to the
-<code>callback</code> must be the <code>Error</code> object if the call failed or <code>null</code> if the
-write succeeded.</p>
+<p>The <code>callback</code> function must be called synchronously inside of
+<code>writable._write()</code> or asynchronously (i.e. different tick) to signal either
+that the write completed successfully or failed with an error.
+The first argument passed to the <code>callback</code> must be the <code>Error</code> object if the
+call failed or <code>null</code> if the write succeeded.</p>
 <p>All calls to <code>writable.write()</code> that occur between the time <code>writable._write()</code>
 is called and the <code>callback</code> is called will cause the written data to be
 buffered. When the <code>callback</code> is invoked, the stream might emit a <a href="#stream_event_drain"><code>'drain'</code></a>
@@ -1937,10 +2099,19 @@ Otherwise, the <code>encoding</code> argument can be safely ignored.</p>
 <p>The <code>writable._write()</code> method is prefixed with an underscore because it is
 internal to the class that defines it, and should never be called directly by
 user programs.</p>
-<h4><code>writable._writev(chunks, callback)</code><span><a class="mark" href="#stream_writable_writev_chunks_callback" id="stream_writable_writev_chunks_callback">#</a></span></h4>
+<h5><code>writable._writev(chunks, callback)</code><span><a class="mark" href="#stream_writable_writev_chunks_callback" id="stream_writable_writev_chunks_callback">#</a></span></h5>
+<ul>
+<li><code>chunks</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object[]></a> The data to be written. The value is an array of <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
+that each represent a discrete chunk of data to write. The properties of
+these objects are:
 <ul>
-<li><code>chunks</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object[]></a> The chunks to be written. Each chunk has following
-format: <code>{ chunk: ..., encoding: ... }</code>.</li>
+<li><code>chunk</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A buffer instance or string containing the data to
+be written. The <code>chunk</code> will be a string if the <code>Writable</code> was created with
+the <code>decodeStrings</code> option set to <code>false</code> and a string was passed to <code>write()</code>.</li>
+<li><code>encoding</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The character encoding of the <code>chunk</code>. If <code>chunk</code> is
+a <code>Buffer</code>, the <code>encoding</code> will be <code>'buffer'</code>.</li>
+</ul>
+</li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> A callback function (optionally with an error
 argument) to be invoked when processing is complete for the supplied chunks.</li>
 </ul>
@@ -1954,7 +2125,7 @@ from previous writes, <code>_writev()</code> will be called instead of <code>_wr
 <p>The <code>writable._writev()</code> method is prefixed with an underscore because it is
 internal to the class that defines it, and should never be called directly by
 user programs.</p>
-<h4><code>writable._destroy(err, callback)</code><span><a class="mark" href="#stream_writable_destroy_err_callback" id="stream_writable_destroy_err_callback">#</a></span></h4>
+<h5><code>writable._destroy(err, callback)</code><span><a class="mark" href="#stream_writable_destroy_err_callback" id="stream_writable_destroy_err_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -1965,7 +2136,7 @@ argument.</li>
 </ul>
 <p>The <code>_destroy()</code> method is called by <a href="#stream_writable_destroy_error"><code>writable.destroy()</code></a>.
 It can be overridden by child classes but it <strong>must not</strong> be called directly.</p>
-<h4><code>writable._final(callback)</code><span><a class="mark" href="#stream_writable_final_callback" id="stream_writable_final_callback">#</a></span></h4>
+<h5><code>writable._final(callback)</code><span><a class="mark" href="#stream_writable_final_callback" id="stream_writable_final_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -1979,7 +2150,7 @@ class methods only.</p>
 <p>This optional function will be called before the stream closes, delaying the
 <code>'finish'</code> event until <code>callback</code> is called. This is useful to close resources
 or write buffered data before a stream ends.</p>
-<h4>Errors while writing<span><a class="mark" href="#stream_errors_while_writing" id="stream_errors_while_writing">#</a></span></h4>
+<h5>Errors while writing<span><a class="mark" href="#stream_errors_while_writing" id="stream_errors_while_writing">#</a></span></h5>
 <p>Errors occurring during the processing of the <a href="#stream_writable_write_chunk_encoding_callback_1"><code>writable._write()</code></a>,
 <a href="#stream_writable_writev_chunks_callback"><code>writable._writev()</code></a> and <a href="#stream_writable_final_callback"><code>writable._final()</code></a> methods must be propagated
 by invoking the callback and passing the error as the first argument.
@@ -1987,78 +2158,80 @@ Throwing an <code>Error</code> from within these methods or manually emitting an
 event results in undefined behavior.</p>
 <p>If a <code>Readable</code> stream pipes into a <code>Writable</code> stream when <code>Writable</code> emits an
 error, the <code>Readable</code> stream will be unpiped.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> Writable({
-  write(chunk, encoding, callback) {
-    <span class="hljs-keyword">if</span> (chunk.toString().indexOf(<span class="hljs-string">'a'</span>) >= <span class="hljs-number">0</span>) {
-      callback(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'chunk is invalid'</span>));
+<span class="hljs-keyword">const</span> myWritable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Writable</span>({
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
+    <span class="hljs-keyword">if</span> (chunk.<span class="hljs-title function_">toString</span>().<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'a'</span>) >= <span class="hljs-number">0</span>) {
+      <span class="hljs-title function_">callback</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'chunk is invalid'</span>));
     } <span class="hljs-keyword">else</span> {
-      callback();
+      <span class="hljs-title function_">callback</span>();
     }
   }
 });</code></pre>
-<h4>An example writable stream<span><a class="mark" href="#stream_an_example_writable_stream" id="stream_an_example_writable_stream">#</a></span></h4>
+<h5>An example writable stream<span><a class="mark" href="#stream_an_example_writable_stream" id="stream_an_example_writable_stream">#</a></span></h5>
 <p>The following illustrates a rather simplistic (and somewhat pointless) custom
 <code>Writable</code> stream implementation. While this specific <code>Writable</code> stream instance
 is not of any real particular usefulness, the example illustrates each of the
 required elements of a custom <a href="#stream_class_stream_writable"><code>Writable</code></a> stream instance:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Writable</span> </span>{
-  _write(chunk, encoding, callback) {
-    <span class="hljs-keyword">if</span> (chunk.toString().indexOf(<span class="hljs-string">'a'</span>) >= <span class="hljs-number">0</span>) {
-      callback(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'chunk is invalid'</span>));
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Writable</span> {
+  <span class="hljs-title function_">_write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
+    <span class="hljs-keyword">if</span> (chunk.<span class="hljs-title function_">toString</span>().<span class="hljs-title function_">indexOf</span>(<span class="hljs-string">'a'</span>) >= <span class="hljs-number">0</span>) {
+      <span class="hljs-title function_">callback</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">'chunk is invalid'</span>));
     } <span class="hljs-keyword">else</span> {
-      callback();
+      <span class="hljs-title function_">callback</span>();
     }
   }
 }</code></pre>
-<h4>Decoding buffers in a writable stream<span><a class="mark" href="#stream_decoding_buffers_in_a_writable_stream" id="stream_decoding_buffers_in_a_writable_stream">#</a></span></h4>
+<h5>Decoding buffers in a writable stream<span><a class="mark" href="#stream_decoding_buffers_in_a_writable_stream" id="stream_decoding_buffers_in_a_writable_stream">#</a></span></h5>
 <p>Decoding buffers is a common task, for instance, when using transformers whose
 input is a string. This is not a trivial process when using multi-byte
 characters encoding, such as UTF-8. The following example shows how to decode
 multi-byte strings using <code>StringDecoder</code> and <a href="#stream_class_stream_writable"><code>Writable</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Writable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-<span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
-
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">StringWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Writable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
-    <span class="hljs-built_in">super</span>(options);
-    <span class="hljs-built_in">this</span>._decoder = <span class="hljs-keyword">new</span> StringDecoder(options &#x26;&#x26; options.defaultEncoding);
-    <span class="hljs-built_in">this</span>.data = <span class="hljs-string">''</span>;
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Writable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
+
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">StringWritable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Writable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_decoder</span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringDecoder</span>(options &#x26;&#x26; options.<span class="hljs-property">defaultEncoding</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">data</span> = <span class="hljs-string">''</span>;
   }
-  _write(chunk, encoding, callback) {
+  <span class="hljs-title function_">_write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-keyword">if</span> (encoding === <span class="hljs-string">'buffer'</span>) {
-      chunk = <span class="hljs-built_in">this</span>._decoder.write(chunk);
+      chunk = <span class="hljs-variable language_">this</span>.<span class="hljs-property">_decoder</span>.<span class="hljs-title function_">write</span>(chunk);
     }
-    <span class="hljs-built_in">this</span>.data += chunk;
-    callback();
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">data</span> += chunk;
+    <span class="hljs-title function_">callback</span>();
   }
-  _final(callback) {
-    <span class="hljs-built_in">this</span>.data += <span class="hljs-built_in">this</span>._decoder.end();
-    callback();
+  <span class="hljs-title function_">_final</span>(<span class="hljs-params">callback</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">data</span> += <span class="hljs-variable language_">this</span>.<span class="hljs-property">_decoder</span>.<span class="hljs-title function_">end</span>();
+    <span class="hljs-title function_">callback</span>();
   }
 }
 
-<span class="hljs-keyword">const</span> euro = [[<span class="hljs-number">0xE2</span>, <span class="hljs-number">0x82</span>], [<span class="hljs-number">0xAC</span>]].map(Buffer.from);
-<span class="hljs-keyword">const</span> w = <span class="hljs-keyword">new</span> StringWritable();
+<span class="hljs-keyword">const</span> euro = [[<span class="hljs-number">0xE2</span>, <span class="hljs-number">0x82</span>], [<span class="hljs-number">0xAC</span>]].<span class="hljs-title function_">map</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-property">from</span>);
+<span class="hljs-keyword">const</span> w = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringWritable</span>();
 
-w.write(<span class="hljs-string">'currency: '</span>);
-w.write(euro[<span class="hljs-number">0</span>]);
-w.end(euro[<span class="hljs-number">1</span>]);
+w.<span class="hljs-title function_">write</span>(<span class="hljs-string">'currency: '</span>);
+w.<span class="hljs-title function_">write</span>(euro[<span class="hljs-number">0</span>]);
+w.<span class="hljs-title function_">end</span>(euro[<span class="hljs-number">1</span>]);
 
-<span class="hljs-built_in">console</span>.log(w.data); <span class="hljs-comment">// currency: €</span></code></pre>
-<h3>Implementing a readable stream<span><a class="mark" href="#stream_implementing_a_readable_stream" id="stream_implementing_a_readable_stream">#</a></span></h3>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(w.<span class="hljs-property">data</span>); <span class="hljs-comment">// currency: €</span></code></pre>
+<h4>Implementing a readable stream<span><a class="mark" href="#stream_implementing_a_readable_stream" id="stream_implementing_a_readable_stream">#</a></span></h4>
 <p>The <code>stream.Readable</code> class is extended to implement a <a href="#stream_class_stream_readable"><code>Readable</code></a> stream.</p>
 <p>Custom <code>Readable</code> streams <em>must</em> call the <code>new stream.Readable([options])</code>
 constructor and implement the <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> method.</p>
-<h4><code>new stream.Readable([options])</code><span><a class="mark" href="#stream_new_stream_readable_options" id="stream_new_stream_readable_options">#</a></span></h4>
+<h5><code>new stream.Readable([options])</code><span><a class="mark" href="#stream_new_stream_readable_options" id="stream_new_stream_readable_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.2.0</td>
+<tr><td>v14.0.0</td>
+<td><p>Change <code>autoDestroy</code> option default to <code>true</code>.</p></td></tr>
+<tr><td>v11.2.0, v10.16.0</td>
 <td><p>Add <code>autoDestroy</code> option to automatically <code>destroy()</code> the stream when it emits <code>'end'</code> or errors.</p></td></tr>
 </tbody></table>
 </details>
@@ -2081,39 +2254,39 @@ method.</li>
 <li><code>destroy</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Implementation for the
 <a href="#stream_readable_destroy_err_callback"><code>stream._destroy()</code></a> method.</li>
 <li><code>autoDestroy</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Whether this stream should automatically call
-<code>.destroy()</code> on itself after ending. <strong>Default:</strong> <code>false</code>.</li>
+<code>.destroy()</code> on itself after ending. <strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
 </ul>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyReadable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Readable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyReadable</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Readable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
     <span class="hljs-comment">// Calls the stream.Readable(options) constructor.</span>
-    <span class="hljs-built_in">super</span>(options);
+    <span class="hljs-variable language_">super</span>(options);
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
 <p>Or, when using pre-ES6 style constructors:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyReadable</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-keyword">if</span> (!(<span class="hljs-built_in">this</span> <span class="hljs-keyword">instanceof</span> MyReadable))
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> MyReadable(options);
-  Readable.call(<span class="hljs-built_in">this</span>, options);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyReadable</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MyReadable</span>))
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyReadable</span>(options);
+  <span class="hljs-title class_">Readable</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, options);
 }
-util.inherits(MyReadable, Readable);</code></pre>
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyReadable</span>, <span class="hljs-title class_">Readable</span>);</code></pre>
 <p>Or, using the simplified constructor approach:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myReadable = <span class="hljs-keyword">new</span> Readable({
-  read(size) {
+<span class="hljs-keyword">const</span> myReadable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Readable</span>({
+  <span class="hljs-title function_">read</span>(<span class="hljs-params">size</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h4><code>readable._read(size)</code><span><a class="mark" href="#stream_readable_read_size_1" id="stream_readable_read_size_1">#</a></span></h4>
+<h5><code>readable._read(size)</code><span><a class="mark" href="#stream_readable_read_size_1" id="stream_readable_read_size_1">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -2127,10 +2300,12 @@ methods only.</p>
 <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> method to fetch data from the underlying resource.</p>
 <p>When <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> is called, if data is available from the resource,
 the implementation should begin pushing that data into the read queue using the
-<a href="#stream_readable_push_chunk_encoding"><code>this.push(dataChunk)</code></a> method. <code>_read()</code> should continue reading
-from the resource and pushing data until <code>readable.push()</code> returns <code>false</code>. Only
-when <code>_read()</code> is called again after it has stopped should it resume pushing
-additional data onto the queue.</p>
+<a href="#stream_readable_push_chunk_encoding"><code>this.push(dataChunk)</code></a> method. <code>_read()</code> will be called again
+after each call to <a href="#stream_readable_push_chunk_encoding"><code>this.push(dataChunk)</code></a> once the stream is
+ready to accept more data. <code>_read()</code> may continue reading from the resource and
+pushing data until <code>readable.push()</code> returns <code>false</code>. Only when <code>_read()</code> is
+called again after it has stopped should it resume pushing additional data into
+the queue.</p>
 <p>Once the <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> method has been called, it will not be called
 again until more data is pushed through the <a href="#stream_readable_push_chunk_encoding"><code>readable.push()</code></a>
 method. Empty data such as empty buffers and strings will not cause
@@ -2143,7 +2318,7 @@ provide data whenever it becomes available. There is no need to "wait" until
 <p>The <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> method is prefixed with an underscore because it is
 internal to the class that defines it, and should never be called directly by
 user programs.</p>
-<h4><code>readable._destroy(err, callback)</code><span><a class="mark" href="#stream_readable_destroy_err_callback" id="stream_readable_destroy_err_callback">#</a></span></h4>
+<h5><code>readable._destroy(err, callback)</code><span><a class="mark" href="#stream_readable_destroy_err_callback" id="stream_readable_destroy_err_callback">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -2154,7 +2329,7 @@ argument.</li>
 </ul>
 <p>The <code>_destroy()</code> method is called by <a href="#stream_readable_destroy_error"><code>readable.destroy()</code></a>.
 It can be overridden by child classes but it <strong>must not</strong> be called directly.</p>
-<h4><code>readable.push(chunk[, encoding])</code><span><a class="mark" href="#stream_readable_push_chunk_encoding" id="stream_readable_push_chunk_encoding">#</a></span></h4>
+<h5><code>readable.push(chunk[, encoding])</code><span><a class="mark" href="#stream_readable_push_chunk_encoding" id="stream_readable_push_chunk_encoding">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2192,28 +2367,28 @@ by the custom <code>Readable</code> instance:</p>
 <span class="hljs-comment">// and an `ondata` member that gets called when it has data, and</span>
 <span class="hljs-comment">// an `onend` member that gets called when the data is over.</span>
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">SourceWrapper</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Readable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
-    <span class="hljs-built_in">super</span>(options);
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">SourceWrapper</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Readable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
 
-    <span class="hljs-built_in">this</span>._source = getLowLevelSourceObject();
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span> = <span class="hljs-title function_">getLowLevelSourceObject</span>();
 
     <span class="hljs-comment">// Every time there's data, push it into the internal buffer.</span>
-    <span class="hljs-built_in">this</span>._source.ondata = <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span>.<span class="hljs-property">ondata</span> = <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
       <span class="hljs-comment">// If push() returns false, then stop reading from source.</span>
-      <span class="hljs-keyword">if</span> (!<span class="hljs-built_in">this</span>.push(chunk))
-        <span class="hljs-built_in">this</span>._source.readStop();
+      <span class="hljs-keyword">if</span> (!<span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(chunk))
+        <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span>.<span class="hljs-title function_">readStop</span>();
     };
 
     <span class="hljs-comment">// When the source ends, push the EOF-signaling `null` chunk.</span>
-    <span class="hljs-built_in">this</span>._source.onend = <span class="hljs-function">() =></span> {
-      <span class="hljs-built_in">this</span>.push(<span class="hljs-literal">null</span>);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span>.<span class="hljs-property">onend</span> = <span class="hljs-function">() =></span> {
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(<span class="hljs-literal">null</span>);
     };
   }
   <span class="hljs-comment">// _read() will be called when the stream wants to pull more data in.</span>
   <span class="hljs-comment">// The advisory size argument is ignored in this case.</span>
-  _read(size) {
-    <span class="hljs-built_in">this</span>._source.readStart();
+  <span class="hljs-title function_">_read</span>(<span class="hljs-params">size</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_source</span>.<span class="hljs-title function_">readStart</span>();
   }
 }</code></pre>
 <p>The <code>readable.push()</code> method is used to push the content
@@ -2221,48 +2396,48 @@ into the internal buffer. It can be driven by the <a href="#stream_readable_read
 <p>For streams not operating in object mode, if the <code>chunk</code> parameter of
 <code>readable.push()</code> is <code>undefined</code>, it will be treated as empty string or
 buffer. See <a href="#stream_readable_push"><code>readable.push('')</code></a> for more information.</p>
-<h4>Errors while reading<span><a class="mark" href="#stream_errors_while_reading" id="stream_errors_while_reading">#</a></span></h4>
+<h5>Errors while reading<span><a class="mark" href="#stream_errors_while_reading" id="stream_errors_while_reading">#</a></span></h5>
 <p>Errors occurring during processing of the <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> must be
 propagated through the <a href="#stream_readable_destroy_err_callback"><code>readable.destroy(err)</code></a> method.
 Throwing an <code>Error</code> from within <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> or manually emitting an
 <code>'error'</code> event results in undefined behavior.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myReadable = <span class="hljs-keyword">new</span> Readable({
-  read(size) {
-    <span class="hljs-keyword">const</span> err = checkSomeErrorCondition();
+<span class="hljs-keyword">const</span> myReadable = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Readable</span>({
+  <span class="hljs-title function_">read</span>(<span class="hljs-params">size</span>) {
+    <span class="hljs-keyword">const</span> err = <span class="hljs-title function_">checkSomeErrorCondition</span>();
     <span class="hljs-keyword">if</span> (err) {
-      <span class="hljs-built_in">this</span>.destroy(err);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">destroy</span>(err);
     } <span class="hljs-keyword">else</span> {
       <span class="hljs-comment">// Do some work.</span>
     }
   }
 });</code></pre>
-<h4>An example counting stream<span><a class="mark" href="#stream_an_example_counting_stream" id="stream_an_example_counting_stream">#</a></span></h4>
+<h5>An example counting stream<span><a class="mark" href="#stream_an_example_counting_stream" id="stream_an_example_counting_stream">#</a></span></h5>
 
 <p>The following is a basic example of a <code>Readable</code> stream that emits the numerals
 from 1 to 1,000,000 in ascending order, and then ends.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Counter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Readable</span> </span>{
-  <span class="hljs-keyword">constructor</span>(opt) {
-    <span class="hljs-built_in">super</span>(opt);
-    <span class="hljs-built_in">this</span>._max = <span class="hljs-number">1000000</span>;
-    <span class="hljs-built_in">this</span>._index = <span class="hljs-number">1</span>;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Counter</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Readable</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">opt</span>) {
+    <span class="hljs-variable language_">super</span>(opt);
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_max</span> = <span class="hljs-number">1000000</span>;
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">_index</span> = <span class="hljs-number">1</span>;
   }
 
-  _read() {
-    <span class="hljs-keyword">const</span> i = <span class="hljs-built_in">this</span>._index++;
-    <span class="hljs-keyword">if</span> (i > <span class="hljs-built_in">this</span>._max)
-      <span class="hljs-built_in">this</span>.push(<span class="hljs-literal">null</span>);
+  <span class="hljs-title function_">_read</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-keyword">const</span> i = <span class="hljs-variable language_">this</span>.<span class="hljs-property">_index</span>++;
+    <span class="hljs-keyword">if</span> (i > <span class="hljs-variable language_">this</span>.<span class="hljs-property">_max</span>)
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(<span class="hljs-literal">null</span>);
     <span class="hljs-keyword">else</span> {
-      <span class="hljs-keyword">const</span> str = <span class="hljs-built_in">String</span>(i);
-      <span class="hljs-keyword">const</span> buf = Buffer.from(str, <span class="hljs-string">'ascii'</span>);
-      <span class="hljs-built_in">this</span>.push(buf);
+      <span class="hljs-keyword">const</span> str = <span class="hljs-title class_">String</span>(i);
+      <span class="hljs-keyword">const</span> buf = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(str, <span class="hljs-string">'ascii'</span>);
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(buf);
     }
   }
 }</code></pre>
-<h3>Implementing a duplex stream<span><a class="mark" href="#stream_implementing_a_duplex_stream" id="stream_implementing_a_duplex_stream">#</a></span></h3>
+<h4>Implementing a duplex stream<span><a class="mark" href="#stream_implementing_a_duplex_stream" id="stream_implementing_a_duplex_stream">#</a></span></h4>
 <p>A <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream is one that implements both <a href="#stream_class_stream_readable"><code>Readable</code></a> and
 <a href="#stream_class_stream_writable"><code>Writable</code></a>, such as a TCP socket connection.</p>
 <p>Because JavaScript does not have support for multiple inheritance, the
@@ -2275,7 +2450,7 @@ both base classes due to overriding <a href="https://developer.mozilla.org/en-US
 <p>Custom <code>Duplex</code> streams <em>must</em> call the <code>new stream.Duplex([options])</code>
 constructor and implement <em>both</em> the <a href="#stream_readable_read_size_1"><code>readable._read()</code></a> and
 <code>writable._write()</code> methods.</p>
-<h4><code>new stream.Duplex(options)</code><span><a class="mark" href="#stream_new_stream_duplex_options" id="stream_new_stream_duplex_options">#</a></span></h4>
+<h5><code>new stream.Duplex(options)</code><span><a class="mark" href="#stream_new_stream_duplex_options" id="stream_new_stream_duplex_options">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -2308,36 +2483,36 @@ of the stream. Has no effect if <code>highWaterMark</code> is provided.</li>
 </li>
 </ul>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Duplex } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Duplex</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyDuplex</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Duplex</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
-    <span class="hljs-built_in">super</span>(options);
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyDuplex</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Duplex</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
 <p>Or, when using pre-ES6 style constructors:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Duplex } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Duplex</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyDuplex</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-keyword">if</span> (!(<span class="hljs-built_in">this</span> <span class="hljs-keyword">instanceof</span> MyDuplex))
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> MyDuplex(options);
-  Duplex.call(<span class="hljs-built_in">this</span>, options);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyDuplex</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MyDuplex</span>))
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyDuplex</span>(options);
+  <span class="hljs-title class_">Duplex</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, options);
 }
-util.inherits(MyDuplex, Duplex);</code></pre>
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyDuplex</span>, <span class="hljs-title class_">Duplex</span>);</code></pre>
 <p>Or, using the simplified constructor approach:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Duplex } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Duplex</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myDuplex = <span class="hljs-keyword">new</span> Duplex({
-  read(size) {
+<span class="hljs-keyword">const</span> myDuplex = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Duplex</span>({
+  <span class="hljs-title function_">read</span>(<span class="hljs-params">size</span>) {
     <span class="hljs-comment">// ...</span>
   },
-  write(chunk, encoding, callback) {
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h4>An example duplex stream<span><a class="mark" href="#stream_an_example_duplex_stream" id="stream_an_example_duplex_stream">#</a></span></h4>
+<h5>An example duplex stream<span><a class="mark" href="#stream_an_example_duplex_stream" id="stream_an_example_duplex_stream">#</a></span></h5>
 <p>The following illustrates a simple example of a <code>Duplex</code> stream that wraps a
 hypothetical lower-level source object to which data can be written, and
 from which data can be read, albeit using an API that is not compatible with
@@ -2345,33 +2520,33 @@ Node.js streams.
 The following illustrates a simple example of a <code>Duplex</code> stream that buffers
 incoming written data via the <a href="#stream_class_stream_writable"><code>Writable</code></a> interface that is read back out
 via the <a href="#stream_class_stream_readable"><code>Readable</code></a> interface.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Duplex } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
-<span class="hljs-keyword">const</span> kSource = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'source'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Duplex</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> kSource = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'source'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyDuplex</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Duplex</span> </span>{
-  <span class="hljs-keyword">constructor</span>(source, options) {
-    <span class="hljs-built_in">super</span>(options);
-    <span class="hljs-built_in">this</span>[kSource] = source;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyDuplex</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Duplex</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">source, options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
+    <span class="hljs-variable language_">this</span>[kSource] = source;
   }
 
-  _write(chunk, encoding, callback) {
+  <span class="hljs-title function_">_write</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// The underlying source only deals with strings.</span>
-    <span class="hljs-keyword">if</span> (Buffer.isBuffer(chunk))
-      chunk = chunk.toString();
-    <span class="hljs-built_in">this</span>[kSource].writeSomeData(chunk);
-    callback();
+    <span class="hljs-keyword">if</span> (<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">isBuffer</span>(chunk))
+      chunk = chunk.<span class="hljs-title function_">toString</span>();
+    <span class="hljs-variable language_">this</span>[kSource].<span class="hljs-title function_">writeSomeData</span>(chunk);
+    <span class="hljs-title function_">callback</span>();
   }
 
-  _read(size) {
-    <span class="hljs-built_in">this</span>[kSource].fetchSomeData(size, <span class="hljs-function">(<span class="hljs-params">data, encoding</span>) =></span> {
-      <span class="hljs-built_in">this</span>.push(Buffer.from(data, encoding));
+  <span class="hljs-title function_">_read</span>(<span class="hljs-params">size</span>) {
+    <span class="hljs-variable language_">this</span>[kSource].<span class="hljs-title function_">fetchSomeData</span>(size, <span class="hljs-function">(<span class="hljs-params">data, encoding</span>) =></span> {
+      <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(data, encoding));
     });
   }
 }</code></pre>
 <p>The most important aspect of a <code>Duplex</code> stream is that the <code>Readable</code> and
 <code>Writable</code> sides operate independently of one another despite co-existing within
 a single object instance.</p>
-<h4>Object mode duplex streams<span><a class="mark" href="#stream_object_mode_duplex_streams" id="stream_object_mode_duplex_streams">#</a></span></h4>
+<h5>Object mode duplex streams<span><a class="mark" href="#stream_object_mode_duplex_streams" id="stream_object_mode_duplex_streams">#</a></span></h5>
 <p>For <code>Duplex</code> streams, <code>objectMode</code> can be set exclusively for either the
 <code>Readable</code> or <code>Writable</code> side using the <code>readableObjectMode</code> and
 <code>writableObjectMode</code> options respectively.</p>
@@ -2379,34 +2554,34 @@ a single object instance.</p>
 type of <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream) is created that has an object mode <code>Writable</code> side
 that accepts JavaScript numbers that are converted to hexadecimal strings on
 the <code>Readable</code> side.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Transform } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Transform</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
 <span class="hljs-comment">// All Transform streams are also Duplex Streams.</span>
-<span class="hljs-keyword">const</span> myTransform = <span class="hljs-keyword">new</span> Transform({
+<span class="hljs-keyword">const</span> myTransform = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Transform</span>({
   <span class="hljs-attr">writableObjectMode</span>: <span class="hljs-literal">true</span>,
 
-  transform(chunk, encoding, callback) {
+  <span class="hljs-title function_">transform</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// Coerce the chunk to a number if necessary.</span>
     chunk |= <span class="hljs-number">0</span>;
 
     <span class="hljs-comment">// Transform the chunk into something else.</span>
-    <span class="hljs-keyword">const</span> data = chunk.toString(<span class="hljs-number">16</span>);
+    <span class="hljs-keyword">const</span> data = chunk.<span class="hljs-title function_">toString</span>(<span class="hljs-number">16</span>);
 
     <span class="hljs-comment">// Push the data onto the readable queue.</span>
-    callback(<span class="hljs-literal">null</span>, <span class="hljs-string">'0'</span>.repeat(data.length % <span class="hljs-number">2</span>) + data);
+    <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, <span class="hljs-string">'0'</span>.<span class="hljs-title function_">repeat</span>(data.<span class="hljs-property">length</span> % <span class="hljs-number">2</span>) + data);
   }
 });
 
-myTransform.setEncoding(<span class="hljs-string">'ascii'</span>);
-myTransform.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> <span class="hljs-built_in">console</span>.log(chunk));
+myTransform.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'ascii'</span>);
+myTransform.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk));
 
-myTransform.write(<span class="hljs-number">1</span>);
+myTransform.<span class="hljs-title function_">write</span>(<span class="hljs-number">1</span>);
 <span class="hljs-comment">// Prints: 01</span>
-myTransform.write(<span class="hljs-number">10</span>);
+myTransform.<span class="hljs-title function_">write</span>(<span class="hljs-number">10</span>);
 <span class="hljs-comment">// Prints: 0a</span>
-myTransform.write(<span class="hljs-number">100</span>);
+myTransform.<span class="hljs-title function_">write</span>(<span class="hljs-number">100</span>);
 <span class="hljs-comment">// Prints: 64</span></code></pre>
-<h3>Implementing a transform stream<span><a class="mark" href="#stream_implementing_a_transform_stream" id="stream_implementing_a_transform_stream">#</a></span></h3>
+<h4>Implementing a transform stream<span><a class="mark" href="#stream_implementing_a_transform_stream" id="stream_implementing_a_transform_stream">#</a></span></h4>
 <p>A <a href="#stream_class_stream_transform"><code>Transform</code></a> stream is a <a href="#stream_class_stream_duplex"><code>Duplex</code></a> stream where the output is computed
 in some way from the input. Examples include <a href="zlib.html">zlib</a> streams or <a href="crypto.html">crypto</a>
 streams that compress, encrypt, or decrypt data.</p>
@@ -2424,7 +2599,7 @@ also implement the <a href="#stream_transform_flush_callback"><code>transform._f
 <p>Care must be taken when using <code>Transform</code> streams in that data written to the
 stream can cause the <code>Writable</code> side of the stream to become paused if the
 output on the <code>Readable</code> side is not consumed.</p>
-<h4><code>new stream.Transform([options])</code><span><a class="mark" href="#stream_new_stream_transform_options" id="stream_new_stream_transform_options">#</a></span></h4>
+<h5><code>new stream.Transform([options])</code><span><a class="mark" href="#stream_new_stream_transform_options" id="stream_new_stream_transform_options">#</a></span></h5>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Passed to both <code>Writable</code> and <code>Readable</code>
 constructors. Also has the following fields:
@@ -2437,40 +2612,43 @@ method.</li>
 </li>
 </ul>
 <!-- eslint-disable no-useless-constructor -->
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Transform } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Transform</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyTransform</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Transform</span> </span>{
-  <span class="hljs-keyword">constructor</span>(options) {
-    <span class="hljs-built_in">super</span>(options);
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyTransform</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">Transform</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">options</span>) {
+    <span class="hljs-variable language_">super</span>(options);
     <span class="hljs-comment">// ...</span>
   }
 }</code></pre>
 <p>Or, when using pre-ES6 style constructors:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Transform } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Transform</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 <span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyTransform</span>(<span class="hljs-params">options</span>) </span>{
-  <span class="hljs-keyword">if</span> (!(<span class="hljs-built_in">this</span> <span class="hljs-keyword">instanceof</span> MyTransform))
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> MyTransform(options);
-  Transform.call(<span class="hljs-built_in">this</span>, options);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyTransform</span>(<span class="hljs-params">options</span>) {
+  <span class="hljs-keyword">if</span> (!(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MyTransform</span>))
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyTransform</span>(options);
+  <span class="hljs-title class_">Transform</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, options);
 }
-util.inherits(MyTransform, Transform);</code></pre>
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyTransform</span>, <span class="hljs-title class_">Transform</span>);</code></pre>
 <p>Or, using the simplified constructor approach:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Transform } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Transform</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> myTransform = <span class="hljs-keyword">new</span> Transform({
-  transform(chunk, encoding, callback) {
+<span class="hljs-keyword">const</span> myTransform = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Transform</span>({
+  <span class="hljs-title function_">transform</span>(<span class="hljs-params">chunk, encoding, callback</span>) {
     <span class="hljs-comment">// ...</span>
   }
 });</code></pre>
-<h4>Events: <code>'finish'</code> and <code>'end'</code><span><a class="mark" href="#stream_events_finish_and_end" id="stream_events_finish_and_end">#</a></span></h4>
-<p>The <a href="#stream_event_finish"><code>'finish'</code></a> and <a href="#stream_event_end"><code>'end'</code></a> events are from the <code>stream.Writable</code>
-and <code>stream.Readable</code> classes, respectively. The <code>'finish'</code> event is emitted
-after <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> is called and all chunks have been processed
-by <a href="#stream_transform_transform_chunk_encoding_callback"><code>stream._transform()</code></a>. The <code>'end'</code> event is emitted
-after all data has been output, which occurs after the callback in
-<a href="#stream_transform_flush_callback"><code>transform._flush()</code></a> has been called.</p>
-<h4><code>transform._flush(callback)</code><span><a class="mark" href="#stream_transform_flush_callback" id="stream_transform_flush_callback">#</a></span></h4>
+<h5>Event: <code>'end'</code><span><a class="mark" href="#stream_event_end_1" id="stream_event_end_1">#</a></span></h5>
+<p>The <a href="#stream_event_end"><code>'end'</code></a> event is from the <code>stream.Readable</code> class. The <code>'end'</code> event is
+emitted after all data has been output, which occurs after the callback in
+<a href="#stream_transform_flush_callback"><code>transform._flush()</code></a> has been called. In the case of an error,
+<code>'end'</code> should not be emitted.</p>
+<h5>Event: <code>'finish'</code><span><a class="mark" href="#stream_event_finish_1" id="stream_event_finish_1">#</a></span></h5>
+<p>The <a href="#stream_event_finish"><code>'finish'</code></a> event is from the <code>stream.Writable</code> class. The <code>'finish'</code>
+event is emitted after <a href="#stream_writable_end_chunk_encoding_callback"><code>stream.end()</code></a> is called and all chunks
+have been processed by <a href="#stream_transform_transform_chunk_encoding_callback"><code>stream._transform()</code></a>. In the case
+of an error, <code>'finish'</code> should not be emitted.</p>
+<h5><code>transform._flush(callback)</code><span><a class="mark" href="#stream_transform_flush_callback" id="stream_transform_flush_callback">#</a></span></h5>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> A callback function (optionally with an error
 argument and data) to be called when remaining data has been flushed.</li>
@@ -2493,7 +2671,7 @@ be called when the flush operation is complete.</p>
 <p>The <code>transform._flush()</code> method is prefixed with an underscore because it is
 internal to the class that defines it, and should never be called directly by
 user programs.</p>
-<h4><code>transform._transform(chunk, encoding, callback)</code><span><a class="mark" href="#stream_transform_transform_chunk_encoding_callback" id="stream_transform_transform_chunk_encoding_callback">#</a></span></h4>
+<h5><code>transform._transform(chunk, encoding, callback)</code><span><a class="mark" href="#stream_transform_transform_chunk_encoding_callback" id="stream_transform_transform_chunk_encoding_callback">#</a></span></h5>
 <ul>
 <li><code>chunk</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The <code>Buffer</code> to be transformed, converted from
 the <code>string</code> passed to <a href="#stream_writable_write_chunk_encoding_callback"><code>stream.write()</code></a>. If the stream's
@@ -2523,13 +2701,13 @@ consumed. The first argument passed to the <code>callback</code> must be an <cod
 if an error occurred while processing the input or <code>null</code> otherwise. If a second
 argument is passed to the <code>callback</code>, it will be forwarded on to the
 <code>transform.push()</code> method. In other words, the following are equivalent:</p>
-<pre><code class="language-js">transform.prototype._transform = <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">data, encoding, callback</span>) </span>{
-  <span class="hljs-built_in">this</span>.push(data);
-  callback();
+<pre><code class="language-js">transform.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">_transform</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">data, encoding, callback</span>) {
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">push</span>(data);
+  <span class="hljs-title function_">callback</span>();
 };
 
-transform.prototype._transform = <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">data, encoding, callback</span>) </span>{
-  callback(<span class="hljs-literal">null</span>, data);
+transform.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">_transform</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">data, encoding, callback</span>) {
+  <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, data);
 };</code></pre>
 <p>The <code>transform._transform()</code> method is prefixed with an underscore because it
 is internal to the class that defines it, and should never be called directly by
@@ -2537,110 +2715,71 @@ user programs.</p>
 <p><code>transform._transform()</code> is never called in parallel; streams implement a
 queue mechanism, and to receive the next chunk, <code>callback</code> must be
 called, either synchronously or asynchronously.</p>
-<h4>Class: <code>stream.PassThrough</code><span><a class="mark" href="#stream_class_stream_passthrough" id="stream_class_stream_passthrough">#</a></span></h4>
+<h5>Class: <code>stream.PassThrough</code><span><a class="mark" href="#stream_class_stream_passthrough" id="stream_class_stream_passthrough">#</a></span></h5>
 <p>The <code>stream.PassThrough</code> class is a trivial implementation of a <a href="#stream_class_stream_transform"><code>Transform</code></a>
 stream that simply passes the input bytes across to the output. Its purpose is
 primarily for examples and testing, but there are some use cases where
 <code>stream.PassThrough</code> is useful as a building block for novel sorts of streams.</p>
-<h2>Additional notes<span><a class="mark" href="#stream_additional_notes" id="stream_additional_notes">#</a></span></h2>
+</section><section><h3>Additional notes<span><a class="mark" href="#stream_additional_notes" id="stream_additional_notes">#</a></span></h3>
 
-<h3>Streams compatibility with async generators and async iterators<span><a class="mark" href="#stream_streams_compatibility_with_async_generators_and_async_iterators" id="stream_streams_compatibility_with_async_generators_and_async_iterators">#</a></span></h3>
+<h4>Streams compatibility with async generators and async iterators<span><a class="mark" href="#stream_streams_compatibility_with_async_generators_and_async_iterators" id="stream_streams_compatibility_with_async_generators_and_async_iterators">#</a></span></h4>
 <p>With the support of async generators and iterators in JavaScript, async
 generators are effectively a first-class language-level stream construct at
 this point.</p>
 <p>Some common interop cases of using Node.js streams with async generators
 and async iterators are provided below.</p>
-<h4>Consuming readable streams with async iterators<span><a class="mark" href="#stream_consuming_readable_streams_with_async_iterators" id="stream_consuming_readable_streams_with_async_iterators">#</a></span></h4>
-<pre><code class="language-js">(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
+<h5>Consuming readable streams with async iterators<span><a class="mark" href="#stream_consuming_readable_streams_with_async_iterators" id="stream_consuming_readable_streams_with_async_iterators">#</a></span></h5>
+<pre><code class="language-js">(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> chunk <span class="hljs-keyword">of</span> readable) {
-    <span class="hljs-built_in">console</span>.log(chunk);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk);
   }
 })();</code></pre>
 <p>Async iterators register a permanent error handler on the stream to prevent any
 unhandled post-destroy errors.</p>
-<h4>Creating readable streams with async generators<span><a class="mark" href="#stream_creating_readable_streams_with_async_generators" id="stream_creating_readable_streams_with_async_generators">#</a></span></h4>
+<h5>Creating readable streams with async generators<span><a class="mark" href="#stream_creating_readable_streams_with_async_generators" id="stream_creating_readable_streams_with_async_generators">#</a></span></h5>
 <p>We can construct a Node.js readable stream from an asynchronous generator
 using the <code>Readable.from()</code> utility method:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Readable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Readable</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> * <span class="hljs-title">generate</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> * <span class="hljs-title function_">generate</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'a'</span>;
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'b'</span>;
   <span class="hljs-keyword">yield</span> <span class="hljs-string">'c'</span>;
 }
 
-<span class="hljs-keyword">const</span> readable = Readable.from(generate());
+<span class="hljs-keyword">const</span> readable = <span class="hljs-title class_">Readable</span>.<span class="hljs-title function_">from</span>(<span class="hljs-title function_">generate</span>());
 
-readable.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(chunk);
+readable.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">chunk</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(chunk);
 });</code></pre>
-<h4>Piping to writable streams from async iterators<span><a class="mark" href="#stream_piping_to_writable_streams_from_async_iterators" id="stream_piping_to_writable_streams_from_async_iterators">#</a></span></h4>
-<p>In the scenario of writing to a writable stream from an async iterator, ensure
-the correct handling of backpressure and errors.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { once } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
-<span class="hljs-keyword">const</span> finished = util.promisify(stream.finished);
-
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'./file'</span>);
+<h5>Piping to writable streams from async iterators<span><a class="mark" href="#stream_piping_to_writable_streams_from_async_iterators" id="stream_piping_to_writable_streams_from_async_iterators">#</a></span></h5>
+<p>When writing to a writable stream from an async iterator, ensure correct
+handling of backpressure and errors. <a href="#stream_stream_pipeline_source_transforms_destination_callback"><code>stream.pipeline()</code></a> abstracts away
+the handling of backpressure and backpressure-related errors:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
+<span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">drain</span>(<span class="hljs-params">writable</span>) </span>{
-  <span class="hljs-keyword">if</span> (writable.destroyed) {
-    <span class="hljs-keyword">return</span> <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'premature close'</span>));
-  }
-  <span class="hljs-keyword">return</span> <span class="hljs-built_in">Promise</span>.race([
-    once(writable, <span class="hljs-string">'drain'</span>),
-    once(writable, <span class="hljs-string">'close'</span>)
-      .then(<span class="hljs-function">() =></span> <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'premature close'</span>)))
-  ]);
-}
+<span class="hljs-keyword">const</span> writable = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'./file'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">pump</span>(<span class="hljs-params">iterable, writable</span>) </span>{
-  <span class="hljs-keyword">for</span> <span class="hljs-keyword">await</span> (<span class="hljs-keyword">const</span> chunk <span class="hljs-keyword">of</span> iterable) {
-    <span class="hljs-comment">// Handle backpressure on write().</span>
-    <span class="hljs-keyword">if</span> (!writable.write(chunk)) {
-      <span class="hljs-keyword">await</span> drain(writable);
-    }
+<span class="hljs-comment">// Callback Pattern</span>
+<span class="hljs-title function_">pipeline</span>(iterator, writable, <span class="hljs-function">(<span class="hljs-params">err, value</span>) =></span> {
+  <span class="hljs-keyword">if</span> (err) {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(err);
+  } <span class="hljs-keyword">else</span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value, <span class="hljs-string">'value returned'</span>);
   }
-  writable.end();
-}
-
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-comment">// Ensure completion without errors.</span>
-  <span class="hljs-keyword">await</span> <span class="hljs-built_in">Promise</span>.all([
-    pump(iterable, writable),
-    finished(writable)
-  ]);
-})();</code></pre>
-<p>In the above, errors on <code>write()</code> would be caught and thrown by the
-<code>once()</code> listener for the <code>'drain'</code> event, since <code>once()</code> will also handle the
-<code>'error'</code> event. To ensure completion of the write stream without errors,
-it is safer to use the <code>finished()</code> method as above, instead of using the
-<code>once()</code> listener for the <code>'finish'</code> event. Under certain cases, an <code>'error'</code>
-event could be emitted by the writable stream after <code>'finish'</code> and as <code>once()</code>
-will release the <code>'error'</code> handler on handling the <code>'finish'</code> event, it could
-result in an unhandled error.</p>
-<p>Alternatively, the readable stream could be wrapped with <code>Readable.from()</code> and
-then piped via <code>.pipe()</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> finished = util.promisify(stream.finished);
-
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'./file'</span>);
-
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> readable = Readable.from(iterable);
-  readable.pipe(writable);
-  <span class="hljs-comment">// Ensure completion without errors.</span>
-  <span class="hljs-keyword">await</span> finished(writable);
-})();</code></pre>
-<p>Or, using <code>stream.pipeline()</code> to pipe streams:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> pipeline = util.promisify(stream.pipeline);
-
-<span class="hljs-keyword">const</span> writable = fs.createWriteStream(<span class="hljs-string">'./file'</span>);
+});
 
-(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> readable = Readable.from(iterable);
-  <span class="hljs-keyword">await</span> pipeline(readable, writable);
-})();</code></pre>
+<span class="hljs-comment">// Promise Pattern</span>
+<span class="hljs-keyword">const</span> pipelinePromise = util.<span class="hljs-title function_">promisify</span>(pipeline);
+<span class="hljs-title function_">pipelinePromise</span>(iterator, writable)
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(value, <span class="hljs-string">'value returned'</span>);
+  })
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">error</span>);</code></pre>
 
-<h3>Compatibility with older Node.js versions<span><a class="mark" href="#stream_compatibility_with_older_node_js_versions" id="stream_compatibility_with_older_node_js_versions">#</a></span></h3>
+<h4>Compatibility with older Node.js versions<span><a class="mark" href="#stream_compatibility_with_older_node_js_versions" id="stream_compatibility_with_older_node_js_versions">#</a></span></h4>
 
 <p>Prior to Node.js 0.10, the <code>Readable</code> stream interface was simpler, but also
 less powerful and less useful.</p>
@@ -2669,32 +2808,32 @@ edge case in the following conditions:</p>
 </ul>
 <p>For example, consider the following code:</p>
 <pre><code class="language-js"><span class="hljs-comment">// WARNING!  BROKEN!</span>
-net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
 
   <span class="hljs-comment">// We add an 'end' listener, but never consume the data.</span>
-  socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
     <span class="hljs-comment">// It will never get here.</span>
-    socket.end(<span class="hljs-string">'The message was received but was not processed.\n'</span>);
+    socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'The message was received but was not processed.\n'</span>);
   });
 
-}).listen(<span class="hljs-number">1337</span>);</code></pre>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
 <p>Prior to Node.js 0.10, the incoming message data would be simply discarded.
 However, in Node.js 0.10 and beyond, the socket remains paused forever.</p>
 <p>The workaround in this situation is to call the
 <a href="#stream_readable_resume"><code>stream.resume()</code></a> method to begin the flow of data:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Workaround.</span>
-net.createServer(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-    socket.end(<span class="hljs-string">'The message was received but was not processed.\n'</span>);
+net.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+    socket.<span class="hljs-title function_">end</span>(<span class="hljs-string">'The message was received but was not processed.\n'</span>);
   });
 
   <span class="hljs-comment">// Start the flow of data, discarding it.</span>
-  socket.resume();
-}).listen(<span class="hljs-number">1337</span>);</code></pre>
+  socket.<span class="hljs-title function_">resume</span>();
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
 <p>In addition to new <code>Readable</code> streams switching into flowing mode,
 pre-0.10 style streams can be wrapped in a <code>Readable</code> class using the
 <a href="#stream_readable_wrap_stream"><code>readable.wrap()</code></a> method.</p>
-<h3><code>readable.read(0)</code><span><a class="mark" href="#stream_readable_read_0" id="stream_readable_read_0">#</a></span></h3>
+<h4><code>readable.read(0)</code><span><a class="mark" href="#stream_readable_read_0" id="stream_readable_read_0">#</a></span></h4>
 <p>There are some cases where it is necessary to trigger a refresh of the
 underlying readable stream mechanisms, without actually consuming any
 data. In such cases, it is possible to call <code>readable.read(0)</code>, which will
@@ -2705,14 +2844,14 @@ a low-level <a href="#stream_readable_read_size_1"><code>stream._read()</code></
 <p>While most applications will almost never need to do this, there are
 situations within Node.js where this is done, particularly in the
 <code>Readable</code> stream class internals.</p>
-<h3><code>readable.push('')</code><span><a class="mark" href="#stream_readable_push" id="stream_readable_push">#</a></span></h3>
+<h4><code>readable.push('')</code><span><a class="mark" href="#stream_readable_push" id="stream_readable_push">#</a></span></h4>
 <p>Use of <code>readable.push('')</code> is not recommended.</p>
 <p>Pushing a zero-byte string, <code>Buffer</code> or <code>Uint8Array</code> to a stream that is not in
 object mode has an interesting side effect. Because it <em>is</em> a call to
 <a href="#stream_readable_push_chunk_encoding"><code>readable.push()</code></a>, the call will end the reading process.
 However, because the argument is an empty string, no data is added to the
 readable buffer so there is nothing for a user to consume.</p>
-<h3><code>highWaterMark</code> discrepancy after calling <code>readable.setEncoding()</code><span><a class="mark" href="#stream_highwatermark_discrepancy_after_calling_readable_setencoding" id="stream_highwatermark_discrepancy_after_calling_readable_setencoding">#</a></span></h3>
+<h4><code>highWaterMark</code> discrepancy after calling <code>readable.setEncoding()</code><span><a class="mark" href="#stream_highwatermark_discrepancy_after_calling_readable_setencoding" id="stream_highwatermark_discrepancy_after_calling_readable_setencoding">#</a></span></h4>
 <p>The use of <code>readable.setEncoding()</code> will change the behavior of how the
 <code>highWaterMark</code> operates in non-object mode.</p>
 <p>Typically, the size of the current buffer is measured against the
@@ -2720,10 +2859,46 @@ readable buffer so there is nothing for a user to consume.</p>
 comparison function will begin to measure the buffer's size in <em>characters</em>.</p>
 <p>This is not a problem in common cases with <code>latin1</code> or <code>ascii</code>. But it is
 advised to be mindful about this behavior when working with strings that could
-contain multi-byte characters.</p>
+contain multi-byte characters.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/stream.json b/doc/api/stream.json
index 1e37bc606931acd450bcff0a7dbd5e79c3c05f3e..ed6eb589cd3a5e21356b3bb0093bc5ed7aaf83ff 100644
--- a/doc/api/stream.json
+++ b/doc/api/stream.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/stream.js\">lib/stream.js</a></p>\n<p>A stream is an abstract interface for working with streaming data in Node.js.\nThe <code>stream</code> module provides an API for implementing the stream interface.</p>\n<p>There are many stream objects provided by Node.js. For instance, a\n<a href=\"http.html#http_class_http_incomingmessage\">request to an HTTP server</a> and <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a>\nare both stream instances.</p>\n<p>Streams can be readable, writable, or both. All streams are instances of\n<a href=\"events.html#events_class_eventemitter\"><code>EventEmitter</code></a>.</p>\n<p>To access the <code>stream</code> module:</p>\n<pre><code class=\"language-js\">const stream = require('stream');\n</code></pre>\n<p>The <code>stream</code> module is useful for creating new types of stream instances. It is\nusually not necessary to use the <code>stream</code> module to consume streams.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/stream.js\">lib/stream.js</a></p>\n<p>A stream is an abstract interface for working with streaming data in Node.js.\nThe <code>stream</code> module provides an API for implementing the stream interface.</p>\n<p>There are many stream objects provided by Node.js. For instance, a\n<a href=\"http.html#http_class_http_incomingmessage\">request to an HTTP server</a> and <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a>\nare both stream instances.</p>\n<p>Streams can be readable, writable, or both. All streams are instances of\n<a href=\"events.html#events_class_eventemitter\"><code>EventEmitter</code></a>.</p>\n<p>To access the <code>stream</code> module:</p>\n<pre><code class=\"language-js\">const stream = require('stream');\n</code></pre>\n<p>The <code>stream</code> module is useful for creating new types of stream instances. It is\nusually not necessary to use the <code>stream</code> module to consume streams.</p>",
       "modules": [
         {
           "textRaw": "Organization of this document",
@@ -20,7 +20,7 @@
         {
           "textRaw": "Types of streams",
           "name": "types_of_streams",
-          "desc": "<p>There are four fundamental stream types within Node.js:</p>\n<ul>\n<li><a href=\"#stream_class_stream_writable\"><code>Writable</code></a>: streams to which data can be written (for example,\n<a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>).</li>\n<li><a href=\"#stream_class_stream_readable\"><code>Readable</code></a>: streams from which data can be read (for example,\n<a href=\"fs.html#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a>).</li>\n<li><a href=\"#stream_class_stream_duplex\"><code>Duplex</code></a>: streams that are both <code>Readable</code> and <code>Writable</code> (for example,\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>).</li>\n<li><a href=\"#stream_class_stream_transform\"><code>Transform</code></a>: <code>Duplex</code> streams that can modify or transform the data as it\nis written and read (for example, <a href=\"zlib.html#zlib_zlib_createdeflate_options\"><code>zlib.createDeflate()</code></a>).</li>\n</ul>\n<p>Additionally, this module includes the utility functions\n<a href=\"#stream_stream_pipeline_streams_callback\"><code>stream.pipeline()</code></a>, <a href=\"#stream_stream_finished_stream_options_callback\"><code>stream.finished()</code></a> and\n<a href=\"#stream_stream_readable_from_iterable_options\"><code>stream.Readable.from()</code></a>.</p>",
+          "desc": "<p>There are four fundamental stream types within Node.js:</p>\n<ul>\n<li><a href=\"#stream_class_stream_writable\"><code>Writable</code></a>: streams to which data can be written (for example,\n<a href=\"fs.html#fs_fs_createwritestream_path_options\"><code>fs.createWriteStream()</code></a>).</li>\n<li><a href=\"#stream_class_stream_readable\"><code>Readable</code></a>: streams from which data can be read (for example,\n<a href=\"fs.html#fs_fs_createreadstream_path_options\"><code>fs.createReadStream()</code></a>).</li>\n<li><a href=\"#stream_class_stream_duplex\"><code>Duplex</code></a>: streams that are both <code>Readable</code> and <code>Writable</code> (for example,\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a>).</li>\n<li><a href=\"#stream_class_stream_transform\"><code>Transform</code></a>: <code>Duplex</code> streams that can modify or transform the data as it\nis written and read (for example, <a href=\"zlib.html#zlib_zlib_createdeflate_options\"><code>zlib.createDeflate()</code></a>).</li>\n</ul>\n<p>Additionally, this module includes the utility functions\n<a href=\"#stream_stream_pipeline_source_transforms_destination_callback\"><code>stream.pipeline()</code></a>, <a href=\"#stream_stream_finished_stream_options_callback\"><code>stream.finished()</code></a> and\n<a href=\"#stream_stream_readable_from_iterable_options\"><code>stream.Readable.from()</code></a>.</p>",
           "modules": [
             {
               "textRaw": "Object mode",
@@ -35,7 +35,7 @@
               "textRaw": "Buffering",
               "name": "Buffering",
               "type": "misc",
-              "desc": "<p>Both <a href=\"#stream_class_stream_writable\"><code>Writable</code></a> and <a href=\"#stream_class_stream_readable\"><code>Readable</code></a> streams will store data in an internal\nbuffer that can be retrieved using <code>writable.writableBuffer</code> or\n<code>readable.readableBuffer</code>, respectively.</p>\n<p>The amount of data potentially buffered depends on the <code>highWaterMark</code> option\npassed into the stream's constructor. For normal streams, the <code>highWaterMark</code>\noption specifies a <a href=\"#stream_highwatermark_discrepancy_after_calling_readable_setencoding\">total number of bytes</a>. For streams operating\nin object mode, the <code>highWaterMark</code> specifies a total number of objects.</p>\n<p>Data is buffered in <code>Readable</code> streams when the implementation calls\n<a href=\"#stream_readable_push_chunk_encoding\"><code>stream.push(chunk)</code></a>. If the consumer of the Stream does not\ncall <a href=\"#stream_readable_read_size\"><code>stream.read()</code></a>, the data will sit in the internal\nqueue until it is consumed.</p>\n<p>Once the total size of the internal read buffer reaches the threshold specified\nby <code>highWaterMark</code>, the stream will temporarily stop reading data from the\nunderlying resource until the data currently buffered can be consumed (that is,\nthe stream will stop calling the internal <a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> method that is\nused to fill the read buffer).</p>\n<p>Data is buffered in <code>Writable</code> streams when the\n<a href=\"#stream_writable_write_chunk_encoding_callback\"><code>writable.write(chunk)</code></a> method is called repeatedly. While the\ntotal size of the internal write buffer is below the threshold set by\n<code>highWaterMark</code>, calls to <code>writable.write()</code> will return <code>true</code>. Once\nthe size of the internal buffer reaches or exceeds the <code>highWaterMark</code>, <code>false</code>\nwill be returned.</p>\n<p>A key goal of the <code>stream</code> API, particularly the <a href=\"#stream_readable_pipe_destination_options\"><code>stream.pipe()</code></a> method,\nis to limit the buffering of data to acceptable levels such that sources and\ndestinations of differing speeds will not overwhelm the available memory.</p>\n<p>The <code>highWaterMark</code> option is a threshold, not a limit: it dictates the amount\nof data that a stream buffers before it stops asking for more data. It does not\nenforce a strict memory limitation in general. Specific stream implementations\nmay choose to enforce stricter limits but doing so is optional.</p>\n<p>Because <a href=\"#stream_class_stream_duplex\"><code>Duplex</code></a> and <a href=\"#stream_class_stream_transform\"><code>Transform</code></a> streams are both <code>Readable</code> and\n<code>Writable</code>, each maintains <em>two</em> separate internal buffers used for reading and\nwriting, allowing each side to operate independently of the other while\nmaintaining an appropriate and efficient flow of data. For example,\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> instances are <a href=\"#stream_class_stream_duplex\"><code>Duplex</code></a> streams whose <code>Readable</code> side allows\nconsumption of data received <em>from</em> the socket and whose <code>Writable</code> side allows\nwriting data <em>to</em> the socket. Because data may be written to the socket at a\nfaster or slower rate than data is received, each side should\noperate (and buffer) independently of the other.</p>"
+              "desc": "<p>Both <a href=\"#stream_class_stream_writable\"><code>Writable</code></a> and <a href=\"#stream_class_stream_readable\"><code>Readable</code></a> streams will store data in an internal\nbuffer.</p>\n<p>The amount of data potentially buffered depends on the <code>highWaterMark</code> option\npassed into the stream's constructor. For normal streams, the <code>highWaterMark</code>\noption specifies a <a href=\"#stream_highwatermark_discrepancy_after_calling_readable_setencoding\">total number of bytes</a>. For streams operating\nin object mode, the <code>highWaterMark</code> specifies a total number of objects.</p>\n<p>Data is buffered in <code>Readable</code> streams when the implementation calls\n<a href=\"#stream_readable_push_chunk_encoding\"><code>stream.push(chunk)</code></a>. If the consumer of the Stream does not\ncall <a href=\"#stream_readable_read_size\"><code>stream.read()</code></a>, the data will sit in the internal\nqueue until it is consumed.</p>\n<p>Once the total size of the internal read buffer reaches the threshold specified\nby <code>highWaterMark</code>, the stream will temporarily stop reading data from the\nunderlying resource until the data currently buffered can be consumed (that is,\nthe stream will stop calling the internal <a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> method that is\nused to fill the read buffer).</p>\n<p>Data is buffered in <code>Writable</code> streams when the\n<a href=\"#stream_writable_write_chunk_encoding_callback\"><code>writable.write(chunk)</code></a> method is called repeatedly. While the\ntotal size of the internal write buffer is below the threshold set by\n<code>highWaterMark</code>, calls to <code>writable.write()</code> will return <code>true</code>. Once\nthe size of the internal buffer reaches or exceeds the <code>highWaterMark</code>, <code>false</code>\nwill be returned.</p>\n<p>A key goal of the <code>stream</code> API, particularly the <a href=\"#stream_readable_pipe_destination_options\"><code>stream.pipe()</code></a> method,\nis to limit the buffering of data to acceptable levels such that sources and\ndestinations of differing speeds will not overwhelm the available memory.</p>\n<p>The <code>highWaterMark</code> option is a threshold, not a limit: it dictates the amount\nof data that a stream buffers before it stops asking for more data. It does not\nenforce a strict memory limitation in general. Specific stream implementations\nmay choose to enforce stricter limits but doing so is optional.</p>\n<p>Because <a href=\"#stream_class_stream_duplex\"><code>Duplex</code></a> and <a href=\"#stream_class_stream_transform\"><code>Transform</code></a> streams are both <code>Readable</code> and\n<code>Writable</code>, each maintains <em>two</em> separate internal buffers used for reading and\nwriting, allowing each side to operate independently of the other while\nmaintaining an appropriate and efficient flow of data. For example,\n<a href=\"net.html#net_class_net_socket\"><code>net.Socket</code></a> instances are <a href=\"#stream_class_stream_duplex\"><code>Duplex</code></a> streams whose <code>Readable</code> side allows\nconsumption of data received <em>from</em> the socket and whose <code>Writable</code> side allows\nwriting data <em>to</em> the socket. Because data may be written to the socket at a\nfaster or slower rate than data is received, each side should\noperate (and buffer) independently of the other.</p>\n<p>The mechanics of the internal buffering are an internal implementation detail\nand may be changed at any time. However, for certain advanced implementations,\nthe internal buffers can be retrieved using <code>writable.writableBuffer</code> or\n<code>readable.readableBuffer</code>. Use of these undocumented properties is discouraged.</p>"
             }
           ],
           "type": "module",
@@ -51,7 +51,23 @@
             "added": [
               "v10.0.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32158",
+                "description": "The `finished(stream, cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+              },
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31545",
+                "description": "Emitting `'close'` before `'end'` on a `Readable` stream will cause an `ERR_STREAM_PREMATURE_CLOSE` error."
+              },
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31509",
+                "description": "Callback will be invoked on streams which have already finished before the call to `finished(stream, cb)`."
+              }
+            ]
           },
           "signatures": [
             {
@@ -105,23 +121,84 @@
           "desc": "<p>A function to get notified when a stream is no longer readable, writable\nor has experienced an error or a premature close event.</p>\n<pre><code class=\"language-js\">const { finished } = require('stream');\n\nconst rs = fs.createReadStream('archive.tar');\n\nfinished(rs, (err) => {\n  if (err) {\n    console.error('Stream failed.', err);\n  } else {\n    console.log('Stream is done reading.');\n  }\n});\n\nrs.resume(); // Drain the stream.\n</code></pre>\n<p>Especially useful in error handling scenarios where a stream is destroyed\nprematurely (like an aborted HTTP request), and will not emit <code>'end'</code>\nor <code>'finish'</code>.</p>\n<p>The <code>finished</code> API is promisify-able as well;</p>\n<pre><code class=\"language-js\">const finished = util.promisify(stream.finished);\n\nconst rs = fs.createReadStream('archive.tar');\n\nasync function run() {\n  await finished(rs);\n  console.log('Stream is done reading.');\n}\n\nrun().catch(console.error);\nrs.resume(); // Drain the stream.\n</code></pre>\n<p><code>stream.finished()</code> leaves dangling event listeners (in particular\n<code>'error'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code>) after <code>callback</code> has been\ninvoked. The reason for this is so that unexpected <code>'error'</code> events (due to\nincorrect stream implementations) do not cause unexpected crashes.\nIf this is unwanted behavior then the returned cleanup function needs to be\ninvoked in the callback:</p>\n<pre><code class=\"language-js\">const cleanup = finished(rs, (err) => {\n  cleanup();\n  // ...\n});\n</code></pre>"
         },
         {
-          "textRaw": "`stream.pipeline(...streams, callback)`",
+          "textRaw": "`stream.pipeline(source[, ...transforms], destination, callback)`",
           "type": "method",
           "name": "pipeline",
           "meta": {
             "added": [
               "v10.0.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32158",
+                "description": "The `pipeline(..., cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+              },
+              {
+                "version": "v13.10.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31223",
+                "description": "Add support for async generators."
+              }
+            ]
           },
           "signatures": [
             {
+              "return": {
+                "textRaw": "Returns: {Stream}",
+                "name": "return",
+                "type": "Stream"
+              },
               "params": [
                 {
-                  "textRaw": "`...streams` {Stream} Two or more streams to pipe between.",
-                  "name": "...streams",
-                  "type": "Stream",
-                  "desc": "Two or more streams to pipe between."
+                  "textRaw": "`streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}",
+                  "name": "streams",
+                  "type": "Stream[]|Iterable[]|AsyncIterable[]|Function[]"
+                },
+                {
+                  "textRaw": "`source` {Stream|Iterable|AsyncIterable|Function}",
+                  "name": "source",
+                  "type": "Stream|Iterable|AsyncIterable|Function",
+                  "options": [
+                    {
+                      "textRaw": "Returns: {Iterable|AsyncIterable}",
+                      "name": "return",
+                      "type": "Iterable|AsyncIterable"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`...transforms` {Stream|Function}",
+                  "name": "...transforms",
+                  "type": "Stream|Function",
+                  "options": [
+                    {
+                      "textRaw": "`source` {AsyncIterable}",
+                      "name": "source",
+                      "type": "AsyncIterable"
+                    },
+                    {
+                      "textRaw": "Returns: {AsyncIterable}",
+                      "name": "return",
+                      "type": "AsyncIterable"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`destination` {Stream|Function}",
+                  "name": "destination",
+                  "type": "Stream|Function",
+                  "options": [
+                    {
+                      "textRaw": "`source` {AsyncIterable}",
+                      "name": "source",
+                      "type": "AsyncIterable"
+                    },
+                    {
+                      "textRaw": "Returns: {AsyncIterable|Promise}",
+                      "name": "return",
+                      "type": "AsyncIterable|Promise"
+                    }
+                  ]
                 },
                 {
                   "textRaw": "`callback` {Function} Called when the pipeline is fully done.",
@@ -133,13 +210,121 @@
                       "textRaw": "`err` {Error}",
                       "name": "err",
                       "type": "Error"
+                    },
+                    {
+                      "textRaw": "`val` Resolved value of `Promise` returned by `destination`.",
+                      "name": "val",
+                      "desc": "Resolved value of `Promise` returned by `destination`."
                     }
                   ]
                 }
               ]
             }
           ],
-          "desc": "<p>A module method to pipe between streams forwarding errors and properly cleaning\nup and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
+          "desc": "<p>A module method to pipe between streams and generators forwarding errors and\nproperly cleaning up and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p>The <code>pipeline</code> API also supports async generators:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\nconst fs = require('fs');\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('lowercase.txt'),\n    async function* (source) {\n      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.\n      for await (const chunk of source) {\n        yield chunk.toUpperCase();\n      }\n    },\n    fs.createWriteStream('uppercase.txt')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
+        },
+        {
+          "textRaw": "`stream.pipeline(streams, callback)`",
+          "type": "method",
+          "name": "pipeline",
+          "meta": {
+            "added": [
+              "v10.0.0"
+            ],
+            "changes": [
+              {
+                "version": "v14.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32158",
+                "description": "The `pipeline(..., cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+              },
+              {
+                "version": "v13.10.0",
+                "pr-url": "https://github.com/nodejs/node/pull/31223",
+                "description": "Add support for async generators."
+              }
+            ]
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {Stream}",
+                "name": "return",
+                "type": "Stream"
+              },
+              "params": [
+                {
+                  "textRaw": "`streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}",
+                  "name": "streams",
+                  "type": "Stream[]|Iterable[]|AsyncIterable[]|Function[]"
+                },
+                {
+                  "textRaw": "`source` {Stream|Iterable|AsyncIterable|Function}",
+                  "name": "source",
+                  "type": "Stream|Iterable|AsyncIterable|Function",
+                  "options": [
+                    {
+                      "textRaw": "Returns: {Iterable|AsyncIterable}",
+                      "name": "return",
+                      "type": "Iterable|AsyncIterable"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`...transforms` {Stream|Function}",
+                  "name": "...transforms",
+                  "type": "Stream|Function",
+                  "options": [
+                    {
+                      "textRaw": "`source` {AsyncIterable}",
+                      "name": "source",
+                      "type": "AsyncIterable"
+                    },
+                    {
+                      "textRaw": "Returns: {AsyncIterable}",
+                      "name": "return",
+                      "type": "AsyncIterable"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`destination` {Stream|Function}",
+                  "name": "destination",
+                  "type": "Stream|Function",
+                  "options": [
+                    {
+                      "textRaw": "`source` {AsyncIterable}",
+                      "name": "source",
+                      "type": "AsyncIterable"
+                    },
+                    {
+                      "textRaw": "Returns: {AsyncIterable|Promise}",
+                      "name": "return",
+                      "type": "AsyncIterable|Promise"
+                    }
+                  ]
+                },
+                {
+                  "textRaw": "`callback` {Function} Called when the pipeline is fully done.",
+                  "name": "callback",
+                  "type": "Function",
+                  "desc": "Called when the pipeline is fully done.",
+                  "options": [
+                    {
+                      "textRaw": "`err` {Error}",
+                      "name": "err",
+                      "type": "Error"
+                    },
+                    {
+                      "textRaw": "`val` Resolved value of `Promise` returned by `destination`.",
+                      "name": "val",
+                      "desc": "Resolved value of `Promise` returned by `destination`."
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "desc": "<p>A module method to pipe between streams and generators forwarding errors and\nproperly cleaning up and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p>The <code>pipeline</code> API also supports async generators:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\nconst fs = require('fs');\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('lowercase.txt'),\n    async function* (source) {\n      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.\n      for await (const chunk of source) {\n        yield chunk.toUpperCase();\n      }\n    },\n    fs.createWriteStream('uppercase.txt')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
         },
         {
           "textRaw": "`stream.Readable.from(iterable, [options])`",
@@ -271,7 +456,7 @@
                           "type": "Error"
                         }
                       ],
-                      "desc": "<p>The <code>'error'</code> event is emitted if an error occurred while writing or piping\ndata. The listener callback is passed a single <code>Error</code> argument when called.</p>\n<p>The stream is not closed when the <code>'error'</code> event is emitted unless the\n<a href=\"#stream_new_stream_writable_options\"><code>autoDestroy</code></a> option was set to <code>true</code> when creating the\nstream.</p>"
+                      "desc": "<p>The <code>'error'</code> event is emitted if an error occurred while writing or piping\ndata. The listener callback is passed a single <code>Error</code> argument when called.</p>\n<p>The stream is closed when the <code>'error'</code> event is emitted unless the\n<a href=\"#stream_new_stream_writable_options\"><code>autoDestroy</code></a> option was set to <code>false</code> when creating the\nstream.</p>\n<p>After <code>'error'</code>, no further events other than <code>'close'</code> <em>should</em> be emitted\n(including <code>'error'</code> events).</p>"
                     },
                     {
                       "textRaw": "Event: `'finish'`",
@@ -353,7 +538,13 @@
                         "added": [
                           "v8.0.0"
                         ],
-                        "changes": []
+                        "changes": [
+                          {
+                            "version": "v14.0.0",
+                            "pr-url": "https://github.com/nodejs/node/pull/29197",
+                            "description": "Work as a no-op on a stream that has already been destroyed."
+                          }
+                        ]
                       },
                       "signatures": [
                         {
@@ -372,7 +563,7 @@
                           ]
                         }
                       ],
-                      "desc": "<p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>\nevent (unless <code>emitClose</code> is set to <code>false</code>). After this call, the writable\nstream has ended and subsequent calls to <code>write()</code> or <code>end()</code> will result in\nan <code>ERR_STREAM_DESTROYED</code> error.\nThis is a destructive and immediate way to destroy a stream. Previous calls to\n<code>write()</code> may not have drained, and may trigger an <code>ERR_STREAM_DESTROYED</code> error.\nUse <code>end()</code> instead of destroy if data should flush before close, or wait for\nthe <code>'drain'</code> event before destroying the stream.\nImplementors should not override this method,\nbut instead implement <a href=\"#stream_writable_destroy_err_callback\"><code>writable._destroy()</code></a>.</p>"
+                      "desc": "<p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>\nevent (unless <code>emitClose</code> is set to <code>false</code>). After this call, the writable\nstream has ended and subsequent calls to <code>write()</code> or <code>end()</code> will result in\nan <code>ERR_STREAM_DESTROYED</code> error.\nThis is a destructive and immediate way to destroy a stream. Previous calls to\n<code>write()</code> may not have drained, and may trigger an <code>ERR_STREAM_DESTROYED</code> error.\nUse <code>end()</code> instead of destroy if data should flush before close, or wait for\nthe <code>'drain'</code> event before destroying the stream.</p>\n<pre><code class=\"language-cjs\">const { Writable } = require('stream');\n\nconst myStream = new Writable();\n\nconst fooErr = new Error('foo error');\nmyStream.destroy(fooErr);\nmyStream.on('error', (fooErr) => console.error(fooErr.message)); // foo error\n</code></pre>\n<pre><code class=\"language-cjs\">const { Writable } = require('stream');\n\nconst myStream = new Writable();\n\nmyStream.destroy();\nmyStream.on('error', function wontHappen() {});\n</code></pre>\n<pre><code class=\"language-cjs\">const { Writable } = require('stream');\n\nconst myStream = new Writable();\nmyStream.destroy();\n\nmyStream.write('foo', (error) => console.error(error.code));\n// ERR_STREAM_DESTROYED\n</code></pre>\n<p>Once <code>destroy()</code> has been called any further calls will be a no-op and no\nfurther errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>\n<p>Implementors should not override this method,\nbut instead implement <a href=\"#stream_writable_destroy_err_callback\"><code>writable._destroy()</code></a>.</p>"
                     },
                     {
                       "textRaw": "`writable.end([chunk[, encoding]][, callback])`",
@@ -383,6 +574,11 @@
                           "v0.9.4"
                         ],
                         "changes": [
+                          {
+                            "version": "v14.0.0",
+                            "pr-url": "https://github.com/nodejs/node/pull/29747",
+                            "description": "The `callback` is invoked if 'finish' or 'error' is emitted."
+                          },
                           {
                             "version": "v10.0.0",
                             "pr-url": "https://github.com/nodejs/node/pull/18780",
@@ -416,15 +612,15 @@
                               "desc": "The encoding if `chunk` is a string"
                             },
                             {
-                              "textRaw": "`callback` {Function} Optional callback for when the stream is finished",
+                              "textRaw": "`callback` {Function} Optional callback for when the stream finishes or errors",
                               "name": "callback",
                               "type": "Function",
-                              "desc": "Optional callback for when the stream is finished"
+                              "desc": "Optional callback for when the stream finishes or errors"
                             }
                           ]
                         }
                       ],
-                      "desc": "<p>Calling the <code>writable.end()</code> method signals that no more data will be written\nto the <a href=\"#stream_class_stream_writable\"><code>Writable</code></a>. The optional <code>chunk</code> and <code>encoding</code> arguments allow one\nfinal additional chunk of data to be written immediately before closing the\nstream. If provided, the optional <code>callback</code> function is attached as a listener\nfor the <a href=\"#stream_event_finish\"><code>'finish'</code></a> event.</p>\n<p>Calling the <a href=\"#stream_writable_write_chunk_encoding_callback\"><code>stream.write()</code></a> method after calling\n<a href=\"#stream_writable_end_chunk_encoding_callback\"><code>stream.end()</code></a> will raise an error.</p>\n<pre><code class=\"language-js\">// Write 'hello, ' and then end with 'world!'.\nconst fs = require('fs');\nconst file = fs.createWriteStream('example.txt');\nfile.write('hello, ');\nfile.end('world!');\n// Writing more now is not allowed!\n</code></pre>"
+                      "desc": "<p>Calling the <code>writable.end()</code> method signals that no more data will be written\nto the <a href=\"#stream_class_stream_writable\"><code>Writable</code></a>. The optional <code>chunk</code> and <code>encoding</code> arguments allow one\nfinal additional chunk of data to be written immediately before closing the\nstream. If provided, the optional <code>callback</code> function is attached as a listener\nfor the <a href=\"#stream_event_finish\"><code>'finish'</code></a> and the <code>'error'</code> event.</p>\n<p>Calling the <a href=\"#stream_writable_write_chunk_encoding_callback\"><code>stream.write()</code></a> method after calling\n<a href=\"#stream_writable_end_chunk_encoding_callback\"><code>stream.end()</code></a> will raise an error.</p>\n<pre><code class=\"language-js\">// Write 'hello, ' and then end with 'world!'.\nconst fs = require('fs');\nconst file = fs.createWriteStream('example.txt');\nfile.write('hello, ');\nfile.end('world!');\n// Writing more now is not allowed!\n</code></pre>"
                     },
                     {
                       "textRaw": "`writable.setDefaultEncoding(encoding)`",
@@ -515,22 +711,22 @@
                               "desc": "Optional data to write. For streams not operating in object mode, `chunk` must be a string, `Buffer` or `Uint8Array`. For object mode streams, `chunk` may be any JavaScript value other than `null`."
                             },
                             {
-                              "textRaw": "`encoding` {string} The encoding, if `chunk` is a string. **Default:** `'utf8'`",
+                              "textRaw": "`encoding` {string|null} The encoding, if `chunk` is a string. **Default:** `'utf8'`",
                               "name": "encoding",
-                              "type": "string",
+                              "type": "string|null",
                               "default": "`'utf8'`",
                               "desc": "The encoding, if `chunk` is a string."
                             },
                             {
-                              "textRaw": "`callback` {Function} Callback for when this chunk of data is flushed",
+                              "textRaw": "`callback` {Function} Callback for when this chunk of data is flushed.",
                               "name": "callback",
                               "type": "Function",
-                              "desc": "Callback for when this chunk of data is flushed"
+                              "desc": "Callback for when this chunk of data is flushed."
                             }
                           ]
                         }
                       ],
-                      "desc": "<p>The <code>writable.write()</code> method writes some data to the stream, and calls the\nsupplied <code>callback</code> once the data has been fully handled. If an error\noccurs, the <code>callback</code> <em>may or may not</em> be called with the error as its\nfirst argument. To reliably detect write errors, add a listener for the\n<code>'error'</code> event.</p>\n<p>The return value is <code>true</code> if the internal buffer is less than the\n<code>highWaterMark</code> configured when the stream was created after admitting <code>chunk</code>.\nIf <code>false</code> is returned, further attempts to write data to the stream should\nstop until the <a href=\"#stream_event_drain\"><code>'drain'</code></a> event is emitted.</p>\n<p>While a stream is not draining, calls to <code>write()</code> will buffer <code>chunk</code>, and\nreturn false. Once all currently buffered chunks are drained (accepted for\ndelivery by the operating system), the <code>'drain'</code> event will be emitted.\nIt is recommended that once <code>write()</code> returns false, no more chunks be written\nuntil the <code>'drain'</code> event is emitted. While calling <code>write()</code> on a stream that\nis not draining is allowed, Node.js will buffer all written chunks until\nmaximum memory usage occurs, at which point it will abort unconditionally.\nEven before it aborts, high memory usage will cause poor garbage collector\nperformance and high RSS (which is not typically released back to the system,\neven after the memory is no longer required). Since TCP sockets may never\ndrain if the remote peer does not read the data, writing a socket that is\nnot draining may lead to a remotely exploitable vulnerability.</p>\n<p>Writing data while the stream is not draining is particularly\nproblematic for a <a href=\"#stream_class_stream_transform\"><code>Transform</code></a>, because the <code>Transform</code> streams are paused\nby default until they are piped or a <code>'data'</code> or <code>'readable'</code> event handler\nis added.</p>\n<p>If the data to be written can be generated or fetched on demand, it is\nrecommended to encapsulate the logic into a <a href=\"#stream_class_stream_readable\"><code>Readable</code></a> and use\n<a href=\"#stream_readable_pipe_destination_options\"><code>stream.pipe()</code></a>. However, if calling <code>write()</code> is preferred, it is\npossible to respect backpressure and avoid memory issues using the\n<a href=\"#stream_event_drain\"><code>'drain'</code></a> event:</p>\n<pre><code class=\"language-js\">function write(data, cb) {\n  if (!stream.write(data)) {\n    stream.once('drain', cb);\n  } else {\n    process.nextTick(cb);\n  }\n}\n\n// Wait for cb to be called before doing any other write.\nwrite('hello', () => {\n  console.log('Write completed, do more writes now.');\n});\n</code></pre>\n<p>A <code>Writable</code> stream in object mode will always ignore the <code>encoding</code> argument.</p>"
+                      "desc": "<p>The <code>writable.write()</code> method writes some data to the stream, and calls the\nsupplied <code>callback</code> once the data has been fully handled. If an error\noccurs, the <code>callback</code> <em>may or may not</em> be called with the error as its\nfirst argument. To reliably detect write errors, add a listener for the\n<code>'error'</code> event. The <code>callback</code> is called asynchronously and before <code>'error'</code> is\nemitted.</p>\n<p>The return value is <code>true</code> if the internal buffer is less than the\n<code>highWaterMark</code> configured when the stream was created after admitting <code>chunk</code>.\nIf <code>false</code> is returned, further attempts to write data to the stream should\nstop until the <a href=\"#stream_event_drain\"><code>'drain'</code></a> event is emitted.</p>\n<p>While a stream is not draining, calls to <code>write()</code> will buffer <code>chunk</code>, and\nreturn false. Once all currently buffered chunks are drained (accepted for\ndelivery by the operating system), the <code>'drain'</code> event will be emitted.\nIt is recommended that once <code>write()</code> returns false, no more chunks be written\nuntil the <code>'drain'</code> event is emitted. While calling <code>write()</code> on a stream that\nis not draining is allowed, Node.js will buffer all written chunks until\nmaximum memory usage occurs, at which point it will abort unconditionally.\nEven before it aborts, high memory usage will cause poor garbage collector\nperformance and high RSS (which is not typically released back to the system,\neven after the memory is no longer required). Since TCP sockets may never\ndrain if the remote peer does not read the data, writing a socket that is\nnot draining may lead to a remotely exploitable vulnerability.</p>\n<p>Writing data while the stream is not draining is particularly\nproblematic for a <a href=\"#stream_class_stream_transform\"><code>Transform</code></a>, because the <code>Transform</code> streams are paused\nby default until they are piped or a <code>'data'</code> or <code>'readable'</code> event handler\nis added.</p>\n<p>If the data to be written can be generated or fetched on demand, it is\nrecommended to encapsulate the logic into a <a href=\"#stream_class_stream_readable\"><code>Readable</code></a> and use\n<a href=\"#stream_readable_pipe_destination_options\"><code>stream.pipe()</code></a>. However, if calling <code>write()</code> is preferred, it is\npossible to respect backpressure and avoid memory issues using the\n<a href=\"#stream_event_drain\"><code>'drain'</code></a> event:</p>\n<pre><code class=\"language-js\">function write(data, cb) {\n  if (!stream.write(data)) {\n    stream.once('drain', cb);\n  } else {\n    process.nextTick(cb);\n  }\n}\n\n// Wait for cb to be called before doing any other write.\nwrite('hello', () => {\n  console.log('Write completed, do more writes now.');\n});\n</code></pre>\n<p>A <code>Writable</code> stream in object mode will always ignore the <code>encoding</code> argument.</p>"
                     }
                   ],
                   "properties": [
@@ -544,7 +740,7 @@
                         ],
                         "changes": []
                       },
-                      "desc": "<p>Is <code>true</code> after <a href=\"#stream_writable_destroy_error\"><code>writable.destroy()</code></a> has been called.</p>"
+                      "desc": "<p>Is <code>true</code> after <a href=\"#stream_writable_destroy_error\"><code>writable.destroy()</code></a> has been called.</p>\n<pre><code class=\"language-cjs\">const { Writable } = require('stream');\n\nconst myStream = new Writable();\n\nconsole.log(myStream.destroyed); // false\nmyStream.destroy();\nconsole.log(myStream.destroyed); // true\n</code></pre>"
                     },
                     {
                       "textRaw": "`writable` {boolean}",
@@ -556,7 +752,7 @@
                         ],
                         "changes": []
                       },
-                      "desc": "<p>Is <code>true</code> if it is safe to call <a href=\"#stream_writable_write_chunk_encoding_callback\"><code>writable.write()</code></a>.</p>"
+                      "desc": "<p>Is <code>true</code> if it is safe to call <a href=\"#stream_writable_write_chunk_encoding_callback\"><code>writable.write()</code></a>, which means\nthe stream has not been destroyed, errored or ended.</p>"
                     },
                     {
                       "textRaw": "`writableEnded` {boolean}",
@@ -576,6 +772,7 @@
                       "name": "writableCorked",
                       "meta": {
                         "added": [
+                          "v13.2.0",
                           "v12.16.0"
                         ],
                         "changes": []
@@ -618,6 +815,18 @@
                       },
                       "desc": "<p>This property contains the number of bytes (or objects) in the queue\nready to be written. The value provides introspection data regarding\nthe status of the <code>highWaterMark</code>.</p>"
                     },
+                    {
+                      "textRaw": "`writableNeedDrain` {boolean}",
+                      "type": "boolean",
+                      "name": "writableNeedDrain",
+                      "meta": {
+                        "added": [
+                          "v14.17.0"
+                        ],
+                        "changes": []
+                      },
+                      "desc": "<p>Is <code>true</code> if the stream's buffer has been full and stream will emit <code>'drain'</code>.</p>"
+                    },
                     {
                       "textRaw": "`writableObjectMode` {boolean}",
                       "type": "boolean",
@@ -805,7 +1014,13 @@
                         "added": [
                           "v8.0.0"
                         ],
-                        "changes": []
+                        "changes": [
+                          {
+                            "version": "v14.0.0",
+                            "pr-url": "https://github.com/nodejs/node/pull/29197",
+                            "description": "Work as a no-op on a stream that has already been destroyed."
+                          }
+                        ]
                       },
                       "signatures": [
                         {
@@ -824,7 +1039,7 @@
                           ]
                         }
                       ],
-                      "desc": "<p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>\nevent (unless <code>emitClose</code> is set to <code>false</code>). After this call, the readable\nstream will release any internal resources and subsequent calls to <code>push()</code>\nwill be ignored.\nImplementors should not override this method, but instead implement\n<a href=\"#stream_readable_destroy_err_callback\"><code>readable._destroy()</code></a>.</p>"
+                      "desc": "<p>Destroy the stream. Optionally emit an <code>'error'</code> event, and emit a <code>'close'</code>\nevent (unless <code>emitClose</code> is set to <code>false</code>). After this call, the readable\nstream will release any internal resources and subsequent calls to <code>push()</code>\nwill be ignored.</p>\n<p>Once <code>destroy()</code> has been called any further calls will be a no-op and no\nfurther errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>\n<p>Implementors should not override this method, but instead implement\n<a href=\"#stream_readable_destroy_err_callback\"><code>readable._destroy()</code></a>.</p>"
                     },
                     {
                       "textRaw": "`readable.isPaused()`",
@@ -942,7 +1157,7 @@
                           ]
                         }
                       ],
-                      "desc": "<p>The <code>readable.read()</code> method pulls some data out of the internal buffer and\nreturns it. If no data available to be read, <code>null</code> is returned. By default,\nthe data will be returned as a <code>Buffer</code> object unless an encoding has been\nspecified using the <code>readable.setEncoding()</code> method or the stream is operating\nin object mode.</p>\n<p>The optional <code>size</code> argument specifies a specific number of bytes to read. If\n<code>size</code> bytes are not available to be read, <code>null</code> will be returned <em>unless</em>\nthe stream has ended, in which case all of the data remaining in the internal\nbuffer will be returned.</p>\n<p>If the <code>size</code> argument is not specified, all of the data contained in the\ninternal buffer will be returned.</p>\n<p>The <code>size</code> argument must be less than or equal to 1 GB.</p>\n<p>The <code>readable.read()</code> method should only be called on <code>Readable</code> streams\noperating in paused mode. In flowing mode, <code>readable.read()</code> is called\nautomatically until the internal buffer is fully drained.</p>\n<pre><code class=\"language-js\">const readable = getReadableStreamSomehow();\n\n// 'readable' may be triggered multiple times as data is buffered in\nreadable.on('readable', () => {\n  let chunk;\n  console.log('Stream is readable (new data received in buffer)');\n  // Use a loop to make sure we read all currently available data\n  while (null !== (chunk = readable.read())) {\n    console.log(`Read ${chunk.length} bytes of data...`);\n  }\n});\n\n// 'end' will be triggered once when there is no more data available\nreadable.on('end', () => {\n  console.log('Reached end of stream.');\n});\n</code></pre>\n<p>Each call to <code>readable.read()</code> returns a chunk of data, or <code>null</code>. The chunks\nare not concatenated. A <code>while</code> loop is necessary to consume all data\ncurrently in the buffer. When reading a large file <code>.read()</code> may return <code>null</code>,\nhaving consumed all buffered content so far, but there is still more data to\ncome not yet buffered. In this case a new <code>'readable'</code> event will be emitted\nwhen there is more data in the buffer. Finally the <code>'end'</code> event will be\nemitted when there is no more data to come.</p>\n<p>Therefore to read a file's whole contents from a <code>readable</code>, it is necessary\nto collect chunks across multiple <code>'readable'</code> events:</p>\n<pre><code class=\"language-js\">const chunks = [];\n\nreadable.on('readable', () => {\n  let chunk;\n  while (null !== (chunk = readable.read())) {\n    chunks.push(chunk);\n  }\n});\n\nreadable.on('end', () => {\n  const content = chunks.join('');\n});\n</code></pre>\n<p>A <code>Readable</code> stream in object mode will always return a single item from\na call to <a href=\"#stream_readable_read_size\"><code>readable.read(size)</code></a>, regardless of the value of the\n<code>size</code> argument.</p>\n<p>If the <code>readable.read()</code> method returns a chunk of data, a <code>'data'</code> event will\nalso be emitted.</p>\n<p>Calling <a href=\"#stream_readable_read_size\"><code>stream.read([size])</code></a> after the <a href=\"#stream_event_end\"><code>'end'</code></a> event has\nbeen emitted will return <code>null</code>. No runtime error will be raised.</p>"
+                      "desc": "<p>The <code>readable.read()</code> method pulls some data out of the internal buffer and\nreturns it. If no data available to be read, <code>null</code> is returned. By default,\nthe data will be returned as a <code>Buffer</code> object unless an encoding has been\nspecified using the <code>readable.setEncoding()</code> method or the stream is operating\nin object mode.</p>\n<p>The optional <code>size</code> argument specifies a specific number of bytes to read. If\n<code>size</code> bytes are not available to be read, <code>null</code> will be returned <em>unless</em>\nthe stream has ended, in which case all of the data remaining in the internal\nbuffer will be returned.</p>\n<p>If the <code>size</code> argument is not specified, all of the data contained in the\ninternal buffer will be returned.</p>\n<p>The <code>size</code> argument must be less than or equal to 1 GiB.</p>\n<p>The <code>readable.read()</code> method should only be called on <code>Readable</code> streams\noperating in paused mode. In flowing mode, <code>readable.read()</code> is called\nautomatically until the internal buffer is fully drained.</p>\n<pre><code class=\"language-js\">const readable = getReadableStreamSomehow();\n\n// 'readable' may be triggered multiple times as data is buffered in\nreadable.on('readable', () => {\n  let chunk;\n  console.log('Stream is readable (new data received in buffer)');\n  // Use a loop to make sure we read all currently available data\n  while (null !== (chunk = readable.read())) {\n    console.log(`Read ${chunk.length} bytes of data...`);\n  }\n});\n\n// 'end' will be triggered once when there is no more data available\nreadable.on('end', () => {\n  console.log('Reached end of stream.');\n});\n</code></pre>\n<p>Each call to <code>readable.read()</code> returns a chunk of data, or <code>null</code>. The chunks\nare not concatenated. A <code>while</code> loop is necessary to consume all data\ncurrently in the buffer. When reading a large file <code>.read()</code> may return <code>null</code>,\nhaving consumed all buffered content so far, but there is still more data to\ncome not yet buffered. In this case a new <code>'readable'</code> event will be emitted\nwhen there is more data in the buffer. Finally the <code>'end'</code> event will be\nemitted when there is no more data to come.</p>\n<p>Therefore to read a file's whole contents from a <code>readable</code>, it is necessary\nto collect chunks across multiple <code>'readable'</code> events:</p>\n<pre><code class=\"language-js\">const chunks = [];\n\nreadable.on('readable', () => {\n  let chunk;\n  while (null !== (chunk = readable.read())) {\n    chunks.push(chunk);\n  }\n});\n\nreadable.on('end', () => {\n  const content = chunks.join('');\n});\n</code></pre>\n<p>A <code>Readable</code> stream in object mode will always return a single item from\na call to <a href=\"#stream_readable_read_size\"><code>readable.read(size)</code></a>, regardless of the value of the\n<code>size</code> argument.</p>\n<p>If the <code>readable.read()</code> method returns a chunk of data, a <code>'data'</code> event will\nalso be emitted.</p>\n<p>Calling <a href=\"#stream_readable_read_size\"><code>stream.read([size])</code></a> after the <a href=\"#stream_event_end\"><code>'end'</code></a> event has\nbeen emitted will return <code>null</code>. No runtime error will be raised.</p>"
                     },
                     {
                       "textRaw": "`readable.resume()`",
@@ -1148,7 +1363,19 @@
                         ],
                         "changes": []
                       },
-                      "desc": "<p>Is <code>true</code> if it is safe to call <a href=\"#stream_readable_read_size\"><code>readable.read()</code></a>.</p>"
+                      "desc": "<p>Is <code>true</code> if it is safe to call <a href=\"#stream_readable_read_size\"><code>readable.read()</code></a>, which means\nthe stream has not been destroyed or emitted <code>'error'</code> or <code>'end'</code>.</p>"
+                    },
+                    {
+                      "textRaw": "`readableDidRead` {boolean}",
+                      "type": "boolean",
+                      "name": "readableDidRead",
+                      "meta": {
+                        "added": [
+                          "v14.18.0"
+                        ],
+                        "changes": []
+                      },
+                      "desc": "<p>Allows determining if the stream has been or is about to be read.\nReturns true if <code>'data'</code>, <code>'end'</code>, <code>'error'</code> or <code>'close'</code> has been\nemitted.</p>"
                     },
                     {
                       "textRaw": "`readableEncoding` {null|string}",
@@ -1270,7 +1497,13 @@
                         "added": [
                           "v8.0.0"
                         ],
-                        "changes": []
+                        "changes": [
+                          {
+                            "version": "v14.0.0",
+                            "pr-url": "https://github.com/nodejs/node/pull/29197",
+                            "description": "Work as a no-op on a stream that has already been destroyed."
+                          }
+                        ]
                       },
                       "signatures": [
                         {
@@ -1288,7 +1521,7 @@
                           ]
                         }
                       ],
-                      "desc": "<p>Destroy the stream, and optionally emit an <code>'error'</code> event. After this call, the\ntransform stream would release any internal resources.\nImplementors should not override this method, but instead implement\n<a href=\"#stream_readable_destroy_err_callback\"><code>readable._destroy()</code></a>.\nThe default implementation of <code>_destroy()</code> for <code>Transform</code> also emit <code>'close'</code>\nunless <code>emitClose</code> is set in false.</p>"
+                      "desc": "<p>Destroy the stream, and optionally emit an <code>'error'</code> event. After this call, the\ntransform stream would release any internal resources.\nImplementors should not override this method, but instead implement\n<a href=\"#stream_readable_destroy_err_callback\"><code>readable._destroy()</code></a>.\nThe default implementation of <code>_destroy()</code> for <code>Transform</code> also emit <code>'close'</code>\nunless <code>emitClose</code> is set in false.</p>\n<p>Once <code>destroy()</code> has been called, any further calls will be a no-op and no\nfurther errors except from <code>_destroy()</code> may be emitted as <code>'error'</code>.</p>"
                     }
                   ]
                 }
@@ -1306,7 +1539,23 @@
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32158",
+                    "description": "The `finished(stream, cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31545",
+                    "description": "Emitting `'close'` before `'end'` on a `Readable` stream will cause an `ERR_STREAM_PREMATURE_CLOSE` error."
+                  },
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31509",
+                    "description": "Callback will be invoked on streams which have already finished before the call to `finished(stream, cb)`."
+                  }
+                ]
               },
               "signatures": [
                 {
@@ -1360,23 +1609,187 @@
               "desc": "<p>A function to get notified when a stream is no longer readable, writable\nor has experienced an error or a premature close event.</p>\n<pre><code class=\"language-js\">const { finished } = require('stream');\n\nconst rs = fs.createReadStream('archive.tar');\n\nfinished(rs, (err) => {\n  if (err) {\n    console.error('Stream failed.', err);\n  } else {\n    console.log('Stream is done reading.');\n  }\n});\n\nrs.resume(); // Drain the stream.\n</code></pre>\n<p>Especially useful in error handling scenarios where a stream is destroyed\nprematurely (like an aborted HTTP request), and will not emit <code>'end'</code>\nor <code>'finish'</code>.</p>\n<p>The <code>finished</code> API is promisify-able as well;</p>\n<pre><code class=\"language-js\">const finished = util.promisify(stream.finished);\n\nconst rs = fs.createReadStream('archive.tar');\n\nasync function run() {\n  await finished(rs);\n  console.log('Stream is done reading.');\n}\n\nrun().catch(console.error);\nrs.resume(); // Drain the stream.\n</code></pre>\n<p><code>stream.finished()</code> leaves dangling event listeners (in particular\n<code>'error'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code>) after <code>callback</code> has been\ninvoked. The reason for this is so that unexpected <code>'error'</code> events (due to\nincorrect stream implementations) do not cause unexpected crashes.\nIf this is unwanted behavior then the returned cleanup function needs to be\ninvoked in the callback:</p>\n<pre><code class=\"language-js\">const cleanup = finished(rs, (err) => {\n  cleanup();\n  // ...\n});\n</code></pre>"
             },
             {
-              "textRaw": "`stream.pipeline(...streams, callback)`",
+              "textRaw": "`stream.pipeline(source[, ...transforms], destination, callback)`",
               "type": "method",
               "name": "pipeline",
               "meta": {
                 "added": [
                   "v10.0.0"
                 ],
-                "changes": []
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32158",
+                    "description": "The `pipeline(..., cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+                  },
+                  {
+                    "version": "v13.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31223",
+                    "description": "Add support for async generators."
+                  }
+                ]
               },
               "signatures": [
                 {
+                  "return": {
+                    "textRaw": "Returns: {Stream}",
+                    "name": "return",
+                    "type": "Stream"
+                  },
                   "params": [
                     {
-                      "textRaw": "`...streams` {Stream} Two or more streams to pipe between.",
-                      "name": "...streams",
-                      "type": "Stream",
-                      "desc": "Two or more streams to pipe between."
+                      "textRaw": "`streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}",
+                      "name": "streams",
+                      "type": "Stream[]|Iterable[]|AsyncIterable[]|Function[]"
+                    },
+                    {
+                      "textRaw": "`source` {Stream|Iterable|AsyncIterable|Function}",
+                      "name": "source",
+                      "type": "Stream|Iterable|AsyncIterable|Function",
+                      "options": [
+                        {
+                          "textRaw": "Returns: {Iterable|AsyncIterable}",
+                          "name": "return",
+                          "type": "Iterable|AsyncIterable"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`...transforms` {Stream|Function}",
+                      "name": "...transforms",
+                      "type": "Stream|Function",
+                      "options": [
+                        {
+                          "textRaw": "`source` {AsyncIterable}",
+                          "name": "source",
+                          "type": "AsyncIterable"
+                        },
+                        {
+                          "textRaw": "Returns: {AsyncIterable}",
+                          "name": "return",
+                          "type": "AsyncIterable"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`destination` {Stream|Function}",
+                      "name": "destination",
+                      "type": "Stream|Function",
+                      "options": [
+                        {
+                          "textRaw": "`source` {AsyncIterable}",
+                          "name": "source",
+                          "type": "AsyncIterable"
+                        },
+                        {
+                          "textRaw": "Returns: {AsyncIterable|Promise}",
+                          "name": "return",
+                          "type": "AsyncIterable|Promise"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`callback` {Function} Called when the pipeline is fully done.",
+                      "name": "callback",
+                      "type": "Function",
+                      "desc": "Called when the pipeline is fully done.",
+                      "options": [
+                        {
+                          "textRaw": "`err` {Error}",
+                          "name": "err",
+                          "type": "Error"
+                        },
+                        {
+                          "textRaw": "`val` Resolved value of `Promise` returned by `destination`.",
+                          "name": "val",
+                          "desc": "Resolved value of `Promise` returned by `destination`."
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>A module method to pipe between streams and generators forwarding errors and\nproperly cleaning up and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p>The <code>pipeline</code> API also supports async generators:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\nconst fs = require('fs');\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('lowercase.txt'),\n    async function* (source) {\n      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.\n      for await (const chunk of source) {\n        yield chunk.toUpperCase();\n      }\n    },\n    fs.createWriteStream('uppercase.txt')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
+            },
+            {
+              "textRaw": "`stream.pipeline(streams, callback)`",
+              "type": "method",
+              "name": "pipeline",
+              "meta": {
+                "added": [
+                  "v10.0.0"
+                ],
+                "changes": [
+                  {
+                    "version": "v14.0.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/32158",
+                    "description": "The `pipeline(..., cb)` will wait for the `'close'` event before invoking the callback. The implementation tries to detect legacy streams and only apply this behavior to streams which are expected to emit `'close'`."
+                  },
+                  {
+                    "version": "v13.10.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/31223",
+                    "description": "Add support for async generators."
+                  }
+                ]
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Stream}",
+                    "name": "return",
+                    "type": "Stream"
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}",
+                      "name": "streams",
+                      "type": "Stream[]|Iterable[]|AsyncIterable[]|Function[]"
+                    },
+                    {
+                      "textRaw": "`source` {Stream|Iterable|AsyncIterable|Function}",
+                      "name": "source",
+                      "type": "Stream|Iterable|AsyncIterable|Function",
+                      "options": [
+                        {
+                          "textRaw": "Returns: {Iterable|AsyncIterable}",
+                          "name": "return",
+                          "type": "Iterable|AsyncIterable"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`...transforms` {Stream|Function}",
+                      "name": "...transforms",
+                      "type": "Stream|Function",
+                      "options": [
+                        {
+                          "textRaw": "`source` {AsyncIterable}",
+                          "name": "source",
+                          "type": "AsyncIterable"
+                        },
+                        {
+                          "textRaw": "Returns: {AsyncIterable}",
+                          "name": "return",
+                          "type": "AsyncIterable"
+                        }
+                      ]
+                    },
+                    {
+                      "textRaw": "`destination` {Stream|Function}",
+                      "name": "destination",
+                      "type": "Stream|Function",
+                      "options": [
+                        {
+                          "textRaw": "`source` {AsyncIterable}",
+                          "name": "source",
+                          "type": "AsyncIterable"
+                        },
+                        {
+                          "textRaw": "Returns: {AsyncIterable|Promise}",
+                          "name": "return",
+                          "type": "AsyncIterable|Promise"
+                        }
+                      ]
                     },
                     {
                       "textRaw": "`callback` {Function} Called when the pipeline is fully done.",
@@ -1388,13 +1801,18 @@
                           "textRaw": "`err` {Error}",
                           "name": "err",
                           "type": "Error"
+                        },
+                        {
+                          "textRaw": "`val` Resolved value of `Promise` returned by `destination`.",
+                          "name": "val",
+                          "desc": "Resolved value of `Promise` returned by `destination`."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>A module method to pipe between streams forwarding errors and properly cleaning\nup and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
+              "desc": "<p>A module method to pipe between streams and generators forwarding errors and\nproperly cleaning up and provide a callback when the pipeline is complete.</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst fs = require('fs');\nconst zlib = require('zlib');\n\n// Use the pipeline API to easily pipe a series of streams\n// together and get notified when the pipeline is fully done.\n\n// A pipeline to gzip a potentially huge tar file efficiently:\n\npipeline(\n  fs.createReadStream('archive.tar'),\n  zlib.createGzip(),\n  fs.createWriteStream('archive.tar.gz'),\n  (err) => {\n    if (err) {\n      console.error('Pipeline failed.', err);\n    } else {\n      console.log('Pipeline succeeded.');\n    }\n  }\n);\n</code></pre>\n<p>The <code>pipeline</code> API is promisify-able as well:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('archive.tar'),\n    zlib.createGzip(),\n    fs.createWriteStream('archive.tar.gz')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p>The <code>pipeline</code> API also supports async generators:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\nconst fs = require('fs');\n\nasync function run() {\n  await pipeline(\n    fs.createReadStream('lowercase.txt'),\n    async function* (source) {\n      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.\n      for await (const chunk of source) {\n        yield chunk.toUpperCase();\n      }\n    },\n    fs.createWriteStream('uppercase.txt')\n  );\n  console.log('Pipeline succeeded.');\n}\n\nrun().catch(console.error);\n</code></pre>\n<p><code>stream.pipeline()</code> will call <code>stream.destroy(err)</code> on all streams except:</p>\n<ul>\n<li><code>Readable</code> streams which have emitted <code>'end'</code> or <code>'close'</code>.</li>\n<li><code>Writable</code> streams which have emitted <code>'finish'</code> or <code>'close'</code>.</li>\n</ul>\n<p><code>stream.pipeline()</code> leaves dangling event listeners on the streams\nafter the <code>callback</code> has been invoked. In the case of reuse of streams after\nfailure, this can cause event listener leaks and swallowed errors.</p>"
             },
             {
               "textRaw": "`stream.Readable.from(iterable, [options])`",
@@ -1438,7 +1856,7 @@
           "textRaw": "API for stream implementers",
           "name": "API for stream implementers",
           "type": "misc",
-          "desc": "<p>The <code>stream</code> module API has been designed to make it possible to easily\nimplement streams using JavaScript's prototypal inheritance model.</p>\n<p>First, a stream developer would declare a new JavaScript class that extends one\nof the four basic stream classes (<code>stream.Writable</code>, <code>stream.Readable</code>,\n<code>stream.Duplex</code>, or <code>stream.Transform</code>), making sure they call the appropriate\nparent class constructor:</p>\n<!-- eslint-disable no-useless-constructor -->\n<pre><code class=\"language-js\">const { Writable } = require('stream');\n\nclass MyWritable extends Writable {\n  constructor({ highWaterMark, ...options }) {\n    super({\n      highWaterMark,\n      autoDestroy: true,\n      emitClose: true\n    });\n    // ...\n  }\n}\n</code></pre>\n<p>When extending streams, keep in mind what options the user\ncan and should provide before forwarding these to the base constructor. For\nexample, if the implementation makes assumptions in regard to the\n<code>autoDestroy</code> and <code>emitClose</code> options, do not allow the\nuser to override these. Be explicit about what\noptions are forwarded instead of implicitly forwarding all options.</p>\n<p>The new stream class must then implement one or more specific methods, depending\non the type of stream being created, as detailed in the chart below:</p>\n<table>\n<thead>\n<tr>\n<th>Use-case</th>\n<th>Class</th>\n<th>Method(s) to implement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Reading only</td>\n<td><a href=\"#stream_class_stream_readable\"><code>Readable</code></a></td>\n<td><a href=\"#stream_readable_read_size_1\"><code>_read()</code></a></td>\n</tr>\n<tr>\n<td>Writing only</td>\n<td><a href=\"#stream_class_stream_writable\"><code>Writable</code></a></td>\n<td><a href=\"#stream_writable_write_chunk_encoding_callback_1\"><code>_write()</code></a>, <a href=\"#stream_writable_writev_chunks_callback\"><code>_writev()</code></a>, <a href=\"#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n<tr>\n<td>Reading and writing</td>\n<td><a href=\"#stream_class_stream_duplex\"><code>Duplex</code></a></td>\n<td><a href=\"#stream_readable_read_size_1\"><code>_read()</code></a>, <a href=\"#stream_writable_write_chunk_encoding_callback_1\"><code>_write()</code></a>, <a href=\"#stream_writable_writev_chunks_callback\"><code>_writev()</code></a>, <a href=\"#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n<tr>\n<td>Operate on written data, then read the result</td>\n<td><a href=\"#stream_class_stream_transform\"><code>Transform</code></a></td>\n<td><a href=\"#stream_transform_transform_chunk_encoding_callback\"><code>_transform()</code></a>, <a href=\"#stream_transform_flush_callback\"><code>_flush()</code></a>, <a href=\"#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>The implementation code for a stream should <em>never</em> call the \"public\" methods\nof a stream that are intended for use by consumers (as described in the\n<a href=\"#stream_api_for_stream_consumers\">API for stream consumers</a> section). Doing so may lead to adverse side effects\nin application code consuming the stream.</p>\n<p>Avoid overriding public methods such as <code>write()</code>, <code>end()</code>, <code>cork()</code>,\n<code>uncork()</code>, <code>read()</code> and <code>destroy()</code>, or emitting internal events such\nas <code>'error'</code>, <code>'data'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code> through <code>.emit()</code>.\nDoing so can break current and future stream invariants leading to behavior\nand/or compatibility issues with other streams, stream utilities, and user\nexpectations.</p>",
+          "desc": "<p>The <code>stream</code> module API has been designed to make it possible to easily\nimplement streams using JavaScript's prototypal inheritance model.</p>\n<p>First, a stream developer would declare a new JavaScript class that extends one\nof the four basic stream classes (<code>stream.Writable</code>, <code>stream.Readable</code>,\n<code>stream.Duplex</code>, or <code>stream.Transform</code>), making sure they call the appropriate\nparent class constructor:</p>\n<!-- eslint-disable no-useless-constructor -->\n<pre><code class=\"language-js\">const { Writable } = require('stream');\n\nclass MyWritable extends Writable {\n  constructor({ highWaterMark, ...options }) {\n    super({ highWaterMark });\n    // ...\n  }\n}\n</code></pre>\n<p>When extending streams, keep in mind what options the user\ncan and should provide before forwarding these to the base constructor. For\nexample, if the implementation makes assumptions in regard to the\n<code>autoDestroy</code> and <code>emitClose</code> options, do not allow the\nuser to override these. Be explicit about what\noptions are forwarded instead of implicitly forwarding all options.</p>\n<p>The new stream class must then implement one or more specific methods, depending\non the type of stream being created, as detailed in the chart below:</p>\n<table>\n<thead>\n<tr>\n<th>Use-case</th>\n<th>Class</th>\n<th>Method(s) to implement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Reading only</td>\n<td><a href=\"#stream_class_stream_readable\"><code>Readable</code></a></td>\n<td><a href=\"#stream_readable_read_size_1\"><code>_read()</code></a></td>\n</tr>\n<tr>\n<td>Writing only</td>\n<td><a href=\"#stream_class_stream_writable\"><code>Writable</code></a></td>\n<td><a href=\"#stream_writable_write_chunk_encoding_callback_1\"><code>_write()</code></a>, <a href=\"#stream_writable_writev_chunks_callback\"><code>_writev()</code></a>, <a href=\"#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n<tr>\n<td>Reading and writing</td>\n<td><a href=\"#stream_class_stream_duplex\"><code>Duplex</code></a></td>\n<td><a href=\"#stream_readable_read_size_1\"><code>_read()</code></a>, <a href=\"#stream_writable_write_chunk_encoding_callback_1\"><code>_write()</code></a>, <a href=\"#stream_writable_writev_chunks_callback\"><code>_writev()</code></a>, <a href=\"#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n<tr>\n<td>Operate on written data, then read the result</td>\n<td><a href=\"#stream_class_stream_transform\"><code>Transform</code></a></td>\n<td><a href=\"#stream_transform_transform_chunk_encoding_callback\"><code>_transform()</code></a>, <a href=\"#stream_transform_flush_callback\"><code>_flush()</code></a>, <a href=\"#stream_writable_final_callback\"><code>_final()</code></a></td>\n</tr>\n</tbody>\n</table>\n<p>The implementation code for a stream should <em>never</em> call the \"public\" methods\nof a stream that are intended for use by consumers (as described in the\n<a href=\"#stream_api_for_stream_consumers\">API for stream consumers</a> section). Doing so may lead to adverse side effects\nin application code consuming the stream.</p>\n<p>Avoid overriding public methods such as <code>write()</code>, <code>end()</code>, <code>cork()</code>,\n<code>uncork()</code>, <code>read()</code> and <code>destroy()</code>, or emitting internal events such\nas <code>'error'</code>, <code>'data'</code>, <code>'end'</code>, <code>'finish'</code> and <code>'close'</code> through <code>.emit()</code>.\nDoing so can break current and future stream invariants leading to behavior\nand/or compatibility issues with other streams, stream utilities, and user\nexpectations.</p>",
           "miscs": [
             {
               "textRaw": "Simplified construction",
@@ -1465,14 +1883,22 @@
                   "meta": {
                     "changes": [
                       {
-                        "version": "v10.0.0",
-                        "pr-url": "https://github.com/nodejs/node/pull/18438",
-                        "description": "Add `emitClose` option to specify if `'close'` is emitted on destroy."
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/30623",
+                        "description": "Change `autoDestroy` option default to `true`."
                       },
                       {
-                        "version": "v11.2.0",
+                        "version": [
+                          "v11.2.0",
+                          "v10.16.0"
+                        ],
                         "pr-url": "https://github.com/nodejs/node/pull/22795",
                         "description": "Add `autoDestroy` option to automatically `destroy()` the stream when it emits `'finish'` or errors."
+                      },
+                      {
+                        "version": "v10.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/18438",
+                        "description": "Add `emitClose` option to specify if `'close'` is emitted on destroy."
                       }
                     ]
                   },
@@ -1544,10 +1970,10 @@
                               "desc": "Implementation for the [`stream._final()`][stream-_final] method."
                             },
                             {
-                              "textRaw": "`autoDestroy` {boolean} Whether this stream should automatically call `.destroy()` on itself after ending. **Default:** `false`.",
+                              "textRaw": "`autoDestroy` {boolean} Whether this stream should automatically call `.destroy()` on itself after ending. **Default:** `true`.",
                               "name": "autoDestroy",
                               "type": "boolean",
-                              "default": "`false`",
+                              "default": "`true`",
                               "desc": "Whether this stream should automatically call `.destroy()` on itself after ending."
                             }
                           ]
@@ -1596,7 +2022,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>All <code>Writable</code> stream implementations must provide a\n<a href=\"#stream_writable_write_chunk_encoding_callback_1\"><code>writable._write()</code></a> and/or\n<a href=\"#stream_writable_writev_chunks_callback\"><code>writable._writev()</code></a> method to send data to the underlying\nresource.</p>\n<p><a href=\"#stream_class_stream_transform\"><code>Transform</code></a> streams provide their own implementation of the\n<a href=\"#stream_writable_write_chunk_encoding_callback_1\"><code>writable._write()</code></a>.</p>\n<p>This function MUST NOT be called by application code directly. It should be\nimplemented by child classes, and called by the internal <code>Writable</code> class\nmethods only.</p>\n<p>The <code>callback</code> method must be called to signal either that the write completed\nsuccessfully or failed with an error. The first argument passed to the\n<code>callback</code> must be the <code>Error</code> object if the call failed or <code>null</code> if the\nwrite succeeded.</p>\n<p>All calls to <code>writable.write()</code> that occur between the time <code>writable._write()</code>\nis called and the <code>callback</code> is called will cause the written data to be\nbuffered. When the <code>callback</code> is invoked, the stream might emit a <a href=\"#stream_event_drain\"><code>'drain'</code></a>\nevent. If a stream implementation is capable of processing multiple chunks of\ndata at once, the <code>writable._writev()</code> method should be implemented.</p>\n<p>If the <code>decodeStrings</code> property is explicitly set to <code>false</code> in the constructor\noptions, then <code>chunk</code> will remain the same object that is passed to <code>.write()</code>,\nand may be a string rather than a <code>Buffer</code>. This is to support implementations\nthat have an optimized handling for certain string data encodings. In that case,\nthe <code>encoding</code> argument will indicate the character encoding of the string.\nOtherwise, the <code>encoding</code> argument can be safely ignored.</p>\n<p>The <code>writable._write()</code> method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.</p>"
+                  "desc": "<p>All <code>Writable</code> stream implementations must provide a\n<a href=\"#stream_writable_write_chunk_encoding_callback_1\"><code>writable._write()</code></a> and/or\n<a href=\"#stream_writable_writev_chunks_callback\"><code>writable._writev()</code></a> method to send data to the underlying\nresource.</p>\n<p><a href=\"#stream_class_stream_transform\"><code>Transform</code></a> streams provide their own implementation of the\n<a href=\"#stream_writable_write_chunk_encoding_callback_1\"><code>writable._write()</code></a>.</p>\n<p>This function MUST NOT be called by application code directly. It should be\nimplemented by child classes, and called by the internal <code>Writable</code> class\nmethods only.</p>\n<p>The <code>callback</code> function must be called synchronously inside of\n<code>writable._write()</code> or asynchronously (i.e. different tick) to signal either\nthat the write completed successfully or failed with an error.\nThe first argument passed to the <code>callback</code> must be the <code>Error</code> object if the\ncall failed or <code>null</code> if the write succeeded.</p>\n<p>All calls to <code>writable.write()</code> that occur between the time <code>writable._write()</code>\nis called and the <code>callback</code> is called will cause the written data to be\nbuffered. When the <code>callback</code> is invoked, the stream might emit a <a href=\"#stream_event_drain\"><code>'drain'</code></a>\nevent. If a stream implementation is capable of processing multiple chunks of\ndata at once, the <code>writable._writev()</code> method should be implemented.</p>\n<p>If the <code>decodeStrings</code> property is explicitly set to <code>false</code> in the constructor\noptions, then <code>chunk</code> will remain the same object that is passed to <code>.write()</code>,\nand may be a string rather than a <code>Buffer</code>. This is to support implementations\nthat have an optimized handling for certain string data encodings. In that case,\nthe <code>encoding</code> argument will indicate the character encoding of the string.\nOtherwise, the <code>encoding</code> argument can be safely ignored.</p>\n<p>The <code>writable._write()</code> method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.</p>"
                 },
                 {
                   "textRaw": "`writable._writev(chunks, callback)`",
@@ -1606,10 +2032,24 @@
                     {
                       "params": [
                         {
-                          "textRaw": "`chunks` {Object[]} The chunks to be written. Each chunk has following format: `{ chunk: ..., encoding: ... }`.",
+                          "textRaw": "`chunks` {Object[]} The data to be written. The value is an array of {Object} that each represent a discrete chunk of data to write. The properties of these objects are:",
                           "name": "chunks",
                           "type": "Object[]",
-                          "desc": "The chunks to be written. Each chunk has following format: `{ chunk: ..., encoding: ... }`."
+                          "desc": "The data to be written. The value is an array of {Object} that each represent a discrete chunk of data to write. The properties of these objects are:",
+                          "options": [
+                            {
+                              "textRaw": "`chunk` {Buffer|string} A buffer instance or string containing the data to be written. The `chunk` will be a string if the `Writable` was created with the `decodeStrings` option set to `false` and a string was passed to `write()`.",
+                              "name": "chunk",
+                              "type": "Buffer|string",
+                              "desc": "A buffer instance or string containing the data to be written. The `chunk` will be a string if the `Writable` was created with the `decodeStrings` option set to `false` and a string was passed to `write()`."
+                            },
+                            {
+                              "textRaw": "`encoding` {string} The character encoding of the `chunk`. If `chunk` is a `Buffer`, the `encoding` will be `'buffer'`.",
+                              "name": "encoding",
+                              "type": "string",
+                              "desc": "The character encoding of the `chunk`. If `chunk` is a `Buffer`, the `encoding` will be `'buffer'`."
+                            }
+                          ]
                         },
                         {
                           "textRaw": "`callback` {Function} A callback function (optionally with an error argument) to be invoked when processing is complete for the supplied chunks.",
@@ -1715,7 +2155,15 @@
                   "meta": {
                     "changes": [
                       {
-                        "version": "v11.2.0",
+                        "version": "v14.0.0",
+                        "pr-url": "https://github.com/nodejs/node/pull/30623",
+                        "description": "Change `autoDestroy` option default to `true`."
+                      },
+                      {
+                        "version": [
+                          "v11.2.0",
+                          "v10.16.0"
+                        ],
                         "pr-url": "https://github.com/nodejs/node/pull/22795",
                         "description": "Add `autoDestroy` option to automatically `destroy()` the stream when it emits `'end'` or errors."
                       }
@@ -1770,10 +2218,10 @@
                               "desc": "Implementation for the [`stream._destroy()`][readable-_destroy] method."
                             },
                             {
-                              "textRaw": "`autoDestroy` {boolean} Whether this stream should automatically call `.destroy()` on itself after ending. **Default:** `false`.",
+                              "textRaw": "`autoDestroy` {boolean} Whether this stream should automatically call `.destroy()` on itself after ending. **Default:** `true`.",
                               "name": "autoDestroy",
                               "type": "boolean",
-                              "default": "`false`",
+                              "default": "`true`",
                               "desc": "Whether this stream should automatically call `.destroy()` on itself after ending."
                             }
                           ]
@@ -1807,7 +2255,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>This function MUST NOT be called by application code directly. It should be\nimplemented by child classes, and called by the internal <code>Readable</code> class\nmethods only.</p>\n<p>All <code>Readable</code> stream implementations must provide an implementation of the\n<a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> method to fetch data from the underlying resource.</p>\n<p>When <a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> is called, if data is available from the resource,\nthe implementation should begin pushing that data into the read queue using the\n<a href=\"#stream_readable_push_chunk_encoding\"><code>this.push(dataChunk)</code></a> method. <code>_read()</code> should continue reading\nfrom the resource and pushing data until <code>readable.push()</code> returns <code>false</code>. Only\nwhen <code>_read()</code> is called again after it has stopped should it resume pushing\nadditional data onto the queue.</p>\n<p>Once the <a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> method has been called, it will not be called\nagain until more data is pushed through the <a href=\"#stream_readable_push_chunk_encoding\"><code>readable.push()</code></a>\nmethod. Empty data such as empty buffers and strings will not cause\n<a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> to be called.</p>\n<p>The <code>size</code> argument is advisory. For implementations where a \"read\" is a\nsingle operation that returns data can use the <code>size</code> argument to determine how\nmuch data to fetch. Other implementations may ignore this argument and simply\nprovide data whenever it becomes available. There is no need to \"wait\" until\n<code>size</code> bytes are available before calling <a href=\"#stream_readable_push_chunk_encoding\"><code>stream.push(chunk)</code></a>.</p>\n<p>The <a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.</p>"
+                  "desc": "<p>This function MUST NOT be called by application code directly. It should be\nimplemented by child classes, and called by the internal <code>Readable</code> class\nmethods only.</p>\n<p>All <code>Readable</code> stream implementations must provide an implementation of the\n<a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> method to fetch data from the underlying resource.</p>\n<p>When <a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> is called, if data is available from the resource,\nthe implementation should begin pushing that data into the read queue using the\n<a href=\"#stream_readable_push_chunk_encoding\"><code>this.push(dataChunk)</code></a> method. <code>_read()</code> will be called again\nafter each call to <a href=\"#stream_readable_push_chunk_encoding\"><code>this.push(dataChunk)</code></a> once the stream is\nready to accept more data. <code>_read()</code> may continue reading from the resource and\npushing data until <code>readable.push()</code> returns <code>false</code>. Only when <code>_read()</code> is\ncalled again after it has stopped should it resume pushing additional data into\nthe queue.</p>\n<p>Once the <a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> method has been called, it will not be called\nagain until more data is pushed through the <a href=\"#stream_readable_push_chunk_encoding\"><code>readable.push()</code></a>\nmethod. Empty data such as empty buffers and strings will not cause\n<a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> to be called.</p>\n<p>The <code>size</code> argument is advisory. For implementations where a \"read\" is a\nsingle operation that returns data can use the <code>size</code> argument to determine how\nmuch data to fetch. Other implementations may ignore this argument and simply\nprovide data whenever it becomes available. There is no need to \"wait\" until\n<code>size</code> bytes are available before calling <a href=\"#stream_readable_push_chunk_encoding\"><code>stream.push(chunk)</code></a>.</p>\n<p>The <a href=\"#stream_readable_read_size_1\"><code>readable._read()</code></a> method is prefixed with an underscore because it is\ninternal to the class that defines it, and should never be called directly by\nuser programs.</p>"
                 },
                 {
                   "textRaw": "`readable._destroy(err, callback)`",
@@ -2038,13 +2486,20 @@
                   "desc": "<!-- eslint-disable no-useless-constructor -->\n<pre><code class=\"language-js\">const { Transform } = require('stream');\n\nclass MyTransform extends Transform {\n  constructor(options) {\n    super(options);\n    // ...\n  }\n}\n</code></pre>\n<p>Or, when using pre-ES6 style constructors:</p>\n<pre><code class=\"language-js\">const { Transform } = require('stream');\nconst util = require('util');\n\nfunction MyTransform(options) {\n  if (!(this instanceof MyTransform))\n    return new MyTransform(options);\n  Transform.call(this, options);\n}\nutil.inherits(MyTransform, Transform);\n</code></pre>\n<p>Or, using the simplified constructor approach:</p>\n<pre><code class=\"language-js\">const { Transform } = require('stream');\n\nconst myTransform = new Transform({\n  transform(chunk, encoding, callback) {\n    // ...\n  }\n});\n</code></pre>"
                 }
               ],
-              "modules": [
+              "events": [
                 {
-                  "textRaw": "Events: `'finish'` and `'end'`",
-                  "name": "events:_`'finish'`_and_`'end'`",
-                  "desc": "<p>The <a href=\"#stream_event_finish\"><code>'finish'</code></a> and <a href=\"#stream_event_end\"><code>'end'</code></a> events are from the <code>stream.Writable</code>\nand <code>stream.Readable</code> classes, respectively. The <code>'finish'</code> event is emitted\nafter <a href=\"#stream_writable_end_chunk_encoding_callback\"><code>stream.end()</code></a> is called and all chunks have been processed\nby <a href=\"#stream_transform_transform_chunk_encoding_callback\"><code>stream._transform()</code></a>. The <code>'end'</code> event is emitted\nafter all data has been output, which occurs after the callback in\n<a href=\"#stream_transform_flush_callback\"><code>transform._flush()</code></a> has been called.</p>",
-                  "type": "module",
-                  "displayName": "Events: `'finish'` and `'end'`"
+                  "textRaw": "Event: `'end'`",
+                  "type": "event",
+                  "name": "end",
+                  "params": [],
+                  "desc": "<p>The <a href=\"#stream_event_end\"><code>'end'</code></a> event is from the <code>stream.Readable</code> class. The <code>'end'</code> event is\nemitted after all data has been output, which occurs after the callback in\n<a href=\"#stream_transform_flush_callback\"><code>transform._flush()</code></a> has been called. In the case of an error,\n<code>'end'</code> should not be emitted.</p>"
+                },
+                {
+                  "textRaw": "Event: `'finish'`",
+                  "type": "event",
+                  "name": "finish",
+                  "params": [],
+                  "desc": "<p>The <a href=\"#stream_event_finish\"><code>'finish'</code></a> event is from the <code>stream.Writable</code> class. The <code>'finish'</code>\nevent is emitted after <a href=\"#stream_writable_end_chunk_encoding_callback\"><code>stream.end()</code></a> is called and all chunks\nhave been processed by <a href=\"#stream_transform_transform_chunk_encoding_callback\"><code>stream._transform()</code></a>. In the case\nof an error, <code>'finish'</code> should not be emitted.</p>"
                 }
               ],
               "methods": [
@@ -2140,7 +2595,7 @@
                   "textRaw": "Piping to writable streams from async iterators",
                   "name": "Piping to writable streams from async iterators",
                   "type": "misc",
-                  "desc": "<p>In the scenario of writing to a writable stream from an async iterator, ensure\nthe correct handling of backpressure and errors.</p>\n<pre><code class=\"language-js\">const { once } = require('events');\nconst finished = util.promisify(stream.finished);\n\nconst writable = fs.createWriteStream('./file');\n\nfunction drain(writable) {\n  if (writable.destroyed) {\n    return Promise.reject(new Error('premature close'));\n  }\n  return Promise.race([\n    once(writable, 'drain'),\n    once(writable, 'close')\n      .then(() => Promise.reject(new Error('premature close')))\n  ]);\n}\n\nasync function pump(iterable, writable) {\n  for await (const chunk of iterable) {\n    // Handle backpressure on write().\n    if (!writable.write(chunk)) {\n      await drain(writable);\n    }\n  }\n  writable.end();\n}\n\n(async function() {\n  // Ensure completion without errors.\n  await Promise.all([\n    pump(iterable, writable),\n    finished(writable)\n  ]);\n})();\n</code></pre>\n<p>In the above, errors on <code>write()</code> would be caught and thrown by the\n<code>once()</code> listener for the <code>'drain'</code> event, since <code>once()</code> will also handle the\n<code>'error'</code> event. To ensure completion of the write stream without errors,\nit is safer to use the <code>finished()</code> method as above, instead of using the\n<code>once()</code> listener for the <code>'finish'</code> event. Under certain cases, an <code>'error'</code>\nevent could be emitted by the writable stream after <code>'finish'</code> and as <code>once()</code>\nwill release the <code>'error'</code> handler on handling the <code>'finish'</code> event, it could\nresult in an unhandled error.</p>\n<p>Alternatively, the readable stream could be wrapped with <code>Readable.from()</code> and\nthen piped via <code>.pipe()</code>:</p>\n<pre><code class=\"language-js\">const finished = util.promisify(stream.finished);\n\nconst writable = fs.createWriteStream('./file');\n\n(async function() {\n  const readable = Readable.from(iterable);\n  readable.pipe(writable);\n  // Ensure completion without errors.\n  await finished(writable);\n})();\n</code></pre>\n<p>Or, using <code>stream.pipeline()</code> to pipe streams:</p>\n<pre><code class=\"language-js\">const pipeline = util.promisify(stream.pipeline);\n\nconst writable = fs.createWriteStream('./file');\n\n(async function() {\n  const readable = Readable.from(iterable);\n  await pipeline(readable, writable);\n})();\n</code></pre>"
+                  "desc": "<p>When writing to a writable stream from an async iterator, ensure correct\nhandling of backpressure and errors. <a href=\"#stream_stream_pipeline_source_transforms_destination_callback\"><code>stream.pipeline()</code></a> abstracts away\nthe handling of backpressure and backpressure-related errors:</p>\n<pre><code class=\"language-js\">const { pipeline } = require('stream');\nconst util = require('util');\nconst fs = require('fs');\n\nconst writable = fs.createWriteStream('./file');\n\n// Callback Pattern\npipeline(iterator, writable, (err, value) => {\n  if (err) {\n    console.error(err);\n  } else {\n    console.log(value, 'value returned');\n  }\n});\n\n// Promise Pattern\nconst pipelinePromise = util.promisify(pipeline);\npipelinePromise(iterator, writable)\n  .then((value) => {\n    console.log(value, 'value returned');\n  })\n  .catch(console.error);\n</code></pre>"
                 }
               ],
               "type": "misc",
diff --git a/doc/api/stream.md b/doc/api/stream.md
index 452f228a4530c5a887ca667723b09e88c8edb519..f6f0afad323b36b5d9ee5bdbf0daa59538d3d29d 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -65,8 +65,7 @@ object mode is not safe.
 <!--type=misc-->
 
 Both [`Writable`][] and [`Readable`][] streams will store data in an internal
-buffer that can be retrieved using `writable.writableBuffer` or
-`readable.readableBuffer`, respectively.
+buffer.
 
 The amount of data potentially buffered depends on the `highWaterMark` option
 passed into the stream's constructor. For normal streams, the `highWaterMark`
@@ -110,6 +109,11 @@ writing data *to* the socket. Because data may be written to the socket at a
 faster or slower rate than data is received, each side should
 operate (and buffer) independently of the other.
 
+The mechanics of the internal buffering are an internal implementation detail
+and may be changed at any time. However, for certain advanced implementations,
+the internal buffers can be retrieved using `writable.writableBuffer` or
+`readable.readableBuffer`. Use of these undocumented properties is discouraged.
+
 ## API for stream consumers
 
 <!--type=misc-->
@@ -284,10 +288,13 @@ added: v0.9.4
 The `'error'` event is emitted if an error occurred while writing or piping
 data. The listener callback is passed a single `Error` argument when called.
 
-The stream is not closed when the `'error'` event is emitted unless the
-[`autoDestroy`][writable-new] option was set to `true` when creating the
+The stream is closed when the `'error'` event is emitted unless the
+[`autoDestroy`][writable-new] option was set to `false` when creating the
 stream.
 
+After `'error'`, no further events other than `'close'` *should* be emitted
+(including `'error'` events).
+
 ##### Event: `'finish'`
 <!-- YAML
 added: v0.9.4
@@ -376,6 +383,10 @@ See also: [`writable.uncork()`][], [`writable._writev()`][stream-_writev].
 ##### `writable.destroy([error])`
 <!-- YAML
 added: v8.0.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/29197
+    description: Work as a no-op on a stream that has already been destroyed.
 -->
 
 * `error` {Error} Optional, an error to emit with `'error'` event.
@@ -389,6 +400,39 @@ This is a destructive and immediate way to destroy a stream. Previous calls to
 `write()` may not have drained, and may trigger an `ERR_STREAM_DESTROYED` error.
 Use `end()` instead of destroy if data should flush before close, or wait for
 the `'drain'` event before destroying the stream.
+
+```cjs
+const { Writable } = require('stream');
+
+const myStream = new Writable();
+
+const fooErr = new Error('foo error');
+myStream.destroy(fooErr);
+myStream.on('error', (fooErr) => console.error(fooErr.message)); // foo error
+```
+
+```cjs
+const { Writable } = require('stream');
+
+const myStream = new Writable();
+
+myStream.destroy();
+myStream.on('error', function wontHappen() {});
+```
+
+```cjs
+const { Writable } = require('stream');
+
+const myStream = new Writable();
+myStream.destroy();
+
+myStream.write('foo', (error) => console.error(error.code));
+// ERR_STREAM_DESTROYED
+```
+
+Once `destroy()` has been called any further calls will be a no-op and no
+further errors except from `_destroy()` may be emitted as `'error'`.
+
 Implementors should not override this method,
 but instead implement [`writable._destroy()`][writable-_destroy].
 
@@ -401,10 +445,23 @@ added: v8.0.0
 
 Is `true` after [`writable.destroy()`][writable-destroy] has been called.
 
+```cjs
+const { Writable } = require('stream');
+
+const myStream = new Writable();
+
+console.log(myStream.destroyed); // false
+myStream.destroy();
+console.log(myStream.destroyed); // true
+```
+
 ##### `writable.end([chunk[, encoding]][, callback])`
 <!-- YAML
 added: v0.9.4
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/29747
+    description: The `callback` is invoked if 'finish' or 'error' is emitted.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/18780
     description: This method now returns a reference to `writable`.
@@ -418,14 +475,15 @@ changes:
   `Uint8Array`. For object mode streams, `chunk` may be any JavaScript value
   other than `null`.
 * `encoding` {string} The encoding if `chunk` is a string
-* `callback` {Function} Optional callback for when the stream is finished
+* `callback` {Function} Optional callback for when the stream finishes
+  or errors
 * Returns: {this}
 
 Calling the `writable.end()` method signals that no more data will be written
 to the [`Writable`][]. The optional `chunk` and `encoding` arguments allow one
 final additional chunk of data to be written immediately before closing the
 stream. If provided, the optional `callback` function is attached as a listener
-for the [`'finish'`][] event.
+for the [`'finish'`][] and the `'error'` event.
 
 Calling the [`stream.write()`][stream-write] method after calling
 [`stream.end()`][stream-end] will raise an error.
@@ -499,7 +557,8 @@ added: v11.4.0
 
 * {boolean}
 
-Is `true` if it is safe to call [`writable.write()`][stream-write].
+Is `true` if it is safe to call [`writable.write()`][stream-write], which means
+the stream has not been destroyed, errored or ended.
 
 ##### `writable.writableEnded`
 <!-- YAML
@@ -514,7 +573,9 @@ does not indicate whether the data has been flushed, for this use
 
 ##### `writable.writableCorked`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.2.0
+ - v12.16.0
 -->
 
 * {integer}
@@ -552,6 +613,15 @@ This property contains the number of bytes (or objects) in the queue
 ready to be written. The value provides introspection data regarding
 the status of the `highWaterMark`.
 
+##### `writable.writableNeedDrain`
+<!-- YAML
+added: v14.17.0
+-->
+
+* {boolean}
+
+Is `true` if the stream's buffer has been full and stream will emit `'drain'`.
+
 ##### `writable.writableObjectMode`
 <!-- YAML
 added: v12.3.0
@@ -578,8 +648,8 @@ changes:
   not operating in object mode, `chunk` must be a string, `Buffer` or
   `Uint8Array`. For object mode streams, `chunk` may be any JavaScript value
   other than `null`.
-* `encoding` {string} The encoding, if `chunk` is a string. **Default:** `'utf8'`
-* `callback` {Function} Callback for when this chunk of data is flushed
+* `encoding` {string|null} The encoding, if `chunk` is a string. **Default:** `'utf8'`
+* `callback` {Function} Callback for when this chunk of data is flushed.
 * Returns: {boolean} `false` if the stream wishes for the calling code to
   wait for the `'drain'` event to be emitted before continuing to write
   additional data; otherwise `true`.
@@ -588,7 +658,8 @@ The `writable.write()` method writes some data to the stream, and calls the
 supplied `callback` once the data has been fully handled. If an error
 occurs, the `callback` *may or may not* be called with the error as its
 first argument. To reliably detect write errors, add a listener for the
-`'error'` event.
+`'error'` event. The `callback` is called asynchronously and before `'error'` is
+emitted.
 
 The return value is `true` if the internal buffer is less than the
 `highWaterMark` configured when the stream was created after admitting `chunk`.
@@ -663,11 +734,11 @@ A [`Readable`][] stream can be in object mode or not, regardless of whether
 it is in flowing mode or paused mode.
 
 * In flowing mode, data is read from the underlying system automatically
-and provided to an application as quickly as possible using events via the
-[`EventEmitter`][] interface.
+  and provided to an application as quickly as possible using events via the
+  [`EventEmitter`][] interface.
 
 * In paused mode, the [`stream.read()`][stream-read] method must be called
-explicitly to read chunks of data from the stream.
+  explicitly to read chunks of data from the stream.
 
 All [`Readable`][] streams begin in paused mode but can be switched to flowing
 mode in one of the following ways:
@@ -946,6 +1017,10 @@ called and `readableFlowing` is not `true`.
 ##### `readable.destroy([error])`
 <!-- YAML
 added: v8.0.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/29197
+    description: Work as a no-op on a stream that has already been destroyed.
 -->
 
 * `error` {Error} Error which will be passed as payload in `'error'` event
@@ -955,6 +1030,10 @@ Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`
 event (unless `emitClose` is set to `false`). After this call, the readable
 stream will release any internal resources and subsequent calls to `push()`
 will be ignored.
+
+Once `destroy()` has been called any further calls will be a no-op and no
+further errors except from `_destroy()` may be emitted as `'error'`.
+
 Implementors should not override this method, but instead implement
 [`readable._destroy()`][readable-_destroy].
 
@@ -1100,7 +1179,7 @@ buffer will be returned.
 If the `size` argument is not specified, all of the data contained in the
 internal buffer will be returned.
 
-The `size` argument must be less than or equal to 1 GB.
+The `size` argument must be less than or equal to 1 GiB.
 
 The `readable.read()` method should only be called on `Readable` streams
 operating in paused mode. In flowing mode, `readable.read()` is called
@@ -1168,7 +1247,19 @@ added: v11.4.0
 
 * {boolean}
 
-Is `true` if it is safe to call [`readable.read()`][stream-read].
+Is `true` if it is safe to call [`readable.read()`][stream-read], which means
+the stream has not been destroyed or emitted `'error'` or `'end'`.
+
+##### `readable.readableDidRead`
+<!-- YAML
+added: v14.18.0
+-->
+
+* {boolean}
+
+Allows determining if the stream has been or is about to be read.
+Returns true if `'data'`, `'end'`, `'error'` or `'close'` has been
+emitted.
 
 ##### `readable.readableEncoding`
 <!-- YAML
@@ -1505,6 +1596,10 @@ Examples of `Transform` streams include:
 ##### `transform.destroy([error])`
 <!-- YAML
 added: v8.0.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/29197
+    description: Work as a no-op on a stream that has already been destroyed.
 -->
 
 * `error` {Error}
@@ -1517,9 +1612,27 @@ Implementors should not override this method, but instead implement
 The default implementation of `_destroy()` for `Transform` also emit `'close'`
 unless `emitClose` is set in false.
 
+Once `destroy()` has been called, any further calls will be a no-op and no
+further errors except from `_destroy()` may be emitted as `'error'`.
+
 ### `stream.finished(stream[, options], callback)`
 <!-- YAML
 added: v10.0.0
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/32158
+    description: The `finished(stream, cb)` will wait for the `'close'` event
+                 before invoking the callback. The implementation tries to
+                 detect legacy streams and only apply this behavior to streams
+                 which are expected to emit `'close'`.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31545
+    description: Emitting `'close'` before `'end'` on a `Readable` stream
+                 will cause an `ERR_STREAM_PREMATURE_CLOSE` error.
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/31509
+    description: Callback will be invoked on streams which have already
+                 finished before the call to `finished(stream, cb)`.
 -->
 
 * `stream` {Stream} A readable and/or writable stream.
@@ -1590,17 +1703,38 @@ const cleanup = finished(rs, (err) => {
 });
 ```
 
-### `stream.pipeline(...streams, callback)`
+### `stream.pipeline(source[, ...transforms], destination, callback)`
+### `stream.pipeline(streams, callback)`
 <!-- YAML
 added: v10.0.0
--->
-
-* `...streams` {Stream} Two or more streams to pipe between.
+changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/32158
+    description: The `pipeline(..., cb)` will wait for the `'close'` event
+                 before invoking the callback. The implementation tries to
+                 detect legacy streams and only apply this behavior to streams
+                 which are expected to emit `'close'`.
+  - version: v13.10.0
+    pr-url: https://github.com/nodejs/node/pull/31223
+    description: Add support for async generators.
+-->
+
+* `streams` {Stream[]|Iterable[]|AsyncIterable[]|Function[]}
+* `source` {Stream|Iterable|AsyncIterable|Function}
+  * Returns: {Iterable|AsyncIterable}
+* `...transforms` {Stream|Function}
+  * `source` {AsyncIterable}
+  * Returns: {AsyncIterable}
+* `destination` {Stream|Function}
+  * `source` {AsyncIterable}
+  * Returns: {AsyncIterable|Promise}
 * `callback` {Function} Called when the pipeline is fully done.
   * `err` {Error}
+  * `val` Resolved value of `Promise` returned by `destination`.
+* Returns: {Stream}
 
-A module method to pipe between streams forwarding errors and properly cleaning
-up and provide a callback when the pipeline is complete.
+A module method to pipe between streams and generators forwarding errors and
+properly cleaning up and provide a callback when the pipeline is complete.
 
 ```js
 const { pipeline } = require('stream');
@@ -1643,6 +1777,29 @@ async function run() {
 run().catch(console.error);
 ```
 
+The `pipeline` API also supports async generators:
+
+```js
+const pipeline = util.promisify(stream.pipeline);
+const fs = require('fs');
+
+async function run() {
+  await pipeline(
+    fs.createReadStream('lowercase.txt'),
+    async function* (source) {
+      source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.
+      for await (const chunk of source) {
+        yield chunk.toUpperCase();
+      }
+    },
+    fs.createWriteStream('uppercase.txt')
+  );
+  console.log('Pipeline succeeded.');
+}
+
+run().catch(console.error);
+```
+
 `stream.pipeline()` will call `stream.destroy(err)` on all streams except:
 * `Readable` streams which have emitted `'end'` or `'close'`.
 * `Writable` streams which have emitted `'finish'` or `'close'`.
@@ -1705,11 +1862,7 @@ const { Writable } = require('stream');
 
 class MyWritable extends Writable {
   constructor({ highWaterMark, ...options }) {
-    super({
-      highWaterMark,
-      autoDestroy: true,
-      emitClose: true
-    });
+    super({ highWaterMark });
     // ...
   }
 }
@@ -1775,14 +1928,19 @@ method.
 #### `new stream.Writable([options])`
 <!-- YAML
 changes:
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/30623
+    description: Change `autoDestroy` option default to `true`.
+  - version:
+     - v11.2.0
+     - v10.16.0
+    pr-url: https://github.com/nodejs/node/pull/22795
+    description: Add `autoDestroy` option to automatically `destroy()` the
+                 stream when it emits `'finish'` or errors.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/18438
     description: Add `emitClose` option to specify if `'close'` is emitted on
                  destroy.
-  - version: v11.2.0
-    pr-url: https://github.com/nodejs/node/pull/22795
-    description: Add `autoDestroy` option to automatically `destroy()` the
-                 stream when it emits `'finish'` or errors.
 -->
 
 * `options` {Object}
@@ -1814,7 +1972,7 @@ changes:
   * `final` {Function} Implementation for the
     [`stream._final()`][stream-_final] method.
   * `autoDestroy` {boolean} Whether this stream should automatically call
-    `.destroy()` on itself after ending. **Default:** `false`.
+    `.destroy()` on itself after ending. **Default:** `true`.
 
 <!-- eslint-disable no-useless-constructor -->
 ```js
@@ -1889,10 +2047,11 @@ This function MUST NOT be called by application code directly. It should be
 implemented by child classes, and called by the internal `Writable` class
 methods only.
 
-The `callback` method must be called to signal either that the write completed
-successfully or failed with an error. The first argument passed to the
-`callback` must be the `Error` object if the call failed or `null` if the
-write succeeded.
+The `callback` function must be called synchronously inside of
+`writable._write()` or asynchronously (i.e. different tick) to signal either
+that the write completed successfully or failed with an error.
+The first argument passed to the `callback` must be the `Error` object if the
+call failed or `null` if the write succeeded.
 
 All calls to `writable.write()` that occur between the time `writable._write()`
 is called and the `callback` is called will cause the written data to be
@@ -1913,8 +2072,14 @@ user programs.
 
 #### `writable._writev(chunks, callback)`
 
-* `chunks` {Object[]} The chunks to be written. Each chunk has following
-  format: `{ chunk: ..., encoding: ... }`.
+* `chunks` {Object[]} The data to be written. The value is an array of {Object}
+  that each represent a discrete chunk of data to write. The properties of
+  these objects are:
+  * `chunk` {Buffer|string} A buffer instance or string containing the data to
+    be written. The `chunk` will be a string if the `Writable` was created with
+    the `decodeStrings` option set to `false` and a string was passed to `write()`.
+  * `encoding` {string} The character encoding of the `chunk`. If `chunk` is
+    a `Buffer`, the `encoding` will be `'buffer'`.
 * `callback` {Function} A callback function (optionally with an error
   argument) to be invoked when processing is complete for the supplied chunks.
 
@@ -2055,7 +2220,12 @@ constructor and implement the [`readable._read()`][] method.
 #### `new stream.Readable([options])`
 <!-- YAML
 changes:
-  - version: v11.2.0
+  - version: v14.0.0
+    pr-url: https://github.com/nodejs/node/pull/30623
+    description: Change `autoDestroy` option default to `true`.
+  - version:
+     - v11.2.0
+     - v10.16.0
     pr-url: https://github.com/nodejs/node/pull/22795
     description: Add `autoDestroy` option to automatically `destroy()` the
                  stream when it emits `'end'` or errors.
@@ -2077,7 +2247,7 @@ changes:
   * `destroy` {Function} Implementation for the
     [`stream._destroy()`][readable-_destroy] method.
   * `autoDestroy` {boolean} Whether this stream should automatically call
-    `.destroy()` on itself after ending. **Default:** `false`.
+    `.destroy()` on itself after ending. **Default:** `true`.
 
 <!-- eslint-disable no-useless-constructor -->
 ```js
@@ -2134,10 +2304,12 @@ All `Readable` stream implementations must provide an implementation of the
 
 When [`readable._read()`][] is called, if data is available from the resource,
 the implementation should begin pushing that data into the read queue using the
-[`this.push(dataChunk)`][stream-push] method. `_read()` should continue reading
-from the resource and pushing data until `readable.push()` returns `false`. Only
-when `_read()` is called again after it has stopped should it resume pushing
-additional data onto the queue.
+[`this.push(dataChunk)`][stream-push] method. `_read()` will be called again
+after each call to [`this.push(dataChunk)`][stream-push] once the stream is
+ready to accept more data. `_read()` may continue reading from the resource and
+pushing data until `readable.push()` returns `false`. Only when `_read()` is
+called again after it has stopped should it resume pushing additional data into
+the queue.
 
 Once the [`readable._read()`][] method has been called, it will not be called
 again until more data is pushed through the [`readable.push()`][stream-push]
@@ -2529,14 +2701,19 @@ const myTransform = new Transform({
 });
 ```
 
-#### Events: `'finish'` and `'end'`
+#### Event: `'end'`
 
-The [`'finish'`][] and [`'end'`][] events are from the `stream.Writable`
-and `stream.Readable` classes, respectively. The `'finish'` event is emitted
-after [`stream.end()`][stream-end] is called and all chunks have been processed
-by [`stream._transform()`][stream-_transform]. The `'end'` event is emitted
-after all data has been output, which occurs after the callback in
-[`transform._flush()`][stream-_flush] has been called.
+The [`'end'`][] event is from the `stream.Readable` class. The `'end'` event is
+emitted after all data has been output, which occurs after the callback in
+[`transform._flush()`][stream-_flush] has been called. In the case of an error,
+`'end'` should not be emitted.
+
+#### Event: `'finish'`
+
+The [`'finish'`][] event is from the `stream.Writable` class. The `'finish'`
+event is emitted after [`stream.end()`][stream-end] is called and all chunks
+have been processed by [`stream._transform()`][stream-_transform]. In the case
+of an error, `'finish'` should not be emitted.
 
 #### `transform._flush(callback)`
 
@@ -2676,81 +2853,33 @@ readable.on('data', (chunk) => {
 
 #### Piping to writable streams from async iterators
 
-In the scenario of writing to a writable stream from an async iterator, ensure
-the correct handling of backpressure and errors.
+When writing to a writable stream from an async iterator, ensure correct
+handling of backpressure and errors. [`stream.pipeline()`][] abstracts away
+the handling of backpressure and backpressure-related errors:
 
 ```js
-const { once } = require('events');
-const finished = util.promisify(stream.finished);
+const { pipeline } = require('stream');
+const util = require('util');
+const fs = require('fs');
 
 const writable = fs.createWriteStream('./file');
 
-function drain(writable) {
-  if (writable.destroyed) {
-    return Promise.reject(new Error('premature close'));
-  }
-  return Promise.race([
-    once(writable, 'drain'),
-    once(writable, 'close')
-      .then(() => Promise.reject(new Error('premature close')))
-  ]);
-}
-
-async function pump(iterable, writable) {
-  for await (const chunk of iterable) {
-    // Handle backpressure on write().
-    if (!writable.write(chunk)) {
-      await drain(writable);
-    }
+// Callback Pattern
+pipeline(iterator, writable, (err, value) => {
+  if (err) {
+    console.error(err);
+  } else {
+    console.log(value, 'value returned');
   }
-  writable.end();
-}
-
-(async function() {
-  // Ensure completion without errors.
-  await Promise.all([
-    pump(iterable, writable),
-    finished(writable)
-  ]);
-})();
-```
-
-In the above, errors on `write()` would be caught and thrown by the
-`once()` listener for the `'drain'` event, since `once()` will also handle the
-`'error'` event. To ensure completion of the write stream without errors,
-it is safer to use the `finished()` method as above, instead of using the
-`once()` listener for the `'finish'` event. Under certain cases, an `'error'`
-event could be emitted by the writable stream after `'finish'` and as `once()`
-will release the `'error'` handler on handling the `'finish'` event, it could
-result in an unhandled error.
-
-Alternatively, the readable stream could be wrapped with `Readable.from()` and
-then piped via `.pipe()`:
-
-```js
-const finished = util.promisify(stream.finished);
-
-const writable = fs.createWriteStream('./file');
-
-(async function() {
-  const readable = Readable.from(iterable);
-  readable.pipe(writable);
-  // Ensure completion without errors.
-  await finished(writable);
-})();
-```
-
-Or, using `stream.pipeline()` to pipe streams:
-
-```js
-const pipeline = util.promisify(stream.pipeline);
-
-const writable = fs.createWriteStream('./file');
+});
 
-(async function() {
-  const readable = Readable.from(iterable);
-  await pipeline(readable, writable);
-})();
+// Promise Pattern
+const pipelinePromise = util.promisify(pipeline);
+pipelinePromise(iterator, writable)
+  .then((value) => {
+    console.log(value, 'value returned');
+  })
+  .catch(console.error);
 ```
 
 <!--type=misc-->
@@ -2860,23 +2989,30 @@ This is not a problem in common cases with `latin1` or `ascii`. But it is
 advised to be mindful about this behavior when working with strings that could
 contain multi-byte characters.
 
+[API for stream consumers]: #stream_api_for_stream_consumers
+[API for stream implementers]: #stream_api_for_stream_implementers
+[Compatibility]: #stream_compatibility_with_older_node_js_versions
+[HTTP requests, on the client]: http.md#http_class_http_clientrequest
+[HTTP responses, on the server]: http.md#http_class_http_serverresponse
+[TCP sockets]: net.md#net_class_net_socket
+[Three states]: #stream_three_states
 [`'data'`]: #stream_event_data
 [`'drain'`]: #stream_event_drain
 [`'end'`]: #stream_event_end
 [`'finish'`]: #stream_event_finish
 [`'readable'`]: #stream_event_readable
 [`Duplex`]: #stream_class_stream_duplex
-[`EventEmitter`]: events.html#events_class_eventemitter
+[`EventEmitter`]: events.md#events_class_eventemitter
 [`Readable`]: #stream_class_stream_readable
 [`Symbol.hasInstance`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance
 [`Transform`]: #stream_class_stream_transform
 [`Writable`]: #stream_class_stream_writable
-[`fs.createReadStream()`]: fs.html#fs_fs_createreadstream_path_options
-[`fs.createWriteStream()`]: fs.html#fs_fs_createwritestream_path_options
-[`net.Socket`]: net.html#net_class_net_socket
-[`process.stderr`]: process.html#process_process_stderr
-[`process.stdin`]: process.html#process_process_stdin
-[`process.stdout`]: process.html#process_process_stdout
+[`fs.createReadStream()`]: fs.md#fs_fs_createreadstream_path_options
+[`fs.createWriteStream()`]: fs.md#fs_fs_createwritestream_path_options
+[`net.Socket`]: net.md#net_class_net_socket
+[`process.stderr`]: process.md#process_process_stderr
+[`process.stdin`]: process.md#process_process_stdin
+[`process.stdout`]: process.md#process_process_stdout
 [`readable._read()`]: #stream_readable_read_size_1
 [`readable.push('')`]: #stream_readable_push
 [`readable.setEncoding()`]: #stream_readable_setencoding_encoding
@@ -2884,7 +3020,7 @@ contain multi-byte characters.
 [`stream.cork()`]: #stream_writable_cork
 [`stream.finished()`]: #stream_stream_finished_stream_options_callback
 [`stream.pipe()`]: #stream_readable_pipe_destination_options
-[`stream.pipeline()`]: #stream_stream_pipeline_streams_callback
+[`stream.pipeline()`]: #stream_stream_pipeline_source_transforms_destination_callback
 [`stream.uncork()`]: #stream_writable_uncork
 [`stream.unpipe()`]: #stream_readable_unpipe_destination
 [`stream.wrap()`]: #stream_readable_wrap_stream
@@ -2895,19 +3031,13 @@ contain multi-byte characters.
 [`writable.end()`]: #stream_writable_end_chunk_encoding_callback
 [`writable.uncork()`]: #stream_writable_uncork
 [`writable.writableFinished`]: #stream_writable_writablefinished
-[`zlib.createDeflate()`]: zlib.html#zlib_zlib_createdeflate_options
-[API for stream consumers]: #stream_api_for_stream_consumers
-[API for stream implementers]: #stream_api_for_stream_implementers
-[Compatibility]: #stream_compatibility_with_older_node_js_versions
-[HTTP requests, on the client]: http.html#http_class_http_clientrequest
-[HTTP responses, on the server]: http.html#http_class_http_serverresponse
-[TCP sockets]: net.html#net_class_net_socket
-[child process stdin]: child_process.html#child_process_subprocess_stdin
-[child process stdout and stderr]: child_process.html#child_process_subprocess_stdout
-[crypto]: crypto.html
-[fs read streams]: fs.html#fs_class_fs_readstream
-[fs write streams]: fs.html#fs_class_fs_writestream
-[http-incoming-message]: http.html#http_class_http_incomingmessage
+[`zlib.createDeflate()`]: zlib.md#zlib_zlib_createdeflate_options
+[child process stdin]: child_process.md#child_process_subprocess_stdin
+[child process stdout and stderr]: child_process.md#child_process_subprocess_stdout
+[crypto]: crypto.md
+[fs read streams]: fs.md#fs_class_fs_readstream
+[fs write streams]: fs.md#fs_class_fs_writestream
+[http-incoming-message]: http.md#http_class_http_incomingmessage
 [hwm-gotcha]: #stream_highwatermark_discrepancy_after_calling_readable_setencoding
 [object-mode]: #stream_object_mode
 [readable-_destroy]: #stream_readable_destroy_err_callback
@@ -2925,8 +3055,7 @@ contain multi-byte characters.
 [stream-resume]: #stream_readable_resume
 [stream-uncork]: #stream_writable_uncork
 [stream-write]: #stream_writable_write_chunk_encoding_callback
-[Three states]: #stream_three_states
 [writable-_destroy]: #stream_writable_destroy_err_callback
 [writable-destroy]: #stream_writable_destroy_error
 [writable-new]: #stream_new_stream_writable_options
-[zlib]: zlib.html
+[zlib]: zlib.md
diff --git a/doc/api/string_decoder.html b/doc/api/string_decoder.html
index 34825b56dfe0cae361557ad1d4b849ebb9dcde9b..3d444c5627c60cb1519986dad2c419b641cf3b00 100644
--- a/doc/api/string_decoder.html
+++ b/doc/api/string_decoder.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>String decoder | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>String decoder | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="string_decoder" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/string_decoder.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/string_decoder.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/string_decoder.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/string_decoder.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/string_decoder.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/string_decoder.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/string_decoder.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/string_decoder.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/string_decoder.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#string_decoder_string_decoder">String decoder</a></span>
 <ul>
 <li><a href="#string_decoder_class_stringdecoder">Class: <code>StringDecoder</code></a>
@@ -138,41 +151,40 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>String decoder<span><a class="mark" href="#string_decoder_string_decoder" id="string_decoder_string_decoder">#</a></span></h1>
+        <h2>String decoder<span><a class="mark" href="#string_decoder_string_decoder" id="string_decoder_string_decoder">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/string_decoder.js">lib/string_decoder.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/string_decoder.js">lib/string_decoder.js</a></p>
 <p>The <code>string_decoder</code> module provides an API for decoding <code>Buffer</code> objects into
 strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
 characters. It can be accessed using:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);</code></pre>
 <p>The following example shows the basic use of the <code>StringDecoder</code> class.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
-<span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> StringDecoder(<span class="hljs-string">'utf8'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
+<span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringDecoder</span>(<span class="hljs-string">'utf8'</span>);
 
-<span class="hljs-keyword">const</span> cent = Buffer.from([<span class="hljs-number">0xC2</span>, <span class="hljs-number">0xA2</span>]);
-<span class="hljs-built_in">console</span>.log(decoder.write(cent));
+<span class="hljs-keyword">const</span> cent = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0xC2</span>, <span class="hljs-number">0xA2</span>]);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decoder.<span class="hljs-title function_">write</span>(cent));
 
-<span class="hljs-keyword">const</span> euro = Buffer.from([<span class="hljs-number">0xE2</span>, <span class="hljs-number">0x82</span>, <span class="hljs-number">0xAC</span>]);
-<span class="hljs-built_in">console</span>.log(decoder.write(euro));</code></pre>
+<span class="hljs-keyword">const</span> euro = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0xE2</span>, <span class="hljs-number">0x82</span>, <span class="hljs-number">0xAC</span>]);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decoder.<span class="hljs-title function_">write</span>(euro));</code></pre>
 <p>When a <code>Buffer</code> instance is written to the <code>StringDecoder</code> instance, an
 internal buffer is used to ensure that the decoded string does not contain
 any incomplete multibyte characters. These are held in the buffer until the
 next call to <code>stringDecoder.write()</code> or until <code>stringDecoder.end()</code> is called.</p>
 <p>In the following example, the three UTF-8 encoded bytes of the European Euro
 symbol (<code>€</code>) are written over three separate operations:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { StringDecoder } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
-<span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> StringDecoder(<span class="hljs-string">'utf8'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">StringDecoder</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'string_decoder'</span>);
+<span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringDecoder</span>(<span class="hljs-string">'utf8'</span>);
 
-decoder.write(Buffer.from([<span class="hljs-number">0xE2</span>]));
-decoder.write(Buffer.from([<span class="hljs-number">0x82</span>]));
-<span class="hljs-built_in">console</span>.log(decoder.end(Buffer.from([<span class="hljs-number">0xAC</span>])));</code></pre>
-<h2>Class: <code>StringDecoder</code><span><a class="mark" href="#string_decoder_class_stringdecoder" id="string_decoder_class_stringdecoder">#</a></span></h2>
-<h3><code>new StringDecoder([encoding])</code><span><a class="mark" href="#string_decoder_new_stringdecoder_encoding" id="string_decoder_new_stringdecoder_encoding">#</a></span></h3>
+decoder.<span class="hljs-title function_">write</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0xE2</span>]));
+decoder.<span class="hljs-title function_">write</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0x82</span>]));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(decoder.<span class="hljs-title function_">end</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>([<span class="hljs-number">0xAC</span>])));</code></pre>
+<section><h3>Class: <code>StringDecoder</code><span><a class="mark" href="#string_decoder_class_stringdecoder" id="string_decoder_class_stringdecoder">#</a></span></h3>
+<h4><code>new StringDecoder([encoding])</code><span><a class="mark" href="#string_decoder_new_stringdecoder_encoding" id="string_decoder_new_stringdecoder_encoding">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.1.99</span>
 </div>
@@ -181,7 +193,7 @@ decoder.write(Buffer.from([<span class="hljs-number">0x82</span>]));
 <strong>Default:</strong> <code>'utf8'</code>.</li>
 </ul>
 <p>Creates a new <code>StringDecoder</code> instance.</p>
-<h3><code>stringDecoder.end([buffer])</code><span><a class="mark" href="#string_decoder_stringdecoder_end_buffer" id="string_decoder_stringdecoder_end_buffer">#</a></span></h3>
+<h4><code>stringDecoder.end([buffer])</code><span><a class="mark" href="#string_decoder_stringdecoder_end_buffer" id="string_decoder_stringdecoder_end_buffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.3</span>
 </div>
@@ -194,8 +206,9 @@ decoder.write(Buffer.from([<span class="hljs-number">0x82</span>]));
 representing incomplete UTF-8 and UTF-16 characters will be replaced with
 substitution characters appropriate for the character encoding.</p>
 <p>If the <code>buffer</code> argument is provided, one final call to <code>stringDecoder.write()</code>
-is performed before returning the remaining input.</p>
-<h3><code>stringDecoder.write(buffer)</code><span><a class="mark" href="#string_decoder_stringdecoder_write_buffer" id="string_decoder_stringdecoder_write_buffer">#</a></span></h3>
+is performed before returning the remaining input.
+After <code>end()</code> is called, the <code>stringDecoder</code> object can be reused for new input.</p>
+<h4><code>stringDecoder.write(buffer)</code><span><a class="mark" href="#string_decoder_stringdecoder_write_buffer" id="string_decoder_stringdecoder_write_buffer">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -215,10 +228,46 @@ is performed before returning the remaining input.</p>
 <p>Returns a decoded string, ensuring that any incomplete multibyte characters at
 the end of the <code>Buffer</code>, or <code>TypedArray</code>, or <code>DataView</code> are omitted from the
 returned string and stored in an internal buffer for the next call to
-<code>stringDecoder.write()</code> or <code>stringDecoder.end()</code>.</p>
+<code>stringDecoder.write()</code> or <code>stringDecoder.end()</code>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/string_decoder.json b/doc/api/string_decoder.json
index 425b48ca1eb73b8b21ff420598d18a1b629b3664..6dca959b2239f7dc0ce34aea47b67666fdab1b4f 100644
--- a/doc/api/string_decoder.json
+++ b/doc/api/string_decoder.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/string_decoder.js\">lib/string_decoder.js</a></p>\n<p>The <code>string_decoder</code> module provides an API for decoding <code>Buffer</code> objects into\nstrings in a manner that preserves encoded multi-byte UTF-8 and UTF-16\ncharacters. It can be accessed using:</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\n</code></pre>\n<p>The following example shows the basic use of the <code>StringDecoder</code> class.</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\nconst decoder = new StringDecoder('utf8');\n\nconst cent = Buffer.from([0xC2, 0xA2]);\nconsole.log(decoder.write(cent));\n\nconst euro = Buffer.from([0xE2, 0x82, 0xAC]);\nconsole.log(decoder.write(euro));\n</code></pre>\n<p>When a <code>Buffer</code> instance is written to the <code>StringDecoder</code> instance, an\ninternal buffer is used to ensure that the decoded string does not contain\nany incomplete multibyte characters. These are held in the buffer until the\nnext call to <code>stringDecoder.write()</code> or until <code>stringDecoder.end()</code> is called.</p>\n<p>In the following example, the three UTF-8 encoded bytes of the European Euro\nsymbol (<code>€</code>) are written over three separate operations:</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\nconst decoder = new StringDecoder('utf8');\n\ndecoder.write(Buffer.from([0xE2]));\ndecoder.write(Buffer.from([0x82]));\nconsole.log(decoder.end(Buffer.from([0xAC])));\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/string_decoder.js\">lib/string_decoder.js</a></p>\n<p>The <code>string_decoder</code> module provides an API for decoding <code>Buffer</code> objects into\nstrings in a manner that preserves encoded multi-byte UTF-8 and UTF-16\ncharacters. It can be accessed using:</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\n</code></pre>\n<p>The following example shows the basic use of the <code>StringDecoder</code> class.</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\nconst decoder = new StringDecoder('utf8');\n\nconst cent = Buffer.from([0xC2, 0xA2]);\nconsole.log(decoder.write(cent));\n\nconst euro = Buffer.from([0xE2, 0x82, 0xAC]);\nconsole.log(decoder.write(euro));\n</code></pre>\n<p>When a <code>Buffer</code> instance is written to the <code>StringDecoder</code> instance, an\ninternal buffer is used to ensure that the decoded string does not contain\nany incomplete multibyte characters. These are held in the buffer until the\nnext call to <code>stringDecoder.write()</code> or until <code>stringDecoder.end()</code> is called.</p>\n<p>In the following example, the three UTF-8 encoded bytes of the European Euro\nsymbol (<code>€</code>) are written over three separate operations:</p>\n<pre><code class=\"language-js\">const { StringDecoder } = require('string_decoder');\nconst decoder = new StringDecoder('utf8');\n\ndecoder.write(Buffer.from([0xE2]));\ndecoder.write(Buffer.from([0x82]));\nconsole.log(decoder.end(Buffer.from([0xAC])));\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `StringDecoder`",
@@ -42,7 +42,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns any remaining input stored in the internal buffer as a string. Bytes\nrepresenting incomplete UTF-8 and UTF-16 characters will be replaced with\nsubstitution characters appropriate for the character encoding.</p>\n<p>If the <code>buffer</code> argument is provided, one final call to <code>stringDecoder.write()</code>\nis performed before returning the remaining input.</p>"
+              "desc": "<p>Returns any remaining input stored in the internal buffer as a string. Bytes\nrepresenting incomplete UTF-8 and UTF-16 characters will be replaced with\nsubstitution characters appropriate for the character encoding.</p>\n<p>If the <code>buffer</code> argument is provided, one final call to <code>stringDecoder.write()</code>\nis performed before returning the remaining input.\nAfter <code>end()</code> is called, the <code>stringDecoder</code> object can be reused for new input.</p>"
             },
             {
               "textRaw": "`stringDecoder.write(buffer)`",
diff --git a/doc/api/string_decoder.md b/doc/api/string_decoder.md
index 59056b861321b47aa3275eb841fff4b9ab57e82c..e0e1323cf331e3baa3744d6f107ea2bdd43f3660 100644
--- a/doc/api/string_decoder.md
+++ b/doc/api/string_decoder.md
@@ -62,7 +62,7 @@ added: v0.9.3
 -->
 
 * `buffer` {Buffer|TypedArray|DataView} A `Buffer`, or `TypedArray`, or
- `DataView` containing the bytes to decode.
+  `DataView` containing the bytes to decode.
 * Returns: {string}
 
 Returns any remaining input stored in the internal buffer as a string. Bytes
@@ -71,6 +71,7 @@ substitution characters appropriate for the character encoding.
 
 If the `buffer` argument is provided, one final call to `stringDecoder.write()`
 is performed before returning the remaining input.
+After `end()` is called, the `stringDecoder` object can be reused for new input.
 
 ### `stringDecoder.write(buffer)`
 <!-- YAML
@@ -83,7 +84,7 @@ changes:
 -->
 
 * `buffer` {Buffer|TypedArray|DataView} A `Buffer`, or `TypedArray`, or
- `DataView` containing the bytes to decode.
+  `DataView` containing the bytes to decode.
 * Returns: {string}
 
 Returns a decoded string, ensuring that any incomplete multibyte characters at
@@ -91,4 +92,4 @@ Returns a decoded string, ensuring that any incomplete multibyte characters at
  returned string and stored in an internal buffer for the next call to
  `stringDecoder.write()` or `stringDecoder.end()`.
 
-[encoding]: buffer.html#buffer_buffers_and_character_encodings
+[encoding]: buffer.md#buffer_buffers_and_character_encodings
diff --git a/doc/api/synopsis.html b/doc/api/synopsis.html
index a16f33a46f4fd6c431fd249909a99a2575b78dde..5c304d5de14ba161e2ef4464fe3ad59cbea6803a 100644
--- a/doc/api/synopsis.html
+++ b/doc/api/synopsis.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Usage and example | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Usage and example | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="synopsis" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/synopsis.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/synopsis.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/synopsis.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/synopsis.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/synopsis.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/synopsis.html">13.x</a></li>
@@ -118,32 +133,29 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/synopsis.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/synopsis.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/synopsis.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#synopsis_usage_and_example">Usage and example</a>
 <ul>
 <li><a href="#synopsis_usage">Usage</a></li>
 <li><a href="#synopsis_example">Example</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Usage and example<span><a class="mark" href="#synopsis_usage_and_example" id="synopsis_usage_and_example">#</a></span></h1>
-<h2>Usage<span><a class="mark" href="#synopsis_usage" id="synopsis_usage">#</a></span></h2>
+        <h2>Usage and example<span><a class="mark" href="#synopsis_usage_and_example" id="synopsis_usage_and_example">#</a></span></h2>
+<section><h3>Usage<span><a class="mark" href="#synopsis_usage" id="synopsis_usage">#</a></span></h3>
 
 
 <p><code>node [options] [V8 options] [script.js | -e "script" | - ] [arguments]</code></p>
-<p>Please see the <a href="cli.html#cli_command_line_options">Command Line Options</a> document for more information.</p>
-<h2>Example<span><a class="mark" href="#synopsis_example" id="synopsis_example">#</a></span></h2>
+<p>Please see the <a href="cli.html#cli_command_line_options">Command-line options</a> document for more information.</p>
+</section><section><h3>Example<span><a class="mark" href="#synopsis_example" id="synopsis_example">#</a></span></h3>
 <p>An example of a <a href="http.html">web server</a> written with Node.js which responds with
 <code>'Hello, World!'</code>:</p>
 <p>Commands in this document start with <code>$</code> or <code>></code> to replicate how they would
@@ -151,18 +163,18 @@ appear in a user's terminal. Do not include the <code>$</code> and <code>></code
 there to show the start of each command.</p>
 <p>Lines that don’t start with <code>$</code> or <code>></code> character show the output of the previous
 command.</p>
-<p>First, make sure to have downloaded and installed Node.js. See <a href="https://nodejs.org/en/download/package-manager/">this guide</a>
-for further install information.</p>
+<p>First, make sure to have downloaded and installed Node.js. See
+<a href="https://nodejs.org/en/download/package-manager/">Installing Node.js via package manager</a> for further install information.</p>
 <p>Now, create an empty project folder called <code>projects</code>, then navigate into it.</p>
 <p>Linux and Mac:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> mkdir ~/projects</span>
-<span class="hljs-meta">$</span><span class="bash"> <span class="hljs-built_in">cd</span> ~/projects</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">mkdir ~/projects</span>
+<span class="hljs-meta">$ </span><span class="language-bash"><span class="hljs-built_in">cd</span> ~/projects</span></code></pre>
 <p>Windows CMD:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> mkdir %USERPROFILE%\projects</span>
-<span class="hljs-meta">></span><span class="bash"> <span class="hljs-built_in">cd</span> %USERPROFILE%\projects</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">mkdir %USERPROFILE%\projects</span>
+<span class="hljs-meta">> </span><span class="language-bash"><span class="hljs-built_in">cd</span> %USERPROFILE%\projects</span></code></pre>
 <p>Windows PowerShell:</p>
-<pre><code class="language-console"><span class="hljs-meta">></span><span class="bash"> mkdir <span class="hljs-variable">$env</span>:USERPROFILE\projects</span>
-<span class="hljs-meta">></span><span class="bash"> <span class="hljs-built_in">cd</span> <span class="hljs-variable">$env</span>:USERPROFILE\projects</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">> </span><span class="language-bash">mkdir <span class="hljs-variable">$env</span>:USERPROFILE\projects</span>
+<span class="hljs-meta">> </span><span class="language-bash"><span class="hljs-built_in">cd</span> <span class="hljs-variable">$env</span>:USERPROFILE\projects</span></code></pre>
 <p>Next, create a new source file in the <code>projects</code>
 folder and call it <code>hello-world.js</code>.</p>
 <p>Open <code>hello-world.js</code> in any preferred text editor and
@@ -172,25 +184,61 @@ paste in the following content:</p>
 <span class="hljs-keyword">const</span> hostname = <span class="hljs-string">'127.0.0.1'</span>;
 <span class="hljs-keyword">const</span> port = <span class="hljs-number">3000</span>;
 
-<span class="hljs-keyword">const</span> server = http.createServer(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
-  res.statusCode = <span class="hljs-number">200</span>;
-  res.setHeader(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/plain'</span>);
-  res.end(<span class="hljs-string">'Hello, World!\n'</span>);
+<span class="hljs-keyword">const</span> server = http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">req, res</span>) =></span> {
+  res.<span class="hljs-property">statusCode</span> = <span class="hljs-number">200</span>;
+  res.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Content-Type'</span>, <span class="hljs-string">'text/plain'</span>);
+  res.<span class="hljs-title function_">end</span>(<span class="hljs-string">'Hello, World!\n'</span>);
 });
 
-server.listen(port, hostname, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Server running at http://<span class="hljs-subst">${hostname}</span>:<span class="hljs-subst">${port}</span>/`</span>);
+server.<span class="hljs-title function_">listen</span>(port, hostname, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Server running at http://<span class="hljs-subst">${hostname}</span>:<span class="hljs-subst">${port}</span>/`</span>);
 });</code></pre>
 <p>Save the file, go back to the terminal window, and enter the following command:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node hello-world.js</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node hello-world.js</span></code></pre>
 <p>Output like this should appear in the terminal:</p>
 <pre><code class="language-console">Server running at http://127.0.0.1:3000/</code></pre>
 <p>Now, open any preferred web browser and visit <code>http://127.0.0.1:3000</code>.</p>
 <p>If the browser displays the string <code>Hello, World!</code>, that indicates
-the server is working.</p>
+the server is working.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/synopsis.json b/doc/api/synopsis.json
index ce0d7b631595e3b3fde035b66fe9fbeb3191fb65..02d877321383ecf37756afb2305e667fdf4b6b2e 100644
--- a/doc/api/synopsis.json
+++ b/doc/api/synopsis.json
@@ -12,7 +12,7 @@
           "name": "Usage",
           "introduced_in": "v0.10.0",
           "type": "misc",
-          "desc": "<p><code>node [options] [V8 options] [script.js | -e \"script\" | - ] [arguments]</code></p>\n<p>Please see the <a href=\"cli.html#cli_command_line_options\">Command Line Options</a> document for more information.</p>\n<h2>Example</h2>\n<p>An example of a <a href=\"http.html\">web server</a> written with Node.js which responds with\n<code>'Hello, World!'</code>:</p>\n<p>Commands in this document start with <code>$</code> or <code>></code> to replicate how they would\nappear in a user's terminal. Do not include the <code>$</code> and <code>></code> characters. They are\nthere to show the start of each command.</p>\n<p>Lines that don’t start with <code>$</code> or <code>></code> character show the output of the previous\ncommand.</p>\n<p>First, make sure to have downloaded and installed Node.js. See <a href=\"https://nodejs.org/en/download/package-manager/\">this guide</a>\nfor further install information.</p>\n<p>Now, create an empty project folder called <code>projects</code>, then navigate into it.</p>\n<p>Linux and Mac:</p>\n<pre><code class=\"language-console\">$ mkdir ~/projects\n$ cd ~/projects\n</code></pre>\n<p>Windows CMD:</p>\n<pre><code class=\"language-console\">> mkdir %USERPROFILE%\\projects\n> cd %USERPROFILE%\\projects\n</code></pre>\n<p>Windows PowerShell:</p>\n<pre><code class=\"language-console\">> mkdir $env:USERPROFILE\\projects\n> cd $env:USERPROFILE\\projects\n</code></pre>\n<p>Next, create a new source file in the <code>projects</code>\nfolder and call it <code>hello-world.js</code>.</p>\n<p>Open <code>hello-world.js</code> in any preferred text editor and\npaste in the following content:</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst hostname = '127.0.0.1';\nconst port = 3000;\n\nconst server = http.createServer((req, res) => {\n  res.statusCode = 200;\n  res.setHeader('Content-Type', 'text/plain');\n  res.end('Hello, World!\\n');\n});\n\nserver.listen(port, hostname, () => {\n  console.log(`Server running at http://${hostname}:${port}/`);\n});\n</code></pre>\n<p>Save the file, go back to the terminal window, and enter the following command:</p>\n<pre><code class=\"language-console\">$ node hello-world.js\n</code></pre>\n<p>Output like this should appear in the terminal:</p>\n<pre><code class=\"language-console\">Server running at http://127.0.0.1:3000/\n</code></pre>\n<p>Now, open any preferred web browser and visit <code>http://127.0.0.1:3000</code>.</p>\n<p>If the browser displays the string <code>Hello, World!</code>, that indicates\nthe server is working.</p>"
+          "desc": "<p><code>node [options] [V8 options] [script.js | -e \"script\" | - ] [arguments]</code></p>\n<p>Please see the <a href=\"cli.html#cli_command_line_options\">Command-line options</a> document for more information.</p>\n<h2>Example</h2>\n<p>An example of a <a href=\"http.html\">web server</a> written with Node.js which responds with\n<code>'Hello, World!'</code>:</p>\n<p>Commands in this document start with <code>$</code> or <code>></code> to replicate how they would\nappear in a user's terminal. Do not include the <code>$</code> and <code>></code> characters. They are\nthere to show the start of each command.</p>\n<p>Lines that don’t start with <code>$</code> or <code>></code> character show the output of the previous\ncommand.</p>\n<p>First, make sure to have downloaded and installed Node.js. See\n<a href=\"https://nodejs.org/en/download/package-manager/\">Installing Node.js via package manager</a> for further install information.</p>\n<p>Now, create an empty project folder called <code>projects</code>, then navigate into it.</p>\n<p>Linux and Mac:</p>\n<pre><code class=\"language-console\">$ mkdir ~/projects\n$ cd ~/projects\n</code></pre>\n<p>Windows CMD:</p>\n<pre><code class=\"language-console\">> mkdir %USERPROFILE%\\projects\n> cd %USERPROFILE%\\projects\n</code></pre>\n<p>Windows PowerShell:</p>\n<pre><code class=\"language-console\">> mkdir $env:USERPROFILE\\projects\n> cd $env:USERPROFILE\\projects\n</code></pre>\n<p>Next, create a new source file in the <code>projects</code>\nfolder and call it <code>hello-world.js</code>.</p>\n<p>Open <code>hello-world.js</code> in any preferred text editor and\npaste in the following content:</p>\n<pre><code class=\"language-js\">const http = require('http');\n\nconst hostname = '127.0.0.1';\nconst port = 3000;\n\nconst server = http.createServer((req, res) => {\n  res.statusCode = 200;\n  res.setHeader('Content-Type', 'text/plain');\n  res.end('Hello, World!\\n');\n});\n\nserver.listen(port, hostname, () => {\n  console.log(`Server running at http://${hostname}:${port}/`);\n});\n</code></pre>\n<p>Save the file, go back to the terminal window, and enter the following command:</p>\n<pre><code class=\"language-console\">$ node hello-world.js\n</code></pre>\n<p>Output like this should appear in the terminal:</p>\n<pre><code class=\"language-console\">Server running at http://127.0.0.1:3000/\n</code></pre>\n<p>Now, open any preferred web browser and visit <code>http://127.0.0.1:3000</code>.</p>\n<p>If the browser displays the string <code>Hello, World!</code>, that indicates\nthe server is working.</p>"
         }
       ],
       "type": "module",
diff --git a/doc/api/synopsis.md b/doc/api/synopsis.md
index 8ae933a499a16c1bdf4f9c0b65d0c21beaf26bdd..cb43312f3587460a1421eb04f11ae56734ab5d4d 100644
--- a/doc/api/synopsis.md
+++ b/doc/api/synopsis.md
@@ -7,7 +7,7 @@
 
 `node [options] [V8 options] [script.js | -e "script" | - ] [arguments]`
 
-Please see the [Command Line Options][] document for more information.
+Please see the [Command-line options][] document for more information.
 
 ## Example
 An example of a [web server][] written with Node.js which responds with
@@ -20,8 +20,8 @@ there to show the start of each command.
 Lines that don’t start with `$` or `>` character show the output of the previous
 command.
 
-First, make sure to have downloaded and installed Node.js. See [this guide][]
-for further install information.
+First, make sure to have downloaded and installed Node.js. See
+[Installing Node.js via package manager][] for further install information.
 
 Now, create an empty project folder called `projects`, then navigate into it.
 
@@ -86,6 +86,6 @@ Now, open any preferred web browser and visit `http://127.0.0.1:3000`.
 If the browser displays the string `Hello, World!`, that indicates
 the server is working.
 
-[Command Line Options]: cli.html#cli_command_line_options
-[this guide]: https://nodejs.org/en/download/package-manager/
-[web server]: http.html
+[Command-line options]: cli.md#cli_command_line_options
+[Installing Node.js via package manager]: https://nodejs.org/en/download/package-manager/
+[web server]: http.md
diff --git a/doc/api/timers.html b/doc/api/timers.html
index 82edc4f2dfbc9e6fa3fbe7788e7f2b57ec83d2d9..1d54d98e8827e942cc5a1e096761dee01520a719 100644
--- a/doc/api/timers.html
+++ b/doc/api/timers.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Timers | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Timers | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="timers" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/timers.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/timers.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/timers.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/timers.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/timers.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/timers.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/timers.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/timers.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/timers.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#timers_timers">Timers</a></span>
 <ul>
 <li><a href="#timers_class_immediate">Class: <code>Immediate</code></a>
@@ -148,8 +161,8 @@
 <li><a href="#timers_scheduling_timers">Scheduling timers</a>
 <ul>
 <li><a href="#timers_setimmediate_callback_args"><code>setImmediate(callback[, ...args])</code></a></li>
-<li><a href="#timers_setinterval_callback_delay_args"><code>setInterval(callback, delay[, ...args])</code></a></li>
-<li><a href="#timers_settimeout_callback_delay_args"><code>setTimeout(callback, delay[, ...args])</code></a></li>
+<li><a href="#timers_setinterval_callback_delay_args"><code>setInterval(callback[, delay[, ...args]])</code></a></li>
+<li><a href="#timers_settimeout_callback_delay_args"><code>setTimeout(callback[, delay[, ...args]])</code></a></li>
 </ul>
 </li>
 <li><a href="#timers_cancelling_timers">Cancelling timers</a>
@@ -161,29 +174,28 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Timers<span><a class="mark" href="#timers_timers" id="timers_timers">#</a></span></h1>
+        <h2>Timers<span><a class="mark" href="#timers_timers" id="timers_timers">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/timers.js">lib/timers.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/timers.js">lib/timers.js</a></p>
 <p>The <code>timer</code> module exposes a global API for scheduling functions to
 be called at some future period of time. Because the timer functions are
 globals, there is no need to call <code>require('timers')</code> to use the API.</p>
 <p>The timer functions within Node.js implement a similar API as the timers API
 provided by Web Browsers but use a different internal implementation that is
 built around the Node.js <a href="https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout">Event Loop</a>.</p>
-<h2>Class: <code>Immediate</code><span><a class="mark" href="#timers_class_immediate" id="timers_class_immediate">#</a></span></h2>
-<p>This object is created internally and is returned from <a href="timers.html#timers_setimmediate_callback_args"><code>setImmediate()</code></a>. It
-can be passed to <a href="timers.html#timers_clearimmediate_immediate"><code>clearImmediate()</code></a> in order to cancel the scheduled
+<section><h3>Class: <code>Immediate</code><span><a class="mark" href="#timers_class_immediate" id="timers_class_immediate">#</a></span></h3>
+<p>This object is created internally and is returned from <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>. It
+can be passed to <a href="#timers_clearimmediate_immediate"><code>clearImmediate()</code></a> in order to cancel the scheduled
 actions.</p>
 <p>By default, when an immediate is scheduled, the Node.js event loop will continue
 running as long as the immediate is active. The <code>Immediate</code> object returned by
-<a href="timers.html#timers_setimmediate_callback_args"><code>setImmediate()</code></a> exports both <code>immediate.ref()</code> and <code>immediate.unref()</code>
+<a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a> exports both <code>immediate.ref()</code> and <code>immediate.unref()</code>
 functions that can be used to control this default behavior.</p>
-<h3><code>immediate.hasRef()</code><span><a class="mark" href="#timers_immediate_hasref" id="timers_immediate_hasref">#</a></span></h3>
+<h4><code>immediate.hasRef()</code><span><a class="mark" href="#timers_immediate_hasref" id="timers_immediate_hasref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
@@ -191,7 +203,7 @@ functions that can be used to control this default behavior.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>If true, the <code>Immediate</code> object will keep the Node.js event loop active.</p>
-<h3><code>immediate.ref()</code><span><a class="mark" href="#timers_immediate_ref" id="timers_immediate_ref">#</a></span></h3>
+<h4><code>immediate.ref()</code><span><a class="mark" href="#timers_immediate_ref" id="timers_immediate_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.7.0</span>
 </div>
@@ -203,7 +215,7 @@ functions that can be used to control this default behavior.</p>
 effect.</p>
 <p>By default, all <code>Immediate</code> objects are "ref'ed", making it normally unnecessary
 to call <code>immediate.ref()</code> unless <code>immediate.unref()</code> had been called previously.</p>
-<h3><code>immediate.unref()</code><span><a class="mark" href="#timers_immediate_unref" id="timers_immediate_unref">#</a></span></h3>
+<h4><code>immediate.unref()</code><span><a class="mark" href="#timers_immediate_unref" id="timers_immediate_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.7.0</span>
 </div>
@@ -214,16 +226,16 @@ to call <code>immediate.ref()</code> unless <code>immediate.unref()</code> had b
 loop to remain active. If there is no other activity keeping the event loop
 running, the process may exit before the <code>Immediate</code> object's callback is
 invoked. Calling <code>immediate.unref()</code> multiple times will have no effect.</p>
-<h2>Class: <code>Timeout</code><span><a class="mark" href="#timers_class_timeout" id="timers_class_timeout">#</a></span></h2>
-<p>This object is created internally and is returned from <a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> and
-<a href="timers.html#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>. It can be passed to either <a href="timers.html#timers_cleartimeout_timeout"><code>clearTimeout()</code></a> or
-<a href="timers.html#timers_clearinterval_timeout"><code>clearInterval()</code></a> in order to cancel the scheduled actions.</p>
-<p>By default, when a timer is scheduled using either <a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> or
-<a href="timers.html#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>, the Node.js event loop will continue running as long as the
+</section><section><h3>Class: <code>Timeout</code><span><a class="mark" href="#timers_class_timeout" id="timers_class_timeout">#</a></span></h3>
+<p>This object is created internally and is returned from <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> and
+<a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>. It can be passed to either <a href="#timers_cleartimeout_timeout"><code>clearTimeout()</code></a> or
+<a href="#timers_clearinterval_timeout"><code>clearInterval()</code></a> in order to cancel the scheduled actions.</p>
+<p>By default, when a timer is scheduled using either <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> or
+<a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>, the Node.js event loop will continue running as long as the
 timer is active. Each of the <code>Timeout</code> objects returned by these functions
 export both <code>timeout.ref()</code> and <code>timeout.unref()</code> functions that can be used to
 control this default behavior.</p>
-<h3><code>timeout.hasRef()</code><span><a class="mark" href="#timers_timeout_hasref" id="timers_timeout_hasref">#</a></span></h3>
+<h4><code>timeout.hasRef()</code><span><a class="mark" href="#timers_timeout_hasref" id="timers_timeout_hasref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
@@ -231,7 +243,7 @@ control this default behavior.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>If true, the <code>Timeout</code> object will keep the Node.js event loop active.</p>
-<h3><code>timeout.ref()</code><span><a class="mark" href="#timers_timeout_ref" id="timers_timeout_ref">#</a></span></h3>
+<h4><code>timeout.ref()</code><span><a class="mark" href="#timers_timeout_ref" id="timers_timeout_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -242,7 +254,7 @@ control this default behavior.</p>
 <code>Timeout</code> is active. Calling <code>timeout.ref()</code> multiple times will have no effect.</p>
 <p>By default, all <code>Timeout</code> objects are "ref'ed", making it normally unnecessary
 to call <code>timeout.ref()</code> unless <code>timeout.unref()</code> had been called previously.</p>
-<h3><code>timeout.refresh()</code><span><a class="mark" href="#timers_timeout_refresh" id="timers_timeout_refresh">#</a></span></h3>
+<h4><code>timeout.refresh()</code><span><a class="mark" href="#timers_timeout_refresh" id="timers_timeout_refresh">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.2.0</span>
 </div>
@@ -255,7 +267,7 @@ time. This is useful for refreshing a timer without allocating a new
 JavaScript object.</p>
 <p>Using this on a timer that has already called its callback will reactivate the
 timer.</p>
-<h3><code>timeout.unref()</code><span><a class="mark" href="#timers_timeout_unref" id="timers_timeout_unref">#</a></span></h3>
+<h4><code>timeout.unref()</code><span><a class="mark" href="#timers_timeout_unref" id="timers_timeout_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -269,9 +281,9 @@ the process may exit before the <code>Timeout</code> object's callback is invoke
 <p>Calling <code>timeout.unref()</code> creates an internal timer that will wake the Node.js
 event loop. Creating too many of these can adversely impact performance
 of the Node.js application.</p>
-<h3><code>timeout[Symbol.toPrimitive]()</code><span><a class="mark" href="#timers_timeout_symbol_toprimitive" id="timers_timeout_symbol_toprimitive">#</a></span></h3>
+<h4><code>timeout[Symbol.toPrimitive]()</code><span><a class="mark" href="#timers_timeout_symbol_toprimitive" id="timers_timeout_symbol_toprimitive">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.9.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> a number that can be used to reference this <code>timeout</code></li>
@@ -282,12 +294,12 @@ same thread where the timeout was created. Therefore, to use it
 across <a href="worker_threads.html"><code>worker_threads</code></a> it must first be passed to the correct
 thread. This allows enhanced compatibility with browser
 <code>setTimeout()</code> and <code>setInterval()</code> implementations.</p>
-<h2>Scheduling timers<span><a class="mark" href="#timers_scheduling_timers" id="timers_scheduling_timers">#</a></span></h2>
+</section><section><h3>Scheduling timers<span><a class="mark" href="#timers_scheduling_timers" id="timers_scheduling_timers">#</a></span></h3>
 <p>A timer in Node.js is an internal construct that calls a given function after
 a certain period of time. When a timer's function is called varies depending on
 which method was used to create the timer and what other work the Node.js
 event loop is doing.</p>
-<h3><code>setImmediate(callback[, ...args])</code><span><a class="mark" href="#timers_setimmediate_callback_args" id="timers_setimmediate_callback_args">#</a></span></h3>
+<h4><code>setImmediate(callback[, ...args])</code><span><a class="mark" href="#timers_setimmediate_callback_args" id="timers_setimmediate_callback_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
@@ -295,7 +307,7 @@ event loop is doing.</p>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to call at the end of this turn of
 the Node.js <a href="https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout">Event Loop</a></li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Optional arguments to pass when the <code>callback</code> is called.</li>
-<li>Returns: <a href="timers.html#timers_class_immediate" class="type">&#x3C;Immediate></a> for use with <a href="timers.html#timers_clearimmediate_immediate"><code>clearImmediate()</code></a></li>
+<li>Returns: <a href="timers.html#timers_class_immediate" class="type">&#x3C;Immediate></a> for use with <a href="#timers_clearimmediate_immediate"><code>clearImmediate()</code></a></li>
 </ul>
 <p>Schedules the "immediate" execution of the <code>callback</code> after I/O events'
 callbacks.</p>
@@ -308,45 +320,45 @@ next event loop iteration.</p>
 <p>This method has a custom variant for promises that is available using
 <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> setImmediatePromise = util.promisify(setImmediate);
+<span class="hljs-keyword">const</span> setImmediatePromise = util.<span class="hljs-title function_">promisify</span>(setImmediate);
 
-setImmediatePromise(<span class="hljs-string">'foobar'</span>).then(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+<span class="hljs-title function_">setImmediatePromise</span>(<span class="hljs-string">'foobar'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
   <span class="hljs-comment">// value === 'foobar' (passing values is optional)</span>
   <span class="hljs-comment">// This is executed after all I/O callbacks.</span>
 });
 
 <span class="hljs-comment">// Or with async function</span>
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">timerExample</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Before I/O callbacks'</span>);
-  <span class="hljs-keyword">await</span> setImmediatePromise();
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'After I/O callbacks'</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">timerExample</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Before I/O callbacks'</span>);
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">setImmediatePromise</span>();
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'After I/O callbacks'</span>);
 }
-timerExample();</code></pre>
-<h3><code>setInterval(callback, delay[, ...args])</code><span><a class="mark" href="#timers_setinterval_callback_delay_args" id="timers_setinterval_callback_delay_args">#</a></span></h3>
+<span class="hljs-title function_">timerExample</span>();</code></pre>
+<h4><code>setInterval(callback[, delay[, ...args]])</code><span><a class="mark" href="#timers_setinterval_callback_delay_args" id="timers_setinterval_callback_delay_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to call when the timer elapses.</li>
 <li><code>delay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of milliseconds to wait before calling the
-<code>callback</code>.</li>
+<code>callback</code>. <strong>Default</strong>: <code>1</code>.</li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Optional arguments to pass when the <code>callback</code> is called.</li>
-<li>Returns: <a href="timers.html#timers_class_timeout" class="type">&#x3C;Timeout></a> for use with <a href="timers.html#timers_clearinterval_timeout"><code>clearInterval()</code></a></li>
+<li>Returns: <a href="timers.html#timers_class_timeout" class="type">&#x3C;Timeout></a> for use with <a href="#timers_clearinterval_timeout"><code>clearInterval()</code></a></li>
 </ul>
 <p>Schedules repeated execution of <code>callback</code> every <code>delay</code> milliseconds.</p>
 <p>When <code>delay</code> is larger than <code>2147483647</code> or less than <code>1</code>, the <code>delay</code> will be
 set to <code>1</code>. Non-integer delays are truncated to an integer.</p>
 <p>If <code>callback</code> is not a function, a <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> will be thrown.</p>
-<h3><code>setTimeout(callback, delay[, ...args])</code><span><a class="mark" href="#timers_settimeout_callback_delay_args" id="timers_settimeout_callback_delay_args">#</a></span></h3>
+<h4><code>setTimeout(callback[, delay[, ...args]])</code><span><a class="mark" href="#timers_settimeout_callback_delay_args" id="timers_settimeout_callback_delay_args">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 <ul>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The function to call when the timer elapses.</li>
 <li><code>delay</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of milliseconds to wait before calling the
-<code>callback</code>.</li>
+<code>callback</code>. <strong>Default</strong>: <code>1</code>.</li>
 <li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Optional arguments to pass when the <code>callback</code> is called.</li>
-<li>Returns: <a href="timers.html#timers_class_timeout" class="type">&#x3C;Timeout></a> for use with <a href="timers.html#timers_cleartimeout_timeout"><code>clearTimeout()</code></a></li>
+<li>Returns: <a href="timers.html#timers_class_timeout" class="type">&#x3C;Timeout></a> for use with <a href="#timers_cleartimeout_timeout"><code>clearTimeout()</code></a></li>
 </ul>
 <p>Schedules execution of a one-time <code>callback</code> after <code>delay</code> milliseconds.</p>
 <p>The <code>callback</code> will likely not be invoked in precisely <code>delay</code> milliseconds.
@@ -359,46 +371,115 @@ will be set to <code>1</code>. Non-integer delays are truncated to an integer.</
 <p>This method has a custom variant for promises that is available using
 <a href="util.html#util_util_promisify_original"><code>util.promisify()</code></a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> setTimeoutPromise = util.promisify(<span class="hljs-built_in">setTimeout</span>);
+<span class="hljs-keyword">const</span> setTimeoutPromise = util.<span class="hljs-title function_">promisify</span>(<span class="hljs-built_in">setTimeout</span>);
 
-setTimeoutPromise(<span class="hljs-number">40</span>, <span class="hljs-string">'foobar'</span>).then(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+setTimeoutPromise(<span class="hljs-number">40</span>, <span class="hljs-string">'foobar'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
   <span class="hljs-comment">// value === 'foobar' (passing values is optional)</span>
   <span class="hljs-comment">// This is executed after about 40 milliseconds.</span>
 });</code></pre>
-<h2>Cancelling timers<span><a class="mark" href="#timers_cancelling_timers" id="timers_cancelling_timers">#</a></span></h2>
-<p>The <a href="timers.html#timers_setimmediate_callback_args"><code>setImmediate()</code></a>, <a href="timers.html#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>, and <a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> methods
+</section><section><h3>Cancelling timers<span><a class="mark" href="#timers_cancelling_timers" id="timers_cancelling_timers">#</a></span></h3>
+<p>The <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>, <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>, and <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a> methods
 each return objects that represent the scheduled timers. These can be used to
 cancel the timer and prevent it from triggering.</p>
-<p>It is not possible to cancel timers that were created using the promisified
-variants of <a href="timers.html#timers_setimmediate_callback_args"><code>setImmediate()</code></a>, <a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>.</p>
-<h3><code>clearImmediate(immediate)</code><span><a class="mark" href="#timers_clearimmediate_immediate" id="timers_clearimmediate_immediate">#</a></span></h3>
+<p>For the promisified variants of <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a> and <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>,
+an <a href="globals.html#globals_class_abortcontroller"><code>AbortController</code></a> may be used to cancel the timer. When canceled, the
+returned Promises will be rejected with an <code>'AbortError'</code>.</p>
+<p>For <code>setImmediate()</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> setImmediatePromise = util.<span class="hljs-title function_">promisify</span>(setImmediate);
+
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> signal = ac.<span class="hljs-property">signal</span>;
+
+<span class="hljs-title function_">setImmediatePromise</span>(<span class="hljs-string">'foobar'</span>, { signal })
+  .<span class="hljs-title function_">then</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>)
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">name</span> === <span class="hljs-string">'AbortError'</span>)
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The immediate was aborted'</span>);
+  });
+
+ac.<span class="hljs-title function_">abort</span>();</code></pre>
+<p>For <code>setTimeout()</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> setTimeoutPromise = util.<span class="hljs-title function_">promisify</span>(<span class="hljs-built_in">setTimeout</span>);
+
+<span class="hljs-keyword">const</span> ac = <span class="hljs-keyword">new</span> <span class="hljs-title class_">AbortController</span>();
+<span class="hljs-keyword">const</span> signal = ac.<span class="hljs-property">signal</span>;
+
+setTimeoutPromise(<span class="hljs-number">1000</span>, <span class="hljs-string">'foobar'</span>, { signal })
+  .<span class="hljs-title function_">then</span>(<span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>)
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-keyword">if</span> (err.<span class="hljs-property">name</span> === <span class="hljs-string">'AbortError'</span>)
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'The timeout was aborted'</span>);
+  });
+
+ac.<span class="hljs-title function_">abort</span>();</code></pre>
+<h4><code>clearImmediate(immediate)</code><span><a class="mark" href="#timers_clearimmediate_immediate" id="timers_clearimmediate_immediate">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.1</span>
 </div>
 <ul>
 <li><code>immediate</code> <a href="timers.html#timers_class_immediate" class="type">&#x3C;Immediate></a> An <code>Immediate</code> object as returned by
-<a href="timers.html#timers_setimmediate_callback_args"><code>setImmediate()</code></a>.</li>
+<a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>.</li>
 </ul>
-<p>Cancels an <code>Immediate</code> object created by <a href="timers.html#timers_setimmediate_callback_args"><code>setImmediate()</code></a>.</p>
-<h3><code>clearInterval(timeout)</code><span><a class="mark" href="#timers_clearinterval_timeout" id="timers_clearinterval_timeout">#</a></span></h3>
+<p>Cancels an <code>Immediate</code> object created by <a href="#timers_setimmediate_callback_args"><code>setImmediate()</code></a>.</p>
+<h4><code>clearInterval(timeout)</code><span><a class="mark" href="#timers_clearinterval_timeout" id="timers_clearinterval_timeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 <ul>
-<li><code>timeout</code> <a href="timers.html#timers_class_timeout" class="type">&#x3C;Timeout></a> A <code>Timeout</code> object as returned by <a href="timers.html#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>.</li>
+<li><code>timeout</code> <a href="timers.html#timers_class_timeout" class="type">&#x3C;Timeout></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A <code>Timeout</code> object as returned by <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>
+or the <a href="#timers_timeout_symbol_toprimitive">primitive</a> of the <code>Timeout</code> object as a string or a number.</li>
 </ul>
-<p>Cancels a <code>Timeout</code> object created by <a href="timers.html#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>.</p>
-<h3><code>clearTimeout(timeout)</code><span><a class="mark" href="#timers_cleartimeout_timeout" id="timers_cleartimeout_timeout">#</a></span></h3>
+<p>Cancels a <code>Timeout</code> object created by <a href="#timers_setinterval_callback_delay_args"><code>setInterval()</code></a>.</p>
+<h4><code>clearTimeout(timeout)</code><span><a class="mark" href="#timers_cleartimeout_timeout" id="timers_cleartimeout_timeout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.0.1</span>
 </div>
 <ul>
-<li><code>timeout</code> <a href="timers.html#timers_class_timeout" class="type">&#x3C;Timeout></a> A <code>Timeout</code> object as returned by <a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>.</li>
+<li><code>timeout</code> <a href="timers.html#timers_class_timeout" class="type">&#x3C;Timeout></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> A <code>Timeout</code> object as returned by <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>
+or the <a href="#timers_timeout_symbol_toprimitive">primitive</a> of the <code>Timeout</code> object as a string or a number.</li>
 </ul>
-<p>Cancels a <code>Timeout</code> object created by <a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>.</p>
+<p>Cancels a <code>Timeout</code> object created by <a href="#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/timers.json b/doc/api/timers.json
index 49f50baef6a760543423956a3525c154caa20dcc..3d5cf89956de2d8c5556ddf9dd453601dc296443 100644
--- a/doc/api/timers.json
+++ b/doc/api/timers.json
@@ -8,13 +8,13 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/timers.js\">lib/timers.js</a></p>\n<p>The <code>timer</code> module exposes a global API for scheduling functions to\nbe called at some future period of time. Because the timer functions are\nglobals, there is no need to call <code>require('timers')</code> to use the API.</p>\n<p>The timer functions within Node.js implement a similar API as the timers API\nprovided by Web Browsers but use a different internal implementation that is\nbuilt around the Node.js <a href=\"https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout\">Event Loop</a>.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/timers.js\">lib/timers.js</a></p>\n<p>The <code>timer</code> module exposes a global API for scheduling functions to\nbe called at some future period of time. Because the timer functions are\nglobals, there is no need to call <code>require('timers')</code> to use the API.</p>\n<p>The timer functions within Node.js implement a similar API as the timers API\nprovided by Web Browsers but use a different internal implementation that is\nbuilt around the Node.js <a href=\"https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout\">Event Loop</a>.</p>",
       "classes": [
         {
           "textRaw": "Class: `Immediate`",
           "type": "class",
           "name": "Immediate",
-          "desc": "<p>This object is created internally and is returned from <a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>. It\ncan be passed to <a href=\"timers.html#timers_clearimmediate_immediate\"><code>clearImmediate()</code></a> in order to cancel the scheduled\nactions.</p>\n<p>By default, when an immediate is scheduled, the Node.js event loop will continue\nrunning as long as the immediate is active. The <code>Immediate</code> object returned by\n<a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a> exports both <code>immediate.ref()</code> and <code>immediate.unref()</code>\nfunctions that can be used to control this default behavior.</p>",
+          "desc": "<p>This object is created internally and is returned from <a href=\"#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>. It\ncan be passed to <a href=\"#timers_clearimmediate_immediate\"><code>clearImmediate()</code></a> in order to cancel the scheduled\nactions.</p>\n<p>By default, when an immediate is scheduled, the Node.js event loop will continue\nrunning as long as the immediate is active. The <code>Immediate</code> object returned by\n<a href=\"#timers_setimmediate_callback_args\"><code>setImmediate()</code></a> exports both <code>immediate.ref()</code> and <code>immediate.unref()</code>\nfunctions that can be used to control this default behavior.</p>",
           "methods": [
             {
               "textRaw": "`immediate.hasRef()`",
@@ -90,7 +90,7 @@
           "textRaw": "Class: `Timeout`",
           "type": "class",
           "name": "Timeout",
-          "desc": "<p>This object is created internally and is returned from <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> and\n<a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>. It can be passed to either <a href=\"timers.html#timers_cleartimeout_timeout\"><code>clearTimeout()</code></a> or\n<a href=\"timers.html#timers_clearinterval_timeout\"><code>clearInterval()</code></a> in order to cancel the scheduled actions.</p>\n<p>By default, when a timer is scheduled using either <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> or\n<a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>, the Node.js event loop will continue running as long as the\ntimer is active. Each of the <code>Timeout</code> objects returned by these functions\nexport both <code>timeout.ref()</code> and <code>timeout.unref()</code> functions that can be used to\ncontrol this default behavior.</p>",
+          "desc": "<p>This object is created internally and is returned from <a href=\"#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> and\n<a href=\"#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>. It can be passed to either <a href=\"#timers_cleartimeout_timeout\"><code>clearTimeout()</code></a> or\n<a href=\"#timers_clearinterval_timeout\"><code>clearInterval()</code></a> in order to cancel the scheduled actions.</p>\n<p>By default, when a timer is scheduled using either <a href=\"#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> or\n<a href=\"#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>, the Node.js event loop will continue running as long as the\ntimer is active. Each of the <code>Timeout</code> objects returned by these functions\nexport both <code>timeout.ref()</code> and <code>timeout.unref()</code> functions that can be used to\ncontrol this default behavior.</p>",
           "methods": [
             {
               "textRaw": "`timeout.hasRef()`",
@@ -189,7 +189,7 @@
               "name": "[Symbol.toPrimitive]",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.9.0"
                 ],
                 "changes": []
               },
@@ -252,7 +252,7 @@
               "desc": "<p>Schedules the \"immediate\" execution of the <code>callback</code> after I/O events'\ncallbacks.</p>\n<p>When multiple calls to <code>setImmediate()</code> are made, the <code>callback</code> functions are\nqueued for execution in the order in which they are created. The entire callback\nqueue is processed every event loop iteration. If an immediate timer is queued\nfrom inside an executing callback, that timer will not be triggered until the\nnext event loop iteration.</p>\n<p>If <code>callback</code> is not a function, a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> will be thrown.</p>\n<p>This method has a custom variant for promises that is available using\n<a href=\"util.html#util_util_promisify_original\"><code>util.promisify()</code></a>:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst setImmediatePromise = util.promisify(setImmediate);\n\nsetImmediatePromise('foobar').then((value) => {\n  // value === 'foobar' (passing values is optional)\n  // This is executed after all I/O callbacks.\n});\n\n// Or with async function\nasync function timerExample() {\n  console.log('Before I/O callbacks');\n  await setImmediatePromise();\n  console.log('After I/O callbacks');\n}\ntimerExample();\n</code></pre>"
             },
             {
-              "textRaw": "`setInterval(callback, delay[, ...args])`",
+              "textRaw": "`setInterval(callback[, delay[, ...args]])`",
               "type": "method",
               "name": "setInterval",
               "meta": {
@@ -277,10 +277,10 @@
                       "desc": "The function to call when the timer elapses."
                     },
                     {
-                      "textRaw": "`delay` {number} The number of milliseconds to wait before calling the `callback`.",
+                      "textRaw": "`delay` {number} The number of milliseconds to wait before calling the `callback`. **Default**: `1`.",
                       "name": "delay",
                       "type": "number",
-                      "desc": "The number of milliseconds to wait before calling the `callback`."
+                      "desc": "The number of milliseconds to wait before calling the `callback`. **Default**: `1`."
                     },
                     {
                       "textRaw": "`...args` {any} Optional arguments to pass when the `callback` is called.",
@@ -294,7 +294,7 @@
               "desc": "<p>Schedules repeated execution of <code>callback</code> every <code>delay</code> milliseconds.</p>\n<p>When <code>delay</code> is larger than <code>2147483647</code> or less than <code>1</code>, the <code>delay</code> will be\nset to <code>1</code>. Non-integer delays are truncated to an integer.</p>\n<p>If <code>callback</code> is not a function, a <a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a> will be thrown.</p>"
             },
             {
-              "textRaw": "`setTimeout(callback, delay[, ...args])`",
+              "textRaw": "`setTimeout(callback[, delay[, ...args]])`",
               "type": "method",
               "name": "setTimeout",
               "meta": {
@@ -319,10 +319,10 @@
                       "desc": "The function to call when the timer elapses."
                     },
                     {
-                      "textRaw": "`delay` {number} The number of milliseconds to wait before calling the `callback`.",
+                      "textRaw": "`delay` {number} The number of milliseconds to wait before calling the `callback`. **Default**: `1`.",
                       "name": "delay",
                       "type": "number",
-                      "desc": "The number of milliseconds to wait before calling the `callback`."
+                      "desc": "The number of milliseconds to wait before calling the `callback`. **Default**: `1`."
                     },
                     {
                       "textRaw": "`...args` {any} Optional arguments to pass when the `callback` is called.",
@@ -342,7 +342,7 @@
         {
           "textRaw": "Cancelling timers",
           "name": "cancelling_timers",
-          "desc": "<p>The <a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>, <a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>, and <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> methods\neach return objects that represent the scheduled timers. These can be used to\ncancel the timer and prevent it from triggering.</p>\n<p>It is not possible to cancel timers that were created using the promisified\nvariants of <a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>, <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a>.</p>",
+          "desc": "<p>The <a href=\"#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>, <a href=\"#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>, and <a href=\"#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a> methods\neach return objects that represent the scheduled timers. These can be used to\ncancel the timer and prevent it from triggering.</p>\n<p>For the promisified variants of <a href=\"#timers_setimmediate_callback_args\"><code>setImmediate()</code></a> and <a href=\"#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a>,\nan <a href=\"globals.html#globals_class_abortcontroller\"><code>AbortController</code></a> may be used to cancel the timer. When canceled, the\nreturned Promises will be rejected with an <code>'AbortError'</code>.</p>\n<p>For <code>setImmediate()</code>:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst setImmediatePromise = util.promisify(setImmediate);\n\nconst ac = new AbortController();\nconst signal = ac.signal;\n\nsetImmediatePromise('foobar', { signal })\n  .then(console.log)\n  .catch((err) => {\n    if (err.name === 'AbortError')\n      console.log('The immediate was aborted');\n  });\n\nac.abort();\n</code></pre>\n<p>For <code>setTimeout()</code>:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst setTimeoutPromise = util.promisify(setTimeout);\n\nconst ac = new AbortController();\nconst signal = ac.signal;\n\nsetTimeoutPromise(1000, 'foobar', { signal })\n  .then(console.log)\n  .catch((err) => {\n    if (err.name === 'AbortError')\n      console.log('The timeout was aborted');\n  });\n\nac.abort();\n</code></pre>",
           "methods": [
             {
               "textRaw": "`clearImmediate(immediate)`",
@@ -366,7 +366,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Cancels an <code>Immediate</code> object created by <a href=\"timers.html#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>.</p>"
+              "desc": "<p>Cancels an <code>Immediate</code> object created by <a href=\"#timers_setimmediate_callback_args\"><code>setImmediate()</code></a>.</p>"
             },
             {
               "textRaw": "`clearInterval(timeout)`",
@@ -382,15 +382,15 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`timeout` {Timeout} A `Timeout` object as returned by [`setInterval()`][].",
+                      "textRaw": "`timeout` {Timeout|string|number} A `Timeout` object as returned by [`setInterval()`][] or the [primitive][] of the `Timeout` object as a string or a number.",
                       "name": "timeout",
-                      "type": "Timeout",
-                      "desc": "A `Timeout` object as returned by [`setInterval()`][]."
+                      "type": "Timeout|string|number",
+                      "desc": "A `Timeout` object as returned by [`setInterval()`][] or the [primitive][] of the `Timeout` object as a string or a number."
                     }
                   ]
                 }
               ],
-              "desc": "<p>Cancels a <code>Timeout</code> object created by <a href=\"timers.html#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>.</p>"
+              "desc": "<p>Cancels a <code>Timeout</code> object created by <a href=\"#timers_setinterval_callback_delay_args\"><code>setInterval()</code></a>.</p>"
             },
             {
               "textRaw": "`clearTimeout(timeout)`",
@@ -406,15 +406,15 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`timeout` {Timeout} A `Timeout` object as returned by [`setTimeout()`][].",
+                      "textRaw": "`timeout` {Timeout|string|number} A `Timeout` object as returned by [`setTimeout()`][] or the [primitive][] of the `Timeout` object as a string or a number.",
                       "name": "timeout",
-                      "type": "Timeout",
-                      "desc": "A `Timeout` object as returned by [`setTimeout()`][]."
+                      "type": "Timeout|string|number",
+                      "desc": "A `Timeout` object as returned by [`setTimeout()`][] or the [primitive][] of the `Timeout` object as a string or a number."
                     }
                   ]
                 }
               ],
-              "desc": "<p>Cancels a <code>Timeout</code> object created by <a href=\"timers.html#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a>.</p>"
+              "desc": "<p>Cancels a <code>Timeout</code> object created by <a href=\"#timers_settimeout_callback_delay_args\"><code>setTimeout()</code></a>.</p>"
             }
           ],
           "type": "module",
diff --git a/doc/api/timers.md b/doc/api/timers.md
index c7bfb2cedb20b4c799dc62e0b23750730ad32353..dbe1938eb4790fdd917b8400a6387d577e08173f 100644
--- a/doc/api/timers.md
+++ b/doc/api/timers.md
@@ -127,7 +127,7 @@ of the Node.js application.
 
 ### `timeout[Symbol.toPrimitive]()`
 <!-- YAML
-added: v12.19.0
+added: v14.9.0
 -->
 
 * Returns: {integer} a number that can be used to reference this `timeout`
@@ -188,14 +188,14 @@ async function timerExample() {
 timerExample();
 ```
 
-### `setInterval(callback, delay[, ...args])`
+### `setInterval(callback[, delay[, ...args]])`
 <!-- YAML
 added: v0.0.1
 -->
 
 * `callback` {Function} The function to call when the timer elapses.
 * `delay` {number} The number of milliseconds to wait before calling the
-  `callback`.
+  `callback`. **Default**: `1`.
 * `...args` {any} Optional arguments to pass when the `callback` is called.
 * Returns: {Timeout} for use with [`clearInterval()`][]
 
@@ -206,14 +206,14 @@ set to `1`. Non-integer delays are truncated to an integer.
 
 If `callback` is not a function, a [`TypeError`][] will be thrown.
 
-### `setTimeout(callback, delay[, ...args])`
+### `setTimeout(callback[, delay[, ...args]])`
 <!-- YAML
 added: v0.0.1
 -->
 
 * `callback` {Function} The function to call when the timer elapses.
 * `delay` {number} The number of milliseconds to wait before calling the
-  `callback`.
+  `callback`. **Default**: `1`.
 * `...args` {any} Optional arguments to pass when the `callback` is called.
 * Returns: {Timeout} for use with [`clearTimeout()`][]
 
@@ -248,8 +248,47 @@ The [`setImmediate()`][], [`setInterval()`][], and [`setTimeout()`][] methods
 each return objects that represent the scheduled timers. These can be used to
 cancel the timer and prevent it from triggering.
 
-It is not possible to cancel timers that were created using the promisified
-variants of [`setImmediate()`][], [`setTimeout()`][].
+For the promisified variants of [`setImmediate()`][] and [`setTimeout()`][],
+an [`AbortController`][] may be used to cancel the timer. When canceled, the
+returned Promises will be rejected with an `'AbortError'`.
+
+For `setImmediate()`:
+
+```js
+const util = require('util');
+const setImmediatePromise = util.promisify(setImmediate);
+
+const ac = new AbortController();
+const signal = ac.signal;
+
+setImmediatePromise('foobar', { signal })
+  .then(console.log)
+  .catch((err) => {
+    if (err.name === 'AbortError')
+      console.log('The immediate was aborted');
+  });
+
+ac.abort();
+```
+
+For `setTimeout()`:
+
+```js
+const util = require('util');
+const setTimeoutPromise = util.promisify(setTimeout);
+
+const ac = new AbortController();
+const signal = ac.signal;
+
+setTimeoutPromise(1000, 'foobar', { signal })
+  .then(console.log)
+  .catch((err) => {
+    if (err.name === 'AbortError')
+      console.log('The timeout was aborted');
+  });
+
+ac.abort();
+```
 
 ### `clearImmediate(immediate)`
 <!-- YAML
@@ -266,7 +305,8 @@ Cancels an `Immediate` object created by [`setImmediate()`][].
 added: v0.0.1
 -->
 
-* `timeout` {Timeout} A `Timeout` object as returned by [`setInterval()`][].
+* `timeout` {Timeout|string|number} A `Timeout` object as returned by [`setInterval()`][]
+  or the [primitive][] of the `Timeout` object as a string or a number.
 
 Cancels a `Timeout` object created by [`setInterval()`][].
 
@@ -275,17 +315,20 @@ Cancels a `Timeout` object created by [`setInterval()`][].
 added: v0.0.1
 -->
 
-* `timeout` {Timeout} A `Timeout` object as returned by [`setTimeout()`][].
+* `timeout` {Timeout|string|number} A `Timeout` object as returned by [`setTimeout()`][]
+  or the [primitive][] of the `Timeout` object as a string or a number.
 
 Cancels a `Timeout` object created by [`setTimeout()`][].
 
 [Event Loop]: https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout
-[`TypeError`]: errors.html#errors_class_typeerror
-[`clearImmediate()`]: timers.html#timers_clearimmediate_immediate
-[`clearInterval()`]: timers.html#timers_clearinterval_timeout
-[`clearTimeout()`]: timers.html#timers_cleartimeout_timeout
-[`setImmediate()`]: timers.html#timers_setimmediate_callback_args
-[`setInterval()`]: timers.html#timers_setinterval_callback_delay_args
-[`setTimeout()`]: timers.html#timers_settimeout_callback_delay_args
-[`util.promisify()`]: util.html#util_util_promisify_original
-[`worker_threads`]: worker_threads.html
+[`AbortController`]: globals.md#globals_class_abortcontroller
+[`TypeError`]: errors.md#errors_class_typeerror
+[`clearImmediate()`]: #timers_clearimmediate_immediate
+[`clearInterval()`]: #timers_clearinterval_timeout
+[`clearTimeout()`]: #timers_cleartimeout_timeout
+[`setImmediate()`]: #timers_setimmediate_callback_args
+[`setInterval()`]: #timers_setinterval_callback_delay_args
+[`setTimeout()`]: #timers_settimeout_callback_delay_args
+[`util.promisify()`]: util.md#util_util_promisify_original
+[`worker_threads`]: worker_threads.md
+[primitive]: #timers_timeout_symbol_toprimitive
diff --git a/doc/api/tls.html b/doc/api/tls.html
index 3352477e5127da7bc940413997cffbb113075a9a..1e11411c9ec755b740e79bc294edf33fe4afb72b 100644
--- a/doc/api/tls.html
+++ b/doc/api/tls.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>TLS (SSL) | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>TLS (SSL) | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="tls" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/tls.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/tls.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/tls.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/tls.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/tls.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/tls.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/tls.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/tls.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/tls.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#tls_tls_ssl">TLS (SSL)</a></span>
 <ul>
 <li><a href="#tls_tls_ssl_concepts">TLS/SSL concepts</a>
@@ -225,19 +238,18 @@
 <li><a href="#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>TLS (SSL)<span><a class="mark" href="#tls_tls_ssl" id="tls_tls_ssl">#</a></span></h1>
+        <h2>TLS (SSL)<span><a class="mark" href="#tls_tls_ssl" id="tls_tls_ssl">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/tls.js">lib/tls.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/tls.js">lib/tls.js</a></p>
 <p>The <code>tls</code> module provides an implementation of the Transport Layer Security
 (TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.
 The module can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> tls = <span class="hljs-built_in">require</span>(<span class="hljs-string">'tls'</span>);</code></pre>
-<h2>TLS/SSL concepts<span><a class="mark" href="#tls_tls_ssl_concepts" id="tls_tls_ssl_concepts">#</a></span></h2>
+<section><h3>TLS/SSL concepts<span><a class="mark" href="#tls_tls_ssl_concepts" id="tls_tls_ssl_concepts">#</a></span></h3>
 <p>The TLS/SSL is a public/private key infrastructure (PKI). For most common
 cases, each client and server must have a <em>private key</em>.</p>
 <p>Private keys can be generated in multiple ways. The example below illustrates
@@ -269,7 +281,7 @@ is illustrated in the example below:</p>
 <li><code>certfile</code>: is a concatenation of all Certificate Authority (CA) certs into
 a single file, e.g. <code>cat ca1-cert.pem ca2-cert.pem > ca-cert.pem</code></li>
 </ul>
-<h3>Perfect forward secrecy<span><a class="mark" href="#tls_perfect_forward_secrecy" id="tls_perfect_forward_secrecy">#</a></span></h3>
+<h4>Perfect forward secrecy<span><a class="mark" href="#tls_perfect_forward_secrecy" id="tls_perfect_forward_secrecy">#</a></span></h4>
 
 <p>The term <em><a href="https://en.wikipedia.org/wiki/Perfect_forward_secrecy">forward secrecy</a></em> or <em>perfect forward secrecy</em> describes a feature
 of key-agreement (i.e., key-exchange) methods. That is, the server and client
@@ -301,7 +313,7 @@ can be used when creating a TLS Server to specify the list of names of supported
 curves to use, see <a href="#tls_tls_createserver_options_secureconnectionlistener"><code>tls.createServer()</code></a> for more info.</p>
 <p>Perfect forward secrecy was optional up to TLSv1.2, but it is not optional for
 TLSv1.3, because all TLSv1.3 cipher suites use ECDHE.</p>
-<h3>ALPN and SNI<span><a class="mark" href="#tls_alpn_and_sni" id="tls_alpn_and_sni">#</a></span></h3>
+<h4>ALPN and SNI<span><a class="mark" href="#tls_alpn_and_sni" id="tls_alpn_and_sni">#</a></span></h4>
 
 <p>ALPN (Application-Layer Protocol Negotiation Extension) and
 SNI (Server Name Indication) are TLS handshake extensions:</p>
@@ -310,7 +322,7 @@ SNI (Server Name Indication) are TLS handshake extensions:</p>
 <li>SNI: Allows the use of one TLS server for multiple hostnames with different
 SSL certificates.</li>
 </ul>
-<h3>Pre-shared keys<span><a class="mark" href="#tls_pre_shared_keys" id="tls_pre_shared_keys">#</a></span></h3>
+<h4>Pre-shared keys<span><a class="mark" href="#tls_pre_shared_keys" id="tls_pre_shared_keys">#</a></span></h4>
 
 <p>TLS-PSK support is available as an alternative to normal certificate-based
 authentication. It uses a pre-shared key instead of certificates to
@@ -337,7 +349,7 @@ PSKs up to 64 bytes in length must be supported. As of OpenSSL 1.1.0
 maximum identity size is 128 bytes, and maximum PSK length is 256 bytes.</p>
 <p>The current implementation doesn't support asynchronous PSK callbacks due to the
 limitations of the underlying OpenSSL API.</p>
-<h3>Client-initiated renegotiation attack mitigation<span><a class="mark" href="#tls_client_initiated_renegotiation_attack_mitigation" id="tls_client_initiated_renegotiation_attack_mitigation">#</a></span></h3>
+<h4>Client-initiated renegotiation attack mitigation<span><a class="mark" href="#tls_client_initiated_renegotiation_attack_mitigation" id="tls_client_initiated_renegotiation_attack_mitigation">#</a></span></h4>
 
 <p>The TLS protocol allows clients to renegotiate certain aspects of the TLS
 session. Unfortunately, session renegotiation requires a disproportionate amount
@@ -355,11 +367,11 @@ in seconds. <strong>Default:</strong> <code>600</code> (10 minutes).</li>
 <p>The default renegotiation limits should not be modified without a full
 understanding of the implications and risks.</p>
 <p>TLSv1.3 does not support renegotiation.</p>
-<h3>Session resumption<span><a class="mark" href="#tls_session_resumption" id="tls_session_resumption">#</a></span></h3>
+<h4>Session resumption<span><a class="mark" href="#tls_session_resumption" id="tls_session_resumption">#</a></span></h4>
 <p>Establishing a TLS session can be relatively slow. The process can be sped
 up by saving and later reusing the session state. There are several mechanisms
 to do so, discussed here from oldest to newest (and preferred).</p>
-<h4>Session identifiers<span><a class="mark" href="#tls_session_identifiers" id="tls_session_identifiers">#</a></span></h4>
+<h5>Session identifiers<span><a class="mark" href="#tls_session_identifiers" id="tls_session_identifiers">#</a></span></h5>
 <p>Servers generate a unique ID for new connections and
 send it to the client. Clients and servers save the session state. When
 reconnecting, clients send the ID of their saved session state and if the server
@@ -376,7 +388,7 @@ to save and restore the session data using the session ID as the lookup key to
 reuse sessions. To reuse sessions across load balancers or cluster workers,
 servers must use a shared session cache (such as Redis) in their session
 handlers.</p>
-<h4>Session tickets<span><a class="mark" href="#tls_session_tickets" id="tls_session_tickets">#</a></span></h4>
+<h5>Session tickets<span><a class="mark" href="#tls_session_tickets" id="tls_session_tickets">#</a></span></h5>
 <p>The servers encrypt the entire session state and send it
 to the client as a "ticket". When reconnecting, the state is sent to the server
 in the initial connection. This mechanism avoids the need for server-side
@@ -402,8 +414,8 @@ securely generate 48 bytes of secure random data and set them with the
 <code>ticketKeys</code> option of <a href="#tls_tls_createserver_options_secureconnectionlistener"><code>tls.createServer()</code></a>. The keys should be regularly
 regenerated and server's keys can be reset with
 <a href="#tls_server_setticketkeys_keys"><code>server.setTicketKeys()</code></a>.</p>
-<p>Session ticket keys are cryptographic keys, and they <strong><em>must be stored
-securely</em></strong>. With TLS 1.2 and below, if they are compromised all sessions that
+<p>Session ticket keys are cryptographic keys, and they <em><strong>must be stored
+securely</strong></em>. With TLS 1.2 and below, if they are compromised all sessions that
 used tickets encrypted with them can be decrypted. They should not be stored
 on disk, and they should be regenerated regularly.</p>
 <p>If clients advertise support for tickets, the server will send them. The
@@ -417,13 +429,13 @@ Since failing to resume the session does not cause TLS/HTTPS connection
 failures, it is easy to not notice unnecessarily poor TLS performance. The
 OpenSSL CLI can be used to verify that servers are resuming sessions. Use the
 <code>-reconnect</code> option to <code>openssl s_client</code>, for example:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> openssl s_client -connect localhost:443 -reconnect</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">openssl s_client -connect localhost:443 -reconnect</span></code></pre>
 <p>Read through the debug output. The first connection should say "New", for
 example:</p>
 <pre><code class="language-text">New, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256</code></pre>
 <p>Subsequent connections should say "Reused", for example:</p>
 <pre><code class="language-text">Reused, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256</code></pre>
-<h2>Modifying the default TLS cipher suite<span><a class="mark" href="#tls_modifying_the_default_tls_cipher_suite" id="tls_modifying_the_default_tls_cipher_suite">#</a></span></h2>
+</section><section><h3>Modifying the default TLS cipher suite<span><a class="mark" href="#tls_modifying_the_default_tls_cipher_suite" id="tls_modifying_the_default_tls_cipher_suite">#</a></span></h3>
 <p>Node.js is built with a default suite of enabled and disabled TLS ciphers. This
 default cipher list can be configured when building Node.js to allow
 distributions to provide their own default list.</p>
@@ -453,10 +465,10 @@ HIGH
 !PSK
 !SRP
 !CAMELLIA</code></pre>
-<p>This default can be replaced entirely using the <a href="cli.html#cli_tls_cipher_list_list"><code>--tls-cipher-list</code></a> command
-line switch (directly, or via the <a href="cli.html#cli_node_options_options"><code>NODE_OPTIONS</code></a> environment variable). For
-instance, the following makes <code>ECDHE-RSA-AES128-GCM-SHA256:!RC4</code> the default TLS
-cipher suite:</p>
+<p>This default can be replaced entirely using the <a href="cli.html#cli_tls_cipher_list_list"><code>--tls-cipher-list</code></a>
+command-line switch (directly, or via the <a href="cli.html#cli_node_options_options"><code>NODE_OPTIONS</code></a> environment
+variable). For instance, the following makes <code>ECDHE-RSA-AES128-GCM-SHA256:!RC4</code>
+the default TLS cipher suite:</p>
 <pre><code class="language-bash">node --tls-cipher-list=<span class="hljs-string">'ECDHE-RSA-AES128-GCM-SHA256:!RC4'</span> server.js
 
 <span class="hljs-built_in">export</span> NODE_OPTIONS=--tls-cipher-list=<span class="hljs-string">'ECDHE-RSA-AES128-GCM-SHA256:!RC4'</span>
@@ -503,27 +515,27 @@ on the format, see the OpenSSL <a href="https://www.openssl.org/docs/man1.1.1/ma
 <p>The first 3 are enabled by default. The last 2 <code>CCM</code>-based suites are supported
 by TLSv1.3 because they may be more performant on constrained systems, but they
 are not enabled by default since they offer less security.</p>
-<h2>Class: <code>tls.CryptoStream</code><span><a class="mark" href="#tls_class_tls_cryptostream" id="tls_class_tls_cryptostream">#</a></span></h2>
+</section><section><h3>Class: <code>tls.CryptoStream</code><span><a class="mark" href="#tls_class_tls_cryptostream" id="tls_class_tls_cryptostream">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span><span>Deprecated since: v0.11.3</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> instead.</div><p></p>
 <p>The <code>tls.CryptoStream</code> class represents a stream of encrypted data. This class
 is deprecated and should no longer be used.</p>
-<h3><code>cryptoStream.bytesWritten</code><span><a class="mark" href="#tls_cryptostream_byteswritten" id="tls_cryptostream_byteswritten">#</a></span></h3>
+<h4><code>cryptoStream.bytesWritten</code><span><a class="mark" href="#tls_cryptostream_byteswritten" id="tls_cryptostream_byteswritten">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.4</span><span>Deprecated since: v0.11.3</span>
 </div>
 <p>The <code>cryptoStream.bytesWritten</code> property returns the total number of bytes
 written to the underlying socket <em>including</em> the bytes required for the
 implementation of the TLS protocol.</p>
-<h2>Class: <code>tls.SecurePair</code><span><a class="mark" href="#tls_class_tls_securepair" id="tls_class_tls_securepair">#</a></span></h2>
+</section><section><h3>Class: <code>tls.SecurePair</code><span><a class="mark" href="#tls_class_tls_securepair" id="tls_class_tls_securepair">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span><span>Deprecated since: v0.11.3</span>
 </div>
 <p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a> instead.</div><p></p>
 <p>Returned by <a href="#tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options"><code>tls.createSecurePair()</code></a>.</p>
-<h3>Event: <code>'secure'</code><span><a class="mark" href="#tls_event_secure" id="tls_event_secure">#</a></span></h3>
+<h4>Event: <code>'secure'</code><span><a class="mark" href="#tls_event_secure" id="tls_event_secure">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span><span>Deprecated since: v0.11.3</span>
 </div>
@@ -533,7 +545,7 @@ connection has been established.</p>
 <a href="#tls_event_secureconnection"><code>'secureConnection'</code></a>
 event, <code>pair.cleartext.authorized</code> should be inspected to confirm whether the
 certificate used is properly authorized.</p>
-<h2>Class: <code>tls.Server</code><span><a class="mark" href="#tls_class_tls_server" id="tls_class_tls_server">#</a></span></h2>
+</section><section><h3>Class: <code>tls.Server</code><span><a class="mark" href="#tls_class_tls_server" id="tls_class_tls_server">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -541,7 +553,7 @@ certificate used is properly authorized.</p>
 <li>Extends: <a href="net.html#net_class_net_server" class="type">&#x3C;net.Server></a></li>
 </ul>
 <p>Accepts encrypted connections using TLS or SSL.</p>
-<h3>Event: <code>'connection'</code><span><a class="mark" href="#tls_event_connection" id="tls_event_connection">#</a></span></h3>
+<h4>Event: <code>'connection'</code><span><a class="mark" href="#tls_event_connection" id="tls_event_connection">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -553,9 +565,9 @@ handshake begins. <code>socket</code> is typically an object of type <a href="ne
 Usually users will not want to access this event.</p>
 <p>This event can also be explicitly emitted by users to inject connections
 into the TLS server. In that case, any <a href="stream.html#stream_class_stream_duplex"><code>Duplex</code></a> stream can be passed.</p>
-<h3>Event: <code>'keylog'</code><span><a class="mark" href="#tls_event_keylog" id="tls_event_keylog">#</a></span></h3>
+<h4>Event: <code>'keylog'</code><span><a class="mark" href="#tls_event_keylog" id="tls_event_keylog">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.3.0</span>
+<span>Added in: v12.3.0, v10.20.0</span>
 </div>
 <ul>
 <li><code>line</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> Line of ASCII text, in NSS <code>SSLKEYLOGFILE</code> format.</li>
@@ -569,14 +581,14 @@ captured TLS traffic to be decrypted. It may be emitted multiple times for
 each socket.</p>
 <p>A typical use case is to append received lines to a common text file, which
 is later used by software (such as Wireshark) to decrypt the traffic:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> logFile = fs.createWriteStream(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, { <span class="hljs-attr">flags</span>: <span class="hljs-string">'a'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> logFile = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, { <span class="hljs-attr">flags</span>: <span class="hljs-string">'a'</span> });
 <span class="hljs-comment">// ...</span>
-server.on(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line, tlsSocket</span>) =></span> {
-  <span class="hljs-keyword">if</span> (tlsSocket.remoteAddress !== <span class="hljs-string">'...'</span>)
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line, tlsSocket</span>) =></span> {
+  <span class="hljs-keyword">if</span> (tlsSocket.<span class="hljs-property">remoteAddress</span> !== <span class="hljs-string">'...'</span>)
     <span class="hljs-keyword">return</span>; <span class="hljs-comment">// Only log keys for a particular IP</span>
-  logFile.write(line);
+  logFile.<span class="hljs-title function_">write</span>(line);
 });</code></pre>
-<h3>Event: <code>'newSession'</code><span><a class="mark" href="#tls_event_newsession" id="tls_event_newsession">#</a></span></h3>
+<h4>Event: <code>'newSession'</code><span><a class="mark" href="#tls_event_newsession" id="tls_event_newsession">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -600,7 +612,7 @@ invoked in order for data to be sent or received over the secure connection.</li
 </ul>
 <p>Listening for this event will have an effect only on connections established
 after the addition of the event listener.</p>
-<h3>Event: <code>'OCSPRequest'</code><span><a class="mark" href="#tls_event_ocsprequest" id="tls_event_ocsprequest">#</a></span></h3>
+<h4>Event: <code>'OCSPRequest'</code><span><a class="mark" href="#tls_event_ocsprequest" id="tls_event_ocsprequest">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.13</span>
 </div>
@@ -640,7 +652,7 @@ via the <code>ca</code> option when establishing the TLS connection.)</p>
 <p>Listening for this event will have an effect only on connections established
 after the addition of the event listener.</p>
 <p>An npm module like <a href="https://www.npmjs.com/package/asn1.js">asn1.js</a> may be used to parse the certificates.</p>
-<h3>Event: <code>'resumeSession'</code><span><a class="mark" href="#tls_event_resumesession" id="tls_event_resumesession">#</a></span></h3>
+<h4>Event: <code>'resumeSession'</code><span><a class="mark" href="#tls_event_resumesession" id="tls_event_resumesession">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.2</span>
 </div>
@@ -668,14 +680,14 @@ connection and destroy the socket.</p>
 after the addition of the event listener.</p>
 <p>The following illustrates resuming a TLS session:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> tlsSessionStore = {};
-server.on(<span class="hljs-string">'newSession'</span>, <span class="hljs-function">(<span class="hljs-params">id, data, cb</span>) =></span> {
-  tlsSessionStore[id.toString(<span class="hljs-string">'hex'</span>)] = data;
-  cb();
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'newSession'</span>, <span class="hljs-function">(<span class="hljs-params">id, data, cb</span>) =></span> {
+  tlsSessionStore[id.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>)] = data;
+  <span class="hljs-title function_">cb</span>();
 });
-server.on(<span class="hljs-string">'resumeSession'</span>, <span class="hljs-function">(<span class="hljs-params">id, cb</span>) =></span> {
-  cb(<span class="hljs-literal">null</span>, tlsSessionStore[id.toString(<span class="hljs-string">'hex'</span>)] || <span class="hljs-literal">null</span>);
+server.<span class="hljs-title function_">on</span>(<span class="hljs-string">'resumeSession'</span>, <span class="hljs-function">(<span class="hljs-params">id, cb</span>) =></span> {
+  <span class="hljs-title function_">cb</span>(<span class="hljs-literal">null</span>, tlsSessionStore[id.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'hex'</span>)] || <span class="hljs-literal">null</span>);
 });</code></pre>
-<h3>Event: <code>'secureConnection'</code><span><a class="mark" href="#tls_event_secureconnection" id="tls_event_secureconnection">#</a></span></h3>
+<h4>Event: <code>'secureConnection'</code><span><a class="mark" href="#tls_event_secureconnection" id="tls_event_secureconnection">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -695,7 +707,7 @@ ALPN protocol. When ALPN has no selected protocol, <code>tlsSocket.alpnProtocol<
 equals <code>false</code>.</p>
 <p>The <code>tlsSocket.servername</code> property is a string containing the server name
 requested via SNI.</p>
-<h3>Event: <code>'tlsClientError'</code><span><a class="mark" href="#tls_event_tlsclienterror" id="tls_event_tlsclienterror">#</a></span></h3>
+<h4>Event: <code>'tlsClientError'</code><span><a class="mark" href="#tls_event_tlsclienterror" id="tls_event_tlsclienterror">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.0.0</span>
 </div>
@@ -707,7 +719,7 @@ called:</p>
 <li><code>tlsSocket</code> <a href="tls.html#tls_class_tls_tlssocket" class="type">&#x3C;tls.TLSSocket></a> The <code>tls.TLSSocket</code> instance from which the
 error originated.</li>
 </ul>
-<h3><code>server.addContext(hostname, context)</code><span><a class="mark" href="#tls_server_addcontext_hostname_context" id="tls_server_addcontext_hostname_context">#</a></span></h3>
+<h4><code>server.addContext(hostname, context)</code><span><a class="mark" href="#tls_server_addcontext_hostname_context" id="tls_server_addcontext_hostname_context">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.3</span>
 </div>
@@ -719,7 +731,7 @@ from the <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureCo
 </ul>
 <p>The <code>server.addContext()</code> method adds a secure context that will be used if
 the client request's SNI name matches the supplied <code>hostname</code> (or wildcard).</p>
-<h3><code>server.address()</code><span><a class="mark" href="#tls_server_address" id="tls_server_address">#</a></span></h3>
+<h4><code>server.address()</code><span><a class="mark" href="#tls_server_address" id="tls_server_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span>
 </div>
@@ -729,7 +741,7 @@ the client request's SNI name matches the supplied <code>hostname</code> (or wil
 <p>Returns the bound address, the address family name, and port of the
 server as reported by the operating system. See <a href="net.html#net_server_address"><code>net.Server.address()</code></a> for
 more information.</p>
-<h3><code>server.close([callback])</code><span><a class="mark" href="#tls_server_close_callback" id="tls_server_close_callback">#</a></span></h3>
+<h4><code>server.close([callback])</code><span><a class="mark" href="#tls_server_close_callback" id="tls_server_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span>
 </div>
@@ -741,7 +753,7 @@ for the server instance's <code>'close'</code> event.</li>
 <p>The <code>server.close()</code> method stops the server from accepting new connections.</p>
 <p>This function operates asynchronously. The <code>'close'</code> event will be emitted
 when the server has no more open connections.</p>
-<h3><code>server.connections</code><span><a class="mark" href="#tls_server_connections" id="tls_server_connections">#</a></span></h3>
+<h4><code>server.connections</code><span><a class="mark" href="#tls_server_connections" id="tls_server_connections">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.2</span><span>Deprecated since: v0.9.7</span>
 </div>
@@ -750,7 +762,7 @@ when the server has no more open connections.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Returns the current number of concurrent connections on the server.</p>
-<h3><code>server.getTicketKeys()</code><span><a class="mark" href="#tls_server_getticketkeys" id="tls_server_getticketkeys">#</a></span></h3>
+<h4><code>server.getTicketKeys()</code><span><a class="mark" href="#tls_server_getticketkeys" id="tls_server_getticketkeys">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
@@ -759,10 +771,10 @@ when the server has no more open connections.</p>
 </ul>
 <p>Returns the session ticket keys.</p>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
-<h3><code>server.listen()</code><span><a class="mark" href="#tls_server_listen" id="tls_server_listen">#</a></span></h3>
+<h4><code>server.listen()</code><span><a class="mark" href="#tls_server_listen" id="tls_server_listen">#</a></span></h4>
 <p>Starts the server listening for encrypted connections.
 This method is identical to <a href="net.html#net_server_listen"><code>server.listen()</code></a> from <a href="net.html#net_class_net_server"><code>net.Server</code></a>.</p>
-<h3><code>server.setSecureContext(options)</code><span><a class="mark" href="#tls_server_setsecurecontext_options" id="tls_server_setsecurecontext_options">#</a></span></h3>
+<h4><code>server.setSecureContext(options)</code><span><a class="mark" href="#tls_server_setsecurecontext_options" id="tls_server_setsecurecontext_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.0.0</span>
 </div>
@@ -773,18 +785,19 @@ the <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext
 </ul>
 <p>The <code>server.setSecureContext()</code> method replaces the secure context of an
 existing server. Existing connections to the server are not interrupted.</p>
-<h3><code>server.setTicketKeys(keys)</code><span><a class="mark" href="#tls_server_setticketkeys_keys" id="tls_server_setticketkeys_keys">#</a></span></h3>
+<h4><code>server.setTicketKeys(keys)</code><span><a class="mark" href="#tls_server_setticketkeys_keys" id="tls_server_setticketkeys_keys">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v3.0.0</span>
 </div>
 <ul>
-<li><code>keys</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> A 48-byte buffer containing the session ticket keys.</li>
+<li><code>keys</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A 48-byte buffer containing the session
+ticket keys.</li>
 </ul>
 <p>Sets the session ticket keys.</p>
 <p>Changes to the ticket keys are effective only for future server connections.
 Existing or currently pending server connections will use the previous keys.</p>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
-<h2>Class: <code>tls.TLSSocket</code><span><a class="mark" href="#tls_class_tls_tlssocket" id="tls_class_tls_tlssocket">#</a></span></h2>
+</section><section><h3>Class: <code>tls.TLSSocket</code><span><a class="mark" href="#tls_class_tls_tlssocket" id="tls_class_tls_tlssocket">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -797,7 +810,7 @@ negotiation.</p>
 <p>Methods that return TLS connection metadata (e.g.
 <a href="#tls_tlssocket_getpeercertificate_detailed"><code>tls.TLSSocket.getPeerCertificate()</code></a> will only return data while the
 connection is open.</p>
-<h3><code>new tls.TLSSocket(socket[, options])</code><span><a class="mark" href="#tls_new_tls_tlssocket_socket_options" id="tls_new_tls_tlssocket_socket_options">#</a></span></h3>
+<h4><code>new tls.TLSSocket(socket[, options])</code><span><a class="mark" href="#tls_new_tls_tlssocket_socket_options" id="tls_new_tls_tlssocket_socket_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -844,9 +857,9 @@ will be created by passing the entire <code>options</code> object to
 </li>
 </ul>
 <p>Construct a new <code>tls.TLSSocket</code> object from an existing TCP socket.</p>
-<h3>Event: <code>'keylog'</code><span><a class="mark" href="#tls_event_keylog_1" id="tls_event_keylog_1">#</a></span></h3>
+<h4>Event: <code>'keylog'</code><span><a class="mark" href="#tls_event_keylog_1" id="tls_event_keylog_1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.3.0</span>
+<span>Added in: v12.3.0, v10.20.0</span>
 </div>
 <ul>
 <li><code>line</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> Line of ASCII text, in NSS <code>SSLKEYLOGFILE</code> format.</li>
@@ -857,10 +870,10 @@ for debugging, as it allows captured TLS traffic to be decrypted. It may
 be emitted multiple times, before or after the handshake completes.</p>
 <p>A typical use case is to append received lines to a common text file, which
 is later used by software (such as Wireshark) to decrypt the traffic:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> logFile = fs.createWriteStream(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, { <span class="hljs-attr">flags</span>: <span class="hljs-string">'a'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> logFile = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'/tmp/ssl-keys.log'</span>, { <span class="hljs-attr">flags</span>: <span class="hljs-string">'a'</span> });
 <span class="hljs-comment">// ...</span>
-tlsSocket.on(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> logFile.write(line));</code></pre>
-<h3>Event: <code>'OCSPResponse'</code><span><a class="mark" href="#tls_event_ocspresponse" id="tls_event_ocspresponse">#</a></span></h3>
+tlsSocket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'keylog'</span>, <span class="hljs-function">(<span class="hljs-params">line</span>) =></span> logFile.<span class="hljs-title function_">write</span>(line));</code></pre>
+<h4>Event: <code>'OCSPResponse'</code><span><a class="mark" href="#tls_event_ocspresponse" id="tls_event_ocspresponse">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.13</span>
 </div>
@@ -872,7 +885,7 @@ The listener callback is passed a single argument when called:</p>
 </ul>
 <p>Typically, the <code>response</code> is a digitally signed object from the server's CA that
 contains information about server's certificate revocation status.</p>
-<h3>Event: <code>'secureConnect'</code><span><a class="mark" href="#tls_event_secureconnect" id="tls_event_secureconnect">#</a></span></h3>
+<h4>Event: <code>'secureConnect'</code><span><a class="mark" href="#tls_event_secureconnect" id="tls_event_secureconnect">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -885,7 +898,9 @@ determine if the server certificate was signed by one of the specified CAs. If
 <code>tlsSocket.authorizationError</code> property. If ALPN was used, the
 <code>tlsSocket.alpnProtocol</code> property can be checked to determine the negotiated
 protocol.</p>
-<h3>Event: <code>'session'</code><span><a class="mark" href="#tls_event_session" id="tls_event_session">#</a></span></h3>
+<p>The <code>'secureConnect'</code> event is not emitted when a <a href="tls.html#tls_class_tls_tlssocket" class="type">&#x3C;tls.TLSSocket></a> is created
+using the <code>new tls.TLSSocket()</code> constructor.</p>
+<h4>Event: <code>'session'</code><span><a class="mark" href="#tls_event_session" id="tls_event_session">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.10.0</span>
 </div>
@@ -910,14 +925,14 @@ after the handshake completes. So it is necessary to wait for the
 should use the <code>'session'</code> event instead of <code>getSession()</code> to ensure
 they will work for all TLS versions. Applications that only expect to
 get or use one session should listen for this event only once:</p>
-<pre><code class="language-js">tlsSocket.once(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
+<pre><code class="language-js">tlsSocket.<span class="hljs-title function_">once</span>(<span class="hljs-string">'session'</span>, <span class="hljs-function">(<span class="hljs-params">session</span>) =></span> {
   <span class="hljs-comment">// The session can be used immediately or later.</span>
-  tls.connect({
+  tls.<span class="hljs-title function_">connect</span>({
     <span class="hljs-attr">session</span>: session,
     <span class="hljs-comment">// Other connect options...</span>
   });
 });</code></pre>
-<h3><code>tlsSocket.address()</code><span><a class="mark" href="#tls_tlssocket_address" id="tls_tlssocket_address">#</a></span></h3>
+<h4><code>tlsSocket.address()</code><span><a class="mark" href="#tls_tlssocket_address" id="tls_tlssocket_address">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -927,13 +942,13 @@ get or use one session should listen for this event only once:</p>
 <p>Returns the bound <code>address</code>, the address <code>family</code> name, and <code>port</code> of the
 underlying socket as reported by the operating system:
 <code>{ port: 12346, family: 'IPv4', address: '127.0.0.1' }</code>.</p>
-<h3><code>tlsSocket.authorizationError</code><span><a class="mark" href="#tls_tlssocket_authorizationerror" id="tls_tlssocket_authorizationerror">#</a></span></h3>
+<h4><code>tlsSocket.authorizationError</code><span><a class="mark" href="#tls_tlssocket_authorizationerror" id="tls_tlssocket_authorizationerror">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
 <p>Returns the reason why the peer's certificate was not been verified. This
 property is set only when <code>tlsSocket.authorized === false</code>.</p>
-<h3><code>tlsSocket.authorized</code><span><a class="mark" href="#tls_tlssocket_authorized" id="tls_tlssocket_authorized">#</a></span></h3>
+<h4><code>tlsSocket.authorized</code><span><a class="mark" href="#tls_tlssocket_authorized" id="tls_tlssocket_authorized">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -942,13 +957,13 @@ property is set only when <code>tlsSocket.authorized === false</code>.</p>
 </ul>
 <p>Returns <code>true</code> if the peer certificate was signed by one of the CAs specified
 when creating the <code>tls.TLSSocket</code> instance, otherwise <code>false</code>.</p>
-<h3><code>tlsSocket.disableRenegotiation()</code><span><a class="mark" href="#tls_tlssocket_disablerenegotiation" id="tls_tlssocket_disablerenegotiation">#</a></span></h3>
+<h4><code>tlsSocket.disableRenegotiation()</code><span><a class="mark" href="#tls_tlssocket_disablerenegotiation" id="tls_tlssocket_disablerenegotiation">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.4.0</span>
 </div>
 <p>Disables TLS renegotiation for this <code>TLSSocket</code> instance. Once called, attempts
 to renegotiate will trigger an <code>'error'</code> event on the <code>TLSSocket</code>.</p>
-<h3><code>tlsSocket.enableTrace()</code><span><a class="mark" href="#tls_tlssocket_enabletrace" id="tls_tlssocket_enabletrace">#</a></span></h3>
+<h4><code>tlsSocket.enableTrace()</code><span><a class="mark" href="#tls_tlssocket_enabletrace" id="tls_tlssocket_enabletrace">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.2.0</span>
 </div>
@@ -957,13 +972,13 @@ used to debug TLS connection problems.</p>
 <p>Note: The format of the output is identical to the output of <code>openssl s_client -trace</code> or <code>openssl s_server -trace</code>. While it is produced by OpenSSL's
 <code>SSL_trace()</code> function, the format is undocumented, can change without notice,
 and should not be relied on.</p>
-<h3><code>tlsSocket.encrypted</code><span><a class="mark" href="#tls_tlssocket_encrypted" id="tls_tlssocket_encrypted">#</a></span></h3>
+<h4><code>tlsSocket.encrypted</code><span><a class="mark" href="#tls_tlssocket_encrypted" id="tls_tlssocket_encrypted">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
 <p>Always returns <code>true</code>. This may be used to distinguish TLS sockets from regular
 <code>net.Socket</code> instances.</p>
-<h3><code>tlsSocket.getCertificate()</code><span><a class="mark" href="#tls_tlssocket_getcertificate" id="tls_tlssocket_getcertificate">#</a></span></h3>
+<h4><code>tlsSocket.getCertificate()</code><span><a class="mark" href="#tls_tlssocket_getcertificate" id="tls_tlssocket_getcertificate">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v11.2.0</span>
 </div>
@@ -976,12 +991,12 @@ some properties corresponding to the fields of the certificate.</p>
 structure.</p>
 <p>If there is no local certificate, an empty object will be returned. If the
 socket has been destroyed, <code>null</code> will be returned.</p>
-<h3><code>tlsSocket.getCipher()</code><span><a class="mark" href="#tls_tlssocket_getcipher" id="tls_tlssocket_getcipher">#</a></span></h3>
+<h4><code>tlsSocket.getCipher()</code><span><a class="mark" href="#tls_tlssocket_getcipher" id="tls_tlssocket_getcipher">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.4.0, v12.16.0</td>
 <td><p>Return the IETF cipher name as <code>standardName</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>Return the minimum cipher version, instead of a fixed string (<code>'TLSv1/SSLv3'</code>).</p></td></tr>
@@ -1002,15 +1017,15 @@ suite.</li>
 </ul>
 <p>Returns an object containing information on the negotiated cipher suite.</p>
 <p>For example:</p>
-<pre><code class="language-json">{
-    <span class="hljs-attr">"name"</span>: <span class="hljs-string">"AES128-SHA256"</span>,
-    <span class="hljs-attr">"standardName"</span>: <span class="hljs-string">"TLS_RSA_WITH_AES_128_CBC_SHA256"</span>,
-    <span class="hljs-attr">"version"</span>: <span class="hljs-string">"TLSv1.2"</span>
-}</code></pre>
+<pre><code class="language-json"><span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"AES128-SHA256"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"standardName"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"TLS_RSA_WITH_AES_128_CBC_SHA256"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"version"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"TLSv1.2"</span>
+<span class="hljs-punctuation">}</span></code></pre>
 <p>See
 <a href="https://www.openssl.org/docs/man1.1.1/man3/SSL_CIPHER_get_name.html">SSL_CIPHER_get_name</a>
 for more information.</p>
-<h3><code>tlsSocket.getEphemeralKeyInfo()</code><span><a class="mark" href="#tls_tlssocket_getephemeralkeyinfo" id="tls_tlssocket_getephemeralkeyinfo">#</a></span></h3>
+<h4><code>tlsSocket.getEphemeralKeyInfo()</code><span><a class="mark" href="#tls_tlssocket_getephemeralkeyinfo" id="tls_tlssocket_getephemeralkeyinfo">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.0.0</span>
 </div>
@@ -1024,7 +1039,7 @@ ephemeral. As this is only supported on a client socket; <code>null</code> is re
 if called on a server socket. The supported types are <code>'DH'</code> and <code>'ECDH'</code>. The
 <code>name</code> property is available only when type is <code>'ECDH'</code>.</p>
 <p>For example: <code>{ type: 'ECDH', name: 'prime256v1', size: 256 }</code>.</p>
-<h3><code>tlsSocket.getFinished()</code><span><a class="mark" href="#tls_tlssocket_getfinished" id="tls_tlssocket_getfinished">#</a></span></h3>
+<h4><code>tlsSocket.getFinished()</code><span><a class="mark" href="#tls_tlssocket_getfinished" id="tls_tlssocket_getfinished">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.9.0</span>
 </div>
@@ -1039,7 +1054,7 @@ be used for external authentication procedures when the authentication
 provided by SSL/TLS is not desired or is not enough.</p>
 <p>Corresponds to the <code>SSL_get_finished</code> routine in OpenSSL and may be used
 to implement the <code>tls-unique</code> channel binding from <a href="https://tools.ietf.org/html/rfc5929">RFC 5929</a>.</p>
-<h3><code>tlsSocket.getPeerCertificate([detailed])</code><span><a class="mark" href="#tls_tlssocket_getpeercertificate_detailed" id="tls_tlssocket_getpeercertificate_detailed">#</a></span></h3>
+<h4><code>tlsSocket.getPeerCertificate([detailed])</code><span><a class="mark" href="#tls_tlssocket_getpeercertificate_detailed" id="tls_tlssocket_getpeercertificate_detailed">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -1054,7 +1069,7 @@ destroyed, <code>null</code> will be returned.</p>
 <p>If the full certificate chain was requested, each certificate will include an
 <code>issuerCertificate</code> property containing an object representing its issuer's
 certificate.</p>
-<h4>Certificate object<span><a class="mark" href="#tls_certificate_object" id="tls_certificate_object">#</a></span></h4>
+<h5>Certificate object<span><a class="mark" href="#tls_certificate_object" id="tls_certificate_object">#</a></span></h5>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1069,28 +1084,28 @@ certificate.</p>
 <ul>
 <li><code>raw</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The DER encoded X.509 certificate data.</li>
 <li><code>subject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The certificate subject, described in terms of
- Country (<code>C:</code>), StateOrProvince (<code>ST</code>), Locality (<code>L</code>), Organization (<code>O</code>),
+Country (<code>C:</code>), StateOrProvince (<code>ST</code>), Locality (<code>L</code>), Organization (<code>O</code>),
 OrganizationalUnit (<code>OU</code>), and CommonName (<code>CN</code>). The CommonName is typically
 a DNS name with TLS certificates. Example:
 <code>{C: 'UK', ST: 'BC', L: 'Metro', O: 'Node Fans', OU: 'Docs', CN: 'example.com'}</code>.</li>
 <li><code>issuer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The certificate issuer, described in the same terms as the
- <code>subject</code>.</li>
+<code>subject</code>.</li>
 <li><code>valid_from</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The date-time the certificate is valid from.</li>
 <li><code>valid_to</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The date-time the certificate is valid to.</li>
 <li><code>serialNumber</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The certificate serial number, as a hex string.
- Example: <code>'B9B0D332A1AA5635'</code>.</li>
+Example: <code>'B9B0D332A1AA5635'</code>.</li>
 <li><code>fingerprint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The SHA-1 digest of the DER encoded certificate. It is
 returned as a <code>:</code> separated hexadecimal string. Example: <code>'2A:7A:C2:DD:...'</code>.</li>
 <li><code>fingerprint256</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The SHA-256 digest of the DER encoded certificate.
- It is returned as a <code>:</code> separated hexadecimal string. Example:
+It is returned as a <code>:</code> separated hexadecimal string. Example:
 <code>'2A:7A:C2:DD:...'</code>.</li>
 <li><code>ext_key_usage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> (Optional) The extended key usage, a set of OIDs.</li>
 <li><code>subjectaltname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> (Optional) A string containing concatenated names
 for the subject, an alternative to the <code>subject</code> names.</li>
 <li><code>infoAccess</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> (Optional) An array describing the AuthorityInfoAccess,
- used with OCSP.</li>
+used with OCSP.</li>
 <li><code>issuerCertificate</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> (Optional) The issuer certificate object. For
- self-signed certificates, this may be a circular reference.</li>
+self-signed certificates, this may be a circular reference.</li>
 </ul>
 <p>The certificate may contain information about the public key, depending on
 the key type.</p>
@@ -1100,7 +1115,7 @@ the key type.</p>
 <li><code>exponent</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The RSA exponent, as a string in hexadecimal number
 notation. Example: <code>'0x010001'</code>.</li>
 <li><code>modulus</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The RSA modulus, as a hexadecimal string. Example:
- <code>'B56CE45CB7...'</code>.</li>
+<code>'B56CE45CB7...'</code>.</li>
 <li><code>pubkey</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> The public key.</li>
 </ul>
 <p>For EC keys, the following properties may be defined:</p>
@@ -1141,7 +1156,7 @@ has one (not all well-known curves have been assigned names by NIST). Example:
   ext_key_usage: [ '1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2' ],
   serialNumber: '66593D57F20CBC573E433381B5FEC280',
   raw: &#x3C;Buffer ... > }</code></pre>
-<h3><code>tlsSocket.getPeerFinished()</code><span><a class="mark" href="#tls_tlssocket_getpeerfinished" id="tls_tlssocket_getpeerfinished">#</a></span></h3>
+<h4><code>tlsSocket.getPeerFinished()</code><span><a class="mark" href="#tls_tlssocket_getpeerfinished" id="tls_tlssocket_getpeerfinished">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.9.0</span>
 </div>
@@ -1156,7 +1171,7 @@ be used for external authentication procedures when the authentication
 provided by SSL/TLS is not desired or is not enough.</p>
 <p>Corresponds to the <code>SSL_get_peer_finished</code> routine in OpenSSL and may be used
 to implement the <code>tls-unique</code> channel binding from <a href="https://tools.ietf.org/html/rfc5929">RFC 5929</a>.</p>
-<h3><code>tlsSocket.getProtocol()</code><span><a class="mark" href="#tls_tlssocket_getprotocol" id="tls_tlssocket_getprotocol">#</a></span></h3>
+<h4><code>tlsSocket.getProtocol()</code><span><a class="mark" href="#tls_tlssocket_getprotocol" id="tls_tlssocket_getprotocol">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v5.7.0</span>
 </div>
@@ -1176,7 +1191,7 @@ be returned for server sockets or disconnected client sockets.</p>
 <li><code>'TLSv1.3'</code></li>
 </ul>
 <p>See the OpenSSL <a href="https://www.openssl.org/docs/man1.1.1/man3/SSL_get_version.html"><code>SSL_get_version</code></a> documentation for more information.</p>
-<h3><code>tlsSocket.getSession()</code><span><a class="mark" href="#tls_tlssocket_getsession" id="tls_tlssocket_getsession">#</a></span></h3>
+<h4><code>tlsSocket.getSession()</code><span><a class="mark" href="#tls_tlssocket_getsession" id="tls_tlssocket_getsession">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -1190,7 +1205,7 @@ for debugging.</p>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
 <p>Note: <code>getSession()</code> works only for TLSv1.2 and below. For TLSv1.3, applications
 must use the <a href="#tls_event_session"><code>'session'</code></a> event (it also works for TLSv1.2 and below).</p>
-<h3><code>tlsSocket.getSharedSigalgs()</code><span><a class="mark" href="#tls_tlssocket_getsharedsigalgs" id="tls_tlssocket_getsharedsigalgs">#</a></span></h3>
+<h4><code>tlsSocket.getSharedSigalgs()</code><span><a class="mark" href="#tls_tlssocket_getsharedsigalgs" id="tls_tlssocket_getsharedsigalgs">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v12.11.0</span>
 </div>
@@ -1201,9 +1216,9 @@ the client in the order of decreasing preference.</li>
 <p>See
 <a href="https://www.openssl.org/docs/man1.1.1/man3/SSL_get_shared_sigalgs.html">SSL_get_shared_sigalgs</a>
 for more information.</p>
-<h3><code>tlsSocket.exportKeyingMaterial(length, label[, context])</code><span><a class="mark" href="#tls_tlssocket_exportkeyingmaterial_length_label_context" id="tls_tlssocket_exportkeyingmaterial_length_label_context">#</a></span></h3>
+<h4><code>tlsSocket.exportKeyingMaterial(length, label[, context])</code><span><a class="mark" href="#tls_tlssocket_exportkeyingmaterial_length_label_context" id="tls_tlssocket_exportkeyingmaterial_length_label_context">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.10.0</span>
 </div>
 <ul>
 <li>
@@ -1224,7 +1239,7 @@ value from the
 <p>Keying material is used for validations to prevent different kind of attacks in
 network protocols, for example in the specifications of IEEE 802.1X.</p>
 <p>Example</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> keyingMaterial = tlsSocket.exportKeyingMaterial(
+<pre><code class="language-js"><span class="hljs-keyword">const</span> keyingMaterial = tlsSocket.<span class="hljs-title function_">exportKeyingMaterial</span>(
   <span class="hljs-number">128</span>,
   <span class="hljs-string">'client finished'</span>);
 
@@ -1236,7 +1251,7 @@ network protocols, for example in the specifications of IEEE 802.1X.</p>
 */</span></code></pre>
 <p>See the OpenSSL <a href="https://www.openssl.org/docs/man1.1.1/man3/SSL_export_keying_material.html"><code>SSL_export_keying_material</code></a> documentation for more
 information.</p>
-<h3><code>tlsSocket.getTLSTicket()</code><span><a class="mark" href="#tls_tlssocket_gettlsticket" id="tls_tlssocket_gettlsticket">#</a></span></h3>
+<h4><code>tlsSocket.getTLSTicket()</code><span><a class="mark" href="#tls_tlssocket_gettlsticket" id="tls_tlssocket_gettlsticket">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -1247,7 +1262,7 @@ information.</p>
 <code>undefined</code>. For a server, always returns <code>undefined</code>.</p>
 <p>It may be useful for debugging.</p>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
-<h3><code>tlsSocket.isSessionReused()</code><span><a class="mark" href="#tls_tlssocket_issessionreused" id="tls_tlssocket_issessionreused">#</a></span></h3>
+<h4><code>tlsSocket.isSessionReused()</code><span><a class="mark" href="#tls_tlssocket_issessionreused" id="tls_tlssocket_issessionreused">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.6</span>
 </div>
@@ -1255,7 +1270,7 @@ information.</p>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if the session was reused, <code>false</code> otherwise.</li>
 </ul>
 <p>See <a href="#tls_session_resumption">Session Resumption</a> for more information.</p>
-<h3><code>tlsSocket.localAddress</code><span><a class="mark" href="#tls_tlssocket_localaddress" id="tls_tlssocket_localaddress">#</a></span></h3>
+<h4><code>tlsSocket.localAddress</code><span><a class="mark" href="#tls_tlssocket_localaddress" id="tls_tlssocket_localaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -1263,7 +1278,7 @@ information.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Returns the string representation of the local IP address.</p>
-<h3><code>tlsSocket.localPort</code><span><a class="mark" href="#tls_tlssocket_localport" id="tls_tlssocket_localport">#</a></span></h3>
+<h4><code>tlsSocket.localPort</code><span><a class="mark" href="#tls_tlssocket_localport" id="tls_tlssocket_localport">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -1271,7 +1286,7 @@ information.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Returns the numeric representation of the local port.</p>
-<h3><code>tlsSocket.remoteAddress</code><span><a class="mark" href="#tls_tlssocket_remoteaddress" id="tls_tlssocket_remoteaddress">#</a></span></h3>
+<h4><code>tlsSocket.remoteAddress</code><span><a class="mark" href="#tls_tlssocket_remoteaddress" id="tls_tlssocket_remoteaddress">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -1280,7 +1295,7 @@ information.</p>
 </ul>
 <p>Returns the string representation of the remote IP address. For example,
 <code>'74.125.127.100'</code> or <code>'2001:4860:a005::68'</code>.</p>
-<h3><code>tlsSocket.remoteFamily</code><span><a class="mark" href="#tls_tlssocket_remotefamily" id="tls_tlssocket_remotefamily">#</a></span></h3>
+<h4><code>tlsSocket.remoteFamily</code><span><a class="mark" href="#tls_tlssocket_remotefamily" id="tls_tlssocket_remotefamily">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -1288,7 +1303,7 @@ information.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Returns the string representation of the remote IP family. <code>'IPv4'</code> or <code>'IPv6'</code>.</p>
-<h3><code>tlsSocket.remotePort</code><span><a class="mark" href="#tls_tlssocket_remoteport" id="tls_tlssocket_remoteport">#</a></span></h3>
+<h4><code>tlsSocket.remotePort</code><span><a class="mark" href="#tls_tlssocket_remoteport" id="tls_tlssocket_remoteport">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -1296,7 +1311,7 @@ information.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Returns the numeric representation of the remote port. For example, <code>443</code>.</p>
-<h3><code>tlsSocket.renegotiate(options, callback)</code><span><a class="mark" href="#tls_tlssocket_renegotiate_options_callback" id="tls_tlssocket_renegotiate_options_callback">#</a></span></h3>
+<h4><code>tlsSocket.renegotiate(options, callback)</code><span><a class="mark" href="#tls_tlssocket_renegotiate_options_callback" id="tls_tlssocket_renegotiate_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.8</span>
 </div>
@@ -1331,7 +1346,7 @@ connection has been established.</p>
 <code>handshakeTimeout</code> timeout.</p>
 <p>For TLSv1.3, renegotiation cannot be initiated, it is not supported by the
 protocol.</p>
-<h3><code>tlsSocket.setMaxSendFragment(size)</code><span><a class="mark" href="#tls_tlssocket_setmaxsendfragment_size" id="tls_tlssocket_setmaxsendfragment_size">#</a></span></h3>
+<h4><code>tlsSocket.setMaxSendFragment(size)</code><span><a class="mark" href="#tls_tlssocket_setmaxsendfragment_size" id="tls_tlssocket_setmaxsendfragment_size">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.11</span>
 </div>
@@ -1348,9 +1363,17 @@ and its integrity is verified; large fragments can span multiple roundtrips
 and their processing can be delayed due to packet loss or reordering. However,
 smaller fragments add extra TLS framing bytes and CPU overhead, which may
 decrease overall server throughput.</p>
-<h2><code>tls.checkServerIdentity(hostname, cert)</code><span><a class="mark" href="#tls_tls_checkserveridentity_hostname_cert" id="tls_tls_checkserveridentity_hostname_cert">#</a></span></h2>
+</section><section><h3><code>tls.checkServerIdentity(hostname, cert)</code><span><a class="mark" href="#tls_tls_checkserveridentity_hostname_cert" id="tls_tls_checkserveridentity_hostname_cert">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v0.8.4</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.18.3</td>
+<td><p>Support for <code>uniformResourceIdentifier</code> subject alternative names has been disabled in response to CVE-2021-44531.</p></td></tr>
+<tr><td>v0.8.4</td>
+<td><p><span>Added in: v0.8.4</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The host name or IP address to verify the certificate
@@ -1367,12 +1390,21 @@ overwriting function can call <code>tls.checkServerIdentity()</code> of course,
 the checks done with additional verification.</p>
 <p>This function is only called if the certificate passed all other checks, such as
 being issued by trusted CA (<code>options.ca</code>).</p>
-<h2><code>tls.connect(options[, callback])</code><span><a class="mark" href="#tls_tls_connect_options_callback" id="tls_tls_connect_options_callback">#</a></span></h2>
+<p>Earlier versions of Node.js incorrectly accepted certificates for a given
+<code>hostname</code> if a matching <code>uniformResourceIdentifier</code> subject alternative name
+was present (see <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531">CVE-2021-44531</a>). Applications that wish to accept
+<code>uniformResourceIdentifier</code> subject alternative names can use a custom
+<code>options.checkServerIdentity</code> function that implements the desired behavior.</p>
+</section><section><h3><code>tls.connect(options[, callback])</code><span><a class="mark" href="#tls_tls_connect_options_callback" id="tls_tls_connect_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v14.18.0</td>
+<td><p>Added <code>onread</code> option.</p></td></tr>
+<tr><td>v14.1.0</td>
+<td><p>The <code>highWaterMark</code> option is accepted now.</p></td></tr>
+<tr><td>v13.6.0, v12.16.0</td>
 <td><p>The <code>pskCallback</code> option is now supported.</p></td></tr>
 <tr><td>v12.9.0</td>
 <td><p>Support the <code>allowHalfOpen</code> option.</p></td></tr>
@@ -1380,16 +1412,16 @@ being issued by trusted CA (<code>options.ca</code>).</p>
 <td><p>The <code>hints</code> option is now supported.</p></td></tr>
 <tr><td>v12.2.0</td>
 <td><p>The <code>enableTrace</code> option is now supported.</p></td></tr>
-<tr><td>v11.8.0</td>
+<tr><td>v11.8.0, v10.16.0</td>
 <td><p>The <code>timeout</code> option is supported now.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>lookup</code> option is supported now.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p>The <code>ALPNProtocols</code> option can be a <code>TypedArray</code> or <code>DataView</code> now.</p></td></tr>
-<tr><td>v5.3.0, v4.7.0</td>
-<td><p>The <code>secureContext</code> option is supported now.</p></td></tr>
 <tr><td>v5.0.0</td>
 <td><p>ALPN options are supported now.</p></td></tr>
+<tr><td>v5.3.0, v4.7.0</td>
+<td><p>The <code>secureContext</code> option is supported now.</p></td></tr>
 <tr><td>v0.11.3</td>
 <td><p><span>Added in: v0.11.3</span></p></td></tr>
 </tbody></table>
@@ -1413,10 +1445,10 @@ when passed to <code>tls.connect()</code>, but it can be connected later.
 Connection/disconnection/destruction of <code>socket</code> is the user's
 responsibility; calling <code>tls.connect()</code> will not cause <code>net.connect()</code> to be
 called.</li>
-<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If the <code>socket</code> option is missing, indicates
-whether or not to allow the internally created socket to be half-open,
-otherwise the option is ignored. See the <code>allowHalfOpen</code> option of
-<a href="net.html#net_class_net_socket"><code>net.Socket</code></a> for details. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>allowHalfOpen</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If set to <code>false</code>, then the socket will
+automatically end the writable side when the readable side ends. If the
+<code>socket</code> option is set, this option has no effect. See the <code>allowHalfOpen</code>
+option of <a href="net.html#net_class_net_socket"><code>net.Socket</code></a> for details. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>rejectUnauthorized</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If not <code>false</code>, the server certificate is
 verified against the list of supplied CAs. An <code>'error'</code> event is emitted if
 verification fails; <code>err.code</code> contains the OpenSSL error code. <strong>Default:</strong>
@@ -1427,10 +1459,11 @@ verification fails; <code>err.code</code> contains the OpenSSL error code. <stro
 decide which identity to use during negotiation.
 Always <code>null</code> if TLS 1.3 is used.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> in the form
-  <code>{ psk: &#x3C;Buffer|TypedArray|DataView>, identity: &#x3C;string> }</code>
+<code>{ psk: &#x3C;Buffer|TypedArray|DataView>, identity: &#x3C;string> }</code>
 or <code>null</code> to stop the negotiation process. <code>psk</code> must be
 compatible with the selected cipher's digest.
-<code>identity</code> must use UTF-8 encoding.
+<code>identity</code> must use UTF-8 encoding.</li>
+</ul>
 When negotiating TLS-PSK (pre-shared keys), this function is called
 with optional identity <code>hint</code> provided by the server or <code>null</code>
 in case of TLS 1.3 where <code>hint</code> was removed.
@@ -1439,8 +1472,6 @@ for the connection as the default one will try to check host name/IP
 of the server against the certificate but that's not applicable for PSK
 because there won't be a certificate present.
 More information can be found in the <a href="https://tools.ietf.org/html/rfc4279">RFC 4279</a>.</li>
-</ul>
-</li>
 <li><code>ALPNProtocols</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray[]></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView[]></a> | <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a>
 An array of strings, <code>Buffer</code>s or <code>TypedArray</code>s or <code>DataView</code>s, or a
 single <code>Buffer</code> or <code>TypedArray</code> or <code>DataView</code> containing the supported ALPN
@@ -1465,10 +1496,16 @@ and <code>cert</code> are verified.</li>
 TLS connection. When a server offers a DH parameter with a size less
 than <code>minDHSize</code>, the TLS connection is destroyed and an error is thrown.
 <strong>Default:</strong> <code>1024</code>.</li>
+<li><code>highWaterMark</code>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Consistent with the readable stream <code>highWaterMark</code> parameter.
+<strong>Default:</strong> <code>16 * 1024</code>.</li>
 <li><code>secureContext</code>: TLS context object created with
 <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a>. If a <code>secureContext</code> is <em>not</em> provided, one
 will be created by passing the entire <code>options</code> object to
 <code>tls.createSecureContext()</code>.</li>
+<li><code>onread</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> If the <code>socket</code> option is missing, incoming data is
+stored in a single <code>buffer</code> and passed to the supplied <code>callback</code> when
+data arrives on the socket, otherwise the option is ignored. See the
+<code>onread</code> option of <a href="net.html#net_class_net_socket"><code>net.Socket</code></a> for details.</li>
 <li>...: <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a> options that are used if the
 <code>secureContext</code> option is missing, otherwise they are ignored.</li>
 <li>...: Any <a href="net.html#net_socket_connect_options_connectlistener"><code>socket.connect()</code></a> option not already listed.</li>
@@ -1493,30 +1530,30 @@ to <code>host</code>.</p>
 
 <span class="hljs-keyword">const</span> options = {
   <span class="hljs-comment">// Necessary only if the server requires client certificate authentication.</span>
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'client-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'client-cert.pem'</span>),
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'client-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'client-cert.pem'</span>),
 
   <span class="hljs-comment">// Necessary only if the server uses a self-signed certificate.</span>
-  <span class="hljs-attr">ca</span>: [ fs.readFileSync(<span class="hljs-string">'server-cert.pem'</span>) ],
+  <span class="hljs-attr">ca</span>: [ fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-cert.pem'</span>) ],
 
   <span class="hljs-comment">// Necessary only if the server's cert isn't for "localhost".</span>
   <span class="hljs-attr">checkServerIdentity</span>: <span class="hljs-function">() =></span> { <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>; },
 };
 
-<span class="hljs-keyword">const</span> socket = tls.connect(<span class="hljs-number">8000</span>, options, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'client connected'</span>,
-              socket.authorized ? <span class="hljs-string">'authorized'</span> : <span class="hljs-string">'unauthorized'</span>);
-  process.stdin.pipe(socket);
-  process.stdin.resume();
+<span class="hljs-keyword">const</span> socket = tls.<span class="hljs-title function_">connect</span>(<span class="hljs-number">8000</span>, options, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'client connected'</span>,
+              socket.<span class="hljs-property">authorized</span> ? <span class="hljs-string">'authorized'</span> : <span class="hljs-string">'unauthorized'</span>);
+  process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">pipe</span>(socket);
+  process.<span class="hljs-property">stdin</span>.<span class="hljs-title function_">resume</span>();
 });
-socket.setEncoding(<span class="hljs-string">'utf8'</span>);
-socket.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(data);
+socket.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(data);
 });
-socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server ends connection'</span>);
+socket.<span class="hljs-title function_">on</span>(<span class="hljs-string">'end'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server ends connection'</span>);
 });</code></pre>
-<h2><code>tls.connect(path[, options][, callback])</code><span><a class="mark" href="#tls_tls_connect_path_options_callback" id="tls_tls_connect_path_options_callback">#</a></span></h2>
+</section><section><h3><code>tls.connect(path[, options][, callback])</code><span><a class="mark" href="#tls_tls_connect_path_options_callback" id="tls_tls_connect_path_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -1529,7 +1566,7 @@ socket.on(<span class="hljs-string">'end'</span>, <span class="hljs-function">()
 <p>Same as <a href="#tls_tls_connect_options_callback"><code>tls.connect()</code></a> except that <code>path</code> can be provided
 as an argument instead of an option.</p>
 <p>A path option, if specified, will take precedence over the path argument.</p>
-<h2><code>tls.connect(port[, host][, options][, callback])</code><span><a class="mark" href="#tls_tls_connect_port_host_options_callback" id="tls_tls_connect_port_host_options_callback">#</a></span></h2>
+</section><section><h3><code>tls.connect(port[, host][, options][, callback])</code><span><a class="mark" href="#tls_tls_connect_port_host_options_callback" id="tls_tls_connect_port_host_options_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -1544,7 +1581,7 @@ as an argument instead of an option.</p>
 as arguments instead of options.</p>
 <p>A port or host option, if specified, will take precedence over any port or host
 argument.</p>
-<h2><code>tls.createSecureContext([options])</code><span><a class="mark" href="#tls_tls_createsecurecontext_options" id="tls_tls_createsecurecontext_options">#</a></span></h2>
+</section><section><h3><code>tls.createSecureContext([options])</code><span><a class="mark" href="#tls_tls_createsecurecontext_options" id="tls_tls_createsecurecontext_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1557,7 +1594,7 @@ argument.</p>
 <td><p>TLSv1.3 support added.</p></td></tr>
 <tr><td>v11.5.0</td>
 <td><p>The <code>ca:</code> option now supports <code>BEGIN TRUSTED CERTIFICATE</code>.</p></td></tr>
-<tr><td>v11.4.0</td>
+<tr><td>v11.4.0, v10.16.0</td>
 <td><p>The <code>minVersion</code> and <code>maxVersion</code> can be used to restrict the allowed TLS protocol versions.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>ecdhCurve</code> cannot be set to <code>false</code> anymore due to a change in OpenSSL.</p></td></tr>
@@ -1652,12 +1689,12 @@ Should not be set together with <code>key</code>, because both options define a
 private key in different ways.</li>
 <li><code>maxVersion</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Optionally set the maximum TLS version to allow. One
 of <code>'TLSv1.3'</code>, <code>'TLSv1.2'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1'</code>. Cannot be specified
-along with the <code>secureProtocol</code> option, use one or the other.
+along with the <code>secureProtocol</code> option; use one or the other.
 <strong>Default:</strong> <a href="#tls_tls_default_max_version"><code>tls.DEFAULT_MAX_VERSION</code></a>.</li>
 <li><code>minVersion</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Optionally set the minimum TLS version to allow. One
 of <code>'TLSv1.3'</code>, <code>'TLSv1.2'</code>, <code>'TLSv1.1'</code>, or <code>'TLSv1'</code>. Cannot be specified
-along with the <code>secureProtocol</code> option, use one or the other. It is not
-recommended to use less than TLSv1.2, but it may be required for
+along with the <code>secureProtocol</code> option; use one or the other. Avoid
+setting to less than TLSv1.2, but it may be required for
 interoperability.
 <strong>Default:</strong> <a href="#tls_tls_default_min_version"><code>tls.DEFAULT_MIN_VERSION</code></a>.</li>
 <li><code>passphrase</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Shared passphrase used for a single private key and/or
@@ -1706,7 +1743,7 @@ and <a href="#tls_server_addcontext_hostname_context"><code>server.addContext()<
 <code>pfx</code> can be used to provide it.</p>
 <p>If the <code>ca</code> option is not given, then Node.js will default to using
 <a href="https://hg.mozilla.org/mozilla-central/raw-file/tip/security/nss/lib/ckfw/builtins/certdata.txt">Mozilla's publicly trusted list of CAs</a>.</p>
-<h2><code>tls.createSecurePair([context][, isServer][, requestCert][, rejectUnauthorized][, options])</code><span><a class="mark" href="#tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options" id="tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options">#</a></span></h2>
+</section><section><h3><code>tls.createSecurePair([context][, isServer][, requestCert][, rejectUnauthorized][, options])</code><span><a class="mark" href="#tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options" id="tls_tls_createsecurepair_context_isserver_requestcert_rejectunauthorized_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1758,13 +1795,13 @@ stream.</p>
 <p>Using <code>cleartext</code> has the same API as <a href="#tls_class_tls_tlssocket"><code>tls.TLSSocket</code></a>.</p>
 <p>The <code>tls.createSecurePair()</code> method is now deprecated in favor of
 <code>tls.TLSSocket()</code>. For example, the code:</p>
-<pre><code class="language-js">pair = tls.createSecurePair(<span class="hljs-comment">/* ... */</span>);
-pair.encrypted.pipe(socket);
-socket.pipe(pair.encrypted);</code></pre>
+<pre><code class="language-js">pair = tls.<span class="hljs-title function_">createSecurePair</span>(<span class="hljs-comment">/* ... */</span>);
+pair.<span class="hljs-property">encrypted</span>.<span class="hljs-title function_">pipe</span>(socket);
+socket.<span class="hljs-title function_">pipe</span>(pair.<span class="hljs-property">encrypted</span>);</code></pre>
 <p>can be replaced by:</p>
-<pre><code class="language-js">secureSocket = tls.TLSSocket(socket, options);</code></pre>
+<pre><code class="language-js">secureSocket = tls.<span class="hljs-title function_">TLSSocket</span>(socket, options);</code></pre>
 <p>where <code>secureSocket</code> has the same API as <code>pair.cleartext</code>.</p>
-<h2><code>tls.createServer([options][, secureConnectionListener])</code><span><a class="mark" href="#tls_tls_createserver_options_secureconnectionlistener" id="tls_tls_createserver_options_secureconnectionlistener">#</a></span></h2>
+</section><section><h3><code>tls.createServer([options][, secureConnectionListener])</code><span><a class="mark" href="#tls_tls_createserver_options_secureconnectionlistener" id="tls_tls_createserver_options_secureconnectionlistener">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1828,8 +1865,9 @@ data. See <a href="#tls_session_resumption">Session Resumption</a> for more info
 this connection.</li>
 <li>identity: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> identity parameter sent from the client.</li>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> pre-shared key that must either be
-  a buffer or <code>null</code> to stop the negotiation process. Returned PSK must be
-compatible with the selected cipher's digest.
+a buffer or <code>null</code> to stop the negotiation process. Returned PSK must be
+compatible with the selected cipher's digest.</li>
+</ul>
 When negotiating TLS-PSK (pre-shared keys), this function is called
 with the identity provided by the client.
 If the return value is <code>null</code> the negotiation process will stop and an
@@ -1840,8 +1878,6 @@ fail with "decrypt_error" before negotiation is finished.
 PSK ciphers are disabled by default, and using TLS-PSK thus
 requires explicitly specifying a cipher suite with the <code>ciphers</code> option.
 More information can be found in the <a href="https://tools.ietf.org/html/rfc4279">RFC 4279</a>.</li>
-</ul>
-</li>
 <li><code>pskIdentityHint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> optional hint to send to a client to help
 with selecting the identity during TLS-PSK negotiation. Will be ignored
 in TLS 1.3. Upon failing to set pskIdentityHint <code>'tlsClientError'</code> will be
@@ -1864,29 +1900,29 @@ workers.</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
 <span class="hljs-keyword">const</span> options = {
-  <span class="hljs-attr">key</span>: fs.readFileSync(<span class="hljs-string">'server-key.pem'</span>),
-  <span class="hljs-attr">cert</span>: fs.readFileSync(<span class="hljs-string">'server-cert.pem'</span>),
+  <span class="hljs-attr">key</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-key.pem'</span>),
+  <span class="hljs-attr">cert</span>: fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'server-cert.pem'</span>),
 
   <span class="hljs-comment">// This is necessary only if using client certificate authentication.</span>
   <span class="hljs-attr">requestCert</span>: <span class="hljs-literal">true</span>,
 
   <span class="hljs-comment">// This is necessary only if the client uses a self-signed certificate.</span>
-  <span class="hljs-attr">ca</span>: [ fs.readFileSync(<span class="hljs-string">'client-cert.pem'</span>) ]
+  <span class="hljs-attr">ca</span>: [ fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'client-cert.pem'</span>) ]
 };
 
-<span class="hljs-keyword">const</span> server = tls.createServer(options, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server connected'</span>,
-              socket.authorized ? <span class="hljs-string">'authorized'</span> : <span class="hljs-string">'unauthorized'</span>);
-  socket.write(<span class="hljs-string">'welcome!\n'</span>);
-  socket.setEncoding(<span class="hljs-string">'utf8'</span>);
-  socket.pipe(socket);
+<span class="hljs-keyword">const</span> server = tls.<span class="hljs-title function_">createServer</span>(options, <span class="hljs-function">(<span class="hljs-params">socket</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server connected'</span>,
+              socket.<span class="hljs-property">authorized</span> ? <span class="hljs-string">'authorized'</span> : <span class="hljs-string">'unauthorized'</span>);
+  socket.<span class="hljs-title function_">write</span>(<span class="hljs-string">'welcome!\n'</span>);
+  socket.<span class="hljs-title function_">setEncoding</span>(<span class="hljs-string">'utf8'</span>);
+  socket.<span class="hljs-title function_">pipe</span>(socket);
 });
-server.listen(<span class="hljs-number">8000</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'server bound'</span>);
+server.<span class="hljs-title function_">listen</span>(<span class="hljs-number">8000</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'server bound'</span>);
 });</code></pre>
 <p>The server can be tested by connecting to it using the example client from
 <a href="#tls_tls_connect_options_callback"><code>tls.connect()</code></a>.</p>
-<h2><code>tls.getCiphers()</code><span><a class="mark" href="#tls_tls_getciphers" id="tls_tls_getciphers">#</a></span></h2>
+</section><section><h3><code>tls.getCiphers()</code><span><a class="mark" href="#tls_tls_getciphers" id="tls_tls_getciphers">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.10.2</span>
 </div>
@@ -1898,8 +1934,8 @@ lower-case for historical reasons, but must be uppercased to be used in
 the <code>ciphers</code> option of <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a>.</p>
 <p>Cipher names that start with <code>'tls_'</code> are for TLSv1.3, all the others are for
 TLSv1.2 and below.</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(tls.getCiphers()); <span class="hljs-comment">// ['aes128-gcm-sha256', 'aes128-sha', ...]</span></code></pre>
-<h2><code>tls.rootCertificates</code><span><a class="mark" href="#tls_tls_rootcertificates" id="tls_tls_rootcertificates">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(tls.<span class="hljs-title function_">getCiphers</span>()); <span class="hljs-comment">// ['aes128-gcm-sha256', 'aes128-sha', ...]</span></code></pre>
+</section><section><h3><code>tls.rootCertificates</code><span><a class="mark" href="#tls_tls_rootcertificates" id="tls_tls_rootcertificates">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
@@ -1910,7 +1946,7 @@ TLSv1.2 and below.</p>
 from the bundled Mozilla CA store as supplied by current Node.js version.</p>
 <p>The bundled CA store, as supplied by Node.js, is a snapshot of Mozilla CA store
 that is fixed at release time. It is identical on all supported platforms.</p>
-<h2><code>tls.DEFAULT_ECDH_CURVE</code><span><a class="mark" href="#tls_tls_default_ecdh_curve" id="tls_tls_default_ecdh_curve">#</a></span></h2>
+</section><section><h3><code>tls.DEFAULT_ECDH_CURVE</code><span><a class="mark" href="#tls_tls_default_ecdh_curve" id="tls_tls_default_ecdh_curve">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1925,7 +1961,7 @@ that is fixed at release time. It is identical on all supported platforms.</p>
 <p>The default curve name to use for ECDH key agreement in a tls server. The
 default value is <code>'auto'</code>. See <a href="#tls_tls_createsecurecontext_options"><code>tls.createSecureContext()</code></a> for further
 information.</p>
-<h2><code>tls.DEFAULT_MAX_VERSION</code><span><a class="mark" href="#tls_tls_default_max_version" id="tls_tls_default_max_version">#</a></span></h2>
+</section><section><h3><code>tls.DEFAULT_MAX_VERSION</code><span><a class="mark" href="#tls_tls_default_max_version" id="tls_tls_default_max_version">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.4.0</span>
 </div>
@@ -1938,7 +1974,7 @@ protocol versions, <code>'TLSv1.3'</code>, <code>'TLSv1.2'</code>, <code>'TLSv1.
 the default to <code>'TLSv1.3'</code>. If multiple of the options are provided, the
 highest maximum is used.</li>
 </ul>
-<h2><code>tls.DEFAULT_MIN_VERSION</code><span><a class="mark" href="#tls_tls_default_min_version" id="tls_tls_default_min_version">#</a></span></h2>
+</section><section><h3><code>tls.DEFAULT_MIN_VERSION</code><span><a class="mark" href="#tls_tls_default_min_version" id="tls_tls_default_min_version">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.4.0</span>
 </div>
@@ -1951,10 +1987,46 @@ protocol versions, <code>'TLSv1.3'</code>, <code>'TLSv1.2'</code>, <code>'TLSv1.
 the default to <code>'TLSv1.1'</code>. Using <code>--tls-min-v1.3</code> sets the default to
 <code>'TLSv1.3'</code>. If multiple of the options are provided, the lowest minimum is
 used.</li>
-</ul>
+</ul></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/tls.json b/doc/api/tls.json
index 9b5812466bf2f8d0a02499a4da8ececbd4154cfa..8bf9f6f333ee195779666ab8063846388ac1a3fc 100644
--- a/doc/api/tls.json
+++ b/doc/api/tls.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/tls.js\">lib/tls.js</a></p>\n<p>The <code>tls</code> module provides an implementation of the Transport Layer Security\n(TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.\nThe module can be accessed using:</p>\n<pre><code class=\"language-js\">const tls = require('tls');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/tls.js\">lib/tls.js</a></p>\n<p>The <code>tls</code> module provides an implementation of the Transport Layer Security\n(TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.\nThe module can be accessed using:</p>\n<pre><code class=\"language-js\">const tls = require('tls');\n</code></pre>",
       "modules": [
         {
           "textRaw": "TLS/SSL concepts",
@@ -56,7 +56,7 @@
                 {
                   "textRaw": "Session tickets",
                   "name": "session_tickets",
-                  "desc": "<p>The servers encrypt the entire session state and send it\nto the client as a \"ticket\". When reconnecting, the state is sent to the server\nin the initial connection. This mechanism avoids the need for server-side\nsession cache. If the server doesn't use the ticket, for any reason (failure\nto decrypt it, it's too old, etc.), it will create a new session and send a new\nticket. See <a href=\"https://tools.ietf.org/html/rfc5077\">RFC 5077</a> for more information.</p>\n<p>Resumption using session tickets is becoming commonly supported by many web\nbrowsers when making HTTPS requests.</p>\n<p>For Node.js, clients use the same APIs for resumption with session identifiers\nas for resumption with session tickets. For debugging, if\n<a href=\"#tls_tlssocket_gettlsticket\"><code>tls.TLSSocket.getTLSTicket()</code></a> returns a value, the session data contains a\nticket, otherwise it contains client-side session state.</p>\n<p>With TLSv1.3, be aware that multiple tickets may be sent by the server,\nresulting in multiple <code>'session'</code> events, see <a href=\"#tls_event_session\"><code>'session'</code></a> for more\ninformation.</p>\n<p>Single process servers need no specific implementation to use session tickets.\nTo use session tickets across server restarts or load balancers, servers must\nall have the same ticket keys. There are three 16-byte keys internally, but the\ntls API exposes them as a single 48-byte buffer for convenience.</p>\n<p>Its possible to get the ticket keys by calling <a href=\"#tls_server_getticketkeys\"><code>server.getTicketKeys()</code></a> on\none server instance and then distribute them, but it is more reasonable to\nsecurely generate 48 bytes of secure random data and set them with the\n<code>ticketKeys</code> option of <a href=\"#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>. The keys should be regularly\nregenerated and server's keys can be reset with\n<a href=\"#tls_server_setticketkeys_keys\"><code>server.setTicketKeys()</code></a>.</p>\n<p>Session ticket keys are cryptographic keys, and they <strong><em>must be stored\nsecurely</em></strong>. With TLS 1.2 and below, if they are compromised all sessions that\nused tickets encrypted with them can be decrypted. They should not be stored\non disk, and they should be regenerated regularly.</p>\n<p>If clients advertise support for tickets, the server will send them. The\nserver can disable tickets by supplying\n<code>require('constants').SSL_OP_NO_TICKET</code> in <code>secureOptions</code>.</p>\n<p>Both session identifiers and session tickets timeout, causing the server to\ncreate new sessions. The timeout can be configured with the <code>sessionTimeout</code>\noption of <a href=\"#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>.</p>\n<p>For all the mechanisms, when resumption fails, servers will create new sessions.\nSince failing to resume the session does not cause TLS/HTTPS connection\nfailures, it is easy to not notice unnecessarily poor TLS performance. The\nOpenSSL CLI can be used to verify that servers are resuming sessions. Use the\n<code>-reconnect</code> option to <code>openssl s_client</code>, for example:</p>\n<pre><code class=\"language-console\">$ openssl s_client -connect localhost:443 -reconnect\n</code></pre>\n<p>Read through the debug output. The first connection should say \"New\", for\nexample:</p>\n<pre><code class=\"language-text\">New, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256\n</code></pre>\n<p>Subsequent connections should say \"Reused\", for example:</p>\n<pre><code class=\"language-text\">Reused, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256\n</code></pre>",
+                  "desc": "<p>The servers encrypt the entire session state and send it\nto the client as a \"ticket\". When reconnecting, the state is sent to the server\nin the initial connection. This mechanism avoids the need for server-side\nsession cache. If the server doesn't use the ticket, for any reason (failure\nto decrypt it, it's too old, etc.), it will create a new session and send a new\nticket. See <a href=\"https://tools.ietf.org/html/rfc5077\">RFC 5077</a> for more information.</p>\n<p>Resumption using session tickets is becoming commonly supported by many web\nbrowsers when making HTTPS requests.</p>\n<p>For Node.js, clients use the same APIs for resumption with session identifiers\nas for resumption with session tickets. For debugging, if\n<a href=\"#tls_tlssocket_gettlsticket\"><code>tls.TLSSocket.getTLSTicket()</code></a> returns a value, the session data contains a\nticket, otherwise it contains client-side session state.</p>\n<p>With TLSv1.3, be aware that multiple tickets may be sent by the server,\nresulting in multiple <code>'session'</code> events, see <a href=\"#tls_event_session\"><code>'session'</code></a> for more\ninformation.</p>\n<p>Single process servers need no specific implementation to use session tickets.\nTo use session tickets across server restarts or load balancers, servers must\nall have the same ticket keys. There are three 16-byte keys internally, but the\ntls API exposes them as a single 48-byte buffer for convenience.</p>\n<p>Its possible to get the ticket keys by calling <a href=\"#tls_server_getticketkeys\"><code>server.getTicketKeys()</code></a> on\none server instance and then distribute them, but it is more reasonable to\nsecurely generate 48 bytes of secure random data and set them with the\n<code>ticketKeys</code> option of <a href=\"#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>. The keys should be regularly\nregenerated and server's keys can be reset with\n<a href=\"#tls_server_setticketkeys_keys\"><code>server.setTicketKeys()</code></a>.</p>\n<p>Session ticket keys are cryptographic keys, and they <em><strong>must be stored\nsecurely</strong></em>. With TLS 1.2 and below, if they are compromised all sessions that\nused tickets encrypted with them can be decrypted. They should not be stored\non disk, and they should be regenerated regularly.</p>\n<p>If clients advertise support for tickets, the server will send them. The\nserver can disable tickets by supplying\n<code>require('constants').SSL_OP_NO_TICKET</code> in <code>secureOptions</code>.</p>\n<p>Both session identifiers and session tickets timeout, causing the server to\ncreate new sessions. The timeout can be configured with the <code>sessionTimeout</code>\noption of <a href=\"#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>.</p>\n<p>For all the mechanisms, when resumption fails, servers will create new sessions.\nSince failing to resume the session does not cause TLS/HTTPS connection\nfailures, it is easy to not notice unnecessarily poor TLS performance. The\nOpenSSL CLI can be used to verify that servers are resuming sessions. Use the\n<code>-reconnect</code> option to <code>openssl s_client</code>, for example:</p>\n<pre><code class=\"language-console\">$ openssl s_client -connect localhost:443 -reconnect\n</code></pre>\n<p>Read through the debug output. The first connection should say \"New\", for\nexample:</p>\n<pre><code class=\"language-text\">New, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256\n</code></pre>\n<p>Subsequent connections should say \"Reused\", for example:</p>\n<pre><code class=\"language-text\">Reused, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256\n</code></pre>",
                   "type": "module",
                   "displayName": "Session tickets"
                 }
@@ -71,7 +71,7 @@
         {
           "textRaw": "Modifying the default TLS cipher suite",
           "name": "modifying_the_default_tls_cipher_suite",
-          "desc": "<p>Node.js is built with a default suite of enabled and disabled TLS ciphers. This\ndefault cipher list can be configured when building Node.js to allow\ndistributions to provide their own default list.</p>\n<p>The following command can be used to show the default cipher suite:</p>\n<pre><code class=\"language-console\">node -p crypto.constants.defaultCoreCipherList | tr ':' '\\n'\nTLS_AES_256_GCM_SHA384\nTLS_CHACHA20_POLY1305_SHA256\nTLS_AES_128_GCM_SHA256\nECDHE-RSA-AES128-GCM-SHA256\nECDHE-ECDSA-AES128-GCM-SHA256\nECDHE-RSA-AES256-GCM-SHA384\nECDHE-ECDSA-AES256-GCM-SHA384\nDHE-RSA-AES128-GCM-SHA256\nECDHE-RSA-AES128-SHA256\nDHE-RSA-AES128-SHA256\nECDHE-RSA-AES256-SHA384\nDHE-RSA-AES256-SHA384\nECDHE-RSA-AES256-SHA256\nDHE-RSA-AES256-SHA256\nHIGH\n!aNULL\n!eNULL\n!EXPORT\n!DES\n!RC4\n!MD5\n!PSK\n!SRP\n!CAMELLIA\n</code></pre>\n<p>This default can be replaced entirely using the <a href=\"cli.html#cli_tls_cipher_list_list\"><code>--tls-cipher-list</code></a> command\nline switch (directly, or via the <a href=\"cli.html#cli_node_options_options\"><code>NODE_OPTIONS</code></a> environment variable). For\ninstance, the following makes <code>ECDHE-RSA-AES128-GCM-SHA256:!RC4</code> the default TLS\ncipher suite:</p>\n<pre><code class=\"language-bash\">node --tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4' server.js\n\nexport NODE_OPTIONS=--tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4'\nnode server.js\n</code></pre>\n<p>The default can also be replaced on a per client or server basis using the\n<code>ciphers</code> option from <a href=\"#tls_tls_createsecurecontext_options\"><code>tls.createSecureContext()</code></a>, which is also available\nin <a href=\"#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>, <a href=\"#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>, and when creating new\n<a href=\"#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a>s.</p>\n<p>The ciphers list can contain a mixture of TLSv1.3 cipher suite names, the ones\nthat start with <code>'TLS_'</code>, and specifications for TLSv1.2 and below cipher\nsuites. The TLSv1.2 ciphers support a legacy specification format, consult\nthe OpenSSL <a href=\"https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT\">cipher list format</a> documentation for details, but those\nspecifications do <em>not</em> apply to TLSv1.3 ciphers. The TLSv1.3 suites can only\nbe enabled by including their full name in the cipher list. They cannot, for\nexample, be enabled or disabled by using the legacy TLSv1.2 <code>'EECDH'</code> or\n<code>'!EECDH'</code> specification.</p>\n<p>Despite the relative order of TLSv1.3 and TLSv1.2 cipher suites, the TLSv1.3\nprotocol is significantly more secure than TLSv1.2, and will always be chosen\nover TLSv1.2 if the handshake indicates it is supported, and if any TLSv1.3\ncipher suites are enabled.</p>\n<p>The default cipher suite included within Node.js has been carefully\nselected to reflect current security best practices and risk mitigation.\nChanging the default cipher suite can have a significant impact on the security\nof an application. The <code>--tls-cipher-list</code> switch and <code>ciphers</code> option should by\nused only if absolutely necessary.</p>\n<p>The default cipher suite prefers GCM ciphers for <a href=\"https://www.chromium.org/Home/chromium-security/education/tls#TOC-Cipher-Suites\">Chrome's 'modern\ncryptography' setting</a> and also prefers ECDHE and DHE ciphers for perfect\nforward secrecy, while offering <em>some</em> backward compatibility.</p>\n<p>128 bit AES is preferred over 192 and 256 bit AES in light of <a href=\"https://www.schneier.com/blog/archives/2009/07/another_new_aes.html\">specific\nattacks affecting larger AES key sizes</a>.</p>\n<p>Old clients that rely on insecure and deprecated RC4 or DES-based ciphers\n(like Internet Explorer 6) cannot complete the handshaking process with\nthe default configuration. If these clients <em>must</em> be supported, the\n<a href=\"https://wiki.mozilla.org/Security/Server_Side_TLS\">TLS recommendations</a> may offer a compatible cipher suite. For more details\non the format, see the OpenSSL <a href=\"https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT\">cipher list format</a> documentation.</p>\n<p>There are only 5 TLSv1.3 cipher suites:</p>\n<ul>\n<li><code>'TLS_AES_256_GCM_SHA384'</code></li>\n<li><code>'TLS_CHACHA20_POLY1305_SHA256'</code></li>\n<li><code>'TLS_AES_128_GCM_SHA256'</code></li>\n<li><code>'TLS_AES_128_CCM_SHA256'</code></li>\n<li><code>'TLS_AES_128_CCM_8_SHA256'</code></li>\n</ul>\n<p>The first 3 are enabled by default. The last 2 <code>CCM</code>-based suites are supported\nby TLSv1.3 because they may be more performant on constrained systems, but they\nare not enabled by default since they offer less security.</p>",
+          "desc": "<p>Node.js is built with a default suite of enabled and disabled TLS ciphers. This\ndefault cipher list can be configured when building Node.js to allow\ndistributions to provide their own default list.</p>\n<p>The following command can be used to show the default cipher suite:</p>\n<pre><code class=\"language-console\">node -p crypto.constants.defaultCoreCipherList | tr ':' '\\n'\nTLS_AES_256_GCM_SHA384\nTLS_CHACHA20_POLY1305_SHA256\nTLS_AES_128_GCM_SHA256\nECDHE-RSA-AES128-GCM-SHA256\nECDHE-ECDSA-AES128-GCM-SHA256\nECDHE-RSA-AES256-GCM-SHA384\nECDHE-ECDSA-AES256-GCM-SHA384\nDHE-RSA-AES128-GCM-SHA256\nECDHE-RSA-AES128-SHA256\nDHE-RSA-AES128-SHA256\nECDHE-RSA-AES256-SHA384\nDHE-RSA-AES256-SHA384\nECDHE-RSA-AES256-SHA256\nDHE-RSA-AES256-SHA256\nHIGH\n!aNULL\n!eNULL\n!EXPORT\n!DES\n!RC4\n!MD5\n!PSK\n!SRP\n!CAMELLIA\n</code></pre>\n<p>This default can be replaced entirely using the <a href=\"cli.html#cli_tls_cipher_list_list\"><code>--tls-cipher-list</code></a>\ncommand-line switch (directly, or via the <a href=\"cli.html#cli_node_options_options\"><code>NODE_OPTIONS</code></a> environment\nvariable). For instance, the following makes <code>ECDHE-RSA-AES128-GCM-SHA256:!RC4</code>\nthe default TLS cipher suite:</p>\n<pre><code class=\"language-bash\">node --tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4' server.js\n\nexport NODE_OPTIONS=--tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4'\nnode server.js\n</code></pre>\n<p>The default can also be replaced on a per client or server basis using the\n<code>ciphers</code> option from <a href=\"#tls_tls_createsecurecontext_options\"><code>tls.createSecureContext()</code></a>, which is also available\nin <a href=\"#tls_tls_createserver_options_secureconnectionlistener\"><code>tls.createServer()</code></a>, <a href=\"#tls_tls_connect_options_callback\"><code>tls.connect()</code></a>, and when creating new\n<a href=\"#tls_class_tls_tlssocket\"><code>tls.TLSSocket</code></a>s.</p>\n<p>The ciphers list can contain a mixture of TLSv1.3 cipher suite names, the ones\nthat start with <code>'TLS_'</code>, and specifications for TLSv1.2 and below cipher\nsuites. The TLSv1.2 ciphers support a legacy specification format, consult\nthe OpenSSL <a href=\"https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT\">cipher list format</a> documentation for details, but those\nspecifications do <em>not</em> apply to TLSv1.3 ciphers. The TLSv1.3 suites can only\nbe enabled by including their full name in the cipher list. They cannot, for\nexample, be enabled or disabled by using the legacy TLSv1.2 <code>'EECDH'</code> or\n<code>'!EECDH'</code> specification.</p>\n<p>Despite the relative order of TLSv1.3 and TLSv1.2 cipher suites, the TLSv1.3\nprotocol is significantly more secure than TLSv1.2, and will always be chosen\nover TLSv1.2 if the handshake indicates it is supported, and if any TLSv1.3\ncipher suites are enabled.</p>\n<p>The default cipher suite included within Node.js has been carefully\nselected to reflect current security best practices and risk mitigation.\nChanging the default cipher suite can have a significant impact on the security\nof an application. The <code>--tls-cipher-list</code> switch and <code>ciphers</code> option should by\nused only if absolutely necessary.</p>\n<p>The default cipher suite prefers GCM ciphers for <a href=\"https://www.chromium.org/Home/chromium-security/education/tls#TOC-Cipher-Suites\">Chrome's 'modern\ncryptography' setting</a> and also prefers ECDHE and DHE ciphers for perfect\nforward secrecy, while offering <em>some</em> backward compatibility.</p>\n<p>128 bit AES is preferred over 192 and 256 bit AES in light of <a href=\"https://www.schneier.com/blog/archives/2009/07/another_new_aes.html\">specific\nattacks affecting larger AES key sizes</a>.</p>\n<p>Old clients that rely on insecure and deprecated RC4 or DES-based ciphers\n(like Internet Explorer 6) cannot complete the handshaking process with\nthe default configuration. If these clients <em>must</em> be supported, the\n<a href=\"https://wiki.mozilla.org/Security/Server_Side_TLS\">TLS recommendations</a> may offer a compatible cipher suite. For more details\non the format, see the OpenSSL <a href=\"https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT\">cipher list format</a> documentation.</p>\n<p>There are only 5 TLSv1.3 cipher suites:</p>\n<ul>\n<li><code>'TLS_AES_256_GCM_SHA384'</code></li>\n<li><code>'TLS_CHACHA20_POLY1305_SHA256'</code></li>\n<li><code>'TLS_AES_128_GCM_SHA256'</code></li>\n<li><code>'TLS_AES_128_CCM_SHA256'</code></li>\n<li><code>'TLS_AES_128_CCM_8_SHA256'</code></li>\n</ul>\n<p>The first 3 are enabled by default. The last 2 <code>CCM</code>-based suites are supported\nby TLSv1.3 because they may be more performant on constrained systems, but they\nare not enabled by default since they offer less security.</p>",
           "type": "module",
           "displayName": "Modifying the default TLS cipher suite"
         }
@@ -182,7 +182,8 @@
               "name": "keylog",
               "meta": {
                 "added": [
-                  "v12.3.0"
+                  "v12.3.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -428,9 +429,9 @@
                 {
                   "params": [
                     {
-                      "textRaw": "`keys` {Buffer} A 48-byte buffer containing the session ticket keys.",
+                      "textRaw": "`keys` {Buffer|TypedArray|DataView} A 48-byte buffer containing the session ticket keys.",
                       "name": "keys",
-                      "type": "Buffer",
+                      "type": "Buffer|TypedArray|DataView",
                       "desc": "A 48-byte buffer containing the session ticket keys."
                     }
                   ]
@@ -477,7 +478,8 @@
               "name": "keylog",
               "meta": {
                 "added": [
-                  "v12.3.0"
+                  "v12.3.0",
+                  "v10.20.0"
                 ],
                 "changes": []
               },
@@ -515,7 +517,7 @@
                 "changes": []
               },
               "params": [],
-              "desc": "<p>The <code>'secureConnect'</code> event is emitted after the handshaking process for a new\nconnection has successfully completed. The listener callback will be called\nregardless of whether or not the server's certificate has been authorized. It\nis the client's responsibility to check the <code>tlsSocket.authorized</code> property to\ndetermine if the server certificate was signed by one of the specified CAs. If\n<code>tlsSocket.authorized === false</code>, then the error can be found by examining the\n<code>tlsSocket.authorizationError</code> property. If ALPN was used, the\n<code>tlsSocket.alpnProtocol</code> property can be checked to determine the negotiated\nprotocol.</p>"
+              "desc": "<p>The <code>'secureConnect'</code> event is emitted after the handshaking process for a new\nconnection has successfully completed. The listener callback will be called\nregardless of whether or not the server's certificate has been authorized. It\nis the client's responsibility to check the <code>tlsSocket.authorized</code> property to\ndetermine if the server certificate was signed by one of the specified CAs. If\n<code>tlsSocket.authorized === false</code>, then the error can be found by examining the\n<code>tlsSocket.authorizationError</code> property. If ALPN was used, the\n<code>tlsSocket.alpnProtocol</code> property can be checked to determine the negotiated\nprotocol.</p>\n<p>The <code>'secureConnect'</code> event is not emitted when a <a href=\"tls.html#tls_class_tls_tlssocket\" class=\"type\">&lt;tls.TLSSocket&gt;</a> is created\nusing the <code>new tls.TLSSocket()</code> constructor.</p>"
             },
             {
               "textRaw": "Event: `'session'`",
@@ -625,15 +627,18 @@
                   "v0.11.4"
                 ],
                 "changes": [
+                  {
+                    "version": [
+                      "v13.4.0",
+                      "v12.16.0"
+                    ],
+                    "pr-url": "https://github.com/nodejs/node/pull/30637",
+                    "description": "Return the IETF cipher name as `standardName`."
+                  },
                   {
                     "version": "v12.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26625",
                     "description": "Return the minimum cipher version, instead of a fixed string (`'TLSv1/SSLv3'`)."
-                  },
-                  {
-                    "version": "v12.16.0",
-                    "pr-url": "https://github.com/nodejs/node/pull/30637",
-                    "description": "Return the IETF cipher name as `standardName`."
                   }
                 ]
               },
@@ -756,7 +761,7 @@
                       }
                     ]
                   },
-                  "desc": "<p>A certificate object has properties corresponding to the fields of the\ncertificate.</p>\n<ul>\n<li><code>raw</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The DER encoded X.509 certificate data.</li>\n<li><code>subject</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The certificate subject, described in terms of\n Country (<code>C:</code>), StateOrProvince (<code>ST</code>), Locality (<code>L</code>), Organization (<code>O</code>),\nOrganizationalUnit (<code>OU</code>), and CommonName (<code>CN</code>). The CommonName is typically\na DNS name with TLS certificates. Example:\n<code>{C: 'UK', ST: 'BC', L: 'Metro', O: 'Node Fans', OU: 'Docs', CN: 'example.com'}</code>.</li>\n<li><code>issuer</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The certificate issuer, described in the same terms as the\n <code>subject</code>.</li>\n<li><code>valid_from</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The date-time the certificate is valid from.</li>\n<li><code>valid_to</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The date-time the certificate is valid to.</li>\n<li><code>serialNumber</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The certificate serial number, as a hex string.\n Example: <code>'B9B0D332A1AA5635'</code>.</li>\n<li><code>fingerprint</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The SHA-1 digest of the DER encoded certificate. It is\nreturned as a <code>:</code> separated hexadecimal string. Example: <code>'2A:7A:C2:DD:...'</code>.</li>\n<li><code>fingerprint256</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The SHA-256 digest of the DER encoded certificate.\n It is returned as a <code>:</code> separated hexadecimal string. Example:\n<code>'2A:7A:C2:DD:...'</code>.</li>\n<li><code>ext_key_usage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\" class=\"type\">&lt;Array&gt;</a> (Optional) The extended key usage, a set of OIDs.</li>\n<li><code>subjectaltname</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) A string containing concatenated names\nfor the subject, an alternative to the <code>subject</code> names.</li>\n<li><code>infoAccess</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\" class=\"type\">&lt;Array&gt;</a> (Optional) An array describing the AuthorityInfoAccess,\n used with OCSP.</li>\n<li><code>issuerCertificate</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> (Optional) The issuer certificate object. For\n self-signed certificates, this may be a circular reference.</li>\n</ul>\n<p>The certificate may contain information about the public key, depending on\nthe key type.</p>\n<p>For RSA keys, the following properties may be defined:</p>\n<ul>\n<li><code>bits</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The RSA bit size. Example: <code>1024</code>.</li>\n<li><code>exponent</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The RSA exponent, as a string in hexadecimal number\nnotation. Example: <code>'0x010001'</code>.</li>\n<li><code>modulus</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The RSA modulus, as a hexadecimal string. Example:\n <code>'B56CE45CB7...'</code>.</li>\n<li><code>pubkey</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The public key.</li>\n</ul>\n<p>For EC keys, the following properties may be defined:</p>\n<ul>\n<li><code>pubkey</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The public key.</li>\n<li><code>bits</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The key size in bits. Example: <code>256</code>.</li>\n<li><code>asn1Curve</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) The ASN.1 name of the OID of the elliptic\ncurve. Well-known curves are identified by an OID. While it is unusual, it is\npossible that the curve is identified by its mathematical properties, in which\ncase it will not have an OID. Example: <code>'prime256v1'</code>.</li>\n<li><code>nistCurve</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) The NIST name for the elliptic curve, if it\nhas one (not all well-known curves have been assigned names by NIST). Example:\n<code>'P-256'</code>.</li>\n</ul>\n<p>Example certificate:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{ subject:\n   { OU: [ 'Domain Control Validated', 'PositiveSSL Wildcard' ],\n     CN: '*.nodejs.org' },\n  issuer:\n   { C: 'GB',\n     ST: 'Greater Manchester',\n     L: 'Salford',\n     O: 'COMODO CA Limited',\n     CN: 'COMODO RSA Domain Validation Secure Server CA' },\n  subjectaltname: 'DNS:*.nodejs.org, DNS:nodejs.org',\n  infoAccess:\n   { 'CA Issuers - URI':\n      [ 'http://crt.comodoca.com/COMODORSADomainValidationSecureServerCA.crt' ],\n     'OCSP - URI': [ 'http://ocsp.comodoca.com' ] },\n  modulus: 'B56CE45CB740B09A13F64AC543B712FF9EE8E4C284B542A1708A27E82A8D151CA178153E12E6DDA15BF70FFD96CB8A88618641BDFCCA03527E665B70D779C8A349A6F88FD4EF6557180BD4C98192872BCFE3AF56E863C09DDD8BC1EC58DF9D94F914F0369102B2870BECFA1348A0838C9C49BD1C20124B442477572347047506B1FCD658A80D0C44BCC16BC5C5496CFE6E4A8428EF654CD3D8972BF6E5BFAD59C93006830B5EB1056BBB38B53D1464FA6E02BFDF2FF66CD949486F0775EC43034EC2602AEFBF1703AD221DAA2A88353C3B6A688EFE8387811F645CEED7B3FE46E1F8B9F59FAD028F349B9BC14211D5830994D055EEA3D547911E07A0ADDEB8A82B9188E58720D95CD478EEC9AF1F17BE8141BE80906F1A339445A7EB5B285F68039B0F294598A7D1C0005FC22B5271B0752F58CCDEF8C8FD856FB7AE21C80B8A2CE983AE94046E53EDE4CB89F42502D31B5360771C01C80155918637490550E3F555E2EE75CC8C636DDE3633CFEDD62E91BF0F7688273694EEEBA20C2FC9F14A2A435517BC1D7373922463409AB603295CEB0BB53787A334C9CA3CA8B30005C5A62FC0715083462E00719A8FA3ED0A9828C3871360A73F8B04A4FC1E71302844E9BB9940B77E745C9D91F226D71AFCAD4B113AAF68D92B24DDB4A2136B55A1CD1ADF39605B63CB639038ED0F4C987689866743A68769CC55847E4A06D6E2E3F1',\n  exponent: '0x10001',\n  pubkey: &#x3C;Buffer ... >,\n  valid_from: 'Aug 14 00:00:00 2017 GMT',\n  valid_to: 'Nov 20 23:59:59 2019 GMT',\n  fingerprint: '01:02:59:D9:C3:D2:0D:08:F7:82:4E:44:A4:B4:53:C5:E2:3A:87:4D',\n  fingerprint256: '69:AE:1A:6A:D4:3D:C6:C1:1B:EA:C6:23:DE:BA:2A:14:62:62:93:5C:7A:EA:06:41:9B:0B:BC:87:CE:48:4E:02',\n  ext_key_usage: [ '1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2' ],\n  serialNumber: '66593D57F20CBC573E433381B5FEC280',\n  raw: &#x3C;Buffer ... > }\n</code></pre>",
+                  "desc": "<p>A certificate object has properties corresponding to the fields of the\ncertificate.</p>\n<ul>\n<li><code>raw</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The DER encoded X.509 certificate data.</li>\n<li><code>subject</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The certificate subject, described in terms of\nCountry (<code>C:</code>), StateOrProvince (<code>ST</code>), Locality (<code>L</code>), Organization (<code>O</code>),\nOrganizationalUnit (<code>OU</code>), and CommonName (<code>CN</code>). The CommonName is typically\na DNS name with TLS certificates. Example:\n<code>{C: 'UK', ST: 'BC', L: 'Metro', O: 'Node Fans', OU: 'Docs', CN: 'example.com'}</code>.</li>\n<li><code>issuer</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> The certificate issuer, described in the same terms as the\n<code>subject</code>.</li>\n<li><code>valid_from</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The date-time the certificate is valid from.</li>\n<li><code>valid_to</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The date-time the certificate is valid to.</li>\n<li><code>serialNumber</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The certificate serial number, as a hex string.\nExample: <code>'B9B0D332A1AA5635'</code>.</li>\n<li><code>fingerprint</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The SHA-1 digest of the DER encoded certificate. It is\nreturned as a <code>:</code> separated hexadecimal string. Example: <code>'2A:7A:C2:DD:...'</code>.</li>\n<li><code>fingerprint256</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The SHA-256 digest of the DER encoded certificate.\nIt is returned as a <code>:</code> separated hexadecimal string. Example:\n<code>'2A:7A:C2:DD:...'</code>.</li>\n<li><code>ext_key_usage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\" class=\"type\">&lt;Array&gt;</a> (Optional) The extended key usage, a set of OIDs.</li>\n<li><code>subjectaltname</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) A string containing concatenated names\nfor the subject, an alternative to the <code>subject</code> names.</li>\n<li><code>infoAccess</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\" class=\"type\">&lt;Array&gt;</a> (Optional) An array describing the AuthorityInfoAccess,\nused with OCSP.</li>\n<li><code>issuerCertificate</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> (Optional) The issuer certificate object. For\nself-signed certificates, this may be a circular reference.</li>\n</ul>\n<p>The certificate may contain information about the public key, depending on\nthe key type.</p>\n<p>For RSA keys, the following properties may be defined:</p>\n<ul>\n<li><code>bits</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The RSA bit size. Example: <code>1024</code>.</li>\n<li><code>exponent</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The RSA exponent, as a string in hexadecimal number\nnotation. Example: <code>'0x010001'</code>.</li>\n<li><code>modulus</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> The RSA modulus, as a hexadecimal string. Example:\n<code>'B56CE45CB7...'</code>.</li>\n<li><code>pubkey</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The public key.</li>\n</ul>\n<p>For EC keys, the following properties may be defined:</p>\n<ul>\n<li><code>pubkey</code> <a href=\"buffer.html#buffer_class_buffer\" class=\"type\">&lt;Buffer&gt;</a> The public key.</li>\n<li><code>bits</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a> The key size in bits. Example: <code>256</code>.</li>\n<li><code>asn1Curve</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) The ASN.1 name of the OID of the elliptic\ncurve. Well-known curves are identified by an OID. While it is unusual, it is\npossible that the curve is identified by its mathematical properties, in which\ncase it will not have an OID. Example: <code>'prime256v1'</code>.</li>\n<li><code>nistCurve</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> (Optional) The NIST name for the elliptic curve, if it\nhas one (not all well-known curves have been assigned names by NIST). Example:\n<code>'P-256'</code>.</li>\n</ul>\n<p>Example certificate:</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{ subject:\n   { OU: [ 'Domain Control Validated', 'PositiveSSL Wildcard' ],\n     CN: '*.nodejs.org' },\n  issuer:\n   { C: 'GB',\n     ST: 'Greater Manchester',\n     L: 'Salford',\n     O: 'COMODO CA Limited',\n     CN: 'COMODO RSA Domain Validation Secure Server CA' },\n  subjectaltname: 'DNS:*.nodejs.org, DNS:nodejs.org',\n  infoAccess:\n   { 'CA Issuers - URI':\n      [ 'http://crt.comodoca.com/COMODORSADomainValidationSecureServerCA.crt' ],\n     'OCSP - URI': [ 'http://ocsp.comodoca.com' ] },\n  modulus: 'B56CE45CB740B09A13F64AC543B712FF9EE8E4C284B542A1708A27E82A8D151CA178153E12E6DDA15BF70FFD96CB8A88618641BDFCCA03527E665B70D779C8A349A6F88FD4EF6557180BD4C98192872BCFE3AF56E863C09DDD8BC1EC58DF9D94F914F0369102B2870BECFA1348A0838C9C49BD1C20124B442477572347047506B1FCD658A80D0C44BCC16BC5C5496CFE6E4A8428EF654CD3D8972BF6E5BFAD59C93006830B5EB1056BBB38B53D1464FA6E02BFDF2FF66CD949486F0775EC43034EC2602AEFBF1703AD221DAA2A88353C3B6A688EFE8387811F645CEED7B3FE46E1F8B9F59FAD028F349B9BC14211D5830994D055EEA3D547911E07A0ADDEB8A82B9188E58720D95CD478EEC9AF1F17BE8141BE80906F1A339445A7EB5B285F68039B0F294598A7D1C0005FC22B5271B0752F58CCDEF8C8FD856FB7AE21C80B8A2CE983AE94046E53EDE4CB89F42502D31B5360771C01C80155918637490550E3F555E2EE75CC8C636DDE3633CFEDD62E91BF0F7688273694EEEBA20C2FC9F14A2A435517BC1D7373922463409AB603295CEB0BB53787A334C9CA3CA8B30005C5A62FC0715083462E00719A8FA3ED0A9828C3871360A73F8B04A4FC1E71302844E9BB9940B77E745C9D91F226D71AFCAD4B113AAF68D92B24DDB4A2136B55A1CD1ADF39605B63CB639038ED0F4C987689866743A68769CC55847E4A06D6E2E3F1',\n  exponent: '0x10001',\n  pubkey: &#x3C;Buffer ... >,\n  valid_from: 'Aug 14 00:00:00 2017 GMT',\n  valid_to: 'Nov 20 23:59:59 2019 GMT',\n  fingerprint: '01:02:59:D9:C3:D2:0D:08:F7:82:4E:44:A4:B4:53:C5:E2:3A:87:4D',\n  fingerprint256: '69:AE:1A:6A:D4:3D:C6:C1:1B:EA:C6:23:DE:BA:2A:14:62:62:93:5C:7A:EA:06:41:9B:0B:BC:87:CE:48:4E:02',\n  ext_key_usage: [ '1.3.6.1.5.5.7.3.1', '1.3.6.1.5.5.7.3.2' ],\n  serialNumber: '66593D57F20CBC573E433381B5FEC280',\n  raw: &#x3C;Buffer ... > }\n</code></pre>",
                   "type": "module",
                   "displayName": "Certificate object"
                 }
@@ -858,7 +863,7 @@
               "name": "exportKeyingMaterial",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.10.0"
                 ],
                 "changes": []
               },
@@ -1204,7 +1209,13 @@
             "added": [
               "v0.8.4"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.18.3",
+                "pr-url": "https://github.com/nodejs-private/node-private/pull/300",
+                "description": "Support for `uniformResourceIdentifier` subject alternative names has been disabled in response to CVE-2021-44531."
+              }
+            ]
           },
           "signatures": [
             {
@@ -1229,7 +1240,7 @@
               ]
             }
           ],
-          "desc": "<p>Verifies the certificate <code>cert</code> is issued to <code>hostname</code>.</p>\n<p>Returns <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\" class=\"type\">&lt;Error&gt;</a> object, populating it with <code>reason</code>, <code>host</code>, and <code>cert</code> on\nfailure. On success, returns <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type\" class=\"type\">&lt;undefined&gt;</a>.</p>\n<p>This function can be overwritten by providing alternative function as part of\nthe <code>options.checkServerIdentity</code> option passed to <code>tls.connect()</code>. The\noverwriting function can call <code>tls.checkServerIdentity()</code> of course, to augment\nthe checks done with additional verification.</p>\n<p>This function is only called if the certificate passed all other checks, such as\nbeing issued by trusted CA (<code>options.ca</code>).</p>"
+          "desc": "<p>Verifies the certificate <code>cert</code> is issued to <code>hostname</code>.</p>\n<p>Returns <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\" class=\"type\">&lt;Error&gt;</a> object, populating it with <code>reason</code>, <code>host</code>, and <code>cert</code> on\nfailure. On success, returns <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type\" class=\"type\">&lt;undefined&gt;</a>.</p>\n<p>This function can be overwritten by providing alternative function as part of\nthe <code>options.checkServerIdentity</code> option passed to <code>tls.connect()</code>. The\noverwriting function can call <code>tls.checkServerIdentity()</code> of course, to augment\nthe checks done with additional verification.</p>\n<p>This function is only called if the certificate passed all other checks, such as\nbeing issued by trusted CA (<code>options.ca</code>).</p>\n<p>Earlier versions of Node.js incorrectly accepted certificates for a given\n<code>hostname</code> if a matching <code>uniformResourceIdentifier</code> subject alternative name\nwas present (see <a href=\"https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531\">CVE-2021-44531</a>). Applications that wish to accept\n<code>uniformResourceIdentifier</code> subject alternative names can use a custom\n<code>options.checkServerIdentity</code> function that implements the desired behavior.</p>"
         },
         {
           "textRaw": "`tls.connect(options[, callback])`",
@@ -1241,7 +1252,20 @@
             ],
             "changes": [
               {
-                "version": "v12.16.0",
+                "version": "v14.18.0",
+                "pr-url": "https://github.com/nodejs/node/pull/35753",
+                "description": "Added `onread` option."
+              },
+              {
+                "version": "v14.1.0",
+                "pr-url": "https://github.com/nodejs/node/pull/32786",
+                "description": "The `highWaterMark` option is accepted now."
+              },
+              {
+                "version": [
+                  "v13.6.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/23188",
                 "description": "The `pskCallback` option is now supported."
               },
@@ -1261,7 +1285,10 @@
                 "description": "The `enableTrace` option is now supported."
               },
               {
-                "version": "v11.8.0",
+                "version": [
+                  "v11.8.0",
+                  "v10.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/25517",
                 "description": "The `timeout` option is supported now."
               },
@@ -1276,7 +1303,10 @@
                 "description": "The `ALPNProtocols` option can be a `TypedArray` or `DataView` now."
               },
               {
-                "version": "v5.3.0, v4.7.0",
+                "version": [
+                  "v5.3.0",
+                  "v4.7.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/4246",
                 "description": "The `secureContext` option is supported now."
               },
@@ -1331,11 +1361,11 @@
                       "desc": "Establish secure connection on a given socket rather than creating a new socket. Typically, this is an instance of [`net.Socket`][], but any `Duplex` stream is allowed. If this option is specified, `path`, `host` and `port` are ignored, except for certificate validation. Usually, a socket is already connected when passed to `tls.connect()`, but it can be connected later. Connection/disconnection/destruction of `socket` is the user's responsibility; calling `tls.connect()` will not cause `net.connect()` to be called."
                     },
                     {
-                      "textRaw": "`allowHalfOpen` {boolean} If the `socket` option is missing, indicates whether or not to allow the internally created socket to be half-open, otherwise the option is ignored. See the `allowHalfOpen` option of [`net.Socket`][] for details. **Default:** `false`.",
+                      "textRaw": "`allowHalfOpen` {boolean} If set to `false`, then the socket will automatically end the writable side when the readable side ends. If the `socket` option is set, this option has no effect. See the `allowHalfOpen` option of [`net.Socket`][] for details. **Default:** `false`.",
                       "name": "allowHalfOpen",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "If the `socket` option is missing, indicates whether or not to allow the internally created socket to be half-open, otherwise the option is ignored. See the `allowHalfOpen` option of [`net.Socket`][] for details."
+                      "desc": "If set to `false`, then the socket will automatically end the writable side when the readable side ends. If the `socket` option is set, this option has no effect. See the `allowHalfOpen` option of [`net.Socket`][] for details."
                     },
                     {
                       "textRaw": "`rejectUnauthorized` {boolean} If not `false`, the server certificate is verified against the list of supplied CAs. An `'error'` event is emitted if verification fails; `err.code` contains the OpenSSL error code. **Default:** `true`.",
@@ -1345,9 +1375,10 @@
                       "desc": "If not `false`, the server certificate is verified against the list of supplied CAs. An `'error'` event is emitted if verification fails; `err.code` contains the OpenSSL error code."
                     },
                     {
-                      "textRaw": "`pskCallback` {Function}",
+                      "textRaw": "`pskCallback` {Function}When negotiating TLS-PSK (pre-shared keys), this function is called with optional identity `hint` provided by the server or `null` in case of TLS 1.3 where `hint` was removed. It will be necessary to provide a custom `tls.checkServerIdentity()` for the connection as the default one will try to check host name/IP of the server against the certificate but that's not applicable for PSK because there won't be a certificate present. More information can be found in the [RFC 4279][].",
                       "name": "pskCallback",
                       "type": "Function",
+                      "desc": "When negotiating TLS-PSK (pre-shared keys), this function is called with optional identity `hint` provided by the server or `null` in case of TLS 1.3 where `hint` was removed. It will be necessary to provide a custom `tls.checkServerIdentity()` for the connection as the default one will try to check host name/IP of the server against the certificate but that's not applicable for PSK because there won't be a certificate present. More information can be found in the [RFC 4279][].",
                       "options": [
                         {
                           "textRaw": "hint: {string} optional message sent from the server to help client decide which identity to use during negotiation. Always `null` if TLS 1.3 is used.",
@@ -1356,10 +1387,10 @@
                           "desc": "optional message sent from the server to help client decide which identity to use during negotiation. Always `null` if TLS 1.3 is used."
                         },
                         {
-                          "textRaw": "Returns: {Object} in the form `{ psk: <Buffer|TypedArray|DataView>, identity: <string> }` or `null` to stop the negotiation process. `psk` must be compatible with the selected cipher's digest. `identity` must use UTF-8 encoding. When negotiating TLS-PSK (pre-shared keys), this function is called with optional identity `hint` provided by the server or `null` in case of TLS 1.3 where `hint` was removed. It will be necessary to provide a custom `tls.checkServerIdentity()` for the connection as the default one will try to check host name/IP of the server against the certificate but that's not applicable for PSK because there won't be a certificate present. More information can be found in the [RFC 4279][].",
+                          "textRaw": "Returns: {Object} in the form `{ psk: <Buffer|TypedArray|DataView>, identity: <string> }` or `null` to stop the negotiation process. `psk` must be compatible with the selected cipher's digest. `identity` must use UTF-8 encoding.",
                           "name": "return",
                           "type": "Object",
-                          "desc": "in the form `{ psk: <Buffer|TypedArray|DataView>, identity: <string> }` or `null` to stop the negotiation process. `psk` must be compatible with the selected cipher's digest. `identity` must use UTF-8 encoding. When negotiating TLS-PSK (pre-shared keys), this function is called with optional identity `hint` provided by the server or `null` in case of TLS 1.3 where `hint` was removed. It will be necessary to provide a custom `tls.checkServerIdentity()` for the connection as the default one will try to check host name/IP of the server against the certificate but that's not applicable for PSK because there won't be a certificate present. More information can be found in the [RFC 4279][]."
+                          "desc": "in the form `{ psk: <Buffer|TypedArray|DataView>, identity: <string> }` or `null` to stop the negotiation process. `psk` must be compatible with the selected cipher's digest. `identity` must use UTF-8 encoding."
                         }
                       ]
                     },
@@ -1393,11 +1424,24 @@
                       "default": "`1024`",
                       "desc": "Minimum size of the DH parameter in bits to accept a TLS connection. When a server offers a DH parameter with a size less than `minDHSize`, the TLS connection is destroyed and an error is thrown."
                     },
+                    {
+                      "textRaw": "`highWaterMark`: {number} Consistent with the readable stream `highWaterMark` parameter. **Default:** `16 * 1024`.",
+                      "name": "highWaterMark",
+                      "type": "number",
+                      "default": "`16 * 1024`",
+                      "desc": "Consistent with the readable stream `highWaterMark` parameter."
+                    },
                     {
                       "textRaw": "`secureContext`: TLS context object created with [`tls.createSecureContext()`][]. If a `secureContext` is _not_ provided, one will be created by passing the entire `options` object to `tls.createSecureContext()`.",
                       "name": "secureContext",
                       "desc": "TLS context object created with [`tls.createSecureContext()`][]. If a `secureContext` is _not_ provided, one will be created by passing the entire `options` object to `tls.createSecureContext()`."
                     },
+                    {
+                      "textRaw": "`onread` {Object} If the `socket` option is missing, incoming data is stored in a single `buffer` and passed to the supplied `callback` when data arrives on the socket, otherwise the option is ignored. See the `onread` option of [`net.Socket`][] for details.",
+                      "name": "onread",
+                      "type": "Object",
+                      "desc": "If the `socket` option is missing, incoming data is stored in a single `buffer` and passed to the supplied `callback` when data arrives on the socket, otherwise the option is ignored. See the `onread` option of [`net.Socket`][] for details."
+                    },
                     {
                       "textRaw": "...: [`tls.createSecureContext()`][] options that are used if the `secureContext` option is missing, otherwise they are ignored.",
                       "name": "...",
@@ -1538,7 +1582,10 @@
                 "description": "The `ca:` option now supports `BEGIN TRUSTED CERTIFICATE`."
               },
               {
-                "version": "v11.4.0",
+                "version": [
+                  "v11.4.0",
+                  "v10.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/24405",
                 "description": "The `minVersion` and `maxVersion` can be used to restrict the allowed TLS protocol versions."
               },
@@ -1651,18 +1698,18 @@
                       "desc": "Identifier of a private key managed by an OpenSSL engine. Should be used together with `privateKeyEngine`. Should not be set together with `key`, because both options define a private key in different ways."
                     },
                     {
-                      "textRaw": "`maxVersion` {string} Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other. **Default:** [`tls.DEFAULT_MAX_VERSION`][].",
+                      "textRaw": "`maxVersion` {string} Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option; use one or the other. **Default:** [`tls.DEFAULT_MAX_VERSION`][].",
                       "name": "maxVersion",
                       "type": "string",
                       "default": "[`tls.DEFAULT_MAX_VERSION`][]",
-                      "desc": "Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other."
+                      "desc": "Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option; use one or the other."
                     },
                     {
-                      "textRaw": "`minVersion` {string} Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other. It is not recommended to use less than TLSv1.2, but it may be required for interoperability. **Default:** [`tls.DEFAULT_MIN_VERSION`][].",
+                      "textRaw": "`minVersion` {string} Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option; use one or the other. Avoid setting to less than TLSv1.2, but it may be required for interoperability. **Default:** [`tls.DEFAULT_MIN_VERSION`][].",
                       "name": "minVersion",
                       "type": "string",
                       "default": "[`tls.DEFAULT_MIN_VERSION`][]",
-                      "desc": "Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other. It is not recommended to use less than TLSv1.2, but it may be required for interoperability."
+                      "desc": "Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option; use one or the other. Avoid setting to less than TLSv1.2, but it may be required for interoperability."
                     },
                     {
                       "textRaw": "`passphrase` {string} Shared passphrase used for a single private key and/or a PFX.",
@@ -1931,9 +1978,10 @@
                       "desc": "48-bytes of cryptographically strong pseudo-random data. See [Session Resumption][] for more information."
                     },
                     {
-                      "textRaw": "`pskCallback` {Function}",
+                      "textRaw": "`pskCallback` {Function}When negotiating TLS-PSK (pre-shared keys), this function is called with the identity provided by the client. If the return value is `null` the negotiation process will stop and an \"unknown_psk_identity\" alert message will be sent to the other party. If the server wishes to hide the fact that the PSK identity was not known, the callback must provide some random data as `psk` to make the connection fail with \"decrypt_error\" before negotiation is finished. PSK ciphers are disabled by default, and using TLS-PSK thus requires explicitly specifying a cipher suite with the `ciphers` option. More information can be found in the [RFC 4279][].",
                       "name": "pskCallback",
                       "type": "Function",
+                      "desc": "When negotiating TLS-PSK (pre-shared keys), this function is called with the identity provided by the client. If the return value is `null` the negotiation process will stop and an \"unknown_psk_identity\" alert message will be sent to the other party. If the server wishes to hide the fact that the PSK identity was not known, the callback must provide some random data as `psk` to make the connection fail with \"decrypt_error\" before negotiation is finished. PSK ciphers are disabled by default, and using TLS-PSK thus requires explicitly specifying a cipher suite with the `ciphers` option. More information can be found in the [RFC 4279][].",
                       "options": [
                         {
                           "textRaw": "socket: {tls.TLSSocket} the server [`tls.TLSSocket`][] instance for this connection.",
@@ -1948,10 +1996,10 @@
                           "desc": "identity parameter sent from the client."
                         },
                         {
-                          "textRaw": "Returns: {Buffer|TypedArray|DataView} pre-shared key that must either be a buffer or `null` to stop the negotiation process. Returned PSK must be compatible with the selected cipher's digest. When negotiating TLS-PSK (pre-shared keys), this function is called with the identity provided by the client. If the return value is `null` the negotiation process will stop and an \"unknown_psk_identity\" alert message will be sent to the other party. If the server wishes to hide the fact that the PSK identity was not known, the callback must provide some random data as `psk` to make the connection fail with \"decrypt_error\" before negotiation is finished. PSK ciphers are disabled by default, and using TLS-PSK thus requires explicitly specifying a cipher suite with the `ciphers` option. More information can be found in the [RFC 4279][].",
+                          "textRaw": "Returns: {Buffer|TypedArray|DataView} pre-shared key that must either be a buffer or `null` to stop the negotiation process. Returned PSK must be compatible with the selected cipher's digest.",
                           "name": "return",
                           "type": "Buffer|TypedArray|DataView",
-                          "desc": "pre-shared key that must either be a buffer or `null` to stop the negotiation process. Returned PSK must be compatible with the selected cipher's digest. When negotiating TLS-PSK (pre-shared keys), this function is called with the identity provided by the client. If the return value is `null` the negotiation process will stop and an \"unknown_psk_identity\" alert message will be sent to the other party. If the server wishes to hide the fact that the PSK identity was not known, the callback must provide some random data as `psk` to make the connection fail with \"decrypt_error\" before negotiation is finished. PSK ciphers are disabled by default, and using TLS-PSK thus requires explicitly specifying a cipher suite with the `ciphers` option. More information can be found in the [RFC 4279][]."
+                          "desc": "pre-shared key that must either be a buffer or `null` to stop the negotiation process. Returned PSK must be compatible with the selected cipher's digest."
                         }
                       ]
                     },
diff --git a/doc/api/tls.md b/doc/api/tls.md
index c9fabbc5b59cf998306bfe9ea52b38fe5aea57c6..271dd095fbdd78f29997cb83d3e555c211e9b1de 100644
--- a/doc/api/tls.md
+++ b/doc/api/tls.md
@@ -308,10 +308,10 @@ HIGH
 !CAMELLIA
 ```
 
-This default can be replaced entirely using the [`--tls-cipher-list`][] command
-line switch (directly, or via the [`NODE_OPTIONS`][] environment variable). For
-instance, the following makes `ECDHE-RSA-AES128-GCM-SHA256:!RC4` the default TLS
-cipher suite:
+This default can be replaced entirely using the [`--tls-cipher-list`][]
+command-line switch (directly, or via the [`NODE_OPTIONS`][] environment
+variable). For instance, the following makes `ECDHE-RSA-AES128-GCM-SHA256:!RC4`
+the default TLS cipher suite:
 
 ```bash
 node --tls-cipher-list='ECDHE-RSA-AES128-GCM-SHA256:!RC4' server.js
@@ -440,7 +440,9 @@ into the TLS server. In that case, any [`Duplex`][] stream can be passed.
 
 ### Event: `'keylog'`
 <!-- YAML
-added: v12.3.0
+added:
+ - v12.3.0
+ - v10.20.0
 -->
 
 * `line` {Buffer} Line of ASCII text, in NSS `SSLKEYLOGFILE` format.
@@ -642,7 +644,7 @@ added: v0.3.2
 -->
 
 * `callback` {Function} A listener callback that will be registered to listen
-for the server instance's `'close'` event.
+  for the server instance's `'close'` event.
 * Returns: {tls.Server}
 
 The `server.close()` method stops the server from accepting new connections.
@@ -695,7 +697,8 @@ existing server. Existing connections to the server are not interrupted.
 added: v3.0.0
 -->
 
-* `keys` {Buffer} A 48-byte buffer containing the session ticket keys.
+* `keys` {Buffer|TypedArray|DataView} A 48-byte buffer containing the session
+  ticket keys.
 
 Sets the session ticket keys.
 
@@ -764,7 +767,9 @@ Construct a new `tls.TLSSocket` object from an existing TCP socket.
 
 ### Event: `'keylog'`
 <!-- YAML
-added: v12.3.0
+added:
+ - v12.3.0
+ - v10.20.0
 -->
 
 * `line` {Buffer} Line of ASCII text, in NSS `SSLKEYLOGFILE` format.
@@ -812,6 +817,9 @@ determine if the server certificate was signed by one of the specified CAs. If
 `tlsSocket.alpnProtocol` property can be checked to determine the negotiated
 protocol.
 
+The `'secureConnect'` event is not emitted when a {tls.TLSSocket} is created
+using the `new tls.TLSSocket()` constructor.
+
 ### Event: `'session'`
 <!-- YAML
 added: v11.10.0
@@ -929,13 +937,15 @@ socket has been destroyed, `null` will be returned.
 <!-- YAML
 added: v0.11.4
 changes:
+  - version:
+     - v13.4.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/30637
+    description: Return the IETF cipher name as `standardName`.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26625
     description: Return the minimum cipher version, instead of a fixed string
       (`'TLSv1/SSLv3'`).
-  - version: v12.16.0
-    pr-url: https://github.com/nodejs/node/pull/30637
-    description: Return the IETF cipher name as `standardName`.
 -->
 
 * Returns: {Object}
@@ -981,8 +991,8 @@ added: v9.9.0
 -->
 
 * Returns: {Buffer|undefined} The latest `Finished` message that has been
-sent to the socket as part of a SSL/TLS handshake, or `undefined` if
-no `Finished` message has been sent yet.
+  sent to the socket as part of a SSL/TLS handshake, or `undefined` if
+  no `Finished` message has been sent yet.
 
 As the `Finished` messages are message digests of the complete handshake
 (with a total of 192 bits for TLS 1.0 and more for SSL 3.0), they can
@@ -1039,7 +1049,7 @@ certificate.
    `'2A:7A:C2:DD:...'`.
 * `ext_key_usage` {Array} (Optional) The extended key usage, a set of OIDs.
 * `subjectaltname` {string} (Optional) A string containing concatenated names
- for the subject, an alternative to the `subject` names.
+   for the subject, an alternative to the `subject` names.
 * `infoAccess` {Array} (Optional) An array describing the AuthorityInfoAccess,
    used with OCSP.
 * `issuerCertificate` {Object} (Optional) The issuer certificate object. For
@@ -1105,8 +1115,8 @@ added: v9.9.0
 -->
 
 * Returns: {Buffer|undefined} The latest `Finished` message that is expected
-or has actually been received from the socket as part of a SSL/TLS handshake,
-or `undefined` if there is no `Finished` message so far.
+  or has actually been received from the socket as part of a SSL/TLS handshake,
+  or `undefined` if there is no `Finished` message so far.
 
 As the `Finished` messages are message digests of the complete handshake
 (with a total of 192 bits for TLS 1.0 and more for SSL 3.0), they can
@@ -1161,7 +1171,7 @@ added: v12.11.0
 -->
 
 * Returns: {Array} List of signature algorithms shared between the server and
-the client in the order of decreasing preference.
+  the client in the order of decreasing preference.
 
 See
 [SSL_get_shared_sigalgs](https://www.openssl.org/docs/man1.1.1/man3/SSL_get_shared_sigalgs.html)
@@ -1169,13 +1179,13 @@ for more information.
 
 ### `tlsSocket.exportKeyingMaterial(length, label[, context])`
 <!-- YAML
-added: v12.17.0
+added: v13.10.0
 -->
 
 * `length` {number} number of bytes to retrieve from keying material
 * `label` {string} an application specific label, typically this will be a
-value from the
-[IANA Exporter Label Registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#exporter-labels).
+  value from the
+  [IANA Exporter Label Registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#exporter-labels).
 * `context` {Buffer} Optionally provide a context.
 
 * Returns: {Buffer} requested bytes of the keying material
@@ -1323,6 +1333,11 @@ decrease overall server throughput.
 ## `tls.checkServerIdentity(hostname, cert)`
 <!-- YAML
 added: v0.8.4
+changes:
+  - version: v14.18.3
+    pr-url: https://github.com/nodejs-private/node-private/pull/300
+    description: Support for `uniformResourceIdentifier` subject alternative
+                 names has been disabled in response to CVE-2021-44531.
 -->
 
 * `hostname` {string} The host name or IP address to verify the certificate
@@ -1343,11 +1358,25 @@ the checks done with additional verification.
 This function is only called if the certificate passed all other checks, such as
 being issued by trusted CA (`options.ca`).
 
+Earlier versions of Node.js incorrectly accepted certificates for a given
+`hostname` if a matching `uniformResourceIdentifier` subject alternative name
+was present (see [CVE-2021-44531][]). Applications that wish to accept
+`uniformResourceIdentifier` subject alternative names can use a custom
+`options.checkServerIdentity` function that implements the desired behavior.
+
 ## `tls.connect(options[, callback])`
 <!-- YAML
 added: v0.11.3
 changes:
-  - version: v12.16.0
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/35753
+    description: Added `onread` option.
+  - version: v14.1.0
+    pr-url: https://github.com/nodejs/node/pull/32786
+    description: The `highWaterMark` option is accepted now.
+  - version:
+     - v13.6.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/23188
     description: The `pskCallback` option is now supported.
   - version: v12.9.0
@@ -1359,7 +1388,9 @@ changes:
   - version: v12.2.0
     pr-url: https://github.com/nodejs/node/pull/27497
     description: The `enableTrace` option is now supported.
-  - version: v11.8.0
+  - version:
+     - v11.8.0
+     - v10.16.0
     pr-url: https://github.com/nodejs/node/pull/25517
     description: The `timeout` option is supported now.
   - version: v8.0.0
@@ -1369,7 +1400,9 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/11984
     description: The `ALPNProtocols` option can be a `TypedArray` or
      `DataView` now.
-  - version: v5.3.0, v4.7.0
+  - version:
+    - v5.3.0
+    - v4.7.0
     pr-url: https://github.com/nodejs/node/pull/4246
     description: The `secureContext` option is supported now.
   - version: v5.0.0
@@ -1393,10 +1426,10 @@ changes:
     Connection/disconnection/destruction of `socket` is the user's
     responsibility; calling `tls.connect()` will not cause `net.connect()` to be
     called.
-  * `allowHalfOpen` {boolean} If the `socket` option is missing, indicates
-    whether or not to allow the internally created socket to be half-open,
-    otherwise the option is ignored. See the `allowHalfOpen` option of
-    [`net.Socket`][] for details. **Default:** `false`.
+  * `allowHalfOpen` {boolean} If set to `false`, then the socket will
+    automatically end the writable side when the readable side ends. If the
+    `socket` option is set, this option has no effect. See the `allowHalfOpen`
+    option of [`net.Socket`][] for details. **Default:** `false`.
   * `rejectUnauthorized` {boolean} If not `false`, the server certificate is
     verified against the list of supplied CAs. An `'error'` event is emitted if
     verification fails; `err.code` contains the OpenSSL error code. **Default:**
@@ -1443,10 +1476,16 @@ changes:
     TLS connection. When a server offers a DH parameter with a size less
     than `minDHSize`, the TLS connection is destroyed and an error is thrown.
     **Default:** `1024`.
+  * `highWaterMark`: {number} Consistent with the readable stream `highWaterMark` parameter.
+    **Default:** `16 * 1024`.
   * `secureContext`: TLS context object created with
     [`tls.createSecureContext()`][]. If a `secureContext` is _not_ provided, one
     will be created by passing the entire `options` object to
     `tls.createSecureContext()`.
+  * `onread` {Object} If the `socket` option is missing, incoming data is
+    stored in a single `buffer` and passed to the supplied `callback` when
+    data arrives on the socket, otherwise the option is ignored. See the
+    `onread` option of [`net.Socket`][] for details.
   * ...: [`tls.createSecureContext()`][] options that are used if the
     `secureContext` option is missing, otherwise they are ignored.
   * ...: Any [`socket.connect()`][] option not already listed.
@@ -1549,7 +1588,9 @@ changes:
   - version: v11.5.0
     pr-url: https://github.com/nodejs/node/pull/24733
     description: The `ca:` option now supports `BEGIN TRUSTED CERTIFICATE`.
-  - version: v11.4.0
+  - version:
+     - v11.4.0
+     - v10.16.0
     pr-url: https://github.com/nodejs/node/pull/24405
     description: The `minVersion` and `maxVersion` can be used to restrict
                  the allowed TLS protocol versions.
@@ -1651,12 +1692,12 @@ changes:
     private key in different ways.
   * `maxVersion` {string} Optionally set the maximum TLS version to allow. One
     of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified
-    along with the `secureProtocol` option, use one or the other.
+    along with the `secureProtocol` option; use one or the other.
     **Default:** [`tls.DEFAULT_MAX_VERSION`][].
   * `minVersion` {string} Optionally set the minimum TLS version to allow. One
     of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified
-    along with the `secureProtocol` option, use one or the other. It is not
-    recommended to use less than TLSv1.2, but it may be required for
+    along with the `secureProtocol` option; use one or the other. Avoid
+    setting to less than TLSv1.2, but it may be required for
     interoperability.
     **Default:** [`tls.DEFAULT_MIN_VERSION`][].
   * `passphrase` {string} Shared passphrase used for a single private key and/or
@@ -1967,27 +2008,43 @@ added: v11.4.0
   `'TLSv1.3'`. If multiple of the options are provided, the lowest minimum is
   used.
 
+[CVE-2021-44531]: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531
+[Chrome's 'modern cryptography' setting]: https://www.chromium.org/Home/chromium-security/education/tls#TOC-Cipher-Suites
+[DHE]: https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
+[ECDHE]: https://en.wikipedia.org/wiki/Elliptic_curve_Diffie%E2%80%93Hellman
+[Mozilla's publicly trusted list of CAs]: https://hg.mozilla.org/mozilla-central/raw-file/tip/security/nss/lib/ckfw/builtins/certdata.txt
+[OCSP request]: https://en.wikipedia.org/wiki/OCSP_stapling
+[OpenSSL Options]: crypto.md#crypto_openssl_options
+[RFC 2246]: https://www.ietf.org/rfc/rfc2246.txt
+[RFC 4086]: https://tools.ietf.org/html/rfc4086
+[RFC 4279]: https://tools.ietf.org/html/rfc4279
+[RFC 5077]: https://tools.ietf.org/html/rfc5077
+[RFC 5929]: https://tools.ietf.org/html/rfc5929
+[SSL_METHODS]: https://www.openssl.org/docs/man1.1.1/man7/ssl.html#Dealing-with-Protocol-Methods
+[Session Resumption]: #tls_session_resumption
+[Stream]: stream.md#stream_stream
+[TLS recommendations]: https://wiki.mozilla.org/Security/Server_Side_TLS
 [`'newSession'`]: #tls_event_newsession
 [`'resumeSession'`]: #tls_event_resumesession
 [`'secureConnect'`]: #tls_event_secureconnect
 [`'secureConnection'`]: #tls_event_secureconnection
 [`'session'`]: #tls_event_session
-[`--tls-cipher-list`]: cli.html#cli_tls_cipher_list_list
-[`NODE_OPTIONS`]: cli.html#cli_node_options_options
+[`--tls-cipher-list`]: cli.md#cli_tls_cipher_list_list
+[`Duplex`]: stream.md#stream_class_stream_duplex
+[`NODE_OPTIONS`]: cli.md#cli_node_options_options
 [`SSL_export_keying_material`]: https://www.openssl.org/docs/man1.1.1/man3/SSL_export_keying_material.html
 [`SSL_get_version`]: https://www.openssl.org/docs/man1.1.1/man3/SSL_get_version.html
-[`crypto.getCurves()`]: crypto.html#crypto_crypto_getcurves
-[`Duplex`]: stream.html#stream_class_stream_duplex
-[`net.createServer()`]: net.html#net_net_createserver_options_connectionlistener
-[`net.Server.address()`]: net.html#net_server_address
-[`net.Server`]: net.html#net_class_net_server
-[`net.Socket`]: net.html#net_class_net_socket
+[`crypto.getCurves()`]: crypto.md#crypto_crypto_getcurves
+[`net.Server.address()`]: net.md#net_server_address
+[`net.Server`]: net.md#net_class_net_server
+[`net.Socket`]: net.md#net_class_net_socket
+[`net.createServer()`]: net.md#net_net_createserver_options_connectionlistener
 [`server.addContext()`]: #tls_server_addcontext_hostname_context
-[`server.getConnections()`]: net.html#net_server_getconnections_callback
+[`server.getConnections()`]: net.md#net_server_getconnections_callback
 [`server.getTicketKeys()`]: #tls_server_getticketkeys
-[`server.listen()`]: net.html#net_server_listen
+[`server.listen()`]: net.md#net_server_listen
 [`server.setTicketKeys()`]: #tls_server_setticketkeys_keys
-[`socket.connect()`]: net.html#net_socket_connect_options_connectlistener
+[`socket.connect()`]: net.md#net_socket_connect_options_connectlistener
 [`tls.DEFAULT_ECDH_CURVE`]: #tls_tls_default_ecdh_curve
 [`tls.DEFAULT_MAX_VERSION`]: #tls_tls_default_max_version
 [`tls.DEFAULT_MIN_VERSION`]: #tls_tls_default_min_version
@@ -2003,25 +2060,10 @@ added: v11.4.0
 [`tls.createServer()`]: #tls_tls_createserver_options_secureconnectionlistener
 [`tls.getCiphers()`]: #tls_tls_getciphers
 [`tls.rootCertificates`]: #tls_tls_rootcertificates
-[Chrome's 'modern cryptography' setting]: https://www.chromium.org/Home/chromium-security/education/tls#TOC-Cipher-Suites
-[DHE]: https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
-[ECDHE]: https://en.wikipedia.org/wiki/Elliptic_curve_Diffie%E2%80%93Hellman
-[forward secrecy]: https://en.wikipedia.org/wiki/Perfect_forward_secrecy
-[Mozilla's publicly trusted list of CAs]: https://hg.mozilla.org/mozilla-central/raw-file/tip/security/nss/lib/ckfw/builtins/certdata.txt
-[OCSP request]: https://en.wikipedia.org/wiki/OCSP_stapling
-[OpenSSL Options]: crypto.html#crypto_openssl_options
-[perfect forward secrecy]: #tls_perfect_forward_secrecy
-[RFC 2246]: https://www.ietf.org/rfc/rfc2246.txt
-[RFC 5077]: https://tools.ietf.org/html/rfc5077
-[RFC 5929]: https://tools.ietf.org/html/rfc5929
-[SSL_METHODS]: https://www.openssl.org/docs/man1.1.1/man7/ssl.html#Dealing-with-Protocol-Methods
-[Session Resumption]: #tls_session_resumption
-[Stream]: stream.html#stream_stream
-[TLS recommendations]: https://wiki.mozilla.org/Security/Server_Side_TLS
 [asn1.js]: https://www.npmjs.com/package/asn1.js
 [certificate object]: #tls_certificate_object
 [cipher list format]: https://www.openssl.org/docs/man1.1.1/man1/ciphers.html#CIPHER-LIST-FORMAT
+[forward secrecy]: https://en.wikipedia.org/wiki/Perfect_forward_secrecy
 [modifying the default cipher suite]: #tls_modifying_the_default_tls_cipher_suite
+[perfect forward secrecy]: #tls_perfect_forward_secrecy
 [specific attacks affecting larger AES key sizes]: https://www.schneier.com/blog/archives/2009/07/another_new_aes.html
-[RFC 4279]: https://tools.ietf.org/html/rfc4279
-[RFC 4086]: https://tools.ietf.org/html/rfc4086
diff --git a/doc/api/tracing.html b/doc/api/tracing.html
index 0b450257fd9c3b960711a48b161fdee793ae8d30..259dfd06535a28c73d606f266083e9b9214eed07 100644
--- a/doc/api/tracing.html
+++ b/doc/api/tracing.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Trace events | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Trace events | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="tracing" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/tracing.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/tracing.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/tracing.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/tracing.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/tracing.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/tracing.html">13.x</a></li>
@@ -113,15 +128,13 @@
 <li><a href="https://nodejs.org/docs/latest-v7.x/api/tracing.html">7.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/tracing.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/tracing.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_1"><a href="#tracing_trace_events">Trace events</a></span>
 <ul>
 <li><a href="#tracing_the_trace_events_module">The <code>trace_events</code> module</a>
@@ -140,14 +153,13 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Trace events<span><a class="mark" href="#tracing_trace_events" id="tracing_trace_events">#</a></span></h1>
+        <h2>Trace events<span><a class="mark" href="#tracing_trace_events" id="tracing_trace_events">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/trace_events.js">lib/trace_events.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/trace_events.js">lib/trace_events.js</a></p>
 <p>The <code>trace_events</code> module provides a mechanism to centralize tracing information
 generated by V8, Node.js core, and userspace code.</p>
 <p>Tracing can be enabled with the <code>--trace-event-categories</code> command-line flag
@@ -192,12 +204,12 @@ flag to enable trace events. This requirement has been removed. However, the
 node --trace-event-categories v8,node,node.async_hooks</code></pre>
 <p>Alternatively, trace events may be enabled using the <code>trace_events</code> module:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> trace_events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'trace_events'</span>);
-<span class="hljs-keyword">const</span> tracing = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>] });
-tracing.enable();  <span class="hljs-comment">// Enable trace event capture for the 'node.perf' category</span>
+<span class="hljs-keyword">const</span> tracing = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>] });
+tracing.<span class="hljs-title function_">enable</span>();  <span class="hljs-comment">// Enable trace event capture for the 'node.perf' category</span>
 
 <span class="hljs-comment">// do work</span>
 
-tracing.disable();  <span class="hljs-comment">// Disable trace event capture for the 'node.perf' category</span></code></pre>
+tracing.<span class="hljs-title function_">disable</span>();  <span class="hljs-comment">// Disable trace event capture for the 'node.perf' category</span></code></pre>
 <p>Running Node.js with tracing enabled will produce log files that can be opened
 in the <a href="https://www.chromium.org/developers/how-tos/trace-event-profiling-tool"><code>chrome://tracing</code></a>
 tab of Chrome.</p>
@@ -211,11 +223,11 @@ as the one used by <code>process.hrtime()</code>.
 However the trace-event timestamps are expressed in microseconds,
 unlike <code>process.hrtime()</code> which returns nanoseconds.</p>
 <p>The features from this module are not available in <a href="worker_threads.html#worker_threads_class_worker"><code>Worker</code></a> threads.</p>
-<h2>The <code>trace_events</code> module<span><a class="mark" href="#tracing_the_trace_events_module" id="tracing_the_trace_events_module">#</a></span></h2>
+<section><h3>The <code>trace_events</code> module<span><a class="mark" href="#tracing_the_trace_events_module" id="tracing_the_trace_events_module">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
-<h3><code>Tracing</code> object<span><a class="mark" href="#tracing_tracing_object" id="tracing_tracing_object">#</a></span></h3>
+<h4><code>Tracing</code> object<span><a class="mark" href="#tracing_tracing_object" id="tracing_tracing_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -226,7 +238,7 @@ method.</p>
 <code>tracing.enable()</code> method adds the categories to the set of enabled trace event
 categories. Calling <code>tracing.disable()</code> will remove the categories from the
 set of enabled trace event categories.</p>
-<h4><code>tracing.categories</code><span><a class="mark" href="#tracing_tracing_categories" id="tracing_tracing_categories">#</a></span></h4>
+<h5><code>tracing.categories</code><span><a class="mark" href="#tracing_tracing_categories" id="tracing_tracing_categories">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -235,7 +247,7 @@ set of enabled trace event categories.</p>
 </ul>
 <p>A comma-separated list of the trace event categories covered by this
 <code>Tracing</code> object.</p>
-<h4><code>tracing.disable()</code><span><a class="mark" href="#tracing_tracing_disable" id="tracing_tracing_disable">#</a></span></h4>
+<h5><code>tracing.disable()</code><span><a class="mark" href="#tracing_tracing_disable" id="tracing_tracing_disable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -243,32 +255,32 @@ set of enabled trace event categories.</p>
 <p>Only trace event categories <em>not</em> covered by other enabled <code>Tracing</code> objects
 and <em>not</em> specified by the <code>--trace-event-categories</code> flag will be disabled.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> trace_events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'trace_events'</span>);
-<span class="hljs-keyword">const</span> t1 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node'</span>, <span class="hljs-string">'v8'</span>] });
-<span class="hljs-keyword">const</span> t2 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>, <span class="hljs-string">'node'</span>] });
-t1.enable();
-t2.enable();
+<span class="hljs-keyword">const</span> t1 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node'</span>, <span class="hljs-string">'v8'</span>] });
+<span class="hljs-keyword">const</span> t2 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>, <span class="hljs-string">'node'</span>] });
+t1.<span class="hljs-title function_">enable</span>();
+t2.<span class="hljs-title function_">enable</span>();
 
 <span class="hljs-comment">// Prints 'node,node.perf,v8'</span>
-<span class="hljs-built_in">console</span>.log(trace_events.getEnabledCategories());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(trace_events.<span class="hljs-title function_">getEnabledCategories</span>());
 
-t2.disable(); <span class="hljs-comment">// Will only disable emission of the 'node.perf' category</span>
+t2.<span class="hljs-title function_">disable</span>(); <span class="hljs-comment">// Will only disable emission of the 'node.perf' category</span>
 
 <span class="hljs-comment">// Prints 'node,v8'</span>
-<span class="hljs-built_in">console</span>.log(trace_events.getEnabledCategories());</code></pre>
-<h4><code>tracing.enable()</code><span><a class="mark" href="#tracing_tracing_enable" id="tracing_tracing_enable">#</a></span></h4>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(trace_events.<span class="hljs-title function_">getEnabledCategories</span>());</code></pre>
+<h5><code>tracing.enable()</code><span><a class="mark" href="#tracing_tracing_enable" id="tracing_tracing_enable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 <p>Enables this <code>Tracing</code> object for the set of categories covered by the
 <code>Tracing</code> object.</p>
-<h4><code>tracing.enabled</code><span><a class="mark" href="#tracing_tracing_enabled" id="tracing_tracing_enabled">#</a></span></h4>
+<h5><code>tracing.enabled</code><span><a class="mark" href="#tracing_tracing_enabled" id="tracing_tracing_enabled">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> only if the <code>Tracing</code> object has been enabled.</li>
 </ul>
-<h3><code>trace_events.createTracing(options)</code><span><a class="mark" href="#tracing_trace_events_createtracing_options" id="tracing_trace_events_createtracing_options">#</a></span></h3>
+<h4><code>trace_events.createTracing(options)</code><span><a class="mark" href="#tracing_trace_events_createtracing_options" id="tracing_trace_events_createtracing_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -285,11 +297,11 @@ thrown if the value cannot be coerced.</li>
 <p>Creates and returns a <code>Tracing</code> object for the given set of <code>categories</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> trace_events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'trace_events'</span>);
 <span class="hljs-keyword">const</span> categories = [<span class="hljs-string">'node.perf'</span>, <span class="hljs-string">'node.async_hooks'</span>];
-<span class="hljs-keyword">const</span> tracing = trace_events.createTracing({ categories });
-tracing.enable();
+<span class="hljs-keyword">const</span> tracing = trace_events.<span class="hljs-title function_">createTracing</span>({ categories });
+tracing.<span class="hljs-title function_">enable</span>();
 <span class="hljs-comment">// do stuff</span>
-tracing.disable();</code></pre>
-<h3><code>trace_events.getEnabledCategories()</code><span><a class="mark" href="#tracing_trace_events_getenabledcategories" id="tracing_trace_events_getenabledcategories">#</a></span></h3>
+tracing.<span class="hljs-title function_">disable</span>();</code></pre>
+<h4><code>trace_events.getEnabledCategories()</code><span><a class="mark" href="#tracing_trace_events_getenabledcategories" id="tracing_trace_events_getenabledcategories">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -304,17 +316,53 @@ enabled using the <code>--trace-event-categories</code> flag.</p>
 <code>node --trace-event-categories node.perf test.js</code> will print
 <code>'node.async_hooks,node.perf'</code> to the console.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> trace_events = <span class="hljs-built_in">require</span>(<span class="hljs-string">'trace_events'</span>);
-<span class="hljs-keyword">const</span> t1 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.async_hooks'</span>] });
-<span class="hljs-keyword">const</span> t2 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>] });
-<span class="hljs-keyword">const</span> t3 = trace_events.createTracing({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'v8'</span>] });
+<span class="hljs-keyword">const</span> t1 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.async_hooks'</span>] });
+<span class="hljs-keyword">const</span> t2 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'node.perf'</span>] });
+<span class="hljs-keyword">const</span> t3 = trace_events.<span class="hljs-title function_">createTracing</span>({ <span class="hljs-attr">categories</span>: [<span class="hljs-string">'v8'</span>] });
 
-t1.enable();
-t2.enable();
+t1.<span class="hljs-title function_">enable</span>();
+t2.<span class="hljs-title function_">enable</span>();
 
-<span class="hljs-built_in">console</span>.log(trace_events.getEnabledCategories());</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(trace_events.<span class="hljs-title function_">getEnabledCategories</span>());</code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/tracing.json b/doc/api/tracing.json
index 7a1c74c79873b7dd83811890710d4fe21692cfcc..21e91ba751ec1ec777e896d13bdc04a4afc57abb 100644
--- a/doc/api/tracing.json
+++ b/doc/api/tracing.json
@@ -8,7 +8,7 @@
       "introduced_in": "v7.7.0",
       "stability": 1,
       "stabilityText": "Experimental",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/trace_events.js\">lib/trace_events.js</a></p>\n<p>The <code>trace_events</code> module provides a mechanism to centralize tracing information\ngenerated by V8, Node.js core, and userspace code.</p>\n<p>Tracing can be enabled with the <code>--trace-event-categories</code> command-line flag\nor by using the <code>trace_events</code> module. The <code>--trace-event-categories</code> flag\naccepts a list of comma-separated category names.</p>\n<p>The available categories are:</p>\n<ul>\n<li><code>node</code>: An empty placeholder.</li>\n<li><code>node.async_hooks</code>: Enables capture of detailed <a href=\"async_hooks.html\"><code>async_hooks</code></a> trace data.\nThe <a href=\"async_hooks.html\"><code>async_hooks</code></a> events have a unique <code>asyncId</code> and a special <code>triggerId</code>\n<code>triggerAsyncId</code> property.</li>\n<li><code>node.bootstrap</code>: Enables capture of Node.js bootstrap milestones.</li>\n<li><code>node.console</code>: Enables capture of <code>console.time()</code> and <code>console.count()</code>\noutput.</li>\n<li><code>node.dns.native</code>: Enables capture of trace data for DNS queries.</li>\n<li><code>node.environment</code>: Enables capture of Node.js Environment milestones.</li>\n<li><code>node.fs.sync</code>: Enables capture of trace data for file system sync methods.</li>\n<li><code>node.perf</code>: Enables capture of <a href=\"perf_hooks.html\">Performance API</a> measurements.\n<ul>\n<li><code>node.perf.usertiming</code>: Enables capture of only Performance API User Timing\nmeasures and marks.</li>\n<li><code>node.perf.timerify</code>: Enables capture of only Performance API timerify\nmeasurements.</li>\n</ul>\n</li>\n<li><code>node.promises.rejections</code>: Enables capture of trace data tracking the number\nof unhandled Promise rejections and handled-after-rejections.</li>\n<li><code>node.vm.script</code>: Enables capture of trace data for the <code>vm</code> module's\n<code>runInNewContext()</code>, <code>runInContext()</code>, and <code>runInThisContext()</code> methods.</li>\n<li><code>v8</code>: The <a href=\"v8.html\">V8</a> events are GC, compiling, and execution related.</li>\n</ul>\n<p>By default the <code>node</code>, <code>node.async_hooks</code>, and <code>v8</code> categories are enabled.</p>\n<pre><code class=\"language-bash\">node --trace-event-categories v8,node,node.async_hooks server.js\n</code></pre>\n<p>Prior versions of Node.js required the use of the <code>--trace-events-enabled</code>\nflag to enable trace events. This requirement has been removed. However, the\n<code>--trace-events-enabled</code> flag <em>may</em> still be used and will enable the\n<code>node</code>, <code>node.async_hooks</code>, and <code>v8</code> trace event categories by default.</p>\n<pre><code class=\"language-bash\">node --trace-events-enabled\n\n# is equivalent to\n\nnode --trace-event-categories v8,node,node.async_hooks\n</code></pre>\n<p>Alternatively, trace events may be enabled using the <code>trace_events</code> module:</p>\n<pre><code class=\"language-js\">const trace_events = require('trace_events');\nconst tracing = trace_events.createTracing({ categories: ['node.perf'] });\ntracing.enable();  // Enable trace event capture for the 'node.perf' category\n\n// do work\n\ntracing.disable();  // Disable trace event capture for the 'node.perf' category\n</code></pre>\n<p>Running Node.js with tracing enabled will produce log files that can be opened\nin the <a href=\"https://www.chromium.org/developers/how-tos/trace-event-profiling-tool\"><code>chrome://tracing</code></a>\ntab of Chrome.</p>\n<p>The logging file is by default called <code>node_trace.${rotation}.log</code>, where\n<code>${rotation}</code> is an incrementing log-rotation id. The filepath pattern can\nbe specified with <code>--trace-event-file-pattern</code> that accepts a template\nstring that supports <code>${rotation}</code> and <code>${pid}</code>:</p>\n<pre><code class=\"language-bash\">node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js\n</code></pre>\n<p>The tracing system uses the same time source\nas the one used by <code>process.hrtime()</code>.\nHowever the trace-event timestamps are expressed in microseconds,\nunlike <code>process.hrtime()</code> which returns nanoseconds.</p>\n<p>The features from this module are not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/trace_events.js\">lib/trace_events.js</a></p>\n<p>The <code>trace_events</code> module provides a mechanism to centralize tracing information\ngenerated by V8, Node.js core, and userspace code.</p>\n<p>Tracing can be enabled with the <code>--trace-event-categories</code> command-line flag\nor by using the <code>trace_events</code> module. The <code>--trace-event-categories</code> flag\naccepts a list of comma-separated category names.</p>\n<p>The available categories are:</p>\n<ul>\n<li><code>node</code>: An empty placeholder.</li>\n<li><code>node.async_hooks</code>: Enables capture of detailed <a href=\"async_hooks.html\"><code>async_hooks</code></a> trace data.\nThe <a href=\"async_hooks.html\"><code>async_hooks</code></a> events have a unique <code>asyncId</code> and a special <code>triggerId</code>\n<code>triggerAsyncId</code> property.</li>\n<li><code>node.bootstrap</code>: Enables capture of Node.js bootstrap milestones.</li>\n<li><code>node.console</code>: Enables capture of <code>console.time()</code> and <code>console.count()</code>\noutput.</li>\n<li><code>node.dns.native</code>: Enables capture of trace data for DNS queries.</li>\n<li><code>node.environment</code>: Enables capture of Node.js Environment milestones.</li>\n<li><code>node.fs.sync</code>: Enables capture of trace data for file system sync methods.</li>\n<li><code>node.perf</code>: Enables capture of <a href=\"perf_hooks.html\">Performance API</a> measurements.\n<ul>\n<li><code>node.perf.usertiming</code>: Enables capture of only Performance API User Timing\nmeasures and marks.</li>\n<li><code>node.perf.timerify</code>: Enables capture of only Performance API timerify\nmeasurements.</li>\n</ul>\n</li>\n<li><code>node.promises.rejections</code>: Enables capture of trace data tracking the number\nof unhandled Promise rejections and handled-after-rejections.</li>\n<li><code>node.vm.script</code>: Enables capture of trace data for the <code>vm</code> module's\n<code>runInNewContext()</code>, <code>runInContext()</code>, and <code>runInThisContext()</code> methods.</li>\n<li><code>v8</code>: The <a href=\"v8.html\">V8</a> events are GC, compiling, and execution related.</li>\n</ul>\n<p>By default the <code>node</code>, <code>node.async_hooks</code>, and <code>v8</code> categories are enabled.</p>\n<pre><code class=\"language-bash\">node --trace-event-categories v8,node,node.async_hooks server.js\n</code></pre>\n<p>Prior versions of Node.js required the use of the <code>--trace-events-enabled</code>\nflag to enable trace events. This requirement has been removed. However, the\n<code>--trace-events-enabled</code> flag <em>may</em> still be used and will enable the\n<code>node</code>, <code>node.async_hooks</code>, and <code>v8</code> trace event categories by default.</p>\n<pre><code class=\"language-bash\">node --trace-events-enabled\n\n# is equivalent to\n\nnode --trace-event-categories v8,node,node.async_hooks\n</code></pre>\n<p>Alternatively, trace events may be enabled using the <code>trace_events</code> module:</p>\n<pre><code class=\"language-js\">const trace_events = require('trace_events');\nconst tracing = trace_events.createTracing({ categories: ['node.perf'] });\ntracing.enable();  // Enable trace event capture for the 'node.perf' category\n\n// do work\n\ntracing.disable();  // Disable trace event capture for the 'node.perf' category\n</code></pre>\n<p>Running Node.js with tracing enabled will produce log files that can be opened\nin the <a href=\"https://www.chromium.org/developers/how-tos/trace-event-profiling-tool\"><code>chrome://tracing</code></a>\ntab of Chrome.</p>\n<p>The logging file is by default called <code>node_trace.${rotation}.log</code>, where\n<code>${rotation}</code> is an incrementing log-rotation id. The filepath pattern can\nbe specified with <code>--trace-event-file-pattern</code> that accepts a template\nstring that supports <code>${rotation}</code> and <code>${pid}</code>:</p>\n<pre><code class=\"language-bash\">node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js\n</code></pre>\n<p>The tracing system uses the same time source\nas the one used by <code>process.hrtime()</code>.\nHowever the trace-event timestamps are expressed in microseconds,\nunlike <code>process.hrtime()</code> which returns nanoseconds.</p>\n<p>The features from this module are not available in <a href=\"worker_threads.html#worker_threads_class_worker\"><code>Worker</code></a> threads.</p>",
       "modules": [
         {
           "textRaw": "The `trace_events` module",
diff --git a/doc/api/tracing.md b/doc/api/tracing.md
index 530f534d82476b8a8c5635e2dcc53b5c914c63aa..5c56360319a69c8e93057a30dcfa112632938692 100644
--- a/doc/api/tracing.md
+++ b/doc/api/tracing.md
@@ -207,7 +207,7 @@ t2.enable();
 console.log(trace_events.getEnabledCategories());
 ```
 
-[Performance API]: perf_hooks.html
-[V8]: v8.html
-[`Worker`]: worker_threads.html#worker_threads_class_worker
-[`async_hooks`]: async_hooks.html
+[Performance API]: perf_hooks.md
+[V8]: v8.md
+[`Worker`]: worker_threads.md#worker_threads_class_worker
+[`async_hooks`]: async_hooks.md
diff --git a/doc/api/tty.html b/doc/api/tty.html
index 0538ea0ecf1615b5b0de14d1286f395a645816cf..59a14baa48907cbace4e6f714e16eb27eed56657 100644
--- a/doc/api/tty.html
+++ b/doc/api/tty.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>TTY | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>TTY | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="tty" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/tty.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/tty.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/tty.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/tty.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/tty.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/tty.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/tty.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/tty.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/tty.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#tty_tty">TTY</a></span>
 <ul>
 <li><a href="#tty_class_tty_readstream">Class: <code>tty.ReadStream</code></a>
@@ -154,14 +167,13 @@
 <li><a href="#tty_tty_isatty_fd"><code>tty.isatty(fd)</code></a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>TTY<span><a class="mark" href="#tty_tty" id="tty_tty">#</a></span></h1>
+        <h2>TTY<span><a class="mark" href="#tty_tty" id="tty_tty">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/tty.js">lib/tty.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/tty.js">lib/tty.js</a></p>
 <p>The <code>tty</code> module provides the <code>tty.ReadStream</code> and <code>tty.WriteStream</code> classes.
 In most cases, it will not be necessary or possible to use this module directly.
 However, it can be accessed using:</p>
@@ -169,17 +181,17 @@ However, it can be accessed using:</p>
 <p>When Node.js detects that it is being run with a text terminal ("TTY")
 attached, <a href="process.html#process_process_stdin"><code>process.stdin</code></a> will, by default, be initialized as an instance of
 <code>tty.ReadStream</code> and both <a href="process.html#process_process_stdout"><code>process.stdout</code></a> and <a href="process.html#process_process_stderr"><code>process.stderr</code></a> will, by
-default be instances of <code>tty.WriteStream</code>. The preferred method of determining
+default, be instances of <code>tty.WriteStream</code>. The preferred method of determining
 whether Node.js is being run within a TTY context is to check that the value of
 the <code>process.stdout.isTTY</code> property is <code>true</code>:</p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> node -p -e <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span></span>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">node -p -e <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span></span>
 true
-<span class="hljs-meta">$</span><span class="bash"> node -p -e <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span> | cat</span>
+<span class="hljs-meta">$ </span><span class="language-bash">node -p -e <span class="hljs-string">"Boolean(process.stdout.isTTY)"</span> | cat</span>
 false</code></pre>
 <p>In most cases, there should be little to no reason for an application to
 manually create instances of the <code>tty.ReadStream</code> and <code>tty.WriteStream</code>
 classes.</p>
-<h2>Class: <code>tty.ReadStream</code><span><a class="mark" href="#tty_class_tty_readstream" id="tty_class_tty_readstream">#</a></span></h2>
+<section><h3>Class: <code>tty.ReadStream</code><span><a class="mark" href="#tty_class_tty_readstream" id="tty_class_tty_readstream">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -189,18 +201,18 @@ classes.</p>
 <p>Represents the readable side of a TTY. In normal circumstances
 <a href="process.html#process_process_stdin"><code>process.stdin</code></a> will be the only <code>tty.ReadStream</code> instance in a Node.js
 process and there should be no reason to create additional instances.</p>
-<h3><code>readStream.isRaw</code><span><a class="mark" href="#tty_readstream_israw" id="tty_readstream_israw">#</a></span></h3>
+<h4><code>readStream.isRaw</code><span><a class="mark" href="#tty_readstream_israw" id="tty_readstream_israw">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>A <code>boolean</code> that is <code>true</code> if the TTY is currently configured to operate as a
 raw device. Defaults to <code>false</code>.</p>
-<h3><code>readStream.isTTY</code><span><a class="mark" href="#tty_readstream_istty" id="tty_readstream_istty">#</a></span></h3>
+<h4><code>readStream.isTTY</code><span><a class="mark" href="#tty_readstream_istty" id="tty_readstream_istty">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>A <code>boolean</code> that is always <code>true</code> for <code>tty.ReadStream</code> instances.</p>
-<h3><code>readStream.setRawMode(mode)</code><span><a class="mark" href="#tty_readstream_setrawmode_mode" id="tty_readstream_setrawmode_mode">#</a></span></h3>
+<h4><code>readStream.setRawMode(mode)</code><span><a class="mark" href="#tty_readstream_setrawmode_mode" id="tty_readstream_setrawmode_mode">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
@@ -215,8 +227,8 @@ mode.</li>
 <p>When in raw mode, input is always available character-by-character, not
 including modifiers. Additionally, all special processing of characters by the
 terminal is disabled, including echoing input characters.
-<code>CTRL</code>+<code>C</code> will no longer cause a <code>SIGINT</code> when in this mode.</p>
-<h2>Class: <code>tty.WriteStream</code><span><a class="mark" href="#tty_class_tty_writestream" id="tty_class_tty_writestream">#</a></span></h2>
+<kbd>Ctrl</kbd>+<kbd>C</kbd> will no longer cause a <code>SIGINT</code> when in this mode.</p>
+</section><section><h3>Class: <code>tty.WriteStream</code><span><a class="mark" href="#tty_class_tty_writestream" id="tty_class_tty_writestream">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -227,18 +239,18 @@ terminal is disabled, including echoing input characters.
 <a href="process.html#process_process_stdout"><code>process.stdout</code></a> and <a href="process.html#process_process_stderr"><code>process.stderr</code></a> will be the only
 <code>tty.WriteStream</code> instances created for a Node.js process and there
 should be no reason to create additional instances.</p>
-<h3>Event: <code>'resize'</code><span><a class="mark" href="#tty_event_resize" id="tty_event_resize">#</a></span></h3>
+<h4>Event: <code>'resize'</code><span><a class="mark" href="#tty_event_resize" id="tty_event_resize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>The <code>'resize'</code> event is emitted whenever either of the <code>writeStream.columns</code>
 or <code>writeStream.rows</code> properties have changed. No arguments are passed to the
 listener callback when called.</p>
-<pre><code class="language-js">process.stdout.on(<span class="hljs-string">'resize'</span>, <span class="hljs-function">() =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'screen size has changed!'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`<span class="hljs-subst">${process.stdout.columns}</span>x<span class="hljs-subst">${process.stdout.rows}</span>`</span>);
+<pre><code class="language-js">process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'resize'</span>, <span class="hljs-function">() =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'screen size has changed!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`<span class="hljs-subst">${process.stdout.columns}</span>x<span class="hljs-subst">${process.stdout.rows}</span>`</span>);
 });</code></pre>
-<h3><code>writeStream.clearLine(dir[, callback])</code><span><a class="mark" href="#tty_writestream_clearline_dir_callback" id="tty_writestream_clearline_dir_callback">#</a></span></h3>
+<h4><code>writeStream.clearLine(dir[, callback])</code><span><a class="mark" href="#tty_writestream_clearline_dir_callback" id="tty_writestream_clearline_dir_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -265,7 +277,7 @@ data; otherwise <code>true</code>.</li>
 </ul>
 <p><code>writeStream.clearLine()</code> clears the current line of this <code>WriteStream</code> in a
 direction identified by <code>dir</code>.</p>
-<h3><code>writeStream.clearScreenDown([callback])</code><span><a class="mark" href="#tty_writestream_clearscreendown_callback" id="tty_writestream_clearscreendown_callback">#</a></span></h3>
+<h4><code>writeStream.clearScreenDown([callback])</code><span><a class="mark" href="#tty_writestream_clearscreendown_callback" id="tty_writestream_clearscreendown_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -285,13 +297,13 @@ data; otherwise <code>true</code>.</li>
 </ul>
 <p><code>writeStream.clearScreenDown()</code> clears this <code>WriteStream</code> from the current
 cursor down.</p>
-<h3><code>writeStream.columns</code><span><a class="mark" href="#tty_writestream_columns" id="tty_writestream_columns">#</a></span></h3>
+<h4><code>writeStream.columns</code><span><a class="mark" href="#tty_writestream_columns" id="tty_writestream_columns">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>A <code>number</code> specifying the number of columns the TTY currently has. This property
 is updated whenever the <code>'resize'</code> event is emitted.</p>
-<h3><code>writeStream.cursorTo(x[, y][, callback])</code><span><a class="mark" href="#tty_writestream_cursorto_x_y_callback" id="tty_writestream_cursorto_x_y_callback">#</a></span></h3>
+<h4><code>writeStream.cursorTo(x[, y][, callback])</code><span><a class="mark" href="#tty_writestream_cursorto_x_y_callback" id="tty_writestream_cursorto_x_y_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -313,7 +325,7 @@ data; otherwise <code>true</code>.</li>
 </ul>
 <p><code>writeStream.cursorTo()</code> moves this <code>WriteStream</code>'s cursor to the specified
 position.</p>
-<h3><code>writeStream.getColorDepth([env])</code><span><a class="mark" href="#tty_writestream_getcolordepth_env" id="tty_writestream_getcolordepth_env">#</a></span></h3>
+<h4><code>writeStream.getColorDepth([env])</code><span><a class="mark" href="#tty_writestream_getcolordepth_env" id="tty_writestream_getcolordepth_env">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v9.9.0</span>
 </div>
@@ -328,9 +340,9 @@ enables simulating the usage of a specific terminal. <strong>Default:</strong>
 <li><code>1</code> for 2,</li>
 <li><code>4</code> for 16,</li>
 <li><code>8</code> for 256,</li>
-<li><code>24</code> for 16,777,216
-colors supported.</li>
+<li><code>24</code> for 16,777,216</li>
 </ul>
+<p>colors supported.</p>
 <p>Use this to determine what colors the terminal supports. Due to the nature of
 colors in terminals it is possible to either have false positives or false
 negatives. It depends on process information and the environment variables that
@@ -346,20 +358,20 @@ terminal. This can be useful to check how specific environment settings behave.<
 </ul>
 <p>Disabling color support is also possible by using the <code>NO_COLOR</code> and
 <code>NODE_DISABLE_COLORS</code> environment variables.</p>
-<h3><code>writeStream.getWindowSize()</code><span><a class="mark" href="#tty_writestream_getwindowsize" id="tty_writestream_getwindowsize">#</a></span></h3>
+<h4><code>writeStream.getWindowSize()</code><span><a class="mark" href="#tty_writestream_getwindowsize" id="tty_writestream_getwindowsize">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number[]></a></li>
 </ul>
-<p><code>writeStream.getWindowSize()</code> returns the size of the <a href="tty.html">TTY</a>
+<p><code>writeStream.getWindowSize()</code> returns the size of the TTY
 corresponding to this <code>WriteStream</code>. The array is of the type
 <code>[numColumns, numRows]</code> where <code>numColumns</code> and <code>numRows</code> represent the number
-of columns and rows in the corresponding <a href="tty.html">TTY</a>.</p>
-<h3><code>writeStream.hasColors([count][, env])</code><span><a class="mark" href="#tty_writestream_hascolors_count_env" id="tty_writestream_hascolors_count_env">#</a></span></h3>
+of columns and rows in the corresponding TTY.</p>
+<h4><code>writeStream.hasColors([count][, env])</code><span><a class="mark" href="#tty_writestream_hascolors_count_env" id="tty_writestream_hascolors_count_env">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.13.0</span>
+<span>Added in: v11.13.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>count</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> The number of colors that are requested (minimum 2).
@@ -373,20 +385,20 @@ enables simulating the usage of a specific terminal. <strong>Default:</strong>
 in <code>count</code>. Minimum support is 2 (black and white).</p>
 <p>This has the same false positives and negatives as described in
 <a href="#tty_writestream_getcolordepth_env"><code>writeStream.getColorDepth()</code></a>.</p>
-<pre><code class="language-js">process.stdout.hasColors();
+<pre><code class="language-js">process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">hasColors</span>();
 <span class="hljs-comment">// Returns true or false depending on if `stdout` supports at least 16 colors.</span>
-process.stdout.hasColors(<span class="hljs-number">256</span>);
+process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">hasColors</span>(<span class="hljs-number">256</span>);
 <span class="hljs-comment">// Returns true or false depending on if `stdout` supports at least 256 colors.</span>
-process.stdout.hasColors({ <span class="hljs-attr">TMUX</span>: <span class="hljs-string">'1'</span> });
+process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">hasColors</span>({ <span class="hljs-attr">TMUX</span>: <span class="hljs-string">'1'</span> });
 <span class="hljs-comment">// Returns true.</span>
-process.stdout.hasColors(<span class="hljs-number">2</span> ** <span class="hljs-number">24</span>, { <span class="hljs-attr">TMUX</span>: <span class="hljs-string">'1'</span> });
+process.<span class="hljs-property">stdout</span>.<span class="hljs-title function_">hasColors</span>(<span class="hljs-number">2</span> ** <span class="hljs-number">24</span>, { <span class="hljs-attr">TMUX</span>: <span class="hljs-string">'1'</span> });
 <span class="hljs-comment">// Returns false (the environment setting pretends to support 2 ** 8 colors).</span></code></pre>
-<h3><code>writeStream.isTTY</code><span><a class="mark" href="#tty_writestream_istty" id="tty_writestream_istty">#</a></span></h3>
+<h4><code>writeStream.isTTY</code><span><a class="mark" href="#tty_writestream_istty" id="tty_writestream_istty">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>A <code>boolean</code> that is always <code>true</code>.</p>
-<h3><code>writeStream.moveCursor(dx, dy[, callback])</code><span><a class="mark" href="#tty_writestream_movecursor_dx_dy_callback" id="tty_writestream_movecursor_dx_dy_callback">#</a></span></h3>
+<h4><code>writeStream.moveCursor(dx, dy[, callback])</code><span><a class="mark" href="#tty_writestream_movecursor_dx_dy_callback" id="tty_writestream_movecursor_dx_dy_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -408,13 +420,13 @@ data; otherwise <code>true</code>.</li>
 </ul>
 <p><code>writeStream.moveCursor()</code> moves this <code>WriteStream</code>'s cursor <em>relative</em> to its
 current position.</p>
-<h3><code>writeStream.rows</code><span><a class="mark" href="#tty_writestream_rows" id="tty_writestream_rows">#</a></span></h3>
+<h4><code>writeStream.rows</code><span><a class="mark" href="#tty_writestream_rows" id="tty_writestream_rows">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.7</span>
 </div>
 <p>A <code>number</code> specifying the number of rows the TTY currently has. This property
 is updated whenever the <code>'resize'</code> event is emitted.</p>
-<h2><code>tty.isatty(fd)</code><span><a class="mark" href="#tty_tty_isatty_fd" id="tty_tty_isatty_fd">#</a></span></h2>
+</section><section><h3><code>tty.isatty(fd)</code><span><a class="mark" href="#tty_tty_isatty_fd" id="tty_tty_isatty_fd">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -424,10 +436,46 @@ is updated whenever the <code>'resize'</code> event is emitted.</p>
 </ul>
 <p>The <code>tty.isatty()</code> method returns <code>true</code> if the given <code>fd</code> is associated with
 a TTY and <code>false</code> if it is not, including whenever <code>fd</code> is not a non-negative
-integer.</p>
+integer.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/tty.json b/doc/api/tty.json
index 0618e8d77bf578a128fd8339d84f2238b159ed59..5d6572d43ceab36d5ab4e93210a80d87ed6abc9d 100644
--- a/doc/api/tty.json
+++ b/doc/api/tty.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/tty.js\">lib/tty.js</a></p>\n<p>The <code>tty</code> module provides the <code>tty.ReadStream</code> and <code>tty.WriteStream</code> classes.\nIn most cases, it will not be necessary or possible to use this module directly.\nHowever, it can be accessed using:</p>\n<pre><code class=\"language-js\">const tty = require('tty');\n</code></pre>\n<p>When Node.js detects that it is being run with a text terminal (\"TTY\")\nattached, <a href=\"process.html#process_process_stdin\"><code>process.stdin</code></a> will, by default, be initialized as an instance of\n<code>tty.ReadStream</code> and both <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> and <a href=\"process.html#process_process_stderr\"><code>process.stderr</code></a> will, by\ndefault be instances of <code>tty.WriteStream</code>. The preferred method of determining\nwhether Node.js is being run within a TTY context is to check that the value of\nthe <code>process.stdout.isTTY</code> property is <code>true</code>:</p>\n<pre><code class=\"language-console\">$ node -p -e \"Boolean(process.stdout.isTTY)\"\ntrue\n$ node -p -e \"Boolean(process.stdout.isTTY)\" | cat\nfalse\n</code></pre>\n<p>In most cases, there should be little to no reason for an application to\nmanually create instances of the <code>tty.ReadStream</code> and <code>tty.WriteStream</code>\nclasses.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/tty.js\">lib/tty.js</a></p>\n<p>The <code>tty</code> module provides the <code>tty.ReadStream</code> and <code>tty.WriteStream</code> classes.\nIn most cases, it will not be necessary or possible to use this module directly.\nHowever, it can be accessed using:</p>\n<pre><code class=\"language-js\">const tty = require('tty');\n</code></pre>\n<p>When Node.js detects that it is being run with a text terminal (\"TTY\")\nattached, <a href=\"process.html#process_process_stdin\"><code>process.stdin</code></a> will, by default, be initialized as an instance of\n<code>tty.ReadStream</code> and both <a href=\"process.html#process_process_stdout\"><code>process.stdout</code></a> and <a href=\"process.html#process_process_stderr\"><code>process.stderr</code></a> will, by\ndefault, be instances of <code>tty.WriteStream</code>. The preferred method of determining\nwhether Node.js is being run within a TTY context is to check that the value of\nthe <code>process.stdout.isTTY</code> property is <code>true</code>:</p>\n<pre><code class=\"language-console\">$ node -p -e \"Boolean(process.stdout.isTTY)\"\ntrue\n$ node -p -e \"Boolean(process.stdout.isTTY)\" | cat\nfalse\n</code></pre>\n<p>In most cases, there should be little to no reason for an application to\nmanually create instances of the <code>tty.ReadStream</code> and <code>tty.WriteStream</code>\nclasses.</p>",
       "classes": [
         {
           "textRaw": "Class: `tty.ReadStream`",
@@ -74,7 +74,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Allows configuration of <code>tty.ReadStream</code> so that it operates as a raw device.</p>\n<p>When in raw mode, input is always available character-by-character, not\nincluding modifiers. Additionally, all special processing of characters by the\nterminal is disabled, including echoing input characters.\n<code>CTRL</code>+<code>C</code> will no longer cause a <code>SIGINT</code> when in this mode.</p>"
+              "desc": "<p>Allows configuration of <code>tty.ReadStream</code> so that it operates as a raw device.</p>\n<p>When in raw mode, input is always available character-by-character, not\nincluding modifiers. Additionally, all special processing of characters by the\nterminal is disabled, including echoing input characters.\n<kbd>Ctrl</kbd>+<kbd>C</kbd> will no longer cause a <code>SIGINT</code> when in this mode.</p>"
             }
           ]
         },
@@ -273,7 +273,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns:</p>\n<ul>\n<li><code>1</code> for 2,</li>\n<li><code>4</code> for 16,</li>\n<li><code>8</code> for 256,</li>\n<li><code>24</code> for 16,777,216\ncolors supported.</li>\n</ul>\n<p>Use this to determine what colors the terminal supports. Due to the nature of\ncolors in terminals it is possible to either have false positives or false\nnegatives. It depends on process information and the environment variables that\nmay lie about what terminal is used.\nIt is possible to pass in an <code>env</code> object to simulate the usage of a specific\nterminal. This can be useful to check how specific environment settings behave.</p>\n<p>To enforce a specific color support, use one of the below environment settings.</p>\n<ul>\n<li>2 colors: <code>FORCE_COLOR = 0</code> (Disables colors)</li>\n<li>16 colors: <code>FORCE_COLOR = 1</code></li>\n<li>256 colors: <code>FORCE_COLOR = 2</code></li>\n<li>16,777,216 colors: <code>FORCE_COLOR = 3</code></li>\n</ul>\n<p>Disabling color support is also possible by using the <code>NO_COLOR</code> and\n<code>NODE_DISABLE_COLORS</code> environment variables.</p>"
+              "desc": "<p>Returns:</p>\n<ul>\n<li><code>1</code> for 2,</li>\n<li><code>4</code> for 16,</li>\n<li><code>8</code> for 256,</li>\n<li><code>24</code> for 16,777,216</li>\n</ul>\n<p>colors supported.</p>\n<p>Use this to determine what colors the terminal supports. Due to the nature of\ncolors in terminals it is possible to either have false positives or false\nnegatives. It depends on process information and the environment variables that\nmay lie about what terminal is used.\nIt is possible to pass in an <code>env</code> object to simulate the usage of a specific\nterminal. This can be useful to check how specific environment settings behave.</p>\n<p>To enforce a specific color support, use one of the below environment settings.</p>\n<ul>\n<li>2 colors: <code>FORCE_COLOR = 0</code> (Disables colors)</li>\n<li>16 colors: <code>FORCE_COLOR = 1</code></li>\n<li>256 colors: <code>FORCE_COLOR = 2</code></li>\n<li>16,777,216 colors: <code>FORCE_COLOR = 3</code></li>\n</ul>\n<p>Disabling color support is also possible by using the <code>NO_COLOR</code> and\n<code>NODE_DISABLE_COLORS</code> environment variables.</p>"
             },
             {
               "textRaw": "`writeStream.getWindowSize()`",
@@ -295,7 +295,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p><code>writeStream.getWindowSize()</code> returns the size of the <a href=\"tty.html\">TTY</a>\ncorresponding to this <code>WriteStream</code>. The array is of the type\n<code>[numColumns, numRows]</code> where <code>numColumns</code> and <code>numRows</code> represent the number\nof columns and rows in the corresponding <a href=\"tty.html\">TTY</a>.</p>"
+              "desc": "<p><code>writeStream.getWindowSize()</code> returns the size of the TTY\ncorresponding to this <code>WriteStream</code>. The array is of the type\n<code>[numColumns, numRows]</code> where <code>numColumns</code> and <code>numRows</code> represent the number\nof columns and rows in the corresponding TTY.</p>"
             },
             {
               "textRaw": "`writeStream.hasColors([count][, env])`",
@@ -303,7 +303,8 @@
               "name": "hasColors",
               "meta": {
                 "added": [
-                  "v11.13.0"
+                  "v11.13.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
diff --git a/doc/api/tty.md b/doc/api/tty.md
index 7dd3a9c35794770ac7529f9a859fd54639da8815..df050c8ae9e96f583ebe03f24cff8d57ec6752c7 100644
--- a/doc/api/tty.md
+++ b/doc/api/tty.md
@@ -17,7 +17,7 @@ const tty = require('tty');
 When Node.js detects that it is being run with a text terminal ("TTY")
 attached, [`process.stdin`][] will, by default, be initialized as an instance of
 `tty.ReadStream` and both [`process.stdout`][] and [`process.stderr`][] will, by
-default be instances of `tty.WriteStream`. The preferred method of determining
+default, be instances of `tty.WriteStream`. The preferred method of determining
 whether Node.js is being run within a TTY context is to check that the value of
 the `process.stdout.isTTY` property is `true`:
 
@@ -74,7 +74,7 @@ Allows configuration of `tty.ReadStream` so that it operates as a raw device.
 When in raw mode, input is always available character-by-character, not
 including modifiers. Additionally, all special processing of characters by the
 terminal is disabled, including echoing input characters.
-`CTRL`+`C` will no longer cause a `SIGINT` when in this mode.
+<kbd>Ctrl</kbd>+<kbd>C</kbd> will no longer cause a `SIGINT` when in this mode.
 
 ## Class: `tty.WriteStream`
 <!-- YAML
@@ -211,14 +211,16 @@ added: v0.7.7
 
 * Returns: {number[]}
 
-`writeStream.getWindowSize()` returns the size of the [TTY](tty.html)
+`writeStream.getWindowSize()` returns the size of the TTY
 corresponding to this `WriteStream`. The array is of the type
 `[numColumns, numRows]` where `numColumns` and `numRows` represent the number
-of columns and rows in the corresponding [TTY](tty.html).
+of columns and rows in the corresponding TTY.
 
 ### `writeStream.hasColors([count][, env])`
 <!-- YAML
-added: v11.13.0
+added:
+ - v11.13.0
+ - v10.16.0
 -->
 
 * `count` {integer} The number of colors that are requested (minimum 2).
@@ -291,7 +293,7 @@ The `tty.isatty()` method returns `true` if the given `fd` is associated with
 a TTY and `false` if it is not, including whenever `fd` is not a non-negative
 integer.
 
-[`process.stderr`]: process.html#process_process_stderr
-[`process.stdin`]: process.html#process_process_stdin
-[`process.stdout`]: process.html#process_process_stdout
+[`process.stderr`]: process.md#process_process_stderr
+[`process.stdin`]: process.md#process_process_stdin
+[`process.stdout`]: process.md#process_process_stdout
 [`writeStream.getColorDepth()`]: #tty_writestream_getcolordepth_env
diff --git a/doc/api/url.html b/doc/api/url.html
index 71721b2d6384af838667a2f3cf10ebd676c9266b..7130489650cc0ffdfd9fa2d645c7688928c8220c 100644
--- a/doc/api/url.html
+++ b/doc/api/url.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>URL | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>URL | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="url" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/url.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/url.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/url.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/url.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/url.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/url.html">13.x</a></li>
@@ -118,18 +133,20 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/url.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/url.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/url.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#url_url">URL</a></span>
 <ul>
-<li><a href="#url_url_strings_and_url_objects">URL strings and URL objects</a></li>
+<li><a href="#url_url_strings_and_url_objects">URL strings and URL objects</a>
+<ul>
+<li><a href="#url_constructing_a_url_from_component_parts_and_getting_the_constructed_string">Constructing a URL from component parts and getting the constructed string</a></li>
+</ul>
+</li>
 <li><a href="#url_the_whatwg_url_api">The WHATWG URL API</a>
 <ul>
 <li><a href="#url_class_url">Class: <code>URL</code></a>
@@ -181,11 +198,12 @@
 <li><a href="#url_url_fileurltopath_url"><code>url.fileURLToPath(url)</code></a></li>
 <li><a href="#url_url_format_url_options"><code>url.format(URL[, options])</code></a></li>
 <li><a href="#url_url_pathtofileurl_path"><code>url.pathToFileURL(path)</code></a></li>
+<li><a href="#url_url_urltohttpoptions_url"><code>url.urlToHttpOptions(url)</code></a></li>
 </ul>
 </li>
-<li><a href="#url_legacy_url_api">Legacy URL API</a>
+<li><span class="stability_3"><a href="#url_legacy_url_api">Legacy URL API</a></span>
 <ul>
-<li><span class="stability_0"><a href="#url_legacy_urlobject">Legacy <code>urlObject</code></a></span>
+<li><span class="stability_3"><a href="#url_legacy_urlobject">Legacy <code>urlObject</code></a></span>
 <ul>
 <li><a href="#url_urlobject_auth"><code>urlObject.auth</code></a></li>
 <li><a href="#url_urlobject_hash"><code>urlObject.hash</code></a></li>
@@ -201,9 +219,9 @@
 <li><a href="#url_urlobject_slashes"><code>urlObject.slashes</code></a></li>
 </ul>
 </li>
-<li><span class="stability_0"><a href="#url_url_format_urlobject"><code>url.format(urlObject)</code></a></span></li>
-<li><span class="stability_0"><a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse(urlString[, parseQueryString[, slashesDenoteHost]])</code></a></span></li>
-<li><span class="stability_0"><a href="#url_url_resolve_from_to"><code>url.resolve(from, to)</code></a></span></li>
+<li><span class="stability_3"><a href="#url_url_format_urlobject"><code>url.format(urlObject)</code></a></span></li>
+<li><span class="stability_3"><a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse(urlString[, parseQueryString[, slashesDenoteHost]])</code></a></span></li>
+<li><span class="stability_3"><a href="#url_url_resolve_from_to"><code>url.resolve(from, to)</code></a></span></li>
 </ul>
 </li>
 <li><a href="#url_percent_encoding_in_urls">Percent-encoding in URLs</a>
@@ -214,18 +232,17 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>URL<span><a class="mark" href="#url_url" id="url_url">#</a></span></h1>
+        <h2>URL<span><a class="mark" href="#url_url" id="url_url">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/url.js">lib/url.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/url.js">lib/url.js</a></p>
 <p>The <code>url</code> module provides utilities for URL resolution and parsing. It can be
 accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);</code></pre>
-<h2>URL strings and URL objects<span><a class="mark" href="#url_url_strings_and_url_objects" id="url_url_strings_and_url_objects">#</a></span></h2>
+<section><h3>URL strings and URL objects<span><a class="mark" href="#url_url_strings_and_url_objects" id="url_url_strings_and_url_objects">#</a></span></h3>
 <p>A URL string is a structured string containing multiple meaningful components.
 When parsed, a URL object is returned containing properties for each of these
 components.</p>
@@ -233,7 +250,7 @@ components.</p>
 Node.js specific, and a newer API that implements the same
 <a href="https://url.spec.whatwg.org/">WHATWG URL Standard</a> used by web browsers.</p>
 <p>A comparison between the WHATWG and Legacy APIs is provided below. Above the URL
-<code>'http://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>, properties
+<code>'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>, properties
 of an object returned by the legacy <code>url.parse()</code> are shown. Below it are
 properties of a WHATWG <code>URL</code> object.</p>
 <p>WHATWG URL's <code>origin</code> property includes <code>protocol</code> and <code>host</code>, but not
@@ -258,13 +275,26 @@ properties of a WHATWG <code>URL</code> object.</p>
 (All spaces in the "" line should be ignored. They are purely for formatting.)</code></pre>
 <p>Parsing the URL string using the WHATWG API:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> myURL =
-  <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</span>);</code></pre>
+  <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</span>);</code></pre>
 <p>Parsing the URL string using the Legacy API:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
 <span class="hljs-keyword">const</span> myURL =
-  url.parse(<span class="hljs-string">'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</span>);</code></pre>
-<h2>The WHATWG URL API<span><a class="mark" href="#url_the_whatwg_url_api" id="url_the_whatwg_url_api">#</a></span></h2>
-<h3>Class: <code>URL</code><span><a class="mark" href="#url_class_url" id="url_class_url">#</a></span></h3>
+  url.<span class="hljs-title function_">parse</span>(<span class="hljs-string">'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</span>);</code></pre>
+<h4>Constructing a URL from component parts and getting the constructed string<span><a class="mark" href="#url_constructing_a_url_from_component_parts_and_getting_the_constructed_string" id="url_constructing_a_url_from_component_parts_and_getting_the_constructed_string">#</a></span></h4>
+<p>It is possible to construct a WHATWG URL from component parts using either the
+property setters or a template literal string:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org'</span>);
+myURL.<span class="hljs-property">pathname</span> = <span class="hljs-string">'/a/b/c'</span>;
+myURL.<span class="hljs-property">search</span> = <span class="hljs-string">'?d=e'</span>;
+myURL.<span class="hljs-property">hash</span> = <span class="hljs-string">'#fgh'</span>;</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> pathname = <span class="hljs-string">'/a/b/c'</span>;
+<span class="hljs-keyword">const</span> search = <span class="hljs-string">'?d=e'</span>;
+<span class="hljs-keyword">const</span> hash = <span class="hljs-string">'#fgh'</span>;
+<span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">`https://example.org<span class="hljs-subst">${pathname}</span><span class="hljs-subst">${search}</span><span class="hljs-subst">${hash}</span>`</span>);</code></pre>
+<p>To get the constructed URL string, use the <code>href</code> property accessor:</p>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);</code></pre>
+</section><section><h3>The WHATWG URL API<span><a class="mark" href="#url_the_whatwg_url_api" id="url_the_whatwg_url_api">#</a></span></h3>
+<h4>Class: <code>URL</code><span><a class="mark" href="#url_class_url" id="url_class_url">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -284,7 +314,7 @@ are implemented as getters and setters on the class prototype, rather than as
 data properties on the object itself. Thus, unlike <a href="#url_legacy_urlobject">legacy <code>urlObject</code></a>s,
 using the <code>delete</code> keyword on any properties of <code>URL</code> objects (e.g. <code>delete myURL.protocol</code>, <code>delete myURL.pathname</code>, etc) has no effect but will still
 return <code>true</code>.</p>
-<h4><code>new URL(input[, base])</code><span><a class="mark" href="#url_new_url_input_base" id="url_new_url_input_base">#</a></span></h4>
+<h5><code>new URL(input[, base])</code><span><a class="mark" href="#url_new_url_input_base" id="url_new_url_input_base">#</a></span></h5>
 <ul>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The absolute or relative input URL to parse. If <code>input</code>
 is relative, then <code>base</code> is required. If <code>input</code> is absolute, the <code>base</code>
@@ -294,97 +324,103 @@ absolute.</li>
 </ul>
 <p>Creates a new <code>URL</code> object by parsing the <code>input</code> relative to the <code>base</code>. If
 <code>base</code> is passed as a string, it will be parsed equivalent to <code>new URL(base)</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'/foo'</span>, <span class="hljs-string">'https://example.org/'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/foo'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// https://example.org/foo</span></code></pre>
 <p>The URL constructor is accessible as a property on the global object.
 It can also be imported from the built-in url module:</p>
-<pre><code class="language-js"><span class="hljs-built_in">console</span>.log(URL === <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>).URL); <span class="hljs-comment">// Prints 'true'.</span></code></pre>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable constant_">URL</span> === <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>).<span class="hljs-property">URL</span>); <span class="hljs-comment">// Prints 'true'.</span></code></pre>
 <p>A <code>TypeError</code> will be thrown if the <code>input</code> or <code>base</code> are not valid URLs. Note
 that an effort will be made to coerce the given values into strings. For
 instance:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL({ <span class="hljs-attr">toString</span>: <span class="hljs-function">() =></span> <span class="hljs-string">'https://example.org/'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>({ <span class="hljs-attr">toString</span>: <span class="hljs-function">() =></span> <span class="hljs-string">'https://example.org/'</span> });
 <span class="hljs-comment">// https://example.org/</span></code></pre>
 <p>Unicode characters appearing within the host name of <code>input</code> will be
 automatically converted to ASCII using the <a href="https://tools.ietf.org/html/rfc5891#section-4.4">Punycode</a> algorithm.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://測試'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://測試'</span>);
 <span class="hljs-comment">// https://xn--g6w251d/</span></code></pre>
 <p>This feature is only available if the <code>node</code> executable was compiled with
 <a href="intl.html#intl_options_for_building_node_js">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>
 <p>In cases where it is not known in advance if <code>input</code> is an absolute URL
 and a <code>base</code> is provided, it is advised to validate that the <code>origin</code> of
 the <code>URL</code> object is what is expected.</p>
-<pre><code class="language-js"><span class="hljs-keyword">let</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">let</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// http://example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// https://example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'foo://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'foo://Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// foo://Example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// http://example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// https://example.org/Example.com/</span>
 
-myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'foo:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
+myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'foo:Example.com/'</span>, <span class="hljs-string">'https://example.org/'</span>);
 <span class="hljs-comment">// foo:Example.com/</span></code></pre>
-<h4><code>url.hash</code><span><a class="mark" href="#url_url_hash" id="url_url_hash">#</a></span></h4>
+<h5><code>url.hash</code><span><a class="mark" href="#url_url_hash" id="url_url_hash">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the fragment portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/foo#bar'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.hash);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/foo#bar'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">hash</span>);
 <span class="hljs-comment">// Prints #bar</span>
 
-myURL.hash = <span class="hljs-string">'baz'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">hash</span> = <span class="hljs-string">'baz'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/foo#baz</span></code></pre>
 <p>Invalid URL characters included in the value assigned to the <code>hash</code> property
 are <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which characters to
 percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a> and
 <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.host</code><span><a class="mark" href="#url_url_host" id="url_url_host">#</a></span></h4>
+<h5><code>url.host</code><span><a class="mark" href="#url_url_host" id="url_url_host">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the host portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org:81/foo'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.host);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org:81/foo'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">host</span>);
 <span class="hljs-comment">// Prints example.org:81</span>
 
-myURL.host = <span class="hljs-string">'example.com:82'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">host</span> = <span class="hljs-string">'example.com:82'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.com:82/foo</span></code></pre>
 <p>Invalid host values assigned to the <code>host</code> property are ignored.</p>
-<h4><code>url.hostname</code><span><a class="mark" href="#url_url_hostname" id="url_url_hostname">#</a></span></h4>
+<h5><code>url.hostname</code><span><a class="mark" href="#url_url_hostname" id="url_url_hostname">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the host name portion of the URL. The key difference between
 <code>url.host</code> and <code>url.hostname</code> is that <code>url.hostname</code> does <em>not</em> include the
 port.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org:81/foo'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.hostname);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org:81/foo'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">hostname</span>);
 <span class="hljs-comment">// Prints example.org</span>
 
-myURL.hostname = <span class="hljs-string">'example.com:82'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
-<span class="hljs-comment">// Prints https://example.com:81/foo</span></code></pre>
+<span class="hljs-comment">// Setting the hostname does not change the port</span>
+myURL.<span class="hljs-property">hostname</span> = <span class="hljs-string">'example.com:82'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
+<span class="hljs-comment">// Prints https://example.com:81/foo</span>
+
+<span class="hljs-comment">// Use myURL.host to change the hostname and port</span>
+myURL.<span class="hljs-property">host</span> = <span class="hljs-string">'example.org:82'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
+<span class="hljs-comment">// Prints https://example.org:82/foo</span></code></pre>
 <p>Invalid host name values assigned to the <code>hostname</code> property are ignored.</p>
-<h4><code>url.href</code><span><a class="mark" href="#url_url_href" id="url_url_href">#</a></span></h4>
+<h5><code>url.href</code><span><a class="mark" href="#url_url_href" id="url_url_href">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the serialized URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/foo'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/foo'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/foo</span>
 
-myURL.href = <span class="hljs-string">'https://example.com/bar'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">href</span> = <span class="hljs-string">'https://example.com/bar'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.com/bar</span></code></pre>
 <p>Getting the value of the <code>href</code> property is equivalent to calling
 <a href="#url_url_tostring"><code>url.toString()</code></a>.</p>
@@ -393,53 +429,53 @@ new <code>URL</code> object using <a href="#url_new_url_input_base"><code>new UR
 object's properties will be modified.</p>
 <p>If the value assigned to the <code>href</code> property is not a valid URL, a <code>TypeError</code>
 will be thrown.</p>
-<h4><code>url.origin</code><span><a class="mark" href="#url_url_origin" id="url_url_origin">#</a></span></h4>
+<h5><code>url.origin</code><span><a class="mark" href="#url_url_origin" id="url_url_origin">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets the read-only serialization of the URL's origin.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/foo/bar?baz'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.origin);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/foo/bar?baz'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">origin</span>);
 <span class="hljs-comment">// Prints https://example.org</span></code></pre>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> idnURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://測試'</span>);
-<span class="hljs-built_in">console</span>.log(idnURL.origin);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> idnURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://測試'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(idnURL.<span class="hljs-property">origin</span>);
 <span class="hljs-comment">// Prints https://xn--g6w251d</span>
 
-<span class="hljs-built_in">console</span>.log(idnURL.hostname);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(idnURL.<span class="hljs-property">hostname</span>);
 <span class="hljs-comment">// Prints xn--g6w251d</span></code></pre>
-<h4><code>url.password</code><span><a class="mark" href="#url_url_password" id="url_url_password">#</a></span></h4>
+<h5><code>url.password</code><span><a class="mark" href="#url_url_password" id="url_url_password">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the password portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.password);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">password</span>);
 <span class="hljs-comment">// Prints xyz</span>
 
-myURL.password = <span class="hljs-string">'123'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">password</span> = <span class="hljs-string">'123'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://abc:123@example.com</span></code></pre>
 <p>Invalid URL characters included in the value assigned to the <code>password</code> property
 are <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which characters to
 percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a> and
 <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.pathname</code><span><a class="mark" href="#url_url_pathname" id="url_url_pathname">#</a></span></h4>
+<h5><code>url.pathname</code><span><a class="mark" href="#url_url_pathname" id="url_url_pathname">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the path portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/abc/xyz?123'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.pathname);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/abc/xyz?123'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">pathname</span>);
 <span class="hljs-comment">// Prints /abc/xyz</span>
 
-myURL.pathname = <span class="hljs-string">'/abcdef'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">pathname</span> = <span class="hljs-string">'/abcdef'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/abcdef?123</span></code></pre>
 <p>Invalid URL characters included in the value assigned to the <code>pathname</code>
 property are <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which characters
 to percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a> and
 <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.port</code><span><a class="mark" href="#url_url_port" id="url_url_port">#</a></span></h4>
+<h5><code>url.port</code><span><a class="mark" href="#url_url_port" id="url_url_port">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -493,107 +529,107 @@ string using <code>.toString()</code>.</p>
 <p>If that string is invalid but it begins with a number, the leading number is
 assigned to <code>port</code>.
 If the number lies outside the range denoted above, it is ignored.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org:8888'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.port);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org:8888'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 8888</span>
 
 <span class="hljs-comment">// Default ports are automatically transformed to the empty string</span>
 <span class="hljs-comment">// (HTTPS protocol's default port is 443)</span>
-myURL.port = <span class="hljs-string">'443'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-string">'443'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints the empty string</span>
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/</span>
 
-myURL.port = <span class="hljs-number">1234</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-number">1234</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 1234</span>
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org:1234/</span>
 
 <span class="hljs-comment">// Completely invalid port strings are ignored</span>
-myURL.port = <span class="hljs-string">'abcd'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-string">'abcd'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 1234</span>
 
 <span class="hljs-comment">// Leading numbers are treated as a port number</span>
-myURL.port = <span class="hljs-string">'5678abcd'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-string">'5678abcd'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 5678</span>
 
 <span class="hljs-comment">// Non-integers are truncated</span>
-myURL.port = <span class="hljs-number">1234.5678</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-number">1234.5678</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 1234</span>
 
 <span class="hljs-comment">// Out-of-range numbers which are not represented in scientific notation</span>
 <span class="hljs-comment">// will be ignored.</span>
-myURL.port = <span class="hljs-number">1e10</span>; <span class="hljs-comment">// 10000000000, will be range-checked as described below</span>
-<span class="hljs-built_in">console</span>.log(myURL.port);
+myURL.<span class="hljs-property">port</span> = <span class="hljs-number">1e10</span>; <span class="hljs-comment">// 10000000000, will be range-checked as described below</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 1234</span></code></pre>
 <p>Numbers which contain a decimal point,
 such as floating-point numbers or numbers in scientific notation,
 are not an exception to this rule.
 Leading numbers up to the decimal point will be set as the URL's port,
 assuming they are valid:</p>
-<pre><code class="language-js">myURL.port = <span class="hljs-number">4.567e21</span>;
-<span class="hljs-built_in">console</span>.log(myURL.port);
+<pre><code class="language-js">myURL.<span class="hljs-property">port</span> = <span class="hljs-number">4.567e21</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">port</span>);
 <span class="hljs-comment">// Prints 4 (because it is the leading number in the string '4.567e21')</span></code></pre>
-<h4><code>url.protocol</code><span><a class="mark" href="#url_url_protocol" id="url_url_protocol">#</a></span></h4>
+<h5><code>url.protocol</code><span><a class="mark" href="#url_url_protocol" id="url_url_protocol">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the protocol portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.protocol);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">protocol</span>);
 <span class="hljs-comment">// Prints https:</span>
 
-myURL.protocol = <span class="hljs-string">'ftp'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">protocol</span> = <span class="hljs-string">'ftp'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints ftp://example.org/</span></code></pre>
 <p>Invalid URL protocol values assigned to the <code>protocol</code> property are ignored.</p>
-<h5>Special schemes<span><a class="mark" href="#url_special_schemes" id="url_special_schemes">#</a></span></h5>
+<h6>Special schemes<span><a class="mark" href="#url_special_schemes" id="url_special_schemes">#</a></span></h6>
 <p>The <a href="https://url.spec.whatwg.org/">WHATWG URL Standard</a> considers a handful of URL protocol schemes to be
 <em>special</em> in terms of how they are parsed and serialized. When a URL is
 parsed using one of these special protocols, the <code>url.protocol</code> property
 may be changed to another special protocol but cannot be changed to a
 non-special protocol, and vice versa.</p>
 <p>For instance, changing from <code>http</code> to <code>https</code> works:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http://example.org'</span>);
-u.protocol = <span class="hljs-string">'https'</span>;
-<span class="hljs-built_in">console</span>.log(u.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http://example.org'</span>);
+u.<span class="hljs-property">protocol</span> = <span class="hljs-string">'https'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// https://example.org</span></code></pre>
 <p>However, changing from <code>http</code> to a hypothetical <code>fish</code> protocol does not
 because the new protocol is not special.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'http://example.org'</span>);
-u.protocol = <span class="hljs-string">'fish'</span>;
-<span class="hljs-built_in">console</span>.log(u.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'http://example.org'</span>);
+u.<span class="hljs-property">protocol</span> = <span class="hljs-string">'fish'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// http://example.org</span></code></pre>
 <p>Likewise, changing from a non-special protocol to a special protocol is also
 not permitted:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'fish://example.org'</span>);
-u.protocol = <span class="hljs-string">'http'</span>;
-<span class="hljs-built_in">console</span>.log(u.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> u = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'fish://example.org'</span>);
+u.<span class="hljs-property">protocol</span> = <span class="hljs-string">'http'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// fish://example.org</span></code></pre>
 <p>According to the WHATWG URL Standard, special protocol schemes are <code>ftp</code>,
 <code>file</code>, <code>gopher</code>, <code>http</code>, <code>https</code>, <code>ws</code>, and <code>wss</code>.</p>
-<h4><code>url.search</code><span><a class="mark" href="#url_url_search" id="url_url_search">#</a></span></h4>
+<h5><code>url.search</code><span><a class="mark" href="#url_url_search" id="url_url_search">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the serialized query portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/abc?123'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.search);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/abc?123'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">search</span>);
 <span class="hljs-comment">// Prints ?123</span>
 
-myURL.search = <span class="hljs-string">'abc=xyz'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">search</span> = <span class="hljs-string">'abc=xyz'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/abc?abc=xyz</span></code></pre>
 <p>Any invalid URL characters appearing in the value assigned the <code>search</code>
 property will be <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which
 characters to percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a>
 and <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.searchParams</code><span><a class="mark" href="#url_url_searchparams" id="url_url_searchparams">#</a></span></h4>
+<h5><code>url.searchParams</code><span><a class="mark" href="#url_url_searchparams" id="url_url_searchparams">#</a></span></h5>
 <ul>
 <li><a href="url.html#url_class_urlsearchparams" class="type">&#x3C;URLSearchParams></a></li>
 </ul>
@@ -607,31 +643,31 @@ per the WHATWG specification, the <code>URLSearchParams</code> object uses
 different rules to determine which characters to percent-encode. For
 instance, the <code>URL</code> object will not percent encode the ASCII tilde (<code>~</code>)
 character, while <code>URLSearchParams</code> will always encode it:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myUrl = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/abc?foo=~bar'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myUrl = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/abc?foo=~bar'</span>);
 
-<span class="hljs-built_in">console</span>.log(myUrl.search);  <span class="hljs-comment">// prints ?foo=~bar</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myUrl.<span class="hljs-property">search</span>);  <span class="hljs-comment">// prints ?foo=~bar</span>
 
 <span class="hljs-comment">// Modify the URL via searchParams...</span>
-myUrl.searchParams.sort();
+myUrl.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">sort</span>();
 
-<span class="hljs-built_in">console</span>.log(myUrl.search);  <span class="hljs-comment">// prints ?foo=%7Ebar</span></code></pre>
-<h4><code>url.username</code><span><a class="mark" href="#url_url_username" id="url_url_username">#</a></span></h4>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myUrl.<span class="hljs-property">search</span>);  <span class="hljs-comment">// prints ?foo=%7Ebar</span></code></pre>
+<h5><code>url.username</code><span><a class="mark" href="#url_url_username" id="url_url_username">#</a></span></h5>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Gets and sets the username portion of the URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.username);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://abc:xyz@example.com'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">username</span>);
 <span class="hljs-comment">// Prints abc</span>
 
-myURL.username = <span class="hljs-string">'123'</span>;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">username</span> = <span class="hljs-string">'123'</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://123:xyz@example.com/</span></code></pre>
 <p>Any invalid URL characters appearing in the value assigned the <code>username</code>
 property will be <a href="#whatwg-percent-encoding">percent-encoded</a>. The selection of which
 characters to percent-encode may vary somewhat from what the <a href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost"><code>url.parse()</code></a>
 and <a href="#url_url_format_urlobject"><code>url.format()</code></a> methods would produce.</p>
-<h4><code>url.toString()</code><span><a class="mark" href="#url_url_tostring" id="url_url_tostring">#</a></span></h4>
+<h5><code>url.toString()</code><span><a class="mark" href="#url_url_tostring" id="url_url_tostring">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -640,7 +676,7 @@ value returned is equivalent to that of <a href="#url_url_href"><code>url.href</
 <p>Because of the need for standard compliance, this method does not allow users
 to customize the serialization process of the URL. For more flexibility,
 <a href="#url_url_format_url_options"><code>require('url').format()</code></a> method might be of interest.</p>
-<h4><code>url.toJSON()</code><span><a class="mark" href="#url_url_tojson" id="url_url_tojson">#</a></span></h4>
+<h5><code>url.toJSON()</code><span><a class="mark" href="#url_url_tojson" id="url_url_tojson">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -650,12 +686,12 @@ value returned is equivalent to that of <a href="#url_url_href"><code>url.href</
 <p>This method is automatically called when an <code>URL</code> object is serialized
 with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify"><code>JSON.stringify()</code></a>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> myURLs = [
-  <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://www.example.com'</span>),
-  <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://test.example.org'</span>)
+  <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://www.example.com'</span>),
+  <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://test.example.org'</span>),
 ];
-<span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">JSON</span>.stringify(myURLs));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">stringify</span>(myURLs));
 <span class="hljs-comment">// Prints ["https://www.example.com/","https://test.example.org/"]</span></code></pre>
-<h3>Class: <code>URLSearchParams</code><span><a class="mark" href="#url_class_urlsearchparams" id="url_class_urlsearchparams">#</a></span></h3>
+<h4>Class: <code>URLSearchParams</code><span><a class="mark" href="#url_class_urlsearchparams" id="url_class_urlsearchparams">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -675,39 +711,39 @@ The <code>URLSearchParams</code> class is also available on the global object.</
 similar purpose, but the purpose of the <a href="querystring.html"><code>querystring</code></a> module is more
 general, as it allows the customization of delimiter characters (<code>&#x26;</code> and <code>=</code>).
 On the other hand, this API is designed purely for URL query strings.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/?abc=123'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.searchParams.get(<span class="hljs-string">'abc'</span>));
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/?abc=123'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">get</span>(<span class="hljs-string">'abc'</span>));
 <span class="hljs-comment">// Prints 123</span>
 
-myURL.searchParams.append(<span class="hljs-string">'abc'</span>, <span class="hljs-string">'xyz'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">append</span>(<span class="hljs-string">'abc'</span>, <span class="hljs-string">'xyz'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?abc=123&#x26;abc=xyz</span>
 
-myURL.searchParams.delete(<span class="hljs-string">'abc'</span>);
-myURL.searchParams.set(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">delete</span>(<span class="hljs-string">'abc'</span>);
+myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">set</span>(<span class="hljs-string">'a'</span>, <span class="hljs-string">'b'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?a=b</span>
 
-<span class="hljs-keyword">const</span> newSearchParams = <span class="hljs-keyword">new</span> URLSearchParams(myURL.searchParams);
+<span class="hljs-keyword">const</span> newSearchParams = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(myURL.<span class="hljs-property">searchParams</span>);
 <span class="hljs-comment">// The above is equivalent to</span>
 <span class="hljs-comment">// const newSearchParams = new URLSearchParams(myURL.search);</span>
 
-newSearchParams.append(<span class="hljs-string">'a'</span>, <span class="hljs-string">'c'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+newSearchParams.<span class="hljs-title function_">append</span>(<span class="hljs-string">'a'</span>, <span class="hljs-string">'c'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?a=b</span>
-<span class="hljs-built_in">console</span>.log(newSearchParams.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(newSearchParams.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints a=b&#x26;a=c</span>
 
 <span class="hljs-comment">// newSearchParams.toString() is implicitly called</span>
-myURL.search = newSearchParams;
-<span class="hljs-built_in">console</span>.log(myURL.href);
+myURL.<span class="hljs-property">search</span> = newSearchParams;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?a=b&#x26;a=c</span>
-newSearchParams.delete(<span class="hljs-string">'a'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+newSearchParams.<span class="hljs-title function_">delete</span>(<span class="hljs-string">'a'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://example.org/?a=b&#x26;a=c</span></code></pre>
-<h4><code>new URLSearchParams()</code><span><a class="mark" href="#url_new_urlsearchparams" id="url_new_urlsearchparams">#</a></span></h4>
+<h5><code>new URLSearchParams()</code><span><a class="mark" href="#url_new_urlsearchparams" id="url_new_urlsearchparams">#</a></span></h5>
 <p>Instantiate a new empty <code>URLSearchParams</code> object.</p>
-<h4><code>new URLSearchParams(string)</code><span><a class="mark" href="#url_new_urlsearchparams_string" id="url_new_urlsearchparams_string">#</a></span></h4>
+<h5><code>new URLSearchParams(string)</code><span><a class="mark" href="#url_new_urlsearchparams_string" id="url_new_urlsearchparams_string">#</a></span></h5>
 <ul>
 <li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A query string</li>
 </ul>
@@ -715,16 +751,16 @@ newSearchParams.delete(<span class="hljs-string">'a'</span>);
 <code>URLSearchParams</code> object. A leading <code>'?'</code>, if present, is ignored.</p>
 <pre><code class="language-js"><span class="hljs-keyword">let</span> params;
 
-params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'user=abc&#x26;query=xyz'</span>);
-<span class="hljs-built_in">console</span>.log(params.get(<span class="hljs-string">'user'</span>));
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'user=abc&#x26;query=xyz'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">get</span>(<span class="hljs-string">'user'</span>));
 <span class="hljs-comment">// Prints 'abc'</span>
-<span class="hljs-built_in">console</span>.log(params.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=xyz'</span>
 
-params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'?user=abc&#x26;query=xyz'</span>);
-<span class="hljs-built_in">console</span>.log(params.toString());
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'?user=abc&#x26;query=xyz'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=xyz'</span></code></pre>
-<h4><code>new URLSearchParams(obj)</code><span><a class="mark" href="#url_new_urlsearchparams_obj" id="url_new_urlsearchparams_obj">#</a></span></h4>
+<h5><code>new URLSearchParams(obj)</code><span><a class="mark" href="#url_new_urlsearchparams_obj" id="url_new_urlsearchparams_obj">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v7.10.0, v6.13.0</span>
 </div>
@@ -736,15 +772,15 @@ value of each property of <code>obj</code> are always coerced to strings.</p>
 <p>Unlike <a href="querystring.html"><code>querystring</code></a> module, duplicate keys in the form of array values are
 not allowed. Arrays are stringified using <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString"><code>array.toString()</code></a>, which simply
 joins all array elements with commas.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>({
   <span class="hljs-attr">user</span>: <span class="hljs-string">'abc'</span>,
   <span class="hljs-attr">query</span>: [<span class="hljs-string">'first'</span>, <span class="hljs-string">'second'</span>]
 });
-<span class="hljs-built_in">console</span>.log(params.getAll(<span class="hljs-string">'query'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">getAll</span>(<span class="hljs-string">'query'</span>));
 <span class="hljs-comment">// Prints [ 'first,second' ]</span>
-<span class="hljs-built_in">console</span>.log(params.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=first%2Csecond'</span></code></pre>
-<h4><code>new URLSearchParams(iterable)</code><span><a class="mark" href="#url_new_urlsearchparams_iterable" id="url_new_urlsearchparams_iterable">#</a></span></h4>
+<h5><code>new URLSearchParams(iterable)</code><span><a class="mark" href="#url_new_urlsearchparams_iterable" id="url_new_urlsearchparams_iterable">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v7.10.0, v6.13.0</span>
 </div>
@@ -761,50 +797,50 @@ themselves be any iterable object.</p>
 <pre><code class="language-js"><span class="hljs-keyword">let</span> params;
 
 <span class="hljs-comment">// Using an array</span>
-params = <span class="hljs-keyword">new</span> URLSearchParams([
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>([
   [<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>],
   [<span class="hljs-string">'query'</span>, <span class="hljs-string">'first'</span>],
-  [<span class="hljs-string">'query'</span>, <span class="hljs-string">'second'</span>]
+  [<span class="hljs-string">'query'</span>, <span class="hljs-string">'second'</span>],
 ]);
-<span class="hljs-built_in">console</span>.log(params.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=first&#x26;query=second'</span>
 
 <span class="hljs-comment">// Using a Map object</span>
-<span class="hljs-keyword">const</span> map = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>();
-map.set(<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>);
-map.set(<span class="hljs-string">'query'</span>, <span class="hljs-string">'xyz'</span>);
-params = <span class="hljs-keyword">new</span> URLSearchParams(map);
-<span class="hljs-built_in">console</span>.log(params.toString());
+<span class="hljs-keyword">const</span> map = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>();
+map.<span class="hljs-title function_">set</span>(<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>);
+map.<span class="hljs-title function_">set</span>(<span class="hljs-string">'query'</span>, <span class="hljs-string">'xyz'</span>);
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(map);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=xyz'</span>
 
 <span class="hljs-comment">// Using a generator function</span>
-<span class="hljs-function"><span class="hljs-keyword">function</span>* <span class="hljs-title">getQueryPairs</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">function</span>* <span class="hljs-title function_">getQueryPairs</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">yield</span> [<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>];
   <span class="hljs-keyword">yield</span> [<span class="hljs-string">'query'</span>, <span class="hljs-string">'first'</span>];
   <span class="hljs-keyword">yield</span> [<span class="hljs-string">'query'</span>, <span class="hljs-string">'second'</span>];
 }
-params = <span class="hljs-keyword">new</span> URLSearchParams(getQueryPairs());
-<span class="hljs-built_in">console</span>.log(params.toString());
+params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-title function_">getQueryPairs</span>());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints 'user=abc&#x26;query=first&#x26;query=second'</span>
 
 <span class="hljs-comment">// Each key-value pair must have exactly two elements</span>
-<span class="hljs-keyword">new</span> URLSearchParams([
-  [<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>, <span class="hljs-string">'error'</span>]
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>([
+  [<span class="hljs-string">'user'</span>, <span class="hljs-string">'abc'</span>, <span class="hljs-string">'error'</span>],
 ]);
 <span class="hljs-comment">// Throws TypeError [ERR_INVALID_TUPLE]:</span>
 <span class="hljs-comment">//        Each query pair must be an iterable [name, value] tuple</span></code></pre>
-<h4><code>urlSearchParams.append(name, value)</code><span><a class="mark" href="#url_urlsearchparams_append_name_value" id="url_urlsearchparams_append_name_value">#</a></span></h4>
+<h5><code>urlSearchParams.append(name, value)</code><span><a class="mark" href="#url_urlsearchparams_append_name_value" id="url_urlsearchparams_append_name_value">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Append a new name-value pair to the query string.</p>
-<h4><code>urlSearchParams.delete(name)</code><span><a class="mark" href="#url_urlsearchparams_delete_name" id="url_urlsearchparams_delete_name">#</a></span></h4>
+<h5><code>urlSearchParams.delete(name)</code><span><a class="mark" href="#url_urlsearchparams_delete_name" id="url_urlsearchparams_delete_name">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Remove all name-value pairs whose name is <code>name</code>.</p>
-<h4><code>urlSearchParams.entries()</code><span><a class="mark" href="#url_urlsearchparams_entries" id="url_urlsearchparams_entries">#</a></span></h4>
+<h5><code>urlSearchParams.entries()</code><span><a class="mark" href="#url_urlsearchparams_entries" id="url_urlsearchparams_entries">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
@@ -812,20 +848,20 @@ params = <span class="hljs-keyword">new</span> URLSearchParams(getQueryPairs());
 Each item of the iterator is a JavaScript <code>Array</code>. The first item of the <code>Array</code>
 is the <code>name</code>, the second item of the <code>Array</code> is the <code>value</code>.</p>
 <p>Alias for <a href="#url_urlsearchparams_symbol_iterator"><code>urlSearchParams[@@iterator]()</code></a>.</p>
-<h4><code>urlSearchParams.forEach(fn[, thisArg])</code><span><a class="mark" href="#url_urlsearchparams_foreach_fn_thisarg" id="url_urlsearchparams_foreach_fn_thisarg">#</a></span></h4>
+<h5><code>urlSearchParams.forEach(fn[, thisArg])</code><span><a class="mark" href="#url_urlsearchparams_foreach_fn_thisarg" id="url_urlsearchparams_foreach_fn_thisarg">#</a></span></h5>
 <ul>
 <li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Invoked for each name-value pair in the query</li>
 <li><code>thisArg</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> To be used as <code>this</code> value for when <code>fn</code> is called</li>
 </ul>
 <p>Iterates over each name-value pair in the query and invokes the given function.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://example.org/?a=b&#x26;c=d'</span>);
-myURL.searchParams.forEach(<span class="hljs-function">(<span class="hljs-params">value, name, searchParams</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(name, value, myURL.searchParams === searchParams);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://example.org/?a=b&#x26;c=d'</span>);
+myURL.<span class="hljs-property">searchParams</span>.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">value, name, searchParams</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(name, value, myURL.<span class="hljs-property">searchParams</span> === searchParams);
 });
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   a b true</span>
 <span class="hljs-comment">//   c d true</span></code></pre>
-<h4><code>urlSearchParams.get(name)</code><span><a class="mark" href="#url_urlsearchparams_get_name" id="url_urlsearchparams_get_name">#</a></span></h4>
+<h5><code>urlSearchParams.get(name)</code><span><a class="mark" href="#url_urlsearchparams_get_name" id="url_urlsearchparams_get_name">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> or <code>null</code> if there is no name-value pair with the given
@@ -833,32 +869,32 @@ myURL.searchParams.forEach(<span class="hljs-function">(<span class="hljs-params
 </ul>
 <p>Returns the value of the first name-value pair whose name is <code>name</code>. If there
 are no such pairs, <code>null</code> is returned.</p>
-<h4><code>urlSearchParams.getAll(name)</code><span><a class="mark" href="#url_urlsearchparams_getall_name" id="url_urlsearchparams_getall_name">#</a></span></h4>
+<h5><code>urlSearchParams.getAll(name)</code><span><a class="mark" href="#url_urlsearchparams_getall_name" id="url_urlsearchparams_getall_name">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
 <p>Returns the values of all name-value pairs whose name is <code>name</code>. If there are
 no such pairs, an empty array is returned.</p>
-<h4><code>urlSearchParams.has(name)</code><span><a class="mark" href="#url_urlsearchparams_has_name" id="url_urlsearchparams_has_name">#</a></span></h4>
+<h5><code>urlSearchParams.has(name)</code><span><a class="mark" href="#url_urlsearchparams_has_name" id="url_urlsearchparams_has_name">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if there is at least one name-value pair whose name is <code>name</code>.</p>
-<h4><code>urlSearchParams.keys()</code><span><a class="mark" href="#url_urlsearchparams_keys" id="url_urlsearchparams_keys">#</a></span></h4>
+<h5><code>urlSearchParams.keys()</code><span><a class="mark" href="#url_urlsearchparams_keys" id="url_urlsearchparams_keys">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
 <p>Returns an ES6 <code>Iterator</code> over the names of each name-value pair.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'foo=bar&#x26;foo=baz'</span>);
-<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> name <span class="hljs-keyword">of</span> params.keys()) {
-  <span class="hljs-built_in">console</span>.log(name);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'foo=bar&#x26;foo=baz'</span>);
+<span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> name <span class="hljs-keyword">of</span> params.<span class="hljs-title function_">keys</span>()) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(name);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   foo</span>
 <span class="hljs-comment">//   foo</span></code></pre>
-<h4><code>urlSearchParams.set(name, value)</code><span><a class="mark" href="#url_urlsearchparams_set_name_value" id="url_urlsearchparams_set_name_value">#</a></span></h4>
+<h5><code>urlSearchParams.set(name, value)</code><span><a class="mark" href="#url_urlsearchparams_set_name_value" id="url_urlsearchparams_set_name_value">#</a></span></h5>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
@@ -867,18 +903,18 @@ no such pairs, an empty array is returned.</p>
 <code>value</code>. If there are any pre-existing name-value pairs whose names are <code>name</code>,
 set the first such pair's value to <code>value</code> and remove all others. If not,
 append the name-value pair to the query string.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams();
-params.append(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
-params.append(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'baz'</span>);
-params.append(<span class="hljs-string">'abc'</span>, <span class="hljs-string">'def'</span>);
-<span class="hljs-built_in">console</span>.log(params.toString());
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>();
+params.<span class="hljs-title function_">append</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>);
+params.<span class="hljs-title function_">append</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'baz'</span>);
+params.<span class="hljs-title function_">append</span>(<span class="hljs-string">'abc'</span>, <span class="hljs-string">'def'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints foo=bar&#x26;foo=baz&#x26;abc=def</span>
 
-params.set(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'def'</span>);
-params.set(<span class="hljs-string">'xyz'</span>, <span class="hljs-string">'opq'</span>);
-<span class="hljs-built_in">console</span>.log(params.toString());
+params.<span class="hljs-title function_">set</span>(<span class="hljs-string">'foo'</span>, <span class="hljs-string">'def'</span>);
+params.<span class="hljs-title function_">set</span>(<span class="hljs-string">'xyz'</span>, <span class="hljs-string">'opq'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints foo=def&#x26;abc=def&#x26;xyz=opq</span></code></pre>
-<h4><code>urlSearchParams.sort()</code><span><a class="mark" href="#url_urlsearchparams_sort" id="url_urlsearchparams_sort">#</a></span></h4>
+<h5><code>urlSearchParams.sort()</code><span><a class="mark" href="#url_urlsearchparams_sort" id="url_urlsearchparams_sort">#</a></span></h5>
 <div class="api_metadata">
 <span>Added in: v7.7.0, v6.13.0</span>
 </div>
@@ -886,22 +922,22 @@ params.set(<span class="hljs-string">'xyz'</span>, <span class="hljs-string">'op
 with a <a href="https://en.wikipedia.org/wiki/Sorting_algorithm#Stability">stable sorting algorithm</a>, so relative order between name-value pairs
 with the same name is preserved.</p>
 <p>This method can be used, in particular, to increase cache hits.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'query[]=abc&#x26;type=search&#x26;query[]=123'</span>);
-params.sort();
-<span class="hljs-built_in">console</span>.log(params.toString());
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'query[]=abc&#x26;type=search&#x26;query[]=123'</span>);
+params.<span class="hljs-title function_">sort</span>();
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(params.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints query%5B%5D=abc&#x26;query%5B%5D=123&#x26;type=search</span></code></pre>
-<h4><code>urlSearchParams.toString()</code><span><a class="mark" href="#url_urlsearchparams_tostring" id="url_urlsearchparams_tostring">#</a></span></h4>
+<h5><code>urlSearchParams.toString()</code><span><a class="mark" href="#url_urlsearchparams_tostring" id="url_urlsearchparams_tostring">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>Returns the search parameters serialized as a string, with characters
 percent-encoded where necessary.</p>
-<h4><code>urlSearchParams.values()</code><span><a class="mark" href="#url_urlsearchparams_values" id="url_urlsearchparams_values">#</a></span></h4>
+<h5><code>urlSearchParams.values()</code><span><a class="mark" href="#url_urlsearchparams_values" id="url_urlsearchparams_values">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
 <p>Returns an ES6 <code>Iterator</code> over the values of each name-value pair.</p>
-<h4><code>urlSearchParams[Symbol.iterator]()</code><span><a class="mark" href="#url_urlsearchparams_symbol_iterator" id="url_urlsearchparams_symbol_iterator">#</a></span></h4>
+<h5><code>urlSearchParams[Symbol.iterator]()</code><span><a class="mark" href="#url_urlsearchparams_symbol_iterator" id="url_urlsearchparams_symbol_iterator">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol" class="type">&#x3C;Iterator></a></li>
 </ul>
@@ -909,14 +945,14 @@ percent-encoded where necessary.</p>
 Each item of the iterator is a JavaScript <code>Array</code>. The first item of the <code>Array</code>
 is the <code>name</code>, the second item of the <code>Array</code> is the <code>value</code>.</p>
 <p>Alias for <a href="#url_urlsearchparams_entries"><code>urlSearchParams.entries()</code></a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> URLSearchParams(<span class="hljs-string">'foo=bar&#x26;xyz=baz'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> params = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URLSearchParams</span>(<span class="hljs-string">'foo=bar&#x26;xyz=baz'</span>);
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> [name, value] <span class="hljs-keyword">of</span> params) {
-  <span class="hljs-built_in">console</span>.log(name, value);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(name, value);
 }
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   foo bar</span>
 <span class="hljs-comment">//   xyz baz</span></code></pre>
-<h3><code>url.domainToASCII(domain)</code><span><a class="mark" href="#url_url_domaintoascii_domain" id="url_url_domaintoascii_domain">#</a></span></h3>
+<h4><code>url.domainToASCII(domain)</code><span><a class="mark" href="#url_url_domaintoascii_domain" id="url_url_domaintoascii_domain">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.4.0, v6.13.0</span>
 </div>
@@ -927,14 +963,16 @@ is the <code>name</code>, the second item of the <code>Array</code> is the <code
 <p>Returns the <a href="https://tools.ietf.org/html/rfc5891#section-4.4">Punycode</a> ASCII serialization of the <code>domain</code>. If <code>domain</code> is an
 invalid domain, the empty string is returned.</p>
 <p>It performs the inverse operation to <a href="#url_url_domaintounicode_domain"><code>url.domainToUnicode()</code></a>.</p>
+<p>This feature is only available if the <code>node</code> executable was compiled with
+<a href="intl.html#intl_options_for_building_node_js">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
-<span class="hljs-built_in">console</span>.log(url.domainToASCII(<span class="hljs-string">'español.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToASCII</span>(<span class="hljs-string">'español.com'</span>));
 <span class="hljs-comment">// Prints xn--espaol-zwa.com</span>
-<span class="hljs-built_in">console</span>.log(url.domainToASCII(<span class="hljs-string">'中文.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToASCII</span>(<span class="hljs-string">'中文.com'</span>));
 <span class="hljs-comment">// Prints xn--fiq228c.com</span>
-<span class="hljs-built_in">console</span>.log(url.domainToASCII(<span class="hljs-string">'xn--iñvalid.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToASCII</span>(<span class="hljs-string">'xn--iñvalid.com'</span>));
 <span class="hljs-comment">// Prints an empty string</span></code></pre>
-<h3><code>url.domainToUnicode(domain)</code><span><a class="mark" href="#url_url_domaintounicode_domain" id="url_url_domaintounicode_domain">#</a></span></h3>
+<h4><code>url.domainToUnicode(domain)</code><span><a class="mark" href="#url_url_domaintounicode_domain" id="url_url_domaintounicode_domain">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.4.0, v6.13.0</span>
 </div>
@@ -945,14 +983,16 @@ invalid domain, the empty string is returned.</p>
 <p>Returns the Unicode serialization of the <code>domain</code>. If <code>domain</code> is an invalid
 domain, the empty string is returned.</p>
 <p>It performs the inverse operation to <a href="#url_url_domaintoascii_domain"><code>url.domainToASCII()</code></a>.</p>
+<p>This feature is only available if the <code>node</code> executable was compiled with
+<a href="intl.html#intl_options_for_building_node_js">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
-<span class="hljs-built_in">console</span>.log(url.domainToUnicode(<span class="hljs-string">'xn--espaol-zwa.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToUnicode</span>(<span class="hljs-string">'xn--espaol-zwa.com'</span>));
 <span class="hljs-comment">// Prints español.com</span>
-<span class="hljs-built_in">console</span>.log(url.domainToUnicode(<span class="hljs-string">'xn--fiq228c.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToUnicode</span>(<span class="hljs-string">'xn--fiq228c.com'</span>));
 <span class="hljs-comment">// Prints 中文.com</span>
-<span class="hljs-built_in">console</span>.log(url.domainToUnicode(<span class="hljs-string">'xn--iñvalid.com'</span>));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">domainToUnicode</span>(<span class="hljs-string">'xn--iñvalid.com'</span>));
 <span class="hljs-comment">// Prints an empty string</span></code></pre>
-<h3><code>url.fileURLToPath(url)</code><span><a class="mark" href="#url_url_fileurltopath_url" id="url_url_fileurltopath_url">#</a></span></h3>
+<h4><code>url.fileURLToPath(url)</code><span><a class="mark" href="#url_url_fileurltopath_url" id="url_url_fileurltopath_url">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -962,18 +1002,34 @@ domain, the empty string is returned.</p>
 </ul>
 <p>This function ensures the correct decodings of percent-encoded characters as
 well as ensuring a cross-platform valid absolute path string.</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///C:/path/'</span>).pathname;    <span class="hljs-comment">// Incorrect: /C:/path/</span>
-fileURLToPath(<span class="hljs-string">'file:///C:/path/'</span>);       <span class="hljs-comment">// Correct:   C:\path\ (Windows)</span>
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file://nas/foo.txt'</span>).pathname;  <span class="hljs-comment">// Incorrect: /foo.txt</span>
-fileURLToPath(<span class="hljs-string">'file://nas/foo.txt'</span>);     <span class="hljs-comment">// Correct:   \\nas\foo.txt (Windows)</span>
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { fileURLToPath } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
+
+<span class="hljs-keyword">const</span> __filename = <span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>);
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///你好.txt'</span>).pathname;    <span class="hljs-comment">// Incorrect: /%E4%BD%A0%E5%A5%BD.txt</span>
-fileURLToPath(<span class="hljs-string">'file:///你好.txt'</span>);       <span class="hljs-comment">// Correct:   /你好.txt (POSIX)</span>
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/path/'</span>).<span class="hljs-property">pathname</span>;      <span class="hljs-comment">// Incorrect: /C:/path/</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///C:/path/'</span>);         <span class="hljs-comment">// Correct:   C:\path\ (Windows)</span>
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'file:///hello world'</span>).pathname; <span class="hljs-comment">// Incorrect: /hello%20world</span>
-fileURLToPath(<span class="hljs-string">'file:///hello world'</span>);    <span class="hljs-comment">// Correct:   /hello world (POSIX)</span></code></pre>
-<h3><code>url.format(URL[, options])</code><span><a class="mark" href="#url_url_format_url_options" id="url_url_format_url_options">#</a></span></h3>
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file://nas/foo.txt'</span>).<span class="hljs-property">pathname</span>;    <span class="hljs-comment">// Incorrect: /foo.txt</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file://nas/foo.txt'</span>);       <span class="hljs-comment">// Correct:   \\nas\foo.txt (Windows)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///你好.txt'</span>).<span class="hljs-property">pathname</span>;      <span class="hljs-comment">// Incorrect: /%E4%BD%A0%E5%A5%BD.txt</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///你好.txt'</span>);         <span class="hljs-comment">// Correct:   /你好.txt (POSIX)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///hello world'</span>).<span class="hljs-property">pathname</span>;   <span class="hljs-comment">// Incorrect: /hello%20world</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///hello world'</span>);      <span class="hljs-comment">// Correct:   /hello world (POSIX)</span></code><code class="language-js cjs"><span class="hljs-keyword">const</span> { fileURLToPath } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///C:/path/'</span>).<span class="hljs-property">pathname</span>;      <span class="hljs-comment">// Incorrect: /C:/path/</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///C:/path/'</span>);         <span class="hljs-comment">// Correct:   C:\path\ (Windows)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file://nas/foo.txt'</span>).<span class="hljs-property">pathname</span>;    <span class="hljs-comment">// Incorrect: /foo.txt</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file://nas/foo.txt'</span>);       <span class="hljs-comment">// Correct:   \\nas\foo.txt (Windows)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///你好.txt'</span>).<span class="hljs-property">pathname</span>;      <span class="hljs-comment">// Incorrect: /%E4%BD%A0%E5%A5%BD.txt</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///你好.txt'</span>);         <span class="hljs-comment">// Correct:   /你好.txt (POSIX)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'file:///hello world'</span>).<span class="hljs-property">pathname</span>;   <span class="hljs-comment">// Incorrect: /hello%20world</span>
+<span class="hljs-title function_">fileURLToPath</span>(<span class="hljs-string">'file:///hello world'</span>);      <span class="hljs-comment">// Correct:   /hello world (POSIX)</span></code></pre>
+<h4><code>url.format(URL[, options])</code><span><a class="mark" href="#url_url_format_url_options" id="url_url_format_url_options">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v7.6.0</span>
 </div>
@@ -1000,17 +1056,29 @@ Punycode encoded. <strong>Default:</strong> <code>false</code>.</li>
 string serializations of the URL. These are not, however, customizable in
 any way. The <code>url.format(URL[, options])</code> method allows for basic customization
 of the output.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://a:b@測試?abc#foo'</span>);
 
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> url <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
+<span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://a:b@測試?abc#foo'</span>);
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://a:b@xn--g6w251d/?abc#foo</span>
 
-<span class="hljs-built_in">console</span>.log(myURL.toString());
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-title function_">toString</span>());
 <span class="hljs-comment">// Prints https://a:b@xn--g6w251d/?abc#foo</span>
 
-<span class="hljs-built_in">console</span>.log(url.format(myURL, { <span class="hljs-attr">fragment</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">unicode</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">auth</span>: <span class="hljs-literal">false</span> }));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">format</span>(myURL, { <span class="hljs-attr">fragment</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">unicode</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">auth</span>: <span class="hljs-literal">false</span> }));
+<span class="hljs-comment">// Prints 'https://測試/?abc'</span></code><code class="language-js cjs"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://a:b@測試?abc#foo'</span>);
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
+<span class="hljs-comment">// Prints https://a:b@xn--g6w251d/?abc#foo</span>
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-title function_">toString</span>());
+<span class="hljs-comment">// Prints https://a:b@xn--g6w251d/?abc#foo</span>
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(url.<span class="hljs-title function_">format</span>(myURL, { <span class="hljs-attr">fragment</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">unicode</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">auth</span>: <span class="hljs-literal">false</span> }));
 <span class="hljs-comment">// Prints 'https://測試/?abc'</span></code></pre>
-<h3><code>url.pathToFileURL(path)</code><span><a class="mark" href="#url_url_pathtofileurl_path" id="url_url_pathtofileurl_path">#</a></span></h3>
+<h4><code>url.pathToFileURL(path)</code><span><a class="mark" href="#url_url_pathtofileurl_path" id="url_url_pathtofileurl_path">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.12.0</span>
 </div>
@@ -1020,75 +1088,137 @@ of the output.</p>
 </ul>
 <p>This function ensures that <code>path</code> is resolved absolutely, and that the URL
 control characters are correctly encoded when converting into a File URL.</p>
-<pre><code class="language-js"><span class="hljs-keyword">new</span> URL(__filename);                <span class="hljs-comment">// Incorrect: throws (POSIX)</span>
-<span class="hljs-keyword">new</span> URL(__filename);                <span class="hljs-comment">// Incorrect: C:\... (Windows)</span>
-pathToFileURL(__filename);          <span class="hljs-comment">// Correct:   file:///... (POSIX)</span>
-pathToFileURL(__filename);          <span class="hljs-comment">// Correct:   file:///C:/... (Windows)</span>
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'/foo#1'</span>, <span class="hljs-string">'file:'</span>);         <span class="hljs-comment">// Incorrect: file:///foo#1</span>
-pathToFileURL(<span class="hljs-string">'/foo#1'</span>);            <span class="hljs-comment">// Correct:   file:///foo%231 (POSIX)</span>
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> { pathToFileURL } <span class="hljs-keyword">from</span> <span class="hljs-string">'url'</span>;
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/foo#1'</span>, <span class="hljs-string">'file:'</span>);           <span class="hljs-comment">// Incorrect: file:///foo#1</span>
+<span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">'/foo#1'</span>);              <span class="hljs-comment">// Correct:   file:///foo%231 (POSIX)</span>
 
-<span class="hljs-keyword">new</span> URL(<span class="hljs-string">'/some/path%.c'</span>, <span class="hljs-string">'file:'</span>); <span class="hljs-comment">// Incorrect: file:///some/path%.c</span>
-pathToFileURL(<span class="hljs-string">'/some/path%.c'</span>);    <span class="hljs-comment">// Correct:   file:///some/path%25.c (POSIX)</span></code></pre>
-<h2>Legacy URL API<span><a class="mark" href="#url_legacy_url_api" id="url_legacy_url_api">#</a></span></h2>
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/some/path%.c'</span>, <span class="hljs-string">'file:'</span>);    <span class="hljs-comment">// Incorrect: file:///some/path%.c</span>
+<span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">'/some/path%.c'</span>);       <span class="hljs-comment">// Correct:   file:///some/path%25.c (POSIX)</span></code><code class="language-js cjs"><span class="hljs-keyword">const</span> { pathToFileURL } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(__filename);                  <span class="hljs-comment">// Incorrect: throws (POSIX)</span>
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(__filename);                  <span class="hljs-comment">// Incorrect: C:\... (Windows)</span>
+<span class="hljs-title function_">pathToFileURL</span>(__filename);            <span class="hljs-comment">// Correct:   file:///... (POSIX)</span>
+<span class="hljs-title function_">pathToFileURL</span>(__filename);            <span class="hljs-comment">// Correct:   file:///C:/... (Windows)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/foo#1'</span>, <span class="hljs-string">'file:'</span>);           <span class="hljs-comment">// Incorrect: file:///foo#1</span>
+<span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">'/foo#1'</span>);              <span class="hljs-comment">// Correct:   file:///foo%231 (POSIX)</span>
+
+<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'/some/path%.c'</span>, <span class="hljs-string">'file:'</span>);    <span class="hljs-comment">// Incorrect: file:///some/path%.c</span>
+<span class="hljs-title function_">pathToFileURL</span>(<span class="hljs-string">'/some/path%.c'</span>);       <span class="hljs-comment">// Correct:   file:///some/path%25.c (POSIX)</span></code></pre>
+<h4><code>url.urlToHttpOptions(url)</code><span><a class="mark" href="#url_url_urltohttpoptions_url" id="url_url_urltohttpoptions_url">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>url</code> <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> The <a href="#url_the_whatwg_url_api">WHATWG URL</a> object to convert to an options object.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Options object
+<ul>
+<li><code>protocol</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Protocol to use.</li>
+<li><code>hostname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A domain name or IP address of the server to issue the
+request to.</li>
+<li><code>hash</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The fragment portion of the URL.</li>
+<li><code>search</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The serialized query portion of the URL.</li>
+<li><code>pathname</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The path portion of the URL.</li>
+<li><code>path</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Request path. Should include query string if any.
+E.G. <code>'/index.html?page=12'</code>. An exception is thrown when the request path
+contains illegal characters. Currently, only spaces are rejected but that
+may change in the future.</li>
+<li><code>href</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The serialized URL.</li>
+<li><code>port</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Port of remote server.</li>
+<li><code>auth</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Basic authentication i.e. <code>'user:password'</code> to compute an
+Authorization header.</li>
+</ul>
+</li>
+</ul>
+<p>This utility function converts a URL object into an ordinary options object as
+expected by the <a href="http.html#http_http_request_options_callback"><code>http.request()</code></a> and <a href="https.html#https_https_request_options_callback"><code>https.request()</code></a> APIs.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { urlToHttpOptions } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+<span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://a:b@測試?abc#foo'</span>);
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">urlToHttpOptions</span>(myUrl));
+<span class="hljs-comment">/**
+{
+  protocol: 'https:',
+  hostname: 'xn--g6w251d',
+  hash: '#foo',
+  search: '?abc',
+  pathname: '/',
+  path: '/?abc',
+  href: 'https://a:b<span class="hljs-doctag">@xn</span>--g6w251d/?abc#foo',
+  auth: 'a:b'
+}
+*/</span></code></pre>
+</section><section><h3>Legacy URL API<span><a class="mark" href="#url_legacy_url_api" id="url_legacy_url_api">#</a></span></h3>
 <div class="api_metadata">
-<span>Deprecated since: v11.0.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
+<tr><td>v11.0.0</td>
+<td><p>This API is deprecated.</p></td></tr>
+</tbody></table>
+</details>
 </div>
-<h3>Legacy <code>urlObject</code><span><a class="mark" href="#url_legacy_urlobject" id="url_legacy_urlobject">#</a></span></h3>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
+<h4>Legacy <code>urlObject</code><span><a class="mark" href="#url_legacy_urlobject" id="url_legacy_urlobject">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>The Legacy URL API is deprecated. Use the WHATWG URL API.</p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use the WHATWG URL API instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
 <p>The legacy <code>urlObject</code> (<code>require('url').Url</code>) is created and returned by the
 <code>url.parse()</code> function.</p>
-<h4><code>urlObject.auth</code><span><a class="mark" href="#url_urlobject_auth" id="url_urlobject_auth">#</a></span></h4>
+<h5><code>urlObject.auth</code><span><a class="mark" href="#url_urlobject_auth" id="url_urlobject_auth">#</a></span></h5>
 <p>The <code>auth</code> property is the username and password portion of the URL, also
 referred to as <em>userinfo</em>. This string subset follows the <code>protocol</code> and
 double slashes (if present) and precedes the <code>host</code> component, delimited by <code>@</code>.
 The string is either the username, or it is the username and password separated
 by <code>:</code>.</p>
 <p>For example: <code>'user:pass'</code>.</p>
-<h4><code>urlObject.hash</code><span><a class="mark" href="#url_urlobject_hash" id="url_urlobject_hash">#</a></span></h4>
+<h5><code>urlObject.hash</code><span><a class="mark" href="#url_urlobject_hash" id="url_urlobject_hash">#</a></span></h5>
 <p>The <code>hash</code> property is the fragment identifier portion of the URL including the
 leading <code>#</code> character.</p>
 <p>For example: <code>'#hash'</code>.</p>
-<h4><code>urlObject.host</code><span><a class="mark" href="#url_urlobject_host" id="url_urlobject_host">#</a></span></h4>
+<h5><code>urlObject.host</code><span><a class="mark" href="#url_urlobject_host" id="url_urlobject_host">#</a></span></h5>
 <p>The <code>host</code> property is the full lower-cased host portion of the URL, including
 the <code>port</code> if specified.</p>
 <p>For example: <code>'sub.example.com:8080'</code>.</p>
-<h4><code>urlObject.hostname</code><span><a class="mark" href="#url_urlobject_hostname" id="url_urlobject_hostname">#</a></span></h4>
+<h5><code>urlObject.hostname</code><span><a class="mark" href="#url_urlobject_hostname" id="url_urlobject_hostname">#</a></span></h5>
 <p>The <code>hostname</code> property is the lower-cased host name portion of the <code>host</code>
 component <em>without</em> the <code>port</code> included.</p>
 <p>For example: <code>'sub.example.com'</code>.</p>
-<h4><code>urlObject.href</code><span><a class="mark" href="#url_urlobject_href" id="url_urlobject_href">#</a></span></h4>
+<h5><code>urlObject.href</code><span><a class="mark" href="#url_urlobject_href" id="url_urlobject_href">#</a></span></h5>
 <p>The <code>href</code> property is the full URL string that was parsed with both the
 <code>protocol</code> and <code>host</code> components converted to lower-case.</p>
 <p>For example: <code>'http://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>.</p>
-<h4><code>urlObject.path</code><span><a class="mark" href="#url_urlobject_path" id="url_urlobject_path">#</a></span></h4>
+<h5><code>urlObject.path</code><span><a class="mark" href="#url_urlobject_path" id="url_urlobject_path">#</a></span></h5>
 <p>The <code>path</code> property is a concatenation of the <code>pathname</code> and <code>search</code>
 components.</p>
 <p>For example: <code>'/p/a/t/h?query=string'</code>.</p>
 <p>No decoding of the <code>path</code> is performed.</p>
-<h4><code>urlObject.pathname</code><span><a class="mark" href="#url_urlobject_pathname" id="url_urlobject_pathname">#</a></span></h4>
+<h5><code>urlObject.pathname</code><span><a class="mark" href="#url_urlobject_pathname" id="url_urlobject_pathname">#</a></span></h5>
 <p>The <code>pathname</code> property consists of the entire path section of the URL. This
 is everything following the <code>host</code> (including the <code>port</code>) and before the start
 of the <code>query</code> or <code>hash</code> components, delimited by either the ASCII question
 mark (<code>?</code>) or hash (<code>#</code>) characters.</p>
 <p>For example: <code>'/p/a/t/h'</code>.</p>
 <p>No decoding of the path string is performed.</p>
-<h4><code>urlObject.port</code><span><a class="mark" href="#url_urlobject_port" id="url_urlobject_port">#</a></span></h4>
+<h5><code>urlObject.port</code><span><a class="mark" href="#url_urlobject_port" id="url_urlobject_port">#</a></span></h5>
 <p>The <code>port</code> property is the numeric port portion of the <code>host</code> component.</p>
 <p>For example: <code>'8080'</code>.</p>
-<h4><code>urlObject.protocol</code><span><a class="mark" href="#url_urlobject_protocol" id="url_urlobject_protocol">#</a></span></h4>
+<h5><code>urlObject.protocol</code><span><a class="mark" href="#url_urlobject_protocol" id="url_urlobject_protocol">#</a></span></h5>
 <p>The <code>protocol</code> property identifies the URL's lower-cased protocol scheme.</p>
 <p>For example: <code>'http:'</code>.</p>
-<h4><code>urlObject.query</code><span><a class="mark" href="#url_urlobject_query" id="url_urlobject_query">#</a></span></h4>
+<h5><code>urlObject.query</code><span><a class="mark" href="#url_urlobject_query" id="url_urlobject_query">#</a></span></h5>
 <p>The <code>query</code> property is either the query string without the leading ASCII
 question mark (<code>?</code>), or an object returned by the <a href="querystring.html"><code>querystring</code></a> module's
 <code>parse()</code> method. Whether the <code>query</code> property is a string or object is
@@ -1096,20 +1226,22 @@ determined by the <code>parseQueryString</code> argument passed to <code>url.par
 <p>For example: <code>'query=string'</code> or <code>{'query': 'string'}</code>.</p>
 <p>If returned as a string, no decoding of the query string is performed. If
 returned as an object, both keys and values are decoded.</p>
-<h4><code>urlObject.search</code><span><a class="mark" href="#url_urlobject_search" id="url_urlobject_search">#</a></span></h4>
+<h5><code>urlObject.search</code><span><a class="mark" href="#url_urlobject_search" id="url_urlobject_search">#</a></span></h5>
 <p>The <code>search</code> property consists of the entire "query string" portion of the
 URL, including the leading ASCII question mark (<code>?</code>) character.</p>
 <p>For example: <code>'?query=string'</code>.</p>
 <p>No decoding of the query string is performed.</p>
-<h4><code>urlObject.slashes</code><span><a class="mark" href="#url_urlobject_slashes" id="url_urlobject_slashes">#</a></span></h4>
+<h5><code>urlObject.slashes</code><span><a class="mark" href="#url_urlobject_slashes" id="url_urlobject_slashes">#</a></span></h5>
 <p>The <code>slashes</code> property is a <code>boolean</code> with a value of <code>true</code> if two ASCII
 forward-slash characters (<code>/</code>) are required following the colon in the
 <code>protocol</code>.</p>
-<h3><code>url.format(urlObject)</code><span><a class="mark" href="#url_url_format_urlobject" id="url_url_format_urlobject">#</a></span></h3>
+<h4><code>url.format(urlObject)</code><span><a class="mark" href="#url_url_format_urlobject" id="url_url_format_urlobject">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>The Legacy URL API is deprecated. Use the WHATWG URL API.</p></td></tr>
 <tr><td>v7.0.0</td>
@@ -1119,7 +1251,7 @@ forward-slash characters (<code>/</code>) are required following the colon in th
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use the WHATWG URL API instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
 <ul>
 <li><code>urlObject</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> A URL object (as returned by <code>url.parse()</code> or
 constructed otherwise). If a string, it is converted to an object by passing
@@ -1127,7 +1259,8 @@ it to <code>url.parse()</code>.</li>
 </ul>
 <p>The <code>url.format()</code> method returns a formatted URL string derived from
 <code>urlObject</code>.</p>
-<pre><code class="language-js">url.format({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
+url.<span class="hljs-title function_">format</span>({
   <span class="hljs-attr">protocol</span>: <span class="hljs-string">'https'</span>,
   <span class="hljs-attr">hostname</span>: <span class="hljs-string">'example.com'</span>,
   <span class="hljs-attr">pathname</span>: <span class="hljs-string">'/some/path'</span>,
@@ -1210,11 +1343,13 @@ character, the literal string <code>#</code> is appended to <code>result</code>.
 string, an <a href="errors.html#errors_class_error"><code>Error</code></a> is thrown.</li>
 <li><code>result</code> is returned.</li>
 </ul>
-<h3><code>url.parse(urlString[, parseQueryString[, slashesDenoteHost]])</code><span><a class="mark" href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost" id="url_url_parse_urlstring_parsequerystring_slashesdenotehost">#</a></span></h3>
+<h4><code>url.parse(urlString[, parseQueryString[, slashesDenoteHost]])</code><span><a class="mark" href="#url_url_parse_urlstring_parsequerystring_slashesdenotehost" id="url_url_parse_urlstring_parsequerystring_slashesdenotehost">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.14.0</td>
 <td><p>The <code>pathname</code> property on the returned URL object is now <code>/</code> when there is no path and the protocol scheme is <code>ws:</code> or <code>wss:</code>.</p></td></tr>
 <tr><td>v11.0.0</td>
@@ -1226,7 +1361,7 @@ string, an <a href="errors.html#errors_class_error"><code>Error</code></a> is th
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use the WHATWG URL API instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
 <ul>
 <li><code>urlString</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The URL string to parse.</li>
 <li><code>parseQueryString</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the <code>query</code> property will always
@@ -1248,25 +1383,27 @@ use the WHATWG <code>URL</code> API. Because the <code>url.parse()</code> method
 lenient, non-standard algorithm for parsing URL strings, security
 issues can be introduced. Specifically, issues with <a href="https://hackerone.com/reports/678487">host name spoofing</a> and
 incorrect handling of usernames and passwords have been identified.</p>
-<h3><code>url.resolve(from, to)</code><span><a class="mark" href="#url_url_resolve_from_to" id="url_url_resolve_from_to">#</a></span></h3>
+<h4><code>url.resolve(from, to)</code><span><a class="mark" href="#url_url_resolve_from_to" id="url_url_resolve_from_to">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.17.0</td>
+<td><p>Deprecation revoked. Status changed to "Legacy".</p></td></tr>
 <tr><td>v11.0.0</td>
 <td><p>The Legacy URL API is deprecated. Use the WHATWG URL API.</p></td></tr>
 <tr><td>v6.6.0</td>
 <td><p>The <code>auth</code> fields are now kept intact when <code>from</code> and <code>to</code> refer to the same host.</p></td></tr>
-<tr><td>v6.5.0, v4.6.2</td>
-<td><p>The <code>port</code> field is copied correctly now.</p></td></tr>
 <tr><td>v6.0.0</td>
 <td><p>The <code>auth</code> fields is cleared now the <code>to</code> parameter contains a hostname.</p></td></tr>
+<tr><td>v6.5.0, v4.6.2</td>
+<td><p>The <code>port</code> field is copied correctly now.</p></td></tr>
 <tr><td>v0.1.25</td>
 <td><p><span>Added in: v0.1.25</span></p></td></tr>
 </tbody></table>
 </details>
 </div>
-<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use the WHATWG URL API instead.</div><p></p>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use the WHATWG URL API instead.</div><p></p>
 <ul>
 <li><code>from</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The Base URL being resolved against.</li>
 <li><code>to</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The HREF URL being resolved.</li>
@@ -1274,22 +1411,36 @@ incorrect handling of usernames and passwords have been identified.</p>
 <p>The <code>url.resolve()</code> method resolves a target URL relative to a base URL in a
 manner similar to that of a Web browser resolving an anchor tag HREF.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> url = <span class="hljs-built_in">require</span>(<span class="hljs-string">'url'</span>);
-url.resolve(<span class="hljs-string">'/one/two/three'</span>, <span class="hljs-string">'four'</span>);         <span class="hljs-comment">// '/one/two/four'</span>
-url.resolve(<span class="hljs-string">'http://example.com/'</span>, <span class="hljs-string">'/one'</span>);    <span class="hljs-comment">// 'http://example.com/one'</span>
-url.resolve(<span class="hljs-string">'http://example.com/one'</span>, <span class="hljs-string">'/two'</span>); <span class="hljs-comment">// 'http://example.com/two'</span></code></pre>
+url.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'/one/two/three'</span>, <span class="hljs-string">'four'</span>);         <span class="hljs-comment">// '/one/two/four'</span>
+url.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'http://example.com/'</span>, <span class="hljs-string">'/one'</span>);    <span class="hljs-comment">// 'http://example.com/one'</span>
+url.<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'http://example.com/one'</span>, <span class="hljs-string">'/two'</span>); <span class="hljs-comment">// 'http://example.com/two'</span></code></pre>
+<p>You can achieve the same result using the WHATWG URL API:</p>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">resolve</span>(<span class="hljs-params"><span class="hljs-keyword">from</span>, to</span>) {
+  <span class="hljs-keyword">const</span> resolvedUrl = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(to, <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-keyword">from</span>, <span class="hljs-string">'resolve://'</span>));
+  <span class="hljs-keyword">if</span> (resolvedUrl.<span class="hljs-property">protocol</span> === <span class="hljs-string">'resolve:'</span>) {
+    <span class="hljs-comment">// `from` is a relative URL.</span>
+    <span class="hljs-keyword">const</span> { pathname, search, hash } = resolvedUrl;
+    <span class="hljs-keyword">return</span> pathname + search + hash;
+  }
+  <span class="hljs-keyword">return</span> resolvedUrl.<span class="hljs-title function_">toString</span>();
+}
+
+<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'/one/two/three'</span>, <span class="hljs-string">'four'</span>);         <span class="hljs-comment">// '/one/two/four'</span>
+<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'http://example.com/'</span>, <span class="hljs-string">'/one'</span>);    <span class="hljs-comment">// 'http://example.com/one'</span>
+<span class="hljs-title function_">resolve</span>(<span class="hljs-string">'http://example.com/one'</span>, <span class="hljs-string">'/two'</span>); <span class="hljs-comment">// 'http://example.com/two'</span></code></pre>
 <p><a id="whatwg-percent-encoding"></a></p>
-<h2>Percent-encoding in URLs<span><a class="mark" href="#url_percent_encoding_in_urls" id="url_percent_encoding_in_urls">#</a></span></h2>
+</section><section><h3>Percent-encoding in URLs<span><a class="mark" href="#url_percent_encoding_in_urls" id="url_percent_encoding_in_urls">#</a></span></h3>
 <p>URLs are permitted to only contain a certain range of characters. Any character
 falling outside of that range must be encoded. How such characters are encoded,
 and which characters to encode depends entirely on where the character is
 located within the structure of the URL.</p>
-<h3>Legacy API<span><a class="mark" href="#url_legacy_api" id="url_legacy_api">#</a></span></h3>
+<h4>Legacy API<span><a class="mark" href="#url_legacy_api" id="url_legacy_api">#</a></span></h4>
 <p>Within the Legacy API, spaces (<code>' '</code>) and the following characters will be
 automatically escaped in the properties of URL objects:</p>
 <pre><code class="language-text">&#x3C; > " ` \r \n \t { } | \ ^ '</code></pre>
 <p>For example, the ASCII space character (<code>' '</code>) is encoded as <code>%20</code>. The ASCII
 forward slash (<code>/</code>) character is encoded as <code>%3C</code>.</p>
-<h3>WHATWG API<span><a class="mark" href="#url_whatwg_api" id="url_whatwg_api">#</a></span></h3>
+<h4>WHATWG API<span><a class="mark" href="#url_whatwg_api" id="url_whatwg_api">#</a></span></h4>
 <p>The <a href="https://url.spec.whatwg.org/">WHATWG URL Standard</a> uses a more selective and fine grained approach to
 selecting encoded characters than that used by the Legacy API.</p>
 <p>The WHATWG algorithm defines four "percent-encode sets" that describe ranges
@@ -1322,14 +1473,50 @@ specific conditions, in addition to all other cases.</p>
 <p>When non-ASCII characters appear within a host name, the host name is encoded
 using the <a href="https://tools.ietf.org/html/rfc5891#section-4.4">Punycode</a> algorithm. Note, however, that a host name <em>may</em> contain
 <em>both</em> Punycode encoded and percent-encoded characters:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> URL(<span class="hljs-string">'https://%CF%80.example.com/foo'</span>);
-<span class="hljs-built_in">console</span>.log(myURL.href);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> myURL = <span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-string">'https://%CF%80.example.com/foo'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">href</span>);
 <span class="hljs-comment">// Prints https://xn--1xa.example.com/foo</span>
-<span class="hljs-built_in">console</span>.log(myURL.origin);
-<span class="hljs-comment">// Prints https://xn--1xa.example.com</span></code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(myURL.<span class="hljs-property">origin</span>);
+<span class="hljs-comment">// Prints https://xn--1xa.example.com</span></code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/url.json b/doc/api/url.json
index f7df7e6bf0454b757344c090bc5605c9d79312ac..e1aaeb273991a2d2846074c32ad29bad6790d823 100644
--- a/doc/api/url.json
+++ b/doc/api/url.json
@@ -8,12 +8,21 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/url.js\">lib/url.js</a></p>\n<p>The <code>url</code> module provides utilities for URL resolution and parsing. It can be\naccessed using:</p>\n<pre><code class=\"language-js\">const url = require('url');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/url.js\">lib/url.js</a></p>\n<p>The <code>url</code> module provides utilities for URL resolution and parsing. It can be\naccessed using:</p>\n<pre><code class=\"language-js\">const url = require('url');\n</code></pre>",
       "modules": [
         {
           "textRaw": "URL strings and URL objects",
           "name": "url_strings_and_url_objects",
-          "desc": "<p>A URL string is a structured string containing multiple meaningful components.\nWhen parsed, a URL object is returned containing properties for each of these\ncomponents.</p>\n<p>The <code>url</code> module provides two APIs for working with URLs: a legacy API that is\nNode.js specific, and a newer API that implements the same\n<a href=\"https://url.spec.whatwg.org/\">WHATWG URL Standard</a> used by web browsers.</p>\n<p>A comparison between the WHATWG and Legacy APIs is provided below. Above the URL\n<code>'http://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>, properties\nof an object returned by the legacy <code>url.parse()</code> are shown. Below it are\nproperties of a WHATWG <code>URL</code> object.</p>\n<p>WHATWG URL's <code>origin</code> property includes <code>protocol</code> and <code>host</code>, but not\n<code>username</code> or <code>password</code>.</p>\n<pre><code class=\"language-text\">┌────────────────────────────────────────────────────────────────────────────────────────────────┐\n│                                              href                                              │\n├──────────┬──┬─────────────────────┬────────────────────────┬───────────────────────────┬───────┤\n│ protocol │  │        auth         │          host          │           path            │ hash  │\n│          │  │                     ├─────────────────┬──────┼──────────┬────────────────┤       │\n│          │  │                     │    hostname     │ port │ pathname │     search     │       │\n│          │  │                     │                 │      │          ├─┬──────────────┤       │\n│          │  │                     │                 │      │          │ │    query     │       │\n\"  https:   //    user   :   pass   @ sub.example.com : 8080   /p/a/t/h  ?  query=string   #hash \"\n│          │  │          │          │    hostname     │ port │          │                │       │\n│          │  │          │          ├─────────────────┴──────┤          │                │       │\n│ protocol │  │ username │ password │          host          │          │                │       │\n├──────────┴──┼──────────┴──────────┼────────────────────────┤          │                │       │\n│   origin    │                     │         origin         │ pathname │     search     │ hash  │\n├─────────────┴─────────────────────┴────────────────────────┴──────────┴────────────────┴───────┤\n│                                              href                                              │\n└────────────────────────────────────────────────────────────────────────────────────────────────┘\n(All spaces in the \"\" line should be ignored. They are purely for formatting.)\n</code></pre>\n<p>Parsing the URL string using the WHATWG API:</p>\n<pre><code class=\"language-js\">const myURL =\n  new URL('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');\n</code></pre>\n<p>Parsing the URL string using the Legacy API:</p>\n<pre><code class=\"language-js\">const url = require('url');\nconst myURL =\n  url.parse('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');\n</code></pre>",
+          "desc": "<p>A URL string is a structured string containing multiple meaningful components.\nWhen parsed, a URL object is returned containing properties for each of these\ncomponents.</p>\n<p>The <code>url</code> module provides two APIs for working with URLs: a legacy API that is\nNode.js specific, and a newer API that implements the same\n<a href=\"https://url.spec.whatwg.org/\">WHATWG URL Standard</a> used by web browsers.</p>\n<p>A comparison between the WHATWG and Legacy APIs is provided below. Above the URL\n<code>'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'</code>, properties\nof an object returned by the legacy <code>url.parse()</code> are shown. Below it are\nproperties of a WHATWG <code>URL</code> object.</p>\n<p>WHATWG URL's <code>origin</code> property includes <code>protocol</code> and <code>host</code>, but not\n<code>username</code> or <code>password</code>.</p>\n<pre><code class=\"language-text\">┌────────────────────────────────────────────────────────────────────────────────────────────────┐\n│                                              href                                              │\n├──────────┬──┬─────────────────────┬────────────────────────┬───────────────────────────┬───────┤\n│ protocol │  │        auth         │          host          │           path            │ hash  │\n│          │  │                     ├─────────────────┬──────┼──────────┬────────────────┤       │\n│          │  │                     │    hostname     │ port │ pathname │     search     │       │\n│          │  │                     │                 │      │          ├─┬──────────────┤       │\n│          │  │                     │                 │      │          │ │    query     │       │\n\"  https:   //    user   :   pass   @ sub.example.com : 8080   /p/a/t/h  ?  query=string   #hash \"\n│          │  │          │          │    hostname     │ port │          │                │       │\n│          │  │          │          ├─────────────────┴──────┤          │                │       │\n│ protocol │  │ username │ password │          host          │          │                │       │\n├──────────┴──┼──────────┴──────────┼────────────────────────┤          │                │       │\n│   origin    │                     │         origin         │ pathname │     search     │ hash  │\n├─────────────┴─────────────────────┴────────────────────────┴──────────┴────────────────┴───────┤\n│                                              href                                              │\n└────────────────────────────────────────────────────────────────────────────────────────────────┘\n(All spaces in the \"\" line should be ignored. They are purely for formatting.)\n</code></pre>\n<p>Parsing the URL string using the WHATWG API:</p>\n<pre><code class=\"language-js\">const myURL =\n  new URL('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');\n</code></pre>\n<p>Parsing the URL string using the Legacy API:</p>\n<pre><code class=\"language-js\">const url = require('url');\nconst myURL =\n  url.parse('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');\n</code></pre>",
+          "modules": [
+            {
+              "textRaw": "Constructing a URL from component parts and getting the constructed string",
+              "name": "constructing_a_url_from_component_parts_and_getting_the_constructed_string",
+              "desc": "<p>It is possible to construct a WHATWG URL from component parts using either the\nproperty setters or a template literal string:</p>\n<pre><code class=\"language-js\">const myURL = new URL('https://example.org');\nmyURL.pathname = '/a/b/c';\nmyURL.search = '?d=e';\nmyURL.hash = '#fgh';\n</code></pre>\n<pre><code class=\"language-js\">const pathname = '/a/b/c';\nconst search = '?d=e';\nconst hash = '#fgh';\nconst myURL = new URL(`https://example.org${pathname}${search}${hash}`);\n</code></pre>\n<p>To get the constructed URL string, use the <code>href</code> property accessor:</p>\n<pre><code class=\"language-js\">console.log(myURL.href);\n</code></pre>",
+              "type": "module",
+              "displayName": "Constructing a URL from component parts and getting the constructed string"
+            }
+          ],
           "type": "module",
           "displayName": "URL strings and URL objects"
         },
@@ -56,7 +65,7 @@
                   "textRaw": "`hostname` {string}",
                   "type": "string",
                   "name": "hostname",
-                  "desc": "<p>Gets and sets the host name portion of the URL. The key difference between\n<code>url.host</code> and <code>url.hostname</code> is that <code>url.hostname</code> does <em>not</em> include the\nport.</p>\n<pre><code class=\"language-js\">const myURL = new URL('https://example.org:81/foo');\nconsole.log(myURL.hostname);\n// Prints example.org\n\nmyURL.hostname = 'example.com:82';\nconsole.log(myURL.href);\n// Prints https://example.com:81/foo\n</code></pre>\n<p>Invalid host name values assigned to the <code>hostname</code> property are ignored.</p>"
+                  "desc": "<p>Gets and sets the host name portion of the URL. The key difference between\n<code>url.host</code> and <code>url.hostname</code> is that <code>url.hostname</code> does <em>not</em> include the\nport.</p>\n<pre><code class=\"language-js\">const myURL = new URL('https://example.org:81/foo');\nconsole.log(myURL.hostname);\n// Prints example.org\n\n// Setting the hostname does not change the port\nmyURL.hostname = 'example.com:82';\nconsole.log(myURL.href);\n// Prints https://example.com:81/foo\n\n// Use myURL.host to change the hostname and port\nmyURL.host = 'example.org:82';\nconsole.log(myURL.href);\n// Prints https://example.org:82/foo\n</code></pre>\n<p>Invalid host name values assigned to the <code>hostname</code> property are ignored.</p>"
                 },
                 {
                   "textRaw": "`href` {string}",
@@ -153,7 +162,7 @@
                       "params": []
                     }
                   ],
-                  "desc": "<p>The <code>toJSON()</code> method on the <code>URL</code> object returns the serialized URL. The\nvalue returned is equivalent to that of <a href=\"#url_url_href\"><code>url.href</code></a> and\n<a href=\"#url_url_tostring\"><code>url.toString()</code></a>.</p>\n<p>This method is automatically called when an <code>URL</code> object is serialized\nwith <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify\"><code>JSON.stringify()</code></a>.</p>\n<pre><code class=\"language-js\">const myURLs = [\n  new URL('https://www.example.com'),\n  new URL('https://test.example.org')\n];\nconsole.log(JSON.stringify(myURLs));\n// Prints [\"https://www.example.com/\",\"https://test.example.org/\"]\n</code></pre>"
+                  "desc": "<p>The <code>toJSON()</code> method on the <code>URL</code> object returns the serialized URL. The\nvalue returned is equivalent to that of <a href=\"#url_url_href\"><code>url.href</code></a> and\n<a href=\"#url_url_tostring\"><code>url.toString()</code></a>.</p>\n<p>This method is automatically called when an <code>URL</code> object is serialized\nwith <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify\"><code>JSON.stringify()</code></a>.</p>\n<pre><code class=\"language-js\">const myURLs = [\n  new URL('https://www.example.com'),\n  new URL('https://test.example.org'),\n];\nconsole.log(JSON.stringify(myURLs));\n// Prints [\"https://www.example.com/\",\"https://test.example.org/\"]\n</code></pre>"
                 }
               ],
               "signatures": [
@@ -482,7 +491,7 @@
                       "desc": "An iterable object whose elements are key-value pairs"
                     }
                   ],
-                  "desc": "<p>Instantiate a new <code>URLSearchParams</code> object with an iterable map in a way that\nis similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\"><code>Map</code></a>'s constructor. <code>iterable</code> can be an <code>Array</code> or any\niterable object. That means <code>iterable</code> can be another <code>URLSearchParams</code>, in\nwhich case the constructor will simply create a clone of the provided\n<code>URLSearchParams</code>. Elements of <code>iterable</code> are key-value pairs, and can\nthemselves be any iterable object.</p>\n<p>Duplicate keys are allowed.</p>\n<pre><code class=\"language-js\">let params;\n\n// Using an array\nparams = new URLSearchParams([\n  ['user', 'abc'],\n  ['query', 'first'],\n  ['query', 'second']\n]);\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=first&#x26;query=second'\n\n// Using a Map object\nconst map = new Map();\nmap.set('user', 'abc');\nmap.set('query', 'xyz');\nparams = new URLSearchParams(map);\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=xyz'\n\n// Using a generator function\nfunction* getQueryPairs() {\n  yield ['user', 'abc'];\n  yield ['query', 'first'];\n  yield ['query', 'second'];\n}\nparams = new URLSearchParams(getQueryPairs());\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=first&#x26;query=second'\n\n// Each key-value pair must have exactly two elements\nnew URLSearchParams([\n  ['user', 'abc', 'error']\n]);\n// Throws TypeError [ERR_INVALID_TUPLE]:\n//        Each query pair must be an iterable [name, value] tuple\n</code></pre>"
+                  "desc": "<p>Instantiate a new <code>URLSearchParams</code> object with an iterable map in a way that\nis similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\"><code>Map</code></a>'s constructor. <code>iterable</code> can be an <code>Array</code> or any\niterable object. That means <code>iterable</code> can be another <code>URLSearchParams</code>, in\nwhich case the constructor will simply create a clone of the provided\n<code>URLSearchParams</code>. Elements of <code>iterable</code> are key-value pairs, and can\nthemselves be any iterable object.</p>\n<p>Duplicate keys are allowed.</p>\n<pre><code class=\"language-js\">let params;\n\n// Using an array\nparams = new URLSearchParams([\n  ['user', 'abc'],\n  ['query', 'first'],\n  ['query', 'second'],\n]);\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=first&#x26;query=second'\n\n// Using a Map object\nconst map = new Map();\nmap.set('user', 'abc');\nmap.set('query', 'xyz');\nparams = new URLSearchParams(map);\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=xyz'\n\n// Using a generator function\nfunction* getQueryPairs() {\n  yield ['user', 'abc'];\n  yield ['query', 'first'];\n  yield ['query', 'second'];\n}\nparams = new URLSearchParams(getQueryPairs());\nconsole.log(params.toString());\n// Prints 'user=abc&#x26;query=first&#x26;query=second'\n\n// Each key-value pair must have exactly two elements\nnew URLSearchParams([\n  ['user', 'abc', 'error'],\n]);\n// Throws TypeError [ERR_INVALID_TUPLE]:\n//        Each query pair must be an iterable [name, value] tuple\n</code></pre>"
                 }
               ]
             }
@@ -515,7 +524,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns the <a href=\"https://tools.ietf.org/html/rfc5891#section-4.4\">Punycode</a> ASCII serialization of the <code>domain</code>. If <code>domain</code> is an\ninvalid domain, the empty string is returned.</p>\n<p>It performs the inverse operation to <a href=\"#url_url_domaintounicode_domain\"><code>url.domainToUnicode()</code></a>.</p>\n<pre><code class=\"language-js\">const url = require('url');\nconsole.log(url.domainToASCII('español.com'));\n// Prints xn--espaol-zwa.com\nconsole.log(url.domainToASCII('中文.com'));\n// Prints xn--fiq228c.com\nconsole.log(url.domainToASCII('xn--iñvalid.com'));\n// Prints an empty string\n</code></pre>"
+              "desc": "<p>Returns the <a href=\"https://tools.ietf.org/html/rfc5891#section-4.4\">Punycode</a> ASCII serialization of the <code>domain</code>. If <code>domain</code> is an\ninvalid domain, the empty string is returned.</p>\n<p>It performs the inverse operation to <a href=\"#url_url_domaintounicode_domain\"><code>url.domainToUnicode()</code></a>.</p>\n<p>This feature is only available if the <code>node</code> executable was compiled with\n<a href=\"intl.html#intl_options_for_building_node_js\">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>\n<pre><code class=\"language-js\">const url = require('url');\nconsole.log(url.domainToASCII('español.com'));\n// Prints xn--espaol-zwa.com\nconsole.log(url.domainToASCII('中文.com'));\n// Prints xn--fiq228c.com\nconsole.log(url.domainToASCII('xn--iñvalid.com'));\n// Prints an empty string\n</code></pre>"
             },
             {
               "textRaw": "`url.domainToUnicode(domain)`",
@@ -544,7 +553,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns the Unicode serialization of the <code>domain</code>. If <code>domain</code> is an invalid\ndomain, the empty string is returned.</p>\n<p>It performs the inverse operation to <a href=\"#url_url_domaintoascii_domain\"><code>url.domainToASCII()</code></a>.</p>\n<pre><code class=\"language-js\">const url = require('url');\nconsole.log(url.domainToUnicode('xn--espaol-zwa.com'));\n// Prints español.com\nconsole.log(url.domainToUnicode('xn--fiq228c.com'));\n// Prints 中文.com\nconsole.log(url.domainToUnicode('xn--iñvalid.com'));\n// Prints an empty string\n</code></pre>"
+              "desc": "<p>Returns the Unicode serialization of the <code>domain</code>. If <code>domain</code> is an invalid\ndomain, the empty string is returned.</p>\n<p>It performs the inverse operation to <a href=\"#url_url_domaintoascii_domain\"><code>url.domainToASCII()</code></a>.</p>\n<p>This feature is only available if the <code>node</code> executable was compiled with\n<a href=\"intl.html#intl_options_for_building_node_js\">ICU</a> enabled. If not, the domain names are passed through unchanged.</p>\n<pre><code class=\"language-js\">const url = require('url');\nconsole.log(url.domainToUnicode('xn--espaol-zwa.com'));\n// Prints español.com\nconsole.log(url.domainToUnicode('xn--fiq228c.com'));\n// Prints 中文.com\nconsole.log(url.domainToUnicode('xn--iñvalid.com'));\n// Prints an empty string\n</code></pre>"
             },
             {
               "textRaw": "`url.fileURLToPath(url)`",
@@ -574,7 +583,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This function ensures the correct decodings of percent-encoded characters as\nwell as ensuring a cross-platform valid absolute path string.</p>\n<pre><code class=\"language-js\">new URL('file:///C:/path/').pathname;    // Incorrect: /C:/path/\nfileURLToPath('file:///C:/path/');       // Correct:   C:\\path\\ (Windows)\n\nnew URL('file://nas/foo.txt').pathname;  // Incorrect: /foo.txt\nfileURLToPath('file://nas/foo.txt');     // Correct:   \\\\nas\\foo.txt (Windows)\n\nnew URL('file:///你好.txt').pathname;    // Incorrect: /%E4%BD%A0%E5%A5%BD.txt\nfileURLToPath('file:///你好.txt');       // Correct:   /你好.txt (POSIX)\n\nnew URL('file:///hello world').pathname; // Incorrect: /hello%20world\nfileURLToPath('file:///hello world');    // Correct:   /hello world (POSIX)\n</code></pre>"
+              "desc": "<p>This function ensures the correct decodings of percent-encoded characters as\nwell as ensuring a cross-platform valid absolute path string.</p>\n<pre><code class=\"language-mjs\">import { fileURLToPath } from 'url';\n\nconst __filename = fileURLToPath(import.meta.url);\n\nnew URL('file:///C:/path/').pathname;      // Incorrect: /C:/path/\nfileURLToPath('file:///C:/path/');         // Correct:   C:\\path\\ (Windows)\n\nnew URL('file://nas/foo.txt').pathname;    // Incorrect: /foo.txt\nfileURLToPath('file://nas/foo.txt');       // Correct:   \\\\nas\\foo.txt (Windows)\n\nnew URL('file:///你好.txt').pathname;      // Incorrect: /%E4%BD%A0%E5%A5%BD.txt\nfileURLToPath('file:///你好.txt');         // Correct:   /你好.txt (POSIX)\n\nnew URL('file:///hello world').pathname;   // Incorrect: /hello%20world\nfileURLToPath('file:///hello world');      // Correct:   /hello world (POSIX)\n</code></pre>\n<pre><code class=\"language-cjs\">const { fileURLToPath } = require('url');\nnew URL('file:///C:/path/').pathname;      // Incorrect: /C:/path/\nfileURLToPath('file:///C:/path/');         // Correct:   C:\\path\\ (Windows)\n\nnew URL('file://nas/foo.txt').pathname;    // Incorrect: /foo.txt\nfileURLToPath('file://nas/foo.txt');       // Correct:   \\\\nas\\foo.txt (Windows)\n\nnew URL('file:///你好.txt').pathname;      // Incorrect: /%E4%BD%A0%E5%A5%BD.txt\nfileURLToPath('file:///你好.txt');         // Correct:   /你好.txt (POSIX)\n\nnew URL('file:///hello world').pathname;   // Incorrect: /hello%20world\nfileURLToPath('file:///hello world');      // Correct:   /hello world (POSIX)\n</code></pre>"
             },
             {
               "textRaw": "`url.format(URL[, options])`",
@@ -638,7 +647,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Returns a customizable serialization of a URL <code>String</code> representation of a\n<a href=\"#url_the_whatwg_url_api\">WHATWG URL</a> object.</p>\n<p>The URL object has both a <code>toString()</code> method and <code>href</code> property that return\nstring serializations of the URL. These are not, however, customizable in\nany way. The <code>url.format(URL[, options])</code> method allows for basic customization\nof the output.</p>\n<pre><code class=\"language-js\">const myURL = new URL('https://a:b@測試?abc#foo');\n\nconsole.log(myURL.href);\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(myURL.toString());\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));\n// Prints 'https://測試/?abc'\n</code></pre>"
+              "desc": "<p>Returns a customizable serialization of a URL <code>String</code> representation of a\n<a href=\"#url_the_whatwg_url_api\">WHATWG URL</a> object.</p>\n<p>The URL object has both a <code>toString()</code> method and <code>href</code> property that return\nstring serializations of the URL. These are not, however, customizable in\nany way. The <code>url.format(URL[, options])</code> method allows for basic customization\nof the output.</p>\n<pre><code class=\"language-mjs\">import url from 'url';\nconst myURL = new URL('https://a:b@測試?abc#foo');\n\nconsole.log(myURL.href);\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(myURL.toString());\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));\n// Prints 'https://測試/?abc'\n</code></pre>\n<pre><code class=\"language-cjs\">const url = require('url');\nconst myURL = new URL('https://a:b@測試?abc#foo');\n\nconsole.log(myURL.href);\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(myURL.toString());\n// Prints https://a:b@xn--g6w251d/?abc#foo\n\nconsole.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));\n// Prints 'https://測試/?abc'\n</code></pre>"
             },
             {
               "textRaw": "`url.pathToFileURL(path)`",
@@ -668,7 +677,93 @@
                   ]
                 }
               ],
-              "desc": "<p>This function ensures that <code>path</code> is resolved absolutely, and that the URL\ncontrol characters are correctly encoded when converting into a File URL.</p>\n<pre><code class=\"language-js\">new URL(__filename);                // Incorrect: throws (POSIX)\nnew URL(__filename);                // Incorrect: C:\\... (Windows)\npathToFileURL(__filename);          // Correct:   file:///... (POSIX)\npathToFileURL(__filename);          // Correct:   file:///C:/... (Windows)\n\nnew URL('/foo#1', 'file:');         // Incorrect: file:///foo#1\npathToFileURL('/foo#1');            // Correct:   file:///foo%231 (POSIX)\n\nnew URL('/some/path%.c', 'file:'); // Incorrect: file:///some/path%.c\npathToFileURL('/some/path%.c');    // Correct:   file:///some/path%25.c (POSIX)\n</code></pre>"
+              "desc": "<p>This function ensures that <code>path</code> is resolved absolutely, and that the URL\ncontrol characters are correctly encoded when converting into a File URL.</p>\n<pre><code class=\"language-mjs\">import { pathToFileURL } from 'url';\n\nnew URL('/foo#1', 'file:');           // Incorrect: file:///foo#1\npathToFileURL('/foo#1');              // Correct:   file:///foo%231 (POSIX)\n\nnew URL('/some/path%.c', 'file:');    // Incorrect: file:///some/path%.c\npathToFileURL('/some/path%.c');       // Correct:   file:///some/path%25.c (POSIX)\n</code></pre>\n<pre><code class=\"language-cjs\">const { pathToFileURL } = require('url');\nnew URL(__filename);                  // Incorrect: throws (POSIX)\nnew URL(__filename);                  // Incorrect: C:\\... (Windows)\npathToFileURL(__filename);            // Correct:   file:///... (POSIX)\npathToFileURL(__filename);            // Correct:   file:///C:/... (Windows)\n\nnew URL('/foo#1', 'file:');           // Incorrect: file:///foo#1\npathToFileURL('/foo#1');              // Correct:   file:///foo%231 (POSIX)\n\nnew URL('/some/path%.c', 'file:');    // Incorrect: file:///some/path%.c\npathToFileURL('/some/path%.c');       // Correct:   file:///some/path%25.c (POSIX)\n</code></pre>"
+            },
+            {
+              "textRaw": "`url.urlToHttpOptions(url)`",
+              "type": "method",
+              "name": "urlToHttpOptions",
+              "meta": {
+                "added": [
+                  "v14.18.0"
+                ],
+                "changes": []
+              },
+              "signatures": [
+                {
+                  "return": {
+                    "textRaw": "Returns: {Object} Options object",
+                    "name": "return",
+                    "type": "Object",
+                    "desc": "Options object",
+                    "options": [
+                      {
+                        "textRaw": "`protocol` {string} Protocol to use.",
+                        "name": "protocol",
+                        "type": "string",
+                        "desc": "Protocol to use."
+                      },
+                      {
+                        "textRaw": "`hostname` {string} A domain name or IP address of the server to issue the request to.",
+                        "name": "hostname",
+                        "type": "string",
+                        "desc": "A domain name or IP address of the server to issue the request to."
+                      },
+                      {
+                        "textRaw": "`hash` {string} The fragment portion of the URL.",
+                        "name": "hash",
+                        "type": "string",
+                        "desc": "The fragment portion of the URL."
+                      },
+                      {
+                        "textRaw": "`search` {string} The serialized query portion of the URL.",
+                        "name": "search",
+                        "type": "string",
+                        "desc": "The serialized query portion of the URL."
+                      },
+                      {
+                        "textRaw": "`pathname` {string} The path portion of the URL.",
+                        "name": "pathname",
+                        "type": "string",
+                        "desc": "The path portion of the URL."
+                      },
+                      {
+                        "textRaw": "`path` {string} Request path. Should include query string if any. E.G. `'/index.html?page=12'`. An exception is thrown when the request path contains illegal characters. Currently, only spaces are rejected but that may change in the future.",
+                        "name": "path",
+                        "type": "string",
+                        "desc": "Request path. Should include query string if any. E.G. `'/index.html?page=12'`. An exception is thrown when the request path contains illegal characters. Currently, only spaces are rejected but that may change in the future."
+                      },
+                      {
+                        "textRaw": "`href` {string} The serialized URL.",
+                        "name": "href",
+                        "type": "string",
+                        "desc": "The serialized URL."
+                      },
+                      {
+                        "textRaw": "`port` {number} Port of remote server.",
+                        "name": "port",
+                        "type": "number",
+                        "desc": "Port of remote server."
+                      },
+                      {
+                        "textRaw": "`auth` {string} Basic authentication i.e. `'user:password'` to compute an Authorization header.",
+                        "name": "auth",
+                        "type": "string",
+                        "desc": "Basic authentication i.e. `'user:password'` to compute an Authorization header."
+                      }
+                    ]
+                  },
+                  "params": [
+                    {
+                      "textRaw": "`url` {URL} The [WHATWG URL][] object to convert to an options object.",
+                      "name": "url",
+                      "type": "URL",
+                      "desc": "The [WHATWG URL][] object to convert to an options object."
+                    }
+                  ]
+                }
+              ],
+              "desc": "<p>This utility function converts a URL object into an ordinary options object as\nexpected by the <a href=\"http.html#http_http_request_options_callback\"><code>http.request()</code></a> and <a href=\"https.html#https_https_request_options_callback\"><code>https.request()</code></a> APIs.</p>\n<pre><code class=\"language-js\">const { urlToHttpOptions } = require('url');\nconst myURL = new URL('https://a:b@測試?abc#foo');\n\nconsole.log(urlToHttpOptions(myUrl));\n/**\n{\n  protocol: 'https:',\n  hostname: 'xn--g6w251d',\n  hash: '#foo',\n  search: '?abc',\n  pathname: '/',\n  path: '/?abc',\n  href: 'https://a:b@xn--g6w251d/?abc#foo',\n  auth: 'a:b'\n}\n*/\n</code></pre>"
             }
           ],
           "type": "module",
@@ -678,17 +773,32 @@
           "textRaw": "Legacy URL API",
           "name": "legacy_url_api",
           "meta": {
-            "deprecated": [
-              "v11.0.0"
-            ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.17.0",
+                "pr-url": "https://github.com/nodejs/node/pull/37784",
+                "description": "Deprecation revoked. Status changed to \"Legacy\"."
+              },
+              {
+                "version": "v11.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/22715",
+                "description": "This API is deprecated."
+              }
+            ]
           },
+          "stability": 3,
+          "stabilityText": "Legacy: Use the WHATWG URL API instead.",
           "modules": [
             {
               "textRaw": "Legacy `urlObject`",
               "name": "legacy_`urlobject`",
               "meta": {
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22715",
@@ -696,8 +806,8 @@
                   }
                 ]
               },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use the WHATWG URL API instead.",
+              "stability": 3,
+              "stabilityText": "Legacy: Use the WHATWG URL API instead.",
               "desc": "<p>The legacy <code>urlObject</code> (<code>require('url').Url</code>) is created and returned by the\n<code>url.parse()</code> function.</p>",
               "properties": [
                 {
@@ -775,6 +885,11 @@
                   "v0.1.25"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22715",
@@ -787,8 +902,8 @@
                   }
                 ]
               },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use the WHATWG URL API instead.",
+              "stability": 3,
+              "stabilityText": "Legacy: Use the WHATWG URL API instead.",
               "signatures": [
                 {
                   "params": [
@@ -801,7 +916,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>url.format()</code> method returns a formatted URL string derived from\n<code>urlObject</code>.</p>\n<pre><code class=\"language-js\">url.format({\n  protocol: 'https',\n  hostname: 'example.com',\n  pathname: '/some/path',\n  query: {\n    page: 1,\n    format: 'json'\n  }\n});\n\n// => 'https://example.com/some/path?page=1&#x26;format=json'\n</code></pre>\n<p>If <code>urlObject</code> is not an object or a string, <code>url.format()</code> will throw a\n<a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a>.</p>\n<p>The formatting process operates as follows:</p>\n<ul>\n<li>A new empty string <code>result</code> is created.</li>\n<li>If <code>urlObject.protocol</code> is a string, it is appended as-is to <code>result</code>.</li>\n<li>Otherwise, if <code>urlObject.protocol</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>For all string values of <code>urlObject.protocol</code> that <em>do not end</em> with an ASCII\ncolon (<code>:</code>) character, the literal string <code>:</code> will be appended to <code>result</code>.</li>\n<li>If either of the following conditions is true, then the literal string <code>//</code>\nwill be appended to <code>result</code>:\n<ul>\n<li><code>urlObject.slashes</code> property is true;</li>\n<li><code>urlObject.protocol</code> begins with <code>http</code>, <code>https</code>, <code>ftp</code>, <code>gopher</code>, or\n<code>file</code>;</li>\n</ul>\n</li>\n<li>If the value of the <code>urlObject.auth</code> property is truthy, and either\n<code>urlObject.host</code> or <code>urlObject.hostname</code> are not <code>undefined</code>, the value of\n<code>urlObject.auth</code> will be coerced into a string and appended to <code>result</code>\nfollowed by the literal string <code>@</code>.</li>\n<li>If the <code>urlObject.host</code> property is <code>undefined</code> then:\n<ul>\n<li>If the <code>urlObject.hostname</code> is a string, it is appended to <code>result</code>.</li>\n<li>Otherwise, if <code>urlObject.hostname</code> is not <code>undefined</code> and is not a string,\nan <a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.port</code> property value is truthy, and <code>urlObject.hostname</code>\nis not <code>undefined</code>:\n<ul>\n<li>The literal string <code>:</code> is appended to <code>result</code>, and</li>\n<li>The value of <code>urlObject.port</code> is coerced to a string and appended to\n<code>result</code>.</li>\n</ul>\n</li>\n</ul>\n</li>\n<li>Otherwise, if the <code>urlObject.host</code> property value is truthy, the value of\n<code>urlObject.host</code> is coerced to a string and appended to <code>result</code>.</li>\n<li>If the <code>urlObject.pathname</code> property is a string that is not an empty string:\n<ul>\n<li>If the <code>urlObject.pathname</code> <em>does not start</em> with an ASCII forward slash\n(<code>/</code>), then the literal string <code>'/'</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.pathname</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if <code>urlObject.pathname</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.search</code> property is <code>undefined</code> and if the <code>urlObject.query</code>\nproperty is an <code>Object</code>, the literal string <code>?</code> is appended to <code>result</code>\nfollowed by the output of calling the <a href=\"querystring.html\"><code>querystring</code></a> module's <code>stringify()</code>\nmethod passing the value of <code>urlObject.query</code>.</li>\n<li>Otherwise, if <code>urlObject.search</code> is a string:\n<ul>\n<li>If the value of <code>urlObject.search</code> <em>does not start</em> with the ASCII question\nmark (<code>?</code>) character, the literal string <code>?</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.search</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if <code>urlObject.search</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.hash</code> property is a string:\n<ul>\n<li>If the value of <code>urlObject.hash</code> <em>does not start</em> with the ASCII hash (<code>#</code>)\ncharacter, the literal string <code>#</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.hash</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if the <code>urlObject.hash</code> property is not <code>undefined</code> and is not a\nstring, an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li><code>result</code> is returned.</li>\n</ul>"
+              "desc": "<p>The <code>url.format()</code> method returns a formatted URL string derived from\n<code>urlObject</code>.</p>\n<pre><code class=\"language-js\">const url = require('url');\nurl.format({\n  protocol: 'https',\n  hostname: 'example.com',\n  pathname: '/some/path',\n  query: {\n    page: 1,\n    format: 'json'\n  }\n});\n\n// => 'https://example.com/some/path?page=1&#x26;format=json'\n</code></pre>\n<p>If <code>urlObject</code> is not an object or a string, <code>url.format()</code> will throw a\n<a href=\"errors.html#errors_class_typeerror\"><code>TypeError</code></a>.</p>\n<p>The formatting process operates as follows:</p>\n<ul>\n<li>A new empty string <code>result</code> is created.</li>\n<li>If <code>urlObject.protocol</code> is a string, it is appended as-is to <code>result</code>.</li>\n<li>Otherwise, if <code>urlObject.protocol</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>For all string values of <code>urlObject.protocol</code> that <em>do not end</em> with an ASCII\ncolon (<code>:</code>) character, the literal string <code>:</code> will be appended to <code>result</code>.</li>\n<li>If either of the following conditions is true, then the literal string <code>//</code>\nwill be appended to <code>result</code>:\n<ul>\n<li><code>urlObject.slashes</code> property is true;</li>\n<li><code>urlObject.protocol</code> begins with <code>http</code>, <code>https</code>, <code>ftp</code>, <code>gopher</code>, or\n<code>file</code>;</li>\n</ul>\n</li>\n<li>If the value of the <code>urlObject.auth</code> property is truthy, and either\n<code>urlObject.host</code> or <code>urlObject.hostname</code> are not <code>undefined</code>, the value of\n<code>urlObject.auth</code> will be coerced into a string and appended to <code>result</code>\nfollowed by the literal string <code>@</code>.</li>\n<li>If the <code>urlObject.host</code> property is <code>undefined</code> then:\n<ul>\n<li>If the <code>urlObject.hostname</code> is a string, it is appended to <code>result</code>.</li>\n<li>Otherwise, if <code>urlObject.hostname</code> is not <code>undefined</code> and is not a string,\nan <a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.port</code> property value is truthy, and <code>urlObject.hostname</code>\nis not <code>undefined</code>:\n<ul>\n<li>The literal string <code>:</code> is appended to <code>result</code>, and</li>\n<li>The value of <code>urlObject.port</code> is coerced to a string and appended to\n<code>result</code>.</li>\n</ul>\n</li>\n</ul>\n</li>\n<li>Otherwise, if the <code>urlObject.host</code> property value is truthy, the value of\n<code>urlObject.host</code> is coerced to a string and appended to <code>result</code>.</li>\n<li>If the <code>urlObject.pathname</code> property is a string that is not an empty string:\n<ul>\n<li>If the <code>urlObject.pathname</code> <em>does not start</em> with an ASCII forward slash\n(<code>/</code>), then the literal string <code>'/'</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.pathname</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if <code>urlObject.pathname</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.search</code> property is <code>undefined</code> and if the <code>urlObject.query</code>\nproperty is an <code>Object</code>, the literal string <code>?</code> is appended to <code>result</code>\nfollowed by the output of calling the <a href=\"querystring.html\"><code>querystring</code></a> module's <code>stringify()</code>\nmethod passing the value of <code>urlObject.query</code>.</li>\n<li>Otherwise, if <code>urlObject.search</code> is a string:\n<ul>\n<li>If the value of <code>urlObject.search</code> <em>does not start</em> with the ASCII question\nmark (<code>?</code>) character, the literal string <code>?</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.search</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if <code>urlObject.search</code> is not <code>undefined</code> and is not a string, an\n<a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li>If the <code>urlObject.hash</code> property is a string:\n<ul>\n<li>If the value of <code>urlObject.hash</code> <em>does not start</em> with the ASCII hash (<code>#</code>)\ncharacter, the literal string <code>#</code> is appended to <code>result</code>.</li>\n<li>The value of <code>urlObject.hash</code> is appended to <code>result</code>.</li>\n</ul>\n</li>\n<li>Otherwise, if the <code>urlObject.hash</code> property is not <code>undefined</code> and is not a\nstring, an <a href=\"errors.html#errors_class_error\"><code>Error</code></a> is thrown.</li>\n<li><code>result</code> is returned.</li>\n</ul>"
             },
             {
               "textRaw": "`url.parse(urlString[, parseQueryString[, slashesDenoteHost]])`",
@@ -812,6 +927,11 @@
                   "v0.1.25"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.14.0",
                     "pr-url": "https://github.com/nodejs/node/pull/26941",
@@ -829,8 +949,8 @@
                   }
                 ]
               },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use the WHATWG URL API instead.",
+              "stability": 3,
+              "stabilityText": "Legacy: Use the WHATWG URL API instead.",
               "signatures": [
                 {
                   "params": [
@@ -868,6 +988,11 @@
                   "v0.1.25"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.17.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37784",
+                    "description": "Deprecation revoked. Status changed to \"Legacy\"."
+                  },
                   {
                     "version": "v11.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/22715",
@@ -879,7 +1004,10 @@
                     "description": "The `auth` fields are now kept intact when `from` and `to` refer to the same host."
                   },
                   {
-                    "version": "v6.5.0, v4.6.2",
+                    "version": [
+                      "v6.5.0",
+                      "v4.6.2"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/8214",
                     "description": "The `port` field is copied correctly now."
                   },
@@ -890,8 +1018,8 @@
                   }
                 ]
               },
-              "stability": 0,
-              "stabilityText": "Deprecated: Use the WHATWG URL API instead.",
+              "stability": 3,
+              "stabilityText": "Legacy: Use the WHATWG URL API instead.",
               "signatures": [
                 {
                   "params": [
@@ -910,7 +1038,7 @@
                   ]
                 }
               ],
-              "desc": "<p>The <code>url.resolve()</code> method resolves a target URL relative to a base URL in a\nmanner similar to that of a Web browser resolving an anchor tag HREF.</p>\n<pre><code class=\"language-js\">const url = require('url');\nurl.resolve('/one/two/three', 'four');         // '/one/two/four'\nurl.resolve('http://example.com/', '/one');    // 'http://example.com/one'\nurl.resolve('http://example.com/one', '/two'); // 'http://example.com/two'\n</code></pre>\n<p><a id=\"whatwg-percent-encoding\"></a></p>"
+              "desc": "<p>The <code>url.resolve()</code> method resolves a target URL relative to a base URL in a\nmanner similar to that of a Web browser resolving an anchor tag HREF.</p>\n<pre><code class=\"language-js\">const url = require('url');\nurl.resolve('/one/two/three', 'four');         // '/one/two/four'\nurl.resolve('http://example.com/', '/one');    // 'http://example.com/one'\nurl.resolve('http://example.com/one', '/two'); // 'http://example.com/two'\n</code></pre>\n<p>You can achieve the same result using the WHATWG URL API:</p>\n<pre><code class=\"language-js\">function resolve(from, to) {\n  const resolvedUrl = new URL(to, new URL(from, 'resolve://'));\n  if (resolvedUrl.protocol === 'resolve:') {\n    // `from` is a relative URL.\n    const { pathname, search, hash } = resolvedUrl;\n    return pathname + search + hash;\n  }\n  return resolvedUrl.toString();\n}\n\nresolve('/one/two/three', 'four');         // '/one/two/four'\nresolve('http://example.com/', '/one');    // 'http://example.com/one'\nresolve('http://example.com/one', '/two'); // 'http://example.com/two'\n</code></pre>\n<p><a id=\"whatwg-percent-encoding\"></a></p>"
             }
           ],
           "type": "module",
diff --git a/doc/api/url.md b/doc/api/url.md
index 55919241b90e0b2384ae912678e99f47ae4d2c4f..980a77836bcbcf04035708baddecd7933aaa83dd 100644
--- a/doc/api/url.md
+++ b/doc/api/url.md
@@ -24,7 +24,7 @@ Node.js specific, and a newer API that implements the same
 [WHATWG URL Standard][] used by web browsers.
 
 A comparison between the WHATWG and Legacy APIs is provided below. Above the URL
-`'http://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'`, properties
+`'https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash'`, properties
 of an object returned by the legacy `url.parse()` are shown. Below it are
 properties of a WHATWG `URL` object.
 
@@ -67,6 +67,31 @@ const myURL =
   url.parse('https://user:pass@sub.example.com:8080/p/a/t/h?query=string#hash');
 ```
 
+### Constructing a URL from component parts and getting the constructed string
+
+It is possible to construct a WHATWG URL from component parts using either the
+property setters or a template literal string:
+
+```js
+const myURL = new URL('https://example.org');
+myURL.pathname = '/a/b/c';
+myURL.search = '?d=e';
+myURL.hash = '#fgh';
+```
+
+```js
+const pathname = '/a/b/c';
+const search = '?d=e';
+const hash = '#fgh';
+const myURL = new URL(`https://example.org${pathname}${search}${hash}`);
+```
+
+To get the constructed URL string, use the `href` property accessor:
+
+```js
+console.log(myURL.href);
+```
+
 ## The WHATWG URL API
 
 ### Class: `URL`
@@ -210,9 +235,15 @@ const myURL = new URL('https://example.org:81/foo');
 console.log(myURL.hostname);
 // Prints example.org
 
+// Setting the hostname does not change the port
 myURL.hostname = 'example.com:82';
 console.log(myURL.href);
 // Prints https://example.com:81/foo
+
+// Use myURL.host to change the hostname and port
+myURL.host = 'example.org:82';
+console.log(myURL.href);
+// Prints https://example.org:82/foo
 ```
 
 Invalid host name values assigned to the `hostname` property are ignored.
@@ -542,7 +573,7 @@ with [`JSON.stringify()`][].
 ```js
 const myURLs = [
   new URL('https://www.example.com'),
-  new URL('https://test.example.org')
+  new URL('https://test.example.org'),
 ];
 console.log(JSON.stringify(myURLs));
 // Prints ["https://www.example.com/","https://test.example.org/"]
@@ -679,7 +710,7 @@ let params;
 params = new URLSearchParams([
   ['user', 'abc'],
   ['query', 'first'],
-  ['query', 'second']
+  ['query', 'second'],
 ]);
 console.log(params.toString());
 // Prints 'user=abc&query=first&query=second'
@@ -704,7 +735,7 @@ console.log(params.toString());
 
 // Each key-value pair must have exactly two elements
 new URLSearchParams([
-  ['user', 'abc', 'error']
+  ['user', 'abc', 'error'],
 ]);
 // Throws TypeError [ERR_INVALID_TUPLE]:
 //        Each query pair must be an iterable [name, value] tuple
@@ -882,6 +913,9 @@ invalid domain, the empty string is returned.
 
 It performs the inverse operation to [`url.domainToUnicode()`][].
 
+This feature is only available if the `node` executable was compiled with
+[ICU][] enabled. If not, the domain names are passed through unchanged.
+
 ```js
 const url = require('url');
 console.log(url.domainToASCII('español.com'));
@@ -907,6 +941,9 @@ domain, the empty string is returned.
 
 It performs the inverse operation to [`url.domainToASCII()`][].
 
+This feature is only available if the `node` executable was compiled with
+[ICU][] enabled. If not, the domain names are passed through unchanged.
+
 ```js
 const url = require('url');
 console.log(url.domainToUnicode('xn--espaol-zwa.com'));
@@ -928,18 +965,37 @@ added: v10.12.0
 This function ensures the correct decodings of percent-encoded characters as
 well as ensuring a cross-platform valid absolute path string.
 
-```js
-new URL('file:///C:/path/').pathname;    // Incorrect: /C:/path/
-fileURLToPath('file:///C:/path/');       // Correct:   C:\path\ (Windows)
+```mjs
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+
+new URL('file:///C:/path/').pathname;      // Incorrect: /C:/path/
+fileURLToPath('file:///C:/path/');         // Correct:   C:\path\ (Windows)
+
+new URL('file://nas/foo.txt').pathname;    // Incorrect: /foo.txt
+fileURLToPath('file://nas/foo.txt');       // Correct:   \\nas\foo.txt (Windows)
+
+new URL('file:///你好.txt').pathname;      // Incorrect: /%E4%BD%A0%E5%A5%BD.txt
+fileURLToPath('file:///你好.txt');         // Correct:   /你好.txt (POSIX)
+
+new URL('file:///hello world').pathname;   // Incorrect: /hello%20world
+fileURLToPath('file:///hello world');      // Correct:   /hello world (POSIX)
+```
+
+```cjs
+const { fileURLToPath } = require('url');
+new URL('file:///C:/path/').pathname;      // Incorrect: /C:/path/
+fileURLToPath('file:///C:/path/');         // Correct:   C:\path\ (Windows)
 
-new URL('file://nas/foo.txt').pathname;  // Incorrect: /foo.txt
-fileURLToPath('file://nas/foo.txt');     // Correct:   \\nas\foo.txt (Windows)
+new URL('file://nas/foo.txt').pathname;    // Incorrect: /foo.txt
+fileURLToPath('file://nas/foo.txt');       // Correct:   \\nas\foo.txt (Windows)
 
-new URL('file:///你好.txt').pathname;    // Incorrect: /%E4%BD%A0%E5%A5%BD.txt
-fileURLToPath('file:///你好.txt');       // Correct:   /你好.txt (POSIX)
+new URL('file:///你好.txt').pathname;      // Incorrect: /%E4%BD%A0%E5%A5%BD.txt
+fileURLToPath('file:///你好.txt');         // Correct:   /你好.txt (POSIX)
 
-new URL('file:///hello world').pathname; // Incorrect: /hello%20world
-fileURLToPath('file:///hello world');    // Correct:   /hello world (POSIX)
+new URL('file:///hello world').pathname;   // Incorrect: /hello%20world
+fileURLToPath('file:///hello world');      // Correct:   /hello world (POSIX)
 ```
 
 ### `url.format(URL[, options])`
@@ -968,7 +1024,22 @@ string serializations of the URL. These are not, however, customizable in
 any way. The `url.format(URL[, options])` method allows for basic customization
 of the output.
 
-```js
+```mjs
+import url from 'url';
+const myURL = new URL('https://a:b@測試?abc#foo');
+
+console.log(myURL.href);
+// Prints https://a:b@xn--g6w251d/?abc#foo
+
+console.log(myURL.toString());
+// Prints https://a:b@xn--g6w251d/?abc#foo
+
+console.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));
+// Prints 'https://測試/?abc'
+```
+
+```cjs
+const url = require('url');
 const myURL = new URL('https://a:b@測試?abc#foo');
 
 console.log(myURL.href);
@@ -992,33 +1063,99 @@ added: v10.12.0
 This function ensures that `path` is resolved absolutely, and that the URL
 control characters are correctly encoded when converting into a File URL.
 
-```js
-new URL(__filename);                // Incorrect: throws (POSIX)
-new URL(__filename);                // Incorrect: C:\... (Windows)
-pathToFileURL(__filename);          // Correct:   file:///... (POSIX)
-pathToFileURL(__filename);          // Correct:   file:///C:/... (Windows)
+```mjs
+import { pathToFileURL } from 'url';
+
+new URL('/foo#1', 'file:');           // Incorrect: file:///foo#1
+pathToFileURL('/foo#1');              // Correct:   file:///foo%231 (POSIX)
+
+new URL('/some/path%.c', 'file:');    // Incorrect: file:///some/path%.c
+pathToFileURL('/some/path%.c');       // Correct:   file:///some/path%25.c (POSIX)
+```
+
+```cjs
+const { pathToFileURL } = require('url');
+new URL(__filename);                  // Incorrect: throws (POSIX)
+new URL(__filename);                  // Incorrect: C:\... (Windows)
+pathToFileURL(__filename);            // Correct:   file:///... (POSIX)
+pathToFileURL(__filename);            // Correct:   file:///C:/... (Windows)
 
-new URL('/foo#1', 'file:');         // Incorrect: file:///foo#1
-pathToFileURL('/foo#1');            // Correct:   file:///foo%231 (POSIX)
+new URL('/foo#1', 'file:');           // Incorrect: file:///foo#1
+pathToFileURL('/foo#1');              // Correct:   file:///foo%231 (POSIX)
+
+new URL('/some/path%.c', 'file:');    // Incorrect: file:///some/path%.c
+pathToFileURL('/some/path%.c');       // Correct:   file:///some/path%25.c (POSIX)
+```
+
+### `url.urlToHttpOptions(url)`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `url` {URL} The [WHATWG URL][] object to convert to an options object.
+* Returns: {Object} Options object
+  * `protocol` {string} Protocol to use.
+  * `hostname` {string} A domain name or IP address of the server to issue the
+    request to.
+  * `hash` {string} The fragment portion of the URL.
+  * `search` {string} The serialized query portion of the URL.
+  * `pathname` {string} The path portion of the URL.
+  * `path` {string} Request path. Should include query string if any.
+    E.G. `'/index.html?page=12'`. An exception is thrown when the request path
+    contains illegal characters. Currently, only spaces are rejected but that
+    may change in the future.
+  * `href` {string} The serialized URL.
+  * `port` {number} Port of remote server.
+  * `auth` {string} Basic authentication i.e. `'user:password'` to compute an
+    Authorization header.
+
+This utility function converts a URL object into an ordinary options object as
+expected by the [`http.request()`][] and [`https.request()`][] APIs.
+
+```js
+const { urlToHttpOptions } = require('url');
+const myURL = new URL('https://a:b@測試?abc#foo');
 
-new URL('/some/path%.c', 'file:'); // Incorrect: file:///some/path%.c
-pathToFileURL('/some/path%.c');    // Correct:   file:///some/path%25.c (POSIX)
+console.log(urlToHttpOptions(myUrl));
+/**
+{
+  protocol: 'https:',
+  hostname: 'xn--g6w251d',
+  hash: '#foo',
+  search: '?abc',
+  pathname: '/',
+  path: '/?abc',
+  href: 'https://a:b@xn--g6w251d/?abc#foo',
+  auth: 'a:b'
+}
+*/
 ```
 
 ## Legacy URL API
 <!-- YAML
-deprecated: v11.0.0
+changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37784
+    description: Deprecation revoked. Status changed to "Legacy".
+  - version: v11.0.0
+    pr-url: https://github.com/nodejs/node/pull/22715
+    description: This API is deprecated.
 -->
 
+> Stability: 3 - Legacy: Use the WHATWG URL API instead.
+
 ### Legacy `urlObject`
 <!-- YAML
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37784
+    description: Deprecation revoked. Status changed to "Legacy".
   - version: v11.0.0
     pr-url: https://github.com/nodejs/node/pull/22715
     description: The Legacy URL API is deprecated. Use the WHATWG URL API.
 -->
 
-> Stability: 0 - Deprecated: Use the WHATWG URL API instead.
+> Stability: 3 - Legacy: Use the WHATWG URL API instead.
 
 The legacy `urlObject` (`require('url').Url`) is created and returned by the
 `url.parse()` function.
@@ -1124,6 +1261,9 @@ forward-slash characters (`/`) are required following the colon in the
 <!-- YAML
 added: v0.1.25
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37784
+    description: Deprecation revoked. Status changed to "Legacy".
   - version: v11.0.0
     pr-url: https://github.com/nodejs/node/pull/22715
     description: The Legacy URL API is deprecated. Use the WHATWG URL API.
@@ -1135,7 +1275,7 @@ changes:
                  times.
 -->
 
-> Stability: 0 - Deprecated: Use the WHATWG URL API instead.
+> Stability: 3 - Legacy: Use the WHATWG URL API instead.
 
 * `urlObject` {Object|string} A URL object (as returned by `url.parse()` or
   constructed otherwise). If a string, it is converted to an object by passing
@@ -1145,6 +1285,7 @@ The `url.format()` method returns a formatted URL string derived from
 `urlObject`.
 
 ```js
+const url = require('url');
 url.format({
   protocol: 'https',
   hostname: 'example.com',
@@ -1217,6 +1358,9 @@ The formatting process operates as follows:
 <!-- YAML
 added: v0.1.25
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37784
+    description: Deprecation revoked. Status changed to "Legacy".
   - version: v11.14.0
     pr-url: https://github.com/nodejs/node/pull/26941
     description: The `pathname` property on the returned URL object is now `/`
@@ -1231,7 +1375,7 @@ changes:
                  when no query string is present.
 -->
 
-> Stability: 0 - Deprecated: Use the WHATWG URL API instead.
+> Stability: 3 - Legacy: Use the WHATWG URL API instead.
 
 * `urlString` {string} The URL string to parse.
 * `parseQueryString` {boolean} If `true`, the `query` property will always
@@ -1261,6 +1405,9 @@ incorrect handling of usernames and passwords have been identified.
 <!-- YAML
 added: v0.1.25
 changes:
+  - version: v14.17.0
+    pr-url: https://github.com/nodejs/node/pull/37784
+    description: Deprecation revoked. Status changed to "Legacy".
   - version: v11.0.0
     pr-url: https://github.com/nodejs/node/pull/22715
     description: The Legacy URL API is deprecated. Use the WHATWG URL API.
@@ -1268,7 +1415,9 @@ changes:
     pr-url: https://github.com/nodejs/node/pull/8215
     description: The `auth` fields are now kept intact when `from` and `to`
                  refer to the same host.
-  - version: v6.5.0, v4.6.2
+  - version:
+    - v6.5.0
+    - v4.6.2
     pr-url: https://github.com/nodejs/node/pull/8214
     description: The `port` field is copied correctly now.
   - version: v6.0.0
@@ -1277,7 +1426,7 @@ changes:
                  contains a hostname.
 -->
 
-> Stability: 0 - Deprecated: Use the WHATWG URL API instead.
+> Stability: 3 - Legacy: Use the WHATWG URL API instead.
 
 * `from` {string} The Base URL being resolved against.
 * `to` {string} The HREF URL being resolved.
@@ -1292,6 +1441,24 @@ url.resolve('http://example.com/', '/one');    // 'http://example.com/one'
 url.resolve('http://example.com/one', '/two'); // 'http://example.com/two'
 ```
 
+You can achieve the same result using the WHATWG URL API:
+
+```js
+function resolve(from, to) {
+  const resolvedUrl = new URL(to, new URL(from, 'resolve://'));
+  if (resolvedUrl.protocol === 'resolve:') {
+    // `from` is a relative URL.
+    const { pathname, search, hash } = resolvedUrl;
+    return pathname + search + hash;
+  }
+  return resolvedUrl.toString();
+}
+
+resolve('/one/two/three', 'four');         // '/one/two/four'
+resolve('http://example.com/', '/one');    // 'http://example.com/one'
+resolve('http://example.com/one', '/two'); // 'http://example.com/two'
+```
+
 <a id="whatwg-percent-encoding"></a>
 ## Percent-encoding in URLs
 
@@ -1352,14 +1519,20 @@ console.log(myURL.origin);
 // Prints https://xn--1xa.example.com
 ```
 
-[`Error`]: errors.html#errors_class_error
+[ICU]: intl.md#intl_options_for_building_node_js
+[Punycode]: https://tools.ietf.org/html/rfc5891#section-4.4
+[WHATWG URL]: #url_the_whatwg_url_api
+[WHATWG URL Standard]: https://url.spec.whatwg.org/
+[`Error`]: errors.md#errors_class_error
 [`JSON.stringify()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
 [`Map`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
-[`TypeError`]: errors.html#errors_class_typeerror
+[`TypeError`]: errors.md#errors_class_typeerror
 [`URLSearchParams`]: #url_class_urlsearchparams
 [`array.toString()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString
+[`http.request()`]: http.md#http_http_request_options_callback
+[`https.request()`]: https.md#https_https_request_options_callback
 [`new URL()`]: #url_new_url_input_base
-[`querystring`]: querystring.html
+[`querystring`]: querystring.md
 [`require('url').format()`]: #url_url_format_url_options
 [`url.domainToASCII()`]: #url_url_domaintoascii_domain
 [`url.domainToUnicode()`]: #url_url_domaintounicode_domain
@@ -1371,10 +1544,6 @@ console.log(myURL.origin);
 [`url.toString()`]: #url_url_tostring
 [`urlSearchParams.entries()`]: #url_urlsearchparams_entries
 [`urlSearchParams@@iterator()`]: #url_urlsearchparams_symbol_iterator
-[ICU]: intl.html#intl_options_for_building_node_js
-[Punycode]: https://tools.ietf.org/html/rfc5891#section-4.4
-[WHATWG URL Standard]: https://url.spec.whatwg.org/
-[WHATWG URL]: #url_the_whatwg_url_api
 [examples of parsed URLs]: https://url.spec.whatwg.org/#example-url-parsing
 [host name spoofing]: https://hackerone.com/reports/678487
 [legacy `urlObject`]: #url_legacy_urlobject
diff --git a/doc/api/util.html b/doc/api/util.html
index 1720ee3a512654db17e369e971d2abc85bebbe4f..0f7606f2c72768df88a5ba821f3bba3f3e86627f 100644
--- a/doc/api/util.html
+++ b/doc/api/util.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Util | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Util | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="util" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/util.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/util.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/util.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/util.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/util.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/util.html">13.x</a></li>
@@ -118,24 +133,28 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/util.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/util.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/util.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#util_util">Util</a></span>
 <ul>
 <li><a href="#util_util_callbackify_original"><code>util.callbackify(original)</code></a></li>
-<li><a href="#util_util_debuglog_section_callback"><code>util.debuglog(section[, callback])</code></a></li>
+<li><a href="#util_util_debuglog_section_callback"><code>util.debuglog(section[, callback])</code></a>
+<ul>
+<li><a href="#util_debuglog_enabled"><code>debuglog().enabled</code></a></li>
+</ul>
+</li>
+<li><a href="#util_util_debug_section"><code>util.debug(section)</code></a></li>
 <li><a href="#util_util_deprecate_fn_msg_code"><code>util.deprecate(fn, msg[, code])</code></a></li>
 <li><a href="#util_util_format_format_args"><code>util.format(format[, ...args])</code></a></li>
 <li><a href="#util_util_formatwithoptions_inspectoptions_format_args"><code>util.formatWithOptions(inspectOptions, format[, ...args])</code></a></li>
 <li><a href="#util_util_getsystemerrorname_err"><code>util.getSystemErrorName(err)</code></a></li>
-<li><a href="#util_util_inherits_constructor_superconstructor"><code>util.inherits(constructor, superConstructor)</code></a></li>
+<li><a href="#util_util_getsystemerrormap"><code>util.getSystemErrorMap()</code></a></li>
+<li><span class="stability_3"><a href="#util_util_inherits_constructor_superconstructor"><code>util.inherits(constructor, superConstructor)</code></a></span></li>
 <li><a href="#util_util_inspect_object_options"><code>util.inspect(object[, options])</code></a></li>
 <li><a href="#util_util_inspect_object_showhidden_depth_colors"><code>util.inspect(object[, showHidden[, depth[, colors]]])</code></a>
 <ul>
@@ -162,9 +181,9 @@
 <ul>
 <li><a href="#util_whatwg_supported_encodings">WHATWG supported encodings</a>
 <ul>
-<li><a href="#util_encodings_supported_without_icu">Encodings Supported Without ICU</a></li>
-<li><a href="#util_encodings_supported_by_default_with_icu">Encodings Supported by Default (With ICU)</a></li>
-<li><a href="#util_encodings_requiring_full_icu_data">Encodings requiring full ICU data</a></li>
+<li><a href="#util_encodings_supported_by_default_with_full_icu_data">Encodings supported by default (with full ICU data)</a></li>
+<li><a href="#util_encodings_supported_when_node_js_is_built_with_the_small_icu_option">Encodings supported when Node.js is built with the <code>small-icu</code> option</a></li>
+<li><a href="#util_encodings_supported_when_icu_is_disabled">Encodings supported when ICU is disabled</a></li>
 </ul>
 </li>
 <li><a href="#util_new_textdecoder_encoding_options"><code>new TextDecoder([encoding[, options]])</code></a></li>
@@ -181,6 +200,7 @@
 <li><a href="#util_textencoder_encoding"><code>textEncoder.encoding</code></a></li>
 </ul>
 </li>
+<li><a href="#util_util_tousvstring_string"><code>util.toUSVString(string)</code></a></li>
 <li><a href="#util_util_types"><code>util.types</code></a>
 <ul>
 <li><a href="#util_util_types_isanyarraybuffer_value"><code>util.types.isAnyArrayBuffer(value)</code></a></li>
@@ -222,7 +242,7 @@
 <li><a href="#util_util_types_isuint32array_value"><code>util.types.isUint32Array(value)</code></a></li>
 <li><a href="#util_util_types_isweakmap_value"><code>util.types.isWeakMap(value)</code></a></li>
 <li><a href="#util_util_types_isweakset_value"><code>util.types.isWeakSet(value)</code></a></li>
-<li><a href="#util_util_types_iswebassemblycompiledmodule_value"><code>util.types.isWebAssemblyCompiledModule(value)</code></a></li>
+<li><span class="stability_0"><a href="#util_util_types_iswebassemblycompiledmodule_value"><code>util.types.isWebAssemblyCompiledModule(value)</code></a></span></li>
 </ul>
 </li>
 <li><a href="#util_deprecated_apis">Deprecated APIs</a>
@@ -248,19 +268,18 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Util<span><a class="mark" href="#util_util" id="util_util">#</a></span></h1>
+        <h2>Util<span><a class="mark" href="#util_util" id="util_util">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/util.js">lib/util.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/util.js">lib/util.js</a></p>
 <p>The <code>util</code> module supports the needs of Node.js internal APIs. Many of the
 utilities are useful for application and module developers as well. To access
 it:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);</code></pre>
-<h2><code>util.callbackify(original)</code><span><a class="mark" href="#util_util_callbackify_original" id="util_util_callbackify_original">#</a></span></h2>
+<section><h3><code>util.callbackify(original)</code><span><a class="mark" href="#util_util_callbackify_original" id="util_util_callbackify_original">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.2.0</span>
 </div>
@@ -275,14 +294,14 @@ first argument will be the rejection reason (or <code>null</code> if the <code>P
 resolved), and the second argument will be the resolved value.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">fn</span>(<span class="hljs-params"></span>) </span>{
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">fn</span>(<span class="hljs-params"></span>) {
   <span class="hljs-keyword">return</span> <span class="hljs-string">'hello world'</span>;
 }
-<span class="hljs-keyword">const</span> callbackFunction = util.callbackify(fn);
+<span class="hljs-keyword">const</span> callbackFunction = util.<span class="hljs-title function_">callbackify</span>(fn);
 
-callbackFunction(<span class="hljs-function">(<span class="hljs-params">err, ret</span>) =></span> {
+<span class="hljs-title function_">callbackFunction</span>(<span class="hljs-function">(<span class="hljs-params">err, ret</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) <span class="hljs-keyword">throw</span> err;
-  <span class="hljs-built_in">console</span>.log(ret);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(ret);
 });</code></pre>
 <p>Will print:</p>
 <pre><code class="language-text">hello world</code></pre>
@@ -293,17 +312,17 @@ event, and if not handled will exit.</p>
 wrapped function rejects a <code>Promise</code> with a falsy value as a reason, the value
 is wrapped in an <code>Error</code> with the original value stored in a field named
 <code>reason</code>.</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">fn</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">return</span> <span class="hljs-built_in">Promise</span>.reject(<span class="hljs-literal">null</span>);
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">fn</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">return</span> <span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">reject</span>(<span class="hljs-literal">null</span>);
 }
-<span class="hljs-keyword">const</span> callbackFunction = util.callbackify(fn);
+<span class="hljs-keyword">const</span> callbackFunction = util.<span class="hljs-title function_">callbackify</span>(fn);
 
-callbackFunction(<span class="hljs-function">(<span class="hljs-params">err, ret</span>) =></span> {
+<span class="hljs-title function_">callbackFunction</span>(<span class="hljs-function">(<span class="hljs-params">err, ret</span>) =></span> {
   <span class="hljs-comment">// When the Promise was rejected with `null` it is wrapped with an Error and</span>
   <span class="hljs-comment">// the original value is stored in `reason`.</span>
-  err &#x26;&#x26; err.hasOwnProperty(<span class="hljs-string">'reason'</span>) &#x26;&#x26; err.reason === <span class="hljs-literal">null</span>;  <span class="hljs-comment">// true</span>
+  err &#x26;&#x26; err.<span class="hljs-title function_">hasOwnProperty</span>(<span class="hljs-string">'reason'</span>) &#x26;&#x26; err.<span class="hljs-property">reason</span> === <span class="hljs-literal">null</span>;  <span class="hljs-comment">// true</span>
 });</code></pre>
-<h2><code>util.debuglog(section[, callback])</code><span><a class="mark" href="#util_util_debuglog_section_callback" id="util_util_debuglog_section_callback">#</a></span></h2>
+</section><section><h3><code>util.debuglog(section[, callback])</code><span><a class="mark" href="#util_util_debuglog_section_callback" id="util_util_debuglog_section_callback">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.3</span>
 </div>
@@ -320,9 +339,9 @@ environment variable. If the <code>section</code> name appears within the value
 environment variable, then the returned function operates similar to
 <a href="console.html#console_console_error_data_args"><code>console.error()</code></a>. If not, then the returned function is a no-op.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> debuglog = util.debuglog(<span class="hljs-string">'foo'</span>);
+<span class="hljs-keyword">const</span> debuglog = util.<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'foo'</span>);
 
-debuglog(<span class="hljs-string">'hello from foo [%d]'</span>, <span class="hljs-number">123</span>);</code></pre>
+<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'hello from foo [%d]'</span>, <span class="hljs-number">123</span>);</code></pre>
 <p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then
 it will output something like:</p>
 <pre><code class="language-console">FOO 3245: hello from foo [123]</code></pre>
@@ -330,9 +349,9 @@ it will output something like:</p>
 environment variable set, then it will not print anything.</p>
 <p>The <code>section</code> supports wildcard also:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> debuglog = util.debuglog(<span class="hljs-string">'foo-bar'</span>);
+<span class="hljs-keyword">const</span> debuglog = util.<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'foo-bar'</span>);
 
-debuglog(<span class="hljs-string">'hi there, it\'s foo-bar [%d]'</span>, <span class="hljs-number">2333</span>);</code></pre>
+<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'hi there, it\'s foo-bar [%d]'</span>, <span class="hljs-number">2333</span>);</code></pre>
 <p>if it is run with <code>NODE_DEBUG=foo*</code> in the environment, then it will output
 something like:</p>
 <pre><code class="language-console">FOO-BAR 3257: hi there, it's foo-bar [2333]</code></pre>
@@ -342,12 +361,38 @@ environment variable: <code>NODE_DEBUG=fs,net,tls</code>.</p>
 with a different function that doesn't have any initialization or
 unnecessary wrapping.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">let</span> debuglog = util.debuglog(<span class="hljs-string">'internals'</span>, <span class="hljs-function">(<span class="hljs-params">debug</span>) =></span> {
+<span class="hljs-keyword">let</span> debuglog = util.<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'internals'</span>, <span class="hljs-function">(<span class="hljs-params">debug</span>) =></span> {
   <span class="hljs-comment">// Replace with a logging function that optimizes out</span>
   <span class="hljs-comment">// testing if the section is enabled</span>
   debuglog = debug;
 });</code></pre>
-<h2><code>util.deprecate(fn, msg[, code])</code><span><a class="mark" href="#util_util_deprecate_fn_msg_code" id="util_util_deprecate_fn_msg_code">#</a></span></h2>
+<h4><code>debuglog().enabled</code><span><a class="mark" href="#util_debuglog_enabled" id="util_debuglog_enabled">#</a></span></h4>
+<div class="api_metadata">
+<span>Added in: v14.9.0</span>
+</div>
+<ul>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
+</ul>
+<p>The <code>util.debuglog().enabled</code> getter is used to create a test that can be used
+in conditionals based on the existence of the <code>NODE_DEBUG</code> environment variable.
+If the <code>section</code> name appears within the value of that environment variable,
+then the returned value will be <code>true</code>. If not, then the returned value will be
+<code>false</code>.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
+<span class="hljs-keyword">const</span> enabled = util.<span class="hljs-title function_">debuglog</span>(<span class="hljs-string">'foo'</span>).<span class="hljs-property">enabled</span>;
+<span class="hljs-keyword">if</span> (enabled) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'hello from foo [%d]'</span>, <span class="hljs-number">123</span>);
+}</code></pre>
+<p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then it will
+output something like:</p>
+<pre><code class="language-console">hello from foo [123]</code></pre>
+</section><section><h3><code>util.debug(section)</code><span><a class="mark" href="#util_util_debug_section" id="util_util_debug_section">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.9.0</span>
+</div>
+<p>Alias for <code>util.debuglog</code>. Usage allows for readability of that doesn't imply
+logging when only using <code>util.debuglog().enabled</code>.</p>
+</section><section><h3><code>util.deprecate(fn, msg[, code])</code><span><a class="mark" href="#util_util_deprecate_fn_msg_code" id="util_util_deprecate_fn_msg_code">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -371,7 +416,7 @@ list of codes.</li>
 such a way that it is marked as deprecated.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-built_in">exports</span>.obsoleteFunction = util.deprecate(<span class="hljs-function">() =></span> {
+<span class="hljs-built_in">exports</span>.<span class="hljs-property">obsoleteFunction</span> = util.<span class="hljs-title function_">deprecate</span>(<span class="hljs-function">() =></span> {
   <span class="hljs-comment">// Do something here.</span>
 }, <span class="hljs-string">'obsoleteFunction() is deprecated. Use newShinyFunction() instead.'</span>);</code></pre>
 <p>When called, <code>util.deprecate()</code> will return a function that will emit a
@@ -383,24 +428,24 @@ emitting a warning.</p>
 the warning will be emitted only once for that <code>code</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-keyword">const</span> fn1 = util.deprecate(someFunction, someMessage, <span class="hljs-string">'DEP0001'</span>);
-<span class="hljs-keyword">const</span> fn2 = util.deprecate(someOtherFunction, someOtherMessage, <span class="hljs-string">'DEP0001'</span>);
-fn1(); <span class="hljs-comment">// Emits a deprecation warning with code DEP0001</span>
-fn2(); <span class="hljs-comment">// Does not emit a deprecation warning because it has the same code</span></code></pre>
-<p>If either the <code>--no-deprecation</code> or <code>--no-warnings</code> command line flags are
+<span class="hljs-keyword">const</span> fn1 = util.<span class="hljs-title function_">deprecate</span>(someFunction, someMessage, <span class="hljs-string">'DEP0001'</span>);
+<span class="hljs-keyword">const</span> fn2 = util.<span class="hljs-title function_">deprecate</span>(someOtherFunction, someOtherMessage, <span class="hljs-string">'DEP0001'</span>);
+<span class="hljs-title function_">fn1</span>(); <span class="hljs-comment">// Emits a deprecation warning with code DEP0001</span>
+<span class="hljs-title function_">fn2</span>(); <span class="hljs-comment">// Does not emit a deprecation warning because it has the same code</span></code></pre>
+<p>If either the <code>--no-deprecation</code> or <code>--no-warnings</code> command-line flags are
 used, or if the <code>process.noDeprecation</code> property is set to <code>true</code> <em>prior</em> to
 the first deprecation warning, the <code>util.deprecate()</code> method does nothing.</p>
-<p>If the <code>--trace-deprecation</code> or <code>--trace-warnings</code> command line flags are set,
+<p>If the <code>--trace-deprecation</code> or <code>--trace-warnings</code> command-line flags are set,
 or the <code>process.traceDeprecation</code> property is set to <code>true</code>, a warning and a
 stack trace are printed to <code>stderr</code> the first time the deprecated function is
 called.</p>
-<p>If the <code>--throw-deprecation</code> command line flag is set, or the
+<p>If the <code>--throw-deprecation</code> command-line flag is set, or the
 <code>process.throwDeprecation</code> property is set to <code>true</code>, then an exception will be
 thrown when the deprecated function is called.</p>
-<p>The <code>--throw-deprecation</code> command line flag and <code>process.throwDeprecation</code>
+<p>The <code>--throw-deprecation</code> command-line flag and <code>process.throwDeprecation</code>
 property take precedence over <code>--trace-deprecation</code> and
 <code>process.traceDeprecation</code>.</p>
-<h2><code>util.format(format[, ...args])</code><span><a class="mark" href="#util_util_format_format_args" id="util_util_format_format_args">#</a></span></h2>
+</section><section><h3><code>util.format(format[, ...args])</code><span><a class="mark" href="#util_util_format_format_args" id="util_util_format_format_args">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -457,27 +502,27 @@ the full object not including non-enumerable properties and proxies.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The formatted string</li>
 </ul>
 <p>If a specifier does not have a corresponding argument, it is not replaced:</p>
-<pre><code class="language-js">util.format(<span class="hljs-string">'%s:%s'</span>, <span class="hljs-string">'foo'</span>);
+<pre><code class="language-js">util.<span class="hljs-title function_">format</span>(<span class="hljs-string">'%s:%s'</span>, <span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Returns: 'foo:%s'</span></code></pre>
 <p>Values that are not part of the format string are formatted using
 <code>util.inspect()</code> if their type is not <code>string</code>.</p>
 <p>If there are more arguments passed to the <code>util.format()</code> method than the
 number of specifiers, the extra arguments are concatenated to the returned
 string, separated by spaces:</p>
-<pre><code class="language-js">util.format(<span class="hljs-string">'%s:%s'</span>, <span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>, <span class="hljs-string">'baz'</span>);
+<pre><code class="language-js">util.<span class="hljs-title function_">format</span>(<span class="hljs-string">'%s:%s'</span>, <span class="hljs-string">'foo'</span>, <span class="hljs-string">'bar'</span>, <span class="hljs-string">'baz'</span>);
 <span class="hljs-comment">// Returns: 'foo:bar baz'</span></code></pre>
 <p>If the first argument does not contain a valid format specifier, <code>util.format()</code>
 returns a string that is the concatenation of all arguments separated by spaces:</p>
-<pre><code class="language-js">util.format(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>);
+<pre><code class="language-js">util.<span class="hljs-title function_">format</span>(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>);
 <span class="hljs-comment">// Returns: '1 2 3'</span></code></pre>
 <p>If only one argument is passed to <code>util.format()</code>, it is returned as it is
 without any formatting:</p>
-<pre><code class="language-js">util.format(<span class="hljs-string">'%% %s'</span>);
+<pre><code class="language-js">util.<span class="hljs-title function_">format</span>(<span class="hljs-string">'%% %s'</span>);
 <span class="hljs-comment">// Returns: '%% %s'</span></code></pre>
 <p><code>util.format()</code> is a synchronous method that is intended as a debugging tool.
 Some input values can have a significant performance overhead that can block the
 event loop. Use this function with care and never in a hot code path.</p>
-<h2><code>util.formatWithOptions(inspectOptions, format[, ...args])</code><span><a class="mark" href="#util_util_formatwithoptions_inspectoptions_format_args" id="util_util_formatwithoptions_inspectoptions_format_args">#</a></span></h2>
+</section><section><h3><code>util.formatWithOptions(inspectOptions, format[, ...args])</code><span><a class="mark" href="#util_util_formatwithoptions_inspectoptions_format_args" id="util_util_formatwithoptions_inspectoptions_format_args">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -488,10 +533,10 @@ event loop. Use this function with care and never in a hot code path.</p>
 <p>This function is identical to <a href="#util_util_format_format_args"><code>util.format()</code></a>, except in that it takes
 an <code>inspectOptions</code> argument which specifies options that are passed along to
 <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a>.</p>
-<pre><code class="language-js">util.formatWithOptions({ <span class="hljs-attr">colors</span>: <span class="hljs-literal">true</span> }, <span class="hljs-string">'See object %O'</span>, { <span class="hljs-attr">foo</span>: <span class="hljs-number">42</span> });
+<pre><code class="language-js">util.<span class="hljs-title function_">formatWithOptions</span>({ <span class="hljs-attr">colors</span>: <span class="hljs-literal">true</span> }, <span class="hljs-string">'See object %O'</span>, { <span class="hljs-attr">foo</span>: <span class="hljs-number">42</span> });
 <span class="hljs-comment">// Returns 'See object { foo: 42 }', where `42` is colored as a number</span>
 <span class="hljs-comment">// when printed to a terminal.</span></code></pre>
-<h2><code>util.getSystemErrorName(err)</code><span><a class="mark" href="#util_util_getsystemerrorname_err" id="util_util_getsystemerrorname_err">#</a></span></h2>
+</section><section><h3><code>util.getSystemErrorName(err)</code><span><a class="mark" href="#util_util_getsystemerrorname_err" id="util_util_getsystemerrorname_err">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.7.0</span>
 </div>
@@ -502,11 +547,26 @@ an <code>inspectOptions</code> argument which specifies options that are passed
 <p>Returns the string name for a numeric error code that comes from a Node.js API.
 The mapping between error codes and error names is platform-dependent.
 See <a href="errors.html#errors_common_system_errors">Common System Errors</a> for the names of common errors.</p>
-<pre><code class="language-js">fs.access(<span class="hljs-string">'file/that/does/not/exist'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-  <span class="hljs-keyword">const</span> name = util.getSystemErrorName(err.errno);
-  <span class="hljs-built_in">console</span>.error(name);  <span class="hljs-comment">// ENOENT</span>
+<pre><code class="language-js">fs.<span class="hljs-title function_">access</span>(<span class="hljs-string">'file/that/does/not/exist'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">const</span> name = util.<span class="hljs-title function_">getSystemErrorName</span>(err.<span class="hljs-property">errno</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(name);  <span class="hljs-comment">// ENOENT</span>
+});</code></pre>
+</section><section><h3><code>util.getSystemErrorMap()</code><span><a class="mark" href="#util_util_getsystemerrormap" id="util_util_getsystemerrormap">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.17.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" class="type">&#x3C;Map></a></li>
+</ul>
+<p>Returns a Map of all system error codes available from the Node.js API.
+The mapping between error codes and error names is platform-dependent.
+See <a href="errors.html#errors_common_system_errors">Common System Errors</a> for the names of common errors.</p>
+<pre><code class="language-js">fs.<span class="hljs-title function_">access</span>(<span class="hljs-string">'file/that/does/not/exist'</span>, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">const</span> errorMap = util.<span class="hljs-title function_">getSystemErrorMap</span>();
+  <span class="hljs-keyword">const</span> name = errorMap.<span class="hljs-title function_">get</span>(err.<span class="hljs-property">errno</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(name);  <span class="hljs-comment">// ENOENT</span>
 });</code></pre>
-<h2><code>util.inherits(constructor, superConstructor)</code><span><a class="mark" href="#util_util_inherits_constructor_superconstructor" id="util_util_inherits_constructor_superconstructor">#</a></span></h2>
+</section><section><h3><code>util.inherits(constructor, superConstructor)</code><span><a class="mark" href="#util_util_inherits_constructor_superconstructor" id="util_util_inherits_constructor_superconstructor">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -518,6 +578,7 @@ See <a href="errors.html#errors_common_system_errors">Common System Errors</a> f
 </tbody></table>
 </details>
 </div>
+<p></p><div class="api_stability api_stability_3"><a href="documentation.html#documentation_stability_index">Stability: 3</a> - Legacy: Use ES2015 class syntax and <code>extends</code> keyword instead.</div><p></p>
 <ul>
 <li><code>constructor</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 <li><code>superConstructor</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
@@ -533,53 +594,55 @@ prototype of <code>constructor</code> will be set to a new object created from
 As an additional convenience, <code>superConstructor</code> will be accessible
 through the <code>constructor.super_</code> property.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">MyStream</span>(<span class="hljs-params"></span>) </span>{
-  EventEmitter.call(<span class="hljs-built_in">this</span>);
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">MyStream</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-title class_">EventEmitter</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>);
 }
 
-util.inherits(MyStream, EventEmitter);
+util.<span class="hljs-title function_">inherits</span>(<span class="hljs-title class_">MyStream</span>, <span class="hljs-title class_">EventEmitter</span>);
 
-MyStream.prototype.write = <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params">data</span>) </span>{
-  <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'data'</span>, data);
+<span class="hljs-title class_">MyStream</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">write</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">data</span>) {
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'data'</span>, data);
 };
 
-<span class="hljs-keyword">const</span> stream = <span class="hljs-keyword">new</span> MyStream();
+<span class="hljs-keyword">const</span> stream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyStream</span>();
 
-<span class="hljs-built_in">console</span>.log(stream <span class="hljs-keyword">instanceof</span> EventEmitter); <span class="hljs-comment">// true</span>
-<span class="hljs-built_in">console</span>.log(MyStream.super_ === EventEmitter); <span class="hljs-comment">// true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(stream <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">EventEmitter</span>); <span class="hljs-comment">// true</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">MyStream</span>.<span class="hljs-property">super_</span> === <span class="hljs-title class_">EventEmitter</span>); <span class="hljs-comment">// true</span>
 
-stream.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received data: "<span class="hljs-subst">${data}</span>"`</span>);
+stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received data: "<span class="hljs-subst">${data}</span>"`</span>);
 });
-stream.write(<span class="hljs-string">'It works!'</span>); <span class="hljs-comment">// Received data: "It works!"</span></code></pre>
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'It works!'</span>); <span class="hljs-comment">// Received data: "It works!"</span></code></pre>
 <p>ES6 example using <code>class</code> and <code>extends</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> EventEmitter = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-title class_">EventEmitter</span> = <span class="hljs-built_in">require</span>(<span class="hljs-string">'events'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyStream</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">EventEmitter</span> </span>{
-  write(data) {
-    <span class="hljs-built_in">this</span>.emit(<span class="hljs-string">'data'</span>, data);
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyStream</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_ inherited__">EventEmitter</span> {
+  <span class="hljs-title function_">write</span>(<span class="hljs-params">data</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">emit</span>(<span class="hljs-string">'data'</span>, data);
   }
 }
 
-<span class="hljs-keyword">const</span> stream = <span class="hljs-keyword">new</span> MyStream();
+<span class="hljs-keyword">const</span> stream = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MyStream</span>();
 
-stream.on(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`Received data: "<span class="hljs-subst">${data}</span>"`</span>);
+stream.<span class="hljs-title function_">on</span>(<span class="hljs-string">'data'</span>, <span class="hljs-function">(<span class="hljs-params">data</span>) =></span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`Received data: "<span class="hljs-subst">${data}</span>"`</span>);
 });
-stream.write(<span class="hljs-string">'With ES6'</span>);</code></pre>
-<h2><code>util.inspect(object[, options])</code><span><a class="mark" href="#util_util_inspect_object_options" id="util_util_inspect_object_options">#</a></span></h2>
-<h2><code>util.inspect(object[, showHidden[, depth[, colors]]])</code><span><a class="mark" href="#util_util_inspect_object_showhidden_depth_colors" id="util_util_inspect_object_showhidden_depth_colors">#</a></span></h2>
+stream.<span class="hljs-title function_">write</span>(<span class="hljs-string">'With ES6'</span>);</code></pre>
+</section><section><h3><code>util.inspect(object[, options])</code><span><a class="mark" href="#util_util_inspect_object_options" id="util_util_inspect_object_options">#</a></span></h3>
+</section><section><h3><code>util.inspect(object[, showHidden[, depth[, colors]]])</code><span><a class="mark" href="#util_util_inspect_object_showhidden_depth_colors" id="util_util_inspect_object_showhidden_depth_colors">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v13.0.0</td>
+<td><p>Circular references now include a marker to the reference.</p></td></tr>
 <tr><td>v14.6.0, v12.19.0</td>
 <td><p>If <code>object</code> is from a different <code>vm.Context</code> now, a custom inspection function on it will not receive context-specific arguments anymore.</p></td></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.13.0, v12.17.0</td>
 <td><p>The <code>maxStringLength</code> option is supported now.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.5.0, v12.16.0</td>
 <td><p>User defined prototype properties are inspected in case <code>showHidden</code> is <code>true</code>.</p></td></tr>
 <tr><td>v12.0.0</td>
 <td><p>The <code>compact</code> options default is changed to <code>3</code> and the <code>breakLength</code> options default is changed to <code>80</code>.</p></td></tr>
@@ -675,37 +738,37 @@ and should not be depended upon programmatically. Additional <code>options</code
 passed that alter the result.
 <code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make
 an identifiable tag for an inspected value.</p>
-<pre><code class="language-js"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Foo</span> </span>{
-  get [<span class="hljs-built_in">Symbol</span>.toStringTag]() {
+<pre><code class="language-js"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Foo</span> {
+  get [<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">toStringTag</span>]() {
     <span class="hljs-keyword">return</span> <span class="hljs-string">'bar'</span>;
   }
 }
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Bar</span> </span>{}
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Bar</span> {}
 
-<span class="hljs-keyword">const</span> baz = <span class="hljs-built_in">Object</span>.create(<span class="hljs-literal">null</span>, { [<span class="hljs-built_in">Symbol</span>.toStringTag]: { <span class="hljs-attr">value</span>: <span class="hljs-string">'foo'</span> } });
+<span class="hljs-keyword">const</span> baz = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(<span class="hljs-literal">null</span>, { [<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">toStringTag</span>]: { <span class="hljs-attr">value</span>: <span class="hljs-string">'foo'</span> } });
 
-util.inspect(<span class="hljs-keyword">new</span> Foo()); <span class="hljs-comment">// 'Foo [bar] {}'</span>
-util.inspect(<span class="hljs-keyword">new</span> Bar()); <span class="hljs-comment">// 'Bar {}'</span>
-util.inspect(baz);       <span class="hljs-comment">// '[foo] {}'</span></code></pre>
-<p>Circular references are marked as <code>'[Circular]'</code>:</p>
+util.<span class="hljs-title function_">inspect</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Foo</span>()); <span class="hljs-comment">// 'Foo [bar] {}'</span>
+util.<span class="hljs-title function_">inspect</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Bar</span>()); <span class="hljs-comment">// 'Bar {}'</span>
+util.<span class="hljs-title function_">inspect</span>(baz);       <span class="hljs-comment">// '[foo] {}'</span></code></pre>
+<p>Circular references point to their anchor by using a reference index:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { inspect } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
 <span class="hljs-keyword">const</span> obj = {};
-obj.a = [obj];
-obj.b = {};
-obj.b.inner = obj.b;
-obj.b.obj = obj;
-
-<span class="hljs-built_in">console</span>.log(inspect(obj));
-<span class="hljs-comment">// {</span>
-<span class="hljs-comment">//   a: [ [Circular] ],</span>
-<span class="hljs-comment">//   b: { inner: [Circular], obj: [Circular] }</span>
+obj.<span class="hljs-property">a</span> = [obj];
+obj.<span class="hljs-property">b</span> = {};
+obj.<span class="hljs-property">b</span>.<span class="hljs-property">inner</span> = obj.<span class="hljs-property">b</span>;
+obj.<span class="hljs-property">b</span>.<span class="hljs-property">obj</span> = obj;
+
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">inspect</span>(obj));
+<span class="hljs-comment">// &#x3C;ref *1> {</span>
+<span class="hljs-comment">//   a: [ [Circular *1] ],</span>
+<span class="hljs-comment">//   b: &#x3C;ref *2> { inner: [Circular *2], obj: [Circular *1] }</span>
 <span class="hljs-comment">// }</span></code></pre>
 <p>The following example inspects all properties of the <code>util</code> object:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-built_in">console</span>.log(util.inspect(util, { <span class="hljs-attr">showHidden</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">depth</span>: <span class="hljs-literal">null</span> }));</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(util.<span class="hljs-title function_">inspect</span>(util, { <span class="hljs-attr">showHidden</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">depth</span>: <span class="hljs-literal">null</span> }));</code></pre>
 <p>The following example highlights the effect of the <code>compact</code> option:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
@@ -715,9 +778,9 @@ obj.b.obj = obj;
       <span class="hljs-string">'eiusmod tempor incididunt ut labore et dolore magna aliqua.'</span>,
     <span class="hljs-string">'test'</span>,
     <span class="hljs-string">'foo'</span>]], <span class="hljs-number">4</span>],
-  <span class="hljs-attr">b</span>: <span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>([[<span class="hljs-string">'za'</span>, <span class="hljs-number">1</span>], [<span class="hljs-string">'zb'</span>, <span class="hljs-string">'test'</span>]])
+  <span class="hljs-attr">b</span>: <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>([[<span class="hljs-string">'za'</span>, <span class="hljs-number">1</span>], [<span class="hljs-string">'zb'</span>, <span class="hljs-string">'test'</span>]])
 };
-<span class="hljs-built_in">console</span>.log(util.inspect(o, { <span class="hljs-attr">compact</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">depth</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">breakLength</span>: <span class="hljs-number">80</span> }));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(util.<span class="hljs-title function_">inspect</span>(o, { <span class="hljs-attr">compact</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">depth</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">breakLength</span>: <span class="hljs-number">80</span> }));
 
 <span class="hljs-comment">// { a:</span>
 <span class="hljs-comment">//   [ 1,</span>
@@ -726,10 +789,10 @@ obj.b.obj = obj;
 <span class="hljs-comment">//           'test',</span>
 <span class="hljs-comment">//           'foo' ] ],</span>
 <span class="hljs-comment">//     4 ],</span>
-<span class="hljs-comment">//   b: Map { 'za' => 1, 'zb' => 'test' } }</span>
+<span class="hljs-comment">//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }</span>
 
 <span class="hljs-comment">// Setting `compact` to false changes the output to be more reader friendly.</span>
-<span class="hljs-built_in">console</span>.log(util.inspect(o, { <span class="hljs-attr">compact</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">depth</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">breakLength</span>: <span class="hljs-number">80</span> }));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(util.<span class="hljs-title function_">inspect</span>(o, { <span class="hljs-attr">compact</span>: <span class="hljs-literal">false</span>, <span class="hljs-attr">depth</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">breakLength</span>: <span class="hljs-number">80</span> }));
 
 <span class="hljs-comment">// {</span>
 <span class="hljs-comment">//   a: [</span>
@@ -747,7 +810,7 @@ obj.b.obj = obj;
 <span class="hljs-comment">//     ],</span>
 <span class="hljs-comment">//     4</span>
 <span class="hljs-comment">//   ],</span>
-<span class="hljs-comment">//   b: Map {</span>
+<span class="hljs-comment">//   b: Map(2) {</span>
 <span class="hljs-comment">//     'za' => 1,</span>
 <span class="hljs-comment">//     'zb' => 'test'</span>
 <span class="hljs-comment">//   }</span>
@@ -766,9 +829,9 @@ with no remaining strong references may be garbage collected at any time.</p>
 
 <span class="hljs-keyword">const</span> obj = { <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> };
 <span class="hljs-keyword">const</span> obj2 = { <span class="hljs-attr">b</span>: <span class="hljs-number">2</span> };
-<span class="hljs-keyword">const</span> weakSet = <span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakSet</span>([obj, obj2]);
+<span class="hljs-keyword">const</span> weakSet = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakSet</span>([obj, obj2]);
 
-<span class="hljs-built_in">console</span>.log(inspect(weakSet, { <span class="hljs-attr">showHidden</span>: <span class="hljs-literal">true</span> }));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">inspect</span>(weakSet, { <span class="hljs-attr">showHidden</span>: <span class="hljs-literal">true</span> }));
 <span class="hljs-comment">// WeakSet { { a: 1 }, { b: 2 } }</span></code></pre>
 <p>The <code>sorted</code> option ensures that an object's property insertion order does not
 impact the result of <code>util.inspect()</code>.</p>
@@ -778,26 +841,26 @@ impact the result of <code>util.inspect()</code>.</p>
 <span class="hljs-keyword">const</span> o1 = {
   <span class="hljs-attr">b</span>: [<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>],
   <span class="hljs-attr">a</span>: <span class="hljs-string">'`a` comes before `b`'</span>,
-  <span class="hljs-attr">c</span>: <span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>([<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>])
+  <span class="hljs-attr">c</span>: <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>([<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>])
 };
-<span class="hljs-built_in">console</span>.log(inspect(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> }));
-<span class="hljs-comment">// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set { 1, 2, 3 } }</span>
-<span class="hljs-built_in">console</span>.log(inspect(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> b.localeCompare(a) }));
-<span class="hljs-comment">// { c: Set { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">inspect</span>(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> }));
+<span class="hljs-comment">// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">inspect</span>(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-function">(<span class="hljs-params">a, b</span>) =></span> b.<span class="hljs-title function_">localeCompare</span>(a) }));
+<span class="hljs-comment">// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }</span>
 
 <span class="hljs-keyword">const</span> o2 = {
-  <span class="hljs-attr">c</span>: <span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>([<span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">3</span>]),
+  <span class="hljs-attr">c</span>: <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>([<span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">3</span>]),
   <span class="hljs-attr">a</span>: <span class="hljs-string">'`a` comes before `b`'</span>,
   <span class="hljs-attr">b</span>: [<span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>]
 };
-assert.strict.equal(
-  inspect(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> }),
-  inspect(o2, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> })
+assert.<span class="hljs-property">strict</span>.<span class="hljs-title function_">equal</span>(
+  <span class="hljs-title function_">inspect</span>(o1, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> }),
+  <span class="hljs-title function_">inspect</span>(o2, { <span class="hljs-attr">sorted</span>: <span class="hljs-literal">true</span> })
 );</code></pre>
 <p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum
 output length is approximately 128 MB. Inputs that result in longer output will
 be truncated.</p>
-<h3>Customizing <code>util.inspect</code> colors<span><a class="mark" href="#util_customizing_util_inspect_colors" id="util_customizing_util_inspect_colors">#</a></span></h3>
+<h4>Customizing <code>util.inspect</code> colors<span><a class="mark" href="#util_customizing_util_inspect_colors" id="util_customizing_util_inspect_colors">#</a></span></h4>
 
 <p>Color output (if enabled) of <code>util.inspect</code> is customizable globally
 via the <code>util.inspect.styles</code> and <code>util.inspect.colors</code> properties.</p>
@@ -822,7 +885,7 @@ via the <code>util.inspect.styles</code> and <code>util.inspect.colors</code> pr
 terminals. To verify color support use <a href="tty.html#tty_writestream_hascolors_count_env"><code>tty.hasColors()</code></a>.</p>
 <p>Predefined control codes are listed below (grouped as "Modifiers", "Foreground
 colors", and "Background colors").</p>
-<h4>Modifiers<span><a class="mark" href="#util_modifiers" id="util_modifiers">#</a></span></h4>
+<h5>Modifiers<span><a class="mark" href="#util_modifiers" id="util_modifiers">#</a></span></h5>
 <p>Modifier support varies throughout different terminals. They will mostly be
 ignored, if not supported.</p>
 <ul>
@@ -843,7 +906,7 @@ background colors (Alias: <code>swapcolors</code>, <code>swapColors</code>)</li>
 double underlined (Alias: <code>doubleUnderline</code>)</li>
 <li><span style="border: 1px">framed</span> - Draw a frame around the text</li>
 </ul>
-<h4>Foreground colors<span><a class="mark" href="#util_foreground_colors" id="util_foreground_colors">#</a></span></h4>
+<h5>Foreground colors<span><a class="mark" href="#util_foreground_colors" id="util_foreground_colors">#</a></span></h5>
 <ul>
 <li><code>black</code></li>
 <li><code>red</code></li>
@@ -862,7 +925,7 @@ double underlined (Alias: <code>doubleUnderline</code>)</li>
 <li><code>cyanBright</code></li>
 <li><code>whiteBright</code></li>
 </ul>
-<h4>Background colors<span><a class="mark" href="#util_background_colors" id="util_background_colors">#</a></span></h4>
+<h5>Background colors<span><a class="mark" href="#util_background_colors" id="util_background_colors">#</a></span></h5>
 <ul>
 <li><code>bgBlack</code></li>
 <li><code>bgRed</code></li>
@@ -881,7 +944,7 @@ double underlined (Alias: <code>doubleUnderline</code>)</li>
 <li><code>bgCyanBright</code></li>
 <li><code>bgWhiteBright</code></li>
 </ul>
-<h3>Custom inspection functions on objects<span><a class="mark" href="#util_custom_inspection_functions_on_objects" id="util_custom_inspection_functions_on_objects">#</a></span></h3>
+<h4>Custom inspection functions on objects<span><a class="mark" href="#util_custom_inspection_functions_on_objects" id="util_custom_inspection_functions_on_objects">#</a></span></h4>
 
 <p>Objects may also define their own
 <a href="#util_util_inspect_custom"><code>[util.inspect.custom](depth, opts)</code></a> function,
@@ -889,31 +952,31 @@ which <code>util.inspect()</code> will invoke and use the result of when inspect
 the object:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Box</span> </span>{
-  <span class="hljs-keyword">constructor</span>(value) {
-    <span class="hljs-built_in">this</span>.value = value;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Box</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">value</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">value</span> = value;
   }
 
-  [util.inspect.custom](depth, options) {
+  [util.<span class="hljs-property">inspect</span>.<span class="hljs-property">custom</span>](depth, options) {
     <span class="hljs-keyword">if</span> (depth &#x3C; <span class="hljs-number">0</span>) {
-      <span class="hljs-keyword">return</span> options.stylize(<span class="hljs-string">'[Box]'</span>, <span class="hljs-string">'special'</span>);
+      <span class="hljs-keyword">return</span> options.<span class="hljs-title function_">stylize</span>(<span class="hljs-string">'[Box]'</span>, <span class="hljs-string">'special'</span>);
     }
 
-    <span class="hljs-keyword">const</span> newOptions = <span class="hljs-built_in">Object</span>.assign({}, options, {
-      <span class="hljs-attr">depth</span>: options.depth === <span class="hljs-literal">null</span> ? <span class="hljs-literal">null</span> : options.depth - <span class="hljs-number">1</span>
+    <span class="hljs-keyword">const</span> newOptions = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">assign</span>({}, options, {
+      <span class="hljs-attr">depth</span>: options.<span class="hljs-property">depth</span> === <span class="hljs-literal">null</span> ? <span class="hljs-literal">null</span> : options.<span class="hljs-property">depth</span> - <span class="hljs-number">1</span>
     });
 
     <span class="hljs-comment">// Five space padding because that's the size of "Box&#x3C; ".</span>
-    <span class="hljs-keyword">const</span> padding = <span class="hljs-string">' '</span>.repeat(<span class="hljs-number">5</span>);
-    <span class="hljs-keyword">const</span> inner = util.inspect(<span class="hljs-built_in">this</span>.value, newOptions)
-                      .replace(<span class="hljs-regexp">/\n/g</span>, <span class="hljs-string">`\n<span class="hljs-subst">${padding}</span>`</span>);
+    <span class="hljs-keyword">const</span> padding = <span class="hljs-string">' '</span>.<span class="hljs-title function_">repeat</span>(<span class="hljs-number">5</span>);
+    <span class="hljs-keyword">const</span> inner = util.<span class="hljs-title function_">inspect</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">value</span>, newOptions)
+                      .<span class="hljs-title function_">replace</span>(<span class="hljs-regexp">/\n/g</span>, <span class="hljs-string">`\n<span class="hljs-subst">${padding}</span>`</span>);
     <span class="hljs-keyword">return</span> <span class="hljs-string">`<span class="hljs-subst">${options.stylize(<span class="hljs-string">'Box'</span>, <span class="hljs-string">'special'</span>)}</span>&#x3C; <span class="hljs-subst">${inner}</span> >`</span>;
   }
 }
 
-<span class="hljs-keyword">const</span> box = <span class="hljs-keyword">new</span> Box(<span class="hljs-literal">true</span>);
+<span class="hljs-keyword">const</span> box = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Box</span>(<span class="hljs-literal">true</span>);
 
-util.inspect(box);
+util.<span class="hljs-title function_">inspect</span>(box);
 <span class="hljs-comment">// Returns: "Box&#x3C; true >"</span></code></pre>
 <p>Custom <code>[util.inspect.custom](depth, opts)</code> functions typically return a string
 but may return a value of any type that will be formatted accordingly by
@@ -921,13 +984,13 @@ but may return a value of any type that will be formatted accordingly by
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
 <span class="hljs-keyword">const</span> obj = { <span class="hljs-attr">foo</span>: <span class="hljs-string">'this will not show up in the inspect() output'</span> };
-obj[util.inspect.custom] = <span class="hljs-function">(<span class="hljs-params">depth</span>) =></span> {
+obj[util.<span class="hljs-property">inspect</span>.<span class="hljs-property">custom</span>] = <span class="hljs-function">(<span class="hljs-params">depth</span>) =></span> {
   <span class="hljs-keyword">return</span> { <span class="hljs-attr">bar</span>: <span class="hljs-string">'baz'</span> };
 };
 
-util.inspect(obj);
+util.<span class="hljs-title function_">inspect</span>(obj);
 <span class="hljs-comment">// Returns: "{ bar: 'baz' }"</span></code></pre>
-<h3><code>util.inspect.custom</code><span><a class="mark" href="#util_util_inspect_custom" id="util_util_inspect_custom">#</a></span></h3>
+<h4><code>util.inspect.custom</code><span><a class="mark" href="#util_util_inspect_custom" id="util_util_inspect_custom">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -945,27 +1008,27 @@ util.inspect(obj);
 <p>In addition to being accessible through <code>util.inspect.custom</code>, this
 symbol is <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for">registered globally</a> and can be
 accessed in any environment as <code>Symbol.for('nodejs.util.inspect.custom')</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> inspect = <span class="hljs-built_in">Symbol</span>.for(<span class="hljs-string">'nodejs.util.inspect.custom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> inspect = <span class="hljs-title class_">Symbol</span>.<span class="hljs-title function_">for</span>(<span class="hljs-string">'nodejs.util.inspect.custom'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Password</span> </span>{
-  <span class="hljs-keyword">constructor</span>(value) {
-    <span class="hljs-built_in">this</span>.value = value;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Password</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params">value</span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">value</span> = value;
   }
 
-  toString() {
+  <span class="hljs-title function_">toString</span>(<span class="hljs-params"></span>) {
     <span class="hljs-keyword">return</span> <span class="hljs-string">'xxxxxxxx'</span>;
   }
 
   [inspect]() {
-    <span class="hljs-keyword">return</span> <span class="hljs-string">`Password &#x3C;<span class="hljs-subst">${<span class="hljs-built_in">this</span>.toString()}</span>>`</span>;
+    <span class="hljs-keyword">return</span> <span class="hljs-string">`Password &#x3C;<span class="hljs-subst">${<span class="hljs-variable language_">this</span>.toString()}</span>>`</span>;
   }
 }
 
-<span class="hljs-keyword">const</span> password = <span class="hljs-keyword">new</span> Password(<span class="hljs-string">'r0sebud'</span>);
-<span class="hljs-built_in">console</span>.log(password);
+<span class="hljs-keyword">const</span> password = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Password</span>(<span class="hljs-string">'r0sebud'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(password);
 <span class="hljs-comment">// Prints Password &#x3C;xxxxxxxx></span></code></pre>
 <p>See <a href="#util_custom_inspection_functions_on_objects">Custom inspection functions on Objects</a> for more details.</p>
-<h3><code>util.inspect.defaultOptions</code><span><a class="mark" href="#util_util_inspect_defaultoptions" id="util_util_inspect_defaultoptions">#</a></span></h3>
+<h4><code>util.inspect.defaultOptions</code><span><a class="mark" href="#util_util_inspect_defaultoptions" id="util_util_inspect_defaultoptions">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v6.4.0</span>
 </div>
@@ -975,12 +1038,12 @@ accessed in any environment as <code>Symbol.for('nodejs.util.inspect.custom')</c
 object containing one or more valid <a href="#util_util_inspect_object_options"><code>util.inspect()</code></a> options. Setting
 option properties directly is also supported.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> arr = <span class="hljs-built_in">Array</span>(<span class="hljs-number">101</span>).fill(<span class="hljs-number">0</span>);
+<span class="hljs-keyword">const</span> arr = <span class="hljs-title class_">Array</span>(<span class="hljs-number">101</span>).<span class="hljs-title function_">fill</span>(<span class="hljs-number">0</span>);
 
-<span class="hljs-built_in">console</span>.log(arr); <span class="hljs-comment">// Logs the truncated array</span>
-util.inspect.defaultOptions.maxArrayLength = <span class="hljs-literal">null</span>;
-<span class="hljs-built_in">console</span>.log(arr); <span class="hljs-comment">// logs the full array</span></code></pre>
-<h2><code>util.isDeepStrictEqual(val1, val2)</code><span><a class="mark" href="#util_util_isdeepstrictequal_val1_val2" id="util_util_isdeepstrictequal_val1_val2">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arr); <span class="hljs-comment">// Logs the truncated array</span>
+util.<span class="hljs-property">inspect</span>.<span class="hljs-property">defaultOptions</span>.<span class="hljs-property">maxArrayLength</span> = <span class="hljs-literal">null</span>;
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arr); <span class="hljs-comment">// logs the full array</span></code></pre>
+</section><section><h3><code>util.isDeepStrictEqual(val1, val2)</code><span><a class="mark" href="#util_util_isdeepstrictequal_val1_val2" id="util_util_isdeepstrictequal_val1_val2">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.0.0</span>
 </div>
@@ -993,7 +1056,7 @@ util.inspect.defaultOptions.maxArrayLength = <span class="hljs-literal">null</sp
 Otherwise, returns <code>false</code>.</p>
 <p>See <a href="assert.html#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> for more information about deep strict
 equality.</p>
-<h2><code>util.promisify(original)</code><span><a class="mark" href="#util_util_promisify_original" id="util_util_promisify_original">#</a></span></h2>
+</section><section><h3><code>util.promisify(original)</code><span><a class="mark" href="#util_util_promisify_original" id="util_util_promisify_original">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -1007,21 +1070,21 @@ that returns promises.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> stat = util.promisify(fs.stat);
-stat(<span class="hljs-string">'.'</span>).then(<span class="hljs-function">(<span class="hljs-params">stats</span>) =></span> {
+<span class="hljs-keyword">const</span> stat = util.<span class="hljs-title function_">promisify</span>(fs.<span class="hljs-property">stat</span>);
+<span class="hljs-title function_">stat</span>(<span class="hljs-string">'.'</span>).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">stats</span>) =></span> {
   <span class="hljs-comment">// Do something with `stats`</span>
-}).catch(<span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
+}).<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">error</span>) =></span> {
   <span class="hljs-comment">// Handle the error.</span>
 });</code></pre>
 <p>Or, equivalently using <code>async function</code>s:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> stat = util.promisify(fs.stat);
+<span class="hljs-keyword">const</span> stat = util.<span class="hljs-title function_">promisify</span>(fs.<span class="hljs-property">stat</span>);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">callStat</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> stat(<span class="hljs-string">'.'</span>);
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`This directory is owned by <span class="hljs-subst">${stats.uid}</span>`</span>);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">callStat</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> stats = <span class="hljs-keyword">await</span> <span class="hljs-title function_">stat</span>(<span class="hljs-string">'.'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`This directory is owned by <span class="hljs-subst">${stats.uid}</span>`</span>);
 }</code></pre>
 <p>If there is an <code>original[util.promisify.custom]</code> property present, <code>promisify</code>
 will return its value, see <a href="#util_custom_promisified_functions">Custom promisified functions</a>.</p>
@@ -1034,59 +1097,59 @@ callback as its last argument.</p>
 work as expected unless handled specially:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Foo</span> </span>{
-  <span class="hljs-keyword">constructor</span>() {
-    <span class="hljs-built_in">this</span>.a = <span class="hljs-number">42</span>;
+<span class="hljs-keyword">class</span> <span class="hljs-title class_">Foo</span> {
+  <span class="hljs-title function_">constructor</span>(<span class="hljs-params"></span>) {
+    <span class="hljs-variable language_">this</span>.<span class="hljs-property">a</span> = <span class="hljs-number">42</span>;
   }
 
-  bar(callback) {
-    callback(<span class="hljs-literal">null</span>, <span class="hljs-built_in">this</span>.a);
+  <span class="hljs-title function_">bar</span>(<span class="hljs-params">callback</span>) {
+    <span class="hljs-title function_">callback</span>(<span class="hljs-literal">null</span>, <span class="hljs-variable language_">this</span>.<span class="hljs-property">a</span>);
   }
 }
 
-<span class="hljs-keyword">const</span> foo = <span class="hljs-keyword">new</span> Foo();
+<span class="hljs-keyword">const</span> foo = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Foo</span>();
 
-<span class="hljs-keyword">const</span> naiveBar = util.promisify(foo.bar);
+<span class="hljs-keyword">const</span> naiveBar = util.<span class="hljs-title function_">promisify</span>(foo.<span class="hljs-property">bar</span>);
 <span class="hljs-comment">// TypeError: Cannot read property 'a' of undefined</span>
 <span class="hljs-comment">// naiveBar().then(a => console.log(a));</span>
 
-naiveBar.call(foo).then(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> <span class="hljs-built_in">console</span>.log(a)); <span class="hljs-comment">// '42'</span>
+naiveBar.<span class="hljs-title function_">call</span>(foo).<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(a)); <span class="hljs-comment">// '42'</span>
 
-<span class="hljs-keyword">const</span> bindBar = naiveBar.bind(foo);
-bindBar().then(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> <span class="hljs-built_in">console</span>.log(a)); <span class="hljs-comment">// '42'</span></code></pre>
-<h3>Custom promisified functions<span><a class="mark" href="#util_custom_promisified_functions" id="util_custom_promisified_functions">#</a></span></h3>
+<span class="hljs-keyword">const</span> bindBar = naiveBar.<span class="hljs-title function_">bind</span>(foo);
+<span class="hljs-title function_">bindBar</span>().<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">a</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(a)); <span class="hljs-comment">// '42'</span></code></pre>
+<h4>Custom promisified functions<span><a class="mark" href="#util_custom_promisified_functions" id="util_custom_promisified_functions">#</a></span></h4>
 <p>Using the <code>util.promisify.custom</code> symbol one can override the return value of
 <a href="#util_util_promisify_original"><code>util.promisify()</code></a>:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">doSomething</span>(<span class="hljs-params">foo, callback</span>) </span>{
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">doSomething</span>(<span class="hljs-params">foo, callback</span>) {
   <span class="hljs-comment">// ...</span>
 }
 
-doSomething[util.promisify.custom] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
-  <span class="hljs-keyword">return</span> getPromiseSomehow();
+doSomething[util.<span class="hljs-property">promisify</span>.<span class="hljs-property">custom</span>] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
+  <span class="hljs-keyword">return</span> <span class="hljs-title function_">getPromiseSomehow</span>();
 };
 
-<span class="hljs-keyword">const</span> promisified = util.promisify(doSomething);
-<span class="hljs-built_in">console</span>.log(promisified === doSomething[util.promisify.custom]);
+<span class="hljs-keyword">const</span> promisified = util.<span class="hljs-title function_">promisify</span>(doSomething);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(promisified === doSomething[util.<span class="hljs-property">promisify</span>.<span class="hljs-property">custom</span>]);
 <span class="hljs-comment">// prints 'true'</span></code></pre>
 <p>This can be useful for cases where the original function does not follow the
 standard format of taking an error-first callback as the last argument.</p>
 <p>For example, with a function that takes in
 <code>(foo, onSuccessCallback, onErrorCallback)</code>:</p>
-<pre><code class="language-js">doSomething[util.promisify.custom] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
-  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-    doSomething(foo, resolve, reject);
+<pre><code class="language-js">doSomething[util.<span class="hljs-property">promisify</span>.<span class="hljs-property">custom</span>] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
+  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+    <span class="hljs-title function_">doSomething</span>(foo, resolve, reject);
   });
 };</code></pre>
 <p>If <code>promisify.custom</code> is defined but is not a function, <code>promisify()</code> will
 throw an error.</p>
-<h3><code>util.promisify.custom</code><span><a class="mark" href="#util_util_promisify_custom" id="util_util_promisify_custom">#</a></span></h3>
+<h4><code>util.promisify.custom</code><span><a class="mark" href="#util_util_promisify_custom" id="util_util_promisify_custom">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.16.2</td>
+<tr><td>v13.12.0, v12.16.2</td>
 <td><p>This is now defined as a shared symbol.</p></td></tr>
 <tr><td>v8.0.0</td>
 <td><p><span>Added in: v8.0.0</span></p></td></tr>
@@ -1102,34 +1165,32 @@ symbol is <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refer
 accessed in any environment as <code>Symbol.for('nodejs.util.promisify.custom')</code>.</p>
 <p>For example, with a function that takes in
 <code>(foo, onSuccessCallback, onErrorCallback)</code>:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> kCustomPromisifiedSymbol = <span class="hljs-built_in">Symbol</span>.for(<span class="hljs-string">'nodejs.util.promisify.custom'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> kCustomPromisifiedSymbol = <span class="hljs-title class_">Symbol</span>.<span class="hljs-title function_">for</span>(<span class="hljs-string">'nodejs.util.promisify.custom'</span>);
 
 doSomething[kCustomPromisifiedSymbol] = <span class="hljs-function">(<span class="hljs-params">foo</span>) =></span> {
-  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-    doSomething(foo, resolve, reject);
+  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+    <span class="hljs-title function_">doSomething</span>(foo, resolve, reject);
   });
 };</code></pre>
-<h2>Class: <code>util.TextDecoder</code><span><a class="mark" href="#util_class_util_textdecoder" id="util_class_util_textdecoder">#</a></span></h2>
+</section><section><h3>Class: <code>util.TextDecoder</code><span><a class="mark" href="#util_class_util_textdecoder" id="util_class_util_textdecoder">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.3.0</span>
 </div>
 <p>An implementation of the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a> <code>TextDecoder</code> API.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> TextDecoder(<span class="hljs-string">'shift_jis'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> decoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">TextDecoder</span>(<span class="hljs-string">'shift_jis'</span>);
 <span class="hljs-keyword">let</span> string = <span class="hljs-string">''</span>;
 <span class="hljs-keyword">let</span> buffer;
-<span class="hljs-keyword">while</span> (buffer = getNextChunkSomehow()) {
-  string += decoder.decode(buffer, { <span class="hljs-attr">stream</span>: <span class="hljs-literal">true</span> });
+<span class="hljs-keyword">while</span> (buffer = <span class="hljs-title function_">getNextChunkSomehow</span>()) {
+  string += decoder.<span class="hljs-title function_">decode</span>(buffer, { <span class="hljs-attr">stream</span>: <span class="hljs-literal">true</span> });
 }
-string += decoder.decode(); <span class="hljs-comment">// end-of-stream</span></code></pre>
-<h3>WHATWG supported encodings<span><a class="mark" href="#util_whatwg_supported_encodings" id="util_whatwg_supported_encodings">#</a></span></h3>
+string += decoder.<span class="hljs-title function_">decode</span>(); <span class="hljs-comment">// end-of-stream</span></code></pre>
+<h4>WHATWG supported encodings<span><a class="mark" href="#util_whatwg_supported_encodings" id="util_whatwg_supported_encodings">#</a></span></h4>
 <p>Per the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a>, the encodings supported by the
 <code>TextDecoder</code> API are outlined in the tables below. For each encoding,
 one or more aliases may be used.</p>
 <p>Different Node.js build configurations support different sets of encodings.
-While a very basic set of encodings is supported even on Node.js builds without
-ICU enabled, support for some encodings is provided only when Node.js is built
-with ICU and using the full ICU data (see <a href="intl.html">Internationalization</a>).</p>
-<h4>Encodings Supported Without ICU<span><a class="mark" href="#util_encodings_supported_without_icu" id="util_encodings_supported_without_icu">#</a></span></h4>
+(see <a href="intl.html">Internationalization</a>)</p>
+<h5>Encodings supported by default (with full ICU data)<span><a class="mark" href="#util_encodings_supported_by_default_with_full_icu_data" id="util_encodings_supported_by_default_with_full_icu_data">#</a></span></h5>
 
 
 
@@ -1147,8 +1208,6 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
-<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'utf-8'</code></td><td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td></tr><tr><td><code>'utf-16le'</code></td><td><code>'utf-16'</code></td></tr></tbody></table>
-<h4>Encodings Supported by Default (With ICU)<span><a class="mark" href="#util_encodings_supported_by_default_with_icu" id="util_encodings_supported_by_default_with_icu">#</a></span></h4>
 
 
 
@@ -1170,8 +1229,6 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
-<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'utf-8'</code></td><td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td></tr><tr><td><code>'utf-16le'</code></td><td><code>'utf-16'</code></td></tr><tr><td><code>'utf-16be'</code></td><td></td></tr></tbody></table>
-<h4>Encodings requiring full ICU data<span><a class="mark" href="#util_encodings_requiring_full_icu_data" id="util_encodings_requiring_full_icu_data">#</a></span></h4>
 
 
 
@@ -1279,6 +1336,8 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
+<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'ibm866'</code></td><td><code>'866'</code>, <code>'cp866'</code>, <code>'csibm866'</code></td></tr><tr><td><code>'iso-8859-2'</code></td><td><code>'csisolatin2'</code>, <code>'iso-ir-101'</code>, <code>'iso8859-2'</code>, <code>'iso88592'</code>, <code>'iso_8859-2'</code>, <code>'iso_8859-2:1987'</code>, <code>'l2'</code>, <code>'latin2'</code></td></tr><tr><td><code>'iso-8859-3'</code></td><td><code>'csisolatin3'</code>, <code>'iso-ir-109'</code>, <code>'iso8859-3'</code>, <code>'iso88593'</code>, <code>'iso_8859-3'</code>, <code>'iso_8859-3:1988'</code>, <code>'l3'</code>, <code>'latin3'</code></td></tr><tr><td><code>'iso-8859-4'</code></td><td><code>'csisolatin4'</code>, <code>'iso-ir-110'</code>, <code>'iso8859-4'</code>, <code>'iso88594'</code>, <code>'iso_8859-4'</code>, <code>'iso_8859-4:1988'</code>, <code>'l4'</code>, <code>'latin4'</code></td></tr><tr><td><code>'iso-8859-5'</code></td><td><code>'csisolatincyrillic'</code>, <code>'cyrillic'</code>, <code>'iso-ir-144'</code>, <code>'iso8859-5'</code>, <code>'iso88595'</code>, <code>'iso_8859-5'</code>, <code>'iso_8859-5:1988'</code></td></tr><tr><td><code>'iso-8859-6'</code></td><td><code>'arabic'</code>, <code>'asmo-708'</code>, <code>'csiso88596e'</code>, <code>'csiso88596i'</code>, <code>'csisolatinarabic'</code>, <code>'ecma-114'</code>, <code>'iso-8859-6-e'</code>, <code>'iso-8859-6-i'</code>, <code>'iso-ir-127'</code>, <code>'iso8859-6'</code>, <code>'iso88596'</code>, <code>'iso_8859-6'</code>, <code>'iso_8859-6:1987'</code></td></tr><tr><td><code>'iso-8859-7'</code></td><td><code>'csisolatingreek'</code>, <code>'ecma-118'</code>, <code>'elot_928'</code>, <code>'greek'</code>, <code>'greek8'</code>, <code>'iso-ir-126'</code>, <code>'iso8859-7'</code>, <code>'iso88597'</code>, <code>'iso_8859-7'</code>, <code>'iso_8859-7:1987'</code>, <code>'sun_eu_greek'</code></td></tr><tr><td><code>'iso-8859-8'</code></td><td><code>'csiso88598e'</code>, <code>'csisolatinhebrew'</code>, <code>'hebrew'</code>, <code>'iso-8859-8-e'</code>, <code>'iso-ir-138'</code>, <code>'iso8859-8'</code>, <code>'iso88598'</code>, <code>'iso_8859-8'</code>, <code>'iso_8859-8:1988'</code>, <code>'visual'</code></td></tr><tr><td><code>'iso-8859-8-i'</code></td><td><code>'csiso88598i'</code>, <code>'logical'</code></td></tr><tr><td><code>'iso-8859-10'</code></td><td><code>'csisolatin6'</code>, <code>'iso-ir-157'</code>, <code>'iso8859-10'</code>, <code>'iso885910'</code>, <code>'l6'</code>, <code>'latin6'</code></td></tr><tr><td><code>'iso-8859-13'</code></td><td><code>'iso8859-13'</code>, <code>'iso885913'</code></td></tr><tr><td><code>'iso-8859-14'</code></td><td><code>'iso8859-14'</code>, <code>'iso885914'</code></td></tr><tr><td><code>'iso-8859-15'</code></td><td><code>'csisolatin9'</code>, <code>'iso8859-15'</code>, <code>'iso885915'</code>, <code>'iso_8859-15'</code>, <code>'l9'</code></td></tr><tr><td><code>'koi8-r'</code></td><td><code>'cskoi8r'</code>, <code>'koi'</code>, <code>'koi8'</code>, <code>'koi8_r'</code></td></tr><tr><td><code>'koi8-u'</code></td><td><code>'koi8-ru'</code></td></tr><tr><td><code>'macintosh'</code></td><td><code>'csmacintosh'</code>, <code>'mac'</code>, <code>'x-mac-roman'</code></td></tr><tr><td><code>'windows-874'</code></td><td><code>'dos-874'</code>, <code>'iso-8859-11'</code>, <code>'iso8859-11'</code>, <code>'iso885911'</code>, <code>'tis-620'</code></td></tr><tr><td><code>'windows-1250'</code></td><td><code>'cp1250'</code>, <code>'x-cp1250'</code></td></tr><tr><td><code>'windows-1251'</code></td><td><code>'cp1251'</code>, <code>'x-cp1251'</code></td></tr><tr><td><code>'windows-1252'</code></td><td><code>'ansi_x3.4-1968'</code>, <code>'ascii'</code>, <code>'cp1252'</code>, <code>'cp819'</code>, <code>'csisolatin1'</code>, <code>'ibm819'</code>, <code>'iso-8859-1'</code>, <code>'iso-ir-100'</code>, <code>'iso8859-1'</code>, <code>'iso88591'</code>, <code>'iso_8859-1'</code>, <code>'iso_8859-1:1987'</code>, <code>'l1'</code>, <code>'latin1'</code>, <code>'us-ascii'</code>, <code>'x-cp1252'</code></td></tr><tr><td><code>'windows-1253'</code></td><td><code>'cp1253'</code>, <code>'x-cp1253'</code></td></tr><tr><td><code>'windows-1254'</code></td><td><code>'cp1254'</code>, <code>'csisolatin5'</code>, <code>'iso-8859-9'</code>, <code>'iso-ir-148'</code>, <code>'iso8859-9'</code>, <code>'iso88599'</code>, <code>'iso_8859-9'</code>, <code>'iso_8859-9:1989'</code>, <code>'l5'</code>, <code>'latin5'</code>, <code>'x-cp1254'</code></td></tr><tr><td><code>'windows-1255'</code></td><td><code>'cp1255'</code>, <code>'x-cp1255'</code></td></tr><tr><td><code>'windows-1256'</code></td><td><code>'cp1256'</code>, <code>'x-cp1256'</code></td></tr><tr><td><code>'windows-1257'</code></td><td><code>'cp1257'</code>, <code>'x-cp1257'</code></td></tr><tr><td><code>'windows-1258'</code></td><td><code>'cp1258'</code>, <code>'x-cp1258'</code></td></tr><tr><td><code>'x-mac-cyrillic'</code></td><td><code>'x-mac-ukrainian'</code></td></tr><tr><td><code>'gbk'</code></td><td><code>'chinese'</code>, <code>'csgb2312'</code>, <code>'csiso58gb231280'</code>, <code>'gb2312'</code>, <code>'gb_2312'</code>, <code>'gb_2312-80'</code>, <code>'iso-ir-58'</code>, <code>'x-gbk'</code></td></tr><tr><td><code>'gb18030'</code></td><td></td></tr><tr><td><code>'big5'</code></td><td><code>'big5-hkscs'</code>, <code>'cn-big5'</code>, <code>'csbig5'</code>, <code>'x-x-big5'</code></td></tr><tr><td><code>'euc-jp'</code></td><td><code>'cseucpkdfmtjapanese'</code>, <code>'x-euc-jp'</code></td></tr><tr><td><code>'iso-2022-jp'</code></td><td><code>'csiso2022jp'</code></td></tr><tr><td><code>'shift_jis'</code></td><td><code>'csshiftjis'</code>, <code>'ms932'</code>, <code>'ms_kanji'</code>, <code>'shift-jis'</code>, <code>'sjis'</code>, <code>'windows-31j'</code>, <code>'x-sjis'</code></td></tr><tr><td><code>'euc-kr'</code></td><td><code>'cseuckr'</code>, <code>'csksc56011987'</code>, <code>'iso-ir-149'</code>, <code>'korean'</code>, <code>'ks_c_5601-1987'</code>, <code>'ks_c_5601-1989'</code>, <code>'ksc5601'</code>, <code>'ksc_5601'</code>, <code>'windows-949'</code></td></tr></tbody></table>
+<h5>Encodings supported when Node.js is built with the <code>small-icu</code> option<span><a class="mark" href="#util_encodings_supported_when_node_js_is_built_with_the_small_icu_option" id="util_encodings_supported_when_node_js_is_built_with_the_small_icu_option">#</a></span></h5>
 
 
 
@@ -1300,6 +1359,8 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
+<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'utf-8'</code></td><td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td></tr><tr><td><code>'utf-16le'</code></td><td><code>'utf-16'</code></td></tr><tr><td><code>'utf-16be'</code></td><td></td></tr></tbody></table>
+<h5>Encodings supported when ICU is disabled<span><a class="mark" href="#util_encodings_supported_when_icu_is_disabled" id="util_encodings_supported_when_icu_is_disabled">#</a></span></h5>
 
 
 
@@ -1317,10 +1378,10 @@ with ICU and using the full ICU data (see <a href="intl.html">Internationalizati
 
 
 
-<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'ibm866'</code></td><td><code>'866'</code>, <code>'cp866'</code>, <code>'csibm866'</code></td></tr><tr><td><code>'iso-8859-2'</code></td><td><code>'csisolatin2'</code>, <code>'iso-ir-101'</code>, <code>'iso8859-2'</code>, <code>'iso88592'</code>, <code>'iso_8859-2'</code>, <code>'iso_8859-2:1987'</code>, <code>'l2'</code>, <code>'latin2'</code></td></tr><tr><td><code>'iso-8859-3'</code></td><td><code>'csisolatin3'</code>, <code>'iso-ir-109'</code>, <code>'iso8859-3'</code>, <code>'iso88593'</code>, <code>'iso_8859-3'</code>, <code>'iso_8859-3:1988'</code>, <code>'l3'</code>, <code>'latin3'</code></td></tr><tr><td><code>'iso-8859-4'</code></td><td><code>'csisolatin4'</code>, <code>'iso-ir-110'</code>, <code>'iso8859-4'</code>, <code>'iso88594'</code>, <code>'iso_8859-4'</code>, <code>'iso_8859-4:1988'</code>, <code>'l4'</code>, <code>'latin4'</code></td></tr><tr><td><code>'iso-8859-5'</code></td><td><code>'csisolatincyrillic'</code>, <code>'cyrillic'</code>, <code>'iso-ir-144'</code>, <code>'iso8859-5'</code>, <code>'iso88595'</code>, <code>'iso_8859-5'</code>, <code>'iso_8859-5:1988'</code></td></tr><tr><td><code>'iso-8859-6'</code></td><td><code>'arabic'</code>, <code>'asmo-708'</code>, <code>'csiso88596e'</code>, <code>'csiso88596i'</code>, <code>'csisolatinarabic'</code>, <code>'ecma-114'</code>, <code>'iso-8859-6-e'</code>, <code>'iso-8859-6-i'</code>, <code>'iso-ir-127'</code>, <code>'iso8859-6'</code>, <code>'iso88596'</code>, <code>'iso_8859-6'</code>, <code>'iso_8859-6:1987'</code></td></tr><tr><td><code>'iso-8859-7'</code></td><td><code>'csisolatingreek'</code>, <code>'ecma-118'</code>, <code>'elot_928'</code>, <code>'greek'</code>, <code>'greek8'</code>, <code>'iso-ir-126'</code>, <code>'iso8859-7'</code>, <code>'iso88597'</code>, <code>'iso_8859-7'</code>, <code>'iso_8859-7:1987'</code>, <code>'sun_eu_greek'</code></td></tr><tr><td><code>'iso-8859-8'</code></td><td><code>'csiso88598e'</code>, <code>'csisolatinhebrew'</code>, <code>'hebrew'</code>, <code>'iso-8859-8-e'</code>, <code>'iso-ir-138'</code>, <code>'iso8859-8'</code>, <code>'iso88598'</code>, <code>'iso_8859-8'</code>, <code>'iso_8859-8:1988'</code>, <code>'visual'</code></td></tr><tr><td><code>'iso-8859-8-i'</code></td><td><code>'csiso88598i'</code>, <code>'logical'</code></td></tr><tr><td><code>'iso-8859-10'</code></td><td><code>'csisolatin6'</code>, <code>'iso-ir-157'</code>, <code>'iso8859-10'</code>, <code>'iso885910'</code>, <code>'l6'</code>, <code>'latin6'</code></td></tr><tr><td><code>'iso-8859-13'</code></td><td><code>'iso8859-13'</code>, <code>'iso885913'</code></td></tr><tr><td><code>'iso-8859-14'</code></td><td><code>'iso8859-14'</code>, <code>'iso885914'</code></td></tr><tr><td><code>'iso-8859-15'</code></td><td><code>'csisolatin9'</code>, <code>'iso8859-15'</code>, <code>'iso885915'</code>, <code>'iso_8859-15'</code>, <code>'l9'</code></td></tr><tr><td><code>'koi8-r'</code></td><td><code>'cskoi8r'</code>, <code>'koi'</code>, <code>'koi8'</code>, <code>'koi8_r'</code></td></tr><tr><td><code>'koi8-u'</code></td><td><code>'koi8-ru'</code></td></tr><tr><td><code>'macintosh'</code></td><td><code>'csmacintosh'</code>, <code>'mac'</code>, <code>'x-mac-roman'</code></td></tr><tr><td><code>'windows-874'</code></td><td><code>'dos-874'</code>, <code>'iso-8859-11'</code>, <code>'iso8859-11'</code>, <code>'iso885911'</code>, <code>'tis-620'</code></td></tr><tr><td><code>'windows-1250'</code></td><td><code>'cp1250'</code>, <code>'x-cp1250'</code></td></tr><tr><td><code>'windows-1251'</code></td><td><code>'cp1251'</code>, <code>'x-cp1251'</code></td></tr><tr><td><code>'windows-1252'</code></td><td><code>'ansi_x3.4-1968'</code>, <code>'ascii'</code>, <code>'cp1252'</code>, <code>'cp819'</code>, <code>'csisolatin1'</code>, <code>'ibm819'</code>, <code>'iso-8859-1'</code>, <code>'iso-ir-100'</code>, <code>'iso8859-1'</code>, <code>'iso88591'</code>, <code>'iso_8859-1'</code>, <code>'iso_8859-1:1987'</code>, <code>'l1'</code>, <code>'latin1'</code>, <code>'us-ascii'</code>, <code>'x-cp1252'</code></td></tr><tr><td><code>'windows-1253'</code></td><td><code>'cp1253'</code>, <code>'x-cp1253'</code></td></tr><tr><td><code>'windows-1254'</code></td><td><code>'cp1254'</code>, <code>'csisolatin5'</code>, <code>'iso-8859-9'</code>, <code>'iso-ir-148'</code>, <code>'iso8859-9'</code>, <code>'iso88599'</code>, <code>'iso_8859-9'</code>, <code>'iso_8859-9:1989'</code>, <code>'l5'</code>, <code>'latin5'</code>, <code>'x-cp1254'</code></td></tr><tr><td><code>'windows-1255'</code></td><td><code>'cp1255'</code>, <code>'x-cp1255'</code></td></tr><tr><td><code>'windows-1256'</code></td><td><code>'cp1256'</code>, <code>'x-cp1256'</code></td></tr><tr><td><code>'windows-1257'</code></td><td><code>'cp1257'</code>, <code>'x-cp1257'</code></td></tr><tr><td><code>'windows-1258'</code></td><td><code>'cp1258'</code>, <code>'x-cp1258'</code></td></tr><tr><td><code>'x-mac-cyrillic'</code></td><td><code>'x-mac-ukrainian'</code></td></tr><tr><td><code>'gbk'</code></td><td><code>'chinese'</code>, <code>'csgb2312'</code>, <code>'csiso58gb231280'</code>, <code>'gb2312'</code>, <code>'gb_2312'</code>, <code>'gb_2312-80'</code>, <code>'iso-ir-58'</code>, <code>'x-gbk'</code></td></tr><tr><td><code>'gb18030'</code></td><td></td></tr><tr><td><code>'big5'</code></td><td><code>'big5-hkscs'</code>, <code>'cn-big5'</code>, <code>'csbig5'</code>, <code>'x-x-big5'</code></td></tr><tr><td><code>'euc-jp'</code></td><td><code>'cseucpkdfmtjapanese'</code>, <code>'x-euc-jp'</code></td></tr><tr><td><code>'iso-2022-jp'</code></td><td><code>'csiso2022jp'</code></td></tr><tr><td><code>'shift_jis'</code></td><td><code>'csshiftjis'</code>, <code>'ms932'</code>, <code>'ms_kanji'</code>, <code>'shift-jis'</code>, <code>'sjis'</code>, <code>'windows-31j'</code>, <code>'x-sjis'</code></td></tr><tr><td><code>'euc-kr'</code></td><td><code>'cseuckr'</code>, <code>'csksc56011987'</code>, <code>'iso-ir-149'</code>, <code>'korean'</code>, <code>'ks_c_5601-1987'</code>, <code>'ks_c_5601-1989'</code>, <code>'ksc5601'</code>, <code>'ksc_5601'</code>, <code>'windows-949'</code></td></tr></tbody></table>
+<table><thead><tr><th>Encoding</th><th>Aliases</th></tr></thead><tbody><tr><td><code>'utf-8'</code></td><td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td></tr><tr><td><code>'utf-16le'</code></td><td><code>'utf-16'</code></td></tr></tbody></table>
 <p>The <code>'iso-8859-16'</code> encoding listed in the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a>
 is not supported.</p>
-<h3><code>new TextDecoder([encoding[, options]])</code><span><a class="mark" href="#util_new_textdecoder_encoding_options" id="util_new_textdecoder_encoding_options">#</a></span></h3>
+<h4><code>new TextDecoder([encoding[, options]])</code><span><a class="mark" href="#util_new_textdecoder_encoding_options" id="util_new_textdecoder_encoding_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1337,9 +1398,9 @@ is not supported.</p>
 supports. <strong>Default:</strong> <code>'utf-8'</code>.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
-<li><code>fatal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if decoding failures are fatal. This option is only
-supported when ICU is enabled (see <a href="intl.html">Internationalization</a>). <strong>Default:</strong>
-<code>false</code>.</li>
+<li><code>fatal</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <code>true</code> if decoding failures are fatal.
+This option is not supported when ICU is disabled
+(see <a href="intl.html">Internationalization</a>). <strong>Default:</strong> <code>false</code>.</li>
 <li><code>ignoreBOM</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, the <code>TextDecoder</code> will include the byte
 order mark in the decoded result. When <code>false</code>, the byte order mark will
 be removed from the output. This option is only used when <code>encoding</code> is
@@ -1350,7 +1411,7 @@ be removed from the output. This option is only used when <code>encoding</code>
 <p>Creates an new <code>TextDecoder</code> instance. The <code>encoding</code> may specify one of the
 supported encodings or an alias.</p>
 <p>The <code>TextDecoder</code> class is also available on the global object.</p>
-<h3><code>textDecoder.decode([input[, options]])</code><span><a class="mark" href="#util_textdecoder_decode_input_options" id="util_textdecoder_decode_input_options">#</a></span></h3>
+<h4><code>textDecoder.decode([input[, options]])</code><span><a class="mark" href="#util_textdecoder_decode_input_options" id="util_textdecoder_decode_input_options">#</a></span></h4>
 <ul>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> An <code>ArrayBuffer</code>, <code>DataView</code> or
 <code>TypedArray</code> instance containing the encoded data.</li>
@@ -1367,24 +1428,24 @@ incomplete byte sequences occurring at the end of the <code>input</code> are buf
 internally and emitted after the next call to <code>textDecoder.decode()</code>.</p>
 <p>If <code>textDecoder.fatal</code> is <code>true</code>, decoding errors that occur will result in a
 <code>TypeError</code> being thrown.</p>
-<h3><code>textDecoder.encoding</code><span><a class="mark" href="#util_textdecoder_encoding" id="util_textdecoder_encoding">#</a></span></h3>
+<h4><code>textDecoder.encoding</code><span><a class="mark" href="#util_textdecoder_encoding" id="util_textdecoder_encoding">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The encoding supported by the <code>TextDecoder</code> instance.</p>
-<h3><code>textDecoder.fatal</code><span><a class="mark" href="#util_textdecoder_fatal" id="util_textdecoder_fatal">#</a></span></h3>
+<h4><code>textDecoder.fatal</code><span><a class="mark" href="#util_textdecoder_fatal" id="util_textdecoder_fatal">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>The value will be <code>true</code> if decoding errors result in a <code>TypeError</code> being
 thrown.</p>
-<h3><code>textDecoder.ignoreBOM</code><span><a class="mark" href="#util_textdecoder_ignorebom" id="util_textdecoder_ignorebom">#</a></span></h3>
+<h4><code>textDecoder.ignoreBOM</code><span><a class="mark" href="#util_textdecoder_ignorebom" id="util_textdecoder_ignorebom">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>The value will be <code>true</code> if the decoding result will include the byte order
 mark.</p>
-<h2>Class: <code>util.TextEncoder</code><span><a class="mark" href="#util_class_util_textencoder" id="util_class_util_textencoder">#</a></span></h2>
+</section><section><h3>Class: <code>util.TextEncoder</code><span><a class="mark" href="#util_class_util_textencoder" id="util_class_util_textencoder">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1398,17 +1459,17 @@ mark.</p>
 </div>
 <p>An implementation of the <a href="https://encoding.spec.whatwg.org/">WHATWG Encoding Standard</a> <code>TextEncoder</code> API. All
 instances of <code>TextEncoder</code> only support UTF-8 encoding.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> encoder = <span class="hljs-keyword">new</span> TextEncoder();
-<span class="hljs-keyword">const</span> uint8array = encoder.encode(<span class="hljs-string">'this is some data'</span>);</code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> encoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">TextEncoder</span>();
+<span class="hljs-keyword">const</span> uint8array = encoder.<span class="hljs-title function_">encode</span>(<span class="hljs-string">'this is some data'</span>);</code></pre>
 <p>The <code>TextEncoder</code> class is also available on the global object.</p>
-<h3><code>textEncoder.encode([input])</code><span><a class="mark" href="#util_textencoder_encode_input" id="util_textencoder_encode_input">#</a></span></h3>
+<h4><code>textEncoder.encode([input])</code><span><a class="mark" href="#util_textencoder_encode_input" id="util_textencoder_encode_input">#</a></span></h4>
 <ul>
 <li><code>input</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The text to encode. <strong>Default:</strong> an empty string.</li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a></li>
 </ul>
 <p>UTF-8 encodes the <code>input</code> string and returns a <code>Uint8Array</code> containing the
 encoded bytes.</p>
-<h3><code>textEncoder.encodeInto(src, dest)</code><span><a class="mark" href="#util_textencoder_encodeinto_src_dest" id="util_textencoder_encodeinto_src_dest">#</a></span></h3>
+<h4><code>textEncoder.encodeInto(src, dest)</code><span><a class="mark" href="#util_textencoder_encodeinto_src_dest" id="util_textencoder_encodeinto_src_dest">#</a></span></h4>
 <ul>
 <li><code>src</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The text to encode.</li>
 <li><code>dest</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&#x3C;Uint8Array></a> The array to hold the encode result.</li>
@@ -1421,16 +1482,26 @@ encoded bytes.</p>
 </ul>
 <p>UTF-8 encodes the <code>src</code> string to the <code>dest</code> Uint8Array and returns an object
 containing the read Unicode code units and written UTF-8 bytes.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> encoder = <span class="hljs-keyword">new</span> TextEncoder();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> encoder = <span class="hljs-keyword">new</span> <span class="hljs-title class_">TextEncoder</span>();
 <span class="hljs-keyword">const</span> src = <span class="hljs-string">'this is some data'</span>;
-<span class="hljs-keyword">const</span> dest = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(<span class="hljs-number">10</span>);
-<span class="hljs-keyword">const</span> { read, written } = encoder.encodeInto(src, dest);</code></pre>
-<h3><code>textEncoder.encoding</code><span><a class="mark" href="#util_textencoder_encoding" id="util_textencoder_encoding">#</a></span></h3>
+<span class="hljs-keyword">const</span> dest = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-number">10</span>);
+<span class="hljs-keyword">const</span> { read, written } = encoder.<span class="hljs-title function_">encodeInto</span>(src, dest);</code></pre>
+<h4><code>textEncoder.encoding</code><span><a class="mark" href="#util_textencoder_encoding" id="util_textencoder_encoding">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The encoding supported by the <code>TextEncoder</code> instance. Always set to <code>'utf-8'</code>.</p>
-<h2><code>util.types</code><span><a class="mark" href="#util_util_types" id="util_util_types">#</a></span></h2>
+</section><section><h3><code>util.toUSVString(string)</code><span><a class="mark" href="#util_util_tousvstring_string" id="util_util_tousvstring_string">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<ul>
+<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>Returns the <code>string</code> after replacing any surrogate code points
+(or equivalently, any unpaired surrogate code units) with the
+Unicode "replacement character" U+FFFD.</p>
+</section><section><h3><code>util.types</code><span><a class="mark" href="#util_util_types" id="util_util_types">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1441,7 +1512,7 @@ their prototype), and usually have the overhead of calling into C++.</p>
 <p>The result generally does not make any guarantees about what kinds of
 properties or behavior a value exposes in JavaScript. They are primarily
 useful for addon developers who prefer to do type checking in JavaScript.</p>
-<h3><code>util.types.isAnyArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_isanyarraybuffer_value" id="util_util_types_isanyarraybuffer_value">#</a></span></h3>
+<h4><code>util.types.isAnyArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_isanyarraybuffer_value" id="util_util_types_isanyarraybuffer_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1453,9 +1524,9 @@ useful for addon developers who prefer to do type checking in JavaScript.</p>
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> instance.</p>
 <p>See also <a href="#util_util_types_isarraybuffer_value"><code>util.types.isArrayBuffer()</code></a> and
 <a href="#util_util_types_issharedarraybuffer_value"><code>util.types.isSharedArrayBuffer()</code></a>.</p>
-<pre><code class="language-js">util.types.isAnyArrayBuffer(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isAnyArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuffer());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isArrayBufferView(value)</code><span><a class="mark" href="#util_util_types_isarraybufferview_value" id="util_util_types_isarraybufferview_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isAnyArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isAnyArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">SharedArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isArrayBufferView(value)</code><span><a class="mark" href="#util_util_types_isarraybufferview_value" id="util_util_types_isarraybufferview_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1466,11 +1537,11 @@ util.types.isAnyArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuf
 <p>Returns <code>true</code> if the value is an instance of one of the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>
 views, such as typed array objects or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a>. Equivalent to
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView"><code>ArrayBuffer.isView()</code></a>.</p>
-<pre><code class="language-js">util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int8Array</span>());  <span class="hljs-comment">// true</span>
-util.types.isArrayBufferView(Buffer.from(<span class="hljs-string">'hello world'</span>)); <span class="hljs-comment">// true</span>
-util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">16</span>)));  <span class="hljs-comment">// true</span>
-util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// false</span></code></pre>
-<h3><code>util.types.isArgumentsObject(value)</code><span><a class="mark" href="#util_util_types_isargumentsobject_value" id="util_util_types_isargumentsobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBufferView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBufferView</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'hello world'</span>)); <span class="hljs-comment">// true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBufferView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">16</span>)));  <span class="hljs-comment">// true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBufferView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// false</span></code></pre>
+<h4><code>util.types.isArgumentsObject(value)</code><span><a class="mark" href="#util_util_types_isargumentsobject_value" id="util_util_types_isargumentsobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1480,10 +1551,10 @@ util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="
 </ul>
 <p>Returns <code>true</code> if the value is an <code>arguments</code> object.</p>
 <!-- eslint-disable prefer-rest-params -->
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{
-  util.types.isArgumentsObject(<span class="hljs-built_in">arguments</span>);  <span class="hljs-comment">// Returns true</span>
+<pre><code class="language-js"><span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {
+  util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArgumentsObject</span>(<span class="hljs-variable language_">arguments</span>);  <span class="hljs-comment">// Returns true</span>
 }</code></pre>
-<h3><code>util.types.isArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_isarraybuffer_value" id="util_util_types_isarraybuffer_value">#</a></span></h3>
+<h4><code>util.types.isArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_isarraybuffer_value" id="util_util_types_isarraybuffer_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1494,9 +1565,9 @@ util.types.isArrayBufferView(<span class="hljs-keyword">new</span> <span class="
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> instance.
 This does <em>not</em> include <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> instances. Usually, it is
 desirable to test for both; See <a href="#util_util_types_isanyarraybuffer_value"><code>util.types.isAnyArrayBuffer()</code></a> for that.</p>
-<pre><code class="language-js">util.types.isArrayBuffer(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuffer());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isAsyncFunction(value)</code><span><a class="mark" href="#util_util_types_isasyncfunction_value" id="util_util_types_isasyncfunction_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">SharedArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isAsyncFunction(value)</code><span><a class="mark" href="#util_util_types_isasyncfunction_value" id="util_util_types_isasyncfunction_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1508,9 +1579,9 @@ util.types.isArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuffer
 This only reports back what the JavaScript engine is seeing;
 in particular, the return value may not match the original source code if
 a transpilation tool was used.</p>
-<pre><code class="language-js">util.types.isAsyncFunction(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{});  <span class="hljs-comment">// Returns false</span>
-util.types.isAsyncFunction(<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{});  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isBigInt64Array(value)</code><span><a class="mark" href="#util_util_types_isbigint64array_value" id="util_util_types_isbigint64array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isAsyncFunction</span>(<span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {});  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isAsyncFunction</span>(<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {});  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isBigInt64Array(value)</code><span><a class="mark" href="#util_util_types_isbigint64array_value" id="util_util_types_isbigint64array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1519,9 +1590,9 @@ util.types.isAsyncFunction(<span class="hljs-keyword">async</span> <span class="
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a <code>BigInt64Array</code> instance.</p>
-<pre><code class="language-js">util.types.isBigInt64Array(<span class="hljs-keyword">new</span> BigInt64Array());   <span class="hljs-comment">// Returns true</span>
-util.types.isBigInt64Array(<span class="hljs-keyword">new</span> BigUint64Array());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isBigUint64Array(value)</code><span><a class="mark" href="#util_util_types_isbiguint64array_value" id="util_util_types_isbiguint64array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBigInt64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">BigInt</span>64<span class="hljs-built_in">Array</span>());   <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBigInt64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">BigUint</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isBigUint64Array(value)</code><span><a class="mark" href="#util_util_types_isbiguint64array_value" id="util_util_types_isbiguint64array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1530,9 +1601,9 @@ util.types.isBigInt64Array(<span class="hljs-keyword">new</span> BigUint64Array(
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a <code>BigUint64Array</code> instance.</p>
-<pre><code class="language-js">util.types.isBigUint64Array(<span class="hljs-keyword">new</span> BigInt64Array());   <span class="hljs-comment">// Returns false</span>
-util.types.isBigUint64Array(<span class="hljs-keyword">new</span> BigUint64Array());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isBooleanObject(value)</code><span><a class="mark" href="#util_util_types_isbooleanobject_value" id="util_util_types_isbooleanobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBigUint64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">BigInt</span>64<span class="hljs-built_in">Array</span>());   <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBigUint64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">BigUint</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isBooleanObject(value)</code><span><a class="mark" href="#util_util_types_isbooleanobject_value" id="util_util_types_isbooleanobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1542,13 +1613,13 @@ util.types.isBigUint64Array(<span class="hljs-keyword">new</span> BigUint64Array
 </ul>
 <p>Returns <code>true</code> if the value is a boolean object, e.g. created
 by <code>new Boolean()</code>.</p>
-<pre><code class="language-js">util.types.isBooleanObject(<span class="hljs-literal">false</span>);  <span class="hljs-comment">// Returns false</span>
-util.types.isBooleanObject(<span class="hljs-literal">true</span>);   <span class="hljs-comment">// Returns false</span>
-util.types.isBooleanObject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns true</span>
-util.types.isBooleanObject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">true</span>));  <span class="hljs-comment">// Returns true</span>
-util.types.isBooleanObject(<span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns false</span>
-util.types.isBooleanObject(<span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">true</span>));  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isBoxedPrimitive(value)</code><span><a class="mark" href="#util_util_types_isboxedprimitive_value" id="util_util_types_isboxedprimitive_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-literal">false</span>);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-literal">true</span>);   <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">true</span>));  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBooleanObject</span>(<span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">true</span>));  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isBoxedPrimitive(value)</code><span><a class="mark" href="#util_util_types_isboxedprimitive_value" id="util_util_types_isboxedprimitive_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.11.0</span>
 </div>
@@ -1559,12 +1630,12 @@ util.types.isBooleanObject(<span class="hljs-built_in">Boolean</span>(<span clas
 <p>Returns <code>true</code> if the value is any boxed primitive object, e.g. created
 by <code>new Boolean()</code>, <code>new String()</code> or <code>Object(Symbol())</code>.</p>
 <p>For example:</p>
-<pre><code class="language-js">util.types.isBoxedPrimitive(<span class="hljs-literal">false</span>); <span class="hljs-comment">// Returns false</span>
-util.types.isBoxedPrimitive(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns true</span>
-util.types.isBoxedPrimitive(<span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// Returns false</span>
-util.types.isBoxedPrimitive(<span class="hljs-built_in">Object</span>(<span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'foo'</span>))); <span class="hljs-comment">// Returns true</span>
-util.types.isBoxedPrimitive(<span class="hljs-built_in">Object</span>(BigInt(<span class="hljs-number">5</span>))); <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isDataView(value)</code><span><a class="mark" href="#util_util_types_isdataview_value" id="util_util_types_isdataview_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-literal">false</span>); <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Boolean</span>(<span class="hljs-literal">false</span>)); <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-title class_">Object</span>(<span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'foo'</span>))); <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isBoxedPrimitive</span>(<span class="hljs-title class_">Object</span>(<span class="hljs-title class_">BigInt</span>(<span class="hljs-number">5</span>))); <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isDataView(value)</code><span><a class="mark" href="#util_util_types_isdataview_value" id="util_util_types_isdataview_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1573,11 +1644,11 @@ util.types.isBoxedPrimitive(<span class="hljs-built_in">Object</span>(BigInt(<sp
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">20</span>);
-util.types.isDataView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">DataView</span>(ab));  <span class="hljs-comment">// Returns true</span>
-util.types.isDataView(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">20</span>);
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isDataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">DataView</span>(ab));  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isDataView</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
 <p>See also <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView"><code>ArrayBuffer.isView()</code></a>.</p>
-<h3><code>util.types.isDate(value)</code><span><a class="mark" href="#util_util_types_isdate_value" id="util_util_types_isdate_value">#</a></span></h3>
+<h4><code>util.types.isDate(value)</code><span><a class="mark" href="#util_util_types_isdate_value" id="util_util_types_isdate_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1586,8 +1657,8 @@ util.types.isDataView(<span class="hljs-keyword">new</span> <span class="hljs-bu
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a> instance.</p>
-<pre><code class="language-js">util.types.isDate(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isExternal(value)</code><span><a class="mark" href="#util_util_types_isexternal_value" id="util_util_types_isexternal_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isDate</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isExternal(value)</code><span><a class="mark" href="#util_util_types_isexternal_value" id="util_util_types_isexternal_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1601,12 +1672,12 @@ raw C++ pointer (<code>void*</code>) for access from native code, and has no oth
 properties. Such objects are created either by Node.js internals or native
 addons. In JavaScript, they are <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze">frozen</a> objects with a
 <code>null</code> prototype.</p>
-<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;js_native_api.h></span></span>
-<span class="hljs-meta">#<span class="hljs-meta-keyword">include</span> <span class="hljs-meta-string">&#x3C;stdlib.h></span></span>
+<pre><code class="language-c"><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;js_native_api.h></span></span>
+<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string">&#x3C;stdlib.h></span></span>
 napi_value result;
-<span class="hljs-function"><span class="hljs-keyword">static</span> napi_value <span class="hljs-title">MyNapi</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> </span>{
-  <span class="hljs-keyword">int</span>* raw = (<span class="hljs-keyword">int</span>*) <span class="hljs-built_in">malloc</span>(<span class="hljs-number">1024</span>);
-  napi_status status = napi_create_external(env, (<span class="hljs-keyword">void</span>*) raw, <span class="hljs-literal">NULL</span>, <span class="hljs-literal">NULL</span>, &#x26;result);
+<span class="hljs-keyword">static</span> napi_value <span class="hljs-title function_">MyNapi</span><span class="hljs-params">(napi_env env, napi_callback_info info)</span> {
+  <span class="hljs-type">int</span>* raw = (<span class="hljs-type">int</span>*) <span class="hljs-built_in">malloc</span>(<span class="hljs-number">1024</span>);
+  napi_status status = napi_create_external(env, (<span class="hljs-type">void</span>*) raw, <span class="hljs-literal">NULL</span>, <span class="hljs-literal">NULL</span>, &#x26;result);
   <span class="hljs-keyword">if</span> (status != napi_ok) {
     napi_throw_error(env, <span class="hljs-literal">NULL</span>, <span class="hljs-string">"napi_create_external failed"</span>);
     <span class="hljs-keyword">return</span> <span class="hljs-literal">NULL</span>;
@@ -1617,13 +1688,13 @@ napi_value result;
 DECLARE_NAPI_PROPERTY(<span class="hljs-string">"myNapi"</span>, MyNapi)
 ...</code></pre>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> native = <span class="hljs-built_in">require</span>(<span class="hljs-string">'napi_addon.node'</span>);
-<span class="hljs-keyword">const</span> data = native.myNapi();
-util.types.isExternal(data); <span class="hljs-comment">// returns true</span>
-util.types.isExternal(<span class="hljs-number">0</span>); <span class="hljs-comment">// returns false</span>
-util.types.isExternal(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// returns false</span></code></pre>
+<span class="hljs-keyword">const</span> data = native.<span class="hljs-title function_">myNapi</span>();
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isExternal</span>(data); <span class="hljs-comment">// returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isExternal</span>(<span class="hljs-number">0</span>); <span class="hljs-comment">// returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isExternal</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(<span class="hljs-string">'foo'</span>)); <span class="hljs-comment">// returns false</span></code></pre>
 <p>For further information on <code>napi_create_external</code>, refer to
 <a href="n-api.html#n_api_napi_create_external"><code>napi_create_external()</code></a>.</p>
-<h3><code>util.types.isFloat32Array(value)</code><span><a class="mark" href="#util_util_types_isfloat32array_value" id="util_util_types_isfloat32array_value">#</a></span></h3>
+<h4><code>util.types.isFloat32Array(value)</code><span><a class="mark" href="#util_util_types_isfloat32array_value" id="util_util_types_isfloat32array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1632,10 +1703,10 @@ util.types.isExternal(<span class="hljs-keyword">new</span> <span class="hljs-bu
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array"><code>Float32Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isFloat32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isFloat32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float32Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isFloat32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isFloat64Array(value)</code><span><a class="mark" href="#util_util_types_isfloat64array_value" id="util_util_types_isfloat64array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>32<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isFloat64Array(value)</code><span><a class="mark" href="#util_util_types_isfloat64array_value" id="util_util_types_isfloat64array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1644,10 +1715,10 @@ util.types.isFloat32Array(<span class="hljs-keyword">new</span> <span class="hlj
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array"><code>Float64Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isFloat64Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isFloat64Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isFloat64Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isGeneratorFunction(value)</code><span><a class="mark" href="#util_util_types_isgeneratorfunction_value" id="util_util_types_isgeneratorfunction_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isFloat64Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isGeneratorFunction(value)</code><span><a class="mark" href="#util_util_types_isgeneratorfunction_value" id="util_util_types_isgeneratorfunction_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1659,9 +1730,9 @@ util.types.isFloat64Array(<span class="hljs-keyword">new</span> <span class="hlj
 This only reports back what the JavaScript engine is seeing;
 in particular, the return value may not match the original source code if
 a transpilation tool was used.</p>
-<pre><code class="language-js">util.types.isGeneratorFunction(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{});  <span class="hljs-comment">// Returns false</span>
-util.types.isGeneratorFunction(<span class="hljs-function"><span class="hljs-keyword">function</span>* <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{});  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isGeneratorObject(value)</code><span><a class="mark" href="#util_util_types_isgeneratorobject_value" id="util_util_types_isgeneratorobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isGeneratorFunction</span>(<span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {});  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isGeneratorFunction</span>(<span class="hljs-keyword">function</span>* <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {});  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isGeneratorObject(value)</code><span><a class="mark" href="#util_util_types_isgeneratorobject_value" id="util_util_types_isgeneratorobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1674,10 +1745,10 @@ built-in generator function.
 This only reports back what the JavaScript engine is seeing;
 in particular, the return value may not match the original source code if
 a transpilation tool was used.</p>
-<pre><code class="language-js"><span class="hljs-function"><span class="hljs-keyword">function</span>* <span class="hljs-title">foo</span>(<span class="hljs-params"></span>) </span>{}
-<span class="hljs-keyword">const</span> generator = foo();
-util.types.isGeneratorObject(generator);  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isInt8Array(value)</code><span><a class="mark" href="#util_util_types_isint8array_value" id="util_util_types_isint8array_value">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">function</span>* <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) {}
+<span class="hljs-keyword">const</span> generator = <span class="hljs-title function_">foo</span>();
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isGeneratorObject</span>(generator);  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isInt8Array(value)</code><span><a class="mark" href="#util_util_types_isint8array_value" id="util_util_types_isint8array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1686,10 +1757,10 @@ util.types.isGeneratorObject(generator);  <span class="hljs-comment">// Returns
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int8Array"><code>Int8Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isInt8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isInt8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int8Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isInt8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isInt16Array(value)</code><span><a class="mark" href="#util_util_types_isint16array_value" id="util_util_types_isint16array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isInt16Array(value)</code><span><a class="mark" href="#util_util_types_isint16array_value" id="util_util_types_isint16array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1698,10 +1769,10 @@ util.types.isInt8Array(<span class="hljs-keyword">new</span> <span class="hljs-b
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int16Array"><code>Int16Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isInt16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isInt16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int16Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isInt16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isInt32Array(value)</code><span><a class="mark" href="#util_util_types_isint32array_value" id="util_util_types_isint32array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>16<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isInt32Array(value)</code><span><a class="mark" href="#util_util_types_isint32array_value" id="util_util_types_isint32array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1710,10 +1781,10 @@ util.types.isInt16Array(<span class="hljs-keyword">new</span> <span class="hljs-
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array"><code>Int32Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Int32Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isMap(value)</code><span><a class="mark" href="#util_util_types_ismap_value" id="util_util_types_ismap_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Int</span>32<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isInt32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isMap(value)</code><span><a class="mark" href="#util_util_types_ismap_value" id="util_util_types_ismap_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1722,8 +1793,8 @@ util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map"><code>Map</code></a> instance.</p>
-<pre><code class="language-js">util.types.isMap(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isMapIterator(value)</code><span><a class="mark" href="#util_util_types_ismapiterator_value" id="util_util_types_ismapiterator_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMap</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isMapIterator(value)</code><span><a class="mark" href="#util_util_types_ismapiterator_value" id="util_util_types_ismapiterator_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1733,12 +1804,12 @@ util.types.isInt32Array(<span class="hljs-keyword">new</span> <span class="hljs-
 </ul>
 <p>Returns <code>true</code> if the value is an iterator returned for a built-in
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map"><code>Map</code></a> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> map = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Map</span>();
-util.types.isMapIterator(map.keys());  <span class="hljs-comment">// Returns true</span>
-util.types.isMapIterator(map.values());  <span class="hljs-comment">// Returns true</span>
-util.types.isMapIterator(map.entries());  <span class="hljs-comment">// Returns true</span>
-util.types.isMapIterator(map[<span class="hljs-built_in">Symbol</span>.iterator]());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isModuleNamespaceObject(value)</code><span><a class="mark" href="#util_util_types_ismodulenamespaceobject_value" id="util_util_types_ismodulenamespaceobject_value">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> map = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Map</span>();
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMapIterator</span>(map.<span class="hljs-title function_">keys</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMapIterator</span>(map.<span class="hljs-title function_">values</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMapIterator</span>(map.<span class="hljs-title function_">entries</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isMapIterator</span>(map[<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">iterator</span>]());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isModuleNamespaceObject(value)</code><span><a class="mark" href="#util_util_types_ismodulenamespaceobject_value" id="util_util_types_ismodulenamespaceobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1750,8 +1821,8 @@ util.types.isMapIterator(map[<span class="hljs-built_in">Symbol</span>.iterator]
 <!-- eslint-skip -->
 <pre><code class="language-js"><span class="hljs-keyword">import</span> * <span class="hljs-keyword">as</span> ns <span class="hljs-keyword">from</span> <span class="hljs-string">'./a.js'</span>;
 
-util.types.isModuleNamespaceObject(ns);  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isNativeError(value)</code><span><a class="mark" href="#util_util_types_isnativeerror_value" id="util_util_types_isnativeerror_value">#</a></span></h3>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isModuleNamespaceObject</span>(ns);  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isNativeError(value)</code><span><a class="mark" href="#util_util_types_isnativeerror_value" id="util_util_types_isnativeerror_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1760,10 +1831,10 @@ util.types.isModuleNamespaceObject(ns);  <span class="hljs-comment">// Returns t
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is an instance of a built-in <a href="errors.html#errors_class_error"><code>Error</code></a> type.</p>
-<pre><code class="language-js">util.types.isNativeError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isNativeError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isNativeError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">RangeError</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isNumberObject(value)</code><span><a class="mark" href="#util_util_types_isnumberobject_value" id="util_util_types_isnumberobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNativeError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNativeError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNativeError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">RangeError</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isNumberObject(value)</code><span><a class="mark" href="#util_util_types_isnumberobject_value" id="util_util_types_isnumberobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1773,9 +1844,9 @@ util.types.isNativeError(<span class="hljs-keyword">new</span> <span class="hljs
 </ul>
 <p>Returns <code>true</code> if the value is a number object, e.g. created
 by <code>new Number()</code>.</p>
-<pre><code class="language-js">util.types.isNumberObject(<span class="hljs-number">0</span>);  <span class="hljs-comment">// Returns false</span>
-util.types.isNumberObject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Number</span>(<span class="hljs-number">0</span>));   <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isPromise(value)</code><span><a class="mark" href="#util_util_types_ispromise_value" id="util_util_types_ispromise_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNumberObject</span>(<span class="hljs-number">0</span>);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isNumberObject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Number</span>(<span class="hljs-number">0</span>));   <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isPromise(value)</code><span><a class="mark" href="#util_util_types_ispromise_value" id="util_util_types_ispromise_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1784,8 +1855,8 @@ util.types.isNumberObject(<span class="hljs-keyword">new</span> <span class="hlj
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise"><code>Promise</code></a>.</p>
-<pre><code class="language-js">util.types.isPromise(<span class="hljs-built_in">Promise</span>.resolve(<span class="hljs-number">42</span>));  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isProxy(value)</code><span><a class="mark" href="#util_util_types_isproxy_value" id="util_util_types_isproxy_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isPromise</span>(<span class="hljs-title class_">Promise</span>.<span class="hljs-title function_">resolve</span>(<span class="hljs-number">42</span>));  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isProxy(value)</code><span><a class="mark" href="#util_util_types_isproxy_value" id="util_util_types_isproxy_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1795,10 +1866,10 @@ util.types.isNumberObject(<span class="hljs-keyword">new</span> <span class="hlj
 </ul>
 <p>Returns <code>true</code> if the value is a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy"><code>Proxy</code></a> instance.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> target = {};
-<span class="hljs-keyword">const</span> proxy = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Proxy</span>(target, {});
-util.types.isProxy(target);  <span class="hljs-comment">// Returns false</span>
-util.types.isProxy(proxy);  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isRegExp(value)</code><span><a class="mark" href="#util_util_types_isregexp_value" id="util_util_types_isregexp_value">#</a></span></h3>
+<span class="hljs-keyword">const</span> proxy = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Proxy</span>(target, {});
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isProxy</span>(target);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isProxy</span>(proxy);  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isRegExp(value)</code><span><a class="mark" href="#util_util_types_isregexp_value" id="util_util_types_isregexp_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1807,9 +1878,9 @@ util.types.isProxy(proxy);  <span class="hljs-comment">// Returns true</span></c
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a regular expression object.</p>
-<pre><code class="language-js">util.types.isRegExp(<span class="hljs-regexp">/abc/</span>);  <span class="hljs-comment">// Returns true</span>
-util.types.isRegExp(<span class="hljs-keyword">new</span> <span class="hljs-built_in">RegExp</span>(<span class="hljs-string">'abc'</span>));  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isSet(value)</code><span><a class="mark" href="#util_util_types_isset_value" id="util_util_types_isset_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isRegExp</span>(<span class="hljs-regexp">/abc/</span>);  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isRegExp</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">RegExp</span>(<span class="hljs-string">'abc'</span>));  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isSet(value)</code><span><a class="mark" href="#util_util_types_isset_value" id="util_util_types_isset_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1818,8 +1889,8 @@ util.types.isRegExp(<span class="hljs-keyword">new</span> <span class="hljs-buil
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set"><code>Set</code></a> instance.</p>
-<pre><code class="language-js">util.types.isSet(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isSetIterator(value)</code><span><a class="mark" href="#util_util_types_issetiterator_value" id="util_util_types_issetiterator_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSet</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isSetIterator(value)</code><span><a class="mark" href="#util_util_types_issetiterator_value" id="util_util_types_issetiterator_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1829,12 +1900,12 @@ util.types.isRegExp(<span class="hljs-keyword">new</span> <span class="hljs-buil
 </ul>
 <p>Returns <code>true</code> if the value is an iterator returned for a built-in
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set"><code>Set</code></a> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> set = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Set</span>();
-util.types.isSetIterator(set.keys());  <span class="hljs-comment">// Returns true</span>
-util.types.isSetIterator(set.values());  <span class="hljs-comment">// Returns true</span>
-util.types.isSetIterator(set.entries());  <span class="hljs-comment">// Returns true</span>
-util.types.isSetIterator(set[<span class="hljs-built_in">Symbol</span>.iterator]());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isSharedArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_issharedarraybuffer_value" id="util_util_types_issharedarraybuffer_value">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> set = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Set</span>();
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSetIterator</span>(set.<span class="hljs-title function_">keys</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSetIterator</span>(set.<span class="hljs-title function_">values</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSetIterator</span>(set.<span class="hljs-title function_">entries</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSetIterator</span>(set[<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">iterator</span>]());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isSharedArrayBuffer(value)</code><span><a class="mark" href="#util_util_types_issharedarraybuffer_value" id="util_util_types_issharedarraybuffer_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1845,9 +1916,9 @@ util.types.isSetIterator(set[<span class="hljs-built_in">Symbol</span>.iterator]
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer"><code>SharedArrayBuffer</code></a> instance.
 This does <em>not</em> include <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> instances. Usually, it is
 desirable to test for both; See <a href="#util_util_types_isanyarraybuffer_value"><code>util.types.isAnyArrayBuffer()</code></a> for that.</p>
-<pre><code class="language-js">util.types.isSharedArrayBuffer(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isSharedArrayBuffer(<span class="hljs-keyword">new</span> SharedArrayBuffer());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isStringObject(value)</code><span><a class="mark" href="#util_util_types_isstringobject_value" id="util_util_types_isstringobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSharedArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSharedArrayBuffer</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">SharedArrayBuffer</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isStringObject(value)</code><span><a class="mark" href="#util_util_types_isstringobject_value" id="util_util_types_isstringobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1857,9 +1928,9 @@ util.types.isSharedArrayBuffer(<span class="hljs-keyword">new</span> SharedArray
 </ul>
 <p>Returns <code>true</code> if the value is a string object, e.g. created
 by <code>new String()</code>.</p>
-<pre><code class="language-js">util.types.isStringObject(<span class="hljs-string">'foo'</span>);  <span class="hljs-comment">// Returns false</span>
-util.types.isStringObject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">String</span>(<span class="hljs-string">'foo'</span>));   <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isSymbolObject(value)</code><span><a class="mark" href="#util_util_types_issymbolobject_value" id="util_util_types_issymbolobject_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isStringObject</span>(<span class="hljs-string">'foo'</span>);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isStringObject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>(<span class="hljs-string">'foo'</span>));   <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isSymbolObject(value)</code><span><a class="mark" href="#util_util_types_issymbolobject_value" id="util_util_types_issymbolobject_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1869,10 +1940,10 @@ util.types.isStringObject(<span class="hljs-keyword">new</span> <span class="hlj
 </ul>
 <p>Returns <code>true</code> if the value is a symbol object, created
 by calling <code>Object()</code> on a <code>Symbol</code> primitive.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> symbol = <span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'foo'</span>);
-util.types.isSymbolObject(symbol);  <span class="hljs-comment">// Returns false</span>
-util.types.isSymbolObject(<span class="hljs-built_in">Object</span>(symbol));   <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isTypedArray(value)</code><span><a class="mark" href="#util_util_types_istypedarray_value" id="util_util_types_istypedarray_value">#</a></span></h3>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> symbol = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'foo'</span>);
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSymbolObject</span>(symbol);  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isSymbolObject</span>(<span class="hljs-title class_">Object</span>(symbol));   <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isTypedArray(value)</code><span><a class="mark" href="#util_util_types_istypedarray_value" id="util_util_types_istypedarray_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1881,11 +1952,11 @@ util.types.isSymbolObject(<span class="hljs-built_in">Object</span>(symbol));
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a> instance.</p>
-<pre><code class="language-js">util.types.isTypedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isTypedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isTypedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isTypedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isTypedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isTypedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
 <p>See also <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView"><code>ArrayBuffer.isView()</code></a>.</p>
-<h3><code>util.types.isUint8Array(value)</code><span><a class="mark" href="#util_util_types_isuint8array_value" id="util_util_types_isuint8array_value">#</a></span></h3>
+<h4><code>util.types.isUint8Array(value)</code><span><a class="mark" href="#util_util_types_isuint8array_value" id="util_util_types_isuint8array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1894,10 +1965,10 @@ util.types.isTypedArray(<span class="hljs-keyword">new</span> <span class="hljs-
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array"><code>Uint8Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isUint8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isUint8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isUint8Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isUint8ClampedArray(value)</code><span><a class="mark" href="#util_util_types_isuint8clampedarray_value" id="util_util_types_isuint8clampedarray_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isUint8ClampedArray(value)</code><span><a class="mark" href="#util_util_types_isuint8clampedarray_value" id="util_util_types_isuint8clampedarray_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1906,10 +1977,10 @@ util.types.isUint8Array(<span class="hljs-keyword">new</span> <span class="hljs-
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray"><code>Uint8ClampedArray</code></a> instance.</p>
-<pre><code class="language-js">util.types.isUint8ClampedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isUint8ClampedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8ClampedArray</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isUint8ClampedArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isUint16Array(value)</code><span><a class="mark" href="#util_util_types_isuint16array_value" id="util_util_types_isuint16array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8ClampedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8ClampedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8ClampedArray());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint8ClampedArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isUint16Array(value)</code><span><a class="mark" href="#util_util_types_isuint16array_value" id="util_util_types_isuint16array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1918,10 +1989,10 @@ util.types.isUint8ClampedArray(<span class="hljs-keyword">new</span> <span class
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array"><code>Uint16Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isUint16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isUint16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isUint16Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isUint32Array(value)</code><span><a class="mark" href="#util_util_types_isuint32array_value" id="util_util_types_isuint32array_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint16Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isUint32Array(value)</code><span><a class="mark" href="#util_util_types_isuint32array_value" id="util_util_types_isuint32array_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1930,10 +2001,10 @@ util.types.isUint16Array(<span class="hljs-keyword">new</span> <span class="hljs
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array"><code>Uint32Array</code></a> instance.</p>
-<pre><code class="language-js">util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
-util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint32Array</span>());  <span class="hljs-comment">// Returns true</span>
-util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
-<h3><code>util.types.isWeakMap(value)</code><span><a class="mark" href="#util_util_types_isweakmap_value" id="util_util_types_isweakmap_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>());  <span class="hljs-comment">// Returns false</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>32<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns true</span>
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isUint32Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>());  <span class="hljs-comment">// Returns false</span></code></pre>
+<h4><code>util.types.isWeakMap(value)</code><span><a class="mark" href="#util_util_types_isweakmap_value" id="util_util_types_isweakmap_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1942,8 +2013,8 @@ util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap"><code>WeakMap</code></a> instance.</p>
-<pre><code class="language-js">util.types.isWeakMap(<span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakMap</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isWeakSet(value)</code><span><a class="mark" href="#util_util_types_isweakset_value" id="util_util_types_isweakset_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isWeakMap</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakMap</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isWeakSet(value)</code><span><a class="mark" href="#util_util_types_isweakset_value" id="util_util_types_isweakset_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -1952,22 +2023,23 @@ util.types.isUint32Array(<span class="hljs-keyword">new</span> <span class="hljs
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet"><code>WeakSet</code></a> instance.</p>
-<pre><code class="language-js">util.types.isWeakSet(<span class="hljs-keyword">new</span> <span class="hljs-built_in">WeakSet</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
-<h3><code>util.types.isWebAssemblyCompiledModule(value)</code><span><a class="mark" href="#util_util_types_iswebassemblycompiledmodule_value" id="util_util_types_iswebassemblycompiledmodule_value">#</a></span></h3>
+<pre><code class="language-js">util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isWeakSet</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">WeakSet</span>());  <span class="hljs-comment">// Returns true</span></code></pre>
+<h4><code>util.types.isWebAssemblyCompiledModule(value)</code><span><a class="mark" href="#util_util_types_iswebassemblycompiledmodule_value" id="util_util_types_iswebassemblycompiledmodule_value">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v10.0.0</span>
+<span>Added in: v10.0.0</span><span>Deprecated since: v14.0.0</span>
 </div>
+<p></p><div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <code>value instanceof WebAssembly.Module</code> instead.</div><p></p>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Returns <code>true</code> if the value is a built-in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module"><code>WebAssembly.Module</code></a> instance.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = <span class="hljs-keyword">new</span> WebAssembly.Module(wasmBuffer);
-util.types.isWebAssemblyCompiledModule(<span class="hljs-built_in">module</span>);  <span class="hljs-comment">// Returns true</span></code></pre>
-<h2>Deprecated APIs<span><a class="mark" href="#util_deprecated_apis" id="util_deprecated_apis">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title class_">Module</span>(wasmBuffer);
+util.<span class="hljs-property">types</span>.<span class="hljs-title function_">isWebAssemblyCompiledModule</span>(<span class="hljs-variable language_">module</span>);  <span class="hljs-comment">// Returns true</span></code></pre>
+</section><section><h3>Deprecated APIs<span><a class="mark" href="#util_deprecated_apis" id="util_deprecated_apis">#</a></span></h3>
 <p>The following APIs are deprecated and should no longer be used. Existing
 applications and modules should be updated to find alternative approaches.</p>
-<h3><code>util._extend(target, source)</code><span><a class="mark" href="#util_util_extend_target_source" id="util_util_extend_target_source">#</a></span></h3>
+<h4><code>util._extend(target, source)</code><span><a class="mark" href="#util_util_extend_target_source" id="util_util_extend_target_source">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.5</span><span>Deprecated since: v6.0.0</span>
 </div>
@@ -1980,7 +2052,7 @@ applications and modules should be updated to find alternative approaches.</p>
 Node.js modules. The community found and used it anyway.</p>
 <p>It is deprecated and should not be used in new code. JavaScript comes with very
 similar built-in functionality through <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign"><code>Object.assign()</code></a>.</p>
-<h3><code>util.isArray(object)</code><span><a class="mark" href="#util_util_isarray_object" id="util_util_isarray_object">#</a></span></h3>
+<h4><code>util.isArray(object)</code><span><a class="mark" href="#util_util_isarray_object" id="util_util_isarray_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -1993,13 +2065,13 @@ similar built-in functionality through <a href="https://developer.mozilla.org/en
 <p>Returns <code>true</code> if the given <code>object</code> is an <code>Array</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isArray([]);
+util.<span class="hljs-title function_">isArray</span>([]);
 <span class="hljs-comment">// Returns: true</span>
-util.isArray(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Array</span>());
+util.<span class="hljs-title function_">isArray</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Array</span>());
 <span class="hljs-comment">// Returns: true</span>
-util.isArray({});
+util.<span class="hljs-title function_">isArray</span>({});
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isBoolean(object)</code><span><a class="mark" href="#util_util_isboolean_object" id="util_util_isboolean_object">#</a></span></h3>
+<h4><code>util.isBoolean(object)</code><span><a class="mark" href="#util_util_isboolean_object" id="util_util_isboolean_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2011,13 +2083,13 @@ util.isArray({});
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Boolean</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isBoolean(<span class="hljs-number">1</span>);
+util.<span class="hljs-title function_">isBoolean</span>(<span class="hljs-number">1</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isBoolean(<span class="hljs-number">0</span>);
+util.<span class="hljs-title function_">isBoolean</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isBoolean(<span class="hljs-literal">false</span>);
+util.<span class="hljs-title function_">isBoolean</span>(<span class="hljs-literal">false</span>);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isBuffer(object)</code><span><a class="mark" href="#util_util_isbuffer_object" id="util_util_isbuffer_object">#</a></span></h3>
+<h4><code>util.isBuffer(object)</code><span><a class="mark" href="#util_util_isbuffer_object" id="util_util_isbuffer_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2029,13 +2101,13 @@ util.isBoolean(<span class="hljs-literal">false</span>);
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Buffer</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isBuffer({ <span class="hljs-attr">length</span>: <span class="hljs-number">0</span> });
+util.<span class="hljs-title function_">isBuffer</span>({ <span class="hljs-attr">length</span>: <span class="hljs-number">0</span> });
 <span class="hljs-comment">// Returns: false</span>
-util.isBuffer([]);
+util.<span class="hljs-title function_">isBuffer</span>([]);
 <span class="hljs-comment">// Returns: false</span>
-util.isBuffer(Buffer.from(<span class="hljs-string">'hello world'</span>));
+util.<span class="hljs-title function_">isBuffer</span>(<span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'hello world'</span>));
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isDate(object)</code><span><a class="mark" href="#util_util_isdate_object" id="util_util_isdate_object">#</a></span></h3>
+<h4><code>util.isDate(object)</code><span><a class="mark" href="#util_util_isdate_object" id="util_util_isdate_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2047,13 +2119,13 @@ util.isBuffer(Buffer.from(<span class="hljs-string">'hello world'</span>));
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Date</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isDate(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>());
+util.<span class="hljs-title function_">isDate</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>());
 <span class="hljs-comment">// Returns: true</span>
-util.isDate(<span class="hljs-built_in">Date</span>());
+util.<span class="hljs-title function_">isDate</span>(<span class="hljs-title class_">Date</span>());
 <span class="hljs-comment">// false (without 'new' returns a String)</span>
-util.isDate({});
+util.<span class="hljs-title function_">isDate</span>({});
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isError(object)</code><span><a class="mark" href="#util_util_iserror_object" id="util_util_iserror_object">#</a></span></h3>
+<h4><code>util.isError(object)</code><span><a class="mark" href="#util_util_iserror_object" id="util_util_iserror_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2066,11 +2138,11 @@ util.isDate({});
 <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>());
+util.<span class="hljs-title function_">isError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>());
 <span class="hljs-comment">// Returns: true</span>
-util.isError(<span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>());
+util.<span class="hljs-title function_">isError</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">TypeError</span>());
 <span class="hljs-comment">// Returns: true</span>
-util.isError({ <span class="hljs-attr">name</span>: <span class="hljs-string">'Error'</span>, <span class="hljs-attr">message</span>: <span class="hljs-string">'an error occurred'</span> });
+util.<span class="hljs-title function_">isError</span>({ <span class="hljs-attr">name</span>: <span class="hljs-string">'Error'</span>, <span class="hljs-attr">message</span>: <span class="hljs-string">'an error occurred'</span> });
 <span class="hljs-comment">// Returns: false</span></code></pre>
 <p>This method relies on <code>Object.prototype.toString()</code> behavior. It is
 possible to obtain an incorrect result when the <code>object</code> argument manipulates
@@ -2078,12 +2150,12 @@ possible to obtain an incorrect result when the <code>object</code> argument man
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 <span class="hljs-keyword">const</span> obj = { <span class="hljs-attr">name</span>: <span class="hljs-string">'Error'</span>, <span class="hljs-attr">message</span>: <span class="hljs-string">'an error occurred'</span> };
 
-util.isError(obj);
+util.<span class="hljs-title function_">isError</span>(obj);
 <span class="hljs-comment">// Returns: false</span>
-obj[<span class="hljs-built_in">Symbol</span>.toStringTag] = <span class="hljs-string">'Error'</span>;
-util.isError(obj);
+obj[<span class="hljs-title class_">Symbol</span>.<span class="hljs-property">toStringTag</span>] = <span class="hljs-string">'Error'</span>;
+util.<span class="hljs-title function_">isError</span>(obj);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isFunction(object)</code><span><a class="mark" href="#util_util_isfunction_object" id="util_util_isfunction_object">#</a></span></h3>
+<h4><code>util.isFunction(object)</code><span><a class="mark" href="#util_util_isfunction_object" id="util_util_isfunction_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2096,16 +2168,16 @@ util.isError(obj);
 <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">Foo</span>(<span class="hljs-params"></span>) </span>{}
-<span class="hljs-keyword">const</span> Bar = <span class="hljs-function">() =></span> {};
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">Foo</span>(<span class="hljs-params"></span>) {}
+<span class="hljs-keyword">const</span> <span class="hljs-title function_">Bar</span> = (<span class="hljs-params"></span>) => {};
 
-util.isFunction({});
+util.<span class="hljs-title function_">isFunction</span>({});
 <span class="hljs-comment">// Returns: false</span>
-util.isFunction(Foo);
+util.<span class="hljs-title function_">isFunction</span>(<span class="hljs-title class_">Foo</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isFunction(Bar);
+util.<span class="hljs-title function_">isFunction</span>(<span class="hljs-title class_">Bar</span>);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isNull(object)</code><span><a class="mark" href="#util_util_isnull_object" id="util_util_isnull_object">#</a></span></h3>
+<h4><code>util.isNull(object)</code><span><a class="mark" href="#util_util_isnull_object" id="util_util_isnull_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2118,13 +2190,13 @@ util.isFunction(Bar);
 <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isNull(<span class="hljs-number">0</span>);
+util.<span class="hljs-title function_">isNull</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isNull(<span class="hljs-literal">undefined</span>);
+util.<span class="hljs-title function_">isNull</span>(<span class="hljs-literal">undefined</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isNull(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isNull</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isNullOrUndefined(object)</code><span><a class="mark" href="#util_util_isnullorundefined_object" id="util_util_isnullorundefined_object">#</a></span></h3>
+<h4><code>util.isNullOrUndefined(object)</code><span><a class="mark" href="#util_util_isnullorundefined_object" id="util_util_isnullorundefined_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2138,13 +2210,13 @@ util.isNull(<span class="hljs-literal">null</span>);
 returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isNullOrUndefined(<span class="hljs-number">0</span>);
+util.<span class="hljs-title function_">isNullOrUndefined</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isNullOrUndefined(<span class="hljs-literal">undefined</span>);
+util.<span class="hljs-title function_">isNullOrUndefined</span>(<span class="hljs-literal">undefined</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isNullOrUndefined(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isNullOrUndefined</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isNumber(object)</code><span><a class="mark" href="#util_util_isnumber_object" id="util_util_isnumber_object">#</a></span></h3>
+<h4><code>util.isNumber(object)</code><span><a class="mark" href="#util_util_isnumber_object" id="util_util_isnumber_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2156,15 +2228,15 @@ util.isNullOrUndefined(<span class="hljs-literal">null</span>);
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Number</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isNumber(<span class="hljs-literal">false</span>);
+util.<span class="hljs-title function_">isNumber</span>(<span class="hljs-literal">false</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isNumber(<span class="hljs-literal">Infinity</span>);
+util.<span class="hljs-title function_">isNumber</span>(<span class="hljs-title class_">Infinity</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isNumber(<span class="hljs-number">0</span>);
+util.<span class="hljs-title function_">isNumber</span>(<span class="hljs-number">0</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isNumber(<span class="hljs-literal">NaN</span>);
+util.<span class="hljs-title function_">isNumber</span>(<span class="hljs-title class_">Na</span>N);
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isObject(object)</code><span><a class="mark" href="#util_util_isobject_object" id="util_util_isobject_object">#</a></span></h3>
+<h4><code>util.isObject(object)</code><span><a class="mark" href="#util_util_isobject_object" id="util_util_isobject_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2179,15 +2251,15 @@ Use <code>value !== null &#x26;&#x26; typeof value === 'object'</code> instead.<
 Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isObject(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isObject</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isObject(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isObject</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isObject({});
+util.<span class="hljs-title function_">isObject</span>({});
 <span class="hljs-comment">// Returns: true</span>
-util.isObject(<span class="hljs-function">() =></span> {});
+util.<span class="hljs-title function_">isObject</span>(<span class="hljs-function">() =></span> {});
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isPrimitive(object)</code><span><a class="mark" href="#util_util_isprimitive_object" id="util_util_isprimitive_object">#</a></span></h3>
+<h4><code>util.isPrimitive(object)</code><span><a class="mark" href="#util_util_isprimitive_object" id="util_util_isprimitive_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2202,25 +2274,25 @@ instead.</div><p></p>
 <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isPrimitive(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive(<span class="hljs-string">'foo'</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive(<span class="hljs-literal">false</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-literal">false</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive(<span class="hljs-literal">undefined</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-literal">undefined</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isPrimitive({});
+util.<span class="hljs-title function_">isPrimitive</span>({});
 <span class="hljs-comment">// Returns: false</span>
-util.isPrimitive(<span class="hljs-function">() =></span> {});
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-function">() =></span> {});
 <span class="hljs-comment">// Returns: false</span>
-util.isPrimitive(<span class="hljs-regexp">/^$/</span>);
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-regexp">/^$/</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isPrimitive(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>());
+util.<span class="hljs-title function_">isPrimitive</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Date</span>());
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isRegExp(object)</code><span><a class="mark" href="#util_util_isregexp_object" id="util_util_isregexp_object">#</a></span></h3>
+<h4><code>util.isRegExp(object)</code><span><a class="mark" href="#util_util_isregexp_object" id="util_util_isregexp_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.6.0</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2232,13 +2304,13 @@ util.isPrimitive(<span class="hljs-keyword">new</span> <span class="hljs-built_i
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>RegExp</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isRegExp(<span class="hljs-regexp">/some regexp/</span>);
+util.<span class="hljs-title function_">isRegExp</span>(<span class="hljs-regexp">/some regexp/</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isRegExp(<span class="hljs-keyword">new</span> <span class="hljs-built_in">RegExp</span>(<span class="hljs-string">'another regexp'</span>));
+util.<span class="hljs-title function_">isRegExp</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">RegExp</span>(<span class="hljs-string">'another regexp'</span>));
 <span class="hljs-comment">// Returns: true</span>
-util.isRegExp({});
+util.<span class="hljs-title function_">isRegExp</span>({});
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isString(object)</code><span><a class="mark" href="#util_util_isstring_object" id="util_util_isstring_object">#</a></span></h3>
+<h4><code>util.isString(object)</code><span><a class="mark" href="#util_util_isstring_object" id="util_util_isstring_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2250,15 +2322,15 @@ util.isRegExp({});
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>string</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isString(<span class="hljs-string">''</span>);
+util.<span class="hljs-title function_">isString</span>(<span class="hljs-string">''</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isString(<span class="hljs-string">'foo'</span>);
+util.<span class="hljs-title function_">isString</span>(<span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Returns: true</span>
-util.isString(<span class="hljs-built_in">String</span>(<span class="hljs-string">'foo'</span>));
+util.<span class="hljs-title function_">isString</span>(<span class="hljs-title class_">String</span>(<span class="hljs-string">'foo'</span>));
 <span class="hljs-comment">// Returns: true</span>
-util.isString(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isString</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.isSymbol(object)</code><span><a class="mark" href="#util_util_issymbol_object" id="util_util_issymbol_object">#</a></span></h3>
+<h4><code>util.isSymbol(object)</code><span><a class="mark" href="#util_util_issymbol_object" id="util_util_issymbol_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2270,13 +2342,13 @@ util.isString(<span class="hljs-number">5</span>);
 <p>Returns <code>true</code> if the given <code>object</code> is a <code>Symbol</code>. Otherwise, returns <code>false</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.isSymbol(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isSymbol</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isSymbol(<span class="hljs-string">'foo'</span>);
+util.<span class="hljs-title function_">isSymbol</span>(<span class="hljs-string">'foo'</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isSymbol(<span class="hljs-built_in">Symbol</span>(<span class="hljs-string">'foo'</span>));
+util.<span class="hljs-title function_">isSymbol</span>(<span class="hljs-title class_">Symbol</span>(<span class="hljs-string">'foo'</span>));
 <span class="hljs-comment">// Returns: true</span></code></pre>
-<h3><code>util.isUndefined(object)</code><span><a class="mark" href="#util_util_isundefined_object" id="util_util_isundefined_object">#</a></span></h3>
+<h4><code>util.isUndefined(object)</code><span><a class="mark" href="#util_util_isundefined_object" id="util_util_isundefined_object">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.5</span><span>Deprecated since: v4.0.0</span>
 </div>
@@ -2289,13 +2361,13 @@ util.isSymbol(<span class="hljs-built_in">Symbol</span>(<span class="hljs-string
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
 <span class="hljs-keyword">const</span> foo = <span class="hljs-literal">undefined</span>;
-util.isUndefined(<span class="hljs-number">5</span>);
+util.<span class="hljs-title function_">isUndefined</span>(<span class="hljs-number">5</span>);
 <span class="hljs-comment">// Returns: false</span>
-util.isUndefined(foo);
+util.<span class="hljs-title function_">isUndefined</span>(foo);
 <span class="hljs-comment">// Returns: true</span>
-util.isUndefined(<span class="hljs-literal">null</span>);
+util.<span class="hljs-title function_">isUndefined</span>(<span class="hljs-literal">null</span>);
 <span class="hljs-comment">// Returns: false</span></code></pre>
-<h3><code>util.log(string)</code><span><a class="mark" href="#util_util_log_string" id="util_util_log_string">#</a></span></h3>
+<h4><code>util.log(string)</code><span><a class="mark" href="#util_util_log_string" id="util_util_log_string">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.3.0</span><span>Deprecated since: v6.0.0</span>
 </div>
@@ -2307,10 +2379,46 @@ util.isUndefined(<span class="hljs-literal">null</span>);
 timestamp.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> util = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
 
-util.log(<span class="hljs-string">'Timestamped message.'</span>);</code></pre>
+util.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Timestamped message.'</span>);</code></pre></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/util.json b/doc/api/util.json
index 5230fd8c3a5a4d4ff88a61a30847a0cf0686b1f6..de7275b45e1e1f11fa562c325ec72255fc287d06 100644
--- a/doc/api/util.json
+++ b/doc/api/util.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/util.js\">lib/util.js</a></p>\n<p>The <code>util</code> module supports the needs of Node.js internal APIs. Many of the\nutilities are useful for application and module developers as well. To access\nit:</p>\n<pre><code class=\"language-js\">const util = require('util');\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/util.js\">lib/util.js</a></p>\n<p>The <code>util</code> module supports the needs of Node.js internal APIs. Many of the\nutilities are useful for application and module developers as well. To access\nit:</p>\n<pre><code class=\"language-js\">const util = require('util');\n</code></pre>",
       "methods": [
         {
           "textRaw": "`util.callbackify(original)`",
@@ -74,7 +74,39 @@
               ]
             }
           ],
-          "desc": "<p>The <code>util.debuglog()</code> method is used to create a function that conditionally\nwrites debug messages to <code>stderr</code> based on the existence of the <code>NODE_DEBUG</code>\nenvironment variable. If the <code>section</code> name appears within the value of that\nenvironment variable, then the returned function operates similar to\n<a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a>. If not, then the returned function is a no-op.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst debuglog = util.debuglog('foo');\n\ndebuglog('hello from foo [%d]', 123);\n</code></pre>\n<p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then\nit will output something like:</p>\n<pre><code class=\"language-console\">FOO 3245: hello from foo [123]\n</code></pre>\n<p>where <code>3245</code> is the process id. If it is not run with that\nenvironment variable set, then it will not print anything.</p>\n<p>The <code>section</code> supports wildcard also:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst debuglog = util.debuglog('foo-bar');\n\ndebuglog('hi there, it\\'s foo-bar [%d]', 2333);\n</code></pre>\n<p>if it is run with <code>NODE_DEBUG=foo*</code> in the environment, then it will output\nsomething like:</p>\n<pre><code class=\"language-console\">FOO-BAR 3257: hi there, it's foo-bar [2333]\n</code></pre>\n<p>Multiple comma-separated <code>section</code> names may be specified in the <code>NODE_DEBUG</code>\nenvironment variable: <code>NODE_DEBUG=fs,net,tls</code>.</p>\n<p>The optional <code>callback</code> argument can be used to replace the logging function\nwith a different function that doesn't have any initialization or\nunnecessary wrapping.</p>\n<pre><code class=\"language-js\">const util = require('util');\nlet debuglog = util.debuglog('internals', (debug) => {\n  // Replace with a logging function that optimizes out\n  // testing if the section is enabled\n  debuglog = debug;\n});\n</code></pre>"
+          "desc": "<p>The <code>util.debuglog()</code> method is used to create a function that conditionally\nwrites debug messages to <code>stderr</code> based on the existence of the <code>NODE_DEBUG</code>\nenvironment variable. If the <code>section</code> name appears within the value of that\nenvironment variable, then the returned function operates similar to\n<a href=\"console.html#console_console_error_data_args\"><code>console.error()</code></a>. If not, then the returned function is a no-op.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst debuglog = util.debuglog('foo');\n\ndebuglog('hello from foo [%d]', 123);\n</code></pre>\n<p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then\nit will output something like:</p>\n<pre><code class=\"language-console\">FOO 3245: hello from foo [123]\n</code></pre>\n<p>where <code>3245</code> is the process id. If it is not run with that\nenvironment variable set, then it will not print anything.</p>\n<p>The <code>section</code> supports wildcard also:</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst debuglog = util.debuglog('foo-bar');\n\ndebuglog('hi there, it\\'s foo-bar [%d]', 2333);\n</code></pre>\n<p>if it is run with <code>NODE_DEBUG=foo*</code> in the environment, then it will output\nsomething like:</p>\n<pre><code class=\"language-console\">FOO-BAR 3257: hi there, it's foo-bar [2333]\n</code></pre>\n<p>Multiple comma-separated <code>section</code> names may be specified in the <code>NODE_DEBUG</code>\nenvironment variable: <code>NODE_DEBUG=fs,net,tls</code>.</p>\n<p>The optional <code>callback</code> argument can be used to replace the logging function\nwith a different function that doesn't have any initialization or\nunnecessary wrapping.</p>\n<pre><code class=\"language-js\">const util = require('util');\nlet debuglog = util.debuglog('internals', (debug) => {\n  // Replace with a logging function that optimizes out\n  // testing if the section is enabled\n  debuglog = debug;\n});\n</code></pre>",
+          "modules": [
+            {
+              "textRaw": "`debuglog().enabled`",
+              "name": "`debuglog().enabled`",
+              "meta": {
+                "added": [
+                  "v14.9.0"
+                ],
+                "changes": []
+              },
+              "desc": "<ul>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a></li>\n</ul>\n<p>The <code>util.debuglog().enabled</code> getter is used to create a test that can be used\nin conditionals based on the existence of the <code>NODE_DEBUG</code> environment variable.\nIf the <code>section</code> name appears within the value of that environment variable,\nthen the returned value will be <code>true</code>. If not, then the returned value will be\n<code>false</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\nconst enabled = util.debuglog('foo').enabled;\nif (enabled) {\n  console.log('hello from foo [%d]', 123);\n}\n</code></pre>\n<p>If this program is run with <code>NODE_DEBUG=foo</code> in the environment, then it will\noutput something like:</p>\n<pre><code class=\"language-console\">hello from foo [123]\n</code></pre>",
+              "type": "module",
+              "displayName": "`debuglog().enabled`"
+            }
+          ]
+        },
+        {
+          "textRaw": "`util.debug(section)`",
+          "type": "method",
+          "name": "debug",
+          "meta": {
+            "added": [
+              "v14.9.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<p>Alias for <code>util.debuglog</code>. Usage allows for readability of that doesn't imply\nlogging when only using <code>util.debuglog().enabled</code>.</p>"
         },
         {
           "textRaw": "`util.deprecate(fn, msg[, code])`",
@@ -122,7 +154,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>util.deprecate()</code> method wraps <code>fn</code> (which may be a function or class) in\nsuch a way that it is marked as deprecated.</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nexports.obsoleteFunction = util.deprecate(() => {\n  // Do something here.\n}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');\n</code></pre>\n<p>When called, <code>util.deprecate()</code> will return a function that will emit a\n<code>DeprecationWarning</code> using the <a href=\"process.html#process_event_warning\"><code>'warning'</code></a> event. The warning will\nbe emitted and printed to <code>stderr</code> the first time the returned function is\ncalled. After the warning is emitted, the wrapped function is called without\nemitting a warning.</p>\n<p>If the same optional <code>code</code> is supplied in multiple calls to <code>util.deprecate()</code>,\nthe warning will be emitted only once for that <code>code</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');\nconst fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');\nfn1(); // Emits a deprecation warning with code DEP0001\nfn2(); // Does not emit a deprecation warning because it has the same code\n</code></pre>\n<p>If either the <code>--no-deprecation</code> or <code>--no-warnings</code> command line flags are\nused, or if the <code>process.noDeprecation</code> property is set to <code>true</code> <em>prior</em> to\nthe first deprecation warning, the <code>util.deprecate()</code> method does nothing.</p>\n<p>If the <code>--trace-deprecation</code> or <code>--trace-warnings</code> command line flags are set,\nor the <code>process.traceDeprecation</code> property is set to <code>true</code>, a warning and a\nstack trace are printed to <code>stderr</code> the first time the deprecated function is\ncalled.</p>\n<p>If the <code>--throw-deprecation</code> command line flag is set, or the\n<code>process.throwDeprecation</code> property is set to <code>true</code>, then an exception will be\nthrown when the deprecated function is called.</p>\n<p>The <code>--throw-deprecation</code> command line flag and <code>process.throwDeprecation</code>\nproperty take precedence over <code>--trace-deprecation</code> and\n<code>process.traceDeprecation</code>.</p>"
+          "desc": "<p>The <code>util.deprecate()</code> method wraps <code>fn</code> (which may be a function or class) in\nsuch a way that it is marked as deprecated.</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nexports.obsoleteFunction = util.deprecate(() => {\n  // Do something here.\n}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');\n</code></pre>\n<p>When called, <code>util.deprecate()</code> will return a function that will emit a\n<code>DeprecationWarning</code> using the <a href=\"process.html#process_event_warning\"><code>'warning'</code></a> event. The warning will\nbe emitted and printed to <code>stderr</code> the first time the returned function is\ncalled. After the warning is emitted, the wrapped function is called without\nemitting a warning.</p>\n<p>If the same optional <code>code</code> is supplied in multiple calls to <code>util.deprecate()</code>,\nthe warning will be emitted only once for that <code>code</code>.</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');\nconst fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');\nfn1(); // Emits a deprecation warning with code DEP0001\nfn2(); // Does not emit a deprecation warning because it has the same code\n</code></pre>\n<p>If either the <code>--no-deprecation</code> or <code>--no-warnings</code> command-line flags are\nused, or if the <code>process.noDeprecation</code> property is set to <code>true</code> <em>prior</em> to\nthe first deprecation warning, the <code>util.deprecate()</code> method does nothing.</p>\n<p>If the <code>--trace-deprecation</code> or <code>--trace-warnings</code> command-line flags are set,\nor the <code>process.traceDeprecation</code> property is set to <code>true</code>, a warning and a\nstack trace are printed to <code>stderr</code> the first time the deprecated function is\ncalled.</p>\n<p>If the <code>--throw-deprecation</code> command-line flag is set, or the\n<code>process.throwDeprecation</code> property is set to <code>true</code>, then an exception will be\nthrown when the deprecated function is called.</p>\n<p>The <code>--throw-deprecation</code> command-line flag and <code>process.throwDeprecation</code>\nproperty take precedence over <code>--trace-deprecation</code> and\n<code>process.traceDeprecation</code>.</p>"
         },
         {
           "textRaw": "`util.format(format[, ...args])`",
@@ -138,11 +170,6 @@
                 "pr-url": "https://github.com/nodejs/node/pull/29606",
                 "description": "The `%c` specifier is ignored now."
               },
-              {
-                "version": "v11.4.0",
-                "pr-url": "https://github.com/nodejs/node/pull/23708",
-                "description": "The `%d`, `%f` and `%i` specifiers now support Symbols properly."
-              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/23162",
@@ -153,6 +180,11 @@
                 "pr-url": "https://github.com/nodejs/node/pull/23162",
                 "description": "If the `format` argument is not a format string, the output string's formatting is no longer dependent on the type of the first argument. This change removes previously present quotes from strings that were being output when the first argument was not a string."
               },
+              {
+                "version": "v11.4.0",
+                "pr-url": "https://github.com/nodejs/node/pull/23708",
+                "description": "The `%d`, `%f` and `%i` specifiers now support Symbols properly."
+              },
               {
                 "version": "v11.4.0",
                 "pr-url": "https://github.com/nodejs/node/pull/24806",
@@ -245,6 +277,28 @@
           ],
           "desc": "<p>Returns the string name for a numeric error code that comes from a Node.js API.\nThe mapping between error codes and error names is platform-dependent.\nSee <a href=\"errors.html#errors_common_system_errors\">Common System Errors</a> for the names of common errors.</p>\n<pre><code class=\"language-js\">fs.access('file/that/does/not/exist', (err) => {\n  const name = util.getSystemErrorName(err.errno);\n  console.error(name);  // ENOENT\n});\n</code></pre>"
         },
+        {
+          "textRaw": "`util.getSystemErrorMap()`",
+          "type": "method",
+          "name": "getSystemErrorMap",
+          "meta": {
+            "added": [
+              "v14.17.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {Map}",
+                "name": "return",
+                "type": "Map"
+              },
+              "params": []
+            }
+          ],
+          "desc": "<p>Returns a Map of all system error codes available from the Node.js API.\nThe mapping between error codes and error names is platform-dependent.\nSee <a href=\"errors.html#errors_common_system_errors\">Common System Errors</a> for the names of common errors.</p>\n<pre><code class=\"language-js\">fs.access('file/that/does/not/exist', (err) => {\n  const errorMap = util.getSystemErrorMap();\n  const name = errorMap.get(err.errno);\n  console.error(name);  // ENOENT\n});\n</code></pre>"
+        },
         {
           "textRaw": "`util.inherits(constructor, superConstructor)`",
           "type": "method",
@@ -261,6 +315,8 @@
               }
             ]
           },
+          "stability": 3,
+          "stabilityText": "Legacy: Use ES2015 class syntax and `extends` keyword instead.",
           "signatures": [
             {
               "params": [
@@ -297,30 +353,41 @@
                 "description": "If `object` is from a different `vm.Context` now, a custom inspection function on it will not receive context-specific arguments anymore."
               },
               {
-                "version": "v12.17.0",
+                "version": [
+                  "v13.13.0",
+                  "v12.17.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/32392",
                 "description": "The `maxStringLength` option is supported now."
               },
               {
-                "version": "v12.16.0",
+                "version": [
+                  "v13.5.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/30768",
                 "description": "User defined prototype properties are inspected in case `showHidden` is `true`."
               },
+              {
+                "version": "v13.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/27685",
+                "description": "Circular references now include a marker to the reference."
+              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/27109",
                 "description": "The `compact` options default is changed to `3` and the `breakLength` options default is changed to `80`."
               },
-              {
-                "version": "v11.11.0",
-                "pr-url": "https://github.com/nodejs/node/pull/26269",
-                "description": "The `compact` option accepts numbers for a new output mode."
-              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/24971",
                 "description": "Internal properties no longer appear in the context argument of a custom inspection function."
               },
+              {
+                "version": "v11.11.0",
+                "pr-url": "https://github.com/nodejs/node/pull/26269",
+                "description": "The `compact` option accepts numbers for a new output mode."
+              },
               {
                 "version": "v11.7.0",
                 "pr-url": "https://github.com/nodejs/node/pull/25006",
@@ -341,16 +408,16 @@
                 "pr-url": "https://github.com/nodejs/node/pull/22846",
                 "description": "The `depth` default changed to `20`."
               },
-              {
-                "version": "v10.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22788",
-                "description": "The `sorted` option is supported now."
-              },
               {
                 "version": "v11.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/22756",
                 "description": "The inspection output is now limited to about 128 MB. Data above that size will not be fully inspected."
               },
+              {
+                "version": "v10.12.0",
+                "pr-url": "https://github.com/nodejs/node/pull/22788",
+                "description": "The `sorted` option is supported now."
+              },
               {
                 "version": "v10.6.0",
                 "pr-url": "https://github.com/nodejs/node/pull/20725",
@@ -489,7 +556,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>util.inspect()</code> method returns a string representation of <code>object</code> that is\nintended for debugging. The output of <code>util.inspect</code> may change at any time\nand should not be depended upon programmatically. Additional <code>options</code> may be\npassed that alter the result.\n<code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make\nan identifiable tag for an inspected value.</p>\n<pre><code class=\"language-js\">class Foo {\n  get [Symbol.toStringTag]() {\n    return 'bar';\n  }\n}\n\nclass Bar {}\n\nconst baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });\n\nutil.inspect(new Foo()); // 'Foo [bar] {}'\nutil.inspect(new Bar()); // 'Bar {}'\nutil.inspect(baz);       // '[foo] {}'\n</code></pre>\n<p>Circular references are marked as <code>'[Circular]'</code>:</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = {};\nobj.a = [obj];\nobj.b = {};\nobj.b.inner = obj.b;\nobj.b.obj = obj;\n\nconsole.log(inspect(obj));\n// {\n//   a: [ [Circular] ],\n//   b: { inner: [Circular], obj: [Circular] }\n// }\n</code></pre>\n<p>The following example inspects all properties of the <code>util</code> object:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));\n</code></pre>\n<p>The following example highlights the effect of the <code>compact</code> option:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst o = {\n  a: [1, 2, [[\n    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +\n      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',\n    'test',\n    'foo']], 4],\n  b: new Map([['za', 1], ['zb', 'test']])\n};\nconsole.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));\n\n// { a:\n//   [ 1,\n//     2,\n//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line\n//           'test',\n//           'foo' ] ],\n//     4 ],\n//   b: Map { 'za' => 1, 'zb' => 'test' } }\n\n// Setting `compact` to false changes the output to be more reader friendly.\nconsole.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));\n\n// {\n//   a: [\n//     1,\n//     2,\n//     [\n//       [\n//         'Lorem ipsum dolor sit amet, consectetur ' +\n//           'adipiscing elit, sed do eiusmod tempor ' +\n//           'incididunt ut labore et dolore magna ' +\n//           'aliqua.,\n//         'test',\n//         'foo'\n//       ]\n//     ],\n//     4\n//   ],\n//   b: Map {\n//     'za' => 1,\n//     'zb' => 'test'\n//   }\n// }\n\n// Setting `breakLength` to e.g. 150 will print the \"Lorem ipsum\" text in a\n// single line.\n// Reducing the `breakLength` will split the \"Lorem ipsum\" text in smaller\n// chunks.\n</code></pre>\n<p>The <code>showHidden</code> option allows <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> entries to be\ninspected. If there are more entries than <code>maxArrayLength</code>, there is no\nguarantee which entries are displayed. That means retrieving the same\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> entries twice may result in different output. Furthermore, entries\nwith no remaining strong references may be garbage collected at any time.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = { a: 1 };\nconst obj2 = { b: 2 };\nconst weakSet = new WeakSet([obj, obj2]);\n\nconsole.log(inspect(weakSet, { showHidden: true }));\n// WeakSet { { a: 1 }, { b: 2 } }\n</code></pre>\n<p>The <code>sorted</code> option ensures that an object's property insertion order does not\nimpact the result of <code>util.inspect()</code>.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\nconst assert = require('assert');\n\nconst o1 = {\n  b: [2, 3, 1],\n  a: '`a` comes before `b`',\n  c: new Set([2, 3, 1])\n};\nconsole.log(inspect(o1, { sorted: true }));\n// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set { 1, 2, 3 } }\nconsole.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));\n// { c: Set { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }\n\nconst o2 = {\n  c: new Set([2, 1, 3]),\n  a: '`a` comes before `b`',\n  b: [2, 3, 1]\n};\nassert.strict.equal(\n  inspect(o1, { sorted: true }),\n  inspect(o2, { sorted: true })\n);\n</code></pre>\n<p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum\noutput length is approximately 128 MB. Inputs that result in longer output will\nbe truncated.</p>"
+          "desc": "<p>The <code>util.inspect()</code> method returns a string representation of <code>object</code> that is\nintended for debugging. The output of <code>util.inspect</code> may change at any time\nand should not be depended upon programmatically. Additional <code>options</code> may be\npassed that alter the result.\n<code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make\nan identifiable tag for an inspected value.</p>\n<pre><code class=\"language-js\">class Foo {\n  get [Symbol.toStringTag]() {\n    return 'bar';\n  }\n}\n\nclass Bar {}\n\nconst baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });\n\nutil.inspect(new Foo()); // 'Foo [bar] {}'\nutil.inspect(new Bar()); // 'Bar {}'\nutil.inspect(baz);       // '[foo] {}'\n</code></pre>\n<p>Circular references point to their anchor by using a reference index:</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = {};\nobj.a = [obj];\nobj.b = {};\nobj.b.inner = obj.b;\nobj.b.obj = obj;\n\nconsole.log(inspect(obj));\n// &#x3C;ref *1> {\n//   a: [ [Circular *1] ],\n//   b: &#x3C;ref *2> { inner: [Circular *2], obj: [Circular *1] }\n// }\n</code></pre>\n<p>The following example inspects all properties of the <code>util</code> object:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));\n</code></pre>\n<p>The following example highlights the effect of the <code>compact</code> option:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst o = {\n  a: [1, 2, [[\n    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +\n      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',\n    'test',\n    'foo']], 4],\n  b: new Map([['za', 1], ['zb', 'test']])\n};\nconsole.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));\n\n// { a:\n//   [ 1,\n//     2,\n//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line\n//           'test',\n//           'foo' ] ],\n//     4 ],\n//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }\n\n// Setting `compact` to false changes the output to be more reader friendly.\nconsole.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));\n\n// {\n//   a: [\n//     1,\n//     2,\n//     [\n//       [\n//         'Lorem ipsum dolor sit amet, consectetur ' +\n//           'adipiscing elit, sed do eiusmod tempor ' +\n//           'incididunt ut labore et dolore magna ' +\n//           'aliqua.,\n//         'test',\n//         'foo'\n//       ]\n//     ],\n//     4\n//   ],\n//   b: Map(2) {\n//     'za' => 1,\n//     'zb' => 'test'\n//   }\n// }\n\n// Setting `breakLength` to e.g. 150 will print the \"Lorem ipsum\" text in a\n// single line.\n// Reducing the `breakLength` will split the \"Lorem ipsum\" text in smaller\n// chunks.\n</code></pre>\n<p>The <code>showHidden</code> option allows <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> entries to be\ninspected. If there are more entries than <code>maxArrayLength</code>, there is no\nguarantee which entries are displayed. That means retrieving the same\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> entries twice may result in different output. Furthermore, entries\nwith no remaining strong references may be garbage collected at any time.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = { a: 1 };\nconst obj2 = { b: 2 };\nconst weakSet = new WeakSet([obj, obj2]);\n\nconsole.log(inspect(weakSet, { showHidden: true }));\n// WeakSet { { a: 1 }, { b: 2 } }\n</code></pre>\n<p>The <code>sorted</code> option ensures that an object's property insertion order does not\nimpact the result of <code>util.inspect()</code>.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\nconst assert = require('assert');\n\nconst o1 = {\n  b: [2, 3, 1],\n  a: '`a` comes before `b`',\n  c: new Set([2, 3, 1])\n};\nconsole.log(inspect(o1, { sorted: true }));\n// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }\nconsole.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));\n// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }\n\nconst o2 = {\n  c: new Set([2, 1, 3]),\n  a: '`a` comes before `b`',\n  b: [2, 3, 1]\n};\nassert.strict.equal(\n  inspect(o1, { sorted: true }),\n  inspect(o2, { sorted: true })\n);\n</code></pre>\n<p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum\noutput length is approximately 128 MB. Inputs that result in longer output will\nbe truncated.</p>"
         },
         {
           "textRaw": "`util.inspect(object[, showHidden[, depth[, colors]]])`",
@@ -509,30 +576,41 @@
                 "description": "If `object` is from a different `vm.Context` now, a custom inspection function on it will not receive context-specific arguments anymore."
               },
               {
-                "version": "v12.17.0",
+                "version": [
+                  "v13.13.0",
+                  "v12.17.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/32392",
                 "description": "The `maxStringLength` option is supported now."
               },
               {
-                "version": "v12.16.0",
+                "version": [
+                  "v13.5.0",
+                  "v12.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/30768",
                 "description": "User defined prototype properties are inspected in case `showHidden` is `true`."
               },
+              {
+                "version": "v13.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/27685",
+                "description": "Circular references now include a marker to the reference."
+              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/27109",
                 "description": "The `compact` options default is changed to `3` and the `breakLength` options default is changed to `80`."
               },
-              {
-                "version": "v11.11.0",
-                "pr-url": "https://github.com/nodejs/node/pull/26269",
-                "description": "The `compact` option accepts numbers for a new output mode."
-              },
               {
                 "version": "v12.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/24971",
                 "description": "Internal properties no longer appear in the context argument of a custom inspection function."
               },
+              {
+                "version": "v11.11.0",
+                "pr-url": "https://github.com/nodejs/node/pull/26269",
+                "description": "The `compact` option accepts numbers for a new output mode."
+              },
               {
                 "version": "v11.7.0",
                 "pr-url": "https://github.com/nodejs/node/pull/25006",
@@ -553,16 +631,16 @@
                 "pr-url": "https://github.com/nodejs/node/pull/22846",
                 "description": "The `depth` default changed to `20`."
               },
-              {
-                "version": "v10.12.0",
-                "pr-url": "https://github.com/nodejs/node/pull/22788",
-                "description": "The `sorted` option is supported now."
-              },
               {
                 "version": "v11.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/22756",
                 "description": "The inspection output is now limited to about 128 MB. Data above that size will not be fully inspected."
               },
+              {
+                "version": "v10.12.0",
+                "pr-url": "https://github.com/nodejs/node/pull/22788",
+                "description": "The `sorted` option is supported now."
+              },
               {
                 "version": "v10.6.0",
                 "pr-url": "https://github.com/nodejs/node/pull/20725",
@@ -701,7 +779,7 @@
               ]
             }
           ],
-          "desc": "<p>The <code>util.inspect()</code> method returns a string representation of <code>object</code> that is\nintended for debugging. The output of <code>util.inspect</code> may change at any time\nand should not be depended upon programmatically. Additional <code>options</code> may be\npassed that alter the result.\n<code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make\nan identifiable tag for an inspected value.</p>\n<pre><code class=\"language-js\">class Foo {\n  get [Symbol.toStringTag]() {\n    return 'bar';\n  }\n}\n\nclass Bar {}\n\nconst baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });\n\nutil.inspect(new Foo()); // 'Foo [bar] {}'\nutil.inspect(new Bar()); // 'Bar {}'\nutil.inspect(baz);       // '[foo] {}'\n</code></pre>\n<p>Circular references are marked as <code>'[Circular]'</code>:</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = {};\nobj.a = [obj];\nobj.b = {};\nobj.b.inner = obj.b;\nobj.b.obj = obj;\n\nconsole.log(inspect(obj));\n// {\n//   a: [ [Circular] ],\n//   b: { inner: [Circular], obj: [Circular] }\n// }\n</code></pre>\n<p>The following example inspects all properties of the <code>util</code> object:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));\n</code></pre>\n<p>The following example highlights the effect of the <code>compact</code> option:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst o = {\n  a: [1, 2, [[\n    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +\n      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',\n    'test',\n    'foo']], 4],\n  b: new Map([['za', 1], ['zb', 'test']])\n};\nconsole.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));\n\n// { a:\n//   [ 1,\n//     2,\n//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line\n//           'test',\n//           'foo' ] ],\n//     4 ],\n//   b: Map { 'za' => 1, 'zb' => 'test' } }\n\n// Setting `compact` to false changes the output to be more reader friendly.\nconsole.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));\n\n// {\n//   a: [\n//     1,\n//     2,\n//     [\n//       [\n//         'Lorem ipsum dolor sit amet, consectetur ' +\n//           'adipiscing elit, sed do eiusmod tempor ' +\n//           'incididunt ut labore et dolore magna ' +\n//           'aliqua.,\n//         'test',\n//         'foo'\n//       ]\n//     ],\n//     4\n//   ],\n//   b: Map {\n//     'za' => 1,\n//     'zb' => 'test'\n//   }\n// }\n\n// Setting `breakLength` to e.g. 150 will print the \"Lorem ipsum\" text in a\n// single line.\n// Reducing the `breakLength` will split the \"Lorem ipsum\" text in smaller\n// chunks.\n</code></pre>\n<p>The <code>showHidden</code> option allows <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> entries to be\ninspected. If there are more entries than <code>maxArrayLength</code>, there is no\nguarantee which entries are displayed. That means retrieving the same\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> entries twice may result in different output. Furthermore, entries\nwith no remaining strong references may be garbage collected at any time.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = { a: 1 };\nconst obj2 = { b: 2 };\nconst weakSet = new WeakSet([obj, obj2]);\n\nconsole.log(inspect(weakSet, { showHidden: true }));\n// WeakSet { { a: 1 }, { b: 2 } }\n</code></pre>\n<p>The <code>sorted</code> option ensures that an object's property insertion order does not\nimpact the result of <code>util.inspect()</code>.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\nconst assert = require('assert');\n\nconst o1 = {\n  b: [2, 3, 1],\n  a: '`a` comes before `b`',\n  c: new Set([2, 3, 1])\n};\nconsole.log(inspect(o1, { sorted: true }));\n// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set { 1, 2, 3 } }\nconsole.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));\n// { c: Set { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }\n\nconst o2 = {\n  c: new Set([2, 1, 3]),\n  a: '`a` comes before `b`',\n  b: [2, 3, 1]\n};\nassert.strict.equal(\n  inspect(o1, { sorted: true }),\n  inspect(o2, { sorted: true })\n);\n</code></pre>\n<p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum\noutput length is approximately 128 MB. Inputs that result in longer output will\nbe truncated.</p>",
+          "desc": "<p>The <code>util.inspect()</code> method returns a string representation of <code>object</code> that is\nintended for debugging. The output of <code>util.inspect</code> may change at any time\nand should not be depended upon programmatically. Additional <code>options</code> may be\npassed that alter the result.\n<code>util.inspect()</code> will use the constructor's name and/or <code>@@toStringTag</code> to make\nan identifiable tag for an inspected value.</p>\n<pre><code class=\"language-js\">class Foo {\n  get [Symbol.toStringTag]() {\n    return 'bar';\n  }\n}\n\nclass Bar {}\n\nconst baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });\n\nutil.inspect(new Foo()); // 'Foo [bar] {}'\nutil.inspect(new Bar()); // 'Bar {}'\nutil.inspect(baz);       // '[foo] {}'\n</code></pre>\n<p>Circular references point to their anchor by using a reference index:</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = {};\nobj.a = [obj];\nobj.b = {};\nobj.b.inner = obj.b;\nobj.b.obj = obj;\n\nconsole.log(inspect(obj));\n// &#x3C;ref *1> {\n//   a: [ [Circular *1] ],\n//   b: &#x3C;ref *2> { inner: [Circular *2], obj: [Circular *1] }\n// }\n</code></pre>\n<p>The following example inspects all properties of the <code>util</code> object:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconsole.log(util.inspect(util, { showHidden: true, depth: null }));\n</code></pre>\n<p>The following example highlights the effect of the <code>compact</code> option:</p>\n<pre><code class=\"language-js\">const util = require('util');\n\nconst o = {\n  a: [1, 2, [[\n    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ' +\n      'eiusmod tempor incididunt ut labore et dolore magna aliqua.',\n    'test',\n    'foo']], 4],\n  b: new Map([['za', 1], ['zb', 'test']])\n};\nconsole.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));\n\n// { a:\n//   [ 1,\n//     2,\n//     [ [ 'Lorem ipsum dolor sit amet, consectetur [...]', // A long line\n//           'test',\n//           'foo' ] ],\n//     4 ],\n//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }\n\n// Setting `compact` to false changes the output to be more reader friendly.\nconsole.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));\n\n// {\n//   a: [\n//     1,\n//     2,\n//     [\n//       [\n//         'Lorem ipsum dolor sit amet, consectetur ' +\n//           'adipiscing elit, sed do eiusmod tempor ' +\n//           'incididunt ut labore et dolore magna ' +\n//           'aliqua.,\n//         'test',\n//         'foo'\n//       ]\n//     ],\n//     4\n//   ],\n//   b: Map(2) {\n//     'za' => 1,\n//     'zb' => 'test'\n//   }\n// }\n\n// Setting `breakLength` to e.g. 150 will print the \"Lorem ipsum\" text in a\n// single line.\n// Reducing the `breakLength` will split the \"Lorem ipsum\" text in smaller\n// chunks.\n</code></pre>\n<p>The <code>showHidden</code> option allows <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> entries to be\ninspected. If there are more entries than <code>maxArrayLength</code>, there is no\nguarantee which entries are displayed. That means retrieving the same\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> entries twice may result in different output. Furthermore, entries\nwith no remaining strong references may be garbage collected at any time.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\n\nconst obj = { a: 1 };\nconst obj2 = { b: 2 };\nconst weakSet = new WeakSet([obj, obj2]);\n\nconsole.log(inspect(weakSet, { showHidden: true }));\n// WeakSet { { a: 1 }, { b: 2 } }\n</code></pre>\n<p>The <code>sorted</code> option ensures that an object's property insertion order does not\nimpact the result of <code>util.inspect()</code>.</p>\n<pre><code class=\"language-js\">const { inspect } = require('util');\nconst assert = require('assert');\n\nconst o1 = {\n  b: [2, 3, 1],\n  a: '`a` comes before `b`',\n  c: new Set([2, 3, 1])\n};\nconsole.log(inspect(o1, { sorted: true }));\n// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }\nconsole.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));\n// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }\n\nconst o2 = {\n  c: new Set([2, 1, 3]),\n  a: '`a` comes before `b`',\n  b: [2, 3, 1]\n};\nassert.strict.equal(\n  inspect(o1, { sorted: true }),\n  inspect(o2, { sorted: true })\n);\n</code></pre>\n<p><code>util.inspect()</code> is a synchronous method intended for debugging. Its maximum\noutput length is approximately 128 MB. Inputs that result in longer output will\nbe truncated.</p>",
           "miscs": [
             {
               "textRaw": "Customizing `util.inspect` colors",
@@ -852,7 +930,10 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.16.2",
+                    "version": [
+                      "v13.12.0",
+                      "v12.16.2"
+                    ],
                     "pr-url": "https://github.com/nodejs/node/pull/31672",
                     "description": "This is now defined as a shared symbol."
                   }
@@ -862,6 +943,29 @@
               "shortDesc": "that can be used to declare custom promisified variants of functions, see [Custom promisified functions][]."
             }
           ]
+        },
+        {
+          "textRaw": "`util.toUSVString(string)`",
+          "type": "method",
+          "name": "toUSVString",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`string` {string}",
+                  "name": "string",
+                  "type": "string"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Returns the <code>string</code> after replacing any surrogate code points\n(or equivalently, any unpaired surrogate code units) with the\nUnicode \"replacement character\" U+FFFD.</p>"
         }
       ],
       "classes": [
@@ -880,28 +984,28 @@
             {
               "textRaw": "WHATWG supported encodings",
               "name": "whatwg_supported_encodings",
-              "desc": "<p>Per the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a>, the encodings supported by the\n<code>TextDecoder</code> API are outlined in the tables below. For each encoding,\none or more aliases may be used.</p>\n<p>Different Node.js build configurations support different sets of encodings.\nWhile a very basic set of encodings is supported even on Node.js builds without\nICU enabled, support for some encodings is provided only when Node.js is built\nwith ICU and using the full ICU data (see <a href=\"intl.html\">Internationalization</a>).</p>",
+              "desc": "<p>Per the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a>, the encodings supported by the\n<code>TextDecoder</code> API are outlined in the tables below. For each encoding,\none or more aliases may be used.</p>\n<p>Different Node.js build configurations support different sets of encodings.\n(see <a href=\"intl.html\">Internationalization</a>)</p>",
               "modules": [
                 {
-                  "textRaw": "Encodings Supported Without ICU",
-                  "name": "encodings_supported_without_icu",
-                  "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'utf-8'</code></td>\n<td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td>\n</tr>\n<tr>\n<td><code>'utf-16le'</code></td>\n<td><code>'utf-16'</code></td>\n</tr>\n</tbody>\n</table>",
+                  "textRaw": "Encodings supported by default (with full ICU data)",
+                  "name": "encodings_supported_by_default_(with_full_icu_data)",
+                  "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'ibm866'</code></td>\n<td><code>'866'</code>, <code>'cp866'</code>, <code>'csibm866'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-2'</code></td>\n<td><code>'csisolatin2'</code>, <code>'iso-ir-101'</code>, <code>'iso8859-2'</code>, <code>'iso88592'</code>, <code>'iso_8859-2'</code>, <code>'iso_8859-2:1987'</code>, <code>'l2'</code>, <code>'latin2'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-3'</code></td>\n<td><code>'csisolatin3'</code>, <code>'iso-ir-109'</code>, <code>'iso8859-3'</code>, <code>'iso88593'</code>, <code>'iso_8859-3'</code>, <code>'iso_8859-3:1988'</code>, <code>'l3'</code>, <code>'latin3'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-4'</code></td>\n<td><code>'csisolatin4'</code>, <code>'iso-ir-110'</code>, <code>'iso8859-4'</code>, <code>'iso88594'</code>, <code>'iso_8859-4'</code>, <code>'iso_8859-4:1988'</code>, <code>'l4'</code>, <code>'latin4'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-5'</code></td>\n<td><code>'csisolatincyrillic'</code>, <code>'cyrillic'</code>, <code>'iso-ir-144'</code>, <code>'iso8859-5'</code>, <code>'iso88595'</code>, <code>'iso_8859-5'</code>, <code>'iso_8859-5:1988'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-6'</code></td>\n<td><code>'arabic'</code>, <code>'asmo-708'</code>, <code>'csiso88596e'</code>, <code>'csiso88596i'</code>, <code>'csisolatinarabic'</code>, <code>'ecma-114'</code>, <code>'iso-8859-6-e'</code>, <code>'iso-8859-6-i'</code>, <code>'iso-ir-127'</code>, <code>'iso8859-6'</code>, <code>'iso88596'</code>, <code>'iso_8859-6'</code>, <code>'iso_8859-6:1987'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-7'</code></td>\n<td><code>'csisolatingreek'</code>, <code>'ecma-118'</code>, <code>'elot_928'</code>, <code>'greek'</code>, <code>'greek8'</code>, <code>'iso-ir-126'</code>, <code>'iso8859-7'</code>, <code>'iso88597'</code>, <code>'iso_8859-7'</code>, <code>'iso_8859-7:1987'</code>, <code>'sun_eu_greek'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-8'</code></td>\n<td><code>'csiso88598e'</code>, <code>'csisolatinhebrew'</code>, <code>'hebrew'</code>, <code>'iso-8859-8-e'</code>, <code>'iso-ir-138'</code>, <code>'iso8859-8'</code>, <code>'iso88598'</code>, <code>'iso_8859-8'</code>, <code>'iso_8859-8:1988'</code>, <code>'visual'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-8-i'</code></td>\n<td><code>'csiso88598i'</code>, <code>'logical'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-10'</code></td>\n<td><code>'csisolatin6'</code>, <code>'iso-ir-157'</code>, <code>'iso8859-10'</code>, <code>'iso885910'</code>, <code>'l6'</code>, <code>'latin6'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-13'</code></td>\n<td><code>'iso8859-13'</code>, <code>'iso885913'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-14'</code></td>\n<td><code>'iso8859-14'</code>, <code>'iso885914'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-15'</code></td>\n<td><code>'csisolatin9'</code>, <code>'iso8859-15'</code>, <code>'iso885915'</code>, <code>'iso_8859-15'</code>, <code>'l9'</code></td>\n</tr>\n<tr>\n<td><code>'koi8-r'</code></td>\n<td><code>'cskoi8r'</code>, <code>'koi'</code>, <code>'koi8'</code>, <code>'koi8_r'</code></td>\n</tr>\n<tr>\n<td><code>'koi8-u'</code></td>\n<td><code>'koi8-ru'</code></td>\n</tr>\n<tr>\n<td><code>'macintosh'</code></td>\n<td><code>'csmacintosh'</code>, <code>'mac'</code>, <code>'x-mac-roman'</code></td>\n</tr>\n<tr>\n<td><code>'windows-874'</code></td>\n<td><code>'dos-874'</code>, <code>'iso-8859-11'</code>, <code>'iso8859-11'</code>, <code>'iso885911'</code>, <code>'tis-620'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1250'</code></td>\n<td><code>'cp1250'</code>, <code>'x-cp1250'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1251'</code></td>\n<td><code>'cp1251'</code>, <code>'x-cp1251'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1252'</code></td>\n<td><code>'ansi_x3.4-1968'</code>, <code>'ascii'</code>, <code>'cp1252'</code>, <code>'cp819'</code>, <code>'csisolatin1'</code>, <code>'ibm819'</code>, <code>'iso-8859-1'</code>, <code>'iso-ir-100'</code>, <code>'iso8859-1'</code>, <code>'iso88591'</code>, <code>'iso_8859-1'</code>, <code>'iso_8859-1:1987'</code>, <code>'l1'</code>, <code>'latin1'</code>, <code>'us-ascii'</code>, <code>'x-cp1252'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1253'</code></td>\n<td><code>'cp1253'</code>, <code>'x-cp1253'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1254'</code></td>\n<td><code>'cp1254'</code>, <code>'csisolatin5'</code>, <code>'iso-8859-9'</code>, <code>'iso-ir-148'</code>, <code>'iso8859-9'</code>, <code>'iso88599'</code>, <code>'iso_8859-9'</code>, <code>'iso_8859-9:1989'</code>, <code>'l5'</code>, <code>'latin5'</code>, <code>'x-cp1254'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1255'</code></td>\n<td><code>'cp1255'</code>, <code>'x-cp1255'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1256'</code></td>\n<td><code>'cp1256'</code>, <code>'x-cp1256'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1257'</code></td>\n<td><code>'cp1257'</code>, <code>'x-cp1257'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1258'</code></td>\n<td><code>'cp1258'</code>, <code>'x-cp1258'</code></td>\n</tr>\n<tr>\n<td><code>'x-mac-cyrillic'</code></td>\n<td><code>'x-mac-ukrainian'</code></td>\n</tr>\n<tr>\n<td><code>'gbk'</code></td>\n<td><code>'chinese'</code>, <code>'csgb2312'</code>, <code>'csiso58gb231280'</code>, <code>'gb2312'</code>, <code>'gb_2312'</code>, <code>'gb_2312-80'</code>, <code>'iso-ir-58'</code>, <code>'x-gbk'</code></td>\n</tr>\n<tr>\n<td><code>'gb18030'</code></td>\n<td></td>\n</tr>\n<tr>\n<td><code>'big5'</code></td>\n<td><code>'big5-hkscs'</code>, <code>'cn-big5'</code>, <code>'csbig5'</code>, <code>'x-x-big5'</code></td>\n</tr>\n<tr>\n<td><code>'euc-jp'</code></td>\n<td><code>'cseucpkdfmtjapanese'</code>, <code>'x-euc-jp'</code></td>\n</tr>\n<tr>\n<td><code>'iso-2022-jp'</code></td>\n<td><code>'csiso2022jp'</code></td>\n</tr>\n<tr>\n<td><code>'shift_jis'</code></td>\n<td><code>'csshiftjis'</code>, <code>'ms932'</code>, <code>'ms_kanji'</code>, <code>'shift-jis'</code>, <code>'sjis'</code>, <code>'windows-31j'</code>, <code>'x-sjis'</code></td>\n</tr>\n<tr>\n<td><code>'euc-kr'</code></td>\n<td><code>'cseuckr'</code>, <code>'csksc56011987'</code>, <code>'iso-ir-149'</code>, <code>'korean'</code>, <code>'ks_c_5601-1987'</code>, <code>'ks_c_5601-1989'</code>, <code>'ksc5601'</code>, <code>'ksc_5601'</code>, <code>'windows-949'</code></td>\n</tr>\n</tbody>\n</table>",
                   "type": "module",
-                  "displayName": "Encodings Supported Without ICU"
+                  "displayName": "Encodings supported by default (with full ICU data)"
                 },
                 {
-                  "textRaw": "Encodings Supported by Default (With ICU)",
-                  "name": "encodings_supported_by_default_(with_icu)",
+                  "textRaw": "Encodings supported when Node.js is built with the `small-icu` option",
+                  "name": "encodings_supported_when_node.js_is_built_with_the_`small-icu`_option",
                   "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'utf-8'</code></td>\n<td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td>\n</tr>\n<tr>\n<td><code>'utf-16le'</code></td>\n<td><code>'utf-16'</code></td>\n</tr>\n<tr>\n<td><code>'utf-16be'</code></td>\n<td></td>\n</tr>\n</tbody>\n</table>",
                   "type": "module",
-                  "displayName": "Encodings Supported by Default (With ICU)"
+                  "displayName": "Encodings supported when Node.js is built with the `small-icu` option"
                 },
                 {
-                  "textRaw": "Encodings requiring full ICU data",
-                  "name": "encodings_requiring_full_icu_data",
-                  "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'ibm866'</code></td>\n<td><code>'866'</code>, <code>'cp866'</code>, <code>'csibm866'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-2'</code></td>\n<td><code>'csisolatin2'</code>, <code>'iso-ir-101'</code>, <code>'iso8859-2'</code>, <code>'iso88592'</code>, <code>'iso_8859-2'</code>, <code>'iso_8859-2:1987'</code>, <code>'l2'</code>, <code>'latin2'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-3'</code></td>\n<td><code>'csisolatin3'</code>, <code>'iso-ir-109'</code>, <code>'iso8859-3'</code>, <code>'iso88593'</code>, <code>'iso_8859-3'</code>, <code>'iso_8859-3:1988'</code>, <code>'l3'</code>, <code>'latin3'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-4'</code></td>\n<td><code>'csisolatin4'</code>, <code>'iso-ir-110'</code>, <code>'iso8859-4'</code>, <code>'iso88594'</code>, <code>'iso_8859-4'</code>, <code>'iso_8859-4:1988'</code>, <code>'l4'</code>, <code>'latin4'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-5'</code></td>\n<td><code>'csisolatincyrillic'</code>, <code>'cyrillic'</code>, <code>'iso-ir-144'</code>, <code>'iso8859-5'</code>, <code>'iso88595'</code>, <code>'iso_8859-5'</code>, <code>'iso_8859-5:1988'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-6'</code></td>\n<td><code>'arabic'</code>, <code>'asmo-708'</code>, <code>'csiso88596e'</code>, <code>'csiso88596i'</code>, <code>'csisolatinarabic'</code>, <code>'ecma-114'</code>, <code>'iso-8859-6-e'</code>, <code>'iso-8859-6-i'</code>, <code>'iso-ir-127'</code>, <code>'iso8859-6'</code>, <code>'iso88596'</code>, <code>'iso_8859-6'</code>, <code>'iso_8859-6:1987'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-7'</code></td>\n<td><code>'csisolatingreek'</code>, <code>'ecma-118'</code>, <code>'elot_928'</code>, <code>'greek'</code>, <code>'greek8'</code>, <code>'iso-ir-126'</code>, <code>'iso8859-7'</code>, <code>'iso88597'</code>, <code>'iso_8859-7'</code>, <code>'iso_8859-7:1987'</code>, <code>'sun_eu_greek'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-8'</code></td>\n<td><code>'csiso88598e'</code>, <code>'csisolatinhebrew'</code>, <code>'hebrew'</code>, <code>'iso-8859-8-e'</code>, <code>'iso-ir-138'</code>, <code>'iso8859-8'</code>, <code>'iso88598'</code>, <code>'iso_8859-8'</code>, <code>'iso_8859-8:1988'</code>, <code>'visual'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-8-i'</code></td>\n<td><code>'csiso88598i'</code>, <code>'logical'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-10'</code></td>\n<td><code>'csisolatin6'</code>, <code>'iso-ir-157'</code>, <code>'iso8859-10'</code>, <code>'iso885910'</code>, <code>'l6'</code>, <code>'latin6'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-13'</code></td>\n<td><code>'iso8859-13'</code>, <code>'iso885913'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-14'</code></td>\n<td><code>'iso8859-14'</code>, <code>'iso885914'</code></td>\n</tr>\n<tr>\n<td><code>'iso-8859-15'</code></td>\n<td><code>'csisolatin9'</code>, <code>'iso8859-15'</code>, <code>'iso885915'</code>, <code>'iso_8859-15'</code>, <code>'l9'</code></td>\n</tr>\n<tr>\n<td><code>'koi8-r'</code></td>\n<td><code>'cskoi8r'</code>, <code>'koi'</code>, <code>'koi8'</code>, <code>'koi8_r'</code></td>\n</tr>\n<tr>\n<td><code>'koi8-u'</code></td>\n<td><code>'koi8-ru'</code></td>\n</tr>\n<tr>\n<td><code>'macintosh'</code></td>\n<td><code>'csmacintosh'</code>, <code>'mac'</code>, <code>'x-mac-roman'</code></td>\n</tr>\n<tr>\n<td><code>'windows-874'</code></td>\n<td><code>'dos-874'</code>, <code>'iso-8859-11'</code>, <code>'iso8859-11'</code>, <code>'iso885911'</code>, <code>'tis-620'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1250'</code></td>\n<td><code>'cp1250'</code>, <code>'x-cp1250'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1251'</code></td>\n<td><code>'cp1251'</code>, <code>'x-cp1251'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1252'</code></td>\n<td><code>'ansi_x3.4-1968'</code>, <code>'ascii'</code>, <code>'cp1252'</code>, <code>'cp819'</code>, <code>'csisolatin1'</code>, <code>'ibm819'</code>, <code>'iso-8859-1'</code>, <code>'iso-ir-100'</code>, <code>'iso8859-1'</code>, <code>'iso88591'</code>, <code>'iso_8859-1'</code>, <code>'iso_8859-1:1987'</code>, <code>'l1'</code>, <code>'latin1'</code>, <code>'us-ascii'</code>, <code>'x-cp1252'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1253'</code></td>\n<td><code>'cp1253'</code>, <code>'x-cp1253'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1254'</code></td>\n<td><code>'cp1254'</code>, <code>'csisolatin5'</code>, <code>'iso-8859-9'</code>, <code>'iso-ir-148'</code>, <code>'iso8859-9'</code>, <code>'iso88599'</code>, <code>'iso_8859-9'</code>, <code>'iso_8859-9:1989'</code>, <code>'l5'</code>, <code>'latin5'</code>, <code>'x-cp1254'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1255'</code></td>\n<td><code>'cp1255'</code>, <code>'x-cp1255'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1256'</code></td>\n<td><code>'cp1256'</code>, <code>'x-cp1256'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1257'</code></td>\n<td><code>'cp1257'</code>, <code>'x-cp1257'</code></td>\n</tr>\n<tr>\n<td><code>'windows-1258'</code></td>\n<td><code>'cp1258'</code>, <code>'x-cp1258'</code></td>\n</tr>\n<tr>\n<td><code>'x-mac-cyrillic'</code></td>\n<td><code>'x-mac-ukrainian'</code></td>\n</tr>\n<tr>\n<td><code>'gbk'</code></td>\n<td><code>'chinese'</code>, <code>'csgb2312'</code>, <code>'csiso58gb231280'</code>, <code>'gb2312'</code>, <code>'gb_2312'</code>, <code>'gb_2312-80'</code>, <code>'iso-ir-58'</code>, <code>'x-gbk'</code></td>\n</tr>\n<tr>\n<td><code>'gb18030'</code></td>\n<td></td>\n</tr>\n<tr>\n<td><code>'big5'</code></td>\n<td><code>'big5-hkscs'</code>, <code>'cn-big5'</code>, <code>'csbig5'</code>, <code>'x-x-big5'</code></td>\n</tr>\n<tr>\n<td><code>'euc-jp'</code></td>\n<td><code>'cseucpkdfmtjapanese'</code>, <code>'x-euc-jp'</code></td>\n</tr>\n<tr>\n<td><code>'iso-2022-jp'</code></td>\n<td><code>'csiso2022jp'</code></td>\n</tr>\n<tr>\n<td><code>'shift_jis'</code></td>\n<td><code>'csshiftjis'</code>, <code>'ms932'</code>, <code>'ms_kanji'</code>, <code>'shift-jis'</code>, <code>'sjis'</code>, <code>'windows-31j'</code>, <code>'x-sjis'</code></td>\n</tr>\n<tr>\n<td><code>'euc-kr'</code></td>\n<td><code>'cseuckr'</code>, <code>'csksc56011987'</code>, <code>'iso-ir-149'</code>, <code>'korean'</code>, <code>'ks_c_5601-1987'</code>, <code>'ks_c_5601-1989'</code>, <code>'ksc5601'</code>, <code>'ksc_5601'</code>, <code>'windows-949'</code></td>\n</tr>\n</tbody>\n</table>\n<p>The <code>'iso-8859-16'</code> encoding listed in the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a>\nis not supported.</p>",
+                  "textRaw": "Encodings supported when ICU is disabled",
+                  "name": "encodings_supported_when_icu_is_disabled",
+                  "desc": "<table>\n<thead>\n<tr>\n<th>Encoding</th>\n<th>Aliases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>'utf-8'</code></td>\n<td><code>'unicode-1-1-utf-8'</code>, <code>'utf8'</code></td>\n</tr>\n<tr>\n<td><code>'utf-16le'</code></td>\n<td><code>'utf-16'</code></td>\n</tr>\n</tbody>\n</table>\n<p>The <code>'iso-8859-16'</code> encoding listed in the <a href=\"https://encoding.spec.whatwg.org/\">WHATWG Encoding Standard</a>\nis not supported.</p>",
                   "type": "module",
-                  "displayName": "Encodings requiring full ICU data"
+                  "displayName": "Encodings supported when ICU is disabled"
                 }
               ],
               "type": "module",
@@ -983,11 +1087,11 @@
                   "type": "Object",
                   "options": [
                     {
-                      "textRaw": "`fatal` {boolean} `true` if decoding failures are fatal. This option is only supported when ICU is enabled (see [Internationalization][]). **Default:** `false`.",
+                      "textRaw": "`fatal` {boolean} `true` if decoding failures are fatal. This option is not supported when ICU is disabled (see [Internationalization][]). **Default:** `false`.",
                       "name": "fatal",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "`true` if decoding failures are fatal. This option is only supported when ICU is enabled (see [Internationalization][])."
+                      "desc": "`true` if decoding failures are fatal. This option is not supported when ICU is disabled (see [Internationalization][])."
                     },
                     {
                       "textRaw": "`ignoreBOM` {boolean} When `true`, the `TextDecoder` will include the byte order mark in the decoded result. When `false`, the byte order mark will be removed from the output. This option is only used when `encoding` is `'utf-8'`, `'utf-16be'` or `'utf-16le'`. **Default:** `false`.",
@@ -1014,7 +1118,7 @@
             "changes": [
               {
                 "version": "v11.0.0",
-                "pr-url": "v11.0.0",
+                "pr-url": "https://github.com/nodejs/node/pull/22281",
                 "description": "The class is now available on the global object."
               }
             ]
@@ -2211,8 +2315,13 @@
                 "added": [
                   "v10.0.0"
                 ],
+                "deprecated": [
+                  "v14.0.0"
+                ],
                 "changes": []
               },
+              "stability": 0,
+              "stabilityText": "Deprecated: Use `value instanceof WebAssembly.Module` instead.",
               "signatures": [
                 {
                   "return": {
diff --git a/doc/api/util.md b/doc/api/util.md
index 2daf57679b708a8cb9d8c98e42c0f13800a1cc33..63e4789e0628f2a902091d956da2888c8b60ddae 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -78,7 +78,7 @@ added: v0.11.3
 * `section` {string} A string identifying the portion of the application for
   which the `debuglog` function is being created.
 * `callback` {Function} A callback invoked the first time the logging function
-is called with a function argument that is a more optimized logging function.
+  is called with a function argument that is a more optimized logging function.
 * Returns: {Function} The logging function
 
 The `util.debuglog()` method is used to create a function that conditionally
@@ -136,6 +136,42 @@ let debuglog = util.debuglog('internals', (debug) => {
 });
 ```
 
+### `debuglog().enabled`
+<!-- YAML
+added: v14.9.0
+-->
+
+* {boolean}
+
+The `util.debuglog().enabled` getter is used to create a test that can be used
+in conditionals based on the existence of the `NODE_DEBUG` environment variable.
+If the `section` name appears within the value of that environment variable,
+then the returned value will be `true`. If not, then the returned value will be
+`false`.
+
+```js
+const util = require('util');
+const enabled = util.debuglog('foo').enabled;
+if (enabled) {
+  console.log('hello from foo [%d]', 123);
+}
+```
+
+If this program is run with `NODE_DEBUG=foo` in the environment, then it will
+output something like:
+
+```console
+hello from foo [123]
+```
+
+## `util.debug(section)`
+<!-- YAML
+added: v14.9.0
+-->
+
+Alias for `util.debuglog`. Usage allows for readability of that doesn't imply
+logging when only using `util.debuglog().enabled`.
+
 ## `util.deprecate(fn, msg[, code])`
 <!-- YAML
 added: v0.8.0
@@ -181,20 +217,20 @@ fn1(); // Emits a deprecation warning with code DEP0001
 fn2(); // Does not emit a deprecation warning because it has the same code
 ```
 
-If either the `--no-deprecation` or `--no-warnings` command line flags are
+If either the `--no-deprecation` or `--no-warnings` command-line flags are
 used, or if the `process.noDeprecation` property is set to `true` *prior* to
 the first deprecation warning, the `util.deprecate()` method does nothing.
 
-If the `--trace-deprecation` or `--trace-warnings` command line flags are set,
+If the `--trace-deprecation` or `--trace-warnings` command-line flags are set,
 or the `process.traceDeprecation` property is set to `true`, a warning and a
 stack trace are printed to `stderr` the first time the deprecated function is
 called.
 
-If the `--throw-deprecation` command line flag is set, or the
+If the `--throw-deprecation` command-line flag is set, or the
 `process.throwDeprecation` property is set to `true`, then an exception will be
 thrown when the deprecated function is called.
 
-The `--throw-deprecation` command line flag and `process.throwDeprecation`
+The `--throw-deprecation` command-line flag and `process.throwDeprecation`
 property take precedence over `--trace-deprecation` and
 `process.traceDeprecation`.
 
@@ -205,10 +241,6 @@ changes:
   - version: v12.11.0
     pr-url: https://github.com/nodejs/node/pull/29606
     description: The `%c` specifier is ignored now.
-  - version: v11.4.0
-    pr-url: https://github.com/nodejs/node/pull/23708
-    description: The `%d`, `%f` and `%i` specifiers now support Symbols
-                 properly.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/23162
     description: The `format` argument is now only taken as such if it actually
@@ -220,6 +252,10 @@ changes:
                  first argument. This change removes previously present quotes
                  from strings that were being output when the first argument
                  was not a string.
+  - version: v11.4.0
+    pr-url: https://github.com/nodejs/node/pull/23708
+    description: The `%d`, `%f` and `%i` specifiers now support Symbols
+                 properly.
   - version: v11.4.0
     pr-url: https://github.com/nodejs/node/pull/24806
     description: The `%o` specifier's `depth` has default depth of 4 again.
@@ -340,6 +376,25 @@ fs.access('file/that/does/not/exist', (err) => {
 });
 ```
 
+## `util.getSystemErrorMap()`
+<!-- YAML
+added: v14.17.0
+-->
+
+* Returns: {Map}
+
+Returns a Map of all system error codes available from the Node.js API.
+The mapping between error codes and error names is platform-dependent.
+See [Common System Errors][] for the names of common errors.
+
+```js
+fs.access('file/that/does/not/exist', (err) => {
+  const errorMap = util.getSystemErrorMap();
+  const name = errorMap.get(err.errno);
+  console.error(name);  // ENOENT
+});
+```
+
 ## `util.inherits(constructor, superConstructor)`
 <!-- YAML
 added: v0.3.0
@@ -349,6 +404,8 @@ changes:
     description: The `constructor` parameter can refer to an ES6 class now.
 -->
 
+> Stability: 3 - Legacy: Use ES2015 class syntax and `extends` keyword instead.
+
 * `constructor` {Function}
 * `superConstructor` {Function}
 
@@ -421,24 +478,31 @@ changes:
     description: If `object` is from a different `vm.Context` now, a custom
                  inspection function on it will not receive context-specific
                  arguments anymore.
-  - version: v12.17.0
+  - version:
+     - v13.13.0
+     - v12.17.0
     pr-url: https://github.com/nodejs/node/pull/32392
     description: The `maxStringLength` option is supported now.
-  - version: v12.16.0
+  - version:
+     - v13.5.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30768
     description: User defined prototype properties are inspected in case
                  `showHidden` is `true`.
+  - version: v13.0.0
+    pr-url: https://github.com/nodejs/node/pull/27685
+    description: Circular references now include a marker to the reference.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/27109
     description: The `compact` options default is changed to `3` and the
                  `breakLength` options default is changed to `80`.
-  - version: v11.11.0
-    pr-url: https://github.com/nodejs/node/pull/26269
-    description: The `compact` option accepts numbers for a new output mode.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/24971
     description: Internal properties no longer appear in the context argument
                  of a custom inspection function.
+  - version: v11.11.0
+    pr-url: https://github.com/nodejs/node/pull/26269
+    description: The `compact` option accepts numbers for a new output mode.
   - version: v11.7.0
     pr-url: https://github.com/nodejs/node/pull/25006
     description: ArrayBuffers now also show their binary contents.
@@ -451,13 +515,13 @@ changes:
   - version: v11.0.0
     pr-url: https://github.com/nodejs/node/pull/22846
     description: The `depth` default changed to `20`.
-  - version: v10.12.0
-    pr-url: https://github.com/nodejs/node/pull/22788
-    description: The `sorted` option is supported now.
   - version: v11.0.0
     pr-url: https://github.com/nodejs/node/pull/22756
     description: The inspection output is now limited to about 128 MB. Data
                  above that size will not be fully inspected.
+  - version: v10.12.0
+    pr-url: https://github.com/nodejs/node/pull/22788
+    description: The `sorted` option is supported now.
   - version: v10.6.0
     pr-url: https://github.com/nodejs/node/pull/20725
     description: Inspecting linked lists and similar objects is now possible
@@ -554,7 +618,7 @@ util.inspect(new Bar()); // 'Bar {}'
 util.inspect(baz);       // '[foo] {}'
 ```
 
-Circular references are marked as `'[Circular]'`:
+Circular references point to their anchor by using a reference index:
 
 ```js
 const { inspect } = require('util');
@@ -566,9 +630,9 @@ obj.b.inner = obj.b;
 obj.b.obj = obj;
 
 console.log(inspect(obj));
-// {
-//   a: [ [Circular] ],
-//   b: { inner: [Circular], obj: [Circular] }
+// <ref *1> {
+//   a: [ [Circular *1] ],
+//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
 // }
 ```
 
@@ -602,7 +666,7 @@ console.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));
 //           'test',
 //           'foo' ] ],
 //     4 ],
-//   b: Map { 'za' => 1, 'zb' => 'test' } }
+//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }
 
 // Setting `compact` to false changes the output to be more reader friendly.
 console.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));
@@ -623,7 +687,7 @@ console.log(util.inspect(o, { compact: false, depth: 5, breakLength: 80 }));
 //     ],
 //     4
 //   ],
-//   b: Map {
+//   b: Map(2) {
 //     'za' => 1,
 //     'zb' => 'test'
 //   }
@@ -665,9 +729,9 @@ const o1 = {
   c: new Set([2, 3, 1])
 };
 console.log(inspect(o1, { sorted: true }));
-// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set { 1, 2, 3 } }
+// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
 console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
-// { c: Set { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }
+// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }
 
 const o2 = {
   c: new Set([2, 1, 3]),
@@ -1022,13 +1086,15 @@ throw an error.
 <!-- YAML
 added: v8.0.0
 changes:
-  - version: v12.16.2
+  - version:
+      - v13.12.0
+      - v12.16.2
     pr-url: https://github.com/nodejs/node/pull/31672
     description: This is now defined as a shared symbol.
 -->
 
 * {symbol} that can be used to declare custom promisified variants of functions,
-see [Custom promisified functions][].
+  see [Custom promisified functions][].
 
 In addition to being accessible through `util.promisify.custom`, this
 symbol is [registered globally][global symbol registry] and can be
@@ -1071,26 +1137,9 @@ Per the [WHATWG Encoding Standard][], the encodings supported by the
 one or more aliases may be used.
 
 Different Node.js build configurations support different sets of encodings.
-While a very basic set of encodings is supported even on Node.js builds without
-ICU enabled, support for some encodings is provided only when Node.js is built
-with ICU and using the full ICU data (see [Internationalization][]).
+(see [Internationalization][])
 
-#### Encodings Supported Without ICU
-
-| Encoding     | Aliases                           |
-| -----------  | --------------------------------- |
-| `'utf-8'`    | `'unicode-1-1-utf-8'`, `'utf8'`   |
-| `'utf-16le'` | `'utf-16'`                        |
-
-#### Encodings Supported by Default (With ICU)
-
-| Encoding     | Aliases                           |
-| -----------  | --------------------------------- |
-| `'utf-8'`    | `'unicode-1-1-utf-8'`, `'utf8'`   |
-| `'utf-16le'` | `'utf-16'`                        |
-| `'utf-16be'` |                                   |
-
-#### Encodings requiring full ICU data
+#### Encodings supported by default (with full ICU data)
 
 | Encoding           | Aliases                          |
 | -----------------  | -------------------------------- |
@@ -1129,6 +1178,21 @@ with ICU and using the full ICU data (see [Internationalization][]).
 | `'shift_jis'`      | `'csshiftjis'`, `'ms932'`, `'ms_kanji'`, `'shift-jis'`, `'sjis'`, `'windows-31j'`, `'x-sjis'` |
 | `'euc-kr'`         | `'cseuckr'`, `'csksc56011987'`, `'iso-ir-149'`, `'korean'`, `'ks_c_5601-1987'`, `'ks_c_5601-1989'`, `'ksc5601'`, `'ksc_5601'`, `'windows-949'` |
 
+#### Encodings supported when Node.js is built with the `small-icu` option
+
+| Encoding     | Aliases                         |
+| -----------  | ------------------------------- |
+| `'utf-8'`    | `'unicode-1-1-utf-8'`, `'utf8'` |
+| `'utf-16le'` | `'utf-16'`                      |
+| `'utf-16be'` |                                 |
+
+#### Encodings supported when ICU is disabled
+
+| Encoding     | Aliases                         |
+| -----------  | ------------------------------- |
+| `'utf-8'`    | `'unicode-1-1-utf-8'`, `'utf8'` |
+| `'utf-16le'` | `'utf-16'`                      |
+
 The `'iso-8859-16'` encoding listed in the [WHATWG Encoding Standard][]
 is not supported.
 
@@ -1137,16 +1201,16 @@ is not supported.
 added: v8.3.0
 changes:
   - version: v11.0.0
-    pr-url: v11.0.0
+    pr-url: https://github.com/nodejs/node/pull/22281
     description: The class is now available on the global object.
 -->
 
 * `encoding` {string} Identifies the `encoding` that this `TextDecoder` instance
   supports. **Default:** `'utf-8'`.
 * `options` {Object}
-  * `fatal` {boolean} `true` if decoding failures are fatal. This option is only
-    supported when ICU is enabled (see [Internationalization][]). **Default:**
-    `false`.
+  * `fatal` {boolean} `true` if decoding failures are fatal.
+    This option is not supported when ICU is disabled
+    (see [Internationalization][]). **Default:** `false`.
   * `ignoreBOM` {boolean} When `true`, the `TextDecoder` will include the byte
      order mark in the decoded result. When `false`, the byte order mark will
      be removed from the output. This option is only used when `encoding` is
@@ -1198,7 +1262,7 @@ mark.
 added: v8.3.0
 changes:
   - version: v11.0.0
-    pr-url: v11.0.0
+    pr-url: https://github.com/nodejs/node/pull/22281
     description: The class is now available on the global object.
 -->
 
@@ -1244,6 +1308,17 @@ const { read, written } = encoder.encodeInto(src, dest);
 
 The encoding supported by the `TextEncoder` instance. Always set to `'utf-8'`.
 
+## `util.toUSVString(string)`
+<!-- YAML
+added: v14.18.0
+-->
+
+* `string` {string}
+
+Returns the `string` after replacing any surrogate code points
+(or equivalently, any unpaired surrogate code units) with the
+Unicode "replacement character" U+FFFD.
+
 ## `util.types`
 <!-- YAML
 added: v10.0.0
@@ -1938,8 +2013,11 @@ util.types.isWeakSet(new WeakSet());  // Returns true
 ### `util.types.isWebAssemblyCompiledModule(value)`
 <!-- YAML
 added: v10.0.0
+deprecated: v14.0.0
 -->
 
+> Stability: 0 - Deprecated: Use `value instanceof WebAssembly.Module` instead.
+
 * `value` {any}
 * Returns: {boolean}
 
@@ -2401,15 +2479,22 @@ const util = require('util');
 util.log('Timestamped message.');
 ```
 
-[`'uncaughtException'`]: process.html#process_event_uncaughtexception
-[`'warning'`]: process.html#process_event_warning
+[Common System Errors]: errors.md#errors_common_system_errors
+[Custom inspection functions on objects]: #util_custom_inspection_functions_on_objects
+[Custom promisified functions]: #util_custom_promisified_functions
+[Customizing `util.inspect` colors]: #util_customizing_util_inspect_colors
+[Internationalization]: intl.md
+[Module Namespace Object]: https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects
+[WHATWG Encoding Standard]: https://encoding.spec.whatwg.org/
+[`'uncaughtException'`]: process.md#process_event_uncaughtexception
+[`'warning'`]: process.md#process_event_warning
 [`Array.isArray()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
 [`ArrayBuffer.isView()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView
 [`ArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
-[`Buffer.isBuffer()`]: buffer.html#buffer_static_method_buffer_isbuffer_obj
+[`Buffer.isBuffer()`]: buffer.md#buffer_static_method_buffer_isbuffer_obj
 [`DataView`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView
 [`Date`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
-[`Error`]: errors.html#errors_class_error
+[`Error`]: errors.md#errors_class_error
 [`Float32Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array
 [`Float64Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array
 [`Int16Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int16Array
@@ -2430,10 +2515,11 @@ util.log('Timestamped message.');
 [`WeakMap`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
 [`WeakSet`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet
 [`WebAssembly.Module`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module
-[`assert.deepStrictEqual()`]: assert.html#assert_assert_deepstrictequal_actual_expected_message
-[`console.error()`]: console.html#console_console_error_data_args
+[`assert.deepStrictEqual()`]: assert.md#assert_assert_deepstrictequal_actual_expected_message
+[`console.error()`]: console.md#console_console_error_data_args
+[`napi_create_external()`]: n-api.md#n_api_napi_create_external
 [`target` and `handler`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy#Terminology
-[`tty.hasColors()`]: tty.html#tty_writestream_hascolors_count_env
+[`tty.hasColors()`]: tty.md#tty_writestream_hascolors_count_env
 [`util.format()`]: #util_util_format_format_args
 [`util.inspect()`]: #util_util_inspect_object_options
 [`util.promisify()`]: #util_util_promisify_original
@@ -2442,19 +2528,11 @@ util.log('Timestamped message.');
 [`util.types.isDate()`]: #util_util_types_isdate_value
 [`util.types.isNativeError()`]: #util_util_types_isnativeerror_value
 [`util.types.isSharedArrayBuffer()`]: #util_util_types_issharedarraybuffer_value
-[Common System Errors]: errors.html#errors_common_system_errors
-[Custom inspection functions on objects]: #util_custom_inspection_functions_on_objects
-[Custom promisified functions]: #util_custom_promisified_functions
-[Customizing `util.inspect` colors]: #util_customizing_util_inspect_colors
-[Internationalization]: intl.html
-[Module Namespace Object]: https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects
-[WHATWG Encoding Standard]: https://encoding.spec.whatwg.org/
 [async function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
 [compare function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters
 [constructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor
 [default sort]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
 [global symbol registry]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for
-[list of deprecated APIS]: deprecations.html#deprecations_list_of_deprecated_apis
-[`napi_create_external()`]: n-api.html#n_api_napi_create_external
+[list of deprecated APIS]: deprecations.md#deprecations_list_of_deprecated_apis
 [semantically incompatible]: https://github.com/nodejs/node/issues/4179
 [util.inspect.custom]: #util_util_inspect_custom
diff --git a/doc/api/v8.html b/doc/api/v8.html
index a8e8a22d6225cc1c45ea585ebf3a12b2e15fa307..80333955deab95ecdc1b34d02248c274f450aa85 100644
--- a/doc/api/v8.html
+++ b/doc/api/v8.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>V8 | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>V8 | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="v8" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/v8.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/v8.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/v8.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/v8.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/v8.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/v8.html">13.x</a></li>
@@ -116,25 +131,23 @@
 <li><a href="https://nodejs.org/docs/latest-v4.x/api/v8.html">4.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/v8.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/v8.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><a href="#v8_v8">V8</a>
 <ul>
 <li><a href="#v8_v8_cacheddataversiontag"><code>v8.cachedDataVersionTag()</code></a></li>
-<li><a href="#v8_v8_getheapspacestatistics"><code>v8.getHeapSpaceStatistics()</code></a></li>
+<li><a href="#v8_v8_getheapcodestatistics"><code>v8.getHeapCodeStatistics()</code></a></li>
 <li><a href="#v8_v8_getheapsnapshot"><code>v8.getHeapSnapshot()</code></a></li>
+<li><a href="#v8_v8_getheapspacestatistics"><code>v8.getHeapSpaceStatistics()</code></a></li>
 <li><a href="#v8_v8_getheapstatistics"><code>v8.getHeapStatistics()</code></a></li>
-<li><a href="#v8_v8_getheapcodestatistics"><code>v8.getHeapCodeStatistics()</code></a></li>
 <li><a href="#v8_v8_setflagsfromstring_flags"><code>v8.setFlagsFromString(flags)</code></a></li>
-<li><a href="#v8_v8_takecoverage"><code>v8.takeCoverage()</code></a></li>
 <li><a href="#v8_v8_stopcoverage"><code>v8.stopCoverage()</code></a></li>
+<li><a href="#v8_v8_takecoverage"><code>v8.takeCoverage()</code></a></li>
 <li><a href="#v8_v8_writeheapsnapshot_filename"><code>v8.writeHeapSnapshot([filename])</code></a></li>
 <li><a href="#v8_serialization_api">Serialization API</a>
 <ul>
@@ -177,29 +190,68 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>V8<span><a class="mark" href="#v8_v8" id="v8_v8">#</a></span></h1>
+        <h2>V8<span><a class="mark" href="#v8_v8" id="v8_v8">#</a></span></h2>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/v8.js">lib/v8.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/v8.js">lib/v8.js</a></p>
 <p>The <code>v8</code> module exposes APIs that are specific to the version of <a href="https://developers.google.com/v8/">V8</a>
 built into the Node.js binary. It can be accessed using:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> v8 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'v8'</span>);</code></pre>
-<p>The APIs and implementation are subject to change at any time.</p>
-<h2><code>v8.cachedDataVersionTag()</code><span><a class="mark" href="#v8_v8_cacheddataversiontag" id="v8_v8_cacheddataversiontag">#</a></span></h2>
+<section><h3><code>v8.cachedDataVersionTag()</code><span><a class="mark" href="#v8_v8_cacheddataversiontag" id="v8_v8_cacheddataversiontag">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
-<p>Returns an integer representing a "version tag" derived from the V8 version,
-command line flags and detected CPU features. This is useful for determining
+<p>Returns an integer representing a version tag derived from the V8 version,
+command-line flags, and detected CPU features. This is useful for determining
 whether a <a href="vm.html#vm_new_vm_script_code_options"><code>vm.Script</code></a> <code>cachedData</code> buffer is compatible with this instance
 of V8.</p>
-<h2><code>v8.getHeapSpaceStatistics()</code><span><a class="mark" href="#v8_v8_getheapspacestatistics" id="v8_v8_getheapspacestatistics">#</a></span></h2>
+<pre><code class="language-js"><span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(v8.<span class="hljs-title function_">cachedDataVersionTag</span>()); <span class="hljs-comment">// 3947234607</span>
+<span class="hljs-comment">// The value returned by v8.cachedDataVersionTag() is derived from the V8</span>
+<span class="hljs-comment">// version, command-line flags, and detected CPU features. Test that the value</span>
+<span class="hljs-comment">// does indeed update when flags are toggled.</span>
+v8.<span class="hljs-title function_">setFlagsFromString</span>(<span class="hljs-string">'--allow_natives_syntax'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(v8.<span class="hljs-title function_">cachedDataVersionTag</span>()); <span class="hljs-comment">// 183726201</span></code></pre>
+</section><section><h3><code>v8.getHeapCodeStatistics()</code><span><a class="mark" href="#v8_v8_getheapcodestatistics" id="v8_v8_getheapcodestatistics">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v12.8.0</span>
+</div>
+<ul>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
+</ul>
+<p>Returns an object with the following properties:</p>
+<ul>
+<li><code>code_and_metadata_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>bytecode_and_metadata_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+<li><code>external_script_source_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
+</ul>
+<!-- eslint-skip -->
+<pre><code class="language-js">{
+  <span class="hljs-attr">code_and_metadata_size</span>: <span class="hljs-number">212208</span>,
+  <span class="hljs-attr">bytecode_and_metadata_size</span>: <span class="hljs-number">161368</span>,
+  <span class="hljs-attr">external_script_source_size</span>: <span class="hljs-number">1410794</span>
+}</code></pre>
+</section><section><h3><code>v8.getHeapSnapshot()</code><span><a class="mark" href="#v8_v8_getheapsnapshot" id="v8_v8_getheapsnapshot">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v11.13.0</span>
+</div>
+<ul>
+<li>Returns: <a href="stream.html#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a> A Readable Stream containing the V8 heap snapshot</li>
+</ul>
+<p>Generates a snapshot of the current V8 heap and returns a Readable
+Stream that may be used to read the JSON serialized representation.
+This JSON stream format is intended to be used with tools such as
+Chrome DevTools. The JSON schema is undocumented and specific to the
+V8 engine. Therefore, the schema may change from one version of V8 to the next.</p>
+<pre><code class="language-js"><span class="hljs-comment">// Print heap snapshot to the console</span>
+<span class="hljs-keyword">const</span> v8 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'v8'</span>);
+<span class="hljs-keyword">const</span> stream = v8.<span class="hljs-title function_">getHeapSnapshot</span>();
+stream.<span class="hljs-title function_">pipe</span>(process.<span class="hljs-property">stdout</span>);</code></pre>
+</section><section><h3><code>v8.getHeapSpaceStatistics()</code><span><a class="mark" href="#v8_v8_getheapspacestatistics" id="v8_v8_getheapspacestatistics">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -227,58 +279,44 @@ next.</p>
 <li><code>space_available_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 <li><code>physical_space_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
-<pre><code class="language-json">[
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"new_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">2063872</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">951112</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">80824</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">2063872</span>
-  },
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"old_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">3090560</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">2493792</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">0</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">3090560</span>
-  },
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"code_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">1260160</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">644256</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">960</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">1260160</span>
-  },
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"map_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">1094160</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">201608</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">0</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">1094160</span>
-  },
-  {
-    <span class="hljs-attr">"space_name"</span>: <span class="hljs-string">"large_object_space"</span>,
-    <span class="hljs-attr">"space_size"</span>: <span class="hljs-number">0</span>,
-    <span class="hljs-attr">"space_used_size"</span>: <span class="hljs-number">0</span>,
-    <span class="hljs-attr">"space_available_size"</span>: <span class="hljs-number">1490980608</span>,
-    <span class="hljs-attr">"physical_space_size"</span>: <span class="hljs-number">0</span>
-  }
-]</code></pre>
-<h2><code>v8.getHeapSnapshot()</code><span><a class="mark" href="#v8_v8_getheapsnapshot" id="v8_v8_getheapsnapshot">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v11.13.0</span>
-</div>
-<ul>
-<li>Returns: <a href="stream.html#stream_class_stream_readable" class="type">&#x3C;stream.Readable></a> A Readable Stream containing the V8 heap snapshot</li>
-</ul>
-<p>Generates a snapshot of the current V8 heap and returns a Readable
-Stream that may be used to read the JSON serialized representation.
-This JSON stream format is intended to be used with tools such as
-Chrome DevTools. The JSON schema is undocumented and specific to the
-V8 engine, and may change from one version of V8 to the next.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> stream = v8.getHeapSnapshot();
-stream.pipe(process.stdout);</code></pre>
-<h2><code>v8.getHeapStatistics()</code><span><a class="mark" href="#v8_v8_getheapstatistics" id="v8_v8_getheapstatistics">#</a></span></h2>
+<pre><code class="language-json"><span class="hljs-punctuation">[</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"new_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2063872</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">951112</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">80824</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2063872</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"old_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">3090560</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">2493792</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">3090560</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"code_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1260160</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">644256</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">960</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1260160</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"map_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1094160</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">201608</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1094160</span>
+  <span class="hljs-punctuation">}</span><span class="hljs-punctuation">,</span>
+  <span class="hljs-punctuation">{</span>
+    <span class="hljs-attr">"space_name"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"large_object_space"</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_used_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"space_available_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">1490980608</span><span class="hljs-punctuation">,</span>
+    <span class="hljs-attr">"physical_space_size"</span><span class="hljs-punctuation">:</span> <span class="hljs-number">0</span>
+  <span class="hljs-punctuation">}</span>
+<span class="hljs-punctuation">]</span></code></pre>
+</section><section><h3><code>v8.getHeapStatistics()</code><span><a class="mark" href="#v8_v8_getheapstatistics" id="v8_v8_getheapstatistics">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -311,7 +349,7 @@ stream.pipe(process.stdout);</code></pre>
 </ul>
 <p><code>does_zap_garbage</code> is a 0/1 boolean, which signifies whether the
 <code>--zap_code_space</code> option is enabled or not. This makes V8 overwrite heap
-garbage with a bit pattern. The RSS footprint (resident memory set) gets bigger
+garbage with a bit pattern. The RSS footprint (resident set size) gets bigger
 because it continuously touches all heap pages and that makes them less likely
 to get swapped out by the operating system.</p>
 <p><code>number_of_native_contexts</code> The value of native_context is the number of the
@@ -334,26 +372,7 @@ being non-zero indicates a potential memory leak.</p>
   <span class="hljs-attr">number_of_native_contexts</span>: <span class="hljs-number">1</span>,
   <span class="hljs-attr">number_of_detached_contexts</span>: <span class="hljs-number">0</span>
 }</code></pre>
-<h2><code>v8.getHeapCodeStatistics()</code><span><a class="mark" href="#v8_v8_getheapcodestatistics" id="v8_v8_getheapcodestatistics">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.8.0</span>
-</div>
-<ul>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
-</ul>
-<p>Returns an object with the following properties:</p>
-<ul>
-<li><code>code_and_metadata_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-<li><code>bytecode_and_metadata_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-<li><code>external_script_source_size</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
-</ul>
-<!-- eslint-skip -->
-<pre><code class="language-js">{
-  <span class="hljs-attr">code_and_metadata_size</span>: <span class="hljs-number">212208</span>,
-  <span class="hljs-attr">bytecode_and_metadata_size</span>: <span class="hljs-number">161368</span>,
-  <span class="hljs-attr">external_script_source_size</span>: <span class="hljs-number">1410794</span>
-}</code></pre>
-<h2><code>v8.setFlagsFromString(flags)</code><span><a class="mark" href="#v8_v8_setflagsfromstring_flags" id="v8_v8_setflagsfromstring_flags">#</a></span></h2>
+</section><section><h3><code>v8.setFlagsFromString(flags)</code><span><a class="mark" href="#v8_v8_setflagsfromstring_flags" id="v8_v8_setflagsfromstring_flags">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v1.0.0</span>
 </div>
@@ -361,7 +380,7 @@ being non-zero indicates a potential memory leak.</p>
 <li><code>flags</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
 <p>The <code>v8.setFlagsFromString()</code> method can be used to programmatically set
-V8 command line flags. This method should be used with care. Changing settings
+V8 command-line flags. This method should be used with care. Changing settings
 after the VM has started may result in unpredictable behavior, including
 crashes and data loss; or it may simply do nothing.</p>
 <p>The V8 options available for a version of Node.js may be determined by running
@@ -369,28 +388,28 @@ crashes and data loss; or it may simply do nothing.</p>
 <p>Usage:</p>
 <pre><code class="language-js"><span class="hljs-comment">// Print GC events to stdout for one minute.</span>
 <span class="hljs-keyword">const</span> v8 = <span class="hljs-built_in">require</span>(<span class="hljs-string">'v8'</span>);
-v8.setFlagsFromString(<span class="hljs-string">'--trace_gc'</span>);
-<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> { v8.setFlagsFromString(<span class="hljs-string">'--notrace_gc'</span>); }, <span class="hljs-number">60e3</span>);</code></pre>
-<h2><code>v8.takeCoverage()</code><span><a class="mark" href="#v8_v8_takecoverage" id="v8_v8_takecoverage">#</a></span></h2>
+v8.<span class="hljs-title function_">setFlagsFromString</span>(<span class="hljs-string">'--trace_gc'</span>);
+<span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =></span> { v8.<span class="hljs-title function_">setFlagsFromString</span>(<span class="hljs-string">'--notrace_gc'</span>); }, <span class="hljs-number">60e3</span>);</code></pre>
+</section><section><h3><code>v8.stopCoverage()</code><span><a class="mark" href="#v8_v8_stopcoverage" id="v8_v8_stopcoverage">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.22.0</span>
+<span>Added in: v14.18.0</span>
+</div>
+<p>The <code>v8.stopCoverage()</code> method allows the user to stop the coverage collection
+started by <a href="cli.html#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a>, so that V8 can release the execution count
+records and optimize code. This can be used in conjunction with
+<a href="#v8_v8_takecoverage"><code>v8.takeCoverage()</code></a> if the user wants to collect the coverage on demand.</p>
+</section><section><h3><code>v8.takeCoverage()</code><span><a class="mark" href="#v8_v8_takecoverage" id="v8_v8_takecoverage">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
 </div>
 <p>The <code>v8.takeCoverage()</code> method allows the user to write the coverage started by
-<a href="cli.md#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a> to disk on demand. This method can be invoked multiple
-times during the lifetime of the process, each time the execution counter will
+<a href="cli.html#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a> to disk on demand. This method can be invoked multiple
+times during the lifetime of the process. Each time the execution counter will
 be reset and a new coverage report will be written to the directory specified
-by <a href="cli.md#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a>.</p>
+by <a href="cli.html#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a>.</p>
 <p>When the process is about to exit, one last coverage will still be written to
-disk, unless <a href="#v8_v8_stopcoverage"><code>v8.stopCoverage()</code></a> is invoked before the process exits.</p>
-<h2><code>v8.stopCoverage()</code><span><a class="mark" href="#v8_v8_stopcoverage" id="v8_v8_stopcoverage">#</a></span></h2>
-<div class="api_metadata">
-<span>Added in: v12.22.0</span>
-</div>
-<p>The <code>v8.stopCoverage()</code> method allows the user to stop the coverage collection
-started by <a href="cli.md#cli_node_v8_coverage_dir"><code>NODE_V8_COVERAGE</code></a>, so that V8 can release the execution count
-records and optimize code. This can be used in conjunction with
-<code>v8.takeCoverage()</code> if the user wants to collect the coverage on demand.</p>
-<h2><code>v8.writeHeapSnapshot([filename])</code><span><a class="mark" href="#v8_v8_writeheapsnapshot_filename" id="v8_v8_writeheapsnapshot_filename">#</a></span></h2>
+disk unless <a href="#v8_v8_stopcoverage"><code>v8.stopCoverage()</code></a> is invoked before the process exits.</p>
+</section><section><h3><code>v8.writeHeapSnapshot([filename])</code><span><a class="mark" href="#v8_v8_writeheapsnapshot_filename" id="v8_v8_writeheapsnapshot_filename">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.13.0</span>
 </div>
@@ -412,37 +431,37 @@ engine, and may change from one version of V8 to the next.</p>
 not contain any information about the workers, and vice versa.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { writeHeapSnapshot } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'v8'</span>);
 <span class="hljs-keyword">const</span> {
-  Worker,
+  <span class="hljs-title class_">Worker</span>,
   isMainThread,
   parentPort
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename);
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
 
-  worker.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">filename</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`worker heapdump: <span class="hljs-subst">${filename}</span>`</span>);
+  worker.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">filename</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`worker heapdump: <span class="hljs-subst">${filename}</span>`</span>);
     <span class="hljs-comment">// Now get a heapdump for the main thread.</span>
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">`main thread heapdump: <span class="hljs-subst">${writeHeapSnapshot()}</span>`</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`main thread heapdump: <span class="hljs-subst">${writeHeapSnapshot()}</span>`</span>);
   });
 
   <span class="hljs-comment">// Tell the worker to create a heapdump.</span>
-  worker.postMessage(<span class="hljs-string">'heapdump'</span>);
+  worker.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'heapdump'</span>);
 } <span class="hljs-keyword">else</span> {
-  parentPort.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
+  parentPort.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
     <span class="hljs-keyword">if</span> (message === <span class="hljs-string">'heapdump'</span>) {
       <span class="hljs-comment">// Generate a heapdump for the worker</span>
       <span class="hljs-comment">// and return the filename to the parent.</span>
-      parentPort.postMessage(writeHeapSnapshot());
+      parentPort.<span class="hljs-title function_">postMessage</span>(<span class="hljs-title function_">writeHeapSnapshot</span>());
     }
   });
 }</code></pre>
-<h2>Serialization API<span><a class="mark" href="#v8_serialization_api" id="v8_serialization_api">#</a></span></h2>
+</section><section><h3>Serialization API<span><a class="mark" href="#v8_serialization_api" id="v8_serialization_api">#</a></span></h3>
 <p>The serialization API provides means of serializing JavaScript values in a way
 that is compatible with the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm">HTML structured clone algorithm</a>.</p>
 <p>The format is backward-compatible (i.e. safe to store to disk).
 Equal JavaScript values may result in different serialized output.</p>
-<h3><code>v8.serialize(value)</code><span><a class="mark" href="#v8_v8_serialize_value" id="v8_v8_serialize_value">#</a></span></h3>
+<h4><code>v8.serialize(value)</code><span><a class="mark" href="#v8_v8_serialize_value" id="v8_v8_serialize_value">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -451,7 +470,7 @@ Equal JavaScript values may result in different serialized output.</p>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 <p>Uses a <a href="#v8_class_v8_defaultserializer"><code>DefaultSerializer</code></a> to serialize <code>value</code> into a buffer.</p>
-<h3><code>v8.deserialize(buffer)</code><span><a class="mark" href="#v8_v8_deserialize_buffer" id="v8_v8_deserialize_buffer">#</a></span></h3>
+<h4><code>v8.deserialize(buffer)</code><span><a class="mark" href="#v8_v8_deserialize_buffer" id="v8_v8_deserialize_buffer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
@@ -460,29 +479,29 @@ Equal JavaScript values may result in different serialized output.</p>
 </ul>
 <p>Uses a <a href="#v8_class_v8_defaultdeserializer"><code>DefaultDeserializer</code></a> with default options to read a JS value
 from a buffer.</p>
-<h3>Class: <code>v8.Serializer</code><span><a class="mark" href="#v8_class_v8_serializer" id="v8_class_v8_serializer">#</a></span></h3>
+<h4>Class: <code>v8.Serializer</code><span><a class="mark" href="#v8_class_v8_serializer" id="v8_class_v8_serializer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
-<h4><code>new Serializer()</code><span><a class="mark" href="#v8_new_serializer" id="v8_new_serializer">#</a></span></h4>
+<h5><code>new Serializer()</code><span><a class="mark" href="#v8_new_serializer" id="v8_new_serializer">#</a></span></h5>
 <p>Creates a new <code>Serializer</code> object.</p>
-<h4><code>serializer.writeHeader()</code><span><a class="mark" href="#v8_serializer_writeheader" id="v8_serializer_writeheader">#</a></span></h4>
+<h5><code>serializer.writeHeader()</code><span><a class="mark" href="#v8_serializer_writeheader" id="v8_serializer_writeheader">#</a></span></h5>
 <p>Writes out a header, which includes the serialization format version.</p>
-<h4><code>serializer.writeValue(value)</code><span><a class="mark" href="#v8_serializer_writevalue_value" id="v8_serializer_writevalue_value">#</a></span></h4>
+<h5><code>serializer.writeValue(value)</code><span><a class="mark" href="#v8_serializer_writevalue_value" id="v8_serializer_writevalue_value">#</a></span></h5>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
 <p>Serializes a JavaScript value and adds the serialized representation to the
 internal buffer.</p>
 <p>This throws an error if <code>value</code> cannot be serialized.</p>
-<h4><code>serializer.releaseBuffer()</code><span><a class="mark" href="#v8_serializer_releasebuffer" id="v8_serializer_releasebuffer">#</a></span></h4>
+<h5><code>serializer.releaseBuffer()</code><span><a class="mark" href="#v8_serializer_releasebuffer" id="v8_serializer_releasebuffer">#</a></span></h5>
 <ul>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
 <p>Returns the stored internal buffer. This serializer should not be used once
 the buffer is released. Calling this method results in undefined behavior
 if a previous write has failed.</p>
-<h4><code>serializer.transferArrayBuffer(id, arrayBuffer)</code><span><a class="mark" href="#v8_serializer_transferarraybuffer_id_arraybuffer" id="v8_serializer_transferarraybuffer_id_arraybuffer">#</a></span></h4>
+<h5><code>serializer.transferArrayBuffer(id, arrayBuffer)</code><span><a class="mark" href="#v8_serializer_transferarraybuffer_id_arraybuffer" id="v8_serializer_transferarraybuffer_id_arraybuffer">#</a></span></h5>
 <ul>
 <li><code>id</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> A 32-bit unsigned integer.</li>
 <li><code>arrayBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> An <code>ArrayBuffer</code> instance.</li>
@@ -490,33 +509,33 @@ if a previous write has failed.</p>
 <p>Marks an <code>ArrayBuffer</code> as having its contents transferred out of band.
 Pass the corresponding <code>ArrayBuffer</code> in the deserializing context to
 <a href="#v8_deserializer_transferarraybuffer_id_arraybuffer"><code>deserializer.transferArrayBuffer()</code></a>.</p>
-<h4><code>serializer.writeUint32(value)</code><span><a class="mark" href="#v8_serializer_writeuint32_value" id="v8_serializer_writeuint32_value">#</a></span></h4>
+<h5><code>serializer.writeUint32(value)</code><span><a class="mark" href="#v8_serializer_writeuint32_value" id="v8_serializer_writeuint32_value">#</a></span></h5>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Write a raw 32-bit unsigned integer.
 For use inside of a custom <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h4><code>serializer.writeUint64(hi, lo)</code><span><a class="mark" href="#v8_serializer_writeuint64_hi_lo" id="v8_serializer_writeuint64_hi_lo">#</a></span></h4>
+<h5><code>serializer.writeUint64(hi, lo)</code><span><a class="mark" href="#v8_serializer_writeuint64_hi_lo" id="v8_serializer_writeuint64_hi_lo">#</a></span></h5>
 <ul>
 <li><code>hi</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li><code>lo</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Write a raw 64-bit unsigned integer, split into high and low 32-bit parts.
 For use inside of a custom <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h4><code>serializer.writeDouble(value)</code><span><a class="mark" href="#v8_serializer_writedouble_value" id="v8_serializer_writedouble_value">#</a></span></h4>
+<h5><code>serializer.writeDouble(value)</code><span><a class="mark" href="#v8_serializer_writedouble_value" id="v8_serializer_writedouble_value">#</a></span></h5>
 <ul>
 <li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Write a JS <code>number</code> value.
 For use inside of a custom <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h4><code>serializer.writeRawBytes(buffer)</code><span><a class="mark" href="#v8_serializer_writerawbytes_buffer" id="v8_serializer_writerawbytes_buffer">#</a></span></h4>
+<h5><code>serializer.writeRawBytes(buffer)</code><span><a class="mark" href="#v8_serializer_writerawbytes_buffer" id="v8_serializer_writerawbytes_buffer">#</a></span></h5>
 <ul>
 <li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a></li>
 </ul>
 <p>Write raw bytes into the serializer’s internal buffer. The deserializer
 will require a way to compute the length of the buffer.
 For use inside of a custom <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h4><code>serializer._writeHostObject(object)</code><span><a class="mark" href="#v8_serializer_writehostobject_object" id="v8_serializer_writehostobject_object">#</a></span></h4>
+<h5><code>serializer._writeHostObject(object)</code><span><a class="mark" href="#v8_serializer_writehostobject_object" id="v8_serializer_writehostobject_object">#</a></span></h5>
 <ul>
 <li><code>object</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
@@ -525,7 +544,7 @@ by native C++ bindings. If it is not possible to serialize <code>object</code>,
 exception should be thrown.</p>
 <p>This method is not present on the <code>Serializer</code> class itself but can be provided
 by subclasses.</p>
-<h4><code>serializer._getDataCloneError(message)</code><span><a class="mark" href="#v8_serializer_getdatacloneerror_message" id="v8_serializer_getdatacloneerror_message">#</a></span></h4>
+<h5><code>serializer._getDataCloneError(message)</code><span><a class="mark" href="#v8_serializer_getdatacloneerror_message" id="v8_serializer_getdatacloneerror_message">#</a></span></h5>
 <ul>
 <li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -533,7 +552,7 @@ by subclasses.</p>
 object can not be cloned.</p>
 <p>This method defaults to the <a href="errors.html#errors_class_error"><code>Error</code></a> constructor and can be overridden on
 subclasses.</p>
-<h4><code>serializer._getSharedArrayBufferId(sharedArrayBuffer)</code><span><a class="mark" href="#v8_serializer_getsharedarraybufferid_sharedarraybuffer" id="v8_serializer_getsharedarraybufferid_sharedarraybuffer">#</a></span></h4>
+<h5><code>serializer._getSharedArrayBufferId(sharedArrayBuffer)</code><span><a class="mark" href="#v8_serializer_getsharedarraybufferid_sharedarraybuffer" id="v8_serializer_getsharedarraybufferid_sharedarraybuffer">#</a></span></h5>
 <ul>
 <li><code>sharedArrayBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer" class="type">&#x3C;SharedArrayBuffer></a></li>
 </ul>
@@ -545,29 +564,29 @@ serialized. When deserializing, this ID will be passed to
 <p>If the object cannot be serialized, an exception should be thrown.</p>
 <p>This method is not present on the <code>Serializer</code> class itself but can be provided
 by subclasses.</p>
-<h4><code>serializer._setTreatArrayBufferViewsAsHostObjects(flag)</code><span><a class="mark" href="#v8_serializer_settreatarraybufferviewsashostobjects_flag" id="v8_serializer_settreatarraybufferviewsashostobjects_flag">#</a></span></h4>
+<h5><code>serializer._setTreatArrayBufferViewsAsHostObjects(flag)</code><span><a class="mark" href="#v8_serializer_settreatarraybufferviewsashostobjects_flag" id="v8_serializer_settreatarraybufferviewsashostobjects_flag">#</a></span></h5>
 <ul>
 <li><code>flag</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> <strong>Default:</strong> <code>false</code></li>
 </ul>
 <p>Indicate whether to treat <code>TypedArray</code> and <code>DataView</code> objects as
 host objects, i.e. pass them to <a href="#v8_serializer_writehostobject_object"><code>serializer._writeHostObject()</code></a>.</p>
-<h3>Class: <code>v8.Deserializer</code><span><a class="mark" href="#v8_class_v8_deserializer" id="v8_class_v8_deserializer">#</a></span></h3>
+<h4>Class: <code>v8.Deserializer</code><span><a class="mark" href="#v8_class_v8_deserializer" id="v8_class_v8_deserializer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
-<h4><code>new Deserializer(buffer)</code><span><a class="mark" href="#v8_new_deserializer_buffer" id="v8_new_deserializer_buffer">#</a></span></h4>
+<h5><code>new Deserializer(buffer)</code><span><a class="mark" href="#v8_new_deserializer_buffer" id="v8_new_deserializer_buffer">#</a></span></h5>
 <ul>
 <li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> A buffer returned by
 <a href="#v8_serializer_releasebuffer"><code>serializer.releaseBuffer()</code></a>.</li>
 </ul>
 <p>Creates a new <code>Deserializer</code> object.</p>
-<h4><code>deserializer.readHeader()</code><span><a class="mark" href="#v8_deserializer_readheader" id="v8_deserializer_readheader">#</a></span></h4>
+<h5><code>deserializer.readHeader()</code><span><a class="mark" href="#v8_deserializer_readheader" id="v8_deserializer_readheader">#</a></span></h5>
 <p>Reads and validates a header (including the format version).
 May, for example, reject an invalid or unsupported wire format. In that case,
 an <code>Error</code> is thrown.</p>
-<h4><code>deserializer.readValue()</code><span><a class="mark" href="#v8_deserializer_readvalue" id="v8_deserializer_readvalue">#</a></span></h4>
+<h5><code>deserializer.readValue()</code><span><a class="mark" href="#v8_deserializer_readvalue" id="v8_deserializer_readvalue">#</a></span></h5>
 <p>Deserializes a JavaScript value from the buffer and returns it.</p>
-<h4><code>deserializer.transferArrayBuffer(id, arrayBuffer)</code><span><a class="mark" href="#v8_deserializer_transferarraybuffer_id_arraybuffer" id="v8_deserializer_transferarraybuffer_id_arraybuffer">#</a></span></h4>
+<h5><code>deserializer.transferArrayBuffer(id, arrayBuffer)</code><span><a class="mark" href="#v8_deserializer_transferarraybuffer_id_arraybuffer" id="v8_deserializer_transferarraybuffer_id_arraybuffer">#</a></span></h5>
 <ul>
 <li><code>id</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> A 32-bit unsigned integer.</li>
 <li><code>arrayBuffer</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer" class="type">&#x3C;SharedArrayBuffer></a> An <code>ArrayBuffer</code> instance.</li>
@@ -576,33 +595,33 @@ an <code>Error</code> is thrown.</p>
 Pass the corresponding <code>ArrayBuffer</code> in the serializing context to
 <a href="#v8_serializer_transferarraybuffer_id_arraybuffer"><code>serializer.transferArrayBuffer()</code></a> (or return the <code>id</code> from
 <a href="#v8_serializer_getsharedarraybufferid_sharedarraybuffer"><code>serializer._getSharedArrayBufferId()</code></a> in the case of <code>SharedArrayBuffer</code>s).</p>
-<h4><code>deserializer.getWireFormatVersion()</code><span><a class="mark" href="#v8_deserializer_getwireformatversion" id="v8_deserializer_getwireformatversion">#</a></span></h4>
+<h5><code>deserializer.getWireFormatVersion()</code><span><a class="mark" href="#v8_deserializer_getwireformatversion" id="v8_deserializer_getwireformatversion">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Reads the underlying wire format version. Likely mostly to be useful to
 legacy code reading old wire format versions. May not be called before
 <code>.readHeader()</code>.</p>
-<h4><code>deserializer.readUint32()</code><span><a class="mark" href="#v8_deserializer_readuint32" id="v8_deserializer_readuint32">#</a></span></h4>
+<h5><code>deserializer.readUint32()</code><span><a class="mark" href="#v8_deserializer_readuint32" id="v8_deserializer_readuint32">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 </ul>
 <p>Read a raw 32-bit unsigned integer and return it.
 For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deserializer._readHostObject()</code></a>.</p>
-<h4><code>deserializer.readUint64()</code><span><a class="mark" href="#v8_deserializer_readuint64" id="v8_deserializer_readuint64">#</a></span></h4>
+<h5><code>deserializer.readUint64()</code><span><a class="mark" href="#v8_deserializer_readuint64" id="v8_deserializer_readuint64">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer[]></a></li>
 </ul>
 <p>Read a raw 64-bit unsigned integer and return it as an array <code>[hi, lo]</code>
 with two 32-bit unsigned integer entries.
 For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deserializer._readHostObject()</code></a>.</p>
-<h4><code>deserializer.readDouble()</code><span><a class="mark" href="#v8_deserializer_readdouble" id="v8_deserializer_readdouble">#</a></span></h4>
+<h5><code>deserializer.readDouble()</code><span><a class="mark" href="#v8_deserializer_readdouble" id="v8_deserializer_readdouble">#</a></span></h5>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
 </ul>
 <p>Read a JS <code>number</code> value.
 For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deserializer._readHostObject()</code></a>.</p>
-<h4><code>deserializer.readRawBytes(length)</code><span><a class="mark" href="#v8_deserializer_readrawbytes_length" id="v8_deserializer_readrawbytes_length">#</a></span></h4>
+<h5><code>deserializer.readRawBytes(length)</code><span><a class="mark" href="#v8_deserializer_readrawbytes_length" id="v8_deserializer_readrawbytes_length">#</a></span></h5>
 <ul>
 <li><code>length</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a></li>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
@@ -611,28 +630,64 @@ For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deser
 must correspond to the length of the buffer that was passed to
 <a href="#v8_serializer_writerawbytes_buffer"><code>serializer.writeRawBytes()</code></a>.
 For use inside of a custom <a href="#v8_deserializer_readhostobject"><code>deserializer._readHostObject()</code></a>.</p>
-<h4><code>deserializer._readHostObject()</code><span><a class="mark" href="#v8_deserializer_readhostobject" id="v8_deserializer_readhostobject">#</a></span></h4>
+<h5><code>deserializer._readHostObject()</code><span><a class="mark" href="#v8_deserializer_readhostobject" id="v8_deserializer_readhostobject">#</a></span></h5>
 <p>This method is called to read some kind of host object, i.e. an object that is
 created by native C++ bindings. If it is not possible to deserialize the data,
 a suitable exception should be thrown.</p>
 <p>This method is not present on the <code>Deserializer</code> class itself but can be
 provided by subclasses.</p>
-<h3>Class: <code>v8.DefaultSerializer</code><span><a class="mark" href="#v8_class_v8_defaultserializer" id="v8_class_v8_defaultserializer">#</a></span></h3>
+<h4>Class: <code>v8.DefaultSerializer</code><span><a class="mark" href="#v8_class_v8_defaultserializer" id="v8_class_v8_defaultserializer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>A subclass of <a href="#v8_class_v8_serializer"><code>Serializer</code></a> that serializes <code>TypedArray</code>
 (in particular <a href="buffer.html"><code>Buffer</code></a>) and <code>DataView</code> objects as host objects, and only
 stores the part of their underlying <code>ArrayBuffer</code>s that they are referring to.</p>
-<h3>Class: <code>v8.DefaultDeserializer</code><span><a class="mark" href="#v8_class_v8_defaultdeserializer" id="v8_class_v8_defaultdeserializer">#</a></span></h3>
+<h4>Class: <code>v8.DefaultDeserializer</code><span><a class="mark" href="#v8_class_v8_defaultdeserializer" id="v8_class_v8_defaultdeserializer">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.0.0</span>
 </div>
 <p>A subclass of <a href="#v8_class_v8_deserializer"><code>Deserializer</code></a> corresponding to the format written by
-<a href="#v8_class_v8_defaultserializer"><code>DefaultSerializer</code></a>.</p>
+<a href="#v8_class_v8_defaultserializer"><code>DefaultSerializer</code></a>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/v8.json b/doc/api/v8.json
index 98798881d7c3eb217046ad6e5a34c790436dba61..68b45693dd18e1aa57ef899103798fe8387d6013 100644
--- a/doc/api/v8.json
+++ b/doc/api/v8.json
@@ -6,7 +6,7 @@
       "textRaw": "V8",
       "name": "v8",
       "introduced_in": "v4.0.0",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/v8.js\">lib/v8.js</a></p>\n<p>The <code>v8</code> module exposes APIs that are specific to the version of <a href=\"https://developers.google.com/v8/\">V8</a>\nbuilt into the Node.js binary. It can be accessed using:</p>\n<pre><code class=\"language-js\">const v8 = require('v8');\n</code></pre>\n<p>The APIs and implementation are subject to change at any time.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/v8.js\">lib/v8.js</a></p>\n<p>The <code>v8</code> module exposes APIs that are specific to the version of <a href=\"https://developers.google.com/v8/\">V8</a>\nbuilt into the Node.js binary. It can be accessed using:</p>\n<pre><code class=\"language-js\">const v8 = require('v8');\n</code></pre>",
       "methods": [
         {
           "textRaw": "`v8.cachedDataVersionTag()`",
@@ -28,35 +28,29 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns an integer representing a \"version tag\" derived from the V8 version,\ncommand line flags and detected CPU features. This is useful for determining\nwhether a <a href=\"vm.html#vm_new_vm_script_code_options\"><code>vm.Script</code></a> <code>cachedData</code> buffer is compatible with this instance\nof V8.</p>"
+          "desc": "<p>Returns an integer representing a version tag derived from the V8 version,\ncommand-line flags, and detected CPU features. This is useful for determining\nwhether a <a href=\"vm.html#vm_new_vm_script_code_options\"><code>vm.Script</code></a> <code>cachedData</code> buffer is compatible with this instance\nof V8.</p>\n<pre><code class=\"language-js\">console.log(v8.cachedDataVersionTag()); // 3947234607\n// The value returned by v8.cachedDataVersionTag() is derived from the V8\n// version, command-line flags, and detected CPU features. Test that the value\n// does indeed update when flags are toggled.\nv8.setFlagsFromString('--allow_natives_syntax');\nconsole.log(v8.cachedDataVersionTag()); // 183726201\n</code></pre>"
         },
         {
-          "textRaw": "`v8.getHeapSpaceStatistics()`",
+          "textRaw": "`v8.getHeapCodeStatistics()`",
           "type": "method",
-          "name": "getHeapSpaceStatistics",
+          "name": "getHeapCodeStatistics",
           "meta": {
             "added": [
-              "v6.0.0"
+              "v12.8.0"
             ],
-            "changes": [
-              {
-                "version": "v7.5.0",
-                "pr-url": "https://github.com/nodejs/node/pull/10186",
-                "description": "Support values exceeding the 32-bit unsigned integer range."
-              }
-            ]
+            "changes": []
           },
           "signatures": [
             {
               "return": {
-                "textRaw": "Returns: {Object[]}",
+                "textRaw": "Returns: {Object}",
                 "name": "return",
-                "type": "Object[]"
+                "type": "Object"
               },
               "params": []
             }
           ],
-          "desc": "<p>Returns statistics about the V8 heap spaces, i.e. the segments which make up\nthe V8 heap. Neither the ordering of heap spaces, nor the availability of a\nheap space can be guaranteed as the statistics are provided via the V8\n<a href=\"https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4\"><code>GetHeapSpaceStatistics</code></a> function and may change from one V8 version to the\nnext.</p>\n<p>The value returned is an array of objects containing the following properties:</p>\n<ul>\n<li><code>space_name</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>space_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>space_used_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>space_available_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>physical_space_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">[\n  {\n    \"space_name\": \"new_space\",\n    \"space_size\": 2063872,\n    \"space_used_size\": 951112,\n    \"space_available_size\": 80824,\n    \"physical_space_size\": 2063872\n  },\n  {\n    \"space_name\": \"old_space\",\n    \"space_size\": 3090560,\n    \"space_used_size\": 2493792,\n    \"space_available_size\": 0,\n    \"physical_space_size\": 3090560\n  },\n  {\n    \"space_name\": \"code_space\",\n    \"space_size\": 1260160,\n    \"space_used_size\": 644256,\n    \"space_available_size\": 960,\n    \"physical_space_size\": 1260160\n  },\n  {\n    \"space_name\": \"map_space\",\n    \"space_size\": 1094160,\n    \"space_used_size\": 201608,\n    \"space_available_size\": 0,\n    \"physical_space_size\": 1094160\n  },\n  {\n    \"space_name\": \"large_object_space\",\n    \"space_size\": 0,\n    \"space_used_size\": 0,\n    \"space_available_size\": 1490980608,\n    \"physical_space_size\": 0\n  }\n]\n</code></pre>"
+          "desc": "<p>Returns an object with the following properties:</p>\n<ul>\n<li><code>code_and_metadata_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>bytecode_and_metadata_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>external_script_source_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  code_and_metadata_size: 212208,\n  bytecode_and_metadata_size: 161368,\n  external_script_source_size: 1410794\n}\n</code></pre>"
         },
         {
           "textRaw": "`v8.getHeapSnapshot()`",
@@ -79,22 +73,17 @@
               "params": []
             }
           ],
-          "desc": "<p>Generates a snapshot of the current V8 heap and returns a Readable\nStream that may be used to read the JSON serialized representation.\nThis JSON stream format is intended to be used with tools such as\nChrome DevTools. The JSON schema is undocumented and specific to the\nV8 engine, and may change from one version of V8 to the next.</p>\n<pre><code class=\"language-js\">const stream = v8.getHeapSnapshot();\nstream.pipe(process.stdout);\n</code></pre>"
+          "desc": "<p>Generates a snapshot of the current V8 heap and returns a Readable\nStream that may be used to read the JSON serialized representation.\nThis JSON stream format is intended to be used with tools such as\nChrome DevTools. The JSON schema is undocumented and specific to the\nV8 engine. Therefore, the schema may change from one version of V8 to the next.</p>\n<pre><code class=\"language-js\">// Print heap snapshot to the console\nconst v8 = require('v8');\nconst stream = v8.getHeapSnapshot();\nstream.pipe(process.stdout);\n</code></pre>"
         },
         {
-          "textRaw": "`v8.getHeapStatistics()`",
+          "textRaw": "`v8.getHeapSpaceStatistics()`",
           "type": "method",
-          "name": "getHeapStatistics",
+          "name": "getHeapSpaceStatistics",
           "meta": {
             "added": [
-              "v1.0.0"
+              "v6.0.0"
             ],
             "changes": [
-              {
-                "version": "v7.2.0",
-                "pr-url": "https://github.com/nodejs/node/pull/8610",
-                "description": "Added `malloced_memory`, `peak_malloced_memory`, and `does_zap_garbage`."
-              },
               {
                 "version": "v7.5.0",
                 "pr-url": "https://github.com/nodejs/node/pull/10186",
@@ -105,24 +94,35 @@
           "signatures": [
             {
               "return": {
-                "textRaw": "Returns: {Object}",
+                "textRaw": "Returns: {Object[]}",
                 "name": "return",
-                "type": "Object"
+                "type": "Object[]"
               },
               "params": []
             }
           ],
-          "desc": "<p>Returns an object with the following properties:</p>\n<ul>\n<li><code>total_heap_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_heap_size_executable</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_physical_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_available_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>used_heap_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>heap_size_limit</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>malloced_memory</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>peak_malloced_memory</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>does_zap_garbage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>number_of_native_contexts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>number_of_detached_contexts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<p><code>does_zap_garbage</code> is a 0/1 boolean, which signifies whether the\n<code>--zap_code_space</code> option is enabled or not. This makes V8 overwrite heap\ngarbage with a bit pattern. The RSS footprint (resident memory set) gets bigger\nbecause it continuously touches all heap pages and that makes them less likely\nto get swapped out by the operating system.</p>\n<p><code>number_of_native_contexts</code> The value of native_context is the number of the\ntop-level contexts currently active. Increase of this number over time indicates\na memory leak.</p>\n<p><code>number_of_detached_contexts</code> The value of detached_context is the number\nof contexts that were detached and not yet garbage collected. This number\nbeing non-zero indicates a potential memory leak.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  total_heap_size: 7326976,\n  total_heap_size_executable: 4194304,\n  total_physical_size: 7326976,\n  total_available_size: 1152656,\n  used_heap_size: 3476208,\n  heap_size_limit: 1535115264,\n  malloced_memory: 16384,\n  peak_malloced_memory: 1127496,\n  does_zap_garbage: 0,\n  number_of_native_contexts: 1,\n  number_of_detached_contexts: 0\n}\n</code></pre>"
+          "desc": "<p>Returns statistics about the V8 heap spaces, i.e. the segments which make up\nthe V8 heap. Neither the ordering of heap spaces, nor the availability of a\nheap space can be guaranteed as the statistics are provided via the V8\n<a href=\"https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4\"><code>GetHeapSpaceStatistics</code></a> function and may change from one V8 version to the\nnext.</p>\n<p>The value returned is an array of objects containing the following properties:</p>\n<ul>\n<li><code>space_name</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a></li>\n<li><code>space_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>space_used_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>space_available_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>physical_space_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<pre><code class=\"language-json\">[\n  {\n    \"space_name\": \"new_space\",\n    \"space_size\": 2063872,\n    \"space_used_size\": 951112,\n    \"space_available_size\": 80824,\n    \"physical_space_size\": 2063872\n  },\n  {\n    \"space_name\": \"old_space\",\n    \"space_size\": 3090560,\n    \"space_used_size\": 2493792,\n    \"space_available_size\": 0,\n    \"physical_space_size\": 3090560\n  },\n  {\n    \"space_name\": \"code_space\",\n    \"space_size\": 1260160,\n    \"space_used_size\": 644256,\n    \"space_available_size\": 960,\n    \"physical_space_size\": 1260160\n  },\n  {\n    \"space_name\": \"map_space\",\n    \"space_size\": 1094160,\n    \"space_used_size\": 201608,\n    \"space_available_size\": 0,\n    \"physical_space_size\": 1094160\n  },\n  {\n    \"space_name\": \"large_object_space\",\n    \"space_size\": 0,\n    \"space_used_size\": 0,\n    \"space_available_size\": 1490980608,\n    \"physical_space_size\": 0\n  }\n]\n</code></pre>"
         },
         {
-          "textRaw": "`v8.getHeapCodeStatistics()`",
+          "textRaw": "`v8.getHeapStatistics()`",
           "type": "method",
-          "name": "getHeapCodeStatistics",
+          "name": "getHeapStatistics",
           "meta": {
             "added": [
-              "v12.8.0"
+              "v1.0.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v7.5.0",
+                "pr-url": "https://github.com/nodejs/node/pull/10186",
+                "description": "Support values exceeding the 32-bit unsigned integer range."
+              },
+              {
+                "version": "v7.2.0",
+                "pr-url": "https://github.com/nodejs/node/pull/8610",
+                "description": "Added `malloced_memory`, `peak_malloced_memory`, and `does_zap_garbage`."
+              }
+            ]
           },
           "signatures": [
             {
@@ -134,7 +134,7 @@
               "params": []
             }
           ],
-          "desc": "<p>Returns an object with the following properties:</p>\n<ul>\n<li><code>code_and_metadata_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>bytecode_and_metadata_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>external_script_source_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  code_and_metadata_size: 212208,\n  bytecode_and_metadata_size: 161368,\n  external_script_source_size: 1410794\n}\n</code></pre>"
+          "desc": "<p>Returns an object with the following properties:</p>\n<ul>\n<li><code>total_heap_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_heap_size_executable</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_physical_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>total_available_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>used_heap_size</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>heap_size_limit</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>malloced_memory</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>peak_malloced_memory</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>does_zap_garbage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>number_of_native_contexts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n<li><code>number_of_detached_contexts</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type\" class=\"type\">&lt;number&gt;</a></li>\n</ul>\n<p><code>does_zap_garbage</code> is a 0/1 boolean, which signifies whether the\n<code>--zap_code_space</code> option is enabled or not. This makes V8 overwrite heap\ngarbage with a bit pattern. The RSS footprint (resident set size) gets bigger\nbecause it continuously touches all heap pages and that makes them less likely\nto get swapped out by the operating system.</p>\n<p><code>number_of_native_contexts</code> The value of native_context is the number of the\ntop-level contexts currently active. Increase of this number over time indicates\na memory leak.</p>\n<p><code>number_of_detached_contexts</code> The value of detached_context is the number\nof contexts that were detached and not yet garbage collected. This number\nbeing non-zero indicates a potential memory leak.</p>\n<!-- eslint-skip -->\n<pre><code class=\"language-js\">{\n  total_heap_size: 7326976,\n  total_heap_size_executable: 4194304,\n  total_physical_size: 7326976,\n  total_available_size: 1152656,\n  used_heap_size: 3476208,\n  heap_size_limit: 1535115264,\n  malloced_memory: 16384,\n  peak_malloced_memory: 1127496,\n  does_zap_garbage: 0,\n  number_of_native_contexts: 1,\n  number_of_detached_contexts: 0\n}\n</code></pre>"
         },
         {
           "textRaw": "`v8.setFlagsFromString(flags)`",
@@ -157,15 +157,15 @@
               ]
             }
           ],
-          "desc": "<p>The <code>v8.setFlagsFromString()</code> method can be used to programmatically set\nV8 command line flags. This method should be used with care. Changing settings\nafter the VM has started may result in unpredictable behavior, including\ncrashes and data loss; or it may simply do nothing.</p>\n<p>The V8 options available for a version of Node.js may be determined by running\n<code>node --v8-options</code>.</p>\n<p>Usage:</p>\n<pre><code class=\"language-js\">// Print GC events to stdout for one minute.\nconst v8 = require('v8');\nv8.setFlagsFromString('--trace_gc');\nsetTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);\n</code></pre>"
+          "desc": "<p>The <code>v8.setFlagsFromString()</code> method can be used to programmatically set\nV8 command-line flags. This method should be used with care. Changing settings\nafter the VM has started may result in unpredictable behavior, including\ncrashes and data loss; or it may simply do nothing.</p>\n<p>The V8 options available for a version of Node.js may be determined by running\n<code>node --v8-options</code>.</p>\n<p>Usage:</p>\n<pre><code class=\"language-js\">// Print GC events to stdout for one minute.\nconst v8 = require('v8');\nv8.setFlagsFromString('--trace_gc');\nsetTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);\n</code></pre>"
         },
         {
-          "textRaw": "`v8.takeCoverage()`",
+          "textRaw": "`v8.stopCoverage()`",
           "type": "method",
-          "name": "takeCoverage",
+          "name": "stopCoverage",
           "meta": {
             "added": [
-              "v12.22.0"
+              "v14.18.0"
             ],
             "changes": []
           },
@@ -174,15 +174,15 @@
               "params": []
             }
           ],
-          "desc": "<p>The <code>v8.takeCoverage()</code> method allows the user to write the coverage started by\n<a href=\"cli.md#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a> to disk on demand. This method can be invoked multiple\ntimes during the lifetime of the process, each time the execution counter will\nbe reset and a new coverage report will be written to the directory specified\nby <a href=\"cli.md#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a>.</p>\n<p>When the process is about to exit, one last coverage will still be written to\ndisk, unless <a href=\"#v8_v8_stopcoverage\"><code>v8.stopCoverage()</code></a> is invoked before the process exits.</p>"
+          "desc": "<p>The <code>v8.stopCoverage()</code> method allows the user to stop the coverage collection\nstarted by <a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a>, so that V8 can release the execution count\nrecords and optimize code. This can be used in conjunction with\n<a href=\"#v8_v8_takecoverage\"><code>v8.takeCoverage()</code></a> if the user wants to collect the coverage on demand.</p>"
         },
         {
-          "textRaw": "`v8.stopCoverage()`",
+          "textRaw": "`v8.takeCoverage()`",
           "type": "method",
-          "name": "stopCoverage",
+          "name": "takeCoverage",
           "meta": {
             "added": [
-              "v12.22.0"
+              "v14.18.0"
             ],
             "changes": []
           },
@@ -191,7 +191,7 @@
               "params": []
             }
           ],
-          "desc": "<p>The <code>v8.stopCoverage()</code> method allows the user to stop the coverage collection\nstarted by <a href=\"cli.md#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a>, so that V8 can release the execution count\nrecords and optimize code. This can be used in conjunction with\n<code>v8.takeCoverage()</code> if the user wants to collect the coverage on demand.</p>"
+          "desc": "<p>The <code>v8.takeCoverage()</code> method allows the user to write the coverage started by\n<a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a> to disk on demand. This method can be invoked multiple\ntimes during the lifetime of the process. Each time the execution counter will\nbe reset and a new coverage report will be written to the directory specified\nby <a href=\"cli.html#cli_node_v8_coverage_dir\"><code>NODE_V8_COVERAGE</code></a>.</p>\n<p>When the process is about to exit, one last coverage will still be written to\ndisk unless <a href=\"#v8_v8_stopcoverage\"><code>v8.stopCoverage()</code></a> is invoked before the process exits.</p>"
         },
         {
           "textRaw": "`v8.writeHeapSnapshot([filename])`",
diff --git a/doc/api/v8.md b/doc/api/v8.md
index 7f337aaf1568e37870322589adae9abb7b0c8913..f8037e56156253db5139de7c81dbd59479a135d4 100644
--- a/doc/api/v8.md
+++ b/doc/api/v8.md
@@ -11,8 +11,6 @@ built into the Node.js binary. It can be accessed using:
 const v8 = require('v8');
 ```
 
-The APIs and implementation are subject to change at any time.
-
 ## `v8.cachedDataVersionTag()`
 <!-- YAML
 added: v8.0.0
@@ -20,11 +18,62 @@ added: v8.0.0
 
 * Returns: {integer}
 
-Returns an integer representing a "version tag" derived from the V8 version,
-command line flags and detected CPU features. This is useful for determining
+Returns an integer representing a version tag derived from the V8 version,
+command-line flags, and detected CPU features. This is useful for determining
 whether a [`vm.Script`][] `cachedData` buffer is compatible with this instance
 of V8.
 
+```js
+console.log(v8.cachedDataVersionTag()); // 3947234607
+// The value returned by v8.cachedDataVersionTag() is derived from the V8
+// version, command-line flags, and detected CPU features. Test that the value
+// does indeed update when flags are toggled.
+v8.setFlagsFromString('--allow_natives_syntax');
+console.log(v8.cachedDataVersionTag()); // 183726201
+```
+
+## `v8.getHeapCodeStatistics()`
+<!-- YAML
+added: v12.8.0
+-->
+
+* Returns: {Object}
+
+Returns an object with the following properties:
+
+* `code_and_metadata_size` {number}
+* `bytecode_and_metadata_size` {number}
+* `external_script_source_size` {number}
+
+<!-- eslint-skip -->
+```js
+{
+  code_and_metadata_size: 212208,
+  bytecode_and_metadata_size: 161368,
+  external_script_source_size: 1410794
+}
+```
+
+## `v8.getHeapSnapshot()`
+<!-- YAML
+added: v11.13.0
+-->
+
+* Returns: {stream.Readable} A Readable Stream containing the V8 heap snapshot
+
+Generates a snapshot of the current V8 heap and returns a Readable
+Stream that may be used to read the JSON serialized representation.
+This JSON stream format is intended to be used with tools such as
+Chrome DevTools. The JSON schema is undocumented and specific to the
+V8 engine. Therefore, the schema may change from one version of V8 to the next.
+
+```js
+// Print heap snapshot to the console
+const v8 = require('v8');
+const stream = v8.getHeapSnapshot();
+stream.pipe(process.stdout);
+```
+
 ## `v8.getHeapSpaceStatistics()`
 <!-- YAML
 added: v6.0.0
@@ -90,35 +139,17 @@ The value returned is an array of objects containing the following properties:
 ]
 ```
 
-## `v8.getHeapSnapshot()`
-<!-- YAML
-added: v11.13.0
--->
-
-* Returns: {stream.Readable} A Readable Stream containing the V8 heap snapshot
-
-Generates a snapshot of the current V8 heap and returns a Readable
-Stream that may be used to read the JSON serialized representation.
-This JSON stream format is intended to be used with tools such as
-Chrome DevTools. The JSON schema is undocumented and specific to the
-V8 engine, and may change from one version of V8 to the next.
-
-```js
-const stream = v8.getHeapSnapshot();
-stream.pipe(process.stdout);
-```
-
 ## `v8.getHeapStatistics()`
 <!-- YAML
 added: v1.0.0
 changes:
+  - version: v7.5.0
+    pr-url: https://github.com/nodejs/node/pull/10186
+    description: Support values exceeding the 32-bit unsigned integer range.
   - version: v7.2.0
     pr-url: https://github.com/nodejs/node/pull/8610
     description: Added `malloced_memory`, `peak_malloced_memory`,
                  and `does_zap_garbage`.
-  - version: v7.5.0
-    pr-url: https://github.com/nodejs/node/pull/10186
-    description: Support values exceeding the 32-bit unsigned integer range.
 -->
 
 * Returns: {Object}
@@ -139,7 +170,7 @@ Returns an object with the following properties:
 
 `does_zap_garbage` is a 0/1 boolean, which signifies whether the
 `--zap_code_space` option is enabled or not. This makes V8 overwrite heap
-garbage with a bit pattern. The RSS footprint (resident memory set) gets bigger
+garbage with a bit pattern. The RSS footprint (resident set size) gets bigger
 because it continuously touches all heap pages and that makes them less likely
 to get swapped out by the operating system.
 
@@ -168,28 +199,6 @@ being non-zero indicates a potential memory leak.
 }
 ```
 
-## `v8.getHeapCodeStatistics()`
-<!-- YAML
-added: v12.8.0
--->
-
-* Returns: {Object}
-
-Returns an object with the following properties:
-
-* `code_and_metadata_size` {number}
-* `bytecode_and_metadata_size` {number}
-* `external_script_source_size` {number}
-
-<!-- eslint-skip -->
-```js
-{
-  code_and_metadata_size: 212208,
-  bytecode_and_metadata_size: 161368,
-  external_script_source_size: 1410794
-}
-```
-
 ## `v8.setFlagsFromString(flags)`
 <!-- YAML
 added: v1.0.0
@@ -198,7 +207,7 @@ added: v1.0.0
 * `flags` {string}
 
 The `v8.setFlagsFromString()` method can be used to programmatically set
-V8 command line flags. This method should be used with care. Changing settings
+V8 command-line flags. This method should be used with care. Changing settings
 after the VM has started may result in unpredictable behavior, including
 crashes and data loss; or it may simply do nothing.
 
@@ -214,31 +223,31 @@ v8.setFlagsFromString('--trace_gc');
 setTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);
 ```
 
+## `v8.stopCoverage()`
+
+<!-- YAML
+added: v14.18.0
+-->
+
+The `v8.stopCoverage()` method allows the user to stop the coverage collection
+started by [`NODE_V8_COVERAGE`][], so that V8 can release the execution count
+records and optimize code. This can be used in conjunction with
+[`v8.takeCoverage()`][] if the user wants to collect the coverage on demand.
+
 ## `v8.takeCoverage()`
 
 <!-- YAML
-added: v12.22.0
+added: v14.18.0
 -->
 
 The `v8.takeCoverage()` method allows the user to write the coverage started by
 [`NODE_V8_COVERAGE`][] to disk on demand. This method can be invoked multiple
-times during the lifetime of the process, each time the execution counter will
+times during the lifetime of the process. Each time the execution counter will
 be reset and a new coverage report will be written to the directory specified
 by [`NODE_V8_COVERAGE`][].
 
 When the process is about to exit, one last coverage will still be written to
-disk, unless [`v8.stopCoverage()`][] is invoked before the process exits.
-
-## `v8.stopCoverage()`
-
-<!-- YAML
-added: v12.22.0
--->
-
-The `v8.stopCoverage()` method allows the user to stop the coverage collection
-started by [`NODE_V8_COVERAGE`][], so that V8 can release the execution count
-records and optimize code. This can be used in conjunction with
-`v8.takeCoverage()` if the user wants to collect the coverage on demand.
+disk unless [`v8.stopCoverage()`][] is invoked before the process exits.
 
 ## `v8.writeHeapSnapshot([filename])`
 <!-- YAML
@@ -529,11 +538,13 @@ added: v8.0.0
 A subclass of [`Deserializer`][] corresponding to the format written by
 [`DefaultSerializer`][].
 
-[`Buffer`]: buffer.html
+[HTML structured clone algorithm]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+[V8]: https://developers.google.com/v8/
+[`Buffer`]: buffer.md
 [`DefaultDeserializer`]: #v8_class_v8_defaultdeserializer
 [`DefaultSerializer`]: #v8_class_v8_defaultserializer
 [`Deserializer`]: #v8_class_v8_deserializer
-[`Error`]: errors.html#errors_class_error
+[`Error`]: errors.md#errors_class_error
 [`GetHeapSpaceStatistics`]: https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4
 [`NODE_V8_COVERAGE`]: cli.md#cli_node_v8_coverage_dir
 [`Serializer`]: #v8_class_v8_serializer
@@ -546,7 +557,6 @@ A subclass of [`Deserializer`][] corresponding to the format written by
 [`serializer.transferArrayBuffer()`]: #v8_serializer_transferarraybuffer_id_arraybuffer
 [`serializer.writeRawBytes()`]: #v8_serializer_writerawbytes_buffer
 [`v8.stopCoverage()`]: #v8_v8_stopcoverage
-[`vm.Script`]: vm.html#vm_new_vm_script_code_options
-[HTML structured clone algorithm]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
-[V8]: https://developers.google.com/v8/
-[worker threads]: worker_threads.html
+[`v8.takeCoverage()`]: #v8_v8_takecoverage
+[`vm.Script`]: vm.md#vm_new_vm_script_code_options
+[worker threads]: worker_threads.md
diff --git a/doc/api/vm.html b/doc/api/vm.html
index 9fd728eb823bc53a9f6852d87ef78362e3532075..ccd1559c9b703608d23109774ca624b6e4bf36cc 100644
--- a/doc/api/vm.html
+++ b/doc/api/vm.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>VM (executing JavaScript) | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>VM (executing JavaScript) | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="vm" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/vm.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/vm.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/vm.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/vm.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/vm.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/vm.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/vm.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/vm.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/vm.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#vm_vm_executing_javascript">VM (executing JavaScript)</a></span>
 <ul>
 <li><a href="#vm_class_vm_script">Class: <code>vm.Script</code></a>
@@ -143,10 +156,10 @@
 <li><a href="#vm_module_dependencyspecifiers"><code>module.dependencySpecifiers</code></a></li>
 <li><a href="#vm_module_error"><code>module.error</code></a></li>
 <li><a href="#vm_module_evaluate_options"><code>module.evaluate([options])</code></a></li>
+<li><a href="#vm_module_identifier"><code>module.identifier</code></a></li>
 <li><a href="#vm_module_link_linker"><code>module.link(linker)</code></a></li>
 <li><a href="#vm_module_namespace"><code>module.namespace</code></a></li>
 <li><a href="#vm_module_status"><code>module.status</code></a></li>
-<li><a href="#vm_module_identifier"><code>module.identifier</code></a></li>
 </ul>
 </li>
 <li><span class="stability_1"><a href="#vm_class_vm_sourcetextmodule">Class: <code>vm.SourceTextModule</code></a></span>
@@ -164,23 +177,23 @@
 <li><a href="#vm_vm_compilefunction_code_params_options"><code>vm.compileFunction(code[, params[, options]])</code></a></li>
 <li><a href="#vm_vm_createcontext_contextobject_options"><code>vm.createContext([contextObject[, options]])</code></a></li>
 <li><a href="#vm_vm_iscontext_object"><code>vm.isContext(object)</code></a></li>
+<li><span class="stability_1"><a href="#vm_vm_measurememory_options"><code>vm.measureMemory([options])</code></a></span></li>
 <li><a href="#vm_vm_runincontext_code_contextifiedobject_options"><code>vm.runInContext(code, contextifiedObject[, options])</code></a></li>
 <li><a href="#vm_vm_runinnewcontext_code_contextobject_options"><code>vm.runInNewContext(code[, contextObject[, options]])</code></a></li>
 <li><a href="#vm_vm_runinthiscontext_code_options"><code>vm.runInThisContext(code[, options])</code></a></li>
 <li><a href="#vm_example_running_an_http_server_within_a_vm">Example: Running an HTTP server within a VM</a></li>
 <li><a href="#vm_what_does_it_mean_to_contextify_an_object">What does it mean to "contextify" an object?</a></li>
-<li><a href="#vm_timeout_limitations_when_using_process_nexttick_promises_and_queuemicrotask">Timeout limitations when using <code>process.nextTick()</code>, promises, and <code>queueMicrotask()</code></a></li>
+<li><a href="#vm_timeout_interactions_with_asynchronous_tasks_and_promises">Timeout interactions with asynchronous tasks and Promises</a></li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>VM (executing JavaScript)<span><a class="mark" href="#vm_vm_executing_javascript" id="vm_vm_executing_javascript">#</a></span></h1>
+        <h2>VM (executing JavaScript)<span><a class="mark" href="#vm_vm_executing_javascript" id="vm_vm_executing_javascript">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
 
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/vm.js">lib/vm.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/vm.js">lib/vm.js</a></p>
 <p>The <code>vm</code> module enables compiling and running code within V8 Virtual
 Machine contexts. <strong>The <code>vm</code> module is not a security mechanism. Do
 not use it to run untrusted code</strong>.</p>
@@ -197,30 +210,30 @@ code are reflected in the context object.</p>
 <span class="hljs-keyword">const</span> x = <span class="hljs-number">1</span>;
 
 <span class="hljs-keyword">const</span> context = { <span class="hljs-attr">x</span>: <span class="hljs-number">2</span> };
-vm.createContext(context); <span class="hljs-comment">// Contextify the object.</span>
+vm.<span class="hljs-title function_">createContext</span>(context); <span class="hljs-comment">// Contextify the object.</span>
 
 <span class="hljs-keyword">const</span> code = <span class="hljs-string">'x += 40; var y = 17;'</span>;
 <span class="hljs-comment">// `x` and `y` are global variables in the context.</span>
 <span class="hljs-comment">// Initially, x has the value 2 because that is the value of context.x.</span>
-vm.runInContext(code, context);
+vm.<span class="hljs-title function_">runInContext</span>(code, context);
 
-<span class="hljs-built_in">console</span>.log(context.x); <span class="hljs-comment">// 42</span>
-<span class="hljs-built_in">console</span>.log(context.y); <span class="hljs-comment">// 17</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context.<span class="hljs-property">x</span>); <span class="hljs-comment">// 42</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context.<span class="hljs-property">y</span>); <span class="hljs-comment">// 17</span>
 
-<span class="hljs-built_in">console</span>.log(x); <span class="hljs-comment">// 1; y is not defined.</span></code></pre>
-<h2>Class: <code>vm.Script</code><span><a class="mark" href="#vm_class_vm_script" id="vm_class_vm_script">#</a></span></h2>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(x); <span class="hljs-comment">// 1; y is not defined.</span></code></pre>
+<section><h3>Class: <code>vm.Script</code><span><a class="mark" href="#vm_class_vm_script" id="vm_class_vm_script">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.3.1</span>
 </div>
 <p>Instances of the <code>vm.Script</code> class contain precompiled scripts that can be
 executed in specific contexts.</p>
-<h3><code>new vm.Script(code[, options])</code><span><a class="mark" href="#vm_new_vm_script_code_options" id="vm_new_vm_script_code_options">#</a></span></h3>
+<h4><code>new vm.Script(code[, options])</code><span><a class="mark" href="#vm_new_vm_script_code_options" id="vm_new_vm_script_code_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
 <tr><td>v10.6.0</td>
-<td><p>The <code>produceCachedData</code> is deprecated in favour of <code>script.createCachedData()</code></p></td></tr>
+<td><p>The <code>produceCachedData</code> is deprecated in favour of <code>script.createCachedData()</code>.</p></td></tr>
 <tr><td>v5.7.0</td>
 <td><p>The <code>cachedData</code> and <code>produceCachedData</code> options are supported now.</p></td></tr>
 <tr><td>v0.3.1</td>
@@ -236,8 +249,8 @@ executed in specific contexts.</p>
 by this script. <strong>Default:</strong> <code>'evalmachine.&#x3C;anonymous>'</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>cachedData</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> Provides an optional <code>Buffer</code> or
 <code>TypedArray</code>, or <code>DataView</code> with V8's code cache data for the supplied
 source. When supplied, the <code>cachedDataRejected</code> value will be set to
@@ -253,11 +266,11 @@ This option is <strong>deprecated</strong> in favor of <code>script.createCached
 <li><code>importModuleDynamically</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this module
 when <code>import()</code> is called. If this option is not specified, calls to
 <code>import()</code> will reject with <a href="errors.html#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code></a>.
-This option is part of the experimental modules API, and should not be
-considered stable.
+This option is part of the experimental modules API. We do not recommend
+using it in a production environment.
 <ul>
 <li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> specifier passed to <code>import()</code></li>
-<li><code>module</code> <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
+<li><code>script</code> <a href="vm.html#vm_class_vm_script" class="type">&#x3C;vm.Script></a></li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects" class="type">&#x3C;Module Namespace Object></a> | <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a> Returning a <code>vm.Module</code> is
 recommended in order to take advantage of error tracking, and to avoid
 issues with namespaces that contain <code>then</code> function exports.</li>
@@ -270,17 +283,17 @@ issues with namespaces that contain <code>then</code> function exports.</li>
 <p>Creating a new <code>vm.Script</code> object compiles <code>code</code> but does not run it. The
 compiled <code>vm.Script</code> can be run later multiple times. The <code>code</code> is not bound to
 any global object; rather, it is bound before each run, just for that run.</p>
-<h3><code>script.createCachedData()</code><span><a class="mark" href="#vm_script_createcacheddata" id="vm_script_createcacheddata">#</a></span></h3>
+<h4><code>script.createCachedData()</code><span><a class="mark" href="#vm_script_createcacheddata" id="vm_script_createcacheddata">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.6.0</span>
 </div>
 <ul>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Creates a code cache that can be used with the Script constructor's
-<code>cachedData</code> option. Returns a Buffer. This method may be called at any
+<p>Creates a code cache that can be used with the <code>Script</code> constructor's
+<code>cachedData</code> option. Returns a <code>Buffer</code>. This method may be called at any
 time and any number of times.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.Script(<span class="hljs-string">`
+<pre><code class="language-js"><span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">Script</span>(<span class="hljs-string">`
 function add(a, b) {
   return a + b;
 }
@@ -288,12 +301,12 @@ function add(a, b) {
 const x = add(1, 2);
 `</span>);
 
-<span class="hljs-keyword">const</span> cacheWithoutX = script.createCachedData();
+<span class="hljs-keyword">const</span> cacheWithoutX = script.<span class="hljs-title function_">createCachedData</span>();
 
-script.runInThisContext();
+script.<span class="hljs-title function_">runInThisContext</span>();
 
-<span class="hljs-keyword">const</span> cacheWithX = script.createCachedData();</code></pre>
-<h3><code>script.runInContext(contextifiedObject[, options])</code><span><a class="mark" href="#vm_script_runincontext_contextifiedobject_options" id="vm_script_runincontext_contextifiedobject_options">#</a></span></h3>
+<span class="hljs-keyword">const</span> cacheWithX = script.<span class="hljs-title function_">createCachedData</span>();</code></pre>
+<h4><code>script.runInContext(contextifiedObject[, options])</code><span><a class="mark" href="#vm_script_runincontext_contextifiedobject_options" id="vm_script_runincontext_contextifiedobject_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -316,11 +329,11 @@ to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="errors.html#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> the result of the very last statement executed in the script.</li>
@@ -338,23 +351,25 @@ The globals are contained in the <code>context</code> object.</p>
   <span class="hljs-attr">count</span>: <span class="hljs-number">2</span>
 };
 
-<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.Script(<span class="hljs-string">'count += 1; name = "kitty";'</span>);
+<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">Script</span>(<span class="hljs-string">'count += 1; name = "kitty";'</span>);
 
-vm.createContext(context);
+vm.<span class="hljs-title function_">createContext</span>(context);
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">10</span>; ++i) {
-  script.runInContext(context);
+  script.<span class="hljs-title function_">runInContext</span>(context);
 }
 
-<span class="hljs-built_in">console</span>.log(context);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context);
 <span class="hljs-comment">// Prints: { animal: 'cat', count: 12, name: 'kitty' }</span></code></pre>
 <p>Using the <code>timeout</code> or <code>breakOnSigint</code> options will result in new event loops
 and corresponding threads being started, which have a non-zero performance
 overhead.</p>
-<h3><code>script.runInNewContext([contextObject[, options]])</code><span><a class="mark" href="#vm_script_runinnewcontext_contextobject_options" id="vm_script_runinnewcontext_contextobject_options">#</a></span></h3>
+<h4><code>script.runInNewContext([contextObject[, options]])</code><span><a class="mark" href="#vm_script_runinnewcontext_contextobject_options" id="vm_script_runinnewcontext_contextobject_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0</td>
+<td><p>The <code>microtaskMode</code> option is supported now.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>contextCodeGeneration</code> option is supported now.</p></td></tr>
 <tr><td>v6.3.0</td>
@@ -375,11 +390,11 @@ to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="errors.html#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>contextName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Human-readable name of the newly created context.
 <strong>Default:</strong> <code>'VM Context i'</code>, where <code>i</code> is an ascending numerical index of
 the created context.</li>
@@ -398,6 +413,10 @@ constructors (<code>Function</code>, <code>GeneratorFunction</code>, etc) will t
 module will throw a <code>WebAssembly.CompileError</code>. <strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
+<li><code>microtaskMode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If set to <code>afterEvaluate</code>, microtasks (tasks
+scheduled through <code>Promise</code>s and <code>async function</code>s) will be run immediately
+after the script has run. They are included in the <code>timeout</code> and
+<code>breakOnSigint</code> scopes in that case.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> the result of the very last statement executed in the script.</li>
@@ -410,16 +429,16 @@ the code multiple times in different contexts. The globals are set on and
 contained within each individual <code>context</code>.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.Script(<span class="hljs-string">'globalVar = "set"'</span>);
+<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">Script</span>(<span class="hljs-string">'globalVar = "set"'</span>);
 
 <span class="hljs-keyword">const</span> contexts = [{}, {}, {}];
-contexts.forEach(<span class="hljs-function">(<span class="hljs-params">context</span>) =></span> {
-  script.runInNewContext(context);
+contexts.<span class="hljs-title function_">forEach</span>(<span class="hljs-function">(<span class="hljs-params">context</span>) =></span> {
+  script.<span class="hljs-title function_">runInNewContext</span>(context);
 });
 
-<span class="hljs-built_in">console</span>.log(contexts);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(contexts);
 <span class="hljs-comment">// Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]</span></code></pre>
-<h3><code>script.runInThisContext([options])</code><span><a class="mark" href="#vm_script_runinthiscontext_options" id="vm_script_runinthiscontext_options">#</a></span></h3>
+<h4><code>script.runInThisContext([options])</code><span><a class="mark" href="#vm_script_runinthiscontext_options" id="vm_script_runinthiscontext_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -440,11 +459,11 @@ to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="errors.html#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> the result of the very last statement executed in the script.</li>
@@ -456,24 +475,24 @@ current <code>global</code> object. Running code does not have access to local s
 executes that code multiple times:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-built_in">global</span>.globalVar = <span class="hljs-number">0</span>;
+<span class="hljs-variable language_">global</span>.<span class="hljs-property">globalVar</span> = <span class="hljs-number">0</span>;
 
-<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.Script(<span class="hljs-string">'globalVar += 1'</span>, { <span class="hljs-attr">filename</span>: <span class="hljs-string">'myfile.vm'</span> });
+<span class="hljs-keyword">const</span> script = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">Script</span>(<span class="hljs-string">'globalVar += 1'</span>, { <span class="hljs-attr">filename</span>: <span class="hljs-string">'myfile.vm'</span> });
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">1000</span>; ++i) {
-  script.runInThisContext();
+  script.<span class="hljs-title function_">runInThisContext</span>();
 }
 
-<span class="hljs-built_in">console</span>.log(globalVar);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(globalVar);
 
 <span class="hljs-comment">// 1000</span></code></pre>
-<h2>Class: <code>vm.Module</code><span><a class="mark" href="#vm_class_vm_module" id="vm_class_vm_module">#</a></span></h2>
+</section><section><h3>Class: <code>vm.Module</code><span><a class="mark" href="#vm_class_vm_module" id="vm_class_vm_module">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command
-flag enabled.</em></p>
+<p>This feature is only available with the <code>--experimental-vm-modules</code> command
+flag enabled.</p>
 <p>The <code>vm.Module</code> class provides a low-level interface for using
 ECMAScript modules in VM contexts. It is the counterpart of the <code>vm.Script</code>
 class that closely mirrors <a href="https://www.ecma-international.org/ecma-262/#sec-abstract-module-records">Module Record</a>s as defined in the ECMAScript
@@ -488,9 +507,80 @@ example.</p>
 <p>This implementation lies at a lower level than the <a href="esm.html#esm_modules_ecmascript_modules">ECMAScript Module
 loader</a>. There is also no way to interact with the Loader yet, though
 support is planned.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-keyword">const</span> contextifiedObject = vm.createContext({ <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span> });
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> vm <span class="hljs-keyword">from</span> <span class="hljs-string">'vm'</span>;
+
+<span class="hljs-keyword">const</span> contextifiedObject = vm.<span class="hljs-title function_">createContext</span>({
+  <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span>,
+  <span class="hljs-attr">print</span>: <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>,
+});
+
+<span class="hljs-comment">// Step 1</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Create a Module by constructing a new `vm.SourceTextModule` object. This</span>
+<span class="hljs-comment">// parses the provided source text, throwing a `SyntaxError` if anything goes</span>
+<span class="hljs-comment">// wrong. By default, a Module is created in the top context. But here, we</span>
+<span class="hljs-comment">// specify `contextifiedObject` as the context this Module belongs to.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Here, we attempt to obtain the default export from the module "foo", and</span>
+<span class="hljs-comment">// put it into local binding "secret".</span>
+
+<span class="hljs-keyword">const</span> bar = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">`
+  import s from 'foo';
+  s;
+  print(s);
+`</span>, { <span class="hljs-attr">context</span>: contextifiedObject });
+
+<span class="hljs-comment">// Step 2</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// "Link" the imported dependencies of this Module to it.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// The provided linking callback (the "linker") accepts two arguments: the</span>
+<span class="hljs-comment">// parent module (`bar` in this case) and the string that is the specifier of</span>
+<span class="hljs-comment">// the imported module. The callback is expected to return a Module that</span>
+<span class="hljs-comment">// corresponds to the provided specifier, with certain requirements documented</span>
+<span class="hljs-comment">// in `module.link()`.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// If linking has not started for the returned Module, the same linker</span>
+<span class="hljs-comment">// callback will be called on the returned Module.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Even top-level Modules without dependencies must be explicitly linked. The</span>
+<span class="hljs-comment">// callback provided would never be called, however.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// The link() method returns a Promise that will be resolved when all the</span>
+<span class="hljs-comment">// Promises returned by the linker resolve.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Note: This is a contrived example in that the linker function creates a new</span>
+<span class="hljs-comment">// "foo" module every time it is called. In a full-fledged module system, a</span>
+<span class="hljs-comment">// cache would probably be used to avoid duplicated modules.</span>
+
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">linker</span>(<span class="hljs-params">specifier, referencingModule</span>) {
+  <span class="hljs-keyword">if</span> (specifier === <span class="hljs-string">'foo'</span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">`
+      // The "secret" variable refers to the global variable we added to
+      // "contextifiedObject" when creating the context.
+      export default secret;
+    `</span>, { <span class="hljs-attr">context</span>: referencingModule.<span class="hljs-property">context</span> });
+
+    <span class="hljs-comment">// Using `contextifiedObject` instead of `referencingModule.context`</span>
+    <span class="hljs-comment">// here would work as well.</span>
+  }
+  <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">`Unable to resolve dependency: <span class="hljs-subst">${specifier}</span>`</span>);
+}
+<span class="hljs-keyword">await</span> bar.<span class="hljs-title function_">link</span>(linker);
+
+<span class="hljs-comment">// Step 3</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// Evaluate the Module. The evaluate() method returns a promise which will</span>
+<span class="hljs-comment">// resolve after the module has finished evaluating.</span>
+
+<span class="hljs-comment">// Prints 42.</span>
+<span class="hljs-keyword">await</span> bar.evaluate();</code><code class="language-js cjs"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
+
+<span class="hljs-keyword">const</span> contextifiedObject = vm.<span class="hljs-title function_">createContext</span>({
+  <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span>,
+  <span class="hljs-attr">print</span>: <span class="hljs-variable language_">console</span>.<span class="hljs-property">log</span>,
+});
 
 (<span class="hljs-keyword">async</span> () => {
   <span class="hljs-comment">// Step 1</span>
@@ -503,9 +593,10 @@ support is planned.</p>
   <span class="hljs-comment">// Here, we attempt to obtain the default export from the module "foo", and</span>
   <span class="hljs-comment">// put it into local binding "secret".</span>
 
-  <span class="hljs-keyword">const</span> bar = <span class="hljs-keyword">new</span> vm.SourceTextModule(<span class="hljs-string">`
+  <span class="hljs-keyword">const</span> bar = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">`
     import s from 'foo';
     s;
+    print(s);
   `</span>, { <span class="hljs-attr">context</span>: contextifiedObject });
 
   <span class="hljs-comment">// Step 2</span>
@@ -531,35 +622,30 @@ support is planned.</p>
   <span class="hljs-comment">// "foo" module every time it is called. In a full-fledged module system, a</span>
   <span class="hljs-comment">// cache would probably be used to avoid duplicated modules.</span>
 
-  <span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">linker</span>(<span class="hljs-params">specifier, referencingModule</span>) </span>{
+  <span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">linker</span>(<span class="hljs-params">specifier, referencingModule</span>) {
     <span class="hljs-keyword">if</span> (specifier === <span class="hljs-string">'foo'</span>) {
-      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> vm.SourceTextModule(<span class="hljs-string">`
+      <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">`
         // The "secret" variable refers to the global variable we added to
         // "contextifiedObject" when creating the context.
         export default secret;
-      `</span>, { <span class="hljs-attr">context</span>: referencingModule.context });
+      `</span>, { <span class="hljs-attr">context</span>: referencingModule.<span class="hljs-property">context</span> });
 
       <span class="hljs-comment">// Using `contextifiedObject` instead of `referencingModule.context`</span>
       <span class="hljs-comment">// here would work as well.</span>
     }
-    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">`Unable to resolve dependency: <span class="hljs-subst">${specifier}</span>`</span>);
+    <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">`Unable to resolve dependency: <span class="hljs-subst">${specifier}</span>`</span>);
   }
-  <span class="hljs-keyword">await</span> bar.link(linker);
+  <span class="hljs-keyword">await</span> bar.<span class="hljs-title function_">link</span>(linker);
 
   <span class="hljs-comment">// Step 3</span>
   <span class="hljs-comment">//</span>
-  <span class="hljs-comment">// Evaluate the Module. The evaluate() method returns a Promise with a single</span>
-  <span class="hljs-comment">// property "result" that contains the result of the very last statement</span>
-  <span class="hljs-comment">// executed in the Module. In the case of `bar`, it is `s;`, which refers to</span>
-  <span class="hljs-comment">// the default export of the `foo` module, the `secret` we set in the</span>
-  <span class="hljs-comment">// beginning to 42.</span>
-
-  <span class="hljs-keyword">const</span> { result } = <span class="hljs-keyword">await</span> bar.evaluate();
+  <span class="hljs-comment">// Evaluate the Module. The evaluate() method returns a promise which will</span>
+  <span class="hljs-comment">// resolve after the module has finished evaluating.</span>
 
-  <span class="hljs-built_in">console</span>.log(result);
   <span class="hljs-comment">// Prints 42.</span>
+  <span class="hljs-keyword">await</span> bar.evaluate();
 })();</code></pre>
-<h3><code>module.dependencySpecifiers</code><span><a class="mark" href="#vm_module_dependencyspecifiers" id="vm_module_dependencyspecifiers">#</a></span></h3>
+<h4><code>module.dependencySpecifiers</code><span><a class="mark" href="#vm_module_dependencyspecifiers" id="vm_module_dependencyspecifiers">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a></li>
 </ul>
@@ -567,7 +653,7 @@ support is planned.</p>
 to disallow any changes to it.</p>
 <p>Corresponds to the <code>[[RequestedModules]]</code> field of <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module Record</a>s in
 the ECMAScript specification.</p>
-<h3><code>module.error</code><span><a class="mark" href="#vm_module_error" id="vm_module_error">#</a></span></h3>
+<h4><code>module.error</code><span><a class="mark" href="#vm_module_error" id="vm_module_error">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
 </ul>
@@ -578,45 +664,44 @@ accessing this property will result in a thrown exception.</p>
 exception due to possible ambiguity with <code>throw undefined;</code>.</p>
 <p>Corresponds to the <code>[[EvaluationError]]</code> field of <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module Record</a>s
 in the ECMAScript specification.</p>
-<h3><code>module.evaluate([options])</code><span><a class="mark" href="#vm_module_evaluate_options" id="vm_module_evaluate_options">#</a></span></h3>
+<h4><code>module.evaluate([options])</code><span><a class="mark" href="#vm_module_evaluate_options" id="vm_module_evaluate_options">#</a></span></h4>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to evaluate
 before terminating execution. If execution is interrupted, an <a href="errors.html#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the event that have
-been attached via <code>process.on('SIGINT')</code> will be disabled during script
-execution, but will continue to work after that. If execution is
-interrupted, an <a href="errors.html#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="errors.html#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 </ul>
 </li>
-<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> Fulfills with <code>undefined</code> upon success.</li>
 </ul>
 <p>Evaluate the module.</p>
-<p>This must be called after the module has been linked; otherwise it will
-throw an error. It could be called also when the module has already been
-evaluated, in which case it will do one of the following two things:</p>
-<ul>
-<li>return <code>undefined</code> if the initial evaluation ended in success (<code>module.status</code>
-is <code>'evaluated'</code>)</li>
-<li>rethrow the same exception the initial evaluation threw if the initial
-evaluation ended in an error (<code>module.status</code> is <code>'errored'</code>)</li>
-</ul>
+<p>This must be called after the module has been linked; otherwise it will reject.
+It could be called also when the module has already been evaluated, in which
+case it will either do nothing if the initial evaluation ended in success
+(<code>module.status</code> is <code>'evaluated'</code>) or it will re-throw the exception that the
+initial evaluation resulted in (<code>module.status</code> is <code>'errored'</code>).</p>
 <p>This method cannot be called while the module is being evaluated
-(<code>module.status</code> is <code>'evaluating'</code>) to prevent infinite recursion.</p>
+(<code>module.status</code> is <code>'evaluating'</code>).</p>
 <p>Corresponds to the <a href="https://tc39.es/ecma262/#sec-moduleevaluation">Evaluate() concrete method</a> field of <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module
 Record</a>s in the ECMAScript specification.</p>
-<h3><code>module.link(linker)</code><span><a class="mark" href="#vm_module_link_linker" id="vm_module_link_linker">#</a></span></h3>
+<h4><code>module.identifier</code><span><a class="mark" href="#vm_module_identifier" id="vm_module_identifier">#</a></span></h4>
 <ul>
-<li>
-<p><code>linker</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></p>
+<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
+</ul>
+<p>The identifier of the current module, as set in the constructor.</p>
+<h4><code>module.link(linker)</code><span><a class="mark" href="#vm_module_link_linker" id="vm_module_link_linker">#</a></span></h4>
+<ul>
+<li><code>linker</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a>
 <ul>
 <li>
 <p><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The specifier of the requested module:</p>
-<!-- eslint-skip -->
-<pre><code class="language-js"><span class="hljs-keyword">import</span> foo <span class="hljs-keyword">from</span> <span class="hljs-string">'foo'</span>;
+<pre><code class="language-js mjs"><span class="hljs-keyword">import</span> foo <span class="hljs-keyword">from</span> <span class="hljs-string">'foo'</span>;
 <span class="hljs-comment">//              ^^^^^ the module specifier</span></code></pre>
 </li>
 <li>
@@ -627,9 +712,7 @@ Record</a>s in the ECMAScript specification.</p>
 </li>
 </ul>
 </li>
-<li>
-<p>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></p>
-</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
 </ul>
 <p>Link module dependencies. This method must be called before evaluation, and
 can only be called once per module.</p>
@@ -660,7 +743,7 @@ that point all modules would have been fully linked already, the
 specification.</p>
 <p>Corresponds to the <a href="https://tc39.es/ecma262/#sec-moduledeclarationlinking">Link() concrete method</a> field of <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module
 Record</a>s in the ECMAScript specification.</p>
-<h3><code>module.namespace</code><span><a class="mark" href="#vm_module_namespace" id="vm_module_namespace">#</a></span></h3>
+<h4><code>module.namespace</code><span><a class="mark" href="#vm_module_namespace" id="vm_module_namespace">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
@@ -668,7 +751,7 @@ Record</a>s in the ECMAScript specification.</p>
 (<code>module.link()</code>) has completed.</p>
 <p>Corresponds to the <a href="https://tc39.es/ecma262/#sec-getmodulenamespace">GetModuleNamespace</a> abstract operation in the ECMAScript
 specification.</p>
-<h3><code>module.status</code><span><a class="mark" href="#vm_module_status" id="vm_module_status">#</a></span></h3>
+<h4><code>module.status</code><span><a class="mark" href="#vm_module_status" id="vm_module_status">#</a></span></h4>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 </ul>
@@ -700,24 +783,19 @@ itself or a parent module.</p>
 <a href="https://tc39.es/ecma262/#sec-cyclic-module-records">Cyclic Module Record</a>'s <code>[[Status]]</code> field. <code>'errored'</code> corresponds to
 <code>'evaluated'</code> in the specification, but with <code>[[EvaluationError]]</code> set to a
 value that is not <code>undefined</code>.</p>
-<h3><code>module.identifier</code><span><a class="mark" href="#vm_module_identifier" id="vm_module_identifier">#</a></span></h3>
-<ul>
-<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
-</ul>
-<p>The identifier of the current module, as set in the constructor.</p>
-<h2>Class: <code>vm.SourceTextModule</code><span><a class="mark" href="#vm_class_vm_sourcetextmodule" id="vm_class_vm_sourcetextmodule">#</a></span></h2>
+</section><section><h3>Class: <code>vm.SourceTextModule</code><span><a class="mark" href="#vm_class_vm_sourcetextmodule" id="vm_class_vm_sourcetextmodule">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v9.6.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command
-flag enabled.</em></p>
+<p>This feature is only available with the <code>--experimental-vm-modules</code> command
+flag enabled.</p>
 <ul>
 <li>Extends: <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
 </ul>
 <p>The <code>vm.SourceTextModule</code> class provides the <a href="https://tc39.es/ecma262/#sec-source-text-module-records">Source Text Module Record</a> as
 defined in the ECMAScript specification.</p>
-<h3><code>new vm.SourceTextModule(code[, options])</code><span><a class="mark" href="#vm_new_vm_sourcetextmodule_code_options" id="vm_new_vm_sourcetextmodule_code_options">#</a></span></h3>
+<h4><code>new vm.SourceTextModule(code[, options])</code><span><a class="mark" href="#vm_new_vm_sourcetextmodule_code_options" id="vm_new_vm_sourcetextmodule_code_options">#</a></span></h4>
 <ul>
 <li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> JavaScript Module code to parse</li>
 <li><code>options</code>
@@ -733,8 +811,8 @@ source. The <code>code</code> must be the same as the module from which this
 <code>vm.createContext()</code> method, to compile and evaluate this <code>Module</code> in.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the line number offset that is displayed
 in stack traces produced by this <code>Module</code>. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the column number offset that is
-displayed in stack traces produced by this <code>Module</code>. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this <code>Module</code>. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>initializeImportMeta</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this <code>Module</code>
 to initialize the <code>import.meta</code>.
 <ul>
@@ -760,26 +838,48 @@ issues with namespaces that contain <code>then</code> function exports.</li>
 <p>Properties assigned to the <code>import.meta</code> object that are objects may
 allow the module to access information outside the specified <code>context</code>. Use
 <code>vm.runInContext()</code> to create objects in a specific context.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-keyword">const</span> contextifiedObject = vm.createContext({ <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span> });
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> vm <span class="hljs-keyword">from</span> <span class="hljs-string">'vm'</span>;
 
+<span class="hljs-keyword">const</span> contextifiedObject = vm.<span class="hljs-title function_">createContext</span>({ <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span> });
+
+<span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(
+  <span class="hljs-string">'Object.getPrototypeOf(import.meta.prop).secret = secret;'</span>,
+  {
+    <span class="hljs-title function_">initializeImportMeta</span>(<span class="hljs-params">meta</span>) {
+      <span class="hljs-comment">// Note: this object is created in the top context. As such,</span>
+      <span class="hljs-comment">// Object.getPrototypeOf(import.meta.prop) points to the</span>
+      <span class="hljs-comment">// Object.prototype in the top context rather than that in</span>
+      <span class="hljs-comment">// the contextified object.</span>
+      meta.<span class="hljs-property">prop</span> = {};
+    }
+  });
+<span class="hljs-comment">// Since module has no dependencies, the linker function will never be called.</span>
+<span class="hljs-keyword">await</span> <span class="hljs-variable language_">module</span>.<span class="hljs-title function_">link</span>(<span class="hljs-function">() =></span> {});
+<span class="hljs-keyword">await</span> <span class="hljs-variable language_">module</span>.evaluate();
+
+<span class="hljs-comment">// Now, Object.prototype.secret will be equal to 42.</span>
+<span class="hljs-comment">//</span>
+<span class="hljs-comment">// To fix this problem, replace</span>
+<span class="hljs-comment">//     meta.prop = {};</span>
+<span class="hljs-comment">// above with</span>
+<span class="hljs-comment">//     meta.prop = vm.runInContext('{}', contextifiedObject);</span></code><code class="language-js cjs"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
+<span class="hljs-keyword">const</span> contextifiedObject = vm.<span class="hljs-title function_">createContext</span>({ <span class="hljs-attr">secret</span>: <span class="hljs-number">42</span> });
 (<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = <span class="hljs-keyword">new</span> vm.SourceTextModule(
+  <span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(
     <span class="hljs-string">'Object.getPrototypeOf(import.meta.prop).secret = secret;'</span>,
     {
-      initializeImportMeta(meta) {
+      <span class="hljs-title function_">initializeImportMeta</span>(<span class="hljs-params">meta</span>) {
         <span class="hljs-comment">// Note: this object is created in the top context. As such,</span>
         <span class="hljs-comment">// Object.getPrototypeOf(import.meta.prop) points to the</span>
         <span class="hljs-comment">// Object.prototype in the top context rather than that in</span>
         <span class="hljs-comment">// the contextified object.</span>
-        meta.prop = {};
+        meta.<span class="hljs-property">prop</span> = {};
       }
     });
   <span class="hljs-comment">// Since module has no dependencies, the linker function will never be called.</span>
-  <span class="hljs-keyword">await</span> <span class="hljs-built_in">module</span>.link(<span class="hljs-function">() =></span> {});
-  <span class="hljs-keyword">await</span> <span class="hljs-built_in">module</span>.evaluate();
-
+  <span class="hljs-keyword">await</span> <span class="hljs-variable language_">module</span>.<span class="hljs-title function_">link</span>(<span class="hljs-function">() =></span> {});
+  <span class="hljs-keyword">await</span> <span class="hljs-variable language_">module</span>.evaluate();
   <span class="hljs-comment">// Now, Object.prototype.secret will be equal to 42.</span>
   <span class="hljs-comment">//</span>
   <span class="hljs-comment">// To fix this problem, replace</span>
@@ -787,31 +887,31 @@ allow the module to access information outside the specified <code>context</code
   <span class="hljs-comment">// above with</span>
   <span class="hljs-comment">//     meta.prop = vm.runInContext('{}', contextifiedObject);</span>
 })();</code></pre>
-<h3><code>sourceTextModule.createCachedData()</code><span><a class="mark" href="#vm_sourcetextmodule_createcacheddata" id="vm_sourcetextmodule_createcacheddata">#</a></span></h3>
+<h4><code>sourceTextModule.createCachedData()</code><span><a class="mark" href="#vm_sourcetextmodule_createcacheddata" id="vm_sourcetextmodule_createcacheddata">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.7.0</span>
 </div>
 <ul>
 <li>Returns: <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a></li>
 </ul>
-<p>Creates a code cache that can be used with the SourceTextModule constructor's
-<code>cachedData</code> option. Returns a Buffer. This method may be called any number
+<p>Creates a code cache that can be used with the <code>SourceTextModule</code> constructor's
+<code>cachedData</code> option. Returns a <code>Buffer</code>. This method may be called any number
 of times before the module has been evaluated.</p>
 <pre><code class="language-js"><span class="hljs-comment">// Create an initial module</span>
-<span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = <span class="hljs-keyword">new</span> vm.SourceTextModule(<span class="hljs-string">'const a = 1;'</span>);
+<span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">'const a = 1;'</span>);
 
 <span class="hljs-comment">// Create cached data from this module</span>
-<span class="hljs-keyword">const</span> cachedData = <span class="hljs-built_in">module</span>.createCachedData();
+<span class="hljs-keyword">const</span> cachedData = <span class="hljs-variable language_">module</span>.<span class="hljs-title function_">createCachedData</span>();
 
 <span class="hljs-comment">// Create a new module using the cached data. The code must be the same.</span>
-<span class="hljs-keyword">const</span> module2 = <span class="hljs-keyword">new</span> vm.SourceTextModule(<span class="hljs-string">'const a = 1;'</span>, { cachedData });</code></pre>
-<h2>Class: <code>vm.SyntheticModule</code><span><a class="mark" href="#vm_class_vm_syntheticmodule" id="vm_class_vm_syntheticmodule">#</a></span></h2>
+<span class="hljs-keyword">const</span> module2 = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SourceTextModule</span>(<span class="hljs-string">'const a = 1;'</span>, { cachedData });</code></pre>
+</section><section><h3>Class: <code>vm.SyntheticModule</code><span><a class="mark" href="#vm_class_vm_syntheticmodule" id="vm_class_vm_syntheticmodule">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command
-flag enabled.</em></p>
+<p>This feature is only available with the <code>--experimental-vm-modules</code> command
+flag enabled.</p>
 <ul>
 <li>Extends: <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
 </ul>
@@ -822,24 +922,26 @@ module graphs.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
 <span class="hljs-keyword">const</span> source = <span class="hljs-string">'{ "a": 1 }'</span>;
-<span class="hljs-keyword">const</span> <span class="hljs-built_in">module</span> = <span class="hljs-keyword">new</span> vm.SyntheticModule([<span class="hljs-string">'default'</span>], <span class="hljs-function"><span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">const</span> obj = <span class="hljs-built_in">JSON</span>.parse(source);
-  <span class="hljs-built_in">this</span>.setExport(<span class="hljs-string">'default'</span>, obj);
+<span class="hljs-keyword">const</span> <span class="hljs-variable language_">module</span> = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SyntheticModule</span>([<span class="hljs-string">'default'</span>], <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">const</span> obj = <span class="hljs-variable constant_">JSON</span>.<span class="hljs-title function_">parse</span>(source);
+  <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">setExport</span>(<span class="hljs-string">'default'</span>, obj);
 });
 
 <span class="hljs-comment">// Use `module` in linking...</span></code></pre>
-<h3><code>new vm.SyntheticModule(exportNames, evaluateCallback[, options])</code><span><a class="mark" href="#vm_new_vm_syntheticmodule_exportnames_evaluatecallback_options" id="vm_new_vm_syntheticmodule_exportnames_evaluatecallback_options">#</a></span></h3>
+<h4><code>new vm.SyntheticModule(exportNames, evaluateCallback[, options])</code><span><a class="mark" href="#vm_new_vm_syntheticmodule_exportnames_evaluatecallback_options" id="vm_new_vm_syntheticmodule_exportnames_evaluatecallback_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>exportNames</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string[]></a> Array of names that will be exported from the module.</li>
 <li><code>evaluateCallback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called when the module is evaluated.</li>
 <li><code>options</code>
 <ul>
-<li><code>identifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> String used in stack traces.
+<li><code>identifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> String used in stack traces.</li>
+</ul>
 <strong>Default:</strong> <code>'vm:module(i)'</code> where <code>i</code> is a context-specific ascending
-index.</li>
+index.
+<ul>
 <li><code>context</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified</a> object as returned by the
 <code>vm.createContext()</code> method, to compile and evaluate this <code>Module</code> in.</li>
 </ul>
@@ -849,9 +951,9 @@ index.</li>
 <p>Objects assigned to the exports of this instance may allow importers of
 the module to access information outside the specified <code>context</code>. Use
 <code>vm.runInContext()</code> to create objects in a specific context.</p>
-<h3><code>syntheticModule.setExport(name, value)</code><span><a class="mark" href="#vm_syntheticmodule_setexport_name_value" id="vm_syntheticmodule_setexport_name_value">#</a></span></h3>
+<h4><code>syntheticModule.setExport(name, value)</code><span><a class="mark" href="#vm_syntheticmodule_setexport_name_value" id="vm_syntheticmodule_setexport_name_value">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.0.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>name</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Name of the export to set.</li>
@@ -860,21 +962,38 @@ the module to access information outside the specified <code>context</code>. Use
 <p>This method is used after the module is linked to set the values of exports. If
 it is called before the module is linked, an <a href="errors.html#ERR_VM_MODULE_STATUS"><code>ERR_VM_MODULE_STATUS</code></a> error
 will be thrown.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> vm <span class="hljs-keyword">from</span> <span class="hljs-string">'vm'</span>;
+
+<span class="hljs-keyword">const</span> m = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SyntheticModule</span>([<span class="hljs-string">'x'</span>], <span class="hljs-function">() =></span> {
+  m.<span class="hljs-title function_">setExport</span>(<span class="hljs-string">'x'</span>, <span class="hljs-number">1</span>);
+});
+
+<span class="hljs-keyword">await</span> m.<span class="hljs-title function_">link</span>(<span class="hljs-function">() =></span> {});
+<span class="hljs-keyword">await</span> m.evaluate();
+
+assert.<span class="hljs-title function_">strictEqual</span>(m.<span class="hljs-property">namespace</span>.<span class="hljs-property">x</span>, <span class="hljs-number">1</span>);</code><code class="language-js cjs"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 (<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> m = <span class="hljs-keyword">new</span> vm.SyntheticModule([<span class="hljs-string">'x'</span>], <span class="hljs-function">() =></span> {
-    m.setExport(<span class="hljs-string">'x'</span>, <span class="hljs-number">1</span>);
+  <span class="hljs-keyword">const</span> m = <span class="hljs-keyword">new</span> vm.<span class="hljs-title class_">SyntheticModule</span>([<span class="hljs-string">'x'</span>], <span class="hljs-function">() =></span> {
+    m.<span class="hljs-title function_">setExport</span>(<span class="hljs-string">'x'</span>, <span class="hljs-number">1</span>);
   });
-
-  <span class="hljs-keyword">await</span> m.link(<span class="hljs-function">() =></span> {});
+  <span class="hljs-keyword">await</span> m.<span class="hljs-title function_">link</span>(<span class="hljs-function">() =></span> {});
   <span class="hljs-keyword">await</span> m.evaluate();
-
-  assert.strictEqual(m.namespace.x, <span class="hljs-number">1</span>);
+  assert.<span class="hljs-title function_">strictEqual</span>(m.<span class="hljs-property">namespace</span>.<span class="hljs-property">x</span>, <span class="hljs-number">1</span>);
 })();</code></pre>
-<h2><code>vm.compileFunction(code[, params[, options]])</code><span><a class="mark" href="#vm_vm_compilefunction_code_params_options" id="vm_vm_compilefunction_code_params_options">#</a></span></h2>
+</section><section><h3><code>vm.compileFunction(code[, params[, options]])</code><span><a class="mark" href="#vm_vm_compilefunction_code_params_options" id="vm_vm_compilefunction_code_params_options">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v10.10.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.3.0</td>
+<td><p>Removal of <code>importModuleDynamically</code> due to compatibility issues.</p></td></tr>
+<tr><td>v14.1.0, v13.14.0</td>
+<td><p>The <code>importModuleDynamically</code> option is now supported.</p></td></tr>
+<tr><td>v10.10.0</td>
+<td><p><span>Added in: v10.10.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
 <li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The body of the function to compile.</li>
@@ -886,8 +1005,8 @@ function.</li>
 by this script. <strong>Default:</strong> <code>''</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>cachedData</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> Provides an optional <code>Buffer</code> or
 <code>TypedArray</code>, or <code>DataView</code> with V8's code cache data for the supplied
 source.</li>
@@ -905,11 +1024,13 @@ compiling. <strong>Default:</strong> <code>[]</code>.</li>
 <p>Compiles the given code into the provided context (if no context is
 supplied, the current context is used), and returns it wrapped inside a
 function with the given <code>params</code>.</p>
-<h2><code>vm.createContext([contextObject[, options]])</code><span><a class="mark" href="#vm_vm_createcontext_contextobject_options" id="vm_vm_createcontext_contextobject_options">#</a></span></h2>
+</section><section><h3><code>vm.createContext([contextObject[, options]])</code><span><a class="mark" href="#vm_vm_createcontext_contextobject_options" id="vm_vm_createcontext_contextobject_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0</td>
+<td><p>The <code>microtaskMode</code> option is supported now.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The first argument can no longer be a function.</p></td></tr>
 <tr><td>v10.0.0</td>
@@ -941,6 +1062,10 @@ constructors (<code>Function</code>, <code>GeneratorFunction</code>, etc) will t
 module will throw a <code>WebAssembly.CompileError</code>. <strong>Default:</strong> <code>true</code>.</li>
 </ul>
 </li>
+<li><code>microtaskMode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If set to <code>afterEvaluate</code>, microtasks (tasks
+scheduled through <code>Promise</code>s and <code>async function</code>s) will be run immediately
+after a script has run through <a href="#vm_script_runincontext_contextifiedobject_options"><code>script.runInContext()</code></a>.
+They are included in the <code>timeout</code> and <code>breakOnSigint</code> scopes in that case.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> contextified object.</li>
@@ -954,17 +1079,17 @@ properties but also having the built-in objects and functions any standard
 will remain unchanged.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-built_in">global</span>.globalVar = <span class="hljs-number">3</span>;
+<span class="hljs-variable language_">global</span>.<span class="hljs-property">globalVar</span> = <span class="hljs-number">3</span>;
 
 <span class="hljs-keyword">const</span> context = { <span class="hljs-attr">globalVar</span>: <span class="hljs-number">1</span> };
-vm.createContext(context);
+vm.<span class="hljs-title function_">createContext</span>(context);
 
-vm.runInContext(<span class="hljs-string">'globalVar *= 2;'</span>, context);
+vm.<span class="hljs-title function_">runInContext</span>(<span class="hljs-string">'globalVar *= 2;'</span>, context);
 
-<span class="hljs-built_in">console</span>.log(context);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context);
 <span class="hljs-comment">// Prints: { globalVar: 2 }</span>
 
-<span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">global</span>.globalVar);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable language_">global</span>.<span class="hljs-property">globalVar</span>);
 <span class="hljs-comment">// Prints: 3</span></code></pre>
 <p>If <code>contextObject</code> is omitted (or passed explicitly as <code>undefined</code>), a new,
 empty <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified</a> object will be returned.</p>
@@ -975,7 +1100,7 @@ window's global object, then run all <code>&#x3C;script></code> tags together wi
 context.</p>
 <p>The provided <code>name</code> and <code>origin</code> of the context are made visible through the
 Inspector API.</p>
-<h2><code>vm.isContext(object)</code><span><a class="mark" href="#vm_vm_iscontext_object" id="vm_vm_iscontext_object">#</a></span></h2>
+</section><section><h3><code>vm.isContext(object)</code><span><a class="mark" href="#vm_vm_iscontext_object" id="vm_vm_iscontext_object">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.11.7</span>
 </div>
@@ -983,9 +1108,80 @@ Inspector API.</p>
 <li><code>object</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
-<p>Returns <code>true</code> if the given <code>oject</code> object has been <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified</a> using
+<p>Returns <code>true</code> if the given <code>object</code> object has been <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified</a> using
 <a href="#vm_vm_createcontext_contextobject_options"><code>vm.createContext()</code></a>.</p>
-<h2><code>vm.runInContext(code, contextifiedObject[, options])</code><span><a class="mark" href="#vm_vm_runincontext_code_contextifiedobject_options" id="vm_vm_runincontext_code_contextifiedobject_options">#</a></span></h2>
+</section><section><h3><code>vm.measureMemory([options])</code><span><a class="mark" href="#vm_vm_measurememory_options" id="vm_vm_measurememory_options">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v13.10.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<p>Measure the memory known to V8 and used by all contexts known to the
+current V8 isolate, or the main context.</p>
+<ul>
+<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> Optional.
+<ul>
+<li><code>mode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'summary'</code> or <code>'detailed'</code>. In summary mode,
+only the memory measured for the main context will be returned. In
+detailed mode, the measure measured for all contexts known to the
+current V8 isolate will be returned.
+<strong>Default:</strong> <code>'summary'</code></li>
+<li><code>execution</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Either <code>'default'</code> or <code>'eager'</code>. With default
+execution, the promise will not resolve until after the next scheduled
+garbage collection starts, which may take a while (or never if the program
+exits before the next GC). With eager execution, the GC will be started
+right away to measure the memory.
+<strong>Default:</strong> <code>'default'</code></li>
+</ul>
+</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> If the memory is successfully measured the promise will
+resolve with an object containing information about the memory usage.</li>
+</ul>
+<p>The format of the object that the returned Promise may resolve with is
+specific to the V8 engine and may change from one version of V8 to the next.</p>
+<p>The returned result is different from the statistics returned by
+<code>v8.getHeapSpaceStatistics()</code> in that <code>vm.measureMemory()</code> measure the
+memory reachable by each V8 specific contexts in the current instance of
+the V8 engine, while the result of <code>v8.getHeapSpaceStatistics()</code> measure
+the memory occupied by each heap space in the current V8 instance.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
+<span class="hljs-comment">// Measure the memory used by the main context.</span>
+vm.<span class="hljs-title function_">measureMemory</span>({ <span class="hljs-attr">mode</span>: <span class="hljs-string">'summary'</span> })
+  <span class="hljs-comment">// This is the same as vm.measureMemory()</span>
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+    <span class="hljs-comment">// The current format is:</span>
+    <span class="hljs-comment">// {</span>
+    <span class="hljs-comment">//   total: {</span>
+    <span class="hljs-comment">//      jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]</span>
+    <span class="hljs-comment">//    }</span>
+    <span class="hljs-comment">// }</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result);
+  });
+
+<span class="hljs-keyword">const</span> context = vm.<span class="hljs-title function_">createContext</span>({ <span class="hljs-attr">a</span>: <span class="hljs-number">1</span> });
+vm.<span class="hljs-title function_">measureMemory</span>({ <span class="hljs-attr">mode</span>: <span class="hljs-string">'detailed'</span>, <span class="hljs-attr">execution</span>: <span class="hljs-string">'eager'</span> })
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">result</span>) =></span> {
+    <span class="hljs-comment">// Reference the context here so that it won't be GC'ed</span>
+    <span class="hljs-comment">// until the measurement is complete.</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(context.<span class="hljs-property">a</span>);
+    <span class="hljs-comment">// {</span>
+    <span class="hljs-comment">//   total: {</span>
+    <span class="hljs-comment">//     jsMemoryEstimate: 2574732,</span>
+    <span class="hljs-comment">//     jsMemoryRange: [ 2574732, 2904372 ]</span>
+    <span class="hljs-comment">//   },</span>
+    <span class="hljs-comment">//   current: {</span>
+    <span class="hljs-comment">//     jsMemoryEstimate: 2438996,</span>
+    <span class="hljs-comment">//     jsMemoryRange: [ 2438996, 2768636 ]</span>
+    <span class="hljs-comment">//   },</span>
+    <span class="hljs-comment">//   other: [</span>
+    <span class="hljs-comment">//     {</span>
+    <span class="hljs-comment">//       jsMemoryEstimate: 135736,</span>
+    <span class="hljs-comment">//       jsMemoryRange: [ 135736, 465376 ]</span>
+    <span class="hljs-comment">//     }</span>
+    <span class="hljs-comment">//   ]</span>
+    <span class="hljs-comment">// }</span>
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(result);
+  });</code></pre>
+</section><section><h3><code>vm.runInContext(code, contextifiedObject[, options])</code><span><a class="mark" href="#vm_vm_runincontext_code_contextifiedobject_options" id="vm_vm_runincontext_code_contextifiedobject_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1007,19 +1203,19 @@ as the <code>global</code> when the <code>code</code> is compiled and run.</li>
 by this script. <strong>Default:</strong> <code>'evalmachine.&#x3C;anonymous>'</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>displayErrors</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, if an <a href="errors.html#errors_class_error"><code>Error</code></a> occurs
 while compiling the <code>code</code>, the line of code causing the error is attached
 to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="errors.html#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>cachedData</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> Provides an optional <code>Buffer</code> or
 <code>TypedArray</code>, or <code>DataView</code> with V8's code cache data for the supplied
 source. When supplied, the <code>cachedDataRejected</code> value will be set to
@@ -1035,11 +1231,11 @@ This option is <strong>deprecated</strong> in favor of <code>script.createCached
 <li><code>importModuleDynamically</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this module
 when <code>import()</code> is called. If this option is not specified, calls to
 <code>import()</code> will reject with <a href="errors.html#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code></a>.
-This option is part of the experimental modules API, and should not be
-considered stable.
+This option is part of the experimental modules API. We do not recommend
+using it in a production environment.
 <ul>
 <li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> specifier passed to <code>import()</code></li>
-<li><code>module</code> <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
+<li><code>script</code> <a href="vm.html#vm_class_vm_script" class="type">&#x3C;vm.Script></a></li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects" class="type">&#x3C;Module Namespace Object></a> | <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a> Returning a <code>vm.Module</code> is
 recommended in order to take advantage of error tracking, and to avoid
 issues with namespaces that contain <code>then</code> function exports.</li>
@@ -1059,18 +1255,20 @@ previously <a href="#vm_what_does_it_mean_to_contextify_an_object">contextified<
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
 <span class="hljs-keyword">const</span> contextObject = { <span class="hljs-attr">globalVar</span>: <span class="hljs-number">1</span> };
-vm.createContext(contextObject);
+vm.<span class="hljs-title function_">createContext</span>(contextObject);
 
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">10</span>; ++i) {
-  vm.runInContext(<span class="hljs-string">'globalVar *= 2;'</span>, contextObject);
+  vm.<span class="hljs-title function_">runInContext</span>(<span class="hljs-string">'globalVar *= 2;'</span>, contextObject);
 }
-<span class="hljs-built_in">console</span>.log(contextObject);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(contextObject);
 <span class="hljs-comment">// Prints: { globalVar: 1024 }</span></code></pre>
-<h2><code>vm.runInNewContext(code[, contextObject[, options]])</code><span><a class="mark" href="#vm_vm_runinnewcontext_code_contextobject_options" id="vm_vm_runinnewcontext_code_contextobject_options">#</a></span></h2>
+</section><section><h3><code>vm.runInNewContext(code[, contextObject[, options]])</code><span><a class="mark" href="#vm_vm_runinnewcontext_code_contextobject_options" id="vm_vm_runinnewcontext_code_contextobject_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.6.0</td>
+<td><p>The <code>microtaskMode</code> option is supported now.</p></td></tr>
 <tr><td>v10.0.0</td>
 <td><p>The <code>contextCodeGeneration</code> option is supported now.</p></td></tr>
 <tr><td>v6.3.0</td>
@@ -1090,19 +1288,19 @@ vm.createContext(contextObject);
 by this script. <strong>Default:</strong> <code>'evalmachine.&#x3C;anonymous>'</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>displayErrors</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, if an <a href="errors.html#errors_class_error"><code>Error</code></a> occurs
 while compiling the <code>code</code>, the line of code causing the error is attached
 to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="errors.html#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>contextName</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Human-readable name of the newly created context.
 <strong>Default:</strong> <code>'VM Context i'</code>, where <code>i</code> is an ascending numerical index of
 the created context.</li>
@@ -1136,16 +1334,20 @@ This option is <strong>deprecated</strong> in favor of <code>script.createCached
 <li><code>importModuleDynamically</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this module
 when <code>import()</code> is called. If this option is not specified, calls to
 <code>import()</code> will reject with <a href="errors.html#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code></a>.
-This option is part of the experimental modules API, and should not be
-considered stable.
+This option is part of the experimental modules API. We do not recommend
+using it in a production environment.
 <ul>
 <li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> specifier passed to <code>import()</code></li>
-<li><code>module</code> <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
+<li><code>script</code> <a href="vm.html#vm_class_vm_script" class="type">&#x3C;vm.Script></a></li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects" class="type">&#x3C;Module Namespace Object></a> | <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a> Returning a <code>vm.Module</code> is
 recommended in order to take advantage of error tracking, and to avoid
 issues with namespaces that contain <code>then</code> function exports.</li>
 </ul>
 </li>
+<li><code>microtaskMode</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If set to <code>afterEvaluate</code>, microtasks (tasks
+scheduled through <code>Promise</code>s and <code>async function</code>s) will be run immediately
+after the script has run. They are included in the <code>timeout</code> and
+<code>breakOnSigint</code> scopes in that case.</li>
 </ul>
 </li>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> the result of the very last statement executed in the script.</li>
@@ -1164,10 +1366,10 @@ variable and sets a new one. These globals are contained in the <code>contextObj
   <span class="hljs-attr">count</span>: <span class="hljs-number">2</span>
 };
 
-vm.runInNewContext(<span class="hljs-string">'count += 1; name = "kitty"'</span>, contextObject);
-<span class="hljs-built_in">console</span>.log(contextObject);
+vm.<span class="hljs-title function_">runInNewContext</span>(<span class="hljs-string">'count += 1; name = "kitty"'</span>, contextObject);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(contextObject);
 <span class="hljs-comment">// Prints: { animal: 'cat', count: 3, name: 'kitty' }</span></code></pre>
-<h2><code>vm.runInThisContext(code[, options])</code><span><a class="mark" href="#vm_vm_runinthiscontext_code_options" id="vm_vm_runinthiscontext_code_options">#</a></span></h2>
+</section><section><h3><code>vm.runInThisContext(code[, options])</code><span><a class="mark" href="#vm_vm_runinthiscontext_code_options" id="vm_vm_runinthiscontext_code_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1187,19 +1389,19 @@ vm.runInNewContext(<span class="hljs-string">'count += 1; name = "kitty"'</span>
 by this script. <strong>Default:</strong> <code>'evalmachine.&#x3C;anonymous>'</code>.</li>
 <li><code>lineOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the line number offset that is displayed
 in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
-<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the column number offset that is displayed
-in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
+<li><code>columnOffset</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Specifies the first-line column number offset that
+is displayed in stack traces produced by this script. <strong>Default:</strong> <code>0</code>.</li>
 <li><code>displayErrors</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> When <code>true</code>, if an <a href="errors.html#errors_class_error"><code>Error</code></a> occurs
 while compiling the <code>code</code>, the line of code causing the error is attached
 to the stack trace. <strong>Default:</strong> <code>true</code>.</li>
 <li><code>timeout</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;integer></a> Specifies the number of milliseconds to execute <code>code</code>
 before terminating execution. If execution is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a>
 will be thrown. This value must be a strictly positive integer.</li>
-<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, the execution will be terminated when
-<code>SIGINT</code> (Ctrl+C) is received. Existing handlers for the
-event that have been attached via <code>process.on('SIGINT')</code> will be disabled
-during script execution, but will continue to work after that. If execution
-is terminated, an <a href="errors.html#errors_class_error"><code>Error</code></a> will be thrown. <strong>Default:</strong> <code>false</code>.</li>
+<li><code>breakOnSigint</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> If <code>true</code>, receiving <code>SIGINT</code>
+(<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+<a href="errors.html#errors_class_error"><code>Error</code></a>. Existing handlers for the event that have been attached via
+<code>process.on('SIGINT')</code> are disabled during script execution, but continue to
+work after that. <strong>Default:</strong> <code>false</code>.</li>
 <li><code>cachedData</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> Provides an optional <code>Buffer</code> or
 <code>TypedArray</code>, or <code>DataView</code> with V8's code cache data for the supplied
 source. When supplied, the <code>cachedDataRejected</code> value will be set to
@@ -1215,11 +1417,11 @@ This option is <strong>deprecated</strong> in favor of <code>script.createCached
 <li><code>importModuleDynamically</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Called during evaluation of this module
 when <code>import()</code> is called. If this option is not specified, calls to
 <code>import()</code> will reject with <a href="errors.html#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING"><code>ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING</code></a>.
-This option is part of the experimental modules API, and should not be
-considered stable.
+This option is part of the experimental modules API. We do not recommend
+using it in a production environment.
 <ul>
 <li><code>specifier</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> specifier passed to <code>import()</code></li>
-<li><code>module</code> <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a></li>
+<li><code>script</code> <a href="vm.html#vm_class_vm_script" class="type">&#x3C;vm.Script></a></li>
 <li>Returns: <a href="https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects" class="type">&#x3C;Module Namespace Object></a> | <a href="vm.html#vm_class_vm_module" class="type">&#x3C;vm.Module></a> Returning a <code>vm.Module</code> is
 recommended in order to take advantage of error tracking, and to avoid
 issues with namespaces that contain <code>then</code> function exports.</li>
@@ -1239,19 +1441,19 @@ the JavaScript <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 <span class="hljs-keyword">let</span> localVar = <span class="hljs-string">'initial value'</span>;
 
-<span class="hljs-keyword">const</span> vmResult = vm.runInThisContext(<span class="hljs-string">'localVar = "vm";'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`vmResult: '<span class="hljs-subst">${vmResult}</span>', localVar: '<span class="hljs-subst">${localVar}</span>'`</span>);
+<span class="hljs-keyword">const</span> vmResult = vm.<span class="hljs-title function_">runInThisContext</span>(<span class="hljs-string">'localVar = "vm";'</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`vmResult: '<span class="hljs-subst">${vmResult}</span>', localVar: '<span class="hljs-subst">${localVar}</span>'`</span>);
 <span class="hljs-comment">// Prints: vmResult: 'vm', localVar: 'initial value'</span>
 
 <span class="hljs-keyword">const</span> evalResult = <span class="hljs-built_in">eval</span>(<span class="hljs-string">'localVar = "eval";'</span>);
-<span class="hljs-built_in">console</span>.log(<span class="hljs-string">`evalResult: '<span class="hljs-subst">${evalResult}</span>', localVar: '<span class="hljs-subst">${localVar}</span>'`</span>);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">`evalResult: '<span class="hljs-subst">${evalResult}</span>', localVar: '<span class="hljs-subst">${localVar}</span>'`</span>);
 <span class="hljs-comment">// Prints: evalResult: 'eval', localVar: 'eval'</span></code></pre>
 <p>Because <code>vm.runInThisContext()</code> does not have access to the local scope,
 <code>localVar</code> is unchanged. In contrast, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval"><code>eval()</code></a> <em>does</em> have access to the
 local scope, so the value <code>localVar</code> is changed. In this way
 <code>vm.runInThisContext()</code> is much like an <a href="https://es5.github.io/#x10.4.2">indirect <code>eval()</code> call</a>, e.g.
 <code>(0,eval)('code')</code>.</p>
-<h2>Example: Running an HTTP server within a VM<span><a class="mark" href="#vm_example_running_an_http_server_within_a_vm" id="vm_example_running_an_http_server_within_a_vm">#</a></span></h2>
+</section><section><h3>Example: Running an HTTP server within a VM<span><a class="mark" href="#vm_example_running_an_http_server_within_a_vm" id="vm_example_running_an_http_server_within_a_vm">#</a></span></h3>
 <p>When using either <a href="#vm_script_runinthiscontext_options"><code>script.runInThisContext()</code></a> or
 <a href="#vm_vm_runinthiscontext_code_options"><code>vm.runInThisContext()</code></a>, the code is executed within the current V8 global
 context. The code passed to this VM context will have its own isolated scope.</p>
@@ -1273,11 +1475,11 @@ to the <code>http</code> module passed to it. For instance:</p>
   console.log('Server running at http://127.0.0.1:8124/');
 })`</span>;
 
-vm.runInThisContext(code)(<span class="hljs-built_in">require</span>);</code></pre>
+vm.<span class="hljs-title function_">runInThisContext</span>(code)(<span class="hljs-built_in">require</span>);</code></pre>
 <p>The <code>require()</code> in the above case shares the state with the context it is
 passed from. This may introduce risks when untrusted code is executed, e.g.
 altering objects in the context in unwanted ways.</p>
-<h2>What does it mean to "contextify" an object?<span><a class="mark" href="#vm_what_does_it_mean_to_contextify_an_object" id="vm_what_does_it_mean_to_contextify_an_object">#</a></span></h2>
+</section><section><h3>What does it mean to "contextify" an object?<span><a class="mark" href="#vm_what_does_it_mean_to_contextify_an_object" id="vm_what_does_it_mean_to_contextify_an_object">#</a></span></h3>
 <p>All JavaScript executed within Node.js runs within the scope of a "context".
 According to the <a href="https://v8.dev/docs/embed#contexts">V8 Embedder's Guide</a>:</p>
 <blockquote>
@@ -1292,33 +1494,95 @@ internally with a new instance of a V8 Context. This V8 Context provides the
 within which it can operate. The process of creating the V8 Context and
 associating it with the <code>contextObject</code> is what this document refers to as
 "contextifying" the object.</p>
-<h2>Timeout limitations when using <code>process.nextTick()</code>, promises, and <code>queueMicrotask()</code><span><a class="mark" href="#vm_timeout_limitations_when_using_process_nexttick_promises_and_queuemicrotask" id="vm_timeout_limitations_when_using_process_nexttick_promises_and_queuemicrotask">#</a></span></h2>
-<p>Because of the internal mechanics of how the <code>process.nextTick()</code> queue and
-the microtask queue that underlies Promises are implemented within V8 and
-Node.js, it is possible for code running within a context to "escape" the
-<code>timeout</code> set using <code>vm.runInContext()</code>, <code>vm.runInNewContext()</code>, and
-<code>vm.runInThisContext()</code>.</p>
+</section><section><h3>Timeout interactions with asynchronous tasks and Promises<span><a class="mark" href="#vm_timeout_interactions_with_asynchronous_tasks_and_promises" id="vm_timeout_interactions_with_asynchronous_tasks_and_promises">#</a></span></h3>
+<p><code>Promise</code>s and <code>async function</code>s can schedule tasks run by the JavaScript
+engine asynchronously. By default, these tasks are run after all JavaScript
+functions on the current stack are done executing.
+This allows escaping the functionality of the <code>timeout</code> and
+<code>breakOnSigint</code> options.</p>
 <p>For example, the following code executed by <code>vm.runInNewContext()</code> with a
 timeout of 5 milliseconds schedules an infinite loop to run after a promise
 resolves. The scheduled loop is never interrupted by the timeout:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
 
-<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">loop</span>(<span class="hljs-params"></span>) </span>{
-  <span class="hljs-keyword">while</span> (<span class="hljs-number">1</span>) <span class="hljs-built_in">console</span>.log(<span class="hljs-built_in">Date</span>.now());
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">loop</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'entering loop'</span>);
+  <span class="hljs-keyword">while</span> (<span class="hljs-number">1</span>) <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>());
 }
 
-vm.runInNewContext(
-  <span class="hljs-string">'Promise.resolve().then(loop);'</span>,
-  { loop, <span class="hljs-built_in">console</span> },
+vm.<span class="hljs-title function_">runInNewContext</span>(
+  <span class="hljs-string">'Promise.resolve().then(() => loop());'</span>,
+  { loop, <span class="hljs-variable language_">console</span> },
   { <span class="hljs-attr">timeout</span>: <span class="hljs-number">5</span> }
+);
+<span class="hljs-comment">// This is printed *before* 'entering loop' (!)</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'done executing'</span>);</code></pre>
+<p>This can be addressed by passing <code>microtaskMode: 'afterEvaluate'</code> to the code
+that creates the <code>Context</code>:</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> vm = <span class="hljs-built_in">require</span>(<span class="hljs-string">'vm'</span>);
+
+<span class="hljs-keyword">function</span> <span class="hljs-title function_">loop</span>(<span class="hljs-params"></span>) {
+  <span class="hljs-keyword">while</span> (<span class="hljs-number">1</span>) <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>());
+}
+
+vm.<span class="hljs-title function_">runInNewContext</span>(
+  <span class="hljs-string">'Promise.resolve().then(() => loop());'</span>,
+  { loop, <span class="hljs-variable language_">console</span> },
+  { <span class="hljs-attr">timeout</span>: <span class="hljs-number">5</span>, <span class="hljs-attr">microtaskMode</span>: <span class="hljs-string">'afterEvaluate'</span> }
 );</code></pre>
-<p>This issue also occurs when the <code>loop()</code> call is scheduled using
-the <code>process.nextTick()</code> and <code>queueMicrotask()</code> functions.</p>
-<p>This issue occurs because all contexts share the same microtask and nextTick
-queues.</p>
+<p>In this case, the microtask scheduled through <code>promise.then()</code> will be run
+before returning from <code>vm.runInNewContext()</code>, and will be interrupted
+by the <code>timeout</code> functionality. This applies only to code running in a
+<code>vm.Context</code>, so e.g. <a href="#vm_vm_runinthiscontext_code_options"><code>vm.runInThisContext()</code></a> does not take this option.</p>
+<p>Promise callbacks are entered into the microtask queue of the context in which
+they were created. For example, if <code>() => loop()</code> is replaced with just <code>loop</code>
+in the above example, then <code>loop</code> will be pushed into the global microtask
+queue, because it is a function from the outer (main) context, and thus will
+also be able to escape the timeout.</p>
+<p>If asynchronous scheduling functions such as <code>process.nextTick()</code>,
+<code>queueMicrotask()</code>, <code>setTimeout()</code>, <code>setImmediate()</code>, etc. are made available
+inside a <code>vm.Context</code>, functions passed to them will be added to global queues,
+which are shared by all contexts. Therefore, callbacks passed to those functions
+are not controllable through the timeout either.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/vm.json b/doc/api/vm.json
index 496119cf48249ff5d57d6388cbdde2b66f59f676..b922b92f724a4392664f2408b55829224c67b5f5 100644
--- a/doc/api/vm.json
+++ b/doc/api/vm.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/vm.js\">lib/vm.js</a></p>\n<p>The <code>vm</code> module enables compiling and running code within V8 Virtual\nMachine contexts. <strong>The <code>vm</code> module is not a security mechanism. Do\nnot use it to run untrusted code</strong>.</p>\n<p>JavaScript code can be compiled and run immediately or\ncompiled, saved, and run later.</p>\n<p>A common use case is to run the code in a different V8 Context. This means\ninvoked code has a different global object than the invoking code.</p>\n<p>One can provide the context by <a href=\"#vm_what_does_it_mean_to_contextify_an_object\"><em>contextifying</em></a> an\nobject. The invoked code treats any property in the context like a\nglobal variable. Any changes to global variables caused by the invoked\ncode are reflected in the context object.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst x = 1;\n\nconst context = { x: 2 };\nvm.createContext(context); // Contextify the object.\n\nconst code = 'x += 40; var y = 17;';\n// `x` and `y` are global variables in the context.\n// Initially, x has the value 2 because that is the value of context.x.\nvm.runInContext(code, context);\n\nconsole.log(context.x); // 42\nconsole.log(context.y); // 17\n\nconsole.log(x); // 1; y is not defined.\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/vm.js\">lib/vm.js</a></p>\n<p>The <code>vm</code> module enables compiling and running code within V8 Virtual\nMachine contexts. <strong>The <code>vm</code> module is not a security mechanism. Do\nnot use it to run untrusted code</strong>.</p>\n<p>JavaScript code can be compiled and run immediately or\ncompiled, saved, and run later.</p>\n<p>A common use case is to run the code in a different V8 Context. This means\ninvoked code has a different global object than the invoking code.</p>\n<p>One can provide the context by <a href=\"#vm_what_does_it_mean_to_contextify_an_object\"><em>contextifying</em></a> an\nobject. The invoked code treats any property in the context like a\nglobal variable. Any changes to global variables caused by the invoked\ncode are reflected in the context object.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst x = 1;\n\nconst context = { x: 2 };\nvm.createContext(context); // Contextify the object.\n\nconst code = 'x += 40; var y = 17;';\n// `x` and `y` are global variables in the context.\n// Initially, x has the value 2 because that is the value of context.x.\nvm.runInContext(code, context);\n\nconsole.log(context.x); // 42\nconsole.log(context.y); // 17\n\nconsole.log(x); // 1; y is not defined.\n</code></pre>",
       "classes": [
         {
           "textRaw": "Class: `vm.Script`",
@@ -42,7 +42,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Creates a code cache that can be used with the Script constructor's\n<code>cachedData</code> option. Returns a Buffer. This method may be called at any\ntime and any number of times.</p>\n<pre><code class=\"language-js\">const script = new vm.Script(`\nfunction add(a, b) {\n  return a + b;\n}\n\nconst x = add(1, 2);\n`);\n\nconst cacheWithoutX = script.createCachedData();\n\nscript.runInThisContext();\n\nconst cacheWithX = script.createCachedData();\n</code></pre>"
+              "desc": "<p>Creates a code cache that can be used with the <code>Script</code> constructor's\n<code>cachedData</code> option. Returns a <code>Buffer</code>. This method may be called at any\ntime and any number of times.</p>\n<pre><code class=\"language-js\">const script = new vm.Script(`\nfunction add(a, b) {\n  return a + b;\n}\n\nconst x = add(1, 2);\n`);\n\nconst cacheWithoutX = script.createCachedData();\n\nscript.runInThisContext();\n\nconst cacheWithX = script.createCachedData();\n</code></pre>"
             },
             {
               "textRaw": "`script.runInContext(contextifiedObject[, options])`",
@@ -94,11 +94,11 @@
                           "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                         },
                         {
-                          "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                          "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                           "name": "breakOnSigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                          "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                         }
                       ]
                     }
@@ -116,6 +116,11 @@
                   "v0.3.1"
                 ],
                 "changes": [
+                  {
+                    "version": "v14.6.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/34023",
+                    "description": "The `microtaskMode` option is supported now."
+                  },
                   {
                     "version": "v10.0.0",
                     "pr-url": "https://github.com/nodejs/node/pull/19016",
@@ -162,11 +167,11 @@
                           "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                         },
                         {
-                          "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                          "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                           "name": "breakOnSigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                          "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                         },
                         {
                           "textRaw": "`contextName` {string} Human-readable name of the newly created context. **Default:** `'VM Context i'`, where `i` is an ascending numerical index of the created context.",
@@ -202,6 +207,12 @@
                               "desc": "If set to false any attempt to compile a WebAssembly module will throw a `WebAssembly.CompileError`."
                             }
                           ]
+                        },
+                        {
+                          "textRaw": "`microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after the script has run. They are included in the `timeout` and `breakOnSigint` scopes in that case.",
+                          "name": "microtaskMode",
+                          "type": "string",
+                          "desc": "If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after the script has run. They are included in the `timeout` and `breakOnSigint` scopes in that case."
                         }
                       ]
                     }
@@ -254,11 +265,11 @@
                           "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                         },
                         {
-                          "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                          "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                           "name": "breakOnSigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                          "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                         }
                       ]
                     }
@@ -297,11 +308,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or `TypedArray`, or `DataView` with V8's code cache data for the supplied source. When supplied, the `cachedDataRejected` value will be set to either `true` or `false` depending on acceptance of the data by V8.",
@@ -317,10 +328,10 @@
                       "desc": "When `true` and no `cachedData` is present, V8 will attempt to produce code cache data for `code`. Upon success, a `Buffer` with V8's code cache data will be produced and stored in the `cachedData` property of the returned `vm.Script` instance. The `cachedDataProduced` value will be set to either `true` or `false` depending on whether code cache data is produced successfully. This option is **deprecated** in favor of `script.createCachedData()`."
                     },
                     {
-                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "name": "importModuleDynamically",
                       "type": "Function",
-                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "options": [
                         {
                           "textRaw": "`specifier` {string} specifier passed to `import()`",
@@ -329,9 +340,9 @@
                           "desc": "specifier passed to `import()`"
                         },
                         {
-                          "textRaw": "`module` {vm.Module}",
-                          "name": "module",
-                          "type": "vm.Module"
+                          "textRaw": "`script` {vm.Script}",
+                          "name": "script",
+                          "type": "vm.Script"
                         },
                         {
                           "textRaw": "Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports.",
@@ -354,13 +365,14 @@
           "name": "vm.Module",
           "meta": {
             "added": [
+              "v13.0.0",
               "v12.16.0"
             ],
             "changes": []
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</em></p>\n<p>The <code>vm.Module</code> class provides a low-level interface for using\nECMAScript modules in VM contexts. It is the counterpart of the <code>vm.Script</code>\nclass that closely mirrors <a href=\"https://www.ecma-international.org/ecma-262/#sec-abstract-module-records\">Module Record</a>s as defined in the ECMAScript\nspecification.</p>\n<p>Unlike <code>vm.Script</code> however, every <code>vm.Module</code> object is bound to a context from\nits creation. Operations on <code>vm.Module</code> objects are intrinsically asynchronous,\nin contrast with the synchronous nature of <code>vm.Script</code> objects. The use of\n'async' functions can help with manipulating <code>vm.Module</code> objects.</p>\n<p>Using a <code>vm.Module</code> object requires three distinct steps: creation/parsing,\nlinking, and evaluation. These three steps are illustrated in the following\nexample.</p>\n<p>This implementation lies at a lower level than the <a href=\"esm.html#esm_modules_ecmascript_modules\">ECMAScript Module\nloader</a>. There is also no way to interact with the Loader yet, though\nsupport is planned.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst contextifiedObject = vm.createContext({ secret: 42 });\n\n(async () => {\n  // Step 1\n  //\n  // Create a Module by constructing a new `vm.SourceTextModule` object. This\n  // parses the provided source text, throwing a `SyntaxError` if anything goes\n  // wrong. By default, a Module is created in the top context. But here, we\n  // specify `contextifiedObject` as the context this Module belongs to.\n  //\n  // Here, we attempt to obtain the default export from the module \"foo\", and\n  // put it into local binding \"secret\".\n\n  const bar = new vm.SourceTextModule(`\n    import s from 'foo';\n    s;\n  `, { context: contextifiedObject });\n\n  // Step 2\n  //\n  // \"Link\" the imported dependencies of this Module to it.\n  //\n  // The provided linking callback (the \"linker\") accepts two arguments: the\n  // parent module (`bar` in this case) and the string that is the specifier of\n  // the imported module. The callback is expected to return a Module that\n  // corresponds to the provided specifier, with certain requirements documented\n  // in `module.link()`.\n  //\n  // If linking has not started for the returned Module, the same linker\n  // callback will be called on the returned Module.\n  //\n  // Even top-level Modules without dependencies must be explicitly linked. The\n  // callback provided would never be called, however.\n  //\n  // The link() method returns a Promise that will be resolved when all the\n  // Promises returned by the linker resolve.\n  //\n  // Note: This is a contrived example in that the linker function creates a new\n  // \"foo\" module every time it is called. In a full-fledged module system, a\n  // cache would probably be used to avoid duplicated modules.\n\n  async function linker(specifier, referencingModule) {\n    if (specifier === 'foo') {\n      return new vm.SourceTextModule(`\n        // The \"secret\" variable refers to the global variable we added to\n        // \"contextifiedObject\" when creating the context.\n        export default secret;\n      `, { context: referencingModule.context });\n\n      // Using `contextifiedObject` instead of `referencingModule.context`\n      // here would work as well.\n    }\n    throw new Error(`Unable to resolve dependency: ${specifier}`);\n  }\n  await bar.link(linker);\n\n  // Step 3\n  //\n  // Evaluate the Module. The evaluate() method returns a Promise with a single\n  // property \"result\" that contains the result of the very last statement\n  // executed in the Module. In the case of `bar`, it is `s;`, which refers to\n  // the default export of the `foo` module, the `secret` we set in the\n  // beginning to 42.\n\n  const { result } = await bar.evaluate();\n\n  console.log(result);\n  // Prints 42.\n})();\n</code></pre>",
+          "desc": "<p>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</p>\n<p>The <code>vm.Module</code> class provides a low-level interface for using\nECMAScript modules in VM contexts. It is the counterpart of the <code>vm.Script</code>\nclass that closely mirrors <a href=\"https://www.ecma-international.org/ecma-262/#sec-abstract-module-records\">Module Record</a>s as defined in the ECMAScript\nspecification.</p>\n<p>Unlike <code>vm.Script</code> however, every <code>vm.Module</code> object is bound to a context from\nits creation. Operations on <code>vm.Module</code> objects are intrinsically asynchronous,\nin contrast with the synchronous nature of <code>vm.Script</code> objects. The use of\n'async' functions can help with manipulating <code>vm.Module</code> objects.</p>\n<p>Using a <code>vm.Module</code> object requires three distinct steps: creation/parsing,\nlinking, and evaluation. These three steps are illustrated in the following\nexample.</p>\n<p>This implementation lies at a lower level than the <a href=\"esm.html#esm_modules_ecmascript_modules\">ECMAScript Module\nloader</a>. There is also no way to interact with the Loader yet, though\nsupport is planned.</p>\n<pre><code class=\"language-mjs\">import vm from 'vm';\n\nconst contextifiedObject = vm.createContext({\n  secret: 42,\n  print: console.log,\n});\n\n// Step 1\n//\n// Create a Module by constructing a new `vm.SourceTextModule` object. This\n// parses the provided source text, throwing a `SyntaxError` if anything goes\n// wrong. By default, a Module is created in the top context. But here, we\n// specify `contextifiedObject` as the context this Module belongs to.\n//\n// Here, we attempt to obtain the default export from the module \"foo\", and\n// put it into local binding \"secret\".\n\nconst bar = new vm.SourceTextModule(`\n  import s from 'foo';\n  s;\n  print(s);\n`, { context: contextifiedObject });\n\n// Step 2\n//\n// \"Link\" the imported dependencies of this Module to it.\n//\n// The provided linking callback (the \"linker\") accepts two arguments: the\n// parent module (`bar` in this case) and the string that is the specifier of\n// the imported module. The callback is expected to return a Module that\n// corresponds to the provided specifier, with certain requirements documented\n// in `module.link()`.\n//\n// If linking has not started for the returned Module, the same linker\n// callback will be called on the returned Module.\n//\n// Even top-level Modules without dependencies must be explicitly linked. The\n// callback provided would never be called, however.\n//\n// The link() method returns a Promise that will be resolved when all the\n// Promises returned by the linker resolve.\n//\n// Note: This is a contrived example in that the linker function creates a new\n// \"foo\" module every time it is called. In a full-fledged module system, a\n// cache would probably be used to avoid duplicated modules.\n\nasync function linker(specifier, referencingModule) {\n  if (specifier === 'foo') {\n    return new vm.SourceTextModule(`\n      // The \"secret\" variable refers to the global variable we added to\n      // \"contextifiedObject\" when creating the context.\n      export default secret;\n    `, { context: referencingModule.context });\n\n    // Using `contextifiedObject` instead of `referencingModule.context`\n    // here would work as well.\n  }\n  throw new Error(`Unable to resolve dependency: ${specifier}`);\n}\nawait bar.link(linker);\n\n// Step 3\n//\n// Evaluate the Module. The evaluate() method returns a promise which will\n// resolve after the module has finished evaluating.\n\n// Prints 42.\nawait bar.evaluate();\n</code></pre>\n<pre><code class=\"language-cjs\">const vm = require('vm');\n\nconst contextifiedObject = vm.createContext({\n  secret: 42,\n  print: console.log,\n});\n\n(async () => {\n  // Step 1\n  //\n  // Create a Module by constructing a new `vm.SourceTextModule` object. This\n  // parses the provided source text, throwing a `SyntaxError` if anything goes\n  // wrong. By default, a Module is created in the top context. But here, we\n  // specify `contextifiedObject` as the context this Module belongs to.\n  //\n  // Here, we attempt to obtain the default export from the module \"foo\", and\n  // put it into local binding \"secret\".\n\n  const bar = new vm.SourceTextModule(`\n    import s from 'foo';\n    s;\n    print(s);\n  `, { context: contextifiedObject });\n\n  // Step 2\n  //\n  // \"Link\" the imported dependencies of this Module to it.\n  //\n  // The provided linking callback (the \"linker\") accepts two arguments: the\n  // parent module (`bar` in this case) and the string that is the specifier of\n  // the imported module. The callback is expected to return a Module that\n  // corresponds to the provided specifier, with certain requirements documented\n  // in `module.link()`.\n  //\n  // If linking has not started for the returned Module, the same linker\n  // callback will be called on the returned Module.\n  //\n  // Even top-level Modules without dependencies must be explicitly linked. The\n  // callback provided would never be called, however.\n  //\n  // The link() method returns a Promise that will be resolved when all the\n  // Promises returned by the linker resolve.\n  //\n  // Note: This is a contrived example in that the linker function creates a new\n  // \"foo\" module every time it is called. In a full-fledged module system, a\n  // cache would probably be used to avoid duplicated modules.\n\n  async function linker(specifier, referencingModule) {\n    if (specifier === 'foo') {\n      return new vm.SourceTextModule(`\n        // The \"secret\" variable refers to the global variable we added to\n        // \"contextifiedObject\" when creating the context.\n        export default secret;\n      `, { context: referencingModule.context });\n\n      // Using `contextifiedObject` instead of `referencingModule.context`\n      // here would work as well.\n    }\n    throw new Error(`Unable to resolve dependency: ${specifier}`);\n  }\n  await bar.link(linker);\n\n  // Step 3\n  //\n  // Evaluate the Module. The evaluate() method returns a promise which will\n  // resolve after the module has finished evaluating.\n\n  // Prints 42.\n  await bar.evaluate();\n})();\n</code></pre>",
           "properties": [
             {
               "textRaw": "`dependencySpecifiers` {string[]}",
@@ -374,6 +386,12 @@
               "name": "error",
               "desc": "<p>If the <code>module.status</code> is <code>'errored'</code>, this property contains the exception\nthrown by the module during evaluation. If the status is anything else,\naccessing this property will result in a thrown exception.</p>\n<p>The value <code>undefined</code> cannot be used for cases where there is not a thrown\nexception due to possible ambiguity with <code>throw undefined;</code>.</p>\n<p>Corresponds to the <code>[[EvaluationError]]</code> field of <a href=\"https://tc39.es/ecma262/#sec-cyclic-module-records\">Cyclic Module Record</a>s\nin the ECMAScript specification.</p>"
             },
+            {
+              "textRaw": "`identifier` {string}",
+              "type": "string",
+              "name": "identifier",
+              "desc": "<p>The identifier of the current module, as set in the constructor.</p>"
+            },
             {
               "textRaw": "`namespace` {Object}",
               "type": "Object",
@@ -385,12 +403,6 @@
               "type": "string",
               "name": "status",
               "desc": "<p>The current status of the module. Will be one of:</p>\n<ul>\n<li>\n<p><code>'unlinked'</code>: <code>module.link()</code> has not yet been called.</p>\n</li>\n<li>\n<p><code>'linking'</code>: <code>module.link()</code> has been called, but not all Promises returned\nby the linker function have been resolved yet.</p>\n</li>\n<li>\n<p><code>'linked'</code>: The module has been linked successfully, and all of its\ndependencies are linked, but <code>module.evaluate()</code> has not yet been called.</p>\n</li>\n<li>\n<p><code>'evaluating'</code>: The module is being evaluated through a <code>module.evaluate()</code> on\nitself or a parent module.</p>\n</li>\n<li>\n<p><code>'evaluated'</code>: The module has been successfully evaluated.</p>\n</li>\n<li>\n<p><code>'errored'</code>: The module has been evaluated, but an exception was thrown.</p>\n</li>\n</ul>\n<p>Other than <code>'errored'</code>, this status string corresponds to the specification's\n<a href=\"https://tc39.es/ecma262/#sec-cyclic-module-records\">Cyclic Module Record</a>'s <code>[[Status]]</code> field. <code>'errored'</code> corresponds to\n<code>'evaluated'</code> in the specification, but with <code>[[EvaluationError]]</code> set to a\nvalue that is not <code>undefined</code>.</p>"
-            },
-            {
-              "textRaw": "`identifier` {string}",
-              "type": "string",
-              "name": "identifier",
-              "desc": "<p>The identifier of the current module, as set in the constructor.</p>"
             }
           ],
           "methods": [
@@ -401,9 +413,10 @@
               "signatures": [
                 {
                   "return": {
-                    "textRaw": "Returns: {Promise}",
+                    "textRaw": "Returns: {Promise} Fulfills with `undefined` upon success.",
                     "name": "return",
-                    "type": "Promise"
+                    "type": "Promise",
+                    "desc": "Fulfills with `undefined` upon success."
                   },
                   "params": [
                     {
@@ -418,18 +431,18 @@
                           "desc": "Specifies the number of milliseconds to evaluate before terminating execution. If execution is interrupted, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                         },
                         {
-                          "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is interrupted, an [`Error`][] will be thrown. **Default:** `false`.",
+                          "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                           "name": "breakOnSigint",
                           "type": "boolean",
                           "default": "`false`",
-                          "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is interrupted, an [`Error`][] will be thrown."
+                          "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                         }
                       ]
                     }
                   ]
                 }
               ],
-              "desc": "<p>Evaluate the module.</p>\n<p>This must be called after the module has been linked; otherwise it will\nthrow an error. It could be called also when the module has already been\nevaluated, in which case it will do one of the following two things:</p>\n<ul>\n<li>return <code>undefined</code> if the initial evaluation ended in success (<code>module.status</code>\nis <code>'evaluated'</code>)</li>\n<li>rethrow the same exception the initial evaluation threw if the initial\nevaluation ended in an error (<code>module.status</code> is <code>'errored'</code>)</li>\n</ul>\n<p>This method cannot be called while the module is being evaluated\n(<code>module.status</code> is <code>'evaluating'</code>) to prevent infinite recursion.</p>\n<p>Corresponds to the <a href=\"https://tc39.es/ecma262/#sec-moduleevaluation\">Evaluate() concrete method</a> field of <a href=\"https://tc39.es/ecma262/#sec-cyclic-module-records\">Cyclic Module\nRecord</a>s in the ECMAScript specification.</p>"
+              "desc": "<p>Evaluate the module.</p>\n<p>This must be called after the module has been linked; otherwise it will reject.\nIt could be called also when the module has already been evaluated, in which\ncase it will either do nothing if the initial evaluation ended in success\n(<code>module.status</code> is <code>'evaluated'</code>) or it will re-throw the exception that the\ninitial evaluation resulted in (<code>module.status</code> is <code>'errored'</code>).</p>\n<p>This method cannot be called while the module is being evaluated\n(<code>module.status</code> is <code>'evaluating'</code>).</p>\n<p>Corresponds to the <a href=\"https://tc39.es/ecma262/#sec-moduleevaluation\">Evaluate() concrete method</a> field of <a href=\"https://tc39.es/ecma262/#sec-cyclic-module-records\">Cyclic Module\nRecord</a>s in the ECMAScript specification.</p>"
             },
             {
               "textRaw": "`module.link(linker)`",
@@ -449,10 +462,10 @@
                       "type": "Function",
                       "options": [
                         {
-                          "textRaw": "`specifier` {string} The specifier of the requested module:```js import foo from 'foo'; // ^^^^^ the module specifier ```",
+                          "textRaw": "`specifier` {string} The specifier of the requested module:```mjs import foo from 'foo'; // ^^^^^ the module specifier ```",
                           "name": "specifier",
                           "type": "string",
-                          "desc": "The specifier of the requested module:```js import foo from 'foo'; // ^^^^^ the module specifier ```"
+                          "desc": "The specifier of the requested module:```mjs import foo from 'foo'; // ^^^^^ the module specifier ```"
                         },
                         {
                           "textRaw": "`referencingModule` {vm.Module} The `Module` object `link()` is called on.",
@@ -486,7 +499,7 @@
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</em></p>\n<ul>\n<li>Extends: <a href=\"vm.html#vm_class_vm_module\" class=\"type\">&lt;vm.Module&gt;</a></li>\n</ul>\n<p>The <code>vm.SourceTextModule</code> class provides the <a href=\"https://tc39.es/ecma262/#sec-source-text-module-records\">Source Text Module Record</a> as\ndefined in the ECMAScript specification.</p>",
+          "desc": "<p>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</p>\n<ul>\n<li>Extends: <a href=\"vm.html#vm_class_vm_module\" class=\"type\">&lt;vm.Module&gt;</a></li>\n</ul>\n<p>The <code>vm.SourceTextModule</code> class provides the <a href=\"https://tc39.es/ecma262/#sec-source-text-module-records\">Source Text Module Record</a> as\ndefined in the ECMAScript specification.</p>",
           "methods": [
             {
               "textRaw": "`sourceTextModule.createCachedData()`",
@@ -494,7 +507,7 @@
               "name": "createCachedData",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.7.0"
                 ],
                 "changes": []
               },
@@ -508,7 +521,7 @@
                   "params": []
                 }
               ],
-              "desc": "<p>Creates a code cache that can be used with the SourceTextModule constructor's\n<code>cachedData</code> option. Returns a Buffer. This method may be called any number\nof times before the module has been evaluated.</p>\n<pre><code class=\"language-js\">// Create an initial module\nconst module = new vm.SourceTextModule('const a = 1;');\n\n// Create cached data from this module\nconst cachedData = module.createCachedData();\n\n// Create a new module using the cached data. The code must be the same.\nconst module2 = new vm.SourceTextModule('const a = 1;', { cachedData });\n</code></pre>"
+              "desc": "<p>Creates a code cache that can be used with the <code>SourceTextModule</code> constructor's\n<code>cachedData</code> option. Returns a <code>Buffer</code>. This method may be called any number\nof times before the module has been evaluated.</p>\n<pre><code class=\"language-js\">// Create an initial module\nconst module = new vm.SourceTextModule('const a = 1;');\n\n// Create cached data from this module\nconst cachedData = module.createCachedData();\n\n// Create a new module using the cached data. The code must be the same.\nconst module2 = new vm.SourceTextModule('const a = 1;', { cachedData });\n</code></pre>"
             }
           ],
           "signatures": [
@@ -551,11 +564,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this `Module`."
                     },
                     {
-                      "textRaw": "`columnOffset` {integer} Specifies the column number offset that is displayed in stack traces produced by this `Module`. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {integer} Specifies the first-line column number offset that is displayed in stack traces produced by this `Module`. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "integer",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this `Module`."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this `Module`."
                     },
                     {
                       "textRaw": "`initializeImportMeta` {Function} Called during evaluation of this `Module` to initialize the `import.meta`.",
@@ -603,7 +616,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Creates a new <code>SourceTextModule</code> instance.</p>\n<p>Properties assigned to the <code>import.meta</code> object that are objects may\nallow the module to access information outside the specified <code>context</code>. Use\n<code>vm.runInContext()</code> to create objects in a specific context.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst contextifiedObject = vm.createContext({ secret: 42 });\n\n(async () => {\n  const module = new vm.SourceTextModule(\n    'Object.getPrototypeOf(import.meta.prop).secret = secret;',\n    {\n      initializeImportMeta(meta) {\n        // Note: this object is created in the top context. As such,\n        // Object.getPrototypeOf(import.meta.prop) points to the\n        // Object.prototype in the top context rather than that in\n        // the contextified object.\n        meta.prop = {};\n      }\n    });\n  // Since module has no dependencies, the linker function will never be called.\n  await module.link(() => {});\n  await module.evaluate();\n\n  // Now, Object.prototype.secret will be equal to 42.\n  //\n  // To fix this problem, replace\n  //     meta.prop = {};\n  // above with\n  //     meta.prop = vm.runInContext('{}', contextifiedObject);\n})();\n</code></pre>"
+              "desc": "<p>Creates a new <code>SourceTextModule</code> instance.</p>\n<p>Properties assigned to the <code>import.meta</code> object that are objects may\nallow the module to access information outside the specified <code>context</code>. Use\n<code>vm.runInContext()</code> to create objects in a specific context.</p>\n<pre><code class=\"language-mjs\">import vm from 'vm';\n\nconst contextifiedObject = vm.createContext({ secret: 42 });\n\nconst module = new vm.SourceTextModule(\n  'Object.getPrototypeOf(import.meta.prop).secret = secret;',\n  {\n    initializeImportMeta(meta) {\n      // Note: this object is created in the top context. As such,\n      // Object.getPrototypeOf(import.meta.prop) points to the\n      // Object.prototype in the top context rather than that in\n      // the contextified object.\n      meta.prop = {};\n    }\n  });\n// Since module has no dependencies, the linker function will never be called.\nawait module.link(() => {});\nawait module.evaluate();\n\n// Now, Object.prototype.secret will be equal to 42.\n//\n// To fix this problem, replace\n//     meta.prop = {};\n// above with\n//     meta.prop = vm.runInContext('{}', contextifiedObject);\n</code></pre>\n<pre><code class=\"language-cjs\">const vm = require('vm');\nconst contextifiedObject = vm.createContext({ secret: 42 });\n(async () => {\n  const module = new vm.SourceTextModule(\n    'Object.getPrototypeOf(import.meta.prop).secret = secret;',\n    {\n      initializeImportMeta(meta) {\n        // Note: this object is created in the top context. As such,\n        // Object.getPrototypeOf(import.meta.prop) points to the\n        // Object.prototype in the top context rather than that in\n        // the contextified object.\n        meta.prop = {};\n      }\n    });\n  // Since module has no dependencies, the linker function will never be called.\n  await module.link(() => {});\n  await module.evaluate();\n  // Now, Object.prototype.secret will be equal to 42.\n  //\n  // To fix this problem, replace\n  //     meta.prop = {};\n  // above with\n  //     meta.prop = vm.runInContext('{}', contextifiedObject);\n})();\n</code></pre>"
             }
           ]
         },
@@ -613,13 +626,14 @@
           "name": "vm.SyntheticModule",
           "meta": {
             "added": [
+              "v13.0.0",
               "v12.16.0"
             ],
             "changes": []
           },
           "stability": 1,
           "stabilityText": "Experimental",
-          "desc": "<p><em>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</em></p>\n<ul>\n<li>Extends: <a href=\"vm.html#vm_class_vm_module\" class=\"type\">&lt;vm.Module&gt;</a></li>\n</ul>\n<p>The <code>vm.SyntheticModule</code> class provides the <a href=\"https://heycam.github.io/webidl/#synthetic-module-records\">Synthetic Module Record</a> as\ndefined in the WebIDL specification. The purpose of synthetic modules is to\nprovide a generic interface for exposing non-JavaScript sources to ECMAScript\nmodule graphs.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst source = '{ \"a\": 1 }';\nconst module = new vm.SyntheticModule(['default'], function() {\n  const obj = JSON.parse(source);\n  this.setExport('default', obj);\n});\n\n// Use `module` in linking...\n</code></pre>",
+          "desc": "<p>This feature is only available with the <code>--experimental-vm-modules</code> command\nflag enabled.</p>\n<ul>\n<li>Extends: <a href=\"vm.html#vm_class_vm_module\" class=\"type\">&lt;vm.Module&gt;</a></li>\n</ul>\n<p>The <code>vm.SyntheticModule</code> class provides the <a href=\"https://heycam.github.io/webidl/#synthetic-module-records\">Synthetic Module Record</a> as\ndefined in the WebIDL specification. The purpose of synthetic modules is to\nprovide a generic interface for exposing non-JavaScript sources to ECMAScript\nmodule graphs.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nconst source = '{ \"a\": 1 }';\nconst module = new vm.SyntheticModule(['default'], function() {\n  const obj = JSON.parse(source);\n  this.setExport('default', obj);\n});\n\n// Use `module` in linking...\n</code></pre>",
           "methods": [
             {
               "textRaw": "`syntheticModule.setExport(name, value)`",
@@ -627,6 +641,7 @@
               "name": "setExport",
               "meta": {
                 "added": [
+                  "v13.0.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -649,7 +664,7 @@
                   ]
                 }
               ],
-              "desc": "<p>This method is used after the module is linked to set the values of exports. If\nit is called before the module is linked, an <a href=\"errors.html#ERR_VM_MODULE_STATUS\"><code>ERR_VM_MODULE_STATUS</code></a> error\nwill be thrown.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\n(async () => {\n  const m = new vm.SyntheticModule(['x'], () => {\n    m.setExport('x', 1);\n  });\n\n  await m.link(() => {});\n  await m.evaluate();\n\n  assert.strictEqual(m.namespace.x, 1);\n})();\n</code></pre>"
+              "desc": "<p>This method is used after the module is linked to set the values of exports. If\nit is called before the module is linked, an <a href=\"errors.html#ERR_VM_MODULE_STATUS\"><code>ERR_VM_MODULE_STATUS</code></a> error\nwill be thrown.</p>\n<pre><code class=\"language-mjs\">import vm from 'vm';\n\nconst m = new vm.SyntheticModule(['x'], () => {\n  m.setExport('x', 1);\n});\n\nawait m.link(() => {});\nawait m.evaluate();\n\nassert.strictEqual(m.namespace.x, 1);\n</code></pre>\n<pre><code class=\"language-cjs\">const vm = require('vm');\n(async () => {\n  const m = new vm.SyntheticModule(['x'], () => {\n    m.setExport('x', 1);\n  });\n  await m.link(() => {});\n  await m.evaluate();\n  assert.strictEqual(m.namespace.x, 1);\n})();\n</code></pre>"
             }
           ],
           "signatures": [
@@ -668,21 +683,15 @@
                   "desc": "Called when the module is evaluated."
                 },
                 {
-                  "textRaw": "`options`",
+                  "textRaw": "`options`**Default:** `'vm:module(i)'` where `i` is a context-specific ascending index.",
                   "name": "options",
+                  "default": "`'vm:module(i)'` where `i` is a context-specific ascending index",
                   "options": [
                     {
-                      "textRaw": "`identifier` {string} String used in stack traces. **Default:** `'vm:module(i)'` where `i` is a context-specific ascending index.",
+                      "textRaw": "`identifier` {string} String used in stack traces.",
                       "name": "identifier",
                       "type": "string",
-                      "default": "`'vm:module(i)'` where `i` is a context-specific ascending index",
                       "desc": "String used in stack traces."
-                    },
-                    {
-                      "textRaw": "`context` {Object} The [contextified][] object as returned by the `vm.createContext()` method, to compile and evaluate this `Module` in.",
-                      "name": "context",
-                      "type": "Object",
-                      "desc": "The [contextified][] object as returned by the `vm.createContext()` method, to compile and evaluate this `Module` in."
                     }
                   ]
                 }
@@ -701,7 +710,21 @@
             "added": [
               "v10.10.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": "v14.3.0",
+                "pr-url": "https://github.com/nodejs/node/pull/33364",
+                "description": "Removal of `importModuleDynamically` due to compatibility issues."
+              },
+              {
+                "version": [
+                  "v14.1.0",
+                  "v13.14.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/32985",
+                "description": "The `importModuleDynamically` option is now supported."
+              }
+            ]
           },
           "signatures": [
             {
@@ -743,11 +766,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or `TypedArray`, or `DataView` with V8's code cache data for the supplied source.",
@@ -791,6 +814,11 @@
               "v0.3.1"
             ],
             "changes": [
+              {
+                "version": "v14.6.0",
+                "pr-url": "https://github.com/nodejs/node/pull/34023",
+                "description": "The `microtaskMode` option is supported now."
+              },
               {
                 "version": "v10.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/19398",
@@ -856,6 +884,12 @@
                           "desc": "If set to false any attempt to compile a WebAssembly module will throw a `WebAssembly.CompileError`."
                         }
                       ]
+                    },
+                    {
+                      "textRaw": "`microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after a script has run through [`script.runInContext()`][]. They are included in the `timeout` and `breakOnSigint` scopes in that case.",
+                      "name": "microtaskMode",
+                      "type": "string",
+                      "desc": "If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after a script has run through [`script.runInContext()`][]. They are included in the `timeout` and `breakOnSigint` scopes in that case."
                     }
                   ]
                 }
@@ -890,7 +924,26 @@
               ]
             }
           ],
-          "desc": "<p>Returns <code>true</code> if the given <code>oject</code> object has been <a href=\"#vm_what_does_it_mean_to_contextify_an_object\">contextified</a> using\n<a href=\"#vm_vm_createcontext_contextobject_options\"><code>vm.createContext()</code></a>.</p>"
+          "desc": "<p>Returns <code>true</code> if the given <code>object</code> object has been <a href=\"#vm_what_does_it_mean_to_contextify_an_object\">contextified</a> using\n<a href=\"#vm_vm_createcontext_contextobject_options\"><code>vm.createContext()</code></a>.</p>"
+        },
+        {
+          "textRaw": "`vm.measureMemory([options])`",
+          "type": "method",
+          "name": "measureMemory",
+          "meta": {
+            "added": [
+              "v13.10.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<p>Measure the memory known to V8 and used by all contexts known to the\ncurrent V8 isolate, or the main context.</p>\n<ul>\n<li><code>options</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\" class=\"type\">&lt;Object&gt;</a> Optional.\n<ul>\n<li><code>mode</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Either <code>'summary'</code> or <code>'detailed'</code>. In summary mode,\nonly the memory measured for the main context will be returned. In\ndetailed mode, the measure measured for all contexts known to the\ncurrent V8 isolate will be returned.\n<strong>Default:</strong> <code>'summary'</code></li>\n<li><code>execution</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Either <code>'default'</code> or <code>'eager'</code>. With default\nexecution, the promise will not resolve until after the next scheduled\ngarbage collection starts, which may take a while (or never if the program\nexits before the next GC). With eager execution, the GC will be started\nright away to measure the memory.\n<strong>Default:</strong> <code>'default'</code></li>\n</ul>\n</li>\n<li>Returns: <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise\" class=\"type\">&lt;Promise&gt;</a> If the memory is successfully measured the promise will\nresolve with an object containing information about the memory usage.</li>\n</ul>\n<p>The format of the object that the returned Promise may resolve with is\nspecific to the V8 engine and may change from one version of V8 to the next.</p>\n<p>The returned result is different from the statistics returned by\n<code>v8.getHeapSpaceStatistics()</code> in that <code>vm.measureMemory()</code> measure the\nmemory reachable by each V8 specific contexts in the current instance of\nthe V8 engine, while the result of <code>v8.getHeapSpaceStatistics()</code> measure\nthe memory occupied by each heap space in the current V8 instance.</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n// Measure the memory used by the main context.\nvm.measureMemory({ mode: 'summary' })\n  // This is the same as vm.measureMemory()\n  .then((result) => {\n    // The current format is:\n    // {\n    //   total: {\n    //      jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]\n    //    }\n    // }\n    console.log(result);\n  });\n\nconst context = vm.createContext({ a: 1 });\nvm.measureMemory({ mode: 'detailed', execution: 'eager' })\n  .then((result) => {\n    // Reference the context here so that it won't be GC'ed\n    // until the measurement is complete.\n    console.log(context.a);\n    // {\n    //   total: {\n    //     jsMemoryEstimate: 2574732,\n    //     jsMemoryRange: [ 2574732, 2904372 ]\n    //   },\n    //   current: {\n    //     jsMemoryEstimate: 2438996,\n    //     jsMemoryRange: [ 2438996, 2768636 ]\n    //   },\n    //   other: [\n    //     {\n    //       jsMemoryEstimate: 135736,\n    //       jsMemoryRange: [ 135736, 465376 ]\n    //     }\n    //   ]\n    // }\n    console.log(result);\n  });\n</code></pre>"
         },
         {
           "textRaw": "`vm.runInContext(code, contextifiedObject[, options])`",
@@ -949,11 +1002,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`displayErrors` {boolean} When `true`, if an [`Error`][] occurs while compiling the `code`, the line of code causing the error is attached to the stack trace. **Default:** `true`.",
@@ -969,11 +1022,11 @@
                       "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                     },
                     {
-                      "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                      "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                       "name": "breakOnSigint",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                      "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                     },
                     {
                       "textRaw": "`cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or `TypedArray`, or `DataView` with V8's code cache data for the supplied source. When supplied, the `cachedDataRejected` value will be set to either `true` or `false` depending on acceptance of the data by V8.",
@@ -989,10 +1042,10 @@
                       "desc": "When `true` and no `cachedData` is present, V8 will attempt to produce code cache data for `code`. Upon success, a `Buffer` with V8's code cache data will be produced and stored in the `cachedData` property of the returned `vm.Script` instance. The `cachedDataProduced` value will be set to either `true` or `false` depending on whether code cache data is produced successfully. This option is **deprecated** in favor of `script.createCachedData()`."
                     },
                     {
-                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "name": "importModuleDynamically",
                       "type": "Function",
-                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "options": [
                         {
                           "textRaw": "`specifier` {string} specifier passed to `import()`",
@@ -1001,9 +1054,9 @@
                           "desc": "specifier passed to `import()`"
                         },
                         {
-                          "textRaw": "`module` {vm.Module}",
-                          "name": "module",
-                          "type": "vm.Module"
+                          "textRaw": "`script` {vm.Script}",
+                          "name": "script",
+                          "type": "vm.Script"
                         },
                         {
                           "textRaw": "Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports.",
@@ -1029,6 +1082,11 @@
               "v0.3.1"
             ],
             "changes": [
+              {
+                "version": "v14.6.0",
+                "pr-url": "https://github.com/nodejs/node/pull/34023",
+                "description": "The `microtaskMode` option is supported now."
+              },
               {
                 "version": "v10.0.0",
                 "pr-url": "https://github.com/nodejs/node/pull/19016",
@@ -1082,11 +1140,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`displayErrors` {boolean} When `true`, if an [`Error`][] occurs while compiling the `code`, the line of code causing the error is attached to the stack trace. **Default:** `true`.",
@@ -1102,11 +1160,11 @@
                       "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                     },
                     {
-                      "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                      "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                       "name": "breakOnSigint",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                      "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                     },
                     {
                       "textRaw": "`contextName` {string} Human-readable name of the newly created context. **Default:** `'VM Context i'`, where `i` is an ascending numerical index of the created context.",
@@ -1157,10 +1215,10 @@
                       "desc": "When `true` and no `cachedData` is present, V8 will attempt to produce code cache data for `code`. Upon success, a `Buffer` with V8's code cache data will be produced and stored in the `cachedData` property of the returned `vm.Script` instance. The `cachedDataProduced` value will be set to either `true` or `false` depending on whether code cache data is produced successfully. This option is **deprecated** in favor of `script.createCachedData()`."
                     },
                     {
-                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "name": "importModuleDynamically",
                       "type": "Function",
-                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "options": [
                         {
                           "textRaw": "`specifier` {string} specifier passed to `import()`",
@@ -1169,9 +1227,9 @@
                           "desc": "specifier passed to `import()`"
                         },
                         {
-                          "textRaw": "`module` {vm.Module}",
-                          "name": "module",
-                          "type": "vm.Module"
+                          "textRaw": "`script` {vm.Script}",
+                          "name": "script",
+                          "type": "vm.Script"
                         },
                         {
                           "textRaw": "Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports.",
@@ -1180,6 +1238,12 @@
                           "desc": "Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports."
                         }
                       ]
+                    },
+                    {
+                      "textRaw": "`microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after the script has run. They are included in the `timeout` and `breakOnSigint` scopes in that case.",
+                      "name": "microtaskMode",
+                      "type": "string",
+                      "desc": "If set to `afterEvaluate`, microtasks (tasks scheduled through `Promise`s and `async function`s) will be run immediately after the script has run. They are included in the `timeout` and `breakOnSigint` scopes in that case."
                     }
                   ]
                 }
@@ -1239,11 +1303,11 @@
                       "desc": "Specifies the line number offset that is displayed in stack traces produced by this script."
                     },
                     {
-                      "textRaw": "`columnOffset` {number} Specifies the column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
+                      "textRaw": "`columnOffset` {number} Specifies the first-line column number offset that is displayed in stack traces produced by this script. **Default:** `0`.",
                       "name": "columnOffset",
                       "type": "number",
                       "default": "`0`",
-                      "desc": "Specifies the column number offset that is displayed in stack traces produced by this script."
+                      "desc": "Specifies the first-line column number offset that is displayed in stack traces produced by this script."
                     },
                     {
                       "textRaw": "`displayErrors` {boolean} When `true`, if an [`Error`][] occurs while compiling the `code`, the line of code causing the error is attached to the stack trace. **Default:** `true`.",
@@ -1259,11 +1323,11 @@
                       "desc": "Specifies the number of milliseconds to execute `code` before terminating execution. If execution is terminated, an [`Error`][] will be thrown. This value must be a strictly positive integer."
                     },
                     {
-                      "textRaw": "`breakOnSigint` {boolean} If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown. **Default:** `false`.",
+                      "textRaw": "`breakOnSigint` {boolean} If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that. **Default:** `false`.",
                       "name": "breakOnSigint",
                       "type": "boolean",
                       "default": "`false`",
-                      "desc": "If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. If execution is terminated, an [`Error`][] will be thrown."
+                      "desc": "If `true`, receiving `SIGINT` (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an [`Error`][]. Existing handlers for the event that have been attached via `process.on('SIGINT')` are disabled during script execution, but continue to work after that."
                     },
                     {
                       "textRaw": "`cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or `TypedArray`, or `DataView` with V8's code cache data for the supplied source. When supplied, the `cachedDataRejected` value will be set to either `true` or `false` depending on acceptance of the data by V8.",
@@ -1279,10 +1343,10 @@
                       "desc": "When `true` and no `cachedData` is present, V8 will attempt to produce code cache data for `code`. Upon success, a `Buffer` with V8's code cache data will be produced and stored in the `cachedData` property of the returned `vm.Script` instance. The `cachedDataProduced` value will be set to either `true` or `false` depending on whether code cache data is produced successfully. This option is **deprecated** in favor of `script.createCachedData()`."
                     },
                     {
-                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "textRaw": "`importModuleDynamically` {Function} Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "name": "importModuleDynamically",
                       "type": "Function",
-                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API, and should not be considered stable.",
+                      "desc": "Called during evaluation of this module when `import()` is called. If this option is not specified, calls to `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][]. This option is part of the experimental modules API. We do not recommend using it in a production environment.",
                       "options": [
                         {
                           "textRaw": "`specifier` {string} specifier passed to `import()`",
@@ -1291,9 +1355,9 @@
                           "desc": "specifier passed to `import()`"
                         },
                         {
-                          "textRaw": "`module` {vm.Module}",
-                          "name": "module",
-                          "type": "vm.Module"
+                          "textRaw": "`script` {vm.Script}",
+                          "name": "script",
+                          "type": "vm.Script"
                         },
                         {
                           "textRaw": "Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is recommended in order to take advantage of error tracking, and to avoid issues with namespaces that contain `then` function exports.",
@@ -1320,11 +1384,11 @@
           "displayName": "What does it mean to \"contextify\" an object?"
         },
         {
-          "textRaw": "Timeout limitations when using `process.nextTick()`, promises, and `queueMicrotask()`",
-          "name": "timeout_limitations_when_using_`process.nexttick()`,_promises,_and_`queuemicrotask()`",
-          "desc": "<p>Because of the internal mechanics of how the <code>process.nextTick()</code> queue and\nthe microtask queue that underlies Promises are implemented within V8 and\nNode.js, it is possible for code running within a context to \"escape\" the\n<code>timeout</code> set using <code>vm.runInContext()</code>, <code>vm.runInNewContext()</code>, and\n<code>vm.runInThisContext()</code>.</p>\n<p>For example, the following code executed by <code>vm.runInNewContext()</code> with a\ntimeout of 5 milliseconds schedules an infinite loop to run after a promise\nresolves. The scheduled loop is never interrupted by the timeout:</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nfunction loop() {\n  while (1) console.log(Date.now());\n}\n\nvm.runInNewContext(\n  'Promise.resolve().then(loop);',\n  { loop, console },\n  { timeout: 5 }\n);\n</code></pre>\n<p>This issue also occurs when the <code>loop()</code> call is scheduled using\nthe <code>process.nextTick()</code> and <code>queueMicrotask()</code> functions.</p>\n<p>This issue occurs because all contexts share the same microtask and nextTick\nqueues.</p>",
+          "textRaw": "Timeout interactions with asynchronous tasks and Promises",
+          "name": "timeout_interactions_with_asynchronous_tasks_and_promises",
+          "desc": "<p><code>Promise</code>s and <code>async function</code>s can schedule tasks run by the JavaScript\nengine asynchronously. By default, these tasks are run after all JavaScript\nfunctions on the current stack are done executing.\nThis allows escaping the functionality of the <code>timeout</code> and\n<code>breakOnSigint</code> options.</p>\n<p>For example, the following code executed by <code>vm.runInNewContext()</code> with a\ntimeout of 5 milliseconds schedules an infinite loop to run after a promise\nresolves. The scheduled loop is never interrupted by the timeout:</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nfunction loop() {\n  console.log('entering loop');\n  while (1) console.log(Date.now());\n}\n\nvm.runInNewContext(\n  'Promise.resolve().then(() => loop());',\n  { loop, console },\n  { timeout: 5 }\n);\n// This is printed *before* 'entering loop' (!)\nconsole.log('done executing');\n</code></pre>\n<p>This can be addressed by passing <code>microtaskMode: 'afterEvaluate'</code> to the code\nthat creates the <code>Context</code>:</p>\n<pre><code class=\"language-js\">const vm = require('vm');\n\nfunction loop() {\n  while (1) console.log(Date.now());\n}\n\nvm.runInNewContext(\n  'Promise.resolve().then(() => loop());',\n  { loop, console },\n  { timeout: 5, microtaskMode: 'afterEvaluate' }\n);\n</code></pre>\n<p>In this case, the microtask scheduled through <code>promise.then()</code> will be run\nbefore returning from <code>vm.runInNewContext()</code>, and will be interrupted\nby the <code>timeout</code> functionality. This applies only to code running in a\n<code>vm.Context</code>, so e.g. <a href=\"#vm_vm_runinthiscontext_code_options\"><code>vm.runInThisContext()</code></a> does not take this option.</p>\n<p>Promise callbacks are entered into the microtask queue of the context in which\nthey were created. For example, if <code>() => loop()</code> is replaced with just <code>loop</code>\nin the above example, then <code>loop</code> will be pushed into the global microtask\nqueue, because it is a function from the outer (main) context, and thus will\nalso be able to escape the timeout.</p>\n<p>If asynchronous scheduling functions such as <code>process.nextTick()</code>,\n<code>queueMicrotask()</code>, <code>setTimeout()</code>, <code>setImmediate()</code>, etc. are made available\ninside a <code>vm.Context</code>, functions passed to them will be added to global queues,\nwhich are shared by all contexts. Therefore, callbacks passed to those functions\nare not controllable through the timeout either.</p>",
           "type": "module",
-          "displayName": "Timeout limitations when using `process.nextTick()`, promises, and `queueMicrotask()`"
+          "displayName": "Timeout interactions with asynchronous tasks and Promises"
         }
       ],
       "type": "module",
diff --git a/doc/api/vm.md b/doc/api/vm.md
index 61aee4042b4eff369584602fd03d7374814d1c53..0554772badfbd662d56b3146faaa254da6b1f35f 100644
--- a/doc/api/vm.md
+++ b/doc/api/vm.md
@@ -54,14 +54,14 @@ executed in specific contexts.
 <!-- YAML
 added: v0.3.1
 changes:
+  - version: v10.6.0
+    pr-url: https://github.com/nodejs/node/pull/20300
+    description: The `produceCachedData` is deprecated in favour of
+                 `script.createCachedData()`.
   - version: v5.7.0
     pr-url: https://github.com/nodejs/node/pull/4777
     description: The `cachedData` and `produceCachedData` options are
                  supported now.
-  - version: v10.6.0
-    pr-url: https://github.com/nodejs/node/pull/20300
-    description: The `produceCachedData` is deprecated in favour of
-                 `script.createCachedData()`
 -->
 
 * `code` {string} The JavaScript code to compile.
@@ -70,8 +70,8 @@ changes:
     by this script. **Default:** `'evalmachine.<anonymous>'`.
   * `lineOffset` {number} Specifies the line number offset that is displayed
     in stack traces produced by this script. **Default:** `0`.
-  * `columnOffset` {number} Specifies the column number offset that is displayed
-    in stack traces produced by this script. **Default:** `0`.
+  * `columnOffset` {number} Specifies the first-line column number offset that
+    is displayed in stack traces produced by this script. **Default:** `0`.
   * `cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or
     `TypedArray`, or `DataView` with V8's code cache data for the supplied
      source. When supplied, the `cachedDataRejected` value will be set to
@@ -87,10 +87,10 @@ changes:
   * `importModuleDynamically` {Function} Called during evaluation of this module
     when `import()` is called. If this option is not specified, calls to
     `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-    This option is part of the experimental modules API, and should not be
-    considered stable.
+    This option is part of the experimental modules API. We do not recommend
+    using it in a production environment.
     * `specifier` {string} specifier passed to `import()`
-    * `module` {vm.Module}
+    * `script` {vm.Script}
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -108,8 +108,8 @@ added: v10.6.0
 
 * Returns: {Buffer}
 
-Creates a code cache that can be used with the Script constructor's
-`cachedData` option. Returns a Buffer. This method may be called at any
+Creates a code cache that can be used with the `Script` constructor's
+`cachedData` option. Returns a `Buffer`. This method may be called at any
 time and any number of times.
 
 ```js
@@ -146,11 +146,11 @@ changes:
   * `timeout` {integer} Specifies the number of milliseconds to execute `code`
     before terminating execution. If execution is terminated, an [`Error`][]
     will be thrown. This value must be a strictly positive integer.
-  * `breakOnSigint` {boolean} If `true`, the execution will be terminated when
-    `SIGINT` (Ctrl+C) is received. Existing handlers for the
-    event that have been attached via `process.on('SIGINT')` will be disabled
-    during script execution, but will continue to work after that. If execution
-    is terminated, an [`Error`][] will be thrown. **Default:** `false`.
+  * `breakOnSigint` {boolean} If `true`, receiving `SIGINT`
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+    [`Error`][]. Existing handlers for the event that have been attached via
+    `process.on('SIGINT')` are disabled during script execution, but continue to
+    work after that. **Default:** `false`.
 * Returns: {any} the result of the very last statement executed in the script.
 
 Runs the compiled code contained by the `vm.Script` object within the given
@@ -188,6 +188,9 @@ overhead.
 <!-- YAML
 added: v0.3.1
 changes:
+  - version: v14.6.0
+    pr-url: https://github.com/nodejs/node/pull/34023
+    description: The `microtaskMode` option is supported now.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/19016
     description: The `contextCodeGeneration` option is supported now.
@@ -205,11 +208,11 @@ changes:
   * `timeout` {integer} Specifies the number of milliseconds to execute `code`
     before terminating execution. If execution is terminated, an [`Error`][]
     will be thrown. This value must be a strictly positive integer.
-  * `breakOnSigint` {boolean} If `true`, the execution will be terminated when
-    `SIGINT` (Ctrl+C) is received. Existing handlers for the
-    event that have been attached via `process.on('SIGINT')` will be disabled
-    during script execution, but will continue to work after that. If execution
-    is terminated, an [`Error`][] will be thrown. **Default:** `false`.
+  * `breakOnSigint` {boolean} If `true`, receiving `SIGINT`
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+    [`Error`][]. Existing handlers for the event that have been attached via
+    `process.on('SIGINT')` are disabled during script execution, but continue to
+    work after that. **Default:** `false`.
   * `contextName` {string} Human-readable name of the newly created context.
     **Default:** `'VM Context i'`, where `i` is an ascending numerical index of
     the created context.
@@ -225,6 +228,10 @@ changes:
       `EvalError`. **Default:** `true`.
     * `wasm` {boolean} If set to false any attempt to compile a WebAssembly
       module will throw a `WebAssembly.CompileError`. **Default:** `true`.
+  * `microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks
+    scheduled through `Promise`s and `async function`s) will be run immediately
+    after the script has run. They are included in the `timeout` and
+    `breakOnSigint` scopes in that case.
 * Returns: {any} the result of the very last statement executed in the script.
 
 First contextifies the given `contextObject`, runs the compiled code contained
@@ -265,11 +272,11 @@ changes:
   * `timeout` {integer} Specifies the number of milliseconds to execute `code`
     before terminating execution. If execution is terminated, an [`Error`][]
     will be thrown. This value must be a strictly positive integer.
-  * `breakOnSigint` {boolean} If `true`, the execution will be terminated when
-    `SIGINT` (Ctrl+C) is received. Existing handlers for the
-    event that have been attached via `process.on('SIGINT')` will be disabled
-    during script execution, but will continue to work after that. If execution
-    is terminated, an [`Error`][] will be thrown. **Default:** `false`.
+  * `breakOnSigint` {boolean} If `true`, receiving `SIGINT`
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+    [`Error`][]. Existing handlers for the event that have been attached via
+    `process.on('SIGINT')` are disabled during script execution, but continue to
+    work after that. **Default:** `false`.
 * Returns: {any} the result of the very last statement executed in the script.
 
 Runs the compiled code contained by the `vm.Script` within the context of the
@@ -297,13 +304,15 @@ console.log(globalVar);
 
 ## Class: `vm.Module`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.0.0
+ - v12.16.0
 -->
 
 > Stability: 1 - Experimental
 
-*This feature is only available with the `--experimental-vm-modules` command
-flag enabled.*
+This feature is only available with the `--experimental-vm-modules` command
+flag enabled.
 
 The `vm.Module` class provides a low-level interface for using
 ECMAScript modules in VM contexts. It is the counterpart of the `vm.Script`
@@ -323,10 +332,84 @@ This implementation lies at a lower level than the [ECMAScript Module
 loader][]. There is also no way to interact with the Loader yet, though
 support is planned.
 
-```js
+```mjs
+import vm from 'vm';
+
+const contextifiedObject = vm.createContext({
+  secret: 42,
+  print: console.log,
+});
+
+// Step 1
+//
+// Create a Module by constructing a new `vm.SourceTextModule` object. This
+// parses the provided source text, throwing a `SyntaxError` if anything goes
+// wrong. By default, a Module is created in the top context. But here, we
+// specify `contextifiedObject` as the context this Module belongs to.
+//
+// Here, we attempt to obtain the default export from the module "foo", and
+// put it into local binding "secret".
+
+const bar = new vm.SourceTextModule(`
+  import s from 'foo';
+  s;
+  print(s);
+`, { context: contextifiedObject });
+
+// Step 2
+//
+// "Link" the imported dependencies of this Module to it.
+//
+// The provided linking callback (the "linker") accepts two arguments: the
+// parent module (`bar` in this case) and the string that is the specifier of
+// the imported module. The callback is expected to return a Module that
+// corresponds to the provided specifier, with certain requirements documented
+// in `module.link()`.
+//
+// If linking has not started for the returned Module, the same linker
+// callback will be called on the returned Module.
+//
+// Even top-level Modules without dependencies must be explicitly linked. The
+// callback provided would never be called, however.
+//
+// The link() method returns a Promise that will be resolved when all the
+// Promises returned by the linker resolve.
+//
+// Note: This is a contrived example in that the linker function creates a new
+// "foo" module every time it is called. In a full-fledged module system, a
+// cache would probably be used to avoid duplicated modules.
+
+async function linker(specifier, referencingModule) {
+  if (specifier === 'foo') {
+    return new vm.SourceTextModule(`
+      // The "secret" variable refers to the global variable we added to
+      // "contextifiedObject" when creating the context.
+      export default secret;
+    `, { context: referencingModule.context });
+
+    // Using `contextifiedObject` instead of `referencingModule.context`
+    // here would work as well.
+  }
+  throw new Error(`Unable to resolve dependency: ${specifier}`);
+}
+await bar.link(linker);
+
+// Step 3
+//
+// Evaluate the Module. The evaluate() method returns a promise which will
+// resolve after the module has finished evaluating.
+
+// Prints 42.
+await bar.evaluate();
+```
+
+```cjs
 const vm = require('vm');
 
-const contextifiedObject = vm.createContext({ secret: 42 });
+const contextifiedObject = vm.createContext({
+  secret: 42,
+  print: console.log,
+});
 
 (async () => {
   // Step 1
@@ -342,6 +425,7 @@ const contextifiedObject = vm.createContext({ secret: 42 });
   const bar = new vm.SourceTextModule(`
     import s from 'foo';
     s;
+    print(s);
   `, { context: contextifiedObject });
 
   // Step 2
@@ -384,16 +468,11 @@ const contextifiedObject = vm.createContext({ secret: 42 });
 
   // Step 3
   //
-  // Evaluate the Module. The evaluate() method returns a Promise with a single
-  // property "result" that contains the result of the very last statement
-  // executed in the Module. In the case of `bar`, it is `s;`, which refers to
-  // the default export of the `foo` module, the `secret` we set in the
-  // beginning to 42.
+  // Evaluate the Module. The evaluate() method returns a promise which will
+  // resolve after the module has finished evaluating.
 
-  const { result } = await bar.evaluate();
-
-  console.log(result);
   // Prints 42.
+  await bar.evaluate();
 })();
 ```
 
@@ -427,36 +506,38 @@ in the ECMAScript specification.
   * `timeout` {integer} Specifies the number of milliseconds to evaluate
     before terminating execution. If execution is interrupted, an [`Error`][]
     will be thrown. This value must be a strictly positive integer.
-  * `breakOnSigint` {boolean} If `true`, the execution will be terminated when
-    `SIGINT` (Ctrl+C) is received. Existing handlers for the event that have
-    been attached via `process.on('SIGINT')` will be disabled during script
-    execution, but will continue to work after that. If execution is
-    interrupted, an [`Error`][] will be thrown. **Default:** `false`.
-* Returns: {Promise}
+  * `breakOnSigint` {boolean} If `true`, receiving `SIGINT`
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+    [`Error`][]. Existing handlers for the event that have been attached via
+    `process.on('SIGINT')` are disabled during script execution, but continue to
+    work after that. **Default:** `false`.
+* Returns: {Promise} Fulfills with `undefined` upon success.
 
 Evaluate the module.
 
-This must be called after the module has been linked; otherwise it will
-throw an error. It could be called also when the module has already been
-evaluated, in which case it will do one of the following two things:
-
-* return `undefined` if the initial evaluation ended in success (`module.status`
-  is `'evaluated'`)
-* rethrow the same exception the initial evaluation threw if the initial
-  evaluation ended in an error (`module.status` is `'errored'`)
+This must be called after the module has been linked; otherwise it will reject.
+It could be called also when the module has already been evaluated, in which
+case it will either do nothing if the initial evaluation ended in success
+(`module.status` is `'evaluated'`) or it will re-throw the exception that the
+initial evaluation resulted in (`module.status` is `'errored'`).
 
 This method cannot be called while the module is being evaluated
-(`module.status` is `'evaluating'`) to prevent infinite recursion.
+(`module.status` is `'evaluating'`).
 
 Corresponds to the [Evaluate() concrete method][] field of [Cyclic Module
 Record][]s in the ECMAScript specification.
 
+### `module.identifier`
+
+* {string}
+
+The identifier of the current module, as set in the constructor.
+
 ### `module.link(linker)`
 
 * `linker` {Function}
   * `specifier` {string} The specifier of the requested module:
-    <!-- eslint-skip -->
-    ```js
+    ```mjs
     import foo from 'foo';
     //              ^^^^^ the module specifier
     ```
@@ -535,12 +616,6 @@ Other than `'errored'`, this status string corresponds to the specification's
 `'evaluated'` in the specification, but with `[[EvaluationError]]` set to a
 value that is not `undefined`.
 
-### `module.identifier`
-
-* {string}
-
-The identifier of the current module, as set in the constructor.
-
 ## Class: `vm.SourceTextModule`
 <!-- YAML
 added: v9.6.0
@@ -548,8 +623,8 @@ added: v9.6.0
 
 > Stability: 1 - Experimental
 
-*This feature is only available with the `--experimental-vm-modules` command
-flag enabled.*
+This feature is only available with the `--experimental-vm-modules` command
+flag enabled.
 
 * Extends: {vm.Module}
 
@@ -571,8 +646,8 @@ defined in the ECMAScript specification.
     `vm.createContext()` method, to compile and evaluate this `Module` in.
   * `lineOffset` {integer} Specifies the line number offset that is displayed
     in stack traces produced by this `Module`. **Default:** `0`.
-  * `columnOffset` {integer} Specifies the column number offset that is
-    displayed in stack traces produced by this `Module`. **Default:** `0`.
+  * `columnOffset` {integer} Specifies the first-line column number offset that
+    is displayed in stack traces produced by this `Module`. **Default:** `0`.
   * `initializeImportMeta` {Function} Called during evaluation of this `Module`
     to initialize the `import.meta`.
     * `meta` {import.meta}
@@ -592,11 +667,37 @@ Properties assigned to the `import.meta` object that are objects may
 allow the module to access information outside the specified `context`. Use
 `vm.runInContext()` to create objects in a specific context.
 
-```js
-const vm = require('vm');
+```mjs
+import vm from 'vm';
 
 const contextifiedObject = vm.createContext({ secret: 42 });
 
+const module = new vm.SourceTextModule(
+  'Object.getPrototypeOf(import.meta.prop).secret = secret;',
+  {
+    initializeImportMeta(meta) {
+      // Note: this object is created in the top context. As such,
+      // Object.getPrototypeOf(import.meta.prop) points to the
+      // Object.prototype in the top context rather than that in
+      // the contextified object.
+      meta.prop = {};
+    }
+  });
+// Since module has no dependencies, the linker function will never be called.
+await module.link(() => {});
+await module.evaluate();
+
+// Now, Object.prototype.secret will be equal to 42.
+//
+// To fix this problem, replace
+//     meta.prop = {};
+// above with
+//     meta.prop = vm.runInContext('{}', contextifiedObject);
+```
+
+```cjs
+const vm = require('vm');
+const contextifiedObject = vm.createContext({ secret: 42 });
 (async () => {
   const module = new vm.SourceTextModule(
     'Object.getPrototypeOf(import.meta.prop).secret = secret;',
@@ -612,7 +713,6 @@ const contextifiedObject = vm.createContext({ secret: 42 });
   // Since module has no dependencies, the linker function will never be called.
   await module.link(() => {});
   await module.evaluate();
-
   // Now, Object.prototype.secret will be equal to 42.
   //
   // To fix this problem, replace
@@ -624,13 +724,13 @@ const contextifiedObject = vm.createContext({ secret: 42 });
 
 ### `sourceTextModule.createCachedData()`
 <!-- YAML
-added: v12.17.0
+added: v13.7.0
 -->
 
 * Returns: {Buffer}
 
-Creates a code cache that can be used with the SourceTextModule constructor's
-`cachedData` option. Returns a Buffer. This method may be called any number
+Creates a code cache that can be used with the `SourceTextModule` constructor's
+`cachedData` option. Returns a `Buffer`. This method may be called any number
 of times before the module has been evaluated.
 
 ```js
@@ -646,13 +746,15 @@ const module2 = new vm.SourceTextModule('const a = 1;', { cachedData });
 
 ## Class: `vm.SyntheticModule`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.0.0
+ - v12.16.0
 -->
 
 > Stability: 1 - Experimental
 
-*This feature is only available with the `--experimental-vm-modules` command
-flag enabled.*
+This feature is only available with the `--experimental-vm-modules` command
+flag enabled.
 
 * Extends: {vm.Module}
 
@@ -675,7 +777,9 @@ const module = new vm.SyntheticModule(['default'], function() {
 
 ### `new vm.SyntheticModule(exportNames, evaluateCallback[, options])`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.0.0
+ - v12.16.0
 -->
 
 * `exportNames` {string[]} Array of names that will be exported from the module.
@@ -695,7 +799,9 @@ the module to access information outside the specified `context`. Use
 
 ### `syntheticModule.setExport(name, value)`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.0.0
+ - v12.16.0
 -->
 
 * `name` {string} Name of the export to set.
@@ -705,17 +811,27 @@ This method is used after the module is linked to set the values of exports. If
 it is called before the module is linked, an [`ERR_VM_MODULE_STATUS`][] error
 will be thrown.
 
-```js
-const vm = require('vm');
+```mjs
+import vm from 'vm';
+
+const m = new vm.SyntheticModule(['x'], () => {
+  m.setExport('x', 1);
+});
+
+await m.link(() => {});
+await m.evaluate();
+
+assert.strictEqual(m.namespace.x, 1);
+```
 
+```cjs
+const vm = require('vm');
 (async () => {
   const m = new vm.SyntheticModule(['x'], () => {
     m.setExport('x', 1);
   });
-
   await m.link(() => {});
   await m.evaluate();
-
   assert.strictEqual(m.namespace.x, 1);
 })();
 ```
@@ -723,6 +839,16 @@ const vm = require('vm');
 ## `vm.compileFunction(code[, params[, options]])`
 <!-- YAML
 added: v10.10.0
+changes:
+  - version: v14.3.0
+    pr-url: https://github.com/nodejs/node/pull/33364
+    description: Removal of `importModuleDynamically` due to compatibility
+                 issues.
+  - version:
+    - v14.1.0
+    - v13.14.0
+    pr-url: https://github.com/nodejs/node/pull/32985
+    description: The `importModuleDynamically` option is now supported.
 -->
 
 * `code` {string} The body of the function to compile.
@@ -733,8 +859,8 @@ added: v10.10.0
     by this script. **Default:** `''`.
   * `lineOffset` {number} Specifies the line number offset that is displayed
     in stack traces produced by this script. **Default:** `0`.
-  * `columnOffset` {number} Specifies the column number offset that is displayed
-    in stack traces produced by this script. **Default:** `0`.
+  * `columnOffset` {number} Specifies the first-line column number offset that
+    is displayed in stack traces produced by this script. **Default:** `0`.
   * `cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or
     `TypedArray`, or `DataView` with V8's code cache data for the supplied
      source.
@@ -755,6 +881,9 @@ function with the given `params`.
 <!-- YAML
 added: v0.3.1
 changes:
+  - version: v14.6.0
+    pr-url: https://github.com/nodejs/node/pull/34023
+    description: The `microtaskMode` option is supported now.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/19398
     description: The first argument can no longer be a function.
@@ -780,6 +909,10 @@ changes:
       `EvalError`. **Default:** `true`.
     * `wasm` {boolean} If set to false any attempt to compile a WebAssembly
       module will throw a `WebAssembly.CompileError`. **Default:** `true`.
+  * `microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks
+    scheduled through `Promise`s and `async function`s) will be run immediately
+    after a script has run through [`script.runInContext()`][].
+    They are included in the `timeout` and `breakOnSigint` scopes in that case.
 * Returns: {Object} contextified object.
 
 If given a `contextObject`, the `vm.createContext()` method will [prepare
@@ -827,9 +960,85 @@ added: v0.11.7
 * `object` {Object}
 * Returns: {boolean}
 
-Returns `true` if the given `oject` object has been [contextified][] using
+Returns `true` if the given `object` object has been [contextified][] using
 [`vm.createContext()`][].
 
+## `vm.measureMemory([options])`
+
+<!-- YAML
+added: v13.10.0
+-->
+
+> Stability: 1 - Experimental
+
+Measure the memory known to V8 and used by all contexts known to the
+current V8 isolate, or the main context.
+
+* `options` {Object} Optional.
+  * `mode` {string} Either `'summary'` or `'detailed'`. In summary mode,
+    only the memory measured for the main context will be returned. In
+    detailed mode, the measure measured for all contexts known to the
+    current V8 isolate will be returned.
+    **Default:** `'summary'`
+  * `execution` {string} Either `'default'` or `'eager'`. With default
+    execution, the promise will not resolve until after the next scheduled
+    garbage collection starts, which may take a while (or never if the program
+    exits before the next GC). With eager execution, the GC will be started
+    right away to measure the memory.
+    **Default:** `'default'`
+* Returns: {Promise} If the memory is successfully measured the promise will
+  resolve with an object containing information about the memory usage.
+
+The format of the object that the returned Promise may resolve with is
+specific to the V8 engine and may change from one version of V8 to the next.
+
+The returned result is different from the statistics returned by
+`v8.getHeapSpaceStatistics()` in that `vm.measureMemory()` measure the
+memory reachable by each V8 specific contexts in the current instance of
+the V8 engine, while the result of `v8.getHeapSpaceStatistics()` measure
+the memory occupied by each heap space in the current V8 instance.
+
+```js
+const vm = require('vm');
+// Measure the memory used by the main context.
+vm.measureMemory({ mode: 'summary' })
+  // This is the same as vm.measureMemory()
+  .then((result) => {
+    // The current format is:
+    // {
+    //   total: {
+    //      jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]
+    //    }
+    // }
+    console.log(result);
+  });
+
+const context = vm.createContext({ a: 1 });
+vm.measureMemory({ mode: 'detailed', execution: 'eager' })
+  .then((result) => {
+    // Reference the context here so that it won't be GC'ed
+    // until the measurement is complete.
+    console.log(context.a);
+    // {
+    //   total: {
+    //     jsMemoryEstimate: 2574732,
+    //     jsMemoryRange: [ 2574732, 2904372 ]
+    //   },
+    //   current: {
+    //     jsMemoryEstimate: 2438996,
+    //     jsMemoryRange: [ 2438996, 2768636 ]
+    //   },
+    //   other: [
+    //     {
+    //       jsMemoryEstimate: 135736,
+    //       jsMemoryRange: [ 135736, 465376 ]
+    //     }
+    //   ]
+    // }
+    console.log(result);
+  });
+```
+
 ## `vm.runInContext(code, contextifiedObject[, options])`
 <!-- YAML
 added: v0.3.1
@@ -847,19 +1056,19 @@ changes:
     by this script. **Default:** `'evalmachine.<anonymous>'`.
   * `lineOffset` {number} Specifies the line number offset that is displayed
     in stack traces produced by this script. **Default:** `0`.
-  * `columnOffset` {number} Specifies the column number offset that is displayed
-    in stack traces produced by this script. **Default:** `0`.
+  * `columnOffset` {number} Specifies the first-line column number offset that
+    is displayed in stack traces produced by this script. **Default:** `0`.
   * `displayErrors` {boolean} When `true`, if an [`Error`][] occurs
     while compiling the `code`, the line of code causing the error is attached
     to the stack trace. **Default:** `true`.
   * `timeout` {integer} Specifies the number of milliseconds to execute `code`
     before terminating execution. If execution is terminated, an [`Error`][]
     will be thrown. This value must be a strictly positive integer.
-  * `breakOnSigint` {boolean} If `true`, the execution will be terminated when
-    `SIGINT` (Ctrl+C) is received. Existing handlers for the
-    event that have been attached via `process.on('SIGINT')` will be disabled
-    during script execution, but will continue to work after that. If execution
-    is terminated, an [`Error`][] will be thrown. **Default:** `false`.
+  * `breakOnSigint` {boolean} If `true`, receiving `SIGINT`
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+    [`Error`][]. Existing handlers for the event that have been attached via
+    `process.on('SIGINT')` are disabled during script execution, but continue to
+    work after that. **Default:** `false`.
   * `cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or
     `TypedArray`, or `DataView` with V8's code cache data for the supplied
      source. When supplied, the `cachedDataRejected` value will be set to
@@ -875,10 +1084,10 @@ changes:
   * `importModuleDynamically` {Function} Called during evaluation of this module
     when `import()` is called. If this option is not specified, calls to
     `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-    This option is part of the experimental modules API, and should not be
-    considered stable.
+    This option is part of the experimental modules API. We do not recommend
+    using it in a production environment.
     * `specifier` {string} specifier passed to `import()`
-    * `module` {vm.Module}
+    * `script` {vm.Script}
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -911,6 +1120,9 @@ console.log(contextObject);
 <!-- YAML
 added: v0.3.1
 changes:
+  - version: v14.6.0
+    pr-url: https://github.com/nodejs/node/pull/34023
+    description: The `microtaskMode` option is supported now.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/19016
     description: The `contextCodeGeneration` option is supported now.
@@ -927,19 +1139,19 @@ changes:
     by this script. **Default:** `'evalmachine.<anonymous>'`.
   * `lineOffset` {number} Specifies the line number offset that is displayed
     in stack traces produced by this script. **Default:** `0`.
-  * `columnOffset` {number} Specifies the column number offset that is displayed
-    in stack traces produced by this script. **Default:** `0`.
+  * `columnOffset` {number} Specifies the first-line column number offset that
+    is displayed in stack traces produced by this script. **Default:** `0`.
   * `displayErrors` {boolean} When `true`, if an [`Error`][] occurs
     while compiling the `code`, the line of code causing the error is attached
     to the stack trace. **Default:** `true`.
   * `timeout` {integer} Specifies the number of milliseconds to execute `code`
     before terminating execution. If execution is terminated, an [`Error`][]
     will be thrown. This value must be a strictly positive integer.
-  * `breakOnSigint` {boolean} If `true`, the execution will be terminated when
-    `SIGINT` (Ctrl+C) is received. Existing handlers for the
-    event that have been attached via `process.on('SIGINT')` will be disabled
-    during script execution, but will continue to work after that. If execution
-    is terminated, an [`Error`][] will be thrown. **Default:** `false`.
+  * `breakOnSigint` {boolean} If `true`, receiving `SIGINT`
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+    [`Error`][]. Existing handlers for the event that have been attached via
+    `process.on('SIGINT')` are disabled during script execution, but continue to
+    work after that. **Default:** `false`.
   * `contextName` {string} Human-readable name of the newly created context.
     **Default:** `'VM Context i'`, where `i` is an ascending numerical index of
     the created context.
@@ -970,13 +1182,17 @@ changes:
   * `importModuleDynamically` {Function} Called during evaluation of this module
     when `import()` is called. If this option is not specified, calls to
     `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-    This option is part of the experimental modules API, and should not be
-    considered stable.
+    This option is part of the experimental modules API. We do not recommend
+    using it in a production environment.
     * `specifier` {string} specifier passed to `import()`
-    * `module` {vm.Module}
+    * `script` {vm.Script}
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
+  * `microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks
+    scheduled through `Promise`s and `async function`s) will be run immediately
+    after the script has run. They are included in the `timeout` and
+    `breakOnSigint` scopes in that case.
 * Returns: {any} the result of the very last statement executed in the script.
 
 The `vm.runInNewContext()` first contextifies the given `contextObject` (or
@@ -1017,19 +1233,19 @@ changes:
     by this script. **Default:** `'evalmachine.<anonymous>'`.
   * `lineOffset` {number} Specifies the line number offset that is displayed
     in stack traces produced by this script. **Default:** `0`.
-  * `columnOffset` {number} Specifies the column number offset that is displayed
-    in stack traces produced by this script. **Default:** `0`.
+  * `columnOffset` {number} Specifies the first-line column number offset that
+    is displayed in stack traces produced by this script. **Default:** `0`.
   * `displayErrors` {boolean} When `true`, if an [`Error`][] occurs
     while compiling the `code`, the line of code causing the error is attached
     to the stack trace. **Default:** `true`.
   * `timeout` {integer} Specifies the number of milliseconds to execute `code`
     before terminating execution. If execution is terminated, an [`Error`][]
     will be thrown. This value must be a strictly positive integer.
-  * `breakOnSigint` {boolean} If `true`, the execution will be terminated when
-    `SIGINT` (Ctrl+C) is received. Existing handlers for the
-    event that have been attached via `process.on('SIGINT')` will be disabled
-    during script execution, but will continue to work after that. If execution
-    is terminated, an [`Error`][] will be thrown. **Default:** `false`.
+  * `breakOnSigint` {boolean} If `true`, receiving `SIGINT`
+    (<kbd>Ctrl</kbd>+<kbd>C</kbd>) will terminate execution and throw an
+    [`Error`][]. Existing handlers for the event that have been attached via
+    `process.on('SIGINT')` are disabled during script execution, but continue to
+    work after that. **Default:** `false`.
   * `cachedData` {Buffer|TypedArray|DataView} Provides an optional `Buffer` or
     `TypedArray`, or `DataView` with V8's code cache data for the supplied
      source. When supplied, the `cachedDataRejected` value will be set to
@@ -1045,10 +1261,10 @@ changes:
   * `importModuleDynamically` {Function} Called during evaluation of this module
     when `import()` is called. If this option is not specified, calls to
     `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
-    This option is part of the experimental modules API, and should not be
-    considered stable.
+    This option is part of the experimental modules API. We do not recommend
+    using it in a production environment.
     * `specifier` {string} specifier passed to `import()`
-    * `module` {vm.Module}
+    * `script` {vm.Script}
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -1133,13 +1349,13 @@ within which it can operate. The process of creating the V8 Context and
 associating it with the `contextObject` is what this document refers to as
 "contextifying" the object.
 
-## Timeout limitations when using `process.nextTick()`, promises, and `queueMicrotask()`
+## Timeout interactions with asynchronous tasks and Promises
 
-Because of the internal mechanics of how the `process.nextTick()` queue and
-the microtask queue that underlies Promises are implemented within V8 and
-Node.js, it is possible for code running within a context to "escape" the
-`timeout` set using `vm.runInContext()`, `vm.runInNewContext()`, and
-`vm.runInThisContext()`.
+`Promise`s and `async function`s can schedule tasks run by the JavaScript
+engine asynchronously. By default, these tasks are run after all JavaScript
+functions on the current stack are done executing.
+This allows escaping the functionality of the `timeout` and
+`breakOnSigint` options.
 
 For example, the following code executed by `vm.runInNewContext()` with a
 timeout of 5 milliseconds schedules an infinite loop to run after a promise
@@ -1149,35 +1365,55 @@ resolves. The scheduled loop is never interrupted by the timeout:
 const vm = require('vm');
 
 function loop() {
+  console.log('entering loop');
   while (1) console.log(Date.now());
 }
 
 vm.runInNewContext(
-  'Promise.resolve().then(loop);',
+  'Promise.resolve().then(() => loop());',
   { loop, console },
   { timeout: 5 }
 );
+// This is printed *before* 'entering loop' (!)
+console.log('done executing');
 ```
 
-This issue also occurs when the `loop()` call is scheduled using
-the `process.nextTick()` and `queueMicrotask()` functions.
+This can be addressed by passing `microtaskMode: 'afterEvaluate'` to the code
+that creates the `Context`:
 
-This issue occurs because all contexts share the same microtask and nextTick
-queues.
+```js
+const vm = require('vm');
+
+function loop() {
+  while (1) console.log(Date.now());
+}
+
+vm.runInNewContext(
+  'Promise.resolve().then(() => loop());',
+  { loop, console },
+  { timeout: 5, microtaskMode: 'afterEvaluate' }
+);
+```
+
+In this case, the microtask scheduled through `promise.then()` will be run
+before returning from `vm.runInNewContext()`, and will be interrupted
+by the `timeout` functionality. This applies only to code running in a
+`vm.Context`, so e.g. [`vm.runInThisContext()`][] does not take this option.
+
+Promise callbacks are entered into the microtask queue of the context in which
+they were created. For example, if `() => loop()` is replaced with just `loop`
+in the above example, then `loop` will be pushed into the global microtask
+queue, because it is a function from the outer (main) context, and thus will
+also be able to escape the timeout.
+
+If asynchronous scheduling functions such as `process.nextTick()`,
+`queueMicrotask()`, `setTimeout()`, `setImmediate()`, etc. are made available
+inside a `vm.Context`, functions passed to them will be added to global queues,
+which are shared by all contexts. Therefore, callbacks passed to those functions
+are not controllable through the timeout either.
 
-[`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`]: errors.html#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING
-[`ERR_VM_MODULE_STATUS`]: errors.html#ERR_VM_MODULE_STATUS
-[`Error`]: errors.html#errors_class_error
-[`URL`]: url.html#url_class_url
-[`eval()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
-[`script.runInContext()`]: #vm_script_runincontext_contextifiedobject_options
-[`script.runInThisContext()`]: #vm_script_runinthiscontext_options
-[`url.origin`]: url.html#url_url_origin
-[`vm.createContext()`]: #vm_vm_createcontext_contextobject_options
-[`vm.runInContext()`]: #vm_vm_runincontext_code_contextifiedobject_options
-[`vm.runInThisContext()`]: #vm_vm_runinthiscontext_code_options
 [Cyclic Module Record]: https://tc39.es/ecma262/#sec-cyclic-module-records
-[ECMAScript Module Loader]: esm.html#esm_modules_ecmascript_modules
+[ECMAScript Module Loader]: esm.md#esm_modules_ecmascript_modules
 [Evaluate() concrete method]: https://tc39.es/ecma262/#sec-moduleevaluation
 [GetModuleNamespace]: https://tc39.es/ecma262/#sec-getmodulenamespace
 [HostResolveImportedModule]: https://tc39.es/ecma262/#sec-hostresolveimportedmodule
@@ -1186,6 +1422,17 @@ queues.
 [Source Text Module Record]: https://tc39.es/ecma262/#sec-source-text-module-records
 [Synthetic Module Record]: https://heycam.github.io/webidl/#synthetic-module-records
 [V8 Embedder's Guide]: https://v8.dev/docs/embed#contexts
+[`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`]: errors.md#ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING
+[`ERR_VM_MODULE_STATUS`]: errors.md#ERR_VM_MODULE_STATUS
+[`Error`]: errors.md#errors_class_error
+[`URL`]: url.md#url_class_url
+[`eval()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+[`script.runInContext()`]: #vm_script_runincontext_contextifiedobject_options
+[`script.runInThisContext()`]: #vm_script_runinthiscontext_options
+[`url.origin`]: url.md#url_url_origin
+[`vm.createContext()`]: #vm_vm_createcontext_contextobject_options
+[`vm.runInContext()`]: #vm_vm_runincontext_code_contextifiedobject_options
+[`vm.runInThisContext()`]: #vm_vm_runinthiscontext_code_options
 [contextified]: #vm_what_does_it_mean_to_contextify_an_object
 [global object]: https://es5.github.io/#x15.1
 [indirect `eval()` call]: https://es5.github.io/#x10.4.2
diff --git a/doc/api/wasi.html b/doc/api/wasi.html
index 579619a5d9a665b9df8598c5c2d375d1ddffcbf8..ceb5fcd877097b2d41a8d878feadad194e26f61e 100644
--- a/doc/api/wasi.html
+++ b/doc/api/wasi.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>WebAssembly System Interface (WASI) | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>WebAssembly System Interface (WASI) | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="wasi" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,22 +115,21 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/wasi.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/wasi.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/wasi.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/wasi.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/wasi.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/wasi.html">13.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v12.x/api/wasi.html">12.x <b>LTS</b></a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/wasi.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/wasi.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_1"><a href="#wasi_webassembly_system_interface_wasi">WebAssembly System Interface (WASI)</a></span>
 <ul>
 <li><a href="#wasi_class_wasi">Class: <code>WASI</code></a>
@@ -129,34 +142,49 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>WebAssembly System Interface (WASI)<span><a class="mark" href="#wasi_webassembly_system_interface_wasi" id="wasi_webassembly_system_interface_wasi">#</a></span></h1>
+        <h2>WebAssembly System Interface (WASI)<span><a class="mark" href="#wasi_webassembly_system_interface_wasi" id="wasi_webassembly_system_interface_wasi">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/wasi.js">lib/wasi.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/wasi.js">lib/wasi.js</a></p>
 <p>The WASI API provides an implementation of the <a href="https://wasi.dev/">WebAssembly System Interface</a>
 specification. WASI gives sandboxed WebAssembly applications access to the
 underlying operating system via a collection of POSIX-like functions.</p>
-<pre><code class="language-js"><span class="hljs-meta">'use strict'</span>;
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> fs <span class="hljs-keyword">from</span> <span class="hljs-string">'fs'</span>;
+<span class="hljs-keyword">import</span> { <span class="hljs-variable constant_">WASI</span> } <span class="hljs-keyword">from</span> <span class="hljs-string">'wasi'</span>;
+
+<span class="hljs-keyword">const</span> wasi = <span class="hljs-keyword">new</span> <span class="hljs-title function_">WASI</span>({
+  <span class="hljs-attr">args</span>: process.<span class="hljs-property">argv</span>,
+  <span class="hljs-attr">env</span>: process.<span class="hljs-property">env</span>,
+  <span class="hljs-attr">preopens</span>: {
+    <span class="hljs-string">'/sandbox'</span>: <span class="hljs-string">'/some/real/path/that/wasm/can/access'</span>
+  }
+});
+<span class="hljs-keyword">const</span> importObject = { <span class="hljs-attr">wasi_snapshot_preview1</span>: wasi.<span class="hljs-property">wasiImport</span> };
+
+<span class="hljs-keyword">const</span> wasm = <span class="hljs-keyword">await</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title function_">compile</span>(fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'./demo.wasm'</span>));
+<span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">await</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title function_">instantiate</span>(wasm, importObject);
+
+wasi.<span class="hljs-title function_">start</span>(instance);</code><code class="language-js cjs"><span class="hljs-meta">'use strict'</span>;
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
-<span class="hljs-keyword">const</span> { WASI } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'wasi'</span>);
-<span class="hljs-keyword">const</span> wasi = <span class="hljs-keyword">new</span> WASI({
-  <span class="hljs-attr">args</span>: process.argv,
-  <span class="hljs-attr">env</span>: process.env,
+<span class="hljs-keyword">const</span> { <span class="hljs-variable constant_">WASI</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'wasi'</span>);
+<span class="hljs-keyword">const</span> wasi = <span class="hljs-keyword">new</span> <span class="hljs-title function_">WASI</span>({
+  <span class="hljs-attr">args</span>: process.<span class="hljs-property">argv</span>,
+  <span class="hljs-attr">env</span>: process.<span class="hljs-property">env</span>,
   <span class="hljs-attr">preopens</span>: {
     <span class="hljs-string">'/sandbox'</span>: <span class="hljs-string">'/some/real/path/that/wasm/can/access'</span>
   }
 });
-<span class="hljs-keyword">const</span> importObject = { <span class="hljs-attr">wasi_snapshot_preview1</span>: wasi.wasiImport };
+<span class="hljs-keyword">const</span> importObject = { <span class="hljs-attr">wasi_snapshot_preview1</span>: wasi.<span class="hljs-property">wasiImport</span> };
 
 (<span class="hljs-keyword">async</span> () => {
-  <span class="hljs-keyword">const</span> wasm = <span class="hljs-keyword">await</span> WebAssembly.compile(fs.readFileSync(<span class="hljs-string">'./demo.wasm'</span>));
-  <span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">await</span> WebAssembly.instantiate(wasm, importObject);
+  <span class="hljs-keyword">const</span> wasm = <span class="hljs-keyword">await</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title function_">compile</span>(fs.<span class="hljs-title function_">readFileSync</span>(<span class="hljs-string">'./demo.wasm'</span>));
+  <span class="hljs-keyword">const</span> instance = <span class="hljs-keyword">await</span> <span class="hljs-title class_">WebAssembly</span>.<span class="hljs-title function_">instantiate</span>(wasm, importObject);
 
-  wasi.start(instance);
+  wasi.<span class="hljs-title function_">start</span>(instance);
 })();</code></pre>
 <p>To run the above example, create a new WebAssembly text format file named
 <code>demo.wat</code>:</p>
@@ -188,27 +216,27 @@ underlying operating system via a collection of POSIX-like functions.</p>
     )
 )</code></pre>
 <p>Use <a href="https://github.com/WebAssembly/wabt">wabt</a> to compile <code>.wat</code> to <code>.wasm</code></p>
-<pre><code class="language-console"><span class="hljs-meta">$</span><span class="bash"> wat2wasm demo.wat</span></code></pre>
+<pre><code class="language-console"><span class="hljs-meta">$ </span><span class="language-bash">wat2wasm demo.wat</span></code></pre>
 <p>The <code>--experimental-wasi-unstable-preview1</code> and <code>--experimental-wasm-bigint</code>
 CLI arguments are needed for this example to run.</p>
-<h2>Class: <code>WASI</code><span><a class="mark" href="#wasi_class_wasi" id="wasi_class_wasi">#</a></span></h2>
+<section><h3>Class: <code>WASI</code><span><a class="mark" href="#wasi_class_wasi" id="wasi_class_wasi">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0</span>
 </div>
 <p>The <code>WASI</code> class provides the WASI system call API and additional convenience
 methods for working with WASI-based applications. Each <code>WASI</code> instance
 represents a distinct sandbox environment. For security purposes, each <code>WASI</code>
-instance must have its command line arguments, environment variables, and
+instance must have its command-line arguments, environment variables, and
 sandbox directory structure configured explicitly.</p>
-<h3><code>new WASI([options])</code><span><a class="mark" href="#wasi_new_wasi_options" id="wasi_new_wasi_options">#</a></span></h3>
+<h4><code>new WASI([options])</code><span><a class="mark" href="#wasi_new_wasi_options" id="wasi_new_wasi_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> An array of strings that the WebAssembly application will
-see as command line arguments. The first argument is the virtual path to the
+see as command-line arguments. The first argument is the virtual path to the
 WASI command itself. <strong>Default:</strong> <code>[]</code>.</li>
 <li><code>env</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> An object similar to <code>process.env</code> that the WebAssembly
 application will see as its environment. <strong>Default:</strong> <code>{}</code>.</li>
@@ -229,9 +257,9 @@ WebAssembly application. <strong>Default:</strong> <code>2</code>.</li>
 </ul>
 </li>
 </ul>
-<h3><code>wasi.start(instance)</code><span><a class="mark" href="#wasi_wasi_start_instance" id="wasi_wasi_start_instance">#</a></span></h3>
+<h4><code>wasi.start(instance)</code><span><a class="mark" href="#wasi_wasi_start_instance" id="wasi_wasi_start_instance">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0</span>
 </div>
 <ul>
 <li><code>instance</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance" class="type">&#x3C;WebAssembly.Instance></a></li>
@@ -242,9 +270,9 @@ WebAssembly application. <strong>Default:</strong> <code>2</code>.</li>
 <p><code>start()</code> requires that <code>instance</code> exports a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory"><code>WebAssembly.Memory</code></a> named
 <code>memory</code>. If <code>instance</code> does not have a <code>memory</code> export an exception is thrown.</p>
 <p>If <code>start()</code> is called more than once, an exception is thrown.</p>
-<h3><code>wasi.initialize(instance)</code><span><a class="mark" href="#wasi_wasi_initialize_instance" id="wasi_wasi_initialize_instance">#</a></span></h3>
+<h4><code>wasi.initialize(instance)</code><span><a class="mark" href="#wasi_wasi_initialize_instance" id="wasi_wasi_initialize_instance">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.6.0</span>
 </div>
 <ul>
 <li><code>instance</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance" class="type">&#x3C;WebAssembly.Instance></a></li>
@@ -255,19 +283,55 @@ export, then an exception is thrown.</p>
 <p><code>initialize()</code> requires that <code>instance</code> exports a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory"><code>WebAssembly.Memory</code></a> named
 <code>memory</code>. If <code>instance</code> does not have a <code>memory</code> export an exception is thrown.</p>
 <p>If <code>initialize()</code> is called more than once, an exception is thrown.</p>
-<h3><code>wasi.wasiImport</code><span><a class="mark" href="#wasi_wasi_wasiimport" id="wasi_wasi_wasiimport">#</a></span></h3>
+<h4><code>wasi.wasiImport</code><span><a class="mark" href="#wasi_wasi_wasiimport" id="wasi_wasi_wasiimport">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.3.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a></li>
 </ul>
 <p><code>wasiImport</code> is an object that implements the WASI system call API. This object
 should be passed as the <code>wasi_snapshot_preview1</code> import during the instantiation
-of a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance"><code>WebAssembly.Instance</code></a>.</p>
+of a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance"><code>WebAssembly.Instance</code></a>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/wasi.json b/doc/api/wasi.json
index cd95529988f54333142a4ee7be21c161e463cea4..4d449586901c018536fa2eabf67878d3c3fe2894 100644
--- a/doc/api/wasi.json
+++ b/doc/api/wasi.json
@@ -8,7 +8,7 @@
       "introduced_in": "v12.16.0",
       "stability": 1,
       "stabilityText": "Experimental",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/wasi.js\">lib/wasi.js</a></p>\n<p>The WASI API provides an implementation of the <a href=\"https://wasi.dev/\">WebAssembly System Interface</a>\nspecification. WASI gives sandboxed WebAssembly applications access to the\nunderlying operating system via a collection of POSIX-like functions.</p>\n<pre><code class=\"language-js\">'use strict';\nconst fs = require('fs');\nconst { WASI } = require('wasi');\nconst wasi = new WASI({\n  args: process.argv,\n  env: process.env,\n  preopens: {\n    '/sandbox': '/some/real/path/that/wasm/can/access'\n  }\n});\nconst importObject = { wasi_snapshot_preview1: wasi.wasiImport };\n\n(async () => {\n  const wasm = await WebAssembly.compile(fs.readFileSync('./demo.wasm'));\n  const instance = await WebAssembly.instantiate(wasm, importObject);\n\n  wasi.start(instance);\n})();\n</code></pre>\n<p>To run the above example, create a new WebAssembly text format file named\n<code>demo.wat</code>:</p>\n<pre><code class=\"language-text\">(module\n    ;; Import the required fd_write WASI function which will write the given io vectors to stdout\n    ;; The function signature for fd_write is:\n    ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written\n    (import \"wasi_snapshot_preview1\" \"fd_write\" (func $fd_write (param i32 i32 i32 i32) (result i32)))\n\n    (memory 1)\n    (export \"memory\" (memory 0))\n\n    ;; Write 'hello world\\n' to memory at an offset of 8 bytes\n    ;; Note the trailing newline which is required for the text to appear\n    (data (i32.const 8) \"hello world\\n\")\n\n    (func $main (export \"_start\")\n        ;; Creating a new io vector within linear memory\n        (i32.store (i32.const 0) (i32.const 8))  ;; iov.iov_base - This is a pointer to the start of the 'hello world\\n' string\n        (i32.store (i32.const 4) (i32.const 12))  ;; iov.iov_len - The length of the 'hello world\\n' string\n\n        (call $fd_write\n            (i32.const 1) ;; file_descriptor - 1 for stdout\n            (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0\n            (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.\n            (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written\n        )\n        drop ;; Discard the number of bytes written from the top of the stack\n    )\n)\n</code></pre>\n<p>Use <a href=\"https://github.com/WebAssembly/wabt\">wabt</a> to compile <code>.wat</code> to <code>.wasm</code></p>\n<pre><code class=\"language-console\">$ wat2wasm demo.wat\n</code></pre>\n<p>The <code>--experimental-wasi-unstable-preview1</code> and <code>--experimental-wasm-bigint</code>\nCLI arguments are needed for this example to run.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/wasi.js\">lib/wasi.js</a></p>\n<p>The WASI API provides an implementation of the <a href=\"https://wasi.dev/\">WebAssembly System Interface</a>\nspecification. WASI gives sandboxed WebAssembly applications access to the\nunderlying operating system via a collection of POSIX-like functions.</p>\n<pre><code class=\"language-mjs\">import fs from 'fs';\nimport { WASI } from 'wasi';\n\nconst wasi = new WASI({\n  args: process.argv,\n  env: process.env,\n  preopens: {\n    '/sandbox': '/some/real/path/that/wasm/can/access'\n  }\n});\nconst importObject = { wasi_snapshot_preview1: wasi.wasiImport };\n\nconst wasm = await WebAssembly.compile(fs.readFileSync('./demo.wasm'));\nconst instance = await WebAssembly.instantiate(wasm, importObject);\n\nwasi.start(instance);\n</code></pre>\n<pre><code class=\"language-cjs\">'use strict';\nconst fs = require('fs');\nconst { WASI } = require('wasi');\nconst wasi = new WASI({\n  args: process.argv,\n  env: process.env,\n  preopens: {\n    '/sandbox': '/some/real/path/that/wasm/can/access'\n  }\n});\nconst importObject = { wasi_snapshot_preview1: wasi.wasiImport };\n\n(async () => {\n  const wasm = await WebAssembly.compile(fs.readFileSync('./demo.wasm'));\n  const instance = await WebAssembly.instantiate(wasm, importObject);\n\n  wasi.start(instance);\n})();\n</code></pre>\n<p>To run the above example, create a new WebAssembly text format file named\n<code>demo.wat</code>:</p>\n<pre><code class=\"language-text\">(module\n    ;; Import the required fd_write WASI function which will write the given io vectors to stdout\n    ;; The function signature for fd_write is:\n    ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written\n    (import \"wasi_snapshot_preview1\" \"fd_write\" (func $fd_write (param i32 i32 i32 i32) (result i32)))\n\n    (memory 1)\n    (export \"memory\" (memory 0))\n\n    ;; Write 'hello world\\n' to memory at an offset of 8 bytes\n    ;; Note the trailing newline which is required for the text to appear\n    (data (i32.const 8) \"hello world\\n\")\n\n    (func $main (export \"_start\")\n        ;; Creating a new io vector within linear memory\n        (i32.store (i32.const 0) (i32.const 8))  ;; iov.iov_base - This is a pointer to the start of the 'hello world\\n' string\n        (i32.store (i32.const 4) (i32.const 12))  ;; iov.iov_len - The length of the 'hello world\\n' string\n\n        (call $fd_write\n            (i32.const 1) ;; file_descriptor - 1 for stdout\n            (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0\n            (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.\n            (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written\n        )\n        drop ;; Discard the number of bytes written from the top of the stack\n    )\n)\n</code></pre>\n<p>Use <a href=\"https://github.com/WebAssembly/wabt\">wabt</a> to compile <code>.wat</code> to <code>.wasm</code></p>\n<pre><code class=\"language-console\">$ wat2wasm demo.wat\n</code></pre>\n<p>The <code>--experimental-wasi-unstable-preview1</code> and <code>--experimental-wasm-bigint</code>\nCLI arguments are needed for this example to run.</p>",
       "classes": [
         {
           "textRaw": "Class: `WASI`",
@@ -16,11 +16,12 @@
           "name": "WASI",
           "meta": {
             "added": [
+              "v13.3.0",
               "v12.16.0"
             ],
             "changes": []
           },
-          "desc": "<p>The <code>WASI</code> class provides the WASI system call API and additional convenience\nmethods for working with WASI-based applications. Each <code>WASI</code> instance\nrepresents a distinct sandbox environment. For security purposes, each <code>WASI</code>\ninstance must have its command line arguments, environment variables, and\nsandbox directory structure configured explicitly.</p>",
+          "desc": "<p>The <code>WASI</code> class provides the WASI system call API and additional convenience\nmethods for working with WASI-based applications. Each <code>WASI</code> instance\nrepresents a distinct sandbox environment. For security purposes, each <code>WASI</code>\ninstance must have its command-line arguments, environment variables, and\nsandbox directory structure configured explicitly.</p>",
           "methods": [
             {
               "textRaw": "`wasi.start(instance)`",
@@ -28,6 +29,7 @@
               "name": "start",
               "meta": {
                 "added": [
+                  "v13.3.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -51,7 +53,7 @@
               "name": "initialize",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.6.0"
                 ],
                 "changes": []
               },
@@ -76,6 +78,7 @@
               "name": "wasiImport",
               "meta": {
                 "added": [
+                  "v13.3.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -92,11 +95,11 @@
                   "type": "Object",
                   "options": [
                     {
-                      "textRaw": "`args` {Array} An array of strings that the WebAssembly application will see as command line arguments. The first argument is the virtual path to the WASI command itself. **Default:** `[]`.",
+                      "textRaw": "`args` {Array} An array of strings that the WebAssembly application will see as command-line arguments. The first argument is the virtual path to the WASI command itself. **Default:** `[]`.",
                       "name": "args",
                       "type": "Array",
                       "default": "`[]`",
-                      "desc": "An array of strings that the WebAssembly application will see as command line arguments. The first argument is the virtual path to the WASI command itself."
+                      "desc": "An array of strings that the WebAssembly application will see as command-line arguments. The first argument is the virtual path to the WASI command itself."
                     },
                     {
                       "textRaw": "`env` {Object} An object similar to `process.env` that the WebAssembly application will see as its environment. **Default:** `{}`.",
diff --git a/doc/api/wasi.md b/doc/api/wasi.md
index 66aeebc6974000cb61fcc2865854e95e7a69544d..6fcb80f6670567c2a714f863b6214e10dd9c5dce 100644
--- a/doc/api/wasi.md
+++ b/doc/api/wasi.md
@@ -10,7 +10,26 @@ The WASI API provides an implementation of the [WebAssembly System Interface][]
 specification. WASI gives sandboxed WebAssembly applications access to the
 underlying operating system via a collection of POSIX-like functions.
 
-```js
+```mjs
+import fs from 'fs';
+import { WASI } from 'wasi';
+
+const wasi = new WASI({
+  args: process.argv,
+  env: process.env,
+  preopens: {
+    '/sandbox': '/some/real/path/that/wasm/can/access'
+  }
+});
+const importObject = { wasi_snapshot_preview1: wasi.wasiImport };
+
+const wasm = await WebAssembly.compile(fs.readFileSync('./demo.wasm'));
+const instance = await WebAssembly.instantiate(wasm, importObject);
+
+wasi.start(instance);
+```
+
+```cjs
 'use strict';
 const fs = require('fs');
 const { WASI } = require('wasi');
@@ -75,23 +94,27 @@ CLI arguments are needed for this example to run.
 
 ## Class: `WASI`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.3.0
+ - v12.16.0
 -->
 
 The `WASI` class provides the WASI system call API and additional convenience
 methods for working with WASI-based applications. Each `WASI` instance
 represents a distinct sandbox environment. For security purposes, each `WASI`
-instance must have its command line arguments, environment variables, and
+instance must have its command-line arguments, environment variables, and
 sandbox directory structure configured explicitly.
 
 ### `new WASI([options])`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.3.0
+ - v12.16.0
 -->
 
 * `options` {Object}
   * `args` {Array} An array of strings that the WebAssembly application will
-    see as command line arguments. The first argument is the virtual path to the
+    see as command-line arguments. The first argument is the virtual path to the
     WASI command itself. **Default:** `[]`.
   * `env` {Object} An object similar to `process.env` that the WebAssembly
     application will see as its environment. **Default:** `{}`.
@@ -112,7 +135,9 @@ added: v12.16.0
 
 ### `wasi.start(instance)`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.3.0
+ - v12.16.0
 -->
 
 * `instance` {WebAssembly.Instance}
@@ -129,7 +154,7 @@ If `start()` is called more than once, an exception is thrown.
 ### `wasi.initialize(instance)`
 <!-- YAML
 added:
- - v12.19.0
+ - v14.6.0
 -->
 
 * `instance` {WebAssembly.Instance}
@@ -145,7 +170,9 @@ If `initialize()` is called more than once, an exception is thrown.
 
 ### `wasi.wasiImport`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.3.0
+ - v12.16.0
 -->
 
 * {Object}
diff --git a/doc/api/worker_threads.html b/doc/api/worker_threads.html
index 7b08c69c4b4781e5ac8e32d9c617c705fa57deca..8e4db373d291e54494abb26eecaf57c8179b1559 100644
--- a/doc/api/worker_threads.html
+++ b/doc/api/worker_threads.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Worker threads | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Worker threads | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="worker_threads" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/worker_threads.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/worker_threads.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/worker_threads.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/worker_threads.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/worker_threads.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/worker_threads.html">13.x</a></li>
@@ -110,17 +125,16 @@
 <li><a href="https://nodejs.org/docs/latest-v10.x/api/worker_threads.html">10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/worker_threads.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/worker_threads.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#worker_threads_worker_threads">Worker threads</a></span>
 <ul>
+<li><span class="stability_1"><a href="#worker_threads_worker_getenvironmentdata_key"><code>worker.getEnvironmentData(key)</code></a></span></li>
 <li><a href="#worker_threads_worker_ismainthread"><code>worker.isMainThread</code></a></li>
 <li><a href="#worker_threads_worker_markasuntransferable_object"><code>worker.markAsUntransferable(object)</code></a></li>
 <li><a href="#worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox"><code>worker.moveMessagePortToContext(port, contextifiedSandbox)</code></a></li>
@@ -128,6 +142,7 @@
 <li><a href="#worker_threads_worker_receivemessageonport_port"><code>worker.receiveMessageOnPort(port)</code></a></li>
 <li><a href="#worker_threads_worker_resourcelimits"><code>worker.resourceLimits</code></a></li>
 <li><a href="#worker_threads_worker_share_env"><code>worker.SHARE_ENV</code></a></li>
+<li><span class="stability_1"><a href="#worker_threads_worker_setenvironmentdata_key_value"><code>worker.setEnvironmentData(key[, value])</code></a></span></li>
 <li><a href="#worker_threads_worker_threadid"><code>worker.threadId</code></a></li>
 <li><a href="#worker_threads_worker_workerdata"><code>worker.workerData</code></a></li>
 <li><a href="#worker_threads_class_messagechannel">Class: <code>MessageChannel</code></a></li>
@@ -172,16 +187,21 @@
 <li><a href="#worker_threads_worker_unref"><code>worker.unref()</code></a></li>
 </ul>
 </li>
+<li><a href="#worker_threads_notes">Notes</a>
+<ul>
+<li><a href="#worker_threads_synchronous_blocking_of_stdio">Synchronous blocking of stdio</a></li>
+<li><a href="#worker_threads_launching_worker_threads_from_preload_scripts">Launching worker threads from preload scripts</a></li>
 </ul>
 </li>
 </ul>
-      </div>
+</li>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Worker threads<span><a class="mark" href="#worker_threads_worker_threads" id="worker_threads_worker_threads">#</a></span></h1>
+        <h2>Worker threads<span><a class="mark" href="#worker_threads_worker_threads" id="worker_threads_worker_threads">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/worker_threads.js">lib/worker_threads.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/worker_threads.js">lib/worker_threads.js</a></p>
 <p>The <code>worker_threads</code> module enables the use of threads that execute JavaScript
 in parallel. To access it:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> worker = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);</code></pre>
@@ -192,27 +212,27 @@ I/O operations are more efficient than Workers can be.</p>
 so by transferring <code>ArrayBuffer</code> instances or sharing <code>SharedArrayBuffer</code>
 instances.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> {
-  Worker, isMainThread, parentPort, workerData
+  <span class="hljs-title class_">Worker</span>, isMainThread, parentPort, workerData
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-built_in">module</span>.exports = <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">parseJSAsync</span>(<span class="hljs-params">script</span>) </span>{
-    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
-      <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename, {
+  <span class="hljs-variable language_">module</span>.<span class="hljs-property">exports</span> = <span class="hljs-keyword">function</span> <span class="hljs-title function_">parseJSAsync</span>(<span class="hljs-params">script</span>) {
+    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Promise</span>(<span class="hljs-function">(<span class="hljs-params">resolve, reject</span>) =></span> {
+      <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename, {
         <span class="hljs-attr">workerData</span>: script
       });
-      worker.on(<span class="hljs-string">'message'</span>, resolve);
-      worker.on(<span class="hljs-string">'error'</span>, reject);
-      worker.on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
+      worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, resolve);
+      worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'error'</span>, reject);
+      worker.<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">(<span class="hljs-params">code</span>) =></span> {
         <span class="hljs-keyword">if</span> (code !== <span class="hljs-number">0</span>)
-          reject(<span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">`Worker stopped with exit code <span class="hljs-subst">${code}</span>`</span>));
+          <span class="hljs-title function_">reject</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">`Worker stopped with exit code <span class="hljs-subst">${code}</span>`</span>));
       });
     });
   };
 } <span class="hljs-keyword">else</span> {
   <span class="hljs-keyword">const</span> { parse } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'some-js-parsing-library'</span>);
   <span class="hljs-keyword">const</span> script = workerData;
-  parentPort.postMessage(parse(script));
+  parentPort.<span class="hljs-title function_">postMessage</span>(<span class="hljs-title function_">parse</span>(script));
 }</code></pre>
 <p>The above example spawns a Worker thread for each <code>parse()</code> call. In actual
 practice, use a pool of Workers instead for these kinds of tasks. Otherwise, the
@@ -225,7 +245,34 @@ in the <code>async_hooks</code> documentation for an example implementation.</p>
 <p>Worker threads inherit non-process-specific options by default. Refer to
 <a href="#worker_threads_new_worker_filename_options"><code>Worker constructor options</code></a> to know how to customize worker thread options,
 specifically <code>argv</code> and <code>execArgv</code> options.</p>
-<h2><code>worker.isMainThread</code><span><a class="mark" href="#worker_threads_worker_ismainthread" id="worker_threads_worker_ismainthread">#</a></span></h2>
+<section><h3><code>worker.getEnvironmentData(key)</code><span><a class="mark" href="#worker_threads_worker_getenvironmentdata_key" id="worker_threads_worker_getenvironmentdata_key">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<ul>
+<li><code>key</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Any arbitrary, cloneable JavaScript value that can be used as a
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" class="type">&#x3C;Map></a> key.</li>
+<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
+</ul>
+<p>Within a worker thread, <code>worker.getEnvironmentData()</code> returns a clone
+of data passed to the spawning thread's <code>worker.setEnvironmentData()</code>.
+Every new <code>Worker</code> receives its own copy of the environment data
+automatically.</p>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> {
+  <span class="hljs-title class_">Worker</span>,
+  isMainThread,
+  setEnvironmentData,
+  getEnvironmentData,
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+
+<span class="hljs-keyword">if</span> (isMainThread) {
+  <span class="hljs-title function_">setEnvironmentData</span>(<span class="hljs-string">'Hello'</span>, <span class="hljs-string">'World!'</span>);
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
+} <span class="hljs-keyword">else</span> {
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">getEnvironmentData</span>(<span class="hljs-string">'Hello'</span>));  <span class="hljs-comment">// Prints 'World!'.</span>
+}</code></pre>
+</section><section><h3><code>worker.isMainThread</code><span><a class="mark" href="#worker_threads_worker_ismainthread" id="worker_threads_worker_ismainthread">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -233,18 +280,18 @@ specifically <code>argv</code> and <code>execArgv</code> options.</p>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a></li>
 </ul>
 <p>Is <code>true</code> if this code is not running inside of a <a href="#worker_threads_class_worker"><code>Worker</code></a> thread.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, isMainThread } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, isMainThread } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
   <span class="hljs-comment">// This re-loads the current file inside a Worker instance.</span>
-  <span class="hljs-keyword">new</span> Worker(__filename);
+  <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
 } <span class="hljs-keyword">else</span> {
-  <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'Inside Worker!'</span>);
-  <span class="hljs-built_in">console</span>.log(isMainThread);  <span class="hljs-comment">// Prints 'false'.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Inside Worker!'</span>);
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(isMainThread);  <span class="hljs-comment">// Prints 'false'.</span>
 }</code></pre>
-<h2><code>worker.markAsUntransferable(object)</code><span><a class="mark" href="#worker_threads_worker_markasuntransferable_object" id="worker_threads_worker_markasuntransferable_object">#</a></span></h2>
+</section><section><h3><code>worker.markAsUntransferable(object)</code><span><a class="mark" href="#worker_threads_worker_markasuntransferable_object" id="worker_threads_worker_markasuntransferable_object">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <p>Mark an object as not transferable. If <code>object</code> occurs in the transfer list of
 a <a href="#worker_threads_port_postmessage_value_transferlist"><code>port.postMessage()</code></a> call, it will be ignored.</p>
@@ -253,25 +300,25 @@ transferred, and which are used by other objects on the sending side.
 For example, Node.js marks the <code>ArrayBuffer</code>s it uses for its
 <a href="buffer.html#buffer_static_method_buffer_allocunsafe_size"><code>Buffer</code> pool</a> with this.</p>
 <p>This operation cannot be undone.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel, markAsUntransferable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span>, markAsUntransferable } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
-<span class="hljs-keyword">const</span> pooledBuffer = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">8</span>);
-<span class="hljs-keyword">const</span> typedArray1 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(pooledBuffer);
-<span class="hljs-keyword">const</span> typedArray2 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Float64Array</span>(pooledBuffer);
+<span class="hljs-keyword">const</span> pooledBuffer = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">8</span>);
+<span class="hljs-keyword">const</span> typedArray1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(pooledBuffer);
+<span class="hljs-keyword">const</span> typedArray2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Float</span>64<span class="hljs-built_in">Array</span>(pooledBuffer);
 
-markAsUntransferable(pooledBuffer);
+<span class="hljs-title function_">markAsUntransferable</span>(pooledBuffer);
 
-<span class="hljs-keyword">const</span> { port1 } = <span class="hljs-keyword">new</span> MessageChannel();
-port1.postMessage(typedArray1, [ typedArray1.buffer ]);
+<span class="hljs-keyword">const</span> { port1 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+port1.<span class="hljs-title function_">postMessage</span>(typedArray1, [ typedArray1.<span class="hljs-property">buffer</span> ]);
 
 <span class="hljs-comment">// The following line prints the contents of typedArray1 -- it still owns</span>
 <span class="hljs-comment">// its memory and has been cloned, not transferred. Without</span>
 <span class="hljs-comment">// `markAsUntransferable()`, this would print an empty Uint8Array.</span>
 <span class="hljs-comment">// typedArray2 is intact as well.</span>
-<span class="hljs-built_in">console</span>.log(typedArray1);
-<span class="hljs-built_in">console</span>.log(typedArray2);</code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(typedArray1);
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(typedArray2);</code></pre>
 <p>There is no equivalent to this API in browsers.</p>
-<h2><code>worker.moveMessagePortToContext(port, contextifiedSandbox)</code><span><a class="mark" href="#worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox" id="worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox">#</a></span></h2>
+</section><section><h3><code>worker.moveMessagePortToContext(port, contextifiedSandbox)</code><span><a class="mark" href="#worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox" id="worker_threads_worker_movemessageporttocontext_port_contextifiedsandbox">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.13.0</span>
 </div>
@@ -295,9 +342,9 @@ inherit from its global <code>Object</code> class. Objects passed to the
 <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage"><code>port.onmessage()</code></a> listener will also be created in the target context
 and inherit from its global <code>Object</code> class.</p>
 <p>However, the created <code>MessagePort</code> will no longer inherit from
-<a href="events.html"><code>EventEmitter</code></a>, and only <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage"><code>port.onmessage()</code></a> can be used to receive
+<a href="https://developer.mozilla.org/en-US/docs/Web/API/EventTarget"><code>EventTarget</code></a>, and only <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage"><code>port.onmessage()</code></a> can be used to receive
 events using it.</p>
-<h2><code>worker.parentPort</code><span><a class="mark" href="#worker_threads_worker_parentport" id="worker_threads_worker_parentport">#</a></span></h2>
+</section><section><h3><code>worker.parentPort</code><span><a class="mark" href="#worker_threads_worker_parentport" id="worker_threads_worker_parentport">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -310,21 +357,21 @@ allowing communication with the parent thread. Messages sent using
 using <code>worker.on('message')</code>, and messages sent from the parent thread
 using <code>worker.postMessage()</code> will be available in this thread using
 <code>parentPort.on('message')</code>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, isMainThread, parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, isMainThread, parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename);
-  worker.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(message);  <span class="hljs-comment">// Prints 'Hello, world!'.</span>
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
+  worker.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message);  <span class="hljs-comment">// Prints 'Hello, world!'.</span>
   });
-  worker.postMessage(<span class="hljs-string">'Hello, world!'</span>);
+  worker.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'Hello, world!'</span>);
 } <span class="hljs-keyword">else</span> {
   <span class="hljs-comment">// When a message from the parent thread is received, send it back:</span>
-  parentPort.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
-    parentPort.postMessage(message);
+  parentPort.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> {
+    parentPort.<span class="hljs-title function_">postMessage</span>(message);
   });
 }</code></pre>
-<h2><code>worker.receiveMessageOnPort(port)</code><span><a class="mark" href="#worker_threads_worker_receivemessageonport_port" id="worker_threads_worker_receivemessageonport_port">#</a></span></h2>
+</section><section><h3><code>worker.receiveMessageOnPort(port)</code><span><a class="mark" href="#worker_threads_worker_receivemessageonport_port" id="worker_threads_worker_receivemessageonport_port">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v12.3.0</span>
 </div>
@@ -340,19 +387,19 @@ using <code>worker.postMessage()</code> will be available in this thread using
 <code>undefined</code> is returned, otherwise an object with a single <code>message</code> property
 that contains the message payload, corresponding to the oldest message in the
 <code>MessagePort</code>’s queue.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel, receiveMessageOnPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
-port1.postMessage({ <span class="hljs-attr">hello</span>: <span class="hljs-string">'world'</span> });
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span>, receiveMessageOnPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+port1.<span class="hljs-title function_">postMessage</span>({ <span class="hljs-attr">hello</span>: <span class="hljs-string">'world'</span> });
 
-<span class="hljs-built_in">console</span>.log(receiveMessageOnPort(port2));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">receiveMessageOnPort</span>(port2));
 <span class="hljs-comment">// Prints: { message: { hello: 'world' } }</span>
-<span class="hljs-built_in">console</span>.log(receiveMessageOnPort(port2));
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-title function_">receiveMessageOnPort</span>(port2));
 <span class="hljs-comment">// Prints: undefined</span></code></pre>
 <p>When this function is used, no <code>'message'</code> event will be emitted and the
 <code>onmessage</code> listener will not be invoked.</p>
-<h2><code>worker.resourceLimits</code><span><a class="mark" href="#worker_threads_worker_resourcelimits" id="worker_threads_worker_resourcelimits">#</a></span></h2>
+</section><section><h3><code>worker.resourceLimits</code><span><a class="mark" href="#worker_threads_worker_resourcelimits" id="worker_threads_worker_resourcelimits">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -368,7 +415,7 @@ port1.postMessage({ <span class="hljs-attr">hello</span>: <span class="hljs-stri
 If the <code>resourceLimits</code> option was passed to the <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor,
 this matches its values.</p>
 <p>If this is used in the main thread, its value is an empty object.</p>
-<h2><code>worker.SHARE_ENV</code><span><a class="mark" href="#worker_threads_worker_share_env" id="worker_threads_worker_share_env">#</a></span></h2>
+</section><section><h3><code>worker.SHARE_ENV</code><span><a class="mark" href="#worker_threads_worker_share_env" id="worker_threads_worker_share_env">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v11.14.0</span>
 </div>
@@ -378,12 +425,27 @@ this matches its values.</p>
 <p>A special value that can be passed as the <code>env</code> option of the <a href="#worker_threads_class_worker"><code>Worker</code></a>
 constructor, to indicate that the current thread and the Worker thread should
 share read and write access to the same set of environment variables.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, SHARE_ENV } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">new</span> Worker(<span class="hljs-string">'process.env.SET_IN_WORKER = "foo"'</span>, { <span class="hljs-attr">eval</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">env</span>: SHARE_ENV })
-  .on(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
-    <span class="hljs-built_in">console</span>.log(process.env.SET_IN_WORKER);  <span class="hljs-comment">// Prints 'foo'.</span>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, <span class="hljs-variable constant_">SHARE_ENV</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(<span class="hljs-string">'process.env.SET_IN_WORKER = "foo"'</span>, { <span class="hljs-attr">eval</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">env</span>: <span class="hljs-variable constant_">SHARE_ENV</span> })
+  .<span class="hljs-title function_">on</span>(<span class="hljs-string">'exit'</span>, <span class="hljs-function">() =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(process.<span class="hljs-property">env</span>.<span class="hljs-property">SET_IN_WORKER</span>);  <span class="hljs-comment">// Prints 'foo'.</span>
   });</code></pre>
-<h2><code>worker.threadId</code><span><a class="mark" href="#worker_threads_worker_threadid" id="worker_threads_worker_threadid">#</a></span></h2>
+</section><section><h3><code>worker.setEnvironmentData(key[, value])</code><span><a class="mark" href="#worker_threads_worker_setenvironmentdata_key_value" id="worker_threads_worker_setenvironmentdata_key_value">#</a></span></h3>
+<div class="api_metadata">
+<span>Added in: v14.18.0</span>
+</div>
+<p></p><div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div><p></p>
+<ul>
+<li><code>key</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Any arbitrary, cloneable JavaScript value that can be used as a
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map" class="type">&#x3C;Map></a> key.</li>
+<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Any arbitrary, cloneable JavaScript value that will be cloned
+and passed automatically to all new <code>Worker</code> instances. If <code>value</code> is passed
+as <code>undefined</code>, any previously set value for the <code>key</code> will be deleted.</li>
+</ul>
+<p>The <code>worker.setEnvironmentData()</code> API sets the content of
+<code>worker.getEnvironmentData()</code> in the current thread and all new <code>Worker</code>
+instances spawned from the current context.</p>
+</section><section><h3><code>worker.threadId</code><span><a class="mark" href="#worker_threads_worker_threadid" id="worker_threads_worker_threadid">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -393,7 +455,7 @@ share read and write access to the same set of environment variables.</p>
 <p>An integer identifier for the current thread. On the corresponding worker object
 (if there is any), it is available as <a href="#worker_threads_worker_threadid_1"><code>worker.threadId</code></a>.
 This value is unique for each <a href="#worker_threads_class_worker"><code>Worker</code></a> instance inside a single process.</p>
-<h2><code>worker.workerData</code><span><a class="mark" href="#worker_threads_worker_workerdata" id="worker_threads_worker_workerdata">#</a></span></h2>
+</section><section><h3><code>worker.workerData</code><span><a class="mark" href="#worker_threads_worker_workerdata" id="worker_threads_worker_workerdata">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -401,14 +463,14 @@ This value is unique for each <a href="#worker_threads_class_worker"><code>Worke
 to this thread’s <code>Worker</code> constructor.</p>
 <p>The data is cloned as if using <a href="#worker_threads_port_postmessage_value_transferlist"><code>postMessage()</code></a>,
 according to the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm">HTML structured clone algorithm</a>.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, isMainThread, workerData } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, isMainThread, workerData } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename, { <span class="hljs-attr">workerData</span>: <span class="hljs-string">'Hello, world!'</span> });
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename, { <span class="hljs-attr">workerData</span>: <span class="hljs-string">'Hello, world!'</span> });
 } <span class="hljs-keyword">else</span> {
-  <span class="hljs-built_in">console</span>.log(workerData);  <span class="hljs-comment">// Prints 'Hello, world!'.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(workerData);  <span class="hljs-comment">// Prints 'Hello, world!'.</span>
 }</code></pre>
-<h2>Class: <code>MessageChannel</code><span><a class="mark" href="#worker_threads_class_messagechannel" id="worker_threads_class_messagechannel">#</a></span></h2>
+</section><section><h3>Class: <code>MessageChannel</code><span><a class="mark" href="#worker_threads_class_messagechannel" id="worker_threads_class_messagechannel">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -417,43 +479,50 @@ two-way communications channel.
 The <code>MessageChannel</code> has no methods of its own. <code>new MessageChannel()</code>
 yields an object with <code>port1</code> and <code>port2</code> properties, which refer to linked
 <a href="#worker_threads_class_messageport"><code>MessagePort</code></a> instances.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
-port1.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'received'</span>, message));
-port2.postMessage({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span> });
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+port1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'received'</span>, message));
+port2.<span class="hljs-title function_">postMessage</span>({ <span class="hljs-attr">foo</span>: <span class="hljs-string">'bar'</span> });
 <span class="hljs-comment">// Prints: received { foo: 'bar' } from the `port1.on('message')` listener</span></code></pre>
-<h2>Class: <code>MessagePort</code><span><a class="mark" href="#worker_threads_class_messageport" id="worker_threads_class_messageport">#</a></span></h2>
+</section><section><h3>Class: <code>MessagePort</code><span><a class="mark" href="#worker_threads_class_messageport" id="worker_threads_class_messageport">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v10.5.0</span>
+<details class="changelog"><summary>History</summary>
+<table>
+<tbody><tr><th>Version</th><th>Changes</th></tr>
+<tr><td>v14.7.0</td>
+<td><p>This class now inherits from <code>EventTarget</code> rather than from <code>EventEmitter</code>.</p></td></tr>
+<tr><td>v10.5.0</td>
+<td><p><span>Added in: v10.5.0</span></p></td></tr>
+</tbody></table>
+</details>
 </div>
 <ul>
-<li>Extends: <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
+<li>Extends: <a href="events.html#events_class_eventtarget" class="type">&#x3C;EventTarget></a></li>
 </ul>
 <p>Instances of the <code>worker.MessagePort</code> class represent one end of an
 asynchronous, two-way communications channel. It can be used to transfer
 structured data, memory regions and other <code>MessagePort</code>s between different
 <a href="#worker_threads_class_worker"><code>Worker</code></a>s.</p>
-<p>With the exception of <code>MessagePort</code>s being <a href="events.html"><code>EventEmitter</code></a>s rather
-than <a href="https://developer.mozilla.org/en-US/docs/Web/API/EventTarget"><code>EventTarget</code></a>s, this implementation matches <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort">browser <code>MessagePort</code></a>s.</p>
-<h3>Event: <code>'close'</code><span><a class="mark" href="#worker_threads_event_close" id="worker_threads_event_close">#</a></span></h3>
+<p>This implementation matches <a href="https://developer.mozilla.org/en-US/docs/Web/API/MessagePort">browser <code>MessagePort</code></a>s.</p>
+<h4>Event: <code>'close'</code><span><a class="mark" href="#worker_threads_event_close" id="worker_threads_event_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
 <p>The <code>'close'</code> event is emitted once either side of the channel has been
 disconnected.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
 
 <span class="hljs-comment">// Prints:</span>
 <span class="hljs-comment">//   foobar</span>
 <span class="hljs-comment">//   closed!</span>
-port2.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(message));
-port2.on(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'closed!'</span>));
+port2.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message));
+port2.<span class="hljs-title function_">on</span>(<span class="hljs-string">'close'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'closed!'</span>));
 
-port1.postMessage(<span class="hljs-string">'foobar'</span>);
-port1.close();</code></pre>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#worker_threads_event_message" id="worker_threads_event_message">#</a></span></h3>
+port1.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'foobar'</span>);
+port1.<span class="hljs-title function_">close</span>();</code></pre>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#worker_threads_event_message" id="worker_threads_event_message">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -464,15 +533,20 @@ port1.close();</code></pre>
 input of <a href="#worker_threads_port_postmessage_value_transferlist"><code>port.postMessage()</code></a>.</p>
 <p>Listeners on this event will receive a clone of the <code>value</code> parameter as passed
 to <code>postMessage()</code> and no further arguments.</p>
-<h3>Event: <code>'messageerror'</code><span><a class="mark" href="#worker_threads_event_messageerror" id="worker_threads_event_messageerror">#</a></span></h3>
+<h4>Event: <code>'messageerror'</code><span><a class="mark" href="#worker_threads_event_messageerror" id="worker_threads_event_messageerror">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> An Error object</li>
 </ul>
 <p>The <code>'messageerror'</code> event is emitted when deserializing a message failed.</p>
-<h3><code>port.close()</code><span><a class="mark" href="#worker_threads_port_close" id="worker_threads_port_close">#</a></span></h3>
+<p>Currently, this event is emitted when there is an error occurring while
+instantiating the posted JS object on the receiving end. Such situations
+are rare, but can happen, for instance, when certain Node.js API objects
+are received in a <code>vm.Context</code> (where Node.js APIs are currently
+unavailable).</p>
+<h4><code>port.close()</code><span><a class="mark" href="#worker_threads_port_close" id="worker_threads_port_close">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -481,14 +555,18 @@ This method can be called when no further communication will happen over this
 <code>MessagePort</code>.</p>
 <p>The <a href="#worker_threads_event_close"><code>'close'</code> event</a> will be emitted on both <code>MessagePort</code> instances that
 are part of the channel.</p>
-<h3><code>port.postMessage(value[, transferList])</code><span><a class="mark" href="#worker_threads_port_postmessage_value_transferlist" id="worker_threads_port_postmessage_value_transferlist">#</a></span></h3>
+<h4><code>port.postMessage(value[, transferList])</code><span><a class="mark" href="#worker_threads_port_postmessage_value_transferlist" id="worker_threads_port_postmessage_value_transferlist">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.18.0</td>
+<td><p>Add 'BlockList' to the list of cloneable types.</p></td></tr>
+<tr><td>v14.18.0</td>
+<td><p>Add 'Histogram' types to the list of cloneable types.</p></td></tr>
+<tr><td>v14.5.0</td>
 <td><p>Added <code>KeyObject</code> to the list of cloneable types.</p></td></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>Added <code>FileHandle</code> to the list of transferable types.</p></td></tr>
 <tr><td>v10.5.0</td>
 <td><p><span>Added in: v10.5.0</span></p></td></tr>
@@ -510,18 +588,26 @@ the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/St
 <li><code>value</code> may contain typed arrays, both using <code>ArrayBuffer</code>s
 and <code>SharedArrayBuffer</code>s.</li>
 <li><code>value</code> may contain <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module"><code>WebAssembly.Module</code></a> instances.</li>
-<li><code>value</code> may not contain native (C++-backed) objects other than <code>MessagePort</code>s,
-<a href="fs.html#fs_class_filehandle"><code>FileHandle</code></a>s, and <a href="crypto.html#crypto_class_keyobject"><code>KeyObject</code></a>s.</li>
+<li><code>value</code> may not contain native (C++-backed) objects other than:
+<ul>
+<li><a href="fs.html#fs_class_filehandle" class="type">&#x3C;FileHandle></a>s,</li>
+<li><a href="perf_hooks.html#perf_hooks_class_histogram" class="type">&#x3C;Histogram></a>s,</li>
+<li><a href="crypto.html#crypto_class_keyobject" class="type">&#x3C;KeyObject></a>s,</li>
+<li><a href="worker_threads.html#worker_threads_class_messageport" class="type">&#x3C;MessagePort></a>s,</li>
+<li><a href="net.html#net_class_net_blocklist" class="type">&#x3C;net.BlockList></a>s,</li>
+<li><a href="net.html#net_class_net_socketaddress" class="type">&#x3C;net.SocketAddress></a>es,</li>
 </ul>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
+</li>
+</ul>
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
 
-port1.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(message));
+port1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message));
 
 <span class="hljs-keyword">const</span> circularData = {};
-circularData.foo = circularData;
+circularData.<span class="hljs-property">foo</span> = circularData;
 <span class="hljs-comment">// Prints: { foo: [Circular] }</span>
-port2.postMessage(circularData);</code></pre>
+port2.<span class="hljs-title function_">postMessage</span>(circularData);</code></pre>
 <p><code>transferList</code> may be a list of <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a>, <a href="#worker_threads_class_messageport"><code>MessagePort</code></a> and
 <a href="fs.html#fs_class_filehandle"><code>FileHandle</code></a> objects.
 After transferring, they will not be usable on the sending side of the channel
@@ -532,27 +618,27 @@ not supported.</p>
 from either thread. They cannot be listed in <code>transferList</code>.</p>
 <p><code>value</code> may still contain <code>ArrayBuffer</code> instances that are not in
 <code>transferList</code>; in that case, the underlying memory is copied rather than moved.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { MessageChannel } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
-<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> MessageChannel();
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">MessageChannel</span> } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<span class="hljs-keyword">const</span> { port1, port2 } = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
 
-port1.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-built_in">console</span>.log(message));
+port1.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">message</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(message));
 
-<span class="hljs-keyword">const</span> uint8Array = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>([ <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span> ]);
+<span class="hljs-keyword">const</span> uint8Array = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>([ <span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span> ]);
 <span class="hljs-comment">// This posts a copy of `uint8Array`:</span>
-port2.postMessage(uint8Array);
+port2.<span class="hljs-title function_">postMessage</span>(uint8Array);
 <span class="hljs-comment">// This does not copy data, but renders `uint8Array` unusable:</span>
-port2.postMessage(uint8Array, [ uint8Array.buffer ]);
+port2.<span class="hljs-title function_">postMessage</span>(uint8Array, [ uint8Array.<span class="hljs-property">buffer</span> ]);
 
 <span class="hljs-comment">// The memory for the `sharedUint8Array` will be accessible from both the</span>
 <span class="hljs-comment">// original and the copy received by `.on('message')`:</span>
-<span class="hljs-keyword">const</span> sharedUint8Array = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(<span class="hljs-keyword">new</span> SharedArrayBuffer(<span class="hljs-number">4</span>));
-port2.postMessage(sharedUint8Array);
+<span class="hljs-keyword">const</span> sharedUint8Array = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(<span class="hljs-keyword">new</span> <span class="hljs-title class_">SharedArrayBuffer</span>(<span class="hljs-number">4</span>));
+port2.<span class="hljs-title function_">postMessage</span>(sharedUint8Array);
 
 <span class="hljs-comment">// This transfers a freshly created message port to the receiver.</span>
 <span class="hljs-comment">// This can be used, for example, to create communication channels between</span>
 <span class="hljs-comment">// multiple `Worker` threads that are children of the same parent thread.</span>
-<span class="hljs-keyword">const</span> otherChannel = <span class="hljs-keyword">new</span> MessageChannel();
-port2.postMessage({ <span class="hljs-attr">port</span>: otherChannel.port1 }, [ otherChannel.port1 ]);</code></pre>
+<span class="hljs-keyword">const</span> otherChannel = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+port2.<span class="hljs-title function_">postMessage</span>({ <span class="hljs-attr">port</span>: otherChannel.<span class="hljs-property">port1</span> }, [ otherChannel.<span class="hljs-property">port1</span> ]);</code></pre>
 <p>Because the object cloning uses the structured clone algorithm,
 non-enumerable properties, property accessors, and object prototypes are
 not preserved. In particular, <a href="buffer.html"><code>Buffer</code></a> objects will be read as
@@ -561,7 +647,7 @@ plain <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference
 posting without having side effects.</p>
 <p>For more information on the serialization and deserialization mechanisms
 behind this API, see the <a href="v8.html#v8_serialization_api">serialization API of the <code>v8</code> module</a>.</p>
-<h4>Considerations when transferring TypedArrays and Buffers<span><a class="mark" href="#worker_threads_considerations_when_transferring_typedarrays_and_buffers" id="worker_threads_considerations_when_transferring_typedarrays_and_buffers">#</a></span></h4>
+<h5>Considerations when transferring TypedArrays and Buffers<span><a class="mark" href="#worker_threads_considerations_when_transferring_typedarrays_and_buffers" id="worker_threads_considerations_when_transferring_typedarrays_and_buffers">#</a></span></h5>
 <p>All <code>TypedArray</code> and <code>Buffer</code> instances are views over an underlying
 <code>ArrayBuffer</code>. That is, it is the <code>ArrayBuffer</code> that actually stores
 the raw data while the <code>TypedArray</code> and <code>Buffer</code> objects provide a
@@ -570,16 +656,16 @@ for multiple views to be created over the same <code>ArrayBuffer</code> instance
 Great care must be taken when using a transfer list to transfer an
 <code>ArrayBuffer</code> as doing so will cause all <code>TypedArray</code> and <code>Buffer</code>
 instances that share that same <code>ArrayBuffer</code> to become unusable.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-built_in">ArrayBuffer</span>(<span class="hljs-number">10</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> ab = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayBuffer</span>(<span class="hljs-number">10</span>);
 
-<span class="hljs-keyword">const</span> u1 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint8Array</span>(ab);
-<span class="hljs-keyword">const</span> u2 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Uint16Array</span>(ab);
+<span class="hljs-keyword">const</span> u1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>8<span class="hljs-built_in">Array</span>(ab);
+<span class="hljs-keyword">const</span> u2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Uint</span>16<span class="hljs-built_in">Array</span>(ab);
 
-<span class="hljs-built_in">console</span>.log(u2.length);  <span class="hljs-comment">// prints 5</span>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u2.<span class="hljs-property">length</span>);  <span class="hljs-comment">// prints 5</span>
 
-port.postMessage(u1, [u1.buffer]);
+port.<span class="hljs-title function_">postMessage</span>(u1, [u1.<span class="hljs-property">buffer</span>]);
 
-<span class="hljs-built_in">console</span>.log(u2.length);  <span class="hljs-comment">// prints 0</span></code></pre>
+<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(u2.<span class="hljs-property">length</span>);  <span class="hljs-comment">// prints 0</span></code></pre>
 <p>For <code>Buffer</code> instances, specifically, whether the underlying
 <code>ArrayBuffer</code> can be transferred or cloned depends entirely on how
 instances were created, which often cannot be reliably determined.</p>
@@ -599,7 +685,7 @@ usage and possible security concerns.</p>
 <code>Buffer.alloc()</code> or <code>Buffer.allocUnsafeSlow()</code> can always be
 transferred but doing so will render all other existing views of
 those <code>ArrayBuffer</code>s unusable.</p>
-<h3><code>port.ref()</code><span><a class="mark" href="#worker_threads_port_ref" id="worker_threads_port_ref">#</a></span></h3>
+<h4><code>port.ref()</code><span><a class="mark" href="#worker_threads_port_ref" id="worker_threads_port_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -609,7 +695,7 @@ behavior). If the port is <code>ref()</code>ed, calling <code>ref()</code> again
 <p>If listeners are attached or removed using <code>.on('message')</code>, the port will
 be <code>ref()</code>ed and <code>unref()</code>ed automatically depending on whether
 listeners for the event exist.</p>
-<h3><code>port.start()</code><span><a class="mark" href="#worker_threads_port_start" id="worker_threads_port_start">#</a></span></h3>
+<h4><code>port.start()</code><span><a class="mark" href="#worker_threads_port_start" id="worker_threads_port_start">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -621,7 +707,7 @@ it is only useful for ignoring messages when no event listener is present.
 Node.js also diverges in its handling of <code>.onmessage</code>. Setting it will
 automatically call <code>.start()</code>, but unsetting it will let messages queue up
 until a new handler is set or the port is discarded.</p>
-<h3><code>port.unref()</code><span><a class="mark" href="#worker_threads_port_unref" id="worker_threads_port_unref">#</a></span></h3>
+<h4><code>port.unref()</code><span><a class="mark" href="#worker_threads_port_unref" id="worker_threads_port_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -631,7 +717,7 @@ active handle in the event system. If the port is already <code>unref()</code>ed
 <p>If listeners are attached or removed using <code>.on('message')</code>, the port will
 be <code>ref()</code>ed and <code>unref()</code>ed automatically depending on whether
 listeners for the event exist.</p>
-<h2>Class: <code>Worker</code><span><a class="mark" href="#worker_threads_class_worker" id="worker_threads_class_worker">#</a></span></h2>
+</section><section><h3>Class: <code>Worker</code><span><a class="mark" href="#worker_threads_class_worker" id="worker_threads_class_worker">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -682,37 +768,41 @@ and what kind of JavaScript values can be successfully transported through
 the thread barrier.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> assert = <span class="hljs-built_in">require</span>(<span class="hljs-string">'assert'</span>);
 <span class="hljs-keyword">const</span> {
-  Worker, MessageChannel, MessagePort, isMainThread, parentPort
+  <span class="hljs-title class_">Worker</span>, <span class="hljs-title class_">MessageChannel</span>, <span class="hljs-title class_">MessagePort</span>, isMainThread, parentPort
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename);
-  <span class="hljs-keyword">const</span> subChannel = <span class="hljs-keyword">new</span> MessageChannel();
-  worker.postMessage({ <span class="hljs-attr">hereIsYourPort</span>: subChannel.port1 }, [subChannel.port1]);
-  subChannel.port2.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
-    <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'received:'</span>, value);
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
+  <span class="hljs-keyword">const</span> subChannel = <span class="hljs-keyword">new</span> <span class="hljs-title class_">MessageChannel</span>();
+  worker.<span class="hljs-title function_">postMessage</span>({ <span class="hljs-attr">hereIsYourPort</span>: subChannel.<span class="hljs-property">port1</span> }, [subChannel.<span class="hljs-property">port1</span>]);
+  subChannel.<span class="hljs-property">port2</span>.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'received:'</span>, value);
   });
 } <span class="hljs-keyword">else</span> {
-  parentPort.once(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
-    assert(value.hereIsYourPort <span class="hljs-keyword">instanceof</span> MessagePort);
-    value.hereIsYourPort.postMessage(<span class="hljs-string">'the worker is sending this'</span>);
-    value.hereIsYourPort.close();
+  parentPort.<span class="hljs-title function_">once</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">(<span class="hljs-params">value</span>) =></span> {
+    <span class="hljs-title function_">assert</span>(value.<span class="hljs-property">hereIsYourPort</span> <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">MessagePort</span>);
+    value.<span class="hljs-property">hereIsYourPort</span>.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'the worker is sending this'</span>);
+    value.<span class="hljs-property">hereIsYourPort</span>.<span class="hljs-title function_">close</span>();
   });
 }</code></pre>
-<h3><code>new Worker(filename[, options])</code><span><a class="mark" href="#worker_threads_new_worker_filename_options" id="worker_threads_new_worker_filename_options">#</a></span></h3>
+<h4><code>new Worker(filename[, options])</code><span><a class="mark" href="#worker_threads_new_worker_filename_options" id="worker_threads_new_worker_filename_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.9.0</td>
+<td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>data:</code> protocol.</p></td></tr>
+<tr><td>v14.9.0</td>
+<td><p>The <code>trackUnmanagedFds</code> option was set to <code>true</code> by default.</p></td></tr>
+<tr><td>v14.6.0</td>
 <td><p>The <code>trackUnmanagedFds</code> option was introduced.</p></td></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v14.0.0</td>
 <td><p>The <code>transferList</code> option was introduced.</p></td></tr>
-<tr><td>v12.17.0</td>
+<tr><td>v13.12.0</td>
 <td><p>The <code>filename</code> parameter can be a WHATWG <code>URL</code> object using <code>file:</code> protocol.</p></td></tr>
-<tr><td>v12.16.0</td>
-<td><p>The <code>resourceLimits</code> option was introduced.</p></td></tr>
-<tr><td>v12.16.0</td>
+<tr><td>v13.4.0, v12.16.0</td>
 <td><p>The <code>argv</code> option was introduced.</p></td></tr>
+<tr><td>v13.2.0, v12.16.0</td>
+<td><p>The <code>resourceLimits</code> option was introduced.</p></td></tr>
 <tr><td>v10.5.0</td>
 <td><p><span>Added in: v10.5.0</span></p></td></tr>
 </tbody></table>
@@ -722,7 +812,9 @@ the thread barrier.</p>
 <li><code>filename</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="url.html#url_the_whatwg_url_api" class="type">&#x3C;URL></a> The path to the Worker’s main script or module. Must
 be either an absolute path or a relative path (i.e. relative to the
 current working directory) starting with <code>./</code> or <code>../</code>, or a WHATWG <code>URL</code>
-object using <code>file:</code> protocol.
+object using <code>file:</code> or <code>data:</code> protocol.
+When using a <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs"><code>data:</code> URL</a>, the data is interpreted based on MIME type using
+the <a href="esm.html#esm_data_imports">ECMAScript module loader</a>.
 If <code>options.eval</code> is <code>true</code>, this is a string containing JavaScript code
 rather than a path.</li>
 <li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -784,7 +876,7 @@ Small values may lead to unusable Worker instances. <strong>Default:</strong> <c
 </ul>
 </li>
 </ul>
-<h3>Event: <code>'error'</code><span><a class="mark" href="#worker_threads_event_error" id="worker_threads_event_error">#</a></span></h3>
+<h4>Event: <code>'error'</code><span><a class="mark" href="#worker_threads_event_error" id="worker_threads_event_error">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -793,7 +885,7 @@ Small values may lead to unusable Worker instances. <strong>Default:</strong> <c
 </ul>
 <p>The <code>'error'</code> event is emitted if the worker thread throws an uncaught
 exception. In that case, the worker will be terminated.</p>
-<h3>Event: <code>'exit'</code><span><a class="mark" href="#worker_threads_event_exit" id="worker_threads_event_exit">#</a></span></h3>
+<h4>Event: <code>'exit'</code><span><a class="mark" href="#worker_threads_event_exit" id="worker_threads_event_exit">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -805,7 +897,7 @@ exited by calling <a href="process.html#process_process_exit_code"><code>process
 passed exit code. If the worker was terminated, the <code>exitCode</code> parameter will
 be <code>1</code>.</p>
 <p>This is the final event emitted by any <code>Worker</code> instance.</p>
-<h3>Event: <code>'message'</code><span><a class="mark" href="#worker_threads_event_message_1" id="worker_threads_event_message_1">#</a></span></h3>
+<h4>Event: <code>'message'</code><span><a class="mark" href="#worker_threads_event_message_1" id="worker_threads_event_message_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -817,23 +909,23 @@ be <code>1</code>.</p>
 See the <a href="#worker_threads_event_message"><code>port.on('message')</code></a> event for more details.</p>
 <p>All messages sent from the worker thread will be emitted before the
 <a href="#worker_threads_event_exit"><code>'exit'</code> event</a> is emitted on the <code>Worker</code> object.</p>
-<h3>Event: <code>'messageerror'</code><span><a class="mark" href="#worker_threads_event_messageerror_1" id="worker_threads_event_messageerror_1">#</a></span></h3>
+<h4>Event: <code>'messageerror'</code><span><a class="mark" href="#worker_threads_event_messageerror_1" id="worker_threads_event_messageerror_1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.19.0</span>
+<span>Added in: v14.5.0</span>
 </div>
 <ul>
 <li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> An Error object</li>
 </ul>
 <p>The <code>'messageerror'</code> event is emitted when deserializing a message failed.</p>
-<h3>Event: <code>'online'</code><span><a class="mark" href="#worker_threads_event_online" id="worker_threads_event_online">#</a></span></h3>
+<h4>Event: <code>'online'</code><span><a class="mark" href="#worker_threads_event_online" id="worker_threads_event_online">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
 <p>The <code>'online'</code> event is emitted when the worker thread has started executing
 JavaScript code.</p>
-<h3><code>worker.getHeapSnapshot()</code><span><a class="mark" href="#worker_threads_worker_getheapsnapshot" id="worker_threads_worker_getheapsnapshot">#</a></span></h3>
+<h4><code>worker.getHeapSnapshot()</code><span><a class="mark" href="#worker_threads_worker_getheapsnapshot" id="worker_threads_worker_getheapsnapshot">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.17.0</span>
+<span>Added in: v13.9.0</span>
 </div>
 <ul>
 <li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a> A promise for a Readable Stream containing
@@ -844,21 +936,21 @@ See <a href="v8.html#v8_v8_getheapsnapshot"><code>v8.getHeapSnapshot()</code></a
 <p>If the Worker thread is no longer running, which may occur before the
 <a href="#worker_threads_event_exit"><code>'exit'</code> event</a> is emitted, the returned <code>Promise</code> will be rejected
 immediately with an <a href="errors.html#ERR_WORKER_NOT_RUNNING"><code>ERR_WORKER_NOT_RUNNING</code></a> error.</p>
-<h3><code>worker.performance</code><span><a class="mark" href="#worker_threads_worker_performance" id="worker_threads_worker_performance">#</a></span></h3>
+<h4><code>worker.performance</code><span><a class="mark" href="#worker_threads_worker_performance" id="worker_threads_worker_performance">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.22.0</span>
+<span>Added in: v14.17.0</span>
 </div>
 <p>An object that can be used to query performance information from a worker
-instance. Similar to <a href="#perf_hooks.md#perf_hooks_perf_hooks_performance"><code>perf_hooks.performance</code></a>.</p>
-<h4><code>performance.eventLoopUtilization([utilization1[, utilization2]])</code><span><a class="mark" href="#worker_threads_performance_eventlooputilization_utilization1_utilization2" id="worker_threads_performance_eventlooputilization_utilization1_utilization2">#</a></span></h4>
+instance. Similar to <a href="perf_hooks.html#perf_hooks_perf_hooks_performance"><code>perf_hooks.performance</code></a>.</p>
+<h5><code>performance.eventLoopUtilization([utilization1[, utilization2]])</code><span><a class="mark" href="#worker_threads_performance_eventlooputilization_utilization1_utilization2" id="worker_threads_performance_eventlooputilization_utilization1_utilization2">#</a></span></h5>
 <div class="api_metadata">
-<span>Added in: v12.22.0</span>
+<span>Added in: v14.17.0</span>
 </div>
 <ul>
 <li><code>utilization1</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to
-  <code>eventLoopUtilization()</code>.</li>
+<code>eventLoopUtilization()</code>.</li>
 <li><code>utilization2</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> The result of a previous call to
-  <code>eventLoopUtilization()</code> prior to <code>utilization1</code>.</li>
+<code>eventLoopUtilization()</code> prior to <code>utilization1</code>.</li>
 <li>Returns <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
 <ul>
 <li><code>idle</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a></li>
@@ -867,7 +959,7 @@ instance. Similar to <a href="#perf_hooks.md#perf_hooks_perf_hooks_performance">
 </ul>
 </li>
 </ul>
-<p>The same call as <a href="perf_hooks.md#perf_hooks_performance_eventlooputilization_utilization1_utilization2"><code>perf_hooks</code> <code>eventLoopUtilization()</code></a>, except the values
+<p>The same call as <a href="perf_hooks.html#perf_hooks_performance_eventlooputilization_utilization1_utilization2"><code>perf_hooks</code> <code>eventLoopUtilization()</code></a>, except the values
 of the worker instance are returned.</p>
 <p>One difference is that, unlike the main thread, bootstrapping within a worker
 is done within the event loop. So the event loop utilization will be
@@ -876,28 +968,28 @@ immediately available once the worker's script begins execution.</p>
 stuck in bootstrap. The following examples shows how the worker's entire
 lifetime will never accumulate any <code>idle</code> time, but is still be able to process
 messages.</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> { Worker, isMainThread, parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+<pre><code class="language-js"><span class="hljs-keyword">const</span> { <span class="hljs-title class_">Worker</span>, isMainThread, parentPort } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
 
 <span class="hljs-keyword">if</span> (isMainThread) {
-  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> Worker(__filename);
+  <span class="hljs-keyword">const</span> worker = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
   <span class="hljs-built_in">setInterval</span>(<span class="hljs-function">() =></span> {
-    worker.postMessage(<span class="hljs-string">'hi'</span>);
-    <span class="hljs-built_in">console</span>.log(worker.performance.eventLoopUtilization());
-  }, <span class="hljs-number">100</span>).unref();
+    worker.<span class="hljs-title function_">postMessage</span>(<span class="hljs-string">'hi'</span>);
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(worker.<span class="hljs-property">performance</span>.<span class="hljs-title function_">eventLoopUtilization</span>());
+  }, <span class="hljs-number">100</span>).<span class="hljs-title function_">unref</span>();
   <span class="hljs-keyword">return</span>;
 }
 
-parentPort.on(<span class="hljs-string">'message'</span>, <span class="hljs-function">() =></span> <span class="hljs-built_in">console</span>.log(<span class="hljs-string">'msg'</span>)).unref();
-(<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">r</span>(<span class="hljs-params">n</span>) </span>{
+parentPort.<span class="hljs-title function_">on</span>(<span class="hljs-string">'message'</span>, <span class="hljs-function">() =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'msg'</span>)).<span class="hljs-title function_">unref</span>();
+(<span class="hljs-keyword">function</span> <span class="hljs-title function_">r</span>(<span class="hljs-params">n</span>) {
   <span class="hljs-keyword">if</span> (--n &#x3C; <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span>;
-  <span class="hljs-keyword">const</span> t = <span class="hljs-built_in">Date</span>.now();
-  <span class="hljs-keyword">while</span> (<span class="hljs-built_in">Date</span>.now() - t &#x3C; <span class="hljs-number">300</span>);
-  setImmediate(r, n);
+  <span class="hljs-keyword">const</span> t = <span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>();
+  <span class="hljs-keyword">while</span> (<span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>() - t &#x3C; <span class="hljs-number">300</span>);
+  <span class="hljs-title function_">setImmediate</span>(r, n);
 })(<span class="hljs-number">10</span>);</code></pre>
 <p>The event loop utilization of a worker is available only after the <a href="#worker_threads_event_online"><code>'online'</code>
 event</a> emitted, and if called before this, or after the <a href="#worker_threads_event_exit"><code>'exit'</code>
 event</a>, then all properties have the value of <code>0</code>.</p>
-<h3><code>worker.postMessage(value[, transferList])</code><span><a class="mark" href="#worker_threads_worker_postmessage_value_transferlist" id="worker_threads_worker_postmessage_value_transferlist">#</a></span></h3>
+<h4><code>worker.postMessage(value[, transferList])</code><span><a class="mark" href="#worker_threads_worker_postmessage_value_transferlist" id="worker_threads_worker_postmessage_value_transferlist">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -908,7 +1000,7 @@ event</a>, then all properties have the value of <code>0</code>.</p>
 <p>Send a message to the worker that will be received via
 <a href="#worker_threads_event_message"><code>require('worker_threads').parentPort.on('message')</code></a>.
 See <a href="#worker_threads_port_postmessage_value_transferlist"><code>port.postMessage()</code></a> for more details.</p>
-<h3><code>worker.ref()</code><span><a class="mark" href="#worker_threads_worker_ref" id="worker_threads_worker_ref">#</a></span></h3>
+<h4><code>worker.ref()</code><span><a class="mark" href="#worker_threads_worker_ref" id="worker_threads_worker_ref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -916,9 +1008,9 @@ See <a href="#worker_threads_port_postmessage_value_transferlist"><code>port.pos
 <em>not</em> let the program exit if it's the only active handle left (the default
 behavior). If the worker is <code>ref()</code>ed, calling <code>ref()</code> again will have
 no effect.</p>
-<h3><code>worker.resourceLimits</code><span><a class="mark" href="#worker_threads_worker_resourcelimits_1" id="worker_threads_worker_resourcelimits_1">#</a></span></h3>
+<h4><code>worker.resourceLimits</code><span><a class="mark" href="#worker_threads_worker_resourcelimits_1" id="worker_threads_worker_resourcelimits_1">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v12.16.0</span>
+<span>Added in: v13.2.0, v12.16.0</span>
 </div>
 <ul>
 <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
@@ -934,7 +1026,7 @@ no effect.</p>
 If the <code>resourceLimits</code> option was passed to the <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor,
 this matches its values.</p>
 <p>If the worker has stopped, the return value is an empty object.</p>
-<h3><code>worker.stderr</code><span><a class="mark" href="#worker_threads_worker_stderr" id="worker_threads_worker_stderr">#</a></span></h3>
+<h4><code>worker.stderr</code><span><a class="mark" href="#worker_threads_worker_stderr" id="worker_threads_worker_stderr">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -945,7 +1037,7 @@ this matches its values.</p>
 inside the worker thread. If <code>stderr: true</code> was not passed to the
 <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor, then data will be piped to the parent thread's
 <a href="process.html#process_process_stderr"><code>process.stderr</code></a> stream.</p>
-<h3><code>worker.stdin</code><span><a class="mark" href="#worker_threads_worker_stdin" id="worker_threads_worker_stdin">#</a></span></h3>
+<h4><code>worker.stdin</code><span><a class="mark" href="#worker_threads_worker_stdin" id="worker_threads_worker_stdin">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -955,7 +1047,7 @@ inside the worker thread. If <code>stderr: true</code> was not passed to the
 <p>If <code>stdin: true</code> was passed to the <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor, this is a
 writable stream. The data written to this stream will be made available in
 the worker thread as <a href="process.html#process_process_stdin"><code>process.stdin</code></a>.</p>
-<h3><code>worker.stdout</code><span><a class="mark" href="#worker_threads_worker_stdout" id="worker_threads_worker_stdout">#</a></span></h3>
+<h4><code>worker.stdout</code><span><a class="mark" href="#worker_threads_worker_stdout" id="worker_threads_worker_stdout">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -966,7 +1058,7 @@ the worker thread as <a href="process.html#process_process_stdin"><code>process.
 inside the worker thread. If <code>stdout: true</code> was not passed to the
 <a href="#worker_threads_class_worker"><code>Worker</code></a> constructor, then data will be piped to the parent thread's
 <a href="process.html#process_process_stdout"><code>process.stdout</code></a> stream.</p>
-<h3><code>worker.terminate()</code><span><a class="mark" href="#worker_threads_worker_terminate" id="worker_threads_worker_terminate">#</a></span></h3>
+<h4><code>worker.terminate()</code><span><a class="mark" href="#worker_threads_worker_terminate" id="worker_threads_worker_terminate">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -984,7 +1076,7 @@ inside the worker thread. If <code>stdout: true</code> was not passed to the
 <p>Stop all JavaScript execution in the worker thread as soon as possible.
 Returns a Promise for the exit code that is fulfilled when the
 <a href="#worker_threads_event_exit"><code>'exit'</code> event</a> is emitted.</p>
-<h3><code>worker.threadId</code><span><a class="mark" href="#worker_threads_worker_threadid_1" id="worker_threads_worker_threadid_1">#</a></span></h3>
+<h4><code>worker.threadId</code><span><a class="mark" href="#worker_threads_worker_threadid_1" id="worker_threads_worker_threadid_1">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
@@ -994,16 +1086,91 @@ Returns a Promise for the exit code that is fulfilled when the
 <p>An integer identifier for the referenced thread. Inside the worker thread,
 it is available as <a href="#worker_threads_worker_threadid"><code>require('worker_threads').threadId</code></a>.
 This value is unique for each <code>Worker</code> instance inside a single process.</p>
-<h3><code>worker.unref()</code><span><a class="mark" href="#worker_threads_worker_unref" id="worker_threads_worker_unref">#</a></span></h3>
+<h4><code>worker.unref()</code><span><a class="mark" href="#worker_threads_worker_unref" id="worker_threads_worker_unref">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.5.0</span>
 </div>
 <p>Calling <code>unref()</code> on a worker will allow the thread to exit if this is the only
 active handle in the event system. If the worker is already <code>unref()</code>ed calling
 <code>unref()</code> again will have no effect.</p>
+</section><section><h3>Notes<span><a class="mark" href="#worker_threads_notes" id="worker_threads_notes">#</a></span></h3>
+<h4>Synchronous blocking of stdio<span><a class="mark" href="#worker_threads_synchronous_blocking_of_stdio" id="worker_threads_synchronous_blocking_of_stdio">#</a></span></h4>
+<p><code>Worker</code>s utilize message passing via <a href="worker_threads.html#worker_threads_class_messageport" class="type">&#x3C;MessagePort></a> to implement interactions
+with <code>stdio</code>. This means that <code>stdio</code> output originating from a <code>Worker</code> can
+get blocked by synchronous code on the receiving end that is blocking the
+Node.js event loop.</p>
+
+<pre><input class="js-flavor-selector" type="checkbox" checked aria-label="Show modern ES modules syntax"><code class="language-js mjs"><span class="hljs-keyword">import</span> {
+  <span class="hljs-title class_">Worker</span>,
+  isMainThread,
+} <span class="hljs-keyword">from</span> <span class="hljs-string">'worker_threads'</span>;
+
+<span class="hljs-keyword">if</span> (isMainThread) {
+  <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(<span class="hljs-keyword">new</span> <span class="hljs-title function_">URL</span>(<span class="hljs-keyword">import</span>.<span class="hljs-property">meta</span>.<span class="hljs-property">url</span>));
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; <span class="hljs-number">1e10</span>; n++) {}
+} <span class="hljs-keyword">else</span> {
+  <span class="hljs-comment">// This output will be blocked by the for loop in the main thread.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo'</span>);
+}</code><code class="language-js cjs"><span class="hljs-meta">'use strict'</span>;
+
+<span class="hljs-keyword">const</span> {
+  <span class="hljs-title class_">Worker</span>,
+  isMainThread,
+} = <span class="hljs-built_in">require</span>(<span class="hljs-string">'worker_threads'</span>);
+
+<span class="hljs-keyword">if</span> (isMainThread) {
+  <span class="hljs-keyword">new</span> <span class="hljs-title class_">Worker</span>(__filename);
+  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> n = <span class="hljs-number">0</span>; n &#x3C; <span class="hljs-number">1e10</span>; n++) {}
+} <span class="hljs-keyword">else</span> {
+  <span class="hljs-comment">// This output will be blocked by the for loop in the main thread.</span>
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'foo'</span>);
+}</code></pre>
+<h4>Launching worker threads from preload scripts<span><a class="mark" href="#worker_threads_launching_worker_threads_from_preload_scripts" id="worker_threads_launching_worker_threads_from_preload_scripts">#</a></span></h4>
+<p>Take care when launching worker threads from preload scripts (scripts loaded
+and run using the <code>-r</code> command line flag). Unless the <code>execArgv</code> option is
+explicitly set, new Worker threads automatically inherit the command line flags
+from the running process and will preload the same preload scripts as the main
+thread. If the preload script unconditionally launches a worker thread, every
+thread spawned will spawn another until the application crashes.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/worker_threads.json b/doc/api/worker_threads.json
index 981ecb29bc9b7c4dafa35c1d4fbd234aad66a9e9..346c81794f40b1c6fd5637590849f66ba9bd3b8a 100644
--- a/doc/api/worker_threads.json
+++ b/doc/api/worker_threads.json
@@ -8,7 +8,152 @@
       "introduced_in": "v10.5.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/worker_threads.js\">lib/worker_threads.js</a></p>\n<p>The <code>worker_threads</code> module enables the use of threads that execute JavaScript\nin parallel. To access it:</p>\n<pre><code class=\"language-js\">const worker = require('worker_threads');\n</code></pre>\n<p>Workers (threads) are useful for performing CPU-intensive JavaScript operations.\nThey will not help much with I/O-intensive work. Node.js’s built-in asynchronous\nI/O operations are more efficient than Workers can be.</p>\n<p>Unlike <code>child_process</code> or <code>cluster</code>, <code>worker_threads</code> can share memory. They do\nso by transferring <code>ArrayBuffer</code> instances or sharing <code>SharedArrayBuffer</code>\ninstances.</p>\n<pre><code class=\"language-js\">const {\n  Worker, isMainThread, parentPort, workerData\n} = require('worker_threads');\n\nif (isMainThread) {\n  module.exports = function parseJSAsync(script) {\n    return new Promise((resolve, reject) => {\n      const worker = new Worker(__filename, {\n        workerData: script\n      });\n      worker.on('message', resolve);\n      worker.on('error', reject);\n      worker.on('exit', (code) => {\n        if (code !== 0)\n          reject(new Error(`Worker stopped with exit code ${code}`));\n      });\n    });\n  };\n} else {\n  const { parse } = require('some-js-parsing-library');\n  const script = workerData;\n  parentPort.postMessage(parse(script));\n}\n</code></pre>\n<p>The above example spawns a Worker thread for each <code>parse()</code> call. In actual\npractice, use a pool of Workers instead for these kinds of tasks. Otherwise, the\noverhead of creating Workers would likely exceed their benefit.</p>\n<p>When implementing a worker pool, use the <a href=\"async_hooks.html#async_hooks_class_asyncresource\"><code>AsyncResource</code></a> API to inform\ndiagnostic tools (e.g. in order to provide asynchronous stack traces) about the\ncorrelation between tasks and their outcomes. See\n<a href=\"async_hooks.html#async-resource-worker-pool\">\"Using <code>AsyncResource</code> for a <code>Worker</code> thread pool\"</a>\nin the <code>async_hooks</code> documentation for an example implementation.</p>\n<p>Worker threads inherit non-process-specific options by default. Refer to\n<a href=\"#worker_threads_new_worker_filename_options\"><code>Worker constructor options</code></a> to know how to customize worker thread options,\nspecifically <code>argv</code> and <code>execArgv</code> options.</p>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/worker_threads.js\">lib/worker_threads.js</a></p>\n<p>The <code>worker_threads</code> module enables the use of threads that execute JavaScript\nin parallel. To access it:</p>\n<pre><code class=\"language-js\">const worker = require('worker_threads');\n</code></pre>\n<p>Workers (threads) are useful for performing CPU-intensive JavaScript operations.\nThey will not help much with I/O-intensive work. Node.js’s built-in asynchronous\nI/O operations are more efficient than Workers can be.</p>\n<p>Unlike <code>child_process</code> or <code>cluster</code>, <code>worker_threads</code> can share memory. They do\nso by transferring <code>ArrayBuffer</code> instances or sharing <code>SharedArrayBuffer</code>\ninstances.</p>\n<pre><code class=\"language-js\">const {\n  Worker, isMainThread, parentPort, workerData\n} = require('worker_threads');\n\nif (isMainThread) {\n  module.exports = function parseJSAsync(script) {\n    return new Promise((resolve, reject) => {\n      const worker = new Worker(__filename, {\n        workerData: script\n      });\n      worker.on('message', resolve);\n      worker.on('error', reject);\n      worker.on('exit', (code) => {\n        if (code !== 0)\n          reject(new Error(`Worker stopped with exit code ${code}`));\n      });\n    });\n  };\n} else {\n  const { parse } = require('some-js-parsing-library');\n  const script = workerData;\n  parentPort.postMessage(parse(script));\n}\n</code></pre>\n<p>The above example spawns a Worker thread for each <code>parse()</code> call. In actual\npractice, use a pool of Workers instead for these kinds of tasks. Otherwise, the\noverhead of creating Workers would likely exceed their benefit.</p>\n<p>When implementing a worker pool, use the <a href=\"async_hooks.html#async_hooks_class_asyncresource\"><code>AsyncResource</code></a> API to inform\ndiagnostic tools (e.g. in order to provide asynchronous stack traces) about the\ncorrelation between tasks and their outcomes. See\n<a href=\"async_hooks.html#async-resource-worker-pool\">\"Using <code>AsyncResource</code> for a <code>Worker</code> thread pool\"</a>\nin the <code>async_hooks</code> documentation for an example implementation.</p>\n<p>Worker threads inherit non-process-specific options by default. Refer to\n<a href=\"#worker_threads_new_worker_filename_options\"><code>Worker constructor options</code></a> to know how to customize worker thread options,\nspecifically <code>argv</code> and <code>execArgv</code> options.</p>",
+      "methods": [
+        {
+          "textRaw": "`worker.getEnvironmentData(key)`",
+          "type": "method",
+          "name": "getEnvironmentData",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {any}",
+                "name": "return",
+                "type": "any"
+              },
+              "params": [
+                {
+                  "textRaw": "`key` {any} Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.",
+                  "name": "key",
+                  "type": "any",
+                  "desc": "Any arbitrary, cloneable JavaScript value that can be used as a {Map} key."
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Within a worker thread, <code>worker.getEnvironmentData()</code> returns a clone\nof data passed to the spawning thread's <code>worker.setEnvironmentData()</code>.\nEvery new <code>Worker</code> receives its own copy of the environment data\nautomatically.</p>\n<pre><code class=\"language-js\">const {\n  Worker,\n  isMainThread,\n  setEnvironmentData,\n  getEnvironmentData,\n} = require('worker_threads');\n\nif (isMainThread) {\n  setEnvironmentData('Hello', 'World!');\n  const worker = new Worker(__filename);\n} else {\n  console.log(getEnvironmentData('Hello'));  // Prints 'World!'.\n}\n</code></pre>"
+        },
+        {
+          "textRaw": "`worker.markAsUntransferable(object)`",
+          "type": "method",
+          "name": "markAsUntransferable",
+          "meta": {
+            "added": [
+              "v14.5.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "params": []
+            }
+          ],
+          "desc": "<p>Mark an object as not transferable. If <code>object</code> occurs in the transfer list of\na <a href=\"#worker_threads_port_postmessage_value_transferlist\"><code>port.postMessage()</code></a> call, it will be ignored.</p>\n<p>In particular, this makes sense for objects that can be cloned, rather than\ntransferred, and which are used by other objects on the sending side.\nFor example, Node.js marks the <code>ArrayBuffer</code>s it uses for its\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer</code> pool</a> with this.</p>\n<p>This operation cannot be undone.</p>\n<pre><code class=\"language-js\">const { MessageChannel, markAsUntransferable } = require('worker_threads');\n\nconst pooledBuffer = new ArrayBuffer(8);\nconst typedArray1 = new Uint8Array(pooledBuffer);\nconst typedArray2 = new Float64Array(pooledBuffer);\n\nmarkAsUntransferable(pooledBuffer);\n\nconst { port1 } = new MessageChannel();\nport1.postMessage(typedArray1, [ typedArray1.buffer ]);\n\n// The following line prints the contents of typedArray1 -- it still owns\n// its memory and has been cloned, not transferred. Without\n// `markAsUntransferable()`, this would print an empty Uint8Array.\n// typedArray2 is intact as well.\nconsole.log(typedArray1);\nconsole.log(typedArray2);\n</code></pre>\n<p>There is no equivalent to this API in browsers.</p>"
+        },
+        {
+          "textRaw": "`worker.moveMessagePortToContext(port, contextifiedSandbox)`",
+          "type": "method",
+          "name": "moveMessagePortToContext",
+          "meta": {
+            "added": [
+              "v11.13.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {MessagePort}",
+                "name": "return",
+                "type": "MessagePort"
+              },
+              "params": [
+                {
+                  "textRaw": "`port` {MessagePort} The message port which will be transferred.",
+                  "name": "port",
+                  "type": "MessagePort",
+                  "desc": "The message port which will be transferred."
+                },
+                {
+                  "textRaw": "`contextifiedSandbox` {Object} A [contextified][] object as returned by the `vm.createContext()` method.",
+                  "name": "contextifiedSandbox",
+                  "type": "Object",
+                  "desc": "A [contextified][] object as returned by the `vm.createContext()` method."
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Transfer a <code>MessagePort</code> to a different <a href=\"vm.html\"><code>vm</code></a> Context. The original <code>port</code>\nobject will be rendered unusable, and the returned <code>MessagePort</code> instance will\ntake its place.</p>\n<p>The returned <code>MessagePort</code> will be an object in the target context, and will\ninherit from its global <code>Object</code> class. Objects passed to the\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage\"><code>port.onmessage()</code></a> listener will also be created in the target context\nand inherit from its global <code>Object</code> class.</p>\n<p>However, the created <code>MessagePort</code> will no longer inherit from\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/API/EventTarget\"><code>EventTarget</code></a>, and only <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage\"><code>port.onmessage()</code></a> can be used to receive\nevents using it.</p>"
+        },
+        {
+          "textRaw": "`worker.receiveMessageOnPort(port)`",
+          "type": "method",
+          "name": "receiveMessageOnPort",
+          "meta": {
+            "added": [
+              "v12.3.0"
+            ],
+            "changes": []
+          },
+          "signatures": [
+            {
+              "return": {
+                "textRaw": "Returns: {Object|undefined}",
+                "name": "return",
+                "type": "Object|undefined"
+              },
+              "params": [
+                {
+                  "textRaw": "`port` {MessagePort}",
+                  "name": "port",
+                  "type": "MessagePort"
+                }
+              ]
+            }
+          ],
+          "desc": "<p>Receive a single message from a given <code>MessagePort</code>. If no message is available,\n<code>undefined</code> is returned, otherwise an object with a single <code>message</code> property\nthat contains the message payload, corresponding to the oldest message in the\n<code>MessagePort</code>’s queue.</p>\n<pre><code class=\"language-js\">const { MessageChannel, receiveMessageOnPort } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\nport1.postMessage({ hello: 'world' });\n\nconsole.log(receiveMessageOnPort(port2));\n// Prints: { message: { hello: 'world' } }\nconsole.log(receiveMessageOnPort(port2));\n// Prints: undefined\n</code></pre>\n<p>When this function is used, no <code>'message'</code> event will be emitted and the\n<code>onmessage</code> listener will not be invoked.</p>"
+        },
+        {
+          "textRaw": "`worker.setEnvironmentData(key[, value])`",
+          "type": "method",
+          "name": "setEnvironmentData",
+          "meta": {
+            "added": [
+              "v14.18.0"
+            ],
+            "changes": []
+          },
+          "stability": 1,
+          "stabilityText": "Experimental",
+          "signatures": [
+            {
+              "params": [
+                {
+                  "textRaw": "`key` {any} Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.",
+                  "name": "key",
+                  "type": "any",
+                  "desc": "Any arbitrary, cloneable JavaScript value that can be used as a {Map} key."
+                },
+                {
+                  "textRaw": "`value` {any} Any arbitrary, cloneable JavaScript value that will be cloned and passed automatically to all new `Worker` instances. If `value` is passed as `undefined`, any previously set value for the `key` will be deleted.",
+                  "name": "value",
+                  "type": "any",
+                  "desc": "Any arbitrary, cloneable JavaScript value that will be cloned and passed automatically to all new `Worker` instances. If `value` is passed as `undefined`, any previously set value for the `key` will be deleted."
+                }
+              ]
+            }
+          ],
+          "desc": "<p>The <code>worker.setEnvironmentData()</code> API sets the content of\n<code>worker.getEnvironmentData()</code> in the current thread and all new <code>Worker</code>\ninstances spawned from the current context.</p>"
+        }
+      ],
       "properties": [
         {
           "textRaw": "`isMainThread` {boolean}",
@@ -40,6 +185,7 @@
           "name": "resourceLimits",
           "meta": {
             "added": [
+              "v13.2.0",
               "v12.16.0"
             ],
             "changes": []
@@ -104,88 +250,6 @@
           "desc": "<p>An arbitrary JavaScript value that contains a clone of the data passed\nto this thread’s <code>Worker</code> constructor.</p>\n<p>The data is cloned as if using <a href=\"#worker_threads_port_postmessage_value_transferlist\"><code>postMessage()</code></a>,\naccording to the <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\">HTML structured clone algorithm</a>.</p>\n<pre><code class=\"language-js\">const { Worker, isMainThread, workerData } = require('worker_threads');\n\nif (isMainThread) {\n  const worker = new Worker(__filename, { workerData: 'Hello, world!' });\n} else {\n  console.log(workerData);  // Prints 'Hello, world!'.\n}\n</code></pre>"
         }
       ],
-      "methods": [
-        {
-          "textRaw": "`worker.markAsUntransferable(object)`",
-          "type": "method",
-          "name": "markAsUntransferable",
-          "meta": {
-            "added": [
-              "v12.19.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "params": []
-            }
-          ],
-          "desc": "<p>Mark an object as not transferable. If <code>object</code> occurs in the transfer list of\na <a href=\"#worker_threads_port_postmessage_value_transferlist\"><code>port.postMessage()</code></a> call, it will be ignored.</p>\n<p>In particular, this makes sense for objects that can be cloned, rather than\ntransferred, and which are used by other objects on the sending side.\nFor example, Node.js marks the <code>ArrayBuffer</code>s it uses for its\n<a href=\"buffer.html#buffer_static_method_buffer_allocunsafe_size\"><code>Buffer</code> pool</a> with this.</p>\n<p>This operation cannot be undone.</p>\n<pre><code class=\"language-js\">const { MessageChannel, markAsUntransferable } = require('worker_threads');\n\nconst pooledBuffer = new ArrayBuffer(8);\nconst typedArray1 = new Uint8Array(pooledBuffer);\nconst typedArray2 = new Float64Array(pooledBuffer);\n\nmarkAsUntransferable(pooledBuffer);\n\nconst { port1 } = new MessageChannel();\nport1.postMessage(typedArray1, [ typedArray1.buffer ]);\n\n// The following line prints the contents of typedArray1 -- it still owns\n// its memory and has been cloned, not transferred. Without\n// `markAsUntransferable()`, this would print an empty Uint8Array.\n// typedArray2 is intact as well.\nconsole.log(typedArray1);\nconsole.log(typedArray2);\n</code></pre>\n<p>There is no equivalent to this API in browsers.</p>"
-        },
-        {
-          "textRaw": "`worker.moveMessagePortToContext(port, contextifiedSandbox)`",
-          "type": "method",
-          "name": "moveMessagePortToContext",
-          "meta": {
-            "added": [
-              "v11.13.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {MessagePort}",
-                "name": "return",
-                "type": "MessagePort"
-              },
-              "params": [
-                {
-                  "textRaw": "`port` {MessagePort} The message port which will be transferred.",
-                  "name": "port",
-                  "type": "MessagePort",
-                  "desc": "The message port which will be transferred."
-                },
-                {
-                  "textRaw": "`contextifiedSandbox` {Object} A [contextified][] object as returned by the `vm.createContext()` method.",
-                  "name": "contextifiedSandbox",
-                  "type": "Object",
-                  "desc": "A [contextified][] object as returned by the `vm.createContext()` method."
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Transfer a <code>MessagePort</code> to a different <a href=\"vm.html\"><code>vm</code></a> Context. The original <code>port</code>\nobject will be rendered unusable, and the returned <code>MessagePort</code> instance will\ntake its place.</p>\n<p>The returned <code>MessagePort</code> will be an object in the target context, and will\ninherit from its global <code>Object</code> class. Objects passed to the\n<a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage\"><code>port.onmessage()</code></a> listener will also be created in the target context\nand inherit from its global <code>Object</code> class.</p>\n<p>However, the created <code>MessagePort</code> will no longer inherit from\n<a href=\"events.html\"><code>EventEmitter</code></a>, and only <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage\"><code>port.onmessage()</code></a> can be used to receive\nevents using it.</p>"
-        },
-        {
-          "textRaw": "`worker.receiveMessageOnPort(port)`",
-          "type": "method",
-          "name": "receiveMessageOnPort",
-          "meta": {
-            "added": [
-              "v12.3.0"
-            ],
-            "changes": []
-          },
-          "signatures": [
-            {
-              "return": {
-                "textRaw": "Returns: {Object|undefined}",
-                "name": "return",
-                "type": "Object|undefined"
-              },
-              "params": [
-                {
-                  "textRaw": "`port` {MessagePort}",
-                  "name": "port",
-                  "type": "MessagePort"
-                }
-              ]
-            }
-          ],
-          "desc": "<p>Receive a single message from a given <code>MessagePort</code>. If no message is available,\n<code>undefined</code> is returned, otherwise an object with a single <code>message</code> property\nthat contains the message payload, corresponding to the oldest message in the\n<code>MessagePort</code>’s queue.</p>\n<pre><code class=\"language-js\">const { MessageChannel, receiveMessageOnPort } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\nport1.postMessage({ hello: 'world' });\n\nconsole.log(receiveMessageOnPort(port2));\n// Prints: { message: { hello: 'world' } }\nconsole.log(receiveMessageOnPort(port2));\n// Prints: undefined\n</code></pre>\n<p>When this function is used, no <code>'message'</code> event will be emitted and the\n<code>onmessage</code> listener will not be invoked.</p>"
-        }
-      ],
       "classes": [
         {
           "textRaw": "Class: `MessageChannel`",
@@ -207,9 +271,17 @@
             "added": [
               "v10.5.0"
             ],
-            "changes": []
+            "changes": [
+              {
+                "version": [
+                  "v14.7.0"
+                ],
+                "pr-url": "https://github.com/nodejs/node/pull/34057",
+                "description": "This class now inherits from `EventTarget` rather than from `EventEmitter`."
+              }
+            ]
           },
-          "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventemitter\" class=\"type\">&lt;EventEmitter&gt;</a></li>\n</ul>\n<p>Instances of the <code>worker.MessagePort</code> class represent one end of an\nasynchronous, two-way communications channel. It can be used to transfer\nstructured data, memory regions and other <code>MessagePort</code>s between different\n<a href=\"#worker_threads_class_worker\"><code>Worker</code></a>s.</p>\n<p>With the exception of <code>MessagePort</code>s being <a href=\"events.html\"><code>EventEmitter</code></a>s rather\nthan <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/EventTarget\"><code>EventTarget</code></a>s, this implementation matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort\">browser <code>MessagePort</code></a>s.</p>",
+          "desc": "<ul>\n<li>Extends: <a href=\"events.html#events_class_eventtarget\" class=\"type\">&lt;EventTarget&gt;</a></li>\n</ul>\n<p>Instances of the <code>worker.MessagePort</code> class represent one end of an\nasynchronous, two-way communications channel. It can be used to transfer\nstructured data, memory regions and other <code>MessagePort</code>s between different\n<a href=\"#worker_threads_class_worker\"><code>Worker</code></a>s.</p>\n<p>This implementation matches <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/MessagePort\">browser <code>MessagePort</code></a>s.</p>",
           "events": [
             {
               "textRaw": "Event: `'close'`",
@@ -250,7 +322,7 @@
               "name": "messageerror",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -262,7 +334,7 @@
                   "desc": "An Error object"
                 }
               ],
-              "desc": "<p>The <code>'messageerror'</code> event is emitted when deserializing a message failed.</p>"
+              "desc": "<p>The <code>'messageerror'</code> event is emitted when deserializing a message failed.</p>\n<p>Currently, this event is emitted when there is an error occurring while\ninstantiating the posted JS object on the receiving end. Such situations\nare rare, but can happen, for instance, when certain Node.js API objects\nare received in a <code>vm.Context</code> (where Node.js APIs are currently\nunavailable).</p>"
             }
           ],
           "methods": [
@@ -293,12 +365,22 @@
                 ],
                 "changes": [
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37917",
+                    "description": "Add 'BlockList' to the list of cloneable types."
+                  },
+                  {
+                    "version": "v14.18.0",
+                    "pr-url": "https://github.com/nodejs/node/pull/37155",
+                    "description": "Add 'Histogram' types to the list of cloneable types."
+                  },
+                  {
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/33360",
                     "description": "Added `KeyObject` to the list of cloneable types."
                   },
                   {
-                    "version": "v12.19.0",
+                    "version": "v14.5.0",
                     "pr-url": "https://github.com/nodejs/node/pull/33772",
                     "description": "Added `FileHandle` to the list of transferable types."
                   }
@@ -320,7 +402,7 @@
                   ]
                 }
               ],
-              "desc": "<p>Sends a JavaScript value to the receiving side of this channel.\n<code>value</code> will be transferred in a way which is compatible with\nthe <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\">HTML structured clone algorithm</a>.</p>\n<p>In particular, the significant differences to <code>JSON</code> are:</p>\n<ul>\n<li><code>value</code> may contain circular references.</li>\n<li><code>value</code> may contain instances of builtin JS types such as <code>RegExp</code>s,\n<code>BigInt</code>s, <code>Map</code>s, <code>Set</code>s, etc.</li>\n<li><code>value</code> may contain typed arrays, both using <code>ArrayBuffer</code>s\nand <code>SharedArrayBuffer</code>s.</li>\n<li><code>value</code> may contain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module\"><code>WebAssembly.Module</code></a> instances.</li>\n<li><code>value</code> may not contain native (C++-backed) objects other than <code>MessagePort</code>s,\n<a href=\"fs.html#fs_class_filehandle\"><code>FileHandle</code></a>s, and <a href=\"crypto.html#crypto_class_keyobject\"><code>KeyObject</code></a>s.</li>\n</ul>\n<pre><code class=\"language-js\">const { MessageChannel } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (message) => console.log(message));\n\nconst circularData = {};\ncircularData.foo = circularData;\n// Prints: { foo: [Circular] }\nport2.postMessage(circularData);\n</code></pre>\n<p><code>transferList</code> may be a list of <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"#worker_threads_class_messageport\"><code>MessagePort</code></a> and\n<a href=\"fs.html#fs_class_filehandle\"><code>FileHandle</code></a> objects.\nAfter transferring, they will not be usable on the sending side of the channel\nanymore (even if they are not contained in <code>value</code>). Unlike with\n<a href=\"child_process.html\">child processes</a>, transferring handles such as network sockets is currently\nnot supported.</p>\n<p>If <code>value</code> contains <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> instances, those will be accessible\nfrom either thread. They cannot be listed in <code>transferList</code>.</p>\n<p><code>value</code> may still contain <code>ArrayBuffer</code> instances that are not in\n<code>transferList</code>; in that case, the underlying memory is copied rather than moved.</p>\n<pre><code class=\"language-js\">const { MessageChannel } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (message) => console.log(message));\n\nconst uint8Array = new Uint8Array([ 1, 2, 3, 4 ]);\n// This posts a copy of `uint8Array`:\nport2.postMessage(uint8Array);\n// This does not copy data, but renders `uint8Array` unusable:\nport2.postMessage(uint8Array, [ uint8Array.buffer ]);\n\n// The memory for the `sharedUint8Array` will be accessible from both the\n// original and the copy received by `.on('message')`:\nconst sharedUint8Array = new Uint8Array(new SharedArrayBuffer(4));\nport2.postMessage(sharedUint8Array);\n\n// This transfers a freshly created message port to the receiver.\n// This can be used, for example, to create communication channels between\n// multiple `Worker` threads that are children of the same parent thread.\nconst otherChannel = new MessageChannel();\nport2.postMessage({ port: otherChannel.port1 }, [ otherChannel.port1 ]);\n</code></pre>\n<p>Because the object cloning uses the structured clone algorithm,\nnon-enumerable properties, property accessors, and object prototypes are\nnot preserved. In particular, <a href=\"buffer.html\"><code>Buffer</code></a> objects will be read as\nplain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>s on the receiving side.</p>\n<p>The message object will be cloned immediately, and can be modified after\nposting without having side effects.</p>\n<p>For more information on the serialization and deserialization mechanisms\nbehind this API, see the <a href=\"v8.html#v8_serialization_api\">serialization API of the <code>v8</code> module</a>.</p>",
+              "desc": "<p>Sends a JavaScript value to the receiving side of this channel.\n<code>value</code> will be transferred in a way which is compatible with\nthe <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\">HTML structured clone algorithm</a>.</p>\n<p>In particular, the significant differences to <code>JSON</code> are:</p>\n<ul>\n<li><code>value</code> may contain circular references.</li>\n<li><code>value</code> may contain instances of builtin JS types such as <code>RegExp</code>s,\n<code>BigInt</code>s, <code>Map</code>s, <code>Set</code>s, etc.</li>\n<li><code>value</code> may contain typed arrays, both using <code>ArrayBuffer</code>s\nand <code>SharedArrayBuffer</code>s.</li>\n<li><code>value</code> may contain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module\"><code>WebAssembly.Module</code></a> instances.</li>\n<li><code>value</code> may not contain native (C++-backed) objects other than:\n<ul>\n<li><a href=\"fs.html#fs_class_filehandle\" class=\"type\">&lt;FileHandle&gt;</a>s,</li>\n<li><a href=\"perf_hooks.html#perf_hooks_class_histogram\" class=\"type\">&lt;Histogram&gt;</a>s,</li>\n<li><a href=\"crypto.html#crypto_class_keyobject\" class=\"type\">&lt;KeyObject&gt;</a>s,</li>\n<li><a href=\"worker_threads.html#worker_threads_class_messageport\" class=\"type\">&lt;MessagePort&gt;</a>s,</li>\n<li><a href=\"net.html#net_class_net_blocklist\" class=\"type\">&lt;net.BlockList&gt;</a>s,</li>\n<li><a href=\"net.html#net_class_net_socketaddress\" class=\"type\">&lt;net.SocketAddress&gt;</a>es,</li>\n</ul>\n</li>\n</ul>\n<pre><code class=\"language-js\">const { MessageChannel } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (message) => console.log(message));\n\nconst circularData = {};\ncircularData.foo = circularData;\n// Prints: { foo: [Circular] }\nport2.postMessage(circularData);\n</code></pre>\n<p><code>transferList</code> may be a list of <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\"><code>ArrayBuffer</code></a>, <a href=\"#worker_threads_class_messageport\"><code>MessagePort</code></a> and\n<a href=\"fs.html#fs_class_filehandle\"><code>FileHandle</code></a> objects.\nAfter transferring, they will not be usable on the sending side of the channel\nanymore (even if they are not contained in <code>value</code>). Unlike with\n<a href=\"child_process.html\">child processes</a>, transferring handles such as network sockets is currently\nnot supported.</p>\n<p>If <code>value</code> contains <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\"><code>SharedArrayBuffer</code></a> instances, those will be accessible\nfrom either thread. They cannot be listed in <code>transferList</code>.</p>\n<p><code>value</code> may still contain <code>ArrayBuffer</code> instances that are not in\n<code>transferList</code>; in that case, the underlying memory is copied rather than moved.</p>\n<pre><code class=\"language-js\">const { MessageChannel } = require('worker_threads');\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (message) => console.log(message));\n\nconst uint8Array = new Uint8Array([ 1, 2, 3, 4 ]);\n// This posts a copy of `uint8Array`:\nport2.postMessage(uint8Array);\n// This does not copy data, but renders `uint8Array` unusable:\nport2.postMessage(uint8Array, [ uint8Array.buffer ]);\n\n// The memory for the `sharedUint8Array` will be accessible from both the\n// original and the copy received by `.on('message')`:\nconst sharedUint8Array = new Uint8Array(new SharedArrayBuffer(4));\nport2.postMessage(sharedUint8Array);\n\n// This transfers a freshly created message port to the receiver.\n// This can be used, for example, to create communication channels between\n// multiple `Worker` threads that are children of the same parent thread.\nconst otherChannel = new MessageChannel();\nport2.postMessage({ port: otherChannel.port1 }, [ otherChannel.port1 ]);\n</code></pre>\n<p>Because the object cloning uses the structured clone algorithm,\nnon-enumerable properties, property accessors, and object prototypes are\nnot preserved. In particular, <a href=\"buffer.html\"><code>Buffer</code></a> objects will be read as\nplain <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\"><code>Uint8Array</code></a>s on the receiving side.</p>\n<p>The message object will be cloned immediately, and can be modified after\nposting without having side effects.</p>\n<p>For more information on the serialization and deserialization mechanisms\nbehind this API, see the <a href=\"v8.html#v8_serialization_api\">serialization API of the <code>v8</code> module</a>.</p>",
               "modules": [
                 {
                   "textRaw": "Considerations when transferring TypedArrays and Buffers",
@@ -460,7 +542,7 @@
               "name": "messageerror",
               "meta": {
                 "added": [
-                  "v12.19.0"
+                  "v14.5.0"
                 ],
                 "changes": []
               },
@@ -495,7 +577,7 @@
               "name": "getHeapSnapshot",
               "meta": {
                 "added": [
-                  "v12.17.0"
+                  "v13.9.0"
                 ],
                 "changes": []
               },
@@ -609,11 +691,11 @@
               "name": "performance",
               "meta": {
                 "added": [
-                  "v12.22.0"
+                  "v14.17.0"
                 ],
                 "changes": []
               },
-              "desc": "<p>An object that can be used to query performance information from a worker\ninstance. Similar to <a href=\"#perf_hooks.md#perf_hooks_perf_hooks_performance\"><code>perf_hooks.performance</code></a>.</p>",
+              "desc": "<p>An object that can be used to query performance information from a worker\ninstance. Similar to <a href=\"perf_hooks.html#perf_hooks_perf_hooks_performance\"><code>perf_hooks.performance</code></a>.</p>",
               "methods": [
                 {
                   "textRaw": "`performance.eventLoopUtilization([utilization1[, utilization2]])`",
@@ -621,7 +703,7 @@
                   "name": "eventLoopUtilization",
                   "meta": {
                     "added": [
-                      "v12.22.0"
+                      "v14.17.0"
                     ],
                     "changes": []
                   },
@@ -665,7 +747,7 @@
                       ]
                     }
                   ],
-                  "desc": "<p>The same call as <a href=\"perf_hooks.md#perf_hooks_performance_eventlooputilization_utilization1_utilization2\"><code>perf_hooks</code> <code>eventLoopUtilization()</code></a>, except the values\nof the worker instance are returned.</p>\n<p>One difference is that, unlike the main thread, bootstrapping within a worker\nis done within the event loop. So the event loop utilization will be\nimmediately available once the worker's script begins execution.</p>\n<p>An <code>idle</code> time that does not increase does not indicate that the worker is\nstuck in bootstrap. The following examples shows how the worker's entire\nlifetime will never accumulate any <code>idle</code> time, but is still be able to process\nmessages.</p>\n<pre><code class=\"language-js\">const { Worker, isMainThread, parentPort } = require('worker_threads');\n\nif (isMainThread) {\n  const worker = new Worker(__filename);\n  setInterval(() => {\n    worker.postMessage('hi');\n    console.log(worker.performance.eventLoopUtilization());\n  }, 100).unref();\n  return;\n}\n\nparentPort.on('message', () => console.log('msg')).unref();\n(function r(n) {\n  if (--n &#x3C; 0) return;\n  const t = Date.now();\n  while (Date.now() - t &#x3C; 300);\n  setImmediate(r, n);\n})(10);\n</code></pre>\n<p>The event loop utilization of a worker is available only after the <a href=\"#worker_threads_event_online\"><code>'online'</code>\nevent</a> emitted, and if called before this, or after the <a href=\"#worker_threads_event_exit\"><code>'exit'</code>\nevent</a>, then all properties have the value of <code>0</code>.</p>"
+                  "desc": "<p>The same call as <a href=\"perf_hooks.html#perf_hooks_performance_eventlooputilization_utilization1_utilization2\"><code>perf_hooks</code> <code>eventLoopUtilization()</code></a>, except the values\nof the worker instance are returned.</p>\n<p>One difference is that, unlike the main thread, bootstrapping within a worker\nis done within the event loop. So the event loop utilization will be\nimmediately available once the worker's script begins execution.</p>\n<p>An <code>idle</code> time that does not increase does not indicate that the worker is\nstuck in bootstrap. The following examples shows how the worker's entire\nlifetime will never accumulate any <code>idle</code> time, but is still be able to process\nmessages.</p>\n<pre><code class=\"language-js\">const { Worker, isMainThread, parentPort } = require('worker_threads');\n\nif (isMainThread) {\n  const worker = new Worker(__filename);\n  setInterval(() => {\n    worker.postMessage('hi');\n    console.log(worker.performance.eventLoopUtilization());\n  }, 100).unref();\n  return;\n}\n\nparentPort.on('message', () => console.log('msg')).unref();\n(function r(n) {\n  if (--n &#x3C; 0) return;\n  const t = Date.now();\n  while (Date.now() - t &#x3C; 300);\n  setImmediate(r, n);\n})(10);\n</code></pre>\n<p>The event loop utilization of a worker is available only after the <a href=\"#worker_threads_event_online\"><code>'online'</code>\nevent</a> emitted, and if called before this, or after the <a href=\"#worker_threads_event_exit\"><code>'exit'</code>\nevent</a>, then all properties have the value of <code>0</code>.</p>"
                 }
               ]
             },
@@ -675,6 +757,7 @@
               "name": "resourceLimits",
               "meta": {
                 "added": [
+                  "v13.2.0",
                   "v12.16.0"
                 ],
                 "changes": []
@@ -756,10 +839,10 @@
             {
               "params": [
                 {
-                  "textRaw": "`filename` {string|URL} The path to the Worker’s main script or module. Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with `./` or `../`, or a WHATWG `URL` object using `file:` protocol. If `options.eval` is `true`, this is a string containing JavaScript code rather than a path.",
+                  "textRaw": "`filename` {string|URL} The path to the Worker’s main script or module. Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with `./` or `../`, or a WHATWG `URL` object using `file:` or `data:` protocol. When using a [`data:` URL][], the data is interpreted based on MIME type using the [ECMAScript module loader][]. If `options.eval` is `true`, this is a string containing JavaScript code rather than a path.",
                   "name": "filename",
                   "type": "string|URL",
-                  "desc": "The path to the Worker’s main script or module. Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with `./` or `../`, or a WHATWG `URL` object using `file:` protocol. If `options.eval` is `true`, this is a string containing JavaScript code rather than a path."
+                  "desc": "The path to the Worker’s main script or module. Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with `./` or `../`, or a WHATWG `URL` object using `file:` or `data:` protocol. When using a [`data:` URL][], the data is interpreted based on MIME type using the [ECMAScript module loader][]. If `options.eval` is `true`, this is a string containing JavaScript code rather than a path."
                 },
                 {
                   "textRaw": "`options` {Object}",
@@ -867,6 +950,30 @@
           ]
         }
       ],
+      "modules": [
+        {
+          "textRaw": "Notes",
+          "name": "notes",
+          "modules": [
+            {
+              "textRaw": "Synchronous blocking of stdio",
+              "name": "synchronous_blocking_of_stdio",
+              "desc": "<p><code>Worker</code>s utilize message passing via <a href=\"worker_threads.html#worker_threads_class_messageport\" class=\"type\">&lt;MessagePort&gt;</a> to implement interactions\nwith <code>stdio</code>. This means that <code>stdio</code> output originating from a <code>Worker</code> can\nget blocked by synchronous code on the receiving end that is blocking the\nNode.js event loop.</p>\n<pre><code class=\"language-mjs\">import {\n  Worker,\n  isMainThread,\n} from 'worker_threads';\n\nif (isMainThread) {\n  new Worker(new URL(import.meta.url));\n  for (let n = 0; n &#x3C; 1e10; n++) {}\n} else {\n  // This output will be blocked by the for loop in the main thread.\n  console.log('foo');\n}\n</code></pre>\n<pre><code class=\"language-cjs\">'use strict';\n\nconst {\n  Worker,\n  isMainThread,\n} = require('worker_threads');\n\nif (isMainThread) {\n  new Worker(__filename);\n  for (let n = 0; n &#x3C; 1e10; n++) {}\n} else {\n  // This output will be blocked by the for loop in the main thread.\n  console.log('foo');\n}\n</code></pre>",
+              "type": "module",
+              "displayName": "Synchronous blocking of stdio"
+            },
+            {
+              "textRaw": "Launching worker threads from preload scripts",
+              "name": "launching_worker_threads_from_preload_scripts",
+              "desc": "<p>Take care when launching worker threads from preload scripts (scripts loaded\nand run using the <code>-r</code> command line flag). Unless the <code>execArgv</code> option is\nexplicitly set, new Worker threads automatically inherit the command line flags\nfrom the running process and will preload the same preload scripts as the main\nthread. If the preload script unconditionally launches a worker thread, every\nthread spawned will spawn another until the application crashes.</p>",
+              "type": "module",
+              "displayName": "Launching worker threads from preload scripts"
+            }
+          ],
+          "type": "module",
+          "displayName": "Notes"
+        }
+      ],
       "type": "module",
       "displayName": "Worker threads"
     }
diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 364c52c4f41c4dae98e0576286a654475b206a6f..77e72535697b02ee41b8c9daee0ce5090dd0ba34 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -61,6 +61,38 @@ Worker threads inherit non-process-specific options by default. Refer to
 [`Worker constructor options`][] to know how to customize worker thread options,
 specifically `argv` and `execArgv` options.
 
+## `worker.getEnvironmentData(key)`
+<!-- YAML
+added: v14.18.0
+-->
+
+> Stability: 1 - Experimental
+
+* `key` {any} Any arbitrary, cloneable JavaScript value that can be used as a
+  {Map} key.
+* Returns: {any}
+
+Within a worker thread, `worker.getEnvironmentData()` returns a clone
+of data passed to the spawning thread's `worker.setEnvironmentData()`.
+Every new `Worker` receives its own copy of the environment data
+automatically.
+
+```js
+const {
+  Worker,
+  isMainThread,
+  setEnvironmentData,
+  getEnvironmentData,
+} = require('worker_threads');
+
+if (isMainThread) {
+  setEnvironmentData('Hello', 'World!');
+  const worker = new Worker(__filename);
+} else {
+  console.log(getEnvironmentData('Hello'));  // Prints 'World!'.
+}
+```
+
 ## `worker.isMainThread`
 <!-- YAML
 added: v10.5.0
@@ -84,7 +116,7 @@ if (isMainThread) {
 
 ## `worker.markAsUntransferable(object)`
 <!-- YAML
-added: v12.19.0
+added: v14.5.0
 -->
 
 Mark an object as not transferable. If `object` occurs in the transfer list of
@@ -140,7 +172,7 @@ inherit from its global `Object` class. Objects passed to the
 and inherit from its global `Object` class.
 
 However, the created `MessagePort` will no longer inherit from
-[`EventEmitter`][], and only [`port.onmessage()`][] can be used to receive
+[`EventTarget`][], and only [`port.onmessage()`][] can be used to receive
 events using it.
 
 ## `worker.parentPort`
@@ -204,7 +236,9 @@ When this function is used, no `'message'` event will be emitted and the
 
 ## `worker.resourceLimits`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.2.0
+ - v12.16.0
 -->
 
 * {Object}
@@ -238,6 +272,23 @@ new Worker('process.env.SET_IN_WORKER = "foo"', { eval: true, env: SHARE_ENV })
   });
 ```
 
+## `worker.setEnvironmentData(key[, value])`
+<!-- YAML
+added: v14.18.0
+-->
+
+> Stability: 1 - Experimental
+
+* `key` {any} Any arbitrary, cloneable JavaScript value that can be used as a
+  {Map} key.
+* `value` {any} Any arbitrary, cloneable JavaScript value that will be cloned
+  and passed automatically to all new `Worker` instances. If `value` is passed
+  as `undefined`, any previously set value for the `key` will be deleted.
+
+The `worker.setEnvironmentData()` API sets the content of
+`worker.getEnvironmentData()` in the current thread and all new `Worker`
+instances spawned from the current context.
+
 ## `worker.threadId`
 <!-- YAML
 added: v10.5.0
@@ -293,17 +344,22 @@ port2.postMessage({ foo: 'bar' });
 ## Class: `MessagePort`
 <!-- YAML
 added: v10.5.0
+changes:
+  - version:
+    - v14.7.0
+    pr-url: https://github.com/nodejs/node/pull/34057
+    description: This class now inherits from `EventTarget` rather than
+                 from `EventEmitter`.
 -->
 
-* Extends: {EventEmitter}
+* Extends: {EventTarget}
 
 Instances of the `worker.MessagePort` class represent one end of an
 asynchronous, two-way communications channel. It can be used to transfer
 structured data, memory regions and other `MessagePort`s between different
 [`Worker`][]s.
 
-With the exception of `MessagePort`s being [`EventEmitter`][]s rather
-than [`EventTarget`][]s, this implementation matches [browser `MessagePort`][]s.
+This implementation matches [browser `MessagePort`][]s.
 
 ### Event: `'close'`
 <!-- YAML
@@ -342,13 +398,19 @@ to `postMessage()` and no further arguments.
 
 ### Event: `'messageerror'`
 <!-- YAML
-added: v12.19.0
+added: v14.5.0
 -->
 
 * `error` {Error} An Error object
 
 The `'messageerror'` event is emitted when deserializing a message failed.
 
+Currently, this event is emitted when there is an error occurring while
+instantiating the posted JS object on the receiving end. Such situations
+are rare, but can happen, for instance, when certain Node.js API objects
+are received in a `vm.Context` (where Node.js APIs are currently
+unavailable).
+
 ### `port.close()`
 <!-- YAML
 added: v10.5.0
@@ -365,10 +427,16 @@ are part of the channel.
 <!-- YAML
 added: v10.5.0
 changes:
-  - version: v12.19.0
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37917
+    description: Add 'BlockList' to the list of cloneable types.
+  - version: v14.18.0
+    pr-url: https://github.com/nodejs/node/pull/37155
+    description: Add 'Histogram' types to the list of cloneable types.
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33360
     description: Added `KeyObject` to the list of cloneable types.
-  - version: v12.19.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33772
     description: Added `FileHandle` to the list of transferable types.
 -->
@@ -388,8 +456,13 @@ In particular, the significant differences to `JSON` are:
 * `value` may contain typed arrays, both using `ArrayBuffer`s
    and `SharedArrayBuffer`s.
 * `value` may contain [`WebAssembly.Module`][] instances.
-* `value` may not contain native (C++-backed) objects other than `MessagePort`s,
-  [`FileHandle`][]s, and [`KeyObject`][]s.
+* `value` may not contain native (C++-backed) objects other than:
+  * {FileHandle}s,
+  * {Histogram}s,
+  * {KeyObject}s,
+  * {MessagePort}s,
+  * {net.BlockList}s,
+  * {net.SocketAddress}es,
 
 ```js
 const { MessageChannel } = require('worker_threads');
@@ -619,29 +692,42 @@ if (isMainThread) {
 <!-- YAML
 added: v10.5.0
 changes:
+  - version: v14.9.0
+    pr-url: https://github.com/nodejs/node/pull/34584
+    description: The `filename` parameter can be a WHATWG `URL` object using
+                 `data:` protocol.
+  - version: v14.9.0
+    pr-url: https://github.com/nodejs/node/pull/34394
+    description: The `trackUnmanagedFds` option was set to `true` by default.
   - version:
-    - v12.19.0
+    - v14.6.0
     pr-url: https://github.com/nodejs/node/pull/34303
     description: The `trackUnmanagedFds` option was introduced.
-  - version: v12.17.0
+  - version: v14.0.0
     pr-url: https://github.com/nodejs/node/pull/32278
     description: The `transferList` option was introduced.
-  - version: v12.17.0
+  - version: v13.12.0
     pr-url: https://github.com/nodejs/node/pull/31664
     description: The `filename` parameter can be a WHATWG `URL` object using
                  `file:` protocol.
-  - version: v12.16.0
-    pr-url: https://github.com/nodejs/node/pull/26628
-    description: The `resourceLimits` option was introduced.
-  - version: v12.16.0
+  - version:
+     - v13.4.0
+     - v12.16.0
     pr-url: https://github.com/nodejs/node/pull/30559
     description: The `argv` option was introduced.
+  - version:
+     - v13.2.0
+     - v12.16.0
+    pr-url: https://github.com/nodejs/node/pull/26628
+    description: The `resourceLimits` option was introduced.
 -->
 
 * `filename` {string|URL} The path to the Worker’s main script or module. Must
   be either an absolute path or a relative path (i.e. relative to the
   current working directory) starting with `./` or `../`, or a WHATWG `URL`
-  object using `file:` protocol.
+  object using `file:` or `data:` protocol.
+  When using a [`data:` URL][], the data is interpreted based on MIME type using
+  the [ECMAScript module loader][].
   If `options.eval` is `true`, this is a string containing JavaScript code
   rather than a path.
 * `options` {Object}
@@ -737,7 +823,7 @@ All messages sent from the worker thread will be emitted before the
 
 ### Event: `'messageerror'`
 <!-- YAML
-added: v12.19.0
+added: v14.5.0
 -->
 
 * `error` {Error} An Error object
@@ -754,7 +840,7 @@ JavaScript code.
 
 ### `worker.getHeapSnapshot()`
 <!-- YAML
-added: v12.17.0
+added: v13.9.0
 -->
 
 * Returns: {Promise} A promise for a Readable Stream containing
@@ -769,7 +855,7 @@ immediately with an [`ERR_WORKER_NOT_RUNNING`][] error.
 
 ### `worker.performance`
 <!-- YAML
-added: v12.22.0
+added: v14.17.0
 -->
 
 An object that can be used to query performance information from a worker
@@ -777,7 +863,7 @@ instance. Similar to [`perf_hooks.performance`][].
 
 #### `performance.eventLoopUtilization([utilization1[, utilization2]])`
 <!-- YAML
-added: v12.22.0
+added: v14.17.0
 -->
 
 * `utilization1` {Object} The result of a previous call to
@@ -850,7 +936,9 @@ no effect.
 
 ### `worker.resourceLimits`
 <!-- YAML
-added: v12.16.0
+added:
+ - v13.2.0
+ - v12.16.0
 -->
 
 * {Object}
@@ -864,6 +952,7 @@ If the `resourceLimits` option was passed to the [`Worker`][] constructor,
 this matches its values.
 
 If the worker has stopped, the return value is an empty object.
+
 ### `worker.stderr`
 <!-- YAML
 added: v10.5.0
@@ -937,63 +1026,113 @@ Calling `unref()` on a worker will allow the thread to exit if this is the only
 active handle in the event system. If the worker is already `unref()`ed calling
 `unref()` again will have no effect.
 
+## Notes
+
+### Synchronous blocking of stdio
+
+`Worker`s utilize message passing via {MessagePort} to implement interactions
+with `stdio`. This means that `stdio` output originating from a `Worker` can
+get blocked by synchronous code on the receiving end that is blocking the
+Node.js event loop.
+
+```mjs
+import {
+  Worker,
+  isMainThread,
+} from 'worker_threads';
+
+if (isMainThread) {
+  new Worker(new URL(import.meta.url));
+  for (let n = 0; n < 1e10; n++) {}
+} else {
+  // This output will be blocked by the for loop in the main thread.
+  console.log('foo');
+}
+```
+
+```cjs
+'use strict';
+
+const {
+  Worker,
+  isMainThread,
+} = require('worker_threads');
+
+if (isMainThread) {
+  new Worker(__filename);
+  for (let n = 0; n < 1e10; n++) {}
+} else {
+  // This output will be blocked by the for loop in the main thread.
+  console.log('foo');
+}
+```
+
+### Launching worker threads from preload scripts
+
+Take care when launching worker threads from preload scripts (scripts loaded
+and run using the `-r` command line flag). Unless the `execArgv` option is
+explicitly set, new Worker threads automatically inherit the command line flags
+from the running process and will preload the same preload scripts as the main
+thread. If the preload script unconditionally launches a worker thread, every
+thread spawned will spawn another until the application crashes.
+
+[Addons worker support]: addons.md#addons_worker_support
+[ECMAScript module loader]: esm.md#esm_data_imports
+[HTML structured clone algorithm]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+[Signals events]: process.md#process_signal_events
+[Web Workers]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API
 [`'close'` event]: #worker_threads_event_close
 [`'exit'` event]: #worker_threads_event_exit
 [`'online'` event]: #worker_threads_event_online
 [`ArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
-[`AsyncResource`]: async_hooks.html#async_hooks_class_asyncresource
-[`Buffer`]: buffer.html
-[`Buffer.allocUnsafe()`]: buffer.html#buffer_static_method_buffer_allocunsafe_size
-[`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`]: errors.html#errors_err_missing_message_port_in_transfer_list
-[`ERR_WORKER_NOT_RUNNING`]: errors.html#ERR_WORKER_NOT_RUNNING
-[`EventEmitter`]: events.html
+[`AsyncResource`]: async_hooks.md#async_hooks_class_asyncresource
+[`Buffer.allocUnsafe()`]: buffer.md#buffer_static_method_buffer_allocunsafe_size
+[`Buffer`]: buffer.md
+[`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`]: errors.md#errors_err_missing_message_port_in_transfer_list
+[`ERR_WORKER_NOT_RUNNING`]: errors.md#ERR_WORKER_NOT_RUNNING
 [`EventTarget`]: https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
-[`FileHandle`]: fs.html#fs_class_filehandle
-[`KeyObject`]: crypto.html#crypto_class_keyobject
+[`FileHandle`]: fs.md#fs_class_filehandle
 [`MessagePort`]: #worker_threads_class_messageport
 [`SharedArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer
 [`Uint8Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
 [`WebAssembly.Module`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module
+[`Worker constructor options`]: #worker_threads_new_worker_filename_options
 [`Worker`]: #worker_threads_class_worker
-[`cluster` module]: cluster.html
-[`fs.open()`]: fs.html#fs_fs_open_path_flags_mode_callback
-[`fs.close()`]: fs.html#fs_fs_close_fd_callback
+[`cluster` module]: cluster.md
+[`data:` URL]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
+[`fs.close()`]: fs.md#fs_fs_close_fd_callback
+[`fs.open()`]: fs.md#fs_fs_open_path_flags_mode_callback
 [`markAsUntransferable()`]: #worker_threads_worker_markasuntransferable_object
-[`perf_hooks.performance`]: #perf_hooks.md#perf_hooks_perf_hooks_performance
+[`perf_hooks.performance`]: perf_hooks.md#perf_hooks_perf_hooks_performance
 [`perf_hooks` `eventLoopUtilization()`]: perf_hooks.md#perf_hooks_performance_eventlooputilization_utilization1_utilization2
 [`port.on('message')`]: #worker_threads_event_message
 [`port.onmessage()`]: https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage
 [`port.postMessage()`]: #worker_threads_port_postmessage_value_transferlist
-[`process.abort()`]: process.html#process_process_abort
-[`process.chdir()`]: process.html#process_process_chdir_directory
-[`process.env`]: process.html#process_process_env
-[`process.execArgv`]: process.html#process_process_execargv
-[`process.exit()`]: process.html#process_process_exit_code
-[`process.stderr`]: process.html#process_process_stderr
-[`process.stdin`]: process.html#process_process_stdin
-[`process.stdout`]: process.html#process_process_stdout
-[`process.title`]: process.html#process_process_title
+[`process.abort()`]: process.md#process_process_abort
+[`process.chdir()`]: process.md#process_process_chdir_directory
+[`process.env`]: process.md#process_process_env
+[`process.execArgv`]: process.md#process_process_execargv
+[`process.exit()`]: process.md#process_process_exit_code
+[`process.stderr`]: process.md#process_process_stderr
+[`process.stdin`]: process.md#process_process_stdin
+[`process.stdout`]: process.md#process_process_stdout
+[`process.title`]: process.md#process_process_title
 [`require('worker_threads').isMainThread`]: #worker_threads_worker_ismainthread
 [`require('worker_threads').parentPort.on('message')`]: #worker_threads_event_message
-[`require('worker_threads').parentPort`]: #worker_threads_worker_parentport
 [`require('worker_threads').parentPort.postMessage()`]: #worker_threads_worker_postmessage_value_transferlist
+[`require('worker_threads').parentPort`]: #worker_threads_worker_parentport
 [`require('worker_threads').threadId`]: #worker_threads_worker_threadid
 [`require('worker_threads').workerData`]: #worker_threads_worker_workerdata
-[`trace_events`]: tracing.html
-[`v8.getHeapSnapshot()`]: v8.html#v8_v8_getheapsnapshot
-[`vm`]: vm.html
-[`Worker constructor options`]: #worker_threads_new_worker_filename_options
+[`trace_events`]: tracing.md
+[`v8.getHeapSnapshot()`]: v8.md#v8_v8_getheapsnapshot
+[`vm`]: vm.md
+[`worker.SHARE_ENV`]: #worker_threads_worker_share_env
 [`worker.on('message')`]: #worker_threads_event_message_1
 [`worker.postMessage()`]: #worker_threads_worker_postmessage_value_transferlist
-[`worker.SHARE_ENV`]: #worker_threads_worker_share_env
 [`worker.terminate()`]: #worker_threads_worker_terminate
 [`worker.threadId`]: #worker_threads_worker_threadid_1
-[Addons worker support]: addons.html#addons_worker_support
-[async-resource-worker-pool]: async_hooks.html#async-resource-worker-pool
-[HTML structured clone algorithm]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
-[Signals events]: process.html#process_signal_events
-[Web Workers]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API
+[async-resource-worker-pool]: async_hooks.md#async-resource-worker-pool
 [browser `MessagePort`]: https://developer.mozilla.org/en-US/docs/Web/API/MessagePort
-[child processes]: child_process.html
-[contextified]: vm.html#vm_what_does_it_mean_to_contextify_an_object
-[v8.serdes]: v8.html#v8_serialization_api
+[child processes]: child_process.md
+[contextified]: vm.md#vm_what_does_it_mean_to_contextify_an_object
+[v8.serdes]: v8.md#v8_serialization_api
diff --git a/doc/api/zlib.html b/doc/api/zlib.html
index f2ff7f27109f106f2ea0f25e5e6711a41ef88d8b..053a75e0a6ad95a83a6ef18cd6c71500ee34e000 100644
--- a/doc/api/zlib.html
+++ b/doc/api/zlib.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width">
-  <meta name="nodejs.org:node-version" content="v12.22.7">
-  <title>Zlib | Node.js v12.22.7 Documentation</title>
+  <meta name="nodejs.org:node-version" content="v14.18.3">
+  <title>Zlib | Node.js v14.18.3 Documentation</title>
   <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
   <link rel="stylesheet" href="assets/style.css">
   <link rel="stylesheet" href="assets/hljs.css">
@@ -27,16 +27,17 @@
 <li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
 <li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
 <li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
-<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
-<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
-<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
-<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
+<li><a href="addons.html" class="nav-addons">C++ addons</a></li>
+<li><a href="n-api.html" class="nav-n-api">C/C++ addons with Node-API</a></li>
+<li><a href="embedding.html" class="nav-embedding">C++ embedder API</a></li>
+<li><a href="child_process.html" class="nav-child_process">Child processes</a></li>
 <li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
-<li><a href="cli.html" class="nav-cli">Command line options</a></li>
+<li><a href="cli.html" class="nav-cli">Command-line options</a></li>
 <li><a href="console.html" class="nav-console">Console</a></li>
 <li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
 <li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
 <li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
+<li><a href="diagnostics_channel.html" class="nav-diagnostics_channel">Diagnostics Channel</a></li>
 <li><a href="dns.html" class="nav-dns">DNS</a></li>
 <li><a href="domain.html" class="nav-domain">Domain</a></li>
 <li><a href="errors.html" class="nav-errors">Errors</a></li>
@@ -86,7 +87,20 @@
 
     <div id="column1" data-id="zlib" class="interior">
       <header>
-        <h1>Node.js v12.22.7 Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js v14.18.3 documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -101,7 +115,8 @@
             
     <li class="version-picker">
       <a href="#">View another version <span>&#x25bc;</span></a>
-      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v16.x/api/zlib.html">16.x</a></li>
+      <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v17.x/api/zlib.html">17.x</a></li>
+<li><a href="https://nodejs.org/docs/latest-v16.x/api/zlib.html">16.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v15.x/api/zlib.html">15.x</a></li>
 <li><a href="https://nodejs.org/docs/latest-v14.x/api/zlib.html">14.x <b>LTS</b></a></li>
 <li><a href="https://nodejs.org/docs/latest-v13.x/api/zlib.html">13.x</a></li>
@@ -118,15 +133,13 @@
 <li><a href="https://nodejs.org/docs/latest-v0.10.x/api/zlib.html">0.10.x</a></li></ol>
     </li>
   
-            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/zlib.md"><span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>Edit on GitHub</a></li>
+            <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/zlib.md">Edit on GitHub</a></li>
           </ul>
         </div>
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        <ul>
+      <details id="toc" open><summary>Table of contents</summary><ul>
 <li><span class="stability_2"><a href="#zlib_zlib">Zlib</a></span>
 <ul>
 <li><a href="#zlib_threadpool_usage_and_performance_considerations">Threadpool usage and performance considerations</a></li>
@@ -205,19 +218,18 @@
 </li>
 </ul>
 </li>
-</ul>
-      </div>
+</ul></details>
 
       <div id="apicontent">
-        <h1>Zlib<span><a class="mark" href="#zlib_zlib" id="zlib_zlib">#</a></span></h1>
+        <h2>Zlib<span><a class="mark" href="#zlib_zlib" id="zlib_zlib">#</a></span></h2>
 
 <p></p><div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div><p></p>
-<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v12.22.7/lib/zlib.js">lib/zlib.js</a></p>
+<p><strong>Source Code:</strong> <a href="https://github.com/nodejs/node/blob/v14.18.3/lib/zlib.js">lib/zlib.js</a></p>
 <p>The <code>zlib</code> module provides compression functionality implemented using Gzip,
 Deflate/Inflate, and Brotli.</p>
 <p>To access it:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> zlib = <span class="hljs-built_in">require</span>(<span class="hljs-string">'zlib'</span>);</code></pre>
-<p>Compression and decompression are built around the Node.js <a href="stream.md">Streams API</a>.</p>
+<p>Compression and decompression are built around the Node.js <a href="stream.html">Streams API</a>.</p>
 <p>Compressing or decompressing a stream (such as a file) can be accomplished by
 piping the source stream through a <code>zlib</code> <code>Transform</code> stream into a destination
 stream:</p>
@@ -228,67 +240,67 @@ stream:</p>
   createWriteStream
 } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 
-<span class="hljs-keyword">const</span> gzip = createGzip();
-<span class="hljs-keyword">const</span> source = createReadStream(<span class="hljs-string">'input.txt'</span>);
-<span class="hljs-keyword">const</span> destination = createWriteStream(<span class="hljs-string">'input.txt.gz'</span>);
+<span class="hljs-keyword">const</span> gzip = <span class="hljs-title function_">createGzip</span>();
+<span class="hljs-keyword">const</span> source = <span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'input.txt'</span>);
+<span class="hljs-keyword">const</span> destination = <span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'input.txt.gz'</span>);
 
-pipeline(source, gzip, destination, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+<span class="hljs-title function_">pipeline</span>(source, gzip, destination, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   }
 });
 
 <span class="hljs-comment">// Or, Promisified</span>
 
 <span class="hljs-keyword">const</span> { promisify } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> pipe = promisify(pipeline);
+<span class="hljs-keyword">const</span> pipe = <span class="hljs-title function_">promisify</span>(pipeline);
 
-<span class="hljs-keyword">async</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">do_gzip</span>(<span class="hljs-params">input, output</span>) </span>{
-  <span class="hljs-keyword">const</span> gzip = createGzip();
-  <span class="hljs-keyword">const</span> source = createReadStream(input);
-  <span class="hljs-keyword">const</span> destination = createWriteStream(output);
-  <span class="hljs-keyword">await</span> pipe(source, gzip, destination);
+<span class="hljs-keyword">async</span> <span class="hljs-keyword">function</span> <span class="hljs-title function_">do_gzip</span>(<span class="hljs-params">input, output</span>) {
+  <span class="hljs-keyword">const</span> gzip = <span class="hljs-title function_">createGzip</span>();
+  <span class="hljs-keyword">const</span> source = <span class="hljs-title function_">createReadStream</span>(input);
+  <span class="hljs-keyword">const</span> destination = <span class="hljs-title function_">createWriteStream</span>(output);
+  <span class="hljs-keyword">await</span> <span class="hljs-title function_">pipe</span>(source, gzip, destination);
 }
 
-do_gzip(<span class="hljs-string">'input.txt'</span>, <span class="hljs-string">'input.txt.gz'</span>)
-  .catch(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+<span class="hljs-title function_">do_gzip</span>(<span class="hljs-string">'input.txt'</span>, <span class="hljs-string">'input.txt.gz'</span>)
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   });</code></pre>
 <p>It is also possible to compress or decompress data in a single step:</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> { deflate, unzip } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'zlib'</span>);
 
 <span class="hljs-keyword">const</span> input = <span class="hljs-string">'.................................'</span>;
-deflate(input, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
+<span class="hljs-title function_">deflate</span>(input, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   }
-  <span class="hljs-built_in">console</span>.log(buffer.toString(<span class="hljs-string">'base64'</span>));
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buffer.<span class="hljs-title function_">toString</span>(<span class="hljs-string">'base64'</span>));
 });
 
-<span class="hljs-keyword">const</span> buffer = Buffer.from(<span class="hljs-string">'eJzT0yMAAGTvBe8='</span>, <span class="hljs-string">'base64'</span>);
-unzip(buffer, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'eJzT0yMAAGTvBe8='</span>, <span class="hljs-string">'base64'</span>);
+<span class="hljs-title function_">unzip</span>(buffer, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
   <span class="hljs-keyword">if</span> (err) {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   }
-  <span class="hljs-built_in">console</span>.log(buffer.toString());
+  <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buffer.<span class="hljs-title function_">toString</span>());
 });
 
 <span class="hljs-comment">// Or, Promisified</span>
 
 <span class="hljs-keyword">const</span> { promisify } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'util'</span>);
-<span class="hljs-keyword">const</span> do_unzip = promisify(unzip);
+<span class="hljs-keyword">const</span> do_unzip = <span class="hljs-title function_">promisify</span>(unzip);
 
-do_unzip(buffer)
-  .then(<span class="hljs-function">(<span class="hljs-params">buf</span>) =></span> <span class="hljs-built_in">console</span>.log(buf.toString()))
-  .catch(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
-    <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-    process.exitCode = <span class="hljs-number">1</span>;
+<span class="hljs-title function_">do_unzip</span>(buffer)
+  .<span class="hljs-title function_">then</span>(<span class="hljs-function">(<span class="hljs-params">buf</span>) =></span> <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buf.<span class="hljs-title function_">toString</span>()))
+  .<span class="hljs-title function_">catch</span>(<span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+    process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
   });</code></pre>
-<h2>Threadpool usage and performance considerations<span><a class="mark" href="#zlib_threadpool_usage_and_performance_considerations" id="zlib_threadpool_usage_and_performance_considerations">#</a></span></h2>
+<section><h3>Threadpool usage and performance considerations<span><a class="mark" href="#zlib_threadpool_usage_and_performance_considerations" id="zlib_threadpool_usage_and_performance_considerations">#</a></span></h3>
 <p>All <code>zlib</code> APIs, except those that are explicitly synchronous, use the Node.js
 internal threadpool. This can lead to surprising effects and performance
 limitations in some applications.</p>
@@ -296,18 +308,18 @@ limitations in some applications.</p>
 significant memory fragmentation.</p>
 <pre><code class="language-js"><span class="hljs-keyword">const</span> zlib = <span class="hljs-built_in">require</span>(<span class="hljs-string">'zlib'</span>);
 
-<span class="hljs-keyword">const</span> payload = Buffer.from(<span class="hljs-string">'This is some data'</span>);
+<span class="hljs-keyword">const</span> payload = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'This is some data'</span>);
 
 <span class="hljs-comment">// WARNING: DO NOT DO THIS!</span>
 <span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &#x3C; <span class="hljs-number">30000</span>; ++i) {
-  zlib.deflate(payload, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {});
+  zlib.<span class="hljs-title function_">deflate</span>(payload, <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {});
 }</code></pre>
 <p>In the preceding example, 30,000 deflate instances are created concurrently.
 Because of how some operating systems handle memory allocation and
 deallocation, this may lead to to significant memory fragmentation.</p>
 <p>It is strongly recommended that the results of compression
 operations be cached to avoid duplication of effort.</p>
-<h2>Compressing HTTP requests and responses<span><a class="mark" href="#zlib_compressing_http_requests_and_responses" id="zlib_compressing_http_requests_and_responses">#</a></span></h2>
+</section><section><h3>Compressing HTTP requests and responses<span><a class="mark" href="#zlib_compressing_http_requests_and_responses" id="zlib_compressing_http_requests_and_responses">#</a></span></h3>
 <p>The <code>zlib</code> module can be used to implement support for the <code>gzip</code>, <code>deflate</code>
 and <code>br</code> content-encoding mechanisms defined by
 <a href="https://tools.ietf.org/html/rfc7230#section-4.2">HTTP</a>.</p>
@@ -325,33 +337,33 @@ tradeoffs involved in <code>zlib</code> usage.</p>
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-<span class="hljs-keyword">const</span> request = http.get({ <span class="hljs-attr">host</span>: <span class="hljs-string">'example.com'</span>,
+<span class="hljs-keyword">const</span> request = http.<span class="hljs-title function_">get</span>({ <span class="hljs-attr">host</span>: <span class="hljs-string">'example.com'</span>,
                            <span class="hljs-attr">path</span>: <span class="hljs-string">'/'</span>,
                            <span class="hljs-attr">port</span>: <span class="hljs-number">80</span>,
                            <span class="hljs-attr">headers</span>: { <span class="hljs-string">'Accept-Encoding'</span>: <span class="hljs-string">'br,gzip,deflate'</span> } });
-request.on(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">response</span>) =></span> {
-  <span class="hljs-keyword">const</span> output = fs.createWriteStream(<span class="hljs-string">'example.com_index.html'</span>);
+request.<span class="hljs-title function_">on</span>(<span class="hljs-string">'response'</span>, <span class="hljs-function">(<span class="hljs-params">response</span>) =></span> {
+  <span class="hljs-keyword">const</span> output = fs.<span class="hljs-title function_">createWriteStream</span>(<span class="hljs-string">'example.com_index.html'</span>);
 
-  <span class="hljs-keyword">const</span> onError = <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">const</span> <span class="hljs-title function_">onError</span> = (<span class="hljs-params">err</span>) => {
     <span class="hljs-keyword">if</span> (err) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-      process.exitCode = <span class="hljs-number">1</span>;
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+      process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
     }
   };
 
-  <span class="hljs-keyword">switch</span> (response.headers[<span class="hljs-string">'content-encoding'</span>]) {
+  <span class="hljs-keyword">switch</span> (response.<span class="hljs-property">headers</span>[<span class="hljs-string">'content-encoding'</span>]) {
     <span class="hljs-keyword">case</span> <span class="hljs-string">'br'</span>:
-      pipeline(response, zlib.createBrotliDecompress(), output, onError);
+      <span class="hljs-title function_">pipeline</span>(response, zlib.<span class="hljs-title function_">createBrotliDecompress</span>(), output, onError);
       <span class="hljs-keyword">break</span>;
     <span class="hljs-comment">// Or, just use zlib.createUnzip() to handle both of the following cases:</span>
     <span class="hljs-keyword">case</span> <span class="hljs-string">'gzip'</span>:
-      pipeline(response, zlib.createGunzip(), output, onError);
+      <span class="hljs-title function_">pipeline</span>(response, zlib.<span class="hljs-title function_">createGunzip</span>(), output, onError);
       <span class="hljs-keyword">break</span>;
     <span class="hljs-keyword">case</span> <span class="hljs-string">'deflate'</span>:
-      pipeline(response, zlib.createInflate(), output, onError);
+      <span class="hljs-title function_">pipeline</span>(response, zlib.<span class="hljs-title function_">createInflate</span>(), output, onError);
       <span class="hljs-keyword">break</span>;
-    <span class="hljs-keyword">default</span>:
-      pipeline(response, output, onError);
+    <span class="hljs-attr">default</span>:
+      <span class="hljs-title function_">pipeline</span>(response, output, onError);
       <span class="hljs-keyword">break</span>;
   }
 });</code></pre>
@@ -363,70 +375,70 @@ request.on(<span class="hljs-string">'response'</span>, <span class="hljs-functi
 <span class="hljs-keyword">const</span> fs = <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
 <span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-http.createServer(<span class="hljs-function">(<span class="hljs-params">request, response</span>) =></span> {
-  <span class="hljs-keyword">const</span> raw = fs.createReadStream(<span class="hljs-string">'index.html'</span>);
+http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">request, response</span>) =></span> {
+  <span class="hljs-keyword">const</span> raw = fs.<span class="hljs-title function_">createReadStream</span>(<span class="hljs-string">'index.html'</span>);
   <span class="hljs-comment">// Store both a compressed and an uncompressed version of the resource.</span>
-  response.setHeader(<span class="hljs-string">'Vary'</span>, <span class="hljs-string">'Accept-Encoding'</span>);
-  <span class="hljs-keyword">let</span> acceptEncoding = request.headers[<span class="hljs-string">'accept-encoding'</span>];
+  response.<span class="hljs-title function_">setHeader</span>(<span class="hljs-string">'Vary'</span>, <span class="hljs-string">'Accept-Encoding'</span>);
+  <span class="hljs-keyword">let</span> acceptEncoding = request.<span class="hljs-property">headers</span>[<span class="hljs-string">'accept-encoding'</span>];
   <span class="hljs-keyword">if</span> (!acceptEncoding) {
     acceptEncoding = <span class="hljs-string">''</span>;
   }
 
-  <span class="hljs-keyword">const</span> onError = <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-keyword">const</span> <span class="hljs-title function_">onError</span> = (<span class="hljs-params">err</span>) => {
     <span class="hljs-keyword">if</span> (err) {
       <span class="hljs-comment">// If an error occurs, there's not much we can do because</span>
       <span class="hljs-comment">// the server has already sent the 200 response code and</span>
       <span class="hljs-comment">// some amount of data has already been sent to the client.</span>
       <span class="hljs-comment">// The best we can do is terminate the response immediately</span>
       <span class="hljs-comment">// and log the error.</span>
-      response.end();
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
+      response.<span class="hljs-title function_">end</span>();
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
     }
   };
 
   <span class="hljs-comment">// Note: This is not a conformant accept-encoding parser.</span>
   <span class="hljs-comment">// See https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3</span>
-  <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bdeflate\b/</span>.test(acceptEncoding)) {
-    response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'deflate'</span> });
-    pipeline(raw, zlib.createDeflate(), response, onError);
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bgzip\b/</span>.test(acceptEncoding)) {
-    response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'gzip'</span> });
-    pipeline(raw, zlib.createGzip(), response, onError);
-  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bbr\b/</span>.test(acceptEncoding)) {
-    response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'br'</span> });
-    pipeline(raw, zlib.createBrotliCompress(), response, onError);
+  <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bdeflate\b/</span>.<span class="hljs-title function_">test</span>(acceptEncoding)) {
+    response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'deflate'</span> });
+    <span class="hljs-title function_">pipeline</span>(raw, zlib.<span class="hljs-title function_">createDeflate</span>(), response, onError);
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bgzip\b/</span>.<span class="hljs-title function_">test</span>(acceptEncoding)) {
+    response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'gzip'</span> });
+    <span class="hljs-title function_">pipeline</span>(raw, zlib.<span class="hljs-title function_">createGzip</span>(), response, onError);
+  } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-regexp">/\bbr\b/</span>.<span class="hljs-title function_">test</span>(acceptEncoding)) {
+    response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'Content-Encoding'</span>: <span class="hljs-string">'br'</span> });
+    <span class="hljs-title function_">pipeline</span>(raw, zlib.<span class="hljs-title function_">createBrotliCompress</span>(), response, onError);
   } <span class="hljs-keyword">else</span> {
-    response.writeHead(<span class="hljs-number">200</span>, {});
-    pipeline(raw, response, onError);
+    response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, {});
+    <span class="hljs-title function_">pipeline</span>(raw, response, onError);
   }
-}).listen(<span class="hljs-number">1337</span>);</code></pre>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
 <p>By default, the <code>zlib</code> methods will throw an error when decompressing
 truncated data. However, if it is known that the data is incomplete, or
 the desire is to inspect only the beginning of a compressed file, it is
 possible to suppress the default error handling by changing the flushing
 method that is used to decompress the last chunk of input data:</p>
 <pre><code class="language-js"><span class="hljs-comment">// This is a truncated version of the buffer from the above examples</span>
-<span class="hljs-keyword">const</span> buffer = Buffer.from(<span class="hljs-string">'eJzT0yMA'</span>, <span class="hljs-string">'base64'</span>);
+<span class="hljs-keyword">const</span> buffer = <span class="hljs-title class_">Buffer</span>.<span class="hljs-title function_">from</span>(<span class="hljs-string">'eJzT0yMA'</span>, <span class="hljs-string">'base64'</span>);
 
-zlib.unzip(
+zlib.<span class="hljs-title function_">unzip</span>(
   buffer,
   <span class="hljs-comment">// For Brotli, the equivalent is zlib.constants.BROTLI_OPERATION_FLUSH.</span>
-  { <span class="hljs-attr">finishFlush</span>: zlib.constants.Z_SYNC_FLUSH },
+  { <span class="hljs-attr">finishFlush</span>: zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">Z_SYNC_FLUSH</span> },
   <span class="hljs-function">(<span class="hljs-params">err, buffer</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) {
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
-      process.exitCode = <span class="hljs-number">1</span>;
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
+      process.<span class="hljs-property">exitCode</span> = <span class="hljs-number">1</span>;
     }
-    <span class="hljs-built_in">console</span>.log(buffer.toString());
+    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(buffer.<span class="hljs-title function_">toString</span>());
   });</code></pre>
 <p>This will not change the behavior in other error-throwing situations, e.g.
 when the input data has an invalid format. Using this method, it will not be
 possible to determine whether the input ended prematurely or lacks the
 integrity checks, making it necessary to manually check that the
 decompressed result is valid.</p>
-<h2>Memory usage tuning<span><a class="mark" href="#zlib_memory_usage_tuning" id="zlib_memory_usage_tuning">#</a></span></h2>
+</section><section><h3>Memory usage tuning<span><a class="mark" href="#zlib_memory_usage_tuning" id="zlib_memory_usage_tuning">#</a></span></h3>
 
-<h3>For zlib-based streams<span><a class="mark" href="#zlib_for_zlib_based_streams" id="zlib_for_zlib_based_streams">#</a></span></h3>
+<h4>For zlib-based streams<span><a class="mark" href="#zlib_for_zlib_based_streams" id="zlib_for_zlib_based_streams">#</a></span></h4>
 <p>From <code>zlib/zconf.h</code>, modified for Node.js usage:</p>
 <p>The memory requirements for deflate are (in bytes):</p>
 <!-- eslint-disable semi -->
@@ -450,7 +462,7 @@ compression, but will be much faster.</p>
 fewer calls to <code>zlib</code> because it will be able to process more data on
 each <code>write</code> operation. So, this is another factor that affects the
 speed, at the cost of memory usage.</p>
-<h3>For Brotli-based streams<span><a class="mark" href="#zlib_for_brotli_based_streams" id="zlib_for_brotli_based_streams">#</a></span></h3>
+<h4>For Brotli-based streams<span><a class="mark" href="#zlib_for_brotli_based_streams" id="zlib_for_brotli_based_streams">#</a></span></h4>
 <p>There are equivalents to the zlib options for Brotli-based streams, although
 these options have different ranges than the zlib ones:</p>
 <ul>
@@ -458,7 +470,7 @@ these options have different ranges than the zlib ones:</p>
 <li>zlib’s <code>windowBits</code> option matches Brotli’s <code>BROTLI_PARAM_LGWIN</code> option.</li>
 </ul>
 <p>See <a href="#zlib_brotli_constants">below</a> for more details on Brotli-specific options.</p>
-<h2>Flushing<span><a class="mark" href="#zlib_flushing" id="zlib_flushing">#</a></span></h2>
+</section><section><h3>Flushing<span><a class="mark" href="#zlib_flushing" id="zlib_flushing">#</a></span></h3>
 <p>Calling <a href="#zlib_zlib_flush_kind_callback"><code>.flush()</code></a> on a compression stream will make <code>zlib</code> return as much
 output as currently possible. This may come at the cost of degraded compression
 quality, but can be useful when data needs to be available as soon as possible.</p>
@@ -468,13 +480,13 @@ HTTP response to the client:</p>
 <span class="hljs-keyword">const</span> http = <span class="hljs-built_in">require</span>(<span class="hljs-string">'http'</span>);
 <span class="hljs-keyword">const</span> { pipeline } = <span class="hljs-built_in">require</span>(<span class="hljs-string">'stream'</span>);
 
-http.createServer(<span class="hljs-function">(<span class="hljs-params">request, response</span>) =></span> {
+http.<span class="hljs-title function_">createServer</span>(<span class="hljs-function">(<span class="hljs-params">request, response</span>) =></span> {
   <span class="hljs-comment">// For the sake of simplicity, the Accept-Encoding checks are omitted.</span>
-  response.writeHead(<span class="hljs-number">200</span>, { <span class="hljs-string">'content-encoding'</span>: <span class="hljs-string">'gzip'</span> });
-  <span class="hljs-keyword">const</span> output = zlib.createGzip();
+  response.<span class="hljs-title function_">writeHead</span>(<span class="hljs-number">200</span>, { <span class="hljs-string">'content-encoding'</span>: <span class="hljs-string">'gzip'</span> });
+  <span class="hljs-keyword">const</span> output = zlib.<span class="hljs-title function_">createGzip</span>();
   <span class="hljs-keyword">let</span> i;
 
-  pipeline(output, response, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
+  <span class="hljs-title function_">pipeline</span>(output, response, <span class="hljs-function">(<span class="hljs-params">err</span>) =></span> {
     <span class="hljs-keyword">if</span> (err) {
       <span class="hljs-comment">// If an error occurs, there's not much we can do because</span>
       <span class="hljs-comment">// the server has already sent the 200 response code and</span>
@@ -482,27 +494,27 @@ http.createServer(<span class="hljs-function">(<span class="hljs-params">request
       <span class="hljs-comment">// The best we can do is terminate the response immediately</span>
       <span class="hljs-comment">// and log the error.</span>
       <span class="hljs-built_in">clearInterval</span>(i);
-      response.end();
-      <span class="hljs-built_in">console</span>.error(<span class="hljs-string">'An error occurred:'</span>, err);
+      response.<span class="hljs-title function_">end</span>();
+      <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'An error occurred:'</span>, err);
     }
   });
 
   i = <span class="hljs-built_in">setInterval</span>(<span class="hljs-function">() =></span> {
-    output.write(<span class="hljs-string">`The current time is <span class="hljs-subst">${<span class="hljs-built_in">Date</span>()}</span>\n`</span>, <span class="hljs-function">() =></span> {
+    output.<span class="hljs-title function_">write</span>(<span class="hljs-string">`The current time is <span class="hljs-subst">${<span class="hljs-built_in">Date</span>()}</span>\n`</span>, <span class="hljs-function">() =></span> {
       <span class="hljs-comment">// The data has been passed to zlib, but the compression algorithm may</span>
       <span class="hljs-comment">// have decided to buffer the data for more efficient compression.</span>
       <span class="hljs-comment">// Calling .flush() will make the data available as soon as the client</span>
       <span class="hljs-comment">// is ready to receive it.</span>
-      output.flush();
+      output.<span class="hljs-title function_">flush</span>();
     });
   }, <span class="hljs-number">1000</span>);
-}).listen(<span class="hljs-number">1337</span>);</code></pre>
-<h2>Constants<span><a class="mark" href="#zlib_constants" id="zlib_constants">#</a></span></h2>
+}).<span class="hljs-title function_">listen</span>(<span class="hljs-number">1337</span>);</code></pre>
+</section><section><h3>Constants<span><a class="mark" href="#zlib_constants" id="zlib_constants">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 
-<h3>zlib constants<span><a class="mark" href="#zlib_zlib_constants" id="zlib_zlib_constants">#</a></span></h3>
+<h4>zlib constants<span><a class="mark" href="#zlib_zlib_constants" id="zlib_zlib_constants">#</a></span></h4>
 <p>All of the constants defined in <code>zlib.h</code> are also defined on
 <code>require('zlib').constants</code>. In the normal course of operations, it will not be
 necessary to use these constants. They are documented so that their presence is
@@ -550,13 +562,13 @@ events.</p>
 <li><code>zlib.constants.Z_FIXED</code></li>
 <li><code>zlib.constants.Z_DEFAULT_STRATEGY</code></li>
 </ul>
-<h3>Brotli constants<span><a class="mark" href="#zlib_brotli_constants" id="zlib_brotli_constants">#</a></span></h3>
+<h4>Brotli constants<span><a class="mark" href="#zlib_brotli_constants" id="zlib_brotli_constants">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <p>There are several options and other constants available for Brotli-based
 streams:</p>
-<h4>Flush operations<span><a class="mark" href="#zlib_flush_operations" id="zlib_flush_operations">#</a></span></h4>
+<h5>Flush operations<span><a class="mark" href="#zlib_flush_operations" id="zlib_flush_operations">#</a></span></h5>
 <p>The following values are valid flush operations for Brotli-based streams:</p>
 <ul>
 <li><code>zlib.constants.BROTLI_OPERATION_PROCESS</code> (default for all operations)</li>
@@ -571,7 +583,7 @@ the Node.js API.</li>
 </ul>
 </li>
 </ul>
-<h4>Compressor options<span><a class="mark" href="#zlib_compressor_options" id="zlib_compressor_options">#</a></span></h4>
+<h5>Compressor options<span><a class="mark" href="#zlib_compressor_options" id="zlib_compressor_options">#</a></span></h5>
 <p>There are several options that can be set on Brotli encoders, affecting
 compression efficiency and speed. Both the keys and the values can be accessed
 as properties of the <code>zlib.constants</code> object.</p>
@@ -636,7 +648,7 @@ Brotli format as standardized in <a href="https://www.rfc-editor.org/rfc/rfc7932
 </ul>
 </li>
 </ul>
-<h4>Decompressor options<span><a class="mark" href="#zlib_decompressor_options" id="zlib_decompressor_options">#</a></span></h4>
+<h5>Decompressor options<span><a class="mark" href="#zlib_decompressor_options" id="zlib_decompressor_options">#</a></span></h5>
 <p>These advanced options are available for controlling decompression:</p>
 <ul>
 <li><code>BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION</code>
@@ -651,12 +663,12 @@ Brotli format as standardized in <a href="https://www.rfc-editor.org/rfc/rfc7932
 </ul>
 </li>
 </ul>
-<h2>Class: <code>Options</code><span><a class="mark" href="#zlib_class_options" id="zlib_class_options">#</a></span></h2>
+</section><section><h3>Class: <code>Options</code><span><a class="mark" href="#zlib_class_options" id="zlib_class_options">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0, v12.19.0</td>
 <td><p>The <code>maxOutputLength</code> option is supported now.</p></td></tr>
 <tr><td>v9.4.0</td>
 <td><p>The <code>dictionary</code> option can be an <code>ArrayBuffer</code>.</p></td></tr>
@@ -689,12 +701,12 @@ empty dictionary by default)</li>
 </ul>
 <p>See the <a href="https://zlib.net/manual.html#Advanced"><code>deflateInit2</code> and <code>inflateInit2</code></a> documentation for more
 information.</p>
-<h2>Class: <code>BrotliOptions</code><span><a class="mark" href="#zlib_class_brotlioptions" id="zlib_class_brotlioptions">#</a></span></h2>
+</section><section><h3>Class: <code>BrotliOptions</code><span><a class="mark" href="#zlib_class_brotlioptions" id="zlib_class_brotlioptions">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v12.19.0</td>
+<tr><td>v14.5.0</td>
 <td><p>The <code>maxOutputLength</code> option is supported now.</p></td></tr>
 <tr><td>v11.7.0</td>
 <td><p><span>Added in: v11.7.0</span></p></td></tr>
@@ -712,35 +724,35 @@ information.</p>
 <a href="#zlib_convenience_methods">convenience methods</a>. <strong>Default:</strong> <a href="buffer.html#buffer_buffer_kmaxlength"><code>buffer.kMaxLength</code></a></li>
 </ul>
 <p>For example:</p>
-<pre><code class="language-js"><span class="hljs-keyword">const</span> stream = zlib.createBrotliCompress({
+<pre><code class="language-js"><span class="hljs-keyword">const</span> stream = zlib.<span class="hljs-title function_">createBrotliCompress</span>({
   <span class="hljs-attr">chunkSize</span>: <span class="hljs-number">32</span> * <span class="hljs-number">1024</span>,
   <span class="hljs-attr">params</span>: {
-    [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
-    [zlib.constants.BROTLI_PARAM_QUALITY]: <span class="hljs-number">4</span>,
-    [zlib.constants.BROTLI_PARAM_SIZE_HINT]: fs.statSync(inputFile).size
+    [zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">BROTLI_PARAM_MODE</span>]: zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">BROTLI_MODE_TEXT</span>,
+    [zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">BROTLI_PARAM_QUALITY</span>]: <span class="hljs-number">4</span>,
+    [zlib.<span class="hljs-property">constants</span>.<span class="hljs-property">BROTLI_PARAM_SIZE_HINT</span>]: fs.<span class="hljs-title function_">statSync</span>(inputFile).<span class="hljs-property">size</span>
   }
 });</code></pre>
-<h2>Class: <code>zlib.BrotliCompress</code><span><a class="mark" href="#zlib_class_zlib_brotlicompress" id="zlib_class_zlib_brotlicompress">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.BrotliCompress</code><span><a class="mark" href="#zlib_class_zlib_brotlicompress" id="zlib_class_zlib_brotlicompress">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <p>Compress data using the Brotli algorithm.</p>
-<h2>Class: <code>zlib.BrotliDecompress</code><span><a class="mark" href="#zlib_class_zlib_brotlidecompress" id="zlib_class_zlib_brotlidecompress">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.BrotliDecompress</code><span><a class="mark" href="#zlib_class_zlib_brotlidecompress" id="zlib_class_zlib_brotlidecompress">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <p>Decompress data using the Brotli algorithm.</p>
-<h2>Class: <code>zlib.Deflate</code><span><a class="mark" href="#zlib_class_zlib_deflate" id="zlib_class_zlib_deflate">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Deflate</code><span><a class="mark" href="#zlib_class_zlib_deflate" id="zlib_class_zlib_deflate">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>Compress data using deflate.</p>
-<h2>Class: <code>zlib.DeflateRaw</code><span><a class="mark" href="#zlib_class_zlib_deflateraw" id="zlib_class_zlib_deflateraw">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.DeflateRaw</code><span><a class="mark" href="#zlib_class_zlib_deflateraw" id="zlib_class_zlib_deflateraw">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>Compress data using deflate, and do not append a <code>zlib</code> header.</p>
-<h2>Class: <code>zlib.Gunzip</code><span><a class="mark" href="#zlib_class_zlib_gunzip" id="zlib_class_zlib_gunzip">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Gunzip</code><span><a class="mark" href="#zlib_class_zlib_gunzip" id="zlib_class_zlib_gunzip">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -757,12 +769,12 @@ information.</p>
 </details>
 </div>
 <p>Decompress a gzip stream.</p>
-<h2>Class: <code>zlib.Gzip</code><span><a class="mark" href="#zlib_class_zlib_gzip" id="zlib_class_zlib_gzip">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Gzip</code><span><a class="mark" href="#zlib_class_zlib_gzip" id="zlib_class_zlib_gzip">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>Compress data using gzip.</p>
-<h2>Class: <code>zlib.Inflate</code><span><a class="mark" href="#zlib_class_zlib_inflate" id="zlib_class_zlib_inflate">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Inflate</code><span><a class="mark" href="#zlib_class_zlib_inflate" id="zlib_class_zlib_inflate">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -775,7 +787,7 @@ information.</p>
 </details>
 </div>
 <p>Decompress a deflate stream.</p>
-<h2>Class: <code>zlib.InflateRaw</code><span><a class="mark" href="#zlib_class_zlib_inflateraw" id="zlib_class_zlib_inflateraw">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.InflateRaw</code><span><a class="mark" href="#zlib_class_zlib_inflateraw" id="zlib_class_zlib_inflateraw">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -790,18 +802,18 @@ information.</p>
 </details>
 </div>
 <p>Decompress a raw deflate stream.</p>
-<h2>Class: <code>zlib.Unzip</code><span><a class="mark" href="#zlib_class_zlib_unzip" id="zlib_class_zlib_unzip">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.Unzip</code><span><a class="mark" href="#zlib_class_zlib_unzip" id="zlib_class_zlib_unzip">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
 <p>Decompress either a Gzip- or Deflate-compressed stream by auto-detecting
 the header.</p>
-<h2>Class: <code>zlib.ZlibBase</code><span><a class="mark" href="#zlib_class_zlib_zlibbase" id="zlib_class_zlib_zlibbase">#</a></span></h2>
+</section><section><h3>Class: <code>zlib.ZlibBase</code><span><a class="mark" href="#zlib_class_zlib_zlibbase" id="zlib_class_zlib_zlibbase">#</a></span></h3>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
 <tbody><tr><th>Version</th><th>Changes</th></tr>
-<tr><td>v11.7.0</td>
+<tr><td>v11.7.0, v10.16.0</td>
 <td><p>This class was renamed from <code>Zlib</code> to <code>ZlibBase</code>.</p></td></tr>
 <tr><td>v0.5.8</td>
 <td><p><span>Added in: v0.5.8</span></p></td></tr>
@@ -812,7 +824,7 @@ the header.</p>
 class of the compressor/decompressor classes.</p>
 <p>This class inherits from <a href="stream.html#stream_class_stream_transform"><code>stream.Transform</code></a>, allowing <code>zlib</code> objects to be
 used in pipes and similar stream operations.</p>
-<h3><code>zlib.bytesRead</code><span><a class="mark" href="#zlib_zlib_bytesread" id="zlib_zlib_bytesread">#</a></span></h3>
+<h4><code>zlib.bytesRead</code><span><a class="mark" href="#zlib_zlib_bytesread" id="zlib_zlib_bytesread">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v8.1.0</span><span>Deprecated since: v10.0.0</span>
 </div>
@@ -824,7 +836,7 @@ used in pipes and similar stream operations.</p>
 because it also made sense to interpret the value as the number of bytes
 read by the engine, but is inconsistent with other streams in Node.js that
 expose values under these names.</p>
-<h3><code>zlib.bytesWritten</code><span><a class="mark" href="#zlib_zlib_byteswritten" id="zlib_zlib_byteswritten">#</a></span></h3>
+<h4><code>zlib.bytesWritten</code><span><a class="mark" href="#zlib_zlib_byteswritten" id="zlib_zlib_byteswritten">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v10.0.0</span>
 </div>
@@ -834,7 +846,7 @@ expose values under these names.</p>
 <p>The <code>zlib.bytesWritten</code> property specifies the number of bytes written to
 the engine, before the bytes are processed (compressed or decompressed,
 as appropriate for the derived class).</p>
-<h3><code>zlib.close([callback])</code><span><a class="mark" href="#zlib_zlib_close_callback" id="zlib_zlib_close_callback">#</a></span></h3>
+<h4><code>zlib.close([callback])</code><span><a class="mark" href="#zlib_zlib_close_callback" id="zlib_zlib_close_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.9.4</span>
 </div>
@@ -842,7 +854,7 @@ as appropriate for the derived class).</p>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
 <p>Close the underlying handle.</p>
-<h3><code>zlib.flush([kind, ]callback)</code><span><a class="mark" href="#zlib_zlib_flush_kind_callback" id="zlib_zlib_flush_kind_callback">#</a></span></h3>
+<h4><code>zlib.flush([kind, ]callback)</code><span><a class="mark" href="#zlib_zlib_flush_kind_callback" id="zlib_zlib_flush_kind_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -857,7 +869,7 @@ impact the effectiveness of the compression algorithm.</p>
 perform flushing of any kind on the streams level. Rather, it behaves like a
 normal call to <code>.write()</code>, i.e. it will be queued up behind other pending
 writes and will only produce output when data is being read from the stream.</p>
-<h3><code>zlib.params(level, strategy, callback)</code><span><a class="mark" href="#zlib_zlib_params_level_strategy_callback" id="zlib_zlib_params_level_strategy_callback">#</a></span></h3>
+<h4><code>zlib.params(level, strategy, callback)</code><span><a class="mark" href="#zlib_zlib_params_level_strategy_callback" id="zlib_zlib_params_level_strategy_callback">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.11.4</span>
 </div>
@@ -869,34 +881,34 @@ writes and will only produce output when data is being read from the stream.</p>
 <p>This function is only available for zlib-based streams, i.e. not Brotli.</p>
 <p>Dynamically update the compression level and compression strategy.
 Only applicable to deflate algorithm.</p>
-<h3><code>zlib.reset()</code><span><a class="mark" href="#zlib_zlib_reset" id="zlib_zlib_reset">#</a></span></h3>
+<h4><code>zlib.reset()</code><span><a class="mark" href="#zlib_zlib_reset" id="zlib_zlib_reset">#</a></span></h4>
 <div class="api_metadata">
 <span>Added in: v0.7.0</span>
 </div>
 <p>Reset the compressor/decompressor to factory defaults. Only applicable to
 the inflate and deflate algorithms.</p>
-<h2><code>zlib.constants</code><span><a class="mark" href="#zlib_zlib_constants_1" id="zlib_zlib_constants_1">#</a></span></h2>
+</section><section><h3><code>zlib.constants</code><span><a class="mark" href="#zlib_zlib_constants_1" id="zlib_zlib_constants_1">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v7.0.0</span>
 </div>
 <p>Provides an object enumerating Zlib-related constants.</p>
-<h2><code>zlib.createBrotliCompress([options])</code><span><a class="mark" href="#zlib_zlib_createbrotlicompress_options" id="zlib_zlib_createbrotlicompress_options">#</a></span></h2>
+</section><section><h3><code>zlib.createBrotliCompress([options])</code><span><a class="mark" href="#zlib_zlib_createbrotlicompress_options" id="zlib_zlib_createbrotlicompress_options">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="zlib.html#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_brotlicompress"><code>BrotliCompress</code></a> object.</p>
-<h2><code>zlib.createBrotliDecompress([options])</code><span><a class="mark" href="#zlib_zlib_createbrotlidecompress_options" id="zlib_zlib_createbrotlidecompress_options">#</a></span></h2>
+</section><section><h3><code>zlib.createBrotliDecompress([options])</code><span><a class="mark" href="#zlib_zlib_createbrotlidecompress_options" id="zlib_zlib_createbrotlidecompress_options">#</a></span></h3>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>options</code> <a href="zlib.html#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_brotlidecompress"><code>BrotliDecompress</code></a> object.</p>
-<h2><code>zlib.createDeflate([options])</code><span><a class="mark" href="#zlib_zlib_createdeflate_options" id="zlib_zlib_createdeflate_options">#</a></span></h2>
+</section><section><h3><code>zlib.createDeflate([options])</code><span><a class="mark" href="#zlib_zlib_createdeflate_options" id="zlib_zlib_createdeflate_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -904,7 +916,7 @@ the inflate and deflate algorithms.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_deflate"><code>Deflate</code></a> object.</p>
-<h2><code>zlib.createDeflateRaw([options])</code><span><a class="mark" href="#zlib_zlib_createdeflateraw_options" id="zlib_zlib_createdeflateraw_options">#</a></span></h2>
+</section><section><h3><code>zlib.createDeflateRaw([options])</code><span><a class="mark" href="#zlib_zlib_createdeflateraw_options" id="zlib_zlib_createdeflateraw_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -918,7 +930,7 @@ to 9 if was initially set to 8. Newer versions of zlib will throw an exception,
 so Node.js restored the original behavior of upgrading a value of 8 to 9,
 since passing <code>windowBits = 9</code> to zlib actually results in a compressed stream
 that effectively uses an 8-bit window only.</p>
-<h2><code>zlib.createGunzip([options])</code><span><a class="mark" href="#zlib_zlib_creategunzip_options" id="zlib_zlib_creategunzip_options">#</a></span></h2>
+</section><section><h3><code>zlib.createGunzip([options])</code><span><a class="mark" href="#zlib_zlib_creategunzip_options" id="zlib_zlib_creategunzip_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -926,7 +938,7 @@ that effectively uses an 8-bit window only.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_gunzip"><code>Gunzip</code></a> object.</p>
-<h2><code>zlib.createGzip([options])</code><span><a class="mark" href="#zlib_zlib_creategzip_options" id="zlib_zlib_creategzip_options">#</a></span></h2>
+</section><section><h3><code>zlib.createGzip([options])</code><span><a class="mark" href="#zlib_zlib_creategzip_options" id="zlib_zlib_creategzip_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -935,7 +947,7 @@ that effectively uses an 8-bit window only.</p>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_gzip"><code>Gzip</code></a> object.
 See <a href="#zlib_zlib">example</a>.</p>
-<h2><code>zlib.createInflate([options])</code><span><a class="mark" href="#zlib_zlib_createinflate_options" id="zlib_zlib_createinflate_options">#</a></span></h2>
+</section><section><h3><code>zlib.createInflate([options])</code><span><a class="mark" href="#zlib_zlib_createinflate_options" id="zlib_zlib_createinflate_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -943,7 +955,7 @@ See <a href="#zlib_zlib">example</a>.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_inflate"><code>Inflate</code></a> object.</p>
-<h2><code>zlib.createInflateRaw([options])</code><span><a class="mark" href="#zlib_zlib_createinflateraw_options" id="zlib_zlib_createinflateraw_options">#</a></span></h2>
+</section><section><h3><code>zlib.createInflateRaw([options])</code><span><a class="mark" href="#zlib_zlib_createinflateraw_options" id="zlib_zlib_createinflateraw_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -951,7 +963,7 @@ See <a href="#zlib_zlib">example</a>.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_inflateraw"><code>InflateRaw</code></a> object.</p>
-<h2><code>zlib.createUnzip([options])</code><span><a class="mark" href="#zlib_zlib_createunzip_options" id="zlib_zlib_createunzip_options">#</a></span></h2>
+</section><section><h3><code>zlib.createUnzip([options])</code><span><a class="mark" href="#zlib_zlib_createunzip_options" id="zlib_zlib_createunzip_options">#</a></span></h3>
 <div class="api_metadata">
 <span>Added in: v0.5.8</span>
 </div>
@@ -959,7 +971,7 @@ See <a href="#zlib_zlib">example</a>.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Creates and returns a new <a href="#zlib_class_zlib_unzip"><code>Unzip</code></a> object.</p>
-<h2>Convenience methods<span><a class="mark" href="#zlib_convenience_methods" id="zlib_convenience_methods">#</a></span></h2>
+</section><section><h3>Convenience methods<span><a class="mark" href="#zlib_convenience_methods" id="zlib_convenience_methods">#</a></span></h3>
 
 <p>All of these take a <a href="buffer.html#buffer_class_buffer"><code>Buffer</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray"><code>TypedArray</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView"><code>DataView</code></a>,
 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer"><code>ArrayBuffer</code></a> or string as the first argument, an optional second argument
@@ -967,43 +979,43 @@ to supply options to the <code>zlib</code> classes and will call the supplied ca
 with <code>callback(error, result)</code>.</p>
 <p>Every method has a <code>*Sync</code> counterpart, which accept the same arguments, but
 without a callback.</p>
-<h3><code>zlib.brotliCompress(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_brotlicompress_buffer_options_callback" id="zlib_zlib_brotlicompress_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.brotliCompress(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_brotlicompress_buffer_options_callback" id="zlib_zlib_brotlicompress_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="zlib.html#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.brotliCompressSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_brotlicompresssync_buffer_options" id="zlib_zlib_brotlicompresssync_buffer_options">#</a></span></h3>
+<h4><code>zlib.brotliCompressSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_brotlicompresssync_buffer_options" id="zlib_zlib_brotlicompresssync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="zlib.html#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 </ul>
 <p>Compress a chunk of data with <a href="#zlib_class_zlib_brotlicompress"><code>BrotliCompress</code></a>.</p>
-<h3><code>zlib.brotliDecompress(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_brotlidecompress_buffer_options_callback" id="zlib_zlib_brotlidecompress_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.brotliDecompress(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_brotlidecompress_buffer_options_callback" id="zlib_zlib_brotlidecompress_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="zlib.html#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.brotliDecompressSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_brotlidecompresssync_buffer_options" id="zlib_zlib_brotlidecompresssync_buffer_options">#</a></span></h3>
+<h4><code>zlib.brotliDecompressSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_brotlidecompresssync_buffer_options" id="zlib_zlib_brotlidecompresssync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
-<span>Added in: v11.7.0</span>
+<span>Added in: v11.7.0, v10.16.0</span>
 </div>
 <ul>
 <li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="zlib.html#zlib_class_brotlioptions" class="type">&#x3C;brotli options></a></li>
 </ul>
 <p>Decompress a chunk of data with <a href="#zlib_class_zlib_brotlidecompress"><code>BrotliDecompress</code></a>.</p>
-<h3><code>zlib.deflate(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_deflate_buffer_options_callback" id="zlib_zlib_deflate_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.deflate(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_deflate_buffer_options_callback" id="zlib_zlib_deflate_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1024,7 +1036,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.deflateSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_deflatesync_buffer_options" id="zlib_zlib_deflatesync_buffer_options">#</a></span></h3>
+<h4><code>zlib.deflateSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_deflatesync_buffer_options" id="zlib_zlib_deflatesync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1045,7 +1057,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Compress a chunk of data with <a href="#zlib_class_zlib_deflate"><code>Deflate</code></a>.</p>
-<h3><code>zlib.deflateRaw(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_deflateraw_buffer_options_callback" id="zlib_zlib_deflateraw_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.deflateRaw(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_deflateraw_buffer_options_callback" id="zlib_zlib_deflateraw_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1064,7 +1076,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.deflateRawSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_deflaterawsync_buffer_options" id="zlib_zlib_deflaterawsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.deflateRawSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_deflaterawsync_buffer_options" id="zlib_zlib_deflaterawsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1085,7 +1097,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Compress a chunk of data with <a href="#zlib_class_zlib_deflateraw"><code>DeflateRaw</code></a>.</p>
-<h3><code>zlib.gunzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_gunzip_buffer_options_callback" id="zlib_zlib_gunzip_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.gunzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_gunzip_buffer_options_callback" id="zlib_zlib_gunzip_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1106,7 +1118,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.gunzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_gunzipsync_buffer_options" id="zlib_zlib_gunzipsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.gunzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_gunzipsync_buffer_options" id="zlib_zlib_gunzipsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1127,7 +1139,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Decompress a chunk of data with <a href="#zlib_class_zlib_gunzip"><code>Gunzip</code></a>.</p>
-<h3><code>zlib.gzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_gzip_buffer_options_callback" id="zlib_zlib_gzip_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.gzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_gzip_buffer_options_callback" id="zlib_zlib_gzip_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1148,7 +1160,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.gzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_gzipsync_buffer_options" id="zlib_zlib_gzipsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.gzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_gzipsync_buffer_options" id="zlib_zlib_gzipsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1169,7 +1181,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Compress a chunk of data with <a href="#zlib_class_zlib_gzip"><code>Gzip</code></a>.</p>
-<h3><code>zlib.inflate(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_inflate_buffer_options_callback" id="zlib_zlib_inflate_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.inflate(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_inflate_buffer_options_callback" id="zlib_zlib_inflate_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1190,7 +1202,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.inflateSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_inflatesync_buffer_options" id="zlib_zlib_inflatesync_buffer_options">#</a></span></h3>
+<h4><code>zlib.inflateSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_inflatesync_buffer_options" id="zlib_zlib_inflatesync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1211,7 +1223,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Decompress a chunk of data with <a href="#zlib_class_zlib_inflate"><code>Inflate</code></a>.</p>
-<h3><code>zlib.inflateRaw(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_inflateraw_buffer_options_callback" id="zlib_zlib_inflateraw_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.inflateRaw(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_inflateraw_buffer_options_callback" id="zlib_zlib_inflateraw_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1232,7 +1244,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.inflateRawSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_inflaterawsync_buffer_options" id="zlib_zlib_inflaterawsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.inflateRawSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_inflaterawsync_buffer_options" id="zlib_zlib_inflaterawsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1253,7 +1265,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
 <p>Decompress a chunk of data with <a href="#zlib_class_zlib_inflateraw"><code>InflateRaw</code></a>.</p>
-<h3><code>zlib.unzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_unzip_buffer_options_callback" id="zlib_zlib_unzip_buffer_options_callback">#</a></span></h3>
+<h4><code>zlib.unzip(buffer[, options], callback)</code><span><a class="mark" href="#zlib_zlib_unzip_buffer_options_callback" id="zlib_zlib_unzip_buffer_options_callback">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1274,7 +1286,7 @@ without a callback.</p>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 <li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
 </ul>
-<h3><code>zlib.unzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_unzipsync_buffer_options" id="zlib_zlib_unzipsync_buffer_options">#</a></span></h3>
+<h4><code>zlib.unzipSync(buffer[, options])</code><span><a class="mark" href="#zlib_zlib_unzipsync_buffer_options" id="zlib_zlib_unzipsync_buffer_options">#</a></span></h4>
 <div class="api_metadata">
 <details class="changelog"><summary>History</summary>
 <table>
@@ -1294,10 +1306,46 @@ without a callback.</p>
 <li><code>buffer</code> <a href="buffer.html#buffer_class_buffer" class="type">&#x3C;Buffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray" class="type">&#x3C;TypedArray></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView" class="type">&#x3C;DataView></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer" class="type">&#x3C;ArrayBuffer></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
 <li><code>options</code> <a href="zlib.html#zlib_class_options" class="type">&#x3C;zlib options></a></li>
 </ul>
-<p>Decompress a chunk of data with <a href="#zlib_class_zlib_unzip"><code>Unzip</code></a>.</p>
+<p>Decompress a chunk of data with <a href="#zlib_class_zlib_unzip"><code>Unzip</code></a>.</p></section>
         <!-- API END -->
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/doc/api/zlib.json b/doc/api/zlib.json
index 57a9d39ed18f984de9dc56ac0b467bda1f0629d5..8bedd9f63cbd4b39eca439245f7c8e52da0ea3b1 100644
--- a/doc/api/zlib.json
+++ b/doc/api/zlib.json
@@ -8,7 +8,7 @@
       "introduced_in": "v0.10.0",
       "stability": 2,
       "stabilityText": "Stable",
-      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v12.22.7/lib/zlib.js\">lib/zlib.js</a></p>\n<p>The <code>zlib</code> module provides compression functionality implemented using Gzip,\nDeflate/Inflate, and Brotli.</p>\n<p>To access it:</p>\n<pre><code class=\"language-js\">const zlib = require('zlib');\n</code></pre>\n<p>Compression and decompression are built around the Node.js <a href=\"stream.md\">Streams API</a>.</p>\n<p>Compressing or decompressing a stream (such as a file) can be accomplished by\npiping the source stream through a <code>zlib</code> <code>Transform</code> stream into a destination\nstream:</p>\n<pre><code class=\"language-js\">const { createGzip } = require('zlib');\nconst { pipeline } = require('stream');\nconst {\n  createReadStream,\n  createWriteStream\n} = require('fs');\n\nconst gzip = createGzip();\nconst source = createReadStream('input.txt');\nconst destination = createWriteStream('input.txt.gz');\n\npipeline(source, gzip, destination, (err) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n});\n\n// Or, Promisified\n\nconst { promisify } = require('util');\nconst pipe = promisify(pipeline);\n\nasync function do_gzip(input, output) {\n  const gzip = createGzip();\n  const source = createReadStream(input);\n  const destination = createWriteStream(output);\n  await pipe(source, gzip, destination);\n}\n\ndo_gzip('input.txt', 'input.txt.gz')\n  .catch((err) => {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  });\n</code></pre>\n<p>It is also possible to compress or decompress data in a single step:</p>\n<pre><code class=\"language-js\">const { deflate, unzip } = require('zlib');\n\nconst input = '.................................';\ndeflate(input, (err, buffer) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n  console.log(buffer.toString('base64'));\n});\n\nconst buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');\nunzip(buffer, (err, buffer) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n  console.log(buffer.toString());\n});\n\n// Or, Promisified\n\nconst { promisify } = require('util');\nconst do_unzip = promisify(unzip);\n\ndo_unzip(buffer)\n  .then((buf) => console.log(buf.toString()))\n  .catch((err) => {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  });\n</code></pre>",
+      "desc": "<p><strong>Source Code:</strong> <a href=\"https://github.com/nodejs/node/blob/v14.18.3/lib/zlib.js\">lib/zlib.js</a></p>\n<p>The <code>zlib</code> module provides compression functionality implemented using Gzip,\nDeflate/Inflate, and Brotli.</p>\n<p>To access it:</p>\n<pre><code class=\"language-js\">const zlib = require('zlib');\n</code></pre>\n<p>Compression and decompression are built around the Node.js <a href=\"stream.html\">Streams API</a>.</p>\n<p>Compressing or decompressing a stream (such as a file) can be accomplished by\npiping the source stream through a <code>zlib</code> <code>Transform</code> stream into a destination\nstream:</p>\n<pre><code class=\"language-js\">const { createGzip } = require('zlib');\nconst { pipeline } = require('stream');\nconst {\n  createReadStream,\n  createWriteStream\n} = require('fs');\n\nconst gzip = createGzip();\nconst source = createReadStream('input.txt');\nconst destination = createWriteStream('input.txt.gz');\n\npipeline(source, gzip, destination, (err) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n});\n\n// Or, Promisified\n\nconst { promisify } = require('util');\nconst pipe = promisify(pipeline);\n\nasync function do_gzip(input, output) {\n  const gzip = createGzip();\n  const source = createReadStream(input);\n  const destination = createWriteStream(output);\n  await pipe(source, gzip, destination);\n}\n\ndo_gzip('input.txt', 'input.txt.gz')\n  .catch((err) => {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  });\n</code></pre>\n<p>It is also possible to compress or decompress data in a single step:</p>\n<pre><code class=\"language-js\">const { deflate, unzip } = require('zlib');\n\nconst input = '.................................';\ndeflate(input, (err, buffer) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n  console.log(buffer.toString('base64'));\n});\n\nconst buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');\nunzip(buffer, (err, buffer) => {\n  if (err) {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  }\n  console.log(buffer.toString());\n});\n\n// Or, Promisified\n\nconst { promisify } = require('util');\nconst do_unzip = promisify(unzip);\n\ndo_unzip(buffer)\n  .then((buf) => console.log(buf.toString()))\n  .catch((err) => {\n    console.error('An error occurred:', err);\n    process.exitCode = 1;\n  });\n</code></pre>",
       "modules": [
         {
           "textRaw": "Threadpool usage and performance considerations",
@@ -77,7 +77,8 @@
               "name": "brotli_constants",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -120,7 +121,10 @@
             ],
             "changes": [
               {
-                "version": "v12.19.0",
+                "version": [
+                  "v14.5.0",
+                  "v12.19.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/33516",
                 "description": "The `maxOutputLength` option is supported now."
               },
@@ -153,7 +157,7 @@
             ],
             "changes": [
               {
-                "version": "v12.19.0",
+                "version": "v14.5.0",
                 "pr-url": "https://github.com/nodejs/node/pull/33516",
                 "description": "The `maxOutputLength` option is supported now."
               }
@@ -173,7 +177,8 @@
               "name": "brotliCompress",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -205,7 +210,8 @@
               "name": "brotliCompressSync",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -233,7 +239,8 @@
               "name": "brotliDecompress",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -265,7 +272,8 @@
               "name": "brotliDecompressSync",
               "meta": {
                 "added": [
-                  "v11.7.0"
+                  "v11.7.0",
+                  "v10.16.0"
                 ],
                 "changes": []
               },
@@ -942,7 +950,8 @@
           "name": "zlib.BrotliCompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -954,7 +963,8 @@
           "name": "zlib.BrotliDecompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -1087,7 +1097,10 @@
             ],
             "changes": [
               {
-                "version": "v11.7.0",
+                "version": [
+                  "v11.7.0",
+                  "v10.16.0"
+                ],
                 "pr-url": "https://github.com/nodejs/node/pull/24939",
                 "description": "This class was renamed from `Zlib` to `ZlibBase`."
               }
@@ -1250,7 +1263,8 @@
           "name": "createBrotliCompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -1273,7 +1287,8 @@
           "name": "createBrotliDecompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -1457,7 +1472,8 @@
           "name": "brotliCompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -1489,7 +1505,8 @@
           "name": "brotliCompressSync",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -1517,7 +1534,8 @@
           "name": "brotliDecompress",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
@@ -1549,7 +1567,8 @@
           "name": "brotliDecompressSync",
           "meta": {
             "added": [
-              "v11.7.0"
+              "v11.7.0",
+              "v10.16.0"
             ],
             "changes": []
           },
diff --git a/doc/api/zlib.md b/doc/api/zlib.md
index a005069f6cf8c27aee0b6a3e92c6dca11c1082bd..e237d644eac800f97ed51f90426d02d3462da62e 100644
--- a/doc/api/zlib.md
+++ b/doc/api/zlib.md
@@ -413,7 +413,9 @@ Compression strategy.
 
 ### Brotli constants
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 There are several options and other constants available for Brotli-based
@@ -486,7 +488,9 @@ These advanced options are available for controlling decompression:
 <!-- YAML
 added: v0.11.1
 changes:
-  - version: v12.19.0
+  - version:
+    - v14.5.0
+    - v12.19.0
     pr-url: https://github.com/nodejs/node/pull/33516
     description: The `maxOutputLength` option is supported now.
   - version: v9.4.0
@@ -527,7 +531,7 @@ information.
 <!-- YAML
 added: v11.7.0
 changes:
-  - version: v12.19.0
+  - version: v14.5.0
     pr-url: https://github.com/nodejs/node/pull/33516
     description: The `maxOutputLength` option is supported now.
 -->
@@ -558,14 +562,18 @@ const stream = zlib.createBrotliCompress({
 
 ## Class: `zlib.BrotliCompress`
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 Compress data using the Brotli algorithm.
 
 ## Class: `zlib.BrotliDecompress`
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 Decompress data using the Brotli algorithm.
@@ -646,7 +654,9 @@ the header.
 <!-- YAML
 added: v0.5.8
 changes:
-  - version: v11.7.0
+  - version:
+     - v11.7.0
+     - v10.16.0
     pr-url: https://github.com/nodejs/node/pull/24939
     description: This class was renamed from `Zlib` to `ZlibBase`.
 -->
@@ -740,7 +750,9 @@ Provides an object enumerating Zlib-related constants.
 
 ## `zlib.createBrotliCompress([options])`
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 * `options` {brotli options}
@@ -749,7 +761,9 @@ Creates and returns a new [`BrotliCompress`][] object.
 
 ## `zlib.createBrotliDecompress([options])`
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 * `options` {brotli options}
@@ -841,7 +855,9 @@ without a callback.
 
 ### `zlib.brotliCompress(buffer[, options], callback)`
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 * `buffer` {Buffer|TypedArray|DataView|ArrayBuffer|string}
@@ -850,7 +866,9 @@ added: v11.7.0
 
 ### `zlib.brotliCompressSync(buffer[, options])`
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 * `buffer` {Buffer|TypedArray|DataView|ArrayBuffer|string}
@@ -860,7 +878,9 @@ Compress a chunk of data with [`BrotliCompress`][].
 
 ### `zlib.brotliDecompress(buffer[, options], callback)`
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 * `buffer` {Buffer|TypedArray|DataView|ArrayBuffer|string}
@@ -869,7 +889,9 @@ added: v11.7.0
 
 ### `zlib.brotliDecompressSync(buffer[, options])`
 <!-- YAML
-added: v11.7.0
+added:
+ - v11.7.0
+ - v10.16.0
 -->
 
 * `buffer` {Buffer|TypedArray|DataView|ArrayBuffer|string}
@@ -1147,13 +1169,16 @@ changes:
 
 Decompress a chunk of data with [`Unzip`][].
 
+[Brotli parameters]: #zlib_brotli_constants
+[Memory usage tuning]: #zlib_memory_usage_tuning
+[RFC 7932]: https://www.rfc-editor.org/rfc/rfc7932.txt
+[Streams API]: stream.md
 [`.flush()`]: #zlib_zlib_flush_kind_callback
 [`Accept-Encoding`]: https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3
 [`ArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
 [`BrotliCompress`]: #zlib_class_zlib_brotlicompress
 [`BrotliDecompress`]: #zlib_class_zlib_brotlidecompress
-[`Buffer`]: buffer.html#buffer_class_buffer
-[`buffer.kMaxLength`]: buffer.html#buffer_buffer_kmaxlength
+[`Buffer`]: buffer.md#buffer_class_buffer
 [`Content-Encoding`]: https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11
 [`DataView`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView
 [`DeflateRaw`]: #zlib_class_zlib_deflateraw
@@ -1164,13 +1189,10 @@ Decompress a chunk of data with [`Unzip`][].
 [`Inflate`]: #zlib_class_zlib_inflate
 [`TypedArray`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
 [`Unzip`]: #zlib_class_zlib_unzip
+[`buffer.kMaxLength`]: buffer.md#buffer_buffer_kmaxlength
 [`deflateInit2` and `inflateInit2`]: https://zlib.net/manual.html#Advanced
-[`stream.Transform`]: stream.html#stream_class_stream_transform
+[`stream.Transform`]: stream.md#stream_class_stream_transform
 [`zlib.bytesWritten`]: #zlib_zlib_byteswritten
-[Brotli parameters]: #zlib_brotli_constants
-[Memory usage tuning]: #zlib_memory_usage_tuning
-[RFC 7932]: https://www.rfc-editor.org/rfc/rfc7932.txt
-[Streams API]: stream.md
 [convenience methods]: #zlib_convenience_methods
 [zlib documentation]: https://zlib.net/manual.html#Constants
 [zlib.createGzip example]: #zlib_zlib
diff --git a/doc/api_assets/hljs.css b/doc/api_assets/hljs.css
index 026a93e194efc376c969b7a7bd987d95615bc714..4893f9de26fab4b9e067b49647f594ee7c07af1e 100644
--- a/doc/api_assets/hljs.css
+++ b/doc/api_assets/hljs.css
@@ -8,7 +8,8 @@
 }
 
 .hljs-attribute,
-.hljs-keyword {
+.hljs-keyword,
+.hljs-type {
   color: #338;
 }
 
@@ -28,3 +29,22 @@
   color: #666;
   font-weight: lighter;
 }
+
+.dark-mode .hljs-number,
+.dark-mode .hljs-string,
+.dark-mode .hljs-regexp {
+  color: var(--green4);
+}
+
+.dark-mode .hljs-attribute,
+.dark-mode .hljs-doctag,
+.dark-mode .hljs-keyword,
+.dark-mode .hljs-type {
+  color: #66d9ef;
+}
+
+.dark-mode .hljs-doctag .hljs-type,
+.dark-mode .hljs-doctag .hljs-variable,
+.dark-mode .hljs-comment {
+  color: var(--gray7);
+}
diff --git a/doc/api_assets/js-flavor-cjs.svg b/doc/api_assets/js-flavor-cjs.svg
new file mode 100644
index 0000000000000000000000000000000000000000..800c1516423059fa20e1fb0c96b9e3e6b6f42973
--- /dev/null
+++ b/doc/api_assets/js-flavor-cjs.svg
@@ -0,0 +1,5 @@
+<!--
+ * Font Awesome Free 5.15.2 by @fontawesome - https://fontawesome.com
+ * License - https://fontawesome.com/license/free - CC BY 4.0
+-->
+<svg xmlns="http://www.w3.org/2000/svg" width="2719" height="384"><path d="M1191.326 384h192c106 0 192-86 192-192s-86-192-192-192h-192c-106 0-192 86-192 192s86 192 192 192zm0-320c70.8 0 128 57.3 128 128 0 70.8-57.3 128-128 128-70.8 0-128-57.3-128-128 0-70.8 57.3-128 128-128z"/><text stroke-width="42" font-family="sans-serif" font-weight="lighter" font-size="490" y="370">CJS</text><text stroke-width="42" font-weight="lighter" font-family="sans-serif" font-size="490" y="370" x="1682">ESM</text></svg>
diff --git a/doc/api_assets/js-flavor-esm.svg b/doc/api_assets/js-flavor-esm.svg
new file mode 100644
index 0000000000000000000000000000000000000000..bcea3ba100698a4e2c111e5c1f197532ff1b0c3d
--- /dev/null
+++ b/doc/api_assets/js-flavor-esm.svg
@@ -0,0 +1,5 @@
+<!--
+ * Font Awesome Free 5.15.2 by @fontawesome - https://fontawesome.com
+ * License - https://fontawesome.com/license/free - CC BY 4.0
+-->
+<svg xmlns="http://www.w3.org/2000/svg" height="384" width="2719"><defs><path d="M-136.321-230.336h2994.365v653.401H-136.321z"/></defs><path d="M1383.326 0h-192c-106 0-192 86-192 192s86 192 192 192h192c106 0 192-86 192-192s-86-192-192-192zm0 320c-70.8 0-128-57.3-128-128 0-70.8 57.3-128 128-128 70.8 0 128 57.3 128 128 0 70.8-57.3 128-128 128z"/><text stroke-width="42" font-family="sans-serif" font-weight="lighter" font-size="490" y="370">CJS</text><text stroke-width="42" font-weight="lighter" font-family="sans-serif" font-size="490" y="370" x="1682">ESM</text></svg>
diff --git a/doc/api_assets/style.css b/doc/api_assets/style.css
index af170888be8f38e0a80e5abc9733c538eda89095..6faeb59efc04ddc55a6ebd75c17413cb6827e308 100644
--- a/doc/api_assets/style.css
+++ b/doc/api_assets/style.css
@@ -1,3 +1,61 @@
+/*--------------------- CSS Variables ----------------------------*/
+:root {
+  --black: #000000;
+  --black1: #090c15;
+  --black2: #2c3437;
+  --black3: #0d111d;
+  --blue1: #00f;
+  --white: #ffffff;
+  --white-smoke: #f2f2f2;
+  --grey-smoke: #e9edf0;
+  --red1: #d60027;
+  --red2: #d50027;
+  --red3: #ca5010;
+  --green1: #3e7a38;
+  --green2: #5a8147;
+  --green3: #64de64;
+  --green4: #99cc7d;
+  --green5: #84ba64;
+  --gray1: #707070;
+  --gray2: #b4b4b4;
+  --gray3: #cccccc;
+  --gray4: #040404;
+  --gray5: #7a7a7a;
+  --gray6: #333333;
+  --gray7: #c1c1c1;
+  --grey8: #ddd;
+
+  --background-color-api-stability-link: rgba(255, 255, 255, .4);
+  --background-color-highlight: var(--white-smoke);
+  --color-brand-primary: var(--gray6);
+  --color-brand-secondary: var(--green1);
+  --color-fill-app: var(--white);
+  --color-fill-side-nav: var(--gray6);
+  --color-links: var(--green1);
+  --color-text-mark: var(--gray1);
+  --color-text-nav: var(--gray3);
+  --color-text-primary: var(--gray6);
+  --color-text-secondary: var(--green2);
+}
+
+.dark-mode {
+  --background-color-highlight: var(--black2);
+  --color-fill-app: var(--black1);
+  --color-fill-side-nav: var(--black3);
+  --color-links: var(--green5);
+  --color-text-mark: var(--gray5);
+  --color-text-primary: var(--white);
+}
+
+.dark-mode code,
+.dark-mode tt {
+  color: var(--grey-smoke);
+  background-color: var(--background-color-highlight);
+}
+.dark-mode a code {
+  color: var(--green3);
+}
+
 /*--------------------- Layout and Typography ----------------------------*/
 html {
   font-size: 1rem;
@@ -16,8 +74,8 @@ body {
   font-family: Lato, "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", Verdana, Tahoma, sans-serif;
   margin: 0;
   padding: 0;
-  color: #333;
-  background-color: #fff;
+  color: var(--color-text-primary);
+  background-color: var(--color-fill-app);
 }
 
 h1, h1 code { font-size: 2.5rem; }
@@ -67,7 +125,7 @@ a.type {
 a:link,
 a:active,
 a:visited {
-  color: #43853d;
+  color: var(--color-links);
   text-decoration: none;
   border-radius: 2px;
   padding: 1px 3px;
@@ -75,8 +133,8 @@ a:visited {
 
 a:hover,
 a:focus {
-  color: #fff;
-  background-color: #43853d;
+  color: var(--white);
+  background-color:var(--green1);
   outline: none;
 }
 
@@ -109,7 +167,7 @@ em code {
 
 #gtoc > ul > li {
   display: inline;
-  border-right: 1px #000 solid;
+  border-right: 1px currentColor solid;
   margin-right: .4rem;
   padding-right: .4rem;
 }
@@ -138,8 +196,8 @@ li.version-picker a span {
 }
 
 ol.version-picker {
-  background-color: #fff;
-  border: 1px solid #43853d;
+  background-color: var(--color-fill-app);
+  border: 1px solid var(--color-brand-secondary);
   border-radius: 0 0 2px 2px;
   display: none;
   list-style: none;
@@ -175,14 +233,14 @@ ol.version-picker li:last-child a {
 }
 
 .api_stability {
-  color: #fff !important;
+  color: var(--white) !important;
   margin: 0 0 1rem;
   padding: 1rem;
   line-height: 1.5;
 }
 
 .api_stability * {
-  color: #fff !important;
+  color: var(--white) !important;
 }
 
 .api_stability a {
@@ -192,7 +250,7 @@ ol.version-picker li:last-child a {
 .api_stability a:hover,
 .api_stability a:active,
 .api_stability a:focus {
-  background-color: rgba(255, 255, 255, .4);
+  background-color: var(--background-color-api-stability-link);
 }
 
 .api_stability a code {
@@ -200,15 +258,23 @@ ol.version-picker li:last-child a {
 }
 
 .api_stability_0 {
-  background-color: #d60027;
+  background-color: var(--red1);
 }
 
 .api_stability_1 {
-  background-color: #ca5010;
+  background-color: var(--red3);
 }
 
 .api_stability_2 {
-  background-color: #5a8147;
+  background-color: var(--green2);
+}
+
+.api_stability_3 {
+  background-color: var(--blue1);
+}
+
+.module_stability {
+  vertical-align: middle;
 }
 
 .api_metadata {
@@ -317,6 +383,11 @@ dd + dt.pre {
   padding-top: 1rem;
 }
 
+#apicontent section {
+  content-visibility: auto;
+  contain-intrinsic-size: 1px 5000px;
+}
+
 #apicontent .line {
   width: calc(50% - 1rem);
   margin: 1rem 1rem .95rem;
@@ -386,7 +457,7 @@ code {
 pre {
   padding: 1rem;
   vertical-align: top;
-  background-color: #f2f2f2;
+  background-color: var(--background-color-highlight);
   margin: 1rem;
   overflow-x: auto;
 }
@@ -409,19 +480,19 @@ code.pre {
 }
 
 #intro a {
-  color: #ddd;
+  color: var(--grey8);
   font-weight: 700;
 }
 
 hr {
   background-color: transparent;
   border: medium none;
-  border-bottom: 1px solid #7a7a7a;
+  border-bottom: 1px solid var(--gray5);
   margin: 0 0 1rem;
 }
 
-#toc h2 {
-  margin: 1.5rem 0;
+#toc > ul {
+  margin-top: 1.5rem;
 }
 
 #toc p {
@@ -442,13 +513,21 @@ hr {
 }
 
 #toc .stability_0::after {
-  background-color: #d50027;
-  color: #fff;
+  background-color: var(--red2);
+  color: var(--white);
   content: "deprecated";
   margin-left: .25rem;
   padding: 1px 3px;
   border-radius: 3px;
 }
+#toc .stability_3::after {
+  background-color: var(--blue1);
+  color: var(--white);
+  content: "legacy";
+  margin-left: .25rem;
+  padding: 1px 3px;
+  border-radius: 3px;
+}
 
 #apicontent li {
   margin-bottom: .5rem;
@@ -488,7 +567,7 @@ a code {
 
 #column2.interior {
   width: 234px;
-  background-color: #333;
+  background-color: var(--color-fill-side-nav);
   position: fixed;
   left: 0;
   top: 0;
@@ -500,7 +579,7 @@ a code {
 #column2 ul {
   list-style: none;
   margin: .9rem 0 .5rem;
-  background-color: #333;
+  background-color: var(--color-fill-side-nav);
 }
 
 #column2 > :first-child {
@@ -531,8 +610,9 @@ a code {
   margin-bottom: 0;
 }
 
-#column2 ul li a {
-  color: #ccc;
+#column2 ul li a,
+#column2 ul li a code {
+  color: var(--color-text-nav);
   border-radius: 0;
 }
 
@@ -540,7 +620,7 @@ a code {
 #column2 ul li a.active:hover,
 #column2 ul li a.active:focus {
   font-weight: 700;
-  color: #fff;
+  color: var(--white);
   background-color: transparent;
 }
 
@@ -548,13 +628,13 @@ a code {
 #intro a:focus,
 #column2 ul li a:hover,
 #column2 ul li a:focus {
-  color: #fff;
+  color: var(--white);
   background-color: transparent;
 }
 
 span > .mark,
 span > .mark:visited {
-  color: #707070;
+  color: var(--color-text-mark);
   position: absolute;
   top: 0;
   right: 0;
@@ -563,7 +643,7 @@ span > .mark:visited {
 span > .mark:hover,
 span > .mark:focus,
 span > .mark:active {
-  color: #43853d;
+  color: var(--color-brand-secondary);
   background-color: transparent;
 }
 
@@ -572,6 +652,20 @@ td > *:last-child {
   margin-bottom: 0;
 }
 
+kbd {
+  background-color: #eee;
+  border-radius: 3px;
+  border: 1px solid #b4b4b4;
+  box-shadow: 0 1px 1px rgba(0, 0, 0, .2);
+  color: #333;
+  display: inline-block;
+  font-size: .85em;
+  font-weight: 700;
+  padding: 2px 4px;
+  white-space: nowrap;
+  vertical-align: middle;
+ }
+
 .changelog > summary {
   margin: .5rem 0;
   padding: .5rem 0;
@@ -587,11 +681,6 @@ td > *:last-child {
   visibility: hidden;
 }
 
-.github_icon {
-  vertical-align: middle;
-  margin: -2px 3px 0 0;
-}
-
 /* API reference sidebar */
 @media only screen and (min-width: 1025px) {
   .apidoc #column2 > .line {
@@ -635,6 +724,23 @@ td > *:last-child {
   }
 }
 
+.header-container {
+  display: flex;
+  align-items: center;
+  margin: 1.5rem 0 1rem;
+  justify-content: space-between;
+}
+
+.header-container h1 {
+  margin: 0;
+}
+
+.theme-toggle-btn {
+  border: none;
+  background: transparent;
+  outline: var(--brand3) dotted 2px;
+}
+
 @media only screen and (max-width: 1024px) {
   #content {
     overflow: visible;
@@ -651,6 +757,56 @@ td > *:last-child {
   }
 }
 
+.icon {
+  cursor: pointer;
+}
+
+.dark-icon {
+  display: block;
+}
+
+.light-icon {
+  fill: var(--white);
+  display: none;
+}
+
+.dark-mode .dark-icon {
+  display: none;
+}
+
+.dark-mode .light-icon {
+  fill: var(--white);
+  display: block;
+}
+
+.js-flavor-selector {
+  -webkit-appearance: none;
+  appearance: none;
+  float: right;
+  background-image: url(./js-flavor-cjs.svg);
+  background-size: contain;
+  background-repeat: no-repeat;
+  width: 142px;
+  height: 20px;
+}
+.js-flavor-selector:checked {
+  background-image: url(./js-flavor-esm.svg);
+}
+.js-flavor-selector:not(:checked) ~ .mjs,
+.js-flavor-selector:checked ~ .cjs {
+  display: none;
+}
+.dark-mode .js-flavor-selector {
+  filter: invert(1);
+}
+@supports (aspect-ratio: 1 / 1) {
+  .js-flavor-selector {
+    height: 1.5em;
+    width: auto;
+    aspect-ratio: 2719 / 384;
+  }
+}
+
 @media print {
   html {
     height: auto;
@@ -701,4 +857,24 @@ td > *:last-child {
   #apicontent {
     overflow: hidden;
   }
+  .js-flavor-selector {
+    display: none;
+  }
+  .js-flavor-selector + * {
+    margin-bottom: 2rem;
+    padding-bottom: 2rem;
+    border-bottom: 1px solid var(--color-text-primary);
+  }
+  .js-flavor-selector ~ * {
+    display: block !important;
+    background-position: top right;
+    background-size: 142px 20px;
+    background-repeat: no-repeat;
+  }
+  .js-flavor-selector ~ .cjs {
+    background-image: url(./js-flavor-cjs.svg);
+  }
+  .js-flavor-selector ~ .mjs {
+    background-image: url(./js-flavor-esm.svg);
+  }
 }
diff --git a/doc/changelogs/CHANGELOG_ARCHIVE.md b/doc/changelogs/CHANGELOG_ARCHIVE.md
index 52278ec3664a06b871cfba9a2b683f8152b9c850..4914d45b955754f39356d73cce58c812174f4181 100644
--- a/doc/changelogs/CHANGELOG_ARCHIVE.md
+++ b/doc/changelogs/CHANGELOG_ARCHIVE.md
@@ -73,6 +73,7 @@
 <a href="#0.8.3">0.8.3</a><br/>
 <a href="#0.8.2">0.8.2</a><br/>
 <a href="#0.8.1">0.8.1</a><br/>
+<a href="#0.8.0">0.8.0</a><br/>
 </td>
 <td valign="top">
 <a href="#0.7.12">0.7.12</a><br/>
@@ -155,6 +156,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
diff --git a/doc/changelogs/CHANGELOG_IOJS.md b/doc/changelogs/CHANGELOG_IOJS.md
index 43dfe1225f443d6a4d4ecdc67d256268ed370c05..540e244f1139a9339e1692ba92910dac9807f23c 100644
--- a/doc/changelogs/CHANGELOG_IOJS.md
+++ b/doc/changelogs/CHANGELOG_IOJS.md
@@ -64,6 +64,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
diff --git a/doc/changelogs/CHANGELOG_V010.md b/doc/changelogs/CHANGELOG_V010.md
index dee227da5c76484068f76d6bf6613cdb017306d3..d4b579e6b5b88b3e3c68e317aa8198c96f7ccc51 100644
--- a/doc/changelogs/CHANGELOG_V010.md
+++ b/doc/changelogs/CHANGELOG_V010.md
@@ -66,6 +66,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
diff --git a/doc/changelogs/CHANGELOG_V012.md b/doc/changelogs/CHANGELOG_V012.md
index eff6838e4218df62166736581ce1c902323cd7f5..009b5eaffee2d3fafbee4282d59ce99c8332b90e 100644
--- a/doc/changelogs/CHANGELOG_V012.md
+++ b/doc/changelogs/CHANGELOG_V012.md
@@ -34,6 +34,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
@@ -61,13 +63,13 @@ will be maintained until December 31st, 2016.
 
 ### Commits:
 
-* [[`a47fd4549d`](https://github.com/nodejs/node/commit/a47fd4549d) - build: add working lint-ci make target (Rod Vagg) https://github.com/nodejs/node/pull/9151
-* [[`830584ca59`](https://github.com/nodejs/node/commit/830584ca59) - deps: define missing operator delete functions (John Barboza) https://github.com/nodejs/node/pull/10356
-* [[`c130b31cba`](https://github.com/nodejs/node/commit/c130b31cba) - deps: upgrade npm to 2.15.11 (Jeremiah Senkpiel) https://github.com/nodejs/node/pull/9619
-* [[`bc6766d847`](https://github.com/nodejs/node/commit/bc6766d847) - doc: update npm license in main LICENSE file (Rod Vagg) https://github.com/nodejs/node/pull/10352
-* [[`0cdf344c80`](https://github.com/nodejs/node/commit/0cdf344c80) - (SEMVER-MINOR) process: reintroduce ares to versions (Johan Bergström) https://github.com/nodejs/node/pull/9191
-* [[`d8e27ec30a`](https://github.com/nodejs/node/commit/d8e27ec30a) - test: mark dgram-multicast-multi-process as flaky (Rod Vagg) https://github.com/nodejs/node/pull/9150
-* [[`c722335ead`](https://github.com/nodejs/node/commit/c722335ead) - tls: fix minor jslint failure (Rod Vagg) https://github.com/nodejs/node/pull/9107
+* [[`a47fd4549d`](https://github.com/nodejs/node/commit/a47fd4549d)] - build: add working lint-ci make target (Rod Vagg) https://github.com/nodejs/node/pull/9151
+* [[`830584ca59`](https://github.com/nodejs/node/commit/830584ca59)] - deps: define missing operator delete functions (John Barboza) https://github.com/nodejs/node/pull/10356
+* [[`c130b31cba`](https://github.com/nodejs/node/commit/c130b31cba)] - deps: upgrade npm to 2.15.11 (Jeremiah Senkpiel) https://github.com/nodejs/node/pull/9619
+* [[`bc6766d847`](https://github.com/nodejs/node/commit/bc6766d847)] - doc: update npm license in main LICENSE file (Rod Vagg) https://github.com/nodejs/node/pull/10352
+* [[`0cdf344c80`](https://github.com/nodejs/node/commit/0cdf344c80)] - (SEMVER-MINOR) process: reintroduce ares to versions (Johan Bergström) https://github.com/nodejs/node/pull/9191
+* [[`d8e27ec30a`](https://github.com/nodejs/node/commit/d8e27ec30a)] - test: mark dgram-multicast-multi-process as flaky (Rod Vagg) https://github.com/nodejs/node/pull/9150
+* [[`c722335ead`](https://github.com/nodejs/node/commit/c722335ead)] - tls: fix minor jslint failure (Rod Vagg) https://github.com/nodejs/node/pull/9107
 
 <a id="0.12.17"></a>
 ## 2016-10-18, Version 0.12.17 (Maintenance), @rvagg
@@ -80,7 +82,7 @@ This is a security release. All Node.js users should consult the security releas
 
 ### Commits:
 
-* [[`c5b095ecf8`](https://github.com/nodejs/node/commit/c5b095ecf8) - deps: avoid single-byte buffer overwrite (Daniel Stenberg) https://github.com/nodejs/node/pull/8849
+* [[`c5b095ecf8`](https://github.com/nodejs/node/commit/c5b095ecf8)] - deps: avoid single-byte buffer overwrite (Daniel Stenberg) https://github.com/nodejs/node/pull/8849
 
 <a id="0.12.16"></a>
 ## 2016-09-27, Version 0.12.16 (Maintenance), @rvagg
@@ -100,18 +102,18 @@ This is a security release. All Node.js users should consult the security releas
 
 ### Commits:
 
-* [[`38d7258d89`](https://github.com/nodejs/node/commit/38d7258d89) - buffer: zero-fill uninitialized bytes in .concat() (Сковорода Никита Андреевич) https://github.com/nodejs/node-private/pull/66
-* [[`1ba6d16786`](https://github.com/nodejs/node/commit/1ba6d16786) - build: turn on -fno-delete-null-pointer-checks (Ben Noordhuis) https://github.com/nodejs/node/pull/6737
-* [[`71e4285e27`](https://github.com/nodejs/node/commit/71e4285e27) - crypto: don't build hardware engines (Rod Vagg) https://github.com/nodejs/node-private/pull/69
-* [[`b6e0105a66`](https://github.com/nodejs/node/commit/b6e0105a66) - deps: add -no_rand_screen to openssl s_client (Shigeki Ohtsu) https://github.com/nodejs/node-v0.x-archive/pull/25368
-* [[`1caec97eab`](https://github.com/nodejs/node/commit/1caec97eab) - deps: fix openssl assembly error on ia32 win32 (Fedor Indutny) https://github.com/nodejs/node-v0.x-archive/pull/25654
-* [[`734bc6938b`](https://github.com/nodejs/node/commit/734bc6938b) - deps: separate sha256/sha512-x86_64.pl for openssl (Shigeki Ohtsu) https://github.com/nodejs/node-v0.x-archive/pull/25654
-* [[`7cc6d4eb5c`](https://github.com/nodejs/node/commit/7cc6d4eb5c) - deps: copy all openssl header files to include dir (Shigeki Ohtsu) https://github.com/nodejs/node/pull/8718
-* [[`4a9da21217`](https://github.com/nodejs/node/commit/4a9da21217) - deps: upgrade openssl sources to 1.0.1u (Shigeki Ohtsu) https://github.com/nodejs/node/pull/8718
-* [[`6d977902bd`](https://github.com/nodejs/node/commit/6d977902bd) - http: check reason chars in writeHead (Evan Lucas) https://github.com/nodejs/node-private/pull/47
-* [[`ad470e496b`](https://github.com/nodejs/node/commit/ad470e496b) - http: disallow sending obviously invalid status codes (Evan Lucas) https://github.com/nodejs/node-private/pull/47
-* [[`9dbde2fc88`](https://github.com/nodejs/node/commit/9dbde2fc88) - lib: make tls.checkServerIdentity() more strict (Ben Noordhuis) https://github.com/nodejs/node-private/pull/61
-* [[`db80592071`](https://github.com/nodejs/node/commit/db80592071) - openssl: fix keypress requirement in apps on win32 (Shigeki Ohtsu) https://github.com/nodejs/node-v0.x-archive/pull/25654
+* [[`38d7258d89`](https://github.com/nodejs/node/commit/38d7258d89)] - buffer: zero-fill uninitialized bytes in .concat() (Сковорода Никита Андреевич) https://github.com/nodejs/node-private/pull/66
+* [[`1ba6d16786`](https://github.com/nodejs/node/commit/1ba6d16786)] - build: turn on -fno-delete-null-pointer-checks (Ben Noordhuis) https://github.com/nodejs/node/pull/6737
+* [[`71e4285e27`](https://github.com/nodejs/node/commit/71e4285e27)] - crypto: don't build hardware engines (Rod Vagg) https://github.com/nodejs/node-private/pull/69
+* [[`b6e0105a66`](https://github.com/nodejs/node/commit/b6e0105a66)] - deps: add -no_rand_screen to openssl s_client (Shigeki Ohtsu) https://github.com/nodejs/node-v0.x-archive/pull/25368
+* [[`1caec97eab`](https://github.com/nodejs/node/commit/1caec97eab)] - deps: fix openssl assembly error on ia32 win32 (Fedor Indutny) https://github.com/nodejs/node-v0.x-archive/pull/25654
+* [[`734bc6938b`](https://github.com/nodejs/node/commit/734bc6938b)] - deps: separate sha256/sha512-x86_64.pl for openssl (Shigeki Ohtsu) https://github.com/nodejs/node-v0.x-archive/pull/25654
+* [[`7cc6d4eb5c`](https://github.com/nodejs/node/commit/7cc6d4eb5c)] - deps: copy all openssl header files to include dir (Shigeki Ohtsu) https://github.com/nodejs/node/pull/8718
+* [[`4a9da21217`](https://github.com/nodejs/node/commit/4a9da21217)] - deps: upgrade openssl sources to 1.0.1u (Shigeki Ohtsu) https://github.com/nodejs/node/pull/8718
+* [[`6d977902bd`](https://github.com/nodejs/node/commit/6d977902bd)] - http: check reason chars in writeHead (Evan Lucas) https://github.com/nodejs/node-private/pull/47
+* [[`ad470e496b`](https://github.com/nodejs/node/commit/ad470e496b)] - http: disallow sending obviously invalid status codes (Evan Lucas) https://github.com/nodejs/node-private/pull/47
+* [[`9dbde2fc88`](https://github.com/nodejs/node/commit/9dbde2fc88)] - lib: make tls.checkServerIdentity() more strict (Ben Noordhuis) https://github.com/nodejs/node-private/pull/61
+* [[`db80592071`](https://github.com/nodejs/node/commit/db80592071)] - openssl: fix keypress requirement in apps on win32 (Shigeki Ohtsu) https://github.com/nodejs/node-v0.x-archive/pull/25654
 
 <a id="0.12.15"></a>
 ## 2016-06-23, Version 0.12.15 (Maintenance), @rvagg
@@ -125,13 +127,13 @@ This is a security release. All Node.js users should consult the security releas
 
 ### Commits:
 
-* [[`da8501edf6`](https://github.com/nodejs/node/commit/da8501edf6) - deps: backport bd1777fd from libuv upstream (Rod Vagg)
-* [[`9207a00f8e`](https://github.com/nodejs/node/commit/9207a00f8e) - deps: backport 85adf43e from libuv upstream (Rod Vagg)
-* [[`9627f34230`](https://github.com/nodejs/node/commit/9627f34230) - deps: backport 98239224 from libuv upstream (Rod Vagg)
-* [[`5df21b2e36`](https://github.com/nodejs/node/commit/5df21b2e36) - deps: backport 9a4fd268 from libuv upstream (Rod Vagg)
-* [[`e75de35057`](https://github.com/nodejs/node/commit/e75de35057) - deps: backport 3eb6764a from libuv upstream (Rod Vagg)
-* [[`a113e02f16`](https://github.com/nodejs/node/commit/a113e02f16) - deps: backport 3a9bfec from v8 upstream (Ben Noordhuis)
-* [[`8138055c88`](https://github.com/nodejs/node/commit/8138055c88) - test: fix test failure due to expired certificates (Ben Noordhuis) https://github.com/nodejs/node/pull/7195
+* [[`da8501edf6`](https://github.com/nodejs/node/commit/da8501edf6)] - deps: backport bd1777fd from libuv upstream (Rod Vagg)
+* [[`9207a00f8e`](https://github.com/nodejs/node/commit/9207a00f8e)] - deps: backport 85adf43e from libuv upstream (Rod Vagg)
+* [[`9627f34230`](https://github.com/nodejs/node/commit/9627f34230)] - deps: backport 98239224 from libuv upstream (Rod Vagg)
+* [[`5df21b2e36`](https://github.com/nodejs/node/commit/5df21b2e36)] - deps: backport 9a4fd268 from libuv upstream (Rod Vagg)
+* [[`e75de35057`](https://github.com/nodejs/node/commit/e75de35057)] - deps: backport 3eb6764a from libuv upstream (Rod Vagg)
+* [[`a113e02f16`](https://github.com/nodejs/node/commit/a113e02f16)] - deps: backport 3a9bfec from v8 upstream (Ben Noordhuis)
+* [[`8138055c88`](https://github.com/nodejs/node/commit/8138055c88)] - test: fix test failure due to expired certificates (Ben Noordhuis) https://github.com/nodejs/node/pull/7195
 
 <a id="0.12.14"></a>
 ## 2016-05-06, Version 0.12.14 (Maintenance), @rvagg
@@ -146,15 +148,15 @@ This is a security release. All Node.js users should consult the security releas
 
 ### Commits:
 
-* [[`3e99ee1b47`](https://github.com/nodejs/node/commit/3e99ee1b47) - deps: completely upgrade npm in LTS to 2.15.1 (Forrest L Norvell) https://github.com/nodejs/node/pull/5988
-* [[`2b63396e1f`](https://github.com/nodejs/node/commit/2b63396e1f) - deps: add -no_rand_screen to openssl s_client (Shigeki Ohtsu) https://github.com/joyent/node/pull/25368
-* [[`f21705df58`](https://github.com/nodejs/node/commit/f21705df58) - deps: update openssl asm files (Shigeki Ohtsu) https://github.com/nodejs/node/pull/6553
-* [[`02b6a6bc27`](https://github.com/nodejs/node/commit/02b6a6bc27) - deps: fix openssl assembly error on ia32 win32 (Fedor Indutny) https://github.com/joyent/node/pull/25654
-* [[`1aecc668b0`](https://github.com/nodejs/node/commit/1aecc668b0) - deps: separate sha256/sha512-x86_64.pl for openssl (Shigeki Ohtsu) https://github.com/joyent/node/pull/25654
-* [[`39380836a0`](https://github.com/nodejs/node/commit/39380836a0) - deps: copy all openssl header files to include dir (Shigeki Ohtsu) https://github.com/nodejs/node/pull/6553
-* [[`08c8ae44a8`](https://github.com/nodejs/node/commit/08c8ae44a8) - deps: upgrade openssl sources to 1.0.1t (Shigeki Ohtsu) https://github.com/nodejs/node/pull/6553
-* [[`f5a961ab13`](https://github.com/nodejs/node/commit/f5a961ab13) - openssl: fix keypress requirement in apps on win32 (Shigeki Ohtsu) https://github.com/joyent/node/pull/25654
-* [[`810fb211a7`](https://github.com/nodejs/node/commit/810fb211a7) - tools: remove obsolete npm test-legacy command (Kat Marchán) https://github.com/nodejs/node/pull/5988
+* [[`3e99ee1b47`](https://github.com/nodejs/node/commit/3e99ee1b47)] - deps: completely upgrade npm in LTS to 2.15.1 (Forrest L Norvell) https://github.com/nodejs/node/pull/5988
+* [[`2b63396e1f`](https://github.com/nodejs/node/commit/2b63396e1f)] - deps: add -no_rand_screen to openssl s_client (Shigeki Ohtsu) https://github.com/joyent/node/pull/25368
+* [[`f21705df58`](https://github.com/nodejs/node/commit/f21705df58)] - deps: update openssl asm files (Shigeki Ohtsu) https://github.com/nodejs/node/pull/6553
+* [[`02b6a6bc27`](https://github.com/nodejs/node/commit/02b6a6bc27)] - deps: fix openssl assembly error on ia32 win32 (Fedor Indutny) https://github.com/joyent/node/pull/25654
+* [[`1aecc668b0`](https://github.com/nodejs/node/commit/1aecc668b0)] - deps: separate sha256/sha512-x86_64.pl for openssl (Shigeki Ohtsu) https://github.com/joyent/node/pull/25654
+* [[`39380836a0`](https://github.com/nodejs/node/commit/39380836a0)] - deps: copy all openssl header files to include dir (Shigeki Ohtsu) https://github.com/nodejs/node/pull/6553
+* [[`08c8ae44a8`](https://github.com/nodejs/node/commit/08c8ae44a8)] - deps: upgrade openssl sources to 1.0.1t (Shigeki Ohtsu) https://github.com/nodejs/node/pull/6553
+* [[`f5a961ab13`](https://github.com/nodejs/node/commit/f5a961ab13)] - openssl: fix keypress requirement in apps on win32 (Shigeki Ohtsu) https://github.com/joyent/node/pull/25654
+* [[`810fb211a7`](https://github.com/nodejs/node/commit/810fb211a7)] - tools: remove obsolete npm test-legacy command (Kat Marchán) https://github.com/nodejs/node/pull/5988
 
 <a id="0.12.13"></a>
 ## 2016-03-31, Version 0.12.13 (LTS), @rvagg
@@ -166,12 +168,12 @@ This is a security release. All Node.js users should consult the security releas
 
 ### Commits
 
-* [[`4041ea6bc5`](https://github.com/nodejs/node/commit/4041ea6bc5) - deps: upgrade npm in LTS to 2.15.1 (Forrest L Norvell)
-* [[`a115779026`](https://github.com/nodejs/node/commit/a115779026) - deps: Disable EXPORT and LOW ciphers in openssl (Shigeki Ohtsu) https://github.com/nodejs/node/pull/5712
-* [[`ab907eb5a8`](https://github.com/nodejs/node/commit/ab907eb5a8) - test: skip cluster-disconnect-race on Windows (Gibson Fahnestock) https://github.com/nodejs/node/pull/5621
-* [[`9c06db7444`](https://github.com/nodejs/node/commit/9c06db7444) - test: change tls tests not to use LOW cipher (Shigeki Ohtsu) https://github.com/nodejs/node/pull/5712
-* [[`154098a3dc`](https://github.com/nodejs/node/commit/154098a3dc) - test: bp fix for test-http-get-pipeline-problem.js (Michael Dawson) https://github.com/nodejs/node/pull/3013
-* [[`ff2bed6e86`](https://github.com/nodejs/node/commit/ff2bed6e86) - win,build: support Visual C++ Build Tools 2015 (João Reis) https://github.com/nodejs/node/pull/5627
+* [[`4041ea6bc5`](https://github.com/nodejs/node/commit/4041ea6bc5)] - deps: upgrade npm in LTS to 2.15.1 (Forrest L Norvell)
+* [[`a115779026`](https://github.com/nodejs/node/commit/a115779026)] - deps: Disable EXPORT and LOW ciphers in openssl (Shigeki Ohtsu) https://github.com/nodejs/node/pull/5712
+* [[`ab907eb5a8`](https://github.com/nodejs/node/commit/ab907eb5a8)] - test: skip cluster-disconnect-race on Windows (Gibson Fahnestock) https://github.com/nodejs/node/pull/5621
+* [[`9c06db7444`](https://github.com/nodejs/node/commit/9c06db7444)] - test: change tls tests not to use LOW cipher (Shigeki Ohtsu) https://github.com/nodejs/node/pull/5712
+* [[`154098a3dc`](https://github.com/nodejs/node/commit/154098a3dc)] - test: bp fix for test-http-get-pipeline-problem.js (Michael Dawson) https://github.com/nodejs/node/pull/3013
+* [[`ff2bed6e86`](https://github.com/nodejs/node/commit/ff2bed6e86)] - win,build: support Visual C++ Build Tools 2015 (João Reis) https://github.com/nodejs/node/pull/5627
 
 <a id="0.12.12"></a>
 ## 2016-03-08, Version 0.12.12 (LTS), @rvagg
@@ -184,7 +186,7 @@ Note that the upgrade to OpenSSL 1.0.1s in Node.js v0.12.11 removed internal SSL
 
 ### Commits:
 
-* [[`dbfc9d9241`](https://github.com/nodejs/node/commit/dbfc9d9241) - crypto,tls: remove SSLv2 support (Ben Noordhuis) https://github.com/nodejs/node/pull/5536
+* [[`dbfc9d9241`](https://github.com/nodejs/node/commit/dbfc9d9241)] - crypto,tls: remove SSLv2 support (Ben Noordhuis) https://github.com/nodejs/node/pull/5536
 
 <a id="0.12.11"></a>
 ## 2016-03-03, Version 0.12.11 (LTS), @rvagg
@@ -202,20 +204,20 @@ Note that the upgrade to OpenSSL 1.0.1s in Node.js v0.12.11 removed internal SSL
 
 ### Commits:
 
-* [[`1ab6653db9`](https://github.com/nodejs/node/commit/1ab6653db9) - build: update Node.js logo on OSX installer (Rod Vagg) https://github.com/nodejs/node/pull/5401
-* [[`fcc64792ae`](https://github.com/nodejs/node/commit/fcc64792ae) - child_process: guard against race condition (Rich Trott) https://github.com/nodejs/node/pull/5153
-* [[`6c468df9af`](https://github.com/nodejs/node/commit/6c468df9af) - child_process: fix data loss with readable event (Brian White) https://github.com/nodejs/node/pull/5037
-* [[`61a22019c2`](https://github.com/nodejs/node/commit/61a22019c2) - deps: upgrade openssl to 1.0.1s (Ben Noordhuis) https://github.com/nodejs/node/pull/5509
-* [[`fa26b13df7`](https://github.com/nodejs/node/commit/fa26b13df7) - deps: update to http-parser 2.3.2 (James M Snell) https://github.com/nodejs/node/pull/5241
-* [[`46c8e2165f`](https://github.com/nodejs/node/commit/46c8e2165f) - deps: backport 1f8555 from v8's upstream (Trevor Norris) https://github.com/nodejs/node/pull/3945
-* [[`ce58c2c31a`](https://github.com/nodejs/node/commit/ce58c2c31a) - doc: remove SSLv2 descriptions (Shigeki Ohtsu) https://github.com/nodejs/node/pull/5541
-* [[`018e4e0b1a`](https://github.com/nodejs/node/commit/018e4e0b1a) - domains: fix handling of uncaught exceptions (Julien Gilli) https://github.com/nodejs/node/pull/3885
-* [[`d421e85dc9`](https://github.com/nodejs/node/commit/d421e85dc9) - lib: fix cluster handle leak (Rich Trott) https://github.com/nodejs/node/pull/5152
-* [[`3a48f0022f`](https://github.com/nodejs/node/commit/3a48f0022f) - node: fix leaking Context handle (Trevor Norris) https://github.com/nodejs/node/pull/3945
-* [[`28dddabf6a`](https://github.com/nodejs/node/commit/28dddabf6a) - src: fix build error without OpenSSL support (Jörg Krause) https://github.com/nodejs/node/pull/4201
-* [[`a79baf03cd`](https://github.com/nodejs/node/commit/a79baf03cd) - src: use global SealHandleScope (Trevor Norris) https://github.com/nodejs/node/pull/3945
-* [[`be39f30447`](https://github.com/nodejs/node/commit/be39f30447) - test: add test-domain-exit-dispose-again back (Julien Gilli) https://github.com/nodejs/node/pull/4278
-* [[`da66166b9a`](https://github.com/nodejs/node/commit/da66166b9a) - test: fix test-domain-exit-dispose-again (Julien Gilli) https://github.com/nodejs/node/pull/3991
+* [[`1ab6653db9`](https://github.com/nodejs/node/commit/1ab6653db9)] - build: update Node.js logo on OSX installer (Rod Vagg) https://github.com/nodejs/node/pull/5401
+* [[`fcc64792ae`](https://github.com/nodejs/node/commit/fcc64792ae)] - child_process: guard against race condition (Rich Trott) https://github.com/nodejs/node/pull/5153
+* [[`6c468df9af`](https://github.com/nodejs/node/commit/6c468df9af)] - child_process: fix data loss with readable event (Brian White) https://github.com/nodejs/node/pull/5037
+* [[`61a22019c2`](https://github.com/nodejs/node/commit/61a22019c2)] - deps: upgrade openssl to 1.0.1s (Ben Noordhuis) https://github.com/nodejs/node/pull/5509
+* [[`fa26b13df7`](https://github.com/nodejs/node/commit/fa26b13df7)] - deps: update to http-parser 2.3.2 (James M Snell) https://github.com/nodejs/node/pull/5241
+* [[`46c8e2165f`](https://github.com/nodejs/node/commit/46c8e2165f)] - deps: backport 1f8555 from v8's upstream (Trevor Norris) https://github.com/nodejs/node/pull/3945
+* [[`ce58c2c31a`](https://github.com/nodejs/node/commit/ce58c2c31a)] - doc: remove SSLv2 descriptions (Shigeki Ohtsu) https://github.com/nodejs/node/pull/5541
+* [[`018e4e0b1a`](https://github.com/nodejs/node/commit/018e4e0b1a)] - domains: fix handling of uncaught exceptions (Julien Gilli) https://github.com/nodejs/node/pull/3885
+* [[`d421e85dc9`](https://github.com/nodejs/node/commit/d421e85dc9)] - lib: fix cluster handle leak (Rich Trott) https://github.com/nodejs/node/pull/5152
+* [[`3a48f0022f`](https://github.com/nodejs/node/commit/3a48f0022f)] - node: fix leaking Context handle (Trevor Norris) https://github.com/nodejs/node/pull/3945
+* [[`28dddabf6a`](https://github.com/nodejs/node/commit/28dddabf6a)] - src: fix build error without OpenSSL support (Jörg Krause) https://github.com/nodejs/node/pull/4201
+* [[`a79baf03cd`](https://github.com/nodejs/node/commit/a79baf03cd)] - src: use global SealHandleScope (Trevor Norris) https://github.com/nodejs/node/pull/3945
+* [[`be39f30447`](https://github.com/nodejs/node/commit/be39f30447)] - test: add test-domain-exit-dispose-again back (Julien Gilli) https://github.com/nodejs/node/pull/4278
+* [[`da66166b9a`](https://github.com/nodejs/node/commit/da66166b9a)] - test: fix test-domain-exit-dispose-again (Julien Gilli) https://github.com/nodejs/node/pull/3991
 
 <a id="0.12.10"></a>
 ## 2016-02-09, Version 0.12.10 (LTS), @jasnell
@@ -236,14 +238,14 @@ This is an important security release. All Node.js users should consult the secu
 
 ### Commits
 
-* [[`4312848bff`](https://github.com/nodejs/node/commit/4312848bff) - build: enable xz compressed tarballs where possible (Rod Vagg) https://github.com/nodejs/node/pull/4894
-* [[`247626245c`](https://github.com/nodejs/node/commit/247626245c) - deps: upgrade openssl sources to 1.0.1r (Shigeki Ohtsu) https://github.com/joyent/node/pull/25368
-* [[`744c9749fc`](https://github.com/nodejs/node/commit/744c9749fc) - deps: update http-parser to version 2.3.1 (James M Snell)
-* [[`d1c56ec7d1`](https://github.com/nodejs/node/commit/d1c56ec7d1) - doc: clarify v0.12.9 notable items (Rod Vagg) https://github.com/nodejs/node/pull/4154
-* [[`e128d9a5b4`](https://github.com/nodejs/node/commit/e128d9a5b4) - http: strictly forbid invalid characters from headers (James M Snell)
-* [[`bdb9f2cf89`](https://github.com/nodejs/node/commit/bdb9f2cf89) - src: avoiding compiler warnings in node_revert.cc (James M Snell)
-* [[`23bced1fb3`](https://github.com/nodejs/node/commit/23bced1fb3) - src: add --security-revert command line flag (James M Snell)
-* [[`f41a3c73e7`](https://github.com/nodejs/node/commit/f41a3c73e7) - tools: backport tools/install.py for headers (Richard Lau) https://github.com/nodejs/node/pull/4149
+* [[`4312848bff`](https://github.com/nodejs/node/commit/4312848bff)] - build: enable xz compressed tarballs where possible (Rod Vagg) https://github.com/nodejs/node/pull/4894
+* [[`247626245c`](https://github.com/nodejs/node/commit/247626245c)] - deps: upgrade openssl sources to 1.0.1r (Shigeki Ohtsu) https://github.com/joyent/node/pull/25368
+* [[`744c9749fc`](https://github.com/nodejs/node/commit/744c9749fc)] - deps: update http-parser to version 2.3.1 (James M Snell)
+* [[`d1c56ec7d1`](https://github.com/nodejs/node/commit/d1c56ec7d1)] - doc: clarify v0.12.9 notable items (Rod Vagg) https://github.com/nodejs/node/pull/4154
+* [[`e128d9a5b4`](https://github.com/nodejs/node/commit/e128d9a5b4)] - http: strictly forbid invalid characters from headers (James M Snell)
+* [[`bdb9f2cf89`](https://github.com/nodejs/node/commit/bdb9f2cf89)] - src: avoiding compiler warnings in node_revert.cc (James M Snell)
+* [[`23bced1fb3`](https://github.com/nodejs/node/commit/23bced1fb3)] - src: add --security-revert command line flag (James M Snell)
+* [[`f41a3c73e7`](https://github.com/nodejs/node/commit/f41a3c73e7)] - tools: backport tools/install.py for headers (Richard Lau) https://github.com/nodejs/node/pull/4149
 
 <a id="0.12.9"></a>
 ## 2015-12-04, Version 0.12.9 (LTS), @rvagg
@@ -257,86 +259,42 @@ Security Update
 
 ### Commits
 
-* [[`8d24a14f2c`](https://github.com/nodejs/node/commit/8d24a14f2c) - deps: upgrade to openssl 1.0.1q (Ben Noordhuis) https://github.com/nodejs/node/pull/4133
-* [[`dfc6f4a9af`](https://github.com/nodejs/node/commit/dfc6f4a9af) - http: fix pipeline regression (Fedor Indutny)
+* [[`8d24a14f2c`](https://github.com/nodejs/node/commit/8d24a14f2c)] - deps: upgrade to openssl 1.0.1q (Ben Noordhuis) https://github.com/nodejs/node/pull/4133
+* [[`dfc6f4a9af`](https://github.com/nodejs/node/commit/dfc6f4a9af)] - http: fix pipeline regression (Fedor Indutny)
 
 <a id="0.12.8"></a>
 ## 2015.11.25, Version 0.12.8 (LTS), @rvagg
 
-* [[`d9399569bd`](https://github.com/nodejs/node/commit/d9399569bd) - build: backport tools/release.sh (Rod Vagg) https://github.com/nodejs/node/pull/3642
-* [[`78c5b4c8bd`](https://github.com/nodejs/node/commit/78c5b4c8bd) - build: backport config for new CI infrastructure (Rod Vagg) https://github.com/nodejs/node/pull/3642
-* [[`83441616a5`](https://github.com/nodejs/node/commit/83441616a5) - build: fix --without-ssl compile time error (Ben Noordhuis) https://github.com/nodejs/node/pull/3825
-* [[`8887666b0b`](https://github.com/nodejs/node/commit/8887666b0b) - build: update manifest to include Windows 10 (Lucien Greathouse) https://github.com/nodejs/node/pull/2843
-* [[`08afe4ec8e`](https://github.com/nodejs/node/commit/08afe4ec8e) - build: add MSVS 2015 support (Rod Vagg) https://github.com/nodejs/node/pull/2843
-* [[`4f2456369c`](https://github.com/nodejs/node/commit/4f2456369c) - build: work around VS2015 issue in ICU <56 (Steven R. Loomis) https://github.com/nodejs/node-v0.x-archive/pull/25804
-* [[`15030f26fd`](https://github.com/nodejs/node/commit/15030f26fd) - build: Intl: bump ICU4C from 54 to 55 (backport) (Steven R. Loomis) https://github.com/nodejs/node-v0.x-archive/pull/25856
-* [[`1083fa70f0`](https://github.com/nodejs/node/commit/1083fa70f0) - build: run-ci makefile rule (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25653
-* [[`2d2494cf14`](https://github.com/nodejs/node/commit/2d2494cf14) - build: support flaky tests in test-ci (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25653
-* [[`b25d26f2ef`](https://github.com/nodejs/node/commit/b25d26f2ef) - build: support Jenkins via test-ci (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25653
-* [[`7e4b47f38a`](https://github.com/nodejs/node/commit/7e4b47f38a) - build,win: fix node.exe resource version (João Reis) https://github.com/nodejs/node/pull/3053
-* [[`e07c86e240`](https://github.com/nodejs/node/commit/e07c86e240) - build,win: try next MSVS version on failure (João Reis) https://github.com/nodejs/node/pull/2843
-* [[`b5a0abcfdf`](https://github.com/nodejs/node/commit/b5a0abcfdf) - child_process: clone spawn options argument (cjihrig) https://github.com/nodejs/node-v0.x-archive/pull/9159
-* [[`8b81f98c41`](https://github.com/nodejs/node/commit/8b81f98c41) - configure: add --without-mdb flag (cgalibern) https://github.com/nodejs/node-v0.x-archive/pull/25707
-* [[`071c860c2b`](https://github.com/nodejs/node/commit/071c860c2b) - crypto: replace rwlocks with simple mutexes (Ben Noordhuis) https://github.com/nodejs/node/pull/2723
-* [[`ca97fb6be3`](https://github.com/nodejs/node/commit/ca97fb6be3) - deps: upgrade npm to 2.14.9 (Forrest L Norvell) https://github.com/nodejs/node/pull/3684
-* [[`583734342e`](https://github.com/nodejs/node/commit/583734342e) - deps: fix openssl for MSVS 2015 (Andy Polyakov) https://github.com/nodejs/node/pull/2843
-* [[`02c262a4c6`](https://github.com/nodejs/node/commit/02c262a4c6) - deps: fix gyp to work on MacOSX without XCode (Shigeki Ohtsu) https://github.com/nodejs/node/pull/2843
-* [[`f0fba0bce8`](https://github.com/nodejs/node/commit/f0fba0bce8) - deps: update gyp to 25ed9ac (João Reis) https://github.com/nodejs/node/pull/2843
-* [[`f693565813`](https://github.com/nodejs/node/commit/f693565813) - deps: upgrade to npm 2.13.4 (Kat Marchán) https://github.com/nodejs/node-v0.x-archive/pull/25825
-* [[`618b142679`](https://github.com/nodejs/node/commit/618b142679) - deps,v8: fix compilation in VS2015 (João Reis) https://github.com/nodejs/node/pull/2843
-* [[`49b4f0d54e`](https://github.com/nodejs/node/commit/49b4f0d54e) - doc: backport README.md (Rod Vagg) https://github.com/nodejs/node/pull/3642
-* [[`2860c53562`](https://github.com/nodejs/node/commit/2860c53562) - doc: fixed child_process.exec doc (Tyler Anton) https://github.com/nodejs/node-v0.x-archive/pull/14088
-* [[`4a91fa11a3`](https://github.com/nodejs/node/commit/4a91fa11a3) - doc: Update docs for os.platform() (George Kotchlamazashvili) https://github.com/nodejs/node-v0.x-archive/pull/25777
-* [[`b03ab02fe8`](https://github.com/nodejs/node/commit/b03ab02fe8) - doc: Change the link for v8 docs to v8dox.com (Chad Walker) https://github.com/nodejs/node-v0.x-archive/pull/25811
-* [[`1fd8f37efd`](https://github.com/nodejs/node/commit/1fd8f37efd) - doc: buffer, adding missing backtick (Dyana Rose) https://github.com/nodejs/node-v0.x-archive/pull/25811
-* [[`162d0db3bb`](https://github.com/nodejs/node/commit/162d0db3bb) - doc: tls.markdown, adjust version from v0.10.39 to v0.10.x (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`eda2560cdc`](https://github.com/nodejs/node/commit/eda2560cdc) - doc: additional refinement to readable event (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`881d9bea01`](https://github.com/nodejs/node/commit/881d9bea01) - doc: readable event clarification (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`b6378f0c75`](https://github.com/nodejs/node/commit/b6378f0c75) - doc: stream.unshift does not reset reading state (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`4952e2b4d2`](https://github.com/nodejs/node/commit/4952e2b4d2) - doc: clarify Readable._read and Readable.push (fresheneesz) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`14000b97d4`](https://github.com/nodejs/node/commit/14000b97d4) - doc: two minor stream doc improvements (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`6b6bd21497`](https://github.com/nodejs/node/commit/6b6bd21497) - doc: Clarified read method with specified size argument. (Philippe Laferriere) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`16f547600a`](https://github.com/nodejs/node/commit/16f547600a) - doc: Document http.request protocol option (Ville Skyttä) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`618e4ecda9`](https://github.com/nodejs/node/commit/618e4ecda9) - doc: add a note about readable in flowing mode (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`0b165be37b`](https://github.com/nodejs/node/commit/0b165be37b) - doc: fix line wrapping in buffer.markdown (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`70dd13f88d`](https://github.com/nodejs/node/commit/70dd13f88d) - doc: add CleartextStream deprecation notice (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`418cde0765`](https://github.com/nodejs/node/commit/418cde0765) - doc: mention that mode is ignored if file exists (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`85bcb281e4`](https://github.com/nodejs/node/commit/85bcb281e4) - doc: improve http.abort description (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`5ccb429ee8`](https://github.com/nodejs/node/commit/5ccb429ee8) - doc, comments: Grammar and spelling fixes (Ville Skyttä) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`a24db43101`](https://github.com/nodejs/node/commit/a24db43101) - docs: event emitter behavior notice (Samuel Mills (Henchman)) https://github.com/nodejs/node-v0.x-archive/pull/25467
-* [[`8cbf7cb021`](https://github.com/nodejs/node/commit/8cbf7cb021) - docs: events clarify emitter.listener() behavior (Benjamin Steephenson) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`b7229debbe`](https://github.com/nodejs/node/commit/b7229debbe) - docs: Fix default options for fs.createWriteStream() (Chris Neave) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`f0453caea2`](https://github.com/nodejs/node/commit/f0453caea2) - domains: port caeb677 from v0.10 to v0.12 (Jeremy Whitlock) https://github.com/nodejs/node-v0.x-archive/pull/25835
-* [[`261fa3620f`](https://github.com/nodejs/node/commit/261fa3620f) - src: fix intermittent SIGSEGV in resolveTxt (Evan Lucas) https://github.com/nodejs/node-v0.x-archive/pull/9300
-* [[`1f7257b02d`](https://github.com/nodejs/node/commit/1f7257b02d) - test: mark test-https-aws-ssl flaky on linux (João Reis) https://github.com/nodejs/node-v0.x-archive/pull/25893
-* [[`cf435d55db`](https://github.com/nodejs/node/commit/cf435d55db) - test: mark test-signal-unregister as flaky (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25750
-* [[`ceb6a8c131`](https://github.com/nodejs/node/commit/ceb6a8c131) - test: fix test-debug-port-from-cmdline (João Reis) https://github.com/nodejs/node-v0.x-archive/pull/25748
-* [[`22997731e6`](https://github.com/nodejs/node/commit/22997731e6) - test: add regression test for #25735 (Fedor Indutny) https://github.com/nodejs/node-v0.x-archive/pull/25739
-* [[`39e05639f4`](https://github.com/nodejs/node/commit/39e05639f4) - test: mark http-pipeline-flood flaky on win32 (Julien Gilli) https://github.com/nodejs/node-v0.x-archive/pull/25707
-* [[`78d256e7f5`](https://github.com/nodejs/node/commit/78d256e7f5) - test: unmark tests that are no longer flaky (João Reis) https://github.com/nodejs/node-v0.x-archive/pull/25676
-* [[`a9b642cf5b`](https://github.com/nodejs/node/commit/a9b642cf5b) - test: runner should return 0 on flaky tests (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25653
-* [[`b48639befd`](https://github.com/nodejs/node/commit/b48639befd) - test: support writing test output to file (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25653
-* [[`caa16b41d6`](https://github.com/nodejs/node/commit/caa16b41d6) - (SEMVER-MINOR) tls: prevent server from using dhe keys < 768 (Michael Dawson) https://github.com/nodejs/node/pull/3890
-* [[`0363cf4a80`](https://github.com/nodejs/node/commit/0363cf4a80) - tls: Closing parent socket also closes the tls sock (Devin Nakamura) https://github.com/nodejs/node-v0.x-archive/pull/25642
-* [[`75697112e8`](https://github.com/nodejs/node/commit/75697112e8) - tls: do not hang without `newSession` handler (Fedor Indutny) https://github.com/nodejs/node-v0.x-archive/pull/25739
-* [[`d998a65058`](https://github.com/nodejs/node/commit/d998a65058) - tools: pass constant to logger instead of string (Johan Bergström) https://github.com/nodejs/node-v0.x-archive/pull/25653
-* [[`1982ed6e63`](https://github.com/nodejs/node/commit/1982ed6e63) - v8: port fbff705 from v0.10 to v0.12 (Jeremy Whitlock) https://github.com/nodejs/node-v0.x-archive/pull/25835
-* [[`44d7054252`](https://github.com/nodejs/node/commit/44d7054252) - win: fix custom actions for WiX older than 3.9 (João Reis) https://github.com/nodejs/node/pull/2843
-* [[`586c4d8b8e`](https://github.com/nodejs/node/commit/586c4d8b8e) - win: fix custom actions on Visual Studio != 2013 (Julien Gilli) https://github.com/nodejs/node/pull/2843
-* [[`14db629497`](https://github.com/nodejs/node/commit/14db629497) - win,msi: correct installation path registry keys (João Reis) https://github.com/nodejs/node-v0.x-archive/pull/25640
-* [[`8e80528453`](https://github.com/nodejs/node/commit/8e80528453) - win,msi: change InstallScope to perMachine (João Reis) https://github.com/nodejs/node-v0.x-archive/pull/25640
-* [[`35bbe98401`](https://github.com/nodejs/node/commit/35bbe98401) - Update addons.markdown (Max Deepfield) https://github.com/nodejs/node-v0.x-archive/pull/25885
-* [[`9a6f1ce416`](https://github.com/nodejs/node/commit/9a6f1ce416) - comma (Julien Valéry) https://github.com/nodejs/node-v0.x-archive/pull/25811
-* [[`d384bf8f84`](https://github.com/nodejs/node/commit/d384bf8f84) - Update assert.markdown (daveboivin) https://github.com/nodejs/node-v0.x-archive/pull/25811
-* [[`89b22ccbe1`](https://github.com/nodejs/node/commit/89b22ccbe1) - Fixed typo (Andrew Murray) https://github.com/nodejs/node-v0.x-archive/pull/25811
-* [[`5ad05af380`](https://github.com/nodejs/node/commit/5ad05af380) - Update util.markdown (Daniel Rentz) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`cb660ab3d3`](https://github.com/nodejs/node/commit/cb660ab3d3) - Update child_process.markdown, spelling (Jared Fox) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`59c67fe3cd`](https://github.com/nodejs/node/commit/59c67fe3cd) - updated documentation for fs.createReadStream (Michele Caini) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`53b6a615a5`](https://github.com/nodejs/node/commit/53b6a615a5) - Documentation update about Buffer initialization (Sarath) https://github.com/nodejs/node-v0.x-archive/pull/25591
-* [[`b8d47a7b6f`](https://github.com/nodejs/node/commit/b8d47a7b6f) - fix (Fedor Indutny) https://github.com/nodejs/node-v0.x-archive/pull/25739
-
-<a id="0.12.7"></a>
-## 2015-07-09, Version 0.12.7 (Stable)
+* [[`d9399569bd`](https://github.com/nodejs/node/commit/d9399569bd)] - build: backport tools/release.sh (Rod Vagg) https://github.com/nodejs/node/pull/3642
+* [[`78c5b4c8bd`](https://github.com/nodejs/node/commit/78c5b4c8bd)] - build: backport config for new CI infrastructure (Rod Vagg) https://github.com/nodejs/node/pull/3642
+* [[`83441616a5`](https://github.com/nodejs/node/commit/83441616a5)] - build: fix --without-ssl compile time error (Ben Noordhuis) https://github.com/nodejs/node/pull/3825
+* [[`8887666b0b`](https://github.com/nodejs/node/commit/8887666b0b)] - build: update manifest to include Windows 10 (Lucien Greathouse) https://github.com/nodejs/node/pull/2843
+* [[`08afe4ec8e`](https://github.com/nodejs/node/commit/08afe4ec8e)] - build: add MSVS 2015 support (Rod Vagg) https://github.com/nodejs/node/pull/2843
+* [[`4f2456369c`](https://github.com/nodejs/node/commit/4f2456369c)] - build: work around VS2015 issue in ICU <56 (Steven R. Loomis) https://github.com/nodejs/node-v0.x-archive/pull/25804
+* [[`15030f26fd`](https://github.com/nodejs/node/commit/15030f26fd)] - build: Intl: bump ICU4C from 54 to 55 (backport) (Steven R. Loomis) https://github.com/nodejs/node-v0.x-archive/pull/25856
+* [[`1083fa70f0`](https://github.com/nodejs/node/commit/1083fa70f0)] - build: run-ci makefile rule (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25653
+* [[`2d2494cf14`](https://github.com/nodejs/node/commit/2d2494cf14)] - build: support flaky tests in test-ci (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25653
+* [[`b25d26f2ef`](https://github.com/nodejs/node/commit/b25d26f2ef)] - build: support Jenkins via test-ci (Alexis Campailla) https://github.com/nodejs/node-v0.x-archive/pull/25653
+* [[`7e4b47f38a`](https://github.com/nodejs/node/commit/7e4b47f38a)] - build,win: fix node.exe resource version (João Reis) https://github.com/nodejs/node/pull/3053
+* [[`e07c86e240`](https://github.com/nodejs/node/commit/e07c86e240)] - build,win: try next MSVS version on failure (João Reis) https://github.com/nodejs/node/pull/2843
+* [[`b5a0abcfdf`](https://github.com/nodejs/node/commit/b5a0abcfdf)] - child_process: clone spawn options argument (cjihrig) https://github.com/nodejs/node-v0.x-archive/pull/9159
+* [[`8b81f98c41`](https://github.com/nodejs/node/commit/8b81f98c41)] - configure: add --without-mdb flag (cgalibern) https://github.com/nodejs/node-v0.x-archive/pull/25707
+* [[`071c860c2b`](https://github.com/nodejs/node/commit/071c860c2b)] - crypto: replace rwlocks with simple mutexes (Ben Noordhuis) https://github.com/nodejs/node/pull/2723
+* [[`ca97fb6be3`](https://github.com/nodejs/node/commit/ca97fb6be3)] - deps: upgrade npm to 2.14.9 (Forrest L Norvell) https://github.com/nodejs/node/pull/3684
+* [[`583734342e`](https://github.com/nodejs/node/commit/583734342e)] - deps: fix openssl for MSVS 2015 (Andy Polyakov) https://github.com/nodejs/node/pull/2843
+* [[`02c262a4c6`](https://github.com/nodejs/node/commit/02c262a4c6)] - deps: fix gyp to work on MacOSX without XCode (Shigeki Ohtsu) https://github.com/nodejs/node/pull/2843
+* [[`f0fba0bce8`](https://github.com/nodejs/node/commit/f0fba0bce8)] - deps: update gyp to 25ed9ac (João Reis) https://github.com/nodejs/node/pull/2843
+* [[`f693565813`](https://github.com/nodejs/node/commit/f693565813)] - deps: upgrade to npm 2.13.4 (Kat Marchán) https://github.com/nodejs/node-v0.x-archive/pull/25825
+* [[`618b142679`](https://github.com/nodejs/node/commit/618b142679)] - deps,v8: fix compilation in VS2015 (João Reis) https://github.com/nodejs/node/pull/2843
+* [[`49b4f0d54e`](https://github.com/nodejs/node/commit/49b4f0d54e)] - doc: backport README.md (Rod Vagg) https://github.com/nodejs/node/pull/3642
+* [[`2860c53562`](https://github.com/nodejs/node/commit/2860c53562)] - doc: fixed child_process.exec doc (Tyler Anton) https://github.com/nodejs/node-v0.x-archive/pull/14088
+* [[`4a91fa11a3`](https://github.com/nodejs/node/commit/4a91fa11a3)] - doc: Update docs for os.platform() (George Kotchlamazashvili) https://github.com/nodejs/node-v0.x-archive/pull/25777
+* [[`b03ab02fe8`](https://github.com/nodejs/node/commit/b03ab02fe8)] - doc: Change the link for v8 docs to v8dox.com (Chad Walker) https://github.com/nodejs/node-v0.x-archive/pull/25811
+* [[`1fd8f37efd`](https://github.com/nodejs/node/commit/1fd8f37efd)] - doc: buffer, adding missing backtick (Dyana Rose) https://github.com/nodejs/node-v0.x-archive/pull/25811
+* [[`162d0db3bb`](https://github.com/nodejs/node/commit/162d0db3bb)] - doc: tls.markdown, adjust version from v0.10.39 to v0.10.x (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
+* [[`eda2560cdc`](https://github.com/nodejs/node/commit/eda2560cdc)] - doc: additional refinement to readable event (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
+* [[`881d9bea01`](https://github.com/nodejs/node/commit/881d9bea01)] - doc: readable event clarification (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
+* [[`b6378f0c75`](https://github.com/nodejs/node/commit/b6378f0c75)] - doc: stream.unshift does not reset reading state (James M Snell) https://github.com/nodejs/node-v0.x-archive/pull/25591
 
 ### Commits
 
diff --git a/doc/changelogs/CHANGELOG_V10.md b/doc/changelogs/CHANGELOG_V10.md
index d82d481ab0ad7b18dcaae920d52746d4292177a6..8a3baae0a53c575be0ce0550309f3db9e4bbfd47 100644
--- a/doc/changelogs/CHANGELOG_V10.md
+++ b/doc/changelogs/CHANGELOG_V10.md
@@ -11,6 +11,16 @@
 </tr>
 <tr>
 <td valign="top">
+<a href="#10.20.1">10.20.1</a><br/>
+<a href="#10.20.0">10.20.0</a><br/>
+<a href="#10.19.0">10.19.0</a><br/>
+<a href="#10.18.1">10.18.1</a><br/>
+<a href="#10.18.0">10.18.0</a><br/>
+<a href="#10.17.0">10.17.0</a><br/>
+<a href="#10.16.3">10.16.3</a><br/>
+<a href="#10.16.2">10.16.2</a><br/>
+<a href="#10.16.1">10.16.1</a><br/>
+<a href="#10.16.0">10.16.0</a><br/>
 <a href="#10.15.3">10.15.3</a><br/>
 <a href="#10.15.2">10.15.2</a><br/>
 <a href="#10.15.1">10.15.1</a><br/>
@@ -41,6 +51,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [9.x](CHANGELOG_V9.md)
@@ -54,6 +66,725 @@
   * [io.js](CHANGELOG_IOJS.md)
   * [Archive](CHANGELOG_ARCHIVE.md)
 
+<a id="10.20.1"></a>
+## 2020-04-12, Version 10.20.1 'Dubnium' (LTS), @BethGriggs
+
+### Notable changes
+
+Due to release process failures, Node.js v10.20.0 shipped with source
+and header tarballs that did not properly match the final release
+commit that was used to build the binaries. We recommend that Node.js
+v10.20.0 not be used, particularly in any applications using native
+add-ons or where compiling Node.js from source is involved.
+
+Node.js v10.20.1 is a clean release with the correct sources and is
+strongly recommended in place of v10.20.0.
+
+<a id="10.20.0"></a>
+## 2020-04-08, Version 10.20.0 'Dubnium' (LTS), @BethGriggs
+
+### macOS package notarization and a change in builder configuration
+
+The macOS binaries for this release, and future 10.x releases, are now
+being compiled on macOS 10.15 (Catalina) with Xcode 11 to support
+package notarization, a requirement for installing .pkg files on macOS
+10.15 and later. Previous builds of Node.js 10.x were compiled on macOS
+10.10 (Yosemite) with a minimum deployment target of macOS 10.7 (Lion).
+As binaries are still being compiled to support a minimum of macOS 10.7
+(Lion) we do not anticipate this having a negative impact on Node.js
+10.x users with older versions of macOS.
+
+### Notable changes
+
+* **buffer**: add {read|write}Big\[U\]Int64{BE|LE} methods (garygsc) [#19691](https://github.com/nodejs/node/pull/19691)
+* **build**: macOS package notarization (Rod Vagg) [#31459](https://github.com/nodejs/node/pull/31459)
+* **deps**:
+  * update npm to 6.14.3 (Myles Borins) [#32368](https://github.com/nodejs/node/pull/32368)
+  * upgrade openssl sources to 1.1.1e (Hassaan Pasha) [#32328](https://github.com/nodejs/node/pull/32328)
+  * upgrade to libuv 1.34.2 (cjihrig) [#31477](https://github.com/nodejs/node/pull/31477)
+* **n-api**:
+  * add napi\_get\_all\_property\_names (himself65) [#30006](https://github.com/nodejs/node/pull/30006)
+  * add APIs for per-instance state management (Gabriel Schulhof) [#28682](https://github.com/nodejs/node/pull/28682)
+  * define release 6 [#32058](https://github.com/nodejs/node/pull/32058)
+  * turn NAPI\_CALL\_INTO\_MODULE into a function (Anna Henningsen) [#26128](https://github.com/nodejs/node/pull/26128)
+* **tls**:
+  * expose keylog event on TLSSocket (Alba Mendez) [#27654](https://github.com/nodejs/node/pull/27654)
+  * support TLS min/max protocol defaults in CLI (Sam Roberts) [#27946](https://github.com/nodejs/node/pull/27946)
+* **url**: handle quasi-WHATWG URLs in urlToOptions() (cjihrig) [#26226](https://github.com/nodejs/node/pull/26226)
+
+### Commits
+
+* [[`64744a282e`](https://github.com/nodejs/node/commit/64744a282e)] - **(SEMVER-MINOR)** **buffer**: add {read|write}Big\[U\]Int64{BE|LE} methods (garygsc) [#19691](https://github.com/nodejs/node/pull/19691)
+* [[`8a0ed8f1ff`](https://github.com/nodejs/node/commit/8a0ed8f1ff)] - **build**: macOS package notarization (Rod Vagg) [#31459](https://github.com/nodejs/node/pull/31459)
+* [[`42af3b861a`](https://github.com/nodejs/node/commit/42af3b861a)] - **build,win**: fix goto exit in vcbuild (João Reis) [#30931](https://github.com/nodejs/node/pull/30931)
+* [[`b164a2e3bf`](https://github.com/nodejs/node/commit/b164a2e3bf)] - **console**: add trace-events for time and count (James M Snell) [#23703](https://github.com/nodejs/node/pull/23703)
+* [[`04cd67f85e`](https://github.com/nodejs/node/commit/04cd67f85e)] - **deps**: upgrade npm to 6.14.4 (Ruy Adorno) [#32495](https://github.com/nodejs/node/pull/32495)
+* [[`8d85a43d99`](https://github.com/nodejs/node/commit/8d85a43d99)] - **deps**: update term-size with signed version (Rod Vagg) [#31459](https://github.com/nodejs/node/pull/31459)
+* [[`76033c5495`](https://github.com/nodejs/node/commit/76033c5495)] - **deps**: update archs files for OpenSSL-1.1.1e (Hassaan Pasha) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`64c184836b`](https://github.com/nodejs/node/commit/64c184836b)] - **deps**: adjust openssl configuration for 1.1.1e (Hassaan Pasha) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`c8f5ab2089`](https://github.com/nodejs/node/commit/c8f5ab2089)] - **deps**: upgrade openssl sources to 1.1.1e (Hassaan Pasha) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`bf26c44c92`](https://github.com/nodejs/node/commit/bf26c44c92)] - **deps**: remove \*.pyc files from deps/npm (Ben Noordhuis) [#32387](https://github.com/nodejs/node/pull/32387)
+* [[`c2b3cf61ce`](https://github.com/nodejs/node/commit/c2b3cf61ce)] - **deps**: update npm to 6.14.3 (Myles Borins) [#32368](https://github.com/nodejs/node/pull/32368)
+* [[`8cae4dde91`](https://github.com/nodejs/node/commit/8cae4dde91)] - **deps**: upgrade npm to 6.14.1 (Isaac Z. Schlueter) [#31977](https://github.com/nodejs/node/pull/31977)
+* [[`47046aa5a9`](https://github.com/nodejs/node/commit/47046aa5a9)] - **deps**: openssl: cherry-pick 4dcb150ea30f (Adam Majer) [#32002](https://github.com/nodejs/node/pull/32002)
+* [[`098704c85d`](https://github.com/nodejs/node/commit/098704c85d)] - **deps**: upgrade to libuv 1.34.2 (Colin Ihrig) [#31477](https://github.com/nodejs/node/pull/31477)
+* [[`4b1cccc4ce`](https://github.com/nodejs/node/commit/4b1cccc4ce)] - **deps**: upgrade to libuv 1.34.1 (Colin Ihrig) [#31332](https://github.com/nodejs/node/pull/31332)
+* [[`fff6162693`](https://github.com/nodejs/node/commit/fff6162693)] - **(SEMVER-MINOR)** **deps**: upgrade to libuv 1.34.0 (Colin Ihrig) [#30783](https://github.com/nodejs/node/pull/30783)
+* [[`6826ef0568`](https://github.com/nodejs/node/commit/6826ef0568)] - **deps**: upgrade to libuv 1.33.1 (Colin Ihrig) [#29996](https://github.com/nodejs/node/pull/29996)
+* [[`aed7ca4fb0`](https://github.com/nodejs/node/commit/aed7ca4fb0)] - **deps**: upgrade to libuv 1.32.0 (Colin Ihrig) [#29508](https://github.com/nodejs/node/pull/29508)
+* [[`794abbc758`](https://github.com/nodejs/node/commit/794abbc758)] - **deps**: upgrade to libuv 1.31.0 (Colin Ihrig) [#29070](https://github.com/nodejs/node/pull/29070)
+* [[`ed71f55a54`](https://github.com/nodejs/node/commit/ed71f55a54)] - **deps**: upgrade to libuv 1.30.1 (Colin Ihrig) [#28511](https://github.com/nodejs/node/pull/28511)
+* [[`7cde563235`](https://github.com/nodejs/node/commit/7cde563235)] - **deps**: upgrade to libuv 1.30.0 (Colin Ihrig) [#28449](https://github.com/nodejs/node/pull/28449)
+* [[`b53ce6e6c5`](https://github.com/nodejs/node/commit/b53ce6e6c5)] - **deps**: upgrade to libuv 1.29.1 (Colin Ihrig) [#27718](https://github.com/nodejs/node/pull/27718)
+* [[`9b2b66b7d8`](https://github.com/nodejs/node/commit/9b2b66b7d8)] - **deps**: V8: cherry-pick d89f4ef1cd62 (Milad Farazmand) [#31753](https://github.com/nodejs/node/pull/31753)
+* [[`7eac95981e`](https://github.com/nodejs/node/commit/7eac95981e)] - **deps**: upgrade npm to 6.13.7 (Michael Perrotte) [#31558](https://github.com/nodejs/node/pull/31558)
+* [[`db24641fbe`](https://github.com/nodejs/node/commit/db24641fbe)] - **deps**: upgrade npm to 6.13.6 (Ruy Adorno) [#31304](https://github.com/nodejs/node/pull/31304)
+* [[`2e3d511cff`](https://github.com/nodejs/node/commit/2e3d511cff)] - **doc**: correct version metadata for Readable.from (Dave Vandyke) [#32639](https://github.com/nodejs/node/pull/32639)
+* [[`34c1c2a82b`](https://github.com/nodejs/node/commit/34c1c2a82b)] - **doc**: add missing version metadata for Readable.from (Anna Henningsen) [#28695](https://github.com/nodejs/node/pull/28695)
+* [[`aa7d369c72`](https://github.com/nodejs/node/commit/aa7d369c72)] - **doc**: update releaser list in README.md (Myles Borins) [#32577](https://github.com/nodejs/node/pull/32577)
+* [[`05f5b3ecc4`](https://github.com/nodejs/node/commit/05f5b3ecc4)] - **doc**: remove em dashes (Rich Trott) [#32080](https://github.com/nodejs/node/pull/32080)
+* [[`ffa9f9bd1b`](https://github.com/nodejs/node/commit/ffa9f9bd1b)] - **doc**: fix changelog for v10.18.1 (Andrew Hughes) [#31358](https://github.com/nodejs/node/pull/31358)
+* [[`0177464b0e`](https://github.com/nodejs/node/commit/0177464b0e)] - **doc,tools**: get altDocs versions from CHANGELOG.md (Richard Lau) [#27661](https://github.com/nodejs/node/pull/27661)
+* [[`e9c590ea00`](https://github.com/nodejs/node/commit/e9c590ea00)] - **(SEMVER-MINOR)** **n-api**: define release 6 (Gabriel Schulhof) [#32058](https://github.com/nodejs/node/pull/32058)
+* [[`239377b654`](https://github.com/nodejs/node/commit/239377b654)] - **(SEMVER-MINOR)** **n-api**: correct instance data tests (Gabriel Schulhof) [#32488](https://github.com/nodejs/node/pull/32488)
+* [[`ecbb331be0`](https://github.com/nodejs/node/commit/ecbb331be0)] - **(SEMVER-MINOR)** **n-api**: add napi\_get\_all\_property\_names (himself65) [#30006](https://github.com/nodejs/node/pull/30006)
+* [[`f29fb14cf6`](https://github.com/nodejs/node/commit/f29fb14cf6)] - **(SEMVER-MINOR)** **n-api**: add APIs for per-instance state management (Gabriel Schulhof) [#28682](https://github.com/nodejs/node/pull/28682)
+* [[`20177b9946`](https://github.com/nodejs/node/commit/20177b9946)] - **n-api**: turn NAPI\_CALL\_INTO\_MODULE into a function (Anna Henningsen) [#26128](https://github.com/nodejs/node/pull/26128)
+* [[`017909b847`](https://github.com/nodejs/node/commit/017909b847)] - **test**: fix tool path in test-doctool-versions.js (Richard Lau) [#32645](https://github.com/nodejs/node/pull/32645)
+* [[`1ea70d641d`](https://github.com/nodejs/node/commit/1ea70d641d)] - **test**: fix flaky doctool and test (Rich Trott) [#29979](https://github.com/nodejs/node/pull/29979)
+* [[`89692ff19b`](https://github.com/nodejs/node/commit/89692ff19b)] - **test**: end tls connection with some data (Sam Roberts) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`9bd1317764`](https://github.com/nodejs/node/commit/9bd1317764)] - **test**: mark empty udp tests flaky on OS X (Sam Roberts) [#31936](https://github.com/nodejs/node/pull/31936)
+* [[`5484e061b5`](https://github.com/nodejs/node/commit/5484e061b5)] - **test**: scale keepalive timeouts for slow machines (Ben Noordhuis) [#30834](https://github.com/nodejs/node/pull/30834)
+* [[`3f9cec3f51`](https://github.com/nodejs/node/commit/3f9cec3f51)] - **test**: add debugging output to test-net-listen-after-destroy-stdin (Rich Trott) [#31698](https://github.com/nodejs/node/pull/31698)
+* [[`f1a8791316`](https://github.com/nodejs/node/commit/f1a8791316)] - **test**: allow EAI\_FAIL in test-http-dns-error.js (Colin Ihrig) [#27500](https://github.com/nodejs/node/pull/27500)
+* [[`4b9a77909b`](https://github.com/nodejs/node/commit/4b9a77909b)] - **test**: mark tests as flaky (João Reis) [#30848](https://github.com/nodejs/node/pull/30848)
+* [[`a8fd8a1a61`](https://github.com/nodejs/node/commit/a8fd8a1a61)] - **test**: mark http2 tests as flaky on 10.x (AshCripps) [#31887](https://github.com/nodejs/node/pull/31887)
+* [[`2315270cb6`](https://github.com/nodejs/node/commit/2315270cb6)] - **test**: try to stabalize test-child-process-fork-exec-path.js (Refael Ackermann) [#27277](https://github.com/nodejs/node/pull/27277)
+* [[`a2b0e9ef6a`](https://github.com/nodejs/node/commit/a2b0e9ef6a)] - **(SEMVER-MINOR)** **tls**: expose keylog event on TLSSocket (Alba Mendez) [#27654](https://github.com/nodejs/node/pull/27654)
+* [[`1cfb45732a`](https://github.com/nodejs/node/commit/1cfb45732a)] - **(SEMVER-MINOR)** **tls**: support TLS min/max protocol defaults in CLI (Sam Roberts) [#27946](https://github.com/nodejs/node/pull/27946)
+* [[`a175b8d3a7`](https://github.com/nodejs/node/commit/a175b8d3a7)] - **tools**: only fetch previous versions when necessary (Richard Lau) [#32518](https://github.com/nodejs/node/pull/32518)
+* [[`3756be8511`](https://github.com/nodejs/node/commit/3756be8511)] - **tools**: add NODE\_TEST\_NO\_INTERNET to the doc builder (Joyee Cheung) [#31849](https://github.com/nodejs/node/pull/31849)
+* [[`ac1ea7312a`](https://github.com/nodejs/node/commit/ac1ea7312a)] - **tools**: make doctool work if no internet available (Richard Lau) [#30214](https://github.com/nodejs/node/pull/30214)
+* [[`f235eea8b3`](https://github.com/nodejs/node/commit/f235eea8b3)] - **tools**: unify make-v8.sh for ppc64le and s390x (Richard Lau) [#31628](https://github.com/nodejs/node/pull/31628)
+* [[`61e2d4856d`](https://github.com/nodejs/node/commit/61e2d4856d)] - **tools**: use CC instead of CXX when pointing to gcc (Milad Farazmand) [#30817](https://github.com/nodejs/node/pull/30817)
+* [[`4390674624`](https://github.com/nodejs/node/commit/4390674624)] - **url**: handle quasi-WHATWG URLs in urlToOptions() (Colin Ihrig) [#26226](https://github.com/nodejs/node/pull/26226)
+* [[`dc61e09feb`](https://github.com/nodejs/node/commit/dc61e09feb)] - **v8**: fix load elimination liveness checks (Ben Noordhuis) [#31613](https://github.com/nodejs/node/pull/31613)
+
+<a id="10.19.0"></a>
+## 2020-02-06, Version 10.19.0 'Dubnium' (LTS), @BethGriggs
+
+### Notable changes
+
+This is a security release.
+
+Vulnerabilities fixed:
+* **CVE-2019-15606**: HTTP header values do not have trailing OWS trimmed.
+* **CVE-2019-15605**: HTTP request smuggling using malformed Transfer-Encoding header.
+* **CVE-2019-15604**: Remotely trigger an assertion on a TLS server with a malformed certificate string.
+
+Also, HTTP parsing is more strict to be more secure. Since this may
+cause problems in interoperability with some non-conformant HTTP
+implementations, it is possible to disable the strict checks with the
+`--insecure-http-parser` command line flag, or the `insecureHTTPParser`
+http option. Using the insecure HTTP parser should be avoided.
+
+### Commits
+
+* [[`f940bee3b7`](https://github.com/nodejs/node/commit/f940bee3b7)] - **crypto**: fix assertion caused by unsupported ext (Fedor Indutny) [nodejs-private/node-private#175](https://github.com/nodejs-private/node-private/pull/175)
+* [[`49f4220ce5`](https://github.com/nodejs/node/commit/49f4220ce5)] - **deps**: upgrade http-parser to v2.9.3 (Sam Roberts) [nodejs-private/http-parser-private#4](https://github.com/nodejs-private/http-parser-private/pull/4)
+* [[`a28e5cc1ed`](https://github.com/nodejs/node/commit/a28e5cc1ed)] - **(SEMVER-MINOR)** **deps**: upgrade http-parser to v2.9.1 (Sam Roberts) [#30471](https://github.com/nodejs/node/pull/30471)
+* [[`0082f62d9c`](https://github.com/nodejs/node/commit/0082f62d9c)] - **(SEMVER-MINOR)** **http**: make --insecure-http-parser configurable per-stream or per-server (Anna Henningsen) [#31448](https://github.com/nodejs/node/pull/31448)
+* [[`a9849c0ff6`](https://github.com/nodejs/node/commit/a9849c0ff6)] - **(SEMVER-MINOR)** **http**: opt-in insecure HTTP header parsing (Sam Roberts) [#30567](https://github.com/nodejs/node/pull/30567)
+* [[`2eee90e959`](https://github.com/nodejs/node/commit/2eee90e959)] - **http**: strip trailing OWS from header values (Sam Roberts) [nodejs-private/node-private#191](https://github.com/nodejs-private/node-private/pull/191)
+* [[`e2c8f89b75`](https://github.com/nodejs/node/commit/e2c8f89b75)] - **test**: using TE to smuggle reqs is not possible (Sam Roberts) [nodejs-private/node-private#192](https://github.com/nodejs-private/node-private/pull/192)
+* [[`d616722f65`](https://github.com/nodejs/node/commit/d616722f65)] - **test**: check that --insecure-http-parser works (Sam Roberts) [#31253](https://github.com/nodejs/node/pull/31253)
+
+<a id="10.18.1"></a>
+## 2020-01-09, Version 10.18.1 'Dubnium' (LTS), @BethGriggs
+
+### Notable changes
+
+* **http2**: fix session memory accounting after pausing (Michael Lehenbauer) [#30684](https://github.com/nodejs/node/pull/30684)
+* **n-api**: correct bug in napi_get_last_error (Octavian Soldea) [#28702](https://github.com/nodejs/node/pull/28702)
+* **tools**: update tzdata to 2019c (Myles Borins) [#30479](https://github.com/nodejs/node/pull/30479)
+
+### Commits
+
+* [[`a80c59130e`](https://github.com/nodejs/node/commit/a80c59130e)] - **build**: fix configure script to work with Apple Clang 11 (Saagar Jha) [#28071](https://github.com/nodejs/node/pull/28071)
+* [[`68b2b5cc51`](https://github.com/nodejs/node/commit/68b2b5cc51)] - **build,win**: propagate error codes in vcbuild (João Reis) [#30724](https://github.com/nodejs/node/pull/30724)
+* [[`3e0709cf5e`](https://github.com/nodejs/node/commit/3e0709cf5e)] - **deps**: V8: backport fb63e5cf55e9 (Michaël Zasso) [#30372](https://github.com/nodejs/node/pull/30372)
+* [[`25b8fbda35`](https://github.com/nodejs/node/commit/25b8fbda35)] - **doc**: allow \<code\> in header elements (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`a1b095dd46`](https://github.com/nodejs/node/commit/a1b095dd46)] - **doc,dns**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`8f3b8ca515`](https://github.com/nodejs/node/commit/8f3b8ca515)] - **http2**: fix session memory accounting after pausing (Michael Lehenbauer) [#30684](https://github.com/nodejs/node/pull/30684)
+* [[`20f64a96de`](https://github.com/nodejs/node/commit/20f64a96de)] - **http2**: use the latest settings (ZYSzys) [#29780](https://github.com/nodejs/node/pull/29780)
+* [[`81c31005fd`](https://github.com/nodejs/node/commit/81c31005fd)] - **lib**: fix comment nits in bootstrap\loaders.js (Vse Mozhet Byt) [#24641](https://github.com/nodejs/node/pull/24641)
+* [[`88e8b7cf83`](https://github.com/nodejs/node/commit/88e8b7cf83)] - **n-api**: correct bug in napi_get_last_error (Octavian Soldea) [#28702](https://github.com/nodejs/node/pull/28702)
+* [[`77e0318849`](https://github.com/nodejs/node/commit/77e0318849)] - **stream**: increase MAX_HWM (Robert Nagy) [#29938](https://github.com/nodejs/node/pull/29938)
+* [[`894aaa2040`](https://github.com/nodejs/node/commit/894aaa2040)] - **stream**: extract Readable.from in its own file (Matteo Collina) [#30140](https://github.com/nodejs/node/pull/30140)
+* [[`7e941eb17d`](https://github.com/nodejs/node/commit/7e941eb17d)] - **test**: do not fail SLOW tests if they are not slow (Yang Guo) [#25868](https://github.com/nodejs/node/pull/25868)
+* [[`0f3ae77aaf`](https://github.com/nodejs/node/commit/0f3ae77aaf)] - **tools**: update tzdata to 2019c (Myles Borins) [#30479](https://github.com/nodejs/node/pull/30479)
+* [[`4ae8d204cb`](https://github.com/nodejs/node/commit/4ae8d204cb)] - **tools**: move python code out of jenkins shell (Sam Roberts) [#28458](https://github.com/nodejs/node/pull/28458)
+* [[`4879b80d87`](https://github.com/nodejs/node/commit/4879b80d87)] - **tools**: fix v8 testing with devtoolset on ppcle (Sam Roberts) [#28458](https://github.com/nodejs/node/pull/28458)
+
+<a id="10.18.0"></a>
+## 2019-12-17, Version 10.18.0 'Dubnium' (LTS), @MylesBorins
+
+This is a security release.
+
+For more details about the vulnerability please consult the npm blog:
+
+https://blog.npmjs.org/post/189618601100/binary-planting-with-the-npm-cli
+
+### Notable changes
+
+* **deps**: update npm to 6.13.4 [#30904](https://github.com/nodejs/node/pull/30904)
+
+### Commits
+
+* [[`54a466a865`](https://github.com/nodejs/node/commit/54a466a865)] - **build,win**: add test-ci-native and test-ci-js (João Reis) [#30724](https://github.com/nodejs/node/pull/30724)
+* [[`f9b31edb25`](https://github.com/nodejs/node/commit/f9b31edb25)] - **deps**: update npm to 6.13.4 (Isaac Z. Schlueter) [#30904](https://github.com/nodejs/node/pull/30904)
+
+<a id="10.17.0"></a>
+## 2019-10-22, Version 10.17.0 'Dubnium' (LTS), @BethGriggs
+
+### Notable changes
+
+* **crypto**:
+  * add support for chacha20-poly1305 for AEAD (chux0519) [#24081](https://github.com/nodejs/node/pull/24081)
+  * increase maxmem range from 32 to 53 bits (Tobias Nießen) [#28799](https://github.com/nodejs/node/pull/28799)
+* **deps**:
+  * update npm to 6.11.3 (claudiahdz) [#29430](https://github.com/nodejs/node/pull/29430)
+  * upgrade openssl sources to 1.1.1d (Sam Roberts) [#29921](https://github.com/nodejs/node/pull/29921)
+* **dns**: remove dns.promises experimental warning (cjihrig) [#26592](https://github.com/nodejs/node/pull/26592)
+* **fs**: remove experimental warning for fs.promises (Anna Henningsen) [#26581](https://github.com/nodejs/node/pull/26581)
+* **http**: makes response.writeHead return the response (Mark S. Everitt) [#25974](https://github.com/nodejs/node/pull/25974)
+* **http2**: makes response.writeHead return the response (Mark S. Everitt) [#25974](https://github.com/nodejs/node/pull/25974)
+* **n-api**:
+  * make func argument of napi\_create\_threadsafe\_function optional (legendecas) [#27791](https://github.com/nodejs/node/pull/27791)
+  * mark version 5 N-APIs as stable (Gabriel Schulhof) [#29401](https://github.com/nodejs/node/pull/29401)
+  * implement date object (Jarrod Connolly) [#25917](https://github.com/nodejs/node/pull/25917)
+* **process**: add --unhandled-rejections flag (Ruben Bridgewater) [#26599](https://github.com/nodejs/node/pull/26599)
+* **stream**:
+  * implement Readable.from async iterator utility (Guy Bedford) [#27660](https://github.com/nodejs/node/pull/27660)
+  * make Symbol.asyncIterator support stable (Matteo Collina) [#26989](https://github.com/nodejs/node/pull/26989)
+
+### Commits
+
+* [[`f1a5a36961`](https://github.com/nodejs/node/commit/f1a5a36961)] - **build**: update Windows icon to Feb 2016 rebrand (Mike MacCana) [#28524](https://github.com/nodejs/node/pull/28524)
+* [[`63de2ade85`](https://github.com/nodejs/node/commit/63de2ade85)] - **(SEMVER-MINOR)** **crypto**: add support for chacha20-poly1305 for AEAD (chux0519) [#24081](https://github.com/nodejs/node/pull/24081)
+* [[`4f0f12c3d6`](https://github.com/nodejs/node/commit/4f0f12c3d6)] - **crypto**: fix rsa key gen with non-default exponent (Sam Roberts) [#27092](https://github.com/nodejs/node/pull/27092)
+* [[`7735824d2c`](https://github.com/nodejs/node/commit/7735824d2c)] - **(SEMVER-MINOR)** **crypto**: increase maxmem range from 32 to 53 bits (Tobias Nießen) [#28799](https://github.com/nodejs/node/pull/28799)
+* [[`e53dbba6bc`](https://github.com/nodejs/node/commit/e53dbba6bc)] - **deps**: update npm to 6.11.3 (claudiahdz) [#29430](https://github.com/nodejs/node/pull/29430)
+* [[`55cd01c5c3`](https://github.com/nodejs/node/commit/55cd01c5c3)] - **(SEMVER-MINOR)** **deps**: update npm to 6.10.3 (isaacs) [#29023](https://github.com/nodejs/node/pull/29023)
+* [[`e2291cf805`](https://github.com/nodejs/node/commit/e2291cf805)] - **deps**: upgrade npm to 6.10.2 (isaacs) [#28853](https://github.com/nodejs/node/pull/28853)
+* [[`03b69660f9`](https://github.com/nodejs/node/commit/03b69660f9)] - **deps**: upgrade npm to 6.10.0 (isaacs) [#28525](https://github.com/nodejs/node/pull/28525)
+* [[`333963ef73`](https://github.com/nodejs/node/commit/333963ef73)] - **deps**: dlloads node static linked executable (Luca Lindhorst) [#28045](https://github.com/nodejs/node/pull/28045)
+* [[`7202792ad3`](https://github.com/nodejs/node/commit/7202792ad3)] - **deps**: update archs files for OpenSSL-1.1.1d (Sam Roberts) [#29921](https://github.com/nodejs/node/pull/29921)
+* [[`9c393f1d02`](https://github.com/nodejs/node/commit/9c393f1d02)] - **deps**: upgrade openssl sources to 1.1.1d (Sam Roberts) [#29921](https://github.com/nodejs/node/pull/29921)
+* [[`7f48519413`](https://github.com/nodejs/node/commit/7f48519413)] - **deps**: do not link against librt (Sam Roberts) [#29729](https://github.com/nodejs/node/pull/29729)
+* [[`fcc22d31a0`](https://github.com/nodejs/node/commit/fcc22d31a0)] - **(SEMVER-MINOR)** **dns**: make dns.promises enumerable (cjihrig) [#26592](https://github.com/nodejs/node/pull/26592)
+* [[`fa27aac5fb`](https://github.com/nodejs/node/commit/fa27aac5fb)] - **(SEMVER-MINOR)** **dns**: remove dns.promises experimental warning (cjihrig) [#26592](https://github.com/nodejs/node/pull/26592)
+* [[`90fb146933`](https://github.com/nodejs/node/commit/90fb146933)] - **(SEMVER-MINOR)** **doc**: move dns.promises to stable status (cjihrig) [#26592](https://github.com/nodejs/node/pull/26592)
+* [[`65e68d1f4f`](https://github.com/nodejs/node/commit/65e68d1f4f)] - **doc**: add documentation for stream readableFlowing (Chetan Karande) [#29506](https://github.com/nodejs/node/pull/29506)
+* [[`c285e694e2`](https://github.com/nodejs/node/commit/c285e694e2)] - **doc**: fix the links tls default version sections (Chetan Karande) [#28827](https://github.com/nodejs/node/pull/28827)
+* [[`cef5010135`](https://github.com/nodejs/node/commit/cef5010135)] - **doc**: describe tls.DEFAULT\_MIN\_VERSION/\_MAX\_VERSION (Chetan Karande) [#28827](https://github.com/nodejs/node/pull/28827)
+* [[`15c2eb0e58`](https://github.com/nodejs/node/commit/15c2eb0e58)] - **doc**: update N-API version matrix (Gabriel Schulhof) [#29461](https://github.com/nodejs/node/pull/29461)
+* [[`a3eda2896d`](https://github.com/nodejs/node/commit/a3eda2896d)] - **doc**: fixup changelog for v10.16.3 (Andrew Hughes) [#29159](https://github.com/nodejs/node/pull/29159)
+* [[`56a834a53f`](https://github.com/nodejs/node/commit/56a834a53f)] - **doc,test**: clarify that Http2Stream is destroyed after data is read (Alba Mendez) [#27891](https://github.com/nodejs/node/pull/27891)
+* [[`85ce8ef19a`](https://github.com/nodejs/node/commit/85ce8ef19a)] - **(SEMVER-MINOR)** **fs**: remove experimental warning for fs.promises (Anna Henningsen) [#26581](https://github.com/nodejs/node/pull/26581)
+* [[`ccf2823f83`](https://github.com/nodejs/node/commit/ccf2823f83)] - **(SEMVER-MINOR)** **http**: makes response.writeHead return the response (Mark S. Everitt) [#25974](https://github.com/nodejs/node/pull/25974)
+* [[`66387cd45e`](https://github.com/nodejs/node/commit/66387cd45e)] - **http2**: send out pending data earlier (Anna Henningsen) [#29398](https://github.com/nodejs/node/pull/29398)
+* [[`925849650b`](https://github.com/nodejs/node/commit/925849650b)] - **(SEMVER-MINOR)** **http2**: makes response.writeHead return the response (Mark S. Everitt) [#25974](https://github.com/nodejs/node/pull/25974)
+* [[`69b0212df3`](https://github.com/nodejs/node/commit/69b0212df3)] - **http2**: do not start reading after write if new write is on wire (Anna Henningsen) [#29399](https://github.com/nodejs/node/pull/29399)
+* [[`36a0e9a063`](https://github.com/nodejs/node/commit/36a0e9a063)] - **http2**: do not crash on stream listener removal w/ destroyed session (Anna Henningsen) [#29459](https://github.com/nodejs/node/pull/29459)
+* [[`c74c6a5ccf`](https://github.com/nodejs/node/commit/c74c6a5ccf)] - **n-api**: mark version 5 N-APIs as stable (Gabriel Schulhof) [#29401](https://github.com/nodejs/node/pull/29401)
+* [[`f8622762e3`](https://github.com/nodejs/node/commit/f8622762e3)] - **(SEMVER-MINOR)** **n-api**: make func argument of napi\_create\_threadsafe\_function optional (legendecas) [#27791](https://github.com/nodejs/node/pull/27791)
+* [[`4f41e4f471`](https://github.com/nodejs/node/commit/4f41e4f471)] - **(SEMVER-MINOR)** **n-api**: implement date object (Jarrod Connolly) [#25917](https://github.com/nodejs/node/pull/25917)
+* [[`69bf5b7944`](https://github.com/nodejs/node/commit/69bf5b7944)] - **net**: treat ENOTCONN at shutdown as success (Anna Henningsen) [#29912](https://github.com/nodejs/node/pull/29912)
+* [[`d6c998a478`](https://github.com/nodejs/node/commit/d6c998a478)] - **process**: use public readableFlowing property (Chetan Karande) [#29502](https://github.com/nodejs/node/pull/29502)
+* [[`b43d7e8f42`](https://github.com/nodejs/node/commit/b43d7e8f42)] - **(SEMVER-MINOR)** **process**: add --unhandled-rejections flag (Ruben Bridgewater) [#26599](https://github.com/nodejs/node/pull/26599)
+* [[`79f3844fb0`](https://github.com/nodejs/node/commit/79f3844fb0)] - **(SEMVER-MINOR)** **readline**: make Symbol.asyncIterator support stable (Matteo Collina) [#26989](https://github.com/nodejs/node/pull/26989)
+* [[`18b140ae75`](https://github.com/nodejs/node/commit/18b140ae75)] - **src**: use maybe version v8::Function::Call (Ouyang Yadong) [#23826](https://github.com/nodejs/node/pull/23826)
+* [[`1bb5102999`](https://github.com/nodejs/node/commit/1bb5102999)] - **src**: use more explicit return type in Sign::SignFinal() (Anna Henningsen) [#23779](https://github.com/nodejs/node/pull/23779)
+* [[`859d47593e`](https://github.com/nodejs/node/commit/859d47593e)] - **src**: reduce platform worker barrier lifetime (Ali Ijaz Sheikh) [#23419](https://github.com/nodejs/node/pull/23419)
+* [[`00831f0293`](https://github.com/nodejs/node/commit/00831f0293)] - **(SEMVER-MINOR)** **stream**: make Symbol.asyncIterator support stable (Matteo Collina) [#26989](https://github.com/nodejs/node/pull/26989)
+* [[`ddb5152e9b`](https://github.com/nodejs/node/commit/ddb5152e9b)] - **(SEMVER-MINOR)** **stream**: implement Readable.from async iterator utility (Guy Bedford) [#27660](https://github.com/nodejs/node/pull/27660)
+* [[`13d8549abd`](https://github.com/nodejs/node/commit/13d8549abd)] - **test**: well-defined DH groups now verify clean (Sam Roberts) [#29550](https://github.com/nodejs/node/pull/29550)
+* [[`f78ecc3f93`](https://github.com/nodejs/node/commit/f78ecc3f93)] - **test**: fix race in test-http2-origin (Alba Mendez) [#28903](https://github.com/nodejs/node/pull/28903)
+* [[`2afbb3efab`](https://github.com/nodejs/node/commit/2afbb3efab)] - **test,win**: cleanup exec-timeout processes (João Reis) [#28723](https://github.com/nodejs/node/pull/28723)
+* [[`fe58bca878`](https://github.com/nodejs/node/commit/fe58bca878)] - **tls**: group chunks into TLS segments (Alba Mendez) [#27861](https://github.com/nodejs/node/pull/27861)
+* [[`2eae030a4b`](https://github.com/nodejs/node/commit/2eae030a4b)] - **(SEMVER-MINOR)** **worker**: add missing return value in case of fatal exceptions (Ruben Bridgewater) [#29036](https://github.com/nodejs/node/pull/29036)
+* [[`e8c90bf4d1`](https://github.com/nodejs/node/commit/e8c90bf4d1)] - **zlib**: do not coalesce multiple `.flush()` calls (Anna Henningsen) [#28520](https://github.com/nodejs/node/pull/28520)
+
+<a id="10.16.3"></a>
+## 2019-08-15, Version 10.16.3 'Dubnium' (LTS), @BethGriggs
+
+### Notable changes
+
+This is a security release.
+
+Node.js, as well as many other implementations of HTTP/2, have been found
+vulnerable to Denial of Service attacks.
+See https://github.com/Netflix/security-bulletins/blob/master/advisories/third-party/2019-002.md
+for more information.
+
+Vulnerabilities fixed:
+
+* **CVE-2019-9511 “Data Dribble”**: The attacker requests a large amount of data from a specified resource over multiple streams. They manipulate window size and stream priority to force the server to queue the data in 1-byte chunks. Depending on how efficiently this data is queued, this can consume excess CPU, memory, or both, potentially leading to a denial of service.
+* **CVE-2019-9512 “Ping Flood”**: The attacker sends continual pings to an HTTP/2 peer, causing the peer to build an internal queue of responses. Depending on how efficiently this data is queued, this can consume excess CPU, memory, or both, potentially leading to a denial of service.
+* **CVE-2019-9513 “Resource Loop”**: The attacker creates multiple request streams and continually shuffles the priority of the streams in a way that causes substantial churn to the priority tree. This can consume excess CPU, potentially leading to a denial of service.
+* **CVE-2019-9514 “Reset Flood”**: The attacker opens a number of streams and sends an invalid request over each stream that should solicit a stream of RST_STREAM frames from the peer. Depending on how the peer queues the RST_STREAM frames, this can consume excess memory, CPU, or both, potentially leading to a denial of service.
+* **CVE-2019-9515 “Settings Flood”**: The attacker sends a stream of SETTINGS frames to the peer. Since the RFC requires that the peer reply with one acknowledgement per SETTINGS frame, an empty SETTINGS frame is almost equivalent in behavior to a ping. Depending on how efficiently this data is queued, this can consume excess CPU, memory, or both, potentially leading to a denial of service.
+* **CVE-2019-9516 “0-Length Headers Leak”**: The attacker sends a stream of headers with a 0-length header name and 0-length header value, optionally Huffman encoded into 1-byte or greater headers. Some implementations allocate memory for these headers and keep the allocation alive until the session dies. This can consume excess memory, potentially leading to a denial of service.
+* **CVE-2019-9517 “Internal Data Buffering”**: The attacker opens the HTTP/2 window so the peer can send without constraint; however, they leave the TCP window closed so the peer cannot actually write (many of) the bytes on the wire. The attacker then sends a stream of requests for a large response object. Depending on how the servers queue the responses, this can consume excess memory, CPU, or both, potentially leading to a denial of service.
+* **CVE-2019-9518 “Empty Frames Flood”**: The attacker sends a stream of frames with an empty payload and without the end-of-stream flag. These frames can be DATA, HEADERS, CONTINUATION and/or PUSH_PROMISE. The peer spends time processing each frame disproportionate to attack bandwidth. This can consume excess CPU, potentially leading to a denial of service. (Discovered by Piotr Sikora of Google)
+
+### Commits
+
+* [[`74507fae34`](https://github.com/nodejs/node/commit/74507fae34)] - **deps**: update nghttp2 to 1.39.2 (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`a397c881ec`](https://github.com/nodejs/node/commit/a397c881ec)] - **deps**: update nghttp2 to 1.39.1 (gengjiawen) [#28448](https://github.com/nodejs/node/pull/28448)
+* [[`fedfa12a33`](https://github.com/nodejs/node/commit/fedfa12a33)] - **deps**: update nghttp2 to 1.38.0 (gengjiawen) [#27295](https://github.com/nodejs/node/pull/27295)
+* [[`ab0f2ace36`](https://github.com/nodejs/node/commit/ab0f2ace36)] - **deps**: update nghttp2 to 1.37.0 (gengjiawen) [#26990](https://github.com/nodejs/node/pull/26990)
+* [[`0acbe05ee2`](https://github.com/nodejs/node/commit/0acbe05ee2)] - **http2**: allow security revert for Ping/Settings Flood (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`c152449012`](https://github.com/nodejs/node/commit/c152449012)] - **http2**: pause input processing if sending output (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`0ce699c7b1`](https://github.com/nodejs/node/commit/0ce699c7b1)] - **http2**: stop reading from socket if writes are in progress (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`17357d37a9`](https://github.com/nodejs/node/commit/17357d37a9)] - **http2**: consider 0-length non-end DATA frames an error (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`460f896c63`](https://github.com/nodejs/node/commit/460f896c63)] - **http2**: shrink default `vector::reserve()` allocations (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`f4242e24f9`](https://github.com/nodejs/node/commit/f4242e24f9)] - **http2**: handle 0-length headers better (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`477461a51f`](https://github.com/nodejs/node/commit/477461a51f)] - **http2**: limit number of invalid incoming frames (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`05dada46ee`](https://github.com/nodejs/node/commit/05dada46ee)] - **http2**: limit number of rejected stream openings (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`7f11465572`](https://github.com/nodejs/node/commit/7f11465572)] - **http2**: do not create ArrayBuffers when no DATA received (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`2eb914ff5f`](https://github.com/nodejs/node/commit/2eb914ff5f)] - **http2**: only call into JS when necessary for session events (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`76a7ada15d`](https://github.com/nodejs/node/commit/76a7ada15d)] - **http2**: improve JS-side debug logging (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`00f153da13`](https://github.com/nodejs/node/commit/00f153da13)] - **http2**: improve http2 code a bit (James M Snell) [#23984](https://github.com/nodejs/node/pull/23984)
+* [[`a0a14c809f`](https://github.com/nodejs/node/commit/a0a14c809f)] - **src**: pass along errors from http2 object creation (Anna Henningsen) [#25822](https://github.com/nodejs/node/pull/25822)
+* [[`d85e4006ab`](https://github.com/nodejs/node/commit/d85e4006ab)] - **test**: apply test-http2-max-session-memory-leak from v12.x (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+
+<a id="10.16.2"></a>
+## 2019-08-06, Version 10.16.2 'Dubnium' (LTS), @BethGriggs
+
+### Notable changes
+
+This release patches a [regression](https://github.com/nodejs/node/issues/28932) in the OpenSSL upgrade to 1.1.1c that causes intermittent hangs in machines that have low entropy.
+
+### Commits
+
+* [[`894a9dd230`](https://github.com/nodejs/node/commit/894a9dd230)] - **deps**: cherry-pick c19c5a6 from openssl upstream (Ali Ijaz Sheikh) [#28983](https://github.com/nodejs/node/pull/28983)
+
+<a id="10.16.1"></a>
+## 2019-07-31, Version 10.16.1 'Dubnium' (LTS), @BethGriggs
+
+### Notable changes
+
+* **deps**: upgrade openssl sources to 1.1.1c (Sam Roberts) [#28212](https://github.com/nodejs/node/pull/28212)
+* **stream**: do not unconditionally call `_read()` on `resume()` (Anna Henningsen) [#26965](https://github.com/nodejs/node/pull/26965)
+* **worker**: fix nullptr deref after MessagePort deser failure (Anna Henningsen) [#25076](https://github.com/nodejs/node/pull/25076)
+
+### Commits
+
+* [[`65ef26fdcb`](https://github.com/nodejs/node/commit/65ef26fdcb)] - **async_hooks**: avoid double-destroy HTTPParser (Gerhard Stoebich) [#27477](https://github.com/nodejs/node/pull/27477)
+* [[`8f5d6cf5f5`](https://github.com/nodejs/node/commit/8f5d6cf5f5)] - **deps**: update archs files for OpenSSL-1.1.1c (Sam Roberts) [#28212](https://github.com/nodejs/node/pull/28212)
+* [[`9e62852724`](https://github.com/nodejs/node/commit/9e62852724)] - **deps**: upgrade openssl sources to 1.1.1c (Sam Roberts) [#28212](https://github.com/nodejs/node/pull/28212)
+* [[`c59e0c256d`](https://github.com/nodejs/node/commit/c59e0c256d)] - **deps**: updated openssl upgrade instructions (Sam Roberts) [#28212](https://github.com/nodejs/node/pull/28212)
+* [[`609d2b9ea4`](https://github.com/nodejs/node/commit/609d2b9ea4)] - **deps**: V8: backport f27ac28 (Michaël Zasso) [#28061](https://github.com/nodejs/node/pull/28061)
+* [[`8f780e8f99`](https://github.com/nodejs/node/commit/8f780e8f99)] - **deps**: cherry-pick 88f8fe1 from upstream V8 (Yang Guo) [#24514](https://github.com/nodejs/node/pull/24514)
+* [[`ad588eb5fc`](https://github.com/nodejs/node/commit/ad588eb5fc)] - **doc**: adjust TOC margins (Roman Reiss) [#28075](https://github.com/nodejs/node/pull/28075)
+* [[`b3d8a1b1d0`](https://github.com/nodejs/node/commit/b3d8a1b1d0)] - **doc**: add missing changes entry (Ruben Bridgewater) [#24758](https://github.com/nodejs/node/pull/24758)
+* [[`819a647d8f`](https://github.com/nodejs/node/commit/819a647d8f)] - **esm**: fix esm load bug (ZYSzys) [#25491](https://github.com/nodejs/node/pull/25491)
+* [[`f34bb968c4`](https://github.com/nodejs/node/commit/f34bb968c4)] - **process**: make stdout and stderr emit 'close' on destroy (Matteo Collina) [#26691](https://github.com/nodejs/node/pull/26691)
+* [[`0339fba1bb`](https://github.com/nodejs/node/commit/0339fba1bb)] - **src**: handle empty Maybe in uv binding initialize (Anna Henningsen) [#25079](https://github.com/nodejs/node/pull/25079)
+* [[`f9e8e8856a`](https://github.com/nodejs/node/commit/f9e8e8856a)] - **src**: fix Get() usage in tls\_wrap.cc (cjihrig) [#24060](https://github.com/nodejs/node/pull/24060)
+* [[`b689008dea`](https://github.com/nodejs/node/commit/b689008dea)] - **src**: in-source comments and minor TLS cleanups (Sam Roberts) [#25713](https://github.com/nodejs/node/pull/25713)
+* [[`76af23a32b`](https://github.com/nodejs/node/commit/76af23a32b)] - **src**: remove internalBinding('config').warningFile (Joyee Cheung) [#24959](https://github.com/nodejs/node/pull/24959)
+* [[`b7dbc1c537`](https://github.com/nodejs/node/commit/b7dbc1c537)] - **src**: fix warning in cares\_wrap.cc (cjihrig) [#25230](https://github.com/nodejs/node/pull/25230)
+* [[`a8f78f02cb`](https://github.com/nodejs/node/commit/a8f78f02cb)] - **src**: fulfill Maybe contract in InlineDecoder (Anna Henningsen) [#25140](https://github.com/nodejs/node/pull/25140)
+* [[`0dee607409`](https://github.com/nodejs/node/commit/0dee607409)] - **src**: extract common Bind method (Jon Moss) [#22315](https://github.com/nodejs/node/pull/22315)
+* [[`08a32fbf57`](https://github.com/nodejs/node/commit/08a32fbf57)] - **src**: elevate v8 namespaces for node\_process.cc (Jayasankar) [#24578](https://github.com/nodejs/node/pull/24578)
+* [[`f3841c6750`](https://github.com/nodejs/node/commit/f3841c6750)] - **stream**: convert existing buffer when calling .setEncoding (Anna Henningsen) [#27936](https://github.com/nodejs/node/pull/27936)
+* [[`274b97c4ea`](https://github.com/nodejs/node/commit/274b97c4ea)] - **stream**: do not unconditionally call `_read()` on `resume()` (Anna Henningsen) [#26965](https://github.com/nodejs/node/pull/26965)
+* [[`044e753aaf`](https://github.com/nodejs/node/commit/044e753aaf)] - **stream**: make \_read() be called indefinitely if the user wants so (Matteo Collina) [#26135](https://github.com/nodejs/node/pull/26135)
+* [[`f332265cda`](https://github.com/nodejs/node/commit/f332265cda)] - **test**: remove `util.inherits()` usage (ZYSzys) [#25245](https://github.com/nodejs/node/pull/25245)
+* [[`ada0ed55d1`](https://github.com/nodejs/node/commit/ada0ed55d1)] - **test**: fix pty test hangs on aix (Ben Noordhuis) [#28600](https://github.com/nodejs/node/pull/28600)
+* [[`2ae99160e5`](https://github.com/nodejs/node/commit/2ae99160e5)] - **test**: skip stringbytes-external-exceed-max on AIX (Sam Roberts) [#28516](https://github.com/nodejs/node/pull/28516)
+* [[`39637cb95f`](https://github.com/nodejs/node/commit/39637cb95f)] - **test**: skip tests related to CI failures on AIX (Sam Roberts) [#28469](https://github.com/nodejs/node/pull/28469)
+* [[`35be08a16f`](https://github.com/nodejs/node/commit/35be08a16f)] - **test**: clean up build files (Gabriel Schulhof) [#28297](https://github.com/nodejs/node/pull/28297)
+* [[`cc3ca08046`](https://github.com/nodejs/node/commit/cc3ca08046)] - **test**: clearing require cache crashes esm loader (Antoine du HAMEL) [#25491](https://github.com/nodejs/node/pull/25491)
+* [[`75052cadaa`](https://github.com/nodejs/node/commit/75052cadaa)] - **tls**: add debugging to native TLS code (Anna Henningsen) [#26843](https://github.com/nodejs/node/pull/26843)
+* [[`99dad28ebf`](https://github.com/nodejs/node/commit/99dad28ebf)] - **tls**: add CHECK for impossible condition (Anna Henningsen) [#26843](https://github.com/nodejs/node/pull/26843)
+* [[`5ffe04753e`](https://github.com/nodejs/node/commit/5ffe04753e)] - **tls**: renegotiate should take care of its own state (Sam Roberts) [#25997](https://github.com/nodejs/node/pull/25997)
+* [[`4a607fab49`](https://github.com/nodejs/node/commit/4a607fab49)] - **tools**: replace rollup with ncc (Rich Trott) [#24813](https://github.com/nodejs/node/pull/24813)
+* [[`14090b59fc`](https://github.com/nodejs/node/commit/14090b59fc)] - **worker**: fix nullptr deref after MessagePort deser failure (Anna Henningsen) [#25076](https://github.com/nodejs/node/pull/25076)
+
+<a id="10.16.0"></a>
+## 2019-05-28, Version 10.16.0 'Dubnium' (LTS), @BethGriggs
+
+### Notable Changes
+
+* **deps**:
+  * update ICU to 64.2 (Ujjwal Sharma) [#27361](https://github.com/nodejs/node/pull/27361)
+  * upgrade npm to 6.9.0 (Kat Marchán) [#26244](https://github.com/nodejs/node/pull/26244)
+  * upgrade openssl sources to 1.1.1b (Sam Roberts) [#26327](https://github.com/nodejs/node/pull/26327)
+  * upgrade to libuv 1.28.0 (cjihrig) [#27241](https://github.com/nodejs/node/pull/27241)
+* **events**: add once method to use promises with EventEmitter (Matteo Collina) [#26078](https://github.com/nodejs/node/pull/26078)
+* **n-api**: mark thread-safe function as stable (Gabriel Schulhof) [#25556](https://github.com/nodejs/node/pull/25556)
+* **repl**: support top-level for-await-of (Shelley Vohr) [#23841](https://github.com/nodejs/node/pull/23841)
+* **zlib**:  add brotli support (Anna Henningsen) [#24938](https://github.com/nodejs/node/pull/24938)
+
+### Commits
+
+* [[`77ed1bbea4`](https://github.com/nodejs/node/commit/77ed1bbea4)] - **benchmark**: fix net-wrap-js-stream-passthrough (Rich Trott) [#25273](https://github.com/nodejs/node/pull/25273)
+* [[`a8cbe0e6d2`](https://github.com/nodejs/node/commit/a8cbe0e6d2)] - **benchmark**: replace deprecated and eliminate var in buffer-from.js (gengjiawen) [#26585](https://github.com/nodejs/node/pull/26585)
+* [[`5249a22704`](https://github.com/nodejs/node/commit/5249a22704)] - **benchmark**: refactor path benchmarks (Ruben Bridgewater) [#26359](https://github.com/nodejs/node/pull/26359)
+* [[`de7db26879`](https://github.com/nodejs/node/commit/de7db26879)] - **benchmark,lib**: add process.hrtime.bigint benchmark (Anna Henningsen) [#26381](https://github.com/nodejs/node/pull/26381)
+* [[`c670358d7e`](https://github.com/nodejs/node/commit/c670358d7e)] - **(SEMVER-MINOR)** **benchmark,test**: add brotli (Anna Henningsen) [#24938](https://github.com/nodejs/node/pull/24938)
+* [[`ff647fda13`](https://github.com/nodejs/node/commit/ff647fda13)] - **buffer**: do not affect memory after target for utf16 write (Anna Henningsen) [#26432](https://github.com/nodejs/node/pull/26432)
+* [[`99a653e9ee`](https://github.com/nodejs/node/commit/99a653e9ee)] - **build**: make compress\_json python3 compatible (Sakthipriyan Vairamani (thefourtheye)) [#25582](https://github.com/nodejs/node/pull/25582)
+* [[`1c7f6a51c4`](https://github.com/nodejs/node/commit/1c7f6a51c4)] - **build**: make configure.py compatible with python 3 (Sakthipriyan Vairamani (thefourtheye)) [#25580](https://github.com/nodejs/node/pull/25580)
+* [[`de268667e7`](https://github.com/nodejs/node/commit/de268667e7)] - **build**: remove AIX/ppc (32bit) dead code (Refael Ackermann) [#25523](https://github.com/nodejs/node/pull/25523)
+* [[`a575a410fa`](https://github.com/nodejs/node/commit/a575a410fa)] - **build**: remove erroneous duplicate declaration from node\_inspector.gypi (Refael Ackermann) [#25586](https://github.com/nodejs/node/pull/25586)
+* [[`6348d71a8a`](https://github.com/nodejs/node/commit/6348d71a8a)] - **build**: do not lint python scripts under test/fixtures (Joyee Cheung) [#25639](https://github.com/nodejs/node/pull/25639)
+* [[`7ead9af0f5`](https://github.com/nodejs/node/commit/7ead9af0f5)] - **build**: add check for empty openssl-fips flag (Daniel Bevenius) [#25391](https://github.com/nodejs/node/pull/25391)
+* [[`554a4345c2`](https://github.com/nodejs/node/commit/554a4345c2)] - **build**: fix Windows shared lib build (Richard Lau) [#25166](https://github.com/nodejs/node/pull/25166)
+* [[`ffd62b129d`](https://github.com/nodejs/node/commit/ffd62b129d)] - **build**: correct fi indentation in Makefile (Daniel Bevenius) [#25107](https://github.com/nodejs/node/pull/25107)
+* [[`5760e419d7`](https://github.com/nodejs/node/commit/5760e419d7)] - **build**: add a space to clarify skipping crypto msg (Daniel Bevenius) [#25011](https://github.com/nodejs/node/pull/25011)
+* [[`513913c672`](https://github.com/nodejs/node/commit/513913c672)] - **build**: restore running tests on Travis (Richard Lau) [#26720](https://github.com/nodejs/node/pull/26720)
+* [[`9512f3938a`](https://github.com/nodejs/node/commit/9512f3938a)] - **build**: temporarily don't run tests on Travis (Richard Lau) [#26720](https://github.com/nodejs/node/pull/26720)
+* [[`add5141933`](https://github.com/nodejs/node/commit/add5141933)] - **build**: use Xenial and gcc 6 on Travis (Richard Lau) [#26720](https://github.com/nodejs/node/pull/26720)
+* [[`9f5ad9b476`](https://github.com/nodejs/node/commit/9f5ad9b476)] - **build,deps**: less warnings from V8 (Refael Ackermann) [#26405](https://github.com/nodejs/node/pull/26405)
+* [[`16a92f66a1`](https://github.com/nodejs/node/commit/16a92f66a1)] - **child_process**: truncate output when maxBuffer is exceeded (Jeremiah Senkpiel) [#24951](https://github.com/nodejs/node/pull/24951)
+* [[`274fc16178`](https://github.com/nodejs/node/commit/274fc16178)] - **child_process**: simplify argument handling (cjihrig) [#25194](https://github.com/nodejs/node/pull/25194)
+* [[`fce822f6e9`](https://github.com/nodejs/node/commit/fce822f6e9)] - **child_process**: ensure message sanity at source (Gireesh Punathil) [#24787](https://github.com/nodejs/node/pull/24787)
+* [[`a193a0f9dd`](https://github.com/nodejs/node/commit/a193a0f9dd)] - **child_process**: spawn ignores options in case args is undefined (Eduard Bondarenko) [#24913](https://github.com/nodejs/node/pull/24913)
+* [[`4b3e9486ca`](https://github.com/nodejs/node/commit/4b3e9486ca)] - **cluster**: refactor empty for in round\_robin\_handle.js (gengjiawen) [#26560](https://github.com/nodejs/node/pull/26560)
+* [[`fb73c06025`](https://github.com/nodejs/node/commit/fb73c06025)] - **cluster**: improve for-loop (gengjiawen) [#26336](https://github.com/nodejs/node/pull/26336)
+* [[`b8b23a3d78`](https://github.com/nodejs/node/commit/b8b23a3d78)] - **crypto**: add crypto modules to cannotUseCache (Daniel Bevenius) [#25606](https://github.com/nodejs/node/pull/25606)
+* [[`3a2814367b`](https://github.com/nodejs/node/commit/3a2814367b)] - **crypto**: add crypto/keys to cannotUseCache (Daniel Bevenius) [#25237](https://github.com/nodejs/node/pull/25237)
+* [[`a0dc65d0ed`](https://github.com/nodejs/node/commit/a0dc65d0ed)] - **crypto**: update root certificates (Sam Roberts) [#25113](https://github.com/nodejs/node/pull/25113)
+* [[`4c87c1b1bc`](https://github.com/nodejs/node/commit/4c87c1b1bc)] - **deps**: upgrade to libuv 1.28.0 (cjihrig) [#27241](https://github.com/nodejs/node/pull/27241)
+* [[`7e5ef4a0e1`](https://github.com/nodejs/node/commit/7e5ef4a0e1)] - **deps**: upgrade to libuv 1.27.0 (cjihrig) [#26707](https://github.com/nodejs/node/pull/26707)
+* [[`8ea22bbb88`](https://github.com/nodejs/node/commit/8ea22bbb88)] - **deps**: upgrade to libuv 1.26.0 (cjihrig) [#26037](https://github.com/nodejs/node/pull/26037)
+* [[`e6275f939a`](https://github.com/nodejs/node/commit/e6275f939a)] - **deps**: upgrade to libuv 1.25.0 (cjihrig) [#25571](https://github.com/nodejs/node/pull/25571)
+* [[`aceac0581c`](https://github.com/nodejs/node/commit/aceac0581c)] - **deps**: patch to fix \*.onion MX query on c-ares (XadillaX) [#25840](https://github.com/nodejs/node/pull/25840)
+* [[`be219bd559`](https://github.com/nodejs/node/commit/be219bd559)] - **deps**: update archs files for OpenSSL-1.1.1b (Sam Roberts) [#26327](https://github.com/nodejs/node/pull/26327)
+* [[`6a6aa6f038`](https://github.com/nodejs/node/commit/6a6aa6f038)] - **(SEMVER-MINOR)** **deps**: add s390 asm rules for OpenSSL-1.1.1 (Shigeki Ohtsu) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`5109c4f432`](https://github.com/nodejs/node/commit/5109c4f432)] - **deps**: add ARM64 Windows support in openssl (Shigeki Ohtsu) [#26001](https://github.com/nodejs/node/pull/26001)
+* [[`f270eeec52`](https://github.com/nodejs/node/commit/f270eeec52)] - **deps**: openssl-1.1.1b no longer packages .gitignore (Sam Roberts) [#26327](https://github.com/nodejs/node/pull/26327)
+* [[`ebe0b05a24`](https://github.com/nodejs/node/commit/ebe0b05a24)] - **deps**: upgrade openssl sources to 1.1.1b (Sam Roberts) [#26327](https://github.com/nodejs/node/pull/26327)
+* [[`bbf5373041`](https://github.com/nodejs/node/commit/bbf5373041)] - **deps**: update OpenSSL upgrade process (Sam Roberts) [#26378](https://github.com/nodejs/node/pull/26378)
+* [[`a9c68a05d9`](https://github.com/nodejs/node/commit/a9c68a05d9)] - **(SEMVER-MINOR)** **deps**: add brotli (Hackzzila) [#24938](https://github.com/nodejs/node/pull/24938)
+* [[`281b52d6ec`](https://github.com/nodejs/node/commit/281b52d6ec)] - **deps**: upgrade npm to 6.9.0 (Kat Marchán) [#26244](https://github.com/nodejs/node/pull/26244)
+* [[`d2413d630c`](https://github.com/nodejs/node/commit/d2413d630c)] - **deps**: upgrade npm to 6.7.0 (Kat Marchán) [#25804](https://github.com/nodejs/node/pull/25804)
+* [[`e880904d22`](https://github.com/nodejs/node/commit/e880904d22)] - **deps**: upgrade npm to v6.5.0 (Jordan Harband) [#25234](https://github.com/nodejs/node/pull/25234)
+* [[`f91a818508`](https://github.com/nodejs/node/commit/f91a818508)] - **deps**: backport ICU-20575 to fix err/crasher (Steven R. Loomis) [#27435](https://github.com/nodejs/node/pull/27435)
+* [[`c7931e4438`](https://github.com/nodejs/node/commit/c7931e4438)] - **deps**: backport ICU-20558 to fix Intl crasher (Steven R. Loomis) [#27415](https://github.com/nodejs/node/pull/27415)
+* [[`c9d0b6a9a0`](https://github.com/nodejs/node/commit/c9d0b6a9a0)] - **deps**: update ICU to 64.2 (Ujjwal Sharma) [#27361](https://github.com/nodejs/node/pull/27361)
+* [[`391185e550`](https://github.com/nodejs/node/commit/391185e550)] - **(SEMVER-MINOR)** **deps**: upgrade npm to 6.5.0 (Audrey Eschright) [#24734](https://github.com/nodejs/node/pull/24734)
+* [[`4875e881cd`](https://github.com/nodejs/node/commit/4875e881cd)] - **deps**: upgrade to libuv 1.24.1 (cjihrig) [#25078](https://github.com/nodejs/node/pull/25078)
+* [[`74f4741b63`](https://github.com/nodejs/node/commit/74f4741b63)] - **(SEMVER-MINOR)** **deps**: upgrade to libuv 1.24.0 (cjihrig) [#24332](https://github.com/nodejs/node/pull/24332)
+* [[`e9a9c88363`](https://github.com/nodejs/node/commit/e9a9c88363)] - **(SEMVER-MINOR)** **deps**: icu 63.1 bump (CLDR 34) (Steven R. Loomis) [#23715](https://github.com/nodejs/node/pull/23715)
+* [[`23ea7ee64b`](https://github.com/nodejs/node/commit/23ea7ee64b)] - **deps**: v8, backport coverage fixes (bcoe) [#26579](https://github.com/nodejs/node/pull/26579)
+* [[`b0b73fa561`](https://github.com/nodejs/node/commit/b0b73fa561)] - **(SEMVER-MINOR)** **deps**: update archs files for OpenSSL-1.1.1a (Sam Roberts) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`56441a0900`](https://github.com/nodejs/node/commit/56441a0900)] - **(SEMVER-MINOR)** **deps**: fix for non GNU assembler in AIX (Shigeki Ohtsu) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`639b1d2f68`](https://github.com/nodejs/node/commit/639b1d2f68)] - **(SEMVER-MINOR)** **deps**: add only avx2 configs for OpenSSL-1.1.1 (Shigeki Ohtsu) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`f5369da047`](https://github.com/nodejs/node/commit/f5369da047)] - **(SEMVER-MINOR)** **deps**: fix MacOS and Win build for OpenSSL-1.1.1 (Shigeki Ohtsu) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`70a785cd9f`](https://github.com/nodejs/node/commit/70a785cd9f)] - **(SEMVER-MINOR)** **deps**: fix gyp/gypi for openssl-1.1.1 (Shigeki Ohtsu) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`0e7019ff76`](https://github.com/nodejs/node/commit/0e7019ff76)] - **(SEMVER-MINOR)** **deps**: add s390 asm rules for OpenSSL-1.1.1 (Shigeki Ohtsu) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`2d396fe058`](https://github.com/nodejs/node/commit/2d396fe058)] - **(SEMVER-MINOR)** **deps**: upgrade openssl sources to 1.1.1a (Sam Roberts) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`ce6fec53a4`](https://github.com/nodejs/node/commit/ce6fec53a4)] - **(SEMVER-MINOR)** **deps,tools**: update license-builder.sh and LICENSE (Hackzzila) [#24938](https://github.com/nodejs/node/pull/24938)
+* [[`b7dd0b841e`](https://github.com/nodejs/node/commit/b7dd0b841e)] - **deps,tools**: include SipHash in LICENSE (Rod Vagg) [#26367](https://github.com/nodejs/node/pull/26367)
+* [[`4fcfa5a63f`](https://github.com/nodejs/node/commit/4fcfa5a63f)] - **dns**: fix TTL value for AAAA replies to `resolveAny()` (Anna Henningsen) [#25187](https://github.com/nodejs/node/pull/25187)
+* [[`2a98b9cf2f`](https://github.com/nodejs/node/commit/2a98b9cf2f)] - **doc**: add "tick" function name and argument description (Artur Hayrapetyan) [#23551](https://github.com/nodejs/node/pull/23551)
+* [[`93edf907ca`](https://github.com/nodejs/node/commit/93edf907ca)] - **(SEMVER-MINOR)** **doc**: add documentation for brotli support (Anna Henningsen) [#24938](https://github.com/nodejs/node/pull/24938)
+* [[`7ed29fc1e8`](https://github.com/nodejs/node/commit/7ed29fc1e8)] - **doc**: revise breaking changes material in COLLABORATOR\_GUIDE (Rich Trott) [#25730](https://github.com/nodejs/node/pull/25730)
+* [[`498edfde9b`](https://github.com/nodejs/node/commit/498edfde9b)] - **doc**: fix http.Agent timeout option description (Luigi Pinca) [#25489](https://github.com/nodejs/node/pull/25489)
+* [[`a040a73ee3`](https://github.com/nodejs/node/commit/a040a73ee3)] - **doc**: fix file extension on ESM file example (Eric Whitebloom) [#25692](https://github.com/nodejs/node/pull/25692)
+* [[`6a2d9d192f`](https://github.com/nodejs/node/commit/6a2d9d192f)] - **doc**: remove outdated s\_client information in tls.md (Rich Trott) [#25678](https://github.com/nodejs/node/pull/25678)
+* [[`bb96d79a7e`](https://github.com/nodejs/node/commit/bb96d79a7e)] - **doc**: clarify what dns.setResolvers() affects (Sam Roberts) [#25570](https://github.com/nodejs/node/pull/25570)
+* [[`a382932097`](https://github.com/nodejs/node/commit/a382932097)] - **doc**: simplify process.binding() deprecation message (Rich Trott) [#25654](https://github.com/nodejs/node/pull/25654)
+* [[`b1a15ab4cf`](https://github.com/nodejs/node/commit/b1a15ab4cf)] - **doc**: add note regarding pushing release tags (Myles Borins) [#25569](https://github.com/nodejs/node/pull/25569)
+* [[`6ae41bde4d`](https://github.com/nodejs/node/commit/6ae41bde4d)] - **doc**: reword stream docs to clarify that decodeStrings encodes strings (Daniel George Holz) [#25468](https://github.com/nodejs/node/pull/25468)
+* [[`13205d5805`](https://github.com/nodejs/node/commit/13205d5805)] - **doc**: correct my wrong note about buf.fill() (Vse Mozhet Byt) [#25585](https://github.com/nodejs/node/pull/25585)
+* [[`12fe2d30fe`](https://github.com/nodejs/node/commit/12fe2d30fe)] - **doc**: add a note to `buf.fill()` description (Vse Mozhet Byt) [#25547](https://github.com/nodejs/node/pull/25547)
+* [[`92d0794d63`](https://github.com/nodejs/node/commit/92d0794d63)] - **doc**: fix typo in Buffer API (H1Gdev) [#25544](https://github.com/nodejs/node/pull/25544)
+* [[`37082bd149`](https://github.com/nodejs/node/commit/37082bd149)] - **doc**: add Rich back to TSC list (Michael Dawson) [#25535](https://github.com/nodejs/node/pull/25535)
+* [[`5631d7a6e0`](https://github.com/nodejs/node/commit/5631d7a6e0)] - **doc**: add metadata about ecdh curve options (Sam Roberts) [#25502](https://github.com/nodejs/node/pull/25502)
+* [[`5c602dabc4`](https://github.com/nodejs/node/commit/5c602dabc4)] - **doc**: add TLSSocket.isSessionReused() docs (Sam Roberts) [#25423](https://github.com/nodejs/node/pull/25423)
+* [[`07f878b0c1`](https://github.com/nodejs/node/commit/07f878b0c1)] - **doc**: fix sorting in buffer.md (Vse Mozhet Byt) [#25477](https://github.com/nodejs/node/pull/25477)
+* [[`9dffc2ba0c`](https://github.com/nodejs/node/commit/9dffc2ba0c)] - **doc**: fix `napi_open_callback_scope` description (Philipp Renoth) [#25366](https://github.com/nodejs/node/pull/25366)
+* [[`0c33ecb2bd`](https://github.com/nodejs/node/commit/0c33ecb2bd)] - **doc**: document that stream.on('close') was changed in Node 10 (Matteo Collina) [#25413](https://github.com/nodejs/node/pull/25413)
+* [[`8f0fa61406`](https://github.com/nodejs/node/commit/8f0fa61406)] - **doc**: fix the path to postMessage() (Mitar) [#25332](https://github.com/nodejs/node/pull/25332)
+* [[`3a30c87e88`](https://github.com/nodejs/node/commit/3a30c87e88)] - **doc**: update `os.networkInterfaces()` example (jvelezpo) [#25417](https://github.com/nodejs/node/pull/25417)
+* [[`530f005d7d`](https://github.com/nodejs/node/commit/530f005d7d)] - **doc**: make sure that calls to .read() are looped (Matteo Collina) [#25375](https://github.com/nodejs/node/pull/25375)
+* [[`487f6536bc`](https://github.com/nodejs/node/commit/487f6536bc)] - **doc**: add history to http.request.setTimeout() (James Bunton) [#25121](https://github.com/nodejs/node/pull/25121)
+* [[`66ab7e4a99`](https://github.com/nodejs/node/commit/66ab7e4a99)] - **doc**: add clarification for exception behaviour (Michael Dawson) [#25339](https://github.com/nodejs/node/pull/25339)
+* [[`ce3cf0dffd`](https://github.com/nodejs/node/commit/ce3cf0dffd)] - **doc**: clarify timing of socket.connecting (Sam Roberts) [#25333](https://github.com/nodejs/node/pull/25333)
+* [[`b68d47a246`](https://github.com/nodejs/node/commit/b68d47a246)] - **doc**: update benchmark doc (Kazushi Kitaya) [#25367](https://github.com/nodejs/node/pull/25367)
+* [[`252a696568`](https://github.com/nodejs/node/commit/252a696568)] - **doc**: use lowercase for zlib (Rich Trott) [#25371](https://github.com/nodejs/node/pull/25371)
+* [[`0d3212aa5c`](https://github.com/nodejs/node/commit/0d3212aa5c)] - **doc**: fix heading in cpp style guide (Kazushi Kitaya) [#25303](https://github.com/nodejs/node/pull/25303)
+* [[`8d5ac6c8ef`](https://github.com/nodejs/node/commit/8d5ac6c8ef)] - **doc**: fix process.stdin example (Anna Henningsen) [#25344](https://github.com/nodejs/node/pull/25344)
+* [[`ef6e4f15a0`](https://github.com/nodejs/node/commit/ef6e4f15a0)] - **doc**: fs.mkdir('/') throws EPERM on Windows (Corey Farrell) [#25340](https://github.com/nodejs/node/pull/25340)
+* [[`fc5dc9c13e`](https://github.com/nodejs/node/commit/fc5dc9c13e)] - **doc**: include license for src/large\_pages in LICENSE (Ujjwal Sharma) [#25246](https://github.com/nodejs/node/pull/25246)
+* [[`b76931b7e9`](https://github.com/nodejs/node/commit/b76931b7e9)] - **doc**: describe TLS session resumption (Sam Roberts) [#25174](https://github.com/nodejs/node/pull/25174)
+* [[`c84b4fb51a`](https://github.com/nodejs/node/commit/c84b4fb51a)] - **doc**: link and expand --tls-cipher-list docs (Sam Roberts) [#25174](https://github.com/nodejs/node/pull/25174)
+* [[`18e0a61f91`](https://github.com/nodejs/node/commit/18e0a61f91)] - **doc**: revise "Breaking Changes to Internal Elements" (Rich Trott) [#25190](https://github.com/nodejs/node/pull/25190)
+* [[`b980fa3a21`](https://github.com/nodejs/node/commit/b980fa3a21)] - **doc**: fix NAPI typo (Philipp Renoth) [#25216](https://github.com/nodejs/node/pull/25216)
+* [[`173e5fee9d`](https://github.com/nodejs/node/commit/173e5fee9d)] - **doc**: revise "Breaking Changes and Deprecations" (Rich Trott) [#25116](https://github.com/nodejs/node/pull/25116)
+* [[`c571e9e18b`](https://github.com/nodejs/node/commit/c571e9e18b)] - **doc**: describe root cert update process (Sam Roberts) [#25113](https://github.com/nodejs/node/pull/25113)
+* [[`09a97f29df`](https://github.com/nodejs/node/commit/09a97f29df)] - **doc**: edit LTS material in Collaborator Guide (Rich Trott) [#26845](https://github.com/nodejs/node/pull/26845)
+* [[`f52160d385`](https://github.com/nodejs/node/commit/f52160d385)] - **doc**: change error message to 'not defined' (Mohammed Essehemy) [#26857](https://github.com/nodejs/node/pull/26857)
+* [[`6bd33dde62`](https://github.com/nodejs/node/commit/6bd33dde62)] - **doc**: fix comma of the list in worker\_threads.md (Hang Jiang) [#26838](https://github.com/nodejs/node/pull/26838)
+* [[`889d68ce6d`](https://github.com/nodejs/node/commit/889d68ce6d)] - **doc**: remove discord community (Aymen Naghmouchi) [#26830](https://github.com/nodejs/node/pull/26830)
+* [[`ddfa756797`](https://github.com/nodejs/node/commit/ddfa756797)] - **doc**: remove How Does LTS Work section from Collaborator Guide (Rich Trott) [#26723](https://github.com/nodejs/node/pull/26723)
+* [[`a228254d6b`](https://github.com/nodejs/node/commit/a228254d6b)] - **doc**: condense LTS material in Collaborator Guide (Rich Trott) [#26722](https://github.com/nodejs/node/pull/26722)
+* [[`09f162b18f`](https://github.com/nodejs/node/commit/09f162b18f)] - **doc**: add Note of options.stdio into child\_process (kohta ito) [#26604](https://github.com/nodejs/node/pull/26604)
+* [[`83c2a14e08`](https://github.com/nodejs/node/commit/83c2a14e08)] - **doc**: update spawnSync() status value possibilities (Rich Trott) [#26680](https://github.com/nodejs/node/pull/26680)
+* [[`621099ebed`](https://github.com/nodejs/node/commit/621099ebed)] - **doc**: add ZYSzys to collaborators (ZYSzys) [#26730](https://github.com/nodejs/node/pull/26730)
+* [[`30021881f8`](https://github.com/nodejs/node/commit/30021881f8)] - **doc**: simplify force-push guidelines (Rich Trott) [#26699](https://github.com/nodejs/node/pull/26699)
+* [[`1e6faf9ee0`](https://github.com/nodejs/node/commit/1e6faf9ee0)] - **doc**: note about DNS ANY queries / RFC 8482 (Thomas Hunter II) [#26695](https://github.com/nodejs/node/pull/26695)
+* [[`fc3552305a`](https://github.com/nodejs/node/commit/fc3552305a)] - **doc**: simplify Troubleshooting text (Rich Trott) [#26652](https://github.com/nodejs/node/pull/26652)
+* [[`983ea7f3e0`](https://github.com/nodejs/node/commit/983ea7f3e0)] - **doc**: update copy/paste error message in Troubleshooting (Rich Trott) [#26652](https://github.com/nodejs/node/pull/26652)
+* [[`c07619d581`](https://github.com/nodejs/node/commit/c07619d581)] - **doc**: add Gireesh to TSC (Rich Trott) [#26657](https://github.com/nodejs/node/pull/26657)
+* [[`07ded7c975`](https://github.com/nodejs/node/commit/07ded7c975)] - **doc**: edit "Technical How-To" section of guide (Rich Trott) [#26601](https://github.com/nodejs/node/pull/26601)
+* [[`0a976ecb63`](https://github.com/nodejs/node/commit/0a976ecb63)] - **doc**: fix misleading sentence in http.md (Luigi Pinca) [#26465](https://github.com/nodejs/node/pull/26465)
+* [[`f30172fa25`](https://github.com/nodejs/node/commit/f30172fa25)] - **doc**: fix typo in http2.md (TJKoury) [#26616](https://github.com/nodejs/node/pull/26616)
+* [[`4fed47ab79`](https://github.com/nodejs/node/commit/4fed47ab79)] - **doc**: edit "Using git-node" section of Guide (Rich Trott) [#26580](https://github.com/nodejs/node/pull/26580)
+* [[`033d49c1f4`](https://github.com/nodejs/node/commit/033d49c1f4)] - **doc**: add version for http.createServer() options addition (Ben Swinburne) [#25001](https://github.com/nodejs/node/pull/25001)
+* [[`d4a1d79e3d`](https://github.com/nodejs/node/commit/d4a1d79e3d)] - **doc**: add inspector API example for heapdump (Sam Roberts) [#26498](https://github.com/nodejs/node/pull/26498)
+* [[`72f0efc1f2`](https://github.com/nodejs/node/commit/72f0efc1f2)] - **doc**: edit Landing Pull Requests (Rich Trott) [#26536](https://github.com/nodejs/node/pull/26536)
+* [[`132a457ed4`](https://github.com/nodejs/node/commit/132a457ed4)] - **doc**: add decode() & encode() methods into querystring.md (ZYSzys) [#23889](https://github.com/nodejs/node/pull/23889)
+* [[`74dac5913d`](https://github.com/nodejs/node/commit/74dac5913d)] - **doc**: update partner communities link in releases.md (Beth Griggs) [#26475](https://github.com/nodejs/node/pull/26475)
+* [[`5279a884cc`](https://github.com/nodejs/node/commit/5279a884cc)] - **doc**: fix nits in writing-tests.md (Vse Mozhet Byt) [#26543](https://github.com/nodejs/node/pull/26543)
+* [[`11d163b439`](https://github.com/nodejs/node/commit/11d163b439)] - **doc**: edit "Involving the TSC" (Rich Trott) [#26481](https://github.com/nodejs/node/pull/26481)
+* [[`5fedf0f257`](https://github.com/nodejs/node/commit/5fedf0f257)] - **doc**: add guidance on console output in tests (Sam Roberts) [#26456](https://github.com/nodejs/node/pull/26456)
+* [[`40657859ca`](https://github.com/nodejs/node/commit/40657859ca)] - **doc**: add caveat and tradeoff example to readline (Vse Mozhet Byt) [#26472](https://github.com/nodejs/node/pull/26472)
+* [[`77eae4ecd6`](https://github.com/nodejs/node/commit/77eae4ecd6)] - **doc**: fix the example implementation of MemoryRetainer (Joyee Cheung) [#26262](https://github.com/nodejs/node/pull/26262)
+* [[`aa49bf53f2`](https://github.com/nodejs/node/commit/aa49bf53f2)] - **doc**: clarify http.Agent constructor options (Luigi Pinca) [#26412](https://github.com/nodejs/node/pull/26412)
+* [[`a562aba84c`](https://github.com/nodejs/node/commit/a562aba84c)] - **doc**: hello addon example should return "world" (Geir Hauge) [#26328](https://github.com/nodejs/node/pull/26328)
+* [[`b450ee28e3`](https://github.com/nodejs/node/commit/b450ee28e3)] - **doc**: fix up N-API support matrix (Michael Dawson) [#26377](https://github.com/nodejs/node/pull/26377)
+* [[`3ff7c631a6`](https://github.com/nodejs/node/commit/3ff7c631a6)] - **doc**: edit deprecation identifier info in Collaborator Guide (Rich Trott) [#26372](https://github.com/nodejs/node/pull/26372)
+* [[`8d22048756`](https://github.com/nodejs/node/commit/8d22048756)] - **doc**: update LICENSE file (Thomas Leah) [#24898](https://github.com/nodejs/node/pull/24898)
+* [[`e05eb3e041`](https://github.com/nodejs/node/commit/e05eb3e041)] - **(SEMVER-MINOR)** **doc**: fix assembler requirement for OpenSSL-1.1.1 (Shigeki Ohtsu) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`ecae7275bd`](https://github.com/nodejs/node/commit/ecae7275bd)] - **doc**: fix REPLACEME for tls min/max protocol option (Sam Roberts) [#24759](https://github.com/nodejs/node/pull/24759)
+* [[`1ae6853015`](https://github.com/nodejs/node/commit/1ae6853015)] - **doc,n-api**: update matrix for N-API version 4 (Richard Lau)
+* [[`98193d1d4d`](https://github.com/nodejs/node/commit/98193d1d4d)] - **doc,tools**: updates for 6.x End-of-Life (Richard Lau) [#27658](https://github.com/nodejs/node/pull/27658)
+* [[`25d73aa187`](https://github.com/nodejs/node/commit/25d73aa187)] - **domain**: avoid circular memory references (Anna Henningsen) [#25993](https://github.com/nodejs/node/pull/25993)
+* [[`46a816fa00`](https://github.com/nodejs/node/commit/46a816fa00)] - **events**: show inspected error in uncaught 'error' message (Anna Henningsen) [#25621](https://github.com/nodejs/node/pull/25621)
+* [[`aca5ed5563`](https://github.com/nodejs/node/commit/aca5ed5563)] - **events**: simplify stack compare function (Ruben Bridgewater) [#24744](https://github.com/nodejs/node/pull/24744)
+* [[`064511ec4b`](https://github.com/nodejs/node/commit/064511ec4b)] - **(SEMVER-MINOR)** **events**: add once method to use promises with EventEmitter (Matteo Collina) [#26078](https://github.com/nodejs/node/pull/26078)
+* [[`e1f293c7a1`](https://github.com/nodejs/node/commit/e1f293c7a1)] - **events**: improve for-loop (gengjiawen) [#26354](https://github.com/nodejs/node/pull/26354)
+* [[`cb0fc6520a`](https://github.com/nodejs/node/commit/cb0fc6520a)] - **events**: onceWrapper returns target value (himself65) [#25818](https://github.com/nodejs/node/pull/25818)
+* [[`af301b2821`](https://github.com/nodejs/node/commit/af301b2821)] - **fs**: fix infinite loop with async recursive mkdir on Windows (Richard Lau) [#27207](https://github.com/nodejs/node/pull/27207)
+* [[`3516a2735f`](https://github.com/nodejs/node/commit/3516a2735f)] - **(SEMVER-MINOR)** **fs**: default open/openSync flags argument to 'r' (Ben Noordhuis) [#23767](https://github.com/nodejs/node/pull/23767)
+* [[`ae465f6fc4`](https://github.com/nodejs/node/commit/ae465f6fc4)] - **(SEMVER-MINOR)** **fs,net**: standardize `pending` stream property (Anna Henningsen) [#24067](https://github.com/nodejs/node/pull/24067)
+* [[`ced7f67fbb`](https://github.com/nodejs/node/commit/ced7f67fbb)] - **http**: make ClientRequest#setTimeout() noop at end (Tim De Pauw) [#25536](https://github.com/nodejs/node/pull/25536)
+* [[`33a9d17733`](https://github.com/nodejs/node/commit/33a9d17733)] - **http**: reuse noop function in socketOnError() (cjihrig) [#25566](https://github.com/nodejs/node/pull/25566)
+* [[`378d4f18f1`](https://github.com/nodejs/node/commit/378d4f18f1)] - **http**: remove unused variable in \_http\_server.js (gengjiawen) [#26407](https://github.com/nodejs/node/pull/26407)
+* [[`cb88c58e42`](https://github.com/nodejs/node/commit/cb88c58e42)] - **http**: check for existance in resetHeadersTimeoutOnReqEnd (Matteo Collina) [#26402](https://github.com/nodejs/node/pull/26402)
+* [[`277271c4a9`](https://github.com/nodejs/node/commit/277271c4a9)] - **http**: send connection: close when closing conn (Yann Hamon) [#26467](https://github.com/nodejs/node/pull/26467)
+* [[`decba1c59b`](https://github.com/nodejs/node/commit/decba1c59b)] - **http2**: allow fully synchronous `_final()` (Anna Henningsen) [#25609](https://github.com/nodejs/node/pull/25609)
+* [[`ba6829d1b8`](https://github.com/nodejs/node/commit/ba6829d1b8)] - **http2**: add test case for goaway (Anto Aravinth) [#24054](https://github.com/nodejs/node/pull/24054)
+* [[`91b1b2cf84`](https://github.com/nodejs/node/commit/91b1b2cf84)] - **http2**: delete unused enum in node\_http2.h (gengjiawen) [#26704](https://github.com/nodejs/node/pull/26704)
+* [[`59b348e0e4`](https://github.com/nodejs/node/commit/59b348e0e4)] - **http2**: `Http2ServerResponse.end()` should always return self (Robert Nagy) [#24346](https://github.com/nodejs/node/pull/24346)
+* [[`32b83eaf38`](https://github.com/nodejs/node/commit/32b83eaf38)] - **http2**: refactor deprecated method in core.js (gengjiawen) [#26275](https://github.com/nodejs/node/pull/26275)
+* [[`cc25f22094`](https://github.com/nodejs/node/commit/cc25f22094)] - **http2**: improve compatibility with http/1 (Sagi Tsofan) [#23908](https://github.com/nodejs/node/pull/23908)
+* [[`4f60364201`](https://github.com/nodejs/node/commit/4f60364201)] - **(SEMVER-MINOR)** **http2**: add Http2Stream.bufferSize (Ouyang Yadong) [#23711](https://github.com/nodejs/node/pull/23711)
+* [[`b7b08d1009`](https://github.com/nodejs/node/commit/b7b08d1009)] - **https**: add missing localPort while create socket (leeight) [#24554](https://github.com/nodejs/node/pull/24554)
+* [[`66ca795028`](https://github.com/nodejs/node/commit/66ca795028)] - **inspector**: print all listening addresses (Ben Noordhuis) [#26008](https://github.com/nodejs/node/pull/26008)
+* [[`cbc428c803`](https://github.com/nodejs/node/commit/cbc428c803)] - **inspector, test**: verify reported console message (Eugene Ostroukhov) [#25455](https://github.com/nodejs/node/pull/25455)
+* [[`73230cc2c8`](https://github.com/nodejs/node/commit/73230cc2c8)] - **(SEMVER-MINOR)** **lib**: support overriding http\\s.globalAgent (Roy Sommer) [#25170](https://github.com/nodejs/node/pull/25170)
+* [[`ec90cefdd9`](https://github.com/nodejs/node/commit/ec90cefdd9)] - **lib**: simplify several debug() calls (cjihrig) [#25241](https://github.com/nodejs/node/pull/25241)
+* [[`43f41beff2`](https://github.com/nodejs/node/commit/43f41beff2)] - **(SEMVER-MINOR)** **lib**: enable TypedArray and DataView for the v8 module (Ouyang Yadong) [#23953](https://github.com/nodejs/node/pull/23953)
+* [[`bda45a5cfe`](https://github.com/nodejs/node/commit/bda45a5cfe)] - **(SEMVER-MINOR)** **lib**: add escapeCodeTimeout as an option to createInterface (Raoof) [#19780](https://github.com/nodejs/node/pull/19780)
+* [[`81cf2b450d`](https://github.com/nodejs/node/commit/81cf2b450d)] - **lib,test**: remove lib/internal/test/unicode.js (Rich Trott) [#25298](https://github.com/nodejs/node/pull/25298)
+* [[`a49bd36a1a`](https://github.com/nodejs/node/commit/a49bd36a1a)] - **module**: revert module.\_compile to original state if module is patched (Ujjwal Sharma) [#21573](https://github.com/nodejs/node/pull/21573)
+* [[`590e8d37e9`](https://github.com/nodejs/node/commit/590e8d37e9)] - **module**: use compileFunction over Module.wrap (Ujjwal Sharma) [#21573](https://github.com/nodejs/node/pull/21573)
+* [[`0dc6f03873`](https://github.com/nodejs/node/commit/0dc6f03873)] - **(SEMVER-MINOR)** **module**: support multi-dot file extension (Geoffrey Booth) [#23416](https://github.com/nodejs/node/pull/23416)
+* [[`2643801d9d`](https://github.com/nodejs/node/commit/2643801d9d)] - **n-api**: improve performance creating strings (Anthony Tuininga) [#26439](https://github.com/nodejs/node/pull/26439)
+* [[`b5588daef0`](https://github.com/nodejs/node/commit/b5588daef0)] - **n-api**: finalize during second-pass callback (Gabriel Schulhof) [#25992](https://github.com/nodejs/node/pull/25992)
+* [[`48a5241b46`](https://github.com/nodejs/node/commit/48a5241b46)] - **(SEMVER-MINOR)** **n-api**: mark thread-safe function as stable (Gabriel Schulhof) [#25556](https://github.com/nodejs/node/pull/25556)
+* [[`f17b61e071`](https://github.com/nodejs/node/commit/f17b61e071)] - **net**: check for close on stream, not parent (David Halls) [#25026](https://github.com/nodejs/node/pull/25026)
+* [[`eef2debcc7`](https://github.com/nodejs/node/commit/eef2debcc7)] - **os**: implement os.release() using uv\_os\_uname() (cjihrig) [#25600](https://github.com/nodejs/node/pull/25600)
+* [[`d4688485b5`](https://github.com/nodejs/node/commit/d4688485b5)] - **os**: use uv\_os\_gethostname() in hostname() (cjihrig) [#25111](https://github.com/nodejs/node/pull/25111)
+* [[`ff3d977f04`](https://github.com/nodejs/node/commit/ff3d977f04)] - **perf_hooks**: clean up GC listeners (Anna Henningsen) [#25647](https://github.com/nodejs/node/pull/25647)
+* [[`45481bce63`](https://github.com/nodejs/node/commit/45481bce63)] - **querystring**: remove eslint-disable (cjihrig) [#24995](https://github.com/nodejs/node/pull/24995)
+* [[`d3f15b0ffb`](https://github.com/nodejs/node/commit/d3f15b0ffb)] - **(SEMVER-MINOR)** **readline**: add support for async iteration (Timothy Gu) [#23916](https://github.com/nodejs/node/pull/23916)
+* [[`2f1ad8efbd`](https://github.com/nodejs/node/commit/2f1ad8efbd)] - **repl**: improve doc for disabling REPL history on Windows (Samuel D. Leslie) [#25672](https://github.com/nodejs/node/pull/25672)
+* [[`b061a08cab`](https://github.com/nodejs/node/commit/b061a08cab)] - **repl**: indicate if errors are thrown or not (Ruben Bridgewater) [#25253](https://github.com/nodejs/node/pull/25253)
+* [[`ef767a28b2`](https://github.com/nodejs/node/commit/ef767a28b2)] - **repl**: eliminate var in function \_memory (gengjiawen) [#26496](https://github.com/nodejs/node/pull/26496)
+* [[`600929d4f8`](https://github.com/nodejs/node/commit/600929d4f8)] - **repl**: simplify regex expression (gengjiawen) [#26496](https://github.com/nodejs/node/pull/26496)
+* [[`1080a1af3d`](https://github.com/nodejs/node/commit/1080a1af3d)] - **repl**: remove redundant escape (gengjiawen) [#26496](https://github.com/nodejs/node/pull/26496)
+* [[`b9188d473b`](https://github.com/nodejs/node/commit/b9188d473b)] - **(SEMVER-MINOR)** **repl**: support top-level for-await-of (Shelley Vohr) [#23841](https://github.com/nodejs/node/pull/23841)
+* [[`b9ea23c0ed`](https://github.com/nodejs/node/commit/b9ea23c0ed)] - **src**: add WeakReference utility (Anna Henningsen) [#25993](https://github.com/nodejs/node/pull/25993)
+* [[`57469e62d9`](https://github.com/nodejs/node/commit/57469e62d9)] - **src**: extract common sockaddr creation code (Daniel Bevenius) [#26070](https://github.com/nodejs/node/pull/26070)
+* [[`bc5e04b5f7`](https://github.com/nodejs/node/commit/bc5e04b5f7)] - **src**: fix race condition in `~NodeTraceBuffer` (Anna Henningsen) [#25896](https://github.com/nodejs/node/pull/25896)
+* [[`51ec21cb17`](https://github.com/nodejs/node/commit/51ec21cb17)] - **src**: remove unused field in node\_http2.h (gengjiawen) [#25727](https://github.com/nodejs/node/pull/25727)
+* [[`550af6d72f`](https://github.com/nodejs/node/commit/550af6d72f)] - **src**: remove unnecessary call to SSL\_get\_mode (Sam Roberts) [#25711](https://github.com/nodejs/node/pull/25711)
+* [[`b31035d0b3`](https://github.com/nodejs/node/commit/b31035d0b3)] - **src**: fix macro duplicate declaration in env.h (gengjiawen) [#25703](https://github.com/nodejs/node/pull/25703)
+* [[`cd4a932af3`](https://github.com/nodejs/node/commit/cd4a932af3)] - **src**: remove outdated `Neuter()` call in `node_buffer.cc` (Anna Henningsen) [#25479](https://github.com/nodejs/node/pull/25479)
+* [[`883d61c7ae`](https://github.com/nodejs/node/commit/883d61c7ae)] - **src**: trace\_events: fix race with metadata events (Ali Ijaz Sheikh) [#25235](https://github.com/nodejs/node/pull/25235)
+* [[`7655253251`](https://github.com/nodejs/node/commit/7655253251)] - **src**: remove unused method declaration (Ben Noordhuis) [#25329](https://github.com/nodejs/node/pull/25329)
+* [[`f5e4a1e9d8`](https://github.com/nodejs/node/commit/f5e4a1e9d8)] - **src**: remove unused variable from string\_search.h (Anna Henningsen) [#25139](https://github.com/nodejs/node/pull/25139)
+* [[`5d5ac23bb7`](https://github.com/nodejs/node/commit/5d5ac23bb7)] - **src**: do not leak NodeTraceStateObserver (Anna Henningsen) [#25180](https://github.com/nodejs/node/pull/25180)
+* [[`870549b8ac`](https://github.com/nodejs/node/commit/870549b8ac)] - **src**: port GetLoadedLibraries for freebsd (Gireesh Punathil) [#25106](https://github.com/nodejs/node/pull/25106)
+* [[`74b034fe94`](https://github.com/nodejs/node/commit/74b034fe94)] - **src**: schedule destroy hooks in BeforeExit early during bootstrap (Joyee Cheung) [#25020](https://github.com/nodejs/node/pull/25020)
+* [[`42c26a6afb`](https://github.com/nodejs/node/commit/42c26a6afb)] - **src**: remove unused variable in class InspectorSocketServer (gengjiawen) [#26633](https://github.com/nodejs/node/pull/26633)
+* [[`84db29c93b`](https://github.com/nodejs/node/commit/84db29c93b)] - **src**: remove usage of deprecated IsNearDeath (Michaël Zasso) [#26630](https://github.com/nodejs/node/pull/26630)
+* [[`4274542a39`](https://github.com/nodejs/node/commit/4274542a39)] - **(SEMVER-MINOR)** **src**: deprecate AddPromiseHook() (Anna Henningsen) [#26529](https://github.com/nodejs/node/pull/26529)
+* [[`479ef60013`](https://github.com/nodejs/node/commit/479ef60013)] - **src**: remove redundant cast in util-inl.h (gengjiawen) [#26410](https://github.com/nodejs/node/pull/26410)
+* [[`44f62607a1`](https://github.com/nodejs/node/commit/44f62607a1)] - **src**: remove redundant cast in string\_search.h (gengjiawen) [#26426](https://github.com/nodejs/node/pull/26426)
+* [[`dc9f1c60e2`](https://github.com/nodejs/node/commit/dc9f1c60e2)] - **src**: remove unused function in cares\_wrap.cc (gengjiawen) [#26429](https://github.com/nodejs/node/pull/26429)
+* [[`e418b4f650`](https://github.com/nodejs/node/commit/e418b4f650)] - **src**: fix if indent in node\_http2.cc (gengjiawen) [#26396](https://github.com/nodejs/node/pull/26396)
+* [[`0bff833df9`](https://github.com/nodejs/node/commit/0bff833df9)] - **src**: remove unused struct in test\_inspector\_socket.cc (gengjiawen) [#26284](https://github.com/nodejs/node/pull/26284)
+* [[`281eb0f928`](https://github.com/nodejs/node/commit/281eb0f928)] - **src**: extra-semi warning in node\_platform.h (Jeremy Apthorp) [#26330](https://github.com/nodejs/node/pull/26330)
+* [[`0fa3a512c1`](https://github.com/nodejs/node/commit/0fa3a512c1)] - **src**: reduce to simple `const char*` in OptionsParser (ZYSzys) [#26297](https://github.com/nodejs/node/pull/26297)
+* [[`44fd3a2fce`](https://github.com/nodejs/node/commit/44fd3a2fce)] - **src**: remove already elevated Isolate namespce (Juan José Arboleda) [#26294](https://github.com/nodejs/node/pull/26294)
+* [[`5cd96b367b`](https://github.com/nodejs/node/commit/5cd96b367b)] - **src**: avoid race condition in tracing code (Anna Henningsen) [#25624](https://github.com/nodejs/node/pull/25624)
+* [[`452b6aad5a`](https://github.com/nodejs/node/commit/452b6aad5a)] - **src**: remove redundant cast in PipeWrap::Fchmod (gengjiawen) [#26242](https://github.com/nodejs/node/pull/26242)
+* [[`55d3be7e9e`](https://github.com/nodejs/node/commit/55d3be7e9e)] - **src**: simplify native immediate by using v8::Global (Anna Henningsen) [#26254](https://github.com/nodejs/node/pull/26254)
+* [[`a92286d6da`](https://github.com/nodejs/node/commit/a92286d6da)] - **src**: ensure no more platform foreground tasks after Deinit (Clemens Hammacher) [#25653](https://github.com/nodejs/node/pull/25653)
+* [[`f4be1767a5`](https://github.com/nodejs/node/commit/f4be1767a5)] - **src**: dispose of V8 platform in `process.exit()` (Anna Henningsen) [#25061](https://github.com/nodejs/node/pull/25061)
+* [[`c2dab8e642`](https://github.com/nodejs/node/commit/c2dab8e642)] - **(SEMVER-MINOR)** **src,test**: add public wrapper for Environment::GetCurrent (Shelley Vohr) [#23676](https://github.com/nodejs/node/pull/23676)
+* [[`99c555a1de`](https://github.com/nodejs/node/commit/99c555a1de)] - **stream**: ensure writable.destroy() emits error once (Luigi Pinca) [#26057](https://github.com/nodejs/node/pull/26057)
+* [[`a1b253a416`](https://github.com/nodejs/node/commit/a1b253a416)] - **(SEMVER-MINOR)** **stream**: add auto-destroy mode (Mathias Buus) [#22795](https://github.com/nodejs/node/pull/22795)
+* [[`cda0d16414`](https://github.com/nodejs/node/commit/cda0d16414)] - **test**: unskip copyfile permission test (cjihrig) [#27241](https://github.com/nodejs/node/pull/27241)
+* [[`1fc2c5bed1`](https://github.com/nodejs/node/commit/1fc2c5bed1)] - **test**: move known issue test to parallel (cjihrig) [#27241](https://github.com/nodejs/node/pull/27241)
+* [[`57eb6b2129`](https://github.com/nodejs/node/commit/57eb6b2129)] - **test**: fix error code typo (cjihrig) [#27024](https://github.com/nodejs/node/pull/27024)
+* [[`ec02117232`](https://github.com/nodejs/node/commit/ec02117232)] - **test**: add fs.watchFile() + worker.terminate() test (Anna Henningsen) [#21179](https://github.com/nodejs/node/pull/21179)
+* [[`f76776b354`](https://github.com/nodejs/node/commit/f76776b354)] - **test**: update test for libuv update (cjihrig) [#26707](https://github.com/nodejs/node/pull/26707)
+* [[`7b76acb6c8`](https://github.com/nodejs/node/commit/7b76acb6c8)] - **test**: fix expectation in test-bootstrap-modules (Myles Borins) [#27727](https://github.com/nodejs/node/pull/27727)
+* [[`583dc5f42c`](https://github.com/nodejs/node/commit/583dc5f42c)] - **test**: add known\_issues test for fs.copyFile() (Rich Trott) [#26939](https://github.com/nodejs/node/pull/26939)
+* [[`d22b9130a2`](https://github.com/nodejs/node/commit/d22b9130a2)] - **test**: add test about unencrypted PKCS#8 private key for RSA (Daiki Ihara) [#26898](https://github.com/nodejs/node/pull/26898)
+* [[`38d85623bd`](https://github.com/nodejs/node/commit/38d85623bd)] - **test**: use assert.rejects() and assert.throws() (Richard Lau) [#27207](https://github.com/nodejs/node/pull/27207)
+* [[`4733a56caf`](https://github.com/nodejs/node/commit/4733a56caf)] - **test**: move tick.js from test/async-hooks to test/common (Artur Hayrapetyan) [#23551](https://github.com/nodejs/node/pull/23551)
+* [[`fe21dd39c3`](https://github.com/nodejs/node/commit/fe21dd39c3)] - **test**: mark some known flakes (Refael Ackermann) [#27225](https://github.com/nodejs/node/pull/27225)
+* [[`3ca5f23ea7`](https://github.com/nodejs/node/commit/3ca5f23ea7)] - **test**: fix zlib-brotli output assumptions (Adam Majer) [#25697](https://github.com/nodejs/node/pull/25697)
+* [[`1afd614104`](https://github.com/nodejs/node/commit/1afd614104)] - **test**: rewrite fs {f}utimes test file (Jeremiah Senkpiel) [#25656](https://github.com/nodejs/node/pull/25656)
+* [[`48505d8321`](https://github.com/nodejs/node/commit/48505d8321)] - **test**: remove unused uncaughtException handler (Anna Henningsen) [#25641](https://github.com/nodejs/node/pull/25641)
+* [[`301f5fb32e`](https://github.com/nodejs/node/commit/301f5fb32e)] - **test**: fix sequential/test-performance delay (Anatoli Papirovski) [#25695](https://github.com/nodejs/node/pull/25695)
+* [[`52d321d836`](https://github.com/nodejs/node/commit/52d321d836)] - **test**: remove common.isOSXMojave (Rich Trott) [#25658](https://github.com/nodejs/node/pull/25658)
+* [[`6ba4ac007a`](https://github.com/nodejs/node/commit/6ba4ac007a)] - **test**: remove known\_issues/test-cluster-bind-privileged-port (Rich Trott) [#25649](https://github.com/nodejs/node/pull/25649)
+* [[`5d69e69b38`](https://github.com/nodejs/node/commit/5d69e69b38)] - **test**: fix pummel/test-exec (Rich Trott) [#25677](https://github.com/nodejs/node/pull/25677)
+* [[`710f650032`](https://github.com/nodejs/node/commit/710f650032)] - **test**: add stdio checks to cp-exec-maxBuffer (Jeremiah Senkpiel) [#24951](https://github.com/nodejs/node/pull/24951)
+* [[`fbf8e60679`](https://github.com/nodejs/node/commit/fbf8e60679)] - **test**: revoke flaky designation for tests (Gireesh Punathil) [#25611](https://github.com/nodejs/node/pull/25611)
+* [[`554b562d2b`](https://github.com/nodejs/node/commit/554b562d2b)] - **test**: remove potential race condition in https renegotiation test (Rich Trott) [#25601](https://github.com/nodejs/node/pull/25601)
+* [[`b27e3c8b89`](https://github.com/nodejs/node/commit/b27e3c8b89)] - **test**: replace common.PORT with `0` in https renegotiation test (Rich Trott) [#25599](https://github.com/nodejs/node/pull/25599)
+* [[`faf1a18640`](https://github.com/nodejs/node/commit/faf1a18640)] - **test**: changed function to arrow function (yathamravali) [#25441](https://github.com/nodejs/node/pull/25441)
+* [[`7bae3d841b`](https://github.com/nodejs/node/commit/7bae3d841b)] - **test**: use stronger curves for keygen (Daniel Bevenius) [#25564](https://github.com/nodejs/node/pull/25564)
+* [[`b4b4c117fd`](https://github.com/nodejs/node/commit/b4b4c117fd)] - **test**: relax chunk count expectations (Gireesh Punathil) [#25415](https://github.com/nodejs/node/pull/25415)
+* [[`6b6c628b02`](https://github.com/nodejs/node/commit/6b6c628b02)] - **test**: improve code coverage for i18n (Michael Dawson) [#25428](https://github.com/nodejs/node/pull/25428)
+* [[`d5316e0a1b`](https://github.com/nodejs/node/commit/d5316e0a1b)] - **test**: use fipsMode instead of common.hasFipsCrypto (Daniel Bevenius) [#25510](https://github.com/nodejs/node/pull/25510)
+* [[`48482b02f8`](https://github.com/nodejs/node/commit/48482b02f8)] - **test**: do not use uninitialized memory in common flags check (Anna Henningsen) [#25475](https://github.com/nodejs/node/pull/25475)
+* [[`3e9d9927ee`](https://github.com/nodejs/node/commit/3e9d9927ee)] - **test**: prepare test-hash-seed for CI (Rich Trott) [#25522](https://github.com/nodejs/node/pull/25522)
+* [[`1592ebd652`](https://github.com/nodejs/node/commit/1592ebd652)] - **test**: refactor min() in test-hash-seed (Rich Trott) [#25522](https://github.com/nodejs/node/pull/25522)
+* [[`f4da641c31`](https://github.com/nodejs/node/commit/f4da641c31)] - **test**: add check for wrk to test-keep-alive (Rich Trott) [#25516](https://github.com/nodejs/node/pull/25516)
+* [[`3fcc44d46d`](https://github.com/nodejs/node/commit/3fcc44d46d)] - **test**: fix test-repl timeout and tmpdir refresh (Brian White) [#25425](https://github.com/nodejs/node/pull/25425)
+* [[`e5b305d4fe`](https://github.com/nodejs/node/commit/e5b305d4fe)] - **test**: refactor pummel/test-net-pingpong (Rich Trott) [#25485](https://github.com/nodejs/node/pull/25485)
+* [[`47cf1a2f70`](https://github.com/nodejs/node/commit/47cf1a2f70)] - **test**: refactor pummel/test-net-many-clients (Rich Trott) [#25485](https://github.com/nodejs/node/pull/25485)
+* [[`017b99a881`](https://github.com/nodejs/node/commit/017b99a881)] - **test**: refactor pummel/test-net-connect-econnrefused (Rich Trott) [#25485](https://github.com/nodejs/node/pull/25485)
+* [[`e3437131b6`](https://github.com/nodejs/node/commit/e3437131b6)] - **test**: refactor pummel/test-keep-alive (Rich Trott) [#25485](https://github.com/nodejs/node/pull/25485)
+* [[`1b6dfac1f0`](https://github.com/nodejs/node/commit/1b6dfac1f0)] - **test**: add test for fs.lchmod (ZYSzys) [#25439](https://github.com/nodejs/node/pull/25439)
+* [[`0a80e61e0f`](https://github.com/nodejs/node/commit/0a80e61e0f)] - **test**: rework ephemeralkeyinfo to run in parallel (Sam Roberts) [#25409](https://github.com/nodejs/node/pull/25409)
+* [[`266a07d09d`](https://github.com/nodejs/node/commit/266a07d09d)] - **test**: check for tls renegotiation errors (Sam Roberts) [#25437](https://github.com/nodejs/node/pull/25437)
+* [[`8bebbd6ec1`](https://github.com/nodejs/node/commit/8bebbd6ec1)] - **test**: fix test-net-connect-econnrefused (again) (Rich Trott) [#25438](https://github.com/nodejs/node/pull/25438)
+* [[`d2df34d870`](https://github.com/nodejs/node/commit/d2df34d870)] - **test**: remove unnecessary skipIfWorker() (Rich Trott) [#25427](https://github.com/nodejs/node/pull/25427)
+* [[`9833bffaca`](https://github.com/nodejs/node/commit/9833bffaca)] - **test**: improve test coverage of native crypto code (Tobias Nießen) [#25400](https://github.com/nodejs/node/pull/25400)
+* [[`c8153ce411`](https://github.com/nodejs/node/commit/c8153ce411)] - **test**: move require('https') to after crypto check (Daniel Bevenius) [#25388](https://github.com/nodejs/node/pull/25388)
+* [[`05f9873de4`](https://github.com/nodejs/node/commit/05f9873de4)] - **test**: fix test-net-connect-econnrefused (Rich Trott) [#25389](https://github.com/nodejs/node/pull/25389)
+* [[`771213ad18`](https://github.com/nodejs/node/commit/771213ad18)] - **test**: remove test/pummel/test-http-client-reconnect-bug.js (Rich Trott) [#25387](https://github.com/nodejs/node/pull/25387)
+* [[`82dd321e91`](https://github.com/nodejs/node/commit/82dd321e91)] - **test**: refactor test-fs-watch-non-recursive (Rich Trott) [#25386](https://github.com/nodejs/node/pull/25386)
+* [[`82bc4ac226`](https://github.com/nodejs/node/commit/82bc4ac226)] - **test**: fix test/pummel/test-fs-watch-non-recursive.js (Rich Trott) [#25386](https://github.com/nodejs/node/pull/25386)
+* [[`af2d22a804`](https://github.com/nodejs/node/commit/af2d22a804)] - **test**: fix test/pummel/test-fs-watch-file.js (Rich Trott) [#25384](https://github.com/nodejs/node/pull/25384)
+* [[`95f311c664`](https://github.com/nodejs/node/commit/95f311c664)] - **test**: fix test/pummel/test-fs-largefile.js (Rich Trott) [#25372](https://github.com/nodejs/node/pull/25372)
+* [[`c103e98ad6`](https://github.com/nodejs/node/commit/c103e98ad6)] - **test**: more tests for internal/util/types (ZYSzys) [#25225](https://github.com/nodejs/node/pull/25225)
+* [[`4a22299bb2`](https://github.com/nodejs/node/commit/4a22299bb2)] - **test**: tune test-uv-threadpool-schedule (Rich Trott) [#25358](https://github.com/nodejs/node/pull/25358)
+* [[`26165ac1b6`](https://github.com/nodejs/node/commit/26165ac1b6)] - **test**: remove redundant fchmod test (ZYSzys) [#25282](https://github.com/nodejs/node/pull/25282)
+* [[`f58dbb35b1`](https://github.com/nodejs/node/commit/f58dbb35b1)] - **test**: move test-tls-securepair-client out of pummel (Rich Trott) [#25222](https://github.com/nodejs/node/pull/25222)
+* [[`26b69fd050`](https://github.com/nodejs/node/commit/26b69fd050)] - **test**: fix test-tls-securepair-client (Rich Trott) [#25222](https://github.com/nodejs/node/pull/25222)
+* [[`374a07d4a7`](https://github.com/nodejs/node/commit/374a07d4a7)] - **test**: http2 origin length ERR\_HTTP2\_ORIGIN\_LENGTH (Furqan Shaikh) [#25296](https://github.com/nodejs/node/pull/25296)
+* [[`acd6915299`](https://github.com/nodejs/node/commit/acd6915299)] - **test**: fix test-benchmark-zlib (Rich Trott) [#25365](https://github.com/nodejs/node/pull/25365)
+* [[`8a4fe98ec9`](https://github.com/nodejs/node/commit/8a4fe98ec9)] - **test**: set umask explicitly (Thomas Chung) [#25213](https://github.com/nodejs/node/pull/25213)
+* [[`d9aa19f98e`](https://github.com/nodejs/node/commit/d9aa19f98e)] - **test**: make sure tmpdir is created before using it (Joyee Cheung) [#25224](https://github.com/nodejs/node/pull/25224)
+* [[`4155b7431a`](https://github.com/nodejs/node/commit/4155b7431a)] - **test**: remove unused --expose-native-as V8 flag (peterwmwong) [#25275](https://github.com/nodejs/node/pull/25275)
+* [[`5095d6cb70`](https://github.com/nodejs/node/commit/5095d6cb70)] - **test**: mark test-util-callbackify flaky on AIX (Rich Trott) [#25284](https://github.com/nodejs/node/pull/25284)
+* [[`9eb677b21f`](https://github.com/nodejs/node/commit/9eb677b21f)] - **test**: slightly refactor test-child-process-execsync (Denys Otrishko) [#25227](https://github.com/nodejs/node/pull/25227)
+* [[`fcc03c1d44`](https://github.com/nodejs/node/commit/fcc03c1d44)] - **test**: remove try/catch in common.isMainThread (Rich Trott) [#25249](https://github.com/nodejs/node/pull/25249)
+* [[`d44a93ad94`](https://github.com/nodejs/node/commit/d44a93ad94)] - **test**: regression test for uv threadpool congestion (Gireesh Punathil) [#23099](https://github.com/nodejs/node/pull/23099)
+* [[`0fe72b88a0`](https://github.com/nodejs/node/commit/0fe72b88a0)] - **test**: mark two tests as flaky in AIX (Gireesh Punathil) [#25126](https://github.com/nodejs/node/pull/25126)
+* [[`19ed5c7428`](https://github.com/nodejs/node/commit/19ed5c7428)] - **test**: refactor stdio handling in test-esm-cjs-main (Richard Lau) [#25169](https://github.com/nodejs/node/pull/25169)
+* [[`5f72f393f5`](https://github.com/nodejs/node/commit/5f72f393f5)] - **test**: refactor test-esm-namespace.mjs (Rich Trott) [#25117](https://github.com/nodejs/node/pull/25117)
+* [[`6014b476c3`](https://github.com/nodejs/node/commit/6014b476c3)] - **test**: fix test-tls-session-timeout (Rich Trott) [#25188](https://github.com/nodejs/node/pull/25188)
+* [[`facf36e6df`](https://github.com/nodejs/node/commit/facf36e6df)] - **test**: mark test-trace-events-api-worker-disabled flaky (Rich Trott) [#25197](https://github.com/nodejs/node/pull/25197)
+* [[`8d791ab001`](https://github.com/nodejs/node/commit/8d791ab001)] - **test**: remove Files: comment processing from Python test runner (Rich Trott) [#25183](https://github.com/nodejs/node/pull/25183)
+* [[`424f254e15`](https://github.com/nodejs/node/commit/424f254e15)] - **test**: add hasCrypto check to common flags check (Daniel Bevenius) [#25147](https://github.com/nodejs/node/pull/25147)
+* [[`ead4bb6fb5`](https://github.com/nodejs/node/commit/ead4bb6fb5)] - **test**: verify input flags (Ruben Bridgewater) [#24876](https://github.com/nodejs/node/pull/24876)
+* [[`1ff2f4b6a7`](https://github.com/nodejs/node/commit/1ff2f4b6a7)] - **test**: add signal check to test-esm-cjs-main (Rich Trott) [#25073](https://github.com/nodejs/node/pull/25073)
+* [[`20980a3a28`](https://github.com/nodejs/node/commit/20980a3a28)] - **(SEMVER-MINOR)** **test**: test TLS client authentication (Sam Roberts) [#24733](https://github.com/nodejs/node/pull/24733)
+* [[`f015eec2ba`](https://github.com/nodejs/node/commit/f015eec2ba)] - **test**: complete console.assert() coverage (Rich Trott) [#26827](https://github.com/nodejs/node/pull/26827)
+* [[`9ca4ce3cc3`](https://github.com/nodejs/node/commit/9ca4ce3cc3)] - **test**: fix test-console-stdio-setters to test setters (Rich Trott) [#26796](https://github.com/nodejs/node/pull/26796)
+* [[`44660c1757`](https://github.com/nodejs/node/commit/44660c1757)] - **test**: optimize test-http2-large-file (Rich Trott) [#26737](https://github.com/nodejs/node/pull/26737)
+* [[`8855395a19`](https://github.com/nodejs/node/commit/8855395a19)] - **test**: fix test case in test-http2-respond-file-304.js (gengjiawen) [#26565](https://github.com/nodejs/node/pull/26565)
+* [[`4378042452`](https://github.com/nodejs/node/commit/4378042452)] - **test**: use semicolon for clarity (gengjiawen) [#26566](https://github.com/nodejs/node/pull/26566)
+* [[`7f3b27fa4a`](https://github.com/nodejs/node/commit/7f3b27fa4a)] - **test**: fix test by removing node-inspect/lib/\_inspect (Ruben Bridgewater) [#26619](https://github.com/nodejs/node/pull/26619)
+* [[`6bc7fd9b3c`](https://github.com/nodejs/node/commit/6bc7fd9b3c)] - **test**: fix compiler warning in test\_string.c (Daniel Bevenius) [#26539](https://github.com/nodejs/node/pull/26539)
+* [[`f0acdfd445`](https://github.com/nodejs/node/commit/f0acdfd445)] - **test**: mark `test-worker-prof` as Flaky on ARM (Refael Ackermann) [#26557](https://github.com/nodejs/node/pull/26557)
+* [[`cc0bb02e86`](https://github.com/nodejs/node/commit/cc0bb02e86)] - **test**: rewrite ocsp test to run in parallel (Sam Roberts) [#26460](https://github.com/nodejs/node/pull/26460)
+* [[`ee9694668b`](https://github.com/nodejs/node/commit/ee9694668b)] - **test**: improve code coverage in timers (Juan José Arboleda) [#26310](https://github.com/nodejs/node/pull/26310)
+* [[`60880d79a5`](https://github.com/nodejs/node/commit/60880d79a5)] - **test**: remove flaky designation for test\_threadsafe\_function (Rich Trott) [#26403](https://github.com/nodejs/node/pull/26403)
+* [[`6d4731e46e`](https://github.com/nodejs/node/commit/6d4731e46e)] - **test**: improve test coverage in perf\_hooks (Juan José Arboleda) [#26290](https://github.com/nodejs/node/pull/26290)
+* [[`7d6afb3dbf`](https://github.com/nodejs/node/commit/7d6afb3dbf)] - **test**: remove duplicated buffer negative allocation test (ZYSzys) [#26160](https://github.com/nodejs/node/pull/26160)
+* [[`dcf1310351`](https://github.com/nodejs/node/commit/dcf1310351)] - **test**: only inspect on failure (Ruben Bridgewater) [#26360](https://github.com/nodejs/node/pull/26360)
+* [[`a87c605e1c`](https://github.com/nodejs/node/commit/a87c605e1c)] - **test**: remove s\_client from test-tls-ci-reneg-attack (Rich Trott) [#25700](https://github.com/nodejs/node/pull/25700)
+* [[`3fab8be211`](https://github.com/nodejs/node/commit/3fab8be211)] - **test**: replace Google servers with localhost (Rich Trott) [#25694](https://github.com/nodejs/node/pull/25694)
+* [[`7cceecfd52`](https://github.com/nodejs/node/commit/7cceecfd52)] - **test**: increase error information in test-cli-syntax-\* (Rich Trott) [#25021](https://github.com/nodejs/node/pull/25021)
+* [[`92792f04be`](https://github.com/nodejs/node/commit/92792f04be)] - **test**: split test-cli-syntax into multiple tests (Rich Trott) [#24922](https://github.com/nodejs/node/pull/24922)
+* [[`fe8e07ddd9`](https://github.com/nodejs/node/commit/fe8e07ddd9)] - **(SEMVER-MINOR)** **test**: assert on client and server side seperately (Sam Roberts) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`26288c8ab7`](https://github.com/nodejs/node/commit/26288c8ab7)] - **test**: fix module loading error for AIX 7.1 (Richard Lau) [#25418](https://github.com/nodejs/node/pull/25418)
+* [[`38c9d2bfea`](https://github.com/nodejs/node/commit/38c9d2bfea)] - **test**: add missing tmpdir.refresh() in recently-added test (Rich Trott) [#25098](https://github.com/nodejs/node/pull/25098)
+* [[`3eab58f3ed`](https://github.com/nodejs/node/commit/3eab58f3ed)] - **test,console**: add testing for monkeypatching of console stdio (Rich Trott) [#26561](https://github.com/nodejs/node/pull/26561)
+* [[`2319bc55ca`](https://github.com/nodejs/node/commit/2319bc55ca)] - **(SEMVER-MINOR)** **tls**: make tls.connect() accept a timeout option (Luigi Pinca) [#25517](https://github.com/nodejs/node/pull/25517)
+* [[`858a42e4ce`](https://github.com/nodejs/node/commit/858a42e4ce)] - **tls**: do not confuse TLSSocket and Socket (Sam Roberts) [#25153](https://github.com/nodejs/node/pull/25153)
+* [[`8dd8033519`](https://github.com/nodejs/node/commit/8dd8033519)] - **(SEMVER-MINOR)** **tls**: workaround handshakedone in renegotiation (Shigeki Ohtsu) [#25381](https://github.com/nodejs/node/pull/25381)
+* [[`d3ebad2d6d`](https://github.com/nodejs/node/commit/d3ebad2d6d)] - **(SEMVER-MINOR)** **tls**: add min/max protocol version options (Sam Roberts) [#24405](https://github.com/nodejs/node/pull/24405)
+* [[`e01f3d362a`](https://github.com/nodejs/node/commit/e01f3d362a)] - **tools**: add `12.x` to alternative docs versions (Richard Lau) [#27658](https://github.com/nodejs/node/pull/27658)
+* [[`0fd4b35336`](https://github.com/nodejs/node/commit/0fd4b35336)] - **tools**: update LICENSE and tools/icu/current\_ver.dep (Ujjwal Sharma) [#27361](https://github.com/nodejs/node/pull/27361)
+* [[`c6a2be2d68`](https://github.com/nodejs/node/commit/c6a2be2d68)] - **tools**: make test.py Queue part Python 3 compatible (gengjiawen) [#25701](https://github.com/nodejs/node/pull/25701)
+* [[`40f5d15468`](https://github.com/nodejs/node/commit/40f5d15468)] - **tools**: make mkssldef.py Python 3 compatible (Sakthipriyan Vairamani (thefourtheye)) [#25584](https://github.com/nodejs/node/pull/25584)
+* [[`f8800c90b1`](https://github.com/nodejs/node/commit/f8800c90b1)] - **tools**: improve valgrind support (Anna Henningsen) [#25498](https://github.com/nodejs/node/pull/25498)
+* [[`b8b585376e`](https://github.com/nodejs/node/commit/b8b585376e)] - **tools**: update ESLint to 5.12.1 (cjihrig) [#25573](https://github.com/nodejs/node/pull/25573)
+* [[`e6d1eb3f77`](https://github.com/nodejs/node/commit/e6d1eb3f77)] - **tools**: lint for use of internalBinding() (cjihrig) [#25395](https://github.com/nodejs/node/pull/25395)
+* [[`21500a81fc`](https://github.com/nodejs/node/commit/21500a81fc)] - **tools**: update crypo check rule (cjihrig) [#25399](https://github.com/nodejs/node/pull/25399)
+* [[`a254b930f5`](https://github.com/nodejs/node/commit/a254b930f5)] - **tools**: add openssl-cli to macos-firewall.sh (Daniel Bevenius) [#25385](https://github.com/nodejs/node/pull/25385)
+* [[`21dc7cc3ac`](https://github.com/nodejs/node/commit/21dc7cc3ac)] - **tools**: update ESLint to 5.12.0 (cjihrig) [#25347](https://github.com/nodejs/node/pull/25347)
+* [[`225dfed85f`](https://github.com/nodejs/node/commit/225dfed85f)] - **tools**: replace NULL with nullptr (Juan José Arboleda) [#25179](https://github.com/nodejs/node/pull/25179)
+* [[`b7095ba764`](https://github.com/nodejs/node/commit/b7095ba764)] - **tools**: enable no-useless-catch lint rule (cjihrig) [#25236](https://github.com/nodejs/node/pull/25236)
+* [[`0098cde626`](https://github.com/nodejs/node/commit/0098cde626)] - **tools**: update ESLint to 5.11.1 (cjihrig) [#25236](https://github.com/nodejs/node/pull/25236)
+* [[`629fb36dce`](https://github.com/nodejs/node/commit/629fb36dce)] - **tools**: update ESLint to 5.11.0 (cjihrig) [#25191](https://github.com/nodejs/node/pull/25191)
+* [[`6e329a8dac`](https://github.com/nodejs/node/commit/6e329a8dac)] - **tools**: update certdata.txt (Sam Roberts) [#25113](https://github.com/nodejs/node/pull/25113)
+* [[`3445080c33`](https://github.com/nodejs/node/commit/3445080c33)] - **tools**: tidy function arguments in eslint rules (Rich Trott) [#26668](https://github.com/nodejs/node/pull/26668)
+* [[`700df16a04`](https://github.com/nodejs/node/commit/700df16a04)] - **tools**: update to mdast-util-to-hast v3.0.2 (Sam Ruby) [#22140](https://github.com/nodejs/node/pull/22140)
+* [[`6586003bfe`](https://github.com/nodejs/node/commit/6586003bfe)] - **tools**: fix test.py --shell (Yang Guo) [#26449](https://github.com/nodejs/node/pull/26449)
+* [[`481929653e`](https://github.com/nodejs/node/commit/481929653e)] - **tools**: roll inspector\_protocol to f67ec5 (Pavel Feldman) [#26303](https://github.com/nodejs/node/pull/26303)
+* [[`416aa6e4e7`](https://github.com/nodejs/node/commit/416aa6e4e7)] - **tools**: update extend to 3.0.2 (Rich Trott) [#26392](https://github.com/nodejs/node/pull/26392)
+* [[`d4a8769b31`](https://github.com/nodejs/node/commit/d4a8769b31)] - **tools**: remove unneeded .gitignore entries (Rich Trott) [#26370](https://github.com/nodejs/node/pull/26370)
+* [[`3ded3df714`](https://github.com/nodejs/node/commit/3ded3df714)] - **(SEMVER-MINOR)** **tools, icu**: actually failover if there are multiple URLs (Steven R. Loomis) [#23715](https://github.com/nodejs/node/pull/23715)
+* [[`437a90cfe4`](https://github.com/nodejs/node/commit/437a90cfe4)] - **trace_events**: remove usage of require('util') (dnlup) [#26822](https://github.com/nodejs/node/pull/26822)
+* [[`4285b57e78`](https://github.com/nodejs/node/commit/4285b57e78)] - **(SEMVER-MINOR)** **tty**: add hasColors function (Ruben Bridgewater) [#26247](https://github.com/nodejs/node/pull/26247)
+* [[`3f51a60092`](https://github.com/nodejs/node/commit/3f51a60092)] - **url**: return backslashes from fileURLToPath on win (Kevin Smith) [#25349](https://github.com/nodejs/node/pull/25349)
+* [[`ca4f0dbec1`](https://github.com/nodejs/node/commit/ca4f0dbec1)] - **(SEMVER-MINOR)** **url**: support LF, CR and TAB in pathToFileURL (Charles Samborski) [#23720](https://github.com/nodejs/node/pull/23720)
+* [[`65392be665`](https://github.com/nodejs/node/commit/65392be665)] - **util**: fixes type in argument type validation error (Ankur Oberoi) [#25103](https://github.com/nodejs/node/pull/25103)
+* [[`4e2ceba908`](https://github.com/nodejs/node/commit/4e2ceba908)] - **util**: fix util.inspect with proxied function (Weijia Wang) [#25244](https://github.com/nodejs/node/pull/25244)
+* [[`5dd31bcf07`](https://github.com/nodejs/node/commit/5dd31bcf07)] - **util**: simplify code (Kazushi Kitaya) [#25162](https://github.com/nodejs/node/pull/25162)
+* [[`3f281b2d70`](https://github.com/nodejs/node/commit/3f281b2d70)] - **util**: remove todo (Ruben Bridgewater) [#24982](https://github.com/nodejs/node/pull/24982)
+* [[`d9d31e8d51`](https://github.com/nodejs/node/commit/d9d31e8d51)] - **(SEMVER-MINOR)** **vm**: allow `cachedData` to also be TypedArray|DataView (Benjamin Chen) [#22921](https://github.com/nodejs/node/pull/22921)
+* [[`91c4d280f4`](https://github.com/nodejs/node/commit/91c4d280f4)] - **win, build**: fix building addons on Windows (Bartosz Sosnowski) [#25108](https://github.com/nodejs/node/pull/25108)
+* [[`680ef36675`](https://github.com/nodejs/node/commit/680ef36675)] - **win,build**: update Windows build documentation (Jon Kunkee) [#25995](https://github.com/nodejs/node/pull/25995)
+* [[`fa74b3eb03`](https://github.com/nodejs/node/commit/fa74b3eb03)] - **win,build**: scope NASM warning to only x64 and x86 (Jon Kunkee) [#25995](https://github.com/nodejs/node/pull/25995)
+* [[`7e89684b8c`](https://github.com/nodejs/node/commit/7e89684b8c)] - **win,build**: add ARM64 sections to common.gypi (Jon Kunkee) [#25995](https://github.com/nodejs/node/pull/25995)
+* [[`103635c23b`](https://github.com/nodejs/node/commit/103635c23b)] - **win,build**: add ARM64 support to vcbuild.bat (Jon Kunkee) [#25995](https://github.com/nodejs/node/pull/25995)
+* [[`a762907f8e`](https://github.com/nodejs/node/commit/a762907f8e)] - **win,build**: add arbitrary and binlog options (Jon Kunkee) [#25994](https://github.com/nodejs/node/pull/25994)
+* [[`53e9c8508c`](https://github.com/nodejs/node/commit/53e9c8508c)] - **(SEMVER-MINOR)** **zlib**: add brotli support (Anna Henningsen) [#24938](https://github.com/nodejs/node/pull/24938)
+* [[`dd8d1dabd7`](https://github.com/nodejs/node/commit/dd8d1dabd7)] - **zlib**: split JS code as prep for non-zlib-backed streams (Anna Henningsen) [#24939](https://github.com/nodejs/node/pull/24939)
+
 <a id="10.15.3"></a>
 ## 2019-03-05, Version 10.15.3 'Dubnium' (LTS), @BethGriggs
 
diff --git a/doc/changelogs/CHANGELOG_V11.md b/doc/changelogs/CHANGELOG_V11.md
index 453e4c1dd68b70cc672e8bd280ff3d1d6c442066..be1cd8102e74a5ca173b86f52c25f648681652af 100644
--- a/doc/changelogs/CHANGELOG_V11.md
+++ b/doc/changelogs/CHANGELOG_V11.md
@@ -10,6 +10,7 @@
 </tr>
 <tr>
 <td>
+<a href="#11.15.0">11.15.0</a><br/>
 <a href="#11.14.0">11.14.0</a><br/>
 <a href="#11.13.0">11.13.0</a><br/>
 <a href="#11.12.0">11.12.0</a><br/>
@@ -31,6 +32,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [10.x](CHANGELOG_V10.md)
   * [9.x](CHANGELOG_V9.md)
@@ -44,6 +47,38 @@
   * [io.js](CHANGELOG_IOJS.md)
   * [Archive](CHANGELOG_ARCHIVE.md)
 
+<a id="11.15.0"></a>
+## 2019-04-30, Version 11.15.0 (Current), @codebytere
+
+### Notable changes
+
+* **deps**: add s390 asm rules for OpenSSL-1.1.1 (Shigeki Ohtsu) [#19794](https://github.com/nodejs/node/pull/19794)
+* **src**: add .code and SSL specific error properties (Sam Roberts) [#25093](https://github.com/nodejs/node/pull/25093)
+* **tls**:
+  * add --tls-min-v1.2 CLI switch (Sam Roberts) [#26951](https://github.com/nodejs/node/pull/26951)
+  * supported shared openssl 1.1.0 (Sam Roberts) [#26951](https://github.com/nodejs/node/pull/26951)
+  * revert default max toTLSv1.2 (Sam Roberts) [#26951](https://github.com/nodejs/node/pull/26951)
+  * revert change to invalid protocol error type (Sam Roberts) [#26951](https://github.com/nodejs/node/pull/26951)
+  * support TLSv1.3 (Sam Roberts) [#26209](https://github.com/nodejs/node/pull/26209)
+  * add code for ERR\_TLS\_INVALID\_PROTOCOL\_METHOD (Sam Roberts) [#24729](https://github.com/nodejs/node/pull/24729)
+
+### Commits
+
+* [[`7da23dcbfa`](https://github.com/nodejs/node/commit/7da23dcbfa)] - **deps**: V8: backport 61f4c22 (Anna Henningsen) [#27259](https://github.com/nodejs/node/pull/27259)
+* [[`8db791d0fe`](https://github.com/nodejs/node/commit/8db791d0fe)] - **deps**: update archs files for OpenSSL-1.1.1b (Sam Roberts) [#26327](https://github.com/nodejs/node/pull/26327)
+* [[`1c98b720b1`](https://github.com/nodejs/node/commit/1c98b720b1)] - **(SEMVER-MINOR)** **deps**: add s390 asm rules for OpenSSL-1.1.1 (Shigeki Ohtsu) [#19794](https://github.com/nodejs/node/pull/19794)
+* [[`d8cc478ae9`](https://github.com/nodejs/node/commit/d8cc478ae9)] - **deps**: upgrade openssl sources to 1.1.1b (Sam Roberts) [#26327](https://github.com/nodejs/node/pull/26327)
+* [[`fa6f0f1644`](https://github.com/nodejs/node/commit/fa6f0f1644)] - **doc**: describe tls.DEFAULT\_MIN\_VERSION/\_MAX\_VERSION (Sam Roberts) [#26821](https://github.com/nodejs/node/pull/26821)
+* [[`8b5d350a35`](https://github.com/nodejs/node/commit/8b5d350a35)] - **(SEMVER-MINOR)** **src**: add .code and SSL specific error properties (Sam Roberts) [#25093](https://github.com/nodejs/node/pull/25093)
+* [[`bf2c283555`](https://github.com/nodejs/node/commit/bf2c283555)] - **(SEMVER-MINOR)** **tls**: add --tls-min-v1.2 CLI switch (Sam Roberts) [#26951](https://github.com/nodejs/node/pull/26951)
+* [[`7aeca270f6`](https://github.com/nodejs/node/commit/7aeca270f6)] - **(SEMVER-MINOR)** **tls**: supported shared openssl 1.1.0 (Sam Roberts) [#26951](https://github.com/nodejs/node/pull/26951)
+* [[`d2666e6ded`](https://github.com/nodejs/node/commit/d2666e6ded)] - **tls**: add debugging to native TLS code (Anna Henningsen) [#26843](https://github.com/nodejs/node/pull/26843)
+* [[`225417b849`](https://github.com/nodejs/node/commit/225417b849)] - **tls**: add CHECK for impossible condition (AnnaHenningsen) [#26843](https://github.com/nodejs/node/pull/26843)
+* [[`109c097797`](https://github.com/nodejs/node/commit/109c097797)] - **(SEMVER-MINOR)** **tls**: revert default max toTLSv1.2 (Sam Roberts) [#26951](https://github.com/nodejs/node/pull/26951)
+* [[`7393e37af1`](https://github.com/nodejs/node/commit/7393e37af1)] - **(SEMVER-MINOR)** **tls**: support TLSv1.3 (Sam Roberts) [#26209](https://github.com/nodejs/node/pull/26209)
+* [[`8e14859459`](https://github.com/nodejs/node/commit/8e14859459)] - **(SEMVER-MINOR)** **tls**: revert change to invalid protocol error type (Sam Roberts) [#26951](https://github.com/nodejs/node/pull/26951)
+* [[`00688b6042`](https://github.com/nodejs/node/commit/00688b6042)] - **(SEMVER-MINOR)** **tls**: add code for ERR\_TLS\_INVALID\_PROTOCOL\_METHOD (Sam Roberts) [#24729](https://github.com/nodejs/node/pull/24729)
+
 <a id="11.14.0"></a>
 ## 2019-04-11, Version 11.14.0 (Current), @BethGriggs
 
diff --git a/doc/changelogs/CHANGELOG_V12.md b/doc/changelogs/CHANGELOG_V12.md
index 58153dce08220596c312a3746b44438499c3fbb5..e3a457c39f18c691f4e4eef5a69dc35cde0ce984 100644
--- a/doc/changelogs/CHANGELOG_V12.md
+++ b/doc/changelogs/CHANGELOG_V12.md
@@ -11,27 +11,6 @@
 </tr>
 <tr>
 <td valign="top">
-<a href="#12.22.7">12.22.7</a><br/>
-<a href="#12.22.6">12.22.6</a><br/>
-<a href="#12.22.5">12.22.5</a><br/>
-<a href="#12.22.4">12.22.4</a><br/>
-<a href="#12.22.3">12.22.3</a><br/>
-<a href="#12.22.2">12.22.2</a><br/>
-<a href="#12.22.1">12.22.1</a><br/>
-<a href="#12.22.0">12.22.0</a><br/>
-<a href="#12.21.0">12.21.0</a><br/>
-<a href="#12.20.2">12.20.2</a><br/>
-<a href="#12.20.1">12.20.1</a><br/>
-<a href="#12.20.0">12.20.0</a><br/>
-<a href="#12.19.1">12.19.1</a><br/>
-<a href="#12.19.0">12.19.0</a><br/>
-<a href="#12.18.4">12.18.4</a><br/>
-<a href="#12.18.3">12.18.3</a><br/>
-<a href="#12.18.2">12.18.2</a><br/>
-<a href="#12.18.1">12.18.1</a><br/>
-<a href="#12.18.0">12.18.0</a><br/>
-<a href="#12.17.0">12.17.0</a><br/>
-<a href="#12.16.3">12.16.3</a><br/>
 <a href="#12.16.2">12.16.2</a><br/>
 <a href="#12.16.1">12.16.1</a><br/>
 <a href="#12.16.0">12.16.0</a><br/>
@@ -64,6 +43,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
   * [9.x](CHANGELOG_V9.md)
@@ -77,2205 +58,6 @@
   * [io.js](CHANGELOG_IOJS.md)
   * [Archive](CHANGELOG_ARCHIVE.md)
 
-<a id="12.22.7"></a>
-## 2021-10-12, Version 12.22.7 'Erbium' (LTS), @danielleadams
-
-This is a security release.
-
-### Notable changes
-
-* **CVE-2021-22959**: HTTP Request Smuggling due to spaced in headers (Medium)
-  * The http parser accepts requests with a space (SP) right after the header name before the colon. This can lead to HTTP Request Smuggling (HRS). More details will be available at [CVE-2021-22959](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22959) after publication.
-* **CVE-2021-22960**: HTTP Request Smuggling when parsing the body (Medium)
-  * The parse ignores chunk extensions when parsing the body of chunked requests. This leads to HTTP Request Smuggling (HRS) under certain conditions. More details will be available at [CVE-2021-22960](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22960) after publication.
-
-### Commits
-
-* [[`21a2e554e3`](https://github.com/nodejs/node/commit/21a2e554e3)] - **deps**: update llhttp to 2.1.4 (Fedor Indutny) [nodejs-private/node-private#286](https://github.com/nodejs-private/node-private/pull/286)
-* [[`d5d3a03246`](https://github.com/nodejs/node/commit/d5d3a03246)] - **http**: add regression test for smuggling content length (Matteo Collina) [nodejs-private/node-private#286](https://github.com/nodejs-private/node-private/pull/286)
-* [[`0858587f21`](https://github.com/nodejs/node/commit/0858587f21)] - **http**: add regression test for chunked smuggling (Matteo Collina) [nodejs-private/node-private#286](https://github.com/nodejs-private/node-private/pull/286)
-
-<a id="12.22.6"></a>
-## 2021-08-31, Version 12.22.6 'Erbium' (LTS), @MylesBorins
-
-This is a security release.
-
-### Notable Changes
-
-These are vulnerabilities in the node-tar, arborist, and npm cli modules which
-are related to the initial reports and subsequent remediation of node-tar
-vulnerabilities [CVE-2021-32803](https://github.com/advisories/GHSA-r628-mhmh-qjhw)
-and [CVE-2021-32804](https://github.com/advisories/GHSA-3jfq-g458-7qm9).
-Subsequent internal security review of node-tar and additional external bounty
-reports have resulted in another 5 CVE being remediated in core npm CLI
-dependencies including node-tar, and npm arborist.
-
-You can read more about it in:
-
-* [CVE-2021-37701](https://github.com/npm/node-tar/security/advisories/GHSA-9r2w-394v-53qc)
-* [CVE-2021-37712](https://github.com/npm/node-tar/security/advisories/GHSA-qq89-hq3f-393p)
-* [CVE-2021-37713](https://github.com/npm/node-tar/security/advisories/GHSA-5955-9wpr-37jh)
-* [CVE-2021-39134](https://github.com/npm/arborist/security/advisories/GHSA-2h3h-q99f-3fhc)
-* [CVE-2021-39135](https://github.com/npm/arborist/security/advisories/GHSA-gmw6-94gg-2rc2)
-
-### Commits
-
-* [[`a0154b586b`](https://github.com/nodejs/node/commit/a0154b586b)] - **deps**: update archs files for OpenSSL-1.1.1l (Richard Lau) [#39869](https://github.com/nodejs/node/pull/39869)
-* [[`7a95637eb7`](https://github.com/nodejs/node/commit/7a95637eb7)] - **deps**: upgrade openssl sources to 1.1.1l (Richard Lau) [#39869](https://github.com/nodejs/node/pull/39869)
-* [[`840b0ffff6`](https://github.com/nodejs/node/commit/840b0ffff6)] - **deps**: upgrade npm to 6.14.15 (Darcy Clarke) [#39856](https://github.com/nodejs/node/pull/39856)
-
-<a id="12.22.5"></a>
-## 2021-08-11, Version 12.22.5 'Erbium' (LTS), @BethGriggs
-
-This is a security release.
-
-### Notable Changes
-
-* **CVE-2021-3672/CVE-2021-22931**: Improper handling of untypical characters in domain names (High)
-  * Node.js was vulnerable to Remote Code Execution, XSS, application crashes due to missing input validation of hostnames returned by Domain Name Servers in the Node.js DNS library which can lead to the output of wrong hostnames (leading to Domain Hijacking) and injection vulnerabilities in applications using the library. You can read more about it at https://nvd.nist.gov/vuln/detail/CVE-2021-22931.
-* **CVE-2021-22930**: Use after free on close http2 on stream canceling (High)
-  * Node.js was vulnerable to a use after free attack where an attacker might be able to exploit memory corruption to change process behavior. This release includes a follow-up fix for CVE-2021-22930 as the issue was not completely resolved by the previous fix. You can read more about it at https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22930.
-* **CVE-2021-22939**: Incomplete validation of rejectUnauthorized parameter (Low)
-  * If the Node.js HTTPS API was used incorrectly and "undefined" was in passed for the "rejectUnauthorized" parameter, no error was returned and connections to servers with an expired certificate would have been accepted. You can read more about it at https://nvd.nist.gov/vuln/detail/CVE-2021-22939.
-
-### Commits
-
-* [[`5f947db68c`](https://github.com/nodejs/node/commit/5f947db68c)] - **deps**: update c-ares to 1.17.2 (Beth Griggs) [#39724](https://github.com/nodejs/node/pull/39724)
-* [[`42695ea34b`](https://github.com/nodejs/node/commit/42695ea34b)] - **deps**: reflect c-ares source tree (Beth Griggs) [#39653](https://github.com/nodejs/node/pull/39653)
-* [[`e4c9156b32`](https://github.com/nodejs/node/commit/e4c9156b32)] - **deps**: apply missed updates from c-ares 1.17.1 (Beth Griggs) [#39653](https://github.com/nodejs/node/pull/39653)
-* [[`9cd1f53103`](https://github.com/nodejs/node/commit/9cd1f53103)] - **http2**: add tests for cancel event while client is paused reading (Akshay K) [#39622](https://github.com/nodejs/node/pull/39622)
-* [[`2008c9722f`](https://github.com/nodejs/node/commit/2008c9722f)] - **http2**: update handling of rst\_stream with error code NGHTTP2\_CANCEL (Akshay K) [#39622](https://github.com/nodejs/node/pull/39622)
-* [[`1780bbc329`](https://github.com/nodejs/node/commit/1780bbc329)] - **tls**: validate "rejectUnauthorized: undefined" (Matteo Collina) [nodejs-private/node-private#276](https://github.com/nodejs-private/node-private/pull/276)
-
-<a id="12.22.4"></a>
-## 2021-07-29, Version 12.22.4 'Erbium' (LTS), @richardlau
-
-This is a security release.
-
-### Notable Changes
-
-* **CVE-2021-22930**: Use after free on close http2 on stream canceling (High)
-  * Node.js is vulnerable to a use after free attack where an attacker might be able to exploit the memory corruption, to change process behavior. You can read more about it in https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22930
-
-### Commits
-
-* [[`499e56babe`](https://github.com/nodejs/node/commit/499e56babe)] - **build**: fix label-pr workflow (Michaël Zasso) [#38399](https://github.com/nodejs/node/pull/38399)
-* [[`98ac3c4108`](https://github.com/nodejs/node/commit/98ac3c4108)] - **build**: label PRs with GitHub Action instead of nodejs-github-bot (Phillip Johnsen) [#38301](https://github.com/nodejs/node/pull/38301)
-* [[`ddc8dde150`](https://github.com/nodejs/node/commit/ddc8dde150)] - **deps**: upgrade npm to 6.14.14 (Darcy Clarke) [#39553](https://github.com/nodejs/node/pull/39553)
-* [[`e11a862eed`](https://github.com/nodejs/node/commit/e11a862eed)] - **deps**: update to c-ares 1.17.1 (Danny Sonnenschein) [#36207](https://github.com/nodejs/node/pull/36207)
-* [[`39e9cd540f`](https://github.com/nodejs/node/commit/39e9cd540f)] - **deps**: restore minimum ICU version to 65 (Richard Lau) [#39068](https://github.com/nodejs/node/pull/39068)
-* [[`e459c79b02`](https://github.com/nodejs/node/commit/e459c79b02)] - **deps**: V8: cherry-pick 035c305ce776 (Michaël Zasso) [#38497](https://github.com/nodejs/node/pull/38497)
-* [[`b3c698a5d8`](https://github.com/nodejs/node/commit/b3c698a5d8)] - **deps**: update to cjs-module-lexer@1.2.1 (Guy Bedford) [#38450](https://github.com/nodejs/node/pull/38450)
-* [[`7d5a2f9588`](https://github.com/nodejs/node/commit/7d5a2f9588)] - **deps**: update to cjs-module-lexer@1.1.1 (Guy Bedford) [#37992](https://github.com/nodejs/node/pull/37992)
-* [[`906b43e586`](https://github.com/nodejs/node/commit/906b43e586)] - **deps**: V8: update build dependencies (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`15b91fa3fa`](https://github.com/nodejs/node/commit/15b91fa3fa)] - **deps**: V8: backport 895949419186 (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`8046daf09f`](https://github.com/nodejs/node/commit/8046daf09f)] - **deps**: V8: cherry-pick 0b3a4ecf7083 (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`f4377b13a6`](https://github.com/nodejs/node/commit/f4377b13a6)] - **deps**: V8: cherry-pick 7c182bd65f42 (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`add7b5b4c2`](https://github.com/nodejs/node/commit/add7b5b4c2)] - **deps**: V8: cherry-pick cc641f6be756 (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`a73275f056`](https://github.com/nodejs/node/commit/a73275f056)] - **deps**: V8: cherry-pick 7b3332844212 (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`492b0d6b37`](https://github.com/nodejs/node/commit/492b0d6b37)] - **deps**: V8: cherry-pick e6f62a41f5ee (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`2b54156260`](https://github.com/nodejs/node/commit/2b54156260)] - **deps**: V8: cherry-pick 92e6d3317082 (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`bbceab4d91`](https://github.com/nodejs/node/commit/bbceab4d91)] - **deps**: V8: backport 1b1eda0876aa (Michaël Zasso) [#39245](https://github.com/nodejs/node/pull/39245)
-* [[`93a1a3c5ae`](https://github.com/nodejs/node/commit/93a1a3c5ae)] - **deps**: V8: cherry-pick 530080c44af2 (Milad Fa) [#38509](https://github.com/nodejs/node/pull/38509)
-* [[`b263f2585a`](https://github.com/nodejs/node/commit/b263f2585a)] - **http2**: on receiving rst\_stream with cancel code add it to pending list (Akshay K) [#39423](https://github.com/nodejs/node/pull/39423)
-* [[`3e4bc1b0d3`](https://github.com/nodejs/node/commit/3e4bc1b0d3)] - **module**: fix legacy `node` specifier resolution to resolve `"main"` field (Antoine du Hamel) [#38979](https://github.com/nodejs/node/pull/38979)
-* [[`f552c45676`](https://github.com/nodejs/node/commit/f552c45676)] - **src**: move CHECK in AddIsolateFinishedCallback (Fedor Indutny) [#38010](https://github.com/nodejs/node/pull/38010)
-* [[`30ce0e66ae`](https://github.com/nodejs/node/commit/30ce0e66ae)] - **src**: update cares\_wrap OpenBSD defines (Anna Henningsen) [#38670](https://github.com/nodejs/node/pull/38670)
-
-<a id="12.22.3"></a>
-## 2021-07-05, Version 12.22.3 'Erbium' (LTS), @richardlau
-
-### Notable Changes
-
-Node.js 12.22.2 introduced a regression in the Windows installer on
-non-English locales that is being fixed in this release. There is no
-need to download this release if you are not using the Windows
-installer.
-
-### Commits
-
-* [[`182f86a4d4`](https://github.com/nodejs/node/commit/182f86a4d4)] - **win,msi**: use localized "Authenticated Users" name (Richard Lau) [#39241](https://github.com/nodejs/node/pull/39241)
-
-<a id="12.22.2"></a>
-## 2021-07-01, Version 12.22.2 'Erbium' (LTS), @richardlau
-
-This is a security release.
-
-### Notable Changes
-
-Vulnerabilities fixed:
-
-* **CVE-2021-22918**: libuv upgrade - Out of bounds read (Medium)
-  * Node.js is vulnerable to out-of-bounds read in libuv's uv__idna_toascii() function which is used to convert strings to ASCII. This is called by Node's dns module's lookup() function and can lead to information disclosures or crashes. You can read more about it in https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22918
-* **CVE-2021-22921**: Windows installer - Node Installer Local Privilege Escalation (Medium)
-  * Node.js is vulnerable to local privilege escalation attacks under certain conditions on Windows platforms. More specifically, improper configuration of permissions in the installation directory allows an attacker to perform two different escalation attacks: PATH and DLL hijacking. You can read more about it in https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22921
-* **CVE-2021-27290**: npm upgrade - ssri Regular Expression Denial of Service (ReDoS) (High)
-  * This is a vulnerability in the ssri npm mudule which may be vulnerable to denial of service attacks. You can read more about it in https://github.com/advisories/GHSA-vx3p-948g-6vhq
-* **CVE-2021-23362**: npm upgrade - hosted-git-info Regular Expression Denial of Service (ReDoS) (Medium)
-  * This is a vulnerability in the hosted-git-info npm mudule which may be vulnerable to denial of service attacks. You can read more about it in https://nvd.nist.gov/vuln/detail/CVE-2021-23362
-
-### Commits
-
-* [[`623fd1fcb5`](https://github.com/nodejs/node/commit/623fd1fcb5)] - **deps**: uv: cherry-pick 99c29c9c2c9b (Ben Noordhuis) [nodejs-private/node-private#267](https://github.com/nodejs-private/node-private/pull/267)
-* [[`923b3760f8`](https://github.com/nodejs/node/commit/923b3760f8)] - **deps**: upgrade npm to 6.14.13 (Ruy Adorno) [#38214](https://github.com/nodejs/node/pull/38214)
-* [[`a52790cba0`](https://github.com/nodejs/node/commit/a52790cba0)] - **win,msi**: set install directory permission (AkshayK) [nodejs-private/node-private#269](https://github.com/nodejs-private/node-private/pull/269)
-
-<a id="12.22.1"></a>
-## 2021-04-06, Version 12.22.1 'Erbium' (LTS), @mylesborins
-
-This is a security release.
-
-### Notable Changes
-
-Vulnerabilities fixed:
-
-* **CVE-2021-3450**: OpenSSL - CA certificate check bypass with X509_V_FLAG_X509_STRICT (High)
-  * This is a vulnerability in OpenSSL which may be exploited through Node.js. You can read more about it in https://www.openssl.org/news/secadv/20210325.txt
-  * Impacts:
-    * All versions of the 15.x, 14.x, 12.x and 10.x releases lines
-* **CVE-2021-3449**: OpenSSL - NULL pointer deref in signature_algorithms processing (High)
-  * This is a vulnerability in OpenSSL which may be exploited through Node.js. You can read more about it in https://www.openssl.org/news/secadv/20210325.txt
-  * Impacts:
-    * All versions of the 15.x, 14.x, 12.x and 10.x releases lines
-* **CVE-2020-7774**: npm upgrade - Update y18n to fix Prototype-Pollution (High)
-  * This is a vulnerability in the y18n npm module which may be exploited by prototype pollution. You can read more about it in https://github.com/advisories/GHSA-c4w7-xm78-47vh
-  * Impacts:
-    * All versions of the 14.x, 12.x and 10.x releases lines
-
-### Commits
-
-* [[`c947f1a0e1`](https://github.com/nodejs/node/commit/c947f1a0e1)] - **deps**: upgrade npm to 6.14.12 (Ruy Adorno) [#37918](https://github.com/nodejs/node/pull/37918)
-* [[`51a753c06f`](https://github.com/nodejs/node/commit/51a753c06f)] - **deps**: update archs files for OpenSSL-1.1.1k (Tobias Nießen) [#37939](https://github.com/nodejs/node/pull/37939)
-* [[`c85a519b48`](https://github.com/nodejs/node/commit/c85a519b48)] - **deps**: upgrade openssl sources to 1.1.1k (Tobias Nießen) [#37939](https://github.com/nodejs/node/pull/37939)
-
-<a id="12.22.0"></a>
-## 2021-03-30, Version 12.22.0 'Erbium' (LTS), @richardlau
-
-### Notable changes
-
-#### The legacy HTTP parser is runtime deprecated
-
-The legacy HTTP parser, selected by the `--http-parser=legacy` command line
-option, is deprecated with the pending End-of-Life of Node.js 10.x (where it
-is the only HTTP parser implementation provided) at the end of April 2021. It
-will now warn on use but otherwise continue to function and may be removed in
-a future Node.js 12.x release.
-
-The default HTTP parser based on llhttp is not affected. By default it is
-stricter than the now deprecated legacy HTTP parser. If interoperability with
-HTTP implementations that send invalid HTTP headers is required, the HTTP
-parser can be started in a less secure mode with the
-[`--insecure-http-parser`](https://nodejs.org/docs/latest-v12.x/api/cli.html#cli_insecure_http_parser)
-command line option.
-
-Contributed by Beth Griggs [#37603](https://github.com/nodejs/node/pull/37603).
-
-#### ES Modules
-
-ES Modules are now considered stable.
-
-Contributed by Guy Bedford [#35781](https://github.com/nodejs/node/pull/35781)
-
-#### node-api
-
-Updated to node-api version 8 and added an experimental API to allow retrieval of the add-on file name.
-
-Contributed by Gabriel Schulhof [#37652](https://github.com/nodejs/node/pull/37652) and [#37195](https://github.com/nodejs/node/pull/37195).
-
-#### New API's to control code coverage data collection
-
-`v8.stopCoverage()` and `v8.takeCoverage()` have been added.
-
-Contributed by Joyee Cheung [#33807](https://github.com/nodejs/node/pull/33807).
-
-#### New API to monitor event loop utilization by Worker threads
-
-`worker.performance.eventLoopUtilization()` has been added.
-
-Contributed by Trevor Norris [#35664](https://github.com/nodejs/node/pull/35664).
-
-### Commits
-
-* [[`1872625990`](https://github.com/nodejs/node/commit/1872625990)] - **(SEMVER-MINOR)** **deps**: update to cjs-module-lexer@1.1.0 (Guy Bedford) [#37712](https://github.com/nodejs/node/pull/37712)
-* [[`dfa04d9035`](https://github.com/nodejs/node/commit/dfa04d9035)] - **deps**: V8: cherry-pick beebee4f80ff (Peter Marshall) [#37293](https://github.com/nodejs/node/pull/37293)
-* [[`bf8733fe22`](https://github.com/nodejs/node/commit/bf8733fe22)] - **doc**: mark modules implementation as stable (Guy Bedford) [#35781](https://github.com/nodejs/node/pull/35781)
-* [[`0a35d49f56`](https://github.com/nodejs/node/commit/0a35d49f56)] - ***Revert*** "**embedding**: make Stop() stop Workers" (Anna Henningsen) [#32623](https://github.com/nodejs/node/pull/32623)
-* [[`a0b610450a`](https://github.com/nodejs/node/commit/a0b610450a)] - **(SEMVER-MINOR)** **http**: runtime deprecate legacy HTTP parser (Beth Griggs) [#37603](https://github.com/nodejs/node/pull/37603)
-* [[`2da24ac302`](https://github.com/nodejs/node/commit/2da24ac302)] - **lib**: add URI handling functions to primordials (Antoine du Hamel) [#37394](https://github.com/nodejs/node/pull/37394)
-* [[`7b0ed4ba92`](https://github.com/nodejs/node/commit/7b0ed4ba92)] - **module**: improve support of data: URLs (Antoine du Hamel) [#37392](https://github.com/nodejs/node/pull/37392)
-* [[`93dd799a86`](https://github.com/nodejs/node/commit/93dd799a86)] - **(SEMVER-MINOR)** **node-api**: define version 8 (Gabriel Schulhof) [#37652](https://github.com/nodejs/node/pull/37652)
-* [[`f5692093d3`](https://github.com/nodejs/node/commit/f5692093d3)] - **(SEMVER-MINOR)** **node-api**: allow retrieval of add-on file name (Gabriel Schulhof) [#37195](https://github.com/nodejs/node/pull/37195)
-* [[`6cef0e3678`](https://github.com/nodejs/node/commit/6cef0e3678)] - **src,test**: add regression test for nested Worker termination (Anna Henningsen) [#32623](https://github.com/nodejs/node/pull/32623)
-* [[`364bf03a68`](https://github.com/nodejs/node/commit/364bf03a68)] - **test**: fix races in test-performance-eventlooputil (Gerhard Stoebich) [#36028](https://github.com/nodejs/node/pull/36028)
-* [[`d7a4ccdf09`](https://github.com/nodejs/node/commit/d7a4ccdf09)] - **test**: correct test-worker-eventlooputil (Gerhard Stoebich) [#35891](https://github.com/nodejs/node/pull/35891)
-* [[`0f6d44500c`](https://github.com/nodejs/node/commit/0f6d44500c)] - **test**: add cpu-profiler-crash test (Santiago Gimeno) [#37293](https://github.com/nodejs/node/pull/37293)
-* [[`86f34ee18c`](https://github.com/nodejs/node/commit/86f34ee18c)] - **(SEMVER-MINOR)** **v8**: implement v8.stopCoverage() (Joyee Cheung) [#33807](https://github.com/nodejs/node/pull/33807)
-* [[`8ddea3f16d`](https://github.com/nodejs/node/commit/8ddea3f16d)] - **(SEMVER-MINOR)** **v8**: implement v8.takeCoverage() (Joyee Cheung) [#33807](https://github.com/nodejs/node/pull/33807)
-* [[`eec7542781`](https://github.com/nodejs/node/commit/eec7542781)] - **(SEMVER-MINOR)** **worker**: add eventLoopUtilization() (Trevor Norris) [#35664](https://github.com/nodejs/node/pull/35664)
-
-<a id="12.21.0"></a>
-## 2021-02-23, Version 12.21.0 'Erbium' (LTS), @richardlau
-
-This is a security release.
-
-### Notable changes
-
-Vulnerabilities fixed:
-
-* **CVE-2021-22883**: HTTP2 'unknownProtocol' cause Denial of Service by resource exhaustion
-  * Affected Node.js versions are vulnerable to denial of service attacks when too many connection attempts with an 'unknownProtocol' are established. This leads to a leak of file descriptors. If a file descriptor limit is configured on the system, then the server is unable to accept new connections and prevent the process also from opening, e.g. a file. If no file descriptor limit is configured, then this lead to an excessive memory usage and cause the system to run out of memory.
-* **CVE-2021-22884**: DNS rebinding in --inspect
-  * Affected Node.js versions are vulnerable to denial of service attacks when the whitelist includes “localhost6”. When “localhost6” is not present in /etc/hosts, it is just an ordinary domain that is resolved via DNS, i.e., over network. If the attacker controls the victim's DNS server or can spoof its responses, the DNS rebinding protection can be bypassed by using the “localhost6” domain. As long as the attacker uses the “localhost6” domain, they can still apply the attack described in CVE-2018-7160.
-* **CVE-2021-23840**: OpenSSL - Integer overflow in CipherUpdate
-  * This is a vulnerability in OpenSSL which may be exploited through Node.js. You can read more about it in https://www.openssl.org/news/secadv/20210216.txt
-
-### Commits
-
-* [[`e69177a088`](https://github.com/nodejs/node/commit/e69177a088)] - **deps**: update archs files for OpenSSL-1.1.1j (Daniel Bevenius) [#37413](https://github.com/nodejs/node/pull/37413)
-* [[`0633ae77e6`](https://github.com/nodejs/node/commit/0633ae77e6)] - **deps**: upgrade openssl sources to 1.1.1j (Daniel Bevenius) [#37413](https://github.com/nodejs/node/pull/37413)
-* [[`922ada7713`](https://github.com/nodejs/node/commit/922ada7713)] - **(SEMVER-MINOR)** **http2**: add unknownProtocol timeout (Daniel Bevenius) [nodejs-private/node-private#246](https://github.com/nodejs-private/node-private/pull/246)
-* [[`1564752d55`](https://github.com/nodejs/node/commit/1564752d55)] - **src**: drop localhost6 as allowed host for inspector (Matteo Collina) [nodejs-private/node-private#244](https://github.com/nodejs-private/node-private/pull/244)
-
-<a id="12.20.2"></a>
-## 2021-02-10, Version 12.20.2 'Erbium' (LTS), @ruyadorno
-
-### Notable changes
-
-* **deps**:
-  * upgrade npm to 6.14.11 (Ruy Adorno) [#37173](https://github.com/nodejs/node/pull/37173)
-
-### Commits
-
-* [[`e8a4e560ea`](https://github.com/nodejs/node/commit/e8a4e560ea)] - **async_hooks**: fix leak in AsyncLocalStorage exit (Stephen Belanger) [#35779](https://github.com/nodejs/node/pull/35779)
-* [[`427968d266`](https://github.com/nodejs/node/commit/427968d266)] - **deps**: upgrade npm to 6.14.11 (Ruy Adorno) [#37173](https://github.com/nodejs/node/pull/37173)
-* [[`cd9a8106be`](https://github.com/nodejs/node/commit/cd9a8106be)] - **http**: do not loop over prototype in Agent (Michaël Zasso) [#36410](https://github.com/nodejs/node/pull/36410)
-* [[`4ac8f37800`](https://github.com/nodejs/node/commit/4ac8f37800)] - **http2**: check write not scheduled in scope destructor (David Halls) [#36241](https://github.com/nodejs/node/pull/36241)
-
-<a id="12.20.1"></a>
-## 2021-01-04, Version 12.20.1 'Erbium' (LTS), @richardlau
-
-### Notable changes
-
-This is a security release.
-
-Vulnerabilities fixed:
-
-* **CVE-2020-8265**: use-after-free in TLSWrap (High)
-Affected Node.js versions are vulnerable to a use-after-free bug in its
-TLS implementation. When writing to a TLS enabled socket,
-node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly
-allocated WriteWrap object as first argument. If the DoWrite method does
-not return an error, this object is passed back to the caller as part of
-a StreamWriteResult structure. This may be exploited to corrupt memory
-leading to a Denial of Service or potentially other exploits
-* **CVE-2020-8287**: HTTP Request Smuggling in nodejs
-Affected versions of Node.js allow two copies of a header field in a
-http request. For example, two Transfer-Encoding header fields. In this
-case Node.js identifies the first header field and ignores the second.
-This can lead to HTTP Request Smuggling
-(https://cwe.mitre.org/data/definitions/444.html).
-* **CVE-2020-1971**: OpenSSL - EDIPARTYNAME NULL pointer de-reference (High)
-This is a vulnerability in OpenSSL which may be exploited through Node.js.
-You can read more about it in
-https://www.openssl.org/news/secadv/20201208.txt
-
-### Commits
-
-* [[`5de5354918`](https://github.com/nodejs/node/commit/5de5354918)] - **deps**: update http-parser to http-parser@ec8b5ee63f (Richard Lau) [nodejs-private/node-private#236](https://github.com/nodejs-private/node-private/pull/236)
-* [[`2eacfbec68`](https://github.com/nodejs/node/commit/2eacfbec68)] - **deps**: upgrade npm to 6.14.10 (Ruy Adorno) [#36571](https://github.com/nodejs/node/pull/36571)
-* [[`96ec482d90`](https://github.com/nodejs/node/commit/96ec482d90)] - **deps**: update archs files for OpenSSL-1.1.1i (Myles Borins) [#36521](https://github.com/nodejs/node/pull/36521)
-* [[`7ec0eb408b`](https://github.com/nodejs/node/commit/7ec0eb408b)] - **deps**: upgrade openssl sources to 1.1.1i (Myles Borins) [#36521](https://github.com/nodejs/node/pull/36521)
-* [[`76ea9c5a7a`](https://github.com/nodejs/node/commit/76ea9c5a7a)] - **deps**: upgrade npm to 6.14.9 (Myles Borins) [#36450](https://github.com/nodejs/node/pull/36450)
-* [[`420244e4d9`](https://github.com/nodejs/node/commit/420244e4d9)] - **http**: unset `F_CHUNKED` on new `Transfer-Encoding` (Matteo Collina) [nodejs-private/node-private#236](https://github.com/nodejs-private/node-private/pull/236)
-* [[`4a30ac8c75`](https://github.com/nodejs/node/commit/4a30ac8c75)] - **http**: add test for http transfer encoding smuggling (Richard Lau) [nodejs-private/node-private#236](https://github.com/nodejs-private/node-private/pull/236)
-* [[`92d430917a`](https://github.com/nodejs/node/commit/92d430917a)] - **http**: unset `F_CHUNKED` on new `Transfer-Encoding` (Fedor Indutny) [nodejs-private/node-private#236](https://github.com/nodejs-private/node-private/pull/236)
-* [[`5b00de7d67`](https://github.com/nodejs/node/commit/5b00de7d67)] - **src**: retain pointers to WriteWrap/ShutdownWrap (James M Snell) [nodejs-private/node-private#230](https://github.com/nodejs-private/node-private/pull/230)
-
-<a id="12.20.0"></a>
-## 2020-11-24, Version 12.20.0 'Erbium' (LTS), @mylesborins
-
-### Notable Changes
-
-* **crypto**:
-  * update certdata to NSS 3.56 (Shelley Vohr)
-    https://github.com/nodejs/node/pull/35546
-* **deps**:
-  * update llhttp to 2.1.3 (Fedor Indutny)
-    https://github.com/nodejs/node/pull/35435
-  * (SEMVER-MINOR) upgrade to libuv 1.40.0 (Colin Ihrig)
-    https://github.com/nodejs/node/pull/35333
-* **doc**:
-  * add aduh95 to collaborators (Antoine du Hamel)
-    https://github.com/nodejs/node/pull/35542
-* **fs**:
-  * (SEMVER-MINOR) add .ref() and .unref() methods to watcher classes (rickyes)
-    https://github.com/nodejs/node/pull/33134
-* **http**:
-  * (SEMVER-MINOR) added scheduling option to http agent (delvedor)
-    https://github.com/nodejs/node/pull/33278
-* **module**:
-  * (SEMVER-MINOR) exports pattern support (Guy Bedford)
-    https://github.com/nodejs/node/pull/34718
-  * (SEMVER-MINOR) named exports for CJS via static analysis (Guy Bedford)
-    https://github.com/nodejs/node/pull/35249
-* **n-api**:
-  * (SEMVER-MINOR) add more property defaults (Gerhard Stoebich)
-    https://github.com/nodejs/node/pull/35214
-* **src**:
-  * (SEMVER-MINOR) move node_contextify to modern THROW_ERR_* (James M Snell)
-    https://github.com/nodejs/node/pull/35470
-  * (SEMVER-MINOR) move node_process to modern THROW_ERR* (James M Snell)
-    https://github.com/nodejs/node/pull/35472
-  * (SEMVER-MINOR) expose v8::Isolate setup callbacks (Shelley Vohr)
-    https://github.com/nodejs/node/pull/35512
-
-### Commits
-
-* [[`c6eb0b62d9`](https://github.com/nodejs/node/commit/c6eb0b62d9)] - **benchmark**: ignore build artifacts for napi addons (Richard Lau) [#35970](https://github.com/nodejs/node/pull/35970)
-* [[`f3a045720c`](https://github.com/nodejs/node/commit/f3a045720c)] - **build**: fuzzer that targets node::LoadEnvironment() (davkor) [#34844](https://github.com/nodejs/node/pull/34844)
-* [[`48bc3fcd4c`](https://github.com/nodejs/node/commit/48bc3fcd4c)] - **build**: improved release lint error message (Shelley Vohr) [#35523](https://github.com/nodejs/node/pull/35523)
-* [[`2e766a6adf`](https://github.com/nodejs/node/commit/2e766a6adf)] - **console**: add Symbol.toStringTag property (Leko) [#35399](https://github.com/nodejs/node/pull/35399)
-* [[`90244362cc`](https://github.com/nodejs/node/commit/90244362cc)] - **crypto**: fix KeyObject garbage collection (Anna Henningsen) [#35481](https://github.com/nodejs/node/pull/35481)
-* [[`42f64eba89`](https://github.com/nodejs/node/commit/42f64eba89)] - **crypto**: update certdata to NSS 3.56 (Shelley Vohr) [#35546](https://github.com/nodejs/node/pull/35546)
-* [[`a6f58c0888`](https://github.com/nodejs/node/commit/a6f58c0888)] - **crypto**: set env values in KeyObject Deserialize method (ThakurKarthik) [#35416](https://github.com/nodejs/node/pull/35416)
-* [[`6539cf2725`](https://github.com/nodejs/node/commit/6539cf2725)] - **deps**: upgrade to cjs-module-lexer@1.0.0 (Guy Bedford) [#35928](https://github.com/nodejs/node/pull/35928)
-* [[`bdcc77bdf4`](https://github.com/nodejs/node/commit/bdcc77bdf4)] - **deps**: update to cjs-module-lexer@0.5.2 (Guy Bedford) [#35901](https://github.com/nodejs/node/pull/35901)
-* [[`5b8d3c74e8`](https://github.com/nodejs/node/commit/5b8d3c74e8)] - **deps**: upgrade to cjs-module-lexer@0.5.0 (Guy Bedford) [#35871](https://github.com/nodejs/node/pull/35871)
-* [[`d7f0e3e5f0`](https://github.com/nodejs/node/commit/d7f0e3e5f0)] - **deps**: update to cjs-module-lexer@0.4.3 (Guy Bedford) [#35745](https://github.com/nodejs/node/pull/35745)
-* [[`0a1474d9df`](https://github.com/nodejs/node/commit/0a1474d9df)] - **deps**: update llhttp to 2.1.3 (Fedor Indutny) [#35435](https://github.com/nodejs/node/pull/35435)
-* [[`cf07a8695a`](https://github.com/nodejs/node/commit/cf07a8695a)] - **deps**: upgrade to libuv 1.40.0 (Colin Ihrig) [#35333](https://github.com/nodejs/node/pull/35333)
-* [[`cc11464b4e`](https://github.com/nodejs/node/commit/cc11464b4e)] - **deps**: upgrade to c-ares v1.16.1 (Shelley Vohr) [#35324](https://github.com/nodejs/node/pull/35324)
-* [[`5405e62eaf`](https://github.com/nodejs/node/commit/5405e62eaf)] - **deps**: update to uvwasi 0.0.11 (Colin Ihrig) [#35104](https://github.com/nodejs/node/pull/35104)
-* [[`44c739cc49`](https://github.com/nodejs/node/commit/44c739cc49)] - **deps**: V8: cherry-pick 6be2f6e26e8d (Benjamin Coe) [#35055](https://github.com/nodejs/node/pull/35055)
-* [[`b78a1a186f`](https://github.com/nodejs/node/commit/b78a1a186f)] - **doc**: update releaser in v12.18.4 changelog (Beth Griggs) [#35217](https://github.com/nodejs/node/pull/35217)
-* [[`1cd1d0159d`](https://github.com/nodejs/node/commit/1cd1d0159d)] - **doc**: move package.import content higher (Myles Borins) [#35535](https://github.com/nodejs/node/pull/35535)
-* [[`79f3c323f6`](https://github.com/nodejs/node/commit/79f3c323f6)] - **doc**: fix broken links in modules.md (Rich Trott) [#35182](https://github.com/nodejs/node/pull/35182)
-* [[`b4941cfaec`](https://github.com/nodejs/node/commit/b4941cfaec)] - **doc**: make minor improvements to module.md (Rich Trott) [#35083](https://github.com/nodejs/node/pull/35083)
-* [[`7dc3b74c34`](https://github.com/nodejs/node/commit/7dc3b74c34)] - **doc**: add ESM examples in `module` API doc page (Antoine du HAMEL) [#34875](https://github.com/nodejs/node/pull/34875)
-* [[`f0b06b64ff`](https://github.com/nodejs/node/commit/f0b06b64ff)] - **doc**: move module core module doc to separate page (Antoine du HAMEL) [#34747](https://github.com/nodejs/node/pull/34747)
-* [[`77555d8500`](https://github.com/nodejs/node/commit/77555d8500)] - **doc**: put landing specifics in details tag (Rich Trott) [#35296](https://github.com/nodejs/node/pull/35296)
-* [[`b50b34b30e`](https://github.com/nodejs/node/commit/b50b34b30e)] - **doc**: put release script specifics in details (Myles Borins) [#35260](https://github.com/nodejs/node/pull/35260)
-* [[`1a8f3a844e`](https://github.com/nodejs/node/commit/1a8f3a844e)] - **doc**: copyedit esm.md (Rich Trott) [#35414](https://github.com/nodejs/node/pull/35414)
-* [[`d99120040c`](https://github.com/nodejs/node/commit/d99120040c)] - **doc**: error code fix in resolver spec (Guy Bedford) [#34998](https://github.com/nodejs/node/pull/34998)
-* [[`df52814113`](https://github.com/nodejs/node/commit/df52814113)] - **doc**: document Buffer.concat may use internal pool (Andrey Pechkurov) [#35541](https://github.com/nodejs/node/pull/35541)
-* [[`42a587f9ba`](https://github.com/nodejs/node/commit/42a587f9ba)] - **doc**: use test username instead of real (Pooja D.P) [#35611](https://github.com/nodejs/node/pull/35611)
-* [[`bfff4fc3c9`](https://github.com/nodejs/node/commit/bfff4fc3c9)] - **doc**: revise description of process.ppid (Pooja D.P) [#35589](https://github.com/nodejs/node/pull/35589)
-* [[`a9ac75480f`](https://github.com/nodejs/node/commit/a9ac75480f)] - **doc**: add symlink information for process.execpath (Pooja D.P) [#35590](https://github.com/nodejs/node/pull/35590)
-* [[`5fea51b66c`](https://github.com/nodejs/node/commit/5fea51b66c)] - **doc**: add PoojaDurgad as a triager (Pooja D.P) [#35153](https://github.com/nodejs/node/pull/35153)
-* [[`a0b541c3e0`](https://github.com/nodejs/node/commit/a0b541c3e0)] - **doc**: use kbd element in process doc (Rich Trott) [#35584](https://github.com/nodejs/node/pull/35584)
-* [[`992355cdf9`](https://github.com/nodejs/node/commit/992355cdf9)] - **doc**: simplify wording in tracing APIs doc (Pooja D.P) [#35556](https://github.com/nodejs/node/pull/35556)
-* [[`05db4b8343`](https://github.com/nodejs/node/commit/05db4b8343)] - **doc**: improve SIGINT error text (Rich Trott) [#35558](https://github.com/nodejs/node/pull/35558)
-* [[`42c479572c`](https://github.com/nodejs/node/commit/42c479572c)] - **doc**: use sentence case for class property (Rich Trott) [#35540](https://github.com/nodejs/node/pull/35540)
-* [[`fb9bb05ee2`](https://github.com/nodejs/node/commit/fb9bb05ee2)] - **doc**: fix util.inspect change history (Antoine du Hamel) [#35528](https://github.com/nodejs/node/pull/35528)
-* [[`6952c45202`](https://github.com/nodejs/node/commit/6952c45202)] - **doc**: add aduh95 to collaborators (Antoine du Hamel) [#35542](https://github.com/nodejs/node/pull/35542)
-* [[`b5f752528b`](https://github.com/nodejs/node/commit/b5f752528b)] - **doc**: update AUTHORS list (Anna Henningsen) [#35280](https://github.com/nodejs/node/pull/35280)
-* [[`370f8e3afd`](https://github.com/nodejs/node/commit/370f8e3afd)] - **doc**: update sxa's email address to Red Hat from IBM (Stewart X Addison) [#35442](https://github.com/nodejs/node/pull/35442)
-* [[`edf3fbbd14`](https://github.com/nodejs/node/commit/edf3fbbd14)] - **doc**: update contact information for @BethGriggs (Beth Griggs) [#35451](https://github.com/nodejs/node/pull/35451)
-* [[`8be289e58c`](https://github.com/nodejs/node/commit/8be289e58c)] - **doc**: update contact information for richardlau (Richard Lau) [#35450](https://github.com/nodejs/node/pull/35450)
-* [[`42c0dfcc23`](https://github.com/nodejs/node/commit/42c0dfcc23)] - **doc**: importable node protocol URLs (Bradley Meck) [#35434](https://github.com/nodejs/node/pull/35434)
-* [[`c192af66e7`](https://github.com/nodejs/node/commit/c192af66e7)] - **doc**: unhide resolver spec (Guy Bedford) [#35358](https://github.com/nodejs/node/pull/35358)
-* [[`b0e43c718c`](https://github.com/nodejs/node/commit/b0e43c718c)] - **doc**: add gpg key export directions to releases doc (Danielle Adams) [#35298](https://github.com/nodejs/node/pull/35298)
-* [[`884755f1e5`](https://github.com/nodejs/node/commit/884755f1e5)] - **doc**: simplify circular dependencies text in modules.md (Rich Trott) [#35126](https://github.com/nodejs/node/pull/35126)
-* [[`85c47d753c`](https://github.com/nodejs/node/commit/85c47d753c)] - **doc**: avoid double-while sentence in perf\_hooks.md (Rich Trott) [#35078](https://github.com/nodejs/node/pull/35078)
-* [[`68c5ee45a2`](https://github.com/nodejs/node/commit/68c5ee45a2)] - **doc**: update fs promise-based examples (Richard Lau) [#35760](https://github.com/nodejs/node/pull/35760)
-* [[`66f8730441`](https://github.com/nodejs/node/commit/66f8730441)] - **doc**: add history entry for exports patterns (Antoine du Hamel) [#35410](https://github.com/nodejs/node/pull/35410)
-* [[`a7e66b635d`](https://github.com/nodejs/node/commit/a7e66b635d)] - **doc**: fix conditional exports flag removal version (Antoine du Hamel) [#35428](https://github.com/nodejs/node/pull/35428)
-* [[`9197a6651d`](https://github.com/nodejs/node/commit/9197a6651d)] - **doc**: copyedit packages.md (Rich Trott) [#35427](https://github.com/nodejs/node/pull/35427)
-* [[`f507ca9e21`](https://github.com/nodejs/node/commit/f507ca9e21)] - **doc**: packages docs feedback (Guy Bedford) [#35370](https://github.com/nodejs/node/pull/35370)
-* [[`5330930128`](https://github.com/nodejs/node/commit/5330930128)] - **doc**: refine require/import conditions constraints (Guy Bedford) [#35311](https://github.com/nodejs/node/pull/35311)
-* [[`5f0b1571a7`](https://github.com/nodejs/node/commit/5f0b1571a7)] - **doc**: edit subpath export patterns introduction (Rich Trott) [#35254](https://github.com/nodejs/node/pull/35254)
-* [[`d6a13a947e`](https://github.com/nodejs/node/commit/d6a13a947e)] - **doc**: document support for package.json fields (Antoine du HAMEL) [#34970](https://github.com/nodejs/node/pull/34970)
-* [[`7c1700e143`](https://github.com/nodejs/node/commit/7c1700e143)] - **doc**: move package config docs to separate page (Antoine du HAMEL) [#34748](https://github.com/nodejs/node/pull/34748)
-* [[`7510667d87`](https://github.com/nodejs/node/commit/7510667d87)] - **doc**: rename module pages (Antoine du HAMEL) [#34663](https://github.com/nodejs/node/pull/34663)
-* [[`b644ab6ae6`](https://github.com/nodejs/node/commit/b644ab6ae6)] - **doc**: fix line length in worker\_threads.md (Jucke) [#34419](https://github.com/nodejs/node/pull/34419)
-* [[`fb9b66bdd7`](https://github.com/nodejs/node/commit/fb9b66bdd7)] - **doc**: fix typos in n-api, tls and worker\_threads (Jucke) [#34419](https://github.com/nodejs/node/pull/34419)
-* [[`1f34230373`](https://github.com/nodejs/node/commit/1f34230373)] - **doc,esm**: document experimental warning removal (Antoine du Hamel) [#35750](https://github.com/nodejs/node/pull/35750)
-* [[`985b96a7d5`](https://github.com/nodejs/node/commit/985b96a7d5)] - **doc,esm**: add history support info (Antoine du Hamel) [#35395](https://github.com/nodejs/node/pull/35395)
-* [[`548137f4ec`](https://github.com/nodejs/node/commit/548137f4ec)] - **errors**: simplify ERR\_REQUIRE\_ESM message generation (Rich Trott) [#35123](https://github.com/nodejs/node/pull/35123)
-* [[`f22672de18`](https://github.com/nodejs/node/commit/f22672de18)] - **errors**: improve ERR\_INVALID\_OPT\_VALUE error (Denys Otrishko) [#34671](https://github.com/nodejs/node/pull/34671)
-* [[`7a98961a26`](https://github.com/nodejs/node/commit/7a98961a26)] - **esm**: fix hook mistypes and links to types (Derek Lewis) [#34240](https://github.com/nodejs/node/pull/34240)
-* [[`0f757bc2df`](https://github.com/nodejs/node/commit/0f757bc2df)] - **esm**: use "node:" namespace for builtins (Guy Bedford) [#35387](https://github.com/nodejs/node/pull/35387)
-* [[`b48473228c`](https://github.com/nodejs/node/commit/b48473228c)] - **events**: assume an EventEmitter if emitter.on is a function (Luigi Pinca) [#35818](https://github.com/nodejs/node/pull/35818)
-* [[`19d711391e`](https://github.com/nodejs/node/commit/19d711391e)] - **fs**: simplify realpathSync (himself65) [#35413](https://github.com/nodejs/node/pull/35413)
-* [[`decfc2ae5c`](https://github.com/nodejs/node/commit/decfc2ae5c)] - **fs**: add .ref() and .unref() methods to watcher classes (rickyes) [#33134](https://github.com/nodejs/node/pull/33134)
-* [[`cce464513e`](https://github.com/nodejs/node/commit/cce464513e)] - **http**: added scheduling option to http agent (delvedor) [#33278](https://github.com/nodejs/node/pull/33278)
-* [[`d477e2e147`](https://github.com/nodejs/node/commit/d477e2e147)] - **http**: only set keep-alive when not exists (atian25@qq.com) [#35138](https://github.com/nodejs/node/pull/35138)
-* [[`f10d721737`](https://github.com/nodejs/node/commit/f10d721737)] - **http**: reset headers timeout on headers complete (Robert Nagy) [#34578](https://github.com/nodejs/node/pull/34578)
-* [[`c8a778985b`](https://github.com/nodejs/node/commit/c8a778985b)] - **http2**: avoid unnecessary buffer resize (Denys Otrishko) [#34480](https://github.com/nodejs/node/pull/34480)
-* [[`b732c92e3d`](https://github.com/nodejs/node/commit/b732c92e3d)] - **http2**: use and support non-empty DATA frame with END\_STREAM flag (Carlos Lopez) [#33875](https://github.com/nodejs/node/pull/33875)
-* [[`bfce0eb13a`](https://github.com/nodejs/node/commit/bfce0eb13a)] - ***Revert*** "**http2**: streamline OnStreamRead streamline memory accounting" (Rich Trott) [#34315](https://github.com/nodejs/node/pull/34315)
-* [[`e85ca7af43`](https://github.com/nodejs/node/commit/e85ca7af43)] - **http2**: wait for session socket writable end on close/destroy (Denys Otrishko) [#30854](https://github.com/nodejs/node/pull/30854)
-* [[`2471197099`](https://github.com/nodejs/node/commit/2471197099)] - **http2**: wait for session to finish writing before destroy (Denys Otrishko) [#30854](https://github.com/nodejs/node/pull/30854)
-* [[`82af8acc8e`](https://github.com/nodejs/node/commit/82af8acc8e)] - **http2,doc**: minor fixes (Alba Mendez) [#28044](https://github.com/nodejs/node/pull/28044)
-* [[`a3e8829d4a`](https://github.com/nodejs/node/commit/a3e8829d4a)] - **inspector**: do not hardcode Debugger.CallFrameId in tests (Dmitry Gozman) [#35570](https://github.com/nodejs/node/pull/35570)
-* [[`6efa140f8f`](https://github.com/nodejs/node/commit/6efa140f8f)] - **lib**: change http client path assignment (Yohanan Baruchel) [#35508](https://github.com/nodejs/node/pull/35508)
-* [[`ad7281b081`](https://github.com/nodejs/node/commit/ad7281b081)] - **lib**: use remaining typed arrays from primordials (Michaël Zasso) [#35499](https://github.com/nodejs/node/pull/35499)
-* [[`a9a606f06b`](https://github.com/nodejs/node/commit/a9a606f06b)] - **lib**: use full URL to GitHub issues in comments (Rich Trott) [#34686](https://github.com/nodejs/node/pull/34686)
-* [[`ea239392c2`](https://github.com/nodejs/node/commit/ea239392c2)] - **module**: cjs-module-lexer@0.4.1 big endian fix (Guy Bedford) [#35634](https://github.com/nodejs/node/pull/35634)
-* [[`354f358c1b`](https://github.com/nodejs/node/commit/354f358c1b)] - **module**: use Wasm CJS lexer when available (Guy Bedford) [#35583](https://github.com/nodejs/node/pull/35583)
-* [[`76f76017bf`](https://github.com/nodejs/node/commit/76f76017bf)] - **module**: fix builtin reexport tracing (Guy Bedford) [#35500](https://github.com/nodejs/node/pull/35500)
-* [[`992af4e112`](https://github.com/nodejs/node/commit/992af4e112)] - **module**: fix specifier resolution option value (himself65) [#35098](https://github.com/nodejs/node/pull/35098)
-* [[`1ff956f49e`](https://github.com/nodejs/node/commit/1ff956f49e)] - **module**: remove experimental modules warning (Guy Bedford) [#31974](https://github.com/nodejs/node/pull/31974)
-* [[`41af927efb`](https://github.com/nodejs/node/commit/41af927efb)] - **module**: exports pattern support (Guy Bedford) [#34718](https://github.com/nodejs/node/pull/34718)
-* [[`a18d0df33a`](https://github.com/nodejs/node/commit/a18d0df33a)] - **module**: update to cjs-module-lexer@0.4.0 (Guy Bedford) [#35501](https://github.com/nodejs/node/pull/35501)
-* [[`6ca8fb552d`](https://github.com/nodejs/node/commit/6ca8fb552d)] - **module**: refine module type mismatch error cases (Guy Bedford) [#35426](https://github.com/nodejs/node/pull/35426)
-* [[`9eb1fa1924`](https://github.com/nodejs/node/commit/9eb1fa1924)] - **module**: named exports for CJS via static analysis (Guy Bedford) [#35249](https://github.com/nodejs/node/pull/35249)
-* [[`a93ca2d494`](https://github.com/nodejs/node/commit/a93ca2d494)] - **n-api**: revert change to finalization (Michael Dawson) [#35777](https://github.com/nodejs/node/pull/35777)
-* [[`5faaa603d8`](https://github.com/nodejs/node/commit/5faaa603d8)] - **n-api**: support for object freeze/seal (Shelley Vohr) [#35359](https://github.com/nodejs/node/pull/35359)
-* [[`d938e8508b`](https://github.com/nodejs/node/commit/d938e8508b)] - **n-api**: add more property defaults (Gerhard Stoebich) [#35214](https://github.com/nodejs/node/pull/35214)
-* [[`18f01ddcb5`](https://github.com/nodejs/node/commit/18f01ddcb5)] - **repl**: improve static import error message in repl (Myles Borins) [#33588](https://github.com/nodejs/node/pull/33588)
-* [[`70768ce109`](https://github.com/nodejs/node/commit/70768ce109)] - **repl**: give repl entries unique names (Bradley Meck) [#34372](https://github.com/nodejs/node/pull/34372)
-* [[`e9bee3950c`](https://github.com/nodejs/node/commit/e9bee3950c)] - **src**: move node\_contextify to modern THROW\_ERR\_\* (James M Snell) [#35470](https://github.com/nodejs/node/pull/35470)
-* [[`b741f2ff84`](https://github.com/nodejs/node/commit/b741f2ff84)] - **src**: move node\_process to modern THROW\_ERR\* (James M Snell) [#35472](https://github.com/nodejs/node/pull/35472)
-* [[`2d5393bb28`](https://github.com/nodejs/node/commit/2d5393bb28)] - **src**: fix freeing unintialized pointer bug in ParseSoaReply (Aastha Gupta) [#35502](https://github.com/nodejs/node/pull/35502)
-* [[`dec004f742`](https://github.com/nodejs/node/commit/dec004f742)] - **src**: expose v8::Isolate setup callbacks (Shelley Vohr) [#35512](https://github.com/nodejs/node/pull/35512)
-* [[`7f8834f76c`](https://github.com/nodejs/node/commit/7f8834f76c)] - **src**: more idiomatic error pattern in node\_wasi (James M Snell) [#35493](https://github.com/nodejs/node/pull/35493)
-* [[`ade27b732b`](https://github.com/nodejs/node/commit/ade27b732b)] - **src**: use env-\>ThrowUVException in pipe\_wrap (James M Snell) [#35493](https://github.com/nodejs/node/pull/35493)
-* [[`e70b05208f`](https://github.com/nodejs/node/commit/e70b05208f)] - **src**: remove invalid ToLocalChecked in EmitBeforeExit (Anna Henningsen) [#35484](https://github.com/nodejs/node/pull/35484)
-* [[`cd80195524`](https://github.com/nodejs/node/commit/cd80195524)] - **src**: make MakeCallback() check can\_call\_into\_js before getting method (Anna Henningsen) [#35424](https://github.com/nodejs/node/pull/35424)
-* [[`8a1091648c`](https://github.com/nodejs/node/commit/8a1091648c)] - **stream**: destroy wrapped streams on error (Robert Nagy) [#34102](https://github.com/nodejs/node/pull/34102)
-* [[`fdc67ebf5f`](https://github.com/nodejs/node/commit/fdc67ebf5f)] - **test**: replace annonymous functions with arrow (Pooja D.P) [#34921](https://github.com/nodejs/node/pull/34921)
-* [[`c3e1bf78c4`](https://github.com/nodejs/node/commit/c3e1bf78c4)] - **test**: add wasi readdir() test (Colin Ihrig) [#35202](https://github.com/nodejs/node/pull/35202)
-* [[`607f3c5d84`](https://github.com/nodejs/node/commit/607f3c5d84)] - **test**: fix comment about DNS lookup test (Tobias Nießen) [#35080](https://github.com/nodejs/node/pull/35080)
-* [[`02787ce5d1`](https://github.com/nodejs/node/commit/02787ce5d1)] - **test**: add ALPNProtocols option to clientOptions (Luigi Pinca) [#35482](https://github.com/nodejs/node/pull/35482)
-* [[`12d76b8e8e`](https://github.com/nodejs/node/commit/12d76b8e8e)] - **tls**: reset secureConnecting on client socket (David Halls) [#33209](https://github.com/nodejs/node/pull/33209)
-* [[`adf4f90bce`](https://github.com/nodejs/node/commit/adf4f90bce)] - **tools**: refloat 7 Node.js patches to cpplint.py (Rich Trott) [#35569](https://github.com/nodejs/node/pull/35569)
-* [[`1173efca27`](https://github.com/nodejs/node/commit/1173efca27)] - **tools**: bump cpplint.py to 1.4.6 (Rich Trott) [#35569](https://github.com/nodejs/node/pull/35569)
-* [[`09552670fe`](https://github.com/nodejs/node/commit/09552670fe)] - **tools**: add missing uv\_setup\_argv() calls (Anna Henningsen) [#35491](https://github.com/nodejs/node/pull/35491)
-* [[`ae149232a1`](https://github.com/nodejs/node/commit/ae149232a1)] - **tools**: exclude gyp from markdown link checker (Michaël Zasso) [#35423](https://github.com/nodejs/node/pull/35423)
-* [[`a9ce9b2614`](https://github.com/nodejs/node/commit/a9ce9b2614)] - **tools**: update ESLint to 7.10.0 (Colin Ihrig) [#35366](https://github.com/nodejs/node/pull/35366)
-* [[`bc7da0c22c`](https://github.com/nodejs/node/commit/bc7da0c22c)] - **tools**: ignore build folder when checking links (Ash Cripps) [#35315](https://github.com/nodejs/node/pull/35315)
-* [[`f29717437f`](https://github.com/nodejs/node/commit/f29717437f)] - **tools,doc**: enforce alphabetical order for md refs (Antoine du Hamel) [#35244](https://github.com/nodejs/node/pull/35244)
-* [[`11b10d7d1f`](https://github.com/nodejs/node/commit/11b10d7d1f)] - **tools,doc**: upgrade dependencies (Antoine du Hamel) [#35244](https://github.com/nodejs/node/pull/35244)
-
-<a id="12.19.1"></a>
-## 2020-11-16, Version 12.19.1 'Erbium' (LTS), @BethGriggs
-
-### Notable changes
-
-This is a security release.
-
-Vulnerabilities fixed:
-
-* **CVE-2020-8277**: Denial of Service through DNS request (High). A Node.js application that allows an attacker to trigger a DNS request for a host of their choice could trigger a Denial of Service by getting the application to resolve a DNS record with a larger number of responses.
-
-### Commits
-
-* [[`022899e1d5`](https://github.com/nodejs/node/commit/022899e1d5)] - **deps**: cherry-pick 0d252eb from upstream c-ares (Michael Dawson) [nodejs-private/node-private#231](https://github.com/nodejs-private/node-private/pull/231)
-
-<a id="12.19.0"></a>
-## 2020-10-06, Version 12.19.0 'Erbium' (LTS), @codebytere
-
-### Notable Changes
-
-* [[`d065334d42`](https://github.com/nodejs/node/commit/d065334d42)] - **(SEMVER-MINOR)** **module**: package "imports" field (Guy Bedford) [#34117](https://github.com/nodejs/node/pull/34117)
-* [[`b9d0f73c7c`](https://github.com/nodejs/node/commit/b9d0f73c7c)] - **(SEMVER-MINOR)** **n-api**: create N-API version 7 (Gabriel Schulhof) [#35199](https://github.com/nodejs/node/pull/35199)
-* [[`53c9975673`](https://github.com/nodejs/node/commit/53c9975673)] - **(SEMVER-MINOR)** **crypto**: add randomInt function (Oli Lalonde) [#34600](https://github.com/nodejs/node/pull/34600)
-* [[`9b53b4ddf2`](https://github.com/nodejs/node/commit/9b53b4ddf2)] - **deps**: upgrade to libuv 1.39.0 (Colin Ihrig) [#34915](https://github.com/nodejs/node/pull/34915)
-* [[`e9a8f0c127`](https://github.com/nodejs/node/commit/e9a8f0c127)] - **doc**: add Ricky Zhou to collaborators (rickyes) [#34676](https://github.com/nodejs/node/pull/34676)
-* [[`260914c432`](https://github.com/nodejs/node/commit/260914c432)] - **doc**: add release key for Ruy Adorno (Ruy Adorno) [#34628](https://github.com/nodejs/node/pull/34628)
-* [[`39f90346f8`](https://github.com/nodejs/node/commit/39f90346f8)] - **doc**: add DerekNonGeneric to collaborators (Derek Lewis) [#34602](https://github.com/nodejs/node/pull/34602)
-* [[`7ef1f6a71d`](https://github.com/nodejs/node/commit/7ef1f6a71d)] - **deps**: upgrade npm to 6.14.7 (claudiahdz) [#34468](https://github.com/nodejs/node/pull/34468)
-* [[`437b092eed`](https://github.com/nodejs/node/commit/437b092eed)] - **doc**: add AshCripps to collaborators (Ash Cripps) [#34494](https://github.com/nodejs/node/pull/34494)
-* [[`319d570a47`](https://github.com/nodejs/node/commit/319d570a47)] - **doc**: add HarshithaKP to collaborators (Harshitha K P) [#34417](https://github.com/nodejs/node/pull/34417)
-* [[`d60b13f2e3`](https://github.com/nodejs/node/commit/d60b13f2e3)] - **zlib**: switch to lazy init for zlib streams (Andrey Pechkurov) [#34048](https://github.com/nodejs/node/pull/34048)
-* [[`ae60f50a69`](https://github.com/nodejs/node/commit/ae60f50a69)] - **doc**: add rexagod to collaborators (Pranshu Srivastava) [#34457](https://github.com/nodejs/node/pull/34457)
-* [[`39dea8f70d`](https://github.com/nodejs/node/commit/39dea8f70d)] - **doc**: add release key for Richard Lau (Richard Lau) [#34397](https://github.com/nodejs/node/pull/34397)
-* [[`a2107101be`](https://github.com/nodejs/node/commit/a2107101be)] - **doc**: add danielleadams to collaborators (Danielle Adams) [#34360](https://github.com/nodejs/node/pull/34360)
-* [[`c4f0cb65a1`](https://github.com/nodejs/node/commit/c4f0cb65a1)] - **doc**: add sxa as collaborator (Stewart X Addison) [#34338](https://github.com/nodejs/node/pull/34338)
-* [[`e9a514d13e`](https://github.com/nodejs/node/commit/e9a514d13e)] - **deps**: upgrade to libuv 1.38.1 (Colin Ihrig) [#34187](https://github.com/nodejs/node/pull/34187)
-* [[`a04d76d2ad`](https://github.com/nodejs/node/commit/a04d76d2ad)] - **doc**: add ruyadorno to collaborators (Ruy Adorno) [#34297](https://github.com/nodejs/node/pull/34297)
-* [[`c9bd1a7d8a`](https://github.com/nodejs/node/commit/c9bd1a7d8a)] - **(SEMVER-MINOR)** **module**: deprecate module.parent (Antoine du HAMEL) [#32217](https://github.com/nodejs/node/pull/32217)
-* [[`0a927216cf`](https://github.com/nodejs/node/commit/0a927216cf)] - **(SEMVER-MAJOR)** **doc**: deprecate process.umask() with no arguments (Colin Ihrig) [#32499](https://github.com/nodejs/node/pull/32499)
-
-### Commits
-
-* [[`27ceec0bc6`](https://github.com/nodejs/node/commit/27ceec0bc6)] - Forces Powershell to use tls1.2 (Bartosz Sosnowski) [#33609](https://github.com/nodejs/node/pull/33609)
-* [[`d73b8346b8`](https://github.com/nodejs/node/commit/d73b8346b8)] - **(SEMVER-MINOR)** **assert**: port common.mustCall() to assert (ConorDavenport) [#31982](https://github.com/nodejs/node/pull/31982)
-* [[`148383fdc3`](https://github.com/nodejs/node/commit/148383fdc3)] - **async_hooks**: avoid GC tracking of AsyncResource in ALS (Gerhard Stoebich) [#34653](https://github.com/nodejs/node/pull/34653)
-* [[`0a4401713a`](https://github.com/nodejs/node/commit/0a4401713a)] - **async_hooks**: avoid unneeded AsyncResource creation (Gerhard Stoebich) [#34616](https://github.com/nodejs/node/pull/34616)
-* [[`07968ac456`](https://github.com/nodejs/node/commit/07968ac456)] - **async_hooks**: improve property descriptors in als.bind (Gerhard Stoebich) [#34620](https://github.com/nodejs/node/pull/34620)
-* [[`45d2f4dd3c`](https://github.com/nodejs/node/commit/45d2f4dd3c)] - **(SEMVER-MINOR)** **async_hooks**: add AsyncResource.bind utility (James M Snell) [#34574](https://github.com/nodejs/node/pull/34574)
-* [[`61683e1763`](https://github.com/nodejs/node/commit/61683e1763)] - **async_hooks**: don't read resource if ALS is disabled (Gerhard Stoebich) [#34617](https://github.com/nodejs/node/pull/34617)
-* [[`95e0f8ef52`](https://github.com/nodejs/node/commit/95e0f8ef52)] - **async_hooks**: execute destroy hooks earlier (Gerhard Stoebich) [#34342](https://github.com/nodejs/node/pull/34342)
-* [[`cfc769b048`](https://github.com/nodejs/node/commit/cfc769b048)] - **async_hooks**: fix resource stack for deep stacks (Anna Henningsen) [#34573](https://github.com/nodejs/node/pull/34573)
-* [[`b2241e9fc1`](https://github.com/nodejs/node/commit/b2241e9fc1)] - **async_hooks**: improve resource stack performance (Anna Henningsen) [#34319](https://github.com/nodejs/node/pull/34319)
-* [[`24fddba59b`](https://github.com/nodejs/node/commit/24fddba59b)] - **benchmark**: add benchmark script for resourceUsage (Yash Ladha) [#34691](https://github.com/nodejs/node/pull/34691)
-* [[`145691b83e`](https://github.com/nodejs/node/commit/145691b83e)] - **benchmark**: always throw the same Error instance (Anna Henningsen) [#34523](https://github.com/nodejs/node/pull/34523)
-* [[`7bc26c2e8c`](https://github.com/nodejs/node/commit/7bc26c2e8c)] - **bootstrap**: correct --frozen-intrinsics override fix (Guy Bedford) [#35041](https://github.com/nodejs/node/pull/35041)
-* [[`6ee800f0c3`](https://github.com/nodejs/node/commit/6ee800f0c3)] - **(SEMVER-MINOR)** **buffer**: also alias BigUInt methods (Anna Henningsen) [#34960](https://github.com/nodejs/node/pull/34960)
-* [[`9d07217d2c`](https://github.com/nodejs/node/commit/9d07217d2c)] - **(SEMVER-MINOR)** **buffer**: alias UInt ➡️ Uint in buffer methods (Anna Henningsen) [#34729](https://github.com/nodejs/node/pull/34729)
-* [[`8f2d2aa9e3`](https://github.com/nodejs/node/commit/8f2d2aa9e3)] - **build**: increase API requests for stale action (Phillip Johnsen) [#35235](https://github.com/nodejs/node/pull/35235)
-* [[`ff0b1000d1`](https://github.com/nodejs/node/commit/ff0b1000d1)] - **build**: filter issues & PRs to auto close by matching on stalled label (Phillip Johnsen) [#35159](https://github.com/nodejs/node/pull/35159)
-* [[`06c5120eef`](https://github.com/nodejs/node/commit/06c5120eef)] - **(SEMVER-MINOR)** **build**: add build flag for OSS-Fuzz integration (davkor) [#34761](https://github.com/nodejs/node/pull/34761)
-* [[`9107595acd`](https://github.com/nodejs/node/commit/9107595acd)] - **build**: comment about auto close when stalled via with github action (Phillip Johnsen) [#34555](https://github.com/nodejs/node/pull/34555)
-* [[`60774c08e3`](https://github.com/nodejs/node/commit/60774c08e3)] - **build**: close stalled issues and PRs with github action (Phillip Johnsen) [#34555](https://github.com/nodejs/node/pull/34555)
-* [[`9bb681458c`](https://github.com/nodejs/node/commit/9bb681458c)] - **build**: use autorebase option for git node land (Denys Otrishko) [#34969](https://github.com/nodejs/node/pull/34969)
-* [[`8d27998bd6`](https://github.com/nodejs/node/commit/8d27998bd6)] - **build**: use latest node-core-utils from npm (Denys Otrishko) [#34969](https://github.com/nodejs/node/pull/34969)
-* [[`d2f44a74f8`](https://github.com/nodejs/node/commit/d2f44a74f8)] - **build**: add support for build on arm64 (Evan Lucas) [#34238](https://github.com/nodejs/node/pull/34238)
-* [[`ea56aea452`](https://github.com/nodejs/node/commit/ea56aea452)] - **build**: run link checker in linter workflow (Richard Lau) [#34810](https://github.com/nodejs/node/pull/34810)
-* [[`9e1f8fcb65`](https://github.com/nodejs/node/commit/9e1f8fcb65)] - **build**: implement a Commit Queue in Actions (Mary Marchini) [#34112](https://github.com/nodejs/node/pull/34112)
-* [[`380600dbe5`](https://github.com/nodejs/node/commit/380600dbe5)] - **build**: set --v8-enable-object-print by default (Mary Marchini) [#34705](https://github.com/nodejs/node/pull/34705)
-* [[`191d0ae311`](https://github.com/nodejs/node/commit/191d0ae311)] - **build**: add flag to build V8 with OBJECT\_PRINT (Mary Marchini) [#32834](https://github.com/nodejs/node/pull/32834)
-* [[`f6ad59b60f`](https://github.com/nodejs/node/commit/f6ad59b60f)] - **build**: do not run auto-start-ci on forks (Evan Lucas) [#34650](https://github.com/nodejs/node/pull/34650)
-* [[`90a44e198b`](https://github.com/nodejs/node/commit/90a44e198b)] - **build**: increase startCI verbosity and fix job name (Mary Marchini) [#34635](https://github.com/nodejs/node/pull/34635)
-* [[`7886e763f5`](https://github.com/nodejs/node/commit/7886e763f5)] - **build**: don't run auto-start-ci on push (Mary Marchini) [#34588](https://github.com/nodejs/node/pull/34588)
-* [[`544a722de4`](https://github.com/nodejs/node/commit/544a722de4)] - **build**: fix auto-start-ci script path (Mary Marchini) [#34588](https://github.com/nodejs/node/pull/34588)
-* [[`e51b2680a8`](https://github.com/nodejs/node/commit/e51b2680a8)] - **build**: auto start Jenkins CI via PR labels (Mary Marchini) [#34089](https://github.com/nodejs/node/pull/34089)
-* [[`343894f990`](https://github.com/nodejs/node/commit/343894f990)] - **build**: toolchain.gypi and node\_gyp.py cleanup (iandrc) [#34268](https://github.com/nodejs/node/pull/34268)
-* [[`e7252df0b9`](https://github.com/nodejs/node/commit/e7252df0b9)] - **build**: fix test-ci-js task in Makefile (Rich Trott) [#34433](https://github.com/nodejs/node/pull/34433)
-* [[`833474f844`](https://github.com/nodejs/node/commit/833474f844)] - **build**: do not run benchmark tests on 'make test' (Rich Trott) [#34434](https://github.com/nodejs/node/pull/34434)
-* [[`f14775e492`](https://github.com/nodejs/node/commit/f14775e492)] - **build**: add benchmark tests to CI runs (Rich Trott) [#34288](https://github.com/nodejs/node/pull/34288)
-* [[`acf63b009d`](https://github.com/nodejs/node/commit/acf63b009d)] - **build,deps**: add gen-openssl target (Evan Lucas) [#34642](https://github.com/nodejs/node/pull/34642)
-* [[`b977672edc`](https://github.com/nodejs/node/commit/b977672edc)] - **build,tools**: fix cmd\_regen\_makefile (Daniel Bevenius) [#34255](https://github.com/nodejs/node/pull/34255)
-* [[`17a098b9e6`](https://github.com/nodejs/node/commit/17a098b9e6)] - **(SEMVER-MINOR)** **cli**: add alias for report-directory to make it consistent (Ash Cripps) [#33587](https://github.com/nodejs/node/pull/33587)
-* [[`b329a95c01`](https://github.com/nodejs/node/commit/b329a95c01)] - **console**: document the behavior of console.assert() (iandrc) [#34501](https://github.com/nodejs/node/pull/34501)
-* [[`ed72d83802`](https://github.com/nodejs/node/commit/ed72d83802)] - **crypto**: simplify KeyObject constructor (Rich Trott) [#35064](https://github.com/nodejs/node/pull/35064)
-* [[`b828560908`](https://github.com/nodejs/node/commit/b828560908)] - **(SEMVER-MINOR)** **crypto**: allow KeyObjects in postMessage (Tobias Nießen) [#33360](https://github.com/nodejs/node/pull/33360)
-* [[`2b7273b2ad`](https://github.com/nodejs/node/commit/2b7273b2ad)] - **crypto**: improve invalid arg type message for randomInt() (Rich Trott) [#35089](https://github.com/nodejs/node/pull/35089)
-* [[`bf5a85b43a`](https://github.com/nodejs/node/commit/bf5a85b43a)] - **crypto**: improve randomInt out-of-range error message (Rich Trott) [#35088](https://github.com/nodejs/node/pull/35088)
-* [[`5ef9ee4254`](https://github.com/nodejs/node/commit/5ef9ee4254)] - **crypto**: fix randomInt range check (Tobias Nießen) [#35052](https://github.com/nodejs/node/pull/35052)
-* [[`921129c1d8`](https://github.com/nodejs/node/commit/921129c1d8)] - **crypto**: align parameter names with documentation (Rich Trott) [#35054](https://github.com/nodejs/node/pull/35054)
-* [[`53c9975673`](https://github.com/nodejs/node/commit/53c9975673)] - **(SEMVER-MINOR)** **crypto**: add randomInt function (Oli Lalonde) [#34600](https://github.com/nodejs/node/pull/34600)
-* [[`39dc4086fe`](https://github.com/nodejs/node/commit/39dc4086fe)] - **crypto**: avoid unitializing ECDH objects on error (Tobias Nießen) [#34302](https://github.com/nodejs/node/pull/34302)
-* [[`865f8e85c4`](https://github.com/nodejs/node/commit/865f8e85c4)] - **crypto**: add OP flag constants added in OpenSSL v1.1.1 (Mateusz Krawczuk) [#33929](https://github.com/nodejs/node/pull/33929)
-* [[`bf4e778e50`](https://github.com/nodejs/node/commit/bf4e778e50)] - **crypto**: move typechecking for timingSafeEqual into C++ (Anna Henningsen) [#34141](https://github.com/nodejs/node/pull/34141)
-* [[`4ff6c77e17`](https://github.com/nodejs/node/commit/4ff6c77e17)] - **deps**: V8: cherry-pick e06ace6b5cdb (Anna Henningsen) [#34673](https://github.com/nodejs/node/pull/34673)
-* [[`5db8b357ce`](https://github.com/nodejs/node/commit/5db8b357ce)] - **deps**: V8: cherry-pick eec10a2fd8fa (Stephen Belanger) [#33778](https://github.com/nodejs/node/pull/33778)
-* [[`e9e3390b18`](https://github.com/nodejs/node/commit/e9e3390b18)] - **deps**: V8: backport 3f071e3e7e15 (Milad Fa) [#35305](https://github.com/nodejs/node/pull/35305)
-* [[`57564eb86d`](https://github.com/nodejs/node/commit/57564eb86d)] - **deps**: V8: cherry-pick 71736859756b2bd0444bdb0a87a (Daniel Bevenius) [#35205](https://github.com/nodejs/node/pull/35205)
-* [[`481cced20e`](https://github.com/nodejs/node/commit/481cced20e)] - **deps**: update brotli to v1.0.9 (Anna Henningsen) [#34937](https://github.com/nodejs/node/pull/34937)
-* [[`f6c0b270e0`](https://github.com/nodejs/node/commit/f6c0b270e0)] - **deps**: add openssl support for arm64 (Evan Lucas) [#34238](https://github.com/nodejs/node/pull/34238)
-* [[`9b53b4ddf2`](https://github.com/nodejs/node/commit/9b53b4ddf2)] - **deps**: upgrade to libuv 1.39.0 (Colin Ihrig) [#34915](https://github.com/nodejs/node/pull/34915)
-* [[`f87b6c0f7c`](https://github.com/nodejs/node/commit/f87b6c0f7c)] - **deps**: upgrade npm to 6.14.8 (Ruy Adorno) [#34834](https://github.com/nodejs/node/pull/34834)
-* [[`f710dbf1b7`](https://github.com/nodejs/node/commit/f710dbf1b7)] - **deps**: update to uvwasi 0.0.10 (Colin Ihrig) [#34623](https://github.com/nodejs/node/pull/34623)
-* [[`7ef1f6a71d`](https://github.com/nodejs/node/commit/7ef1f6a71d)] - **deps**: upgrade npm to 6.14.7 (claudiahdz) [#34468](https://github.com/nodejs/node/pull/34468)
-* [[`e9a514d13e`](https://github.com/nodejs/node/commit/e9a514d13e)] - **deps**: upgrade to libuv 1.38.1 (Colin Ihrig) [#34187](https://github.com/nodejs/node/pull/34187)
-* [[`60b697de30`](https://github.com/nodejs/node/commit/60b697de30)] - **deps**: V8: cherry-pick 7889803e82d3 (Zhao Jiazhong) [#34214](https://github.com/nodejs/node/pull/34214)
-* [[`de174cd1bc`](https://github.com/nodejs/node/commit/de174cd1bc)] - **(SEMVER-MINOR)** **dgram**: add IPv6 scope id suffix to received udp6 dgrams (Pekka Nikander) [#14500](https://github.com/nodejs/node/pull/14500)
-* [[`be6aee9f53`](https://github.com/nodejs/node/commit/be6aee9f53)] - **(SEMVER-MINOR)** **dgram**: allow typed arrays in .send() (Sarat Addepalli) [#22413](https://github.com/nodejs/node/pull/22413)
-* [[`1a8669d6ec`](https://github.com/nodejs/node/commit/1a8669d6ec)] - **(SEMVER-MINOR)** **doc**: Add maxTotalSockets option to agent constructor (rickyes) [#33617](https://github.com/nodejs/node/pull/33617)
-* [[`05da376c05`](https://github.com/nodejs/node/commit/05da376c05)] - **doc**: remove errors that were never released (Rich Trott) [#34197](https://github.com/nodejs/node/pull/34197)
-* [[`831328bdb2`](https://github.com/nodejs/node/commit/831328bdb2)] - **doc**: add note about multiple sync events and once (James M Snell) [#34220](https://github.com/nodejs/node/pull/34220)
-* [[`a9f0fc9896`](https://github.com/nodejs/node/commit/a9f0fc9896)] - **doc**: document behavior for once(ee, 'error') (James M Snell) [#34225](https://github.com/nodejs/node/pull/34225)
-* [[`ed055c010d`](https://github.com/nodejs/node/commit/ed055c010d)] - **doc**: replace http to https of link urls (sapics) [#34158](https://github.com/nodejs/node/pull/34158)
-* [[`cef9921c74`](https://github.com/nodejs/node/commit/cef9921c74)] - **doc**: specify how fs.WriteStream/ReadStreams are created (James M Snell) [#34188](https://github.com/nodejs/node/pull/34188)
-* [[`4277d952c0`](https://github.com/nodejs/node/commit/4277d952c0)] - **doc**: mark assert.CallTracker experimental (Ruben Bridgewater) [#33124](https://github.com/nodejs/node/pull/33124)
-* [[`1a7082052f`](https://github.com/nodejs/node/commit/1a7082052f)] - **(SEMVER-MINOR)** **doc**: add basic embedding example documentation (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`55dc7aaaa3`](https://github.com/nodejs/node/commit/55dc7aaaa3)] - **doc**: standardize on \_backward\_ (Rich Trott) [#35243](https://github.com/nodejs/node/pull/35243)
-* [[`746517aad5`](https://github.com/nodejs/node/commit/746517aad5)] - **doc**: revise stability section of values doc (Rich Trott) [#35242](https://github.com/nodejs/node/pull/35242)
-* [[`1018e520d6`](https://github.com/nodejs/node/commit/1018e520d6)] - **doc**: remove excessive formatting in dgram.md (Rich Trott) [#35234](https://github.com/nodejs/node/pull/35234)
-* [[`e026ce9b82`](https://github.com/nodejs/node/commit/e026ce9b82)] - **doc**: sort repl references in ASCII order (Rich Trott) [#35230](https://github.com/nodejs/node/pull/35230)
-* [[`6669effc4d`](https://github.com/nodejs/node/commit/6669effc4d)] - **doc**: clarify use of NAPI\_EXPERIMENTAL (Michael Dawson) [#35195](https://github.com/nodejs/node/pull/35195)
-* [[`89636e3257`](https://github.com/nodejs/node/commit/89636e3257)] - **doc**: update attributes used by n-api samples (#35220) (Gerhard Stoebich)
-* [[`e21d1cd58f`](https://github.com/nodejs/node/commit/e21d1cd58f)] - **doc**: add issue labels sections to release guide (Michaël Zasso) [#35224](https://github.com/nodejs/node/pull/35224)
-* [[`f050ecc3b1`](https://github.com/nodejs/node/commit/f050ecc3b1)] - **doc**: fix small grammatical issues in timers.md (Turner Jabbour) [#35203](https://github.com/nodejs/node/pull/35203)
-* [[`d81db1dcb9`](https://github.com/nodejs/node/commit/d81db1dcb9)] - **doc**: add technical values document (Michael Dawson) [#35145](https://github.com/nodejs/node/pull/35145)
-* [[`ee1bcdbe0d`](https://github.com/nodejs/node/commit/ee1bcdbe0d)] - **doc**: remove "end user" (Rich Trott) [#35200](https://github.com/nodejs/node/pull/35200)
-* [[`3ffaf66886`](https://github.com/nodejs/node/commit/3ffaf66886)] - **doc**: replace "you should do X" with "do X" (Rich Trott) [#35194](https://github.com/nodejs/node/pull/35194)
-* [[`c606ed761c`](https://github.com/nodejs/node/commit/c606ed761c)] - **doc**: fix missing word in dgram.md (Tom Atkinson) [#35231](https://github.com/nodejs/node/pull/35231)
-* [[`3094ace6b0`](https://github.com/nodejs/node/commit/3094ace6b0)] - **doc**: fix deprecation documentation inconsistencies (Antoine du HAMEL) [#35082](https://github.com/nodejs/node/pull/35082)
-* [[`2b86032728`](https://github.com/nodejs/node/commit/2b86032728)] - **doc**: fix broken link in crypto.md (Rich Trott) [#35181](https://github.com/nodejs/node/pull/35181)
-* [[`4af4a809c2`](https://github.com/nodejs/node/commit/4af4a809c2)] - **doc**: remove problematic auto-linking of curl man pages (Rich Trott) [#35174](https://github.com/nodejs/node/pull/35174)
-* [[`d94dac467b`](https://github.com/nodejs/node/commit/d94dac467b)] - **doc**: update process.release (schamberg97) [#35167](https://github.com/nodejs/node/pull/35167)
-* [[`52eba5b542`](https://github.com/nodejs/node/commit/52eba5b542)] - **doc**: add missing copyFile change history (Shelley Vohr) [#35056](https://github.com/nodejs/node/pull/35056)
-* [[`799fad73e9`](https://github.com/nodejs/node/commit/799fad73e9)] - **doc**: perform cleanup on security-release-process.md (Rich Trott) [#35154](https://github.com/nodejs/node/pull/35154)
-* [[`62436e6bab`](https://github.com/nodejs/node/commit/62436e6bab)] - **doc**: fix minor punctuation issue in path.md (Amila Welihinda) [#35127](https://github.com/nodejs/node/pull/35127)
-* [[`23dcfe52ac`](https://github.com/nodejs/node/commit/23dcfe52ac)] - **doc**: fix left nav color contrast (Rich Trott) [#35141](https://github.com/nodejs/node/pull/35141)
-* [[`745987e9f5`](https://github.com/nodejs/node/commit/745987e9f5)] - **doc**: update contact info for Ash Cripps (Ash Cripps) [#35139](https://github.com/nodejs/node/pull/35139)
-* [[`f3f72fd951`](https://github.com/nodejs/node/commit/f3f72fd951)] - **doc**: update my email address (Michael Dawson) [#35121](https://github.com/nodejs/node/pull/35121)
-* [[`0f9908beef`](https://github.com/nodejs/node/commit/0f9908beef)] - **doc**: add missing changes entry for breakEvalOnSigint REPL option (Anna Henningsen) [#35143](https://github.com/nodejs/node/pull/35143)
-* [[`f0b9866a93`](https://github.com/nodejs/node/commit/f0b9866a93)] - **doc**: update security process (Michael Dawson) [#35107](https://github.com/nodejs/node/pull/35107)
-* [[`255d47a6b1`](https://github.com/nodejs/node/commit/255d47a6b1)] - **doc**: fix broken link in perf\_hooks.md (Rich Trott) [#35113](https://github.com/nodejs/node/pull/35113)
-* [[`1e3982047d`](https://github.com/nodejs/node/commit/1e3982047d)] - **doc**: fix broken link in http2.md (Rich Trott) [#35112](https://github.com/nodejs/node/pull/35112)
-* [[`ec5a0ada51`](https://github.com/nodejs/node/commit/ec5a0ada51)] - **doc**: fix broken link in fs.md (Rich Trott) [#35111](https://github.com/nodejs/node/pull/35111)
-* [[`55b8caa958`](https://github.com/nodejs/node/commit/55b8caa958)] - **doc**: fix broken links in deprecations.md (Rich Trott) [#35109](https://github.com/nodejs/node/pull/35109)
-* [[`3954b8f12d`](https://github.com/nodejs/node/commit/3954b8f12d)] - **doc**: add note about path.basename on Windows (Tobias Nießen) [#35065](https://github.com/nodejs/node/pull/35065)
-* [[`bf39354cbc`](https://github.com/nodejs/node/commit/bf39354cbc)] - **doc**: add link to safe integer definition (Tobias Nießen) [#35049](https://github.com/nodejs/node/pull/35049)
-* [[`8ed4ab5ac4`](https://github.com/nodejs/node/commit/8ed4ab5ac4)] - **doc**: format exponents better (Tobias Nießen) [#35050](https://github.com/nodejs/node/pull/35050)
-* [[`b117467a77`](https://github.com/nodejs/node/commit/b117467a77)] - **doc**: improve link-local text in dgram.md (Rich Trott) [#34868](https://github.com/nodejs/node/pull/34868)
-* [[`14d4bfa7c8`](https://github.com/nodejs/node/commit/14d4bfa7c8)] - **doc**: use \_Static method\_ instead of \_Class Method\_ (Rich Trott) [#34659](https://github.com/nodejs/node/pull/34659)
-* [[`d05f615896`](https://github.com/nodejs/node/commit/d05f615896)] - **doc**: tidy some addons.md text (Rich Trott) [#34654](https://github.com/nodejs/node/pull/34654)
-* [[`5846befacb`](https://github.com/nodejs/node/commit/5846befacb)] - **doc**: use \_Class Method\_ in async\_hooks.md (Rich Trott) [#34626](https://github.com/nodejs/node/pull/34626)
-* [[`2302dff635`](https://github.com/nodejs/node/commit/2302dff635)] - **doc**: fix typo in cli.md for report-dir (Ash Cripps) [#33725](https://github.com/nodejs/node/pull/33725)
-* [[`65b7bf40b8`](https://github.com/nodejs/node/commit/65b7bf40b8)] - **doc**: restore color for visited links (Rich Trott) [#35108](https://github.com/nodejs/node/pull/35108)
-* [[`ef8d3731eb`](https://github.com/nodejs/node/commit/ef8d3731eb)] - **doc**: change stablility-2 color for accessibility (Rich Trott) [#35061](https://github.com/nodejs/node/pull/35061)
-* [[`7c947b26e8`](https://github.com/nodejs/node/commit/7c947b26e8)] - **doc**: add deprecated badge to legacy URL methods (Antoine du HAMEL) [#34931](https://github.com/nodejs/node/pull/34931)
-* [[`fb1a1339de`](https://github.com/nodejs/node/commit/fb1a1339de)] - **doc**: spruce up user journey to local docs browsing (Derek Lewis) [#34986](https://github.com/nodejs/node/pull/34986)
-* [[`08b56130db`](https://github.com/nodejs/node/commit/08b56130db)] - **doc**: update syntax highlighting color for accessibility (Rich Trott) [#35063](https://github.com/nodejs/node/pull/35063)
-* [[`1ce26fe50c`](https://github.com/nodejs/node/commit/1ce26fe50c)] - **doc**: remove style for empty links (Antoine du HAMEL) [#35034](https://github.com/nodejs/node/pull/35034)
-* [[`3c984115a0`](https://github.com/nodejs/node/commit/3c984115a0)] - **doc**: fix certificate display in tls doc (Rich Trott) [#35032](https://github.com/nodejs/node/pull/35032)
-* [[`d7989bd1d7`](https://github.com/nodejs/node/commit/d7989bd1d7)] - **doc**: use consistent header typography (Rich Trott) [#35030](https://github.com/nodejs/node/pull/35030)
-* [[`80fa1f5722`](https://github.com/nodejs/node/commit/80fa1f5722)] - **doc**: fix malformed hashes in assert.md (Rich Trott) [#35028](https://github.com/nodejs/node/pull/35028)
-* [[`2529ba261b`](https://github.com/nodejs/node/commit/2529ba261b)] - **doc**: change color contrast for accessibility (Rich Trott) [#35047](https://github.com/nodejs/node/pull/35047)
-* [[`8cc7a730a5`](https://github.com/nodejs/node/commit/8cc7a730a5)] - **doc**: revise commit-queue.md (Rich Trott) [#35006](https://github.com/nodejs/node/pull/35006)
-* [[`e7c74ebee2`](https://github.com/nodejs/node/commit/e7c74ebee2)] - **doc**: change effected to affected (Turner Jabbour) [#34989](https://github.com/nodejs/node/pull/34989)
-* [[`c68c6cd485`](https://github.com/nodejs/node/commit/c68c6cd485)] - **doc**: drop the --production flag for installing windows-build-tools (DeeDeeG) [#34979](https://github.com/nodejs/node/pull/34979)
-* [[`4d28435104`](https://github.com/nodejs/node/commit/4d28435104)] - **doc**: fix broken link to response.writableFinished in deprecations doc (Rich Trott) [#34983](https://github.com/nodejs/node/pull/34983)
-* [[`23389a082f`](https://github.com/nodejs/node/commit/23389a082f)] - **doc**: fix broken link to response.finished in deprecations doc (Rich Trott) [#34982](https://github.com/nodejs/node/pull/34982)
-* [[`4e2415fc6a`](https://github.com/nodejs/node/commit/4e2415fc6a)] - **doc**: fix broken link to writableEnded in deprecations doc (Rich Trott) [#34984](https://github.com/nodejs/node/pull/34984)
-* [[`b575e6341c`](https://github.com/nodejs/node/commit/b575e6341c)] - **doc**: fix typos in buffer doc (Robert Williams) [#34981](https://github.com/nodejs/node/pull/34981)
-* [[`0695e243de`](https://github.com/nodejs/node/commit/0695e243de)] - **doc**: make minor improvements to query string sentence in http2.md (Rich Trott) [#34929](https://github.com/nodejs/node/pull/34929)
-* [[`a5b4526f5d`](https://github.com/nodejs/node/commit/a5b4526f5d)] - **doc**: simplify "make use of" to "use" (Rich Trott) [#34861](https://github.com/nodejs/node/pull/34861)
-* [[`1e33bfcc6a`](https://github.com/nodejs/node/commit/1e33bfcc6a)] - **doc**: make minor fixes to maintaining-openssl.md (Rich Trott) [#34926](https://github.com/nodejs/node/pull/34926)
-* [[`533d00d05d`](https://github.com/nodejs/node/commit/533d00d05d)] - **doc**: fix CHANGELOG.md parsing issue (Juan José Arboleda) [#34923](https://github.com/nodejs/node/pull/34923)
-* [[`1b27f098bd`](https://github.com/nodejs/node/commit/1b27f098bd)] - **doc**: provide more guidance about process.version (Rich Trott) [#34909](https://github.com/nodejs/node/pull/34909)
-* [[`f50fec605d`](https://github.com/nodejs/node/commit/f50fec605d)] - **doc**: use consistent typography for node-addon-api (Rich Trott) [#34910](https://github.com/nodejs/node/pull/34910)
-* [[`222fcb1e66`](https://github.com/nodejs/node/commit/222fcb1e66)] - **doc**: use "previous"/"preceding" instead of "above" as modifier (Rich Trott) [#34877](https://github.com/nodejs/node/pull/34877)
-* [[`961844d25b`](https://github.com/nodejs/node/commit/961844d25b)] - **doc**: improve fs doc intro (James M Snell) [#34843](https://github.com/nodejs/node/pull/34843)
-* [[`26b060f4cd`](https://github.com/nodejs/node/commit/26b060f4cd)] - **doc**: indicate the format of process.version (Danny Guo) [#34872](https://github.com/nodejs/node/pull/34872)
-* [[`da150f4e1e`](https://github.com/nodejs/node/commit/da150f4e1e)] - **doc**: fix ESM/CJS wrapper example (Maksim Sinik) [#34853](https://github.com/nodejs/node/pull/34853)
-* [[`3ea7e03ae4`](https://github.com/nodejs/node/commit/3ea7e03ae4)] - **doc**: adopt Microsoft Style Guide officially (Rich Trott) [#34821](https://github.com/nodejs/node/pull/34821)
-* [[`5f09f45d1f`](https://github.com/nodejs/node/commit/5f09f45d1f)] - **doc**: use 'console' info string for console output (Rich Trott) [#34837](https://github.com/nodejs/node/pull/34837)
-* [[`9d52480396`](https://github.com/nodejs/node/commit/9d52480396)] - **doc**: move addaleax to TSC emeritus (Anna Henningsen) [#34809](https://github.com/nodejs/node/pull/34809)
-* [[`6d9e6f6186`](https://github.com/nodejs/node/commit/6d9e6f6186)] - **doc**: remove space above version picker (Justice Almanzar) [#34768](https://github.com/nodejs/node/pull/34768)
-* [[`c53c34c045`](https://github.com/nodejs/node/commit/c53c34c045)] - **doc**: reorder deprecated tls docs (Jerome T.K. Covington) [#34687](https://github.com/nodejs/node/pull/34687)
-* [[`edda492a94`](https://github.com/nodejs/node/commit/edda492a94)] - **doc**: fix file name to main.mjs and not main.js in esm.md (Frank Lemanschik) [#34786](https://github.com/nodejs/node/pull/34786)
-* [[`3abcc74882`](https://github.com/nodejs/node/commit/3abcc74882)] - **doc**: improve async\_hooks snippets (Andrey Pechkurov) [#34829](https://github.com/nodejs/node/pull/34829)
-* [[`fd4f561ce4`](https://github.com/nodejs/node/commit/fd4f561ce4)] - **doc**: fix some typos and grammar mistakes (Hilla Shahrabani) [#34800](https://github.com/nodejs/node/pull/34800)
-* [[`7a983f5f1d`](https://github.com/nodejs/node/commit/7a983f5f1d)] - **doc**: remove "is recommended from crypto legacy API text (Rich Trott) [#34697](https://github.com/nodejs/node/pull/34697)
-* [[`c7fc16e10a`](https://github.com/nodejs/node/commit/c7fc16e10a)] - **doc**: fix broken links in commit-queue.md (Luigi Pinca) [#34789](https://github.com/nodejs/node/pull/34789)
-* [[`09687b85f7`](https://github.com/nodejs/node/commit/09687b85f7)] - **doc**: avoid \_may\_ in collaborator guide (Rich Trott) [#34749](https://github.com/nodejs/node/pull/34749)
-* [[`f295869ba3`](https://github.com/nodejs/node/commit/f295869ba3)] - **doc**: use sentence-casing for headers in collaborator guide (Rich Trott) [#34713](https://github.com/nodejs/node/pull/34713)
-* [[`94039b75d3`](https://github.com/nodejs/node/commit/94039b75d3)] - **doc**: edit (general) collaborator guide (Rich Trott) [#34712](https://github.com/nodejs/node/pull/34712)
-* [[`653d88ac13`](https://github.com/nodejs/node/commit/653d88ac13)] - **doc**: reduce repetitiveness on Consensus Seeking (Mary Marchini) [#34702](https://github.com/nodejs/node/pull/34702)
-* [[`b28a6a57c4`](https://github.com/nodejs/node/commit/b28a6a57c4)] - **doc**: remove typo in crypto.md (Rich Trott) [#34698](https://github.com/nodejs/node/pull/34698)
-* [[`c189832647`](https://github.com/nodejs/node/commit/c189832647)] - **doc**: n-api environment life cycle APIs are stable (Jim Schlight) [#34641](https://github.com/nodejs/node/pull/34641)
-* [[`898947b5b1`](https://github.com/nodejs/node/commit/898947b5b1)] - **doc**: add padding in the sidebar column (Antoine du HAMEL) [#34665](https://github.com/nodejs/node/pull/34665)
-* [[`75ea463c25`](https://github.com/nodejs/node/commit/75ea463c25)] - **doc**: use semantically appropriate tag for lines (Antoine du HAMEL) [#34660](https://github.com/nodejs/node/pull/34660)
-* [[`0da5ac805c`](https://github.com/nodejs/node/commit/0da5ac805c)] - **doc**: add HPE\_UNEXPECTED\_CONTENT\_LENGTH error description (Nikolay Krashnikov) [#34596](https://github.com/nodejs/node/pull/34596)
-* [[`75ed2f6e2e`](https://github.com/nodejs/node/commit/75ed2f6e2e)] - **doc**: update http server response 'close' event (Renato Mariscal) [#34472](https://github.com/nodejs/node/pull/34472)
-* [[`0ba9052b57`](https://github.com/nodejs/node/commit/0ba9052b57)] - **doc**: add writable and readable options to Duplex docs (Priyank Singh) [#34383](https://github.com/nodejs/node/pull/34383)
-* [[`d0bf0f9c00`](https://github.com/nodejs/node/commit/d0bf0f9c00)] - **doc**: harden policy around objections (Mary Marchini) [#34639](https://github.com/nodejs/node/pull/34639)
-* [[`e9a8f0c127`](https://github.com/nodejs/node/commit/e9a8f0c127)] - **doc**: add Ricky Zhou to collaborators (rickyes) [#34676](https://github.com/nodejs/node/pull/34676)
-* [[`fc612d5635`](https://github.com/nodejs/node/commit/fc612d5635)] - **doc**: edit process.title note for brevity and clarity (Rich Trott) [#34627](https://github.com/nodejs/node/pull/34627)
-* [[`3dda55aedf`](https://github.com/nodejs/node/commit/3dda55aedf)] - **doc**: update fs.watch() availability for IBM i (iandrc) [#34611](https://github.com/nodejs/node/pull/34611)
-* [[`dc6e7f8584`](https://github.com/nodejs/node/commit/dc6e7f8584)] - **doc**: fix typo in path.md (aetheryx) [#34550](https://github.com/nodejs/node/pull/34550)
-* [[`260914c432`](https://github.com/nodejs/node/commit/260914c432)] - **doc**: add release key for Ruy Adorno (Ruy Adorno) [#34628](https://github.com/nodejs/node/pull/34628)
-* [[`e67bd9e050`](https://github.com/nodejs/node/commit/e67bd9e050)] - **doc**: clarify process.title inconsistencies (Corey Butler) [#34557](https://github.com/nodejs/node/pull/34557)
-* [[`c56a29178b`](https://github.com/nodejs/node/commit/c56a29178b)] - **doc**: document the connection event for HTTP2 & TLS servers (Tim Perry) [#34531](https://github.com/nodejs/node/pull/34531)
-* [[`059db0591c`](https://github.com/nodejs/node/commit/059db0591c)] - **doc**: mention null special-case for `napi\_typeof` (Renée Kooi) [#34577](https://github.com/nodejs/node/pull/34577)
-* [[`39f90346f8`](https://github.com/nodejs/node/commit/39f90346f8)] - **doc**: add DerekNonGeneric to collaborators (Derek Lewis) [#34602](https://github.com/nodejs/node/pull/34602)
-* [[`65a0ddbfc3`](https://github.com/nodejs/node/commit/65a0ddbfc3)] - **doc**: use consistent spelling for "falsy" (Rich Trott) [#34545](https://github.com/nodejs/node/pull/34545)
-* [[`261fd11d4b`](https://github.com/nodejs/node/commit/261fd11d4b)] - **doc**: simplify and clarify console.assert() documentation (Rich Trott) [#34544](https://github.com/nodejs/node/pull/34544)
-* [[`b4b2057fb6`](https://github.com/nodejs/node/commit/b4b2057fb6)] - **doc**: use consistent capitalization for addons (Rich Trott) [#34536](https://github.com/nodejs/node/pull/34536)
-* [[`2410a0f7cb`](https://github.com/nodejs/node/commit/2410a0f7cb)] - **doc**: add mmarchini pronouns (Mary Marchini) [#34586](https://github.com/nodejs/node/pull/34586)
-* [[`de03d635d4`](https://github.com/nodejs/node/commit/de03d635d4)] - **doc**: update mmarchini contact info (Mary Marchini) [#34586](https://github.com/nodejs/node/pull/34586)
-* [[`873e84366c`](https://github.com/nodejs/node/commit/873e84366c)] - **doc**: update .mailmap for mmarchini (Mary Marchini) [#34586](https://github.com/nodejs/node/pull/34586)
-* [[`f350b512e7`](https://github.com/nodejs/node/commit/f350b512e7)] - **doc**: use sentence-case for headers in SECURITY.md (Rich Trott) [#34525](https://github.com/nodejs/node/pull/34525)
-* [[`057613c464`](https://github.com/nodejs/node/commit/057613c464)] - ***Revert*** "**doc**: move ronkorving to emeritus" (Rich Trott) [#34507](https://github.com/nodejs/node/pull/34507)
-* [[`9c725919fc`](https://github.com/nodejs/node/commit/9c725919fc)] - **doc**: use sentence-case for GOVERNANCE.md headers (Rich Trott) [#34503](https://github.com/nodejs/node/pull/34503)
-* [[`c95964afd6`](https://github.com/nodejs/node/commit/c95964afd6)] - **doc**: revise onboarding-extras (Rich Trott) [#34496](https://github.com/nodejs/node/pull/34496)
-* [[`3db13a8043`](https://github.com/nodejs/node/commit/3db13a8043)] - **doc**: remove breaking-change-helper from onboarding-extras (Rich Trott) [#34497](https://github.com/nodejs/node/pull/34497)
-* [[`cef1284a22`](https://github.com/nodejs/node/commit/cef1284a22)] - **doc**: add Triagers section to table of contents in GOVERNANCE.md (Rich Trott) [#34504](https://github.com/nodejs/node/pull/34504)
-* [[`8c0a781ee0`](https://github.com/nodejs/node/commit/8c0a781ee0)] - **doc**: onboarding process extras (Gireesh Punathil) [#34455](https://github.com/nodejs/node/pull/34455)
-* [[`b37b3f017f`](https://github.com/nodejs/node/commit/b37b3f017f)] - **doc**: mention triage in GOVERNANCE.md (Gireesh Punathil) [#34426](https://github.com/nodejs/node/pull/34426)
-* [[`dfdedfd67a`](https://github.com/nodejs/node/commit/dfdedfd67a)] - **doc**: move thefourtheye to emeritus (Rich Trott) [#34471](https://github.com/nodejs/node/pull/34471)
-* [[`56d5ba852f`](https://github.com/nodejs/node/commit/56d5ba852f)] - **doc**: move ronkorving to emeritus (Rich Trott) [#34471](https://github.com/nodejs/node/pull/34471)
-* [[`f70cbc63b8`](https://github.com/nodejs/node/commit/f70cbc63b8)] - **doc**: match link text in index to doc headline (Rich Trott) [#34449](https://github.com/nodejs/node/pull/34449)
-* [[`437b092eed`](https://github.com/nodejs/node/commit/437b092eed)] - **doc**: add AshCripps to collaborators (Ash Cripps) [#34494](https://github.com/nodejs/node/pull/34494)
-* [[`c91e31ded2`](https://github.com/nodejs/node/commit/c91e31ded2)] - **doc**: add author-ready label ref to onboarding doc (Ruy Adorno) [#34381](https://github.com/nodejs/node/pull/34381)
-* [[`319d570a47`](https://github.com/nodejs/node/commit/319d570a47)] - **doc**: add HarshithaKP to collaborators (Harshitha K P) [#34417](https://github.com/nodejs/node/pull/34417)
-* [[`ae60f50a69`](https://github.com/nodejs/node/commit/ae60f50a69)] - **doc**: add rexagod to collaborators (Pranshu Srivastava) [#34457](https://github.com/nodejs/node/pull/34457)
-* [[`8ee83a9d58`](https://github.com/nodejs/node/commit/8ee83a9d58)] - **doc**: add statement of purpose to documentation style guide (Rich Trott) [#34424](https://github.com/nodejs/node/pull/34424)
-* [[`39dea8f70d`](https://github.com/nodejs/node/commit/39dea8f70d)] - **doc**: add release key for Richard Lau (Richard Lau) [#34397](https://github.com/nodejs/node/pull/34397)
-* [[`e15dc5f6ea`](https://github.com/nodejs/node/commit/e15dc5f6ea)] - **doc**: use correct identifier for callback argument (Rich Trott) [#34405](https://github.com/nodejs/node/pull/34405)
-* [[`88bd124d5c`](https://github.com/nodejs/node/commit/88bd124d5c)] - **doc**: add changes metadata to TLS newSession event (Tobias Nießen) [#34294](https://github.com/nodejs/node/pull/34294)
-* [[`0f050d4597`](https://github.com/nodejs/node/commit/0f050d4597)] - **doc**: introduce a triager role (Gireesh Punathil) [#34295](https://github.com/nodejs/node/pull/34295)
-* [[`857ba90138`](https://github.com/nodejs/node/commit/857ba90138)] - **doc**: strengthen suggestion in errors.md (Rich Trott) [#34390](https://github.com/nodejs/node/pull/34390)
-* [[`7c7d3e3697`](https://github.com/nodejs/node/commit/7c7d3e3697)] - **doc**: strengthen wording about fs.access() misuse (Rich Trott) [#34352](https://github.com/nodejs/node/pull/34352)
-* [[`1d64c2c345`](https://github.com/nodejs/node/commit/1d64c2c345)] - **doc**: fix typo in assert.md (Ye-hyoung Kang) [#34316](https://github.com/nodejs/node/pull/34316)
-* [[`7be8dded52`](https://github.com/nodejs/node/commit/7be8dded52)] - **doc**: clarify conditional exports guidance (Guy Bedford) [#34306](https://github.com/nodejs/node/pull/34306)
-* [[`c1b5c89e60`](https://github.com/nodejs/node/commit/c1b5c89e60)] - **doc**: reword warnings about sockets passed to subprocesses (Rich Trott) [#34273](https://github.com/nodejs/node/pull/34273)
-* [[`a2107101be`](https://github.com/nodejs/node/commit/a2107101be)] - **doc**: add danielleadams to collaborators (Danielle Adams) [#34360](https://github.com/nodejs/node/pull/34360)
-* [[`eff1febe9e`](https://github.com/nodejs/node/commit/eff1febe9e)] - **doc**: buffer documentation improvements (James M Snell) [#34230](https://github.com/nodejs/node/pull/34230)
-* [[`ba7ba4fe14`](https://github.com/nodejs/node/commit/ba7ba4fe14)] - **doc**: improve text in fs docs about omitting callbacks (Rich Trott) [#34307](https://github.com/nodejs/node/pull/34307)
-* [[`c4f0cb65a1`](https://github.com/nodejs/node/commit/c4f0cb65a1)] - **doc**: add sxa as collaborator (Stewart X Addison) [#34338](https://github.com/nodejs/node/pull/34338)
-* [[`513ad146c8`](https://github.com/nodejs/node/commit/513ad146c8)] - **doc**: move sebdeckers to emeritus (Rich Trott) [#34298](https://github.com/nodejs/node/pull/34298)
-* [[`a04d76d2ad`](https://github.com/nodejs/node/commit/a04d76d2ad)] - **doc**: add ruyadorno to collaborators (Ruy Adorno) [#34297](https://github.com/nodejs/node/pull/34297)
-* [[`3064755d31`](https://github.com/nodejs/node/commit/3064755d31)] - **doc**: move kfarnung to collaborator emeriti list (Rich Trott) [#34258](https://github.com/nodejs/node/pull/34258)
-* [[`ea33e738fb`](https://github.com/nodejs/node/commit/ea33e738fb)] - **doc**: specify encoding in text/html examples (James M Snell) [#34222](https://github.com/nodejs/node/pull/34222)
-* [[`2615e55d93`](https://github.com/nodejs/node/commit/2615e55d93)] - **doc**: document the ready event for Http2Stream (James M Snell) [#34221](https://github.com/nodejs/node/pull/34221)
-* [[`fbb36ed5c4`](https://github.com/nodejs/node/commit/fbb36ed5c4)] - **doc**: add comment to example about 2xx status codes (James M Snell) [#34223](https://github.com/nodejs/node/pull/34223)
-* [[`f2f1537ea0`](https://github.com/nodejs/node/commit/f2f1537ea0)] - **doc**: document that whitespace is ignored in base64 decoding (James M Snell) [#34227](https://github.com/nodejs/node/pull/34227)
-* [[`0ebb30bb88`](https://github.com/nodejs/node/commit/0ebb30bb88)] - **doc**: document security issues with url.parse() (James M Snell) [#34226](https://github.com/nodejs/node/pull/34226)
-* [[`b60b6d7404`](https://github.com/nodejs/node/commit/b60b6d7404)] - **doc**: move digitalinfinity to emeritus (Rich Trott) [#34191](https://github.com/nodejs/node/pull/34191)
-* [[`e65d6fddaf`](https://github.com/nodejs/node/commit/e65d6fddaf)] - **doc**: move gibfahn to emeritus (Rich Trott) [#34190](https://github.com/nodejs/node/pull/34190)
-* [[`c62941e84c`](https://github.com/nodejs/node/commit/c62941e84c)] - **doc**: remove parenthetical \\r\\n comment in http and http2 docs (Rich Trott) [#34178](https://github.com/nodejs/node/pull/34178)
-* [[`9bb70a498d`](https://github.com/nodejs/node/commit/9bb70a498d)] - **doc**: remove stability from unreleased errors (Rich Trott) [#33764](https://github.com/nodejs/node/pull/33764)
-* [[`a7a564b418`](https://github.com/nodejs/node/commit/a7a564b418)] - **doc**: util.debuglog callback (Bradley Meck) [#33856](https://github.com/nodejs/node/pull/33856)
-* [[`089a4479a4`](https://github.com/nodejs/node/commit/089a4479a4)] - **doc**: update wording in "Two reading modes" (Julien Poissonnier) [#34119](https://github.com/nodejs/node/pull/34119)
-* [[`32ef1b3347`](https://github.com/nodejs/node/commit/32ef1b3347)] - **doc**: clarify that the ctx argument is optional (Luigi Pinca) [#34097](https://github.com/nodejs/node/pull/34097)
-* [[`8960a63312`](https://github.com/nodejs/node/commit/8960a63312)] - **doc**: add a reference to the list of OpenSSL flags. (Mateusz Krawczuk) [#34050](https://github.com/nodejs/node/pull/34050)
-* [[`4ac0df9160`](https://github.com/nodejs/node/commit/4ac0df9160)] - **doc**: no longer maintain a CNA structure (Sam Roberts) [#33639](https://github.com/nodejs/node/pull/33639)
-* [[`75637e6867`](https://github.com/nodejs/node/commit/75637e6867)] - **doc**: use consistent naming in stream doc (Saleem) [#30506](https://github.com/nodejs/node/pull/30506)
-* [[`71664158fc`](https://github.com/nodejs/node/commit/71664158fc)] - **doc**: clarify how to read process.stdin (Anentropic) [#27350](https://github.com/nodejs/node/pull/27350)
-* [[`25939ccded`](https://github.com/nodejs/node/commit/25939ccded)] - **doc**: fix entry for `napi\_create\_external\_buffer` (Gabriel Schulhof) [#34125](https://github.com/nodejs/node/pull/34125)
-* [[`5f131f71e9`](https://github.com/nodejs/node/commit/5f131f71e9)] - **doc**: fix source link margin to sub-header mark (Rodion Abdurakhimov) [#33664](https://github.com/nodejs/node/pull/33664)
-* [[`f12c6f406a`](https://github.com/nodejs/node/commit/f12c6f406a)] - **doc**: improve async\_hooks asynchronous context example (Denys Otrishko) [#33730](https://github.com/nodejs/node/pull/33730)
-* [[`8fb265d03c`](https://github.com/nodejs/node/commit/8fb265d03c)] - **doc**: clarify esm conditional exports prose (Derek Lewis) [#33886](https://github.com/nodejs/node/pull/33886)
-* [[`49383c8a25`](https://github.com/nodejs/node/commit/49383c8a25)] - **doc**: improve triaging text in issues.md (Rich Trott) [#34164](https://github.com/nodejs/node/pull/34164)
-* [[`a9302b50c9`](https://github.com/nodejs/node/commit/a9302b50c9)] - **doc**: simply dns.ADDRCONFIG language (Rich Trott) [#34155](https://github.com/nodejs/node/pull/34155)
-* [[`1d25e70392`](https://github.com/nodejs/node/commit/1d25e70392)] - **doc**: remove "considered" in errors.md (Rich Trott) [#34152](https://github.com/nodejs/node/pull/34152)
-* [[`f6dff0a57e`](https://github.com/nodejs/node/commit/f6dff0a57e)] - **doc**: simplify and clarify ReferenceError material in errors.md (Rich Trott) [#34151](https://github.com/nodejs/node/pull/34151)
-* [[`e2fff1b1b0`](https://github.com/nodejs/node/commit/e2fff1b1b0)] - **doc**: add http highlight grammar (Derek Lewis) [#33785](https://github.com/nodejs/node/pull/33785)
-* [[`19bfc012d1`](https://github.com/nodejs/node/commit/19bfc012d1)] - **doc**: move sam-github to TSC Emeriti (Sam Roberts) [#34095](https://github.com/nodejs/node/pull/34095)
-* [[`c78ef2d35c`](https://github.com/nodejs/node/commit/c78ef2d35c)] - **doc**: change "considered experimental" to "experimental" in n-api.md (Rich Trott) [#34129](https://github.com/nodejs/node/pull/34129)
-* [[`3d5f7674e7`](https://github.com/nodejs/node/commit/3d5f7674e7)] - **doc**: changed "considered experimental" to "experimental" in cli.md (Rich Trott) [#34128](https://github.com/nodejs/node/pull/34128)
-* [[`6c739aac55`](https://github.com/nodejs/node/commit/6c739aac55)] - **doc**: improve text in issues.md (falguniraina) [#33973](https://github.com/nodejs/node/pull/33973)
-* [[`0672384be9`](https://github.com/nodejs/node/commit/0672384be9)] - **doc**: change "currently not considered public" to "not supported" (Rich Trott) [#34114](https://github.com/nodejs/node/pull/34114)
-* [[`64e182553e`](https://github.com/nodejs/node/commit/64e182553e)] - **doc**: clarify that APIs are no longer experimental (Rich Trott) [#34113](https://github.com/nodejs/node/pull/34113)
-* [[`e4ac393383`](https://github.com/nodejs/node/commit/e4ac393383)] - **doc**: clarify O\_EXCL text in fs.md (Rich Trott) [#34096](https://github.com/nodejs/node/pull/34096)
-* [[`d67cb7ed0f`](https://github.com/nodejs/node/commit/d67cb7ed0f)] - **doc**: clarify ambiguous rdev description (Rich Trott) [#34094](https://github.com/nodejs/node/pull/34094)
-* [[`c6ea3d6616`](https://github.com/nodejs/node/commit/c6ea3d6616)] - **doc**: make minor improvements to paragraph in child\_process.md (Rich Trott) [#34063](https://github.com/nodejs/node/pull/34063)
-* [[`21b0132eec`](https://github.com/nodejs/node/commit/21b0132eec)] - **doc**: improve paragraph in esm.md (Rich Trott) [#34064](https://github.com/nodejs/node/pull/34064)
-* [[`66cd7bf69d`](https://github.com/nodejs/node/commit/66cd7bf69d)] - **doc**: clarify require/import mutual exclusivity (Guy Bedford) [#33832](https://github.com/nodejs/node/pull/33832)
-* [[`5ba0ba4b69`](https://github.com/nodejs/node/commit/5ba0ba4b69)] - **doc**: add dynamic source code links (Alec Davidson) [#33996](https://github.com/nodejs/node/pull/33996)
-* [[`51cdd10ea5`](https://github.com/nodejs/node/commit/51cdd10ea5)] - **doc**: mention errors thrown by methods called on an unbound dgram.Socket (Mateusz Krawczuk) [#33983](https://github.com/nodejs/node/pull/33983)
-* [[`6d22ae3630`](https://github.com/nodejs/node/commit/6d22ae3630)] - **doc**: document n-api callback scope usage (Gabriel Schulhof) [#33915](https://github.com/nodejs/node/pull/33915)
-* [[`e4854de18c`](https://github.com/nodejs/node/commit/e4854de18c)] - **doc**: standardize constructor doc header layout (Rich Trott) [#33781](https://github.com/nodejs/node/pull/33781)
-* [[`79c4c73f4c`](https://github.com/nodejs/node/commit/79c4c73f4c)] - **doc**: split process.umask() entry into two (Rich Trott) [#32711](https://github.com/nodejs/node/pull/32711)
-* [[`0a927216cf`](https://github.com/nodejs/node/commit/0a927216cf)] - **(SEMVER-MAJOR)** **doc**: deprecate process.umask() with no arguments (Colin Ihrig) [#32499](https://github.com/nodejs/node/pull/32499)
-* [[`05dae0231b`](https://github.com/nodejs/node/commit/05dae0231b)] - **doc,lib**: remove unused error code (Rich Trott) [#34792](https://github.com/nodejs/node/pull/34792)
-* [[`e8ddaa3f0e`](https://github.com/nodejs/node/commit/e8ddaa3f0e)] - **doc,n-api**: add link to n-api tutorial website (Jim Schlight) [#34870](https://github.com/nodejs/node/pull/34870)
-* [[`b47172d2ed`](https://github.com/nodejs/node/commit/b47172d2ed)] - **doc,test**: specify and test CLI option precedence rules (Anna Henningsen) [#35106](https://github.com/nodejs/node/pull/35106)
-* [[`3975dd3525`](https://github.com/nodejs/node/commit/3975dd3525)] - **doc,tools**: remove malfunctioning Linux manpage linker (Rich Trott) [#34985](https://github.com/nodejs/node/pull/34985)
-* [[`f57104bb1a`](https://github.com/nodejs/node/commit/f57104bb1a)] - **doc,tools**: annotate broken links in actions workflow (Richard Lau) [#34810](https://github.com/nodejs/node/pull/34810)
-* [[`7b29c91944`](https://github.com/nodejs/node/commit/7b29c91944)] - **doc,tools**: syntax highlight api docs at compile-time (Francisco Ryan Tolmasky I) [#34148](https://github.com/nodejs/node/pull/34148)
-* [[`7a8f59f1d6`](https://github.com/nodejs/node/commit/7a8f59f1d6)] - **(SEMVER-MINOR)** **embedding**: make Stop() stop Workers (Anna Henningsen) [#32531](https://github.com/nodejs/node/pull/32531)
-* [[`ff0a0366f7`](https://github.com/nodejs/node/commit/ff0a0366f7)] - **(SEMVER-MINOR)** **embedding**: provide hook for custom process.exit() behaviour (Anna Henningsen) [#32531](https://github.com/nodejs/node/pull/32531)
-* [[`5c968a0f92`](https://github.com/nodejs/node/commit/5c968a0f92)] - **errors**: use `ErrorPrototypeToString` from `primordials` object (ExE Boss) [#34891](https://github.com/nodejs/node/pull/34891)
-* [[`bf7b796491`](https://github.com/nodejs/node/commit/bf7b796491)] - **esm**: better package.json parser errors (Guy Bedford) [#35117](https://github.com/nodejs/node/pull/35117)
-* [[`9159649395`](https://github.com/nodejs/node/commit/9159649395)] - **esm**: shorten ERR\_UNSUPPORTED\_ESM\_URL\_SCHEME message (Rich Trott) [#34836](https://github.com/nodejs/node/pull/34836)
-* [[`551be2aeb9`](https://github.com/nodejs/node/commit/551be2aeb9)] - **esm**: improve error message of ERR\_UNSUPPORTED\_ESM\_URL\_SCHEME (Denys Otrishko) [#34795](https://github.com/nodejs/node/pull/34795)
-* [[`5c3c8b3029`](https://github.com/nodejs/node/commit/5c3c8b3029)] - **events**: variable originalListener is useless (fuxingZhang) [#33596](https://github.com/nodejs/node/pull/33596)
-* [[`ff7fbc38f1`](https://github.com/nodejs/node/commit/ff7fbc38f1)] - **events**: improve listeners() performance (Brian White) [#33863](https://github.com/nodejs/node/pull/33863)
-* [[`830574f199`](https://github.com/nodejs/node/commit/830574f199)] - **events**: improve arrayClone performance (Brian White) [#33774](https://github.com/nodejs/node/pull/33774)
-* [[`a19933f7fc`](https://github.com/nodejs/node/commit/a19933f7fc)] - **(SEMVER-MINOR)** **fs**: implement lutimes (Maël Nison) [#33399](https://github.com/nodejs/node/pull/33399)
-* [[`3d1bdc254c`](https://github.com/nodejs/node/commit/3d1bdc254c)] - **(SEMVER-MINOR)** **http**: add maxTotalSockets to agent class (rickyes) [#33617](https://github.com/nodejs/node/pull/33617)
-* [[`fb68487b8c`](https://github.com/nodejs/node/commit/fb68487b8c)] - **(SEMVER-MINOR)** **http**: return this from IncomingMessage#destroy() (Colin Ihrig) [#32789](https://github.com/nodejs/node/pull/32789)
-* [[`388d125a64`](https://github.com/nodejs/node/commit/388d125a64)] - **(SEMVER-MINOR)** **http**: expose host and protocol on ClientRequest (wenningplus) [#33803](https://github.com/nodejs/node/pull/33803)
-* [[`756ac65218`](https://github.com/nodejs/node/commit/756ac65218)] - **http**: fix crash for sync write errors during header parsing (Anna Henningsen) [#34251](https://github.com/nodejs/node/pull/34251)
-* [[`10815c4eff`](https://github.com/nodejs/node/commit/10815c4eff)] - **http**: provide keep-alive timeout response header (Robert Nagy) [#34561](https://github.com/nodejs/node/pull/34561)
-* [[`e52cc24e31`](https://github.com/nodejs/node/commit/e52cc24e31)] - **http**: don't write error to socket (Robert Nagy) [#34465](https://github.com/nodejs/node/pull/34465)
-* [[`4e07faa7cf`](https://github.com/nodejs/node/commit/4e07faa7cf)] - **http**: add note about timer unref (Robert Nagy) [#34143](https://github.com/nodejs/node/pull/34143)
-* [[`1a09b4d2ca`](https://github.com/nodejs/node/commit/1a09b4d2ca)] - **http**: fixes memory retention issue with FreeList and HTTPParser (John Leidegren) [#33190](https://github.com/nodejs/node/pull/33190)
-* [[`ec1df7b4c9`](https://github.com/nodejs/node/commit/ec1df7b4c9)] - **http**: fix incorrect headersTimeout measurement (Alex R) [#32329](https://github.com/nodejs/node/pull/32329)
-* [[`ca836344fa`](https://github.com/nodejs/node/commit/ca836344fa)] - **http**: don't throw on `Uint8Array`s for `http.ServerResponse#write` (Pranshu Srivastava) [#33155](https://github.com/nodejs/node/pull/33155)
-* [[`4079cdd5f2`](https://github.com/nodejs/node/commit/4079cdd5f2)] - **http2**: fix Http2Response.sendDate (João Lucas Lucchetta) [#34850](https://github.com/nodejs/node/pull/34850)
-* [[`7551a8be47`](https://github.com/nodejs/node/commit/7551a8be47)] - **(SEMVER-MINOR)** **http2**: return this for Http2ServerRequest#setTimeout (Pranshu Srivastava) [#33994](https://github.com/nodejs/node/pull/33994)
-* [[`4d0129aefb`](https://github.com/nodejs/node/commit/4d0129aefb)] - **(SEMVER-MINOR)** **http2**: do not modify explicity set date headers (Pranshu Srivastava) [#33160](https://github.com/nodejs/node/pull/33160)
-* [[`45d712c6f6`](https://github.com/nodejs/node/commit/45d712c6f6)] - **http2**: add maxHeaderSize option to http2 (Priyank Singh) [#33636](https://github.com/nodejs/node/pull/33636)
-* [[`4a2accb3d0`](https://github.com/nodejs/node/commit/4a2accb3d0)] - **internal**: rename error-serdes for consistency (Evan Lucas) [#33793](https://github.com/nodejs/node/pull/33793)
-* [[`9f16b7f332`](https://github.com/nodejs/node/commit/9f16b7f332)] - **lib**: improve debuglog() performance (Brian White) [#32260](https://github.com/nodejs/node/pull/32260)
-* [[`efd46e3b61`](https://github.com/nodejs/node/commit/efd46e3b61)] - **lib**: always initialize esm loader callbackMap (Shelley Vohr) [#34127](https://github.com/nodejs/node/pull/34127)
-* [[`f29ab4092f`](https://github.com/nodejs/node/commit/f29ab4092f)] - **lib**: add UNC support to url.pathToFileURL() (Matthew McEachen) [#34743](https://github.com/nodejs/node/pull/34743)
-* [[`176f8c35c5`](https://github.com/nodejs/node/commit/176f8c35c5)] - **lib**: use non-symbols in isURLInstance check (Shelley Vohr) [#34622](https://github.com/nodejs/node/pull/34622)
-* [[`633b4d5e62`](https://github.com/nodejs/node/commit/633b4d5e62)] - **lib**: absorb `path` error cases (Gireesh Punathil) [#34519](https://github.com/nodejs/node/pull/34519)
-* [[`6054e213f9`](https://github.com/nodejs/node/commit/6054e213f9)] - **lib**: simplify assignment (sapics) [#33718](https://github.com/nodejs/node/pull/33718)
-* [[`32c51c6c7d`](https://github.com/nodejs/node/commit/32c51c6c7d)] - **lib**: replace http to https of comment link urls (sapics) [#34158](https://github.com/nodejs/node/pull/34158)
-* [[`d1be44c705`](https://github.com/nodejs/node/commit/d1be44c705)] - **meta**: update module pages in CODEOWNERS (Antoine du Hamel) [#34932](https://github.com/nodejs/node/pull/34932)
-* [[`09100ce4ce`](https://github.com/nodejs/node/commit/09100ce4ce)] - **meta**: add links to OpenJSF Slack (Mary Marchini) [#35128](https://github.com/nodejs/node/pull/35128)
-* [[`c7eb462bde`](https://github.com/nodejs/node/commit/c7eb462bde)] - **meta**: update my collab entry (devsnek) [#35160](https://github.com/nodejs/node/pull/35160)
-* [[`2b3d4bd550`](https://github.com/nodejs/node/commit/2b3d4bd550)] - **meta**: remove non-existent quic from CODEOWNERS (Richard Lau) [#34947](https://github.com/nodejs/node/pull/34947)
-* [[`36c705d83b`](https://github.com/nodejs/node/commit/36c705d83b)] - **meta**: enable wasi for CODEOWNERS (gengjiawen) [#34889](https://github.com/nodejs/node/pull/34889)
-* [[`fb98e762ce`](https://github.com/nodejs/node/commit/fb98e762ce)] - **meta**: fix codeowners docs path (Mary Marchini) [#34811](https://github.com/nodejs/node/pull/34811)
-* [[`5119586c0b`](https://github.com/nodejs/node/commit/5119586c0b)] - **meta**: add TSC as owner of governance-related docs (Mary Marchini) [#34737](https://github.com/nodejs/node/pull/34737)
-* [[`6d6bd2dc3b`](https://github.com/nodejs/node/commit/6d6bd2dc3b)] - **meta**: uncomment all codeowners (Mary Marchini) [#34670](https://github.com/nodejs/node/pull/34670)
-* [[`ac0b9496e5`](https://github.com/nodejs/node/commit/ac0b9496e5)] - **meta**: enable http2 team for CODEOWNERS (Rich Trott) [#34534](https://github.com/nodejs/node/pull/34534)
-* [[`2ac653dc1a`](https://github.com/nodejs/node/commit/2ac653dc1a)] - **meta**: make issue template mobile friendly and address nits (Derek Lewis) [#34243](https://github.com/nodejs/node/pull/34243)
-* [[`6319c8f8bb`](https://github.com/nodejs/node/commit/6319c8f8bb)] - **meta**: add N-API to codeowners coverage (Michael Dawson) [#34039](https://github.com/nodejs/node/pull/34039)
-* [[`78ee480469`](https://github.com/nodejs/node/commit/78ee480469)] - **meta**: fixup CODEOWNERS so it hopefully works (James M Snell) [#34147](https://github.com/nodejs/node/pull/34147)
-* [[`ed3278d55d`](https://github.com/nodejs/node/commit/ed3278d55d)] - **module**: fix crash on multiline named cjs imports (Christoph Tavan) [#35275](https://github.com/nodejs/node/pull/35275)
-* [[`89a58f61d7`](https://github.com/nodejs/node/commit/89a58f61d7)] - **module**: use isURLInstance instead of instanceof (Antoine du HAMEL) [#34951](https://github.com/nodejs/node/pull/34951)
-* [[`fc93cc95d8`](https://github.com/nodejs/node/commit/fc93cc95d8)] - **module**: drop `-u` alias for `--conditions` (Richard Lau) [#34935](https://github.com/nodejs/node/pull/34935)
-* [[`740c95819f`](https://github.com/nodejs/node/commit/740c95819f)] - **module**: fix check for package.json at volume root (Derek Lewis) [#34595](https://github.com/nodejs/node/pull/34595)
-* [[`cecc193abc`](https://github.com/nodejs/node/commit/cecc193abc)] - **module**: share CJS/ESM resolver fns, refactoring (Guy Bedford) [#34744](https://github.com/nodejs/node/pull/34744)
-* [[`d9857fdbc2`](https://github.com/nodejs/node/commit/d9857fdbc2)] - **module**: custom --conditions flag option (Guy Bedford) [#34637](https://github.com/nodejs/node/pull/34637)
-* [[`3ad146d474`](https://github.com/nodejs/node/commit/3ad146d474)] - **module**: use cjsCache over esm injection (Guy Bedford) [#34605](https://github.com/nodejs/node/pull/34605)
-* [[`00aa935f5c`](https://github.com/nodejs/node/commit/00aa935f5c)] - **module**: self referential modules in repl or `-r` (Daniele Belardi) [#32261](https://github.com/nodejs/node/pull/32261)
-* [[`d065334d42`](https://github.com/nodejs/node/commit/d065334d42)] - **(SEMVER-MINOR)** **module**: package "imports" field (Guy Bedford) [#34117](https://github.com/nodejs/node/pull/34117)
-* [[`c9bd1a7d8a`](https://github.com/nodejs/node/commit/c9bd1a7d8a)] - **(SEMVER-MINOR)** **module**: deprecate module.parent (Antoine du HAMEL) [#32217](https://github.com/nodejs/node/pull/32217)
-* [[`b9d0f73c7c`](https://github.com/nodejs/node/commit/b9d0f73c7c)] - **(SEMVER-MINOR)** **n-api**: create N-API version 7 (Gabriel Schulhof) [#35199](https://github.com/nodejs/node/pull/35199)
-* [[`a5aa3ddacf`](https://github.com/nodejs/node/commit/a5aa3ddacf)] - **n-api**: re-implement async env cleanup hooks (Gabriel Schulhof) [#34819](https://github.com/nodejs/node/pull/34819)
-* [[`c440748779`](https://github.com/nodejs/node/commit/c440748779)] - **n-api**: fix use-after-free with napi\_remove\_async\_cleanup\_hook (Anna Henningsen) [#34662](https://github.com/nodejs/node/pull/34662)
-* [[`e7486d4df6`](https://github.com/nodejs/node/commit/e7486d4df6)] - **(SEMVER-MINOR)** **n-api**: support type-tagging objects (Gabriel Schulhof) [#28237](https://github.com/nodejs/node/pull/28237)
-* [[`a6b655614f`](https://github.com/nodejs/node/commit/a6b655614f)] - **n-api**: handle weak no-finalizer refs correctly (Gabriel Schulhof) [#34839](https://github.com/nodejs/node/pull/34839)
-* [[`02fe75026e`](https://github.com/nodejs/node/commit/02fe75026e)] - **n-api**: simplify bigint-from-word creation (Gabriel Schulhof) [#34554](https://github.com/nodejs/node/pull/34554)
-* [[`ba2e341f1d`](https://github.com/nodejs/node/commit/ba2e341f1d)] - **n-api**: run all finalizers via SetImmediate() (Gabriel Schulhof) [#34386](https://github.com/nodejs/node/pull/34386)
-* [[`2cf231678b`](https://github.com/nodejs/node/commit/2cf231678b)] - **(SEMVER-MINOR)** **n-api,src**: provide asynchronous cleanup hooks (Anna Henningsen) [#34572](https://github.com/nodejs/node/pull/34572)
-* [[`3c4abe0e91`](https://github.com/nodejs/node/commit/3c4abe0e91)] - **net**: replace usage of internal stream state with public api (Denys Otrishko) [#34885](https://github.com/nodejs/node/pull/34885)
-* [[`6b5d679c80`](https://github.com/nodejs/node/commit/6b5d679c80)] - **net**: validate custom lookup() output (Colin Ihrig) [#34813](https://github.com/nodejs/node/pull/34813)
-* [[`09056fdf38`](https://github.com/nodejs/node/commit/09056fdf38)] - **net**: don't return the stream object from onStreamRead (Robey Pointer) [#34375](https://github.com/nodejs/node/pull/34375)
-* [[`76ba129151`](https://github.com/nodejs/node/commit/76ba129151)] - **net**: allow wider regex in interface name (Stewart X Addison) [#34364](https://github.com/nodejs/node/pull/34364)
-* [[`ce5d0db34b`](https://github.com/nodejs/node/commit/ce5d0db34b)] - **net**: fix bufferSize (Robert Nagy) [#34088](https://github.com/nodejs/node/pull/34088)
-* [[`2c409a2853`](https://github.com/nodejs/node/commit/2c409a2853)] - **(SEMVER-MINOR)** **perf_hooks**: add idleTime and event loop util (Trevor Norris) [#34938](https://github.com/nodejs/node/pull/34938)
-* [[`35ff592613`](https://github.com/nodejs/node/commit/35ff592613)] - **policy**: increase tests via permutation matrix (Bradley Meck) [#34404](https://github.com/nodejs/node/pull/34404)
-* [[`0ede223fa8`](https://github.com/nodejs/node/commit/0ede223fa8)] - **policy**: add startup benchmark and make SRI lazier (Bradley Farias) [#29527](https://github.com/nodejs/node/pull/29527)
-* [[`53eae0dafd`](https://github.com/nodejs/node/commit/53eae0dafd)] - **process**: correctly parse Unicode in NODE\_OPTIONS (Bartosz Sosnowski) [#34476](https://github.com/nodejs/node/pull/34476)
-* [[`6ccacdfddb`](https://github.com/nodejs/node/commit/6ccacdfddb)] - **querystring**: manage percent character at unescape (Daijiro Wachi) [#35013](https://github.com/nodejs/node/pull/35013)
-* [[`b7be751447`](https://github.com/nodejs/node/commit/b7be751447)] - **repl**: support --loader option in builtin REPL (Michaël Zasso) [#33437](https://github.com/nodejs/node/pull/33437)
-* [[`63cd05b1d6`](https://github.com/nodejs/node/commit/63cd05b1d6)] - **src**: fix ParseEncoding (sapics) [#33957](https://github.com/nodejs/node/pull/33957)
-* [[`090f86955f`](https://github.com/nodejs/node/commit/090f86955f)] - **src**: fix minor comment typo in KeyObjectData (Daniel Bevenius) [#34167](https://github.com/nodejs/node/pull/34167)
-* [[`50b1cde872`](https://github.com/nodejs/node/commit/50b1cde872)] - **(SEMVER-MINOR)** **src**: store key data in separate class (Tobias Nießen) [#33360](https://github.com/nodejs/node/pull/33360)
-* [[`bf3aaa31d0`](https://github.com/nodejs/node/commit/bf3aaa31d0)] - **(SEMVER-MINOR)** **src**: add NativeKeyObject base class (Tobias Nießen) [#33360](https://github.com/nodejs/node/pull/33360)
-* [[`91978820fa`](https://github.com/nodejs/node/commit/91978820fa)] - **(SEMVER-MINOR)** **src**: rename internal key handles to KeyObjectHandle (Tobias Nießen) [#33360](https://github.com/nodejs/node/pull/33360)
-* [[`667d520148`](https://github.com/nodejs/node/commit/667d520148)] - **(SEMVER-MINOR)** **src**: introduce BaseObject base FunctionTemplate (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
-* [[`3e21dd91c1`](https://github.com/nodejs/node/commit/3e21dd91c1)] - **(SEMVER-MINOR)** **src**: add option to track unmanaged file descriptors (Anna Henningsen) [#34303](https://github.com/nodejs/node/pull/34303)
-* [[`0affe8622e`](https://github.com/nodejs/node/commit/0affe8622e)] - **(SEMVER-MINOR)** **src**: add public APIs to manage v8::TracingController (Anna Henningsen) [#33850](https://github.com/nodejs/node/pull/33850)
-* [[`b7e4d5fc0e`](https://github.com/nodejs/node/commit/b7e4d5fc0e)] - **src**: shutdown libuv before exit() (Anna Henningsen) [#35021](https://github.com/nodejs/node/pull/35021)
-* [[`5e28660121`](https://github.com/nodejs/node/commit/5e28660121)] - **(SEMVER-MINOR)** **src**: allow embedders to disable esm loader (Shelley Vohr) [#34060](https://github.com/nodejs/node/pull/34060)
-* [[`7e2cd728bb`](https://github.com/nodejs/node/commit/7e2cd728bb)] - **src**: add callback scope for native immediates (Anna Henningsen) [#34366](https://github.com/nodejs/node/pull/34366)
-* [[`147440510f`](https://github.com/nodejs/node/commit/147440510f)] - **src**: flush V8 interrupts from Environment dtor (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
-* [[`29620c41fb`](https://github.com/nodejs/node/commit/29620c41fb)] - **src**: use env-\>RequestInterrupt() for inspector MainThreadInterface (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
-* [[`2e4536e701`](https://github.com/nodejs/node/commit/2e4536e701)] - **src**: use env-\>RequestInterrupt() for inspector io thread start (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
-* [[`4704e586dc`](https://github.com/nodejs/node/commit/4704e586dc)] - **src**: fix cleanup hook removal for InspectorTimer (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
-* [[`4513b6a3df`](https://github.com/nodejs/node/commit/4513b6a3df)] - **src**: make `Environment::interrupt\_data\_` atomic (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
-* [[`1066341cd9`](https://github.com/nodejs/node/commit/1066341cd9)] - **src**: initialize inspector before RunBootstrapping() (Anna Henningsen) [#32672](https://github.com/nodejs/node/pull/32672)
-* [[`b8c9048a87`](https://github.com/nodejs/node/commit/b8c9048a87)] - **(SEMVER-MINOR)** **src**: shutdown platform from FreePlatform() (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`a28c990061`](https://github.com/nodejs/node/commit/a28c990061)] - **(SEMVER-MINOR)** **src**: fix what a dispose without checking (Jichan) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`2f8f76736b`](https://github.com/nodejs/node/commit/2f8f76736b)] - **(SEMVER-MINOR)** **src**: allow non-Node.js TracingControllers (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`9b84ee6480`](https://github.com/nodejs/node/commit/9b84ee6480)] - **(SEMVER-MINOR)** **src**: add ability to look up platform based on `Environment\*` (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`a770a35f61`](https://github.com/nodejs/node/commit/a770a35f61)] - **(SEMVER-MINOR)** **src**: make InitializeNodeWithArgs() official public API (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`8005e637b1`](https://github.com/nodejs/node/commit/8005e637b1)] - **(SEMVER-MINOR)** **src**: add unique\_ptr equivalent of CreatePlatform (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`4a6748d2c3`](https://github.com/nodejs/node/commit/4a6748d2c3)] - **(SEMVER-MINOR)** **src**: add LoadEnvironment() variant taking a string (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`c5aa3f4adb`](https://github.com/nodejs/node/commit/c5aa3f4adb)] - **(SEMVER-MINOR)** **src**: provide a variant of LoadEnvironment taking a callback (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`808dedc4b3`](https://github.com/nodejs/node/commit/808dedc4b3)] - **(SEMVER-MINOR)** **src**: align worker and main thread code with embedder API (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`e809a5cd6b`](https://github.com/nodejs/node/commit/e809a5cd6b)] - **(SEMVER-MINOR)** **src**: associate is\_main\_thread() with worker\_context() (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`b7350e8c6e`](https://github.com/nodejs/node/commit/b7350e8c6e)] - **(SEMVER-MINOR)** **src**: move worker\_context from Environment to IsolateData (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`9a5cec3466`](https://github.com/nodejs/node/commit/9a5cec3466)] - **(SEMVER-MINOR)** **src**: fix memory leak in CreateEnvironment when bootstrap fails (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`7d92ac7a35`](https://github.com/nodejs/node/commit/7d92ac7a35)] - **(SEMVER-MINOR)** **src**: make `FreeEnvironment()` perform all necessary cleanup (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`1d3638b189`](https://github.com/nodejs/node/commit/1d3638b189)] - **src**: use enum for refed flag on native immediates (Anna Henningsen) [#33444](https://github.com/nodejs/node/pull/33444)
-* [[`18e8687923`](https://github.com/nodejs/node/commit/18e8687923)] - **(SEMVER-MINOR)** **src**: allow preventing SetPromiseRejectCallback (Shelley Vohr) [#34387](https://github.com/nodejs/node/pull/34387)
-* [[`403deb71d5`](https://github.com/nodejs/node/commit/403deb71d5)] - **(SEMVER-MINOR)** **src**: allow setting a dir for all diagnostic output (Ash Cripps) [#33584](https://github.com/nodejs/node/pull/33584)
-* [[`19b55be03b`](https://github.com/nodejs/node/commit/19b55be03b)] - **(SEMVER-MINOR)** **src**: add equality operators for BaseObjectPtr (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
-* [[`5eb1c9cee0`](https://github.com/nodejs/node/commit/5eb1c9cee0)] - **src**: add get/set pair for env context awareness (Shelley Vohr) [#35024](https://github.com/nodejs/node/pull/35024)
-* [[`00e020b841`](https://github.com/nodejs/node/commit/00e020b841)] - **src**: disallow JS execution during exit() (Anna Henningsen) [#35020](https://github.com/nodejs/node/pull/35020)
-* [[`26a596bf29`](https://github.com/nodejs/node/commit/26a596bf29)] - **src**: fix abort on uv\_loop\_init() failure (Ben Noordhuis) [#34874](https://github.com/nodejs/node/pull/34874)
-* [[`d953fa3038`](https://github.com/nodejs/node/commit/d953fa3038)] - **src**: usage of modernize-use-equals-default (Yash Ladha) [#34807](https://github.com/nodejs/node/pull/34807)
-* [[`541fb1b001`](https://github.com/nodejs/node/commit/541fb1b001)] - **src**: prefer C++ empty() in boolean expressions (Tobias Nießen) [#34432](https://github.com/nodejs/node/pull/34432)
-* [[`1549048307`](https://github.com/nodejs/node/commit/1549048307)] - **src**: spin shutdown loop while immediates are pending (Anna Henningsen) [#34662](https://github.com/nodejs/node/pull/34662)
-* [[`dabd04d79b`](https://github.com/nodejs/node/commit/dabd04d79b)] - **src**: fix `size` underflow in CallbackQueue (Anna Henningsen) [#34662](https://github.com/nodejs/node/pull/34662)
-* [[`c0a961efc7`](https://github.com/nodejs/node/commit/c0a961efc7)] - **src**: fix unused namespace member in node\_util (Andrey Pechkurov) [#34565](https://github.com/nodejs/node/pull/34565)
-* [[`9f465009b1`](https://github.com/nodejs/node/commit/9f465009b1)] - **src**: skip weak references for memory tracking (Anna Henningsen) [#34469](https://github.com/nodejs/node/pull/34469)
-* [[`c302cae814`](https://github.com/nodejs/node/commit/c302cae814)] - **src**: remove unused variable in node\_file.cc (sapics) [#34317](https://github.com/nodejs/node/pull/34317)
-* [[`5a16a671ef`](https://github.com/nodejs/node/commit/5a16a671ef)] - **src**: avoid strcmp in SecureContext::Init (Tobias Nießen) [#34329](https://github.com/nodejs/node/pull/34329)
-* [[`007b4c1ac9`](https://github.com/nodejs/node/commit/007b4c1ac9)] - **src**: refactor CertCbDone to avoid goto statement (Tobias Nießen) [#34325](https://github.com/nodejs/node/pull/34325)
-* [[`a2141d32ed`](https://github.com/nodejs/node/commit/a2141d32ed)] - **src**: remove redundant snprintf (Anna Henningsen) [#34282](https://github.com/nodejs/node/pull/34282)
-* [[`6ddeee4b8d`](https://github.com/nodejs/node/commit/6ddeee4b8d)] - **src**: use FromMaybe instead of ToLocal in GetCert (Daniel Bevenius) [#34276](https://github.com/nodejs/node/pull/34276)
-* [[`3901c7fd30`](https://github.com/nodejs/node/commit/3901c7fd30)] - **src**: add GetCipherValue function (Daniel Bevenius) [#34287](https://github.com/nodejs/node/pull/34287)
-* [[`c1901896b7`](https://github.com/nodejs/node/commit/c1901896b7)] - **src**: add encoding\_type variable in WritePrivateKey (Daniel Bevenius) [#34181](https://github.com/nodejs/node/pull/34181)
-* [[`00835434ef`](https://github.com/nodejs/node/commit/00835434ef)] - **src**: fix unused namespace member (Nikola Glavina) [#34212](https://github.com/nodejs/node/pull/34212)
-* [[`88d12c00da`](https://github.com/nodejs/node/commit/88d12c00da)] - **src**: remove unnecessary ToLocalChecked call (Daniel Bevenius) [#33902](https://github.com/nodejs/node/pull/33902)
-* [[`a1da012f6b`](https://github.com/nodejs/node/commit/a1da012f6b)] - **src**: do not crash if ToggleAsyncHook fails during termination (Anna Henningsen) [#34362](https://github.com/nodejs/node/pull/34362)
-* [[`2a7c65acaf`](https://github.com/nodejs/node/commit/2a7c65acaf)] - **src,doc**: fix wording to refer to context, not environment (Turner Jabbour) [#34880](https://github.com/nodejs/node/pull/34880)
-* [[`302d38974d`](https://github.com/nodejs/node/commit/302d38974d)] - **src,doc**: rephrase for clarity (Turner Jabbour) [#34879](https://github.com/nodejs/node/pull/34879)
-* [[`4af336d741`](https://github.com/nodejs/node/commit/4af336d741)] - **(SEMVER-MINOR)** **src,test**: add full-featured embedder API test (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`d44b05b18c`](https://github.com/nodejs/node/commit/d44b05b18c)] - **stream**: allow using `.push()`/`.unshift()` during `once('data')` (Anna Henningsen) [#34957](https://github.com/nodejs/node/pull/34957)
-* [[`2e77a10d9c`](https://github.com/nodejs/node/commit/2e77a10d9c)] - **stream**: pipeline should use req.abort() to destroy response (Robert Nagy) [#31054](https://github.com/nodejs/node/pull/31054)
-* [[`2f67e99a0b`](https://github.com/nodejs/node/commit/2f67e99a0b)] - **test**: add arrayOfStreams to pipeline (rickyes) [#34156](https://github.com/nodejs/node/pull/34156)
-* [[`3598056ac1`](https://github.com/nodejs/node/commit/3598056ac1)] - **test**: add vm crash regression test (Anna Henningsen) [#34673](https://github.com/nodejs/node/pull/34673)
-* [[`8545fb2aa9`](https://github.com/nodejs/node/commit/8545fb2aa9)] - **test**: add common/udppair utility (James M Snell) [#33380](https://github.com/nodejs/node/pull/33380)
-* [[`232f6e1154`](https://github.com/nodejs/node/commit/232f6e1154)] - **test**: AsyncLocalStorage works with thenables (Gerhard Stoebich) [#34008](https://github.com/nodejs/node/pull/34008)
-* [[`4cd7f5f147`](https://github.com/nodejs/node/commit/4cd7f5f147)] - **test**: add non-ASCII character embedding test (Anna Henningsen) [#33972](https://github.com/nodejs/node/pull/33972)
-* [[`b0c1acafda`](https://github.com/nodejs/node/commit/b0c1acafda)] - **test**: verify threadId in reports (Dylan Coakley) [#31556](https://github.com/nodejs/node/pull/31556)
-* [[`bd71cdf153`](https://github.com/nodejs/node/commit/bd71cdf153)] - **test**: use common.buildType in embedding test (Anna Henningsen) [#32422](https://github.com/nodejs/node/pull/32422)
-* [[`bdf6d41c72`](https://github.com/nodejs/node/commit/bdf6d41c72)] - **test**: use InitializeNodeWithArgs in cctest (Anna Henningsen) [#32406](https://github.com/nodejs/node/pull/32406)
-* [[`61eec0c6c7`](https://github.com/nodejs/node/commit/61eec0c6c7)] - **test**: wait for message from parent in embedding cctest (Anna Henningsen) [#32563](https://github.com/nodejs/node/pull/32563)
-* [[`cb635c2dc0`](https://github.com/nodejs/node/commit/cb635c2dc0)] - **(SEMVER-MINOR)** **test**: add extended embedder cctest (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`f325c9544f`](https://github.com/nodejs/node/commit/f325c9544f)] - **(SEMVER-MINOR)** **test**: re-enable cctest that was commented out (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
-* [[`5a6bdd040d`](https://github.com/nodejs/node/commit/5a6bdd040d)] - **test**: improve assertions in pummel/test-timers (Rich Trott) [#35216](https://github.com/nodejs/node/pull/35216)
-* [[`942551e46f`](https://github.com/nodejs/node/commit/942551e46f)] - **test**: improve pummel/test-timers.js (Rich Trott) [#35175](https://github.com/nodejs/node/pull/35175)
-* [[`43c0174867`](https://github.com/nodejs/node/commit/43c0174867)] - **test**: revise test-policy-integrity (Rich Trott) [#35101](https://github.com/nodejs/node/pull/35101)
-* [[`d60c487c53`](https://github.com/nodejs/node/commit/d60c487c53)] - **test**: remove setMaxListeners in test-crypto-random (Tobias Nießen) [#35079](https://github.com/nodejs/node/pull/35079)
-* [[`867c4516af`](https://github.com/nodejs/node/commit/867c4516af)] - **test**: add regression tests for HTTP parser crash (Anna Henningsen) [#34251](https://github.com/nodejs/node/pull/34251)
-* [[`627e484e62`](https://github.com/nodejs/node/commit/627e484e62)] - **test**: use mustCall() in test-http-timeout (Pooja D.P) [#34996](https://github.com/nodejs/node/pull/34996)
-* [[`cd4b2aa891`](https://github.com/nodejs/node/commit/cd4b2aa891)] - **test**: change var to let (Pooja D.P) [#34902](https://github.com/nodejs/node/pull/34902)
-* [[`0bd176896e`](https://github.com/nodejs/node/commit/0bd176896e)] - **test**: remove incorrect debug() in test-policy-integrity (Rich Trott) [#34961](https://github.com/nodejs/node/pull/34961)
-* [[`327d00997d`](https://github.com/nodejs/node/commit/327d00997d)] - **test**: fix typo in test/parallel/test-icu-punycode.js (Daijiro Wachi) [#34934](https://github.com/nodejs/node/pull/34934)
-* [[`3fd7889e30`](https://github.com/nodejs/node/commit/3fd7889e30)] - **test**: add readline test for escape sequence (Rich Trott) [#34952](https://github.com/nodejs/node/pull/34952)
-* [[`46f94f9111`](https://github.com/nodejs/node/commit/46f94f9111)] - **test**: make test-tls-reuse-host-from-socket pass without internet (Rich Trott) [#34953](https://github.com/nodejs/node/pull/34953)
-* [[`76d991cf6b`](https://github.com/nodejs/node/commit/76d991cf6b)] - **test**: simplify test-vm-memleak (Rich Trott) [#34881](https://github.com/nodejs/node/pull/34881)
-* [[`d016cdcaa9`](https://github.com/nodejs/node/commit/d016cdcaa9)] - **test**: fix test-cluster-net-listen-relative-path.js to run in / (Rich Trott) [#34820](https://github.com/nodejs/node/pull/34820)
-* [[`cc98103802`](https://github.com/nodejs/node/commit/cc98103802)] - **test**: run REPL preview test regardless of terminal type (Rich Trott) [#34798](https://github.com/nodejs/node/pull/34798)
-* [[`4661b887cf`](https://github.com/nodejs/node/commit/4661b887cf)] - **test**: modernize test-cluster-master-error (Anna Henningsen) [#34685](https://github.com/nodejs/node/pull/34685)
-* [[`a4d50de661`](https://github.com/nodejs/node/commit/a4d50de661)] - **test**: move test-inspector-already-activated-cli to parallel (Rich Trott) [#34755](https://github.com/nodejs/node/pull/34755)
-* [[`4b22d335d1`](https://github.com/nodejs/node/commit/4b22d335d1)] - **test**: move execution of WPT to worker threads (Michaël Zasso) [#34796](https://github.com/nodejs/node/pull/34796)
-* [[`ac776f43f4`](https://github.com/nodejs/node/commit/ac776f43f4)] - **test**: convert assertion that always fails to assert.fail() (Rich Trott) [#34793](https://github.com/nodejs/node/pull/34793)
-* [[`a0ba41685b`](https://github.com/nodejs/node/commit/a0ba41685b)] - **test**: remove common.rootDir (Rich Trott) [#34772](https://github.com/nodejs/node/pull/34772)
-* [[`5352cde7ee`](https://github.com/nodejs/node/commit/5352cde7ee)] - **test**: allow ENOENT in test-worker-init-failure (Rich Trott) [#34769](https://github.com/nodejs/node/pull/34769)
-* [[`238d01f62f`](https://github.com/nodejs/node/commit/238d01f62f)] - **test**: allow ENFILE in test-worker-init-failure (Rich Trott) [#34769](https://github.com/nodejs/node/pull/34769)
-* [[`9cde4eb73a`](https://github.com/nodejs/node/commit/9cde4eb73a)] - **test**: use process.env.PYTHON to spawn python (Anna Henningsen) [#34700](https://github.com/nodejs/node/pull/34700)
-* [[`b4d9e0da6b`](https://github.com/nodejs/node/commit/b4d9e0da6b)] - **test**: remove error message checking in test-worker-init-failure (Rich Trott) [#34727](https://github.com/nodejs/node/pull/34727)
-* [[`335b61ac74`](https://github.com/nodejs/node/commit/335b61ac74)] - **test**: skip node-api/test\_worker\_terminate\_finalization (Anna Henningsen) [#34732](https://github.com/nodejs/node/pull/34732)
-* [[`e23f7ee1b9`](https://github.com/nodejs/node/commit/e23f7ee1b9)] - **test**: fix test\_worker\_terminate\_finalization (Anna Henningsen) [#34726](https://github.com/nodejs/node/pull/34726)
-* [[`b77309fe37`](https://github.com/nodejs/node/commit/b77309fe37)] - **test**: split test-crypto-dh-hash (Rich Trott) [#34631](https://github.com/nodejs/node/pull/34631)
-* [[`aa24b4a69d`](https://github.com/nodejs/node/commit/aa24b4a69d)] - **test**: use block-scoping in test/pummel/test-timers.js (Rich Trott) [#34630](https://github.com/nodejs/node/pull/34630)
-* [[`e30ddacddb`](https://github.com/nodejs/node/commit/e30ddacddb)] - **test**: remove test-child-process-fork-args flaky designation (Rich Trott) [#34684](https://github.com/nodejs/node/pull/34684)
-* [[`7eb80403b5`](https://github.com/nodejs/node/commit/7eb80403b5)] - **test**: add debugging for callbacks in test-https-foafssl.js (Rich Trott) [#34603](https://github.com/nodejs/node/pull/34603)
-* [[`4dbc787a2f`](https://github.com/nodejs/node/commit/4dbc787a2f)] - **test**: add debugging for test-https-foafssl.js (Rich Trott) [#34603](https://github.com/nodejs/node/pull/34603)
-* [[`71ee48863a`](https://github.com/nodejs/node/commit/71ee48863a)] - **test**: change Fixes: to Refs: (Rich Trott) [#34568](https://github.com/nodejs/node/pull/34568)
-* [[`09a6cefa94`](https://github.com/nodejs/node/commit/09a6cefa94)] - **test**: remove unneeded flag check in test-vm-memleak (Rich Trott) [#34528](https://github.com/nodejs/node/pull/34528)
-* [[`17973b7d7c`](https://github.com/nodejs/node/commit/17973b7d7c)] - **test**: add ref comment to test-regress-GH-814\_2 (Rich Trott) [#34516](https://github.com/nodejs/node/pull/34516)
-* [[`f6c674029d`](https://github.com/nodejs/node/commit/f6c674029d)] - **test**: add ref comment to test-regress-GH-814 (Rich Trott) [#34516](https://github.com/nodejs/node/pull/34516)
-* [[`d8c5bdaa08`](https://github.com/nodejs/node/commit/d8c5bdaa08)] - **test**: remove superfluous check in pummel/test-timers (Rich Trott) [#34488](https://github.com/nodejs/node/pull/34488)
-* [[`afd6e46772`](https://github.com/nodejs/node/commit/afd6e46772)] - **test**: fix test-heapdump-zlib (Andrey Pechkurov) [#34499](https://github.com/nodejs/node/pull/34499)
-* [[`72e0df3734`](https://github.com/nodejs/node/commit/72e0df3734)] - **test**: remove duplicate checks in pummel/test-timers (Rich Trott) [#34473](https://github.com/nodejs/node/pull/34473)
-* [[`4d4aa9a859`](https://github.com/nodejs/node/commit/4d4aa9a859)] - **test**: delete invalid test (Anna Henningsen) [#34445](https://github.com/nodejs/node/pull/34445)
-* [[`967334b9dc`](https://github.com/nodejs/node/commit/967334b9dc)] - **test**: fixup worker + source map test (Anna Henningsen) [#34446](https://github.com/nodejs/node/pull/34446)
-* [[`26c5f9febd`](https://github.com/nodejs/node/commit/26c5f9febd)] - **test**: force resigning of app (Colin Ihrig) [#34331](https://github.com/nodejs/node/pull/34331)
-* [[`8cb306e5a4`](https://github.com/nodejs/node/commit/8cb306e5a4)] - **test**: fix flaky test-watch-file (Rich Trott) [#34420](https://github.com/nodejs/node/pull/34420)
-* [[`cc2643188f`](https://github.com/nodejs/node/commit/cc2643188f)] - **test**: fix flaky test-heapdump-http2 (Rich Trott) [#34415](https://github.com/nodejs/node/pull/34415)
-* [[`2137024a55`](https://github.com/nodejs/node/commit/2137024a55)] - **test**: do not write to fixtures dir in test-watch-file (Rich Trott) [#34376](https://github.com/nodejs/node/pull/34376)
-* [[`95b2a39cf6`](https://github.com/nodejs/node/commit/95b2a39cf6)] - **test**: remove common.localhostIPv6 (Rich Trott) [#34373](https://github.com/nodejs/node/pull/34373)
-* [[`2ab3fccdbc`](https://github.com/nodejs/node/commit/2ab3fccdbc)] - **test**: fix test-net-pingpong pummel test for non-IPv6 hosts (Rich Trott) [#34359](https://github.com/nodejs/node/pull/34359)
-* [[`c3ac5e945c`](https://github.com/nodejs/node/commit/c3ac5e945c)] - **test**: fix flaky test-net-connect-econnrefused (Rich Trott) [#34330](https://github.com/nodejs/node/pull/34330)
-* [[`bd3cef7e0f`](https://github.com/nodejs/node/commit/bd3cef7e0f)] - **test**: use mustCall() in pummel test (Rich Trott) [#34327](https://github.com/nodejs/node/pull/34327)
-* [[`9741510336`](https://github.com/nodejs/node/commit/9741510336)] - **test**: fix flaky test-http2-reset-flood (Rich Trott) [#34318](https://github.com/nodejs/node/pull/34318)
-* [[`ed651374a4`](https://github.com/nodejs/node/commit/ed651374a4)] - **test**: add n-api null checks for conversions (Gabriel Schulhof) [#34142](https://github.com/nodejs/node/pull/34142)
-* [[`55ba743600`](https://github.com/nodejs/node/commit/55ba743600)] - **test**: add WASI test for file resizing (Colin Ihrig) [#31617](https://github.com/nodejs/node/pull/31617)
-* [[`4ae34e8ea8`](https://github.com/nodejs/node/commit/4ae34e8ea8)] - **test**: skip an ipv6 test on IBM i (Xu Meng) [#34209](https://github.com/nodejs/node/pull/34209)
-* [[`b7ae73bfe2`](https://github.com/nodejs/node/commit/b7ae73bfe2)] - **test**: add regression test for C++-created Buffer transfer (Anna Henningsen) [#34140](https://github.com/nodejs/node/pull/34140)
-* [[`235417039f`](https://github.com/nodejs/node/commit/235417039f)] - **test**: replace deprecated function call from test-repl-history-navigation (Rich Trott) [#34199](https://github.com/nodejs/node/pull/34199)
-* [[`44246e6701`](https://github.com/nodejs/node/commit/44246e6701)] - **test**: skip some IBM i unsupported test cases (Xu Meng) [#34118](https://github.com/nodejs/node/pull/34118)
-* [[`bb542176b0`](https://github.com/nodejs/node/commit/bb542176b0)] - **test**: report actual error code on failure (Richard Lau) [#34134](https://github.com/nodejs/node/pull/34134)
-* [[`09a12892e1`](https://github.com/nodejs/node/commit/09a12892e1)] - **test**: update test-child-process-spawn-loop for Python 3 (Richard Lau) [#34071](https://github.com/nodejs/node/pull/34071)
-* [[`26ede7f295`](https://github.com/nodejs/node/commit/26ede7f295)] - **test,doc**: add missing uv\_setup\_args() calls (Colin Ihrig) [#34751](https://github.com/nodejs/node/pull/34751)
-* [[`987e0cb785`](https://github.com/nodejs/node/commit/987e0cb785)] - **(SEMVER-MINOR)** **timers**: allow timers to be used as primitives (Denys Otrishko) [#34017](https://github.com/nodejs/node/pull/34017)
-* [[`9b27933549`](https://github.com/nodejs/node/commit/9b27933549)] - **(SEMVER-MINOR)** **tls**: make 'createSecureContext' honor more options (Mateusz Krawczuk) [#33974](https://github.com/nodejs/node/pull/33974)
-* [[`c059d3d287`](https://github.com/nodejs/node/commit/c059d3d287)] - **tls**: enable renegotiation when using BoringSSL (Jeremy Rose) [#34832](https://github.com/nodejs/node/pull/34832)
-* [[`bcc0913564`](https://github.com/nodejs/node/commit/bcc0913564)] - **tls**: remove setMaxSendFragment guards (Tobias Nießen) [#34323](https://github.com/nodejs/node/pull/34323)
-* [[`68654da30d`](https://github.com/nodejs/node/commit/68654da30d)] - **tls**: remove unnecessary close listener (Robert Nagy) [#34105](https://github.com/nodejs/node/pull/34105)
-* [[`55ed2d2280`](https://github.com/nodejs/node/commit/55ed2d2280)] - **tools**: update ESLint to 7.9.0 (Colin Ihrig) [#35170](https://github.com/nodejs/node/pull/35170)
-* [[`a3c59d8707`](https://github.com/nodejs/node/commit/a3c59d8707)] - **tools**: fix docopen target (Antoine du HAMEL) [#35062](https://github.com/nodejs/node/pull/35062)
-* [[`6d6c6fa929`](https://github.com/nodejs/node/commit/6d6c6fa929)] - **tools**: fix doc build targets (Antoine du HAMEL) [#35060](https://github.com/nodejs/node/pull/35060)
-* [[`1dce35d04a`](https://github.com/nodejs/node/commit/1dce35d04a)] - **tools**: add banner to lint-md.js by rollup.config.js (KuthorX) [#34233](https://github.com/nodejs/node/pull/34233)
-* [[`0f6102065e`](https://github.com/nodejs/node/commit/0f6102065e)] - **tools**: update ESLint to 7.8.1 (Colin Ihrig) [#35004](https://github.com/nodejs/node/pull/35004)
-* [[`eeb8a4aaa0`](https://github.com/nodejs/node/commit/eeb8a4aaa0)] - **tools**: update ESLint to 7.8.0 (Colin Ihrig) [#35004](https://github.com/nodejs/node/pull/35004)
-* [[`b4b0dcd43e`](https://github.com/nodejs/node/commit/b4b0dcd43e)] - **tools**: add debug entitlements for macOS 10.15+ (Gabriele Greco) [#34378](https://github.com/nodejs/node/pull/34378)
-* [[`a92aec137e`](https://github.com/nodejs/node/commit/a92aec137e)] - **tools**: update ESLint to 7.6.0 (Colin Ihrig) [#34589](https://github.com/nodejs/node/pull/34589)
-* [[`155f706ad0`](https://github.com/nodejs/node/commit/155f706ad0)] - **tools**: add meta.fixable to fixable lint rules (Colin Ihrig) [#34589](https://github.com/nodejs/node/pull/34589)
-* [[`aa15abb2be`](https://github.com/nodejs/node/commit/aa15abb2be)] - **tools**: update ESLint to 7.5.0 (Colin Ihrig) [#34423](https://github.com/nodejs/node/pull/34423)
-* [[`0507535277`](https://github.com/nodejs/node/commit/0507535277)] - **tools**: remove lint-js.js (Rich Trott) [#30955](https://github.com/nodejs/node/pull/30955)
-* [[`fed08a8e49`](https://github.com/nodejs/node/commit/fed08a8e49)] - **tools,doc**: allow page titles to contain inline code (Antoine du HAMEL) [#35003](https://github.com/nodejs/node/pull/35003)
-* [[`0ec3e6138e`](https://github.com/nodejs/node/commit/0ec3e6138e)] - **tools,doc**: fix global table of content active element (Antoine du Hamel) [#34976](https://github.com/nodejs/node/pull/34976)
-* [[`4a0c01e3d5`](https://github.com/nodejs/node/commit/4a0c01e3d5)] - **tools,doc**: remove "toc" anchor name (Rich Trott) [#34893](https://github.com/nodejs/node/pull/34893)
-* [[`8d0c21fd24`](https://github.com/nodejs/node/commit/8d0c21fd24)] - **util**: restrict custom inspect function + vm.Context interaction (Anna Henningsen) [#33690](https://github.com/nodejs/node/pull/33690)
-* [[`9027a87f62`](https://github.com/nodejs/node/commit/9027a87f62)] - **util**: print External address from inspect (unknown) [#34398](https://github.com/nodejs/node/pull/34398)
-* [[`58cd76cb04`](https://github.com/nodejs/node/commit/58cd76cb04)] - **util**: improve getStringWidth performance (Ruben Bridgewater) [#33674](https://github.com/nodejs/node/pull/33674)
-* [[`7f51e79511`](https://github.com/nodejs/node/commit/7f51e79511)] - **vm**: add tests for function declarations using \[\[DefineOwnProperty\]\] (ExE Boss) [#34032](https://github.com/nodejs/node/pull/34032)
-* [[`4913051ba6`](https://github.com/nodejs/node/commit/4913051ba6)] - **wasi**: add \_\_wasi\_fd\_filestat\_set\_times() test (Colin Ihrig) [#34623](https://github.com/nodejs/node/pull/34623)
-* [[`2e95550476`](https://github.com/nodejs/node/commit/2e95550476)] - **wasi**: add reactor support (Gus Caplan) [#34046](https://github.com/nodejs/node/pull/34046)
-* [[`139442c34e`](https://github.com/nodejs/node/commit/139442c34e)] - **(SEMVER-MINOR)** **worker**: add public method for marking objects as untransferable (Anna Henningsen) [#33979](https://github.com/nodejs/node/pull/33979)
-* [[`44864d7385`](https://github.com/nodejs/node/commit/44864d7385)] - **worker**: do not crash when JSTransferable lists untransferable value (Anna Henningsen) [#34766](https://github.com/nodejs/node/pull/34766)
-* [[`dafa380732`](https://github.com/nodejs/node/commit/dafa380732)] - **(SEMVER-MINOR)** **worker**: emit `'messagerror'` events for failed deserialization (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
-* [[`0d35eaa034`](https://github.com/nodejs/node/commit/0d35eaa034)] - **(SEMVER-MINOR)** **worker**: allow passing JS wrapper objects via postMessage (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
-* [[`8e1698a784`](https://github.com/nodejs/node/commit/8e1698a784)] - **(SEMVER-MINOR)** **worker**: allow transferring/cloning generic BaseObjects (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
-* [[`b4819dba5c`](https://github.com/nodejs/node/commit/b4819dba5c)] - **(SEMVER-MINOR)** **worker**: add option to track unmanaged file descriptors (Anna Henningsen) [#34303](https://github.com/nodejs/node/pull/34303)
-* [[`5e9f0cfa62`](https://github.com/nodejs/node/commit/5e9f0cfa62)] - **worker**: fix --abort-on-uncaught-exception handling (Anna Henningsen) [#34724](https://github.com/nodejs/node/pull/34724)
-* [[`9173b09445`](https://github.com/nodejs/node/commit/9173b09445)] - **(SEMVER-MINOR)** **worker**: add stack size resource limit option (Anna Henningsen) [#33085](https://github.com/nodejs/node/pull/33085)
-* [[`18ecaebdbb`](https://github.com/nodejs/node/commit/18ecaebdbb)] - **worker**: unify custom error creation (Anna Henningsen) [#33084](https://github.com/nodejs/node/pull/33084)
-* [[`c31b6bff34`](https://github.com/nodejs/node/commit/c31b6bff34)] - **worker**: fix nested uncaught exception handling (Anna Henningsen) [#34310](https://github.com/nodejs/node/pull/34310)
-* [[`dd51ba3f93`](https://github.com/nodejs/node/commit/dd51ba3f93)] - **(SEMVER-MINOR)** **worker,fs**: make FileHandle transferable (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
-* [[`1b24d3a552`](https://github.com/nodejs/node/commit/1b24d3a552)] - **zlib**: remove redundant variable in zlibBufferOnEnd (Andrey Pechkurov) [#34072](https://github.com/nodejs/node/pull/34072)
-* [[`33b22d7c4f`](https://github.com/nodejs/node/commit/33b22d7c4f)] - **(SEMVER-MINOR)** **zlib**: add `maxOutputLength` option (unknown) [#33516](https://github.com/nodejs/node/pull/33516)
-* [[`cda459ecb0`](https://github.com/nodejs/node/commit/cda459ecb0)] - **zlib**: replace usage of internal stream state with public api (Denys Otrishko) [#34884](https://github.com/nodejs/node/pull/34884)
-* [[`d60b13f2e3`](https://github.com/nodejs/node/commit/d60b13f2e3)] - **zlib**: switch to lazy init for zlib streams (Andrey Pechkurov) [#34048](https://github.com/nodejs/node/pull/34048)
-
-<a id="12.18.4"></a>
-## 2020-09-15, Version 12.18.4 'Erbium' (LTS), @BethGriggs prepared by @targos
-
-### Notable Changes
-
-This is a security release.
-
-Vulnerabilities fixed:
-
-* **CVE-2020-8201**: HTTP Request Smuggling due to CR-to-Hyphen conversion (High).
-* **CVE-2020-8252**: fs.realpath.native on may cause buffer overflow (Medium).
-
-### Commits
-
-* [[`2ea6d255f8`](https://github.com/nodejs/node/commit/2ea6d255f8)] - **deps**: libuv: cherry-pick 0e6e8620 (cjihrig) [nodejs-private/node-private#221](https://github.com/nodejs-private/node-private/pull/221)
-* [[`65415049af`](https://github.com/nodejs/node/commit/65415049af)] - **deps**: update llhttp to 2.1.2 (Fedor Indutny) [nodejs-private/node-private#219](https://github.com/nodejs-private/node-private/pull/219)
-* [[`edad52e243`](https://github.com/nodejs/node/commit/edad52e243)] - **test**: modify tests to support the latest llhttp (Fedor Indutny) [nodejs-private/node-private#219](https://github.com/nodejs-private/node-private/pull/219)
-
-<a id="12.18.3"></a>
-## 2020-07-22, Version 12.18.3 'Erbium' (LTS), @codebytere
-
-### Notable Changes
-
-* **deps:**
-  * upgrade npm to 6.14.6 (claudiahdz) [#34246](https://github.com/nodejs/node/pull/34246)
-  * update node-inspect to v2.0.0 (Jan Krems) [#33447](https://github.com/nodejs/node/pull/33447)
-  * uvwasi: cherry-pick 9e75217 (Colin Ihrig) [#33521](https://github.com/nodejs/node/pull/33521)
-
-### Commits
-
-* [[`0d79c533ef`](https://github.com/nodejs/node/commit/0d79c533ef)] - **async_hooks**: callback trampoline for MakeCallback (Stephen Belanger) [#33801](https://github.com/nodejs/node/pull/33801)
-* [[`bfffb977ad`](https://github.com/nodejs/node/commit/bfffb977ad)] - **benchmark**: fix async-resource benchmark (Anna Henningsen) [#33642](https://github.com/nodejs/node/pull/33642)
-* [[`09277fa5e4`](https://github.com/nodejs/node/commit/09277fa5e4)] - **benchmark**: fixing http\_server\_for\_chunky\_client.js (Adrian Estrada) [#33271](https://github.com/nodejs/node/pull/33271)
-* [[`5a6d80f25f`](https://github.com/nodejs/node/commit/5a6d80f25f)] - **buffer**: remove hoisted variable (Nikolai Vavilov) [#33470](https://github.com/nodejs/node/pull/33470)
-* [[`e057189ee8`](https://github.com/nodejs/node/commit/e057189ee8)] - **build**: configure byte order for mips targets (Ben Noordhuis) [#33898](https://github.com/nodejs/node/pull/33898)
-* [[`d77eaeefb8`](https://github.com/nodejs/node/commit/d77eaeefb8)] - **build**: add target specific build\_type variable (Daniel Bevenius) [#33925](https://github.com/nodejs/node/pull/33925)
-* [[`d56585ec8d`](https://github.com/nodejs/node/commit/d56585ec8d)] - **build**: add LINT_CPP_FILES to checkimports check (Daniel Bevenius) [#33697](https://github.com/nodejs/node/pull/33697)
-* [[`a5ce90c46b`](https://github.com/nodejs/node/commit/a5ce90c46b)] - **build**: add --v8-lite-mode flag (Maciej Kacper Jagiełło) [#33541](https://github.com/nodejs/node/pull/33541)
-* [[`11dad02e50`](https://github.com/nodejs/node/commit/11dad02e50)] - **build**: fix python-version selection with actions (Richard Lau) [#33589](https://github.com/nodejs/node/pull/33589)
-* [[`bba41bf6e1`](https://github.com/nodejs/node/commit/bba41bf6e1)] - **build**: fix makefile script on windows (Thomas) [#33136](https://github.com/nodejs/node/pull/33136)
-* [[`817f6593ee`](https://github.com/nodejs/node/commit/817f6593ee)] - **configure**: account for CLANG_VENDOR when checking for llvm version (Nathan Blair) [#33860](https://github.com/nodejs/node/pull/33860)
-* [[`a9c5b3348c`](https://github.com/nodejs/node/commit/a9c5b3348c)] - **console**: name console functions appropriately (Ruben Bridgewater) [#33524](https://github.com/nodejs/node/pull/33524)
-* [[`d8365bc71e`](https://github.com/nodejs/node/commit/d8365bc71e)] - **console**: mark special console properties as non-enumerable (Ruben Bridgewater) [#33524](https://github.com/nodejs/node/pull/33524)
-* [[`80782cb261`](https://github.com/nodejs/node/commit/80782cb261)] - **console**: remove dead code (Ruben Bridgewater) [#33524](https://github.com/nodejs/node/pull/33524)
-* [[`18dc03d6a5`](https://github.com/nodejs/node/commit/18dc03d6a5)] - **crypto**: fix wrong error message (Ben Bucksch) [#33482](https://github.com/nodejs/node/pull/33482)
-* [[`b64963e5c3`](https://github.com/nodejs/node/commit/b64963e5c3)] - **deps**: upgrade npm to 6.14.6 (claudiahdz) [#34246](https://github.com/nodejs/node/pull/34246)
-* [[`9ee9688fe0`](https://github.com/nodejs/node/commit/9ee9688fe0)] - **deps**: uvwasi: cherry-pick 9e75217 (Colin Ihrig) [#33521](https://github.com/nodejs/node/pull/33521)
-* [[`8803d7e8cf`](https://github.com/nodejs/node/commit/8803d7e8cf)] - **deps**: update node-inspect to v2.0.0 (Jan Krems) [#33447](https://github.com/nodejs/node/pull/33447)
-* [[`5d3f818e9e`](https://github.com/nodejs/node/commit/5d3f818e9e)] - **dns**: make dns.Resolver timeout configurable (Ben Noordhuis) [#33472](https://github.com/nodejs/node/pull/33472)
-* [[`10b88cb117`](https://github.com/nodejs/node/commit/10b88cb117)] - **dns**: use ternary operator simplify statement (Wenning Zhang) [#33234](https://github.com/nodejs/node/pull/33234)
-* [[`fbd6fe5839`](https://github.com/nodejs/node/commit/fbd6fe5839)] - **doc**: update code language flag for internal doc (Rich Trott) [#33852](https://github.com/nodejs/node/pull/33852)
-* [[`24fd15778a`](https://github.com/nodejs/node/commit/24fd15778a)] - **doc**: specify maxHeaderCount alias for maxHeaderListPairs (Pranshu Srivastava) [#33519](https://github.com/nodejs/node/pull/33519)
-* [[`04ceeaf5eb`](https://github.com/nodejs/node/commit/04ceeaf5eb)] - **doc**: add allowed info strings to style guide (Derek Lewis) [#34024](https://github.com/nodejs/node/pull/34024)
-* [[`ee36c87fd7`](https://github.com/nodejs/node/commit/ee36c87fd7)] - **doc**: clarify thread-safe function references (legendecas) [#33871](https://github.com/nodejs/node/pull/33871)
-* [[`30b5e76ffd`](https://github.com/nodejs/node/commit/30b5e76ffd)] - **doc**: use npm team for npm upgrades in collaborator guide (Rich Trott) [#33999](https://github.com/nodejs/node/pull/33999)
-* [[`06937249d0`](https://github.com/nodejs/node/commit/06937249d0)] - **doc**: correct default values in http2 docs (Rich Trott) [#33997](https://github.com/nodejs/node/pull/33997)
-* [[`498dfba33a`](https://github.com/nodejs/node/commit/498dfba33a)] - **doc**: use a single space between sentences (Rich Trott) [#33995](https://github.com/nodejs/node/pull/33995)
-* [[`47ea3067d0`](https://github.com/nodejs/node/commit/47ea3067d0)] - **doc**: revise text in dns module documentation introduction (Rich Trott) [#33986](https://github.com/nodejs/node/pull/33986)
-* [[`f29f77f111`](https://github.com/nodejs/node/commit/f29f77f111)] - **doc**: update fs.md (Shakil-Shahadat) [#33820](https://github.com/nodejs/node/pull/33820)
-* [[`ddc5afdddc`](https://github.com/nodejs/node/commit/ddc5afdddc)] - **doc**: warn that tls.connect() doesn't set SNI (Alba Mendez) [#33855](https://github.com/nodejs/node/pull/33855)
-* [[`732b80b474`](https://github.com/nodejs/node/commit/732b80b474)] - **doc**: fix lexical sorting of bottom-references in dns doc (Rich Trott) [#33987](https://github.com/nodejs/node/pull/33987)
-* [[`6af2ed3fdc`](https://github.com/nodejs/node/commit/6af2ed3fdc)] - **doc**: change "GitHub Repo" to "Code repository" (Rich Trott) [#33985](https://github.com/nodejs/node/pull/33985)
-* [[`322a51e582`](https://github.com/nodejs/node/commit/322a51e582)] - **doc**: use Class: consistently (Rich Trott) [#33978](https://github.com/nodejs/node/pull/33978)
-* [[`410b23398d`](https://github.com/nodejs/node/commit/410b23398d)] - **doc**: update WASM code sample (Pragyan Das) [#33626](https://github.com/nodejs/node/pull/33626)
-* [[`335f405f1b`](https://github.com/nodejs/node/commit/335f405f1b)] - **doc**: link readable.\_read in stream.md (Pranshu Srivastava) [#33767](https://github.com/nodejs/node/pull/33767)
-* [[`3789c28c89`](https://github.com/nodejs/node/commit/3789c28c89)] - **doc**: specify default encoding in writable.write (Pranshu Srivastava) [#33765](https://github.com/nodejs/node/pull/33765)
-* [[`5609b17e2d`](https://github.com/nodejs/node/commit/5609b17e2d)] - **doc**: move --force-context-aware option in cli.md (Daniel Bevenius) [#33823](https://github.com/nodejs/node/pull/33823)
-* [[`f39ee7d245`](https://github.com/nodejs/node/commit/f39ee7d245)] - **doc**: add snippet for AsyncResource and EE integration (Andrey Pechkurov) [#33751](https://github.com/nodejs/node/pull/33751)
-* [[`f8baeccaaa`](https://github.com/nodejs/node/commit/f8baeccaaa)] - **doc**: use single quotes in --tls-cipher-list (Daniel Bevenius) [#33709](https://github.com/nodejs/node/pull/33709)
-* [[`4654e2321b`](https://github.com/nodejs/node/commit/4654e2321b)] - **doc**: fix misc. mislabeled code block info strings (Derek Lewis) [#33548](https://github.com/nodejs/node/pull/33548)
-* [[`046dee6eb3`](https://github.com/nodejs/node/commit/046dee6eb3)] - **doc**: update V8 inspector example (Colin Ihrig) [#33758](https://github.com/nodejs/node/pull/33758)
-* [[`d547d1c1bc`](https://github.com/nodejs/node/commit/d547d1c1bc)] - **doc**: fix linting in doc-style-guide.md (Pranshu Srivastava) [#33787](https://github.com/nodejs/node/pull/33787)
-* [[`3b437416d5`](https://github.com/nodejs/node/commit/3b437416d5)] - **doc**: add formatting for version numbers to doc-style-guide.md (Rich Trott) [#33755](https://github.com/nodejs/node/pull/33755)
-* [[`b00996ce35`](https://github.com/nodejs/node/commit/b00996ce35)] - **doc**: remove "currently" from repl.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
-* [[`7595d15286`](https://github.com/nodejs/node/commit/7595d15286)] - **doc**: remove "currently" from vm.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
-* [[`36a8af7a5e`](https://github.com/nodejs/node/commit/36a8af7a5e)] - **doc**: remove "currently" from addons.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
-* [[`27e797687f`](https://github.com/nodejs/node/commit/27e797687f)] - **doc**: remove "currently" from util.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
-* [[`94ac13678d`](https://github.com/nodejs/node/commit/94ac13678d)] - **doc**: change "pre Node.js v0.10" to "prior to Node.js 0.10" (Rich Trott) [#33754](https://github.com/nodejs/node/pull/33754)
-* [[`f1a810880e`](https://github.com/nodejs/node/commit/f1a810880e)] - **doc**: normalize C++ code block info strings (Derek Lewis) [#33483](https://github.com/nodejs/node/pull/33483)
-* [[`289d0bf105`](https://github.com/nodejs/node/commit/289d0bf105)] - **doc**: remove default parameter value from header (Rich Trott) [#33752](https://github.com/nodejs/node/pull/33752)
-* [[`35cee03849`](https://github.com/nodejs/node/commit/35cee03849)] - **doc**: remove shell dollar signs without output (Nick Schonning) [#33692](https://github.com/nodejs/node/pull/33692)
-* [[`d10fac73a3`](https://github.com/nodejs/node/commit/d10fac73a3)] - **doc**: add lint disabling comment for collaborator list (Rich Trott) [#33719](https://github.com/nodejs/node/pull/33719)
-* [[`8dbf3349d0`](https://github.com/nodejs/node/commit/8dbf3349d0)] - **doc**: fix urls to avoid redirection (sapics) [#33614](https://github.com/nodejs/node/pull/33614)
-* [[`5416635677`](https://github.com/nodejs/node/commit/5416635677)] - **doc**: improve buffer.md a tiny bit (Tom Nagle) [#33547](https://github.com/nodejs/node/pull/33547)
-* [[`a3b6095db1`](https://github.com/nodejs/node/commit/a3b6095db1)] - **doc**: normalize Markdown code block info strings (Derek Lewis) [#33542](https://github.com/nodejs/node/pull/33542)
-* [[`4fcbfdc45c`](https://github.com/nodejs/node/commit/4fcbfdc45c)] - **doc**: normalize JavaScript code block info strings (Derek Lewis) [#33531](https://github.com/nodejs/node/pull/33531)
-* [[`543605782d`](https://github.com/nodejs/node/commit/543605782d)] - **doc**: outline when origin is set to unhandledRejection (Ruben Bridgewater) [#33530](https://github.com/nodejs/node/pull/33530)
-* [[`7dc28ab4d3`](https://github.com/nodejs/node/commit/7dc28ab4d3)] - **doc**: update txt fandamental and raw code blocks (Zeke Sikelianos) [#33028](https://github.com/nodejs/node/pull/33028)
-* [[`cf82adf87f`](https://github.com/nodejs/node/commit/cf82adf87f)] - **doc**: normalize Bash code block info strings (Derek Lewis) [#33510](https://github.com/nodejs/node/pull/33510)
-* [[`7ea6b07b90`](https://github.com/nodejs/node/commit/7ea6b07b90)] - **doc**: normalize shell code block info strings (Derek Lewis) [#33486](https://github.com/nodejs/node/pull/33486)
-* [[`74a1493441`](https://github.com/nodejs/node/commit/74a1493441)] - **doc**: normalize C code block info strings (Derek Lewis) [#33507](https://github.com/nodejs/node/pull/33507)
-* [[`281d7f74d8`](https://github.com/nodejs/node/commit/281d7f74d8)] - **doc**: correct tls.rootCertificates to match implementation (Eric Bickle) [#33313](https://github.com/nodejs/node/pull/33313)
-* [[`6133639d53`](https://github.com/nodejs/node/commit/6133639d53)] - **doc**: fix Buffer.from(object) documentation (Nikolai Vavilov) [#33327](https://github.com/nodejs/node/pull/33327)
-* [[`b599037f78`](https://github.com/nodejs/node/commit/b599037f78)] - **doc**: fix typo in pathToFileURL example (Antoine du HAMEL) [#33418](https://github.com/nodejs/node/pull/33418)
-* [[`78734c2698`](https://github.com/nodejs/node/commit/78734c2698)] - **doc**: eliminate dead space in API section's sidebar (John Gardner) [#33469](https://github.com/nodejs/node/pull/33469)
-* [[`c76ec4d007`](https://github.com/nodejs/node/commit/c76ec4d007)] - **doc**: fixed a grammatical error in path.md (Deep310) [#33489](https://github.com/nodejs/node/pull/33489)
-* [[`1b76377bce`](https://github.com/nodejs/node/commit/1b76377bce)] - **doc**: correct CommonJS self-resolve spec (Guy Bedford) [#33391](https://github.com/nodejs/node/pull/33391)
-* [[`70d025f510`](https://github.com/nodejs/node/commit/70d025f510)] - **doc**: standardize on sentence case for headers (Rich Trott) [#33889](https://github.com/nodejs/node/pull/33889)
-* [[`3e68d21c6f`](https://github.com/nodejs/node/commit/3e68d21c6f)] - **doc**: use sentence-case for headings in docs (Rich Trott) [#33889](https://github.com/nodejs/node/pull/33889)
-* [[`dfa8028254`](https://github.com/nodejs/node/commit/dfa8028254)] - **doc**: fix readline key binding documentation (Ruben Bridgewater) [#33361](https://github.com/nodejs/node/pull/33361)
-* [[`6f8b7a85d2`](https://github.com/nodejs/node/commit/6f8b7a85d2)] - **doc,tools**: properly syntax highlight API ref docs (Derek Lewis) [#33442](https://github.com/nodejs/node/pull/33442)
-* [[`43d1d89d27`](https://github.com/nodejs/node/commit/43d1d89d27)] - **domain**: fix unintentional deprecation warning (Anna Henningsen) [#34245](https://github.com/nodejs/node/pull/34245)
-* [[`ba476326dd`](https://github.com/nodejs/node/commit/ba476326dd)] - **domain**: remove native domain code (Stephen Belanger) [#33801](https://github.com/nodejs/node/pull/33801)
-* [[`76b06e53c6`](https://github.com/nodejs/node/commit/76b06e53c6)] - **errors**: fully inspect errors on exit (Ruben Bridgewater) [#33523](https://github.com/nodejs/node/pull/33523)
-* [[`9111fab663`](https://github.com/nodejs/node/commit/9111fab663)] - **esm**: fix loader hooks doc annotations (Derek Lewis) [#33563](https://github.com/nodejs/node/pull/33563)
-* [[`3559471153`](https://github.com/nodejs/node/commit/3559471153)] - **esm**: share package.json cache between ESM and CJS loaders (Kirill Shatskiy) [#33229](https://github.com/nodejs/node/pull/33229)
-* [[`d09f6d55c7`](https://github.com/nodejs/node/commit/d09f6d55c7)] - **esm**: doc & validate source values for formats (Bradley Farias) [#32202](https://github.com/nodejs/node/pull/32202)
-* [[`a76fa60c63`](https://github.com/nodejs/node/commit/a76fa60c63)] - **fs**: fix readdir failure when libuv returns UV\_DIRENT\_UNKNOWN (Kirill Shatskiy) [#33395](https://github.com/nodejs/node/pull/33395)
-* [[`b92c0cb15c`](https://github.com/nodejs/node/commit/b92c0cb15c)] - **fs**: fix realpath inode link caching (Denys Otrishko) [#33945](https://github.com/nodejs/node/pull/33945)
-* [[`04fa6d675f`](https://github.com/nodejs/node/commit/04fa6d675f)] - **fs**: close file descriptor of promisified truncate (João Reis) [#34239](https://github.com/nodejs/node/pull/34239)
-* [[`c9cf41d841`](https://github.com/nodejs/node/commit/c9cf41d841)] - **fs**: support util.promisify for fs.readv (Lucas Holmquist) [#33590](https://github.com/nodejs/node/pull/33590)
-* [[`adb93f153b`](https://github.com/nodejs/node/commit/adb93f153b)] - **fs**: unify style in preprocessSymlinkDestination (Bartosz Sosnowski) [#33496](https://github.com/nodejs/node/pull/33496)
-* [[`5fb1cc8cc1`](https://github.com/nodejs/node/commit/5fb1cc8cc1)] - **fs**: replace checkPosition with validateInteger (rickyes) [#33277](https://github.com/nodejs/node/pull/33277)
-* [[`75107e23a8`](https://github.com/nodejs/node/commit/75107e23a8)] - **http2**: always call callback on Http2ServerResponse#end (Pranshu Srivastava) [#33911](https://github.com/nodejs/node/pull/33911)
-* [[`0f0720a665`](https://github.com/nodejs/node/commit/0f0720a665)] - **http2**: add writable\* properties to compat api (Pranshu Srivastava) [#33506](https://github.com/nodejs/node/pull/33506)
-* [[`8def93429e`](https://github.com/nodejs/node/commit/8def93429e)] - **http2**: add type checks for Http2ServerResponse.end (Pranshu Srivastava) [#33146](https://github.com/nodejs/node/pull/33146)
-* [[`a3b7e5992d`](https://github.com/nodejs/node/commit/a3b7e5992d)] - **http2**: use `Object.create(null)` for `getHeaders` (Pranshu Srivastava) [#33188](https://github.com/nodejs/node/pull/33188)
-* [[`bcdf4c808d`](https://github.com/nodejs/node/commit/bcdf4c808d)] - **http2**: reuse .\_onTimeout() in Http2Session and Http2Stream classes (rickyes) [#33354](https://github.com/nodejs/node/pull/33354)
-* [[`103a9af673`](https://github.com/nodejs/node/commit/103a9af673)] - **inspector**: drop 'chrome-' from inspector url (Colin Ihrig) [#33758](https://github.com/nodejs/node/pull/33758)
-* [[`0941635bb5`](https://github.com/nodejs/node/commit/0941635bb5)] - **inspector**: throw error when activating an already active inspector (Joyee Cheung) [#33015](https://github.com/nodejs/node/pull/33015)
-* [[`0197ea4e56`](https://github.com/nodejs/node/commit/0197ea4e56)] - **lib**: replace charCodeAt with fixed Unicode (rickyes) [#32758](https://github.com/nodejs/node/pull/32758)
-* [[`69291e4b7d`](https://github.com/nodejs/node/commit/69291e4b7d)] - **lib**: add Int16Array primordials (Sebastien Ahkrin) [#31205](https://github.com/nodejs/node/pull/31205)
-* [[`83c9364bf1`](https://github.com/nodejs/node/commit/83c9364bf1)] - **lib**: update TODO comments (Ruben Bridgewater) [#33361](https://github.com/nodejs/node/pull/33361)
-* [[`a94e7dabcc`](https://github.com/nodejs/node/commit/a94e7dabcc)] - **lib**: update executionAsyncId/triggerAsyncId comment (Daniel Bevenius) [#33396](https://github.com/nodejs/node/pull/33396)
-* [[`857ff68485`](https://github.com/nodejs/node/commit/857ff68485)] - **meta**: introduce codeowners again (James M Snell) [#33895](https://github.com/nodejs/node/pull/33895)
-* [[`f534ac06bd`](https://github.com/nodejs/node/commit/f534ac06bd)] - **meta**: fix a typo in the flaky test template (Colin Ihrig) [#33677](https://github.com/nodejs/node/pull/33677)
-* [[`1376c3bab2`](https://github.com/nodejs/node/commit/1376c3bab2)] - **meta**: wrap flaky test template at 80 characters (Colin Ihrig) [#33677](https://github.com/nodejs/node/pull/33677)
-* [[`b7ea7be2a8`](https://github.com/nodejs/node/commit/b7ea7be2a8)] - **meta**: add flaky test issue template (Ash Cripps) [#33500](https://github.com/nodejs/node/pull/33500)
-* [[`0867ab7da5`](https://github.com/nodejs/node/commit/0867ab7da5)] - **module**: fix error message about importing names from cjs (Fábio Santos) [#33882](https://github.com/nodejs/node/pull/33882)
-* [[`47f5eeb0d5`](https://github.com/nodejs/node/commit/47f5eeb0d5)] - **n-api**: add version to wasm registration (Gus Caplan) [#34045](https://github.com/nodejs/node/pull/34045)
-* [[`2e97d82509`](https://github.com/nodejs/node/commit/2e97d82509)] - **n-api**: document nextTick timing in callbacks (Mathias Buus) [#33804](https://github.com/nodejs/node/pull/33804)
-* [[`90ddf0aa2e`](https://github.com/nodejs/node/commit/90ddf0aa2e)] - **n-api**: ensure scope present for finalization (Michael Dawson) [#33508](https://github.com/nodejs/node/pull/33508)
-* [[`ed741ecb1e`](https://github.com/nodejs/node/commit/ed741ecb1e)] - **n-api**: remove `napi_env::CallIntoModuleThrow` (Gabriel Schulhof) [#33570](https://github.com/nodejs/node/pull/33570)
-* [[`0a949c3f93`](https://github.com/nodejs/node/commit/0a949c3f93)] - **napi**: add \_\_wasm32\_\_ guards (Gus Caplan) [#33597](https://github.com/nodejs/node/pull/33597)
-* [[`7c7f5c8869`](https://github.com/nodejs/node/commit/7c7f5c8869)] - **net**: refactor check for Windows (rickyes) [#33497](https://github.com/nodejs/node/pull/33497)
-* [[`578e731321`](https://github.com/nodejs/node/commit/578e731321)] - **querystring**: fix stringify for empty array (sapics) [#33918](https://github.com/nodejs/node/pull/33918)
-* [[`13b693fd54`](https://github.com/nodejs/node/commit/13b693fd54)] - **querystring**: improve stringify() performance (Brian White) [#33669](https://github.com/nodejs/node/pull/33669)
-* [[`d3737a1c32`](https://github.com/nodejs/node/commit/d3737a1c32)] - **src**: add errorProperties on process.report (himself65) [#28426](https://github.com/nodejs/node/pull/28426)
-* [[`b57778ff26`](https://github.com/nodejs/node/commit/b57778ff26)] - **src**: tolerate EPERM returned from tcsetattr (patr0nus) [#33944](https://github.com/nodejs/node/pull/33944)
-* [[`9e1185afee`](https://github.com/nodejs/node/commit/9e1185afee)] - **src**: clang\_format base\_object (Yash Ladha) [#33680](https://github.com/nodejs/node/pull/33680)
-* [[`69f962953c`](https://github.com/nodejs/node/commit/69f962953c)] - **src**: remove unnecessary calculation in base64.h (sapics) [#33839](https://github.com/nodejs/node/pull/33839)
-* [[`b1c9f75a20`](https://github.com/nodejs/node/commit/b1c9f75a20)] - **src**: use ToLocal in node\_os.cc (wenningplus) [#33939](https://github.com/nodejs/node/pull/33939)
-* [[`153f292a97`](https://github.com/nodejs/node/commit/153f292a97)] - **src**: handle empty Maybe(Local) in node\_util.cc (Anna Henningsen) [#33867](https://github.com/nodejs/node/pull/33867)
-* [[`6d5383de35`](https://github.com/nodejs/node/commit/6d5383de35)] - **src**: improve indention for upd\_wrap.cc (gengjiawen) [#33976](https://github.com/nodejs/node/pull/33976)
-* [[`437f387de9`](https://github.com/nodejs/node/commit/437f387de9)] - **src**: reduce scope of code cache mutex (Anna Henningsen) [#33980](https://github.com/nodejs/node/pull/33980)
-* [[`9199808355`](https://github.com/nodejs/node/commit/9199808355)] - **src**: do not track BaseObjects via cleanup hooks (Anna Henningsen) [#33809](https://github.com/nodejs/node/pull/33809)
-* [[`5b987c46b7`](https://github.com/nodejs/node/commit/5b987c46b7)] - **src**: remove ref to tools/generate\_code\_cache.js (Daniel Bevenius) [#33825](https://github.com/nodejs/node/pull/33825)
-* [[`185657dfd7`](https://github.com/nodejs/node/commit/185657dfd7)] - **src**: remove unused vector include in string\_bytes (Daniel Bevenius) [#33824](https://github.com/nodejs/node/pull/33824)
-* [[`ec2452c4af`](https://github.com/nodejs/node/commit/ec2452c4af)] - **src**: avoid unnecessary ToLocalChecked calls (Daniel Bevenius) [#33824](https://github.com/nodejs/node/pull/33824)
-* [[`74843db28c`](https://github.com/nodejs/node/commit/74843db28c)] - **src**: simplify format in node\_file.cc (himself65) [#33660](https://github.com/nodejs/node/pull/33660)
-* [[`86283aaa6a`](https://github.com/nodejs/node/commit/86283aaa6a)] - **src**: handle missing TracingController everywhere (Anna Henningsen) [#33815](https://github.com/nodejs/node/pull/33815)
-* [[`e07c1c2508`](https://github.com/nodejs/node/commit/e07c1c2508)] - **src**: simplify Reindent function in json\_utils.cc (sapics) [#33722](https://github.com/nodejs/node/pull/33722)
-* [[`449d9ec1c5`](https://github.com/nodejs/node/commit/449d9ec1c5)] - **src**: add "missing" bash completion options (Daniel Bevenius) [#33744](https://github.com/nodejs/node/pull/33744)
-* [[`4b4fb1381b`](https://github.com/nodejs/node/commit/4b4fb1381b)] - **src**: use Check() instead of FromJust in environment (Daniel Bevenius) [#33706](https://github.com/nodejs/node/pull/33706)
-* [[`6f1d38cd8f`](https://github.com/nodejs/node/commit/6f1d38cd8f)] - **src**: use ToLocal in SafeGetenv (Daniel Bevenius) [#33695](https://github.com/nodejs/node/pull/33695)
-* [[`5b8cac8cf5`](https://github.com/nodejs/node/commit/5b8cac8cf5)] - **src**: remove unnecessary ToLocalChecked call (Daniel Bevenius) [#33683](https://github.com/nodejs/node/pull/33683)
-* [[`eb8d6f5fd8`](https://github.com/nodejs/node/commit/eb8d6f5fd8)] - **src**: simplify MaybeStackBuffer::capacity() (Ben Noordhuis) [#33602](https://github.com/nodejs/node/pull/33602)
-* [[`e3beb781e0`](https://github.com/nodejs/node/commit/e3beb781e0)] - **src**: avoid OOB read in URL parser (Anna Henningsen) [#33640](https://github.com/nodejs/node/pull/33640)
-* [[`99371ade2a`](https://github.com/nodejs/node/commit/99371ade2a)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty worker (Daniel Bevenius) [#33599](https://github.com/nodejs/node/pull/33599)
-* [[`9c69296990`](https://github.com/nodejs/node/commit/9c69296990)] - **src**: don't use semicolon outside function (Shelley Vohr) [#33592](https://github.com/nodejs/node/pull/33592)
-* [[`41d879616f`](https://github.com/nodejs/node/commit/41d879616f)] - **src**: remove unused using declarations (Daniel Bevenius) [#33268](https://github.com/nodejs/node/pull/33268)
-* [[`103479a0c5`](https://github.com/nodejs/node/commit/103479a0c5)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty (Daniel Bevenius) [#33554](https://github.com/nodejs/node/pull/33554)
-* [[`05cbd8f6f2`](https://github.com/nodejs/node/commit/05cbd8f6f2)] - **src**: use const in constant args.Length() (himself65) [#33555](https://github.com/nodejs/node/pull/33555)
-* [[`48035a2a35`](https://github.com/nodejs/node/commit/48035a2a35)] - **src**: use MaybeLocal::FromMaybe to return exception (Daniel Bevenius) [#33514](https://github.com/nodejs/node/pull/33514)
-* [[`e1050344f8`](https://github.com/nodejs/node/commit/e1050344f8)] - ***Revert*** "**src**: fix missing extra ca in tls.rootCertificates" (Eric Bickle) [#33313](https://github.com/nodejs/node/pull/33313)
-* [[`77b6298b67`](https://github.com/nodejs/node/commit/77b6298b67)] - **src**: remove BeforeExit callback list (Ben Noordhuis) [#33386](https://github.com/nodejs/node/pull/33386)
-* [[`a522c0e2c7`](https://github.com/nodejs/node/commit/a522c0e2c7)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty (Daniel Bevenius) [#33457](https://github.com/nodejs/node/pull/33457)
-* [[`0837c2cc99`](https://github.com/nodejs/node/commit/0837c2cc99)] - **src**: remove unused headers in src/util.h (Juan José Arboleda) [#33070](https://github.com/nodejs/node/pull/33070)
-* [[`6f6fb1fcf5`](https://github.com/nodejs/node/commit/6f6fb1fcf5)] - **src**: prefer make\_unique (Michael Dawson) [#33378](https://github.com/nodejs/node/pull/33378)
-* [[`c697b96dea`](https://github.com/nodejs/node/commit/c697b96dea)] - **src**: remove unnecessary else in base\_object-inl.h (Daniel Bevenius) [#33413](https://github.com/nodejs/node/pull/33413)
-* [[`abf04b245a`](https://github.com/nodejs/node/commit/abf04b245a)] - **src,build**: add --openssl-default-cipher-list (Daniel Bevenius) [#33708](https://github.com/nodejs/node/pull/33708)
-* [[`62edaaefc2`](https://github.com/nodejs/node/commit/62edaaefc2)] - **stream**: fix the spellings (antsmartian) [#33635](https://github.com/nodejs/node/pull/33635)
-* [[`998b22cbbc`](https://github.com/nodejs/node/commit/998b22cbbc)] - **test**: add test for Http2ServerResponse#\[writableCorked,cork,uncork\] (Pranshu Srivastava) [#33956](https://github.com/nodejs/node/pull/33956)
-* [[`9b8695fb35`](https://github.com/nodejs/node/commit/9b8695fb35)] - **test**: account for non-node basename (Shelley Vohr) [#33952](https://github.com/nodejs/node/pull/33952)
-* [[`b9f8034f95`](https://github.com/nodejs/node/commit/b9f8034f95)] - **test**: fix typo in common/index.js (gengjiawen) [#33976](https://github.com/nodejs/node/pull/33976)
-* [[`7744f66e0d`](https://github.com/nodejs/node/commit/7744f66e0d)] - **test**: print arguments passed to mustNotCall function (Denys Otrishko) [#33951](https://github.com/nodejs/node/pull/33951)
-* [[`b5113d0b53`](https://github.com/nodejs/node/commit/b5113d0b53)] - **test**: temporarily exclude test on arm (Michael Dawson) [#33814](https://github.com/nodejs/node/pull/33814)
-* [[`c50bd2f954`](https://github.com/nodejs/node/commit/c50bd2f954)] - **test**: fix invalid regular expressions in case test-trace-exit (legendecas) [#33769](https://github.com/nodejs/node/pull/33769)
-* [[`d374e76428`](https://github.com/nodejs/node/commit/d374e76428)] - **test**: changed function to arrow function (Sagar Jadhav) [#33711](https://github.com/nodejs/node/pull/33711)
-* [[`0982bf4234`](https://github.com/nodejs/node/commit/0982bf4234)] - **test**: uv\_tty\_init now returns EINVAL on IBM i (Xu Meng) [#33629](https://github.com/nodejs/node/pull/33629)
-* [[`3032f0f38d`](https://github.com/nodejs/node/commit/3032f0f38d)] - **test**: make flaky test stricter (Robert Nagy) [#33539](https://github.com/nodejs/node/pull/33539)
-* [[`ef27e6ce57`](https://github.com/nodejs/node/commit/ef27e6ce57)] - **test**: mark test-dgram-multicast-ssmv6-multi-process flaky (AshCripps) [#33498](https://github.com/nodejs/node/pull/33498)
-* [[`a131c72586`](https://github.com/nodejs/node/commit/a131c72586)] - **tools**: enable no-else-return lint rule (Luigi Pinca) [#32667](https://github.com/nodejs/node/pull/32667)
-* [[`6651bde34e`](https://github.com/nodejs/node/commit/6651bde34e)] - **tools**: update remark-preset-lint-node@1.15.1 to 1.16.0 (Rich Trott) [#33852](https://github.com/nodejs/node/pull/33852)
-* [[`2e38f0dafd`](https://github.com/nodejs/node/commit/2e38f0dafd)] - **tools**: remove superfluous regex in tools/doc/json.js (Rich Trott) [#33998](https://github.com/nodejs/node/pull/33998)
-* [[`ba813dd0dd`](https://github.com/nodejs/node/commit/ba813dd0dd)] - **tools**: prevent js2c from running if nothing changed (Daniel Bevenius) [#33844](https://github.com/nodejs/node/pull/33844)
-* [[`fd5ab63d96`](https://github.com/nodejs/node/commit/fd5ab63d96)] - **tools**: remove unused vector include in mkdcodecache (Daniel Bevenius) [#33828](https://github.com/nodejs/node/pull/33828)
-* [[`54a4a816a4`](https://github.com/nodejs/node/commit/54a4a816a4)] - **tools**: update ESLint to 7.2.0 (Colin Ihrig) [#33776](https://github.com/nodejs/node/pull/33776)
-* [[`5328089c91`](https://github.com/nodejs/node/commit/5328089c91)] - **tools**: remove unused using declarations code\_cache (Daniel Bevenius) [#33697](https://github.com/nodejs/node/pull/33697)
-* [[`2f02fbac3a`](https://github.com/nodejs/node/commit/2f02fbac3a)] - **tools**: update remark-preset-lint-node from 1.15.0 to 1.15.1 (Rich Trott) [#33727](https://github.com/nodejs/node/pull/33727)
-* [[`3d05e3d861`](https://github.com/nodejs/node/commit/3d05e3d861)] - **tools**: fix check-imports.py to match on word boundaries (Richard Lau) [#33268](https://github.com/nodejs/node/pull/33268)
-* [[`ff4f9a9247`](https://github.com/nodejs/node/commit/ff4f9a9247)] - **tools**: update ESLint to 7.1.0 (Colin Ihrig) [#33526](https://github.com/nodejs/node/pull/33526)
-* [[`f495ab3dcb`](https://github.com/nodejs/node/commit/f495ab3dcb)] - **tools**: add docserve target (Antoine du HAMEL) [#33221](https://github.com/nodejs/node/pull/33221)
-* [[`a9dbb224af`](https://github.com/nodejs/node/commit/a9dbb224af)] - **util**: fix width detection for DEL without ICU (Ruben Bridgewater) [#33650](https://github.com/nodejs/node/pull/33650)
-* [[`02ae3f5625`](https://github.com/nodejs/node/commit/02ae3f5625)] - **util**: support Combining Diacritical Marks for Symbols (Ruben Bridgewater) [#33650](https://github.com/nodejs/node/pull/33650)
-* [[`524b230143`](https://github.com/nodejs/node/commit/524b230143)] - **util**: gracefully handle unknown colors (Ruben Bridgewater) [#33797](https://github.com/nodejs/node/pull/33797)
-* [[`e3533ab337`](https://github.com/nodejs/node/commit/e3533ab337)] - **util**: mark classes while inspecting them (Ruben Bridgewater) [#32332](https://github.com/nodejs/node/pull/32332)
-* [[`c4129f91e8`](https://github.com/nodejs/node/commit/c4129f91e8)] - **vm**: allow proxy callbacks to throw (Gus Caplan) [#33808](https://github.com/nodejs/node/pull/33808)
-* [[`8adfb542eb`](https://github.com/nodejs/node/commit/8adfb542eb)] - **wasi**: allow WASI stdio to be configured (Colin Ihrig) [#33544](https://github.com/nodejs/node/pull/33544)
-* [[`33984d6e4d`](https://github.com/nodejs/node/commit/33984d6e4d)] - **wasi**: simplify WASI memory management (Colin Ihrig) [#33525](https://github.com/nodejs/node/pull/33525)
-* [[`5e5be9929b`](https://github.com/nodejs/node/commit/5e5be9929b)] - **wasi**: refactor and enable poll\_oneoff() test (Colin Ihrig) [#33521](https://github.com/nodejs/node/pull/33521)
-* [[`383c5b3962`](https://github.com/nodejs/node/commit/383c5b3962)] - **wasi**: relax WebAssembly.Instance type check (Ben Noordhuis) [#33431](https://github.com/nodejs/node/pull/33431)
-* [[`7df79f498c`](https://github.com/nodejs/node/commit/7df79f498c)] - **wasi,worker**: handle termination exception (Ben Noordhuis) [#33386](https://github.com/nodejs/node/pull/33386)
-* [[`3b46e7f148`](https://github.com/nodejs/node/commit/3b46e7f148)] - **win,fs**: use namespaced path in absolute symlinks (Bartosz Sosnowski) [#33351](https://github.com/nodejs/node/pull/33351)
-* [[`4388dad537`](https://github.com/nodejs/node/commit/4388dad537)] - **win,msi**: add arm64 config for windows msi (Dennis Ameling) [#33689](https://github.com/nodejs/node/pull/33689)
-* [[`032c64f1e4`](https://github.com/nodejs/node/commit/032c64f1e4)] - **worker**: fix variable referencing in template string (Harshitha KP) [#33467](https://github.com/nodejs/node/pull/33467)
-* [[`1c64bc5e34`](https://github.com/nodejs/node/commit/1c64bc5e34)] - **worker**: perform initial port.unref() before preload modules (Anna Henningsen) [#33455](https://github.com/nodejs/node/pull/33455)
-* [[`c502384ab7`](https://github.com/nodejs/node/commit/c502384ab7)] - **worker**: use \_writev in internal communication (Anna Henningsen) [#33454](https://github.com/nodejs/node/pull/33454)
-
-<a id="12.18.2"></a>
-## 2020-06-30, Version 12.18.2 'Erbium' (LTS), @BethGriggs
-
-### Notable changes
-
-* **deps**: V8: backport fb26d0bb1835 (Matheus Marchini) [#33573](https://github.com/nodejs/node/pull/33573)
-  * Fixes memory leak in `PrototypeUsers::Add`
-* **src**: use symbol to store `AsyncWrap` resource (Anna Henningsen) [#31745](https://github.com/nodejs/node/pull/31745)
-  * Fixes reported memory leak in [#33468](https://github.com/nodejs/node/issues/33468)
-
-### Commits
-
-* [[`97a3f7b702`](https://github.com/nodejs/node/commit/97a3f7b702)] - **deps**: V8: backport fb26d0bb1835 (Matheus Marchini) [#33573](https://github.com/nodejs/node/pull/33573)
-* [[`30b0339061`](https://github.com/nodejs/node/commit/30b0339061)] - **src**: use symbol to store `AsyncWrap` resource (Anna Henningsen) [#31745](https://github.com/nodejs/node/pull/31745)
-
-<a id="12.18.1"></a>
-## 2020-06-17, Version 12.18.1 'Erbium' (LTS), @codebytere
-
-### Notable Changes
-
-* **deps**:
-  * V8: cherry-pick 548f6c81d424 (Dominykas Blyžė) [#33484](https://github.com/nodejs/node/pull/33484)
-  * update to uvwasi 0.0.9 (Colin Ihrig) [#33445](https://github.com/nodejs/node/pull/33445)
-  * upgrade to libuv 1.38.0 (Colin Ihrig) [#33446](https://github.com/nodejs/node/pull/33446)
-  * upgrade npm to 6.14.5 (Ruy Adorno) [#33239](https://github.com/nodejs/node/pull/33239)
-
-### Commits
-
-* [[`ba93c8d87d`](https://github.com/nodejs/node/commit/ba93c8d87d)] - **async_hooks**: clear async\_id\_stack for terminations in more places (Anna Henningsen) [#33347](https://github.com/nodejs/node/pull/33347)
-* [[`964adfafa5`](https://github.com/nodejs/node/commit/964adfafa5)] - **buffer**: improve copy() performance (Nikolai Vavilov) [#33214](https://github.com/nodejs/node/pull/33214)
-* [[`af95bd70bd`](https://github.com/nodejs/node/commit/af95bd70bd)] - **deps**: V8: cherry-pick 548f6c81d424 (Dominykas Blyžė) [#33484](https://github.com/nodejs/node/pull/33484)
-* [[`5c7176bf90`](https://github.com/nodejs/node/commit/5c7176bf90)] - **deps**: update to uvwasi 0.0.9 (Colin Ihrig) [#33445](https://github.com/nodejs/node/pull/33445)
-* [[`402aa1b840`](https://github.com/nodejs/node/commit/402aa1b840)] - **deps**: upgrade to libuv 1.38.0 (Colin Ihrig) [#33446](https://github.com/nodejs/node/pull/33446)
-* [[`4d6f56a76a`](https://github.com/nodejs/node/commit/4d6f56a76a)] - **deps**: upgrade npm to 6.14.5 (Ruy Adorno) [#33239](https://github.com/nodejs/node/pull/33239)
-* [[`98a7026311`](https://github.com/nodejs/node/commit/98a7026311)] - **doc**: document module.path (Antoine du Hamel) [#33323](https://github.com/nodejs/node/pull/33323)
-* [[`9572701705`](https://github.com/nodejs/node/commit/9572701705)] - **doc**: add fs.open() multiple constants example (Ethan Arrowood) [#33281](https://github.com/nodejs/node/pull/33281)
-* [[`7d8a226958`](https://github.com/nodejs/node/commit/7d8a226958)] - **doc**: fix typos in handle scope descriptions (Tobias Nießen) [#33267](https://github.com/nodejs/node/pull/33267)
-* [[`0c9b826ef8`](https://github.com/nodejs/node/commit/0c9b826ef8)] - **doc**: update function description for `decipher.setAAD` (Jonathan Buhacoff) [#33095](https://github.com/nodejs/node/pull/33095)
-* [[`4749156f4b`](https://github.com/nodejs/node/commit/4749156f4b)] - **doc**: add comment about highWaterMark limit (Benjamin Gruenbaum) [#33432](https://github.com/nodejs/node/pull/33432)
-* [[`a48aeb3f74`](https://github.com/nodejs/node/commit/a48aeb3f74)] - **doc**: clarify about the Node.js-only extensions in perf\_hooks (Joyee Cheung) [#33199](https://github.com/nodejs/node/pull/33199)
-* [[`a9ed287f00`](https://github.com/nodejs/node/commit/a9ed287f00)] - **doc**: fix extension in esm example (Gus Caplan) [#33408](https://github.com/nodejs/node/pull/33408)
-* [[`d2897a2836`](https://github.com/nodejs/node/commit/d2897a2836)] - **doc**: enhance guides by fixing and making grammar more consistent (Chris Holland) [#33152](https://github.com/nodejs/node/pull/33152)
-* [[`3d8ba292e2`](https://github.com/nodejs/node/commit/3d8ba292e2)] - **doc**: add examples for implementing ESM (unknown) [#33168](https://github.com/nodejs/node/pull/33168)
-* [[`318fcf8188`](https://github.com/nodejs/node/commit/318fcf8188)] - **doc**: add note about clientError writable handling (Paolo Insogna) [#33308](https://github.com/nodejs/node/pull/33308)
-* [[`30c9cb556f`](https://github.com/nodejs/node/commit/30c9cb556f)] - **doc**: fix typo in n-api.md (Daniel Bevenius) [#33319](https://github.com/nodejs/node/pull/33319)
-* [[`9dde1db332`](https://github.com/nodejs/node/commit/9dde1db332)] - **doc**: add warning for socket.connect reuse (Robert Nagy) [#33204](https://github.com/nodejs/node/pull/33204)
-* [[`0c7cf24431`](https://github.com/nodejs/node/commit/0c7cf24431)] - **doc**: correct description of `decipher.setAuthTag` in crypto.md (Jonathan Buhacoff)
-* [[`59619b0c9a`](https://github.com/nodejs/node/commit/59619b0c9a)] - **doc**: mention python3-distutils dependency in BUILDING.md (osher) [#33174](https://github.com/nodejs/node/pull/33174)
-* [[`0cee4c3eae`](https://github.com/nodejs/node/commit/0cee4c3eae)] - **doc**: removed unnecessary util imports from vm examples (Karol Walasek) [#33179](https://github.com/nodejs/node/pull/33179)
-* [[`903862089b`](https://github.com/nodejs/node/commit/903862089b)] - **doc**: update Buffer(size) documentation (Nikolai Vavilov) [#33198](https://github.com/nodejs/node/pull/33198)
-* [[`8b44be9b26`](https://github.com/nodejs/node/commit/8b44be9b26)] - **doc**: add Uint8Array to `end` and `write` (Pranshu Srivastava) [#33217](https://github.com/nodejs/node/pull/33217)
-* [[`4a584200f8`](https://github.com/nodejs/node/commit/4a584200f8)] - **doc**: specify unit of time passed to `fs.utimes` (Simen Bekkhus) [#33230](https://github.com/nodejs/node/pull/33230)
-* [[`ad7a890597`](https://github.com/nodejs/node/commit/ad7a890597)] - **doc**: add troubleshooting guide for AsyncLocalStorage (Andrey Pechkurov) [#33248](https://github.com/nodejs/node/pull/33248)
-* [[`2262962ab7`](https://github.com/nodejs/node/commit/2262962ab7)] - **doc**: remove AsyncWrap mentions from async\_hooks.md (Andrey Pechkurov) [#33249](https://github.com/nodejs/node/pull/33249)
-* [[`ac5cdd682a`](https://github.com/nodejs/node/commit/ac5cdd682a)] - **doc**: add warnings about transferring Buffers and ArrayBuffer (James M Snell) [#33252](https://github.com/nodejs/node/pull/33252)
-* [[`033bc96ec1`](https://github.com/nodejs/node/commit/033bc96ec1)] - **doc**: update napi\_async\_init documentation (Michael Dawson) [#33181](https://github.com/nodejs/node/pull/33181)
-* [[`ea3a68f74f`](https://github.com/nodejs/node/commit/ea3a68f74f)] - **doc**: doc and test URLSearchParams discrepancy (James M Snell) [#33236](https://github.com/nodejs/node/pull/33236)
-* [[`c6cf0483f2`](https://github.com/nodejs/node/commit/c6cf0483f2)] - **doc**: explicitly doc package.exports is breaking (Myles Borins) [#33074](https://github.com/nodejs/node/pull/33074)
-* [[`e572cf93e5`](https://github.com/nodejs/node/commit/e572cf93e5)] - **doc**: fix style and grammer in buffer.md (Nikolai Vavilov) [#33194](https://github.com/nodejs/node/pull/33194)
-* [[`5d80576889`](https://github.com/nodejs/node/commit/5d80576889)] - **errors**: skip fatal error highlighting on windows (Thomas) [#33132](https://github.com/nodejs/node/pull/33132)
-* [[`a029dca90e`](https://github.com/nodejs/node/commit/a029dca90e)] - **esm**: improve commonjs hint on module not found (Antoine du Hamel) [#33220](https://github.com/nodejs/node/pull/33220)
-* [[`c129e8809e`](https://github.com/nodejs/node/commit/c129e8809e)] - **fs**: forbid concurrent operations on Dir handle (Anna Henningsen) [#33274](https://github.com/nodejs/node/pull/33274)
-* [[`aa4611cccb`](https://github.com/nodejs/node/commit/aa4611cccb)] - **fs**: clean up Dir.read() uv\_fs\_t data before calling into JS (Anna Henningsen) [#33274](https://github.com/nodejs/node/pull/33274)
-* [[`fa4a37c57b`](https://github.com/nodejs/node/commit/fa4a37c57b)] - **http2**: comment on usage of `Object.create(null)` (Pranshu Srivastava) [#33183](https://github.com/nodejs/node/pull/33183)
-* [[`66dbaff848`](https://github.com/nodejs/node/commit/66dbaff848)] - **http2**: add `bytesWritten` test for `Http2Stream` (Pranshu Srivastava) [#33162](https://github.com/nodejs/node/pull/33162)
-* [[`59769c4d14`](https://github.com/nodejs/node/commit/59769c4d14)] - **lib**: fix typo in timers insert function comment (Daniel Bevenius) [#33301](https://github.com/nodejs/node/pull/33301)
-* [[`6881410951`](https://github.com/nodejs/node/commit/6881410951)] - **lib**: refactored scheduling policy assignment (Yash Ladha) [#32663](https://github.com/nodejs/node/pull/32663)
-* [[`9017bce54b`](https://github.com/nodejs/node/commit/9017bce54b)] - **lib**: fix grammar in internal/bootstrap/loaders.js (szTheory) [#33211](https://github.com/nodejs/node/pull/33211)
-* [[`d64dbfa1e7`](https://github.com/nodejs/node/commit/d64dbfa1e7)] - **meta**: add issue template for API reference docs (Derek Lewis) [#32944](https://github.com/nodejs/node/pull/32944)
-* [[`4f6e4ae49d`](https://github.com/nodejs/node/commit/4f6e4ae49d)] - **module**: add specific error for dir import (Antoine du HAMEL) [#33220](https://github.com/nodejs/node/pull/33220)
-* [[`77caf92314`](https://github.com/nodejs/node/commit/77caf92314)] - **module**: better error for named exports from cjs (Myles Borins) [#33256](https://github.com/nodejs/node/pull/33256)
-* [[`82da74b1cd`](https://github.com/nodejs/node/commit/82da74b1cd)] - **n-api**: add uint32 test for -1 (Gabriel Schulhof)
-* [[`68551d22d2`](https://github.com/nodejs/node/commit/68551d22d2)] - **perf_hooks**: fix error message for invalid entryTypes (Michaël Zasso) [#33285](https://github.com/nodejs/node/pull/33285)
-* [[`e67df04df2`](https://github.com/nodejs/node/commit/e67df04df2)] - **src**: use BaseObjectPtr in StreamReq::Dispose (James M Snell) [#33102](https://github.com/nodejs/node/pull/33102)
-* [[`c797c7c7ab`](https://github.com/nodejs/node/commit/c797c7c7ab)] - **src**: reduce duplication in RegisterHandleCleanups (Daniel Bevenius) [#33421](https://github.com/nodejs/node/pull/33421)
-* [[`548db2e5b9`](https://github.com/nodejs/node/commit/548db2e5b9)] - **src**: remove unused IsolateSettings variable (Daniel Bevenius) [#33417](https://github.com/nodejs/node/pull/33417)
-* [[`e668376b5b`](https://github.com/nodejs/node/commit/e668376b5b)] - **src**: remove unused misc variable (Daniel Bevenius) [#33417](https://github.com/nodejs/node/pull/33417)
-* [[`9883ba6ddd`](https://github.com/nodejs/node/commit/9883ba6ddd)] - **src**: add promise\_resolve to SetupHooks comment (Daniel Bevenius) [#33365](https://github.com/nodejs/node/pull/33365)
-* [[`b924910fe7`](https://github.com/nodejs/node/commit/b924910fe7)] - **src**: distinguish refed/unrefed threadsafe Immediates (Anna Henningsen) [#33320](https://github.com/nodejs/node/pull/33320)
-* [[`29d24db914`](https://github.com/nodejs/node/commit/29d24db914)] - **src**: add #include \<string\> in json\_utils.h (Cheng Zhao) [#33332](https://github.com/nodejs/node/pull/33332)
-* [[`a0bc2e3b64`](https://github.com/nodejs/node/commit/a0bc2e3b64)] - **src**: replace to CHECK\_NOT\_NULL in node\_crypto (himself65) [#33383](https://github.com/nodejs/node/pull/33383)
-* [[`1f159e45f2`](https://github.com/nodejs/node/commit/1f159e45f2)] - **src**: add primordials to arguments comment (Daniel Bevenius) [#33318](https://github.com/nodejs/node/pull/33318)
-* [[`fe780a5fe0`](https://github.com/nodejs/node/commit/fe780a5fe0)] - **src**: remove unused using declarations in node.cc (Daniel Bevenius) [#33261](https://github.com/nodejs/node/pull/33261)
-* [[`82c43d1594`](https://github.com/nodejs/node/commit/82c43d1594)] - **src**: delete unused variables to resolve compile time print warning (rickyes) [#33358](https://github.com/nodejs/node/pull/33358)
-* [[`548672d39c`](https://github.com/nodejs/node/commit/548672d39c)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty (Daniel Bevenius) [#33312](https://github.com/nodejs/node/pull/33312)
-* [[`f27ae6ef46`](https://github.com/nodejs/node/commit/f27ae6ef46)] - **src**: fix typo in comment in async\_wrap.cc (Daniel Bevenius) [#33350](https://github.com/nodejs/node/pull/33350)
-* [[`b6300793fb`](https://github.com/nodejs/node/commit/b6300793fb)] - **src**: remove unnecessary Isolate::GetCurrent() calls (Anna Henningsen) [#33298](https://github.com/nodejs/node/pull/33298)
-* [[`642f81317e`](https://github.com/nodejs/node/commit/642f81317e)] - **src**: fix invalid windowBits=8 gzip segfault (Ben Noordhuis) [#33045](https://github.com/nodejs/node/pull/33045)
-* [[`a5e8c5ce0d`](https://github.com/nodejs/node/commit/a5e8c5ce0d)] - **src**: split out callback queue implementation from Environment (Anna Henningsen) [#33272](https://github.com/nodejs/node/pull/33272)
-* [[`ed62d43e79`](https://github.com/nodejs/node/commit/ed62d43e79)] - **src**: clean up large pages code (Gabriel Schulhof) [#33255](https://github.com/nodejs/node/pull/33255)
-* [[`c05483483f`](https://github.com/nodejs/node/commit/c05483483f)] - ***Revert*** "**src**: add test/abort build tasks" (Richard Lau) [#33196](https://github.com/nodejs/node/pull/33196)
-* [[`b43fc64aa7`](https://github.com/nodejs/node/commit/b43fc64aa7)] - ***Revert*** "**src**: add aliased-buffer-overflow abort test" (Richard Lau) [#33196](https://github.com/nodejs/node/pull/33196)
-* [[`edf75e4299`](https://github.com/nodejs/node/commit/edf75e4299)] - **src**: use basename(argv0) for --trace-uncaught suggestion (Anna Henningsen) [#32798](https://github.com/nodejs/node/pull/32798)
-* [[`4294d92b26`](https://github.com/nodejs/node/commit/4294d92b26)] - **stream**: make from read one at a time (Robert Nagy) [#33201](https://github.com/nodejs/node/pull/33201)
-* [[`194789f25b`](https://github.com/nodejs/node/commit/194789f25b)] - **stream**: make all streams error in a pipeline (Matteo Collina) [#30869](https://github.com/nodejs/node/pull/30869)
-* [[`5da7d52a9f`](https://github.com/nodejs/node/commit/5da7d52a9f)] - **test**: regression tests for async\_hooks + Promise + Worker interaction (Anna Henningsen) [#33347](https://github.com/nodejs/node/pull/33347)
-* [[`9f594be75a`](https://github.com/nodejs/node/commit/9f594be75a)] - **test**: fix test-dns-idna2008 (Rich Trott) [#33367](https://github.com/nodejs/node/pull/33367)
-* [[`33a787873f`](https://github.com/nodejs/node/commit/33a787873f)] - **test**: refactor WPTRunner (Joyee Cheung) [#33297](https://github.com/nodejs/node/pull/33297)
-* [[`fa1631355f`](https://github.com/nodejs/node/commit/fa1631355f)] - **test**: update WPT interfaces and hr-time (Joyee Cheung) [#33297](https://github.com/nodejs/node/pull/33297)
-* [[`c459832e4b`](https://github.com/nodejs/node/commit/c459832e4b)] - **test**: fix test-net-throttle (Rich Trott) [#33329](https://github.com/nodejs/node/pull/33329)
-* [[`cd92052935`](https://github.com/nodejs/node/commit/cd92052935)] - **test**: add hr-time Web platform tests (Michaël Zasso) [#33287](https://github.com/nodejs/node/pull/33287)
-* [[`0177cbf9e0`](https://github.com/nodejs/node/commit/0177cbf9e0)] - **test**: rename test-lookupService-promises (rickyes) [#33100](https://github.com/nodejs/node/pull/33100)
-* [[`139eb6bd68`](https://github.com/nodejs/node/commit/139eb6bd68)] - **test**: skip some console tests on dumb terminal (Adam Majer) [#33165](https://github.com/nodejs/node/pull/33165)
-* [[`1766514c5b`](https://github.com/nodejs/node/commit/1766514c5b)] - **test**: add tests for options.fs in fs streams (Julian Duque) [#33185](https://github.com/nodejs/node/pull/33185)
-* [[`7315c2288a`](https://github.com/nodejs/node/commit/7315c2288a)] - **tls**: fix --tls-keylog option (Alba Mendez) [#33366](https://github.com/nodejs/node/pull/33366)
-* [[`e240d56983`](https://github.com/nodejs/node/commit/e240d56983)] - **tools**: update dependencies for markdown linting (Rich Trott) [#33412](https://github.com/nodejs/node/pull/33412)
-* [[`2645b1c85b`](https://github.com/nodejs/node/commit/2645b1c85b)] - **tools**: update ESLint to 7.0.0 (Colin Ihrig) [#33316](https://github.com/nodejs/node/pull/33316)
-* [[`cdd7d3a66d`](https://github.com/nodejs/node/commit/cdd7d3a66d)] - **tools**: remove obsolete no-restricted-syntax eslint rules (Ruben Bridgewater) [#32161](https://github.com/nodejs/node/pull/32161)
-* [[`5d5e66c10c`](https://github.com/nodejs/node/commit/5d5e66c10c)] - **tools**: add eslint rule to only pass through 'test' to debuglog (Ruben Bridgewater) [#32161](https://github.com/nodejs/node/pull/32161)
-* [[`22f2c2c871`](https://github.com/nodejs/node/commit/22f2c2c871)] - **wasi**: fix poll\_oneoff memory interface (Colin Ihrig) [#33250](https://github.com/nodejs/node/pull/33250)
-* [[`33aacbefb1`](https://github.com/nodejs/node/commit/33aacbefb1)] - **wasi**: prevent syscalls before start (Tobias Nießen) [#33235](https://github.com/nodejs/node/pull/33235)
-* [[`5eed20b3b7`](https://github.com/nodejs/node/commit/5eed20b3b7)] - **worker**: fix race condition in node\_messaging.cc (Anna Henningsen) [#33429](https://github.com/nodejs/node/pull/33429)
-* [[`b4d903402b`](https://github.com/nodejs/node/commit/b4d903402b)] - **worker**: fix crash when .unref() is called during exit (Anna Henningsen) [#33394](https://github.com/nodejs/node/pull/33394)
-* [[`8a926982e5`](https://github.com/nodejs/node/commit/8a926982e5)] - **worker**: call CancelTerminateExecution() before exiting Locker (Anna Henningsen) [#33347](https://github.com/nodejs/node/pull/33347)
-* [[`631e433cf5`](https://github.com/nodejs/node/commit/631e433cf5)] - **zlib**: reject windowBits=8 when mode=GZIP (Ben Noordhuis) [#33045](https://github.com/nodejs/node/pull/33045)
-
-<a id="12.18.0"></a>
-## 2020-06-02, Version 12.18.0 'Erbium' (LTS), @targos
-
-### Notable changes
-
-This is a security release.
-
-Vulnerabilities fixed:
-* **CVE-2020-8172**: TLS session reuse can lead to host certificate verification bypass (High).
-* **CVE-2020-11080**: HTTP/2 Large Settings Frame DoS (Low).
-* **CVE-2020-8174**: `napi_get_value_string_*()` allows various kinds of memory corruption (High).
-
-### Commits
-
-* [[`c6d0bdacc4`](https://github.com/nodejs/node/commit/c6d0bdacc4)] - **crypto**: update root certificates (AshCripps) [#33682](https://github.com/nodejs/node/pull/33682)
-* [[`916b2824d1`](https://github.com/nodejs/node/commit/916b2824d1)] - **(SEMVER-MINOR)** **deps**: update nghttp2 to 1.41.0 (James M Snell) [nodejs-private/node-private#206](https://github.com/nodejs-private/node-private/pull/206)
-* [[`d381426377`](https://github.com/nodejs/node/commit/d381426377)] - **(SEMVER-MINOR)** **http2**: implement support for max settings entries (James M Snell) [nodejs-private/node-private#206](https://github.com/nodejs-private/node-private/pull/206)
-* [[`7dd8982570`](https://github.com/nodejs/node/commit/7dd8982570)] - **napi**: fix memory corruption vulnerability (Tobias Nießen) [nodejs-private/node-private#195](https://github.com/nodejs-private/node-private/pull/195)
-* [[`0932309af2`](https://github.com/nodejs/node/commit/0932309af2)] - **tls**: emit `session` after verifying certificate (Fedor Indutny) [nodejs-private/node-private#200](https://github.com/nodejs-private/node-private/pull/200)
-* [[`c392d3923f`](https://github.com/nodejs/node/commit/c392d3923f)] - **tools**: update certdata.txt (AshCripps) [#33682](https://github.com/nodejs/node/pull/33682)
-
-<a id="12.17.0"></a>
-## 2020-05-26, Version 12.17.0 'Erbium' (LTS), @targos
-
-### Notable Changes
-
-#### ECMAScript Modules - `--experimental-modules` flag removal
-
-As of Node.js 12.17.0, the `--experimental-modules` flag is no longer necessary
-to use ECMAScript modules (ESM). However, the ESM implementation in Node.js
-remains experimental. As per our stability index: “The feature is not subject
-to Semantic Versioning rules. Non-backward compatible changes or removal may
-occur in any future release.” Users should be cautious when using the feature
-in production environments.
-
-Unlike Node.js 14, using ESM will still emit a runtime experimental warning,
-either when a module is used a the application's entrypoint or the first time
-dynamic `import()` is called.
-
-Please keep in mind that the implementation of ESM in Node.js differs from the
-developer experience you might be familiar with. Most transpilation workflows
-support features such as named exports from CommonJS module imports, optional
-file extensions or JSON modules that the Node.js ESM implementation does not
-support. It is highly likely that modules from transpiled environments will
-require a certain degree of refactoring to work in Node.js. It is worth
-mentioning that many of our design decisions were made with two primary goals.
-Spec compliance and Web Compatibility. It is our belief that the current
-implementation offers a future proof model to authoring ESM modules that paves
-the path to Universal JavaScript. Please read more in our documentation.
-
-The ESM implementation in Node.js is still experimental but we do believe that
-we are getting very close to being able to call ESM in Node.js “stable”.
-Removing the flag is a huge step in that direction.
-
-We expect to remove the warning Node.js 12 later this year, possibly in late
-October, when Node.js 14 will become LTS.
-
-#### AsyncLocalStorage API (experimental)
-
-The `AsyncLocalStorage` class has been introduced in the Async Hooks module.
-
-This API allows keeping a context across asynchronous operations. For instance,
-if a sequence id is stored within an instance of `AsyncLocalStorage` for each
-HTTP request entering in a server, it will be possible to retrieve this id
-without having access the current HTTP request:
-
-```js
-const http = require('http');
-const { AsyncLocalStorage } = require('async_hooks');
-
-const asyncLocalStorage = new AsyncLocalStorage();
-
-function logWithId(msg) {
-  const id = asyncLocalStorage.getStore();
-  console.log(`${id !== undefined ? id : '-'}: `, msg);
-}
-
-let idSeq = 0;
-http.createServer((req, res) => {
-  asyncLocalStorage.run(idSeq++, () => {
-    logWithId('start');
-    // Imagine any chain of async operations here.
-    setImmediate(() => {
-      logWithId('finish');
-      res.end();
-    });
-  });
-}).listen(8080);
-```
-
-In this example, the `logWithId` function will always know what the current
-request id is, even when there are multiple requests in parallel.
-
-##### What can this API be used for
-
-Use cases of this API include:
-* Logging
-* User identification
-* Performance tracking
-* Error tracking and handling
-* Much more!
-
-*Note: This API is still experimental and some methods might change in future releases of Node.js*
-
-Contributed by Vladimir de Turckheim - [#26540](https://github.com/nodejs/node/pull/26540).
-
-#### REPL previews
-
-If further input is predicable, a suggestion is inserted as preview.
-
-The REPL now supports previews similar to the Chrome DevTools console. An input
-suggestion is inserted as preview in case further input is predicable. The
-suggestion may be accepted by either pressing `<TAB>` or `<RIGHT>` at the end of
-the input.
-On top of that, output is previewed when entering variable names or function
-calls that have no side effect.
-
-![image](https://user-images.githubusercontent.com/8822573/80928108-afb03300-8da2-11ea-8898-499d8c2dbc7a.png)
-![image](https://user-images.githubusercontent.com/8822573/80928118-c191d600-8da2-11ea-9739-32e8becc68fe.png)
-
-[Check the preview in action](https://asciinema.org/a/ePQx0GfCYQGdnQTzwlnSIyxbN)
-and try it out on your own. Just access the REPL on your terminal by starting
-the Node.js executable without any further command.
-
-Contributed by Ruben Bridgewater - [#30907](https://github.com/nodejs/node/pull/30907), [#30811](https://github.com/nodejs/node/pull/30811).
-
-#### REPL reverse-i-search
-
-The REPL supports bi-directional reverse-i-search similar to
-[ZSH](https://en.wikipedia.org/wiki/Z_shell). It is triggered with `<ctrl> + R`
-to search backwards and `<ctrl> + S` to search forwards.
-
-Entries are accepted as soon as any button is pressed that doesn't correspond
-with the reverse search. Cancelling is possible by pressing `escape` or
-`<ctrl> + C`.
-
-Changing the direction immediately searches for the next entry in the expected
-direction from the current position on.
-
-![image](https://user-images.githubusercontent.com/8822573/80928291-f3f00300-8da3-11ea-97d8-12e85e2e3d2c.png)
-
-[Reverse-i-search in action](https://asciinema.org/a/shV3YOFu74BcBakJcvY4USNqv).
-
-Contributed by Ruben Bridgewater - [#31006](https://github.com/nodejs/node/pull/31006).
-
-#### REPL substring-based search
-
-It is now possible to access former history entries very fast by writing the
-first characters of the formerly entered code you are looking for. Then push
-`<UP>` or `<DOWN>` to go through the history entries that start with those
-characters.
-
-It works similar to the [Fish Shell](https://fishshell.com/) substring-based
-history search.
-
-Contributed by Ruben Bridgewater - [#31112](https://github.com/nodejs/node/pull/31112).
-
-#### Error monitoring
-
-##### Monitoring `error` events
-
-It is now possible to monitor `'error'` events on an `EventEmitter` without
-consuming the emitted error by installing a listener using the symbol
-`EventEmitter.errorMonitor`:
-
-```js
-const myEmitter = new MyEmitter();
-
-myEmitter.on(EventEmitter.errorMonitor, (err) => {
-  MyMonitoringTool.log(err);
-});
-
-myEmitter.emit('error', new Error('whoops!'));
-// Still throws and crashes Node.js
-```
-
-Contributed by Gerhard Stoebich - [#30932](https://github.com/nodejs/node/pull/30932).
-
-#### Monitoring uncaught exceptions
-
-It is now possible to monitor `'uncaughtException'` events without overriding
-the default behavior that exits the process by installing an
-`'uncaughtExceptionMonitor'` listener:
-
-```js
-process.on('uncaughtExceptionMonitor', (err, origin) => {
-  MyMonitoringTool.logSync(err, origin);
-});
-
-// Intentionally cause an exception, but do not catch it.
-nonexistentFunc();
-// Still crashes Node.js
-```
-
-Contributed by Gerhard Stoebich - [#31257](https://github.com/nodejs/node/pull/31257).
-
-#### File system APIs
-
-##### New function: `fs.readv`
-
-This new function (along with its sync and promisified versions) takes an array
-of `ArrayBufferView` elements and will write the data it reads sequentially to
-the buffers.
-
-Contributed by Sk Sajidul Kadir - [#32356](https://github.com/nodejs/node/pull/32356).
-
-##### Optional parameters in `fs.read`
-
-A new overload is available for `fs.read` (along with its sync and promisified
-versions), which allows to optionally pass any of the `offset`, `length` and
-`position` parameters.
-
-Contributed by Lucas Holmquist - [#31402](https://github.com/nodejs/node/pull/31402).
-
-#### Console `groupIndentation` option
-
-The Console constructor (`require('console').Console`) now supports different group indentations.
-
-This is useful in case you want different grouping width than 2 spaces.
-
-```js
-const { Console } = require('console');
-const customConsole = new Console({
-  stdout: process.stdout,
-  stderr: process.stderr,
-  groupIndentation: 10
-});
-
-customConsole.log('foo');
-// 'foo'
-customConsole.group();
-customConsole.log('foo');
-//           'foo'
-```
-
-Contributed by rickyes - [#32964](https://github.com/nodejs/node/pull/32964).
-
-#### `maxStringLength` option for `util.inspect()`
-
-It is now possible to limit the length of strings while inspecting objects.
-This is possible by passing through the `maxStringLength` option similar to:
-
-```js
-const { inspect } = require('util');
-
-const string = inspect(['a'.repeat(1e8)], { maxStringLength: 10 });
-
-console.log(string);
-// "[ 'aaaaaaaaaa'... 99999990 more characters ]"
-```
-
-Contributed by rosaxny - [#32392](https://github.com/nodejs/node/pull/32392).
-
-#### Stable N-API release 6
-
-The following N-API features are now stable as part of the N-API 6 release:
-
-* [`napi_set_instance_data`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_set_instance_data)
-* [`napi_get_instance_data`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_get_instance_data)
-* [`napi_key_collection_mode`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_key_collection_mode)
-* [`napi_key_filter`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_key_filter)
-* [`napi_key_conversion`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_key_conversion)
-* [`napi_create_bigint_int64`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_create_bigint_int64)
-* [`napi_create_bigint_uint64`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_create_bigint_uint64)
-* [`napi_create_bigint_words`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_create_bigint_words)
-* [`napi_get_value_bigint_int64`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_get_value_bigint_int64)
-* [`napi_get_value_bigint_uint64`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_get_value_bigint_uint64)
-* [`napi_get_value_bigint_words`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_get_value_bigint_words)
-* [`napi_get_all_property_names`](https://nodejs.org/dist/latest-v12.x/docs/api/n-api.html#n_api_napi_get_all_property_names)
-
-#### Stable diagnostic reports
-
-The [Diagnostic Report](https://nodejs.org/dist/latest-v12.x/docs/api/report.html)
-feature is now stable and supports a new `--report-compact` flag to write the
-reports in a compact, single-line JSON format, more easily consumable by log
-processing systems than the default multi-line format designed for human
-consumption.
-
-#### Increase of the default server headers timeout
-
-The default value of `server.headersTimeout` for `http` and `https` servers was
-increased from `40000` to `60000` (60 seconds). This to accomodate for systems
-like AWS ELB that have a timeout of 60 seconds.
-
-Contributed by Tim Costa - [#30071](https://github.com/nodejs/node/pull/30071).
-
-#### Other changes
-
-* **cli**:
-  * Added a `--trace-sigint` CLI flag that will print the current execution
-    stack on SIGINT (legendecas) [#29207](https://github.com/nodejs/node/pull/29207).
-* **crypto**:
-  * Various crypto APIs now support Diffie-Hellman secrets (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178).
-* **dns**:
-  * Added the `dns.ALL` flag, that can be passed to `dns.lookup()` with `dns.V4MAPPED`
-    to return resolved IPv6 addresses as well as IPv4 mapped IPv6 addresses (murgatroid99) [#32183](https://github.com/nodejs/node/pull/32183).
-* **module**
-  * Added a new experimental API to interact with Source Map V3 data (Benjamin Coe) [#31132](https://github.com/nodejs/node/pull/31132).
-* **worker**:
-  * Added support for passing a `transferList` along with `workerData` to the
-    `Worker` constructor (Juan José Arboleda) [#32278](https://github.com/nodejs/node/pull/32278).
-
-### Commits
-
-#### Semver-minor commits
-
-* [[`a35e88caf5`](https://github.com/nodejs/node/commit/a35e88caf5)] - **(SEMVER-MINOR)** **async_hooks**: merge run and exit methods (Andrey Pechkurov) [#31950](https://github.com/nodejs/node/pull/31950)
-* [[`3eb34068a2`](https://github.com/nodejs/node/commit/3eb34068a2)] - **(SEMVER-MINOR)** **async_hooks**: prevent sync methods of async storage exiting outer context (Stephen Belanger) [#31950](https://github.com/nodejs/node/pull/31950)
-* [[`22db34caa7`](https://github.com/nodejs/node/commit/22db34caa7)] - **(SEMVER-MINOR)** **async_hooks**: add sync enterWith to ALS (Stephen Belanger) [#31945](https://github.com/nodejs/node/pull/31945)
-* [[`16e8b11708`](https://github.com/nodejs/node/commit/16e8b11708)] - **(SEMVER-MINOR)** **async_hooks**: introduce async-context API (Vladimir de Turckheim) [#26540](https://github.com/nodejs/node/pull/26540)
-* [[`f7adfcc1df`](https://github.com/nodejs/node/commit/f7adfcc1df)] - **(SEMVER-MINOR)** **async_hooks**: add executionAsyncResource (Matteo Collina) [#30959](https://github.com/nodejs/node/pull/30959)
-* [[`984ae304f2`](https://github.com/nodejs/node/commit/984ae304f2)] - **(SEMVER-MINOR)** **build**: make --without-report a no-op (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
-* [[`e67b97ee53`](https://github.com/nodejs/node/commit/e67b97ee53)] - **(SEMVER-MINOR)** **cli**: allow --huge-max-old-generation-size in NODE\_OPTIONS (Anna Henningsen) [#32251](https://github.com/nodejs/node/pull/32251)
-* [[`154b18ffca`](https://github.com/nodejs/node/commit/154b18ffca)] - **(SEMVER-MINOR)** **console**: support console constructor groupIndentation option (rickyes) [#32964](https://github.com/nodejs/node/pull/32964)
-* [[`40253cc1c8`](https://github.com/nodejs/node/commit/40253cc1c8)] - **(SEMVER-MINOR)** **crypto**: add crypto.diffieHellman (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
-* [[`1977136a19`](https://github.com/nodejs/node/commit/1977136a19)] - **(SEMVER-MINOR)** **crypto**: add DH support to generateKeyPair (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
-* [[`9f85585b13`](https://github.com/nodejs/node/commit/9f85585b13)] - **(SEMVER-MINOR)** **crypto**: add key type 'dh' (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
-* [[`6ffe4ed3b5`](https://github.com/nodejs/node/commit/6ffe4ed3b5)] - **(SEMVER-MINOR)** **deps**: upgrade to libuv 1.37.0 (Colin Ihrig) [#32866](https://github.com/nodejs/node/pull/32866)
-* [[`2d7a7592ec`](https://github.com/nodejs/node/commit/2d7a7592ec)] - **(SEMVER-MINOR)** **deps**: upgrade to libuv 1.36.0 (Colin Ihrig) [#32866](https://github.com/nodejs/node/pull/32866)
-* [[`ae83f0f993`](https://github.com/nodejs/node/commit/ae83f0f993)] - **(SEMVER-MINOR)** **deps**: upgrade to libuv 1.35.0 (Colin Ihrig) [#32204](https://github.com/nodejs/node/pull/32204)
-* [[`b7d264edaf`](https://github.com/nodejs/node/commit/b7d264edaf)] - **(SEMVER-MINOR)** **dns**: add dns.ALL hints flag constant (murgatroid99) [#32183](https://github.com/nodejs/node/pull/32183)
-* [[`fd2486ea44`](https://github.com/nodejs/node/commit/fd2486ea44)] - **(SEMVER-MINOR)** **doc**: update stability of report features (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
-* [[`90d35adccd`](https://github.com/nodejs/node/commit/90d35adccd)] - **(SEMVER-MINOR)** **doc,lib,src,test**: make --experimental-report a nop (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
-* [[`93226a5097`](https://github.com/nodejs/node/commit/93226a5097)] - **(SEMVER-MINOR)** **esm**: unflag --experimental-modules (Guy Bedford) [#29866](https://github.com/nodejs/node/pull/29866)
-* [[`8c497f8969`](https://github.com/nodejs/node/commit/8c497f8969)] - **(SEMVER-MINOR)** **events**: allow monitoring error events (Gerhard Stoebich) [#30932](https://github.com/nodejs/node/pull/30932)
-* [[`a100709fa8`](https://github.com/nodejs/node/commit/a100709fa8)] - **(SEMVER-MINOR)** **fs**: make parameters optional for readSync (Lucas Holmquist) [#32460](https://github.com/nodejs/node/pull/32460)
-* [[`6601fac06a`](https://github.com/nodejs/node/commit/6601fac06a)] - **(SEMVER-MINOR)** **fs**: add fs.readv() (Sk Sajidul Kadir) [#32356](https://github.com/nodejs/node/pull/32356)
-* [[`16a913f702`](https://github.com/nodejs/node/commit/16a913f702)] - **(SEMVER-MINOR)** **fs**: make fs.read params optional (Lucas Holmquist) [#31402](https://github.com/nodejs/node/pull/31402)
-* [[`7260ede9e6`](https://github.com/nodejs/node/commit/7260ede9e6)] - **(SEMVER-MINOR)** **fs**: return first folder made by mkdir recursive (Benjamin Coe) [#31530](https://github.com/nodejs/node/pull/31530)
-* [[`a15e712ef6`](https://github.com/nodejs/node/commit/a15e712ef6)] - **(SEMVER-MINOR)** **fs**: allow overriding fs for streams (Robert Nagy) [#29083](https://github.com/nodejs/node/pull/29083)
-* [[`b5983213c1`](https://github.com/nodejs/node/commit/b5983213c1)] - **(SEMVER-MINOR)** **lib**: add option to disable \_\_proto\_\_ (Gus Caplan) [#32279](https://github.com/nodejs/node/pull/32279)
-* [[`784fb8f08c`](https://github.com/nodejs/node/commit/784fb8f08c)] - **(SEMVER-MINOR)** **module**: add API for interacting with source maps (Benjamin Coe) [#31132](https://github.com/nodejs/node/pull/31132)
-* [[`e22d853c5d`](https://github.com/nodejs/node/commit/e22d853c5d)] - **(SEMVER-MINOR)** **n-api**: define release 6 (Gabriel Schulhof) [#32058](https://github.com/nodejs/node/pull/32058)
-* [[`f56c4dd933`](https://github.com/nodejs/node/commit/f56c4dd933)] - **(SEMVER-MINOR)** **n-api**: add napi\_get\_all\_property\_names (himself65) [#30006](https://github.com/nodejs/node/pull/30006)
-* [[`9eeee0d9f2`](https://github.com/nodejs/node/commit/9eeee0d9f2)] - **(SEMVER-MINOR)** **perf_hooks**: add property flags to GCPerformanceEntry (Kirill Fomichev) [#29547](https://github.com/nodejs/node/pull/29547)
-* [[`5ec9295034`](https://github.com/nodejs/node/commit/5ec9295034)] - **(SEMVER-MINOR)** **process**: report ArrayBuffer memory in `memoryUsage()` (Anna Henningsen) [#31550](https://github.com/nodejs/node/pull/31550)
-* [[`de3603f0a6`](https://github.com/nodejs/node/commit/de3603f0a6)] - **(SEMVER-MINOR)** **process**: allow monitoring uncaughtException (Gerhard Stoebich) [#31257](https://github.com/nodejs/node/pull/31257)
-* [[`cf28afeeb6`](https://github.com/nodejs/node/commit/cf28afeeb6)] - **(SEMVER-MINOR)** **readline,repl**: improve history up/previous (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`a0eb3e4ed2`](https://github.com/nodejs/node/commit/a0eb3e4ed2)] - **(SEMVER-MINOR)** **readline,repl**: skip history entries identical to the current line (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`d7e153bddb`](https://github.com/nodejs/node/commit/d7e153bddb)] - **(SEMVER-MINOR)** **readline,repl**: add substring based history search (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`936c85c309`](https://github.com/nodejs/node/commit/936c85c309)] - **(SEMVER-MINOR)** **repl**: implement reverse search (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
-* [[`bf9ff16412`](https://github.com/nodejs/node/commit/bf9ff16412)] - **(SEMVER-MINOR)** **repl**: add completion preview (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`b14440fb5c`](https://github.com/nodejs/node/commit/b14440fb5c)] - **(SEMVER-MINOR)** **repl**: support previews by eager evaluating input (Ruben Bridgewater) [#30811](https://github.com/nodejs/node/pull/30811)
-* [[`0b310df532`](https://github.com/nodejs/node/commit/0b310df532)] - **(SEMVER-MINOR)** **src**: unconditionally include report feature (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
-* [[`394487e3e8`](https://github.com/nodejs/node/commit/394487e3e8)] - **(SEMVER-MINOR)** **src**: create a getter for kernel version (Juan José Arboleda) [#31732](https://github.com/nodejs/node/pull/31732)
-* [[`4ec25b4865`](https://github.com/nodejs/node/commit/4ec25b4865)] - **(SEMVER-MINOR)** **src,cli**: support compact (one-line) JSON reports (Sam Roberts) [#32254](https://github.com/nodejs/node/pull/32254)
-* [[`b038ad91f5`](https://github.com/nodejs/node/commit/b038ad91f5)] - **(SEMVER-MINOR)** **src,lib**: make ^C print a JS stack trace (legendecas) [#29207](https://github.com/nodejs/node/pull/29207)
-* [[`6348fae690`](https://github.com/nodejs/node/commit/6348fae690)] - **(SEMVER-MINOR)** **tls**: expose SSL\_export\_keying\_material (simon) [#31814](https://github.com/nodejs/node/pull/31814)
-* [[`6aa3869688`](https://github.com/nodejs/node/commit/6aa3869688)] - **(SEMVER-MINOR)** **util**: add `maxStrLength` option to `inspect` function (unknown) [#32392](https://github.com/nodejs/node/pull/32392)
-* [[`eda6665799`](https://github.com/nodejs/node/commit/eda6665799)] - **(SEMVER-MINOR)** **vm**: add code cache support for SourceTextModule (Gus Caplan) [#31278](https://github.com/nodejs/node/pull/31278)
-* [[`5c81b8d814`](https://github.com/nodejs/node/commit/5c81b8d814)] - **(SEMVER-MINOR)** **wasi**: add returnOnExit option (Colin Ihrig) [#32101](https://github.com/nodejs/node/pull/32101)
-* [[`ca4e65273f`](https://github.com/nodejs/node/commit/ca4e65273f)] - **(SEMVER-MINOR)** **worker**: support MessagePort to workers data (Juan José Arboleda) [#32278](https://github.com/nodejs/node/pull/32278)
-* [[`217e3dfea6`](https://github.com/nodejs/node/commit/217e3dfea6)] - **(SEMVER-MINOR)** **worker**: allow URL in Worker constructor (Antoine du HAMEL) [#31664](https://github.com/nodejs/node/pull/31664)
-* [[`ab8f38b551`](https://github.com/nodejs/node/commit/ab8f38b551)] - **(SEMVER-MINOR)** **worker**: add ability to take heap snapshot from parent thread (Anna Henningsen) [#31569](https://github.com/nodejs/node/pull/31569)
-
-#### Semver-patch commits
-
-* [[`06d607d50f`](https://github.com/nodejs/node/commit/06d607d50f)] - **async_hooks**: fix ctx loss after nested ALS calls (Andrey Pechkurov) [#32085](https://github.com/nodejs/node/pull/32085)
-* [[`96d1f14005`](https://github.com/nodejs/node/commit/96d1f14005)] - **async_hooks**: add store arg in AsyncLocalStorage (Andrey Pechkurov) [#31930](https://github.com/nodejs/node/pull/31930)
-* [[`b4ca132254`](https://github.com/nodejs/node/commit/b4ca132254)] - **async_hooks**: executionAsyncResource matches in hooks (Gerhard Stoebich) [#31821](https://github.com/nodejs/node/pull/31821)
-* [[`02f99d289d`](https://github.com/nodejs/node/commit/02f99d289d)] - **buffer**: add type check in bidirectionalIndexOf (Gerhard Stoebich) [#32770](https://github.com/nodejs/node/pull/32770)
-* [[`b53193a33b`](https://github.com/nodejs/node/commit/b53193a33b)] - **buffer**: mark pool ArrayBuffer as untransferable (Anna Henningsen) [#32759](https://github.com/nodejs/node/pull/32759)
-* [[`b555a772cc`](https://github.com/nodejs/node/commit/b555a772cc)] - **build**: fix vcbuild error for missing Visual Studio (Thomas) [#32658](https://github.com/nodejs/node/pull/32658)
-* [[`6f1931de25`](https://github.com/nodejs/node/commit/6f1931de25)] - **build**: remove .git folders when testing V8 (Richard Lau) [#32877](https://github.com/nodejs/node/pull/32877)
-* [[`c0805f0cab`](https://github.com/nodejs/node/commit/c0805f0cab)] - **build**: add configure flag to build V8 with DCHECKs (Anna Henningsen) [#32787](https://github.com/nodejs/node/pull/32787)
-* [[`60660c35ee`](https://github.com/nodejs/node/commit/60660c35ee)] - **build**: use same flags as V8 for ASAN (Matheus Marchini) [#32776](https://github.com/nodejs/node/pull/32776)
-* [[`26fee8b323`](https://github.com/nodejs/node/commit/26fee8b323)] - **build**: remove `.txt` files from .gitignore (Rich Trott) [#32710](https://github.com/nodejs/node/pull/32710)
-* [[`70eaba12a1`](https://github.com/nodejs/node/commit/70eaba12a1)] - **build**: remove node\_report option in node.gyp (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
-* [[`e765d597fd`](https://github.com/nodejs/node/commit/e765d597fd)] - **build**: add missing comma in node.gyp (Colin Ihrig) [#31959](https://github.com/nodejs/node/pull/31959)
-* [[`49ddd36f13`](https://github.com/nodejs/node/commit/49ddd36f13)] - **build**: fix building with ninja (Richard Lau) [#32071](https://github.com/nodejs/node/pull/32071)
-* [[`e097980cfe`](https://github.com/nodejs/node/commit/e097980cfe)] - **build**: warn upon --use-largepages config option (Gabriel Schulhof) [#31103](https://github.com/nodejs/node/pull/31103)
-* [[`c3efd2cb9a`](https://github.com/nodejs/node/commit/c3efd2cb9a)] - **build**: switch realpath to pwd (Benjamin Coe) [#31095](https://github.com/nodejs/node/pull/31095)
-* [[`0190a62f58`](https://github.com/nodejs/node/commit/0190a62f58)] - **build**: re-introduce --use-largepages as no-op (Gabriel Schulhof)
-* [[`e2a090b693`](https://github.com/nodejs/node/commit/e2a090b693)] - **build**: enable loading internal modules from disk (Gus Caplan) [#31321](https://github.com/nodejs/node/pull/31321)
-* [[`c4da682437`](https://github.com/nodejs/node/commit/c4da682437)] - **cli, report**: move --report-on-fatalerror to stable (Colin Ihrig) [#32496](https://github.com/nodejs/node/pull/32496)
-* [[`e05c29db3f`](https://github.com/nodejs/node/commit/e05c29db3f)] - **cluster**: fix error on worker disconnect/destroy (Santiago Gimeno) [#32793](https://github.com/nodejs/node/pull/32793)
-* [[`d217b792bc`](https://github.com/nodejs/node/commit/d217b792bc)] - **cluster**: removed unused addressType argument from constructor (Yash Ladha) [#32963](https://github.com/nodejs/node/pull/32963)
-* [[`71bccdde76`](https://github.com/nodejs/node/commit/71bccdde76)] - **crypto**: check DiffieHellman p and g params (Ben Noordhuis) [#32739](https://github.com/nodejs/node/pull/32739)
-* [[`c1b767471a`](https://github.com/nodejs/node/commit/c1b767471a)] - **crypto**: generator must be int32 in DiffieHellman() (Ben Noordhuis) [#32739](https://github.com/nodejs/node/pull/32739)
-* [[`4236175878`](https://github.com/nodejs/node/commit/4236175878)] - **crypto**: key size must be int32 in DiffieHellman() (Ben Noordhuis) [#32739](https://github.com/nodejs/node/pull/32739)
-* [[`0847bc3788`](https://github.com/nodejs/node/commit/0847bc3788)] - **crypto**: simplify exportKeyingMaterial (Tobias Nießen) [#31922](https://github.com/nodejs/node/pull/31922)
-* [[`907252d4cf`](https://github.com/nodejs/node/commit/907252d4cf)] - **crypto**: improve errors in DiffieHellmanGroup (Tobias Nießen) [#31445](https://github.com/nodejs/node/pull/31445)
-* [[`30633acf20`](https://github.com/nodejs/node/commit/30633acf20)] - **crypto**: assign and use ERR\_CRYPTO\_UNKNOWN\_CIPHER (Tobias Nießen) [#31437](https://github.com/nodejs/node/pull/31437)
-* [[`5dab489d50`](https://github.com/nodejs/node/commit/5dab489d50)] - **crypto**: simplify DH groups (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
-* [[`5c0232a632`](https://github.com/nodejs/node/commit/5c0232a632)] - **deps**: backport ICU-21081 for ICU 67.x (constexpr) (Steven R. Loomis) [#33337](https://github.com/nodejs/node/pull/33337)
-* [[`2d76ae7497`](https://github.com/nodejs/node/commit/2d76ae7497)] - **deps**: update to ICU 67.1 (Michaël Zasso) [#33337](https://github.com/nodejs/node/pull/33337)
-* [[`e073da095e`](https://github.com/nodejs/node/commit/e073da095e)] - **deps**: update to uvwasi 0.0.8 (Colin Ihrig) [#33078](https://github.com/nodejs/node/pull/33078)
-* [[`eb33d523da`](https://github.com/nodejs/node/commit/eb33d523da)] - **deps**: V8: backport 3f8dc4b2e5ba (Ujjwal Sharma) [#32993](https://github.com/nodejs/node/pull/32993)
-* [[`56313daff6`](https://github.com/nodejs/node/commit/56313daff6)] - **deps**: V8: cherry-pick e1eac1b16c96 (Milad Farazmand) [#32974](https://github.com/nodejs/node/pull/32974)
-* [[`65db9b210d`](https://github.com/nodejs/node/commit/65db9b210d)] - **deps**: fix zlib compilation for CPUs without SIMD features (Anna Henningsen) [#32627](https://github.com/nodejs/node/pull/32627)
-* [[`1b53e179b8`](https://github.com/nodejs/node/commit/1b53e179b8)] - **deps**: update zlib to upstream d7f3ca9 (Sam Roberts) [#31800](https://github.com/nodejs/node/pull/31800)
-* [[`9a89718410`](https://github.com/nodejs/node/commit/9a89718410)] - **deps**: move zlib maintenance info to guides (Sam Roberts) [#31800](https://github.com/nodejs/node/pull/31800)
-* [[`9e33f97c4e`](https://github.com/nodejs/node/commit/9e33f97c4e)] - **deps**: switch to chromium's zlib implementation (Brian White) [#31201](https://github.com/nodejs/node/pull/31201)
-* [[`322a9986fe`](https://github.com/nodejs/node/commit/322a9986fe)] - **dgram**: make UDPWrap more reusable (Anna Henningsen) [#31871](https://github.com/nodejs/node/pull/31871)
-* [[`ea4302bd46`](https://github.com/nodejs/node/commit/ea4302bd46)] - **errors**: drop pronouns from ERR\_WORKER\_PATH message (Colin Ihrig) [#32285](https://github.com/nodejs/node/pull/32285)
-* [[`daf1d842cc`](https://github.com/nodejs/node/commit/daf1d842cc)] - **esm**: improve commonjs hint on module not found (Daniele Belardi) [#31906](https://github.com/nodejs/node/pull/31906)
-* [[`7410e8d63a`](https://github.com/nodejs/node/commit/7410e8d63a)] - **esm**: port loader code to JS (Anna Henningsen) [#32201](https://github.com/nodejs/node/pull/32201)
-* [[`3241aee0f7`](https://github.com/nodejs/node/commit/3241aee0f7)] - **events**: convert errorMonitor to a normal property (Gerhard Stoebich) [#31848](https://github.com/nodejs/node/pull/31848)
-* [[`2093f13333`](https://github.com/nodejs/node/commit/2093f13333)] - **fs**: update validateOffsetLengthRead in utils.js (daemon1024) [#32896](https://github.com/nodejs/node/pull/32896)
-* [[`9c18838e8e`](https://github.com/nodejs/node/commit/9c18838e8e)] - **fs**: remove unnecessary else statement (Jesus Hernandez) [#32662](https://github.com/nodejs/node/pull/32662)
-* [[`6d6bb2a3dc`](https://github.com/nodejs/node/commit/6d6bb2a3dc)] - **fs**: use finished over destroy w/ cb (Robert Nagy) [#32809](https://github.com/nodejs/node/pull/32809)
-* [[`bde08377a1`](https://github.com/nodejs/node/commit/bde08377a1)] - **fs**: fix fs.read when passing null value (himself65) [#32479](https://github.com/nodejs/node/pull/32479)
-* [[`ebd9090240`](https://github.com/nodejs/node/commit/ebd9090240)] - **http**: disable headersTimeout check when set to zero (Paolo Insogna) [#33307](https://github.com/nodejs/node/pull/33307)
-* [[`a3decf5e59`](https://github.com/nodejs/node/commit/a3decf5e59)] - **http**: simplify sending header (Robert Nagy) [#33200](https://github.com/nodejs/node/pull/33200)
-* [[`12b8345db8`](https://github.com/nodejs/node/commit/12b8345db8)] - **http, async_hooks**: remove unneeded reference to wrapping resource (Gerhard Stoebich) [#32054](https://github.com/nodejs/node/pull/32054)
-* [[`d60988161d`](https://github.com/nodejs/node/commit/d60988161d)] - **http,https**: increase server headers timeout (Tim Costa) [#30071](https://github.com/nodejs/node/pull/30071)
-* [[`d883024884`](https://github.com/nodejs/node/commit/d883024884)] - **http2**: wait for secureConnect before initializing (Benjamin Coe) [#32958](https://github.com/nodejs/node/pull/32958)
-* [[`79e95e49f7`](https://github.com/nodejs/node/commit/79e95e49f7)] - **inspector**: only write coverage in fully bootstrapped Environments (Joyee Cheung) [#32960](https://github.com/nodejs/node/pull/32960)
-* [[`9570644194`](https://github.com/nodejs/node/commit/9570644194)] - **lib**: cosmetic change to builtinLibs list for maintainability (James M Snell) [#33106](https://github.com/nodejs/node/pull/33106)
-* [[`6356ad42ab`](https://github.com/nodejs/node/commit/6356ad42ab)] - **lib**: fix validateport error message when allowZero is false (rickyes) [#32861](https://github.com/nodejs/node/pull/32861)
-* [[`698e21b346`](https://github.com/nodejs/node/commit/698e21b346)] - **lib**: add warning on dynamic import es modules (Juan José Arboleda) [#30720](https://github.com/nodejs/node/pull/30720)
-* [[`4dba3fcafd`](https://github.com/nodejs/node/commit/4dba3fcafd)] - **lib**: unnecessary const assignment for class (Yash Ladha) [#32962](https://github.com/nodejs/node/pull/32962)
-* [[`84571cec7e`](https://github.com/nodejs/node/commit/84571cec7e)] - **lib**: remove unnecesary else block (David Daza) [#32644](https://github.com/nodejs/node/pull/32644)
-* [[`5885b37bcc`](https://github.com/nodejs/node/commit/5885b37bcc)] - **lib**: created isValidCallback helper (Yash Ladha) [#32665](https://github.com/nodejs/node/pull/32665)
-* [[`5b1c34651e`](https://github.com/nodejs/node/commit/5b1c34651e)] - **lib**: removed unused error code (Yash Ladha) [#32481](https://github.com/nodejs/node/pull/32481)
-* [[`965452dbad`](https://github.com/nodejs/node/commit/965452dbad)] - **lib**: replace Array to ArrayIsArray by primordials (himself65) [#32258](https://github.com/nodejs/node/pull/32258)
-* [[`434ca8766a`](https://github.com/nodejs/node/commit/434ca8766a)] - **lib**: move isLegalPort to validators, refactor (James M Snell) [#31851](https://github.com/nodejs/node/pull/31851)
-* [[`65ebfb2f12`](https://github.com/nodejs/node/commit/65ebfb2f12)] - **lib**: delete dead code in SourceMap (Justin Ridgewell) [#31512](https://github.com/nodejs/node/pull/31512)
-* [[`b1f08b8359`](https://github.com/nodejs/node/commit/b1f08b8359)] - **module**: no type module resolver side effects (Guy Bedford) [#33086](https://github.com/nodejs/node/pull/33086)
-* [[`a1fa180079`](https://github.com/nodejs/node/commit/a1fa180079)] - **module**: partial doc removal of --experimental-modules (Myles Borins) [#32915](https://github.com/nodejs/node/pull/32915)
-* [[`195043f910`](https://github.com/nodejs/node/commit/195043f910)] - **module**: refactor condition (Myles Borins) [#32989](https://github.com/nodejs/node/pull/32989)
-* [[`1811a10415`](https://github.com/nodejs/node/commit/1811a10415)] - **module**: exports not exported for null resolutions (Guy Bedford) [#32838](https://github.com/nodejs/node/pull/32838)
-* [[`3dc3772bb0`](https://github.com/nodejs/node/commit/3dc3772bb0)] - **module**: improve error for invalid package targets (Myles Borins) [#32052](https://github.com/nodejs/node/pull/32052)
-* [[`6489a5b1d8`](https://github.com/nodejs/node/commit/6489a5b1d8)] - **module**: fix memory leak when require error occurs (Qinhui Chen) [#32837](https://github.com/nodejs/node/pull/32837)
-* [[`b62910c851`](https://github.com/nodejs/node/commit/b62910c851)] - **module**: expose exports conditions to loaders (Jan Krems) [#31303](https://github.com/nodejs/node/pull/31303)
-* [[`b62db597af`](https://github.com/nodejs/node/commit/b62db597af)] - **module**: port source map sort logic from chromium (Benjamin Coe) [#31927](https://github.com/nodejs/node/pull/31927)
-* [[`4d7f9869f3`](https://github.com/nodejs/node/commit/4d7f9869f3)] - **n-api**: simplify uv\_idle wrangling (Ben Noordhuis) [#32997](https://github.com/nodejs/node/pull/32997)
-* [[`d08be9c8ca`](https://github.com/nodejs/node/commit/d08be9c8ca)] - **n-api**: fix false assumption on napi\_async\_context structures (legendecas) [#32928](https://github.com/nodejs/node/pull/32928)
-* [[`fbd39436a0`](https://github.com/nodejs/node/commit/fbd39436a0)] - **n-api**: fix comment on expected N-API version (Michael Dawson) [#32236](https://github.com/nodejs/node/pull/32236)
-* [[`d50fe6c1ea`](https://github.com/nodejs/node/commit/d50fe6c1ea)] - **path**: fix comment grammar (thecodrr) [#32942](https://github.com/nodejs/node/pull/32942)
-* [[`8dcb22f735`](https://github.com/nodejs/node/commit/8dcb22f735)] - **perf_hooks**: remove unnecessary assignment when name is undefined (rickyes) [#32910](https://github.com/nodejs/node/pull/32910)
-* [[`f537377957`](https://github.com/nodejs/node/commit/f537377957)] - **process**: fix two overflow cases in SourceMap VLQ decoding (Justin Ridgewell) [#31490](https://github.com/nodejs/node/pull/31490)
-* [[`7582bce58d`](https://github.com/nodejs/node/commit/7582bce58d)] - **readline**: improve unicode support and tab completion (Ruben Bridgewater) [#31288](https://github.com/nodejs/node/pull/31288)
-* [[`5231c84396`](https://github.com/nodejs/node/commit/5231c84396)] - **readline**: move charLengthLeft() and charLengthAt() (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`03efa716f0`](https://github.com/nodejs/node/commit/03efa716f0)] - **readline**: improve getStringWidth() (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`e894eeb22d`](https://github.com/nodejs/node/commit/e894eeb22d)] - **readline**: set null as callback return in case there's no error (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
-* [[`3946cadf89`](https://github.com/nodejs/node/commit/3946cadf89)] - **readline**: small refactoring (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
-* [[`0bafe087e4`](https://github.com/nodejs/node/commit/0bafe087e4)] - **readline**: update ansi-regex (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`4e9e4402c5`](https://github.com/nodejs/node/commit/4e9e4402c5)] - **readline,repl**: support tabs properly (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`3903aec0b4`](https://github.com/nodejs/node/commit/3903aec0b4)] - **repl**: align preview with the actual executed code (Ruben Bridgewater) [#32154](https://github.com/nodejs/node/pull/32154)
-* [[`709d3e5eb3`](https://github.com/nodejs/node/commit/709d3e5eb3)] - **repl**: eager-evaluate input in parens (Shelley Vohr) [#31943](https://github.com/nodejs/node/pull/31943)
-* [[`ce5c9d771c`](https://github.com/nodejs/node/commit/ce5c9d771c)] - **repl**: do not preview while pasting code (Ruben Bridgewater) [#31315](https://github.com/nodejs/node/pull/31315)
-* [[`3867f2095e`](https://github.com/nodejs/node/commit/3867f2095e)] - **repl**: fix preview cursor position (Ruben Bridgewater) [#31293](https://github.com/nodejs/node/pull/31293)
-* [[`ee40b67413`](https://github.com/nodejs/node/commit/ee40b67413)] - **repl**: change preview default in case of custom eval functions (Ruben Bridgewater) [#31259](https://github.com/nodejs/node/pull/31259)
-* [[`a4ca3787ea`](https://github.com/nodejs/node/commit/a4ca3787ea)] - **repl**: activate previews for lines exceeding the terminal columns (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`a892b4d00c`](https://github.com/nodejs/node/commit/a892b4d00c)] - **repl**: improve preview length calculation (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`9abe0e32d8`](https://github.com/nodejs/node/commit/9abe0e32d8)] - **repl**: use public getCursorPos() (Colin Ihrig) [#31091](https://github.com/nodejs/node/pull/31091)
-* [[`85f8654415`](https://github.com/nodejs/node/commit/85f8654415)] - **repl**: fix preview of lines that exceed the terminal columns (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
-* [[`47dfa22adb`](https://github.com/nodejs/node/commit/47dfa22adb)] - **repl**: fix preview bug in case of long lines (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`7131de5f77`](https://github.com/nodejs/node/commit/7131de5f77)] - **repl**: improve completion (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`61886507ce`](https://github.com/nodejs/node/commit/61886507ce)] - **repl**: simplify code (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`9b893e1bee`](https://github.com/nodejs/node/commit/9b893e1bee)] - **repl**: simplify repl autocompletion (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`78dcdee35f`](https://github.com/nodejs/node/commit/78dcdee35f)] - **repl**: remove dead code (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`f588301f2d`](https://github.com/nodejs/node/commit/f588301f2d)] - **repl,readline**: clean up code (Ruben Bridgewater) [#31288](https://github.com/nodejs/node/pull/31288)
-* [[`8be00314a6`](https://github.com/nodejs/node/commit/8be00314a6)] - **repl,readline**: refactor for simplicity (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`6eda28c69f`](https://github.com/nodejs/node/commit/6eda28c69f)] - **repl,readline**: refactor common code (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`f945a5e3e1`](https://github.com/nodejs/node/commit/f945a5e3e1)] - **report**: fix stderr matching for fatal error (gengjiawen) [#32699](https://github.com/nodejs/node/pull/32699)
-* [[`4b96fc522c`](https://github.com/nodejs/node/commit/4b96fc522c)] - **report**: add missing locks for report\_on\_fatalerror accessors (Anna Henningsen) [#32535](https://github.com/nodejs/node/pull/32535)
-* [[`c126d28c2e`](https://github.com/nodejs/node/commit/c126d28c2e)] - **report**: handle on-fatalerror better (Harshitha KP) [#32207](https://github.com/nodejs/node/pull/32207)
-* [[`85ef383bc5`](https://github.com/nodejs/node/commit/85ef383bc5)] - **src**: remove unused v8 Message namespace (Adrian Estrada) [#33180](https://github.com/nodejs/node/pull/33180)
-* [[`ffca498ca2`](https://github.com/nodejs/node/commit/ffca498ca2)] - **src**: use unique\_ptr for CachedData in ContextifyScript::New (Anna Henningsen) [#33113](https://github.com/nodejs/node/pull/33113)
-* [[`b3f0417830`](https://github.com/nodejs/node/commit/b3f0417830)] - **src**: return undefined when validation err == 0 (James M Snell) [#33107](https://github.com/nodejs/node/pull/33107)
-* [[`1436977984`](https://github.com/nodejs/node/commit/1436977984)] - **src**: crypto::UseSNIContext to use BaseObjectPtr (James M Snell) [#33107](https://github.com/nodejs/node/pull/33107)
-* [[`6b1e2359c2`](https://github.com/nodejs/node/commit/6b1e2359c2)] - **src**: separate out NgLibMemoryManagerBase (James M Snell) [#33104](https://github.com/nodejs/node/pull/33104)
-* [[`8864353c6e`](https://github.com/nodejs/node/commit/8864353c6e)] - **src**: remove unnecessary fully qualified names (rickyes) [#33077](https://github.com/nodejs/node/pull/33077)
-* [[`62f29534de`](https://github.com/nodejs/node/commit/62f29534de)] - **src**: add AsyncWrapObject constructor template factory (Stephen Belanger) [#33051](https://github.com/nodejs/node/pull/33051)
-* [[`08b66f223d`](https://github.com/nodejs/node/commit/08b66f223d)] - **src**: do not compare against wide characters (Christopher Beeson) [#32921](https://github.com/nodejs/node/pull/32921)
-* [[`60db9afde5`](https://github.com/nodejs/node/commit/60db9afde5)] - **src**: fix empty-named env var assertion failure (Christopher Beeson) [#32921](https://github.com/nodejs/node/pull/32921)
-* [[`b893c5b7ba`](https://github.com/nodejs/node/commit/b893c5b7ba)] - **src**: assignment to valid type (Yash Ladha) [#32879](https://github.com/nodejs/node/pull/32879)
-* [[`846d7bdbbf`](https://github.com/nodejs/node/commit/846d7bdbbf)] - **src**: delete MicroTaskPolicy namespace (Juan José Arboleda) [#32853](https://github.com/nodejs/node/pull/32853)
-* [[`05059a2469`](https://github.com/nodejs/node/commit/05059a2469)] - **src**: use using NewStringType (rickyes) [#32843](https://github.com/nodejs/node/pull/32843)
-* [[`cf16cb7ed5`](https://github.com/nodejs/node/commit/cf16cb7ed5)] - **src**: fix null deref in AllocatedBuffer::clear (Matt Kulukundis) [#32892](https://github.com/nodejs/node/pull/32892)
-* [[`0745f8884c`](https://github.com/nodejs/node/commit/0745f8884c)] - **src**: remove validation of unreachable code (Juan José Arboleda) [#32818](https://github.com/nodejs/node/pull/32818)
-* [[`9c216640d7`](https://github.com/nodejs/node/commit/9c216640d7)] - **src**: elevate v8 namespaces (Nimit) [#32872](https://github.com/nodejs/node/pull/32872)
-* [[`71bdcaeac7`](https://github.com/nodejs/node/commit/71bdcaeac7)] - **src**: remove redundant v8::HeapSnapshot namespace (Juan José Arboleda) [#32854](https://github.com/nodejs/node/pull/32854)
-* [[`bb1481fd23`](https://github.com/nodejs/node/commit/bb1481fd23)] - **src**: remove unused using in node\_worker.cc (Daniel Bevenius) [#32840](https://github.com/nodejs/node/pull/32840)
-* [[`8a38726826`](https://github.com/nodejs/node/commit/8a38726826)] - **src**: ignore GCC -Wcast-function-type for v8.h (Daniel Bevenius) [#32679](https://github.com/nodejs/node/pull/32679)
-* [[`c26637b7da`](https://github.com/nodejs/node/commit/c26637b7da)] - **src**: remove unused v8 Array namespace (Juan José Arboleda) [#32749](https://github.com/nodejs/node/pull/32749)
-* [[`c0d3fc28ec`](https://github.com/nodejs/node/commit/c0d3fc28ec)] - **src**: sync access for report and openssl options (Sam Roberts) [#32618](https://github.com/nodejs/node/pull/32618)
-* [[`9a010a3ea5`](https://github.com/nodejs/node/commit/9a010a3ea5)] - **src**: munmap(2) upon class instance destructor (Gabriel Schulhof) [#32570](https://github.com/nodejs/node/pull/32570)
-* [[`06953df051`](https://github.com/nodejs/node/commit/06953df051)] - **src**: fix extra includes of "env.h" and "env-inl.h" (Nick Kreeger) [#32293](https://github.com/nodejs/node/pull/32293)
-* [[`7432d0a170`](https://github.com/nodejs/node/commit/7432d0a170)] - **src**: avoid using elevated v8 namespaces in node\_perf.h (James M Snell) [#32468](https://github.com/nodejs/node/pull/32468)
-* [[`6175a22b87`](https://github.com/nodejs/node/commit/6175a22b87)] - **src**: avoid using elevated v8 namespaces in node\_errors.h (James M Snell) [#32468](https://github.com/nodejs/node/pull/32468)
-* [[`464ff85ddd`](https://github.com/nodejs/node/commit/464ff85ddd)] - **src**: remove loop\_init\_failed\_ from Worker class (Anna Henningsen) [#32562](https://github.com/nodejs/node/pull/32562)
-* [[`9f6ed724e0`](https://github.com/nodejs/node/commit/9f6ed724e0)] - **src**: clean up worker thread creation code (Anna Henningsen) [#32562](https://github.com/nodejs/node/pull/32562)
-* [[`73c55d39f3`](https://github.com/nodejs/node/commit/73c55d39f3)] - **src**: include AsyncWrap provider strings in snapshot (Anna Henningsen) [#32572](https://github.com/nodejs/node/pull/32572)
-* [[`29eca36ea8`](https://github.com/nodejs/node/commit/29eca36ea8)] - **src**: move JSONWriter into its own file (Anna Henningsen) [#32552](https://github.com/nodejs/node/pull/32552)
-* [[`8e3dd47db7`](https://github.com/nodejs/node/commit/8e3dd47db7)] - **src**: handle report options on fatalerror (Sam Roberts) [#32497](https://github.com/nodejs/node/pull/32497)
-* [[`e0351945bc`](https://github.com/nodejs/node/commit/e0351945bc)] - **src**: refactoring and cleanup of node\_i18n (James M Snell) [#32438](https://github.com/nodejs/node/pull/32438)
-* [[`23f8f35022`](https://github.com/nodejs/node/commit/23f8f35022)] - **src**: unify Linux and FreeBSD large pages implem (Gabriel Schulhof) [#32534](https://github.com/nodejs/node/pull/32534)
-* [[`16d85d9328`](https://github.com/nodejs/node/commit/16d85d9328)] - **src**: fix compiler warnings in node\_report\_module (Daniel Bevenius) [#32498](https://github.com/nodejs/node/pull/32498)
-* [[`58aadcdacf`](https://github.com/nodejs/node/commit/58aadcdacf)] - **src**: simplify large pages mapping code (Gabriel Schulhof) [#32396](https://github.com/nodejs/node/pull/32396)
-* [[`2da974e15e`](https://github.com/nodejs/node/commit/2da974e15e)] - **src**: use single ObjectTemplate for TextDecoder (Anna Henningsen) [#32426](https://github.com/nodejs/node/pull/32426)
-* [[`8f7f4e5aba`](https://github.com/nodejs/node/commit/8f7f4e5aba)] - **src**: avoid Isolate::GetCurrent() for platform implementation (Anna Henningsen) [#32269](https://github.com/nodejs/node/pull/32269)
-* [[`df046dec97`](https://github.com/nodejs/node/commit/df046dec97)] - **src**: add debug option to report large page stats (Gabriel Schulhof) [#32331](https://github.com/nodejs/node/pull/32331)
-* [[`43e9ae8317`](https://github.com/nodejs/node/commit/43e9ae8317)] - **src**: prefer OnScopeLeave over shared\_ptr\<void\> (Anna Henningsen) [#32247](https://github.com/nodejs/node/pull/32247)
-* [[`2f976d783f`](https://github.com/nodejs/node/commit/2f976d783f)] - **src**: find .text section using dl\_iterate\_phdr (Gabriel Schulhof) [#32244](https://github.com/nodejs/node/pull/32244)
-* [[`40c5d58095`](https://github.com/nodejs/node/commit/40c5d58095)] - ***Revert*** "**src**: keep main-thread Isolate attached to platform during Dispose" (Anna Henningsen) [#31853](https://github.com/nodejs/node/pull/31853)
-* [[`51a345674e`](https://github.com/nodejs/node/commit/51a345674e)] - **src**: handle NULL env scenario (Harshitha KP) [#31899](https://github.com/nodejs/node/pull/31899)
-* [[`154da1f0d3`](https://github.com/nodejs/node/commit/154da1f0d3)] - **src**: add missing namespace using statements in node\_watchdog.h (legendecas) [#32117](https://github.com/nodejs/node/pull/32117)
-* [[`83c47b6079`](https://github.com/nodejs/node/commit/83c47b6079)] - **src**: introduce node\_sockaddr (James M Snell) [#32070](https://github.com/nodejs/node/pull/32070)
-* [[`c979aeaf26`](https://github.com/nodejs/node/commit/c979aeaf26)] - **src**: improve handling of internal field counting (James M Snell) [#31960](https://github.com/nodejs/node/pull/31960)
-* [[`38de40ac50`](https://github.com/nodejs/node/commit/38de40ac50)] - **src**: do not unnecessarily re-assign uv handle data (Anna Henningsen) [#31696](https://github.com/nodejs/node/pull/31696)
-* [[`e204dba3f3`](https://github.com/nodejs/node/commit/e204dba3f3)] - **src**: pass resource object along with InternalMakeCallback (Anna Henningsen) [#32063](https://github.com/nodejs/node/pull/32063)
-* [[`ffefb059e2`](https://github.com/nodejs/node/commit/ffefb059e2)] - **src**: move InternalCallbackScope to StartExecution (Shelley Vohr) [#31944](https://github.com/nodejs/node/pull/31944)
-* [[`178c682ad1`](https://github.com/nodejs/node/commit/178c682ad1)] - **src**: start the .text section with an asm symbol (Gabriel Schulhof) [#31981](https://github.com/nodejs/node/pull/31981)
-* [[`809d8b5036`](https://github.com/nodejs/node/commit/809d8b5036)] - **src**: include large pages source unconditionally (Gabriel Schulhof) [#31904](https://github.com/nodejs/node/pull/31904)
-* [[`5ea3d60db1`](https://github.com/nodejs/node/commit/5ea3d60db1)] - **src**: use \_\_executable\_start for linux hugepages (Ben Noordhuis) [#31547](https://github.com/nodejs/node/pull/31547)
-* [[`1e95bb85a9`](https://github.com/nodejs/node/commit/1e95bb85a9)] - **src**: make large\_pages node.cc include conditional (Denys Otrishko) [#31078](https://github.com/nodejs/node/pull/31078)
-* [[`6dcb868a0a`](https://github.com/nodejs/node/commit/6dcb868a0a)] - **src**: make --use-largepages a runtime option (Gabriel Schulhof) [#30954](https://github.com/nodejs/node/pull/30954)
-* [[`f3fb6a11fe`](https://github.com/nodejs/node/commit/f3fb6a11fe)] - **src**: change GetStringWidth's expand\_emoji\_sequence option default (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`4f6300f804`](https://github.com/nodejs/node/commit/4f6300f804)] - **src**: improve GetColumnWidth performance (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`98297b92f5`](https://github.com/nodejs/node/commit/98297b92f5)] - **src**: inline SetSNICallback (Anna Henningsen) [#30548](https://github.com/nodejs/node/pull/30548)
-* [[`ce8d8c06ac`](https://github.com/nodejs/node/commit/ce8d8c06ac)] - **src**: use BaseObjectPtr to store SNI context (Anna Henningsen) [#30548](https://github.com/nodejs/node/pull/30548)
-* [[`c86883e4fe`](https://github.com/nodejs/node/commit/c86883e4fe)] - **stream**: add null check in Readable.from (Pranshu Srivastava) [#32873](https://github.com/nodejs/node/pull/32873)
-* [[`5df8ab16f2`](https://github.com/nodejs/node/commit/5df8ab16f2)] - **stream**: close iterator in Readable.from (Vadzim Zieńka) [#32844](https://github.com/nodejs/node/pull/32844)
-* [[`c8b4ab0978`](https://github.com/nodejs/node/commit/c8b4ab0978)] - **stream**: fix readable state `awaitDrain` increase in recursion (ran) [#27572](https://github.com/nodejs/node/pull/27572)
-* [[`becbe9e246`](https://github.com/nodejs/node/commit/becbe9e246)] - **tls**: move getAllowUnauthorized to internal/options (James M Snell) [#32917](https://github.com/nodejs/node/pull/32917)
-* [[`dec8a21cc8`](https://github.com/nodejs/node/commit/dec8a21cc8)] - **tls**: provide default cipher list from command line (Anna Henningsen) [#32760](https://github.com/nodejs/node/pull/32760)
-* [[`8961d33aff`](https://github.com/nodejs/node/commit/8961d33aff)] - **tls**: add memory tracking support to SSLWrap (Anna Henningsen) [#30548](https://github.com/nodejs/node/pull/30548)
-* [[`1b41829828`](https://github.com/nodejs/node/commit/1b41829828)] - **util**: improve unicode support (Ruben Bridgewater) [#31319](https://github.com/nodejs/node/pull/31319)
-* [[`a0b1a06fff`](https://github.com/nodejs/node/commit/a0b1a06fff)] - **util**: add todo comments for inspect to add unicode support (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`e0e8a9af6f`](https://github.com/nodejs/node/commit/e0e8a9af6f)] - **util,readline**: NFC-normalize strings before getStringWidth (Anna Henningsen) [#33052](https://github.com/nodejs/node/pull/33052)
-* [[`6a9f867e56`](https://github.com/nodejs/node/commit/6a9f867e56)] - **vm**: throw error when duplicated exportNames in SyntheticModule (himself65) [#32810](https://github.com/nodejs/node/pull/32810)
-* [[`02de66a110`](https://github.com/nodejs/node/commit/02de66a110)] - **vm**: lazily initialize primordials for vm contexts (Joyee Cheung) [#31738](https://github.com/nodejs/node/pull/31738)
-* [[`843a54fd33`](https://github.com/nodejs/node/commit/843a54fd33)] - **wasi**: use free() to release preopen array (Anna Henningsen) [#33110](https://github.com/nodejs/node/pull/33110)
-* [[`7f845e614b`](https://github.com/nodejs/node/commit/7f845e614b)] - **wasi**: update start() behavior to match spec (Colin Ihrig) [#33073](https://github.com/nodejs/node/pull/33073)
-* [[`e1fe0b66b5`](https://github.com/nodejs/node/commit/e1fe0b66b5)] - **wasi**: rename \_\_wasi\_unstable\_reactor\_start() (Colin Ihrig) [#33073](https://github.com/nodejs/node/pull/33073)
-* [[`7c723af3ae`](https://github.com/nodejs/node/commit/7c723af3ae)] - **wasi**: clean up options validation (Denys Otrishko) [#31797](https://github.com/nodejs/node/pull/31797)
-* [[`9ce6e363f4`](https://github.com/nodejs/node/commit/9ce6e363f4)] - **worker**: fix process.env var empty key access (Christopher Beeson) [#32921](https://github.com/nodejs/node/pull/32921)
-* [[`57cd7d2faa`](https://github.com/nodejs/node/commit/57cd7d2faa)] - **worker**: fix type check in receiveMessageOnPort (Anna Henningsen) [#32745](https://github.com/nodejs/node/pull/32745)
-* [[`ade4ec6f9a`](https://github.com/nodejs/node/commit/ade4ec6f9a)] - **worker**: runtime error on pthread creation (Harshitha KP) [#32344](https://github.com/nodejs/node/pull/32344)
-
-#### Documentation commits
-
-* [[`51c3c8d1e8`](https://github.com/nodejs/node/commit/51c3c8d1e8)] - **doc**: fix a typo in crypto.generateKeyPairSync() (himself65) [#33187](https://github.com/nodejs/node/pull/33187)
-* [[`62143b5cb9`](https://github.com/nodejs/node/commit/62143b5cb9)] - **doc**: add util.types.isArrayBufferView() (Kevin Locke) [#33092](https://github.com/nodejs/node/pull/33092)
-* [[`f127ae3102`](https://github.com/nodejs/node/commit/f127ae3102)] - **doc**: clarify when not to run CI on docs (Juan José Arboleda) [#33101](https://github.com/nodejs/node/pull/33101)
-* [[`7c8b0d27eb`](https://github.com/nodejs/node/commit/7c8b0d27eb)] - **doc**: fix the spelling error in stream.md (白一梓) [#31561](https://github.com/nodejs/node/pull/31561)
-* [[`31b143ccf1`](https://github.com/nodejs/node/commit/31b143ccf1)] - **doc**: correct Nodejs to Node.js spelling (Nick Schonning) [#33088](https://github.com/nodejs/node/pull/33088)
-* [[`2ac0f20019`](https://github.com/nodejs/node/commit/2ac0f20019)] - **doc**: improve worker pool example (Ranjan Purbey) [#33082](https://github.com/nodejs/node/pull/33082)
-* [[`90cf88614e`](https://github.com/nodejs/node/commit/90cf88614e)] - **doc**: some grammar fixes (Chris Holland) [#33081](https://github.com/nodejs/node/pull/33081)
-* [[`8a9be1d071`](https://github.com/nodejs/node/commit/8a9be1d071)] - **doc**: don't check links in tmp dirs (Ben Noordhuis) [#32996](https://github.com/nodejs/node/pull/32996)
-* [[`5ea5c26442`](https://github.com/nodejs/node/commit/5ea5c26442)] - **doc**: improve WHATWG url constructor code example (Liran Tal) [#32782](https://github.com/nodejs/node/pull/32782)
-* [[`c90a070735`](https://github.com/nodejs/node/commit/c90a070735)] - **doc**: make openssl maintenance position independent (Sam Roberts) [#32977](https://github.com/nodejs/node/pull/32977)
-* [[`d75f644dc2`](https://github.com/nodejs/node/commit/d75f644dc2)] - **doc**: improve release documentation (Michaël Zasso) [#33042](https://github.com/nodejs/node/pull/33042)
-* [[`98c3c427fc`](https://github.com/nodejs/node/commit/98c3c427fc)] - **doc**: add documentation for transferList arg at worker threads (Juan José Arboleda) [#32881](https://github.com/nodejs/node/pull/32881)
-* [[`9038e64619`](https://github.com/nodejs/node/commit/9038e64619)] - **doc**: avoid tautology in README (Ishaan Jain) [#33005](https://github.com/nodejs/node/pull/33005)
-* [[`cb7dae3385`](https://github.com/nodejs/node/commit/cb7dae3385)] - **doc**: updated directory entry information (Eileen) [#32791](https://github.com/nodejs/node/pull/32791)
-* [[`7397f80dc2`](https://github.com/nodejs/node/commit/7397f80dc2)] - **doc**: ignore no-literal-urls in README (Nick Schonning) [#32676](https://github.com/nodejs/node/pull/32676)
-* [[`d8bb226c0d`](https://github.com/nodejs/node/commit/d8bb226c0d)] - **doc**: convert bare email addresses to mailto links (Nick Schonning) [#32676](https://github.com/nodejs/node/pull/32676)
-* [[`b057175893`](https://github.com/nodejs/node/commit/b057175893)] - **doc**: ignore no-literal-urls in changelogs (Nick Schonning) [#32676](https://github.com/nodejs/node/pull/32676)
-* [[`92d91d1e78`](https://github.com/nodejs/node/commit/92d91d1e78)] - **doc**: add angle brackets around implicit links (Nick Schonning) [#32676](https://github.com/nodejs/node/pull/32676)
-* [[`e5a24507f2`](https://github.com/nodejs/node/commit/e5a24507f2)] - **doc**: remove repeated word in modules.md (Prosper Opara) [#32931](https://github.com/nodejs/node/pull/32931)
-* [[`a7ec1ea38d`](https://github.com/nodejs/node/commit/a7ec1ea38d)] - **doc**: elevate diagnostic report to tier1 (Gireesh Punathil) [#32732](https://github.com/nodejs/node/pull/32732)
-* [[`931c0c74b0`](https://github.com/nodejs/node/commit/931c0c74b0)] - **doc**: fix typo in security-release-process.md (Edward Elric) [#32926](https://github.com/nodejs/node/pull/32926)
-* [[`26cf6a3752`](https://github.com/nodejs/node/commit/26cf6a3752)] - **doc**: fix usage of folder and directory terms in fs.md (karan singh virdi) [#32919](https://github.com/nodejs/node/pull/32919)
-* [[`1472a39819`](https://github.com/nodejs/node/commit/1472a39819)] - **doc**: fix typo in zlib.md (雨夜带刀) [#32901](https://github.com/nodejs/node/pull/32901)
-* [[`26fdc64d96`](https://github.com/nodejs/node/commit/26fdc64d96)] - **doc**: synch SECURITY.md with website (Rich Trott) [#32903](https://github.com/nodejs/node/pull/32903)
-* [[`6ddf37cbfd`](https://github.com/nodejs/node/commit/6ddf37cbfd)] - **doc**: add `tsc-agenda` to onboarding labels list (Rich Trott) [#32832](https://github.com/nodejs/node/pull/32832)
-* [[`f7b78f221d`](https://github.com/nodejs/node/commit/f7b78f221d)] - **doc**: add N-API version 6 to table (Michael Dawson) [#32829](https://github.com/nodejs/node/pull/32829)
-* [[`aed5112889`](https://github.com/nodejs/node/commit/aed5112889)] - **doc**: add juanarbol as collaborator (Juan José Arboleda) [#32906](https://github.com/nodejs/node/pull/32906)
-* [[`68a1cec37f`](https://github.com/nodejs/node/commit/68a1cec37f)] - **doc**: missing brackets (William Bonawentura) [#32657](https://github.com/nodejs/node/pull/32657)
-* [[`8d53024889`](https://github.com/nodejs/node/commit/8d53024889)] - **doc**: improve consistency in usage of NULL (Michael Dawson) [#32726](https://github.com/nodejs/node/pull/32726)
-* [[`e9927e5587`](https://github.com/nodejs/node/commit/e9927e5587)] - **doc**: improve net docs (Robert Nagy) [#32811](https://github.com/nodejs/node/pull/32811)
-* [[`8e7c41ee55`](https://github.com/nodejs/node/commit/8e7c41ee55)] - **doc**: note that signatures of binary may be from subkeys (Reşat SABIQ) [#32591](https://github.com/nodejs/node/pull/32591)
-* [[`873d4aaaa2`](https://github.com/nodejs/node/commit/873d4aaaa2)] - **doc**: add transform stream destroy() return value (Colin Ihrig) [#32788](https://github.com/nodejs/node/pull/32788)
-* [[`39da5bfca7`](https://github.com/nodejs/node/commit/39da5bfca7)] - **doc**: updated guidance for n-api changes (Michael Dawson) [#32721](https://github.com/nodejs/node/pull/32721)
-* [[`38e51d335d`](https://github.com/nodejs/node/commit/38e51d335d)] - **doc**: remove warning from `response.writeHead` (Cecchi MacNaughton) [#32700](https://github.com/nodejs/node/pull/32700)
-* [[`fa51d859b5`](https://github.com/nodejs/node/commit/fa51d859b5)] - **doc**: document `buffer.from` returns internal pool buffer (Harshitha KP) [#32703](https://github.com/nodejs/node/pull/32703)
-* [[`47d2a9604b`](https://github.com/nodejs/node/commit/47d2a9604b)] - **doc**: add puzpuzpuz to collaborators (Andrey Pechkurov) [#32817](https://github.com/nodejs/node/pull/32817)
-* [[`ad2fdd5142`](https://github.com/nodejs/node/commit/ad2fdd5142)] - **doc**: make openssl commit messages be valid (Sam Roberts) [#32602](https://github.com/nodejs/node/pull/32602)
-* [[`a55d215b08`](https://github.com/nodejs/node/commit/a55d215b08)] - **doc**: add missing changes: entry for dns.ALL (Anna Henningsen) [#32617](https://github.com/nodejs/node/pull/32617)
-* [[`13342f884b`](https://github.com/nodejs/node/commit/13342f884b)] - **doc**: fix typo in maintaining-openssl guide (Nitin Kumar) [#32292](https://github.com/nodejs/node/pull/32292)
-* [[`d7e4bb20a7`](https://github.com/nodejs/node/commit/d7e4bb20a7)] - **doc**: add missing changes: entry for mkdir (Anna Henningsen) [#32490](https://github.com/nodejs/node/pull/32490)
-* [[`742a032775`](https://github.com/nodejs/node/commit/742a032775)] - **doc**: complete n-api version matrix (Gabriel Schulhof) [#32304](https://github.com/nodejs/node/pull/32304)
-* [[`f5b60ec8dd`](https://github.com/nodejs/node/commit/f5b60ec8dd)] - **doc**: change worker.takeHeapSnapshot to getHeapSnapshot (Gerhard Stoebich) [#32061](https://github.com/nodejs/node/pull/32061)
-* [[`c0cf234da9`](https://github.com/nodejs/node/commit/c0cf234da9)] - **doc**: remove personal pronoun usage in policy.md (Rich Trott) [#32142](https://github.com/nodejs/node/pull/32142)
-* [[`97689e05fd`](https://github.com/nodejs/node/commit/97689e05fd)] - **doc**: remove personal pronoun usage in fs.md (Rich Trott) [#32142](https://github.com/nodejs/node/pull/32142)
-* [[`9a7f89245d`](https://github.com/nodejs/node/commit/9a7f89245d)] - **doc**: remove personal pronoun usage in errors.md (Rich Trott) [#32142](https://github.com/nodejs/node/pull/32142)
-* [[`c98ba9537b`](https://github.com/nodejs/node/commit/c98ba9537b)] - **doc**: remove personal pronoun usage in addons.md (Rich Trott) [#32142](https://github.com/nodejs/node/pull/32142)
-* [[`e8985c2e87`](https://github.com/nodejs/node/commit/e8985c2e87)] - **doc**: improve AsyncLocalStorage sample (Andrey Pechkurov) [#32757](https://github.com/nodejs/node/pull/32757)
-* [[`9d9e185e3a`](https://github.com/nodejs/node/commit/9d9e185e3a)] - **doc**: list largepage values in --help (Colin Ihrig) [#31537](https://github.com/nodejs/node/pull/31537)
-* [[`f13ecd801e`](https://github.com/nodejs/node/commit/f13ecd801e)] - **doc**: fix typo in maintaining-zlib guide (Nitin Kumar) [#32292](https://github.com/nodejs/node/pull/32292)
-* [[`3e939ffb5e`](https://github.com/nodejs/node/commit/3e939ffb5e)] - **doc**: describe how to update zlib (Sam Roberts) [#31800](https://github.com/nodejs/node/pull/31800)
-* [[`1d2565b8b6`](https://github.com/nodejs/node/commit/1d2565b8b6)] - **doc**: document readline key bindings (Harshitha KP) [#31256](https://github.com/nodejs/node/pull/31256)
-* [[`8e829d4a56`](https://github.com/nodejs/node/commit/8e829d4a56)] - ***Revert*** "**doc**: fix default server timeout description for https" (Michaël Zasso) [#33069](https://github.com/nodejs/node/pull/33069)
-
-#### Other commits
-
-* [[`cdf4f4875d`](https://github.com/nodejs/node/commit/cdf4f4875d)] - **benchmark**: use let instead of var in worker (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`c572218552`](https://github.com/nodejs/node/commit/c572218552)] - **benchmark**: use let instead of var in util (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`862aeae238`](https://github.com/nodejs/node/commit/862aeae238)] - **benchmark**: use let instead of var in url (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`e68c21f079`](https://github.com/nodejs/node/commit/e68c21f079)] - **benchmark**: use let instead of var in tls (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`f3ef8946d0`](https://github.com/nodejs/node/commit/f3ef8946d0)] - **benchmark**: use let instead of var in timers (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`33858fa917`](https://github.com/nodejs/node/commit/33858fa917)] - **benchmark**: use let instead of var in run.js (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`a05f22647a`](https://github.com/nodejs/node/commit/a05f22647a)] - **benchmark**: use let instead of var in dns (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`2d7c52d729`](https://github.com/nodejs/node/commit/2d7c52d729)] - **benchmark**: use let instead of var in common.js (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`d205bc91d4`](https://github.com/nodejs/node/commit/d205bc91d4)] - **benchmark**: use const instead of var in async\_hooks (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`d7f1add038`](https://github.com/nodejs/node/commit/d7f1add038)] - **benchmark**: add `no-var` rule in .eslintrc.yaml (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`b4a6351634`](https://github.com/nodejs/node/commit/b4a6351634)] - **benchmark**: remove special test entries (Ruben Bridgewater) [#31755](https://github.com/nodejs/node/pull/31755)
-* [[`71397885b2`](https://github.com/nodejs/node/commit/71397885b2)] - **benchmark**: add `test` and `all` options and improve errors" (Ruben Bridgewater) [#31755](https://github.com/nodejs/node/pull/31755)
-* [[`011e3dec00`](https://github.com/nodejs/node/commit/011e3dec00)] - **benchmark**: refactor helper into a class (Ruben Bridgewater) [#31755](https://github.com/nodejs/node/pull/31755)
-* [[`cf2ca11828`](https://github.com/nodejs/node/commit/cf2ca11828)] - ***Revert*** "**benchmark**: refactor helper into a class" (Anna Henningsen) [#31722](https://github.com/nodejs/node/pull/31722)
-* [[`ef80c02794`](https://github.com/nodejs/node/commit/ef80c02794)] - ***Revert*** "**benchmark**: remove special test entries" (Anna Henningsen) [#31722](https://github.com/nodejs/node/pull/31722)
-* [[`3861c69b02`](https://github.com/nodejs/node/commit/3861c69b02)] - **benchmark**: fix error on server close in AsyncLocalStorage benchmark (Andrey Pechkurov) [#32503](https://github.com/nodejs/node/pull/32503)
-* [[`daf6e1702f`](https://github.com/nodejs/node/commit/daf6e1702f)] - **benchmark**: use let instead of var in zlib (Daniele Belardi) [#31794](https://github.com/nodejs/node/pull/31794)
-* [[`6b02359dbf`](https://github.com/nodejs/node/commit/6b02359dbf)] - **test**: update c8 ignore comment (Benjamin Coe) [#33151](https://github.com/nodejs/node/pull/33151)
-* [[`d7b13abbf8`](https://github.com/nodejs/node/commit/d7b13abbf8)] - **test**: skip memory usage tests when ASAN is enabled (Anna Henningsen) [#33129](https://github.com/nodejs/node/pull/33129)
-* [[`238353839c`](https://github.com/nodejs/node/commit/238353839c)] - **test**: move test-process-title to sequential (Anna Henningsen) [#33150](https://github.com/nodejs/node/pull/33150)
-* [[`13cae34484`](https://github.com/nodejs/node/commit/13cae34484)] - **test**: fix out-of-bound reads from invalid sizeof usage (Anna Henningsen) [#33115](https://github.com/nodejs/node/pull/33115)
-* [[`08e01a12d0`](https://github.com/nodejs/node/commit/08e01a12d0)] - **test**: add missing calls to napi\_async\_destroy (Anna Henningsen) [#33114](https://github.com/nodejs/node/pull/33114)
-* [[`3015887019`](https://github.com/nodejs/node/commit/3015887019)] - **test**: check args on SourceTextModule cachedData (Juan José Arboleda) [#32956](https://github.com/nodejs/node/pull/32956)
-* [[`dad82173cd`](https://github.com/nodejs/node/commit/dad82173cd)] - **test**: mark test flaky on freebsd (Sam Roberts) [#32849](https://github.com/nodejs/node/pull/32849)
-* [[`4ab6643abb`](https://github.com/nodejs/node/commit/4ab6643abb)] - **test**: flaky test-stdout-close-catch on freebsd (Sam Roberts) [#32849](https://github.com/nodejs/node/pull/32849)
-* [[`60550f35ac`](https://github.com/nodejs/node/commit/60550f35ac)] - **test**: refactor test-async-hooks-constructor (himself65) [#33063](https://github.com/nodejs/node/pull/33063)
-* [[`83520451cc`](https://github.com/nodejs/node/commit/83520451cc)] - **test**: remove timers-blocking-callback (Jeremiah Senkpiel) [#32870](https://github.com/nodejs/node/pull/32870)
-* [[`579f68c5fd`](https://github.com/nodejs/node/commit/579f68c5fd)] - **test**: better error validations for event-capture (Adrian Estrada) [#32771](https://github.com/nodejs/node/pull/32771)
-* [[`dacd27927a`](https://github.com/nodejs/node/commit/dacd27927a)] - **test**: refactor events tests for invalid listeners (Adrian Estrada) [#32769](https://github.com/nodejs/node/pull/32769)
-* [[`4c67568148`](https://github.com/nodejs/node/commit/4c67568148)] - **test**: test-async-wrap-constructor prefer forEach (Daniel Estiven Rico Posada) [#32631](https://github.com/nodejs/node/pull/32631)
-* [[`0bae243438`](https://github.com/nodejs/node/commit/0bae243438)] - **test**: mark test-child-process-fork-args as flaky on Windows (Andrey Pechkurov) [#32950](https://github.com/nodejs/node/pull/32950)
-* [[`f181b5996a`](https://github.com/nodejs/node/commit/f181b5996a)] - **test**: changed function to arrow function (Nimit) [#32875](https://github.com/nodejs/node/pull/32875)
-* [[`68e3954d1a`](https://github.com/nodejs/node/commit/68e3954d1a)] - **test**: replace console.log/error() with debuglog (daemon1024) [#32692](https://github.com/nodejs/node/pull/32692)
-* [[`c566906789`](https://github.com/nodejs/node/commit/c566906789)] - **test**: only detect uname on supported os (Xu Meng) [#32833](https://github.com/nodejs/node/pull/32833)
-* [[`50130f0e23`](https://github.com/nodejs/node/commit/50130f0e23)] - **test**: mark cpu-prof-dir-worker flaky on all (Sam Roberts) [#32828](https://github.com/nodejs/node/pull/32828)
-* [[`96c93113a8`](https://github.com/nodejs/node/commit/96c93113a8)] - **test**: replace equal with strictEqual (Jesus Hernandez) [#32727](https://github.com/nodejs/node/pull/32727)
-* [[`e839a71ca8`](https://github.com/nodejs/node/commit/e839a71ca8)] - **test**: mark test-worker-prof flaky on arm (Sam Roberts) [#32826](https://github.com/nodejs/node/pull/32826)
-* [[`44ca47904d`](https://github.com/nodejs/node/commit/44ca47904d)] - **test**: mark test-http2-reset-flood flaky on all (Sam Roberts) [#32825](https://github.com/nodejs/node/pull/32825)
-* [[`271b309c91`](https://github.com/nodejs/node/commit/271b309c91)] - **test**: cover node entry type in perf\_hooks (Julian Duque) [#32751](https://github.com/nodejs/node/pull/32751)
-* [[`769ac24eba`](https://github.com/nodejs/node/commit/769ac24eba)] - **test**: use symlinks to copy shells (John Kleinschmidt) [#32129](https://github.com/nodejs/node/pull/32129)
-* [[`b3ac840b97`](https://github.com/nodejs/node/commit/b3ac840b97)] - **test**: save test file in temporary directory (Luigi Pinca) [#32670](https://github.com/nodejs/node/pull/32670)
-* [[`c5e0615942`](https://github.com/nodejs/node/commit/c5e0615942)] - **test**: refactor test-worker (himself65) [#32509](https://github.com/nodejs/node/pull/32509)
-* [[`8eb6807dfe`](https://github.com/nodejs/node/commit/8eb6807dfe)] - **test**: replace flag expose\_internals to expose-internals (Juan José Arboleda) [#32542](https://github.com/nodejs/node/pull/32542)
-* [[`5598dd14df`](https://github.com/nodejs/node/commit/5598dd14df)] - **test**: fix a typo on test-fs-read-optional-params (himself65) [#32461](https://github.com/nodejs/node/pull/32461)
-* [[`30207985cc`](https://github.com/nodejs/node/commit/30207985cc)] - **test**: als variant of test-timers-clearImmediate (Harshitha KP) [#32303](https://github.com/nodejs/node/pull/32303)
-* [[`e3baee6c3d`](https://github.com/nodejs/node/commit/e3baee6c3d)] - **test**: refactoring / cleanup on child-process tests (James M Snell) [#32078](https://github.com/nodejs/node/pull/32078)
-* [[`6a0bc83370`](https://github.com/nodejs/node/commit/6a0bc83370)] - **test**: remove common.skipIfReportDisabled() (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
-* [[`4a08b85fc8`](https://github.com/nodejs/node/commit/4a08b85fc8)] - **test**: make test-memory-usage predictable (Matheus Marchini) [#32239](https://github.com/nodejs/node/pull/32239)
-* [[`efc844d00d`](https://github.com/nodejs/node/commit/efc844d00d)] - **test**: verify that WASI errors are rethrown (Colin Ihrig) [#32157](https://github.com/nodejs/node/pull/32157)
-* [[`10ee89a8d5`](https://github.com/nodejs/node/commit/10ee89a8d5)] - **test**: refactor and simplify test-repl-preview (Ruben Bridgewater) [#32154](https://github.com/nodejs/node/pull/32154)
-* [[`5a8e54b6de`](https://github.com/nodejs/node/commit/5a8e54b6de)] - **test**: refactor all benchmark tests to use the new test option (Ruben Bridgewater) [#31755](https://github.com/nodejs/node/pull/31755)
-* [[`d1d22fa86e`](https://github.com/nodejs/node/commit/d1d22fa86e)] - **test**: add secp224k1 check in crypto-dh-stateless (Daniel Bevenius) [#31715](https://github.com/nodejs/node/pull/31715)
-* [[`8a044cb9ae`](https://github.com/nodejs/node/commit/8a044cb9ae)] - **test**: fix flaky parallel/test-repl-history-navigation test (Ruben Bridgewater) [#31708](https://github.com/nodejs/node/pull/31708)
-* [[`2fc72cac97`](https://github.com/nodejs/node/commit/2fc72cac97)] - **test**: fix flaky test-trace-sigint-on-idle (Anna Henningsen) [#31645](https://github.com/nodejs/node/pull/31645)
-* [[`a4ee930d71`](https://github.com/nodejs/node/commit/a4ee930d71)] - **test**: improve logged errors (Ruben Bridgewater) [#31425](https://github.com/nodejs/node/pull/31425)
-* [[`4aaf4075e9`](https://github.com/nodejs/node/commit/4aaf4075e9)] - **test**: show child stderr output in largepages test (Ben Noordhuis) [#31612](https://github.com/nodejs/node/pull/31612)
-* [[`2508e1321f`](https://github.com/nodejs/node/commit/2508e1321f)] - **test**: add new scenario for async-local storage (Harshitha KP) [#32082](https://github.com/nodejs/node/pull/32082)
-* [[`52a11544cf`](https://github.com/nodejs/node/commit/52a11544cf)] - **test**: add GC test for disabled AsyncLocalStorage (Andrey Pechkurov) [#31995](https://github.com/nodejs/node/pull/31995)
-* [[`98ece74dc7`](https://github.com/nodejs/node/commit/98ece74dc7)] - **test**: improve disable AsyncLocalStorage test (Andrey Pechkurov) [#31998](https://github.com/nodejs/node/pull/31998)
-* [[`e5a64e5def`](https://github.com/nodejs/node/commit/e5a64e5def)] - **test**: fix flaky test-memory-usage (Anna Henningsen) [#31602](https://github.com/nodejs/node/pull/31602)
-* [[`02ec03ce27`](https://github.com/nodejs/node/commit/02ec03ce27)] - **test**: cover property n-api null cases (Gabriel Schulhof) [#31488](https://github.com/nodejs/node/pull/31488)
-* [[`733002b081`](https://github.com/nodejs/node/commit/733002b081)] - **test**: skip keygen tests on arm systems (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
-* [[`5e5d053585`](https://github.com/nodejs/node/commit/5e5d053585)] - **test**: add repl tests to verify unicode support in previews (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
-* [[`f1624bbafa`](https://github.com/nodejs/node/commit/f1624bbafa)] - **test**: add multiple repl preview tests (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
-* [[`9dcf137623`](https://github.com/nodejs/node/commit/9dcf137623)] - **test,benchmark**: fix test-benchmark-zlib (Rich Trott) [#31538](https://github.com/nodejs/node/pull/31538)
-* [[`94e4847142`](https://github.com/nodejs/node/commit/94e4847142)] - **tools**: bump remark-preset-lint-node to 1.15.0 (Rich Trott) [#33157](https://github.com/nodejs/node/pull/33157)
-* [[`58bd92aa26`](https://github.com/nodejs/node/commit/58bd92aa26)] - **tools**: update remark-preset-lint-node@1.14.0 (Rich Trott) [#33072](https://github.com/nodejs/node/pull/33072)
-* [[`b9d9c24cfc`](https://github.com/nodejs/node/commit/b9d9c24cfc)] - **tools**: update broken types in type parser (Colin Ihrig) [#33068](https://github.com/nodejs/node/pull/33068)
-* [[`3dafc1460d`](https://github.com/nodejs/node/commit/3dafc1460d)] - **tools**: fix mkcodecache when run with ASAN (Anna Henningsen) [#32850](https://github.com/nodejs/node/pull/32850)
-* [[`1c010b41a1`](https://github.com/nodejs/node/commit/1c010b41a1)] - **tools**: update ESLint to 7.0.0-rc.0 (himself65) [#33062](https://github.com/nodejs/node/pull/33062)
-* [[`5f79ab2239`](https://github.com/nodejs/node/commit/5f79ab2239)] - **tools**: remove unused code in doc generation tool (Rich Trott) [#32913](https://github.com/nodejs/node/pull/32913)
-* [[`576a62688f`](https://github.com/nodejs/node/commit/576a62688f)] - **tools**: decrease timeout in test.py (Anna Henningsen) [#32868](https://github.com/nodejs/node/pull/32868)
-* [[`9cf9cb436b`](https://github.com/nodejs/node/commit/9cf9cb436b)] - **tools**: remove prefer-common-expectserror lint rule (Colin Ihrig) [#31147](https://github.com/nodejs/node/pull/31147)
-
-<a id="12.16.3"></a>
-## 2020-04-28, Version 12.16.3 'Erbium' (LTS), @targos
-
-### Notable Changes
-
-* **Dependencies**:
-  * Updated OpenSSL to 1.1.1g (Hassaan Pasha) [#32971](https://github.com/nodejs/node/pull/32971).
-  * Updated c-ares to 1.16.0 (Anna Henningsen) [#32246](https://github.com/nodejs/node/pull/32246).
-  * Updated experimental uvwasi to 0.0.6 (Colin Ihrig) [#32309](https://github.com/nodejs/node/pull/32309).
-* **ESM (experimental)**:
-  * Additional warnings are no longer printed for modules that use conditional
-    exports or package name self resolution (Guy Bedford) [#31845](https://github.com/nodejs/node/pull/31845).
-
-### Commits
-
-* [[`2c5b0147fa`](https://github.com/nodejs/node/commit/2c5b0147fa)] - **async_hooks**: use hasHooks function internally (rickyes) [#32656](https://github.com/nodejs/node/pull/32656)
-* [[`28abbfd594`](https://github.com/nodejs/node/commit/28abbfd594)] - **async_hooks**: move to lazy destroy hook registration in AsyncResource (Andrey Pechkurov) [#32429](https://github.com/nodejs/node/pull/32429)
-* [[`146ad4eaae`](https://github.com/nodejs/node/commit/146ad4eaae)] - **async_hooks**: avoid resource reuse by FileHandle (Gerhard Stoebich) [#31972](https://github.com/nodejs/node/pull/31972)
-* [[`39a3cc13dc`](https://github.com/nodejs/node/commit/39a3cc13dc)] - **buffer,n-api**: fix double ArrayBuffer::Detach() during cleanup (Anna Henningsen) [#33039](https://github.com/nodejs/node/pull/33039)
-* [[`20f3e9d836`](https://github.com/nodejs/node/commit/20f3e9d836)] - **build**: output dots instead of tap in GitHub actions (Michaël Zasso) [#32714](https://github.com/nodejs/node/pull/32714)
-* [[`c98aa9312e`](https://github.com/nodejs/node/commit/c98aa9312e)] - **build**: move doc versions JSON file out of out/doc (Richard Lau) [#32728](https://github.com/nodejs/node/pull/32728)
-* [[`546a9ea998`](https://github.com/nodejs/node/commit/546a9ea998)] - **build**: fix LINT\_MD\_NEWER assignment (Rich Trott) [#32712](https://github.com/nodejs/node/pull/32712)
-* [[`ae772b7c6a`](https://github.com/nodejs/node/commit/ae772b7c6a)] - **build**: log detected compilers in --verbose mode (Richard Lau) [#32715](https://github.com/nodejs/node/pull/32715)
-* [[`43055519d3`](https://github.com/nodejs/node/commit/43055519d3)] - **build**: use tabs for indentation in Makefile (Luigi Pinca) [#32614](https://github.com/nodejs/node/pull/32614)
-* [[`2e31ac96f3`](https://github.com/nodejs/node/commit/2e31ac96f3)] - **build**: remove make lint on lint-py (himself65) [#32599](https://github.com/nodejs/node/pull/32599)
-* [[`d8a948f0fc`](https://github.com/nodejs/node/commit/d8a948f0fc)] - **build**: disable -Wattributes warnings on aix (Ben Noordhuis) [#32419](https://github.com/nodejs/node/pull/32419)
-* [[`a3848e51aa`](https://github.com/nodejs/node/commit/a3848e51aa)] - **build**: expand ASAN acronym in configure help (Sam Roberts) [#32325](https://github.com/nodejs/node/pull/32325)
-* [[`c8541a7d7a`](https://github.com/nodejs/node/commit/c8541a7d7a)] - **build**: disable libstdc++ debug containers globally (Ben Noordhuis) [#30147](https://github.com/nodejs/node/pull/30147)
-* [[`d3c9a82a6e`](https://github.com/nodejs/node/commit/d3c9a82a6e)] - **build**: remove empty line on node.gyp file (Juan José Arboleda) [#31952](https://github.com/nodejs/node/pull/31952)
-* [[`e65586985f`](https://github.com/nodejs/node/commit/e65586985f)] - **build**: support android build on ndk version equal or above 23 (forfun414) [#31521](https://github.com/nodejs/node/pull/31521)
-* [[`790841597d`](https://github.com/nodejs/node/commit/790841597d)] - **console**: fixup error message (James M Snell) [#32475](https://github.com/nodejs/node/pull/32475)
-* [[`d19251630e`](https://github.com/nodejs/node/commit/d19251630e)] - **crypto**: clear openssl error stack after en/decrypt (Ben Noordhuis) [#32248](https://github.com/nodejs/node/pull/32248)
-* [[`51f05d2f3d`](https://github.com/nodejs/node/commit/51f05d2f3d)] - **deps**: update archs files for OpenSSL-1.1.1g (Hassaan Pasha) [#32971](https://github.com/nodejs/node/pull/32971)
-* [[`a89744f4e0`](https://github.com/nodejs/node/commit/a89744f4e0)] - **deps**: upgrade openssl sources to 1.1.1g (Hassaan Pasha) [#32971](https://github.com/nodejs/node/pull/32971)
-* [[`80c89d4ec7`](https://github.com/nodejs/node/commit/80c89d4ec7)] - **deps**: update archs files for OpenSSL-1.1.1f (Hassaan Pasha) [#32583](https://github.com/nodejs/node/pull/32583)
-* [[`c9cc38114a`](https://github.com/nodejs/node/commit/c9cc38114a)] - **deps**: upgrade openssl sources to 1.1.1f (Hassaan Pasha) [#32583](https://github.com/nodejs/node/pull/32583)
-* [[`fedcb16144`](https://github.com/nodejs/node/commit/fedcb16144)] - **deps**: update acorn to v7.1.1 (Ruben Bridgewater) [#32310](https://github.com/nodejs/node/pull/32310)
-* [[`37476a339a`](https://github.com/nodejs/node/commit/37476a339a)] - **deps**: upgrade to c-ares v1.16.0 (Anna Henningsen) [#32246](https://github.com/nodejs/node/pull/32246)
-* [[`fe0e1dbd13`](https://github.com/nodejs/node/commit/fe0e1dbd13)] - **deps**: update to uvwasi 0.0.6 (Colin Ihrig) [#32309](https://github.com/nodejs/node/pull/32309)
-* [[`2e92cb476d`](https://github.com/nodejs/node/commit/2e92cb476d)] - **deps**: V8: cherry-pick f9257802c1c0 (Matheus Marchini) [#32180](https://github.com/nodejs/node/pull/32180)
-* [[`0e922440d6`](https://github.com/nodejs/node/commit/0e922440d6)] - **deps,doc**: move openssl maintenance guide to doc (Sam Roberts) [#32209](https://github.com/nodejs/node/pull/32209)
-* [[`06d16cf9ef`](https://github.com/nodejs/node/commit/06d16cf9ef)] - **dns**: remove duplicate code (rickyes) [#32664](https://github.com/nodejs/node/pull/32664)
-* [[`af392a114b`](https://github.com/nodejs/node/commit/af392a114b)] - **doc**: add link to code ide configs (Robert Nagy) [#32767](https://github.com/nodejs/node/pull/32767)
-* [[`b1790fbf4b`](https://github.com/nodejs/node/commit/b1790fbf4b)] - **doc**: replace node-test-pull-request-lite-pipeline from onboarding (Juan José Arboleda) [#32736](https://github.com/nodejs/node/pull/32736)
-* [[`00ce6a3240`](https://github.com/nodejs/node/commit/00ce6a3240)] - **doc**: add useful v8 option section (Nimit) [#32262](https://github.com/nodejs/node/pull/32262)
-* [[`c78019d792`](https://github.com/nodejs/node/commit/c78019d792)] - **doc**: add himself65 to collaborators (himself65) [#32734](https://github.com/nodejs/node/pull/32734)
-* [[`16126328ac`](https://github.com/nodejs/node/commit/16126328ac)] - **doc**: clarify behavior of napi\_get\_typedarray\_info (Michael Dawson) [#32603](https://github.com/nodejs/node/pull/32603)
-* [[`a5fd29b024`](https://github.com/nodejs/node/commit/a5fd29b024)] - **doc**: remove optional parameter from markdown anchor link (Rich Trott) [#32671](https://github.com/nodejs/node/pull/32671)
-* [[`d2c86a9dfc`](https://github.com/nodejs/node/commit/d2c86a9dfc)] - **doc**: clarify `listening` event (Harshitha KP) [#32581](https://github.com/nodejs/node/pull/32581)
-* [[`9039c03967`](https://github.com/nodejs/node/commit/9039c03967)] - **doc**: update Ninja information in build guide (Adrian Estrada) [#32629](https://github.com/nodejs/node/pull/32629)
-* [[`1d563a646e`](https://github.com/nodejs/node/commit/1d563a646e)] - **doc**: correct version metadata for Readable.from (Dave Vandyke) [#32639](https://github.com/nodejs/node/pull/32639)
-* [[`5e2791ee84`](https://github.com/nodejs/node/commit/5e2791ee84)] - **doc**: adjust paths in openssl maintenance guide (Hassaan Pasha) [#32593](https://github.com/nodejs/node/pull/32593)
-* [[`21c3685623`](https://github.com/nodejs/node/commit/21c3685623)] - **doc**: clarify docs fs.watch exception may be emitted (Juan José Arboleda) [#32513](https://github.com/nodejs/node/pull/32513)
-* [[`c3d91eb94d`](https://github.com/nodejs/node/commit/c3d91eb94d)] - **doc**: add unreachable code on events example (himself65) [#32364](https://github.com/nodejs/node/pull/32364)
-* [[`b4ba9b8bef`](https://github.com/nodejs/node/commit/b4ba9b8bef)] - **doc**: clarify `length` param in `buffer.write` (Harshitha KP) [#32119](https://github.com/nodejs/node/pull/32119)
-* [[`5996df3c39`](https://github.com/nodejs/node/commit/5996df3c39)] - **doc**: document that server.address() can return null (Thomas Watson Steen) [#32519](https://github.com/nodejs/node/pull/32519)
-* [[`a299e9cf28`](https://github.com/nodejs/node/commit/a299e9cf28)] - **doc**: return type of `crypto.getFips()` may change (Richard Lau) [#32580](https://github.com/nodejs/node/pull/32580)
-* [[`4604127697`](https://github.com/nodejs/node/commit/4604127697)] - **doc**: fix return type of `crypto.getFips()` (Richard Lau) [#32580](https://github.com/nodejs/node/pull/32580)
-* [[`f2235f68aa`](https://github.com/nodejs/node/commit/f2235f68aa)] - **doc**: clarify `requireManualDestroy` option (Harshitha KP) [#32514](https://github.com/nodejs/node/pull/32514)
-* [[`7e952f2d38`](https://github.com/nodejs/node/commit/7e952f2d38)] - **doc**: fix wordy sentence (Moni) [#32567](https://github.com/nodejs/node/pull/32567)
-* [[`f93b770bda`](https://github.com/nodejs/node/commit/f93b770bda)] - **doc**: fix more links (Alba Mendez) [#32586](https://github.com/nodejs/node/pull/32586)
-* [[`d764414706`](https://github.com/nodejs/node/commit/d764414706)] - **doc**: improve markdown link checker (Alba Mendez) [#32586](https://github.com/nodejs/node/pull/32586)
-* [[`3d36458cc6`](https://github.com/nodejs/node/commit/3d36458cc6)] - **doc**: add flarna to collaborators (Gerhard Stoebich) [#32620](https://github.com/nodejs/node/pull/32620)
-* [[`4b417f87bd`](https://github.com/nodejs/node/commit/4b417f87bd)] - **doc**: improve fs.read documentation (Hachimi Aa (Sfeir)) [#29270](https://github.com/nodejs/node/pull/29270)
-* [[`959055f225`](https://github.com/nodejs/node/commit/959055f225)] - **doc**: add ASAN build instructions (gengjiawen) [#32436](https://github.com/nodejs/node/pull/32436)
-* [[`f1552f830f`](https://github.com/nodejs/node/commit/f1552f830f)] - **doc**: update context-aware section of addon doc (Gabriel Schulhof) [#28659](https://github.com/nodejs/node/pull/28659)
-* [[`d0d414d98c`](https://github.com/nodejs/node/commit/d0d414d98c)] - **doc**: update AUTHORS list (Luigi Pinca) [#32222](https://github.com/nodejs/node/pull/32222)
-* [[`e51c42dc52`](https://github.com/nodejs/node/commit/e51c42dc52)] - **doc**: tests local links in markdown documents (Antoine du HAMEL) [#32359](https://github.com/nodejs/node/pull/32359)
-* [[`8b355eab57`](https://github.com/nodejs/node/commit/8b355eab57)] - **doc**: fix profile type of --heap-prof-name (Syohei YOSHIDA) [#32404](https://github.com/nodejs/node/pull/32404)
-* [[`59a8dbebc2`](https://github.com/nodejs/node/commit/59a8dbebc2)] - **doc**: use uppercase on windows path (himself65) [#32294](https://github.com/nodejs/node/pull/32294)
-* [[`fa9b10cebe`](https://github.com/nodejs/node/commit/fa9b10cebe)] - **doc**: rename cve\_management\_process.md to fit doc style guide (Ling Samuel) [#32456](https://github.com/nodejs/node/pull/32456)
-* [[`3ed9fcd784`](https://github.com/nodejs/node/commit/3ed9fcd784)] - **doc**: add mildsunrise to collaborators (Alba Mendez) [#32525](https://github.com/nodejs/node/pull/32525)
-* [[`5d15dd3fe3`](https://github.com/nodejs/node/commit/5d15dd3fe3)] - **doc**: add link to DNS definition (unknown) [#32228](https://github.com/nodejs/node/pull/32228)
-* [[`8d27eb94d1`](https://github.com/nodejs/node/commit/8d27eb94d1)] - **doc**: remove extraneous sentence in events.md (Rich Trott) [#32457](https://github.com/nodejs/node/pull/32457)
-* [[`1c84d85437`](https://github.com/nodejs/node/commit/1c84d85437)] - **doc**: trim wording in n-api.md text about exceptions (Rich Trott) [#32457](https://github.com/nodejs/node/pull/32457)
-* [[`bba8dd3344`](https://github.com/nodejs/node/commit/bba8dd3344)] - **doc**: simplify and correct example descriptions in net.md (Rich Trott) [#32451](https://github.com/nodejs/node/pull/32451)
-* [[`2976ac6c2e`](https://github.com/nodejs/node/commit/2976ac6c2e)] - **doc**: add new TSC members (Michael Dawson) [#32473](https://github.com/nodejs/node/pull/32473)
-* [[`3d752cd3b9`](https://github.com/nodejs/node/commit/3d752cd3b9)] - **doc**: improve wording in vm.md (Rich Trott) [#32427](https://github.com/nodejs/node/pull/32427)
-* [[`80a8e20826`](https://github.com/nodejs/node/commit/80a8e20826)] - **doc**: update security release process (Sam Roberts) [#31679](https://github.com/nodejs/node/pull/31679)
-* [[`80493f54c8`](https://github.com/nodejs/node/commit/80493f54c8)] - **doc**: fix some 404 links (Thomas Watson Steen) [#32200](https://github.com/nodejs/node/pull/32200)
-* [[`76e2455b06`](https://github.com/nodejs/node/commit/76e2455b06)] - **doc**: expand fs.watch caveats (Bartosz Sosnowski) [#32176](https://github.com/nodejs/node/pull/32176)
-* [[`c1c3aa1b5f`](https://github.com/nodejs/node/commit/c1c3aa1b5f)] - **doc**: add Ruben to TSC (Michael Dawson) [#32213](https://github.com/nodejs/node/pull/32213)
-* [[`385faf7721`](https://github.com/nodejs/node/commit/385faf7721)] - **doc**: include the error type in the request.resolve doc (Joe Pea) [#32152](https://github.com/nodejs/node/pull/32152)
-* [[`11899f647a`](https://github.com/nodejs/node/commit/11899f647a)] - **doc**: clear up child\_process command resolution (Denys Otrishko) [#32091](https://github.com/nodejs/node/pull/32091)
-* [[`e33e989f20`](https://github.com/nodejs/node/commit/e33e989f20)] - **doc**: clarify windows specific behaviour (Sam Roberts) [#32079](https://github.com/nodejs/node/pull/32079)
-* [[`860239255b`](https://github.com/nodejs/node/commit/860239255b)] - **doc**: improve Buffer documentation (Anna Henningsen) [#32086](https://github.com/nodejs/node/pull/32086)
-* [[`ab1136a7ed`](https://github.com/nodejs/node/commit/ab1136a7ed)] - **doc**: add support encoding link on string\_decoder.md (himself65) [#31911](https://github.com/nodejs/node/pull/31911)
-* [[`c439d83dbf`](https://github.com/nodejs/node/commit/c439d83dbf)] - **doc**: add entry for `AsyncHook` class (Harshitha KP) [#31865](https://github.com/nodejs/node/pull/31865)
-* [[`e6e38ecf64`](https://github.com/nodejs/node/commit/e6e38ecf64)] - **doc**: prevent tables from shrinking page (David Gilbertson) [#31859](https://github.com/nodejs/node/pull/31859)
-* [[`6e68d9816d`](https://github.com/nodejs/node/commit/6e68d9816d)] - **doc**: fix anchor for ERR\_TLS\_INVALID\_CONTEXT (Tobias Nießen) [#31915](https://github.com/nodejs/node/pull/31915)
-* [[`d3b9a8810c`](https://github.com/nodejs/node/commit/d3b9a8810c)] - **doc,crypto**: clarify oaepHash option's impact (Filip Skokan) [#32340](https://github.com/nodejs/node/pull/32340)
-* [[`b85bc0cc02`](https://github.com/nodejs/node/commit/b85bc0cc02)] - **fs**: fixup error message for invalid options.recursive (James M Snell) [#32472](https://github.com/nodejs/node/pull/32472)
-* [[`010814856a`](https://github.com/nodejs/node/commit/010814856a)] - **fs**: fix writeFile\[Sync\] for non-seekable files (Alba Mendez) [#32006](https://github.com/nodejs/node/pull/32006)
-* [[`225ddd5f42`](https://github.com/nodejs/node/commit/225ddd5f42)] - **http**: move free socket error handling to agent (Robert Nagy) [#32003](https://github.com/nodejs/node/pull/32003)
-* [[`3b0204245d`](https://github.com/nodejs/node/commit/3b0204245d)] - **http**: don't emit 'readable' after 'close' (Robert Nagy) [#32277](https://github.com/nodejs/node/pull/32277)
-* [[`52a52d2664`](https://github.com/nodejs/node/commit/52a52d2664)] - **http**: fixup options.method error message (James M Snell) [#32471](https://github.com/nodejs/node/pull/32471)
-* [[`cf47bb9818`](https://github.com/nodejs/node/commit/cf47bb9818)] - **http**: don't emit 'finish' after 'error' (Robert Nagy) [#32276](https://github.com/nodejs/node/pull/32276)
-* [[`f9123eb91b`](https://github.com/nodejs/node/commit/f9123eb91b)] - **http**: fix socket re-use races (Robert Nagy) [#32000](https://github.com/nodejs/node/pull/32000)
-* [[`e54eb46cdb`](https://github.com/nodejs/node/commit/e54eb46cdb)] - **http2**: rename counter in `mapToHeaders` inner loop (Mateusz Krawczuk) [#32012](https://github.com/nodejs/node/pull/32012)
-* [[`0db58753db`](https://github.com/nodejs/node/commit/0db58753db)] - **lib**: fix return type of setTimeout in net.Socket (龙腾道) [#32722](https://github.com/nodejs/node/pull/32722)
-* [[`a152792590`](https://github.com/nodejs/node/commit/a152792590)] - **lib**: removes unnecessary params (Jesus Hernandez) [#32694](https://github.com/nodejs/node/pull/32694)
-* [[`7dd001c1db`](https://github.com/nodejs/node/commit/7dd001c1db)] - **lib**: changed functional logic in cluster schedulers (Yash Ladha) [#32505](https://github.com/nodejs/node/pull/32505)
-* [[`5a671772a2`](https://github.com/nodejs/node/commit/5a671772a2)] - **lib**: use spread operator on cluster (himself65) [#32125](https://github.com/nodejs/node/pull/32125)
-* [[`4d0be3dce5`](https://github.com/nodejs/node/commit/4d0be3dce5)] - **meta**: move inactive collaborators to emeriti (Rich Trott) [#32151](https://github.com/nodejs/node/pull/32151)
-* [[`ecddf6519f`](https://github.com/nodejs/node/commit/ecddf6519f)] - **module**: disable conditional exports, self resolve warnings (Guy Bedford) [#31845](https://github.com/nodejs/node/pull/31845)
-* [[`717f9c5905`](https://github.com/nodejs/node/commit/717f9c5905)] - **module**: path-only CJS exports extension searching (Guy Bedford) [#32351](https://github.com/nodejs/node/pull/32351)
-* [[`ff5ab6f925`](https://github.com/nodejs/node/commit/ff5ab6f925)] - **net**: fix crash if POLLHUP is received (Santiago Gimeno) [#32590](https://github.com/nodejs/node/pull/32590)
-* [[`ed21d32a7c`](https://github.com/nodejs/node/commit/ed21d32a7c)] - **net**: wait for shutdown to complete before closing (Robert Nagy) [#32491](https://github.com/nodejs/node/pull/32491)
-* [[`7d66ceadbb`](https://github.com/nodejs/node/commit/7d66ceadbb)] - **perf,src**: add HistogramBase and internal/histogram.js (James M Snell) [#31988](https://github.com/nodejs/node/pull/31988)
-* [[`f302ac9ae4`](https://github.com/nodejs/node/commit/f302ac9ae4)] - **perf_hooks**: allow omitted parameters in 'performance.measure' (himself65) [#32651](https://github.com/nodejs/node/pull/32651)
-* [[`7c0c4e9a7e`](https://github.com/nodejs/node/commit/7c0c4e9a7e)] - **repl**: fixup error message (James M Snell) [#32474](https://github.com/nodejs/node/pull/32474)
-* [[`522101dbca`](https://github.com/nodejs/node/commit/522101dbca)] - **src**: removes unused v8::Integer and v8::Array namespace (Jesus Hernandez) [#32779](https://github.com/nodejs/node/pull/32779)
-* [[`f9d94143fb`](https://github.com/nodejs/node/commit/f9d94143fb)] - **src**: remove unused v8::TryCatch namespace (Juan José Arboleda) [#32729](https://github.com/nodejs/node/pull/32729)
-* [[`d0d7ebc2a6`](https://github.com/nodejs/node/commit/d0d7ebc2a6)] - **src**: remove duplicated code (himself65) [#32719](https://github.com/nodejs/node/pull/32719)
-* [[`a50220955e`](https://github.com/nodejs/node/commit/a50220955e)] - **src**: refactor to avoid goto in node\_file.cc (Tobias Nießen) [#32637](https://github.com/nodejs/node/pull/32637)
-* [[`fabb53ed79`](https://github.com/nodejs/node/commit/fabb53ed79)] - **src**: fix warnings on SPrintF (himself65) [#32558](https://github.com/nodejs/node/pull/32558)
-* [[`3605a9d67a`](https://github.com/nodejs/node/commit/3605a9d67a)] - **src**: replace goto with lambda in options parser (Tobias Nießen) [#32635](https://github.com/nodejs/node/pull/32635)
-* [[`872f893e0f`](https://github.com/nodejs/node/commit/872f893e0f)] - **src**: align PerformanceState class name with conventions (Anna Henningsen) [#32539](https://github.com/nodejs/node/pull/32539)
-* [[`191cde0e4d`](https://github.com/nodejs/node/commit/191cde0e4d)] - **src**: remove unnecessary 'Local.As' operation (himself65) [#32286](https://github.com/nodejs/node/pull/32286)
-* [[`6d71eb5b5b`](https://github.com/nodejs/node/commit/6d71eb5b5b)] - **src**: add test/abort build tasks (Christian Niederer) [#31740](https://github.com/nodejs/node/pull/31740)
-* [[`0dfb9514de`](https://github.com/nodejs/node/commit/0dfb9514de)] - **src**: add aliased-buffer-overflow abort test (Christian Niederer) [#31740](https://github.com/nodejs/node/pull/31740)
-* [[`28cfaa837e`](https://github.com/nodejs/node/commit/28cfaa837e)] - **src**: check for overflow when extending AliasedBufferBase (Christian Niederer) [#31740](https://github.com/nodejs/node/pull/31740)
-* [[`4155358031`](https://github.com/nodejs/node/commit/4155358031)] - **src**: replace handle dereference with ContainerOf (Harshitha KP) [#32298](https://github.com/nodejs/node/pull/32298)
-* [[`c9b22c8d6d`](https://github.com/nodejs/node/commit/c9b22c8d6d)] - **src**: enhance template function 'MakeUtf8String' (himself65) [#32322](https://github.com/nodejs/node/pull/32322)
-* [[`ad347f4cbb`](https://github.com/nodejs/node/commit/ad347f4cbb)] - **src**: remove excess v8 namespace (himself65) [#32191](https://github.com/nodejs/node/pull/32191)
-* [[`12d83b3242`](https://github.com/nodejs/node/commit/12d83b3242)] - **src**: clean v8 namespaces in env.cc file (Juan José Arboleda) [#32374](https://github.com/nodejs/node/pull/32374)
-* [[`13a7e0546f`](https://github.com/nodejs/node/commit/13a7e0546f)] - **src**: check for empty maybe local (Xavier Stouder) [#32339](https://github.com/nodejs/node/pull/32339)
-* [[`aaf94fd6bb`](https://github.com/nodejs/node/commit/aaf94fd6bb)] - **src**: cleanup DestroyParam when Environment exits (Anna Henningsen) [#32421](https://github.com/nodejs/node/pull/32421)
-* [[`4b5fd24855`](https://github.com/nodejs/node/commit/4b5fd24855)] - **src**: enhance C++ sprintf utility (himself65) [#32385](https://github.com/nodejs/node/pull/32385)
-* [[`46e68bb445`](https://github.com/nodejs/node/commit/46e68bb445)] - **src**: simplify IsolateData shortcut accesses (Anna Henningsen) [#32407](https://github.com/nodejs/node/pull/32407)
-* [[`7aa2ee2bd8`](https://github.com/nodejs/node/commit/7aa2ee2bd8)] - **src**: delete CallbackInfo when cleared from cleanup hook (Anna Henningsen) [#32405](https://github.com/nodejs/node/pull/32405)
-* [[`7a346f63d6`](https://github.com/nodejs/node/commit/7a346f63d6)] - **src**: update comment for SetImmediate() (Anna Henningsen) [#32300](https://github.com/nodejs/node/pull/32300)
-* [[`46c751e7f1`](https://github.com/nodejs/node/commit/46c751e7f1)] - **src**: handle NULL env scenario (himself65) [#32230](https://github.com/nodejs/node/pull/32230)
-* [[`9b6f678751`](https://github.com/nodejs/node/commit/9b6f678751)] - **src**: fix warn\_unused\_result compiler warning (Colin Ihrig) [#32241](https://github.com/nodejs/node/pull/32241)
-* [[`4e268314b5`](https://github.com/nodejs/node/commit/4e268314b5)] - **src**: refactor to more safe method (gengjiawen) [#32087](https://github.com/nodejs/node/pull/32087)
-* [[`f223d2c7e4`](https://github.com/nodejs/node/commit/f223d2c7e4)] - **src**: fix spawnSync CHECK when SIGKILL fails (Ben Noordhuis) [#31768](https://github.com/nodejs/node/pull/31768)
-* [[`5b2f698b32`](https://github.com/nodejs/node/commit/5b2f698b32)] - **src**: fix missing extra ca in tls.rootCertificates (Eric Bickle) [#32075](https://github.com/nodejs/node/pull/32075)
-* [[`a53980d947`](https://github.com/nodejs/node/commit/a53980d947)] - **src**: fix -Wmaybe-uninitialized compiler warning (Ben Noordhuis) [#31809](https://github.com/nodejs/node/pull/31809)
-* [[`a2d961da23`](https://github.com/nodejs/node/commit/a2d961da23)] - **src**: remove unused include from node\_file.cc (Ben Noordhuis) [#31809](https://github.com/nodejs/node/pull/31809)
-* [[`8fe70e88fe`](https://github.com/nodejs/node/commit/8fe70e88fe)] - **src**: elevate v8 namespace (RamanandPatil) [#32041](https://github.com/nodejs/node/pull/32041)
-* [[`7e5e34d01e`](https://github.com/nodejs/node/commit/7e5e34d01e)] - **src**: simplify node\_worker.cc using new KVStore API (Denys Otrishko) [#31773](https://github.com/nodejs/node/pull/31773)
-* [[`7152fe3180`](https://github.com/nodejs/node/commit/7152fe3180)] - **src**: improve KVStore API (Denys Otrishko) [#31773](https://github.com/nodejs/node/pull/31773)
-* [[`3bf21b096e`](https://github.com/nodejs/node/commit/3bf21b096e)] - **src**: fix minor typo in base\_object.h (Daniel Bevenius) [#31535](https://github.com/nodejs/node/pull/31535)
-* [[`8d1eeb1ae5`](https://github.com/nodejs/node/commit/8d1eeb1ae5)] - **stream**: combine properties using defineProperties (antsmartian) [#31187](https://github.com/nodejs/node/pull/31187)
-* [[`d07dd313ae`](https://github.com/nodejs/node/commit/d07dd313ae)] - **stream**: add regression test for async iteration completion (Matteo Collina) [#31508](https://github.com/nodejs/node/pull/31508)
-* [[`2f72054ec7`](https://github.com/nodejs/node/commit/2f72054ec7)] - **test**: replace console.log/error with debuglog (Agustin Daguerre) [#32695](https://github.com/nodejs/node/pull/32695)
-* [[`bc9453a870`](https://github.com/nodejs/node/commit/bc9453a870)] - **test**: make sure that inspector tests finish (Anna Henningsen) [#32673](https://github.com/nodejs/node/pull/32673)
-* [[`2cf7381a87`](https://github.com/nodejs/node/commit/2cf7381a87)] - **test**: fix check error name on error instance (himself65) [#32508](https://github.com/nodejs/node/pull/32508)
-* [[`e4174165f3`](https://github.com/nodejs/node/commit/e4174165f3)] - ***Revert*** "**test**: mark empty udp tests flaky on OS X" (Luigi Pinca) [#32489](https://github.com/nodejs/node/pull/32489)
-* [[`6feed98f33`](https://github.com/nodejs/node/commit/6feed98f33)] - **test**: remove unused variables on async hook test (Julian Duque) [#32630](https://github.com/nodejs/node/pull/32630)
-* [[`b0386b4aaf`](https://github.com/nodejs/node/commit/b0386b4aaf)] - **test**: check that --expose-internals is disallowed in NODE\_OPTIONS (Juan José Arboleda) [#32554](https://github.com/nodejs/node/pull/32554)
-* [[`0adc867d59`](https://github.com/nodejs/node/commit/0adc867d59)] - **test**: add Worker initialization failure test case (Harshitha KP) [#31929](https://github.com/nodejs/node/pull/31929)
-* [[`73221278d7`](https://github.com/nodejs/node/commit/73221278d7)] - **test**: fix tool path in test-doctool-versions.js (Richard Lau) [#32645](https://github.com/nodejs/node/pull/32645)
-* [[`90a5b9d964`](https://github.com/nodejs/node/commit/90a5b9d964)] - **test**: copy addons .gitignore to test/abort/ (Anna Henningsen) [#32624](https://github.com/nodejs/node/pull/32624)
-* [[`39be571a3f`](https://github.com/nodejs/node/commit/39be571a3f)] - **test**: refactor test-http2-buffersize (Rich Trott) [#32540](https://github.com/nodejs/node/pull/32540)
-* [[`f71007ff39`](https://github.com/nodejs/node/commit/f71007ff39)] - **test**: skip crypto test on arm buildbots (Ben Noordhuis) [#32636](https://github.com/nodejs/node/pull/32636)
-* [[`4e405ee899`](https://github.com/nodejs/node/commit/4e405ee899)] - **test**: replace console.error() with debuglog calls (Rich Trott) [#32588](https://github.com/nodejs/node/pull/32588)
-* [[`8083d452e6`](https://github.com/nodejs/node/commit/8083d452e6)] - **test**: add a missing common.mustCall (Harshitha KP) [#32305](https://github.com/nodejs/node/pull/32305)
-* [[`416531227e`](https://github.com/nodejs/node/commit/416531227e)] - **test**: remove unnecessary console.log() calls (Juan José Arboleda) [#32541](https://github.com/nodejs/node/pull/32541)
-* [[`30d21fb6e6`](https://github.com/nodejs/node/commit/30d21fb6e6)] - **test**: replace console.log() with debuglog() (Juan José Arboleda) [#32550](https://github.com/nodejs/node/pull/32550)
-* [[`fcf1123052`](https://github.com/nodejs/node/commit/fcf1123052)] - **test**: validate util.format when the value is 'Infinity' (Andrés M. Gómez) [#32573](https://github.com/nodejs/node/pull/32573)
-* [[`e2174e4e3c`](https://github.com/nodejs/node/commit/e2174e4e3c)] - **test**: fix fs test-fs-utimes strictEqual arg order (Ben Noordhuis) [#32420](https://github.com/nodejs/node/pull/32420)
-* [[`32ab30cc35`](https://github.com/nodejs/node/commit/32ab30cc35)] - **test**: use common.mustCall in test-worker-esm-exit (himself65) [#32544](https://github.com/nodejs/node/pull/32544)
-* [[`a0552441fa`](https://github.com/nodejs/node/commit/a0552441fa)] - **test**: use template strings in parallel tests (Daniel Estiven Rico Posada) [#32549](https://github.com/nodejs/node/pull/32549)
-* [[`d53d152da3`](https://github.com/nodejs/node/commit/d53d152da3)] - **test**: add known issues test for #31733 (Ben Noordhuis) [#31734](https://github.com/nodejs/node/pull/31734)
-* [[`d6f6623243`](https://github.com/nodejs/node/commit/d6f6623243)] - **test**: refactor test-http-information-processing (Rich Trott) [#32547](https://github.com/nodejs/node/pull/32547)
-* [[`b6e739a6b3`](https://github.com/nodejs/node/commit/b6e739a6b3)] - **test**: skip a wasi test on IBMi PASE (Xu Meng) [#32459](https://github.com/nodejs/node/pull/32459)
-* [[`a40e7daf3c`](https://github.com/nodejs/node/commit/a40e7daf3c)] - **test**: harden the tick sampling logic (Harshitha KP) [#32190](https://github.com/nodejs/node/pull/32190)
-* [[`9c84d7773a`](https://github.com/nodejs/node/commit/9c84d7773a)] - **test**: skip some binding tests on IBMi PASE (Xu Meng) [#31967](https://github.com/nodejs/node/pull/31967)
-* [[`afc0c708a2`](https://github.com/nodejs/node/commit/afc0c708a2)] - **test**: revise test-http-response-multi-content-length (Rich Trott) [#32526](https://github.com/nodejs/node/pull/32526)
-* [[`df890ad3d2`](https://github.com/nodejs/node/commit/df890ad3d2)] - **test**: remove a duplicated test (himself65) [#32453](https://github.com/nodejs/node/pull/32453)
-* [[`fa4de53a3e`](https://github.com/nodejs/node/commit/fa4de53a3e)] - **test**: check bundled binaries are signed on macOS (Richard Lau) [#32522](https://github.com/nodejs/node/pull/32522)
-* [[`d9abea5e3f`](https://github.com/nodejs/node/commit/d9abea5e3f)] - **test**: unflake async-hooks/test-statwatcher (Bartosz Sosnowski) [#32484](https://github.com/nodejs/node/pull/32484)
-* [[`5cae1b7a53`](https://github.com/nodejs/node/commit/5cae1b7a53)] - **test**: use Promise.all() in test-cluster-net-listen-ipv6only-false (Rich Trott) [#32398](https://github.com/nodejs/node/pull/32398)
-* [[`60db56ddba`](https://github.com/nodejs/node/commit/60db56ddba)] - **test**: replace Map with Array in test-cluster-net-listen-ipv6only-false (Rich Trott) [#32398](https://github.com/nodejs/node/pull/32398)
-* [[`565f0f73e2`](https://github.com/nodejs/node/commit/565f0f73e2)] - **test**: revise test-http-client-default-headers-exist (Rich Trott) [#32493](https://github.com/nodejs/node/pull/32493)
-* [[`7f5b89c307`](https://github.com/nodejs/node/commit/7f5b89c307)] - **test**: use mustCall in place of countdown in timers test (Rich Trott) [#32416](https://github.com/nodejs/node/pull/32416)
-* [[`97e352d1a6`](https://github.com/nodejs/node/commit/97e352d1a6)] - **test**: replace countdown with Promise.all() in cluster-net-listen tests (Rich Trott) [#32381](https://github.com/nodejs/node/pull/32381)
-* [[`1b79174203`](https://github.com/nodejs/node/commit/1b79174203)] - **test**: replace Map with Array in cluster-net-listen tests (Rich Trott) [#32381](https://github.com/nodejs/node/pull/32381)
-* [[`85ae5661df`](https://github.com/nodejs/node/commit/85ae5661df)] - **test**: uv\_tty\_init returns EBADF on IBM i (Xu Meng) [#32338](https://github.com/nodejs/node/pull/32338)
-* [[`8dbd7cf0e4`](https://github.com/nodejs/node/commit/8dbd7cf0e4)] - **test**: use Promise.all() in test-hash-seed (Rich Trott) [#32273](https://github.com/nodejs/node/pull/32273)
-* [[`92a207cd2d`](https://github.com/nodejs/node/commit/92a207cd2d)] - **test**: workaround for V8 8.1 inspector pause issue (Matheus Marchini) [#32234](https://github.com/nodejs/node/pull/32234)
-* [[`776905ef99`](https://github.com/nodejs/node/commit/776905ef99)] - **test**: use portable EOL (Harshitha KP) [#32104](https://github.com/nodejs/node/pull/32104)
-* [[`914edddd79`](https://github.com/nodejs/node/commit/914edddd79)] - **test**: `buffer.write` with longer string scenario (Harshitha KP) [#32123](https://github.com/nodejs/node/pull/32123)
-* [[`7060ed1176`](https://github.com/nodejs/node/commit/7060ed1176)] - **test**: fix test-tls-env-extra-ca-file-load (Eric Bickle) [#32073](https://github.com/nodejs/node/pull/32073)
-* [[`bee009d271`](https://github.com/nodejs/node/commit/bee009d271)] - **test**: improve test-fs-existssync-false.js (himself65) [#31883](https://github.com/nodejs/node/pull/31883)
-* [[`0403f00321`](https://github.com/nodejs/node/commit/0403f00321)] - **test**: mark test-timers-blocking-callback flaky on osx (Myles Borins) [#32189](https://github.com/nodejs/node/pull/32189)
-* [[`fa7e975d2f`](https://github.com/nodejs/node/commit/fa7e975d2f)] - **test**: warn when inspector process crashes (Matheus Marchini) [#32133](https://github.com/nodejs/node/pull/32133)
-* [[`4a94179a3c`](https://github.com/nodejs/node/commit/4a94179a3c)] - **tools**: update Boxstarter script and document (himself65) [#32299](https://github.com/nodejs/node/pull/32299)
-* [[`8bc53d1298`](https://github.com/nodejs/node/commit/8bc53d1298)] - **tools**: update ESLint to 7.0.0-alpha.3 (Colin Ihrig) [#32533](https://github.com/nodejs/node/pull/32533)
-* [[`baf56f8135`](https://github.com/nodejs/node/commit/baf56f8135)] - **tools**: fixup icutrim.py use of string and bytes objects (Jonathan MERCIER) [#31659](https://github.com/nodejs/node/pull/31659)
-* [[`540a024057`](https://github.com/nodejs/node/commit/540a024057)] - **tools**: update to acorn@7.1.1 (Rich Trott) [#32259](https://github.com/nodejs/node/pull/32259)
-* [[`ecf842ec27`](https://github.com/nodejs/node/commit/ecf842ec27)] - **tools**: enable no-useless-backreference lint rule (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
-* [[`bcf152e2d0`](https://github.com/nodejs/node/commit/bcf152e2d0)] - **tools**: enable default-case-last lint rule (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
-* [[`5dacfa76f2`](https://github.com/nodejs/node/commit/5dacfa76f2)] - **tools**: update ESLint to 7.0.0-alpha.2 (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
-* [[`e641b3c6b6`](https://github.com/nodejs/node/commit/e641b3c6b6)] - **tools**: update ESLint to 7.0.0-alpha.1 (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
-* [[`394fa1f356`](https://github.com/nodejs/node/commit/394fa1f356)] - **tools**: update ESLint to 7.0.0-alpha.0 (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
-* [[`848df6f6cc`](https://github.com/nodejs/node/commit/848df6f6cc)] - **tracing**: do not attempt to call into JS when disallowed (Anna Henningsen) [#32548](https://github.com/nodejs/node/pull/32548)
-* [[`12fe985154`](https://github.com/nodejs/node/commit/12fe985154)] - **util**: only inspect error properties that are not visible otherwise (Ruben Bridgewater) [#32327](https://github.com/nodejs/node/pull/32327)
-* [[`eccd2a7740`](https://github.com/nodejs/node/commit/eccd2a7740)] - **util**: fix inspecting document.all (Gus Caplan) [#31938](https://github.com/nodejs/node/pull/31938)
-* [[`58c6422f83`](https://github.com/nodejs/node/commit/58c6422f83)] - **util**: text decoding allows SharedArrayBuffer (Bradley Farias) [#32203](https://github.com/nodejs/node/pull/32203)
-* [[`10c525f38d`](https://github.com/nodejs/node/commit/10c525f38d)] - **win,build**: set exit\_code on configure failure (Bartlomiej Brzozowski) [#32205](https://github.com/nodejs/node/pull/32205)
-* [[`aeea7d9c1f`](https://github.com/nodejs/node/commit/aeea7d9c1f)] - **worker**: do not emit 'exit' events during process.exit() (Anna Henningsen) [#32546](https://github.com/nodejs/node/pull/32546)
-* [[`28cb7e78ff`](https://github.com/nodejs/node/commit/28cb7e78ff)] - **worker**: improve MessagePort performance (Anna Henningsen) [#31605](https://github.com/nodejs/node/pull/31605)
-
 <a id="12.16.2"></a>
 ## 2020-04-08, Version 12.16.2 'Erbium' (LTS), @codebytere
 
diff --git a/doc/changelogs/CHANGELOG_V13.md b/doc/changelogs/CHANGELOG_V13.md
new file mode 100644
index 0000000000000000000000000000000000000000..a7853de9d4576b8d5f693b340a39b9e3e74b523a
--- /dev/null
+++ b/doc/changelogs/CHANGELOG_V13.md
@@ -0,0 +1,2033 @@
+# Node.js 13 ChangeLog
+
+<!--lint disable prohibited-strings-->
+<!--lint disable maximum-line-length-->
+<!--lint disable no-literal-urls-->
+
+<table>
+<tr>
+<th>Current</th>
+</tr>
+<tr>
+<td>
+<a href="#13.12.0">13.12.0</a><br/>
+<a href="#13.11.0">13.11.0</a><br/>
+<a href="#13.10.1">13.10.1</a><br/>
+<a href="#13.10.0">13.10.0</a><br/>
+<a href="#13.9.0">13.9.0</a><br/>
+<a href="#13.8.0">13.8.0</a><br/>
+<a href="#13.7.0">13.7.0</a><br/>
+<a href="#13.6.0">13.6.0</a><br/>
+<a href="#13.5.0">13.5.0</a><br/>
+<a href="#13.4.0">13.4.0</a><br/>
+<a href="#13.3.0">13.3.0</a><br/>
+<a href="#13.2.0">13.2.0</a><br/>
+<a href="#13.1.0">13.1.0</a><br/>
+<a href="#13.0.1">13.0.1</a><br/>
+<a href="#13.0.0">13.0.0</a><br/>
+</td>
+</tr>
+</table>
+
+* Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [12.x](CHANGELOG_V12.md)
+  * [11.x](CHANGELOG_V11.md)
+  * [10.x](CHANGELOG_V10.md)
+  * [9.x](CHANGELOG_V9.md)
+  * [8.x](CHANGELOG_V8.md)
+  * [7.x](CHANGELOG_V7.md)
+  * [6.x](CHANGELOG_V6.md)
+  * [5.x](CHANGELOG_V5.md)
+  * [4.x](CHANGELOG_V4.md)
+  * [0.12.x](CHANGELOG_V012.md)
+  * [0.10.x](CHANGELOG_V010.md)
+  * [io.js](CHANGELOG_IOJS.md)
+  * [Archive](CHANGELOG_ARCHIVE.md)
+
+<a id="13.12.0"></a>
+## 2020-03-26, Version 13.12.0 (Current), @mylesborins
+
+### macOS package notarization and a change in builder configuration
+
+The macOS binaries for this release, and future 13.x releases, are now being compiled on
+macOS 10.15 (Catalina) with Xcode 11 to support package notarization, a requirement for
+installing on .pkg files on macOS 10.15 and later. Previous builds of Node.js 13.x were
+compiled on macOS 10.11 (El Capitan) with Xcode 10. As binaries are still being compiled
+to support a minimum of macOS 10.10 (Yosemite) we do not anticipate this having a negative
+impact on Node.js 13.x users with older versions of macOS.
+
+### Notable Changes
+
+* **build**:
+  * macOS package notarization (Rod Vagg) [#31459](https://github.com/nodejs/node/pull/31459)
+* **deps**:
+  * upgrade npm to 6.14.4 (Ruy Adorno) [#32495](https://github.com/nodejs/node/pull/32495)
+  * update to uvwasi 0.0.6 (Colin Ihrig) [#32309](https://github.com/nodejs/node/pull/32309)
+  * upgrade to libuv 1.35.0 (Colin Ihrig) [#32204](https://github.com/nodejs/node/pull/32204)
+* **lib**:
+  * add --disable-proto option to cli (Gus Caplan) [#32279](https://github.com/nodejs/node/pull/32279)
+* **node\_report**:
+  * move diagnostic reports to stable (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
+* **worker**:
+  * allow URL in Worker constructor (Antoine du HAMEL) [#31664](https://github.com/nodejs/node/pull/31664)
+* **util**:
+  * use a global symbol for `util.promisify.custom` (ExE Boss) [#31672](https://github.com/nodejs/node/pull/31672)
+
+### Commits
+
+* [[`81183caa4c`](https://github.com/nodejs/node/commit/81183caa4c)] - **build**: annotate markdown lint failures in pull requests (Richard Lau) [#32391](https://github.com/nodejs/node/pull/32391)
+* [[`f8a020e636`](https://github.com/nodejs/node/commit/f8a020e636)] - **build**: macOS package notarization (Rod Vagg) [#31459](https://github.com/nodejs/node/pull/31459)
+* [[`85bdb424c2`](https://github.com/nodejs/node/commit/85bdb424c2)] - ***Revert*** "**build**: add asan check in Github action" (Matheus Marchini) [#32324](https://github.com/nodejs/node/pull/32324)
+* [[`8ea5ffc033`](https://github.com/nodejs/node/commit/8ea5ffc033)] - **build**: expand ASAN acronym in configure help (Sam Roberts) [#32325](https://github.com/nodejs/node/pull/32325)
+* [[`074c3c144f`](https://github.com/nodejs/node/commit/074c3c144f)] - **(SEMVER-MINOR)** **build**: make --without-report a no-op (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
+* [[`96ad768dbc`](https://github.com/nodejs/node/commit/96ad768dbc)] - **(SEMVER-MINOR)** **build**: remove node\_report option in node.gyp (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
+* [[`2069c4e530`](https://github.com/nodejs/node/commit/2069c4e530)] - **build**: disable libstdc++ debug containers globally (Ben Noordhuis) [#30147](https://github.com/nodejs/node/pull/30147)
+* [[`79fdc6bea3`](https://github.com/nodejs/node/commit/79fdc6bea3)] - **cli**: allow --huge-max-old-generation-size in NODE\_OPTIONS (Anna Henningsen) [#32251](https://github.com/nodejs/node/pull/32251)
+* [[`deab08bc4e`](https://github.com/nodejs/node/commit/deab08bc4e)] - **deps**: upgrade npm to 6.14.4 (Ruy Adorno) [#32495](https://github.com/nodejs/node/pull/32495)
+* [[`6387cf88c2`](https://github.com/nodejs/node/commit/6387cf88c2)] - **deps**: update term-size with signed version (Rod Vagg) [#31459](https://github.com/nodejs/node/pull/31459)
+* [[`8201704231`](https://github.com/nodejs/node/commit/8201704231)] - **deps**: remove \*.pyc files from deps/npm (Ben Noordhuis) [#32387](https://github.com/nodejs/node/pull/32387)
+* [[`eef4721174`](https://github.com/nodejs/node/commit/eef4721174)] - **deps**: update npm to 6.14.3 (Myles Borins) [#32368](https://github.com/nodejs/node/pull/32368)
+* [[`fbdc4f59f7`](https://github.com/nodejs/node/commit/fbdc4f59f7)] - **deps**: upgrade npm to 6.14.1 (Isaac Z. Schlueter) [#31977](https://github.com/nodejs/node/pull/31977)
+* [[`d640426c8b`](https://github.com/nodejs/node/commit/d640426c8b)] - **deps**: update archs files for OpenSSL-1.1.1e (Hassaan Pasha) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`d719f87ad6`](https://github.com/nodejs/node/commit/d719f87ad6)] - **deps**: adjust openssl configuration for 1.1.1e (Hassaan Pasha) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`3878d8dd2e`](https://github.com/nodejs/node/commit/3878d8dd2e)] - **deps**: upgrade openssl sources to 1.1.1e (Hassaan Pasha) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`2cb9f7acb6`](https://github.com/nodejs/node/commit/2cb9f7acb6)] - **deps**: update to ICU 66.1 (Steven R. Loomis) [#32348](https://github.com/nodejs/node/pull/32348)
+* [[`e16964ed22`](https://github.com/nodejs/node/commit/e16964ed22)] - **deps**: minor ICU fixes: maint docs/tool, downloader (Steven R. Loomis) [#32347](https://github.com/nodejs/node/pull/32347)
+* [[`3825afed74`](https://github.com/nodejs/node/commit/3825afed74)] - **deps**: upgrade to c-ares v1.16.0 (Anna Henningsen) [#32246](https://github.com/nodejs/node/pull/32246)
+* [[`7904ecd245`](https://github.com/nodejs/node/commit/7904ecd245)] - **deps**: update to uvwasi 0.0.6 (Colin Ihrig) [#32309](https://github.com/nodejs/node/pull/32309)
+* [[`bee126131a`](https://github.com/nodejs/node/commit/bee126131a)] - **deps**: upgrade to libuv 1.35.0 (Colin Ihrig) [#32204](https://github.com/nodejs/node/pull/32204)
+* [[`ae90bccb70`](https://github.com/nodejs/node/commit/ae90bccb70)] - **deps**: V8: cherry-pick f9257802c1c0 (Matheus Marchini) [#32180](https://github.com/nodejs/node/pull/32180)
+* [[`11ed1e6c86`](https://github.com/nodejs/node/commit/11ed1e6c86)] - **deps,doc**: move openssl maintenance guide to doc (Sam Roberts) [#32209](https://github.com/nodejs/node/pull/32209)
+* [[`40a9289e53`](https://github.com/nodejs/node/commit/40a9289e53)] - **doc**: remove extraneous sentence in events.md (Rich Trott) [#32457](https://github.com/nodejs/node/pull/32457)
+* [[`6168bd5951`](https://github.com/nodejs/node/commit/6168bd5951)] - **doc**: remove unnecessary "obvious(ly)" modifiers in esm.md (Rich Trott) [#32457](https://github.com/nodejs/node/pull/32457)
+* [[`9fda9123b1`](https://github.com/nodejs/node/commit/9fda9123b1)] - **doc**: trim wording in n-api.md text about exceptions (Rich Trott) [#32457](https://github.com/nodejs/node/pull/32457)
+* [[`3e002c3977`](https://github.com/nodejs/node/commit/3e002c3977)] - **doc**: update async\_hooks.md (Victor) [#32382](https://github.com/nodejs/node/pull/32382)
+* [[`6693b40bd5`](https://github.com/nodejs/node/commit/6693b40bd5)] - **doc**: simplify and correct example descriptions in net.md (Rich Trott) [#32451](https://github.com/nodejs/node/pull/32451)
+* [[`b5e4adfb49`](https://github.com/nodejs/node/commit/b5e4adfb49)] - **doc**: add new TSC members (Michael Dawson) [#32473](https://github.com/nodejs/node/pull/32473)
+* [[`99a7636443`](https://github.com/nodejs/node/commit/99a7636443)] - **doc**: fix lint warning in doc/api/esm.md (Richard Lau) [#32462](https://github.com/nodejs/node/pull/32462)
+* [[`dfcc3e8990`](https://github.com/nodejs/node/commit/dfcc3e8990)] - **doc**: improve wording in vm.md (Rich Trott) [#32427](https://github.com/nodejs/node/pull/32427)
+* [[`bbea3f21ff`](https://github.com/nodejs/node/commit/bbea3f21ff)] - **doc**: improve wording in esm.md (Rich Trott) [#32427](https://github.com/nodejs/node/pull/32427)
+* [[`4ca30303a7`](https://github.com/nodejs/node/commit/4ca30303a7)] - **doc**: import clarifications with links to MDN (Eric Dobbertin) [#31479](https://github.com/nodejs/node/pull/31479)
+* [[`471a5d8b82`](https://github.com/nodejs/node/commit/471a5d8b82)] - **doc**: add note re term-size commit on top of npm (Rod Vagg) [#32403](https://github.com/nodejs/node/pull/32403)
+* [[`99f260f42a`](https://github.com/nodejs/node/commit/99f260f42a)] - **doc**: official macOS builds now on 10.15 + Xcode 11 (Rod Vagg) [#31459](https://github.com/nodejs/node/pull/31459)
+* [[`569e555c2e`](https://github.com/nodejs/node/commit/569e555c2e)] - **doc**: update security release process (Sam Roberts) [#31679](https://github.com/nodejs/node/pull/31679)
+* [[`d2ce8e9c99`](https://github.com/nodejs/node/commit/d2ce8e9c99)] - **doc**: fix some 404 links (Thomas Watson Steen) [#32200](https://github.com/nodejs/node/pull/32200)
+* [[`b8753466e5`](https://github.com/nodejs/node/commit/b8753466e5)] - **doc**: complete n-api version matrix (Gabriel Schulhof) [#32304](https://github.com/nodejs/node/pull/32304)
+* [[`2e1fb2b9af`](https://github.com/nodejs/node/commit/2e1fb2b9af)] - **(SEMVER-MINOR)** **doc**: update stability of report features (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
+* [[`597bcb530a`](https://github.com/nodejs/node/commit/597bcb530a)] - **doc**: update conditional exports recommendations (Guy Bedford) [#32098](https://github.com/nodejs/node/pull/32098)
+* [[`5080734301`](https://github.com/nodejs/node/commit/5080734301)] - **doc**: expand fs.watch caveats (Bartosz Sosnowski) [#32176](https://github.com/nodejs/node/pull/32176)
+* [[`19fee761ba`](https://github.com/nodejs/node/commit/19fee761ba)] - **doc**: add Ruben to TSC (Michael Dawson) [#32213](https://github.com/nodejs/node/pull/32213)
+* [[`c72a678d0c`](https://github.com/nodejs/node/commit/c72a678d0c)] - **doc**: add missing link for v13.11.0 changelog (Myles Borins) [#32218](https://github.com/nodejs/node/pull/32218)
+* [[`cd388b25f6`](https://github.com/nodejs/node/commit/cd388b25f6)] - **(SEMVER-MINOR)** **doc,lib,src,test**: make --experimental-report a nop (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
+* [[`71a2fa24da`](https://github.com/nodejs/node/commit/71a2fa24da)] - **errors**: drop pronouns from ERR\_WORKER\_PATH message (Colin Ihrig) [#32285](https://github.com/nodejs/node/pull/32285)
+* [[`3e9012a3da`](https://github.com/nodejs/node/commit/3e9012a3da)] - **esm**: port loader code to JS (Anna Henningsen) [#32201](https://github.com/nodejs/node/pull/32201)
+* [[`ef32069d0c`](https://github.com/nodejs/node/commit/ef32069d0c)] - **http**: don't emit 'finish' after 'error' (Robert Nagy) [#32276](https://github.com/nodejs/node/pull/32276)
+* [[`d2fea9fb4a`](https://github.com/nodejs/node/commit/d2fea9fb4a)] - **http2**: rename counter in `mapToHeaders` inner loop (Mateusz Krawczuk) [#32012](https://github.com/nodejs/node/pull/32012)
+* [[`36ba54e8e1`](https://github.com/nodejs/node/commit/36ba54e8e1)] - **lib**: add option to disable \_\_proto\_\_ (Gus Caplan) [#32279](https://github.com/nodejs/node/pull/32279)
+* [[`435341a94f`](https://github.com/nodejs/node/commit/435341a94f)] - **lib**: use spread operator on cluster (himself65) [#32125](https://github.com/nodejs/node/pull/32125)
+* [[`cd0982ae7c`](https://github.com/nodejs/node/commit/cd0982ae7c)] - **lib**: change var to let/const (himself65) [#32037](https://github.com/nodejs/node/pull/32037)
+* [[`397cbca720`](https://github.com/nodejs/node/commit/397cbca720)] - **meta**: move inactive collaborators to emeriti (Rich Trott) [#32151](https://github.com/nodejs/node/pull/32151)
+* [[`7356c43997`](https://github.com/nodejs/node/commit/7356c43997)] - **module**: add hook for global preload code (Jan Krems) [#32068](https://github.com/nodejs/node/pull/32068)
+* [[`59a21e28d6`](https://github.com/nodejs/node/commit/59a21e28d6)] - **n-api**: fix comment on expected N-API version (Michael Dawson) [#32236](https://github.com/nodejs/node/pull/32236)
+* [[`1ecd407a71`](https://github.com/nodejs/node/commit/1ecd407a71)] - **repl**: align preview with the actual executed code (Ruben Bridgewater) [#32154](https://github.com/nodejs/node/pull/32154)
+* [[`28e298f219`](https://github.com/nodejs/node/commit/28e298f219)] - **report**: handle on-fatalerror better (Harshitha KP) [#32207](https://github.com/nodejs/node/pull/32207)
+* [[`94952b4ac8`](https://github.com/nodejs/node/commit/94952b4ac8)] - **src**: enhance C++ sprintf utility (himself65) [#32385](https://github.com/nodejs/node/pull/32385)
+* [[`e9e12b8f36`](https://github.com/nodejs/node/commit/e9e12b8f36)] - **src**: use single ObjectTemplate for TextDecoder (Anna Henningsen) [#32426](https://github.com/nodejs/node/pull/32426)
+* [[`6f06cf0bf4`](https://github.com/nodejs/node/commit/6f06cf0bf4)] - **src**: delete BaseObjectWeakPtr data when pointee is gone (Anna Henningsen) [#32393](https://github.com/nodejs/node/pull/32393)
+* [[`2bcf535a05`](https://github.com/nodejs/node/commit/2bcf535a05)] - **src**: simplify IsolateData shortcut accesses (Anna Henningsen) [#32407](https://github.com/nodejs/node/pull/32407)
+* [[`2fe351f6c3`](https://github.com/nodejs/node/commit/2fe351f6c3)] - **src**: delete CallbackInfo when cleared from cleanup hook (Anna Henningsen) [#32405](https://github.com/nodejs/node/pull/32405)
+* [[`bd55a9a607`](https://github.com/nodejs/node/commit/bd55a9a607)] - **src**: avoid Isolate::GetCurrent() for platform implementation (Anna Henningsen) [#32269](https://github.com/nodejs/node/pull/32269)
+* [[`11650c683e`](https://github.com/nodejs/node/commit/11650c683e)] - **src**: update comment for SetImmediate() (Anna Henningsen) [#32300](https://github.com/nodejs/node/pull/32300)
+* [[`243d0d4716`](https://github.com/nodejs/node/commit/243d0d4716)] - **src**: add debug option to report large page stats (Gabriel Schulhof) [#32331](https://github.com/nodejs/node/pull/32331)
+* [[`f873d87a7f`](https://github.com/nodejs/node/commit/f873d87a7f)] - **src**: prefer OnScopeLeave over shared\_ptr\<void\> (Anna Henningsen) [#32247](https://github.com/nodejs/node/pull/32247)
+* [[`1c4a112fcc`](https://github.com/nodejs/node/commit/1c4a112fcc)] - **src**: clean up stream\_base.h and stream-base-inl.h (James M Snell) [#32307](https://github.com/nodejs/node/pull/32307)
+* [[`1476182670`](https://github.com/nodejs/node/commit/1476182670)] - **src**: handle NULL env scenario (himself65) [#32230](https://github.com/nodejs/node/pull/32230)
+* [[`1950c08ab1`](https://github.com/nodejs/node/commit/1950c08ab1)] - **(SEMVER-MINOR)** **src**: unconditionally include report feature (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
+* [[`c00ce7b708`](https://github.com/nodejs/node/commit/c00ce7b708)] - **src**: find .text section using dl\_iterate\_phdr (Gabriel Schulhof) [#32244](https://github.com/nodejs/node/pull/32244)
+* [[`7fc5e6d37b`](https://github.com/nodejs/node/commit/7fc5e6d37b)] - **src**: fix warn\_unused\_result compiler warning (Colin Ihrig) [#32241](https://github.com/nodejs/node/pull/32241)
+* [[`d497f268f2`](https://github.com/nodejs/node/commit/d497f268f2)] - **src**: refactor to more safe method (gengjiawen) [#32087](https://github.com/nodejs/node/pull/32087)
+* [[`b5b7bf5ea4`](https://github.com/nodejs/node/commit/b5b7bf5ea4)] - **src,cli**: support compact (one-line) JSON reports (Sam Roberts) [#32254](https://github.com/nodejs/node/pull/32254)
+* [[`56da8dfd86`](https://github.com/nodejs/node/commit/56da8dfd86)] - **stream**: emit 'pause' on unpipe (Robert Nagy) [#32476](https://github.com/nodejs/node/pull/32476)
+* [[`b7a8878f0c`](https://github.com/nodejs/node/commit/b7a8878f0c)] - **stream**: fix pipeline with dest in objectMode (Robert Nagy) [#32414](https://github.com/nodejs/node/pull/32414)
+* [[`0185e3a46c`](https://github.com/nodejs/node/commit/0185e3a46c)] - **stream**: add pipeline test for destroy of returned stream (Robert Nagy) [#32425](https://github.com/nodejs/node/pull/32425)
+* [[`23ba0889ce`](https://github.com/nodejs/node/commit/23ba0889ce)] - **stream**: don't emit 'finish' after 'error' (Robert Nagy) [#32275](https://github.com/nodejs/node/pull/32275)
+* [[`07e41311d0`](https://github.com/nodejs/node/commit/07e41311d0)] - **test**: refactoring / cleanup on child-process tests (James M Snell) [#32078](https://github.com/nodejs/node/pull/32078)
+* [[`2f73e6eee0`](https://github.com/nodejs/node/commit/2f73e6eee0)] - **test**: use mustCall in place of countdown in timers test (Rich Trott) [#32416](https://github.com/nodejs/node/pull/32416)
+* [[`76a7386eff`](https://github.com/nodejs/node/commit/76a7386eff)] - **test**: end tls connection with some data (Sam Roberts) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`fcf9b46d55`](https://github.com/nodejs/node/commit/fcf9b46d55)] - **test**: discard data received by client (Hassaan Pasha) [#32328](https://github.com/nodejs/node/pull/32328)
+* [[`2e287837f8`](https://github.com/nodejs/node/commit/2e287837f8)] - **test**: replace countdown with Promise.all() in cluster-net-listen tests (Rich Trott) [#32381](https://github.com/nodejs/node/pull/32381)
+* [[`bdcc11f167`](https://github.com/nodejs/node/commit/bdcc11f167)] - **test**: replace Map with Array in cluster-net-listen tests (Rich Trott) [#32381](https://github.com/nodejs/node/pull/32381)
+* [[`4d173ea7d6`](https://github.com/nodejs/node/commit/4d173ea7d6)] - **test**: uv\_tty\_init returns EBADF on IBM i (Xu Meng) [#32338](https://github.com/nodejs/node/pull/32338)
+* [[`05fd16048c`](https://github.com/nodejs/node/commit/05fd16048c)] - **test**: use Promise.all() in test-hash-seed (Rich Trott) [#32273](https://github.com/nodejs/node/pull/32273)
+* [[`76781bd16e`](https://github.com/nodejs/node/commit/76781bd16e)] - **(SEMVER-MINOR)** **test**: remove common.skipIfReportDisabled() (Colin Ihrig) [#32242](https://github.com/nodejs/node/pull/32242)
+* [[`df1d4f708f`](https://github.com/nodejs/node/commit/df1d4f708f)] - **test**: workaround for V8 8.1 inspector pause issue (Matheus Marchini) [#32234](https://github.com/nodejs/node/pull/32234)
+* [[`fbcf602823`](https://github.com/nodejs/node/commit/fbcf602823)] - **test**: make test-memory-usage predictable (Matheus Marchini) [#32239](https://github.com/nodejs/node/pull/32239)
+* [[`09ca76befa`](https://github.com/nodejs/node/commit/09ca76befa)] - **test**: verify that WASI errors are rethrown (Colin Ihrig) [#32157](https://github.com/nodejs/node/pull/32157)
+* [[`fd80c21e9c`](https://github.com/nodejs/node/commit/fd80c21e9c)] - **test**: add new scenario for async-local storage (Harshitha KP) [#32082](https://github.com/nodejs/node/pull/32082)
+* [[`c0af3acc52`](https://github.com/nodejs/node/commit/c0af3acc52)] - **test**: use portable EOL (Harshitha KP) [#32104](https://github.com/nodejs/node/pull/32104)
+* [[`ed83a1cc09`](https://github.com/nodejs/node/commit/ed83a1cc09)] - **test**: refactor and simplify test-repl-preview (Ruben Bridgewater) [#32154](https://github.com/nodejs/node/pull/32154)
+* [[`08edf53207`](https://github.com/nodejs/node/commit/08edf53207)] - **test**: `buffer.write` with longer string scenario (Harshitha KP) [#32123](https://github.com/nodejs/node/pull/32123)
+* [[`2262e7c26d`](https://github.com/nodejs/node/commit/2262e7c26d)] - **test**: fix test-tls-env-extra-ca-file-load (Eric Bickle) [#32073](https://github.com/nodejs/node/pull/32073)
+* [[`dedd219622`](https://github.com/nodejs/node/commit/dedd219622)] - **tools**: fixup icutrim.py use of string and bytes objects (Jonathan MERCIER) [#31659](https://github.com/nodejs/node/pull/31659)
+* [[`5adaf1092a`](https://github.com/nodejs/node/commit/5adaf1092a)] - **tools**: update minimist@1.2.5 (Rich Trott) [#32274](https://github.com/nodejs/node/pull/32274)
+* [[`963ce088fc`](https://github.com/nodejs/node/commit/963ce088fc)] - **tools**: update to acorn@7.1.1 (Rich Trott) [#32259](https://github.com/nodejs/node/pull/32259)
+* [[`fa1fa3111a`](https://github.com/nodejs/node/commit/fa1fa3111a)] - **util**: text decoding allows SharedArrayBuffer (Bradley Farias) [#32203](https://github.com/nodejs/node/pull/32203)
+* [[`53fd0d80b1`](https://github.com/nodejs/node/commit/53fd0d80b1)] - **(SEMVER-MINOR)** **util**: use a global symbol for `util.promisify.custom` (ExE Boss) [#31672](https://github.com/nodejs/node/pull/31672)
+* [[`e83dcdef7e`](https://github.com/nodejs/node/commit/e83dcdef7e)] - **(SEMVER-MINOR)** **worker**: allow URL in Worker constructor (Antoine du HAMEL) [#31664](https://github.com/nodejs/node/pull/31664)
+
+<a id="13.11.0"></a>
+## 2020-03-11, Version 13.11.0 (Current), @MylesBorins
+
+### Notable Changes
+
+* **async_hooks**: add sync enterWith to ALS (Stephen Belanger) [#31945](https://github.com/nodejs/node/pull/31945)
+* **cli**: allow --jitless V8 flag in NODE\_OPTIONS (Andrew Neitsch) [#32100](https://github.com/nodejs/node/pull/32100)
+* **fs**: return first folder made by mkdir recursive (Benjamin Coe) [#31530](https://github.com/nodejs/node/pull/31530)
+* **n-api**: define release 6 (Gabriel Schulhof) [#32058](https://github.com/nodejs/node/pull/32058)
+* **os**: create a getter for kernel version (Juan José Arboleda) [#31732](https://github.com/nodejs/node/pull/31732)
+* **wasi**: add returnOnExit option (Colin Ihrig) [#32101](https://github.com/nodejs/node/pull/32101)
+
+### Commits
+
+* [[`478f1e7e13`](https://github.com/nodejs/node/commit/478f1e7e13)] - **async_hooks**: avoid resource reuse by FileHandle (Gerhard Stoebich) [#31972](https://github.com/nodejs/node/pull/31972)
+* [[`4d5981be96`](https://github.com/nodejs/node/commit/4d5981be96)] - **(SEMVER-MINOR)** **async_hooks**: add sync enterWith to ALS (Stephen Belanger) [#31945](https://github.com/nodejs/node/pull/31945)
+* [[`3befe80c4f`](https://github.com/nodejs/node/commit/3befe80c4f)] - **async_hooks**: fix ctx loss after nested ALS calls (Andrey Pechkurov) [#32085](https://github.com/nodejs/node/pull/32085)
+* [[`ddb882439f`](https://github.com/nodejs/node/commit/ddb882439f)] - **benchmark**: remove special test entries (Ruben Bridgewater) [#31755](https://github.com/nodejs/node/pull/31755)
+* [[`5d92cec12d`](https://github.com/nodejs/node/commit/5d92cec12d)] - **benchmark**: add `test` and `all` options and improve errors" (Ruben Bridgewater) [#31755](https://github.com/nodejs/node/pull/31755)
+* [[`e11f38cbab`](https://github.com/nodejs/node/commit/e11f38cbab)] - **benchmark**: refactor helper into a class (Ruben Bridgewater) [#31755](https://github.com/nodejs/node/pull/31755)
+* [[`31ec44302a`](https://github.com/nodejs/node/commit/31ec44302a)] - **benchmark**: remove problematic tls params (Brian White) [#31816](https://github.com/nodejs/node/pull/31816)
+* [[`079bb31b29`](https://github.com/nodejs/node/commit/079bb31b29)] - **build**: remove empty line on node.gyp file (Juan José Arboleda) [#31952](https://github.com/nodejs/node/pull/31952)
+* [[`fe34da84de`](https://github.com/nodejs/node/commit/fe34da84de)] - **build**: add mjs extension to lint-js (Nick Schonning) [#32145](https://github.com/nodejs/node/pull/32145)
+* [[`d66daa5661`](https://github.com/nodejs/node/commit/d66daa5661)] - **build**: support android build on ndk version equal or above 23 (forfun414) [#31521](https://github.com/nodejs/node/pull/31521)
+* [[`3c06316679`](https://github.com/nodejs/node/commit/3c06316679)] - **build**: workaround for gclient python3 issues (Matheus Marchini) [#32140](https://github.com/nodejs/node/pull/32140)
+* [[`64135249e5`](https://github.com/nodejs/node/commit/64135249e5)] - **build**: allow use of system-installed brotli (André Draszik) [#32046](https://github.com/nodejs/node/pull/32046)
+* [[`f07d423d16`](https://github.com/nodejs/node/commit/f07d423d16)] - **build**: allow passing multiple libs to pkg\_config (André Draszik) [#32046](https://github.com/nodejs/node/pull/32046)
+* [[`7c739aa386`](https://github.com/nodejs/node/commit/7c739aa386)] - **build**: enable backtrace when V8 is built for PPC and S390x (Michaël Zasso) [#32113](https://github.com/nodejs/node/pull/32113)
+* [[`e1347b411a`](https://github.com/nodejs/node/commit/e1347b411a)] - **cli**: allow --jitless V8 flag in NODE\_OPTIONS (Andrew Neitsch) [#32100](https://github.com/nodejs/node/pull/32100)
+* [[`ce686c03ae`](https://github.com/nodejs/node/commit/ce686c03ae)] - **crypto**: optimize sign.update() and verify.update() (Ben Noordhuis) [#31767](https://github.com/nodejs/node/pull/31767)
+* [[`a727b13343`](https://github.com/nodejs/node/commit/a727b13343)] - **crypto**: make update(buf, enc) ignore encoding (Ben Noordhuis) [#31766](https://github.com/nodejs/node/pull/31766)
+* [[`893e9183b5`](https://github.com/nodejs/node/commit/893e9183b5)] - **doc**: include the error type in the request.resolve doc (Joe Pea) [#32152](https://github.com/nodejs/node/pull/32152)
+* [[`af73ed632c`](https://github.com/nodejs/node/commit/af73ed632c)] - **doc**: clear up child\_process command resolution (Denys Otrishko) [#32091](https://github.com/nodejs/node/pull/32091)
+* [[`fa78aa4a60`](https://github.com/nodejs/node/commit/fa78aa4a60)] - **doc**: clarify windows specific behaviour (Sam Roberts) [#32079](https://github.com/nodejs/node/pull/32079)
+* [[`5bc51612b9`](https://github.com/nodejs/node/commit/5bc51612b9)] - **doc**: improve Buffer documentation (Anna Henningsen) [#32086](https://github.com/nodejs/node/pull/32086)
+* [[`35bea0798e`](https://github.com/nodejs/node/commit/35bea0798e)] - **doc**: add support encoding link on string\_decoder.md (himself65) [#31911](https://github.com/nodejs/node/pull/31911)
+* [[`3fa57ee0c2`](https://github.com/nodejs/node/commit/3fa57ee0c2)] - **doc**: add entry for `AsyncHook` class (Harshitha KP) [#31865](https://github.com/nodejs/node/pull/31865)
+* [[`38329bd438`](https://github.com/nodejs/node/commit/38329bd438)] - **doc**: prevent tables from shrinking page (David Gilbertson) [#31859](https://github.com/nodejs/node/pull/31859)
+* [[`bc1e3575d4`](https://github.com/nodejs/node/commit/bc1e3575d4)] - **doc**: change worker.takeHeapSnapshot to getHeapSnapshot (Gerhard Stoebich) [#32061](https://github.com/nodejs/node/pull/32061)
+* [[`7de4dfba79`](https://github.com/nodejs/node/commit/7de4dfba79)] - **doc**: remove personal pronoun usage in policy.md (Rich Trott) [#32142](https://github.com/nodejs/node/pull/32142)
+* [[`618b389b6a`](https://github.com/nodejs/node/commit/618b389b6a)] - **doc**: remove personal pronoun usage in fs.md (Rich Trott) [#32142](https://github.com/nodejs/node/pull/32142)
+* [[`fa99fb2eac`](https://github.com/nodejs/node/commit/fa99fb2eac)] - **doc**: remove personal pronoun usage in errors.md (Rich Trott) [#32142](https://github.com/nodejs/node/pull/32142)
+* [[`2d39369ee5`](https://github.com/nodejs/node/commit/2d39369ee5)] - **doc**: remove personal pronoun usage in addons.md (Rich Trott) [#32142](https://github.com/nodejs/node/pull/32142)
+* [[`02ebc81e94`](https://github.com/nodejs/node/commit/02ebc81e94)] - **doc**: revise tools/icu/README.md (Rich Trott) [#32136](https://github.com/nodejs/node/pull/32136)
+* [[`50c5eb49ab`](https://github.com/nodejs/node/commit/50c5eb49ab)] - **doc**: link setRawMode() from signal docs (Anna Henningsen) [#32088](https://github.com/nodejs/node/pull/32088)
+* [[`97965f518c`](https://github.com/nodejs/node/commit/97965f518c)] - **doc**: document self-referencing a package name (Gil Tayar) [#31680](https://github.com/nodejs/node/pull/31680)
+* [[`a79b8fa6f8`](https://github.com/nodejs/node/commit/a79b8fa6f8)] - **doc**: document fs.watchFile() bigint option (Colin Ihrig) [#32128](https://github.com/nodejs/node/pull/32128)
+* [[`2e5f81f69c`](https://github.com/nodejs/node/commit/2e5f81f69c)] - **doc**: fix broken links in benchmark README (Rich Trott) [#32121](https://github.com/nodejs/node/pull/32121)
+* [[`50094de274`](https://github.com/nodejs/node/commit/50094de274)] - **doc**: remove em dashes (Rich Trott) [#32080](https://github.com/nodejs/node/pull/32080)
+* [[`5f12595e00`](https://github.com/nodejs/node/commit/5f12595e00)] - **doc**: update email address in authors (Yael Hermon) [#32026](https://github.com/nodejs/node/pull/32026)
+* [[`77e5b509a9`](https://github.com/nodejs/node/commit/77e5b509a9)] - **doc,test**: add server.timeout property to http2 public API (Andrey Pechkurov) [#31693](https://github.com/nodejs/node/pull/31693)
+* [[`4c2e4d1747`](https://github.com/nodejs/node/commit/4c2e4d1747)] - **esm**: remove unused parameter on module.instantiate (himself65) [#32147](https://github.com/nodejs/node/pull/32147)
+* [[`55486bceb9`](https://github.com/nodejs/node/commit/55486bceb9)] - **events**: fix removeListener for Symbols (zfx) [#31847](https://github.com/nodejs/node/pull/31847)
+* [[`94f3eed229`](https://github.com/nodejs/node/commit/94f3eed229)] - **(SEMVER-MINOR)** **fs**: make fs.read params optional (Lucas Holmquist) [#31402](https://github.com/nodejs/node/pull/31402)
+* [[`7eed9d6bcc`](https://github.com/nodejs/node/commit/7eed9d6bcc)] - **fs**: fix WriteStream autoClose order (Robert Nagy) [#31790](https://github.com/nodejs/node/pull/31790)
+* [[`ff58854dbe`](https://github.com/nodejs/node/commit/ff58854dbe)] - **(SEMVER-MINOR)** **fs**: return first folder made by mkdir recursive (Benjamin Coe) [#31530](https://github.com/nodejs/node/pull/31530)
+* [[`1c4f4cc436`](https://github.com/nodejs/node/commit/1c4f4cc436)] - **fs**: fix writeFile\[Sync\] for non-seekable files (Alba Mendez) [#32006](https://github.com/nodejs/node/pull/32006)
+* [[`c106a857a9`](https://github.com/nodejs/node/commit/c106a857a9)] - **fs**: fix valid id range on chown, lchown, fchown (himself65) [#31694](https://github.com/nodejs/node/pull/31694)
+* [[`1ffa9f388f`](https://github.com/nodejs/node/commit/1ffa9f388f)] - **http**: fix socket re-use races (Robert Nagy) [#32000](https://github.com/nodejs/node/pull/32000)
+* [[`49a07f7932`](https://github.com/nodejs/node/commit/49a07f7932)] - **http, async_hooks**: remove unneeded reference to wrapping resource (Gerhard Stoebich) [#32054](https://github.com/nodejs/node/pull/32054)
+* [[`897b1d2e5e`](https://github.com/nodejs/node/commit/897b1d2e5e)] - **lib**: move isLegalPort to validators, refactor (James M Snell) [#31851](https://github.com/nodejs/node/pull/31851)
+* [[`607ac90906`](https://github.com/nodejs/node/commit/607ac90906)] - **lib**: improve value validation utils (Denys Otrishko) [#31480](https://github.com/nodejs/node/pull/31480)
+* [[`c0ba6ec560`](https://github.com/nodejs/node/commit/c0ba6ec560)] - **meta**: move thefourtheye to TSC Emeritus (Rich Trott) [#32059](https://github.com/nodejs/node/pull/32059)
+* [[`710c9051e3`](https://github.com/nodejs/node/commit/710c9051e3)] - **n-api**: define release 6 (Gabriel Schulhof) [#32058](https://github.com/nodejs/node/pull/32058)
+* [[`e83671c3c4`](https://github.com/nodejs/node/commit/e83671c3c4)] - **src**: DRY crypto Update() methods (Ben Noordhuis) [#31767](https://github.com/nodejs/node/pull/31767)
+* [[`025f658fa6`](https://github.com/nodejs/node/commit/025f658fa6)] - **src**: fix spawnSync CHECK when SIGKILL fails (Ben Noordhuis) [#31768](https://github.com/nodejs/node/pull/31768)
+* [[`2248ba760b`](https://github.com/nodejs/node/commit/2248ba760b)] - **src**: fix missing extra ca in tls.rootCertificates (Eric Bickle) [#32075](https://github.com/nodejs/node/pull/32075)
+* [[`fa376f420c`](https://github.com/nodejs/node/commit/fa376f420c)] - **src**: fix -Wmaybe-uninitialized compiler warning (Ben Noordhuis) [#31809](https://github.com/nodejs/node/pull/31809)
+* [[`c3aa3e70f0`](https://github.com/nodejs/node/commit/c3aa3e70f0)] - **src**: remove unused include from node\_file.cc (Ben Noordhuis) [#31809](https://github.com/nodejs/node/pull/31809)
+* [[`d8c927b5f1`](https://github.com/nodejs/node/commit/d8c927b5f1)] - ***Revert*** "**src**: keep main-thread Isolate attached to platform during Dispose" (Anna Henningsen) [#31853](https://github.com/nodejs/node/pull/31853)
+* [[`625d8f7007`](https://github.com/nodejs/node/commit/625d8f7007)] - **src**: discard tasks posted to platform TaskRunner during shutdown (Anna Henningsen) [#31853](https://github.com/nodejs/node/pull/31853)
+* [[`55a8ca8ee4`](https://github.com/nodejs/node/commit/55a8ca8ee4)] - **src**: elevate v8 namespace (RamanandPatil) [#32041](https://github.com/nodejs/node/pull/32041)
+* [[`1e9a2516df`](https://github.com/nodejs/node/commit/1e9a2516df)] - **src**: use C++ style for struct with initializers (Sam Roberts) [#32134](https://github.com/nodejs/node/pull/32134)
+* [[`6aa797b546`](https://github.com/nodejs/node/commit/6aa797b546)] - **src**: implement per-process native Debug() printer (Joyee Cheung) [#31884](https://github.com/nodejs/node/pull/31884)
+* [[`5127c700d0`](https://github.com/nodejs/node/commit/5127c700d0)] - **src**: refactor debug category parsing (Joyee Cheung) [#31884](https://github.com/nodejs/node/pull/31884)
+* [[`2388a40f56`](https://github.com/nodejs/node/commit/2388a40f56)] - **src**: make aliased\_buffer.h self-contained (Joyee Cheung) [#31884](https://github.com/nodejs/node/pull/31884)
+* [[`258a80d3cc`](https://github.com/nodejs/node/commit/258a80d3cc)] - **(SEMVER-MINOR)** **src**: create a getter for kernel version (Juan José Arboleda) [#31732](https://github.com/nodejs/node/pull/31732)
+* [[`cba75c5cf4`](https://github.com/nodejs/node/commit/cba75c5cf4)] - **src**: handle NULL env scenario (Harshitha KP) [#31899](https://github.com/nodejs/node/pull/31899)
+* [[`cc27846fb9`](https://github.com/nodejs/node/commit/cc27846fb9)] - **src**: simplify node\_worker.cc using new KVStore API (Denys Otrishko) [#31773](https://github.com/nodejs/node/pull/31773)
+* [[`296f35b888`](https://github.com/nodejs/node/commit/296f35b888)] - **src**: improve KVStore API (Denys Otrishko) [#31773](https://github.com/nodejs/node/pull/31773)
+* [[`bd756883a7`](https://github.com/nodejs/node/commit/bd756883a7)] - **src**: add missing namespace using statements in node\_watchdog.h (legendecas) [#32117](https://github.com/nodejs/node/pull/32117)
+* [[`e9f9d076e9`](https://github.com/nodejs/node/commit/e9f9d076e9)] - **src**: fix -Wreorder compiler warning (Colin Ihrig) [#32126](https://github.com/nodejs/node/pull/32126)
+* [[`7b9b578652`](https://github.com/nodejs/node/commit/7b9b578652)] - **src**: fix -Winconsistent-missing-override warning (Colin Ihrig) [#32126](https://github.com/nodejs/node/pull/32126)
+* [[`4ac1ce1071`](https://github.com/nodejs/node/commit/4ac1ce1071)] - **src**: introduce node\_sockaddr (James M Snell) [#32070](https://github.com/nodejs/node/pull/32070)
+* [[`31e4a0d7ac`](https://github.com/nodejs/node/commit/31e4a0d7ac)] - **src**: Handle bad callback in asyc\_wrap (Harshitha KP) [#31946](https://github.com/nodejs/node/pull/31946)
+* [[`a03777096e`](https://github.com/nodejs/node/commit/a03777096e)] - **src,http2**: introduce node\_http\_common (James M Snell) [#32069](https://github.com/nodejs/node/pull/32069)
+* [[`fab8c83253`](https://github.com/nodejs/node/commit/fab8c83253)] - **stream**: avoid destroying writable source (Robert Nagy) [#32198](https://github.com/nodejs/node/pull/32198)
+* [[`66fe2d90ff`](https://github.com/nodejs/node/commit/66fe2d90ff)] - **stream**: avoid destroying http1 objects (Robert Nagy) [#32197](https://github.com/nodejs/node/pull/32197)
+* [[`0a00552122`](https://github.com/nodejs/node/commit/0a00552122)] - **stream**: do not swallow errors with async iterators and pipeline (Matteo Collina) [#32051](https://github.com/nodejs/node/pull/32051)
+* [[`f2636598e8`](https://github.com/nodejs/node/commit/f2636598e8)] - **stream**: eos make const state const (Robert Nagy) [#32031](https://github.com/nodejs/node/pull/32031)
+* [[`4b04bf89ad`](https://github.com/nodejs/node/commit/4b04bf89ad)] - **stream**: re-use legacy destroyer (Robert Nagy) [#31316](https://github.com/nodejs/node/pull/31316)
+* [[`7ce1cc93ce`](https://github.com/nodejs/node/commit/7ce1cc93ce)] - **stream**: simplify pipeline (Robert Nagy) [#31316](https://github.com/nodejs/node/pull/31316)
+* [[`9d1b1a3fbd`](https://github.com/nodejs/node/commit/9d1b1a3fbd)] - **stream**: simplify Writable.write (Robert Nagy) [#31146](https://github.com/nodejs/node/pull/31146)
+* [[`1e05ddf406`](https://github.com/nodejs/node/commit/1e05ddf406)] - **stream**: improve writable.write() performance (Brian White) [#31624](https://github.com/nodejs/node/pull/31624)
+* [[`90a4d438cb`](https://github.com/nodejs/node/commit/90a4d438cb)] - **stream**: combine properties using defineProperties (antsmartian) [#31187](https://github.com/nodejs/node/pull/31187)
+* [[`4640ea24bd`](https://github.com/nodejs/node/commit/4640ea24bd)] - **stream**: don't destroy final readable stream in pipeline (Robert Nagy) [#32110](https://github.com/nodejs/node/pull/32110)
+* [[`2585b814b0`](https://github.com/nodejs/node/commit/2585b814b0)] - **stream**: add comments to pipeline implementation (Robert Nagy) [#32042](https://github.com/nodejs/node/pull/32042)
+* [[`ceca1c3a4f`](https://github.com/nodejs/node/commit/ceca1c3a4f)] - **test**: improve test-fs-existssync-false.js (himself65) [#31883](https://github.com/nodejs/node/pull/31883)
+* [[`84197eaae0`](https://github.com/nodejs/node/commit/84197eaae0)] - **test**: mark test-timers-blocking-callback flaky on osx (Myles Borins) [#32189](https://github.com/nodejs/node/pull/32189)
+* [[`4589863518`](https://github.com/nodejs/node/commit/4589863518)] - **test**: always skip vm-timeout-escape-queuemicrotask (Denys Otrishko) [#31980](https://github.com/nodejs/node/pull/31980)
+* [[`188f1d275f`](https://github.com/nodejs/node/commit/188f1d275f)] - **test**: improve test-debug-usage (Rich Trott) [#32141](https://github.com/nodejs/node/pull/32141)
+* [[`92cc406baf`](https://github.com/nodejs/node/commit/92cc406baf)] - **test**: refactor all benchmark tests to use the new test option (Ruben Bridgewater) [#31755](https://github.com/nodejs/node/pull/31755)
+* [[`6f9f2c5de4`](https://github.com/nodejs/node/commit/6f9f2c5de4)] - **test**: warn when inspector process crashes (Matheus Marchini) [#32133](https://github.com/nodejs/node/pull/32133)
+* [[`6a9654a7a9`](https://github.com/nodejs/node/commit/6a9654a7a9)] - **test**: increase test timeout to prevent flakiness (Ruben Bridgewater) [#31716](https://github.com/nodejs/node/pull/31716)
+* [[`862cd2b49d`](https://github.com/nodejs/node/commit/862cd2b49d)] - **test**: use index.js if package.json "main" is empty (Ben Noordhuis) [#32040](https://github.com/nodejs/node/pull/32040)
+* [[`3d64c9eba6`](https://github.com/nodejs/node/commit/3d64c9eba6)] - **test**: changed function to arrow function (ProdipRoy89) [#32045](https://github.com/nodejs/node/pull/32045)
+* [[`6545d1a55d`](https://github.com/nodejs/node/commit/6545d1a55d)] - **test**: allow EAI\_FAIL in test-net-dns-error.js (Vita Batrla) [#31780](https://github.com/nodejs/node/pull/31780)
+* [[`1428de8ee6`](https://github.com/nodejs/node/commit/1428de8ee6)] - **test**: add WASI test for path\_link() (Colin Ihrig) [#32132](https://github.com/nodejs/node/pull/32132)
+* [[`da7349d908`](https://github.com/nodejs/node/commit/da7349d908)] - **test**: remove superfluous checks in test-net-reconnect-error (Rich Trott) [#32120](https://github.com/nodejs/node/pull/32120)
+* [[`74edcc5dd9`](https://github.com/nodejs/node/commit/74edcc5dd9)] - **test**: apply camelCase in test-net-reconnect-error (Rich Trott) [#32120](https://github.com/nodejs/node/pull/32120)
+* [[`8e435687bb`](https://github.com/nodejs/node/commit/8e435687bb)] - **test**: update tests for larger Buffers (Jakob Kummerow) [#32114](https://github.com/nodejs/node/pull/32114)
+* [[`83e9a3ea59`](https://github.com/nodejs/node/commit/83e9a3ea59)] - **test**: add coverage for FSWatcher exception (Rich Trott) [#32057](https://github.com/nodejs/node/pull/32057)
+* [[`89987b3a9f`](https://github.com/nodejs/node/commit/89987b3a9f)] - **test**: remove common.expectsInternalAssertion (Rich Trott) [#32057](https://github.com/nodejs/node/pull/32057)
+* [[`35d0569356`](https://github.com/nodejs/node/commit/35d0569356)] - **tools**: enable no-useless-backreference lint rule (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
+* [[`d3c4210ea0`](https://github.com/nodejs/node/commit/d3c4210ea0)] - **tools**: enable default-case-last lint rule (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
+* [[`814bb4a35d`](https://github.com/nodejs/node/commit/814bb4a35d)] - **tools**: update ESLint to 7.0.0-alpha.2 (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
+* [[`cac1d01cad`](https://github.com/nodejs/node/commit/cac1d01cad)] - **tools**: update ESLint to 7.0.0-alpha.1 (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
+* [[`c70cfd2ba6`](https://github.com/nodejs/node/commit/c70cfd2ba6)] - **tools**: update ESLint to 7.0.0-alpha.0 (Colin Ihrig) [#31400](https://github.com/nodejs/node/pull/31400)
+* [[`bb41383bdc`](https://github.com/nodejs/node/commit/bb41383bdc)] - **tools**: use per-process native Debug() printer in mkcodecache (Joyee Cheung) [#31884](https://github.com/nodejs/node/pull/31884)
+* [[`eaf6723804`](https://github.com/nodejs/node/commit/eaf6723804)] - **vm**: refactor value validation with internal/validators.js (Denys Otrishko) [#31480](https://github.com/nodejs/node/pull/31480)
+* [[`dd83bd266d`](https://github.com/nodejs/node/commit/dd83bd266d)] - **(SEMVER-MINOR)** **wasi**: add returnOnExit option (Colin Ihrig) [#32101](https://github.com/nodejs/node/pull/32101)
+
+<a id="13.10.1"></a>
+## 2020-03-04, Version 13.10.1 (Current), @MylesBorins
+
+### Notable Changes
+
+In Node.js 13.9.0 deps/zlib was switched to the chromium maintained implementation. This change
+had the unforseen consequence of breaking building from the tarballs we release as we were too
+aggressively removing `unneccessary files` from the `deps/zlib` folder. This release includes
+a patch that ensures that individuals will once again be able to build Node.js from source.
+
+### Commits
+
+* [[`723aa41d96`](https://github.com/nodejs/node/commit/723aa41d96)] - **build**: fix zlib tarball generation (Shelley Vohr) [#32094](https://github.com/nodejs/node/pull/32094)
+* [[`9c1ac50fc5`](https://github.com/nodejs/node/commit/9c1ac50fc5)] - **build**: fix building with ninja (Richard Lau) [#32071](https://github.com/nodejs/node/pull/32071)
+* [[`478450d6b3`](https://github.com/nodejs/node/commit/478450d6b3)] - **build**: add asan check in Github action (gengjiawen) [#31902](https://github.com/nodejs/node/pull/31902)
+* [[`0fc45f80b5`](https://github.com/nodejs/node/commit/0fc45f80b5)] - **crypto**: simplify exportKeyingMaterial (Tobias Nießen) [#31922](https://github.com/nodejs/node/pull/31922)
+* [[`4dc59b91a7`](https://github.com/nodejs/node/commit/4dc59b91a7)] - **dgram**: make UDPWrap more reusable (Anna Henningsen) [#31871](https://github.com/nodejs/node/pull/31871)
+* [[`4ed720e940`](https://github.com/nodejs/node/commit/4ed720e940)] - **doc**: visibility of Worker threads cli options (Harshitha KP) [#31380](https://github.com/nodejs/node/pull/31380)
+* [[`2518213a1b`](https://github.com/nodejs/node/commit/2518213a1b)] - **doc**: improve doc/markdown file organization coherence (ConorDavenport) [#31792](https://github.com/nodejs/node/pull/31792)
+* [[`ba3f7ff94d`](https://github.com/nodejs/node/commit/ba3f7ff94d)] - **doc**: update stream.pipeline() signature (vsemozhetbyt) [#31789](https://github.com/nodejs/node/pull/31789)
+* [[`3c8daa3aa0`](https://github.com/nodejs/node/commit/3c8daa3aa0)] - **events**: convert errorMonitor to a normal property (Gerhard Stoebich) [#31848](https://github.com/nodejs/node/pull/31848)
+* [[`6b44df2415`](https://github.com/nodejs/node/commit/6b44df2415)] - **perf,src**: add HistogramBase and internal/histogram.js (James M Snell) [#31988](https://github.com/nodejs/node/pull/31988)
+* [[`6a9cea9ed2`](https://github.com/nodejs/node/commit/6a9cea9ed2)] - **src**: pass resource object along with InternalMakeCallback (Anna Henningsen) [#32063](https://github.com/nodejs/node/pull/32063)
+* [[`70f046010c`](https://github.com/nodejs/node/commit/70f046010c)] - **src**: start the .text section with an asm symbol (Gabriel Schulhof) [#31981](https://github.com/nodejs/node/pull/31981)
+* [[`755da035ce`](https://github.com/nodejs/node/commit/755da035ce)] - **src**: add node\_crypto\_common and refactor (James M Snell) [#32016](https://github.com/nodejs/node/pull/32016)
+* [[`4d5318c164`](https://github.com/nodejs/node/commit/4d5318c164)] - **src**: improve handling of internal field counting (James M Snell) [#31960](https://github.com/nodejs/node/pull/31960)
+* [[`1539928ed9`](https://github.com/nodejs/node/commit/1539928ed9)] - **test**: add GC test for disabled AsyncLocalStorage (Andrey Pechkurov) [#31995](https://github.com/nodejs/node/pull/31995)
+* [[`be90817558`](https://github.com/nodejs/node/commit/be90817558)] - **test**: remove common.port from test-tls-securepair-client (Rich Trott) [#32024](https://github.com/nodejs/node/pull/32024)
+
+<a id="13.10.0"></a>
+## 2020-03-04, Version 13.10.0 (Current), @codebytere
+
+### Notable Changes
+
+* **async_hooks**
+  * introduce async-context API (vdeturckheim) [#26540](https://github.com/nodejs/node/pull/26540)
+* **stream**
+  * support passing generator functions into pipeline() (Robert Nagy) [#31223](https://github.com/nodejs/node/pull/31223)
+* **tls**
+  * expose SSL\_export\_keying\_material (simon) [#31814](https://github.com/nodejs/node/pull/31814)
+* **vm**
+  * implement vm.measureMemory() for per-context memory measurement (Joyee Cheung) [#31824](https://github.com/nodejs/node/pull/31824)
+
+### Commits
+
+* [[`f71fc9044a`](https://github.com/nodejs/node/commit/f71fc9044a)] - **async_hooks**: add store arg in AsyncLocalStorage (Andrey Pechkurov) [#31930](https://github.com/nodejs/node/pull/31930)
+* [[`6af9e7e0c3`](https://github.com/nodejs/node/commit/6af9e7e0c3)] - **async_hooks**: executionAsyncResource matches in hooks (Gerhard Stoebich) [#31821](https://github.com/nodejs/node/pull/31821)
+* [[`877ab97286`](https://github.com/nodejs/node/commit/877ab97286)] - **(SEMVER-MINOR)** **async_hooks**: introduce async-context API (vdeturckheim) [#26540](https://github.com/nodejs/node/pull/26540)
+* [[`9a41ced0d1`](https://github.com/nodejs/node/commit/9a41ced0d1)] - **build**: only lint markdown files that have changed (POSIX-only) (Rich Trott) [#31923](https://github.com/nodejs/node/pull/31923)
+* [[`ca4407105e`](https://github.com/nodejs/node/commit/ca4407105e)] - **build**: add missing comma in node.gyp (cjihrig) [#31959](https://github.com/nodejs/node/pull/31959)
+* [[`4dffd0437d`](https://github.com/nodejs/node/commit/4dffd0437d)] - **cli**: --perf-prof only works on Linux (Shelley Vohr) [#31892](https://github.com/nodejs/node/pull/31892)
+* [[`4d05508aa8`](https://github.com/nodejs/node/commit/4d05508aa8)] - **crypto**: turn impossible DH errors into assertions (Tobias Nießen) [#31934](https://github.com/nodejs/node/pull/31934)
+* [[`d0e94fc77e`](https://github.com/nodejs/node/commit/d0e94fc77e)] - **crypto**: fix ieee-p1363 for createVerify (Tobias Nießen) [#31876](https://github.com/nodejs/node/pull/31876)
+* [[`fbaab7d854`](https://github.com/nodejs/node/commit/fbaab7d854)] - **deps**: openssl: cherry-pick 4dcb150ea30f (Adam Majer) [#32002](https://github.com/nodejs/node/pull/32002)
+* [[`e6125cd53b`](https://github.com/nodejs/node/commit/e6125cd53b)] - **deps**: V8: backport f7771e5b0cc4 (Matheus Marchini) [#31957](https://github.com/nodejs/node/pull/31957)
+* [[`c27f0d10c4`](https://github.com/nodejs/node/commit/c27f0d10c4)] - **deps**: update zlib to upstream d7f3ca9 (Sam Roberts) [#31800](https://github.com/nodejs/node/pull/31800)
+* [[`b30a6981d3`](https://github.com/nodejs/node/commit/b30a6981d3)] - **deps**: move zlib maintenance info to guides (Sam Roberts) [#31800](https://github.com/nodejs/node/pull/31800)
+* [[`cd30dbb0d6`](https://github.com/nodejs/node/commit/cd30dbb0d6)] - **doc**: revise --zero-fill-buffers text in buffer.md (Rich Trott) [#32019](https://github.com/nodejs/node/pull/32019)
+* [[`166579f84b`](https://github.com/nodejs/node/commit/166579f84b)] - **doc**: add link to sem-ver info (unknown) [#31985](https://github.com/nodejs/node/pull/31985)
+* [[`e3258fd148`](https://github.com/nodejs/node/commit/e3258fd148)] - **doc**: update zlib doc (James M Snell) [#31665](https://github.com/nodejs/node/pull/31665)
+* [[`8516602ba0`](https://github.com/nodejs/node/commit/8516602ba0)] - **doc**: clarify http2.connect authority details (James M Snell) [#31828](https://github.com/nodejs/node/pull/31828)
+* [[`c5acf0a13b`](https://github.com/nodejs/node/commit/c5acf0a13b)] - **doc**: updated YAML version representation in readline.md (Rich Trott) [#31924](https://github.com/nodejs/node/pull/31924)
+* [[`4c6343fdea`](https://github.com/nodejs/node/commit/4c6343fdea)] - **doc**: describe how to update zlib (Sam Roberts) [#31800](https://github.com/nodejs/node/pull/31800)
+* [[`a46839279f`](https://github.com/nodejs/node/commit/a46839279f)] - **doc**: update releases guide re pushing tags (Myles Borins) [#31855](https://github.com/nodejs/node/pull/31855)
+* [[`15cc9b0126`](https://github.com/nodejs/node/commit/15cc9b0126)] - **doc**: update assert.rejects() docs with a validation function example (Eric Eastwood) [#31271](https://github.com/nodejs/node/pull/31271)
+* [[`2046652b4e`](https://github.com/nodejs/node/commit/2046652b4e)] - **doc**: fix anchor for ERR\_TLS\_INVALID\_CONTEXT (Tobias Nießen) [#31915](https://github.com/nodejs/node/pull/31915)
+* [[`091b4bfe2d`](https://github.com/nodejs/node/commit/091b4bfe2d)] - **doc**: add note about ssh key to releases (Shelley Vohr) [#31856](https://github.com/nodejs/node/pull/31856)
+* [[`3438937a37`](https://github.com/nodejs/node/commit/3438937a37)] - **doc**: fix notable changes for v13.9.0 (Shelley Vohr) [#31857](https://github.com/nodejs/node/pull/31857)
+* [[`672f76d6bd`](https://github.com/nodejs/node/commit/672f76d6bd)] - **doc**: reword possessive form of Node.js in adding-new-napi-api.md (Rich Trott) [#31748](https://github.com/nodejs/node/pull/31748)
+* [[`3eaf37767e`](https://github.com/nodejs/node/commit/3eaf37767e)] - **doc**: reword possessive form of Node.js in http.md (Rich Trott) [#31748](https://github.com/nodejs/node/pull/31748)
+* [[`cb210e6b16`](https://github.com/nodejs/node/commit/cb210e6b16)] - **doc**: reword possessive form of Node.js in process.md (Rich Trott) [#31748](https://github.com/nodejs/node/pull/31748)
+* [[`3969af43b4`](https://github.com/nodejs/node/commit/3969af43b4)] - **doc**: reword possessive form of Node.js in debugger.md (Rich Trott) [#31748](https://github.com/nodejs/node/pull/31748)
+* [[`f9526057b3`](https://github.com/nodejs/node/commit/f9526057b3)] - **doc**: move gireeshpunathil to TSC emeritus (Gireesh Punathil) [#31770](https://github.com/nodejs/node/pull/31770)
+* [[`b07175853f`](https://github.com/nodejs/node/commit/b07175853f)] - **doc**: pronouns for @Fishrock123 (Jeremiah Senkpiel) [#31725](https://github.com/nodejs/node/pull/31725)
+* [[`7f4d6ee8ea`](https://github.com/nodejs/node/commit/7f4d6ee8ea)] - **doc**: move @Fishrock123 to TSC Emeriti (Jeremiah Senkpiel) [#31725](https://github.com/nodejs/node/pull/31725)
+* [[`b177bba555`](https://github.com/nodejs/node/commit/b177bba555)] - **doc**: move @Fishrock123 to a previous releaser (Jeremiah Senkpiel) [#31725](https://github.com/nodejs/node/pull/31725)
+* [[`9e4aad705f`](https://github.com/nodejs/node/commit/9e4aad705f)] - **doc**: fix typos in doc/api/https.md (Jeff) [#31793](https://github.com/nodejs/node/pull/31793)
+* [[`eb2dce8342`](https://github.com/nodejs/node/commit/eb2dce8342)] - **doc**: claim ABI version 82 for Electron 10 (Samuel Attard) [#31778](https://github.com/nodejs/node/pull/31778)
+* [[`db291aaf06`](https://github.com/nodejs/node/commit/db291aaf06)] - **doc**: guide - using valgrind to debug memory leaks (Michael Dawson) [#31501](https://github.com/nodejs/node/pull/31501)
+* [[`aa16d80c05`](https://github.com/nodejs/node/commit/aa16d80c05)] - **doc,crypto**: re-document oaepLabel option (Ben Noordhuis) [#31825](https://github.com/nodejs/node/pull/31825)
+* [[`9079bb42ea`](https://github.com/nodejs/node/commit/9079bb42ea)] - **http2**: make compat finished match http/1 (Robert Nagy) [#24347](https://github.com/nodejs/node/pull/24347)
+* [[`3bd8feac0c`](https://github.com/nodejs/node/commit/3bd8feac0c)] - **meta**: move aqrln to emeritus (Rich Trott) [#31997](https://github.com/nodejs/node/pull/31997)
+* [[`c801045fcd`](https://github.com/nodejs/node/commit/c801045fcd)] - **meta**: move jbergstroem to emeritus (Rich Trott) [#31996](https://github.com/nodejs/node/pull/31996)
+* [[`ded3890bec`](https://github.com/nodejs/node/commit/ded3890bec)] - **meta**: move maclover7 to Emeritus (Rich Trott) [#31994](https://github.com/nodejs/node/pull/31994)
+* [[`91ce69a554`](https://github.com/nodejs/node/commit/91ce69a554)] - **meta**: move Glen Keane to Collaborator Emeritus (Rich Trott) [#31993](https://github.com/nodejs/node/pull/31993)
+* [[`b74c40eda6`](https://github.com/nodejs/node/commit/b74c40eda6)] - **meta**: move not-an-aardvark to emeritus (Rich Trott) [#31928](https://github.com/nodejs/node/pull/31928)
+* [[`61a0d8b6cd`](https://github.com/nodejs/node/commit/61a0d8b6cd)] - **meta**: move julianduque to emeritus (Rich Trott) [#31863](https://github.com/nodejs/node/pull/31863)
+* [[`94a471a422`](https://github.com/nodejs/node/commit/94a471a422)] - **meta**: move eljefedelrodeodeljefe to emeritus (Rich Trott) [#31735](https://github.com/nodejs/node/pull/31735)
+* [[`9e3e6763fa`](https://github.com/nodejs/node/commit/9e3e6763fa)] - **module**: port source map sort logic from chromium (bcoe) [#31927](https://github.com/nodejs/node/pull/31927)
+* [[`b9f3bfe6c8`](https://github.com/nodejs/node/commit/b9f3bfe6c8)] - **module**: disable conditional exports, self resolve warnings (Guy Bedford) [#31845](https://github.com/nodejs/node/pull/31845)
+* [[`bbb6cc733c`](https://github.com/nodejs/node/commit/bbb6cc733c)] - **module**: package "exports" error refinements (Guy Bedford) [#31625](https://github.com/nodejs/node/pull/31625)
+* [[`6adbfac9b0`](https://github.com/nodejs/node/commit/6adbfac9b0)] - **repl**: eager-evaluate input in parens (Shelley Vohr) [#31943](https://github.com/nodejs/node/pull/31943)
+* [[`6a35b0d102`](https://github.com/nodejs/node/commit/6a35b0d102)] - **src**: don't run bootstrapper in CreateEnvironment (Shelley Vohr) [#31910](https://github.com/nodejs/node/pull/31910)
+* [[`3497370d66`](https://github.com/nodejs/node/commit/3497370d66)] - **src**: move InternalCallbackScope to StartExecution (Shelley Vohr) [#31944](https://github.com/nodejs/node/pull/31944)
+* [[`f62967c827`](https://github.com/nodejs/node/commit/f62967c827)] - **src**: enable `StreamPipe` for generic `StreamBase`s (Anna Henningsen) [#31869](https://github.com/nodejs/node/pull/31869)
+* [[`776f379124`](https://github.com/nodejs/node/commit/776f379124)] - **src**: include large pages source unconditionally (Gabriel Schulhof) [#31904](https://github.com/nodejs/node/pull/31904)
+* [[`9f68e14052`](https://github.com/nodejs/node/commit/9f68e14052)] - **src**: elevate v8 namespaces (Harshitha KP) [#31901](https://github.com/nodejs/node/pull/31901)
+* [[`8fa6373e62`](https://github.com/nodejs/node/commit/8fa6373e62)] - **src**: allow unique\_ptrs with custom deleter in memory tracker (Anna Henningsen) [#31870](https://github.com/nodejs/node/pull/31870)
+* [[`88ccb444e3`](https://github.com/nodejs/node/commit/88ccb444e3)] - **src**: move BaseObject subclass dtors/ctors out of node\_crypto.h (Anna Henningsen) [#31872](https://github.com/nodejs/node/pull/31872)
+* [[`98d262e5f3`](https://github.com/nodejs/node/commit/98d262e5f3)] - **src**: inform callback scopes about exceptions in HTTP parser (Anna Henningsen) [#31801](https://github.com/nodejs/node/pull/31801)
+* [[`57302f866e`](https://github.com/nodejs/node/commit/57302f866e)] - **src**: prefer 3-argument Array::New() (Anna Henningsen) [#31775](https://github.com/nodejs/node/pull/31775)
+* [[`8a2b62e4cd`](https://github.com/nodejs/node/commit/8a2b62e4cd)] - **stream**: ensure pipeline always destroys streams (Robert Nagy) [#31940](https://github.com/nodejs/node/pull/31940)
+* [[`313ecaabe5`](https://github.com/nodejs/node/commit/313ecaabe5)] - **stream**: fix broken pipeline error propagation (Robert Nagy) [#31835](https://github.com/nodejs/node/pull/31835)
+* [[`8ad64b8e53`](https://github.com/nodejs/node/commit/8ad64b8e53)] - **(SEMVER-MINOR)** **stream**: support passing generator functions into pipeline() (Robert Nagy) [#31223](https://github.com/nodejs/node/pull/31223)
+* [[`d0a00711f8`](https://github.com/nodejs/node/commit/d0a00711f8)] - **stream**: invoke buffered write callbacks on error (Robert Nagy) [#30596](https://github.com/nodejs/node/pull/30596)
+* [[`1bca7b6c70`](https://github.com/nodejs/node/commit/1bca7b6c70)] - **test**: move test-inspector-module to parallel (Rich Trott) [#32025](https://github.com/nodejs/node/pull/32025)
+* [[`932563473c`](https://github.com/nodejs/node/commit/932563473c)] - **test**: improve disable AsyncLocalStorage test (Andrey Pechkurov) [#31998](https://github.com/nodejs/node/pull/31998)
+* [[`49864d161e`](https://github.com/nodejs/node/commit/49864d161e)] - **test**: fix flaky test-dns-any.js (Rich Trott) [#32017](https://github.com/nodejs/node/pull/32017)
+* [[`38494746a6`](https://github.com/nodejs/node/commit/38494746a6)] - **test**: fix flaky test-gc-net-timeout (Robert Nagy) [#31918](https://github.com/nodejs/node/pull/31918)
+* [[`b6d33f671a`](https://github.com/nodejs/node/commit/b6d33f671a)] - **test**: change test to not be sensitive to buffer send size (Rusty Conover) [#31499](https://github.com/nodejs/node/pull/31499)
+* [[`cef5502055`](https://github.com/nodejs/node/commit/cef5502055)] - **test**: remove sequential/test-https-keep-alive-large-write.js (Rusty Conover) [#31499](https://github.com/nodejs/node/pull/31499)
+* [[`f1e76488a7`](https://github.com/nodejs/node/commit/f1e76488a7)] - **test**: validate common property usage (Denys Otrishko) [#31933](https://github.com/nodejs/node/pull/31933)
+* [[`ab8f060159`](https://github.com/nodejs/node/commit/ab8f060159)] - **test**: fix usage of invalid common properties (Denys Otrishko) [#31933](https://github.com/nodejs/node/pull/31933)
+* [[`49c959d636`](https://github.com/nodejs/node/commit/49c959d636)] - **test**: increase timeout in vm-timeout-escape-queuemicrotask (Denys Otrishko) [#31966](https://github.com/nodejs/node/pull/31966)
+* [[`04eda02d87`](https://github.com/nodejs/node/commit/04eda02d87)] - **test**: add documentation for common.enoughTestCpu (Rich Trott) [#31931](https://github.com/nodejs/node/pull/31931)
+* [[`918c2b67cc`](https://github.com/nodejs/node/commit/918c2b67cc)] - **test**: fix typo in common/index.js (Rich Trott) [#31931](https://github.com/nodejs/node/pull/31931)
+* [[`f89fb2751b`](https://github.com/nodejs/node/commit/f89fb2751b)] - **test**: mark empty udp tests flaky on OS X (Sam Roberts) [#31936](https://github.com/nodejs/node/pull/31936)
+* [[`e08fef1fda`](https://github.com/nodejs/node/commit/e08fef1fda)] - **test**: add secp224k1 check in crypto-dh-stateless (Daniel Bevenius) [#31715](https://github.com/nodejs/node/pull/31715)
+* [[`4fe9e043ef`](https://github.com/nodejs/node/commit/4fe9e043ef)] - **test**: remove common.PORT from assorted pummel tests (Rich Trott) [#31897](https://github.com/nodejs/node/pull/31897)
+* [[`7d5776e119`](https://github.com/nodejs/node/commit/7d5776e119)] - **test**: remove flaky designation for test-net-connect-options-port (Rich Trott) [#31841](https://github.com/nodejs/node/pull/31841)
+* [[`1933efa62f`](https://github.com/nodejs/node/commit/1933efa62f)] - **test**: remove common.PORT from test-net-write-callbacks.js (Rich Trott) [#31839](https://github.com/nodejs/node/pull/31839)
+* [[`87e9014764`](https://github.com/nodejs/node/commit/87e9014764)] - **test**: remove common.PORT from test-net-pause (Rich Trott) [#31749](https://github.com/nodejs/node/pull/31749)
+* [[`3fbd5ab265`](https://github.com/nodejs/node/commit/3fbd5ab265)] - **test**: remove common.PORT from test-tls-server-large-request (Rich Trott) [#31749](https://github.com/nodejs/node/pull/31749)
+* [[`e76ac1d2c9`](https://github.com/nodejs/node/commit/e76ac1d2c9)] - **test**: remove common.PORT from test-net-throttle (Rich Trott) [#31749](https://github.com/nodejs/node/pull/31749)
+* [[`724bf3105b`](https://github.com/nodejs/node/commit/724bf3105b)] - **test**: remove common.PORT from test-net-timeout (Rich Trott) [#31749](https://github.com/nodejs/node/pull/31749)
+* [[`60c71dcad2`](https://github.com/nodejs/node/commit/60c71dcad2)] - **test**: add known issue test for sync writable callback (James M Snell) [#31756](https://github.com/nodejs/node/pull/31756)
+* [[`2c0b249098`](https://github.com/nodejs/node/commit/2c0b249098)] - **tls**: reduce memory copying and number of BIO buffer allocations (Rusty Conover) [#31499](https://github.com/nodejs/node/pull/31499)
+* [[`acb3aff674`](https://github.com/nodejs/node/commit/acb3aff674)] - **(SEMVER-MINOR)** **tls**: expose SSL\_export\_keying\_material (simon) [#31814](https://github.com/nodejs/node/pull/31814)
+* [[`f293dcf6de`](https://github.com/nodejs/node/commit/f293dcf6de)] - **tools**: add NODE\_TEST\_NO\_INTERNET to the doc builder (Joyee Cheung) [#31849](https://github.com/nodejs/node/pull/31849)
+* [[`79b1f04b15`](https://github.com/nodejs/node/commit/79b1f04b15)] - **tools**: sync gyp code base with node-gyp repo (Michaël Zasso) [#30563](https://github.com/nodejs/node/pull/30563)
+* [[`f858f2366c`](https://github.com/nodejs/node/commit/f858f2366c)] - **tools**: update lint-md task to lint for possessives of Node.js (Rich Trott) [#31862](https://github.com/nodejs/node/pull/31862)
+* [[`ae3929e958`](https://github.com/nodejs/node/commit/ae3929e958)] - **(SEMVER-MINOR)** **vm**: implement vm.measureMemory() for per-context memory measurement (Joyee Cheung) [#31824](https://github.com/nodejs/node/pull/31824)
+* [[`a86cb0e480`](https://github.com/nodejs/node/commit/a86cb0e480)] - **vm**: lazily initialize primordials for vm contexts (Joyee Cheung) [#31738](https://github.com/nodejs/node/pull/31738)
+* [[`f2389eba99`](https://github.com/nodejs/node/commit/f2389eba99)] - **worker**: emit runtime error on loop creation failure (Harshitha KP) [#31621](https://github.com/nodejs/node/pull/31621)
+* [[`f87ac90849`](https://github.com/nodejs/node/commit/f87ac90849)] - **worker**: unroll file extension regexp (Anna Henningsen) [#31779](https://github.com/nodejs/node/pull/31779)
+
+<a id="13.9.0"></a>
+## 2020-02-18, Version 13.9.0 (Current), @codebytere
+
+### Notable changes
+
+* **async_hooks**
+  * add executionAsyncResource (Matteo Collina) [#30959](https://github.com/nodejs/node/pull/30959)
+* **crypto**
+  * add crypto.diffieHellman (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+  * add DH support to generateKeyPair (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+  * simplify DH groups (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+  * add key type 'dh' (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+* **test**
+  * skip keygen tests on arm systems (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+* **perf_hooks**
+  * add property flags to GCPerformanceEntry (Kirill Fomichev) [#29547](https://github.com/nodejs/node/pull/29547)
+* **process**
+  * report ArrayBuffer memory in `memoryUsage()` (Anna Henningsen) [#31550](https://github.com/nodejs/node/pull/31550)
+* **readline**
+  * make tab size configurable (Ruben Bridgewater) [#31318](https://github.com/nodejs/node/pull/31318)
+* **report**
+  * add support for Workers (Anna Henningsen) [#31386](https://github.com/nodejs/node/pull/31386)
+* **worker**
+  * add ability to take heap snapshot from parent thread (Anna Henningsen) [#31569](https://github.com/nodejs/node/pull/31569)
+* **added new collaborators**
+  * add ronag to collaborators (Robert Nagy) [#31498](https://github.com/nodejs/node/pull/31498)
+
+### Commits
+
+* [[`2db7593838`](https://github.com/nodejs/node/commit/2db7593838)] - **assert**: align character indicators properly (Ruben Bridgewater) [#31429](https://github.com/nodejs/node/pull/31429)
+* [[`a840e9d639`](https://github.com/nodejs/node/commit/a840e9d639)] - **async_hooks**: ensure event after been emitted on runInAsyncScope (legendecas) [#31784](https://github.com/nodejs/node/pull/31784)
+* [[`6be51296e4`](https://github.com/nodejs/node/commit/6be51296e4)] - **(SEMVER-MINOR)** **async_hooks**: add executionAsyncResource (Matteo Collina) [#30959](https://github.com/nodejs/node/pull/30959)
+* [[`2de085fe93`](https://github.com/nodejs/node/commit/2de085fe93)] - **benchmark**: use let instead of var (Daniele Belardi) [#31592](https://github.com/nodejs/node/pull/31592)
+* [[`e37f5100e5`](https://github.com/nodejs/node/commit/e37f5100e5)] - **benchmark**: swap var for let in benchmarks (Alex Ramirez) [#28958](https://github.com/nodejs/node/pull/28958)
+* [[`819fb76ba5`](https://github.com/nodejs/node/commit/819fb76ba5)] - ***Revert*** "**benchmark**: refactor helper into a class" (Anna Henningsen) [#31722](https://github.com/nodejs/node/pull/31722)
+* [[`8974fa794c`](https://github.com/nodejs/node/commit/8974fa794c)] - ***Revert*** "**benchmark**: add `test` and `all` options and improve errors" (Anna Henningsen) [#31722](https://github.com/nodejs/node/pull/31722)
+* [[`30f55cebb6`](https://github.com/nodejs/node/commit/30f55cebb6)] - ***Revert*** "**benchmark**: remove special test entries" (Anna Henningsen) [#31722](https://github.com/nodejs/node/pull/31722)
+* [[`1484f5ab6e`](https://github.com/nodejs/node/commit/1484f5ab6e)] - **benchmark**: remove special test entries (Ruben Bridgewater) [#31396](https://github.com/nodejs/node/pull/31396)
+* [[`ca343caee3`](https://github.com/nodejs/node/commit/ca343caee3)] - **benchmark**: add `test` and `all` options and improve errors (Ruben Bridgewater) [#31396](https://github.com/nodejs/node/pull/31396)
+* [[`9f2c742626`](https://github.com/nodejs/node/commit/9f2c742626)] - **benchmark**: refactor helper into a class (Ruben Bridgewater) [#31396](https://github.com/nodejs/node/pull/31396)
+* [[`161db608ae`](https://github.com/nodejs/node/commit/161db608ae)] - **benchmark**: check for and fix multiple end() (Brian White) [#31624](https://github.com/nodejs/node/pull/31624)
+* [[`6fe8eda3ca`](https://github.com/nodejs/node/commit/6fe8eda3ca)] - **benchmark**: clean up config resolution in multiple benchmarks (Denys Otrishko) [#31581](https://github.com/nodejs/node/pull/31581)
+* [[`ebdcafafeb`](https://github.com/nodejs/node/commit/ebdcafafeb)] - **benchmark**: add MessagePort benchmark (Anna Henningsen) [#31568](https://github.com/nodejs/node/pull/31568)
+* [[`eb3c6e9127`](https://github.com/nodejs/node/commit/eb3c6e9127)] - **benchmark**: use let and const instead of var (Daniele Belardi) [#31518](https://github.com/nodejs/node/pull/31518)
+* [[`b29badad81`](https://github.com/nodejs/node/commit/b29badad81)] - **benchmark**: fix getStringWidth() benchmark (Rich Trott) [#31476](https://github.com/nodejs/node/pull/31476)
+* [[`519134ddb0`](https://github.com/nodejs/node/commit/519134ddb0)] - **buffer**: improve from() performance (Brian White) [#31615](https://github.com/nodejs/node/pull/31615)
+* [[`769154de07`](https://github.com/nodejs/node/commit/769154de07)] - **buffer**: improve concat() performance (Brian White) [#31522](https://github.com/nodejs/node/pull/31522)
+* [[`9d45393e95`](https://github.com/nodejs/node/commit/9d45393e95)] - **buffer**: improve fill(number) performance (Brian White) [#31489](https://github.com/nodejs/node/pull/31489)
+* [[`60a69770f5`](https://github.com/nodejs/node/commit/60a69770f5)] - **build**: add configure option to debug only Node.js part of the binary (Anna Henningsen) [#31644](https://github.com/nodejs/node/pull/31644)
+* [[`10f9abe81d`](https://github.com/nodejs/node/commit/10f9abe81d)] - **build**: ignore all the "Debug","Release" folders (ConorDavenport) [#31565](https://github.com/nodejs/node/pull/31565)
+* [[`03eade01d7`](https://github.com/nodejs/node/commit/03eade01d7)] - **build**: enable loading internal modules from disk (Gus Caplan) [#31321](https://github.com/nodejs/node/pull/31321)
+* [[`a2b7006847`](https://github.com/nodejs/node/commit/a2b7006847)] - **build**: build docs in GitHub Actions CI workflow (Richard Lau) [#31504](https://github.com/nodejs/node/pull/31504)
+* [[`2e216aebcb`](https://github.com/nodejs/node/commit/2e216aebcb)] - **build**: do not use setup-node in build workflows (Richard Lau) [#31349](https://github.com/nodejs/node/pull/31349)
+* [[`825d089763`](https://github.com/nodejs/node/commit/825d089763)] - **crypto**: fix performance regression (Robert Nagy) [#31742](https://github.com/nodejs/node/pull/31742)
+* [[`3c6545f0b4`](https://github.com/nodejs/node/commit/3c6545f0b4)] - **crypto**: improve randomBytes() performance (Brian White) [#31519](https://github.com/nodejs/node/pull/31519)
+* [[`f84b34d42c`](https://github.com/nodejs/node/commit/f84b34d42c)] - **crypto**: improve errors in DiffieHellmanGroup (Tobias Nießen) [#31445](https://github.com/nodejs/node/pull/31445)
+* [[`4591202e66`](https://github.com/nodejs/node/commit/4591202e66)] - **crypto**: assign and use ERR\_CRYPTO\_UNKNOWN\_CIPHER (Tobias Nießen) [#31437](https://github.com/nodejs/node/pull/31437)
+* [[`bf46c304dd`](https://github.com/nodejs/node/commit/bf46c304dd)] - **(SEMVER-MINOR)** **crypto**: add crypto.diffieHellman (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+* [[`0d3e095941`](https://github.com/nodejs/node/commit/0d3e095941)] - **(SEMVER-MINOR)** **crypto**: add DH support to generateKeyPair (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+* [[`15bd2c9f0c`](https://github.com/nodejs/node/commit/15bd2c9f0c)] - **(SEMVER-MINOR)** **crypto**: simplify DH groups (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+* [[`572322fddf`](https://github.com/nodejs/node/commit/572322fddf)] - **(SEMVER-MINOR)** **crypto**: add key type 'dh' (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+* [[`0ac124b6b9`](https://github.com/nodejs/node/commit/0ac124b6b9)] - **deps**: upgrade npm to 6.13.7 (Michael Perrotte) [#31558](https://github.com/nodejs/node/pull/31558)
+* [[`bf7097c77d`](https://github.com/nodejs/node/commit/bf7097c77d)] - **deps**: switch to chromium's zlib implementation (Brian White) [#31201](https://github.com/nodejs/node/pull/31201)
+* [[`2eeaa5ce40`](https://github.com/nodejs/node/commit/2eeaa5ce40)] - **deps**: uvwasi: cherry-pick 7b5b6f9 (cjihrig) [#31495](https://github.com/nodejs/node/pull/31495)
+* [[`464f4afa66`](https://github.com/nodejs/node/commit/464f4afa66)] - **deps**: upgrade to libuv 1.34.2 (cjihrig) [#31477](https://github.com/nodejs/node/pull/31477)
+* [[`9811ebe0c5`](https://github.com/nodejs/node/commit/9811ebe0c5)] - **deps**: uvwasi: cherry-pick eea4508 (cjihrig) [#31432](https://github.com/nodejs/node/pull/31432)
+* [[`2fe0ed3a2e`](https://github.com/nodejs/node/commit/2fe0ed3a2e)] - **deps**: uvwasi: cherry-pick c3bef8e (cjihrig) [#31432](https://github.com/nodejs/node/pull/31432)
+* [[`09566be899`](https://github.com/nodejs/node/commit/09566be899)] - **deps**: uvwasi: cherry-pick ea73af5 (cjihrig) [#31432](https://github.com/nodejs/node/pull/31432)
+* [[`04f2799ed2`](https://github.com/nodejs/node/commit/04f2799ed2)] - **deps**: update to uvwasi 0.0.5 (cjihrig) [#31432](https://github.com/nodejs/node/pull/31432)
+* [[`7c4f1ed030`](https://github.com/nodejs/node/commit/7c4f1ed030)] - **deps**: uvwasi: cherry-pick 941bedf (cjihrig) [#31363](https://github.com/nodejs/node/pull/31363)
+* [[`00e38a749a`](https://github.com/nodejs/node/commit/00e38a749a)] - **deps**: port uvwasi@676ba9a to gyp (cjihrig) [#31363](https://github.com/nodejs/node/pull/31363)
+* [[`5bd3f6c258`](https://github.com/nodejs/node/commit/5bd3f6c258)] - **deps,test**: update to uvwasi 0.0.4 (cjihrig) [#31363](https://github.com/nodejs/node/pull/31363)
+* [[`2cd8461e56`](https://github.com/nodejs/node/commit/2cd8461e56)] - **doc**: add glossary.md (gengjiawen) [#27517](https://github.com/nodejs/node/pull/27517)
+* [[`c4613c6b8b`](https://github.com/nodejs/node/commit/c4613c6b8b)] - **doc**: add prerequisites information for Arch (Ujjwal Sharma) [#31669](https://github.com/nodejs/node/pull/31669)
+* [[`b35f83e69b`](https://github.com/nodejs/node/commit/b35f83e69b)] - **doc**: fix typo on fs docs (Juan José Arboleda) [#31620](https://github.com/nodejs/node/pull/31620)
+* [[`2ff812ca84`](https://github.com/nodejs/node/commit/2ff812ca84)] - **doc**: update contact email for @ryzokuken (Ujjwal Sharma) [#31670](https://github.com/nodejs/node/pull/31670)
+* [[`2c83946757`](https://github.com/nodejs/node/commit/2c83946757)] - **doc**: fix default server timeout description for https (Andrey Pechkurov) [#31692](https://github.com/nodejs/node/pull/31692)
+* [[`b56a21fdad`](https://github.com/nodejs/node/commit/b56a21fdad)] - **doc**: add directions to mark a release line as lts (Danielle Adams) [#31724](https://github.com/nodejs/node/pull/31724)
+* [[`5ae40cd2b2`](https://github.com/nodejs/node/commit/5ae40cd2b2)] - **doc**: expand C++ README with information about exception handling (Anna Henningsen) [#31720](https://github.com/nodejs/node/pull/31720)
+* [[`94a0ec1b99`](https://github.com/nodejs/node/commit/94a0ec1b99)] - **doc**: update foundation name in onboarding (Tobias Nießen) [#31719](https://github.com/nodejs/node/pull/31719)
+* [[`fda97fa772`](https://github.com/nodejs/node/commit/fda97fa772)] - **doc**: reword possessive form of Node.js in zlib.md (Rich Trott) [#31713](https://github.com/nodejs/node/pull/31713)
+* [[`eea58cd3d5`](https://github.com/nodejs/node/commit/eea58cd3d5)] - **doc**: reword possessive form of Node.js in modules.md (Rich Trott) [#31713](https://github.com/nodejs/node/pull/31713)
+* [[`d0238190a1`](https://github.com/nodejs/node/commit/d0238190a1)] - **doc**: reword possessive form of Node.js in repl.md (Rich Trott) [#31713](https://github.com/nodejs/node/pull/31713)
+* [[`55a25b3bbe`](https://github.com/nodejs/node/commit/55a25b3bbe)] - **doc**: reword section title in addons.md (Rich Trott) [#31713](https://github.com/nodejs/node/pull/31713)
+* [[`ba9fae058a`](https://github.com/nodejs/node/commit/ba9fae058a)] - **doc**: revise deepEqual() legacy assertion mode text (Rich Trott) [#31704](https://github.com/nodejs/node/pull/31704)
+* [[`f6d78f959f`](https://github.com/nodejs/node/commit/f6d78f959f)] - **doc**: improve strict assertion mode color text (Rich Trott) [#31703](https://github.com/nodejs/node/pull/31703)
+* [[`22cf3e3d4e`](https://github.com/nodejs/node/commit/22cf3e3d4e)] - **doc**: consolidate introductory text (Rich Trott) [#31667](https://github.com/nodejs/node/pull/31667)
+* [[`1e2327d9e6`](https://github.com/nodejs/node/commit/1e2327d9e6)] - **doc**: simplify async\_hooks overview (Rich Trott) [#31660](https://github.com/nodejs/node/pull/31660)
+* [[`77ec381ea2`](https://github.com/nodejs/node/commit/77ec381ea2)] - **doc**: clarify Worker exit/message event ordering (Anna Henningsen) [#31642](https://github.com/nodejs/node/pull/31642)
+* [[`4b0085c7e3`](https://github.com/nodejs/node/commit/4b0085c7e3)] - **doc**: update TSC name in "Release Process" (Tobias Nießen) [#31652](https://github.com/nodejs/node/pull/31652)
+* [[`2e6c737281`](https://github.com/nodejs/node/commit/2e6c737281)] - **doc**: remove .github/ISSUE\_TEMPLATE.md in favor of the template folder (Joyee Cheung) [#31656](https://github.com/nodejs/node/pull/31656)
+* [[`b61b85ccf9`](https://github.com/nodejs/node/commit/b61b85ccf9)] - **doc**: add note in BUILDING.md about running `make distclean` (Swagat Konchada) [#31542](https://github.com/nodejs/node/pull/31542)
+* [[`2991e7c0e3`](https://github.com/nodejs/node/commit/2991e7c0e3)] - **doc**: correct getting an ArrayBuffer's length (tsabolov) [#31632](https://github.com/nodejs/node/pull/31632)
+* [[`e27f24987e`](https://github.com/nodejs/node/commit/e27f24987e)] - **doc**: ask more questions in the bug report template (Joyee Cheung) [#31611](https://github.com/nodejs/node/pull/31611)
+* [[`b50a6cc54d`](https://github.com/nodejs/node/commit/b50a6cc54d)] - **doc**: add example to fs.promises.readdir (Conor ONeill) [#31552](https://github.com/nodejs/node/pull/31552)
+* [[`1dbe765b0b`](https://github.com/nodejs/node/commit/1dbe765b0b)] - **doc**: add AsyncResource + Worker pool example (Anna Henningsen) [#31601](https://github.com/nodejs/node/pull/31601)
+* [[`f40264980e`](https://github.com/nodejs/node/commit/f40264980e)] - **doc**: fix numbering (Steffen) [#31575](https://github.com/nodejs/node/pull/31575)
+* [[`3ba0a22c57`](https://github.com/nodejs/node/commit/3ba0a22c57)] - **doc**: clarify socket.setNoDelay() explanation (Rusty Conover) [#31541](https://github.com/nodejs/node/pull/31541)
+* [[`faec87b7f1`](https://github.com/nodejs/node/commit/faec87b7f1)] - **doc**: list largepage values in --help (cjihrig) [#31537](https://github.com/nodejs/node/pull/31537)
+* [[`2638110cce`](https://github.com/nodejs/node/commit/2638110cce)] - **doc**: clarify require() OS independence (Denys Otrishko) [#31571](https://github.com/nodejs/node/pull/31571)
+* [[`7fe9d5ebd4`](https://github.com/nodejs/node/commit/7fe9d5ebd4)] - **doc**: add protocol option in http2.connect() (Michael Lumish) [#31560](https://github.com/nodejs/node/pull/31560)
+* [[`6626c4de3c`](https://github.com/nodejs/node/commit/6626c4de3c)] - **doc**: clarify that `v8.serialize()` is not deterministic (Anna Henningsen) [#31548](https://github.com/nodejs/node/pull/31548)
+* [[`cde4b51a92`](https://github.com/nodejs/node/commit/cde4b51a92)] - **doc**: update job reference in COLLABORATOR\_GUIDE.md (Richard Lau) [#31557](https://github.com/nodejs/node/pull/31557)
+* [[`4cac2cccd6`](https://github.com/nodejs/node/commit/4cac2cccd6)] - **doc**: simultaneous blog and email of sec announce (Sam Roberts) [#31483](https://github.com/nodejs/node/pull/31483)
+* [[`e2b3e4e0e3`](https://github.com/nodejs/node/commit/e2b3e4e0e3)] - **doc**: update collaborator guide citgm instructions (Robert Nagy) [#31549](https://github.com/nodejs/node/pull/31549)
+* [[`43186e0046`](https://github.com/nodejs/node/commit/43186e0046)] - **doc**: change error message testing policy (Tobias Nießen) [#31421](https://github.com/nodejs/node/pull/31421)
+* [[`a52df55b9a`](https://github.com/nodejs/node/commit/a52df55b9a)] - **doc**: remove redundant properties from headers (XhmikosR) [#31492](https://github.com/nodejs/node/pull/31492)
+* [[`04d783ae71`](https://github.com/nodejs/node/commit/04d783ae71)] - **doc**: update maintaining-V8.md (kenzo-spaulding) [#31503](https://github.com/nodejs/node/pull/31503)
+* [[`f75fe9ab71`](https://github.com/nodejs/node/commit/f75fe9ab71)] - **doc**: enable visual code indication in headers (Rich Trott) [#31493](https://github.com/nodejs/node/pull/31493)
+* [[`8f25e51e4e`](https://github.com/nodejs/node/commit/8f25e51e4e)] - **doc**: clean up and streamline vm.md examples (Denys Otrishko) [#31474](https://github.com/nodejs/node/pull/31474)
+* [[`729b96137e`](https://github.com/nodejs/node/commit/729b96137e)] - **doc**: further fix async iterator example (Robert Nagy) [#31367](https://github.com/nodejs/node/pull/31367)
+* [[`15b24b71ce`](https://github.com/nodejs/node/commit/15b24b71ce)] - **doc**: add ronag to collaborators (Robert Nagy) [#31498](https://github.com/nodejs/node/pull/31498)
+* [[`e9462b4d44`](https://github.com/nodejs/node/commit/e9462b4d44)] - **doc**: fix code display in header glitch (Rich Trott) [#31460](https://github.com/nodejs/node/pull/31460)
+* [[`b1c745877b`](https://github.com/nodejs/node/commit/b1c745877b)] - **doc**: fix syntax in N-API documentation (Tobias Nießen) [#31466](https://github.com/nodejs/node/pull/31466)
+* [[`67d8967f98`](https://github.com/nodejs/node/commit/67d8967f98)] - **doc**: add explanatory to path.resolve description (Yakov Litvin) [#31430](https://github.com/nodejs/node/pull/31430)
+* [[`1099524452`](https://github.com/nodejs/node/commit/1099524452)] - **doc**: document process.std\*.fd (Harshitha KP) [#31395](https://github.com/nodejs/node/pull/31395)
+* [[`843c5c6f46`](https://github.com/nodejs/node/commit/843c5c6f46)] - **doc**: fix several child\_process doc typos (cjihrig) [#31393](https://github.com/nodejs/node/pull/31393)
+* [[`d77099856a`](https://github.com/nodejs/node/commit/d77099856a)] - **doc**: fix a broken link in fs.md (himself65) [#31373](https://github.com/nodejs/node/pull/31373)
+* [[`1e08d3c2f1`](https://github.com/nodejs/node/commit/1e08d3c2f1)] - **doc**: correct added version for --abort-on-uncaught-exception (Anna Henningsen) [#31360](https://github.com/nodejs/node/pull/31360)
+* [[`6055134db6`](https://github.com/nodejs/node/commit/6055134db6)] - **doc**: explain `hex` encoding in Buffer API (Harshitha KP) [#31352](https://github.com/nodejs/node/pull/31352)
+* [[`bd54abe3f7`](https://github.com/nodejs/node/commit/bd54abe3f7)] - **doc**: explain \_writev() API (Harshitha KP) [#31356](https://github.com/nodejs/node/pull/31356)
+* [[`91f5e9b0f7`](https://github.com/nodejs/node/commit/91f5e9b0f7)] - **doc**: document missing properties in child\_process (Harshitha KP) [#31342](https://github.com/nodejs/node/pull/31342)
+* [[`6874deef28`](https://github.com/nodejs/node/commit/6874deef28)] - **doc,assert**: rename "mode" to "assertion mode" (Rich Trott) [#31635](https://github.com/nodejs/node/pull/31635)
+* [[`788ea36ce0`](https://github.com/nodejs/node/commit/788ea36ce0)] - **doc,net**: reword Unix domain path paragraph in net.md (Rich Trott) [#31684](https://github.com/nodejs/node/pull/31684)
+* [[`e3e40a12b0`](https://github.com/nodejs/node/commit/e3e40a12b0)] - **doc,util**: revise util.md introductory paragraph (Rich Trott) [#31685](https://github.com/nodejs/node/pull/31685)
+* [[`e46cfaf146`](https://github.com/nodejs/node/commit/e46cfaf146)] - **errors**: make use of "cannot" consistent (Tobias Nießen) [#31420](https://github.com/nodejs/node/pull/31420)
+* [[`f6392e9fde`](https://github.com/nodejs/node/commit/f6392e9fde)] - **esm**: import.meta.resolve with nodejs: builtins (Guy Bedford) [#31032](https://github.com/nodejs/node/pull/31032)
+* [[`21fc81821f`](https://github.com/nodejs/node/commit/21fc81821f)] - **fs**: set path when mkdir recursive called on file (bcoe) [#31607](https://github.com/nodejs/node/pull/31607)
+* [[`8669ecc8a2`](https://github.com/nodejs/node/commit/8669ecc8a2)] - **fs**: bail on permission error in recursive directory creation (bcoe) [#31505](https://github.com/nodejs/node/pull/31505)
+* [[`2c2b3ba39c`](https://github.com/nodejs/node/commit/2c2b3ba39c)] - **fs**: do not emit 'close' twice if emitClose enabled (Robert Nagy) [#31383](https://github.com/nodejs/node/pull/31383)
+* [[`32ac1be372`](https://github.com/nodejs/node/commit/32ac1be372)] - **fs**: unset FileHandle fd after close (Anna Henningsen) [#31389](https://github.com/nodejs/node/pull/31389)
+* [[`9ecae58643`](https://github.com/nodejs/node/commit/9ecae58643)] - **lib**: delete dead code in SourceMap (Justin Ridgewell) [#31512](https://github.com/nodejs/node/pull/31512)
+* [[`7ecf842429`](https://github.com/nodejs/node/commit/7ecf842429)] - **lib,src**: switch Buffer::kMaxLength to size\_t (Ben Noordhuis) [#31406](https://github.com/nodejs/node/pull/31406)
+* [[`15c8d9ead1`](https://github.com/nodejs/node/commit/15c8d9ead1)] - **meta**: move princejwesley to emeritus (Rich Trott) [#31730](https://github.com/nodejs/node/pull/31730)
+* [[`f5ae510e03`](https://github.com/nodejs/node/commit/f5ae510e03)] - **meta**: move vkurchatkin to emeritus (Rich Trott) [#31729](https://github.com/nodejs/node/pull/31729)
+* [[`cd520ddfef`](https://github.com/nodejs/node/commit/cd520ddfef)] - **meta**: move calvinmetcalf to emeritus (Rich Trott) [#31736](https://github.com/nodejs/node/pull/31736)
+* [[`832255df89`](https://github.com/nodejs/node/commit/832255df89)] - **meta**: fix collaborator list errors in README.md (James M Snell) [#31655](https://github.com/nodejs/node/pull/31655)
+* [[`aa266628ba`](https://github.com/nodejs/node/commit/aa266628ba)] - **module**: drop support for extensionless main entry points in esm (Geoffrey Booth) [#31415](https://github.com/nodejs/node/pull/31415)
+* [[`ca81af7d73`](https://github.com/nodejs/node/commit/ca81af7d73)] - **module**: correct docs about when extensionless files are supported (Geoffrey Booth) [#31415](https://github.com/nodejs/node/pull/31415)
+* [[`6797656d86`](https://github.com/nodejs/node/commit/6797656d86)] - **module**: revert #31021 (Geoffrey Booth) [#31415](https://github.com/nodejs/node/pull/31415)
+* [[`ae2141effc`](https://github.com/nodejs/node/commit/ae2141effc)] - **n-api**: free instance data as reference (Gabriel Schulhof) [#31638](https://github.com/nodejs/node/pull/31638)
+* [[`c8215699ab`](https://github.com/nodejs/node/commit/c8215699ab)] - **n-api**: rename 'promise' parameter to 'value' (Tobias Nießen) [#31544](https://github.com/nodejs/node/pull/31544)
+* [[`5982726ef9`](https://github.com/nodejs/node/commit/5982726ef9)] - **net**: track state of setNoDelay() and prevent unnecessary system calls (Rusty Conover) [#31543](https://github.com/nodejs/node/pull/31543)
+* [[`e7fea14c7b`](https://github.com/nodejs/node/commit/e7fea14c7b)] - **(SEMVER-MINOR)** **perf_hooks**: add property flags to GCPerformanceEntry (Kirill Fomichev) [#29547](https://github.com/nodejs/node/pull/29547)
+* [[`672315651d`](https://github.com/nodejs/node/commit/672315651d)] - **(SEMVER-MINOR)** **process**: report ArrayBuffer memory in `memoryUsage()` (Anna Henningsen) [#31550](https://github.com/nodejs/node/pull/31550)
+* [[`cd754337f8`](https://github.com/nodejs/node/commit/cd754337f8)] - **process**: fix two overflow cases in SourceMap VLQ decoding (Justin Ridgewell) [#31490](https://github.com/nodejs/node/pull/31490)
+* [[`98f3028c30`](https://github.com/nodejs/node/commit/98f3028c30)] - **readline**: remove intermediate variable (cjihrig) [#31676](https://github.com/nodejs/node/pull/31676)
+* [[`148dfde1d4`](https://github.com/nodejs/node/commit/148dfde1d4)] - **(SEMVER-MINOR)** **readline**: make tab size configurable (Ruben Bridgewater) [#31318](https://github.com/nodejs/node/pull/31318)
+* [[`1bcf2f9423`](https://github.com/nodejs/node/commit/1bcf2f9423)] - **report**: add support for Workers (Anna Henningsen) [#31386](https://github.com/nodejs/node/pull/31386)
+* [[`7c2d33f38f`](https://github.com/nodejs/node/commit/7c2d33f38f)] - **src**: use hex not decimal in IsArrayIndex (Shelley Vohr) [#31758](https://github.com/nodejs/node/pull/31758)
+* [[`a095ef0d52`](https://github.com/nodejs/node/commit/a095ef0d52)] - **src**: keep main-thread Isolate attached to platform during Dispose (Anna Henningsen) [#31795](https://github.com/nodejs/node/pull/31795)
+* [[`1dec9d196f`](https://github.com/nodejs/node/commit/1dec9d196f)] - **src**: wrap HostPort in ExclusiveAccess (Ben Noordhuis) [#31717](https://github.com/nodejs/node/pull/31717)
+* [[`e23023d685`](https://github.com/nodejs/node/commit/e23023d685)] - **src**: add ExclusiveAccess class (Ben Noordhuis) [#31717](https://github.com/nodejs/node/pull/31717)
+* [[`54caf76210`](https://github.com/nodejs/node/commit/54caf76210)] - **src**: allow to reuse env options handling (Denys Otrishko) [#31711](https://github.com/nodejs/node/pull/31711)
+* [[`6ad8ca5ecf`](https://github.com/nodejs/node/commit/6ad8ca5ecf)] - **src**: do not unnecessarily re-assign uv handle data (Anna Henningsen) [#31696](https://github.com/nodejs/node/pull/31696)
+* [[`2837788849`](https://github.com/nodejs/node/commit/2837788849)] - **src**: fix compile warnings in node\_url.cc (Anna Henningsen) [#31689](https://github.com/nodejs/node/pull/31689)
+* [[`1d34ab5e43`](https://github.com/nodejs/node/commit/1d34ab5e43)] - **src**: modernized unique\_ptr construction (Yuhanun Citgez) [#31654](https://github.com/nodejs/node/pull/31654)
+* [[`0e44902b85`](https://github.com/nodejs/node/commit/0e44902b85)] - **src**: remove dead code in InternalMakeCallback (Gerhard Stoebich) [#31622](https://github.com/nodejs/node/pull/31622)
+* [[`348c7871b6`](https://github.com/nodejs/node/commit/348c7871b6)] - **src**: remove fixed-size GetHumanReadableProcessName (Ben Noordhuis) [#31633](https://github.com/nodejs/node/pull/31633)
+* [[`8964077935`](https://github.com/nodejs/node/commit/8964077935)] - **src**: fix OOB reads in process.title getter (Ben Noordhuis) [#31633](https://github.com/nodejs/node/pull/31633)
+* [[`af612bcc21`](https://github.com/nodejs/node/commit/af612bcc21)] - **src**: various minor improvements to node\_url (James M Snell) [#31651](https://github.com/nodejs/node/pull/31651)
+* [[`f0ffa4cb80`](https://github.com/nodejs/node/commit/f0ffa4cb80)] - **src**: fix inspecting `MessagePort` from `init` async hook (Anna Henningsen) [#31600](https://github.com/nodejs/node/pull/31600)
+* [[`425662e2d6`](https://github.com/nodejs/node/commit/425662e2d6)] - **src**: remove unused `Worker::child\_port\_` member (Anna Henningsen) [#31599](https://github.com/nodejs/node/pull/31599)
+* [[`43e2c2e643`](https://github.com/nodejs/node/commit/43e2c2e643)] - **src**: change Fill() to use ParseArrayIndex() (ConorDavenport) [#31591](https://github.com/nodejs/node/pull/31591)
+* [[`42b835412d`](https://github.com/nodejs/node/commit/42b835412d)] - **src**: remove duplicate field env in CryptoJob class (ConorDavenport) [#31554](https://github.com/nodejs/node/pull/31554)
+* [[`9fd1e717e6`](https://github.com/nodejs/node/commit/9fd1e717e6)] - **src**: fix console debug output on Windows (Denys Otrishko) [#31580](https://github.com/nodejs/node/pull/31580)
+* [[`277980d288`](https://github.com/nodejs/node/commit/277980d288)] - **src**: use \_\_executable\_start for linux hugepages (Ben Noordhuis) [#31547](https://github.com/nodejs/node/pull/31547)
+* [[`6d5c3cd7ac`](https://github.com/nodejs/node/commit/6d5c3cd7ac)] - **src**: remove preview for heap dump utilities (Anna Henningsen) [#31570](https://github.com/nodejs/node/pull/31570)
+* [[`c167ae0a87`](https://github.com/nodejs/node/commit/c167ae0a87)] - **src**: fix minor typo in base\_object.h (Daniel Bevenius) [#31535](https://github.com/nodejs/node/pull/31535)
+* [[`f04576ede0`](https://github.com/nodejs/node/commit/f04576ede0)] - **src**: fix debug crash handling null strings (Rusty Conover) [#31523](https://github.com/nodejs/node/pull/31523)
+* [[`ef4d081660`](https://github.com/nodejs/node/commit/ef4d081660)] - **src**: simplify native immediate queue running (Anna Henningsen) [#31502](https://github.com/nodejs/node/pull/31502)
+* [[`bc0c1420f0`](https://github.com/nodejs/node/commit/bc0c1420f0)] - **src**: define noreturn attribute for windows (Alexander Smarus) [#31467](https://github.com/nodejs/node/pull/31467)
+* [[`9e9dbd44fe`](https://github.com/nodejs/node/commit/9e9dbd44fe)] - **src**: reduce code duplication in BootstrapNode (Denys Otrishko) [#31465](https://github.com/nodejs/node/pull/31465)
+* [[`76aad0e5e1`](https://github.com/nodejs/node/commit/76aad0e5e1)] - **src**: use custom fprintf alike to write errors to stderr (Anna Henningsen) [#31446](https://github.com/nodejs/node/pull/31446)
+* [[`a685827a55`](https://github.com/nodejs/node/commit/a685827a55)] - **src**: add C++-style sprintf utility (Anna Henningsen) [#31446](https://github.com/nodejs/node/pull/31446)
+* [[`049a1727d4`](https://github.com/nodejs/node/commit/049a1727d4)] - **src**: harden running native `SetImmediate()`s slightly (Anna Henningsen) [#31468](https://github.com/nodejs/node/pull/31468)
+* [[`f56de5a3b4`](https://github.com/nodejs/node/commit/f56de5a3b4)] - **src**: move MemoryInfo() for worker code to .cc files (Anna Henningsen) [#31386](https://github.com/nodejs/node/pull/31386)
+* [[`0cacc1facf`](https://github.com/nodejs/node/commit/0cacc1facf)] - **src**: add interrupts to Environments/Workers (Anna Henningsen) [#31386](https://github.com/nodejs/node/pull/31386)
+* [[`f8c45b277f`](https://github.com/nodejs/node/commit/f8c45b277f)] - **src**: remove AsyncRequest (Anna Henningsen) [#31386](https://github.com/nodejs/node/pull/31386)
+* [[`600e96ec04`](https://github.com/nodejs/node/commit/600e96ec04)] - **src**: add a threadsafe variant of SetImmediate() (Anna Henningsen) [#31386](https://github.com/nodejs/node/pull/31386)
+* [[`74a7cdbe05`](https://github.com/nodejs/node/commit/74a7cdbe05)] - **src**: exclude C++ SetImmediate() from count (Anna Henningsen) [#31386](https://github.com/nodejs/node/pull/31386)
+* [[`53e566bc50`](https://github.com/nodejs/node/commit/53e566bc50)] - **src**: better encapsulate native immediate list (Anna Henningsen) [#31386](https://github.com/nodejs/node/pull/31386)
+* [[`b8face28e7`](https://github.com/nodejs/node/commit/b8face28e7)] - **src**: reduce large pages code duplication (Gabriel Schulhof) [#31385](https://github.com/nodejs/node/pull/31385)
+* [[`83dd65a469`](https://github.com/nodejs/node/commit/83dd65a469)] - **src**: fix ignore GCC -Wcast-function-type for older compilers (Denys Otrishko) [#31524](https://github.com/nodejs/node/pull/31524)
+* [[`13c6965703`](https://github.com/nodejs/node/commit/13c6965703)] - **src**: ignore GCC -Wcast-function-type for v8.h (Daniel Bevenius) [#31475](https://github.com/nodejs/node/pull/31475)
+* [[`3dd4089b9a`](https://github.com/nodejs/node/commit/3dd4089b9a)] - **(SEMVER-MINOR)** **src,lib**: make ^C print a JS stack trace (legendecas) [#29207](https://github.com/nodejs/node/pull/29207)
+* [[`6d0b2267ce`](https://github.com/nodejs/node/commit/6d0b2267ce)] - **stream**: fix finished w/ 'close' before 'finish' (Robert Nagy) [#31534](https://github.com/nodejs/node/pull/31534)
+* [[`80e75ab389`](https://github.com/nodejs/node/commit/80e75ab389)] - **stream**: add regression test for async iteration completion (Matteo Collina) [#31508](https://github.com/nodejs/node/pull/31508)
+* [[`538582b43d`](https://github.com/nodejs/node/commit/538582b43d)] - ***Revert*** "**stream**: fix async iterator destroyed error propagation" (Matteo Collina) [#31508](https://github.com/nodejs/node/pull/31508)
+* [[`f255053033`](https://github.com/nodejs/node/commit/f255053033)] - **stream**: fix finished writable/readable state (Robert Nagy) [#31527](https://github.com/nodejs/node/pull/31527)
+* [[`3046648580`](https://github.com/nodejs/node/commit/3046648580)] - **stream**: implement throw for async iterator (Robert Nagy) [#31316](https://github.com/nodejs/node/pull/31316)
+* [[`5a95fa4aeb`](https://github.com/nodejs/node/commit/5a95fa4aeb)] - **stream**: normalize async iterator stream destroy (Robert Nagy) [#31316](https://github.com/nodejs/node/pull/31316)
+* [[`20d0a0e9a7`](https://github.com/nodejs/node/commit/20d0a0e9a7)] - **stream**: add async iterator support for v1 streams (Robert Nagy) [#31316](https://github.com/nodejs/node/pull/31316)
+* [[`0654e6790d`](https://github.com/nodejs/node/commit/0654e6790d)] - **test**: mark test-fs-stat-bigint flaky on FreeBSD (Rich Trott) [#31728](https://github.com/nodejs/node/pull/31728)
+* [[`6dbe6bde56`](https://github.com/nodejs/node/commit/6dbe6bde56)] - **test**: fix flaky parallel/test-repl-history-navigation test (Ruben Bridgewater) [#31708](https://github.com/nodejs/node/pull/31708)
+* [[`1dae7dc6bc`](https://github.com/nodejs/node/commit/1dae7dc6bc)] - **test**: improve test-fs-stat-bigint (Rich Trott) [#31726](https://github.com/nodejs/node/pull/31726)
+* [[`fa9b59276d`](https://github.com/nodejs/node/commit/fa9b59276d)] - **test**: remove flaky designation for test-fs-stat-bigint (Rich Trott) [#30437](https://github.com/nodejs/node/pull/30437)
+* [[`d36ba2b555`](https://github.com/nodejs/node/commit/d36ba2b555)] - **test**: fix flaky test-fs-stat-bigint (Duncan Healy) [#30437](https://github.com/nodejs/node/pull/30437)
+* [[`5b3c4b3e7d`](https://github.com/nodejs/node/commit/5b3c4b3e7d)] - ***Revert*** "**test**: refactor all benchmark tests to use the new test option" (Anna Henningsen) [#31722](https://github.com/nodejs/node/pull/31722)
+* [[`2c0f3028c9`](https://github.com/nodejs/node/commit/2c0f3028c9)] - **test**: add debugging output to test-net-listen-after-destroy-stdin (Rich Trott) [#31698](https://github.com/nodejs/node/pull/31698)
+* [[`2224211609`](https://github.com/nodejs/node/commit/2224211609)] - **test**: improve assertion message in test-dns-any (Rich Trott) [#31697](https://github.com/nodejs/node/pull/31697)
+* [[`b0e37b7180`](https://github.com/nodejs/node/commit/b0e37b7180)] - **test**: fix flaky test-trace-sigint-on-idle (Anna Henningsen) [#31645](https://github.com/nodejs/node/pull/31645)
+* [[`58f17c0e6b`](https://github.com/nodejs/node/commit/58f17c0e6b)] - **test**: stricter assert color test (Ruben Bridgewater) [#31429](https://github.com/nodejs/node/pull/31429)
+* [[`89dcf733c6`](https://github.com/nodejs/node/commit/89dcf733c6)] - **test**: improve logged errors (Ruben Bridgewater) [#31425](https://github.com/nodejs/node/pull/31425)
+* [[`4878c7a197`](https://github.com/nodejs/node/commit/4878c7a197)] - **test**: refactor all benchmark tests to use the new test option (Ruben Bridgewater) [#31396](https://github.com/nodejs/node/pull/31396)
+* [[`3bcc2da887`](https://github.com/nodejs/node/commit/3bcc2da887)] - **test**: fix test-benchmark-http (Rich Trott) [#31686](https://github.com/nodejs/node/pull/31686)
+* [[`6139d4ea3b`](https://github.com/nodejs/node/commit/6139d4ea3b)] - **test**: fix flaky test-inspector-connect-main-thread (Anna Henningsen) [#31637](https://github.com/nodejs/node/pull/31637)
+* [[`13c256d31d`](https://github.com/nodejs/node/commit/13c256d31d)] - **test**: add test-dns-promises-lookupService (Rich Trott) [#31640](https://github.com/nodejs/node/pull/31640)
+* [[`23fefba84c`](https://github.com/nodejs/node/commit/23fefba84c)] - **test**: fix flaky test-http2-stream-destroy-event-order (Anna Henningsen) [#31610](https://github.com/nodejs/node/pull/31610)
+* [[`435b9c977a`](https://github.com/nodejs/node/commit/435b9c977a)] - **test**: abstract common assertions in readline-interface test (Ruben Bridgewater) [#31423](https://github.com/nodejs/node/pull/31423)
+* [[`d2a12d3af8`](https://github.com/nodejs/node/commit/d2a12d3af8)] - **test**: refactor test-readline-interface.js (Ruben Bridgewater) [#31423](https://github.com/nodejs/node/pull/31423)
+* [[`7c3cc94b9f`](https://github.com/nodejs/node/commit/7c3cc94b9f)] - **test**: unset NODE\_OPTIONS for cctest (Anna Henningsen) [#31594](https://github.com/nodejs/node/pull/31594)
+* [[`62d0c6029d`](https://github.com/nodejs/node/commit/62d0c6029d)] - **test**: simplify test-https-simple.js (Sam Roberts) [#31584](https://github.com/nodejs/node/pull/31584)
+* [[`49be50051c`](https://github.com/nodejs/node/commit/49be50051c)] - **test**: show child stderr output in largepages test (Ben Noordhuis) [#31612](https://github.com/nodejs/node/pull/31612)
+* [[`c3247fedd9`](https://github.com/nodejs/node/commit/c3247fedd9)] - **test**: mark additional tests as flaky on Windows (Anna Henningsen) [#31606](https://github.com/nodejs/node/pull/31606)
+* [[`3fdec1c790`](https://github.com/nodejs/node/commit/3fdec1c790)] - **test**: fix flaky test-memory-usage (Anna Henningsen) [#31602](https://github.com/nodejs/node/pull/31602)
+* [[`23da559ab2`](https://github.com/nodejs/node/commit/23da559ab2)] - **test**: verify threadId in reports (Dylan Coakley) [#31556](https://github.com/nodejs/node/pull/31556)
+* [[`5a12cd636b`](https://github.com/nodejs/node/commit/5a12cd636b)] - **test**: remove --experimental-worker flag comment (Harshitha KP) [#31563](https://github.com/nodejs/node/pull/31563)
+* [[`07525c317e`](https://github.com/nodejs/node/commit/07525c317e)] - **test**: make test-http2-buffersize more correct (Anna Henningsen) [#31502](https://github.com/nodejs/node/pull/31502)
+* [[`c4a2f94a11`](https://github.com/nodejs/node/commit/c4a2f94a11)] - **test**: cover property n-api null cases (Gabriel Schulhof) [#31488](https://github.com/nodejs/node/pull/31488)
+* [[`f2dc694805`](https://github.com/nodejs/node/commit/f2dc694805)] - **test**: fix test-heapdump-worker (Anna Henningsen) [#31494](https://github.com/nodejs/node/pull/31494)
+* [[`b25ea9b1dc`](https://github.com/nodejs/node/commit/b25ea9b1dc)] - **test**: add tests for main() argument handling (cjihrig) [#31426](https://github.com/nodejs/node/pull/31426)
+* [[`38ea53629b`](https://github.com/nodejs/node/commit/38ea53629b)] - **test**: add wasi test for freopen() (cjihrig) [#31432](https://github.com/nodejs/node/pull/31432)
+* [[`c2792aad44`](https://github.com/nodejs/node/commit/c2792aad44)] - **test**: remove bluebird remnants from test fixture (Rich Trott) [#31435](https://github.com/nodejs/node/pull/31435)
+* [[`583d1d9f55`](https://github.com/nodejs/node/commit/583d1d9f55)] - **test**: improve wasi stat test (cjihrig) [#31413](https://github.com/nodejs/node/pull/31413)
+* [[`676b84a803`](https://github.com/nodejs/node/commit/676b84a803)] - **(SEMVER-MINOR)** **test**: skip keygen tests on arm systems (Tobias Nießen) [#31178](https://github.com/nodejs/node/pull/31178)
+* [[`099c921f40`](https://github.com/nodejs/node/commit/099c921f40)] - **test**: add wasi test for symlink() and readlink() (cjihrig) [#31403](https://github.com/nodejs/node/pull/31403)
+* [[`6256d0ae92`](https://github.com/nodejs/node/commit/6256d0ae92)] - **test**: update postmortem test with v12 constants (Matheus Marchini) [#31391](https://github.com/nodejs/node/pull/31391)
+* [[`0bafb5c8c8`](https://github.com/nodejs/node/commit/0bafb5c8c8)] - **test**: export public symbols in addons tests (Ben Noordhuis) [#28717](https://github.com/nodejs/node/pull/28717)
+* [[`6833f62e9d`](https://github.com/nodejs/node/commit/6833f62e9d)] - **test**: add promises metadata to postmortem test (Matheus Marchini) [#31357](https://github.com/nodejs/node/pull/31357)
+* [[`41524282b5`](https://github.com/nodejs/node/commit/41524282b5)] - **test,benchmark**: fix test-benchmark-zlib (Rich Trott) [#31538](https://github.com/nodejs/node/pull/31538)
+* [[`c34872e464`](https://github.com/nodejs/node/commit/c34872e464)] - **test,dns**: add coverage for dns exception (Rich Trott) [#31678](https://github.com/nodejs/node/pull/31678)
+* [[`03aac4e65d`](https://github.com/nodejs/node/commit/03aac4e65d)] - **tls**: simplify errors using ThrowCryptoError (Tobias Nießen) [#31436](https://github.com/nodejs/node/pull/31436)
+* [[`95d509e974`](https://github.com/nodejs/node/commit/95d509e974)] - **tools**: update Markdown linter to be cross-platform (Derek Lewis) [#31239](https://github.com/nodejs/node/pull/31239)
+* [[`328b8a6444`](https://github.com/nodejs/node/commit/328b8a6444)] - **tools**: unify make-v8.sh for ppc64le and s390x (Richard Lau) [#31628](https://github.com/nodejs/node/pull/31628)
+* [[`39c86bbe4c`](https://github.com/nodejs/node/commit/39c86bbe4c)] - **tools**: replace deprecated iteritems() for items() (Giovanny Andres Gongora Granada (Gioyik)) [#31528](https://github.com/nodejs/node/pull/31528)
+* [[`be55f3ec4f`](https://github.com/nodejs/node/commit/be55f3ec4f)] - **tty**: do not end in an infinite warning recursion (Ruben Bridgewater) [#31429](https://github.com/nodejs/node/pull/31429)
+* [[`a0c1ceddbc`](https://github.com/nodejs/node/commit/a0c1ceddbc)] - **util**: throw if unreachable TypedArray checking code is reached (Rich Trott) [#31737](https://github.com/nodejs/node/pull/31737)
+* [[`7b9d6d08f4`](https://github.com/nodejs/node/commit/7b9d6d08f4)] - **util**: add coverage for util.inspect.colors alias setter (Rich Trott) [#31743](https://github.com/nodejs/node/pull/31743)
+* [[`9f9edc2c78`](https://github.com/nodejs/node/commit/9f9edc2c78)] - **util**: throw if unreachable code is reached (Rich Trott) [#31712](https://github.com/nodejs/node/pull/31712)
+* [[`5e1bee817c`](https://github.com/nodejs/node/commit/5e1bee817c)] - **util**: fix inspection of typed arrays with unusual length (Ruben Bridgewater) [#31458](https://github.com/nodejs/node/pull/31458)
+* [[`3da4d5174c`](https://github.com/nodejs/node/commit/3da4d5174c)] - **util**: improve unicode support (Ruben Bridgewater) [#31319](https://github.com/nodejs/node/pull/31319)
+* [[`822f2ac640`](https://github.com/nodejs/node/commit/822f2ac640)] - **worker**: add support for .cjs extension (Antoine du HAMEL) [#31662](https://github.com/nodejs/node/pull/31662)
+* [[`cd99dc7368`](https://github.com/nodejs/node/commit/cd99dc7368)] - **worker**: properly handle env and NODE\_OPTIONS in workers (Denys Otrishko) [#31711](https://github.com/nodejs/node/pull/31711)
+* [[`1592c474da`](https://github.com/nodejs/node/commit/1592c474da)] - **worker**: reset `Isolate` stack limit after entering `Locker` (Anna Henningsen) [#31593](https://github.com/nodejs/node/pull/31593)
+* [[`3e5803f91b`](https://github.com/nodejs/node/commit/3e5803f91b)] - **worker**: improve MessagePort performance (Anna Henningsen) [#31605](https://github.com/nodejs/node/pull/31605)
+* [[`8d3ffbeb55`](https://github.com/nodejs/node/commit/8d3ffbeb55)] - **(SEMVER-MINOR)** **worker**: add ability to take heap snapshot from parent thread (Anna Henningsen) [#31569](https://github.com/nodejs/node/pull/31569)
+* [[`6fdef457c6`](https://github.com/nodejs/node/commit/6fdef457c6)] - **worker**: remove redundant closing of child port (aaccttrr) [#31555](https://github.com/nodejs/node/pull/31555)
+* [[`5656ec9f71`](https://github.com/nodejs/node/commit/5656ec9f71)] - **worker**: move JoinThread() back into exit callback (Anna Henningsen) [#31468](https://github.com/nodejs/node/pull/31468)
+
+<a id="13.8.0"></a>
+## 2020-02-06, Version 13.8.0 (Current), @BethGriggs
+
+### Notable Changes
+
+This is a security release.
+
+Vulnerabilities fixed:
+* **CVE-2019-15606**: HTTP header values do not have trailing OWS trimmed.
+* **CVE-2019-15605**: HTTP request smuggling using malformed Transfer-Encoding header.
+* **CVE-2019-15604**: Remotely trigger an assertion on a TLS server with a malformed certificate string.
+
+Also, HTTP parsing is more strict to be more secure. Since this may
+cause problems in interoperability with some non-conformant HTTP
+implementations, it is possible to disable the strict checks with the
+`--insecure-http-parser` command line flag, or the `insecureHTTPParser`
+http option. Using the insecure HTTP parser should be avoided.
+
+### Commits
+
+* [[`b7da194714`](https://github.com/nodejs/node/commit/b7da194714)] - **benchmark**: support optional headers with wrk (Sam Roberts) [nodejs-private/node-private#189](https://github.com/nodejs-private/node-private/pull/189)
+* [[`1156a9e5f8`](https://github.com/nodejs/node/commit/1156a9e5f8)] - **crypto**: fix assertion caused by unsupported ext (Fedor Indutny) [nodejs-private/node-private#175](https://github.com/nodejs-private/node-private/pull/175)
+* [[`8f41e837bb`](https://github.com/nodejs/node/commit/8f41e837bb)] - **deps**: update llhttp to 2.0.4 (Beth Griggs) [nodejs-private/node-private#199](https://github.com/nodejs-private/node-private/pull/199)
+* [[`07d56e49cf`](https://github.com/nodejs/node/commit/07d56e49cf)] - **(SEMVER-MINOR)** **http**: make --insecure-http-parser configurable per-stream or per-server (Anna Henningsen) [#31448](https://github.com/nodejs/node/pull/31448)
+* [[`25b6897e8a`](https://github.com/nodejs/node/commit/25b6897e8a)] - **http**: strip trailing OWS from header values (Sam Roberts) [nodejs-private/node-private#189](https://github.com/nodejs-private/node-private/pull/189)
+* [[`eea3a7429b`](https://github.com/nodejs/node/commit/eea3a7429b)] - **test**: using TE to smuggle reqs is not possible (Sam Roberts) [nodejs-private/node-private#199](https://github.com/nodejs-private/node-private/pull/199)
+
+<a id="13.7.0"></a>
+## 2020-01-21, Version 13.7.0 (Current), @codebytere
+
+### Notable Changes
+
+* **deps**:
+  * upgrade to libuv 1.34.1 (cjihrig) [#31332](https://github.com/nodejs/node/pull/31332)
+  * upgrade npm to 6.13.6 (Ruy Adorno) [#31304](https://github.com/nodejs/node/pull/31304)
+* **module**
+  * add API for interacting with source maps (bcoe) [#31132](https://github.com/nodejs/node/pull/31132)
+  * loader getSource, getFormat, transform hooks (Geoffrey Booth) [#30986](https://github.com/nodejs/node/pull/30986)
+  * logical conditional exports ordering (Guy Bedford) [#31008](https://github.com/nodejs/node/pull/31008)
+  * unflag conditional exports (Guy Bedford) [#31001](https://github.com/nodejs/node/pull/31001)
+* **process**:
+  * allow monitoring uncaughtException (Gerhard Stoebich) [#31257](https://github.com/nodejs/node/pull/31257)
+* **Added new collaborators**:
+  * [GeoffreyBooth](https://github.com/GeoffreyBooth) - Geoffrey Booth. [#31306](https://github.com/nodejs/node/pull/31306)
+
+### Commits
+
+* [[`9d26358cfe`](https://github.com/nodejs/node/commit/9d26358cfe)] - **async_hooks**: remove internal only error checking (Anatoli Papirovski) [#30967](https://github.com/nodejs/node/pull/30967)
+* [[`6e978f7d73`](https://github.com/nodejs/node/commit/6e978f7d73)] - **benchmark**: add default type in getstringwidth.js (Rich Trott) [#31377](https://github.com/nodejs/node/pull/31377)
+* [[`317d2dba45`](https://github.com/nodejs/node/commit/317d2dba45)] - **benchmark**: benchmarking impacts of async hooks on promises (legendecas) [#31188](https://github.com/nodejs/node/pull/31188)
+* [[`55e2b4ee3b`](https://github.com/nodejs/node/commit/55e2b4ee3b)] - **build**: remove enable\_vtune from vcbuild.bat (Richard Lau) [#31338](https://github.com/nodejs/node/pull/31338)
+* [[`f11406de43`](https://github.com/nodejs/node/commit/f11406de43)] - **build**: add vs2019 to vcbuild.bat help (Richard Lau) [#31338](https://github.com/nodejs/node/pull/31338)
+* [[`b2180d932a`](https://github.com/nodejs/node/commit/b2180d932a)] - **build**: fix macos runner type in GitHub Action (扩散性百万甜面包) [#31327](https://github.com/nodejs/node/pull/31327)
+* [[`a6e1e9c6c3`](https://github.com/nodejs/node/commit/a6e1e9c6c3)] - **build**: fix step name in GitHub Actions workflow (Richard Lau) [#31323](https://github.com/nodejs/node/pull/31323)
+* [[`0379c319fd`](https://github.com/nodejs/node/commit/0379c319fd)] - **build**: add GitHub actions to run linters (Richard Lau) [#31323](https://github.com/nodejs/node/pull/31323)
+* [[`a31eed0214`](https://github.com/nodejs/node/commit/a31eed0214)] - **build**: silence OpenSSL Windows compiler warnings (Richard Lau) [#31311](https://github.com/nodejs/node/pull/31311)
+* [[`6b118b44e8`](https://github.com/nodejs/node/commit/6b118b44e8)] - **build**: silence c-ares Windows compiler warnings (Richard Lau) [#31311](https://github.com/nodejs/node/pull/31311)
+* [[`7a5d4fad84`](https://github.com/nodejs/node/commit/7a5d4fad84)] - **build**: test Python 3 using GitHub Actions-based CI (cclauss) [#29474](https://github.com/nodejs/node/pull/29474)
+* [[`964371824c`](https://github.com/nodejs/node/commit/964371824c)] - **build**: avoid using CMP for BZ2File (SpaceRacet5w2A6l0I) [#31198](https://github.com/nodejs/node/pull/31198)
+* [[`22859367ca`](https://github.com/nodejs/node/commit/22859367ca)] - **child_process**: remove unnecessary use of inner state (Chetan Karande) [#29358](https://github.com/nodejs/node/pull/29358)
+* [[`6d6a3e4551`](https://github.com/nodejs/node/commit/6d6a3e4551)] - **deps**: V8: cherry-pick d89f4ef1cd62 (Milad Farazmand) [#31354](https://github.com/nodejs/node/pull/31354)
+* [[`d62d06b3b7`](https://github.com/nodejs/node/commit/d62d06b3b7)] - **deps**: V8: cherry-pick b9d33036e9a8 (Benjamin Coe) [#31335](https://github.com/nodejs/node/pull/31335)
+* [[`51e4a5618b`](https://github.com/nodejs/node/commit/51e4a5618b)] - **deps**: upgrade to libuv 1.34.1 (cjihrig) [#31332](https://github.com/nodejs/node/pull/31332)
+* [[`985f980053`](https://github.com/nodejs/node/commit/985f980053)] - **deps**: upgrade npm to 6.13.6 (Ruy Adorno) [#31304](https://github.com/nodejs/node/pull/31304)
+* [[`6f95f01f95`](https://github.com/nodejs/node/commit/6f95f01f95)] - **deps**: deactivate failing tests corresponding to experimental features (Ruben Bridgewater) [#31289](https://github.com/nodejs/node/pull/31289)
+* [[`aed00d7d68`](https://github.com/nodejs/node/commit/aed00d7d68)] - **doc**: add missing code formatting in vm.md (cjihrig) [#31350](https://github.com/nodejs/node/pull/31350)
+* [[`aedbfdb33a`](https://github.com/nodejs/node/commit/aedbfdb33a)] - **doc**: standardize on "host name" in url.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`28245277d7`](https://github.com/nodejs/node/commit/28245277d7)] - **doc**: standardize on "host name" in tls.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`baeabff896`](https://github.com/nodejs/node/commit/baeabff896)] - **doc**: standardize on "host name" in os.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`94122f611a`](https://github.com/nodejs/node/commit/94122f611a)] - **doc**: standardize on "host name" in net.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`bac588e076`](https://github.com/nodejs/node/commit/bac588e076)] - **doc**: standardize on "host name" in https.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`600eb8b67c`](https://github.com/nodejs/node/commit/600eb8b67c)] - **doc**: standardize on "host name" in http2.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`47f71de786`](https://github.com/nodejs/node/commit/47f71de786)] - **doc**: standardize on "host name" in fs.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`ece70a8288`](https://github.com/nodejs/node/commit/ece70a8288)] - **doc**: standardize on "host name" in errors.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`b8dee4540a`](https://github.com/nodejs/node/commit/b8dee4540a)] - **doc**: standardize on "host name" in dgram.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`8055f78995`](https://github.com/nodejs/node/commit/8055f78995)] - **doc**: standardize on "host name" in deprecations.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`6e9f0daad1`](https://github.com/nodejs/node/commit/6e9f0daad1)] - **doc**: standardize on "host name" in async\_hooks.md (Rich Trott) [#31326](https://github.com/nodejs/node/pull/31326)
+* [[`e1fd6ae4fa`](https://github.com/nodejs/node/commit/e1fd6ae4fa)] - **doc**: fix a code example in crypto.md (himself65) [#31313](https://github.com/nodejs/node/pull/31313)
+* [[`bb9622ba5a`](https://github.com/nodejs/node/commit/bb9622ba5a)] - **doc**: add an example for util.types.isExternal (Harshitha KP) [#31173](https://github.com/nodejs/node/pull/31173)
+* [[`0608873052`](https://github.com/nodejs/node/commit/0608873052)] - **doc**: fix example of parsing request.url (Egor Pavlov) [#31302](https://github.com/nodejs/node/pull/31302)
+* [[`b9aca7849d`](https://github.com/nodejs/node/commit/b9aca7849d)] - **doc**: document readline key bindings (Harshitha KP) [#31256](https://github.com/nodejs/node/pull/31256)
+* [[`6184f1ab70`](https://github.com/nodejs/node/commit/6184f1ab70)] - **doc**: improve doc v8.getHeapSpaceStatistics() 'GetHeapSpaceStatistics' (dev-313) [#31274](https://github.com/nodejs/node/pull/31274)
+* [[`deff60024a`](https://github.com/nodejs/node/commit/deff60024a)] - **doc**: update README to make Node.js description clearer (carterbancroft) [#31266](https://github.com/nodejs/node/pull/31266)
+* [[`8e14066578`](https://github.com/nodejs/node/commit/8e14066578)] - **doc**: fix a code example in zlib.md (Alexander Wang) [#31264](https://github.com/nodejs/node/pull/31264)
+* [[`9c58aa4c75`](https://github.com/nodejs/node/commit/9c58aa4c75)] - **doc**: add GeoffreyBooth to collaborators (Geoffrey Booth) [#31306](https://github.com/nodejs/node/pull/31306)
+* [[`de6f2be0d0`](https://github.com/nodejs/node/commit/de6f2be0d0)] - **doc**: update description of `External` (Anna Henningsen) [#31255](https://github.com/nodejs/node/pull/31255)
+* [[`0e48d8d855`](https://github.com/nodejs/node/commit/0e48d8d855)] - **doc**: rename iterator to iterable in examples (Robert Nagy) [#31252](https://github.com/nodejs/node/pull/31252)
+* [[`d51de787d9`](https://github.com/nodejs/node/commit/d51de787d9)] - **doc**: fix stream async iterator sample (Robert Nagy) [#31252](https://github.com/nodejs/node/pull/31252)
+* [[`3e7b3e3c18`](https://github.com/nodejs/node/commit/3e7b3e3c18)] - **doc**: correct filehandle.\[read|write|append\]File() (Bryan English) [#31235](https://github.com/nodejs/node/pull/31235)
+* [[`220ea0c12e`](https://github.com/nodejs/node/commit/220ea0c12e)] - **doc**: prefer server vs srv and client vs clt (Andrew Hughes) [#31224](https://github.com/nodejs/node/pull/31224)
+* [[`c1333ea113`](https://github.com/nodejs/node/commit/c1333ea113)] - **doc**: explain native external types (Harshitha KP) [#31214](https://github.com/nodejs/node/pull/31214)
+* [[`82b447c399`](https://github.com/nodejs/node/commit/82b447c399)] - **doc,src**: clarify that one napi\_env is per-module (legendecas) [#31102](https://github.com/nodejs/node/pull/31102)
+* [[`4981f9721a`](https://github.com/nodejs/node/commit/4981f9721a)] - **errors**: remove dead code in ERR\_INVALID\_ARG\_TYPE (Gerhard Stoebich) [#31322](https://github.com/nodejs/node/pull/31322)
+* [[`b55fba2028`](https://github.com/nodejs/node/commit/b55fba2028)] - **fs**: add missing HandleScope to FileHandle.close (Anna Henningsen) [#31276](https://github.com/nodejs/node/pull/31276)
+* [[`57016b9e66`](https://github.com/nodejs/node/commit/57016b9e66)] - **fs**: use async writeFile in FileHandle#appendFile (Bryan English) [#31235](https://github.com/nodejs/node/pull/31235)
+* [[`52504fb91e`](https://github.com/nodejs/node/commit/52504fb91e)] - **http2**: skip creating native ShutdownWrap (Anna Henningsen) [#31283](https://github.com/nodejs/node/pull/31283)
+* [[`108046d910`](https://github.com/nodejs/node/commit/108046d910)] - **lib**: replace BigInt64Array global by the primordials (Sebastien Ahkrin) [#31193](https://github.com/nodejs/node/pull/31193)
+* [[`02714573ee`](https://github.com/nodejs/node/commit/02714573ee)] - **lib**: add Uint16Array primordials (Sebastien Ahkrin) [#31210](https://github.com/nodejs/node/pull/31210)
+* [[`53e73fc60e`](https://github.com/nodejs/node/commit/53e73fc60e)] - **lib**: add RegExp primordials (Sebastien Ahkrin) [#31208](https://github.com/nodejs/node/pull/31208)
+* [[`f7833ac934`](https://github.com/nodejs/node/commit/f7833ac934)] - **lib**: replace Float32Array global by the primordials (Sebastien Ahkrin) [#31195](https://github.com/nodejs/node/pull/31195)
+* [[`aafeab8cdb`](https://github.com/nodejs/node/commit/aafeab8cdb)] - **lib**: replace BigUInt64Array global by the primordials (Sebastien Ahkrin) [#31194](https://github.com/nodejs/node/pull/31194)
+* [[`ac904f9e65`](https://github.com/nodejs/node/commit/ac904f9e65)] - **lib,tools,test**: remove custom number-isnan rule (cjihrig) [#31211](https://github.com/nodejs/node/pull/31211)
+* [[`cb27c2bd3e`](https://github.com/nodejs/node/commit/cb27c2bd3e)] - **module**: fix check exports issue in cjs module loading (Guy Bedford) [#31427](https://github.com/nodejs/node/pull/31427)
+* [[`ea27e16fc2`](https://github.com/nodejs/node/commit/ea27e16fc2)] - **(SEMVER-MINOR)** **module**: unflag conditional exports (Guy Bedford) [#31001](https://github.com/nodejs/node/pull/31001)
+* [[`4dced024fd`](https://github.com/nodejs/node/commit/4dced024fd)] - **(SEMVER-MINOR)** **module**: add API for interacting with source maps (bcoe) [#31132](https://github.com/nodejs/node/pull/31132)
+* [[`f62fb7603a`](https://github.com/nodejs/node/commit/f62fb7603a)] - **module**: logical conditional exports ordering (Guy Bedford) [#31008](https://github.com/nodejs/node/pull/31008)
+* [[`94af94ae73`](https://github.com/nodejs/node/commit/94af94ae73)] - **module**: loader getSource, getFormat, transform hooks (Geoffrey Booth) [#30986](https://github.com/nodejs/node/pull/30986)
+* [[`c8aa08ed27`](https://github.com/nodejs/node/commit/c8aa08ed27)] - **n-api**: return napi\_invalid\_arg on napi\_create\_bigint\_words (legendecas) [#31312](https://github.com/nodejs/node/pull/31312)
+* [[`0911813862`](https://github.com/nodejs/node/commit/0911813862)] - **(SEMVER-MINOR)** **n-api**: add napi\_get\_all\_property\_names (himself65) [#30006](https://github.com/nodejs/node/pull/30006)
+* [[`79eba6afa3`](https://github.com/nodejs/node/commit/79eba6afa3)] - **(SEMVER-MINOR)** **process**: allow monitoring uncaughtException (Gerhard Stoebich) [#31257](https://github.com/nodejs/node/pull/31257)
+* [[`38811897c0`](https://github.com/nodejs/node/commit/38811897c0)] - **readline**: improve unicode support and tab completion (Ruben Bridgewater) [#31288](https://github.com/nodejs/node/pull/31288)
+* [[`f0506c3dd2`](https://github.com/nodejs/node/commit/f0506c3dd2)] - **readline**: move charLengthLeft() and charLengthAt() (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`7ba21d0e15`](https://github.com/nodejs/node/commit/7ba21d0e15)] - **readline**: improve getStringWidth() (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`686a3bcf92`](https://github.com/nodejs/node/commit/686a3bcf92)] - **readline,repl**: support tabs properly (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`2e54a9922e`](https://github.com/nodejs/node/commit/2e54a9922e)] - **readline,repl**: improve history up/previous (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`cecd25693f`](https://github.com/nodejs/node/commit/cecd25693f)] - **readline,repl**: skip history entries identical to the current line (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`b6f4e01a0e`](https://github.com/nodejs/node/commit/b6f4e01a0e)] - **readline,repl**: add substring based history search (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`85926d4038`](https://github.com/nodejs/node/commit/85926d4038)] - **repl**: do not preview while pasting code (Ruben Bridgewater) [#31315](https://github.com/nodejs/node/pull/31315)
+* [[`c252356d38`](https://github.com/nodejs/node/commit/c252356d38)] - **repl**: fix preview cursor position (Ruben Bridgewater) [#31293](https://github.com/nodejs/node/pull/31293)
+* [[`b9b044b98e`](https://github.com/nodejs/node/commit/b9b044b98e)] - **repl**: change preview default in case of custom eval functions (Ruben Bridgewater) [#31259](https://github.com/nodejs/node/pull/31259)
+* [[`b92d65dbe7`](https://github.com/nodejs/node/commit/b92d65dbe7)] - **repl**: activate previews for lines exceeding the terminal columns (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`d84c394541`](https://github.com/nodejs/node/commit/d84c394541)] - **repl**: improve preview length calculation (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`f8e805985e`](https://github.com/nodejs/node/commit/f8e805985e)] - **repl,readline**: clean up code (Ruben Bridgewater) [#31288](https://github.com/nodejs/node/pull/31288)
+* [[`83f7b5a8a9`](https://github.com/nodejs/node/commit/83f7b5a8a9)] - **src**: fix performance regression in node\_file.cc (Ben Noordhuis) [#31343](https://github.com/nodejs/node/pull/31343)
+* [[`6534c6c7bd`](https://github.com/nodejs/node/commit/6534c6c7bd)] - **src**: use uv\_guess\_handle() to detect TTYs (cjihrig) [#31333](https://github.com/nodejs/node/pull/31333)
+* [[`06fbc03cbd`](https://github.com/nodejs/node/commit/06fbc03cbd)] - **src**: include uv.h in node\_binding header (Shelley Vohr) [#31265](https://github.com/nodejs/node/pull/31265)
+* [[`e3491d7dd6`](https://github.com/nodejs/node/commit/e3491d7dd6)] - **src**: change GetStringWidth's expand\_emoji\_sequence option default (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`d2a10ad847`](https://github.com/nodejs/node/commit/d2a10ad847)] - **src**: improve GetColumnWidth performance (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`d0a96ab700`](https://github.com/nodejs/node/commit/d0a96ab700)] - **src**: fix -Wbraced-scalar-init warning (cjihrig) [#31254](https://github.com/nodejs/node/pull/31254)
+* [[`60942cc2a7`](https://github.com/nodejs/node/commit/60942cc2a7)] - **src**: add build Github Action (gengjiawen) [#31153](https://github.com/nodejs/node/pull/31153)
+* [[`4259afe583`](https://github.com/nodejs/node/commit/4259afe583)] - **src**: remove node::InitializeV8Platform() (Ben Noordhuis) [#31245](https://github.com/nodejs/node/pull/31245)
+* [[`6050236c3d`](https://github.com/nodejs/node/commit/6050236c3d)] - **src**: remove uses of node::InitializeV8Platform() (Ben Noordhuis) [#31245](https://github.com/nodejs/node/pull/31245)
+* [[`1ad907039d`](https://github.com/nodejs/node/commit/1ad907039d)] - **src**: clean up large\_pages code (Denys Otrishko) [#31196](https://github.com/nodejs/node/pull/31196)
+* [[`499c41d78a`](https://github.com/nodejs/node/commit/499c41d78a)] - **stream**: fix async iterator destroyed error propagation (Robert Nagy) [#31314](https://github.com/nodejs/node/pull/31314)
+* [[`d04118f125`](https://github.com/nodejs/node/commit/d04118f125)] - **stream**: simplify push (Robert Nagy) [#31150](https://github.com/nodejs/node/pull/31150)
+* [[`ff60a0e2b1`](https://github.com/nodejs/node/commit/ff60a0e2b1)] - **stream**: clean up definition using defineProperties (antsmartian) [#31236](https://github.com/nodejs/node/pull/31236)
+* [[`9c98d25506`](https://github.com/nodejs/node/commit/9c98d25506)] - **stream**: replace Function.prototype with primordial (Sebastien Ahkrin) [#31204](https://github.com/nodejs/node/pull/31204)
+* [[`256289fe83`](https://github.com/nodejs/node/commit/256289fe83)] - **stream**: sync stream unpipe resume (Robert Nagy) [#31191](https://github.com/nodejs/node/pull/31191)
+* [[`424408005f`](https://github.com/nodejs/node/commit/424408005f)] - **test**: stricten readline keypress failure test condition (Ruben Bridgewater) [#31300](https://github.com/nodejs/node/pull/31300)
+* [[`1df7961b28`](https://github.com/nodejs/node/commit/1df7961b28)] - **test**: allow disabling crypto tests (Shelley Vohr) [#31268](https://github.com/nodejs/node/pull/31268)
+* [[`3c82d5bed2`](https://github.com/nodejs/node/commit/3c82d5bed2)] - **test**: add repl tests to verify unicode support in previews (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`ca51ff8981`](https://github.com/nodejs/node/commit/ca51ff8981)] - **test**: fix recursive rm test to actually use tmpdir (Denys Otrishko) [#31250](https://github.com/nodejs/node/pull/31250)
+* [[`0b88c3d8ed`](https://github.com/nodejs/node/commit/0b88c3d8ed)] - **test**: check that --insecure-http-parser works (Sam Roberts) [#31253](https://github.com/nodejs/node/pull/31253)
+* [[`69c4f229cb`](https://github.com/nodejs/node/commit/69c4f229cb)] - **test**: remove unused symlink loop (cjihrig) [#31267](https://github.com/nodejs/node/pull/31267)
+* [[`d76deca9cf`](https://github.com/nodejs/node/commit/d76deca9cf)] - **test**: prefer server over srv (Andrew Hughes) [#31224](https://github.com/nodejs/node/pull/31224)
+* [[`f93095de6f`](https://github.com/nodejs/node/commit/f93095de6f)] - **test**: fix unit test logging with python3 (Adam Majer) [#31156](https://github.com/nodejs/node/pull/31156)
+* [[`cbd84c5ee1`](https://github.com/nodejs/node/commit/cbd84c5ee1)] - **test,module**: add test for exports cjs loader check (Rich Trott) [#31427](https://github.com/nodejs/node/pull/31427)
+* [[`5dd6fb1529`](https://github.com/nodejs/node/commit/5dd6fb1529)] - **tools**: remove obsolete dependencies (Rich Trott) [#31359](https://github.com/nodejs/node/pull/31359)
+* [[`29e0465104`](https://github.com/nodejs/node/commit/29e0465104)] - **tools**: update remark-preset-lint-node to 1.12.0 (Rich Trott) [#31359](https://github.com/nodejs/node/pull/31359)
+* [[`49364b0835`](https://github.com/nodejs/node/commit/49364b0835)] - **tools**: update JSON header parsing for backticks (Rich Trott) [#31294](https://github.com/nodejs/node/pull/31294)
+* [[`d48f59224b`](https://github.com/nodejs/node/commit/d48f59224b)] - **tools**: ensure consistent perms of signed release files (Rod Vagg) [#29350](https://github.com/nodejs/node/pull/29350)
+* [[`a5311bd757`](https://github.com/nodejs/node/commit/a5311bd757)] - **tools**: add clang-tidy rule in src (gengjiawen) [#26840](https://github.com/nodejs/node/pull/26840)
+* [[`63f4eaefee`](https://github.com/nodejs/node/commit/63f4eaefee)] - **util**: add todo comments for inspect to add unicode support (Ruben Bridgewater) [#31112](https://github.com/nodejs/node/pull/31112)
+* [[`27564a4837`](https://github.com/nodejs/node/commit/27564a4837)] - **(SEMVER-MINOR)** **vm**: add code cache support for SourceTextModule (Gus Caplan) [#31278](https://github.com/nodejs/node/pull/31278)
+* [[`bdaac04c10`](https://github.com/nodejs/node/commit/bdaac04c10)] - **wasi**: improve use of primordials (cjihrig) [#31212](https://github.com/nodejs/node/pull/31212)
+* [[`66fe92353b`](https://github.com/nodejs/node/commit/66fe92353b)] - **win**: change to use Python in install tool (gengjiawen) [#31221](https://github.com/nodejs/node/pull/31221)
+
+<a id="13.6.0"></a>
+## 2020-01-07, Version 13.6.0 (Current), @BridgeAR
+
+### Notable Changes
+
+* **assert**:
+  * Implement `assert.match()` and `assert.doesNotMatch()` (Ruben Bridgewater) [#30929](https://github.com/nodejs/node/pull/30929)
+* **events**:
+  * Add `EventEmitter.on` to async iterate over events (Matteo Collina) [#27994](https://github.com/nodejs/node/pull/27994)
+  * Allow monitoring error events (Gerhard Stoebich) [#30932](https://github.com/nodejs/node/pull/30932)
+* **fs**:
+  * Allow overriding `fs` for streams (Robert Nagy) [#29083](https://github.com/nodejs/node/pull/29083)
+* **perf_hooks**:
+  * Move `perf_hooks` out of experimental (legendecas) [#31101](https://github.com/nodejs/node/pull/31101)
+* **repl**:
+  * Implement ZSH-like reverse-i-search (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
+* **tls**:
+  * Add PSK (pre-shared key) support (Denys Otrishko) [#23188](https://github.com/nodejs/node/pull/23188)
+
+### Commits
+
+* [[`d831dc1b77`](https://github.com/nodejs/node/commit/d831dc1b77)] - **(SEMVER-MINOR)** **assert**: implement `assert.match()` and `assert.doesNotMatch()` (Ruben Bridgewater) [#30929](https://github.com/nodejs/node/pull/30929)
+* [[`f8aa365508`](https://github.com/nodejs/node/commit/f8aa365508)] - **assert**: use for...of (Soar) [#30983](https://github.com/nodejs/node/pull/30983)
+* [[`5fccb508e9`](https://github.com/nodejs/node/commit/5fccb508e9)] - **benchmark**: use let instead of var in dgram (dnlup) [#31175](https://github.com/nodejs/node/pull/31175)
+* [[`827d3fea0e`](https://github.com/nodejs/node/commit/827d3fea0e)] - **benchmark**: add benchmark on async\_hooks enabled http server (legendecas) [#31100](https://github.com/nodejs/node/pull/31100)
+* [[`b193142e0a`](https://github.com/nodejs/node/commit/b193142e0a)] - **benchmark**: use let instead of var in crypto (dnlup) [#31135](https://github.com/nodejs/node/pull/31135)
+* [[`b8ccf30ac1`](https://github.com/nodejs/node/commit/b8ccf30ac1)] - **benchmark**: replace var with let/const in cluster benchmark (dnlup) [#31042](https://github.com/nodejs/node/pull/31042)
+* [[`01fd3be84a`](https://github.com/nodejs/node/commit/01fd3be84a)] - **benchmark**: include writev in benchmark (Robert Nagy) [#31066](https://github.com/nodejs/node/pull/31066)
+* [[`ca53f02767`](https://github.com/nodejs/node/commit/ca53f02767)] - **benchmark**: use let instead of var in child\_process (dnlup) [#31043](https://github.com/nodejs/node/pull/31043)
+* [[`625744d292`](https://github.com/nodejs/node/commit/625744d292)] - **benchmark**: add clear connections to secure-pair (Diego Lafuente) [#27971](https://github.com/nodejs/node/pull/27971)
+* [[`0e864a383c`](https://github.com/nodejs/node/commit/0e864a383c)] - **benchmark**: update manywrites back pressure (Robert Nagy) [#30977](https://github.com/nodejs/node/pull/30977)
+* [[`37ffa8c2ae`](https://github.com/nodejs/node/commit/37ffa8c2ae)] - **bootstrap**: use different scripts to setup different configurations (Joyee Cheung) [#30862](https://github.com/nodejs/node/pull/30862)
+* [[`4df365256f`](https://github.com/nodejs/node/commit/4df365256f)] - **buffer**: improve .from() error details (Ruben Bridgewater) [#29675](https://github.com/nodejs/node/pull/29675)
+* [[`9b7cf090c7`](https://github.com/nodejs/node/commit/9b7cf090c7)] - **build**: don't use -latomic on macOS (Ryan Schmidt) [#30099](https://github.com/nodejs/node/pull/30099)
+* [[`d2ab877b72`](https://github.com/nodejs/node/commit/d2ab877b72)] - **build**: warn upon --use-largepages config option (Gabriel Schulhof) [#31103](https://github.com/nodejs/node/pull/31103)
+* [[`ca05a5bb64`](https://github.com/nodejs/node/commit/ca05a5bb64)] - **build**: switch realpath to pwd (bcoe) [#31095](https://github.com/nodejs/node/pull/31095)
+* [[`d131877398`](https://github.com/nodejs/node/commit/d131877398)] - **build**: fixes build for some os versions (David Carlier)
+* [[`baf8730a47`](https://github.com/nodejs/node/commit/baf8730a47)] - **build**: re-introduce --use-largepages as no-op (Gabriel Schulhof)
+* [[`ca235112ae`](https://github.com/nodejs/node/commit/ca235112ae)] - **deps**: V8: backport a4545db (David Carlier) [#31127](https://github.com/nodejs/node/pull/31127)
+* [[`e2ef1a9e63`](https://github.com/nodejs/node/commit/e2ef1a9e63)] - **deps**: V8: bump v8\_embedder\_string for 0e21c1e637bf (Сковорода Никита Андреевич) [#31096](https://github.com/nodejs/node/pull/31096)
+* [[`2ec817e02d`](https://github.com/nodejs/node/commit/2ec817e02d)] - **deps**: uvwasi: cherry-pick 75b389c (cjihrig) [#31076](https://github.com/nodejs/node/pull/31076)
+* [[`a5937c7b6c`](https://github.com/nodejs/node/commit/a5937c7b6c)] - **deps**: uvwasi: cherry-pick 64e59d5 (cjihrig) [#31076](https://github.com/nodejs/node/pull/31076)
+* [[`647f3c7639`](https://github.com/nodejs/node/commit/647f3c7639)] - **deps**: V8: cherry-pick 687d865fe251 (Сковорода Никита Андреевич) [#31007](https://github.com/nodejs/node/pull/31007)
+* [[`7fe8399e08`](https://github.com/nodejs/node/commit/7fe8399e08)] - **deps**: V8: cherry-pick d406bfd64653 (Sam Roberts) [#30819](https://github.com/nodejs/node/pull/30819)
+* [[`7e13ae7757`](https://github.com/nodejs/node/commit/7e13ae7757)] - **deps**: V8: cherry-pick d3a1a5b6c491 (Michaël Zasso) [#31005](https://github.com/nodejs/node/pull/31005)
+* [[`32805a9525`](https://github.com/nodejs/node/commit/32805a9525)] - **deps,src,test**: update to uvwasi 0.0.3 (cjihrig) [#30980](https://github.com/nodejs/node/pull/30980)
+* [[`44d03e81d4`](https://github.com/nodejs/node/commit/44d03e81d4)] - **dgram**: test to add and to drop specific membership (A. Volgin) [#31047](https://github.com/nodejs/node/pull/31047)
+* [[`21ef3d615e`](https://github.com/nodejs/node/commit/21ef3d615e)] - **dgram**: use for...of (Trivikram Kamat) [#30999](https://github.com/nodejs/node/pull/30999)
+* [[`7b696fe9f4`](https://github.com/nodejs/node/commit/7b696fe9f4)] - **doc**: remove extra backtick (cjihrig) [#31186](https://github.com/nodejs/node/pull/31186)
+* [[`dba2ab75d9`](https://github.com/nodejs/node/commit/dba2ab75d9)] - **doc**: use code markup/markdown in headers (Ruben Bridgewater) [#31149](https://github.com/nodejs/node/pull/31149)
+* [[`cc44325eed`](https://github.com/nodejs/node/commit/cc44325eed)] - **doc**: update REPL documentation to instantiate the REPL (Ruben Bridgewater) [#30928](https://github.com/nodejs/node/pull/30928)
+* [[`d3a8088cd5`](https://github.com/nodejs/node/commit/d3a8088cd5)] - **doc**: improve explanation of package.json "type" field (Ronald J Kimball) [#27516](https://github.com/nodejs/node/pull/27516)
+* [[`33352c2433`](https://github.com/nodejs/node/commit/33352c2433)] - **doc**: clarify role of writable.cork() (Colin Grant) [#30442](https://github.com/nodejs/node/pull/30442)
+* [[`b657a64b77`](https://github.com/nodejs/node/commit/b657a64b77)] - **doc**: de-duplicate security release processes (Sam Roberts) [#30996](https://github.com/nodejs/node/pull/30996)
+* [[`18b34def41`](https://github.com/nodejs/node/commit/18b34def41)] - **doc**: fix createDiffieHellman generator type (Tobias Nießen) [#31121](https://github.com/nodejs/node/pull/31121)
+* [[`1fa8e49f7e`](https://github.com/nodejs/node/commit/1fa8e49f7e)] - **doc**: update mode type for mkdir() functions (cjihrig) [#31115](https://github.com/nodejs/node/pull/31115)
+* [[`a37a88f40d`](https://github.com/nodejs/node/commit/a37a88f40d)] - **doc**: update mode type for process.umask() (cjihrig) [#31115](https://github.com/nodejs/node/pull/31115)
+* [[`2313b9e33b`](https://github.com/nodejs/node/commit/2313b9e33b)] - **doc**: update mode type for fs open() functions (cjihrig) [#31115](https://github.com/nodejs/node/pull/31115)
+* [[`53c6a1ee34`](https://github.com/nodejs/node/commit/53c6a1ee34)] - **doc**: update mode type for fchmod() functions (cjihrig) [#31115](https://github.com/nodejs/node/pull/31115)
+* [[`68557889d3`](https://github.com/nodejs/node/commit/68557889d3)] - **doc**: update parameter type for fsPromises.chmod() (cjihrig) [#31115](https://github.com/nodejs/node/pull/31115)
+* [[`72d70d5102`](https://github.com/nodejs/node/commit/72d70d5102)] - **doc**: improve dns introduction (Rich Trott) [#31090](https://github.com/nodejs/node/pull/31090)
+* [[`4c29a6ee15`](https://github.com/nodejs/node/commit/4c29a6ee15)] - **doc**: update parameter type for fs.chmod() (Santosh Yadav) [#31085](https://github.com/nodejs/node/pull/31085)
+* [[`dcce8b68b2`](https://github.com/nodejs/node/commit/dcce8b68b2)] - **doc**: use code markup/markdown in headers in globals documentation (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`7afe69cee0`](https://github.com/nodejs/node/commit/7afe69cee0)] - **doc**: use code markup/markdown in headers in deprecations documentation (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`ff828900f6`](https://github.com/nodejs/node/commit/ff828900f6)] - **doc**: use code markup/markdown in headers in addons documentation (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`ce60a80944`](https://github.com/nodejs/node/commit/ce60a80944)] - **doc**: allow \<code\> in header elements (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`1033760874`](https://github.com/nodejs/node/commit/1033760874)] - **doc**: add --inspect-publish-uid man page entry (cjihrig) [#31077](https://github.com/nodejs/node/pull/31077)
+* [[`23013e3e31`](https://github.com/nodejs/node/commit/23013e3e31)] - **doc**: add --force-context-aware man page entry (cjihrig) [#31077](https://github.com/nodejs/node/pull/31077)
+* [[`efc97fd927`](https://github.com/nodejs/node/commit/efc97fd927)] - **doc**: add --enable-source-maps man page entry (cjihrig) [#31077](https://github.com/nodejs/node/pull/31077)
+* [[`4292f64c27`](https://github.com/nodejs/node/commit/4292f64c27)] - **doc**: fix anchors and subtitle in BUILDING.md (sutangu) [#30296](https://github.com/nodejs/node/pull/30296)
+* [[`1357c97a70`](https://github.com/nodejs/node/commit/1357c97a70)] - **doc**: standardize usage of hostname vs. host name (Rich Trott) [#31073](https://github.com/nodejs/node/pull/31073)
+* [[`4caf4578fe`](https://github.com/nodejs/node/commit/4caf4578fe)] - **doc**: add unrepresented flags docs for configure (Pranshu Srivastava) [#28069](https://github.com/nodejs/node/pull/28069)
+* [[`9141366e09`](https://github.com/nodejs/node/commit/9141366e09)] - **doc**: improve doc net:server.listen (dev-313) [#31064](https://github.com/nodejs/node/pull/31064)
+* [[`69d6e9732b`](https://github.com/nodejs/node/commit/69d6e9732b)] - **doc**: implement minor improvements to BUILDING.md text (Rich Trott) [#31070](https://github.com/nodejs/node/pull/31070)
+* [[`a7988ab0fa`](https://github.com/nodejs/node/commit/a7988ab0fa)] - **doc**: avoid using v8::Persistent in addon docs (Anna Henningsen) [#31018](https://github.com/nodejs/node/pull/31018)
+* [[`a3861147e5`](https://github.com/nodejs/node/commit/a3861147e5)] - **doc**: clarify required flag for extensionless esm (Lucas Azzola) [#30657](https://github.com/nodejs/node/pull/30657)
+* [[`cc8c0b4cde`](https://github.com/nodejs/node/commit/cc8c0b4cde)] - **doc**: reference worker threads on signal events (legendecas) [#30990](https://github.com/nodejs/node/pull/30990)
+* [[`7815d5f2cb`](https://github.com/nodejs/node/commit/7815d5f2cb)] - **doc**: update message.url example in http.IncomingMessage (Tadao Iseki) [#30830](https://github.com/nodejs/node/pull/30830)
+* [[`118df63d9f`](https://github.com/nodejs/node/commit/118df63d9f)] - **doc,assert**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`32e5895a2f`](https://github.com/nodejs/node/commit/32e5895a2f)] - **doc,async_hooks**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`0e0d45b02f`](https://github.com/nodejs/node/commit/0e0d45b02f)] - **doc,buffer**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`405bf8c8bb`](https://github.com/nodejs/node/commit/405bf8c8bb)] - **doc,child_process**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`27790fc76e`](https://github.com/nodejs/node/commit/27790fc76e)] - **doc,cluster**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`f8a6edaac6`](https://github.com/nodejs/node/commit/f8a6edaac6)] - **doc,console**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`df5ec4e7b1`](https://github.com/nodejs/node/commit/df5ec4e7b1)] - **doc,crypto**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`4a42230fd7`](https://github.com/nodejs/node/commit/4a42230fd7)] - **doc,dgram**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`9979f82716`](https://github.com/nodejs/node/commit/9979f82716)] - **doc,dns**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`decfcaf89e`](https://github.com/nodejs/node/commit/decfcaf89e)] - **doc,domain**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`665a662ad1`](https://github.com/nodejs/node/commit/665a662ad1)] - **doc,errors**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`fbb217a29d`](https://github.com/nodejs/node/commit/fbb217a29d)] - **doc,esm**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`db01d0f947`](https://github.com/nodejs/node/commit/db01d0f947)] - **doc,events**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`e7f7e45ddb`](https://github.com/nodejs/node/commit/e7f7e45ddb)] - **doc,fs**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`cdb79fc106`](https://github.com/nodejs/node/commit/cdb79fc106)] - **doc,http**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`3062bcb13c`](https://github.com/nodejs/node/commit/3062bcb13c)] - **doc,http2**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`3571df3115`](https://github.com/nodejs/node/commit/3571df3115)] - **doc,https**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`699b31f8fe`](https://github.com/nodejs/node/commit/699b31f8fe)] - **doc,inspector**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`d6f942003b`](https://github.com/nodejs/node/commit/d6f942003b)] - **doc,lib,src,test**: rename WASI CLI flag (cjihrig) [#30980](https://github.com/nodejs/node/pull/30980)
+* [[`7d25e44bc1`](https://github.com/nodejs/node/commit/7d25e44bc1)] - **doc,module**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`927b37f5a3`](https://github.com/nodejs/node/commit/927b37f5a3)] - **doc,net**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`9de914687d`](https://github.com/nodejs/node/commit/9de914687d)] - **doc,os**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`5921654eca`](https://github.com/nodejs/node/commit/5921654eca)] - **doc,path**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`3ee3e6f5ff`](https://github.com/nodejs/node/commit/3ee3e6f5ff)] - **doc,perf_hooks**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`8c126527d9`](https://github.com/nodejs/node/commit/8c126527d9)] - **doc,process**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`f0bc62896a`](https://github.com/nodejs/node/commit/f0bc62896a)] - **doc,punycode**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`125a59a0b0`](https://github.com/nodejs/node/commit/125a59a0b0)] - **doc,querystring**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`128a69dde3`](https://github.com/nodejs/node/commit/128a69dde3)] - **doc,readline**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`38e09f8d17`](https://github.com/nodejs/node/commit/38e09f8d17)] - **doc,repl**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`4c5a9854ec`](https://github.com/nodejs/node/commit/4c5a9854ec)] - **doc,stream**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`cf563bbd7f`](https://github.com/nodejs/node/commit/cf563bbd7f)] - **doc,string_decoder**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`450d9a27bf`](https://github.com/nodejs/node/commit/450d9a27bf)] - **doc,timers**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`d6d507aa6c`](https://github.com/nodejs/node/commit/d6d507aa6c)] - **doc,tls**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`9d2082be94`](https://github.com/nodejs/node/commit/9d2082be94)] - **doc,tty**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`73c598a905`](https://github.com/nodejs/node/commit/73c598a905)] - **doc,url**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`4672e106c1`](https://github.com/nodejs/node/commit/4672e106c1)] - **doc,util**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`342d3372ef`](https://github.com/nodejs/node/commit/342d3372ef)] - **doc,v8**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`e6fbde53b3`](https://github.com/nodejs/node/commit/e6fbde53b3)] - **doc,vm**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`796a9c0f43`](https://github.com/nodejs/node/commit/796a9c0f43)] - **doc,vm,test**: remove \_sandbox\_ from vm documentation (Rich Trott) [#31057](https://github.com/nodejs/node/pull/31057)
+* [[`1bcc07b758`](https://github.com/nodejs/node/commit/1bcc07b758)] - **doc,wasi**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`cb3c3fcb3f`](https://github.com/nodejs/node/commit/cb3c3fcb3f)] - **doc,worker**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`a6f16b3e78`](https://github.com/nodejs/node/commit/a6f16b3e78)] - **doc,zlib**: use code markup/markdown in headers (Rich Trott) [#31086](https://github.com/nodejs/node/pull/31086)
+* [[`1057a4cdf2`](https://github.com/nodejs/node/commit/1057a4cdf2)] - **errors**: support prepareSourceMap with source-maps (bcoe) [#31143](https://github.com/nodejs/node/pull/31143)
+* [[`33c5dbe197`](https://github.com/nodejs/node/commit/33c5dbe197)] - **errors**: improve ERR\_INVALID\_ARG\_TYPE (Ruben Bridgewater) [#29675](https://github.com/nodejs/node/pull/29675)
+* [[`a6c2502686`](https://github.com/nodejs/node/commit/a6c2502686)] - **esm**: better error message for unsupported URL (Thomas) [#31129](https://github.com/nodejs/node/pull/31129)
+* [[`24a021216d`](https://github.com/nodejs/node/commit/24a021216d)] - **esm**: empty ext from pkg type/main doesnt affect format (Bradley Farias) [#31021](https://github.com/nodejs/node/pull/31021)
+* [[`afecc973d5`](https://github.com/nodejs/node/commit/afecc973d5)] - **(SEMVER-MINOR)** **events**: add EventEmitter.on to async iterate over events (Matteo Collina) [#27994](https://github.com/nodejs/node/pull/27994)
+* [[`f570de8ea9`](https://github.com/nodejs/node/commit/f570de8ea9)] - **(SEMVER-MINOR)** **events**: allow monitoring error events (Gerhard Stoebich) [#30932](https://github.com/nodejs/node/pull/30932)
+* [[`4f32bbb816`](https://github.com/nodejs/node/commit/4f32bbb816)] - **fs**: use consistent defaults in sync stat functions (cjihrig) [#31097](https://github.com/nodejs/node/pull/31097)
+* [[`7f6a0ed548`](https://github.com/nodejs/node/commit/7f6a0ed548)] - **(SEMVER-MINOR)** **fs**: allow overriding fs for streams (Robert Nagy) [#29083](https://github.com/nodejs/node/pull/29083)
+* [[`4a54f304a7`](https://github.com/nodejs/node/commit/4a54f304a7)] - **http**: http\_outgoing rename var to let and const (telenord) [#30284](https://github.com/nodejs/node/pull/30284)
+* [[`1b720aa802`](https://github.com/nodejs/node/commit/1b720aa802)] - **http**: free listeners on free sockets (Robert Nagy) [#29259](https://github.com/nodejs/node/pull/29259)
+* [[`b5a71a439d`](https://github.com/nodejs/node/commit/b5a71a439d)] - **http2**: set default enableConnectProtocol to 0 (ZYSzys) [#31174](https://github.com/nodejs/node/pull/31174)
+* [[`b9160351ec`](https://github.com/nodejs/node/commit/b9160351ec)] - **http2**: make HTTP2ServerResponse more streams compliant (Robert Nagy) [#30964](https://github.com/nodejs/node/pull/30964)
+* [[`ba0682e91c`](https://github.com/nodejs/node/commit/ba0682e91c)] - **http2**: wait for session socket writable end on close/destroy (Denys Otrishko) [#30854](https://github.com/nodejs/node/pull/30854)
+* [[`86f2e869dc`](https://github.com/nodejs/node/commit/86f2e869dc)] - **http2**: wait for session to finish writing before destroy (Denys Otrishko) [#30854](https://github.com/nodejs/node/pull/30854)
+* [[`18acaccf0a`](https://github.com/nodejs/node/commit/18acaccf0a)] - **https**: prevent options object from being mutated (Vighnesh Raut) [#31151](https://github.com/nodejs/node/pull/31151)
+* [[`42d36dca90`](https://github.com/nodejs/node/commit/42d36dca90)] - **lib**: move initialization of APIs for changing process state (Anna Henningsen) [#31172](https://github.com/nodejs/node/pull/31172)
+* [[`20ecb5dcfb`](https://github.com/nodejs/node/commit/20ecb5dcfb)] - **lib**: replace Map global by the primordials (Sebastien Ahkrin) [#31155](https://github.com/nodejs/node/pull/31155)
+* [[`f268621ffa`](https://github.com/nodejs/node/commit/f268621ffa)] - **lib**: replace use of Error with primordials (Sebastien Ahkrin) [#31163](https://github.com/nodejs/node/pull/31163)
+* [[`3f21ad67f8`](https://github.com/nodejs/node/commit/3f21ad67f8)] - **lib**: replace Set global by the primordials (Sebastien Ahkrin) [#31154](https://github.com/nodejs/node/pull/31154)
+* [[`542aae4bf0`](https://github.com/nodejs/node/commit/542aae4bf0)] - **lib**: replace WeakSet global by the primordials (Sebastien Ahkrin) [#31157](https://github.com/nodejs/node/pull/31157)
+* [[`0b8eaf2e5c`](https://github.com/nodejs/node/commit/0b8eaf2e5c)] - **lib**: replace WeakMap global by the primordials (Sebastien Ahkrin) [#31158](https://github.com/nodejs/node/pull/31158)
+* [[`1527796661`](https://github.com/nodejs/node/commit/1527796661)] - **lib**: replace Set.prototype with SetPrototype primordial (Sebastien Ahkrin) [#31161](https://github.com/nodejs/node/pull/31161)
+* [[`4b2d8df5b5`](https://github.com/nodejs/node/commit/4b2d8df5b5)] - **lib**: do not catch user errors (Ruben Bridgewater) [#31159](https://github.com/nodejs/node/pull/31159)
+* [[`97ce0a3b47`](https://github.com/nodejs/node/commit/97ce0a3b47)] - **lib**: replace var with let/const (kresimirfranin) [#30394](https://github.com/nodejs/node/pull/30394)
+* [[`614b2c58f0`](https://github.com/nodejs/node/commit/614b2c58f0)] - **lib**: further simplify assertions in vm/module (Anna Henningsen) [#30815](https://github.com/nodejs/node/pull/30815)
+* [[`a83d338102`](https://github.com/nodejs/node/commit/a83d338102)] - **lib**: improve spelling and grammar in comment (David Newman) [#31026](https://github.com/nodejs/node/pull/31026)
+* [[`799b50934b`](https://github.com/nodejs/node/commit/799b50934b)] - **meta**: clarify scope of new nodejs.org issue choice (Derek Lewis) [#31123](https://github.com/nodejs/node/pull/31123)
+* [[`72c64605c9`](https://github.com/nodejs/node/commit/72c64605c9)] - **module**: unflag resolve self (Guy Bedford) [#31002](https://github.com/nodejs/node/pull/31002)
+* [[`bd047e8277`](https://github.com/nodejs/node/commit/bd047e8277)] - **module**: self resolve bug fix and esm ordering (Guy Bedford) [#31009](https://github.com/nodejs/node/pull/31009)
+* [[`d7712213a4`](https://github.com/nodejs/node/commit/d7712213a4)] - **n-api**: keep napi\_env alive while it has finalizers (Anna Henningsen) [#31140](https://github.com/nodejs/node/pull/31140)
+* [[`ae58c9709b`](https://github.com/nodejs/node/commit/ae58c9709b)] - **perf_hooks**: use for...of (Kamat, Trivikram) [#31049](https://github.com/nodejs/node/pull/31049)
+* [[`dcbb97e2c3`](https://github.com/nodejs/node/commit/dcbb97e2c3)] - **(SEMVER-MINOR)** **perf_hooks**: move perf\_hooks out of experimental (legendecas) [#31101](https://github.com/nodejs/node/pull/31101)
+* [[`ffbf790358`](https://github.com/nodejs/node/commit/ffbf790358)] - **(SEMVER-MINOR)** **readline**: set null as callback return in case there's no error (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
+* [[`92dcf3e4ae`](https://github.com/nodejs/node/commit/92dcf3e4ae)] - **(SEMVER-MINOR)** **readline**: small refactoring (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
+* [[`0999d53df0`](https://github.com/nodejs/node/commit/0999d53df0)] - **repl**: use public getCursorPos() (cjihrig) [#31091](https://github.com/nodejs/node/pull/31091)
+* [[`09ca8be1f2`](https://github.com/nodejs/node/commit/09ca8be1f2)] - **(SEMVER-MINOR)** **repl**: implement reverse search (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
+* [[`925dd8e7f9`](https://github.com/nodejs/node/commit/925dd8e7f9)] - **(SEMVER-MINOR)** **repl**: fix preview of lines that exceed the terminal columns (Ruben Bridgewater) [#31006](https://github.com/nodejs/node/pull/31006)
+* [[`892e7b0d7f`](https://github.com/nodejs/node/commit/892e7b0d7f)] - **src**: suppress warning in src/node\_env\_var.cc (Harshitha KP) [#31136](https://github.com/nodejs/node/pull/31136)
+* [[`2c6f81730b`](https://github.com/nodejs/node/commit/2c6f81730b)] - **src**: make large\_pages node.cc include conditional (Denys Otrishko) [#31078](https://github.com/nodejs/node/pull/31078)
+* [[`54caadc6ef`](https://github.com/nodejs/node/commit/54caadc6ef)] - **src**: enable stack trace printing for V8 check failures (Anna Henningsen) [#31079](https://github.com/nodejs/node/pull/31079)
+* [[`60dd1838e9`](https://github.com/nodejs/node/commit/60dd1838e9)] - **src**: prevent hard coding stack trace limit (legendecas) [#30752](https://github.com/nodejs/node/pull/30752)
+* [[`80732cdf9c`](https://github.com/nodejs/node/commit/80732cdf9c)] - **src**: port --bash-completion to C++ (Joyee Cheung) [#25901](https://github.com/nodejs/node/pull/25901)
+* [[`49a7e73898`](https://github.com/nodejs/node/commit/49a7e73898)] - **src**: make --use-largepages a runtime option (Gabriel Schulhof) [#30954](https://github.com/nodejs/node/pull/30954)
+* [[`6b65cafacf`](https://github.com/nodejs/node/commit/6b65cafacf)] - **src**: list used functions on headers (Juan José Arboleda) [#30827](https://github.com/nodejs/node/pull/30827)
+* [[`e5a41552e6`](https://github.com/nodejs/node/commit/e5a41552e6)] - **src**: fix compiler warning in env.cc (Anna Henningsen) [#31020](https://github.com/nodejs/node/pull/31020)
+* [[`a27edd8335`](https://github.com/nodejs/node/commit/a27edd8335)] - **src,test**: use v8::Global instead of v8::Persistent (Anna Henningsen) [#31018](https://github.com/nodejs/node/pull/31018)
+* [[`5bf27729dd`](https://github.com/nodejs/node/commit/5bf27729dd)] - **stream**: group all properties using defineProperties (antsmartian) [#31144](https://github.com/nodejs/node/pull/31144)
+* [[`ca22ce2698`](https://github.com/nodejs/node/commit/ca22ce2698)] - **stream**: pipeline should use req.abort() to destroy response (Robert Nagy) [#31054](https://github.com/nodejs/node/pull/31054)
+* [[`bca23b9e16`](https://github.com/nodejs/node/commit/bca23b9e16)] - **stream**: reset flowing state if no 'readable' or 'data' listeners (Robert Nagy) [#31036](https://github.com/nodejs/node/pull/31036)
+* [[`146321410c`](https://github.com/nodejs/node/commit/146321410c)] - **stream**: simplify isBuf (Robert Nagy) [#31067](https://github.com/nodejs/node/pull/31067)
+* [[`21d96645db`](https://github.com/nodejs/node/commit/21d96645db)] - **test**: change buffer offset to accommodate V8 BackingStore (Thang Tran) [#31171](https://github.com/nodejs/node/pull/31171)
+* [[`bd6a29c60b`](https://github.com/nodejs/node/commit/bd6a29c60b)] - **test**: use spread object (Fran Herrero) [#30423](https://github.com/nodejs/node/pull/30423)
+* [[`efa0bd8e25`](https://github.com/nodejs/node/commit/efa0bd8e25)] - **test**: refactor common.expectsError (Ruben Bridgewater) [#31092](https://github.com/nodejs/node/pull/31092)
+* [[`16f60cedb3`](https://github.com/nodejs/node/commit/16f60cedb3)] - **test**: increase coverage for \_http\_incoming.js (Rich Trott) [#31093](https://github.com/nodejs/node/pull/31093)
+* [[`990760e57f`](https://github.com/nodejs/node/commit/990760e57f)] - **test**: log errors in test-http2-propagate-session-destroy-code (Denys Otrishko) [#31072](https://github.com/nodejs/node/pull/31072)
+* [[`e28e873fb6`](https://github.com/nodejs/node/commit/e28e873fb6)] - **test**: skip the unsupported test cases for IBM i (Xu Meng) [#30819](https://github.com/nodejs/node/pull/30819)
+* [[`07e82db764`](https://github.com/nodejs/node/commit/07e82db764)] - **test**: get lib/wasi.js coverage to 100% (cjihrig) [#31039](https://github.com/nodejs/node/pull/31039)
+* [[`e5980a106c`](https://github.com/nodejs/node/commit/e5980a106c)] - **test**: cover vm with negative tests (Andrew Kuzmenko) [#31028](https://github.com/nodejs/node/pull/31028)
+* [[`3c9e435f56`](https://github.com/nodejs/node/commit/3c9e435f56)] - **test**: unflake async hooks statwatcher test (Denys Otrishko) [#30362](https://github.com/nodejs/node/pull/30362)
+* [[`dadccb7761`](https://github.com/nodejs/node/commit/dadccb7761)] - **test**: fix common.enoughTestMem (Rich Trott) [#31035](https://github.com/nodejs/node/pull/31035)
+* [[`93cf1231db`](https://github.com/nodejs/node/commit/93cf1231db)] - **test**: fix long lines (cjihrig) [#31014](https://github.com/nodejs/node/pull/31014)
+* [[`54c471a3bf`](https://github.com/nodejs/node/commit/54c471a3bf)] - **test**: fix flaky test-http2-client-upload (Gerhard Stoebich) [#29889](https://github.com/nodejs/node/pull/29889)
+* [[`3753f47677`](https://github.com/nodejs/node/commit/3753f47677)] - **test**: use tmpdir.refresh() in test-esm-windows.js (Richard Lau) [#30997](https://github.com/nodejs/node/pull/30997)
+* [[`d36ae62bd7`](https://github.com/nodejs/node/commit/d36ae62bd7)] - **test**: remove obsolete WASI test (cjihrig) [#30980](https://github.com/nodejs/node/pull/30980)
+* [[`fe4f55ee13`](https://github.com/nodejs/node/commit/fe4f55ee13)] - **timers**: fix refresh for expired timers (Anatoli Papirovski) [#27345](https://github.com/nodejs/node/pull/27345)
+* [[`83330a00a0`](https://github.com/nodejs/node/commit/83330a00a0)] - **timers**: do less work in insert (Anatoli Papirovski) [#27345](https://github.com/nodejs/node/pull/27345)
+* [[`7b2bf20f7e`](https://github.com/nodejs/node/commit/7b2bf20f7e)] - **(SEMVER-MINOR)** **tls**: add PSK support (Denys Otrishko) [#23188](https://github.com/nodejs/node/pull/23188)
+* [[`c23bbc6fe2`](https://github.com/nodejs/node/commit/c23bbc6fe2)] - **tools**: remove prefer-common-expectserror lint rule (cjihrig) [#31147](https://github.com/nodejs/node/pull/31147)
+* [[`85d152fccf`](https://github.com/nodejs/node/commit/85d152fccf)] - **tools**: allow the travis commit message job to fail (Ruben Bridgewater) [#31116](https://github.com/nodejs/node/pull/31116)
+* [[`048b7f469c`](https://github.com/nodejs/node/commit/048b7f469c)] - **tools**: fix Raspbian armv7 build (Andrey Hohutkin) [#31041](https://github.com/nodejs/node/pull/31041)
+* [[`c779421f41`](https://github.com/nodejs/node/commit/c779421f41)] - **tools**: update ESLint to 6.8.0 (cjihrig) [#31044](https://github.com/nodejs/node/pull/31044)
+* [[`28a62c30be`](https://github.com/nodejs/node/commit/28a62c30be)] - **tools,src**: forbid usage of v8::Persistent (Anna Henningsen) [#31018](https://github.com/nodejs/node/pull/31018)
+* [[`697908e8d9`](https://github.com/nodejs/node/commit/697908e8d9)] - **util**: improve prototype inspection using `inspect()` and `showHidden` (Ruben Bridgewater) [#31113](https://github.com/nodejs/node/pull/31113)
+* [[`a6998085d2`](https://github.com/nodejs/node/commit/a6998085d2)] - **util**: add (typed) array length to the default output (Ruben Bridgewater) [#31027](https://github.com/nodejs/node/pull/31027)
+* [[`7611d5b47b`](https://github.com/nodejs/node/commit/7611d5b47b)] - **util**: add colors to debuglog() (Ruben Bridgewater) [#30930](https://github.com/nodejs/node/pull/30930)
+* [[`614b074f3b`](https://github.com/nodejs/node/commit/614b074f3b)] - **wasi**: refactor destructuring object on constructor (himself65) [#31185](https://github.com/nodejs/node/pull/31185)
+* [[`8491e1c3c6`](https://github.com/nodejs/node/commit/8491e1c3c6)] - **wasi**: fix serdes bugs from snapshot1 migration (cjihrig) [#31122](https://github.com/nodejs/node/pull/31122)
+* [[`87f15c03bc`](https://github.com/nodejs/node/commit/87f15c03bc)] - **wasi**: throw on failed uvwasi\_init() (cjihrig) [#31076](https://github.com/nodejs/node/pull/31076)
+* [[`10f7169d58`](https://github.com/nodejs/node/commit/10f7169d58)] - **zlib**: use for...of (Kamat, Trivikram) [#31051](https://github.com/nodejs/node/pull/31051)
+* [[`31bbae7c92`](https://github.com/nodejs/node/commit/31bbae7c92)] - **zlib**: allow writes after readable 'end' to finish (Anna Henningsen) [#31082](https://github.com/nodejs/node/pull/31082)
+
+<a id="13.5.0"></a>
+## 2019-12-18, Version 13.5.0 (Current), @MylesBorins
+
+### Notable Changes
+
+* **cli**:
+  * add --trace-exit cli option (legendecas) [#30516](https://github.com/nodejs/node/pull/30516)
+* **http,https**:
+  * increase server headers timeout (Tim Costa) [#30071](https://github.com/nodejs/node/pull/30071)
+* **readline**:
+  * update ansi-regex (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+  * promote \_getCursorPos to public api (Jeremy Albright) [#30687](https://github.com/nodejs/node/pull/30687)
+* **repl**:
+  * add completion preview (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* **util**:
+  * add Set and map size to inspect output (Ruben Bridgewater) [#30225](https://github.com/nodejs/node/pull/30225)
+* **wasi**:
+  * require CLI flag to require() wasi module (Colin Ihrig) [#30963](https://github.com/nodejs/node/pull/30963)
+
+### Commits
+
+* [[`e10917f8ba`](https://github.com/nodejs/node/commit/e10917f8ba)] - **async_hooks**: ensure proper handling in runInAsyncScope (Anatoli Papirovski) [#30965](https://github.com/nodejs/node/pull/30965)
+* [[`b6ddbc1291`](https://github.com/nodejs/node/commit/b6ddbc1291)] - **benchmark**: use let/const instead of var in buffers (dnlup) [#30945](https://github.com/nodejs/node/pull/30945)
+* [[`00cbf5b1b6`](https://github.com/nodejs/node/commit/00cbf5b1b6)] - **build**: auto-load ICU data from --with-icu-default-data-dir (Stephen Gallagher) [#30825](https://github.com/nodejs/node/pull/30825)
+* [[`60225c171e`](https://github.com/nodejs/node/commit/60225c171e)] - **build**: fix missing x64 arch suffix in binary tar name (legendecas) [#30877](https://github.com/nodejs/node/pull/30877)
+* [[`10a77d3cd1`](https://github.com/nodejs/node/commit/10a77d3cd1)] - **build,win**: fix goto exit in vcbuild (João Reis) [#30931](https://github.com/nodejs/node/pull/30931)
+* [[`f371562e30`](https://github.com/nodejs/node/commit/f371562e30)] - **build,win**: support building MSI with VS2019 (João Reis) [#30895](https://github.com/nodejs/node/pull/30895)
+* [[`d8ce9a0e23`](https://github.com/nodejs/node/commit/d8ce9a0e23)] - **(SEMVER-MINOR)** **cli**: add --trace-exit cli option (legendecas) [#30516](https://github.com/nodejs/node/pull/30516)
+* [[`30e2d28ac5`](https://github.com/nodejs/node/commit/30e2d28ac5)] - **cluster**: remove unnecessary bind (Anatoli Papirovski) [#28131](https://github.com/nodejs/node/pull/28131)
+* [[`4f3eca5d42`](https://github.com/nodejs/node/commit/4f3eca5d42)] - **console**: unregister temporary error listener (Robert Nagy) [#30852](https://github.com/nodejs/node/pull/30852)
+* [[`a221017ee8`](https://github.com/nodejs/node/commit/a221017ee8)] - **crypto**: cast oaepLabel to unsigned char\* (Shelley Vohr) [#30917](https://github.com/nodejs/node/pull/30917)
+* [[`3abcb69c3e`](https://github.com/nodejs/node/commit/3abcb69c3e)] - **doc**: add note about fs.close() about undefined behavior (Robert Nagy) [#30966](https://github.com/nodejs/node/pull/30966)
+* [[`13b5ace4db`](https://github.com/nodejs/node/commit/13b5ace4db)] - **doc**: explain napi\_run\_script (Tobias Nießen) [#30918](https://github.com/nodejs/node/pull/30918)
+* [[`559284b20a`](https://github.com/nodejs/node/commit/559284b20a)] - **doc**: add "Be direct." to the style guide (Rich Trott) [#30935](https://github.com/nodejs/node/pull/30935)
+* [[`eb6443dc11`](https://github.com/nodejs/node/commit/eb6443dc11)] - **doc**: clarify expectations for PR commit messages (Derek Lewis) [#30922](https://github.com/nodejs/node/pull/30922)
+* [[`df5ae1a8ef`](https://github.com/nodejs/node/commit/df5ae1a8ef)] - **doc**: fix description of N-API exception handlers (Tobias Nießen) [#30893](https://github.com/nodejs/node/pull/30893)
+* [[`b53e2a84ec`](https://github.com/nodejs/node/commit/b53e2a84ec)] - **doc**: improve doc writable streams: 'finish' event (dev-313) [#30889](https://github.com/nodejs/node/pull/30889)
+* [[`ad5b71525d`](https://github.com/nodejs/node/commit/ad5b71525d)] - **fs**: remove unnecessary bind (Anatoli Papirovski) [#28131](https://github.com/nodejs/node/pull/28131)
+* [[`3bc9b09ce6`](https://github.com/nodejs/node/commit/3bc9b09ce6)] - **http**: use for...of in http library code (Trivikram Kamat) [#30958](https://github.com/nodejs/node/pull/30958)
+* [[`7a756cb539`](https://github.com/nodejs/node/commit/7a756cb539)] - **http**: remove unnecessary bind (Anatoli Papirovski) [#28131](https://github.com/nodejs/node/pull/28131)
+* [[`172228047a`](https://github.com/nodejs/node/commit/172228047a)] - **http,https**: increase server headers timeout (Tim Costa) [#30071](https://github.com/nodejs/node/pull/30071)
+* [[`52aab47766`](https://github.com/nodejs/node/commit/52aab47766)] - **http2**: remove unnecessary bind from setImmediate (Anatoli Papirovski) [#28131](https://github.com/nodejs/node/pull/28131)
+* [[`88731adff6`](https://github.com/nodejs/node/commit/88731adff6)] - **lib**: replace Symbol.species by SymbolSpecies (Sebastien Ahkrin) [#30950](https://github.com/nodejs/node/pull/30950)
+* [[`f51b5bd3dc`](https://github.com/nodejs/node/commit/f51b5bd3dc)] - **lib**: replace Symbol.hasInstance by SymbolHasInstance (Sebastien Ahkrin) [#30948](https://github.com/nodejs/node/pull/30948)
+* [[`92475e998d`](https://github.com/nodejs/node/commit/92475e998d)] - **lib**: replace Symbol.asyncIterator by SymbolAsyncIterator (Sebastien Ahkrin) [#30947](https://github.com/nodejs/node/pull/30947)
+* [[`19f05cab39`](https://github.com/nodejs/node/commit/19f05cab39)] - **lib**: enforce use of Promise from primordials (Michaël Zasso) [#30936](https://github.com/nodejs/node/pull/30936)
+* [[`698e0a2095`](https://github.com/nodejs/node/commit/698e0a2095)] - **lib**: add TypedArray constructors to primordials (Sebastien Ahkrin) [#30740](https://github.com/nodejs/node/pull/30740)
+* [[`cbe29ce4cf`](https://github.com/nodejs/node/commit/cbe29ce4cf)] - **lib**: change var to let/const (rene.herrmann) [#30910](https://github.com/nodejs/node/pull/30910)
+* [[`2430dd8ecb`](https://github.com/nodejs/node/commit/2430dd8ecb)] - **lib**: use strict equality comparison (Donggeon Lim) [#30898](https://github.com/nodejs/node/pull/30898)
+* [[`30d32492a0`](https://github.com/nodejs/node/commit/30d32492a0)] - **lib**: refactor NativeModule (Joyee Cheung) [#30856](https://github.com/nodejs/node/pull/30856)
+* [[`a326309a74`](https://github.com/nodejs/node/commit/a326309a74)] - **lib**: replace Symbol.toPrimitive to SymbolToPrimitive primordials (Sebastien Ahkrin) [#30905](https://github.com/nodejs/node/pull/30905)
+* [[`0d2172fb5d`](https://github.com/nodejs/node/commit/0d2172fb5d)] - **lib**: update Symbol.toStringTag by SymbolToStringTag primordial (Sebastien Ahkrin) [#30908](https://github.com/nodejs/node/pull/30908)
+* [[`4e67d38f42`](https://github.com/nodejs/node/commit/4e67d38f42)] - **perf_hooks**: remove unnecessary bind (Anatoli Papirovski) [#28131](https://github.com/nodejs/node/pull/28131)
+* [[`510edead69`](https://github.com/nodejs/node/commit/510edead69)] - **process**: refs --unhandled-rejections documentation in warning message (Antoine du HAMEL) [#30564](https://github.com/nodejs/node/pull/30564)
+* [[`954793f363`](https://github.com/nodejs/node/commit/954793f363)] - **process**: fix promise catching (Rongjian Zhang) [#30957](https://github.com/nodejs/node/pull/30957)
+* [[`5b49ded22a`](https://github.com/nodejs/node/commit/5b49ded22a)] - **(SEMVER-MINOR)** **readline**: promote \_getCursorPos to public api (Jeremy Albright) [#30687](https://github.com/nodejs/node/pull/30687)
+* [[`424c37baba`](https://github.com/nodejs/node/commit/424c37baba)] - **(SEMVER-MINOR)** **readline**: update ansi-regex (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`02f3fe4b60`](https://github.com/nodejs/node/commit/02f3fe4b60)] - **(SEMVER-MINOR)** **repl**: fix preview bug in case of long lines (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`6a3e79f953`](https://github.com/nodejs/node/commit/6a3e79f953)] - **(SEMVER-MINOR)** **repl**: add completion preview (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`1a8f828c17`](https://github.com/nodejs/node/commit/1a8f828c17)] - **(SEMVER-MINOR)** **repl**: improve completion (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`8b92223ed1`](https://github.com/nodejs/node/commit/8b92223ed1)] - **(SEMVER-MINOR)** **repl**: simplify code (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`f7eeb8cc0b`](https://github.com/nodejs/node/commit/f7eeb8cc0b)] - **(SEMVER-MINOR)** **repl**: simplify repl autocompletion (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`d549daef18`](https://github.com/nodejs/node/commit/d549daef18)] - **(SEMVER-MINOR)** **repl**: remove dead code (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`e11acc5a45`](https://github.com/nodejs/node/commit/e11acc5a45)] - **repl**: fix autocomplete when useGlobal is false (Michaël Zasso) [#30883](https://github.com/nodejs/node/pull/30883)
+* [[`3906e145ca`](https://github.com/nodejs/node/commit/3906e145ca)] - **(SEMVER-MINOR)** **repl,readline**: refactor for simplicity (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`f6f298e3cf`](https://github.com/nodejs/node/commit/f6f298e3cf)] - **(SEMVER-MINOR)** **repl,readline**: refactor common code (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`d456aa0a57`](https://github.com/nodejs/node/commit/d456aa0a57)] - **src**: unregister Isolate with platform before disposing (Anna Henningsen) [#30909](https://github.com/nodejs/node/pull/30909)
+* [[`c43461ac56`](https://github.com/nodejs/node/commit/c43461ac56)] - **src**: make debug\_options getters public (Shelley Vohr) [#30494](https://github.com/nodejs/node/pull/30494)
+* [[`5ca29d860b`](https://github.com/nodejs/node/commit/5ca29d860b)] - **stream**: use for...of (Trivikram Kamat) [#30960](https://github.com/nodejs/node/pull/30960)
+* [[`0c18c49f0e`](https://github.com/nodejs/node/commit/0c18c49f0e)] - **stream**: do not chunk strings and Buffer in Readable.from (Matteo Collina) [#30912](https://github.com/nodejs/node/pull/30912)
+* [[`663a6b4938`](https://github.com/nodejs/node/commit/663a6b4938)] - **stream**: make all streams error in a pipeline (Matteo Collina) [#30869](https://github.com/nodejs/node/pull/30869)
+* [[`5e268b8dbe`](https://github.com/nodejs/node/commit/5e268b8dbe)] - **test**: simplify test-wasi-start-validation.js (Colin Ihrig) [#30972](https://github.com/nodejs/node/pull/30972)
+* [[`c2d95529f6`](https://github.com/nodejs/node/commit/c2d95529f6)] - **test**: improve WASI start() coverage (Colin Ihrig) [#30972](https://github.com/nodejs/node/pull/30972)
+* [[`72b4aee745`](https://github.com/nodejs/node/commit/72b4aee745)] - **test**: improve test coverage in child\_process (Juan José Arboleda) [#26282](https://github.com/nodejs/node/pull/26282)
+* [[`f30b771fd2`](https://github.com/nodejs/node/commit/f30b771fd2)] - **(SEMVER-MINOR)** **test**: add multiple repl preview tests (Ruben Bridgewater) [#30907](https://github.com/nodejs/node/pull/30907)
+* [[`69aaab0e2c`](https://github.com/nodejs/node/commit/69aaab0e2c)] - **test**: improve dns lookup coverage (Kirill Ponomarev) [#30777](https://github.com/nodejs/node/pull/30777)
+* [[`b6b917dda0`](https://github.com/nodejs/node/commit/b6b917dda0)] - **test**: avoid leftover report file (Gerhard Stoebich) [#30925](https://github.com/nodejs/node/pull/30925)
+* [[`51d1a919bf`](https://github.com/nodejs/node/commit/51d1a919bf)] - **test**: add missing test flags (Colin Ihrig) [#30971](https://github.com/nodejs/node/pull/30971)
+* [[`60485dcc8e`](https://github.com/nodejs/node/commit/60485dcc8e)] - **test**: add test for validation for wasi.start() argument (Rich Trott) [#30919](https://github.com/nodejs/node/pull/30919)
+* [[`7a25c2c073`](https://github.com/nodejs/node/commit/7a25c2c073)] - **test**: improve assertion error message in test-debug-usage (Rich Trott) [#30913](https://github.com/nodejs/node/pull/30913)
+* [[`b7a0574d6f`](https://github.com/nodejs/node/commit/b7a0574d6f)] - **test**: make test-os-checked-function work without test harness (Rich Trott) [#30914](https://github.com/nodejs/node/pull/30914)
+* [[`7e6510bcfb`](https://github.com/nodejs/node/commit/7e6510bcfb)] - **test**: delay loading 'os' in test/common module (Rich Trott) [#30914](https://github.com/nodejs/node/pull/30914)
+* [[`956dec8b6b`](https://github.com/nodejs/node/commit/956dec8b6b)] - **tls**: for...of in \_tls\_common.js (Trivikram Kamat) [#30961](https://github.com/nodejs/node/pull/30961)
+* [[`b20ddde2f6`](https://github.com/nodejs/node/commit/b20ddde2f6)] - **tools**: enable Markdown linter's usage information (Derek Lewis) [#30216](https://github.com/nodejs/node/pull/30216)
+* [[`f62a7679a3`](https://github.com/nodejs/node/commit/f62a7679a3)] - **util**: add Set and map size to inspect output (Ruben Bridgewater) [#30225](https://github.com/nodejs/node/pull/30225)
+* [[`f830a7dd73`](https://github.com/nodejs/node/commit/f830a7dd73)] - **util**: refactor inspect code for constistency (Ruben Bridgewater) [#30225](https://github.com/nodejs/node/pull/30225)
+* [[`8dec909aa7`](https://github.com/nodejs/node/commit/8dec909aa7)] - **(SEMVER-MINOR)** **util**: inspect (user defined) prototype properties (Ruben Bridgewater) [#30768](https://github.com/nodejs/node/pull/30768)
+* [[`453be95edc`](https://github.com/nodejs/node/commit/453be95edc)] - **(SEMVER-MINOR)** **util**: fix built-in detection (Ruben Bridgewater) [#30768](https://github.com/nodejs/node/pull/30768)
+* [[`2b0e2c280f`](https://github.com/nodejs/node/commit/2b0e2c280f)] - **v8**: use of TypedArray constructors from primordials (Sebastien Ahkrin) [#30740](https://github.com/nodejs/node/pull/30740)
+* [[`54d51dbe4c`](https://github.com/nodejs/node/commit/54d51dbe4c)] - **wasi**: require CLI flag to require() wasi module (Colin Ihrig) [#30963](https://github.com/nodejs/node/pull/30963)
+
+<a id="13.4.0"></a>
+## 2019-12-17, Version 13.4.0 (Current), @MylesBorins
+
+This is a security release.
+
+For more details about the vulnerability please consult the npm blog:
+
+https://blog.npmjs.org/post/189618601100/binary-planting-with-the-npm-cli
+
+### Notable Changes
+
+* **deps**:
+  * update npm to 6.13.4 [#30904](https://github.com/nodejs/node/pull/30904)
+  * update uvwasi (Anna Henningsen) [#30745](https://github.com/nodejs/node/pull/30745)
+  * upgrade to libuv 1.34.0 (Colin Ihrig) [#30783](https://github.com/nodejs/node/pull/30783)
+* **doc**:
+  * docs deprecate http finished (Robert Nagy) [#28679](https://github.com/nodejs/node/pull/28679)
+* **events**:
+  * add captureRejection option (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* **http**:
+  * add captureRejection support (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+  * llhttp opt-in insecure HTTP header parsing (Sam Roberts) [#30567](https://github.com/nodejs/node/pull/30567)
+* **http2**:
+  * implement capture rection for 'request' and 'stream' events (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* **net**:
+  * implement capture rejections for 'connection' event (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* **repl**:
+  * support previews by eager evaluating input (Ruben Bridgewater) [#30811](https://github.com/nodejs/node/pull/30811)
+* **stream**:
+  * add support for captureRejection option (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* **tls**:
+  * implement capture rejections for 'secureConnection' event (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+  * expose IETF name for current cipher suite (Sam Roberts) [#30637](https://github.com/nodejs/node/pull/30637)
+* **worker**:
+  * add argv constructor option (legendecas) [#30559](https://github.com/nodejs/node/pull/30559)
+
+### Commits
+
+* [[`1c4b2f15d9`](https://github.com/nodejs/node/commit/1c4b2f15d9)] - **assert,util**: stricter type comparison using deep equal comparisons (Ruben Bridgewater) [#30764](https://github.com/nodejs/node/pull/30764)
+* [[`78eaf50693`](https://github.com/nodejs/node/commit/78eaf50693)] - **benchmark**: improve `--filter` pattern matching (Matheus Marchini) [#29987](https://github.com/nodejs/node/pull/29987)
+* [[`ad4d52d1b5`](https://github.com/nodejs/node/commit/ad4d52d1b5)] - **benchmark**: add more util inspect and format benchmarks (Ruben Bridgewater) [#30767](https://github.com/nodejs/node/pull/30767)
+* [[`d90815d08e`](https://github.com/nodejs/node/commit/d90815d08e)] - **build**: on Android, use android log library to print stack traces (Giovanni Campagna) [#29388](https://github.com/nodejs/node/pull/29388)
+* [[`d1c4fccde2`](https://github.com/nodejs/node/commit/d1c4fccde2)] - **build**: fix library version and compile flags on Android (Giovanni Campagna) [#29388](https://github.com/nodejs/node/pull/29388)
+* [[`dfd3a4d6c1`](https://github.com/nodejs/node/commit/dfd3a4d6c1)] - **(SEMVER-MINOR)** **build**: add flag to enable pointer compression (Matteo Collina) [#30463](https://github.com/nodejs/node/pull/30463)
+* [[`3d05d4beea`](https://github.com/nodejs/node/commit/3d05d4beea)] - **build**: ease DragonFlyBSD build (David Carlier) [#30201](https://github.com/nodejs/node/pull/30201)
+* [[`43e947a155`](https://github.com/nodejs/node/commit/43e947a155)] - **build**: remove (almost) unused macros/constants (Benjamin Coe) [#30755](https://github.com/nodejs/node/pull/30755)
+* [[`0379fb65c1`](https://github.com/nodejs/node/commit/0379fb65c1)] - **deps**: update npm to 6.13.4 (Isaac Z. Schlueter) [#30904](https://github.com/nodejs/node/pull/30904)
+* [[`13fe9f7cc8`](https://github.com/nodejs/node/commit/13fe9f7cc8)] - **deps**: update uvwasi (Anna Henningsen) [#30745](https://github.com/nodejs/node/pull/30745)
+* [[`ca47f72868`](https://github.com/nodejs/node/commit/ca47f72868)] - **(SEMVER-MINOR)** **deps**: upgrade to libuv 1.34.0 (Colin Ihrig) [#30783](https://github.com/nodejs/node/pull/30783)
+* [[`458860691c`](https://github.com/nodejs/node/commit/458860691c)] - **deps**: fix OPENSSLDIR on Windows (Shigeki Ohtsu) [#29456](https://github.com/nodejs/node/pull/29456)
+* [[`b3ae532392`](https://github.com/nodejs/node/commit/b3ae532392)] - **doc**: clarify build support text (Rich Trott) [#30899](https://github.com/nodejs/node/pull/30899)
+* [[`8bf0da6c93`](https://github.com/nodejs/node/commit/8bf0da6c93)] - **doc**: edit colorMode information (Rich Trott) [#30887](https://github.com/nodejs/node/pull/30887)
+* [[`df9df1883e`](https://github.com/nodejs/node/commit/df9df1883e)] - **doc**: fix argument type of setAAD (Tobias Nießen) [#30863](https://github.com/nodejs/node/pull/30863)
+* [[`9d1c793ceb`](https://github.com/nodejs/node/commit/9d1c793ceb)] - **doc**: clarify Tier 2 implications in BUILDING.md (Rich Trott) [#30866](https://github.com/nodejs/node/pull/30866)
+* [[`1cce00073e`](https://github.com/nodejs/node/commit/1cce00073e)] - **doc**: add code example to inspector.url() method (Juan José Arboleda) [#29496](https://github.com/nodejs/node/pull/29496)
+* [[`93ca4f4098`](https://github.com/nodejs/node/commit/93ca4f4098)] - **doc**: deprecate http finished (Robert Nagy) [#28679](https://github.com/nodejs/node/pull/28679)
+* [[`0022d7544a`](https://github.com/nodejs/node/commit/0022d7544a)] - **doc**: improve doc Http2Stream: FrameError, Timeout and Trailers (dev-313) [#30373](https://github.com/nodejs/node/pull/30373)
+* [[`2123d53c28`](https://github.com/nodejs/node/commit/2123d53c28)] - **doc**: include line/cursor in readline documentation (Jeremy Albright) [#30667](https://github.com/nodejs/node/pull/30667)
+* [[`1baa6ab075`](https://github.com/nodejs/node/commit/1baa6ab075)] - **doc**: improve napi formatting (Ruben Bridgewater) [#30772](https://github.com/nodejs/node/pull/30772)
+* [[`1d5c4e21de`](https://github.com/nodejs/node/commit/1d5c4e21de)] - **doc**: add documentation about node\_mksnapshot and mkcodecache (Joyee Cheung) [#30773](https://github.com/nodejs/node/pull/30773)
+* [[`67823e8fc4`](https://github.com/nodejs/node/commit/67823e8fc4)] - **doc**: remove imprecise and redundant testing text (Rich Trott) [#30763](https://github.com/nodejs/node/pull/30763)
+* [[`7cb84fdbe5`](https://github.com/nodejs/node/commit/7cb84fdbe5)] - **doc**: remove usage of "Node" in favor of "Node.js" (Rich Trott) [#30758](https://github.com/nodejs/node/pull/30758)
+* [[`510eb3a6eb`](https://github.com/nodejs/node/commit/510eb3a6eb)] - **doc**: revise addons introduction for brevity and clarity (Rich Trott) [#30756](https://github.com/nodejs/node/pull/30756)
+* [[`543bf9d8ea`](https://github.com/nodejs/node/commit/543bf9d8ea)] - **doc**: fix up N-API doc (NickNaso) [#30656](https://github.com/nodejs/node/pull/30656)
+* [[`2c0f1edfd5`](https://github.com/nodejs/node/commit/2c0f1edfd5)] - **doc**: adds assert doc for strict mode with pointer to strict equality (Shobhit Chittora) [#30486](https://github.com/nodejs/node/pull/30486)
+* [[`9428304d4a`](https://github.com/nodejs/node/commit/9428304d4a)] - **doc**: Buffer.toString(): add note about invalid data (Jan-Philip Gehrcke) [#30706](https://github.com/nodejs/node/pull/30706)
+* [[`8369562757`](https://github.com/nodejs/node/commit/8369562757)] - **doc**: clarify text about using 'session' event for compatibility (Rich Trott) [#30746](https://github.com/nodejs/node/pull/30746)
+* [[`145f881ff9`](https://github.com/nodejs/node/commit/145f881ff9)] - **doc**: update status of Python 3 support (Michael Dawson) [#30722](https://github.com/nodejs/node/pull/30722)
+* [[`bbbba76f2c`](https://github.com/nodejs/node/commit/bbbba76f2c)] - **doc,benchmark**: move benchmark guide to benchmark directory (Rich Trott) [#30781](https://github.com/nodejs/node/pull/30781)
+* [[`eb4f443a5a`](https://github.com/nodejs/node/commit/eb4f443a5a)] - **esm**: make specifier flag clearly experimental (Myles Borins) [#30678](https://github.com/nodejs/node/pull/30678)
+* [[`220a6001c6`](https://github.com/nodejs/node/commit/220a6001c6)] - **(SEMVER-MINOR)** **events**: add captureRejection option (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* [[`6c07a72833`](https://github.com/nodejs/node/commit/6c07a72833)] - **fs**: synchronize close with other I/O for streams (Anna Henningsen) [#30837](https://github.com/nodejs/node/pull/30837)
+* [[`18758ef183`](https://github.com/nodejs/node/commit/18758ef183)] - **fs**: retry unlink operations in rimraf (Colin Ihrig) [#30569](https://github.com/nodejs/node/pull/30569)
+* [[`5e98de1751`](https://github.com/nodejs/node/commit/5e98de1751)] - **fs**: only operate on buffers in rimraf (Colin Ihrig) [#30569](https://github.com/nodejs/node/pull/30569)
+* [[`7e1dee3347`](https://github.com/nodejs/node/commit/7e1dee3347)] - **fs**: reduce unnecessary sync rimraf retries (Colin Ihrig) [#30785](https://github.com/nodejs/node/pull/30785)
+* [[`5523950b47`](https://github.com/nodejs/node/commit/5523950b47)] - **fs**: add synchronous retries to rimraf (Colin Ihrig) [#30785](https://github.com/nodejs/node/pull/30785)
+* [[`60b1e1ad61`](https://github.com/nodejs/node/commit/60b1e1ad61)] - **fs**: fix existsSync for invalid symlink at win32 (Rongjian Zhang) [#30556](https://github.com/nodejs/node/pull/30556)
+* [[`daca0780b1`](https://github.com/nodejs/node/commit/daca0780b1)] - **(SEMVER-MINOR)** **http**: llhttp opt-in insecure HTTP header parsing (Sam Roberts) [#30567](https://github.com/nodejs/node/pull/30567)
+* [[`334d4f6256`](https://github.com/nodejs/node/commit/334d4f6256)] - **(SEMVER-MINOR)** **http**: add captureRejection support to OutgoingMessage (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* [[`33a6bf3a83`](https://github.com/nodejs/node/commit/33a6bf3a83)] - **(SEMVER-MINOR)** **http**: implement capture rejections for 'request' event (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* [[`822fb00dbe`](https://github.com/nodejs/node/commit/822fb00dbe)] - **http2**: forward debug message in debugStreamObj (Denys Otrishko) [#30840](https://github.com/nodejs/node/pull/30840)
+* [[`d17ea8f584`](https://github.com/nodejs/node/commit/d17ea8f584)] - **http2**: track nghttp2-allocated memory in heap snapshot (Anna Henningsen) [#30745](https://github.com/nodejs/node/pull/30745)
+* [[`8a9f57d0d5`](https://github.com/nodejs/node/commit/8a9f57d0d5)] - **http2**: use shared memory tracking implementation (Anna Henningsen) [#30745](https://github.com/nodejs/node/pull/30745)
+* [[`71bb026e0c`](https://github.com/nodejs/node/commit/71bb026e0c)] - **http2**: streamline OnStreamRead streamline memory accounting (Denys Otrishko) [#30351](https://github.com/nodejs/node/pull/30351)
+* [[`3840abed11`](https://github.com/nodejs/node/commit/3840abed11)] - **http2**: small clean up in OnStreamRead (Denys Otrishko) [#30351](https://github.com/nodejs/node/pull/30351)
+* [[`c3ac4c85a5`](https://github.com/nodejs/node/commit/c3ac4c85a5)] - **(SEMVER-MINOR)** **http2**: implement capture rection for 'request' and 'stream' events (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* [[`d3f0dd2148`](https://github.com/nodejs/node/commit/d3f0dd2148)] - **inspector**: do not access queueMicrotask from global (Michaël Zasso) [#30732](https://github.com/nodejs/node/pull/30732)
+* [[`71c6d44efa`](https://github.com/nodejs/node/commit/71c6d44efa)] - **lib**: enforce use of BigInt from primordials (Michaël Zasso) [#30882](https://github.com/nodejs/node/pull/30882)
+* [[`64ab5c9c84`](https://github.com/nodejs/node/commit/64ab5c9c84)] - **lib**: replace Symbol.iterator by SymbolIterator (Sebastien Ahkrin) [#30859](https://github.com/nodejs/node/pull/30859)
+* [[`39898a9db4`](https://github.com/nodejs/node/commit/39898a9db4)] - **lib**: replace every Symbol.for by SymbolFor primordials (Sebastien Ahkrin) [#30857](https://github.com/nodejs/node/pull/30857)
+* [[`0a34fcb086`](https://github.com/nodejs/node/commit/0a34fcb086)] - **lib**: replace var with let/const (jens-cappelle) [#30384](https://github.com/nodejs/node/pull/30384)
+* [[`af014170a7`](https://github.com/nodejs/node/commit/af014170a7)] - **lib**: replace Symbol global by the primordials Symbol (Sebastien Ahkrin) [#30737](https://github.com/nodejs/node/pull/30737)
+* [[`2c439bb8ad`](https://github.com/nodejs/node/commit/2c439bb8ad)] - **lib**: add parent to ERR\_UNKNOWN\_FILE\_EXTENSION (qualitymanifest) [#30728](https://github.com/nodejs/node/pull/30728)
+* [[`d9d64754f9`](https://github.com/nodejs/node/commit/d9d64754f9)] - **lib**: add warning on dynamic import es modules (Juan José Arboleda) [#30720](https://github.com/nodejs/node/pull/30720)
+* [[`325128e469`](https://github.com/nodejs/node/commit/325128e469)] - **lib**: delay access to CLI option to pre-execution (Joyee Cheung) [#30778](https://github.com/nodejs/node/pull/30778)
+* [[`94f237e5ac`](https://github.com/nodejs/node/commit/94f237e5ac)] - **lib,test**: improves ERR\_REQUIRE\_ESM message (Juan José Arboleda) [#30694](https://github.com/nodejs/node/pull/30694)
+* [[`e61f4ead93`](https://github.com/nodejs/node/commit/e61f4ead93)] - **module**: conditional exports import condition (Guy Bedford) [#30799](https://github.com/nodejs/node/pull/30799)
+* [[`8e16093b64`](https://github.com/nodejs/node/commit/8e16093b64)] - **module**: fix require in node repl (Yongsheng Zhang) [#30835](https://github.com/nodejs/node/pull/30835)
+* [[`d4aa656d57`](https://github.com/nodejs/node/commit/d4aa656d57)] - **module**: fix dynamic import from eval (Corey Farrell) [#30624](https://github.com/nodejs/node/pull/30624)
+* [[`a7ec78f34e`](https://github.com/nodejs/node/commit/a7ec78f34e)] - **module**: fixup lint and test regressions (Guy Bedford) [#30802](https://github.com/nodejs/node/pull/30802)
+* [[`bd2f1270f7`](https://github.com/nodejs/node/commit/bd2f1270f7)] - **module**: ignore resolution failures for inspect-brk (Maël Nison) [#30336](https://github.com/nodejs/node/pull/30336)
+* [[`851f3135ab`](https://github.com/nodejs/node/commit/851f3135ab)] - **module**: add warnings for experimental flags (Rongjian Zhang) [#30617](https://github.com/nodejs/node/pull/30617)
+* [[`123327d4c1`](https://github.com/nodejs/node/commit/123327d4c1)] - **net**: remove duplicate \_undestroy (Robert Nagy) [#30833](https://github.com/nodejs/node/pull/30833)
+* [[`4eecee089d`](https://github.com/nodejs/node/commit/4eecee089d)] - **(SEMVER-MINOR)** **net**: implement capture rejections for 'connection' event (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* [[`2f1ae4f2bf`](https://github.com/nodejs/node/commit/2f1ae4f2bf)] - **readline**: eagerly load string\_decoder (Ruben Bridgewater) [#30807](https://github.com/nodejs/node/pull/30807)
+* [[`e551c169b8`](https://github.com/nodejs/node/commit/e551c169b8)] - **(SEMVER-MINOR)** **repl**: support previews by eager evaluating input (Ruben Bridgewater) [#30811](https://github.com/nodejs/node/pull/30811)
+* [[`c440f3fa3d`](https://github.com/nodejs/node/commit/c440f3fa3d)] - **repl**: use better uncaught exceptions indicator (Ruben Bridgewater) [#29676](https://github.com/nodejs/node/pull/29676)
+* [[`de368200f3`](https://github.com/nodejs/node/commit/de368200f3)] - **src**: accept single argument in getProxyDetails (Ruben Bridgewater) [#30858](https://github.com/nodejs/node/pull/30858)
+* [[`60886036c9`](https://github.com/nodejs/node/commit/60886036c9)] - **src**: fix the false isatty() issue on IBMi (Xu Meng) [#30829](https://github.com/nodejs/node/pull/30829)
+* [[`7ed867dddb`](https://github.com/nodejs/node/commit/7ed867dddb)] - **src**: improve checked uv loop close output (Anna Henningsen) [#30814](https://github.com/nodejs/node/pull/30814)
+* [[`041daaa273`](https://github.com/nodejs/node/commit/041daaa273)] - **src**: port memory-tracking allocator from QUIC repo (Anna Henningsen) [#30745](https://github.com/nodejs/node/pull/30745)
+* [[`ccf0917aef`](https://github.com/nodejs/node/commit/ccf0917aef)] - **src**: don't use deprecated OpenSSL APIs (Rosen Penev) [#30812](https://github.com/nodejs/node/pull/30812)
+* [[`8ad53ab2b7`](https://github.com/nodejs/node/commit/8ad53ab2b7)] - **src**: free preopen memory in WASI::New() (Colin Ihrig) [#30809](https://github.com/nodejs/node/pull/30809)
+* [[`e6e379ea41`](https://github.com/nodejs/node/commit/e6e379ea41)] - **src**: use checked allocations in WASI::New() (Colin Ihrig) [#30809](https://github.com/nodejs/node/pull/30809)
+* [[`838ae10a9b`](https://github.com/nodejs/node/commit/838ae10a9b)] - **src**: delete redundant method in node\_dir.h (gengjiawen) [#30747](https://github.com/nodejs/node/pull/30747)
+* [[`66db8746c7`](https://github.com/nodejs/node/commit/66db8746c7)] - **src**: remove redundant cast in node\_dir.cc (gengjiawen) [#30747](https://github.com/nodejs/node/pull/30747)
+* [[`cb69ff47f6`](https://github.com/nodejs/node/commit/cb69ff47f6)] - **src**: improve node\_crypto.cc memory allocation (Priyanka Kore) [#30751](https://github.com/nodejs/node/pull/30751)
+* [[`b51b26ffef`](https://github.com/nodejs/node/commit/b51b26ffef)] - **src**: fix node\_dir.cc memory allocation (Priyanka Kore) [#30750](https://github.com/nodejs/node/pull/30750)
+* [[`89bc571490`](https://github.com/nodejs/node/commit/89bc571490)] - **(SEMVER-MINOR)** **stream**: add support for captureRejection option (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* [[`1b534d571a`](https://github.com/nodejs/node/commit/1b534d571a)] - **test**: work around ENOTEMPTY when cleaning tmp dir (Ben Noordhuis) [#30849](https://github.com/nodejs/node/pull/30849)
+* [[`eb6e32c2fc`](https://github.com/nodejs/node/commit/eb6e32c2fc)] - **test**: disable colorMode in test-console-group (Rich Trott) [#30886](https://github.com/nodejs/node/pull/30886)
+* [[`5f42b1fc6b`](https://github.com/nodejs/node/commit/5f42b1fc6b)] - **test**: assert: fix deepStrictEqual comparing a real array and fake array (Jordan Harband) [#30743](https://github.com/nodejs/node/pull/30743)
+* [[`ce21fc7154`](https://github.com/nodejs/node/commit/ce21fc7154)] - **test**: wait for stream close before writing to file (Anna Henningsen) [#30836](https://github.com/nodejs/node/pull/30836)
+* [[`cc4a6ed645`](https://github.com/nodejs/node/commit/cc4a6ed645)] - **test**: use fs rimraf to refresh tmpdir (Colin Ihrig) [#30569](https://github.com/nodejs/node/pull/30569)
+* [[`5ae3a858f7`](https://github.com/nodejs/node/commit/5ae3a858f7)] - **test**: refactor test-accessor-properties (himself65) [#29943](https://github.com/nodejs/node/pull/29943)
+* [[`97e0efeedf`](https://github.com/nodejs/node/commit/97e0efeedf)] - **test**: scale keepalive timeouts for slow machines (Ben Noordhuis) [#30834](https://github.com/nodejs/node/pull/30834)
+* [[`305e45a041`](https://github.com/nodejs/node/commit/305e45a041)] - **test**: mark tests as flaky (João Reis) [#30848](https://github.com/nodejs/node/pull/30848)
+* [[`4dc9d8db13`](https://github.com/nodejs/node/commit/4dc9d8db13)] - **test**: mark addons/openssl-bindings/test flaky on arm (Richard Lau) [#30838](https://github.com/nodejs/node/pull/30838)
+* [[`25e3696a07`](https://github.com/nodejs/node/commit/25e3696a07)] - **test**: improve WASI options validation (Rich Trott) [#30800](https://github.com/nodejs/node/pull/30800)
+* [[`a574cb0ab9`](https://github.com/nodejs/node/commit/a574cb0ab9)] - **test**: remove common.busyLoop() (Colin Ihrig) [#30787](https://github.com/nodejs/node/pull/30787)
+* [[`3557659afb`](https://github.com/nodejs/node/commit/3557659afb)] - **test**: run more assert tests (Ruben Bridgewater) [#30764](https://github.com/nodejs/node/pull/30764)
+* [[`5067463f3c`](https://github.com/nodejs/node/commit/5067463f3c)] - **test**: use callback arguments in getconnections test (Rich Trott) [#30775](https://github.com/nodejs/node/pull/30775)
+* [[`30756e36e7`](https://github.com/nodejs/node/commit/30756e36e7)] - **test**: improve wasi test coverage (Rich Trott) [#30770](https://github.com/nodejs/node/pull/30770)
+* [[`fb31ab52c0`](https://github.com/nodejs/node/commit/fb31ab52c0)] - **test**: simplify tmpdir import in wasi tests (Rich Trott) [#30770](https://github.com/nodejs/node/pull/30770)
+* [[`55a270b583`](https://github.com/nodejs/node/commit/55a270b583)] - **test**: remove duplicate entries from root.status (Richard Lau) [#30769](https://github.com/nodejs/node/pull/30769)
+* [[`54a266c878`](https://github.com/nodejs/node/commit/54a266c878)] - **test**: increase debugging information in subprocess test (Rich Trott) [#30761](https://github.com/nodejs/node/pull/30761)
+* [[`a0fa327365`](https://github.com/nodejs/node/commit/a0fa327365)] - **test**: use block-scoping in test-net-server-address (Rich Trott) [#30754](https://github.com/nodejs/node/pull/30754)
+* [[`9bd5c72104`](https://github.com/nodejs/node/commit/9bd5c72104)] - **test**: move test-child-process-fork-getconnections to parallel (Rich Trott) [#30749](https://github.com/nodejs/node/pull/30749)
+* [[`50ab1fa013`](https://github.com/nodejs/node/commit/50ab1fa013)] - **test**: change common.PORT to arbitrary port (Rich Trott) [#30749](https://github.com/nodejs/node/pull/30749)
+* [[`255cd7e572`](https://github.com/nodejs/node/commit/255cd7e572)] - **(SEMVER-MINOR)** **tls**: expose IETF name for current cipher suite (Sam Roberts) [#30637](https://github.com/nodejs/node/pull/30637)
+* [[`5ad3efbfb3`](https://github.com/nodejs/node/commit/5ad3efbfb3)] - **(SEMVER-MINOR)** **tls**: implement capture rejections for 'secureConnection' event (Matteo Collina) [#27867](https://github.com/nodejs/node/pull/27867)
+* [[`5203ffb2f4`](https://github.com/nodejs/node/commit/5203ffb2f4)] - **tools**: update link to google styleguide for cpplint (Daniel Bevenius) [#30876](https://github.com/nodejs/node/pull/30876)
+* [[`1ed1a645f2`](https://github.com/nodejs/node/commit/1ed1a645f2)] - **tools**: use CC instead of CXX when pointing to gcc (Milad Farazmand) [#30817](https://github.com/nodejs/node/pull/30817)
+* [[`2b687af852`](https://github.com/nodejs/node/commit/2b687af852)] - **tools**: update remark-preset-lint-node to 1.11.0 (Rich Trott) [#30789](https://github.com/nodejs/node/pull/30789)
+* [[`0cb7720dd8`](https://github.com/nodejs/node/commit/0cb7720dd8)] - **tools**: update icu to 65.1 (Albert Wang) [#30232](https://github.com/nodejs/node/pull/30232)
+* [[`7b9400ce63`](https://github.com/nodejs/node/commit/7b9400ce63)] - **tools**: update ESLint to 6.7.2 (Rich Trott) [#30762](https://github.com/nodejs/node/pull/30762)
+* [[`5ab3ca4f96`](https://github.com/nodejs/node/commit/5ab3ca4f96)] - **url**: declare iterator inside loop (Trivikram Kamat) [#30509](https://github.com/nodejs/node/pull/30509)
+* [[`dc69cbeb05`](https://github.com/nodejs/node/commit/dc69cbeb05)] - **util**: add internal sleep() function (Colin Ihrig) [#30787](https://github.com/nodejs/node/pull/30787)
+* [[`3898b2387b`](https://github.com/nodejs/node/commit/3898b2387b)] - **util**: never trigger any proxy traps using `format()` (Ruben Bridgewater) [#30767](https://github.com/nodejs/node/pull/30767)
+* [[`eeaeb51dcc`](https://github.com/nodejs/node/commit/eeaeb51dcc)] - **util**: improve performance inspecting proxies (Ruben Bridgewater) [#30767](https://github.com/nodejs/node/pull/30767)
+* [[`608d720834`](https://github.com/nodejs/node/commit/608d720834)] - **(SEMVER-MINOR)** **util**: add more predefined color codes to inspect.colors (Ruben Bridgewater) [#30659](https://github.com/nodejs/node/pull/30659)
+* [[`77ffd5482d`](https://github.com/nodejs/node/commit/77ffd5482d)] - **(SEMVER-MINOR)** **util**: improve inspect's customInspect performance (Ruben Bridgewater) [#30659](https://github.com/nodejs/node/pull/30659)
+* [[`14269d15cf`](https://github.com/nodejs/node/commit/14269d15cf)] - **wasi**: use memory-tracking allocator (Anna Henningsen) [#30745](https://github.com/nodejs/node/pull/30745)
+* [[`71d43a5569`](https://github.com/nodejs/node/commit/71d43a5569)] - **(SEMVER-MINOR)** **worker**: add argv constructor option (legendecas) [#30559](https://github.com/nodejs/node/pull/30559)
+
+<a id="13.3.0"></a>
+## 2019-12-03, Version 13.3.0 (Current), @BridgeAR
+
+### Notable Changes
+
+* **fs**:
+  * Reworked experimental recursive `rmdir()`  (cjihrig) [#30644](https://github.com/nodejs/node/pull/30644)
+    * The `maxBusyTries` option is renamed to `maxRetries`, and its default is
+      set to 0. The `emfileWait` option has been removed, and `EMFILE` errors
+      use the same retry logic as other errors. The `retryDelay` option is now
+      supported. `ENFILE` errors are now retried.
+* **http**:
+  * Make maximum header size configurable per-stream or per-server (Anna Henningsen) [#30570](https://github.com/nodejs/node/pull/30570)
+* **http2**:
+  * Make maximum tolerated rejected streams configurable (Denys Otrishko) [#30534](https://github.com/nodejs/node/pull/30534)
+  * Allow to configure maximum tolerated invalid frames (Denys Otrishko) [#30534](https://github.com/nodejs/node/pull/30534)
+* **wasi**:
+  * Introduce initial WASI support (cjihrig) [#30258](https://github.com/nodejs/node/pull/30258)
+
+### Commits
+
+* [[`4cd4e7c17a`](https://github.com/nodejs/node/commit/4cd4e7c17a)] - **benchmark,doc,lib,test**: prepare for padding lint rule (Rich Trott) [#30696](https://github.com/nodejs/node/pull/30696)
+* [[`63eb4fee46`](https://github.com/nodejs/node/commit/63eb4fee46)] - **buffer**: fix 6-byte writeUIntBE() range check (Brian White) [#30459](https://github.com/nodejs/node/pull/30459)
+* [[`e8af569200`](https://github.com/nodejs/node/commit/e8af569200)] - **buffer**: release buffers with free callbacks on env exit (Anna Henningsen) [#30551](https://github.com/nodejs/node/pull/30551)
+* [[`648766bccf`](https://github.com/nodejs/node/commit/648766bccf)] - **build**: do not build mksnapshot and mkcodecache for --shared (Joyee Cheung) [#30647](https://github.com/nodejs/node/pull/30647)
+* [[`6545314a4f`](https://github.com/nodejs/node/commit/6545314a4f)] - **build**: add --without-node-code-cache configure option (Joyee Cheung) [#30647](https://github.com/nodejs/node/pull/30647)
+* [[`80ada94cd3`](https://github.com/nodejs/node/commit/80ada94cd3)] - **build**: use Node.js instead of Node in configure (Tobias Nießen) [#30642](https://github.com/nodejs/node/pull/30642)
+* [[`0aae502c67`](https://github.com/nodejs/node/commit/0aae502c67)] - **build,win**: propagate error codes in vcbuild (João Reis) [#30724](https://github.com/nodejs/node/pull/30724)
+* [[`6a53152b42`](https://github.com/nodejs/node/commit/6a53152b42)] - **build,win**: add test-ci-native and test-ci-js (João Reis) [#30724](https://github.com/nodejs/node/pull/30724)
+* [[`30a4f68a15`](https://github.com/nodejs/node/commit/30a4f68a15)] - **child_process**: document kill() return value (cjihrig) [#30669](https://github.com/nodejs/node/pull/30669)
+* [[`dae36a9692`](https://github.com/nodejs/node/commit/dae36a9692)] - **child_process**: replace var with let/const (dnlup) [#30389](https://github.com/nodejs/node/pull/30389)
+* [[`4b13bca31a`](https://github.com/nodejs/node/commit/4b13bca31a)] - **child_process**: replace var with const/let in internal/child\_process.js (Luis Camargo) [#30414](https://github.com/nodejs/node/pull/30414)
+* [[`378c54fe97`](https://github.com/nodejs/node/commit/378c54fe97)] - **cluster**: replace vars in child.js (EmaSuriano) [#30383](https://github.com/nodejs/node/pull/30383)
+* [[`708e67a732`](https://github.com/nodejs/node/commit/708e67a732)] - **cluster**: replace var with let (Herrmann, Rene R. (656)) [#30425](https://github.com/nodejs/node/pull/30425)
+* [[`55fbe45f69`](https://github.com/nodejs/node/commit/55fbe45f69)] - **cluster**: replace var by let in shared\_handle.js (poutch) [#30402](https://github.com/nodejs/node/pull/30402)
+* [[`4affc30a12`](https://github.com/nodejs/node/commit/4affc30a12)] - **crypto**: automatically manage memory for ECDSA\_SIG (Tobias Nießen) [#30641](https://github.com/nodejs/node/pull/30641)
+* [[`55c2ac70b7`](https://github.com/nodejs/node/commit/55c2ac70b7)] - **crypto**: remove redundant validateUint32 argument (Tobias Nießen) [#30579](https://github.com/nodejs/node/pull/30579)
+* [[`0ba877a541`](https://github.com/nodejs/node/commit/0ba877a541)] - **deps**: V8: cherry-pick 0dfd9ea51241 (bcoe) [#30713](https://github.com/nodejs/node/pull/30713)
+* [[`b470354057`](https://github.com/nodejs/node/commit/b470354057)] - **deps**: patch V8 to 7.9.317.25 (Myles Borins) [#30679](https://github.com/nodejs/node/pull/30679)
+* [[`d257448bca`](https://github.com/nodejs/node/commit/d257448bca)] - **deps**: update llhttp to 2.0.1 (Fedor Indutny) [#30553](https://github.com/nodejs/node/pull/30553)
+* [[`456d250d2d`](https://github.com/nodejs/node/commit/456d250d2d)] - **deps**: V8: backport 93f189f19a03 (Michaël Zasso) [#30681](https://github.com/nodejs/node/pull/30681)
+* [[`aa01ebdbca`](https://github.com/nodejs/node/commit/aa01ebdbca)] - **deps**: V8: cherry-pick ca5b0ec (Anna Henningsen) [#30708](https://github.com/nodejs/node/pull/30708)
+* [[`f37450f580`](https://github.com/nodejs/node/commit/f37450f580)] - **dns**: use length for building TXT string (Anna Henningsen) [#30690](https://github.com/nodejs/node/pull/30690)
+* [[`3d302ff276`](https://github.com/nodejs/node/commit/3d302ff276)] - **doc**: fix typographical error (Rich Trott) [#30735](https://github.com/nodejs/node/pull/30735)
+* [[`19b31c1bc5`](https://github.com/nodejs/node/commit/19b31c1bc5)] - **doc**: revise REPL uncaught exception text (Rich Trott) [#30729](https://github.com/nodejs/node/pull/30729)
+* [[`61af1fcaa1`](https://github.com/nodejs/node/commit/61af1fcaa1)] - **doc**: update signature algorithm in release doc (Myles Borins) [#30673](https://github.com/nodejs/node/pull/30673)
+* [[`a8002d92ab`](https://github.com/nodejs/node/commit/a8002d92ab)] - **doc**: update README.md to fix active/maint times (Michael Dawson) [#30707](https://github.com/nodejs/node/pull/30707)
+* [[`f46df0b496`](https://github.com/nodejs/node/commit/f46df0b496)] - **doc**: update socket.bufferSize text (Rich Trott) [#30723](https://github.com/nodejs/node/pull/30723)
+* [[`cbd50262c0`](https://github.com/nodejs/node/commit/cbd50262c0)] - **doc**: note that buf.buffer's contents might differ (AJ Jordan) [#29651](https://github.com/nodejs/node/pull/29651)
+* [[`a25626c1ed`](https://github.com/nodejs/node/commit/a25626c1ed)] - **doc**: clarify IncomingMessage.destroy() description (Sam Foxman) [#30255](https://github.com/nodejs/node/pull/30255)
+* [[`8fcb450934`](https://github.com/nodejs/node/commit/8fcb450934)] - **doc**: fixed a typo in process.md (Harendra Singh) [#30277](https://github.com/nodejs/node/pull/30277)
+* [[`ad9f737e44`](https://github.com/nodejs/node/commit/ad9f737e44)] - **doc**: documenting a bit more FreeBSD case (David Carlier) [#30325](https://github.com/nodejs/node/pull/30325)
+* [[`40b762177f`](https://github.com/nodejs/node/commit/40b762177f)] - **doc**: add missing 'added' versions to module.builtinModules (Thomas Watson) [#30562](https://github.com/nodejs/node/pull/30562)
+* [[`aca0119089`](https://github.com/nodejs/node/commit/aca0119089)] - **doc**: fix worker.resourceLimits indentation (Daniel Nalborczyk) [#30663](https://github.com/nodejs/node/pull/30663)
+* [[`43e78578a6`](https://github.com/nodejs/node/commit/43e78578a6)] - **doc**: fix worker.resourceLimits type (Daniel Nalborczyk) [#30664](https://github.com/nodejs/node/pull/30664)
+* [[`20dbce17d5`](https://github.com/nodejs/node/commit/20dbce17d5)] - **doc**: avoid proposal syntax in code example (Alex Zherdev) [#30685](https://github.com/nodejs/node/pull/30685)
+* [[`1e7c567734`](https://github.com/nodejs/node/commit/1e7c567734)] - **doc**: address nits for src/README.md (Anna Henningsen) [#30693](https://github.com/nodejs/node/pull/30693)
+* [[`87136c9bde`](https://github.com/nodejs/node/commit/87136c9bde)] - **doc**: revise socket.connect() note (Rich Trott) [#30691](https://github.com/nodejs/node/pull/30691)
+* [[`fcde49700c`](https://github.com/nodejs/node/commit/fcde49700c)] - **doc**: remove "this API is unstable" note for v8 serdes API (bruce-one) [#30631](https://github.com/nodejs/node/pull/30631)
+* [[`809a2b056b`](https://github.com/nodejs/node/commit/809a2b056b)] - **doc**: fixup incorrect flag name reference (Guy Bedford) [#30651](https://github.com/nodejs/node/pull/30651)
+* [[`3d978839c1`](https://github.com/nodejs/node/commit/3d978839c1)] - **doc**: minor updates to releases.md (Beth Griggs) [#30636](https://github.com/nodejs/node/pull/30636)
+* [[`e9f031c741`](https://github.com/nodejs/node/commit/e9f031c741)] - **doc**: add 13 and 12 to previous versions (Andrew Hughes) [#30590](https://github.com/nodejs/node/pull/30590)
+* [[`8ab18b6b6f`](https://github.com/nodejs/node/commit/8ab18b6b6f)] - **doc**: update AUTHORS list (Gus Caplan) [#30672](https://github.com/nodejs/node/pull/30672)
+* [[`329a821d25`](https://github.com/nodejs/node/commit/329a821d25)] - **doc**: add explanation why keep var with for loop (Lucas Recknagel) [#30380](https://github.com/nodejs/node/pull/30380)
+* [[`426ca263c8`](https://github.com/nodejs/node/commit/426ca263c8)] - **doc**: document "Resume Build" limitation (Richard Lau) [#30604](https://github.com/nodejs/node/pull/30604)
+* [[`00f7cc65a1`](https://github.com/nodejs/node/commit/00f7cc65a1)] - **doc**: add note of caution about non-conforming streams (Robert Nagy) [#29895](https://github.com/nodejs/node/pull/29895)
+* [[`7d98a59c39`](https://github.com/nodejs/node/commit/7d98a59c39)] - **doc**: add note about debugging worker\_threads (Denys Otrishko) [#30594](https://github.com/nodejs/node/pull/30594)
+* [[`8ef629a78a`](https://github.com/nodejs/node/commit/8ef629a78a)] - **doc**: simplify "is recommended" language in assert documentation (Rich Trott) [#30558](https://github.com/nodejs/node/pull/30558)
+* [[`19d192d1f0`](https://github.com/nodejs/node/commit/19d192d1f0)] - **doc**: fix a typo in a date for version 13.2.0 (Kirlat) [#30587](https://github.com/nodejs/node/pull/30587)
+* [[`b67759a93c`](https://github.com/nodejs/node/commit/b67759a93c)] - **doc,deps**: document how to maintain ICU in Node.js (Steven R. Loomis) [#30607](https://github.com/nodejs/node/pull/30607)
+* [[`bfcc9142f3`](https://github.com/nodejs/node/commit/bfcc9142f3)] - **doc,n-api**: mark napi\_detach\_arraybuffer as experimental (legendecas) [#30703](https://github.com/nodejs/node/pull/30703)
+* [[`365f0ab09b`](https://github.com/nodejs/node/commit/365f0ab09b)] - **esm**: data URLs should ignore unknown parameters (Bradley Farias) [#30593](https://github.com/nodejs/node/pull/30593)
+* [[`0285aa0967`](https://github.com/nodejs/node/commit/0285aa0967)] - **events**: improve performance caused by primordials (guzhizhou) [#30577](https://github.com/nodejs/node/pull/30577)
+* [[`3475f9b82c`](https://github.com/nodejs/node/commit/3475f9b82c)] - **fs**: add ENFILE to rimraf retry logic (cjihrig) [#30644](https://github.com/nodejs/node/pull/30644)
+* [[`f725953433`](https://github.com/nodejs/node/commit/f725953433)] - **fs**: add retryDelay option to rimraf (cjihrig) [#30644](https://github.com/nodejs/node/pull/30644)
+* [[`51bc379243`](https://github.com/nodejs/node/commit/51bc379243)] - **fs**: remove rimraf's emfileWait option (cjihrig) [#30644](https://github.com/nodejs/node/pull/30644)
+* [[`612a3a2e6c`](https://github.com/nodejs/node/commit/612a3a2e6c)] - **fs**: make rimraf default to 0 retries (cjihrig) [#30644](https://github.com/nodejs/node/pull/30644)
+* [[`fa1f87b199`](https://github.com/nodejs/node/commit/fa1f87b199)] - **fs**: rename rimraf's maxBusyTries to maxRetries (cjihrig) [#30644](https://github.com/nodejs/node/pull/30644)
+* [[`8ee27ffe77`](https://github.com/nodejs/node/commit/8ee27ffe77)] - **fs**: change var to let (Àlvar Pérez) [#30407](https://github.com/nodejs/node/pull/30407)
+* [[`850c2a72ea`](https://github.com/nodejs/node/commit/850c2a72ea)] - **fs**: cover fs.opendir ERR\_INVALID\_CALLBACK (Vladislav Botvin) [#30307](https://github.com/nodejs/node/pull/30307)
+* [[`62574087ea`](https://github.com/nodejs/node/commit/62574087ea)] - **(SEMVER-MINOR)** **http**: make maximum header size configurable per-stream or per-server (Anna Henningsen) [#30570](https://github.com/nodejs/node/pull/30570)
+* [[`1d1d136806`](https://github.com/nodejs/node/commit/1d1d136806)] - **http**: set socket.server unconditionally (Anna Henningsen) [#30571](https://github.com/nodejs/node/pull/30571)
+* [[`6848bfbf65`](https://github.com/nodejs/node/commit/6848bfbf65)] - **http**: replace var with let (Guilherme Goncalves) [#30421](https://github.com/nodejs/node/pull/30421)
+* [[`8256d38349`](https://github.com/nodejs/node/commit/8256d38349)] - **http**: destructure primordials in lib/\_http\_server.js (Artem Maksimov) [#30315](https://github.com/nodejs/node/pull/30315)
+* [[`3b169f1dbd`](https://github.com/nodejs/node/commit/3b169f1dbd)] - **http**: improve performance caused by primordials (Lucas Recknagel) [#30416](https://github.com/nodejs/node/pull/30416)
+* [[`6f313f9ab0`](https://github.com/nodejs/node/commit/6f313f9ab0)] - **http2**: fix session memory accounting after pausing (Michael Lehenbauer) [#30684](https://github.com/nodejs/node/pull/30684)
+* [[`7d37bcebea`](https://github.com/nodejs/node/commit/7d37bcebea)] - **(SEMVER-MINOR)** **http2**: make maximum tolerated rejected streams configurable (Denys Otrishko) [#30534](https://github.com/nodejs/node/pull/30534)
+* [[`092a3c28aa`](https://github.com/nodejs/node/commit/092a3c28aa)] - **(SEMVER-MINOR)** **http2**: allow to configure maximum tolerated invalid frames (Denys Otrishko) [#30534](https://github.com/nodejs/node/pull/30534)
+* [[`e92afd998f`](https://github.com/nodejs/node/commit/e92afd998f)] - **(SEMVER-MINOR)** **http2**: replace direct array usage with struct for js\_fields\_ (Denys Otrishko) [#30534](https://github.com/nodejs/node/pull/30534)
+* [[`30ef8e4cbd`](https://github.com/nodejs/node/commit/30ef8e4cbd)] - **http2**: change var to let compact.js (Maria Emmanouil) [#30392](https://github.com/nodejs/node/pull/30392)
+* [[`1a2ed4a5f4`](https://github.com/nodejs/node/commit/1a2ed4a5f4)] - **http2**: core.js replace var with let (Daniel Schuech) [#30403](https://github.com/nodejs/node/pull/30403)
+* [[`f7ca7e6677`](https://github.com/nodejs/node/commit/f7ca7e6677)] - **http2**: replace var with let/const (Paolo Ceschi Berrini) [#30417](https://github.com/nodejs/node/pull/30417)
+* [[`6322611077`](https://github.com/nodejs/node/commit/6322611077)] - **inspector**: properly shut down uv\_async\_t (Anna Henningsen) [#30612](https://github.com/nodejs/node/pull/30612)
+* [[`de3a1c3019`](https://github.com/nodejs/node/commit/de3a1c3019)] - **lib**: enforce use of primordial Number (Sebastien Ahkrin) [#30700](https://github.com/nodejs/node/pull/30700)
+* [[`5a9340d723`](https://github.com/nodejs/node/commit/5a9340d723)] - **lib**: use static Number properties from primordials (Michaël Zasso) [#30686](https://github.com/nodejs/node/pull/30686)
+* [[`892bde635e`](https://github.com/nodejs/node/commit/892bde635e)] - **lib**: enforce use of Boolean from primordials (Michaël Zasso) [#30698](https://github.com/nodejs/node/pull/30698)
+* [[`ae2c7d0b02`](https://github.com/nodejs/node/commit/ae2c7d0b02)] - **lib**: replace Date.now function by primordial DateNow (Tchoupinax) [#30689](https://github.com/nodejs/node/pull/30689)
+* [[`c09e3deac5`](https://github.com/nodejs/node/commit/c09e3deac5)] - **lib**: replace ArrayBuffer.isView by primordial ArrayBuffer (Vincent Dhennin) [#30692](https://github.com/nodejs/node/pull/30692)
+* [[`5ef4dceb95`](https://github.com/nodejs/node/commit/5ef4dceb95)] - **lib**: enforce use of Array from primordials (Michaël Zasso) [#30635](https://github.com/nodejs/node/pull/30635)
+* [[`a4dfe3b7dc`](https://github.com/nodejs/node/commit/a4dfe3b7dc)] - **lib**: flatten access to primordials (Michaël Zasso) [#30610](https://github.com/nodejs/node/pull/30610)
+* [[`b545b91de5`](https://github.com/nodejs/node/commit/b545b91de5)] - **lib**: use let instead of var (Shubham Chaturvedi) [#30375](https://github.com/nodejs/node/pull/30375)
+* [[`5120926337`](https://github.com/nodejs/node/commit/5120926337)] - **lib**: replace var with let/const (jens-cappelle) [#30391](https://github.com/nodejs/node/pull/30391)
+* [[`b18b056d64`](https://github.com/nodejs/node/commit/b18b056d64)] - **lib**: replace var w/ let (Chris Oyler) [#30386](https://github.com/nodejs/node/pull/30386)
+* [[`3796885096`](https://github.com/nodejs/node/commit/3796885096)] - **lib**: replace var with let/const (Tijl Claessens) [#30390](https://github.com/nodejs/node/pull/30390)
+* [[`ffe3040659`](https://github.com/nodejs/node/commit/ffe3040659)] - **lib**: adding perf notes js\_stream\_socket.js (ryan jarvinen) [#30415](https://github.com/nodejs/node/pull/30415)
+* [[`797b938c49`](https://github.com/nodejs/node/commit/797b938c49)] - **lib**: replace var with let (Dennis Saenger) [#30396](https://github.com/nodejs/node/pull/30396)
+* [[`0b64e45e41`](https://github.com/nodejs/node/commit/0b64e45e41)] - **lib**: main\_thread\_only change var to let (matijagaspar) [#30398](https://github.com/nodejs/node/pull/30398)
+* [[`d024630f44`](https://github.com/nodejs/node/commit/d024630f44)] - **lib**: change var to let in stream\_base\_commons (Kyriakos Markakis) [#30426](https://github.com/nodejs/node/pull/30426)
+* [[`3c041edbe7`](https://github.com/nodejs/node/commit/3c041edbe7)] - **lib**: use let instead of var (Semir Ajruli) [#30424](https://github.com/nodejs/node/pull/30424)
+* [[`d277c375fd`](https://github.com/nodejs/node/commit/d277c375fd)] - **lib**: changed var to let (Oliver Belaifa) [#30427](https://github.com/nodejs/node/pull/30427)
+* [[`0fd89cc0f1`](https://github.com/nodejs/node/commit/0fd89cc0f1)] - **lib**: replace var with let/const (Dries Stelten) [#30409](https://github.com/nodejs/node/pull/30409)
+* [[`bdba03e3ed`](https://github.com/nodejs/node/commit/bdba03e3ed)] - **lib**: change var to let (Dimitris Ktistakis) [#30408](https://github.com/nodejs/node/pull/30408)
+* [[`48fef42ca9`](https://github.com/nodejs/node/commit/48fef42ca9)] - **lib**: replace var with let/const (Tembrechts) [#30404](https://github.com/nodejs/node/pull/30404)
+* [[`502173b54e`](https://github.com/nodejs/node/commit/502173b54e)] - **lib**: replace var to let in cli\_table.js (Jing Lin) [#30400](https://github.com/nodejs/node/pull/30400)
+* [[`2cf8a7f117`](https://github.com/nodejs/node/commit/2cf8a7f117)] - **module**: fix specifier resolution algorithm (Rongjian Zhang) [#30574](https://github.com/nodejs/node/pull/30574)
+* [[`be9788bf20`](https://github.com/nodejs/node/commit/be9788bf20)] - **n-api**: detach external ArrayBuffers on env exit (Anna Henningsen) [#30551](https://github.com/nodejs/node/pull/30551)
+* [[`8171cef921`](https://github.com/nodejs/node/commit/8171cef921)] - **(SEMVER-MINOR)** **n-api**: implement napi\_is\_detached\_arraybuffer (Denys Otrishko) [#30613](https://github.com/nodejs/node/pull/30613)
+* [[`cc5875b2e6`](https://github.com/nodejs/node/commit/cc5875b2e6)] - **n-api**: add missed nullptr check in napi\_has\_own\_property (Denys Otrishko) [#30626](https://github.com/nodejs/node/pull/30626)
+* [[`017280e6e2`](https://github.com/nodejs/node/commit/017280e6e2)] - **net**: replaced vars to lets and consts (nathias) [#30401](https://github.com/nodejs/node/pull/30401)
+* [[`56248a827a`](https://github.com/nodejs/node/commit/56248a827a)] - **process**: replace var with let/const (Jesper Ek) [#30382](https://github.com/nodejs/node/pull/30382)
+* [[`5c40b2f9ac`](https://github.com/nodejs/node/commit/5c40b2f9ac)] - **process**: replace vars in per\_thread.js (EmaSuriano) [#30385](https://github.com/nodejs/node/pull/30385)
+* [[`c50bbf58da`](https://github.com/nodejs/node/commit/c50bbf58da)] - **readline**: change var to let (dnlup) [#30435](https://github.com/nodejs/node/pull/30435)
+* [[`b91d22cc8d`](https://github.com/nodejs/node/commit/b91d22cc8d)] - **repl**: fix referrer for dynamic import (Corey Farrell) [#30609](https://github.com/nodejs/node/pull/30609)
+* [[`4e5818a456`](https://github.com/nodejs/node/commit/4e5818a456)] - **repl**: change var to let (Oliver Belaifa) [#30428](https://github.com/nodejs/node/pull/30428)
+* [[`e65ad865c6`](https://github.com/nodejs/node/commit/e65ad865c6)] - **src**: change header file in node\_stat\_watcher.cc (Reza Fatahi) [#29976](https://github.com/nodejs/node/pull/29976)
+* [[`be84ceefb8`](https://github.com/nodejs/node/commit/be84ceefb8)] - **src**: clean up node\_file.h (Anna Henningsen) [#30530](https://github.com/nodejs/node/pull/30530)
+* [[`bccfd124b0`](https://github.com/nodejs/node/commit/bccfd124b0)] - **src**: remove unused variable in node\_dir.cc (gengjiawen) [#30267](https://github.com/nodejs/node/pull/30267)
+* [[`fc11db18fe`](https://github.com/nodejs/node/commit/fc11db18fe)] - **src**: inline SetSNICallback (Anna Henningsen) [#30548](https://github.com/nodejs/node/pull/30548)
+* [[`7bd587ef0c`](https://github.com/nodejs/node/commit/7bd587ef0c)] - **src**: use BaseObjectPtr to store SNI context (Anna Henningsen) [#30548](https://github.com/nodejs/node/pull/30548)
+* [[`8ec0d75de7`](https://github.com/nodejs/node/commit/8ec0d75de7)] - **src**: cleanup unused headers (Alexandre Ferrando) [#30328](https://github.com/nodejs/node/pull/30328)
+* [[`6c249c0982`](https://github.com/nodejs/node/commit/6c249c0982)] - **src**: run native immediates during Environment cleanup (Anna Henningsen) [#30666](https://github.com/nodejs/node/pull/30666)
+* [[`bea25016d1`](https://github.com/nodejs/node/commit/bea25016d1)] - **src**: no SetImmediate from destructor in stream\_pipe code (Anna Henningsen) [#30666](https://github.com/nodejs/node/pull/30666)
+* [[`94357db815`](https://github.com/nodejs/node/commit/94357db815)] - **src**: add more `can_call_into_js()` guards (Anna Henningsen) [#30666](https://github.com/nodejs/node/pull/30666)
+* [[`d54432f974`](https://github.com/nodejs/node/commit/d54432f974)] - **src**: keep object alive in stream\_pipe code (Anna Henningsen) [#30666](https://github.com/nodejs/node/pull/30666)
+* [[`d194c0ff37`](https://github.com/nodejs/node/commit/d194c0ff37)] - **src**: replaced var with let (Aldo Ambrosioni) [#30397](https://github.com/nodejs/node/pull/30397)
+* [[`44f28ea155`](https://github.com/nodejs/node/commit/44f28ea155)] - **src**: fix -Wsign-compare warnings (cjihrig) [#30565](https://github.com/nodejs/node/pull/30565)
+* [[`1916acb3cb`](https://github.com/nodejs/node/commit/1916acb3cb)] - **src**: fix signal handler crash on close (Shelley Vohr) [#30582](https://github.com/nodejs/node/pull/30582)
+* [[`9e9e48bf7e`](https://github.com/nodejs/node/commit/9e9e48bf7e)] - **src**: use uv\_async\_t for WeakRefs (Anna Henningsen) [#30616](https://github.com/nodejs/node/pull/30616)
+* [[`9d8d2e1f45`](https://github.com/nodejs/node/commit/9d8d2e1f45)] - **src,doc**: fix broken links (cjihrig) [#30662](https://github.com/nodejs/node/pull/30662)
+* [[`f135c38796`](https://github.com/nodejs/node/commit/f135c38796)] - **src,doc**: add C++ internals documentation (Anna Henningsen) [#30552](https://github.com/nodejs/node/pull/30552)
+* [[`e968e26dbd`](https://github.com/nodejs/node/commit/e968e26dbd)] - **stream**: improve performance for sync write finishes (Anna Henningsen) [#30710](https://github.com/nodejs/node/pull/30710)
+* [[`49e047f7a1`](https://github.com/nodejs/node/commit/49e047f7a1)] - **test**: add coverage for ERR\_TLS\_INVALID\_PROTOCOL\_VERSION (Rich Trott) [#30741](https://github.com/nodejs/node/pull/30741)
+* [[`81d81a5904`](https://github.com/nodejs/node/commit/81d81a5904)] - **test**: add an indicator `isIBMi` (Xu Meng) [#30714](https://github.com/nodejs/node/pull/30714)
+* [[`37c70ee198`](https://github.com/nodejs/node/commit/37c70ee198)] - **test**: use arrow functions in async-hooks tests (garygsc) [#30137](https://github.com/nodejs/node/pull/30137)
+* [[`b5c7dad95a`](https://github.com/nodejs/node/commit/b5c7dad95a)] - **test**: fix test-benchmark-streams (Rich Trott) [#30757](https://github.com/nodejs/node/pull/30757)
+* [[`1e199ceb71`](https://github.com/nodejs/node/commit/1e199ceb71)] - **test**: move test-http-max-http-headers to parallel (Rich Trott) [#30712](https://github.com/nodejs/node/pull/30712)
+* [[`1918b4e84f`](https://github.com/nodejs/node/commit/1918b4e84f)] - **test**: correct header length subtraction (Rich Trott) [#30712](https://github.com/nodejs/node/pull/30712)
+* [[`1222be81e3`](https://github.com/nodejs/node/commit/1222be81e3)] - **test**: remove unused callback argument (Rich Trott) [#30712](https://github.com/nodejs/node/pull/30712)
+* [[`d69b9b753a`](https://github.com/nodejs/node/commit/d69b9b753a)] - **test**: simplify forEach() usage (Rich Trott) [#30712](https://github.com/nodejs/node/pull/30712)
+* [[`01ab031cca`](https://github.com/nodejs/node/commit/01ab031cca)] - **test**: remove unused callback argument (Rich Trott) [#30712](https://github.com/nodejs/node/pull/30712)
+* [[`93707c4916`](https://github.com/nodejs/node/commit/93707c4916)] - **test**: increase coverage for trace\_events.js (Rich Trott) [#30705](https://github.com/nodejs/node/pull/30705)
+* [[`4800b623ed`](https://github.com/nodejs/node/commit/4800b623ed)] - **test**: use arrow functions in addons tests (garygsc) [#30131](https://github.com/nodejs/node/pull/30131)
+* [[`ba0115fe6f`](https://github.com/nodejs/node/commit/ba0115fe6f)] - **test**: refactor createHook test (Jeny) [#30568](https://github.com/nodejs/node/pull/30568)
+* [[`099d3fdf87`](https://github.com/nodejs/node/commit/099d3fdf87)] - **test**: port worker + buffer test to N-API (Anna Henningsen) [#30551](https://github.com/nodejs/node/pull/30551)
+* [[`83861fb333`](https://github.com/nodejs/node/commit/83861fb333)] - **test**: revert 6d022c13 (Anna Henningsen) [#30708](https://github.com/nodejs/node/pull/30708)
+* [[`a3b758d634`](https://github.com/nodejs/node/commit/a3b758d634)] - **test**: move test-https-server-consumed-timeout to parallel (Rich Trott) [#30677](https://github.com/nodejs/node/pull/30677)
+* [[`00f532f15e`](https://github.com/nodejs/node/commit/00f532f15e)] - **test**: remove unnecessary common.platformTimeout() call (Rich Trott) [#30677](https://github.com/nodejs/node/pull/30677)
+* [[`ecb902f33c`](https://github.com/nodejs/node/commit/ecb902f33c)] - **test**: do not skip test-http-server-consumed-timeout (Rich Trott) [#30677](https://github.com/nodejs/node/pull/30677)
+* [[`49458deb4f`](https://github.com/nodejs/node/commit/49458deb4f)] - **test**: remove unused function argument from http test (Rich Trott) [#30677](https://github.com/nodejs/node/pull/30677)
+* [[`a2f440d326`](https://github.com/nodejs/node/commit/a2f440d326)] - **test**: add logging in case of infinite loop (Rich Trott) [#30649](https://github.com/nodejs/node/pull/30649)
+* [[`3e3ad396bd`](https://github.com/nodejs/node/commit/3e3ad396bd)] - **test**: remove destructuring from test-inspector-contexts (Rich Trott) [#30649](https://github.com/nodejs/node/pull/30649)
+* [[`3571e132a7`](https://github.com/nodejs/node/commit/3571e132a7)] - **test**: check for session.post() errors in test-insepctor-context (Rich Trott) [#30649](https://github.com/nodejs/node/pull/30649)
+* [[`37696320a2`](https://github.com/nodejs/node/commit/37696320a2)] - **test**: add mustCall() to test-inspector-contexts (Rich Trott) [#30649](https://github.com/nodejs/node/pull/30649)
+* [[`0972fa3c16`](https://github.com/nodejs/node/commit/0972fa3c16)] - **test**: add regression test for signal handler removal in exit (Anna Henningsen) [#30589](https://github.com/nodejs/node/pull/30589)
+* [[`5ecfd947e2`](https://github.com/nodejs/node/commit/5ecfd947e2)] - **(SEMVER-MINOR)** **test**: update and harden http2-reset-flood (Denys Otrishko) [#30534](https://github.com/nodejs/node/pull/30534)
+* [[`70d6fa122a`](https://github.com/nodejs/node/commit/70d6fa122a)] - **test**: skip test-domain-error-types in debug mode temporariliy (Rich Trott) [#30629](https://github.com/nodejs/node/pull/30629)
+* [[`949f2ad528`](https://github.com/nodejs/node/commit/949f2ad528)] - **test**: move test-worker-prof to sequential (Rich Trott) [#30628](https://github.com/nodejs/node/pull/30628)
+* [[`d4b61709f1`](https://github.com/nodejs/node/commit/d4b61709f1)] - **test**: dir class initialisation w/o handler (Dmitriy Kikinskiy) [#30313](https://github.com/nodejs/node/pull/30313)
+* [[`60b17b4fe6`](https://github.com/nodejs/node/commit/60b17b4fe6)] - **test**: change object assign by spread operator (poutch) [#30438](https://github.com/nodejs/node/pull/30438)
+* [[`97e627335f`](https://github.com/nodejs/node/commit/97e627335f)] - **test**: use useful message argument in test function (Rich Trott) [#30618](https://github.com/nodejs/node/pull/30618)
+* [[`d651c7dd6b`](https://github.com/nodejs/node/commit/d651c7dd6b)] - **test**: test for minimum ICU version consistency (Richard Lau) [#30608](https://github.com/nodejs/node/pull/30608)
+* [[`dade9069c3`](https://github.com/nodejs/node/commit/dade9069c3)] - **test**: code&learn var to let update (Nazar Malyy) [#30436](https://github.com/nodejs/node/pull/30436)
+* [[`e401e8c8ed`](https://github.com/nodejs/node/commit/e401e8c8ed)] - **test**: change object assign to spread object (poutch) [#30422](https://github.com/nodejs/node/pull/30422)
+* [[`2ecc735c48`](https://github.com/nodejs/node/commit/2ecc735c48)] - **test**: use spread instead of Object.assign (dnlup) [#30419](https://github.com/nodejs/node/pull/30419)
+* [[`d8da9dacab`](https://github.com/nodejs/node/commit/d8da9dacab)] - **test**: changed var to let in module-errors (Jamar Torres) [#30413](https://github.com/nodejs/node/pull/30413)
+* [[`9dab32f340`](https://github.com/nodejs/node/commit/9dab32f340)] - **test**: use spread instead of object.assign (Shubham Chaturvedi) [#30412](https://github.com/nodejs/node/pull/30412)
+* [[`7e7a8165a8`](https://github.com/nodejs/node/commit/7e7a8165a8)] - **test**: replace var with let in pre\_execution.js (Vladimir Adamic) [#30411](https://github.com/nodejs/node/pull/30411)
+* [[`8a9ee48797`](https://github.com/nodejs/node/commit/8a9ee48797)] - **test**: change var to let in test-trace-events (Jon Church) [#30406](https://github.com/nodejs/node/pull/30406)
+* [[`d6a448825c`](https://github.com/nodejs/node/commit/d6a448825c)] - **test**: dns utils replace var (Osmond van Hemert) [#30405](https://github.com/nodejs/node/pull/30405)
+* [[`01e0571e94`](https://github.com/nodejs/node/commit/01e0571e94)] - **test**: test cover cases when trace is empty (telenord) [#30311](https://github.com/nodejs/node/pull/30311)
+* [[`f8dfa2d704`](https://github.com/nodejs/node/commit/f8dfa2d704)] - **test**: switch to object spread in common/benchmark.js (palmires) [#30309](https://github.com/nodejs/node/pull/30309)
+* [[`36671f9bf8`](https://github.com/nodejs/node/commit/36671f9bf8)] - **test**: add common.mustCall() to stream test (Rich Trott) [#30561](https://github.com/nodejs/node/pull/30561)
+* [[`106235fe91`](https://github.com/nodejs/node/commit/106235fe91)] - **test**: move explanatory comment to expected location in file (Rich Trott) [#30561](https://github.com/nodejs/node/pull/30561)
+* [[`081b4e2496`](https://github.com/nodejs/node/commit/081b4e2496)] - **test**: move stream test to parallel (Rich Trott) [#30561](https://github.com/nodejs/node/pull/30561)
+* [[`103d01e057`](https://github.com/nodejs/node/commit/103d01e057)] - **test**: remove string literal as message in strictEqual() in stream test (Rich Trott) [#30561](https://github.com/nodejs/node/pull/30561)
+* [[`ebba3228e2`](https://github.com/nodejs/node/commit/ebba3228e2)] - **test**: use arrow function for callback in stream test (Rich Trott) [#30561](https://github.com/nodejs/node/pull/30561)
+* [[`e122d397c0`](https://github.com/nodejs/node/commit/e122d397c0)] - **test**: replace setTimeout with setImmediate in stream test (Rich Trott) [#30561](https://github.com/nodejs/node/pull/30561)
+* [[`20ee4997f3`](https://github.com/nodejs/node/commit/20ee4997f3)] - **test**: refactor test-dgram-multicast-set-interface-lo.js (Taylor Gagne) [#30536](https://github.com/nodejs/node/pull/30536)
+* [[`7aa1df7076`](https://github.com/nodejs/node/commit/7aa1df7076)] - **tls**: introduce ERR\_TLS\_INVALID\_CONTEXT (Rich Trott) [#30718](https://github.com/nodejs/node/pull/30718)
+* [[`0b0f0237c1`](https://github.com/nodejs/node/commit/0b0f0237c1)] - **tls**: add memory tracking support to SSLWrap (Anna Henningsen) [#30548](https://github.com/nodejs/node/pull/30548)
+* [[`89e2c71b27`](https://github.com/nodejs/node/commit/89e2c71b27)] - **tls**: allow empty subject even with altNames defined (Jason Macgowan) [#22906](https://github.com/nodejs/node/pull/22906)
+* [[`941a91daed`](https://github.com/nodejs/node/commit/941a91daed)] - **tools**: enforce blank line between functions (Rich Trott) [#30696](https://github.com/nodejs/node/pull/30696)
+* [[`5a6f836a15`](https://github.com/nodejs/node/commit/5a6f836a15)] - **tools**: add unified plugin changing links for html docs (Marek Łabuz) [#29946](https://github.com/nodejs/node/pull/29946)
+* [[`84f7b5c752`](https://github.com/nodejs/node/commit/84f7b5c752)] - **tools**: enable more eslint rules (cjihrig) [#30598](https://github.com/nodejs/node/pull/30598)
+* [[`5522467cf5`](https://github.com/nodejs/node/commit/5522467cf5)] - **tools**: update ESLint to 6.7.1 (cjihrig) [#30598](https://github.com/nodejs/node/pull/30598)
+* [[`1f10681496`](https://github.com/nodejs/node/commit/1f10681496)] - **tty**: truecolor check moved before 256 check (Duncan Healy) [#30474](https://github.com/nodejs/node/pull/30474)
+* [[`6a0dd1cbbd`](https://github.com/nodejs/node/commit/6a0dd1cbbd)] - **util**: fix .format() not always calling toString when it should be (Ruben Bridgewater) [#30343](https://github.com/nodejs/node/pull/30343)
+* [[`1040e7222f`](https://github.com/nodejs/node/commit/1040e7222f)] - **util**: fix inspection of errors with tampered name or stack property (Ruben Bridgewater) [#30576](https://github.com/nodejs/node/pull/30576)
+* [[`18e9b56bf6`](https://github.com/nodejs/node/commit/18e9b56bf6)] - **util**: use let instead of var for util/inspect.js (Luciano) [#30399](https://github.com/nodejs/node/pull/30399)
+* [[`9ec53cf5c1`](https://github.com/nodejs/node/commit/9ec53cf5c1)] - **(SEMVER-MINOR)** **wasi**: introduce initial WASI support (cjihrig) [#30258](https://github.com/nodejs/node/pull/30258)
+
+<a id="13.2.0"></a>
+## 2019-11-21, Version 13.2.0 (Current), @MylesBorins
+
+### Notable Changes
+
+* **addons**:
+  * Deprecate one- and two-argument `AtExit()`. Use the three-argument variant of `AtExit()` or `AddEnvironmentCleanupHook()` instead (Anna Henningsen) [#30227](https://github.com/nodejs/node/pull/30227)
+* **child_process,cluster**:
+  * The `serialization` option is added that allows child process IPC to use the V8 serialization API (to e.g., pass through data types like sets or maps) (Anna Henningsen) [#30162](https://github.com/nodejs/node/pull/30162)
+* **deps**:
+  * Update V8 to 7.9
+  * Update `npm` to 6.13.1 (Ruy Adorno) [#30271](https://github.com/nodejs/node/pull/30271)
+* **embedder**:
+  * Exposes the ability to pass cli flags / options through an API as embedder (Shelley Vohr) [#30466](https://github.com/nodejs/node/pull/30466)
+  * Allow adding linked bindings to Environment (Anna Henningsen) [#30274](https://github.com/nodejs/node/pull/30274)
+* **esm**:
+  * Unflag `--experimental-modules` (Guy Bedford) [#29866](https://github.com/nodejs/node/pull/29866)
+* **stream**:
+  * Add `writable.writableCorked` property (Robert Nagy) [#29012](https://github.com/nodejs/node/pull/29012)
+* **worker**:
+  * Allow specifying resource limits (Anna Henningsen) [#26628](https://github.com/nodejs/node/pull/26628)
+* **v8**:
+  * The Serialization API is now stable (Anna Henningsen) [#30234](https://github.com/nodejs/node/pull/30234)
+
+### Commits
+
+* [[`b76c13ec86`](https://github.com/nodejs/node/commit/b76c13ec86)] - **assert**: replace var with let in lib/assert.js (PerfectPan) [#30261](https://github.com/nodejs/node/pull/30261)
+* [[`7f49816e8a`](https://github.com/nodejs/node/commit/7f49816e8a)] - **benchmark**: use let instead of var in async\_hooks (dnlup) [#30470](https://github.com/nodejs/node/pull/30470)
+* [[`0130d2b6e0`](https://github.com/nodejs/node/commit/0130d2b6e0)] - **benchmark**: use let instead of var in assert (dnlup) [#30450](https://github.com/nodejs/node/pull/30450)
+* [[`9cae205f4d`](https://github.com/nodejs/node/commit/9cae205f4d)] - **buffer**: change var to let (Vladislav Botvin) [#30292](https://github.com/nodejs/node/pull/30292)
+* [[`b5198cd3b0`](https://github.com/nodejs/node/commit/b5198cd3b0)] - **(SEMVER-MINOR)** **build**: reset embedder string to "-node.0" (Michaël Zasso) [#30513](https://github.com/nodejs/node/pull/30513)
+* [[`f4f210adc1`](https://github.com/nodejs/node/commit/f4f210adc1)] - **build**: store cache on timed out builds on Travis (Richard Lau) [#30469](https://github.com/nodejs/node/pull/30469)
+* [[`277e5fadf8`](https://github.com/nodejs/node/commit/277e5fadf8)] - **(SEMVER-MINOR)** **build,tools**: update V8 gypfiles for V8 7.9 (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`e51beef8d4`](https://github.com/nodejs/node/commit/e51beef8d4)] - **(SEMVER-MINOR)** **child_process,cluster**: allow using V8 serialization API (Anna Henningsen) [#30162](https://github.com/nodejs/node/pull/30162)
+* [[`6bf0e40bad`](https://github.com/nodejs/node/commit/6bf0e40bad)] - **cluster**: destruct primordials in lib/internal/cluster/worker.js (peze) [#30246](https://github.com/nodejs/node/pull/30246)
+* [[`18ec8a84be`](https://github.com/nodejs/node/commit/18ec8a84be)] - **(SEMVER-MINOR)** **crypto**: add support for IEEE-P1363 DSA signatures (Tobias Nießen) [#29292](https://github.com/nodejs/node/pull/29292)
+* [[`39d0a25ddd`](https://github.com/nodejs/node/commit/39d0a25ddd)] - **crypto**: fix key requirements in asymmetric cipher (Tobias Nießen) [#30249](https://github.com/nodejs/node/pull/30249)
+* [[`8c2e2ce6bf`](https://github.com/nodejs/node/commit/8c2e2ce6bf)] - **crypto**: update root certificates (AshCripps) [#30195](https://github.com/nodejs/node/pull/30195)
+* [[`4f282f52f0`](https://github.com/nodejs/node/commit/4f282f52f0)] - **deps**: patch V8 to 7.9.317.23 (Myles Borins) [#30560](https://github.com/nodejs/node/pull/30560)
+* [[`9b71534d23`](https://github.com/nodejs/node/commit/9b71534d23)] - **deps**: upgrade npm to 6.13.1 (claudiahdz) [#30533](https://github.com/nodejs/node/pull/30533)
+* [[`f17c794faf`](https://github.com/nodejs/node/commit/f17c794faf)] - **(SEMVER-MINOR)** **deps**: patch V8 to be API/ABI compatible with 7.8 (from 7.9) (Michaël Zasso) [#30513](https://github.com/nodejs/node/pull/30513)
+* [[`5a1ad570ea`](https://github.com/nodejs/node/commit/5a1ad570ea)] - **deps**: V8: cherry-pick a7dffcd767be (Christian Clauss) [#30218](https://github.com/nodejs/node/pull/30218)
+* [[`2c6cf902b0`](https://github.com/nodejs/node/commit/2c6cf902b0)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 50031fae736f (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`1e5e8c3922`](https://github.com/nodejs/node/commit/1e5e8c3922)] - **deps**: V8: cherry-pick e5dbc95 (Gabriel Schulhof) [#30130](https://github.com/nodejs/node/pull/30130)
+* [[`9c356ba91c`](https://github.com/nodejs/node/commit/9c356ba91c)] - **(SEMVER-MINOR)** **deps**: V8: backport 5e755c6ee6d3 (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`fe99841c88`](https://github.com/nodejs/node/commit/fe99841c88)] - **(SEMVER-MINOR)** **deps**: V8: backport 07ee86a5a28b (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`5131bbe477`](https://github.com/nodejs/node/commit/5131bbe477)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 777fa98 (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`824e8b6f9b`](https://github.com/nodejs/node/commit/824e8b6f9b)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 7228ef8 (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`4c7acc256a`](https://github.com/nodejs/node/commit/4c7acc256a)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 6b0a953 (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`ebef1b2308`](https://github.com/nodejs/node/commit/ebef1b2308)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick bba5f1f (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`28ca44c724`](https://github.com/nodejs/node/commit/28ca44c724)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick cfe9172 (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`ba4abfd198`](https://github.com/nodejs/node/commit/ba4abfd198)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 3e82c8d (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`2abdcbbe5e`](https://github.com/nodejs/node/commit/2abdcbbe5e)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick f2d92ec (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`46383616e3`](https://github.com/nodejs/node/commit/46383616e3)] - **(SEMVER-MINOR)** **deps**: make v8.h compatible with VS2015 (Joao Reis) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`5bc35732aa`](https://github.com/nodejs/node/commit/5bc35732aa)] - **(SEMVER-MINOR)** **deps**: V8: forward declaration of `Rtl\*FunctionTable` (Refael Ackermann) [#27375](https://github.com/nodejs/node/pull/27375)
+* [[`627a804627`](https://github.com/nodejs/node/commit/627a804627)] - **(SEMVER-MINOR)** **deps**: V8: patch register-arm64.h (Refael Ackermann) [#27375](https://github.com/nodejs/node/pull/27375)
+* [[`13e6b0b82a`](https://github.com/nodejs/node/commit/13e6b0b82a)] - **(SEMVER-MINOR)** **deps**: update V8's postmortem script (Colin Ihrig) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`a4a6565348`](https://github.com/nodejs/node/commit/a4a6565348)] - **(SEMVER-MINOR)** **deps**: update V8's postmortem script (Colin Ihrig) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`4182e3bad7`](https://github.com/nodejs/node/commit/4182e3bad7)] - **(SEMVER-MINOR)** **deps**: patch V8 to run on older XCode versions (Ujjwal Sharma) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`6566c15157`](https://github.com/nodejs/node/commit/6566c15157)] - **(SEMVER-MINOR)** **deps**: V8: silence irrelevant warnings (Michaël Zasso) [#26685](https://github.com/nodejs/node/pull/26685)
+* [[`6018db2ef9`](https://github.com/nodejs/node/commit/6018db2ef9)] - **(SEMVER-MINOR)** **deps**: V8: un-cherry-pick bd019bd (Refael Ackermann) [#26685](https://github.com/nodejs/node/pull/26685)
+* [[`605cb9f0fc`](https://github.com/nodejs/node/commit/605cb9f0fc)] - **(SEMVER-MINOR)** **deps**: update V8 to 7.9.317.22 (Michaël Zasso) [#30513](https://github.com/nodejs/node/pull/30513)
+* [[`b82f63d9ca`](https://github.com/nodejs/node/commit/b82f63d9ca)] - **deps**: update nghttp2 to 1.40.0 (gengjiawen) [#30493](https://github.com/nodejs/node/pull/30493)
+* [[`401d2e9115`](https://github.com/nodejs/node/commit/401d2e9115)] - **deps**: update npm to 6.13.0 (Ruy Adorno) [#30271](https://github.com/nodejs/node/pull/30271)
+* [[`f8ee70c94d`](https://github.com/nodejs/node/commit/f8ee70c94d)] - **dgram**: remove listeners on bind error (Anna Henningsen) [#30210](https://github.com/nodejs/node/pull/30210)
+* [[`0433d7995a`](https://github.com/nodejs/node/commit/0433d7995a)] - **dgram**: reset bind state before emitting error (Anna Henningsen) [#30210](https://github.com/nodejs/node/pull/30210)
+* [[`0f8662d615`](https://github.com/nodejs/node/commit/0f8662d615)] - **dns**: switch var to const/let (Dmitriy Kikinskiy) [#30302](https://github.com/nodejs/node/pull/30302)
+* [[`ab887bd5f6`](https://github.com/nodejs/node/commit/ab887bd5f6)] - **doc**: add mention for using promisify on class methods (Denys Otrishko) [#30355](https://github.com/nodejs/node/pull/30355)
+* [[`9940116aba`](https://github.com/nodejs/node/commit/9940116aba)] - **doc**: explain GIT\_REMOTE\_REF in COLLABORATOR\_GUIDE (Denys Otrishko) [#30371](https://github.com/nodejs/node/pull/30371)
+* [[`027bde563d`](https://github.com/nodejs/node/commit/027bde563d)] - **doc**: fix overriding of prefix option (Luigi Pinca) [#30518](https://github.com/nodejs/node/pull/30518)
+* [[`b7757533bc`](https://github.com/nodejs/node/commit/b7757533bc)] - **doc**: update http.md mention of socket (Jesse O'Connor) [#30155](https://github.com/nodejs/node/pull/30155)
+* [[`7f664e454b`](https://github.com/nodejs/node/commit/7f664e454b)] - **doc**: adds NO\_COLOR to assert doc page (Shobhit Chittora) [#30483](https://github.com/nodejs/node/pull/30483)
+* [[`fba2f9a3d6`](https://github.com/nodejs/node/commit/fba2f9a3d6)] - **doc**: document timed out Travis CI builds (Richard Lau) [#30469](https://github.com/nodejs/node/pull/30469)
+* [[`c40e242b32`](https://github.com/nodejs/node/commit/c40e242b32)] - **doc**: replace const / var with let (Duncan Healy) [#30446](https://github.com/nodejs/node/pull/30446)
+* [[`a93345b7cd`](https://github.com/nodejs/node/commit/a93345b7cd)] - **doc**: update outdated commonjs compat info (Geoffrey Booth) [#30512](https://github.com/nodejs/node/pull/30512)
+* [[`b590533253`](https://github.com/nodejs/node/commit/b590533253)] - **doc**: esm: improve dual package hazard docs (Geoffrey Booth) [#30345](https://github.com/nodejs/node/pull/30345)
+* [[`d631a0a3e4`](https://github.com/nodejs/node/commit/d631a0a3e4)] - **doc**: update 8.x to 10.x in backporting guide (garygsc) [#30481](https://github.com/nodejs/node/pull/30481)
+* [[`7e603bed52`](https://github.com/nodejs/node/commit/7e603bed52)] - **doc**: createRequire can take import.meta.url directly (Geoffrey Booth) [#30495](https://github.com/nodejs/node/pull/30495)
+* [[`e4a296ce8d`](https://github.com/nodejs/node/commit/e4a296ce8d)] - **doc**: add entry to url.parse() changes metadata (Luigi Pinca) [#30348](https://github.com/nodejs/node/pull/30348)
+* [[`64cf00b0b9`](https://github.com/nodejs/node/commit/64cf00b0b9)] - **doc**: simplify text in pull-requests.md (Rich Trott) [#30458](https://github.com/nodejs/node/pull/30458)
+* [[`1e2672012f`](https://github.com/nodejs/node/commit/1e2672012f)] - **doc**: remove "multiple variants" from BUILDING.md (Rich Trott) [#30366](https://github.com/nodejs/node/pull/30366)
+* [[`2d16a74ff9`](https://github.com/nodejs/node/commit/2d16a74ff9)] - **doc**: remove "maintenance is supported by" text in BUILDING.md (Rich Trott) [#30365](https://github.com/nodejs/node/pull/30365)
+* [[`c832565290`](https://github.com/nodejs/node/commit/c832565290)] - **doc**: add lookup to http.request() options (Luigi Pinca) [#30353](https://github.com/nodejs/node/pull/30353)
+* [[`b8afe57e85`](https://github.com/nodejs/node/commit/b8afe57e85)] - **doc**: fix up N-API doc (Michael Dawson) [#30254](https://github.com/nodejs/node/pull/30254)
+* [[`b558d941bd`](https://github.com/nodejs/node/commit/b558d941bd)] - **doc**: fix some recent doc nits (vsemozhetbyt) [#30341](https://github.com/nodejs/node/pull/30341)
+* [[`1133981eac`](https://github.com/nodejs/node/commit/1133981eac)] - **doc**: add link to node-code-ide-configs in testing (Trivikram Kamat) [#24012](https://github.com/nodejs/node/pull/24012)
+* [[`041f3a306e`](https://github.com/nodejs/node/commit/041f3a306e)] - **doc**: update divergent specifier hazard guidance (Geoffrey Booth) [#30051](https://github.com/nodejs/node/pull/30051)
+* [[`085af30361`](https://github.com/nodejs/node/commit/085af30361)] - **doc**: include --experimental-resolve-self in manpage (Guy Bedford) [#29978](https://github.com/nodejs/node/pull/29978)
+* [[`31a3b724f0`](https://github.com/nodejs/node/commit/31a3b724f0)] - **doc**: update GOVERNANCE.md (Rich Trott) [#30259](https://github.com/nodejs/node/pull/30259)
+* [[`15a7032d44`](https://github.com/nodejs/node/commit/15a7032d44)] - **doc**: move inactive Collaborators to emeriti (Rich Trott) [#30243](https://github.com/nodejs/node/pull/30243)
+* [[`fabc489dba`](https://github.com/nodejs/node/commit/fabc489dba)] - **doc**: update examples in writing-tests.md (garygsc) [#30126](https://github.com/nodejs/node/pull/30126)
+* [[`1836eae7a6`](https://github.com/nodejs/node/commit/1836eae7a6)] - **doc, console**: remove non-existant methods from docs (Simon Schick) [#30346](https://github.com/nodejs/node/pull/30346)
+* [[`7ad2e024dd`](https://github.com/nodejs/node/commit/7ad2e024dd)] - **doc,meta**: allow Travis results for doc/comment changes (Rich Trott) [#30330](https://github.com/nodejs/node/pull/30330)
+* [[`2deea28070`](https://github.com/nodejs/node/commit/2deea28070)] - **doc,meta**: remove wait period for npm pull requests (Rich Trott) [#30329](https://github.com/nodejs/node/pull/30329)
+* [[`7e0f90e286`](https://github.com/nodejs/node/commit/7e0f90e286)] - **domain**: rename var to let and const (Maria Stogova) [#30312](https://github.com/nodejs/node/pull/30312)
+* [[`c2c74fc93e`](https://github.com/nodejs/node/commit/c2c74fc93e)] - **encoding**: make TextDecoder handle BOM correctly (Anna Henningsen) [#30132](https://github.com/nodejs/node/pull/30132)
+* [[`f9eab48dd0`](https://github.com/nodejs/node/commit/f9eab48dd0)] - **esm**: disable non-js exts outside package scopes (Guy Bedford) [#30501](https://github.com/nodejs/node/pull/30501)
+* [[`3d8cdf191d`](https://github.com/nodejs/node/commit/3d8cdf191d)] - **esm**: unflag --experimental-modules (Guy Bedford) [#29866](https://github.com/nodejs/node/pull/29866)
+* [[`293e8a2384`](https://github.com/nodejs/node/commit/293e8a2384)] - **esm**: exit the process with an error if loader has an issue (Michaël Zasso) [#30219](https://github.com/nodejs/node/pull/30219)
+* [[`45fd44c6ec`](https://github.com/nodejs/node/commit/45fd44c6ec)] - **fs**: change var to let (Nadya) [#30318](https://github.com/nodejs/node/pull/30318)
+* [[`bb6f944607`](https://github.com/nodejs/node/commit/bb6f944607)] - **fs**: add noop stub for FSWatcher.prototype.start (Lucas Holmquist) [#30160](https://github.com/nodejs/node/pull/30160)
+* [[`4fe62c1620`](https://github.com/nodejs/node/commit/4fe62c1620)] - **http**: revise \_http\_server.js (telenord) [#30279](https://github.com/nodejs/node/pull/30279)
+* [[`62e15a793a`](https://github.com/nodejs/node/commit/62e15a793a)] - **http**: outgoing cork (Robert Nagy) [#29053](https://github.com/nodejs/node/pull/29053)
+* [[`50f9476a44`](https://github.com/nodejs/node/commit/50f9476a44)] - **http**: http\_common rename var to let and const (telenord) [#30288](https://github.com/nodejs/node/pull/30288)
+* [[`b8aceace95`](https://github.com/nodejs/node/commit/b8aceace95)] - **http**: http\_incoming rename var to let and const (telenord) [#30285](https://github.com/nodejs/node/pull/30285)
+* [[`a37ade8648`](https://github.com/nodejs/node/commit/a37ade8648)] - **http**: replace vars with lets and consts in lib/\_http\_agent.js (palmires) [#30301](https://github.com/nodejs/node/pull/30301)
+* [[`e59cc8aad8`](https://github.com/nodejs/node/commit/e59cc8aad8)] - **http,async_hooks**: keep resource object alive from socket (Anna Henningsen) [#30196](https://github.com/nodejs/node/pull/30196)
+* [[`1b84175924`](https://github.com/nodejs/node/commit/1b84175924)] - **http2**: remove duplicated assertIsObject (Yongsheng Zhang) [#30541](https://github.com/nodejs/node/pull/30541)
+* [[`666588143e`](https://github.com/nodejs/node/commit/666588143e)] - **http2**: use custom BaseObject smart pointers (Anna Henningsen) [#30374](https://github.com/nodejs/node/pull/30374)
+* [[`f25b00aaca`](https://github.com/nodejs/node/commit/f25b00aaca)] - **(SEMVER-MINOR)** **https**: add client support for TLS keylog events (Sam Roberts) [#30053](https://github.com/nodejs/node/pull/30053)
+* [[`88da3af6f6`](https://github.com/nodejs/node/commit/88da3af6f6)] - **https**: change var to let in lib/https.js (galina.prokofeva) [#30320](https://github.com/nodejs/node/pull/30320)
+* [[`f15a3b0281`](https://github.com/nodejs/node/commit/f15a3b0281)] - **lib**: replace var with let (David OLIVIER) [#30381](https://github.com/nodejs/node/pull/30381)
+* [[`31a63ab1ec`](https://github.com/nodejs/node/commit/31a63ab1ec)] - **lib**: replace var with let and const in readline.js (VinceOPS) [#30377](https://github.com/nodejs/node/pull/30377)
+* [[`3eeeea419d`](https://github.com/nodejs/node/commit/3eeeea419d)] - **lib**: change var to let/const in internal/querystring.js (Artem Maksimov) [#30286](https://github.com/nodejs/node/pull/30286)
+* [[`f10608655b`](https://github.com/nodejs/node/commit/f10608655b)] - **lib**: change var to let in internal/streams (Kyriakos Markakis) [#30430](https://github.com/nodejs/node/pull/30430)
+* [[`3ce6e15844`](https://github.com/nodejs/node/commit/3ce6e15844)] - **lib**: replace var with let/const (Kenza Houmani) [#30440](https://github.com/nodejs/node/pull/30440)
+* [[`d37d340472`](https://github.com/nodejs/node/commit/d37d340472)] - **lib**: change var to let in string\_decoder (mkdorff) [#30393](https://github.com/nodejs/node/pull/30393)
+* [[`9a1c16eda4`](https://github.com/nodejs/node/commit/9a1c16eda4)] - **lib**: replaced var to let in lib/v8.js (Vadim Gorbachev) [#30305](https://github.com/nodejs/node/pull/30305)
+* [[`3e4a6a5968`](https://github.com/nodejs/node/commit/3e4a6a5968)] - **lib**: change var to let in lib/\_stream\_duplex.js (Ilia Safronov) [#30297](https://github.com/nodejs/node/pull/30297)
+* [[`c7c566023f`](https://github.com/nodejs/node/commit/c7c566023f)] - **module**: reduce circular dependency of internal/modules/cjs/loader (Joyee Cheung) [#30349](https://github.com/nodejs/node/pull/30349)
+* [[`e98d89cef9`](https://github.com/nodejs/node/commit/e98d89cef9)] - **module**: conditional exports with flagged conditions (Guy Bedford) [#29978](https://github.com/nodejs/node/pull/29978)
+* [[`caedcd9ef9`](https://github.com/nodejs/node/commit/caedcd9ef9)] - **module**: fix for empty object in InternalModuleReadJSON (Guy Bedford) [#30256](https://github.com/nodejs/node/pull/30256)
+* [[`66e1adf200`](https://github.com/nodejs/node/commit/66e1adf200)] - **net**: destructure primordials (Guilherme Goncalves) [#30447](https://github.com/nodejs/node/pull/30447)
+* [[`9230ffffd0`](https://github.com/nodejs/node/commit/9230ffffd0)] - **net**: replaced vars to lets and consts (alexahdp) [#30287](https://github.com/nodejs/node/pull/30287)
+* [[`9248c8b960`](https://github.com/nodejs/node/commit/9248c8b960)] - **path**: replace var with let in lib/path.js (peze) [#30260](https://github.com/nodejs/node/pull/30260)
+* [[`e363f8e17f`](https://github.com/nodejs/node/commit/e363f8e17f)] - **process**: add coverage tests for sourceMapFromDataUrl method (Nolik) [#30319](https://github.com/nodejs/node/pull/30319)
+* [[`7b4187413e`](https://github.com/nodejs/node/commit/7b4187413e)] - **process**: make source map getter resistant against prototype tampering (Anna Henningsen) [#30228](https://github.com/nodejs/node/pull/30228)
+* [[`183464a24d`](https://github.com/nodejs/node/commit/183464a24d)] - **querystring**: replace var with let/const (Raoul Jaeckel) [#30429](https://github.com/nodejs/node/pull/30429)
+* [[`7188b9599d`](https://github.com/nodejs/node/commit/7188b9599d)] - **src**: fix -Winconsistent-missing-override warning (Colin Ihrig) [#30549](https://github.com/nodejs/node/pull/30549)
+* [[`966404fd24`](https://github.com/nodejs/node/commit/966404fd24)] - **src**: add file name to 'Module did not self-register' error (Jeremy Apthorp) [#30125](https://github.com/nodejs/node/pull/30125)
+* [[`21dd6019ec`](https://github.com/nodejs/node/commit/21dd6019ec)] - **(SEMVER-MINOR)** **src**: expose ArrayBuffer version of Buffer::New() (Anna Henningsen) [#30476](https://github.com/nodejs/node/pull/30476)
+* [[`2e43686c5a`](https://github.com/nodejs/node/commit/2e43686c5a)] - **src**: mark ArrayBuffers with free callbacks as untransferable (Anna Henningsen) [#30475](https://github.com/nodejs/node/pull/30475)
+* [[`564c18e214`](https://github.com/nodejs/node/commit/564c18e214)] - **src**: remove HandleWrap instances from list once closed (Anna Henningsen) [#30374](https://github.com/nodejs/node/pull/30374)
+* [[`4222f2400a`](https://github.com/nodejs/node/commit/4222f2400a)] - **src**: remove keep alive option from SetImmediate() (Anna Henningsen) [#30374](https://github.com/nodejs/node/pull/30374)
+* [[`940a2972b2`](https://github.com/nodejs/node/commit/940a2972b2)] - **src**: use BaseObjectPtr for keeping channel alive in dns bindings (Anna Henningsen) [#30374](https://github.com/nodejs/node/pull/30374)
+* [[`a2dbadc1ce`](https://github.com/nodejs/node/commit/a2dbadc1ce)] - **src**: introduce custom smart pointers for `BaseObject`s (Anna Henningsen) [#30374](https://github.com/nodejs/node/pull/30374)
+* [[`1a92c88418`](https://github.com/nodejs/node/commit/1a92c88418)] - **src**: migrate off ArrayBuffer::GetContents (Anna Henningsen) [#30339](https://github.com/nodejs/node/pull/30339)
+* [[`0d5de1a20e`](https://github.com/nodejs/node/commit/0d5de1a20e)] - **(SEMVER-MINOR)** **src**: remove custom tracking for SharedArrayBuffers (Anna Henningsen) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`f0ff2ed9d5`](https://github.com/nodejs/node/commit/f0ff2ed9d5)] - **(SEMVER-MINOR)** **src**: update v8abbr.h for V8 update (Colin Ihrig) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`2c8276eda8`](https://github.com/nodejs/node/commit/2c8276eda8)] - **(SEMVER-MINOR)** **src**: expose ability to set options (Shelley Vohr) [#30466](https://github.com/nodejs/node/pull/30466)
+* [[`592d51cb23`](https://github.com/nodejs/node/commit/592d51cb23)] - **src**: enhance feature access `CHECK`s during bootstrap (Anna Henningsen) [#30452](https://github.com/nodejs/node/pull/30452)
+* [[`d648c933b5`](https://github.com/nodejs/node/commit/d648c933b5)] - **src**: lib/internal/timers.js var -\> let/const (Nikolay Krashnikov) [#30314](https://github.com/nodejs/node/pull/30314)
+* [[`70ad676023`](https://github.com/nodejs/node/commit/70ad676023)] - **src**: persist strings that are used multiple times in the environment (Vadim Gorbachev) [#30321](https://github.com/nodejs/node/pull/30321)
+* [[`b744070d74`](https://github.com/nodejs/node/commit/b744070d74)] - **(SEMVER-MINOR)** **src**: allow adding linked bindings to Environment (Anna Henningsen) [#30274](https://github.com/nodejs/node/pull/30274)
+* [[`058a8d5363`](https://github.com/nodejs/node/commit/058a8d5363)] - **src**: do not use `std::function` for `OnScopeLeave` (Anna Henningsen) [#30134](https://github.com/nodejs/node/pull/30134)
+* [[`906d279e69`](https://github.com/nodejs/node/commit/906d279e69)] - **src**: run RunBeforeExitCallbacks as part of EmitBeforeExit (Anna Henningsen) [#30229](https://github.com/nodejs/node/pull/30229)
+* [[`66b3619b4e`](https://github.com/nodejs/node/commit/66b3619b4e)] - **src**: use unique\_ptr for InitializeInspector() (Anna Henningsen) [#30229](https://github.com/nodejs/node/pull/30229)
+* [[`db7deb6e7a`](https://github.com/nodejs/node/commit/db7deb6e7a)] - **src**: make WaitForInspectorDisconnect an exit hook (Anna Henningsen) [#30229](https://github.com/nodejs/node/pull/30229)
+* [[`cd233e3f16`](https://github.com/nodejs/node/commit/cd233e3f16)] - **src**: make EndStartedProfilers an exit hook (Anna Henningsen) [#30229](https://github.com/nodejs/node/pull/30229)
+* [[`8234d04b56`](https://github.com/nodejs/node/commit/8234d04b56)] - **src**: track no of active JS signal handlers (Anna Henningsen) [#30229](https://github.com/nodejs/node/pull/30229)
+* [[`0072a8eddf`](https://github.com/nodejs/node/commit/0072a8eddf)] - **src**: remove AsyncScope and AsyncCallbackScope (Anna Henningsen) [#30236](https://github.com/nodejs/node/pull/30236)
+* [[`e3371f0c93`](https://github.com/nodejs/node/commit/e3371f0c93)] - **src**: use callback scope for main script (Anna Henningsen) [#30236](https://github.com/nodejs/node/pull/30236)
+* [[`cd6d6215cc`](https://github.com/nodejs/node/commit/cd6d6215cc)] - **(SEMVER-MINOR)** **src**: deprecate two- and one-argument AtExit() (Anna Henningsen) [#30227](https://github.com/nodejs/node/pull/30227)
+* [[`5f4535a97c`](https://github.com/nodejs/node/commit/5f4535a97c)] - **src**: make AtExit() callbacks run in reverse order (Anna Henningsen) [#30230](https://github.com/nodejs/node/pull/30230)
+* [[`44968f0edc`](https://github.com/nodejs/node/commit/44968f0edc)] - **src**: remove unimplemented method from node.h (Anna Henningsen) [#30098](https://github.com/nodejs/node/pull/30098)
+* [[`4524c7ad36`](https://github.com/nodejs/node/commit/4524c7ad36)] - **stream**: replace var with let (daern91) [#30379](https://github.com/nodejs/node/pull/30379)
+* [[`41720d78c9`](https://github.com/nodejs/node/commit/41720d78c9)] - **stream**: add writableCorked to Duplex (Anna Henningsen) [#29053](https://github.com/nodejs/node/pull/29053)
+* [[`7cbdac9a71`](https://github.com/nodejs/node/commit/7cbdac9a71)] - **stream**: increase MAX\_HWM (Robert Nagy) [#29938](https://github.com/nodejs/node/pull/29938)
+* [[`c254d7469d`](https://github.com/nodejs/node/commit/c254d7469d)] - **(SEMVER-MINOR)** **stream**: add writableCorked property (Robert Nagy) [#29012](https://github.com/nodejs/node/pull/29012)
+* [[`cb9c64a6e0`](https://github.com/nodejs/node/commit/cb9c64a6e0)] - **test**: move test not requiring internet from internet to parallel (Rich Trott) [#30545](https://github.com/nodejs/node/pull/30545)
+* [[`902c6702df`](https://github.com/nodejs/node/commit/902c6702df)] - **test**: use reserved .invalid TLD for invalid address in test (Rich Trott) [#30545](https://github.com/nodejs/node/pull/30545)
+* [[`92f766bd83`](https://github.com/nodejs/node/commit/92f766bd83)] - **test**: improve assertion message in internet dgram test (Rich Trott) [#30545](https://github.com/nodejs/node/pull/30545)
+* [[`a5f25ecf07`](https://github.com/nodejs/node/commit/a5f25ecf07)] - **test**: cover 'close' method in Dir class (Artem Maksimov) [#30310](https://github.com/nodejs/node/pull/30310)
+* [[`45e57303f3`](https://github.com/nodejs/node/commit/45e57303f3)] - **test**: add test for options validation of createServer (Yongsheng Zhang) [#30541](https://github.com/nodejs/node/pull/30541)
+* [[`6be03981b2`](https://github.com/nodejs/node/commit/6be03981b2)] - **test**: clean up http-set-trailers (Denys Otrishko) [#30522](https://github.com/nodejs/node/pull/30522)
+* [[`2952c5d72b`](https://github.com/nodejs/node/commit/2952c5d72b)] - **(SEMVER-MINOR)** **test**: increase limit again for network space overhead test (Michaël Zasso) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`4131b14011`](https://github.com/nodejs/node/commit/4131b14011)] - **(SEMVER-MINOR)** **test**: update test-postmortem-metadata.js (Colin Ihrig) [#30020](https://github.com/nodejs/node/pull/30020)
+* [[`c464ede598`](https://github.com/nodejs/node/commit/c464ede598)] - **test**: handle undefined default\_configuration (Shelley Vohr) [#30465](https://github.com/nodejs/node/pull/30465)
+* [[`5ec550de02`](https://github.com/nodejs/node/commit/5ec550de02)] - **test**: Change from var to const (Jure Stepisnik) [#30431](https://github.com/nodejs/node/pull/30431)
+* [[`13bac0ac0f`](https://github.com/nodejs/node/commit/13bac0ac0f)] - **test**: changed var to let in test-repl-editor (JL Phillips) [#30443](https://github.com/nodejs/node/pull/30443)
+* [[`0d12e9cc29`](https://github.com/nodejs/node/commit/0d12e9cc29)] - **test**: improve test-fs-open (Artem Maksimov) [#30280](https://github.com/nodejs/node/pull/30280)
+* [[`89bc2526ab`](https://github.com/nodejs/node/commit/89bc2526ab)] - **test**: change var to let (nathias) [#30444](https://github.com/nodejs/node/pull/30444)
+* [[`fa071efea4`](https://github.com/nodejs/node/commit/fa071efea4)] - **test**: changed var to const in test (Kerry Mahne) [#30434](https://github.com/nodejs/node/pull/30434)
+* [[`13a22432fc`](https://github.com/nodejs/node/commit/13a22432fc)] - **test**: var to const in test-repl-multiline.js (SoulMonk) [#30433](https://github.com/nodejs/node/pull/30433)
+* [[`109da52141`](https://github.com/nodejs/node/commit/109da52141)] - **test**: deflake test-http-dump-req-when-res-ends.js (Luigi Pinca) [#30360](https://github.com/nodejs/node/pull/30360)
+* [[`72bbd5cdb0`](https://github.com/nodejs/node/commit/72bbd5cdb0)] - **test**: change var to const in parallel/test-stream-transform-final\* (Kenza Houmani) [#30448](https://github.com/nodejs/node/pull/30448)
+* [[`cd82e4d9d8`](https://github.com/nodejs/node/commit/cd82e4d9d8)] - **test**: replace Object.assign with object spread (Grigoriy Levanov) [#30306](https://github.com/nodejs/node/pull/30306)
+* [[`aec695eb6c`](https://github.com/nodejs/node/commit/aec695eb6c)] - **test**: fix Python unittests in ./test and ./tools (Christian Clauss) [#30340](https://github.com/nodejs/node/pull/30340)
+* [[`ea0c1a67c5`](https://github.com/nodejs/node/commit/ea0c1a67c5)] - **test**: mark test-http-dump-req-when-res-ends as flaky on windows (AshCripps) [#30316](https://github.com/nodejs/node/pull/30316)
+* [[`308f5e4710`](https://github.com/nodejs/node/commit/308f5e4710)] - **test**: fix test-benchmark-cluster (Rich Trott) [#30342](https://github.com/nodejs/node/pull/30342)
+* [[`bb0727a132`](https://github.com/nodejs/node/commit/bb0727a132)] - **test**: do not run release-npm test without crypto (Michaël Zasso) [#30265](https://github.com/nodejs/node/pull/30265)
+* [[`ab5bca379f`](https://github.com/nodejs/node/commit/ab5bca379f)] - **test**: remove AtExit() addon test (Anna Henningsen) [#30275](https://github.com/nodejs/node/pull/30275)
+* [[`de68720908`](https://github.com/nodejs/node/commit/de68720908)] - **test**: deflake test-tls-close-notify.js (Luigi Pinca) [#30202](https://github.com/nodejs/node/pull/30202)
+* [[`8fe684961b`](https://github.com/nodejs/node/commit/8fe684961b)] - ***Revert*** "**test**: test configure ninja" (Anna Henningsen) [#30295](https://github.com/nodejs/node/pull/30295)
+* [[`0dedecc7e0`](https://github.com/nodejs/node/commit/0dedecc7e0)] - **test**: test configure ninja (Patrick Housley) [#30033](https://github.com/nodejs/node/pull/30033)
+* [[`01fa18c99c`](https://github.com/nodejs/node/commit/01fa18c99c)] - **(SEMVER-MINOR)** **tls**: cli option to enable TLS key logging to file (Sam Roberts) [#30055](https://github.com/nodejs/node/pull/30055)
+* [[`5869f2bee7`](https://github.com/nodejs/node/commit/5869f2bee7)] - **tls**: change loop var to let (Xavier Redondo) [#30445](https://github.com/nodejs/node/pull/30445)
+* [[`26a9bdfca3`](https://github.com/nodejs/node/commit/26a9bdfca3)] - **tls**: replace var with let (Daniil Pletnev) [#30308](https://github.com/nodejs/node/pull/30308)
+* [[`bad0b66580`](https://github.com/nodejs/node/commit/bad0b66580)] - **tls**: replace var with let and const (Nolik) [#30299](https://github.com/nodejs/node/pull/30299)
+* [[`ae5aa3ee83`](https://github.com/nodejs/node/commit/ae5aa3ee83)] - **tls**: refactor tls\_wrap.cc (Artem Maksimov) [#30303](https://github.com/nodejs/node/pull/30303)
+* [[`80b1717c0f`](https://github.com/nodejs/node/commit/80b1717c0f)] - **tools**: fix build at non-English windows (Rongjian Zhang) [#30492](https://github.com/nodejs/node/pull/30492)
+* [[`642b0b883f`](https://github.com/nodejs/node/commit/642b0b883f)] - **tools**: update tzdata to 2019c (Albert Wang) [#30356](https://github.com/nodejs/node/pull/30356)
+* [[`3a44adebf8`](https://github.com/nodejs/node/commit/3a44adebf8)] - **tools**: pull xcode\_emulation.py from node-gyp (Christian Clauss) [#30272](https://github.com/nodejs/node/pull/30272)
+* [[`92fa4e0096`](https://github.com/nodejs/node/commit/92fa4e0096)] - **tools**: make doctool work if no internet available (Richard Lau) [#30214](https://github.com/nodejs/node/pull/30214)
+* [[`0f9f18aabe`](https://github.com/nodejs/node/commit/0f9f18aabe)] - **tools**: update certdata.txt (AshCripps) [#30195](https://github.com/nodejs/node/pull/30195)
+* [[`dbdc3818e0`](https://github.com/nodejs/node/commit/dbdc3818e0)] - **tools**: check-imports using utf-8 (Christian Clauss) [#30220](https://github.com/nodejs/node/pull/30220)
+* [[`3b45f8fd9c`](https://github.com/nodejs/node/commit/3b45f8fd9c)] - **url**: replace var with let in lib/url.js (xefimx) [#30281](https://github.com/nodejs/node/pull/30281)
+* [[`35dc84859f`](https://github.com/nodejs/node/commit/35dc84859f)] - **util**: replace var with let (Susana Ferreira) [#30439](https://github.com/nodejs/node/pull/30439)
+* [[`3727a6572b`](https://github.com/nodejs/node/commit/3727a6572b)] - **v8**: mark serdes API as stable (Anna Henningsen) [#30234](https://github.com/nodejs/node/pull/30234)
+* [[`9b11bdb001`](https://github.com/nodejs/node/commit/9b11bdb001)] - **v8**: inspect unserializable objects (Anna Henningsen) [#30167](https://github.com/nodejs/node/pull/30167)
+* [[`2ec40c265a`](https://github.com/nodejs/node/commit/2ec40c265a)] - **(SEMVER-MINOR)** **worker**: allow specifying resource limits (Anna Henningsen) [#26628](https://github.com/nodejs/node/pull/26628)
+
+<a id="13.1.0"></a>
+## 2019-11-05, Version 13.1.0 (Current), @targos
+
+### Notable Changes
+
+* **cli**:
+  * Added a new flag (`--trace-uncaught`) that makes Node.js print the stack
+    trace at the time of throwing uncaught exceptions, rather than at the
+    creation of the `Error` object, if there is any. This is disabled by default
+    because it affects GC behavior (Anna Henningsen) [#30025](https://github.com/nodejs/node/pull/30025).
+* **crypto**:
+  * Added `Hash.prototype.copy()` method. It returns a new `Hash` object with
+    its internal state cloned from the original one (Ben Noordhuis) [#29910](https://github.com/nodejs/node/pull/29910).
+* **dgram**:
+  * Added source-specific multicast support. This adds methods to Datagram
+    sockets to support [RFC 4607](https://tools.ietf.org/html/rfc4607) for IPv4
+    and IPv6 (Lucas Pardue) [#15735](https://github.com/nodejs/node/pull/15735).
+* **fs**:
+  * Added a `bufferSize` option to `fs.opendir()`. It allows to control the
+    number of entries that are buffered internally when reading from the
+    directory (Anna Henningsen) [#30114](https://github.com/nodejs/node/pull/30114).
+* **meta**:
+  * Added [Chengzhong Wu](https://github.com/legendecas) to collaborators [#30115](https://github.com/nodejs/node/pull/30115).
+
+### Commits
+
+* [[`445837851b`](https://github.com/nodejs/node/commit/445837851b)] - **async_hooks**: only emit `after` for AsyncResource if stack not empty (Anna Henningsen) [#30087](https://github.com/nodejs/node/pull/30087)
+* [[`8860bd68b6`](https://github.com/nodejs/node/commit/8860bd68b6)] - **buffer**: improve performance caused by primordials (Jizu Sun) [#30235](https://github.com/nodejs/node/pull/30235)
+* [[`1bded9841c`](https://github.com/nodejs/node/commit/1bded9841c)] - **build**: fix detection of Visual Studio 2017 (Richard Lau) [#30119](https://github.com/nodejs/node/pull/30119)
+* [[`49e7f042f9`](https://github.com/nodejs/node/commit/49e7f042f9)] - **build**: add workaround for WSL (gengjiawen) [#30221](https://github.com/nodejs/node/pull/30221)
+* [[`03827ddf38`](https://github.com/nodejs/node/commit/03827ddf38)] - **build**: allow Python 3.8 (Michaël Zasso) [#30194](https://github.com/nodejs/node/pull/30194)
+* [[`54698113c0`](https://github.com/nodejs/node/commit/54698113c0)] - **build**: find Python syntax errors in dependencies (Christian Clauss) [#30143](https://github.com/nodejs/node/pull/30143)
+* [[`b255688d5f`](https://github.com/nodejs/node/commit/b255688d5f)] - **build**: fix pkg-config search for libnghttp2 (Ben Noordhuis) [#30145](https://github.com/nodejs/node/pull/30145)
+* [[`8980d8c25f`](https://github.com/nodejs/node/commit/8980d8c25f)] - **build**: vcbuild uses default Python, not Py2 (João Reis) [#30091](https://github.com/nodejs/node/pull/30091)
+* [[`cedad02406`](https://github.com/nodejs/node/commit/cedad02406)] - **build**: prefer python 3 over 2 for configure (Sam Roberts) [#30091](https://github.com/nodejs/node/pull/30091)
+* [[`5ba842b8f9`](https://github.com/nodejs/node/commit/5ba842b8f9)] - **build**: python3 support for configure (Rod Vagg) [#30047](https://github.com/nodejs/node/pull/30047)
+* [[`d05f67caef`](https://github.com/nodejs/node/commit/d05f67caef)] - **cli**: whitelist new V8 flag in NODE\_OPTIONS (Shelley Vohr) [#30094](https://github.com/nodejs/node/pull/30094)
+* [[`5ca58646c1`](https://github.com/nodejs/node/commit/5ca58646c1)] - **(SEMVER-MINOR)** **cli**: add --trace-uncaught flag (Anna Henningsen) [#30025](https://github.com/nodejs/node/pull/30025)
+* [[`8b75aabee9`](https://github.com/nodejs/node/commit/8b75aabee9)] - **crypto**: guard with OPENSSL\_NO\_GOST (Shelley Vohr) [#30050](https://github.com/nodejs/node/pull/30050)
+* [[`1d03df4c5e`](https://github.com/nodejs/node/commit/1d03df4c5e)] - **(SEMVER-MINOR)** **crypto**: add Hash.prototype.copy() method (Ben Noordhuis) [#29910](https://github.com/nodejs/node/pull/29910)
+* [[`46c9194ec8`](https://github.com/nodejs/node/commit/46c9194ec8)] - **deps**: V8: cherry-pick a7dffcd767be (Christian Clauss) [#30218](https://github.com/nodejs/node/pull/30218)
+* [[`104bfb9a38`](https://github.com/nodejs/node/commit/104bfb9a38)] - **deps**: V8: cherry-pick e5dbc95 (Gabriel Schulhof) [#30130](https://github.com/nodejs/node/pull/30130)
+* [[`e3124481c2`](https://github.com/nodejs/node/commit/e3124481c2)] - **deps**: update npm to 6.12.1 (Michael Perrotte) [#30164](https://github.com/nodejs/node/pull/30164)
+* [[`f3d00c594d`](https://github.com/nodejs/node/commit/f3d00c594d)] - **deps**: V8: backport 777fa98 (Michaël Zasso) [#30062](https://github.com/nodejs/node/pull/30062)
+* [[`1cfa98c23e`](https://github.com/nodejs/node/commit/1cfa98c23e)] - **deps**: V8: cherry-pick c721203 (Michaël Zasso) [#30065](https://github.com/nodejs/node/pull/30065)
+* [[`0d9ae1b8f6`](https://github.com/nodejs/node/commit/0d9ae1b8f6)] - **deps**: V8: cherry-pick ed40ab1 (Michaël Zasso) [#30064](https://github.com/nodejs/node/pull/30064)
+* [[`a63f7e73c4`](https://github.com/nodejs/node/commit/a63f7e73c4)] - **(SEMVER-MINOR)** **dgram**: add source-specific multicast support (Lucas Pardue) [#15735](https://github.com/nodejs/node/pull/15735)
+* [[`fc407bb555`](https://github.com/nodejs/node/commit/fc407bb555)] - **doc**: add missing hash for header link (Nick Schonning) [#30188](https://github.com/nodejs/node/pull/30188)
+* [[`201a60e6ba`](https://github.com/nodejs/node/commit/201a60e6ba)] - **doc**: linkify `.setupMaster()` in cluster doc (Trivikram Kamat) [#30204](https://github.com/nodejs/node/pull/30204)
+* [[`b7070f315f`](https://github.com/nodejs/node/commit/b7070f315f)] - **doc**: explain http2 aborted event callback (dev-313) [#30179](https://github.com/nodejs/node/pull/30179)
+* [[`f8fb2c06c5`](https://github.com/nodejs/node/commit/f8fb2c06c5)] - **doc**: linkify `.fork()` in cluster documentation (Anna Henningsen) [#30163](https://github.com/nodejs/node/pull/30163)
+* [[`ae81360214`](https://github.com/nodejs/node/commit/ae81360214)] - **doc**: update AUTHORS list (Michaël Zasso) [#30142](https://github.com/nodejs/node/pull/30142)
+* [[`1499a72a1f`](https://github.com/nodejs/node/commit/1499a72a1f)] - **doc**: improve doc Http2Session:Timeout (dev-313) [#30161](https://github.com/nodejs/node/pull/30161)
+* [[`3709b5cc7e`](https://github.com/nodejs/node/commit/3709b5cc7e)] - **doc**: move inactive Collaborators to emeriti (Rich Trott) [#30177](https://github.com/nodejs/node/pull/30177)
+* [[`a48d17900b`](https://github.com/nodejs/node/commit/a48d17900b)] - **doc**: add options description for send APIs (dev-313) [#29868](https://github.com/nodejs/node/pull/29868)
+* [[`dfb4a24695`](https://github.com/nodejs/node/commit/dfb4a24695)] - **doc**: fix an error in resolution algorithm steps (Alex Zherdev) [#29940](https://github.com/nodejs/node/pull/29940)
+* [[`403a648a16`](https://github.com/nodejs/node/commit/403a648a16)] - **doc**: fix numbering in require algorithm (Jan Krems) [#30117](https://github.com/nodejs/node/pull/30117)
+* [[`e4ab6fced1`](https://github.com/nodejs/node/commit/e4ab6fced1)] - **doc**: remove incorrect and outdated example (Tobias Nießen) [#30138](https://github.com/nodejs/node/pull/30138)
+* [[`3c23224a76`](https://github.com/nodejs/node/commit/3c23224a76)] - **doc**: adjust code sample for stream.finished (Cotton Hou) [#29983](https://github.com/nodejs/node/pull/29983)
+* [[`d91d270416`](https://github.com/nodejs/node/commit/d91d270416)] - **doc**: claim NODE\_MODULE\_VERSION=80 for Electron 9 (Samuel Attard) [#30052](https://github.com/nodejs/node/pull/30052)
+* [[`621eaf9ed5`](https://github.com/nodejs/node/commit/621eaf9ed5)] - **doc**: remove "it is important to" phrasing (Rich Trott) [#30108](https://github.com/nodejs/node/pull/30108)
+* [[`9a71091098`](https://github.com/nodejs/node/commit/9a71091098)] - **doc**: revise os.md (Rich Trott) [#30102](https://github.com/nodejs/node/pull/30102)
+* [[`381c6cd0d2`](https://github.com/nodejs/node/commit/381c6cd0d2)] - **doc**: delete "a number of" things in the docs (Rich Trott) [#30103](https://github.com/nodejs/node/pull/30103)
+* [[`45c70a9793`](https://github.com/nodejs/node/commit/45c70a9793)] - **doc**: remove dashes (Rich Trott) [#30101](https://github.com/nodejs/node/pull/30101)
+* [[`ea9d125536`](https://github.com/nodejs/node/commit/ea9d125536)] - **doc**: add legendecas to collaborators (legendecas) [#30115](https://github.com/nodejs/node/pull/30115)
+* [[`39070bbed0`](https://github.com/nodejs/node/commit/39070bbed0)] - **doc**: make YAML matter consistent in crypto.md (Rich Trott) [#30016](https://github.com/nodejs/node/pull/30016)
+* [[`978946e38b`](https://github.com/nodejs/node/commit/978946e38b)] - **doc,meta**: prefer aliases and stubs over Runtime Deprecations (Rich Trott) [#30153](https://github.com/nodejs/node/pull/30153)
+* [[`32a538901f`](https://github.com/nodejs/node/commit/32a538901f)] - **doc,n-api**: sort bottom-of-the-page references (Gabriel Schulhof) [#30124](https://github.com/nodejs/node/pull/30124)
+* [[`07b5584a3f`](https://github.com/nodejs/node/commit/07b5584a3f)] - **(SEMVER-MINOR)** **fs**: add `bufferSize` option to `fs.opendir()` (Anna Henningsen) [#30114](https://github.com/nodejs/node/pull/30114)
+* [[`2505f678ef`](https://github.com/nodejs/node/commit/2505f678ef)] - **http**: support readable hwm in IncomingMessage (Colin Ihrig) [#30135](https://github.com/nodejs/node/pull/30135)
+* [[`f01c5c51b0`](https://github.com/nodejs/node/commit/f01c5c51b0)] - **inspector**: turn platform tasks that outlive Agent into no-ops (Anna Henningsen) [#30031](https://github.com/nodejs/node/pull/30031)
+* [[`050efebf24`](https://github.com/nodejs/node/commit/050efebf24)] - **meta**: use contact\_links instead of issue templates (Michaël Zasso) [#30172](https://github.com/nodejs/node/pull/30172)
+* [[`edfbee3727`](https://github.com/nodejs/node/commit/edfbee3727)] - **module**: resolve self-references (Jan Krems) [#29327](https://github.com/nodejs/node/pull/29327)
+* [[`93b1bb8cb5`](https://github.com/nodejs/node/commit/93b1bb8cb5)] - **n-api,doc**: add info about building n-api addons (Jim Schlight) [#30032](https://github.com/nodejs/node/pull/30032)
+* [[`cc1cd2b3c5`](https://github.com/nodejs/node/commit/cc1cd2b3c5)] - **src**: isolate-\>Dispose() order consistency (Shelley Vohr) [#30181](https://github.com/nodejs/node/pull/30181)
+* [[`a0df91cce1`](https://github.com/nodejs/node/commit/a0df91cce1)] - **(SEMVER-MINOR)** **src**: expose granular SetIsolateUpForNode (Shelley Vohr) [#30150](https://github.com/nodejs/node/pull/30150)
+* [[`ec7b69ff05`](https://github.com/nodejs/node/commit/ec7b69ff05)] - **src**: change env.h includes for forward declarations (Alexandre Ferrando) [#30133](https://github.com/nodejs/node/pull/30133)
+* [[`98c8f76dd1`](https://github.com/nodejs/node/commit/98c8f76dd1)] - **src**: split up InitializeContext (Shelley Vohr) [#30067](https://github.com/nodejs/node/pull/30067)
+* [[`d78e3176dd`](https://github.com/nodejs/node/commit/d78e3176dd)] - **src**: fix crash with SyntheticModule#setExport (Michaël Zasso) [#30062](https://github.com/nodejs/node/pull/30062)
+* [[`fd0aded233`](https://github.com/nodejs/node/commit/fd0aded233)] - **src**: allow inspector without v8 platform (Shelley Vohr) [#30049](https://github.com/nodejs/node/pull/30049)
+* [[`87f14e13b3`](https://github.com/nodejs/node/commit/87f14e13b3)] - **stream**: extract Readable.from in its own file (Matteo Collina) [#30140](https://github.com/nodejs/node/pull/30140)
+* [[`1d9f4278dd`](https://github.com/nodejs/node/commit/1d9f4278dd)] - **test**: use arrow functions for callbacks (Minuk Park) [#30069](https://github.com/nodejs/node/pull/30069)
+* [[`a03809d7dd`](https://github.com/nodejs/node/commit/a03809d7dd)] - **test**: verify npm compatibility with releases (Michaël Zasso) [#30082](https://github.com/nodejs/node/pull/30082)
+* [[`68e4b5a1fc`](https://github.com/nodejs/node/commit/68e4b5a1fc)] - **tools**: fix Python 3 deprecation warning in test.py (Loris Zinsou) [#30208](https://github.com/nodejs/node/pull/30208)
+* [[`348ec693ac`](https://github.com/nodejs/node/commit/348ec693ac)] - **tools**: fix Python 3 syntax error in mac\_tool.py (Christian Clauss) [#30146](https://github.com/nodejs/node/pull/30146)
+* [[`e2fb353df3`](https://github.com/nodejs/node/commit/e2fb353df3)] - **tools**: use print() function in buildbot\_run.py (Christian Clauss) [#30148](https://github.com/nodejs/node/pull/30148)
+* [[`bcbcce5983`](https://github.com/nodejs/node/commit/bcbcce5983)] - **tools**: undefined name opts -\> args in gyptest.py (Christian Clauss) [#30144](https://github.com/nodejs/node/pull/30144)
+* [[`14981f5bba`](https://github.com/nodejs/node/commit/14981f5bba)] - **tools**: git rm -r tools/v8\_gypfiles/broken (Christian Clauss) [#30149](https://github.com/nodejs/node/pull/30149)
+* [[`d549a34597`](https://github.com/nodejs/node/commit/d549a34597)] - **tools**: update ESLint to 6.6.0 (Colin Ihrig) [#30123](https://github.com/nodejs/node/pull/30123)
+* [[`a3757546e8`](https://github.com/nodejs/node/commit/a3757546e8)] - **tools**: doc: improve async workflow of generate.js (Theotime Poisseau) [#30106](https://github.com/nodejs/node/pull/30106)
+
+<a id="13.0.1"></a>
+## 2019-10-23, Version 13.0.1 (Current), @targos
+
+### Notable Changes
+
+* **deps**:
+  * Fixed a bug in npm 6.12.0 where warnings are emitted on Node.js 13.x (Jordan Harband) [#30079](https://github.com/nodejs/node/pull/30079).
+* **esm**:
+  * Changed file extension resolution order of `--es-module-specifier-resolution=node`
+    to match that of the CommonJS loader (Myles Borins) [#29974](https://github.com/nodejs/node/pull/29974).
+
+### Commits
+
+* [[`19a983c615`](https://github.com/nodejs/node/commit/19a983c615)] - **build**: make linter failures fail `test-doc` target (Richard Lau) [#30012](https://github.com/nodejs/node/pull/30012)
+* [[`13f3d6c680`](https://github.com/nodejs/node/commit/13f3d6c680)] - **build**: log the found compiler version if too old (Richard Lau) [#30028](https://github.com/nodejs/node/pull/30028)
+* [[`a25d2fcf8b`](https://github.com/nodejs/node/commit/a25d2fcf8b)] - **build**: make configure --without-snapshot a no-op (Michaël Zasso) [#30021](https://github.com/nodejs/node/pull/30021)
+* [[`e04d0584a5`](https://github.com/nodejs/node/commit/e04d0584a5)] - **build**: default Windows build to Visual Studio 2019 (Michaël Zasso) [#30022](https://github.com/nodejs/node/pull/30022)
+* [[`ccf58835c7`](https://github.com/nodejs/node/commit/ccf58835c7)] - **build**: use python3 to build and test on Travis (Christian Clauss) [#29451](https://github.com/nodejs/node/pull/29451)
+* [[`b92afcd90c`](https://github.com/nodejs/node/commit/b92afcd90c)] - **build**: fix version checks in configure.py (Michaël Zasso) [#29965](https://github.com/nodejs/node/pull/29965)
+* [[`2dc4da0d8b`](https://github.com/nodejs/node/commit/2dc4da0d8b)] - **build**: build benchmark addons like test addons (Richard Lau) [#29995](https://github.com/nodejs/node/pull/29995)
+* [[`2f36976594`](https://github.com/nodejs/node/commit/2f36976594)] - **deps**: npm: patch support for 13.x (Jordan Harband) [#30079](https://github.com/nodejs/node/pull/30079)
+* [[`9d332ab4ce`](https://github.com/nodejs/node/commit/9d332ab4ce)] - **deps**: upgrade to libuv 1.33.1 (Colin Ihrig) [#29996](https://github.com/nodejs/node/pull/29996)
+* [[`89b9115c4d`](https://github.com/nodejs/node/commit/89b9115c4d)] - **doc**: --enable-source-maps and prepareStackTrace are incompatible (Benjamin Coe) [#30046](https://github.com/nodejs/node/pull/30046)
+* [[`35bffcdd9d`](https://github.com/nodejs/node/commit/35bffcdd9d)] - **doc**: join parts of disrupt section in cli.md (vsemozhetbyt) [#30038](https://github.com/nodejs/node/pull/30038)
+* [[`0299767508`](https://github.com/nodejs/node/commit/0299767508)] - **doc**: update collaborator email address (Minwoo Jung) [#30007](https://github.com/nodejs/node/pull/30007)
+* [[`ff4f2999e6`](https://github.com/nodejs/node/commit/ff4f2999e6)] - **doc**: fix tls version typo (akitsu-sanae) [#29984](https://github.com/nodejs/node/pull/29984)
+* [[`62b4ca6e32`](https://github.com/nodejs/node/commit/62b4ca6e32)] - **doc**: clarify readable.unshift null/EOF (Robert Nagy) [#29950](https://github.com/nodejs/node/pull/29950)
+* [[`dc83ff9056`](https://github.com/nodejs/node/commit/dc83ff9056)] - **doc**: remove unused Markdown reference links (Nick Schonning) [#29961](https://github.com/nodejs/node/pull/29961)
+* [[`d80ece68ac`](https://github.com/nodejs/node/commit/d80ece68ac)] - **doc**: re-enable passing remark-lint rule (Nick Schonning) [#29961](https://github.com/nodejs/node/pull/29961)
+* [[`828e171107`](https://github.com/nodejs/node/commit/828e171107)] - **doc**: add server header into the discarded list of http message.headers (Huachao Mao) [#29962](https://github.com/nodejs/node/pull/29962)
+* [[`9729c5da8a`](https://github.com/nodejs/node/commit/9729c5da8a)] - **esm**: modify resolution order for specifier flag (Myles Borins) [#29974](https://github.com/nodejs/node/pull/29974)
+* [[`cfd45ebf94`](https://github.com/nodejs/node/commit/cfd45ebf94)] - **module**: refactor modules bootstrap (Bradley Farias) [#29937](https://github.com/nodejs/node/pull/29937)
+* [[`d561321e4a`](https://github.com/nodejs/node/commit/d561321e4a)] - **src**: remove unnecessary std::endl usage (Daniel Bevenius) [#30003](https://github.com/nodejs/node/pull/30003)
+* [[`ed80c233cd`](https://github.com/nodejs/node/commit/ed80c233cd)] - **src**: make implementing CancelPendingDelayedTasks for platform optional (Anna Henningsen) [#30034](https://github.com/nodejs/node/pull/30034)
+* [[`8fcc039de9`](https://github.com/nodejs/node/commit/8fcc039de9)] - **src**: expose ListNode\<T\>::prev\_ on postmortem metadata (legendecas) [#30027](https://github.com/nodejs/node/pull/30027)
+* [[`0c88dc1932`](https://github.com/nodejs/node/commit/0c88dc1932)] - **src**: fewer uses of NODE\_USE\_V8\_PLATFORM (Shelley Vohr) [#30029](https://github.com/nodejs/node/pull/30029)
+* [[`972144073b`](https://github.com/nodejs/node/commit/972144073b)] - **src**: remove unused iomanip include (Daniel Bevenius) [#30004](https://github.com/nodejs/node/pull/30004)
+* [[`b019ccd59d`](https://github.com/nodejs/node/commit/b019ccd59d)] - **src**: initialize openssl only once (Sam Roberts) [#29999](https://github.com/nodejs/node/pull/29999)
+* [[`3eae670470`](https://github.com/nodejs/node/commit/3eae670470)] - **src**: refine maps parsing for large pages (Gabriel Schulhof) [#29973](https://github.com/nodejs/node/pull/29973)
+* [[`f3712dfe83`](https://github.com/nodejs/node/commit/f3712dfe83)] - **stream**: simplify uint8ArrayToBuffer helper (Luigi Pinca) [#30041](https://github.com/nodejs/node/pull/30041)
+* [[`46aa4810ad`](https://github.com/nodejs/node/commit/46aa4810ad)] - **stream**: remove dead code (Luigi Pinca) [#30041](https://github.com/nodejs/node/pull/30041)
+* [[`f155dfeecb`](https://github.com/nodejs/node/commit/f155dfeecb)] - **test**: expand Worker test for non-shared ArrayBuffer (Anna Henningsen) [#30044](https://github.com/nodejs/node/pull/30044)
+* [[`e110d81b17`](https://github.com/nodejs/node/commit/e110d81b17)] - **test**: fix test runner for Python 3 on Windows (Michaël Zasso) [#30023](https://github.com/nodejs/node/pull/30023)
+* [[`c096f251e4`](https://github.com/nodejs/node/commit/c096f251e4)] - **test**: remove common.skipIfInspectorEnabled() (Rich Trott) [#29993](https://github.com/nodejs/node/pull/29993)
+* [[`b1b8663a23`](https://github.com/nodejs/node/commit/b1b8663a23)] - **test**: add cb error test for fs.close() (Matteo Rossi) [#29970](https://github.com/nodejs/node/pull/29970)
+
+<a id="13.0.0"></a>
+## 2019-10-22, Version 13.0.0 (Current), @BethGriggs
+
+### Notable Changes
+
+* **assert**:
+  * If the validation function passed to `assert.throws()` or `assert.rejects()`
+    returns a value other than `true`, an assertion error will be thrown instead
+    of the original error to highlight the programming mistake (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263).
+  * If a constructor function is passed to validate the instance of errors
+    thrown in `assert.throws()` or `assert.reject()`, an assertion error will be
+    thrown instead of the original error (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263).
+* **build**:
+  * Node.js releases are now built with default full-icu support. This means
+    that all locales supported by ICU are now included and Intl-related APIs may
+    return different values than before (Richard Lau) [#29887](https://github.com/nodejs/node/pull/29887).
+  * The minimum Xcode version supported for macOS was increased to 10. It is
+    still possible to build Node.js with Xcode 8 but this may no longer be the
+    case in a future v13.x release (Michael Dawson) [#29622](https://github.com/nodejs/node/pull/29622).
+* **child_process**:
+  * `ChildProcess._channel` (DEP0129) is now a Runtime deprecation (cjihrig) [#27949](https://github.com/nodejs/node/pull/27949).
+* **console**:
+  * The output `console.timeEnd()` and `console.timeLog()` will now
+    automatically select a suitable time unit instead of always using
+    milliseconds (Xavier Stouder) [#29251](https://github.com/nodejs/node/pull/29251).
+* **deps**:
+  * The V8 engine was updated to version 7.8. This includes performance
+    improvements to object destructuring, memory usage and WebAssembly startup
+    time (Myles Borins) [#29694](https://github.com/nodejs/node/pull/29694).
+* **domain**:
+  * The domain's error handler is now executed with the active domain set to the
+    domain's parent to prevent inner recursion (Julien Gilli) [#26211](https://github.com/nodejs/node/pull/26211).
+* **fs**:
+  * The undocumented method `FSWatcher.prototype.start()` was removed (Lucas Holmquist) [#29905](https://github.com/nodejs/node/pull/29905).
+  * Calling the `open()` method on a `ReadStream` or `WriteStream` now emits a
+    runtime deprecation warning. The methods are supposed to be internal and
+    should not be called by user code (Robert Nagy) [#29061](https://github.com/nodejs/node/pull/29061).
+  * `fs.read/write`, `fs.readSync/writeSync` and `fd.read/write` now accept any
+    safe integer as their `offset` parameter. The value of `offset` is also no
+    longer coerced, so a valid type must be passed to the functions (Zach Bjornson) [#26572](https://github.com/nodejs/node/pull/26572).
+* **http**:
+  * Aborted requests no longer emit the `end` or `error` events after `aborted`
+    (Robert Nagy) [#27984](https://github.com/nodejs/node/pull/27984), [#20077](https://github.com/nodejs/node/pull/20077).
+  * Data will no longer be emitted after a socket error (Robert Nagy) [#28711](https://github.com/nodejs/node/pull/28711).
+  * The legacy HTTP parser (previously available under the
+    `--http-parser=legacy` flag) was removed (Anna Henningsen) [#29589](https://github.com/nodejs/node/pull/29589).
+  * The `host` option for HTTP requests is now validated to be a string value (Giorgos Ntemiris) [#29568](https://github.com/nodejs/node/pull/29568).
+  * The `request.connection` and `response.connection` properties are now
+    runtime deprecated. The equivalent `request.socket` and `response.socket`
+    should be used instead (Robert Nagy) [#29015](https://github.com/nodejs/node/pull/29015).
+* **http, http2**:
+  * The default server timeout was removed (Ali Ijaz Sheikh) [#27558](https://github.com/nodejs/node/pull/27558).
+  * Brought 425 status code name into accordance with RFC 8470. The name changed
+    from "Unordered Collection" to "Too Early" (Sergei Osipov) [#29880](https://github.com/nodejs/node/pull/29880).
+* **lib**:
+  * The `error.errno` property will now always be a number. To get the string
+    value, use `error.code` instead (Joyee Cheung) [#28140](https://github.com/nodejs/node/pull/28140).
+* **module**:
+  * `module.createRequireFromPath()` is deprecated. Use `module.createRequire()`
+    instead (cjihrig) [#27951](https://github.com/nodejs/node/pull/27951).
+* **src**:
+  * Changing the value of `process.env.TZ` will now clear the tz cache. This
+    affects the default time zone used by methods such as
+    `Date.prototype.toString` (Ben Noordhuis) [#20026](https://github.com/nodejs/node/pull/20026).
+* **stream**:
+  * The timing and behavior of streams was consolidated for a number of edge
+    cases. Please look at the individual commits below for more information.
+
+### Semver-Major Commits
+
+* [[`5981fb7faa`](https://github.com/nodejs/node/commit/5981fb7faa)] - **(SEMVER-MAJOR)** **assert**: fix line number calculation after V8 upgrade (Michaël Zasso) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`48d1ea5e7f`](https://github.com/nodejs/node/commit/48d1ea5e7f)] - **(SEMVER-MAJOR)** **assert**: special handle identical error names in instance checks (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263)
+* [[`97c52ca5dc`](https://github.com/nodejs/node/commit/97c52ca5dc)] - **(SEMVER-MAJOR)** **assert**: add more information to AssertionErrors (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263)
+* [[`5700cd17dd`](https://github.com/nodejs/node/commit/5700cd17dd)] - **(SEMVER-MAJOR)** **assert**: do not repeat .throws() code (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263)
+* [[`d47b6786c9`](https://github.com/nodejs/node/commit/d47b6786c9)] - **(SEMVER-MAJOR)** **assert**: wrap validation function errors (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263)
+* [[`0b3242c3ce`](https://github.com/nodejs/node/commit/0b3242c3ce)] - **(SEMVER-MAJOR)** **assert**: fix generatedMessage property (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263)
+* [[`ace3f16917`](https://github.com/nodejs/node/commit/ace3f16917)] - **(SEMVER-MAJOR)** **assert**: improve class instance errors (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263)
+* [[`0376b5b7ba`](https://github.com/nodejs/node/commit/0376b5b7ba)] - **(SEMVER-MAJOR)** **benchmark**: use test/common/tmpdir consistently (João Reis) [#28858](https://github.com/nodejs/node/pull/28858)
+* [[`4885e50f7e`](https://github.com/nodejs/node/commit/4885e50f7e)] - **(SEMVER-MAJOR)** **build**: make full-icu the default for releases (Richard Lau) [#29887](https://github.com/nodejs/node/pull/29887)
+* [[`60a3bd93ce`](https://github.com/nodejs/node/commit/60a3bd93ce)] - **(SEMVER-MAJOR)** **build**: reset embedder string to "-node.0" (Myles Borins) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`9f830f37da`](https://github.com/nodejs/node/commit/9f830f37da)] - **(SEMVER-MAJOR)** **build**: update minimum Xcode version for macOS (Michael Dawson) [#29622](https://github.com/nodejs/node/pull/29622)
+* [[`66eaeac1df`](https://github.com/nodejs/node/commit/66eaeac1df)] - **(SEMVER-MAJOR)** **build**: reset embedder string to "-node.0" (Michaël Zasso) [#28016](https://github.com/nodejs/node/pull/28016)
+* [[`d05668d688`](https://github.com/nodejs/node/commit/d05668d688)] - **(SEMVER-MAJOR)** **child_process**: runtime deprecate \_channel (cjihrig) [#27949](https://github.com/nodejs/node/pull/27949)
+* [[`4f9cd2770a`](https://github.com/nodejs/node/commit/4f9cd2770a)] - **(SEMVER-MAJOR)** **child_process**: simplify spawn argument parsing (cjihrig) [#27854](https://github.com/nodejs/node/pull/27854)
+* [[`66043e1812`](https://github.com/nodejs/node/commit/66043e1812)] - **(SEMVER-MAJOR)** **console**: display timeEnd with suitable time unit (Xavier Stouder) [#29251](https://github.com/nodejs/node/pull/29251)
+* [[`80f2b67367`](https://github.com/nodejs/node/commit/80f2b67367)] - **(SEMVER-MAJOR)** **deps**: patch V8 to 7.8.279.14 (Myles Borins) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`eeafb263f4`](https://github.com/nodejs/node/commit/eeafb263f4)] - **(SEMVER-MAJOR)** **deps**: patch V8 to 7.8.279.12 (Myles Borins) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`ddfc3b0a76`](https://github.com/nodejs/node/commit/ddfc3b0a76)] - **(SEMVER-MAJOR)** **deps**: patch V8 to 7.8.279.10 (Myles Borins) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`8d05991d10`](https://github.com/nodejs/node/commit/8d05991d10)] - **(SEMVER-MAJOR)** **deps**: update V8's postmortem script (cjihrig) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`858602445b`](https://github.com/nodejs/node/commit/858602445b)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick 716875d (Myles Borins) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`f7f6c928c1`](https://github.com/nodejs/node/commit/f7f6c928c1)] - **(SEMVER-MAJOR)** **deps**: update V8 to 7.8.279.9 (Myles Borins) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`84d3243ce9`](https://github.com/nodejs/node/commit/84d3243ce9)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick b33af60 (Michaël Zasso) [#28016](https://github.com/nodejs/node/pull/28016)
+* [[`2dcc3665ab`](https://github.com/nodejs/node/commit/2dcc3665ab)] - **(SEMVER-MAJOR)** **deps**: update V8 to 7.6.303.28 (Michaël Zasso) [#28016](https://github.com/nodejs/node/pull/28016)
+* [[`eef1b5aa0f`](https://github.com/nodejs/node/commit/eef1b5aa0f)] - **(SEMVER-MAJOR)** **doc**: make `AssertionError` a link (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263)
+* [[`8fd7184959`](https://github.com/nodejs/node/commit/8fd7184959)] - **(SEMVER-MAJOR)** **doc**: update assert.throws() examples (Ruben Bridgewater) [#28263](https://github.com/nodejs/node/pull/28263)
+* [[`80d9b1c712`](https://github.com/nodejs/node/commit/80d9b1c712)] - **(SEMVER-MAJOR)** **doc**: wrap long line (cjihrig) [#27951](https://github.com/nodejs/node/pull/27951)
+* [[`43a5170858`](https://github.com/nodejs/node/commit/43a5170858)] - **(SEMVER-MAJOR)** **domain**: error handler runs outside of its domain (Julien Gilli) [#26211](https://github.com/nodejs/node/pull/26211)
+* [[`7eacb74389`](https://github.com/nodejs/node/commit/7eacb74389)] - **(SEMVER-MAJOR)** **fs**: make FSWatcher.start private (Lucas Holmquist) [#29905](https://github.com/nodejs/node/pull/29905)
+* [[`773769df60`](https://github.com/nodejs/node/commit/773769df60)] - **(SEMVER-MAJOR)** **fs**: add runtime deprecate for file stream open() (Robert Nagy) [#29061](https://github.com/nodejs/node/pull/29061)
+* [[`5e3b4d6ed9`](https://github.com/nodejs/node/commit/5e3b4d6ed9)] - **(SEMVER-MAJOR)** **fs**: allow int64 offset in fs.write/writeSync/fd.write (Zach Bjornson) [#26572](https://github.com/nodejs/node/pull/26572)
+* [[`a3c0014e73`](https://github.com/nodejs/node/commit/a3c0014e73)] - **(SEMVER-MAJOR)** **fs**: use IsSafeJsInt instead of IsNumber for ftruncate (Zach Bjornson) [#26572](https://github.com/nodejs/node/pull/26572)
+* [[`0bbda5e5ae`](https://github.com/nodejs/node/commit/0bbda5e5ae)] - **(SEMVER-MAJOR)** **fs**: allow int64 offset in fs.read/readSync/fd.read (Zach Bjornson) [#26572](https://github.com/nodejs/node/pull/26572)
+* [[`eadc3850fe`](https://github.com/nodejs/node/commit/eadc3850fe)] - **(SEMVER-MAJOR)** **fs**: close file descriptor of promisified truncate (João Reis) [#28858](https://github.com/nodejs/node/pull/28858)
+* [[`5f80df8820`](https://github.com/nodejs/node/commit/5f80df8820)] - **(SEMVER-MAJOR)** **http**: do not emit end after aborted (Robert Nagy) [#27984](https://github.com/nodejs/node/pull/27984)
+* [[`e573c39b88`](https://github.com/nodejs/node/commit/e573c39b88)] - **(SEMVER-MAJOR)** **http**: don't emit 'data' after 'error' (Robert Nagy) [#28711](https://github.com/nodejs/node/pull/28711)
+* [[`ac59dc42ed`](https://github.com/nodejs/node/commit/ac59dc42ed)] - **(SEMVER-MAJOR)** **http**: remove legacy parser (Anna Henningsen) [#29589](https://github.com/nodejs/node/pull/29589)
+* [[`2daf883a18`](https://github.com/nodejs/node/commit/2daf883a18)] - **(SEMVER-MAJOR)** **http**: throw if 'host' agent header is not a string value (Giorgos Ntemiris) [#29568](https://github.com/nodejs/node/pull/29568)
+* [[`0daec61b9b`](https://github.com/nodejs/node/commit/0daec61b9b)] - **(SEMVER-MAJOR)** **http**: replace superfluous connection property with getter/setter (Robert Nagy) [#29015](https://github.com/nodejs/node/pull/29015)
+* [[`461bf36d70`](https://github.com/nodejs/node/commit/461bf36d70)] - **(SEMVER-MAJOR)** **http**: fix test where aborted should not be emitted (Robert Nagy) [#20077](https://github.com/nodejs/node/pull/20077)
+* [[`d5577f0395`](https://github.com/nodejs/node/commit/d5577f0395)] - **(SEMVER-MAJOR)** **http**: remove default 'timeout' listener on upgrade (Luigi Pinca) [#26030](https://github.com/nodejs/node/pull/26030)
+* [[`c30ef3cbd2`](https://github.com/nodejs/node/commit/c30ef3cbd2)] - **(SEMVER-MAJOR)** **http, http2**: remove default server timeout (Ali Ijaz Sheikh) [#27558](https://github.com/nodejs/node/pull/27558)
+* [[`4e782c9deb`](https://github.com/nodejs/node/commit/4e782c9deb)] - **(SEMVER-MAJOR)** **http2**: remove security revert flags (Anna Henningsen) [#29141](https://github.com/nodejs/node/pull/29141)
+* [[`41637a530e`](https://github.com/nodejs/node/commit/41637a530e)] - **(SEMVER-MAJOR)** **http2**: remove callback-based padding (Anna Henningsen) [#29144](https://github.com/nodejs/node/pull/29144)
+* [[`91a4cb7175`](https://github.com/nodejs/node/commit/91a4cb7175)] - **(SEMVER-MAJOR)** **lib**: rename validateInteger to validateSafeInteger (Zach Bjornson) [#26572](https://github.com/nodejs/node/pull/26572)
+* [[`1432065e9d`](https://github.com/nodejs/node/commit/1432065e9d)] - **(SEMVER-MAJOR)** **lib**: correct error.errno to always be numeric (Joyee Cheung) [#28140](https://github.com/nodejs/node/pull/28140)
+* [[`702331be90`](https://github.com/nodejs/node/commit/702331be90)] - **(SEMVER-MAJOR)** **lib**: no need to strip BOM or shebang for scripts (Refael Ackermann) [#27375](https://github.com/nodejs/node/pull/27375)
+* [[`e2c0c0c680`](https://github.com/nodejs/node/commit/e2c0c0c680)] - **(SEMVER-MAJOR)** **lib**: rework logic of stripping BOM+Shebang from commonjs (Gus Caplan) [#27768](https://github.com/nodejs/node/pull/27768)
+* [[`14701e539c`](https://github.com/nodejs/node/commit/14701e539c)] - **(SEMVER-MAJOR)** **module**: runtime deprecate createRequireFromPath() (cjihrig) [#27951](https://github.com/nodejs/node/pull/27951)
+* [[`04633eeeb9`](https://github.com/nodejs/node/commit/04633eeeb9)] - **(SEMVER-MAJOR)** **readline**: error on falsy values for callback (Sam Roberts) [#28109](https://github.com/nodejs/node/pull/28109)
+* [[`3eea43af07`](https://github.com/nodejs/node/commit/3eea43af07)] - **(SEMVER-MAJOR)** **repl**: close file descriptor of history file (João Reis) [#28858](https://github.com/nodejs/node/pull/28858)
+* [[`458a38c904`](https://github.com/nodejs/node/commit/458a38c904)] - **(SEMVER-MAJOR)** **src**: bring 425 status code name into accordance with RFC 8470 (Sergei Osipov) [#29880](https://github.com/nodejs/node/pull/29880)
+* [[`7fcc1f7047`](https://github.com/nodejs/node/commit/7fcc1f7047)] - **(SEMVER-MAJOR)** **src**: update NODE\_MODULE\_VERSION to 79 (Myles Borins) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`4b7be335b9`](https://github.com/nodejs/node/commit/4b7be335b9)] - **(SEMVER-MAJOR)** **src**: update NODE\_MODULE\_VERSION to 78 (Michaël Zasso) [#28918](https://github.com/nodejs/node/pull/28918)
+* [[`a0e2c6d284`](https://github.com/nodejs/node/commit/a0e2c6d284)] - **(SEMVER-MAJOR)** **src**: add error codes to errors thrown in C++ (Yaniv Friedensohn) [#27700](https://github.com/nodejs/node/pull/27700)
+* [[`94e980c9d3`](https://github.com/nodejs/node/commit/94e980c9d3)] - **(SEMVER-MAJOR)** **src**: use non-deprecated overload of V8::SetFlagsFromString (Michaël Zasso) [#28016](https://github.com/nodejs/node/pull/28016)
+* [[`655e0dc01a`](https://github.com/nodejs/node/commit/655e0dc01a)] - **(SEMVER-MAJOR)** **src**: update NODE\_MODULE\_VERSION to 77 (Michaël Zasso) [#28016](https://github.com/nodejs/node/pull/28016)
+* [[`e3cd79ef8e`](https://github.com/nodejs/node/commit/e3cd79ef8e)] - **(SEMVER-MAJOR)** **src**: update NODE\_MODULE\_VERSION to 74 (Refael Ackermann) [#27375](https://github.com/nodejs/node/pull/27375)
+* [[`eba348b6ae`](https://github.com/nodejs/node/commit/eba348b6ae)] - **(SEMVER-MAJOR)** **src**: make process.env.TZ setter clear tz cache (Ben Noordhuis) [#20026](https://github.com/nodejs/node/pull/20026)
+* [[`f2061930c8`](https://github.com/nodejs/node/commit/f2061930c8)] - **(SEMVER-MAJOR)** **src**: enable V8's WASM trap handlers (Gus Caplan) [#27246](https://github.com/nodejs/node/pull/27246)
+* [[`f8f6a21580`](https://github.com/nodejs/node/commit/f8f6a21580)] - **(SEMVER-MAJOR)** **stream**: throw unhandled error for readable with autoDestroy (Robert Nagy) [#29806](https://github.com/nodejs/node/pull/29806)
+* [[`f663b31cc2`](https://github.com/nodejs/node/commit/f663b31cc2)] - **(SEMVER-MAJOR)** **stream**: always invoke callback before emitting error (Robert Nagy) [#29293](https://github.com/nodejs/node/pull/29293)
+* [[`aa32e13968`](https://github.com/nodejs/node/commit/aa32e13968)] - **(SEMVER-MAJOR)** **stream**: do not flush destroyed writable (Robert Nagy) [#29028](https://github.com/nodejs/node/pull/29028)
+* [[`ba3be578d8`](https://github.com/nodejs/node/commit/ba3be578d8)] - **(SEMVER-MAJOR)** **stream**: don't emit finish on error (Robert Nagy) [#28979](https://github.com/nodejs/node/pull/28979)
+* [[`db706da235`](https://github.com/nodejs/node/commit/db706da235)] - **(SEMVER-MAJOR)** **stream**: disallow stream methods on finished stream (Robert Nagy) [#28687](https://github.com/nodejs/node/pull/28687)
+* [[`188896ea3e`](https://github.com/nodejs/node/commit/188896ea3e)] - **(SEMVER-MAJOR)** **stream**: do not emit after 'error' (Robert Nagy) [#28708](https://github.com/nodejs/node/pull/28708)
+* [[`4a2bd69db9`](https://github.com/nodejs/node/commit/4a2bd69db9)] - **(SEMVER-MAJOR)** **stream**: fix destroy() behavior (Robert Nagy) [#29058](https://github.com/nodejs/node/pull/29058)
+* [[`824dc576db`](https://github.com/nodejs/node/commit/824dc576db)] - **(SEMVER-MAJOR)** **stream**: simplify `.pipe()` and `.unpipe()` in Readable (Weijia Wang) [#28583](https://github.com/nodejs/node/pull/28583)
+* [[`8ef68e66d0`](https://github.com/nodejs/node/commit/8ef68e66d0)] - **(SEMVER-MAJOR)** **test**: clean tmpdir on process exit (João Reis) [#28858](https://github.com/nodejs/node/pull/28858)
+* [[`d3f20a4725`](https://github.com/nodejs/node/commit/d3f20a4725)] - **(SEMVER-MAJOR)** **test**: use unique tmpdirs for each test (João Reis) [#28858](https://github.com/nodejs/node/pull/28858)
+* [[`174723354e`](https://github.com/nodejs/node/commit/174723354e)] - **(SEMVER-MAJOR)** **tools**: patch V8 to run on older XCode versions (Ujjwal Sharma) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`1676502318`](https://github.com/nodejs/node/commit/1676502318)] - **(SEMVER-MAJOR)** **tools**: update V8 gypfiles (Michaël Zasso) [#29694](https://github.com/nodejs/node/pull/29694)
+* [[`1a25e901b7`](https://github.com/nodejs/node/commit/1a25e901b7)] - **(SEMVER-MAJOR)** **tools**: support full-icu by default (Steven R. Loomis) [#29522](https://github.com/nodejs/node/pull/29522)
+* [[`2664dacf7e`](https://github.com/nodejs/node/commit/2664dacf7e)] - **(SEMVER-MAJOR)** **util**: validate formatWithOptions inspectOptions (Ruben Bridgewater) [#29824](https://github.com/nodejs/node/pull/29824)
+
+### Semver-Minor Commits
+
+* [[`8915b15f8c`](https://github.com/nodejs/node/commit/8915b15f8c)] - **(SEMVER-MINOR)** **http**: add reusedSocket property on client request (themez) [#29715](https://github.com/nodejs/node/pull/29715)
+* [[`6afed1dc85`](https://github.com/nodejs/node/commit/6afed1dc85)] - **(SEMVER-MINOR)** **n-api**: add `napi\_detach\_arraybuffer` (legendecas) [#29768](https://github.com/nodejs/node/pull/29768)
+* [[`c0305af2c4`](https://github.com/nodejs/node/commit/c0305af2c4)] - **(SEMVER-MINOR)** **repl**: check for NODE\_REPL\_EXTERNAL\_MODULE (Gus Caplan) [#29778](https://github.com/nodejs/node/pull/29778)
+
+### Semver-Patch Commits
+
+* [[`e6c389cb3c`](https://github.com/nodejs/node/commit/e6c389cb3c)] - **benchmark**: remove double word "then" in comments (Nick Schonning) [#29823](https://github.com/nodejs/node/pull/29823)
+* [[`1294c7e485`](https://github.com/nodejs/node/commit/1294c7e485)] - **benchmark**: add benchmark for vm.createContext (Joyee Cheung) [#29845](https://github.com/nodejs/node/pull/29845)
+* [[`6f814013f4`](https://github.com/nodejs/node/commit/6f814013f4)] - **build**: fix version checks in gyp files (Ben Noordhuis) [#29931](https://github.com/nodejs/node/pull/29931)
+* [[`6c205aba00`](https://github.com/nodejs/node/commit/6c205aba00)] - **build**: always use strings for compiler version in gyp files (Michaël Zasso) [#29897](https://github.com/nodejs/node/pull/29897)
+* [[`be926c7e21`](https://github.com/nodejs/node/commit/be926c7e21)] - **build**: find Python 3 or Python 2 in configure (cclauss) [#25878](https://github.com/nodejs/node/pull/25878)
+* [[`16f673ebcc`](https://github.com/nodejs/node/commit/16f673ebcc)] - **build**: re-enable openssl arm for arm64 (Edward Vielmetti) [#28180](https://github.com/nodejs/node/pull/28180)
+* [[`204248a0c3`](https://github.com/nodejs/node/commit/204248a0c3)] - **console**: update time formatting (Ruben Bridgewater) [#29629](https://github.com/nodejs/node/pull/29629)
+* [[`c64ed10d80`](https://github.com/nodejs/node/commit/c64ed10d80)] - **crypto**: reject public keys properly (Tobias Nießen) [#29913](https://github.com/nodejs/node/pull/29913)
+* [[`7de5a55710`](https://github.com/nodejs/node/commit/7de5a55710)] - **deps**: patch V8 to 7.8.279.17 (Michaël Zasso) [#29928](https://github.com/nodejs/node/pull/29928)
+* [[`a350d8b780`](https://github.com/nodejs/node/commit/a350d8b780)] - **deps**: V8: cherry-pick 53e62af (Michaël Zasso) [#29898](https://github.com/nodejs/node/pull/29898)
+* [[`6b962ddf01`](https://github.com/nodejs/node/commit/6b962ddf01)] - **deps**: patch V8 to 7.8.279.15 (Michaël Zasso) [#29899](https://github.com/nodejs/node/pull/29899)
+* [[`efa6bead1d`](https://github.com/nodejs/node/commit/efa6bead1d)] - **doc**: add missing deprecation code (cjihrig) [#29969](https://github.com/nodejs/node/pull/29969)
+* [[`c4de76f7a6`](https://github.com/nodejs/node/commit/c4de76f7a6)] - **doc**: update vm.md for link linting (Rich Trott) [#29982](https://github.com/nodejs/node/pull/29982)
+* [[`ed5eaa0495`](https://github.com/nodejs/node/commit/ed5eaa0495)] - **doc**: prepare miscellaneous docs for new markdown lint rules (Rich Trott) [#29963](https://github.com/nodejs/node/pull/29963)
+* [[`039eb56249`](https://github.com/nodejs/node/commit/039eb56249)] - **doc**: fix some recent nits in fs.md (Vse Mozhet Byt) [#29906](https://github.com/nodejs/node/pull/29906)
+* [[`7812a615ab`](https://github.com/nodejs/node/commit/7812a615ab)] - **doc**: fs dir modifications may not be reflected by dir.read (Anna Henningsen) [#29893](https://github.com/nodejs/node/pull/29893)
+* [[`37321a9e11`](https://github.com/nodejs/node/commit/37321a9e11)] - **doc**: add missing deprecation number (cjihrig) [#29183](https://github.com/nodejs/node/pull/29183)
+* [[`791409a9ce`](https://github.com/nodejs/node/commit/791409a9ce)] - **doc**: fixup changelog for v10.16.3 (Andrew Hughes) [#29159](https://github.com/nodejs/node/pull/29159)
+* [[`02b3722b30`](https://github.com/nodejs/node/commit/02b3722b30)] - **doc,meta**: reduce npm PR wait period to one week (Rich Trott) [#29922](https://github.com/nodejs/node/pull/29922)
+* [[`fce1a5198a`](https://github.com/nodejs/node/commit/fce1a5198a)] - **domain**: do not import util for a simple type check (Ruben Bridgewater) [#29825](https://github.com/nodejs/node/pull/29825)
+* [[`b798f64566`](https://github.com/nodejs/node/commit/b798f64566)] - **esm**: unflag --experimental-exports (Guy Bedford) [#29867](https://github.com/nodejs/node/pull/29867)
+* [[`5c93aab278`](https://github.com/nodejs/node/commit/5c93aab278)] - **fs**: buffer dir entries in opendir() (Anna Henningsen) [#29893](https://github.com/nodejs/node/pull/29893)
+* [[`624fa4147a`](https://github.com/nodejs/node/commit/624fa4147a)] - **http2**: fix file close error condition at respondWithFd (Anna Henningsen) [#29884](https://github.com/nodejs/node/pull/29884)
+* [[`d5c3837061`](https://github.com/nodejs/node/commit/d5c3837061)] - **lib**: remove the comment of base64 validation (Maledong) [#29201](https://github.com/nodejs/node/pull/29201)
+* [[`3238232fc4`](https://github.com/nodejs/node/commit/3238232fc4)] - **lib**: rename validateSafeInteger to validateInteger (cjihrig) [#29184](https://github.com/nodejs/node/pull/29184)
+* [[`aca1c283bd`](https://github.com/nodejs/node/commit/aca1c283bd)] - **module**: warn on require of .js inside type: module (Guy Bedford) [#29909](https://github.com/nodejs/node/pull/29909)
+* [[`1447a79dc4`](https://github.com/nodejs/node/commit/1447a79dc4)] - **net**: treat ENOTCONN at shutdown as success (Anna Henningsen) [#29912](https://github.com/nodejs/node/pull/29912)
+* [[`4ca61f40fe`](https://github.com/nodejs/node/commit/4ca61f40fe)] - **process**: add lineLength to source-map-cache (bcoe) [#29863](https://github.com/nodejs/node/pull/29863)
+* [[`545f7282d1`](https://github.com/nodejs/node/commit/545f7282d1)] - **src**: implement v8 host weakref hooks (Gus Caplan) [#29874](https://github.com/nodejs/node/pull/29874)
+* [[`53ca0b9ae1`](https://github.com/nodejs/node/commit/53ca0b9ae1)] - **src**: render N-API weak callbacks as cleanup hooks (Gabriel Schulhof) [#28428](https://github.com/nodejs/node/pull/28428)
+* [[`075c7ebeb5`](https://github.com/nodejs/node/commit/075c7ebeb5)] - **src**: fix largepages regression (Gabriel Schulhof) [#29914](https://github.com/nodejs/node/pull/29914)
+* [[`179f4232ed`](https://github.com/nodejs/node/commit/179f4232ed)] - **src**: remove unused using declarations in worker.cc (Daniel Bevenius) [#29883](https://github.com/nodejs/node/pull/29883)
+* [[`264cb79bc2`](https://github.com/nodejs/node/commit/264cb79bc2)] - **src**: silence compiler warning node\_process\_methods (Daniel Bevenius) [#28261](https://github.com/nodejs/node/pull/28261)
+* [[`89b32378c8`](https://github.com/nodejs/node/commit/89b32378c8)] - **src**: forbid reset\_handler for SIGSEGV handling (Anna Henningsen) [#27775](https://github.com/nodejs/node/pull/27775)
+* [[`e256204776`](https://github.com/nodejs/node/commit/e256204776)] - **src**: reset SIGSEGV handler before crashing (Anna Henningsen) [#27775](https://github.com/nodejs/node/pull/27775)
+* [[`e6b3ec3d3c`](https://github.com/nodejs/node/commit/e6b3ec3d3c)] - **src**: do not use posix feature macro in node.h (Anna Henningsen) [#27775](https://github.com/nodejs/node/pull/27775)
+* [[`6e796581fc`](https://github.com/nodejs/node/commit/6e796581fc)] - **src**: remove freebsd SA\_RESETHAND workaround (Ben Noordhuis) [#27780](https://github.com/nodejs/node/pull/27780)
+* [[`8709a408d2`](https://github.com/nodejs/node/commit/8709a408d2)] - **stream**: use more accurate end-of-stream writable and readable detection (Robert Nagy) [#29409](https://github.com/nodejs/node/pull/29409)
+* [[`698a29420f`](https://github.com/nodejs/node/commit/698a29420f)] - **stream**: fix readable state `awaitDrain` increase in recursion (ran) [#27572](https://github.com/nodejs/node/pull/27572)
+* [[`033037cec9`](https://github.com/nodejs/node/commit/033037cec9)] - **stream**: avoid unecessary nextTick (Robert Nagy) [#29194](https://github.com/nodejs/node/pull/29194)
+* [[`f4f856b238`](https://github.com/nodejs/node/commit/f4f856b238)] - **test**: fix flaky doctool and test (Rich Trott) [#29979](https://github.com/nodejs/node/pull/29979)
+* [[`7991b57cfd`](https://github.com/nodejs/node/commit/7991b57cfd)] - **test**: fix fs benchmark test (Rich Trott) [#29967](https://github.com/nodejs/node/pull/29967)
+* [[`2bb93e1108`](https://github.com/nodejs/node/commit/2bb93e1108)] - **test**: set LC\_ALL to known good value (Ben Noordhuis) [#28096](https://github.com/nodejs/node/pull/28096)
+* [[`039cfdc838`](https://github.com/nodejs/node/commit/039cfdc838)] - **test**: add addon tests for `RegisterSignalHandler()` (Anna Henningsen) [#27775](https://github.com/nodejs/node/pull/27775)
+* [[`90b5f1b107`](https://github.com/nodejs/node/commit/90b5f1b107)] - **tools**: update remark-preset-lint-node to 1.10.1 (Rich Trott) [#29982](https://github.com/nodejs/node/pull/29982)
+* [[`ea3d5ff785`](https://github.com/nodejs/node/commit/ea3d5ff785)] - **tools**: fix test runner in presence of NODE\_REPL\_EXTERNAL\_MODULE (Gus Caplan) [#29956](https://github.com/nodejs/node/pull/29956)
+* [[`8728f8660a`](https://github.com/nodejs/node/commit/8728f8660a)] - **tools**: fix GYP MSVS solution generator for Python 3 (Michaël Zasso) [#29897](https://github.com/nodejs/node/pull/29897)
+* [[`66b953207d`](https://github.com/nodejs/node/commit/66b953207d)] - **tools**: port Python 3 compat patches from node-gyp to gyp (Michaël Zasso) [#29897](https://github.com/nodejs/node/pull/29897)
+* [[`a0c6cf8eb1`](https://github.com/nodejs/node/commit/a0c6cf8eb1)] - **tools**: update remark-preset-lint-node to 1.10.0 (Rich Trott) [#29594](https://github.com/nodejs/node/pull/29594)
+* [[`1e01f3f022`](https://github.com/nodejs/node/commit/1e01f3f022)] - **tools**: apply more stringent blank-line linting for markdown files (Rich Trott) [#29447](https://github.com/nodejs/node/pull/29447)
+* [[`f9caee986c`](https://github.com/nodejs/node/commit/f9caee986c)] - **vm**: add Synthetic modules (Gus Caplan) [#29864](https://github.com/nodejs/node/pull/29864)
diff --git a/doc/changelogs/CHANGELOG_V14.md b/doc/changelogs/CHANGELOG_V14.md
new file mode 100644
index 0000000000000000000000000000000000000000..b666394626c7cf8caf3a0928efb25650e4bd0185
--- /dev/null
+++ b/doc/changelogs/CHANGELOG_V14.md
@@ -0,0 +1,4219 @@
+# Node.js 14 ChangeLog
+
+<!--lint disable prohibited-strings-->
+<!--lint disable maximum-line-length-->
+<!--lint disable no-literal-urls-->
+
+<table>
+<tr>
+<th>LTS 'Fermium'</th>
+<th>Current</th>
+</tr>
+<tr>
+<td valign="top">
+<a href="#14.18.3">14.18.3</a><br/>
+<a href="#14.18.2">14.18.2</a><br/>
+<a href="#14.18.1">14.18.1</a><br/>
+<a href="#14.18.0">14.18.0</a><br/>
+<a href="#14.17.6">14.17.6</a><br/>
+<a href="#14.17.5">14.17.5</a><br/>
+<a href="#14.17.4">14.17.4</a><br/>
+<a href="#14.17.3">14.17.3</a><br/>
+<a href="#14.17.2">14.17.2</a><br/>
+<a href="#14.17.1">14.17.1</a><br/>
+<a href="#14.17.0">14.17.0</a><br/>
+<a href="#14.16.1">14.16.1</a><br/>
+<a href="#14.16.0">14.16.0</a><br/>
+<a href="#14.15.5">14.15.5</a><br/>
+<a href="#14.15.4">14.15.4</a><br/>
+<a href="#14.15.3">14.15.3</a><br/>
+<a href="#14.15.2">14.15.2</a><br/>
+<a href="#14.15.1">14.15.1</a><br/>
+<a href="#14.15.0">14.15.0</a><br/>
+</td>
+<td valign="top">
+<a href="#14.14.0">14.14.0</a><br/>
+<a href="#14.13.1">14.13.1</a><br/>
+<a href="#14.13.0">14.13.0</a><br/>
+<a href="#14.12.0">14.12.0</a><br/>
+<a href="#14.11.0">14.11.0</a><br/>
+<a href="#14.10.1">14.10.1</a><br/>
+<a href="#14.10.0">14.10.0</a><br/>
+<a href="#14.9.0">14.9.0</a><br/>
+<a href="#14.8.0">14.8.0</a><br/>
+<a href="#14.7.0">14.7.0</a><br/>
+<a href="#14.6.0">14.6.0</a><br/>
+<a href="#14.5.0">14.5.0</a><br/>
+<a href="#14.4.0">14.4.0</a><br/>
+<a href="#14.3.0">14.3.0</a><br/>
+<a href="#14.2.0">14.2.0</a><br/>
+<a href="#14.1.0">14.1.0</a><br/>
+<a href="#14.0.0">14.0.0</a><br/>
+</td>
+</tr>
+</table>
+
+* Other Versions
+  * [13.x](CHANGELOG_V13.md)
+  * [12.x](CHANGELOG_V12.md)
+  * [11.x](CHANGELOG_V11.md)
+  * [10.x](CHANGELOG_V10.md)
+  * [9.x](CHANGELOG_V9.md)
+  * [8.x](CHANGELOG_V8.md)
+  * [7.x](CHANGELOG_V7.md)
+  * [6.x](CHANGELOG_V6.md)
+  * [5.x](CHANGELOG_V5.md)
+  * [4.x](CHANGELOG_V4.md)
+  * [0.12.x](CHANGELOG_V012.md)
+  * [0.10.x](CHANGELOG_V010.md)
+  * [io.js](CHANGELOG_IOJS.md)
+  * [Archive](CHANGELOG_ARCHIVE.md)
+
+<a id="14.18.3"></a>
+## 2022-01-10, Version 14.18.3 'Fermium' (LTS), @richardlau
+
+This is a security release.
+
+### Notable changes
+
+#### Improper handling of URI Subject Alternative Names (Medium)(CVE-2021-44531)
+
+Accepting arbitrary Subject Alternative Name (SAN) types, unless a PKI is specifically defined to use a particular SAN type, can result in bypassing name-constrained intermediates. Node.js was accepting URI SAN types, which PKIs are often not defined to use. Additionally, when a protocol allows URI SANs, Node.js did not match the URI correctly.
+
+Versions of Node.js with the fix for this disable the URI SAN type when checking a certificate against a hostname. This behavior can be reverted through the `--security-revert` command-line option.
+
+More details will be available at [CVE-2021-44531](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531) after publication.
+
+#### Certificate Verification Bypass via String Injection (Medium)(CVE-2021-44532)
+
+Node.js converts SANs (Subject Alternative Names) to a string format. It uses this string to check peer certificates against hostnames when validating connections. The string format was subject to an injection vulnerability when name constraints were used within a certificate chain, allowing the bypass of these name constraints.
+
+Versions of Node.js with the fix for this escape SANs containing the problematic characters in order to prevent the injection. This behavior can be reverted through the `--security-revert` command-line option.
+
+More details will be available at [CVE-2021-44532](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44532) after publication.
+
+#### Incorrect handling of certificate subject and issuer fields (Medium)(CVE-2021-44533)
+
+Node.js did not handle multi-value Relative Distinguished Names correctly. Attackers could craft certificate subjects containing a single-value Relative Distinguished Name that would be interpreted as a multi-value Relative Distinguished Name, for example, in order to inject a Common Name that would allow bypassing the certificate subject verification.
+
+Affected versions of Node.js do not accept multi-value Relative Distinguished Names and are thus not vulnerable to such attacks themselves. However, third-party code that uses node's ambiguous presentation of certificate subjects may be vulnerable.
+
+More details will be available at [CVE-2021-44533](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44533) after publication.
+
+#### Prototype pollution via `console.table` properties (Low)(CVE-2022-21824)
+
+Due to the formatting logic of the `console.table()` function it was not safe to allow user controlled input to be passed to the `properties` parameter while simultaneously passing a plain object with at least one property as the first parameter, which could be `__proto__`. The prototype pollution has very limited control, in that it only allows an empty string to be assigned numerical keys of the object prototype.
+
+Versions of Node.js with the fix for this use a null protoype for the object these properties are being assigned to.
+
+More details will be available at [CVE-2022-21824](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-21824) after publication.
+
+Thanks to Patrik Oldsberg (rugvip) for reporting this vulnerability.
+
+### Commits
+
+* \[[`e2a74f3c99`](https://github.com/nodejs/node/commit/e2a74f3c99)] - **console**: fix prototype pollution via console.table (Tobias Nießen) [nodejs-private/node-private#307](https://github.com/nodejs-private/node-private/pull/307)
+* \[[`df1b2c33f6`](https://github.com/nodejs/node/commit/df1b2c33f6)] - **crypto,tls**: implement safe x509 GeneralName format (Tobias Nießen and Akshay Kumar) [nodejs-private/node-private#300](https://github.com/nodejs-private/node-private/pull/300)
+* \[[`9f2c52617f`](https://github.com/nodejs/node/commit/9f2c52617f)] - **src**: add cve reverts and associated tests (Michael Dawson and Akshay Kumar) [nodejs-private/node-private#300](https://github.com/nodejs-private/node-private/pull/300)
+* \[[`b14be42518`](https://github.com/nodejs/node/commit/b14be42518)] - **src**: remove unused x509 functions (Tobias Nießen and Akshay Kumar) [nodejs-private/node-private#300](https://github.com/nodejs-private/node-private/pull/300)
+* \[[`83d8f880bb`](https://github.com/nodejs/node/commit/83d8f880bb)] - **tls**: fix handling of x509 subject and issuer (Tobias Nießen and Akshay Kumar) [nodejs-private/node-private#300](https://github.com/nodejs-private/node-private/pull/300)
+* \[[`461a0c674b`](https://github.com/nodejs/node/commit/461a0c674b)] - **tls**: drop support for URI alternative names (Tobias Nießen and Akshay Kumar) [nodejs-private/node-private#300](https://github.com/nodejs-private/node-private/pull/300)
+
+<a id="14.18.2"></a>
+## 2021-11-30, Version 14.18.2 'Fermium' (LTS), @richardlau
+
+### Notable changes
+
+This release contains a c-ares update to fix a regression introduced in
+Node.js 14.17.5 resolving CNAME records containing underscores
+[#39780](https://github.com/nodejs/node/issues/39780).
+
+Also included are commits to allow Node.js 14 to continue to build and
+pass tests on our Jenkins CI, including adding Python 3.10 to the list
+of allowable Python versions for building.
+
+### Commits
+
+* \[[`7923c61a62`](https://github.com/nodejs/node/commit/7923c61a62)] - **build**: pin build-docs workflow to Node.js 14 (Richard Lau) [#40939](https://github.com/nodejs/node/pull/40939)
+* \[[`da356128fb`](https://github.com/nodejs/node/commit/da356128fb)] - **build**: support Python 3.10.0 (FrankQiu) [#40296](https://github.com/nodejs/node/pull/40296)
+* \[[`9c3a85d279`](https://github.com/nodejs/node/commit/9c3a85d279)] - **deps**: update c-ares to 1.18.1 (Richard Lau) [#40660](https://github.com/nodejs/node/pull/40660)
+* \[[`cd7c340545`](https://github.com/nodejs/node/commit/cd7c340545)] - **deps**: V8: patch jinja2 for Python 3.10 compat (Michaël Zasso) [#40296](https://github.com/nodejs/node/pull/40296)
+* \[[`6330d435f5`](https://github.com/nodejs/node/commit/6330d435f5)] - **doc**: mark Node.js 10 as End-of-Life (Richard Lau) [#38482](https://github.com/nodejs/node/pull/38482)
+* \[[`8ca082ec71`](https://github.com/nodejs/node/commit/8ca082ec71)] - **doc**: fix CJS-ESM selector in Safari (Bradley Farias) [#40135](https://github.com/nodejs/node/pull/40135)
+* \[[`92490d1c89`](https://github.com/nodejs/node/commit/92490d1c89)] - **doc**: add macOS arm64 experimental status (Michael Rienstra) [#40127](https://github.com/nodejs/node/pull/40127)
+* \[[`8894bdd4d8`](https://github.com/nodejs/node/commit/8894bdd4d8)] - **lib**: fix regular expression to detect \`/\` and \`\\\` (Francesco Trotta) [#40325](https://github.com/nodejs/node/pull/40325)
+* \[[`704989b698`](https://github.com/nodejs/node/commit/704989b698)] - **test**: deflake child-process-pipe-dataflow (Luigi Pinca) [#40838](https://github.com/nodejs/node/pull/40838)
+* \[[`df401cd346`](https://github.com/nodejs/node/commit/df401cd346)] - **test**: update upload.zip to be uncorrupted (Greg Ziskind) [#37294](https://github.com/nodejs/node/pull/37294)
+* \[[`aa947f7dbf`](https://github.com/nodejs/node/commit/aa947f7dbf)] - **tools**: add script to update c-ares (Richard Lau) [#40660](https://github.com/nodejs/node/pull/40660)
+* \[[`6b7b2bba41`](https://github.com/nodejs/node/commit/6b7b2bba41)] - **tools**: patch jinja2 for Python 3.10 compat (Michaël Zasso) [#40296](https://github.com/nodejs/node/pull/40296)
+* \[[`39583f77d8`](https://github.com/nodejs/node/commit/39583f77d8)] - **worker**: avoid potential deadlock on NearHeapLimit (Santiago Gimeno) [#38403](https://github.com/nodejs/node/pull/38403)
+
+<a id="14.18.1"></a>
+## 2021-10-12, Version 14.18.1 'Fermium' (LTS), @danielleadams
+
+This is a security release.
+
+### Notable changes
+
+* **CVE-2021-22959**: HTTP Request Smuggling due to spaced in headers (Medium)
+  * The http parser accepts requests with a space (SP) right after the header name before the colon. This can lead to HTTP Request Smuggling (HRS). More details will be available at [CVE-2021-22959](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22959) after publication.
+* **CVE-2021-22960**: HTTP Request Smuggling when parsing the body (Medium)
+  * The parse ignores chunk extensions when parsing the body of chunked requests. This leads to HTTP Request Smuggling (HRS) under certain conditions. More details will be available at [CVE-2021-22960](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22960) after publication.
+
+### Commits
+
+* [[`8c254ca7e4`](https://github.com/nodejs/node/commit/8c254ca7e4)] - **deps**: update llhttp to 2.1.4 (Fedor Indutny) [nodejs-private/node-private#285](https://github.com/nodejs-private/node-private/pull/285)
+* [[`9b92ae2499`](https://github.com/nodejs/node/commit/9b92ae2499)] - **http**: add regression test for smuggling content length (Matteo Collina) [nodejs-private/node-private#285](https://github.com/nodejs-private/node-private/pull/285)
+* [[`f467539719`](https://github.com/nodejs/node/commit/f467539719)] - **http**: add regression test for chunked smuggling (Matteo Collina) [nodejs-private/node-private#285](https://github.com/nodejs-private/node-private/pull/285)
+
+<a id="14.18.0"></a>
+## 2021-09-28, Version 14.18.0 'Fermium' (LTS), @targos
+
+### Notable Changes
+
+* [[`3a60de0135`](https://github.com/nodejs/node/commit/3a60de0135)] - **assert**: change status of legacy asserts (James M Snell) [#38113](https://github.com/nodejs/node/pull/38113)
+* [[`df37c106a7`](https://github.com/nodejs/node/commit/df37c106a7)] - **(SEMVER-MINOR)** **buffer**: introduce Blob (James M Snell) [#36811](https://github.com/nodejs/node/pull/36811)
+* [[`223494c548`](https://github.com/nodejs/node/commit/223494c548)] - **(SEMVER-MINOR)** **buffer**: add base64url encoding option (Filip Skokan) [#36952](https://github.com/nodejs/node/pull/36952)
+* [[`14fc4ddabc`](https://github.com/nodejs/node/commit/14fc4ddabc)] - **(SEMVER-MINOR)** **child_process**: allow `options.cwd` receive a URL (Khaidi Chu) [#38862](https://github.com/nodejs/node/pull/38862)
+* [[`b68b13acb3`](https://github.com/nodejs/node/commit/b68b13acb3)] - **(SEMVER-MINOR)** **child_process**: add timeout to spawn and fork (Nitzan Uziely) [#37256](https://github.com/nodejs/node/pull/37256)
+* [[`da98c9f99b`](https://github.com/nodejs/node/commit/da98c9f99b)] - **(SEMVER-MINOR)** **child_process**: allow promisified exec to be cancel (Carlos Fuentes) [#34249](https://github.com/nodejs/node/pull/34249)
+* [[`779310ac87`](https://github.com/nodejs/node/commit/779310ac87)] - **(SEMVER-MINOR)** **child_process**: add 'overlapped' stdio flag (Thiago Padilha) [#29412](https://github.com/nodejs/node/pull/29412)
+* [[`40eb3b79f1`](https://github.com/nodejs/node/commit/40eb3b79f1)] - **(SEMVER-MINOR)** **cli**: add -C alias for --conditions flag (Guy Bedford) [#38755](https://github.com/nodejs/node/pull/38755)
+* [[`39eba0a2e1`](https://github.com/nodejs/node/commit/39eba0a2e1)] - **(SEMVER-MINOR)** **cli**: add --node-memory-debug option (Anna Henningsen) [#35537](https://github.com/nodejs/node/pull/35537)
+* [[`d8d9a9628a`](https://github.com/nodejs/node/commit/d8d9a9628a)] - **(SEMVER-MINOR)** **dns**: add "tries" option to Resolve options (Luan Devecchi) [#39610](https://github.com/nodejs/node/pull/39610)
+* [[`15ba19b020`](https://github.com/nodejs/node/commit/15ba19b020)] - **(SEMVER-MINOR)** **dns**: allow `--dns-result-order` to change default dns verbatim (Ouyang Yadong) [#38099](https://github.com/nodejs/node/pull/38099)
+* [[`307c1d817f`](https://github.com/nodejs/node/commit/307c1d817f)] - **doc**: refactor fs docs structure (James M Snell) [#37170](https://github.com/nodejs/node/pull/37170)
+* [[`9ee3f77e32`](https://github.com/nodejs/node/commit/9ee3f77e32)] - **(SEMVER-MINOR)** **errors**: remove experimental from --enable-source-maps (Benjamin Coe) [#37362](https://github.com/nodejs/node/pull/37362)
+* [[`e73bfed2f4`](https://github.com/nodejs/node/commit/e73bfed2f4)] - **esm**: deprecate legacy main lookup for modules (Guy Bedford) [#36918](https://github.com/nodejs/node/pull/36918)
+* [[`989c204a58`](https://github.com/nodejs/node/commit/989c204a58)] - **(SEMVER-MINOR)** **fs**: allow empty string for temp directory prefix (Voltrex) [#39028](https://github.com/nodejs/node/pull/39028)
+* [[`ef72490cde`](https://github.com/nodejs/node/commit/ef72490cde)] - **(SEMVER-MINOR)** **fs**: allow no-params fsPromises fileHandle read (Nitzan Uziely) [#38287](https://github.com/nodejs/node/pull/38287)
+* [[`cad9d20f64`](https://github.com/nodejs/node/commit/cad9d20f64)] - **(SEMVER-MINOR)** **fs**: add support for async iterators to `fsPromises.writeFile` (HiroyukiYagihashi) [#37490](https://github.com/nodejs/node/pull/37490)
+* [[`2b0e2706c0`](https://github.com/nodejs/node/commit/2b0e2706c0)] - **fs**: improve fsPromises readFile performance (Nitzan Uziely) [#37608](https://github.com/nodejs/node/pull/37608)
+* [[`fe12cc07b3`](https://github.com/nodejs/node/commit/fe12cc07b3)] - **(SEMVER-MINOR)** **fs**: add fsPromises.watch() (James M Snell) [#37179](https://github.com/nodejs/node/pull/37179)
+* [[`2459c115a8`](https://github.com/nodejs/node/commit/2459c115a8)] - **(SEMVER-MINOR)** **fs**: allow `position` parameter to be a `BigInt` in read and readSync (Darshan Sen) [#36190](https://github.com/nodejs/node/pull/36190)
+* [[`6544cfb4b9`](https://github.com/nodejs/node/commit/6544cfb4b9)] - **(SEMVER-MINOR)** **http2**: add support for sensitive headers (Anna Henningsen) [#34145](https://github.com/nodejs/node/pull/34145)
+* [[`a6c6cbb4e6`](https://github.com/nodejs/node/commit/a6c6cbb4e6)] - **(SEMVER-MINOR)** **http2**: allow setting the local window size of a session (Yongsheng Zhang) [#35978](https://github.com/nodejs/node/pull/35978)
+* [[`1e5aca550c`](https://github.com/nodejs/node/commit/1e5aca550c)] - **inspector**: mark as stable (Gireesh Punathil) [#37748](https://github.com/nodejs/node/pull/37748)
+* [[`93af04afbb`](https://github.com/nodejs/node/commit/93af04afbb)] - **(SEMVER-MINOR)** **module**: add support for `URL` to `import.meta.resolve` (Antoine du Hamel) [#38587](https://github.com/nodejs/node/pull/38587)
+* [[`f9f9389d83`](https://github.com/nodejs/node/commit/f9f9389d83)] - **(SEMVER-MINOR)** **module**: add support for `node:`‑prefixed `require(…)` calls (ExE Boss) [#37246](https://github.com/nodejs/node/pull/37246)
+* [[`87c71065eb`](https://github.com/nodejs/node/commit/87c71065eb)] - **(SEMVER-MINOR)** **net**: introduce net.BlockList (James M Snell) [#34625](https://github.com/nodejs/node/pull/34625)
+* [[`b421d99a48`](https://github.com/nodejs/node/commit/b421d99a48)] - **(SEMVER-MINOR)** **node-api**: allow retrieval of add-on file name (Gabriel Schulhof) [#37195](https://github.com/nodejs/node/pull/37195)
+* [[`6a4811df8a`](https://github.com/nodejs/node/commit/6a4811df8a)] - **(SEMVER-MINOR)** **os**: add os.devNull (Luigi Pinca) [#38569](https://github.com/nodejs/node/pull/38569)
+* [[`4a88ddeeca`](https://github.com/nodejs/node/commit/4a88ddeeca)] - **(SEMVER-MINOR)** **perf_hooks**: introduce createHistogram (James M Snell) [#37155](https://github.com/nodejs/node/pull/37155)
+* [[`1a6bf1c4a3`](https://github.com/nodejs/node/commit/1a6bf1c4a3)] - **(SEMVER-MINOR)** **process**: add api to enable source-maps programmatically (legendecas) [#39085](https://github.com/nodejs/node/pull/39085)
+* [[`99735a6fe8`](https://github.com/nodejs/node/commit/99735a6fe8)] - **(SEMVER-MINOR)** **process**: add `'worker'` event (James M Snell) [#38659](https://github.com/nodejs/node/pull/38659)
+* [[`3982919317`](https://github.com/nodejs/node/commit/3982919317)] - **(SEMVER-MINOR)** **process**: add direct access to rss without iterating pages (Adrien Maret) [#34291](https://github.com/nodejs/node/pull/34291)
+* [[`526e6c7bde`](https://github.com/nodejs/node/commit/526e6c7bde)] - **(SEMVER-MINOR)** **readline**: add AbortSignal support to interface (Nitzan Uziely) [#37932](https://github.com/nodejs/node/pull/37932)
+* [[`e6eee08692`](https://github.com/nodejs/node/commit/e6eee08692)] - **(SEMVER-MINOR)** **readline**: add support for the AbortController to the question method (Mattias Runge-Broberg) [#33676](https://github.com/nodejs/node/pull/33676)
+* [[`32de361d70`](https://github.com/nodejs/node/commit/32de361d70)] - **(SEMVER-MINOR)** **readline**: add history event and option to set initial history (Mattias Runge-Broberg) [#33662](https://github.com/nodejs/node/pull/33662)
+* [[`797f7f8a38`](https://github.com/nodejs/node/commit/797f7f8a38)] - **(SEMVER-MINOR)** **repl**: add auto‑completion for `node:`‑prefixed `require(…)` calls (ExE Boss) [#37246](https://github.com/nodejs/node/pull/37246)
+* [[`abfd71b64c`](https://github.com/nodejs/node/commit/abfd71b64c)] - **(SEMVER-MINOR)** **src**: call overload ctor from the original ctor (Darshan Sen) [#39768](https://github.com/nodejs/node/pull/39768)
+* [[`1efae01b18`](https://github.com/nodejs/node/commit/1efae01b18)] - **(SEMVER-MINOR)** **src**: add a constructor overload for CallbackScope (Darshan Sen) [#39768](https://github.com/nodejs/node/pull/39768)
+* [[`f7933804ba`](https://github.com/nodejs/node/commit/f7933804ba)] - **(SEMVER-MINOR)** **src**: allow to negate boolean CLI flags (Michaël Zasso) [#39023](https://github.com/nodejs/node/pull/39023)
+* [[`6d06ac2202`](https://github.com/nodejs/node/commit/6d06ac2202)] - **(SEMVER-MINOR)** **src**: add --heapsnapshot-near-heap-limit option (Joyee Cheung) [#33010](https://github.com/nodejs/node/pull/33010)
+* [[`577d228ca0`](https://github.com/nodejs/node/commit/577d228ca0)] - **(SEMVER-MINOR)** **src**: add way to get IsolateData and allocator from Environment (Anna Henningsen) [#36441](https://github.com/nodejs/node/pull/36441)
+* [[`658a266cd4`](https://github.com/nodejs/node/commit/658a266cd4)] - **(SEMVER-MINOR)** **src**: allow preventing SetPrepareStackTraceCallback (Shelley Vohr) [#36447](https://github.com/nodejs/node/pull/36447)
+* [[`f421422ea4`](https://github.com/nodejs/node/commit/f421422ea4)] - **(SEMVER-MINOR)** **src**: add maybe versions of EmitExit and EmitBeforeExit (Anna Henningsen) [#35486](https://github.com/nodejs/node/pull/35486)
+* [[`a62d4d60f4`](https://github.com/nodejs/node/commit/a62d4d60f4)] - **(SEMVER-MINOR)** **stream**: add readableDidRead if has been read from (Robert Nagy) [#39589](https://github.com/nodejs/node/pull/39589)
+* [[`63502131a3`](https://github.com/nodejs/node/commit/63502131a3)] - **(SEMVER-MINOR)** **stream**: pipeline accept Buffer as a valid first argument (Nitzan Uziely) [#37739](https://github.com/nodejs/node/pull/37739)
+* [[`68bbebd42c`](https://github.com/nodejs/node/commit/68bbebd42c)] - **(SEMVER-MINOR)** **tls**: allow reading data into a static buffer (Andrey Pechkurov) [#35753](https://github.com/nodejs/node/pull/35753)
+* [[`1cbb74d63d`](https://github.com/nodejs/node/commit/1cbb74d63d)] - **(SEMVER-MINOR)** **url**: expose urlToHttpOptions utility (Yongsheng Zhang) [#35960](https://github.com/nodejs/node/pull/35960)
+* [[`8eb11356dd`](https://github.com/nodejs/node/commit/8eb11356dd)] - **(SEMVER-MINOR)** **util**: expose toUSVString (Robert Nagy) [#39814](https://github.com/nodejs/node/pull/39814)
+* [[`84fcdc3074`](https://github.com/nodejs/node/commit/84fcdc3074)] - **(SEMVER-MINOR)** **v8**: implement v8.stopCoverage() (Joyee Cheung) [#33807](https://github.com/nodejs/node/pull/33807)
+* [[`b238b6bf17`](https://github.com/nodejs/node/commit/b238b6bf17)] - **(SEMVER-MINOR)** **v8**: implement v8.takeCoverage() (Joyee Cheung) [#33807](https://github.com/nodejs/node/pull/33807)
+* [[`9f6bc58da8`](https://github.com/nodejs/node/commit/9f6bc58da8)] - **(SEMVER-MINOR)** **worker**: add setEnvironmentData/getEnvironmentData (James M Snell) [#37486](https://github.com/nodejs/node/pull/37486)
+
+### Commits
+
+#### Semver-minor commits
+
+* [[`f3563d3197`](https://github.com/nodejs/node/commit/f3563d3197)] - **(SEMVER-MINOR)** **async_hooks**: use new v8::Context PromiseHook API (Stephen Belanger) [#36394](https://github.com/nodejs/node/pull/36394)
+* [[`df37c106a7`](https://github.com/nodejs/node/commit/df37c106a7)] - **(SEMVER-MINOR)** **buffer**: introduce Blob (James M Snell) [#36811](https://github.com/nodejs/node/pull/36811)
+* [[`223494c548`](https://github.com/nodejs/node/commit/223494c548)] - **(SEMVER-MINOR)** **buffer**: add base64url encoding option (Filip Skokan) [#36952](https://github.com/nodejs/node/pull/36952)
+* [[`14fc4ddabc`](https://github.com/nodejs/node/commit/14fc4ddabc)] - **(SEMVER-MINOR)** **child_process**: allow `options.cwd` receive a URL (Khaidi Chu) [#38862](https://github.com/nodejs/node/pull/38862)
+* [[`b68b13acb3`](https://github.com/nodejs/node/commit/b68b13acb3)] - **(SEMVER-MINOR)** **child_process**: add timeout to spawn and fork (Nitzan Uziely) [#37256](https://github.com/nodejs/node/pull/37256)
+* [[`da98c9f99b`](https://github.com/nodejs/node/commit/da98c9f99b)] - **(SEMVER-MINOR)** **child_process**: allow promisified exec to be cancel (Carlos Fuentes) [#34249](https://github.com/nodejs/node/pull/34249)
+* [[`779310ac87`](https://github.com/nodejs/node/commit/779310ac87)] - **(SEMVER-MINOR)** **child_process**: add 'overlapped' stdio flag (Thiago Padilha) [#29412](https://github.com/nodejs/node/pull/29412)
+* [[`40eb3b79f1`](https://github.com/nodejs/node/commit/40eb3b79f1)] - **(SEMVER-MINOR)** **cli**: add -C alias for --conditions flag (Guy Bedford) [#38755](https://github.com/nodejs/node/pull/38755)
+* [[`39eba0a2e1`](https://github.com/nodejs/node/commit/39eba0a2e1)] - **(SEMVER-MINOR)** **cli**: add --node-memory-debug option (Anna Henningsen) [#35537](https://github.com/nodejs/node/pull/35537)
+* [[`d9b58a0262`](https://github.com/nodejs/node/commit/d9b58a0262)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick fa4cb172cde2 (Stephen Belanger) [#38577](https://github.com/nodejs/node/pull/38577)
+* [[`9d7177c152`](https://github.com/nodejs/node/commit/9d7177c152)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 4c074516397b (Stephen Belanger) [#36394](https://github.com/nodejs/node/pull/36394)
+* [[`ec0f0ef8ef`](https://github.com/nodejs/node/commit/ec0f0ef8ef)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 5f4413194480 (Stephen Belanger) [#36394](https://github.com/nodejs/node/pull/36394)
+* [[`3e7238e45a`](https://github.com/nodejs/node/commit/3e7238e45a)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 272445f10927 (Stephen Belanger) [#36394](https://github.com/nodejs/node/pull/36394)
+* [[`214e568597`](https://github.com/nodejs/node/commit/214e568597)] - **(SEMVER-MINOR)** **deps**: V8: backport c0fceaa0669b (Stephen Belanger) [#36394](https://github.com/nodejs/node/pull/36394)
+* [[`d8d9a9628a`](https://github.com/nodejs/node/commit/d8d9a9628a)] - **(SEMVER-MINOR)** **dns**: add "tries" option to Resolve options (Luan Devecchi) [#39610](https://github.com/nodejs/node/pull/39610)
+* [[`15ba19b020`](https://github.com/nodejs/node/commit/15ba19b020)] - **(SEMVER-MINOR)** **dns**: allow `--dns-result-order` to change default dns verbatim (Ouyang Yadong) [#38099](https://github.com/nodejs/node/pull/38099)
+* [[`defb77cac9`](https://github.com/nodejs/node/commit/defb77cac9)] - **(SEMVER-MINOR)** **doc**: add missing change to resolver ctor (Luan Devecchi) [#39610](https://github.com/nodejs/node/pull/39610)
+* [[`9ee3f77e32`](https://github.com/nodejs/node/commit/9ee3f77e32)] - **(SEMVER-MINOR)** **errors**: remove experimental from --enable-source-maps (Benjamin Coe) [#37362](https://github.com/nodejs/node/pull/37362)
+* [[`989c204a58`](https://github.com/nodejs/node/commit/989c204a58)] - **(SEMVER-MINOR)** **fs**: allow empty string for temp directory prefix (Voltrex) [#39028](https://github.com/nodejs/node/pull/39028)
+* [[`ef72490cde`](https://github.com/nodejs/node/commit/ef72490cde)] - **(SEMVER-MINOR)** **fs**: allow no-params fsPromises fileHandle read (Nitzan Uziely) [#38287](https://github.com/nodejs/node/pull/38287)
+* [[`cad9d20f64`](https://github.com/nodejs/node/commit/cad9d20f64)] - **(SEMVER-MINOR)** **fs**: add support for async iterators to `fsPromises.writeFile` (HiroyukiYagihashi) [#37490](https://github.com/nodejs/node/pull/37490)
+* [[`fe12cc07b3`](https://github.com/nodejs/node/commit/fe12cc07b3)] - **(SEMVER-MINOR)** **fs**: add fsPromises.watch() (James M Snell) [#37179](https://github.com/nodejs/node/pull/37179)
+* [[`2459c115a8`](https://github.com/nodejs/node/commit/2459c115a8)] - **(SEMVER-MINOR)** **fs**: allow `position` parameter to be a `BigInt` in read and readSync (Darshan Sen) [#36190](https://github.com/nodejs/node/pull/36190)
+* [[`6544cfb4b9`](https://github.com/nodejs/node/commit/6544cfb4b9)] - **(SEMVER-MINOR)** **http2**: add support for sensitive headers (Anna Henningsen) [#34145](https://github.com/nodejs/node/pull/34145)
+* [[`a6c6cbb4e6`](https://github.com/nodejs/node/commit/a6c6cbb4e6)] - **(SEMVER-MINOR)** **http2**: allow setting the local window size of a session (Yongsheng Zhang) [#35978](https://github.com/nodejs/node/pull/35978)
+* [[`93af04afbb`](https://github.com/nodejs/node/commit/93af04afbb)] - **(SEMVER-MINOR)** **module**: add support for `URL` to `import.meta.resolve` (Antoine du Hamel) [#38587](https://github.com/nodejs/node/pull/38587)
+* [[`f9f9389d83`](https://github.com/nodejs/node/commit/f9f9389d83)] - **(SEMVER-MINOR)** **module**: add support for `node:`‑prefixed `require(…)` calls (ExE Boss) [#37246](https://github.com/nodejs/node/pull/37246)
+* [[`76d4f22bab`](https://github.com/nodejs/node/commit/76d4f22bab)] - **(SEMVER-MINOR)** **net**: allow net.BlockList to use net.SocketAddress objects (James M Snell) [#37917](https://github.com/nodejs/node/pull/37917)
+* [[`82363d864d`](https://github.com/nodejs/node/commit/82363d864d)] - **(SEMVER-MINOR)** **net**: add SocketAddress class (James M Snell) [#37917](https://github.com/nodejs/node/pull/37917)
+* [[`0202ba46b8`](https://github.com/nodejs/node/commit/0202ba46b8)] - **(SEMVER-MINOR)** **net**: make net.BlockList cloneable (James M Snell) [#37917](https://github.com/nodejs/node/pull/37917)
+* [[`a41a3e3b3f`](https://github.com/nodejs/node/commit/a41a3e3b3f)] - **(SEMVER-MINOR)** **net**: make blocklist family case insensitive (James M Snell) [#34864](https://github.com/nodejs/node/pull/34864)
+* [[`87c71065eb`](https://github.com/nodejs/node/commit/87c71065eb)] - **(SEMVER-MINOR)** **net**: introduce net.BlockList (James M Snell) [#34625](https://github.com/nodejs/node/pull/34625)
+* [[`b421d99a48`](https://github.com/nodejs/node/commit/b421d99a48)] - **(SEMVER-MINOR)** **node-api**: allow retrieval of add-on file name (Gabriel Schulhof) [#37195](https://github.com/nodejs/node/pull/37195)
+* [[`6a4811df8a`](https://github.com/nodejs/node/commit/6a4811df8a)] - **(SEMVER-MINOR)** **os**: add os.devNull (Luigi Pinca) [#38569](https://github.com/nodejs/node/pull/38569)
+* [[`4a88ddeeca`](https://github.com/nodejs/node/commit/4a88ddeeca)] - **(SEMVER-MINOR)** **perf_hooks**: introduce createHistogram (James M Snell) [#37155](https://github.com/nodejs/node/pull/37155)
+* [[`1a6bf1c4a3`](https://github.com/nodejs/node/commit/1a6bf1c4a3)] - **(SEMVER-MINOR)** **process**: add api to enable source-maps programmatically (legendecas) [#39085](https://github.com/nodejs/node/pull/39085)
+* [[`99735a6fe8`](https://github.com/nodejs/node/commit/99735a6fe8)] - **(SEMVER-MINOR)** **process**: add `'worker'` event (James M Snell) [#38659](https://github.com/nodejs/node/pull/38659)
+* [[`3982919317`](https://github.com/nodejs/node/commit/3982919317)] - **(SEMVER-MINOR)** **process**: add direct access to rss without iterating pages (Adrien Maret) [#34291](https://github.com/nodejs/node/pull/34291)
+* [[`526e6c7bde`](https://github.com/nodejs/node/commit/526e6c7bde)] - **(SEMVER-MINOR)** **readline**: add AbortSignal support to interface (Nitzan Uziely) [#37932](https://github.com/nodejs/node/pull/37932)
+* [[`e6eee08692`](https://github.com/nodejs/node/commit/e6eee08692)] - **(SEMVER-MINOR)** **readline**: add support for the AbortController to the question method (Mattias Runge-Broberg) [#33676](https://github.com/nodejs/node/pull/33676)
+* [[`32de361d70`](https://github.com/nodejs/node/commit/32de361d70)] - **(SEMVER-MINOR)** **readline**: add history event and option to set initial history (Mattias Runge-Broberg) [#33662](https://github.com/nodejs/node/pull/33662)
+* [[`797f7f8a38`](https://github.com/nodejs/node/commit/797f7f8a38)] - **(SEMVER-MINOR)** **repl**: add auto‑completion for `node:`‑prefixed `require(…)` calls (ExE Boss) [#37246](https://github.com/nodejs/node/pull/37246)
+* [[`abfd71b64c`](https://github.com/nodejs/node/commit/abfd71b64c)] - **(SEMVER-MINOR)** **src**: call overload ctor from the original ctor (Darshan Sen) [#39768](https://github.com/nodejs/node/pull/39768)
+* [[`1efae01b18`](https://github.com/nodejs/node/commit/1efae01b18)] - **(SEMVER-MINOR)** **src**: add a constructor overload for CallbackScope (Darshan Sen) [#39768](https://github.com/nodejs/node/pull/39768)
+* [[`1aa2080d29`](https://github.com/nodejs/node/commit/1aa2080d29)] - **(SEMVER-MINOR)** **src**: fix align in cares\_wrap.h (Luan) [#39610](https://github.com/nodejs/node/pull/39610)
+* [[`f7933804ba`](https://github.com/nodejs/node/commit/f7933804ba)] - **(SEMVER-MINOR)** **src**: allow to negate boolean CLI flags (Michaël Zasso) [#39023](https://github.com/nodejs/node/pull/39023)
+* [[`6d06ac2202`](https://github.com/nodejs/node/commit/6d06ac2202)] - **(SEMVER-MINOR)** **src**: add --heapsnapshot-near-heap-limit option (Joyee Cheung) [#33010](https://github.com/nodejs/node/pull/33010)
+* [[`4091eb9db7`](https://github.com/nodejs/node/commit/4091eb9db7)] - **(SEMVER-MINOR)** **src**: move node\_binding to modern THROW\_ERR\* (James M Snell) [#35469](https://github.com/nodejs/node/pull/35469)
+* [[`577d228ca0`](https://github.com/nodejs/node/commit/577d228ca0)] - **(SEMVER-MINOR)** **src**: add way to get IsolateData and allocator from Environment (Anna Henningsen) [#36441](https://github.com/nodejs/node/pull/36441)
+* [[`658a266cd4`](https://github.com/nodejs/node/commit/658a266cd4)] - **(SEMVER-MINOR)** **src**: allow preventing SetPrepareStackTraceCallback (Shelley Vohr) [#36447](https://github.com/nodejs/node/pull/36447)
+* [[`f421422ea4`](https://github.com/nodejs/node/commit/f421422ea4)] - **(SEMVER-MINOR)** **src**: add maybe versions of EmitExit and EmitBeforeExit (Anna Henningsen) [#35486](https://github.com/nodejs/node/pull/35486)
+* [[`a62d4d60f4`](https://github.com/nodejs/node/commit/a62d4d60f4)] - **(SEMVER-MINOR)** **stream**: add readableDidRead if has been read from (Robert Nagy) [#39589](https://github.com/nodejs/node/pull/39589)
+* [[`63502131a3`](https://github.com/nodejs/node/commit/63502131a3)] - **(SEMVER-MINOR)** **stream**: pipeline accept Buffer as a valid first argument (Nitzan Uziely) [#37739](https://github.com/nodejs/node/pull/37739)
+* [[`72ef41c72b`](https://github.com/nodejs/node/commit/72ef41c72b)] - **(SEMVER-MINOR)** **test**: add wpt tests for Blob (Michaël Zasso) [#36811](https://github.com/nodejs/node/pull/36811)
+* [[`68bbebd42c`](https://github.com/nodejs/node/commit/68bbebd42c)] - **(SEMVER-MINOR)** **tls**: allow reading data into a static buffer (Andrey Pechkurov) [#35753](https://github.com/nodejs/node/pull/35753)
+* [[`587deacad9`](https://github.com/nodejs/node/commit/587deacad9)] - **(SEMVER-MINOR)** **tools**: add `Worker` to type-parser (James M Snell) [#38659](https://github.com/nodejs/node/pull/38659)
+* [[`1cbb74d63d`](https://github.com/nodejs/node/commit/1cbb74d63d)] - **(SEMVER-MINOR)** **url**: expose urlToHttpOptions utility (Yongsheng Zhang) [#35960](https://github.com/nodejs/node/pull/35960)
+* [[`8eb11356dd`](https://github.com/nodejs/node/commit/8eb11356dd)] - **(SEMVER-MINOR)** **util**: expose toUSVString (Robert Nagy) [#39814](https://github.com/nodejs/node/pull/39814)
+* [[`84fcdc3074`](https://github.com/nodejs/node/commit/84fcdc3074)] - **(SEMVER-MINOR)** **v8**: implement v8.stopCoverage() (Joyee Cheung) [#33807](https://github.com/nodejs/node/pull/33807)
+* [[`b238b6bf17`](https://github.com/nodejs/node/commit/b238b6bf17)] - **(SEMVER-MINOR)** **v8**: implement v8.takeCoverage() (Joyee Cheung) [#33807](https://github.com/nodejs/node/pull/33807)
+* [[`9f6bc58da8`](https://github.com/nodejs/node/commit/9f6bc58da8)] - **(SEMVER-MINOR)** **worker**: add setEnvironmentData/getEnvironmentData (James M Snell) [#37486](https://github.com/nodejs/node/pull/37486)
+
+#### Semver-patch commits
+
+* [[`3a60de0135`](https://github.com/nodejs/node/commit/3a60de0135)] - **assert**: change status of legacy asserts (James M Snell) [#38113](https://github.com/nodejs/node/pull/38113)
+* [[`5a42be9719`](https://github.com/nodejs/node/commit/5a42be9719)] - **async_hooks**: use resource stack for AsyncLocalStorage run (Stephen Belanger) [#39890](https://github.com/nodejs/node/pull/39890)
+* [[`fc29ddb38e`](https://github.com/nodejs/node/commit/fc29ddb38e)] - **async_hooks**: emit promise trace events from JS (Stephen Belanger) [#39135](https://github.com/nodejs/node/pull/39135)
+* [[`13296d1abf`](https://github.com/nodejs/node/commit/13296d1abf)] - **async_hooks**: eliminate native PromiseHook (Stephen Belanger) [#39135](https://github.com/nodejs/node/pull/39135)
+* [[`48e5971e51`](https://github.com/nodejs/node/commit/48e5971e51)] - **async_hooks**: check for empty contexts before removing (Bryan English) [#39095](https://github.com/nodejs/node/pull/39095)
+* [[`691c00c48b`](https://github.com/nodejs/node/commit/691c00c48b)] - **async_hooks**: switch between native and context hooks correctly (Stephen Belanger) [#38912](https://github.com/nodejs/node/pull/38912)
+* [[`8484ab2a6c`](https://github.com/nodejs/node/commit/8484ab2a6c)] - **buffer**: avoid creating the backing store in the thread (James M Snell) [#37052](https://github.com/nodejs/node/pull/37052)
+* [[`c8d039a872`](https://github.com/nodejs/node/commit/c8d039a872)] - **buffer**: make Blob's constructor more spec-compliant (Michaël Zasso) [#37361](https://github.com/nodejs/node/pull/37361)
+* [[`05d73ac286`](https://github.com/nodejs/node/commit/05d73ac286)] - **buffer**: make Blob's slice method more spec-compliant (Michaël Zasso) [#37361](https://github.com/nodejs/node/pull/37361)
+* [[`e7cf2efc60`](https://github.com/nodejs/node/commit/e7cf2efc60)] - **buffer**: add @@toStringTag to Blob (Colin Ihrig) [#37336](https://github.com/nodejs/node/pull/37336)
+* [[`d99deeaf97`](https://github.com/nodejs/node/commit/d99deeaf97)] - **build**: fix update authors commit (Mestery) [#39858](https://github.com/nodejs/node/pull/39858)
+* [[`5e1cba81bf`](https://github.com/nodejs/node/commit/5e1cba81bf)] - **build**: add authors.yml (Tierney Cyren) [#35831](https://github.com/nodejs/node/pull/35831)
+* [[`ed3c332089`](https://github.com/nodejs/node/commit/ed3c332089)] - **build**: add option to hide console window (Cheng Zhao) [#39712](https://github.com/nodejs/node/pull/39712)
+* [[`c696f97c5e`](https://github.com/nodejs/node/commit/c696f97c5e)] - **build**: exclude markdown files from some GitHub Actions (Rich Trott) [#39565](https://github.com/nodejs/node/pull/39565)
+* [[`0bd6dd1ee2`](https://github.com/nodejs/node/commit/0bd6dd1ee2)] - **build**: use lts shorthand in GitHub Actions (Rich Trott) [#39538](https://github.com/nodejs/node/pull/39538)
+* [[`3482bca643`](https://github.com/nodejs/node/commit/3482bca643)] - **build**: override python executable path on configure (legendecas) [#39465](https://github.com/nodejs/node/pull/39465)
+* [[`61261cdb8e`](https://github.com/nodejs/node/commit/61261cdb8e)] - **build**: use Node.js 14 in commit-lint.yml (Rich Trott) [#39506](https://github.com/nodejs/node/pull/39506)
+* [[`719f1563c1`](https://github.com/nodejs/node/commit/719f1563c1)] - **build**: fix `host_arch_cc()` for AIX/IBM i (Richard Lau) [#39481](https://github.com/nodejs/node/pull/39481)
+* [[`6e06b2ff9d`](https://github.com/nodejs/node/commit/6e06b2ff9d)] - **build**: update coverage Makefile target comments (Richard Lau) [#39365](https://github.com/nodejs/node/pull/39365)
+* [[`4e28d2b2c0`](https://github.com/nodejs/node/commit/4e28d2b2c0)] - **build**: run workflows when a PR is ready for review (Michaël Zasso) [#39405](https://github.com/nodejs/node/pull/39405)
+* [[`0da5d74da4`](https://github.com/nodejs/node/commit/0da5d74da4)] - **build**: update to setup-node@v2 (Rich Trott) [#39366](https://github.com/nodejs/node/pull/39366)
+* [[`f2e1c2267e`](https://github.com/nodejs/node/commit/f2e1c2267e)] - **build**: update gcovr for gcc 8 compatibility (Richard Lau) [#39326](https://github.com/nodejs/node/pull/39326)
+* [[`131dd6ec4d`](https://github.com/nodejs/node/commit/131dd6ec4d)] - **build**: remove unused comment in Makefile (LitoMore) [#39171](https://github.com/nodejs/node/pull/39171)
+* [[`40e46321b0`](https://github.com/nodejs/node/commit/40e46321b0)] - **build**: uvwasi honours node\_shared\_libuv (Jérémy Lal) [#39260](https://github.com/nodejs/node/pull/39260)
+* [[`5c6ab719f2`](https://github.com/nodejs/node/commit/5c6ab719f2)] - **build**: shorten path used in tarball build workflow (Richard Lau) [#39192](https://github.com/nodejs/node/pull/39192)
+* [[`870526374c`](https://github.com/nodejs/node/commit/870526374c)] - **build**: add `library_files` to gyp variables (himself65) [#39293](https://github.com/nodejs/node/pull/39293)
+* [[`0e221156aa`](https://github.com/nodejs/node/commit/0e221156aa)] - **build**: pass directory instead of list of files to js2c.py (Joyee Cheung) [#39069](https://github.com/nodejs/node/pull/39069)
+* [[`8d8415415b`](https://github.com/nodejs/node/commit/8d8415415b)] - **build**: don't pass `--mode` argument to V8 test-runner (Richard Lau) [#39055](https://github.com/nodejs/node/pull/39055)
+* [[`2d50217634`](https://github.com/nodejs/node/commit/2d50217634)] - **build**: fix commit linter on unrebased PRs (Mary Marchini) [#39121](https://github.com/nodejs/node/pull/39121)
+* [[`c93d5e006e`](https://github.com/nodejs/node/commit/c93d5e006e)] - **build**: use Actions to validate commit message (Mary Marchini) [#32417](https://github.com/nodejs/node/pull/32417)
+* [[`0bcaf9c4d1`](https://github.com/nodejs/node/commit/0bcaf9c4d1)] - **child_process**: fix spawn and fork abort behavior (Nitzan Uziely) [#37325](https://github.com/nodejs/node/pull/37325)
+* [[`8010c83180`](https://github.com/nodejs/node/commit/8010c83180)] - **child_process**: fix bad abort signal leak (Nitzan Uziely) [#37257](https://github.com/nodejs/node/pull/37257)
+* [[`32aff2f5a0`](https://github.com/nodejs/node/commit/32aff2f5a0)] - **console**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#36753](https://github.com/nodejs/node/pull/36753)
+* [[`f46e8cdf79`](https://github.com/nodejs/node/commit/f46e8cdf79)] - **debugger**: remove undefined parameter (Rich Trott) [#39570](https://github.com/nodejs/node/pull/39570)
+* [[`482459edd4`](https://github.com/nodejs/node/commit/482459edd4)] - **debugger**: validate sec-websocket-accept response header (Chris Opperwall) [#39357](https://github.com/nodejs/node/pull/39357)
+* [[`e9c46107d7`](https://github.com/nodejs/node/commit/e9c46107d7)] - **debugger**: rename internal module (Rich Trott) [#39378](https://github.com/nodejs/node/pull/39378)
+* [[`49e0883c75`](https://github.com/nodejs/node/commit/49e0883c75)] - **debugger**: indicate server is ending (Rich Trott) [#39334](https://github.com/nodejs/node/pull/39334)
+* [[`72a3419510`](https://github.com/nodejs/node/commit/72a3419510)] - **debugger**: rename inspector-cli test module to debugger (Rich Trott) [#38530](https://github.com/nodejs/node/pull/38530)
+* [[`b3352cfba4`](https://github.com/nodejs/node/commit/b3352cfba4)] - **debugger**: prevent simultaneous heap snapshots (Rich Trott) [#39638](https://github.com/nodejs/node/pull/39638)
+* [[`e5826ab1c2`](https://github.com/nodejs/node/commit/e5826ab1c2)] - **debugger**: remove final lint exceptions in inspect\_repl.js (Rich Trott) [#39078](https://github.com/nodejs/node/pull/39078)
+* [[`34c0701952`](https://github.com/nodejs/node/commit/34c0701952)] - **deps**: V8: cherry-pick 00bb1a77c03e (Darshan Sen) [#39829](https://github.com/nodejs/node/pull/39829)
+* [[`42359ab582`](https://github.com/nodejs/node/commit/42359ab582)] - **deps**: upgrade to libuv 1.42.0 (Luigi Pinca) [#39525](https://github.com/nodejs/node/pull/39525)
+* [[`d863a9db68`](https://github.com/nodejs/node/commit/d863a9db68)] - **deps**: bump HdrHistogram\_C to 0.11.2 (Matteo Collina) [#39462](https://github.com/nodejs/node/pull/39462)
+* [[`4c93968a62`](https://github.com/nodejs/node/commit/4c93968a62)] - **deps**: extract gtest source files to deps/googletest (legendecas) [#39386](https://github.com/nodejs/node/pull/39386)
+* [[`fcae391fed`](https://github.com/nodejs/node/commit/fcae391fed)] - **deps**: update Acorn to v8.4.1 (Michaël Zasso) [#39166](https://github.com/nodejs/node/pull/39166)
+* [[`327838dd96`](https://github.com/nodejs/node/commit/327838dd96)] - **deps**: V8: backport c9224589cf53 (Stephen Belanger) [#39743](https://github.com/nodejs/node/pull/39743)
+* [[`89c1bbd7b2`](https://github.com/nodejs/node/commit/89c1bbd7b2)] - **deps**: V8: cherry-pick 81814ed44574 (Stephen Belanger) [#39719](https://github.com/nodejs/node/pull/39719)
+* [[`8b9215d07c`](https://github.com/nodejs/node/commit/8b9215d07c)] - **deps**: update to cjs-module-lexer@1.2.2 (Guy Bedford) [#39402](https://github.com/nodejs/node/pull/39402)
+* [[`e201293ddb`](https://github.com/nodejs/node/commit/e201293ddb)] - **dgram**: use simplified validator (Voltrex) [#39753](https://github.com/nodejs/node/pull/39753)
+* [[`6fdac38f91`](https://github.com/nodejs/node/commit/6fdac38f91)] - **doc,fs**: remove experimental status for WHATWG URL as path (Antoine du Hamel) [#38870](https://github.com/nodejs/node/pull/38870)
+* [[`d56e8268f9`](https://github.com/nodejs/node/commit/d56e8268f9)] - **doc,lib**: prepare for stricter multi-line array linting (Rich Trott) [#37088](https://github.com/nodejs/node/pull/37088)
+* [[`5500ae9236`](https://github.com/nodejs/node/commit/5500ae9236)] - **domain**: do not add domain to promise from other context (Stephen Belanger) [#39135](https://github.com/nodejs/node/pull/39135)
+* [[`dc855af18e`](https://github.com/nodejs/node/commit/dc855af18e)] - **errors**: don't throw TypeError on missing export (Benjamin Coe) [#39017](https://github.com/nodejs/node/pull/39017)
+* [[`c13eadc218`](https://github.com/nodejs/node/commit/c13eadc218)] - **errors**: eliminate all overhead for hidden calls (Momtchil Momtchev) [#35644](https://github.com/nodejs/node/pull/35644)
+* [[`d42bbe48c5`](https://github.com/nodejs/node/commit/d42bbe48c5)] - **esm**: use correct URL for error decoration (Bradley Farias) [#37854](https://github.com/nodejs/node/pull/37854)
+* [[`9db3304368`](https://github.com/nodejs/node/commit/9db3304368)] - **esm**: update to correct deprecation code (Colin Ihrig) [#37147](https://github.com/nodejs/node/pull/37147)
+* [[`e73bfed2f4`](https://github.com/nodejs/node/commit/e73bfed2f4)] - **esm**: deprecate legacy main lookup for modules (Guy Bedford) [#36918](https://github.com/nodejs/node/pull/36918)
+* [[`c1782ea1f5`](https://github.com/nodejs/node/commit/c1782ea1f5)] - **events**: allow the options argument to be null (Luigi Pinca) [#39486](https://github.com/nodejs/node/pull/39486)
+* [[`d2834fb97f`](https://github.com/nodejs/node/commit/d2834fb97f)] - **fs**: improve fsPromises writeFile performance (Nitzan Uziely) [#37610](https://github.com/nodejs/node/pull/37610)
+* [[`ee1d13c90d`](https://github.com/nodejs/node/commit/ee1d13c90d)] - **fs**: use byteLength to handle ArrayBuffer views (Michaël Zasso) [#38187](https://github.com/nodejs/node/pull/38187)
+* [[`b38d6b475b`](https://github.com/nodejs/node/commit/b38d6b475b)] - **fs**: fixup negative length in fs.truncate (James M Snell) [#37483](https://github.com/nodejs/node/pull/37483)
+* [[`fe28128f3c`](https://github.com/nodejs/node/commit/fe28128f3c)] - **fs**: add docs and tests for `AsyncIterable` support in `fh.writeFile` (Antoine du Hamel) [#39836](https://github.com/nodejs/node/pull/39836)
+* [[`2b0e2706c0`](https://github.com/nodejs/node/commit/2b0e2706c0)] - **fs**: improve fsPromises readFile performance (Nitzan Uziely) [#37608](https://github.com/nodejs/node/pull/37608)
+* [[`a4d6f78619`](https://github.com/nodejs/node/commit/a4d6f78619)] - **fs**: move constants to internal/fs/utils.js (Darshan Sen) [#38061](https://github.com/nodejs/node/pull/38061)
+* [[`402f7722ce`](https://github.com/nodejs/node/commit/402f7722ce)] - **fs**: add validatePosition and use in read and readSync (Darshan Sen) [#37051](https://github.com/nodejs/node/pull/37051)
+* [[`2bc301dcff`](https://github.com/nodejs/node/commit/2bc301dcff)] - **http**: decodes url.username and url.password for authorization header (Lew Gordon) [#39310](https://github.com/nodejs/node/pull/39310)
+* [[`5459f4af33`](https://github.com/nodejs/node/commit/5459f4af33)] - **http**: clean up HttpParser correctly (Tobias Koppers) [#39292](https://github.com/nodejs/node/pull/39292)
+* [[`8b3feee148`](https://github.com/nodejs/node/commit/8b3feee148)] - **http,https**: align server option of https with http (Qingyu Deng) [#38992](https://github.com/nodejs/node/pull/38992)
+* [[`cf59e87c8b`](https://github.com/nodejs/node/commit/cf59e87c8b)] - **inspector**: update inspector\_protocol to 89c4adf (Rich Trott) [#39650](https://github.com/nodejs/node/pull/39650)
+* [[`ea5f2047a2`](https://github.com/nodejs/node/commit/ea5f2047a2)] - **inspector**: update inspector\_protocol to 8ec18cf (Rich Trott) [#39614](https://github.com/nodejs/node/pull/39614)
+* [[`1e5aca550c`](https://github.com/nodejs/node/commit/1e5aca550c)] - **inspector**: mark as stable (Gireesh Punathil) [#37748](https://github.com/nodejs/node/pull/37748)
+* [[`8a2ce5dae6`](https://github.com/nodejs/node/commit/8a2ce5dae6)] - **inspector**: move inspector async hooks to environment (Joyee Cheung) [#39112](https://github.com/nodejs/node/pull/39112)
+* [[`338189ff6f`](https://github.com/nodejs/node/commit/338189ff6f)] - **lib**: simplify validators (Voltrex) [#39753](https://github.com/nodejs/node/pull/39753)
+* [[`e1019351e8`](https://github.com/nodejs/node/commit/e1019351e8)] - **lib**: cleanup validation (Voltrex) [#39652](https://github.com/nodejs/node/pull/39652)
+* [[`dbaf4988bc`](https://github.com/nodejs/node/commit/dbaf4988bc)] - **lib**: use validators (Voltrex) [#39663](https://github.com/nodejs/node/pull/39663)
+* [[`9c33e4bfb2`](https://github.com/nodejs/node/commit/9c33e4bfb2)] - **lib**: use validator (Voltrex) [#39547](https://github.com/nodejs/node/pull/39547)
+* [[`5b1104291d`](https://github.com/nodejs/node/commit/5b1104291d)] - **lib**: use `validateObject` (Voltrex) [#39605](https://github.com/nodejs/node/pull/39605)
+* [[`1ce81079df`](https://github.com/nodejs/node/commit/1ce81079df)] - **lib**: remove use of array destructuring (Antoine du Hamel) [#36818](https://github.com/nodejs/node/pull/36818)
+* [[`b24b34effd`](https://github.com/nodejs/node/commit/b24b34effd)] - **lib**: add `bound apply` variants of varargs `primordials` (ExE Boss) [#37005](https://github.com/nodejs/node/pull/37005)
+* [[`7cdff9a6a8`](https://github.com/nodejs/node/commit/7cdff9a6a8)] - **lib**: refactor `primordials.makeSafe` to use more primordials (ExE Boss) [#36865](https://github.com/nodejs/node/pull/36865)
+* [[`1737352580`](https://github.com/nodejs/node/commit/1737352580)] - **lib**: comment explaining special-case handling of promises (Stephen Belanger) [#39135](https://github.com/nodejs/node/pull/39135)
+* [[`7f54cccb6c`](https://github.com/nodejs/node/commit/7f54cccb6c)] - **lib**: refactor to use validateString (ZiJian Liu) [#37006](https://github.com/nodejs/node/pull/37006)
+* [[`98259dc527`](https://github.com/nodejs/node/commit/98259dc527)] - **module**: improve support of data: URLs (Antoine du Hamel) [#37392](https://github.com/nodejs/node/pull/37392)
+* [[`9aba2888a1`](https://github.com/nodejs/node/commit/9aba2888a1)] - **net**: throw ERR\_OUT\_OF\_RANGE if blockList.addSubnet prefix is NaN (ZiJian Liu) [#36732](https://github.com/nodejs/node/pull/36732)
+* [[`2ca12c83b4`](https://github.com/nodejs/node/commit/2ca12c83b4)] - **node-api**: handle pending exception in cb wrapper (Michael Dawson) [#39476](https://github.com/nodejs/node/pull/39476)
+* [[`9e5edf2158`](https://github.com/nodejs/node/commit/9e5edf2158)] - **node-api**: cctest on v8impl::Reference (legendecas) [#38970](https://github.com/nodejs/node/pull/38970)
+* [[`a74032a490`](https://github.com/nodejs/node/commit/a74032a490)] - **node-api**: rtn pending excep on napi\_new\_instance (legendecas) [#38798](https://github.com/nodejs/node/pull/38798)
+* [[`bcb85adee6`](https://github.com/nodejs/node/commit/bcb85adee6)] - **policy**: canonicalize before resolving specifiers (Bradley Farias) [#37863](https://github.com/nodejs/node/pull/37863)
+* [[`0ff520cf02`](https://github.com/nodejs/node/commit/0ff520cf02)] - **policy**: fix integrity when DEFAULT\_ENCODING is set (Tobias Nießen) [#39750](https://github.com/nodejs/node/pull/39750)
+* [[`6c87b591d9`](https://github.com/nodejs/node/commit/6c87b591d9)] - **readline**: allow completer to rewrite existing input (Anna Henningsen) [#39178](https://github.com/nodejs/node/pull/39178)
+* [[`37b4708b19`](https://github.com/nodejs/node/commit/37b4708b19)] - **repl**: fix tla function hoisting (Don Jayamanne) [#39745](https://github.com/nodejs/node/pull/39745)
+* [[`9264caeafe`](https://github.com/nodejs/node/commit/9264caeafe)] - **repl**: do not include legacy getter/setter methods in completion (Anna Henningsen) [#39576](https://github.com/nodejs/node/pull/39576)
+* [[`50c5e71e22`](https://github.com/nodejs/node/commit/50c5e71e22)] - **repl**: correctly hoist top level await declarations (ejose19) [#39265](https://github.com/nodejs/node/pull/39265)
+* [[`1e065a0a43`](https://github.com/nodejs/node/commit/1e065a0a43)] - **repl**: processTopLevelAwait fallback error handling (ejose19) [#39290](https://github.com/nodejs/node/pull/39290)
+* [[`99664494ff`](https://github.com/nodejs/node/commit/99664494ff)] - **repl**: ensure correct syntax err for await parsing (Guy Bedford) [#39154](https://github.com/nodejs/node/pull/39154)
+* [[`761dafafde`](https://github.com/nodejs/node/commit/761dafafde)] - **repl**: fix Ctrl+C on top level await (Antoine du Hamel) [#38656](https://github.com/nodejs/node/pull/38656)
+* [[`88b02cbb08`](https://github.com/nodejs/node/commit/88b02cbb08)] - **repl**: add auto‑completion for dynamic import calls (ExE Boss) [#37178](https://github.com/nodejs/node/pull/37178)
+* [[`8f3a8830ba`](https://github.com/nodejs/node/commit/8f3a8830ba)] - **repl**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#37188](https://github.com/nodejs/node/pull/37188)
+* [[`a48e2d6ec7`](https://github.com/nodejs/node/commit/a48e2d6ec7)] - **repl**: refactor to avoid unsafe array iteration (Darshan Sen) [#36663](https://github.com/nodejs/node/pull/36663)
+* [[`20ffadf437`](https://github.com/nodejs/node/commit/20ffadf437)] - **repl**: refactor to use more primordials (Antoine du Hamel) [#36264](https://github.com/nodejs/node/pull/36264)
+* [[`f69c934ad4`](https://github.com/nodejs/node/commit/f69c934ad4)] - **report**: generates report on threads with no isolates (legendecas) [#38994](https://github.com/nodejs/node/pull/38994)
+* [[`c4686fa5a7`](https://github.com/nodejs/node/commit/c4686fa5a7)] - **src**: fix TextDecoder final flush size calculation (James M Snell) [#39737](https://github.com/nodejs/node/pull/39737)
+* [[`495cd02c20`](https://github.com/nodejs/node/commit/495cd02c20)] - **src**: add cosmetic space character to `async_wrap.h` file (Juan José Arboleda) [#39459](https://github.com/nodejs/node/pull/39459)
+* [[`985ec48975`](https://github.com/nodejs/node/commit/985ec48975)] - **src**: print native module id on native module not found (legendecas) [#39460](https://github.com/nodejs/node/pull/39460)
+* [[`e6ff7e648e`](https://github.com/nodejs/node/commit/e6ff7e648e)] - **src**: close HandleWraps instead of deleting them in OnGCCollect() (Anna Henningsen) [#39441](https://github.com/nodejs/node/pull/39441)
+* [[`5c473bdc12`](https://github.com/nodejs/node/commit/5c473bdc12)] - **src**: remove unused guards around node-api reference (legendecas) [#38334](https://github.com/nodejs/node/pull/38334)
+* [[`41213bd507`](https://github.com/nodejs/node/commit/41213bd507)] - **src**: add JSDoc typings for v8 (Voltrex) [#38944](https://github.com/nodejs/node/pull/38944)
+* [[`02b1df9fac`](https://github.com/nodejs/node/commit/02b1df9fac)] - **src**: fix crash in AfterGetAddrInfo (Anna Henningsen) [#39735](https://github.com/nodejs/node/pull/39735)
+* [[`99493b07d4`](https://github.com/nodejs/node/commit/99493b07d4)] - **src**: fix fatal errors when a current isolate not exist (legendecas) [#38624](https://github.com/nodejs/node/pull/38624)
+* [[`9433c28c14`](https://github.com/nodejs/node/commit/9433c28c14)] - **src**: remove more extra semis from member fns (Shelley Vohr) [#38744](https://github.com/nodejs/node/pull/38744)
+* [[`bad990c934`](https://github.com/nodejs/node/commit/bad990c934)] - **src**: use BaseObject::kInteralFieldCount in Blob (Joyee Cheung) [#36991](https://github.com/nodejs/node/pull/36991)
+* [[`0a759dff52`](https://github.com/nodejs/node/commit/0a759dff52)] - **src**: compare IPv4 addresses in host byte order (Colin Ihrig) [#39096](https://github.com/nodejs/node/pull/39096)
+* [[`d73181f243`](https://github.com/nodejs/node/commit/d73181f243)] - **src**: reduce duplicated boilerplate with new env utility fn (James M Snell) [#36536](https://github.com/nodejs/node/pull/36536)
+* [[`85af15a8b6`](https://github.com/nodejs/node/commit/85af15a8b6)] - **src**: allow instances of net.BlockList to be created internally (James M Snell) [#34741](https://github.com/nodejs/node/pull/34741)
+* [[`1008c80176`](https://github.com/nodejs/node/commit/1008c80176)] - **src**: add SocketAddressLRU Utility (James M Snell) [#34618](https://github.com/nodejs/node/pull/34618)
+* [[`e404841a9c`](https://github.com/nodejs/node/commit/e404841a9c)] - **src**: set PromiseHooks by Environment (Bryan English) [#38821](https://github.com/nodejs/node/pull/38821)
+* [[`c8c290ae8f`](https://github.com/nodejs/node/commit/c8c290ae8f)] - **src,zlib**: tighten up Z\_\*\_WINDOWBITS macros (Khaidi Chu) [#39115](https://github.com/nodejs/node/pull/39115)
+* [[`de171177b4`](https://github.com/nodejs/node/commit/de171177b4)] - **stream**: clean `endWritableNT` (Mestery) [#39645](https://github.com/nodejs/node/pull/39645)
+* [[`32a5b8f59b`](https://github.com/nodejs/node/commit/32a5b8f59b)] - **stream**: move duplicated code to an internal module (Rich Trott) [#37508](https://github.com/nodejs/node/pull/37508)
+* [[`f90b22d351`](https://github.com/nodejs/node/commit/f90b22d351)] - **util**: add internal createDeferredPromise() (Colin Ihrig) [#37095](https://github.com/nodejs/node/pull/37095)
+* [[`61b4a98480`](https://github.com/nodejs/node/commit/61b4a98480)] - **zlib**: avoid converting `Uint8Array` instances to `Buffer` (Antoine du Hamel) [#39492](https://github.com/nodejs/node/pull/39492)
+
+#### Documentation commits
+
+* [[`8efd559347`](https://github.com/nodejs/node/commit/8efd559347)] - **doc**: add duplicate CVE check in sec. release doc (Daniel Bevenius) [#39845](https://github.com/nodejs/node/pull/39845)
+* [[`7b123ec78d`](https://github.com/nodejs/node/commit/7b123ec78d)] - **doc**: improve description of the triagers team (Michaël Zasso) [#39833](https://github.com/nodejs/node/pull/39833)
+* [[`615477f67b`](https://github.com/nodejs/node/commit/615477f67b)] - **doc**: update instructions for cc (Michael Dawson) [#39674](https://github.com/nodejs/node/pull/39674)
+* [[`1a8a26d92e`](https://github.com/nodejs/node/commit/1a8a26d92e)] - **doc**: fix malformed changelog entries (Rich Trott) [#39791](https://github.com/nodejs/node/pull/39791)
+* [[`9e772ca9a1`](https://github.com/nodejs/node/commit/9e772ca9a1)] - **doc**: fix lint errors in packages.md (Rich Trott) [#39792](https://github.com/nodejs/node/pull/39792)
+* [[`2624c98207`](https://github.com/nodejs/node/commit/2624c98207)] - **doc**: add example of self-reference in scoped packages (Jesús Leganés-Combarro 'piranna) [#37630](https://github.com/nodejs/node/pull/37630)
+* [[`00f2cee26c`](https://github.com/nodejs/node/commit/00f2cee26c)] - **doc**: add himadriganguly as a triager (Himadri Ganguly) [#39757](https://github.com/nodejs/node/pull/39757)
+* [[`95b9cc78d2`](https://github.com/nodejs/node/commit/95b9cc78d2)] - **doc**: fix YAML comment opening tags (Jayden Seric) [#38324](https://github.com/nodejs/node/pull/38324)
+* [[`49a7962d58`](https://github.com/nodejs/node/commit/49a7962d58)] - **doc**: fix `fs.rmdir` `recursive` option deprecation history (Antoine du Hamel) [#39728](https://github.com/nodejs/node/pull/39728)
+* [[`53300d33c7`](https://github.com/nodejs/node/commit/53300d33c7)] - **doc**: fixed variable names in queueMicrotask example (ashish maurya) [#39634](https://github.com/nodejs/node/pull/39634)
+* [[`df1e20aaf1`](https://github.com/nodejs/node/commit/df1e20aaf1)] - **doc**: update debugger.md description and examples (Rich Trott) [#39661](https://github.com/nodejs/node/pull/39661)
+* [[`9672bbf01c`](https://github.com/nodejs/node/commit/9672bbf01c)] - **doc**: fix color contrast issue in light mode (Rich Trott) [#39660](https://github.com/nodejs/node/pull/39660)
+* [[`48281ecfcd`](https://github.com/nodejs/node/commit/48281ecfcd)] - **doc**: add code examples to `Writable.destroy()` and `Writable.destroyed` (Juan José Arboleda) [#39491](https://github.com/nodejs/node/pull/39491)
+* [[`8799a134e4`](https://github.com/nodejs/node/commit/8799a134e4)] - **doc**: move `NODE_MODULE_VERSION` in release guide (Richard Lau) [#39544](https://github.com/nodejs/node/pull/39544)
+* [[`89c8afcf48`](https://github.com/nodejs/node/commit/89c8afcf48)] - **doc**: remove outdated ARM information from release guide (Richard Lau) [#39544](https://github.com/nodejs/node/pull/39544)
+* [[`a718b26f28`](https://github.com/nodejs/node/commit/a718b26f28)] - **doc**: fence command examples in release guide (Richard Lau) [#39544](https://github.com/nodejs/node/pull/39544)
+* [[`42669bb049`](https://github.com/nodejs/node/commit/42669bb049)] - **doc**: update backport labels in release guide (Richard Lau) [#39544](https://github.com/nodejs/node/pull/39544)
+* [[`a437de3c5f`](https://github.com/nodejs/node/commit/a437de3c5f)] - **doc**: add code example to `http.createServer` method (Juan José Arboleda) [#39455](https://github.com/nodejs/node/pull/39455)
+* [[`695569fc17`](https://github.com/nodejs/node/commit/695569fc17)] - **doc**: move lball@redhat.com to emeritus (Lance Ball) [#39501](https://github.com/nodejs/node/pull/39501)
+* [[`c7523da86c`](https://github.com/nodejs/node/commit/c7523da86c)] - **doc**: update AUTHORS (Rich Trott) [#39488](https://github.com/nodejs/node/pull/39488)
+* [[`e826109d5c`](https://github.com/nodejs/node/commit/e826109d5c)] - **doc**: update strategic initiative champion (Rich Trott) [#39487](https://github.com/nodejs/node/pull/39487)
+* [[`39da842051`](https://github.com/nodejs/node/commit/39da842051)] - **doc**: simplify unnecessarily specific .mailmap entries (Rich Trott) [#39430](https://github.com/nodejs/node/pull/39430)
+* [[`6a4c6ce4d7`](https://github.com/nodejs/node/commit/6a4c6ce4d7)] - **doc**: update checkbox label in backporting guide (Darshan Sen) [#39420](https://github.com/nodejs/node/pull/39420)
+* [[`d17afa08bd`](https://github.com/nodejs/node/commit/d17afa08bd)] - **doc**: remove \_Addenda\_ from headers (Rich Trott) [#39427](https://github.com/nodejs/node/pull/39427)
+* [[`ae97a96d9e`](https://github.com/nodejs/node/commit/ae97a96d9e)] - **doc**: simplify .mailmap file (Rich Trott) [#39418](https://github.com/nodejs/node/pull/39418)
+* [[`a3dee70f66`](https://github.com/nodejs/node/commit/a3dee70f66)] - **doc**: fix broken internal link in http.md (Rich Trott) [#39425](https://github.com/nodejs/node/pull/39425)
+* [[`ca947ac524`](https://github.com/nodejs/node/commit/ca947ac524)] - **doc**: remove outdated step in onboarding exercise (Rich Trott) [#39410](https://github.com/nodejs/node/pull/39410)
+* [[`86e12607f0`](https://github.com/nodejs/node/commit/86e12607f0)] - **doc**: revise strategic initiatives text (Rich Trott) [#39417](https://github.com/nodejs/node/pull/39417)
+* [[`cd8e773d28`](https://github.com/nodejs/node/commit/cd8e773d28)] - **doc**: update mailmap and AUTHORS (Rich Trott) [#39393](https://github.com/nodejs/node/pull/39393)
+* [[`8376b07ae8`](https://github.com/nodejs/node/commit/8376b07ae8)] - **doc**: use a details tag for completed initiatves (Rich Trott) [#39416](https://github.com/nodejs/node/pull/39416)
+* [[`43d28f5f00`](https://github.com/nodejs/node/commit/43d28f5f00)] - **doc**: update commit-queue.md to indicate GitHub Actions are checked (Rich Trott) [#39411](https://github.com/nodejs/node/pull/39411)
+* [[`63b0603e95`](https://github.com/nodejs/node/commit/63b0603e95)] - **doc**: use \_pull request\_ instead of \_PR\_ in onboarding doc (Rich Trott) [#39409](https://github.com/nodejs/node/pull/39409)
+* [[`73f784f764`](https://github.com/nodejs/node/commit/73f784f764)] - **doc**: add strategic initiatives from TSC repo (Rich Trott) [#39394](https://github.com/nodejs/node/pull/39394)
+* [[`1a494d51dc`](https://github.com/nodejs/node/commit/1a494d51dc)] - **doc**: standardize on \_pull request\_ (Rich Trott) [#39384](https://github.com/nodejs/node/pull/39384)
+* [[`eb12e4ccfb`](https://github.com/nodejs/node/commit/eb12e4ccfb)] - **doc**: make minor edits to pull request text (Rich Trott) [#39383](https://github.com/nodejs/node/pull/39383)
+* [[`ab0bf4fa1a`](https://github.com/nodejs/node/commit/ab0bf4fa1a)] - **doc**: add docker-node and build-wg issue contents (Daniel Bevenius) [#39215](https://github.com/nodejs/node/pull/39215)
+* [[`8438e8bf33`](https://github.com/nodejs/node/commit/8438e8bf33)] - **doc**: add instructions for core vuln files (Daniel Bevenius) [#39220](https://github.com/nodejs/node/pull/39220)
+* [[`c3cfefc2d3`](https://github.com/nodejs/node/commit/c3cfefc2d3)] - **doc**: standardize on not capitalizing \_collaborator\_ (Rich Trott) [#39379](https://github.com/nodejs/node/pull/39379)
+* [[`672023f9f2`](https://github.com/nodejs/node/commit/672023f9f2)] - **doc**: update mailmap and deduplicate AUTHORS entry (Rich Trott) [#39391](https://github.com/nodejs/node/pull/39391)
+* [[`baaa397e39`](https://github.com/nodejs/node/commit/baaa397e39)] - **doc**: update AUTHORS (Rich Trott) [#39367](https://github.com/nodejs/node/pull/39367)
+* [[`f39d93a428`](https://github.com/nodejs/node/commit/f39d93a428)] - **doc**: move jdalton to emeritus (Rich Trott) [#39380](https://github.com/nodejs/node/pull/39380)
+* [[`0b1ce72d64`](https://github.com/nodejs/node/commit/0b1ce72d64)] - **doc**: edit guide on pull requests (Rich Trott) [#39359](https://github.com/nodejs/node/pull/39359)
+* [[`6f0b3a20d1`](https://github.com/nodejs/node/commit/6f0b3a20d1)] - **doc**: add text about moving long commit lists out of PR description (Danielle Adams) [#39186](https://github.com/nodejs/node/pull/39186)
+* [[`9d43ce3b80`](https://github.com/nodejs/node/commit/9d43ce3b80)] - **doc**: do not use & for "and" in text (Rich Trott) [#39345](https://github.com/nodejs/node/pull/39345)
+* [[`25c104f21f`](https://github.com/nodejs/node/commit/25c104f21f)] - **doc**: update AUTHORS (Rich Trott) [#39277](https://github.com/nodejs/node/pull/39277)
+* [[`b47b47930c`](https://github.com/nodejs/node/commit/b47b47930c)] - **doc**: put information about the past in details tags (Rich Trott) [#39321](https://github.com/nodejs/node/pull/39321)
+* [[`5eafc3afa8`](https://github.com/nodejs/node/commit/5eafc3afa8)] - **doc**: move AndreasMadsen to emeritus (Rich Trott) [#39315](https://github.com/nodejs/node/pull/39315)
+* [[`fbf658f1d5`](https://github.com/nodejs/node/commit/fbf658f1d5)] - **doc**: move ofrobots to collaborator emeritus (Rich Trott) [#39307](https://github.com/nodejs/node/pull/39307)
+* [[`fc7d714149`](https://github.com/nodejs/node/commit/fc7d714149)] - **doc**: simplify CRAN mirror text in benchmark guide (Rich Trott) [#39287](https://github.com/nodejs/node/pull/39287)
+* [[`22f0b7e0d0`](https://github.com/nodejs/node/commit/22f0b7e0d0)] - **doc**: use "repository" instead of "repo" in onboarding.md (Rich Trott) [#39286](https://github.com/nodejs/node/pull/39286)
+* [[`f46ae3ffb6`](https://github.com/nodejs/node/commit/f46ae3ffb6)] - **doc**: update collaborator email address (Rich Trott) [#39263](https://github.com/nodejs/node/pull/39263)
+* [[`8c569cef88`](https://github.com/nodejs/node/commit/8c569cef88)] - **doc**: remove GitHub mark (Rich Trott) [#39251](https://github.com/nodejs/node/pull/39251)
+* [[`b4a0c5a384`](https://github.com/nodejs/node/commit/b4a0c5a384)] - **doc**: remove emailing the TSC from offboarding doc (Rich Trott) [#39280](https://github.com/nodejs/node/pull/39280)
+* [[`a4d70ff0cc`](https://github.com/nodejs/node/commit/a4d70ff0cc)] - **doc**: use "repository" in guides versus repo (Michael Dawson) [#39198](https://github.com/nodejs/node/pull/39198)
+* [[`31163ed9ee`](https://github.com/nodejs/node/commit/31163ed9ee)] - **doc**: update Node-api version matrix (Michael Dawson) [#39197](https://github.com/nodejs/node/pull/39197)
+* [[`9357547519`](https://github.com/nodejs/node/commit/9357547519)] - **doc**: update node-api support matrix (Michael Dawson) [#38424](https://github.com/nodejs/node/pull/38424)
+* [[`f08e9d5230`](https://github.com/nodejs/node/commit/f08e9d5230)] - **doc**: remove onboarding-extras (Rich Trott) [#39252](https://github.com/nodejs/node/pull/39252)
+* [[`6466faf26d`](https://github.com/nodejs/node/commit/6466faf26d)] - **doc**: move Sam Ruby to emeritus (Rich Trott) [#39264](https://github.com/nodejs/node/pull/39264)
+* [[`06acbf6453`](https://github.com/nodejs/node/commit/06acbf6453)] - **doc**: update AUTHORS file (Rich Trott) [#39250](https://github.com/nodejs/node/pull/39250)
+* [[`9178805653`](https://github.com/nodejs/node/commit/9178805653)] - **doc**: fix color contrast for anchor marks in dark mode (Rich Trott) [#39168](https://github.com/nodejs/node/pull/39168)
+* [[`c6118b23f7`](https://github.com/nodejs/node/commit/c6118b23f7)] - **doc**: rename datatypes to data types (FrankEntriken) [#39209](https://github.com/nodejs/node/pull/39209)
+* [[`fdd315918f`](https://github.com/nodejs/node/commit/fdd315918f)] - **doc**: normalize CSS variable names and indentation (Rich Trott) [#39199](https://github.com/nodejs/node/pull/39199)
+* [[`9c7c44781c`](https://github.com/nodejs/node/commit/9c7c44781c)] - **doc**: use more consistent formatting for deprecations (Rich Trott) [#39218](https://github.com/nodejs/node/pull/39218)
+* [[`c97ebd7905`](https://github.com/nodejs/node/commit/c97ebd7905)] - **doc**: update AUTHORS (Rich Trott) [#39217](https://github.com/nodejs/node/pull/39217)
+* [[`c4a3a24848`](https://github.com/nodejs/node/commit/c4a3a24848)] - **doc**: use "pull request" instead of "PR" in packages.md (Rich Trott) [#39213](https://github.com/nodejs/node/pull/39213)
+* [[`0d098bfaf0`](https://github.com/nodejs/node/commit/0d098bfaf0)] - **doc**: move v8.stopCoverage() to expected location in doc (Rich Trott) [#39212](https://github.com/nodejs/node/pull/39212)
+* [[`bd6af78749`](https://github.com/nodejs/node/commit/bd6af78749)] - **doc**: move vm.measureMemory() to expected location in doc (Rich Trott) [#39211](https://github.com/nodejs/node/pull/39211)
+* [[`7378b84bb8`](https://github.com/nodejs/node/commit/7378b84bb8)] - **doc**: add missing deprecation code (Colin Ihrig) [#37147](https://github.com/nodejs/node/pull/37147)
+* [[`2f6861ca51`](https://github.com/nodejs/node/commit/2f6861ca51)] - **doc**: use ASCII order for md refs (Antoine du Hamel) [#39170](https://github.com/nodejs/node/pull/39170)
+* [[`fa3909504f`](https://github.com/nodejs/node/commit/fa3909504f)] - **doc**: add cc oss-security@lists.openwall.com (Daniel Bevenius) [#39191](https://github.com/nodejs/node/pull/39191)
+* [[`52105acd5f`](https://github.com/nodejs/node/commit/52105acd5f)] - **doc**: remove instructions for unsupported Node.js versions (Rich Trott) [#39185](https://github.com/nodejs/node/pull/39185)
+* [[`eb2d75da16`](https://github.com/nodejs/node/commit/eb2d75da16)] - **doc**: remove obsolete cc recommendations (Rich Trott) [#39181](https://github.com/nodejs/node/pull/39181)
+* [[`4cf17edd03`](https://github.com/nodejs/node/commit/4cf17edd03)] - **doc**: use "repository" in maintaining-V8 doc (Rich Trott) [#39179](https://github.com/nodejs/node/pull/39179)
+* [[`d6a4f8aac9`](https://github.com/nodejs/node/commit/d6a4f8aac9)] - **doc**: fix broken link in errors.md (Rich Trott) [#39200](https://github.com/nodejs/node/pull/39200)
+* [[`82458b30fe`](https://github.com/nodejs/node/commit/82458b30fe)] - **doc**: correct JavaScript primitive value names in n-api.md (legendecas) [#39129](https://github.com/nodejs/node/pull/39129)
+* [[`2629979fd0`](https://github.com/nodejs/node/commit/2629979fd0)] - **doc**: apply logical ordering to CSS variables (Rich Trott) [#39169](https://github.com/nodejs/node/pull/39169)
+* [[`1996580b06`](https://github.com/nodejs/node/commit/1996580b06)] - **doc**: use repository instead of repo (Rich Trott) [#39157](https://github.com/nodejs/node/pull/39157)
+* [[`74ba115ab6`](https://github.com/nodejs/node/commit/74ba115ab6)] - **doc**: fix `EventTarget.dispatchEvent` docs (Rohan Sharma) [#39127](https://github.com/nodejs/node/pull/39127)
+* [[`2884d9094d`](https://github.com/nodejs/node/commit/2884d9094d)] - **doc**: update AUTHORS file (Rich Trott) [#39082](https://github.com/nodejs/node/pull/39082)
+* [[`d069c725b1`](https://github.com/nodejs/node/commit/d069c725b1)] - **doc**: fix napi\_default\_property name (Davidson Francis) [#39104](https://github.com/nodejs/node/pull/39104)
+* [[`1b74d3f775`](https://github.com/nodejs/node/commit/1b74d3f775)] - **doc**: fix dead links in packages.md (Michaël Zasso) [#39113](https://github.com/nodejs/node/pull/39113)
+* [[`0c2b5a048d`](https://github.com/nodejs/node/commit/0c2b5a048d)] - **doc**: clearify that http does chunked encoding itself (Mao Wtm) [#28379](https://github.com/nodejs/node/pull/28379)
+* [[`d0d731e271`](https://github.com/nodejs/node/commit/d0d731e271)] - **doc**: add descriptions about when `options.mode` is ignored (Ray) [#39881](https://github.com/nodejs/node/pull/39881)
+* [[`898db5a570`](https://github.com/nodejs/node/commit/898db5a570)] - **doc**: add code example to `fs.truncate` method (Juan José Arboleda) [#39454](https://github.com/nodejs/node/pull/39454)
+* [[`05d7460747`](https://github.com/nodejs/node/commit/05d7460747)] - **doc**: add annotation to writeFile `data` as `Object` (Jacob) [#39167](https://github.com/nodejs/node/pull/39167)
+* [[`2ef61b987d`](https://github.com/nodejs/node/commit/2ef61b987d)] - **doc**: fix constants usage in fs.access example (Cyrille Bourgois) [#39289](https://github.com/nodejs/node/pull/39289)
+* [[`b2c533ea1d`](https://github.com/nodejs/node/commit/b2c533ea1d)] - **doc**: remove unnecessary module format comments (Rich Trott) [#39219](https://github.com/nodejs/node/pull/39219)
+* [[`e8355c47d2`](https://github.com/nodejs/node/commit/e8355c47d2)] - **doc**: remove file name from self-reference links (Antoine du Hamel) [#39165](https://github.com/nodejs/node/pull/39165)
+* [[`f799c4617e`](https://github.com/nodejs/node/commit/f799c4617e)] - **doc**: use `await` in filehandle.truncate() snippet (RA80533) [#38939](https://github.com/nodejs/node/pull/38939)
+* [[`e7f3f0d778`](https://github.com/nodejs/node/commit/e7f3f0d778)] - **doc**: update abort signal in fs promise api example (Moritz Kneilmann) [#38669](https://github.com/nodejs/node/pull/38669)
+* [[`a44219d979`](https://github.com/nodejs/node/commit/a44219d979)] - **doc**: add documentation for fs.WriteStream.close() (Hitesh Sharma) [#38610](https://github.com/nodejs/node/pull/38610)
+* [[`c3ae1cfbab`](https://github.com/nodejs/node/commit/c3ae1cfbab)] - **doc**: fix fs.openSync() signature (Luigi Pinca) [#38591](https://github.com/nodejs/node/pull/38591)
+* [[`23a8aed3f9`](https://github.com/nodejs/node/commit/23a8aed3f9)] - **doc**: typo stats() should be stat(); clarity (Bryan Field) [#38541](https://github.com/nodejs/node/pull/38541)
+* [[`9fe46ea0fd`](https://github.com/nodejs/node/commit/9fe46ea0fd)] - **doc**: fix broken AHAFS link in fs doc (Rich Trott) [#38534](https://github.com/nodejs/node/pull/38534)
+* [[`7a92c3cfd4`](https://github.com/nodejs/node/commit/7a92c3cfd4)] - **doc**: clarify that fs.Dir async iterator closes automatically (James M Snell) [#38438](https://github.com/nodejs/node/pull/38438)
+* [[`b819848487`](https://github.com/nodejs/node/commit/b819848487)] - **doc**: remove superfluous await from fsPromises.readdir example (Michael Rommel) [#38293](https://github.com/nodejs/node/pull/38293)
+* [[`9fa7dcf9df`](https://github.com/nodejs/node/commit/9fa7dcf9df)] - **doc**: fix missing backtick in fs.md (Siddharth) [#38260](https://github.com/nodejs/node/pull/38260)
+* [[`4cf4ee99dc`](https://github.com/nodejs/node/commit/4cf4ee99dc)] - **doc**: fix typo in fs.md (Antoine du Hamel) [#38100](https://github.com/nodejs/node/pull/38100)
+* [[`f9d36cbf42`](https://github.com/nodejs/node/commit/f9d36cbf42)] - **doc**: fix typos in /doc/api/fs.md (Merlin Luntke) [#37557](https://github.com/nodejs/node/pull/37557)
+* [[`bbcc2171c5`](https://github.com/nodejs/node/commit/bbcc2171c5)] - **doc**: fix typo "director" instead of "directory" (humanwebpl) [#37523](https://github.com/nodejs/node/pull/37523)
+* [[`67ac6b3b66`](https://github.com/nodejs/node/commit/67ac6b3b66)] - **doc**: fix "referred to" in fs docs (Tobias Nießen) [#37388](https://github.com/nodejs/node/pull/37388)
+* [[`3b9fa2412f`](https://github.com/nodejs/node/commit/3b9fa2412f)] - **doc**: change "Version 4 UUID" to "version 4 UUID" (Tobias Nießen) [#39682](https://github.com/nodejs/node/pull/39682)
+* [[`3d26572773`](https://github.com/nodejs/node/commit/3d26572773)] - **doc**: add point to ask H1 reporter about credit (Daniel Bevenius) [#39585](https://github.com/nodejs/node/pull/39585)
+* [[`469190d13c`](https://github.com/nodejs/node/commit/469190d13c)] - **doc**: move util.toUSVString() outside of deprecated group (Luigi Pinca) [#39840](https://github.com/nodejs/node/pull/39840)
+* [[`f509788850`](https://github.com/nodejs/node/commit/f509788850)] - **doc**: fix lint error in modules.md (Rich Trott) [#37811](https://github.com/nodejs/node/pull/37811)
+* [[`a7833c7ce6`](https://github.com/nodejs/node/commit/a7833c7ce6)] - **doc**: refactor signal info in child\_process.md (Darshan Sen) [#37528](https://github.com/nodejs/node/pull/37528)
+* [[`f5b2fe1204`](https://github.com/nodejs/node/commit/f5b2fe1204)] - **doc**: change lang info string in fs JS snippets (Antoine du Hamel) [#37605](https://github.com/nodejs/node/pull/37605)
+* [[`307c1d817f`](https://github.com/nodejs/node/commit/307c1d817f)] - **doc**: refactor fs docs structure (Michaël Zasso) [#37170](https://github.com/nodejs/node/pull/37170)
+* [[`298a16a2e7`](https://github.com/nodejs/node/commit/298a16a2e7)] - **doc**: update emitClose default for fs streams (Kevin Locke) [#36653](https://github.com/nodejs/node/pull/36653)
+* [[`0c469b3f77`](https://github.com/nodejs/node/commit/0c469b3f77)] - **doc**: revise process.memoryUsage() text (Rich Trott) [#36757](https://github.com/nodejs/node/pull/36757)
+* [[`1ebe7d70ea`](https://github.com/nodejs/node/commit/1ebe7d70ea)] - **doc**: fix punctuation in v8.md (Rich Trott) [#36192](https://github.com/nodejs/node/pull/36192)
+* [[`591a05b637`](https://github.com/nodejs/node/commit/591a05b637)] - **doc**: add link for v8.takeCoverage() (Rich Trott) [#36135](https://github.com/nodejs/node/pull/36135)
+* [[`e5fe3164f3`](https://github.com/nodejs/node/commit/e5fe3164f3)] - **doc**: add YAML metadata for process.memoryUsage.rss (Gerhard Stoebich) [#36781](https://github.com/nodejs/node/pull/36781)
+
+#### Other commits
+
+* [[`ab66dabbf2`](https://github.com/nodejs/node/commit/ab66dabbf2)] - **doc,meta**: update email addresses for misterdjules (Rich Trott) [#39433](https://github.com/nodejs/node/pull/39433)
+* [[`c6ccd97fe2`](https://github.com/nodejs/node/commit/c6ccd97fe2)] - **doc,tools**: remove `checkLinks.mjs` (Antoine du Hamel) [#39206](https://github.com/nodejs/node/pull/39206)
+* [[`8f8f528f08`](https://github.com/nodejs/node/commit/8f8f528f08)] - **meta**: add gyp as owner of gyp files and tools/gyp (Mary Marchini) [#34847](https://github.com/nodejs/node/pull/34847)
+* [[`4b2eee5232`](https://github.com/nodejs/node/commit/4b2eee5232)] - **meta**: consolidate AUTHORS entries for ooHmartY (Rich Trott) [#39705](https://github.com/nodejs/node/pull/39705)
+* [[`6916a6c2b0`](https://github.com/nodejs/node/commit/6916a6c2b0)] - **meta**: consolidate AUTHORS entries for homosaur (Rich Trott) [#39705](https://github.com/nodejs/node/pull/39705)
+* [[`b65a635c8a`](https://github.com/nodejs/node/commit/b65a635c8a)] - **meta**: consolidate AUTHORS entries for Ayase-252 (Rich Trott) [#39705](https://github.com/nodejs/node/pull/39705)
+* [[`e86b59cf4c`](https://github.com/nodejs/node/commit/e86b59cf4c)] - **meta**: consolidate AUTHORS entries for robin-drexler (Rich Trott) [#39705](https://github.com/nodejs/node/pull/39705)
+* [[`1eda8442bd`](https://github.com/nodejs/node/commit/1eda8442bd)] - **meta**: consolidate AUTHORS entries for samshull (Rich Trott) [#39705](https://github.com/nodejs/node/pull/39705)
+* [[`cd67d86572`](https://github.com/nodejs/node/commit/cd67d86572)] - **meta**: update AUTHORS (Rich Trott) [#39705](https://github.com/nodejs/node/pull/39705)
+* [[`bb06282a9e`](https://github.com/nodejs/node/commit/bb06282a9e)] - **meta**: consolidate email addresses for MarshallOfSound (Rich Trott) [#39651](https://github.com/nodejs/node/pull/39651)
+* [[`12fe34eae4`](https://github.com/nodejs/node/commit/12fe34eae4)] - **meta**: consolidate email addresses for tadjik1 (Rich Trott) [#39651](https://github.com/nodejs/node/pull/39651)
+* [[`4301e252b4`](https://github.com/nodejs/node/commit/4301e252b4)] - **meta**: consolidate email addresses for szmarczak (Rich Trott) [#39651](https://github.com/nodejs/node/pull/39651)
+* [[`3e8fc49730`](https://github.com/nodejs/node/commit/3e8fc49730)] - **meta**: update AUTHORS (Rich Trott) [#39636](https://github.com/nodejs/node/pull/39636)
+* [[`60f41c34dd`](https://github.com/nodejs/node/commit/60f41c34dd)] - **meta**: simplify mailmap (Rich Trott) [#39612](https://github.com/nodejs/node/pull/39612)
+* [[`fc9c680260`](https://github.com/nodejs/node/commit/fc9c680260)] - **meta**: consolidate emails for tadhgcreedon (Rich Trott) [#39611](https://github.com/nodejs/node/pull/39611)
+* [[`d87fcf9959`](https://github.com/nodejs/node/commit/d87fcf9959)] - **meta**: consolidate emails for timcosta (Rich Trott) [#39611](https://github.com/nodejs/node/pull/39611)
+* [[`fdbe97849b`](https://github.com/nodejs/node/commit/fdbe97849b)] - **meta**: consolidate emails for timruffles (Rich Trott) [#39611](https://github.com/nodejs/node/pull/39611)
+* [[`b9f2ea92e9`](https://github.com/nodejs/node/commit/b9f2ea92e9)] - **meta**: update AUTHORS (Rich Trott) [#39629](https://github.com/nodejs/node/pull/39629)
+* [[`472cf1520e`](https://github.com/nodejs/node/commit/472cf1520e)] - **meta**: add mailmap entry for ryzokuken (Rich Trott) [#39596](https://github.com/nodejs/node/pull/39596)
+* [[`ae3f8b1eda`](https://github.com/nodejs/node/commit/ae3f8b1eda)] - **meta**: add mailmap entry for uttampawar (Rich Trott) [#39596](https://github.com/nodejs/node/pull/39596)
+* [[`2a2d8ebd90`](https://github.com/nodejs/node/commit/2a2d8ebd90)] - **meta**: add mailmap entry for dmabupt (Rich Trott) [#39596](https://github.com/nodejs/node/pull/39596)
+* [[`030036ec92`](https://github.com/nodejs/node/commit/030036ec92)] - **meta**: align README/.mailmap/AUTHORS email entries (Rich Trott) [#39505](https://github.com/nodejs/node/pull/39505)
+* [[`fd2146be91`](https://github.com/nodejs/node/commit/fd2146be91)] - **meta**: add mailmap entry for garygsc (Rich Trott) [#39588](https://github.com/nodejs/node/pull/39588)
+* [[`0833e2d9cb`](https://github.com/nodejs/node/commit/0833e2d9cb)] - **meta**: add mailmap entry for ttzztztz (Rich Trott) [#39588](https://github.com/nodejs/node/pull/39588)
+* [[`1fbc19ee32`](https://github.com/nodejs/node/commit/1fbc19ee32)] - **meta**: update AUTHORS (Rich Trott) [#39587](https://github.com/nodejs/node/pull/39587)
+* [[`2d6428665d`](https://github.com/nodejs/node/commit/2d6428665d)] - **meta**: update .mailmap to remove duplication in AUTHORS (Rich Trott) [#39561](https://github.com/nodejs/node/pull/39561)
+* [[`6c4febd701`](https://github.com/nodejs/node/commit/6c4febd701)] - **meta**: add .mailmap entries to remove AUTHORS duplicates (Rich Trott) [#39560](https://github.com/nodejs/node/pull/39560)
+* [[`1755f49a20`](https://github.com/nodejs/node/commit/1755f49a20)] - **meta**: add .mailmap entry to remove duplication in AUTHORS (Rich Trott) [#39559](https://github.com/nodejs/node/pull/39559)
+* [[`fdcc5729d9`](https://github.com/nodejs/node/commit/fdcc5729d9)] - **meta**: update collaborator email in AUTHORS/.mailmap (Rich Trott) [#39521](https://github.com/nodejs/node/pull/39521)
+* [[`27e9a44852`](https://github.com/nodejs/node/commit/27e9a44852)] - **meta**: update collaborator email in README (Rich Trott) [#39521](https://github.com/nodejs/node/pull/39521)
+* [[`5e1c49ff0f`](https://github.com/nodejs/node/commit/5e1c49ff0f)] - **meta**: update collaborator email in AUTHORS/.mailmap (Rich Trott) [#39521](https://github.com/nodejs/node/pull/39521)
+* [[`fbecae169e`](https://github.com/nodejs/node/commit/fbecae169e)] - **meta**: move gdams to emeritus (Rich Trott) [#39539](https://github.com/nodejs/node/pull/39539)
+* [[`48ec33f1b8`](https://github.com/nodejs/node/commit/48ec33f1b8)] - **meta**: update collaborator email in README (Rich Trott) [#39510](https://github.com/nodejs/node/pull/39510)
+* [[`f269df31ea`](https://github.com/nodejs/node/commit/f269df31ea)] - **meta**: remove unneeded .mailmap entry (Rich Trott) [#39512](https://github.com/nodejs/node/pull/39512)
+* [[`b0c1aab28d`](https://github.com/nodejs/node/commit/b0c1aab28d)] - **meta**: update email address for collaborator (Rich Trott) [#39511](https://github.com/nodejs/node/pull/39511)
+* [[`5f4935292a`](https://github.com/nodejs/node/commit/5f4935292a)] - **meta**: align collaborator name in .mailmap/AUTHORS with README (Rich Trott) [#39489](https://github.com/nodejs/node/pull/39489)
+* [[`1b2078c912`](https://github.com/nodejs/node/commit/1b2078c912)] - **meta**: align email address in README/.mailmap/AUTHORS (Rich Trott) [#39503](https://github.com/nodejs/node/pull/39503)
+* [[`2f816bf24b`](https://github.com/nodejs/node/commit/2f816bf24b)] - **meta**: revise .mailmap for README consistency (Rich Trott) [#39457](https://github.com/nodejs/node/pull/39457)
+* [[`1302a911f5`](https://github.com/nodejs/node/commit/1302a911f5)] - **meta**: alphabetize .mailmap file (Rich Trott) [#39434](https://github.com/nodejs/node/pull/39434)
+* [[`55322c0260`](https://github.com/nodejs/node/commit/55322c0260)] - **meta**: align collaborator email in .mailmap/AUTHORS with README (Rich Trott) [#39478](https://github.com/nodejs/node/pull/39478)
+* [[`83f5cc0bd4`](https://github.com/nodejs/node/commit/83f5cc0bd4)] - **meta**: update AUTHORS (Rich Trott) [#39461](https://github.com/nodejs/node/pull/39461)
+* [[`69b56a3fe9`](https://github.com/nodejs/node/commit/69b56a3fe9)] - **meta**: add .mailmap entry for new email for existing contributor (Rich Trott) [#39431](https://github.com/nodejs/node/pull/39431)
+* [[`2f325c946f`](https://github.com/nodejs/node/commit/2f325c946f)] - **meta**: use form schema for bug report template (Michaël Zasso) [#39194](https://github.com/nodejs/node/pull/39194)
+* [[`9766a99dd2`](https://github.com/nodejs/node/commit/9766a99dd2)] - **meta**: add @nodejs/actions as CODEOWNERS (Mary Marchini) [#39119](https://github.com/nodejs/node/pull/39119)
+* [[`007f9a0e36`](https://github.com/nodejs/node/commit/007f9a0e36)] - **test**: fix test-vm-memleak for high baseline platforms (Rich Trott) [#38062](https://github.com/nodejs/node/pull/38062)
+* [[`0fabd8e755`](https://github.com/nodejs/node/commit/0fabd8e755)] - **test**: fix flaky test-vm-memleak (Rich Trott) [#38054](https://github.com/nodejs/node/pull/38054)
+* [[`64fb928ec7`](https://github.com/nodejs/node/commit/64fb928ec7)] - **test**: fix flaky test-child-process-exec-abortcontroller-promisified (Antoine du Hamel) [#37572](https://github.com/nodejs/node/pull/37572)
+* [[`e660892f1a`](https://github.com/nodejs/node/commit/e660892f1a)] - **test**: use simplfied validator (voltrexmaster) [#39753](https://github.com/nodejs/node/pull/39753)
+* [[`779417f97e`](https://github.com/nodejs/node/commit/779417f97e)] - **test**: use template to concatenate string (Himadri Ganguly) [#39621](https://github.com/nodejs/node/pull/39621)
+* [[`a61076042d`](https://github.com/nodejs/node/commit/a61076042d)] - **test**: deflake test-http2-buffersize (Luigi Pinca) [#39591](https://github.com/nodejs/node/pull/39591)
+* [[`68ef265c39`](https://github.com/nodejs/node/commit/68ef265c39)] - **test**: convert anonymous function to arrow function (Himadri Ganguly) [#39604](https://github.com/nodejs/node/pull/39604)
+* [[`78db43c9e7`](https://github.com/nodejs/node/commit/78db43c9e7)] - **test**: add test-debugger-breakpoint-exists (Rich Trott) [#39570](https://github.com/nodejs/node/pull/39570)
+* [[`5696bcf715`](https://github.com/nodejs/node/commit/5696bcf715)] - **test**: fix WASI link test (Richard Lau) [#39485](https://github.com/nodejs/node/pull/39485)
+* [[`0b564a6d40`](https://github.com/nodejs/node/commit/0b564a6d40)] - **test**: add test for WebSocket secret verification in debugger (Rich Trott) [#39357](https://github.com/nodejs/node/pull/39357)
+* [[`831f266d6f`](https://github.com/nodejs/node/commit/831f266d6f)] - **test**: put common lint exceptions into config file (Rich Trott) [#39358](https://github.com/nodejs/node/pull/39358)
+* [[`d8066f5325`](https://github.com/nodejs/node/commit/d8066f5325)] - **test**: mark test-domain-error-types flaky (James M Snell) [#39369](https://github.com/nodejs/node/pull/39369)
+* [[`c915a1bd04`](https://github.com/nodejs/node/commit/c915a1bd04)] - **test**: remove eslint-disable comment from fixture file (Rich Trott) [#39320](https://github.com/nodejs/node/pull/39320)
+* [[`1eb8307cc5`](https://github.com/nodejs/node/commit/1eb8307cc5)] - **test**: move debugger test case to parallel (Rich Trott) [#39300](https://github.com/nodejs/node/pull/39300)
+* [[`546202364c`](https://github.com/nodejs/node/commit/546202364c)] - **test**: remove debugger workaround for AIX (Rich Trott) [#39296](https://github.com/nodejs/node/pull/39296)
+* [[`e12164e88d`](https://github.com/nodejs/node/commit/e12164e88d)] - **test**: fix test-debugger-heap-profiler for workers (Richard Lau) [#39687](https://github.com/nodejs/node/pull/39687)
+* [[`a45bf2f1a0`](https://github.com/nodejs/node/commit/a45bf2f1a0)] - **test**: use common.PORT instead of hardcoded port number (Rich Trott) [#39298](https://github.com/nodejs/node/pull/39298)
+* [[`9b737ebd4b`](https://github.com/nodejs/node/commit/9b737ebd4b)] - **test**: add test for debugger restart message issue (Rich Trott) [#39273](https://github.com/nodejs/node/pull/39273)
+* [[`68523894ab`](https://github.com/nodejs/node/commit/68523894ab)] - **test**: remove workaround code in debugger test (Rich Trott) [#39238](https://github.com/nodejs/node/pull/39238)
+* [[`2cd414147b`](https://github.com/nodejs/node/commit/2cd414147b)] - **test**: move test-debugger-address to parallel (Rich Trott) [#39236](https://github.com/nodejs/node/pull/39236)
+* [[`a2e4020e4b`](https://github.com/nodejs/node/commit/a2e4020e4b)] - **test**: prepare for consistent comma-dangle lint rule (Rich Trott) [#37930](https://github.com/nodejs/node/pull/37930)
+* [[`62b439e04d`](https://github.com/nodejs/node/commit/62b439e04d)] - **test**: replace "inspector-cli" with "debugger" (Rich Trott) [#39156](https://github.com/nodejs/node/pull/39156)
+* [[`f13a302d23`](https://github.com/nodejs/node/commit/f13a302d23)] - **test**: improve coverage of stream.Readable (Rongjian Zhang) [#38702](https://github.com/nodejs/node/pull/38702)
+* [[`f3d2e6ac29`](https://github.com/nodejs/node/commit/f3d2e6ac29)] - **test**: add tests for `bound apply` variants of varargs `primordials` (ExE Boss) [#37005](https://github.com/nodejs/node/pull/37005)
+* [[`f70fd00fb3`](https://github.com/nodejs/node/commit/f70fd00fb3)] - **test**: use localhost test instead of connecting to remote (Adam Majer) [#39011](https://github.com/nodejs/node/pull/39011)
+* [[`c4ff5e4a7e`](https://github.com/nodejs/node/commit/c4ff5e4a7e)] - **test**: update error message keywords (leeight) [#39826](https://github.com/nodejs/node/pull/39826)
+* [[`922dacebfb`](https://github.com/nodejs/node/commit/922dacebfb)] - **test**: increase coverage for Blob (ZiJian Liu) [#38515](https://github.com/nodejs/node/pull/38515)
+* [[`c6ab19895d`](https://github.com/nodejs/node/commit/c6ab19895d)] - **test**: account for OOM risks in heapsnapshot-near-heap-limit tests (Joyee Cheung) [#37761](https://github.com/nodejs/node/pull/37761)
+* [[`971d5be57c`](https://github.com/nodejs/node/commit/971d5be57c)] - **test**: split heap snapshot limit tests (Rich Trott) [#37189](https://github.com/nodejs/node/pull/37189)
+* [[`815d59a7b3`](https://github.com/nodejs/node/commit/815d59a7b3)] - **test**: fix test-memory-usage.js for IBMi (Rich Trott) [#36758](https://github.com/nodejs/node/pull/36758)
+* [[`aa5309c33f`](https://github.com/nodejs/node/commit/aa5309c33f)] - **test**: increase coverage for net/blocklist (Zijian Liu) [#36405](https://github.com/nodejs/node/pull/36405)
+* [[`f3be3ec417`](https://github.com/nodejs/node/commit/f3be3ec417)] - **test**: check mustCall errors in test-fs-read-type (Tobias Nießen) [#36914](https://github.com/nodejs/node/pull/36914)
+* [[`b643fe7edf`](https://github.com/nodejs/node/commit/b643fe7edf)] - **test**: use faster variant for rss (Pooja D P) [#36839](https://github.com/nodejs/node/pull/36839)
+* [[`d4362db111`](https://github.com/nodejs/node/commit/d4362db111)] - **test**: use faster variant for rss in test-crypto-dh-leak (Pooja D P) [#36766](https://github.com/nodejs/node/pull/36766)
+* [[`3094ef967a`](https://github.com/nodejs/node/commit/3094ef967a)] - **test**: use faster variant for rss in test-vm-memleak.js (Pooja D P) [#36769](https://github.com/nodejs/node/pull/36769)
+* [[`ff7879b41e`](https://github.com/nodejs/node/commit/ff7879b41e)] - **test**: use faster variant for rss test-memoryusage-emfile (Pooja D P) [#36768](https://github.com/nodejs/node/pull/36768)
+* [[`d39200c7f4`](https://github.com/nodejs/node/commit/d39200c7f4)] - **tools**: make utils.SearchFiles Python2-compatible (Michaël Zasso) [#40020](https://github.com/nodejs/node/pull/40020)
+* [[`55493f2011`](https://github.com/nodejs/node/commit/55493f2011)] - **tools**: update workflow to open a pull request (Rich Trott) [#39825](https://github.com/nodejs/node/pull/39825)
+* [[`417a3ac474`](https://github.com/nodejs/node/commit/417a3ac474)] - **tools**: use find-inactive-collaborators to modify README.md (Rich Trott) [#39825](https://github.com/nodejs/node/pull/39825)
+* [[`e9b1a006a1`](https://github.com/nodejs/node/commit/e9b1a006a1)] - **tools**: fix markdown linting (Rich Trott) [#39832](https://github.com/nodejs/node/pull/39832)
+* [[`67f1bff657`](https://github.com/nodejs/node/commit/67f1bff657)] - **tools**: update markdown linter dependencies and move to ESM (Antoine du Hamel) [#39801](https://github.com/nodejs/node/pull/39801)
+* [[`67c5921e8a`](https://github.com/nodejs/node/commit/67c5921e8a)] - **tools**: update rollup to latest version in markdown linter (Rich Trott) [#39797](https://github.com/nodejs/node/pull/39797)
+* [[`64714b429a`](https://github.com/nodejs/node/commit/64714b429a)] - **tools**: update markdown lint dependencies (Rich Trott) [#39770](https://github.com/nodejs/node/pull/39770)
+* [[`de9461168a`](https://github.com/nodejs/node/commit/de9461168a)] - **tools**: bump remark-preset-lint-node to 3.0.0 (Rich Trott) [#39755](https://github.com/nodejs/node/pull/39755)
+* [[`dfdf6c7317`](https://github.com/nodejs/node/commit/dfdf6c7317)] - **tools**: update markdown linter rules (Rich Trott) [#38384](https://github.com/nodejs/node/pull/38384)
+* [[`f8fee449f7`](https://github.com/nodejs/node/commit/f8fee449f7)] - **tools**: update path-parse in markdown linter package-lock file (Rich Trott) [#39729](https://github.com/nodejs/node/pull/39729)
+* [[`a338c0e07b`](https://github.com/nodejs/node/commit/a338c0e07b)] - **tools**: fix more build warnings in inspector\_protocol (Richard Lau) [#39725](https://github.com/nodejs/node/pull/39725)
+* [[`09630cf199`](https://github.com/nodejs/node/commit/09630cf199)] - **tools**: cherry-pick ffb34b6d5dbf0 (Darshan Sen) [#39725](https://github.com/nodejs/node/pull/39725)
+* [[`26a067e33e`](https://github.com/nodejs/node/commit/26a067e33e)] - **tools**: update inspector\_protocol to e8ba1a7 (Rich Trott) [#39694](https://github.com/nodejs/node/pull/39694)
+* [[`9847d58feb`](https://github.com/nodejs/node/commit/9847d58feb)] - **tools**: update inspector\_protocol to 39ca567 (Rich Trott) [#39694](https://github.com/nodejs/node/pull/39694)
+* [[`6870bb7505`](https://github.com/nodejs/node/commit/6870bb7505)] - **tools**: update inspector\_protocol to 97d3146 (Rich Trott) [#39694](https://github.com/nodejs/node/pull/39694)
+* [[`383fa01e97`](https://github.com/nodejs/node/commit/383fa01e97)] - ***Revert*** "**tools**: fix compiler warning in inspector\_protocol" (Rich Trott) [#39694](https://github.com/nodejs/node/pull/39694)
+* [[`b95a759c86`](https://github.com/nodejs/node/commit/b95a759c86)] - **tools**: update inspector\_protocol to a53e96d31a2755eb16ca37 (Rich Trott) [#39694](https://github.com/nodejs/node/pull/39694)
+* [[`ad39687422`](https://github.com/nodejs/node/commit/ad39687422)] - **tools**: update inspector\_protocol to fe0467fd105a (Rich Trott) [#39694](https://github.com/nodejs/node/pull/39694)
+* [[`78de83cc74`](https://github.com/nodejs/node/commit/78de83cc74)] - **tools**: improve error detection in find-inactive-collaborators (Rich Trott) [#39617](https://github.com/nodejs/node/pull/39617)
+* [[`a5152a0875`](https://github.com/nodejs/node/commit/a5152a0875)] - **tools**: flag README/mailmap mismatches in find-inactive-collaborators (Rich Trott) [#39477](https://github.com/nodejs/node/pull/39477)
+* [[`87c5332f89`](https://github.com/nodejs/node/commit/87c5332f89)] - **tools**: use mailmap for find-inactive-collaborators (Rich Trott) [#39432](https://github.com/nodejs/node/pull/39432)
+* [[`f75224f1ce`](https://github.com/nodejs/node/commit/f75224f1ce)] - **tools**: email matchin is case insensitive for .mailmap (Rich Trott) [#39430](https://github.com/nodejs/node/pull/39430)
+* [[`dfb77a581f`](https://github.com/nodejs/node/commit/dfb77a581f)] - **tools**: make internal link checker more robust (Rich Trott) [#39429](https://github.com/nodejs/node/pull/39429)
+* [[`d2c0da20a0`](https://github.com/nodejs/node/commit/d2c0da20a0)] - **tools**: added remark-frontmatter (Ben Halverson) [#38717](https://github.com/nodejs/node/pull/38717)
+* [[`cec04821aa`](https://github.com/nodejs/node/commit/cec04821aa)] - **tools**: change commit fetch limiting in find-inactive-collaborators (Rich Trott) [#39362](https://github.com/nodejs/node/pull/39362)
+* [[`d948148498`](https://github.com/nodejs/node/commit/d948148498)] - **tools**: use Node.js 16.x for GitHub workflow (Rich Trott) [#39362](https://github.com/nodejs/node/pull/39362)
+* [[`edc5791b5a`](https://github.com/nodejs/node/commit/edc5791b5a)] - **tools**: add GitHub Action to run find-inactive-collaborators.mjs (Rich Trott) [#39335](https://github.com/nodejs/node/pull/39335)
+* [[`d86d37bc9e`](https://github.com/nodejs/node/commit/d86d37bc9e)] - **tools**: relax max-len lint rule for template strings (Rich Trott) [#38097](https://github.com/nodejs/node/pull/38097)
+* [[`f467e2a0c5`](https://github.com/nodejs/node/commit/f467e2a0c5)] - **tools**: pass bot token to node-pr-labeler (Michaël Zasso) [#39271](https://github.com/nodejs/node/pull/39271)
+* [[`61ec594609`](https://github.com/nodejs/node/commit/61ec594609)] - **tools**: add find-inactive-collaborators.js (Rich Trott) [#39262](https://github.com/nodejs/node/pull/39262)
+* [[`ff0ca11521`](https://github.com/nodejs/node/commit/ff0ca11521)] - **tools**: update path-parse to 1.0.7 (Rich Trott) [#39232](https://github.com/nodejs/node/pull/39232)
+* [[`b8fb75121b`](https://github.com/nodejs/node/commit/b8fb75121b)] - **tools**: remove unused `lint-pr-commit-message.sh` (Richard Lau) [#39120](https://github.com/nodejs/node/pull/39120)
+* [[`e7761b627f`](https://github.com/nodejs/node/commit/e7761b627f)] - **tools**: apply consistent comma-dangle lint rule (Rich Trott) [#37930](https://github.com/nodejs/node/pull/37930)
+* [[`315eba7789`](https://github.com/nodejs/node/commit/315eba7789)] - **tools**: make comma-dangle ESLint rule more stringent … (Rich Trott) [#37088](https://github.com/nodejs/node/pull/37088)
+* [[`3ecfe9d7ee`](https://github.com/nodejs/node/commit/3ecfe9d7ee)] - **tools**: update remark-preset-lint-node to 2.4.1 (Rich Trott) [#39201](https://github.com/nodejs/node/pull/39201)
+* [[`70e527c0c7`](https://github.com/nodejs/node/commit/70e527c0c7)] - **tools**: upgrade `highlight.js` to version 11.0.1 (Antoine du Hamel) [#39032](https://github.com/nodejs/node/pull/39032)
+* [[`7b2bebba7a`](https://github.com/nodejs/node/commit/7b2bebba7a)] - **tools**: add support for import assertions in linter (Antoine du Hamel) [#39924](https://github.com/nodejs/node/pull/39924)
+* [[`1353a6e22f`](https://github.com/nodejs/node/commit/1353a6e22f)] - **tools**: update ESLint to 7.32.0 (Luigi Pinca) [#39602](https://github.com/nodejs/node/pull/39602)
+* [[`509f26549c`](https://github.com/nodejs/node/commit/509f26549c)] - **tools**: update ESLint to 7.31.0 (Colin Ihrig) [#39424](https://github.com/nodejs/node/pull/39424)
+* [[`f0e0c8f720`](https://github.com/nodejs/node/commit/f0e0c8f720)] - **tools**: update ESLint to 7.30.0 (Colin Ihrig) [#39242](https://github.com/nodejs/node/pull/39242)
+* [[`6540c271e4`](https://github.com/nodejs/node/commit/6540c271e4)] - **tools**: update @babel/eslint-parser to 7.14.7 (Rich Trott) [#39160](https://github.com/nodejs/node/pull/39160)
+* [[`d7e2318e74`](https://github.com/nodejs/node/commit/d7e2318e74)] - **tools**: add ESLint rule no-array-destructuring (Antoine du Hamel) [#36818](https://github.com/nodejs/node/pull/36818)
+* [[`87e5429334`](https://github.com/nodejs/node/commit/87e5429334)] - **tools,doc**: fix error message for unrecognized type (Antoine du Hamel) [#39221](https://github.com/nodejs/node/pull/39221)
+* [[`f206af679c`](https://github.com/nodejs/node/commit/f206af679c)] - **typings**: add a few JSDoc typings for the net lib module (nerdthatnoonelikes) [#38953](https://github.com/nodejs/node/pull/38953)
+* [[`d458cd7e2b`](https://github.com/nodejs/node/commit/d458cd7e2b)] - **typings**: add JSDoc typings for timers (Voltrex) [#38834](https://github.com/nodejs/node/pull/38834)
+
+<a id="14.17.6"></a>
+## 2021-08-31, Version 14.17.6 'Fermium' (LTS), @MylesBorins
+
+This is a security release.
+
+### Notable Changes
+
+These are vulnerabilities in the node-tar, arborist, and npm cli modules which
+are related to the initial reports and subsequent remediation of node-tar
+vulnerabilities [CVE-2021-32803](https://github.com/advisories/GHSA-r628-mhmh-qjhw)
+and [CVE-2021-32804](https://github.com/advisories/GHSA-3jfq-g458-7qm9).
+Subsequent internal security review of node-tar and additional external bounty
+reports have resulted in another 5 CVE being remediated in core npm CLI
+dependencies including node-tar, and npm arborist.
+
+You can read more about it in:
+
+* [CVE-2021-37701](https://github.com/npm/node-tar/security/advisories/GHSA-9r2w-394v-53qc)
+* [CVE-2021-37712](https://github.com/npm/node-tar/security/advisories/GHSA-qq89-hq3f-393p)
+* [CVE-2021-37713](https://github.com/npm/node-tar/security/advisories/GHSA-5955-9wpr-37jh)
+* [CVE-2021-39134](https://github.com/npm/arborist/security/advisories/GHSA-2h3h-q99f-3fhc)
+* [CVE-2021-39135](https://github.com/npm/arborist/security/advisories/GHSA-gmw6-94gg-2rc2)
+
+### Commits
+
+* [[`5b3f70bfb5`](https://github.com/nodejs/node/commit/5b3f70bfb5)] - **deps**: update archs files for OpenSSL-1.1.1l (Richard Lau) [#39868](https://github.com/nodejs/node/pull/39868)
+* [[`71372625ae`](https://github.com/nodejs/node/commit/71372625ae)] - **deps**: upgrade openssl sources to 1.1.1l (Richard Lau) [#39868](https://github.com/nodejs/node/pull/39868)
+* [[`4276984803`](https://github.com/nodejs/node/commit/4276984803)] - **deps**: upgrade npm to 6.14.15 (Darcy Clarke) [#39856](https://github.com/nodejs/node/pull/39856)
+
+<a id="14.17.5"></a>
+## 2021-08-11, Version 14.17.5 'Fermium' (LTS), @BethGriggs
+
+This is a security release.
+
+### Notable Changes
+
+* **CVE-2021-3672/CVE-2021-22931**: Improper handling of untypical characters in domain names (High)
+  * Node.js was vulnerable to Remote Code Execution, XSS, application crashes due to missing input validation of hostnames returned by Domain Name Servers in the Node.js DNS library which can lead to the output of wrong hostnames (leading to Domain Hijacking) and injection vulnerabilities in applications using the library. You can read more about it at https://nvd.nist.gov/vuln/detail/CVE-2021-22931.
+* **CVE-2021-22930**: Use after free on close http2 on stream canceling (High)
+  * Node.js was vulnerable to a use after free attack where an attacker might be able to exploit memory corruption to change process behavior. This release includes a follow-up fix for CVE-2021-22930 as the issue was not completely resolved by the previous fix. You can read more about it at https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22930.
+* **CVE-2021-22939**: Incomplete validation of rejectUnauthorized parameter (Low)
+  * If the Node.js HTTPS API was used incorrectly and "undefined" was in passed for the "rejectUnauthorized" parameter, no error was returned and connections to servers with an expired certificate would have been accepted. You can read more about it at https://nvd.nist.gov/vuln/detail/CVE-2021-22939.
+
+### Commits
+
+* [[`4923b59e0b`](https://github.com/nodejs/node/commit/4923b59e0b)] - **deps**: update c-ares to 1.17.2 (Beth Griggs) [#39724](https://github.com/nodejs/node/pull/39724)
+* [[`847a4c6a8a`](https://github.com/nodejs/node/commit/847a4c6a8a)] - **deps**: reflect c-ares source tree (Beth Griggs) [#39653](https://github.com/nodejs/node/pull/39653)
+* [[`33208e2f89`](https://github.com/nodejs/node/commit/33208e2f89)] - **deps**: apply missed updates from c-ares 1.17.1 (Beth Griggs) [#39653](https://github.com/nodejs/node/pull/39653)
+* [[`af5c1af9a4`](https://github.com/nodejs/node/commit/af5c1af9a4)] - **http2**: add tests for cancel event while client is paused reading (Akshay K) [#39622](https://github.com/nodejs/node/pull/39622)
+* [[`434872e838`](https://github.com/nodejs/node/commit/434872e838)] - **http2**: update handling of rst\_stream with error code NGHTTP2\_CANCEL (Akshay K) [#39622](https://github.com/nodejs/node/pull/39622)
+* [[`35b86110e4`](https://github.com/nodejs/node/commit/35b86110e4)] - **tls**: validate "rejectUnauthorized: undefined" (Matteo Collina) [nodejs-private/node-private#276](https://github.com/nodejs-private/node-private/pull/276)
+
+<a id="14.17.4"></a>
+## 2021-07-29, Version 14.17.4 'Fermium' (LTS), @richardlau
+
+This is a security release.
+
+### Notable Changes
+
+* **CVE-2021-22930**: Use after free on close http2 on stream canceling (High)
+  * Node.js is vulnerable to a use after free attack where an attacker might be able to exploit the memory corruption, to change process behavior. You can read more about it in https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22930
+
+This releases also fixes some regressions with internationalization introduced by the ICU updates in Node.js 14.17.0 and 14.17.1.
+
+### Commits
+
+* [[`86477b2b53`](https://github.com/nodejs/node/commit/86477b2b53)] - **benchmark**: output JSON-compatible numbers (Michaël Zasso) [#38778](https://github.com/nodejs/node/pull/38778)
+* [[`f9693cf0a0`](https://github.com/nodejs/node/commit/f9693cf0a0)] - **benchmark**: fix http elapsed time (Antoine du Hamel) [#38743](https://github.com/nodejs/node/pull/38743)
+* [[`1ab4f81abc`](https://github.com/nodejs/node/commit/1ab4f81abc)] - **build**: fix building with external builtins (Momtchil Momtchev) [#39091](https://github.com/nodejs/node/pull/39091)
+* [[`a657f250f1`](https://github.com/nodejs/node/commit/a657f250f1)] - **build**: reconfigure when gyp files change on Windows (Joyee Cheung) [#39066](https://github.com/nodejs/node/pull/39066)
+* [[`6962c647d6`](https://github.com/nodejs/node/commit/6962c647d6)] - ***Revert*** "**build**: work around bug in MSBuild v16.10.0" (Michaël Zasso) [#38977](https://github.com/nodejs/node/pull/38977)
+* [[`069cf59e56`](https://github.com/nodejs/node/commit/069cf59e56)] - **build**: make build-addons errors fail the build (Richard Lau) [#38983](https://github.com/nodejs/node/pull/38983)
+* [[`d341561ae0`](https://github.com/nodejs/node/commit/d341561ae0)] - **build**: fix commit-queue default branch (Mary Marchini) [#38998](https://github.com/nodejs/node/pull/38998)
+* [[`0736dd833a`](https://github.com/nodejs/node/commit/0736dd833a)] - **build**: don't pass python override to V8 build (Richard Lau) [#38969](https://github.com/nodejs/node/pull/38969)
+* [[`49a000683a`](https://github.com/nodejs/node/commit/49a000683a)] - **build**: correct Xcode spelling in .gitignore (bl-ue) [#38895](https://github.com/nodejs/node/pull/38895)
+* [[`1ffbe3d5da`](https://github.com/nodejs/node/commit/1ffbe3d5da)] - **build**: remove outdated dont-land-on-v6.x label (Michaël Zasso) [#38886](https://github.com/nodejs/node/pull/38886)
+* [[`7f53a0b349`](https://github.com/nodejs/node/commit/7f53a0b349)] - **build**: add lto build to CI (Jiawen Geng) [#38567](https://github.com/nodejs/node/pull/38567)
+* [[`a6f8ba8f0c`](https://github.com/nodejs/node/commit/a6f8ba8f0c)] - **build**: allow LTO with Clang 3.9.1+ (Jesse Chan) [#38751](https://github.com/nodejs/node/pull/38751)
+* [[`b5b1d1fb79`](https://github.com/nodejs/node/commit/b5b1d1fb79)] - **build**: replace non-POSIX test -a|o (Issam E. Maghni) [#38731](https://github.com/nodejs/node/pull/38731)
+* [[`fc2b1ec308`](https://github.com/nodejs/node/commit/fc2b1ec308)] - **child_process**: refactor to use `validateBoolean` (Qingyu Deng) [#38927](https://github.com/nodejs/node/pull/38927)
+* [[`55ea29eedd`](https://github.com/nodejs/node/commit/55ea29eedd)] - **child_process**: retain reference to data with advanced serialization (Anna Henningsen) [#38728](https://github.com/nodejs/node/pull/38728)
+* [[`716ee1531c`](https://github.com/nodejs/node/commit/716ee1531c)] - **debugger**: rename internal library for clarity (Rich Trott) [#39080](https://github.com/nodejs/node/pull/39080)
+* [[`b7ee9d8287`](https://github.com/nodejs/node/commit/b7ee9d8287)] - **debugger**: use ERR\_DEBUGGER\_STARTUP\_ERROR in \_inspect.js (Rich Trott) [#39024](https://github.com/nodejs/node/pull/39024)
+* [[`5d4d23dcf3`](https://github.com/nodejs/node/commit/5d4d23dcf3)] - **debugger**: use error codes in debugger REPL (Rich Trott) [#39024](https://github.com/nodejs/node/pull/39024)
+* [[`a3991d7c18`](https://github.com/nodejs/node/commit/a3991d7c18)] - **debugger**: use ERR\_DEBUGGER\_ERROR in debugger client (Rich Trott) [#39024](https://github.com/nodejs/node/pull/39024)
+* [[`052e1c5385`](https://github.com/nodejs/node/commit/052e1c5385)] - **debugger**: removed unused function argument (Rich Trott) [#38850](https://github.com/nodejs/node/pull/38850)
+* [[`f9a4dcb30c`](https://github.com/nodejs/node/commit/f9a4dcb30c)] - **debugger**: refactor `inspect_repl` to use primordials (Antoine du Hamel) [#38551](https://github.com/nodejs/node/pull/38551)
+* [[`ad8056659f`](https://github.com/nodejs/node/commit/ad8056659f)] - **debugger**: refactor to use internal modules (Antoine du Hamel) [#38550](https://github.com/nodejs/node/pull/38550)
+* [[`b5724a1984`](https://github.com/nodejs/node/commit/b5724a1984)] - **debugger**: disable only the lint rules required by current file state (Rich Trott) [#38529](https://github.com/nodejs/node/pull/38529)
+* [[`34659f2b7a`](https://github.com/nodejs/node/commit/34659f2b7a)] - **debugger**: avoid non-ASCII char in code file (Rich Trott) [#38529](https://github.com/nodejs/node/pull/38529)
+* [[`ae90756582`](https://github.com/nodejs/node/commit/ae90756582)] - **debugger**: wrap lines longer than 80 chars (Rich Trott) [#38529](https://github.com/nodejs/node/pull/38529)
+* [[`b30ff35a36`](https://github.com/nodejs/node/commit/b30ff35a36)] - **debugger**: align message with Node.js standard (Rich Trott) [#38400](https://github.com/nodejs/node/pull/38400)
+* [[`d74d67f207`](https://github.com/nodejs/node/commit/d74d67f207)] - **debugger**: remove unnecessary boilerplate copyright comment (Rich Trott) [#38952](https://github.com/nodejs/node/pull/38952)
+* [[`e58f938ab3`](https://github.com/nodejs/node/commit/e58f938ab3)] - **debugger**: enable linter on `internal/inspector/inspect_client` (Antoine du Hamel) [#38417](https://github.com/nodejs/node/pull/38417)
+* [[`249acd5e69`](https://github.com/nodejs/node/commit/249acd5e69)] - **debugger**: reduce scope of eslint disable comment (Rich Trott) [#38946](https://github.com/nodejs/node/pull/38946)
+* [[`0ef5e088c0`](https://github.com/nodejs/node/commit/0ef5e088c0)] - **debugger**: revise async iterator usage to comply with lint rules (Rich Trott) [#38847](https://github.com/nodejs/node/pull/38847)
+* [[`79bfb0416b`](https://github.com/nodejs/node/commit/79bfb0416b)] - **debugger**: wait for V8 debugger to be enabled (Michaël Zasso) [#38811](https://github.com/nodejs/node/pull/38811)
+* [[`721edeffd3`](https://github.com/nodejs/node/commit/721edeffd3)] - **debugger**: refactor `internal/inspector/_inspect` to use more primordials (Antoine du Hamel) [#38406](https://github.com/nodejs/node/pull/38406)
+* [[`21ecee1b4b`](https://github.com/nodejs/node/commit/21ecee1b4b)] - **debugger**: add usage example for `--port` (Rafael Gonzaga) [#38400](https://github.com/nodejs/node/pull/38400)
+* [[`cde72213d1`](https://github.com/nodejs/node/commit/cde72213d1)] - ***Revert*** "**debugger**: rename internal library for clarity" (Antoine du Hamel) [#39446](https://github.com/nodejs/node/pull/39446)
+* [[`4c2b813799`](https://github.com/nodejs/node/commit/4c2b813799)] - **debugger**: rename internal library for clarity (Rich Trott) [#39080](https://github.com/nodejs/node/pull/39080)
+* [[`61da371251`](https://github.com/nodejs/node/commit/61da371251)] - **debugger**: apply automatic lint fixes for inspect\_repl.js (Rich Trott) [#38411](https://github.com/nodejs/node/pull/38411)
+* [[`8dd1f70fe3`](https://github.com/nodejs/node/commit/8dd1f70fe3)] - **debugger**: apply automatic lint fixes for \_inspect.js (Rich Trott) [#38411](https://github.com/nodejs/node/pull/38411)
+* [[`fb0ab4c034`](https://github.com/nodejs/node/commit/fb0ab4c034)] - **debugger**: removed unused function argument (Rich Trott) [#38850](https://github.com/nodejs/node/pull/38850)
+* [[`9e28c6c946`](https://github.com/nodejs/node/commit/9e28c6c946)] - **debugger**: fix race condition/deadlock on initialization (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`a8924fa0fb`](https://github.com/nodejs/node/commit/a8924fa0fb)] - **debugger**: replace internal use of deprecated API (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`22afb7cbe6`](https://github.com/nodejs/node/commit/22afb7cbe6)] - **debugger**: allow longer time to connect (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`b172e6f436`](https://github.com/nodejs/node/commit/b172e6f436)] - **debugger**: accommodate line chunking in Windows (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`1da692185a`](https://github.com/nodejs/node/commit/1da692185a)] - **debugger**: fix inspect restart on Windows (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`0321c5b194`](https://github.com/nodejs/node/commit/0321c5b194)] - **debugger**: remove unused code (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`8bd2a3926a`](https://github.com/nodejs/node/commit/8bd2a3926a)] - **debugger**: move node-inspect to internal library (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`acf5279c39`](https://github.com/nodejs/node/commit/acf5279c39)] - **deps**: upgrade npm to 6.14.14 (Darcy Clarke) [#39553](https://github.com/nodejs/node/pull/39553)
+* [[`4efefe02a8`](https://github.com/nodejs/node/commit/4efefe02a8)] - **deps**: V8: backport ae7bfb3f03b3 (Michaël Zasso) [#39051](https://github.com/nodejs/node/pull/39051)
+* [[`5039f21396`](https://github.com/nodejs/node/commit/5039f21396)] - **deps**: V8: backport 16ffec97e5eb (Michaël Zasso) [#39051](https://github.com/nodejs/node/pull/39051)
+* [[`9b69069f71`](https://github.com/nodejs/node/commit/9b69069f71)] - **deps**: V8: cherry-pick b0a7f5691113 (Michaël Zasso) [#39051](https://github.com/nodejs/node/pull/39051)
+* [[`4213e97d26`](https://github.com/nodejs/node/commit/4213e97d26)] - **deps**: V8: cherry-pick 81181a8ad80a (thomasmichaelwallace) [#39187](https://github.com/nodejs/node/pull/39187)
+* [[`ccecea5f72`](https://github.com/nodejs/node/commit/ccecea5f72)] - **deps**: restore minimum ICU version to 65 (Richard Lau) [#39068](https://github.com/nodejs/node/pull/39068)
+* [[`7557e74cf4`](https://github.com/nodejs/node/commit/7557e74cf4)] - **deps**: V8: update build dependencies (Michaël Zasso) [#39244](https://github.com/nodejs/node/pull/39244)
+* [[`a60a960406`](https://github.com/nodejs/node/commit/a60a960406)] - **deps**: V8: cherry-pick 895949419186 (Michaël Zasso) [#39244](https://github.com/nodejs/node/pull/39244)
+* [[`7fdd6ecbb4`](https://github.com/nodejs/node/commit/7fdd6ecbb4)] - **deps**: V8: cherry-pick 0b3a4ecf7083 (Michaël Zasso) [#39244](https://github.com/nodejs/node/pull/39244)
+* [[`4be2e878b7`](https://github.com/nodejs/node/commit/4be2e878b7)] - **deps**: V8: cherry-pick 7c182bd65f42 (Michaël Zasso) [#39244](https://github.com/nodejs/node/pull/39244)
+* [[`a83b01a4af`](https://github.com/nodejs/node/commit/a83b01a4af)] - **deps**: V8: cherry-pick 92e6d3317082 (Michaël Zasso) [#39244](https://github.com/nodejs/node/pull/39244)
+* [[`17eb561184`](https://github.com/nodejs/node/commit/17eb561184)] - **deps**: V8: backport 1b1eda0876aa (Michaël Zasso) [#39244](https://github.com/nodejs/node/pull/39244)
+* [[`04032fa1a3`](https://github.com/nodejs/node/commit/04032fa1a3)] - **doc**: remove references to deleted freenode channels (devsnek) [#39047](https://github.com/nodejs/node/pull/39047)
+* [[`797bd73849`](https://github.com/nodejs/node/commit/797bd73849)] - **doc**: add missing parameter types (Voltrex) [#39013](https://github.com/nodejs/node/pull/39013)
+* [[`e474e984e5`](https://github.com/nodejs/node/commit/e474e984e5)] - **doc**: clarify that only one Python version is required to build (bl-ue) [#38894](https://github.com/nodejs/node/pull/38894)
+* [[`cd48ee71d9`](https://github.com/nodejs/node/commit/cd48ee71d9)] - **doc**: fixed typo in process.md (Derevianchenko Maksym) [#38941](https://github.com/nodejs/node/pull/38941)
+* [[`41fcbad2b2`](https://github.com/nodejs/node/commit/41fcbad2b2)] - **doc**: add missing semis after classes (Darshan Sen) [#38931](https://github.com/nodejs/node/pull/38931)
+* [[`b40529643b`](https://github.com/nodejs/node/commit/b40529643b)] - **doc**: mark util.inherits as legacy (Voltrex) [#38896](https://github.com/nodejs/node/pull/38896)
+* [[`b2d836b1ea`](https://github.com/nodejs/node/commit/b2d836b1ea)] - **doc**: clarify when `readable._read(...)` is called (Shaun Keys) [#38726](https://github.com/nodejs/node/pull/38726)
+* [[`e36d2a6d6a`](https://github.com/nodejs/node/commit/e36d2a6d6a)] - **doc**: fixed typo in n-api.md (julianjany) [#38822](https://github.com/nodejs/node/pull/38822)
+* [[`b4f60bb523`](https://github.com/nodejs/node/commit/b4f60bb523)] - **doc**: use "Long Term Support" in collaborator guide (Rich Trott) [#38841](https://github.com/nodejs/node/pull/38841)
+* [[`7a9850a5fb`](https://github.com/nodejs/node/commit/7a9850a5fb)] - **doc**: use "Long Term Support" in technical values doc (Rich Trott) [#38841](https://github.com/nodejs/node/pull/38841)
+* [[`dfe9698db0`](https://github.com/nodejs/node/commit/dfe9698db0)] - **doc**: use "Long Term Support" in README (Philip) [#38839](https://github.com/nodejs/node/pull/38839)
+* [[`8699e622fc`](https://github.com/nodejs/node/commit/8699e622fc)] - **doc**: fix grammar in `fs.md` (yotamselementor) [#38818](https://github.com/nodejs/node/pull/38818)
+* [[`826ae9b2e2`](https://github.com/nodejs/node/commit/826ae9b2e2)] - **doc**: fixup code sample in http.md (TodorTotev) [#38776](https://github.com/nodejs/node/pull/38776)
+* [[`8049b69b7f`](https://github.com/nodejs/node/commit/8049b69b7f)] - **doc**: document null target pattern (Guy Bedford) [#38724](https://github.com/nodejs/node/pull/38724)
+* [[`4d9129eb71`](https://github.com/nodejs/node/commit/4d9129eb71)] - **doc**: update code examples for `node:url` module (fisker Cheung) [#38645](https://github.com/nodejs/node/pull/38645)
+* [[`2ff671e4c4`](https://github.com/nodejs/node/commit/2ff671e4c4)] - **doc,url**: clarify domainTo\* when built without ICU (Darshan Sen) [#38789](https://github.com/nodejs/node/pull/38789)
+* [[`9b993edca8`](https://github.com/nodejs/node/commit/9b993edca8)] - **errors**: add ERR\_DEBUGGER\_STARTUP\_ERROR (Rich Trott) [#39024](https://github.com/nodejs/node/pull/39024)
+* [[`cfccf13e84`](https://github.com/nodejs/node/commit/cfccf13e84)] - **errors**: add ERR\_DEBUGGER\_ERROR (Rich Trott) [#39024](https://github.com/nodejs/node/pull/39024)
+* [[`bb9a9adc2b`](https://github.com/nodejs/node/commit/bb9a9adc2b)] - **errors**: don't rekey on primitive type (Benjamin Coe) [#39025](https://github.com/nodejs/node/pull/39025)
+* [[`d48b91ea2b`](https://github.com/nodejs/node/commit/d48b91ea2b)] - **http2**: on receiving rst\_stream with cancel code add it to pending list (Akshay K) [#39423](https://github.com/nodejs/node/pull/39423)
+* [[`d8cc2fffd6`](https://github.com/nodejs/node/commit/d8cc2fffd6)] - **lib**: add primordials.SafeArrayIterator (Antoine du Hamel) [#36532](https://github.com/nodejs/node/pull/36532)
+* [[`e3223edb89`](https://github.com/nodejs/node/commit/e3223edb89)] - **lib**: harden lint checks for globals (Antoine du Hamel) [#38419](https://github.com/nodejs/node/pull/38419)
+* [[`d4f96bb926`](https://github.com/nodejs/node/commit/d4f96bb926)] - **lib**: enforce using `primordials.globalThis` instead of `global` (Antoine du Hamel) [#38230](https://github.com/nodejs/node/pull/38230)
+* [[`ea9003a559`](https://github.com/nodejs/node/commit/ea9003a559)] - **lib**: add `globalThis` to primordials (Antoine du Hamel) [#38211](https://github.com/nodejs/node/pull/38211)
+* [[`097a7874d3`](https://github.com/nodejs/node/commit/097a7874d3)] - **lib**: remove semicolon in preparation for babel/eslint-parser update (Rich Trott) [#39094](https://github.com/nodejs/node/pull/39094)
+* [[`199fe32cbc`](https://github.com/nodejs/node/commit/199fe32cbc)] - **lib**: make internal/options lazy (Joyee Cheung) [#38993](https://github.com/nodejs/node/pull/38993)
+* [[`2bc2a232af`](https://github.com/nodejs/node/commit/2bc2a232af)] - **lib**: add JSDoc typings for child\_process (Voltrex) [#38222](https://github.com/nodejs/node/pull/38222)
+* [[`b0a1984d4d`](https://github.com/nodejs/node/commit/b0a1984d4d)] - **lib**: fix typos (bl-ue) [#38846](https://github.com/nodejs/node/pull/38846)
+* [[`6c061d5f2c`](https://github.com/nodejs/node/commit/6c061d5f2c)] - **meta**: update label-pr-config (Michaël Zasso) [#38950](https://github.com/nodejs/node/pull/38950)
+* [[`afb61786b9`](https://github.com/nodejs/node/commit/afb61786b9)] - **module**: fix legacy `node` specifier resolution to resolve `"main"` field (Antoine du Hamel) [#38979](https://github.com/nodejs/node/pull/38979)
+* [[`cd3305a9e4`](https://github.com/nodejs/node/commit/cd3305a9e4)] - **node-api**: avoid SecondPassCallback crash (Michael Dawson) [#38899](https://github.com/nodejs/node/pull/38899)
+* [[`e7f266e93d`](https://github.com/nodejs/node/commit/e7f266e93d)] - **src**: use SPrintF in ProcessEmitWarning (Darshan Sen) [#38758](https://github.com/nodejs/node/pull/38758)
+* [[`43fe6c1d27`](https://github.com/nodejs/node/commit/43fe6c1d27)] - **src**: cleanup uv\_fs\_t regardless of success or not (legendecas) [#38996](https://github.com/nodejs/node/pull/38996)
+* [[`dcfb182546`](https://github.com/nodejs/node/commit/dcfb182546)] - **src**: refactor to use locale functions (Darshan Sen) [#39014](https://github.com/nodejs/node/pull/39014)
+* [[`bee477b000`](https://github.com/nodejs/node/commit/bee477b000)] - **src**: throw error in LoadBuiltinModuleSource when reading fails (Joyee Cheung) [#38904](https://github.com/nodejs/node/pull/38904)
+* [[`ff7cc8f9ef`](https://github.com/nodejs/node/commit/ff7cc8f9ef)] - **src**: add not-weak DCHECK to PersistentToLocal::Strong (Anna Henningsen) [#38875](https://github.com/nodejs/node/pull/38875)
+* [[`981217e48a`](https://github.com/nodejs/node/commit/981217e48a)] - **src**: replace `auto`s in node\_api.cc (Khaidi Chu) [#38852](https://github.com/nodejs/node/pull/38852)
+* [[`73e199d963`](https://github.com/nodejs/node/commit/73e199d963)] - **src**: fix typos (bl-ue) [#38845](https://github.com/nodejs/node/pull/38845)
+* [[`2d32031724`](https://github.com/nodejs/node/commit/2d32031724)] - **src**: use HandleScope in StreamReq::Done() (Darshan Sen) [#38720](https://github.com/nodejs/node/pull/38720)
+* [[`2c11d3ec0a`](https://github.com/nodejs/node/commit/2c11d3ec0a)] - **src**: remove commented code in `node_file.cc` (Juan José Arboleda) [#38693](https://github.com/nodejs/node/pull/38693)
+* [[`846a138f54`](https://github.com/nodejs/node/commit/846a138f54)] - **src**: write named pipe info in diagnostic report (legendecas) [#38637](https://github.com/nodejs/node/pull/38637)
+* [[`7d82200861`](https://github.com/nodejs/node/commit/7d82200861)] - **src**: replace `auto`s in node\_contextify.cc (Khaidi Chu) [#38644](https://github.com/nodejs/node/pull/38644)
+* [[`51da7d2048`](https://github.com/nodejs/node/commit/51da7d2048)] - **src,url**: separate some tables out of node\_url.cc (Khaidi Chu) [#38988](https://github.com/nodejs/node/pull/38988)
+* [[`45c2ea3b72`](https://github.com/nodejs/node/commit/45c2ea3b72)] - **test**: add NumberFormat resolvedOptions test (Richard Lau) [#39401](https://github.com/nodejs/node/pull/39401)
+* [[`6b2fea38d1`](https://github.com/nodejs/node/commit/6b2fea38d1)] - **test**: move inspector-cli tests to sequential (Rich Trott) [#39079](https://github.com/nodejs/node/pull/39079)
+* [[`6447cab7be`](https://github.com/nodejs/node/commit/6447cab7be)] - **test**: improve buffer coverage (Rongjian Zhang) [#38538](https://github.com/nodejs/node/pull/38538)
+* [[`6f1862eab3`](https://github.com/nodejs/node/commit/6f1862eab3)] - **test**: fix name of variable in inspector-cli test (Tobias Nießen) [#38869](https://github.com/nodejs/node/pull/38869)
+* [[`40093504bc`](https://github.com/nodejs/node/commit/40093504bc)] - **test**: fix typo (Houssem Chebab) [#39045](https://github.com/nodejs/node/pull/39045)
+* [[`ab28f9b9a1`](https://github.com/nodejs/node/commit/ab28f9b9a1)] - **test**: remove obsolete TLS test (Rich Trott) [#39001](https://github.com/nodejs/node/pull/39001)
+* [[`b3b59953fe`](https://github.com/nodejs/node/commit/b3b59953fe)] - **test**: improve coverage of lib/events.js (Rongjian Zhang) [#38582](https://github.com/nodejs/node/pull/38582)
+* [[`c99a09f05f`](https://github.com/nodejs/node/commit/c99a09f05f)] - **test**: http outgoing \_headers setter null (ycjcl868) [#38881](https://github.com/nodejs/node/pull/38881)
+* [[`660a97b1d5`](https://github.com/nodejs/node/commit/660a97b1d5)] - **test**: suppress warning in test\_environment.cc (Daniel Bevenius) [#38868](https://github.com/nodejs/node/pull/38868)
+* [[`0cca16ac4c`](https://github.com/nodejs/node/commit/0cca16ac4c)] - **test**: improve coverage of fs internal utils (Rongjian Zhang) [#38746](https://github.com/nodejs/node/pull/38746)
+* [[`fecad40f27`](https://github.com/nodejs/node/commit/fecad40f27)] - **test**: fix writefile with fd (Nitzan Uziely) [#38820](https://github.com/nodejs/node/pull/38820)
+* [[`01f00faaa8`](https://github.com/nodejs/node/commit/01f00faaa8)] - **test**: simplify test-path-resolve.js (himself65) [#38671](https://github.com/nodejs/node/pull/38671)
+* [[`504bfd7a88`](https://github.com/nodejs/node/commit/504bfd7a88)] - **test**: improve coverage for `question` in readline (Qingyu Deng) [#38799](https://github.com/nodejs/node/pull/38799)
+* [[`eb91932e77`](https://github.com/nodejs/node/commit/eb91932e77)] - **test**: os, replace custom flatten method with built-in Array.flat (Wael Almattar) [#38770](https://github.com/nodejs/node/pull/38770)
+* [[`aeea252b96`](https://github.com/nodejs/node/commit/aeea252b96)] - **test**: improve coverage of lib/\_http\_outgoing.js (Rongjian Zhang) [#38734](https://github.com/nodejs/node/pull/38734)
+* [[`e265d8ee1b`](https://github.com/nodejs/node/commit/e265d8ee1b)] - **test**: give js-native-api tests consistent names (Gabriel Schulhof) [#38692](https://github.com/nodejs/node/pull/38692)
+* [[`99fd8bfc6a`](https://github.com/nodejs/node/commit/99fd8bfc6a)] - **test**: fix flaky inspector-cli tests when breakpionts are restored (Rich Trott) [#38431](https://github.com/nodejs/node/pull/38431)
+* [[`4d3a1fad28`](https://github.com/nodejs/node/commit/4d3a1fad28)] - **test**: extend timeout on debugger tests for slower machines (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`dd2642b5db`](https://github.com/nodejs/node/commit/dd2642b5db)] - **test**: fix comment typo (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`193ea8fd91`](https://github.com/nodejs/node/commit/193ea8fd91)] - **test**: fix test-inspector-cli-address (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`a62826bbe6`](https://github.com/nodejs/node/commit/a62826bbe6)] - **test,debugger**: migrate node-inspect tests to core (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`ab45ace9bd`](https://github.com/nodejs/node/commit/ab45ace9bd)] - **tools**: update babel-eslint-parser to 7.14.5 (Rich Trott) [#39094](https://github.com/nodejs/node/pull/39094)
+* [[`b8e63b3c08`](https://github.com/nodejs/node/commit/b8e63b3c08)] - **tools**: update ESLint to 7.29.0 (Rich Trott) [#39083](https://github.com/nodejs/node/pull/39083)
+* [[`54a250e79c`](https://github.com/nodejs/node/commit/54a250e79c)] - **tools**: update doctool dependencies, migrate to ESM (Michaël Zasso) [#38966](https://github.com/nodejs/node/pull/38966)
+* [[`443db64eed`](https://github.com/nodejs/node/commit/443db64eed)] - **tools**: avoid crashing CQ when git push fails (Antoine du Hamel) [#36861](https://github.com/nodejs/node/pull/36861)
+* [[`547f88b149`](https://github.com/nodejs/node/commit/547f88b149)] - **tools**: fix typo in commit-queue.sh (bl-ue) [#39000](https://github.com/nodejs/node/pull/39000)
+* [[`1023433a81`](https://github.com/nodejs/node/commit/1023433a81)] - **tools**: update ESLint to 7.28.0 (Luigi Pinca) [#38955](https://github.com/nodejs/node/pull/38955)
+* [[`9b4ae8fbb0`](https://github.com/nodejs/node/commit/9b4ae8fbb0)] - **tools**: bump remark-preset-lint-node to 2.3.0 (Rich Trott) [#38910](https://github.com/nodejs/node/pull/38910)
+* [[`2ad0719e86`](https://github.com/nodejs/node/commit/2ad0719e86)] - **tools**: refloat 7 Node.js patches to cpplint.py (Rich Trott) [#38851](https://github.com/nodejs/node/pull/38851)
+* [[`b7686d0c1e`](https://github.com/nodejs/node/commit/b7686d0c1e)] - **tools**: bump cpplint to 1.5.5 (Rich Trott) [#38851](https://github.com/nodejs/node/pull/38851)
+* [[`2ec7c9de57`](https://github.com/nodejs/node/commit/2ec7c9de57)] - **tools**: remove exception for Node.js 8 and earlier (Rich Trott) [#38840](https://github.com/nodejs/node/pull/38840)
+* [[`1dc71da302`](https://github.com/nodejs/node/commit/1dc71da302)] - **tools**: update setup-node to setup-node@v2 (pengjie) [#38825](https://github.com/nodejs/node/pull/38825)
+* [[`fc219d862c`](https://github.com/nodejs/node/commit/fc219d862c)] - **tools**: remove node-inspect from license (Rich Trott) [#38161](https://github.com/nodejs/node/pull/38161)
+* [[`4bb0bd0f0e`](https://github.com/nodejs/node/commit/4bb0bd0f0e)] - **tools,doc**: forbid CJS globals in ESM code snippets (Antoine du Hamel) [#38889](https://github.com/nodejs/node/pull/38889)
+* [[`58154ce426`](https://github.com/nodejs/node/commit/58154ce426)] - **typings**: add JSDoc typings for https (Voltrex) [#38589](https://github.com/nodejs/node/pull/38589)
+* [[`6ea1368a67`](https://github.com/nodejs/node/commit/6ea1368a67)] - **typings**: add JSDoc typings for events (Voltrex) [#38712](https://github.com/nodejs/node/pull/38712)
+* [[`b6942a6138`](https://github.com/nodejs/node/commit/b6942a6138)] - **url,src**: simplify ipv6 logic by using uv\_inet\_pton (Khaidi Chu) [#38842](https://github.com/nodejs/node/pull/38842)
+* [[`dd00547ada`](https://github.com/nodejs/node/commit/dd00547ada)] - **vm**: use missing validator (Voltrex) [#38935](https://github.com/nodejs/node/pull/38935)
+* [[`2c28e00685`](https://github.com/nodejs/node/commit/2c28e00685)] - **worker**: do not look up context twice in PostMessage (Anna Henningsen) [#38784](https://github.com/nodejs/node/pull/38784)
+
+<a id="14.17.3"></a>
+## 2021-07-05, Version 14.17.3 'Fermium' (LTS), @richardlau
+
+### Notable Changes
+
+Node.js 14.17.2 introduced a regression in the Windows installer on
+non-English locales that is being fixed in this release. There is no
+need to download this release if you are not using the Windows
+installer.
+
+### Commits
+
+* [[`0f00104a2c`](https://github.com/nodejs/node/commit/0f00104a2c)] - **win,msi**: use localized "Authenticated Users" name (Richard Lau) [#39241](https://github.com/nodejs/node/pull/39241)
+
+<a id="14.17.2"></a>
+## 2021-07-01, Version 14.17.2 'Fermium' (LTS), @richardlau
+
+This is a security release.
+
+### Notable Changes
+
+Vulnerabilities fixed:
+
+* **CVE-2021-22918**: libuv upgrade - Out of bounds read (Medium)
+  * Node.js is vulnerable to out-of-bounds read in libuv's uv__idna_toascii() function which is used to convert strings to ASCII. This is called by Node's dns module's lookup() function and can lead to information disclosures or crashes. You can read more about it in https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22918
+* **CVE-2021-22921**: Windows installer - Node Installer Local Privilege Escalation (Medium)
+  * Node.js is vulnerable to local privilege escalation attacks under certain conditions on Windows platforms. More specifically, improper configuration of permissions in the installation directory allows an attacker to perform two different escalation attacks: PATH and DLL hijacking. You can read more about it in https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-22921
+
+### Commits
+
+* [[`a7496aba0a`](https://github.com/nodejs/node/commit/a7496aba0a)] - **deps**: uv: cherry-pick 99c29c9c2c9b (Ben Noordhuis) [nodejs-private/node-private#267](https://github.com/nodejs-private/node-private/pull/267)
+* [[`d0b449da1d`](https://github.com/nodejs/node/commit/d0b449da1d)] - **win,msi**: set install directory permission (AkshayK) [nodejs-private/node-private#269](https://github.com/nodejs-private/node-private/pull/269)
+
+<a id="14.17.1"></a>
+## 2021-06-15, Version 14.17.1 'Fermium' (LTS), @targos
+
+### Notable Changes
+
+* [[`6035492c8f`](https://github.com/nodejs/node/commit/6035492c8f)] - **deps**: update ICU to 69.1 (Michaël Zasso) [#38178](https://github.com/nodejs/node/pull/38178)
+* [[`9417fd0bc8`](https://github.com/nodejs/node/commit/9417fd0bc8)] - **errors**: align source-map stacks with spec (Benjamin Coe) [#37252](https://github.com/nodejs/node/pull/37252)
+
+### Commits
+
+* [[`87fa636953`](https://github.com/nodejs/node/commit/87fa636953)] - **assert**: refactor to use more primordials (Antoine du Hamel) [#36234](https://github.com/nodejs/node/pull/36234)
+* [[`cfff3b4462`](https://github.com/nodejs/node/commit/cfff3b4462)] - **assert**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#37344](https://github.com/nodejs/node/pull/37344)
+* [[`dd18def7db`](https://github.com/nodejs/node/commit/dd18def7db)] - **async_hooks**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#37125](https://github.com/nodejs/node/pull/37125)
+* [[`5f3e96b570`](https://github.com/nodejs/node/commit/5f3e96b570)] - **async_hooks,doc**: replace process.stdout.fd with 1 (Darshan Sen) [#38382](https://github.com/nodejs/node/pull/38382)
+* [[`f4cb8b8281`](https://github.com/nodejs/node/commit/f4cb8b8281)] - **benchmark**: avoid using `console.log()` (Antoine du Hamel) [#38370](https://github.com/nodejs/node/pull/38370)
+* [[`9e4c1f2f2c`](https://github.com/nodejs/node/commit/9e4c1f2f2c)] - **benchmark**: use `process.hrtime.bigint()` (Antoine du Hamel) [#38369](https://github.com/nodejs/node/pull/38369)
+* [[`3c886e0ad6`](https://github.com/nodejs/node/commit/3c886e0ad6)] - **buffer**: remove TODOs in `atob` / `btoa` (Khaidi Chu) [#38548](https://github.com/nodejs/node/pull/38548)
+* [[`c5b86f8c2f`](https://github.com/nodejs/node/commit/c5b86f8c2f)] - **buffer**: remove unreachable code (Rongjian Zhang) [#38537](https://github.com/nodejs/node/pull/38537)
+* [[`9ae2a27d44`](https://github.com/nodejs/node/commit/9ae2a27d44)] - **buffer**: make FastBuffer safe to construct (Antoine du Hamel) [#36587](https://github.com/nodejs/node/pull/36587)
+* [[`ff546ff744`](https://github.com/nodejs/node/commit/ff546ff744)] - **buffer**: refactor to use primordials instead of Array#reduce (Antoine du Hamel) [#36392](https://github.com/nodejs/node/pull/36392)
+* [[`5acf0a5ba3`](https://github.com/nodejs/node/commit/5acf0a5ba3)] - **buffer**: refactor to use more primordials (Antoine du Hamel) [#36166](https://github.com/nodejs/node/pull/36166)
+* [[`52fd42ec46`](https://github.com/nodejs/node/commit/52fd42ec46)] - **build**: work around bug in MSBuild v16.10.0 (Michaël Zasso) [#38873](https://github.com/nodejs/node/pull/38873)
+* [[`5df0f35bf6`](https://github.com/nodejs/node/commit/5df0f35bf6)] - **build**: add workaround for V8 builds (Richard Lau) [#38632](https://github.com/nodejs/node/pull/38632)
+* [[`754aa384e0`](https://github.com/nodejs/node/commit/754aa384e0)] - **build**: remove dependency on `distutils.spawn` (Richard Lau) [#38600](https://github.com/nodejs/node/pull/38600)
+* [[`5de7e64f3a`](https://github.com/nodejs/node/commit/5de7e64f3a)] - **build**: fix make test-npm (Ruy Adorno) [#36369](https://github.com/nodejs/node/pull/36369)
+* [[`e5fae63108`](https://github.com/nodejs/node/commit/e5fae63108)] - **child_process**: reduce abort handler code duplication (Rich Trott) [#36644](https://github.com/nodejs/node/pull/36644)
+* [[`598d2bdf09`](https://github.com/nodejs/node/commit/598d2bdf09)] - **child_process**: treat already-aborted controller as aborting (Rich Trott) [#36644](https://github.com/nodejs/node/pull/36644)
+* [[`8d7708bdef`](https://github.com/nodejs/node/commit/8d7708bdef)] - **child_process**: refactor to use more primordials (Antoine du Hamel) [#36003](https://github.com/nodejs/node/pull/36003)
+* [[`b8c4d30e77`](https://github.com/nodejs/node/commit/b8c4d30e77)] - **deps**: update to cjs-module-lexer@1.2.1 (Guy Bedford) [#38450](https://github.com/nodejs/node/pull/38450)
+* [[`6035492c8f`](https://github.com/nodejs/node/commit/6035492c8f)] - **deps**: update ICU to 69.1 (Michaël Zasso) [#38178](https://github.com/nodejs/node/pull/38178)
+* [[`51dad8cabb`](https://github.com/nodejs/node/commit/51dad8cabb)] - **deps**: V8: cherry-pick 035c305ce776 (Michaël Zasso) [#38497](https://github.com/nodejs/node/pull/38497)
+* [[`a467125c8d`](https://github.com/nodejs/node/commit/a467125c8d)] - **deps**: V8: cherry-pick dfcdf7837e23 (Benjamin Coe) [#36573](https://github.com/nodejs/node/pull/36573)
+* [[`acc9fad2ba`](https://github.com/nodejs/node/commit/acc9fad2ba)] - **deps**: V8: cherry-pick 86991d0587a1 (Benjamin Coe) [#36254](https://github.com/nodejs/node/pull/36254)
+* [[`d67827744b`](https://github.com/nodejs/node/commit/d67827744b)] - **deps**: V8: cherry-pick 530080c44af2 (Milad Fa) [#38508](https://github.com/nodejs/node/pull/38508)
+* [[`bac9ba4f8a`](https://github.com/nodejs/node/commit/bac9ba4f8a)] - **dgram**: extract cluster lazy loading method to make it testable (Rongjian Zhang) [#38563](https://github.com/nodejs/node/pull/38563)
+* [[`f5b2115b76`](https://github.com/nodejs/node/commit/f5b2115b76)] - **dgram**: refactor to use more primordials (Antoine du Hamel) [#36286](https://github.com/nodejs/node/pull/36286)
+* [[`cd7cf0547a`](https://github.com/nodejs/node/commit/cd7cf0547a)] - **dns**: refactor to use more primordials (Antoine du Hamel) [#36314](https://github.com/nodejs/node/pull/36314)
+* [[`9f67c0852c`](https://github.com/nodejs/node/commit/9f67c0852c)] - **doc**: cleanup events.md structure (James M Snell) [#36100](https://github.com/nodejs/node/pull/36100)
+* [[`41cfe645c0`](https://github.com/nodejs/node/commit/41cfe645c0)] - **doc**: fix JS flavor selection (Antoine du Hamel) [#37791](https://github.com/nodejs/node/pull/37791)
+* [[`7c4748b0dc`](https://github.com/nodejs/node/commit/7c4748b0dc)] - **doc**: use `HEAD` instead of `master` for links (Antoine du Hamel) [#38518](https://github.com/nodejs/node/pull/38518)
+* [[`26426577ff`](https://github.com/nodejs/node/commit/26426577ff)] - **doc**: remove import.meta.resolve parent URL type (Kevin Locke) [#38585](https://github.com/nodejs/node/pull/38585)
+* [[`88055abf19`](https://github.com/nodejs/node/commit/88055abf19)] - **doc**: document buffer.kStringMaxLength (Tobias Nießen) [#38688](https://github.com/nodejs/node/pull/38688)
+* [[`2e8dfee165`](https://github.com/nodejs/node/commit/2e8dfee165)] - **doc**: clarify synchronous blocking of Worker stdio (James M Snell) [#38658](https://github.com/nodejs/node/pull/38658)
+* [[`212cd5cf05`](https://github.com/nodejs/node/commit/212cd5cf05)] - **doc**: update contact info (Gabriel Schulhof) [#38689](https://github.com/nodejs/node/pull/38689)
+* [[`fa35c0662b`](https://github.com/nodejs/node/commit/fa35c0662b)] - **doc**: change color of doctag on night mode (Qingyu Deng) [#38652](https://github.com/nodejs/node/pull/38652)
+* [[`4c67437c53`](https://github.com/nodejs/node/commit/4c67437c53)] - **doc**: clarify DiffieHellmanGroup class docs (Nitzan Uziely) [#38363](https://github.com/nodejs/node/pull/38363)
+* [[`e90c60b1e3`](https://github.com/nodejs/node/commit/e90c60b1e3)] - **doc**: use AIX instead of Aix in fs.md (Rich Trott) [#38535](https://github.com/nodejs/node/pull/38535)
+* [[`dc67fec1b4`](https://github.com/nodejs/node/commit/dc67fec1b4)] - **doc**: remove extraneous dash from flag prefix (Rodolfo Carvalho) [#38532](https://github.com/nodejs/node/pull/38532)
+* [[`4c54d81a59`](https://github.com/nodejs/node/commit/4c54d81a59)] - **doc**: document `'secureConnect'` event limitation (James M Snell) [#38447](https://github.com/nodejs/node/pull/38447)
+* [[`839e8d1672`](https://github.com/nodejs/node/commit/839e8d1672)] - **doc**: mark querystring api as legacy (James M Snell) [#38436](https://github.com/nodejs/node/pull/38436)
+* [[`a75b7af9bd`](https://github.com/nodejs/node/commit/a75b7af9bd)] - **doc**: add arguments for stream event of Http2Server and Http2SecureServer (Qingyu Deng) [#37892](https://github.com/nodejs/node/pull/37892)
+* [[`cf0007edc4`](https://github.com/nodejs/node/commit/cf0007edc4)] - **doc**: indicate that abort tests do not generate core files (Rich Trott) [#38422](https://github.com/nodejs/node/pull/38422)
+* [[`945450b5cf`](https://github.com/nodejs/node/commit/945450b5cf)] - **doc**: add try/catch in http2 respondWithFile example (Matteo Collina) [#38410](https://github.com/nodejs/node/pull/38410)
+* [[`1f7cd7148a`](https://github.com/nodejs/node/commit/1f7cd7148a)] - **doc**: note the system requirements for V8 tests (DeeDeeG) [#38319](https://github.com/nodejs/node/pull/38319)
+* [[`cd54834854`](https://github.com/nodejs/node/commit/cd54834854)] - **doc**: minor clarification to pathObject (James M Snell) [#38437](https://github.com/nodejs/node/pull/38437)
+* [[`ba117c2c6f`](https://github.com/nodejs/node/commit/ba117c2c6f)] - **doc**: document new TCP\_KEEPCNT and TCP\_KEEPINTVL socket option defaults (Arnold Zokas) [#38313](https://github.com/nodejs/node/pull/38313)
+* [[`dcdbaffced`](https://github.com/nodejs/node/commit/dcdbaffced)] - **doc**: do not mention TCP in the allowHalfOpen option description (Luigi Pinca) [#38360](https://github.com/nodejs/node/pull/38360)
+* [[`fe8003e5de`](https://github.com/nodejs/node/commit/fe8003e5de)] - **doc**: update message to match actual output (Rich Trott) [#35271](https://github.com/nodejs/node/pull/35271)
+* [[`c03f23e126`](https://github.com/nodejs/node/commit/c03f23e126)] - **doc**: request default snap track be updated for LTS (Rod Vagg) [#37708](https://github.com/nodejs/node/pull/37708)
+* [[`a9f7aeed12`](https://github.com/nodejs/node/commit/a9f7aeed12)] - **doc**: mark `process.hrtime()` as legacy (Antoine du Hamel) [#38371](https://github.com/nodejs/node/pull/38371)
+* [[`cede0c57b8`](https://github.com/nodejs/node/commit/cede0c57b8)] - **doc**: fix version history for `"exports"` patterns (Antoine du Hamel) [#38355](https://github.com/nodejs/node/pull/38355)
+* [[`9702f22397`](https://github.com/nodejs/node/commit/9702f22397)] - **doc**: fix `package.json` `"imports"` field history (Antoine du Hamel) [#38356](https://github.com/nodejs/node/pull/38356)
+* [[`2d96da875e`](https://github.com/nodejs/node/commit/2d96da875e)] - **doc**: fix typo in buffer.md (divlo) [#38323](https://github.com/nodejs/node/pull/38323)
+* [[`6b58f28472`](https://github.com/nodejs/node/commit/6b58f28472)] - **doc**: add nodejs-sec email template (Daniel Bevenius) [#38290](https://github.com/nodejs/node/pull/38290)
+* [[`5a532e4725`](https://github.com/nodejs/node/commit/5a532e4725)] - **doc**: update TSC members list with three new members (Rich Trott) [#38352](https://github.com/nodejs/node/pull/38352)
+* [[`e994d6a27c`](https://github.com/nodejs/node/commit/e994d6a27c)] - **doc**: use `foo.prototype.bar` notation in buffer.md (Voltrex) [#38032](https://github.com/nodejs/node/pull/38032)
+* [[`c61f363d66`](https://github.com/nodejs/node/commit/c61f363d66)] - **doc**: internal/test/binding for testing (Bradley Meck) [#38026](https://github.com/nodejs/node/pull/38026)
+* [[`0bb6fe31b3`](https://github.com/nodejs/node/commit/0bb6fe31b3)] - **doc**: add missing events.on metadata (Anna Henningsen) [#37965](https://github.com/nodejs/node/pull/37965)
+* [[`30c82b2745`](https://github.com/nodejs/node/commit/30c82b2745)] - **doc**: fix wording in outgoingMessage.write (Tobias Nießen) [#37894](https://github.com/nodejs/node/pull/37894)
+* [[`932000020a`](https://github.com/nodejs/node/commit/932000020a)] - **doc**: fix grammar errors in http document (Qingyu Deng) [#37265](https://github.com/nodejs/node/pull/37265)
+* [[`19e8ae44c4`](https://github.com/nodejs/node/commit/19e8ae44c4)] - **doc**: add document for http.OutgoingMessage (Qingyu Deng) [#37265](https://github.com/nodejs/node/pull/37265)
+* [[`a6c123363d`](https://github.com/nodejs/node/commit/a6c123363d)] - **doc**: remove generated from dsaEncoding description (Marko Kaznovac) [#37459](https://github.com/nodejs/node/pull/37459)
+* [[`bc6ea63e48`](https://github.com/nodejs/node/commit/bc6ea63e48)] - **doc**: document how to register external bindings for snapshot (Joyee Cheung) [#37463](https://github.com/nodejs/node/pull/37463)
+* [[`2168e954aa`](https://github.com/nodejs/node/commit/2168e954aa)] - **doc**: document the NO\_COLOR and FORCE\_COLOR env vars (James M Snell) [#37477](https://github.com/nodejs/node/pull/37477)
+* [[`2907848fc9`](https://github.com/nodejs/node/commit/2907848fc9)] - **doc**: clarify event.isTrusted text (Rich Trott) [#36827](https://github.com/nodejs/node/pull/36827)
+* [[`7efa020892`](https://github.com/nodejs/node/commit/7efa020892)] - **doc**: expand openssl instructions (Michael Dawson) [#36554](https://github.com/nodejs/node/pull/36554)
+* [[`b197a44152`](https://github.com/nodejs/node/commit/b197a44152)] - **doc**: document ABORT\_ERR code (Benjamin Gruenbaum) [#36319](https://github.com/nodejs/node/pull/36319)
+* [[`1d80f89442`](https://github.com/nodejs/node/commit/1d80f89442)] - **doc**: document changes for `*/promises` alias modules (ExE Boss) [#34002](https://github.com/nodejs/node/pull/34002)
+* [[`9417fd0bc8`](https://github.com/nodejs/node/commit/9417fd0bc8)] - **errors**: align source-map stacks with spec (Benjamin Coe) [#37252](https://github.com/nodejs/node/pull/37252)
+* [[`dcd221ce69`](https://github.com/nodejs/node/commit/dcd221ce69)] - **errors**: refactor to use more primordials (Antoine du Hamel) [#36651](https://github.com/nodejs/node/pull/36651)
+* [[`ee444473e9`](https://github.com/nodejs/node/commit/ee444473e9)] - **errors**: display original symbol name (Benjamin Coe) [#36042](https://github.com/nodejs/node/pull/36042)
+* [[`83d28374d6`](https://github.com/nodejs/node/commit/83d28374d6)] - **errors**: refactor to use more primordials (Antoine du Hamel) [#36167](https://github.com/nodejs/node/pull/36167)
+* [[`7d7e34c15a`](https://github.com/nodejs/node/commit/7d7e34c15a)] - **errors**: refactor to use more primordials (Antoine du Hamel) [#35944](https://github.com/nodejs/node/pull/35944)
+* [[`18e5c0f3e2`](https://github.com/nodejs/node/commit/18e5c0f3e2)] - **events**: refactor to use optional chaining (ZiJian Liu) [#36763](https://github.com/nodejs/node/pull/36763)
+* [[`4fdcbae583`](https://github.com/nodejs/node/commit/4fdcbae583)] - **events**: refactor to use more primordials (Antoine du Hamel) [#36304](https://github.com/nodejs/node/pull/36304)
+* [[`c4e7dca8f3`](https://github.com/nodejs/node/commit/c4e7dca8f3)] - **fs**: fix error when writing buffers \> INT32\_MAX (Zach Bjornson) [#38546](https://github.com/nodejs/node/pull/38546)
+* [[`07c55d2844`](https://github.com/nodejs/node/commit/07c55d2844)] - ***Revert*** "**http**: make HEAD method to work with keep-alive" (Michaël Zasso) [#38949](https://github.com/nodejs/node/pull/38949)
+* [[`d8da265c81`](https://github.com/nodejs/node/commit/d8da265c81)] - **http2**: treat non-EOF empty frames like other invalid frames (Anna Henningsen) [#37875](https://github.com/nodejs/node/pull/37875)
+* [[`c3bd0fdb73`](https://github.com/nodejs/node/commit/c3bd0fdb73)] - **http2**: fix setting options before handle exists (Anna Henningsen) [#37875](https://github.com/nodejs/node/pull/37875)
+* [[`74fe1d8f0c`](https://github.com/nodejs/node/commit/74fe1d8f0c)] - **http2**: add support for TypedArray to getUnpackedSettings (Antoine du Hamel) [#36141](https://github.com/nodejs/node/pull/36141)
+* [[`c90f1dbeb3`](https://github.com/nodejs/node/commit/c90f1dbeb3)] - **https**: refactor to use more primordials (Antoine du Hamel) [#36195](https://github.com/nodejs/node/pull/36195)
+* [[`8258799472`](https://github.com/nodejs/node/commit/8258799472)] - **inspector**: remove redundant method for connection check (Yash Ladha) [#37986](https://github.com/nodejs/node/pull/37986)
+* [[`ba19313e1e`](https://github.com/nodejs/node/commit/ba19313e1e)] - **inspector**: refactor to use more primordials (Antoine du Hamel) [#36356](https://github.com/nodejs/node/pull/36356)
+* [[`eb8f7ee634`](https://github.com/nodejs/node/commit/eb8f7ee634)] - **lib**: revert primordials in a hot path (Antoine du Hamel) [#38248](https://github.com/nodejs/node/pull/38248)
+* [[`cea8b4265c`](https://github.com/nodejs/node/commit/cea8b4265c)] - **lib**: make `IterableWeakMap` safe to iterate (Antoine du Hamel) [#38523](https://github.com/nodejs/node/pull/38523)
+* [[`490bc58229`](https://github.com/nodejs/node/commit/490bc58229)] - **lib**: fix and improve os typings (Akhil Marsonya) [#38316](https://github.com/nodejs/node/pull/38316)
+* [[`af39df6d03`](https://github.com/nodejs/node/commit/af39df6d03)] - **lib**: add URI handling functions to primordials (Antoine du Hamel) [#37394](https://github.com/nodejs/node/pull/37394)
+* [[`16691be80e`](https://github.com/nodejs/node/commit/16691be80e)] - **lib**: fix WebIDL `object` and dictionary type conversion (ExE Boss) [#37047](https://github.com/nodejs/node/pull/37047)
+* [[`47ed512312`](https://github.com/nodejs/node/commit/47ed512312)] - **lib**: refactor to use optional chaining in internal/options.js (raisinten) [#36939](https://github.com/nodejs/node/pull/36939)
+* [[`346fc0ac21`](https://github.com/nodejs/node/commit/346fc0ac21)] - **lib**: support returning Safe collections from C++ (ExE Boss) [#36989](https://github.com/nodejs/node/pull/36989)
+* [[`8912caba64`](https://github.com/nodejs/node/commit/8912caba64)] - **lib**: expose primordials object (Antoine du Hamel) [#36872](https://github.com/nodejs/node/pull/36872)
+* [[`46c019b988`](https://github.com/nodejs/node/commit/46c019b988)] - **lib**: refactor source\_map to use more primordials (Antoine du Hamel) [#36733](https://github.com/nodejs/node/pull/36733)
+* [[`cf9556d8f7`](https://github.com/nodejs/node/commit/cf9556d8f7)] - **lib**: refactor source\_map to avoid unsafe array iteration (Antoine du Hamel) [#36734](https://github.com/nodejs/node/pull/36734)
+* [[`6eaf357f49`](https://github.com/nodejs/node/commit/6eaf357f49)] - **lib**: simplify `primordials.uncurryThis` (ExE Boss) [#36866](https://github.com/nodejs/node/pull/36866)
+* [[`9338759b01`](https://github.com/nodejs/node/commit/9338759b01)] - **lib**: remove v8\_prof\_polyfill from eslint ignore list (Antoine du Hamel) [#36537](https://github.com/nodejs/node/pull/36537)
+* [[`c9861a344a`](https://github.com/nodejs/node/commit/c9861a344a)] - **lib**: remove unused code (Brian White) [#36632](https://github.com/nodejs/node/pull/36632)
+* [[`01a71dd393`](https://github.com/nodejs/node/commit/01a71dd393)] - **lib**: refactor to use more primordials in internal/encoding.js (raisinten) [#36480](https://github.com/nodejs/node/pull/36480)
+* [[`e6c0877604`](https://github.com/nodejs/node/commit/e6c0877604)] - **lib**: refactor to use primordials in internal/priority\_queue.js (ZiJian Liu) [#36560](https://github.com/nodejs/node/pull/36560)
+* [[`6e3a2ffb98`](https://github.com/nodejs/node/commit/6e3a2ffb98)] - **lib**: add primordials.SafeStringIterator (Antoine du Hamel) [#36526](https://github.com/nodejs/node/pull/36526)
+* [[`bf0738bc07`](https://github.com/nodejs/node/commit/bf0738bc07)] - **lib**: make safe primordials safe to construct (Antoine du Hamel) [#36428](https://github.com/nodejs/node/pull/36428)
+* [[`7ebc18f293`](https://github.com/nodejs/node/commit/7ebc18f293)] - **lib**: make safe primordials safe to iterate (Antoine du Hamel) [#36391](https://github.com/nodejs/node/pull/36391)
+* [[`e12dbc8519`](https://github.com/nodejs/node/commit/e12dbc8519)] - **lib**: refactor to use more primordials in internal/histogram.js (raisinten) [#36455](https://github.com/nodejs/node/pull/36455)
+* [[`5daeac64a4`](https://github.com/nodejs/node/commit/5daeac64a4)] - **lib**: add uncurried accessor properties to `primordials` (ExE Boss) [#36329](https://github.com/nodejs/node/pull/36329)
+* [[`bb4900d9eb`](https://github.com/nodejs/node/commit/bb4900d9eb)] - **lib**: refactor primordials.uncurryThis (Antoine du Hamel) [#36221](https://github.com/nodejs/node/pull/36221)
+* [[`0fbe945ebb`](https://github.com/nodejs/node/commit/0fbe945ebb)] - **lib**: refactor to use more primordials (Antoine du Hamel) [#36140](https://github.com/nodejs/node/pull/36140)
+* [[`24d4d63308`](https://github.com/nodejs/node/commit/24d4d63308)] - **lib**: add %TypedArray% abstract constructor to primordials (ExE Boss) [#36016](https://github.com/nodejs/node/pull/36016)
+* [[`e2395b0f3b`](https://github.com/nodejs/node/commit/e2395b0f3b)] - **lib**: use Object static properties from primordials (Michaël Zasso) [#35380](https://github.com/nodejs/node/pull/35380)
+* [[`b3e22e1612`](https://github.com/nodejs/node/commit/b3e22e1612)] - **lib,tools**: enforce access to prototype from primordials (Antoine du Hamel) [#36025](https://github.com/nodejs/node/pull/36025)
+* [[`e94e0b488e`](https://github.com/nodejs/node/commit/e94e0b488e)] - **meta**: add v8 team (Jiawen Geng) [#38566](https://github.com/nodejs/node/pull/38566)
+* [[`fcc6a00f1a`](https://github.com/nodejs/node/commit/fcc6a00f1a)] - **meta**: post comment when pr labeled fast-track (James M Snell) [#38446](https://github.com/nodejs/node/pull/38446)
+* [[`bd0d9647ca`](https://github.com/nodejs/node/commit/bd0d9647ca)] - **module**: clarify CJS global-like variables not defined error message (Antoine du Hamel) [#37852](https://github.com/nodejs/node/pull/37852)
+* [[`0fdb5d59f7`](https://github.com/nodejs/node/commit/0fdb5d59f7)] - **module**: refactor NativeModule to avoid unsafe array iteration (Antoine du Hamel) [#37656](https://github.com/nodejs/node/pull/37656)
+* [[`77c7d979b6`](https://github.com/nodejs/node/commit/77c7d979b6)] - **module**: simplify tryStatSync with throwIfNoEntry option (Antoine du Hamel) [#36971](https://github.com/nodejs/node/pull/36971)
+* [[`1aae572220`](https://github.com/nodejs/node/commit/1aae572220)] - **module**: refactor to use more primordials (Antoine du Hamel) [#36348](https://github.com/nodejs/node/pull/36348)
+* [[`9e7f166161`](https://github.com/nodejs/node/commit/9e7f166161)] - **module**: refactor to use more primordials (Antoine du Hamel) [#36024](https://github.com/nodejs/node/pull/36024)
+* [[`eee1d291cf`](https://github.com/nodejs/node/commit/eee1d291cf)] - **module**: refactor to use iterable-weak-map (Benjamin Coe) [#35915](https://github.com/nodejs/node/pull/35915)
+* [[`52cbe89f7f`](https://github.com/nodejs/node/commit/52cbe89f7f)] - **net**: refactor to use more primordials (Antoine du Hamel) [#36303](https://github.com/nodejs/node/pull/36303)
+* [[`779ad54078`](https://github.com/nodejs/node/commit/779ad54078)] - **node-api**: faster threadsafe\_function (Fedor Indutny) [#38506](https://github.com/nodejs/node/pull/38506)
+* [[`5995221ced`](https://github.com/nodejs/node/commit/5995221ced)] - **node-api**: fix shutdown crashes (Michael Dawson) [#38492](https://github.com/nodejs/node/pull/38492)
+* [[`d8acec4cb1`](https://github.com/nodejs/node/commit/d8acec4cb1)] - **node-api**: make reference weak parameter an indirect link to references (Chengzhong Wu) [#38000](https://github.com/nodejs/node/pull/38000)
+* [[`c442d89ad6`](https://github.com/nodejs/node/commit/c442d89ad6)] - **os**: refactor to use more primordials (Antoine du Hamel) [#36284](https://github.com/nodejs/node/pull/36284)
+* [[`daeb6fcd78`](https://github.com/nodejs/node/commit/daeb6fcd78)] - **path**: inline conditions (Voltrex) [#38613](https://github.com/nodejs/node/pull/38613)
+* [[`e2f531f646`](https://github.com/nodejs/node/commit/e2f531f646)] - **path**: refactor to use more primordials (Akhil Marsonya) [#37893](https://github.com/nodejs/node/pull/37893)
+* [[`c1364d15a2`](https://github.com/nodejs/node/commit/c1364d15a2)] - **path**: refactor to use more primordials (Antoine du Hamel) [#36302](https://github.com/nodejs/node/pull/36302)
+* [[`726ef40fcb`](https://github.com/nodejs/node/commit/726ef40fcb)] - **perf_hooks**: throw ERR\_INVALID\_ARG\_VALUE if histogram.percentile param is NaN (ZiJian Liu) [#36937](https://github.com/nodejs/node/pull/36937)
+* [[`4686f4f41b`](https://github.com/nodejs/node/commit/4686f4f41b)] - **perf_hooks**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#36723](https://github.com/nodejs/node/pull/36723)
+* [[`6adec6351e`](https://github.com/nodejs/node/commit/6adec6351e)] - **perf_hooks**: refactor to use more primordials (Antoine du Hamel) [#36297](https://github.com/nodejs/node/pull/36297)
+* [[`bf9aa425c0`](https://github.com/nodejs/node/commit/bf9aa425c0)] - **policy**: refactor to use more primordials (Antoine du Hamel) [#36210](https://github.com/nodejs/node/pull/36210)
+* [[`0f6c3f76b3`](https://github.com/nodejs/node/commit/0f6c3f76b3)] - **querystring**: refactor to use more primordials (Antoine du Hamel) [#36315](https://github.com/nodejs/node/pull/36315)
+* [[`b5b8a996f3`](https://github.com/nodejs/node/commit/b5b8a996f3)] - **readline**: refactor to use more primordials (Antoine du Hamel) [#36296](https://github.com/nodejs/node/pull/36296)
+* [[`cd981808b4`](https://github.com/nodejs/node/commit/cd981808b4)] - **repl**: document top level await limitation with const/let (James M Snell) [#38449](https://github.com/nodejs/node/pull/38449)
+* [[`a4eb5571eb`](https://github.com/nodejs/node/commit/a4eb5571eb)] - **repl**: display prompt once after error callback (Anna Henningsen) [#38314](https://github.com/nodejs/node/pull/38314)
+* [[`163fcecb69`](https://github.com/nodejs/node/commit/163fcecb69)] - **src**: fix multiple AddLinkedBinding() calls (Anna Henningsen) [#39012](https://github.com/nodejs/node/pull/39012)
+* [[`8809ef98f9`](https://github.com/nodejs/node/commit/8809ef98f9)] - **src**: update cares\_wrap OpenBSD defines (Anna Henningsen) [#38670](https://github.com/nodejs/node/pull/38670)
+* [[`d66f88ce97`](https://github.com/nodejs/node/commit/d66f88ce97)] - **src**: remove extra semi after member fn (Shelley Vohr) [#38686](https://github.com/nodejs/node/pull/38686)
+* [[`bc2111c7e6`](https://github.com/nodejs/node/commit/bc2111c7e6)] - **src**: make workers messaging more resilient (Juan José Arboleda) [#38510](https://github.com/nodejs/node/pull/38510)
+* [[`378e0e778b`](https://github.com/nodejs/node/commit/378e0e778b)] - **src**: fix validation of negative offset to avoid abort (James M Snell) [#38421](https://github.com/nodejs/node/pull/38421)
+* [[`c170026b7b`](https://github.com/nodejs/node/commit/c170026b7b)] - **src**: use %progbits instead of @progbits (Stephen Gallagher) [#38312](https://github.com/nodejs/node/pull/38312)
+* [[`d177541b0e`](https://github.com/nodejs/node/commit/d177541b0e)] - **src**: fix setting Converter sub char length (James M Snell) [#38331](https://github.com/nodejs/node/pull/38331)
+* [[`e279b029c0`](https://github.com/nodejs/node/commit/e279b029c0)] - **src**: avoid deferred gc/cleanup for Buffer.from (James M Snell) [#38337](https://github.com/nodejs/node/pull/38337)
+* [[`006c7b78da`](https://github.com/nodejs/node/commit/006c7b78da)] - **src**: indent long help text properly (David Glasser) [#37911](https://github.com/nodejs/node/pull/37911)
+* [[`f5541ddea3`](https://github.com/nodejs/node/commit/f5541ddea3)] - **src**: fix ETW\_WRITE\_EMPTY\_EVENT macro (Michaël Zasso) [#37334](https://github.com/nodejs/node/pull/37334)
+* [[`6b1052d034`](https://github.com/nodejs/node/commit/6b1052d034)] - **src**: disable unfixable MSVC warnings (Michaël Zasso) [#37334](https://github.com/nodejs/node/pull/37334)
+* [[`38afa3fa79`](https://github.com/nodejs/node/commit/38afa3fa79)] - **src**: avoid implicit type conversions (take 2) (Michaël Zasso) [#37334](https://github.com/nodejs/node/pull/37334)
+* [[`8a60ae2161`](https://github.com/nodejs/node/commit/8a60ae2161)] - **src**: fix compiler warnings in node\_buffer.cc (Darshan Sen) [#38722](https://github.com/nodejs/node/pull/38722)
+* [[`78cde14c45`](https://github.com/nodejs/node/commit/78cde14c45)] - **src**: fix compiler warning in env.cc (Anna Henningsen) [#35547](https://github.com/nodejs/node/pull/35547)
+* [[`ea311a41cc`](https://github.com/nodejs/node/commit/ea311a41cc)] - **src**: add check against non-weak BaseObjects at process exit (Anna Henningsen) [#35490](https://github.com/nodejs/node/pull/35490)
+* [[`a1b4681efc`](https://github.com/nodejs/node/commit/a1b4681efc)] - **src**: use transferred consistently (Daniel Bevenius) [#36340](https://github.com/nodejs/node/pull/36340)
+* [[`29c623e5cb`](https://github.com/nodejs/node/commit/29c623e5cb)] - **src**: fix label indentation (Rich Trott) [#36213](https://github.com/nodejs/node/pull/36213)
+* [[`dbb0d2612c`](https://github.com/nodejs/node/commit/dbb0d2612c)] - **stream**: fix multiple Writable.destroy() calls (Robert Nagy) [#38221](https://github.com/nodejs/node/pull/38221)
+* [[`a18b1ff80b`](https://github.com/nodejs/node/commit/a18b1ff80b)] - **stream**: the position of \_read() is wrong (helloyou2012) [#38292](https://github.com/nodejs/node/pull/38292)
+* [[`ab130e929a`](https://github.com/nodejs/node/commit/ab130e929a)] - **stream**: only use legacy close listeners if not willEmitClose (Robert Nagy) [#36649](https://github.com/nodejs/node/pull/36649)
+* [[`c31e2f6b0f`](https://github.com/nodejs/node/commit/c31e2f6b0f)] - **stream**: fix legacy pipe error handling (Robert Nagy) [#35257](https://github.com/nodejs/node/pull/35257)
+* [[`1dc4dea215`](https://github.com/nodejs/node/commit/1dc4dea215)] - **string_decoder**: throw ERR\_STRING\_TOO\_LONG for UTF-8 (Michaël Zasso) [#36661](https://github.com/nodejs/node/pull/36661)
+* [[`0db9101922`](https://github.com/nodejs/node/commit/0db9101922)] - **string_decoder**: refactor to use more primordials (Antoine du Hamel) [#36358](https://github.com/nodejs/node/pull/36358)
+* [[`8a44ee478e`](https://github.com/nodejs/node/commit/8a44ee478e)] - **test**: improve coverage of lib/\_http\_client.js (Rongjian Zhang) [#38599](https://github.com/nodejs/node/pull/38599)
+* [[`8a45b85dbd`](https://github.com/nodejs/node/commit/8a45b85dbd)] - **test**: improve coverage of lib/os.js (Rongjian Zhang) [#38653](https://github.com/nodejs/node/pull/38653)
+* [[`d7c6a3eb03`](https://github.com/nodejs/node/commit/d7c6a3eb03)] - **test**: call functions internally (Voltrex) [#38560](https://github.com/nodejs/node/pull/38560)
+* [[`726cb48bd8`](https://github.com/nodejs/node/commit/726cb48bd8)] - **test**: complete coverage of querystring (Rongjian Zhang) [#38520](https://github.com/nodejs/node/pull/38520)
+* [[`4f1ba79eb8`](https://github.com/nodejs/node/commit/4f1ba79eb8)] - **test**: increase coverage for AbortController (ZiJian Liu) [#38514](https://github.com/nodejs/node/pull/38514)
+* [[`d98b355336`](https://github.com/nodejs/node/commit/d98b355336)] - **test**: run message and pseudo-tty tests in parallel (Richard Lau) [#38502](https://github.com/nodejs/node/pull/38502)
+* [[`7938af6565`](https://github.com/nodejs/node/commit/7938af6565)] - **test**: move test-net-connect-econnrefused from pummel to sequential (Rich Trott) [#38462](https://github.com/nodejs/node/pull/38462)
+* [[`52f3837518`](https://github.com/nodejs/node/commit/52f3837518)] - **test**: fix `common.mustCall` `length` and `name` properties (Antoine du Hamel) [#38464](https://github.com/nodejs/node/pull/38464)
+* [[`fdfb39e692`](https://github.com/nodejs/node/commit/fdfb39e692)] - **test**: address deprecation warning (Rich Trott) [#38448](https://github.com/nodejs/node/pull/38448)
+* [[`25e5afe3be`](https://github.com/nodejs/node/commit/25e5afe3be)] - **test**: move abort test from pummel to abort directory (Rich Trott) [#38396](https://github.com/nodejs/node/pull/38396)
+* [[`296b969e0a`](https://github.com/nodejs/node/commit/296b969e0a)] - **test**: skip some pummel tests on slower machines (Rich Trott) [#38394](https://github.com/nodejs/node/pull/38394)
+* [[`a9ff9c0918`](https://github.com/nodejs/node/commit/a9ff9c0918)] - **test**: add ancestor package.json checks for tmpdir (Richard Lau) [#38285](https://github.com/nodejs/node/pull/38285)
+* [[`c9ce98c377`](https://github.com/nodejs/node/commit/c9ce98c377)] - **test**: replace function with arrow function and remove unused argument (Andres) [#38235](https://github.com/nodejs/node/pull/38235)
+* [[`c77abf5a89`](https://github.com/nodejs/node/commit/c77abf5a89)] - **test**: use .test domain for not found address (Richard Lau) [#38286](https://github.com/nodejs/node/pull/38286)
+* [[`d9eb8b3ed0`](https://github.com/nodejs/node/commit/d9eb8b3ed0)] - **test**: increase fs promise coverage (Emil Sivervik) [#36813](https://github.com/nodejs/node/pull/36813)
+* [[`d85b70fffa`](https://github.com/nodejs/node/commit/d85b70fffa)] - **test**: increase timeout on ASAN Action (Antoine du Hamel) [#37007](https://github.com/nodejs/node/pull/37007)
+* [[`836fba52ea`](https://github.com/nodejs/node/commit/836fba52ea)] - **test**: improve coverage of `SourceTextModule` getters (Juan José Arboleda) [#37013](https://github.com/nodejs/node/pull/37013)
+* [[`f43fc6b6cc`](https://github.com/nodejs/node/commit/f43fc6b6cc)] - **test**: improve coverage for `Module` getters (Juan José Arboleda) [#36950](https://github.com/nodejs/node/pull/36950)
+* [[`a45d280c18`](https://github.com/nodejs/node/commit/a45d280c18)] - **test**: improve coverage on worker threads (Juan José Arboleda) [#36910](https://github.com/nodejs/node/pull/36910)
+* [[`ec4d79e259`](https://github.com/nodejs/node/commit/ec4d79e259)] - **test**: improve coverage at `lib/internal/vm/module.js` (Juan José Arboleda) [#36898](https://github.com/nodejs/node/pull/36898)
+* [[`c34de75687`](https://github.com/nodejs/node/commit/c34de75687)] - **test**: guard large string decoder allocation (Michaël Zasso) [#36795](https://github.com/nodejs/node/pull/36795)
+* [[`3215a58843`](https://github.com/nodejs/node/commit/3215a58843)] - **test**: add already-aborted-controller test for spawn() (Rich Trott) [#36644](https://github.com/nodejs/node/pull/36644)
+* [[`c3b116795b`](https://github.com/nodejs/node/commit/c3b116795b)] - **test**: add test for reused AbortController with execfile() (Rich Trott) [#36644](https://github.com/nodejs/node/pull/36644)
+* [[`219ed0ba4c`](https://github.com/nodejs/node/commit/219ed0ba4c)] - **test**: add Actions annotation output (Mary Marchini) [#34590](https://github.com/nodejs/node/pull/34590)
+* [[`89ee6abae0`](https://github.com/nodejs/node/commit/89ee6abae0)] - **test**: use `.then(common.mustCall())` for all async IIFEs (Anna Henningsen) [#34363](https://github.com/nodejs/node/pull/34363)
+* [[`294b3e60a5`](https://github.com/nodejs/node/commit/294b3e60a5)] - **test,doc,lib**: adjust object literal newlines for lint rule (Rich Trott) [#37040](https://github.com/nodejs/node/pull/37040)
+* [[`bfe02b8808`](https://github.com/nodejs/node/commit/bfe02b8808)] - **test,readline**: improve tab completion coverage (Antoine du Hamel) [#38465](https://github.com/nodejs/node/pull/38465)
+* [[`1dc7fd238c`](https://github.com/nodejs/node/commit/1dc7fd238c)] - **timers**: fix unsafe array iteration (Darshan Sen) [#37223](https://github.com/nodejs/node/pull/37223)
+* [[`679973866d`](https://github.com/nodejs/node/commit/679973866d)] - **timers**: reject with AbortError on cancellation (Benjamin Gruenbaum) [#36317](https://github.com/nodejs/node/pull/36317)
+* [[`dec3610a31`](https://github.com/nodejs/node/commit/dec3610a31)] - **timers**: refactor to use more primordials (Antoine du Hamel) [#36132](https://github.com/nodejs/node/pull/36132)
+* [[`d84b05a619`](https://github.com/nodejs/node/commit/d84b05a619)] - **timers**: cleanup abort listener on awaitable timers (James M Snell) [#36006](https://github.com/nodejs/node/pull/36006)
+* [[`f6e4dbb779`](https://github.com/nodejs/node/commit/f6e4dbb779)] - **tls**: validate ticket keys buffer (Antoine du Hamel) [#38308](https://github.com/nodejs/node/pull/38308)
+* [[`661e9809bd`](https://github.com/nodejs/node/commit/661e9809bd)] - **tls**: fix session and keylog add listener segfault (Nitzan Uziely) [#38180](https://github.com/nodejs/node/pull/38180)
+* [[`de44e90523`](https://github.com/nodejs/node/commit/de44e90523)] - **tools**: refloat 7 Node.js patches to cpplint.py (Rich Trott) [#36324](https://github.com/nodejs/node/pull/36324)
+* [[`37bc7d5945`](https://github.com/nodejs/node/commit/37bc7d5945)] - **tools**: bump cpplint to 1.5.4 (Rich Trott) [#36324](https://github.com/nodejs/node/pull/36324)
+* [[`84e918858e`](https://github.com/nodejs/node/commit/84e918858e)] - **tools**: refloat 7 Node.js patches to cpplint.py (Rich Trott) [#36235](https://github.com/nodejs/node/pull/36235)
+* [[`fb2bb93f95`](https://github.com/nodejs/node/commit/fb2bb93f95)] - **tools**: bump cpplint to 1.5.3 (Rich Trott) [#36235](https://github.com/nodejs/node/pull/36235)
+* [[`3351910f97`](https://github.com/nodejs/node/commit/3351910f97)] - **tools**: refloat 7 Node.js patches to cpplint.py (Rich Trott) [#36213](https://github.com/nodejs/node/pull/36213)
+* [[`193b18effa`](https://github.com/nodejs/node/commit/193b18effa)] - **tools**: bump cpplint.py to 1.5.2 (Rich Trott) [#36213](https://github.com/nodejs/node/pull/36213)
+* [[`8a6c35d735`](https://github.com/nodejs/node/commit/8a6c35d735)] - **tools**: update ESLint to 7.27.0 (Luigi Pinca) [#38764](https://github.com/nodejs/node/pull/38764)
+* [[`f8753b6299`](https://github.com/nodejs/node/commit/f8753b6299)] - **tools**: update ESLint to 7.26.0 (Colin Ihrig) [#38605](https://github.com/nodejs/node/pull/38605)
+* [[`1098aec40b`](https://github.com/nodejs/node/commit/1098aec40b)] - **tools**: update ESLint to 7.25.0 (Colin Ihrig) [#38378](https://github.com/nodejs/node/pull/38378)
+* [[`3fbabfa94d`](https://github.com/nodejs/node/commit/3fbabfa94d)] - **tools**: update ESLint to 7.24.0 (Colin Ihrig) [#38179](https://github.com/nodejs/node/pull/38179)
+* [[`6ce779cd8b`](https://github.com/nodejs/node/commit/6ce779cd8b)] - **tools**: update ESLint to 7.23.0 (Luigi Pinca) [#37979](https://github.com/nodejs/node/pull/37979)
+* [[`77f88e7725`](https://github.com/nodejs/node/commit/77f88e7725)] - **tools**: update ESLint to 7.22.0 (Colin Ihrig) [#37734](https://github.com/nodejs/node/pull/37734)
+* [[`5de911eeaf`](https://github.com/nodejs/node/commit/5de911eeaf)] - **tools**: make update-eslint.sh work with npm@7 (Luigi Pinca) [#37566](https://github.com/nodejs/node/pull/37566)
+* [[`839976669f`](https://github.com/nodejs/node/commit/839976669f)] - **tools**: add support for mjs and cjs JS snippet linting (Antoine du Hamel) [#37311](https://github.com/nodejs/node/pull/37311)
+* [[`2463bd0689`](https://github.com/nodejs/node/commit/2463bd0689)] - **tools**: update eslint-plugin-markdown configuration (Colin Ihrig) [#37549](https://github.com/nodejs/node/pull/37549)
+* [[`f868fac455`](https://github.com/nodejs/node/commit/f868fac455)] - **tools**: enable object-curly-newline in ESLint rules (Rich Trott) [#37040](https://github.com/nodejs/node/pull/37040)
+* [[`d13508d219`](https://github.com/nodejs/node/commit/d13508d219)] - **tools**: make GH Actions workflows work if default branch is not master (Antoine du Hamel) [#38516](https://github.com/nodejs/node/pull/38516)
+* [[`7021c31d06`](https://github.com/nodejs/node/commit/7021c31d06)] - **tools**: use mktemp to create the workspace directory (Luigi Pinca) [#38432](https://github.com/nodejs/node/pull/38432)
+* [[`16a3e555ba`](https://github.com/nodejs/node/commit/16a3e555ba)] - **tools**: use a shallow clone of the npm/cli repository (Luigi Pinca) [#38463](https://github.com/nodejs/node/pull/38463)
+* [[`3484a23140`](https://github.com/nodejs/node/commit/3484a23140)] - **tools**: remove fixer for non-ascii-character ESLint custom rule (Rich Trott) [#38413](https://github.com/nodejs/node/pull/38413)
+* [[`aec4b295e4`](https://github.com/nodejs/node/commit/aec4b295e4)] - **tools**: fix doc generation when version info is not available (Antoine du Hamel) [#38398](https://github.com/nodejs/node/pull/38398)
+* [[`0172b110a3`](https://github.com/nodejs/node/commit/0172b110a3)] - **tools**: add \_depot\_tools to PATH (for V8 tests) (DeeDeeG) [#38299](https://github.com/nodejs/node/pull/38299)
+* [[`d0eed18c87`](https://github.com/nodejs/node/commit/d0eed18c87)] - **tools**: fix type mismatch in test runner (Richard Lau) [#38289](https://github.com/nodejs/node/pull/38289)
+* [[`11ca018db9`](https://github.com/nodejs/node/commit/11ca018db9)] - **tools**: simplify eslint comma-dangle configuration (tools) (Rich Trott) [#37883](https://github.com/nodejs/node/pull/37883)
+* [[`f7c14e86a7`](https://github.com/nodejs/node/commit/f7c14e86a7)] - **tools**: simplify eslint comma-dangle configuration (Rich Trott) [#37850](https://github.com/nodejs/node/pull/37850)
+* [[`241e05795b`](https://github.com/nodejs/node/commit/241e05795b)] - **tools**: run doctool tests on GitHub Actions CI (Antoine du Hamel) [#37398](https://github.com/nodejs/node/pull/37398)
+* [[`a4dd50f8f9`](https://github.com/nodejs/node/commit/a4dd50f8f9)] - **tools**: refactor prefer-primordials (Antoine du Hamel) [#36018](https://github.com/nodejs/node/pull/36018)
+* [[`4af3906e72`](https://github.com/nodejs/node/commit/4af3906e72)] - **tools**: update ESLint to 7.21.0 (Luigi Pinca) [#37546](https://github.com/nodejs/node/pull/37546)
+* [[`955880de1a`](https://github.com/nodejs/node/commit/955880de1a)] - **tools**: update ESLint to 7.20.0 (Colin Ihrig) [#37339](https://github.com/nodejs/node/pull/37339)
+* [[`42c1f98a31`](https://github.com/nodejs/node/commit/42c1f98a31)] - **tools**: update ESLint to 7.19.0 (Colin Ihrig) [#37159](https://github.com/nodejs/node/pull/37159)
+* [[`25eb720b4d`](https://github.com/nodejs/node/commit/25eb720b4d)] - **tools**: update ESLint to 7.18.0 (Colin Ihrig) [#36955](https://github.com/nodejs/node/pull/36955)
+* [[`4983ef205e`](https://github.com/nodejs/node/commit/4983ef205e)] - **tools**: update gyp-next to v0.7.0 (Michaël Zasso) [#36580](https://github.com/nodejs/node/pull/36580)
+* [[`613378da1e`](https://github.com/nodejs/node/commit/613378da1e)] - **tools**: update ESLint to 7.17.0 (Colin Ihrig) [#36726](https://github.com/nodejs/node/pull/36726)
+* [[`e6d01f6545`](https://github.com/nodejs/node/commit/e6d01f6545)] - **tools**: update ESLint to 7.16.0 (Yongsheng Zhang) [#36579](https://github.com/nodejs/node/pull/36579)
+* [[`98806da810`](https://github.com/nodejs/node/commit/98806da810)] - **tools**: enable no-unsafe-optional-chaining lint rule (Colin Ihrig) [#36411](https://github.com/nodejs/node/pull/36411)
+* [[`7d411920f6`](https://github.com/nodejs/node/commit/7d411920f6)] - **tools**: update ESLint to 7.15.0 (Colin Ihrig) [#36411](https://github.com/nodejs/node/pull/36411)
+* [[`226a86c3b5`](https://github.com/nodejs/node/commit/226a86c3b5)] - **tools**: enable no-unused-expressions lint rule (Michaël Zasso) [#36248](https://github.com/nodejs/node/pull/36248)
+* [[`24a81c7d6c`](https://github.com/nodejs/node/commit/24a81c7d6c)] - **tools**: enable no-nonoctal-decimal-escape lint rule (Colin Ihrig) [#36217](https://github.com/nodejs/node/pull/36217)
+* [[`19d4eb17b9`](https://github.com/nodejs/node/commit/19d4eb17b9)] - **tools**: update ESLint to 7.14.0 (Colin Ihrig) [#36217](https://github.com/nodejs/node/pull/36217)
+* [[`9fa8d2037f`](https://github.com/nodejs/node/commit/9fa8d2037f)] - **tools**: add linting rule for async IIFEs (Anna Henningsen) [#34363](https://github.com/nodejs/node/pull/34363)
+* [[`55fc206d13`](https://github.com/nodejs/node/commit/55fc206d13)] - **tools**: update ESLint to 7.13.0 (Luigi Pinca) [#36031](https://github.com/nodejs/node/pull/36031)
+* [[`937fc0a30c`](https://github.com/nodejs/node/commit/937fc0a30c)] - **tools**: update ESLint to 7.12.1 (Colin Ihrig) [#35799](https://github.com/nodejs/node/pull/35799)
+* [[`29d0840a90`](https://github.com/nodejs/node/commit/29d0840a90)] - **tools**: update ESLint to 7.12.0 (Colin Ihrig) [#35799](https://github.com/nodejs/node/pull/35799)
+* [[`dcbd44758c`](https://github.com/nodejs/node/commit/dcbd44758c)] - **tools**: update ESLint to 7.11.0 (Colin Ihrig) [#35578](https://github.com/nodejs/node/pull/35578)
+* [[`c7751b4e69`](https://github.com/nodejs/node/commit/c7751b4e69)] - **tools**: add new ESLint rule: prefer-primordials (Leko) [#35448](https://github.com/nodejs/node/pull/35448)
+* [[`9a5411a2b4`](https://github.com/nodejs/node/commit/9a5411a2b4)] - **tools,doc**: add support for several flavors of JS code snippets (Antoine du Hamel) [#37162](https://github.com/nodejs/node/pull/37162)
+* [[`e19478aa76`](https://github.com/nodejs/node/commit/e19478aa76)] - **tools,lib**: recommend using safe primordials (Antoine du Hamel) [#36026](https://github.com/nodejs/node/pull/36026)
+* [[`5f848a612d`](https://github.com/nodejs/node/commit/5f848a612d)] - **tools,lib**: tighten prefer-primordials rules for Error statics (Antoine du Hamel) [#36017](https://github.com/nodejs/node/pull/36017)
+* [[`716076e389`](https://github.com/nodejs/node/commit/716076e389)] - **tty**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#36771](https://github.com/nodejs/node/pull/36771)
+* [[`41d74a4d9a`](https://github.com/nodejs/node/commit/41d74a4d9a)] - **tty**: refactor to use more primordials (Zijian Liu) [#36272](https://github.com/nodejs/node/pull/36272)
+* [[`e35a3543fd`](https://github.com/nodejs/node/commit/e35a3543fd)] - **typings**: add JSDoc typings for util (Rohit Gohri) [#38213](https://github.com/nodejs/node/pull/38213)
+* [[`c8b22185f7`](https://github.com/nodejs/node/commit/c8b22185f7)] - **url**: refactor to use more primordials (Antoine du Hamel) [#36316](https://github.com/nodejs/node/pull/36316)
+* [[`e113035c9a`](https://github.com/nodejs/node/commit/e113035c9a)] - **util**: simplify constructor retrieval in inspect() (Rich Trott) [#36466](https://github.com/nodejs/node/pull/36466)
+* [[`1551b40d01`](https://github.com/nodejs/node/commit/1551b40d01)] - **v8**: refactor to use more primordials (Antoine du Hamel) [#36527](https://github.com/nodejs/node/pull/36527)
+* [[`6c1bbb5caf`](https://github.com/nodejs/node/commit/6c1bbb5caf)] - **v8**: refactor to use more primordials (Antoine du Hamel) [#36285](https://github.com/nodejs/node/pull/36285)
+* [[`3aee77d279`](https://github.com/nodejs/node/commit/3aee77d279)] - **vm**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#36752](https://github.com/nodejs/node/pull/36752)
+* [[`0dea86634d`](https://github.com/nodejs/node/commit/0dea86634d)] - **wasi**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#36724](https://github.com/nodejs/node/pull/36724)
+* [[`2c66305ac4`](https://github.com/nodejs/node/commit/2c66305ac4)] - ***Revert*** "**worker**: remove `ERR_CLOSED_MESSAGE_PORT`" (Juan José Arboleda) [#38510](https://github.com/nodejs/node/pull/38510)
+* [[`698bffaa90`](https://github.com/nodejs/node/commit/698bffaa90)] - **worker**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#37346](https://github.com/nodejs/node/pull/37346)
+* [[`3d4785c174`](https://github.com/nodejs/node/commit/3d4785c174)] - **worker**: refactor to use more primordials (Antoine du Hamel) [#36267](https://github.com/nodejs/node/pull/36267)
+* [[`8702b045a4`](https://github.com/nodejs/node/commit/8702b045a4)] - **zlib**: fix brotli flush range (Khaidi Chu) [#38408](https://github.com/nodejs/node/pull/38408)
+* [[`459fe6864e`](https://github.com/nodejs/node/commit/459fe6864e)] - **zlib**: refactor to avoid unsafe array iteration (Antoine du Hamel) [#36722](https://github.com/nodejs/node/pull/36722)
+* [[`740638de0f`](https://github.com/nodejs/node/commit/740638de0f)] - **zlib**: refactor to use primordial instead of \<string\>.startsWith (Rohan Chougule) [#36718](https://github.com/nodejs/node/pull/36718)
+* [[`32e10f388c`](https://github.com/nodejs/node/commit/32e10f388c)] - **zlib**: refactor to use more primordials (Antoine du Hamel) [#36347](https://github.com/nodejs/node/pull/36347)
+
+<a id="14.17.0"></a>
+## 2021-05-11, Version 14.17.0 'Fermium' (LTS), @danielleadams
+
+### Notable Changes
+
+#### Diagnostics channel (experimental module)
+
+`diagnostics_channel` is a new experimental module that provides an API to create named channels to report arbitrary message data for diagnostics purposes.
+
+The module was initially introduced in Node.js v15.1.0 and is backported to v14.17.0
+to enable testing it at a larger scale.
+
+With `diagnostics_channel`, Node.js core and module authors can publish contextual data about what they are doing at a given time. This could be the hostname and query string of a mysql query, for example. Just create a named channel with `dc.channel(name)` and call `channel.publish(data)` to send the data to any listeners to that channel.
+
+```js
+const dc = require('diagnostics_channel');
+const channel = dc.channel('mysql.query');
+
+MySQL.prototype.query = function query(queryString, values, callback) {
+  // Broadcast query information whenever a query is made
+  channel.publish({
+    query: queryString,
+    host: this.hostname,
+  });
+
+  this.doQuery(queryString, values, callback);
+};
+```
+
+Channels are like one big global event emitter but are split into separate objects to ensure they get the best performance. If nothing is listening to the channel, the publishing overhead should be as close to zero as possible. Consuming channel data is as easy as using `channel.subscribe(listener)` to run a function whenever a message is published to that channel.
+
+```js
+const dc = require('diagnostics_channel');
+const channel = dc.channel('mysql.query');
+
+channel.subscribe(({ query, host }) => {
+  console.log(`mysql query to ${host}: ${query}`);
+});
+```
+
+The data captured can be used to provide context for what an app is doing at a given time. This can be used for things like augmenting tracing data, tracking network and filesystem activity, logging queries, and many other things. It's also a very useful data source for diagnostics tools to provide a clearer picture of exactly what the application is doing at a given point in the data they are presenting.
+
+Contributed by Stephen Belanger [#34895](https://github.com/nodejs/node/pull/34895).
+
+#### UUID support in the crypto module
+
+The new `crypto.randomUUID()` method now allows to generate random
+[RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.txt) Version 4 UUID strings:
+
+```js
+const { randomUUID } = require('crypto');
+
+console.log(randomUUID());
+// 'aa7c91a1-f8fc-4339-b9db-f93fc7233429'
+```
+
+Contributed by James M Snell [#36729](https://github.com/nodejs/node/pull/36729).
+
+#### Experimental support for `AbortController` and `AbortSignal`
+
+Node.js 14.17.0 adds experimental partial support for `AbortController` and `AbortSignal`.
+
+Both constructors can be enabled globally using the `--experimental-abortcontroller` flag.
+
+Additionally, several Node.js APIs have been updated to support `AbortSignal` for cancellation.
+It is not mandatory to use the built-in constructors with them. Any spec-compliant third-party alternatives
+should be compatible.
+
+`AbortSignal` support was added to the following methods:
+
+* `child_process.exec`
+* `child_process.execFile`
+* `child_process.fork`
+* `child_process.spawn`
+* `dgram.createSocket`
+* `events.on`
+* `events.once`
+* `fs.readFile`
+* `fs.watch`
+* `fs.writeFile`
+* `http.request`
+* `https.request`
+* `http2Session.request`
+* The promisified variants of `setImmediate` and `setTimeout`
+
+#### Other notable changes
+
+* **doc**:
+  * revoke deprecation of legacy url, change status to legacy (James M Snell) [#37784](https://github.com/nodejs/node/pull/37784)
+  * add legacy status to stability index (James M Snell) [#37784](https://github.com/nodejs/node/pull/37784)
+  * upgrade stability status of report API (Gireesh Punathil) [#35654](https://github.com/nodejs/node/pull/35654)
+* **deps**:
+  * V8: Backport various patches for Apple Silicon support (BoHong Li) [#38051](https://github.com/nodejs/node/pull/38051)
+  * update ICU to 68.1 (Michaël Zasso) [#36187](https://github.com/nodejs/node/pull/36187)
+  * upgrade to libuv 1.41.0 (Colin Ihrig) [#37360](https://github.com/nodejs/node/pull/37360)
+* **http**:
+  * add http.ClientRequest.getRawHeaderNames() (simov) [#37660](https://github.com/nodejs/node/pull/37660)
+  * report request start and end with diagnostics\_channel (Stephen Belanger) [#34895](https://github.com/nodejs/node/pull/34895)
+* **util**:
+  * add getSystemErrorMap() impl (eladkeyshawn) [#38101](https://github.com/nodejs/node/pull/38101)
+
+### Commits
+
+* [[`9fb10dc4e7`](https://github.com/nodejs/node/commit/9fb10dc4e7)] - **assert,util**: fix commutativity edge case (Ruben Bridgewater) [#37711](https://github.com/nodejs/node/pull/37711)
+* [[`2bbf253b00`](https://github.com/nodejs/node/commit/2bbf253b00)] - **benchmark**: changed `fstat` to `fstatSync` (Narasimha Prasanna HN) [#36206](https://github.com/nodejs/node/pull/36206)
+* [[`c00c31c3c5`](https://github.com/nodejs/node/commit/c00c31c3c5)] - **benchmark**: improve compare.R output (Brian White) [#38118](https://github.com/nodejs/node/pull/38118)
+* [[`a191bc7761`](https://github.com/nodejs/node/commit/a191bc7761)] - **benchmark**: add benchmark for fsPromises.writeFile (Nitzan Uziely) [#37610](https://github.com/nodejs/node/pull/37610)
+* [[`d2770a5608`](https://github.com/nodejs/node/commit/d2770a5608)] - **benchmark**: add benchmark for NODE\_V8\_COVERAGE (Benjamin Coe) [#36972](https://github.com/nodejs/node/pull/36972)
+* [[`4318e708b8`](https://github.com/nodejs/node/commit/4318e708b8)] - **benchmark**: make output RFC 4180 compliant (Tobias Nießen) [#37038](https://github.com/nodejs/node/pull/37038)
+* [[`0fbeab7a95`](https://github.com/nodejs/node/commit/0fbeab7a95)] - **benchmark**: improve explanations in R script (Tobias Nießen) [#36995](https://github.com/nodejs/node/pull/36995)
+* [[`c22efc5191`](https://github.com/nodejs/node/commit/c22efc5191)] - **benchmark**: fix http2 benchmarks (Rich Trott) [#36871](https://github.com/nodejs/node/pull/36871)
+* [[`682d0a92db`](https://github.com/nodejs/node/commit/682d0a92db)] - **benchmark**: fix http/headers.js with test-double (Rich Trott) [#36794](https://github.com/nodejs/node/pull/36794)
+* [[`3a11ee88a2`](https://github.com/nodejs/node/commit/3a11ee88a2)] - **benchmark**: add simple https benchmark (Andrey Pechkurov) [#36612](https://github.com/nodejs/node/pull/36612)
+* [[`681c4afc51`](https://github.com/nodejs/node/commit/681c4afc51)] - **benchmark**: reduce code duplication (Rich Trott) [#36568](https://github.com/nodejs/node/pull/36568)
+* [[`f28eea0896`](https://github.com/nodejs/node/commit/f28eea0896)] - **benchmark,child_process**: remove failing benchmark parameter (Antoine du Hamel) [#36295](https://github.com/nodejs/node/pull/36295)
+* [[`bf2d9f25d4`](https://github.com/nodejs/node/commit/bf2d9f25d4)] - **(SEMVER-MINOR)** **buffer**: implement btoa and atob (James M Snell) [#37529](https://github.com/nodejs/node/pull/37529)
+* [[`0544410328`](https://github.com/nodejs/node/commit/0544410328)] - **buffer,errors**: add missing n literal in range error string (Cactysman) [#37750](https://github.com/nodejs/node/pull/37750)
+* [[`5667d0a540`](https://github.com/nodejs/node/commit/5667d0a540)] - **build**: don't run test workflow on doc dir on macOS (ycjcl868) [#37999](https://github.com/nodejs/node/pull/37999)
+* [[`079d90b9f3`](https://github.com/nodejs/node/commit/079d90b9f3)] - **build**: package release changelog for releases (Richard Lau) [#38033](https://github.com/nodejs/node/pull/38033)
+* [[`5c74dc7227`](https://github.com/nodejs/node/commit/5c74dc7227)] - **build**: refactor Makefile (raisinten) [#36759](https://github.com/nodejs/node/pull/36759)
+* [[`38921b3805`](https://github.com/nodejs/node/commit/38921b3805)] - **build**: do not "exit" a script meant to be "source"d (François-Denis Gonthier) [#35520](https://github.com/nodejs/node/pull/35520)
+* [[`dcbcd9e045`](https://github.com/nodejs/node/commit/dcbcd9e045)] - **build**: run some workflows only on nodejs/node (Michaël Zasso) [#36507](https://github.com/nodejs/node/pull/36507)
+* [[`cda0a80713`](https://github.com/nodejs/node/commit/cda0a80713)] - **build**: fix typo in Makefile (raisinten) [#36176](https://github.com/nodejs/node/pull/36176)
+* [[`d8f8719415`](https://github.com/nodejs/node/commit/d8f8719415)] - **build**: do not pass mode option to test-v8 command (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`f62b138278`](https://github.com/nodejs/node/commit/f62b138278)] - **build**: fix label-pr workflow (Michaël Zasso) [#38399](https://github.com/nodejs/node/pull/38399)
+* [[`1250db9206`](https://github.com/nodejs/node/commit/1250db9206)] - **build**: label PRs with GitHub Action instead of nodejs-github-bot (Phillip Johnsen) [#38301](https://github.com/nodejs/node/pull/38301)
+* [[`9ccf7dbe2d`](https://github.com/nodejs/node/commit/9ccf7dbe2d)] - **build,lib,test**: change whitelist to allowlist (Michaël Zasso) [#36406](https://github.com/nodejs/node/pull/36406)
+* [[`385e8e8d7b`](https://github.com/nodejs/node/commit/385e8e8d7b)] - **(SEMVER-MINOR)** **child_process**: support AbortSignal in fork (Benjamin Gruenbaum) [#36603](https://github.com/nodejs/node/pull/36603)
+* [[`0b691ce57e`](https://github.com/nodejs/node/commit/0b691ce57e)] - **(SEMVER-MINOR)** **child_process**: add signal support to spawn (Benjamin Gruenbaum) [#36432](https://github.com/nodejs/node/pull/36432)
+* [[`6c08c9de4a`](https://github.com/nodejs/node/commit/6c08c9de4a)] - **child_process**: clean event listener correctly (Benjamin Gruenbaum) [#36424](https://github.com/nodejs/node/pull/36424)
+* [[`a5c0f39197`](https://github.com/nodejs/node/commit/a5c0f39197)] - **(SEMVER-MINOR)** **child_process**: add AbortSignal support (Benjamin Gruenbaum) [#36308](https://github.com/nodejs/node/pull/36308)
+* [[`aa5b726f83`](https://github.com/nodejs/node/commit/aa5b726f83)] - **(SEMVER-MINOR)** **child_process**: add ChildProcess 'spawn' event (Matthew Francis Brunetti) [#35369](https://github.com/nodejs/node/pull/35369)
+* [[`723977feaa`](https://github.com/nodejs/node/commit/723977feaa)] - **crypto**: reduce range of size to int max (Qingyu Deng) [#38096](https://github.com/nodejs/node/pull/38096)
+* [[`46ece20fe3`](https://github.com/nodejs/node/commit/46ece20fe3)] - **crypto**: fix DiffieHellman argument validation (Antoine du Hamel) [#37810](https://github.com/nodejs/node/pull/37810)
+* [[`00659a9218`](https://github.com/nodejs/node/commit/00659a9218)] - **crypto**: fix randomInt bias (Tobias Nießen) [#36894](https://github.com/nodejs/node/pull/36894)
+* [[`08f9130888`](https://github.com/nodejs/node/commit/08f9130888)] - **(SEMVER-MINOR)** **crypto**: implement randomuuid (James M Snell) [#36729](https://github.com/nodejs/node/pull/36729)
+* [[`8951c19e72`](https://github.com/nodejs/node/commit/8951c19e72)] - **deps**: V8: cherry-pick 501482cbc704 (Colin Ihrig) [#38121](https://github.com/nodejs/node/pull/38121)
+* [[`ea0b0697c3`](https://github.com/nodejs/node/commit/ea0b0697c3)] - **deps**: update nghttp2 to 1.42.0 (Michaël Zasso) [#36842](https://github.com/nodejs/node/pull/36842)
+* [[`5747dff04e`](https://github.com/nodejs/node/commit/5747dff04e)] - **deps**: update to c-ares 1.17.1 (Danny Sonnenschein) [#36207](https://github.com/nodejs/node/pull/36207)
+* [[`329ee8bbc3`](https://github.com/nodejs/node/commit/329ee8bbc3)] - **deps**: V8: cherry-pick bbc59d124ef3 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`bda15149f8`](https://github.com/nodejs/node/commit/bda15149f8)] - **deps**: V8: cherry-pick be91c6c50818 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`16a005cfa0`](https://github.com/nodejs/node/commit/16a005cfa0)] - **deps**: V8: cherry-pick 4e24c353d812 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`42140a12f2`](https://github.com/nodejs/node/commit/42140a12f2)] - **deps**: V8: cherry-pick eddb82330975 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`4d0bc3839a`](https://github.com/nodejs/node/commit/4d0bc3839a)] - **deps**: V8: cherry-pick 6771d3e31883 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`982937893e`](https://github.com/nodejs/node/commit/982937893e)] - **deps**: V8: cherry-pick f44fcbf803ac (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`fa45d6a358`](https://github.com/nodejs/node/commit/fa45d6a358)] - **deps**: V8: cherry-pick 93b2105fbe44 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`c5fe3a226a`](https://github.com/nodejs/node/commit/c5fe3a226a)] - **deps**: V8: cherry-pick 1a7d55a9a427 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`7dd68ac5b6`](https://github.com/nodejs/node/commit/7dd68ac5b6)] - **deps**: V8: cherry-pick 8ebd894186ed (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`a4a9246ea1`](https://github.com/nodejs/node/commit/a4a9246ea1)] - **deps**: V8: cherry-pick 1e35f6472510 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`9bfb0f33e9`](https://github.com/nodejs/node/commit/9bfb0f33e9)] - **deps**: V8: cherry-pick 3066b7b2fcb3 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`5dc82469d5`](https://github.com/nodejs/node/commit/5dc82469d5)] - **deps**: V8: cherry-pick 254c7945eea2 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`77b7a3b710`](https://github.com/nodejs/node/commit/77b7a3b710)] - **deps**: V8: cherry-pick 5678ebe8f6c4 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`0bd8e14501`](https://github.com/nodejs/node/commit/0bd8e14501)] - **deps**: V8: cherry-pick 813066946968 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`d221cdc97c`](https://github.com/nodejs/node/commit/d221cdc97c)] - **deps**: V8: cherry-pick d2283ba066ba (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`26cc160565`](https://github.com/nodejs/node/commit/26cc160565)] - **deps**: V8: cherry-pick 53c4d057974a (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`05530e8333`](https://github.com/nodejs/node/commit/05530e8333)] - **deps**: V8: cherry-pick e527ba4bf8af (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`fdb4a0c170`](https://github.com/nodejs/node/commit/fdb4a0c170)] - **deps**: V8: cherry-pick 5c6c99a8dc72 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`42552a7eda`](https://github.com/nodejs/node/commit/42552a7eda)] - **deps**: V8: cherry-pick ad2c5dae4688 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`aff53dd8b3`](https://github.com/nodejs/node/commit/aff53dd8b3)] - **deps**: V8: cherry-pick 482e5c7750b3 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`931d31a2cb`](https://github.com/nodejs/node/commit/931d31a2cb)] - **deps**: V8: cherry-pick 412ac52d8246 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`e99e456757`](https://github.com/nodejs/node/commit/e99e456757)] - **deps**: V8: cherry-pick c449afa1953b (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`18a4cbfb52`](https://github.com/nodejs/node/commit/18a4cbfb52)] - **deps**: V8: cherry-pick 3ba21a17ce2f (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`70f622b542`](https://github.com/nodejs/node/commit/70f622b542)] - **deps**: V8: cherry-pick 8c725f7b5bbf (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`0e6976f5ee`](https://github.com/nodejs/node/commit/0e6976f5ee)] - **deps**: V8: cherry-pick ed3eedae33d0 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`86c7c0ae4e`](https://github.com/nodejs/node/commit/86c7c0ae4e)] - **deps**: V8: cherry-pick 6a4cd97d6691 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`b10cce1b87`](https://github.com/nodejs/node/commit/b10cce1b87)] - **deps**: V8: cherry-pick d724820c1d5d (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`aaeeb75a99`](https://github.com/nodejs/node/commit/aaeeb75a99)] - **deps**: V8: cherry-pick 33f4064dbad3 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`b0d1a060e2`](https://github.com/nodejs/node/commit/b0d1a060e2)] - **deps**: V8: cherry-pick abb4d0a431c0 (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`5372f1ff5b`](https://github.com/nodejs/node/commit/5372f1ff5b)] - **deps**: V8: cherry-pick a59e3ac1d7fa (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`31154a5611`](https://github.com/nodejs/node/commit/31154a5611)] - **deps**: V8: cherry-pick 516b5d3f9cfe (Michaël Zasso) [#38275](https://github.com/nodejs/node/pull/38275)
+* [[`fc8f1b7f0a`](https://github.com/nodejs/node/commit/fc8f1b7f0a)] - **deps**: upgrade npm to 6.14.13 (Ruy Adorno) [#38214](https://github.com/nodejs/node/pull/38214)
+* [[`0c1e878c4c`](https://github.com/nodejs/node/commit/0c1e878c4c)] - **deps**: backport v8 f19142e6 (Guy Bedford) [#37864](https://github.com/nodejs/node/pull/37864)
+* [[`dd5da301c8`](https://github.com/nodejs/node/commit/dd5da301c8)] - **deps**: backport v8 5f90cfd7 (Guy Bedford) [#37973](https://github.com/nodejs/node/pull/37973)
+* [[`d56079ab9b`](https://github.com/nodejs/node/commit/d56079ab9b)] - **deps**: update to cjs-module-lexer@1.1.1 (Guy Bedford) [#38002](https://github.com/nodejs/node/pull/38002)
+* [[`866e3244da`](https://github.com/nodejs/node/commit/866e3244da)] - **deps**: V8: Backport various patches for Apple Silicon support (BoHong Li) [#38051](https://github.com/nodejs/node/pull/38051)
+* [[`16b59c62ff`](https://github.com/nodejs/node/commit/16b59c62ff)] - **deps**: cherry-pick 8957d4677aa794c230577f234071af0 from V8 upstream (Antoine du Hamel) [#37471](https://github.com/nodejs/node/pull/37471)
+* [[`5707adaf33`](https://github.com/nodejs/node/commit/5707adaf33)] - **deps**: V8: cherry-pick 0c8b6e415c30 (Matin Zadehdolatabad) [#37276](https://github.com/nodejs/node/pull/37276)
+* [[`7d247f1691`](https://github.com/nodejs/node/commit/7d247f1691)] - **deps**: V8: cherry-pick 1d0f426311d4 (Ole André Vadla Ravnås) [#35986](https://github.com/nodejs/node/pull/35986)
+* [[`14a87a5a01`](https://github.com/nodejs/node/commit/14a87a5a01)] - **deps**: V8: cherry-pick 4e077ff0444a (Ole André Vadla Ravnås) [#35986](https://github.com/nodejs/node/pull/35986)
+* [[`507c2f2101`](https://github.com/nodejs/node/commit/507c2f2101)] - **deps**: V8: cherry-pick 086eecbd96b6 (Ole André Vadla Ravnås) [#35986](https://github.com/nodejs/node/pull/35986)
+* [[`31f8610a02`](https://github.com/nodejs/node/commit/31f8610a02)] - **deps**: V8: cherry-pick 27e1ac1a79ff (Ole André Vadla Ravnås) [#35986](https://github.com/nodejs/node/pull/35986)
+* [[`6b115d762d`](https://github.com/nodejs/node/commit/6b115d762d)] - **deps**: patch V8 to 8.4.371.23 (Michaël Zasso) [#38001](https://github.com/nodejs/node/pull/38001)
+* [[`a92ecf0081`](https://github.com/nodejs/node/commit/a92ecf0081)] - **deps**: v8 backport 9689b17687b (Guy Bedford) [#37865](https://github.com/nodejs/node/pull/37865)
+* [[`3e8ceed0eb`](https://github.com/nodejs/node/commit/3e8ceed0eb)] - **deps**: update ICU to 68.2 (Michaël Zasso) [#36980](https://github.com/nodejs/node/pull/36980)
+* [[`2d7e0b6912`](https://github.com/nodejs/node/commit/2d7e0b6912)] - **deps**: update ICU to 68.1 (Michaël Zasso) [#36187](https://github.com/nodejs/node/pull/36187)
+* [[`bfba66dbd6`](https://github.com/nodejs/node/commit/bfba66dbd6)] - **deps**: upgrade to libuv 1.41.0 (Colin Ihrig) [#37360](https://github.com/nodejs/node/pull/37360)
+* [[`e446d82394`](https://github.com/nodejs/node/commit/e446d82394)] - **deps**: V8: cherry-pick beebee4f80ff (Peter Marshall) [#37293](https://github.com/nodejs/node/pull/37293)
+* [[`ae1fa98496`](https://github.com/nodejs/node/commit/ae1fa98496)] - **deps**: cherry-pick f4376ec801e1ded from V8 upstream (Daniel Bevenius) [#37225](https://github.com/nodejs/node/pull/37225)
+* [[`81cd06b3c6`](https://github.com/nodejs/node/commit/81cd06b3c6)] - **(SEMVER-MINOR)** **dgram**: support AbortSignal in createSocket (Nitzan Uziely) [#37026](https://github.com/nodejs/node/pull/37026)
+* [[`46651b63c1`](https://github.com/nodejs/node/commit/46651b63c1)] - **dns**: refactor cares\_wrap internals (James M Snell) [#38172](https://github.com/nodejs/node/pull/38172)
+* [[`8715462f47`](https://github.com/nodejs/node/commit/8715462f47)] - **(SEMVER-MINOR)** **dns**: add a cancel() method to the promise Resolver (Szymon Marczak) [#33099](https://github.com/nodejs/node/pull/33099)
+* [[`0f126d0e05`](https://github.com/nodejs/node/commit/0f126d0e05)] - **dns**: fix trace\_events name for resolveCaa() (Rich Trott) [#35979](https://github.com/nodejs/node/pull/35979)
+* [[`ed79c98683`](https://github.com/nodejs/node/commit/ed79c98683)] - **(SEMVER-MINOR)** **dns**: add setLocalAddress to Resolver (Josh Dague) [#34824](https://github.com/nodejs/node/pull/34824)
+* [[`2e7f74c8a5`](https://github.com/nodejs/node/commit/2e7f74c8a5)] - **doc**: harmonize changes list ordering (Antoine du Hamel) [#35454](https://github.com/nodejs/node/pull/35454)
+* [[`885ed96540`](https://github.com/nodejs/node/commit/885ed96540)] - **doc**: fix typo in repl.md (Arkerone) [#38244](https://github.com/nodejs/node/pull/38244)
+* [[`92650278eb`](https://github.com/nodejs/node/commit/92650278eb)] - **doc**: change "oject" to "object" (Arkerone) [#38256](https://github.com/nodejs/node/pull/38256)
+* [[`5dfe5af155`](https://github.com/nodejs/node/commit/5dfe5af155)] - **doc**: revise TLS minVersion/maxVersion text (Rich Trott) [#38202](https://github.com/nodejs/node/pull/38202)
+* [[`e6c599b680`](https://github.com/nodejs/node/commit/e6c599b680)] - **doc**: standardize command flag notes (Ferdi) [#38199](https://github.com/nodejs/node/pull/38199)
+* [[`bb8db846b3`](https://github.com/nodejs/node/commit/bb8db846b3)] - **doc**: clarify child\_process close event (Nitzan Uziely) [#38181](https://github.com/nodejs/node/pull/38181)
+* [[`be28376140`](https://github.com/nodejs/node/commit/be28376140)] - **doc**: add command flag to import.meta.resolve (Ferdi) [#38171](https://github.com/nodejs/node/pull/38171)
+* [[`c7c8722ba3`](https://github.com/nodejs/node/commit/c7c8722ba3)] - **doc**: update links in ICU guide (Michaël Zasso) [#38177](https://github.com/nodejs/node/pull/38177)
+* [[`4350bf5a0b`](https://github.com/nodejs/node/commit/4350bf5a0b)] - **doc**: mention cryptographic prng in description of randomUUID (Serkan Özel) [#38074](https://github.com/nodejs/node/pull/38074)
+* [[`424c8e1eb9`](https://github.com/nodejs/node/commit/424c8e1eb9)] - **doc**: add link to V8 (Voltrex) [#38144](https://github.com/nodejs/node/pull/38144)
+* [[`ecc85516cf`](https://github.com/nodejs/node/commit/ecc85516cf)] - **doc**: improve security text in collaborators guide (Rich Trott) [#38107](https://github.com/nodejs/node/pull/38107)
+* [[`6c970ba2d4`](https://github.com/nodejs/node/commit/6c970ba2d4)] - **doc**: apply consistent punctuation to header contributing guide (Akhil Marsonya) [#38047](https://github.com/nodejs/node/pull/38047)
+* [[`aff0cd3ea6`](https://github.com/nodejs/node/commit/aff0cd3ea6)] - **doc**: sending http request to localhost to avoid https redirect (Hassaan Pasha) [#38036](https://github.com/nodejs/node/pull/38036)
+* [[`56aaf7010c`](https://github.com/nodejs/node/commit/56aaf7010c)] - **doc**: apply sentence case to backporting-to-release-lines.md headers (marsonya) [#37617](https://github.com/nodejs/node/pull/37617)
+* [[`8615fa1983`](https://github.com/nodejs/node/commit/8615fa1983)] - **doc**: add parentheses to function and move reference (Rich Trott) [#38066](https://github.com/nodejs/node/pull/38066)
+* [[`5d2f0d0c4e`](https://github.com/nodejs/node/commit/5d2f0d0c4e)] - **doc**: change wording in doc/api/domain.md comment (Akhil Marsonya) [#38044](https://github.com/nodejs/node/pull/38044)
+* [[`ac59022106`](https://github.com/nodejs/node/commit/ac59022106)] - **doc**: fix asyncLocalStorage.run() description (Darkripper214) [#38023](https://github.com/nodejs/node/pull/38023)
+* [[`df54edc668`](https://github.com/nodejs/node/commit/df54edc668)] - **doc**: document how to unref stdin when using readline.Interface (Anu Pasumarthy) [#38019](https://github.com/nodejs/node/pull/38019)
+* [[`21bc5d4bd4`](https://github.com/nodejs/node/commit/21bc5d4bd4)] - **doc**: move psmarshall to collaborators emeriti (Peter Marshall) [#37994](https://github.com/nodejs/node/pull/37994)
+* [[`69c4bfd750`](https://github.com/nodejs/node/commit/69c4bfd750)] - **doc**: add distinctive color for code elements inside links (Antoine du Hamel) [#37950](https://github.com/nodejs/node/pull/37950)
+* [[`35a382e814`](https://github.com/nodejs/node/commit/35a382e814)] - **doc**: add Windows-specific info to subprocess.kill() (João Lucas Lucchetta) [#34867](https://github.com/nodejs/node/pull/34867)
+* [[`2a5f21f9cd`](https://github.com/nodejs/node/commit/2a5f21f9cd)] - **doc**: fix typos in lib/internal/bootstrap/pre\_execution.js (marsonya) [#37658](https://github.com/nodejs/node/pull/37658)
+* [[`9f1f2153e9`](https://github.com/nodejs/node/commit/9f1f2153e9)] - **doc**: add more commands for cherry-picking and changelog to release docs (Danielle Adams) [#37785](https://github.com/nodejs/node/pull/37785)
+* [[`dd1c47bbf3`](https://github.com/nodejs/node/commit/dd1c47bbf3)] - **doc**: spell out ICU acronym on first occurrence (Rich Trott) [#37942](https://github.com/nodejs/node/pull/37942)
+* [[`585f1119a3`](https://github.com/nodejs/node/commit/585f1119a3)] - **doc**: update GOVERNANCE.md for TSC Charter changes (Rich Trott) [#37888](https://github.com/nodejs/node/pull/37888)
+* [[`b51651cfc5`](https://github.com/nodejs/node/commit/b51651cfc5)] - **doc**: reduce header nesting in async\_hooks.md (Rich Trott) [#37839](https://github.com/nodejs/node/pull/37839)
+* [[`7789159009`](https://github.com/nodejs/node/commit/7789159009)] - **doc**: add examples for WHATWG URL objects (James M Snell) [#37822](https://github.com/nodejs/node/pull/37822)
+* [[`b31bb72c10`](https://github.com/nodejs/node/commit/b31bb72c10)] - **doc**: clarify when child process 'spawn' event is \*not\* emitted (Matthew Francis Brunetti) [#37833](https://github.com/nodejs/node/pull/37833)
+* [[`9166653aef`](https://github.com/nodejs/node/commit/9166653aef)] - **doc**: fix legacy stability indicator display (Rich Trott) [#37838](https://github.com/nodejs/node/pull/37838)
+* [[`2e0266de5b`](https://github.com/nodejs/node/commit/2e0266de5b)] - **doc**: use sentence-style capitlaztion in template header (Rich Trott) [#37837](https://github.com/nodejs/node/pull/37837)
+* [[`1b83242772`](https://github.com/nodejs/node/commit/1b83242772)] - **doc**: add Ayase-252 to triagers (Qingyu Deng) [#37781](https://github.com/nodejs/node/pull/37781)
+* [[`89418e8758`](https://github.com/nodejs/node/commit/89418e8758)] - **doc**: use sentence case in issues.md headers (marsonya) [#37537](https://github.com/nodejs/node/pull/37537)
+* [[`66502fc186`](https://github.com/nodejs/node/commit/66502fc186)] - **doc**: move Derek Lewis back to collaborators (Derek Lewis) [#37726](https://github.com/nodejs/node/pull/37726)
+* [[`0d720a4a5c`](https://github.com/nodejs/node/commit/0d720a4a5c)] - **doc**: apply style for legacy status (James M Snell) [#37784](https://github.com/nodejs/node/pull/37784)
+* [[`c8383dd99f`](https://github.com/nodejs/node/commit/c8383dd99f)] - **doc**: revoke deprecation of legacy url, change status to legacy (James M Snell) [#37784](https://github.com/nodejs/node/pull/37784)
+* [[`e34aace62b`](https://github.com/nodejs/node/commit/e34aace62b)] - **doc**: add legacy status to stability index (James M Snell) [#37784](https://github.com/nodejs/node/pull/37784)
+* [[`b2d3ac835c`](https://github.com/nodejs/node/commit/b2d3ac835c)] - **doc**: add @linkgoron to collaborators (Nitzan Uziely) [#37817](https://github.com/nodejs/node/pull/37817)
+* [[`a27534e883`](https://github.com/nodejs/node/commit/a27534e883)] - **doc**: fix AbortError example for timers (dbachko) [#37738](https://github.com/nodejs/node/pull/37738)
+* [[`14a160ae04`](https://github.com/nodejs/node/commit/14a160ae04)] - **doc**: fix typo in stream docs (Ian Kerins) [#37716](https://github.com/nodejs/node/pull/37716)
+* [[`fe0f6a53a6`](https://github.com/nodejs/node/commit/fe0f6a53a6)] - **doc**: add gyp maintain info (Jiawen Geng) [#37765](https://github.com/nodejs/node/pull/37765)
+* [[`6d7c7bc8d9`](https://github.com/nodejs/node/commit/6d7c7bc8d9)] - **doc**: add marsonya as a triager (marsonya) [#37667](https://github.com/nodejs/node/pull/37667)
+* [[`5f2da5af42`](https://github.com/nodejs/node/commit/5f2da5af42)] - **doc**: add hints to http.request() options (Luigi Pinca) [#37745](https://github.com/nodejs/node/pull/37745)
+* [[`02cd4044da`](https://github.com/nodejs/node/commit/02cd4044da)] - **doc**: fix link to googletest fixtures (Tobias Nießen) [#37698](https://github.com/nodejs/node/pull/37698)
+* [[`85a293bdfc`](https://github.com/nodejs/node/commit/85a293bdfc)] - **doc**: fix typo in description of close event (Tobias Nießen) [#37662](https://github.com/nodejs/node/pull/37662)
+* [[`3a6e40530c`](https://github.com/nodejs/node/commit/3a6e40530c)] - **doc**: use sentence case in README.md headers (marsonya) [#37645](https://github.com/nodejs/node/pull/37645)
+* [[`c51a60cd05`](https://github.com/nodejs/node/commit/c51a60cd05)] - **doc**: add localPort to http.request() options (Luigi Pinca) [#37586](https://github.com/nodejs/node/pull/37586)
+* [[`b0840ac680`](https://github.com/nodejs/node/commit/b0840ac680)] - **doc**: fix typo in doc/guides/collaborator-guide.md (marsonya) [#37643](https://github.com/nodejs/node/pull/37643)
+* [[`5ef2a8de25`](https://github.com/nodejs/node/commit/5ef2a8de25)] - **doc**: document that module.evaluate fulfills as undefined (James M Snell) [#37663](https://github.com/nodejs/node/pull/37663)
+* [[`b192227a95`](https://github.com/nodejs/node/commit/b192227a95)] - **doc**: add return type of readline.createInterface (Darshan Sen) [#37600](https://github.com/nodejs/node/pull/37600)
+* [[`68d5cb80de`](https://github.com/nodejs/node/commit/68d5cb80de)] - **doc**: apply sentence case to headers in pull-requests.md (marsonya) [#37602](https://github.com/nodejs/node/pull/37602)
+* [[`183dba0dd8`](https://github.com/nodejs/node/commit/183dba0dd8)] - **doc**: add top-level await syntax in vm.md (Antoine du Hamel) [#37077](https://github.com/nodejs/node/pull/37077)
+* [[`1dc7f426aa`](https://github.com/nodejs/node/commit/1dc7f426aa)] - **doc**: clarify that columnOffset applies only to the first line (James M Snell) [#37563](https://github.com/nodejs/node/pull/37563)
+* [[`c21731b39f`](https://github.com/nodejs/node/commit/c21731b39f)] - **doc**: document that NODE\_EXTRA\_CA\_CERTS is read only once (James M Snell) [#37562](https://github.com/nodejs/node/pull/37562)
+* [[`0255ed7e8e`](https://github.com/nodejs/node/commit/0255ed7e8e)] - **doc**: fix typo in doc/api/packages.md (marsonya) [#37536](https://github.com/nodejs/node/pull/37536)
+* [[`52c0f0bf0f`](https://github.com/nodejs/node/commit/52c0f0bf0f)] - **doc**: revise LTS text in collaborator guide (Rich Trott) [#37527](https://github.com/nodejs/node/pull/37527)
+* [[`fdc6a96d49`](https://github.com/nodejs/node/commit/fdc6a96d49)] - **doc**: revise CI text in collaborator guide (Rich Trott) [#37526](https://github.com/nodejs/node/pull/37526)
+* [[`c62a1345bb`](https://github.com/nodejs/node/commit/c62a1345bb)] - **doc**: revise objections section of collaborator guide (Rich Trott) [#37525](https://github.com/nodejs/node/pull/37525)
+* [[`adc75368ba`](https://github.com/nodejs/node/commit/adc75368ba)] - **doc**: revise premature disclosure text in collaborator guide (Rich Trott) [#37524](https://github.com/nodejs/node/pull/37524)
+* [[`1b851461b1`](https://github.com/nodejs/node/commit/1b851461b1)] - **doc**: change links to use HEAD in top level docs (Michael Dawson) [#37494](https://github.com/nodejs/node/pull/37494)
+* [[`64ed65ecc4`](https://github.com/nodejs/node/commit/64ed65ecc4)] - **doc**: apply sentence case to headers in doc/guides (marsonya) [#37506](https://github.com/nodejs/node/pull/37506)
+* [[`ff1990c409`](https://github.com/nodejs/node/commit/ff1990c409)] - **doc**: add url.resolve replacement example (Antoine du Hamel) [#37501](https://github.com/nodejs/node/pull/37501)
+* [[`52b3b54c14`](https://github.com/nodejs/node/commit/52b3b54c14)] - **doc**: apply sentence case to guides headers (marsonya) [#37497](https://github.com/nodejs/node/pull/37497)
+* [[`da2cd4a48a`](https://github.com/nodejs/node/commit/da2cd4a48a)] - **doc**: update CI requirements for landing pull requests (Antoine du Hamel) [#37308](https://github.com/nodejs/node/pull/37308)
+* [[`2082f5bd68`](https://github.com/nodejs/node/commit/2082f5bd68)] - **doc**: recommend queueMicrotask over process.nextTick (James M Snell) [#37484](https://github.com/nodejs/node/pull/37484)
+* [[`099eef6a84`](https://github.com/nodejs/node/commit/099eef6a84)] - **doc**: apply sentence case to headers in doc/guides (marsonya) [#37478](https://github.com/nodejs/node/pull/37478)
+* [[`a0bab6915e`](https://github.com/nodejs/node/commit/a0bab6915e)] - **doc**: fix typo in doc/api/http2/md (marsonya) [#37479](https://github.com/nodejs/node/pull/37479)
+* [[`3e82263877`](https://github.com/nodejs/node/commit/3e82263877)] - **doc**: alphabetize vm Module class properties (Rich Trott) [#37451](https://github.com/nodejs/node/pull/37451)
+* [[`e6f804b0af`](https://github.com/nodejs/node/commit/e6f804b0af)] - **doc**: alphabetize crypto Cipher class entries (Rich Trott) [#37450](https://github.com/nodejs/node/pull/37450)
+* [[`bb434a983c`](https://github.com/nodejs/node/commit/bb434a983c)] - **doc**: use HEAD for links in api docs (Michael Dawson) [#37437](https://github.com/nodejs/node/pull/37437)
+* [[`39ef3bd155`](https://github.com/nodejs/node/commit/39ef3bd155)] - **doc**: fix alignment of parameters (Michael Dawson) [#37422](https://github.com/nodejs/node/pull/37422)
+* [[`8b60e66982`](https://github.com/nodejs/node/commit/8b60e66982)] - **doc**: fix typo in doc/api/esm.md (marsonya) [#37400](https://github.com/nodejs/node/pull/37400)
+* [[`605cb4cd4c`](https://github.com/nodejs/node/commit/605cb4cd4c)] - **doc**: fix typo in esm.md (Jay Tailor) [#37417](https://github.com/nodejs/node/pull/37417)
+* [[`74f0760a9b`](https://github.com/nodejs/node/commit/74f0760a9b)] - **doc**: use HEAD in links where possible (Michael Dawson) [#37421](https://github.com/nodejs/node/pull/37421)
+* [[`4785755014`](https://github.com/nodejs/node/commit/4785755014)] - **doc**: clarify that async\_hook callbacks cannot be async (James M Snell) [#37384](https://github.com/nodejs/node/pull/37384)
+* [[`07130c038f`](https://github.com/nodejs/node/commit/07130c038f)] - **doc**: add dmabupt to collaborators (Xu Meng) [#37377](https://github.com/nodejs/node/pull/37377)
+* [[`2a3feff2f0`](https://github.com/nodejs/node/commit/2a3feff2f0)] - **doc**: optimize HTML rendering (Antoine du Hamel) [#37301](https://github.com/nodejs/node/pull/37301)
+* [[`8b5e42e031`](https://github.com/nodejs/node/commit/8b5e42e031)] - **doc**: fix quotes in stream docs (Tobias Nießen) [#37269](https://github.com/nodejs/node/pull/37269)
+* [[`d426143f54`](https://github.com/nodejs/node/commit/d426143f54)] - **doc**: link PACKAGE\_EXPORTS\_RESOLVE to ESM section (Utku Gultopu) [#37135](https://github.com/nodejs/node/pull/37135)
+* [[`debffd9b41`](https://github.com/nodejs/node/commit/debffd9b41)] - **doc**: use sentence case in benchmark doc (Rich Trott) [#37351](https://github.com/nodejs/node/pull/37351)
+* [[`f28a5c6e1e`](https://github.com/nodejs/node/commit/f28a5c6e1e)] - **doc**: apply sentence-consistently in C++ style guide (Rich Trott) [#37350](https://github.com/nodejs/node/pull/37350)
+* [[`569ad98b9a`](https://github.com/nodejs/node/commit/569ad98b9a)] - **doc**: apply sentence case to release doc headers (Rich Trott) [#37349](https://github.com/nodejs/node/pull/37349)
+* [[`7cf4a4b2b8`](https://github.com/nodejs/node/commit/7cf4a4b2b8)] - **doc**: fix performanceEntry.flags style format (Cheng Liu) [#37274](https://github.com/nodejs/node/pull/37274)
+* [[`5ade2fd207`](https://github.com/nodejs/node/commit/5ade2fd207)] - **doc**: fix typo in deprecations.md (marsonya) [#37282](https://github.com/nodejs/node/pull/37282)
+* [[`5bc0a0d9f7`](https://github.com/nodejs/node/commit/5bc0a0d9f7)] - **doc**: add version metadata for packages features (Antoine du Hamel) [#37289](https://github.com/nodejs/node/pull/37289)
+* [[`b485a3e2d2`](https://github.com/nodejs/node/commit/b485a3e2d2)] - **doc**: fix typo in /api/dns.md (marsonya) [#37312](https://github.com/nodejs/node/pull/37312)
+* [[`a99456ce69`](https://github.com/nodejs/node/commit/a99456ce69)] - **doc**: fix description of hasSubscribers (Tobias Nießen) [#37324](https://github.com/nodejs/node/pull/37324)
+* [[`b7c9366979`](https://github.com/nodejs/node/commit/b7c9366979)] - **doc**: discourage error event (Benjamin Gruenbaum) [#37264](https://github.com/nodejs/node/pull/37264)
+* [[`8c41bc953e`](https://github.com/nodejs/node/commit/8c41bc953e)] - **doc**: fix misnamed SHASUMS256.txt name in README.md (marsonya) [#37260](https://github.com/nodejs/node/pull/37260)
+* [[`b2ee1afb2e`](https://github.com/nodejs/node/commit/b2ee1afb2e)] - **doc**: fix typo in console.md (marsonya) [#37279](https://github.com/nodejs/node/pull/37279)
+* [[`281d75cebb`](https://github.com/nodejs/node/commit/281d75cebb)] - **doc**: use sentence case in README headers (Rich Trott) [#37251](https://github.com/nodejs/node/pull/37251)
+* [[`8cffab6571`](https://github.com/nodejs/node/commit/8cffab6571)] - **doc**: use sentence case for headers in BUILDING.md (Rich Trott) [#37250](https://github.com/nodejs/node/pull/37250)
+* [[`0eaeaea454`](https://github.com/nodejs/node/commit/0eaeaea454)] - **doc**: rename N-API to Node-API (Gabriel Schulhof) [#37259](https://github.com/nodejs/node/pull/37259)
+* [[`cb632e4040`](https://github.com/nodejs/node/commit/cb632e4040)] - **doc**: fix version number for DEP006 (Antoine du Hamel) [#37231](https://github.com/nodejs/node/pull/37231)
+* [[`e7415c374b`](https://github.com/nodejs/node/commit/e7415c374b)] - **doc**: fix CHANGELOG\_ARCHIVE table of contents (Antoine du Hamel) [#37232](https://github.com/nodejs/node/pull/37232)
+* [[`2959c65632`](https://github.com/nodejs/node/commit/2959c65632)] - **doc**: fix typo in globals.md (Darshan Sen) [#37228](https://github.com/nodejs/node/pull/37228)
+* [[`ad80e3de1e`](https://github.com/nodejs/node/commit/ad80e3de1e)] - **doc**: fix 404 links in module.md (Antoine du Hamel) [#37202](https://github.com/nodejs/node/pull/37202)
+* [[`e7ca9b6d71`](https://github.com/nodejs/node/commit/e7ca9b6d71)] - **doc**: fix color contrast on \<kbd\> elements (Antoine du Hamel) [#37185](https://github.com/nodejs/node/pull/37185)
+* [[`11d3e71f80`](https://github.com/nodejs/node/commit/11d3e71f80)] - **doc**: improve promise terminology (Benjamin Gruenbaum) [#37181](https://github.com/nodejs/node/pull/37181)
+* [[`35cf86c83b`](https://github.com/nodejs/node/commit/35cf86c83b)] - **doc**: fix list format in Developer's Certificate of Origin (Akash Negi) [#37138](https://github.com/nodejs/node/pull/37138)
+* [[`6264ac187a`](https://github.com/nodejs/node/commit/6264ac187a)] - **doc**: clarify ERR\_INVALID\_REPL\_INPUT usage (Rich Trott) [#37143](https://github.com/nodejs/node/pull/37143)
+* [[`d340dca940`](https://github.com/nodejs/node/commit/d340dca940)] - **doc**: clarify repl exception conditions (Rich Trott) [#37142](https://github.com/nodejs/node/pull/37142)
+* [[`26ec20a9b6`](https://github.com/nodejs/node/commit/26ec20a9b6)] - **doc**: add example for test structure (Turner Jabbour) [#35046](https://github.com/nodejs/node/pull/35046)
+* [[`8099bfb35c`](https://github.com/nodejs/node/commit/8099bfb35c)] - **doc**: remove TOC summary for pages with no TOC (Rich Trott) [#37043](https://github.com/nodejs/node/pull/37043)
+* [[`b0c9b1fdfb`](https://github.com/nodejs/node/commit/b0c9b1fdfb)] - **doc**: update Buffer encoding option count (Dave Cardwell) [#37102](https://github.com/nodejs/node/pull/37102)
+* [[`af313a8495`](https://github.com/nodejs/node/commit/af313a8495)] - **doc**: update BUILDING.md previous versions links (Richard Lau) [#37082](https://github.com/nodejs/node/pull/37082)
+* [[`b353549f7c`](https://github.com/nodejs/node/commit/b353549f7c)] - **doc**: mention adding Fixes to collaborator onboarding PR (Joyee Cheung) [#37097](https://github.com/nodejs/node/pull/37097)
+* [[`8ed0c17bee`](https://github.com/nodejs/node/commit/8ed0c17bee)] - **doc**: add Zijian Liu to collaborators (ZiJian Liu) [#37075](https://github.com/nodejs/node/pull/37075)
+* [[`87fcda8d3e`](https://github.com/nodejs/node/commit/87fcda8d3e)] - **doc**: add tooltip for light/dark mode toggle (Rich Trott) [#37044](https://github.com/nodejs/node/pull/37044)
+* [[`49f13743e5`](https://github.com/nodejs/node/commit/49f13743e5)] - **doc**: improve AsyncLocalStorage introduction (Romuald Brillout) [#36946](https://github.com/nodejs/node/pull/36946)
+* [[`b8080134a2`](https://github.com/nodejs/node/commit/b8080134a2)] - **doc**: add missing comma in tty (Matthew Mario Di Pasquale) [#37039](https://github.com/nodejs/node/pull/37039)
+* [[`1e2beeea99`](https://github.com/nodejs/node/commit/1e2beeea99)] - **doc**: list Unsupported Directory Import resolve err (Guy Bedford) [#37032](https://github.com/nodejs/node/pull/37032)
+* [[`fb4eee132e`](https://github.com/nodejs/node/commit/fb4eee132e)] - **doc**: add missing ARIA label for button (Rich Trott) [#37031](https://github.com/nodejs/node/pull/37031)
+* [[`f260f4a12f`](https://github.com/nodejs/node/commit/f260f4a12f)] - **doc**: add @RaisinTen to collaborators (Darshan Sen) [#36998](https://github.com/nodejs/node/pull/36998)
+* [[`00075986f0`](https://github.com/nodejs/node/commit/00075986f0)] - **doc**: fix typo in http.server.requestTimout docs (alexbs) [#36987](https://github.com/nodejs/node/pull/36987)
+* [[`b25b69418a`](https://github.com/nodejs/node/commit/b25b69418a)] - **doc**: add performance notes for fs.readFile (James M Snell) [#36880](https://github.com/nodejs/node/pull/36880)
+* [[`385d0df02d`](https://github.com/nodejs/node/commit/385d0df02d)] - **doc**: clarify maxSockets option of http.Agent (Pooja D P) [#36941](https://github.com/nodejs/node/pull/36941)
+* [[`792bea4e78`](https://github.com/nodejs/node/commit/792bea4e78)] - **doc**: remove pull-requests.md preamble (Rich Trott) [#36960](https://github.com/nodejs/node/pull/36960)
+* [[`d43492ee42`](https://github.com/nodejs/node/commit/d43492ee42)] - **doc**: fix percentile range in perf\_hooks.md (raisinten) [#36938](https://github.com/nodejs/node/pull/36938)
+* [[`f39ee90c94`](https://github.com/nodejs/node/commit/f39ee90c94)] - **doc**: improve perf\_hooks docs (Juan José Arboleda) [#36909](https://github.com/nodejs/node/pull/36909)
+* [[`e990b11672`](https://github.com/nodejs/node/commit/e990b11672)] - **doc**: fix invalid HTML in doc template (Rich Trott) [#36930](https://github.com/nodejs/node/pull/36930)
+* [[`e1c62dd977`](https://github.com/nodejs/node/commit/e1c62dd977)] - **doc**: remove issue template duplication from contributing docs (Rich Trott) [#36908](https://github.com/nodejs/node/pull/36908)
+* [[`3c70f6842d`](https://github.com/nodejs/node/commit/3c70f6842d)] - **doc**: remove resolving-a-bug-report from contributing docs (Rich Trott) [#36905](https://github.com/nodejs/node/pull/36905)
+* [[`308d361a79`](https://github.com/nodejs/node/commit/308d361a79)] - **doc**: use ESM syntax for WASI example (Antoine du Hamel) [#36848](https://github.com/nodejs/node/pull/36848)
+* [[`189fae8618`](https://github.com/nodejs/node/commit/189fae8618)] - **doc**: add iansu to collaborators (Ian Sutherland) [#36951](https://github.com/nodejs/node/pull/36951)
+* [[`28c80b514f`](https://github.com/nodejs/node/commit/28c80b514f)] - **doc**: add alternative version links to the packages page (Filip Skokan) [#36915](https://github.com/nodejs/node/pull/36915)
+* [[`ed5bb7673f`](https://github.com/nodejs/node/commit/ed5bb7673f)] - **doc**: add miladfarca to collaborators (Milad Fa) [#36934](https://github.com/nodejs/node/pull/36934)
+* [[`580b647ee4`](https://github.com/nodejs/node/commit/580b647ee4)] - **doc**: update tls test to use better terminology (Michael Dawson) [#36851](https://github.com/nodejs/node/pull/36851)
+* [[`fa82cbc4f7`](https://github.com/nodejs/node/commit/fa82cbc4f7)] - **doc**: remove unnecessary contributing.md section (Rich Trott) [#36891](https://github.com/nodejs/node/pull/36891)
+* [[`583b2192d9`](https://github.com/nodejs/node/commit/583b2192d9)] - **doc**: wrap TOC in a \<details\> tag (Mattia Pontonio) [#36896](https://github.com/nodejs/node/pull/36896)
+* [[`9a3cfa7069`](https://github.com/nodejs/node/commit/9a3cfa7069)] - **doc**: fix indentation on http2 doc entry (Rich Trott) [#36869](https://github.com/nodejs/node/pull/36869)
+* [[`7fbbdb831a`](https://github.com/nodejs/node/commit/7fbbdb831a)] - **doc**: define "browser", "production", "development" (Guy Bedford) [#36856](https://github.com/nodejs/node/pull/36856)
+* [[`5770ae057e`](https://github.com/nodejs/node/commit/5770ae057e)] - **doc**: fix module syncBuiltinESMExports example (Bruce A. MacNaughton) [#34284](https://github.com/nodejs/node/pull/34284)
+* [[`099d776e29`](https://github.com/nodejs/node/commit/099d776e29)] - **doc**: update release key for Danielle Adams (Danielle Adams) [#36793](https://github.com/nodejs/node/pull/36793)
+* [[`57e27a3824`](https://github.com/nodejs/node/commit/57e27a3824)] - **doc**: clarify child\_process.exec inherits cwd (ugultopu) [#36809](https://github.com/nodejs/node/pull/36809)
+* [[`f605bc00ae`](https://github.com/nodejs/node/commit/f605bc00ae)] - **doc**: clarify descriptions of \_writev chunks argument (James M Snell) [#36822](https://github.com/nodejs/node/pull/36822)
+* [[`cf0fa7fa2f`](https://github.com/nodejs/node/commit/cf0fa7fa2f)] - **doc**: document buffer's "Uint" aliases clearly (Michaël Zasso) [#36796](https://github.com/nodejs/node/pull/36796)
+* [[`5f36ff80b9`](https://github.com/nodejs/node/commit/5f36ff80b9)] - **doc**: add dnlup to collaborators (Daniele Belardi) [#36849](https://github.com/nodejs/node/pull/36849)
+* [[`c1ea23c55d`](https://github.com/nodejs/node/commit/c1ea23c55d)] - **doc**: clarify subprocess.stdout/in/err/io properties (James M Snell) [#36784](https://github.com/nodejs/node/pull/36784)
+* [[`19e61206f2`](https://github.com/nodejs/node/commit/19e61206f2)] - **doc**: add dark mode (Ajay Poshak) [#36313](https://github.com/nodejs/node/pull/36313)
+* [[`8620458966`](https://github.com/nodejs/node/commit/8620458966)] - **doc**: revise method text in async\_hooks.md (Rich Trott) [#36736](https://github.com/nodejs/node/pull/36736)
+* [[`a800b5b698`](https://github.com/nodejs/node/commit/a800b5b698)] - **doc**: clarify when messageerror is emitted (James M Snell) [#36780](https://github.com/nodejs/node/pull/36780)
+* [[`e973bdc14e`](https://github.com/nodejs/node/commit/e973bdc14e)] - **doc**: avoid memory leak warning in async\_hooks example (James M Snell) [#36783](https://github.com/nodejs/node/pull/36783)
+* [[`1521a59002`](https://github.com/nodejs/node/commit/1521a59002)] - **doc**: clarify that --require only supports cjs (James M Snell) [#36806](https://github.com/nodejs/node/pull/36806)
+* [[`dc15608661`](https://github.com/nodejs/node/commit/dc15608661)] - **doc**: clarify Buffer.from when using ArrayBuffer (James M Snell) [#36785](https://github.com/nodejs/node/pull/36785)
+* [[`67a6e9c516`](https://github.com/nodejs/node/commit/67a6e9c516)] - **doc**: fix broken link for ChildProcess (James M Snell) [#36788](https://github.com/nodejs/node/pull/36788)
+* [[`31039dbf63`](https://github.com/nodejs/node/commit/31039dbf63)] - **doc**: revise exit() and run() text in async\_hooks.md (Rich Trott) [#36738](https://github.com/nodejs/node/pull/36738)
+* [[`844a15622f`](https://github.com/nodejs/node/commit/844a15622f)] - **doc**: clarify that N-API addons are context-aware (Alba Mendez) [#36640](https://github.com/nodejs/node/pull/36640)
+* [[`8f48e77217`](https://github.com/nodejs/node/commit/8f48e77217)] - **doc**: fix typo in esm documentation (Mohamed Kamagate) [#36800](https://github.com/nodejs/node/pull/36800)
+* [[`095c69dce3`](https://github.com/nodejs/node/commit/095c69dce3)] - **doc**: add panva to collaborators (Filip Skokan) [#36802](https://github.com/nodejs/node/pull/36802)
+* [[`8bda9f4dce`](https://github.com/nodejs/node/commit/8bda9f4dce)] - **doc**: reduce abbreviations in async\_hooks.md (Rich Trott) [#36737](https://github.com/nodejs/node/pull/36737)
+* [[`1a65b442f0`](https://github.com/nodejs/node/commit/1a65b442f0)] - **doc**: simplify pull request template (Rich Trott) [#36739](https://github.com/nodejs/node/pull/36739)
+* [[`71b94e1ff7`](https://github.com/nodejs/node/commit/71b94e1ff7)] - **doc**: clarify undocumented stream properties (James M Snell) [#36715](https://github.com/nodejs/node/pull/36715)
+* [[`bcca52c11a`](https://github.com/nodejs/node/commit/bcca52c11a)] - **doc**: document common warning types (James M Snell) [#36713](https://github.com/nodejs/node/pull/36713)
+* [[`97faeeb115`](https://github.com/nodejs/node/commit/97faeeb115)] - **doc**: improve ALS.enterWith and exit descriptions (Andrey Pechkurov) [#36705](https://github.com/nodejs/node/pull/36705)
+* [[`535bbc294a`](https://github.com/nodejs/node/commit/535bbc294a)] - **doc**: add yashLadha to collaborator (Yash Ladha) [#36666](https://github.com/nodejs/node/pull/36666)
+* [[`6293aea1d1`](https://github.com/nodejs/node/commit/6293aea1d1)] - **doc**: alphabetize http response properties (Rich Trott) [#36631](https://github.com/nodejs/node/pull/36631)
+* [[`afb9534d65`](https://github.com/nodejs/node/commit/afb9534d65)] - **doc**: correct callback parameter type for createPushResponse() (Rich Trott) [#36631](https://github.com/nodejs/node/pull/36631)
+* [[`f65b842ee1`](https://github.com/nodejs/node/commit/f65b842ee1)] - **doc**: use \_code name\_ rather than \_codename\_ (Rich Trott) [#36611](https://github.com/nodejs/node/pull/36611)
+* [[`12dc0e6a28`](https://github.com/nodejs/node/commit/12dc0e6a28)] - **doc**: document return value of https.request (Michael Chen) [#36370](https://github.com/nodejs/node/pull/36370)
+* [[`317a1d7a0d`](https://github.com/nodejs/node/commit/317a1d7a0d)] - **doc**: remove replication of GitHub template (Rich Trott) [#36590](https://github.com/nodejs/node/pull/36590)
+* [[`653492f2d4`](https://github.com/nodejs/node/commit/653492f2d4)] - **doc**: remove "Related Issues" from pull request template (Rich Trott) [#36590](https://github.com/nodejs/node/pull/36590)
+* [[`b57785d89b`](https://github.com/nodejs/node/commit/b57785d89b)] - **doc**: update and run license-builder for Babel (Michaël Zasso) [#36504](https://github.com/nodejs/node/pull/36504)
+* [[`e3c2d112eb`](https://github.com/nodejs/node/commit/e3c2d112eb)] - **doc**: add remark about Collaborators discussion page (FrankQiu) [#36420](https://github.com/nodejs/node/pull/36420)
+* [[`8b349187b8`](https://github.com/nodejs/node/commit/8b349187b8)] - **doc**: add two tips for speeding the dev builds (Momtchil Momtchev) [#36452](https://github.com/nodejs/node/pull/36452)
+* [[`6198d74cd3`](https://github.com/nodejs/node/commit/6198d74cd3)] - **doc**: add note about timingSafeEqual for TypedArray (Tobias Nießen) [#36323](https://github.com/nodejs/node/pull/36323)
+* [[`d27028040e`](https://github.com/nodejs/node/commit/d27028040e)] - **doc**: move Derek Lewis to emeritus (Rich Trott) [#36514](https://github.com/nodejs/node/pull/36514)
+* [[`cf9d476948`](https://github.com/nodejs/node/commit/cf9d476948)] - **doc**: add issue reference to github pr template (Chinmoy Chakraborty) [#36440](https://github.com/nodejs/node/pull/36440)
+* [[`760e593968`](https://github.com/nodejs/node/commit/760e593968)] - **doc**: update url.md (Rock) [#36147](https://github.com/nodejs/node/pull/36147)
+* [[`c32c109450`](https://github.com/nodejs/node/commit/c32c109450)] - **doc**: make explicit reverting node\_version.h changes (Richard Lau) [#36461](https://github.com/nodejs/node/pull/36461)
+* [[`647ec70419`](https://github.com/nodejs/node/commit/647ec70419)] - **doc**: add license info to the README (FrankQiu) [#36278](https://github.com/nodejs/node/pull/36278)
+* [[`2ec839d974`](https://github.com/nodejs/node/commit/2ec839d974)] - **doc**: revise addon mulitple initializations text (Rich Trott) [#36457](https://github.com/nodejs/node/pull/36457)
+* [[`050b52f16b`](https://github.com/nodejs/node/commit/050b52f16b)] - **doc**: add PoojaDurgad to collaborators (Pooja D P) [#36511](https://github.com/nodejs/node/pull/36511)
+* [[`681d2a7176`](https://github.com/nodejs/node/commit/681d2a7176)] - **doc**: edit addon text about event loop blocking (Rich Trott) [#36448](https://github.com/nodejs/node/pull/36448)
+* [[`afad5e6be6`](https://github.com/nodejs/node/commit/afad5e6be6)] - **doc**: update terminology (Michael Dawson) [#36475](https://github.com/nodejs/node/pull/36475)
+* [[`615a0aaf86`](https://github.com/nodejs/node/commit/615a0aaf86)] - **doc**: reword POSIX threads text in addons.md (Rich Trott) [#36436](https://github.com/nodejs/node/pull/36436)
+* [[`94d41f22f0`](https://github.com/nodejs/node/commit/94d41f22f0)] - **doc**: add RaisinTen as a triager (raisinten) [#36404](https://github.com/nodejs/node/pull/36404)
+* [[`cd065210a5`](https://github.com/nodejs/node/commit/cd065210a5)] - **doc**: provide more context on techinical values (Michael Dawson) [#36201](https://github.com/nodejs/node/pull/36201)
+* [[`f515156fab`](https://github.com/nodejs/node/commit/f515156fab)] - **doc**: add Powershell oneliner to get Windows version (Michael Bashurov) [#30289](https://github.com/nodejs/node/pull/30289)
+* [[`280d1b09be`](https://github.com/nodejs/node/commit/280d1b09be)] - **doc**: add process for handling premature disclosure (Michael Dawson) [#36155](https://github.com/nodejs/node/pull/36155)
+* [[`9269352e45`](https://github.com/nodejs/node/commit/9269352e45)] - **doc**: add table header in intl.md (Rich Trott) [#36261](https://github.com/nodejs/node/pull/36261)
+* [[`6201f23e12`](https://github.com/nodejs/node/commit/6201f23e12)] - **doc**: adding example to Buffer.isBuffer method (naortedgi) [#36233](https://github.com/nodejs/node/pull/36233)
+* [[`1d78d50127`](https://github.com/nodejs/node/commit/1d78d50127)] - **doc**: fix typo in events.md (Luigi Pinca) [#36231](https://github.com/nodejs/node/pull/36231)
+* [[`9b32c9c575`](https://github.com/nodejs/node/commit/9b32c9c575)] - **doc**: fix --experimental-wasm-modules text location (Colin Ihrig) [#36220](https://github.com/nodejs/node/pull/36220)
+* [[`28149cff23`](https://github.com/nodejs/node/commit/28149cff23)] - **doc**: add missing version to update cmd (Ruy Adorno) [#36204](https://github.com/nodejs/node/pull/36204)
+* [[`2d6494775b`](https://github.com/nodejs/node/commit/2d6494775b)] - **doc**: fix invalid link in worker\_threads.md (Rich Trott) [#36109](https://github.com/nodejs/node/pull/36109)
+* [[`ec140d7160`](https://github.com/nodejs/node/commit/ec140d7160)] - **doc**: fix `events.getEventListeners` example (Dmitry Semigradsky) [#36085](https://github.com/nodejs/node/pull/36085)
+* [[`34d8a64c56`](https://github.com/nodejs/node/commit/34d8a64c56)] - **doc**: fix incorrect heading level (Bryan Field) [#35965](https://github.com/nodejs/node/pull/35965)
+* [[`d9d7ebd0b4`](https://github.com/nodejs/node/commit/d9d7ebd0b4)] - **doc**: make globals Extends usage consistent (Colin Ihrig) [#33777](https://github.com/nodejs/node/pull/33777)
+* [[`2f7afd11a4`](https://github.com/nodejs/node/commit/2f7afd11a4)] - **doc**: make perf\_hooks Extends usage consistent (Colin Ihrig) [#33777](https://github.com/nodejs/node/pull/33777)
+* [[`810b1d0cbb`](https://github.com/nodejs/node/commit/810b1d0cbb)] - **doc**: make events Extends usage consistent (Colin Ihrig) [#33777](https://github.com/nodejs/node/pull/33777)
+* [[`cf4fa79f17`](https://github.com/nodejs/node/commit/cf4fa79f17)] - **doc**: recommend checking abortSignal.aborted first (James M Snell) [#37714](https://github.com/nodejs/node/pull/37714)
+* [[`e93615c5e3`](https://github.com/nodejs/node/commit/e93615c5e3)] - **doc**: make AbortSignal text consistent in events.md (Rich Trott) [#35005](https://github.com/nodejs/node/pull/35005)
+* [[`1a362d8d4b`](https://github.com/nodejs/node/commit/1a362d8d4b)] - **doc**: revise AbortSignal text and example using events.once() (Rich Trott) [#35005](https://github.com/nodejs/node/pull/35005)
+* [[`a7da993cff`](https://github.com/nodejs/node/commit/a7da993cff)] - **doc**: stabilize packages features (Myles Borins) [#35742](https://github.com/nodejs/node/pull/35742)
+* [[`b133034735`](https://github.com/nodejs/node/commit/b133034735)] - **doc**: stabilize subpath patterns (Guy Bedford) [#36177](https://github.com/nodejs/node/pull/36177)
+* [[`5a3e12b1ee`](https://github.com/nodejs/node/commit/5a3e12b1ee)] - **doc**: update fs.l/statSync API history for throwIfNoEntry (Andrew Casey) [#36882](https://github.com/nodejs/node/pull/36882)
+* [[`7c9f3a9d0c`](https://github.com/nodejs/node/commit/7c9f3a9d0c)] - **doc**: fix module.isPreloading documentation (Antoine du Hamel) [#36944](https://github.com/nodejs/node/pull/36944)
+* [[`c1af59384d`](https://github.com/nodejs/node/commit/c1af59384d)] - **doc**: mark modules implementation as stable (Guy Bedford) [#35781](https://github.com/nodejs/node/pull/35781)
+* [[`9930b6b825`](https://github.com/nodejs/node/commit/9930b6b825)] - **doc**: update `buffer.constants.MAX\_LENGTH` (Qingyu Deng) [#38109](https://github.com/nodejs/node/pull/38109)
+* [[`c975a8ded1`](https://github.com/nodejs/node/commit/c975a8ded1)] - **doc**: fix maintaining ICU guide (Michaël Zasso) [#36980](https://github.com/nodejs/node/pull/36980)
+* [[`d1004d26e4`](https://github.com/nodejs/node/commit/d1004d26e4)] - **doc**: fix typo in BUILDING.md (raisinten) [#35807](https://github.com/nodejs/node/pull/35807)
+* [[`f41c28cf4b`](https://github.com/nodejs/node/commit/f41c28cf4b)] - **doc**: fix YAML lint error on master (Rich Trott) [#35709](https://github.com/nodejs/node/pull/35709)
+* [[`4a768bc13b`](https://github.com/nodejs/node/commit/4a768bc13b)] - **doc**: upgrade stability status of report API (Gireesh Punathil) [#35654](https://github.com/nodejs/node/pull/35654)
+* [[`a3c564bead`](https://github.com/nodejs/node/commit/a3c564bead)] - **doc,child_process**: `pid` can be `undefined` when `ENOENT` (dr-js) [#37014](https://github.com/nodejs/node/pull/37014)
+* [[`404327563a`](https://github.com/nodejs/node/commit/404327563a)] - **doc,tools**: allow stability table to be updated (Richard Lau) [#38048](https://github.com/nodejs/node/pull/38048)
+* [[`eb6ea8501b`](https://github.com/nodejs/node/commit/eb6ea8501b)] - **doc,tools**: use only one level 1 header per page (Rich Trott) [#37839](https://github.com/nodejs/node/pull/37839)
+* [[`73c1999d0c`](https://github.com/nodejs/node/commit/73c1999d0c)] - **docs**: add references to punycode.md (Isaac Levy) [#36761](https://github.com/nodejs/node/pull/36761)
+* [[`bd38dfbfcc`](https://github.com/nodejs/node/commit/bd38dfbfcc)] - **domain**: add name to monkey-patched emit function (Colin Ihrig) [#37550](https://github.com/nodejs/node/pull/37550)
+* [[`13d972dd86`](https://github.com/nodejs/node/commit/13d972dd86)] - **domain**: show falsy names as anonymous for DEP0097 (Colin Ihrig) [#37550](https://github.com/nodejs/node/pull/37550)
+* [[`3f43743c9d`](https://github.com/nodejs/node/commit/3f43743c9d)] - **domain**: make node resilient to Array prototype tempering (Antoine du Hamel) [#36676](https://github.com/nodejs/node/pull/36676)
+* [[`4807499d21`](https://github.com/nodejs/node/commit/4807499d21)] - **domain**: improve deprecation warning text for DEP0097 (Anna Henningsen) [#36136](https://github.com/nodejs/node/pull/36136)
+* [[`b01c496e34`](https://github.com/nodejs/node/commit/b01c496e34)] - **errors**: do not call resolve on URLs with schemes (Benjamin Coe) [#35903](https://github.com/nodejs/node/pull/35903)
+* [[`3c37f896a4`](https://github.com/nodejs/node/commit/3c37f896a4)] - **errors**: print original exception context (Benjamin Coe) [#33491](https://github.com/nodejs/node/pull/33491)
+* [[`3006302372`](https://github.com/nodejs/node/commit/3006302372)] - **(SEMVER-MINOR)** **events**: add max listener warning for EventTarget (James M Snell) [#36001](https://github.com/nodejs/node/pull/36001)
+* [[`6e734a8a61`](https://github.com/nodejs/node/commit/6e734a8a61)] - **(SEMVER-MINOR)** **events**: getEventListeners static (Benjamin Gruenbaum) [#35991](https://github.com/nodejs/node/pull/35991)
+* [[`64cd54be57`](https://github.com/nodejs/node/commit/64cd54be57)] - **events**: disabled manual construction AbortSignal (raisinten) [#36094](https://github.com/nodejs/node/pull/36094)
+* [[`daad5214c4`](https://github.com/nodejs/node/commit/daad5214c4)] - **events**: fire handlers in correct oder (Benjamin Gruenbaum) [#35931](https://github.com/nodejs/node/pull/35931)
+* [[`7c95cfc164`](https://github.com/nodejs/node/commit/7c95cfc164)] - **events**: define abort on prototype (Benjamin Gruenbaum) [#35931](https://github.com/nodejs/node/pull/35931)
+* [[`bdad1bc4fc`](https://github.com/nodejs/node/commit/bdad1bc4fc)] - **events**: support event handlers on prototypes (Benjamin Gruenbaum) [#35931](https://github.com/nodejs/node/pull/35931)
+* [[`6e21e8283f`](https://github.com/nodejs/node/commit/6e21e8283f)] - **events**: define event handler as enumerable (Benjamin Gruenbaum) [#35931](https://github.com/nodejs/node/pull/35931)
+* [[`e51d7c535f`](https://github.com/nodejs/node/commit/e51d7c535f)] - **events**: support emit on nodeeventtarget (Benjamin Gruenbaum) [#35851](https://github.com/nodejs/node/pull/35851)
+* [[`6558ffa76b`](https://github.com/nodejs/node/commit/6558ffa76b)] - **events**: add a few tests (Benjamin Gruenbaum) [#35806](https://github.com/nodejs/node/pull/35806)
+* [[`bf728b5439`](https://github.com/nodejs/node/commit/bf728b5439)] - **events**: make abort\_controller event trusted (Benjamin Gruenbaum) [#35811](https://github.com/nodejs/node/pull/35811)
+* [[`3f33b5a89e`](https://github.com/nodejs/node/commit/3f33b5a89e)] - **(SEMVER-MINOR)** **events**: allow use of AbortController with on (James M Snell) [#34912](https://github.com/nodejs/node/pull/34912)
+* [[`1fefb5cb75`](https://github.com/nodejs/node/commit/1fefb5cb75)] - **(SEMVER-MINOR)** **events**: allow use of AbortController with once (James M Snell) [#34911](https://github.com/nodejs/node/pull/34911)
+* [[`85987450df`](https://github.com/nodejs/node/commit/85987450df)] - **fs**: fix chown abort (Darshan Sen) [#38004](https://github.com/nodejs/node/pull/38004)
+* [[`dd1fe6d8ba`](https://github.com/nodejs/node/commit/dd1fe6d8ba)] - **fs**: add promisified readFile benchmark (Nitzan Uziely) [#37608](https://github.com/nodejs/node/pull/37608)
+* [[`f2279f856e`](https://github.com/nodejs/node/commit/f2279f856e)] - **fs**: fix writeFile signal does not close file (Nitzan Uziely) [#37402](https://github.com/nodejs/node/pull/37402)
+* [[`92348a9216`](https://github.com/nodejs/node/commit/92348a9216)] - **(SEMVER-MINOR)** **fs**: use a default callback for fs.close() (James M Snell) [#37174](https://github.com/nodejs/node/pull/37174)
+* [[`e582832643`](https://github.com/nodejs/node/commit/e582832643)] - **fs**: only use Buffer.concat in promises.readFile when necessary (Anna Henningsen) [#37127](https://github.com/nodejs/node/pull/37127)
+* [[`a1ee9b3680`](https://github.com/nodejs/node/commit/a1ee9b3680)] - **fs**: add explicit note about undefined path when recursive (Sebastian Silbermann) [#37010](https://github.com/nodejs/node/pull/37010)
+* [[`fe6e5e4c0e`](https://github.com/nodejs/node/commit/fe6e5e4c0e)] - **fs**: accept non-32-bit length in writeBuffer (raisinten) [#36667](https://github.com/nodejs/node/pull/36667)
+* [[`455243667a`](https://github.com/nodejs/node/commit/455243667a)] - **fs**: move method definition from header (Yash Ladha) [#36256](https://github.com/nodejs/node/pull/36256)
+* [[`1bffd8d7bb`](https://github.com/nodejs/node/commit/1bffd8d7bb)] - **fs**: pass ERR\_DIR\_CLOSED asynchronously to dir.close (Zijian Liu) [#36243](https://github.com/nodejs/node/pull/36243)
+* [[`9b8596a67f`](https://github.com/nodejs/node/commit/9b8596a67f)] - **fs**: fix when path is buffer on fs.symlinkSync (himself65) [#34540](https://github.com/nodejs/node/pull/34540)
+* [[`026941381b`](https://github.com/nodejs/node/commit/026941381b)] - **fs**: fix pre-aborted writeFile AbortSignal file leak (Nitzan Uziely) [#37393](https://github.com/nodejs/node/pull/37393)
+* [[`7aa2e5d8dc`](https://github.com/nodejs/node/commit/7aa2e5d8dc)] - **(SEMVER-MINOR)** **fs**: add AbortSignal support to watch (Benjamin Gruenbaum) [#37190](https://github.com/nodejs/node/pull/37190)
+* [[`219cd000c0`](https://github.com/nodejs/node/commit/219cd000c0)] - **(SEMVER-MINOR)** **fs**: support abortsignal in writeFile (Benjamin Gruenbaum) [#35993](https://github.com/nodejs/node/pull/35993)
+* [[`5f88b644f8`](https://github.com/nodejs/node/commit/5f88b644f8)] - **(SEMVER-MINOR)** **fs**: add support for AbortSignal in readFile (Benjamin Gruenbaum) [#35911](https://github.com/nodejs/node/pull/35911)
+* [[`443cacee5f`](https://github.com/nodejs/node/commit/443cacee5f)] - **fs**: remove custom Buffer pool for streams (Robert Nagy) [#33981](https://github.com/nodejs/node/pull/33981)
+* [[`d0115f14f6`](https://github.com/nodejs/node/commit/d0115f14f6)] - **(SEMVER-MINOR)** **http**: add http.ClientRequest.getRawHeaderNames() (simov) [#37660](https://github.com/nodejs/node/pull/37660)
+* [[`105b8630b9`](https://github.com/nodejs/node/commit/105b8630b9)] - **http**: explain the possibilty of refactor unused argument (Qingyu Deng) [#37275](https://github.com/nodejs/node/pull/37275)
+* [[`926bb4fd17`](https://github.com/nodejs/node/commit/926bb4fd17)] - **http**: explain the unused argument in IncomingMessage.\_read (Qingyu Deng) [#37275](https://github.com/nodejs/node/pull/37275)
+* [[`e7bc37909c`](https://github.com/nodejs/node/commit/e7bc37909c)] - **http**: cleanup ClientRequest oncreate (Robert Nagy) [#36862](https://github.com/nodejs/node/pull/36862)
+* [[`5064822f24`](https://github.com/nodejs/node/commit/5064822f24)] - **http**: make HEAD method to work with keep-alive (Joseph Hackman) [#34231](https://github.com/nodejs/node/pull/34231)
+* [[`8163f3179b`](https://github.com/nodejs/node/commit/8163f3179b)] - **http**: remove dead code from internal/http.js (ZiJian Liu) [#36630](https://github.com/nodejs/node/pull/36630)
+* [[`ad39b37974`](https://github.com/nodejs/node/commit/ad39b37974)] - **(SEMVER-MINOR)** **http**: enable call chaining with setHeader() (pooja d.p) [#35924](https://github.com/nodejs/node/pull/35924)
+* [[`623099db4b`](https://github.com/nodejs/node/commit/623099db4b)] - **(SEMVER-MINOR)** **http**: report request start and end with diagnostics\_channel (Stephen Belanger) [#34895](https://github.com/nodejs/node/pull/34895)
+* [[`524b7134e8`](https://github.com/nodejs/node/commit/524b7134e8)] - **(SEMVER-MINOR)** **http**: add support for abortsignal to http.request (Benjamin Gruenbaum) [#36048](https://github.com/nodejs/node/pull/36048)
+* [[`f70aee03ab`](https://github.com/nodejs/node/commit/f70aee03ab)] - **(SEMVER-MINOR)** **http**: set lifo as the default scheduling strategy in Agent (Matteo Collina) [#36685](https://github.com/nodejs/node/pull/36685)
+* [[`16a16508c4`](https://github.com/nodejs/node/commit/16a16508c4)] - **http2**: fix typos in core.js (Pranshu Jethmalani) [#36719](https://github.com/nodejs/node/pull/36719)
+* [[`2e259220cb`](https://github.com/nodejs/node/commit/2e259220cb)] - **(SEMVER-MINOR)** **http2**: add updateSettings to both http2 servers (Vincent Boivin) [#35383](https://github.com/nodejs/node/pull/35383)
+* [[`336fb18b44`](https://github.com/nodejs/node/commit/336fb18b44)] - **http2**: add support for AbortSignal to http2Session.request (Madara Uchiha) [#36070](https://github.com/nodejs/node/pull/36070)
+* [[`f44b3c12e5`](https://github.com/nodejs/node/commit/f44b3c12e5)] - **https**: add abortcontroller test (Benjamin Gruenbaum) [#36307](https://github.com/nodejs/node/pull/36307)
+* [[`b5ad655c6b`](https://github.com/nodejs/node/commit/b5ad655c6b)] - **lib**: properly process JavaScript exceptions on async\_hooks fatal error (legendecas) [#38106](https://github.com/nodejs/node/pull/38106)
+* [[`1d8269302e`](https://github.com/nodejs/node/commit/1d8269302e)] - **lib**: change wording in lib/domain.js comment (Akhil Marsonya) [#37933](https://github.com/nodejs/node/pull/37933)
+* [[`a61fd37786`](https://github.com/nodejs/node/commit/a61fd37786)] - **lib**: change wording in lib/internal/child\_process comment (Akhil Marsonya) [#37903](https://github.com/nodejs/node/pull/37903)
+* [[`13ac680cdb`](https://github.com/nodejs/node/commit/13ac680cdb)] - **lib**: fix typo in internal/modules/esm/module\_job.js (marsonya) [#37773](https://github.com/nodejs/node/pull/37773)
+* [[`eea4f3bf82`](https://github.com/nodejs/node/commit/eea4f3bf82)] - **lib**: fix typo in lib/internal/bootstrap/loaders.js (marsonya) [#37644](https://github.com/nodejs/node/pull/37644)
+* [[`fe47563bed`](https://github.com/nodejs/node/commit/fe47563bed)] - **lib**: simplify check in child\_process (Darshan Sen) [#37367](https://github.com/nodejs/node/pull/37367)
+* [[`d78e2ed82c`](https://github.com/nodejs/node/commit/d78e2ed82c)] - **lib**: remove non used getter in `lib/perf\_hooks.js` (Juan José Arboleda) [#36907](https://github.com/nodejs/node/pull/36907)
+* [[`08b69fb1e8`](https://github.com/nodejs/node/commit/08b69fb1e8)] - **lib**: fix diagnostics\_channel hasSubscribers error (ZiJian Liu) [#36599](https://github.com/nodejs/node/pull/36599)
+* [[`3ee0423dfa`](https://github.com/nodejs/node/commit/3ee0423dfa)] - **(SEMVER-MINOR)** **lib**: support BigInt in querystring.stringify (raisinten) [#36499](https://github.com/nodejs/node/pull/36499)
+* [[`e71eed620a`](https://github.com/nodejs/node/commit/e71eed620a)] - **lib**: fix typo in internal/errors.js (raisinten) [#36426](https://github.com/nodejs/node/pull/36426)
+* [[`be537fe877`](https://github.com/nodejs/node/commit/be537fe877)] - **lib**: remove primordials.SafePromise (Antoine du Hamel) [#36149](https://github.com/nodejs/node/pull/36149)
+* [[`60ef53cc14`](https://github.com/nodejs/node/commit/60ef53cc14)] - **(SEMVER-MINOR)** **lib**: create diagnostics\_channel module (Stephen Belanger) [#34895](https://github.com/nodejs/node/pull/34895)
+* [[`b1507c41e7`](https://github.com/nodejs/node/commit/b1507c41e7)] - **lib**: add brand checks to AbortController and AbortSignal (Mattias Buelens) [#37720](https://github.com/nodejs/node/pull/37720)
+* [[`448a6a22cf`](https://github.com/nodejs/node/commit/448a6a22cf)] - **(SEMVER-MINOR)** **lib**: implement AbortSignal.abort() (James M Snell) [#37693](https://github.com/nodejs/node/pull/37693)
+* [[`4cd9f39066`](https://github.com/nodejs/node/commit/4cd9f39066)] - **lib**: set abort-controller toStringTag (Benjamin Gruenbaum) [#36115](https://github.com/nodejs/node/pull/36115)
+* [[`b2f8e8dd28`](https://github.com/nodejs/node/commit/b2f8e8dd28)] - **lib**: let abort\_controller target be EventTarget (Daijiro Wachi) [#35869](https://github.com/nodejs/node/pull/35869)
+* [[`f30f9314c8`](https://github.com/nodejs/node/commit/f30f9314c8)] - **(SEMVER-MINOR)** **lib**: initial experimental AbortController implementation (James M Snell) [#33527](https://github.com/nodejs/node/pull/33527)
+* [[`5e77bcd3dc`](https://github.com/nodejs/node/commit/5e77bcd3dc)] - **(SEMVER-MINOR)** **lib**: add throws option to fs.f/l/statSync (Andrew Casey) [#33716](https://github.com/nodejs/node/pull/33716)
+* [[`e0df3bc751`](https://github.com/nodejs/node/commit/e0df3bc751)] - **meta**: notify slack when someone force pushes (Mary Marchini) [#35131](https://github.com/nodejs/node/pull/35131)
+* [[`079671d3c1`](https://github.com/nodejs/node/commit/079671d3c1)] - **module**: improve error message for invalid data URL (Antoine du Hamel) [#37701](https://github.com/nodejs/node/pull/37701)
+* [[`4cdd9b63b4`](https://github.com/nodejs/node/commit/4cdd9b63b4)] - **module**: make synthetic module evaluation steps return a Promise to support top level await (Daniel Clark) [#37300](https://github.com/nodejs/node/pull/37300)
+* [[`2413907a12`](https://github.com/nodejs/node/commit/2413907a12)] - **(SEMVER-MINOR)** **module**: add isPreloading indicator (James M Snell) [#36263](https://github.com/nodejs/node/pull/36263)
+* [[`fd08c37d98`](https://github.com/nodejs/node/commit/fd08c37d98)] - **(SEMVER-MINOR)** **net**: add support for resolving DNS CAA records (Danny Sonnenschein) [#35466](https://github.com/nodejs/node/pull/35466)
+* [[`8413759d84`](https://github.com/nodejs/node/commit/8413759d84)] - **node-api**: fix crash in finalization (Michael Dawson) [#37876](https://github.com/nodejs/node/pull/37876)
+* [[`6e018559db`](https://github.com/nodejs/node/commit/6e018559db)] - **node-api**: stop ref gc during environment teardown (Gabriel Schulhof) [#37616](https://github.com/nodejs/node/pull/37616)
+* [[`b5b1ad39dd`](https://github.com/nodejs/node/commit/b5b1ad39dd)] - **node-api**: force env shutdown deferring behavior (Gabriel Schulhof) [#37303](https://github.com/nodejs/node/pull/37303)
+* [[`36abc1802c`](https://github.com/nodejs/node/commit/36abc1802c)] - **(SEMVER-MINOR)** **node-api**: define version 8 (Gabriel Schulhof) [#37652](https://github.com/nodejs/node/pull/37652)
+* [[`991251fbb2`](https://github.com/nodejs/node/commit/991251fbb2)] - **os**: performance improvement in vector allocation (Yash Ladha) [#36748](https://github.com/nodejs/node/pull/36748)
+* [[`395b9a69a1`](https://github.com/nodejs/node/commit/395b9a69a1)] - **perf_hooks**: make nodeTiming a first-class object (Momtchil Momtchev) [#35977](https://github.com/nodejs/node/pull/35977)
+* [[`506f1d4044`](https://github.com/nodejs/node/commit/506f1d4044)] - **policy**: fix cascade getting scope (Bradley Meck) [#37298](https://github.com/nodejs/node/pull/37298)
+* [[`e9110d56d2`](https://github.com/nodejs/node/commit/e9110d56d2)] - **process**: do not lazily load AsyncResource (Michaël Zasso) [#38041](https://github.com/nodejs/node/pull/38041)
+* [[`43057595e2`](https://github.com/nodejs/node/commit/43057595e2)] - **process**: passing -1 to setuid/setgid should not abort (James M Snell) [#36786](https://github.com/nodejs/node/pull/36786)
+* [[`70cbe4a565`](https://github.com/nodejs/node/commit/70cbe4a565)] - **readline**: fix behaviour of Interface plugged to a non-terminal output (Antoine du Hamel) [#36774](https://github.com/nodejs/node/pull/36774)
+* [[`ffaa1149e1`](https://github.com/nodejs/node/commit/ffaa1149e1)] - **(SEMVER-MINOR)** **readline**: add getPrompt to get the current prompt (Mattias Runge-Broberg) [#33675](https://github.com/nodejs/node/pull/33675)
+* [[`8d4936da2c`](https://github.com/nodejs/node/commit/8d4936da2c)] - **repl**: fix error message printing (Anna Henningsen) [#38209](https://github.com/nodejs/node/pull/38209)
+* [[`1ac07b2aee`](https://github.com/nodejs/node/commit/1ac07b2aee)] - **repl**: disable blocking completions by default (Anna Henningsen) [#36564](https://github.com/nodejs/node/pull/36564)
+* [[`5ed770e1b7`](https://github.com/nodejs/node/commit/5ed770e1b7)] - **src**: cache some context in locals (Khaidi Chu) [#37473](https://github.com/nodejs/node/pull/37473)
+* [[`ec4be2d7e1`](https://github.com/nodejs/node/commit/ec4be2d7e1)] - **src**: fix finalization crash (James M Snell) [#38250](https://github.com/nodejs/node/pull/38250)
+* [[`854a2a9c8a`](https://github.com/nodejs/node/commit/854a2a9c8a)] - **src**: fix typo for initialization (Yash Ladha) [#37974](https://github.com/nodejs/node/pull/37974)
+* [[`b0f8f8d637`](https://github.com/nodejs/node/commit/b0f8f8d637)] - **src**: fix typo in node\_mutex (Tobias Nießen) [#38011](https://github.com/nodejs/node/pull/38011)
+* [[`e4f614100f`](https://github.com/nodejs/node/commit/e4f614100f)] - **src**: document newer values for --unhandled-rejections flag (David Glasser) [#37899](https://github.com/nodejs/node/pull/37899)
+* [[`d0cb129cdb`](https://github.com/nodejs/node/commit/d0cb129cdb)] - **src**: fix typo in src code guide (Tobias Nießen) [#37956](https://github.com/nodejs/node/pull/37956)
+* [[`6aa1ed20fa`](https://github.com/nodejs/node/commit/6aa1ed20fa)] - **src**: report idle time correctly (Stephen Belanger) [#37868](https://github.com/nodejs/node/pull/37868)
+* [[`eb0faa12df`](https://github.com/nodejs/node/commit/eb0faa12df)] - **src**: add .note.GNU-stack section (James Addison) [#37688](https://github.com/nodejs/node/pull/37688)
+* [[`ec5d7b1ec0`](https://github.com/nodejs/node/commit/ec5d7b1ec0)] - **src**: fix variable name of OnCloseReceived callback (Tobias Nießen) [#37521](https://github.com/nodejs/node/pull/37521)
+* [[`fc0d6e4008`](https://github.com/nodejs/node/commit/fc0d6e4008)] - **src**: add error formatting support (Gus Caplan) [#37598](https://github.com/nodejs/node/pull/37598)
+* [[`512ae7e125`](https://github.com/nodejs/node/commit/512ae7e125)] - **src**: adjust THP sysfs config token retrieval and file closure (James Addison) [#37187](https://github.com/nodejs/node/pull/37187)
+* [[`bf16d288e2`](https://github.com/nodejs/node/commit/bf16d288e2)] - **src**: fix return type of method in string\_search.h (Darshan Sen) [#37167](https://github.com/nodejs/node/pull/37167)
+* [[`f476c6dc0c`](https://github.com/nodejs/node/commit/f476c6dc0c)] - **src**: refactor v8 binding (Joyee Cheung) [#37112](https://github.com/nodejs/node/pull/37112)
+* [[`33ebf5d9ef`](https://github.com/nodejs/node/commit/33ebf5d9ef)] - **src**: rename binding\_data\_name to type\_name in BindingData (Joyee Cheung) [#37112](https://github.com/nodejs/node/pull/37112)
+* [[`88d9676e74`](https://github.com/nodejs/node/commit/88d9676e74)] - **src**: use make\_shared for safe allocation (Yash Ladha) [#37139](https://github.com/nodejs/node/pull/37139)
+* [[`ec7e5bc786`](https://github.com/nodejs/node/commit/ec7e5bc786)] - **src**: fix warning in string\_search.h (Darshan Sen) [#37146](https://github.com/nodejs/node/pull/37146)
+* [[`00309eea27`](https://github.com/nodejs/node/commit/00309eea27)] - **src**: read exactly two tokens from Linux THP sysfs config (James Addison) [#37065](https://github.com/nodejs/node/pull/37065)
+* [[`1ecdb66299`](https://github.com/nodejs/node/commit/1ecdb66299)] - **src**: expose BaseObject::kInternalFieldCount in post-mortem metadata (Joyee Cheung) [#37111](https://github.com/nodejs/node/pull/37111)
+* [[`93517dce78`](https://github.com/nodejs/node/commit/93517dce78)] - **src**: replace push\_back with emplace\_back in debug\_utils (raisinten) [#36897](https://github.com/nodejs/node/pull/36897)
+* [[`dcba374604`](https://github.com/nodejs/node/commit/dcba374604)] - **src**: fix leading backslash bug in URL (raisinten) [#36613](https://github.com/nodejs/node/pull/36613)
+* [[`c308b06483`](https://github.com/nodejs/node/commit/c308b06483)] - **src**: remove unnecessary ToLocalChecked node\_errors (Daniel Bevenius) [#36547](https://github.com/nodejs/node/pull/36547)
+* [[`e8f8c70911`](https://github.com/nodejs/node/commit/e8f8c70911)] - **src**: remove unnecessary ToLocalChecked call (Daniel Bevenius) [#36523](https://github.com/nodejs/node/pull/36523)
+* [[`a356f32e66`](https://github.com/nodejs/node/commit/a356f32e66)] - **src**: remove empty name check in node\_env\_var.cc (raisinten) [#36133](https://github.com/nodejs/node/pull/36133)
+* [[`308cb93304`](https://github.com/nodejs/node/commit/308cb93304)] - **src**: remove duplicate V macros in node\_v8.cc (Daniel Bevenius) [#36454](https://github.com/nodejs/node/pull/36454)
+* [[`6df1132c85`](https://github.com/nodejs/node/commit/6df1132c85)] - **src**: guard against env != null in node\_errors.cc (Anna Henningsen) [#36414](https://github.com/nodejs/node/pull/36414)
+* [[`3701e5d14f`](https://github.com/nodejs/node/commit/3701e5d14f)] - **src**: add typedef for CleanupHookCallback callback (Daniel Bevenius) [#36442](https://github.com/nodejs/node/pull/36442)
+* [[`bd90752a7e`](https://github.com/nodejs/node/commit/bd90752a7e)] - **src**: fix indentation in memory\_tracker-inl.h (Daniel Bevenius) [#36425](https://github.com/nodejs/node/pull/36425)
+* [[`05bb3e14cf`](https://github.com/nodejs/node/commit/05bb3e14cf)] - **src**: remove identical V macro (Daniel Bevenius) [#36427](https://github.com/nodejs/node/pull/36427)
+* [[`4b386e3dbe`](https://github.com/nodejs/node/commit/4b386e3dbe)] - **src**: add missing context scopes (Anna Henningsen) [#36413](https://github.com/nodejs/node/pull/36413)
+* [[`685ed2c275`](https://github.com/nodejs/node/commit/685ed2c275)] - **src**: use ToLocal in DeserializeProperties (Daniel Bevenius) [#36279](https://github.com/nodejs/node/pull/36279)
+* [[`d8cb34158b`](https://github.com/nodejs/node/commit/d8cb34158b)] - **src**: update node.rc file description (devsnek) [#36197](https://github.com/nodejs/node/pull/36197)
+* [[`bacd432f34`](https://github.com/nodejs/node/commit/bacd432f34)] - **src**: move all base64.h inline methods into -inl.h header file (Anna Henningsen) [#35432](https://github.com/nodejs/node/pull/35432)
+* [[`b1d5160828`](https://github.com/nodejs/node/commit/b1d5160828)] - **src**: guard against nullptr deref in TimerWrapHandle::Stop (Anna Henningsen) [#34460](https://github.com/nodejs/node/pull/34460)
+* [[`cf2475ca09`](https://github.com/nodejs/node/commit/cf2475ca09)] - **src**: refactor TimerWrap lifetime management (Anna Henningsen) [#34252](https://github.com/nodejs/node/pull/34252)
+* [[`b8bccc3132`](https://github.com/nodejs/node/commit/b8bccc3132)] - **src**: remove user\_data from TimerWrap (Anna Henningsen) [#34252](https://github.com/nodejs/node/pull/34252)
+* [[`8e1e3b563f`](https://github.com/nodejs/node/commit/8e1e3b563f)] - **src**: replace InspectorTimer with TimerWrap utility (James M Snell) [#34186](https://github.com/nodejs/node/pull/34186)
+* [[`a3a4d2c283`](https://github.com/nodejs/node/commit/a3a4d2c283)] - **src**: add TimerWrap utility (James M Snell) [#34186](https://github.com/nodejs/node/pull/34186)
+* [[`ae9bd89329`](https://github.com/nodejs/node/commit/ae9bd89329)] - **src**: perform bounds checking on error source line (Anna Henningsen) [#33645](https://github.com/nodejs/node/pull/33645)
+* [[`44868010f7`](https://github.com/nodejs/node/commit/44868010f7)] - **(SEMVER-MINOR)** **src**: add loop idle time in diagnostic report (Gireesh Punathil) [#35940](https://github.com/nodejs/node/pull/35940)
+* [[`4793f165dc`](https://github.com/nodejs/node/commit/4793f165dc)] - **stream**: fix pipe deadlock when starting with needDrain (Robert Nagy) [#36563](https://github.com/nodejs/node/pull/36563)
+* [[`617f2dc0cf`](https://github.com/nodejs/node/commit/617f2dc0cf)] - **(SEMVER-MINOR)** **stream**: writableNeedDrain (Robert Nagy) [#35348](https://github.com/nodejs/node/pull/35348)
+* [[`26e9c39cea`](https://github.com/nodejs/node/commit/26e9c39cea)] - **stream**: remove isPromise utility function (Antoine du Hamel) [#35925](https://github.com/nodejs/node/pull/35925)
+* [[`7858de4f63`](https://github.com/nodejs/node/commit/7858de4f63)] - **stream,util**: fix "the the" typo in comments (Luigi Pinca) [#37674](https://github.com/nodejs/node/pull/37674)
+* [[`93c917c1ce`](https://github.com/nodejs/node/commit/93c917c1ce)] - **test**: move buffer-as-path symlink test to its own test file (Rich Trott) [#34569](https://github.com/nodejs/node/pull/34569)
+* [[`cd95bf3dd7`](https://github.com/nodejs/node/commit/cd95bf3dd7)] - **test**: change Fixes: to Refs: (Rich Trott) [#34568](https://github.com/nodejs/node/pull/34568)
+* [[`2e81ded71e`](https://github.com/nodejs/node/commit/2e81ded71e)] - **test**: fix flaky test-dns and test-dns-lookup (Rich Trott) [#38282](https://github.com/nodejs/node/pull/38282)
+* [[`ea1183c6ec`](https://github.com/nodejs/node/commit/ea1183c6ec)] - **test**: fixup failing test/internet/test-dns.js (James M Snell) [#38241](https://github.com/nodejs/node/pull/38241)
+* [[`ae44e5f5b5`](https://github.com/nodejs/node/commit/ae44e5f5b5)] - **test**: add tests for missing https agent options (Rich Trott) [#38202](https://github.com/nodejs/node/pull/38202)
+* [[`796007ba07`](https://github.com/nodejs/node/commit/796007ba07)] - **test**: fix test-https-agent-additional-options.js (Rich Trott) [#38202](https://github.com/nodejs/node/pull/38202)
+* [[`a4275eec79`](https://github.com/nodejs/node/commit/a4275eec79)] - **test**: fix typo in comment in binding.c (Tobias Nießen) [#38220](https://github.com/nodejs/node/pull/38220)
+* [[`95c7dabbb4`](https://github.com/nodejs/node/commit/95c7dabbb4)] - **test**: fix typo in gtest-all.cc (Ikko Ashimine) [#38224](https://github.com/nodejs/node/pull/38224)
+* [[`605f830672`](https://github.com/nodejs/node/commit/605f830672)] - **test**: add undefined fatalException exit code test (Nitzan Uziely) [#38119](https://github.com/nodejs/node/pull/38119)
+* [[`ce70ea8a85`](https://github.com/nodejs/node/commit/ce70ea8a85)] - **test**: skip fs.watch() test on IBMi (Rich Trott) [#38192](https://github.com/nodejs/node/pull/38192)
+* [[`058abbece1`](https://github.com/nodejs/node/commit/058abbece1)] - **test**: skip test-vm-memleak in ASAN (Rich Trott) [#34289](https://github.com/nodejs/node/pull/34289)
+* [[`c7981daf09`](https://github.com/nodejs/node/commit/c7981daf09)] - **test**: skip test-hash-seed on armv6 and armv7 (Rich Trott) [#34289](https://github.com/nodejs/node/pull/34289)
+* [[`552c945c7c`](https://github.com/nodejs/node/commit/552c945c7c)] - **test**: remove unneeded m flag on regular expressions (Rich Trott) [#38124](https://github.com/nodejs/node/pull/38124)
+* [[`e999da7004`](https://github.com/nodejs/node/commit/e999da7004)] - **test**: fix flaky test-zlib-unused-weak.js (Ouyang Yadong) [#38149](https://github.com/nodejs/node/pull/38149)
+* [[`aa0d8146e9`](https://github.com/nodejs/node/commit/aa0d8146e9)] - **test**: add regression test for serdes readDouble() (Colin Ihrig) [#38121](https://github.com/nodejs/node/pull/38121)
+* [[`dd8c9ad65b`](https://github.com/nodejs/node/commit/dd8c9ad65b)] - **test**: skip test-crypto-dh-keys on armv6 and armv7 (Rich Trott) [#38076](https://github.com/nodejs/node/pull/38076)
+* [[`7d85617484`](https://github.com/nodejs/node/commit/7d85617484)] - **test**: fix skip message for test-macos-app-sandbox (Tobias Nießen) [#38114](https://github.com/nodejs/node/pull/38114)
+* [[`f1aae43349`](https://github.com/nodejs/node/commit/f1aae43349)] - **test**: correct test comment (Evan Lucas) [#38095](https://github.com/nodejs/node/pull/38095)
+* [[`d6ab9bf1ad`](https://github.com/nodejs/node/commit/d6ab9bf1ad)] - **test**: fix flaky test-net-timeout (Rich Trott) [#38060](https://github.com/nodejs/node/pull/38060)
+* [[`1cb3d89bf1`](https://github.com/nodejs/node/commit/1cb3d89bf1)] - **test**: fix flaky timeout-delayed-body and headers tests (Nitzan Uziely) [#38045](https://github.com/nodejs/node/pull/38045)
+* [[`8590720489`](https://github.com/nodejs/node/commit/8590720489)] - **test**: add extra space in test failure output (Qingyu Deng) [#37957](https://github.com/nodejs/node/pull/37957)
+* [[`d6346e1486`](https://github.com/nodejs/node/commit/d6346e1486)] - **test**: deflake test-fs-read-optional-params (Luigi Pinca) [#37991](https://github.com/nodejs/node/pull/37991)
+* [[`abec939c58`](https://github.com/nodejs/node/commit/abec939c58)] - **test**: improve clarity of ALS-enable-disable.js (Darkripper214) [#38008](https://github.com/nodejs/node/pull/38008)
+* [[`2e3305d1b3`](https://github.com/nodejs/node/commit/2e3305d1b3)] - **test**: add DataView test case for v8 serdes (Rich Trott) [#37955](https://github.com/nodejs/node/pull/37955)
+* [[`7b0e4e23f2`](https://github.com/nodejs/node/commit/7b0e4e23f2)] - **test**: fix typeof comparison (Rich Trott) [#37924](https://github.com/nodejs/node/pull/37924)
+* [[`4c5eff91ef`](https://github.com/nodejs/node/commit/4c5eff91ef)] - **test**: increase wiggle room for memory in test-worker-resource-limits (Rich Trott) [#37901](https://github.com/nodejs/node/pull/37901)
+* [[`939f5541fa`](https://github.com/nodejs/node/commit/939f5541fa)] - **test**: fix deprecation warning in test-doctool-html (Antoine du Hamel) [#37858](https://github.com/nodejs/node/pull/37858)
+* [[`f5334881f2`](https://github.com/nodejs/node/commit/f5334881f2)] - **test**: fix ibmi skip message (Tobias Nießen) [#37821](https://github.com/nodejs/node/pull/37821)
+* [[`cd71199cdb`](https://github.com/nodejs/node/commit/cd71199cdb)] - **test**: fix flaky test-vm-timeout-escape-promise-module-2 (Rich Trott) [#37842](https://github.com/nodejs/node/pull/37842)
+* [[`b858e12fca`](https://github.com/nodejs/node/commit/b858e12fca)] - **test**: remove duplicated test for eventtarget (himself65) [#37853](https://github.com/nodejs/node/pull/37853)
+* [[`e57e532d28`](https://github.com/nodejs/node/commit/e57e532d28)] - **test**: relax Y2K38 check in test-fs-utimes-y2K38 (Richard Lau) [#37825](https://github.com/nodejs/node/pull/37825)
+* [[`08d32e18b7`](https://github.com/nodejs/node/commit/08d32e18b7)] - **test**: remove skip for fixed test-benchmark-fs (Rich Trott) [#37803](https://github.com/nodejs/node/pull/37803)
+* [[`3f86dc1d9b`](https://github.com/nodejs/node/commit/3f86dc1d9b)] - **test**: improve test-arm-math-illegal-instruction (marsonya) [#37670](https://github.com/nodejs/node/pull/37670)
+* [[`5c60087132`](https://github.com/nodejs/node/commit/5c60087132)] - **(SEMVER-MINOR)** **test**: app atob web platform tests (James M Snell) [#37529](https://github.com/nodejs/node/pull/37529)
+* [[`02916edbdd`](https://github.com/nodejs/node/commit/02916edbdd)] - **test**: add known\_issues test for #13683 (Rich Trott) [#37744](https://github.com/nodejs/node/pull/37744)
+* [[`62292031a8`](https://github.com/nodejs/node/commit/62292031a8)] - **test**: fix test-fs-utimes on non-Y2K38 file systems (Rich Trott) [#37707](https://github.com/nodejs/node/pull/37707)
+* [[`e29905441e`](https://github.com/nodejs/node/commit/e29905441e)] - **test**: remove unnecessary V8 flag (Antoine du Hamel) [#37671](https://github.com/nodejs/node/pull/37671)
+* [[`27d4fedca3`](https://github.com/nodejs/node/commit/27d4fedca3)] - **test**: improve error reporting in test-child-process-pipe-dataflow (Rich Trott) [#37632](https://github.com/nodejs/node/pull/37632)
+* [[`376fcc75c6`](https://github.com/nodejs/node/commit/376fcc75c6)] - **test**: remove FLAKY status for test-async-hooks-http-parser-destroy (Rich Trott) [#37636](https://github.com/nodejs/node/pull/37636)
+* [[`a91a200be0`](https://github.com/nodejs/node/commit/a91a200be0)] - **test**: remove FLAKY status for fixed test (Rich Trott) [#37633](https://github.com/nodejs/node/pull/37633)
+* [[`102d12f308`](https://github.com/nodejs/node/commit/102d12f308)] - **test**: clear flaky designation for test-stream-pipeline-http2 (Rich Trott) [#37631](https://github.com/nodejs/node/pull/37631)
+* [[`ed30e52ee8`](https://github.com/nodejs/node/commit/ed30e52ee8)] - **test**: clear FLAKY designation for test-http2-pipe (Rich Trott) [#37631](https://github.com/nodejs/node/pull/37631)
+* [[`df93cb47da`](https://github.com/nodejs/node/commit/df93cb47da)] - **test**: fix wasi/test-return-on-exit on 32-bit systems (Colin Ihrig) [#37615](https://github.com/nodejs/node/pull/37615)
+* [[`097f638fde`](https://github.com/nodejs/node/commit/097f638fde)] - **test**: remove FLAKY status for test-http2-multistream-destroy-on-read-tls (Rich Trott) [#37533](https://github.com/nodejs/node/pull/37533)
+* [[`0726192c94`](https://github.com/nodejs/node/commit/0726192c94)] - **test**: make status file names consistent (Rich Trott) [#37532](https://github.com/nodejs/node/pull/37532)
+* [[`bcc4f1773c`](https://github.com/nodejs/node/commit/bcc4f1773c)] - **test**: remove FLAKY for test-http2-compat-client-upload-reject (Rich Trott) [#37462](https://github.com/nodejs/node/pull/37462)
+* [[`d168cdea50`](https://github.com/nodejs/node/commit/d168cdea50)] - **test**: validate no debug info for http2 (Michael Dawson) [#37447](https://github.com/nodejs/node/pull/37447)
+* [[`2f2f83fc4c`](https://github.com/nodejs/node/commit/2f2f83fc4c)] - **test**: remove FLAKY designation for test-http2-client-upload-reject (Rich Trott) [#37461](https://github.com/nodejs/node/pull/37461)
+* [[`776ef11732`](https://github.com/nodejs/node/commit/776ef11732)] - **test**: clarify usage of tmpdir.refresh() (Darshan Sen) [#37383](https://github.com/nodejs/node/pull/37383)
+* [[`8386b88c7f`](https://github.com/nodejs/node/commit/8386b88c7f)] - **test**: fix test-doctool-html (Antoine du Hamel) [#37397](https://github.com/nodejs/node/pull/37397)
+* [[`03752c0412`](https://github.com/nodejs/node/commit/03752c0412)] - **test**: remove flaky designation for test-http2-large-file (Rich Trott) [#37156](https://github.com/nodejs/node/pull/37156)
+* [[`db44b92c58`](https://github.com/nodejs/node/commit/db44b92c58)] - **test**: increase inspect coverage (Emil Sivervik) [#36755](https://github.com/nodejs/node/pull/36755)
+* [[`21e7b021a0`](https://github.com/nodejs/node/commit/21e7b021a0)] - **test**: skip tests consistently in parallel.status (Rich Trott) [#37035](https://github.com/nodejs/node/pull/37035)
+* [[`8f580df5ac`](https://github.com/nodejs/node/commit/8f580df5ac)] - **test**: increase read file abort coverage (Moshe vilner) [#36716](https://github.com/nodejs/node/pull/36716)
+* [[`55a7b0c2e1`](https://github.com/nodejs/node/commit/55a7b0c2e1)] - **test**: increase coverage for assert/calltracker (ZiJian Liu) [#36728](https://github.com/nodejs/node/pull/36728)
+* [[`ec7ee61af0`](https://github.com/nodejs/node/commit/ec7ee61af0)] - **test**: improve assertion message for test-vm-memleak (Rich Trott) [#37034](https://github.com/nodejs/node/pull/37034)
+* [[`456fd758f3`](https://github.com/nodejs/node/commit/456fd758f3)] - **test**: process.nextTick for before exit (ttzztztz) [#37012](https://github.com/nodejs/node/pull/37012)
+* [[`d99f1755d3`](https://github.com/nodejs/node/commit/d99f1755d3)] - **test**: log error in test-fs-realpath-pipe (Joyee Cheung) [#36996](https://github.com/nodejs/node/pull/36996)
+* [[`0e1963c486`](https://github.com/nodejs/node/commit/0e1963c486)] - **test**: test mode passed as an options object in mkdir/mkdirSync (Darshan Sen) [#37008](https://github.com/nodejs/node/pull/37008)
+* [[`5408f51684`](https://github.com/nodejs/node/commit/5408f51684)] - **test**: mark flaky tests on IBM i (Richard Lau) [#36986](https://github.com/nodejs/node/pull/36986)
+* [[`e72b2b4639`](https://github.com/nodejs/node/commit/e72b2b4639)] - **test**: increase buffer list coverage (Emil Sivervik) [#36688](https://github.com/nodejs/node/pull/36688)
+* [[`90122d87c9`](https://github.com/nodejs/node/commit/90122d87c9)] - **test**: fix warning in test\_environment.cc (raisinten) [#36846](https://github.com/nodejs/node/pull/36846)
+* [[`2cbd72e17d`](https://github.com/nodejs/node/commit/2cbd72e17d)] - **test**: skip internet for test-npm-install (Ruy Adorno) [#36933](https://github.com/nodejs/node/pull/36933)
+* [[`2896219613`](https://github.com/nodejs/node/commit/2896219613)] - **test**: add coverage for breakLength one-column array (Rich Trott) [#36657](https://github.com/nodejs/node/pull/36657)
+* [[`ff212f44b7`](https://github.com/nodejs/node/commit/ff212f44b7)] - **test**: increase coverage for diagnostics\_channel (ZiJian Liu) [#36602](https://github.com/nodejs/node/pull/36602)
+* [[`35c388ab1f`](https://github.com/nodejs/node/commit/35c388ab1f)] - **test**: increase coverage for internal/error\_serdes.js (ZiJian Liu) [#36628](https://github.com/nodejs/node/pull/36628)
+* [[`581a95f0ea`](https://github.com/nodejs/node/commit/581a95f0ea)] - **test**: improve coverage for util.inspect() with classes (Rich Trott) [#36625](https://github.com/nodejs/node/pull/36625)
+* [[`e82a2e8ad5`](https://github.com/nodejs/node/commit/e82a2e8ad5)] - **test**: increase runInAsyncScope() coverage (Rich Trott) [#36624](https://github.com/nodejs/node/pull/36624)
+* [[`064144db89`](https://github.com/nodejs/node/commit/064144db89)] - **test**: redirect stderr EnvironmentWithNoESMLoader (Daniel Bevenius) [#36548](https://github.com/nodejs/node/pull/36548)
+* [[`cf8d025207`](https://github.com/nodejs/node/commit/cf8d025207)] - **test**: increase abort logic coverage (Moshe vilner) [#36586](https://github.com/nodejs/node/pull/36586)
+* [[`eba2dc5330`](https://github.com/nodejs/node/commit/eba2dc5330)] - **test**: increase coverage for worker (ZiJian Liu) [#36491](https://github.com/nodejs/node/pull/36491)
+* [[`5ef609af3e`](https://github.com/nodejs/node/commit/5ef609af3e)] - **test**: specify global object for globals (Rich Trott) [#36498](https://github.com/nodejs/node/pull/36498)
+* [[`829213f624`](https://github.com/nodejs/node/commit/829213f624)] - **test**: increase coverage for fs/dir read (Zijian Liu) [#36388](https://github.com/nodejs/node/pull/36388)
+* [[`c0604c9958`](https://github.com/nodejs/node/commit/c0604c9958)] - **test**: remove test-http2-client-upload as flaky (Rich Trott) [#36496](https://github.com/nodejs/node/pull/36496)
+* [[`dabbd6d8ad`](https://github.com/nodejs/node/commit/dabbd6d8ad)] - **test**: make executable name more general (Shelley Vohr) [#36489](https://github.com/nodejs/node/pull/36489)
+* [[`44603b7535`](https://github.com/nodejs/node/commit/44603b7535)] - **test**: increased externalized string length (Shelley Vohr) [#36451](https://github.com/nodejs/node/pull/36451)
+* [[`2d0b6ca1c6`](https://github.com/nodejs/node/commit/2d0b6ca1c6)] - **test**: fix flaky test-repl (Rich Trott) [#36415](https://github.com/nodejs/node/pull/36415)
+* [[`fee0389c12`](https://github.com/nodejs/node/commit/fee0389c12)] - **test**: check null proto-of-proto in util.inspect() (Rich Trott) [#36399](https://github.com/nodejs/node/pull/36399)
+* [[`0e821ff337`](https://github.com/nodejs/node/commit/0e821ff337)] - **test**: fix child-process-pipe-dataflow (Santiago Gimeno) [#36366](https://github.com/nodejs/node/pull/36366)
+* [[`736b575b7e`](https://github.com/nodejs/node/commit/736b575b7e)] - **test**: fix comment misspellings of transferred (Rich Trott) [#36360](https://github.com/nodejs/node/pull/36360)
+* [[`5fc0f5eabb`](https://github.com/nodejs/node/commit/5fc0f5eabb)] - **test**: increase coverage for readline (Zijian Liu) [#36389](https://github.com/nodejs/node/pull/36389)
+* [[`f5e8f12c1e`](https://github.com/nodejs/node/commit/f5e8f12c1e)] - **test**: fix typo in comment (inokawa) [#36312](https://github.com/nodejs/node/pull/36312)
+* [[`72b3e5a6d9`](https://github.com/nodejs/node/commit/72b3e5a6d9)] - **test**: replace anonymous functions by arrows (Aleksandr Krutko) [#36125](https://github.com/nodejs/node/pull/36125)
+* [[`b11e3ea1e6`](https://github.com/nodejs/node/commit/b11e3ea1e6)] - **test**: fix flaky sequential/test-fs-watch (Rich Trott) [#36249](https://github.com/nodejs/node/pull/36249)
+* [[`cb530d2372`](https://github.com/nodejs/node/commit/cb530d2372)] - **test**: increase coverage for util.inspect() (Rich Trott) [#36228](https://github.com/nodejs/node/pull/36228)
+* [[`94a877b0a4`](https://github.com/nodejs/node/commit/94a877b0a4)] - **test**: improve test coverage SourceMap API (Juan José Arboleda) [#36089](https://github.com/nodejs/node/pull/36089)
+* [[`6c62e15c36`](https://github.com/nodejs/node/commit/6c62e15c36)] - **test**: move test-worker-eventlooputil to sequential (Rich Trott) [#35996](https://github.com/nodejs/node/pull/35996)
+* [[`16f6f1a0c2`](https://github.com/nodejs/node/commit/16f6f1a0c2)] - **test**: add missing test coverage for setLocalAddress() (Rich Trott) [#36039](https://github.com/nodejs/node/pull/36039)
+* [[`23835012e0`](https://github.com/nodejs/node/commit/23835012e0)] - **test**: fix races in test-performance-eventlooputil (Gerhard Stoebich) [#36028](https://github.com/nodejs/node/pull/36028)
+* [[`d63747de5a`](https://github.com/nodejs/node/commit/d63747de5a)] - **test**: fix error in test/internet/test-dns.js (Rich Trott) [#35969](https://github.com/nodejs/node/pull/35969)
+* [[`00b9d955e9`](https://github.com/nodejs/node/commit/00b9d955e9)] - **test**: run test-benchmark-napi on arm (Rich Trott) [#34502](https://github.com/nodejs/node/pull/34502)
+* [[`de654bf5b4`](https://github.com/nodejs/node/commit/de654bf5b4)] - **test**: fix unreliable test-fs-write-file.js (Rich Trott) [#36102](https://github.com/nodejs/node/pull/36102)
+* [[`397d9372c2`](https://github.com/nodejs/node/commit/397d9372c2)] - **(SEMVER-MINOR)** **test**: update dom/abort tests (James M Snell) [#37693](https://github.com/nodejs/node/pull/37693)
+* [[`dc63ca686e`](https://github.com/nodejs/node/commit/dc63ca686e)] - **test**: increase execFile abort coverage (Moshe vilner) [#36429](https://github.com/nodejs/node/pull/36429)
+* [[`88f42617dd`](https://github.com/nodejs/node/commit/88f42617dd)] - **test**: integrate abort\_controller tests from wpt (Daijiro Wachi) [#35869](https://github.com/nodejs/node/pull/35869)
+* [[`cd1da67295`](https://github.com/nodejs/node/commit/cd1da67295)] - **test**: fix flaky test-http2-respond-file-error-pipe-offset (Rich Trott) [#36305](https://github.com/nodejs/node/pull/36305)
+* [[`db04ae6b02`](https://github.com/nodejs/node/commit/db04ae6b02)] - **test**: add SIGTRAP to test-signal-handler (Ash Cripps) [#36368](https://github.com/nodejs/node/pull/36368)
+* [[`48e3f592a0`](https://github.com/nodejs/node/commit/48e3f592a0)] - **test**: refactor coverage logic (Benjamin Coe) [#35767](https://github.com/nodejs/node/pull/35767)
+* [[`01ba1c9a9c`](https://github.com/nodejs/node/commit/01ba1c9a9c)] - **test**: correct test-worker-eventlooputil (Gerhard Stoebich) [#35891](https://github.com/nodejs/node/pull/35891)
+* [[`89046d7840`](https://github.com/nodejs/node/commit/89046d7840)] - **test**: add cpu-profiler-crash test (Santiago Gimeno) [#37293](https://github.com/nodejs/node/pull/37293)
+* [[`6961be5ed1`](https://github.com/nodejs/node/commit/6961be5ed1)] - **test**: add arm64 arch to test-worker-prof status (Daniel Bevenius) [#37225](https://github.com/nodejs/node/pull/37225)
+* [[`98f08c06e4`](https://github.com/nodejs/node/commit/98f08c06e4)] - **test,benchmark**: stop requiring URL and URLSearchParams (raisinten) [#36927](https://github.com/nodejs/node/pull/36927)
+* [[`51ef745975`](https://github.com/nodejs/node/commit/51ef745975)] - **test,child_process**: add check for `subProcess.pid` (dr-js) [#37014](https://github.com/nodejs/node/pull/37014)
+* [[`8476537aa4`](https://github.com/nodejs/node/commit/8476537aa4)] - **test,http**: check that http server is robust from handler abuse (Rich Trott) [#37958](https://github.com/nodejs/node/pull/37958)
+* [[`e4d10426c4`](https://github.com/nodejs/node/commit/e4d10426c4)] - **timers**: fix arbitrary object clearImmediate errors (Nitzan Uziely) [#37824](https://github.com/nodejs/node/pull/37824)
+* [[`1b74a08eba`](https://github.com/nodejs/node/commit/1b74a08eba)] - **timers**: refactor to use validateAbortSignal (ZiJian Liu) [#36604](https://github.com/nodejs/node/pull/36604)
+* [[`4b04bb87f6`](https://github.com/nodejs/node/commit/4b04bb87f6)] - **timers**: use AbortController with correct name/message (Anna Henningsen) [#34763](https://github.com/nodejs/node/pull/34763)
+* [[`9660a78278`](https://github.com/nodejs/node/commit/9660a78278)] - **(SEMVER-MINOR)** **timers**: move promisified timers implementations (James M Snell) [#33950](https://github.com/nodejs/node/pull/33950)
+* [[`59a8425d04`](https://github.com/nodejs/node/commit/59a8425d04)] - **timers**: fix multipleResolves in promisified timeouts/immediates (Denys Otrishko) [#33949](https://github.com/nodejs/node/pull/33949)
+* [[`84b2863f00`](https://github.com/nodejs/node/commit/84b2863f00)] - **(SEMVER-MINOR)** **timers**: allow promisified timeouts/immediates to be canceled (James M Snell) [#33833](https://github.com/nodejs/node/pull/33833)
+* [[`08ed2337ea`](https://github.com/nodejs/node/commit/08ed2337ea)] - **tls**: forward new SecureContext options (Alba Mendez) [#36416](https://github.com/nodejs/node/pull/36416)
+* [[`2c49953fc9`](https://github.com/nodejs/node/commit/2c49953fc9)] - **tools**: update glob-parent to 5.1.2 (Rich Trott) [#37646](https://github.com/nodejs/node/pull/37646)
+* [[`b76aa10aa8`](https://github.com/nodejs/node/commit/b76aa10aa8)] - **tools**: update remark-preset-lint-node to 2.1.1 (Rich Trott) [#37604](https://github.com/nodejs/node/pull/37604)
+* [[`5afaeafabe`](https://github.com/nodejs/node/commit/5afaeafabe)] - **tools**: bump remark-present-lint-node from 2.0.0 to 2.0.1 (Rich Trott) [#37270](https://github.com/nodejs/node/pull/37270)
+* [[`abd45d3355`](https://github.com/nodejs/node/commit/abd45d3355)] - **tools**: update all lint-md rollup dependencies (Michaël Zasso) [#36843](https://github.com/nodejs/node/pull/36843)
+* [[`c8f77f2e1d`](https://github.com/nodejs/node/commit/c8f77f2e1d)] - **tools**: update ini in tools/node-lint-md-cli-rollup (Myles Borins) [#36474](https://github.com/nodejs/node/pull/36474)
+* [[`ac70a59056`](https://github.com/nodejs/node/commit/ac70a59056)] - **tools**: bump remark-lint-preset-node to 2.0.0 (Rich Trott) [#35905](https://github.com/nodejs/node/pull/35905)
+* [[`cbb0a458b5`](https://github.com/nodejs/node/commit/cbb0a458b5)] - **tools**: bump remark-lint-preset-node to 1.17.1 (Rich Trott) [#35668](https://github.com/nodejs/node/pull/35668)
+* [[`ed7c0d7c1b`](https://github.com/nodejs/node/commit/ed7c0d7c1b)] - **tools**: skip macOS GitHub Actions test on doc-only changes (Rich Trott) [#38296](https://github.com/nodejs/node/pull/38296)
+* [[`4254315ebe`](https://github.com/nodejs/node/commit/4254315ebe)] - **tools**: improve valid-typeof lint rule (Rich Trott) [#37924](https://github.com/nodejs/node/pull/37924)
+* [[`f055faf647`](https://github.com/nodejs/node/commit/f055faf647)] - **tools**: improve macos-firewall.sh output (Rich Trott) [#37846](https://github.com/nodejs/node/pull/37846)
+* [[`2551bb1a61`](https://github.com/nodejs/node/commit/2551bb1a61)] - **tools**: make genv8constants.py Python3-compatible (Michaël Zasso) [#37835](https://github.com/nodejs/node/pull/37835)
+* [[`e6a79802d3`](https://github.com/nodejs/node/commit/e6a79802d3)] - **tools**: update gitignore for CMake (Jiawen Geng) [#37793](https://github.com/nodejs/node/pull/37793)
+* [[`e4975d9057`](https://github.com/nodejs/node/commit/e4975d9057)] - **tools**: fix object name in prefer-assert-methods.js (Tobias Nießen) [#37544](https://github.com/nodejs/node/pull/37544)
+* [[`77eb45aad4`](https://github.com/nodejs/node/commit/77eb45aad4)] - **tools**: fix compiler warning in inspector\_protocol (Darshan Sen) [#37573](https://github.com/nodejs/node/pull/37573)
+* [[`af8b3852a8`](https://github.com/nodejs/node/commit/af8b3852a8)] - **tools**: fix lint-pr-url message (Antoine du Hamel) [#37304](https://github.com/nodejs/node/pull/37304)
+* [[`2ba6db3c3e`](https://github.com/nodejs/node/commit/2ba6db3c3e)] - **tools**: avoid pending deprecation in doc generator (Michaël Zasso) [#37267](https://github.com/nodejs/node/pull/37267)
+* [[`981659c7b9`](https://github.com/nodejs/node/commit/981659c7b9)] - **tools**: add GitHub Action linter for pr-url (Antoine du Hamel) [#37221](https://github.com/nodejs/node/pull/37221)
+* [[`2e5994dcd8`](https://github.com/nodejs/node/commit/2e5994dcd8)] - **tools**: remove commented code from stability.js (Colin Ihrig) [#37092](https://github.com/nodejs/node/pull/37092)
+* [[`ef1aab1239`](https://github.com/nodejs/node/commit/ef1aab1239)] - **tools**: add support for top-level await syntax in linter (Antoine du Hamel) [#36911](https://github.com/nodejs/node/pull/36911)
+* [[`aef769745b`](https://github.com/nodejs/node/commit/aef769745b)] - **tools**: update doc tool dependencies (Michaël Zasso) [#36844](https://github.com/nodejs/node/pull/36844)
+* [[`dd10afc45a`](https://github.com/nodejs/node/commit/dd10afc45a)] - **tools**: revise install.py for minor improvements (Rich Trott) [#36626](https://github.com/nodejs/node/pull/36626)
+* [[`d85ea61c7e`](https://github.com/nodejs/node/commit/d85ea61c7e)] - **tools**: correct usage message for genv8constants.py (Rich Trott) [#36606](https://github.com/nodejs/node/pull/36606)
+* [[`9990ec7423`](https://github.com/nodejs/node/commit/9990ec7423)] - **tools**: call close() explicitly in genv8constants.py (Rich Trott) [#36606](https://github.com/nodejs/node/pull/36606)
+* [[`26d5965c77`](https://github.com/nodejs/node/commit/26d5965c77)] - **tools**: use `is None` consistently in Python (Rich Trott) [#36606](https://github.com/nodejs/node/pull/36606)
+* [[`bb07a767c0`](https://github.com/nodejs/node/commit/bb07a767c0)] - **tools**: revise line in configure.py for clarity (Rich Trott) [#36551](https://github.com/nodejs/node/pull/36551)
+* [[`5ac21bceba`](https://github.com/nodejs/node/commit/5ac21bceba)] - **tools**: fix make-v8.sh (Richard Lau) [#36594](https://github.com/nodejs/node/pull/36594)
+* [[`3cac041b97`](https://github.com/nodejs/node/commit/3cac041b97)] - **tools**: fix release script sign function (Antoine du Hamel) [#36556](https://github.com/nodejs/node/pull/36556)
+* [[`b398e4044c`](https://github.com/nodejs/node/commit/b398e4044c)] - **tools**: fix update-eslint.sh (Yongsheng Zhang) [#36579](https://github.com/nodejs/node/pull/36579)
+* [[`471da7dc88`](https://github.com/nodejs/node/commit/471da7dc88)] - **tools**: fix release script (Antoine du Hamel) [#36540](https://github.com/nodejs/node/pull/36540)
+* [[`1f3c129f05`](https://github.com/nodejs/node/commit/1f3c129f05)] - **tools**: remove unused variable in configure.py (Rich Trott) [#36525](https://github.com/nodejs/node/pull/36525)
+* [[`9b13ddc6a6`](https://github.com/nodejs/node/commit/9b13ddc6a6)] - **tools**: lint shell scripts (Antoine du Hamel) [#36099](https://github.com/nodejs/node/pull/36099)
+* [[`7ac8ab8e26`](https://github.com/nodejs/node/commit/7ac8ab8e26)] - **tools**: update doc tool dependencies (Michaël Zasso) [#36407](https://github.com/nodejs/node/pull/36407)
+* [[`e8b2c776f7`](https://github.com/nodejs/node/commit/e8b2c776f7)] - **tools**: upgrade to @babel/eslint-parser 7.12.1 (Antoine du Hamel) [#36321](https://github.com/nodejs/node/pull/36321)
+* [[`a0339101ba`](https://github.com/nodejs/node/commit/a0339101ba)] - **tools**: remove bashisms from macOS release scripts (Antoine du Hamel) [#36121](https://github.com/nodejs/node/pull/36121)
+* [[`9434bb3cfd`](https://github.com/nodejs/node/commit/9434bb3cfd)] - **tools**: remove bashisms from release script (Antoine du Hamel) [#36123](https://github.com/nodejs/node/pull/36123)
+* [[`2183a2be51`](https://github.com/nodejs/node/commit/2183a2be51)] - **tools**: update stability index linking logic (Rich Trott) [#36280](https://github.com/nodejs/node/pull/36280)
+* [[`2677fe9dcb`](https://github.com/nodejs/node/commit/2677fe9dcb)] - **tools**: update highlight.js to 10.1.2 (Myles Borins) [#36309](https://github.com/nodejs/node/pull/36309)
+* [[`17f942ffc0`](https://github.com/nodejs/node/commit/17f942ffc0)] - **tools**: fix undeclared identifier FALSE (Antoine du Hamel) [#36276](https://github.com/nodejs/node/pull/36276)
+* [[`4bb5c10915`](https://github.com/nodejs/node/commit/4bb5c10915)] - **tools**: cleanup old ICU version-specific fixes (Michaël Zasso) [#36980](https://github.com/nodejs/node/pull/36980)
+* [[`77f32ee8f7`](https://github.com/nodejs/node/commit/77f32ee8f7)] - **tools**: fix md5 hash for ICU 68.1 src (Richard Lau) [#36777](https://github.com/nodejs/node/pull/36777)
+* [[`5d29781491`](https://github.com/nodejs/node/commit/5d29781491)] - **tools**: add msvc /P output to .gitignore (Jiawen Geng) [#35735](https://github.com/nodejs/node/pull/35735)
+* [[`571afd3c30`](https://github.com/nodejs/node/commit/571afd3c30)] - **tools,doc**: add "legacy" badge in the TOC (Antoine du Hamel) [#37949](https://github.com/nodejs/node/pull/37949)
+* [[`15d66fbc0c`](https://github.com/nodejs/node/commit/15d66fbc0c)] - **tools,doc**: list the stability status of each API (Zijian Liu) [#36223](https://github.com/nodejs/node/pull/36223)
+* [[`d89d55ab36`](https://github.com/nodejs/node/commit/d89d55ab36)] - **tty**: validate file descriptor to avoid int32 overflow (Antoine du Hamel) [#37809](https://github.com/nodejs/node/pull/37809)
+* [[`face4b86dd`](https://github.com/nodejs/node/commit/face4b86dd)] - **typings**: add JSDoc to os module functions (David Brownman) [#38197](https://github.com/nodejs/node/pull/38197)
+* [[`599434a61d`](https://github.com/nodejs/node/commit/599434a61d)] - **typings**: add JSDoc Types to lib/querystring (Simon Knott) [#38185](https://github.com/nodejs/node/pull/38185)
+* [[`60c7591af2`](https://github.com/nodejs/node/commit/60c7591af2)] - **typings**: add JSDoc typings for http (Voltrex) [#38191](https://github.com/nodejs/node/pull/38191)
+* [[`530e69e145`](https://github.com/nodejs/node/commit/530e69e145)] - **typings**: add JSDoc typings for assert (Voltrex) [#38188](https://github.com/nodejs/node/pull/38188)
+* [[`e2c2f2b7a5`](https://github.com/nodejs/node/commit/e2c2f2b7a5)] - **typings**: add JSDoc types to lib/path (Simon Knott) [#38186](https://github.com/nodejs/node/pull/38186)
+* [[`d13fc6ed68`](https://github.com/nodejs/node/commit/d13fc6ed68)] - **url**: align url format behavior with browsers (ZiJian Liu) [#36903](https://github.com/nodejs/node/pull/36903)
+* [[`2aff77f358`](https://github.com/nodejs/node/commit/2aff77f358)] - **url**: fix url.format with ipv6 hostname (ZiJian Liu) [#36665](https://github.com/nodejs/node/pull/36665)
+* [[`08a6d9effd`](https://github.com/nodejs/node/commit/08a6d9effd)] - **(SEMVER-MINOR)** **util**: add getSystemErrorMap() impl (eladkeyshawn) [#38101](https://github.com/nodejs/node/pull/38101)
+* [[`e6c64bf0c7`](https://github.com/nodejs/node/commit/e6c64bf0c7)] - **util**: remove unreachable inspect code (Rich Trott) [#37941](https://github.com/nodejs/node/pull/37941)
+* [[`b5c5bd1f51`](https://github.com/nodejs/node/commit/b5c5bd1f51)] - **util**: inspect \_\_proto\_\_ key as written in object literal (Anna Henningsen) [#37713](https://github.com/nodejs/node/pull/37713)
+* [[`2bfe185c3f`](https://github.com/nodejs/node/commit/2bfe185c3f)] - **util**: use assert for unreachable code (Rich Trott) [#37249](https://github.com/nodejs/node/pull/37249)
+* [[`ba4788dd9f`](https://github.com/nodejs/node/commit/ba4788dd9f)] - **(SEMVER-MINOR)** **v8**: fix native `serdes` constructors (ExE Boss) [#36549](https://github.com/nodejs/node/pull/36549)
+* [[`16606d05b7`](https://github.com/nodejs/node/commit/16606d05b7)] - **vm**: add `SafeForTerminationScope`s for SIGINT interruptions (Anna Henningsen) [#36344](https://github.com/nodejs/node/pull/36344)
+* [[`b6f4d790d3`](https://github.com/nodejs/node/commit/b6f4d790d3)] - **worker**: fix exit code for error thrown in handler (Nitzan Uziely) [#38012](https://github.com/nodejs/node/pull/38012)
+* [[`9460f2cd83`](https://github.com/nodejs/node/commit/9460f2cd83)] - **(SEMVER-MINOR)** **worker**: add eventLoopUtilization() (Trevor Norris) [#35664](https://github.com/nodejs/node/pull/35664)
+* [[`78ad8b4c44`](https://github.com/nodejs/node/commit/78ad8b4c44)] - **workers**: fix spawning from preload scripts (James M Snell) [#37481](https://github.com/nodejs/node/pull/37481)
+
+<a id="14.16.1"></a>
+## 2021-04-06, Version 14.16.1 'Fermium' (LTS), @mylesborins
+
+This is a security release.
+
+### Notable Changes
+
+Vulnerabilities fixed:
+
+* **CVE-2021-3450**: OpenSSL - CA certificate check bypass with X509_V_FLAG_X509_STRICT (High)
+  * This is a vulnerability in OpenSSL which may be exploited through Node.js. You can read more about it in https://www.openssl.org/news/secadv/20210325.txt
+  * Impacts:
+    * All versions of the 15.x, 14.x, 12.x and 10.x releases lines
+* **CVE-2021-3449**: OpenSSL - NULL pointer deref in signature_algorithms processing (High)
+  * This is a vulnerability in OpenSSL which may be exploited through Node.js. You can read more about it in https://www.openssl.org/news/secadv/20210325.txt
+  * Impacts:
+    * All versions of the 15.x, 14.x, 12.x and 10.x releases lines
+* **CVE-2020-7774**: npm upgrade - Update y18n to fix Prototype-Pollution (High)
+  * This is a vulnerability in the y18n npm module which may be exploited by prototype pollution. You can read more about it in https://github.com/advisories/GHSA-c4w7-xm78-47vh
+  * Impacts:
+    * All versions of the 14.x, 12.x and 10.x releases lines
+
+### Commits
+
+* [[`467be7a950`](https://github.com/nodejs/node/commit/467be7a950)] - **deps**: upgrade npm to 6.14.12 (Ruy Adorno) [#37918](https://github.com/nodejs/node/pull/37918)
+* [[`6bc8f58182`](https://github.com/nodejs/node/commit/6bc8f58182)] - **deps**: update archs files for OpenSSL-1.1.1k (Tobias Nießen) [#37938](https://github.com/nodejs/node/pull/37938)
+* [[`403a014ef6`](https://github.com/nodejs/node/commit/403a014ef6)] - **deps**: upgrade openssl sources to 1.1.1k (Tobias Nießen) [#37938](https://github.com/nodejs/node/pull/37938)
+
+<a id="14.16.0"></a>
+## 2021-02-23, Version 14.16.0 'Fermium' (LTS), @BethGriggs
+
+This is a security release.
+
+### Notable changes
+
+Vulnerabilities fixed:
+
+* **CVE-2021-22883**: HTTP2 'unknownProtocol' cause Denial of Service by resource exhaustion
+  * Affected Node.js versions are vulnerable to denial of service attacks when too many connection attempts with an 'unknownProtocol' are established. This leads to a leak of file descriptors. If a file descriptor limit is configured on the system, then the server is unable to accept new connections and prevent the process also from opening, e.g. a file. If no file descriptor limit is configured, then this lead to an excessive memory usage and cause the system to run out of memory.
+* **CVE-2021-22884**: DNS rebinding in --inspect
+  * Affected Node.js versions are vulnerable to denial of service attacks when the whitelist includes “localhost6”. When “localhost6” is not present in /etc/hosts, it is just an ordinary domain that is resolved via DNS, i.e., over network. If the attacker controls the victim's DNS server or can spoof its responses, the DNS rebinding protection can be bypassed by using the “localhost6” domain. As long as the attacker uses the “localhost6” domain, they can still apply the attack described in CVE-2018-7160.
+* **CVE-2021-23840**: OpenSSL - Integer overflow in CipherUpdate
+  * This is a vulnerability in OpenSSL which may be exploited through Node.js. You can read more about it in https://www.openssl.org/news/secadv/20210216.txt
+
+### Commits
+
+* [[`313d26800c`](https://github.com/nodejs/node/commit/313d26800c)] - **deps**: update archs files for OpenSSL-1.1.1j (Daniel Bevenius) [#37412](https://github.com/nodejs/node/pull/37412)
+* [[`6098012b48`](https://github.com/nodejs/node/commit/6098012b48)] - **deps**: upgrade openssl sources to 1.1.1j (Daniel Bevenius) [#37412](https://github.com/nodejs/node/pull/37412)
+* [[`afea10b097`](https://github.com/nodejs/node/commit/afea10b097)] - **(SEMVER-MINOR)** **http2**: add unknownProtocol timeout (Daniel Bevenius) [nodejs-private/node-private#246](https://github.com/nodejs-private/node-private/pull/246)
+* [[`1ca3f5abcb`](https://github.com/nodejs/node/commit/1ca3f5abcb)] - **src**: drop localhost6 as allowed host for inspector (Matteo Collina) [nodejs-private/node-private#244](https://github.com/nodejs-private/node-private/pull/244)
+
+<a id="14.15.5"></a>
+## 2021-02-09, Version 14.15.5 'Fermium' (LTS), @BethGriggs
+
+### Notable Changes
+
+* **deps**:
+  * upgrade npm to 6.14.11 (Ruy Adorno) [#37173](https://github.com/nodejs/node/pull/37173)
+  * V8: backport dfcf1e86fac0 (Michaël Zasso) [#37245](https://github.com/nodejs/node/pull/37245)
+    * **Note**: Node.js is not believed to be vulnerable to CVE-2021-21148.
+* **stream,zlib**: do not use \_stream\_\* anymore (Matteo Collina) [#36618](https://github.com/nodejs/node/pull/36618)
+
+### Commits
+
+* [[`20b1e6c802`](https://github.com/nodejs/node/commit/20b1e6c802)] - **deps**: V8: backport dfcf1e86fac0 (Michaël Zasso) [#37245](https://github.com/nodejs/node/pull/37245)
+* [[`408c7a65f3`](https://github.com/nodejs/node/commit/408c7a65f3)] - **deps**: upgrade npm to 6.14.11 (Ruy Adorno) [#37173](https://github.com/nodejs/node/pull/37173)
+* [[`017eed665b`](https://github.com/nodejs/node/commit/017eed665b)] - **http**: do not loop over prototype in Agent (Michaël Zasso) [#36410](https://github.com/nodejs/node/pull/36410)
+* [[`25a3204fe2`](https://github.com/nodejs/node/commit/25a3204fe2)] - **http**: don't cork .end when not needed (Dimitris Halatsis) [#36633](https://github.com/nodejs/node/pull/36633)
+* [[`2a1e4e9244`](https://github.com/nodejs/node/commit/2a1e4e9244)] - **stream**: accept iterable as a valid first argument (ZiJian Liu) [#36479](https://github.com/nodejs/node/pull/36479)
+* [[`9ff73fcdbe`](https://github.com/nodejs/node/commit/9ff73fcdbe)] - **stream,zlib**: do not use \_stream\_\* anymore (Matteo Collina) [#36618](https://github.com/nodejs/node/pull/36618)
+* [[`c03cddb46f`](https://github.com/nodejs/node/commit/c03cddb46f)] - **test**: http complete response after socket double end (Dimitris Halatsis) [#36633](https://github.com/nodejs/node/pull/36633)
+* [[`f206505e9d`](https://github.com/nodejs/node/commit/f206505e9d)] - **util**: fix instanceof checks with null prototypes during inspection (Ruben Bridgewater) [#36178](https://github.com/nodejs/node/pull/36178)
+* [[`2f7944b18b`](https://github.com/nodejs/node/commit/2f7944b18b)] - **util**: fix module prefixes during inspection (Ruben Bridgewater) [#36178](https://github.com/nodejs/node/pull/36178)
+
+<a id="14.15.4"></a>
+## 2021-01-04, Version 14.15.4 'Fermium' (LTS), @BethGriggs
+
+This is a security release.
+
+### Notable Changes
+
+Vulnerabilities fixed:
+
+* **CVE-2020-1971**: OpenSSL - EDIPARTYNAME NULL pointer de-reference (High)
+  * This is a vulnerability in OpenSSL which may be exploited through
+  Node.js. You can read more about it in
+  https://www.openssl.org/news/secadv/20201208.txt
+
+* **CVE-2020-8265**: use-after-free in TLSWrap (High)
+  * Affected Node.js versions are vulnerable to a use-after-free bug in
+  its TLS implementation. When writing to a TLS enabled socket,
+  node::StreamBase::Write calls node::TLSWrap::DoWrite with a freshly
+  allocated WriteWrap object as first argument. If the DoWrite method
+  does not return an error, this object is passed back to the caller as
+  part of a StreamWriteResult structure. This may be exploited to
+  corrupt memory leading to a Denial of Service or potentially other
+  exploits.
+
+* **CVE-2020-8287**: HTTP Request Smuggling in nodejs (Low)
+  * Affected versions of Node.js allow two copies of a header field in
+  a http request. For example, two Transfer-Encoding header fields. In
+  this case Node.js identifies the first header field and ignores the
+  second. This can lead to HTTP Request Smuggling
+  (https://cwe.mitre.org/data/definitions/444.html).
+
+### Commits
+
+* [[`305c0f4977`](https://github.com/nodejs/node/commit/305c0f4977)] - **deps**: upgrade npm to 6.14.10 (Ruy Adorno) [#36571](https://github.com/nodejs/node/pull/36571)
+* [[`d62c650f75`](https://github.com/nodejs/node/commit/d62c650f75)] - **deps**: update archs files for OpenSSL-1.1.1i (Myles Borins) [#36521](https://github.com/nodejs/node/pull/36521)
+* [[`2de2672eb5`](https://github.com/nodejs/node/commit/2de2672eb5)] - **deps**: upgrade openssl sources to 1.1.1i (Myles Borins) [#36521](https://github.com/nodejs/node/pull/36521)
+* [[`7ecac8143f`](https://github.com/nodejs/node/commit/7ecac8143f)] - **http**: add test for http transfer encoding smuggling (Matteo Collina) [nodejs-private/node-private#228](https://github.com/nodejs-private/node-private/pull/228)
+* [[`641f786bb1`](https://github.com/nodejs/node/commit/641f786bb1)] - **http**: unset `F_CHUNKED` on new `Transfer-Encoding` (Matteo Collina) [nodejs-private/node-private#228](https://github.com/nodejs-private/node-private/pull/228)
+* [[`4f8772f9b7`](https://github.com/nodejs/node/commit/4f8772f9b7)] - **src**: retain pointers to WriteWrap/ShutdownWrap (James M Snell) [nodejs-private/node-private#23](https://github.com/nodejs-private/node-private/pull/23)
+
+<a id="14.15.3"></a>
+## 2020-12-17, Version 14.15.3 'Fermium' (LTS), @BethGriggs
+
+### Notable Changes
+
+Node.js v14.15.2 included a commit that has caused reported breakages when cloning request objects. This release reverts the commit that introduced the behaviour change. See https://github.com/nodejs/node/issues/36550 for more details.
+
+### Commits
+
+* [[`4264d9aa67`](https://github.com/nodejs/node/commit/4264d9aa67)] - ***Revert*** "**http**: lazy create IncomingMessage.headers" (Beth Griggs) [#36553](https://github.com/nodejs/node/pull/36553)
+
+<a id="14.15.2"></a>
+## 2020-12-15, Version 14.15.2 'Fermium' (LTS), @BethGriggs
+
+### Notable Changes
+
+* **deps**:
+  * upgrade npm to 6.14.9 (Myles Borins) [#36450](https://github.com/nodejs/node/pull/36450)
+  * update acorn to v8.0.4 (Michaël Zasso) [#35791](https://github.com/nodejs/node/pull/35791)
+* **doc**: add release key for Danielle Adams (Danielle Adams) [#35545](https://github.com/nodejs/node/pull/35545)
+* **http2**: check write not scheduled in scope destructor (David Halls) [#36241](https://github.com/nodejs/node/pull/36241)
+* **stream**: fix regression on duplex end (Momtchil Momtchev) [#35941](https://github.com/nodejs/node/pull/35941)
+
+### Commits
+
+* [[`c508bfc66b`](https://github.com/nodejs/node/commit/c508bfc66b)] - **assert**: refactor to use more primordials (Antoine du Hamel) [#35998](https://github.com/nodejs/node/pull/35998)
+* [[`a9d3a0df29`](https://github.com/nodejs/node/commit/a9d3a0df29)] - **assert,repl**: enable ecmaVersion 2021 in acorn parser (Michaël Zasso) [#35827](https://github.com/nodejs/node/pull/35827)
+* [[`6d43c8dd69`](https://github.com/nodejs/node/commit/6d43c8dd69)] - **async_hooks**: refactor to use more primordials (Antoine du Hamel) [#36168](https://github.com/nodejs/node/pull/36168)
+* [[`029ea16a24`](https://github.com/nodejs/node/commit/029ea16a24)] - **async_hooks**: fix leak in AsyncLocalStorage exit (Stephen Belanger) [#35779](https://github.com/nodejs/node/pull/35779)
+* [[`d49e0ca73a`](https://github.com/nodejs/node/commit/d49e0ca73a)] - **benchmark**: fix build warnings (Gabriel Schulhof) [#36157](https://github.com/nodejs/node/pull/36157)
+* [[`d027be0551`](https://github.com/nodejs/node/commit/d027be0551)] - **benchmark**: ignore build artifacts for napi addons (Richard Lau) [#35970](https://github.com/nodejs/node/pull/35970)
+* [[`fdb1c0d31c`](https://github.com/nodejs/node/commit/fdb1c0d31c)] - **benchmark**: remove modules that require intl (Richard Lau) [#35968](https://github.com/nodejs/node/pull/35968)
+* [[`f6487960b5`](https://github.com/nodejs/node/commit/f6487960b5)] - **benchmark**: make the benchmark tool work with Node 10 (Joyee Cheung) [#35817](https://github.com/nodejs/node/pull/35817)
+* [[`21d3ccf5df`](https://github.com/nodejs/node/commit/21d3ccf5df)] - **benchmark**: add startup benchmark for loading public modules (Joyee Cheung) [#35816](https://github.com/nodejs/node/pull/35816)
+* [[`0477e000bf`](https://github.com/nodejs/node/commit/0477e000bf)] - **bootstrap**: refactor to use more primordials (Antoine du Hamel) [#35999](https://github.com/nodejs/node/pull/35999)
+* [[`699bb348d9`](https://github.com/nodejs/node/commit/699bb348d9)] - **build**: replace which with command -v (raisinten) [#36118](https://github.com/nodejs/node/pull/36118)
+* [[`304e269001`](https://github.com/nodejs/node/commit/304e269001)] - **build**: try “python3” as a last resort for 3.x (Ole André Vadla Ravnås) [#35983](https://github.com/nodejs/node/pull/35983)
+* [[`6bafe04911`](https://github.com/nodejs/node/commit/6bafe04911)] - **build**: conditionally clear vcinstalldir (Brian Ingenito) [#36009](https://github.com/nodejs/node/pull/36009)
+* [[`f498127c41`](https://github.com/nodejs/node/commit/f498127c41)] - **build**: fix zlib inlining for IA-32 (raisinten) [#35679](https://github.com/nodejs/node/pull/35679)
+* [[`f33fa264cc`](https://github.com/nodejs/node/commit/f33fa264cc)] - **build**: fix lint-js-fix target (Antoine du Hamel) [#35927](https://github.com/nodejs/node/pull/35927)
+* [[`67d31827ac`](https://github.com/nodejs/node/commit/67d31827ac)] - **build**: add vcbuilt test-doc target (Antoine du Hamel) [#35708](https://github.com/nodejs/node/pull/35708)
+* [[`2a8c2ddcb1`](https://github.com/nodejs/node/commit/2a8c2ddcb1)] - **build**: add license-builder GitHub Action (Tierney Cyren) [#35712](https://github.com/nodejs/node/pull/35712)
+* [[`6c61b9372b`](https://github.com/nodejs/node/commit/6c61b9372b)] - **build**: use make functions instead of echo (Antoine du Hamel) [#35707](https://github.com/nodejs/node/pull/35707)
+* [[`4813d913e3`](https://github.com/nodejs/node/commit/4813d913e3)] - **build**: use GITHUB\_ENV file to set env variables (Michaël Zasso) [#35638](https://github.com/nodejs/node/pull/35638)
+* [[`71e0f33751`](https://github.com/nodejs/node/commit/71e0f33751)] - **build**: do not install jq in workflows (Michaël Zasso) [#35638](https://github.com/nodejs/node/pull/35638)
+* [[`8ab7f258d4`](https://github.com/nodejs/node/commit/8ab7f258d4)] - **build, tools**: look for local installation of NASM (Richard Lau) [#36014](https://github.com/nodejs/node/pull/36014)
+* [[`50552facb7`](https://github.com/nodejs/node/commit/50552facb7)] - **build,tools**: gitHub Actions: use Node.js Fermium (Antoine du Hamel) [#35840](https://github.com/nodejs/node/pull/35840)
+* [[`77b7c985f6`](https://github.com/nodejs/node/commit/77b7c985f6)] - **build,tools**: add lint-js-doc target (Antoine du Hamel) [#35708](https://github.com/nodejs/node/pull/35708)
+* [[`929e1272ee`](https://github.com/nodejs/node/commit/929e1272ee)] - **cluster**: refactor to use more primordials (Antoine du Hamel) [#36011](https://github.com/nodejs/node/pull/36011)
+* [[`568e6177c9`](https://github.com/nodejs/node/commit/568e6177c9)] - **console**: use more primordials (Antoine du Hamel) [#35734](https://github.com/nodejs/node/pull/35734)
+* [[`6cea3152fe`](https://github.com/nodejs/node/commit/6cea3152fe)] - **deps**: upgrade npm to 6.14.9 (Myles Borins) [#36450](https://github.com/nodejs/node/pull/36450)
+* [[`d2ee676eb9`](https://github.com/nodejs/node/commit/d2ee676eb9)] - **deps**: cherry-pick 9a49b22 from V8 upstream (Daniel Bevenius) [#35939](https://github.com/nodejs/node/pull/35939)
+* [[`7367e6c6be`](https://github.com/nodejs/node/commit/7367e6c6be)] - **deps**: update acorn to v8.0.4 (Michaël Zasso) [#35791](https://github.com/nodejs/node/pull/35791)
+* [[`4937a34be6`](https://github.com/nodejs/node/commit/4937a34be6)] - **deps**: fix typo in zlib.gyp that break arm-fpu-neon build (lucasg) [#35659](https://github.com/nodejs/node/pull/35659)
+* [[`1e8dfb9d2c`](https://github.com/nodejs/node/commit/1e8dfb9d2c)] - **deps**: upgrade to cjs-module-lexer@1.0.0 (Guy Bedford) [#35928](https://github.com/nodejs/node/pull/35928)
+* [[`0356963f0e`](https://github.com/nodejs/node/commit/0356963f0e)] - **deps**: update to cjs-module-lexer@0.5.2 (Guy Bedford) [#35901](https://github.com/nodejs/node/pull/35901)
+* [[`172be4ffe0`](https://github.com/nodejs/node/commit/172be4ffe0)] - **deps**: upgrade to cjs-module-lexer@0.5.0 (Guy Bedford) [#35871](https://github.com/nodejs/node/pull/35871)
+* [[`1f7740691d`](https://github.com/nodejs/node/commit/1f7740691d)] - **deps**: update to cjs-module-lexer@0.4.3 (Guy Bedford) [#35745](https://github.com/nodejs/node/pull/35745)
+* [[`47bd445e56`](https://github.com/nodejs/node/commit/47bd445e56)] - **doc**: remove stray comma in url.md (Rich Trott) [#36175](https://github.com/nodejs/node/pull/36175)
+* [[`2f76a75fc6`](https://github.com/nodejs/node/commit/2f76a75fc6)] - **doc**: revise agent.destroy() text (Rich Trott) [#36163](https://github.com/nodejs/node/pull/36163)
+* [[`72fb6f88ab`](https://github.com/nodejs/node/commit/72fb6f88ab)] - **doc**: add compatibility/interop technical value (Geoffrey Booth) [#35323](https://github.com/nodejs/node/pull/35323)
+* [[`f5efd54727`](https://github.com/nodejs/node/commit/f5efd54727)] - **doc**: de-emphasize wrapping in napi\_define\_class (Gabriel Schulhof) [#36159](https://github.com/nodejs/node/pull/36159)
+* [[`8a7c2b951d`](https://github.com/nodejs/node/commit/8a7c2b951d)] - **doc**: clarify text about process not responding (Rich Trott) [#36117](https://github.com/nodejs/node/pull/36117)
+* [[`800e1db83d`](https://github.com/nodejs/node/commit/800e1db83d)] - **doc**: esm docs consolidation and reordering (Guy Bedford) [#36046](https://github.com/nodejs/node/pull/36046)
+* [[`4fad888fe1`](https://github.com/nodejs/node/commit/4fad888fe1)] - **doc**: move shigeki to emeritus (Rich Trott) [#36093](https://github.com/nodejs/node/pull/36093)
+* [[`c088434b4d`](https://github.com/nodejs/node/commit/c088434b4d)] - **doc**: document the error when cwd not exists in child\_process.spawn (FeelyChau) [#34505](https://github.com/nodejs/node/pull/34505)
+* [[`4dbbbaa2e9`](https://github.com/nodejs/node/commit/4dbbbaa2e9)] - **doc**: fix typo in debugger.md (Rich Trott) [#36066](https://github.com/nodejs/node/pull/36066)
+* [[`d796bc7348`](https://github.com/nodejs/node/commit/d796bc7348)] - **doc**: update list styles for remark-parse@9 rendering (Rich Trott) [#36049](https://github.com/nodejs/node/pull/36049)
+* [[`6daf204f32`](https://github.com/nodejs/node/commit/6daf204f32)] - **doc**: escape asterisk in cctest gtest-filter (raisinten) [#36034](https://github.com/nodejs/node/pull/36034)
+* [[`9470bf5872`](https://github.com/nodejs/node/commit/9470bf5872)] - **doc**: move v8.getHeapCodeStatistics() (Rich Trott) [#36027](https://github.com/nodejs/node/pull/36027)
+* [[`30cd797c15`](https://github.com/nodejs/node/commit/30cd797c15)] - **doc**: add note regarding file structure in src/README.md (Denys Otrishko) [#35000](https://github.com/nodejs/node/pull/35000)
+* [[`cddcfcde9f`](https://github.com/nodejs/node/commit/cddcfcde9f)] - **doc**: advise users to import the full set of trusted release keys (Reşat SABIQ) [#32655](https://github.com/nodejs/node/pull/32655)
+* [[`1ca1f262a5`](https://github.com/nodejs/node/commit/1ca1f262a5)] - **doc**: fix crypto doc linter errors (Antoine du Hamel) [#36035](https://github.com/nodejs/node/pull/36035)
+* [[`b11725eb9e`](https://github.com/nodejs/node/commit/b11725eb9e)] - **doc**: revise v8.getHeapSnapshot() (Rich Trott) [#35849](https://github.com/nodejs/node/pull/35849)
+* [[`990facbc3e`](https://github.com/nodejs/node/commit/990facbc3e)] - **doc**: update core-validate-commit link in guide (Daijiro Wachi) [#35938](https://github.com/nodejs/node/pull/35938)
+* [[`773685c2a4`](https://github.com/nodejs/node/commit/773685c2a4)] - **doc**: update benchmark CI test indicator in README (Rich Trott) [#35945](https://github.com/nodejs/node/pull/35945)
+* [[`c90571ff2a`](https://github.com/nodejs/node/commit/c90571ff2a)] - **doc**: add new wordings to the API description (Pooja D.P) [#35588](https://github.com/nodejs/node/pull/35588)
+* [[`6259c2d231`](https://github.com/nodejs/node/commit/6259c2d231)] - **doc**: option --prof documentation help added (krank2me) [#34991](https://github.com/nodejs/node/pull/34991)
+* [[`98e4b77b89`](https://github.com/nodejs/node/commit/98e4b77b89)] - **doc**: fix release-schedule link in backport guide (Daijiro Wachi) [#35920](https://github.com/nodejs/node/pull/35920)
+* [[`51ce1a2fa8`](https://github.com/nodejs/node/commit/51ce1a2fa8)] - **doc**: update tables in README files for linting changes (Rich Trott) [#35905](https://github.com/nodejs/node/pull/35905)
+* [[`513bed2776`](https://github.com/nodejs/node/commit/513bed2776)] - **doc**: temporarily disable list-item-bullet-indent (Nick Schonning) [#35647](https://github.com/nodejs/node/pull/35647)
+* [[`733c9da1e9`](https://github.com/nodejs/node/commit/733c9da1e9)] - **doc**: disable no-undefined-references workarounds (Nick Schonning) [#35647](https://github.com/nodejs/node/pull/35647)
+* [[`6e1612fa15`](https://github.com/nodejs/node/commit/6e1612fa15)] - **doc**: adjust table alignment for remark v13 (Nick Schonning) [#35647](https://github.com/nodejs/node/pull/35647)
+* [[`a15dede26d`](https://github.com/nodejs/node/commit/a15dede26d)] - **doc**: move bnoordhuis to emeritus (Ben Noordhuis) [#35865](https://github.com/nodejs/node/pull/35865)
+* [[`26e42939f2`](https://github.com/nodejs/node/commit/26e42939f2)] - **doc**: add on statement in the APIs docs (Pooja D.P) [#35610](https://github.com/nodejs/node/pull/35610)
+* [[`9486f5fc37`](https://github.com/nodejs/node/commit/9486f5fc37)] - **doc**: move ronkorving to emeritus (Rich Trott) [#35828](https://github.com/nodejs/node/pull/35828)
+* [[`3f3d2d781b`](https://github.com/nodejs/node/commit/3f3d2d781b)] - **doc**: recommend test-doc instead of lint-md (Antoine du Hamel) [#35708](https://github.com/nodejs/node/pull/35708)
+* [[`8131d954d9`](https://github.com/nodejs/node/commit/8131d954d9)] - **doc**: fix reference to googletest test fixture (Tobias Nießen) [#35813](https://github.com/nodejs/node/pull/35813)
+* [[`34d6ca3bef`](https://github.com/nodejs/node/commit/34d6ca3bef)] - **doc**: add conditional example for setBreakpoint() (Chris Opperwall) [#35823](https://github.com/nodejs/node/pull/35823)
+* [[`29849743b8`](https://github.com/nodejs/node/commit/29849743b8)] - **doc**: make small improvements to REPL doc (Rich Trott) [#35808](https://github.com/nodejs/node/pull/35808)
+* [[`02f9a2a77a`](https://github.com/nodejs/node/commit/02f9a2a77a)] - **doc**: update MessagePort documentation for EventTarget inheritance (Anna Henningsen) [#35839](https://github.com/nodejs/node/pull/35839)
+* [[`9c7d4bd0f3`](https://github.com/nodejs/node/commit/9c7d4bd0f3)] - **doc**: use case-sensitive in the example (Pooja D.P) [#35624](https://github.com/nodejs/node/pull/35624)
+* [[`600cffae3c`](https://github.com/nodejs/node/commit/600cffae3c)] - **doc**: consolidate and clarify breakOnSigInt text (Rich Trott) [#35787](https://github.com/nodejs/node/pull/35787)
+* [[`0de3f564b2`](https://github.com/nodejs/node/commit/0de3f564b2)] - **doc**: add a subsystems header in pull-requests.md (Pooja D.P) [#35718](https://github.com/nodejs/node/pull/35718)
+* [[`47b4b2be29`](https://github.com/nodejs/node/commit/47b4b2be29)] - **doc**: add require statement in the example (Pooja D.P) [#35554](https://github.com/nodejs/node/pull/35554)
+* [[`77cfcba7c8`](https://github.com/nodejs/node/commit/77cfcba7c8)] - **doc**: modified memory set statement set size (Pooja D.P) [#35517](https://github.com/nodejs/node/pull/35517)
+* [[`41937f76f0`](https://github.com/nodejs/node/commit/41937f76f0)] - **doc**: use kbd element in readline doc prose (Rich Trott) [#35737](https://github.com/nodejs/node/pull/35737)
+* [[`eee62b05f6`](https://github.com/nodejs/node/commit/eee62b05f6)] - **doc**: fix header level in fs.md (ax1) [#35771](https://github.com/nodejs/node/pull/35771)
+* [[`63533d7d56`](https://github.com/nodejs/node/commit/63533d7d56)] - **doc**: remove stability warning in v8 module doc (Rich Trott) [#35774](https://github.com/nodejs/node/pull/35774)
+* [[`62bf1a63d6`](https://github.com/nodejs/node/commit/62bf1a63d6)] - **doc**: mark optional parameters in timers.md (Vse Mozhe Buty) [#35764](https://github.com/nodejs/node/pull/35764)
+* [[`4dc5e4a354`](https://github.com/nodejs/node/commit/4dc5e4a354)] - **doc**: add a example code to API doc property (Pooja D.P) [#35738](https://github.com/nodejs/node/pull/35738)
+* [[`8ef0652566`](https://github.com/nodejs/node/commit/8ef0652566)] - **doc**: update console.error example (Lee, Bonggi) [#34964](https://github.com/nodejs/node/pull/34964)
+* [[`47ba12265e`](https://github.com/nodejs/node/commit/47ba12265e)] - **doc**: improve text for breakOnSigint (Rich Trott) [#35692](https://github.com/nodejs/node/pull/35692)
+* [[`c0d9756163`](https://github.com/nodejs/node/commit/c0d9756163)] - **doc**: this prints replaced with this is printed (Pooja D.P) [#35515](https://github.com/nodejs/node/pull/35515)
+* [[`2feb86e635`](https://github.com/nodejs/node/commit/2feb86e635)] - **doc**: update package.json field definitions (Myles Borins) [#35741](https://github.com/nodejs/node/pull/35741)
+* [[`d0d67c67c0`](https://github.com/nodejs/node/commit/d0d67c67c0)] - **doc**: add Installing Node.js header in BUILDING.md (Pooja D.P) [#35710](https://github.com/nodejs/node/pull/35710)
+* [[`7c089ad04c`](https://github.com/nodejs/node/commit/7c089ad04c)] - **doc**: use kbd element in readline doc (Rich Trott) [#35698](https://github.com/nodejs/node/pull/35698)
+* [[`ba623ef35a`](https://github.com/nodejs/node/commit/ba623ef35a)] - **doc**: add release key for Danielle Adams (Danielle Adams) [#35545](https://github.com/nodejs/node/pull/35545)
+* [[`df4043bed3`](https://github.com/nodejs/node/commit/df4043bed3)] - **doc**: use kbd element in os doc (Rich Trott) [#35656](https://github.com/nodejs/node/pull/35656)
+* [[`4d72e982de`](https://github.com/nodejs/node/commit/4d72e982de)] - **doc**: add a statement in the documentation. (Pooja D.P) [#35585](https://github.com/nodejs/node/pull/35585)
+* [[`238885288d`](https://github.com/nodejs/node/commit/238885288d)] - **doc**: clarify experimental API elements in vm.md (Rich Trott) [#35594](https://github.com/nodejs/node/pull/35594)
+* [[`806a269a83`](https://github.com/nodejs/node/commit/806a269a83)] - **doc**: importModuleDynamically gets Script, not Module (Simen Bekkhus) [#35593](https://github.com/nodejs/node/pull/35593)
+* [[`6c4e697f56`](https://github.com/nodejs/node/commit/6c4e697f56)] - **doc**: fix EventEmitter examples (Sourav Shaw) [#33513](https://github.com/nodejs/node/pull/33513)
+* [[`f6ebd81693`](https://github.com/nodejs/node/commit/f6ebd81693)] - **doc**: add example code for process.getgroups() (Pooja D.P) [#35625](https://github.com/nodejs/node/pull/35625)
+* [[`2c342662e5`](https://github.com/nodejs/node/commit/2c342662e5)] - **doc**: use kbd element in tty doc (Rich Trott) [#35613](https://github.com/nodejs/node/pull/35613)
+* [[`f723335f9e`](https://github.com/nodejs/node/commit/f723335f9e)] - **doc**: remove documentation for stream.\_construct() (Luigi Pinca) [#36119](https://github.com/nodejs/node/pull/36119)
+* [[`e71b4baa88`](https://github.com/nodejs/node/commit/e71b4baa88)] - **doc**: Remove reference to io.js (Hussaina Begum Nandyala) [#35618](https://github.com/nodejs/node/pull/35618)
+* [[`4faf71b474`](https://github.com/nodejs/node/commit/4faf71b474)] - **doc,crypto**: added sign/verify method changes about dsaEncoding (Filip Skokan) [#35480](https://github.com/nodejs/node/pull/35480)
+* [[`e9d485f878`](https://github.com/nodejs/node/commit/e9d485f878)] - **doc,esm**: document experimental warning removal (Antoine du Hamel) [#35750](https://github.com/nodejs/node/pull/35750)
+* [[`17c3fc67cf`](https://github.com/nodejs/node/commit/17c3fc67cf)] - **doc,fs**: document value of stats.isDirectory on symbolic links (coderaiser) [#27413](https://github.com/nodejs/node/pull/27413)
+* [[`fc17ead531`](https://github.com/nodejs/node/commit/fc17ead531)] - **doc,net**: document socket.timeout (Brandon Kobel) [#34543](https://github.com/nodejs/node/pull/34543)
+* [[`dc589b541f`](https://github.com/nodejs/node/commit/dc589b541f)] - **doc,src,test**: revise C++ code for linter update (Rich Trott) [#35719](https://github.com/nodejs/node/pull/35719)
+* [[`0a944a42c0`](https://github.com/nodejs/node/commit/0a944a42c0)] - **doc,stream**: write(chunk, encoding, cb) encoding can be null (dev-script) [#35372](https://github.com/nodejs/node/pull/35372)
+* [[`be79250aad`](https://github.com/nodejs/node/commit/be79250aad)] - **doc,test**: update v8 method doc and comment (Rich Trott) [#35795](https://github.com/nodejs/node/pull/35795)
+* [[`8fdf077efc`](https://github.com/nodejs/node/commit/8fdf077efc)] - **doc,url**: fix url.hostname example (Rishabh Mehan) [#33735](https://github.com/nodejs/node/pull/33735)
+* [[`3a08afc402`](https://github.com/nodejs/node/commit/3a08afc402)] - **domain**: refactor to use more primordials (Antoine du Hamel) [#35885](https://github.com/nodejs/node/pull/35885)
+* [[`8d672b8e53`](https://github.com/nodejs/node/commit/8d672b8e53)] - **esm**: refactor to use more primordials (Antoine du Hamel) [#36019](https://github.com/nodejs/node/pull/36019)
+* [[`570a8bfe12`](https://github.com/nodejs/node/commit/570a8bfe12)] - **events**: port some wpt tests (Benjamin Gruenbaum) [#33621](https://github.com/nodejs/node/pull/33621)
+* [[`8ef4557c65`](https://github.com/nodejs/node/commit/8ef4557c65)] - **events**: make eventTarget.removeAllListeners() return this (Luigi Pinca) [#35805](https://github.com/nodejs/node/pull/35805)
+* [[`d27e56356b`](https://github.com/nodejs/node/commit/d27e56356b)] - **fs**: remove experimental from promises.rmdir recursive (Anders Kaseorg) [#36131](https://github.com/nodejs/node/pull/36131)
+* [[`8d84bdc46b`](https://github.com/nodejs/node/commit/8d84bdc46b)] - **fs**: filehandle read now accepts object as argument (Nikola Glavina) [#34180](https://github.com/nodejs/node/pull/34180)
+* [[`7c3b6f17e3`](https://github.com/nodejs/node/commit/7c3b6f17e3)] - **fs**: replace finally with PromisePrototypeFinally (Baruch Odem (Rothkoff)) [#35995](https://github.com/nodejs/node/pull/35995)
+* [[`2f692c4cc6`](https://github.com/nodejs/node/commit/2f692c4cc6)] - **fs**: remove unnecessary Function#bind() in fs/promises (Ben Noordhuis) [#35208](https://github.com/nodejs/node/pull/35208)
+* [[`5f0c8142b7`](https://github.com/nodejs/node/commit/5f0c8142b7)] - **fs**: remove unused assignment (Rich Trott) [#35642](https://github.com/nodejs/node/pull/35642)
+* [[`e2b8734d20`](https://github.com/nodejs/node/commit/e2b8734d20)] - **gyp,build**: consistent shared library location (Rod Vagg) [#35635](https://github.com/nodejs/node/pull/35635)
+* [[`45aee0d25e`](https://github.com/nodejs/node/commit/45aee0d25e)] - **http**: fix typo in comment (Hollow Man) [#36193](https://github.com/nodejs/node/pull/36193)
+* [[`b58725c4c0`](https://github.com/nodejs/node/commit/b58725c4c0)] - **http**: lazy create IncomingMessage.headers (Robert Nagy) [#35281](https://github.com/nodejs/node/pull/35281)
+* [[`71c3efe278`](https://github.com/nodejs/node/commit/71c3efe278)] - **http2**: check write not scheduled in scope destructor (David Halls) [#36241](https://github.com/nodejs/node/pull/36241)
+* [[`ab2b066fc1`](https://github.com/nodejs/node/commit/ab2b066fc1)] - **http2**: delay session.receive() by a tick (Szymon Marczak) [#35985](https://github.com/nodejs/node/pull/35985)
+* [[`c4e17cfa25`](https://github.com/nodejs/node/commit/c4e17cfa25)] - **http2**: add has method to proxySocketHandler (masx200) [#35197](https://github.com/nodejs/node/pull/35197)
+* [[`c455b848d9`](https://github.com/nodejs/node/commit/c455b848d9)] - **http2**: centralise socket event binding in Http2Session (Momtchil Momtchev) [#35772](https://github.com/nodejs/node/pull/35772)
+* [[`dce01fd27f`](https://github.com/nodejs/node/commit/dce01fd27f)] - **http2**: move events to the JSStreamSocket (Momtchil Momtchev) [#35772](https://github.com/nodejs/node/pull/35772)
+* [[`92bd7b522a`](https://github.com/nodejs/node/commit/92bd7b522a)] - **http2**: fix error stream write followed by destroy (David Halls) [#35951](https://github.com/nodejs/node/pull/35951)
+* [[`ec9fae96bc`](https://github.com/nodejs/node/commit/ec9fae96bc)] - **http2**: fix reinjection check (Momtchil Momtchev) [#35678](https://github.com/nodejs/node/pull/35678)
+* [[`57f2fe0609`](https://github.com/nodejs/node/commit/57f2fe0609)] - **http2**: reinject data received before http2 is attached (Momtchil Momtchev) [#35678](https://github.com/nodejs/node/pull/35678)
+* [[`2dbaaf92e5`](https://github.com/nodejs/node/commit/2dbaaf92e5)] - **http2**: remove unsupported %.\* specifier (Momtchil Momtchev) [#35694](https://github.com/nodejs/node/pull/35694)
+* [[`de3c8045ac`](https://github.com/nodejs/node/commit/de3c8045ac)] - **lib**: refactor to use more primordials (Antoine du Hamel) [#35875](https://github.com/nodejs/node/pull/35875)
+* [[`41d997cc72`](https://github.com/nodejs/node/commit/41d997cc72)] - **lib**: use primordials when calling methods of Error (Antoine du Hamel) [#35837](https://github.com/nodejs/node/pull/35837)
+* [[`d58a466da0`](https://github.com/nodejs/node/commit/d58a466da0)] - **lib**: honor setUncaughtExceptionCaptureCallback (Gireesh Punathil) [#35595](https://github.com/nodejs/node/pull/35595)
+* [[`1fdf72765b`](https://github.com/nodejs/node/commit/1fdf72765b)] - **module**: only try to enrich CJS syntax errors (Michaël Zasso) [#35691](https://github.com/nodejs/node/pull/35691)
+* [[`81b0562c62`](https://github.com/nodejs/node/commit/81b0562c62)] - **n-api**: clean up binding creation (Gabriel Schulhof) [#36170](https://github.com/nodejs/node/pull/36170)
+* [[`7a01e241ee`](https://github.com/nodejs/node/commit/7a01e241ee)] - **n-api**: fix test\_async\_context warnings (Gabriel Schulhof) [#36171](https://github.com/nodejs/node/pull/36171)
+* [[`dde727e72f`](https://github.com/nodejs/node/commit/dde727e72f)] - **n-api**: improve consistency of how we get context (Michael Dawson) [#36068](https://github.com/nodejs/node/pull/36068)
+* [[`08657e7e11`](https://github.com/nodejs/node/commit/08657e7e11)] - **n-api**: factor out calling pattern (Gabriel Schulhof) [#36113](https://github.com/nodejs/node/pull/36113)
+* [[`88aa4e0d25`](https://github.com/nodejs/node/commit/88aa4e0d25)] - **n-api**: unlink reference during its destructor (Gabriel Schulhof) [#35933](https://github.com/nodejs/node/pull/35933)
+* [[`1cb50c17d3`](https://github.com/nodejs/node/commit/1cb50c17d3)] - **n-api**: napi\_make\_callback emit async init with resource of async\_context (legendecas) [#32930](https://github.com/nodejs/node/pull/32930)
+* [[`f1e84f4dd8`](https://github.com/nodejs/node/commit/f1e84f4dd8)] - **n-api**: revert change to finalization (Michael Dawson) [#35777](https://github.com/nodejs/node/pull/35777)
+* [[`e16124979d`](https://github.com/nodejs/node/commit/e16124979d)] - **querystring**: reduce memory usage by Int8Array (sapics) [#34179](https://github.com/nodejs/node/pull/34179)
+* [[`5c81a1071e`](https://github.com/nodejs/node/commit/5c81a1071e)] - **src**: refactor using-declarations node\_env\_var.cc (raisinten) [#36128](https://github.com/nodejs/node/pull/36128)
+* [[`2770cd941e`](https://github.com/nodejs/node/commit/2770cd941e)] - **src**: remove duplicate logic for getting buffer (Yash Ladha) [#34553](https://github.com/nodejs/node/pull/34553)
+* [[`f2300390aa`](https://github.com/nodejs/node/commit/f2300390aa)] - **src**: create helper for reading Uint32BE (Juan José Arboleda) [#34944](https://github.com/nodejs/node/pull/34944)
+* [[`34c870e9f0`](https://github.com/nodejs/node/commit/34c870e9f0)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty (Daniel Bevenius) [#35716](https://github.com/nodejs/node/pull/35716)
+* [[`00d9499b14`](https://github.com/nodejs/node/commit/00d9499b14)] - **src**: large pages support in illumos/solaris systems (David Carlier) [#34320](https://github.com/nodejs/node/pull/34320)
+* [[`7c99885a9b`](https://github.com/nodejs/node/commit/7c99885a9b)] - **stream**: fix thrown object reference (Gil Pedersen) [#36065](https://github.com/nodejs/node/pull/36065)
+* [[`1cefb7e710`](https://github.com/nodejs/node/commit/1cefb7e710)] - **stream**: fix regression on duplex end (Momtchil Momtchev) [#35941](https://github.com/nodejs/node/pull/35941)
+* [[`d1fd3f27e4`](https://github.com/nodejs/node/commit/d1fd3f27e4)] - **stream**: remove redundant context from comments (Yash Ladha) [#35728](https://github.com/nodejs/node/pull/35728)
+* [[`fb14acb22c`](https://github.com/nodejs/node/commit/fb14acb22c)] - **stream**: move to internal/streams (Matteo Collina) [#35239](https://github.com/nodejs/node/pull/35239)
+* [[`40d59281f7`](https://github.com/nodejs/node/commit/40d59281f7)] - **test**: update comments in test-fs-read-offset-null (Rich Trott) [#36152](https://github.com/nodejs/node/pull/36152)
+* [[`a563f79d80`](https://github.com/nodejs/node/commit/a563f79d80)] - **test**: fix typo in inspector-helper.js (Luigi Pinca) [#36127](https://github.com/nodejs/node/pull/36127)
+* [[`3e77536c6b`](https://github.com/nodejs/node/commit/3e77536c6b)] - **test**: deflake test-http-destroyed-socket-write2 (Luigi Pinca) [#36120](https://github.com/nodejs/node/pull/36120)
+* [[`402e29a87c`](https://github.com/nodejs/node/commit/402e29a87c)] - **test**: make test-http2-client-jsstream-destroy.js reliable (Rich Trott) [#36129](https://github.com/nodejs/node/pull/36129)
+* [[`b6aa42c349`](https://github.com/nodejs/node/commit/b6aa42c349)] - **test**: add test for fs.read when offset key is null (mayank agarwal) [#35918](https://github.com/nodejs/node/pull/35918)
+* [[`8516c2ef90`](https://github.com/nodejs/node/commit/8516c2ef90)] - **test**: improve test-stream-duplex-readable-end (Luigi Pinca) [#36056](https://github.com/nodejs/node/pull/36056)
+* [[`b53068ec0d`](https://github.com/nodejs/node/commit/b53068ec0d)] - **test**: add util.inspect test for null maxStringLength (Rich Trott) [#36086](https://github.com/nodejs/node/pull/36086)
+* [[`3029872631`](https://github.com/nodejs/node/commit/3029872631)] - **test**: replace var with const (Aleksandr Krutko) [#36069](https://github.com/nodejs/node/pull/36069)
+* [[`b05cdfee64`](https://github.com/nodejs/node/commit/b05cdfee64)] - **test**: remove flaky designation for fixed test (Rich Trott) [#35961](https://github.com/nodejs/node/pull/35961)
+* [[`002005f537`](https://github.com/nodejs/node/commit/002005f537)] - **test**: improve error message for policy failures (Bradley Meck) [#35633](https://github.com/nodejs/node/pull/35633)
+* [[`1453de1381`](https://github.com/nodejs/node/commit/1453de1381)] - **test**: update old comment style test\_util.cc (raisinten) [#35884](https://github.com/nodejs/node/pull/35884)
+* [[`de375e16f4`](https://github.com/nodejs/node/commit/de375e16f4)] - **test**: add missing ref comments to parallel.status (Rich Trott) [#35896](https://github.com/nodejs/node/pull/35896)
+* [[`cab65fbe63`](https://github.com/nodejs/node/commit/cab65fbe63)] - **test**: mark test-worker-eventlooputil flaky (Myles Borins) [#35886](https://github.com/nodejs/node/pull/35886)
+* [[`4ed4b64293`](https://github.com/nodejs/node/commit/4ed4b64293)] - **test**: mark test-http2-respond-file-error-pipe-offset flaky (Myles Borins) [#35883](https://github.com/nodejs/node/pull/35883)
+* [[`a5b94180fe`](https://github.com/nodejs/node/commit/a5b94180fe)] - **test**: fix reference to WPT testharness.js (Tobias Nießen) [#35814](https://github.com/nodejs/node/pull/35814)
+* [[`3bb7f3602b`](https://github.com/nodejs/node/commit/3bb7f3602b)] - **test**: add onerror test cases to policy (Daijiro Wachi) [#35797](https://github.com/nodejs/node/pull/35797)
+* [[`0aba12218a`](https://github.com/nodejs/node/commit/0aba12218a)] - **test**: add upstream test cases to encoding (Daijiro Wachi) [#35794](https://github.com/nodejs/node/pull/35794)
+* [[`f535d6252f`](https://github.com/nodejs/node/commit/f535d6252f)] - **test**: add test for listen callback runtime binding (H Adinarayana) [#35657](https://github.com/nodejs/node/pull/35657)
+* [[`d62e72b341`](https://github.com/nodejs/node/commit/d62e72b341)] - **test**: refactor test-https-host-headers (himself65) [#32805](https://github.com/nodejs/node/pull/32805)
+* [[`70cb70812d`](https://github.com/nodejs/node/commit/70cb70812d)] - **test**: add common.mustSucceed (Tobias Nießen) [#35086](https://github.com/nodejs/node/pull/35086)
+* [[`226c1800a8`](https://github.com/nodejs/node/commit/226c1800a8)] - **test**: check for AbortController existence (James M Snell) [#35616](https://github.com/nodejs/node/pull/35616)
+* [[`41aac465cc`](https://github.com/nodejs/node/commit/41aac465cc)] - **timers**: correct explanation in comment (Turner Jabbour) [#35437](https://github.com/nodejs/node/pull/35437)
+* [[`713d1ebe75`](https://github.com/nodejs/node/commit/713d1ebe75)] - **tools**: bump unist-util-find@1.0.1 to unist-util-find@1.0.2 (Rich Trott) [#36106](https://github.com/nodejs/node/pull/36106)
+* [[`127a4fb810`](https://github.com/nodejs/node/commit/127a4fb810)] - **tools**: only use 2 cores for macos action (Myles Borins) [#36169](https://github.com/nodejs/node/pull/36169)
+* [[`75e49b833b`](https://github.com/nodejs/node/commit/75e49b833b)] - **tools**: remove bashisms from license builder script (Antoine du Hamel) [#36122](https://github.com/nodejs/node/pull/36122)
+* [[`28d6283f96`](https://github.com/nodejs/node/commit/28d6283f96)] - **tools**: hide commit queue action link (Antoine du Hamel) [#36124](https://github.com/nodejs/node/pull/36124)
+* [[`b7441ea4d2`](https://github.com/nodejs/node/commit/b7441ea4d2)] - **tools**: update doc tools to remark-parse@9.0.0 (Rich Trott) [#36049](https://github.com/nodejs/node/pull/36049)
+* [[`5a41282ef5`](https://github.com/nodejs/node/commit/5a41282ef5)] - **tools**: enforce use of single quotes in editorconfig (Antoine du Hamel) [#36020](https://github.com/nodejs/node/pull/36020)
+* [[`23dd2b00dd`](https://github.com/nodejs/node/commit/23dd2b00dd)] - **tools**: fix config serialization w/ long strings (Ole André Vadla Ravnås) [#35982](https://github.com/nodejs/node/pull/35982)
+* [[`4664681220`](https://github.com/nodejs/node/commit/4664681220)] - **tools**: don't print gold linker warning w/o flag (Myles Borins) [#35955](https://github.com/nodejs/node/pull/35955)
+* [[`dfd6ad9d99`](https://github.com/nodejs/node/commit/dfd6ad9d99)] - **tools**: refloat 7 Node.js patches to cpplint.py (Rich Trott) [#35866](https://github.com/nodejs/node/pull/35866)
+* [[`d177cb3993`](https://github.com/nodejs/node/commit/d177cb3993)] - **tools**: bump cpplint to 1.5.1 (Rich Trott) [#35866](https://github.com/nodejs/node/pull/35866)
+* [[`b19a85ed2a`](https://github.com/nodejs/node/commit/b19a85ed2a)] - **tools**: add update-npm script (Myles Borins) [#35822](https://github.com/nodejs/node/pull/35822)
+* [[`07e5d35d14`](https://github.com/nodejs/node/commit/07e5d35d14)] - **tools**: refloat 7 Node.js patches to cpplint.py (Rich Trott) [#35719](https://github.com/nodejs/node/pull/35719)
+* [[`c7301533de`](https://github.com/nodejs/node/commit/c7301533de)] - **tools**: bump cpplint to 1.5.0 (Rich Trott) [#35719](https://github.com/nodejs/node/pull/35719)
+* [[`985efdfa09`](https://github.com/nodejs/node/commit/985efdfa09)] - **tools**: update gyp-next to v0.6.2 (Michaël Zasso) [#35690](https://github.com/nodejs/node/pull/35690)
+* [[`baca8ee873`](https://github.com/nodejs/node/commit/baca8ee873)] - **tools**: update gyp-next to v0.6.0 (Ujjwal Sharma) [#35635](https://github.com/nodejs/node/pull/35635)
+* [[`3e7598da9b`](https://github.com/nodejs/node/commit/3e7598da9b)] - **tools,doc**: enable ecmaVersion 2021 in acorn parser (Antoine du Hamel) [#35994](https://github.com/nodejs/node/pull/35994)
+* [[`dfb353b882`](https://github.com/nodejs/node/commit/dfb353b882)] - **util**: fix to inspect getters that access this (raisinten) [#36052](https://github.com/nodejs/node/pull/36052)
+* [[`1906f19e49`](https://github.com/nodejs/node/commit/1906f19e49)] - **vm**: refactor to use more primordials (Antoine du Hamel) [#36023](https://github.com/nodejs/node/pull/36023)
+* [[`ffe517b40d`](https://github.com/nodejs/node/commit/ffe517b40d)] - **win, build**: fix build time on Windows (Bartosz Sosnowski) [#35932](https://github.com/nodejs/node/pull/35932)
+* [[`c4c8541621`](https://github.com/nodejs/node/commit/c4c8541621)] - **win,build,tools**: support VS prerelease (Baruch Odem) [#36033](https://github.com/nodejs/node/pull/36033)
+* [[`f59e225675`](https://github.com/nodejs/node/commit/f59e225675)] - **zlib**: test BrotliCompress throws invalid arg value (raisinten) [#35830](https://github.com/nodejs/node/pull/35830)
+
+<a id="14.15.1"></a>
+## 2020-11-16, Version 14.15.1 'Fermium' (LTS), @BethGriggs
+
+### Notable changes
+
+This is a security release.
+
+Vulnerabilities fixed:
+
+* **CVE-2020-8277**: Denial of Service through DNS request (High). A Node.js application that allows an attacker to trigger a DNS request for a host of their choice could trigger a Denial of Service by getting the application to resolve a DNS record with a larger number of responses.
+
+### Commits
+
+* [[`1fd2c8142b`](https://github.com/nodejs/node/commit/1fd2c8142b)] - **deps**: cherry-pick 0d252eb from upstream c-ares (Michael Dawson) [nodejs-private/node-private#231](https://github.com/nodejs-private/node-private/pull/231)
+
+<a id="14.15.0"></a>
+## 2020-10-27, Version 14.15.0 'Fermium' (LTS), @richardlau
+
+### Notable Changes
+
+This release marks the transition of Node.js 14.x into Long Term Support (LTS)
+with the codename 'Fermium'. The 14.x release line now moves into "Active LTS"
+and will remain so until October 2021. After that time, it will move into
+"Maintenance" until end of life in April 2023.
+
+### Commits
+
+* [[`5b7a08c902`](https://github.com/nodejs/node/commit/5b7a08c902)] - **doc**: add missing link in Node.js 14 Changelog (Antoine du Hamel) [#35782](https://github.com/nodejs/node/pull/35782)
+* [[`90a5d59824`](https://github.com/nodejs/node/commit/90a5d59824)] - **doc**: fix Node.js 14.x changelogs (Richard Lau) [#35756](https://github.com/nodejs/node/pull/35756)
+* [[`7f788573b3`](https://github.com/nodejs/node/commit/7f788573b3)] - ***Revert*** "**test**: mark test-webcrypto-encrypt-decrypt-aes flaky" (Myles Borins) [#35666](https://github.com/nodejs/node/pull/35666)
+
+<a id="14.14.0"></a>
+## 2020-10-15, Version 14.14.0 (Current), @MylesBorins
+
+### Notable Changes
+
+* [[`7e7afc5186`](https://github.com/nodejs/node/commit/7e7afc5186)] - **crypto**: update certdata to NSS 3.56 (Shelley Vohr) [#35546](https://github.com/nodejs/node/pull/35546)
+* [[`8877430530`](https://github.com/nodejs/node/commit/8877430530)] - **doc**: add aduh95 to collaborators (Antoine du Hamel) [#35542](https://github.com/nodejs/node/pull/35542)
+* [[`1610728d7c`](https://github.com/nodejs/node/commit/1610728d7c)] - **(SEMVER-MINOR)** **fs**: add rm method (Ian Sutherland) [#35494](https://github.com/nodejs/node/pull/35494)
+* [[`6ff152cc67`](https://github.com/nodejs/node/commit/6ff152cc67)] - **(SEMVER-MINOR)** **http**: allow passing array of key/val into writeHead (Robert Nagy) [#35274](https://github.com/nodejs/node/pull/35274)
+* [[`93f947af0a`](https://github.com/nodejs/node/commit/93f947af0a)] - **(SEMVER-MINOR)** **src**: expose v8::Isolate setup callbacks (Shelley Vohr) [#35512](https://github.com/nodejs/node/pull/35512)
+
+### Commits
+
+* [[`16c17ddd88`](https://github.com/nodejs/node/commit/16c17ddd88)] - **build**: fix Commit Queue failure comment (Antoine du Hamel) [#35599](https://github.com/nodejs/node/pull/35599)
+* [[`b7305284e2`](https://github.com/nodejs/node/commit/b7305284e2)] - **build**: gitHub actions: Python 3.9 and actions/setup-python@v2 (Christian Clauss) [#35521](https://github.com/nodejs/node/pull/35521)
+* [[`e8fcbc8318`](https://github.com/nodejs/node/commit/e8fcbc8318)] - **build**: fix landed message for multiple commits in commit-queue (Denys Otrishko) [#35226](https://github.com/nodejs/node/pull/35226)
+* [[`84c0adefa0`](https://github.com/nodejs/node/commit/84c0adefa0)] - **build**: add Commit Queue actions url to failure comment (Denys Otrishko) [#35206](https://github.com/nodejs/node/pull/35206)
+* [[`9c74d4598d`](https://github.com/nodejs/node/commit/9c74d4598d)] - **build**: fuzzer that targets node::LoadEnvironment() (davkor) [#34844](https://github.com/nodejs/node/pull/34844)
+* [[`f552e5c251`](https://github.com/nodejs/node/commit/f552e5c251)] - **build**: improved release lint error message (Shelley Vohr) [#35523](https://github.com/nodejs/node/pull/35523)
+* [[`7e7afc5186`](https://github.com/nodejs/node/commit/7e7afc5186)] - **crypto**: update certdata to NSS 3.56 (Shelley Vohr) [#35546](https://github.com/nodejs/node/pull/35546)
+* [[`b8529a7104`](https://github.com/nodejs/node/commit/b8529a7104)] - **deps**: V8: cherry-pick 3176bfd447a9 (Anna Henningsen) [#35612](https://github.com/nodejs/node/pull/35612)
+* [[`0c877762ea`](https://github.com/nodejs/node/commit/0c877762ea)] - **doc**: document Buffer.concat may use internal pool (Andrey Pechkurov) [#35541](https://github.com/nodejs/node/pull/35541)
+* [[`6284f0dbc2`](https://github.com/nodejs/node/commit/6284f0dbc2)] - **doc**: use test username instead of real (Pooja D.P) [#35611](https://github.com/nodejs/node/pull/35611)
+* [[`78259b6519`](https://github.com/nodejs/node/commit/78259b6519)] - **doc**: add doc for starting ci job via label (Juan José Arboleda) [#35551](https://github.com/nodejs/node/pull/35551)
+* [[`41d7500bf9`](https://github.com/nodejs/node/commit/41d7500bf9)] - **doc**: fix unit of size argument of readable.read (Tobias Nießen) [#35051](https://github.com/nodejs/node/pull/35051)
+* [[`00eff4a534`](https://github.com/nodejs/node/commit/00eff4a534)] - **doc**: add missing deprecation number (Benjamin Coe) [#35630](https://github.com/nodejs/node/pull/35630)
+* [[`9288f9d74b`](https://github.com/nodejs/node/commit/9288f9d74b)] - **doc**: harmonize YAML comments (Antoine du Hamel) [#35575](https://github.com/nodejs/node/pull/35575)
+* [[`16f8298170`](https://github.com/nodejs/node/commit/16f8298170)] - **doc**: revise description of process.ppid (Pooja D.P) [#35589](https://github.com/nodejs/node/pull/35589)
+* [[`cad86d40de`](https://github.com/nodejs/node/commit/cad86d40de)] - **doc**: add symlink information for process.execpath (Pooja D.P) [#35590](https://github.com/nodejs/node/pull/35590)
+* [[`4025fc811d`](https://github.com/nodejs/node/commit/4025fc811d)] - **doc**: add PoojaDurgad as a triager (Pooja D.P) [#35153](https://github.com/nodejs/node/pull/35153)
+* [[`809cd07968`](https://github.com/nodejs/node/commit/809cd07968)] - **doc**: document rmdir/recursive deprecation (Benjamin Coe) [#35579](https://github.com/nodejs/node/pull/35579)
+* [[`9d1b7ac334`](https://github.com/nodejs/node/commit/9d1b7ac334)] - **doc**: edit fs.md for minor style changes (Rich Trott) [#35505](https://github.com/nodejs/node/pull/35505)
+* [[`c1bb364105`](https://github.com/nodejs/node/commit/c1bb364105)] - **doc**: run license builder (Myles Borins) [#35577](https://github.com/nodejs/node/pull/35577)
+* [[`970975b588`](https://github.com/nodejs/node/commit/970975b588)] - **doc**: use kbd element in process doc (Rich Trott) [#35584](https://github.com/nodejs/node/pull/35584)
+* [[`64ebbddb5f`](https://github.com/nodejs/node/commit/64ebbddb5f)] - **doc**: fixup perf\_hooks (Antoine du Hamel) [#35527](https://github.com/nodejs/node/pull/35527)
+* [[`b074717af7`](https://github.com/nodejs/node/commit/b074717af7)] - **doc**: remove incorrect synchronous label (Colin Ihrig) [#35561](https://github.com/nodejs/node/pull/35561)
+* [[`ddf13e0df0`](https://github.com/nodejs/node/commit/ddf13e0df0)] - **doc**: make fs.rm()'s force docs consistent (Colin Ihrig) [#35561](https://github.com/nodejs/node/pull/35561)
+* [[`4164477b43`](https://github.com/nodejs/node/commit/4164477b43)] - **doc**: simplify wording in tracing APIs doc (Pooja D.P) [#35556](https://github.com/nodejs/node/pull/35556)
+* [[`c865b02397`](https://github.com/nodejs/node/commit/c865b02397)] - **doc**: improve SIGINT error text (Rich Trott) [#35558](https://github.com/nodejs/node/pull/35558)
+* [[`7d1cdd411f`](https://github.com/nodejs/node/commit/7d1cdd411f)] - **doc**: move package.import content higher (Myles Borins) [#35535](https://github.com/nodejs/node/pull/35535)
+* [[`62755b6230`](https://github.com/nodejs/node/commit/62755b6230)] - **doc**: harmonize changes list ordering (Antoine du Hamel) [#35454](https://github.com/nodejs/node/pull/35454)
+* [[`8cacca0f62`](https://github.com/nodejs/node/commit/8cacca0f62)] - **doc**: changes description must end with a period (Antoine du Hamel) [#35454](https://github.com/nodejs/node/pull/35454)
+* [[`28c94ca123`](https://github.com/nodejs/node/commit/28c94ca123)] - **doc**: harmonize version list style in YAML comments (Antoine du Hamel) [#35454](https://github.com/nodejs/node/pull/35454)
+* [[`b3f15b7d89`](https://github.com/nodejs/node/commit/b3f15b7d89)] - **doc**: fix missing PR-URLs in YAML comments (Antoine du Hamel) [#35454](https://github.com/nodejs/node/pull/35454)
+* [[`02bf73e239`](https://github.com/nodejs/node/commit/02bf73e239)] - **doc**: remove outstanding YAML comment (Antoine du Hamel) [#35454](https://github.com/nodejs/node/pull/35454)
+* [[`a5552468d2`](https://github.com/nodejs/node/commit/a5552468d2)] - **doc**: harmonize YAML comments style in deprecations.md (Antoine du Hamel) [#35454](https://github.com/nodejs/node/pull/35454)
+* [[`863ba4b7da`](https://github.com/nodejs/node/commit/863ba4b7da)] - **doc**: refactor the n-api matrix (Michael Dawson) [#35345](https://github.com/nodejs/node/pull/35345)
+* [[`85dc84d1bb`](https://github.com/nodejs/node/commit/85dc84d1bb)] - **doc**: use sentence case for class property (Rich Trott) [#35540](https://github.com/nodejs/node/pull/35540)
+* [[`01c9c59c85`](https://github.com/nodejs/node/commit/01c9c59c85)] - **doc**: add history entry for exports patterns (Antoine du Hamel) [#35410](https://github.com/nodejs/node/pull/35410)
+* [[`51b988ba0f`](https://github.com/nodejs/node/commit/51b988ba0f)] - **doc**: fix deprecation history (Antoine du Hamel) [#35455](https://github.com/nodejs/node/pull/35455)
+* [[`328c624cdf`](https://github.com/nodejs/node/commit/328c624cdf)] - **doc**: fix util.inspect change history (Antoine du Hamel) [#35528](https://github.com/nodejs/node/pull/35528)
+* [[`d53cfcd9e7`](https://github.com/nodejs/node/commit/d53cfcd9e7)] - **doc**: improve kbd element rendering (Rich Trott) [#35497](https://github.com/nodejs/node/pull/35497)
+* [[`8877430530`](https://github.com/nodejs/node/commit/8877430530)] - **doc**: add aduh95 to collaborators (Antoine du Hamel) [#35542](https://github.com/nodejs/node/pull/35542)
+* [[`8cdc59b34c`](https://github.com/nodejs/node/commit/8cdc59b34c)] - **doc**: fix YAML syntax errors (Antoine du Hamel) [#35529](https://github.com/nodejs/node/pull/35529)
+* [[`3c90b1a278`](https://github.com/nodejs/node/commit/3c90b1a278)] - **errors**: support possible deletion of globalThis.Error (Michaël Zasso) [#35499](https://github.com/nodejs/node/pull/35499)
+* [[`a3c7f8e576`](https://github.com/nodejs/node/commit/a3c7f8e576)] - **fs**: rimraf should not recurse on failure (Benjamin Coe) [#35566](https://github.com/nodejs/node/pull/35566)
+* [[`939f8e8bfa`](https://github.com/nodejs/node/commit/939f8e8bfa)] - **fs**: throw rm() validation errors (Colin Ihrig) [#35602](https://github.com/nodejs/node/pull/35602)
+* [[`3a401b8695`](https://github.com/nodejs/node/commit/3a401b8695)] - **fs**: update rm/rmdir validation messages (Colin Ihrig) [#35565](https://github.com/nodejs/node/pull/35565)
+* [[`937fa5d292`](https://github.com/nodejs/node/commit/937fa5d292)] - **fs**: use validateBoolean() in rm/rmdir validation (Colin Ihrig) [#35565](https://github.com/nodejs/node/pull/35565)
+* [[`1ad9aca194`](https://github.com/nodejs/node/commit/1ad9aca194)] - **fs**: remove extraneous assignments in rmdir() (Colin Ihrig) [#35567](https://github.com/nodejs/node/pull/35567)
+* [[`1fadcf2163`](https://github.com/nodejs/node/commit/1fadcf2163)] - **fs**: simplify validateRmOptions() error handling (Colin Ihrig) [#35567](https://github.com/nodejs/node/pull/35567)
+* [[`8e3b11adb3`](https://github.com/nodejs/node/commit/8e3b11adb3)] - **fs**: use errno constant with ERR\_FS\_EISDIR (Colin Ihrig) [#35563](https://github.com/nodejs/node/pull/35563)
+* [[`1610728d7c`](https://github.com/nodejs/node/commit/1610728d7c)] - **(SEMVER-MINOR)** **fs**: add rm method (Ian Sutherland) [#35494](https://github.com/nodejs/node/pull/35494)
+* [[`6ff152cc67`](https://github.com/nodejs/node/commit/6ff152cc67)] - **(SEMVER-MINOR)** **http**: allow passing array of key/val into writeHead (Robert Nagy) [#35274](https://github.com/nodejs/node/pull/35274)
+* [[`2f1319967c`](https://github.com/nodejs/node/commit/2f1319967c)] - **http**: make response.setTimeout() work (Ben Noordhuis) [#34913](https://github.com/nodejs/node/pull/34913)
+* [[`59a2cb5ebb`](https://github.com/nodejs/node/commit/59a2cb5ebb)] - **inspector**: do not hardcode Debugger.CallFrameId in tests (Dmitry Gozman) [#35570](https://github.com/nodejs/node/pull/35570)
+* [[`cd0b1365ae`](https://github.com/nodejs/node/commit/cd0b1365ae)] - **lib**: fix readFile flag option typo (Daniil Demidovich) [#35292](https://github.com/nodejs/node/pull/35292)
+* [[`70927560f6`](https://github.com/nodejs/node/commit/70927560f6)] - **lib**: change http client path assignment (Yohanan Baruchel) [#35508](https://github.com/nodejs/node/pull/35508)
+* [[`fa171dbb7f`](https://github.com/nodejs/node/commit/fa171dbb7f)] - **lib**: use remaining typed arrays from primordials (Michaël Zasso) [#35499](https://github.com/nodejs/node/pull/35499)
+* [[`7e8fdd399f`](https://github.com/nodejs/node/commit/7e8fdd399f)] - **lib**: use Number.parseFloat from primordials (Michaël Zasso) [#35499](https://github.com/nodejs/node/pull/35499)
+* [[`5d727f0308`](https://github.com/nodejs/node/commit/5d727f0308)] - **lib**: use Number.parseInt from primordials (Michaël Zasso) [#35499](https://github.com/nodejs/node/pull/35499)
+* [[`77f1e1ea57`](https://github.com/nodejs/node/commit/77f1e1ea57)] - **lib**: use global Error constructors from primordials (Michaël Zasso) [#35499](https://github.com/nodejs/node/pull/35499)
+* [[`30c6b3e809`](https://github.com/nodejs/node/commit/30c6b3e809)] - **lib**: replace String global with primordials (Sebastien Ahkrin) [#35397](https://github.com/nodejs/node/pull/35397)
+* [[`ebf3900795`](https://github.com/nodejs/node/commit/ebf3900795)] - **lib**: replace Int8Array global with primordials (Sebastien Ahkrin) [#35397](https://github.com/nodejs/node/pull/35397)
+* [[`d6ba4ecc4d`](https://github.com/nodejs/node/commit/d6ba4ecc4d)] - **lib**: replace Int32Array global with primordials (Sebastien Ahkrin) [#35397](https://github.com/nodejs/node/pull/35397)
+* [[`f544f7a102`](https://github.com/nodejs/node/commit/f544f7a102)] - **lib**: replace Float64Array global with primordials (Sebastien Ahkrin) [#35397](https://github.com/nodejs/node/pull/35397)
+* [[`b82fc409ca`](https://github.com/nodejs/node/commit/b82fc409ca)] - **module**: cjs-module-lexer@0.4.1 big endian fix (Guy Bedford) [#35634](https://github.com/nodejs/node/pull/35634)
+* [[`cb2f6ffd3e`](https://github.com/nodejs/node/commit/cb2f6ffd3e)] - **module**: use Wasm CJS lexer when available (Guy Bedford) [#35583](https://github.com/nodejs/node/pull/35583)
+* [[`c995242068`](https://github.com/nodejs/node/commit/c995242068)] - **n-api**: support for object freeze/seal (Shelley Vohr) [#35359](https://github.com/nodejs/node/pull/35359)
+* [[`4d1d3f454d`](https://github.com/nodejs/node/commit/4d1d3f454d)] - **src**: reduced substring calls (Yash Ladha) [#34808](https://github.com/nodejs/node/pull/34808)
+* [[`5946b1ee23`](https://github.com/nodejs/node/commit/5946b1ee23)] - **(SEMVER-MINOR)** **src**: move node\_contextify to modern THROW\_ERR\_\* (James M Snell) [#35470](https://github.com/nodejs/node/pull/35470)
+* [[`541082ccd9`](https://github.com/nodejs/node/commit/541082ccd9)] - **(SEMVER-MINOR)** **src**: move node\_process to modern THROW\_ERR\* (James M Snell) [#35472](https://github.com/nodejs/node/pull/35472)
+* [[`2e67d650bb`](https://github.com/nodejs/node/commit/2e67d650bb)] - **src**: fix freeing unintialized pointer bug in ParseSoaReply (Aastha Gupta) [#35502](https://github.com/nodejs/node/pull/35502)
+* [[`93f947af0a`](https://github.com/nodejs/node/commit/93f947af0a)] - **(SEMVER-MINOR)** **src**: expose v8::Isolate setup callbacks (Shelley Vohr) [#35512](https://github.com/nodejs/node/pull/35512)
+* [[`573410fb69`](https://github.com/nodejs/node/commit/573410fb69)] - **(SEMVER-MINOR)** **stream**: multiple stream backports (Robert Nagy) [#34887](https://github.com/nodejs/node/pull/34887)
+* [[`775af7af4f`](https://github.com/nodejs/node/commit/775af7af4f)] - **test**: add regression test for v8.getHeapSnapshot() crash (Anna Henningsen) [#35612](https://github.com/nodejs/node/pull/35612)
+* [[`3d21792f86`](https://github.com/nodejs/node/commit/3d21792f86)] - **test**: mark test-webcrypto-encrypt-decrypt-aes flaky (James M Snell) [#35587](https://github.com/nodejs/node/pull/35587)
+* [[`4a2ba4384b`](https://github.com/nodejs/node/commit/4a2ba4384b)] - **test**: do not use the same EventEmitter instance (Luigi Pinca) [#35560](https://github.com/nodejs/node/pull/35560)
+* [[`768529736a`](https://github.com/nodejs/node/commit/768529736a)] - **test**: add ALPNProtocols option to clientOptions (Luigi Pinca) [#35482](https://github.com/nodejs/node/pull/35482)
+* [[`3a77d1e208`](https://github.com/nodejs/node/commit/3a77d1e208)] - **test**: adjust comments for upcoming lint rule (Rich Trott) [#35485](https://github.com/nodejs/node/pull/35485)
+* [[`2992d0b82c`](https://github.com/nodejs/node/commit/2992d0b82c)] - **tools**: refloat 7 Node.js patches to cpplint.py (Rich Trott) [#35569](https://github.com/nodejs/node/pull/35569)
+* [[`a19b320a31`](https://github.com/nodejs/node/commit/a19b320a31)] - **tools**: bump cpplint.py to 1.4.6 (Rich Trott) [#35569](https://github.com/nodejs/node/pull/35569)
+* [[`bd344108eb`](https://github.com/nodejs/node/commit/bd344108eb)] - ***Revert*** "**tools**: add missing uv\_setup\_argv() calls" (Beth Griggs) [#35641](https://github.com/nodejs/node/pull/35641)
+* [[`e8434d88fe`](https://github.com/nodejs/node/commit/e8434d88fe)] - **tools,test**: enable multiline-comment-style rule in tests (Rich Trott) [#35485](https://github.com/nodejs/node/pull/35485)
+
+<a id="14.13.1"></a>
+## 2020-10-07, Version 14.13.1 (Current), @BethGriggs prepared by @danielleadams
+
+### Notable Changes
+
+* **fs**:
+  * remove experimental from rmdir recursive (Benjamin Coe) [#35171](https://github.com/nodejs/node/pull/35171)
+
+### Commits
+
+* [[`f36476d9d6`](https://github.com/nodejs/node/commit/f36476d9d6)] - **build**: fix CQ after latest ncu release (Mary Marchini) [#35468](https://github.com/nodejs/node/pull/35468)
+* [[`7dc6b2fac7`](https://github.com/nodejs/node/commit/7dc6b2fac7)] - **build**: add support for section ordering (Gabriel Schulhof) [#35272](https://github.com/nodejs/node/pull/35272)
+* [[`05e08bdf13`](https://github.com/nodejs/node/commit/05e08bdf13)] - **console**: add Symbol.toStringTag property (Leko) [#35399](https://github.com/nodejs/node/pull/35399)
+* [[`a01154e3fd`](https://github.com/nodejs/node/commit/a01154e3fd)] - **crypto**: fix KeyObject garbage collection (Anna Henningsen) [#35481](https://github.com/nodejs/node/pull/35481)
+* [[`1f15e34dc8`](https://github.com/nodejs/node/commit/1f15e34dc8)] - **crypto**: set env values in KeyObject Deserialize method (ThakurKarthik) [#35416](https://github.com/nodejs/node/pull/35416)
+* [[`85062b3aad`](https://github.com/nodejs/node/commit/85062b3aad)] - **deps**: update llhttp to 2.1.3 (Fedor Indutny) [#35435](https://github.com/nodejs/node/pull/35435)
+* [[`a995dd7a89`](https://github.com/nodejs/node/commit/a995dd7a89)] - **doc**: revise introductory child\_process text (Rich Trott) [#35344](https://github.com/nodejs/node/pull/35344)
+* [[`6585b161ba`](https://github.com/nodejs/node/commit/6585b161ba)] - **doc**: improve eventLoopUtilization documentation (Andrey Pechkurov) [#35479](https://github.com/nodejs/node/pull/35479)
+* [[`f08577c4a6`](https://github.com/nodejs/node/commit/f08577c4a6)] - **doc**: update AUTHORS list (Anna Henningsen) [#35280](https://github.com/nodejs/node/pull/35280)
+* [[`91ef862365`](https://github.com/nodejs/node/commit/91ef862365)] - **doc**: mention adding YAML for APIs in PR contributing guide (Denys Otrishko) [#35459](https://github.com/nodejs/node/pull/35459)
+* [[`885840b543`](https://github.com/nodejs/node/commit/885840b543)] - **doc**: adopt MDN style for kbd elements (Rich Trott) [#35460](https://github.com/nodejs/node/pull/35460)
+* [[`1313c8c33a`](https://github.com/nodejs/node/commit/1313c8c33a)] - **doc**: update sxa's email address to Red Hat from IBM (Stewart X Addison) [#35442](https://github.com/nodejs/node/pull/35442)
+* [[`3f95440334`](https://github.com/nodejs/node/commit/3f95440334)] - **doc**: fix conditional exports flag removal version (Antoine du Hamel) [#35428](https://github.com/nodejs/node/pull/35428)
+* [[`e40876a5e5`](https://github.com/nodejs/node/commit/e40876a5e5)] - **doc**: specify how to detect EOF (Luigi Pinca) [#35445](https://github.com/nodejs/node/pull/35445)
+* [[`541ce17386`](https://github.com/nodejs/node/commit/541ce17386)] - **doc**: add entry to console.timeEnd() changes array (Luigi Pinca) [#35441](https://github.com/nodejs/node/pull/35441)
+* [[`38a5715c1a`](https://github.com/nodejs/node/commit/38a5715c1a)] - **doc**: avoid using deprecated connection property (Luigi Pinca) [#35439](https://github.com/nodejs/node/pull/35439)
+* [[`862b75d35e`](https://github.com/nodejs/node/commit/862b75d35e)] - **doc**: added details around console.timeEnd changes (Yash Ladha) [#35027](https://github.com/nodejs/node/pull/35027)
+* [[`4dbb3a91fe`](https://github.com/nodejs/node/commit/4dbb3a91fe)] - **doc**: copyedit packages.md (Rich Trott) [#35427](https://github.com/nodejs/node/pull/35427)
+* [[`368a3ae415`](https://github.com/nodejs/node/commit/368a3ae415)] - **doc**: update contact information for @BethGriggs (Beth Griggs) [#35451](https://github.com/nodejs/node/pull/35451)
+* [[`a11ddee8b9`](https://github.com/nodejs/node/commit/a11ddee8b9)] - **doc**: update contact information for richardlau (Richard Lau) [#35450](https://github.com/nodejs/node/pull/35450)
+* [[`35b62ef0a7`](https://github.com/nodejs/node/commit/35b62ef0a7)] - **doc**: importable node protocol URLs (Bradley Meck) [#35434](https://github.com/nodejs/node/pull/35434)
+* [[`95c62a1dca`](https://github.com/nodejs/node/commit/95c62a1dca)] - **doc**: copyedit esm.md (Rich Trott) [#35414](https://github.com/nodejs/node/pull/35414)
+* [[`86f2f83a2f`](https://github.com/nodejs/node/commit/86f2f83a2f)] - **doc**: implement fancier rendering for keys (Rich Trott) [#35400](https://github.com/nodejs/node/pull/35400)
+* [[`d6427886b8`](https://github.com/nodejs/node/commit/d6427886b8)] - **doc**: unhide resolver spec (Guy Bedford) [#35358](https://github.com/nodejs/node/pull/35358)
+* [[`5a730b5def`](https://github.com/nodejs/node/commit/5a730b5def)] - **doc**: sort md references in ASCII order (Antoine du Hamel) [#35191](https://github.com/nodejs/node/pull/35191)
+* [[`ce789f1ca4`](https://github.com/nodejs/node/commit/ce789f1ca4)] - **doc**: use .md extension for internal links (Antoine du Hamel) [#35191](https://github.com/nodejs/node/pull/35191)
+* [[`79e3e5008d`](https://github.com/nodejs/node/commit/79e3e5008d)] - **doc**: update example ICU URL (Daijiro Wachi) [#35373](https://github.com/nodejs/node/pull/35373)
+* [[`998b24ef17`](https://github.com/nodejs/node/commit/998b24ef17)] - **doc**: align to function signature (anlex N) [#34930](https://github.com/nodejs/node/pull/34930)
+* [[`af360ace37`](https://github.com/nodejs/node/commit/af360ace37)] - **doc**: make minor edits for consistency (Rich Trott) [#35377](https://github.com/nodejs/node/pull/35377)
+* [[`53e27b3f67`](https://github.com/nodejs/node/commit/53e27b3f67)] - **doc,esm**: add history support info (Antoine du Hamel) [#35395](https://github.com/nodejs/node/pull/35395)
+* [[`91b820e939`](https://github.com/nodejs/node/commit/91b820e939)] - **esm**: use "node:" namespace for builtins (Guy Bedford) [#35387](https://github.com/nodejs/node/pull/35387)
+* [[`541be526c3`](https://github.com/nodejs/node/commit/541be526c3)] - **fs**: do not throw exception after creating FSReqCallback (Anna Henningsen) [#35487](https://github.com/nodejs/node/pull/35487)
+* [[`f29451dece`](https://github.com/nodejs/node/commit/f29451dece)] - **fs**: simplify realpathSync (himself65) [#35413](https://github.com/nodejs/node/pull/35413)
+* [[`fcbdb0686d`](https://github.com/nodejs/node/commit/fcbdb0686d)] - **fs**: remove experimental from rmdir recursive (Benjamin Coe) [#35171](https://github.com/nodejs/node/pull/35171)
+* [[`e4a4f81d19`](https://github.com/nodejs/node/commit/e4a4f81d19)] - **fs**: use Promise.resolve from primordials (Michaël Zasso) [#35379](https://github.com/nodejs/node/pull/35379)
+* [[`8e3a81eed9`](https://github.com/nodejs/node/commit/8e3a81eed9)] - **http2,tls**: store WriteWrap using BaseObjectPtr (Anna Henningsen) [#35488](https://github.com/nodejs/node/pull/35488)
+* [[`62ddc77a5b`](https://github.com/nodejs/node/commit/62ddc77a5b)] - **meta**: add nodejs/streams to CODEOWNERS (Matteo Collina) [#35411](https://github.com/nodejs/node/pull/35411)
+* [[`23022066ec`](https://github.com/nodejs/node/commit/23022066ec)] - **meta**: add startup team in CODEOWNERS (Joyee Cheung) [#35406](https://github.com/nodejs/node/pull/35406)
+* [[`0ac5fa703e`](https://github.com/nodejs/node/commit/0ac5fa703e)] - **module**: update to cjs-module-lexer@0.4.0 (Guy Bedford) [#35501](https://github.com/nodejs/node/pull/35501)
+* [[`5c879a97e6`](https://github.com/nodejs/node/commit/5c879a97e6)] - **module**: fix builtin reexport tracing (Guy Bedford) [#35500](https://github.com/nodejs/node/pull/35500)
+* [[`f23a0e250c`](https://github.com/nodejs/node/commit/f23a0e250c)] - **module**: refine module type mismatch error cases (Guy Bedford) [#35426](https://github.com/nodejs/node/pull/35426)
+* [[`3f62f997a2`](https://github.com/nodejs/node/commit/3f62f997a2)] - **src**: more idiomatic error pattern in node\_wasi (James M Snell) [#35493](https://github.com/nodejs/node/pull/35493)
+* [[`392c8815fe`](https://github.com/nodejs/node/commit/392c8815fe)] - **src**: use env-\>ThrowUVException in pipe\_wrap (James M Snell) [#35493](https://github.com/nodejs/node/pull/35493)
+* [[`e09f7f023a`](https://github.com/nodejs/node/commit/e09f7f023a)] - **src**: limit GetProcessTitle() result to 1MB (Anna Henningsen) [#35492](https://github.com/nodejs/node/pull/35492)
+* [[`fbb9dd9ac9`](https://github.com/nodejs/node/commit/fbb9dd9ac9)] - **src**: fix aliased buffer import warning in env.h (Yash Ladha) [#35436](https://github.com/nodejs/node/pull/35436)
+* [[`7bbf8ee256`](https://github.com/nodejs/node/commit/7bbf8ee256)] - **src**: remove invalid ToLocalChecked in EmitBeforeExit (Anna Henningsen) [#35484](https://github.com/nodejs/node/pull/35484)
+* [[`5a85d4f2c6`](https://github.com/nodejs/node/commit/5a85d4f2c6)] - **src**: make MakeCallback() check can\_call\_into\_js before getting method (Anna Henningsen) [#35424](https://github.com/nodejs/node/pull/35424)
+* [[`4aed176b68`](https://github.com/nodejs/node/commit/4aed176b68)] - **src**: document required else block at src/node\_platform.cc (Juan José Arboleda) [#34688](https://github.com/nodejs/node/pull/34688)
+* [[`552ebafd06`](https://github.com/nodejs/node/commit/552ebafd06)] - **test**: update wpt tests for encoding (Daijiro Wachi) [#35330](https://github.com/nodejs/node/pull/35330)
+* [[`27cd99b217`](https://github.com/nodejs/node/commit/27cd99b217)] - **test**: improve test coverage for eventtarget (Juan José Arboleda) [#33733](https://github.com/nodejs/node/pull/33733)
+* [[`5790c40c32`](https://github.com/nodejs/node/commit/5790c40c32)] - **tools**: add missing uv\_setup\_argv() calls (Anna Henningsen) [#35491](https://github.com/nodejs/node/pull/35491)
+* [[`f499302ac0`](https://github.com/nodejs/node/commit/f499302ac0)] - **tools**: fix typo in error message (Antoine du Hamel) [#35417](https://github.com/nodejs/node/pull/35417)
+* [[`5f1d792a09`](https://github.com/nodejs/node/commit/5f1d792a09)] - **tools**: update gyp to v0.5.0 (Ujjwal Sharma) [#32698](https://github.com/nodejs/node/pull/32698)
+* [[`ad8fce6e61`](https://github.com/nodejs/node/commit/ad8fce6e61)] - **tools**: update gyp to v0.4.0 (Ujjwal Sharma) [#32698](https://github.com/nodejs/node/pull/32698)
+* [[`3e75907dea`](https://github.com/nodejs/node/commit/3e75907dea)] - **tools**: update gyp-next to v0.3.0 (Ujjwal Sharma) [#32698](https://github.com/nodejs/node/pull/32698)
+* [[`7361a3fd1a`](https://github.com/nodejs/node/commit/7361a3fd1a)] - **tools**: update gyp-next to v0.2.1 (Ujjwal Sharma) [#32698](https://github.com/nodejs/node/pull/32698)
+* [[`190d46bdde`](https://github.com/nodejs/node/commit/190d46bdde)] - **tools**: update gyp to 0.2.0 (Ujjwal Sharma) [#32698](https://github.com/nodejs/node/pull/32698)
+* [[`166f14ac98`](https://github.com/nodejs/node/commit/166f14ac98)] - **tools**: check links in api docs (Antoine du Hamel) [#35191](https://github.com/nodejs/node/pull/35191)
+* [[`a4e5a3af85`](https://github.com/nodejs/node/commit/a4e5a3af85)] - **tools**: exclude gyp from markdown link checker (Michaël Zasso) [#35423](https://github.com/nodejs/node/pull/35423)
+* [[`4d29fb56f2`](https://github.com/nodejs/node/commit/4d29fb56f2)] - **tools**: add pythonenv to .gitignore (Michaël Zasso) [#35389](https://github.com/nodejs/node/pull/35389)
+* [[`6e9e5c3381`](https://github.com/nodejs/node/commit/6e9e5c3381)] - **tools,doc**: fix broken link in module.html (Rich Trott) [#35446](https://github.com/nodejs/node/pull/35446)
+
+<a id="14.13.0"></a>
+## 2020-09-29, Version 14.13.0 (Current), @MylesBorins
+
+### Notable Changes
+
+* [[`19b95a7fa9`](https://github.com/nodejs/node/commit/19b95a7fa9)] - **(SEMVER-MINOR)** **deps**: upgrade to libuv 1.40.0 (Colin Ihrig) [#35333](https://github.com/nodejs/node/pull/35333)
+* [[`f551f52f83`](https://github.com/nodejs/node/commit/f551f52f83)] - **(SEMVER-MINOR)** **module**: named exports for CJS via static analysis (Guy Bedford) [#35249](https://github.com/nodejs/node/pull/35249)
+* [[`505731871e`](https://github.com/nodejs/node/commit/505731871e)] - **(SEMVER-MINOR)** **module**: exports pattern support (Guy Bedford) [#34718](https://github.com/nodejs/node/pull/34718)
+* [[`0d8eaa3942`](https://github.com/nodejs/node/commit/0d8eaa3942)] - **(SEMVER-MINOR)** **src**: allow N-API addon in `AddLinkedBinding()` (Anna Henningsen) [#35301](https://github.com/nodejs/node/pull/35301)
+
+### Commits
+
+* [[`19b95a7fa9`](https://github.com/nodejs/node/commit/19b95a7fa9)] - **(SEMVER-MINOR)** **deps**: upgrade to libuv 1.40.0 (Colin Ihrig) [#35333](https://github.com/nodejs/node/pull/35333)
+* [[`353a567235`](https://github.com/nodejs/node/commit/353a567235)] - **deps**: upgrade to c-ares v1.16.1 (Shelley Vohr) [#35324](https://github.com/nodejs/node/pull/35324)
+* [[`2e10616d48`](https://github.com/nodejs/node/commit/2e10616d48)] - **doc**: remove http2 non-link anchor tags (Rich Trott) [#35161](https://github.com/nodejs/node/pull/35161)
+* [[`02db136c49`](https://github.com/nodejs/node/commit/02db136c49)] - **doc**: alphabetize error list (Rich Trott) [#35219](https://github.com/nodejs/node/pull/35219)
+* [[`46a4154cab`](https://github.com/nodejs/node/commit/46a4154cab)] - **doc**: packages docs feedback (Guy Bedford) [#35370](https://github.com/nodejs/node/pull/35370)
+* [[`70ad69ba46`](https://github.com/nodejs/node/commit/70ad69ba46)] - **doc**: outline when origin is set to unhandledRejection (Matthieu Larcher) [#35294](https://github.com/nodejs/node/pull/35294)
+* [[`010173a4b7`](https://github.com/nodejs/node/commit/010173a4b7)] - **doc**: edit n-api.md for minor improvements (Rich Trott) [#35361](https://github.com/nodejs/node/pull/35361)
+* [[`86ac7497e0`](https://github.com/nodejs/node/commit/86ac7497e0)] - **doc**: add history entry for breaking destroy() change (Gil Pedersen) [#35326](https://github.com/nodejs/node/pull/35326)
+* [[`857e321baf`](https://github.com/nodejs/node/commit/857e321baf)] - **doc**: set encoding to hex before piping hash (Victor Antonio Barzana Crespo) [#35338](https://github.com/nodejs/node/pull/35338)
+* [[`87dfed012c`](https://github.com/nodejs/node/commit/87dfed012c)] - **doc**: add gpg key export directions to releases doc (Danielle Adams) [#35298](https://github.com/nodejs/node/pull/35298)
+* [[`1758ac8237`](https://github.com/nodejs/node/commit/1758ac8237)] - **doc**: added version 7 to N-API version matrix (NickNaso) [#35319](https://github.com/nodejs/node/pull/35319)
+* [[`5da5d41b1c`](https://github.com/nodejs/node/commit/5da5d41b1c)] - **doc**: refine require/import conditions constraints (Guy Bedford) [#35311](https://github.com/nodejs/node/pull/35311)
+* [[`482ce6ce1d`](https://github.com/nodejs/node/commit/482ce6ce1d)] - **doc**: improve N-API string-to-native doc (Gabriel Schulhof) [#35322](https://github.com/nodejs/node/pull/35322)
+* [[`6dc6dadfc6`](https://github.com/nodejs/node/commit/6dc6dadfc6)] - **doc**: avoid referring to C array size (Tobias Nießen) [#35300](https://github.com/nodejs/node/pull/35300)
+* [[`0a847ca729`](https://github.com/nodejs/node/commit/0a847ca729)] - **doc**: update napi\_make\_callback documentation (Gerhard Stoebich) [#35321](https://github.com/nodejs/node/pull/35321)
+* [[`a8d3a7f742`](https://github.com/nodejs/node/commit/a8d3a7f742)] - **doc**: put landing specifics in details tag (Rich Trott) [#35296](https://github.com/nodejs/node/pull/35296)
+* [[`dd530364d0`](https://github.com/nodejs/node/commit/dd530364d0)] - **doc**: fixup lutimes metadata (Anna Henningsen) [#35328](https://github.com/nodejs/node/pull/35328)
+* [[`d7282c0ae3`](https://github.com/nodejs/node/commit/d7282c0ae3)] - **doc**: edit subpath export patterns introduction (Rich Trott) [#35254](https://github.com/nodejs/node/pull/35254)
+* [[`1d1ce1fc2c`](https://github.com/nodejs/node/commit/1d1ce1fc2c)] - **doc**: document support for package.json fields (Antoine du HAMEL) [#34970](https://github.com/nodejs/node/pull/34970)
+* [[`ef0d2ef5a2`](https://github.com/nodejs/node/commit/ef0d2ef5a2)] - **doc**: move package config docs to separate page (Antoine du HAMEL) [#34748](https://github.com/nodejs/node/pull/34748)
+* [[`b9d767c4d5`](https://github.com/nodejs/node/commit/b9d767c4d5)] - **doc**: change type of child\_process.signalCode to string (Linn Dahlgren) [#35223](https://github.com/nodejs/node/pull/35223)
+* [[`b4514d464d`](https://github.com/nodejs/node/commit/b4514d464d)] - **doc**: replace "this guide" link text with guide title (Rich Trott) [#35283](https://github.com/nodejs/node/pull/35283)
+* [[`1893449724`](https://github.com/nodejs/node/commit/1893449724)] - **doc**: revise dependency redirection text in policy.md (Rich Trott) [#35276](https://github.com/nodejs/node/pull/35276)
+* [[`0c4540b050`](https://github.com/nodejs/node/commit/0c4540b050)] - **doc**: fix heading space bug in assert.md (Thomas Hunter II) [#35310](https://github.com/nodejs/node/pull/35310)
+* [[`ec6b78ae73`](https://github.com/nodejs/node/commit/ec6b78ae73)] - **doc**: add `socket.readyState` (Clark Kozak) [#35262](https://github.com/nodejs/node/pull/35262)
+* [[`2a4ae0926d`](https://github.com/nodejs/node/commit/2a4ae0926d)] - **doc**: update crypto.createSecretKey accepted types (Filip Skokan) [#35246](https://github.com/nodejs/node/pull/35246)
+* [[`c09f3dc2f3`](https://github.com/nodejs/node/commit/c09f3dc2f3)] - **doc**: put release script specifics in details (Myles Borins) [#35260](https://github.com/nodejs/node/pull/35260)
+* [[`99a79e32a6`](https://github.com/nodejs/node/commit/99a79e32a6)] - **fs**: fix fs.promises.writeFile with typed arrays (Michaël Zasso) [#35376](https://github.com/nodejs/node/pull/35376)
+* [[`ab7d0e92b1`](https://github.com/nodejs/node/commit/ab7d0e92b1)] - **meta**: update module pages in CODEOWNERS (Antoine du Hamel) [#34932](https://github.com/nodejs/node/pull/34932)
+* [[`f551f52f83`](https://github.com/nodejs/node/commit/f551f52f83)] - **(SEMVER-MINOR)** **module**: named exports for CJS via static analysis (Guy Bedford) [#35249](https://github.com/nodejs/node/pull/35249)
+* [[`505731871e`](https://github.com/nodejs/node/commit/505731871e)] - **(SEMVER-MINOR)** **module**: exports pattern support (Guy Bedford) [#34718](https://github.com/nodejs/node/pull/34718)
+* [[`68ea7f5560`](https://github.com/nodejs/node/commit/68ea7f5560)] - **module**: fix crash on multiline named cjs imports (Christoph Tavan) [#35275](https://github.com/nodejs/node/pull/35275)
+* [[`0f4ecaa741`](https://github.com/nodejs/node/commit/0f4ecaa741)] - **repl**: standardize Control key indications (Rich Trott) [#35270](https://github.com/nodejs/node/pull/35270)
+* [[`1e1cb94e69`](https://github.com/nodejs/node/commit/1e1cb94e69)] - **src**: fix incorrect SIGSEGV handling in NODE\_USE\_V8\_WASM\_TRAP\_HANDLER (Anatoly Korniltsev) [#35282](https://github.com/nodejs/node/pull/35282)
+* [[`0d8eaa3942`](https://github.com/nodejs/node/commit/0d8eaa3942)] - **(SEMVER-MINOR)** **src**: allow N-API addon in `AddLinkedBinding()` (Anna Henningsen) [#35301](https://github.com/nodejs/node/pull/35301)
+* [[`f2635b317e`](https://github.com/nodejs/node/commit/f2635b317e)] - **test**: replace annonymous functions with arrow (Pooja D.P) [#34921](https://github.com/nodejs/node/pull/34921)
+* [[`d7c28c9243`](https://github.com/nodejs/node/commit/d7c28c9243)] - **test,child_process**: add tests for signalCode value (Rich Trott) [#35327](https://github.com/nodejs/node/pull/35327)
+* [[`80eb22185e`](https://github.com/nodejs/node/commit/80eb22185e)] - **tools**: update ESLint to 7.10.0 (Colin Ihrig) [#35366](https://github.com/nodejs/node/pull/35366)
+* [[`7f355735df`](https://github.com/nodejs/node/commit/7f355735df)] - **tools**: ignore build folder when checking links (Ash Cripps) [#35315](https://github.com/nodejs/node/pull/35315)
+* [[`c5d27e1e29`](https://github.com/nodejs/node/commit/c5d27e1e29)] - **tools,doc**: enforce alphabetical order for md refs (Antoine du Hamel) [#35244](https://github.com/nodejs/node/pull/35244)
+* [[`9d91842a9d`](https://github.com/nodejs/node/commit/9d91842a9d)] - **tools,doc**: upgrade dependencies (Antoine du Hamel) [#35244](https://github.com/nodejs/node/pull/35244)
+
+<a id="14.12.0"></a>
+## 2020-09-22, Version 14.12.0 (Current), @ruyadorno
+
+### Notable changes
+
+* **deps**:
+  * update to uvwasi 0.0.11 (Colin Ihrig) [#35104](https://github.com/nodejs/node/pull/35104)
+* **n-api**:
+  * create N-API version 7 (Gabriel Schulhof) [#35199](https://github.com/nodejs/node/pull/35199)
+  * add more property defaults (Gerhard Stoebich) [#35214](https://github.com/nodejs/node/pull/35214)
+
+### Commits
+* [[`5229ffadcf`](https://github.com/nodejs/node/commit/5229ffadcf)] - **buffer**: adjust validation to account for buffer.kMaxLength (Anna Henningsen) [#35134](https://github.com/nodejs/node/pull/35134)
+* [[`3d78686987`](https://github.com/nodejs/node/commit/3d78686987)] - **build**: increase API requests for stale action (Phillip Johnsen) [#35235](https://github.com/nodejs/node/pull/35235)
+* [[`f2cc1c22c1`](https://github.com/nodejs/node/commit/f2cc1c22c1)] - **build**: filter issues & PRs to auto close by matching on stalled label (Phillip Johnsen) [#35159](https://github.com/nodejs/node/pull/35159)
+* [[`f3c45a1cef`](https://github.com/nodejs/node/commit/f3c45a1cef)] - ***Revert*** "**build**: require "allow edits" to be checked" (Rich Trott) [#35094](https://github.com/nodejs/node/pull/35094)
+* [[`1bb0ed3c6a`](https://github.com/nodejs/node/commit/1bb0ed3c6a)] - **crypto**: improve invalid arg type message for randomInt() (Rich Trott) [#35089](https://github.com/nodejs/node/pull/35089)
+* [[`3573545315`](https://github.com/nodejs/node/commit/3573545315)] - **crypto**: improve randomInt out-of-range error message (Rich Trott) [#35088](https://github.com/nodejs/node/pull/35088)
+* [[`d4389b59b4`](https://github.com/nodejs/node/commit/d4389b59b4)] - **deps**: update to uvwasi 0.0.11 (Colin Ihrig) [#35104](https://github.com/nodejs/node/pull/35104)
+* [[`836680a4ea`](https://github.com/nodejs/node/commit/836680a4ea)] - **doc**: use present tense in error messages (Rich Trott) [#35164](https://github.com/nodejs/node/pull/35164)
+* [[`b860a7f61c`](https://github.com/nodejs/node/commit/b860a7f61c)] - **doc**: standardize on \_backward\_ (Rich Trott) [#35243](https://github.com/nodejs/node/pull/35243)
+* [[`d82dd0c773`](https://github.com/nodejs/node/commit/d82dd0c773)] - **doc**: revise stability section of values doc (Rich Trott) [#35242](https://github.com/nodejs/node/pull/35242)
+* [[`2bc335dcf6`](https://github.com/nodejs/node/commit/2bc335dcf6)] - **doc**: clarify napi\_property\_attributes text (Rich Trott) [#35253](https://github.com/nodejs/node/pull/35253)
+* [[`b62d9b47be`](https://github.com/nodejs/node/commit/b62d9b47be)] - **doc**: remove excessive formatting in dgram.md (Rich Trott) [#35234](https://github.com/nodejs/node/pull/35234)
+* [[`b9161f408f`](https://github.com/nodejs/node/commit/b9161f408f)] - **doc**: sort repl references in ASCII order (Rich Trott) [#35230](https://github.com/nodejs/node/pull/35230)
+* [[`d195d20dbc`](https://github.com/nodejs/node/commit/d195d20dbc)] - **doc**: relax prohibition on personal pronouns (Rich Trott) [#34353](https://github.com/nodejs/node/pull/34353)
+* [[`6119e9511c`](https://github.com/nodejs/node/commit/6119e9511c)] - **doc**: clarify use of NAPI\_EXPERIMENTAL (Michael Dawson) [#35195](https://github.com/nodejs/node/pull/35195)
+* [[`6d4ab36175`](https://github.com/nodejs/node/commit/6d4ab36175)] - **doc**: update attributes used by n-api samples (#35220) (Gerhard Stoebich)
+* [[`7610fe500e`](https://github.com/nodejs/node/commit/7610fe500e)] - **doc**: add issue labels sections to release guide (Michaël Zasso) [#35224](https://github.com/nodejs/node/pull/35224)
+* [[`2308be06b3`](https://github.com/nodejs/node/commit/2308be06b3)] - **doc**: fix header level for error code (Rich Trott) [#35219](https://github.com/nodejs/node/pull/35219)
+* [[`64ac5c68aa`](https://github.com/nodejs/node/commit/64ac5c68aa)] - **doc**: fix small grammatical issues in timers.md (Turner Jabbour) [#35203](https://github.com/nodejs/node/pull/35203)
+* [[`92a14d3c72`](https://github.com/nodejs/node/commit/92a14d3c72)] - **doc**: add technical values document (Michael Dawson) [#35145](https://github.com/nodejs/node/pull/35145)
+* [[`dbfd3b261d`](https://github.com/nodejs/node/commit/dbfd3b261d)] - **doc**: remove "end user" (Rich Trott) [#35200](https://github.com/nodejs/node/pull/35200)
+* [[`c1c93a6cde`](https://github.com/nodejs/node/commit/c1c93a6cde)] - **doc**: use command-line/command line consistently (Rich Trott) [#35198](https://github.com/nodejs/node/pull/35198)
+* [[`70ec369b76`](https://github.com/nodejs/node/commit/70ec369b76)] - **doc**: replace "you should do X" with "do X" (Rich Trott) [#35194](https://github.com/nodejs/node/pull/35194)
+* [[`e5fffe2f8f`](https://github.com/nodejs/node/commit/e5fffe2f8f)] - **doc**: fix missing word in dgram.md (Tom Atkinson) [#35231](https://github.com/nodejs/node/pull/35231)
+* [[`c1e16d15dd`](https://github.com/nodejs/node/commit/c1e16d15dd)] - **doc**: fix deprecation documentation inconsistencies (Antoine du HAMEL) [#35082](https://github.com/nodejs/node/pull/35082)
+* [[`910deff2de`](https://github.com/nodejs/node/commit/910deff2de)] - **doc**: fix broken link in crypto.md (Rich Trott) [#35181](https://github.com/nodejs/node/pull/35181)
+* [[`066148d229`](https://github.com/nodejs/node/commit/066148d229)] - **doc**: remove problematic auto-linking of curl man pages (Rich Trott) [#35174](https://github.com/nodejs/node/pull/35174)
+* [[`aea3f77c8d`](https://github.com/nodejs/node/commit/aea3f77c8d)] - **doc**: update eventLoopUtilization documentation (Anna Henningsen) [#35155](https://github.com/nodejs/node/pull/35155)
+* [[`32d1731ae1`](https://github.com/nodejs/node/commit/32d1731ae1)] - **doc**: update process.release (schamberg97) [#35167](https://github.com/nodejs/node/pull/35167)
+* [[`176e9e4054`](https://github.com/nodejs/node/commit/176e9e4054)] - **doc**: fix broken links in modules.md (Rich Trott) [#35182](https://github.com/nodejs/node/pull/35182)
+* [[`dc4c5696da`](https://github.com/nodejs/node/commit/dc4c5696da)] - **doc**: add missing copyFile change history (Shelley Vohr) [#35056](https://github.com/nodejs/node/pull/35056)
+* [[`e8d479ed67`](https://github.com/nodejs/node/commit/e8d479ed67)] - **doc**: perform cleanup on security-release-process.md (Rich Trott) [#35154](https://github.com/nodejs/node/pull/35154)
+* [[`99785e48ea`](https://github.com/nodejs/node/commit/99785e48ea)] - **doc**: fix minor punctuation issue in path.md (Amila Welihinda) [#35127](https://github.com/nodejs/node/pull/35127)
+* [[`ae85228e54`](https://github.com/nodejs/node/commit/ae85228e54)] - **doc**: perform minor cleanup on cli.md (Rich Trott) [#35152](https://github.com/nodejs/node/pull/35152)
+* [[`e4105140e7`](https://github.com/nodejs/node/commit/e4105140e7)] - **doc**: improve table accessibility (Rich Trott) [#35146](https://github.com/nodejs/node/pull/35146)
+* [[`7dbcd24541`](https://github.com/nodejs/node/commit/7dbcd24541)] - **doc**: fix left nav color contrast (Rich Trott) [#35141](https://github.com/nodejs/node/pull/35141)
+* [[`331142ca25`](https://github.com/nodejs/node/commit/331142ca25)] - **doc**: update contact info for Ash Cripps (Ash Cripps) [#35139](https://github.com/nodejs/node/pull/35139)
+* [[`df70861863`](https://github.com/nodejs/node/commit/df70861863)] - **doc**: simplify circular dependencies text in modules.md (Rich Trott) [#35126](https://github.com/nodejs/node/pull/35126)
+* [[`f4e714aaf5`](https://github.com/nodejs/node/commit/f4e714aaf5)] - **doc**: update my email address (Michael Dawson) [#35121](https://github.com/nodejs/node/pull/35121)
+* [[`46b9f4b376`](https://github.com/nodejs/node/commit/46b9f4b376)] - **doc**: add missing changes entry for breakEvalOnSigint REPL option (Anna Henningsen) [#35143](https://github.com/nodejs/node/pull/35143)
+* [[`122edad98b`](https://github.com/nodejs/node/commit/122edad98b)] - **doc**: update security process (Michael Dawson) [#35107](https://github.com/nodejs/node/pull/35107)
+* [[`aa93c1c22d`](https://github.com/nodejs/node/commit/aa93c1c22d)] - **doc**: fix broken link in perf\_hooks.md (Rich Trott) [#35113](https://github.com/nodejs/node/pull/35113)
+* [[`5c8d2083c5`](https://github.com/nodejs/node/commit/5c8d2083c5)] - **doc**: fix broken link in http2.md (Rich Trott) [#35112](https://github.com/nodejs/node/pull/35112)
+* [[`f4e958fc0c`](https://github.com/nodejs/node/commit/f4e958fc0c)] - **doc**: fix broken link in fs.md (Rich Trott) [#35111](https://github.com/nodejs/node/pull/35111)
+* [[`79c6d92e49`](https://github.com/nodejs/node/commit/79c6d92e49)] - **doc**: fix broken links in deprecations.md (Rich Trott) [#35109](https://github.com/nodejs/node/pull/35109)
+* [[`93e4d545d8`](https://github.com/nodejs/node/commit/93e4d545d8)] - **doc**: add note about path.basename on Windows (Tobias Nießen) [#35065](https://github.com/nodejs/node/pull/35065)
+* [[`0a2610a7aa`](https://github.com/nodejs/node/commit/0a2610a7aa)] - **doc**: avoid double-while sentence in perf\_hooks.md (Rich Trott) [#35078](https://github.com/nodejs/node/pull/35078)
+* [[`1cf9934e4e`](https://github.com/nodejs/node/commit/1cf9934e4e)] - **doc**: make minor improvements to module.md (Rich Trott) [#35083](https://github.com/nodejs/node/pull/35083)
+* [[`fb89be63be`](https://github.com/nodejs/node/commit/fb89be63be)] - **doc**: use correct Error type for EventEmitter.defaultMaxListener (Rich Trott) [#35069](https://github.com/nodejs/node/pull/35069)
+* [[`b75822dd93`](https://github.com/nodejs/node/commit/b75822dd93)] - **doc,test**: specify and test CLI option precedence rules (Anna Henningsen) [#35106](https://github.com/nodejs/node/pull/35106)
+* [[`4bde865145`](https://github.com/nodejs/node/commit/4bde865145)] - **errors**: simplify ERR\_REQUIRE\_ESM message generation (Rich Trott) [#35123](https://github.com/nodejs/node/pull/35123)
+* [[`6e622d6337`](https://github.com/nodejs/node/commit/6e622d6337)] - **esm**: better package.json parser errors (Guy Bedford) [#35117](https://github.com/nodejs/node/pull/35117)
+* [[`beb75bd031`](https://github.com/nodejs/node/commit/beb75bd031)] - **fs**: loosen validation to allow objects with an own toString function (Jordan Harband) [#34993](https://github.com/nodejs/node/pull/34993)
+* [[`8ea28536d0`](https://github.com/nodejs/node/commit/8ea28536d0)] - **http**: only set keep-alive when not exists (atian25@qq.com) [#35138](https://github.com/nodejs/node/pull/35138)
+* [[`977b0ed865`](https://github.com/nodejs/node/commit/977b0ed865)] - **http**: allow Content-Length header for 304 responses (Arnaud Lefebvre) [#34835](https://github.com/nodejs/node/pull/34835)
+* [[`d8b57140b4`](https://github.com/nodejs/node/commit/d8b57140b4)] - **https**: set requestTimeout default to 0 (Robert Nagy) [#35264](https://github.com/nodejs/node/pull/35264)
+* [[`12f2934224`](https://github.com/nodejs/node/commit/12f2934224)] - **meta**: add links to OpenJSF Slack (Mary Marchini) [#35128](https://github.com/nodejs/node/pull/35128)
+* [[`f21a5c6200`](https://github.com/nodejs/node/commit/f21a5c6200)] - **meta**: update my collab entry (devsnek) [#35160](https://github.com/nodejs/node/pull/35160)
+* [[`76e24f9aa9`](https://github.com/nodejs/node/commit/76e24f9aa9)] - **module**: use isURLInstance instead of instanceof (Antoine du HAMEL) [#34951](https://github.com/nodejs/node/pull/34951)
+* [[`314483cd09`](https://github.com/nodejs/node/commit/314483cd09)] - **module**: fix specifier resolution option value (himself65) [#35098](https://github.com/nodejs/node/pull/35098)
+* [[`ca1181615e`](https://github.com/nodejs/node/commit/ca1181615e)] - **(SEMVER-MINOR)** **n-api**: create N-API version 7 (Gabriel Schulhof) [#35199](https://github.com/nodejs/node/pull/35199)
+* [[`7f3b2b2a1f`](https://github.com/nodejs/node/commit/7f3b2b2a1f)] - **(SEMVER-MINOR)** **n-api**: add more property defaults (Gerhard Stoebich) [#35214](https://github.com/nodejs/node/pull/35214)
+* [[`4f4faa8e3c`](https://github.com/nodejs/node/commit/4f4faa8e3c)] - **readline**: fix key name for function keys with modifiers (DrunkenPoney) [#35268](https://github.com/nodejs/node/pull/35268)
+* [[`e29e2daf4c`](https://github.com/nodejs/node/commit/e29e2daf4c)] - **test**: improve assertions in pummel/test-timers (Rich Trott) [#35216](https://github.com/nodejs/node/pull/35216)
+* [[`8357b56984`](https://github.com/nodejs/node/commit/8357b56984)] - **test**: add wasi readdir() test (Colin Ihrig) [#35202](https://github.com/nodejs/node/pull/35202)
+* [[`49da459ce6`](https://github.com/nodejs/node/commit/49da459ce6)] - **test**: improve pummel/test-timers.js (Rich Trott) [#35175](https://github.com/nodejs/node/pull/35175)
+* [[`379c5cefd7`](https://github.com/nodejs/node/commit/379c5cefd7)] - **test**: revise test-policy-integrity (Rich Trott) [#35101](https://github.com/nodejs/node/pull/35101)
+* [[`6627c1f8e4`](https://github.com/nodejs/node/commit/6627c1f8e4)] - **test**: remove setMaxListeners in test-crypto-random (Tobias Nießen) [#35079](https://github.com/nodejs/node/pull/35079)
+* [[`bc38485fb1`](https://github.com/nodejs/node/commit/bc38485fb1)] - **test**: fix comment about DNS lookup test (Tobias Nießen) [#35080](https://github.com/nodejs/node/pull/35080)
+* [[`9faaa659b2`](https://github.com/nodejs/node/commit/9faaa659b2)] - **test**: separate the test fixtures between ICU and URL (Leko) [#35077](https://github.com/nodejs/node/pull/35077)
+* [[`25f93f3ec3`](https://github.com/nodejs/node/commit/25f93f3ec3)] - **test**: add more valid results to test-trace-atomics-wait (Anna Henningsen) [#35066](https://github.com/nodejs/node/pull/35066)
+* [[`0a97f44b50`](https://github.com/nodejs/node/commit/0a97f44b50)] - **tools**: update ESLint to 7.9.0 (Colin Ihrig) [#35170](https://github.com/nodejs/node/pull/35170)
+
+<a id="14.11.0"></a>
+## 2020-09-15, Version 14.11.0 (Current), @richardlau
+
+### Notable Changes
+
+This is a security release.
+
+Vulnerabilities fixed:
+
+* **CVE-2020-8251**: Denial of Service by resource exhaustion CWE-400 due to unfinished HTTP/1.1 requests (Critical).
+* **CVE-2020-8201**: HTTP Request Smuggling due to CR-to-Hyphen conversion (High).
+
+### Commits
+
+* [[`dd828376a0`](https://github.com/nodejs/node/commit/dd828376a0)] - **deps**: update llhttp to 2.1.2 (Fedor Indutny) [nodejs-private/node-private#215](https://github.com/nodejs-private/node-private/pull/215)
+* [[`753f3b247a`](https://github.com/nodejs/node/commit/753f3b247a)] - **http**: add requestTimeout (Matteo Collina, Paolo Insogna, Robert Nagy) [nodejs-private/node-private#208](https://github.com/nodejs-private/node-private/pull/208)
+
+<a id="14.10.1"></a>
+## 2020-09-10, Version 14.10.1 (Current), @richardlau
+
+### Notable Changes
+
+Node.js 14.10.0 included a streams regression with async generators
+and a docs rendering regression that are being fixed in this release.
+
+### Commits
+
+* [[`3c92f93b44`](https://github.com/nodejs/node/commit/3c92f93b44)] - **doc**: restore color for visited links (Rich Trott) [#35108](https://github.com/nodejs/node/pull/35108)
+* [[`0f94c6b4e4`](https://github.com/nodejs/node/commit/0f94c6b4e4)] - ***Revert*** "**stream**: simpler and faster Readable async iterator" (Richard Lau)
+
+<a id="14.10.0"></a>
+## 2020-09-08, Version 14.10.0 (Current), @richardlau
+
+### Notable Changes
+
+* [[`2ab33c58ae`](https://github.com/nodejs/node/commit/2ab33c58ae)] - **(SEMVER-MINOR)** **buffer**: also alias BigUInt methods (Anna Henningsen) [#34960](https://github.com/nodejs/node/pull/34960)
+* [[`44d89a9faa`](https://github.com/nodejs/node/commit/44d89a9faa)] - **(SEMVER-MINOR)** **crypto**: add randomInt function (Oli Lalonde) [#34600](https://github.com/nodejs/node/pull/34600)
+* [[`8aac42caf2`](https://github.com/nodejs/node/commit/8aac42caf2)] - **(SEMVER-MINOR)** **perf_hooks**: add idleTime and event loop util (Trevor Norris) [#34938](https://github.com/nodejs/node/pull/34938)
+* [[`4bb40078da`](https://github.com/nodejs/node/commit/4bb40078da)] - **(SEMVER-MINOR)** **stream**: simpler and faster Readable async iterator (Robert Nagy) [#34035](https://github.com/nodejs/node/pull/34035)
+* [[`ffae5f3809`](https://github.com/nodejs/node/commit/ffae5f3809)] - **(SEMVER-MINOR)** **stream**: save error in state (Robert Nagy) [#34103](https://github.com/nodejs/node/pull/34103)
+
+### Commits
+
+* [[`1fdfaa578f`](https://github.com/nodejs/node/commit/1fdfaa578f)] - **bootstrap**: correct --frozen-intrinsics override fix (Guy Bedford) [#35041](https://github.com/nodejs/node/pull/35041)
+* [[`2ab33c58ae`](https://github.com/nodejs/node/commit/2ab33c58ae)] - **(SEMVER-MINOR)** **buffer**: also alias BigUInt methods (Anna Henningsen) [#34960](https://github.com/nodejs/node/pull/34960)
+* [[`1be6956ee0`](https://github.com/nodejs/node/commit/1be6956ee0)] - **build**: require "allow edits" to be checked (Jordan Harband) [#35002](https://github.com/nodejs/node/pull/35002)
+* [[`7b7299012e`](https://github.com/nodejs/node/commit/7b7299012e)] - **build**: comment about auto close when stalled via with github action (Phillip Johnsen) [#34555](https://github.com/nodejs/node/pull/34555)
+* [[`d6c796b4ab`](https://github.com/nodejs/node/commit/d6c796b4ab)] - **build**: close stalled issues and PRs with github action (Phillip Johnsen) [#34555](https://github.com/nodejs/node/pull/34555)
+* [[`46766a10df`](https://github.com/nodejs/node/commit/46766a10df)] - **build**: use autorebase option for git node land (Denys Otrishko) [#34969](https://github.com/nodejs/node/pull/34969)
+* [[`7afb67f491`](https://github.com/nodejs/node/commit/7afb67f491)] - **build**: use latest node-core-utils from npm (Denys Otrishko) [#34969](https://github.com/nodejs/node/pull/34969)
+* [[`d06e158253`](https://github.com/nodejs/node/commit/d06e158253)] - **build**: add support for build on arm64 (Evan Lucas) [#34238](https://github.com/nodejs/node/pull/34238)
+* [[`755f9e4bc8`](https://github.com/nodejs/node/commit/755f9e4bc8)] - **build,deps**: add gen-openssl target (Evan Lucas) [#34642](https://github.com/nodejs/node/pull/34642)
+* [[`178a740caf`](https://github.com/nodejs/node/commit/178a740caf)] - **crypto**: simplify KeyObject constructor (Rich Trott) [#35064](https://github.com/nodejs/node/pull/35064)
+* [[`a12d92c97b`](https://github.com/nodejs/node/commit/a12d92c97b)] - **crypto**: fix randomInt range check (Tobias Nießen) [#35052](https://github.com/nodejs/node/pull/35052)
+* [[`6d0d5b2ec2`](https://github.com/nodejs/node/commit/6d0d5b2ec2)] - **crypto**: align parameter names with documentation (Rich Trott) [#35054](https://github.com/nodejs/node/pull/35054)
+* [[`44d89a9faa`](https://github.com/nodejs/node/commit/44d89a9faa)] - **(SEMVER-MINOR)** **crypto**: add randomInt function (Oli Lalonde) [#34600](https://github.com/nodejs/node/pull/34600)
+* [[`791a85b880`](https://github.com/nodejs/node/commit/791a85b880)] - **deps**: V8: cherry-pick 6be2f6e26e8d (Benjamin Coe) [#35055](https://github.com/nodejs/node/pull/35055)
+* [[`96ae05a770`](https://github.com/nodejs/node/commit/96ae05a770)] - **deps**: V8: backport 3f071e3e7e15 (Milad Farazmand) [#35036](https://github.com/nodejs/node/pull/35036)
+* [[`90f9348297`](https://github.com/nodejs/node/commit/90f9348297)] - **deps**: update brotli to v1.0.9 (Anna Henningsen) [#34937](https://github.com/nodejs/node/pull/34937)
+* [[`f1fcd6646d`](https://github.com/nodejs/node/commit/f1fcd6646d)] - **deps**: add openssl support for arm64 (Evan Lucas) [#34238](https://github.com/nodejs/node/pull/34238)
+* [[`bbf7b925a2`](https://github.com/nodejs/node/commit/bbf7b925a2)] - **doc**: use present tense in events.md (Rich Trott) [#35068](https://github.com/nodejs/node/pull/35068)
+* [[`f6b2286e12`](https://github.com/nodejs/node/commit/f6b2286e12)] - **doc**: change stablility-2 color for accessibility (Rich Trott) [#35061](https://github.com/nodejs/node/pull/35061)
+* [[`8044533e87`](https://github.com/nodejs/node/commit/8044533e87)] - **doc**: add link to safe integer definition (Tobias Nießen) [#35049](https://github.com/nodejs/node/pull/35049)
+* [[`f03a4d78a2`](https://github.com/nodejs/node/commit/f03a4d78a2)] - **doc**: format exponents better (Tobias Nießen) [#35050](https://github.com/nodejs/node/pull/35050)
+* [[`1a9ca52716`](https://github.com/nodejs/node/commit/1a9ca52716)] - **doc**: add ESM examples in `module` API doc page (Antoine du HAMEL) [#34875](https://github.com/nodejs/node/pull/34875)
+* [[`0ac7d5423f`](https://github.com/nodejs/node/commit/0ac7d5423f)] - **doc**: add deprecated badge to legacy URL methods (Antoine du HAMEL) [#34931](https://github.com/nodejs/node/pull/34931)
+* [[`a08e853edc`](https://github.com/nodejs/node/commit/a08e853edc)] - **doc**: spruce up user journey to local docs browsing (Derek Lewis) [#34986](https://github.com/nodejs/node/pull/34986)
+* [[`83a3e3b681`](https://github.com/nodejs/node/commit/83a3e3b681)] - **doc**: update syntax highlighting color for accessibility (Rich Trott) [#35063](https://github.com/nodejs/node/pull/35063)
+* [[`5bd0e0803d`](https://github.com/nodejs/node/commit/5bd0e0803d)] - **doc**: fix incorrect URL in cli.md (Rich Trott) [#35043](https://github.com/nodejs/node/pull/35043)
+* [[`28e89f6766`](https://github.com/nodejs/node/commit/28e89f6766)] - **doc**: remove style for empty links (Antoine du HAMEL) [#35034](https://github.com/nodejs/node/pull/35034)
+* [[`cdc1198a62`](https://github.com/nodejs/node/commit/cdc1198a62)] - **doc**: fix certificate display in tls doc (Rich Trott) [#35032](https://github.com/nodejs/node/pull/35032)
+* [[`72d03cd802`](https://github.com/nodejs/node/commit/72d03cd802)] - **doc**: remove duplicate error code entry (Rich Trott) [#35031](https://github.com/nodejs/node/pull/35031)
+* [[`680782ea64`](https://github.com/nodejs/node/commit/680782ea64)] - **doc**: use consistent header typography (Rich Trott) [#35030](https://github.com/nodejs/node/pull/35030)
+* [[`1ae674c67a`](https://github.com/nodejs/node/commit/1ae674c67a)] - **doc**: fix malformed hashes in assert.md (Rich Trott) [#35028](https://github.com/nodejs/node/pull/35028)
+* [[`c3a3cb69aa`](https://github.com/nodejs/node/commit/c3a3cb69aa)] - **doc**: fix a typo of microtaskMode (Shigma) [#34980](https://github.com/nodejs/node/pull/34980)
+* [[`a846a9f116`](https://github.com/nodejs/node/commit/a846a9f116)] - **doc**: change 'be will' to 'will be' (Victory Osikwemhe) [#34999](https://github.com/nodejs/node/pull/34999)
+* [[`593236ad33`](https://github.com/nodejs/node/commit/593236ad33)] - **doc**: change color contrast for accessibility (Rich Trott) [#35047](https://github.com/nodejs/node/pull/35047)
+* [[`8c207c67d1`](https://github.com/nodejs/node/commit/8c207c67d1)] - **doc**: refactor deprecation anchors (Antoine du HAMEL) [#34955](https://github.com/nodejs/node/pull/34955)
+* [[`cc0aaf2384`](https://github.com/nodejs/node/commit/cc0aaf2384)] - **doc**: error code fix in resolver spec (Guy Bedford) [#34998](https://github.com/nodejs/node/pull/34998)
+* [[`a4201843e7`](https://github.com/nodejs/node/commit/a4201843e7)] - **doc**: use period consistently in man page (Rich Trott) [#34939](https://github.com/nodejs/node/pull/34939)
+* [[`f1217d6d8b`](https://github.com/nodejs/node/commit/f1217d6d8b)] - **doc**: revise commit-queue.md (Rich Trott) [#35006](https://github.com/nodejs/node/pull/35006)
+* [[`9aba579acb`](https://github.com/nodejs/node/commit/9aba579acb)] - **doc**: change effected to affected (Turner Jabbour) [#34989](https://github.com/nodejs/node/pull/34989)
+* [[`2598527112`](https://github.com/nodejs/node/commit/2598527112)] - **doc**: drop the --production flag for installing windows-build-tools (DeeDeeG) [#34979](https://github.com/nodejs/node/pull/34979)
+* [[`287ce7b810`](https://github.com/nodejs/node/commit/287ce7b810)] - **doc**: fix broken link to response.writableFinished in deprecations doc (Rich Trott) [#34983](https://github.com/nodejs/node/pull/34983)
+* [[`a0656ff863`](https://github.com/nodejs/node/commit/a0656ff863)] - **doc**: fix broken link to response.finished in deprecations doc (Rich Trott) [#34982](https://github.com/nodejs/node/pull/34982)
+* [[`f4524b8936`](https://github.com/nodejs/node/commit/f4524b8936)] - **doc**: fix broken link to writableEnded in deprecations doc (Rich Trott) [#34984](https://github.com/nodejs/node/pull/34984)
+* [[`514a538f64`](https://github.com/nodejs/node/commit/514a538f64)] - **doc**: fix typos in buffer doc (Robert Williams) [#34981](https://github.com/nodejs/node/pull/34981)
+* [[`df76c89b78`](https://github.com/nodejs/node/commit/df76c89b78)] - **doc**: recommend URL() over url.parse() in http2 doc (Rich Trott) [#34978](https://github.com/nodejs/node/pull/34978)
+* [[`ca0302e4f1`](https://github.com/nodejs/node/commit/ca0302e4f1)] - **doc**: arrange perf\_hooks entries alphabetically (Rich Trott) [#34973](https://github.com/nodejs/node/pull/34973)
+* [[`94c6e09367`](https://github.com/nodejs/node/commit/94c6e09367)] - **doc**: replace require() with reference links in http2.md (Rich Trott) [#34956](https://github.com/nodejs/node/pull/34956)
+* [[`2407a7a671`](https://github.com/nodejs/node/commit/2407a7a671)] - **doc**: add a note about possible missing lines to readline.asyncIterator (Igor Mikhalev) [#34675](https://github.com/nodejs/node/pull/34675)
+* [[`31098a4c0e`](https://github.com/nodejs/node/commit/31098a4c0e)] - **doc**: make minor improvements to query string sentence in http2.md (Rich Trott) [#34929](https://github.com/nodejs/node/pull/34929)
+* [[`1589f0e6f4`](https://github.com/nodejs/node/commit/1589f0e6f4)] - **doc**: make general copy-edit changes to policy.md (Rich Trott) [#34943](https://github.com/nodejs/node/pull/34943)
+* [[`aee3b8510b`](https://github.com/nodejs/node/commit/aee3b8510b)] - **doc**: simplify "make use of" to "use" (Rich Trott) [#34861](https://github.com/nodejs/node/pull/34861)
+* [[`0e09ff8ab1`](https://github.com/nodejs/node/commit/0e09ff8ab1)] - **doc**: make minor fixes to maintaining-openssl.md (Rich Trott) [#34926](https://github.com/nodejs/node/pull/34926)
+* [[`b091681d25`](https://github.com/nodejs/node/commit/b091681d25)] - **doc**: fix CHANGELOG.md parsing issue (Juan José Arboleda) [#34923](https://github.com/nodejs/node/pull/34923)
+* [[`fbd18be459`](https://github.com/nodejs/node/commit/fbd18be459)] - **doc**: provide more guidance about process.version (Rich Trott) [#34909](https://github.com/nodejs/node/pull/34909)
+* [[`4782ec7b3b`](https://github.com/nodejs/node/commit/4782ec7b3b)] - **doc**: use consistent typography for node-addon-api (Rich Trott) [#34910](https://github.com/nodejs/node/pull/34910)
+* [[`2fe95094fd`](https://github.com/nodejs/node/commit/2fe95094fd)] - **doc**: improve link-local text in dgram.md (Rich Trott) [#34868](https://github.com/nodejs/node/pull/34868)
+* [[`657292e2dd`](https://github.com/nodejs/node/commit/657292e2dd)] - **doc**: fix broken markdown/display in cli.html (Rich Trott) [#34892](https://github.com/nodejs/node/pull/34892)
+* [[`4cf93bb3cf`](https://github.com/nodejs/node/commit/4cf93bb3cf)] - **doc**: use "previous"/"preceding" instead of "above" as modifier (Rich Trott) [#34877](https://github.com/nodejs/node/pull/34877)
+* [[`29b048b06b`](https://github.com/nodejs/node/commit/29b048b06b)] - **doc**: use links to MS guide in style guide (Rich Trott) [#34871](https://github.com/nodejs/node/pull/34871)
+* [[`52be37cf39`](https://github.com/nodejs/node/commit/52be37cf39)] - **doc,tools**: remove malfunctioning Linux manpage linker (Rich Trott) [#34985](https://github.com/nodejs/node/pull/34985)
+* [[`fffba3a270`](https://github.com/nodejs/node/commit/fffba3a270)] - **errors**: use `ErrorPrototypeToString` from `primordials` object (ExE Boss) [#34891](https://github.com/nodejs/node/pull/34891)
+* [[`db8c66b8c2`](https://github.com/nodejs/node/commit/db8c66b8c2)] - **esm**: shorten ERR\_UNSUPPORTED\_ESM\_URL\_SCHEME message (Rich Trott) [#34836](https://github.com/nodejs/node/pull/34836)
+* [[`be71e717c5`](https://github.com/nodejs/node/commit/be71e717c5)] - **meta**: enable wasi for CODEOWNERS (gengjiawen) [#34889](https://github.com/nodejs/node/pull/34889)
+* [[`a43b7ff72e`](https://github.com/nodejs/node/commit/a43b7ff72e)] - **meta**: remove non-existent quic from CODEOWNERS (Richard Lau) [#34947](https://github.com/nodejs/node/pull/34947)
+* [[`3c32fe09e9`](https://github.com/nodejs/node/commit/3c32fe09e9)] - **n-api**: re-implement async env cleanup hooks (Gabriel Schulhof) [#34819](https://github.com/nodejs/node/pull/34819)
+* [[`fcb211f38a`](https://github.com/nodejs/node/commit/fcb211f38a)] - **net**: replace usage of internal stream state with public api (Denys Otrishko) [#34885](https://github.com/nodejs/node/pull/34885)
+* [[`8aac42caf2`](https://github.com/nodejs/node/commit/8aac42caf2)] - **(SEMVER-MINOR)** **perf_hooks**: add idleTime and event loop util (Trevor Norris) [#34938](https://github.com/nodejs/node/pull/34938)
+* [[`18b04ab4c8`](https://github.com/nodejs/node/commit/18b04ab4c8)] - **policy**: implement scopes field (Bradley Farias) [#34552](https://github.com/nodejs/node/pull/34552)
+* [[`1bf5d1a39b`](https://github.com/nodejs/node/commit/1bf5d1a39b)] - **querystring**: manage percent character at unescape (Daijiro Wachi) [#35013](https://github.com/nodejs/node/pull/35013)
+* [[`f21d78d537`](https://github.com/nodejs/node/commit/f21d78d537)] - **src**: shutdown libuv before exit() (Anna Henningsen) [#35021](https://github.com/nodejs/node/pull/35021)
+* [[`789798bedf`](https://github.com/nodejs/node/commit/789798bedf)] - **src**: add get/set pair for env context awareness (Shelley Vohr) [#35024](https://github.com/nodejs/node/pull/35024)
+* [[`73ef3f2f05`](https://github.com/nodejs/node/commit/73ef3f2f05)] - **src**: disallow JS execution during exit() (Anna Henningsen) [#35020](https://github.com/nodejs/node/pull/35020)
+* [[`f6a5999a9d`](https://github.com/nodejs/node/commit/f6a5999a9d)] - **src,doc**: fix wording to refer to context, not environment (Turner Jabbour) [#34880](https://github.com/nodejs/node/pull/34880)
+* [[`bcc1d431f8`](https://github.com/nodejs/node/commit/bcc1d431f8)] - **src,doc**: fix grammar due to missing 'is' (Turner Jabbour) [#34897](https://github.com/nodejs/node/pull/34897)
+* [[`044297ff10`](https://github.com/nodejs/node/commit/044297ff10)] - **src,doc**: rephrase for clarity (Turner Jabbour) [#34879](https://github.com/nodejs/node/pull/34879)
+* [[`4bb40078da`](https://github.com/nodejs/node/commit/4bb40078da)] - **(SEMVER-MINOR)** **stream**: simpler and faster Readable async iterator (Robert Nagy) [#34035](https://github.com/nodejs/node/pull/34035)
+* [[`ffae5f3809`](https://github.com/nodejs/node/commit/ffae5f3809)] - **(SEMVER-MINOR)** **stream**: save error in state (Robert Nagy) [#34103](https://github.com/nodejs/node/pull/34103)
+* [[`5f24cea11a`](https://github.com/nodejs/node/commit/5f24cea11a)] - **stream**: fix Readable stream state properties (Denys Otrishko) [#34886](https://github.com/nodejs/node/pull/34886)
+* [[`f537c868b9`](https://github.com/nodejs/node/commit/f537c868b9)] - **stream**: allow using `.push()`/`.unshift()` during `once('data')` (Anna Henningsen) [#34957](https://github.com/nodejs/node/pull/34957)
+* [[`4d533858cf`](https://github.com/nodejs/node/commit/4d533858cf)] - **test**: make .out checks embedder-friendly (Shelley Vohr) [#35040](https://github.com/nodejs/node/pull/35040)
+* [[`a756b92c4a`](https://github.com/nodejs/node/commit/a756b92c4a)] - **test**: use mustCall() in test-http-timeout (Pooja D.P) [#34996](https://github.com/nodejs/node/pull/34996)
+* [[`9011c87c1c`](https://github.com/nodejs/node/commit/9011c87c1c)] - **test**: change var to let (Pooja D.P) [#34902](https://github.com/nodejs/node/pull/34902)
+* [[`b698d2ec81`](https://github.com/nodejs/node/commit/b698d2ec81)] - **test**: remove incorrect debug() in test-policy-integrity (Rich Trott) [#34961](https://github.com/nodejs/node/pull/34961)
+* [[`ee6a583b9f`](https://github.com/nodejs/node/commit/ee6a583b9f)] - **test**: fix typo in test/parallel/test-icu-punycode.js (Daijiro Wachi) [#34934](https://github.com/nodejs/node/pull/34934)
+* [[`9057a1644d`](https://github.com/nodejs/node/commit/9057a1644d)] - **test**: add readline test for escape sequence (Rich Trott) [#34952](https://github.com/nodejs/node/pull/34952)
+* [[`75d16125e1`](https://github.com/nodejs/node/commit/75d16125e1)] - **test**: make test-tls-reuse-host-from-socket pass without internet (Rich Trott) [#34953](https://github.com/nodejs/node/pull/34953)
+* [[`971b7ac087`](https://github.com/nodejs/node/commit/971b7ac087)] - **test**: simplify test-vm-memleak (Rich Trott) [#34881](https://github.com/nodejs/node/pull/34881)
+* [[`577978a96c`](https://github.com/nodejs/node/commit/577978a96c)] - **tools**: fix docopen target (Antoine du HAMEL) [#35062](https://github.com/nodejs/node/pull/35062)
+* [[`2b445bb3ee`](https://github.com/nodejs/node/commit/2b445bb3ee)] - **tools**: fix doc build targets (Antoine du HAMEL) [#35060](https://github.com/nodejs/node/pull/35060)
+* [[`3d41ff25b7`](https://github.com/nodejs/node/commit/3d41ff25b7)] - **tools**: add banner to lint-md.js by rollup.config.js (KuthorX) [#34233](https://github.com/nodejs/node/pull/34233)
+* [[`62cc3b8249`](https://github.com/nodejs/node/commit/62cc3b8249)] - **tools**: update ESLint to 7.8.1 (cjihrig) [#35004](https://github.com/nodejs/node/pull/35004)
+* [[`c47d319ac6`](https://github.com/nodejs/node/commit/c47d319ac6)] - **tools**: update ESLint to 7.8.0 (cjihrig) [#35004](https://github.com/nodejs/node/pull/35004)
+* [[`b6f3ae8ffc`](https://github.com/nodejs/node/commit/b6f3ae8ffc)] - **tools,doc**: allow page titles to contain inline code (Antoine du HAMEL) [#35003](https://github.com/nodejs/node/pull/35003)
+* [[`fb2111e300`](https://github.com/nodejs/node/commit/fb2111e300)] - **tools,doc**: fix global table of content active element (Antoine du Hamel) [#34976](https://github.com/nodejs/node/pull/34976)
+* [[`7ad629e4e4`](https://github.com/nodejs/node/commit/7ad629e4e4)] - **tools,doc**: remove "toc" anchor name (Rich Trott) [#34893](https://github.com/nodejs/node/pull/34893)
+* [[`94528f510e`](https://github.com/nodejs/node/commit/94528f510e)] - **zlib**: replace usage of internal stream state with public api (Denys Otrishko) [#34884](https://github.com/nodejs/node/pull/34884)
+
+<a id="14.9.0"></a>
+## 2020-08-27, Version 14.9.0 (Current), @BethGriggs prepared by @danielleadams
+
+### Notable Changes
+
+* **build**: set --v8-enable-object-print by default (Mary Marchini) [#34705](https://github.com/nodejs/node/pull/34705)
+* **deps**:
+  * upgrade to libuv 1.39.0 (cjihrig) [#34915](https://github.com/nodejs/node/pull/34915)
+  * upgrade npm to 6.14.8 (Ruy Adorno) [#34834](https://github.com/nodejs/node/pull/34834)
+  * V8: cherry-pick e06ace6b5cdb (Anna Henningsen) [#34673](https://github.com/nodejs/node/pull/34673)
+* **n-api**: handle weak no-finalizer refs correctly (Gabriel Schulhof) [#34839](https://github.com/nodejs/node/pull/34839)
+* **tools**: add debug entitlements for macOS 10.15+ (Gabriele Greco) [#34378](https://github.com/nodejs/node/pull/34378)
+
+### Commits
+
+* [[`aaa6e43d3c`](https://github.com/nodejs/node/commit/aaa6e43d3c)] - Forces Powershell to use tls1.2 (Bartosz Sosnowski) [#33609](https://github.com/nodejs/node/pull/33609)
+* [[`8de6b72efa`](https://github.com/nodejs/node/commit/8de6b72efa)] - **benchmark**: add benchmark script for resourceUsage (Yash Ladha) [#34691](https://github.com/nodejs/node/pull/34691)
+* [[`e4450a199f`](https://github.com/nodejs/node/commit/e4450a199f)] - **benchmark**: update function\_args addon code (Anna Henningsen) [#34725](https://github.com/nodejs/node/pull/34725)
+* [[`332e38433b`](https://github.com/nodejs/node/commit/332e38433b)] - **(SEMVER-MINOR)** **buffer**: alias UInt ➡️ Uint in buffer methods (Anna Henningsen) [#34729](https://github.com/nodejs/node/pull/34729)
+* [[`7f0869f963`](https://github.com/nodejs/node/commit/7f0869f963)] - **build**: run link checker in linter workflow (Richard Lau) [#34810](https://github.com/nodejs/node/pull/34810)
+* [[`9ca4b2ad5c`](https://github.com/nodejs/node/commit/9ca4b2ad5c)] - **build**: add CODEOWNERS linter action (Mary Marchini) [#34739](https://github.com/nodejs/node/pull/34739)
+* [[`bdf26aebb4`](https://github.com/nodejs/node/commit/bdf26aebb4)] - **(SEMVER-MINOR)** **build**: add build flag for OSS-Fuzz integration (davkor) [#34761](https://github.com/nodejs/node/pull/34761)
+* [[`d89a83c62c`](https://github.com/nodejs/node/commit/d89a83c62c)] - **build**: move compiling for Windows ARM64 to Tier 2 (João Reis) [#34721](https://github.com/nodejs/node/pull/34721)
+* [[`aed82379dd`](https://github.com/nodejs/node/commit/aed82379dd)] - **build**: implement a Commit Queue in Actions (Mary Marchini) [#34112](https://github.com/nodejs/node/pull/34112)
+* [[`15c92083b5`](https://github.com/nodejs/node/commit/15c92083b5)] - **build**: set --v8-enable-object-print by default (Mary Marchini) [#34705](https://github.com/nodejs/node/pull/34705)
+* [[`201d3d7074`](https://github.com/nodejs/node/commit/201d3d7074)] - **build**: cover all benchmark addons with C++ linter (Anna Henningsen) [#34725](https://github.com/nodejs/node/pull/34725)
+* [[`2abc98e9ff`](https://github.com/nodejs/node/commit/2abc98e9ff)] - **build**: add flag to build V8 with OBJECT\_PRINT (Mary Marchini) [#32834](https://github.com/nodejs/node/pull/32834)
+* [[`6048421726`](https://github.com/nodejs/node/commit/6048421726)] - **build,win**: use x64 Node when building for ARM64 (Dennis Ameling) [#34009](https://github.com/nodejs/node/pull/34009)
+* [[`69bcca122e`](https://github.com/nodejs/node/commit/69bcca122e)] - **crypto**: avoid unitializing ECDH objects on error (Tobias Nießen) [#34302](https://github.com/nodejs/node/pull/34302)
+* [[`cf348542c6`](https://github.com/nodejs/node/commit/cf348542c6)] - **deps**: upgrade to libuv 1.39.0 (cjihrig) [#34915](https://github.com/nodejs/node/pull/34915)
+* [[`68b7a8db6f`](https://github.com/nodejs/node/commit/68b7a8db6f)] - **deps**: upgrade npm to 6.14.8 (Ruy Adorno) [#34834](https://github.com/nodejs/node/pull/34834)
+* [[`9527a2a8a7`](https://github.com/nodejs/node/commit/9527a2a8a7)] - **deps**: V8: cherry-pick e06ace6b5cdb (Anna Henningsen) [#34673](https://github.com/nodejs/node/pull/34673)
+* [[`cd32522c92`](https://github.com/nodejs/node/commit/cd32522c92)] - **doc**: add missing DEP ID for 'new crypto.Certificate()' (Beth Griggs) [#34940](https://github.com/nodejs/node/pull/34940)
+* [[`ff15c92a7f`](https://github.com/nodejs/node/commit/ff15c92a7f)] - **doc**: improve fs doc intro (James M Snell) [#34843](https://github.com/nodejs/node/pull/34843)
+* [[`dae93ca0cb`](https://github.com/nodejs/node/commit/dae93ca0cb)] - **doc**: indicate the format of process.version (Danny Guo) [#34872](https://github.com/nodejs/node/pull/34872)
+* [[`bf7f492cb6`](https://github.com/nodejs/node/commit/bf7f492cb6)] - **doc**: rename module pages (Antoine du HAMEL) [#34663](https://github.com/nodejs/node/pull/34663)
+* [[`f2c2f42195`](https://github.com/nodejs/node/commit/f2c2f42195)] - **doc**: improve wording in deprecations.md (Rich Trott) [#34860](https://github.com/nodejs/node/pull/34860)
+* [[`4b3b0e3f98`](https://github.com/nodejs/node/commit/4b3b0e3f98)] - **doc**: fix ESM/CJS wrapper example (Maksim Sinik) [#34853](https://github.com/nodejs/node/pull/34853)
+* [[`d6bb2ad5ea`](https://github.com/nodejs/node/commit/d6bb2ad5ea)] - **doc**: adopt Microsoft Style Guide officially (Rich Trott) [#34821](https://github.com/nodejs/node/pull/34821)
+* [[`e4679bd45d`](https://github.com/nodejs/node/commit/e4679bd45d)] - **doc**: use 'console' info string for console output (Rich Trott) [#34837](https://github.com/nodejs/node/pull/34837)
+* [[`b1c3fb73fc`](https://github.com/nodejs/node/commit/b1c3fb73fc)] - **doc**: fix bulleted list punctuation in BUILDING.md (Rich Trott) [#34849](https://github.com/nodejs/node/pull/34849)
+* [[`ef41ddf5cb`](https://github.com/nodejs/node/commit/ef41ddf5cb)] - **doc**: sort references lexically (Rich Trott) [#34848](https://github.com/nodejs/node/pull/34848)
+* [[`3133b75b68`](https://github.com/nodejs/node/commit/3133b75b68)] - **doc**: move addaleax to TSC emeritus (Anna Henningsen) [#34809](https://github.com/nodejs/node/pull/34809)
+* [[`5214de78cd`](https://github.com/nodejs/node/commit/5214de78cd)] - **doc**: remove space above version picker (Justice Almanzar) [#34768](https://github.com/nodejs/node/pull/34768)
+* [[`34430abd71`](https://github.com/nodejs/node/commit/34430abd71)] - **doc**: move module core module doc to separate page (Antoine du HAMEL) [#34747](https://github.com/nodejs/node/pull/34747)
+* [[`b356b79ca4`](https://github.com/nodejs/node/commit/b356b79ca4)] - **doc**: reorder deprecated tls docs (Jerome T.K. Covington) [#34687](https://github.com/nodejs/node/pull/34687)
+* [[`5c987ffc96`](https://github.com/nodejs/node/commit/5c987ffc96)] - **doc**: fix file name to main.mjs and not main.js in esm.md (Frank Lemanschik) [#34786](https://github.com/nodejs/node/pull/34786)
+* [[`969fb1c5e3`](https://github.com/nodejs/node/commit/969fb1c5e3)] - **doc**: improve async\_hooks snippets (Andrey Pechkurov) [#34829](https://github.com/nodejs/node/pull/34829)
+* [[`3360dcbfab`](https://github.com/nodejs/node/commit/3360dcbfab)] - **doc**: fix some typos and grammar mistakes (Hilla Shahrabani) [#34800](https://github.com/nodejs/node/pull/34800)
+* [[`47f2f45dd8`](https://github.com/nodejs/node/commit/47f2f45dd8)] - **doc**: deprecate (doc-only) crypto.Certificate() (Rich Trott) [#34697](https://github.com/nodejs/node/pull/34697)
+* [[`3bfe199c28`](https://github.com/nodejs/node/commit/3bfe199c28)] - **doc**: remove "is recommended from crypto legacy API text (Rich Trott) [#34697](https://github.com/nodejs/node/pull/34697)
+* [[`258f64f578`](https://github.com/nodejs/node/commit/258f64f578)] - **doc**: edit filehandle.close() entry in fs.md (Rich Trott) [#34782](https://github.com/nodejs/node/pull/34782)
+* [[`e54a6842e0`](https://github.com/nodejs/node/commit/e54a6842e0)] - **doc**: fix broken links in commit-queue.md (Luigi Pinca) [#34789](https://github.com/nodejs/node/pull/34789)
+* [[`3925fd6550`](https://github.com/nodejs/node/commit/3925fd6550)] - **doc**: avoid \_may\_ in collaborator guide (Rich Trott) [#34749](https://github.com/nodejs/node/pull/34749)
+* [[`cb0960635b`](https://github.com/nodejs/node/commit/cb0960635b)] - **doc**: use sentence-casing for headers in collaborator guide (Rich Trott) [#34713](https://github.com/nodejs/node/pull/34713)
+* [[`8b5690287c`](https://github.com/nodejs/node/commit/8b5690287c)] - **doc**: edit (general) collaborator guide (Rich Trott) [#34712](https://github.com/nodejs/node/pull/34712)
+* [[`b933eef1f3`](https://github.com/nodejs/node/commit/b933eef1f3)] - **doc**: reduce repetitiveness on Consensus Seeking (Mary Marchini) [#34702](https://github.com/nodejs/node/pull/34702)
+* [[`f7563f811a`](https://github.com/nodejs/node/commit/f7563f811a)] - **doc**: remove typo in crypto.md (Rich Trott) [#34698](https://github.com/nodejs/node/pull/34698)
+* [[`ea98122a51`](https://github.com/nodejs/node/commit/ea98122a51)] - **doc**: n-api environment life cycle APIs are stable (Jim Schlight) [#34641](https://github.com/nodejs/node/pull/34641)
+* [[`b00f71b660`](https://github.com/nodejs/node/commit/b00f71b660)] - **doc**: add padding in the sidebar column (Antoine du HAMEL) [#34665](https://github.com/nodejs/node/pull/34665)
+* [[`91f53245ae`](https://github.com/nodejs/node/commit/91f53245ae)] - **doc**: use semantically appropriate tag for lines (Antoine du HAMEL) [#34660](https://github.com/nodejs/node/pull/34660)
+* [[`230bcaf276`](https://github.com/nodejs/node/commit/230bcaf276)] - **doc**: add HPE\_UNEXPECTED\_CONTENT\_LENGTH error description (Nikolay Krashnikov) [#34596](https://github.com/nodejs/node/pull/34596)
+* [[`d29b805569`](https://github.com/nodejs/node/commit/d29b805569)] - **doc**: update http server response 'close' event (Renato Mariscal) [#34472](https://github.com/nodejs/node/pull/34472)
+* [[`b93ba07fa5`](https://github.com/nodejs/node/commit/b93ba07fa5)] - **doc**: add writable and readable options to Duplex docs (Priyank Singh) [#34383](https://github.com/nodejs/node/pull/34383)
+* [[`7cde699115`](https://github.com/nodejs/node/commit/7cde699115)] - **doc**: harden policy around objections (Mary Marchini) [#34639](https://github.com/nodejs/node/pull/34639)
+* [[`7d0970ca66`](https://github.com/nodejs/node/commit/7d0970ca66)] - **doc,lib**: remove unused error code (Rich Trott) [#34792](https://github.com/nodejs/node/pull/34792)
+* [[`9ebae0a758`](https://github.com/nodejs/node/commit/9ebae0a758)] - **doc,n-api**: add link to n-api tutorial website (Jim Schlight) [#34870](https://github.com/nodejs/node/pull/34870)
+* [[`cdd4540124`](https://github.com/nodejs/node/commit/cdd4540124)] - **doc,tools**: annotate broken links in actions workflow (Richard Lau) [#34810](https://github.com/nodejs/node/pull/34810)
+* [[`dbcb36d553`](https://github.com/nodejs/node/commit/dbcb36d553)] - **errors**: improve ERR\_INVALID\_OPT\_VALUE error (Denys Otrishko) [#34671](https://github.com/nodejs/node/pull/34671)
+* [[`8f38c19c08`](https://github.com/nodejs/node/commit/8f38c19c08)] - **esm**: improve error message of ERR\_UNSUPPORTED\_ESM\_URL\_SCHEME (Denys Otrishko) [#34795](https://github.com/nodejs/node/pull/34795)
+* [[`7ef5591d06`](https://github.com/nodejs/node/commit/7ef5591d06)] - **fs**: guard against undefined behavior (Robert Nagy) [#34746](https://github.com/nodejs/node/pull/34746)
+* [[`952f233e39`](https://github.com/nodejs/node/commit/952f233e39)] - **http**: add RFC references for each status code (Voltra) [#33671](https://github.com/nodejs/node/pull/33671)
+* [[`cc7258469c`](https://github.com/nodejs/node/commit/cc7258469c)] - **http2**: fix Http2Response.sendDate (João Lucas Lucchetta) [#34850](https://github.com/nodejs/node/pull/34850)
+* [[`9e0d18fd3f`](https://github.com/nodejs/node/commit/9e0d18fd3f)] - **http2**: use and support non-empty DATA frame with END\_STREAM flag (Carlos Lopez) [#33875](https://github.com/nodejs/node/pull/33875)
+* [[`6ee2578427`](https://github.com/nodejs/node/commit/6ee2578427)] - **http2**: add maxHeaderSize option to http2 (Priyank Singh) [#33636](https://github.com/nodejs/node/pull/33636)
+* [[`04defbaacd`](https://github.com/nodejs/node/commit/04defbaacd)] - **lib**: allow to validate enums with validateOneOf (Denys Otrishko) [#34070](https://github.com/nodejs/node/pull/34070)
+* [[`1a9496a79d`](https://github.com/nodejs/node/commit/1a9496a79d)] - **lib**: add UNC support to url.pathToFileURL() (Matthew McEachen) [#34743](https://github.com/nodejs/node/pull/34743)
+* [[`124a01d487`](https://github.com/nodejs/node/commit/124a01d487)] - **lib**: use full URL to GitHub issues in comments (Rich Trott) [#34686](https://github.com/nodejs/node/pull/34686)
+* [[`756c058c45`](https://github.com/nodejs/node/commit/756c058c45)] - **meta**: fix codeowners docs path (Mary Marchini) [#34811](https://github.com/nodejs/node/pull/34811)
+* [[`2781f646c9`](https://github.com/nodejs/node/commit/2781f646c9)] - **meta**: add TSC as owner of governance-related docs (Mary Marchini) [#34737](https://github.com/nodejs/node/pull/34737)
+* [[`a69d30eb3f`](https://github.com/nodejs/node/commit/a69d30eb3f)] - **module**: drop `-u` alias for `--conditions` (Richard Lau) [#34935](https://github.com/nodejs/node/pull/34935)
+* [[`e4a0e5bc1a`](https://github.com/nodejs/node/commit/e4a0e5bc1a)] - **module**: fix check for package.json at volume root (Derek Lewis) [#34595](https://github.com/nodejs/node/pull/34595)
+* [[`698cae7625`](https://github.com/nodejs/node/commit/698cae7625)] - **module**: share CJS/ESM resolver fns, refactoring (Guy Bedford) [#34744](https://github.com/nodejs/node/pull/34744)
+* [[`6929649793`](https://github.com/nodejs/node/commit/6929649793)] - **module**: custom --conditions flag option (Guy Bedford) [#34637](https://github.com/nodejs/node/pull/34637)
+* [[`9a7c87df37`](https://github.com/nodejs/node/commit/9a7c87df37)] - **module**: use cjsCache over esm injection (Guy Bedford) [#34605](https://github.com/nodejs/node/pull/34605)
+* [[`98f7d8ec81`](https://github.com/nodejs/node/commit/98f7d8ec81)] - **n-api**: handle weak no-finalizer refs correctly (Gabriel Schulhof) [#34839](https://github.com/nodejs/node/pull/34839)
+* [[`90abdd3dd4`](https://github.com/nodejs/node/commit/90abdd3dd4)] - **net**: validate custom lookup() output (cjihrig) [#34813](https://github.com/nodejs/node/pull/34813)
+* [[`84031183bc`](https://github.com/nodejs/node/commit/84031183bc)] - **policy**: support conditions for redirects (Bradley Farias) [#34414](https://github.com/nodejs/node/pull/34414)
+* [[`a16f0f427e`](https://github.com/nodejs/node/commit/a16f0f427e)] - **process**: correctly parse Unicode in NODE\_OPTIONS (Bartosz Sosnowski) [#34476](https://github.com/nodejs/node/pull/34476)
+* [[`fff1e7f86c`](https://github.com/nodejs/node/commit/fff1e7f86c)] - **src**: fix abort on uv\_loop\_init() failure (Ben Noordhuis) [#34874](https://github.com/nodejs/node/pull/34874)
+* [[`7666d95c7d`](https://github.com/nodejs/node/commit/7666d95c7d)] - **src**: usage of modernize-use-equals-default (Yash Ladha) [#34807](https://github.com/nodejs/node/pull/34807)
+* [[`3022e0d614`](https://github.com/nodejs/node/commit/3022e0d614)] - **src**: prefer C++ empty() in boolean expressions (Tobias Nießen) [#34432](https://github.com/nodejs/node/pull/34432)
+* [[`e16b3e72f9`](https://github.com/nodejs/node/commit/e16b3e72f9)] - **test**: fix test-cluster-net-listen-relative-path.js to run in / (Rich Trott) [#34820](https://github.com/nodejs/node/pull/34820)
+* [[`2a78c33445`](https://github.com/nodejs/node/commit/2a78c33445)] - **test**: run REPL preview test regardless of terminal type (Rich Trott) [#34798](https://github.com/nodejs/node/pull/34798)
+* [[`6b45bf3475`](https://github.com/nodejs/node/commit/6b45bf3475)] - **test**: modernize test-cluster-master-error (Anna Henningsen) [#34685](https://github.com/nodejs/node/pull/34685)
+* [[`c080fc590d`](https://github.com/nodejs/node/commit/c080fc590d)] - **test**: move test-inspector-already-activated-cli to parallel (Rich Trott) [#34755](https://github.com/nodejs/node/pull/34755)
+* [[`7ed7ef7ad8`](https://github.com/nodejs/node/commit/7ed7ef7ad8)] - **test**: move execution of WPT to worker threads (Michaël Zasso) [#34796](https://github.com/nodejs/node/pull/34796)
+* [[`e8eed5c426`](https://github.com/nodejs/node/commit/e8eed5c426)] - **test**: convert assertion that always fails to assert.fail() (Rich Trott) [#34793](https://github.com/nodejs/node/pull/34793)
+* [[`c458e8406e`](https://github.com/nodejs/node/commit/c458e8406e)] - **test**: remove common.rootDir (Rich Trott) [#34772](https://github.com/nodejs/node/pull/34772)
+* [[`1c324d5939`](https://github.com/nodejs/node/commit/1c324d5939)] - **test**: allow ENOENT in test-worker-init-failure (Rich Trott) [#34769](https://github.com/nodejs/node/pull/34769)
+* [[`88919e584b`](https://github.com/nodejs/node/commit/88919e584b)] - **test**: allow ENFILE in test-worker-init-failure (Rich Trott) [#34769](https://github.com/nodejs/node/pull/34769)
+* [[`a78c638fc3`](https://github.com/nodejs/node/commit/a78c638fc3)] - **test**: use process.env.PYTHON to spawn python (Anna Henningsen) [#34700](https://github.com/nodejs/node/pull/34700)
+* [[`9a790203ed`](https://github.com/nodejs/node/commit/9a790203ed)] - **test**: remove error message checking in test-worker-init-failure (Rich Trott) [#34727](https://github.com/nodejs/node/pull/34727)
+* [[`0472d1629a`](https://github.com/nodejs/node/commit/0472d1629a)] - **test**: skip node-api/test\_worker\_terminate\_finalization (Anna Henningsen) [#34732](https://github.com/nodejs/node/pull/34732)
+* [[`8e91f3ec0a`](https://github.com/nodejs/node/commit/8e91f3ec0a)] - **test**: fix test\_worker\_terminate\_finalization (Anna Henningsen) [#34726](https://github.com/nodejs/node/pull/34726)
+* [[`fd5153c822`](https://github.com/nodejs/node/commit/fd5153c822)] - **test**: split test-crypto-dh-hash (Rich Trott) [#34631](https://github.com/nodejs/node/pull/34631)
+* [[`9f0917e656`](https://github.com/nodejs/node/commit/9f0917e656)] - **test**: use block-scoping in test/pummel/test-timers.js (Rich Trott) [#34630](https://github.com/nodejs/node/pull/34630)
+* [[`b261895d2b`](https://github.com/nodejs/node/commit/b261895d2b)] - **test**: remove test-child-process-fork-args flaky designation (Rich Trott) [#34684](https://github.com/nodejs/node/pull/34684)
+* [[`27c0653517`](https://github.com/nodejs/node/commit/27c0653517)] - **test**: add vm crash regression test (Anna Henningsen) [#34673](https://github.com/nodejs/node/pull/34673)
+* [[`093a4b0ae4`](https://github.com/nodejs/node/commit/093a4b0ae4)] - **test**: add tests for validateNumber/validateString (Denys Otrishko) [#34672](https://github.com/nodejs/node/pull/34672)
+* [[`5009d82b0c`](https://github.com/nodejs/node/commit/5009d82b0c)] - **test,doc**: add missing uv\_setup\_args() calls (cjihrig) [#34751](https://github.com/nodejs/node/pull/34751)
+* [[`cca0372022`](https://github.com/nodejs/node/commit/cca0372022)] - **(SEMVER-MINOR)** **timers**: allow timers to be used as primitives (Denys Otrishko) [#34017](https://github.com/nodejs/node/pull/34017)
+* [[`e90cb49390`](https://github.com/nodejs/node/commit/e90cb49390)] - **tls**: enable renegotiation when using BoringSSL (Jeremy Rose) [#34832](https://github.com/nodejs/node/pull/34832)
+* [[`8766b5bfd5`](https://github.com/nodejs/node/commit/8766b5bfd5)] - **tools**: add debug entitlements for macOS 10.15+ (Gabriele Greco) [#34378](https://github.com/nodejs/node/pull/34378)
+* [[`77bbd73919`](https://github.com/nodejs/node/commit/77bbd73919)] - **util**: add debug and debuglog.enabled (Bradley Farias) [#33424](https://github.com/nodejs/node/pull/33424)
+* [[`513ab0e02f`](https://github.com/nodejs/node/commit/513ab0e02f)] - **worker**: fix --abort-on-uncaught-exception handling (Anna Henningsen) [#34724](https://github.com/nodejs/node/pull/34724)
+* [[`03d601344a`](https://github.com/nodejs/node/commit/03d601344a)] - **worker**: do not crash when JSTransferable lists untransferable value (Anna Henningsen) [#34766](https://github.com/nodejs/node/pull/34766)
+* [[`b73943e476`](https://github.com/nodejs/node/commit/b73943e476)] - **workers**: add support for data: URLs (Antoine du HAMEL) [#34584](https://github.com/nodejs/node/pull/34584)
+
+<a id="14.8.0"></a>
+## 2020-08-11, Version 14.8.0 (Current), @codebytere
+
+### Notable Changes
+
+* [[`16aa927216`](https://github.com/nodejs/node/commit/16aa927216)] - **(SEMVER-MINOR)** **async_hooks**: add AsyncResource.bind utility (James M Snell) [#34574](https://github.com/nodejs/node/pull/34574)
+* [[`dc49561e8d`](https://github.com/nodejs/node/commit/dc49561e8d)] - **deps**: update to uvwasi 0.0.10 (Colin Ihrig) [#34623](https://github.com/nodejs/node/pull/34623)
+* [[`6cd1c41604`](https://github.com/nodejs/node/commit/6cd1c41604)] - **doc**: add Ricky Zhou to collaborators (rickyes) [#34676](https://github.com/nodejs/node/pull/34676)
+* [[`f0a41b2530`](https://github.com/nodejs/node/commit/f0a41b2530)] - **doc**: add release key for Ruy Adorno (Ruy Adorno) [#34628](https://github.com/nodejs/node/pull/34628)
+* [[`10dd7a0eda`](https://github.com/nodejs/node/commit/10dd7a0eda)] - **doc**: add DerekNonGeneric to collaborators (Derek Lewis) [#34602](https://github.com/nodejs/node/pull/34602)
+* [[`62bb2e757f`](https://github.com/nodejs/node/commit/62bb2e757f)] - **(SEMVER-MINOR)** **module**: unflag Top-Level Await (Myles Borins) [#34558](https://github.com/nodejs/node/pull/34558)
+* [[`8cc9e5eb52`](https://github.com/nodejs/node/commit/8cc9e5eb52)] - **(SEMVER-MINOR)** **n-api**: support type-tagging objects (Gabriel Schulhof) [#28237](https://github.com/nodejs/node/pull/28237)
+* [[`e89ec46ba9`](https://github.com/nodejs/node/commit/e89ec46ba9)] - **(SEMVER-MINOR)** **n-api,src**: provide asynchronous cleanup hooks (Anna Henningsen) [#34572](https://github.com/nodejs/node/pull/34572)
+
+### Commits
+
+* [[`650248922b`](https://github.com/nodejs/node/commit/650248922b)] - **async_hooks**: avoid GC tracking of AsyncResource in ALS (Gerhard Stoebich) [#34653](https://github.com/nodejs/node/pull/34653)
+* [[`0a51aa8fdb`](https://github.com/nodejs/node/commit/0a51aa8fdb)] - **async_hooks**: avoid unneeded AsyncResource creation (Gerhard Stoebich) [#34616](https://github.com/nodejs/node/pull/34616)
+* [[`0af9bee4c3`](https://github.com/nodejs/node/commit/0af9bee4c3)] - **async_hooks**: improve property descriptors in als.bind (Gerhard Stoebich) [#34620](https://github.com/nodejs/node/pull/34620)
+* [[`16aa927216`](https://github.com/nodejs/node/commit/16aa927216)] - **(SEMVER-MINOR)** **async_hooks**: add AsyncResource.bind utility (James M Snell) [#34574](https://github.com/nodejs/node/pull/34574)
+* [[`e45c68af27`](https://github.com/nodejs/node/commit/e45c68af27)] - **async_hooks**: don't read resource if ALS is disabled (Gerhard Stoebich) [#34617](https://github.com/nodejs/node/pull/34617)
+* [[`e9aebc3a8f`](https://github.com/nodejs/node/commit/e9aebc3a8f)] - **async_hooks**: fix id assignment in fast-path promise hook (Andrey Pechkurov) [#34548](https://github.com/nodejs/node/pull/34548)
+* [[`5aed83c77f`](https://github.com/nodejs/node/commit/5aed83c77f)] - **async_hooks**: fix resource stack for deep stacks (Anna Henningsen) [#34573](https://github.com/nodejs/node/pull/34573)
+* [[`9af62641c6`](https://github.com/nodejs/node/commit/9af62641c6)] - **async_hooks**: execute destroy hooks earlier (Gerhard Stoebich) [#34342](https://github.com/nodejs/node/pull/34342)
+* [[`14656e1703`](https://github.com/nodejs/node/commit/14656e1703)] - **async_hooks**: don't reuse resource in HttpAgent when queued (Andrey Pechkurov) [#34439](https://github.com/nodejs/node/pull/34439)
+* [[`c4457d873f`](https://github.com/nodejs/node/commit/c4457d873f)] - **benchmark**: always throw the same Error instance (Anna Henningsen) [#34523](https://github.com/nodejs/node/pull/34523)
+* [[`6a129d0cf5`](https://github.com/nodejs/node/commit/6a129d0cf5)] - **build**: do not run auto-start-ci on forks (Evan Lucas) [#34650](https://github.com/nodejs/node/pull/34650)
+* [[`2cd299b217`](https://github.com/nodejs/node/commit/2cd299b217)] - **build**: run CI on release branches (Shelley Vohr) [#34649](https://github.com/nodejs/node/pull/34649)
+* [[`9ed9ccc5b3`](https://github.com/nodejs/node/commit/9ed9ccc5b3)] - **build**: enable build for node-v8 push (gengjiawen) [#34634](https://github.com/nodejs/node/pull/34634)
+* [[`10f29e7550`](https://github.com/nodejs/node/commit/10f29e7550)] - **build**: increase startCI verbosity and fix job name (Mary Marchini) [#34635](https://github.com/nodejs/node/pull/34635)
+* [[`befbaf384e`](https://github.com/nodejs/node/commit/befbaf384e)] - **build**: don't run auto-start-ci on push (Mary Marchini) [#34588](https://github.com/nodejs/node/pull/34588)
+* [[`4af5dbd3bf`](https://github.com/nodejs/node/commit/4af5dbd3bf)] - **build**: fix auto-start-ci script path (Mary Marchini) [#34588](https://github.com/nodejs/node/pull/34588)
+* [[`70cf3cbdfa`](https://github.com/nodejs/node/commit/70cf3cbdfa)] - **build**: auto start Jenkins CI via PR labels (Mary Marchini) [#34089](https://github.com/nodejs/node/pull/34089)
+* [[`70e9eceeee`](https://github.com/nodejs/node/commit/70e9eceeee)] - **build**: toolchain.gypi and node\_gyp.py cleanup (iandrc) [#34268](https://github.com/nodejs/node/pull/34268)
+* [[`465968c5f8`](https://github.com/nodejs/node/commit/465968c5f8)] - **console**: document the behavior of console.assert() (iandrc) [#34501](https://github.com/nodejs/node/pull/34501)
+* [[`a7b4318df9`](https://github.com/nodejs/node/commit/a7b4318df9)] - **crypto**: add OP flag constants added in OpenSSL v1.1.1 (Mateusz Krawczuk) [#33929](https://github.com/nodejs/node/pull/33929)
+* [[`dc49561e8d`](https://github.com/nodejs/node/commit/dc49561e8d)] - **deps**: update to uvwasi 0.0.10 (Colin Ihrig) [#34623](https://github.com/nodejs/node/pull/34623)
+* [[`8b1ec43da4`](https://github.com/nodejs/node/commit/8b1ec43da4)] - **doc**: use \_Static method\_ instead of \_Class Method\_ (Rich Trott) [#34659](https://github.com/nodejs/node/pull/34659)
+* [[`a1b9d7f42e`](https://github.com/nodejs/node/commit/a1b9d7f42e)] - **doc**: tidy some addons.md text (Rich Trott) [#34654](https://github.com/nodejs/node/pull/34654)
+* [[`b78278b922`](https://github.com/nodejs/node/commit/b78278b922)] - **doc**: use \_Class Method\_ in async\_hooks.md (Rich Trott) [#34626](https://github.com/nodejs/node/pull/34626)
+* [[`6cd1c41604`](https://github.com/nodejs/node/commit/6cd1c41604)] - **doc**: add Ricky Zhou to collaborators (rickyes) [#34676](https://github.com/nodejs/node/pull/34676)
+* [[`d8e0deaa7c`](https://github.com/nodejs/node/commit/d8e0deaa7c)] - **doc**: edit process.title note for brevity and clarity (Rich Trott) [#34627](https://github.com/nodejs/node/pull/34627)
+* [[`dd6bf20e8f`](https://github.com/nodejs/node/commit/dd6bf20e8f)] - **doc**: update fs.watch() availability for IBM i (iandrc) [#34611](https://github.com/nodejs/node/pull/34611)
+* [[`f260bdd57b`](https://github.com/nodejs/node/commit/f260bdd57b)] - **doc**: fix typo in path.md (aetheryx) [#34550](https://github.com/nodejs/node/pull/34550)
+* [[`f0a41b2530`](https://github.com/nodejs/node/commit/f0a41b2530)] - **doc**: add release key for Ruy Adorno (Ruy Adorno) [#34628](https://github.com/nodejs/node/pull/34628)
+* [[`3f55dcd723`](https://github.com/nodejs/node/commit/3f55dcd723)] - **doc**: clarify process.title inconsistencies (Corey Butler) [#34557](https://github.com/nodejs/node/pull/34557)
+* [[`6cd9ea82f6`](https://github.com/nodejs/node/commit/6cd9ea82f6)] - **doc**: document the connection event for HTTP2 & TLS servers (Tim Perry) [#34531](https://github.com/nodejs/node/pull/34531)
+* [[`0a9389bb1a`](https://github.com/nodejs/node/commit/0a9389bb1a)] - **doc**: mention null special-case for `napi\_typeof` (Renée Kooi) [#34577](https://github.com/nodejs/node/pull/34577)
+* [[`10dd7a0eda`](https://github.com/nodejs/node/commit/10dd7a0eda)] - **doc**: add DerekNonGeneric to collaborators (Derek Lewis) [#34602](https://github.com/nodejs/node/pull/34602)
+* [[`d7eaf3a027`](https://github.com/nodejs/node/commit/d7eaf3a027)] - **doc**: revise N-API versions matrix text (Rich Trott) [#34566](https://github.com/nodejs/node/pull/34566)
+* [[`e2bea73b03`](https://github.com/nodejs/node/commit/e2bea73b03)] - **doc**: clarify N-API version 1 (Michael Dawson) [#34344](https://github.com/nodejs/node/pull/34344)
+* [[`be23e23361`](https://github.com/nodejs/node/commit/be23e23361)] - **doc**: use consistent spelling for "falsy" (Rich Trott) [#34545](https://github.com/nodejs/node/pull/34545)
+* [[`f393ae9296`](https://github.com/nodejs/node/commit/f393ae9296)] - **doc**: simplify and clarify console.assert() documentation (Rich Trott) [#34544](https://github.com/nodejs/node/pull/34544)
+* [[`b69ff2ff60`](https://github.com/nodejs/node/commit/b69ff2ff60)] - **doc**: use consistent capitalization for addons (Rich Trott) [#34536](https://github.com/nodejs/node/pull/34536)
+* [[`212d17fa06`](https://github.com/nodejs/node/commit/212d17fa06)] - **doc**: add mmarchini pronouns (Mary Marchini) [#34586](https://github.com/nodejs/node/pull/34586)
+* [[`7a28c3d543`](https://github.com/nodejs/node/commit/7a28c3d543)] - **doc**: update mmarchini contact info (Mary Marchini) [#34586](https://github.com/nodejs/node/pull/34586)
+* [[`c8104f3d10`](https://github.com/nodejs/node/commit/c8104f3d10)] - **doc**: update .mailmap for mmarchini (Mary Marchini) [#34586](https://github.com/nodejs/node/pull/34586)
+* [[`692a735881`](https://github.com/nodejs/node/commit/692a735881)] - **doc**: use sentence-case for headers in SECURITY.md (Rich Trott) [#34525](https://github.com/nodejs/node/pull/34525)
+* [[`44e6c010b4`](https://github.com/nodejs/node/commit/44e6c010b4)] - **esm**: fix hook mistypes and links to types (Derek Lewis) [#34240](https://github.com/nodejs/node/pull/34240)
+* [[`7322e58d11`](https://github.com/nodejs/node/commit/7322e58d11)] - **http**: reset headers timeout on headers complete (Robert Nagy) [#34578](https://github.com/nodejs/node/pull/34578)
+* [[`36fd3daae6`](https://github.com/nodejs/node/commit/36fd3daae6)] - **http**: provide keep-alive timeout response header (Robert Nagy) [#34561](https://github.com/nodejs/node/pull/34561)
+* [[`d0efaf2fe3`](https://github.com/nodejs/node/commit/d0efaf2fe3)] - **lib**: use non-symbols in isURLInstance check (Shelley Vohr) [#34622](https://github.com/nodejs/node/pull/34622)
+* [[`335cb0d1d1`](https://github.com/nodejs/node/commit/335cb0d1d1)] - **lib**: absorb `path` error cases (Gireesh Punathil) [#34519](https://github.com/nodejs/node/pull/34519)
+* [[`521e620533`](https://github.com/nodejs/node/commit/521e620533)] - **meta**: uncomment all codeowners (Mary Marchini) [#34670](https://github.com/nodejs/node/pull/34670)
+* [[`650adeca22`](https://github.com/nodejs/node/commit/650adeca22)] - **meta**: enable http2 team for CODEOWNERS (Rich Trott) [#34534](https://github.com/nodejs/node/pull/34534)
+* [[`35ef9907aa`](https://github.com/nodejs/node/commit/35ef9907aa)] - **module**: handle Top-Level Await non-fulfills better (Anna Henningsen) [#34640](https://github.com/nodejs/node/pull/34640)
+* [[`62bb2e757f`](https://github.com/nodejs/node/commit/62bb2e757f)] - **(SEMVER-MINOR)** **module**: unflag Top-Level Await (Myles Borins) [#34558](https://github.com/nodejs/node/pull/34558)
+* [[`fbd411d28a`](https://github.com/nodejs/node/commit/fbd411d28a)] - **n-api**: fix use-after-free with napi\_remove\_async\_cleanup\_hook (Anna Henningsen) [#34662](https://github.com/nodejs/node/pull/34662)
+* [[`8cc9e5eb52`](https://github.com/nodejs/node/commit/8cc9e5eb52)] - **(SEMVER-MINOR)** **n-api**: support type-tagging objects (Gabriel Schulhof) [#28237](https://github.com/nodejs/node/pull/28237)
+* [[`2703fe498e`](https://github.com/nodejs/node/commit/2703fe498e)] - **n-api**: simplify bigint-from-word creation (Gabriel Schulhof) [#34554](https://github.com/nodejs/node/pull/34554)
+* [[`e89ec46ba9`](https://github.com/nodejs/node/commit/e89ec46ba9)] - **(SEMVER-MINOR)** **n-api,src**: provide asynchronous cleanup hooks (Anna Henningsen) [#34572](https://github.com/nodejs/node/pull/34572)
+* [[`b1890e0866`](https://github.com/nodejs/node/commit/b1890e0866)] - **net**: don't return the stream object from onStreamRead (Robey Pointer) [#34375](https://github.com/nodejs/node/pull/34375)
+* [[`35fdfb44a2`](https://github.com/nodejs/node/commit/35fdfb44a2)] - **policy**: increase tests via permutation matrix (Bradley Meck) [#34404](https://github.com/nodejs/node/pull/34404)
+* [[`ddd339ff45`](https://github.com/nodejs/node/commit/ddd339ff45)] - **repl**: use \_Node.js\_ in user-facing REPL text (Rich Trott) [#34644](https://github.com/nodejs/node/pull/34644)
+* [[`276e2980e2`](https://github.com/nodejs/node/commit/276e2980e2)] - **repl**: use \_REPL\_ in user-facing text (Rich Trott) [#34643](https://github.com/nodejs/node/pull/34643)
+* [[`465c262ac6`](https://github.com/nodejs/node/commit/465c262ac6)] - **repl**: improve static import error message in repl (Myles Borins) [#33588](https://github.com/nodejs/node/pull/33588)
+* [[`12cb0fb8a0`](https://github.com/nodejs/node/commit/12cb0fb8a0)] - **repl**: give repl entries unique names (Bradley Meck) [#34372](https://github.com/nodejs/node/pull/34372)
+* [[`2dbd15a075`](https://github.com/nodejs/node/commit/2dbd15a075)] - **src**: fix linter failures (Anna Henningsen) [#34582](https://github.com/nodejs/node/pull/34582)
+* [[`2761f349ec`](https://github.com/nodejs/node/commit/2761f349ec)] - **src**: spin shutdown loop while immediates are pending (Anna Henningsen) [#34662](https://github.com/nodejs/node/pull/34662)
+* [[`39ca48c840`](https://github.com/nodejs/node/commit/39ca48c840)] - **src**: fix `size` underflow in CallbackQueue (Anna Henningsen) [#34662](https://github.com/nodejs/node/pull/34662)
+* [[`c1abc8d3e5`](https://github.com/nodejs/node/commit/c1abc8d3e5)] - **src**: fix unused namespace member in node\_util (Andrey Pechkurov) [#34565](https://github.com/nodejs/node/pull/34565)
+* [[`e146686972`](https://github.com/nodejs/node/commit/e146686972)] - **test**: fix wrong method call (gengjiawen) [#34629](https://github.com/nodejs/node/pull/34629)
+* [[`ca89c375f7`](https://github.com/nodejs/node/commit/ca89c375f7)] - **test**: add debugging for callbacks in test-https-foafssl.js (Rich Trott) [#34603](https://github.com/nodejs/node/pull/34603)
+* [[`2133b18bee`](https://github.com/nodejs/node/commit/2133b18bee)] - **test**: add debugging for test-https-foafssl.js (Rich Trott) [#34603](https://github.com/nodejs/node/pull/34603)
+* [[`b9fb0c63b3`](https://github.com/nodejs/node/commit/b9fb0c63b3)] - **test**: convert most N-API tests from C++ to C (Gabriel Schulhof) [#34615](https://github.com/nodejs/node/pull/34615)
+* [[`54a4c6a39c`](https://github.com/nodejs/node/commit/54a4c6a39c)] - **test**: replace flaky pummel regression tests (Anna Henningsen) [#34530](https://github.com/nodejs/node/pull/34530)
+* [[`bd55236788`](https://github.com/nodejs/node/commit/bd55236788)] - **test**: change Fixes: to Refs: (Rich Trott) [#34568](https://github.com/nodejs/node/pull/34568)
+* [[`a340587cfd`](https://github.com/nodejs/node/commit/a340587cfd)] - **test**: fix flaky http-parser-timeout-reset (Robert Nagy) [#34609](https://github.com/nodejs/node/pull/34609)
+* [[`9c442f9786`](https://github.com/nodejs/node/commit/9c442f9786)] - **test**: remove unneeded flag check in test-vm-memleak (Rich Trott) [#34528](https://github.com/nodejs/node/pull/34528)
+* [[`05100e1eec`](https://github.com/nodejs/node/commit/05100e1eec)] - **tools**: fix C++ import checker argument expansion (Anna Henningsen) [#34582](https://github.com/nodejs/node/pull/34582)
+* [[`bf6c8aaae3`](https://github.com/nodejs/node/commit/bf6c8aaae3)] - **tools**: update ESLint to 7.6.0 (Colin Ihrig) [#34589](https://github.com/nodejs/node/pull/34589)
+* [[`0b1616c2f0`](https://github.com/nodejs/node/commit/0b1616c2f0)] - **tools**: add meta.fixable to fixable lint rules (Colin Ihrig) [#34589](https://github.com/nodejs/node/pull/34589)
+* [[`f46649bc5b`](https://github.com/nodejs/node/commit/f46649bc5b)] - **util**: print External address from inspect (unknown) [#34398](https://github.com/nodejs/node/pull/34398)
+* [[`2fa24c0ccc`](https://github.com/nodejs/node/commit/2fa24c0ccc)] - **wasi**: add \_\_wasi\_fd\_filestat\_set\_times() test (Colin Ihrig) [#34623](https://github.com/nodejs/node/pull/34623)
+
+<a id="14.7.0"></a>
+## 2020-07-29, Version 14.7.0 (Current), @MylesBorins prepared by @ruyadorno
+
+### Notable Changes
+
+* **deps**:
+  * upgrade npm to 6.14.7 (claudiahdz) [#34468](https://github.com/nodejs/node/pull/34468)
+* **dgram**:
+  * **(SEMVER-MINOR)** add IPv6 scope id suffix to received udp6 dgrams (Pekka Nikander) [#14500](https://github.com/nodejs/node/pull/14500)
+* **src**:
+  * **(SEMVER-MINOR)** allow preventing SetPromiseRejectCallback (Shelley Vohr) [#34387](https://github.com/nodejs/node/pull/34387)
+  * **(SEMVER-MINOR)** allow setting a dir for all diagnostic output (AshCripps) [#33584](https://github.com/nodejs/node/pull/33584)
+* **worker**:
+  * **(SEMVER-MINOR)** make MessagePort inherit from EventTarget (Anna Henningsen) [#34057](https://github.com/nodejs/node/pull/34057)
+* **zlib**:
+  * switch to lazy init for zlib streams (Andrey Pechkurov) [#34048](https://github.com/nodejs/node/pull/34048)
+* **New Collaborators**:
+  * add rexagod to collaborators (Pranshu Srivastava) [#34457](https://github.com/nodejs/node/pull/34457)
+  * add AshCripps to collaborators (AshCripps) [#34494](https://github.com/nodejs/node/pull/34494)
+  * add HarshithaKP to collaborators (Harshitha K P) [#34417](https://github.com/nodejs/node/pull/34417)
+  * add release key for Richard Lau (Richard Lau) [#34397](https://github.com/nodejs/node/pull/34397)
+
+### Commits
+
+* [[`dd2988917f`](https://github.com/nodejs/node/commit/dd2988917f)] - **async_hooks**: optimize fast-path promise hook for ALS (Andrey Pechkurov) [#34512](https://github.com/nodejs/node/pull/34512)
+* [[`358b934284`](https://github.com/nodejs/node/commit/358b934284)] - **build**: fix test-ci-js task in Makefile (Rich Trott) [#34433](https://github.com/nodejs/node/pull/34433)
+* [[`24e1beb829`](https://github.com/nodejs/node/commit/24e1beb829)] - **build**: do not run benchmark tests on 'make test' (Rich Trott) [#34434](https://github.com/nodejs/node/pull/34434)
+* [[`b24f254472`](https://github.com/nodejs/node/commit/b24f254472)] - **build**: add benchmark tests to CI runs (Rich Trott) [#34288](https://github.com/nodejs/node/pull/34288)
+* [[`a4806e2d12`](https://github.com/nodejs/node/commit/a4806e2d12)] - **build**: speed up source tarball creation (Richard Lau) [#34508](https://github.com/nodejs/node/pull/34508)
+* [[`cce1f3e3a8`](https://github.com/nodejs/node/commit/cce1f3e3a8)] - **build**: don't run test-asan workflow on non-master pushes (Richard Lau) [#34509](https://github.com/nodejs/node/pull/34509)
+* [[`70f23eb405`](https://github.com/nodejs/node/commit/70f23eb405)] - **build**: remove test-tarball action for windows + osx (Myles Borins) [#34440](https://github.com/nodejs/node/pull/34440)
+* [[`3fda3d4bf3`](https://github.com/nodejs/node/commit/3fda3d4bf3)] - **build**: don't run Actions on non-master pushes (Shelley Vohr) [#34464](https://github.com/nodejs/node/pull/34464)
+* [[`f7600d5ab6`](https://github.com/nodejs/node/commit/f7600d5ab6)] - **deps**: upgrade npm to 6.14.7 (claudiahdz) [#34468](https://github.com/nodejs/node/pull/34468)
+* [[`02ae6d65d4`](https://github.com/nodejs/node/commit/02ae6d65d4)] - **(SEMVER-MINOR)** **dgram**: add IPv6 scope id suffix to received udp6 dgrams (Pekka Nikander) [#14500](https://github.com/nodejs/node/pull/14500)
+* [[`e5f380052f`](https://github.com/nodejs/node/commit/e5f380052f)] - ***Revert*** "**doc**: move ronkorving to emeritus" (Rich Trott) [#34507](https://github.com/nodejs/node/pull/34507)
+* [[`17bca62428`](https://github.com/nodejs/node/commit/17bca62428)] - **doc**: use sentence-case for GOVERNANCE.md headers (Rich Trott) [#34503](https://github.com/nodejs/node/pull/34503)
+* [[`37752cde43`](https://github.com/nodejs/node/commit/37752cde43)] - **doc**: revise onboarding-extras (Rich Trott) [#34496](https://github.com/nodejs/node/pull/34496)
+* [[`050866ddf1`](https://github.com/nodejs/node/commit/050866ddf1)] - **doc**: remove breaking-change-helper from onboarding-extras (Rich Trott) [#34497](https://github.com/nodejs/node/pull/34497)
+* [[`2297d74fd8`](https://github.com/nodejs/node/commit/2297d74fd8)] - **doc**: add Triagers section to table of contents in GOVERNANCE.md (Rich Trott) [#34504](https://github.com/nodejs/node/pull/34504)
+* [[`99a648738c`](https://github.com/nodejs/node/commit/99a648738c)] - **doc**: onboarding process extras (Gireesh Punathil) [#34455](https://github.com/nodejs/node/pull/34455)
+* [[`bbc7eeadd9`](https://github.com/nodejs/node/commit/bbc7eeadd9)] - **doc**: mention triage in GOVERNANCE.md (Gireesh Punathil) [#34426](https://github.com/nodejs/node/pull/34426)
+* [[`92c57b284b`](https://github.com/nodejs/node/commit/92c57b284b)] - **doc**: move thefourtheye to emeritus (Rich Trott) [#34471](https://github.com/nodejs/node/pull/34471)
+* [[`657f2d78ee`](https://github.com/nodejs/node/commit/657f2d78ee)] - **doc**: move ronkorving to emeritus (Rich Trott) [#34471](https://github.com/nodejs/node/pull/34471)
+* [[`455dd9cc76`](https://github.com/nodejs/node/commit/455dd9cc76)] - **doc**: match link text in index to doc headline (Rich Trott) [#34449](https://github.com/nodejs/node/pull/34449)
+* [[`f4a63f3d9a`](https://github.com/nodejs/node/commit/f4a63f3d9a)] - **doc**: add AshCripps to collaborators (AshCripps) [#34494](https://github.com/nodejs/node/pull/34494)
+* [[`7d058a4c01`](https://github.com/nodejs/node/commit/7d058a4c01)] - **doc**: add author-ready label ref to onboarding doc (Ruy Adorno) [#34381](https://github.com/nodejs/node/pull/34381)
+* [[`a3c9f75b7e`](https://github.com/nodejs/node/commit/a3c9f75b7e)] - **doc**: add HarshithaKP to collaborators (Harshitha K P) [#34417](https://github.com/nodejs/node/pull/34417)
+* [[`4b4eb5f130`](https://github.com/nodejs/node/commit/4b4eb5f130)] - **doc**: add rexagod to collaborators (Pranshu Srivastava) [#34457](https://github.com/nodejs/node/pull/34457)
+* [[`29ad6fb34e`](https://github.com/nodejs/node/commit/29ad6fb34e)] - **doc**: add statement of purpose to documentation style guide (Rich Trott) [#34424](https://github.com/nodejs/node/pull/34424)
+* [[`631dd21709`](https://github.com/nodejs/node/commit/631dd21709)] - **doc**: mark Node.js 13 as End-of-Life (Antoine du Hamel) [#34436](https://github.com/nodejs/node/pull/34436)
+* [[`905e3d18c0`](https://github.com/nodejs/node/commit/905e3d18c0)] - **doc**: fix line length in worker\_threads.md (Jucke) [#34419](https://github.com/nodejs/node/pull/34419)
+* [[`d67a2b8d38`](https://github.com/nodejs/node/commit/d67a2b8d38)] - **doc**: fix typos in n-api, tls and worker\_threads (Jucke) [#34419](https://github.com/nodejs/node/pull/34419)
+* [[`39894f8842`](https://github.com/nodejs/node/commit/39894f8842)] - **doc**: add release key for Richard Lau (Richard Lau) [#34397](https://github.com/nodejs/node/pull/34397)
+* [[`4a828c6c06`](https://github.com/nodejs/node/commit/4a828c6c06)] - **doc**: use correct identifier for callback argument (Rich Trott) [#34405](https://github.com/nodejs/node/pull/34405)
+* [[`10830732f6`](https://github.com/nodejs/node/commit/10830732f6)] - **doc**: add changes metadata to TLS newSession event (Tobias Nießen) [#34294](https://github.com/nodejs/node/pull/34294)
+* [[`10962c81e1`](https://github.com/nodejs/node/commit/10962c81e1)] - **doc**: introduce a triager role (Gireesh Punathil) [#34295](https://github.com/nodejs/node/pull/34295)
+* [[`50fd2b9de9`](https://github.com/nodejs/node/commit/50fd2b9de9)] - **doc**: strengthen suggestion in errors.md (Rich Trott) [#34390](https://github.com/nodejs/node/pull/34390)
+* [[`346c201c4e`](https://github.com/nodejs/node/commit/346c201c4e)] - **doc**: strengthen wording about fs.access() misuse (Rich Trott) [#34352](https://github.com/nodejs/node/pull/34352)
+* [[`c28453aff4`](https://github.com/nodejs/node/commit/c28453aff4)] - **doc**: fix typo in assert.md (Ye-hyoung Kang) [#34316](https://github.com/nodejs/node/pull/34316)
+* [[`f60e58b6c9`](https://github.com/nodejs/node/commit/f60e58b6c9)] - **doc,tools**: syntax highlight api docs at compile-time (Francisco Ryan Tolmasky I) [#34148](https://github.com/nodejs/node/pull/34148)
+* [[`d90967b346`](https://github.com/nodejs/node/commit/d90967b346)] - **events**: re-use the same isTrusted getter (Anna Henningsen) [#34459](https://github.com/nodejs/node/pull/34459)
+* [[`c93a898028`](https://github.com/nodejs/node/commit/c93a898028)] - **(SEMVER-MINOR)** **events**: expand NodeEventTarget functionality (Anna Henningsen) [#34057](https://github.com/nodejs/node/pull/34057)
+* [[`9b91467aac`](https://github.com/nodejs/node/commit/9b91467aac)] - **http**: don't write error to socket (Robert Nagy) [#34465](https://github.com/nodejs/node/pull/34465)
+* [[`098b193eab`](https://github.com/nodejs/node/commit/098b193eab)] - **http2**: avoid unnecessary buffer resize (Denys Otrishko) [#34480](https://github.com/nodejs/node/pull/34480)
+* [[`3024927c9b`](https://github.com/nodejs/node/commit/3024927c9b)] - **lib**: initialize instance members in class constructors (Joyee Cheung) [#32984](https://github.com/nodejs/node/pull/32984)
+* [[`82fad58ade`](https://github.com/nodejs/node/commit/82fad58ade)] - **lib**: simplify assignment (sapics) [#33718](https://github.com/nodejs/node/pull/33718)
+* [[`e1199af50a`](https://github.com/nodejs/node/commit/e1199af50a)] - **module**: self referential modules in repl or `-r` (Daniele Belardi) [#32261](https://github.com/nodejs/node/pull/32261)
+* [[`e7c64af404`](https://github.com/nodejs/node/commit/e7c64af404)] - **n-api**: run all finalizers via SetImmediate() (Gabriel Schulhof) [#34386](https://github.com/nodejs/node/pull/34386)
+* [[`668632d531`](https://github.com/nodejs/node/commit/668632d531)] - **net**: allow wider regex in interface name (Stewart X Addison) [#34364](https://github.com/nodejs/node/pull/34364)
+* [[`c05b63d8b2`](https://github.com/nodejs/node/commit/c05b63d8b2)] - **src**: skip weak references for memory tracking (Anna Henningsen) [#34469](https://github.com/nodejs/node/pull/34469)
+* [[`b12211eeca`](https://github.com/nodejs/node/commit/b12211eeca)] - **src**: prefer internal fields in ModuleWrap (Anna Henningsen) [#34470](https://github.com/nodejs/node/pull/34470)
+* [[`cbe6385880`](https://github.com/nodejs/node/commit/cbe6385880)] - **src**: remove unused variable in node\_file.cc (sapics) [#34317](https://github.com/nodejs/node/pull/34317)
+* [[`d6ee1fd0c2`](https://github.com/nodejs/node/commit/d6ee1fd0c2)] - **src**: do not crash if ToggleAsyncHook fails during termination (Anna Henningsen) [#34362](https://github.com/nodejs/node/pull/34362)
+* [[`bd9ab00acd`](https://github.com/nodejs/node/commit/bd9ab00acd)] - **(SEMVER-MINOR)** **src**: allow preventing SetPromiseRejectCallback (Shelley Vohr) [#34387](https://github.com/nodejs/node/pull/34387)
+* [[`5c943588bc`](https://github.com/nodejs/node/commit/5c943588bc)] - **(SEMVER-MINOR)** **src**: allow setting a dir for all diagnostic output (AshCripps) [#33584](https://github.com/nodejs/node/pull/33584)
+* [[`9d40af54a6`](https://github.com/nodejs/node/commit/9d40af54a6)] - **src**: avoid strcmp in SecureContext::Init (Tobias Nießen) [#34329](https://github.com/nodejs/node/pull/34329)
+* [[`aef41e5b52`](https://github.com/nodejs/node/commit/aef41e5b52)] - **src**: refactor CertCbDone to avoid goto statement (Tobias Nießen) [#34325](https://github.com/nodejs/node/pull/34325)
+* [[`3d4f608e42`](https://github.com/nodejs/node/commit/3d4f608e42)] - **stream**: rename opts to options (rickyes) [#34339](https://github.com/nodejs/node/pull/34339)
+* [[`fced3ce5ad`](https://github.com/nodejs/node/commit/fced3ce5ad)] - **test**: add ref comment to test-regress-GH-814\_2 (Rich Trott) [#34516](https://github.com/nodejs/node/pull/34516)
+* [[`d5c8b386c6`](https://github.com/nodejs/node/commit/d5c8b386c6)] - **test**: add ref comment to test-regress-GH-814 (Rich Trott) [#34516](https://github.com/nodejs/node/pull/34516)
+* [[`cc279db29f`](https://github.com/nodejs/node/commit/cc279db29f)] - **test**: remove superfluous check in pummel/test-timers (Rich Trott) [#34488](https://github.com/nodejs/node/pull/34488)
+* [[`3f11ba1c69`](https://github.com/nodejs/node/commit/3f11ba1c69)] - **test**: fix test-heapdump-zlib (Andrey Pechkurov) [#34499](https://github.com/nodejs/node/pull/34499)
+* [[`81eaaa27d5`](https://github.com/nodejs/node/commit/81eaaa27d5)] - **test**: remove duplicate checks in pummel/test-timers (Rich Trott) [#34473](https://github.com/nodejs/node/pull/34473)
+* [[`1a9138d679`](https://github.com/nodejs/node/commit/1a9138d679)] - **test**: delete invalid test (Anna Henningsen) [#34445](https://github.com/nodejs/node/pull/34445)
+* [[`4e2f5fa907`](https://github.com/nodejs/node/commit/4e2f5fa907)] - **test**: fixup worker + source map test (Anna Henningsen) [#34446](https://github.com/nodejs/node/pull/34446)
+* [[`cd35d00518`](https://github.com/nodejs/node/commit/cd35d00518)] - **test**: force resigning of app (Colin Ihrig) [#34331](https://github.com/nodejs/node/pull/34331)
+* [[`eecb92c9da`](https://github.com/nodejs/node/commit/eecb92c9da)] - **test**: fix flaky test-watch-file (Rich Trott) [#34420](https://github.com/nodejs/node/pull/34420)
+* [[`30da332314`](https://github.com/nodejs/node/commit/30da332314)] - **test**: fix flaky test-heapdump-http2 (Rich Trott) [#34415](https://github.com/nodejs/node/pull/34415)
+* [[`77542a4a7a`](https://github.com/nodejs/node/commit/77542a4a7a)] - **test**: do not write to fixtures dir in test-watch-file (Rich Trott) [#34376](https://github.com/nodejs/node/pull/34376)
+* [[`699da05b29`](https://github.com/nodejs/node/commit/699da05b29)] - **test**: remove common.localhostIPv6 (Rich Trott) [#34373](https://github.com/nodejs/node/pull/34373)
+* [[`ec1393db63`](https://github.com/nodejs/node/commit/ec1393db63)] - **test**: fix test-net-pingpong pummel test for non-IPv6 hosts (Rich Trott) [#34359](https://github.com/nodejs/node/pull/34359)
+* [[`8ca80427db`](https://github.com/nodejs/node/commit/8ca80427db)] - **test**: fix flaky test-net-connect-econnrefused (Rich Trott) [#34330](https://github.com/nodejs/node/pull/34330)
+* [[`e9c7722ea4`](https://github.com/nodejs/node/commit/e9c7722ea4)] - **tls**: remove setMaxSendFragment guards (Tobias Nießen) [#34323](https://github.com/nodejs/node/pull/34323)
+* [[`f4d61c7ce9`](https://github.com/nodejs/node/commit/f4d61c7ce9)] - **tools**: update ESLint to 7.5.0 (Colin Ihrig) [#34423](https://github.com/nodejs/node/pull/34423)
+* [[`74da2c44ca`](https://github.com/nodejs/node/commit/74da2c44ca)] - **util**: improve getStringWidth performance (Ruben Bridgewater) [#33674](https://github.com/nodejs/node/pull/33674)
+* [[`c9b652f13f`](https://github.com/nodejs/node/commit/c9b652f13f)] - **vm**: add tests for function declarations using \[\[DefineOwnProperty\]\] (ExE Boss) [#34032](https://github.com/nodejs/node/pull/34032)
+* [[`0aa3809b6b`](https://github.com/nodejs/node/commit/0aa3809b6b)] - **(SEMVER-MINOR)** **worker**: make MessagePort inherit from EventTarget (Anna Henningsen) [#34057](https://github.com/nodejs/node/pull/34057)
+* [[`252f37630a`](https://github.com/nodejs/node/commit/252f37630a)] - **zlib**: switch to lazy init for zlib streams (Andrey Pechkurov) [#34048](https://github.com/nodejs/node/pull/34048)
+
+<a id="14.6.0"></a>
+## 2020-07-21, Version 14.6.0 (Current), @MylesBorins
+
+### Notable Changes
+
+* **deps**:
+  * upgrade to libuv 1.38.1 (Colin Ihrig) [#34187](https://github.com/nodejs/node/pull/34187)
+  * upgrade npm to 6.14.6 (claudiahdz) [#34246](https://github.com/nodejs/node/pull/34246)
+  * **(SEMVER-MINOR)** update V8 to 8.4.371.19 (Michaël Zasso) [#33579](https://github.com/nodejs/node/pull/33579)
+* **module**:
+  * **(SEMVER-MINOR)** doc only deprecation of module.parent (Antoine du HAMEL) [#32217](https://github.com/nodejs/node/pull/32217)
+  * **(SEMVER-MINOR)** package "imports" field (Guy Bedford) [#34117](https://github.com/nodejs/node/pull/34117)
+* **src**:
+  * **(SEMVER-MINOR)** allow embedders to disable esm loader (Shelley Vohr) [#34060](https://github.com/nodejs/node/pull/34060)
+* **tls**:
+  * **(SEMVER-MINOR)** make 'createSecureContext' honor more options (Mateusz Krawczuk) [#33974](https://github.com/nodejs/node/pull/33974)
+* **vm**:
+  * **(SEMVER-MINOR)** add run-after-evaluate microtask mode (Anna Henningsen) [#34023](https://github.com/nodejs/node/pull/34023)
+* **worker**:
+  * **(SEMVER-MINOR)** add option to track unmanaged file descriptors (Anna Henningsen) [#34303](https://github.com/nodejs/node/pull/34303)
+* **New Collaborators**:
+  * add danielleadams to collaborators (Danielle Adams) [#34360](https://github.com/nodejs/node/pull/34360)
+  * add ruyadorno to collaborators (Ruy Adorno) [#34297](https://github.com/nodejs/node/pull/34297)
+  * add sxa as collaborator (Stewart X Addison) [#34338](https://github.com/nodejs/node/pull/34338)
+
+### Commits
+
+* [[`afec0d7f51`](https://github.com/nodejs/node/commit/afec0d7f51)] - **async_hooks**: improve resource stack performance (Anna Henningsen) [#34319](https://github.com/nodejs/node/pull/34319)
+* [[`f340571301`](https://github.com/nodejs/node/commit/f340571301)] - **(SEMVER-MINOR)** **build**: reset embedder string to "-node.0" (Michaël Zasso) [#33579](https://github.com/nodejs/node/pull/33579)
+* [[`de250c136c`](https://github.com/nodejs/node/commit/de250c136c)] - **build**: recommend Python 3.8 to build on Windows (Michaël Zasso) [#34182](https://github.com/nodejs/node/pull/34182)
+* [[`a130771d4f`](https://github.com/nodejs/node/commit/a130771d4f)] - **build,tools**: fix cmd\_regen\_makefile (Daniel Bevenius) [#34255](https://github.com/nodejs/node/pull/34255)
+* [[`cfd4c8012d`](https://github.com/nodejs/node/commit/cfd4c8012d)] - **crypto**: move typechecking for timingSafeEqual into C++ (Anna Henningsen) [#34141](https://github.com/nodejs/node/pull/34141)
+* [[`95afc2e50e`](https://github.com/nodejs/node/commit/95afc2e50e)] - **deps**: V8: update headers for ABI compatibility (Anna Henningsen) [#34356](https://github.com/nodejs/node/pull/34356)
+* [[`2c9fd6ebd4`](https://github.com/nodejs/node/commit/2c9fd6ebd4)] - **deps**: V8: revert de4c0042cbe6 from upstream V8 (Anna Henningsen) [#34356](https://github.com/nodejs/node/pull/34356)
+* [[`447b1e86a5`](https://github.com/nodejs/node/commit/447b1e86a5)] - **deps**: V8: re-add dummy Isolate::CheckMemoryPressure (Anna Henningsen) [#34356](https://github.com/nodejs/node/pull/34356)
+* [[`2079fefacf`](https://github.com/nodejs/node/commit/2079fefacf)] - **deps**: V8: undo header change of 9dbab9bbdb979 (Anna Henningsen) [#34356](https://github.com/nodejs/node/pull/34356)
+* [[`9f886c968c`](https://github.com/nodejs/node/commit/9f886c968c)] - **(SEMVER-MINOR)** **deps**: bump minimum icu version to 67 (Michaël Zasso) [#33579](https://github.com/nodejs/node/pull/33579)
+* [[`3fa7ad3375`](https://github.com/nodejs/node/commit/3fa7ad3375)] - **(SEMVER-MINOR)** **deps**: update V8 postmortem metadata script (Colin Ihrig) [#33579](https://github.com/nodejs/node/pull/33579)
+* [[`4c37837424`](https://github.com/nodejs/node/commit/4c37837424)] - **deps**: V8: cherry-pick eec10a2fd8fa (Stephen Belanger) [#33778](https://github.com/nodejs/node/pull/33778)
+* [[`fb180ac110`](https://github.com/nodejs/node/commit/fb180ac110)] - **deps**: V8: backport 22014de00115 (Joyee Cheung) [#33300](https://github.com/nodejs/node/pull/33300)
+* [[`01e788622c`](https://github.com/nodejs/node/commit/01e788622c)] - **(SEMVER-MINOR)** **deps**: V8: fix compilation on VS2017 (Jiawen Geng) [#33579](https://github.com/nodejs/node/pull/33579)
+* [[`f269dff06e`](https://github.com/nodejs/node/commit/f269dff06e)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 9868b2aefa1a (Michaël Zasso) [#33579](https://github.com/nodejs/node/pull/33579)
+* [[`335e3861c3`](https://github.com/nodejs/node/commit/335e3861c3)] - **(SEMVER-MINOR)** **deps**: patch V8 to run on Xcode 8 (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`355e2f2b6a`](https://github.com/nodejs/node/commit/355e2f2b6a)] - **(SEMVER-MINOR)** **deps**: V8: silence irrelevant warnings (Michaël Zasso) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`eb6ded61b7`](https://github.com/nodejs/node/commit/eb6ded61b7)] - **(SEMVER-MINOR)** **deps**: make v8.h compatible with VS2015 (Joao Reis) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`a4b71e02ca`](https://github.com/nodejs/node/commit/a4b71e02ca)] - **(SEMVER-MINOR)** **deps**: V8: forward declaration of `Rtl\*FunctionTable` (Refael Ackermann) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`1e37442fdd`](https://github.com/nodejs/node/commit/1e37442fdd)] - **(SEMVER-MINOR)** **deps**: V8: patch register-arm64.h (Refael Ackermann) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`eac35c6061`](https://github.com/nodejs/node/commit/eac35c6061)] - **(SEMVER-MINOR)** **deps**: patch V8 to run on older XCode versions (Ujjwal Sharma) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`51d86f4b59`](https://github.com/nodejs/node/commit/51d86f4b59)] - **(SEMVER-MINOR)** **deps**: V8: un-cherry-pick bd019bd (Refael Ackermann) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`9cd523d148`](https://github.com/nodejs/node/commit/9cd523d148)] - **(SEMVER-MINOR)** **deps**: update V8 to 8.4.371.19 (Michaël Zasso) [#33579](https://github.com/nodejs/node/pull/33579)
+* [[`24f76cf004`](https://github.com/nodejs/node/commit/24f76cf004)] - **deps**: upgrade npm to 6.14.6 (claudiahdz) [#34246](https://github.com/nodejs/node/pull/34246)
+* [[`a9ca4204e0`](https://github.com/nodejs/node/commit/a9ca4204e0)] - **deps**: upgrade to libuv 1.38.1 (Colin Ihrig) [#34187](https://github.com/nodejs/node/pull/34187)
+* [[`601ed8ef7e`](https://github.com/nodejs/node/commit/601ed8ef7e)] - **deps**: V8: backport 2d5017a0fc02 (Benjamin Coe) [#34272](https://github.com/nodejs/node/pull/34272)
+* [[`17174e69ce`](https://github.com/nodejs/node/commit/17174e69ce)] - **doc**: clarify conditional exports guidance (Guy Bedford) [#34306](https://github.com/nodejs/node/pull/34306)
+* [[`1dd265384b`](https://github.com/nodejs/node/commit/1dd265384b)] - **doc**: reword warnings about sockets passed to subprocesses (Rich Trott) [#34273](https://github.com/nodejs/node/pull/34273)
+* [[`ef31f179e0`](https://github.com/nodejs/node/commit/ef31f179e0)] - **doc**: sync deprecation numbers with v14.x (Myles Borins) [#34368](https://github.com/nodejs/node/pull/34368)
+* [[`0b42e5d205`](https://github.com/nodejs/node/commit/0b42e5d205)] - **doc**: add danielleadams to collaborators (Danielle Adams) [#34360](https://github.com/nodejs/node/pull/34360)
+* [[`1cc65332b0`](https://github.com/nodejs/node/commit/1cc65332b0)] - **doc**: buffer documentation improvements (James M Snell) [#34230](https://github.com/nodejs/node/pull/34230)
+* [[`d11496174d`](https://github.com/nodejs/node/commit/d11496174d)] - **doc**: improve text in fs docs about omitting callbacks (Rich Trott) [#34307](https://github.com/nodejs/node/pull/34307)
+* [[`d2c58948e9`](https://github.com/nodejs/node/commit/d2c58948e9)] - **doc**: add sxa as collaborator (Stewart X Addison) [#34338](https://github.com/nodejs/node/pull/34338)
+* [[`d865be4cab`](https://github.com/nodejs/node/commit/d865be4cab)] - **doc**: move sebdeckers to emeritus (Rich Trott) [#34298](https://github.com/nodejs/node/pull/34298)
+* [[`24fe55872f`](https://github.com/nodejs/node/commit/24fe55872f)] - **doc**: add ruyadorno to collaborators (Ruy Adorno) [#34297](https://github.com/nodejs/node/pull/34297)
+* [[`e6776fe194`](https://github.com/nodejs/node/commit/e6776fe194)] - **doc**: move kfarnung to collaborator emeriti list (Rich Trott) [#34258](https://github.com/nodejs/node/pull/34258)
+* [[`7416028f99`](https://github.com/nodejs/node/commit/7416028f99)] - **doc**: specify encoding in text/html examples (James M Snell) [#34222](https://github.com/nodejs/node/pull/34222)
+* [[`9339f9f602`](https://github.com/nodejs/node/commit/9339f9f602)] - **doc**: document the ready event for Http2Stream (James M Snell) [#34221](https://github.com/nodejs/node/pull/34221)
+* [[`25ac669be9`](https://github.com/nodejs/node/commit/25ac669be9)] - **doc**: add comment to example about 2xx status codes (James M Snell) [#34223](https://github.com/nodejs/node/pull/34223)
+* [[`6f014d0b13`](https://github.com/nodejs/node/commit/6f014d0b13)] - **doc**: document that whitespace is ignored in base64 decoding (James M Snell) [#34227](https://github.com/nodejs/node/pull/34227)
+* [[`431bfe177f`](https://github.com/nodejs/node/commit/431bfe177f)] - **doc**: add note about multiple sync events and once (James M Snell) [#34220](https://github.com/nodejs/node/pull/34220)
+* [[`ffe6886de9`](https://github.com/nodejs/node/commit/ffe6886de9)] - **doc**: document behavior for once(ee, 'error') (James M Snell) [#34225](https://github.com/nodejs/node/pull/34225)
+* [[`a6a656abaa`](https://github.com/nodejs/node/commit/a6a656abaa)] - **doc**: document security issues with url.parse() (James M Snell) [#34226](https://github.com/nodejs/node/pull/34226)
+* [[`abfab9892b`](https://github.com/nodejs/node/commit/abfab9892b)] - **doc**: replace http to https of link urls (sapics) [#34158](https://github.com/nodejs/node/pull/34158)
+* [[`2e20cd4fde`](https://github.com/nodejs/node/commit/2e20cd4fde)] - **doc**: remove errors that were never released (Rich Trott) [#34197](https://github.com/nodejs/node/pull/34197)
+* [[`c83d98619d`](https://github.com/nodejs/node/commit/c83d98619d)] - **doc**: move ERR\_FEATURE\_UNAVAILABLE\_ON\_PLATFORM to current errors (Rich Trott) [#34196](https://github.com/nodejs/node/pull/34196)
+* [[`59bb6d6663`](https://github.com/nodejs/node/commit/59bb6d6663)] - **doc**: move digitalinfinity to emeritus (Rich Trott) [#34191](https://github.com/nodejs/node/pull/34191)
+* [[`39d6ecdea9`](https://github.com/nodejs/node/commit/39d6ecdea9)] - **doc**: move gibfahn to emeritus (Rich Trott) [#34190](https://github.com/nodejs/node/pull/34190)
+* [[`938de338ef`](https://github.com/nodejs/node/commit/938de338ef)] - **doc**: specify how fs.WriteStream/ReadStreams are created (James M Snell) [#34188](https://github.com/nodejs/node/pull/34188)
+* [[`326b854e6e`](https://github.com/nodejs/node/commit/326b854e6e)] - **doc**: remove parenthetical \\r\\n comment in http and http2 docs (Rich Trott) [#34178](https://github.com/nodejs/node/pull/34178)
+* [[`a2dd2589c1`](https://github.com/nodejs/node/commit/a2dd2589c1)] - **doc**: remove stability from unreleased errors (Rich Trott) [#33764](https://github.com/nodejs/node/pull/33764)
+* [[`8dd8b1a8be`](https://github.com/nodejs/node/commit/8dd8b1a8be)] - **doc**: util.debuglog callback (Bradley Meck) [#33856](https://github.com/nodejs/node/pull/33856)
+* [[`aaba1c08dc`](https://github.com/nodejs/node/commit/aaba1c08dc)] - **doc**: update wording in "Two reading modes" (Julien Poissonnier) [#34119](https://github.com/nodejs/node/pull/34119)
+* [[`6aa0dac362`](https://github.com/nodejs/node/commit/6aa0dac362)] - **doc**: clarify that the ctx argument is optional (Luigi Pinca) [#34097](https://github.com/nodejs/node/pull/34097)
+* [[`1558800217`](https://github.com/nodejs/node/commit/1558800217)] - **doc**: add a reference to the list of OpenSSL flags. (Mateusz Krawczuk) [#34050](https://github.com/nodejs/node/pull/34050)
+* [[`25d310b631`](https://github.com/nodejs/node/commit/25d310b631)] - **doc**: no longer maintain a CNA structure (Sam Roberts) [#33639](https://github.com/nodejs/node/pull/33639)
+* [[`5ae2b74350`](https://github.com/nodejs/node/commit/5ae2b74350)] - **doc**: use consistent naming in stream doc (Saleem) [#30506](https://github.com/nodejs/node/pull/30506)
+* [[`a0cfa62338`](https://github.com/nodejs/node/commit/a0cfa62338)] - **doc**: clarify how to read process.stdin (Anentropic) [#27350](https://github.com/nodejs/node/pull/27350)
+* [[`e8184554ba`](https://github.com/nodejs/node/commit/e8184554ba)] - **doc**: fix entry for `napi\_create\_external\_buffer` (Gabriel Schulhof) [#34125](https://github.com/nodejs/node/pull/34125)
+* [[`167a21a66a`](https://github.com/nodejs/node/commit/167a21a66a)] - **doc**: fix source link margin to sub-header mark (Rodion Abdurakhimov) [#33664](https://github.com/nodejs/node/pull/33664)
+* [[`146538de65`](https://github.com/nodejs/node/commit/146538de65)] - **doc**: improve async\_hooks asynchronous context example (Denys Otrishko) [#33730](https://github.com/nodejs/node/pull/33730)
+* [[`e386188775`](https://github.com/nodejs/node/commit/e386188775)] - **doc**: clarify esm conditional exports prose (Derek Lewis) [#33886](https://github.com/nodejs/node/pull/33886)
+* [[`e273edf943`](https://github.com/nodejs/node/commit/e273edf943)] - **doc**: Add maxTotalSockets option to agent constructor (rickyes) [#34013](https://github.com/nodejs/node/pull/34013)
+* [[`ab6b786e9d`](https://github.com/nodejs/node/commit/ab6b786e9d)] - **doc**: add streams to the pipeline function signature (rickyes) [#34153](https://github.com/nodejs/node/pull/34153)
+* [[`9f0bf5c9e1`](https://github.com/nodejs/node/commit/9f0bf5c9e1)] - **doc**: improve triaging text in issues.md (Rich Trott) [#34164](https://github.com/nodejs/node/pull/34164)
+* [[`22c1fbf4cb`](https://github.com/nodejs/node/commit/22c1fbf4cb)] - **doc**: simply dns.ADDRCONFIG language (Rich Trott) [#34155](https://github.com/nodejs/node/pull/34155)
+* [[`7fc56ebd0d`](https://github.com/nodejs/node/commit/7fc56ebd0d)] - **doc**: remove "considered" in errors.md (Rich Trott) [#34152](https://github.com/nodejs/node/pull/34152)
+* [[`e33c09cb3a`](https://github.com/nodejs/node/commit/e33c09cb3a)] - **doc**: simplify and clarify ReferenceError material in errors.md (Rich Trott) [#34151](https://github.com/nodejs/node/pull/34151)
+* [[`af9e6f6e1b`](https://github.com/nodejs/node/commit/af9e6f6e1b)] - **doc**: add http highlight grammar (Derek Lewis) [#33785](https://github.com/nodejs/node/pull/33785)
+* [[`26ecdf8ade`](https://github.com/nodejs/node/commit/26ecdf8ade)] - **doc**: move sam-github to TSC Emeriti (Sam Roberts) [#34095](https://github.com/nodejs/node/pull/34095)
+* [[`78a4d97b82`](https://github.com/nodejs/node/commit/78a4d97b82)] - **doc**: change "considered experimental" to "experimental" in n-api.md (Rich Trott) [#34129](https://github.com/nodejs/node/pull/34129)
+* [[`da5fde6594`](https://github.com/nodejs/node/commit/da5fde6594)] - **doc**: changed "considered experimental" to "experimental" in cli.md (Rich Trott) [#34128](https://github.com/nodejs/node/pull/34128)
+* [[`49d2d49336`](https://github.com/nodejs/node/commit/49d2d49336)] - **doc**: improve text in issues.md (falguniraina) [#33973](https://github.com/nodejs/node/pull/33973)
+* [[`9d30f0542c`](https://github.com/nodejs/node/commit/9d30f0542c)] - **doc**: change "currently not considered public" to "not supported" (Rich Trott) [#34114](https://github.com/nodejs/node/pull/34114)
+* [[`64bd518f26`](https://github.com/nodejs/node/commit/64bd518f26)] - **doc**: clarify that APIs are no longer experimental (Rich Trott) [#34113](https://github.com/nodejs/node/pull/34113)
+* [[`ee6ccef091`](https://github.com/nodejs/node/commit/ee6ccef091)] - **doc**: clarify O\_EXCL text in fs.md (Rich Trott) [#34096](https://github.com/nodejs/node/pull/34096)
+* [[`05a69e2e88`](https://github.com/nodejs/node/commit/05a69e2e88)] - **doc**: clarify ambiguous rdev description (Rich Trott) [#34094](https://github.com/nodejs/node/pull/34094)
+* [[`4927fed9ea`](https://github.com/nodejs/node/commit/4927fed9ea)] - **doc**: make minor improvements to paragraph in child\_process.md (Rich Trott) [#34063](https://github.com/nodejs/node/pull/34063)
+* [[`585f3a5f84`](https://github.com/nodejs/node/commit/585f3a5f84)] - **doc**: improve paragraph in esm.md (Rich Trott) [#34064](https://github.com/nodejs/node/pull/34064)
+* [[`556e55db72`](https://github.com/nodejs/node/commit/556e55db72)] - **doc**: clarify require/import mutual exclusivity (Guy Bedford) [#33832](https://github.com/nodejs/node/pull/33832)
+* [[`eb04ba3080`](https://github.com/nodejs/node/commit/eb04ba3080)] - **doc**: add dynamic source code links (Alec Davidson) [#33996](https://github.com/nodejs/node/pull/33996)
+* [[`2ca6a45ba9`](https://github.com/nodejs/node/commit/2ca6a45ba9)] - **doc**: mention errors thrown by methods called on an unbound dgram.Socket (Mateusz Krawczuk) [#33983](https://github.com/nodejs/node/pull/33983)
+* [[`b8a17ccc9a`](https://github.com/nodejs/node/commit/b8a17ccc9a)] - **doc**: document n-api callback scope usage (Gabriel Schulhof) [#33915](https://github.com/nodejs/node/pull/33915)
+* [[`3b268094cc`](https://github.com/nodejs/node/commit/3b268094cc)] - **doc**: use sentence-case for headings in docs (Rich Trott) [#33889](https://github.com/nodejs/node/pull/33889)
+* [[`280cd967d3`](https://github.com/nodejs/node/commit/280cd967d3)] - **domain**: fix unintentional deprecation warning (Anna Henningsen) [#34245](https://github.com/nodejs/node/pull/34245)
+* [[`96ebd5f352`](https://github.com/nodejs/node/commit/96ebd5f352)] - **http**: add note about timer unref (Robert Nagy) [#34143](https://github.com/nodejs/node/pull/34143)
+* [[`16160e654f`](https://github.com/nodejs/node/commit/16160e654f)] - ***Revert*** "**http2**: streamline OnStreamRead streamline memory accounting" (Rich Trott) [#34315](https://github.com/nodejs/node/pull/34315)
+* [[`8bafba2e56`](https://github.com/nodejs/node/commit/8bafba2e56)] - **lib**: always initialize esm loader callbackMap (Shelley Vohr) [#34127](https://github.com/nodejs/node/pull/34127)
+* [[`daf2abf393`](https://github.com/nodejs/node/commit/daf2abf393)] - **lib**: replace http to https of comment link urls (sapics) [#34158](https://github.com/nodejs/node/pull/34158)
+* [[`8f8d16849c`](https://github.com/nodejs/node/commit/8f8d16849c)] - **meta**: make issue template mobile friendly and address nits (Derek Lewis) [#34243](https://github.com/nodejs/node/pull/34243)
+* [[`de58eb6286`](https://github.com/nodejs/node/commit/de58eb6286)] - **meta**: add N-API to codeowners coverage (Michael Dawson) [#34039](https://github.com/nodejs/node/pull/34039)
+* [[`4dc89c6d30`](https://github.com/nodejs/node/commit/4dc89c6d30)] - **meta**: fixup CODEOWNERS so it hopefully works (James M Snell) [#34147](https://github.com/nodejs/node/pull/34147)
+* [[`8d7330be0e`](https://github.com/nodejs/node/commit/8d7330be0e)] - **(SEMVER-MINOR)** **module**: deprecate module.parent (Antoine du HAMEL) [#32217](https://github.com/nodejs/node/pull/32217)
+* [[`1ae76bd075`](https://github.com/nodejs/node/commit/1ae76bd075)] - **(SEMVER-MINOR)** **module**: package "imports" field (Guy Bedford) [#34117](https://github.com/nodejs/node/pull/34117)
+* [[`0e1361cb8b`](https://github.com/nodejs/node/commit/0e1361cb8b)] - **net**: doc deprecate bufferSize (Robert Nagy) [#34088](https://github.com/nodejs/node/pull/34088)
+* [[`b7e9b43b2f`](https://github.com/nodejs/node/commit/b7e9b43b2f)] - **net**: fix bufferSize (Robert Nagy) [#34088](https://github.com/nodejs/node/pull/34088)
+* [[`02ea320e0c`](https://github.com/nodejs/node/commit/02ea320e0c)] - **policy**: add startup benchmark and make SRI lazier (Bradley Farias) [#29527](https://github.com/nodejs/node/pull/29527)
+* [[`73d6792a05`](https://github.com/nodejs/node/commit/73d6792a05)] - **repl**: support --loader option in builtin REPL (Michaël Zasso) [#33437](https://github.com/nodejs/node/pull/33437)
+* [[`b20e6ed94e`](https://github.com/nodejs/node/commit/b20e6ed94e)] - **repl**: fix verb conjugation in deprecation message (Rich Trott) [#34198](https://github.com/nodejs/node/pull/34198)
+* [[`b878e3223e`](https://github.com/nodejs/node/commit/b878e3223e)] - **src**: add callback scope for native immediates (Anna Henningsen) [#34366](https://github.com/nodejs/node/pull/34366)
+* [[`0f6805d507`](https://github.com/nodejs/node/commit/0f6805d507)] - **(SEMVER-MINOR)** **src**: add option to track unmanaged file descriptors (Anna Henningsen) [#34303](https://github.com/nodejs/node/pull/34303)
+* [[`e4c7b59665`](https://github.com/nodejs/node/commit/e4c7b59665)] - **(SEMVER-MINOR)** **src**: allow embedders to disable esm loader (Shelley Vohr) [#34060](https://github.com/nodejs/node/pull/34060)
+* [[`9c12e53d47`](https://github.com/nodejs/node/commit/9c12e53d47)] - **src**: remove redundant snprintf (Anna Henningsen) [#34282](https://github.com/nodejs/node/pull/34282)
+* [[`844bf770f8`](https://github.com/nodejs/node/commit/844bf770f8)] - **src**: use FromMaybe instead of ToLocal in GetCert (Daniel Bevenius) [#34276](https://github.com/nodejs/node/pull/34276)
+* [[`ec876eecc0`](https://github.com/nodejs/node/commit/ec876eecc0)] - **src**: add GetCipherValue function (Daniel Bevenius) [#34287](https://github.com/nodejs/node/pull/34287)
+* [[`9c98af71db`](https://github.com/nodejs/node/commit/9c98af71db)] - **src**: exit explicitly after printing V8 help (Anna Henningsen) [#34136](https://github.com/nodejs/node/pull/34136)
+* [[`3e3d908c81`](https://github.com/nodejs/node/commit/3e3d908c81)] - **src**: add encoding\_type variable in WritePrivateKey (Daniel Bevenius) [#34181](https://github.com/nodejs/node/pull/34181)
+* [[`ed0f5697d8`](https://github.com/nodejs/node/commit/ed0f5697d8)] - **src**: fix minor comment typo in KeyObjectData (Daniel Bevenius) [#34167](https://github.com/nodejs/node/pull/34167)
+* [[`8f7ed40fc4`](https://github.com/nodejs/node/commit/8f7ed40fc4)] - **src**: fix unused namespace member (Nikola Glavina) [#34212](https://github.com/nodejs/node/pull/34212)
+* [[`e378b681d0`](https://github.com/nodejs/node/commit/e378b681d0)] - **src**: remove unused fields from IsolateData (Anna Henningsen) [#34139](https://github.com/nodejs/node/pull/34139)
+* [[`b2cd87e611`](https://github.com/nodejs/node/commit/b2cd87e611)] - **src,doc,test**: remove String::New default parameter (Anna Henningsen) [#34248](https://github.com/nodejs/node/pull/34248)
+* [[`41c80f6abe`](https://github.com/nodejs/node/commit/41c80f6abe)] - **stream**: destroy wrapped streams on error (Robert Nagy) [#34102](https://github.com/nodejs/node/pull/34102)
+* [[`1af8943622`](https://github.com/nodejs/node/commit/1af8943622)] - **(SEMVER-MINOR)** **test**: remove test/v8-updates/test-postmortem-metadata.js (Colin Ihrig) [#33579](https://github.com/nodejs/node/pull/33579)
+* [[`58dfeac133`](https://github.com/nodejs/node/commit/58dfeac133)] - **test**: use mustCall() in pummel test (Rich Trott) [#34327](https://github.com/nodejs/node/pull/34327)
+* [[`28ce378e17`](https://github.com/nodejs/node/commit/28ce378e17)] - **test**: fix flaky test-http2-reset-flood (Rich Trott) [#34318](https://github.com/nodejs/node/pull/34318)
+* [[`060c95a3b1`](https://github.com/nodejs/node/commit/060c95a3b1)] - **test**: add n-api null checks for conversions (Gabriel Schulhof) [#34142](https://github.com/nodejs/node/pull/34142)
+* [[`3ee8f5342c`](https://github.com/nodejs/node/commit/3ee8f5342c)] - **test**: add regression tests for HTTP parser crash (Anna Henningsen) [#34250](https://github.com/nodejs/node/pull/34250)
+* [[`6925ef3b1c`](https://github.com/nodejs/node/commit/6925ef3b1c)] - **test**: add WASI test for file resizing (Colin Ihrig) [#31617](https://github.com/nodejs/node/pull/31617)
+* [[`1aad61eeec`](https://github.com/nodejs/node/commit/1aad61eeec)] - **test**: add issue ref for known\_issues test (Rich Trott) [#34267](https://github.com/nodejs/node/pull/34267)
+* [[`ec9b49a9b9`](https://github.com/nodejs/node/commit/ec9b49a9b9)] - **test**: add known issue for fs.open() keeping event loop open (Rich Trott) [#34228](https://github.com/nodejs/node/pull/34228)
+* [[`38b3c2a300`](https://github.com/nodejs/node/commit/38b3c2a300)] - **test**: add arrayOfStreams to pipeline (rickyes) [#34156](https://github.com/nodejs/node/pull/34156)
+* [[`0f9bafd03d`](https://github.com/nodejs/node/commit/0f9bafd03d)] - **test**: skip an ipv6 test on IBM i (Xu Meng) [#34209](https://github.com/nodejs/node/pull/34209)
+* [[`a38219f962`](https://github.com/nodejs/node/commit/a38219f962)] - **test**: add regression test for C++-created Buffer transfer (Anna Henningsen) [#34140](https://github.com/nodejs/node/pull/34140)
+* [[`09faebd9ad`](https://github.com/nodejs/node/commit/09faebd9ad)] - **test**: replace deprecated function call from test-repl-history-navigation (Rich Trott) [#34199](https://github.com/nodejs/node/pull/34199)
+* [[`bddc99ec7f`](https://github.com/nodejs/node/commit/bddc99ec7f)] - **test**: skip some IBM i unsupported test cases (Xu Meng) [#34118](https://github.com/nodejs/node/pull/34118)
+* [[`f5691fa6b6`](https://github.com/nodejs/node/commit/f5691fa6b6)] - **test**: report actual error code on failure (Richard Lau) [#34134](https://github.com/nodejs/node/pull/34134)
+* [[`46d183c86e`](https://github.com/nodejs/node/commit/46d183c86e)] - **test**: update test-child-process-spawn-loop for Python 3 (Richard Lau) [#34071](https://github.com/nodejs/node/pull/34071)
+* [[`a89bcf72fb`](https://github.com/nodejs/node/commit/a89bcf72fb)] - **(SEMVER-MINOR)** **tls**: make 'createSecureContext' honor more options (Mateusz Krawczuk) [#33974](https://github.com/nodejs/node/pull/33974)
+* [[`fbcd1fa0f4`](https://github.com/nodejs/node/commit/fbcd1fa0f4)] - **tls**: remove unnecessary close listener (Robert Nagy) [#34105](https://github.com/nodejs/node/pull/34105)
+* [[`4e2fa439c9`](https://github.com/nodejs/node/commit/4e2fa439c9)] - **(SEMVER-MINOR)** **tools**: update V8 gypfiles for 8.4 (Ujjwal Sharma) [#33579](https://github.com/nodejs/node/pull/33579)
+* [[`440642d00b`](https://github.com/nodejs/node/commit/440642d00b)] - **tools**: remove lint-js.js (Rich Trott) [#30955](https://github.com/nodejs/node/pull/30955)
+* [[`e0206bafe6`](https://github.com/nodejs/node/commit/e0206bafe6)] - **util**: restrict custom inspect function + vm.Context interaction (Anna Henningsen) [#33690](https://github.com/nodejs/node/pull/33690)
+* [[`70c4045aa5`](https://github.com/nodejs/node/commit/70c4045aa5)] - **(SEMVER-MINOR)** **vm**: add run-after-evaluate microtask mode (Anna Henningsen) [#34023](https://github.com/nodejs/node/pull/34023)
+* [[`6be685a99d`](https://github.com/nodejs/node/commit/6be685a99d)] - **wasi**: add reactor support (Gus Caplan) [#34046](https://github.com/nodejs/node/pull/34046)
+* [[`1bc4def18f`](https://github.com/nodejs/node/commit/1bc4def18f)] - **worker**: fix nested uncaught exception handling (Anna Henningsen) [#34310](https://github.com/nodejs/node/pull/34310)
+* [[`9e04070d3c`](https://github.com/nodejs/node/commit/9e04070d3c)] - **(SEMVER-MINOR)** **worker**: add option to track unmanaged file descriptors (Anna Henningsen) [#34303](https://github.com/nodejs/node/pull/34303)
+* [[`105d5607a8`](https://github.com/nodejs/node/commit/105d5607a8)] - **zlib**: remove redundant variable in zlibBufferOnEnd (Andrey Pechkurov) [#34072](https://github.com/nodejs/node/pull/34072)
+
+<a id="14.5.0"></a>
+## 2020-06-30, Version 14.5.0 (Current), @codebytere
+
+### Notable Changes
+
+#### V8 engine is updated to version 8.3
+
+This version includes performance improvements and now allows WebAssembly
+modules to request memories up to 4GB in size.
+
+For more information, have a look at the [official V8 blog post](https://v8.dev/blog/v8-release-83).
+
+Contributed by Matheus Marchini and Michaël Zasso - [#33376](https://github.com/nodejs/node/pull/33376).
+
+#### Initial experimental implementation of EventTarget
+
+This version introduces an new experimental API `EventTarget`, which provides a DOM interface implemented by objects that can receive events and may have listeners for them.
+
+It is an adaptation of the Web API EventTarget.
+
+Example Usage:
+
+```js
+const target = getEventTargetSomehow();
+
+target.addEventListener('foo', (event) => {
+  console.log('foo event happened!');
+});
+```
+
+Contributed by James Snell - [#33556](https://github.com/nodejs/node/pull/33556).
+
+### Semver-Minor Commits
+
+* [[`4ccaa537d4`](https://github.com/nodejs/node/commit/4ccaa537d4)] - **(SEMVER-MINOR)** **build**: reset embedder string to "-node.0" (Michaël Zasso) [#33376](https://github.com/nodejs/node/pull/33376)
+* [[`d194d20828`](https://github.com/nodejs/node/commit/d194d20828)] - **(SEMVER-MINOR)** **cli**: add alias for report-directory to make it consistent (AshCripps) [#33587](https://github.com/nodejs/node/pull/33587)
+* [[`70398dbf60`](https://github.com/nodejs/node/commit/70398dbf60)] - **(SEMVER-MINOR)** **crypto**: allow KeyObjects in postMessage (Tobias Nießen) [#33360](https://github.com/nodejs/node/pull/33360)
+* [[`9b7ba87aa6`](https://github.com/nodejs/node/commit/9b7ba87aa6)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 0d6debcc5f08 (Michaël Zasso) [#33376](https://github.com/nodejs/node/pull/33376)
+* [[`ce1a1ae621`](https://github.com/nodejs/node/commit/ce1a1ae621)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 74d50c5063b3 (Michaël Zasso) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`aa7267a344`](https://github.com/nodejs/node/commit/aa7267a344)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick e29c62b74854 (Michaël Zasso) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`1512757a22`](https://github.com/nodejs/node/commit/1512757a22)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick 3f8dc4b2e5ba (Michaël Zasso) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`3d9cf4bde6`](https://github.com/nodejs/node/commit/3d9cf4bde6)] - **(SEMVER-MINOR)** **deps**: V8: cherry-pick e1eac1b16c96 (Milad Farazmand) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`cdeade308e`](https://github.com/nodejs/node/commit/cdeade308e)] - **(SEMVER-MINOR)** **deps**: fix V8 8.3 on SmartOS (Colin Ihrig) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`883840bc17`](https://github.com/nodejs/node/commit/883840bc17)] - **(SEMVER-MINOR)** **deps**: patch V8 to run on Xcode 8 (Matheus Marchini) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`3831a541fb`](https://github.com/nodejs/node/commit/3831a541fb)] - **(SEMVER-MINOR)** **deps**: V8: silence irrelevant warnings (Michaël Zasso) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`e2fc08f216`](https://github.com/nodejs/node/commit/e2fc08f216)] - **(SEMVER-MINOR)** **deps**: make v8.h compatible with VS2015 (Joao Reis) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`74b623bd51`](https://github.com/nodejs/node/commit/74b623bd51)] - **(SEMVER-MINOR)** **deps**: V8: forward declaration of `Rtl\*FunctionTable` (Refael Ackermann) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`0f5764aec2`](https://github.com/nodejs/node/commit/0f5764aec2)] - **(SEMVER-MINOR)** **deps**: V8: patch register-arm64.h (Refael Ackermann) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`be773fc3cf`](https://github.com/nodejs/node/commit/be773fc3cf)] - **(SEMVER-MINOR)** **deps**: patch V8 to run on older XCode versions (Ujjwal Sharma) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`7aa41c6e6f`](https://github.com/nodejs/node/commit/7aa41c6e6f)] - **(SEMVER-MINOR)** **deps**: V8: un-cherry-pick bd019bd (Refael Ackermann) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`ce901e3906`](https://github.com/nodejs/node/commit/ce901e3906)] - **(SEMVER-MINOR)** **deps**: update V8 dtrace & postmortem metadata (Colin Ihrig) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`1123425dd1`](https://github.com/nodejs/node/commit/1123425dd1)] - **(SEMVER-MINOR)** **deps**: update V8 to 8.3.110.9 (Michaël Zasso) [#33376](https://github.com/nodejs/node/pull/33376)
+* [[`1c70b18da8`](https://github.com/nodejs/node/commit/1c70b18da8)] - **(SEMVER-MINOR)** **events**: initial implementation of experimental EventTarget (James M Snell) [#33556](https://github.com/nodejs/node/pull/33556)
+* [[`cf97c56dab`](https://github.com/nodejs/node/commit/cf97c56dab)] - **(SEMVER-MINOR)** **fs**: implement lutimes (Maël Nison) [#33399](https://github.com/nodejs/node/pull/33399)
+* [[`a24b8df7fb`](https://github.com/nodejs/node/commit/a24b8df7fb)] - **(SEMVER-MINOR)** **http**: expose host and protocol on ClientRequest (wenningplus) [#33803](https://github.com/nodejs/node/pull/33803)
+* [[`507a2ef31c`](https://github.com/nodejs/node/commit/507a2ef31c)] - **(SEMVER-MINOR)** **http**: add maxTotalSockets to agent class (rickyes) [#33617](https://github.com/nodejs/node/pull/33617)
+* [[`e1e3ae1567`](https://github.com/nodejs/node/commit/e1e3ae1567)] - **(SEMVER-MINOR)** **http**: return this from OutgoingMessage#destroy() (Colin Ihrig) [#32789](https://github.com/nodejs/node/pull/32789)
+* [[`d87031def4`](https://github.com/nodejs/node/commit/d87031def4)] - **(SEMVER-MINOR)** **http**: return this from ClientRequest#destroy() (Colin Ihrig) [#32789](https://github.com/nodejs/node/pull/32789)
+* [[`c7959557db`](https://github.com/nodejs/node/commit/c7959557db)] - **(SEMVER-MINOR)** **http**: return this from IncomingMessage#destroy() (Colin Ihrig) [#32789](https://github.com/nodejs/node/pull/32789)
+* [[`a3a0c0e0fc`](https://github.com/nodejs/node/commit/a3a0c0e0fc)] - **(SEMVER-MINOR)** **http**: added scheduling option to http agent (delvedor) [#33278](https://github.com/nodejs/node/pull/33278)
+* [[`e3fd2f5a48`](https://github.com/nodejs/node/commit/e3fd2f5a48)] - **(SEMVER-MINOR)** **http2**: return this for Http2ServerRequest#setTimeout (Pranshu Srivastava) [#33994](https://github.com/nodejs/node/pull/33994)
+* [[`7ccb021ffc`](https://github.com/nodejs/node/commit/7ccb021ffc)] - **(SEMVER-MINOR)** **http2**: do not modify explicity set date headers (Pranshu Srivastava) [#33160](https://github.com/nodejs/node/pull/33160)
+* [[`f66bb57c13`](https://github.com/nodejs/node/commit/f66bb57c13)] - **(SEMVER-MINOR)** **process**: add unhandled-rejection throw and warn-with-error-code (Dan Fabulich) [#33475](https://github.com/nodejs/node/pull/33475)
+* [[`33020256de`](https://github.com/nodejs/node/commit/33020256de)] - **(SEMVER-MINOR)** **src**: store key data in separate class (Tobias Nießen) [#33360](https://github.com/nodejs/node/pull/33360)
+* [[`44b9d08344`](https://github.com/nodejs/node/commit/44b9d08344)] - **(SEMVER-MINOR)** **src**: add NativeKeyObject base class (Tobias Nießen) [#33360](https://github.com/nodejs/node/pull/33360)
+* [[`13e633873e`](https://github.com/nodejs/node/commit/13e633873e)] - **(SEMVER-MINOR)** **src**: rename internal key handles to KeyObjectHandle (Tobias Nießen) [#33360](https://github.com/nodejs/node/pull/33360)
+* [[`a3d0b0e2d7`](https://github.com/nodejs/node/commit/a3d0b0e2d7)] - **(SEMVER-MINOR)** **src**: add equality operators for BaseObjectPtr (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
+* [[`0720d1ff24`](https://github.com/nodejs/node/commit/0720d1ff24)] - **(SEMVER-MINOR)** **src**: introduce BaseObject base FunctionTemplate (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
+* [[`5362fef3f5`](https://github.com/nodejs/node/commit/5362fef3f5)] - **(SEMVER-MINOR)** **src**: add public APIs to manage v8::TracingController (Anna Henningsen) [#33850](https://github.com/nodejs/node/pull/33850)
+* [[`db2d1ca51b`](https://github.com/nodejs/node/commit/db2d1ca51b)] - **(SEMVER-MINOR)** **stream**: runtime deprecate Transform.\_transformState (Robert Nagy) [#32763](https://github.com/nodejs/node/pull/32763)
+* [[`b6da77756e`](https://github.com/nodejs/node/commit/b6da77756e)] - **(SEMVER-MINOR)** **test**: stop testing --interpreted-frames-native-stack for s390x (Michaël Zasso) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`5cad007408`](https://github.com/nodejs/node/commit/5cad007408)] - **(SEMVER-MINOR)** **test**: fix test-zlib-unused-weak on V8 8.2 (Matheus Marchini) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`2c59f9bbe2`](https://github.com/nodejs/node/commit/2c59f9bbe2)] - **(SEMVER-MINOR)** **tools**: update V8 gypfiles for V8 8.3 (Michaël Zasso) [#32831](https://github.com/nodejs/node/pull/32831)
+* [[`0ef6e0426f`](https://github.com/nodejs/node/commit/0ef6e0426f)] - **(SEMVER-MINOR)** **win**: allow skipping the supported platform check (João Reis) [#33176](https://github.com/nodejs/node/pull/33176)
+* [[`4e42eb5e14`](https://github.com/nodejs/node/commit/4e42eb5e14)] - **(SEMVER-MINOR)** **worker**: add public method for marking objects as untransferable (Anna Henningsen) [#33979](https://github.com/nodejs/node/pull/33979)
+* [[`4a37180b09`](https://github.com/nodejs/node/commit/4a37180b09)] - **(SEMVER-MINOR)** **worker**: emit `'messagerror'` events for failed deserialization (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
+* [[`9692208a91`](https://github.com/nodejs/node/commit/9692208a91)] - **(SEMVER-MINOR)** **worker**: allow passing JS wrapper objects via postMessage (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
+* [[`eaccf842eb`](https://github.com/nodejs/node/commit/eaccf842eb)] - **(SEMVER-MINOR)** **worker**: allow transferring/cloning generic BaseObjects (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
+* [[`5b1fd10048`](https://github.com/nodejs/node/commit/5b1fd10048)] - **(SEMVER-MINOR)** **worker,fs**: make FileHandle transferable (Anna Henningsen) [#33772](https://github.com/nodejs/node/pull/33772)
+* [[`c1f625fe1f`](https://github.com/nodejs/node/commit/c1f625fe1f)] - **(SEMVER-MINOR)** **zlib**: add `maxOutputLength` option (unknown) [#33516](https://github.com/nodejs/node/pull/33516)
+
+### Semver-Patch Commits
+
+* [[`ef05e1526a`](https://github.com/nodejs/node/commit/ef05e1526a)] - **async_hooks**: callback trampoline for MakeCallback (Stephen Belanger) [#33801](https://github.com/nodejs/node/pull/33801)
+* [[`0eed22d6ed`](https://github.com/nodejs/node/commit/0eed22d6ed)] - **benchmark**: fix EventTarget benchmark (Brian White) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`bf56decc79`](https://github.com/nodejs/node/commit/bf56decc79)] - **benchmark**: fix async-resource benchmark (Anna Henningsen) [#33642](https://github.com/nodejs/node/pull/33642)
+* [[`26269be510`](https://github.com/nodejs/node/commit/26269be510)] - **benchmark**: fixing http\_server\_for\_chunky\_client.js (Adrian Estrada) [#33271](https://github.com/nodejs/node/pull/33271)
+* [[`c31d5145d9`](https://github.com/nodejs/node/commit/c31d5145d9)] - **buffer**: remove hoisted variable (Nikolai Vavilov) [#33470](https://github.com/nodejs/node/pull/33470)
+* [[`43fd4746e9`](https://github.com/nodejs/node/commit/43fd4746e9)] - **build**: configure byte order for mips targets (Ben Noordhuis) [#33898](https://github.com/nodejs/node/pull/33898)
+* [[`ebb2fb81fa`](https://github.com/nodejs/node/commit/ebb2fb81fa)] - **build**: add target specific build\_type variable (Daniel Bevenius) [#33925](https://github.com/nodejs/node/pull/33925)
+* [[`e8f7670b77`](https://github.com/nodejs/node/commit/e8f7670b77)] - **build**: add LINT\_CPP\_FILES to checkimports check (Daniel Bevenius) [#33697](https://github.com/nodejs/node/pull/33697)
+* [[`1355d35a61`](https://github.com/nodejs/node/commit/1355d35a61)] - **build**: output dots in "Build from tarball" action (Michaël Zasso) [#33696](https://github.com/nodejs/node/pull/33696)
+* [[`153f5eda0e`](https://github.com/nodejs/node/commit/153f5eda0e)] - **build**: fix compiling addons with older versions of Node.js (Richard Lau) [#33688](https://github.com/nodejs/node/pull/33688)
+* [[`7a4c689912`](https://github.com/nodejs/node/commit/7a4c689912)] - **build**: fix node.gyp config (gengjiawen) [#33685](https://github.com/nodejs/node/pull/33685)
+* [[`1f7a65529d`](https://github.com/nodejs/node/commit/1f7a65529d)] - **build**: add --v8-lite-mode flag (Maciej Kacper Jagiełło) [#33541](https://github.com/nodejs/node/pull/33541)
+* [[`3ac05b75ca`](https://github.com/nodejs/node/commit/3ac05b75ca)] - **build**: zlib build error on Windows on Arm (Richard Townsend) [#33511](https://github.com/nodejs/node/pull/33511)
+* [[`fc032247e0`](https://github.com/nodejs/node/commit/fc032247e0)] - **build**: fix GetCurrentThreadStackLimits error on Windows on Arm (Richard Townsend) [#33511](https://github.com/nodejs/node/pull/33511)
+* [[`e393e879cf`](https://github.com/nodejs/node/commit/e393e879cf)] - **build**: fix python-version selection with actions (Richard Lau) [#33589](https://github.com/nodejs/node/pull/33589)
+* [[`8ed25eda60`](https://github.com/nodejs/node/commit/8ed25eda60)] - **build**: fix inability to detect correct python command in configure (Eli Schwartz) [#32925](https://github.com/nodejs/node/pull/32925)
+* [[`8b887c4462`](https://github.com/nodejs/node/commit/8b887c4462)] - **build**: fix makefile script on windows (Thomas) [#33136](https://github.com/nodejs/node/pull/33136)
+* [[`85ce30fe57`](https://github.com/nodejs/node/commit/85ce30fe57)] - **build**: run full test suite in ASAN action (Anna Henningsen) [#33170](https://github.com/nodejs/node/pull/33170)
+* [[`71c4d9174e`](https://github.com/nodejs/node/commit/71c4d9174e)] - **build,win**: add support for MSVC cross-compilation (Richard Townsend) [#32867](https://github.com/nodejs/node/pull/32867)
+* [[`ac7946eb08`](https://github.com/nodejs/node/commit/ac7946eb08)] - **build,win**: add support for MSVC cross-compilation (Richard Townsend) [#32867](https://github.com/nodejs/node/pull/32867)
+* [[`22b5ec19a2`](https://github.com/nodejs/node/commit/22b5ec19a2)] - **cli**: support --experimental-top-level-await in NODE\_OPTIONS (Dan Fabulich) [#33495](https://github.com/nodejs/node/pull/33495)
+* [[`0a7f13e26b`](https://github.com/nodejs/node/commit/0a7f13e26b)] - **configure**: account for CLANG\_VENDOR when checking for llvm version (Nathan Blair) [#33860](https://github.com/nodejs/node/pull/33860)
+* [[`a6a74ae1d5`](https://github.com/nodejs/node/commit/a6a74ae1d5)] - **console**: name console functions appropriately (Ruben Bridgewater) [#33524](https://github.com/nodejs/node/pull/33524)
+* [[`9d24f71d45`](https://github.com/nodejs/node/commit/9d24f71d45)] - **console**: mark special console properties as non-enumerable (Ruben Bridgewater) [#33524](https://github.com/nodejs/node/pull/33524)
+* [[`bce99867f7`](https://github.com/nodejs/node/commit/bce99867f7)] - **console**: remove dead code (Ruben Bridgewater) [#33524](https://github.com/nodejs/node/pull/33524)
+* [[`134ed0eea3`](https://github.com/nodejs/node/commit/134ed0eea3)] - **crypto**: fix wrong error message (Ben Bucksch) [#33482](https://github.com/nodejs/node/pull/33482)
+* [[`5957afc31a`](https://github.com/nodejs/node/commit/5957afc31a)] - **deps**: V8: cherry-pick 767e65f945e7 (Gus Caplan) [#33859](https://github.com/nodejs/node/pull/33859)
+* [[`162092ea2a`](https://github.com/nodejs/node/commit/162092ea2a)] - **deps**: V8: cherry-pick eec10a2fd8fa (Stephen Belanger) [#33778](https://github.com/nodejs/node/pull/33778)
+* [[`499c7402b1`](https://github.com/nodejs/node/commit/499c7402b1)] - **deps**: V8: cherry-pick 4e1bf2bc92bd (Milad Farazmand) [#33702](https://github.com/nodejs/node/pull/33702)
+* [[`0524c7ad5d`](https://github.com/nodejs/node/commit/0524c7ad5d)] - **deps**: V8: cherry-pick b5939c758924 (Milad Farazmand) [#33702](https://github.com/nodejs/node/pull/33702)
+* [[`7ad6cfa005`](https://github.com/nodejs/node/commit/7ad6cfa005)] - **deps**: V8: backport 22014de00115 (Joyee Cheung) [#33300](https://github.com/nodejs/node/pull/33300)
+* [[`817befde11`](https://github.com/nodejs/node/commit/817befde11)] - **deps**: V8: backport bb9f0c2b2fe9 (Joyee Cheung) [#33300](https://github.com/nodejs/node/pull/33300)
+* [[`8f82692999`](https://github.com/nodejs/node/commit/8f82692999)] - **deps**: V8: backport ea0719b8ed08 (Joyee Cheung) [#33300](https://github.com/nodejs/node/pull/33300)
+* [[`773d76ea04`](https://github.com/nodejs/node/commit/773d76ea04)] - **deps**: uvwasi: cherry-pick 9e75217 (Colin Ihrig) [#33521](https://github.com/nodejs/node/pull/33521)
+* [[`748720e7b6`](https://github.com/nodejs/node/commit/748720e7b6)] - **deps**: V8: cherry-pick 548f6c81d424 (Dominykas Blyžė) [#33484](https://github.com/nodejs/node/pull/33484)
+* [[`b0bce9b2a4`](https://github.com/nodejs/node/commit/b0bce9b2a4)] - **deps**: update node-inspect to v2.0.0 (Jan Krems) [#33447](https://github.com/nodejs/node/pull/33447)
+* [[`ac459b34e7`](https://github.com/nodejs/node/commit/ac459b34e7)] - **deps**: V8: cherry-pick fa3e37e511ee (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`2bc79f5b50`](https://github.com/nodejs/node/commit/2bc79f5b50)] - **deps**: V8: cherry-pick 2db93c023379 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`8d47e8bf7b`](https://github.com/nodejs/node/commit/8d47e8bf7b)] - **deps**: update to uvwasi 0.0.9 (Colin Ihrig) [#33445](https://github.com/nodejs/node/pull/33445)
+* [[`9d6fd4599d`](https://github.com/nodejs/node/commit/9d6fd4599d)] - **deps**: upgrade to libuv 1.38.0 (Colin Ihrig) [#33446](https://github.com/nodejs/node/pull/33446)
+* [[`33a662ad2d`](https://github.com/nodejs/node/commit/33a662ad2d)] - **deps**: update icu to include tzdata2020a (Shelley Vohr) [#33362](https://github.com/nodejs/node/pull/33362)
+* [[`f151bde312`](https://github.com/nodejs/node/commit/f151bde312)] - **(SEMVER-MINOR)** **dgram**: allow typed arrays in .send() (Sarat Addepalli) [#22413](https://github.com/nodejs/node/pull/22413)
+* [[`d4442b15bf`](https://github.com/nodejs/node/commit/d4442b15bf)] - **dns**: make dns.Resolver timeout configurable (Ben Noordhuis) [#33472](https://github.com/nodejs/node/pull/33472)
+* [[`eb55d9e4b1`](https://github.com/nodejs/node/commit/eb55d9e4b1)] - **dns**: use ternary operator simplify statement (Wenning Zhang) [#33234](https://github.com/nodejs/node/pull/33234)
+* [[`d61de303c9`](https://github.com/nodejs/node/commit/d61de303c9)] - **doc**: specify maxHeaderCount alias for maxHeaderListPairs (Pranshu Srivastava) [#33519](https://github.com/nodejs/node/pull/33519)
+* [[`4323346f5a`](https://github.com/nodejs/node/commit/4323346f5a)] - **doc**: add allowed info strings to style guide (Derek Lewis) [#34024](https://github.com/nodejs/node/pull/34024)
+* [[`0dbad26db4`](https://github.com/nodejs/node/commit/0dbad26db4)] - **doc**: fix lexical sorting of bottom-references in http doc (Pranshu Srivastava) [#34007](https://github.com/nodejs/node/pull/34007)
+* [[`ec07e61f6a`](https://github.com/nodejs/node/commit/ec07e61f6a)] - **doc**: clarify thread-safe function references (legendecas) [#33871](https://github.com/nodejs/node/pull/33871)
+* [[`5a4dcfcf4c`](https://github.com/nodejs/node/commit/5a4dcfcf4c)] - **doc**: use npm team for npm upgrades in collaborator guide (Rich Trott) [#33999](https://github.com/nodejs/node/pull/33999)
+* [[`319707add2`](https://github.com/nodejs/node/commit/319707add2)] - **doc**: correct default values in http2 docs (Rich Trott) [#33997](https://github.com/nodejs/node/pull/33997)
+* [[`b4d0eebe7c`](https://github.com/nodejs/node/commit/b4d0eebe7c)] - **doc**: use a single space between sentences (Rich Trott) [#33995](https://github.com/nodejs/node/pull/33995)
+* [[`24105a7f44`](https://github.com/nodejs/node/commit/24105a7f44)] - **doc**: piping from async generators using pipeline() (WilliamConnatser) [#33992](https://github.com/nodejs/node/pull/33992)
+* [[`9590d81349`](https://github.com/nodejs/node/commit/9590d81349)] - **doc**: revise text in dns module documentation introduction (Rich Trott) [#33986](https://github.com/nodejs/node/pull/33986)
+* [[`ed26e8e2fb`](https://github.com/nodejs/node/commit/ed26e8e2fb)] - **doc**: update fs.md (Shakil-Shahadat) [#33820](https://github.com/nodejs/node/pull/33820)
+* [[`6dc541778e`](https://github.com/nodejs/node/commit/6dc541778e)] - **doc**: warn that tls.connect() doesn't set SNI (Alba Mendez) [#33855](https://github.com/nodejs/node/pull/33855)
+* [[`d9c78ac270`](https://github.com/nodejs/node/commit/d9c78ac270)] - **doc**: fix lexical sorting of bottom-references in dns doc (Rich Trott) [#33987](https://github.com/nodejs/node/pull/33987)
+* [[`98228b25af`](https://github.com/nodejs/node/commit/98228b25af)] - **doc**: change "GitHub Repo" to "Code repository" (Rich Trott) [#33985](https://github.com/nodejs/node/pull/33985)
+* [[`645cd481e9`](https://github.com/nodejs/node/commit/645cd481e9)] - **doc**: use Class: consistently (Rich Trott) [#33978](https://github.com/nodejs/node/pull/33978)
+* [[`72e2fd315e`](https://github.com/nodejs/node/commit/72e2fd315e)] - **doc**: update WASM code sample (Pragyan Das) [#33626](https://github.com/nodejs/node/pull/33626)
+* [[`894ec7d5c6`](https://github.com/nodejs/node/commit/894ec7d5c6)] - **doc**: standardize on sentence case for headers (Rich Trott) [#33889](https://github.com/nodejs/node/pull/33889)
+* [[`61de26a2f3`](https://github.com/nodejs/node/commit/61de26a2f3)] - **doc**: link readable.\_read in stream.md (Pranshu Srivastava) [#33767](https://github.com/nodejs/node/pull/33767)
+* [[`76fe2a93a9`](https://github.com/nodejs/node/commit/76fe2a93a9)] - **doc**: specify default encoding in writable.write (Pranshu Srivastava) [#33765](https://github.com/nodejs/node/pull/33765)
+* [[`2427d6544b`](https://github.com/nodejs/node/commit/2427d6544b)] - **doc**: move --force-context-aware option in cli.md (Daniel Bevenius) [#33823](https://github.com/nodejs/node/pull/33823)
+* [[`fdaf0ca550`](https://github.com/nodejs/node/commit/fdaf0ca550)] - **doc**: add snippet for AsyncResource and EE integration (Andrey Pechkurov) [#33751](https://github.com/nodejs/node/pull/33751)
+* [[`8f5ac3865c`](https://github.com/nodejs/node/commit/8f5ac3865c)] - **doc**: use single quotes in --tls-cipher-list (Daniel Bevenius) [#33709](https://github.com/nodejs/node/pull/33709)
+* [[`922c13c6bb`](https://github.com/nodejs/node/commit/922c13c6bb)] - **doc**: fix misc. mislabeled code block info strings (Derek Lewis) [#33548](https://github.com/nodejs/node/pull/33548)
+* [[`114d77e30b`](https://github.com/nodejs/node/commit/114d77e30b)] - **doc**: standardize constructor doc header layout (Rich Trott) [#33781](https://github.com/nodejs/node/pull/33781)
+* [[`b10d20385e`](https://github.com/nodejs/node/commit/b10d20385e)] - **doc**: update V8 inspector example (Colin Ihrig) [#33758](https://github.com/nodejs/node/pull/33758)
+* [[`785760448b`](https://github.com/nodejs/node/commit/785760448b)] - **doc**: fix linting in doc-style-guide.md (Pranshu Srivastava) [#33787](https://github.com/nodejs/node/pull/33787)
+* [[`2288840a8f`](https://github.com/nodejs/node/commit/2288840a8f)] - **doc**: remove "currently" from repl.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
+* [[`cc0f827182`](https://github.com/nodejs/node/commit/cc0f827182)] - **doc**: remove "currently" from events.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
+* [[`4a738e6462`](https://github.com/nodejs/node/commit/4a738e6462)] - **doc**: remove "currently" from vm.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
+* [[`bb29a8177f`](https://github.com/nodejs/node/commit/bb29a8177f)] - **doc**: remove "currently" from addons.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
+* [[`f0597d9a6e`](https://github.com/nodejs/node/commit/f0597d9a6e)] - **doc**: remove "currently" from util.md (Rich Trott) [#33756](https://github.com/nodejs/node/pull/33756)
+* [[`095efac2ef`](https://github.com/nodejs/node/commit/095efac2ef)] - **doc**: add formatting for version numbers to doc-style-guide.md (Rich Trott) [#33755](https://github.com/nodejs/node/pull/33755)
+* [[`843ab3eb94`](https://github.com/nodejs/node/commit/843ab3eb94)] - **doc**: change "pre Node.js v0.10" to "prior to Node.js 0.10" (Rich Trott) [#33754](https://github.com/nodejs/node/pull/33754)
+* [[`b565897996`](https://github.com/nodejs/node/commit/b565897996)] - **doc**: remove default parameter value from header (Rich Trott) [#33752](https://github.com/nodejs/node/pull/33752)
+* [[`ebf2378731`](https://github.com/nodejs/node/commit/ebf2378731)] - **doc**: fix typo in cli.md for report-dir (AshCripps) [#33725](https://github.com/nodejs/node/pull/33725)
+* [[`16b69818ba`](https://github.com/nodejs/node/commit/16b69818ba)] - **doc**: remove shell dollar signs without output (Nick Schonning) [#33692](https://github.com/nodejs/node/pull/33692)
+* [[`b3d500f949`](https://github.com/nodejs/node/commit/b3d500f949)] - **doc**: add lint disabling comment for collaborator list (Rich Trott) [#33719](https://github.com/nodejs/node/pull/33719)
+* [[`61bb789fa0`](https://github.com/nodejs/node/commit/61bb789fa0)] - **doc**: use consistent Default: in events (Colin Ihrig) [#33678](https://github.com/nodejs/node/pull/33678)
+* [[`1e4edd8d75`](https://github.com/nodejs/node/commit/1e4edd8d75)] - **doc**: remove "it is important" (Colin Ihrig) [#33678](https://github.com/nodejs/node/pull/33678)
+* [[`cb8b9ec98a`](https://github.com/nodejs/node/commit/cb8b9ec98a)] - **doc**: fix urls to avoid redirection (sapics) [#33614](https://github.com/nodejs/node/pull/33614)
+* [[`c184929975`](https://github.com/nodejs/node/commit/c184929975)] - **doc**: improve buffer.md a tiny bit (Tom Nagle) [#33547](https://github.com/nodejs/node/pull/33547)
+* [[`6d25b5753a`](https://github.com/nodejs/node/commit/6d25b5753a)] - **doc**: normalize Markdown code block info strings (Derek Lewis) [#33542](https://github.com/nodejs/node/pull/33542)
+* [[`e7c3890901`](https://github.com/nodejs/node/commit/e7c3890901)] - **doc**: normalize JavaScript code block info strings (Derek Lewis) [#33531](https://github.com/nodejs/node/pull/33531)
+* [[`352adcb437`](https://github.com/nodejs/node/commit/352adcb437)] - **doc**: outline when origin is set to unhandledRejection (Ruben Bridgewater) [#33530](https://github.com/nodejs/node/pull/33530)
+* [[`94177dae8e`](https://github.com/nodejs/node/commit/94177dae8e)] - **doc**: add --experimental-top-level-await to man page (Colin Ihrig) [#33529](https://github.com/nodejs/node/pull/33529)
+* [[`8e3a0d7773`](https://github.com/nodejs/node/commit/8e3a0d7773)] - **doc**: update ```txt ```fandamental and ```raw code blocks (Zeke Sikelianos) [#33028](https://github.com/nodejs/node/pull/33028)
+* [[`4cc391b495`](https://github.com/nodejs/node/commit/4cc391b495)] - **doc**: normalize shell code block info strings (Derek Lewis) [#33486](https://github.com/nodejs/node/pull/33486)
+* [[`24ada7acd4`](https://github.com/nodejs/node/commit/24ada7acd4)] - **doc**: normalize C code block info strings (Derek Lewis) [#33507](https://github.com/nodejs/node/pull/33507)
+* [[`8c04e61f16`](https://github.com/nodejs/node/commit/8c04e61f16)] - **doc**: normalize Bash code block info strings (Derek Lewis) [#33510](https://github.com/nodejs/node/pull/33510)
+* [[`7c87fc1c48`](https://github.com/nodejs/node/commit/7c87fc1c48)] - **doc**: correct tls.rootCertificates to match implementation (Eric Bickle) [#33313](https://github.com/nodejs/node/pull/33313)
+* [[`0c2b7c0adf`](https://github.com/nodejs/node/commit/0c2b7c0adf)] - **doc**: fix Buffer.from(object) documentation (Nikolai Vavilov) [#33327](https://github.com/nodejs/node/pull/33327)
+* [[`de608c3124`](https://github.com/nodejs/node/commit/de608c3124)] - **doc**: fix typo in pathToFileURL example (Antoine du HAMEL) [#33418](https://github.com/nodejs/node/pull/33418)
+* [[`23cf39ab78`](https://github.com/nodejs/node/commit/23cf39ab78)] - **doc**: eliminate dead space in API section's sidebar (John Gardner) [#33469](https://github.com/nodejs/node/pull/33469)
+* [[`95e7a80cbf`](https://github.com/nodejs/node/commit/95e7a80cbf)] - **doc**: mention --experimental-top-level-await flag (dfabulich) [#33473](https://github.com/nodejs/node/pull/33473)
+* [[`64410f206e`](https://github.com/nodejs/node/commit/64410f206e)] - **doc**: normalize C++ code block info strings (Derek Lewis) [#33483](https://github.com/nodejs/node/pull/33483)
+* [[`c8f79d80a4`](https://github.com/nodejs/node/commit/c8f79d80a4)] - **doc**: fixed a grammatical error in path.md (Deep310) [#33489](https://github.com/nodejs/node/pull/33489)
+* [[`500bad1103`](https://github.com/nodejs/node/commit/500bad1103)] - **doc**: correct CommonJS self-resolve spec (Guy Bedford) [#33391](https://github.com/nodejs/node/pull/33391)
+* [[`4e74f050a7`](https://github.com/nodejs/node/commit/4e74f050a7)] - **doc**: fix readline key binding documentation (Ruben Bridgewater) [#33361](https://github.com/nodejs/node/pull/33361)
+* [[`7c553cd4f6`](https://github.com/nodejs/node/commit/7c553cd4f6)] - **doc**: claim ABI version 85 for Electron 11 (Shelley Vohr) [#33375](https://github.com/nodejs/node/pull/33375)
+* [[`4cc5e9668f`](https://github.com/nodejs/node/commit/4cc5e9668f)] - **doc**: document module.path (Antoine du Hamel) [#33323](https://github.com/nodejs/node/pull/33323)
+* [[`c1fe152132`](https://github.com/nodejs/node/commit/c1fe152132)] - **doc**: add fs.open() multiple constants example (Ethan Arrowood) [#33281](https://github.com/nodejs/node/pull/33281)
+* [[`b02cfef510`](https://github.com/nodejs/node/commit/b02cfef510)] - **doc**: fix typos in handle scope descriptions (Tobias Nießen) [#33267](https://github.com/nodejs/node/pull/33267)
+* [[`d4e871424f`](https://github.com/nodejs/node/commit/d4e871424f)] - **doc**: update function description for `decipher.setAAD` (Jonathan Buhacoff) [#33095](https://github.com/nodejs/node/pull/33095)
+* [[`e2484b24cb`](https://github.com/nodejs/node/commit/e2484b24cb)] - **doc**: add comment about highWaterMark limit (Benjamin Gruenbaum) [#33432](https://github.com/nodejs/node/pull/33432)
+* [[`b8c88891a6`](https://github.com/nodejs/node/commit/b8c88891a6)] - **doc**: clarify about the Node.js-only extensions in perf\_hooks (Joyee Cheung) [#33199](https://github.com/nodejs/node/pull/33199)
+* [[`d1efdb29b4`](https://github.com/nodejs/node/commit/d1efdb29b4)] - **doc**: document ICU time zone data update process (Andrew Paprocki) [#30364](https://github.com/nodejs/node/pull/30364)
+* [[`1d918b67ca`](https://github.com/nodejs/node/commit/1d918b67ca)] - **doc,stream**: split finish and end events into separate entries (Rich Trott) [#33881](https://github.com/nodejs/node/pull/33881)
+* [[`af9fb5969d`](https://github.com/nodejs/node/commit/af9fb5969d)] - **doc,tools**: properly syntax highlight API ref docs (Derek Lewis) [#33442](https://github.com/nodejs/node/pull/33442)
+* [[`122d2b5c02`](https://github.com/nodejs/node/commit/122d2b5c02)] - **domain**: remove native domain code (Stephen Belanger) [#33801](https://github.com/nodejs/node/pull/33801)
+* [[`e060060aa2`](https://github.com/nodejs/node/commit/e060060aa2)] - **errors**: fully inspect errors on exit (Ruben Bridgewater) [#33523](https://github.com/nodejs/node/pull/33523)
+* [[`aca07f428e`](https://github.com/nodejs/node/commit/aca07f428e)] - **errors**: skip fatal error highlighting on windows (Thomas) [#33132](https://github.com/nodejs/node/pull/33132)
+* [[`50adccadc1`](https://github.com/nodejs/node/commit/50adccadc1)] - **esm**: fix loader hooks doc annotations (Derek Lewis) [#33563](https://github.com/nodejs/node/pull/33563)
+* [[`5bef20c2fc`](https://github.com/nodejs/node/commit/5bef20c2fc)] - **esm**: share package.json cache between ESM and CJS loaders (Kirill Shatskiy) [#33229](https://github.com/nodejs/node/pull/33229)
+* [[`828d5d22eb`](https://github.com/nodejs/node/commit/828d5d22eb)] - **esm**: doc & validate source values for formats (Bradley Farias) [#32202](https://github.com/nodejs/node/pull/32202)
+* [[`2724514f53`](https://github.com/nodejs/node/commit/2724514f53)] - **event**: cancelBubble is a property (Benjamin Gruenbaum) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`c9dec0c0f0`](https://github.com/nodejs/node/commit/c9dec0c0f0)] - **event**: cancelBubble is a property (Benjamin Gruenbaum) [#33613](https://github.com/nodejs/node/pull/33613)
+* [[`0c32920a82`](https://github.com/nodejs/node/commit/0c32920a82)] - **events**: fix add-remove-add case in EventTarget (Anna Henningsen) [#34056](https://github.com/nodejs/node/pull/34056)
+* [[`c34f4743c4`](https://github.com/nodejs/node/commit/c34f4743c4)] - **events**: improve argument handling, start passive (James M Snell) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`ea1a2d7bc9`](https://github.com/nodejs/node/commit/ea1a2d7bc9)] - **events**: support dispatching event from event (James M Snell) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`5ce153365e`](https://github.com/nodejs/node/commit/5ce153365e)] - **events**: add event-target tests (James M Snell) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`91b6c093b1`](https://github.com/nodejs/node/commit/91b6c093b1)] - **events**: support event handlers (Benjamin Gruenbaum) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`b392fdd4aa`](https://github.com/nodejs/node/commit/b392fdd4aa)] - **events**: expose Event statics (Benjamin Gruenbaum) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`cd3a1429a3`](https://github.com/nodejs/node/commit/cd3a1429a3)] - **events**: Handle a range of this values for dispatchEvent (Zirak) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`aa1cb3f186`](https://github.com/nodejs/node/commit/aa1cb3f186)] - **events**: fix EventTarget support (Benjamin Gruenbaum) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`0f0f4e0c40`](https://github.com/nodejs/node/commit/0f0f4e0c40)] - **events**: fix depth in customInspectSymbol and clean up (Denys Otrishko) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`6ce3293cc4`](https://github.com/nodejs/node/commit/6ce3293cc4)] - **events**: use internal/validators in event\_target.js (Denys Otrishko) [#34015](https://github.com/nodejs/node/pull/34015)
+* [[`eb01214ab2`](https://github.com/nodejs/node/commit/eb01214ab2)] - **events**: use property, primordials (Benjamin Gruenbaum) [#33775](https://github.com/nodejs/node/pull/33775)
+* [[`667195ef8f`](https://github.com/nodejs/node/commit/667195ef8f)] - **events**: improve listeners() performance (Brian White) [#33863](https://github.com/nodejs/node/pull/33863)
+* [[`f1b0291d82`](https://github.com/nodejs/node/commit/f1b0291d82)] - **events**: lazy load perf\_hooks for EventTarget (James M Snell) [#33717](https://github.com/nodejs/node/pull/33717)
+* [[`c291ce599c`](https://github.com/nodejs/node/commit/c291ce599c)] - **events**: improve arrayClone performance (Brian White) [#33774](https://github.com/nodejs/node/pull/33774)
+* [[`a3ef2b7335`](https://github.com/nodejs/node/commit/a3ef2b7335)] - **events**: support useCapture boolean (Benjamin Gruenbaum) [#33618](https://github.com/nodejs/node/pull/33618)
+* [[`2e6eceac5c`](https://github.com/nodejs/node/commit/2e6eceac5c)] - **events**: set target property to null (Benjamin Gruenbaum) [#33615](https://github.com/nodejs/node/pull/33615)
+* [[`bc2e821ccc`](https://github.com/nodejs/node/commit/bc2e821ccc)] - **events**: deal with no argument case (Benjamin Gruenbaum) [#33611](https://github.com/nodejs/node/pull/33611)
+* [[`e7bce2e03a`](https://github.com/nodejs/node/commit/e7bce2e03a)] - **events**: deal with Symbol() passed to event constructor (Benjamin Gruenbaum) [#33612](https://github.com/nodejs/node/pull/33612)
+* [[`27c90efce0`](https://github.com/nodejs/node/commit/27c90efce0)] - **events**: variable originalListener is useless (fuxingZhang) [#33596](https://github.com/nodejs/node/pull/33596)
+* [[`2a29ced050`](https://github.com/nodejs/node/commit/2a29ced050)] - **events**: fix event-target enumerable keys (Benjamin Gruenbaum) [#33616](https://github.com/nodejs/node/pull/33616)
+* [[`f3d0d3089d`](https://github.com/nodejs/node/commit/f3d0d3089d)] - **events**: add tests, better toString (Benjamin Gruenbaum) [#33622](https://github.com/nodejs/node/pull/33622)
+* [[`95cbfcec99`](https://github.com/nodejs/node/commit/95cbfcec99)] - **fs**: fix readdir failure when libuv returns UV\_DIRENT\_UNKNOWN (Kirill Shatskiy) [#33395](https://github.com/nodejs/node/pull/33395)
+* [[`b894df860a`](https://github.com/nodejs/node/commit/b894df860a)] - **fs**: fix realpath inode link caching (Denys Otrishko) [#33945](https://github.com/nodejs/node/pull/33945)
+* [[`b280c86213`](https://github.com/nodejs/node/commit/b280c86213)] - **fs**: support util.promisify for fs.readv (Lucas Holmquist) [#33590](https://github.com/nodejs/node/pull/33590)
+* [[`2c03661860`](https://github.com/nodejs/node/commit/2c03661860)] - **fs**: unify style in preprocessSymlinkDestination (Bartosz Sosnowski) [#33496](https://github.com/nodejs/node/pull/33496)
+* [[`b675ea0272`](https://github.com/nodejs/node/commit/b675ea0272)] - **fs**: replace checkPosition with validateInteger (rickyes) [#33277](https://github.com/nodejs/node/pull/33277)
+* [[`a90b96f338`](https://github.com/nodejs/node/commit/a90b96f338)] - **fs**: refactor the import of internalUtil (rickyes) [#33296](https://github.com/nodejs/node/pull/33296)
+* [[`a0a61b81a5`](https://github.com/nodejs/node/commit/a0a61b81a5)] - **http**: used already defined validator for boolean check (Yash Ladha) [#33731](https://github.com/nodejs/node/pull/33731)
+* [[`6dbd63c8ba`](https://github.com/nodejs/node/commit/6dbd63c8ba)] - ***Revert*** "**http**: set IncomingMessage.destroyed" (Robert Nagy) [#33686](https://github.com/nodejs/node/pull/33686)
+* [[`feb6e1ffb8`](https://github.com/nodejs/node/commit/feb6e1ffb8)] - **http**: don't throw on `Uint8Array`s for `http.ServerResponse#write` (Pranshu Srivastava) [#33155](https://github.com/nodejs/node/pull/33155)
+* [[`bcdf7e94be`](https://github.com/nodejs/node/commit/bcdf7e94be)] - **http**: simplify Agent initialization (himself65) [#33551](https://github.com/nodejs/node/pull/33551)
+* [[`c2aad813c0`](https://github.com/nodejs/node/commit/c2aad813c0)] - **http**: tidy up exposure of header validation (Osher) [#33371](https://github.com/nodejs/node/pull/33371)
+* [[`0752d2309f`](https://github.com/nodejs/node/commit/0752d2309f)] - **http2**: always call callback on Http2ServerResponse#end (Pranshu Srivastava) [#33911](https://github.com/nodejs/node/pull/33911)
+* [[`d8aeafb4bf`](https://github.com/nodejs/node/commit/d8aeafb4bf)] - **http2**: add writable\* properties to compat api (Pranshu Srivastava) [#33506](https://github.com/nodejs/node/pull/33506)
+* [[`0b34c4fb75`](https://github.com/nodejs/node/commit/0b34c4fb75)] - **http2**: add type checks for Http2ServerResponse.end (Pranshu Srivastava) [#33146](https://github.com/nodejs/node/pull/33146)
+* [[`cc74f3c67c`](https://github.com/nodejs/node/commit/cc74f3c67c)] - **http2**: use `Object.create(null)` for `getHeaders` (Pranshu Srivastava) [#33188](https://github.com/nodejs/node/pull/33188)
+* [[`8457033d83`](https://github.com/nodejs/node/commit/8457033d83)] - **http2**: reuse .\_onTimeout() in Http2Session and Http2Stream classes (rickyes) [#33354](https://github.com/nodejs/node/pull/33354)
+* [[`c972ce200e`](https://github.com/nodejs/node/commit/c972ce200e)] - **http2**: comment on usage of `Object.create(null)` (Pranshu Srivastava) [#33183](https://github.com/nodejs/node/pull/33183)
+* [[`e58f14fee7`](https://github.com/nodejs/node/commit/e58f14fee7)] - **inspector**: drop 'chrome-' from inspector url (Colin Ihrig) [#33758](https://github.com/nodejs/node/pull/33758)
+* [[`42df2baa21`](https://github.com/nodejs/node/commit/42df2baa21)] - **inspector**: throw error when activating an already active inspector (Joyee Cheung) [#33015](https://github.com/nodejs/node/pull/33015)
+* [[`c9489f2f23`](https://github.com/nodejs/node/commit/c9489f2f23)] - **internal**: rename error-serdes for consistency (Evan Lucas) [#33793](https://github.com/nodejs/node/pull/33793)
+* [[`b7690da65e`](https://github.com/nodejs/node/commit/b7690da65e)] - **lib**: improve debuglog() performance (Brian White) [#32260](https://github.com/nodejs/node/pull/32260)
+* [[`b6ef6c8476`](https://github.com/nodejs/node/commit/b6ef6c8476)] - **lib**: remove manual exception handling in queueMicrotask (Gus Caplan) [#33859](https://github.com/nodejs/node/pull/33859)
+* [[`ec01867623`](https://github.com/nodejs/node/commit/ec01867623)] - **lib**: replace charCodeAt with fixed Unicode (rickyes) [#32758](https://github.com/nodejs/node/pull/32758)
+* [[`76123b9ae7`](https://github.com/nodejs/node/commit/76123b9ae7)] - **lib**: add Int16Array primordials (Sebastien Ahkrin) [#31205](https://github.com/nodejs/node/pull/31205)
+* [[`59d435ed4d`](https://github.com/nodejs/node/commit/59d435ed4d)] - **lib**: update TODO comments (Ruben Bridgewater) [#33361](https://github.com/nodejs/node/pull/33361)
+* [[`e62a8b5007`](https://github.com/nodejs/node/commit/e62a8b5007)] - **lib**: update executionAsyncId/triggerAsyncId comment (Daniel Bevenius) [#33396](https://github.com/nodejs/node/pull/33396)
+* [[`4ae4073abf`](https://github.com/nodejs/node/commit/4ae4073abf)] - **lib,src**: remove cpu profiler idle notifier (Ben Noordhuis) [#34010](https://github.com/nodejs/node/pull/34010)
+* [[`fc7cad828b`](https://github.com/nodejs/node/commit/fc7cad828b)] - **meta**: introduce codeowners again (James M Snell) [#33895](https://github.com/nodejs/node/pull/33895)
+* [[`b162c532d7`](https://github.com/nodejs/node/commit/b162c532d7)] - **meta**: fix a typo in the flaky test template (Colin Ihrig) [#33677](https://github.com/nodejs/node/pull/33677)
+* [[`148c1f1344`](https://github.com/nodejs/node/commit/148c1f1344)] - **meta**: wrap flaky test template at 80 characters (Colin Ihrig) [#33677](https://github.com/nodejs/node/pull/33677)
+* [[`2aa6469bea`](https://github.com/nodejs/node/commit/2aa6469bea)] - **meta**: add flaky test issue template (Ash Cripps) [#33500](https://github.com/nodejs/node/pull/33500)
+* [[`84a5e6cec8`](https://github.com/nodejs/node/commit/84a5e6cec8)] - **module**: fix error message about importing names from cjs (Fábio Santos) [#33882](https://github.com/nodejs/node/pull/33882)
+* [[`8c9e3a9dfb`](https://github.com/nodejs/node/commit/8c9e3a9dfb)] - **module**: remove dynamicInstantiate loader hook (Jan Krems) [#33501](https://github.com/nodejs/node/pull/33501)
+* [[`53dbb9d232`](https://github.com/nodejs/node/commit/53dbb9d232)] - **n-api**: add version to wasm registration (Gus Caplan) [#34045](https://github.com/nodejs/node/pull/34045)
+* [[`e924439d96`](https://github.com/nodejs/node/commit/e924439d96)] - **n-api**: document nextTick timing in callbacks (Mathias Buus) [#33804](https://github.com/nodejs/node/pull/33804)
+* [[`524daf89a1`](https://github.com/nodejs/node/commit/524daf89a1)] - **n-api**: ensure scope present for finalization (Michael Dawson) [#33508](https://github.com/nodejs/node/pull/33508)
+* [[`e83642f73d`](https://github.com/nodejs/node/commit/e83642f73d)] - **n-api**: remove `napi\_env::CallIntoModuleThrow` (Gabriel Schulhof) [#33570](https://github.com/nodejs/node/pull/33570)
+* [[`4c235b07ae`](https://github.com/nodejs/node/commit/4c235b07ae)] - ***Revert*** "**n-api**: detect deadlocks in thread-safe function" (Anna Henningsen) [#33453](https://github.com/nodejs/node/pull/33453)
+* [[`022dcebcd8`](https://github.com/nodejs/node/commit/022dcebcd8)] - **napi**: add \_\_wasm32\_\_ guards (Gus Caplan) [#33597](https://github.com/nodejs/node/pull/33597)
+* [[`164461edfd`](https://github.com/nodejs/node/commit/164461edfd)] - **net**: refactor check for Windows (rickyes) [#33497](https://github.com/nodejs/node/pull/33497)
+* [[`e0b0ddd257`](https://github.com/nodejs/node/commit/e0b0ddd257)] - **querystring**: fix stringify for empty array (sapics) [#33918](https://github.com/nodejs/node/pull/33918)
+* [[`e8572e7070`](https://github.com/nodejs/node/commit/e8572e7070)] - **querystring**: improve stringify() performance (Brian White) [#33669](https://github.com/nodejs/node/pull/33669)
+* [[`011fe1d443`](https://github.com/nodejs/node/commit/011fe1d443)] - **repl**: add builtinModules (Ruben Bridgewater) [#33295](https://github.com/nodejs/node/pull/33295)
+* [[`71d6599191`](https://github.com/nodejs/node/commit/71d6599191)] - **repl**: simplify repl autocompletion (Ruben Bridgewater) [#33450](https://github.com/nodejs/node/pull/33450)
+* [[`1330cfc2a9`](https://github.com/nodejs/node/commit/1330cfc2a9)] - **repl**: support optional chaining during autocompletion (Ruben Bridgewater) [#33450](https://github.com/nodejs/node/pull/33450)
+* [[`9760c6caff`](https://github.com/nodejs/node/commit/9760c6caff)] - **src**: add errorProperties on process.report (himself65) [#28426](https://github.com/nodejs/node/pull/28426)
+* [[`da81930b13`](https://github.com/nodejs/node/commit/da81930b13)] - **src**: tolerate EPERM returned from tcsetattr (patr0nus) [#33944](https://github.com/nodejs/node/pull/33944)
+* [[`c1664a9008`](https://github.com/nodejs/node/commit/c1664a9008)] - **src**: clang\_format base\_object (Yash Ladha) [#33680](https://github.com/nodejs/node/pull/33680)
+* [[`a789474945`](https://github.com/nodejs/node/commit/a789474945)] - **src**: fix ParseEncoding (sapics) [#33957](https://github.com/nodejs/node/pull/33957)
+* [[`74f4aae22f`](https://github.com/nodejs/node/commit/74f4aae22f)] - **src**: remove unnecessary calculation in base64.h (sapics) [#33839](https://github.com/nodejs/node/pull/33839)
+* [[`c492a2715e`](https://github.com/nodejs/node/commit/c492a2715e)] - **src**: use ToLocal in node\_os.cc (wenningplus) [#33939](https://github.com/nodejs/node/pull/33939)
+* [[`9a52cd9cc0`](https://github.com/nodejs/node/commit/9a52cd9cc0)] - **src**: handle empty Maybe(Local) in node\_util.cc (Anna Henningsen) [#33867](https://github.com/nodejs/node/pull/33867)
+* [[`e1bebf13db`](https://github.com/nodejs/node/commit/e1bebf13db)] - **src**: fix FastStringKey equal operator (sapics) [#33748](https://github.com/nodejs/node/pull/33748)
+* [[`0dd67d992e`](https://github.com/nodejs/node/commit/0dd67d992e)] - **src**: reduce scope of code cache mutex (Anna Henningsen) [#33980](https://github.com/nodejs/node/pull/33980)
+* [[`cd0ae4007f`](https://github.com/nodejs/node/commit/cd0ae4007f)] - **src**: improve indention for upd\_wrap.cc (gengjiawen) [#33976](https://github.com/nodejs/node/pull/33976)
+* [[`6014e4e0b8`](https://github.com/nodejs/node/commit/6014e4e0b8)] - **src**: remove unnecessary ToLocalChecked call (Daniel Bevenius) [#33902](https://github.com/nodejs/node/pull/33902)
+* [[`4715a41c1c`](https://github.com/nodejs/node/commit/4715a41c1c)] - **src**: simplify alignment-handling code (Anna Henningsen) [#33884](https://github.com/nodejs/node/pull/33884)
+* [[`33cff40bb7`](https://github.com/nodejs/node/commit/33cff40bb7)] - **src**: remove ref to tools/generate\_code\_cache.js (Daniel Bevenius) [#33825](https://github.com/nodejs/node/pull/33825)
+* [[`dfa0ee13ee`](https://github.com/nodejs/node/commit/dfa0ee13ee)] - **src**: remove unused vector include in string\_bytes (Daniel Bevenius) [#33824](https://github.com/nodejs/node/pull/33824)
+* [[`fb2b0a094b`](https://github.com/nodejs/node/commit/fb2b0a094b)] - **src**: avoid unnecessary ToLocalChecked calls (Daniel Bevenius) [#33824](https://github.com/nodejs/node/pull/33824)
+* [[`07c21d0d27`](https://github.com/nodejs/node/commit/07c21d0d27)] - **src**: reduce FileHandle size by reordering fields (Anna Henningsen) [#33784](https://github.com/nodejs/node/pull/33784)
+* [[`83aaad7ec3`](https://github.com/nodejs/node/commit/83aaad7ec3)] - **src**: do not track BaseObjects via cleanup hooks (Anna Henningsen) [#33809](https://github.com/nodejs/node/pull/33809)
+* [[`f8dddd3416`](https://github.com/nodejs/node/commit/f8dddd3416)] - **src**: handle missing TracingController everywhere (Anna Henningsen) [#33815](https://github.com/nodejs/node/pull/33815)
+* [[`3b71aa8029`](https://github.com/nodejs/node/commit/3b71aa8029)] - **src**: remove unused `ERR\_TRANSFERRING\_EXTERNALIZED\_SHAREDARRAYBUFFER` (Anna Henningsen) [#33810](https://github.com/nodejs/node/pull/33810)
+* [[`1f996b7372`](https://github.com/nodejs/node/commit/1f996b7372)] - **src**: simplify Reindent function in json\_utils.cc (sapics) [#33722](https://github.com/nodejs/node/pull/33722)
+* [[`cdcd76810e`](https://github.com/nodejs/node/commit/cdcd76810e)] - **src**: add "missing" bash completion options (Daniel Bevenius) [#33744](https://github.com/nodejs/node/pull/33744)
+* [[`cc8d70531d`](https://github.com/nodejs/node/commit/cc8d70531d)] - **src**: use Check() instead of FromJust in environment (Daniel Bevenius) [#33706](https://github.com/nodejs/node/pull/33706)
+* [[`858c6b9dfd`](https://github.com/nodejs/node/commit/858c6b9dfd)] - **src**: use ToLocal in SafeGetenv (Daniel Bevenius) [#33695](https://github.com/nodejs/node/pull/33695)
+* [[`c2f49319b7`](https://github.com/nodejs/node/commit/c2f49319b7)] - **src**: remove unnecessary ToLocalChecked call (Daniel Bevenius) [#33683](https://github.com/nodejs/node/pull/33683)
+* [[`21f1e64737`](https://github.com/nodejs/node/commit/21f1e64737)] - **src**: simplify format in node\_file.cc (himself65) [#33660](https://github.com/nodejs/node/pull/33660)
+* [[`c3728c6235`](https://github.com/nodejs/node/commit/c3728c6235)] - **src**: simplify MaybeStackBuffer::capacity() (Ben Noordhuis) [#33602](https://github.com/nodejs/node/pull/33602)
+* [[`7725ff392c`](https://github.com/nodejs/node/commit/7725ff392c)] - **src**: remove superfluous inline keywords (James M Snell) [#33291](https://github.com/nodejs/node/pull/33291)
+* [[`27e9cb7e85`](https://github.com/nodejs/node/commit/27e9cb7e85)] - **src**: turn AllocatedBuffer into thin wrapper around v8::BackingStore (James M Snell) [#33291](https://github.com/nodejs/node/pull/33291)
+* [[`d8f040e33d`](https://github.com/nodejs/node/commit/d8f040e33d)] - **src**: extract AllocatedBuffer from env.h (James M Snell) [#33291](https://github.com/nodejs/node/pull/33291)
+* [[`a8824ae0a5`](https://github.com/nodejs/node/commit/a8824ae0a5)] - **src**: avoid OOB read in URL parser (Anna Henningsen) [#33640](https://github.com/nodejs/node/pull/33640)
+* [[`6ef2efe33a`](https://github.com/nodejs/node/commit/6ef2efe33a)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty worker (Daniel Bevenius) [#33599](https://github.com/nodejs/node/pull/33599)
+* [[`522fbbc8d9`](https://github.com/nodejs/node/commit/522fbbc8d9)] - **src**: don't use semicolon outside function (Shelley Vohr) [#33592](https://github.com/nodejs/node/pull/33592)
+* [[`ad970996cf`](https://github.com/nodejs/node/commit/ad970996cf)] - **src**: remove unused using declarations (Daniel Bevenius) [#33268](https://github.com/nodejs/node/pull/33268)
+* [[`20d54f6908`](https://github.com/nodejs/node/commit/20d54f6908)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty (Daniel Bevenius) [#33554](https://github.com/nodejs/node/pull/33554)
+* [[`5438611984`](https://github.com/nodejs/node/commit/5438611984)] - **src**: use NewFromUtf8Literal in GetLinkedBinding (Daniel Bevenius) [#33552](https://github.com/nodejs/node/pull/33552)
+* [[`a5e860cd29`](https://github.com/nodejs/node/commit/a5e860cd29)] - **src**: use const in constant args.Length() (himself65) [#33555](https://github.com/nodejs/node/pull/33555)
+* [[`7e351f15cb`](https://github.com/nodejs/node/commit/7e351f15cb)] - **src**: use MaybeLocal::FromMaybe to return exception (Daniel Bevenius) [#33514](https://github.com/nodejs/node/pull/33514)
+* [[`3f1c756f89`](https://github.com/nodejs/node/commit/3f1c756f89)] - ***Revert*** "**src**: fix missing extra ca in tls.rootCertificates" (Eric Bickle) [#33313](https://github.com/nodejs/node/pull/33313)
+* [[`d1e1dbf188`](https://github.com/nodejs/node/commit/d1e1dbf188)] - **src**: remove BeforeExit callback list (Ben Noordhuis) [#33386](https://github.com/nodejs/node/pull/33386)
+* [[`ee45b78b7f`](https://github.com/nodejs/node/commit/ee45b78b7f)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty (Daniel Bevenius) [#33457](https://github.com/nodejs/node/pull/33457)
+* [[`9018e92b13`](https://github.com/nodejs/node/commit/9018e92b13)] - **src**: remove unused headers in src/util.h (Juan José Arboleda) [#33070](https://github.com/nodejs/node/pull/33070)
+* [[`7d1d00f97a`](https://github.com/nodejs/node/commit/7d1d00f97a)] - **src**: use enum for refed flag on native immediates (Anna Henningsen) [#33444](https://github.com/nodejs/node/pull/33444)
+* [[`e8cc269ee0`](https://github.com/nodejs/node/commit/e8cc269ee0)] - **src**: use symbol to store `AsyncWrap` resource (Anna Henningsen) [#31745](https://github.com/nodejs/node/pull/31745)
+* [[`ab2454dec5`](https://github.com/nodejs/node/commit/ab2454dec5)] - **src**: prefer make\_unique (Michael Dawson) [#33378](https://github.com/nodejs/node/pull/33378)
+* [[`a942f7280a`](https://github.com/nodejs/node/commit/a942f7280a)] - **src**: remove unnecessary else in base\_object-inl.h (Daniel Bevenius) [#33413](https://github.com/nodejs/node/pull/33413)
+* [[`f6227c0577`](https://github.com/nodejs/node/commit/f6227c0577)] - **src**: reduce duplication in RegisterHandleCleanups (Daniel Bevenius) [#33421](https://github.com/nodejs/node/pull/33421)
+* [[`f24292e106`](https://github.com/nodejs/node/commit/f24292e106)] - **src**: remove unused IsolateSettings variable (Daniel Bevenius) [#33417](https://github.com/nodejs/node/pull/33417)
+* [[`308be6ca0c`](https://github.com/nodejs/node/commit/308be6ca0c)] - **src**: remove unused misc variable (Daniel Bevenius) [#33417](https://github.com/nodejs/node/pull/33417)
+* [[`7fd0519a91`](https://github.com/nodejs/node/commit/7fd0519a91)] - **src**: add promise\_resolve to SetupHooks comment (Daniel Bevenius) [#33365](https://github.com/nodejs/node/pull/33365)
+* [[`26a3cf058d`](https://github.com/nodejs/node/commit/26a3cf058d)] - **src,build**: add --openssl-default-cipher-list (Daniel Bevenius) [#33708](https://github.com/nodejs/node/pull/33708)
+* [[`b0fa611e68`](https://github.com/nodejs/node/commit/b0fa611e68)] - **stream**: fix the spellings (antsmartian) [#33635](https://github.com/nodejs/node/pull/33635)
+* [[`1db0d51ab2`](https://github.com/nodejs/node/commit/1db0d51ab2)] - **stream**: forward writableObjectMode (Robert Nagy) [#33390](https://github.com/nodejs/node/pull/33390)
+* [[`2c568c80f3`](https://github.com/nodejs/node/commit/2c568c80f3)] - **test**: add non-ASCII character embedding test (Anna Henningsen) [#33972](https://github.com/nodejs/node/pull/33972)
+* [[`d4a2ae094e`](https://github.com/nodejs/node/commit/d4a2ae094e)] - **test**: add test for Http2ServerResponse#\[writableCorked,cork,uncork\] (Pranshu Srivastava) [#33956](https://github.com/nodejs/node/pull/33956)
+* [[`4a61013fb2`](https://github.com/nodejs/node/commit/4a61013fb2)] - **test**: print arguments passed to mustNotCall function (Denys Otrishko) [#33951](https://github.com/nodejs/node/pull/33951)
+* [[`1b55d90975`](https://github.com/nodejs/node/commit/1b55d90975)] - **test**: AsyncLocalStorage works with thenables (Gerhard Stoebich) [#34008](https://github.com/nodejs/node/pull/34008)
+* [[`195980d667`](https://github.com/nodejs/node/commit/195980d667)] - **test**: account for non-node basename (Shelley Vohr) [#33952](https://github.com/nodejs/node/pull/33952)
+* [[`90223f0a88`](https://github.com/nodejs/node/commit/90223f0a88)] - **test**: fix typo in common/index.js (gengjiawen) [#33976](https://github.com/nodejs/node/pull/33976)
+* [[`d427d7f905`](https://github.com/nodejs/node/commit/d427d7f905)] - **test**: add common/udppair utility (James M Snell) [#33380](https://github.com/nodejs/node/pull/33380)
+* [[`b8fdde400a`](https://github.com/nodejs/node/commit/b8fdde400a)] - ***Revert*** "**test**: stop testing --interpreted-frames-native-stack for s390x" (Michaël Zasso) [#33794](https://github.com/nodejs/node/pull/33794)
+* [[`e3a53329c2`](https://github.com/nodejs/node/commit/e3a53329c2)] - **test**: temporarily exclude test on arm (Michael Dawson) [#33814](https://github.com/nodejs/node/pull/33814)
+* [[`b6e3616911`](https://github.com/nodejs/node/commit/b6e3616911)] - **test**: fix invalid regular expressions in case test-trace-exit (legendecas) [#33769](https://github.com/nodejs/node/pull/33769)
+* [[`c3ac47c03d`](https://github.com/nodejs/node/commit/c3ac47c03d)] - **test**: changed function to arrow function (Sagar Jadhav) [#33711](https://github.com/nodejs/node/pull/33711)
+* [[`15eb5a3da4`](https://github.com/nodejs/node/commit/15eb5a3da4)] - **test**: uv\_tty\_init now returns EINVAL on IBM i (Xu Meng) [#33629](https://github.com/nodejs/node/pull/33629)
+* [[`da5e970a8c`](https://github.com/nodejs/node/commit/da5e970a8c)] - **test**: make flaky test stricter (Robert Nagy) [#33539](https://github.com/nodejs/node/pull/33539)
+* [[`47396a42cf`](https://github.com/nodejs/node/commit/47396a42cf)] - **test**: fix flaky test-trace-atomics-wait (Anna Henningsen) [#33428](https://github.com/nodejs/node/pull/33428)
+* [[`eb877a4c49`](https://github.com/nodejs/node/commit/eb877a4c49)] - **test**: mark test-dgram-multicast-ssmv6-multi-process flaky (AshCripps) [#33498](https://github.com/nodejs/node/pull/33498)
+* [[`5dca04ee8e`](https://github.com/nodejs/node/commit/5dca04ee8e)] - **tools**: remove superfluous regex in tools/doc/json.js (Rich Trott) [#33998](https://github.com/nodejs/node/pull/33998)
+* [[`1791d5727c`](https://github.com/nodejs/node/commit/1791d5727c)] - **tools**: update remark-preset-lint-node@1.15.1 to 1.16.0 (Rich Trott) [#33852](https://github.com/nodejs/node/pull/33852)
+* [[`01d8b91942`](https://github.com/nodejs/node/commit/01d8b91942)] - **tools**: prevent js2c from running if nothing changed (Daniel Bevenius) [#33844](https://github.com/nodejs/node/pull/33844)
+* [[`e837f00b4f`](https://github.com/nodejs/node/commit/e837f00b4f)] - **tools**: remove unused vector include in mkdcodecache (Daniel Bevenius) [#33828](https://github.com/nodejs/node/pull/33828)
+* [[`800dbb6bdd`](https://github.com/nodejs/node/commit/800dbb6bdd)] - **tools**: update ESLint to 7.2.0 (Colin Ihrig) [#33776](https://github.com/nodejs/node/pull/33776)
+* [[`a14e38a6c0`](https://github.com/nodejs/node/commit/a14e38a6c0)] - **tools**: remove unused using declarations code\_cache (Daniel Bevenius) [#33697](https://github.com/nodejs/node/pull/33697)
+* [[`9fb1eb09d9`](https://github.com/nodejs/node/commit/9fb1eb09d9)] - **tools**: update remark-preset-lint-node from 1.15.0 to 1.15.1 (Rich Trott) [#33727](https://github.com/nodejs/node/pull/33727)
+* [[`a331a00eac`](https://github.com/nodejs/node/commit/a331a00eac)] - **tools**: fix check-imports.py to match on word boundaries (Richard Lau) [#33268](https://github.com/nodejs/node/pull/33268)
+* [[`9325ed9e1c`](https://github.com/nodejs/node/commit/9325ed9e1c)] - **tools**: update ESLint to 7.1.0 (Colin Ihrig) [#33526](https://github.com/nodejs/node/pull/33526)
+* [[`6dab63f36d`](https://github.com/nodejs/node/commit/6dab63f36d)] - **tools**: add docserve target (Antoine du HAMEL) [#33221](https://github.com/nodejs/node/pull/33221)
+* [[`2384044c95`](https://github.com/nodejs/node/commit/2384044c95)] - **tools,gyp**: add support for MSVC cross-compilation (Richard Townsend) [#32867](https://github.com/nodejs/node/pull/32867)
+* [[`987c927225`](https://github.com/nodejs/node/commit/987c927225)] - **util**: fix width detection for DEL without ICU (Ruben Bridgewater) [#33650](https://github.com/nodejs/node/pull/33650)
+* [[`91d0d53b59`](https://github.com/nodejs/node/commit/91d0d53b59)] - **util**: support Combining Diacritical Marks for Symbols (Ruben Bridgewater) [#33650](https://github.com/nodejs/node/pull/33650)
+* [[`e3d53f999d`](https://github.com/nodejs/node/commit/e3d53f999d)] - **util**: gracefully handle unknown colors (Ruben Bridgewater) [#33797](https://github.com/nodejs/node/pull/33797)
+* [[`a90c9aa858`](https://github.com/nodejs/node/commit/a90c9aa858)] - **util**: fix inspection of class instance prototypes (Ruben Bridgewater) [#33449](https://github.com/nodejs/node/pull/33449)
+* [[`2380d90f0a`](https://github.com/nodejs/node/commit/2380d90f0a)] - **util**: mark classes while inspecting them (Ruben Bridgewater) [#32332](https://github.com/nodejs/node/pull/32332)
+* [[`879c9322ce`](https://github.com/nodejs/node/commit/879c9322ce)] - **vm**: allow proxy callbacks to throw (Gus Caplan) [#33808](https://github.com/nodejs/node/pull/33808)
+* [[`af14c1f776`](https://github.com/nodejs/node/commit/af14c1f776)] - **wasi**: allow WASI stdio to be configured (Colin Ihrig) [#33544](https://github.com/nodejs/node/pull/33544)
+* [[`5eecea375f`](https://github.com/nodejs/node/commit/5eecea375f)] - **wasi**: simplify WASI memory management (Colin Ihrig) [#33525](https://github.com/nodejs/node/pull/33525)
+* [[`f98e888fdd`](https://github.com/nodejs/node/commit/f98e888fdd)] - **wasi**: refactor and enable poll\_oneoff() test (Colin Ihrig) [#33521](https://github.com/nodejs/node/pull/33521)
+* [[`6b20e8442f`](https://github.com/nodejs/node/commit/6b20e8442f)] - **wasi**: relax WebAssembly.Instance type check (Ben Noordhuis) [#33431](https://github.com/nodejs/node/pull/33431)
+* [[`d15383253a`](https://github.com/nodejs/node/commit/d15383253a)] - **wasi,worker**: handle termination exception (Ben Noordhuis) [#33386](https://github.com/nodejs/node/pull/33386)
+* [[`3f971d89a9`](https://github.com/nodejs/node/commit/3f971d89a9)] - **win,fs**: use namespaced path in absolute symlinks (Bartosz Sosnowski) [#33351](https://github.com/nodejs/node/pull/33351)
+* [[`3520a134af`](https://github.com/nodejs/node/commit/3520a134af)] - **win,msi**: add arm64 config for windows msi (Dennis Ameling) [#33689](https://github.com/nodejs/node/pull/33689)
+* [[`b79495905f`](https://github.com/nodejs/node/commit/b79495905f)] - **worker**: fix variable referencing in template string (Harshitha KP) [#33467](https://github.com/nodejs/node/pull/33467)
+* [[`9c3008005d`](https://github.com/nodejs/node/commit/9c3008005d)] - **worker**: perform initial port.unref() before preload modules (Anna Henningsen) [#33455](https://github.com/nodejs/node/pull/33455)
+* [[`64cae13799`](https://github.com/nodejs/node/commit/64cae13799)] - **worker**: use \_writev in internal communication (Anna Henningsen) [#33454](https://github.com/nodejs/node/pull/33454)
+* [[`7817b875a7`](https://github.com/nodejs/node/commit/7817b875a7)] - **worker**: fix race condition in node\_messaging.cc (Anna Henningsen) [#33429](https://github.com/nodejs/node/pull/33429)
+
+<a id="14.4.0"></a>
+## 2020-06-02, Version 14.4.0 (Current), @targos
+
+### Notable changes
+
+This is a security release.
+
+Vulnerabilities fixed:
+* **CVE-2020-8172**: TLS session reuse can lead to host certificate verification bypass (High).
+* **CVE-2020-11080**: HTTP/2 Large Settings Frame DoS (Low).
+* **CVE-2020-8174**: `napi_get_value_string_*()` allows various kinds of memory corruption (High).
+
+### Commits
+
+* [[`07a4d5061f`](https://github.com/nodejs/node/commit/07a4d5061f)] - **crypto**: update root certificates (AshCripps) [#33682](https://github.com/nodejs/node/pull/33682)
+* [[`0a7bf50fd4`](https://github.com/nodejs/node/commit/0a7bf50fd4)] - **(SEMVER-MINOR)** **deps**: update nghttp2 to 1.41.0 (James M Snell) [nodejs-private/node-private#204](https://github.com/nodejs-private/node-private/pull/204)
+* [[`55e4c72af8`](https://github.com/nodejs/node/commit/55e4c72af8)] - **(SEMVER-MINOR)** **http2**: implement support for max settings entries (James M Snell) [nodejs-private/node-private#204](https://github.com/nodejs-private/node-private/pull/204)
+* [[`290720d16a`](https://github.com/nodejs/node/commit/290720d16a)] - **napi**: fix memory corruption vulnerability (Tobias Nießen) [nodejs-private/node-private#195](https://github.com/nodejs-private/node-private/pull/195)
+* [[`94571c1001`](https://github.com/nodejs/node/commit/94571c1001)] - **tls**: emit `session` after verifying certificate (Fedor Indutny) [nodejs-private/node-private#200](https://github.com/nodejs-private/node-private/pull/200)
+* [[`1658cf9ee6`](https://github.com/nodejs/node/commit/1658cf9ee6)] - **tools**: update certdata.txt (AshCripps) [#33682](https://github.com/nodejs/node/pull/33682)
+
+<a id="14.3.0"></a>
+## 2020-05-19, Version 14.3.0 (Current), @codebytere
+
+### Notable Changes
+
+#### REPL previews improvements with autocompletion
+
+The output preview is changed to generate previews for autocompleted input
+instead of the actual input.
+
+![image](https://user-images.githubusercontent.com/8822573/82209841-4259e180-990e-11ea-93d7-0ea4b3bfc76f.png)
+
+Pressing `<enter>` during a preview is now going to evaluate the whole string
+including the autocompleted part. Pressing `<escape>` cancels that behavior.
+
+#### Support for Top-Level Await
+
+It's now possible to use the await keyword outside of async functions, with the
+`--experimental-top-level-await` flag.
+
+#### Other Notable Changes
+
+* [[`7aa581f4ff`](https://github.com/nodejs/node/commit/7aa581f4ff)] - **(SEMVER-MINOR)** **repl**: deprecate repl.\_builtinLibs (Ruben Bridgewater) [#33294](https://github.com/nodejs/node/pull/33294)
+* [[`db7bb941a3`](https://github.com/nodejs/node/commit/db7bb941a3)] - **(SEMVER-MINOR)** **repl**: deprecate repl.inputStream and repl.outputStream (Ruben Bridgewater) [#33294](https://github.com/nodejs/node/pull/33294)
+* [[`2dc5db8c07`](https://github.com/nodejs/node/commit/2dc5db8c07)] - **(SEMVER-MINOR)** **cli**: add `--trace-atomics-wait` flag (Anna Henningsen) [#33292](https://github.com/nodejs/node/pull/33292)
+* [[`6257cf256e`](https://github.com/nodejs/node/commit/6257cf256e)] - **(SEMVER-MINOR)** **repl**: improve repl autocompletion for require calls (Ruben Bridgewater) [#33282](https://github.com/nodejs/node/pull/33282)
+* [[`d33dcf1d5f`](https://github.com/nodejs/node/commit/d33dcf1d5f)] - **(SEMVER-MINOR)** **repl**: show reference errors during preview (Ruben Bridgewater) [#33282](https://github.com/nodejs/node/pull/33282)
+* [[`1dcf66cf87`](https://github.com/nodejs/node/commit/1dcf66cf87)] - **(SEMVER-MINOR)** **fs**: add .ref() and .unref() methods to watcher classes (rickyes) [#33134](https://github.com/nodejs/node/pull/33134)
+* [[`f33e86649e`](https://github.com/nodejs/node/commit/f33e86649e)] - **(SEMVER-MINOR)** **http**: expose http.validate-header-name/value (osher) [#33119](https://github.com/nodejs/node/pull/33119)
+* [[`b06165584e`](https://github.com/nodejs/node/commit/b06165584e)] - **(SEMVER-MINOR)** **async_hooks**: move PromiseHook handler to JS (Stephen Belanger) [#32891](https://github.com/nodejs/node/pull/32891)
+
+### Commits
+
+* [[`dd4789b8ee`](https://github.com/nodejs/node/commit/dd4789b8ee)] - **async_hooks**: clear async\_id\_stack for terminations in more places (Anna Henningsen) [#33347](https://github.com/nodejs/node/pull/33347)
+* [[`b06165584e`](https://github.com/nodejs/node/commit/b06165584e)] - **(SEMVER-MINOR)** **async_hooks**: move PromiseHook handler to JS (Stephen Belanger) [#32891](https://github.com/nodejs/node/pull/32891)
+* [[`cae2051b83`](https://github.com/nodejs/node/commit/cae2051b83)] - **buffer**: improve copy() performance (Nikolai Vavilov) [#33214](https://github.com/nodejs/node/pull/33214)
+* [[`24faa37a09`](https://github.com/nodejs/node/commit/24faa37a09)] - **buffer,n-api**: release external buffers from BackingStore callback (Anna Henningsen) [#33321](https://github.com/nodejs/node/pull/33321)
+* [[`34e7400fc1`](https://github.com/nodejs/node/commit/34e7400fc1)] - **build**: enable `--error-on-warn` for POSIX workflows (Richard Lau) [#33357](https://github.com/nodejs/node/pull/33357)
+* [[`7d4db35f84`](https://github.com/nodejs/node/commit/7d4db35f84)] - **build**: fix `--error-on-warn` for macOS (Richard Lau) [#33357](https://github.com/nodejs/node/pull/33357)
+* [[`2dc5db8c07`](https://github.com/nodejs/node/commit/2dc5db8c07)] - **(SEMVER-MINOR)** **cli**: add `--trace-atomics-wait` flag (Anna Henningsen) [#33292](https://github.com/nodejs/node/pull/33292)
+* [[`331f0b3420`](https://github.com/nodejs/node/commit/331f0b3420)] - **deps**: update to ICU 67.1 (Michaël Zasso) [#33324](https://github.com/nodejs/node/pull/33324)
+* [[`ba66b21c37`](https://github.com/nodejs/node/commit/ba66b21c37)] - **deps**: upgrade npm to 6.14.5 (Ruy Adorno) [#33239](https://github.com/nodejs/node/pull/33239)
+* [[`cc279490ce`](https://github.com/nodejs/node/commit/cc279490ce)] - **doc**: prepare 14.x changelog for remark update (Rich Trott) [#33412](https://github.com/nodejs/node/pull/33412)
+* [[`7f9ccd6d89`](https://github.com/nodejs/node/commit/7f9ccd6d89)] - **doc**: fix extension in esm example (Gus Caplan) [#33408](https://github.com/nodejs/node/pull/33408)
+* [[`8f91338f6e`](https://github.com/nodejs/node/commit/8f91338f6e)] - **doc**: fix stream example (Anna Henningsen) [#33426](https://github.com/nodejs/node/pull/33426)
+* [[`182aaf5622`](https://github.com/nodejs/node/commit/182aaf5622)] - **doc**: enhance guides by fixing and making grammar more consistent (Chris Holland) [#33152](https://github.com/nodejs/node/pull/33152)
+* [[`0ffa0402a5`](https://github.com/nodejs/node/commit/0ffa0402a5)] - **doc**: add examples for implementing ESM (unknown) [#33168](https://github.com/nodejs/node/pull/33168)
+* [[`b41affb9e2`](https://github.com/nodejs/node/commit/b41affb9e2)] - **doc**: add note about clientError writable handling (Paolo Insogna) [#33308](https://github.com/nodejs/node/pull/33308)
+* [[`4f0cd648bb`](https://github.com/nodejs/node/commit/4f0cd648bb)] - **doc**: fix typo in n-api.md (Daniel Bevenius) [#33319](https://github.com/nodejs/node/pull/33319)
+* [[`0cbee57109`](https://github.com/nodejs/node/commit/0cbee57109)] - **doc**: add warning for socket.connect reuse (Robert Nagy) [#33204](https://github.com/nodejs/node/pull/33204)
+* [[`a9e4fdbd1b`](https://github.com/nodejs/node/commit/a9e4fdbd1b)] - **doc**: correct description of `decipher.setAuthTag` in crypto.md (Jonathan Buhacoff)
+* [[`84974d3f2c`](https://github.com/nodejs/node/commit/84974d3f2c)] - **doc**: mention python3-distutils dependency in BUILDING.md (osher) [#33174](https://github.com/nodejs/node/pull/33174)
+* [[`b5dcfbf634`](https://github.com/nodejs/node/commit/b5dcfbf634)] - **doc**: removed unnecessary util imports from vm examples (Karol Walasek) [#33179](https://github.com/nodejs/node/pull/33179)
+* [[`e20fe535a5`](https://github.com/nodejs/node/commit/e20fe535a5)] - **doc**: update Buffer(size) documentation (Nikolai Vavilov) [#33198](https://github.com/nodejs/node/pull/33198)
+* [[`5b42d812cc`](https://github.com/nodejs/node/commit/5b42d812cc)] - **doc**: add Uint8Array to `end` and `write` (Pranshu Srivastava) [#33217](https://github.com/nodejs/node/pull/33217)
+* [[`c6a8cd0fa1`](https://github.com/nodejs/node/commit/c6a8cd0fa1)] - **doc**: fix md issue in src/README.md (Juan José Arboleda) [#33224](https://github.com/nodejs/node/pull/33224)
+* [[`2c49dd3d01`](https://github.com/nodejs/node/commit/2c49dd3d01)] - **doc**: specify unit of time passed to `fs.utimes` (Simen Bekkhus) [#33230](https://github.com/nodejs/node/pull/33230)
+* [[`6ffec50494`](https://github.com/nodejs/node/commit/6ffec50494)] - **doc**: add troubleshooting guide for AsyncLocalStorage (Andrey Pechkurov) [#33248](https://github.com/nodejs/node/pull/33248)
+* [[`dab5c38f98`](https://github.com/nodejs/node/commit/dab5c38f98)] - **doc**: remove AsyncWrap mentions from async\_hooks.md (Andrey Pechkurov) [#33249](https://github.com/nodejs/node/pull/33249)
+* [[`05729430bf`](https://github.com/nodejs/node/commit/05729430bf)] - **doc**: add warnings about transferring Buffers and ArrayBuffer (James M Snell) [#33252](https://github.com/nodejs/node/pull/33252)
+* [[`cf88ed8664`](https://github.com/nodejs/node/commit/cf88ed8664)] - **doc**: update napi\_async\_init documentation (Michael Dawson) [#33181](https://github.com/nodejs/node/pull/33181)
+* [[`25443fa7f2`](https://github.com/nodejs/node/commit/25443fa7f2)] - **doc**: doc and test URLSearchParams discrepancy (James M Snell) [#33236](https://github.com/nodejs/node/pull/33236)
+* [[`07372e9d5b`](https://github.com/nodejs/node/commit/07372e9d5b)] - **doc**: explicitly doc package.exports is breaking (Myles Borins) [#33074](https://github.com/nodejs/node/pull/33074)
+* [[`c5a38fe6d7`](https://github.com/nodejs/node/commit/c5a38fe6d7)] - **doc**: fix style and grammer in buffer.md (Nikolai Vavilov) [#33194](https://github.com/nodejs/node/pull/33194)
+* [[`e53de96a89`](https://github.com/nodejs/node/commit/e53de96a89)] - **esm**: improve commonjs hint on module not found (Antoine du Hamel) [#33220](https://github.com/nodejs/node/pull/33220)
+* [[`c7c420ec87`](https://github.com/nodejs/node/commit/c7c420ec87)] - **fs**: forbid concurrent operations on Dir handle (Anna Henningsen) [#33274](https://github.com/nodejs/node/pull/33274)
+* [[`12391c7a20`](https://github.com/nodejs/node/commit/12391c7a20)] - **fs**: clean up Dir.read() uv\_fs\_t data before calling into JS (Anna Henningsen) [#33274](https://github.com/nodejs/node/pull/33274)
+* [[`1dcf66cf87`](https://github.com/nodejs/node/commit/1dcf66cf87)] - **(SEMVER-MINOR)** **fs**: add .ref() and .unref() methods to watcher classes (rickyes) [#33134](https://github.com/nodejs/node/pull/33134)
+* [[`f33e86649e`](https://github.com/nodejs/node/commit/f33e86649e)] - **(SEMVER-MINOR)** **http**: expose http.validate-header-name/value (osher) [#33119](https://github.com/nodejs/node/pull/33119)
+* [[`cc5c8e039d`](https://github.com/nodejs/node/commit/cc5c8e039d)] - **http**: don't destroy completed request (Robert Nagy) [#33120](https://github.com/nodejs/node/pull/33120)
+* [[`b634d4b000`](https://github.com/nodejs/node/commit/b634d4b000)] - **http**: set IncomingMessage.destroyed (Robert Nagy) [#33131](https://github.com/nodejs/node/pull/33131)
+* [[`cc02c73e53`](https://github.com/nodejs/node/commit/cc02c73e53)] - **http**: fixes memory retention issue with FreeList and HTTPParser (John Leidegren) [#33190](https://github.com/nodejs/node/pull/33190)
+* [[`41c5524432`](https://github.com/nodejs/node/commit/41c5524432)] - **http2**: add `bytesWritten` test for `Http2Stream` (Pranshu Srivastava) [#33162](https://github.com/nodejs/node/pull/33162)
+* [[`a133a88234`](https://github.com/nodejs/node/commit/a133a88234)] - **lib**: fix typo in timers insert function comment (Daniel Bevenius) [#33301](https://github.com/nodejs/node/pull/33301)
+* [[`94d0a088ec`](https://github.com/nodejs/node/commit/94d0a088ec)] - **lib**: refactored scheduling policy assignment (Yash Ladha) [#32663](https://github.com/nodejs/node/pull/32663)
+* [[`6bca487b8b`](https://github.com/nodejs/node/commit/6bca487b8b)] - **lib**: fix grammar in internal/bootstrap/loaders.js (szTheory) [#33211](https://github.com/nodejs/node/pull/33211)
+* [[`0a78925146`](https://github.com/nodejs/node/commit/0a78925146)] - **meta**: add issue template for API reference docs (Derek Lewis) [#32944](https://github.com/nodejs/node/pull/32944)
+* [[`35aae31968`](https://github.com/nodejs/node/commit/35aae31968)] - **module**: add specific error for dir import (Antoine du HAMEL) [#33220](https://github.com/nodejs/node/pull/33220)
+* [[`c2d2dfc09f`](https://github.com/nodejs/node/commit/c2d2dfc09f)] - **module**: do not check circular dependencies for exported proxies (Ruben Bridgewater) [#33338](https://github.com/nodejs/node/pull/33338)
+* [[`ad8680773e`](https://github.com/nodejs/node/commit/ad8680773e)] - **module**: better error for named exports from cjs (Myles Borins) [#33256](https://github.com/nodejs/node/pull/33256)
+* [[`27b814c79b`](https://github.com/nodejs/node/commit/27b814c79b)] - **module**: lazy load 'getOptionValue' in initializeLoader (himself65) [#33212](https://github.com/nodejs/node/pull/33212)
+* [[`4ae6130010`](https://github.com/nodejs/node/commit/4ae6130010)] - **n-api**: add uint32 test for -1 (Gabriel Schulhof)
+* [[`398bdf40e5`](https://github.com/nodejs/node/commit/398bdf40e5)] - **perf_hooks**: fix error message for invalid entryTypes (Michaël Zasso) [#33285](https://github.com/nodejs/node/pull/33285)
+* [[`7aa581f4ff`](https://github.com/nodejs/node/commit/7aa581f4ff)] - **(SEMVER-MINOR)** **repl**: deprecate repl.\_builtinLibs (Ruben Bridgewater) [#33294](https://github.com/nodejs/node/pull/33294)
+* [[`ed83202307`](https://github.com/nodejs/node/commit/ed83202307)] - **repl**: remove obsolete completer variable (Ruben Bridgewater) [#33294](https://github.com/nodejs/node/pull/33294)
+* [[`db7bb941a3`](https://github.com/nodejs/node/commit/db7bb941a3)] - **(SEMVER-MINOR)** **repl**: deprecate repl.inputStream and repl.outputStream (Ruben Bridgewater) [#33294](https://github.com/nodejs/node/pull/33294)
+* [[`6257cf256e`](https://github.com/nodejs/node/commit/6257cf256e)] - **repl**: improve repl autocompletion for require calls (Ruben Bridgewater) [#33282](https://github.com/nodejs/node/pull/33282)
+* [[`69061dc73e`](https://github.com/nodejs/node/commit/69061dc73e)] - **repl**: replace hard coded core module list with actual list (Ruben Bridgewater) [#33282](https://github.com/nodejs/node/pull/33282)
+* [[`d33dcf1d5f`](https://github.com/nodejs/node/commit/d33dcf1d5f)] - **(SEMVER-MINOR)** **repl**: show reference errors during preview (Ruben Bridgewater) [#33282](https://github.com/nodejs/node/pull/33282)
+* [[`1a9771a50a`](https://github.com/nodejs/node/commit/1a9771a50a)] - **(SEMVER-MINOR)** **repl**: improve repl preview (Ruben Bridgewater) [#33282](https://github.com/nodejs/node/pull/33282)
+* [[`e4ad4642d7`](https://github.com/nodejs/node/commit/e4ad4642d7)] - **src**: add default: case to silence compiler warning (Anna Henningsen) [#33451](https://github.com/nodejs/node/pull/33451)
+* [[`099f18e89b`](https://github.com/nodejs/node/commit/099f18e89b)] - **src**: distinguish refed/unrefed threadsafe Immediates (Anna Henningsen) [#33320](https://github.com/nodejs/node/pull/33320)
+* [[`5e5aa0bc6c`](https://github.com/nodejs/node/commit/5e5aa0bc6c)] - **src**: add #include \<string\> in json\_utils.h (Cheng Zhao) [#33332](https://github.com/nodejs/node/pull/33332)
+* [[`8ada953ef2`](https://github.com/nodejs/node/commit/8ada953ef2)] - **src**: replace to CHECK\_NOT\_NULL in node\_crypto (himself65) [#33383](https://github.com/nodejs/node/pull/33383)
+* [[`0257386cd4`](https://github.com/nodejs/node/commit/0257386cd4)] - **src**: remove deprecated FinalizationRegistry hooks (Gus Caplan) [#33373](https://github.com/nodejs/node/pull/33373)
+* [[`354ff4f21b`](https://github.com/nodejs/node/commit/354ff4f21b)] - **src**: small modification to NgHeader (James M Snell) [#33289](https://github.com/nodejs/node/pull/33289)
+* [[`fd89ef1478`](https://github.com/nodejs/node/commit/fd89ef1478)] - **src**: refactor Reallocate since it introduced in upstream v8 (Jiawen Geng) [#33402](https://github.com/nodejs/node/pull/33402)
+* [[`d292633ed4`](https://github.com/nodejs/node/commit/d292633ed4)] - **src**: add primordials to arguments comment (Daniel Bevenius) [#33318](https://github.com/nodejs/node/pull/33318)
+* [[`19996073ca`](https://github.com/nodejs/node/commit/19996073ca)] - **src**: remove unused using declarations in node.cc (Daniel Bevenius) [#33261](https://github.com/nodejs/node/pull/33261)
+* [[`c9c16c03c4`](https://github.com/nodejs/node/commit/c9c16c03c4)] - **src**: delete unused variables to resolve compile time print warning (rickyes) [#33358](https://github.com/nodejs/node/pull/33358)
+* [[`066ca98069`](https://github.com/nodejs/node/commit/066ca98069)] - **src**: use MaybeLocal.ToLocal instead of IsEmpty (Daniel Bevenius) [#33312](https://github.com/nodejs/node/pull/33312)
+* [[`f3129b290d`](https://github.com/nodejs/node/commit/f3129b290d)] - **src**: fix typo in comment in async\_wrap.cc (Daniel Bevenius) [#33350](https://github.com/nodejs/node/pull/33350)
+* [[`0d77eec4b0`](https://github.com/nodejs/node/commit/0d77eec4b0)] - **src**: add support for TLA (Gus Caplan) [#30370](https://github.com/nodejs/node/pull/30370)
+* [[`fd9c7c2118`](https://github.com/nodejs/node/commit/fd9c7c2118)] - **src**: fix compiler warning in async\_wrap.cc (Anna Henningsen) [#33322](https://github.com/nodejs/node/pull/33322)
+* [[`3de9dd9c8d`](https://github.com/nodejs/node/commit/3de9dd9c8d)] - **src**: remove unnecessary Isolate::GetCurrent() calls (Anna Henningsen) [#33298](https://github.com/nodejs/node/pull/33298)
+* [[`ef2503375b`](https://github.com/nodejs/node/commit/ef2503375b)] - **src**: fix invalid windowBits=8 gzip segfault (Ben Noordhuis) [#33045](https://github.com/nodejs/node/pull/33045)
+* [[`548cedd870`](https://github.com/nodejs/node/commit/548cedd870)] - **src**: split out callback queue implementation from Environment (Anna Henningsen) [#33272](https://github.com/nodejs/node/pull/33272)
+* [[`ed41494397`](https://github.com/nodejs/node/commit/ed41494397)] - **src**: clean up large pages code (Gabriel Schulhof) [#33255](https://github.com/nodejs/node/pull/33255)
+* [[`cf476984f6`](https://github.com/nodejs/node/commit/cf476984f6)] - **src**: use BaseObjectPtr in StreamReq::Dispose (James M Snell) [#33102](https://github.com/nodejs/node/pull/33102)
+* [[`5ff31921cc`](https://github.com/nodejs/node/commit/5ff31921cc)] - ***Revert*** "**src**: add test/abort build tasks" (Richard Lau) [#33196](https://github.com/nodejs/node/pull/33196)
+* [[`a56b600e93`](https://github.com/nodejs/node/commit/a56b600e93)] - ***Revert*** "**src**: add aliased-buffer-overflow abort test" (Richard Lau) [#33196](https://github.com/nodejs/node/pull/33196)
+* [[`a292630baf`](https://github.com/nodejs/node/commit/a292630baf)] - **src**: retrieve binding data from the context (Joyee Cheung) [#33139](https://github.com/nodejs/node/pull/33139)
+* [[`b2fb01a68d`](https://github.com/nodejs/node/commit/b2fb01a68d)] - **stream**: make from read one at a time (Robert Nagy) [#33201](https://github.com/nodejs/node/pull/33201)
+* [[`b93a723fe6`](https://github.com/nodejs/node/commit/b93a723fe6)] - **test**: regression tests for async\_hooks + Promise + Worker interaction (Anna Henningsen) [#33347](https://github.com/nodejs/node/pull/33347)
+* [[`d3e2fc81e8`](https://github.com/nodejs/node/commit/d3e2fc81e8)] - **test**: fix test-dns-idna2008 (Rich Trott) [#33367](https://github.com/nodejs/node/pull/33367)
+* [[`95842db17e`](https://github.com/nodejs/node/commit/95842db17e)] - **test**: refactor test/parallel/test-bootstrap-modules.js (Ruben Bridgewater) [#33282](https://github.com/nodejs/node/pull/33282)
+* [[`f31b262f50`](https://github.com/nodejs/node/commit/f31b262f50)] - **test**: refactor WPTRunner (Joyee Cheung) [#33297](https://github.com/nodejs/node/pull/33297)
+* [[`85cffb8e4c`](https://github.com/nodejs/node/commit/85cffb8e4c)] - **test**: update WPT interfaces and hr-time (Joyee Cheung) [#33297](https://github.com/nodejs/node/pull/33297)
+* [[`5b2cd440a1`](https://github.com/nodejs/node/commit/5b2cd440a1)] - **test**: fix test-net-throttle (Rich Trott) [#33329](https://github.com/nodejs/node/pull/33329)
+* [[`1d2c81fee9`](https://github.com/nodejs/node/commit/1d2c81fee9)] - **test**: add hr-time Web platform tests (Michaël Zasso) [#33287](https://github.com/nodejs/node/pull/33287)
+* [[`6f54c2bbb6`](https://github.com/nodejs/node/commit/6f54c2bbb6)] - **test**: rename test-lookupService-promises (rickyes) [#33100](https://github.com/nodejs/node/pull/33100)
+* [[`302408e515`](https://github.com/nodejs/node/commit/302408e515)] - **test**: skip some console tests on dumb terminal (Adam Majer) [#33165](https://github.com/nodejs/node/pull/33165)
+* [[`676ef952ab`](https://github.com/nodejs/node/commit/676ef952ab)] - **test**: add tests for options.fs in fs streams (Julian Duque) [#33185](https://github.com/nodejs/node/pull/33185)
+* [[`6d2aaaf6b4`](https://github.com/nodejs/node/commit/6d2aaaf6b4)] - **tls**: fix --tls-keylog option (Alba Mendez) [#33366](https://github.com/nodejs/node/pull/33366)
+* [[`eedc13174e`](https://github.com/nodejs/node/commit/eedc13174e)] - **tls**: reset secureConnecting on client socket (David Halls) [#33209](https://github.com/nodejs/node/pull/33209)
+* [[`453affebb0`](https://github.com/nodejs/node/commit/453affebb0)] - **tools**: update dependencies for markdown linting (Rich Trott) [#33412](https://github.com/nodejs/node/pull/33412)
+* [[`91193447fb`](https://github.com/nodejs/node/commit/91193447fb)] - **tools**: enable no-else-return lint rule (Luigi Pinca) [#32667](https://github.com/nodejs/node/pull/32667)
+* [[`e1e57a4223`](https://github.com/nodejs/node/commit/e1e57a4223)] - **tools**: update ESLint to 7.0.0 (Colin Ihrig) [#33316](https://github.com/nodejs/node/pull/33316)
+* [[`cf03fe5b67`](https://github.com/nodejs/node/commit/cf03fe5b67)] - **tools**: remove obsolete no-restricted-syntax eslint rules (Ruben Bridgewater) [#32161](https://github.com/nodejs/node/pull/32161)
+* [[`804982c1b6`](https://github.com/nodejs/node/commit/804982c1b6)] - **tools**: add eslint rule to only pass through 'test' to debuglog (Ruben Bridgewater) [#32161](https://github.com/nodejs/node/pull/32161)
+* [[`c2cf9782ab`](https://github.com/nodejs/node/commit/c2cf9782ab)] - ***Revert*** "**vm**: add importModuleDynamically option to compileFunction" (Matteo Collina) [#33364](https://github.com/nodejs/node/pull/33364)
+* [[`6a26eee3c5`](https://github.com/nodejs/node/commit/6a26eee3c5)] - **wasi**: fix poll\_oneoff memory interface (Colin Ihrig) [#33250](https://github.com/nodejs/node/pull/33250)
+* [[`4465d23c30`](https://github.com/nodejs/node/commit/4465d23c30)] - **wasi**: prevent syscalls before start (Tobias Nießen) [#33235](https://github.com/nodejs/node/pull/33235)
+* [[`9d1e577109`](https://github.com/nodejs/node/commit/9d1e577109)] - **worker**: fix crash when .unref() is called during exit (Anna Henningsen) [#33394](https://github.com/nodejs/node/pull/33394)
+* [[`b1a7fdac43`](https://github.com/nodejs/node/commit/b1a7fdac43)] - **worker**: call CancelTerminateExecution() before exiting Locker (Anna Henningsen) [#33347](https://github.com/nodejs/node/pull/33347)
+* [[`736ca65c2c`](https://github.com/nodejs/node/commit/736ca65c2c)] - **zlib**: reject windowBits=8 when mode=GZIP (Ben Noordhuis) [#33045](https://github.com/nodejs/node/pull/33045)
+
+<a id="14.2.0"></a>
+## 2020-05-05, Version 14.2.0 (Current), @targos
+
+### Notable Changes
+
+#### Track function calls with `assert.CallTracker` (experimental)
+
+`assert.CallTracker` is a new experimental API that allows to track and later
+verify the number of times a function was called. This works by creating a
+`CallTracker` object and using its `calls` method to create wrapper functions
+that will count each time they are called. Then the `verify` method can be used
+to assert that the expected number of calls happened:
+
+```js
+const assert = require('assert');
+
+const tracker = new assert.CallTracker();
+
+function func() {}
+// callsfunc() must be called exactly twice before tracker.verify().
+const callsfunc = tracker.calls(func, 2);
+callsfunc();
+callsfunc();
+
+function otherFunc() {}
+// The second parameter defaults to `1`.
+const callsotherFunc = tracker.calls(otherFunc);
+callsotherFunc();
+
+// Calls tracker.verify() and verifies if all tracker.calls() functions have
+// been called the right number of times.
+process.on('exit', () => {
+  tracker.verify();
+});
+```
+
+Additionally, `tracker.report()` will return an array which contains information
+about the errors, if there are any:
+
+<!-- eslint-disable max-len -->
+```js
+const assert = require('assert');
+
+const tracker = new assert.CallTracker();
+
+function func() {}
+const callsfunc = tracker.calls(func);
+
+console.log(tracker.report());
+/*
+[
+  {
+    message: 'Expected the func function to be executed 1 time(s) but was executed 0 time(s).',
+    actual: 0,
+    expected: 1,
+    operator: 'func',
+    stack: Error
+        ...
+  }
+]
+*/
+```
+
+Contributed by ConorDavenport - [#31982](https://github.com/nodejs/node/pull/31982).
+
+#### Console `groupIndentation` option
+
+The Console constructor (`require('console').Console`) now supports different group indentations.
+
+This is useful in case you want different grouping width than 2 spaces.
+
+```js
+const { Console } = require('console');
+const customConsole = new Console({
+  stdout: process.stdout,
+  stderr: process.stderr,
+  groupIndentation: 10
+});
+
+customConsole.log('foo');
+// 'foo'
+customConsole.group();
+customConsole.log('foo');
+//           'foo'
+```
+
+Contributed by rickyes - [#32964](https://github.com/nodejs/node/pull/32964).
+
+### Commits
+
+#### Semver-minor commits
+
+* [[`c87ed21fdf`](https://github.com/nodejs/node/commit/c87ed21fdf)] - **(SEMVER-MINOR)** **assert**: port common.mustCall() to assert (ConorDavenport) [#31982](https://github.com/nodejs/node/pull/31982)
+* [[`c49e3ea20c`](https://github.com/nodejs/node/commit/c49e3ea20c)] - **(SEMVER-MINOR)** **console**: support console constructor groupIndentation option (rickyes) [#32964](https://github.com/nodejs/node/pull/32964)
+* [[`bc9e413dae`](https://github.com/nodejs/node/commit/bc9e413dae)] - **(SEMVER-MINOR)** **worker**: add stack size resource limit option (Anna Henningsen) [#33085](https://github.com/nodejs/node/pull/33085)
+
+#### Semver-patch commits
+
+* [[`f62d92b900`](https://github.com/nodejs/node/commit/f62d92b900)] - **build**: add --error-on-warn configure flag (Daniel Bevenius) [#32685](https://github.com/nodejs/node/pull/32685)
+* [[`db293c47dd`](https://github.com/nodejs/node/commit/db293c47dd)] - **cluster**: fix error on worker disconnect/destroy (Santiago Gimeno) [#32793](https://github.com/nodejs/node/pull/32793)
+* [[`83e165bf88`](https://github.com/nodejs/node/commit/83e165bf88)] - **crypto**: check DiffieHellman p and g params (Ben Noordhuis) [#32739](https://github.com/nodejs/node/pull/32739)
+* [[`e07cca6af6`](https://github.com/nodejs/node/commit/e07cca6af6)] - **crypto**: generator must be int32 in DiffieHellman() (Ben Noordhuis) [#32739](https://github.com/nodejs/node/pull/32739)
+* [[`637442fec9`](https://github.com/nodejs/node/commit/637442fec9)] - **crypto**: key size must be int32 in DiffieHellman() (Ben Noordhuis) [#32739](https://github.com/nodejs/node/pull/32739)
+* [[`c5a4534d5c`](https://github.com/nodejs/node/commit/c5a4534d5c)] - **deps**: V8: backport e29c62b74854 (Anna Henningsen) [#33125](https://github.com/nodejs/node/pull/33125)
+* [[`8325c29e92`](https://github.com/nodejs/node/commit/8325c29e92)] - **deps**: update to uvwasi 0.0.8 (Colin Ihrig) [#33078](https://github.com/nodejs/node/pull/33078)
+* [[`2174159598`](https://github.com/nodejs/node/commit/2174159598)] - **esm**: improve commonjs hint on module not found (Daniele Belardi) [#31906](https://github.com/nodejs/node/pull/31906)
+* [[`74b0e8c3a8`](https://github.com/nodejs/node/commit/74b0e8c3a8)] - **http**: ensure client request emits close (Robert Nagy) [#33178](https://github.com/nodejs/node/pull/33178)
+* [[`a4ec01c55b`](https://github.com/nodejs/node/commit/a4ec01c55b)] - **http**: simplify sending header (Robert Nagy) [#33200](https://github.com/nodejs/node/pull/33200)
+* [[`451993ea94`](https://github.com/nodejs/node/commit/451993ea94)] - **http**: set default timeout in agent keepSocketAlive (Owen Smith) [#33127](https://github.com/nodejs/node/pull/33127)
+* [[`3cb1713a59`](https://github.com/nodejs/node/commit/3cb1713a59)] - **http2,doc**: minor fixes (Alba Mendez) [#28044](https://github.com/nodejs/node/pull/28044)
+* [[`eab4be1b93`](https://github.com/nodejs/node/commit/eab4be1b93)] - **lib**: cosmetic change to builtinLibs list for maintainability (James M Snell) [#33106](https://github.com/nodejs/node/pull/33106)
+* [[`542da430ff`](https://github.com/nodejs/node/commit/542da430ff)] - **lib**: fix validateport error message when allowZero is false (rickyes) [#32861](https://github.com/nodejs/node/pull/32861)
+* [[`5eccf1e9ad`](https://github.com/nodejs/node/commit/5eccf1e9ad)] - **module**: no type module resolver side effects (Guy Bedford) [#33086](https://github.com/nodejs/node/pull/33086)
+* [[`466213d726`](https://github.com/nodejs/node/commit/466213d726)] - **n-api**: simplify uv\_idle wrangling (Ben Noordhuis) [#32997](https://github.com/nodejs/node/pull/32997)
+* [[`ed45b51642`](https://github.com/nodejs/node/commit/ed45b51642)] - **path**: fix comment grammar (thecodrr) [#32942](https://github.com/nodejs/node/pull/32942)
+* [[`bb2d2f6e0e`](https://github.com/nodejs/node/commit/bb2d2f6e0e)] - **src**: remove unused v8 Message namespace (Adrian Estrada) [#33180](https://github.com/nodejs/node/pull/33180)
+* [[`de643bc325`](https://github.com/nodejs/node/commit/de643bc325)] - **src**: use unique\_ptr for CachedData in ContextifyScript::New (Anna Henningsen) [#33113](https://github.com/nodejs/node/pull/33113)
+* [[`f61928ba35`](https://github.com/nodejs/node/commit/f61928ba35)] - **src**: return undefined when validation err == 0 (James M Snell) [#33107](https://github.com/nodejs/node/pull/33107)
+* [[`f4e5ab14da`](https://github.com/nodejs/node/commit/f4e5ab14da)] - **src**: crypto::UseSNIContext to use BaseObjectPtr (James M Snell) [#33107](https://github.com/nodejs/node/pull/33107)
+* [[`541ea035bf`](https://github.com/nodejs/node/commit/541ea035bf)] - **src**: separate out NgLibMemoryManagerBase (James M Snell) [#33104](https://github.com/nodejs/node/pull/33104)
+* [[`10a87c81cf`](https://github.com/nodejs/node/commit/10a87c81cf)] - **src**: remove unnecessary fully qualified names (rickyes) [#33077](https://github.com/nodejs/node/pull/33077)
+* [[`45032a39e8`](https://github.com/nodejs/node/commit/45032a39e8)] - **stream**: fix stream.finished on Duplex (Robert Nagy) [#33133](https://github.com/nodejs/node/pull/33133)
+* [[`4cfa7e0716`](https://github.com/nodejs/node/commit/4cfa7e0716)] - **stream**: simplify Readable push/unshift logic (himself65) [#32899](https://github.com/nodejs/node/pull/32899)
+* [[`bc40ed31b3`](https://github.com/nodejs/node/commit/bc40ed31b3)] - **stream**: add null check in Readable.from (Pranshu Srivastava) [#32873](https://github.com/nodejs/node/pull/32873)
+* [[`b183d0a18a`](https://github.com/nodejs/node/commit/b183d0a18a)] - **stream**: let Duplex re-use Writable properties (Robert Nagy) [#33079](https://github.com/nodejs/node/pull/33079)
+* [[`ec24577406`](https://github.com/nodejs/node/commit/ec24577406)] - **v8**: use AliasedBuffers for passing heap statistics around (Joyee Cheung) [#32929](https://github.com/nodejs/node/pull/32929)
+* [[`d39254ada6`](https://github.com/nodejs/node/commit/d39254ada6)] - **vm**: fix vm.measureMemory() and introduce execution option (Joyee Cheung) [#32988](https://github.com/nodejs/node/pull/32988)
+* [[`4423304ac4`](https://github.com/nodejs/node/commit/4423304ac4)] - **vm**: throw error when duplicated exportNames in SyntheticModule (himself65) [#32810](https://github.com/nodejs/node/pull/32810)
+* [[`3866dc1311`](https://github.com/nodejs/node/commit/3866dc1311)] - **wasi**: use free() to release preopen array (Anna Henningsen) [#33110](https://github.com/nodejs/node/pull/33110)
+* [[`d7d9960d38`](https://github.com/nodejs/node/commit/d7d9960d38)] - **wasi**: update start() behavior to match spec (Colin Ihrig) [#33073](https://github.com/nodejs/node/pull/33073)
+* [[`8d5ac1bbf0`](https://github.com/nodejs/node/commit/8d5ac1bbf0)] - **wasi**: rename \_\_wasi\_unstable\_reactor\_start() (Colin Ihrig) [#33073](https://github.com/nodejs/node/pull/33073)
+* [[`c6d632a72a`](https://github.com/nodejs/node/commit/c6d632a72a)] - **worker**: unify custom error creation (Anna Henningsen) [#33084](https://github.com/nodejs/node/pull/33084)
+
+#### Documentation commits
+
+* [[`6925b358f9`](https://github.com/nodejs/node/commit/6925b358f9)] - **doc**: mark assert.CallTracker experimental (Ruben Bridgewater) [#33124](https://github.com/nodejs/node/pull/33124)
+* [[`413f5d3581`](https://github.com/nodejs/node/commit/413f5d3581)] - **doc**: add missing deprecation not (Robert Nagy) [#33203](https://github.com/nodejs/node/pull/33203)
+* [[`7893bde07e`](https://github.com/nodejs/node/commit/7893bde07e)] - **doc**: fix a typo in crypto.generateKeyPairSync() (himself65) [#33187](https://github.com/nodejs/node/pull/33187)
+* [[`d02ced8af6`](https://github.com/nodejs/node/commit/d02ced8af6)] - **doc**: add util.types.isArrayBufferView() (Kevin Locke) [#33092](https://github.com/nodejs/node/pull/33092)
+* [[`36d50027af`](https://github.com/nodejs/node/commit/36d50027af)] - **doc**: clarify when not to run CI on docs (Juan José Arboleda) [#33101](https://github.com/nodejs/node/pull/33101)
+* [[`a99013718c`](https://github.com/nodejs/node/commit/a99013718c)] - **doc**: fix the spelling error in stream.md (白一梓) [#31561](https://github.com/nodejs/node/pull/31561)
+* [[`23962191c1`](https://github.com/nodejs/node/commit/23962191c1)] - **doc**: correct Nodejs to Node.js spelling (Nick Schonning) [#33088](https://github.com/nodejs/node/pull/33088)
+* [[`de15edcfc0`](https://github.com/nodejs/node/commit/de15edcfc0)] - **doc**: improve worker pool example (Ranjan Purbey) [#33082](https://github.com/nodejs/node/pull/33082)
+* [[`289a5c8dfb`](https://github.com/nodejs/node/commit/289a5c8dfb)] - **doc**: some grammar fixes (Chris Holland) [#33081](https://github.com/nodejs/node/pull/33081)
+* [[`82e459d9af`](https://github.com/nodejs/node/commit/82e459d9af)] - **doc**: don't check links in tmp dirs (Ben Noordhuis) [#32996](https://github.com/nodejs/node/pull/32996)
+* [[`c5a2f9a02a`](https://github.com/nodejs/node/commit/c5a2f9a02a)] - **doc**: fix markdown parsing on doc/api/os.md (Juan José Arboleda) [#33067](https://github.com/nodejs/node/pull/33067)
+
+#### Other commits
+
+* [[`60ebbc4386`](https://github.com/nodejs/node/commit/60ebbc4386)] - **test**: update c8 ignore comment (Benjamin Coe) [#33151](https://github.com/nodejs/node/pull/33151)
+* [[`e276524fcc`](https://github.com/nodejs/node/commit/e276524fcc)] - **test**: skip memory usage tests when ASAN is enabled (Anna Henningsen) [#33129](https://github.com/nodejs/node/pull/33129)
+* [[`89ed7a5862`](https://github.com/nodejs/node/commit/89ed7a5862)] - **test**: move test-process-title to sequential (Anna Henningsen) [#33150](https://github.com/nodejs/node/pull/33150)
+* [[`af7da46d9b`](https://github.com/nodejs/node/commit/af7da46d9b)] - **test**: fix out-of-bound reads from invalid sizeof usage (Anna Henningsen) [#33115](https://github.com/nodejs/node/pull/33115)
+* [[`9ccb6b2e8c`](https://github.com/nodejs/node/commit/9ccb6b2e8c)] - **test**: add missing calls to napi\_async\_destroy (Anna Henningsen) [#33114](https://github.com/nodejs/node/pull/33114)
+* [[`3c2f608a8d`](https://github.com/nodejs/node/commit/3c2f608a8d)] - **test**: correct typo in test name (Colin Ihrig) [#33083](https://github.com/nodejs/node/pull/33083)
+* [[`92c7e0620f`](https://github.com/nodejs/node/commit/92c7e0620f)] - **test**: check args on SourceTextModule cachedData (Juan José Arboleda) [#32956](https://github.com/nodejs/node/pull/32956)
+* [[`f79ef96fea`](https://github.com/nodejs/node/commit/f79ef96fea)] - **test**: mark test flaky on freebsd (Sam Roberts) [#32849](https://github.com/nodejs/node/pull/32849)
+* [[`aced1f5d70`](https://github.com/nodejs/node/commit/aced1f5d70)] - **test**: flaky test-stdout-close-catch on freebsd (Sam Roberts) [#32849](https://github.com/nodejs/node/pull/32849)
+* [[`6734cc43df`](https://github.com/nodejs/node/commit/6734cc43df)] - **tools**: bump remark-preset-lint-node to 1.15.0 (Rich Trott) [#33157](https://github.com/nodejs/node/pull/33157)
+* [[`a87d371014`](https://github.com/nodejs/node/commit/a87d371014)] - **tools**: fix redundant-move warning in inspector (Daniel Bevenius) [#32685](https://github.com/nodejs/node/pull/32685)
+* [[`12426f59f5`](https://github.com/nodejs/node/commit/12426f59f5)] - **tools**: update remark-preset-lint-node@1.14.0 (Rich Trott) [#33072](https://github.com/nodejs/node/pull/33072)
+* [[`8c40ffc329`](https://github.com/nodejs/node/commit/8c40ffc329)] - **tools**: update broken types in type parser (Colin Ihrig) [#33068](https://github.com/nodejs/node/pull/33068)
+
+<a id="14.1.0"></a>
+## 2020-04-29, Version 14.1.0 (Current), @BethGriggs
+
+### Notable Changes
+
+* **deps**: upgrade openssl sources to 1.1.1g (Hassaan Pasha) [#32971](https://github.com/nodejs/node/pull/32971)
+* **doc**: add juanarbol as collaborator (Juan José Arboleda) [#32906](https://github.com/nodejs/node/pull/32906)
+* **http**: doc deprecate abort and improve docs (Robert Nagy) [#32807](https://github.com/nodejs/node/pull/32807)
+* **module**: do not warn when accessing `__esModule` of unfinished exports (Anna Henningsen) [#33048](https://github.com/nodejs/node/pull/33048)
+* **n-api**: detect deadlocks in thread-safe function (Gabriel Schulhof) [#32860](https://github.com/nodejs/node/pull/32860)
+* **src**: deprecate embedder APIs with replacements (Anna Henningsen) [#32858](https://github.com/nodejs/node/pull/32858)
+* **stream**:
+  * don't emit end after close (Robert Nagy) [#33076](https://github.com/nodejs/node/pull/33076)
+  * don't wait for close on legacy streams (Robert Nagy) [#33058](https://github.com/nodejs/node/pull/33058)
+  * pipeline should only destroy un-finished streams (Robert Nagy) [#32968](https://github.com/nodejs/node/pull/32968)
+* **vm**: add importModuleDynamically option to compileFunction (Gus Caplan) [#32985](https://github.com/nodejs/node/pull/32985)
+
+### Commits
+
+* [[`1af08e1c5e`](https://github.com/nodejs/node/commit/1af08e1c5e)] - **buffer,n-api**: fix double ArrayBuffer::Detach() during cleanup (Anna Henningsen) [#33039](https://github.com/nodejs/node/pull/33039)
+* [[`91e30e35a1`](https://github.com/nodejs/node/commit/91e30e35a1)] - **build**: fix vcbuild error for missing Visual Studio (Thomas) [#32658](https://github.com/nodejs/node/pull/32658)
+* [[`4035cbe631`](https://github.com/nodejs/node/commit/4035cbe631)] - **cluster**: removed unused addressType argument from constructor (Yash Ladha) [#32963](https://github.com/nodejs/node/pull/32963)
+* [[`56f50aeff0`](https://github.com/nodejs/node/commit/56f50aeff0)] - **deps**: patch V8 to 8.1.307.31 (Michaël Zasso) [#33080](https://github.com/nodejs/node/pull/33080)
+* [[`fad188fe23`](https://github.com/nodejs/node/commit/fad188fe23)] - **deps**: update archs files for OpenSSL-1.1.1g (Hassaan Pasha) [#32971](https://github.com/nodejs/node/pull/32971)
+* [[`b12f1630fc`](https://github.com/nodejs/node/commit/b12f1630fc)] - **deps**: upgrade openssl sources to 1.1.1g (Hassaan Pasha) [#32971](https://github.com/nodejs/node/pull/32971)
+* [[`b50333e001`](https://github.com/nodejs/node/commit/b50333e001)] - **deps**: V8: backport 3f8dc4b2e5ba (Ujjwal Sharma) [#32993](https://github.com/nodejs/node/pull/32993)
+* [[`bbed1e56cd`](https://github.com/nodejs/node/commit/bbed1e56cd)] - **deps**: V8: cherry-pick e1eac1b16c96 (Milad Farazmand) [#32974](https://github.com/nodejs/node/pull/32974)
+* [[`3fed735099`](https://github.com/nodejs/node/commit/3fed735099)] - **doc**: fix LTS replaceme tags (Anna Henningsen) [#33041](https://github.com/nodejs/node/pull/33041)
+* [[`343c6ac639`](https://github.com/nodejs/node/commit/343c6ac639)] - **doc**: assign missing deprecation code (Richard Lau) [#33109](https://github.com/nodejs/node/pull/33109)
+* [[`794b8796dd`](https://github.com/nodejs/node/commit/794b8796dd)] - **doc**: improve WHATWG url constructor code example (Liran Tal) [#32782](https://github.com/nodejs/node/pull/32782)
+* [[`14e559df87`](https://github.com/nodejs/node/commit/14e559df87)] - **doc**: make openssl maintenance position independent (Sam Roberts) [#32977](https://github.com/nodejs/node/pull/32977)
+* [[`8a4de2ef25`](https://github.com/nodejs/node/commit/8a4de2ef25)] - **doc**: improve release documentation (Michaël Zasso) [#33042](https://github.com/nodejs/node/pull/33042)
+* [[`401ab610e7`](https://github.com/nodejs/node/commit/401ab610e7)] - **doc**: document major finished changes in v14 (Robert Nagy) [#33065](https://github.com/nodejs/node/pull/33065)
+* [[`a534d8282c`](https://github.com/nodejs/node/commit/a534d8282c)] - **doc**: add documentation for transferList arg at worker threads (Juan José Arboleda) [#32881](https://github.com/nodejs/node/pull/32881)
+* [[`f116825d56`](https://github.com/nodejs/node/commit/f116825d56)] - **doc**: avoid tautology in README (Ishaan Jain) [#33005](https://github.com/nodejs/node/pull/33005)
+* [[`7e9f88e005`](https://github.com/nodejs/node/commit/7e9f88e005)] - **doc**: updated directory entry information (Eileen) [#32791](https://github.com/nodejs/node/pull/32791)
+* [[`bf331b4e21`](https://github.com/nodejs/node/commit/bf331b4e21)] - **doc**: ignore no-literal-urls in README (Nick Schonning) [#32676](https://github.com/nodejs/node/pull/32676)
+* [[`f92b398c76`](https://github.com/nodejs/node/commit/f92b398c76)] - **doc**: convert bare email addresses to mailto links (Nick Schonning) [#32676](https://github.com/nodejs/node/pull/32676)
+* [[`2bde11607d`](https://github.com/nodejs/node/commit/2bde11607d)] - **doc**: ignore no-literal-urls in changelogs (Nick Schonning) [#32676](https://github.com/nodejs/node/pull/32676)
+* [[`71f90234f9`](https://github.com/nodejs/node/commit/71f90234f9)] - **doc**: add angle brackets around implicit links (Nick Schonning) [#32676](https://github.com/nodejs/node/pull/32676)
+* [[`aec7bc754e`](https://github.com/nodejs/node/commit/aec7bc754e)] - **doc**: remove repeated word in modules.md (Prosper Opara) [#32931](https://github.com/nodejs/node/pull/32931)
+* [[`005c2bab29`](https://github.com/nodejs/node/commit/005c2bab29)] - **doc**: elevate diagnostic report to tier1 (Gireesh Punathil) [#32732](https://github.com/nodejs/node/pull/32732)
+* [[`4dd3a7ddc9`](https://github.com/nodejs/node/commit/4dd3a7ddc9)] - **doc**: set module version 83 to node 14 (Gerhard Stoebich) [#32975](https://github.com/nodejs/node/pull/32975)
+* [[`b5b3efeb90`](https://github.com/nodejs/node/commit/b5b3efeb90)] - **doc**: add more info to v14 changelog (Gus Caplan) [#32979](https://github.com/nodejs/node/pull/32979)
+* [[`f6be140222`](https://github.com/nodejs/node/commit/f6be140222)] - **doc**: fix typo in security-release-process.md (Edward Elric) [#32926](https://github.com/nodejs/node/pull/32926)
+* [[`fa710732bf`](https://github.com/nodejs/node/commit/fa710732bf)] - **doc**: corrected ERR\_SOCKET\_CANNOT\_SEND message (William Armiros) [#32847](https://github.com/nodejs/node/pull/32847)
+* [[`68b7c80a44`](https://github.com/nodejs/node/commit/68b7c80a44)] - **doc**: fix usage of folder and directory terms in fs.md (karan singh virdi) [#32919](https://github.com/nodejs/node/pull/32919)
+* [[`57c170c75c`](https://github.com/nodejs/node/commit/57c170c75c)] - **doc**: fix typo in zlib.md (雨夜带刀) [#32901](https://github.com/nodejs/node/pull/32901)
+* [[`a8ed8f5d0a`](https://github.com/nodejs/node/commit/a8ed8f5d0a)] - **doc**: synch SECURITY.md with website (Rich Trott) [#32903](https://github.com/nodejs/node/pull/32903)
+* [[`ccf6d3e5ed`](https://github.com/nodejs/node/commit/ccf6d3e5ed)] - **doc**: add `tsc-agenda` to onboarding labels list (Rich Trott) [#32832](https://github.com/nodejs/node/pull/32832)
+* [[`fc71a85c49`](https://github.com/nodejs/node/commit/fc71a85c49)] - **doc**: add N-API version 6 to table (Michael Dawson) [#32829](https://github.com/nodejs/node/pull/32829)
+* [[`87605f0ed3`](https://github.com/nodejs/node/commit/87605f0ed3)] - **doc**: add juanarbol as collaborator (Juan José Arboleda) [#32906](https://github.com/nodejs/node/pull/32906)
+* [[`4c643c0d42`](https://github.com/nodejs/node/commit/4c643c0d42)] - **fs**: update validateOffsetLengthRead in utils.js (daemon1024) [#32896](https://github.com/nodejs/node/pull/32896)
+* [[`baa8231728`](https://github.com/nodejs/node/commit/baa8231728)] - **fs**: extract kWriteFileMaxChunkSize constant (rickyes) [#32640](https://github.com/nodejs/node/pull/32640)
+* [[`03d02d74f3`](https://github.com/nodejs/node/commit/03d02d74f3)] - **fs**: remove unnecessary else statement (Jesus Hernandez) [#32662](https://github.com/nodejs/node/pull/32662)
+* [[`31c797cb11`](https://github.com/nodejs/node/commit/31c797cb11)] - **http**: doc deprecate abort and improve docs (Robert Nagy) [#32807](https://github.com/nodejs/node/pull/32807)
+* [[`4ef91a640e`](https://github.com/nodejs/node/commit/4ef91a640e)] - **http2**: wait for secureConnect before initializing (Benjamin Coe) [#32958](https://github.com/nodejs/node/pull/32958)
+* [[`6fc4d174b5`](https://github.com/nodejs/node/commit/6fc4d174b5)] - **http2**: refactor and cleanup http2 (James M Snell) [#32884](https://github.com/nodejs/node/pull/32884)
+* [[`4b6aa077fe`](https://github.com/nodejs/node/commit/4b6aa077fe)] - **inspector**: only write coverage in fully bootstrapped Environments (Joyee Cheung) [#32960](https://github.com/nodejs/node/pull/32960)
+* [[`737bd6205b`](https://github.com/nodejs/node/commit/737bd6205b)] - **lib**: unnecessary const assignment for class (Yash Ladha) [#32962](https://github.com/nodejs/node/pull/32962)
+* [[`98b30b06ff`](https://github.com/nodejs/node/commit/98b30b06ff)] - **lib**: simplify function process.emitWarning (himself65) [#32992](https://github.com/nodejs/node/pull/32992)
+* [[`b957895ff7`](https://github.com/nodejs/node/commit/b957895ff7)] - **lib**: remove unnecesary else block (David Daza) [#32644](https://github.com/nodejs/node/pull/32644)
+* [[`cb4d8ce889`](https://github.com/nodejs/node/commit/cb4d8ce889)] - **module**: refactor condition (Myles Borins) [#32989](https://github.com/nodejs/node/pull/32989)
+* [[`4abc45a4b9`](https://github.com/nodejs/node/commit/4abc45a4b9)] - **module**: do not warn when accessing `__esModule` of unfinished exports (Anna Henningsen) [#33048](https://github.com/nodejs/node/pull/33048)
+* [[`21d314e7fc`](https://github.com/nodejs/node/commit/21d314e7fc)] - **module**: exports not exported for null resolutions (Guy Bedford) [#32838](https://github.com/nodejs/node/pull/32838)
+* [[`eaf841d585`](https://github.com/nodejs/node/commit/eaf841d585)] - **module**: improve error for invalid package targets (Myles Borins) [#32052](https://github.com/nodejs/node/pull/32052)
+* [[`8663fd5f88`](https://github.com/nodejs/node/commit/8663fd5f88)] - **module**: partial doc removal of --experimental-modules (Myles Borins) [#32915](https://github.com/nodejs/node/pull/32915)
+* [[`68656cf588`](https://github.com/nodejs/node/commit/68656cf588)] - **n-api**: fix false assumption on napi\_async\_context structures (legendecas) [#32928](https://github.com/nodejs/node/pull/32928)
+* [[`861eb39307`](https://github.com/nodejs/node/commit/861eb39307)] - **(SEMVER-MINOR)** **n-api**: detect deadlocks in thread-safe function (Gabriel Schulhof) [#32860](https://github.com/nodejs/node/pull/32860)
+* [[`a133ac17eb`](https://github.com/nodejs/node/commit/a133ac17eb)] - **perf_hooks**: remove unnecessary assignment when name is undefined (rickyes) [#32910](https://github.com/nodejs/node/pull/32910)
+* [[`59b64adb79`](https://github.com/nodejs/node/commit/59b64adb79)] - **src**: add AsyncWrapObject constructor template factory (Stephen Belanger) [#33051](https://github.com/nodejs/node/pull/33051)
+* [[`23eda417b6`](https://github.com/nodejs/node/commit/23eda417b6)] - **src**: do not compare against wide characters (Christopher Beeson) [#32921](https://github.com/nodejs/node/pull/32921)
+* [[`d10c2c6968`](https://github.com/nodejs/node/commit/d10c2c6968)] - **src**: fix empty-named env var assertion failure (Christopher Beeson) [#32921](https://github.com/nodejs/node/pull/32921)
+* [[`44c157e45d`](https://github.com/nodejs/node/commit/44c157e45d)] - **src**: assignment to valid type (Yash Ladha) [#32879](https://github.com/nodejs/node/pull/32879)
+* [[`d82c3c28de`](https://github.com/nodejs/node/commit/d82c3c28de)] - **src**: delete MicroTaskPolicy namespace (Juan José Arboleda) [#32853](https://github.com/nodejs/node/pull/32853)
+* [[`bc755fc4c2`](https://github.com/nodejs/node/commit/bc755fc4c2)] - **src**: fix compiler warnings in node\_http2.cc (Daniel Bevenius) [#33014](https://github.com/nodejs/node/pull/33014)
+* [[`30c2b0f798`](https://github.com/nodejs/node/commit/30c2b0f798)] - **(SEMVER-MINOR)** **src**: deprecate embedder APIs with replacements (Anna Henningsen) [#32858](https://github.com/nodejs/node/pull/32858)
+* [[`95e897edfc`](https://github.com/nodejs/node/commit/95e897edfc)] - **src**: use using NewStringType (rickyes) [#32843](https://github.com/nodejs/node/pull/32843)
+* [[`4221b1c8c9`](https://github.com/nodejs/node/commit/4221b1c8c9)] - **src**: fix null deref in AllocatedBuffer::clear (Matt Kulukundis) [#32892](https://github.com/nodejs/node/pull/32892)
+* [[`f9b8988df6`](https://github.com/nodejs/node/commit/f9b8988df6)] - **src**: remove validation of unreachable code (Juan José Arboleda) [#32818](https://github.com/nodejs/node/pull/32818)
+* [[`307e43da4d`](https://github.com/nodejs/node/commit/307e43da4d)] - **src**: elevate v8 namespaces (Nimit) [#32872](https://github.com/nodejs/node/pull/32872)
+* [[`ca7e0a226e`](https://github.com/nodejs/node/commit/ca7e0a226e)] - **src**: remove redundant v8::HeapSnapshot namespace (Juan José Arboleda) [#32854](https://github.com/nodejs/node/pull/32854)
+* [[`ae157b8ca7`](https://github.com/nodejs/node/commit/ae157b8ca7)] - **(SEMVER-MINOR)** **stream**: don't emit end after close (Robert Nagy) [#33076](https://github.com/nodejs/node/pull/33076)
+* [[`184e80a144`](https://github.com/nodejs/node/commit/184e80a144)] - **stream**: don't wait for close on legacy streams (Robert Nagy) [#33058](https://github.com/nodejs/node/pull/33058)
+* [[`e07c4ffc39`](https://github.com/nodejs/node/commit/e07c4ffc39)] - **stream**: fix sync write perf regression (Robert Nagy) [#33032](https://github.com/nodejs/node/pull/33032)
+* [[`2bb4ac409b`](https://github.com/nodejs/node/commit/2bb4ac409b)] - **stream**: avoid drain for sync streams (Robert Nagy) [#32887](https://github.com/nodejs/node/pull/32887)
+* [[`c21f1f03c5`](https://github.com/nodejs/node/commit/c21f1f03c5)] - **stream**: removes unnecessary params (Jesus Hernandez) [#32936](https://github.com/nodejs/node/pull/32936)
+* [[`4c10b5f378`](https://github.com/nodejs/node/commit/4c10b5f378)] - **stream**: consistent punctuation (Robert Nagy) [#32934](https://github.com/nodejs/node/pull/32934)
+* [[`1a2b3eb3a4`](https://github.com/nodejs/node/commit/1a2b3eb3a4)] - **stream**: fix broken pipeline test (Robert Nagy) [#33030](https://github.com/nodejs/node/pull/33030)
+* [[`7abc61f668`](https://github.com/nodejs/node/commit/7abc61f668)] - **stream**: refactor Writable buffering (Robert Nagy) [#31046](https://github.com/nodejs/node/pull/31046)
+* [[`180b935b58`](https://github.com/nodejs/node/commit/180b935b58)] - **stream**: pipeline should only destroy un-finished streams (Robert Nagy) [#32968](https://github.com/nodejs/node/pull/32968)
+* [[`7647860000`](https://github.com/nodejs/node/commit/7647860000)] - **stream**: finished should complete with read-only Duplex (Robert Nagy) [#32967](https://github.com/nodejs/node/pull/32967)
+* [[`36a4f54d69`](https://github.com/nodejs/node/commit/36a4f54d69)] - **stream**: close iterator in Readable.from (Vadzim Zieńka) [#32844](https://github.com/nodejs/node/pull/32844)
+* [[`7f498125e4`](https://github.com/nodejs/node/commit/7f498125e4)] - **stream**: inline unbuffered \_write (Robert Nagy) [#32886](https://github.com/nodejs/node/pull/32886)
+* [[`2ab4ebc8bf`](https://github.com/nodejs/node/commit/2ab4ebc8bf)] - **stream**: simplify Writable.end() (Robert Nagy) [#32882](https://github.com/nodejs/node/pull/32882)
+* [[`11ea13f96c`](https://github.com/nodejs/node/commit/11ea13f96c)] - **test**: refactor test-async-hooks-constructor (himself65) [#33063](https://github.com/nodejs/node/pull/33063)
+* [[`8fad112d93`](https://github.com/nodejs/node/commit/8fad112d93)] - **test**: remove timers-blocking-callback (Jeremiah Senkpiel) [#32870](https://github.com/nodejs/node/pull/32870)
+* [[`988c2fe287`](https://github.com/nodejs/node/commit/988c2fe287)] - **test**: better error validations for event-capture (Adrian Estrada) [#32771](https://github.com/nodejs/node/pull/32771)
+* [[`45e188b2e3`](https://github.com/nodejs/node/commit/45e188b2e3)] - **test**: refactor events tests for invalid listeners (Adrian Estrada) [#32769](https://github.com/nodejs/node/pull/32769)
+* [[`b4ef06267d`](https://github.com/nodejs/node/commit/b4ef06267d)] - **test**: test-async-wrap-constructor prefer forEach (Daniel Estiven Rico Posada) [#32631](https://github.com/nodejs/node/pull/32631)
+* [[`c9ae385abf`](https://github.com/nodejs/node/commit/c9ae385abf)] - **test**: mark test-child-process-fork-args as flaky on Windows (Andrey Pechkurov) [#32950](https://github.com/nodejs/node/pull/32950)
+* [[`b12204e27e`](https://github.com/nodejs/node/commit/b12204e27e)] - **test**: changed function to arrow function (Nimit) [#32875](https://github.com/nodejs/node/pull/32875)
+* [[`323da6f251`](https://github.com/nodejs/node/commit/323da6f251)] - **tls**: add highWaterMark option for connect (rickyes) [#32786](https://github.com/nodejs/node/pull/32786)
+* [[`308681307f`](https://github.com/nodejs/node/commit/308681307f)] - **tls**: move getAllowUnauthorized to internal/options (James M Snell) [#32917](https://github.com/nodejs/node/pull/32917)
+* [[`6a8e266a3b`](https://github.com/nodejs/node/commit/6a8e266a3b)] - **tools**: update ESLint to 7.0.0-rc.0 (himself65) [#33062](https://github.com/nodejs/node/pull/33062)
+* [[`fa7d969237`](https://github.com/nodejs/node/commit/fa7d969237)] - **tools**: remove unused code in doc generation tool (Rich Trott) [#32913](https://github.com/nodejs/node/pull/32913)
+* [[`ca5ebcfb67`](https://github.com/nodejs/node/commit/ca5ebcfb67)] - **tools**: fix mkcodecache when run with ASAN (Anna Henningsen) [#32850](https://github.com/nodejs/node/pull/32850)
+* [[`22ccf2ba1f`](https://github.com/nodejs/node/commit/22ccf2ba1f)] - **tools**: decrease timeout in test.py (Anna Henningsen) [#32868](https://github.com/nodejs/node/pull/32868)
+* [[`c82c08416f`](https://github.com/nodejs/node/commit/c82c08416f)] - **util,readline**: NFC-normalize strings before getStringWidth (Anna Henningsen) [#33052](https://github.com/nodejs/node/pull/33052)
+* [[`4143c747fc`](https://github.com/nodejs/node/commit/4143c747fc)] - **(SEMVER-MINOR)** **vm**: add importModuleDynamically option to compileFunction (Gus Caplan) [#32985](https://github.com/nodejs/node/pull/32985)
+* [[`c84d802449`](https://github.com/nodejs/node/commit/c84d802449)] - **worker**: fix process.env var empty key access (Christopher Beeson) [#32921](https://github.com/nodejs/node/pull/32921)
+
+<a id="14.0.0"></a>
+## 2020-04-21, Version 14.0.0 (Current), @BethGriggs
+
+### Notable Changes
+
+#### Deprecations
+
+* **(SEMVER-MAJOR)** **crypto**: move pbkdf2 without digest to EOL (James M Snell) [#31166](https://github.com/nodejs/node/pull/31166)
+* **(SEMVER-MAJOR)** **fs**: deprecate closing FileHandle on garbage collection (James M Snell) [#28396](https://github.com/nodejs/node/pull/28396)
+* **(SEMVER-MAJOR)** **http**: move OutboundMessage.prototype.flush to EOL (James M Snell) [#31164](https://github.com/nodejs/node/pull/31164)
+* **(SEMVER-MAJOR)** **lib**: move GLOBAL and root aliases to EOL (James M Snell) [#31167](https://github.com/nodejs/node/pull/31167)
+* **(SEMVER-MAJOR)** **os**: move tmpDir() to EOL (James M Snell) [#31169](https://github.com/nodejs/node/pull/31169)
+* **(SEMVER-MAJOR)** **src**: remove deprecated wasm type check (Clemens Backes) [#32116](https://github.com/nodejs/node/pull/32116)
+* **(SEMVER-MAJOR)** **stream**: move \_writableState.buffer to EOL (James M Snell) [#31165](https://github.com/nodejs/node/pull/31165)
+* **(SEMVER-MINOR)** **doc**: deprecate process.mainModule (Antoine du HAMEL) [#32232](https://github.com/nodejs/node/pull/32232)
+* **(SEMVER-MINOR)** **doc**: deprecate process.umask() with no arguments (Colin Ihrig) [#32499](https://github.com/nodejs/node/pull/32499)
+
+#### ECMAScript Modules - Experimental Warning Removal
+
+* **module**: remove experimental modules warning (Guy Bedford) [#31974](https://github.com/nodejs/node/pull/31974)
+
+In Node.js 13 we removed the need to include the --experimental-modules flag, but when running EcmaScript Modules in Node.js, this would still result in a warning ExperimentalWarning: The ESM module loader is experimental.
+
+As of Node.js 14 there is no longer this warning when using ESM in Node.js. However, the ESM implementation in Node.js remains experimental. As per our stability index: “The feature is not subject to Semantic Versioning rules. Non-backward compatible changes or removal may occur in any future release.” Users should be cautious when using the feature in production environments.
+
+Please keep in mind that the implementation of ESM in Node.js differs from the developer experience you might be familiar with. Most transpilation workflows support features such as optional file extensions or JSON modules that the Node.js ESM implementation does not support. It is highly likely that modules from transpiled environments will require a certain degree of refactoring to work in Node.js. It is worth mentioning that many of our design decisions were made with two primary goals. Spec compliance and Web Compatibility. It is our belief that the current implementation offers a future proof model to authoring ESM modules that paves the path to Universal JavaScript. Please read more in our documentation.
+
+The ESM implementation in Node.js is still experimental but we do believe that we are getting very close to being able to call ESM in Node.js “stable”. Removing the warning is a huge step in that direction.
+
+#### New V8 ArrayBuffer API
+
+* **src**: migrate to new V8 ArrayBuffer API (Thang Tran) [#30782](https://github.com/nodejs/node/pull/30782)
+
+Multiple ArrayBuffers pointing to the same base address are no longer allowed by V8. This may impact native addons.
+
+#### Toolchain and Compiler Upgrades
+
+* **(SEMVER-MAJOR)** **build**: update macos deployment target to 10.13 for 14.x (AshCripps) [#32454](https://github.com/nodejs/node/pull/32454)
+* **(SEMVER-MAJOR)** **doc**: update cross compiler machine for Linux armv7 (Richard Lau) [#32812](https://github.com/nodejs/node/pull/32812)
+* **(SEMVER-MAJOR)** **doc**: update Centos/RHEL releases use devtoolset-8 (Richard Lau) [#32812](https://github.com/nodejs/node/pull/32812)
+* **(SEMVER-MAJOR)** **doc**: remove SmartOS from official binaries (Richard Lau) [#32812](https://github.com/nodejs/node/pull/32812)
+* **(SEMVER-MAJOR)** **win**: block running on EOL Windows versions (João Reis) [#31954](https://github.com/nodejs/node/pull/31954)
+
+It is expected that there will be an ABI mismatch on ARM between the Node.js binary and native addons. Native addons are only broken if they
+interact with `std::shared_ptr`. This is expected to be fixed in a later version of Node.js 14. - [#30786](https://github.com/nodejs/node/issues/30786)
+
+#### Update to V8 8.1
+
+* **(SEMVER-MAJOR)** **deps**: update V8 to 8.1.307.20 (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+  * Enables Optional Chaining by default ([MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining), [v8.dev](https://v8.dev/features/optional-chaining))
+  * Enables Nullish Coalescing by default ([MDN](https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_Coalescing_Operator), [v8.dev](https://v8.dev/features/nullish-coalescing))
+  * Enables `Intl.DisplayNames` by default ([MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DisplayNames), [v8.dev](https://v8.dev/features/intl-displaynames))
+  * Enables `calendar` and `numberingSystem` options for `Intl.DateTimeFormat` by default ([MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat))
+
+#### Other Notable Changes:
+
+* **cli, report**: move --report-on-fatalerror to stable (Colin Ihrig) [#32496](https://github.com/nodejs/node/pull/32496)
+* **deps**: upgrade to libuv 1.37.0 (Colin Ihrig) [#32866](https://github.com/nodejs/node/pull/32866)
+* **fs**: add fs/promises alias module (Gus Caplan) [#31553](https://github.com/nodejs/node/pull/31553)
+
+### Semver-Major Commits
+
+* [[`5360dd151d`](https://github.com/nodejs/node/commit/5360dd151d)] - **(SEMVER-MAJOR)** **assert**: handle (deep) equal(NaN, NaN) as being identical (Ruben Bridgewater) [#30766](https://github.com/nodejs/node/pull/30766)
+* [[`a621608f12`](https://github.com/nodejs/node/commit/a621608f12)] - **(SEMVER-MAJOR)** **build**: update macos deployment target to 10.13 for 14.x (AshCripps) [#32454](https://github.com/nodejs/node/pull/32454)
+* [[`e65bed1b7e`](https://github.com/nodejs/node/commit/e65bed1b7e)] - **(SEMVER-MAJOR)** **child_process**: create proper public API for `channel` (Anna Henningsen) [#30165](https://github.com/nodejs/node/pull/30165)
+* [[`1b9a62cff4`](https://github.com/nodejs/node/commit/1b9a62cff4)] - **(SEMVER-MAJOR)** **crypto**: make DH error messages consistent (Tobias Nießen) [#31873](https://github.com/nodejs/node/pull/31873)
+* [[`bffa5044c5`](https://github.com/nodejs/node/commit/bffa5044c5)] - **(SEMVER-MAJOR)** **crypto**: move pbkdf2 without digest to EOL (James M Snell) [#31166](https://github.com/nodejs/node/pull/31166)
+* [[`10f5fa7513`](https://github.com/nodejs/node/commit/10f5fa7513)] - **(SEMVER-MAJOR)** **crypto**: forbid setting the PBKDF2 iter count to 0 (Tobias Nießen) [#30578](https://github.com/nodejs/node/pull/30578)
+* [[`2883c855e0`](https://github.com/nodejs/node/commit/2883c855e0)] - **(SEMVER-MAJOR)** **deps**: update V8 to 8.1.307.20 (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`1b2e2944bc`](https://github.com/nodejs/node/commit/1b2e2944bc)] - **(SEMVER-MAJOR)** **dgram**: don't hide implicit bind errors (Colin Ihrig) [#31958](https://github.com/nodejs/node/pull/31958)
+* [[`1a1ce93317`](https://github.com/nodejs/node/commit/1a1ce93317)] - **(SEMVER-MAJOR)** **doc**: update cross compiler machine for Linux armv7 (Richard Lau) [#32812](https://github.com/nodejs/node/pull/32812)
+* [[`dad96e4fc1`](https://github.com/nodejs/node/commit/dad96e4fc1)] - **(SEMVER-MAJOR)** **doc**: update Centos/RHEL releases use devtoolset-8 (Richard Lau) [#32812](https://github.com/nodejs/node/pull/32812)
+* [[`5317202aa1`](https://github.com/nodejs/node/commit/5317202aa1)] - **(SEMVER-MAJOR)** **doc**: remove SmartOS from official binaries (Richard Lau) [#32812](https://github.com/nodejs/node/pull/32812)
+* [[`75ee5b2622`](https://github.com/nodejs/node/commit/75ee5b2622)] - **(SEMVER-MAJOR)** **doc**: deprecate process.umask() with no arguments (Colin Ihrig) [#32499](https://github.com/nodejs/node/pull/32499)
+* [[`afe353061b`](https://github.com/nodejs/node/commit/afe353061b)] - **(SEMVER-MAJOR)** **doc**: fs.write is not longer coercing strings (Juan José Arboleda) [#31030](https://github.com/nodejs/node/pull/31030)
+* [[`a45c1aa39f`](https://github.com/nodejs/node/commit/a45c1aa39f)] - **(SEMVER-MAJOR)** **doc**: fix mode and flags being mistaken in fs (Ruben Bridgewater) [#27044](https://github.com/nodejs/node/pull/27044)
+* [[`331d636240`](https://github.com/nodejs/node/commit/331d636240)] - **(SEMVER-MAJOR)** **errors**: remove unused ERR\_SOCKET\_CANNOT\_SEND error (Colin Ihrig) [#31958](https://github.com/nodejs/node/pull/31958)
+* [[`b8e41774d4`](https://github.com/nodejs/node/commit/b8e41774d4)] - **(SEMVER-MAJOR)** **fs**: add fs/promises alias module (Gus Caplan) [#31553](https://github.com/nodejs/node/pull/31553)
+* [[`fb6df3bfac`](https://github.com/nodejs/node/commit/fb6df3bfac)] - **(SEMVER-MAJOR)** **fs**: validate the input data to be of expected types (Ruben Bridgewater) [#31030](https://github.com/nodejs/node/pull/31030)
+* [[`2d8febceef`](https://github.com/nodejs/node/commit/2d8febceef)] - **(SEMVER-MAJOR)** **fs**: deprecate closing FileHandle on garbage collection (James M Snell) [#28396](https://github.com/nodejs/node/pull/28396)
+* [[`67e067eb06`](https://github.com/nodejs/node/commit/67e067eb06)] - **(SEMVER-MAJOR)** **fs**: watch signals for recursive incompatibility (Eran Levin) [#29947](https://github.com/nodejs/node/pull/29947)
+* [[`f0d2df41f8`](https://github.com/nodejs/node/commit/f0d2df41f8)] - **(SEMVER-MAJOR)** **fs**: change streams to always emit close by default (Robert Nagy) [#31408](https://github.com/nodejs/node/pull/31408)
+* [[`a13500f503`](https://github.com/nodejs/node/commit/a13500f503)] - **(SEMVER-MAJOR)** **fs**: improve mode and flags validation (Ruben Bridgewater) [#27044](https://github.com/nodejs/node/pull/27044)
+* [[`535e9571f5`](https://github.com/nodejs/node/commit/535e9571f5)] - **(SEMVER-MAJOR)** **fs**: make FSStatWatcher.start private (Lucas Holmquist) [#29971](https://github.com/nodejs/node/pull/29971)
+* [[`c1b2f6afbe`](https://github.com/nodejs/node/commit/c1b2f6afbe)] - **(SEMVER-MAJOR)** **http**: detach socket from IncomingMessage on keep-alive (Robert Nagy) [#32153](https://github.com/nodejs/node/pull/32153)
+* [[`173d044d09`](https://github.com/nodejs/node/commit/173d044d09)] - **(SEMVER-MAJOR)** **http**: align OutgoingMessage and ClientRequest destroy (Robert Nagy) [#32148](https://github.com/nodejs/node/pull/32148)
+* [[`d3715c76b5`](https://github.com/nodejs/node/commit/d3715c76b5)] - **(SEMVER-MAJOR)** **http**: move OutboundMessage.prototype.flush to EOL (James M Snell) [#31164](https://github.com/nodejs/node/pull/31164)
+* [[`c776a37791`](https://github.com/nodejs/node/commit/c776a37791)] - **(SEMVER-MAJOR)** **http**: end with data can cause write after end (Robert Nagy) [#28666](https://github.com/nodejs/node/pull/28666)
+* [[`ff2ed3ec85`](https://github.com/nodejs/node/commit/ff2ed3ec85)] - **(SEMVER-MAJOR)** **http**: remove unused hasItems() from freelist (Rich Trott) [#30744](https://github.com/nodejs/node/pull/30744)
+* [[`d247a8e1dc`](https://github.com/nodejs/node/commit/d247a8e1dc)] - **(SEMVER-MAJOR)** **http**: emit close on socket re-use (Robert Nagy) [#28685](https://github.com/nodejs/node/pull/28685)
+* [[`6f0ec79e42`](https://github.com/nodejs/node/commit/6f0ec79e42)] - **(SEMVER-MAJOR)** **http,stream**: make virtual methods throw an error (Luigi Pinca) [#31912](https://github.com/nodejs/node/pull/31912)
+* [[`ec0dd6fa1c`](https://github.com/nodejs/node/commit/ec0dd6fa1c)] - **(SEMVER-MAJOR)** **lib**: move GLOBAL and root aliases to EOL (James M Snell) [#31167](https://github.com/nodejs/node/pull/31167)
+* [[`d7452b7140`](https://github.com/nodejs/node/commit/d7452b7140)] - **(SEMVER-MAJOR)** **module**: warn on using unfinished circular dependency (Anna Henningsen) [#29935](https://github.com/nodejs/node/pull/29935)
+* [[`eeccd52b4e`](https://github.com/nodejs/node/commit/eeccd52b4e)] - **(SEMVER-MAJOR)** **net**: make readable/writable start as true (Robert Nagy) [#32272](https://github.com/nodejs/node/pull/32272)
+* [[`ab4115f17c`](https://github.com/nodejs/node/commit/ab4115f17c)] - **(SEMVER-MAJOR)** **os**: move tmpDir() to EOL (James M Snell) [#31169](https://github.com/nodejs/node/pull/31169)
+* [[`8c18e91c8a`](https://github.com/nodejs/node/commit/8c18e91c8a)] - **(SEMVER-MAJOR)** **process**: remove undocumented `now` argument from emitWarning() (Rich Trott) [#31643](https://github.com/nodejs/node/pull/31643)
+* [[`84c426cb60`](https://github.com/nodejs/node/commit/84c426cb60)] - **(SEMVER-MAJOR)** **repl**: properly handle `repl.repl` (Ruben Bridgewater) [#30981](https://github.com/nodejs/node/pull/30981)
+* [[`4f523c2c1a`](https://github.com/nodejs/node/commit/4f523c2c1a)] - **(SEMVER-MAJOR)** **src**: migrate to new V8 ArrayBuffer API (Thang Tran) [#30782](https://github.com/nodejs/node/pull/30782)
+* [[`c712fb7cd6`](https://github.com/nodejs/node/commit/c712fb7cd6)] - **(SEMVER-MAJOR)** **src**: add abstract `IsolatePlatformDelegate` (Marcel Laverdet) [#30324](https://github.com/nodejs/node/pull/30324)
+* [[`1428a92492`](https://github.com/nodejs/node/commit/1428a92492)] - **(SEMVER-MAJOR)** **stream**: make pipeline try to wait for 'close' (Robert Nagy) [#32158](https://github.com/nodejs/node/pull/32158)
+* [[`388cef61e8`](https://github.com/nodejs/node/commit/388cef61e8)] - **(SEMVER-MAJOR)** **stream**: align stream.Duplex with net.Socket (Robert Nagy) [#32139](https://github.com/nodejs/node/pull/32139)
+* [[`7cafd5f3a9`](https://github.com/nodejs/node/commit/7cafd5f3a9)] - **(SEMVER-MAJOR)** **stream**: fix finished w/ 'close' before 'end' (Robert Nagy) [#31545](https://github.com/nodejs/node/pull/31545)
+* [[`311e12b962`](https://github.com/nodejs/node/commit/311e12b962)] - **(SEMVER-MAJOR)** **stream**: fix multiple destroy calls (Robert Nagy) [#29197](https://github.com/nodejs/node/pull/29197)
+* [[`1f209129c7`](https://github.com/nodejs/node/commit/1f209129c7)] - **(SEMVER-MAJOR)** **stream**: throw invalid argument errors (Robert Nagy) [#31831](https://github.com/nodejs/node/pull/31831)
+* [[`d016b9d708`](https://github.com/nodejs/node/commit/d016b9d708)] - **(SEMVER-MAJOR)** **stream**: finished callback for closed streams (Robert Nagy) [#31509](https://github.com/nodejs/node/pull/31509)
+* [[`e559842188`](https://github.com/nodejs/node/commit/e559842188)] - **(SEMVER-MAJOR)** **stream**: make readable & writable computed (Robert Nagy) [#31197](https://github.com/nodejs/node/pull/31197)
+* [[`907c07fa85`](https://github.com/nodejs/node/commit/907c07fa85)] - **(SEMVER-MAJOR)** **stream**: move \_writableState.buffer to EOL (James M Snell) [#31165](https://github.com/nodejs/node/pull/31165)
+* [[`66f4e4edcb`](https://github.com/nodejs/node/commit/66f4e4edcb)] - **(SEMVER-MAJOR)** **stream**: do not emit 'end' after 'error' (Robert Nagy) [#31182](https://github.com/nodejs/node/pull/31182)
+* [[`75b30c606c`](https://github.com/nodejs/node/commit/75b30c606c)] - **(SEMVER-MAJOR)** **stream**: emit 'error' asynchronously (Robert Nagy) [#29744](https://github.com/nodejs/node/pull/29744)
+* [[`4bec6d13f9`](https://github.com/nodejs/node/commit/4bec6d13f9)] - **(SEMVER-MAJOR)** **stream**: enable autoDestroy by default (Robert Nagy) [#30623](https://github.com/nodejs/node/pull/30623)
+* [[`20d009d2fd`](https://github.com/nodejs/node/commit/20d009d2fd)] - **(SEMVER-MAJOR)** **stream**: pipe should not swallow error (Robert Nagy) [#30993](https://github.com/nodejs/node/pull/30993)
+* [[`67ed526ab0`](https://github.com/nodejs/node/commit/67ed526ab0)] - **(SEMVER-MAJOR)** **stream**: error state cleanup (Robert Nagy) [#30851](https://github.com/nodejs/node/pull/30851)
+* [[`e902fadc5e`](https://github.com/nodejs/node/commit/e902fadc5e)] - **(SEMVER-MAJOR)** **stream**: do not throw multiple callback errors in writable (Robert Nagy) [#30614](https://github.com/nodejs/node/pull/30614)
+* [[`e13a37e49d`](https://github.com/nodejs/node/commit/e13a37e49d)] - **(SEMVER-MAJOR)** **stream**: ensure finish is emitted in next tick (Robert Nagy) [#30733](https://github.com/nodejs/node/pull/30733)
+* [[`9d09969f4c`](https://github.com/nodejs/node/commit/9d09969f4c)] - **(SEMVER-MAJOR)** **stream**: always invoke end callback (Robert Nagy) [#29747](https://github.com/nodejs/node/pull/29747)
+
+* [[`0f78dcc86d`](https://github.com/nodejs/node/commit/0f78dcc86d)] - **(SEMVER-MAJOR)** **util**: escape C1 control characters and switch to hex format (Ruben Bridgewater) [#29826](https://github.com/nodejs/node/pull/29826)
+* [[`cb8898c48f`](https://github.com/nodejs/node/commit/cb8898c48f)] - **(SEMVER-MAJOR)** **win**: block running on EOL Windows versions (João Reis) [#31954](https://github.com/nodejs/node/pull/31954)
+* [[`a9401439c7`](https://github.com/nodejs/node/commit/a9401439c7)] - **(SEMVER-MAJOR)** **zlib**: align with streams (Robert Nagy) [#32220](https://github.com/nodejs/node/pull/32220)
+
+### Semver-Minor Commits
+
+* [[`63f0dd1ab9`](https://github.com/nodejs/node/commit/63f0dd1ab9)] - **(SEMVER-MINOR)** **async_hooks**: merge run and exit methods (Andrey Pechkurov) [#31950](https://github.com/nodejs/node/pull/31950)
+* [[`a683e87cd0`](https://github.com/nodejs/node/commit/a683e87cd0)] - **(SEMVER-MINOR)** **async_hooks**: prevent sync methods of async storage exiting outer context (Stephen Belanger) [#31950](https://github.com/nodejs/node/pull/31950)
+* [[`f571b294f5`](https://github.com/nodejs/node/commit/f571b294f5)] - **(SEMVER-MINOR)** **doc**: deprecate process.mainModule (Antoine du HAMEL) [#32232](https://github.com/nodejs/node/pull/32232)
+* [[`e04f599258`](https://github.com/nodejs/node/commit/e04f599258)] - **(SEMVER-MINOR)** **doc**: add basic embedding example documentation (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`e93503be83`](https://github.com/nodejs/node/commit/e93503be83)] - **(SEMVER-MINOR)** **embedding**: provide hook for custom process.exit() behaviour (Anna Henningsen) [#32531](https://github.com/nodejs/node/pull/32531)
+* [[`a8cf886de7`](https://github.com/nodejs/node/commit/a8cf886de7)] - **(SEMVER-MINOR)** **src**: shutdown platform from FreePlatform() (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`0e576740dc`](https://github.com/nodejs/node/commit/0e576740dc)] - **(SEMVER-MINOR)** **src**: fix what a dispose without checking (Jichan) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`887b6a143b`](https://github.com/nodejs/node/commit/887b6a143b)] - **(SEMVER-MINOR)** **src**: allow non-Node.js TracingControllers (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`7e0264d932`](https://github.com/nodejs/node/commit/7e0264d932)] - **(SEMVER-MINOR)** **src**: add ability to look up platform based on `Environment\*` (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`d7f11077f1`](https://github.com/nodejs/node/commit/d7f11077f1)] - **(SEMVER-MINOR)** **src**: make InitializeNodeWithArgs() official public API (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`821e21de8c`](https://github.com/nodejs/node/commit/821e21de8c)] - **(SEMVER-MINOR)** **src**: add unique\_ptr equivalent of CreatePlatform (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`7dead8440c`](https://github.com/nodejs/node/commit/7dead8440c)] - **(SEMVER-MINOR)** **src**: add LoadEnvironment() variant taking a string (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`c44edec4da`](https://github.com/nodejs/node/commit/c44edec4da)] - **(SEMVER-MINOR)** **src**: provide a variant of LoadEnvironment taking a callback (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`a9fb51f9be`](https://github.com/nodejs/node/commit/a9fb51f9be)] - **(SEMVER-MINOR)** **src**: align worker and main thread code with embedder API (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`084c379648`](https://github.com/nodejs/node/commit/084c379648)] - **(SEMVER-MINOR)** **src**: associate is\_main\_thread() with worker\_context() (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`64c01222d9`](https://github.com/nodejs/node/commit/64c01222d9)] - **(SEMVER-MINOR)** **src**: move worker\_context from Environment to IsolateData (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`288382a4ce`](https://github.com/nodejs/node/commit/288382a4ce)] - **(SEMVER-MINOR)** **src**: fix memory leak in CreateEnvironment when bootstrap fails (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`d7bc5816a5`](https://github.com/nodejs/node/commit/d7bc5816a5)] - **(SEMVER-MINOR)** **src**: make `FreeEnvironment()` perform all necessary cleanup (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`43d32b073f`](https://github.com/nodejs/node/commit/43d32b073f)] - **(SEMVER-MINOR)** **src,test**: add full-featured embedder API test (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`2061c33670`](https://github.com/nodejs/node/commit/2061c33670)] - **(SEMVER-MINOR)** **test**: add extended embedder cctest (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+* [[`2561484dcb`](https://github.com/nodejs/node/commit/2561484dcb)] - **(SEMVER-MINOR)** **test**: re-enable cctest that was commented out (Anna Henningsen) [#30467](https://github.com/nodejs/node/pull/30467)
+
+### Semver-Patch Commits
+
+* [[`9b6e797379`](https://github.com/nodejs/node/commit/9b6e797379)] - ***Revert*** "**assert**: fix line number calculation after V8 upgrade" (Michaël Zasso) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`c740fbda9d`](https://github.com/nodejs/node/commit/c740fbda9d)] - **buffer**: add type check in bidirectionalIndexOf (Gerhard Stoebich) [#32770](https://github.com/nodejs/node/pull/32770)
+* [[`c8e3470e53`](https://github.com/nodejs/node/commit/c8e3470e53)] - **buffer**: mark pool ArrayBuffer as untransferable (Anna Henningsen) [#32759](https://github.com/nodejs/node/pull/32759)
+* [[`f2c22db580`](https://github.com/nodejs/node/commit/f2c22db580)] - **build**: remove .git folders when testing V8 (Richard Lau) [#32877](https://github.com/nodejs/node/pull/32877)
+* [[`c0f43bfda8`](https://github.com/nodejs/node/commit/c0f43bfda8)] - **build**: add configure flag to build V8 with DCHECKs (Anna Henningsen) [#32787](https://github.com/nodejs/node/pull/32787)
+* [[`99e7f878ce`](https://github.com/nodejs/node/commit/99e7f878ce)] - **build**: re-enable ASAN Action using clang (Matheus Marchini) [#32776](https://github.com/nodejs/node/pull/32776)
+* [[`3e55284e9b`](https://github.com/nodejs/node/commit/3e55284e9b)] - **build**: use same flags as V8 for ASAN (Matheus Marchini) [#32776](https://github.com/nodejs/node/pull/32776)
+* [[`4e5ec41024`](https://github.com/nodejs/node/commit/4e5ec41024)] - **build**: add build from tarball (John Kleinschmidt) [#32129](https://github.com/nodejs/node/pull/32129)
+* [[`6a349019da`](https://github.com/nodejs/node/commit/6a349019da)] - **build**: temporarily skip ASAN build (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`da92f15413`](https://github.com/nodejs/node/commit/da92f15413)] - **build**: reset embedder string to "-node.0" (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`e883059c24`](https://github.com/nodejs/node/commit/e883059c24)] - **cli, report**: move --report-on-fatalerror to stable (Colin Ihrig) [#32496](https://github.com/nodejs/node/pull/32496)
+* [[`bf86f55e22`](https://github.com/nodejs/node/commit/bf86f55e22)] - **deps**: patch V8 to 8.1.307.30 (Michaël Zasso) [#32693](https://github.com/nodejs/node/pull/32693)
+* [[`b5bbde8cf1`](https://github.com/nodejs/node/commit/b5bbde8cf1)] - **deps**: upgrade to libuv 1.37.0 (Colin Ihrig) [#32866](https://github.com/nodejs/node/pull/32866)
+* [[`7afe24dba6`](https://github.com/nodejs/node/commit/7afe24dba6)] - **deps**: upgrade to libuv 1.36.0 (Colin Ihrig) [#32866](https://github.com/nodejs/node/pull/32866)
+* [[`1cd235d1a0`](https://github.com/nodejs/node/commit/1cd235d1a0)] - **deps**: patch V8 to run on Xcode 8 (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`5d867badd0`](https://github.com/nodejs/node/commit/5d867badd0)] - **deps**: V8: silence irrelevant warnings (Michaël Zasso) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`8d2c441e4d`](https://github.com/nodejs/node/commit/8d2c441e4d)] - **deps**: V8: cherry-pick 931bdbd76f5b (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`049160dfb6`](https://github.com/nodejs/node/commit/049160dfb6)] - **deps**: V8: cherry-pick 1e36e21acc40 (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`0220c298c5`](https://github.com/nodejs/node/commit/0220c298c5)] - **deps**: bump minimum icu version to 65 (Michaël Zasso) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`f90eba1d91`](https://github.com/nodejs/node/commit/f90eba1d91)] - **deps**: make v8.h compatible with VS2015 (Joao Reis) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`56b6a4f732`](https://github.com/nodejs/node/commit/56b6a4f732)] - **deps**: V8: forward declaration of `Rtl\*FunctionTable` (Refael Ackermann) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`40c9419b35`](https://github.com/nodejs/node/commit/40c9419b35)] - **deps**: V8: patch register-arm64.h (Refael Ackermann) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`55407ab73e`](https://github.com/nodejs/node/commit/55407ab73e)] - **deps**: patch V8 to run on older XCode versions (Ujjwal Sharma) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`990bc9adb4`](https://github.com/nodejs/node/commit/990bc9adb4)] - **deps**: V8: un-cherry-pick bd019bd (Refael Ackermann) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`17a6def4e8`](https://github.com/nodejs/node/commit/17a6def4e8)] - **deps**: update V8 dtrace & postmortem metadata (Colin Ihrig) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`0f14123186`](https://github.com/nodejs/node/commit/0f14123186)] - **deps**: V8: stub backport fast API call changes (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`bf412ed77b`](https://github.com/nodejs/node/commit/bf412ed77b)] - **deps**: V8: stub backport d5b444bc5a84 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`fdaa365b0b`](https://github.com/nodejs/node/commit/fdaa365b0b)] - **deps**: V8: stub backport 65238018ca4b and 8d08318e1a85 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`8198e7882c`](https://github.com/nodejs/node/commit/8198e7882c)] - **deps**: V8: stub backport 9e52d5c5d717 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`a27852ae7c`](https://github.com/nodejs/node/commit/a27852ae7c)] - **deps**: V8: cherry-pick 98b1ef80c722 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`e8c7b7a2df`](https://github.com/nodejs/node/commit/e8c7b7a2df)] - **deps**: V8: cherry-pick b5c917ee80cb (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`552cee0cc0`](https://github.com/nodejs/node/commit/552cee0cc0)] - **deps**: V8: cherry-pick 700b1b97e9ab (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`9b7a1b048a`](https://github.com/nodejs/node/commit/9b7a1b048a)] - **deps**: V8: cherry-pick e8ba5699c648 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`1f02617b05`](https://github.com/nodejs/node/commit/1f02617b05)] - **deps**: V8: cherry-pick 55a01ec7519a (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`da728c482c`](https://github.com/nodejs/node/commit/da728c482c)] - **deps**: V8: cherry-pick 9f0f2cb7f08d (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`2ee8b4a512`](https://github.com/nodejs/node/commit/2ee8b4a512)] - **deps**: V8: cherry-pick e395d1698453 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`dfc66a6af4`](https://github.com/nodejs/node/commit/dfc66a6af4)] - **deps**: V8: cherry-pick d1253ae95b09 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`c3ecbc758b`](https://github.com/nodejs/node/commit/c3ecbc758b)] - **deps**: V8: cherry-pick fa3e37e511ee (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`9568fbc7cd`](https://github.com/nodejs/node/commit/9568fbc7cd)] - **deps**: V8: cherry-pick f0057afc2fb6 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`07d4372d5a`](https://github.com/nodejs/node/commit/07d4372d5a)] - **deps**: V8: cherry-pick 94723c197199 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`4a11a54f9a`](https://github.com/nodejs/node/commit/4a11a54f9a)] - **deps**: V8: backport 844fe8f7d965 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`1b7878558a`](https://github.com/nodejs/node/commit/1b7878558a)] - **deps**: V8: cherry-pick 2db93c023379 (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`122937fc67`](https://github.com/nodejs/node/commit/122937fc67)] - **deps**: V8: cherry-pick 4b1447e4bb0e (Anna Henningsen) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`01573ba4ae`](https://github.com/nodejs/node/commit/01573ba4ae)] - **deps**: remove duplicated postmortem metadata entry (Matheus Marchini) [#32521](https://github.com/nodejs/node/pull/32521)
+* [[`9290febefa`](https://github.com/nodejs/node/commit/9290febefa)] - **deps**: patch V8 to 8.1.307.26 (Matheus Marchini) [#32521](https://github.com/nodejs/node/pull/32521)
+* [[`a9e4cec70d`](https://github.com/nodejs/node/commit/a9e4cec70d)] - ***Revert*** "**deps**: V8: cherry-pick f9257802c1c0" (Matheus Marchini) [#32521](https://github.com/nodejs/node/pull/32521)
+* [[`77542a5d57`](https://github.com/nodejs/node/commit/77542a5d57)] - **deps**: revert whitespace changes on V8 (Matheus Marchini) [#32587](https://github.com/nodejs/node/pull/32587)
+* [[`9add24ecd3`](https://github.com/nodejs/node/commit/9add24ecd3)] - **doc**: missing brackets (William Bonawentura) [#32657](https://github.com/nodejs/node/pull/32657)
+* [[`1796cc0df5`](https://github.com/nodejs/node/commit/1796cc0df5)] - **doc**: improve consistency in usage of NULL (Michael Dawson) [#32726](https://github.com/nodejs/node/pull/32726)
+* [[`2662b0c9e3`](https://github.com/nodejs/node/commit/2662b0c9e3)] - **doc**: improve net docs (Robert Nagy) [#32811](https://github.com/nodejs/node/pull/32811)
+* [[`5d940de17b`](https://github.com/nodejs/node/commit/5d940de17b)] - **doc**: note that signatures of binary may be from subkeys (Reşat SABIQ) [#32591](https://github.com/nodejs/node/pull/32591)
+* [[`3c8dd6d0c3`](https://github.com/nodejs/node/commit/3c8dd6d0c3)] - **doc**: add transform stream destroy() return value (Colin Ihrig) [#32788](https://github.com/nodejs/node/pull/32788)
+* [[`39368b34eb`](https://github.com/nodejs/node/commit/39368b34eb)] - **doc**: updated guidance for n-api changes (Michael Dawson) [#32721](https://github.com/nodejs/node/pull/32721)
+* [[`cba6e5dc09`](https://github.com/nodejs/node/commit/cba6e5dc09)] - **doc**: remove warning from `response.writeHead` (Cecchi MacNaughton) [#32700](https://github.com/nodejs/node/pull/32700)
+* [[`8f7fd8d6aa`](https://github.com/nodejs/node/commit/8f7fd8d6aa)] - **doc**: improve AsyncLocalStorage sample (Andrey Pechkurov) [#32757](https://github.com/nodejs/node/pull/32757)
+* [[`a7c75f956f`](https://github.com/nodejs/node/commit/a7c75f956f)] - **doc**: document `buffer.from` returns internal pool buffer (Harshitha KP) [#32703](https://github.com/nodejs/node/pull/32703)
+* [[`f6a91156c7`](https://github.com/nodejs/node/commit/f6a91156c7)] - **doc**: add puzpuzpuz to collaborators (Andrey Pechkurov) [#32817](https://github.com/nodejs/node/pull/32817)
+* [[`1db8da21f2`](https://github.com/nodejs/node/commit/1db8da21f2)] - **doc**: split process.umask() entry into two (Rich Trott) [#32711](https://github.com/nodejs/node/pull/32711)
+* [[`6ade42bb3c`](https://github.com/nodejs/node/commit/6ade42bb3c)] - **doc**: stream.end(cb) cb can be invoked with error (Pranshu Srivastava) [#32238](https://github.com/nodejs/node/pull/32238)
+* [[`edb3ffb003`](https://github.com/nodejs/node/commit/edb3ffb003)] - **doc**: fix os.version() Windows API (Colin Ihrig) [#32156](https://github.com/nodejs/node/pull/32156)
+* [[`a777cfa843`](https://github.com/nodejs/node/commit/a777cfa843)] - **doc**: remove repetition (Luigi Pinca) [#31868](https://github.com/nodejs/node/pull/31868)
+* [[`7c524fb092`](https://github.com/nodejs/node/commit/7c524fb092)] - **doc**: fix Writable.write callback description (Robert Nagy) [#31812](https://github.com/nodejs/node/pull/31812)
+* [[`43fb664701`](https://github.com/nodejs/node/commit/43fb664701)] - **doc**: fix missing changelog corrections (Myles Borins) [#31854](https://github.com/nodejs/node/pull/31854)
+* [[`a2d6f98e1a`](https://github.com/nodejs/node/commit/a2d6f98e1a)] - **doc**: fix typo (Colin Ihrig) [#31675](https://github.com/nodejs/node/pull/31675)
+* [[`17e3f3be76`](https://github.com/nodejs/node/commit/17e3f3be76)] - **doc**: update pr-url for DEP0022 EOL (Colin Ihrig) [#31675](https://github.com/nodejs/node/pull/31675)
+* [[`cd0f5a239e`](https://github.com/nodejs/node/commit/cd0f5a239e)] - **doc**: update pr-url for DEP0016 EOL (Colin Ihrig) [#31675](https://github.com/nodejs/node/pull/31675)
+* [[`5170daaca5`](https://github.com/nodejs/node/commit/5170daaca5)] - **doc**: fix changelog for v10.18.1 (Andrew Hughes) [#31358](https://github.com/nodejs/node/pull/31358)
+* [[`d845915d46`](https://github.com/nodejs/node/commit/d845915d46)] - **doc**: mark Node.js 8 End-of-Life in CHANGELOG (Beth Griggs) [#31152](https://github.com/nodejs/node/pull/31152)
+* [[`009a9c475b`](https://github.com/nodejs/node/commit/009a9c475b)] - **doc,src,test**: assign missing deprecation code (Colin Ihrig) [#31674](https://github.com/nodejs/node/pull/31674)
+* [[`ed4fbefb71`](https://github.com/nodejs/node/commit/ed4fbefb71)] - **fs**: use finished over destroy w/ cb (Robert Nagy) [#32809](https://github.com/nodejs/node/pull/32809)
+* [[`3e9302b2b3`](https://github.com/nodejs/node/commit/3e9302b2b3)] - **fs**: validate the input data before opening file (Yongsheng Zhang) [#31731](https://github.com/nodejs/node/pull/31731)
+* [[`1a3e358a1d`](https://github.com/nodejs/node/commit/1a3e358a1d)] - **http**: refactor agent 'free' handler (Robert Nagy) [#32801](https://github.com/nodejs/node/pull/32801)
+* [[`399749e4d8`](https://github.com/nodejs/node/commit/399749e4d8)] - **lib**: created isValidCallback helper (Yash Ladha) [#32665](https://github.com/nodejs/node/pull/32665)
+* [[`bc55b57e64`](https://github.com/nodejs/node/commit/bc55b57e64)] - **lib**: fix few comment typos in fs/watchers.js (Denys Otrishko) [#31705](https://github.com/nodejs/node/pull/31705)
+* [[`f98668ade3`](https://github.com/nodejs/node/commit/f98668ade3)] - **module**: remove experimental modules warning (Guy Bedford) [#31974](https://github.com/nodejs/node/pull/31974)
+* [[`fe1bda9aeb`](https://github.com/nodejs/node/commit/fe1bda9aeb)] - **module**: fix memory leak when require error occurs (Qinhui Chen) [#32837](https://github.com/nodejs/node/pull/32837)
+* [[`076ba3150d`](https://github.com/nodejs/node/commit/076ba3150d)] - ***Revert*** "**n-api**: detect deadlocks in thread-safe function" (Gabriel Schulhof) [#32880](https://github.com/nodejs/node/pull/32880)
+* [[`1092bb94f4`](https://github.com/nodejs/node/commit/1092bb94f4)] - **process**: suggest --trace-warnings when printing warning (Anna Henningsen) [#32797](https://github.com/nodejs/node/pull/32797)
+* [[`d19a2c33b3`](https://github.com/nodejs/node/commit/d19a2c33b3)] - **src**: migrate measureMemory to new v8 api (gengjiawen) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`a63db7fb5e`](https://github.com/nodejs/node/commit/a63db7fb5e)] - **src**: remove deprecated wasm type check (Clemens Backes) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`c080b2d821`](https://github.com/nodejs/node/commit/c080b2d821)] - **src**: avoid calling deprecated method (Clemens Backes) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`7ed0d1439e`](https://github.com/nodejs/node/commit/7ed0d1439e)] - **src**: remove use of deprecated Symbol::Name() (Colin Ihrig) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`59eeb3b5b9`](https://github.com/nodejs/node/commit/59eeb3b5b9)] - **src**: stop overriding deprecated V8 methods (Clemens Backes) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`339c192ddb`](https://github.com/nodejs/node/commit/339c192ddb)] - **src**: update NODE\_MODULE\_VERSION to 83 (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`6681a685a9`](https://github.com/nodejs/node/commit/6681a685a9)] - **src**: remove unused using in node\_worker.cc (Daniel Bevenius) [#32840](https://github.com/nodejs/node/pull/32840)
+* [[`b9d9f91a80`](https://github.com/nodejs/node/commit/b9d9f91a80)] - **src**: use basename(argv0) for --trace-uncaught suggestion (Anna Henningsen) [#32798](https://github.com/nodejs/node/pull/32798)
+* [[`24e1e28b38`](https://github.com/nodejs/node/commit/24e1e28b38)] - **src**: ignore GCC -Wcast-function-type for v8.h (Daniel Bevenius) [#32679](https://github.com/nodejs/node/pull/32679)
+* [[`a946189ccd`](https://github.com/nodejs/node/commit/a946189ccd)] - **src**: add AliasedStruct utility (James M Snell) [#32778](https://github.com/nodejs/node/pull/32778)
+* [[`457f1f1ed0`](https://github.com/nodejs/node/commit/457f1f1ed0)] - **src**: remove unused v8 Array namespace (Juan José Arboleda) [#32749](https://github.com/nodejs/node/pull/32749)
+* [[`b68e26ee70`](https://github.com/nodejs/node/commit/b68e26ee70)] - **src**: flush V8 interrupts from Environment dtor (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
+* [[`96bf137cca`](https://github.com/nodejs/node/commit/96bf137cca)] - **src**: use env-\>RequestInterrupt() for inspector MainThreadInterface (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
+* [[`72da426780`](https://github.com/nodejs/node/commit/72da426780)] - **src**: use env-\>RequestInterrupt() for inspector io thread start (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
+* [[`99c9b2368c`](https://github.com/nodejs/node/commit/99c9b2368c)] - **src**: fix cleanup hook removal for InspectorTimer (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
+* [[`6dffd6b3de`](https://github.com/nodejs/node/commit/6dffd6b3de)] - **src**: make `Environment::interrupt\_data\_` atomic (Anna Henningsen) [#32523](https://github.com/nodejs/node/pull/32523)
+* [[`8c5ad1392f`](https://github.com/nodejs/node/commit/8c5ad1392f)] - **src**: initialize inspector before RunBootstrapping() (Anna Henningsen) [#32672](https://github.com/nodejs/node/pull/32672)
+* [[`eafd64b1c8`](https://github.com/nodejs/node/commit/eafd64b1c8)] - **src**: consistently declare BindingData class (Sam Roberts) [#32677](https://github.com/nodejs/node/pull/32677)
+* [[`78c82a38ac`](https://github.com/nodejs/node/commit/78c82a38ac)] - **src**: move fs state out of Environment (Anna Henningsen) [#32538](https://github.com/nodejs/node/pull/32538)
+* [[`7005670f34`](https://github.com/nodejs/node/commit/7005670f34)] - **src**: move http parser state out of Environment (Anna Henningsen) [#32538](https://github.com/nodejs/node/pull/32538)
+* [[`19b671506c`](https://github.com/nodejs/node/commit/19b671506c)] - **src**: move v8 stats buffers out of Environment (Anna Henningsen) [#32538](https://github.com/nodejs/node/pull/32538)
+* [[`4df24f040d`](https://github.com/nodejs/node/commit/4df24f040d)] - **src**: move HTTP/2 state out of Environment (Anna Henningsen) [#32538](https://github.com/nodejs/node/pull/32538)
+* [[`1fc3de908e`](https://github.com/nodejs/node/commit/1fc3de908e)] - **src**: make creating per-binding data structures easier (Anna Henningsen) [#32538](https://github.com/nodejs/node/pull/32538)
+* [[`0e9f9b7592`](https://github.com/nodejs/node/commit/0e9f9b7592)] - **src**: include AsyncWrap provider strings in snapshot (Anna Henningsen) [#32572](https://github.com/nodejs/node/pull/32572)
+* [[`effebf87ab`](https://github.com/nodejs/node/commit/effebf87ab)] - **src**: remove unused v8 namespace (Juan José Arboleda) [#32375](https://github.com/nodejs/node/pull/32375)
+* [[`d23eed256b`](https://github.com/nodejs/node/commit/d23eed256b)] - **src**: remove calls to deprecated ArrayBuffer methods (Michaël Zasso) [#32358](https://github.com/nodejs/node/pull/32358)
+* [[`f3682102dc`](https://github.com/nodejs/node/commit/f3682102dc)] - **src**: give Http2Session JS fields their own backing store (Anna Henningsen) [#31648](https://github.com/nodejs/node/pull/31648)
+* [[`90f7a5c010`](https://github.com/nodejs/node/commit/90f7a5c010)] - **src**: set arraybuffer\_untransferable\_private\_symbol (Thang Tran) [#31053](https://github.com/nodejs/node/pull/31053)
+* [[`d06efafe6b`](https://github.com/nodejs/node/commit/d06efafe6b)] - **src**: explicitly allocate backing stores for v8 stat buffers (Anna Henningsen) [#30946](https://github.com/nodejs/node/pull/30946)
+* [[`917fedd21a`](https://github.com/nodejs/node/commit/917fedd21a)] - **src**: unset NODE\_VERSION\_IS\_RELEASE from master (Michaël Zasso) [#30584](https://github.com/nodejs/node/pull/30584)
+* [[`69f19f4ccd`](https://github.com/nodejs/node/commit/69f19f4ccd)] - **src**: remove uses of deprecated wasm TransferrableModule (Clemens Backes) [#30026](https://github.com/nodejs/node/pull/30026)
+* [[`acac5df260`](https://github.com/nodejs/node/commit/acac5df260)] - **src,doc**: add documentation for per-binding state pattern (Anna Henningsen) [#32538](https://github.com/nodejs/node/pull/32538)
+* [[`ad4c10e824`](https://github.com/nodejs/node/commit/ad4c10e824)] - **stream**: improve comments regarding end() errors (Robert Nagy) [#32839](https://github.com/nodejs/node/pull/32839)
+* [[`6e5c23b6c8`](https://github.com/nodejs/node/commit/6e5c23b6c8)] - **stream**: update comment to indicate unused API (Robert Nagy) [#32808](https://github.com/nodejs/node/pull/32808)
+* [[`21bd6679ce`](https://github.com/nodejs/node/commit/21bd6679ce)] - **stream**: fix finished typo (Robert Nagy) [#31881](https://github.com/nodejs/node/pull/31881)
+* [[`85c6fcd1cd`](https://github.com/nodejs/node/commit/85c6fcd1cd)] - **stream**: avoid writing to writable (Robert Nagy) [#31805](https://github.com/nodejs/node/pull/31805)
+* [[`0875837417`](https://github.com/nodejs/node/commit/0875837417)] - **stream**: fix async iterator destroyed error order (Robert Nagy) [#31700](https://github.com/nodejs/node/pull/31700)
+* [[`b9a7625fdf`](https://github.com/nodejs/node/commit/b9a7625fdf)] - **stream**: removed outdated TODO (Robert Nagy) [#31701](https://github.com/nodejs/node/pull/31701)
+* [[`68e1288e00`](https://github.com/nodejs/node/commit/68e1288e00)] - **test**: mark addons/zlib-bindings/test flaky on arm (Michaël Zasso) [#32885](https://github.com/nodejs/node/pull/32885)
+* [[`a09bf3ad5f`](https://github.com/nodejs/node/commit/a09bf3ad5f)] - **test**: replace console.log/error() with debuglog (daemon1024) [#32692](https://github.com/nodejs/node/pull/32692)
+* [[`d1b41bbd86`](https://github.com/nodejs/node/commit/d1b41bbd86)] - **test**: only detect uname on supported os (Xu Meng) [#32833](https://github.com/nodejs/node/pull/32833)
+* [[`4bb29ed044`](https://github.com/nodejs/node/commit/4bb29ed044)] - **test**: mark cpu-prof-dir-worker flaky on all (Sam Roberts) [#32828](https://github.com/nodejs/node/pull/32828)
+* [[`e18a40e42d`](https://github.com/nodejs/node/commit/e18a40e42d)] - **test**: replace equal with strictEqual (Jesus Hernandez) [#32727](https://github.com/nodejs/node/pull/32727)
+* [[`320f297a35`](https://github.com/nodejs/node/commit/320f297a35)] - **test**: mark test-worker-prof flaky on arm (Sam Roberts) [#32826](https://github.com/nodejs/node/pull/32826)
+* [[`4b5658b536`](https://github.com/nodejs/node/commit/4b5658b536)] - **test**: mark test-http2-reset-flood flaky on all (Sam Roberts) [#32825](https://github.com/nodejs/node/pull/32825)
+* [[`ead51be541`](https://github.com/nodejs/node/commit/ead51be541)] - **test**: cover node entry type in perf\_hooks (Julian Duque) [#32751](https://github.com/nodejs/node/pull/32751)
+* [[`9e5189a560`](https://github.com/nodejs/node/commit/9e5189a560)] - **test**: use symlinks to copy shells (John Kleinschmidt) [#32129](https://github.com/nodejs/node/pull/32129)
+* [[`c5763e8dc1`](https://github.com/nodejs/node/commit/c5763e8dc1)] - **test**: wait for message from parent in embedding cctest (Anna Henningsen) [#32563](https://github.com/nodejs/node/pull/32563)
+* [[`c3204a8787`](https://github.com/nodejs/node/commit/c3204a8787)] - **test**: use common.buildType in embedding test (Anna Henningsen) [#32422](https://github.com/nodejs/node/pull/32422)
+* [[`f2cc28aec3`](https://github.com/nodejs/node/commit/f2cc28aec3)] - **test**: use InitializeNodeWithArgs in cctest (Anna Henningsen) [#32406](https://github.com/nodejs/node/pull/32406)
+* [[`df1592d2e9`](https://github.com/nodejs/node/commit/df1592d2e9)] - **test**: async iterate destroyed stream (Robert Nagy) [#28995](https://github.com/nodejs/node/pull/28995)
+* [[`5100e84f4b`](https://github.com/nodejs/node/commit/5100e84f4b)] - **test**: fix flaky test-fs-promises-file-handle-close (Anna Henningsen) [#31687](https://github.com/nodejs/node/pull/31687)
+* [[`52944b834a`](https://github.com/nodejs/node/commit/52944b834a)] - **test**: remove test (Clemens Backes) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`119fdf6813`](https://github.com/nodejs/node/commit/119fdf6813)] - **test**: remove checks for deserializing wasm (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`add5f6e5cd`](https://github.com/nodejs/node/commit/add5f6e5cd)] - **tls**: provide default cipher list from command line (Anna Henningsen) [#32760](https://github.com/nodejs/node/pull/32760)
+* [[`405ae1909b`](https://github.com/nodejs/node/commit/405ae1909b)] - **tools**: update V8 gypfiles for 8.1 (Matheus Marchini) [#32116](https://github.com/nodejs/node/pull/32116)
+* [[`7fe61222ef`](https://github.com/nodejs/node/commit/7fe61222ef)] - **worker**: mention argument name in type check message (Anna Henningsen) [#32815](https://github.com/nodejs/node/pull/32815)
+* [[`7147df53e8`](https://github.com/nodejs/node/commit/7147df53e8)] - **worker**: fix type check in receiveMessageOnPort (Anna Henningsen) [#32745](https://github.com/nodejs/node/pull/32745)
+* [[`0c545f0f72`](https://github.com/nodejs/node/commit/0c545f0f72)] - **zlib**: emits 'close' event after readable 'end' (Sergey Zelenov) [#32050](https://github.com/nodejs/node/pull/32050)
diff --git a/doc/changelogs/CHANGELOG_V4.md b/doc/changelogs/CHANGELOG_V4.md
index 06d8b90a598f1ab3fa3c966a6e314b8c6dce85d2..69f36cf2cea9d94cde3245a10d558429b52f08e5 100644
--- a/doc/changelogs/CHANGELOG_V4.md
+++ b/doc/changelogs/CHANGELOG_V4.md
@@ -58,6 +58,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
diff --git a/doc/changelogs/CHANGELOG_V5.md b/doc/changelogs/CHANGELOG_V5.md
index 7c290223be4b3a82b8a45fa0fea66f88585c51da..c9cd28d692bfaf6e08d4cfd4cb9c7a89f19bb958 100644
--- a/doc/changelogs/CHANGELOG_V5.md
+++ b/doc/changelogs/CHANGELOG_V5.md
@@ -34,6 +34,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
diff --git a/doc/changelogs/CHANGELOG_V6.md b/doc/changelogs/CHANGELOG_V6.md
index 7f8ea30191c190ee5cf0e9a86f81aeab4e93fc05..20c9370ff0d5ab2a86df1bde3d83a5b2d9c7a40b 100644
--- a/doc/changelogs/CHANGELOG_V6.md
+++ b/doc/changelogs/CHANGELOG_V6.md
@@ -63,6 +63,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
diff --git a/doc/changelogs/CHANGELOG_V7.md b/doc/changelogs/CHANGELOG_V7.md
index ad42d662828d8592eedbab53d5ee49fd1c21f2b5..a64b973c8c21929364d2fb8f53f89a0a630f62d5 100644
--- a/doc/changelogs/CHANGELOG_V7.md
+++ b/doc/changelogs/CHANGELOG_V7.md
@@ -32,6 +32,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
diff --git a/doc/changelogs/CHANGELOG_V8.md b/doc/changelogs/CHANGELOG_V8.md
index 4ac6e71abf3fc73a45e76844fa9cb9e2eec30bb4..41e38efcf572063b39f26a1e05f731943126bff3 100644
--- a/doc/changelogs/CHANGELOG_V8.md
+++ b/doc/changelogs/CHANGELOG_V8.md
@@ -11,6 +11,9 @@
 </tr>
 <tr>
 <td valign="top">
+<a href="#8.17.0">8.17.0</a><br/>
+<a href="#8.16.2">8.16.2</a><br/>
+<a href="#8.16.1">8.16.1</a><br/>
 <a href="#8.16.0">8.16.0</a><br/>
 <a href="#8.15.1">8.15.1</a><br/>
 <a href="#8.15.0">8.15.0</a><br/>
@@ -51,6 +54,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
@@ -68,6 +73,104 @@
 [Node.js Long Term Support Plan](https://github.com/nodejs/LTS) and
 will be supported actively until April 2019 and maintained until December 2019.
 
+<a id="8.17.0"></a>
+## 2019-12-17, Version 8.17.0 'Carbon' (LTS), @MylesBorins
+
+This is a security release.
+
+For more details about the vulnerability please consult the npm blog:
+
+https://blog.npmjs.org/post/189618601100/binary-planting-with-the-npm-cli
+
+### Notable changes
+
+* **deps**: update npm to 6.13.4 [#30904](https://github.com/nodejs/node/pull/30904)
+
+### Commits
+
+* [[`208b813e49`](https://github.com/nodejs/node/commit/208b813e49)] - **build,win**: add test-ci-native and test-ci-js (João Reis) [#30724](https://github.com/nodejs/node/pull/30724)
+* [[`369a23a670`](https://github.com/nodejs/node/commit/369a23a670)] - **deps**: update npm to 6.13.4 (Audrey Eschright) [#30904](https://github.com/nodejs/node/pull/30904)
+
+<a id="8.16.2"></a>
+## 2019-10-09, Version 8.16.2 'Carbon' (LTS), @BethGriggs
+
+Node.js 8 is due to go End-of-Life on 31st December 2019.
+
+### Notable changes
+
+* **deps**: upgrade openssl sources to 1.0.2s (Sam Roberts) [#28230](https://github.com/nodejs/node/pull/28230)
+
+### Commits
+
+* [[`cc9d005628`](https://github.com/nodejs/node/commit/cc9d005628)] - **crypto**: update root certificates (Sam Roberts) [#28808](https://github.com/nodejs/node/pull/28808)
+* [[`347fcd35e3`](https://github.com/nodejs/node/commit/347fcd35e3)] - **crypto**: update root certificates (Sam Roberts) [#27374](https://github.com/nodejs/node/pull/27374)
+* [[`b2a6b3254d`](https://github.com/nodejs/node/commit/b2a6b3254d)] - **crypto**: update root certificates (Sam Roberts) [#25113](https://github.com/nodejs/node/pull/25113)
+* [[`5682e50325`](https://github.com/nodejs/node/commit/5682e50325)] - **deps**: add -no\_rand\_screen to openssl s\_client (Shigeki Ohtsu) [nodejs/io.js#1836](https://github.com/nodejs/io.js/pull/1836)
+* [[`9663ae3546`](https://github.com/nodejs/node/commit/9663ae3546)] - **deps**: fix asm build error of openssl in x86\_win32 (Shigeki Ohtsu) [iojs/io.js#1389](https://github.com/iojs/io.js/pull/1389)
+* [[`87eee99466`](https://github.com/nodejs/node/commit/87eee99466)] - **deps**: fix openssl assembly error on ia32 win32 (Fedor Indutny) [iojs/io.js#1389](https://github.com/iojs/io.js/pull/1389)
+* [[`da99d3f972`](https://github.com/nodejs/node/commit/da99d3f972)] - **deps**: copy all openssl header files to include dir (Sam Roberts) [#28230](https://github.com/nodejs/node/pull/28230)
+* [[`dc9d645ac4`](https://github.com/nodejs/node/commit/dc9d645ac4)] - **deps**: upgrade openssl sources to 1.0.2s (Sam Roberts) [#28230](https://github.com/nodejs/node/pull/28230)
+* [[`37e24b19a0`](https://github.com/nodejs/node/commit/37e24b19a0)] - **deps**: V8: backport d520ebb (Michaël Zasso) [#27358](https://github.com/nodejs/node/pull/27358)
+* [[`1a5dc6a3e7`](https://github.com/nodejs/node/commit/1a5dc6a3e7)] - **http**: check for existance in resetHeadersTimeoutOnReqEnd (Matteo Collina) [#26402](https://github.com/nodejs/node/pull/26402)
+* [[`e45b6a3b98`](https://github.com/nodejs/node/commit/e45b6a3b98)] - **http2**: do not start reading after write if new write is on wire (Anna Henningsen) [#29399](https://github.com/nodejs/node/pull/29399)
+* [[`559a8e342b`](https://github.com/nodejs/node/commit/559a8e342b)] - **http2**: do not crash on stream listener removal w/ destroyed session (Anna Henningsen) [#29459](https://github.com/nodejs/node/pull/29459)
+* [[`dd285968c4`](https://github.com/nodejs/node/commit/dd285968c4)] - **openssl**: fix keypress requirement in apps on win32 (Shigeki Ohtsu) [iojs/io.js#1389](https://github.com/iojs/io.js/pull/1389)
+* [[`3ee076f03d`](https://github.com/nodejs/node/commit/3ee076f03d)] - **stream**: ensure writable.destroy() emits error once (Luigi Pinca) [#26057](https://github.com/nodejs/node/pull/26057)
+* [[`a7e5fe1f06`](https://github.com/nodejs/node/commit/a7e5fe1f06)] - **test**: unskip tests that now pass on AIX (Sam Roberts) [#29054](https://github.com/nodejs/node/pull/29054)
+* [[`65e9b0f5a2`](https://github.com/nodejs/node/commit/65e9b0f5a2)] - **test**: specialize OOM check for AIX (Sam Roberts) [#28857](https://github.com/nodejs/node/pull/28857)
+* [[`7aca9cb09b`](https://github.com/nodejs/node/commit/7aca9cb09b)] - **test**: fix pty test hangs on aix (Ben Noordhuis) [#28600](https://github.com/nodejs/node/pull/28600)
+* [[`588b761fca`](https://github.com/nodejs/node/commit/588b761fca)] - **test**: skip stringbytes-external-exceed-max on AIX (Sam Roberts) [#28516](https://github.com/nodejs/node/pull/28516)
+* [[`930647d0fe`](https://github.com/nodejs/node/commit/930647d0fe)] - **test**: skip tests related to CI failures on AIX (Sam Roberts) [#28469](https://github.com/nodejs/node/pull/28469)
+* [[`92a2f8bbe3`](https://github.com/nodejs/node/commit/92a2f8bbe3)] - **test,win**: cleanup exec-timeout processes (João Reis) [#28723](https://github.com/nodejs/node/pull/28723)
+* [[`d57f79726d`](https://github.com/nodejs/node/commit/d57f79726d)] - **tls**: partially backport pull request #26415 (Ben Noordhuis) [#26415](https://github.com/nodejs/node/pull/26415)
+* [[`c582fef5cc`](https://github.com/nodejs/node/commit/c582fef5cc)] - **tools**: update certdata.txt (Sam Roberts) [#28808](https://github.com/nodejs/node/pull/28808)
+* [[`4fbadf6a9e`](https://github.com/nodejs/node/commit/4fbadf6a9e)] - **tools**: update certdata.txt (Sam Roberts) [#27374](https://github.com/nodejs/node/pull/27374)
+* [[`529b2ad25f`](https://github.com/nodejs/node/commit/529b2ad25f)] - **tools**: update certdata.txt (Sam Roberts) [#25113](https://github.com/nodejs/node/pull/25113)
+
+<a id="8.16.1"></a>
+## 2019-08-15, Version 8.16.1 'Carbon' (LTS), @BethGriggs
+
+### Notable changes
+
+This is a security release.
+
+Node.js, as well as many other implementations of HTTP/2, have been found
+vulnerable to Denial of Service attacks.
+See https://github.com/Netflix/security-bulletins/blob/master/advisories/third-party/2019-002.md
+for more information.
+
+Vulnerabilities fixed:
+
+* **CVE-2019-9511 “Data Dribble”**: The attacker requests a large amount of data from a specified resource over multiple streams. They manipulate window size and stream priority to force the server to queue the data in 1-byte chunks. Depending on how efficiently this data is queued, this can consume excess CPU, memory, or both, potentially leading to a denial of service.
+* **CVE-2019-9512 “Ping Flood”**: The attacker sends continual pings to an HTTP/2 peer, causing the peer to build an internal queue of responses. Depending on how efficiently this data is queued, this can consume excess CPU, memory, or both, potentially leading to a denial of service.
+* **CVE-2019-9513 “Resource Loop”**: The attacker creates multiple request streams and continually shuffles the priority of the streams in a way that causes substantial churn to the priority tree. This can consume excess CPU, potentially leading to a denial of service.
+* **CVE-2019-9514 “Reset Flood”**: The attacker opens a number of streams and sends an invalid request over each stream that should solicit a stream of RST_STREAM frames from the peer. Depending on how the peer queues the RST_STREAM frames, this can consume excess memory, CPU, or both, potentially leading to a denial of service.
+* **CVE-2019-9515 “Settings Flood”**: The attacker sends a stream of SETTINGS frames to the peer. Since the RFC requires that the peer reply with one acknowledgement per SETTINGS frame, an empty SETTINGS frame is almost equivalent in behavior to a ping. Depending on how efficiently this data is queued, this can consume excess CPU, memory, or both, potentially leading to a denial of service.
+* **CVE-2019-9516 “0-Length Headers Leak”**: The attacker sends a stream of headers with a 0-length header name and 0-length header value, optionally Huffman encoded into 1-byte or greater headers. Some implementations allocate memory for these headers and keep the allocation alive until the session dies. This can consume excess memory, potentially leading to a denial of service.
+* **CVE-2019-9517 “Internal Data Buffering”**: The attacker opens the HTTP/2 window so the peer can send without constraint; however, they leave the TCP window closed so the peer cannot actually write (many of) the bytes on the wire. The attacker then sends a stream of requests for a large response object. Depending on how the servers queue the responses, this can consume excess memory, CPU, or both, potentially leading to a denial of service.
+* **CVE-2019-9518 “Empty Frames Flood”**: The attacker sends a stream of frames with an empty payload and without the end-of-stream flag. These frames can be DATA, HEADERS, CONTINUATION and/or PUSH_PROMISE. The peer spends time processing each frame disproportionate to attack bandwidth. This can consume excess CPU, potentially leading to a denial of service. (Discovered by Piotr Sikora of Google)
+
+### Commits
+
+* [[`6d427378c0`](https://github.com/nodejs/node/commit/6d427378c0)] - **deps**: update nghttp2 to 1.39.2 (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`33d4d916d5`](https://github.com/nodejs/node/commit/33d4d916d5)] - **deps**: update nghttp2 to 1.39.1 (gengjiawen) [#28448](https://github.com/nodejs/node/pull/28448)
+* [[`17fad97113`](https://github.com/nodejs/node/commit/17fad97113)] - **deps**: update nghttp2 to 1.38.0 (gengjiawen) [#27295](https://github.com/nodejs/node/pull/27295)
+* [[`0b44733695`](https://github.com/nodejs/node/commit/0b44733695)] - **deps**: update nghttp2 to 1.37.0 (gengjiawen) [#26990](https://github.com/nodejs/node/pull/26990)
+* [[`5afc77b044`](https://github.com/nodejs/node/commit/5afc77b044)] - **deps**: update nghttp2 to 1.34.0 (James M Snell) [#23284](https://github.com/nodejs/node/pull/23284)
+* [[`073108c855`](https://github.com/nodejs/node/commit/073108c855)] - **http2**: allow security revert for Ping/Settings Flood (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`6d687f7af8`](https://github.com/nodejs/node/commit/6d687f7af8)] - **http2**: pause input processing if sending output (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`854dba649e`](https://github.com/nodejs/node/commit/854dba649e)] - **http2**: stop reading from socket if writes are in progress (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`a3191689dd`](https://github.com/nodejs/node/commit/a3191689dd)] - **http2**: consider 0-length non-end DATA frames an error (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`156f2f35df`](https://github.com/nodejs/node/commit/156f2f35df)] - **http2**: shrink default `vector::reserve()` allocations (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`10f05b65c4`](https://github.com/nodejs/node/commit/10f05b65c4)] - **http2**: handle 0-length headers better (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`ac28a628a5`](https://github.com/nodejs/node/commit/ac28a628a5)] - **http2**: limit number of invalid incoming frames (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`11b4e2c0db`](https://github.com/nodejs/node/commit/11b4e2c0db)] - **http2**: limit number of rejected stream openings (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`7de642b6f9`](https://github.com/nodejs/node/commit/7de642b6f9)] - **http2**: do not create ArrayBuffers when no DATA received (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`dd60d3561a`](https://github.com/nodejs/node/commit/dd60d3561a)] - **http2**: only call into JS when necessary for session events (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`00f6846b73`](https://github.com/nodejs/node/commit/00f6846b73)] - **http2**: improve JS-side debug logging (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+* [[`b095e35f1f`](https://github.com/nodejs/node/commit/b095e35f1f)] - **http2**: improve http2 code a bit (James M Snell) [#23984](https://github.com/nodejs/node/pull/23984)
+* [[`cc282239c1`](https://github.com/nodejs/node/commit/cc282239c1)] - **test**: apply test-http2-max-session-memory-leak from v12.x (Anna Henningsen) [#29122](https://github.com/nodejs/node/pull/29122)
+
 <a id="8.16.0"></a>
 ## 2019-04-16, Version 8.16.0 'Carbon' (LTS), @MylesBorins
 
diff --git a/doc/changelogs/CHANGELOG_V9.md b/doc/changelogs/CHANGELOG_V9.md
index 859e654f63bf7a051045e6ea48c89fd605bf2e8e..e4cdf50a9381b62ef8e526bd72a07546337a0375 100644
--- a/doc/changelogs/CHANGELOG_V9.md
+++ b/doc/changelogs/CHANGELOG_V9.md
@@ -33,6 +33,8 @@
 </table>
 
 * Other Versions
+  * [14.x](CHANGELOG_V14.md)
+  * [13.x](CHANGELOG_V13.md)
   * [12.x](CHANGELOG_V12.md)
   * [11.x](CHANGELOG_V11.md)
   * [10.x](CHANGELOG_V10.md)
diff --git a/doc/guides/adding-new-napi-api.md b/doc/guides/adding-new-napi-api.md
index 825b4877783f9b4e1846a3b033c3a4d5b300e3ec..18f551929e4e035f964fd02bf6033061e0968db6 100644
--- a/doc/guides/adding-new-napi-api.md
+++ b/doc/guides/adding-new-napi-api.md
@@ -1,20 +1,20 @@
-# Contributing a new API to N-API
+# Contributing a new API to Node-API
 
-N-API is the next-generation ABI-stable API for native modules.
+Node-API is the next-generation ABI-stable API for native modules.
 While improving the API surface is encouraged and welcomed, the following are
 a set of principles and guidelines to keep in mind while adding a new
-N-API API.
+Node-API.
 
-* A new API **must** adhere to N-API API shape and spirit.
+* A new API **must** adhere to Node-API API shape and spirit.
   * **Must** be a C API.
   * **Must** not throw exceptions.
   * **Must** return `napi_status`.
   * **Should** consume `napi_env`.
   * **Must** operate only on primitive data types, pointers to primitive
-    datatypes or opaque handles.
+    data types or opaque handles.
   * **Must** be a necessary API and not a nice to have. Convenience APIs
     belong in node-addon-api.
-  * **Must** not change the signature of an existing N-API API or break
+  * **Must** not change the signature of an existing Node-API API or break
     ABI compatibility with other versions of Node.js.
 * New API **should** be agnostic towards the underlying JavaScript VM.
 * New API PRs **must** have a corresponding documentation update.
@@ -23,9 +23,9 @@ N-API API.
 * There **should** be at least one test case per interesting use of the API.
 * There **should** be a sample provided that operates in a realistic way
   (operating how a real addon would be written).
-* A new API **should** be discussed at the N-API team meeting.
+* A new API **should** be discussed at the Node-API team meeting.
 * A new API addition **must** be signed off by at least two members of
-  the N-API team.
+  the Node-API team.
 * A new API addition **should** be simultaneously implemented in at least
   one other VM implementation of Node.js.
 * A new API **must** be considered experimental for at least one minor
diff --git a/doc/guides/backporting-to-release-lines.md b/doc/guides/backporting-to-release-lines.md
index 90b4a3dcaf328c981043edcb435b71ec6fe34895..5233173c882557b46798f62526a30c7f62306052 100644
--- a/doc/guides/backporting-to-release-lines.md
+++ b/doc/guides/backporting-to-release-lines.md
@@ -1,4 +1,4 @@
-# How to Backport a Pull Request to a Release Line
+# How to backport a pull request to a release line
 
 ## Staging branches
 
@@ -77,7 +77,8 @@ replace that with the staging branch for the targeted release line.
    1. Include the backport target in the pull request title in the following
       format: `[v10.x backport] <commit title>`.
       Example: `[v10.x backport] process: improve performance of nextTick`
-   1. Check the checkbox labeled "Allow edits from maintainers".
+   1. Check the checkbox labeled "Allow edits and access to secrets by
+      maintainers".
    1. In the description add a reference to the original pull request.
    1. Amend the commit message and include a `Backport-PR-URL:` metadata and
       re-push the change to your fork.
@@ -90,5 +91,5 @@ After the pull request lands, replace the `backport-requested-v10.x` label
 on the original pull request with `backported-to-v10.x`.
 
 [Release Plan]: https://github.com/nodejs/Release#release-plan
-[Release Schedule]: https://github.com/nodejs/Release#release-schedule1
+[Release Schedule]: https://github.com/nodejs/Release#release-schedule
 [`node-test-pull-request`]: https://ci.nodejs.org/job/node-test-pull-request/build
diff --git a/doc/guides/collaborator-guide.md b/doc/guides/collaborator-guide.md
index b6080292713fddba159db6fd0ac7854cb216798c..3ce33be392915c28fb01b5bcca0b1f193d4bfeb1 100644
--- a/doc/guides/collaborator-guide.md
+++ b/doc/guides/collaborator-guide.md
@@ -1,4 +1,4 @@
-# Node.js Collaborator Guide
+# Node.js collaborator guide
 
 ## Contents
 
@@ -7,13 +7,14 @@
   * [Closing issues and pull requests](#closing-issues-and-pull-requests)
   * [Author ready pull requests](#author-ready-pull-requests)
   * [Handling own pull requests](#handling-own-pull-requests)
+  * [Security issues](#managing-security-issues)
 * [Accepting modifications](#accepting-modifications)
   * [Code reviews](#code-reviews)
   * [Consensus seeking](#consensus-seeking)
   * [Waiting for approvals](#waiting-for-approvals)
   * [Testing and CI](#testing-and-ci)
-    * [Useful CI jobs](#useful-ci-jobs)
-    * [Starting a CI job](#starting-a-ci-job)
+    * [Useful Jenkins CI jobs](#useful-jenkins-ci-jobs)
+    * [Starting a Jenkins CI job](#starting-a-jenkins-ci-job)
   * [Internal vs. public API](#internal-vs-public-api)
   * [Breaking changes](#breaking-changes)
     * [Breaking changes and deprecations](#breaking-changes-and-deprecations)
@@ -21,7 +22,7 @@
     * [Unintended breaking changes](#unintended-breaking-changes)
       * [Reverting commits](#reverting-commits)
   * [Introducing new modules](#introducing-new-modules)
-  * [Additions to N-API](#additions-to-n-api)
+  * [Additions to Node-API](#additions-to-n-api)
   * [Deprecations](#deprecations)
   * [Involving the TSC](#involving-the-tsc)
 * [Landing pull requests](#landing-pull-requests)
@@ -29,20 +30,20 @@
   * [Technical HOWTO](#technical-howto)
   * [Troubleshooting](#troubleshooting)
   * [I made a mistake](#i-made-a-mistake)
-  * [Long term support](#long-term-support)
+  * [Long Term Support](#long-term-support)
     * [What is LTS?](#what-is-lts)
     * [How are LTS branches managed?](#how-are-lts-branches-managed)
     * [How can I help?](#how-can-i-help)
 * [Who to CC in the issue tracker](#who-to-cc-in-the-issue-tracker)
 
-This document explains how Collaborators manage the Node.js project.
+This document explains how collaborators manage the Node.js project.
 Collaborators should understand the
 [guidelines for new contributors](../../CONTRIBUTING.md) and the
 [project governance model](../../GOVERNANCE.md).
 
 ## Issues and pull requests
 
-Mind these guidelines, the opinions of other Collaborators, and guidance of the
+Mind these guidelines, the opinions of other collaborators, and guidance of the
 [TSC][]. Notify other qualified parties for more input on an issue or a pull
 request. See [Who to CC in the issue tracker](#who-to-cc-in-the-issue-tracker).
 
@@ -70,7 +71,7 @@ issues and pull requests can always be re-opened if necessary.
 A pull request is _author ready_ when:
 
 * There is a CI run in progress or completed.
-* There is at least one Collaborator approval.
+* There is at least one collaborator approval.
 * There are no outstanding review comments.
 
 Please always add the `author ready` label to the pull request in that case.
@@ -82,33 +83,55 @@ When you open a pull request, [start a CI](#testing-and-ci) right away. Later,
 after new code changes or rebasing, start a new CI.
 
 As soon as the pull request is ready to land, please do so. This allows other
-Collaborators to focus on other pull requests. If your pull request is not ready
+collaborators to focus on other pull requests. If your pull request is not ready
 to land but is [author ready](#author-ready-pull-requests), add the
 `author ready` label. If you wish to land the pull request yourself, use the
 "assign yourself" link to self-assign it.
 
+### Managing security issues
+
+Use the process outlined in [SECURITY.md][] to report security
+issues. If a user opens a security issue in the public repository:
+
+* Ask the user to submit a report through HackerOne as outlined in
+  [SECURITY.md][].
+* Move the issue to the private repository called
+  [premature-disclosures](https://github.com/nodejs/premature-disclosures).
+* For any related pull requests, create an associated issue in the
+  `premature-disclosures` repository.  Add a copy of the patch for the
+  pull request to the issue. Add screenshots of discussion from the pull request
+  to the issue.
+* [Open a ticket with GitHub](https://support.github.com/contact) to delete the
+  pull request using Node.js (team) as the account organization.
+* Open a new issue in the public repository with the title `FYI - pull request
+  deleted #YYYY`. Include an explanation for the user:
+  > FYI @xxxx we asked GitHub to delete your pull request while we work on
+  > releases in private.
+* Email `tsc@iojs.org` with links to the issues in the
+  `premature-disclosures` repository.
+
 ## Accepting modifications
 
 Contributors propose modifications to Node.js using GitHub pull requests. This
-includes modifications proposed by TSC members and other Collaborators. A pull
+includes modifications proposed by TSC members and other collaborators. A pull
 request must pass code review and CI before landing into the codebase.
 
 ### Code reviews
 
-At least two Collaborators must approve a pull request before the pull request
-lands. One Collaborator approval is enough if the pull request has been open
+At least two collaborators must approve a pull request before the pull request
+lands. One collaborator approval is enough if the pull request has been open
 for more than seven days.
 
-Approving a pull request indicates that the Collaborator accepts responsibility
+Approving a pull request indicates that the collaborator accepts responsibility
 for the change.
 
-Approval must be from Collaborators who are not authors of the change.
+Approval must be from collaborators who are not authors of the change.
 
 In some cases, it might be necessary to summon a GitHub team to a pull request
 for review by @-mention.
 See [Who to CC in the issue tracker](#who-to-cc-in-the-issue-tracker).
 
-If you are the first Collaborator to approve a pull request that has no CI yet,
+If you are the first collaborator to approve a pull request that has no CI yet,
 please [start one](#testing-and-ci). Please also start a new CI if the
 pull request creator pushed new code since the last CI run.
 
@@ -124,21 +147,21 @@ requirements. If a pull request meets all requirements except the
 
 #### Objections
 
-**Collaborators can object to a pull request by using the "Request
-Changes" GitHub feature**. Dissent comments alone don't constitute an
-objection. **Any PR objection must include a clear reason for that objection,
-and the objector must remain responsive for further discussion towards
-consensus about the direction of the pull request**. Providing a set of
-actionable steps alongside the objection is recommended.
+Collaborators can object to a pull request by using the "Request
+Changes" GitHub feature. Dissent comments alone don't constitute an
+objection. Any pull request objection must include a clear reason for that
+objection, and the objector must remain responsive for further discussion
+towards consensus about the direction of the pull request. Where possible,
+provide a set of actionable steps alongside the objection.
 
 If the objection is not clear to others, another collaborator can ask an
 objecting collaborator to explain their objection or to provide actionable
-steps to resolve the objection. **If the objector is unresponsive for seven
-days after a collaborator asks for clarification, another collaborator can
-dismiss the objection**.
+steps to resolve the objection. If the objector is unresponsive for seven
+days after a collaborator asks for clarification, a collaborator may
+dismiss the objection.
 
-**Pull requests with outstanding objections must remain open until all
-objections are satisfied**. If reaching consensus is not possible, a
+Pull requests with outstanding objections must remain open until all
+objections are satisfied. If reaching consensus is not possible, a
 collaborator can escalate the issue to the TSC by pinging `@nodejs/tsc` and
 adding the `tsc-agenda` label to the issue.
 
@@ -150,7 +173,7 @@ adding the `tsc-agenda` label to the issue.
 
 ### Waiting for approvals
 
-Before landing pull requests, allow 48 hours for input from other Collaborators.
+Before landing pull requests, allow 48 hours for input from other collaborators.
 Certain types of pull requests can be fast-tracked and can land after a shorter
 delay. For example:
 
@@ -162,14 +185,14 @@ delay. For example:
   * Regressions that happen right before a release, or reported soon after.
 
 To propose fast-tracking a pull request, apply the `fast-track` label. Then add
-a comment that Collaborators can upvote.
+a comment that collaborators can upvote.
 
 If someone disagrees with the fast-tracking request, remove the label. Do not
 fast-track the pull request in that case.
 
-The pull request can be fast-tracked if two Collaborators approve the
+The pull request can be fast-tracked if two collaborators approve the
 fast-tracking request. To land, the pull request itself still needs two
-Collaborator approvals and a passing CI.
+collaborator approvals and a passing CI.
 
 Collaborators can request fast-tracking of pull requests they did not author.
 In that case only, the request itself is also one fast-track approval. Upvote
@@ -180,21 +203,56 @@ the comment anyway to avoid any doubt.
 All fixes must have a test case which demonstrates the defect. The test should
 fail before the change, and pass after the change.
 
-All pull requests must pass continuous integration tests. Code changes must pass
-on [project CI server](https://ci.nodejs.org/). Pull requests that only change
-documentation and comments can use GitHub Actions results.
+Do not land any pull requests without the necessary passing CI runs.
+A passing (green) GitHub Actions CI result is required. A passing (green or
+yellow) [Jenkins CI](https://ci.nodejs.org/) is also required if the pull
+request contains changes that will affect the `node` binary. This is because
+GitHub Actions CI does not cover all the environments supported by Node.js.
+
+<details>
+<summary>Changes that affect the `node` binary</summary>
+
+Changes in the following folders (except comment-only changes) are guaranteed to
+affect the `node` binary:
+
+* `deps/`
+* `lib/`
+* `src/`
+* `test/`
+* `tools/code_cache/`
+* `tools/gyp/`
+* `tools/icu/`
+* `tools/inspector-protocol/`
+* `tools/msvs/`
+* `tools/snapshot/`
+* `tools/v8_gypfiles/`
+
+There are some other files that touch the build chain. Changes in the following
+files also qualify as affecting the `node` binary:
+
+* `tools/*.py`
+* `tools/build-addons.js`
+* `*.gyp`
+* `*.gypi`
+* `configure`
+* `configure.py`
+* `Makefile`
+* `vcbuilt.bat`
 
-Do not land any pull requests without a passing (green or yellow) CI run.
-For documentation-only changes, GitHub Actions CI is sufficient.
-For all other code changes, Jenkins CI must pass as well. If there are
-Jenkins CI failures unrelated to the change in the pull request, try "Resume
-Build". It is in the left navigation of the relevant `node-test-pull-request`
-job. It will preserve all the green results from the current job but re-run
-everything else. Start a fresh CI if more than seven days have elapsed since
-the original failing CI as the compiled binaries for the Windows and ARM
-platforms are only kept for seven days.
+</details>
 
-#### Useful CI jobs
+If there are GitHub Actions CI failures unrelated to the change in the pull
+request, try "Re-run all jobs". It's under the "🔄 Re-run jobs" button, on the
+right-hand side of "Checks" tab.
+
+If there are Jenkins CI failures unrelated to the change in the pull request,
+try "Resume Build". It is in the left navigation of the relevant
+`node-test-pull-request` job. It will preserve all the green results from the
+current job but re-run everything else. Start a fresh CI if more than seven days
+have elapsed since the original failing CI as the compiled binaries for the
+Windows and ARM platforms are only kept for seven days.
+
+#### Useful Jenkins CI jobs
 
 * [`node-test-pull-request`](https://ci.nodejs.org/job/node-test-pull-request/)
 is the CI job to test pull requests. It runs the `build-ci` and `test-ci`
@@ -219,7 +277,7 @@ not used in other CI test runs (such as tests in the `internet` or `pummel`
 directories). It can also make sure tests pass when provided with a flag not
 used in other CI test runs (such as `--worker`).
 
-#### Starting a CI job
+#### Starting a Jenkins CI job
 
 From the CI Job page, click "Build with Parameters" on the left side.
 
@@ -230,7 +288,7 @@ in the form:
 To specify the branch this way, `refs/heads/BRANCH` is used
 (e.g. for `master` -> `refs/heads/master`).
 For pull requests, it will look like `refs/pull/PR_NUMBER/head`
-(e.g. for PR#42 -> `refs/pull/42/head`).
+(e.g. for pull request #42 -> `refs/pull/42/head`).
 * `REBASE_ONTO`: Change that to `origin/master` so the pull request gets rebased
 onto master. This can especially be important for pull requests that have been
 open a while.
@@ -244,6 +302,12 @@ Copy/paste the URL for the job into a comment in the pull request.
 [`node-test-pull-request`](https://ci.nodejs.org/job/node-test-pull-request/)
 is an exception where the GitHub bot will automatically post for you.
 
+The [`node-test-pull-request`](https://ci.nodejs.org/job/node-test-pull-request/)
+CI job can be started by adding the `request-ci` label into the pull request.
+Once this label is added, `github-actions bot` will start
+the `node-test-pull-request` automatically. If the `github-actions bot`
+is unable to start the job, it will update the label with `request-ci-failed`.
+
 ### Internal vs. public API
 
 All functionality in the official Node.js documentation is part of the public
@@ -308,7 +372,7 @@ providing a Public API in such cases.
 #### Unintended breaking changes
 
 Sometimes, a change intended to be non-breaking turns out to be a breaking
-change. If such a change lands on the master branch, a Collaborator can revert
+change. If such a change lands on the master branch, a collaborator can revert
 it. As an alternative to reverting, the TSC can apply the semver-major label
 after-the-fact.
 
@@ -338,12 +402,12 @@ For pull requests introducing new core modules:
 * Land with a [Stability Index][] of Experimental. The module must remain
   Experimental until a semver-major release.
 
-### Additions to N-API
+### Additions to Node-API
 
-N-API provides an ABI-stable API guaranteed for future Node.js versions. N-API
-additions call for unusual care and scrutiny. If a change adds to `node_api.h`,
-`js_native_api.h`, `node_api_types.h`, or `js_native_api_types.h`, consult [the relevant
-guide](https://github.com/nodejs/node/blob/master/doc/guides/adding-new-napi-api.md).
+Node-API provides an ABI-stable API guaranteed for future Node.js versions.
+Node-API additions call for unusual care and scrutiny. If a change adds to
+`node_api.h`, `js_native_api.h`, `node_api_types.h`, or `js_native_api_types.h`,
+consult [the relevant guide](https://github.com/nodejs/node/blob/HEAD/doc/guides/adding-new-napi-api.md).
 
 ### Deprecations
 
@@ -410,7 +474,7 @@ Do this if a pull request or issue:
 * Is labeled `semver-major`, or
 * Has a significant impact on the codebase, or
 * Is controversial, or
-* Is at an impasse among Collaborators who are participating in the discussion.
+* Is at an impasse among collaborators who are participating in the discussion.
 
 @-mention the `@nodejs/tsc` GitHub team if you want to elevate an issue to the
 [TSC][]. Do not use the GitHub UI on the right-hand side to assign to
@@ -424,7 +488,7 @@ The TSC serves as the final arbiter where required.
    who wish to land their own pull requests will self-assign them. Sometimes, an
    author will delegate to someone else. If in doubt, ask the assignee whether
    it is okay to land.
-1. Never use GitHub's green ["Merge Pull Request"][] button. Reasons for not
+1. Never use GitHub's green ["Merge pull request"][] button. Reasons for not
    using the web interface button:
    * The "Create a merge commit" method will add an unnecessary merge commit.
    * The "Squash and merge" method will add metadata (the pull request #) to the
@@ -488,7 +552,7 @@ Checkout proper target branch:
 $ git checkout master
 ```
 
-Update the tree (assumes your repo is set up as detailed in
+Update the tree (assumes your repository is set up as detailed in
 [CONTRIBUTING.md](./contributing/pull-requests.md#step-1-fork)):
 
 ```text
@@ -595,7 +659,7 @@ for that commit. This is an opportunity to fix commit messages.
     issue. A commit message can include more than one `Fixes:` lines.
   * Optional: One or more `Refs:` lines referencing a URL for any relevant
     background.
-  * Required: A `Reviewed-By: Name <email>` line for each Collaborator who
+  * Required: A `Reviewed-By: Name <email>` line for each collaborator who
     reviewed the change.
     * Useful for @mentions / contact list if something goes wrong in the
       pull request.
@@ -605,7 +669,7 @@ Other changes might have landed on master since the successful CI run. As a
 precaution, run tests (`make -j4 test` or `vcbuild test`).
 
 Confirm that the commit message format is correct using
-[core-validate-commit](https://github.com/evanlucas/core-validate-commit).
+[core-validate-commit](https://github.com/nodejs/core-validate-commit).
 
 ```text
 $ git rev-list upstream/master...HEAD | xargs core-validate-commit
@@ -662,7 +726,6 @@ git push upstream master
 ### I made a mistake
 
 * Ping a TSC member.
-* `#node-dev` on freenode.
 * With `git`, there's a way to override remote trees by force pushing
   (`git push -f`). This is generally forbidden as it creates conflicts in other
   people's forks. It is permissible for simpler slip-ups such as typos in commit
@@ -671,9 +734,8 @@ git push upstream master
   10-minute period passes, consider the commit final.
   * Use `--force-with-lease` to reduce the chance of overwriting someone else's
     change.
-  * Post to `#node-dev` (IRC) if you force push.
 
-### Long term support
+### Long Term Support
 
 #### What is LTS?
 
@@ -689,10 +751,10 @@ Each LTS release has a corresponding branch (v10.x, v8.x, etc.). Each also has a
 corresponding staging branch (v10.x-staging, v8.x-staging, etc.).
 
 Commits that land on master are cherry-picked to each staging branch as
-appropriate. If a change applies only to the LTS branch, open the PR against the
-*staging* branch. Commits from the staging branch land on the LTS branch only
-when a release is being prepared. They can land on the LTS branch in a different
-order than they were in staging.
+appropriate. If a change applies only to the LTS branch, open the pull request
+against the *staging* branch. Commits from the staging branch land on the LTS
+branch only when a release is being prepared. They might land on the LTS branch
+in a different order than they do in staging.
 
 Only members of @nodejs/backporters should land commits onto LTS staging
 branches.
@@ -713,7 +775,7 @@ There are several LTS-related labels:
   release. For example, `land-on-v10.x` would be for a change to land in Node.js
   10.x.
 
-Any Collaborator can attach these labels to any pull request/issue. As commits
+Any collaborator can attach these labels to any pull request/issue. As commits
 land on the staging branches, the backporter removes the `lts-watch-` label.
 Likewise, as commits land in an LTS release, the releaser removes the `land-on-`
 label.
@@ -769,8 +831,89 @@ When things need extra attention, are controversial, or `semver-major`:
 
 If you cannot find who to cc for a file, `git shortlog -n -s <file>` can help.
 
-["Merge Pull Request"]: https://help.github.com/articles/merging-a-pull-request/#merging-a-pull-request-on-github
+## Labels
+
+### General labels
+
+* `confirmed-bug`: Bugs you have verified
+* `discuss`: Things that need larger discussion
+* `feature request`: Any issue that requests a new feature
+* `good first issue`: Issues suitable for newcomers to fix
+* `meta`: Governance, policies, procedures, etc.
+* `tsc-agenda`: Open issues and pull requests with this label will be added to
+  the Technical Steering Committee meeting agenda
+
+---
+
+* `author-ready` - A pull request is _author ready_ when:
+  * There is a CI run in progress or completed.
+  * There is at least one collaborator approval (or two TSC approvals for
+    semver-major pull requests).
+  * There are no outstanding review comments.
+
+Please always add the `author ready` label to pull requests that qualify.
+Please always remove it again as soon as the conditions are not met anymore,
+such as if the CI run fails or a new outstanding review comment is posted.
+
+---
+
+* `semver-{minor,major}`
+  * be conservative – that is, if a change has the remote *chance* of breaking
+    something, go for semver-major
+  * when adding a semver label, add a comment explaining why you're adding it
+  * minor vs. patch: roughly: "does it add a new method / does it add a new
+    section to the docs"
+  * major vs. everything else: run last versions tests against this version, if
+    they pass, **probably** minor or patch
+
+### LTS/version labels
+
+We use labels to keep track of which branches a commit should land on:
+
+* `dont-land-on-v?.x`
+  * For changes that do not apply to a certain release line
+  * Also used when the work of backporting a change outweighs the benefits
+* `land-on-v?.x`
+  * Used by releasers to mark a pull request as scheduled for inclusion in an
+    LTS release
+  * Applied to the original pull request for clean cherry-picks, to the backport
+    pull request otherwise
+* `backport-requested-v?.x`
+  * Used to indicate that a pull request needs a manual backport to a branch in
+    order to land the changes on that branch
+  * Typically applied by a releaser when the pull request does not apply cleanly
+    or it breaks the tests after applying
+  * Will be replaced by either `dont-land-on-v?.x` or `backported-to-v?.x`
+* `backported-to-v?.x`
+  * Applied to pull requests for which a backport pull request has been merged
+* `lts-watch-v?.x`
+  * Applied to pull requests which the Release working group should consider
+    including in an LTS release
+  * Does not indicate that any specific action will be taken, but can be
+    effective as messaging to non-collaborators
+* `release-agenda`
+  * For things that need discussion by the Release working group
+  * (for example semver-minor changes that need or should go into an LTS
+    release)
+* `v?.x`
+  * Automatically applied to changes that do not target `master` but rather the
+    `v?.x-staging` branch
+
+Once a release line enters maintenance mode, the corresponding labels do not
+need to be attached anymore, as only important bugfixes will be included.
+
+### Other labels
+
+* Operating system labels
+  * `macos`, `windows`, `smartos`, `aix`
+  * No `linux` label because it is the implied default
+* Architecture labels
+  * `arm`, `mips`, `s390`, `ppc`
+  * No `x86{_64}` label because it is the implied default
+
+["Merge pull request"]: https://help.github.com/articles/merging-a-pull-request/#merging-a-pull-request-on-github
 [Deprecation]: https://en.wikipedia.org/wiki/Deprecation
+[SECURITY.md]: https://github.com/nodejs/node/blob/HEAD/SECURITY.md
 [Stability Index]: ../api/documentation.md#stability-index
 [TSC]: https://github.com/nodejs/TSC
 [`--pending-deprecation`]: ../api/cli.md#--pending-deprecation
@@ -780,8 +923,8 @@ If you cannot find who to cc for a file, `git shortlog -n -s <file>` can help.
 [commit message guidelines]: contributing/pull-requests.md#commit-message-guidelines
 [commit-example]: https://github.com/nodejs/node/commit/b636ba8186
 [git-email]: https://help.github.com/articles/setting-your-commit-email-address-in-git/
-[git-node]: https://github.com/nodejs/node-core-utils/blob/master/docs/git-node.md
-[git-node-metadata]: https://github.com/nodejs/node-core-utils/blob/master/docs/git-node.md#git-node-metadata
+[git-node]: https://github.com/nodejs/node-core-utils/blob/HEAD/docs/git-node.md
+[git-node-metadata]: https://github.com/nodejs/node-core-utils/blob/HEAD/docs/git-node.md#git-node-metadata
 [git-username]: https://help.github.com/articles/setting-your-username-in-git/
 [node-core-utils-credentials]: https://github.com/nodejs/node-core-utils#setting-up-credentials
 [node-core-utils-issues]: https://github.com/nodejs/node-core-utils/issues
diff --git a/doc/guides/commit-queue.md b/doc/guides/commit-queue.md
index 33f4924f7fdb5c2f904cedcf4079afe0ee748f47..6d81ee8e652d2c574cc19aae1cbfdc2ca15e9236 100644
--- a/doc/guides/commit-queue.md
+++ b/doc/guides/commit-queue.md
@@ -1,13 +1,13 @@
-# Commit Queue
+# Commit queue
 
 > Stability: 1 - Experimental
 
-*tl;dr: You can land Pull Requests by adding the `commit-queue` label to it.*
+*tl;dr: You can land pull requests by adding the `commit-queue` label to it.*
 
 Commit Queue is an experimental feature for the project which simplifies the
-landing process by automating it via GitHub Actions. With it, Collaborators can
-land Pull Requests by adding the `commit-queue` label to a PR. All
-checks will run via node-core-utils, and if the Pull Request is ready to land,
+landing process by automating it via GitHub Actions. With it, collaborators can
+land pull requests by adding the `commit-queue` label to a PR. All
+checks will run via node-core-utils, and if the pull request is ready to land,
 the Action will rebase it and push to master.
 
 This document gives an overview of how the Commit Queue works, as well as
@@ -17,8 +17,8 @@ implementation details, reasoning for design choices, and current limitations.
 
 From a high-level, the Commit Queue works as follow:
 
-1. Collaborators will add `commit-queue` label to Pull Requests ready to land
-2. Every five minutes the queue will do the following for each Pull Request
+1. Collaborators will add `commit-queue` label to pull requests ready to land
+2. Every five minutes the queue will do the following for each pull request
    with the label:
    1. Check if the PR also has a `request-ci` label (if it has, skip this PR
       since it's pending a CI run)
@@ -37,19 +37,19 @@ From a high-level, the Commit Queue works as follow:
       3. Close the PR
       4. Go to next PR in the queue
 
-## Current Limitations
+## Current limitations
 
 The Commit Queue feature is still in early stages, and as such it might not
-work for more complex Pull Requests. These are the currently known limitations
+work for more complex pull requests. These are the currently known limitations
 of the commit queue:
 
-1. All commits in a Pull Request must either be following commit message
+1. All commits in a pull request must either be following commit message
    guidelines or be a valid [`fixup!`](https://git-scm.com/docs/git-commit#Documentation/git-commit.txt---fixupltcommitgt)
    commit that will be correctly handled by the [`--autosquash`](https://git-scm.com/docs/git-rebase#Documentation/git-rebase.txt---autosquash)
    option
 2. A CI must've ran and succeeded since the last change on the PR
-3. A Collaborator must have approved the PR since the last change
-4. Only Jenkins CI is checked (Actions, V8 CI and CITGM are ignored)
+3. A collaborator must have approved the PR since the last change
+4. Only Jenkins CI and GitHub Actions are checked (V8 CI and CITGM are ignored)
 
 ## Implementation
 
@@ -73,7 +73,7 @@ reasons:
 `node-core-utils` is configured with a personal token and
 a Jenkins token from
 [@nodejs-github-bot](https://github.com/nodejs/github-bot).
-`octokit/graphql-action` is used to fetch all Pull Requests with the
+`octokit/graphql-action` is used to fetch all pull requests with the
 `commit-queue` label. The output is a JSON payload, so `jq` is used to turn
 that into a list of PR ids we can pass as arguments to
 [`commit-queue.sh`](../../tools/actions/commit-queue.sh).
@@ -87,8 +87,8 @@ that into a list of PR ids we can pass as arguments to
 1. The repository owner
 2. The repository name
 3. The Action GITHUB_TOKEN
-4. Every positional argument starting at this one will be a Pull Request ID of
-    a Pull Request with commit-queue set.
+4. Every positional argument starting at this one will be a pull request ID of
+    a pull request with commit-queue set.
 
 The script will iterate over the pull requests. `ncu-ci` is used to check if
 the last CI is still pending, and calls to the GitHub API are used to check if
@@ -106,9 +106,9 @@ If no errors happen during `git node land`, the script will use the
 `Landed in ...` comment in the PR, and then will close it. Iteration continues
 until all PRs have done the steps above.
 
-## Reverting Broken Commits
+## Reverting broken commits
 
-Reverting broken commits is done manually by Collaborators, just like when
+Reverting broken commits is done manually by collaborators, just like when
 commits are landed manually via `git node land`. An easy way to revert is a
 good feature for the project, but is not explicitly required for the Commit
 Queue to work because the Action lands PRs just like collaborators do today. If
diff --git a/doc/guides/contributing/code-of-conduct.md b/doc/guides/contributing/code-of-conduct.md
index 6e2c1db36e9f60d3727d0516ce334bfebf2384fd..9c3ad120b13d34455b8e7fbd6b5963b6cb0490c7 100644
--- a/doc/guides/contributing/code-of-conduct.md
+++ b/doc/guides/contributing/code-of-conduct.md
@@ -40,4 +40,4 @@ that you *might* be wrong is critical for any successful open collaboration.
 
 Don't be a bad actor.
 
-[Code of Conduct]: https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md
+[Code of Conduct]: https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md
diff --git a/doc/guides/contributing/issues.md b/doc/guides/contributing/issues.md
index 44b18bc8ede7d2b2faac68e94f0e3adf19b92e99..10aa28201d9e0bacaafe7a0d66cd9fba1936d7c8 100644
--- a/doc/guides/contributing/issues.md
+++ b/doc/guides/contributing/issues.md
@@ -1,29 +1,11 @@
 # Issues
 
-* [How to Contribute in Issues](#how-to-contribute-in-issues)
-* [Asking for General Help](#asking-for-general-help)
+* [Asking for general help](#asking-for-general-help)
 * [Discussing non-technical topics](#discussing-non-technical-topics)
-* [Submitting a Bug Report](#submitting-a-bug-report)
-* [Triaging a Bug Report](#triaging-a-bug-report)
-* [Resolving a Bug Report](#resolving-a-bug-report)
+* [Submitting a bug report](#submitting-a-bug-report)
+* [Triaging a bug report](#triaging-a-bug-report)
 
-## How to Contribute in Issues
-
-For any issue, there are fundamentally three ways an individual can
-contribute:
-
-1. By opening the issue for discussion: For instance, if you believe that you
-   have uncovered a bug in Node.js, creating a new issue in the `nodejs/node`
-   issue tracker is the way to report it.
-2. By helping to triage the issue: This can be done either by providing
-   supporting details (a test case that demonstrates a bug), or providing
-   suggestions on how to address the issue.
-3. By helping to resolve the issue: Typically this is done either in the form
-   of demonstrating that the issue reported is not a problem after all, or more
-   often, by opening a Pull Request that changes some bit of something in
-   `nodejs/node` in a concrete and reviewable manner.
-
-## Asking for General Help
+## Asking for general help
 
 Because the level of activity in the `nodejs/node` repository is so high,
 questions or requests for general help using Node.js should be directed at
@@ -34,40 +16,13 @@ the [Node.js help repository][].
 Discussion of non-technical topics (such as intellectual property and trademark)
 should be directed to the [Technical Steering Committee (TSC) repository][].
 
-## Submitting a Bug Report
+## Submitting a bug report
 
 When opening a new issue in the `nodejs/node` issue tracker, users will be
-presented with a basic template that should be filled in.
-
-```markdown
-<!--
-Thank you for reporting an issue.
-
-This issue tracker is for bugs and issues found within Node.js core.
-If you require more general support please file an issue on our help
-repo. https://github.com/nodejs/help
-
-
-Please fill in as much of the template below as you're able.
-
-Version: output of `node -v`
-Platform: output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows)
-Subsystem: if known, please specify affected core module name
-
-If possible, please provide code that demonstrates the problem, keeping it as
-simple and free of external dependencies as you are able.
--->
-
-* **Version**:
-* **Platform**:
-* **Subsystem**:
-
-<!-- Enter your issue details below this comment. -->
-```
-
-If you believe that you have uncovered a bug in Node.js, please fill out this
-form, following the template to the best of your ability. Do not worry if you
-cannot answer every detail, just fill in what you can.
+presented with a choice of issue templates. If you believe that you have
+uncovered a bug in Node.js, please fill out the `Bug Report` template to the
+best of your ability. Do not worry if you cannot answer every detail; just fill
+in what you can.
 
 The two most important pieces of information we need in order to properly
 evaluate the report is a description of the behavior you are seeing and a simple
@@ -82,7 +37,7 @@ Node.js changed that broke the module.
 
 See [How to create a Minimal, Complete, and Verifiable example](https://stackoverflow.com/help/mcve).
 
-## Triaging a Bug Report
+## Triaging a bug report
 
 Once an issue has been opened, it is common for there to be discussion
 around it. Some contributors may have differing opinions about the issue,
@@ -98,20 +53,12 @@ project's GitHub organization plus a few contributions to the project
 (commenting on issues or PRs) can apply for and become a triager. Open a PR
 on the README.md of this project with: i) a request to be added as a triager,
 ii) the motivation for becoming a triager, and iii) agreement on reading,
-understanding, and adhering to the project's [Code Of Conduct](https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md).
+understanding, and adhering to the project's [Code Of Conduct](https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md).
 
 The triage role enables the ability to carry out the most common triage
 activities, such as applying labels and closing/reopening/assigning issues.
 For more information on the roles and permissions, see ["Permission levels for
 repositories owned by an organization"](https://docs.github.com/en/github/setting-up-and-managing-organizations-and-teams/repository-permission-levels-for-an-organization#permission-levels-for-repositories-owned-by-an-organization).
 
-## Resolving a Bug Report
-
-In the vast majority of cases, issues are resolved by opening a Pull Request.
-The process for opening and reviewing a Pull Request is similar to that of
-opening and triaging issues, but carries with it a necessary review and approval
-workflow that ensures that the proposed changes meet the minimal quality and
-functional guidelines of the Node.js project.
-
 [Node.js help repository]: https://github.com/nodejs/help/issues
 [Technical Steering Committee (TSC) repository]: https://github.com/nodejs/TSC/issues
diff --git a/doc/guides/contributing/pull-requests.md b/doc/guides/contributing/pull-requests.md
index 5cdf6e82f19ec499d8b02d8991234bbae2e6f18b..763b05491592d124d1a55a9683725a04098f7354 100644
--- a/doc/guides/contributing/pull-requests.md
+++ b/doc/guides/contributing/pull-requests.md
@@ -1,40 +1,36 @@
-# Pull Requests
-
-There are two fundamental components of the Pull Request process: one concrete
-and technical, and one more process oriented. The concrete and technical
-component involves the specific details of setting up your local environment
-so that you can make the actual changes. This is where we will start.
+# Pull requests
 
 * [Dependencies](#dependencies)
 * [Setting up your local environment](#setting-up-your-local-environment)
   * [Step 1: Fork](#step-1-fork)
   * [Step 2: Branch](#step-2-branch)
-* [The Process of Making Changes](#the-process-of-making-changes)
+* [The process of making changes](#the-process-of-making-changes)
   * [Step 3: Code](#step-3-code)
   * [Step 4: Commit](#step-4-commit)
     * [Commit message guidelines](#commit-message-guidelines)
   * [Step 5: Rebase](#step-5-rebase)
   * [Step 6: Test](#step-6-test)
   * [Step 7: Push](#step-7-push)
-  * [Step 8: Opening the Pull Request](#step-8-opening-the-pull-request)
-  * [Step 9: Discuss and Update](#step-9-discuss-and-update)
-    * [Approval and Request Changes Workflow](#approval-and-request-changes-workflow)
+  * [Step 8: Opening the pull request](#step-8-opening-the-pull-request)
+  * [Step 9: Discuss and update](#step-9-discuss-and-update)
+    * [Approval and request changes workflow](#approval-and-request-changes-workflow)
   * [Step 10: Landing](#step-10-landing)
-* [Reviewing Pull Requests](#reviewing-pull-requests)
+* [Reviewing pull requests](#reviewing-pull-requests)
   * [Review a bit at a time](#review-a-bit-at-a-time)
   * [Be aware of the person behind the code](#be-aware-of-the-person-behind-the-code)
   * [Respect the minimum wait time for comments](#respect-the-minimum-wait-time-for-comments)
-  * [Abandoned or Stalled Pull Requests](#abandoned-or-stalled-pull-requests)
+  * [Abandoned or stalled pull requests](#abandoned-or-stalled-pull-requests)
   * [Approving a change](#approving-a-change)
   * [Accept that there are different opinions about what belongs in Node.js](#accept-that-there-are-different-opinions-about-what-belongs-in-nodejs)
   * [Performance is not everything](#performance-is-not-everything)
-  * [Continuous Integration Testing](#continuous-integration-testing)
+  * [Continuous integration testing](#continuous-integration-testing)
 * [Notes](#notes)
-  * [Commit Squashing](#commit-squashing)
-  * [Getting Approvals for your Pull Request](#getting-approvals-for-your-pull-request)
-  * [CI Testing](#ci-testing)
-  * [Waiting Until the Pull Request Gets Landed](#waiting-until-the-pull-request-gets-landed)
-  * [Check Out the Collaborator Guide](#check-out-the-collaborator-guide)
+  * [Commit squashing](#commit-squashing)
+  * [Getting approvals for your pull request](#getting-approvals-for-your-pull-request)
+  * [CI testing](#ci-testing)
+  * [Waiting until the pull request gets landed](#waiting-until-the-pull-request-gets-landed)
+  * [Check out the collaborator guide](#check-out-the-collaborator-guide)
+  * [Appendix: subsystems](#appendix-subsystems)
 
 ## Dependencies
 
@@ -45,7 +41,7 @@ Node.js. We cannot accept such patches.
 
 In case of doubt, open an issue in the
 [issue tracker](https://github.com/nodejs/node/issues/) or contact one of the
-[project Collaborators](https://github.com/nodejs/node/#current-project-team-members).
+[project collaborators](https://github.com/nodejs/node/#current-project-team-members).
 
 Node.js has many channels on the
 [OpenJS Foundation Slack](https://slack-invite.openjsf.org/). Interesting
@@ -55,11 +51,8 @@ help, questions and discussions.
 [#nodejs-dev](https://openjs-foundation.slack.com/archives/C019Y2T6STH) for
 development of Node.js core specifically.
 
-Node.js also has two IRC channels:
-[#Node.js](https://webchat.freenode.net/?channels=node.js) for general help and
-questions, and
-[#node-dev](https://webchat.freenode.net/?channels=node-dev) for development of
-Node.js core specifically.
+Node.js also has an unofficial IRC channel:
+[#Node.js](https://web.libera.chat/?channels=node.js).
 
 ## Setting up your local environment
 
@@ -111,11 +104,11 @@ directly off of the `master` branch.
 $ git checkout -b my-branch -t upstream/master
 ```
 
-## The Process of Making Changes
+## The process of making changes
 
 ### Step 3: Code
 
-The vast majority of Pull Requests opened against the `nodejs/node`
+The vast majority of pull requests opened against the `nodejs/node`
 repository includes changes to one or more of the following:
 
 * the C/C++ code contained in the `src` directory
@@ -123,25 +116,36 @@ repository includes changes to one or more of the following:
 * the documentation in `doc/api`
 * tests within the `test` directory.
 
-If you are modifying code, please be sure to run `make lint` from time to
-time to ensure that the changes follow the Node.js code style guide.
+If you are modifying code, please be sure to run `make lint` (or
+`vcbuild.bat lint` on Windows) to ensure that the changes follow the Node.js
+code style guide.
 
 Any documentation you write (including code comments and API documentation)
 should follow the [Style Guide](../doc-style-guide.md). Code samples
 included in the API docs will also be checked when running `make lint` (or
 `vcbuild.bat lint` on Windows). If you are adding to or deprecating an API,
-use `REPLACEME` for the version number in the documentation YAML.
+add or change the appropriate YAML documentation. Use `REPLACEME` for the
+version number in the documentation YAML:
+
+```markdown
+### `request.method`
+<!-- YAML
+added: REPLACEME
+-->
+
+* {string} The request method.
+```
 
 For contributing C++ code, you may want to look at the
 [C++ Style Guide](../cpp-style-guide.md), as well as the
-[README of `src/`](../../../src/README.md) for an overview over Node.js
+[README of `src/`](../../../src/README.md) for an overview of Node.js
 C++ internals.
 
 ### Step 4: Commit
 
 It is a best practice to keep your changes as logically grouped
 as possible within individual commits. There is no limit to the number of
-commits any single Pull Request may have, and many contributors find it easier
+commits any single pull request may have, and many contributors find it easier
 to review changes that are split across multiple commits.
 
 ```text
@@ -161,9 +165,9 @@ A good commit message should describe what changed and why.
      less, and no more than 72 characters)
    * be entirely in lowercase with the exception of proper nouns, acronyms, and
    the words that refer to code, like function/variable names
-   * be prefixed with the name of the changed subsystem and start with an
-   imperative verb. Check the output of `git log --oneline files/you/changed` to
-   find out what subsystems your changes touch.
+   * be prefixed with the name of the changed [subsystem](#appendix-subsystems)
+   and start with an imperative verb. Check the output of `git log --oneline
+   files/you/changed` to find out what subsystems your changes touch.
 
    Examples:
    * `net: add localAddress and localPort to Socket`
@@ -201,7 +205,7 @@ Refs: https://eslint.org/docs/rules/space-in-parens.html
 If you are new to contributing to Node.js, please try to do your best at
 conforming to these guidelines, but do not worry if you get something wrong.
 One of the existing contributors will help get things situated and the
-contributor landing the Pull Request will ensure that everything follows
+contributor landing the pull request will ensure that everything follows
 the project guidelines.
 
 ### Step 5: Rebase
@@ -230,7 +234,7 @@ often not clear where a new test file should go. When in doubt, add new tests
 to the `test/parallel/` directory and the right location will be sorted out
 later.
 
-Before submitting your changes in a Pull Request, always run the full Node.js
+Before submitting your changes in a pull request, always run the full Node.js
 test suite. To run the tests (including code linting) on Unix / macOS:
 
 ```text
@@ -248,53 +252,32 @@ And on Windows:
 ### Step 7: Push
 
 Once you are sure your commits are ready to go, with passing tests and linting,
-begin the process of opening a Pull Request by pushing your working branch to
+begin the process of opening a pull request by pushing your working branch to
 your fork on GitHub.
 
 ```text
 $ git push origin my-branch
 ```
 
-### Step 8: Opening the Pull Request
-
-From within GitHub, opening a new Pull Request will present you with a template
-that should be filled out:
-
-```markdown
-<!--
-Thank you for your Pull Request. Please provide a description above and review
-the requirements below.
-
-Bug fixes and new features should include tests and possibly benchmarks.
-
-Contributors guide: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
--->
+### Step 8: Opening the pull request
 
-#### Checklist
-<!-- Remove items that do not apply. For completed items, change [ ] to [x]. -->
-
-- [ ] `make -j4 test` (UNIX), or `vcbuild test` (Windows) passes
-- [ ] tests and/or benchmarks are included
-- [ ] documentation is changed or added
-- [ ] commit message follows [commit guidelines](https://github.com/nodejs/node/blob/master/doc/guides/contributing/pull-requests.md#commit-message-guidelines)
-```
+From within GitHub, opening a new pull request will present you with a
+[pull request template][]. Please try to do your best at filling out the
+details, but feel free to skip parts if you're not sure what to put.
 
-Please try to do your best at filling out the details, but feel free to skip
-parts if you're not sure what to put.
-
-Once opened, Pull Requests are usually reviewed within a few days.
+Once opened, pull requests are usually reviewed within a few days.
 
 ### Step 9: Discuss and update
 
-You will probably get feedback or requests for changes to your Pull Request.
+You will probably get feedback or requests for changes to your pull request.
 This is a big part of the submission process so don't be discouraged! Some
-contributors may sign off on the Pull Request right away, others may have
+contributors may sign off on the pull request right away, others may have
 more detailed comments or feedback. This is a necessary part of the process
 in order to evaluate whether the changes are correct and necessary.
 
-To make changes to an existing Pull Request, make the changes to your local
+To make changes to an existing pull request, make the changes to your local
 branch, add a new commit with those changes, and push those to your fork.
-GitHub will automatically update the Pull Request.
+GitHub will automatically update the pull request.
 
 ```text
 $ git add my/changed/files
@@ -302,7 +285,7 @@ $ git commit
 $ git push origin my-branch
 ```
 
-It is also frequently necessary to synchronize your Pull Request with other
+It is also frequently necessary to synchronize your pull request with other
 changes that have landed in `master` by using `git rebase`:
 
 ```text
@@ -313,8 +296,7 @@ $ git push --force-with-lease origin my-branch
 
 **Important:** The `git push --force-with-lease` command is one of the few ways
 to delete history in `git`. Before you use it, make sure you understand the
-risks. If in doubt, you can always ask for guidance in the Pull Request or on
-[IRC in the #node-dev channel][].
+risks. If in doubt, you can always ask for guidance in the pull request.
 
 If you happen to make a mistake in any of your commits, do not worry. You can
 amend the last commit (for example if you want to change the commit log).
@@ -328,15 +310,15 @@ $ git push --force-with-lease origin my-branch
 There are a number of more advanced mechanisms for managing commits using
 `git rebase` that can be used, but are beyond the scope of this guide.
 
-Feel free to post a comment in the Pull Request to ping reviewers if you are
+Feel free to post a comment in the pull request to ping reviewers if you are
 awaiting an answer on something. If you encounter words or acronyms that
 seem unfamiliar, refer to this
 [glossary](https://sites.google.com/a/chromium.org/dev/glossary).
 
-#### Approval and Request Changes Workflow
+#### Approval and request changes workflow
 
-All Pull Requests require "sign off" in order to land. Whenever a contributor
-reviews a Pull Request they may find specific details that they would like to
+All pull requests require "sign off" in order to land. Whenever a contributor
+reviews a pull request they may find specific details that they would like to
 see changed or fixed. These may be as simple as fixing a typo, or may involve
 substantive changes to the code you have written. While such requests are
 intended to be helpful, they may come across as abrupt or unhelpful, especially
@@ -353,42 +335,41 @@ unhelpful is likely safe to ignore.
 
 ### Step 10: Landing
 
-In order to land, a Pull Request needs to be reviewed and [approved][] by
-at least two Node.js Collaborators (one Collaborator approval is enough if the
+In order to land, a pull request needs to be reviewed and [approved][] by
+at least two Node.js Collaborators (one collaborator approval is enough if the
 pull request has been open for more than 7 days) and pass a
 [CI (Continuous Integration) test run][]. After that, as long as there are no
-objections from other contributors, the Pull Request can be merged. If you find
-your Pull Request waiting longer than you expect, see the
+objections from other contributors, the pull request can be merged. If you find
+your pull request waiting longer than you expect, see the
 [notes about the waiting time](#waiting-until-the-pull-request-gets-landed).
 
-When a collaborator lands your Pull Request, they will post
-a comment to the Pull Request page mentioning the commit(s) it
-landed as. GitHub often shows the Pull Request as `Closed` at this
+When a collaborator lands your pull request, they will post
+a comment to the pull request page mentioning the commit(s) it
+landed as. GitHub often shows the pull request as `Closed` at this
 point, but don't worry. If you look at the branch you raised your
-Pull Request against (probably `master`), you should see a commit with
+pull request against (probably `master`), you should see a commit with
 your name on it. Congratulations and thanks for your contribution!
 
-## Reviewing Pull Requests
+## Reviewing pull requests
 
 All Node.js contributors who choose to review and provide feedback on Pull
 Requests have a responsibility to both the project and the individual making the
 contribution. Reviews and feedback must be helpful, insightful, and geared
-towards improving the contribution as opposed to simply blocking it. If there
-are reasons why you feel the PR should not land, explain what those are. Do not
-expect to be able to block a Pull Request from advancing simply because you say
+towards improving the contribution as opposed to simply blocking it. Do not
+expect to be able to block a pull request from advancing simply because you say
 "No" without giving an explanation. Be open to having your mind changed. Be open
-to working with the contributor to make the Pull Request better.
+to working with the contributor to make the pull request better.
 
 Reviews that are dismissive or disrespectful of the contributor or any other
 reviewers are strictly counter to the [Code of Conduct][].
 
-When reviewing a Pull Request, the primary goals are for the codebase to improve
-and for the person submitting the request to succeed. Even if a Pull Request
+When reviewing a pull request, the primary goals are for the codebase to improve
+and for the person submitting the request to succeed. Even if a pull request
 does not land, the submitters should come away from the experience feeling like
-their effort was not wasted or unappreciated. Every Pull Request from a new
+their effort was not wasted or unappreciated. Every pull request from a new
 contributor is an opportunity to grow the community.
 
-### Review a bit at a time.
+### Review a bit at a time
 
 Do not overwhelm new contributors.
 
@@ -410,8 +391,8 @@ Specific performance optimization techniques, coding styles and conventions
 change over time. The first impression you give to a new contributor never does.
 
 Nits (requests for small changes that are not essential) are fine, but try to
-avoid stalling the Pull Request. Most nits can typically be fixed by the
-Node.js Collaborator landing the Pull Request but they can also be an
+avoid stalling the pull request. Most nits can typically be fixed by the
+Node.js collaborator landing the pull request but they can also be an
 opportunity for the contributor to learn a bit more about the project.
 
 It is always good to clearly indicate nits when you comment: e.g.
@@ -424,7 +405,7 @@ with the appropriate reason to keep the conversation flow concise and relevant.
 ### Be aware of the person behind the code
 
 Be aware that *how* you communicate requests and reviews in your feedback can
-have a significant impact on the success of the Pull Request. Yes, we may land
+have a significant impact on the success of the pull request. Yes, we may land
 a particular change that makes Node.js better, but the individual might just
 not want to have anything to do with Node.js ever again. The goal is not just
 having good code.
@@ -435,18 +416,16 @@ There is a minimum waiting time which we try to respect for non-trivial
 changes, so that people who may have important input in such a distributed
 project are able to respond.
 
-For non-trivial changes, Pull Requests must be left open for at least 48 hours.
-In most cases, when the PR is relatively small and focused on a narrow set of
-changes, that will provide more than enough time to adequately review. Sometimes
-changes take far longer to review, or need more specialized review from subject
-matter experts. When in doubt, do not rush.
+For non-trivial changes, pull requests must be left open for at least 48 hours.
+Sometimes changes take far longer to review, or need more specialized review
+from subject-matter experts. When in doubt, do not rush.
 
 Trivial changes, typically limited to small formatting changes or fixes to
 documentation, may be landed within the minimum 48 hour window.
 
-### Abandoned or Stalled Pull Requests
+### Abandoned or stalled pull requests
 
-If a Pull Request appears to be abandoned or stalled, it is polite to first
+If a pull request appears to be abandoned or stalled, it is polite to first
 check with the contributor to see if they intend to continue the work before
 checking if they would mind if you took it over (especially if it just has
 nits left). When doing so, it is courteous to give the original contributor
@@ -456,12 +435,12 @@ commit.
 
 ### Approving a change
 
-Any Node.js core Collaborator (any GitHub user with commit rights in the
+Any Node.js core collaborator (any GitHub user with commit rights in the
 `nodejs/node` repository) is authorized to approve any other contributor's
-work. Collaborators are not permitted to approve their own Pull Requests.
+work. Collaborators are not permitted to approve their own pull requests.
 
 Collaborators indicate that they have reviewed and approve of the changes in
-a Pull Request either by using GitHub's Approval Workflow, which is preferred,
+a pull request either by using GitHub's Approval Workflow, which is preferred,
 or by leaving an `LGTM` ("Looks Good To Me") comment.
 
 When explicitly using the "Changes requested" component of the GitHub Approval
@@ -479,11 +458,9 @@ Change requests that are vague, dismissive, or unconstructive may also be
 dismissed if requests for greater clarification go unanswered within a
 reasonable period of time.
 
-If you do not believe that the Pull Request should land at all, use
-`Changes requested` to indicate that you are considering some of your comments
-to block the PR from landing. When doing so, explain *why* you believe the
-Pull Request should not land along with an explanation of what may be an
-acceptable alternative course, if any.
+Use `Changes requested` to block a pull request from landing. When doing so,
+explain why you believe the pull request should not land along with an
+explanation of what may be an acceptable alternative course, if any.
 
 ### Accept that there are different opinions about what belongs in Node.js
 
@@ -507,7 +484,7 @@ ridiculed for even trying run counter to the [Code of Conduct][].
 
 Node.js has always optimized for speed of execution. If a particular change
 can be shown to make some part of Node.js faster, it's quite likely to be
-accepted. Claims that a particular Pull Request will make things faster will
+accepted. Claims that a particular pull request will make things faster will
 almost always be met by requests for performance [benchmark results][] that
 demonstrate the improvement.
 
@@ -515,21 +492,21 @@ That said, performance is not the only factor to consider. Node.js also
 optimizes in favor of not breaking existing code in the ecosystem, and not
 changing working functional code just for the sake of changing.
 
-If a particular Pull Request introduces a performance or functional
-regression, rather than simply rejecting the Pull Request, take the time to
+If a particular pull request introduces a performance or functional
+regression, rather than simply rejecting the pull request, take the time to
 work *with* the contributor on improving the change. Offer feedback and
-advice on what would make the Pull Request acceptable, and do not assume that
+advice on what would make the pull request acceptable, and do not assume that
 the contributor should already know how to do that. Be explicit in your
 feedback.
 
-### Continuous Integration Testing
+### Continuous integration testing
 
-All Pull Requests that contain changes to code must be run through
+All pull requests that contain changes to code must be run through
 continuous integration (CI) testing at [https://ci.nodejs.org/][].
 
-Only Node.js core Collaborators with commit rights to the `nodejs/node`
+Only Node.js core collaborators with commit rights to the `nodejs/node`
 repository may start a CI testing run. The specific details of how to do
-this are included in the new Collaborator [Onboarding guide][].
+this are included in the new collaborator [Onboarding guide][].
 
 Ideally, the code change will pass ("be green") on all platform configurations
 supported by Node.js (there are over 30 platform configurations currently).
@@ -537,18 +514,18 @@ This means that all tests pass and there are no linting errors. In reality,
 however, it is not uncommon for the CI infrastructure itself to fail on
 specific platforms or for so-called "flaky" tests to fail ("be red"). It is
 vital to visually inspect the results of all failed ("red") tests to determine
-whether the failure was caused by the changes in the Pull Request.
+whether the failure was caused by the changes in the pull request.
 
 ## Notes
 
-### Commit Squashing
+### Commit squashing
 
-In most cases, do not squash commits that you add to your Pull Request during
-the review process. When the commits in your Pull Request land, they may be
+In most cases, do not squash commits that you add to your pull request during
+the review process. When the commits in your pull request land, they may be
 squashed into one commit per logical change. Metadata will be added to the
-commit message (including links to the Pull Request, links to relevant issues,
-and the names of the reviewers). The commit history of your Pull Request,
-however, will stay intact on the Pull Request page.
+commit message (including links to the pull request, links to relevant issues,
+and the names of the reviewers). The commit history of your pull request,
+however, will stay intact on the pull request page.
 
 For the size of "one logical change",
 [0b5191f](https://github.com/nodejs/node/commit/0b5191f15d0f311c804d542b67e2e922d98834f8)
@@ -556,11 +533,11 @@ can be a good example. It touches the implementation, the documentation,
 and the tests, but is still one logical change. All tests should always pass
 when each individual commit lands on the master branch.
 
-### Getting Approvals for Your Pull Request
+### Getting approvals for your pull request
 
-A Pull Request is approved either by saying LGTM, which stands for
+A pull request is approved either by saying LGTM, which stands for
 "Looks Good To Me", or by using GitHub's Approve button.
-GitHub's Pull Request review feature can be used during the process.
+GitHub's pull request review feature can be used during the process.
 For more information, check out
 [the video tutorial](https://www.youtube.com/watch?v=HW0RPaJqm4g)
 or [the official documentation](https://help.github.com/articles/reviewing-changes-in-pull-requests/).
@@ -569,39 +546,50 @@ After you push new changes to your branch, you need to get
 approval for these new changes again, even if GitHub shows "Approved"
 because the reviewers have hit the buttons before.
 
-### CI Testing
+### CI testing
 
-Every Pull Request needs to be tested
+Every pull request needs to be tested
 to make sure that it works on the platforms that Node.js
 supports. This is done by running the code through the CI system.
 
-Only a Collaborator can start a CI run. Usually one of them will do it
-for you as approvals for the Pull Request come in.
-If not, you can ask a Collaborator to start a CI run.
+Only a collaborator can start a CI run. Usually one of them will do it
+for you as approvals for the pull request come in.
+If not, you can ask a collaborator to start a CI run.
 
-### Waiting Until the Pull Request Gets Landed
+### Waiting until the pull request gets landed
 
-A Pull Request needs to stay open for at least 48 hours from when it is
+A pull request needs to stay open for at least 48 hours from when it is
 submitted, even after it gets approved and passes the CI. This is to make sure
 that everyone has a chance to weigh in. If the changes are trivial,
-collaborators may decide it doesn't need to wait. A Pull Request may well take
+collaborators may decide it doesn't need to wait. A pull request may well take
 longer to be merged in. All these precautions are important because Node.js is
 widely used, so don't be discouraged!
 
-### Check Out the Collaborator Guide
+### Check out the collaborator guide
 
 If you want to know more about the code review and the landing process, see the
-[Collaborator Guide][].
+[collaborator guide][].
+
+### Appendix: subsystems
+
+* `lib/*.js` (`assert`, `buffer`, etc.)
+* `build`
+* `doc`
+* `lib / src`
+* `test`
+* `tools`
+
+More than one subsystem may be valid for any particular issue or pull request.
 
 [Building guide]: ../../../BUILDING.md
 [CI (Continuous Integration) test run]: #ci-testing
-[Code of Conduct]: https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md
-[Collaborator Guide]: ../collaborator-guide.md
-[IRC in the #node-dev channel]: https://webchat.freenode.net?channels=node-dev&uio=d4
+[Code of Conduct]: https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md
 [Onboarding guide]: ../../../onboarding.md
 [approved]: #getting-approvals-for-your-pull-request
 [benchmark results]: ../writing-and-running-benchmarks.md
+[collaborator guide]: ../collaborator-guide.md
 [guide for writing tests in Node.js]: ../writing-tests.md
 [hiding-a-comment]: https://help.github.com/articles/managing-disruptive-comments/#hiding-a-comment
 [https://ci.nodejs.org/]: https://ci.nodejs.org/
+[pull request template]: https://raw.githubusercontent.com/nodejs/node/HEAD/.github/PULL_REQUEST_TEMPLATE.md
 [running tests]: ../../../BUILDING.md#running-tests
diff --git a/doc/guides/cpp-style-guide.md b/doc/guides/cpp-style-guide.md
index 56f3f5b4c840943355cd2a48e03dfa8315376adc..10fd7f9a00a5c6d60a01f4bf0f0259db3d68f492 100644
--- a/doc/guides/cpp-style-guide.md
+++ b/doc/guides/cpp-style-guide.md
@@ -1,11 +1,11 @@
-# C++ Style Guide
+# C++ style guide
 
 See also the [C++ codebase README](../../src/README.md) for C++ idioms in the
 Node.js codebase not related to stylistic issues.
 
-## Table of Contents
+## Table of contents
 
-* [Guides and References](#guides-and-references)
+* [Guides and references](#guides-and-references)
 * [Formatting](#formatting)
   * [Left-leaning (C++ style) asterisks for pointer declarations](#left-leaning-c-style-asterisks-for-pointer-declarations)
   * [C++ style comments](#c-style-comments)
@@ -18,11 +18,11 @@ Node.js codebase not related to stylistic issues.
   * [`snake_case_` for private class fields](#snake_case_-for-private-class-fields)
   * [`snake_case` for C-like structs](#snake_case-for-c-like-structs)
   * [Space after `template`](#space-after-template)
-* [Memory Management](#memory-management)
+* [Memory management](#memory-management)
   * [Memory allocation](#memory-allocation)
   * [Use `nullptr` instead of `NULL` or `0`](#use-nullptr-instead-of-null-or-0)
   * [Use explicit pointer comparisons](#use-explicit-pointer-comparisons)
-  * [Ownership and Smart Pointers](#ownership-and-smart-pointers)
+  * [Ownership and smart pointers](#ownership-and-smart-pointers)
   * [Avoid non-const references](#avoid-non-const-references)
   * [Use AliasedBuffers to manipulate TypedArrays](#use-aliasedbuffers-to-manipulate-typedarrays)
 * [Others](#others)
@@ -32,7 +32,7 @@ Node.js codebase not related to stylistic issues.
   * [Avoid throwing JavaScript errors in C++ methods](#avoid-throwing-javascript-errors-in-c)
     * [Avoid throwing JavaScript errors in nested C++ methods](#avoid-throwing-javascript-errors-in-nested-c-methods)
 
-## Guides and References
+## Guides and references
 
 The Node.js C++ codebase strives to be consistent in its use of language
 features and idioms, as well as have some specific guidelines for the use of
@@ -179,7 +179,7 @@ For plain C-like structs snake_case can be used.
 ```cpp
 struct foo_bar {
   int name;
-}
+};
 ```
 
 ### Space after `template`
@@ -188,10 +188,10 @@ struct foo_bar {
 template <typename T>
 class FancyContainer {
  ...
-}
+};
 ```
 
-## Memory Management
+## Memory management
 
 ### Memory allocation
 
@@ -208,7 +208,7 @@ Use explicit comparisons to `nullptr` when testing pointers, i.e.
 `if (foo == nullptr)` instead of `if (foo)` and
 `foo != nullptr` instead of `!foo`.
 
-### Ownership and Smart Pointers
+### Ownership and smart pointers
 
 * [R.20][]: Use `std::unique_ptr` or `std::shared_ptr` to represent ownership
 * [R.21][]: Prefer `unique_ptr` over `shared_ptr` unless you need to share
@@ -400,7 +400,7 @@ even `try` and `catch` **will** break.
 [R.20]: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rr-owner
 [R.21]: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rr-unique
 [Run Time Type Information]: https://en.wikipedia.org/wiki/Run-time_type_information
-[aliased_buffer.h]: https://github.com/nodejs/node/blob/master/src/aliased_buffer.h#L12
+[aliased_buffer.h]: https://github.com/nodejs/node/blob/HEAD/src/aliased_buffer.h#L12
 [cppref_auto_ptr]: https://en.cppreference.com/w/cpp/memory/auto_ptr
-[errors]: https://github.com/nodejs/node/blob/master/doc/guides/using-internal-errors.md
+[errors]: https://github.com/nodejs/node/blob/HEAD/doc/guides/using-internal-errors.md
 [without C++ exception handling]: https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_exceptions.html#intro.using.exception.no
diff --git a/doc/guides/diagnostic-tooling-support-tiers.md b/doc/guides/diagnostic-tooling-support-tiers.md
index 5d935a29369a8813cb7502a293bf7a3b37920038..7672606c8fad99d60dacd2785fa22693cbd84513 100644
--- a/doc/guides/diagnostic-tooling-support-tiers.md
+++ b/doc/guides/diagnostic-tooling-support-tiers.md
@@ -1,4 +1,4 @@
-# Diagnostic Tooling Support Tiers
+# Diagnostic tooling support tiers
 
 Diagnostic tooling is important to the consumers of Node.js. It is used both
 in development and in production in order to investigate problems.  The failure
@@ -93,56 +93,56 @@ The tools are currently assigned to Tiers as follows:
 
 ## Tier 1
 
- | Tool Type | Tool/API Name             | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
- |-----------|---------------------------|-------------------------------|-------------------------|-------------|
- | FFDC | diagnostic report | Yes | Yes | 1 |
- | | | | | |
+| Tool Type | Tool/API Name             | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
+|-----------|---------------------------|-------------------------------|-------------------------|-------------|
+| FFDC | diagnostic report | Yes | Yes | 1 |
+| | | | | |
 
 ## Tier 2
 
- | Tool Type | Tool/API Name             | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
- |-----------|---------------------------|-------------------------------|-------------------------|-------------|
- |           |                           |                               |                         |             |
+| Tool Type | Tool/API Name | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
+|-----------|---------------|-------------------------------|-------------------------|-------------|
+|           |               |                               |                         |             |
 
 ## Tier 3
 
- | Tool Type | Tool/API Name                        | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
- |-----------|--------------------------------------|-------------------------------|-------------------------|-------------|
- | Profiling | V8 CPU profiler                      | Partial (V8 Tests)            | Yes                     |     1       |
- | Profiling | --prof/--prof-process flags          | Yes                           | Yes                     |     1       |
- | Profiling | V8 CodeEventHandler API              | Partial (V8 Tests)            | Yes                     |     2       |
- | Profiling | V8 --interpreted-frames-native-stack | Yes                           | Yes                     |     2       |
- | Profiling | Linux perf                           | Yes                           | Partial                 |     2       |
+| Tool Type | Tool/API Name                        | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
+|-----------|--------------------------------------|-------------------------------|-------------------------|-------------|
+| Profiling | V8 CPU profiler                      | Partial (V8 Tests)            | Yes                     |     1       |
+| Profiling | --prof/--prof-process flags          | Yes                           | Yes                     |     1       |
+| Profiling | V8 CodeEventHandler API              | Partial (V8 Tests)            | Yes                     |     2       |
+| Profiling | V8 --interpreted-frames-native-stack | Yes                           | Yes                     |     2       |
+| Profiling | Linux perf                           | Yes                           | Partial                 |     2       |
 
 ## Tier 4
 
- | Tool Type | Tool/API Name             | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
- |-----------|---------------------------|-------------------------------|-------------------------|-------------|
- |           |                           |                               |                         |             |
+| Tool Type | Tool/API Name | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
+|-----------|---------------|-------------------------------|-------------------------|-------------|
+|           |               |                               |                         |             |
 
 ## Not yet classified
 
- | Tool Type | Tool/API Name             | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
- |-----------|---------------------------|-------------------------------|-------------------------|-------------|
- | FFDC      | node-report               | No                            | No                      |     1       |
- | Memory    | mdb_V8                    | No                            | No                      |     4       |
- | Memory    | node-heapdump             | No                            | No                      |     2       |
- | Memory    | V8 heap profiler          | No                            | Yes                     |     1       |
- | Memory    | V8 sampling heap profiler | No                            | Yes                     |     1       |
- | AsyncFlow | Async Hooks (API)         | ?                             | Yes                     |     1       |
- | Debugger  | V8 Debug protocol (API)   | No                            | Yes                     |     1       |
- | Debugger  | Command line Debug Client | ?                             | Yes                     |     1       |
- | Debugger  | llnode                    | ?                             | No                      |     2       |
- | Debugger  | Chrome Dev tools          | ?                             | No                      |     3       |
- | Debugger  | Chakracore - time-travel  | No                            | Data source only        | too early   |
- | Tracing   | trace_events (API)        | No                            | Yes                     |     1       |
- | Tracing   | DTrace                    | No                            | Partial                 |     3       |
- | Tracing   | LTTng                     | No                            | Removed?                |     N/A     |
- | Tracing   | ETW                       | No                            | Partial                 |     3       |
- | Tracing   | Systemtap                 | No                            | Partial                 |     ?       |
- | Profiling | DTrace                    | No                            | Partial                 |     3       |
- | Profiling | Windows Xperf             | No                            | ?                       |     ?       |
- | Profiling | 0x                        | No                            | No                      |     4       |
- | Profiling | node-clinic               | No                            | No                      | too early   |
- | F/P/T     | appmetrics                | No                            | No                      |     ?       |
- | M/T       | eBPF tracing tool         | No                            | No                      |     ?       |
+| Tool Type | Tool/API Name             | Regular Testing in Node.js CI | Integrated with Node.js | Target Tier |
+|-----------|---------------------------|-------------------------------|-------------------------|-------------|
+| FFDC      | node-report               | No                            | No                      |     1       |
+| Memory    | mdb_V8                    | No                            | No                      |     4       |
+| Memory    | node-heapdump             | No                            | No                      |     2       |
+| Memory    | V8 heap profiler          | No                            | Yes                     |     1       |
+| Memory    | V8 sampling heap profiler | No                            | Yes                     |     1       |
+| AsyncFlow | Async Hooks (API)         | ?                             | Yes                     |     1       |
+| Debugger  | V8 Debug protocol (API)   | No                            | Yes                     |     1       |
+| Debugger  | Command line Debug Client | ?                             | Yes                     |     1       |
+| Debugger  | llnode                    | ?                             | No                      |     2       |
+| Debugger  | Chrome Dev tools          | ?                             | No                      |     3       |
+| Debugger  | Chakracore - time-travel  | No                            | Data source only        | too early   |
+| Tracing   | trace_events (API)        | No                            | Yes                     |     1       |
+| Tracing   | DTrace                    | No                            | Partial                 |     3       |
+| Tracing   | LTTng                     | No                            | Removed?                |     N/A     |
+| Tracing   | ETW                       | No                            | Partial                 |     3       |
+| Tracing   | Systemtap                 | No                            | Partial                 |     ?       |
+| Profiling | DTrace                    | No                            | Partial                 |     3       |
+| Profiling | Windows Xperf             | No                            | ?                       |     ?       |
+| Profiling | 0x                        | No                            | No                      |     4       |
+| Profiling | node-clinic               | No                            | No                      | too early   |
+| F/P/T     | appmetrics                | No                            | No                      |     ?       |
+| M/T       | eBPF tracing tool         | No                            | No                      |     ?       |
diff --git a/doc/guides/doc-style-guide.md b/doc/guides/doc-style-guide.md
index b1cde790385c902c67ff6e2b4a318a83bec19853..26322e6c7ba3b0a2f160e2f1fdeeff03df57e0d4 100644
--- a/doc/guides/doc-style-guide.md
+++ b/doc/guides/doc-style-guide.md
@@ -16,16 +16,14 @@ this guide.
 * Documents should be word-wrapped at 80 characters.
 * `.editorconfig` describes the preferred formatting.
   * A [plugin][] is available for some editors to apply these rules.
-* Check changes to documentation with `make lint-md`.
-* Use American English spelling.
-  * OK: _capitalize_, _color_
-  * NOT OK: _capitalise_, _colour_
-* Use [serial commas][].
-* Avoid personal pronouns (_I_, _you_, _we_) in reference documentation.
-  * Personal pronouns are acceptable in colloquial documentation such as guides.
-  * Use gender-neutral pronouns and gender-neutral plural nouns.
-    * OK: _they_, _their_, _them_, _folks_, _people_, _developers_
-    * NOT OK: _his_, _hers_, _him_, _her_, _guys_, _dudes_
+* Check changes to documentation with `make test-doc -j` or `vcbuild test-doc`.
+* [Use US spelling][].
+* [Use serial commas][].
+* Avoid first-person pronouns (_I_, _we_).
+  * Exception: _we recommend foo_ is preferable to _foo is recommended_.
+* Use gender-neutral pronouns and gender-neutral plural nouns.
+  * OK: _they_, _their_, _them_, _folks_, _people_, _developers_
+  * NOT OK: _his_, _hers_, _him_, _her_, _guys_, _dudes_
 * When combining wrapping elements (parentheses and quotes), place terminal
   punctuation:
   * Inside the wrapping element if the wrapping element contains a complete
@@ -41,21 +39,21 @@ this guide.
   * Use [language][]-aware fences. (<code>```js</code>)
   * For the [info string][], use one of the following.
 
-    | Meaning       | Info string       |
-    | ------------- | ----------------- |
-    | Bash          | `bash`            |
-    | C             | `c`               |
-    | C++           | `cpp`             |
-    | CoffeeScript  | `coffee`          |
-    | Diff          | `diff`            |
-    | HTTP          | `http`            |
-    | JavaScript    | `js`              |
-    | JSON          | `json`            |
-    | Markdown      | `markdown`        |
-    | Plaintext     | `text`            |
-    | Powershell    | `powershell`      |
-    | R             | `r`               |
-    | Shell Session | `console`         |
+    | Meaning       | Info string  |
+    | ------------- | ------------ |
+    | Bash          | `bash`       |
+    | C             | `c`          |
+    | C++           | `cpp`        |
+    | CoffeeScript  | `coffee`     |
+    | Diff          | `diff`       |
+    | HTTP          | `http`       |
+    | JavaScript    | `js`         |
+    | JSON          | `json`       |
+    | Markdown      | `markdown`   |
+    | Plaintext     | `text`       |
+    | Powershell    | `powershell` |
+    | R             | `r`          |
+    | Shell Session | `console`    |
 
     If one of your language-aware fences needs an info string that is not
     already on this list, you may use `text` until the grammar gets added to
@@ -86,32 +84,29 @@ this guide.
 * Use _Node.js_ and not _Node_, _NodeJS_, or similar variants.
   <!-- lint enable prohibited-strings remark-lint-->
   * When referring to the executable, _`node`_ is acceptable.
-* Be direct.
-  * OK: The return value is a string.
-  <!-- lint disable prohibited-strings remark-lint-->
-  * NOT OK: It is important to note that, in all cases, the return value will be
-    a string regardless.
-* For headings, use sentence case, not title case.
-  <!-- lint enable prohibited-strings remark-lint-->
-  * OK: _## Everybody to the limit_
-  * NOT OK: _## Everybody To The Limit_
+* [Be direct][].
+<!-- lint disable prohibited-strings remark-lint-->
 * When referring to a version of Node.js in prose, use _Node.js_ and the version
   number. Do not prefix the version number with _v_ in prose. This is to avoid
-  confusion about whether _V8_ refers to Node.js 8.x or the V8 JavaScript
+  confusion about whether _v8_ refers to Node.js 8.x or the V8 JavaScript
   engine.
   <!-- lint enable prohibited-strings remark-lint-->
   * OK: _Node.js 14.x_, _Node.js 14.3.1_
   * NOT OK: _Node.js v14_
+* [Use sentence-style capitalization for headings][].
 
 See also API documentation structure overview in [doctools README][].
 
 For topics not covered here, refer to the [Microsoft Writing Style Guide][].
 
+[Be direct]: https://docs.microsoft.com/en-us/style-guide/word-choice/use-simple-words-concise-sentences
 [Javascript type]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Data_structures_and_types
 [Microsoft Writing Style Guide]: https://docs.microsoft.com/en-us/style-guide/welcome/
+[Use US spelling]: https://docs.microsoft.com/en-us/style-guide/word-choice/use-us-spelling-avoid-non-english-words
+[Use sentence-style capitalization for headings]: https://docs.microsoft.com/en-us/style-guide/scannable-content/headings#formatting-headings
+[Use serial commas]: https://docs.microsoft.com/en-us/style-guide/punctuation/commas
 [`remark-preset-lint-node`]: https://github.com/nodejs/remark-preset-lint-node
 [doctools README]: ../../tools/doc/README.md
 [info string]: https://github.github.com/gfm/#info-string
-[language]: https://github.com/highlightjs/highlight.js/blob/master/SUPPORTED_LANGUAGES.md
+[language]: https://github.com/highlightjs/highlight.js/blob/HEAD/SUPPORTED_LANGUAGES.md
 [plugin]: https://editorconfig.org/#download
-[serial commas]: https://en.wikipedia.org/wiki/Serial_comma
diff --git a/doc/guides/investigating_native_memory_leak.md b/doc/guides/investigating_native_memory_leak.md
index f0a156286e3e5fbc64cdca9ec70ee76fbd3f48d9..55ba1b1ec3d60b030edc395f2fb0d6872c1a9fcb 100644
--- a/doc/guides/investigating_native_memory_leak.md
+++ b/doc/guides/investigating_native_memory_leak.md
@@ -1,4 +1,4 @@
-# Investigating Memory Leaks with valgrind
+# Investigating memory leaks with valgrind
 
 A Node.js process may run out of memory due to excessive consumption of
 native memory. Native Memory is memory which is not managed by the
diff --git a/doc/guides/maintaining-V8.md b/doc/guides/maintaining-V8.md
index f7e836194ae0e9bb01e7e3ee5c9ea35abd989490..6234b29bc2b2254cf0a36f418cec24b7e6b012ba 100644
--- a/doc/guides/maintaining-V8.md
+++ b/doc/guides/maintaining-V8.md
@@ -12,7 +12,7 @@ This document attempts to outline the current maintenance processes, proposes
 a workflow for maintaining the V8 branches in both Node.js LTS and current
 releases, and discusses how the Node.js and V8 teams at Google can help.
 
-## V8 Release Schedule
+## V8 release schedule
 
 V8 and Chromium follow a
 [roughly 6-week release cadence][ChromiumReleaseCalendar]. At any given time
@@ -30,7 +30,7 @@ For example, at the time of this writing:
 
 All older branches are abandoned and are not maintained by the V8 team.
 
-### V8 Merge Process Overview
+### V8 merge process overview
 
 The process for backporting bug fixes to active branches is officially
 documented [on the V8 wiki][V8MergingPatching]. The summary of the process is:
@@ -48,7 +48,7 @@ documented [on the V8 wiki][V8MergingPatching]. The summary of the process is:
 * Merge requests to an abandoned branch will be rejected.
 * Only bug fixes are accepted for backporting.
 
-## Node.js Support Requirements
+## Node.js support requirements
 
 At any given time Node.js needs to be maintaining a few different V8 branches
 for the various Current, LTS, and nightly releases. At present this list
@@ -146,7 +146,7 @@ abandoned by upstream V8. However, Node.js needs to continue supporting
 these branches for many months (Current branches) or several
 years (LTS branches).
 
-## Maintenance Process
+## Maintenance process
 
 Once a bug in Node.js has been identified to be caused by V8, the first step is
 to identify the versions of Node.js and V8 affected. The bug may be present in
@@ -160,7 +160,7 @@ process.
 * Backports identified by the V8 team. Bugs identified by upstream V8 that we
   haven't encountered in Node.js yet.
 
-### Unfixed Upstream Bugs
+### Unfixed upstream bugs
 
 If the bug can be reproduced on the [Node.js `canary` branch][], Chromium
 canary, or V8 tip-of-tree, and the test case is valid, then the bug needs to be
@@ -176,10 +176,10 @@ fixed upstream first.
   branches that are still active or are branches that Node.js cares about.
   Follow the process for backporting below.
 
-### Backporting to Active Branches
+### Backporting to active branches
 
 If the bug exists in any of the active V8 branches, we may need to get the fix
-backported. At any given time there are [two active branches][V8ActiveBranches]
+backported. At any given time, there are [two active branches][V8ActiveBranches]
 (beta and stable) in addition to master. The following steps are needed to
 backport the fix:
 
@@ -191,9 +191,7 @@ backport the fix:
   * If a bug already exists
     * Add a reference to the GitHub issue.
     * Attach *merge-request-x.x* labels to the bug for any active branches
-      that still contain the bug. (e.g. merge-request-5.3,
-      merge-request-5.4)
-    * Add ofrobots-at-google.com to the cc list.
+      that still contain the bug.
 * Once the merge has been approved, it should be merged using the
   [merge script documented in the V8 wiki][V8MergingPatching]. Merging requires
   commit access to the V8 repository. If you don't have commit access you can
@@ -205,7 +203,7 @@ backport the fix:
 * Once the fix has been merged upstream, it can be picked up during an update of
   the V8 branch (see below).
 
-### Backporting to Abandoned Branches
+### Backporting to abandoned branches
 
 Abandoned V8 branches are supported in the Node.js repository. The fix needs
 to be cherry-picked in the Node.js repository and V8-CI must test the change.
@@ -215,21 +213,16 @@ to be cherry-picked in the Node.js repository and V8-CI must test the change.
   * Checkout a branch off the appropriate *vY.x-staging* branch (e.g.
     *v6.x-staging* to fix an issue in V8 5.1).
   * Cherry-pick the commit(s) from the V8 repository.
-  * On Node.js < 9.0.0: Increase the patch level version in `v8-version.h`.
-    This will not cause any problems with versioning because V8 will not
-    publish other patches for this branch, so Node.js can effectively bump the
-    patch version.
-  * On Node.js >= 9.0.0: Increase the `v8_embedder_string` number in
-    `common.gypi`.
+  * Increase the `v8_embedder_string` number in `common.gypi`.
   * In some cases the patch may require extra effort to merge in case V8 has
-    changed substantially. For important issues we may be able to lean on the
+    changed substantially. For important issues, we may be able to lean on the
     V8 team to get help with reimplementing the patch.
-  * Open a cherry-pick PR on `nodejs/node` targeting the *vY.x-staging* branch
-    and notify the `@nodejs/v8` team.
+  * Open a cherry-pick pull request on `nodejs/node` targeting the
+    *vY.x-staging* branch and notify the `@nodejs/v8` team.
   * Run the Node.js [V8 CI][] in addition to the [Node.js CI][].
     The CI uses the `test-v8` target in the `Makefile`, which uses
     `tools/make-v8.sh` to reconstruct a git tree in the `deps/v8` directory to
-    run V8 tests.
+    run V8 tests<sup>2</sup>.
 
 The [`git-node`][] tool can be used to simplify this task. Run
 `git node v8 backport <sha>` to cherry-pick a commit.
@@ -246,8 +239,7 @@ fix needed to be cherry-picked. To cherry-pick, here's an example workflow:
   not apply cleanly. It may help to try to cherry-pick the merge to the oldest
   branch that was done upstream in V8. In this example, this would be the patch
   from the merge to 5.2. The hope is that this would be closer to the V8 5.1,
-  and has a better chance of applying cleanly. If you're stuck, feel free to
-  ping @ofrobots for help.
+  and has a better chance of applying cleanly.
 * Modify the commit message to match the format we use for V8 backports and
   replace yourself as the author. `git commit --amend --reset-author`. You may
   want to add extra description if necessary to indicate the impact of the fix
@@ -274,11 +266,11 @@ Refs: https://github.com/v8/v8/commit/a51f429772d1e796744244128c9feeab4c26a854
 PR-URL: https://github.com/nodejs/node/pull/7833
 ```
 
-* Open a PR against the `v6.x-staging` branch in the Node.js repo. Launch the
-  normal and [V8 CI][] using the Node.js CI system. We only needed to backport
-  to `v6.x` as the other LTS branches weren't affected by this bug.
+* Open a PR against the `v6.x-staging` branch in the Node.js repository. Launch
+  the normal and [V8 CI][] using the Node.js CI system. We only needed to
+  backport to `v6.x` as the other LTS branches weren't affected by this bug.
 
-### Backports Identified by the V8 Team
+### Backports identified by the V8 team
 
 For bugs found through the browser or other channels, the V8 team marks bugs
 that might be applicable to the abandoned branches in use by Node.js. This is
@@ -313,7 +305,11 @@ Node.js keeps a vendored copy of V8 inside of the deps/ directory. In addition,
 Node.js may need to float patches that do not exist upstream. This means that
 some care may need to be taken to update the vendored copy of V8.
 
-### Minor Updates (Patch Level)
+V8 builds against the version of ICU supplied by Node.js,
+see [maintaining-icu.md](./maintaining-icu.md) for special considerations.
+Specifically, a V8 update may necessitate an ICU update.
+
+### Minor updates (patch level)
 
 Because there may be floating patches on the version of V8 in Node.js, it is
 safest to apply the patch level updates as a patch. For example, imagine that
@@ -343,7 +339,7 @@ Revision* from the 5.4 branch that can be useful in the update process above.
 The [`git-node`][] tool can be used to simplify this task. Run `git node v8 minor`
 to apply a minor update.
 
-### Major Updates
+### Major updates
 
 We upgrade the version of V8 in Node.js master whenever a V8 release goes stable
 upstream, that is, whenever a new release of Chrome comes out.
@@ -378,7 +374,7 @@ git node v8 major --branch=5.1-lkgr
 
 This should be followed up with manual refloating of all relevant patches.
 
-## Proposal: Using a Fork Repo to Track Upstream V8
+## Proposal: Using a fork repository to track upstream V8
 
 The fact that Node.js keeps a vendored, potentially edited copy of V8 in deps/
 makes the above processes a bit complicated. An alternative proposal would be to
@@ -410,6 +406,11 @@ This would require some tooling to:
 <sup>1</sup>Node.js 0.12 and older are intentionally omitted from this document
 as their support has ended.
 
+<sup>2</sup>The V8 tests still require Python 2. To run these tests locally,
+you can run `PYTHON2 ./configure.py` before running `make test-v8`, in the root
+of this repository. On macOS, this also requires a full Xcode install,
+not just the "command line tools" for Xcode.
+
 [ChromiumReleaseCalendar]: https://www.chromium.org/developers/calendar
 [Node.js CI]: https://ci.nodejs.org/job/node-test-pull-request/
 [Node.js `canary` branch]: https://github.com/nodejs/node-v8/tree/canary
@@ -427,4 +428,4 @@ as their support has ended.
 [V8MergingPatching]: https://github.com/v8/v8/wiki/Merging%20&%20Patching
 [V8TemplateMergeRequest]: https://bugs.chromium.org/p/v8/issues/entry?template=Node.js%20merge%20request
 [V8TemplateUpstreamBug]: https://bugs.chromium.org/p/v8/issues/entry?template=Node.js%20upstream%20bug
-[`git-node`]: https://github.com/nodejs/node-core-utils/blob/master/docs/git-node.md#git-node-v8
+[`git-node`]: https://github.com/nodejs/node-core-utils/blob/HEAD/docs/git-node.md#git-node-v8
diff --git a/doc/guides/maintaining-c-ares.md b/doc/guides/maintaining-c-ares.md
new file mode 100644
index 0000000000000000000000000000000000000000..968b96f25820d1e6fd801fcdbac1b904b96beb0a
--- /dev/null
+++ b/doc/guides/maintaining-c-ares.md
@@ -0,0 +1,66 @@
+# Maintaining c-ares
+
+Updates to the c-ares dependency involve the following steps:
+
+1. Downloading the source archive for the new version.
+2. Unpacking the source in a temporary workspace directory.
+3. Removing the `test` directory (to save disk space).
+4. Copying over the existing `.gitignore`, pre-generated `config` directory and
+   `cares.gyp` files.
+5. Replacing the existing `deps/cares` with the workspace directory.
+6. Modifying the `cares.gyp` file for file additions/deletions.
+7. Rebuilding the main Node.js `LICENSE`.
+
+## Running the update script
+
+The `tools/update-cares.sh` script automates the update of the c-ares source
+files, preserving the existing files added by Node.js.
+
+In the following examples, `x.y.z` should match the c-ares version to update to.
+
+```console
+./tools/update-cares.sh x.y.z
+```
+
+e.g.
+
+```console
+./tools/update-cares.sh 1.18.1
+```
+
+## Check that Node.js still builds and tests
+
+It may be necessary to update `deps/cares/cares.gyp` if any significant changes
+have occurred upstream.
+
+## Rebuild the main Node.js license
+
+Run the `tools/license-builder.sh` script to rebuild the main Node.js `LICENSE`
+file. This may result in no changes if c-ares' license has not changed.
+
+```console
+./tools/license-builder.sh
+```
+
+If the updated `LICENSE` contains changes for other dependencies, those should
+be done in a separate pull request first.
+
+## Commit the changes
+
+```console
+git add -A deps/cares
+```
+
+Add the rebuilt `LICENSE` if it has been updated.
+
+```console
+git add LICENSE
+```
+
+Commit the changes with a message like
+
+```text
+deps: update c-ares to x.y.z
+
+Updated as described in doc/guides/maintaining-c-ares.md.
+```
diff --git a/doc/guides/maintaining-icu.md b/doc/guides/maintaining-icu.md
new file mode 100644
index 0000000000000000000000000000000000000000..a9d075d47007b6f65f6efb25845cbcc594e45a2f
--- /dev/null
+++ b/doc/guides/maintaining-icu.md
@@ -0,0 +1,267 @@
+# Maintaining ICU in Node.js
+
+## Background
+
+International Components for Unicode ([ICU4C][ICU]) is used both by V8
+and also by Node.js directly to provide internationalization
+functionality. To quote from icu-project.org:
+
+> ICU is a mature, widely used set of C/C++ and Java libraries providing
+> Unicode and Globalization support for software applications. ICU is
+> widely portable and gives applications the same results on all platforms
+> and between C/C++ and Java software.
+
+## Data dependencies
+
+ICU consumes and includes:
+
+* Extracted locale data from [CLDR][]
+* Extracted [Unicode][] data.
+* Time zone ([tz][]) data
+
+The current versions of these items can be viewed for node with `node -p process.versions`:
+
+```console
+$ node -p process.versions
+
+{
+  …
+  cldr: '35.1',
+  icu: '64.2',
+  tz: '2019a',
+  unicode: '12.1'
+}
+```
+
+### Time zone data
+
+Time zone data files are updated independently of ICU CLDR data.  ICU and its
+main data files do not need to be upgraded in order to apply time zone data file
+fixes.
+
+The [IANA tzdata][tz] project releases new versions and announces them on the
+[`tz-announce`](https://mm.icann.org/pipermail/tz-announce/) mailing list.
+
+The Unicode project takes new releases and publishes
+[updated time zone data files](https://github.com/unicode-org/icu-data/tree/HEAD/tzdata/icunew)
+in the icu/icu-data repository.
+
+All modern versions of Node.js use the version 44 ABI of the time zone data
+files.
+
+#### Example: updating the ICU `.dat` file
+
+* Decompress `deps/icu/source/data/in/icudt##l.dat.bz2`, where `##` is
+  the ICU major version number.
+* Clone the icu/icu-data repository and copy the latest `tzdata` release `le`
+  files into the `source/data/in` directory.
+* Follow the upstream [ICU instructions](https://unicode-org.github.io/icu/userguide/datetime/timezone/)
+  to patch the ICU `.dat` file:
+  > `for i in zoneinfo64.res windowsZones.res timezoneTypes.res metaZones.res;
+  > do icupkg -a $i icudt*l.dat`
+* Optionally, verify that there is only one of the above files listed when using
+  `icupkg -l`.
+* Optionally, extract each file using `icupkg -x` and verify the `shasum`
+  matches the desired value.
+* Compress the `.dat` file with the same filename as in the first step.
+* Build, test, verifying `process.versions.tz` matches the desired version.
+* Create a new minor version release.
+
+## Release schedule
+
+ICU typically has >1 release a year, particularly coinciding with a major
+release of [Unicode][]. The current release schedule is available on the [ICU][]
+website on the left sidebar.
+
+### V8 depends on ICU
+
+V8 will aggressively upgrade to a new ICU version, due to requirements for
+features/bugfixes needed for [Ecma402][] support. The minimum required version
+of ICU is specified within the V8 source tree. If the ICU version is too old,
+V8 will not compile.
+
+```c
+// deps/v8/src/objects/intl-objects.h
+#define V8_MINIMUM_ICU_VERSION 65
+```
+
+V8 in Node.js depends on the ICU version supplied by Node.js.
+
+The file `tools/icu/icu_versions.json` contains the current minimum
+version of ICU that Node.js is known to work with. This should be
+_at least_ the same version as V8, so that users will find out
+earlier that their ICU is too old.  A test case validates this when
+Node.js is built.
+
+## How to upgrade ICU
+
+* Make sure your Node.js workspace is clean (`git status`
+should be sufficient).
+* Configure Node.js with the specific [ICU version](http://site.icu-project.org/download)
+  you want to upgrade to, for example:
+
+```bash
+./configure \
+    --with-intl=full-icu \
+    --with-icu-source=https://github.com/unicode-org/icu/releases/download/release-67-1/icu4c-67_1-src.tgz
+make
+```
+
+> _Note_ in theory, the equivalent `vcbuild.bat` commands should work also,
+> but the commands below are makefile-centric.
+
+* If there are ICU version-specific changes needed, you may need to make changes
+  in `tools/icu/icu-generic.gyp` or add patch files to `tools/icu/patches`.
+  * Specifically, look for the lists in `sources!` in the `tools/icu/icu-generic.gyp` for
+  files to exclude.
+
+* Verify the Node.js build works:
+
+```bash
+make test-ci
+```
+
+Also running
+
+<!-- eslint-disable strict -->
+
+```js
+new Intl.DateTimeFormat('es', { month: 'long' }).format(new Date(9E8));
+```
+
+…Should return `enero` not `January`.
+
+* Now, run the shrink tool to update `deps/icu-small` from `deps/icu`
+
+> :warning: Do not modify any source code in `deps/icu-small` !
+> See section below about floating patches to ICU.
+
+```bash
+python tools/icu/shrink-icu-src.py
+```
+
+* Now, do a clean rebuild of Node.js to test:
+
+```bash
+make -k distclean
+./configure
+make
+```
+
+* Test this newly default-generated Node.js
+
+<!-- eslint-disable strict -->
+
+```js
+process.versions.icu;
+new Intl.DateTimeFormat('es', { month: 'long' }).format(new Date(9E8));
+```
+
+(This should print your updated ICU version number, and also `enero` again.)
+
+You are ready to check in the updated `deps/icu-small`. This is a big commit,
+so make this a separate commit from the smaller changes.
+
+> :warning: Do not modify any source code in `deps/icu-small` !
+> See section below about floating patches to ICU.
+
+* Now, rebuild the Node.js license.
+
+```bash
+# clean up - remove deps/icu
+make clean
+tools/license-builder.sh
+```
+
+* Update the URL and hash for the full ICU file in `tools/icu/current_ver.dep`.
+It should match the ICU URL used in the first step.  When this is done, the
+following should build with small ICU.
+
+```bash
+# clean up
+rm -rf out deps/icu deps/icu4c*
+./configure --with-intl=small-icu --download=all
+make
+make test-ci
+```
+
+* commit the change to `tools/icu/current_ver.dep` and `LICENSE` files.
+
+  * Note: To simplify review, I often will “pre-land” this patch, meaning that
+  I run the patch through `curl -L https://github.com/nodejs/node/pull/xxx.patch
+  | git am -3 --whitespace=fix` per the collaborator’s guide… and then push that
+  patched branch into my PR's branch. This reduces the whitespace changes that
+  show up in the PR, since the final land will eliminate those anyway.
+
+## Floating patches to ICU
+
+Floating patches are applied at `configure` time. The "patch" files
+are used instead of the original source files. The patch files are
+complete `.cpp` files replacing the original contents.
+
+Patches are tied to a specific ICU version. They won’t apply to a
+future ICU version.  We assume that you filed a bug against [ICU][] and
+upstreamed the fix, so the patch won’t be needed in a later ICU
+version.
+
+### Example
+
+For example, to patch `source/tools/toolutil/pkg_genc.cpp` for
+ICU version 63:
+
+```bash
+# go to your Node.js source directory
+cd <node>
+
+# create the floating patch directory
+mkdir -p tools/icu/patches/63
+
+# create the subdirectory for the file(s) to patch:
+mkdir -p tools/icu/patches/63/source/tools/toolutil/
+
+# copy the file to patch
+cp deps/icu-small/source/tools/toolutil/pkg_genc.cpp \
+tools/icu/patches/63/source/tools/toolutil/pkg_genc.cpp
+
+# Make any changes to this file:
+(edit tools/icu/patches/63/source/tools/toolutil/pkg_genc.cpp )
+
+# test
+make clean && ./configure && make
+```
+
+You should see a message such as:
+
+```console
+INFO: Using floating patch "tools/icu/patches/63/source/tools/toolutil/pkg_genc.cpp" from "tools/icu"
+```
+
+### Clean up
+
+Any patches older than the minimum version given in `tools/icu/icu_versions.json`
+ought to be deleted, because they will never be used.
+
+### Why not just modify the ICU source directly?
+
+Especially given the V8 dependencies above, there may be times when a floating
+patch to ICU is required.  Though it seems expedient to simply change a file in
+`deps/icu-small`, this is not the right approach for the following reasons:
+
+1. **Repeatability.** Given the complexity of merging in a new ICU version,
+following the steps above in the prior section of this document ought to be
+repeatable without concern for overriding a patch.
+
+2. **Verifiability.** Given the number of files modified in an ICU PR,
+a floating patch could easily be missed or dropped altogether next time
+something is landed.
+
+3. **Compatibility.** There are a number of ways that ICU can be loaded into
+Node.js (see the top level README.md). Only modifying `icu-small` would cause
+the patch not to be landed in case the user specifies the ICU source code
+another way.
+
+[CLDR]: http://cldr.unicode.org/
+[Ecma402]: https://github.com/tc39/ecma402
+[ICU]: http://site.icu-project.org/
+[Unicode]: https://home.unicode.org/
+[tz]: https://www.iana.org/time-zones
diff --git a/doc/guides/maintaining-npm.md b/doc/guides/maintaining-npm.md
index 986c202bb17a977da402cc1ca147e8237c2f4b63..5536fd513f8552dee55dee30bc1d1d3615676a93 100644
--- a/doc/guides/maintaining-npm.md
+++ b/doc/guides/maintaining-npm.md
@@ -10,52 +10,22 @@ are at the discretion of the release and LTS teams.
 This process only covers full updates to new versions of npm. Cherry-picked
 changes can be reviewed and landed via the normal consensus seeking process.
 
-## Step 1: Clone npm
+## Step 1: Run the update script
 
-```console
-$ git clone https://github.com/npm/cli.git npm
-$ cd npm
-```
-
-or if you already have npm cloned make sure the repo is up to date
-
-```console
-$ git remote update -p
-$ git reset --hard origin/latest
-```
-
-## Step 2: Build release
-
-```console
-$ git checkout vX.Y.Z
-$ make
-$ make release
-```
-
-Note: please run `npm dist-tag ls npm` and make sure this is the `latest`
-**dist-tag**. `latest` on git is usually released as `next` when it's time to
-downstream
-
-## Step 3: Remove old npm
+In the following examples, `x.y.z` should match the npm version to update to.
 
 ```console
-$ cd /path/to/node
-$ git remote update -p
-$ git checkout -b npm-x.y.z origin/master
-$ cd deps
-$ rm -rf npm
+$ ./tools/update-npm.sh x.y.z
 ```
 
-## Step 4: Extract and commit new npm
+## Step 2: Commit new npm
 
 ```console
-$ tar zxf /path/to/npm/release/npm-x.y.z.tgz
-$ git add -A npm
+$ git add -A deps/npm
 $ git commit -m "deps: upgrade npm to x.y.z"
-$ cd ..
 ```
 
-## Step 5: Update licenses
+## Step 3: Update licenses
 
 ```console
 $ ./configure
@@ -68,13 +38,13 @@ $ git commit -m "doc: update npm LICENSE using license-builder.sh"
 
 Note: please ensure you are only making the updates that are changed by npm.
 
-## Step 6: Apply Whitespace fix
+## Step 4: Apply whitespace fix
 
 ```console
 $ git rebase --whitespace=fix master
 ```
 
-## Step 7: Test the build
+## Step 5: Test the build
 
 ```console
 $ make test-npm
diff --git a/doc/guides/maintaining-openssl.md b/doc/guides/maintaining-openssl.md
index 75be7c10ba3957e9c071b4b5ca46ecdb21f3f11a..492eaea75cdd7a6cd7e634ed8543ec25169944ec 100644
--- a/doc/guides/maintaining-openssl.md
+++ b/doc/guides/maintaining-openssl.md
@@ -2,13 +2,28 @@
 
 This document describes how to update `deps/openssl/`.
 
+If you need to provide updates across all active release lines you will
+currently need to generate three PRs as follows:
+
+* a PR for master which is generated following the instructions
+  below which include the QUIC patch.
+* a PR for 14.x following the instruction below based on the
+  14,x branch but skipping the step to apply the QUICK patch.
+  This PR should cherry pick back to the active release lines
+  except for the 10.x line.
+* a PR which uses the same commit from the second PR to apply the
+  updates to the openssl source code, with a new commit generated
+  by following steps 2 onwards on the 10.x line. This is
+  necessary because differences in 10.x requires that the
+  configuration files be regenerated specifically for 10.x.
+
 ## Requirements
 * Linux environment.
 * `perl` Only Perl version 5 is tested.
 * `nasm` (<https://www.nasm.us/>) Version 2.11 or higher is needed.
 * GNU `as` in binutils. Version 2.26 or higher is needed.
 
-## 0. Check Requirements
+## 0. Check requirements
 
 ```console
 % perl -v
diff --git a/doc/guides/maintaining-root-certs.md b/doc/guides/maintaining-root-certs.md
index e14e2d8eca075614f12b3be3a032f67b478bddfe..8ab3764aac53bfadd57972fb6c07eb5ea7a782d1 100644
--- a/doc/guides/maintaining-root-certs.md
+++ b/doc/guides/maintaining-root-certs.md
@@ -1,4 +1,4 @@
-# Maintaining the Root Certificates
+# Maintaining the root certificates
 
 Node.js contains a compiled-in set of root certificates used as trust anchors
 for TLS certificate validation.
diff --git a/doc/guides/maintaining-the-build-files.md b/doc/guides/maintaining-the-build-files.md
index 433b387e5ee20e5e1a9408fd4bf0addf6a5d618f..548441dc0126ca0add5adc2f90f9f1fe3a0d2334 100644
--- a/doc/guides/maintaining-the-build-files.md
+++ b/doc/guides/maintaining-the-build-files.md
@@ -1,4 +1,4 @@
-# Maintaining the Build files
+# Maintaining the build files
 
 This document explains how to maintain the build files in the codebase.
 
diff --git a/doc/guides/node-postmortem-support.md b/doc/guides/node-postmortem-support.md
index 21d317204911cfbf038b618d90e448df5505ef29..b709c03b53d7512e09fd384a904cb02acd3b11ea 100644
--- a/doc/guides/node-postmortem-support.md
+++ b/doc/guides/node-postmortem-support.md
@@ -1,18 +1,18 @@
-# Postmortem Support
+# Postmortem support
 
 Postmortem metadata are constants present in the final build which can be used
 by debuggers and other tools to navigate through internal structures of software
 when analyzing its memory (either on a running process or a core dump). Node.js
 provides this metadata in its builds for V8 and Node.js internal structures.
 
-## V8 Postmortem metadata
+## V8 postmortem metadata
 
 V8 prefixes all postmortem constants with `v8dbg_`, and they allow inspection of
 objects on the heap as well as object properties and references. V8 generates
 those symbols with a script (`deps/v8/tools/gen-postmortem-metadata.py`), and
 Node.js always includes these constants in the final build.
 
-## Node.js Debug Symbols
+## Node.js debug symbols
 
 Node.js prefixes all postmortem constants with `nodedbg_`, and they complement
 V8 constants by providing ways to inspect Node.js-specific structures, like
@@ -64,7 +64,7 @@ class ReqWrap : public AsyncWrap {
 There are also tests on `test/cctest/test_node_postmortem_metadata.cc` to make
 sure all Node.js postmortem metadata are calculated correctly.
 
-## Tools and References
+## Tools and references
 
 * [llnode](https://github.com/nodejs/llnode): LLDB plugin
 * [`mdb_v8`](https://github.com/joyent/mdb_v8): mdb plugin
diff --git a/doc/guides/offboarding.md b/doc/guides/offboarding.md
index 13f602bb0f828661e9579d406911709ae2d5dbc5..2c5ecfa9018f6cdebd17c490452b08d46af2cc68 100644
--- a/doc/guides/offboarding.md
+++ b/doc/guides/offboarding.md
@@ -1,16 +1,14 @@
 # Offboarding
 
-This document is a checklist of things to do when a Collaborator becomes
-Emeritus or leaves the project.
+This document is a checklist of things to do when a collaborator becomes
+emeritus or leaves the project.
 
-* Remove the Collaborator from the @nodejs/collaborators team.
-* Open a fast-track pull request to move the Collaborator to Collaborator
-  Emeriti in README.md.
-* Email the TSC mailing list to notify TSC members that the Collaborator is
-  moving to Collaborator Emeritus.
-* Determine what GitHub teams the Collaborator belongs to. In consultation with
-  the Collaborator, determine which of those teams they should be removed from.
-  * Some teams may also require a pull request to remove the Collaborator from
+* Remove the collaborator from the @nodejs/collaborators team.
+* Open a fast-track pull request to move the collaborator to the collaborator
+  emeriti list in README.md.
+* Determine what GitHub teams the collaborator belongs to. In consultation with
+  the collaborator, determine which of those teams they should be removed from.
+  * Some teams may also require a pull request to remove the collaborator from
     a team listing. For example, if someone is removed from @nodejs/build,
     they should also be removed from the Build WG README.md file in the
     <https://github.com/nodejs/build> repository.
diff --git a/doc/guides/onboarding-extras.md b/doc/guides/onboarding-extras.md
deleted file mode 100644
index 030074093eef364e9e9c4f94a5cbb34b5bbe10cd..0000000000000000000000000000000000000000
--- a/doc/guides/onboarding-extras.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# Additional onboarding information
-
-## Labels
-
-### Subsystems
-
-* `lib/*.js` (`assert`, `buffer`, etc.)
-* `build`
-* `doc`
-* `lib / src`
-* `test`
-* `tools`
-
-More than one subsystem may be valid for any particular issue or pull request.
-
-### General
-
-* `confirmed-bug`: Bugs you have verified
-* `discuss`: Things that need larger discussion
-* `feature request`: Any issue that requests a new feature
-* `good first issue`: Issues suitable for newcomers to fix
-* `meta`: Governance, policies, procedures, etc.
-* `tsc-agenda`: Open issues and pull requests with this label will be added to
-  the Technical Steering Committee meeting agenda
-
----
-
-* `author-ready` - A pull request is _author ready_ when:
-  * There is a CI run in progress or completed.
-  * There is at least one Collaborator approval (or two TSC approvals for
-    semver-major PRs).
-  * There are no outstanding review comments.
-
-Please always add the `author ready` label to pull requests that qualify.
-Please always remove it again as soon as the conditions are not met anymore,
-such as if the CI run fails or a new outstanding review comment is posted.
-
----
-
-* `semver-{minor,major}`
-  * be conservative – that is, if a change has the remote *chance* of breaking
-    something, go for semver-major
-  * when adding a semver label, add a comment explaining why you're adding it
-  * minor vs. patch: roughly: "does it add a new method / does it add a new
-    section to the docs"
-  * major vs. everything else: run last versions tests against this version, if
-    they pass, **probably** minor or patch
-
-### LTS/version labels
-
-We use labels to keep track of which branches a commit should land on:
-
-* `dont-land-on-v?.x`
-  * For changes that do not apply to a certain release line
-  * Also used when the work of backporting a change outweighs the benefits
-* `land-on-v?.x`
-  * Used by releasers to mark a PR as scheduled for inclusion in an LTS release
-  * Applied to the original PR for clean cherry-picks, to the backport PR
-    otherwise
-* `backport-requested-v?.x`
-  * Used to indicate that a PR needs a manual backport to a branch in order to
-    land the changes on that branch
-  * Typically applied by a releaser when the PR does not apply cleanly or it
-    breaks the tests after applying
-  * Will be replaced by either `dont-land-on-v?.x` or `backported-to-v?.x`
-* `backported-to-v?.x`
-  * Applied to PRs for which a backport PR has been merged
-* `lts-watch-v?.x`
-  * Applied to PRs which the LTS working group should consider including in a
-    LTS release
-  * Does not indicate that any specific action will be taken, but can be
-    effective as messaging to non-collaborators
-* `lts-agenda`
-  * For things that need discussion by the LTS working group
-  * (for example semver-minor changes that need or should go into an LTS
-    release)
-* `v?.x`
-  * Automatically applied to changes that do not target `master` but rather the
-    `v?.x-staging` branch
-
-Once a release line enters maintenance mode, the corresponding labels do not
-need to be attached anymore, as only important bugfixes will be included.
-
-### Other labels
-
-* Operating system labels
-  * `macos`, `windows`, `smartos`, `aix`
-  * No `linux` label because it is the implied default
-* Architecture labels
-  * `arm`, `mips`, `s390`, `ppc`
-  * No `x86{_64}` label because it is the implied default
diff --git a/doc/guides/releases.md b/doc/guides/releases.md
index fbbb43b4e3e7a4279b2e296d252bbd8a2220f771..d3c0712b73768c5cce4c54d4f42a0350748338fe 100644
--- a/doc/guides/releases.md
+++ b/doc/guides/releases.md
@@ -1,48 +1,48 @@
-# Node.js Release Process
+# Node.js release process
 
 This document describes the technical aspects of the Node.js release process.
 The intended audience is those who have been authorized by the Node.js
 Technical Steering Committee (TSC) to create, promote, and sign
 official release builds for Node.js, hosted on <https://nodejs.org/>.
 
-## Table of Contents
+## Table of contents
 
 * [Who can make a release?](#who-can-make-a-release)
-  * [1. Jenkins Release Access](#1-jenkins-release-access)
-  * [2. <nodejs.org> Access](#2-nodejsorg-access)
-  * [3. A Publicly Listed GPG Key](#3-a-publicly-listed-gpg-key)
+  * [1. Jenkins release access](#1-jenkins-release-access)
+  * [2. <nodejs.org> access](#2-nodejsorg-access)
+  * [3. A publicly listed GPG key](#3-a-publicly-listed-gpg-key)
 * [How to create a release](#how-to-create-a-release)
   * [0. Pre-release steps](#0-pre-release-steps)
   * [1. Update the staging branch](#1-update-the-staging-branch)
   * [2. Create a new branch for the release](#2-create-a-new-branch-for-the-release)
   * [3. Update `src/node_version.h`](#3-update-srcnode_versionh)
-  * [4. Update the Changelog](#4-update-the-changelog)
-  * [5. Create Release Commit](#5-create-release-commit)
-  * [6. Propose Release on GitHub](#6-propose-release-on-github)
-  * [7. Ensure that the Release Branch is Stable](#7-ensure-that-the-release-branch-is-stable)
-  * [8. Produce a Nightly Build _(optional)_](#8-produce-a-nightly-build-optional)
-  * [9. Produce Release Builds](#9-produce-release-builds)
-  * [10. Test the Build](#10-test-the-build)
-  * [11. Tag and Sign the Release Commit](#11-tag-and-sign-the-release-commit)
-  * [12. Set Up For the Next Release](#12-set-up-for-the-next-release)
-  * [13. Cherry-pick the Release Commit to `master`](#13-cherry-pick-the-release-commit-to-master)
+  * [4. Update the changelog](#4-update-the-changelog)
+  * [5. Create release commit](#5-create-release-commit)
+  * [6. Propose release on GitHub](#6-propose-release-on-github)
+  * [7. Ensure that the release branch is stable](#7-ensure-that-the-release-branch-is-stable)
+  * [8. Produce a nightly build _(optional)_](#8-produce-a-nightly-build-optional)
+  * [9. Produce release builds](#9-produce-release-builds)
+  * [10. Test the build](#10-test-the-build)
+  * [11. Tag and sign the release commit](#11-tag-and-sign-the-release-commit)
+  * [12. Set up for the next release](#12-set-up-for-the-next-release)
+  * [13. Cherry-pick the release commit to `master`](#13-cherry-pick-the-release-commit-to-master)
   * [14. Push the release tag](#14-push-the-release-tag)
-  * [15. Promote and Sign the Release Builds](#15-promote-and-sign-the-release-builds)
-  * [16. Check the Release](#16-check-the-release)
-  * [17. Create a Blog Post](#17-create-a-blog-post)
+  * [15. Promote and sign the release builds](#15-promote-and-sign-the-release-builds)
+  * [16. Check the release](#16-check-the-release)
+  * [17. Create a blog post](#17-create-a-blog-post)
   * [18. Create the release on GitHub](#18-create-the-release-on-github)
   * [19. Cleanup](#19-cleanup)
   * [20. Announce](#20-announce)
   * [21. Celebrate](#21-celebrate)
-* [LTS Releases](#lts-releases)
-* [Major Releases](#major-releases)
+* [LTS releases](#lts-releases)
+* [Major releases](#major-releases)
 
 ## Who can make a release?
 
 Release authorization is given by the Node.js TSC. Once authorized, an
 individual must have the following:
 
-### 1. Jenkins Release Access
+### 1. Jenkins release access
 
 There are three relevant Jenkins jobs that should be used for a release flow:
 
@@ -64,7 +64,7 @@ a manual step once they are ready (see below).
 The [Node.js build team](https://github.com/nodejs/build) is able to provide
 this access to individuals authorized by the TSC.
 
-### 2. <nodejs.org> Access
+### 2. <nodejs.org> access
 
 The _dist_ user on nodejs.org controls the assets available in
 <https://nodejs.org/download/>. <https://nodejs.org/dist/> is an alias for
@@ -82,7 +82,7 @@ server as the _dist_ user. The
 [Node.js build team](https://github.com/nodejs/build) is able to provide this
 access to individuals authorized by the TSC.
 
-### 3. A Publicly Listed GPG Key
+### 3. A publicly-listed GPG key
 
 A `SHASUMS256.txt` file is produced for every promoted build, nightly, and
 releases. Additionally for releases, this file is signed by the individual
@@ -128,7 +128,7 @@ Build is essential to make sure that the CI works, release files are published,
 and the release blog post is available on the project website.
 
 Build can be contacted best by opening up an issue on the [Build issue
-tracker][], and by posting in `#node-build` on [webchat.freenode.net][].
+tracker][].
 
 When preparing a security release, contact Build at least two weekdays in
 advance of the expected release. To ensure that the security patch(es) can be
@@ -175,10 +175,10 @@ duplicate or not.
 For a list of commits that could be landed in a patch release on v1.x:
 
 ```console
-$ branch-diff v1.x-staging master --exclude-label=semver-major,semver-minor,dont-land-on-v1.x,backport-requested-v1.x --filter-release --format=simple
+$ branch-diff v1.x-staging master --exclude-label=semver-major,semver-minor,dont-land-on-v1.x,backport-requested-v1.x,backport-blocked-v1.x,backport-open-v1.x,backported-to-v1.x --filter-release --format=simple
 ```
 
-Previous release commits and version bumps do not need to be
+Previously released commits and version bumps do not need to be
 cherry-picked.
 
 Carefully review the list of commits:
@@ -187,17 +187,30 @@ Carefully review the list of commits:
 * Checking semver status - Commits labeled as `semver-minor` or `semver-major`
 should only be cherry-picked when appropriate for the type of release being
 made.
-* If you think it's risky so should wait for a while, add the `baking-for-lts`
-tag.
+* If you think it's risky and the change should wait for a while, add the
+`baking-for-lts` tag.
+
+When you are ready to cherry-pick commits, you can automate with the following
+command. (For semver-minor releases, make sure to remove the `semver-minor` tag
+from `exclude-label`.)
+
+```console
+$ branch-diff v1.x-staging master --exclude-label=semver-major,semver-minor,dont-land-on-v1.x,backport-requested-v1.x,backport-blocked-v1.x,backport-open-v1.x,backported-to-v1.x --filter-release --format=sha --reverse | xargs git cherry-pick
+```
 
 When cherry-picking commits, if there are simple conflicts you can resolve
 them. Otherwise, add the `backport-requested-vN.x` label to the original PR
 and post a comment stating that it does not land cleanly and will require a
 backport PR. You can refer the owner of the PR to the "[Backporting to Release
- Lines](https://github.com/nodejs/node/blob/master/doc/guides/backporting-to-release-lines.md)" guide.
+ Lines](https://github.com/nodejs/node/blob/HEAD/doc/guides/backporting-to-release-lines.md)" guide.
 
-If commits were cherry-picked in this step, check that the test still pass and
-push to the staging branch to keep it up-to-date.
+If commits were cherry-picked in this step, check that the test still pass.
+
+```console
+$ make test
+```
+
+Then, push to the staging branch to keep it up-to-date.
 
 ```console
 $ git push upstream v1.x-staging
@@ -230,35 +243,7 @@ be produced with a version string that does not have a trailing pre-release tag:
 #define NODE_VERSION_IS_RELEASE 1
 ```
 
-**Also consider whether to bump `NODE_MODULE_VERSION`**:
-
-This macro is used to signal an ABI version for native addons. It currently has
-two common uses in the community:
-
-* Determining what API to work against for compiling native addons, e.g.
-  [NAN](https://github.com/nodejs/nan) uses it to form a compatibility-layer for
-  much of what it wraps.
-* Determining the ABI for downloading pre-built binaries of native addons, e.g.
-  [node-pre-gyp](https://github.com/mapbox/node-pre-gyp) uses this value as
-  exposed via `process.versions.modules` to help determine the appropriate
-  binary to download at install-time.
-
-The general rule is to bump this version when there are _breaking ABI_ changes
-and also if there are non-trivial API changes. The rules are not yet strictly
-defined, so if in doubt, please confer with someone that will have a more
-informed perspective, such as a member of the NAN team.
-
-A registry of currently used `NODE_MODULE_VERSION` values is maintained at
-<https://github.com/nodejs/node/blob/master/doc/abi_version_registry.json>.
-When bumping `NODE_MODULE_VERSION`, you should choose a new value not listed
-in the registry. Also include a change to the registry in your commit to
-reflect the newly used value.
-
-It is current TSC policy to bump major version when ABI changes. If you
-see a need to bump `NODE_MODULE_VERSION` then you should consult the TSC.
-Commits may need to be reverted or a major version bump may need to happen.
-
-### 4. Update the Changelog
+### 4. Update the changelog
 
 #### Step 1: Collect the formatted list of changes
 
@@ -274,9 +259,11 @@ in the repository was not on the current branch you may have to supply a
 `--start-ref` argument:
 
 ```console
-$ changelog-maker --group --start-ref v1.2.2
+$ changelog-maker --group --filter-release --start-ref v1.2.2
 ```
 
+`--filter-release` will remove the release commit from the previous release.
+
 #### Step 2: Update the appropriate doc/changelogs/CHANGELOG_*.md file
 
 There is a separate `CHANGELOG_Vx.md` file for each major Node.js release line.
@@ -330,10 +317,14 @@ accordingly by removing the bold styling from the previous release.
 If this release includes new APIs then it is necessary to document that they
 were first added in this version. The relevant commits should already include
 `REPLACEME` tags as per the example in the
-[docs README](../../tools/doc/README.md). Check for these tags with `grep
-REPLACEME doc/api/*.md`, and substitute this node version with `sed -i
-"s/REPLACEME/$VERSION/g" doc/api/*.md` or `perl -pi -e "s/REPLACEME/$VERSION/g"
-doc/api/*.md`.
+[docs README](../../tools/doc/README.md). Check for these tags with
+```console
+grep REPLACEME doc/api/*.md
+```
+and substitute this node version with
+```console
+sed -i "s/REPLACEME/$VERSION/g" doc/api/*.md` or `perl -pi -e "s/REPLACEME/$VERSION/g" doc/api/*.md
+```
 
 `$VERSION` should be prefixed with a `v`.
 
@@ -344,7 +335,7 @@ must be assigned a number (e.g. `DEP0012`). This assignment should
 occur when the PR is landed, but a check will be made when the release build is
 run.
 
-### 5. Create Release Commit
+### 5. Create release commit
 
 The `CHANGELOG.md`, `doc/changelogs/CHANGELOG_Vx.md`, `src/node_version.h`, and
 `REPLACEME` changes should be the final commit that will be tagged for the
@@ -373,7 +364,7 @@ Notable changes:
 * Copy the notable changes list here, reformatted for plain-text
 ```
 
-### 6. Propose Release on GitHub
+### 6. Propose release on GitHub
 
 Push the release branch to `nodejs/node`, not to your own fork. This allows
 release branches to more easily be passed between members of the release team if
@@ -383,7 +374,19 @@ Create a pull request targeting the correct release line. For example, a
 `v5.3.0-proposal` PR should target `v5.x`, not master. Paste the CHANGELOG
 modifications into the body of the PR so that collaborators can see what is
 changing. These PRs should be left open for at least 24 hours, and can be
-updated as new commits land.
+updated as new commits land. If the CHANGELOG pasted into the pull request
+is long enough that it slows down the GitHub UI, consider pasting the commits
+into `<details>` tags or in follow up comments.
+
+If using the `<details>` tag, use the following format:
+
+```markdown
+<details>
+<summary>Commits</summary>
+
+* Full list of commits...
+</details>
+```
 
 If you need any additional information about any of the commits, this PR is a
 good place to @-mention the relevant contributors.
@@ -391,7 +394,7 @@ good place to @-mention the relevant contributors.
 After opening the PR, update the release commit to include `PR-URL` metadata and
 force-push the proposal.
 
-### 7. Ensure that the Release Branch is Stable
+### 7. Ensure that the release branch is stable
 
 Run a **[`node-test-pull-request`](https://ci.nodejs.org/job/node-test-pull-request/)**
 test run to ensure that the build is stable and the HEAD commit is ready for
@@ -406,7 +409,7 @@ purpose. Run it once with the base `vx.x` branch as a reference and with the
 proposal branch to check if new regressions could be introduced in the
 ecosystem.
 
-### 8. Produce a Nightly Build _(optional)_
+### 8. Produce a nightly build _(optional)_
 
 If there is a reason to produce a test release for the purpose of having others
 try out installers or specifics of builds, produce a nightly build using
@@ -418,7 +421,7 @@ enter a proper length commit SHA, enter a date string, and select "nightly" for
 This is particularly recommended if there has been recent work relating to the
 macOS or Windows installers as they are not tested in any way by CI.
 
-### 9. Produce Release Builds
+### 9. Produce release builds
 
 Use **[iojs+release](https://ci-release.nodejs.org/job/iojs+release/)** to
 produce release artifacts. Enter the commit that you want to build from and
@@ -444,34 +447,14 @@ minutes which will prevent Jenkins from clearing the workspace to start a new
 one. This isn't a big deal, it's just a hassle because it'll result in another
 failed build if you start again!
 
-ARMv7 takes the longest to compile. Unfortunately ccache isn't as effective on
-release builds, I think it's because of the additional macro settings that go in
-to a release build that nullify previous builds. Also most of the release build
-machines are separate to the test build machines so they don't get any benefit
-from ongoing compiles between releases. You can expect 1.5 hours for the ARMv7
-builder to complete and you should normally wait for this to finish. It is
-possible to rush a release out if you want and add additional builds later but
-we normally provide ARMv7 from initial promotion.
-
-You do not have to wait for the ARMv6 / Raspberry PI builds if they take longer
-than the others. It is only necessary to have the main Linux (x64 and x86),
-macOS .pkg and .tar.gz, Windows (x64 and x86) .msi and .exe, source, headers,
-and docs (both produced currently by an macOS worker). **If you promote builds
-_before_ ARM builds have finished, you must repeat the promotion step for the
-ARM builds when they are ready**. If the ARMv6 build failed for some reason you
-can use the
-[`iojs-release-arm6-only`](https://ci-release.nodejs.org/job/iojs+release-arm6-only/)
-build in the release CI to re-run the build only for ARMv6. When launching the
-build make sure to use the same commit hash as for the original release.
-
-### 10. Test the Build
+### 10. Test the build
 
 Jenkins collects the artifacts from the builds, allowing you to download and
 install the new build. Make sure that the build appears correct. Check the
 version numbers, and perform some basic checks to confirm that all is well with
 the build before moving forward.
 
-### 11. Tag and Sign the Release Commit
+### 11. Tag and sign the release commit
 
 Once you have produced builds that you're happy with, create a new tag. By
 waiting until this stage to create tags, you can discard a proposed release if
@@ -497,7 +480,7 @@ $ git secure-tag <vx.y.z> <commit-sha> -sm "YYYY-MM-DD Node.js vx.y.z (<release-
 ```
 
 `release-type` is either "Current" or "LTS". For LTS releases, you should also
- include the release codename, for example:
+ include the release code name.
 
 ```text
 2019-10-22 Node.js v10.17.0 'Dubnium' (LTS) Release
@@ -506,7 +489,7 @@ $ git secure-tag <vx.y.z> <commit-sha> -sm "YYYY-MM-DD Node.js vx.y.z (<release-
 The tag **must** be signed using the GPG key that's listed for you on the
 project README.
 
-### 12. Set Up For the Next Release
+### 12. Set up for the next release
 
 On release proposal branch, edit `src/node_version.h` again and:
 
@@ -536,7 +519,7 @@ $ git rebase v1.x
 $ git push upstream v1.x-staging
 ```
 
-### 13. Cherry-pick the Release Commit to `master`
+### 13. Cherry-pick the release commit to `master`
 
 ```console
 $ git checkout master
@@ -544,7 +527,13 @@ $ git cherry-pick v1.x^
 ```
 
 Git should stop to let you fix conflicts. Revert all changes that were made to
-`src/node_version.h`. If there are conflicts in `doc` due to updated `REPLACEME`
+`src/node_version.h`:
+
+```console
+$ git checkout --ours HEAD -- src/node_version.h
+```
+
+If there are conflicts in `doc` due to updated `REPLACEME`
 placeholders (that happens when a change previously landed on another release
 branch), keep both version numbers. Convert the YAML field to an array if it is
 not already one.
@@ -562,9 +551,9 @@ $ git push upstream master
 
 ### 14. Push the release tag
 
-Push the tag to the repo before you promote the builds. If you haven't pushed
-your tag first, then build promotion won't work properly. Push the tag using the
-following command:
+Push the tag to the repository before you promote the builds. If you
+haven't pushed your tag first, then build promotion won't work properly.
+Push the tag using the following command:
 
 ```console
 $ git push <remote> <vx.y.z>
@@ -573,7 +562,7 @@ $ git push <remote> <vx.y.z>
 *Note*: Please do not push the tag unless you are ready to complete the
 remainder of the release steps.
 
-### 15. Promote and Sign the Release Builds
+### 15. Promote and sign the release builds
 
 **The same individual who signed the release tag must be the one
 to promote the builds as the `SHASUMS256.txt` file needs to be signed with the
@@ -641,15 +630,10 @@ SHASUMS256.txt.sig.
 directory.
 </details>
 
-If you didn't wait for ARM builds in the previous step before promoting the
-release, you should re-run `tools/release.sh` after the ARM builds have
-finished. That will move the ARM artifacts into the correct location. You will
-be prompted to re-sign `SHASUMS256.txt`.
-
 **It is possible to only sign a release by running `./tools/release.sh -s
 vX.Y.Z`.**
 
-### 16. Check the Release
+### 16. Check the release
 
 Your release should be available at `https://nodejs.org/dist/vx.y.z/` and
 <https://nodejs.org/dist/latest/>. Check that the appropriate files are in
@@ -658,7 +642,7 @@ have the right internal version strings. Check that the API docs are available
 at <https://nodejs.org/api/>. Check that the release catalog files are correct
 at <https://nodejs.org/dist/index.tab> and <https://nodejs.org/dist/index.json>.
 
-### 17. Create a Blog Post
+### 17. Create a blog post
 
 There is an automatic build that is kicked off when you promote new builds, so
 within a few minutes nodejs.org will be listing your new version as the latest
@@ -726,7 +710,7 @@ _In whatever form you do this..._
 
 ## LTS Releases
 
-### Marking a Release Line as LTS
+### Marking a release line as LTS
 
 To mark a release line as LTS, the following changes must be made to
 `src/node_version.h`:
@@ -734,7 +718,7 @@ To mark a release line as LTS, the following changes must be made to
 * The `NODE_MINOR_VERSION` macro must be incremented by one
 * The `NODE_PATCH_VERSION` macro must be set to `0`
 * The `NODE_VERSION_IS_LTS` macro must be set to `1`
-* The `NODE_VERSION_LTS_CODENAME` macro must be set to the codename selected
+* The `NODE_VERSION_LTS_CODENAME` macro must be set to the code name selected
 for the LTS release.
 
 For example:
@@ -764,7 +748,7 @@ existing labels for that release line, such as `vN.x`.
 If the release is transitioning from Active LTS to Maintenance, the
 `backport-requested-vN.x` label must be deleted.
 
-## Major Releases
+## Major releases
 
 The process for cutting a new Node.js major release has a number of differences
 from cutting a minor or patch release.
@@ -785,7 +769,7 @@ The release date for the next major release should be announced immediately
 following the current release (e.g. the release date for 13.0.0 should be
 announced immediately following the release of 12.0.0).
 
-### Release Branch
+### Release branch
 
 Approximately three months before a major release, new `vN.x` and
 `vN.x-staging` branches (where `N` indicates the major release) should be
@@ -815,7 +799,7 @@ The label description can be copied from existing labels of previous releases.
 The label color must be the same for all new labels, but different from the
 labels of previous releases.
 
-### Release Proposal
+### Release proposal
 
 A draft release proposal should be created two months before the release. A
 separate `vN.x-proposal` branch should be created that tracks the `vN.x`
@@ -826,7 +810,37 @@ Notify the `@nodejs/npm` team in the release proposal PR to inform them of the
 upcoming release. `npm` maintains a list of [supported versions](https://github.com/npm/cli/blob/latest/lib/utils/unsupported.js#L3)
 that will need updating to include the new major release.
 
-### Test Releases and Release Candidates
+### Update `NODE_MODULE_VERSION`
+
+This macro in `src/node_version.h` is used to signal an ABI version for native
+addons. It currently has two common uses in the community:
+
+* Determining what API to work against for compiling native addons, e.g.
+  [NAN](https://github.com/nodejs/nan) uses it to form a compatibility-layer for
+  much of what it wraps.
+* Determining the ABI for downloading pre-built binaries of native addons, e.g.
+  [node-pre-gyp](https://github.com/mapbox/node-pre-gyp) uses this value as
+  exposed via `process.versions.modules` to help determine the appropriate
+  binary to download at install-time.
+
+The general rule is to bump this version when there are _breaking ABI_ changes
+and also if there are non-trivial API changes. The rules are not yet strictly
+defined, so if in doubt, please confer with someone that will have a more
+informed perspective, such as a member of the NAN team.
+
+A registry of currently used `NODE_MODULE_VERSION` values is maintained at
+<https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json>.
+When bumping `NODE_MODULE_VERSION`, you should choose a new value not listed
+in the registry. Also include a change to the registry in your commit to
+reflect the newly used value. Ensure that the release commit removes the
+`-pre` suffix for the major version being prepared.
+
+It is current TSC policy to bump major version when ABI changes. If you
+see a need to bump `NODE_MODULE_VERSION` outside of a majore release then
+you should consult the TSC. Commits may need to be reverted or a major
+version bump may need to happen.
+
+### Test releases and release candidates
 
 Test builds should be generated from the `vN.x-proposal` branch starting at
 about 6 weeks before the release.
@@ -875,9 +889,19 @@ test, or doc-related are to be listed as notable changes. Some SEMVER-MINOR
 commits may be listed as notable changes on a case-by-case basis. Use your
 judgment there.
 
+### Snap
+
+The Node.js [Snap][] package has a "default" for installs where the user hasn't
+specified a release line ("track" in Snap terminology). This should be updated
+to point to the most recently activated LTS. A member of the Node.js Build
+Infrastructure team is able to perform the switch of the default. An issue
+should be opened on the [Node.js Snap management repository][] requesting this
+take place once a new LTS line has been released.
+
 [Build issue tracker]: https://github.com/nodejs/build/issues/new
-[CI lockdown procedure]: https://github.com/nodejs/build/blob/master/doc/jenkins-guide.md#restricting-access-for-security-releases
-[Partner Communities]: https://github.com/nodejs/community-committee/blob/master/governance/PARTNER_COMMUNITIES.md
-[nodejs.org release-post.js script]: https://github.com/nodejs/nodejs.org/blob/master/scripts/release-post.js
+[CI lockdown procedure]: https://github.com/nodejs/build/blob/HEAD/doc/jenkins-guide.md#restricting-access-for-security-releases
+[Node.js Snap management repository]: https://github.com/nodejs/snap
+[Partner Communities]: https://github.com/nodejs/community-committee/blob/HEAD/governance/PARTNER_COMMUNITIES.md
+[Snap]: https://snapcraft.io/node
+[nodejs.org release-post.js script]: https://github.com/nodejs/nodejs.org/blob/HEAD/scripts/release-post.js
 [nodejs.org repository]: https://github.com/nodejs/nodejs.org
-[webchat.freenode.net]: https://webchat.freenode.net/
diff --git a/doc/guides/security-release-process.md b/doc/guides/security-release-process.md
index 0ada9b63742615f1fba9a6476d955e9df011f06b..bcad4687ccb612bfebb252355c76474abb9e5914 100644
--- a/doc/guides/security-release-process.md
+++ b/doc/guides/security-release-process.md
@@ -21,6 +21,11 @@ information described.
     the date in the slug so that it will move to the top of the blog list.)
   * [ ] pre-release: ***LINK TO PR***
   * [ ] post-release: ***LINK TO PR***
+    * Ask the HackerOne reporter if they would like to be credited on the
+      security release blog page:
+      ```text
+      Thank you to <name> for reporting this vulnerability.
+      ```
 
 * [ ] Get agreement on the planned date for the release: ***RELEASE DATE***
 
@@ -35,11 +40,26 @@ information described.
   * Approved
   * Pass `make test`
   * Have CVEs
+     * Make sure that dependent libraries have CVEs for their issues. We should
+       only create CVEs for vulnerabilities in Node.js itself. This is to avoid
+       having duplicate CVEs for the same vulnerability.
   * Described in the pre/post announcements
 
 * [ ] Pre-release announcement [email][]: ***LINK TO EMAIL***
+   * Subject: `Node.js security updates for all active release lines, Month Year`
+   * Body:
+  ```text
+  The Node.js project will release new versions of all supported release lines on or shortly after Day of week, Month Day of Month, Year
+  For more information see: https://nodejs.org/en/blog/vulnerability/month-year-security-releases/
+  ```
   (Get access from existing manager: Ben Noordhuis, Rod Vagg, Michael Dawson)
 
+* [ ] CC `oss-security@lists.openwall.com` on pre-release
+
+The google groups UI does not support adding a CC, until we figure
+out a better way, forward the email you receive to
+`oss-security@lists.openwall.com` as a CC.
+
 * [ ] Pre-release announcement to nodejs.org blog: ***LINK TO BLOG***
   (Re-PR the pre-approved branch from nodejs-private/nodejs.org-private to
   nodejs/nodejs.org)
@@ -51,19 +71,36 @@ information described.
 * [ ] Request releaser(s) to start integrating the PRs to be released.
 
 * [ ] Notify [docker-node][] of upcoming security release date: ***LINK***
+  ```text
+  Heads up of Node.js security releases Day Month Year
+
+  As per the Node.js security release process this is the FYI that there is going to be a security release Day Month Year
+  ```
 
 * [ ] Notify build-wg of upcoming security release date by opening an issue
   in [nodejs/build][] to request WG members are available to fix any CI issues.
+  ```text
+  Heads up of Node.js security releases Day Month Year
+
+  As per security release process this is a heads up that there will be security releases Day Month Year and we'll need people from build to lock/unlock ci and to support and build issues we see.
+  ```
 
 ## Release day
 
-* [ ] [Lock CI](https://github.com/nodejs/build/blob/master/doc/jenkins-guide.md#before-the-release)
+* [ ] [Lock CI](https://github.com/nodejs/build/blob/HEAD/doc/jenkins-guide.md#before-the-release)
 
 * [ ] The releaser(s) run the release process to completion.
 
-* [ ] [Unlock CI](https://github.com/nodejs/build/blob/master/doc/jenkins-guide.md#after-the-release)
+* [ ] [Unlock CI](https://github.com/nodejs/build/blob/HEAD/doc/jenkins-guide.md#after-the-release)
 
 * [ ] Post-release announcement in reply [email][]: ***LINK TO EMAIL***
+   * CC: `oss-security@lists.openwall.com`
+   * Subject: `Node.js security updates for all active release lines, Month Year`
+   * Body:
+  ```text
+  The Node.js project has now released new versions of all supported release lines.
+  For more information see: https://nodejs.org/en/blog/vulnerability/month-year-security-releases/
+  ```
 
 * [ ] Post-release announcement to Nodejs.org blog: ***LINK TO BLOG POST***
   * (Re-PR the pre-approved branch from nodejs-private/nodejs.org-private to
@@ -84,8 +121,12 @@ information described.
       links to the release blogs in the "Public Reference" section)
 
 * [ ] PR machine-readable JSON descriptions of the vulnerabilities to the
-  [core](https://github.com/nodejs/security-wg/tree/master/vuln/core)
+  [core](https://github.com/nodejs/security-wg/tree/HEAD/vuln/core)
   vulnerability DB. ***LINK TO PR***
+  * For each vulnerability add a `#.json` file, one can copy an existing
+    [json](https://github.com/nodejs/security-wg/blob/0d82062d917cb9ddab88f910559469b2b13812bf/vuln/core/78.json)
+    file, and increment the latest created file number and use that as the name
+    of the new file to be added. For example, `79.json`.
 
 * [ ] Close this issue
 
diff --git a/doc/guides/strategic-initiatives.md b/doc/guides/strategic-initiatives.md
new file mode 100644
index 0000000000000000000000000000000000000000..ddcdbbf1d334e5c609973af247527fa3a2ac8199
--- /dev/null
+++ b/doc/guides/strategic-initiatives.md
@@ -0,0 +1,42 @@
+# Strategic initiatives
+
+The Node.js project has several strategic initiatives underway. A review of the
+current initiatives is a standing item on the Technical Steering Committee
+agenda to ensure they are active and have the support they need.
+
+## Current initiatives
+
+| Initiative                | Champion                    | Links                                                                                    |
+|---------------------------|-----------------------------|------------------------------------------------------------------------------------------|
+| Core Promise APIs         | [Antoine du Hamel][aduh95]  |                                                                                          |
+| Future of Build Toolchain | [Mary Marchini][mmarchini]  | <https://github.com/nodejs/TSC/issues/901>, <https://github.com/nodejs/build-toolchain-next> |
+| QUIC / HTTP3              | [James M Snell][jasnell]    | <https://github.com/nodejs/quic>                                                           |
+| Startup performance       | [Joyee Cheung][joyeecheung] | <https://github.com/nodejs/node/issues/17058> <https://github.com/nodejs/node/issues/21563>  |
+| V8 Currency               | [Michaël Zasso][targos]     |                                                                                          |
+
+<details>
+<summary>List of completed initiatives</summary>
+
+## Completed initiatives
+
+| Initiative         | Champion                   | Links                                           |
+|--------------------|----------------------------|--------------------------------------------------|
+| Build resources    | Michael Dawson             | <https://github.com/nodejs/build/issues/1154#issuecomment-448418977> |
+| CVE Management     | Michael Dawson             | <https://github.com/nodejs/security-wg/issues/33> |
+| Governance         | Myles Borins               |                                                 |
+| Moderation Team    | Rich Trott                 | <https://github.com/nodejs/TSC/issues/329>        |
+| Modules            | Myles Borins               | <https://github.com/nodejs/modules>               |
+| N-API              | Michael Dawson             | <https://github.com/nodejs/abi-stable-node>       |
+| npm Integration    | Myles Borins               | <https://github.com/nodejs/node/pull/21594>       |
+| OpenSSL Evolution  | Rod Vagg                   | <https://github.com/nodejs/TSC/issues/677>        |
+| Open Web Standards | Myles Borins, Joyee Cheung | <https://github.com/nodejs/open-standards>        |
+| VM module fix      | Franziska Hinkelmann       | <https://github.com/nodejs/node/issues/6283>      |
+| Workers            | Anna Henningsen            | <https://github.com/nodejs/worker>                |
+
+</details>
+
+[aduh95]: https://github.com/aduh95
+[jasnell]: https://github.com/jasnell
+[joyeecheung]: https://github.com/joyeecheung
+[mmarchini]: https://github.com/mmarchini
+[targos]: https://github.com/targos
diff --git a/doc/guides/technical-values.md b/doc/guides/technical-values.md
index d79fde6a46102132f17522efbcfb9ec4c6402859..b86f2243896147e21391f7fcffb08b871da13106 100644
--- a/doc/guides/technical-values.md
+++ b/doc/guides/technical-values.md
@@ -3,13 +3,23 @@
 The project uses these technical values to establish priorities and guide
 collaboration.
 
+These are the shared values as of this writing and will
+evolve. We hope they are useful to people new
+to the project in order to better understand which contributions
+will be aligned with the current direction and as thinking
+points when trading off between conflicting goals.
+
+The factors influencing every discussion/decision are
+different and priority 1 does not always trump priority 2
+and so on.
+
 ## Values and priority level
 
 * Priority 1 - Developer experience
 * Priority 2 - Stability
 * Priority 3 - Operational qualities
 * Priority 4 - Node.js maintainer experience
-* Priority 5 - Up to date Technology and APIs
+* Priority 5 - Up to date technology and APIs
 
 ## Value descriptions
 
@@ -20,6 +30,9 @@ with Node.js. Some key elements of this include:
 * Great documentation
 * Bundling friction-reducing APIs and components, even though
   they could be provided externally
+* Compatibility and interoperability with browsers and other JavaScript
+  environments so that as much code as possible runs as is both in Node.js and
+  in the other environments
 * Enabling/supporting external packages to ensure overall developer experience
 
 ### 2 - Stability
@@ -30,7 +43,7 @@ Some key elements of this include:
 * Stable releases on a predictable schedule
 * A strong safety net, including testing how changes
   in Node.js affect popular packages
-* Careful consideration of what goes into long term support (LTS) releases
+* Careful consideration of what goes into Long Term Support (LTS) releases
 
 ### 3 - Operational qualities
 We value keeping Node.js safe, performant, and lightweight.
@@ -52,7 +65,7 @@ Some key elements of this include:
 * Low-friction policies and processes
 * Good CI and tooling to make maintainers productive
 
-### 5 - Up to date Technology and APIs
+### 5 - Up to date technology and APIs
 We value providing developers with modern APIs and technologies
 following existing standards whenever possible.
 Some key elements of this include:
diff --git a/doc/guides/using-internal-errors.md b/doc/guides/using-internal-errors.md
index 9fac1298a1d050b59bc3ee2b03bc33445e4e5b0b..fe7bafb7be682794c7c862734330ef1b0bf5b3f3 100644
--- a/doc/guides/using-internal-errors.md
+++ b/doc/guides/using-internal-errors.md
@@ -1,4 +1,4 @@
-# Using the internal/errors.js Module
+# Using the internal/errors.js module
 
 ## What is internal/errors.js
 
diff --git a/doc/guides/writing-and-running-benchmarks.md b/doc/guides/writing-and-running-benchmarks.md
index b6b22d75c17e2c27278f91e4732a9fbc3739ce51..f498d00e54d35881ca8291b598c4d9e15608763c 100644
--- a/doc/guides/writing-and-running-benchmarks.md
+++ b/doc/guides/writing-and-running-benchmarks.md
@@ -1,17 +1,19 @@
-# How to Write and Run Benchmarks in Node.js Core
+# How to write and run benchmarks in Node.js core
 
-## Table of Contents
+## Table of contents
 
 * [Prerequisites](#prerequisites)
-  * [HTTP Benchmark Requirements](#http-benchmark-requirements)
-  * [Benchmark Analysis Requirements](#benchmark-analysis-requirements)
+  * [HTTP benchmark requirements](#http-benchmark-requirements)
+  * [HTTPS benchmark requirements](#https-benchmark-requirements)
+  * [HTTP/2 benchmark requirements](#http2-benchmark-requirements)
+  * [Benchmark analysis requirements](#benchmark-analysis-requirements)
 * [Running benchmarks](#running-benchmarks)
   * [Running individual benchmarks](#running-individual-benchmarks)
   * [Running all benchmarks](#running-all-benchmarks)
   * [Filtering benchmarks](#filtering-benchmarks)
   * [Comparing Node.js versions](#comparing-nodejs-versions)
   * [Comparing parameters](#comparing-parameters)
-  * [Running Benchmarks on the CI](#running-benchmarks-on-the-ci)
+  * [Running benchmarks on the CI](#running-benchmarks-on-the-ci)
 * [Creating a benchmark](#creating-a-benchmark)
   * [Basics of a benchmark](#basics-of-a-benchmark)
   * [Creating an HTTP benchmark](#creating-an-http-benchmark)
@@ -22,7 +24,7 @@ Basic Unix tools are required for some benchmarks.
 [Git for Windows][git-for-windows] includes Git Bash and the necessary tools,
 which need to be included in the global Windows `PATH`.
 
-### HTTP Benchmark Requirements
+### HTTP benchmark requirements
 
 Most of the HTTP benchmarks require a benchmarker to be installed. This can be
 either [`wrk`][wrk] or [`autocannon`][autocannon].
@@ -43,15 +45,22 @@ benchmarker to be used should be specified by providing it as an argument:
 
 `node benchmark/http/simple.js benchmarker=autocannon`
 
-#### HTTP/2 Benchmark Requirements
+#### HTTPS benchmark requirements
+
+To run the `https` benchmarks, one of `autocannon` or `wrk` benchmarkers must
+be used.
+
+`node benchmark/https/simple.js benchmarker=autocannon`
+
+#### HTTP/2 benchmark requirements
 
 To run the `http2` benchmarks, the `h2load` benchmarker must be used. The
 `h2load` tool is a component of the `nghttp2` project and may be installed
 from [nghttp2.org][] or built from source.
 
-`node benchmark/http2/simple.js benchmarker=autocannon`
+`node benchmark/http2/simple.js benchmarker=h2load`
 
-### Benchmark Analysis Requirements
+### Benchmark analysis requirements
 
 To analyze the results, `R` should be installed. Use one of the available
 package managers or download it from <https://www.r-project.org/>.
@@ -65,11 +74,8 @@ install.packages("ggplot2")
 install.packages("plyr")
 ```
 
-In the event that a message is reported stating that a CRAN mirror must be
-selected first, specify a mirror by adding in the repo parameter.
-
-If we used the "<http://cran.us.r-project.org>" mirror, it could look something
-like this:
+If a message states that a CRAN mirror must be selected first, specify a mirror
+with the `repo` parameter.
 
 ```r
 install.packages("ggplot2", repo="http://cran.us.r-project.org")
@@ -414,9 +420,9 @@ chunkLen     encoding      rate confidence.interval
 
 ![compare tool boxplot](doc_img/scatter-plot.png)
 
-### Running Benchmarks on the CI
+### Running benchmarks on the CI
 
-To see the performance impact of a Pull Request by running benchmarks on
+To see the performance impact of a pull request by running benchmarks on
 the CI, check out [How to: Running core benchmarks on Node.js CI][benchmark-ci].
 
 ## Creating a benchmark
@@ -551,7 +557,7 @@ Supported options keys are:
   benchmarker
 
 [autocannon]: https://github.com/mcollina/autocannon
-[benchmark-ci]: https://github.com/nodejs/benchmarking/blob/master/docs/core_benchmarks.md
+[benchmark-ci]: https://github.com/nodejs/benchmarking/blob/HEAD/docs/core_benchmarks.md
 [git-for-windows]: https://git-scm.com/download/win
 [nghttp2.org]: https://nghttp2.org
 [t-test]: https://en.wikipedia.org/wiki/Student%27s_t-test#Equal_or_unequal_sample_sizes.2C_unequal_variances
diff --git a/doc/guides/writing-tests.md b/doc/guides/writing-tests.md
index b7d92709444678e1f724aff24f7589eb95b17f5c..027917494dfb62d92935c2bfb701528983b7acf5 100644
--- a/doc/guides/writing-tests.md
+++ b/doc/guides/writing-tests.md
@@ -20,7 +20,7 @@ Add tests when:
 
 ## Test directory structure
 
-See [directory structure overview][] for outline of existing test & locations.
+See [directory structure overview][] for outline of existing test and locations.
 When deciding on whether to expand an existing test file or create a new one,
 consider going through the files related to the subsystem.
 For example, look for `test-streams` when writing a test for `lib/streams.js`.
@@ -109,6 +109,21 @@ case, `_`, lower case).
 
 ### **Lines 11-22**
 
+```js
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end('ok');
+}));
+server.listen(0, () => {
+  http.get({
+    port: server.address().port,
+    headers: { 'Test': 'Düsseldorf' }
+  }, common.mustCall((res) => {
+    assert.strictEqual(res.statusCode, 200);
+    server.close();
+  }));
+});
+```
+
 This is the body of the test. This test is simple, it just tests that an
 HTTP server accepts `non-ASCII` characters in the headers of an incoming
 request. Interesting things to notice:
@@ -146,7 +161,7 @@ platforms.
 ### The *common* API
 
 Make use of the helpers from the `common` module as much as possible. Please
-refer to the [common file documentation](https://github.com/nodejs/node/tree/master/test/common)
+refer to the [common file documentation](https://github.com/nodejs/node/tree/HEAD/test/common)
 for the full details of the helpers.
 
 #### common.mustCall
@@ -206,12 +221,16 @@ const server = http.createServer(common.mustCall((req, res) => {
     server.close();
   }));
 }));
-
 ```
 
-#### Countdown Module
+**Note:** Many functions invoke their callback with an `err` value as the first
+argument. It is not a good idea to simply pass `common.mustCall()` to those
+because `common.mustCall()` will ignore the error. Use `common.mustSucceed()`
+instead.
+
+#### Countdown module
 
-The common [Countdown module](https://github.com/nodejs/node/tree/master/test/common#countdown-module)
+The common [Countdown module](https://github.com/nodejs/node/tree/HEAD/test/common#countdown-module)
 provides a simple countdown mechanism for tests that require a particular
 action to be taken after a given number of completed tasks (for instance,
 shutting down an HTTP server after a specific number of requests).
@@ -267,6 +286,15 @@ const assert = require('assert');
 const freelist = require('internal/freelist');
 ```
 
+In specific scenarios it may be useful to get a hold of `primordials` or
+`internalBinding()`. You can do so using
+
+```console
+node --expose-internals -r internal/test/binding lib/fs.js
+```
+
+This only works if you preload `internal/test/binding` by command line flag.
+
 ### Assertions
 
 When writing assertions, prefer the strict versions:
@@ -325,7 +353,7 @@ in each release, such as:
 * Template literals over string concatenation
 * Arrow functions when appropriate
 
-## Naming Test Files
+## Naming test files
 
 Test files are named using kebab casing. The first component of the name is
 `test`. The second is the module or subsystem being tested. The third is usually
@@ -337,13 +365,13 @@ named `test-process-before-exit.js`. If the test specifically checked that arrow
 functions worked correctly with the `beforeExit` event, then it might be named
 `test-process-before-exit-arrow-functions.js`.
 
-## Imported Tests
+## Imported tests
 
-### Web Platform Tests
+### Web platform tests
 
 See [`test/wpt`](../../test/wpt/README.md) for more information.
 
-## C++ Unit test
+## C++ unit test
 
 C++ code can be tested using [Google Test][]. Most features in Node.js can be
 tested using the methods described previously in this document. But there are
@@ -413,7 +441,7 @@ $ make cctest GTEST_FILTER=EnvironmentTest.AtExitWithArgument
 `cctest` can also be run directly which can be useful when debugging:
 
 ```console
-$ out/Release/cctest --gtest_filter=EnvironmentTest.AtExit*
+$ out/Release/cctest --gtest_filter=EnvironmentTest.AtExit\*
 ```
 
 ### Node.js test fixture
@@ -424,7 +452,7 @@ and tearing it down after the tests have finished.
 It also contains a helper to create arguments to be passed into Node.js. It
 will depend on what is being tested if this is required or not.
 
-### Test Coverage
+### Test coverage
 
 To generate a test coverage report, see the
 [Test Coverage section of the Building guide][].
@@ -434,9 +462,9 @@ Nightly coverage reports for the Node.js master branch are available at
 
 [ASCII]: https://man7.org/linux/man-pages/man7/ascii.7.html
 [Google Test]: https://github.com/google/googletest
-[Test Coverage section of the Building guide]: https://github.com/nodejs/node/blob/master/BUILDING.md#running-coverage
-[`common` module]: https://github.com/nodejs/node/blob/master/test/common/README.md
+[Test Coverage section of the Building guide]: https://github.com/nodejs/node/blob/HEAD/BUILDING.md#running-coverage
+[`common` module]: https://github.com/nodejs/node/blob/HEAD/test/common/README.md
 [all maintained branches]: https://github.com/nodejs/lts
-[directory structure overview]: https://github.com/nodejs/node/blob/master/test/README.md#test-directories
+[directory structure overview]: https://github.com/nodejs/node/blob/HEAD/test/README.md#test-directories
 [node.green]: https://node.green/
-[test fixture]: https://github.com/google/googletest/blob/master/googletest/docs/Primer.md#test-fixtures-using-the-same-data-configuration-for-multiple-tests
+[test fixture]: https://github.com/google/googletest/blob/HEAD/docs/primer.md#test-fixtures-using-the-same-data-configuration-for-multiple-tests-same-data-multiple-tests
diff --git a/doc/node.1 b/doc/node.1
index 610b21d0eef114bb0fc93f83cb57bc847ab743c8..58465b5b655f8ef09bb5fab465e456a92566ed30 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -78,8 +78,8 @@ Aborting instead of exiting causes a core file to be generated for analysis.
 .It Fl -completion-bash
 Print source-able bash completion script for Node.js.
 .
-.It Fl -conditions Ar string
-Use custom conditional exports conditions
+.It Fl C , Fl -conditions Ar string
+Use custom conditional exports conditions.
 .Ar string
 .
 .It Fl -cpu-prof
@@ -95,7 +95,7 @@ The directory where the CPU profiles generated by
 will be placed.
 The default value is controlled by the
 .Fl -diagnostic-dir .
-command line option.
+command-line option.
 .
 .It Fl -cpu-prof-interval
 The sampling interval in microseconds for the CPU profiles generated by
@@ -105,7 +105,7 @@ The default is
 .
 .It Fl -cpu-prof-name
 File name of the V8 CPU profile generated with
-.Fl -cpu-prof
+.Fl -cpu-prof .
 .
 .It Fl -diagnostic-dir
 Set the directory for all diagnostic output files.
@@ -136,6 +136,9 @@ Enable FIPS-compliant crypto at startup.
 Requires Node.js to be built with
 .Sy ./configure --openssl-fips .
 .
+.It Fl -experimental-abortcontroller
+Enable experimental AbortController and AbortSignal support.
+.
 .It Fl -enable-source-maps
 Enable experimental Source Map V3 support for stack traces.
 .
@@ -159,7 +162,7 @@ Enable experimental top-level
 keyword support in REPL.
 .
 .It Fl -experimental-specifier-resolution
-Select extension resolution algorithm for ES Modules; either 'explicit' (default) or 'node'
+Select extension resolution algorithm for ES Modules; either 'explicit' (default) or 'node'.
 .
 .It Fl -experimental-vm-modules
 Enable experimental ES module support in VM module.
@@ -182,6 +185,10 @@ Same requirements as
 .It Fl -frozen-intrinsics
 Enable experimental frozen intrinsics support.
 .
+.It Fl -heapsnapshot-near-heap-limit Ns = Ns Ar max_count
+Generate heap snapshot when the V8 heap usage is approaching the heap limit.
+No more than the specified number of snapshots will be generated.
+.
 .It Fl -heapsnapshot-signal Ns = Ns Ar signal
 Generate heap snapshot on specified signal.
 .
@@ -198,7 +205,7 @@ The directory where the heap profiles generated by
 will be placed.
 The default value is controlled by the
 .Fl -diagnostic-dir .
-command line option.
+command-line option.
 .
 .It Fl -heap-prof-interval
 The average sampling interval in bytes for the heap profiles generated by
@@ -208,16 +215,7 @@ The default is
 .
 .It Fl -heap-prof-name
 File name of the V8 heap profile generated with
-.Fl -heap-prof
-.
-.It Fl -http-parser Ns = Ns Ar library
-Chooses an HTTP parser library. Available values are
-.Sy llhttp
-or
-.Sy legacy .
-.
-.It Fl -http-server-default-timeout Ns = Ns Ar milliseconds
-Overrides the default value for server socket timeout.
+.Fl -heap-prof .
 .
 .It Fl -icu-data-dir Ns = Ns Ar file
 Specify ICU data load path.
@@ -271,7 +269,7 @@ This flag is inherited from V8 and is subject to change upstream. It may
 disappear in a non-semver-major release.
 .
 .It Fl -max-http-header-size Ns = Ns Ar size
-Specify the maximum size of HTTP headers in bytes. Defaults to 8KB.
+Specify the maximum size of HTTP headers in bytes. Defaults to 16KB.
 .
 .It Fl -napi-modules
 This option is a no-op.
@@ -287,6 +285,10 @@ These will still be enabled dynamically when `async_hooks` is enabled.
 .It Fl -no-warnings
 Silence all process warnings (including deprecations).
 .
+.It Fl -node-memory-debug
+Enable extra debug checks for memory leaks in Node.js internals. This is
+usually only useful for developers debugging Node.js itself.
+.
 .It Fl -openssl-config Ns = Ns Ar file
 Load an OpenSSL configuration file on startup.
 Among other uses, this can be used to enable FIPS-compliant crypto if Node.js is built with
@@ -328,7 +330,7 @@ will be generated.
 The `file` name may be an absolute path. If it is not, the default directory it will
 be written to is controlled by the
 .Fl -diagnostic-dir .
-command line option.
+command-line option.
 .
 .It Fl -report-filename
 Name of the file to which the
@@ -397,6 +399,10 @@ but the option is supported for compatibility with older Node.js versions.
 Set default minVersion to 'TLSv1.3'. Use to disable support for TLSv1.2 in
 favour of TLSv1.3, which is more secure.
 .
+.It Fl -trace-atomics-wait
+Print short summaries of calls to
+.Sy Atomics.wait() .
+.
 .It Fl -trace-deprecation
 Print stack traces for deprecations.
 .
@@ -444,7 +450,7 @@ Print stack traces for process warnings (including deprecations).
 .It Fl -track-heap-objects
 Track heap object allocations for heap snapshots.
 .
-.It Fl --unhandled-rejections=mode
+.It Fl -unhandled-rejections=mode
 Define the behavior for unhandled rejections. Can be one of `strict` (raise an error), `warn` (enforce warnings) or `none` (silence warnings).
 .
 .It Fl -use-bundled-ca , Fl -use-openssl-ca
@@ -520,6 +526,26 @@ Print node's version.
 .\" =====================================================================
 .Sh ENVIRONMENT
 .Bl -tag -width 6n
+.It Ev FORCE_COLOR
+Used to enable ANSI colorized output. The value may be one of:
+.Ar 1
+,
+.Ar true
+, or
+.Ar an empty string
+to
+indicate 16-color support,
+.Ar 2
+to indicate 256-color support, or
+.Ar 3
+to indicate 16 million-color support. When used and set to a supported
+value, both the NO_COLOR and NODE_DISABLE_COLORS environment variables
+are ignored. Any other value will result in colorized output being
+disabled.
+.
+.It Ev NO_COLOR
+Alias for NODE_DISABLE_COLORS
+.
 .It Ev NODE_DEBUG Ar modules...
 Comma-separated list of core modules that should print debug information.
 .
@@ -546,6 +572,13 @@ but any errors are otherwise ignored.
 .Pp
 This environment variable is ignored when `node` runs as setuid root or
 has Linux file capabilities set.
+.Pp
+The
+.Ar NODE_EXTRA_CA_CERTS
+environment variable is only read when the Node.js process is first launched.
+Changing the value at runtime using
+.Ar process.env.NODE_EXTRA_CA_CERTS
+has no effect on the current process.
 .
 .It Ev NODE_ICU_DATA Ar file
 Data path for ICU (Intl object) data.
@@ -559,7 +592,7 @@ process warnings are silenced.
 .It Ev NODE_OPTIONS Ar options...
 A space-separated list of command-line
 .Ar options ,
-which are interpreted as if they had been specified on the command-line before the actual command (so they can be overridden).
+which are interpreted as if they had been specified on the command line before the actual command (so they can be overridden).
 Node.js will exit with an error if an option that is not allowed in the environment is used, such as
 .Fl -print
 or a script file.
@@ -585,7 +618,7 @@ Write process warnings to the given
 instead of printing to stderr.
 Equivalent to passing
 .Fl -redirect-warnings Ar file
-on command-line.
+on the command line.
 .It Ev NODE_REPL_HISTORY Ar file
 Path to the
 .Ar file
@@ -595,6 +628,13 @@ The default path is
 which is overridden by this variable.
 Setting the value to an empty string ("" or " ") will disable persistent REPL history.
 .
+.It Ev NODE_SKIP_PLATFORM_CHECK
+When set to
+.Ar 1 ,
+the check for a supported platform is skipped during Node.js startup.
+Node.js might not execute correctly.
+Any issues encountered on unsupported platforms will not be fixed.
+.
 .It Ev NODE_TLS_REJECT_UNAUTHORIZED
 When set to
 .Ar 0 ,
@@ -641,7 +681,7 @@ Node.js is available under the MIT license.
 .Pp
 Node.js also includes external libraries that are available under a variety of licenses.
 See
-.Sy https://github.com/nodejs/node/blob/master/LICENSE
+.Sy https://github.com/nodejs/node/blob/HEAD/LICENSE
 for the full license text.
 .
 .\"======================================================================
@@ -654,19 +694,15 @@ Documentation:
 .Sy https://nodejs.org/api/
 .
 .Pp
-GitHub repository & Issue Tracker:
+GitHub repository and issue tracker:
 .Sy https://github.com/nodejs/node
 .
 .Pp
 IRC (general questions):
-.Sy "chat.freenode.net #node.js"
+.Sy "libera.chat #node.js"
 (unofficial)
 .
-.Pp
-IRC (Node.js core development):
-.Sy "chat.freenode.net #node-dev"
-.
 .\"======================================================================
 .Sh AUTHORS
 Written and maintained by 1000+ contributors:
-.Sy https://github.com/nodejs/node/blob/master/AUTHORS
+.Sy https://github.com/nodejs/node/blob/HEAD/AUTHORS
diff --git a/doc/template.html b/doc/template.html
index 9e07b55c44e5e1dc1e1fcbbd13d3380ab6caca24..5e70b6054e080b042a766009e44596bd599a1b80 100644
--- a/doc/template.html
+++ b/doc/template.html
@@ -1,4 +1,4 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
@@ -23,7 +23,20 @@
 
     <div id="column1" data-id="__ID__" class="interior">
       <header>
-        <h1>Node.js __VERSION__ Documentation</h1>
+        <div class="header-container">
+          <h1>Node.js __VERSION__ documentation</h1>
+          <button class="theme-toggle-btn" id="theme-toggle-btn" title="Toggle dark mode/light mode" aria-label="Toggle dark mode/light mode" hidden>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon dark-icon" height="24" width="24">
+              <path fill="none" d="M0 0h24v24H0z" />
+              <path d="M11.1 12.08c-2.33-4.51-.5-8.48.53-10.07C6.27 2.2 1.98 6.59 1.98 12c0 .14.02.28.02.42.62-.27 1.29-.42 2-.42 1.66 0 3.18.83 4.1 2.15A4.01 4.01 0 0111 18c0 1.52-.87 2.83-2.12 3.51.98.32 2.03.5 3.11.5 3.5 0 6.58-1.8 8.37-4.52-2.36.23-6.98-.97-9.26-5.41z"/>
+              <path d="M7 16h-.18C6.4 14.84 5.3 14 4 14c-1.66 0-3 1.34-3 3s1.34 3 3 3h3c1.1 0 2-.9 2-2s-.9-2-2-2z"/>
+            </svg>
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon light-icon" height="24" width="24">
+              <path d="M0 0h24v24H0z" fill="none" />
+              <path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/>
+            </svg>
+          </button>
+        </div>
         <div id="gtoc">
           <ul>
             <li>
@@ -42,10 +55,7 @@
         <hr>
       </header>
 
-      <div id="toc">
-        <h2>Table of Contents</h2>
-        __TOC__
-      </div>
+      __TOC__
 
       <div id="apicontent">
         __CONTENT__
@@ -53,5 +63,41 @@
       </div>
     </div>
   </div>
+  <script>
+    'use strict';
+    {
+      const kCustomPreference = 'customDarkTheme';
+      const userSettings = sessionStorage.getItem(kCustomPreference);
+      const themeToggleButton = document.getElementById('theme-toggle-btn');
+      if (userSettings === null && window.matchMedia) {
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        if ('onchange' in mq) {
+          function mqChangeListener(e) {
+            document.body.classList.toggle('dark-mode', e.matches);
+          }
+          mq.addEventListener('change', mqChangeListener);
+          if (themeToggleButton) {
+            themeToggleButton.addEventListener('click', function() {
+              mq.removeEventListener('change', mqChangeListener);
+            }, { once: true });
+          }
+        }
+        if (mq.matches) {
+          document.body.classList.add('dark-mode');
+        }
+      } else if (userSettings === 'true') {
+        document.body.classList.add('dark-mode');
+      }
+      if (themeToggleButton) {
+        themeToggleButton.hidden = false;
+        themeToggleButton.addEventListener('click', function() {
+          sessionStorage.setItem(
+            kCustomPreference,
+            document.body.classList.toggle('dark-mode')
+          );
+        });
+      }
+    }
+  </script>
 </body>
 </html>
diff --git a/glossary.md b/glossary.md
index eb44536e6eca79c07f96c3b13b1ee7155ac7435a..ccc1e495dfffe685e81eecd83a18751026685a5e 100644
--- a/glossary.md
+++ b/glossary.md
@@ -1,4 +1,4 @@
-You may also need to check <https://chromium.googlesource.com/chromiumos/docs/+/master/glossary.md>.
+You may also need to check <https://chromium.googlesource.com/chromiumos/docs/+/HEAD/glossary.md>.
 
 * LGTM: "Looks good to me", commonly used to approve a code review.
 * PTAL: Please take a look.
diff --git a/lib/_http_agent.js b/lib/_http_agent.js
index c14492c3c31ece7cae68050ca0ffcfaf263cfe57..237f7e104482bef93c8fac491254fef2e8c87ff6 100644
--- a/lib/_http_agent.js
+++ b/lib/_http_agent.js
@@ -34,17 +34,20 @@ const EventEmitter = require('events');
 let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
   debug = fn;
 });
+const { AsyncResource } = require('async_hooks');
 const { async_id_symbol } = require('internal/async_hooks').symbols;
 const {
   codes: {
+    ERR_INVALID_ARG_TYPE,
     ERR_OUT_OF_RANGE,
-    ERR_INVALID_OPT_VALUE,
   },
 } = require('internal/errors');
-const { validateNumber } = require('internal/validators');
+const { once } = require('internal/util');
+const { validateNumber, validateOneOf } = require('internal/validators');
 
 const kOnKeylog = Symbol('onkeylog');
 const kRequestOptions = Symbol('requestOptions');
+const kRequestAsyncResource = Symbol('requestAsyncResource');
 // New Agent code.
 
 // The largest departure from the previous implementation is that
@@ -91,9 +94,12 @@ function Agent(options) {
   this.keepAlive = this.options.keepAlive || false;
   this.maxSockets = this.options.maxSockets || Agent.defaultMaxSockets;
   this.maxFreeSockets = this.options.maxFreeSockets || 256;
+  this.scheduling = this.options.scheduling || 'lifo';
   this.maxTotalSockets = this.options.maxTotalSockets;
   this.totalSocketCount = 0;
 
+  validateOneOf(this.scheduling, 'scheduling', ['fifo', 'lifo'], true);
+
   if (this.maxTotalSockets !== undefined) {
     validateNumber(this.maxTotalSockets, 'maxTotalSockets');
     if (this.maxTotalSockets <= 0 || NumberIsNaN(this.maxTotalSockets))
@@ -103,12 +109,6 @@ function Agent(options) {
     this.maxTotalSockets = Infinity;
   }
 
-  this.scheduling = this.options.scheduling || 'fifo';
-
-  if (this.scheduling !== 'fifo' && this.scheduling !== 'lifo') {
-    throw new ERR_INVALID_OPT_VALUE('scheduling', this.scheduling);
-  }
-
   this.on('free', (socket, options) => {
     const name = this.getName(options);
     debug('agent.on(free)', name);
@@ -118,54 +118,60 @@ function Agent(options) {
     // case of socket.destroy() below this 'error' has no handler
     // and could cause unhandled exception.
 
-    if (socket.writable &&
-        this.requests[name] && this.requests[name].length) {
-      const req = this.requests[name].shift();
-      setRequestSocket(this, req, socket);
-      if (this.requests[name].length === 0) {
-        // don't leak
-        delete this.requests[name];
-      }
-    } else {
-      // If there are no pending requests, then put it in
-      // the freeSockets pool, but only if we're allowed to do so.
-      const req = socket._httpMessage;
-      if (req &&
-          req.shouldKeepAlive &&
-          socket.writable &&
-          this.keepAlive) {
-        let freeSockets = this.freeSockets[name];
-        const freeLen = freeSockets ? freeSockets.length : 0;
-        let count = freeLen;
-        if (this.sockets[name])
-          count += this.sockets[name].length;
-
-        if (this.totalSocketCount > this.maxTotalSockets ||
-            count > this.maxSockets ||
-            freeLen >= this.maxFreeSockets) {
-          socket.destroy();
-        } else if (this.keepSocketAlive(socket)) {
-          freeSockets = freeSockets || [];
-          this.freeSockets[name] = freeSockets;
-          socket[async_id_symbol] = -1;
-          socket._httpMessage = null;
-          this.removeSocket(socket, options);
-
-          const agentTimeout = this.options.timeout || 0;
-          if (socket.timeout !== agentTimeout) {
-            socket.setTimeout(agentTimeout);
-          }
-
-          socket.once('error', freeSocketErrorListener);
-          freeSockets.push(socket);
-        } else {
-          // Implementation doesn't want to keep socket alive
-          socket.destroy();
-        }
+    if (!socket.writable) {
+      socket.destroy();
+      return;
+    }
+
+    const requests = this.requests[name];
+    if (requests && requests.length) {
+      const req = requests.shift();
+      const reqAsyncRes = req[kRequestAsyncResource];
+      if (reqAsyncRes) {
+        // Run request within the original async context.
+        reqAsyncRes.runInAsyncScope(() => {
+          asyncResetHandle(socket);
+          setRequestSocket(this, req, socket);
+        });
+        req[kRequestAsyncResource] = null;
       } else {
-        socket.destroy();
+        setRequestSocket(this, req, socket);
+      }
+      if (requests.length === 0) {
+        delete this.requests[name];
       }
+      return;
+    }
+
+    // If there are no pending requests, then put it in
+    // the freeSockets pool, but only if we're allowed to do so.
+    const req = socket._httpMessage;
+    if (!req || !req.shouldKeepAlive || !this.keepAlive) {
+      socket.destroy();
+      return;
+    }
+
+    const freeSockets = this.freeSockets[name] || [];
+    const freeLen = freeSockets.length;
+    let count = freeLen;
+    if (this.sockets[name])
+      count += this.sockets[name].length;
+
+    if (this.totalSocketCount > this.maxTotalSockets ||
+        count > this.maxSockets ||
+        freeLen >= this.maxFreeSockets ||
+        !this.keepSocketAlive(socket)) {
+      socket.destroy();
+      return;
     }
+
+    this.freeSockets[name] = freeSockets;
+    socket[async_id_symbol] = -1;
+    socket._httpMessage = null;
+    this.removeSocket(socket, options);
+
+    socket.once('error', freeSocketErrorListener);
+    freeSockets.push(socket);
   });
 
   // Don't emit keylog events unless there is a listener for them.
@@ -256,14 +262,7 @@ Agent.prototype.addRequest = function addRequest(req, options, port/* legacy */,
   const sockLen = freeLen + this.sockets[name].length;
 
   if (socket) {
-    // Guard against an uninitialized or user supplied Socket.
-    const handle = socket._handle;
-    if (handle && typeof handle.asyncReset === 'function') {
-      // Assign the handle a new asyncId and run any destroy()/init() hooks.
-      handle.asyncReset(new ReusedHandle(handle.getProviderType(), handle));
-      socket[async_id_symbol] = handle.getAsyncId();
-    }
-
+    asyncResetHandle(socket);
     this.reuseSocket(socket, req);
     setRequestSocket(this, req, socket);
     this.sockets[name].push(socket);
@@ -272,7 +271,12 @@ Agent.prototype.addRequest = function addRequest(req, options, port/* legacy */,
              this.totalSocketCount < this.maxTotalSockets) {
     debug('call onSocket', sockLen, freeLen);
     // If we are under maxSockets create a new one.
-    this.createSocket(req, options, handleSocketCreation(this, req, true));
+    this.createSocket(req, options, (err, socket) => {
+      if (err)
+        req.onSocket(socket, err);
+      else
+        setRequestSocket(this, req, socket);
+    });
   } else {
     debug('wait for socket');
     // We are over limit so we'll add it to the queue.
@@ -282,6 +286,8 @@ Agent.prototype.addRequest = function addRequest(req, options, port/* legacy */,
 
     // Used to create sockets for pending requests from different origin
     req[kRequestOptions] = options;
+    // Used to capture the original async context.
+    req[kRequestAsyncResource] = new AsyncResource('QueuedRequest');
 
     this.requests[name].push(req);
   }
@@ -300,12 +306,8 @@ Agent.prototype.createSocket = function createSocket(req, options, cb) {
 
   debug('createConnection', name, options);
   options.encoding = null;
-  let called = false;
 
-  const oncreate = (err, s) => {
-    if (called)
-      return;
-    called = true;
+  const oncreate = once((err, s) => {
     if (err)
       return cb(err);
     if (!this.sockets[name]) {
@@ -316,7 +318,7 @@ Agent.prototype.createSocket = function createSocket(req, options, cb) {
     debug('sockets', name, this.sockets[name].length, this.totalSocketCount);
     installListeners(this, s, options);
     cb(null, s);
-  };
+  });
 
   const newSocket = this.createConnection(options, oncreate);
   if (newSocket)
@@ -327,6 +329,11 @@ function calculateServerName(options, req) {
   let servername = options.host;
   const hostHeader = req.getHeader('host');
   if (hostHeader) {
+    if (typeof hostHeader !== 'string') {
+      throw new ERR_INVALID_ARG_TYPE('options.headers.host',
+                                     'String', hostHeader);
+    }
+
     // abc => abc
     // abc:123 => abc
     // [::1] => ::1
@@ -442,8 +449,12 @@ Agent.prototype.removeSocket = function removeSocket(s, options) {
   if (req && options) {
     req[kRequestOptions] = undefined;
     // If we have pending requests and a socket gets closed make a new one
-    const socketCreationHandler = handleSocketCreation(this, req, false);
-    this.createSocket(req, options, socketCreationHandler);
+    this.createSocket(req, options, (err, socket) => {
+      if (err)
+        req.onSocket(socket, err);
+      else
+        socket.emit('free');
+    });
   }
 
 };
@@ -452,6 +463,11 @@ Agent.prototype.keepSocketAlive = function keepSocketAlive(socket) {
   socket.setKeepAlive(true, this.keepAliveMsecs);
   socket.unref();
 
+  const agentTimeout = this.options.timeout || 0;
+  if (socket.timeout !== agentTimeout) {
+    socket.setTimeout(agentTimeout);
+  }
+
   return true;
 };
 
@@ -472,19 +488,6 @@ Agent.prototype.destroy = function destroy() {
   }
 };
 
-function handleSocketCreation(agent, request, informRequest) {
-  return function handleSocketCreation_Inner(err, socket) {
-    if (err) {
-      process.nextTick(emitErrorNT, request, err);
-      return;
-    }
-    if (informRequest)
-      setRequestSocket(agent, request, socket);
-    else
-      socket.emit('free');
-  };
-}
-
 function setRequestSocket(agent, req, socket) {
   req.onSocket(socket);
   const agentTimeout = agent.options.timeout || 0;
@@ -494,8 +497,14 @@ function setRequestSocket(agent, req, socket) {
   socket.setTimeout(req.timeout);
 }
 
-function emitErrorNT(emitter, err) {
-  emitter.emit('error', err);
+function asyncResetHandle(socket) {
+  // Guard against an uninitialized or user supplied Socket.
+  const handle = socket._handle;
+  if (handle && typeof handle.asyncReset === 'function') {
+    // Assign the handle a new asyncId and run any destroy()/init() hooks.
+    handle.asyncReset(new ReusedHandle(handle.getProviderType(), handle));
+    socket[async_id_symbol] = handle.getAsyncId();
+  }
 }
 
 module.exports = {
diff --git a/lib/_http_client.js b/lib/_http_client.js
index f2639aafce324d245c233076d850fe6e075628ab..5efc69757a32752bb31268feed4317bf5ee6cf00 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -29,11 +29,14 @@ const {
   ObjectAssign,
   ObjectKeys,
   ObjectSetPrototypeOf,
+  String,
+  Symbol
 } = primordials;
 
 const net = require('net');
 const url = require('url');
 const assert = require('internal/assert');
+const { once } = require('internal/util');
 const {
   _checkIsHttpToken: checkIsHttpToken,
   debug,
@@ -47,9 +50,9 @@ const { OutgoingMessage } = require('_http_outgoing');
 const Agent = require('_http_agent');
 const { Buffer } = require('buffer');
 const { defaultTriggerAsyncIdScope } = require('internal/async_hooks');
-const { URL, urlToOptions, searchParamsSymbol } = require('internal/url');
+const { URL, urlToHttpOptions, searchParamsSymbol } = require('internal/url');
 const { kOutHeaders, kNeedDrain } = require('internal/http');
-const { connResetException, codes } = require('internal/errors');
+const { AbortError, connResetException, codes } = require('internal/errors');
 const {
   ERR_HTTP_HEADERS_SENT,
   ERR_INVALID_ARG_TYPE,
@@ -57,6 +60,10 @@ const {
   ERR_INVALID_PROTOCOL,
   ERR_UNESCAPED_CHARACTERS
 } = codes;
+const {
+  validateInteger,
+  validateAbortSignal,
+} = require('internal/validators');
 const { getTimerDuration } = require('internal/timers');
 const {
   DTRACE_HTTP_CLIENT_REQUEST,
@@ -64,6 +71,7 @@ const {
 } = require('internal/dtrace');
 
 const INVALID_PATH_REGEX = /[^\u0021-\u00ff]/;
+const kError = Symbol('kError');
 
 function validateHost(host, name) {
   if (host !== null && host !== undefined && typeof host !== 'string') {
@@ -88,7 +96,7 @@ function ClientRequest(input, options, cb) {
   if (typeof input === 'string') {
     const urlStr = input;
     try {
-      input = urlToOptions(new URL(urlStr));
+      input = urlToHttpOptions(new URL(urlStr));
     } catch (err) {
       input = url.parse(urlStr);
       if (!input.hostname) {
@@ -105,7 +113,7 @@ function ClientRequest(input, options, cb) {
   } else if (input && input[searchParamsSymbol] &&
              input[searchParamsSymbol][searchParamsSymbol]) {
     // url.URL instance
-    input = urlToOptions(input);
+    input = urlToHttpOptions(input);
   } else {
     cb = options;
     options = input;
@@ -165,6 +173,15 @@ function ClientRequest(input, options, cb) {
   if (options.timeout !== undefined)
     this.timeout = getTimerDuration(options.timeout, 'timeout');
 
+  const signal = options.signal;
+  if (signal) {
+    validateAbortSignal(signal, 'options.signal');
+    const listener = (e) => this.destroy(new AbortError());
+    signal.addEventListener('abort', listener);
+    this.once('close', () => {
+      signal.removeEventListener('abort', listener);
+    });
+  }
   let method = options.method;
   const methodIsString = (typeof method === 'string');
   if (method !== null && method !== undefined && !methodIsString) {
@@ -180,6 +197,11 @@ function ClientRequest(input, options, cb) {
     method = this.method = 'GET';
   }
 
+  const maxHeaderSize = options.maxHeaderSize;
+  if (maxHeaderSize !== undefined)
+    validateInteger(maxHeaderSize, 'maxHeaderSize', 0);
+  this.maxHeaderSize = maxHeaderSize;
+
   const insecureHTTPParser = options.insecureHTTPParser;
   if (insecureHTTPParser !== undefined &&
       typeof insecureHTTPParser !== 'boolean') {
@@ -215,8 +237,6 @@ function ClientRequest(input, options, cb) {
   this.host = host;
   this.protocol = protocol;
 
-  let called = false;
-
   if (this.agent) {
     // If there is an agent we should default to Connection:keep-alive,
     // but only if the Agent will actually reuse the connection!
@@ -280,18 +300,6 @@ function ClientRequest(input, options, cb) {
                       options.headers);
   }
 
-  const oncreate = (err, socket) => {
-    if (called)
-      return;
-    called = true;
-    if (err) {
-      process.nextTick(() => this.emit('error', err));
-      return;
-    }
-    this.onSocket(socket);
-    this._deferToConnect(null, null, () => this._flush());
-  };
-
   // initiate connection
   if (this.agent) {
     this.agent.addRequest(this, options);
@@ -300,26 +308,33 @@ function ClientRequest(input, options, cb) {
     this._last = true;
     this.shouldKeepAlive = false;
     if (typeof options.createConnection === 'function') {
-      const newSocket = options.createConnection(options, oncreate);
-      if (newSocket && !called) {
-        called = true;
-        this.onSocket(newSocket);
-      } else {
-        return;
+      const oncreate = once((err, socket) => {
+        if (err) {
+          process.nextTick(() => this.emit('error', err));
+        } else {
+          this.onSocket(socket);
+        }
+      });
+
+      try {
+        const newSocket = options.createConnection(options, oncreate);
+        if (newSocket) {
+          oncreate(null, newSocket);
+        }
+      } catch (err) {
+        oncreate(err);
       }
     } else {
       debug('CLIENT use net.createConnection', options);
       this.onSocket(net.createConnection(options));
     }
   }
-
-  this._deferToConnect(null, null, () => this._flush());
 }
 ObjectSetPrototypeOf(ClientRequest.prototype, OutgoingMessage.prototype);
 ObjectSetPrototypeOf(ClientRequest, OutgoingMessage);
 
 ClientRequest.prototype._finish = function _finish() {
-  DTRACE_HTTP_CLIENT_REQUEST(this, this.connection);
+  DTRACE_HTTP_CLIENT_REQUEST(this, this.socket);
   OutgoingMessage.prototype._finish.call(this);
 };
 
@@ -332,10 +347,19 @@ ClientRequest.prototype._implicitHeader = function _implicitHeader() {
 };
 
 ClientRequest.prototype.abort = function abort() {
-  if (!this.aborted) {
-    process.nextTick(emitAbortNT, this);
+  if (this.aborted) {
+    return;
   }
   this.aborted = true;
+  process.nextTick(emitAbortNT, this);
+  this.destroy();
+};
+
+ClientRequest.prototype.destroy = function destroy(err) {
+  if (this.destroyed) {
+    return this;
+  }
+  this.destroyed = true;
 
   // If we're aborting, we don't care about any more response data.
   if (this.res) {
@@ -345,11 +369,33 @@ ClientRequest.prototype.abort = function abort() {
   // In the event that we don't have a socket, we will pop out of
   // the request queue through handling in onSocket.
   if (this.socket) {
-    // in-progress
-    this.socket.destroy();
+    _destroy(this, this.socket, err);
+  } else if (err) {
+    this[kError] = err;
   }
+
+  return this;
 };
 
+function _destroy(req, socket, err) {
+  // TODO (ronag): Check if socket was used at all (e.g. headersSent) and
+  // re-use it in that case. `req.socket` just checks whether the socket was
+  // assigned to the request and *might* have been used.
+  if (socket && (!req.agent || req.socket)) {
+    socket.destroy(err);
+  } else {
+    if (socket) {
+      socket.emit('free');
+    }
+    if (!req.aborted && !err) {
+      err = connResetException('socket hang up');
+    }
+    if (err) {
+      req.emit('error', err);
+    }
+    req.emit('close');
+  }
+}
 
 function emitAbortNT(req) {
   req.emit('abort');
@@ -377,6 +423,8 @@ function socketCloseListener() {
   // the `socketOnData`.
   const parser = socket.parser;
   const res = req.res;
+
+  req.destroyed = true;
   if (res) {
     // Socket closed before we emitted 'end' below.
     if (!res.complete) {
@@ -384,7 +432,7 @@ function socketCloseListener() {
       res.emit('aborted');
     }
     req.emit('close');
-    if (res.readable) {
+    if (!res.aborted && res.readable) {
       res.on('end', function() {
         this.emit('close');
       });
@@ -427,17 +475,10 @@ function socketErrorListener(err) {
     req.emit('error', err);
   }
 
-  // Handle any pending data
-  socket.read();
-
   const parser = socket.parser;
   if (parser) {
-    // Use process.nextTick() on v12.x since 'error' events might be
-    // emitted synchronously from e.g. a failed write() call on the socket.
-    process.nextTick(() => {
-      parser.finish();
-      freeParser(parser, req, socket);
-    });
+    parser.finish();
+    freeParser(parser, req, socket);
   }
 
   // Ensure that no further data will come out of the socket
@@ -488,6 +529,10 @@ function socketOnData(d) {
     socket.removeListener('data', socketOnData);
     socket.removeListener('end', socketOnEnd);
     socket.removeListener('drain', ondrain);
+
+    if (req.timeoutCb) socket.removeListener('timeout', req.timeoutCb);
+    socket.removeListener('timeout', responseOnTimeout);
+
     parser.finish();
     freeParser(parser, req, socket);
 
@@ -594,6 +639,7 @@ function parserOnIncomingClient(res, shouldKeepAlive) {
   // Add our listener first, so that we guarantee socket cleanup
   res.on('end', responseOnEnd);
   req.on('prefinish', requestOnPrefinish);
+  socket.on('timeout', responseOnTimeout);
 
   // If the user did not listen for the 'response' event, then they
   // can't possibly read the data, so we ._dump() it into the void
@@ -604,6 +650,11 @@ function parserOnIncomingClient(res, shouldKeepAlive) {
   if (method === 'HEAD')
     return 1;  // Skip body but don't treat as Upgrade.
 
+  if (res.statusCode === 304) {
+    res.complete = true;
+    return 1; // Skip body as there won't be any
+  }
+
   return 0;  // No special treatment.
 }
 
@@ -629,20 +680,29 @@ function responseKeepAlive(req) {
   const asyncId = socket._handle ? socket._handle.getAsyncId() : undefined;
   // Mark this socket as available, AFTER user-added end
   // handlers have a chance to run.
-  defaultTriggerAsyncIdScope(asyncId, process.nextTick, emitFreeNT, socket);
+  defaultTriggerAsyncIdScope(asyncId, process.nextTick, emitFreeNT, req);
+
+  req.destroyed = true;
+  if (req.res) {
+    req.res.destroyed = true;
+    // Detach socket from IncomingMessage to avoid destroying the freed
+    // socket in IncomingMessage.destroy().
+    req.res.socket = null;
+  }
 }
 
 function responseOnEnd() {
   const req = this.req;
+  const socket = req.socket;
 
-  if (req.socket && req.timeoutCb) {
-    req.socket.removeListener('timeout', emitRequestTimeout);
+  if (socket) {
+    if (req.timeoutCb) socket.removeListener('timeout', emitRequestTimeout);
+    socket.removeListener('timeout', responseOnTimeout);
   }
 
   req._ended = true;
 
   if (!req.shouldKeepAlive) {
-    const socket = req.socket;
     if (socket.writable) {
       debug('AGENT socket.destroySoon()');
       if (typeof socket.destroySoon === 'function')
@@ -651,7 +711,7 @@ function responseOnEnd() {
         socket.end();
     }
     assert(!socket.writable);
-  } else if (req.finished) {
+  } else if (req.finished && !this.aborted) {
     // We can assume `req.finished` means all data has been written since:
     // - `'responseOnEnd'` means we have been assigned a socket.
     // - when we have a socket we write directly to it without buffering.
@@ -661,6 +721,14 @@ function responseOnEnd() {
   }
 }
 
+function responseOnTimeout() {
+  const req = this._httpMessage;
+  if (!req) return;
+  const res = req.res;
+  if (!res) return;
+  res.emit('timeout');
+}
+
 function requestOnPrefinish() {
   const req = this;
 
@@ -668,16 +736,23 @@ function requestOnPrefinish() {
     responseKeepAlive(req);
 }
 
-function emitFreeNT(socket) {
-  socket.emit('free');
+function emitFreeNT(req) {
+  req.emit('close');
+  if (req.res) {
+    req.res.emit('close');
+  }
+
+  if (req.socket) {
+    req.socket.emit('free');
+  }
 }
 
 function tickOnSocket(req, socket) {
   const parser = parsers.alloc();
   req.socket = socket;
-  req.connection = socket;
   parser.initialize(HTTPParser.RESPONSE,
                     new HTTPClientAsyncResource('HTTPINCOMINGMESSAGE', req),
+                    req.maxHeaderSize || 0,
                     req.insecureHTTPParser === undefined ?
                       isLenient() : req.insecureHTTPParser,
                     0);
@@ -732,22 +807,21 @@ function listenSocketTimeout(req) {
   }
 }
 
-ClientRequest.prototype.onSocket = function onSocket(socket) {
+ClientRequest.prototype.onSocket = function onSocket(socket, err) {
   // TODO(ronag): Between here and onSocketNT the socket
   // has no 'error' handler.
-  process.nextTick(onSocketNT, this, socket);
+  process.nextTick(onSocketNT, this, socket, err);
 };
 
-function onSocketNT(req, socket) {
-  if (req.aborted) {
-    // If we were aborted while waiting for a socket, skip the whole thing.
-    if (!req.agent) {
-      socket.destroy();
-    } else {
-      socket.emit('free');
-    }
+function onSocketNT(req, socket, err) {
+  if (req.destroyed) {
+    _destroy(req, socket, req[kError]);
+  } else if (err) {
+    req.destroyed = true;
+    _destroy(req, null, err);
   } else {
     tickOnSocket(req, socket);
+    req._flush();
   }
 }
 
diff --git a/lib/_http_common.js b/lib/_http_common.js
index 8e2387e45367693cb78faf7dd9e0b14ff804d59a..361776f249810e2d1d97e5608489315c721e7e4c 100644
--- a/lib/_http_common.js
+++ b/lib/_http_common.js
@@ -27,11 +27,8 @@ const {
 } = primordials;
 const { setImmediate } = require('timers');
 
+const { methods, HTTPParser } = internalBinding('http_parser');
 const { getOptionValue } = require('internal/options');
-
-const { methods, HTTPParser } =
-  getOptionValue('--http-parser') === 'legacy' ?
-    internalBinding('http_parser') : internalBinding('http_parser_llhttp');
 const insecureHTTPParser = getOptionValue('--insecure-http-parser');
 
 const FreeList = require('internal/freelist');
@@ -47,6 +44,8 @@ let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
 });
 
 const kIncomingMessage = Symbol('IncomingMessage');
+const kRequestTimeout = Symbol('RequestTimeout');
+const kOnMessageBegin = HTTPParser.kOnMessageBegin | 0;
 const kOnHeaders = HTTPParser.kOnHeaders | 0;
 const kOnHeadersComplete = HTTPParser.kOnHeadersComplete | 0;
 const kOnBody = HTTPParser.kOnBody | 0;
@@ -102,6 +101,12 @@ function parserOnHeadersComplete(versionMajor, versionMinor, headers, method,
   incoming.url = url;
   incoming.upgrade = upgrade;
 
+  if (socket) {
+    debug('requestTimeout timer moved to req');
+    incoming[kRequestTimeout] = incoming.socket[kRequestTimeout];
+    incoming.socket[kRequestTimeout] = undefined;
+  }
+
   let n = headers.length;
 
   // If parser.maxHeaderPairs <= 0 assume that there's no limit.
@@ -234,6 +239,7 @@ function cleanParser(parser) {
   parser.incoming = null;
   parser.outgoing = null;
   parser.maxHeaderPairs = MAX_HEADER_PAIRS;
+  parser[kOnMessageBegin] = null;
   parser[kOnExecute] = null;
   parser[kOnTimeout] = null;
   parser._consumed = false;
@@ -267,6 +273,7 @@ module.exports = {
   methods,
   parsers,
   kIncomingMessage,
+  kRequestTimeout,
   HTTPParser,
   isLenient,
   prepareError,
diff --git a/lib/_http_incoming.js b/lib/_http_incoming.js
index d4431256646573c97f2bf4d9d7ef4a3b6fde1fee..628043aaf76131a7fad176c4c5dfce4c82afa183 100644
--- a/lib/_http_incoming.js
+++ b/lib/_http_incoming.js
@@ -22,6 +22,7 @@
 'use strict';
 
 const {
+  ObjectDefineProperty,
   ObjectSetPrototypeOf,
 } = primordials;
 
@@ -47,12 +48,11 @@ function IncomingMessage(socket) {
     };
   }
 
-  Stream.Readable.call(this, streamOptions);
+  Stream.Readable.call(this, { autoDestroy: false, ...streamOptions });
 
   this._readableState.readingMore = true;
 
   this.socket = socket;
-  this.connection = socket;
 
   this.httpVersionMajor = null;
   this.httpVersionMinor = null;
@@ -63,8 +63,6 @@ function IncomingMessage(socket) {
   this.trailers = {};
   this.rawTrailers = [];
 
-  this.readable = true;
-
   this.aborted = false;
 
   this.upgrade = null;
@@ -86,6 +84,15 @@ function IncomingMessage(socket) {
 ObjectSetPrototypeOf(IncomingMessage.prototype, Stream.Readable.prototype);
 ObjectSetPrototypeOf(IncomingMessage, Stream.Readable);
 
+ObjectDefineProperty(IncomingMessage.prototype, 'connection', {
+  get: function() {
+    return this.socket;
+  },
+  set: function(val) {
+    this.socket = val;
+  }
+});
+
 IncomingMessage.prototype.setTimeout = function setTimeout(msecs, callback) {
   if (callback)
     this.on('timeout', callback);
@@ -93,7 +100,14 @@ IncomingMessage.prototype.setTimeout = function setTimeout(msecs, callback) {
   return this;
 };
 
-
+// Argument n cannot be factored out due to the overhead of
+// argument adaptor frame creation inside V8 in case that number of actual
+// arguments is different from expected arguments.
+// Ref: https://bugs.chromium.org/p/v8/issues/detail?id=10201
+// NOTE: Argument adapt frame issue might be solved in V8 engine v8.9.
+// Refactoring `n` out might be possible when V8 is upgraded to that
+// version.
+// Ref: https://v8.dev/blog/v8-release-89
 IncomingMessage.prototype._read = function _read(n) {
   if (!this._consuming) {
     this._readableState.readingMore = false;
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index 1e1e65736d98a8a6ee856b717c3542911fd2f594..dbd53365f06e51faba63ca8162febd3c091499f3 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -22,10 +22,12 @@
 'use strict';
 
 const {
+  Array,
   ArrayIsArray,
   ObjectCreate,
   ObjectDefineProperty,
   ObjectKeys,
+  ObjectValues,
   ObjectPrototypeHasOwnProperty,
   ObjectSetPrototypeOf,
   MathFloor,
@@ -53,9 +55,11 @@ const {
     ERR_HTTP_TRAILER_INVALID,
     ERR_INVALID_HTTP_TOKEN,
     ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
     ERR_INVALID_CHAR,
     ERR_METHOD_NOT_IMPLEMENTED,
     ERR_STREAM_CANNOT_PIPE,
+    ERR_STREAM_ALREADY_FINISHED,
     ERR_STREAM_WRITE_AFTER_END
   },
   hideStackFrames
@@ -94,6 +98,7 @@ function OutgoingMessage() {
   this.outputSize = 0;
 
   this.writable = true;
+  this.destroyed = false;
 
   this._last = false;
   this.chunkedEncoding = false;
@@ -115,7 +120,6 @@ function OutgoingMessage() {
   this[kCorked] = 0;
 
   this.socket = null;
-  this.connection = null;
   this._header = null;
   this[kOutHeaders] = null;
 
@@ -181,6 +185,15 @@ ObjectDefineProperty(OutgoingMessage.prototype, '_headers', {
   }, 'OutgoingMessage.prototype._headers is deprecated', 'DEP0066')
 });
 
+ObjectDefineProperty(OutgoingMessage.prototype, 'connection', {
+  get: function() {
+    return this.socket;
+  },
+  set: function(val) {
+    this.socket = val;
+  }
+});
+
 ObjectDefineProperty(OutgoingMessage.prototype, '_headerNames', {
   get: internalUtil.deprecate(function() {
     const headers = this[kOutHeaders];
@@ -273,6 +286,11 @@ OutgoingMessage.prototype.setTimeout = function setTimeout(msecs, callback) {
 // any messages, before ever calling this.  In that case, just skip
 // it, since something else is destroying this connection anyway.
 OutgoingMessage.prototype.destroy = function destroy(error) {
+  if (this.destroyed) {
+    return this;
+  }
+  this.destroyed = true;
+
   if (this.socket) {
     this.socket.destroy(error);
   } else {
@@ -280,6 +298,8 @@ OutgoingMessage.prototype.destroy = function destroy(error) {
       socket.destroy(error);
     });
   }
+
+  return this;
 };
 
 
@@ -310,7 +330,7 @@ OutgoingMessage.prototype._send = function _send(data, encoding, callback) {
 
 OutgoingMessage.prototype._writeRaw = _writeRaw;
 function _writeRaw(data, encoding, callback) {
-  const conn = this.connection;
+  const conn = this.socket;
   if (conn && conn.destroyed) {
     // The socket was destroyed. If we're still trying to write to it,
     // then we haven't gotten the 'close' event yet.
@@ -359,8 +379,19 @@ function _storeHeader(firstLine, headers) {
         processHeader(this, state, entry[0], entry[1], false);
       }
     } else if (ArrayIsArray(headers)) {
-      for (const entry of headers) {
-        processHeader(this, state, entry[0], entry[1], true);
+      if (headers.length && ArrayIsArray(headers[0])) {
+        for (let i = 0; i < headers.length; i++) {
+          const entry = headers[i];
+          processHeader(this, state, entry[0], entry[1], true);
+        }
+      } else {
+        if (headers.length % 2 !== 0) {
+          throw new ERR_INVALID_ARG_VALUE('headers', headers);
+        }
+
+        for (let n = 0; n < headers.length; n += 2) {
+          processHeader(this, state, headers[n + 0], headers[n + 1], true);
+        }
       }
     } else {
       for (const key in headers) {
@@ -537,6 +568,7 @@ OutgoingMessage.prototype.setHeader = function setHeader(name, value) {
     this[kOutHeaders] = headers = ObjectCreate(null);
 
   headers[name.toLowerCase()] = [name, value];
+  return this;
 };
 
 
@@ -558,6 +590,23 @@ OutgoingMessage.prototype.getHeaderNames = function getHeaderNames() {
 };
 
 
+// Returns an array of the names of the current outgoing raw headers.
+OutgoingMessage.prototype.getRawHeaderNames = function getRawHeaderNames() {
+  const headersMap = this[kOutHeaders];
+  if (headersMap === null) return [];
+
+  const values = ObjectValues(headersMap);
+  const headers = Array(values.length);
+  // Retain for(;;) loop for performance reasons
+  // Refs: https://github.com/nodejs/node/pull/30958
+  for (let i = 0, l = values.length; i < l; i++) {
+    headers[i] = values[i][0];
+  }
+
+  return headers;
+};
+
+
 // Returns a shallow copy of the current outgoing headers.
 OutgoingMessage.prototype.getHeaders = function getHeaders() {
   const headers = this[kOutHeaders];
@@ -614,7 +663,7 @@ OutgoingMessage.prototype.removeHeader = function removeHeader(name) {
 
 
 OutgoingMessage.prototype._implicitHeader = function _implicitHeader() {
-  this.emit('error', new ERR_METHOD_NOT_IMPLEMENTED('_implicitHeader()'));
+  throw new ERR_METHOD_NOT_IMPLEMENTED('_implicitHeader()');
 };
 
 ObjectDefineProperty(OutgoingMessage.prototype, 'headersSent', {
@@ -627,6 +676,11 @@ ObjectDefineProperty(OutgoingMessage.prototype, 'writableEnded', {
   get: function() { return this.finished; }
 });
 
+ObjectDefineProperty(OutgoingMessage.prototype, 'writableNeedDrain', {
+  get: function() {
+    return !this.destroyed && !this.finished && this[kNeedDrain];
+  }
+});
 
 const crlf_buf = Buffer.from('\r\n');
 OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {
@@ -636,17 +690,20 @@ OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {
   return ret;
 };
 
+function writeAfterEnd(msg, callback) {
+  const err = new ERR_STREAM_WRITE_AFTER_END();
+  const triggerAsyncId = msg.socket ? msg.socket[async_id_symbol] : undefined;
+  defaultTriggerAsyncIdScope(triggerAsyncId,
+                             process.nextTick,
+                             writeAfterEndNT,
+                             msg,
+                             err,
+                             callback);
+}
+
 function write_(msg, chunk, encoding, callback, fromEnd) {
   if (msg.finished) {
-    const err = new ERR_STREAM_WRITE_AFTER_END();
-    const triggerAsyncId = msg.socket ? msg.socket[async_id_symbol] : undefined;
-    defaultTriggerAsyncIdScope(triggerAsyncId,
-                               process.nextTick,
-                               writeAfterEndNT,
-                               msg,
-                               err,
-                               callback);
-
+    writeAfterEnd(msg, callback);
     return true;
   }
 
@@ -661,14 +718,14 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
     return true;
   }
 
-  if (!fromEnd && typeof chunk !== 'string' && !isUint8Array(chunk)) {
+  if (!fromEnd && typeof chunk !== 'string' && !(isUint8Array(chunk))) {
     throw new ERR_INVALID_ARG_TYPE('first argument',
                                    ['string', 'Buffer', 'Uint8Array'], chunk);
   }
 
-  if (!fromEnd && msg.connection && !msg.connection.writableCorked) {
-    msg.connection.cork();
-    process.nextTick(connectionCorkNT, msg, msg.connection);
+  if (!fromEnd && msg.socket && !msg.socket.writableCorked) {
+    msg.socket.cork();
+    process.nextTick(connectionCorkNT, msg.socket);
   }
 
   let ret;
@@ -744,19 +801,21 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
     encoding = null;
   }
 
-  if (this.finished) {
-    return this;
-  }
-
-  if (this.socket) {
+  // Not finished, socket exists and data will be written (chunk or header)
+  if (this.socket && !this.finished && (chunk || !this._header)) {
     this.socket.cork();
   }
 
   if (chunk) {
     if (typeof chunk !== 'string' && !(chunk instanceof Buffer)) {
-      throw new ERR_INVALID_ARG_TYPE(
-        'chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
+      throw new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
+    }
+
+    if (this.finished) {
+      writeAfterEnd(this, callback);
+      return this;
     }
+
     if (!this._header) {
       if (typeof chunk === 'string')
         this._contentLength = Buffer.byteLength(chunk, encoding);
@@ -764,6 +823,15 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
         this._contentLength = chunk.length;
     }
     write_(this, chunk, encoding, null, true);
+  } else if (this.finished) {
+    if (typeof callback === 'function') {
+      if (!this.writableFinished) {
+        this.on('finish', callback);
+      } else {
+        callback(new ERR_STREAM_ALREADY_FINISHED('end'));
+      }
+    }
+    return this;
   } else if (!this._header) {
     this._contentLength = 0;
     this._implicitHeader();
@@ -794,8 +862,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
   // everything to the socket.
   debug('outgoing message end.');
   if (this.outputData.length === 0 &&
-      this.connection &&
-      this.connection._httpMessage === this) {
+      this.socket &&
+      this.socket._httpMessage === this) {
     this._finish();
   }
 
@@ -804,7 +872,7 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 
 
 OutgoingMessage.prototype._finish = function _finish() {
-  assert(this.connection);
+  assert(this.socket);
   this.emit('prefinish');
 };
 
@@ -883,10 +951,6 @@ OutgoingMessage.prototype.flushHeaders = function flushHeaders() {
   this._send('');
 };
 
-OutgoingMessage.prototype.flush = internalUtil.deprecate(function() {
-  this.flushHeaders();
-}, 'OutgoingMessage.flush is deprecated. Use flushHeaders instead.', 'DEP0001');
-
 OutgoingMessage.prototype.pipe = function pipe() {
   // OutgoingMessage should be write-only. Piping from it is disabled.
   this.emit('error', new ERR_STREAM_CANNOT_PIPE());
@@ -898,5 +962,7 @@ function(err, event) {
 };
 
 module.exports = {
+  validateHeaderName,
+  validateHeaderValue,
   OutgoingMessage
 };
diff --git a/lib/_http_server.js b/lib/_http_server.js
index 4d1f8e4fbd7077e63c43229d7498eefe4124a265..6d587d9d048000a7a89ef1d6faf4c5555e32de14 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -22,10 +22,12 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   Error,
   ObjectKeys,
   ObjectSetPrototypeOf,
   Symbol,
+  SymbolFor,
 } = primordials;
 
 const net = require('net');
@@ -39,6 +41,7 @@ const {
   continueExpression,
   chunkExpression,
   kIncomingMessage,
+  kRequestTimeout,
   HTTPParser,
   isLenient,
   _checkInvalidHeaderChar: checkInvalidHeaderChar,
@@ -56,91 +59,100 @@ const {
 } = require('internal/async_hooks');
 const { IncomingMessage } = require('_http_incoming');
 const {
+  ERR_HTTP_REQUEST_TIMEOUT,
   ERR_HTTP_HEADERS_SENT,
   ERR_HTTP_INVALID_STATUS_CODE,
   ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_ARG_VALUE,
   ERR_INVALID_CHAR
 } = require('internal/errors').codes;
+const {
+  validateInteger,
+  validateBoolean
+} = require('internal/validators');
 const Buffer = require('buffer').Buffer;
 const {
   DTRACE_HTTP_SERVER_REQUEST,
   DTRACE_HTTP_SERVER_RESPONSE
 } = require('internal/dtrace');
-const { getOptionValue } = require('internal/options');
 const { observerCounts, constants } = internalBinding('performance');
+const { setTimeout, clearTimeout } = require('timers');
 const { NODE_PERFORMANCE_ENTRY_TYPE_HTTP } = constants;
 
+const dc = require('diagnostics_channel');
+const onRequestStartChannel = dc.channel('http.server.request.start');
+const onResponseFinishChannel = dc.channel('http.server.response.finish');
+
 const kServerResponse = Symbol('ServerResponse');
 const kServerResponseStatistics = Symbol('ServerResponseStatistics');
-const kDefaultHttpServerTimeout =
-  getOptionValue('--http-server-default-timeout');
 
 const STATUS_CODES = {
-  100: 'Continue',
-  101: 'Switching Protocols',
-  102: 'Processing',                 // RFC 2518, obsoleted by RFC 4918
-  103: 'Early Hints',
-  200: 'OK',
-  201: 'Created',
-  202: 'Accepted',
-  203: 'Non-Authoritative Information',
-  204: 'No Content',
-  205: 'Reset Content',
-  206: 'Partial Content',
-  207: 'Multi-Status',               // RFC 4918
-  208: 'Already Reported',
-  226: 'IM Used',
-  300: 'Multiple Choices',           // RFC 7231
-  301: 'Moved Permanently',
-  302: 'Found',
-  303: 'See Other',
-  304: 'Not Modified',
-  305: 'Use Proxy',
-  307: 'Temporary Redirect',
-  308: 'Permanent Redirect',         // RFC 7238
-  400: 'Bad Request',
-  401: 'Unauthorized',
-  402: 'Payment Required',
-  403: 'Forbidden',
-  404: 'Not Found',
-  405: 'Method Not Allowed',
-  406: 'Not Acceptable',
-  407: 'Proxy Authentication Required',
-  408: 'Request Timeout',
-  409: 'Conflict',
-  410: 'Gone',
-  411: 'Length Required',
-  412: 'Precondition Failed',
-  413: 'Payload Too Large',
-  414: 'URI Too Long',
-  415: 'Unsupported Media Type',
-  416: 'Range Not Satisfiable',
-  417: 'Expectation Failed',
-  418: 'I\'m a Teapot',              // RFC 7168
-  421: 'Misdirected Request',
-  422: 'Unprocessable Entity',       // RFC 4918
-  423: 'Locked',                     // RFC 4918
-  424: 'Failed Dependency',          // RFC 4918
-  425: 'Unordered Collection',       // RFC 4918
-  426: 'Upgrade Required',           // RFC 2817
-  428: 'Precondition Required',      // RFC 6585
-  429: 'Too Many Requests',          // RFC 6585
-  431: 'Request Header Fields Too Large', // RFC 6585
-  451: 'Unavailable For Legal Reasons',
-  500: 'Internal Server Error',
-  501: 'Not Implemented',
-  502: 'Bad Gateway',
-  503: 'Service Unavailable',
-  504: 'Gateway Timeout',
-  505: 'HTTP Version Not Supported',
-  506: 'Variant Also Negotiates',    // RFC 2295
-  507: 'Insufficient Storage',       // RFC 4918
-  508: 'Loop Detected',
+  100: 'Continue',                   // RFC 7231 6.2.1
+  101: 'Switching Protocols',        // RFC 7231 6.2.2
+  102: 'Processing',                 // RFC 2518 10.1 (obsoleted by RFC 4918)
+  103: 'Early Hints',                // RFC 8297 2
+  200: 'OK',                         // RFC 7231 6.3.1
+  201: 'Created',                    // RFC 7231 6.3.2
+  202: 'Accepted',                   // RFC 7231 6.3.3
+  203: 'Non-Authoritative Information', // RFC 7231 6.3.4
+  204: 'No Content',                 // RFC 7231 6.3.5
+  205: 'Reset Content',              // RFC 7231 6.3.6
+  206: 'Partial Content',            // RFC 7233 4.1
+  207: 'Multi-Status',               // RFC 4918 11.1
+  208: 'Already Reported',           // RFC 5842 7.1
+  226: 'IM Used',                    // RFC 3229 10.4.1
+  300: 'Multiple Choices',           // RFC 7231 6.4.1
+  301: 'Moved Permanently',          // RFC 7231 6.4.2
+  302: 'Found',                      // RFC 7231 6.4.3
+  303: 'See Other',                  // RFC 7231 6.4.4
+  304: 'Not Modified',               // RFC 7232 4.1
+  305: 'Use Proxy',                  // RFC 7231 6.4.5
+  307: 'Temporary Redirect',         // RFC 7231 6.4.7
+  308: 'Permanent Redirect',         // RFC 7238 3
+  400: 'Bad Request',                // RFC 7231 6.5.1
+  401: 'Unauthorized',               // RFC 7235 3.1
+  402: 'Payment Required',           // RFC 7231 6.5.2
+  403: 'Forbidden',                  // RFC 7231 6.5.3
+  404: 'Not Found',                  // RFC 7231 6.5.4
+  405: 'Method Not Allowed',         // RFC 7231 6.5.5
+  406: 'Not Acceptable',             // RFC 7231 6.5.6
+  407: 'Proxy Authentication Required', // RFC 7235 3.2
+  408: 'Request Timeout',            // RFC 7231 6.5.7
+  409: 'Conflict',                   // RFC 7231 6.5.8
+  410: 'Gone',                       // RFC 7231 6.5.9
+  411: 'Length Required',            // RFC 7231 6.5.10
+  412: 'Precondition Failed',        // RFC 7232 4.2
+  413: 'Payload Too Large',          // RFC 7231 6.5.11
+  414: 'URI Too Long',               // RFC 7231 6.5.12
+  415: 'Unsupported Media Type',     // RFC 7231 6.5.13
+  416: 'Range Not Satisfiable',      // RFC 7233 4.4
+  417: 'Expectation Failed',         // RFC 7231 6.5.14
+  418: 'I\'m a Teapot',              // RFC 7168 2.3.3
+  421: 'Misdirected Request',        // RFC 7540 9.1.2
+  422: 'Unprocessable Entity',       // RFC 4918 11.2
+  423: 'Locked',                     // RFC 4918 11.3
+  424: 'Failed Dependency',          // RFC 4918 11.4
+  425: 'Too Early',                  // RFC 8470 5.2
+  426: 'Upgrade Required',           // RFC 2817 and RFC 7231 6.5.15
+  428: 'Precondition Required',      // RFC 6585 3
+  429: 'Too Many Requests',          // RFC 6585 4
+  431: 'Request Header Fields Too Large', // RFC 6585 5
+  451: 'Unavailable For Legal Reasons', // RFC 7725 3
+  500: 'Internal Server Error',      // RFC 7231 6.6.1
+  501: 'Not Implemented',            // RFC 7231 6.6.2
+  502: 'Bad Gateway',                // RFC 7231 6.6.3
+  503: 'Service Unavailable',        // RFC 7231 6.6.4
+  504: 'Gateway Timeout',            // RFC 7231 6.6.5
+  505: 'HTTP Version Not Supported', // RFC 7231 6.6.6
+  506: 'Variant Also Negotiates',    // RFC 2295 8.1
+  507: 'Insufficient Storage',       // RFC 4918 11.5
+  508: 'Loop Detected',              // RFC 5842 7.2
   509: 'Bandwidth Limit Exceeded',
-  510: 'Not Extended',               // RFC 2774
-  511: 'Network Authentication Required' // RFC 6585
+  510: 'Not Extended',               // RFC 2774 7
+  511: 'Network Authentication Required' // RFC 6585 6
 };
 
+const kOnMessageBegin = HTTPParser.kOnMessageBegin | 0;
 const kOnExecute = HTTPParser.kOnExecute | 0;
 const kOnTimeout = HTTPParser.kOnTimeout | 0;
 
@@ -176,7 +188,7 @@ ObjectSetPrototypeOf(ServerResponse.prototype, OutgoingMessage.prototype);
 ObjectSetPrototypeOf(ServerResponse, OutgoingMessage);
 
 ServerResponse.prototype._finish = function _finish() {
-  DTRACE_HTTP_SERVER_RESPONSE(this.connection);
+  DTRACE_HTTP_SERVER_RESPONSE(this.socket);
   if (this[kServerResponseStatistics] !== undefined) {
     emitStatistics(this[kServerResponseStatistics]);
   }
@@ -214,7 +226,6 @@ ServerResponse.prototype.assignSocket = function assignSocket(socket) {
   socket._httpMessage = this;
   socket.on('close', onServerResponseClose);
   this.socket = socket;
-  this.connection = socket;
   this.emit('socket', socket);
   this._flush();
 };
@@ -223,7 +234,7 @@ ServerResponse.prototype.detachSocket = function detachSocket(socket) {
   assert(socket._httpMessage === this);
   socket.removeListener('close', onServerResponseClose);
   socket._httpMessage = null;
-  this.socket = this.connection = null;
+  this.socket = null;
 };
 
 ServerResponse.prototype.writeContinue = function writeContinue(cb) {
@@ -264,7 +275,16 @@ function writeHead(statusCode, reason, obj) {
   if (this[kOutHeaders]) {
     // Slow-case: when progressive API and header fields are passed.
     let k;
-    if (obj) {
+    if (ArrayIsArray(obj)) {
+      if (obj.length % 2 !== 0) {
+        throw new ERR_INVALID_ARG_VALUE('headers', obj);
+      }
+
+      for (let n = 0; n < obj.length; n += 2) {
+        k = obj[n + 0];
+        if (k) this.setHeader(k, obj[n + 1]);
+      }
+    } else if (obj) {
       const keys = ObjectKeys(obj);
       // Retain for(;;) loop for performance reasons
       // Refs: https://github.com/nodejs/node/pull/30958
@@ -317,6 +337,21 @@ function writeHead(statusCode, reason, obj) {
 // Docs-only deprecated: DEP0063
 ServerResponse.prototype.writeHeader = ServerResponse.prototype.writeHead;
 
+function storeHTTPOptions(options) {
+  this[kIncomingMessage] = options.IncomingMessage || IncomingMessage;
+  this[kServerResponse] = options.ServerResponse || ServerResponse;
+
+  const maxHeaderSize = options.maxHeaderSize;
+  if (maxHeaderSize !== undefined)
+    validateInteger(maxHeaderSize, 'maxHeaderSize', 0);
+  this.maxHeaderSize = maxHeaderSize;
+
+  const insecureHTTPParser = options.insecureHTTPParser;
+  if (insecureHTTPParser !== undefined)
+    validateBoolean(insecureHTTPParser, 'options.insecureHTTPParser');
+  this.insecureHTTPParser = insecureHTTPParser;
+}
+
 function Server(options, requestListener) {
   if (!(this instanceof Server)) return new Server(options, requestListener);
 
@@ -329,17 +364,7 @@ function Server(options, requestListener) {
     throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
   }
 
-  this[kIncomingMessage] = options.IncomingMessage || IncomingMessage;
-  this[kServerResponse] = options.ServerResponse || ServerResponse;
-
-  const insecureHTTPParser = options.insecureHTTPParser;
-  if (insecureHTTPParser !== undefined &&
-      typeof insecureHTTPParser !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE(
-      'options.insecureHTTPParser', 'boolean', insecureHTTPParser);
-  }
-  this.insecureHTTPParser = insecureHTTPParser;
-
+  storeHTTPOptions.call(this, options);
   net.Server.call(this, { allowHalfOpen: true });
 
   if (requestListener) {
@@ -353,10 +378,11 @@ function Server(options, requestListener) {
 
   this.on('connection', connectionListener);
 
-  this.timeout = kDefaultHttpServerTimeout;
+  this.timeout = 0;
   this.keepAliveTimeout = 5000;
   this.maxHeadersCount = null;
   this.headersTimeout = 60 * 1000; // 60 seconds
+  this.requestTimeout = 0;
 }
 ObjectSetPrototypeOf(Server.prototype, net.Server.prototype);
 ObjectSetPrototypeOf(Server, net.Server);
@@ -369,16 +395,15 @@ Server.prototype.setTimeout = function setTimeout(msecs, callback) {
   return this;
 };
 
-Server.prototype[EE.captureRejectionSymbol] = function(
-  err, event, ...args) {
-
+Server.prototype[EE.captureRejectionSymbol] = function(err, event, ...args) {
   switch (event) {
     case 'request':
-      const [ , res] = args;
+      const { 1: res } = args;
       if (!res.headersSent && !res.writableEnded) {
         // Don't leak headers.
-        for (const name of res.getHeaderNames()) {
-          res.removeHeader(name);
+        const names = res.getHeaderNames();
+        for (let i = 0; i < names.length; i++) {
+          res.removeHeader(names[i]);
         }
         res.statusCode = 500;
         res.end(STATUS_CODES[500]);
@@ -387,8 +412,8 @@ Server.prototype[EE.captureRejectionSymbol] = function(
       }
       break;
     default:
-      net.Server.prototype[Symbol.for('nodejs.rejection')]
-        .call(this, err, event, ...args);
+      net.Server.prototype[SymbolFor('nodejs.rejection')]
+        .apply(this, arguments);
   }
 };
 
@@ -420,6 +445,7 @@ function connectionListenerInternal(server, socket) {
   parser.initialize(
     HTTPParser.REQUEST,
     new HTTPServerAsyncResource('HTTPINCOMINGMESSAGE', socket),
+    server.maxHeaderSize || 0,
     server.insecureHTTPParser === undefined ?
       isLenient() : server.insecureHTTPParser,
     server.headersTimeout || 0,
@@ -479,6 +505,16 @@ function connectionListenerInternal(server, socket) {
   parser[kOnTimeout] =
     onParserTimeout.bind(undefined, server, socket);
 
+  // When receiving new requests on the same socket (pipelining or keep alive)
+  // make sure the requestTimeout is active.
+  parser[kOnMessageBegin] =
+    setRequestTimeout.bind(undefined, server, socket);
+
+  // This protects from DOS attack where an attacker establish the connection
+  // without sending any data on applications where server.timeout is left to
+  // the default value of zero.
+  setRequestTimeout(server, socket);
+
   socket._paused = false;
 }
 
@@ -565,6 +601,11 @@ function socketOnData(server, socket, parser, state, d) {
   onParserExecuteCommon(server, socket, parser, state, ret, d);
 }
 
+function onRequestTimeout(socket) {
+  socket[kRequestTimeout] = undefined;
+  socketOnError.call(socket, new ERR_HTTP_REQUEST_TIMEOUT());
+}
+
 function onParserExecute(server, socket, parser, state, ret) {
   // When underlying `net.Socket` instance is consumed - no
   // `data` events are emitted, and thus `socket.setTimeout` fires the
@@ -587,6 +628,10 @@ const badRequestResponse = Buffer.from(
   `HTTP/1.1 400 ${STATUS_CODES[400]}${CRLF}` +
   `Connection: close${CRLF}${CRLF}`, 'ascii'
 );
+const requestTimeoutResponse = Buffer.from(
+  `HTTP/1.1 408 ${STATUS_CODES[408]}${CRLF}` +
+  `Connection: close${CRLF}${CRLF}`, 'ascii'
+);
 const requestHeaderFieldsTooLargeResponse = Buffer.from(
   `HTTP/1.1 431 ${STATUS_CODES[431]}${CRLF}` +
   `Connection: close${CRLF}${CRLF}`, 'ascii'
@@ -598,8 +643,20 @@ function socketOnError(e) {
 
   if (!this.server.emit('clientError', e, this)) {
     if (this.writable && this.bytesWritten === 0) {
-      const response = e.code === 'HPE_HEADER_OVERFLOW' ?
-        requestHeaderFieldsTooLargeResponse : badRequestResponse;
+      let response;
+
+      switch (e.code) {
+        case 'HPE_HEADER_OVERFLOW':
+          response = requestHeaderFieldsTooLargeResponse;
+          break;
+        case 'ERR_HTTP_REQUEST_TIMEOUT':
+          response = requestTimeoutResponse;
+          break;
+        default:
+          response = badRequestResponse;
+          break;
+      }
+
       this.write(response);
     }
     this.destroy(e);
@@ -627,6 +684,7 @@ function onParserExecuteCommon(server, socket, parser, state, ret, d) {
     socket.removeListener('close', state.onClose);
     socket.removeListener('drain', state.onDrain);
     socket.removeListener('error', socketOnError);
+    socket.removeListener('timeout', socketOnTimeout);
     unconsume(parser, socket);
     parser.finish();
     freeParser(parser, req, socket);
@@ -638,11 +696,20 @@ function onParserExecuteCommon(server, socket, parser, state, ret, d) {
       const bodyHead = d.slice(ret, d.length);
 
       socket.readableFlowing = null;
+
+      // Clear the requestTimeout after upgrading the connection.
+      clearRequestTimeout(req);
+
       server.emit(eventName, req, socket, bodyHead);
     } else {
       // Got CONNECT method, but have no handler.
       socket.destroy();
     }
+  } else {
+    // When receiving new requests on the same socket (pipelining or keep alive)
+    // make sure the requestTimeout is active.
+    parser[kOnMessageBegin] =
+      setRequestTimeout.bind(undefined, server, socket);
   }
 
   if (socket._paused && socket.parser) {
@@ -668,7 +735,42 @@ function clearIncoming(req) {
   }
 }
 
+function setRequestTimeout(server, socket) {
+  // Set the request timeout handler.
+  if (
+    !socket[kRequestTimeout] &&
+    server.requestTimeout && server.requestTimeout > 0
+  ) {
+    debug('requestTimeout timer set');
+    socket[kRequestTimeout] =
+      setTimeout(onRequestTimeout, server.requestTimeout, socket).unref();
+  }
+}
+
+function clearRequestTimeout(req) {
+  if (!req) {
+    req = this;
+  }
+
+  if (!req[kRequestTimeout]) {
+    return;
+  }
+
+  debug('requestTimeout timer cleared');
+  clearTimeout(req[kRequestTimeout]);
+  req[kRequestTimeout] = undefined;
+}
+
 function resOnFinish(req, res, socket, state, server) {
+  if (onResponseFinishChannel.hasSubscribers) {
+    onResponseFinishChannel.publish({
+      request: req,
+      response: res,
+      socket,
+      server
+    });
+  }
+
   // Usually the first incoming element should be our request.  it may
   // be that in the case abortIncoming() was called that the incoming
   // array will be empty.
@@ -682,6 +784,14 @@ function resOnFinish(req, res, socket, state, server) {
   if (!req._consuming && !req._readableState.resumeScheduled)
     req._dump();
 
+  // Make sure the requestTimeout is cleared before finishing.
+  // This might occur if the application has sent a response
+  // without consuming the request body, which would have already
+  // cleared the timer.
+  // clearRequestTimeout can be executed even if the timer is not active,
+  // so this is safe.
+  clearRequestTimeout(req);
+
   res.detachSocket(socket);
   clearIncoming(req);
   process.nextTick(emitCloseNT, res);
@@ -746,6 +856,15 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
   res.shouldKeepAlive = keepAlive;
   DTRACE_HTTP_SERVER_REQUEST(req, socket);
 
+  if (onRequestStartChannel.hasSubscribers) {
+    onRequestStartChannel.publish({
+      request: req,
+      response: res,
+      socket,
+      server
+    });
+  }
+
   if (socket._httpMessage) {
     // There are already pending outgoing res, append.
     state.outgoing.push(res);
@@ -776,6 +895,8 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
       res.end();
     }
   } else {
+    req.on('end', clearRequestTimeout);
+
     server.emit('request', req, res);
   }
   return 0;  // No special treatment.
@@ -845,6 +966,7 @@ module.exports = {
   STATUS_CODES,
   Server,
   ServerResponse,
+  storeHTTPOptions,
   _connectionListener: connectionListener,
   kServerResponse
 };
diff --git a/lib/_stream_duplex.js b/lib/_stream_duplex.js
index 36908dddf6a7bfd0d0549f44d761301922984edd..9e46d02ddcb3d3a2ae14c68574df341f56d70edb 100644
--- a/lib/_stream_duplex.js
+++ b/lib/_stream_duplex.js
@@ -1,143 +1,6 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a duplex stream is just a stream that is both readable and writable.
-// Since JS doesn't have multiple prototype inheritance, this class
-// prototypically inherits from Readable, and then parasitically from
-// Writable.
-
 'use strict';
 
-const {
-  ObjectDefineProperties,
-  ObjectKeys,
-  ObjectSetPrototypeOf,
-} = primordials;
+// TODO(mcollina): deprecate this file
 
+const Duplex = require('internal/streams/duplex');
 module.exports = Duplex;
-
-const Readable = require('_stream_readable');
-const Writable = require('_stream_writable');
-
-ObjectSetPrototypeOf(Duplex.prototype, Readable.prototype);
-ObjectSetPrototypeOf(Duplex, Readable);
-
-{
-  // Allow the keys array to be GC'ed.
-  for (const method of ObjectKeys(Writable.prototype)) {
-    if (!Duplex.prototype[method])
-      Duplex.prototype[method] = Writable.prototype[method];
-  }
-}
-
-function Duplex(options) {
-  if (!(this instanceof Duplex))
-    return new Duplex(options);
-
-  Readable.call(this, options);
-  Writable.call(this, options);
-  this.allowHalfOpen = true;
-
-  if (options) {
-    if (options.readable === false)
-      this.readable = false;
-
-    if (options.writable === false)
-      this.writable = false;
-
-    if (options.allowHalfOpen === false) {
-      this.allowHalfOpen = false;
-      this.once('end', onend);
-    }
-  }
-}
-
-ObjectDefineProperties(Duplex.prototype, {
-
-  destroyed: {
-    get() {
-      if (this._readableState === undefined ||
-        this._writableState === undefined) {
-        return false;
-      }
-      return this._readableState.destroyed && this._writableState.destroyed;
-    },
-    set(value) {
-      // Backward compatibility, the user is explicitly
-      // managing destroyed
-      if (this._readableState && this._writableState) {
-        this._readableState.destroyed = value;
-        this._writableState.destroyed = value;
-      }
-    }
-  },
-
-  writableHighWaterMark: {
-    get() {
-      return this._writableState && this._writableState.highWaterMark;
-    }
-  },
-
-  writableBuffer: {
-    get() {
-      return this._writableState && this._writableState.getBuffer();
-    }
-  },
-
-  writableLength: {
-    get() {
-      return this._writableState && this._writableState.length;
-    }
-  },
-
-  writableFinished: {
-    get() {
-      return this._writableState ? this._writableState.finished : false;
-    }
-  },
-
-  writableCorked: {
-    get() {
-      return this._writableState ? this._writableState.corked : 0;
-    }
-  },
-
-  writableEnded: {
-    get() {
-      return this._writableState ? this._writableState.ending : false;
-    }
-  }
-});
-
-// The no-half-open enforcer
-function onend() {
-  // If the writable side ended, then we're ok.
-  if (this._writableState.ended)
-    return;
-
-  // No more data can be written.
-  // But allow more writes to happen in this tick.
-  process.nextTick(onEndNT, this);
-}
-
-function onEndNT(self) {
-  self.end();
-}
diff --git a/lib/_stream_passthrough.js b/lib/_stream_passthrough.js
index 279df5ac2d68ca39ffacdbd307433fdfb1e879d3..dbf8646e009931e9c7395fd2f77a5fc291ae6bd0 100644
--- a/lib/_stream_passthrough.js
+++ b/lib/_stream_passthrough.js
@@ -1,47 +1,6 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a passthrough stream.
-// basically just the most minimal sort of Transform stream.
-// Every written chunk gets output as-is.
-
 'use strict';
 
-const {
-  ObjectSetPrototypeOf,
-} = primordials;
+// TODO(mcollina): deprecate this file
 
+const PassThrough = require('internal/streams/passthrough');
 module.exports = PassThrough;
-
-const Transform = require('_stream_transform');
-ObjectSetPrototypeOf(PassThrough.prototype, Transform.prototype);
-ObjectSetPrototypeOf(PassThrough, Transform);
-
-function PassThrough(options) {
-  if (!(this instanceof PassThrough))
-    return new PassThrough(options);
-
-  Transform.call(this, options);
-}
-
-PassThrough.prototype._transform = function(chunk, encoding, cb) {
-  cb(null, chunk);
-};
diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
index 3e62d41779312b457379cacac1ea2c1c6c50c644..1e3b32be09bd5aad64d875877145e11cfcbf1338 100644
--- a/lib/_stream_readable.js
+++ b/lib/_stream_readable.js
@@ -1,1259 +1,5 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
 'use strict';
 
-const {
-  ArrayIsArray,
-  NumberIsInteger,
-  NumberIsNaN,
-  ObjectDefineProperties,
-  ObjectSetPrototypeOf,
-  Set,
-  SymbolAsyncIterator,
-  Symbol
-} = primordials;
-
+// TODO(mcollina): deprecate this file
+const Readable = require('internal/streams/readable');
 module.exports = Readable;
-Readable.ReadableState = ReadableState;
-
-const EE = require('events');
-const Stream = require('stream');
-const { Buffer } = require('buffer');
-
-let debug = require('internal/util/debuglog').debuglog('stream', (fn) => {
-  debug = fn;
-});
-const BufferList = require('internal/streams/buffer_list');
-const destroyImpl = require('internal/streams/destroy');
-const {
-  getHighWaterMark,
-  getDefaultHighWaterMark
-} = require('internal/streams/state');
-const {
-  ERR_INVALID_ARG_TYPE,
-  ERR_STREAM_PUSH_AFTER_EOF,
-  ERR_METHOD_NOT_IMPLEMENTED,
-  ERR_STREAM_UNSHIFT_AFTER_END_EVENT
-} = require('internal/errors').codes;
-
-const kPaused = Symbol('kPaused');
-
-// Lazy loaded to improve the startup performance.
-let StringDecoder;
-let createReadableStreamAsyncIterator;
-let from;
-
-ObjectSetPrototypeOf(Readable.prototype, Stream.prototype);
-ObjectSetPrototypeOf(Readable, Stream);
-
-const { errorOrDestroy } = destroyImpl;
-
-function prependListener(emitter, event, fn) {
-  // Sadly this is not cacheable as some libraries bundle their own
-  // event emitter implementation with them.
-  if (typeof emitter.prependListener === 'function')
-    return emitter.prependListener(event, fn);
-
-  // This is a hack to make sure that our error handler is attached before any
-  // userland ones.  NEVER DO THIS. This is here only because this code needs
-  // to continue to work with older versions of Node.js that do not include
-  // the prependListener() method. The goal is to eventually remove this hack.
-  if (!emitter._events || !emitter._events[event])
-    emitter.on(event, fn);
-  else if (ArrayIsArray(emitter._events[event]))
-    emitter._events[event].unshift(fn);
-  else
-    emitter._events[event] = [fn, emitter._events[event]];
-}
-
-function ReadableState(options, stream, isDuplex) {
-  // Duplex streams are both readable and writable, but share
-  // the same options object.
-  // However, some cases require setting options to different
-  // values for the readable and the writable sides of the duplex stream.
-  // These options can be provided separately as readableXXX and writableXXX.
-  if (typeof isDuplex !== 'boolean')
-    isDuplex = stream instanceof Stream.Duplex;
-
-  // Object stream flag. Used to make read(n) ignore n and to
-  // make all the buffer merging and length checks go away
-  this.objectMode = !!(options && options.objectMode);
-
-  if (isDuplex)
-    this.objectMode = this.objectMode ||
-      !!(options && options.readableObjectMode);
-
-  // The point at which it stops calling _read() to fill the buffer
-  // Note: 0 is a valid value, means "don't call _read preemptively ever"
-  this.highWaterMark = options ?
-    getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex) :
-    getDefaultHighWaterMark(false);
-
-  // A linked list is used to store data chunks instead of an array because the
-  // linked list can remove elements from the beginning faster than
-  // array.shift()
-  this.buffer = new BufferList();
-  this.length = 0;
-  this.pipes = null;
-  this.pipesCount = 0;
-  this.flowing = null;
-  this.ended = false;
-  this.endEmitted = false;
-  this.reading = false;
-
-  // A flag to be able to tell if the event 'readable'/'data' is emitted
-  // immediately, or on a later tick.  We set this to true at first, because
-  // any actions that shouldn't happen until "later" should generally also
-  // not happen before the first read call.
-  this.sync = true;
-
-  // Whenever we return null, then we set a flag to say
-  // that we're awaiting a 'readable' event emission.
-  this.needReadable = false;
-  this.emittedReadable = false;
-  this.readableListening = false;
-  this.resumeScheduled = false;
-  this[kPaused] = null;
-
-  // Should close be emitted on destroy. Defaults to true.
-  this.emitClose = !options || options.emitClose !== false;
-
-  // Should .destroy() be called after 'end' (and potentially 'finish')
-  this.autoDestroy = !!(options && options.autoDestroy);
-
-  // Has it been destroyed
-  this.destroyed = false;
-
-  // Crypto is kind of old and crusty.  Historically, its default string
-  // encoding is 'binary' so we have to make this configurable.
-  // Everything else in the universe uses 'utf8', though.
-  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8';
-
-  // Ref the piped dest which we need a drain event on it
-  // type: null | Writable | Set<Writable>
-  this.awaitDrainWriters = null;
-  this.multiAwaitDrain = false;
-
-  // If true, a maybeReadMore has been scheduled
-  this.readingMore = false;
-
-  this.decoder = null;
-  this.encoding = null;
-  if (options && options.encoding) {
-    if (!StringDecoder)
-      StringDecoder = require('string_decoder').StringDecoder;
-    this.decoder = new StringDecoder(options.encoding);
-    this.encoding = options.encoding;
-  }
-}
-
-
-function Readable(options) {
-  if (!(this instanceof Readable))
-    return new Readable(options);
-
-  // Checking for a Stream.Duplex instance is faster here instead of inside
-  // the ReadableState constructor, at least with V8 6.5
-  const isDuplex = this instanceof Stream.Duplex;
-
-  this._readableState = new ReadableState(options, this, isDuplex);
-
-  // legacy
-  this.readable = true;
-
-  if (options) {
-    if (typeof options.read === 'function')
-      this._read = options.read;
-
-    if (typeof options.destroy === 'function')
-      this._destroy = options.destroy;
-  }
-
-  Stream.call(this, options);
-}
-
-Readable.prototype.destroy = destroyImpl.destroy;
-Readable.prototype._undestroy = destroyImpl.undestroy;
-Readable.prototype._destroy = function(err, cb) {
-  cb(err);
-};
-
-Readable.prototype[EE.captureRejectionSymbol] = function(err) {
-  // TODO(mcollina): remove the destroyed if once errorEmitted lands in
-  // Readable.
-  if (!this.destroyed) {
-    this.destroy(err);
-  }
-};
-
-// Manually shove something into the read() buffer.
-// This returns true if the highWaterMark has not been hit yet,
-// similar to how Writable.write() returns true if you should
-// write() some more.
-Readable.prototype.push = function(chunk, encoding) {
-  return readableAddChunk(this, chunk, encoding, false);
-};
-
-// Unshift should *always* be something directly out of read()
-Readable.prototype.unshift = function(chunk, encoding) {
-  return readableAddChunk(this, chunk, encoding, true);
-};
-
-function readableAddChunk(stream, chunk, encoding, addToFront) {
-  debug('readableAddChunk', chunk);
-  const state = stream._readableState;
-
-  let err;
-  if (!state.objectMode) {
-    if (typeof chunk === 'string') {
-      encoding = encoding || state.defaultEncoding;
-      if (addToFront && state.encoding && state.encoding !== encoding) {
-        // When unshifting, if state.encoding is set, we have to save
-        // the string in the BufferList with the state encoding
-        chunk = Buffer.from(chunk, encoding).toString(state.encoding);
-      } else if (encoding !== state.encoding) {
-        chunk = Buffer.from(chunk, encoding);
-        encoding = '';
-      }
-    } else if (chunk instanceof Buffer) {
-      encoding = '';
-    } else if (Stream._isUint8Array(chunk)) {
-      chunk = Stream._uint8ArrayToBuffer(chunk);
-      encoding = '';
-    } else if (chunk != null) {
-      err = new ERR_INVALID_ARG_TYPE(
-        'chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
-    }
-  }
-
-  if (err) {
-    errorOrDestroy(stream, err);
-  } else if (chunk === null) {
-    state.reading = false;
-    onEofChunk(stream, state);
-  } else if (state.objectMode || (chunk && chunk.length > 0)) {
-    if (addToFront) {
-      if (state.endEmitted)
-        errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
-      else
-        addChunk(stream, state, chunk, true);
-    } else if (state.ended) {
-      errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
-    } else if (state.destroyed) {
-      return false;
-    } else {
-      state.reading = false;
-      if (state.decoder && !encoding) {
-        chunk = state.decoder.write(chunk);
-        if (state.objectMode || chunk.length !== 0)
-          addChunk(stream, state, chunk, false);
-        else
-          maybeReadMore(stream, state);
-      } else {
-        addChunk(stream, state, chunk, false);
-      }
-    }
-  } else if (!addToFront) {
-    state.reading = false;
-    maybeReadMore(stream, state);
-  }
-
-  // We can push more data if we are below the highWaterMark.
-  // Also, if we have no data yet, we can stand some more bytes.
-  // This is to work around cases where hwm=0, such as the repl.
-  return !state.ended &&
-    (state.length < state.highWaterMark || state.length === 0);
-}
-
-function addChunk(stream, state, chunk, addToFront) {
-  if (state.flowing && state.length === 0 && !state.sync &&
-      stream.listenerCount('data') > 0) {
-    // Use the guard to avoid creating `Set()` repeatedly
-    // when we have multiple pipes.
-    if (state.multiAwaitDrain) {
-      state.awaitDrainWriters.clear();
-    } else {
-      state.awaitDrainWriters = null;
-    }
-    stream.emit('data', chunk);
-  } else {
-    // Update the buffer info.
-    state.length += state.objectMode ? 1 : chunk.length;
-    if (addToFront)
-      state.buffer.unshift(chunk);
-    else
-      state.buffer.push(chunk);
-
-    if (state.needReadable)
-      emitReadable(stream);
-  }
-  maybeReadMore(stream, state);
-}
-
-Readable.prototype.isPaused = function() {
-  const state = this._readableState;
-  return state[kPaused] === true || state.flowing === false;
-};
-
-// Backwards compatibility.
-Readable.prototype.setEncoding = function(enc) {
-  if (!StringDecoder)
-    StringDecoder = require('string_decoder').StringDecoder;
-  const decoder = new StringDecoder(enc);
-  this._readableState.decoder = decoder;
-  // If setEncoding(null), decoder.encoding equals utf8
-  this._readableState.encoding = this._readableState.decoder.encoding;
-
-  const buffer = this._readableState.buffer;
-  // Iterate over current buffer to convert already stored Buffers:
-  let content = '';
-  for (const data of buffer) {
-    content += decoder.write(data);
-  }
-  buffer.clear();
-  if (content !== '')
-    buffer.push(content);
-  this._readableState.length = content.length;
-  return this;
-};
-
-// Don't raise the hwm > 1GB
-const MAX_HWM = 0x40000000;
-function computeNewHighWaterMark(n) {
-  if (n >= MAX_HWM) {
-    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
-    n = MAX_HWM;
-  } else {
-    // Get the next highest power of 2 to prevent increasing hwm excessively in
-    // tiny amounts
-    n--;
-    n |= n >>> 1;
-    n |= n >>> 2;
-    n |= n >>> 4;
-    n |= n >>> 8;
-    n |= n >>> 16;
-    n++;
-  }
-  return n;
-}
-
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function howMuchToRead(n, state) {
-  if (n <= 0 || (state.length === 0 && state.ended))
-    return 0;
-  if (state.objectMode)
-    return 1;
-  if (NumberIsNaN(n)) {
-    // Only flow one buffer at a time
-    if (state.flowing && state.length)
-      return state.buffer.first().length;
-    return state.length;
-  }
-  if (n <= state.length)
-    return n;
-  return state.ended ? state.length : 0;
-}
-
-// You can override either this method, or the async _read(n) below.
-Readable.prototype.read = function(n) {
-  debug('read', n);
-  // Same as parseInt(undefined, 10), however V8 7.3 performance regressed
-  // in this scenario, so we are doing it manually.
-  if (n === undefined) {
-    n = NaN;
-  } else if (!NumberIsInteger(n)) {
-    n = parseInt(n, 10);
-  }
-  const state = this._readableState;
-  const nOrig = n;
-
-  // If we're asking for more than the current hwm, then raise the hwm.
-  if (n > state.highWaterMark)
-    state.highWaterMark = computeNewHighWaterMark(n);
-
-  if (n !== 0)
-    state.emittedReadable = false;
-
-  // If we're doing read(0) to trigger a readable event, but we
-  // already have a bunch of data in the buffer, then just trigger
-  // the 'readable' event and move on.
-  if (n === 0 &&
-      state.needReadable &&
-      ((state.highWaterMark !== 0 ?
-        state.length >= state.highWaterMark :
-        state.length > 0) ||
-       state.ended)) {
-    debug('read: emitReadable', state.length, state.ended);
-    if (state.length === 0 && state.ended)
-      endReadable(this);
-    else
-      emitReadable(this);
-    return null;
-  }
-
-  n = howMuchToRead(n, state);
-
-  // If we've ended, and we're now clear, then finish it up.
-  if (n === 0 && state.ended) {
-    if (state.length === 0)
-      endReadable(this);
-    return null;
-  }
-
-  // All the actual chunk generation logic needs to be
-  // *below* the call to _read.  The reason is that in certain
-  // synthetic stream cases, such as passthrough streams, _read
-  // may be a completely synchronous operation which may change
-  // the state of the read buffer, providing enough data when
-  // before there was *not* enough.
-  //
-  // So, the steps are:
-  // 1. Figure out what the state of things will be after we do
-  // a read from the buffer.
-  //
-  // 2. If that resulting state will trigger a _read, then call _read.
-  // Note that this may be asynchronous, or synchronous.  Yes, it is
-  // deeply ugly to write APIs this way, but that still doesn't mean
-  // that the Readable class should behave improperly, as streams are
-  // designed to be sync/async agnostic.
-  // Take note if the _read call is sync or async (ie, if the read call
-  // has returned yet), so that we know whether or not it's safe to emit
-  // 'readable' etc.
-  //
-  // 3. Actually pull the requested chunks out of the buffer and return.
-
-  // if we need a readable event, then we need to do some reading.
-  var doRead = state.needReadable;
-  debug('need readable', doRead);
-
-  // If we currently have less than the highWaterMark, then also read some
-  if (state.length === 0 || state.length - n < state.highWaterMark) {
-    doRead = true;
-    debug('length less than watermark', doRead);
-  }
-
-  // However, if we've ended, then there's no point, if we're already
-  // reading, then it's unnecessary, and if we're destroyed, then it's
-  // not allowed.
-  if (state.ended || state.reading || state.destroyed) {
-    doRead = false;
-    debug('reading or ended', doRead);
-  } else if (doRead) {
-    debug('do read');
-    state.reading = true;
-    state.sync = true;
-    // If the length is currently zero, then we *need* a readable event.
-    if (state.length === 0)
-      state.needReadable = true;
-    // Call internal read method
-    this._read(state.highWaterMark);
-    state.sync = false;
-    // If _read pushed data synchronously, then `reading` will be false,
-    // and we need to re-evaluate how much data we can return to the user.
-    if (!state.reading)
-      n = howMuchToRead(nOrig, state);
-  }
-
-  var ret;
-  if (n > 0)
-    ret = fromList(n, state);
-  else
-    ret = null;
-
-  if (ret === null) {
-    state.needReadable = state.length <= state.highWaterMark;
-    n = 0;
-  } else {
-    state.length -= n;
-    if (state.multiAwaitDrain) {
-      state.awaitDrainWriters.clear();
-    } else {
-      state.awaitDrainWriters = null;
-    }
-  }
-
-  if (state.length === 0) {
-    // If we have nothing in the buffer, then we want to know
-    // as soon as we *do* get something into the buffer.
-    if (!state.ended)
-      state.needReadable = true;
-
-    // If we tried to read() past the EOF, then emit end on the next tick.
-    if (nOrig !== n && state.ended)
-      endReadable(this);
-  }
-
-  if (ret !== null)
-    this.emit('data', ret);
-
-  return ret;
-};
-
-function onEofChunk(stream, state) {
-  debug('onEofChunk');
-  if (state.ended) return;
-  if (state.decoder) {
-    var chunk = state.decoder.end();
-    if (chunk && chunk.length) {
-      state.buffer.push(chunk);
-      state.length += state.objectMode ? 1 : chunk.length;
-    }
-  }
-  state.ended = true;
-
-  if (state.sync) {
-    // If we are sync, wait until next tick to emit the data.
-    // Otherwise we risk emitting data in the flow()
-    // the readable code triggers during a read() call
-    emitReadable(stream);
-  } else {
-    // Emit 'readable' now to make sure it gets picked up.
-    state.needReadable = false;
-    state.emittedReadable = true;
-    // We have to emit readable now that we are EOF. Modules
-    // in the ecosystem (e.g. dicer) rely on this event being sync.
-    emitReadable_(stream);
-  }
-}
-
-// Don't emit readable right away in sync mode, because this can trigger
-// another read() call => stack overflow.  This way, it might trigger
-// a nextTick recursion warning, but that's not so bad.
-function emitReadable(stream) {
-  const state = stream._readableState;
-  debug('emitReadable', state.needReadable, state.emittedReadable);
-  state.needReadable = false;
-  if (!state.emittedReadable) {
-    debug('emitReadable', state.flowing);
-    state.emittedReadable = true;
-    process.nextTick(emitReadable_, stream);
-  }
-}
-
-function emitReadable_(stream) {
-  const state = stream._readableState;
-  debug('emitReadable_', state.destroyed, state.length, state.ended);
-  if (!state.destroyed && (state.length || state.ended)) {
-    stream.emit('readable');
-    state.emittedReadable = false;
-  }
-
-  // The stream needs another readable event if
-  // 1. It is not flowing, as the flow mechanism will take
-  //    care of it.
-  // 2. It is not ended.
-  // 3. It is below the highWaterMark, so we can schedule
-  //    another readable later.
-  state.needReadable =
-    !state.flowing &&
-    !state.ended &&
-    state.length <= state.highWaterMark;
-  flow(stream);
-}
-
-
-// At this point, the user has presumably seen the 'readable' event,
-// and called read() to consume some data.  that may have triggered
-// in turn another _read(n) call, in which case reading = true if
-// it's in progress.
-// However, if we're not ended, or reading, and the length < hwm,
-// then go ahead and try to read some more preemptively.
-function maybeReadMore(stream, state) {
-  if (!state.readingMore) {
-    state.readingMore = true;
-    process.nextTick(maybeReadMore_, stream, state);
-  }
-}
-
-function maybeReadMore_(stream, state) {
-  // Attempt to read more data if we should.
-  //
-  // The conditions for reading more data are (one of):
-  // - Not enough data buffered (state.length < state.highWaterMark). The loop
-  //   is responsible for filling the buffer with enough data if such data
-  //   is available. If highWaterMark is 0 and we are not in the flowing mode
-  //   we should _not_ attempt to buffer any extra data. We'll get more data
-  //   when the stream consumer calls read() instead.
-  // - No data in the buffer, and the stream is in flowing mode. In this mode
-  //   the loop below is responsible for ensuring read() is called. Failing to
-  //   call read here would abort the flow and there's no other mechanism for
-  //   continuing the flow if the stream consumer has just subscribed to the
-  //   'data' event.
-  //
-  // In addition to the above conditions to keep reading data, the following
-  // conditions prevent the data from being read:
-  // - The stream has ended (state.ended).
-  // - There is already a pending 'read' operation (state.reading). This is a
-  //   case where the the stream has called the implementation defined _read()
-  //   method, but they are processing the call asynchronously and have _not_
-  //   called push() with new data. In this case we skip performing more
-  //   read()s. The execution ends in this method again after the _read() ends
-  //   up calling push() with more data.
-  while (!state.reading && !state.ended &&
-         (state.length < state.highWaterMark ||
-          (state.flowing && state.length === 0))) {
-    const len = state.length;
-    debug('maybeReadMore read 0');
-    stream.read(0);
-    if (len === state.length)
-      // Didn't get any data, stop spinning.
-      break;
-  }
-  state.readingMore = false;
-}
-
-// Abstract method.  to be overridden in specific implementation classes.
-// call cb(er, data) where data is <= n in length.
-// for virtual (non-string, non-buffer) streams, "length" is somewhat
-// arbitrary, and perhaps not very meaningful.
-Readable.prototype._read = function(n) {
-  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
-};
-
-Readable.prototype.pipe = function(dest, pipeOpts) {
-  const src = this;
-  const state = this._readableState;
-
-  if (state.pipesCount === 1) {
-    if (!state.multiAwaitDrain) {
-      state.multiAwaitDrain = true;
-      state.awaitDrainWriters = new Set(
-        state.awaitDrainWriters ? [state.awaitDrainWriters] : []
-      );
-    }
-  }
-
-  switch (state.pipesCount) {
-    case 0:
-      state.pipes = dest;
-      break;
-    case 1:
-      state.pipes = [state.pipes, dest];
-      break;
-    default:
-      state.pipes.push(dest);
-      break;
-  }
-  state.pipesCount += 1;
-  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
-
-  const doEnd = (!pipeOpts || pipeOpts.end !== false) &&
-              dest !== process.stdout &&
-              dest !== process.stderr;
-
-  const endFn = doEnd ? onend : unpipe;
-  if (state.endEmitted)
-    process.nextTick(endFn);
-  else
-    src.once('end', endFn);
-
-  dest.on('unpipe', onunpipe);
-  function onunpipe(readable, unpipeInfo) {
-    debug('onunpipe');
-    if (readable === src) {
-      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
-        unpipeInfo.hasUnpiped = true;
-        cleanup();
-      }
-    }
-  }
-
-  function onend() {
-    debug('onend');
-    dest.end();
-  }
-
-  let ondrain;
-
-  var cleanedUp = false;
-  function cleanup() {
-    debug('cleanup');
-    // Cleanup event handlers once the pipe is broken
-    dest.removeListener('close', onclose);
-    dest.removeListener('finish', onfinish);
-    if (ondrain) {
-      dest.removeListener('drain', ondrain);
-    }
-    dest.removeListener('error', onerror);
-    dest.removeListener('unpipe', onunpipe);
-    src.removeListener('end', onend);
-    src.removeListener('end', unpipe);
-    src.removeListener('data', ondata);
-
-    cleanedUp = true;
-
-    // If the reader is waiting for a drain event from this
-    // specific writer, then it would cause it to never start
-    // flowing again.
-    // So, if this is awaiting a drain, then we just call it now.
-    // If we don't know, then assume that we are waiting for one.
-    if (ondrain && state.awaitDrainWriters &&
-        (!dest._writableState || dest._writableState.needDrain))
-      ondrain();
-  }
-
-  src.on('data', ondata);
-  function ondata(chunk) {
-    debug('ondata');
-    const ret = dest.write(chunk);
-    debug('dest.write', ret);
-    if (ret === false) {
-      // If the user unpiped during `dest.write()`, it is possible
-      // to get stuck in a permanently paused state if that write
-      // also returned false.
-      // => Check whether `dest` is still a piping destination.
-      if (!cleanedUp) {
-        if (state.pipesCount === 1 && state.pipes === dest) {
-          debug('false write response, pause', 0);
-          state.awaitDrainWriters = dest;
-          state.multiAwaitDrain = false;
-        } else if (state.pipesCount > 1 && state.pipes.includes(dest)) {
-          debug('false write response, pause', state.awaitDrainWriters.size);
-          state.awaitDrainWriters.add(dest);
-        }
-        src.pause();
-      }
-      if (!ondrain) {
-        // When the dest drains, it reduces the awaitDrain counter
-        // on the source.  This would be more elegant with a .once()
-        // handler in flow(), but adding and removing repeatedly is
-        // too slow.
-        ondrain = pipeOnDrain(src, dest);
-        dest.on('drain', ondrain);
-      }
-    }
-  }
-
-  // If the dest has an error, then stop piping into it.
-  // However, don't suppress the throwing behavior for this.
-  function onerror(er) {
-    debug('onerror', er);
-    unpipe();
-    dest.removeListener('error', onerror);
-    if (EE.listenerCount(dest, 'error') === 0)
-      errorOrDestroy(dest, er);
-  }
-
-  // Make sure our error handler is attached before userland ones.
-  prependListener(dest, 'error', onerror);
-
-  // Both close and finish should trigger unpipe, but only once.
-  function onclose() {
-    dest.removeListener('finish', onfinish);
-    unpipe();
-  }
-  dest.once('close', onclose);
-  function onfinish() {
-    debug('onfinish');
-    dest.removeListener('close', onclose);
-    unpipe();
-  }
-  dest.once('finish', onfinish);
-
-  function unpipe() {
-    debug('unpipe');
-    src.unpipe(dest);
-  }
-
-  // Tell the dest that it's being piped to
-  dest.emit('pipe', src);
-
-  // Start the flow if it hasn't been started already.
-  if (!state.flowing) {
-    debug('pipe resume');
-    src.resume();
-  }
-
-  return dest;
-};
-
-function pipeOnDrain(src, dest) {
-  return function pipeOnDrainFunctionResult() {
-    const state = src._readableState;
-
-    // `ondrain` will call directly,
-    // `this` maybe not a reference to dest,
-    // so we use the real dest here.
-    if (state.awaitDrainWriters === dest) {
-      debug('pipeOnDrain', 1);
-      state.awaitDrainWriters = null;
-    } else if (state.multiAwaitDrain) {
-      debug('pipeOnDrain', state.awaitDrainWriters.size);
-      state.awaitDrainWriters.delete(dest);
-    }
-
-    if ((!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) &&
-      EE.listenerCount(src, 'data')) {
-      state.flowing = true;
-      flow(src);
-    }
-  };
-}
-
-
-Readable.prototype.unpipe = function(dest) {
-  const state = this._readableState;
-  const unpipeInfo = { hasUnpiped: false };
-
-  // If we're not piping anywhere, then do nothing.
-  if (state.pipesCount === 0)
-    return this;
-
-  // Just one destination.  most common case.
-  if (state.pipesCount === 1) {
-    // Passed in one, but it's not the right one.
-    if (dest && dest !== state.pipes)
-      return this;
-
-    if (!dest)
-      dest = state.pipes;
-
-    // got a match.
-    state.pipes = null;
-    state.pipesCount = 0;
-    state.flowing = false;
-    if (dest)
-      dest.emit('unpipe', this, unpipeInfo);
-    return this;
-  }
-
-  // Slow case with multiple pipe destinations.
-
-  if (!dest) {
-    // remove all.
-    var dests = state.pipes;
-    var len = state.pipesCount;
-    state.pipes = null;
-    state.pipesCount = 0;
-    state.flowing = false;
-
-    for (var i = 0; i < len; i++)
-      dests[i].emit('unpipe', this, { hasUnpiped: false });
-    return this;
-  }
-
-  // Try to find the right one.
-  const index = state.pipes.indexOf(dest);
-  if (index === -1)
-    return this;
-
-  state.pipes.splice(index, 1);
-  state.pipesCount -= 1;
-  if (state.pipesCount === 1)
-    state.pipes = state.pipes[0];
-
-  dest.emit('unpipe', this, unpipeInfo);
-
-  return this;
-};
-
-// Set up data events if they are asked for
-// Ensure readable listeners eventually get something
-Readable.prototype.on = function(ev, fn) {
-  const res = Stream.prototype.on.call(this, ev, fn);
-  const state = this._readableState;
-
-  if (ev === 'data') {
-    // Update readableListening so that resume() may be a no-op
-    // a few lines down. This is needed to support once('readable').
-    state.readableListening = this.listenerCount('readable') > 0;
-
-    // Try start flowing on next tick if stream isn't explicitly paused
-    if (state.flowing !== false)
-      this.resume();
-  } else if (ev === 'readable') {
-    if (!state.endEmitted && !state.readableListening) {
-      state.readableListening = state.needReadable = true;
-      state.flowing = false;
-      state.emittedReadable = false;
-      debug('on readable', state.length, state.reading);
-      if (state.length) {
-        emitReadable(this);
-      } else if (!state.reading) {
-        process.nextTick(nReadingNextTick, this);
-      }
-    }
-  }
-
-  return res;
-};
-Readable.prototype.addListener = Readable.prototype.on;
-
-Readable.prototype.removeListener = function(ev, fn) {
-  const res = Stream.prototype.removeListener.call(this, ev, fn);
-
-  if (ev === 'readable') {
-    // We need to check if there is someone still listening to
-    // readable and reset the state. However this needs to happen
-    // after readable has been emitted but before I/O (nextTick) to
-    // support once('readable', fn) cycles. This means that calling
-    // resume within the same tick will have no
-    // effect.
-    process.nextTick(updateReadableListening, this);
-  }
-
-  return res;
-};
-Readable.prototype.off = Readable.prototype.removeListener;
-
-Readable.prototype.removeAllListeners = function(ev) {
-  const res = Stream.prototype.removeAllListeners.apply(this, arguments);
-
-  if (ev === 'readable' || ev === undefined) {
-    // We need to check if there is someone still listening to
-    // readable and reset the state. However this needs to happen
-    // after readable has been emitted but before I/O (nextTick) to
-    // support once('readable', fn) cycles. This means that calling
-    // resume within the same tick will have no
-    // effect.
-    process.nextTick(updateReadableListening, this);
-  }
-
-  return res;
-};
-
-function updateReadableListening(self) {
-  const state = self._readableState;
-  state.readableListening = self.listenerCount('readable') > 0;
-
-  if (state.resumeScheduled && state[kPaused] === false) {
-    // Flowing needs to be set to true now, otherwise
-    // the upcoming resume will not flow.
-    state.flowing = true;
-
-    // Crude way to check if we should resume
-  } else if (self.listenerCount('data') > 0) {
-    self.resume();
-  } else if (!state.readableListening) {
-    state.flowing = null;
-  }
-}
-
-function nReadingNextTick(self) {
-  debug('readable nexttick read 0');
-  self.read(0);
-}
-
-// pause() and resume() are remnants of the legacy readable stream API
-// If the user uses them, then switch into old mode.
-Readable.prototype.resume = function() {
-  const state = this._readableState;
-  if (!state.flowing) {
-    debug('resume');
-    // We flow only if there is no one listening
-    // for readable, but we still have to call
-    // resume()
-    state.flowing = !state.readableListening;
-    resume(this, state);
-  }
-  state[kPaused] = false;
-  return this;
-};
-
-function resume(stream, state) {
-  if (!state.resumeScheduled) {
-    state.resumeScheduled = true;
-    process.nextTick(resume_, stream, state);
-  }
-}
-
-function resume_(stream, state) {
-  debug('resume', state.reading);
-  if (!state.reading) {
-    stream.read(0);
-  }
-
-  state.resumeScheduled = false;
-  stream.emit('resume');
-  flow(stream);
-  if (state.flowing && !state.reading)
-    stream.read(0);
-}
-
-Readable.prototype.pause = function() {
-  debug('call pause flowing=%j', this._readableState.flowing);
-  if (this._readableState.flowing !== false) {
-    debug('pause');
-    this._readableState.flowing = false;
-    this.emit('pause');
-  }
-  this._readableState[kPaused] = true;
-  return this;
-};
-
-function flow(stream) {
-  const state = stream._readableState;
-  debug('flow', state.flowing);
-  while (state.flowing && stream.read() !== null);
-}
-
-// Wrap an old-style stream as the async data source.
-// This is *not* part of the readable stream interface.
-// It is an ugly unfortunate mess of history.
-Readable.prototype.wrap = function(stream) {
-  const state = this._readableState;
-  var paused = false;
-
-  stream.on('end', () => {
-    debug('wrapped end');
-    if (state.decoder && !state.ended) {
-      var chunk = state.decoder.end();
-      if (chunk && chunk.length)
-        this.push(chunk);
-    }
-
-    this.push(null);
-  });
-
-  stream.on('data', (chunk) => {
-    debug('wrapped data');
-    if (state.decoder)
-      chunk = state.decoder.write(chunk);
-
-    // Don't skip over falsy values in objectMode
-    if (state.objectMode && (chunk === null || chunk === undefined))
-      return;
-    else if (!state.objectMode && (!chunk || !chunk.length))
-      return;
-
-    const ret = this.push(chunk);
-    if (!ret) {
-      paused = true;
-      stream.pause();
-    }
-  });
-
-  // Proxy all the other methods. Important when wrapping filters and duplexes.
-  for (const i in stream) {
-    if (this[i] === undefined && typeof stream[i] === 'function') {
-      this[i] = function methodWrap(method) {
-        return function methodWrapReturnFunction() {
-          return stream[method].apply(stream, arguments);
-        };
-      }(i);
-    }
-  }
-
-  stream.on('error', (err) => {
-    errorOrDestroy(this, err);
-  });
-
-  stream.on('close', () => {
-    // TODO(ronag): Update readable state?
-    this.emit('close');
-  });
-
-  stream.on('destroy', () => {
-    // TODO(ronag): this.destroy()?
-    this.emit('destroy');
-  });
-
-  stream.on('pause', () => {
-    // TODO(ronag): this.pause()?
-    this.emit('pause');
-  });
-
-  stream.on('resume', () => {
-    // TODO(ronag): this.resume()?
-    this.emit('resume');
-  });
-
-  // When we try to consume some more bytes, simply unpause the
-  // underlying stream.
-  this._read = (n) => {
-    debug('wrapped _read', n);
-    if (paused) {
-      paused = false;
-      stream.resume();
-    }
-  };
-
-  return this;
-};
-
-Readable.prototype[SymbolAsyncIterator] = function() {
-  if (createReadableStreamAsyncIterator === undefined) {
-    createReadableStreamAsyncIterator =
-      require('internal/streams/async_iterator');
-  }
-  return createReadableStreamAsyncIterator(this);
-};
-
-// Making it explicit these properties are not enumerable
-// because otherwise some prototype manipulation in
-// userland will fail
-ObjectDefineProperties(Readable.prototype, {
-
-  readableHighWaterMark: {
-    enumerable: false,
-    get: function() {
-      return this._readableState.highWaterMark;
-    }
-  },
-
-  readableBuffer: {
-    enumerable: false,
-    get: function() {
-      return this._readableState && this._readableState.buffer;
-    }
-  },
-
-  readableFlowing: {
-    enumerable: false,
-    get: function() {
-      return this._readableState.flowing;
-    },
-    set: function(state) {
-      if (this._readableState) {
-        this._readableState.flowing = state;
-      }
-    }
-  },
-
-  readableLength: {
-    enumerable: false,
-    get() {
-      return this._readableState.length;
-    }
-  },
-
-  readableObjectMode: {
-    enumerable: false,
-    get() {
-      return this._readableState ? this._readableState.objectMode : false;
-    }
-  },
-
-  readableEncoding: {
-    enumerable: false,
-    get() {
-      return this._readableState ? this._readableState.encoding : null;
-    }
-  },
-
-  destroyed: {
-    enumerable: false,
-    get() {
-      if (this._readableState === undefined) {
-        return false;
-      }
-      return this._readableState.destroyed;
-    },
-    set(value) {
-      // We ignore the value if the stream
-      // has not been initialized yet
-      if (!this._readableState) {
-        return;
-      }
-
-      // Backward compatibility, the user is explicitly
-      // managing destroyed
-      this._readableState.destroyed = value;
-    }
-  },
-
-  readableEnded: {
-    enumerable: false,
-    get() {
-      return this._readableState ? this._readableState.endEmitted : false;
-    }
-  },
-
-  paused: {
-    get() {
-      return this[kPaused] !== false;
-    },
-    set(value) {
-      this[kPaused] = !!value;
-    }
-  }
-});
-
-// Exposed for testing purposes only.
-Readable._fromList = fromList;
-
-// Pluck off n bytes from an array of buffers.
-// Length is the combined lengths of all the buffers in the list.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function fromList(n, state) {
-  // nothing buffered
-  if (state.length === 0)
-    return null;
-
-  var ret;
-  if (state.objectMode)
-    ret = state.buffer.shift();
-  else if (!n || n >= state.length) {
-    // Read it all, truncate the list
-    if (state.decoder)
-      ret = state.buffer.join('');
-    else if (state.buffer.length === 1)
-      ret = state.buffer.first();
-    else
-      ret = state.buffer.concat(state.length);
-    state.buffer.clear();
-  } else {
-    // read part of list
-    ret = state.buffer.consume(n, state.decoder);
-  }
-
-  return ret;
-}
-
-function endReadable(stream) {
-  const state = stream._readableState;
-
-  debug('endReadable', state.endEmitted);
-  if (!state.endEmitted) {
-    state.ended = true;
-    process.nextTick(endReadableNT, state, stream);
-  }
-}
-
-function endReadableNT(state, stream) {
-  debug('endReadableNT', state.endEmitted, state.length);
-
-  // Check that we didn't get one last unshift.
-  if (!state.endEmitted && state.length === 0) {
-    state.endEmitted = true;
-    stream.readable = false;
-    stream.emit('end');
-
-    if (state.autoDestroy) {
-      // In case of duplex streams we need a way to detect
-      // if the writable side is ready for autoDestroy as well
-      const wState = stream._writableState;
-      if (!wState || (wState.autoDestroy && wState.finished)) {
-        stream.destroy();
-      }
-    }
-  }
-}
-
-Readable.from = function(iterable, opts) {
-  if (from === undefined) {
-    from = require('internal/streams/from');
-  }
-  return from(Readable, iterable, opts);
-};
diff --git a/lib/_stream_transform.js b/lib/_stream_transform.js
index cb4aae2e6d18f4fe918fa35b74c99333a84b240d..50150638d9db8c33c0493c1add005a5ad133c64f 100644
--- a/lib/_stream_transform.js
+++ b/lib/_stream_transform.js
@@ -1,221 +1,6 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a transform stream is a readable/writable stream where you do
-// something with the data.  Sometimes it's called a "filter",
-// but that's not a great name for it, since that implies a thing where
-// some bits pass through, and others are simply ignored.  (That would
-// be a valid example of a transform, of course.)
-//
-// While the output is causally related to the input, it's not a
-// necessarily symmetric or synchronous transformation.  For example,
-// a zlib stream might take multiple plain-text writes(), and then
-// emit a single compressed chunk some time in the future.
-//
-// Here's how this works:
-//
-// The Transform stream has all the aspects of the readable and writable
-// stream classes.  When you write(chunk), that calls _write(chunk,cb)
-// internally, and returns false if there's a lot of pending writes
-// buffered up.  When you call read(), that calls _read(n) until
-// there's enough pending readable data buffered up.
-//
-// In a transform stream, the written data is placed in a buffer.  When
-// _read(n) is called, it transforms the queued up data, calling the
-// buffered _write cb's as it consumes chunks.  If consuming a single
-// written chunk would result in multiple output chunks, then the first
-// outputted bit calls the readcb, and subsequent chunks just go into
-// the read buffer, and will cause it to emit 'readable' if necessary.
-//
-// This way, back-pressure is actually determined by the reading side,
-// since _read has to be called to start processing a new chunk.  However,
-// a pathological inflate type of transform can cause excessive buffering
-// here.  For example, imagine a stream where every byte of input is
-// interpreted as an integer from 0-255, and then results in that many
-// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
-// 1kb of data being output.  In this case, you could write a very small
-// amount of input, and end up with a very large amount of output.  In
-// such a pathological inflating mechanism, there'd be no way to tell
-// the system to stop doing the transform.  A single 4MB write could
-// cause the system to run out of memory.
-//
-// However, even in such a pathological case, only a single written chunk
-// would be consumed, and then the rest would wait (un-transformed) until
-// the results of the previous transformed chunk were consumed.
-
 'use strict';
 
-const {
-  ObjectSetPrototypeOf,
-} = primordials;
+// TODO(mcollina): deprecate this file
 
+const Transform = require('internal/streams/transform');
 module.exports = Transform;
-const {
-  ERR_METHOD_NOT_IMPLEMENTED,
-  ERR_MULTIPLE_CALLBACK,
-  ERR_TRANSFORM_ALREADY_TRANSFORMING,
-  ERR_TRANSFORM_WITH_LENGTH_0
-} = require('internal/errors').codes;
-const Duplex = require('_stream_duplex');
-ObjectSetPrototypeOf(Transform.prototype, Duplex.prototype);
-ObjectSetPrototypeOf(Transform, Duplex);
-
-
-function afterTransform(er, data) {
-  const ts = this._transformState;
-  ts.transforming = false;
-
-  const cb = ts.writecb;
-
-  if (cb === null) {
-    return this.emit('error', new ERR_MULTIPLE_CALLBACK());
-  }
-
-  ts.writechunk = null;
-  ts.writecb = null;
-
-  if (data != null) // Single equals check for both `null` and `undefined`
-    this.push(data);
-
-  cb(er);
-
-  const rs = this._readableState;
-  rs.reading = false;
-  if (rs.needReadable || rs.length < rs.highWaterMark) {
-    this._read(rs.highWaterMark);
-  }
-}
-
-
-function Transform(options) {
-  if (!(this instanceof Transform))
-    return new Transform(options);
-
-  Duplex.call(this, options);
-
-  this._transformState = {
-    afterTransform: afterTransform.bind(this),
-    needTransform: false,
-    transforming: false,
-    writecb: null,
-    writechunk: null,
-    writeencoding: null
-  };
-
-  // We have implemented the _read method, and done the other things
-  // that Readable wants before the first _read call, so unset the
-  // sync guard flag.
-  this._readableState.sync = false;
-
-  if (options) {
-    if (typeof options.transform === 'function')
-      this._transform = options.transform;
-
-    if (typeof options.flush === 'function')
-      this._flush = options.flush;
-  }
-
-  // When the writable side finishes, then flush out anything remaining.
-  this.on('prefinish', prefinish);
-}
-
-function prefinish() {
-  if (typeof this._flush === 'function' && !this._readableState.destroyed) {
-    this._flush((er, data) => {
-      done(this, er, data);
-    });
-  } else {
-    done(this, null, null);
-  }
-}
-
-Transform.prototype.push = function(chunk, encoding) {
-  this._transformState.needTransform = false;
-  return Duplex.prototype.push.call(this, chunk, encoding);
-};
-
-// This is the part where you do stuff!
-// override this function in implementation classes.
-// 'chunk' is an input chunk.
-//
-// Call `push(newChunk)` to pass along transformed output
-// to the readable side.  You may call 'push' zero or more times.
-//
-// Call `cb(err)` when you are done with this chunk.  If you pass
-// an error, then that'll put the hurt on the whole operation.  If you
-// never call cb(), then you'll never get another chunk.
-Transform.prototype._transform = function(chunk, encoding, cb) {
-  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
-};
-
-Transform.prototype._write = function(chunk, encoding, cb) {
-  const ts = this._transformState;
-  ts.writecb = cb;
-  ts.writechunk = chunk;
-  ts.writeencoding = encoding;
-  if (!ts.transforming) {
-    var rs = this._readableState;
-    if (ts.needTransform ||
-        rs.needReadable ||
-        rs.length < rs.highWaterMark)
-      this._read(rs.highWaterMark);
-  }
-};
-
-// Doesn't matter what the args are here.
-// _transform does all the work.
-// That we got here means that the readable side wants more data.
-Transform.prototype._read = function(n) {
-  const ts = this._transformState;
-
-  if (ts.writechunk !== null && !ts.transforming) {
-    ts.transforming = true;
-    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
-  } else {
-    // Mark that we need a transform, so that any data that comes in
-    // will get processed, now that we've asked for it.
-    ts.needTransform = true;
-  }
-};
-
-
-Transform.prototype._destroy = function(err, cb) {
-  Duplex.prototype._destroy.call(this, err, (err2) => {
-    cb(err2);
-  });
-};
-
-
-function done(stream, er, data) {
-  if (er)
-    return stream.emit('error', er);
-
-  if (data != null) // Single equals check for both `null` and `undefined`
-    stream.push(data);
-
-  // These two error cases are coherence checks that can likely not be tested.
-  if (stream._writableState.length)
-    throw new ERR_TRANSFORM_WITH_LENGTH_0();
-
-  if (stream._transformState.transforming)
-    throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
-  return stream.push(null);
-}
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index 6f5758bef08343558946c16bf88c7a65cf1955d3..e328a9434c85a984dced41e0e7a13ecb601d5bd9 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -1,746 +1,6 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// A bit simpler than readable streams.
-// Implement an async ._write(chunk, encoding, cb), and it'll handle all
-// the drain event emission and buffering.
-
 'use strict';
 
-const {
-  Array,
-  FunctionPrototype,
-  ObjectDefineProperty,
-  ObjectDefineProperties,
-  ObjectSetPrototypeOf,
-  Symbol,
-  SymbolHasInstance,
-} = primordials;
+// TODO(mcollina): deprecate this file
 
+const Writable = require('internal/streams/writable');
 module.exports = Writable;
-Writable.WritableState = WritableState;
-
-const internalUtil = require('internal/util');
-const EE = require('events');
-const Stream = require('stream');
-const { Buffer } = require('buffer');
-const destroyImpl = require('internal/streams/destroy');
-const {
-  getHighWaterMark,
-  getDefaultHighWaterMark
-} = require('internal/streams/state');
-const {
-  ERR_INVALID_ARG_TYPE,
-  ERR_METHOD_NOT_IMPLEMENTED,
-  ERR_MULTIPLE_CALLBACK,
-  ERR_STREAM_CANNOT_PIPE,
-  ERR_STREAM_DESTROYED,
-  ERR_STREAM_NULL_VALUES,
-  ERR_STREAM_WRITE_AFTER_END,
-  ERR_UNKNOWN_ENCODING
-} = require('internal/errors').codes;
-
-const { errorOrDestroy } = destroyImpl;
-
-ObjectSetPrototypeOf(Writable.prototype, Stream.prototype);
-ObjectSetPrototypeOf(Writable, Stream);
-
-function nop() {}
-
-function WritableState(options, stream, isDuplex) {
-  // Duplex streams are both readable and writable, but share
-  // the same options object.
-  // However, some cases require setting options to different
-  // values for the readable and the writable sides of the duplex stream,
-  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
-  if (typeof isDuplex !== 'boolean')
-    isDuplex = stream instanceof Stream.Duplex;
-
-  // Object stream flag to indicate whether or not this stream
-  // contains buffers or objects.
-  this.objectMode = !!(options && options.objectMode);
-
-  if (isDuplex)
-    this.objectMode = this.objectMode ||
-      !!(options && options.writableObjectMode);
-
-  // The point at which write() starts returning false
-  // Note: 0 is a valid value, means that we always return false if
-  // the entire buffer is not flushed immediately on write()
-  this.highWaterMark = options ?
-    getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex) :
-    getDefaultHighWaterMark(false);
-
-  // if _final has been called
-  this.finalCalled = false;
-
-  // drain event flag.
-  this.needDrain = false;
-  // At the start of calling end()
-  this.ending = false;
-  // When end() has been called, and returned
-  this.ended = false;
-  // When 'finish' is emitted
-  this.finished = false;
-
-  // Has it been destroyed
-  this.destroyed = false;
-
-  // Should we decode strings into buffers before passing to _write?
-  // this is here so that some node-core streams can optimize string
-  // handling at a lower level.
-  const noDecode = !!(options && options.decodeStrings === false);
-  this.decodeStrings = !noDecode;
-
-  // Crypto is kind of old and crusty.  Historically, its default string
-  // encoding is 'binary' so we have to make this configurable.
-  // Everything else in the universe uses 'utf8', though.
-  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8';
-
-  // Not an actual buffer we keep track of, but a measurement
-  // of how much we're waiting to get pushed to some underlying
-  // socket or file.
-  this.length = 0;
-
-  // A flag to see when we're in the middle of a write.
-  this.writing = false;
-
-  // When true all writes will be buffered until .uncork() call
-  this.corked = 0;
-
-  // A flag to be able to tell if the onwrite cb is called immediately,
-  // or on a later tick.  We set this to true at first, because any
-  // actions that shouldn't happen until "later" should generally also
-  // not happen before the first write call.
-  this.sync = true;
-
-  // A flag to know if we're processing previously buffered items, which
-  // may call the _write() callback in the same tick, so that we don't
-  // end up in an overlapped onwrite situation.
-  this.bufferProcessing = false;
-
-  // The callback that's passed to _write(chunk,cb)
-  this.onwrite = onwrite.bind(undefined, stream);
-
-  // The callback that the user supplies to write(chunk,encoding,cb)
-  this.writecb = null;
-
-  // The amount that is being written when _write is called.
-  this.writelen = 0;
-
-  // Storage for data passed to the afterWrite() callback in case of
-  // synchronous _write() completion.
-  this.afterWriteTickInfo = null;
-
-  this.bufferedRequest = null;
-  this.lastBufferedRequest = null;
-
-  // Number of pending user-supplied write callbacks
-  // this must be 0 before 'finish' can be emitted
-  this.pendingcb = 0;
-
-  // Emit prefinish if the only thing we're waiting for is _write cbs
-  // This is relevant for synchronous Transform streams
-  this.prefinished = false;
-
-  // True if the error was already emitted and should not be thrown again
-  this.errorEmitted = false;
-
-  // Should close be emitted on destroy. Defaults to true.
-  this.emitClose = !options || options.emitClose !== false;
-
-  // Should .destroy() be called after 'finish' (and potentially 'end')
-  this.autoDestroy = !!(options && options.autoDestroy);
-
-  // Count buffered requests
-  this.bufferedRequestCount = 0;
-
-  // Allocate the first CorkedRequest, there is always
-  // one allocated and free to use, and we maintain at most two
-  const corkReq = { next: null, entry: null, finish: undefined };
-  corkReq.finish = onCorkedFinish.bind(undefined, corkReq, this);
-  this.corkedRequestsFree = corkReq;
-}
-
-WritableState.prototype.getBuffer = function getBuffer() {
-  var current = this.bufferedRequest;
-  const out = [];
-  while (current) {
-    out.push(current);
-    current = current.next;
-  }
-  return out;
-};
-
-ObjectDefineProperty(WritableState.prototype, 'buffer', {
-  get: internalUtil.deprecate(function writableStateBufferGetter() {
-    return this.getBuffer();
-  }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' +
-     'instead.', 'DEP0003')
-});
-
-// Test _writableState for inheritance to account for Duplex streams,
-// whose prototype chain only points to Readable.
-var realHasInstance;
-if (typeof Symbol === 'function' && SymbolHasInstance) {
-  realHasInstance = FunctionPrototype[SymbolHasInstance];
-  ObjectDefineProperty(Writable, SymbolHasInstance, {
-    value: function(object) {
-      if (realHasInstance.call(this, object))
-        return true;
-      if (this !== Writable)
-        return false;
-
-      return object && object._writableState instanceof WritableState;
-    }
-  });
-} else {
-  realHasInstance = function(object) {
-    return object instanceof this;
-  };
-}
-
-function Writable(options) {
-  // Writable ctor is applied to Duplexes, too.
-  // `realHasInstance` is necessary because using plain `instanceof`
-  // would return false, as no `_writableState` property is attached.
-
-  // Trying to use the custom `instanceof` for Writable here will also break the
-  // Node.js LazyTransform implementation, which has a non-trivial getter for
-  // `_writableState` that would lead to infinite recursion.
-
-  // Checking for a Stream.Duplex instance is faster here instead of inside
-  // the WritableState constructor, at least with V8 6.5
-  const isDuplex = (this instanceof Stream.Duplex);
-
-  if (!isDuplex && !realHasInstance.call(Writable, this))
-    return new Writable(options);
-
-  this._writableState = new WritableState(options, this, isDuplex);
-
-  // legacy.
-  this.writable = true;
-
-  if (options) {
-    if (typeof options.write === 'function')
-      this._write = options.write;
-
-    if (typeof options.writev === 'function')
-      this._writev = options.writev;
-
-    if (typeof options.destroy === 'function')
-      this._destroy = options.destroy;
-
-    if (typeof options.final === 'function')
-      this._final = options.final;
-  }
-
-  Stream.call(this, options);
-}
-
-// Otherwise people can pipe Writable streams, which is just wrong.
-Writable.prototype.pipe = function() {
-  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
-};
-
-
-function writeAfterEnd(stream, cb) {
-  const er = new ERR_STREAM_WRITE_AFTER_END();
-  // TODO: defer error events consistently everywhere, not just the cb
-  errorOrDestroy(stream, er);
-  process.nextTick(cb, er);
-}
-
-// Checks that a user-supplied chunk is valid, especially for the particular
-// mode the stream is in. Currently this means that `null` is never accepted
-// and undefined/non-string values are only allowed in object mode.
-function validChunk(stream, state, chunk, cb) {
-  var er;
-
-  if (chunk === null) {
-    er = new ERR_STREAM_NULL_VALUES();
-  } else if (typeof chunk !== 'string' && !state.objectMode) {
-    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
-  }
-  if (er) {
-    errorOrDestroy(stream, er);
-    process.nextTick(cb, er);
-    return false;
-  }
-  return true;
-}
-
-Writable.prototype.write = function(chunk, encoding, cb) {
-  const state = this._writableState;
-  var ret = false;
-  const isBuf = !state.objectMode && Stream._isUint8Array(chunk);
-
-  // Do not use Object.getPrototypeOf as it is slower since V8 7.3.
-  if (isBuf && !(chunk instanceof Buffer)) {
-    chunk = Stream._uint8ArrayToBuffer(chunk);
-  }
-
-  if (typeof encoding === 'function') {
-    cb = encoding;
-    encoding = null;
-  }
-
-  if (isBuf)
-    encoding = 'buffer';
-  else if (!encoding)
-    encoding = state.defaultEncoding;
-
-  if (typeof cb !== 'function')
-    cb = nop;
-
-  if (state.ending)
-    writeAfterEnd(this, cb);
-  else if (isBuf || validChunk(this, state, chunk, cb)) {
-    state.pendingcb++;
-    ret = writeOrBuffer(this, state, chunk, encoding, cb);
-  }
-
-  return ret;
-};
-
-Writable.prototype.cork = function() {
-  this._writableState.corked++;
-};
-
-Writable.prototype.uncork = function() {
-  const state = this._writableState;
-
-  if (state.corked) {
-    state.corked--;
-
-    if (!state.writing &&
-        !state.corked &&
-        !state.bufferProcessing &&
-        state.bufferedRequest)
-      clearBuffer(this, state);
-  }
-};
-
-Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
-  // node::ParseEncoding() requires lower case.
-  if (typeof encoding === 'string')
-    encoding = encoding.toLowerCase();
-  if (!Buffer.isEncoding(encoding))
-    throw new ERR_UNKNOWN_ENCODING(encoding);
-  this._writableState.defaultEncoding = encoding;
-  return this;
-};
-
-// If we're already writing something, then just put this
-// in the queue, and wait our turn.  Otherwise, call _write
-// If we return false, then we need a drain event, so set that flag.
-function writeOrBuffer(stream, state, chunk, encoding, cb) {
-  if (!state.objectMode &&
-      state.decodeStrings !== false &&
-      encoding !== 'buffer' &&
-      typeof chunk === 'string') {
-    chunk = Buffer.from(chunk, encoding);
-    encoding = 'buffer';
-  }
-  const len = state.objectMode ? 1 : chunk.length;
-
-  state.length += len;
-
-  const ret = state.length < state.highWaterMark;
-  // We must ensure that previous needDrain will not be reset to false.
-  if (!ret)
-    state.needDrain = true;
-
-  if (state.writing || state.corked) {
-    var last = state.lastBufferedRequest;
-    state.lastBufferedRequest = {
-      chunk,
-      encoding,
-      callback: cb,
-      next: null
-    };
-    if (last) {
-      last.next = state.lastBufferedRequest;
-    } else {
-      state.bufferedRequest = state.lastBufferedRequest;
-    }
-    state.bufferedRequestCount += 1;
-  } else {
-    doWrite(stream, state, false, len, chunk, encoding, cb);
-  }
-
-  return ret;
-}
-
-function doWrite(stream, state, writev, len, chunk, encoding, cb) {
-  state.writelen = len;
-  state.writecb = cb;
-  state.writing = true;
-  state.sync = true;
-  if (state.destroyed)
-    state.onwrite(new ERR_STREAM_DESTROYED('write'));
-  else if (writev)
-    stream._writev(chunk, state.onwrite);
-  else
-    stream._write(chunk, encoding, state.onwrite);
-  state.sync = false;
-}
-
-function onwriteError(stream, state, sync, er, cb) {
-  --state.pendingcb;
-
-  if (sync) {
-    // Defer the callback if we are being called synchronously
-    // to avoid piling up things on the stack
-    process.nextTick(cb, er);
-    // This can emit finish, and it will always happen
-    // after error
-    process.nextTick(finishMaybe, stream, state);
-    stream._writableState.errorEmitted = true;
-    errorOrDestroy(stream, er);
-  } else {
-    // The caller expect this to happen before if
-    // it is async
-    cb(er);
-    stream._writableState.errorEmitted = true;
-    errorOrDestroy(stream, er);
-    // This can emit finish, but finish must
-    // always follow error
-    finishMaybe(stream, state);
-  }
-}
-
-function onwrite(stream, er) {
-  const state = stream._writableState;
-  const sync = state.sync;
-  const cb = state.writecb;
-
-  if (typeof cb !== 'function')
-    throw new ERR_MULTIPLE_CALLBACK();
-
-  state.writing = false;
-  state.writecb = null;
-  state.length -= state.writelen;
-  state.writelen = 0;
-
-  if (er)
-    onwriteError(stream, state, sync, er, cb);
-  else {
-    // Check if we're actually ready to finish, but don't emit yet
-    var finished = needFinish(state) || stream.destroyed;
-
-    if (!finished &&
-        !state.corked &&
-        !state.bufferProcessing &&
-        state.bufferedRequest) {
-      clearBuffer(stream, state);
-    }
-
-    if (sync) {
-      // It is a common case that the callback passed to .write() is always
-      // the same. In that case, we do not schedule a new nextTick(), but rather
-      // just increase a counter, to improve performance and avoid memory
-      // allocations.
-      if (state.afterWriteTickInfo !== null &&
-          state.afterWriteTickInfo.cb === cb) {
-        state.afterWriteTickInfo.count++;
-      } else {
-        state.afterWriteTickInfo = { count: 1, cb, stream, state };
-        process.nextTick(afterWriteTick, state.afterWriteTickInfo);
-      }
-    } else {
-      afterWrite(stream, state, 1, cb);
-    }
-  }
-}
-
-function afterWriteTick({ stream, state, count, cb }) {
-  state.afterWriteTickInfo = null;
-  return afterWrite(stream, state, count, cb);
-}
-
-function afterWrite(stream, state, count, cb) {
-  const needDrain = !state.ending && !stream.destroyed && state.length === 0 &&
-    state.needDrain;
-  if (needDrain) {
-    state.needDrain = false;
-    stream.emit('drain');
-  }
-
-  while (count-- > 0) {
-    state.pendingcb--;
-    cb();
-  }
-
-  finishMaybe(stream, state);
-}
-
-// If there's something in the buffer waiting, then process it
-function clearBuffer(stream, state) {
-  state.bufferProcessing = true;
-  var entry = state.bufferedRequest;
-
-  if (stream._writev && entry && entry.next) {
-    // Fast case, write everything using _writev()
-    var l = state.bufferedRequestCount;
-    var buffer = new Array(l);
-    var holder = state.corkedRequestsFree;
-    holder.entry = entry;
-
-    var count = 0;
-    var allBuffers = true;
-    while (entry) {
-      buffer[count] = entry;
-      if (entry.encoding !== 'buffer')
-        allBuffers = false;
-      entry = entry.next;
-      count += 1;
-    }
-    buffer.allBuffers = allBuffers;
-
-    doWrite(stream, state, true, state.length, buffer, '', holder.finish);
-
-    // doWrite is almost always async, defer these to save a bit of time
-    // as the hot path ends with doWrite
-    state.pendingcb++;
-    state.lastBufferedRequest = null;
-    if (holder.next) {
-      state.corkedRequestsFree = holder.next;
-      holder.next = null;
-    } else {
-      var corkReq = { next: null, entry: null, finish: undefined };
-      corkReq.finish = onCorkedFinish.bind(undefined, corkReq, state);
-      state.corkedRequestsFree = corkReq;
-    }
-    state.bufferedRequestCount = 0;
-  } else {
-    // Slow case, write chunks one-by-one
-    while (entry) {
-      var chunk = entry.chunk;
-      var encoding = entry.encoding;
-      var cb = entry.callback;
-      var len = state.objectMode ? 1 : chunk.length;
-
-      doWrite(stream, state, false, len, chunk, encoding, cb);
-      entry = entry.next;
-      state.bufferedRequestCount--;
-      // If we didn't call the onwrite immediately, then
-      // it means that we need to wait until it does.
-      // also, that means that the chunk and cb are currently
-      // being processed, so move the buffer counter past them.
-      if (state.writing) {
-        break;
-      }
-    }
-
-    if (entry === null)
-      state.lastBufferedRequest = null;
-  }
-
-  state.bufferedRequest = entry;
-  state.bufferProcessing = false;
-}
-
-Writable.prototype._write = function(chunk, encoding, cb) {
-  if (this._writev) {
-    this._writev([{ chunk, encoding }], cb);
-  } else {
-    cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
-  }
-};
-
-Writable.prototype._writev = null;
-
-Writable.prototype.end = function(chunk, encoding, cb) {
-  const state = this._writableState;
-
-  if (typeof chunk === 'function') {
-    cb = chunk;
-    chunk = null;
-    encoding = null;
-  } else if (typeof encoding === 'function') {
-    cb = encoding;
-    encoding = null;
-  }
-
-  if (chunk !== null && chunk !== undefined)
-    this.write(chunk, encoding);
-
-  // .end() fully uncorks
-  if (state.corked) {
-    state.corked = 1;
-    this.uncork();
-  }
-
-  // Ignore unnecessary end() calls.
-  if (!state.ending)
-    endWritable(this, state, cb);
-
-  return this;
-};
-
-function needFinish(state) {
-  return (state.ending &&
-          state.length === 0 &&
-          state.bufferedRequest === null &&
-          !state.finished &&
-          !state.writing);
-}
-
-function callFinal(stream, state) {
-  stream._final((err) => {
-    state.pendingcb--;
-    if (err) {
-      errorOrDestroy(stream, err);
-    }
-    state.prefinished = true;
-    stream.emit('prefinish');
-    finishMaybe(stream, state);
-  });
-}
-
-function prefinish(stream, state) {
-  if (!state.prefinished && !state.finalCalled) {
-    if (typeof stream._final === 'function' && !state.destroyed) {
-      state.pendingcb++;
-      state.finalCalled = true;
-      process.nextTick(callFinal, stream, state);
-    } else {
-      state.prefinished = true;
-      stream.emit('prefinish');
-    }
-  }
-}
-
-function finishMaybe(stream, state) {
-  const need = needFinish(state);
-  if (need) {
-    prefinish(stream, state);
-    if (state.pendingcb === 0) {
-      state.finished = true;
-      stream.emit('finish');
-
-      if (state.autoDestroy) {
-        // In case of duplex streams we need a way to detect
-        // if the readable side is ready for autoDestroy as well
-        const rState = stream._readableState;
-        if (!rState || (rState.autoDestroy && rState.endEmitted)) {
-          stream.destroy();
-        }
-      }
-    }
-  }
-  return need;
-}
-
-function endWritable(stream, state, cb) {
-  state.ending = true;
-  finishMaybe(stream, state);
-  if (cb) {
-    if (state.finished)
-      process.nextTick(cb);
-    else
-      stream.once('finish', cb);
-  }
-  state.ended = true;
-  stream.writable = false;
-}
-
-function onCorkedFinish(corkReq, state, err) {
-  var entry = corkReq.entry;
-  corkReq.entry = null;
-  while (entry) {
-    var cb = entry.callback;
-    state.pendingcb--;
-    cb(err);
-    entry = entry.next;
-  }
-
-  // Reuse the free corkReq.
-  state.corkedRequestsFree.next = corkReq;
-}
-
-ObjectDefineProperties(Writable.prototype, {
-
-  destroyed: {
-    get() {
-      return this._writableState ? this._writableState.destroyed : false;
-    },
-    set(value) {
-      // Backward compatibility, the user is explicitly managing destroyed
-      if (this._writableState) {
-        this._writableState.destroyed = value;
-      }
-    }
-  },
-
-  writableFinished: {
-    get() {
-      return this._writableState ? this._writableState.finished : false;
-    }
-  },
-
-  writableObjectMode: {
-    get() {
-      return this._writableState ? this._writableState.objectMode : false;
-    }
-  },
-
-  writableBuffer: {
-    get() {
-      return this._writableState && this._writableState.getBuffer();
-    }
-  },
-
-  writableEnded: {
-    get() {
-      return this._writableState ? this._writableState.ending : false;
-    }
-  },
-
-  writableHighWaterMark: {
-    get() {
-      return this._writableState && this._writableState.highWaterMark;
-    }
-  },
-
-  writableCorked: {
-    get() {
-      return this._writableState ? this._writableState.corked : 0;
-    }
-  },
-
-  writableLength: {
-    get() {
-      return this._writableState && this._writableState.length;
-    }
-  }
-});
-
-Writable.prototype.destroy = destroyImpl.destroy;
-Writable.prototype._undestroy = destroyImpl.undestroy;
-Writable.prototype._destroy = function(err, cb) {
-  cb(err);
-};
-
-Writable.prototype[EE.captureRejectionSymbol] = function(err) {
-  this.destroy(err);
-};
diff --git a/lib/_tls_common.js b/lib/_tls_common.js
index b7a3b70a24047957ef7004598dbb02752df0cee3..75da23894688906d5720fcdfe2b8da83e6049b5d 100644
--- a/lib/_tls_common.js
+++ b/lib/_tls_common.js
@@ -23,6 +23,7 @@
 
 const {
   ArrayIsArray,
+  JSONParse,
   ObjectCreate,
 } = primordials;
 
@@ -312,17 +313,27 @@ exports.translatePeerCertificate = function translatePeerCertificate(c) {
   if (!c)
     return null;
 
-  if (c.issuer != null) c.issuer = parseCertString(c.issuer);
+  // TODO(tniessen): can we remove parseCertString without breaking anything?
+  if (typeof c.issuer === 'string') c.issuer = parseCertString(c.issuer);
   if (c.issuerCertificate != null && c.issuerCertificate !== c) {
     c.issuerCertificate = translatePeerCertificate(c.issuerCertificate);
   }
-  if (c.subject != null) c.subject = parseCertString(c.subject);
+  // TODO(tniessen): can we remove parseCertString without breaking anything?
+  if (typeof c.subject === 'string') c.subject = parseCertString(c.subject);
   if (c.infoAccess != null) {
     const info = c.infoAccess;
     c.infoAccess = ObjectCreate(null);
 
     // XXX: More key validation?
     info.replace(/([^\n:]*):([^\n]*)(?:\n|$)/g, (all, key, val) => {
+      if (val.charCodeAt(0) === 0x22) {
+        // The translatePeerCertificate function is only
+        // used on internally created legacy certificate
+        // objects, and any value that contains a quote
+        // will always be a valid JSON string literal,
+        // so this should never throw.
+        val = JSONParse(val);
+      }
       if (key in c.infoAccess)
         c.infoAccess[key].push(val);
       else
diff --git a/lib/_tls_wrap.js b/lib/_tls_wrap.js
index 9ab6a198ff2bd3bee7d3a73ed85e03857f79ea9f..fe281d0c5d9dfff0c529e2f2c6e10996dc807691 100644
--- a/lib/_tls_wrap.js
+++ b/lib/_tls_wrap.js
@@ -27,6 +27,7 @@ const {
   ObjectSetPrototypeOf,
   RegExp,
   Symbol,
+  SymbolFor,
 } = primordials;
 
 const {
@@ -499,9 +500,9 @@ function TLSSocket(socket, opts) {
     handle: this._wrapHandle(wrap),
     allowHalfOpen: socket ? socket.allowHalfOpen : tlsOptions.allowHalfOpen,
     pauseOnCreate: tlsOptions.pauseOnConnect,
-    // The readable flag is only needed if pauseOnCreate will be handled.
-    readable: tlsOptions.pauseOnConnect,
-    writable: false
+    manualStart: true,
+    highWaterMark: tlsOptions.highWaterMark,
+    onread: !socket ? tlsOptions.onread : null,
   });
 
   // Proxy for API compatibility
@@ -511,11 +512,6 @@ function TLSSocket(socket, opts) {
 
   this._init(socket, wrap);
 
-  // Make sure to setup all required properties like: `connecting` before
-  // starting the flow of the data
-  this.readable = true;
-  this.writable = true;
-
   if (enableTrace && this._handle)
     this._handle.enableTrace();
 
@@ -680,7 +676,9 @@ TLSSocket.prototype._init = function(socket, wrap) {
     if (event !== 'keylog')
       return;
 
-    ssl.enableKeylogCallback();
+    // Guard against enableKeylogCallback after destroy
+    if (!this._handle) return;
+    this._handle.enableKeylogCallback();
 
     // Remove this listener since it's no longer needed.
     this.removeListener('newListener', keylogNewListener);
@@ -724,7 +722,9 @@ TLSSocket.prototype._init = function(socket, wrap) {
       if (event !== 'session')
         return;
 
-      ssl.enableSessionCallbacks();
+      // Guard against enableSessionCallbacks after destroy
+      if (!this._handle) return;
+      this._handle.enableSessionCallbacks();
 
       // Remove this listener since it's no longer needed.
       this.removeListener('newListener', newListener);
@@ -1325,6 +1325,9 @@ Server.prototype.setSecureContext = function(options) {
   if (options.ticketKeys)
     this.ticketKeys = options.ticketKeys;
 
+  this.privateKeyIdentifier = options.privateKeyIdentifier;
+  this.privateKeyEngine = options.privateKeyEngine;
+
   this._sharedCreds = tls.createSecureContext({
     pfx: this.pfx,
     key: this.key,
@@ -1344,7 +1347,9 @@ Server.prototype.setSecureContext = function(options) {
     crl: this.crl,
     sessionIdContext: this.sessionIdContext,
     ticketKeys: this.ticketKeys,
-    sessionTimeout: this.sessionTimeout
+    sessionTimeout: this.sessionTimeout,
+    privateKeyIdentifier: this.privateKeyIdentifier,
+    privateKeyEngine: this.privateKeyEngine,
   });
 };
 
@@ -1367,6 +1372,9 @@ Server.prototype.getTicketKeys = function getTicketKeys() {
 
 
 Server.prototype.setTicketKeys = function setTicketKeys(keys) {
+  validateBuffer(keys);
+  assert(keys.byteLength === 48,
+         'Session ticket keys must be a 48-byte buffer');
   this._sharedCreds.context.setTicketKeys(keys);
 };
 
@@ -1410,6 +1418,11 @@ Server.prototype.setOptions = deprecate(function(options) {
   }
   if (options.pskCallback) this[kPskCallback] = options.pskCallback;
   if (options.pskIdentityHint) this[kPskIdentityHint] = options.pskIdentityHint;
+  if (options.sigalgs) this.sigalgs = options.sigalgs;
+  if (options.privateKeyIdentifier !== undefined)
+    this.privateKeyIdentifier = options.privateKeyIdentifier;
+  if (options.privateKeyEngine !== undefined)
+    this.privateKeyEngine = options.privateKeyEngine;
 }, 'Server.prototype.setOptions() is deprecated', 'DEP0122');
 
 // SNI Contexts High-Level API
@@ -1433,7 +1446,7 @@ Server.prototype[EE.captureRejectionSymbol] = function(
       sock.destroy(err);
       break;
     default:
-      net.Server.prototype[Symbol.for('nodejs.rejection')]
+      net.Server.prototype[SymbolFor('nodejs.rejection')]
         .call(this, err, event, sock);
   }
 };
@@ -1604,6 +1617,8 @@ exports.connect = function connect(...args) {
     requestOCSP: options.requestOCSP,
     enableTrace: options.enableTrace,
     pskCallback: options.pskCallback,
+    highWaterMark: options.highWaterMark,
+    onread: options.onread,
   });
 
   // rejectUnauthorized property can be explicitly defined as `undefined`
@@ -1650,7 +1665,7 @@ exports.connect = function connect(...args) {
     tlssock._start();
 
   tlssock.on('secure', onConnectSecure);
-  tlssock.once('end', onConnectEnd);
+  tlssock.prependListener('end', onConnectEnd);
 
   return tlssock;
 };
diff --git a/lib/assert.js b/lib/assert.js
index 6d6afdf8537bbbc9a69cb2092491e88a67d46582..deb73bc54b92ea329cc875685c80e42643676486 100644
--- a/lib/assert.js
+++ b/lib/assert.js
@@ -21,13 +21,29 @@
 'use strict';
 
 const {
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypePush,
+  ArrayPrototypeShift,
+  ArrayPrototypeSlice,
   Error,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  NumberIsNaN,
   ObjectAssign,
   ObjectIs,
   ObjectKeys,
   ObjectPrototypeIsPrototypeOf,
-  Map,
+  ReflectApply,
   RegExpPrototypeTest,
+  SafeMap,
+  String,
+  StringPrototypeCharCodeAt,
+  StringPrototypeIncludes,
+  StringPrototypeIndexOf,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
 } = primordials;
 
 const { Buffer } = require('buffer');
@@ -47,8 +63,9 @@ const { inspect } = require('internal/util/inspect');
 const { isPromise, isRegExp } = require('internal/util/types');
 const { EOL } = require('internal/constants');
 const { NativeModule } = require('internal/bootstrap/loaders');
+const { isError } = require('internal/util');
 
-const errorCache = new Map();
+const errorCache = new SafeMap();
 const CallTracker = require('internal/assert/calltracker');
 
 let isDeepEqual;
@@ -74,10 +91,10 @@ const meta = [
   '\\u000f', '\\u0010', '\\u0011', '\\u0012', '\\u0013',
   '\\u0014', '\\u0015', '\\u0016', '\\u0017', '\\u0018',
   '\\u0019', '\\u001a', '\\u001b', '\\u001c', '\\u001d',
-  '\\u001e', '\\u001f'
+  '\\u001e', '\\u001f',
 ];
 
-const escapeFn = (str) => meta[str.charCodeAt(0)];
+const escapeFn = (str) => meta[StringPrototypeCharCodeAt(str, 0)];
 
 let warned = false;
 
@@ -101,6 +118,14 @@ function innerFail(obj) {
   throw new AssertionError(obj);
 }
 
+/**
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @param {string} [operator]
+ * @param {Function} [stackStartFn]
+ * @returns {never}
+ */
 function fail(actual, expected, message, operator, stackStartFn) {
   const argsLen = arguments.length;
 
@@ -213,32 +238,17 @@ function getCode(fd, line, column) {
 function parseCode(code, offset) {
   // Lazy load acorn.
   if (parseExpressionAt === undefined) {
-    const acorn = require('internal/deps/acorn/acorn/dist/acorn');
-    const privateMethods =
-      require('internal/deps/acorn-plugins/acorn-private-methods/index');
-    const classFields =
-      require('internal/deps/acorn-plugins/acorn-class-fields/index');
-    const numericSeparator =
-      require('internal/deps/acorn-plugins/acorn-numeric-separator/index');
-    const staticClassFeatures =
-      require('internal/deps/acorn-plugins/acorn-static-class-features/index');
-
+    const Parser = require('internal/deps/acorn/acorn/dist/acorn').Parser;
     ({ findNodeAround } = require('internal/deps/acorn/acorn-walk/dist/walk'));
 
-    const Parser = acorn.Parser.extend(
-      privateMethods,
-      classFields,
-      numericSeparator,
-      staticClassFeatures
-    );
-    parseExpressionAt = Parser.parseExpressionAt.bind(Parser);
+    parseExpressionAt = FunctionPrototypeBind(Parser.parseExpressionAt, Parser);
   }
   let node;
   let start = 0;
   // Parse the read code until the correct expression is found.
   do {
     try {
-      node = parseExpressionAt(code, start, { ecmaVersion: 11 });
+      node = parseExpressionAt(code, start, { ecmaVersion: 'latest' });
       start = node.end + 1 || start;
       // Find the CallExpression in the tree.
       node = findNodeAround(node, offset, 'CallExpression');
@@ -256,8 +266,9 @@ function parseCode(code, offset) {
 
   return [
     node.node.start,
-    code.slice(node.node.start, node.node.end)
-        .replace(escapeSequencesRegExp, escapeFn)
+    StringPrototypeReplace(StringPrototypeSlice(code,
+                                                node.node.start, node.node.end),
+                           escapeSequencesRegExp, escapeFn),
   ];
 }
 
@@ -269,15 +280,14 @@ function getErrMessage(message, fn) {
   // We only need the stack trace. To minimize the overhead use an object
   // instead of an error.
   const err = {};
-  // eslint-disable-next-line no-restricted-syntax
-  Error.captureStackTrace(err, fn);
+  ErrorCaptureStackTrace(err, fn);
   Error.stackTraceLimit = tmpLimit;
 
   overrideStackTrace.set(err, (_, stack) => stack);
   const call = err.stack[0];
 
   const filename = call.getFileName();
-  let line = call.getLineNumber() - 1;
+  const line = call.getLineNumber() - 1;
   let column = call.getColumnNumber() - 1;
   let identifier;
   let code;
@@ -297,9 +307,6 @@ function getErrMessage(message, fn) {
       return message;
     }
     code = String(fn);
-    // For functions created with the Function constructor, V8 does not count
-    // the lines containing the function header.
-    line += 2;
     identifier = `${code}${line}${column}`;
   }
 
@@ -320,28 +327,29 @@ function getErrMessage(message, fn) {
       }
       fd = openSync(filename, 'r', 0o666);
       // Reset column and message.
-      [column, message] = getCode(fd, line, column);
+      ({ 0: column, 1: message } = getCode(fd, line, column));
       // Flush unfinished multi byte characters.
       decoder.end();
     } else {
       for (let i = 0; i < line; i++) {
-        code = code.slice(code.indexOf('\n') + 1);
+        code = StringPrototypeSlice(code,
+                                    StringPrototypeIndexOf(code, '\n') + 1);
       }
-      [column, message] = parseCode(code, column);
+      ({ 0: column, 1: message } = parseCode(code, column));
     }
     // Always normalize indentation, otherwise the message could look weird.
-    if (message.includes('\n')) {
+    if (StringPrototypeIncludes(message, '\n')) {
       if (EOL === '\r\n') {
-        message = message.replace(/\r\n/g, '\n');
+        message = StringPrototypeReplace(message, /\r\n/g, '\n');
       }
-      const frames = message.split('\n');
-      message = frames.shift();
+      const frames = StringPrototypeSplit(message, '\n');
+      message = ArrayPrototypeShift(frames);
       for (const frame of frames) {
         let pos = 0;
         while (pos < column && (frame[pos] === ' ' || frame[pos] === '\t')) {
           pos++;
         }
-        message += `\n  ${frame.slice(pos)}`;
+        message += `\n  ${StringPrototypeSlice(frame, pos)}`;
       }
     }
     message = `The expression evaluated to a falsy value:\n\n  ${message}\n`;
@@ -387,21 +395,31 @@ function innerOk(fn, argLen, value, message) {
   }
 }
 
-// Pure assertion tests whether a value is truthy, as determined
-// by !!value.
+/**
+ * Pure assertion tests whether a value is truthy, as determined
+ * by !!value.
+ * @param {...any} args
+ * @returns {void}
+ */
 function ok(...args) {
   innerOk(ok, args.length, ...args);
 }
 assert.ok = ok;
 
-// The equality assertion tests shallow, coercive equality with ==.
+/**
+ * The equality assertion tests shallow, coercive equality with ==.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 /* eslint-disable no-restricted-properties */
 assert.equal = function equal(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
   // eslint-disable-next-line eqeqeq
-  if (actual != expected) {
+  if (actual != expected && (!NumberIsNaN(actual) || !NumberIsNaN(expected))) {
     innerFail({
       actual,
       expected,
@@ -412,14 +430,20 @@ assert.equal = function equal(actual, expected, message) {
   }
 };
 
-// The non-equality assertion tests for whether two objects are not
-// equal with !=.
+/**
+ * The non-equality assertion tests for whether two objects are not
+ * equal with !=.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.notEqual = function notEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
   // eslint-disable-next-line eqeqeq
-  if (actual == expected) {
+  if (actual == expected || (NumberIsNaN(actual) && NumberIsNaN(expected))) {
     innerFail({
       actual,
       expected,
@@ -430,7 +454,13 @@ assert.notEqual = function notEqual(actual, expected, message) {
   }
 };
 
-// The equivalence assertion tests a deep equality relation.
+/**
+ * The deep equivalence assertion tests a deep equality relation.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.deepEqual = function deepEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -447,7 +477,13 @@ assert.deepEqual = function deepEqual(actual, expected, message) {
   }
 };
 
-// The non-equivalence assertion tests for any deep inequality.
+/**
+ * The deep non-equivalence assertion tests for any deep inequality.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -465,6 +501,14 @@ assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
 };
 /* eslint-enable */
 
+/**
+ * The deep strict equivalence assertion tests a deep strict equality
+ * relation.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -481,6 +525,14 @@ assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
   }
 };
 
+/**
+ * The deep strict non-equivalence assertion tests for any deep strict
+ * inequality.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.notDeepStrictEqual = notDeepStrictEqual;
 function notDeepStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
@@ -498,6 +550,13 @@ function notDeepStrictEqual(actual, expected, message) {
   }
 }
 
+/**
+ * The strict equivalence assertion tests a strict equality relation.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.strictEqual = function strictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -513,6 +572,13 @@ assert.strictEqual = function strictEqual(actual, expected, message) {
   }
 };
 
+/**
+ * The strict non-equivalence assertion tests for any strict inequality.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -607,7 +673,7 @@ function expectedException(actual, expected, message, fn) {
       // Special handle errors to make sure the name and the message are
       // compared as well.
       if (expected instanceof Error) {
-        keys.push('name', 'message');
+        ArrayPrototypePush(keys, 'name', 'message');
       } else if (keys.length === 0) {
         throw new ERR_INVALID_ARG_VALUE('error',
                                         expected, 'may not be an empty object');
@@ -628,12 +694,41 @@ function expectedException(actual, expected, message, fn) {
   } else if (expected.prototype !== undefined && actual instanceof expected) {
     return;
   } else if (ObjectPrototypeIsPrototypeOf(Error, expected)) {
-    throw actual;
+    if (!message) {
+      generatedMessage = true;
+      message = 'The error is expected to be an instance of ' +
+        `"${expected.name}". Received `;
+      if (isError(actual)) {
+        const name = (actual.constructor && actual.constructor.name) ||
+                     actual.name;
+        if (expected.name === name) {
+          message += 'an error with identical name but a different prototype.';
+        } else {
+          message += `"${name}"`;
+        }
+        if (actual.message) {
+          message += `\n\nError message:\n\n${actual.message}`;
+        }
+      } else {
+        message += `"${inspect(actual, { depth: -1 })}"`;
+      }
+    }
+    throwError = true;
   } else {
     // Check validation functions return value.
-    const res = expected.call({}, actual);
+    const res = ReflectApply(expected, {}, [actual]);
     if (res !== true) {
-      throw actual;
+      if (!message) {
+        generatedMessage = true;
+        const name = expected.name ? `"${expected.name}" ` : '';
+        message = `The ${name}validation function is expected to return` +
+          ` "true". Received ${inspect(res)}`;
+
+        if (isError(actual)) {
+          message += `\n\nCaught error:\n\n${actual}`;
+        }
+      }
+      throwError = true;
     }
   }
 
@@ -763,10 +858,10 @@ function hasMatchingError(actual, expected) {
   if (expected.prototype !== undefined && actual instanceof expected) {
     return true;
   }
-  if (Error.isPrototypeOf(expected)) {
+  if (ObjectPrototypeIsPrototypeOf(Error, expected)) {
     return false;
   }
-  return expected.call({}, actual) === true;
+  return ReflectApply(expected, {}, [actual]) === true;
 }
 
 function expectsNoError(stackStartFn, actual, error, message) {
@@ -794,22 +889,51 @@ function expectsNoError(stackStartFn, actual, error, message) {
   throw actual;
 }
 
+/**
+ * Expects the function `promiseFn` to throw an error.
+ * @param {() => any} promiseFn
+ * @param {...any} [args]
+ * @returns {void}
+ */
 assert.throws = function throws(promiseFn, ...args) {
   expectsError(throws, getActual(promiseFn), ...args);
 };
 
+/**
+ * Expects `promiseFn` function or its value to reject.
+ * @param {() => Promise<any>} promiseFn
+ * @param {...any} [args]
+ * @returns {Promise<void>}
+ */
 assert.rejects = async function rejects(promiseFn, ...args) {
   expectsError(rejects, await waitForActual(promiseFn), ...args);
 };
 
+/**
+ * Asserts that the function `fn` does not throw an error.
+ * @param {() => any} fn
+ * @param {...any} [args]
+ * @returns {void}
+ */
 assert.doesNotThrow = function doesNotThrow(fn, ...args) {
   expectsNoError(doesNotThrow, getActual(fn), ...args);
 };
 
+/**
+ * Expects `fn` or its value to not reject.
+ * @param {() => Promise<any>} fn
+ * @param {...any} [args]
+ * @returns {Promise<void>}
+ */
 assert.doesNotReject = async function doesNotReject(fn, ...args) {
   expectsNoError(doesNotReject, await waitForActual(fn), ...args);
 };
 
+/**
+ * Throws `value` if the value is not `null` or `undefined`.
+ * @param {any} err
+ * @returns {void}
+ */
 assert.ifError = function ifError(err) {
   if (err !== null && err !== undefined) {
     let message = 'ifError got unwanted exception: ';
@@ -838,20 +962,21 @@ assert.ifError = function ifError(err) {
       // This will remove any duplicated frames from the error frames taken
       // from within `ifError` and add the original error frames to the newly
       // created ones.
-      const tmp2 = origStack.split('\n');
-      tmp2.shift();
+      const tmp2 = StringPrototypeSplit(origStack, '\n');
+      ArrayPrototypeShift(tmp2);
       // Filter all frames existing in err.stack.
-      let tmp1 = newErr.stack.split('\n');
+      let tmp1 = StringPrototypeSplit(newErr.stack, '\n');
       for (const errFrame of tmp2) {
         // Find the first occurrence of the frame.
-        const pos = tmp1.indexOf(errFrame);
+        const pos = ArrayPrototypeIndexOf(tmp1, errFrame);
         if (pos !== -1) {
           // Only keep new frames.
-          tmp1 = tmp1.slice(0, pos);
+          tmp1 = ArrayPrototypeSlice(tmp1, 0, pos);
           break;
         }
       }
-      newErr.stack = `${tmp1.join('\n')}\n${tmp2.join('\n')}`;
+      newErr.stack =
+        `${ArrayPrototypeJoin(tmp1, '\n')}\n${ArrayPrototypeJoin(tmp2, '\n')}`;
     }
 
     throw newErr;
@@ -893,24 +1018,44 @@ function internalMatch(string, regexp, message, fn) {
   }
 }
 
+/**
+ * Expects the `string` input to match the regular expression.
+ * @param {string} string
+ * @param {RegExp} regexp
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.match = function match(string, regexp, message) {
   internalMatch(string, regexp, message, match);
 };
 
+/**
+ * Expects the `string` input not to match the regular expression.
+ * @param {string} string
+ * @param {RegExp} regexp
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
 assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
   internalMatch(string, regexp, message, doesNotMatch);
 };
 
 assert.CallTracker = CallTracker;
 
-// Expose a strict only variant of assert
+/**
+ * Expose a strict only variant of assert.
+ * @param {...any} args
+ * @returns {void}
+ */
 function strict(...args) {
   innerOk(strict, args.length, ...args);
 }
+
 assert.strict = ObjectAssign(strict, assert, {
   equal: assert.strictEqual,
   deepEqual: assert.deepStrictEqual,
   notEqual: assert.notStrictEqual,
   notDeepEqual: assert.notDeepStrictEqual
 });
+
 assert.strict.strict = assert.strict;
diff --git a/lib/async_hooks.js b/lib/async_hooks.js
index b5ff5d012670ff956821ced21d049f96c6b0a7d5..ee8c31fbe0a6617b38565df8e238e0f82dd46d81 100644
--- a/lib/async_hooks.js
+++ b/lib/async_hooks.js
@@ -1,6 +1,11 @@
 'use strict';
 
 const {
+  ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypeSplice,
+  FunctionPrototypeBind,
   NumberIsSafeInteger,
   ObjectDefineProperties,
   ObjectIs,
@@ -29,6 +34,7 @@ const {
   getHookArrays,
   enableHooks,
   disableHooks,
+  updatePromiseHookMode,
   executionAsyncResource,
   // Internal Embedder API
   newAsyncId,
@@ -81,10 +87,10 @@ class AsyncHook {
     // enable()/disable() are run during their execution. The following
     // references are reassigned to the tmp arrays if a hook is currently being
     // processed.
-    const [hooks_array, hook_fields] = getHookArrays();
+    const { 0: hooks_array, 1: hook_fields } = getHookArrays();
 
     // Each hook is only allowed to be added once.
-    if (hooks_array.includes(this))
+    if (ArrayPrototypeIncludes(hooks_array, this))
       return this;
 
     const prev_kTotals = hook_fields[kTotals];
@@ -98,19 +104,21 @@ class AsyncHook {
     hook_fields[kTotals] += hook_fields[kDestroy] += +!!this[destroy_symbol];
     hook_fields[kTotals] +=
         hook_fields[kPromiseResolve] += +!!this[promise_resolve_symbol];
-    hooks_array.push(this);
+    ArrayPrototypePush(hooks_array, this);
 
     if (prev_kTotals === 0 && hook_fields[kTotals] > 0) {
       enableHooks();
     }
 
+    updatePromiseHookMode();
+
     return this;
   }
 
   disable() {
-    const [hooks_array, hook_fields] = getHookArrays();
+    const { 0: hooks_array, 1: hook_fields } = getHookArrays();
 
-    const index = hooks_array.indexOf(this);
+    const index = ArrayPrototypeIndexOf(hooks_array, this);
     if (index === -1)
       return this;
 
@@ -122,7 +130,7 @@ class AsyncHook {
     hook_fields[kTotals] += hook_fields[kDestroy] -= +!!this[destroy_symbol];
     hook_fields[kTotals] +=
         hook_fields[kPromiseResolve] -= +!!this[promise_resolve_symbol];
-    hooks_array.splice(index, 1);
+    ArrayPrototypeSplice(hooks_array, index, 1);
 
     if (prev_kTotals > 0 && hook_fields[kTotals] === 0) {
       disableHooks();
@@ -185,8 +193,7 @@ class AsyncResource {
     emitBefore(asyncId, this[trigger_async_id_symbol], this);
 
     try {
-      const ret = thisArg === undefined ?
-        fn(...args) :
+      const ret =
         ReflectApply(fn, thisArg, args);
 
       return ret;
@@ -215,7 +222,7 @@ class AsyncResource {
   bind(fn) {
     if (typeof fn !== 'function')
       throw new ERR_INVALID_ARG_TYPE('fn', 'Function', fn);
-    const ret = this.runInAsyncScope.bind(this, fn);
+    const ret = FunctionPrototypeBind(this.runInAsyncScope, this, fn);
     ObjectDefineProperties(ret, {
       'length': {
         configurable: true,
@@ -250,7 +257,6 @@ const storageHook = createHook({
   }
 });
 
-const defaultAlsResourceOpts = { requireManualDestroy: true };
 class AsyncLocalStorage {
   constructor() {
     this.kResourceStore = Symbol('kResourceStore');
@@ -261,7 +267,8 @@ class AsyncLocalStorage {
     if (this.enabled) {
       this.enabled = false;
       // If this.enabled, the instance must be in storageList
-      storageList.splice(storageList.indexOf(this), 1);
+      ArrayPrototypeSplice(storageList,
+                           ArrayPrototypeIndexOf(storageList, this), 1);
       if (storageList.length === 0) {
         storageHook.disable();
       }
@@ -271,7 +278,7 @@ class AsyncLocalStorage {
   _enable() {
     if (!this.enabled) {
       this.enabled = true;
-      storageList.push(this);
+      ArrayPrototypePush(storageList, this);
       storageHook.enable();
     }
   }
@@ -293,25 +300,30 @@ class AsyncLocalStorage {
   run(store, callback, ...args) {
     // Avoid creation of an AsyncResource if store is already active
     if (ObjectIs(store, this.getStore())) {
-      return callback(...args);
+      return ReflectApply(callback, null, args);
+    }
+
+    this._enable();
+
+    const resource = executionAsyncResource();
+    const oldStore = resource[this.kResourceStore];
+
+    resource[this.kResourceStore] = store;
+
+    try {
+      return ReflectApply(callback, null, args);
+    } finally {
+      resource[this.kResourceStore] = oldStore;
     }
-    const resource = new AsyncResource('AsyncLocalStorage',
-                                       defaultAlsResourceOpts);
-    // Calling emitDestroy before runInAsyncScope avoids a try/finally
-    // It is ok because emitDestroy only schedules calling the hook
-    return resource.emitDestroy().runInAsyncScope(() => {
-      this.enterWith(store);
-      return callback(...args);
-    });
   }
 
   exit(callback, ...args) {
     if (!this.enabled) {
-      return callback(...args);
+      return ReflectApply(callback, null, args);
     }
     this.disable();
     try {
-      return callback(...args);
+      return ReflectApply(callback, null, args);
     } finally {
       this._enable();
     }
diff --git a/lib/buffer.js b/lib/buffer.js
index 201626e13ab105d22f1da6039220040d5f93d3f8..757399e5a6465c170a447e613fb774b0ddfe657b 100644
--- a/lib/buffer.js
+++ b/lib/buffer.js
@@ -24,6 +24,7 @@
 const {
   Array,
   ArrayIsArray,
+  ArrayPrototypeForEach,
   Error,
   MathFloor,
   MathMin,
@@ -34,11 +35,17 @@ const {
   ObjectCreate,
   ObjectDefineProperties,
   ObjectDefineProperty,
-  ObjectGetOwnPropertyDescriptor,
-  ObjectGetPrototypeOf,
   ObjectSetPrototypeOf,
+  StringPrototypeCharCodeAt,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeToLowerCase,
+  StringPrototypeTrim,
   SymbolSpecies,
   SymbolToPrimitive,
+  TypedArrayPrototypeGetByteLength,
+  TypedArrayPrototypeFill,
+  TypedArrayPrototypeSet,
   Uint8Array,
   Uint8ArrayPrototype,
 } = primordials;
@@ -96,9 +103,12 @@ const {
 } = require('internal/errors');
 const {
   validateBuffer,
-  validateInt32,
+  validateInteger,
   validateString
 } = require('internal/validators');
+// Provide validateInteger() but with kMaxLength as the default maximum value.
+const validateOffset = (value, name, min = 0, max = kMaxLength) =>
+  validateInteger(value, name, min, max);
 
 const {
   FastBuffer,
@@ -106,12 +116,9 @@ const {
   addBufferPrototypeMethods
 } = require('internal/buffer');
 
-const TypedArrayPrototype = ObjectGetPrototypeOf(Uint8ArrayPrototype);
-
-const TypedArrayProto_byteLength =
-      ObjectGetOwnPropertyDescriptor(TypedArrayPrototype,
-                                     'byteLength').get;
-const TypedArrayFill = TypedArrayPrototype.fill;
+const {
+  Blob,
+} = require('internal/blob');
 
 FastBuffer.prototype.constructor = Buffer;
 Buffer.prototype = FastBuffer.prototype;
@@ -249,17 +256,14 @@ function _copyActual(source, target, targetStart, sourceStart, sourceEnd) {
     sourceEnd = sourceStart + target.length - targetStart;
 
   let nb = sourceEnd - sourceStart;
-  const targetLen = target.length - targetStart;
   const sourceLen = source.length - sourceStart;
-  if (nb > targetLen)
-    nb = targetLen;
   if (nb > sourceLen)
     nb = sourceLen;
 
   if (sourceStart !== 0 || sourceEnd < source.length)
     source = new Uint8Array(source.buffer, source.byteOffset + sourceStart, nb);
 
-  target.set(source, targetStart);
+  TypedArrayPrototypeSet(target, source, targetStart);
 
   return nb;
 }
@@ -493,7 +497,7 @@ function fromArrayLike(obj) {
     if (obj.length > (poolSize - poolOffset))
       createPool();
     const b = new FastBuffer(allocPool, poolOffset, obj.length);
-    b.set(obj, 0);
+    TypedArrayPrototypeSet(b, obj, 0);
     poolOffset += obj.length;
     alignPool();
     return b;
@@ -558,7 +562,7 @@ Buffer.concat = function concat(list, length) {
       }
     }
   } else {
-    validateInt32(length, 'length', 0);
+    validateOffset(length, 'length');
   }
 
   const buffer = Buffer.allocUnsafe(length);
@@ -579,7 +583,7 @@ Buffer.concat = function concat(list, length) {
     // Zero-fill the remaining bytes if the specified `length` was more than
     // the actual total length, i.e. if we have some remaining allocated bytes
     // there were not initialized.
-    TypedArrayFill.call(buffer, 0, pos, length);
+    TypedArrayPrototypeFill(buffer, 0, pos, length);
   }
 
   return buffer;
@@ -587,9 +591,9 @@ Buffer.concat = function concat(list, length) {
 
 function base64ByteLength(str, bytes) {
   // Handle padding
-  if (str.charCodeAt(bytes - 1) === 0x3D)
+  if (StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
     bytes--;
-  if (bytes > 1 && str.charCodeAt(bytes - 1) === 0x3D)
+  if (bytes > 1 && StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
     bytes--;
 
   // Base64 ratio: 3/4
@@ -659,6 +663,20 @@ const encodingOps = {
                     encodingsMap.base64,
                     dir)
   },
+  base64url: {
+    encoding: 'base64url',
+    encodingVal: encodingsMap.base64url,
+    byteLength: (string) => base64ByteLength(string, string.length),
+    write: (buf, string, offset, len) =>
+      buf.base64urlWrite(string, offset, len),
+    slice: (buf, start, end) => buf.base64urlSlice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.base64url),
+                    byteOffset,
+                    encodingsMap.base64url,
+                    dir)
+  },
   hex: {
     encoding: 'hex',
     encodingVal: encodingsMap.hex,
@@ -679,7 +697,7 @@ function getEncodingOps(encoding) {
     case 4:
       if (encoding === 'utf8') return encodingOps.utf8;
       if (encoding === 'ucs2') return encodingOps.ucs2;
-      encoding = encoding.toLowerCase();
+      encoding = StringPrototypeToLowerCase(encoding);
       if (encoding === 'utf8') return encodingOps.utf8;
       if (encoding === 'ucs2') return encodingOps.ucs2;
       break;
@@ -687,32 +705,39 @@ function getEncodingOps(encoding) {
       if (encoding === 'utf-8') return encodingOps.utf8;
       if (encoding === 'ascii') return encodingOps.ascii;
       if (encoding === 'ucs-2') return encodingOps.ucs2;
-      encoding = encoding.toLowerCase();
+      encoding = StringPrototypeToLowerCase(encoding);
       if (encoding === 'utf-8') return encodingOps.utf8;
       if (encoding === 'ascii') return encodingOps.ascii;
       if (encoding === 'ucs-2') return encodingOps.ucs2;
       break;
     case 7:
-      if (encoding === 'utf16le' || encoding.toLowerCase() === 'utf16le')
+      if (encoding === 'utf16le' ||
+          StringPrototypeToLowerCase(encoding) === 'utf16le')
         return encodingOps.utf16le;
       break;
     case 8:
-      if (encoding === 'utf-16le' || encoding.toLowerCase() === 'utf-16le')
+      if (encoding === 'utf-16le' ||
+          StringPrototypeToLowerCase(encoding) === 'utf-16le')
         return encodingOps.utf16le;
       break;
     case 6:
       if (encoding === 'latin1' || encoding === 'binary')
         return encodingOps.latin1;
       if (encoding === 'base64') return encodingOps.base64;
-      encoding = encoding.toLowerCase();
+      encoding = StringPrototypeToLowerCase(encoding);
       if (encoding === 'latin1' || encoding === 'binary')
         return encodingOps.latin1;
       if (encoding === 'base64') return encodingOps.base64;
       break;
     case 3:
-      if (encoding === 'hex' || encoding.toLowerCase() === 'hex')
+      if (encoding === 'hex' || StringPrototypeToLowerCase(encoding) === 'hex')
         return encodingOps.hex;
       break;
+    case 9:
+      if (encoding === 'base64url' ||
+          StringPrototypeToLowerCase(encoding) === 'base64url')
+        return encodingOps.base64url;
+      break;
   }
 }
 
@@ -823,28 +848,30 @@ Buffer.prototype[customInspectSymbol] = function inspect(recurseTimes, ctx) {
   const max = INSPECT_MAX_BYTES;
   const actualMax = MathMin(max, this.length);
   const remaining = this.length - max;
-  let str = this.hexSlice(0, actualMax).replace(/(.{2})/g, '$1 ').trim();
+  let str = StringPrototypeTrim(StringPrototypeReplace(
+    this.hexSlice(0, actualMax), /(.{2})/g, '$1 '));
   if (remaining > 0)
     str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
   // Inspect special properties as well, if possible.
   if (ctx) {
     let extras = false;
     const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
-    const obj = getOwnNonIndexProperties(this, filter).reduce((obj, key) => {
-      extras = true;
-      obj[key] = this[key];
-      return obj;
-    }, ObjectCreate(null));
+    const obj = ObjectCreate(null);
+    ArrayPrototypeForEach(getOwnNonIndexProperties(this, filter),
+                          (key) => {
+                            extras = true;
+                            obj[key] = this[key];
+                          });
     if (extras) {
       if (this.length !== 0)
         str += ', ';
       // '[Object: null prototype] {'.length === 26
       // This is guarded with a test.
-      str += utilInspect(obj, {
+      str += StringPrototypeSlice(utilInspect(obj, {
         ...ctx,
         breakLength: Infinity,
         compact: true
-      }).slice(27, -2);
+      }), 27, -2);
     }
   }
   return `<${this.constructor.name} ${str}>`;
@@ -865,22 +892,22 @@ Buffer.prototype.compare = function compare(target,
   if (targetStart === undefined)
     targetStart = 0;
   else
-    validateInt32(targetStart, 'targetStart', 0);
+    validateOffset(targetStart, 'targetStart');
 
   if (targetEnd === undefined)
     targetEnd = target.length;
   else
-    validateInt32(targetEnd, 'targetEnd', 0, target.length);
+    validateOffset(targetEnd, 'targetEnd', 0, target.length);
 
   if (sourceStart === undefined)
     sourceStart = 0;
   else
-    validateInt32(sourceStart, 'sourceStart', 0);
+    validateOffset(sourceStart, 'sourceStart');
 
   if (sourceEnd === undefined)
     sourceEnd = this.length;
   else
-    validateInt32(sourceEnd, 'sourceEnd', 0, this.length);
+    validateOffset(sourceEnd, 'sourceEnd', 0, this.length);
 
   if (sourceStart >= sourceEnd)
     return (targetStart >= targetEnd ? 0 : -1);
@@ -988,12 +1015,12 @@ function _fill(buf, value, offset, end, encoding) {
     } else if (value.length === 1) {
       // Fast path: If `value` fits into a single byte, use that numeric value.
       if (normalizedEncoding === 'utf8') {
-        const code = value.charCodeAt(0);
+        const code = StringPrototypeCharCodeAt(value, 0);
         if (code < 128) {
           value = code;
         }
       } else if (normalizedEncoding === 'latin1') {
-        value = value.charCodeAt(0);
+        value = StringPrototypeCharCodeAt(value, 0);
       }
     }
   } else {
@@ -1004,12 +1031,12 @@ function _fill(buf, value, offset, end, encoding) {
     offset = 0;
     end = buf.length;
   } else {
-    validateInt32(offset, 'offset', 0);
+    validateOffset(offset, 'offset');
     // Invalid ranges are not set to a default, so can range check early.
     if (end === undefined) {
       end = buf.length;
     } else {
-      validateInt32(end, 'end', 0, buf.length);
+      validateOffset(end, 'end', 0, buf.length);
     }
     if (offset >= end)
       return buf;
@@ -1018,12 +1045,12 @@ function _fill(buf, value, offset, end, encoding) {
 
   if (typeof value === 'number') {
     // OOB check
-    const byteLen = TypedArrayProto_byteLength.call(buf);
+    const byteLen = TypedArrayPrototypeGetByteLength(buf);
     const fillLength = end - offset;
     if (offset > end || fillLength + offset > byteLen)
       throw new ERR_BUFFER_OUT_OF_BOUNDS();
 
-    TypedArrayFill.call(buf, value, offset, end);
+    TypedArrayPrototypeFill(buf, value, offset, end);
   } else {
     const res = bindingFill(buf, value, offset, end, encoding);
     if (res < 0) {
@@ -1049,7 +1076,7 @@ Buffer.prototype.write = function write(string, offset, length, encoding) {
 
   // Buffer#write(string, offset[, length][, encoding])
   } else {
-    validateInt32(offset, 'offset', 0, this.length);
+    validateOffset(offset, 'offset', 0, this.length);
 
     const remaining = this.length - offset;
 
@@ -1059,7 +1086,7 @@ Buffer.prototype.write = function write(string, offset, length, encoding) {
       encoding = length;
       length = remaining;
     } else {
-      validateInt32(length, 'length', 0, this.length);
+      validateOffset(length, 'length', 0, this.length);
       if (length > remaining)
         length = remaining;
     }
@@ -1199,13 +1226,52 @@ if (internalBinding('config').hasIntl) {
   };
 }
 
+let DOMException;
+
+const lazyInvalidCharError = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  throw new DOMException('Invalid character', 'InvalidCharacterError');
+});
+
+function btoa(input) {
+  // The implementation here has not been performance optimized in any way and
+  // should not be.
+  // Refs: https://github.com/nodejs/node/pull/38433#issuecomment-828426932
+  input = `${input}`;
+  for (let n = 0; n < input.length; n++) {
+    if (input[n].charCodeAt(0) > 0xff)
+      lazyInvalidCharError();
+  }
+  const buf = Buffer.from(input, 'latin1');
+  return buf.toString('base64');
+}
+
+const kBase64Digits =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+
+function atob(input) {
+  // The implementation here has not been performance optimized in any way and
+  // should not be.
+  // Refs: https://github.com/nodejs/node/pull/38433#issuecomment-828426932
+  input = `${input}`;
+  for (let n = 0; n < input.length; n++) {
+    if (!kBase64Digits.includes(input[n]))
+      lazyInvalidCharError();
+  }
+  return Buffer.from(input, 'base64').toString('latin1');
+}
+
 module.exports = {
+  Blob,
   Buffer,
   SlowBuffer,
   transcode,
   // Legacy
   kMaxLength,
-  kStringMaxLength
+  kStringMaxLength,
+  btoa,
+  atob,
 };
 
 ObjectDefineProperties(module.exports, {
diff --git a/lib/child_process.js b/lib/child_process.js
index 6897ad47b03d5b55d9e6bd490d4e9bbb4469dd23..06c6e37cc29f6dff78f1d8f422beb21860c9cad5 100644
--- a/lib/child_process.js
+++ b/lib/child_process.js
@@ -28,12 +28,12 @@ const {
   ObjectAssign,
   ObjectDefineProperty,
   ObjectPrototypeHasOwnProperty,
-  Promise,
 } = primordials;
 
 const {
   promisify,
   convertToValidSignal,
+  createDeferredPromise,
   getSystemErrorName
 } = require('internal/util');
 const { isArrayBufferView } = require('internal/util/types');
@@ -45,15 +45,26 @@ let debug = require('internal/util/debuglog').debuglog(
 );
 const { Buffer } = require('buffer');
 const { Pipe, constants: PipeConstants } = internalBinding('pipe_wrap');
+
+const {
+  AbortError,
+  codes: errorCodes,
+} = require('internal/errors');
 const {
   ERR_INVALID_ARG_VALUE,
   ERR_CHILD_PROCESS_IPC_REQUIRED,
   ERR_CHILD_PROCESS_STDIO_MAXBUFFER,
   ERR_INVALID_ARG_TYPE,
-  ERR_OUT_OF_RANGE
-} = require('internal/errors').codes;
+  ERR_OUT_OF_RANGE,
+} = errorCodes;
 const { clearTimeout, setTimeout } = require('timers');
-const { validateString, isInt32 } = require('internal/validators');
+const { getValidatedPath } = require('internal/fs/utils');
+const {
+  validateString,
+  isInt32,
+  validateAbortSignal,
+  validateBoolean,
+} = require('internal/validators');
 const child_process = require('internal/child_process');
 const {
   getValidStdio,
@@ -64,6 +75,28 @@ const {
 
 const MAX_BUFFER = 1024 * 1024;
 
+/**
+ * Spawns a new Node.js process + fork.
+ * @param {string} modulePath
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string;
+ *   detached?: boolean;
+ *   env?: Object;
+ *   execPath?: string;
+ *   execArgv?: string[];
+ *   gid?: number;
+ *   serialization?: string;
+ *   signal?: AbortSignal;
+ *   killSignal?: string | number;
+ *   silent?: boolean;
+ *   stdio?: Array | string;
+ *   uid?: number;
+ *   windowsVerbatimArguments?: boolean;
+ *   timeout?: number;
+ *   }} [options]
+ * @returns {ChildProcess}
+ */
 function fork(modulePath /* , args, options */) {
   validateString(modulePath, 'modulePath');
 
@@ -76,8 +109,7 @@ function fork(modulePath /* , args, options */) {
     args = arguments[pos++];
   }
 
-  if (pos < arguments.length &&
-      (arguments[pos] === undefined || arguments[pos] === null)) {
+  if (pos < arguments.length && arguments[pos] == null) {
     pos++;
   }
 
@@ -128,10 +160,10 @@ function _forkChild(fd, serializationMode) {
   p.unref();
   const control = setupChannel(process, p, serializationMode);
   process.on('newListener', function onNewListener(name) {
-    if (name === 'message' || name === 'disconnect') control.ref();
+    if (name === 'message' || name === 'disconnect') control.refCounted();
   });
   process.on('removeListener', function onRemoveListener(name) {
-    if (name === 'message' || name === 'disconnect') control.unref();
+    if (name === 'message' || name === 'disconnect') control.unrefCounted();
   });
 }
 
@@ -152,7 +184,29 @@ function normalizeExecArgs(command, options, callback) {
   };
 }
 
-
+/**
+ * Spawns a shell executing the given command.
+ * @param {string} command
+ * @param {{
+ *   cmd?: string;
+ *   env?: Object;
+ *   encoding?: string;
+ *   shell?: string;
+ *   signal?: AbortSignal;
+ *   timeout?: number;
+ *   maxBuffer?: number;
+ *   killSignal?: string | number;
+ *   uid?: number;
+ *   gid?: number;
+ *   windowsHide?: boolean;
+ *   }} [options]
+ * @param {(
+ *   error?: Error,
+ *   stdout?: string | Buffer,
+ *   stderr?: string | Buffer
+ *   ) => any} [callback]
+ * @returns {ChildProcess}
+ */
 function exec(command, options, callback) {
   const opts = normalizeExecArgs(command, options, callback);
   return module.exports.execFile(opts.file,
@@ -162,12 +216,7 @@ function exec(command, options, callback) {
 
 const customPromiseExecFunction = (orig) => {
   return (...args) => {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
+    const { promise, resolve, reject } = createDeferredPromise();
 
     promise.child = orig(...args, (err, stdout, stderr) => {
       if (err !== null) {
@@ -188,6 +237,31 @@ ObjectDefineProperty(exec, promisify.custom, {
   value: customPromiseExecFunction(exec)
 });
 
+/**
+ * Spawns the specified file as a shell.
+ * @param {string} file
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string;
+ *   env?: Object;
+ *   encoding?: string;
+ *   timeout?: number;
+ *   maxBuffer?: number;
+ *   killSignal?: string | number;
+ *   uid?: number;
+ *   gid?: number;
+ *   windowsHide?: boolean;
+ *   windowsVerbatimArguments?: boolean;
+ *   shell?: boolean | string;
+ *   signal?: AbortSignal;
+ *   }} [options]
+ * @param {(
+ *   error?: Error,
+ *   stdout?: string | Buffer,
+ *   stderr?: string | Buffer
+ *   ) => any} [callback]
+ * @returns {ChildProcess}
+ */
 function execFile(file /* , args, options, callback */) {
   let args = [];
   let callback;
@@ -238,8 +312,9 @@ function execFile(file /* , args, options, callback */) {
     cwd: options.cwd,
     env: options.env,
     gid: options.gid,
-    uid: options.uid,
     shell: options.shell,
+    signal: options.signal,
+    uid: options.uid,
     windowsHide: !!options.windowsHide,
     windowsVerbatimArguments: !!options.windowsVerbatimArguments
   });
@@ -429,17 +504,16 @@ function normalizeSpawnArguments(file, args, options) {
   else if (options === null || typeof options !== 'object')
     throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
 
+  let cwd = options.cwd;
+
   // Validate the cwd, if present.
-  if (options.cwd != null &&
-      typeof options.cwd !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('options.cwd', 'string', options.cwd);
+  if (cwd != null) {
+    cwd = getValidatedPath(cwd, 'options.cwd');
   }
 
   // Validate detached, if present.
-  if (options.detached != null &&
-      typeof options.detached !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE('options.detached',
-                                   'boolean', options.detached);
+  if (options.detached != null) {
+    validateBoolean(options.detached, 'options.detached');
   }
 
   // Validate the uid, if present.
@@ -461,29 +535,22 @@ function normalizeSpawnArguments(file, args, options) {
   }
 
   // Validate argv0, if present.
-  if (options.argv0 != null &&
-      typeof options.argv0 !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('options.argv0', 'string', options.argv0);
+  if (options.argv0 != null) {
+    validateString(options.argv0, 'options.argv0');
   }
 
   // Validate windowsHide, if present.
-  if (options.windowsHide != null &&
-      typeof options.windowsHide !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE('options.windowsHide',
-                                   'boolean', options.windowsHide);
+  if (options.windowsHide != null) {
+    validateBoolean(options.windowsHide, 'options.windowsHide');
   }
 
   // Validate windowsVerbatimArguments, if present.
-  if (options.windowsVerbatimArguments != null &&
-      typeof options.windowsVerbatimArguments !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE('options.windowsVerbatimArguments',
-                                   'boolean',
-                                   options.windowsVerbatimArguments);
+  let { windowsVerbatimArguments } = options;
+  if (windowsVerbatimArguments != null) {
+    validateBoolean(windowsVerbatimArguments,
+                    'options.windowsVerbatimArguments');
   }
 
-  // Make a shallow copy so we don't clobber the user's options object.
-  options = { ...options };
-
   if (options.shell) {
     const command = [file].concat(args).join(' ');
     // Set the shell, switches, and commands.
@@ -495,7 +562,7 @@ function normalizeSpawnArguments(file, args, options) {
       // '/d /s /c' is used only for cmd.exe.
       if (/^(?:.*\\)?cmd(?:\.exe)?$/i.test(file)) {
         args = ['/d', '/s', '/c', `"${command}"`];
-        options.windowsVerbatimArguments = true;
+        windowsVerbatimArguments = true;
       } else {
         args = ['-c', command];
       }
@@ -535,48 +602,140 @@ function normalizeSpawnArguments(file, args, options) {
   }
 
   return {
-    file: file,
-    args: args,
-    options: options,
-    envPairs: envPairs
+    // Make a shallow copy so we don't clobber the user's options object.
+    ...options,
+    args,
+    cwd,
+    detached: !!options.detached,
+    envPairs,
+    file,
+    windowsHide: !!options.windowsHide,
+    windowsVerbatimArguments: !!windowsVerbatimArguments,
   };
 }
 
+function abortChildProcess(child, killSignal) {
+  if (!child)
+    return;
+  try {
+    if (child.kill(killSignal)) {
+      child.emit('error', new AbortError());
+    }
+  } catch (err) {
+    child.emit('error', err);
+  }
+}
+
 
+/**
+ * Spawns a new process using the given `file`.
+ * @param {string} file
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string;
+ *   env?: Object;
+ *   argv0?: string;
+ *   stdio?: Array | string;
+ *   detached?: boolean;
+ *   uid?: number;
+ *   gid?: number;
+ *   serialization?: string;
+ *   shell?: boolean | string;
+ *   windowsVerbatimArguments?: boolean;
+ *   windowsHide?: boolean;
+ *   signal?: AbortSignal;
+ *   timeout?: number;
+ *   killSignal?: string | number;
+ *   }} [options]
+ * @returns {ChildProcess}
+ */
 function spawn(file, args, options) {
-  const opts = normalizeSpawnArguments(file, args, options);
+  options = normalizeSpawnArguments(file, args, options);
+  validateTimeout(options.timeout, 'options.timeout');
+  validateAbortSignal(options.signal, 'options.signal');
+  const killSignal = sanitizeKillSignal(options.killSignal);
   const child = new ChildProcess();
 
-  options = opts.options;
-  debug('spawn', opts.args, options);
+  if (options.signal) {
+    const signal = options.signal;
+    if (signal.aborted) {
+      onAbortListener();
+    } else {
+      signal.addEventListener('abort', onAbortListener, { once: true });
+      child.once('exit',
+                 () => signal.removeEventListener('abort', onAbortListener));
+    }
 
-  child.spawn({
-    file: opts.file,
-    args: opts.args,
-    cwd: options.cwd,
-    windowsHide: !!options.windowsHide,
-    windowsVerbatimArguments: !!options.windowsVerbatimArguments,
-    detached: !!options.detached,
-    envPairs: opts.envPairs,
-    stdio: options.stdio,
-    uid: options.uid,
-    gid: options.gid,
-    serialization: options.serialization,
-  });
+    function onAbortListener() {
+      process.nextTick(() => {
+        abortChildProcess(child, killSignal);
+      });
+    }
+  }
+
+  debug('spawn', options);
+  child.spawn(options);
+
+  if (options.timeout > 0) {
+    let timeoutId = setTimeout(() => {
+      if (timeoutId) {
+        try {
+          child.kill(killSignal);
+        } catch (err) {
+          child.emit('error', err);
+        }
+        timeoutId = null;
+      }
+    }, options.timeout);
+
+    child.once('exit', () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    });
+  }
 
   return child;
 }
 
+/**
+ * Spawns a new process synchronously using the given `file`.
+ * @param {string} file
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string;
+ *   input?: string | Buffer | TypedArray | DataView;
+ *   argv0?: string;
+ *   stdio?: string | Array;
+ *   env?: Object;
+ *   uid?: number;
+ *   gid?: number;
+ *   timeout?: number;
+ *   killSignal?: string | number;
+ *   maxBuffer?: number;
+ *   encoding?: string;
+ *   shell?: boolean | string;
+ *   windowsVerbatimArguments?: boolean;
+ *   windowsHide?: boolean;
+ *   }} [options]
+ * @returns {{
+ *   pid: number;
+ *   output: Array;
+ *   stdout: Buffer | string;
+ *   stderr: Buffer | string;
+ *   status: number | null;
+ *   signal: string | null;
+ *   error: Error;
+ *   }}
+ */
 function spawnSync(file, args, options) {
-  const opts = normalizeSpawnArguments(file, args, options);
-
-  const defaults = {
+  options = {
     maxBuffer: MAX_BUFFER,
-    ...opts.options
+    ...normalizeSpawnArguments(file, args, options)
   };
-  options = opts.options = defaults;
 
-  debug('spawnSync', opts.args, options);
+  debug('spawnSync', options);
 
   // Validate the timeout, if present.
   validateTimeout(options.timeout);
@@ -584,10 +743,6 @@ function spawnSync(file, args, options) {
   // Validate maxBuffer, if present.
   validateMaxBuffer(options.maxBuffer);
 
-  options.file = opts.file;
-  options.args = opts.args;
-  options.envPairs = opts.envPairs;
-
   // Validate and translate the kill signal, if present.
   options.killSignal = sanitizeKillSignal(options.killSignal);
 
@@ -618,7 +773,7 @@ function spawnSync(file, args, options) {
     }
   }
 
-  return child_process.spawnSync(opts);
+  return child_process.spawnSync(options);
 }
 
 
@@ -640,17 +795,36 @@ function checkExecSyncError(ret, args, cmd) {
   return err;
 }
 
-
+/**
+ * Spawns a file as a shell synchronously.
+ * @param {string} command
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string;
+ *   input?: string | Buffer | TypedArray | DataView;
+ *   stdio?: string | Array;
+ *   env?: Object;
+ *   uid?: number;
+ *   gid?: number;
+ *   timeout?: number;
+ *   killSignal?: string | number;
+ *   maxBuffer?: number;
+ *   encoding?: string;
+ *   windowsHide?: boolean;
+ *   shell?: boolean | string;
+ *   }} [options]
+ * @returns {Buffer | string}
+ */
 function execFileSync(command, args, options) {
-  const opts = normalizeSpawnArguments(command, args, options);
-  const inheritStderr = !opts.options.stdio;
+  options = normalizeSpawnArguments(command, args, options);
 
-  const ret = spawnSync(opts.file, opts.args.slice(1), opts.options);
+  const inheritStderr = !options.stdio;
+  const ret = spawnSync(options.file, options.args.slice(1), options);
 
   if (inheritStderr && ret.stderr)
     process.stderr.write(ret.stderr);
 
-  const err = checkExecSyncError(ret, opts.args, undefined);
+  const err = checkExecSyncError(ret, options.args, undefined);
 
   if (err)
     throw err;
@@ -658,7 +832,25 @@ function execFileSync(command, args, options) {
   return ret.stdout;
 }
 
-
+/**
+ * Spawns a shell executing the given `command` synchronously.
+ * @param {string} command
+ * @param {{
+ *   cwd?: string;
+ *   input?: string | Buffer | TypedArray | DataView;
+ *   stdio?: string | Array;
+ *   env?: Object;
+ *   shell?: string;
+ *   uid?: number;
+ *   gid?: number;
+ *   timeout?: number;
+ *   killSignal?: string | number;
+ *   maxBuffer?: number;
+ *   encoding?: string;
+ *   windowsHide?: boolean;
+ *   }} [options]
+ * @returns {Buffer | string}
+ */
 function execSync(command, options) {
   const opts = normalizeExecArgs(command, options, null);
   const inheritStderr = !opts.options.stdio;
@@ -703,6 +895,37 @@ function sanitizeKillSignal(killSignal) {
   }
 }
 
+// This level of indirection is here because the other child_process methods
+// call spawn internally but should use different cancellation logic.
+function spawnWithSignal(file, args, options) {
+  // Remove signal from options to spawn
+  // to avoid double emitting of AbortError
+  const opts = options && typeof options === 'object' && ('signal' in options) ?
+    { ...options, signal: undefined } :
+    options;
+
+  if (options?.signal) {
+    // Validate signal, if present
+    validateAbortSignal(options.signal, 'options.signal');
+  }
+  const child = spawn(file, args, opts);
+
+  if (options?.signal) {
+    const killSignal = sanitizeKillSignal(options.killSignal);
+
+    function kill() {
+      abortChildProcess(child, killSignal);
+    }
+    if (options.signal.aborted) {
+      process.nextTick(kill);
+    } else {
+      options.signal.addEventListener('abort', kill, { once: true });
+      const remove = () => options.signal.removeEventListener('abort', kill);
+      child.once('exit', remove);
+    }
+  }
+  return child;
+}
 module.exports = {
   _forkChild,
   ChildProcess,
@@ -711,6 +934,6 @@ module.exports = {
   execFileSync,
   execSync,
   fork,
-  spawn,
+  spawn: spawnWithSignal,
   spawnSync
 };
diff --git a/lib/crypto.js b/lib/crypto.js
index b2bcc4d0a44592827ade5fc498a9e0f13dc05669..a41b02d97a70ade61534f7b2dcda531d49a87f7c 100644
--- a/lib/crypto.js
+++ b/lib/crypto.js
@@ -53,7 +53,8 @@ const {
   randomBytes,
   randomFill,
   randomFillSync,
-  randomInt
+  randomInt,
+  randomUUID,
 } = require('internal/crypto/random');
 const {
   pbkdf2,
@@ -186,6 +187,7 @@ module.exports = {
   randomFill,
   randomFillSync,
   randomInt,
+  randomUUID,
   scrypt,
   scryptSync,
   sign: signOneShot,
diff --git a/lib/dgram.js b/lib/dgram.js
index 0901f2d650bd7c356844a1189777284bd09b3fbd..ec2c1a6f49d9465f1df93e09999e581b0618edd0 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -24,8 +24,12 @@
 const {
   Array,
   ArrayIsArray,
+  ArrayPrototypePush,
+  FunctionPrototypeBind,
+  FunctionPrototypeCall,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
+  ReflectApply,
 } = primordials;
 
 const errors = require('internal/errors');
@@ -41,7 +45,6 @@ const {
   ERR_SOCKET_ALREADY_BOUND,
   ERR_SOCKET_BAD_BUFFER_SIZE,
   ERR_SOCKET_BUFFER_SIZE,
-  ERR_SOCKET_CANNOT_SEND,
   ERR_SOCKET_DGRAM_IS_CONNECTED,
   ERR_SOCKET_DGRAM_NOT_CONNECTED,
   ERR_SOCKET_DGRAM_NOT_RUNNING,
@@ -49,6 +52,7 @@ const {
 } = errors.codes;
 const {
   isInt32,
+  validateAbortSignal,
   validateString,
   validateNumber,
   validatePort,
@@ -81,14 +85,18 @@ const RECV_BUFFER = true;
 const SEND_BUFFER = false;
 
 // Lazily loaded
-let cluster = null;
+let _cluster = null;
+function lazyLoadCluster() {
+  if (!_cluster) _cluster = require('cluster');
+  return _cluster;
+}
 
 const errnoException = errors.errnoException;
 const exceptionWithHostPort = errors.exceptionWithHostPort;
 
 
 function Socket(type, listener) {
-  EventEmitter.call(this);
+  FunctionPrototypeCall(EventEmitter, this);
   let lookup;
   let recvBufferSize;
   let sendBufferSize;
@@ -122,6 +130,20 @@ function Socket(type, listener) {
     recvBufferSize,
     sendBufferSize
   };
+
+  if (options?.signal !== undefined) {
+    const { signal } = options;
+    validateAbortSignal(signal, 'options.signal');
+    const onAborted = () => {
+      this.close();
+    };
+    if (signal.aborted) {
+      onAborted();
+    } else {
+      signal.addEventListener('abort', onAborted);
+      this.once('close', () => signal.removeEventListener('abort', onAborted));
+    }
+  }
 }
 ObjectSetPrototypeOf(Socket.prototype, EventEmitter.prototype);
 ObjectSetPrototypeOf(Socket, EventEmitter);
@@ -182,8 +204,7 @@ function bufferSize(self, size, buffer) {
 
 // Query master process to get the server handle and utilize it.
 function bindServerHandle(self, options, errCb) {
-  if (!cluster)
-    cluster = require('cluster');
+  const cluster = lazyLoadCluster();
 
   const state = self[kStateSymbol];
   cluster._getServer(self, options, (err, handle) => {
@@ -221,8 +242,8 @@ Socket.prototype.bind = function(port_, address_ /* , callback */) {
     }
 
     function onListening() {
-      removeListeners.call(this);
-      cb.call(this);
+      FunctionPrototypeCall(removeListeners, this);
+      FunctionPrototypeCall(cb, this);
     }
 
     this.on('error', removeListeners);
@@ -244,8 +265,7 @@ Socket.prototype.bind = function(port_, address_ /* , callback */) {
     const exclusive = !!port.exclusive;
     const state = this[kStateSymbol];
 
-    if (!cluster)
-      cluster = require('cluster');
+    const cluster = lazyLoadCluster();
 
     if (cluster.isWorker && !exclusive) {
       bindServerHandle(this, {
@@ -307,8 +327,7 @@ Socket.prototype.bind = function(port_, address_ /* , callback */) {
       return;
     }
 
-    if (!cluster)
-      cluster = require('cluster');
+    const cluster = lazyLoadCluster();
 
     let flags = 0;
     if (state.reuseAddr)
@@ -350,7 +369,7 @@ Socket.prototype.bind = function(port_, address_ /* , callback */) {
 };
 
 Socket.prototype.connect = function(port, address, callback) {
-  port = validatePort(port, 'Port', { allowZero: false });
+  port = validatePort(port, 'Port', false);
   if (typeof address === 'function') {
     callback = address;
     address = '';
@@ -370,11 +389,12 @@ Socket.prototype.connect = function(port, address, callback) {
     this.bind({ port: 0, exclusive: true }, null);
 
   if (state.bindState !== BIND_STATE_BOUND) {
-    enqueue(this, _connect.bind(this, port, address, callback));
+    enqueue(this, FunctionPrototypeBind(_connect, this,
+                                        port, address, callback));
     return;
   }
 
-  _connect.call(this, port, address, callback);
+  ReflectApply(_connect, this, [port, address, callback]);
 };
 
 
@@ -496,23 +516,22 @@ function enqueue(self, toEnqueue) {
   // event handler that flushes the send queue after binding is done.
   if (state.queue === undefined) {
     state.queue = [];
-    self.once('error', onListenError);
+    self.once(EventEmitter.errorMonitor, onListenError);
     self.once('listening', onListenSuccess);
   }
-  state.queue.push(toEnqueue);
+  ArrayPrototypePush(state.queue, toEnqueue);
 }
 
 
 function onListenSuccess() {
-  this.removeListener('error', onListenError);
-  clearQueue.call(this);
+  this.removeListener(EventEmitter.errorMonitor, onListenError);
+  FunctionPrototypeCall(clearQueue, this);
 }
 
 
 function onListenError(err) {
   this.removeListener('listening', onListenSuccess);
   this[kStateSymbol].queue = undefined;
-  this.emit('error', new ERR_SOCKET_CANNOT_SEND());
 }
 
 
@@ -607,7 +626,7 @@ Socket.prototype.send = function(buffer,
   }
 
   if (!connected)
-    port = validatePort(port, 'Port', { allowZero: false });
+    port = validatePort(port, 'Port', false);
 
   // Normalize callback so it's either a function or undefined but not anything
   // else.
@@ -627,12 +646,13 @@ Socket.prototype.send = function(buffer,
     this.bind({ port: 0, exclusive: true }, null);
 
   if (list.length === 0)
-    list.push(Buffer.alloc(0));
+    ArrayPrototypePush(list, Buffer.alloc(0));
 
   // If the socket hasn't been bound yet, push the outbound packet onto the
   // send queue and send after binding is complete.
   if (state.bindState !== BIND_STATE_BOUND) {
-    enqueue(this, this.send.bind(this, list, port, address, callback));
+    enqueue(this, FunctionPrototypeBind(this.send, this,
+                                        list, port, address, callback));
     return;
   }
 
@@ -714,7 +734,7 @@ Socket.prototype.close = function(callback) {
     this.on('close', callback);
 
   if (queue !== undefined) {
-    queue.push(this.close.bind(this));
+    ArrayPrototypePush(queue, FunctionPrototypeBind(this.close, this));
     return this;
   }
 
@@ -852,13 +872,8 @@ Socket.prototype.addSourceSpecificMembership = function(sourceAddress,
                                                         interfaceAddress) {
   healthCheck(this);
 
-  if (typeof sourceAddress !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('sourceAddress', 'string', sourceAddress);
-  }
-
-  if (typeof groupAddress !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('groupAddress', 'string', groupAddress);
-  }
+  validateString(sourceAddress, 'sourceAddress');
+  validateString(groupAddress, 'groupAddress');
 
   const err =
     this[kStateSymbol].handle.addSourceSpecificMembership(sourceAddress,
@@ -875,13 +890,8 @@ Socket.prototype.dropSourceSpecificMembership = function(sourceAddress,
                                                          interfaceAddress) {
   healthCheck(this);
 
-  if (typeof sourceAddress !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('sourceAddress', 'string', sourceAddress);
-  }
-
-  if (typeof groupAddress !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('groupAddress', 'string', groupAddress);
-  }
+  validateString(sourceAddress, 'sourceAddress');
+  validateString(groupAddress, 'groupAddress');
 
   const err =
     this[kStateSymbol].handle.dropSourceSpecificMembership(sourceAddress,
diff --git a/lib/diagnostics_channel.js b/lib/diagnostics_channel.js
new file mode 100644
index 0000000000000000000000000000000000000000..c29c9ff00524055502af5cc9bbab6e2863ae7377
--- /dev/null
+++ b/lib/diagnostics_channel.js
@@ -0,0 +1,121 @@
+'use strict';
+
+const {
+  ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypeSplice,
+  ObjectCreate,
+  ObjectGetPrototypeOf,
+  ObjectSetPrototypeOf,
+  SymbolHasInstance,
+} = primordials;
+
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+  }
+} = require('internal/errors');
+
+const { triggerUncaughtException } = internalBinding('errors');
+
+const { WeakReference } = internalBinding('util');
+
+// TODO(qard): should there be a C++ channel interface?
+class ActiveChannel {
+  subscribe(subscription) {
+    if (typeof subscription !== 'function') {
+      throw new ERR_INVALID_ARG_TYPE('subscription', ['function'],
+                                     subscription);
+    }
+    ArrayPrototypePush(this._subscribers, subscription);
+  }
+
+  unsubscribe(subscription) {
+    const index = ArrayPrototypeIndexOf(this._subscribers, subscription);
+    if (index >= 0) {
+      ArrayPrototypeSplice(this._subscribers, index, 1);
+
+      // When there are no more active subscribers, restore to fast prototype.
+      if (!this._subscribers.length) {
+        // eslint-disable-next-line no-use-before-define
+        ObjectSetPrototypeOf(this, Channel.prototype);
+      }
+    }
+  }
+
+  get hasSubscribers() {
+    return true;
+  }
+
+  publish(data) {
+    for (let i = 0; i < this._subscribers.length; i++) {
+      try {
+        const onMessage = this._subscribers[i];
+        onMessage(data, this.name);
+      } catch (err) {
+        process.nextTick(() => {
+          triggerUncaughtException(err, false);
+        });
+      }
+    }
+  }
+}
+
+class Channel {
+  constructor(name) {
+    this._subscribers = undefined;
+    this.name = name;
+  }
+
+  static [SymbolHasInstance](instance) {
+    const prototype = ObjectGetPrototypeOf(instance);
+    return prototype === Channel.prototype ||
+           prototype === ActiveChannel.prototype;
+  }
+
+  subscribe(subscription) {
+    ObjectSetPrototypeOf(this, ActiveChannel.prototype);
+    this._subscribers = [];
+    this.subscribe(subscription);
+  }
+
+  get hasSubscribers() {
+    return false;
+  }
+
+  publish() {}
+}
+
+const channels = ObjectCreate(null);
+
+function channel(name) {
+  let channel;
+  const ref = channels[name];
+  if (ref) channel = ref.get();
+  if (channel) return channel;
+
+  if (typeof name !== 'string' && typeof name !== 'symbol') {
+    throw new ERR_INVALID_ARG_TYPE('channel', ['string', 'symbol'], name);
+  }
+
+  channel = new Channel(name);
+  channels[name] = new WeakReference(channel);
+  return channel;
+}
+
+function hasSubscribers(name) {
+  let channel;
+  const ref = channels[name];
+  if (ref) channel = ref.get();
+  if (!channel) {
+    return false;
+  }
+
+  return channel.hasSubscribers;
+}
+
+module.exports = {
+  channel,
+  hasSubscribers,
+  Channel
+};
diff --git a/lib/dns.js b/lib/dns.js
index 92b70c73effbf299969a3853ec5a04ec41eccfb9..67611ff9e1ed6410527d16c76638639c77ec9053 100644
--- a/lib/dns.js
+++ b/lib/dns.js
@@ -22,9 +22,11 @@
 'use strict';
 
 const {
+  ArrayPrototypeMap,
   ObjectCreate,
   ObjectDefineProperties,
   ObjectDefineProperty,
+  ReflectApply,
 } = primordials;
 
 const cares = internalBinding('cares_wrap');
@@ -39,6 +41,8 @@ const {
   Resolver,
   validateHints,
   emitInvalidHostnameWarning,
+  getDefaultVerbatim,
+  setDefaultResultOrder,
 } = require('internal/dns/utils');
 const {
   ERR_INVALID_ARG_TYPE,
@@ -49,6 +53,7 @@ const {
 const {
   validatePort,
   validateString,
+  validateOneOf,
 } = require('internal/validators');
 
 const {
@@ -93,7 +98,7 @@ function lookup(hostname, options, callback) {
   let hints = 0;
   let family = -1;
   let all = false;
-  let verbatim = false;
+  let verbatim = getDefaultVerbatim();
 
   // Parse arguments
   if (hostname && typeof hostname !== 'string') {
@@ -107,15 +112,16 @@ function lookup(hostname, options, callback) {
     hints = options.hints >>> 0;
     family = options.family >>> 0;
     all = options.all === true;
-    verbatim = options.verbatim === true;
+    if (typeof options.verbatim === 'boolean') {
+      verbatim = options.verbatim === true;
+    }
 
     validateHints(hints);
   } else {
     family = options >>> 0;
   }
 
-  if (family !== 0 && family !== 4 && family !== 6)
-    throw new ERR_INVALID_OPT_VALUE('family', family);
+  validateOneOf(family, 'family', [0, 4, 6], true);
 
   if (!hostname) {
     emitInvalidHostnameWarning(hostname);
@@ -197,7 +203,8 @@ ObjectDefineProperty(lookupService, customPromisifyArgs,
 
 function onresolve(err, result, ttls) {
   if (ttls && this.ttl)
-    result = result.map((address, index) => ({ address, ttl: ttls[index] }));
+    result = ArrayPrototypeMap(
+      result, (address, index) => ({ address, ttl: ttls[index] }));
 
   if (err)
     this.callback(dnsException(err, this.bindingName, this.hostname));
@@ -236,6 +243,7 @@ const resolveMap = ObjectCreate(null);
 Resolver.prototype.resolveAny = resolveMap.ANY = resolver('queryAny');
 Resolver.prototype.resolve4 = resolveMap.A = resolver('queryA');
 Resolver.prototype.resolve6 = resolveMap.AAAA = resolver('queryAaaa');
+Resolver.prototype.resolveCaa = resolveMap.CAA = resolver('queryCaa');
 Resolver.prototype.resolveCname = resolveMap.CNAME = resolver('queryCname');
 Resolver.prototype.resolveMx = resolveMap.MX = resolver('queryMx');
 Resolver.prototype.resolveNs = resolveMap.NS = resolver('queryNs');
@@ -260,7 +268,7 @@ function resolve(hostname, rrtype, callback) {
   }
 
   if (typeof resolver === 'function') {
-    return resolver.call(this, hostname, callback);
+    return ReflectApply(resolver, this, [hostname, callback]);
   }
   throw new ERR_INVALID_OPT_VALUE('rrtype', rrtype);
 }
@@ -281,6 +289,7 @@ module.exports = {
   lookupService,
 
   Resolver,
+  setDefaultResultOrder,
   setServers: defaultResolverSetServers,
 
   // uv_getaddrinfo flags
@@ -325,6 +334,7 @@ ObjectDefineProperties(module.exports, {
       if (promises === null) {
         promises = require('internal/dns/promises');
         promises.setServers = defaultResolverSetServers;
+        promises.setDefaultResultOrder = setDefaultResultOrder;
       }
       return promises;
     }
diff --git a/lib/domain.js b/lib/domain.js
index 9659dcde855c933edec67ea3125ef7efe8df4e50..fcc8bb0a6dbc690767672a521fcc7cda58f139fc 100644
--- a/lib/domain.js
+++ b/lib/domain.js
@@ -27,11 +27,18 @@
 // unless they address existing, critical bugs.
 
 const {
-  Array,
+  ArrayPrototypeEvery,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeLastIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
   Error,
-  Map,
+  FunctionPrototypeCall,
   ObjectDefineProperty,
+  Promise,
   ReflectApply,
+  SafeMap,
   Symbol,
 } = primordials;
 
@@ -61,18 +68,22 @@ ObjectDefineProperty(process, 'domain', {
   }
 });
 
-const pairing = new Map();
+const pairing = new SafeMap();
 const asyncHook = createHook({
   init(asyncId, type, triggerAsyncId, resource) {
     if (process.domain !== null && process.domain !== undefined) {
       // If this operation is created while in a domain, let's mark it
       pairing.set(asyncId, process.domain[kWeak]);
-      ObjectDefineProperty(resource, 'domain', {
-        configurable: true,
-        enumerable: false,
-        value: process.domain,
-        writable: true
-      });
+      // Promises from other contexts, such as with the VM module, should not
+      // have a domain property as it can be used to escape the sandbox.
+      if (type !== 'PROMISE' || resource instanceof Promise) {
+        ObjectDefineProperty(resource, 'domain', {
+          configurable: true,
+          enumerable: false,
+          value: process.domain,
+          writable: true
+        });
+      }
     }
   },
   before(asyncId) {
@@ -118,12 +129,15 @@ process.setUncaughtExceptionCaptureCallback = function(fn) {
 
 
 let sendMakeCallbackDeprecation = false;
-function emitMakeCallbackDeprecation() {
+function emitMakeCallbackDeprecation({ target, method }) {
   if (!sendMakeCallbackDeprecation) {
     process.emitWarning(
       'Using a domain property in MakeCallback is deprecated. Use the ' +
       'async_context variant of MakeCallback or the AsyncResource class ' +
-      'instead.', 'DeprecationWarning', 'DEP0097');
+      'instead. ' +
+      `(Triggered by calling ${method?.name || '<anonymous>'} ` +
+      `on ${target?.constructor?.name}.)`,
+      'DeprecationWarning', 'DEP0097');
     sendMakeCallbackDeprecation = true;
   }
 }
@@ -131,7 +145,7 @@ function emitMakeCallbackDeprecation() {
 function topLevelDomainCallback(cb, ...args) {
   const domain = this.domain;
   if (exports.active && domain)
-    emitMakeCallbackDeprecation();
+    emitMakeCallbackDeprecation({ target: this, method: cb });
 
   if (domain)
     domain.enter();
@@ -144,12 +158,13 @@ function topLevelDomainCallback(cb, ...args) {
 
 // It's possible to enter one domain while already inside
 // another one. The stack is each entered domain.
-const stack = [];
+let stack = [];
 exports._stack = stack;
 useDomainTrampoline(topLevelDomainCallback);
 
 function updateExceptionCapture() {
-  if (stack.every((domain) => domain.listenerCount('error') === 0)) {
+  if (ArrayPrototypeEvery(stack,
+                          (domain) => domain.listenerCount('error') === 0)) {
     setUncaughtExceptionCaptureCallback(null);
   } else {
     setUncaughtExceptionCaptureCallback(null);
@@ -223,6 +238,13 @@ Domain.prototype._errorHandler = function(er) {
     });
     er.domainThrown = true;
   }
+  // Pop all adjacent duplicates of the currently active domain from the stack.
+  // This is done to prevent a domain's error handler to run within the context
+  // of itself, and re-entering itself recursively handler as a result of an
+  // exception thrown in its context.
+  while (exports.active === this) {
+    this.exit();
+  }
 
   // The top-level domain-handler is handled separately.
   //
@@ -233,15 +255,15 @@ Domain.prototype._errorHandler = function(er) {
   // process abort. Using try/catch here would always make V8 think
   // that these exceptions are caught, and thus would prevent it from
   // aborting in these cases.
-  if (stack.length === 1) {
+  if (stack.length === 0) {
     // If there's no error handler, do not emit an 'error' event
     // as this would throw an error, make the process exit, and thus
     // prevent the process 'uncaughtException' event from being emitted
     // if a listener is set.
     if (EventEmitter.listenerCount(this, 'error') > 0) {
-      // Clear the uncaughtExceptionCaptureCallback so that we know that, even
-      // if technically the top-level domain is still active, it would
-      // be ok to abort on an uncaught exception at this point
+      // Clear the uncaughtExceptionCaptureCallback so that we know that, since
+      // the top-level domain is not active anymore, it would be ok to abort on
+      // an uncaught exception at this point
       setUncaughtExceptionCaptureCallback(null);
       try {
         caught = this.emit('error', er);
@@ -265,10 +287,6 @@ Domain.prototype._errorHandler = function(er) {
       // The domain error handler threw!  oh no!
       // See if another domain can catch THIS error,
       // or else crash on the original one.
-      // If the user already exited it, then don't double-exit.
-      if (this === exports.active) {
-        stack.pop();
-      }
       updateExceptionCapture();
       if (stack.length) {
         exports.active = process.domain = stack[stack.length - 1];
@@ -293,20 +311,20 @@ Domain.prototype.enter = function() {
   // Note that this might be a no-op, but we still need
   // to push it onto the stack so that we can pop it later.
   exports.active = process.domain = this;
-  stack.push(this);
+  ArrayPrototypePush(stack, this);
   updateExceptionCapture();
 };
 
 
 Domain.prototype.exit = function() {
   // Don't do anything if this domain is not on the stack.
-  const index = stack.lastIndexOf(this);
+  const index = ArrayPrototypeLastIndexOf(stack, this);
   if (index === -1) return;
 
   // Exit all domains until this one.
-  stack.splice(index);
+  ArrayPrototypeSplice(stack, index);
 
-  exports.active = stack[stack.length - 1];
+  exports.active = stack.length === 0 ? undefined : stack[stack.length - 1];
   process.domain = exports.active;
   updateExceptionCapture();
 };
@@ -323,7 +341,7 @@ Domain.prototype.add = function(ee) {
     ee.domain.remove(ee);
 
   // Check for circular Domain->Domain links.
-  // This causes bad insanity!
+  // They cause big issues.
   //
   // For example:
   // var d = domain.create();
@@ -343,33 +361,21 @@ Domain.prototype.add = function(ee) {
     value: this,
     writable: true
   });
-  this.members.push(ee);
+  ArrayPrototypePush(this.members, ee);
 };
 
 
 Domain.prototype.remove = function(ee) {
   ee.domain = null;
-  const index = this.members.indexOf(ee);
+  const index = ArrayPrototypeIndexOf(this.members, ee);
   if (index !== -1)
-    this.members.splice(index, 1);
+    ArrayPrototypeSplice(this.members, index, 1);
 };
 
 
 Domain.prototype.run = function(fn) {
-  let ret;
-
   this.enter();
-  if (arguments.length >= 2) {
-    const len = arguments.length;
-    const args = new Array(len - 1);
-
-    for (let i = 1; i < len; i++)
-      args[i - 1] = arguments[i];
-
-    ret = fn.apply(this, args);
-  } else {
-    ret = fn.call(this);
-  }
+  const ret = ReflectApply(fn, this, ArrayPrototypeSlice(arguments, 1));
   this.exit();
 
   return ret;
@@ -391,17 +397,8 @@ function intercepted(_this, self, cb, fnargs) {
     return;
   }
 
-  const args = [];
-  let ret;
-
   self.enter();
-  if (fnargs.length > 1) {
-    for (let i = 1; i < fnargs.length; i++)
-      args.push(fnargs[i]);
-    ret = cb.apply(_this, args);
-  } else {
-    ret = cb.call(_this);
-  }
+  const ret = ReflectApply(cb, _this, ArrayPrototypeSlice(fnargs, 1));
   self.exit();
 
   return ret;
@@ -420,13 +417,8 @@ Domain.prototype.intercept = function(cb) {
 
 
 function bound(_this, self, cb, fnargs) {
-  let ret;
-
   self.enter();
-  if (fnargs.length > 0)
-    ret = cb.apply(_this, fnargs);
-  else
-    ret = cb.call(_this);
+  const ret = ReflectApply(cb, _this, fnargs);
   self.exit();
 
   return ret;
@@ -465,11 +457,11 @@ EventEmitter.init = function() {
     this.domain = exports.active;
   }
 
-  return eventInit.call(this);
+  return FunctionPrototypeCall(eventInit, this);
 };
 
 const eventEmit = EventEmitter.prototype.emit;
-EventEmitter.prototype.emit = function(...args) {
+EventEmitter.prototype.emit = function emit(...args) {
   const domain = this.domain;
 
   const type = args[0];
@@ -498,7 +490,46 @@ EventEmitter.prototype.emit = function(...args) {
       er.domainThrown = false;
     }
 
+    // Remove the current domain (and its duplicates) from the domains stack and
+    // set the active domain to its parent (if any) so that the domain's error
+    // handler doesn't run in its own context. This prevents any event emitter
+    // created or any exception thrown in that error handler from recursively
+    // executing that error handler.
+    const origDomainsStack = ArrayPrototypeSlice(stack);
+    const origActiveDomain = process.domain;
+
+    // Travel the domains stack from top to bottom to find the first domain
+    // instance that is not a duplicate of the current active domain.
+    let idx = stack.length - 1;
+    while (idx > -1 && process.domain === stack[idx]) {
+      --idx;
+    }
+
+    // Change the stack to not contain the current active domain, and only the
+    // domains above it on the stack.
+    if (idx < 0) {
+      stack.length = 0;
+    } else {
+      ArrayPrototypeSplice(stack, idx + 1);
+    }
+
+    // Change the current active domain
+    if (stack.length > 0) {
+      exports.active = process.domain = stack[stack.length - 1];
+    } else {
+      exports.active = process.domain = null;
+    }
+
+    updateExceptionCapture();
+
     domain.emit('error', er);
+
+    // Now that the domain's error handler has completed, restore the domains
+    // stack and the active domain to their original values.
+    exports._stack = stack = origDomainsStack;
+    exports.active = process.domain = origActiveDomain;
+    updateExceptionCapture();
+
     return false;
   }
 
diff --git a/lib/events.js b/lib/events.js
index 300f9f1e6b687f4d6b72970af89126bce13b8cca..76d7628806476146d118514e7b43958b8adf63b8 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -22,19 +22,22 @@
 'use strict';
 
 const {
+  ArrayPrototypeSlice,
   Boolean,
   Error,
+  ErrorCaptureStackTrace,
   MathMin,
   NumberIsNaN,
   ObjectCreate,
   ObjectDefineProperty,
+  ObjectDefineProperties,
   ObjectGetPrototypeOf,
   ObjectSetPrototypeOf,
   Promise,
   PromiseReject,
   PromiseResolve,
-  ReflectApply,
   ReflectOwnKeys,
+  String,
   Symbol,
   SymbolFor,
   SymbolAsyncIterator
@@ -44,6 +47,7 @@ const kRejection = SymbolFor('nodejs.rejection');
 let spliceOne;
 
 const {
+  hideStackFrames,
   kEnhanceStackBeforeInspector,
   codes
 } = require('internal/errors');
@@ -57,16 +61,36 @@ const {
   inspect
 } = require('internal/util/inspect');
 
+const {
+  validateAbortSignal
+} = require('internal/validators');
+
 const kCapture = Symbol('kCapture');
 const kErrorMonitor = Symbol('events.errorMonitor');
+const kMaxEventTargetListeners = Symbol('events.maxEventTargetListeners');
+const kMaxEventTargetListenersWarned =
+  Symbol('events.maxEventTargetListenersWarned');
+
+let DOMException;
+const lazyDOMException = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message, name);
+});
+
 
+/**
+ * Creates a new `EventEmitter` instance.
+ * @param {{ captureRejections?: boolean; }} [opts]
+ * @returns {EventEmitter}
+ */
 function EventEmitter(opts) {
   EventEmitter.init.call(this, opts);
 }
 module.exports = EventEmitter;
 module.exports.once = once;
 module.exports.on = on;
-
+module.exports.getEventListeners = getEventListeners;
 // Backwards-compat with node 0.10.x
 EventEmitter.EventEmitter = EventEmitter;
 
@@ -104,6 +128,7 @@ EventEmitter.prototype._maxListeners = undefined;
 // By default EventEmitters will print a warning if more than 10 listeners are
 // added to it. This is a useful default which helps finding memory leaks.
 let defaultMaxListeners = 10;
+let isEventTarget;
 
 function checkListener(listener) {
   if (typeof listener !== 'function') {
@@ -126,6 +151,54 @@ ObjectDefineProperty(EventEmitter, 'defaultMaxListeners', {
   }
 });
 
+ObjectDefineProperties(EventEmitter, {
+  kMaxEventTargetListeners: {
+    value: kMaxEventTargetListeners,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  },
+  kMaxEventTargetListenersWarned: {
+    value: kMaxEventTargetListenersWarned,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  }
+});
+
+/**
+ * Sets the max listeners.
+ * @param {number} n
+ * @param {EventTarget[] | EventEmitter[]} [eventTargets]
+ * @returns {void}
+ */
+EventEmitter.setMaxListeners =
+  function(n = defaultMaxListeners, ...eventTargets) {
+    if (typeof n !== 'number' || n < 0 || NumberIsNaN(n))
+      throw new ERR_OUT_OF_RANGE('n', 'a non-negative number', n);
+    if (eventTargets.length === 0) {
+      defaultMaxListeners = n;
+    } else {
+      if (isEventTarget === undefined)
+        isEventTarget = require('internal/event_target').isEventTarget;
+
+      for (let i = 0; i < eventTargets.length; i++) {
+        const target = eventTargets[i];
+        if (isEventTarget(target)) {
+          target[kMaxEventTargetListeners] = n;
+          target[kMaxEventTargetListenersWarned] = false;
+        } else if (typeof target.setMaxListeners === 'function') {
+          target.setMaxListeners(n);
+        } else {
+          throw new ERR_INVALID_ARG_TYPE(
+            'eventTargets',
+            ['EventEmitter', 'EventTarget'],
+            target);
+        }
+      }
+    }
+  };
+
 EventEmitter.init = function(opts) {
 
   if (this._events === undefined ||
@@ -137,7 +210,7 @@ EventEmitter.init = function(opts) {
   this._maxListeners = this._maxListeners || undefined;
 
 
-  if (opts && opts.captureRejections) {
+  if (opts?.captureRejections) {
     if (typeof opts.captureRejections !== 'boolean') {
       throw new ERR_INVALID_ARG_TYPE('options.captureRejections',
                                      'boolean', opts.captureRejections);
@@ -193,8 +266,11 @@ function emitUnhandledRejectionOrErr(ee, err, type, args) {
   }
 }
 
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
+/**
+ * Increases the max listeners of the event emitter.
+ * @param {number} n
+ * @returns {EventEmitter}
+ */
 EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
   if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
     throw new ERR_OUT_OF_RANGE('n', 'a non-negative number', n);
@@ -209,6 +285,10 @@ function _getMaxListeners(that) {
   return that._maxListeners;
 }
 
+/**
+ * Returns the current max listener value for the event emitter.
+ * @returns {number}
+ */
 EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
   return _getMaxListeners(this);
 };
@@ -250,7 +330,7 @@ function enhanceStackTrace(err, own) {
   const errStack = err.stack.split('\n').slice(1);
   const ownStack = own.stack.split('\n').slice(1);
 
-  const [ len, off ] = identicalSequenceRange(ownStack, errStack);
+  const { 0: len, 1: off } = identicalSequenceRange(ownStack, errStack);
   if (len > 0) {
     ownStack.splice(off + 1, len - 2,
                     '    [... lines matching original stack trace ...]');
@@ -259,6 +339,13 @@ function enhanceStackTrace(err, own) {
   return err.stack + sep + ownStack.join('\n');
 }
 
+/**
+ * Synchronously calls each of the listeners registered
+ * for the event.
+ * @param {string | symbol} type
+ * @param {...any} [args]
+ * @returns {boolean}
+ */
 EventEmitter.prototype.emit = function emit(type, ...args) {
   let doError = (type === 'error');
 
@@ -278,8 +365,7 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
     if (er instanceof Error) {
       try {
         const capture = {};
-        // eslint-disable-next-line no-restricted-syntax
-        Error.captureStackTrace(capture, EventEmitter.prototype.emit);
+        ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
         ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
           value: enhanceStackTrace.bind(this, er, capture),
           configurable: true
@@ -311,7 +397,7 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
     return false;
 
   if (typeof handler === 'function') {
-    const result = ReflectApply(handler, this, args);
+    const result = handler.apply(this, args);
 
     // We check if result is undefined first because that
     // is the most common case so we do not pay any perf
@@ -323,7 +409,7 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
     const len = handler.length;
     const listeners = arrayClone(handler);
     for (let i = 0; i < len; ++i) {
-      const result = ReflectApply(listeners[i], this, args);
+      const result = listeners[i].apply(this, args);
 
       // We check if result is undefined first because that
       // is the most common case so we do not pay any perf
@@ -401,12 +487,25 @@ function _addListener(target, type, listener, prepend) {
   return target;
 }
 
+/**
+ * Adds a listener to the event emitter.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
 EventEmitter.prototype.addListener = function addListener(type, listener) {
   return _addListener(this, type, listener, false);
 };
 
 EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
+/**
+ * Adds the `listener` function to the beginning of
+ * the listeners array.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
 EventEmitter.prototype.prependListener =
     function prependListener(type, listener) {
       return _addListener(this, type, listener, true);
@@ -430,6 +529,12 @@ function _onceWrap(target, type, listener) {
   return wrapped;
 }
 
+/**
+ * Adds a one-time `listener` function to the event emitter.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
 EventEmitter.prototype.once = function once(type, listener) {
   checkListener(listener);
 
@@ -437,6 +542,13 @@ EventEmitter.prototype.once = function once(type, listener) {
   return this;
 };
 
+/**
+ * Adds a one-time `listener` function to the beginning of
+ * the listeners array.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
 EventEmitter.prototype.prependOnceListener =
     function prependOnceListener(type, listener) {
       checkListener(listener);
@@ -445,7 +557,12 @@ EventEmitter.prototype.prependOnceListener =
       return this;
     };
 
-// Emits a 'removeListener' event if and only if the listener was removed.
+/**
+ * Removes the specified `listener` from the listeners array.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
 EventEmitter.prototype.removeListener =
     function removeListener(type, listener) {
       checkListener(listener);
@@ -499,6 +616,13 @@ EventEmitter.prototype.removeListener =
 
 EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 
+/**
+ * Removes all listeners from the event emitter. (Only
+ * removes listeners for a specific event name if specified
+ * as `type`).
+ * @param {string | symbol} [type]
+ * @returns {EventEmitter}
+ */
 EventEmitter.prototype.removeAllListeners =
     function removeAllListeners(type) {
       const events = this._events;
@@ -562,14 +686,34 @@ function _listeners(target, type, unwrap) {
     unwrapListeners(evlistener) : arrayClone(evlistener);
 }
 
+/**
+ * Returns a copy of the array of listeners for the event name
+ * specified as `type`.
+ * @param {string | symbol} type
+ * @returns {Function[]}
+ */
 EventEmitter.prototype.listeners = function listeners(type) {
   return _listeners(this, type, true);
 };
 
+/**
+ * Returns a copy of the array of listeners and wrappers for
+ * the event name specified as `type`.
+ * @param {string | symbol} type
+ * @returns {Function[]}
+ */
 EventEmitter.prototype.rawListeners = function rawListeners(type) {
   return _listeners(this, type, false);
 };
 
+/**
+ * Returns the number of listeners listening to the event name
+ * specified as `type`.
+ * @deprecated since v3.2.0
+ * @param {EventEmitter} emitter
+ * @param {string | symbol} type
+ * @returns {number}
+ */
 EventEmitter.listenerCount = function(emitter, type) {
   if (typeof emitter.listenerCount === 'function') {
     return emitter.listenerCount(type);
@@ -578,6 +722,13 @@ EventEmitter.listenerCount = function(emitter, type) {
 };
 
 EventEmitter.prototype.listenerCount = listenerCount;
+
+/**
+ * Returns the number of listeners listening to event name
+ * specified as `type`.
+ * @param {string | symbol} type
+ * @returns {number}
+ */
 function listenerCount(type) {
   const events = this._events;
 
@@ -594,6 +745,11 @@ function listenerCount(type) {
   return 0;
 }
 
+/**
+ * Returns an array listing the events for which
+ * the emitter has registered listeners.
+ * @returns {any[]}
+ */
 EventEmitter.prototype.eventNames = function eventNames() {
   return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
 };
@@ -608,7 +764,7 @@ function arrayClone(arr) {
     case 5: return [arr[0], arr[1], arr[2], arr[3], arr[4]];
     case 6: return [arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]];
   }
-  return arr.slice();
+  return ArrayPrototypeSlice(arr);
 }
 
 function unwrapListeners(arr) {
@@ -621,46 +777,98 @@ function unwrapListeners(arr) {
   return ret;
 }
 
-function once(emitter, name) {
-  return new Promise((resolve, reject) => {
-    if (
-      typeof emitter.addEventListener === 'function' &&
-      typeof emitter.on !== 'function'
-    ) {
-      // EventTarget does not have `error` event semantics like Node
-      // EventEmitters, we do not listen to `error` events here.
-      emitter.addEventListener(
-        name,
-        (...args) => { resolve(args); },
-        { once: true }
-      );
-      return;
+/**
+ * Returns a copy of the array of listeners for the event name
+ * specified as `type`.
+ * @param {EventEmitter | EventTarget} emitterOrTarget
+ * @param {string | symbol} type
+ * @returns {Function[]}
+ */
+function getEventListeners(emitterOrTarget, type) {
+  // First check if EventEmitter
+  if (typeof emitterOrTarget.listeners === 'function') {
+    return emitterOrTarget.listeners(type);
+  }
+  // Require event target lazily to avoid always loading it
+  const { isEventTarget, kEvents } = require('internal/event_target');
+  if (isEventTarget(emitterOrTarget)) {
+    const root = emitterOrTarget[kEvents].get(type);
+    const listeners = [];
+    let handler = root?.next;
+    while (handler?.listener !== undefined) {
+      listeners.push(handler.listener);
+      handler = handler.next;
     }
+    return listeners;
+  }
+  throw new ERR_INVALID_ARG_TYPE('emitter',
+                                 ['EventEmitter', 'EventTarget'],
+                                 emitterOrTarget);
+}
 
-    const eventListener = (...args) => {
-      if (errorListener !== undefined) {
+/**
+ * Creates a `Promise` that is fulfilled when the emitter
+ * emits the given event.
+ * @param {EventEmitter} emitter
+ * @param {string} name
+ * @param {{ signal: AbortSignal; }} [options]
+ * @returns {Promise}
+ */
+async function once(emitter, name, options = {}) {
+  const signal = options?.signal;
+  validateAbortSignal(signal, 'options.signal');
+  if (signal?.aborted)
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  return new Promise((resolve, reject) => {
+    const errorListener = (err) => {
+      emitter.removeListener(name, resolver);
+      if (signal != null) {
+        eventTargetAgnosticRemoveListener(
+          signal,
+          'abort',
+          abortListener,
+          { once: true });
+      }
+      reject(err);
+    };
+    const resolver = (...args) => {
+      if (typeof emitter.removeListener === 'function') {
         emitter.removeListener('error', errorListener);
       }
+      if (signal != null) {
+        eventTargetAgnosticRemoveListener(
+          signal,
+          'abort',
+          abortListener,
+          { once: true });
+      }
       resolve(args);
     };
-    let errorListener;
-
-    // Adding an error listener is not optional because
-    // if an error is thrown on an event emitter we cannot
-    // guarantee that the actual event we are waiting will
-    // be fired. The result could be a silent way to create
-    // memory or file descriptor leaks, which is something
-    // we should avoid.
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
     if (name !== 'error') {
-      errorListener = (err) => {
-        emitter.removeListener(name, eventListener);
-        reject(err);
-      };
-
-      emitter.once('error', errorListener);
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+    function abortListener() {
+      if (typeof emitter.removeListener === 'function') {
+        emitter.removeListener(name, resolver);
+        emitter.removeListener('error', errorListener);
+      } else {
+        eventTargetAgnosticRemoveListener(
+          emitter,
+          name,
+          resolver,
+          { once: true });
+        eventTargetAgnosticRemoveListener(
+          emitter,
+          'error',
+          errorListener,
+          { once: true });
+      }
+      reject(lazyDOMException('The operation was aborted', 'AbortError'));
+    }
+    if (signal != null) {
+      signal.addEventListener('abort', abortListener, { once: true });
     }
-
-    emitter.once(name, eventListener);
   });
 }
 
@@ -671,7 +879,52 @@ function createIterResult(value, done) {
   return { value, done };
 }
 
-function on(emitter, event) {
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+  }
+}
+
+function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) {
+  if (typeof emitter.removeListener === 'function') {
+    emitter.removeListener(name, listener);
+  } else if (typeof emitter.removeEventListener === 'function') {
+    emitter.removeEventListener(name, listener, flags);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('emitter', 'EventEmitter', emitter);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+    if (flags?.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === 'function') {
+    // EventTarget does not have `error` event semantics like Node
+    // EventEmitters, we do not listen to `error` events here.
+    emitter.addEventListener(name, (arg) => { listener(arg); }, flags);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('emitter', 'EventEmitter', emitter);
+  }
+}
+
+/**
+ * Returns an `AsyncIterator` that iterates `event` events.
+ * @param {EventEmitter} emitter
+ * @param {string | symbol} event
+ * @param {{ signal: AbortSignal; }} [options]
+ * @returns {AsyncIterator}
+ */
+function on(emitter, event, options) {
+  const signal = options?.signal;
+  validateAbortSignal(signal, 'options.signal');
+  if (signal?.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
+
   const unconsumedEvents = [];
   const unconsumedPromises = [];
   let error = null;
@@ -707,8 +960,17 @@ function on(emitter, event) {
     },
 
     return() {
-      emitter.removeListener(event, eventHandler);
-      emitter.removeListener('error', errorHandler);
+      eventTargetAgnosticRemoveListener(emitter, event, eventHandler);
+      eventTargetAgnosticRemoveListener(emitter, 'error', errorHandler);
+
+      if (signal) {
+        eventTargetAgnosticRemoveListener(
+          signal,
+          'abort',
+          abortListener,
+          { once: true });
+      }
+
       finished = true;
 
       for (const promise of unconsumedPromises) {
@@ -724,8 +986,8 @@ function on(emitter, event) {
                                        'Error', err);
       }
       error = err;
-      emitter.removeListener(event, eventHandler);
-      emitter.removeListener('error', errorHandler);
+      eventTargetAgnosticRemoveListener(emitter, event, eventHandler);
+      eventTargetAgnosticRemoveListener(emitter, 'error', errorHandler);
     },
 
     [SymbolAsyncIterator]() {
@@ -733,11 +995,25 @@ function on(emitter, event) {
     }
   }, AsyncIteratorPrototype);
 
-  emitter.on(event, eventHandler);
-  emitter.on('error', errorHandler);
+  eventTargetAgnosticAddListener(emitter, event, eventHandler);
+  if (event !== 'error') {
+    addErrorHandlerIfEventEmitter(emitter, errorHandler);
+  }
+
+  if (signal) {
+    eventTargetAgnosticAddListener(
+      signal,
+      'abort',
+      abortListener,
+      { once: true });
+  }
 
   return iterator;
 
+  function abortListener() {
+    errorHandler(lazyDOMException('The operation was aborted', 'AbortError'));
+  }
+
   function eventHandler(...args) {
     const promise = unconsumedPromises.shift();
     if (promise) {
diff --git a/lib/fs.js b/lib/fs.js
index 8196e694ae7bd41d53c68d8cab6da41e2b1f2ee7..acd8e10f3908691d5e0c0442fa5052e37c37f2d7 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -24,15 +24,19 @@
 
 'use strict';
 
+// When using FSReqCallback, make sure to create the object only *after* all
+// parameter validation has happened, so that the objects are not kept in memory
+// in case they are created but never used due to an exception.
+
 const {
   Map,
   MathMax,
   Number,
-  NumberIsSafeInteger,
   ObjectCreate,
   ObjectDefineProperties,
   ObjectDefineProperty,
   Promise,
+  String,
 } = primordials;
 
 const { fs: constants } = internalBinding('constants');
@@ -53,14 +57,17 @@ const {
 const pathModule = require('path');
 const { isArrayBufferView } = require('internal/util/types');
 const binding = internalBinding('fs');
-const { Buffer, kMaxLength } = require('buffer');
+const { Buffer } = require('buffer');
 const {
   codes: {
     ERR_FS_FILE_TOO_LARGE,
     ERR_INVALID_ARG_VALUE,
     ERR_INVALID_ARG_TYPE,
-    ERR_INVALID_CALLBACK
+    ERR_INVALID_CALLBACK,
+    ERR_FEATURE_UNAVAILABLE_ON_PLATFORM,
   },
+  hideStackFrames,
+  uvErrmapGet,
   uvException
 } = require('internal/errors');
 
@@ -68,11 +75,16 @@ const { FSReqCallback, statValues } = binding;
 const { toPathIfFileURL } = require('internal/url');
 const internalUtil = require('internal/util');
 const {
+  constants: {
+    kIoMaxLength,
+    kMaxUserId,
+  },
   copyObject,
   Dirent,
   getDirents,
   getOptions,
   getValidatedPath,
+  getValidMode,
   handleErrorFromBinding,
   nullCheck,
   preprocessSymlinkDestination,
@@ -86,7 +98,11 @@ const {
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
   validatePath,
+  validatePosition,
+  validateRmOptions,
+  validateRmOptionsSync,
   validateRmdirOptions,
+  validateStringAfterArrayBufferView,
   warnOnNonPortableTemplate
 } = require('internal/fs/utils');
 const {
@@ -100,13 +116,12 @@ const {
 } = require('internal/constants');
 const {
   isUint32,
-  parseMode,
+  parseFileMode,
   validateBuffer,
   validateInteger,
-  validateInt32
+  validateInt32,
+  validateString,
 } = require('internal/validators');
-// 2 ** 32 - 1
-const kMaxUserId = 4294967295;
 
 let truncateWarn = true;
 let fs;
@@ -119,6 +134,13 @@ let ReadStream;
 let WriteStream;
 let rimraf;
 let rimrafSync;
+let DOMException;
+
+const lazyDOMException = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message, name);
+});
 
 // These have to be separate because of how graceful-fs happens to do it's
 // monkeypatching.
@@ -126,6 +148,7 @@ let FileReadStream;
 let FileWriteStream;
 
 const isWindows = process.platform === 'win32';
+const isOSX = process.platform === 'darwin';
 
 
 function showTruncateDeprecation() {
@@ -188,20 +211,17 @@ function access(path, mode, callback) {
   }
 
   path = getValidatedPath(path);
+  mode = getValidMode(mode, 'access');
+  callback = makeCallback(callback);
 
-  mode = mode | 0;
   const req = new FSReqCallback();
-  req.oncomplete = makeCallback(callback);
+  req.oncomplete = callback;
   binding.access(pathModule.toNamespacedPath(path), mode, req);
 }
 
 function accessSync(path, mode) {
   path = getValidatedPath(path);
-
-  if (mode === undefined)
-    mode = F_OK;
-  else
-    mode = mode | 0;
+  mode = getValidMode(mode, 'access');
 
   const ctx = { path };
   binding.access(pathModule.toNamespacedPath(path), mode, undefined, ctx);
@@ -278,7 +298,7 @@ function readFileAfterStat(err, stats) {
 
   const size = context.size = isFileType(stats, S_IFREG) ? stats[8] : 0;
 
-  if (size > kMaxLength) {
+  if (size > kIoMaxLength) {
     err = new ERR_FS_FILE_TOO_LARGE(size);
     return context.close(err);
   }
@@ -303,20 +323,29 @@ function readFile(path, options, callback) {
   const context = new ReadFileContext(callback, options.encoding);
   context.isUserFd = isFd(path); // File descriptor ownership
 
-  const req = new FSReqCallback();
-  req.context = context;
-  req.oncomplete = readFileAfterOpen;
-
+  if (options.signal) {
+    context.signal = options.signal;
+  }
   if (context.isUserFd) {
-    process.nextTick(function tick() {
-      req.oncomplete(null, path);
-    });
+    process.nextTick(function tick(context) {
+      readFileAfterOpen.call({ context }, null, path);
+    }, context);
     return;
   }
 
+  if (options.signal?.aborted) {
+    callback(lazyDOMException('The operation was aborted', 'AbortError'));
+    return;
+  }
+
+  const flagsNumber = stringToFlags(options.flag);
   path = getValidatedPath(path);
+
+  const req = new FSReqCallback();
+  req.context = context;
+  req.oncomplete = readFileAfterOpen;
   binding.open(pathModule.toNamespacedPath(path),
-               stringToFlags(options.flag || 'r'),
+               flagsNumber,
                0o666,
                req);
 }
@@ -335,7 +364,7 @@ function tryCreateBuffer(size, fd, isUserFd) {
   let threw = true;
   let buffer;
   try {
-    if (size > kMaxLength) {
+    if (size > kIoMaxLength) {
       throw new ERR_FS_FILE_TOO_LARGE(size);
     }
     buffer = Buffer.allocUnsafe(size);
@@ -409,10 +438,17 @@ function readFileSync(path, options) {
   return buffer;
 }
 
-function close(fd, callback) {
+function defaultCloseCallback(err) {
+  if (err != null) throw err;
+}
+
+function close(fd, callback = defaultCloseCallback) {
   validateInt32(fd, 'fd', 0);
+  if (callback !== defaultCloseCallback)
+    callback = makeCallback(callback);
+
   const req = new FSReqCallback();
-  req.oncomplete = makeCallback(callback);
+  req.oncomplete = callback;
   binding.close(fd, req);
 }
 
@@ -433,11 +469,10 @@ function open(path, flags, mode, callback) {
   } else if (typeof mode === 'function') {
     callback = mode;
     mode = 0o666;
+  } else {
+    mode = parseFileMode(mode, 'mode', 0o666);
   }
   const flagsNumber = stringToFlags(flags);
-  if (arguments.length >= 4) {
-    mode = parseMode(mode, 'mode', 0o666);
-  }
   callback = makeCallback(callback);
 
   const req = new FSReqCallback();
@@ -452,8 +487,8 @@ function open(path, flags, mode, callback) {
 
 function openSync(path, flags, mode) {
   path = getValidatedPath(path);
-  const flagsNumber = stringToFlags(flags || 'r');
-  mode = parseMode(mode, 'mode', 0o666);
+  const flagsNumber = stringToFlags(flags);
+  mode = parseFileMode(mode, 'mode', 0o666);
 
   const ctx = { path };
   const result = binding.open(pathModule.toNamespacedPath(path),
@@ -488,7 +523,7 @@ function read(fd, buffer, offset, length, position, callback) {
     ({
       buffer = Buffer.alloc(16384),
       offset = 0,
-      length = buffer.length,
+      length = buffer.byteLength,
       position
     } = options);
   }
@@ -496,7 +531,12 @@ function read(fd, buffer, offset, length, position, callback) {
   validateBuffer(buffer);
   callback = maybeCallback(callback);
 
-  offset |= 0;
+  if (offset == null) {
+    offset = 0;
+  } else {
+    validateInteger(offset, 'offset', 0);
+  }
+
   length |= 0;
 
   if (length === 0) {
@@ -512,9 +552,11 @@ function read(fd, buffer, offset, length, position, callback) {
 
   validateOffsetLengthRead(offset, length, buffer.byteLength);
 
-  if (!NumberIsSafeInteger(position))
+  if (position == null)
     position = -1;
 
+  validatePosition(position, 'position');
+
   function wrapper(err, bytesRead) {
     // Retain a reference to buffer so that it can't be GC'ed too soon.
     callback(err, bytesRead || 0, buffer);
@@ -536,16 +578,21 @@ ObjectDefineProperty(read, internalUtil.customPromisifyArgs,
 function readSync(fd, buffer, offset, length, position) {
   validateInt32(fd, 'fd', 0);
 
+  validateBuffer(buffer);
+
   if (arguments.length <= 3) {
     // Assume fs.read(fd, buffer, options)
     const options = offset || {};
 
-    ({ offset = 0, length = buffer.length, position } = options);
+    ({ offset = 0, length = buffer.byteLength, position } = options);
   }
 
-  validateBuffer(buffer);
+  if (offset == null) {
+    offset = 0;
+  } else {
+    validateInteger(offset, 'offset', 0);
+  }
 
-  offset |= 0;
   length |= 0;
 
   if (length === 0) {
@@ -559,9 +606,11 @@ function readSync(fd, buffer, offset, length, position) {
 
   validateOffsetLengthRead(offset, length, buffer.byteLength);
 
-  if (!NumberIsSafeInteger(position))
+  if (position == null)
     position = -1;
 
+  validatePosition(position, 'position');
+
   const ctx = {};
   const result = binding.read(fd, buffer, offset, length, position,
                               undefined, ctx);
@@ -576,12 +625,11 @@ function readv(fd, buffers, position, callback) {
 
   validateInt32(fd, 'fd', /* min */ 0);
   validateBufferArray(buffers);
+  callback = maybeCallback(callback || position);
 
   const req = new FSReqCallback();
   req.oncomplete = wrapper;
 
-  callback = maybeCallback(callback || position);
-
   if (typeof position !== 'number')
     position = null;
 
@@ -617,23 +665,26 @@ function write(fd, buffer, offset, length, position, callback) {
 
   validateInt32(fd, 'fd', 0);
 
-  const req = new FSReqCallback();
-  req.oncomplete = wrapper;
-
   if (isArrayBufferView(buffer)) {
     callback = maybeCallback(callback || position || length || offset);
-    if (typeof offset !== 'number')
+    if (offset == null || typeof offset === 'function') {
       offset = 0;
+    } else {
+      validateInteger(offset, 'offset', 0);
+    }
     if (typeof length !== 'number')
-      length = buffer.length - offset;
+      length = buffer.byteLength - offset;
     if (typeof position !== 'number')
       position = null;
     validateOffsetLengthWrite(offset, length, buffer.byteLength);
+
+    const req = new FSReqCallback();
+    req.oncomplete = wrapper;
     return binding.writeBuffer(fd, buffer, offset, length, position, req);
   }
 
-  if (typeof buffer !== 'string')
-    buffer += '';
+  validateStringAfterArrayBufferView(buffer, 'buffer');
+
   if (typeof position !== 'function') {
     if (typeof offset === 'function') {
       position = offset;
@@ -644,7 +695,10 @@ function write(fd, buffer, offset, length, position, callback) {
     length = 'utf8';
   }
   callback = maybeCallback(position);
-  return binding.writeString(fd, buffer, offset, length, req);
+
+  const req = new FSReqCallback();
+  req.oncomplete = wrapper;
+  return binding.writeString(fd, String(buffer), offset, length, req);
 }
 
 ObjectDefineProperty(write, internalUtil.customPromisifyArgs,
@@ -661,16 +715,19 @@ function writeSync(fd, buffer, offset, length, position) {
   if (isArrayBufferView(buffer)) {
     if (position === undefined)
       position = null;
-    if (typeof offset !== 'number')
+    if (offset == null) {
       offset = 0;
+    } else {
+      validateInteger(offset, 'offset', 0);
+    }
     if (typeof length !== 'number')
       length = buffer.byteLength - offset;
     validateOffsetLengthWrite(offset, length, buffer.byteLength);
     result = binding.writeBuffer(fd, buffer, offset, length, position,
                                  undefined, ctx);
   } else {
-    if (typeof buffer !== 'string')
-      buffer += '';
+    validateStringAfterArrayBufferView(buffer, 'buffer');
+
     if (offset === undefined)
       offset = null;
     result = binding.writeString(fd, buffer, offset, length,
@@ -689,12 +746,11 @@ function writev(fd, buffers, position, callback) {
 
   validateInt32(fd, 'fd', 0);
   validateBufferArray(buffers);
+  callback = maybeCallback(callback || position);
 
   const req = new FSReqCallback();
   req.oncomplete = wrapper;
 
-  callback = maybeCallback(callback || position);
-
   if (typeof position !== 'number')
     position = null;
 
@@ -754,6 +810,7 @@ function truncate(path, len, callback) {
   }
 
   validateInteger(len, 'len');
+  len = MathMax(0, len);
   callback = maybeCallback(callback);
   fs.open(path, 'r+', (er, fd) => {
     if (er) return callback(er);
@@ -796,8 +853,10 @@ function ftruncate(fd, len = 0, callback) {
   validateInt32(fd, 'fd', 0);
   validateInteger(len, 'len');
   len = MathMax(0, len);
+  callback = makeCallback(callback);
+
   const req = new FSReqCallback();
-  req.oncomplete = makeCallback(callback);
+  req.oncomplete = callback;
   binding.ftruncate(fd, len, req);
 }
 
@@ -824,30 +883,59 @@ function rmdir(path, options, callback) {
 
   callback = makeCallback(callback);
   path = pathModule.toNamespacedPath(getValidatedPath(path));
-  options = validateRmdirOptions(options);
 
-  if (options.recursive) {
-    lazyLoadRimraf();
-    return rimraf(path, options, callback);
-  }
+  if (options && options.recursive) {
+    validateRmOptions(path, { ...options, force: true }, (err, options) => {
+      if (err) {
+        return callback(err);
+      }
 
-  const req = new FSReqCallback();
-  req.oncomplete = callback;
-  binding.rmdir(path, req);
+      lazyLoadRimraf();
+      return rimraf(path, options, callback);
+    });
+  } else {
+    validateRmdirOptions(options);
+    const req = new FSReqCallback();
+    req.oncomplete = callback;
+    return binding.rmdir(path, req);
+  }
 }
 
 function rmdirSync(path, options) {
   path = getValidatedPath(path);
-  options = validateRmdirOptions(options);
 
-  if (options.recursive) {
+  if (options && options.recursive) {
+    options = validateRmOptionsSync(path, { ...options, force: true });
     lazyLoadRimraf();
     return rimrafSync(pathModule.toNamespacedPath(path), options);
   }
 
+  validateRmdirOptions(options);
   const ctx = { path };
   binding.rmdir(pathModule.toNamespacedPath(path), undefined, ctx);
-  handleErrorFromBinding(ctx);
+  return handleErrorFromBinding(ctx);
+}
+
+function rm(path, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = undefined;
+  }
+
+  validateRmOptions(path, options, (err, options) => {
+    if (err) {
+      return callback(err);
+    }
+    lazyLoadRimraf();
+    return rimraf(pathModule.toNamespacedPath(path), options, callback);
+  });
+}
+
+function rmSync(path, options) {
+  options = validateRmOptionsSync(path, options);
+
+  lazyLoadRimraf();
+  return rimrafSync(pathModule.toNamespacedPath(path), options);
 }
 
 function fdatasync(fd, callback) {
@@ -879,16 +967,18 @@ function fsyncSync(fd) {
 }
 
 function mkdir(path, options, callback) {
+  let mode = 0o777;
+  let recursive = false;
   if (typeof options === 'function') {
     callback = options;
-    options = {};
   } else if (typeof options === 'number' || typeof options === 'string') {
-    options = { mode: options };
+    mode = options;
+  } else if (options) {
+    if (options.recursive !== undefined)
+      recursive = options.recursive;
+    if (options.mode !== undefined)
+      mode = options.mode;
   }
-  const {
-    recursive = false,
-    mode = 0o777
-  } = options || {};
   callback = makeCallback(callback);
   path = getValidatedPath(path);
 
@@ -898,25 +988,27 @@ function mkdir(path, options, callback) {
   const req = new FSReqCallback();
   req.oncomplete = callback;
   binding.mkdir(pathModule.toNamespacedPath(path),
-                parseMode(mode, 'mode', 0o777), recursive, req);
+                parseFileMode(mode, 'mode'), recursive, req);
 }
 
 function mkdirSync(path, options) {
+  let mode = 0o777;
+  let recursive = false;
   if (typeof options === 'number' || typeof options === 'string') {
-    options = { mode: options };
+    mode = options;
+  } else if (options) {
+    if (options.recursive !== undefined)
+      recursive = options.recursive;
+    if (options.mode !== undefined)
+      mode = options.mode;
   }
-  const {
-    recursive = false,
-    mode = 0o777
-  } = options || {};
-
   path = getValidatedPath(path);
   if (typeof recursive !== 'boolean')
     throw new ERR_INVALID_ARG_TYPE('options.recursive', 'boolean', recursive);
 
   const ctx = { path };
   const result = binding.mkdir(pathModule.toNamespacedPath(path),
-                               parseMode(mode, 'mode', 0o777), recursive,
+                               parseFileMode(mode, 'mode'), recursive,
                                undefined, ctx);
   handleErrorFromBinding(ctx);
   if (recursive) {
@@ -962,8 +1054,10 @@ function fstat(fd, options = { bigint: false }, callback) {
     options = {};
   }
   validateInt32(fd, 'fd', 0);
+  callback = makeStatsCallback(callback);
+
   const req = new FSReqCallback(options.bigint);
-  req.oncomplete = makeStatsCallback(callback);
+  req.oncomplete = callback;
   binding.fstat(fd, options.bigint, req);
 }
 
@@ -974,6 +1068,7 @@ function lstat(path, options = { bigint: false }, callback) {
   }
   callback = makeStatsCallback(callback);
   path = getValidatedPath(path);
+
   const req = new FSReqCallback(options.bigint);
   req.oncomplete = callback;
   binding.lstat(pathModule.toNamespacedPath(path), options.bigint, req);
@@ -986,12 +1081,26 @@ function stat(path, options = { bigint: false }, callback) {
   }
   callback = makeStatsCallback(callback);
   path = getValidatedPath(path);
+
   const req = new FSReqCallback(options.bigint);
   req.oncomplete = callback;
   binding.stat(pathModule.toNamespacedPath(path), options.bigint, req);
 }
 
-function fstatSync(fd, options = { bigint: false }) {
+function hasNoEntryError(ctx) {
+  if (ctx.errno) {
+    const uvErr = uvErrmapGet(ctx.errno);
+    return uvErr && uvErr[0] === 'ENOENT';
+  }
+
+  if (ctx.error) {
+    return ctx.error.code === 'ENOENT';
+  }
+
+  return false;
+}
+
+function fstatSync(fd, options = { bigint: false, throwIfNoEntry: true }) {
   validateInt32(fd, 'fd', 0);
   const ctx = { fd };
   const stats = binding.fstat(fd, options.bigint, undefined, ctx);
@@ -999,20 +1108,26 @@ function fstatSync(fd, options = { bigint: false }) {
   return getStatsFromBinding(stats);
 }
 
-function lstatSync(path, options = { bigint: false }) {
+function lstatSync(path, options = { bigint: false, throwIfNoEntry: true }) {
   path = getValidatedPath(path);
   const ctx = { path };
   const stats = binding.lstat(pathModule.toNamespacedPath(path),
                               options.bigint, undefined, ctx);
+  if (options.throwIfNoEntry === false && hasNoEntryError(ctx)) {
+    return undefined;
+  }
   handleErrorFromBinding(ctx);
   return getStatsFromBinding(stats);
 }
 
-function statSync(path, options = { bigint: false }) {
+function statSync(path, options = { bigint: false, throwIfNoEntry: true }) {
   path = getValidatedPath(path);
   const ctx = { path };
   const stats = binding.stat(pathModule.toNamespacedPath(path),
                              options.bigint, undefined, ctx);
+  if (options.throwIfNoEntry === false && hasNoEntryError(ctx)) {
+    return undefined;
+  }
   handleErrorFromBinding(ctx);
   return getStatsFromBinding(stats);
 }
@@ -1043,9 +1158,6 @@ function symlink(target, path, type_, callback_) {
   target = getValidatedPath(target, 'target');
   path = getValidatedPath(path);
 
-  const req = new FSReqCallback();
-  req.oncomplete = callback;
-
   if (isWindows && type === null) {
     let absoluteTarget;
     try {
@@ -1060,18 +1172,25 @@ function symlink(target, path, type_, callback_) {
       stat(absoluteTarget, (err, stat) => {
         const resolvedType = !err && stat.isDirectory() ? 'dir' : 'file';
         const resolvedFlags = stringToSymlinkType(resolvedType);
-        binding.symlink(preprocessSymlinkDestination(target,
-                                                     resolvedType,
-                                                     path),
+        const destination = preprocessSymlinkDestination(target,
+                                                         resolvedType,
+                                                         path);
+
+        const req = new FSReqCallback();
+        req.oncomplete = callback;
+        binding.symlink(destination,
                         pathModule.toNamespacedPath(path), resolvedFlags, req);
       });
       return;
     }
   }
 
+  const destination = preprocessSymlinkDestination(target, type, path);
+
   const flags = stringToSymlinkType(type);
-  binding.symlink(preprocessSymlinkDestination(target, type, path),
-                  pathModule.toNamespacedPath(path), flags, req);
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.symlink(destination, pathModule.toNamespacedPath(path), flags, req);
 }
 
 function symlinkSync(target, path, type) {
@@ -1138,7 +1257,7 @@ function unlinkSync(path) {
 
 function fchmod(fd, mode, callback) {
   validateInt32(fd, 'fd', 0);
-  mode = parseMode(mode, 'mode');
+  mode = parseFileMode(mode, 'mode');
   callback = makeCallback(callback);
 
   const req = new FSReqCallback();
@@ -1148,7 +1267,7 @@ function fchmod(fd, mode, callback) {
 
 function fchmodSync(fd, mode) {
   validateInt32(fd, 'fd', 0);
-  mode = parseMode(mode, 'mode');
+  mode = parseFileMode(mode, 'mode');
   const ctx = {};
   binding.fchmod(fd, mode, undefined, ctx);
   handleErrorFromBinding(ctx);
@@ -1188,7 +1307,7 @@ function lchmodSync(path, mode) {
 
 function chmod(path, mode, callback) {
   path = getValidatedPath(path);
-  mode = parseMode(mode, 'mode');
+  mode = parseFileMode(mode, 'mode');
   callback = makeCallback(callback);
 
   const req = new FSReqCallback();
@@ -1198,7 +1317,7 @@ function chmod(path, mode, callback) {
 
 function chmodSync(path, mode) {
   path = getValidatedPath(path);
-  mode = parseMode(mode, 'mode');
+  mode = parseFileMode(mode, 'mode');
 
   const ctx = { path };
   binding.chmod(pathModule.toNamespacedPath(path), mode, undefined, ctx);
@@ -1228,9 +1347,10 @@ function fchown(fd, uid, gid, callback) {
   validateInt32(fd, 'fd', 0);
   validateInteger(uid, 'uid', -1, kMaxUserId);
   validateInteger(gid, 'gid', -1, kMaxUserId);
+  callback = makeCallback(callback);
 
   const req = new FSReqCallback();
-  req.oncomplete = makeCallback(callback);
+  req.oncomplete = callback;
   binding.fchown(fd, uid, gid, req);
 }
 
@@ -1289,8 +1409,10 @@ function futimes(fd, atime, mtime, callback) {
   validateInt32(fd, 'fd', 0);
   atime = toUnixTimestamp(atime, 'atime');
   mtime = toUnixTimestamp(mtime, 'mtime');
+  callback = makeCallback(callback);
+
   const req = new FSReqCallback();
-  req.oncomplete = makeCallback(callback);
+  req.oncomplete = callback;
   binding.futimes(fd, atime, mtime, req);
 }
 
@@ -1325,7 +1447,17 @@ function lutimesSync(path, atime, mtime) {
   handleErrorFromBinding(ctx);
 }
 
-function writeAll(fd, isUserFd, buffer, offset, length, callback) {
+function writeAll(fd, isUserFd, buffer, offset, length, signal, callback) {
+  if (signal?.aborted) {
+    if (isUserFd) {
+      callback(lazyDOMException('The operation was aborted', 'AbortError'));
+    } else {
+      fs.close(fd, function() {
+        callback(lazyDOMException('The operation was aborted', 'AbortError'));
+      });
+    }
+    return;
+  }
   // write(fd, buffer, offset, length, position, callback)
   fs.write(fd, buffer, offset, length, null, (writeErr, written) => {
     if (writeErr) {
@@ -1345,7 +1477,7 @@ function writeAll(fd, isUserFd, buffer, offset, length, callback) {
     } else {
       offset += written;
       length -= written;
-      writeAll(fd, isUserFd, buffer, offset, length, callback);
+      writeAll(fd, isUserFd, buffer, offset, length, signal, callback);
     }
   });
 }
@@ -1355,37 +1487,46 @@ function writeFile(path, data, options, callback) {
   options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'w' });
   const flag = options.flag || 'w';
 
+  if (!isArrayBufferView(data)) {
+    validateStringAfterArrayBufferView(data, 'data');
+    data = Buffer.from(String(data), options.encoding || 'utf8');
+  }
+
   if (isFd(path)) {
-    writeFd(path, true);
+    const isUserFd = true;
+    const signal = options.signal;
+    writeAll(path, isUserFd, data, 0, data.byteLength, signal, callback);
     return;
   }
 
+  if (options.signal?.aborted) {
+    callback(lazyDOMException('The operation was aborted', 'AbortError'));
+    return;
+  }
   fs.open(path, flag, options.mode, (openErr, fd) => {
     if (openErr) {
       callback(openErr);
     } else {
-      writeFd(fd, false);
+      const isUserFd = false;
+      const signal = options.signal;
+      writeAll(fd, isUserFd, data, 0, data.byteLength, signal, callback);
     }
   });
-
-  function writeFd(fd, isUserFd) {
-    const buffer = isArrayBufferView(data) ?
-      data : Buffer.from('' + data, options.encoding || 'utf8');
-
-    writeAll(fd, isUserFd, buffer, 0, buffer.byteLength, callback);
-  }
 }
 
 function writeFileSync(path, data, options) {
   options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'w' });
+
+  if (!isArrayBufferView(data)) {
+    validateStringAfterArrayBufferView(data, 'data');
+    data = Buffer.from(String(data), options.encoding || 'utf8');
+  }
+
   const flag = options.flag || 'w';
 
   const isUserFd = isFd(path); // File descriptor ownership
   const fd = isUserFd ? path : fs.openSync(path, flag, options.mode);
 
-  if (!isArrayBufferView(data)) {
-    data = Buffer.from('' + data, options.encoding || 'utf8');
-  }
   let offset = 0;
   let length = data.byteLength;
   try {
@@ -1437,18 +1578,30 @@ function watch(filename, options, listener) {
 
   if (options.persistent === undefined) options.persistent = true;
   if (options.recursive === undefined) options.recursive = false;
-
+  if (options.recursive && !(isOSX || isWindows))
+    throw new ERR_FEATURE_UNAVAILABLE_ON_PLATFORM('watch recursively');
   if (!watchers)
     watchers = require('internal/fs/watchers');
   const watcher = new watchers.FSWatcher();
-  watcher.start(filename,
-                options.persistent,
-                options.recursive,
-                options.encoding);
+  watcher[watchers.kFSWatchStart](filename,
+                                  options.persistent,
+                                  options.recursive,
+                                  options.encoding);
 
   if (listener) {
     watcher.addListener('change', listener);
   }
+  if (options.signal) {
+    if (options.signal.aborted) {
+      process.nextTick(() => watcher.close());
+    } else {
+      const listener = () => watcher.close();
+      options.signal.addEventListener('abort', listener);
+      watcher.once('close', () => {
+        options.signal.removeEventListener('abort', listener);
+      });
+    }
+  }
 
   return watcher;
 }
@@ -1485,7 +1638,8 @@ function watchFile(filename, options, listener) {
     if (!watchers)
       watchers = require('internal/fs/watchers');
     stat = new watchers.StatWatcher(options.bigint);
-    stat.start(filename, options.persistent, options.interval);
+    stat[watchers.kFSStatWatcherStart](filename,
+                                       options.persistent, options.interval);
     statWatchers.set(filename, stat);
   } else {
     stat[watchers.kFSStatWatcherAddOrCleanRef]('add');
@@ -1847,9 +2001,8 @@ realpath.native = (path, options, callback) => {
 function mkdtemp(prefix, options, callback) {
   callback = makeCallback(typeof options === 'function' ? options : callback);
   options = getOptions(options, {});
-  if (!prefix || typeof prefix !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('prefix', 'string', prefix);
-  }
+
+  validateString(prefix, 'prefix');
   nullCheck(prefix, 'prefix');
   warnOnNonPortableTemplate(prefix);
   const req = new FSReqCallback();
@@ -1860,9 +2013,8 @@ function mkdtemp(prefix, options, callback) {
 
 function mkdtempSync(prefix, options) {
   options = getOptions(options, {});
-  if (!prefix || typeof prefix !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('prefix', 'string', prefix);
-  }
+
+  validateString(prefix, 'prefix');
   nullCheck(prefix, 'prefix');
   warnOnNonPortableTemplate(prefix);
   const path = `${prefix}XXXXXX`;
@@ -1874,10 +2026,10 @@ function mkdtempSync(prefix, options) {
 }
 
 
-function copyFile(src, dest, flags, callback) {
-  if (typeof flags === 'function') {
-    callback = flags;
-    flags = 0;
+function copyFile(src, dest, mode, callback) {
+  if (typeof mode === 'function') {
+    callback = mode;
+    mode = 0;
   } else if (typeof callback !== 'function') {
     throw new ERR_INVALID_CALLBACK(callback);
   }
@@ -1887,14 +2039,16 @@ function copyFile(src, dest, flags, callback) {
 
   src = pathModule._makeLong(src);
   dest = pathModule._makeLong(dest);
-  flags = flags | 0;
+  mode = getValidMode(mode, 'copyFile');
+  callback = makeCallback(callback);
+
   const req = new FSReqCallback();
-  req.oncomplete = makeCallback(callback);
-  binding.copyFile(src, dest, flags, req);
+  req.oncomplete = callback;
+  binding.copyFile(src, dest, mode, req);
 }
 
 
-function copyFileSync(src, dest, flags) {
+function copyFileSync(src, dest, mode) {
   src = getValidatedPath(src, 'src');
   dest = getValidatedPath(dest, 'dest');
 
@@ -1902,15 +2056,16 @@ function copyFileSync(src, dest, flags) {
 
   src = pathModule._makeLong(src);
   dest = pathModule._makeLong(dest);
-  flags = flags | 0;
-  binding.copyFile(src, dest, flags, undefined, ctx);
+  mode = getValidMode(mode, 'copyFile');
+  binding.copyFile(src, dest, mode, undefined, ctx);
   handleErrorFromBinding(ctx);
 }
 
 function lazyLoadStreams() {
   if (!ReadStream) {
     ({ ReadStream, WriteStream } = require('internal/fs/streams'));
-    [ FileReadStream, FileWriteStream ] = [ ReadStream, WriteStream ];
+    FileReadStream = ReadStream;
+    FileWriteStream = WriteStream;
   }
 }
 
@@ -1987,6 +2142,8 @@ module.exports = fs = {
   realpathSync,
   rename,
   renameSync,
+  rm,
+  rmSync,
   rmdir,
   rmdirSync,
   stat,
diff --git a/lib/fs/promises.js b/lib/fs/promises.js
new file mode 100644
index 0000000000000000000000000000000000000000..1fa3a185deac02c90615875695aa9a8f7c87f84e
--- /dev/null
+++ b/lib/fs/promises.js
@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('internal/fs/promises').exports;
diff --git a/lib/http.js b/lib/http.js
index 55c655763d264706bbddec122ff28fad9fa6665e..07b65d76e1bd2fc060998dcdae37375f0e88d2ab 100644
--- a/lib/http.js
+++ b/lib/http.js
@@ -29,7 +29,11 @@ const httpAgent = require('_http_agent');
 const { ClientRequest } = require('_http_client');
 const { methods } = require('_http_common');
 const { IncomingMessage } = require('_http_incoming');
-const { OutgoingMessage } = require('_http_outgoing');
+const {
+  validateHeaderName,
+  validateHeaderValue,
+  OutgoingMessage
+} = require('_http_outgoing');
 const {
   _connectionListener,
   STATUS_CODES,
@@ -38,14 +42,65 @@ const {
 } = require('_http_server');
 let maxHeaderSize;
 
+/**
+ * Returns a new instance of `http.Server`.
+ * @param {{
+ *   IncomingMessage?: IncomingMessage;
+ *   ServerResponse?: ServerResponse;
+ *   insecureHTTPParser?: boolean;
+ *   maxHeaderSize?: number;
+ *   }} [opts]
+ * @param {Function} [requestListener]
+ * @returns {Server}
+ */
 function createServer(opts, requestListener) {
   return new Server(opts, requestListener);
 }
 
+/**
+ * @typedef {Object} HTTPRequestOptions
+ * @property {httpAgent.Agent | boolean} [agent]
+ * @property {string} [auth]
+ * @property {Function} [createConnection]
+ * @property {number} [defaultPort]
+ * @property {number} [family]
+ * @property {Object} [headers]
+ * @property {number} [hints]
+ * @property {string} [host]
+ * @property {string} [hostname]
+ * @property {boolean} [insecureHTTPParser]
+ * @property {string} [localAddress]
+ * @property {number} [localPort]
+ * @property {Function} [lookup]
+ * @property {number} [maxHeaderSize]
+ * @property {string} [method]
+ * @property {string} [path]
+ * @property {number} [port]
+ * @property {string} [protocol]
+ * @property {boolean} [setHost]
+ * @property {string} [socketPath]
+ * @property {number} [timeout]
+ * @property {AbortSignal} [signal]
+ */
+
+/**
+ * Makes an HTTP request.
+ * @param {string | URL} url
+ * @param {HTTPRequestOptions} [options]
+ * @param {Function} [cb]
+ * @returns {ClientRequest}
+ */
 function request(url, options, cb) {
   return new ClientRequest(url, options, cb);
 }
 
+/**
+ * Makes a `GET` HTTP request.
+ * @param {string | URL} url
+ * @param {HTTPRequestOptions} [options]
+ * @param {Function} [cb]
+ * @returns {ClientRequest}
+ */
 function get(url, options, cb) {
   const req = request(url, options, cb);
   req.end();
@@ -63,6 +118,8 @@ module.exports = {
   Server,
   ServerResponse,
   createServer,
+  validateHeaderName,
+  validateHeaderValue,
   get,
   request
 };
diff --git a/lib/http2.js b/lib/http2.js
index c3ecd82072ee531b547cbeb396683b70c7b98360..14b4f57acdabd12d31c4719a963b8c5c99f1b031 100644
--- a/lib/http2.js
+++ b/lib/http2.js
@@ -8,6 +8,7 @@ const {
   getDefaultSettings,
   getPackedSettings,
   getUnpackedSettings,
+  sensitiveHeaders,
   Http2ServerRequest,
   Http2ServerResponse
 } = require('internal/http2/core');
@@ -20,6 +21,7 @@ module.exports = {
   getDefaultSettings,
   getPackedSettings,
   getUnpackedSettings,
+  sensitiveHeaders,
   Http2ServerRequest,
   Http2ServerResponse
 };
diff --git a/lib/https.js b/lib/https.js
index 47d59d1984ebbb537a0734b4f9b6a4c0ecfe5c93..a90cdd2a4788595d36cff6b52730508f5e818e7e 100644
--- a/lib/https.js
+++ b/lib/https.js
@@ -22,8 +22,16 @@
 'use strict';
 
 const {
+  ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypeShift,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  FunctionPrototypeCall,
+  JSONStringify,
   ObjectAssign,
   ObjectSetPrototypeOf,
+  ReflectConstruct,
 } = primordials;
 
 require('internal/util').assertCrypto();
@@ -33,20 +41,14 @@ const url = require('url');
 const { Agent: HttpAgent } = require('_http_agent');
 const {
   Server: HttpServer,
+  storeHTTPOptions,
   _connectionListener,
-  kServerResponse
 } = require('_http_server');
 const { ClientRequest } = require('_http_client');
 let debug = require('internal/util/debuglog').debuglog('https', (fn) => {
   debug = fn;
 });
-const { URL, urlToOptions, searchParamsSymbol } = require('internal/url');
-const { IncomingMessage, ServerResponse } = require('http');
-const { kIncomingMessage } = require('_http_common');
-const { getOptionValue } = require('internal/options');
-
-const kDefaultHttpServerTimeout =
-  getOptionValue('--http-server-default-timeout');
+const { URL, urlToHttpOptions, searchParamsSymbol } = require('internal/url');
 
 function Server(opts, requestListener) {
   if (!(this instanceof Server)) return new Server(opts, requestListener);
@@ -64,10 +66,8 @@ function Server(opts, requestListener) {
     opts.ALPNProtocols = ['http/1.1'];
   }
 
-  this[kIncomingMessage] = opts.IncomingMessage || IncomingMessage;
-  this[kServerResponse] = opts.ServerResponse || ServerResponse;
-
-  tls.Server.call(this, opts, _connectionListener);
+  FunctionPrototypeCall(storeHTTPOptions, this, opts);
+  FunctionPrototypeCall(tls.Server, this, opts, _connectionListener);
 
   this.httpAllowHalfOpen = false;
 
@@ -80,16 +80,28 @@ function Server(opts, requestListener) {
       conn.destroy(err);
   });
 
-  this.timeout = kDefaultHttpServerTimeout;
+  this.timeout = 0;
   this.keepAliveTimeout = 5000;
   this.maxHeadersCount = null;
   this.headersTimeout = 60 * 1000; // 60 seconds
+  this.requestTimeout = 0;
 }
 ObjectSetPrototypeOf(Server.prototype, tls.Server.prototype);
 ObjectSetPrototypeOf(Server, tls.Server);
 
 Server.prototype.setTimeout = HttpServer.prototype.setTimeout;
 
+/**
+ * Creates a new `https.Server` instance.
+ * @param {{
+ *   IncomingMessage?: IncomingMessage;
+ *   ServerResponse?: ServerResponse;
+ *   insecureHTTPParser?: boolean;
+ *   maxHeaderSize?: number;
+ *   }} [opts]
+ * @param {Function} [requestListener]
+ * @returns {Server}
+ */
 function createServer(opts, requestListener) {
   return new Server(opts, requestListener);
 }
@@ -147,12 +159,26 @@ function createConnection(port, host, options) {
   return socket;
 }
 
-
+/**
+ * Creates a new `HttpAgent` instance.
+ * @param {{
+ *   keepAlive?: boolean;
+ *   keepAliveMsecs?: number;
+ *   maxSockets?: number;
+ *   maxTotalSockets?: number;
+ *   maxFreeSockets?: number;
+ *   scheduling?: string;
+ *   timeout?: number;
+ *   maxCachedSessions?: number;
+ *   servername?: string;
+ *   }} [options]
+ * @returns {Agent}
+ */
 function Agent(options) {
   if (!(this instanceof Agent))
     return new Agent(options);
 
-  HttpAgent.call(this, options);
+  FunctionPrototypeCall(HttpAgent, this, options);
   this.defaultPort = 443;
   this.protocol = 'https:';
   this.maxCachedSessions = this.options.maxCachedSessions;
@@ -168,8 +194,18 @@ ObjectSetPrototypeOf(Agent.prototype, HttpAgent.prototype);
 ObjectSetPrototypeOf(Agent, HttpAgent);
 Agent.prototype.createConnection = createConnection;
 
+/**
+ * Gets a unique name for a set of options.
+ * @param {{
+ *   host: string;
+ *   port: number;
+ *   localAddress: string;
+ *   family: number;
+ *   }} [options]
+ * @returns {string}
+ */
 Agent.prototype.getName = function getName(options) {
-  let name = HttpAgent.prototype.getName.call(this, options);
+  let name = FunctionPrototypeCall(HttpAgent.prototype.getName, this, options);
 
   name += ':';
   if (options.ca)
@@ -239,6 +275,18 @@ Agent.prototype.getName = function getName(options) {
   if (options.sessionIdContext)
     name += options.sessionIdContext;
 
+  name += ':';
+  if (options.sigalgs)
+    name += JSONStringify(options.sigalgs);
+
+  name += ':';
+  if (options.privateKeyIdentifier)
+    name += options.privateKeyIdentifier;
+
+  name += ':';
+  if (options.privateKeyEngine)
+    name += options.privateKeyEngine;
+
   return name;
 };
 
@@ -259,34 +307,40 @@ Agent.prototype._cacheSession = function _cacheSession(key, session) {
 
   // Put new entry
   if (this._sessionCache.list.length >= this.maxCachedSessions) {
-    const oldKey = this._sessionCache.list.shift();
+    const oldKey = ArrayPrototypeShift(this._sessionCache.list);
     debug('evicting %j', oldKey);
     delete this._sessionCache.map[oldKey];
   }
 
-  this._sessionCache.list.push(key);
+  ArrayPrototypePush(this._sessionCache.list, key);
   this._sessionCache.map[key] = session;
 };
 
 Agent.prototype._evictSession = function _evictSession(key) {
-  const index = this._sessionCache.list.indexOf(key);
+  const index = ArrayPrototypeIndexOf(this._sessionCache.list, key);
   if (index === -1)
     return;
 
-  this._sessionCache.list.splice(index, 1);
+  ArrayPrototypeSplice(this._sessionCache.list, index, 1);
   delete this._sessionCache.map[key];
 };
 
 const globalAgent = new Agent();
 
 let urlWarningEmitted = false;
+
+/**
+ * Makes a request to a secure web server.
+ * @param {...any} args
+ * @returns {ClientRequest}
+ */
 function request(...args) {
   let options = {};
 
   if (typeof args[0] === 'string') {
-    const urlStr = args.shift();
+    const urlStr = ArrayPrototypeShift(args);
     try {
-      options = urlToOptions(new URL(urlStr));
+      options = urlToHttpOptions(new URL(urlStr));
     } catch (err) {
       options = url.parse(urlStr);
       if (!options.hostname) {
@@ -303,19 +357,49 @@ function request(...args) {
   } else if (args[0] && args[0][searchParamsSymbol] &&
              args[0][searchParamsSymbol][searchParamsSymbol]) {
     // url.URL instance
-    options = urlToOptions(args.shift());
+    options = urlToHttpOptions(ArrayPrototypeShift(args));
   }
 
   if (args[0] && typeof args[0] !== 'function') {
-    ObjectAssign(options, args.shift());
+    ObjectAssign(options, ArrayPrototypeShift(args));
   }
 
   options._defaultAgent = module.exports.globalAgent;
-  args.unshift(options);
+  ArrayPrototypeUnshift(args, options);
 
-  return new ClientRequest(...args);
+  return ReflectConstruct(ClientRequest, args);
 }
 
+/**
+ * Makes a GET request to a secure web server.
+ * @param {string | URL} input
+ * @param {{
+ *   agent?: Agent | boolean;
+ *   auth?: string;
+ *   createConnection?: Function;
+ *   defaultPort?: number;
+ *   family?: number;
+ *   headers?: Object;
+ *   hints?: number;
+ *   host?: string;
+ *   hostname?: string;
+ *   insecureHTTPParser?: boolean;
+ *   localAddress?: string;
+ *   localPort?: number;
+ *   lookup?: Function;
+ *   maxHeaderSize?: number;
+ *   method?: string;
+ *   path?: string;
+ *   port?: number;
+ *   protocol?: string;
+ *   setHost?: boolean;
+ *   socketPath?: string;
+ *   timeout?: number;
+ *   signal?: AbortSignal;
+ *   } | string | URL} [options]
+ * @param {Function} [cb]
+ * @returns {ClientRequest}
+ */
 function get(input, options, cb) {
   const req = request(input, options, cb);
   req.end();
diff --git a/lib/inspector.js b/lib/inspector.js
index 60640bc1fb645658df480fa4002ec353549441ed..007822ffa20f0dd2b4600b182ef2d09c9bbc5b1a 100644
--- a/lib/inspector.js
+++ b/lib/inspector.js
@@ -3,7 +3,7 @@
 const {
   JSONParse,
   JSONStringify,
-  Map,
+  SafeMap,
   Symbol,
 } = primordials;
 
@@ -48,7 +48,7 @@ class Session extends EventEmitter {
     super();
     this[connectionSymbol] = null;
     this[nextIdSymbol] = 1;
-    this[messageCallbacksSymbol] = new Map();
+    this[messageCallbacksSymbol] = new SafeMap();
   }
 
   connect() {
diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
new file mode 100644
index 0000000000000000000000000000000000000000..0db98f903a1556fc3f7fdf6a508d0546d549bfab
--- /dev/null
+++ b/lib/internal/abort_controller.js
@@ -0,0 +1,150 @@
+'use strict';
+
+// Modeled very closely on the AbortController implementation
+// in https://github.com/mysticatea/abort-controller (MIT license)
+
+const {
+  ObjectAssign,
+  ObjectDefineProperties,
+  ObjectSetPrototypeOf,
+  ObjectDefineProperty,
+  Symbol,
+  SymbolToStringTag,
+  TypeError,
+} = primordials;
+
+const {
+  defineEventHandler,
+  EventTarget,
+  Event,
+  kTrustEvent
+} = require('internal/event_target');
+const {
+  customInspectSymbol,
+  emitExperimentalWarning
+} = require('internal/util');
+const { inspect } = require('internal/util/inspect');
+const {
+  codes: {
+    ERR_INVALID_THIS,
+  }
+} = require('internal/errors');
+
+const kAborted = Symbol('kAborted');
+
+function customInspect(self, obj, depth, options) {
+  if (depth < 0)
+    return self;
+
+  const opts = ObjectAssign({}, options, {
+    depth: options.depth === null ? null : options.depth - 1
+  });
+
+  return `${self.constructor.name} ${inspect(obj, opts)}`;
+}
+
+function validateAbortSignal(obj) {
+  if (obj?.[kAborted] === undefined)
+    throw new ERR_INVALID_THIS('AbortSignal');
+}
+
+class AbortSignal extends EventTarget {
+  constructor() {
+    // eslint-disable-next-line no-restricted-syntax
+    throw new TypeError('Illegal constructor');
+  }
+
+  get aborted() {
+    validateAbortSignal(this);
+    return !!this[kAborted];
+  }
+
+  [customInspectSymbol](depth, options) {
+    return customInspect(this, {
+      aborted: this.aborted
+    }, depth, options);
+  }
+
+  static abort() {
+    return createAbortSignal(true);
+  }
+}
+
+ObjectDefineProperties(AbortSignal.prototype, {
+  aborted: { enumerable: true }
+});
+
+ObjectDefineProperty(AbortSignal.prototype, SymbolToStringTag, {
+  writable: false,
+  enumerable: false,
+  configurable: true,
+  value: 'AbortSignal',
+});
+
+defineEventHandler(AbortSignal.prototype, 'abort');
+
+function createAbortSignal(aborted = false) {
+  const signal = new EventTarget();
+  ObjectSetPrototypeOf(signal, AbortSignal.prototype);
+  signal[kAborted] = aborted;
+  return signal;
+}
+
+function abortSignal(signal) {
+  if (signal[kAborted]) return;
+  signal[kAborted] = true;
+  const event = new Event('abort', {
+    [kTrustEvent]: true
+  });
+  signal.dispatchEvent(event);
+}
+
+// TODO(joyeecheung): V8 snapshot does not support instance member
+// initializers for now:
+// https://bugs.chromium.org/p/v8/issues/detail?id=10704
+const kSignal = Symbol('signal');
+
+function validateAbortController(obj) {
+  if (obj?.[kSignal] === undefined)
+    throw new ERR_INVALID_THIS('AbortController');
+}
+
+class AbortController {
+  constructor() {
+    this[kSignal] = createAbortSignal();
+    emitExperimentalWarning('AbortController');
+  }
+
+  get signal() {
+    validateAbortController(this);
+    return this[kSignal];
+  }
+
+  abort() {
+    validateAbortController(this);
+    abortSignal(this[kSignal]);
+  }
+
+  [customInspectSymbol](depth, options) {
+    return customInspect(this, {
+      signal: this.signal
+    }, depth, options);
+  }
+}
+
+ObjectDefineProperties(AbortController.prototype, {
+  signal: { enumerable: true },
+  abort: { enumerable: true }
+});
+
+ObjectDefineProperty(AbortController.prototype, SymbolToStringTag, {
+  writable: false,
+  enumerable: false,
+  configurable: true,
+  value: 'AbortController',
+});
+
+module.exports = {
+  AbortController,
+  AbortSignal,
+};
diff --git a/lib/internal/assert/assertion_error.js b/lib/internal/assert/assertion_error.js
index 3c2150c69e4e09e968c1f82eabee8bd3e82e60ab..83e32ef2b547e25f6c687b29fcc1c4802618fd09 100644
--- a/lib/internal/assert/assertion_error.js
+++ b/lib/internal/assert/assertion_error.js
@@ -1,12 +1,20 @@
 'use strict';
 
 const {
+  ArrayPrototypeJoin,
+  ArrayPrototypePop,
   Error,
+  ErrorCaptureStackTrace,
   MathMax,
   ObjectCreate,
   ObjectDefineProperty,
   ObjectGetPrototypeOf,
   ObjectKeys,
+  String,
+  StringPrototypeEndsWith,
+  StringPrototypeRepeat,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
 } = primordials;
 
 const { inspect } = require('internal/util/inspect');
@@ -77,8 +85,8 @@ function createErrDiff(actual, expected, operator) {
   let end = '';
   let skipped = false;
   const actualInspected = inspectValue(actual);
-  const actualLines = actualInspected.split('\n');
-  const expectedLines = inspectValue(expected).split('\n');
+  const actualLines = StringPrototypeSplit(actualInspected, '\n');
+  const expectedLines = StringPrototypeSplit(inspectValue(expected), '\n');
 
   let i = 0;
   let indicator = '';
@@ -125,7 +133,7 @@ function createErrDiff(actual, expected, operator) {
         if (i > 2) {
           // Add position indicator for the first mismatch in case it is a
           // single line and the input length is less than the column length.
-          indicator = `\n  ${' '.repeat(i)}^`;
+          indicator = `\n  ${StringPrototypeRepeat(' ', i)}^`;
           i = 0;
         }
       }
@@ -142,8 +150,8 @@ function createErrDiff(actual, expected, operator) {
     } else {
       other = a;
     }
-    actualLines.pop();
-    expectedLines.pop();
+    ArrayPrototypePop(actualLines);
+    ArrayPrototypePop(expectedLines);
     if (actualLines.length === 0 || expectedLines.length === 0)
       break;
     a = actualLines[actualLines.length - 1];
@@ -155,18 +163,19 @@ function createErrDiff(actual, expected, operator) {
   // E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() })
   if (maxLines === 0) {
     // We have to get the result again. The lines were all removed before.
-    const actualLines = actualInspected.split('\n');
+    const actualLines = StringPrototypeSplit(actualInspected, '\n');
 
     // Only remove lines in case it makes sense to collapse those.
     // TODO: Accept env to always show the full error.
     if (actualLines.length > 50) {
       actualLines[46] = `${blue}...${white}`;
       while (actualLines.length > 47) {
-        actualLines.pop();
+        ArrayPrototypePop(actualLines);
       }
     }
 
-    return `${kReadableOperator.notIdentical}\n\n${actualLines.join('\n')}\n`;
+    return `${kReadableOperator.notIdentical}\n\n` +
+           `${ArrayPrototypeJoin(actualLines, '\n')}\n`;
   }
 
   // There were at least five identical lines at the end. Mark a couple of
@@ -233,9 +242,10 @@ function createErrDiff(actual, expected, operator) {
       // If the lines diverge, specifically check for lines that only diverge by
       // a trailing comma. In that case it is actually identical and we should
       // mark it as such.
-      let divergingLines = actualLine !== expectedLine &&
-                           (!actualLine.endsWith(',') ||
-                            actualLine.slice(0, -1) !== expectedLine);
+      let divergingLines =
+        actualLine !== expectedLine &&
+        (!StringPrototypeEndsWith(actualLine, ',') ||
+         StringPrototypeSlice(actualLine, 0, -1) !== expectedLine);
       // If the expected line has a trailing comma but is otherwise identical,
       // add a comma at the end of the actual line. Otherwise the output could
       // look weird as in:
@@ -246,8 +256,8 @@ function createErrDiff(actual, expected, operator) {
       //   ]
       //
       if (divergingLines &&
-          expectedLine.endsWith(',') &&
-          expectedLine.slice(0, -1) === actualLine) {
+          StringPrototypeEndsWith(expectedLine, ',') &&
+          StringPrototypeSlice(expectedLine, 0, -1) === actualLine) {
         divergingLines = false;
         actualLine += ',';
       }
@@ -303,6 +313,17 @@ function createErrDiff(actual, expected, operator) {
   return `${msg}${skipped ? skippedMsg : ''}\n${res}${other}${end}${indicator}`;
 }
 
+function addEllipsis(string) {
+  const lines = StringPrototypeSplit(string, '\n', 11);
+  if (lines.length > 10) {
+    lines.length = 10;
+    return `${ArrayPrototypeJoin(lines, '\n')}\n...`;
+  } else if (string.length > 512) {
+    return `${StringPrototypeSlice(string, 512)}...`;
+  }
+  return string;
+}
+
 class AssertionError extends Error {
   constructor(options) {
     if (typeof options !== 'object' || options === null) {
@@ -360,7 +381,7 @@ class AssertionError extends Error {
         // In case the objects are equal but the operator requires unequal, show
         // the first object and say A equals B
         let base = kReadableOperator[operator];
-        const res = inspectValue(actual).split('\n');
+        const res = StringPrototypeSplit(inspectValue(actual), '\n');
 
         // In case "actual" is an object or a function, it should not be
         // reference equal.
@@ -375,7 +396,7 @@ class AssertionError extends Error {
         if (res.length > 50) {
           res[46] = `${blue}...${white}`;
           while (res.length > 47) {
-            res.pop();
+            ArrayPrototypePop(res);
           }
         }
 
@@ -383,7 +404,7 @@ class AssertionError extends Error {
         if (res.length === 1) {
           super(`${base}${res[0].length > 5 ? '\n\n' : ' '}${res[0]}`);
         } else {
-          super(`${base}\n\n${res.join('\n')}\n`);
+          super(`${base}\n\n${ArrayPrototypeJoin(res, '\n')}\n`);
         }
       } else {
         let res = inspectValue(actual);
@@ -392,15 +413,15 @@ class AssertionError extends Error {
         if (operator === 'notDeepEqual' && res === other) {
           res = `${knownOperator}\n\n${res}`;
           if (res.length > 1024) {
-            res = `${res.slice(0, 1021)}...`;
+            res = `${StringPrototypeSlice(res, 0, 1021)}...`;
           }
           super(res);
         } else {
           if (res.length > 512) {
-            res = `${res.slice(0, 509)}...`;
+            res = `${StringPrototypeSlice(res, 0, 509)}...`;
           }
           if (other.length > 512) {
-            other = `${other.slice(0, 509)}...`;
+            other = `${StringPrototypeSlice(other, 0, 509)}...`;
           }
           if (operator === 'deepEqual') {
             res = `${knownOperator}\n\n${res}\n\nshould loosely deep-equal\n\n`;
@@ -443,10 +464,9 @@ class AssertionError extends Error {
       this.expected = expected;
       this.operator = operator;
     }
-    // eslint-disable-next-line no-restricted-syntax
-    Error.captureStackTrace(this, stackStartFn || stackStartFunction);
+    ErrorCaptureStackTrace(this, stackStartFn || stackStartFunction);
     // Create error message including the error code in the name.
-    this.stack;
+    this.stack; // eslint-disable-line no-unused-expressions
     // Reset the name.
     this.name = 'AssertionError';
   }
@@ -460,16 +480,11 @@ class AssertionError extends Error {
     const tmpActual = this.actual;
     const tmpExpected = this.expected;
 
-    for (const name of ['actual', 'expected']) {
-      if (typeof this[name] === 'string') {
-        const lines = this[name].split('\n');
-        if (lines.length > 10) {
-          lines.length = 10;
-          this[name] = `${lines.join('\n')}\n...`;
-        } else if (this[name].length > 512) {
-          this[name] = `${this[name].slice(512)}...`;
-        }
-      }
+    if (typeof this.actual === 'string') {
+      this.actual = addEllipsis(this.actual);
+    }
+    if (typeof this.expected === 'string') {
+      this.expected = addEllipsis(this.expected);
     }
 
     // This limits the `actual` and `expected` property default inspection to
diff --git a/lib/internal/assert/calltracker.js b/lib/internal/assert/calltracker.js
index 74f517f3f9e99b4e34b41f3a50af2d55cc8dd519..d45fb67d611e8bcf0f33008b2437e8489089b10a 100644
--- a/lib/internal/assert/calltracker.js
+++ b/lib/internal/assert/calltracker.js
@@ -1,7 +1,10 @@
 'use strict';
 
 const {
+  ArrayPrototypePush,
   Error,
+  FunctionPrototype,
+  ReflectApply,
   SafeSet,
 } = primordials;
 
@@ -15,7 +18,7 @@ const {
   validateUint32,
 } = require('internal/validators');
 
-const noop = () => {};
+const noop = FunctionPrototype;
 
 class CallTracker {
 
@@ -55,7 +58,7 @@ class CallTracker {
       if (context.actual === context.exact + 1) {
         callChecks.add(context);
       }
-      return fn.apply(this, arguments);
+      return ReflectApply(fn, this, arguments);
     };
   }
 
@@ -67,7 +70,7 @@ class CallTracker {
         const message = `Expected the ${context.name} function to be ` +
                         `executed ${context.exact} time(s) but was ` +
                         `executed ${context.actual} time(s).`;
-        errors.push({
+        ArrayPrototypePush(errors, {
           message,
           actual: context.actual,
           expected: context.exact,
diff --git a/lib/internal/async_hooks.js b/lib/internal/async_hooks.js
index a5e514528aee0a6b2d45f75450713445cbfffba8..42f4dceb77413aa393ff01975fce113d6fc09633 100644
--- a/lib/internal/async_hooks.js
+++ b/lib/internal/async_hooks.js
@@ -1,11 +1,10 @@
 'use strict';
 
 const {
-  ArrayPrototypeUnshift,
-  Error,
-  FunctionPrototypeBind,
+  ArrayPrototypeSlice,
+  ErrorCaptureStackTrace,
+  ObjectPrototypeHasOwnProperty,
   ObjectDefineProperty,
-  ReflectApply,
   Symbol,
 } = primordials;
 
@@ -53,7 +52,7 @@ const {
   clearAsyncIdStack,
 } = async_wrap;
 // For performance reasons, only track Promises when a hook is enabled.
-const { enablePromiseHook, disablePromiseHook } = async_wrap;
+const { setPromiseHooks } = async_wrap;
 // Properties in active_hooks are used to keep track of the set of hooks being
 // executed in case another hook is enabled/disabled. The new set of hooks is
 // then restored once the active set of hooks is finished executing.
@@ -87,14 +86,19 @@ const { resource_symbol, owner_symbol } = internalBinding('symbols');
 // Each constant tracks how many callbacks there are for any given step of
 // async execution. These are tracked so if the user didn't include callbacks
 // for a given step, that step can bail out early.
-const { kInit, kBefore, kAfter, kDestroy, kTotals, kPromiseResolve,
-        kCheck, kExecutionAsyncId, kAsyncIdCounter, kTriggerAsyncId,
-        kDefaultTriggerAsyncId, kStackLength, kUsesExecutionAsyncResource
+const {
+  kInit, kBefore, kAfter, kDestroy, kTotals, kPromiseResolve,
+  kCheck, kExecutionAsyncId, kAsyncIdCounter, kTriggerAsyncId,
+  kDefaultTriggerAsyncId, kStackLength, kUsesExecutionAsyncResource,
 } = async_wrap.constants;
 
+const { async_id_symbol,
+        trigger_async_id_symbol } = internalBinding('symbols');
+
+// Lazy load of internal/util/inspect;
+let inspect;
+
 // Used in AsyncHook and AsyncResource.
-const async_id_symbol = Symbol('asyncId');
-const trigger_async_id_symbol = Symbol('triggerAsyncId');
 const init_symbol = Symbol('init');
 const before_symbol = Symbol('before');
 const after_symbol = Symbol('after');
@@ -120,10 +124,10 @@ function callbackTrampoline(asyncId, resource, cb, ...args) {
 
   let result;
   if (asyncId === 0 && typeof domain_cb === 'function') {
-    ArrayPrototypeUnshift(args, cb);
-    result = ReflectApply(domain_cb, this, args);
+    args.unshift(cb);
+    result = domain_cb.apply(this, args);
   } else {
-    result = ReflectApply(cb, this, args);
+    result = cb.apply(this, args);
   }
 
   if (asyncId !== 0 && hasHooks(kAfter))
@@ -150,14 +154,18 @@ function executionAsyncResource() {
   return lookupPublicResource(resource);
 }
 
+function inspectExceptionValue(e) {
+  inspect = inspect ?? require('internal/util/inspect').inspect;
+  return { message: inspect(e) };
+}
+
 // Used to fatally abort the process if a callback throws.
 function fatalError(e) {
-  if (typeof e.stack === 'string') {
+  if (typeof e?.stack === 'string') {
     process._rawDebug(e.stack);
   } else {
-    const o = { message: e };
-    // eslint-disable-next-line no-restricted-syntax
-    Error.captureStackTrace(o, fatalError);
+    const o = inspectExceptionValue(e);
+    ErrorCaptureStackTrace(o, fatalError);
     process._rawDebug(o.stack);
   }
 
@@ -243,7 +251,7 @@ function emitHook(symbol, asyncId) {
 }
 
 function emitHookFactory(symbol, name) {
-  const fn = FunctionPrototypeBind(emitHook, undefined, symbol);
+  const fn = emitHook.bind(undefined, symbol);
 
   // Set the name property of the function as it looks good in the stack trace.
   ObjectDefineProperty(fn, 'name', {
@@ -268,7 +276,7 @@ function getHookArrays() {
 
 
 function storeActiveHooks() {
-  active_hooks.tmp_array = active_hooks.array.slice();
+  active_hooks.tmp_array = ArrayPrototypeSlice(active_hooks.array);
   // Don't want to make the assumption that kInit to kDestroy are indexes 0 to
   // 4. So do this the long way.
   active_hooks.tmp_fields = [];
@@ -294,27 +302,107 @@ function restoreActiveHooks() {
   active_hooks.tmp_fields = null;
 }
 
+function trackPromise(promise, parent) {
+  if (promise[async_id_symbol]) {
+    return;
+  }
+
+  // Get trigger id from parent async id before making the async id of the
+  // child so if a new one must be made it will be lower than the child.
+  const triggerAsyncId = parent ? getOrSetAsyncId(parent) :
+    getDefaultTriggerAsyncId();
+
+  promise[async_id_symbol] = newAsyncId();
+  promise[trigger_async_id_symbol] = triggerAsyncId;
+}
+
+function promiseInitHook(promise, parent) {
+  trackPromise(promise, parent);
+  const asyncId = promise[async_id_symbol];
+  const triggerAsyncId = promise[trigger_async_id_symbol];
+  emitInitScript(asyncId, 'PROMISE', triggerAsyncId, promise);
+}
+
+function promiseInitHookWithDestroyTracking(promise, parent) {
+  promiseInitHook(promise, parent);
+  destroyTracking(promise, parent);
+}
+
+const destroyedSymbol = Symbol('destroyed');
+
+function destroyTracking(promise, parent) {
+  trackPromise(promise, parent);
+  const asyncId = promise[async_id_symbol];
+  const destroyed = { destroyed: false };
+  promise[destroyedSymbol] = destroyed;
+  registerDestroyHook(promise, asyncId, destroyed);
+}
+
+function promiseBeforeHook(promise) {
+  trackPromise(promise);
+  const asyncId = promise[async_id_symbol];
+  const triggerId = promise[trigger_async_id_symbol];
+  emitBeforeScript(asyncId, triggerId, promise);
+}
+
+function promiseAfterHook(promise) {
+  trackPromise(promise);
+  const asyncId = promise[async_id_symbol];
+  if (hasHooks(kAfter)) {
+    emitAfterNative(asyncId);
+  }
+  if (asyncId === executionAsyncId()) {
+    // This condition might not be true if async_hooks was enabled during
+    // the promise callback execution.
+    // Popping it off the stack can be skipped in that case, because it is
+    // known that it would correspond to exactly one call with
+    // PromiseHookType::kBefore that was not witnessed by the PromiseHook.
+    popAsyncContext(asyncId);
+  }
+}
+
+function promiseResolveHook(promise) {
+  trackPromise(promise);
+  const asyncId = promise[async_id_symbol];
+  emitPromiseResolveNative(asyncId);
+}
 
 let wantPromiseHook = false;
 function enableHooks() {
   async_hook_fields[kCheck] += 1;
+}
 
+function updatePromiseHookMode() {
   wantPromiseHook = true;
-  enablePromiseHook();
+  let initHook;
+  if (initHooksExist()) {
+    initHook = destroyHooksExist() ? promiseInitHookWithDestroyTracking :
+      promiseInitHook;
+  } else if (destroyHooksExist()) {
+    initHook = destroyTracking;
+  }
+  setPromiseHooks(
+    initHook,
+    promiseBeforeHook,
+    promiseAfterHook,
+    promiseResolveHooksExist() ? promiseResolveHook : undefined,
+  );
 }
 
 function disableHooks() {
   async_hook_fields[kCheck] -= 1;
 
   wantPromiseHook = false;
+
   // Delay the call to `disablePromiseHook()` because we might currently be
   // between the `before` and `after` calls of a Promise.
   enqueueMicrotask(disablePromiseHookIfNecessary);
 }
 
 function disablePromiseHookIfNecessary() {
-  if (!wantPromiseHook)
-    disablePromiseHook();
+  if (!wantPromiseHook) {
+    setPromiseHooks(undefined, undefined, undefined, undefined);
+  }
 }
 
 // Internal Embedder API //
@@ -327,7 +415,7 @@ function newAsyncId() {
 }
 
 function getOrSetAsyncId(object) {
-  if (object.hasOwnProperty(async_id_symbol)) {
+  if (ObjectPrototypeHasOwnProperty(object, async_id_symbol)) {
     return object[async_id_symbol];
   }
 
@@ -354,14 +442,14 @@ function clearDefaultTriggerAsyncId() {
 
 function defaultTriggerAsyncIdScope(triggerAsyncId, block, ...args) {
   if (triggerAsyncId === undefined)
-    return block(...args);
+    return block.apply(null, args);
   // CHECK(NumberIsSafeInteger(triggerAsyncId))
   // CHECK(triggerAsyncId > 0)
   const oldDefaultTriggerAsyncId = async_id_fields[kDefaultTriggerAsyncId];
   async_id_fields[kDefaultTriggerAsyncId] = triggerAsyncId;
 
   try {
-    return block(...args);
+    return block.apply(null, args);
   } finally {
     async_id_fields[kDefaultTriggerAsyncId] = oldDefaultTriggerAsyncId;
   }
@@ -387,6 +475,10 @@ function destroyHooksExist() {
   return hasHooks(kDestroy);
 }
 
+function promiseResolveHooksExist() {
+  return hasHooks(kPromiseResolve);
+}
+
 
 function emitInitScript(asyncId, type, triggerAsyncId, resource) {
   // Short circuit all checks for the common case. Which is that no hooks have
@@ -488,6 +580,7 @@ module.exports = {
   },
   enableHooks,
   disableHooks,
+  updatePromiseHookMode,
   clearDefaultTriggerAsyncId,
   clearAsyncIdStack,
   hasAsyncIdStack,
diff --git a/lib/internal/blob.js b/lib/internal/blob.js
new file mode 100644
index 0000000000000000000000000000000000000000..927b9f54046bf212e4040ead0b2999fc3035966b
--- /dev/null
+++ b/lib/internal/blob.js
@@ -0,0 +1,236 @@
+'use strict';
+
+const {
+  ArrayFrom,
+  MathMax,
+  MathMin,
+  ObjectDefineProperty,
+  ObjectSetPrototypeOf,
+  PromiseResolve,
+  RegExpPrototypeTest,
+  StringPrototypeToLowerCase,
+  Symbol,
+  SymbolIterator,
+  SymbolToStringTag,
+  Uint8Array,
+} = primordials;
+
+const {
+  createBlob,
+  FixedSizeBlobCopyJob,
+} = internalBinding('buffer');
+
+const { TextDecoder } = require('internal/encoding');
+
+const {
+  JSTransferable,
+  kClone,
+  kDeserialize,
+} = require('internal/worker/js_transferable');
+
+const {
+  isAnyArrayBuffer,
+  isArrayBufferView,
+} = require('internal/util/types');
+
+const {
+  createDeferredPromise,
+  customInspectSymbol: kInspect,
+  emitExperimentalWarning,
+} = require('internal/util');
+const { inspect } = require('internal/util/inspect');
+
+const {
+  AbortError,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_BUFFER_TOO_LARGE,
+  }
+} = require('internal/errors');
+
+const {
+  validateObject,
+  isUint32,
+} = require('internal/validators');
+
+const kHandle = Symbol('kHandle');
+const kType = Symbol('kType');
+const kLength = Symbol('kLength');
+
+const disallowedTypeCharacters = /[^\u{0020}-\u{007E}]/u;
+
+let Buffer;
+
+function lazyBuffer() {
+  if (Buffer === undefined)
+    Buffer = require('buffer').Buffer;
+  return Buffer;
+}
+
+function isBlob(object) {
+  return object?.[kHandle] !== undefined;
+}
+
+function getSource(source, encoding) {
+  if (isBlob(source))
+    return [source.size, source[kHandle]];
+
+  if (isAnyArrayBuffer(source)) {
+    source = new Uint8Array(source);
+  } else if (!isArrayBufferView(source)) {
+    source = lazyBuffer().from(`${source}`, encoding);
+  }
+
+  // We copy into a new Uint8Array because the underlying
+  // BackingStores are going to be detached and owned by
+  // the Blob. We also don't want to have to worry about
+  // byte offsets.
+  source = new Uint8Array(source);
+  return [source.byteLength, source];
+}
+
+class InternalBlob extends JSTransferable {
+  constructor(handle, length, type = '') {
+    super();
+    this[kHandle] = handle;
+    this[kType] = type;
+    this[kLength] = length;
+  }
+}
+
+class Blob extends JSTransferable {
+  constructor(sources = [], options = {}) {
+    emitExperimentalWarning('buffer.Blob');
+    if (sources === null ||
+        typeof sources[SymbolIterator] !== 'function' ||
+        typeof sources === 'string') {
+      throw new ERR_INVALID_ARG_TYPE('sources', 'Iterable', sources);
+    }
+    validateObject(options, 'options');
+    const { encoding = 'utf8' } = options;
+    let { type = '' } = options;
+
+    let length = 0;
+    const sources_ = ArrayFrom(sources, (source) => {
+      const { 0: len, 1: src } = getSource(source, encoding);
+      length += len;
+      return src;
+    });
+
+    if (!isUint32(length))
+      throw new ERR_BUFFER_TOO_LARGE(0xFFFFFFFF);
+
+    super();
+    this[kHandle] = createBlob(sources_, length);
+    this[kLength] = length;
+
+    type = `${type}`;
+    this[kType] = RegExpPrototypeTest(disallowedTypeCharacters, type) ?
+      '' : StringPrototypeToLowerCase(type);
+  }
+
+  [kInspect](depth, options) {
+    if (depth < 0)
+      return this;
+
+    const opts = {
+      ...options,
+      depth: options.depth == null ? null : options.depth - 1
+    };
+
+    return `Blob ${inspect({
+      size: this.size,
+      type: this.type,
+    }, opts)}`;
+  }
+
+  [kClone]() {
+    const handle = this[kHandle];
+    const type = this[kType];
+    const length = this[kLength];
+    return {
+      data: { handle, type, length },
+      deserializeInfo: 'internal/blob:InternalBlob'
+    };
+  }
+
+  [kDeserialize]({ handle, type, length }) {
+    this[kHandle] = handle;
+    this[kType] = type;
+    this[kLength] = length;
+  }
+
+  get type() { return this[kType]; }
+
+  get size() { return this[kLength]; }
+
+  slice(start = 0, end = this[kLength], contentType = '') {
+    if (start < 0) {
+      start = MathMax(this[kLength] + start, 0);
+    } else {
+      start = MathMin(start, this[kLength]);
+    }
+    start |= 0;
+
+    if (end < 0) {
+      end = MathMax(this[kLength] + end, 0);
+    } else {
+      end = MathMin(end, this[kLength]);
+    }
+    end |= 0;
+
+    contentType = `${contentType}`;
+    if (RegExpPrototypeTest(disallowedTypeCharacters, contentType)) {
+      contentType = '';
+    } else {
+      contentType = StringPrototypeToLowerCase(contentType);
+    }
+
+    const span = MathMax(end - start, 0);
+
+    return new InternalBlob(
+      this[kHandle].slice(start, start + span), span, contentType);
+  }
+
+  async arrayBuffer() {
+    const job = new FixedSizeBlobCopyJob(this[kHandle]);
+
+    const ret = job.run();
+    if (ret !== undefined)
+      return PromiseResolve(ret);
+
+    const {
+      promise,
+      resolve,
+      reject
+    } = createDeferredPromise();
+    job.ondone = (err, ab) => {
+      if (err !== undefined)
+        return reject(new AbortError());
+      resolve(ab);
+    };
+
+    return promise;
+  }
+
+  async text() {
+    const dec = new TextDecoder();
+    return dec.decode(await this.arrayBuffer());
+  }
+}
+
+ObjectDefineProperty(Blob.prototype, SymbolToStringTag, {
+  configurable: true,
+  value: 'Blob',
+});
+
+InternalBlob.prototype.constructor = Blob;
+ObjectSetPrototypeOf(
+  InternalBlob.prototype,
+  Blob.prototype);
+
+module.exports = {
+  Blob,
+  InternalBlob,
+  isBlob,
+};
diff --git a/lib/internal/blocklist.js b/lib/internal/blocklist.js
new file mode 100644
index 0000000000000000000000000000000000000000..a73f3f19de07ff57b85d49f1e1ec5141bcf19ec6
--- /dev/null
+++ b/lib/internal/blocklist.js
@@ -0,0 +1,166 @@
+'use strict';
+
+const {
+  Boolean,
+  ObjectSetPrototypeOf,
+  Symbol
+} = primordials;
+
+const {
+  BlockList: BlockListHandle,
+} = internalBinding('block_list');
+
+const {
+  customInspectSymbol: kInspect,
+} = require('internal/util');
+
+const {
+  SocketAddress,
+  kHandle: kSocketAddressHandle,
+} = require('internal/socketaddress');
+
+const {
+  JSTransferable,
+  kClone,
+  kDeserialize,
+} = require('internal/worker/js_transferable');
+
+const { inspect } = require('internal/util/inspect');
+
+const kHandle = Symbol('kHandle');
+const { owner_symbol } = internalBinding('symbols');
+
+const {
+  ERR_INVALID_ARG_VALUE,
+} = require('internal/errors').codes;
+
+const { validateInt32, validateString } = require('internal/validators');
+
+class BlockList extends JSTransferable {
+  constructor() {
+    super();
+    this[kHandle] = new BlockListHandle();
+    this[kHandle][owner_symbol] = this;
+  }
+
+  [kInspect](depth, options) {
+    if (depth < 0)
+      return this;
+
+    const opts = {
+      ...options,
+      depth: options.depth == null ? null : options.depth - 1
+    };
+
+    return `BlockList ${inspect({
+      rules: this.rules
+    }, opts)}`;
+  }
+
+  addAddress(address, family = 'ipv4') {
+    if (!SocketAddress.isSocketAddress(address)) {
+      validateString(address, 'address');
+      validateString(family, 'family');
+      address = new SocketAddress({
+        address,
+        family,
+      });
+    }
+    this[kHandle].addAddress(address[kSocketAddressHandle]);
+  }
+
+  addRange(start, end, family = 'ipv4') {
+    if (!SocketAddress.isSocketAddress(start)) {
+      validateString(start, 'start');
+      validateString(family, 'family');
+      start = new SocketAddress({
+        address: start,
+        family,
+      });
+    }
+    if (!SocketAddress.isSocketAddress(end)) {
+      validateString(end, 'end');
+      validateString(family, 'family');
+      end = new SocketAddress({
+        address: end,
+        family,
+      });
+    }
+    const ret = this[kHandle].addRange(
+      start[kSocketAddressHandle],
+      end[kSocketAddressHandle]);
+    if (ret === false)
+      throw new ERR_INVALID_ARG_VALUE('start', start, 'must come before end');
+  }
+
+  addSubnet(network, prefix, family = 'ipv4') {
+    if (!SocketAddress.isSocketAddress(network)) {
+      validateString(network, 'network');
+      validateString(family, 'family');
+      network = new SocketAddress({
+        address: network,
+        family,
+      });
+    }
+    switch (network.family) {
+      case 'ipv4':
+        validateInt32(prefix, 'prefix', 0, 32);
+        break;
+      case 'ipv6':
+        validateInt32(prefix, 'prefix', 0, 128);
+        break;
+    }
+    this[kHandle].addSubnet(network[kSocketAddressHandle], prefix);
+  }
+
+  check(address, family = 'ipv4') {
+    if (!SocketAddress.isSocketAddress(address)) {
+      validateString(address, 'address');
+      validateString(family, 'family');
+      try {
+        address = new SocketAddress({
+          address,
+          family,
+        });
+      } catch {
+        // Ignore the error. If it's not a valid address, return false.
+        return false;
+      }
+    }
+    return Boolean(this[kHandle].check(address[kSocketAddressHandle]));
+  }
+
+  get rules() {
+    return this[kHandle].getRules();
+  }
+
+  [kClone]() {
+    const handle = this[kHandle];
+    return {
+      data: { handle },
+      deserializeInfo: 'internal/blocklist:InternalBlockList',
+    };
+  }
+
+  [kDeserialize]({ handle }) {
+    this[kHandle] = handle;
+    this[kHandle][owner_symbol] = this;
+  }
+}
+
+class InternalBlockList extends JSTransferable {
+  constructor(handle) {
+    super();
+    this[kHandle] = handle;
+    if (handle !== undefined)
+      handle[owner_symbol] = this;
+  }
+}
+
+InternalBlockList.prototype.constructor = BlockList.prototype.constructor;
+ObjectSetPrototypeOf(InternalBlockList.prototype, BlockList.prototype);
+
+module.exports = {
+  BlockList,
+  InternalBlockList,
+};
diff --git a/lib/internal/bootstrap/loaders.js b/lib/internal/bootstrap/loaders.js
index fd8a4327a426ecb4b729e6baafd8770ccc16fceb..852aca8e6220329d82462fdc5e3b0512e2a1b1e4 100644
--- a/lib/internal/bootstrap/loaders.js
+++ b/lib/internal/bootstrap/loaders.js
@@ -4,7 +4,7 @@
 // lib/internal/modules/esm/* (ES Modules).
 //
 // This file is compiled and run by node.cc before bootstrap/node.js
-// was called, therefore the loaders are bootstraped before we start to
+// was called, therefore the loaders are bootstrapped before we start to
 // actually bootstrap Node.js. It creates the following objects:
 //
 // C++ binding loaders:
@@ -44,14 +44,20 @@
 /* global process, getLinkedBinding, getInternalBinding, primordials */
 
 const {
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
   Error,
-  Map,
   ObjectCreate,
   ObjectDefineProperty,
   ObjectKeys,
   ObjectPrototypeHasOwnProperty,
   ReflectGet,
+  SafeMap,
   SafeSet,
+  String,
+  StringPrototypeStartsWith,
+  TypeError,
 } = primordials;
 
 // Set up process.moduleLoadList.
@@ -64,11 +70,11 @@ ObjectDefineProperty(process, 'moduleLoadList', {
 });
 
 
-// internalBindingWhitelist contains the name of internalBinding modules
-// that are whitelisted for access via process.binding()... This is used
+// internalBindingAllowlist contains the name of internalBinding modules
+// that are allowed for access via process.binding()... This is used
 // to provide a transition path for modules that are being moved over to
 // internalBinding.
-const internalBindingWhitelist = new SafeSet([
+const internalBindingAllowlist = new SafeSet([
   'async_wrap',
   'buffer',
   'cares_wrap',
@@ -79,7 +85,6 @@ const internalBindingWhitelist = new SafeSet([
   'fs',
   'fs_event_wrap',
   'http_parser',
-  'http_parser_llhttp',
   'icu',
   'inspector',
   'js_stream',
@@ -98,7 +103,7 @@ const internalBindingWhitelist = new SafeSet([
   'util',
   'uv',
   'v8',
-  'zlib'
+  'zlib',
 ]);
 
 // Set up process.binding() and process._linkedBinding().
@@ -109,7 +114,7 @@ const internalBindingWhitelist = new SafeSet([
     module = String(module);
     // Deprecated specific process.binding() modules, but not all, allow
     // selective fallback to internalBinding for the deprecated ones.
-    if (internalBindingWhitelist.has(module)) {
+    if (internalBindingAllowlist.has(module)) {
       return internalBinding(module);
     }
     // eslint-disable-next-line no-restricted-syntax
@@ -134,7 +139,7 @@ let internalBinding;
     let mod = bindingObj[module];
     if (typeof mod !== 'object') {
       mod = bindingObj[module] = getInternalBinding(module);
-      moduleLoadList.push(`Internal Binding ${module}`);
+      ArrayPrototypePush(moduleLoadList, `Internal Binding ${module}`);
     }
     return mod;
   };
@@ -162,12 +167,14 @@ class NativeModule {
    * A map from the module IDs to the module instances.
    * @type {Map<string, NativeModule>}
   */
-  static map = new Map(moduleIds.map((id) => [id, new NativeModule(id)]));
+  static map = new SafeMap(
+    ArrayPrototypeMap(moduleIds, (id) => [id, new NativeModule(id)])
+  );
 
   constructor(id) {
     this.filename = `${id}.js`;
     this.id = id;
-    this.canBeRequiredByUsers = !id.startsWith('internal/');
+    this.canBeRequiredByUsers = !StringPrototypeStartsWith(id, 'internal/');
 
     // The CJS exports object of the module.
     this.exports = {};
@@ -192,7 +199,7 @@ class NativeModule {
   // To be called during pre-execution when --expose-internals is on.
   // Enables the user-land module loader to access internal modules.
   static exposeInternals() {
-    for (const [id, mod] of NativeModule.map) {
+    for (const { 0: id, 1: mod } of NativeModule.map) {
       // Do not expose this to user land even with --expose-internals.
       if (id !== loaderId) {
         mod.canBeRequiredByUsers = true;
@@ -220,7 +227,7 @@ class NativeModule {
     if (!this.exportKeys) {
       // When using --expose-internals, we do not want to reflect the named
       // exports from core modules as this can trigger unnecessary getters.
-      const internal = this.id.startsWith('internal/');
+      const internal = StringPrototypeStartsWith(this.id, 'internal/');
       this.exportKeys = internal ? [] : ObjectKeys(this.exports);
     }
     this.getESMFacade();
@@ -233,8 +240,10 @@ class NativeModule {
     const { ModuleWrap } = internalBinding('module_wrap');
     const url = `node:${this.id}`;
     const nativeModule = this;
+    const exportsKeys = ArrayPrototypeSlice(this.exportKeys);
+    ArrayPrototypePush(exportsKeys, 'default');
     this.module = new ModuleWrap(
-      url, undefined, [...this.exportKeys, 'default'],
+      url, undefined, exportsKeys,
       function() {
         nativeModule.syncExports();
         this.setExport('default', nativeModule.exports);
@@ -270,7 +279,7 @@ class NativeModule {
     this.loading = true;
 
     try {
-      const requireFn = this.id.startsWith('internal/deps/') ?
+      const requireFn = StringPrototypeStartsWith(this.id, 'internal/deps/') ?
         requireWithFallbackInDeps : nativeModuleRequire;
 
       const fn = compileFunction(id);
@@ -281,7 +290,7 @@ class NativeModule {
       this.loading = false;
     }
 
-    moduleLoadList.push(`NativeModule ${id}`);
+    ArrayPrototypePush(moduleLoadList, `NativeModule ${id}`);
     return this.exports;
   }
 }
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 2be5da2a993a526f626fe9083e1a7ccb998c422c..718c9a6ac6491e7df05b2bcdfe6bbb46450a6cd3 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -39,12 +39,13 @@
 setupPrepareStackTrace();
 
 const {
+  FunctionPrototypeCall,
   JSONParse,
-  ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectGetPrototypeOf,
   ObjectSetPrototypeOf,
   SymbolToStringTag,
+  globalThis,
 } = primordials;
 const config = internalBinding('config');
 const { deprecate } = require('internal/util');
@@ -119,34 +120,35 @@ if (!config.noBrowserGlobals) {
   // Override global console from the one provided by the VM
   // to the one implemented by Node.js
   // https://console.spec.whatwg.org/#console-namespace
-  exposeNamespace(global, 'console', createGlobalConsole(global.console));
+  exposeNamespace(globalThis, 'console',
+                  createGlobalConsole(globalThis.console));
 
   const { URL, URLSearchParams } = require('internal/url');
   // https://url.spec.whatwg.org/#url
-  exposeInterface(global, 'URL', URL);
+  exposeInterface(globalThis, 'URL', URL);
   // https://url.spec.whatwg.org/#urlsearchparams
-  exposeInterface(global, 'URLSearchParams', URLSearchParams);
+  exposeInterface(globalThis, 'URLSearchParams', URLSearchParams);
 
   const {
     TextEncoder, TextDecoder
   } = require('internal/encoding');
   // https://encoding.spec.whatwg.org/#textencoder
-  exposeInterface(global, 'TextEncoder', TextEncoder);
+  exposeInterface(globalThis, 'TextEncoder', TextEncoder);
   // https://encoding.spec.whatwg.org/#textdecoder
-  exposeInterface(global, 'TextDecoder', TextDecoder);
+  exposeInterface(globalThis, 'TextDecoder', TextDecoder);
 
   // https://html.spec.whatwg.org/multipage/webappapis.html#windoworworkerglobalscope
   const timers = require('timers');
-  defineOperation(global, 'clearInterval', timers.clearInterval);
-  defineOperation(global, 'clearTimeout', timers.clearTimeout);
-  defineOperation(global, 'setInterval', timers.setInterval);
-  defineOperation(global, 'setTimeout', timers.setTimeout);
+  defineOperation(globalThis, 'clearInterval', timers.clearInterval);
+  defineOperation(globalThis, 'clearTimeout', timers.clearTimeout);
+  defineOperation(globalThis, 'setInterval', timers.setInterval);
+  defineOperation(globalThis, 'setTimeout', timers.setTimeout);
 
-  defineOperation(global, 'queueMicrotask', queueMicrotask);
+  defineOperation(globalThis, 'queueMicrotask', queueMicrotask);
 
   // Non-standard extensions:
-  defineOperation(global, 'clearImmediate', timers.clearImmediate);
-  defineOperation(global, 'setImmediate', timers.setImmediate);
+  defineOperation(globalThis, 'clearImmediate', timers.clearImmediate);
+  defineOperation(globalThis, 'setImmediate', timers.setImmediate);
 }
 
 // Set the per-Environment callback that will be called
@@ -272,7 +274,7 @@ function setupProcessObject() {
   const EventEmitter = require('events');
   const origProcProto = ObjectGetPrototypeOf(process);
   ObjectSetPrototypeOf(origProcProto, EventEmitter.prototype);
-  EventEmitter.call(process);
+  FunctionPrototypeCall(EventEmitter, process);
   ObjectDefineProperty(process, SymbolToStringTag, {
     enumerable: false,
     writable: true,
@@ -280,7 +282,7 @@ function setupProcessObject() {
     value: 'process'
   });
   // Make process globally available to users by putting it on the global proxy
-  ObjectDefineProperty(global, 'process', {
+  ObjectDefineProperty(globalThis, 'process', {
     value: process,
     enumerable: false,
     writable: true,
@@ -289,42 +291,12 @@ function setupProcessObject() {
 }
 
 function setupGlobalProxy() {
-  ObjectDefineProperty(global, SymbolToStringTag, {
+  ObjectDefineProperty(globalThis, SymbolToStringTag, {
     value: 'global',
     writable: false,
     enumerable: false,
     configurable: true
   });
-
-  function makeGetter(name) {
-    return deprecate(function() {
-      return this;
-    }, `'${name}' is deprecated, use 'global'`, 'DEP0016');
-  }
-
-  function makeSetter(name) {
-    return deprecate(function(value) {
-      ObjectDefineProperty(this, name, {
-        configurable: true,
-        writable: true,
-        enumerable: true,
-        value: value
-      });
-    }, `'${name}' is deprecated, use 'global'`, 'DEP0016');
-  }
-
-  ObjectDefineProperties(global, {
-    GLOBAL: {
-      configurable: true,
-      get: makeGetter('GLOBAL'),
-      set: makeSetter('GLOBAL')
-    },
-    root: {
-      configurable: true,
-      get: makeGetter('root'),
-      set: makeSetter('root')
-    }
-  });
 }
 
 function setupBuffer() {
@@ -336,7 +308,7 @@ function setupBuffer() {
   delete bufferBinding.setBufferPrototype;
   delete bufferBinding.zeroFill;
 
-  ObjectDefineProperty(global, 'Buffer', {
+  ObjectDefineProperty(globalThis, 'Buffer', {
     value: Buffer,
     enumerable: false,
     writable: true,
diff --git a/lib/internal/bootstrap/pre_execution.js b/lib/internal/bootstrap/pre_execution.js
index dfbefa955cab8adcafc5f46151ac83ed893645e0..f116dd0f5f5685c9b58c333ba1f493630ca61d3e 100644
--- a/lib/internal/bootstrap/pre_execution.js
+++ b/lib/internal/bootstrap/pre_execution.js
@@ -1,9 +1,13 @@
 'use strict';
 
 const {
-  Map,
+  NumberParseInt,
   ObjectDefineProperty,
+  ObjectDefineProperties,
+  SafeMap,
   SafeWeakMap,
+  StringPrototypeStartsWith,
+  globalThis,
 } = primordials;
 
 const {
@@ -29,14 +33,6 @@ function prepareMainThreadExecution(expandArgv1 = false) {
       setupCoverageHooks(process.env.NODE_V8_COVERAGE);
   }
 
-  // If source-map support has been enabled, we substitute in a new
-  // prepareStackTrace method, replacing the default in errors.js.
-  if (getOptionValue('--enable-source-maps')) {
-    const { prepareStackTrace } =
-      require('internal/source_map/prepare_stack_trace');
-    const { setPrepareStackTraceCallback } = internalBinding('errors');
-    setPrepareStackTraceCallback(prepareStackTrace);
-  }
 
   setupDebugEnv();
 
@@ -64,6 +60,8 @@ function prepareMainThreadExecution(expandArgv1 = false) {
   // (including preload modules).
   initializeClusterIPC();
 
+  initializeAbortController();
+  initializeSourceMapsHandlers();
   initializeDeprecations();
   initializeWASI();
   initializeCJSLoader();
@@ -89,7 +87,8 @@ function patchProcessObject(expandArgv1) {
   });
   process.argv[0] = process.execPath;
 
-  if (expandArgv1 && process.argv[1] && !process.argv[1].startsWith('-')) {
+  if (expandArgv1 && process.argv[1] &&
+      !StringPrototypeStartsWith(process.argv[1], '-')) {
     // Expand process.argv[1] into a full path.
     const path = require('path');
     try {
@@ -130,7 +129,7 @@ function setupWarningHandler() {
   const {
     onWarning
   } = require('internal/process/warning');
-  if (!getOptionValue('--no-warnings') &&
+  if (getOptionValue('--warnings') &&
     process.env.NODE_NO_WARNINGS !== '1') {
     process.on('warning', onWarning);
   }
@@ -227,9 +226,9 @@ function setupInspectorHooks() {
   }
 }
 
-// In general deprecations are intialized wherever the APIs are implemented,
+// In general deprecations are initialized wherever the APIs are implemented,
 // this is used to deprecate APIs implemented in C++ where the deprecation
-// utitlities are not easily accessible.
+// utilities are not easily accessible.
 function initializeDeprecations() {
   const { deprecate } = require('internal/util');
   const pendingDeprecation = getOptionValue('--pending-deprecation');
@@ -254,7 +253,7 @@ function initializeDeprecations() {
     'isSetIterator',
     'isTypedArray',
     'isUint8Array',
-    'isAnyArrayBuffer'
+    'isAnyArrayBuffer',
   ]) {
     utilBinding[name] = pendingDeprecation ?
       deprecate(types[name],
@@ -293,7 +292,7 @@ function initializeDeprecations() {
   // deprecation path for these in ES Modules.
   // See https://github.com/nodejs/node/pull/26334.
   let _process = process;
-  ObjectDefineProperty(global, 'process', {
+  ObjectDefineProperty(globalThis, 'process', {
     get() {
       return _process;
     },
@@ -305,7 +304,7 @@ function initializeDeprecations() {
   });
 
   let _Buffer = Buffer;
-  ObjectDefineProperty(global, 'Buffer', {
+  ObjectDefineProperty(globalThis, 'Buffer', {
     get() {
       return _Buffer;
     },
@@ -317,11 +316,35 @@ function initializeDeprecations() {
   });
 }
 
+function initializeAbortController() {
+  const abortController = getOptionValue('--experimental-abortcontroller');
+  if (abortController) {
+    const {
+      AbortController,
+      AbortSignal
+    } = require('internal/abort_controller');
+    ObjectDefineProperties(globalThis, {
+      AbortController: {
+        writable: true,
+        enumerable: false,
+        configurable: true,
+        value: AbortController
+      },
+      AbortSignal: {
+        writable: true,
+        enumerable: false,
+        configurable: true,
+        value: AbortSignal
+      }
+    });
+  }
+}
+
 function setupChildProcessIpcChannel() {
   if (process.env.NODE_CHANNEL_FD) {
     const assert = require('internal/assert');
 
-    const fd = parseInt(process.env.NODE_CHANNEL_FD, 10);
+    const fd = NumberParseInt(process.env.NODE_CHANNEL_FD, 10);
     assert(fd >= 0);
 
     // Make sure it's not accidentally inherited by child processes.
@@ -350,7 +373,7 @@ function initializePolicy() {
   if (experimentalPolicy) {
     process.emitWarning('Policies are experimental.',
                         'ExperimentalWarning');
-    const { pathToFileURL, URL } = require('url');
+    const { pathToFileURL, URL } = require('internal/url');
     // URL here as it is slightly different parsing
     // no bare specifiers for now
     let manifestURL;
@@ -367,7 +390,7 @@ function initializePolicy() {
     if (experimentalPolicyIntegrity) {
       const SRI = require('internal/policy/sri');
       const { createHash, timingSafeEqual } = require('crypto');
-      const realIntegrities = new Map();
+      const realIntegrities = new SafeMap();
       const integrityEntries = SRI.parse(experimentalPolicyIntegrity);
       let foundMatch = false;
       for (let i = 0; i < integrityEntries.length; i++) {
@@ -426,6 +449,12 @@ function initializeESMLoader() {
   setImportModuleDynamicallyCallback(esm.importModuleDynamicallyCallback);
 }
 
+function initializeSourceMapsHandlers() {
+  const { setSourceMapsEnabled } =
+    require('internal/source_map/source_map_cache');
+  process.setSourceMapsEnabled = setSourceMapsEnabled;
+}
+
 function initializeFrozenIntrinsics() {
   if (getOptionValue('--frozen-intrinsics')) {
     process.emitWarning('The --frozen-intrinsics flag is experimental',
@@ -453,9 +482,11 @@ module.exports = {
   setupWarningHandler,
   setupDebugEnv,
   prepareMainThreadExecution,
+  initializeAbortController,
   initializeDeprecations,
   initializeESMLoader,
   initializeFrozenIntrinsics,
+  initializeSourceMapsHandlers,
   loadPreloadModules,
   setupTraceCategoryState,
   setupInspectorHooks,
diff --git a/lib/internal/bootstrap/switches/does_own_process_state.js b/lib/internal/bootstrap/switches/does_own_process_state.js
index 0bfa2fd0c541a86229177f576a7ad112ba6378fa..0d60fb1f4595d189a7700c953ba71c0d236034da 100644
--- a/lib/internal/bootstrap/switches/does_own_process_state.js
+++ b/lib/internal/bootstrap/switches/does_own_process_state.js
@@ -23,7 +23,7 @@ if (credentials.implementsPosixCredentials) {
 // ----              compare the setups side-by-side                    -----
 
 const {
-  parseMode,
+  parseFileMode,
   validateString
 } = require('internal/validators');
 
@@ -80,6 +80,7 @@ function wrapPosixCredentialSetters(credentials) {
   function wrapIdSetter(type, method) {
     return function(id) {
       validateId(id, 'id');
+      if (typeof id === 'number') id |= 0;
       // Result is 0 on success, 1 if credential is unknown.
       const result = method(id);
       if (result === 1) {
@@ -119,12 +120,13 @@ function wrappedChdir(directory) {
 
 function wrappedUmask(mask) {
   if (mask !== undefined) {
-    mask = parseMode(mask, 'mask');
+    mask = parseFileMode(mask, 'mask');
   }
   return rawMethods.umask(mask);
 }
 
 function wrappedCwd() {
-  cachedCwd = rawMethods.cwd();
+  if (cachedCwd === '')
+    cachedCwd = rawMethods.cwd();
   return cachedCwd;
 }
diff --git a/lib/internal/bootstrap/switches/is_main_thread.js b/lib/internal/bootstrap/switches/is_main_thread.js
index ac8336fb6229e7f44eb00f43abb07bea83a9463c..08623898edafacfa8cee47ab35bd75887f9d3e2a 100644
--- a/lib/internal/bootstrap/switches/is_main_thread.js
+++ b/lib/internal/bootstrap/switches/is_main_thread.js
@@ -6,8 +6,12 @@ const rawMethods = internalBinding('process_methods');
 // TODO(joyeecheung): deprecate and remove these underscore methods
 process._debugProcess = rawMethods._debugProcess;
 process._debugEnd = rawMethods._debugEnd;
-process._startProfilerIdleNotifier = rawMethods._startProfilerIdleNotifier;
-process._stopProfilerIdleNotifier = rawMethods._stopProfilerIdleNotifier;
+
+// See the discussion in https://github.com/nodejs/node/issues/19009 and
+// https://github.com/nodejs/node/pull/34010 for why these are no-ops.
+// Five word summary: they were broken beyond repair.
+process._startProfilerIdleNotifier = () => {};
+process._stopProfilerIdleNotifier = () => {};
 
 function defineStream(name, getter) {
   ObjectDefineProperty(process, name, {
@@ -58,8 +62,9 @@ function createWritableStdioStream(fd) {
       // an error when trying to use it again. In that case, create the socket
       // using the existing handle instead of the fd.
       if (process.channel && process.channel.fd === fd) {
+        const { kChannelHandle } = require('internal/child_process');
         stream = new net.Socket({
-          handle: process.channel,
+          handle: process[kChannelHandle],
           readable: false,
           writable: true
         });
diff --git a/lib/internal/bootstrap/switches/is_not_main_thread.js b/lib/internal/bootstrap/switches/is_not_main_thread.js
index 852352eead0d7330cdb35ebebdf49fa26fb89d83..379ad0a587a22afa6d8f0478aae3aa7723eb8af8 100644
--- a/lib/internal/bootstrap/switches/is_not_main_thread.js
+++ b/lib/internal/bootstrap/switches/is_not_main_thread.js
@@ -4,8 +4,6 @@ const { ObjectDefineProperty } = primordials;
 
 delete process._debugProcess;
 delete process._debugEnd;
-delete process._startProfilerIdleNotifier;
-delete process._stopProfilerIdleNotifier;
 
 function defineStream(name, getter) {
   ObjectDefineProperty(process, name, {
diff --git a/lib/internal/buffer.js b/lib/internal/buffer.js
index b54ca4e767b893ac48703edee8eca2ec91aeb033..f366bef638fb48f828ea2cac5312f2fab84b2f96 100644
--- a/lib/internal/buffer.js
+++ b/lib/internal/buffer.js
@@ -3,6 +3,7 @@
 const {
   BigInt,
   Float32Array,
+  Float64Array,
   MathFloor,
   Number,
   Uint8Array,
@@ -17,12 +18,14 @@ const { validateNumber } = require('internal/validators');
 const {
   asciiSlice,
   base64Slice,
+  base64urlSlice,
   latin1Slice,
   hexSlice,
   ucs2Slice,
   utf8Slice,
   asciiWrite,
   base64Write,
+  base64urlWrite,
   latin1Write,
   hexWrite,
   ucs2Write,
@@ -59,8 +62,8 @@ function checkInt(value, min, max, buf, offset, byteLength) {
       if (min === 0 || min === 0n) {
         range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
       } else {
-        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +
-                `${(byteLength + 1) * 8 - 1}${n}`;
+        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and ` +
+                `< 2${n} ** ${(byteLength + 1) * 8 - 1}${n}`;
       }
     } else {
       range = `>= ${min}${n} and <= ${max}${n}`;
@@ -947,21 +950,28 @@ function writeFloatBackwards(val, offset = 0) {
   return offset;
 }
 
-class FastBuffer extends Uint8Array {}
+class FastBuffer extends Uint8Array {
+  // Using an explicit constructor here is necessary to avoid relying on
+  // `Array.prototype[Symbol.iterator]`, which can be mutated by users.
+  // eslint-disable-next-line no-useless-constructor
+  constructor(bufferOrLength, byteOffset, length) {
+    super(bufferOrLength, byteOffset, length);
+  }
+}
 
 function addBufferPrototypeMethods(proto) {
-  proto.readBigUInt64LE = readBigUInt64LE,
-  proto.readBigUInt64BE = readBigUInt64BE,
-  proto.readBigUint64LE = readBigUInt64LE,
-  proto.readBigUint64BE = readBigUInt64BE,
-  proto.readBigInt64LE = readBigInt64LE,
-  proto.readBigInt64BE = readBigInt64BE,
-  proto.writeBigUInt64LE = writeBigUInt64LE,
-  proto.writeBigUInt64BE = writeBigUInt64BE,
-  proto.writeBigUint64LE = writeBigUInt64LE,
-  proto.writeBigUint64BE = writeBigUInt64BE,
-  proto.writeBigInt64LE = writeBigInt64LE,
-  proto.writeBigInt64BE = writeBigInt64BE,
+  proto.readBigUInt64LE = readBigUInt64LE;
+  proto.readBigUInt64BE = readBigUInt64BE;
+  proto.readBigUint64LE = readBigUInt64LE;
+  proto.readBigUint64BE = readBigUInt64BE;
+  proto.readBigInt64LE = readBigInt64LE;
+  proto.readBigInt64BE = readBigInt64BE;
+  proto.writeBigUInt64LE = writeBigUInt64LE;
+  proto.writeBigUInt64BE = writeBigUInt64BE;
+  proto.writeBigUint64LE = writeBigUInt64LE;
+  proto.writeBigUint64BE = writeBigUInt64BE;
+  proto.writeBigInt64LE = writeBigInt64LE;
+  proto.writeBigInt64BE = writeBigInt64BE;
 
   proto.readUIntLE = readUIntLE;
   proto.readUInt32LE = readUInt32LE;
@@ -1018,12 +1028,14 @@ function addBufferPrototypeMethods(proto) {
 
   proto.asciiSlice = asciiSlice;
   proto.base64Slice = base64Slice;
+  proto.base64urlSlice = base64urlSlice;
   proto.latin1Slice = latin1Slice;
   proto.hexSlice = hexSlice;
   proto.ucs2Slice = ucs2Slice;
   proto.utf8Slice = utf8Slice;
   proto.asciiWrite = asciiWrite;
   proto.base64Write = base64Write;
+  proto.base64urlWrite = base64urlWrite;
   proto.latin1Write = latin1Write;
   proto.hexWrite = hexWrite;
   proto.ucs2Write = ucs2Write;
@@ -1042,4 +1054,6 @@ module.exports = {
   FastBuffer,
   addBufferPrototypeMethods,
   markAsUntransferable,
+  readUInt16BE,
+  readUInt32BE,
 };
diff --git a/lib/internal/child_process.js b/lib/internal/child_process.js
index 15d3ef3bf015679459ee4281538c7a498020589a..44d19966768587461031672a2997fd283d2063a0 100644
--- a/lib/internal/child_process.js
+++ b/lib/internal/child_process.js
@@ -22,7 +22,11 @@ const {
     ERR_MISSING_ARGS
   }
 } = require('internal/errors');
-const { validateString } = require('internal/validators');
+const {
+  validateArray,
+  validateOneOf,
+  validateString,
+} = require('internal/validators');
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
@@ -43,7 +47,7 @@ const { TTY } = internalBinding('tty_wrap');
 const { UDP } = internalBinding('udp_wrap');
 const SocketList = require('internal/socket_list');
 const { owner_symbol } = require('internal/async_hooks').symbols;
-const { convertToValidSignal } = require('internal/util');
+const { convertToValidSignal, deprecate } = require('internal/util');
 const { isArrayBufferView } = require('internal/util/types');
 const spawn_sync = internalBinding('spawn_sync');
 const { kStateSymbol } = require('internal/dgram');
@@ -67,6 +71,7 @@ let freeParser;
 let HTTPParser;
 
 const MAX_HANDLE_RETRANSMISSIONS = 3;
+const kChannelHandle = Symbol('kChannelHandle');
 const kIsUsedAsStdio = Symbol('kIsUsedAsStdio');
 
 // This object contain function to convert TCP objects to native handle objects
@@ -109,7 +114,7 @@ const handleConversion = {
         // The worker should keep track of the socket
         message.key = socket.server._connectionKey;
 
-        const firstTime = !this.channel.sockets.send[message.key];
+        const firstTime = !this[kChannelHandle].sockets.send[message.key];
         const socketList = getSocketList('send', this, message.key);
 
         // The server should no longer expose a .connection property
@@ -223,6 +228,7 @@ function stdioStringToArray(stdio, channel) {
 
   switch (stdio) {
     case 'ignore':
+    case 'overlapped':
     case 'pipe': options.push(stdio, stdio, stdio); break;
     case 'inherit': options.push(0, 1, 2); break;
     default:
@@ -301,9 +307,7 @@ function flushStdio(subprocess) {
     // TODO(addaleax): This doesn't necessarily account for all the ways in
     // which data can be read from a stream, e.g. being consumed on the
     // native layer directly as a StreamBase.
-    if (!stream || !stream.readable ||
-        stream._readableState.readableListening ||
-        stream[kIsUsedAsStdio]) {
+    if (!stream || !stream.readable || stream[kIsUsedAsStdio]) {
       continue;
     }
     stream.resume();
@@ -347,24 +351,17 @@ ChildProcess.prototype.spawn = function(options) {
   const ipcFd = stdio.ipcFd;
   stdio = options.stdio = stdio.stdio;
 
-  if (options.serialization !== undefined &&
-      options.serialization !== 'json' &&
-      options.serialization !== 'advanced') {
-    throw new ERR_INVALID_OPT_VALUE('options.serialization',
-                                    options.serialization);
-  }
 
+  validateOneOf(options.serialization, 'options.serialization',
+                [undefined, 'json', 'advanced'], true);
   const serialization = options.serialization || 'json';
 
   if (ipc !== undefined) {
     // Let child process know about opened IPC channel
     if (options.envPairs === undefined)
       options.envPairs = [];
-    else if (!ArrayIsArray(options.envPairs)) {
-      throw new ERR_INVALID_ARG_TYPE('options.envPairs',
-                                     'Array',
-                                     options.envPairs);
-    }
+    else
+      validateArray(options.envPairs, 'options.envPairs');
 
     options.envPairs.push(`NODE_CHANNEL_FD=${ipcFd}`);
     options.envPairs.push(`NODE_CHANNEL_SERIALIZATION_MODE=${serialization}`);
@@ -406,6 +403,8 @@ ChildProcess.prototype.spawn = function(options) {
     this._handle.close();
     this._handle = null;
     throw errnoException(err, 'spawn');
+  } else {
+    process.nextTick(onSpawnNT, this);
   }
 
   this.pid = this._handle.pid;
@@ -471,6 +470,11 @@ function onErrorNT(self, err) {
 }
 
 
+function onSpawnNT(self) {
+  self.emit('spawn');
+}
+
+
 ChildProcess.prototype.kill = function(sig) {
 
   const signal = sig === 0 ? sig :
@@ -509,40 +513,70 @@ ChildProcess.prototype.unref = function() {
 };
 
 class Control extends EventEmitter {
+  #channel = null;
+  #refs = 0;
+  #refExplicitlySet = false;
+
   constructor(channel) {
     super();
-    this.channel = channel;
-    this.refs = 0;
+    this.#channel = channel;
   }
-  ref() {
-    if (++this.refs === 1) {
-      this.channel.ref();
+
+  // The methods keeping track of the counter are being used to track the
+  // listener count on the child process object as well as when writes are
+  // in progress. Once the user has explicitly requested a certain state, these
+  // methods become no-ops in order to not interfere with the user's intentions.
+  refCounted() {
+    if (++this.#refs === 1 && !this.#refExplicitlySet) {
+      this.#channel.ref();
     }
   }
-  unref() {
-    if (--this.refs === 0) {
-      this.channel.unref();
+
+  unrefCounted() {
+    if (--this.#refs === 0 && !this.#refExplicitlySet) {
+      this.#channel.unref();
       this.emit('unref');
     }
   }
+
+  ref() {
+    this.#refExplicitlySet = true;
+    this.#channel.ref();
+  }
+
+  unref() {
+    this.#refExplicitlySet = true;
+    this.#channel.unref();
+  }
+
+  get fd() {
+    return this.#channel ? this.#channel.fd : undefined;
+  }
 }
 
+const channelDeprecationMsg = '_channel is deprecated. ' +
+                              'Use ChildProcess.channel instead.';
+
 let serialization;
 function setupChannel(target, channel, serializationMode) {
-  target.channel = channel;
+  const control = new Control(channel);
+  target.channel = control;
+  target[kChannelHandle] = channel;
 
-  // _channel can be deprecated in version 8
   ObjectDefineProperty(target, '_channel', {
-    get() { return target.channel; },
-    set(val) { target.channel = val; },
-    enumerable: true
+    get: deprecate(() => {
+      return target.channel;
+    }, channelDeprecationMsg, 'DEP0129'),
+    set: deprecate((val) => {
+      target.channel = val;
+    }, channelDeprecationMsg, 'DEP0129'),
+    configurable: true,
+    enumerable: false
   });
 
   target._handleQueue = null;
   target._pendingMessage = null;
 
-  const control = new Control(channel);
-
   if (serialization === undefined)
     serialization = require('internal/child_process/serialization');
   const {
@@ -695,7 +729,7 @@ function setupChannel(target, channel, serializationMode) {
     // Non-serializable messages should not reach the remote
     // end point; as any failure in the stringification there
     // will result in error message that is weakly consumable.
-    // So perform a sanity check on message prior to sending.
+    // So perform a final check on message prior to sending.
     if (typeof message !== 'string' &&
         typeof message !== 'object' &&
         typeof message !== 'number' &&
@@ -790,11 +824,11 @@ function setupChannel(target, channel, serializationMode) {
 
       if (wasAsyncWrite) {
         req.oncomplete = () => {
-          control.unref();
+          control.unrefCounted();
           if (typeof callback === 'function')
             callback(null);
         };
-        control.ref();
+        control.refCounted();
       } else if (typeof callback === 'function') {
         process.nextTick(callback, null);
       }
@@ -849,6 +883,7 @@ function setupChannel(target, channel, serializationMode) {
 
     // This marks the fact that the channel is actually disconnected.
     this.channel = null;
+    this[kChannelHandle] = null;
 
     if (this._pendingMessage)
       closePendingHandle(this);
@@ -935,9 +970,10 @@ function getValidStdio(stdio, sync) {
 
     if (stdio === 'ignore') {
       acc.push({ type: 'ignore' });
-    } else if (stdio === 'pipe' || (typeof stdio === 'number' && stdio < 0)) {
+    } else if (stdio === 'pipe' || stdio === 'overlapped' ||
+               (typeof stdio === 'number' && stdio < 0)) {
       const a = {
-        type: 'pipe',
+        type: stdio === 'overlapped' ? 'overlapped' : 'pipe',
         readable: i === 0,
         writable: i !== 0
       };
@@ -1005,7 +1041,7 @@ function getValidStdio(stdio, sync) {
 
 
 function getSocketList(type, worker, key) {
-  const sockets = worker.channel.sockets[type];
+  const sockets = worker[kChannelHandle].sockets[type];
   let socketList = sockets[key];
   if (!socketList) {
     const Construct = type === 'send' ? SocketListSend : SocketListReceive;
@@ -1023,8 +1059,7 @@ function maybeClose(subprocess) {
   }
 }
 
-function spawnSync(opts) {
-  const options = opts.options;
+function spawnSync(options) {
   const result = spawn_sync.spawn(options);
 
   if (result.output && options.encoding && options.encoding !== 'buffer') {
@@ -1039,9 +1074,9 @@ function spawnSync(opts) {
   result.stderr = result.output && result.output[2];
 
   if (result.error) {
-    result.error = errnoException(result.error, 'spawnSync ' + opts.file);
-    result.error.path = opts.file;
-    result.error.spawnargs = opts.args.slice(1);
+    result.error = errnoException(result.error, 'spawnSync ' + options.file);
+    result.error.path = options.file;
+    result.error.spawnargs = options.args.slice(1);
   }
 
   return result;
@@ -1049,6 +1084,7 @@ function spawnSync(opts) {
 
 module.exports = {
   ChildProcess,
+  kChannelHandle,
   setupChannel,
   getValidStdio,
   stdioStringToArray,
diff --git a/lib/internal/child_process/serialization.js b/lib/internal/child_process/serialization.js
index df8a6ca67236c5c3e9742c6c03a67b5c3c9876f6..ec858f401bea9eb8cd34e7c97244bbce90c770b7 100644
--- a/lib/internal/child_process/serialization.js
+++ b/lib/internal/child_process/serialization.js
@@ -3,13 +3,16 @@
 const {
   JSONParse,
   JSONStringify,
+  StringPrototypeSplit,
   Symbol,
+  TypedArrayPrototypeSubarray,
 } = primordials;
 const { Buffer } = require('buffer');
 const { StringDecoder } = require('string_decoder');
 const v8 = require('v8');
 const { isArrayBufferView } = require('internal/util/types');
 const assert = require('internal/assert');
+const { streamBaseState, kLastWriteWasAsync } = internalBinding('stream_wrap');
 
 const kMessageBuffer = Symbol('kMessageBuffer');
 const kJSONBuffer = Symbol('kJSONBuffer');
@@ -63,8 +66,8 @@ const advanced = {
       }
 
       const deserializer = new ChildProcessDeserializer(
-        messageBuffer.subarray(4, 4 + size));
-      messageBuffer = messageBuffer.subarray(4 + size);
+        TypedArrayPrototypeSubarray(messageBuffer, 4, 4 + size));
+      messageBuffer = TypedArrayPrototypeSubarray(messageBuffer, 4 + size);
 
       deserializer.readHeader();
       yield deserializer.readValue();
@@ -80,10 +83,16 @@ const advanced = {
     const serializedMessage = ser.releaseBuffer();
     const sizeBuffer = Buffer.allocUnsafe(4);
     sizeBuffer.writeUInt32BE(serializedMessage.length);
-    return channel.writeBuffer(req, Buffer.concat([
+
+    const buffer = Buffer.concat([
       sizeBuffer,
-      serializedMessage
-    ]), handle);
+      serializedMessage,
+    ]);
+    const result = channel.writeBuffer(req, buffer, handle);
+    // Mirror what stream_base_commons.js does for Buffer retention.
+    if (streamBaseState[kLastWriteWasAsync])
+      req.buffer = buffer;
+    return result;
   },
 };
 
@@ -98,7 +107,8 @@ const json = {
 
     if (channel[kStringDecoder] === undefined)
       channel[kStringDecoder] = new StringDecoder('utf8');
-    const chunks = channel[kStringDecoder].write(readData).split('\n');
+    const chunks =
+      StringPrototypeSplit(channel[kStringDecoder].write(readData), '\n');
     const numCompleteChunks = chunks.length - 1;
     // Last line does not have trailing linebreak
     const incompleteChunk = chunks[numCompleteChunks];
diff --git a/lib/internal/cluster/child.js b/lib/internal/cluster/child.js
index 74f30c0d2ece905cb10c5afdfcf171f6e3cbf285..90dce42fa6fa703c7b7189132720dac9e32e230f 100644
--- a/lib/internal/cluster/child.js
+++ b/lib/internal/cluster/child.js
@@ -1,8 +1,11 @@
 'use strict';
 
 const {
-  Map,
+  ArrayPrototypeJoin,
+  FunctionPrototype,
   ObjectAssign,
+  ReflectApply,
+  SafeMap,
 } = primordials;
 
 const assert = require('internal/assert');
@@ -12,9 +15,9 @@ const { owner_symbol } = require('internal/async_hooks').symbols;
 const Worker = require('internal/cluster/worker');
 const { internal, sendHelper } = require('internal/cluster/utils');
 const cluster = new EventEmitter();
-const handles = new Map();
-const indexes = new Map();
-const noop = () => {};
+const handles = new SafeMap();
+const indexes = new SafeMap();
+const noop = FunctionPrototype;
 
 module.exports = cluster;
 
@@ -49,7 +52,7 @@ cluster._setupWorker = function() {
     if (message.act === 'newconn')
       onconnection(message, handle);
     else if (message.act === 'disconnect')
-      _disconnect.call(worker, true);
+      ReflectApply(_disconnect, worker, [true]);
   }
 };
 
@@ -62,10 +65,13 @@ cluster._getServer = function(obj, options, cb) {
       process.platform !== 'win32')
     address = path.resolve(address);
 
-  const indexesKey = [address,
-                      options.port,
-                      options.addressType,
-                      options.fd ].join(':');
+  const indexesKey = ArrayPrototypeJoin(
+    [
+      address,
+      options.port,
+      options.addressType,
+      options.fd,
+    ], ':');
 
   let index = indexes.get(indexesKey);
 
@@ -119,7 +125,7 @@ function shared(message, handle, indexesKey, cb) {
     send({ act: 'close', key });
     handles.delete(key);
     indexes.delete(indexesKey);
-    return close.apply(handle, arguments);
+    return ReflectApply(close, handle, arguments);
   };
   assert(handles.has(key) === false);
   handles.set(key, handle);
@@ -228,9 +234,9 @@ function _disconnect(masterInitiated) {
 
 // Extend generic Worker with methods specific to worker processes.
 Worker.prototype.disconnect = function() {
-  if (![ 'disconnecting', 'destroying' ].includes(this.state)) {
+  if (this.state !== 'disconnecting' && this.state !== 'destroying') {
     this.state = 'disconnecting';
-    _disconnect.call(this);
+    ReflectApply(_disconnect, this, []);
   }
 
   return this;
diff --git a/lib/internal/cluster/master.js b/lib/internal/cluster/master.js
index 9e2c7cbecb9963e5a8cb4f9f0516b264ccebbb3b..2ae18165695be78f2a64a48ef49c24b202a05cfd 100644
--- a/lib/internal/cluster/master.js
+++ b/lib/internal/cluster/master.js
@@ -1,9 +1,14 @@
 'use strict';
 
 const {
-  Map,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSome,
   ObjectKeys,
   ObjectValues,
+  RegExpPrototypeTest,
+  SafeMap,
+  StringPrototypeStartsWith,
 } = primordials;
 
 const assert = require('internal/assert');
@@ -23,7 +28,7 @@ const { validatePort } = require('internal/validators');
 
 module.exports = cluster;
 
-const handles = new Map();
+const handles = new SafeMap();
 cluster.isWorker = false;
 cluster.isMaster = true;
 cluster.Worker = Worker;
@@ -53,7 +58,7 @@ cluster.schedulingPolicy = schedulingPolicy;
 
 cluster.setupMaster = function(options) {
   const settings = {
-    args: process.argv.slice(2),
+    args: ArrayPrototypeSlice(process.argv, 2),
     exec: process.argv[1],
     execArgv: process.execArgv,
     silent: false,
@@ -65,8 +70,10 @@ cluster.setupMaster = function(options) {
   // Without --logfile=v8-%p.log, everything ends up in a single, unusable
   // file. (Unusable because what V8 logs are memory addresses and each
   // process has its own memory mappings.)
-  if (settings.execArgv.some((s) => s.startsWith('--prof')) &&
-      !settings.execArgv.some((s) => s.startsWith('--logfile='))) {
+  if (ArrayPrototypeSome(settings.execArgv,
+                         (s) => StringPrototypeStartsWith(s, '--prof')) &&
+      !ArrayPrototypeSome(settings.execArgv,
+                          (s) => StringPrototypeStartsWith(s, '--logfile='))) {
     settings.execArgv = [...settings.execArgv, '--logfile=v8-%p.log'];
   }
 
@@ -109,8 +116,9 @@ function createWorkerProcess(id, env) {
   const nodeOptions = process.env.NODE_OPTIONS ?
     process.env.NODE_OPTIONS : '';
 
-  if (execArgv.some((arg) => arg.match(debugArgRegex)) ||
-      nodeOptions.match(debugArgRegex)) {
+  if (ArrayPrototypeSome(execArgv,
+                         (arg) => RegExpPrototypeTest(debugArgRegex, arg)) ||
+      RegExpPrototypeTest(debugArgRegex, nodeOptions)) {
     let inspectPort;
     if ('inspectPort' in cluster.settings) {
       if (typeof cluster.settings.inspectPort === 'function')
@@ -126,7 +134,7 @@ function createWorkerProcess(id, env) {
       debugPortOffset++;
     }
 
-    execArgv.push(`--inspect-port=${inspectPort}`);
+    ArrayPrototypePush(execArgv, `--inspect-port=${inspectPort}`);
   }
 
   return fork(cluster.settings.exec, cluster.settings.args, {
diff --git a/lib/internal/cluster/round_robin_handle.js b/lib/internal/cluster/round_robin_handle.js
index 636bdcc88982165f938141c5e80658ad6f38ad18..c195fc9e941831aa19415e23eef6f98b19c05ab7 100644
--- a/lib/internal/cluster/round_robin_handle.js
+++ b/lib/internal/cluster/round_robin_handle.js
@@ -2,22 +2,23 @@
 
 const {
   ArrayIsArray,
+  ArrayPrototypePush,
+  ArrayPrototypeShift,
   Boolean,
-  Map,
+  SafeMap,
 } = primordials;
 
 const assert = require('internal/assert');
 const net = require('net');
 const { sendHelper } = require('internal/cluster/utils');
-const uv = internalBinding('uv');
 const { constants } = internalBinding('tcp_wrap');
 
 module.exports = RoundRobinHandle;
 
 function RoundRobinHandle(key, address, { port, fd, flags }) {
   this.key = key;
-  this.all = new Map();
-  this.free = new Map();
+  this.all = new SafeMap();
+  this.free = new SafeMap();
   this.handles = [];
   this.handle = null;
   this.server = net.createServer(assert.fail);
@@ -65,10 +66,7 @@ RoundRobinHandle.prototype.add = function(worker, send) {
   // Still busy binding.
   this.server.once('listening', done);
   this.server.once('error', (err) => {
-    // Hack: translate 'EADDRINUSE' error string back to numeric error code.
-    // It works but ideally we'd have some backchannel between the net and
-    // cluster modules for stuff like this.
-    send(uv[`UV_${err.errno}`], null);
+    send(err.errno, null);
   });
 };
 
@@ -94,11 +92,11 @@ RoundRobinHandle.prototype.remove = function(worker) {
 };
 
 RoundRobinHandle.prototype.distribute = function(err, handle) {
-  this.handles.push(handle);
-  const [ workerEntry ] = this.free;
+  ArrayPrototypePush(this.handles, handle);
+  const [ workerEntry ] = this.free; // this.free is a SafeMap
 
   if (ArrayIsArray(workerEntry)) {
-    const [ workerId, worker ] = workerEntry;
+    const { 0: workerId, 1: worker } = workerEntry;
     this.free.delete(workerId);
     this.handoff(worker);
   }
@@ -109,7 +107,7 @@ RoundRobinHandle.prototype.handoff = function(worker) {
     return;  // Worker is closing (or has closed) the server.
   }
 
-  const handle = this.handles.shift();
+  const handle = ArrayPrototypeShift(this.handles);
 
   if (handle === undefined) {
     this.free.set(worker.id, worker);  // Add to ready queue again.
diff --git a/lib/internal/cluster/shared_handle.js b/lib/internal/cluster/shared_handle.js
index 656b1292988948217bbbba586661eaf819c7a707..87b83df20081b1b9e07f5f23e80d0f5d712a7210 100644
--- a/lib/internal/cluster/shared_handle.js
+++ b/lib/internal/cluster/shared_handle.js
@@ -1,5 +1,5 @@
 'use strict';
-const { Map } = primordials;
+const { SafeMap } = primordials;
 const assert = require('internal/assert');
 const dgram = require('internal/dgram');
 const net = require('net');
@@ -8,7 +8,7 @@ module.exports = SharedHandle;
 
 function SharedHandle(key, address, { port, addressType, fd, flags }) {
   this.key = key;
-  this.workers = new Map();
+  this.workers = new SafeMap();
   this.handle = null;
   this.errno = 0;
 
diff --git a/lib/internal/cluster/utils.js b/lib/internal/cluster/utils.js
index 9e7a1186ffc2bfdb390ff64a29084e7ed63fb871..732d33e46936a8ab16baa2e356528a68cfda85e1 100644
--- a/lib/internal/cluster/utils.js
+++ b/lib/internal/cluster/utils.js
@@ -1,7 +1,8 @@
 'use strict';
 
 const {
-  Map,
+  ReflectApply,
+  SafeMap,
 } = primordials;
 
 module.exports = {
@@ -9,7 +10,7 @@ module.exports = {
   internal
 };
 
-const callbacks = new Map();
+const callbacks = new SafeMap();
 let seq = 0;
 
 function sendHelper(proc, message, handle, cb) {
@@ -44,6 +45,6 @@ function internal(worker, cb) {
       }
     }
 
-    fn.apply(worker, arguments);
+    ReflectApply(fn, worker, arguments);
   };
 }
diff --git a/lib/internal/cluster/worker.js b/lib/internal/cluster/worker.js
index 516b7a3b73d787ddf3567d3ac59c176bf8c3069e..cdc1cd97ce06c833a1ffea35ae496a39f517422d 100644
--- a/lib/internal/cluster/worker.js
+++ b/lib/internal/cluster/worker.js
@@ -2,6 +2,7 @@
 
 const {
   ObjectSetPrototypeOf,
+  ReflectApply,
 } = primordials;
 
 const EventEmitter = require('events');
@@ -13,7 +14,7 @@ function Worker(options) {
   if (!(this instanceof Worker))
     return new Worker(options);
 
-  EventEmitter.call(this);
+  ReflectApply(EventEmitter, this, []);
 
   if (options === null || typeof options !== 'object')
     options = {};
@@ -38,11 +39,11 @@ ObjectSetPrototypeOf(Worker.prototype, EventEmitter.prototype);
 ObjectSetPrototypeOf(Worker, EventEmitter);
 
 Worker.prototype.kill = function() {
-  this.destroy.apply(this, arguments);
+  ReflectApply(this.destroy, this, arguments);
 };
 
 Worker.prototype.send = function() {
-  return this.process.send.apply(this.process, arguments);
+  return ReflectApply(this.process.send, this.process, arguments);
 };
 
 Worker.prototype.isDead = function() {
diff --git a/lib/internal/console/constructor.js b/lib/internal/console/constructor.js
index af027cf3b3cc59830aa0c8fddf568f8588dedd75..7881dc1c133676e2dd80a10ee9448a4f2cbc7f0c 100644
--- a/lib/internal/console/constructor.js
+++ b/lib/internal/console/constructor.js
@@ -6,19 +6,36 @@
 const {
   ArrayFrom,
   ArrayIsArray,
+  ArrayPrototypeForEach,
+  ArrayPrototypePush,
+  ArrayPrototypeUnshift,
   Boolean,
-  Error,
-  Map,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  MathFloor,
+  Number,
+  NumberPrototypeToFixed,
+  ObjectCreate,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectKeys,
   ObjectPrototypeHasOwnProperty,
   ObjectValues,
+  ReflectApply,
+  ReflectConstruct,
   ReflectOwnKeys,
+  SafeArrayIterator,
+  SafeMap,
+  SafeWeakMap,
+  StringPrototypeIncludes,
+  StringPrototypePadStart,
+  StringPrototypeRepeat,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
   Symbol,
   SymbolHasInstance,
   SymbolToStringTag,
-  WeakMap,
 } = primordials;
 
 const { trace } = internalBinding('trace_events');
@@ -55,6 +72,9 @@ const kTraceBegin = CHAR_LOWERCASE_B;
 const kTraceEnd = CHAR_LOWERCASE_E;
 const kTraceInstant = CHAR_LOWERCASE_N;
 
+const kSecond = 1000;
+const kMinute = 60 * kSecond;
+const kHour = 60 * kMinute;
 const kMaxGroupIndentation = 1000;
 
 // Lazy loaded for startup performance.
@@ -75,14 +95,14 @@ const kBindStreamsLazy = Symbol('kBindStreamsLazy');
 const kUseStdout = Symbol('kUseStdout');
 const kUseStderr = Symbol('kUseStderr');
 
-const optionsMap = new WeakMap();
+const optionsMap = new SafeWeakMap();
 
 function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
   // We have to test new.target here to see if this function is called
   // with new, because we need to define a custom instanceof to accommodate
   // the global console.
   if (!new.target) {
-    return new Console(...arguments);
+    return ReflectConstruct(Console, arguments);
   }
 
   if (!options || typeof options.write === 'function') {
@@ -132,16 +152,15 @@ function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
   }
 
   // Bind the prototype functions to this Console instance
-  const keys = ObjectKeys(Console.prototype);
-  for (const key of keys) {
+  ArrayPrototypeForEach(ObjectKeys(Console.prototype), (key) => {
     // We have to bind the methods grabbed from the instance instead of from
     // the prototype so that users extending the Console can override them
     // from the prototype chain of the subclass.
-    this[key] = this[key].bind(this);
+    this[key] = FunctionPrototypeBind(this[key], this);
     ObjectDefineProperty(this[key], 'name', {
       value: key
     });
-  }
+  });
 
   this[kBindStreamsEager](stdout, stderr);
   this[kBindProperties](ignoreErrors, colorMode, groupIndentation);
@@ -219,9 +238,9 @@ ObjectDefineProperties(Console.prototype, {
           ...consolePropAttributes,
           value: Boolean(ignoreErrors)
         },
-        '_times': { ...consolePropAttributes, value: new Map() },
+        '_times': { ...consolePropAttributes, value: new SafeMap() },
         // Corresponds to https://console.spec.whatwg.org/#count-map
-        [kCounts]: { ...consolePropAttributes, value: new Map() },
+        [kCounts]: { ...consolePropAttributes, value: new SafeMap() },
         [kColorMode]: { ...consolePropAttributes, value: colorMode },
         [kIsConsole]: { ...consolePropAttributes, value: true },
         [kGroupIndent]: { ...consolePropAttributes, value: '' },
@@ -250,8 +269,8 @@ ObjectDefineProperties(Console.prototype, {
         this._stdoutErrorHandler : this._stderrErrorHandler;
 
       if (groupIndent.length !== 0) {
-        if (string.includes('\n')) {
-          string = string.replace(/\n/g, `\n${groupIndent}`);
+        if (StringPrototypeIncludes(string, '\n')) {
+          string = StringPrototypeReplace(string, /\n/g, `\n${groupIndent}`);
         }
         string = groupIndent + string;
       }
@@ -305,14 +324,16 @@ ObjectDefineProperties(Console.prototype, {
     ...consolePropAttributes,
     value: function(args) {
       const opts = this[kGetInspectOptions](this._stdout);
-      return formatWithOptions(opts, ...args);
+      ArrayPrototypeUnshift(args, opts);
+      return ReflectApply(formatWithOptions, null, args);
     }
   },
   [kFormatForStderr]: {
     ...consolePropAttributes,
     value: function(args) {
       const opts = this[kGetInspectOptions](this._stderr);
-      return formatWithOptions(opts, ...args);
+      ArrayPrototypeUnshift(args, opts);
+      return ReflectApply(formatWithOptions, null, args);
     }
   },
 });
@@ -390,15 +411,15 @@ const consoleMethods = {
       name: 'Trace',
       message: this[kFormatForStderr](args)
     };
-    // eslint-disable-next-line no-restricted-syntax
-    Error.captureStackTrace(err, trace);
+    ErrorCaptureStackTrace(err, trace);
     this.error(err.stack);
   },
 
   assert(expression, ...args) {
     if (!expression) {
       args[0] = `Assertion failed${args.length === 0 ? '' : `: ${args[0]}`}`;
-      this.warn(...args);  // The arguments will be formatted in warn() again
+      // The arguments will be formatted in warn() again
+      ReflectApply(this.warn, this, args);
     }
   },
 
@@ -444,15 +465,18 @@ const consoleMethods = {
 
   group(...data) {
     if (data.length > 0) {
-      this.log(...data);
+      ReflectApply(this.log, this, data);
     }
-    this[kGroupIndent] += ' '.repeat(this[kGroupIndentationWidth]);
+    this[kGroupIndent] +=
+      StringPrototypeRepeat(' ', this[kGroupIndentationWidth]);
   },
 
   groupEnd() {
-    this[kGroupIndent] =
-      this[kGroupIndent].slice(0, this[kGroupIndent].length -
-        this[kGroupIndentationWidth]);
+    this[kGroupIndent] = StringPrototypeSlice(
+      this[kGroupIndent],
+      0,
+      this[kGroupIndent].length - this[kGroupIndentationWidth]
+    );
   },
 
   // https://console.spec.whatwg.org/#table
@@ -497,19 +521,19 @@ const consoleMethods = {
       let length = 0;
       if (mapIter) {
         for (; i < tabularData.length / 2; ++i) {
-          keys.push(_inspect(tabularData[i * 2]));
-          values.push(_inspect(tabularData[i * 2 + 1]));
+          ArrayPrototypePush(keys, _inspect(tabularData[i * 2]));
+          ArrayPrototypePush(values, _inspect(tabularData[i * 2 + 1]));
           length++;
         }
       } else {
-        for (const [k, v] of tabularData) {
-          keys.push(_inspect(k));
-          values.push(_inspect(v));
+        for (const { 0: k, 1: v } of tabularData) {
+          ArrayPrototypePush(keys, _inspect(k));
+          ArrayPrototypePush(values, _inspect(v));
           length++;
         }
       }
       return final([
-        iterKey, keyKey, valuesKey
+        iterKey, keyKey, valuesKey,
       ], [
         getIndexArray(length),
         keys,
@@ -526,13 +550,13 @@ const consoleMethods = {
       const values = [];
       let length = 0;
       for (const v of tabularData) {
-        values.push(_inspect(v));
+        ArrayPrototypePush(values, _inspect(v));
         length++;
       }
       return final([iterKey, valuesKey], [getIndexArray(length), values]);
     }
 
-    const map = {};
+    const map = ObjectCreate(null);
     let hasPrimitives = false;
     const valuesKeyArray = [];
     const indexKeyArray = ObjectKeys(tabularData);
@@ -561,11 +585,11 @@ const consoleMethods = {
     const keys = ObjectKeys(map);
     const values = ObjectValues(map);
     if (hasPrimitives) {
-      keys.push(valuesKey);
-      values.push(valuesKeyArray);
+      ArrayPrototypePush(keys, valuesKey);
+      ArrayPrototypePush(values, valuesKeyArray);
     }
-    keys.unshift(indexKey);
-    values.unshift(indexKeyArray);
+    ArrayPrototypeUnshift(keys, indexKey);
+    ArrayPrototypeUnshift(values, indexKeyArray);
 
     return final(keys, values);
   },
@@ -580,14 +604,54 @@ function timeLogImpl(self, name, label, data) {
   }
   const duration = process.hrtime(time);
   const ms = duration[0] * 1000 + duration[1] / 1e6;
+
+  const formatted = formatTime(ms);
+
   if (data === undefined) {
-    self.log('%s: %sms', label, ms.toFixed(3));
+    self.log('%s: %s', label, formatted);
   } else {
-    self.log('%s: %sms', label, ms.toFixed(3), ...data);
+    self.log('%s: %s', label, formatted, ...new SafeArrayIterator(data));
   }
   return true;
 }
 
+function pad(value) {
+  return StringPrototypePadStart(`${value}`, 2, '0');
+}
+
+function formatTime(ms) {
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+
+  if (ms >= kSecond) {
+    if (ms >= kMinute) {
+      if (ms >= kHour) {
+        hours = MathFloor(ms / kHour);
+        ms = ms % kHour;
+      }
+      minutes = MathFloor(ms / kMinute);
+      ms = ms % kMinute;
+    }
+    seconds = ms / kSecond;
+  }
+
+  if (hours !== 0 || minutes !== 0) {
+    ({ 0: seconds, 1: ms } = StringPrototypeSplit(
+      NumberPrototypeToFixed(seconds, 3),
+      '.'
+    ));
+    const res = hours !== 0 ? `${hours}:${pad(minutes)}` : minutes;
+    return `${res}:${pad(seconds)}.${ms} (${hours !== 0 ? 'h:m' : ''}m:ss.mmm)`;
+  }
+
+  if (seconds !== 0) {
+    return `${NumberPrototypeToFixed(seconds, 3)}s`;
+  }
+
+  return `${Number(NumberPrototypeToFixed(ms, 3))}ms`;
+}
+
 const keyKey = 'Key';
 const valuesKey = 'Values';
 const indexKey = '(index)';
@@ -609,5 +673,6 @@ Console.prototype.groupCollapsed = Console.prototype.group;
 module.exports = {
   Console,
   kBindStreamsLazy,
-  kBindProperties
+  kBindProperties,
+  formatTime // exported for tests
 };
diff --git a/lib/internal/console/global.js b/lib/internal/console/global.js
index 1c615c784515103dab462e3cb8398c0b5c8ee445..d6c0c24d529dccc5821ce8bfc80e304e6f056e2d 100644
--- a/lib/internal/console/global.js
+++ b/lib/internal/console/global.js
@@ -13,6 +13,7 @@
 // in the global console prototype chain anymore.
 
 const {
+  FunctionPrototypeBind,
   ObjectCreate,
   ReflectDefineProperty,
   ReflectGetOwnPropertyDescriptor,
@@ -37,7 +38,7 @@ for (const prop of ReflectOwnKeys(Console.prototype)) {
   const desc = ReflectGetOwnPropertyDescriptor(Console.prototype, prop);
   if (typeof desc.value === 'function') { // fix the receiver
     const name = desc.value.name;
-    desc.value = desc.value.bind(globalConsole);
+    desc.value = FunctionPrototypeBind(desc.value, globalConsole);
     ReflectDefineProperty(desc.value, 'name', { value: name });
   }
   ReflectDefineProperty(globalConsole, prop, desc);
diff --git a/lib/internal/crypto/cipher.js b/lib/internal/crypto/cipher.js
index ee1422da0fd2d59e2510886adccdfc6d470fb408..80b0c0e9dab38274ab99e9065a9200cb1951e651 100644
--- a/lib/internal/crypto/cipher.js
+++ b/lib/internal/crypto/cipher.js
@@ -14,7 +14,7 @@ const {
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_OPT_VALUE
 } = require('internal/errors').codes;
-const { validateString } = require('internal/validators');
+const { validateEncoding, validateString } = require('internal/validators');
 
 const {
   preparePrivateKey,
@@ -151,7 +151,9 @@ Cipher.prototype.update = function update(data, inputEncoding, outputEncoding) {
   inputEncoding = inputEncoding || encoding;
   outputEncoding = outputEncoding || encoding;
 
-  if (typeof data !== 'string' && !isArrayBufferView(data)) {
+  if (typeof data === 'string') {
+    validateEncoding(data, inputEncoding);
+  } else if (!isArrayBufferView(data)) {
     throw new ERR_INVALID_ARG_TYPE(
       'data', ['string', 'Buffer', 'TypedArray', 'DataView'], data);
   }
diff --git a/lib/internal/crypto/diffiehellman.js b/lib/internal/crypto/diffiehellman.js
index 8f86911757fe1ff01101b20804c71a4ae7a00b7e..752aabb04c92775dec790bd46d24ce14aae7d221 100644
--- a/lib/internal/crypto/diffiehellman.js
+++ b/lib/internal/crypto/diffiehellman.js
@@ -75,12 +75,20 @@ function DiffieHellman(sizeOrKey, keyEncoding, generator, genEncoding) {
   if (typeof sizeOrKey !== 'number')
     sizeOrKey = toBuf(sizeOrKey, keyEncoding);
 
-  if (!generator)
+  if (!generator) {
     generator = DH_GENERATOR;
-  else if (typeof generator === 'number')
+  } else if (typeof generator === 'number') {
     validateInt32(generator, 'generator');
-  else
+  } else if (generator !== true) {
     generator = toBuf(generator, genEncoding);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE(
+      'generator',
+      ['number', 'string', 'ArrayBuffer', 'Buffer', 'TypedArray', 'DataView'],
+      generator
+    );
+  }
+
 
   this[kHandle] = new _DiffieHellman(sizeOrKey, generator);
   ObjectDefineProperty(this, 'verifyError', {
diff --git a/lib/internal/crypto/hash.js b/lib/internal/crypto/hash.js
index d8866ca6df90a0226674ed9aa49786344eb35fbf..1cf0188da2f35ecffdf5dd45e08426e51c4e42c3 100644
--- a/lib/internal/crypto/hash.js
+++ b/lib/internal/crypto/hash.js
@@ -27,10 +27,8 @@ const {
   ERR_CRYPTO_HASH_UPDATE_FAILED,
   ERR_INVALID_ARG_TYPE
 } = require('internal/errors').codes;
-const {
-  validateString,
-  validateUint32
-} = require('internal/validators');
+const { validateEncoding, validateString, validateUint32 } =
+  require('internal/validators');
 const { isArrayBufferView } = require('internal/util/types');
 const LazyTransform = require('internal/streams/lazy_transform');
 const kState = Symbol('kState');
@@ -74,20 +72,20 @@ Hash.prototype._flush = function _flush(callback) {
 };
 
 Hash.prototype.update = function update(data, encoding) {
+  encoding = encoding || getDefaultEncoding();
+
   const state = this[kState];
   if (state[kFinalized])
     throw new ERR_CRYPTO_HASH_FINALIZED();
 
-  if (typeof data !== 'string' && !isArrayBufferView(data)) {
-    throw new ERR_INVALID_ARG_TYPE('data',
-                                   ['string',
-                                    'Buffer',
-                                    'TypedArray',
-                                    'DataView'],
-                                   data);
+  if (typeof data === 'string') {
+    validateEncoding(data, encoding);
+  } else if (!isArrayBufferView(data)) {
+    throw new ERR_INVALID_ARG_TYPE(
+      'data', ['string', 'Buffer', 'TypedArray', 'DataView'], data);
   }
 
-  if (!this[kHandle].update(data, encoding || getDefaultEncoding()))
+  if (!this[kHandle].update(data, encoding))
     throw new ERR_CRYPTO_HASH_UPDATE_FAILED();
   return this;
 };
diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js
index 3c976ca349e4fad8c98d24386325b5ab6d60620e..89a78f9888f18f8db0dc6f2e88027d880cd26219 100644
--- a/lib/internal/crypto/keys.js
+++ b/lib/internal/crypto/keys.js
@@ -48,12 +48,12 @@ for (const m of [[kKeyEncodingPKCS1, 'pkcs1'], [kKeyEncodingPKCS8, 'pkcs8'],
 // which requires the KeyObject base class to be implemented in C++.
 // The creation requires a callback to make sure that the NativeKeyObject
 // base class cannot exist without the other KeyObject implementations.
-const [
-  KeyObject,
-  SecretKeyObject,
-  PublicKeyObject,
-  PrivateKeyObject
-] = createNativeKeyObjectClass((NativeKeyObject) => {
+const {
+  0: KeyObject,
+  1: SecretKeyObject,
+  2: PublicKeyObject,
+  3: PrivateKeyObject,
+} = createNativeKeyObjectClass((NativeKeyObject) => {
   // Publicly visible KeyObject class.
   class KeyObject extends NativeKeyObject {
     constructor(type, handle) {
diff --git a/lib/internal/crypto/pbkdf2.js b/lib/internal/crypto/pbkdf2.js
index 20f6f682254036b2cd6d25712526fffc1274c034..00a031c6ece0a0ec86afba6653d8fc8ac2a1c82f 100644
--- a/lib/internal/crypto/pbkdf2.js
+++ b/lib/internal/crypto/pbkdf2.js
@@ -4,7 +4,6 @@ const { AsyncWrap, Providers } = internalBinding('async_wrap');
 const { Buffer } = require('buffer');
 const { pbkdf2: _pbkdf2 } = internalBinding('crypto');
 const { validateUint32 } = require('internal/validators');
-const { deprecate } = require('internal/util');
 const {
   ERR_CRYPTO_INVALID_DIGEST,
   ERR_CRYPTO_PBKDF2_ERROR,
@@ -52,21 +51,13 @@ function pbkdf2Sync(password, salt, iterations, keylen, digest) {
   return keybuf.toString(encoding);
 }
 
-const defaultDigest = deprecate(() => 'sha1',
-                                'Calling pbkdf2 or pbkdf2Sync with "digest" ' +
-                                'set to null is deprecated.',
-                                'DEP0009');
-
 function check(password, salt, iterations, keylen, digest) {
-  if (typeof digest !== 'string') {
-    if (digest !== null)
-      throw new ERR_INVALID_ARG_TYPE('digest', ['string', 'null'], digest);
-    digest = defaultDigest();
-  }
+  if (typeof digest !== 'string')
+    throw new ERR_INVALID_ARG_TYPE('digest', 'string', digest);
 
   password = getArrayBufferView(password, 'password');
   salt = getArrayBufferView(salt, 'salt');
-  validateUint32(iterations, 'iterations');
+  validateUint32(iterations, 'iterations', true);
   validateUint32(keylen, 'keylen');
 
   return { password, salt, iterations, keylen, digest };
diff --git a/lib/internal/crypto/random.js b/lib/internal/crypto/random.js
index 9e0500ea3a67bb6e0c75fa74c5256e6869f4e052..21eb9aa125bc2f3218da975a1b0390379dfe6310 100644
--- a/lib/internal/crypto/random.js
+++ b/lib/internal/crypto/random.js
@@ -7,19 +7,32 @@ const {
 } = primordials;
 
 const { AsyncWrap, Providers } = internalBinding('async_wrap');
-const { kMaxLength } = require('buffer');
-const { randomBytes: _randomBytes } = internalBinding('crypto');
 const {
-  ERR_INVALID_ARG_TYPE,
-  ERR_INVALID_CALLBACK,
-  ERR_OUT_OF_RANGE
-} = require('internal/errors').codes;
-const { validateNumber } = require('internal/validators');
+  Buffer,
+  kMaxLength,
+} = require('buffer');
+const {
+  randomBytes: _randomBytes,
+  secureBuffer,
+} = internalBinding('crypto');
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_CALLBACK,
+    ERR_OUT_OF_RANGE,
+    ERR_OPERATION_FAILED,
+  }
+} = require('internal/errors');
+const {
+  validateBoolean,
+  validateNumber,
+  validateObject,
+} = require('internal/validators');
 const { isArrayBufferView } = require('internal/util/types');
 const { FastBuffer } = require('internal/buffer');
 
-const kMaxUint32 = 2 ** 32 - 1;
-const kMaxPossibleLength = MathMin(kMaxLength, kMaxUint32);
+const kMaxInt32 = 2 ** 31 - 1;
+const kMaxPossibleLength = MathMin(kMaxLength, kMaxInt32);
 
 function assertOffset(offset, elementSize, length) {
   validateNumber(offset, 'offset');
@@ -163,20 +176,20 @@ function randomInt(min, max, callback) {
                                `<= ${RAND_MAX}`, range);
   }
 
-  const excess = RAND_MAX % range;
-  const randLimit = RAND_MAX - excess;
+  // For (x % range) to produce an unbiased value greater than or equal to 0 and
+  // less than range, x must be drawn randomly from the set of integers greater
+  // than or equal to 0 and less than randLimit.
+  const randLimit = RAND_MAX - (RAND_MAX % range);
 
   if (isSync) {
     // Sync API
     while (true) {
       const x = randomBytes(6).readUIntBE(0, 6);
-      // If x > (maxVal - (maxVal % range)), we will get "modulo bias"
-      if (x > randLimit) {
-        // Try again
+      if (x >= randLimit) {
+        // Try again.
         continue;
       }
-      const n = (x % range) + min;
-      return n;
+      return (x % range) + min;
     }
   } else {
     // Async API
@@ -184,9 +197,8 @@ function randomInt(min, max, callback) {
       randomBytes(6, (err, bytes) => {
         if (err) return callback(err);
         const x = bytes.readUIntBE(0, 6);
-        // If x > (maxVal - (maxVal % range)), we will get "modulo bias"
-        if (x > randLimit) {
-          // Try again
+        if (x >= randLimit) {
+          // Try again.
           return pickAttempt();
         }
         const n = (x % range) + min;
@@ -203,9 +215,113 @@ function handleError(ex, buf) {
   return buf;
 }
 
+// Implements an RFC 4122 version 4 random UUID.
+// To improve performance, random data is generated in batches
+// large enough to cover kBatchSize UUID's at a time. The uuidData
+// and uuid buffers are reused. Each call to randomUUID() consumes
+// 16 bytes from the buffer.
+
+const kHexDigits = [
+  48, 49, 50, 51, 52, 53, 54, 55,
+  56, 57, 97, 98, 99, 100, 101, 102,
+];
+
+const kBatchSize = 128;
+let uuidData;
+let uuidNotBuffered;
+let uuid;
+let uuidBatch = 0;
+
+function getBufferedUUID() {
+  if (uuidData === undefined) {
+    uuidData = secureBuffer(16 * kBatchSize);
+    if (uuidData === undefined)
+      throw new ERR_OPERATION_FAILED('Out of memory');
+  }
+
+  if (uuidBatch === 0) randomFillSync(uuidData);
+  uuidBatch = (uuidBatch + 1) % kBatchSize;
+  return uuidData.slice(uuidBatch * 16, (uuidBatch * 16) + 16);
+}
+
+function randomUUID(options) {
+  if (options !== undefined)
+    validateObject(options, 'options');
+  const {
+    disableEntropyCache = false,
+  } = { ...options };
+
+  validateBoolean(disableEntropyCache, 'options.disableEntropyCache');
+
+  if (uuid === undefined) {
+    uuid = Buffer.alloc(36, '-');
+    uuid[14] = 52; // '4', identifies the UUID version
+  }
+
+  let uuidBuf;
+  if (!disableEntropyCache) {
+    uuidBuf = getBufferedUUID();
+  } else {
+    uuidBuf = uuidNotBuffered;
+    if (uuidBuf === undefined)
+      uuidBuf = uuidNotBuffered = secureBuffer(16);
+    if (uuidBuf === undefined)
+      throw new ERR_OPERATION_FAILED('Out of memory');
+    randomFillSync(uuidBuf);
+  }
+
+  // Variant byte: 10xxxxxx (variant 1)
+  uuidBuf[8] = (uuidBuf[8] & 0x3f) | 0x80;
+
+  // This function is structured the way it is for performance.
+  // The uuid buffer stores the serialization of the random
+  // bytes from uuidData.
+  // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  let n = 0;
+  uuid[0] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[1] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[2] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[3] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[4] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[5] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[6] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[7] = kHexDigits[uuidBuf[n++] & 0xf];
+  // -
+  uuid[9] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[10] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[11] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[12] = kHexDigits[uuidBuf[n++] & 0xf];
+  // -
+  // 4, uuid[14] is set already...
+  uuid[15] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[16] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[17] = kHexDigits[uuidBuf[n++] & 0xf];
+  // -
+  uuid[19] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[20] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[21] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[22] = kHexDigits[uuidBuf[n++] & 0xf];
+  // -
+  uuid[24] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[25] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[26] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[27] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[28] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[29] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[30] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[31] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[32] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[33] = kHexDigits[uuidBuf[n++] & 0xf];
+  uuid[34] = kHexDigits[uuidBuf[n] >> 4];
+  uuid[35] = kHexDigits[uuidBuf[n] & 0xf];
+
+  return uuid.latin1Slice(0, 36);
+}
+
 module.exports = {
   randomBytes,
   randomFill,
   randomFillSync,
-  randomInt
+  randomInt,
+  randomUUID,
 };
diff --git a/lib/internal/crypto/sig.js b/lib/internal/crypto/sig.js
index 415ea8ac85e45d93a6a72831331ead4a662fd616..a7c7b71e35619d9afc700cfc54b438bba6042d03 100644
--- a/lib/internal/crypto/sig.js
+++ b/lib/internal/crypto/sig.js
@@ -9,7 +9,7 @@ const {
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_OPT_VALUE
 } = require('internal/errors').codes;
-const { validateString } = require('internal/validators');
+const { validateEncoding, validateString } = require('internal/validators');
 const {
   Sign: _Sign,
   Verify: _Verify,
@@ -50,8 +50,15 @@ Sign.prototype._write = function _write(chunk, encoding, callback) {
 
 Sign.prototype.update = function update(data, encoding) {
   encoding = encoding || getDefaultEncoding();
-  data = getArrayBufferView(data, 'data', encoding);
-  this[kHandle].update(data);
+
+  if (typeof data === 'string') {
+    validateEncoding(data, encoding);
+  } else if (!isArrayBufferView(data)) {
+    throw new ERR_INVALID_ARG_TYPE(
+      'data', ['string', 'Buffer', 'TypedArray', 'DataView'], data);
+  }
+
+  this[kHandle].update(data, encoding);
   return this;
 };
 
diff --git a/deps/node-inspect/lib/_inspect.js b/lib/internal/debugger/inspect.js
similarity index 35%
rename from deps/node-inspect/lib/_inspect.js
rename to lib/internal/debugger/inspect.js
index aac278db0a891ea68f854afd6ea0794e7de8e518..c8e38512bb82973b61c186e69b617ae035ee17de 100644
--- a/deps/node-inspect/lib/_inspect.js
+++ b/lib/internal/debugger/inspect.js
@@ -1,136 +1,123 @@
-/*
- * Copyright Node.js contributors. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
 'use strict';
+
+const {
+  ArrayPrototypeConcat,
+  ArrayPrototypeForEach,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePop,
+  ArrayPrototypeShift,
+  ArrayPrototypeSlice,
+  FunctionPrototypeBind,
+  Number,
+  Promise,
+  PromisePrototypeCatch,
+  PromisePrototypeThen,
+  PromiseResolve,
+  Proxy,
+  RegExpPrototypeSymbolMatch,
+  RegExpPrototypeSymbolSplit,
+  RegExpPrototypeTest,
+  StringPrototypeEndsWith,
+  StringPrototypeSplit,
+} = primordials;
+
 const { spawn } = require('child_process');
 const { EventEmitter } = require('events');
 const net = require('net');
 const util = require('util');
+const {
+  AbortController,
+} = require('internal/abort_controller');
+
+const pSetTimeout = util.promisify(require('timers').setTimeout);
+async function* pSetInterval(delay) {
+  while (true) {
+    await pSetTimeout(delay);
+    yield;
+  }
+}
 
-const runAsStandalone = typeof __dirname !== 'undefined';
+// TODO(aduh95): remove console calls
+const console = require('internal/console/global');
 
-const [ InspectClient, createRepl ] =
-  runAsStandalone ?
-  // This copy of node-inspect is on-disk, relative paths make sense.
-    [
-      require('./internal/inspect_client'),
-      require('./internal/inspect_repl')
-    ] :
-  // This copy of node-inspect is built into the node executable.
+const { 0: InspectClient, 1: createRepl } =
     [
-      require('node-inspect/lib/internal/inspect_client'),
-      require('node-inspect/lib/internal/inspect_repl')
+      require('internal/debugger/inspect_client'),
+      require('internal/debugger/inspect_repl'),
     ];
 
 const debuglog = util.debuglog('inspect');
 
-class StartupError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'StartupError';
-  }
-}
+const { ERR_DEBUGGER_STARTUP_ERROR } = require('internal/errors').codes;
 
-function portIsFree(host, port, timeout = 9999) {
-  if (port === 0) return Promise.resolve(); // Binding to a random port.
+async function portIsFree(host, port, timeout = 9999) {
+  if (port === 0) return; // Binding to a random port.
 
   const retryDelay = 150;
-  let didTimeOut = false;
+  const ac = new AbortController();
+  const { signal } = ac;
 
-  return new Promise((resolve, reject) => {
-    setTimeout(() => {
-      didTimeOut = true;
-      reject(new StartupError(
-        `Timeout (${timeout}) waiting for ${host}:${port} to be free`));
-    }, timeout);
-
-    function pingPort() {
-      if (didTimeOut) return;
+  pSetTimeout(timeout).then(() => ac.abort());
 
+  const asyncIterator = pSetInterval(retryDelay);
+  while (true) {
+    await asyncIterator.next();
+    if (signal.aborted) {
+      throw new ERR_DEBUGGER_STARTUP_ERROR(
+        `Timeout (${timeout}) waiting for ${host}:${port} to be free`);
+    }
+    const error = await new Promise((resolve) => {
       const socket = net.connect(port, host);
-      let didRetry = false;
-      function retry() {
-        if (!didRetry && !didTimeOut) {
-          didRetry = true;
-          setTimeout(pingPort, retryDelay);
-        }
-      }
-
-      socket.on('error', (error) => {
-        if (error.code === 'ECONNREFUSED') {
-          resolve();
-        } else {
-          retry();
-        }
-      });
-      socket.on('connect', () => {
-        socket.destroy();
-        retry();
-      });
+      socket.on('error', resolve);
+      socket.on('connect', resolve);
+    });
+    if (error?.code === 'ECONNREFUSED') {
+      return;
     }
-    pingPort();
-  });
+  }
 }
 
-function runScript(script, scriptArgs, inspectHost, inspectPort, childPrint) {
-  return portIsFree(inspectHost, inspectPort)
-    .then(() => {
-      return new Promise((resolve) => {
-        const needDebugBrk = process.version.match(/^v(6|7)\./);
-        const args = (needDebugBrk ?
-          ['--inspect', `--debug-brk=${inspectPort}`] :
-          [`--inspect-brk=${inspectPort}`])
-          .concat([script], scriptArgs);
-        const child = spawn(process.execPath, args);
-        child.stdout.setEncoding('utf8');
-        child.stderr.setEncoding('utf8');
-        child.stdout.on('data', childPrint);
-        child.stderr.on('data', childPrint);
-
-        let output = '';
-        function waitForListenHint(text) {
-          output += text;
-          if (/Debugger listening on ws:\/\/\[?(.+?)\]?:(\d+)\//.test(output)) {
-            const host = RegExp.$1;
-            const port = Number.parseInt(RegExp.$2);
-            child.stderr.removeListener('data', waitForListenHint);
-            resolve([child, port, host]);
-          }
-        }
-
-        child.stderr.on('data', waitForListenHint);
-      });
-    });
+const debugRegex = /Debugger listening on ws:\/\/\[?(.+?)\]?:(\d+)\//;
+async function runScript(script, scriptArgs, inspectHost, inspectPort,
+                         childPrint) {
+  await portIsFree(inspectHost, inspectPort);
+  const args = ArrayPrototypeConcat(
+    [`--inspect-brk=${inspectPort}`, script],
+    scriptArgs);
+  const child = spawn(process.execPath, args);
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  child.stdout.on('data', (chunk) => childPrint(chunk, 'stdout'));
+  child.stderr.on('data', (chunk) => childPrint(chunk, 'stderr'));
+
+  let output = '';
+  return new Promise((resolve) => {
+    function waitForListenHint(text) {
+      output += text;
+      const debug = RegExpPrototypeSymbolMatch(debugRegex, output);
+      if (debug) {
+        const host = debug[1];
+        const port = Number(debug[2]);
+        child.stderr.removeListener('data', waitForListenHint);
+        resolve([child, port, host]);
+      }
+    }
+
+    child.stderr.on('data', waitForListenHint);
+  });
 }
 
 function createAgentProxy(domain, client) {
   const agent = new EventEmitter();
-  agent.then = (...args) => {
+  agent.then = (then, _catch) => {
     // TODO: potentially fetch the protocol and pretty-print it here.
     const descriptor = {
       [util.inspect.custom](depth, { stylize }) {
         return stylize(`[Agent ${domain}]`, 'special');
       },
     };
-    return Promise.resolve(descriptor).then(...args);
+    return PromisePrototypeThen(PromiseResolve(descriptor), then, _catch);
   };
 
   return new Proxy(agent, {
@@ -153,25 +140,26 @@ class NodeInspector {
     this.child = null;
 
     if (options.script) {
-      this._runScript = runScript.bind(null,
+      this._runScript = FunctionPrototypeBind(
+        runScript, null,
         options.script,
         options.scriptArgs,
         options.host,
         options.port,
-        this.childPrint.bind(this));
+        FunctionPrototypeBind(this.childPrint, this));
     } else {
       this._runScript =
-          () => Promise.resolve([null, options.port, options.host]);
+          () => PromiseResolve([null, options.port, options.host]);
     }
 
     this.client = new InspectClient();
 
     this.domainNames = ['Debugger', 'HeapProfiler', 'Profiler', 'Runtime'];
-    this.domainNames.forEach((domain) => {
+    ArrayPrototypeForEach(this.domainNames, (domain) => {
       this[domain] = createAgentProxy(domain, this.client);
     });
     this.handleDebugEvent = (fullName, params) => {
-      const [domain, name] = fullName.split('.');
+      const { 0: domain, 1: name } = StringPrototypeSplit(fullName, '.');
       if (domain in this) {
         this[domain].emit(name, params);
       }
@@ -181,19 +169,16 @@ class NodeInspector {
 
     // Handle all possible exits
     process.on('exit', () => this.killChild());
-    process.once('SIGTERM', process.exit.bind(process, 0));
-    process.once('SIGHUP', process.exit.bind(process, 0));
-
-    this.run()
-      .then(() => startRepl())
-      .then((repl) => {
-        this.repl = repl;
-        this.repl.on('exit', () => {
-          process.exit(0);
-        });
-        this.paused = false;
-      })
-      .then(null, (error) => process.nextTick(() => { throw error; }));
+    const exitCodeZero = () => process.exit(0);
+    process.once('SIGTERM', exitCodeZero);
+    process.once('SIGHUP', exitCodeZero);
+
+    PromisePrototypeCatch(PromisePrototypeThen(this.run(), async () => {
+      const repl = await startRepl();
+      this.repl = repl;
+      this.repl.on('exit', exitCodeZero);
+      this.paused = false;
+    }), (error) => process.nextTick(() => { throw error; }));
   }
 
   suspendReplWhile(fn) {
@@ -202,16 +187,16 @@ class NodeInspector {
     }
     this.stdin.pause();
     this.paused = true;
-    return new Promise((resolve) => {
+    return PromisePrototypeCatch(PromisePrototypeThen(new Promise((resolve) => {
       resolve(fn());
-    }).then(() => {
+    }), () => {
       this.paused = false;
       if (this.repl) {
         this.repl.resume();
         this.repl.displayPrompt();
       }
       this.stdin.resume();
-    }).then(null, (error) => process.nextTick(() => { throw error; }));
+    }), (error) => process.nextTick(() => { throw error; }));
   }
 
   killChild() {
@@ -222,37 +207,28 @@ class NodeInspector {
     }
   }
 
-  run() {
+  async run() {
     this.killChild();
 
-    return this._runScript().then(([child, port, host]) => {
-      this.child = child;
-
-      let connectionAttempts = 0;
-      const attemptConnect = () => {
-        ++connectionAttempts;
-        debuglog('connection attempt #%d', connectionAttempts);
-        this.stdout.write('.');
-        return this.client.connect(port, host)
-          .then(() => {
-            debuglog('connection established');
-            this.stdout.write(' ok');
-          }, (error) => {
-            debuglog('connect failed', error);
-            // If it's failed to connect 10 times then print failed message
-            if (connectionAttempts >= 10) {
-              this.stdout.write(' failed to connect, please retry\n');
-              process.exit(1);
-            }
-
-            return new Promise((resolve) => setTimeout(resolve, 500))
-              .then(attemptConnect);
-          });
-      };
-
-      this.print(`connecting to ${host}:${port} ..`, true);
-      return attemptConnect();
-    });
+    const { 0: child, 1: port, 2: host } = await this._runScript();
+    this.child = child;
+
+    this.print(`connecting to ${host}:${port} ..`, false);
+    for (let attempt = 0; attempt < 5; attempt++) {
+      debuglog('connection attempt #%d', attempt);
+      this.stdout.write('.');
+      try {
+        await this.client.connect(port, host);
+        debuglog('connection established');
+        this.stdout.write(' ok\n');
+        return;
+      } catch (error) {
+        debuglog('connect failed', error);
+        await pSetTimeout(1000);
+      }
+    }
+    this.stdout.write(' failed to connect, please retry\n');
+    process.exit(1);
   }
 
   clearLine() {
@@ -264,61 +240,74 @@ class NodeInspector {
     }
   }
 
-  print(text, oneline = false) {
+  print(text, appendNewline = false) {
     this.clearLine();
-    this.stdout.write(oneline ? text : `${text}\n`);
+    this.stdout.write(appendNewline ? `${text}\n` : text);
   }
 
-  childPrint(text) {
-    this.print(
-      text.toString()
-        .split(/\r\n|\r|\n/g)
-        .filter((chunk) => !!chunk)
-        .map((chunk) => `< ${chunk}`)
-        .join('\n')
-    );
-    if (!this.paused) {
-      this.repl.displayPrompt(true);
+  #stdioBuffers = { stdout: '', stderr: '' };
+  childPrint(text, which) {
+    const lines = RegExpPrototypeSymbolSplit(
+      /\r\n|\r|\n/g,
+      this.#stdioBuffers[which] + text);
+
+    this.#stdioBuffers[which] = '';
+
+    if (lines[lines.length - 1] !== '') {
+      this.#stdioBuffers[which] = ArrayPrototypePop(lines);
+    }
+
+    const textToPrint = ArrayPrototypeJoin(
+      ArrayPrototypeMap(lines, (chunk) => `< ${chunk}`),
+      '\n');
+
+    if (lines.length) {
+      this.print(textToPrint, true);
+      if (!this.paused) {
+        this.repl.displayPrompt(true);
+      }
     }
-    if (/Waiting for the debugger to disconnect\.\.\.\n$/.test(text)) {
+
+    if (StringPrototypeEndsWith(
+      textToPrint,
+      'Waiting for the debugger to disconnect...\n'
+    )) {
       this.killChild();
     }
   }
 }
 
-function parseArgv([target, ...args]) {
+function parseArgv(args) {
+  const target = ArrayPrototypeShift(args);
   let host = '127.0.0.1';
   let port = 9229;
   let isRemote = false;
   let script = target;
   let scriptArgs = args;
 
-  const hostMatch = target.match(/^([^:]+):(\d+)$/);
-  const portMatch = target.match(/^--port=(\d+)$/);
+  const hostMatch = RegExpPrototypeSymbolMatch(/^([^:]+):(\d+)$/, target);
+  const portMatch = RegExpPrototypeSymbolMatch(/^--port=(\d+)$/, target);
 
   if (hostMatch) {
     // Connecting to remote debugger
-    // `node-inspect localhost:9229`
     host = hostMatch[1];
-    port = parseInt(hostMatch[2], 10);
+    port = Number(hostMatch[2]);
     isRemote = true;
     script = null;
   } else if (portMatch) {
-    // start debugee on custom port
-    // `node inspect --port=9230 script.js`
-    port = parseInt(portMatch[1], 10);
+    // Start on custom port
+    port = Number(portMatch[1]);
     script = args[0];
-    scriptArgs = args.slice(1);
-  } else if (args.length === 1 && /^\d+$/.test(args[0]) && target === '-p') {
+    scriptArgs = ArrayPrototypeSlice(args, 1);
+  } else if (args.length === 1 && RegExpPrototypeTest(/^\d+$/, args[0]) &&
+             target === '-p') {
     // Start debugger against a given pid
-    const pid = parseInt(args[0], 10);
+    const pid = Number(args[0]);
     try {
       process._debugProcess(pid);
     } catch (e) {
       if (e.code === 'ESRCH') {
-        /* eslint-disable no-console */
         console.error(`Target process: ${pid} doesn't exist.`);
-        /* eslint-enable no-console */
         process.exit(1);
       }
       throw e;
@@ -332,17 +321,15 @@ function parseArgv([target, ...args]) {
   };
 }
 
-function startInspect(argv = process.argv.slice(2),
-  stdin = process.stdin,
-  stdout = process.stdout) {
-  /* eslint-disable no-console */
+function startInspect(argv = ArrayPrototypeSlice(process.argv, 2),
+                      stdin = process.stdin,
+                      stdout = process.stdout) {
   if (argv.length < 1) {
-    const invokedAs = runAsStandalone ?
-      'node-inspect' :
-      `${process.argv0} ${process.argv[1]}`;
+    const invokedAs = `${process.argv0} ${process.argv[1]}`;
 
     console.error(`Usage: ${invokedAs} script.js`);
     console.error(`       ${invokedAs} <host>:<port>`);
+    console.error(`       ${invokedAs} --port=<port>`);
     console.error(`       ${invokedAs} -p <pid>`);
     process.exit(1);
   }
@@ -353,8 +340,8 @@ function startInspect(argv = process.argv.slice(2),
   stdin.resume();
 
   function handleUnexpectedError(e) {
-    if (!(e instanceof StartupError)) {
-      console.error('There was an internal error in node-inspect. ' +
+    if (e.code !== 'ERR_DEBUGGER_STARTUP_ERROR') {
+      console.error('There was an internal error in Node.js. ' +
                     'Please report this bug.');
       console.error(e.message);
       console.error(e.stack);
@@ -366,6 +353,5 @@ function startInspect(argv = process.argv.slice(2),
   }
 
   process.on('uncaughtException', handleUnexpectedError);
-  /* eslint-enable no-console */
 }
 exports.start = startInspect;
diff --git a/deps/node-inspect/lib/internal/inspect_client.js b/lib/internal/debugger/inspect_client.js
similarity index 70%
rename from deps/node-inspect/lib/internal/inspect_client.js
rename to lib/internal/debugger/inspect_client.js
index 9b8529de21aae27addd2f10585c54e5fcb3422a7..fb905e742807d07be49e086c4eff32475b6b1d8e 100644
--- a/deps/node-inspect/lib/internal/inspect_client.js
+++ b/lib/internal/debugger/inspect_client.js
@@ -1,33 +1,23 @@
-/*
- * Copyright Node.js contributors. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
 'use strict';
+
+const {
+  ArrayPrototypePush,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  JSONParse,
+  JSONStringify,
+  ObjectKeys,
+  Promise,
+} = primordials;
+
 const Buffer = require('buffer').Buffer;
 const crypto = require('crypto');
+const { ERR_DEBUGGER_ERROR } = require('internal/errors').codes;
 const { EventEmitter } = require('events');
 const http = require('http');
 const URL = require('url');
-const util = require('util');
 
-const debuglog = util.debuglog('inspect');
+const debuglog = require('internal/util/debuglog').debuglog('inspect');
 
 const kOpCodeText = 0x1;
 const kOpCodeClose = 0x8;
@@ -46,17 +36,30 @@ const kTwoBytePayloadLengthField = 126;
 const kEightBytePayloadLengthField = 127;
 const kMaskingKeyWidthInBytes = 4;
 
-function isEmpty(obj) {
-  return Object.keys(obj).length === 0;
-}
+// This guid is defined in the Websocket Protocol RFC
+// https://tools.ietf.org/html/rfc6455#section-1.3
+const WEBSOCKET_HANDSHAKE_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
 
-function unpackError({ code, message, data }) {
-  const err = new Error(`${message} - ${data}`);
+function unpackError({ code, message }) {
+  const err = new ERR_DEBUGGER_ERROR(`${message}`);
   err.code = code;
-  Error.captureStackTrace(err, unpackError);
+  ErrorCaptureStackTrace(err, unpackError);
   return err;
 }
 
+function validateHandshake(requestKey, responseKey) {
+  const expectedResponseKeyBase = requestKey + WEBSOCKET_HANDSHAKE_GUID;
+  const shasum = crypto.createHash('sha1');
+  shasum.update(expectedResponseKeyBase);
+  const shabuf = shasum.digest();
+
+  if (shabuf.toString('base64') !== responseKey) {
+    throw new ERR_DEBUGGER_ERROR(
+      `WebSocket secret mismatch: ${requestKey} did not match ${responseKey}`
+    );
+  }
+}
+
 function encodeFrameHybi17(payload) {
   var i;
 
@@ -113,14 +116,14 @@ function decodeFrameHybi17(data) {
   const masked = (secondByte & kMaskBit) !== 0;
   const compressed = reserved1;
   if (compressed) {
-    throw new Error('Compressed frames not supported');
+    throw new ERR_DEBUGGER_ERROR('Compressed frames not supported');
   }
   if (!final || reserved2 || reserved3) {
-    throw new Error('Only compression extension is supported');
+    throw new ERR_DEBUGGER_ERROR('Only compression extension is supported');
   }
 
   if (masked) {
-    throw new Error('Masked server frame - not supported');
+    throw new ERR_DEBUGGER_ERROR('Masked server frame - not supported');
   }
 
   let closed = false;
@@ -131,7 +134,7 @@ function decodeFrameHybi17(data) {
     case kOpCodeText:
       break;
     default:
-      throw new Error(`Unsupported op code ${opCode}`);
+      throw new ERR_DEBUGGER_ERROR(`Unsupported op code ${opCode}`);
   }
 
   let payloadLength = secondByte & kPayloadLengthMask;
@@ -166,7 +169,7 @@ function decodeFrameHybi17(data) {
 class Client extends EventEmitter {
   constructor() {
     super();
-    this.handleChunk = this._handleChunk.bind(this);
+    this.handleChunk = FunctionPrototypeBind(this._handleChunk, this);
 
     this._port = undefined;
     this._host = undefined;
@@ -189,17 +192,19 @@ class Client extends EventEmitter {
         this.reset();
         return;
       }
-      if (payloadBuffer === null) break;
+      if (payloadBuffer === null || payloadBuffer.length === 0) break;
 
       const payloadStr = payloadBuffer.toString();
       debuglog('< %s', payloadStr);
       const lastChar = payloadStr[payloadStr.length - 1];
       if (payloadStr[0] !== '{' || lastChar !== '}') {
-        throw new Error(`Payload does not look like JSON: ${payloadStr}`);
+        throw new ERR_DEBUGGER_ERROR(
+          `Payload does not look like JSON: ${payloadStr}`
+        );
       }
       let payload;
       try {
-        payload = JSON.parse(payloadStr);
+        payload = JSONParse(payloadStr);
       } catch (parseError) {
         parseError.string = payloadStr;
         throw parseError;
@@ -216,7 +221,7 @@ class Client extends EventEmitter {
         this.emit('debugEvent', method, params);
         this.emit(method, params);
       } else {
-        throw new Error(`Unsupported response: ${payloadStr}`);
+        throw new ERR_DEBUGGER_ERROR(`Unsupported response: ${payloadStr}`);
       }
     }
   }
@@ -225,6 +230,9 @@ class Client extends EventEmitter {
     if (this._http) {
       this._http.destroy();
     }
+    if (this._socket) {
+      this._socket.destroy();
+    }
     this._http = null;
     this._lastId = 0;
     this._socket = null;
@@ -235,15 +243,15 @@ class Client extends EventEmitter {
   callMethod(method, params) {
     return new Promise((resolve, reject) => {
       if (!this._socket) {
-        reject(new Error('Use `run` to start the app again.'));
+        reject(new ERR_DEBUGGER_ERROR('Use `run` to start the app again.'));
         return;
       }
       const data = { id: ++this._lastId, method, params };
       this._pending[data.id] = (error, result) => {
         if (error) reject(unpackError(error));
-        else resolve(isEmpty(result) ? undefined : result);
+        else resolve(ObjectKeys(result).length ? result : undefined);
       };
-      const json = JSON.stringify(data);
+      const json = JSONStringify(data);
       debuglog('> %s', json);
       this._socket.write(encodeFrameHybi17(Buffer.from(json)));
     });
@@ -263,19 +271,22 @@ class Client extends EventEmitter {
         function parseChunks() {
           const resBody = Buffer.concat(chunks).toString();
           if (httpRes.statusCode !== 200) {
-            reject(new Error(`Unexpected ${httpRes.statusCode}: ${resBody}`));
+            reject(new ERR_DEBUGGER_ERROR(
+              `Unexpected ${httpRes.statusCode}: ${resBody}`
+            ));
             return;
           }
           try {
-            resolve(JSON.parse(resBody));
-          } catch (parseError) {
-            reject(new Error(`Response didn't contain JSON: ${resBody}`));
-            return;
+            resolve(JSONParse(resBody));
+          } catch {
+            reject(new ERR_DEBUGGER_ERROR(
+              `Response didn't contain JSON: ${resBody}`
+            ));
           }
         }
 
         httpRes.on('error', reject);
-        httpRes.on('data', (chunk) => chunks.push(chunk));
+        httpRes.on('data', (chunk) => ArrayPrototypePush(chunks, chunk));
         httpRes.on('end', parseChunks);
       }
 
@@ -284,33 +295,32 @@ class Client extends EventEmitter {
     });
   }
 
-  connect(port, host) {
+  async connect(port, host) {
     this._port = port;
     this._host = host;
-    return this._discoverWebsocketPath()
-      .then((urlPath) => this._connectWebsocket(urlPath));
+    const urlPath = await this._discoverWebsocketPath();
+    return this._connectWebsocket(urlPath);
   }
 
-  _discoverWebsocketPath() {
-    return this._fetchJSON('/json')
-      .then(([{ webSocketDebuggerUrl }]) =>
-        URL.parse(webSocketDebuggerUrl).path);
+  async _discoverWebsocketPath() {
+    const { 0: { webSocketDebuggerUrl } } = await this._fetchJSON('/json');
+    return URL.parse(webSocketDebuggerUrl).path;
   }
 
   _connectWebsocket(urlPath) {
     this.reset();
 
-    const key1 = crypto.randomBytes(16).toString('base64');
-    debuglog('request websocket', key1);
+    const requestKey = crypto.randomBytes(16).toString('base64');
+    debuglog('request WebSocket', requestKey);
 
     const httpReq = this._http = http.request({
       host: this._host,
       port: this._port,
       path: urlPath,
       headers: {
-        Connection: 'Upgrade',
-        Upgrade: 'websocket',
-        'Sec-WebSocket-Key': key1,
+        'Connection': 'Upgrade',
+        'Upgrade': 'websocket',
+        'Sec-WebSocket-Key': requestKey,
         'Sec-WebSocket-Version': '13',
       },
     });
@@ -327,7 +337,7 @@ class Client extends EventEmitter {
     });
 
     const handshakeListener = (res, socket) => {
-      // TODO: we *could* validate res.headers[sec-websocket-accept]
+      validateHandshake(requestKey, res.headers['sec-websocket-accept']);
       debuglog('websocket upgrade');
 
       this._socket = socket;
diff --git a/deps/node-inspect/lib/internal/inspect_repl.js b/lib/internal/debugger/inspect_repl.js
similarity index 57%
rename from deps/node-inspect/lib/internal/inspect_repl.js
rename to lib/internal/debugger/inspect_repl.js
index bfbedf66a71b79f287a543dca271e0db0a68e95c..401887cbda5c746f549cf8ae804d14a0893f3993 100644
--- a/deps/node-inspect/lib/internal/inspect_repl.js
+++ b/lib/internal/debugger/inspect_repl.js
@@ -1,33 +1,63 @@
-/*
- * Copyright Node.js contributors. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
 'use strict';
+
+const {
+  Array,
+  ArrayFrom,
+  ArrayPrototypeFilter,
+  ArrayPrototypeFind,
+  ArrayPrototypeForEach,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSome,
+  ArrayPrototypeSplice,
+  Date,
+  FunctionPrototypeCall,
+  JSONStringify,
+  MathMax,
+  ObjectAssign,
+  ObjectDefineProperty,
+  ObjectKeys,
+  ObjectValues,
+  Promise,
+  PromiseAll,
+  PromisePrototypeCatch,
+  PromisePrototypeThen,
+  PromiseResolve,
+  ReflectGetOwnPropertyDescriptor,
+  ReflectOwnKeys,
+  RegExpPrototypeSymbolMatch,
+  RegExpPrototypeSymbolReplace,
+  SafeArrayIterator,
+  SafeMap,
+  String,
+  StringFromCharCode,
+  StringPrototypeEndsWith,
+  StringPrototypeIncludes,
+  StringPrototypeRepeat,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+  StringPrototypeToUpperCase,
+  StringPrototypeTrim,
+} = primordials;
+
+const { ERR_DEBUGGER_ERROR } = require('internal/errors').codes;
+
+const { validateString } = require('internal/validators');
+
 const FS = require('fs');
 const Path = require('path');
 const Repl = require('repl');
-const util = require('util');
 const vm = require('vm');
-const fileURLToPath = require('url').fileURLToPath;
+const { fileURLToPath } = require('internal/url');
 
-const debuglog = util.debuglog('inspect');
+const { customInspectSymbol } = require('internal/util');
+const { inspect: utilInspect } = require('internal/util/inspect');
+const debuglog = require('internal/util/debuglog').debuglog('inspect');
 
 const SHORTCUTS = {
   cont: 'c',
@@ -40,7 +70,7 @@ const SHORTCUTS = {
   run: 'r',
 };
 
-const HELP = `
+const HELP = StringPrototypeTrim(`
 run, restart, r       Run the application or reconnect
 kill                  Kill a running application or disconnect
 
@@ -77,100 +107,95 @@ profiles[n].save(filepath = 'node.cpuprofile')
 
 takeHeapSnapshot(filepath = 'node.heapsnapshot')
                       Take a heap snapshot and save to disk as JSON.
-`.trim();
+`);
 
 const FUNCTION_NAME_PATTERN = /^(?:function\*? )?([^(\s]+)\(/;
 function extractFunctionName(description) {
-  const fnNameMatch = description.match(FUNCTION_NAME_PATTERN);
+  const fnNameMatch =
+    RegExpPrototypeSymbolMatch(FUNCTION_NAME_PATTERN, description);
   return fnNameMatch ? `: ${fnNameMatch[1]}` : '';
 }
 
-const PUBLIC_BUILTINS = require('module').builtinModules;
-const NATIVES = PUBLIC_BUILTINS ? process.binding('natives') : {};
+const {
+  moduleIds: PUBLIC_BUILTINS,
+} = internalBinding('native_module');
+const NATIVES = internalBinding('natives');
 function isNativeUrl(url) {
-  url = url.replace(/\.js$/, '');
-  if (PUBLIC_BUILTINS) {
-    if (url.startsWith('internal/') || PUBLIC_BUILTINS.includes(url))
-      return true;
-  }
+  url = RegExpPrototypeSymbolReplace(/\.js$/, url, '');
 
-  return url in NATIVES || url === 'bootstrap_node';
+  return StringPrototypeStartsWith(url, 'node:internal/') ||
+         ArrayPrototypeIncludes(PUBLIC_BUILTINS, url) ||
+         url in NATIVES || url === 'bootstrap_node';
 }
 
 function getRelativePath(filenameOrURL) {
-  const dir = Path.join(Path.resolve(), 'x').slice(0, -1);
+  const dir = StringPrototypeSlice(Path.join(Path.resolve(), 'x'), 0, -1);
 
-  const filename = filenameOrURL.startsWith('file://') ?
+  const filename = StringPrototypeStartsWith(filenameOrURL, 'file://') ?
     fileURLToPath(filenameOrURL) : filenameOrURL;
 
   // Change path to relative, if possible
-  if (filename.indexOf(dir) === 0) {
-    return filename.slice(dir.length);
+  if (StringPrototypeStartsWith(filename, dir)) {
+    return StringPrototypeSlice(filename, dir.length);
   }
   return filename;
 }
 
-function toCallback(promise, callback) {
-  function forward(...args) {
-    process.nextTick(() => callback(...args));
-  }
-  promise.then(forward.bind(null, null), forward);
-}
-
 // Adds spaces and prefix to number
 // maxN is a maximum number we should have space for
 function leftPad(n, prefix, maxN) {
   const s = n.toString();
-  const nchars = Math.max(2, String(maxN).length) + 1;
-  const nspaces = nchars - s.length - 1;
+  const nchars = MathMax(2, String(maxN).length);
+  const nspaces = nchars - s.length;
 
-  return prefix + ' '.repeat(nspaces) + s;
+  return prefix + StringPrototypeRepeat(' ', nspaces) + s;
 }
 
 function markSourceColumn(sourceText, position, useColors) {
   if (!sourceText) return '';
 
-  const head = sourceText.slice(0, position);
-  let tail = sourceText.slice(position);
+  const head = StringPrototypeSlice(sourceText, 0, position);
+  let tail = StringPrototypeSlice(sourceText, position);
 
   // Colourize char if stdout supports colours
   if (useColors) {
-    tail = tail.replace(/(.+?)([^\w]|$)/, '\u001b[32m$1\u001b[39m$2');
+    tail = RegExpPrototypeSymbolReplace(/(.+?)([^\w]|$)/, tail,
+                                        '\u001b[32m$1\u001b[39m$2');
   }
 
   // Return source line with coloured char at `position`
-  return [head, tail].join('');
+  return head + tail;
 }
 
 function extractErrorMessage(stack) {
   if (!stack) return '<unknown>';
-  const m = stack.match(/^\w+: ([^\n]+)/);
-  return m ? m[1] : stack;
+  const m = RegExpPrototypeSymbolMatch(/^\w+: ([^\n]+)/, stack);
+  return m?.[1] ?? stack;
 }
 
 function convertResultToError(result) {
   const { className, description } = result;
-  const err = new Error(extractErrorMessage(description));
+  const err = new ERR_DEBUGGER_ERROR(extractErrorMessage(description));
   err.stack = description;
-  Object.defineProperty(err, 'name', { value: className });
+  ObjectDefineProperty(err, 'name', { value: className });
   return err;
 }
 
 class RemoteObject {
   constructor(attributes) {
-    Object.assign(this, attributes);
+    ObjectAssign(this, attributes);
     if (this.type === 'number') {
       this.value =
         this.unserializableValue ? +this.unserializableValue : +this.value;
     }
   }
 
-  [util.inspect.custom](depth, opts) {
+  [customInspectSymbol](depth, opts) {
     function formatProperty(prop) {
       switch (prop.type) {
         case 'string':
         case 'undefined':
-          return util.inspect(prop.value, opts);
+          return utilInspect(prop.value, opts);
 
         case 'number':
         case 'boolean':
@@ -179,7 +204,7 @@ class RemoteObject {
         case 'object':
         case 'symbol':
           if (prop.subtype === 'date') {
-            return util.inspect(new Date(prop.value), opts);
+            return utilInspect(new Date(prop.value), opts);
           }
           if (prop.subtype === 'array') {
             return opts.stylize(prop.value, 'special');
@@ -195,7 +220,7 @@ class RemoteObject {
       case 'number':
       case 'string':
       case 'undefined':
-        return util.inspect(this.value, opts);
+        return utilInspect(this.value, opts);
 
       case 'symbol':
         return opts.stylize(this.description, 'special');
@@ -209,10 +234,10 @@ class RemoteObject {
       case 'object':
         switch (this.subtype) {
           case 'date':
-            return util.inspect(new Date(this.description), opts);
+            return utilInspect(new Date(this.description), opts);
 
           case 'null':
-            return util.inspect(null, opts);
+            return utilInspect(null, opts);
 
           case 'regexp':
             return opts.stylize(this.description, 'regexp');
@@ -221,18 +246,21 @@ class RemoteObject {
             break;
         }
         if (this.preview) {
-          const props = this.preview.properties
-            .map((prop, idx) => {
+          const props = ArrayPrototypeMap(
+            this.preview.properties,
+            (prop, idx) => {
               const value = formatProperty(prop);
               if (prop.name === `${idx}`) return value;
               return `${prop.name}: ${value}`;
             });
           if (this.preview.overflow) {
-            props.push('...');
+            ArrayPrototypePush(props, '...');
           }
-          const singleLine = props.join(', ');
+          const singleLine = ArrayPrototypeJoin(props, ', ');
           const propString =
-            singleLine.length > 60 ? props.join(',\n  ') : singleLine;
+            singleLine.length > 60 ?
+              ArrayPrototypeJoin(props, ',\n  ') :
+              singleLine;
 
           return this.subtype === 'array' ?
             `[ ${propString} ]` : `{ ${propString} }`;
@@ -252,46 +280,52 @@ class RemoteObject {
 
 class ScopeSnapshot {
   constructor(scope, properties) {
-    Object.assign(this, scope);
-    this.properties = new Map(properties.map((prop) => {
+    ObjectAssign(this, scope);
+    this.properties = new SafeMap();
+    this.completionGroup = ArrayPrototypeMap(properties, (prop) => {
       const value = new RemoteObject(prop.value);
-      return [prop.name, value];
-    }));
-    this.completionGroup = properties.map((prop) => prop.name);
+      this.properties.set(prop.name, value);
+      return prop.name;
+    });
   }
 
-  [util.inspect.custom](depth, opts) {
-    const type = `${this.type[0].toUpperCase()}${this.type.slice(1)}`;
+  [customInspectSymbol](depth, opts) {
+    const type = StringPrototypeToUpperCase(this.type[0]) +
+                 StringPrototypeSlice(this.type, 1);
     const name = this.name ? `<${this.name}>` : '';
     const prefix = `${type}${name} `;
-    return util.inspect(this.properties, opts)
-      .replace(/^Map /, prefix);
+    return RegExpPrototypeSymbolReplace(/^Map /,
+                                        utilInspect(this.properties, opts),
+                                        prefix);
   }
 }
 
 function copyOwnProperties(target, source) {
-  Object.getOwnPropertyNames(source).forEach((prop) => {
-    const descriptor = Object.getOwnPropertyDescriptor(source, prop);
-    Object.defineProperty(target, prop, descriptor);
-  });
+  ArrayPrototypeForEach(
+    ReflectOwnKeys(source),
+    (prop) => {
+      const desc = ReflectGetOwnPropertyDescriptor(source, prop);
+      ObjectDefineProperty(target, prop, desc);
+    });
 }
 
 function aliasProperties(target, mapping) {
-  Object.keys(mapping).forEach((key) => {
-    const descriptor = Object.getOwnPropertyDescriptor(target, key);
-    Object.defineProperty(target, mapping[key], descriptor);
+  ArrayPrototypeForEach(ObjectKeys(mapping), (key) => {
+    const desc = ReflectGetOwnPropertyDescriptor(target, key);
+    ObjectDefineProperty(target, mapping[key], desc);
   });
 }
 
 function createRepl(inspector) {
   const { Debugger, HeapProfiler, Profiler, Runtime } = inspector;
 
-  let repl; // eslint-disable-line prefer-const
+  let repl;
 
   // Things we want to keep around
   const history = { control: [], debug: [] };
   const watchedExpressions = [];
   const knownBreakpoints = [];
+  let heapSnapshotPromise = null;
   let pauseOnExceptionState = 'none';
   let lastCommand;
 
@@ -313,17 +347,17 @@ function createRepl(inspector) {
 
   const INSPECT_OPTIONS = { colors: inspector.stdout.isTTY };
   function inspect(value) {
-    return util.inspect(value, INSPECT_OPTIONS);
+    return utilInspect(value, INSPECT_OPTIONS);
   }
 
-  function print(value, oneline = false) {
+  function print(value, addNewline = true) {
     const text = typeof value === 'string' ? value : inspect(value);
-    return inspector.print(text, oneline);
+    return inspector.print(text, addNewline);
   }
 
   function getCurrentLocation() {
     if (!selectedFrame) {
-      throw new Error('Requires execution to be paused');
+      throw new ERR_DEBUGGER_ERROR('Requires execution to be paused');
     }
     return selectedFrame.location;
   }
@@ -338,21 +372,20 @@ function createRepl(inspector) {
       return !script.isNative || isCurrentScript(script);
     }
 
-    return Object.keys(knownScripts)
-      .map((scriptId) => knownScripts[scriptId])
-      .filter(isVisible)
-      .map((script) => {
+    return ArrayPrototypeJoin(ArrayPrototypeMap(
+      ArrayPrototypeFilter(ObjectValues(knownScripts), isVisible),
+      (script) => {
         const isCurrent = isCurrentScript(script);
         const { isNative, url } = script;
         const name = `${getRelativePath(url)}${isNative ? ' <native>' : ''}`;
         return `${isCurrent ? '*' : ' '} ${script.scriptId}: ${name}`;
-      })
-      .join('\n');
+      }), '\n');
   }
+
   function listScripts(displayNatives = false) {
     print(formatScripts(displayNatives));
   }
-  listScripts[util.inspect.custom] = function listWithoutInternal() {
+  listScripts[customInspectSymbol] = function listWithoutInternal() {
     return formatScripts();
   };
 
@@ -364,18 +397,19 @@ function createRepl(inspector) {
 
     static createAndRegister({ profile }) {
       const p = new Profile(profile);
-      profiles.push(p);
+      ArrayPrototypePush(profiles, p);
       return p;
     }
 
-    [util.inspect.custom](depth, { stylize }) {
+    [customInspectSymbol](depth, { stylize }) {
       const { startTime, endTime } = this.data;
-      return stylize(`[Profile ${endTime - startTime}μs]`, 'special');
+      const MU = StringFromCharCode(956);
+      return stylize(`[Profile ${endTime - startTime}${MU}s]`, 'special');
     }
 
     save(filename = 'node.cpuprofile') {
       const absoluteFile = Path.resolve(filename);
-      const json = JSON.stringify(this.data);
+      const json = JSONStringify(this.data);
       FS.writeFileSync(absoluteFile, json);
       print('Saved profile to ' + absoluteFile);
     }
@@ -383,68 +417,75 @@ function createRepl(inspector) {
 
   class SourceSnippet {
     constructor(location, delta, scriptSource) {
-      Object.assign(this, location);
+      ObjectAssign(this, location);
       this.scriptSource = scriptSource;
       this.delta = delta;
     }
 
-    [util.inspect.custom](depth, options) {
+    [customInspectSymbol](depth, options) {
       const { scriptId, lineNumber, columnNumber, delta, scriptSource } = this;
-      const start = Math.max(1, lineNumber - delta + 1);
+      const start = MathMax(1, lineNumber - delta + 1);
       const end = lineNumber + delta + 1;
 
-      const lines = scriptSource.split('\n');
-      return lines.slice(start - 1, end).map((lineText, offset) => {
-        const i = start + offset;
-        const isCurrent = i === (lineNumber + 1);
-
-        const markedLine = isCurrent
-          ? markSourceColumn(lineText, columnNumber, options.colors)
-          : lineText;
-
-        let isBreakpoint = false;
-        knownBreakpoints.forEach(({ location }) => {
-          if (!location) return;
-          if (scriptId === location.scriptId &&
+      const lines = StringPrototypeSplit(scriptSource, '\n');
+      return ArrayPrototypeJoin(
+        ArrayPrototypeMap(
+          ArrayPrototypeSlice(lines, start - 1, end),
+          (lineText, offset) => {
+            const i = start + offset;
+            const isCurrent = i === (lineNumber + 1);
+
+            const markedLine = isCurrent ?
+              markSourceColumn(lineText, columnNumber, options.colors) :
+              lineText;
+
+            let isBreakpoint = false;
+            ArrayPrototypeForEach(knownBreakpoints, ({ location }) => {
+              if (!location) return;
+              if (scriptId === location.scriptId &&
               i === (location.lineNumber + 1)) {
-            isBreakpoint = true;
-          }
-        });
+                isBreakpoint = true;
+              }
+            });
 
-        let prefixChar = ' ';
-        if (isCurrent) {
-          prefixChar = '>';
-        } else if (isBreakpoint) {
-          prefixChar = '*';
-        }
-        return `${leftPad(i, prefixChar, end)} ${markedLine}`;
-      }).join('\n');
+            let prefixChar = ' ';
+            if (isCurrent) {
+              prefixChar = '>';
+            } else if (isBreakpoint) {
+              prefixChar = '*';
+            }
+            return `${leftPad(i, prefixChar, end)} ${markedLine}`;
+          }), '\n');
     }
   }
 
-  function getSourceSnippet(location, delta = 5) {
+  async function getSourceSnippet(location, delta = 5) {
     const { scriptId } = location;
-    return Debugger.getScriptSource({ scriptId })
-      .then(({ scriptSource }) =>
-        new SourceSnippet(location, delta, scriptSource));
+    const { scriptSource } = await Debugger.getScriptSource({ scriptId });
+    return new SourceSnippet(location, delta, scriptSource);
   }
 
   class CallFrame {
     constructor(callFrame) {
-      Object.assign(this, callFrame);
+      ObjectAssign(this, callFrame);
     }
 
     loadScopes() {
-      return Promise.all(
-        this.scopeChain
-          .filter((scope) => scope.type !== 'global')
-          .map((scope) => {
+      return PromiseAll(
+        new SafeArrayIterator(ArrayPrototypeMap(
+          ArrayPrototypeFilter(
+            this.scopeChain,
+            (scope) => scope.type !== 'global'
+          ),
+          async (scope) => {
             const { objectId } = scope.object;
-            return Runtime.getProperties({
+            const { result } = await Runtime.getProperties({
               objectId,
               generatePreview: true,
-            }).then(({ result }) => new ScopeSnapshot(scope, result));
+            });
+            return new ScopeSnapshot(scope, result);
           })
+        )
       );
     }
 
@@ -454,70 +495,73 @@ function createRepl(inspector) {
   }
 
   class Backtrace extends Array {
-    [util.inspect.custom]() {
-      return this.map((callFrame, idx) => {
-        const {
-          location: { scriptId, lineNumber, columnNumber },
-          functionName
-        } = callFrame;
-        const name = functionName || '(anonymous)';
-
-        const script = knownScripts[scriptId];
-        const relativeUrl =
+    [customInspectSymbol]() {
+      return ArrayPrototypeJoin(
+        ArrayPrototypeMap(this, (callFrame, idx) => {
+          const {
+            location: { scriptId, lineNumber, columnNumber },
+            functionName
+          } = callFrame;
+          const name = functionName || '(anonymous)';
+
+          const script = knownScripts[scriptId];
+          const relativeUrl =
           (script && getRelativePath(script.url)) || '<unknown>';
-        const frameLocation =
+          const frameLocation =
           `${relativeUrl}:${lineNumber + 1}:${columnNumber}`;
 
-        return `#${idx} ${name} ${frameLocation}`;
-      }).join('\n');
+          return `#${idx} ${name} ${frameLocation}`;
+        }), '\n');
     }
 
     static from(callFrames) {
-      return super.from(Array.from(callFrames).map((callFrame) => {
-        if (callFrame instanceof CallFrame) {
-          return callFrame;
-        }
-        return new CallFrame(callFrame);
-      }));
+      return FunctionPrototypeCall(
+        ArrayFrom,
+        this,
+        callFrames,
+        (callFrame) =>
+          (callFrame instanceof CallFrame ?
+            callFrame :
+            new CallFrame(callFrame))
+      );
     }
   }
 
   function prepareControlCode(input) {
     if (input === '\n') return lastCommand;
-    // exec process.title => exec("process.title");
-    const match = input.match(/^\s*exec\s+([^\n]*)/);
+    // Add parentheses: exec process.title => exec("process.title");
+    const match = RegExpPrototypeSymbolMatch(/^\s*exec\s+([^\n]*)/, input);
     if (match) {
-      lastCommand = `exec(${JSON.stringify(match[1])})`;
+      lastCommand = `exec(${JSONStringify(match[1])})`;
     } else {
       lastCommand = input;
     }
     return lastCommand;
   }
 
-  function evalInCurrentContext(code) {
+  async function evalInCurrentContext(code) {
     // Repl asked for scope variables
     if (code === '.scope') {
       if (!selectedFrame) {
-        return Promise.reject(new Error('Requires execution to be paused'));
+        throw new ERR_DEBUGGER_ERROR('Requires execution to be paused');
       }
-      return selectedFrame.loadScopes().then((scopes) => {
-        return scopes.map((scope) => scope.completionGroup);
-      });
+      const scopes = await selectedFrame.loadScopes();
+      return ArrayPrototypeMap(scopes, (scope) => scope.completionGroup);
     }
 
     if (selectedFrame) {
-      return Debugger.evaluateOnCallFrame({
+      return PromisePrototypeThen(Debugger.evaluateOnCallFrame({
         callFrameId: selectedFrame.callFrameId,
         expression: code,
         objectGroup: 'node-inspect',
         generatePreview: true,
-      }).then(RemoteObject.fromEvalResult);
+      }), RemoteObject.fromEvalResult);
     }
-    return Runtime.evaluate({
+    return PromisePrototypeThen(Runtime.evaluate({
       expression: code,
       objectGroup: 'node-inspect',
       generatePreview: true,
-    }).then(RemoteObject.fromEvalResult);
+    }), RemoteObject.fromEvalResult);
   }
 
   function controlEval(input, context, filename, callback) {
@@ -531,11 +575,16 @@ function createRepl(inspector) {
       const code = prepareControlCode(input);
       const result = vm.runInContext(code, context, filename);
 
-      if (result && typeof result.then === 'function') {
-        toCallback(result, returnToCallback);
-        return;
+      const then = result?.then;
+      if (typeof then === 'function') {
+        FunctionPrototypeCall(
+          then, result,
+          (result) => returnToCallback(null, result),
+          returnToCallback
+        );
+      } else {
+        returnToCallback(null, result);
       }
-      returnToCallback(null, result);
     } catch (e) {
       returnToCallback(e);
     }
@@ -548,76 +597,63 @@ function createRepl(inspector) {
       callback(error, result);
     }
 
-    try {
-      const result = evalInCurrentContext(input);
-
-      if (result && typeof result.then === 'function') {
-        toCallback(result, returnToCallback);
-        return;
-      }
-      returnToCallback(null, result);
-    } catch (e) {
-      returnToCallback(e);
-    }
+    PromisePrototypeThen(evalInCurrentContext(input),
+                         (result) => returnToCallback(null, result),
+                         returnToCallback
+    );
   }
 
-  function formatWatchers(verbose = false) {
+  async function formatWatchers(verbose = false) {
     if (!watchedExpressions.length) {
-      return Promise.resolve('');
+      return '';
     }
 
     const inspectValue = (expr) =>
-      evalInCurrentContext(expr)
-        // .then(formatValue)
-        .catch((error) => `<${error.message}>`);
+      PromisePrototypeCatch(evalInCurrentContext(expr),
+                            (error) => `<${error.message}>`);
     const lastIndex = watchedExpressions.length - 1;
 
-    return Promise.all(watchedExpressions.map(inspectValue))
-      .then((values) => {
-        const lines = watchedExpressions
-          .map((expr, idx) => {
-            const prefix = `${leftPad(idx, ' ', lastIndex)}: ${expr} =`;
-            const value = inspect(values[idx], { colors: true });
-            if (value.indexOf('\n') === -1) {
-              return `${prefix} ${value}`;
-            }
-            return `${prefix}\n    ${value.split('\n').join('\n    ')}`;
-          });
-        return lines.join('\n');
-      })
-      .then((valueList) => {
-        return verbose ? `Watchers:\n${valueList}\n` : valueList;
-      });
+    const values = await PromiseAll(new SafeArrayIterator(
+      ArrayPrototypeMap(watchedExpressions, inspectValue)));
+    const lines = ArrayPrototypeMap(watchedExpressions, (expr, idx) => {
+      const prefix = `${leftPad(idx, ' ', lastIndex)}: ${expr} =`;
+      const value = inspect(values[idx]);
+      if (!StringPrototypeIncludes(value, '\n')) {
+        return `${prefix} ${value}`;
+      }
+      return `${prefix}\n    ${RegExpPrototypeSymbolReplace(/\n/g, value, '\n    ')}`;
+    });
+    const valueList = ArrayPrototypeJoin(lines, '\n');
+    return verbose ? `Watchers:\n${valueList}\n` : valueList;
   }
 
   function watchers(verbose = false) {
-    return formatWatchers(verbose).then(print);
+    return PromisePrototypeThen(formatWatchers(verbose), print);
   }
 
   // List source code
   function list(delta = 5) {
-    return selectedFrame.list(delta)
-      .then(null, (error) => {
-        print('You can\'t list source code right now');
-        throw error;
-      });
+    return selectedFrame.list(delta).then(null, (error) => {
+      print("You can't list source code right now");
+      throw error;
+    });
   }
 
   function handleBreakpointResolved({ breakpointId, location }) {
     const script = knownScripts[location.scriptId];
     const scriptUrl = script && script.url;
     if (scriptUrl) {
-      Object.assign(location, { scriptUrl });
+      ObjectAssign(location, { scriptUrl });
     }
-    const isExisting = knownBreakpoints.some((bp) => {
+    const isExisting = ArrayPrototypeSome(knownBreakpoints, (bp) => {
       if (bp.breakpointId === breakpointId) {
-        Object.assign(bp, { location });
+        ObjectAssign(bp, { location });
         return true;
       }
       return false;
     });
     if (!isExisting) {
-      knownBreakpoints.push({ breakpointId, location });
+      ArrayPrototypePush(knownBreakpoints, { breakpointId, location });
     }
   }
 
@@ -633,9 +669,11 @@ function createRepl(inspector) {
       const scriptUrl = script ? script.url : location.scriptUrl;
       return `${getRelativePath(scriptUrl)}:${location.lineNumber + 1}`;
     }
-    const breaklist = knownBreakpoints
-      .map((bp, idx) => `#${idx} ${formatLocation(bp.location)}`)
-      .join('\n');
+    const breaklist = ArrayPrototypeJoin(
+      ArrayPrototypeMap(
+        knownBreakpoints,
+        (bp, idx) => `#${idx} ${formatLocation(bp.location)}`),
+      '\n');
     print(breaklist);
   }
 
@@ -652,9 +690,9 @@ function createRepl(inspector) {
 
     // setBreakpoint(): set breakpoint at current location
     if (script === undefined) {
-      return Debugger
-        .setBreakpoint({ location: getCurrentLocation(), condition })
-        .then(registerBreakpoint);
+      return PromisePrototypeThen(
+        Debugger.setBreakpoint({ location: getCurrentLocation(), condition }),
+        registerBreakpoint);
     }
 
     // setBreakpoint(line): set breakpoint in current script at specific line
@@ -663,28 +701,27 @@ function createRepl(inspector) {
         scriptId: getCurrentLocation().scriptId,
         lineNumber: script - 1,
       };
-      return Debugger.setBreakpoint({ location, condition })
-        .then(registerBreakpoint);
+      return PromisePrototypeThen(
+        Debugger.setBreakpoint({ location, condition }),
+        registerBreakpoint);
     }
 
-    if (typeof script !== 'string') {
-      throw new TypeError(`setBreakpoint() expects a string, got ${script}`);
-    }
+    validateString(script, 'script');
 
     // setBreakpoint('fn()'): Break when a function is called
-    if (script.endsWith('()')) {
+    if (StringPrototypeEndsWith(script, '()')) {
       const debugExpr = `debug(${script.slice(0, -2)})`;
-      const debugCall = selectedFrame
-        ? Debugger.evaluateOnCallFrame({
+      const debugCall = selectedFrame ?
+        Debugger.evaluateOnCallFrame({
           callFrameId: selectedFrame.callFrameId,
           expression: debugExpr,
           includeCommandLineAPI: true,
-        })
-        : Runtime.evaluate({
+        }) :
+        Runtime.evaluate({
           expression: debugExpr,
           includeCommandLineAPI: true,
         });
-      return debugCall.then(({ result, wasThrown }) => {
+      return PromisePrototypeThen(debugCall, ({ result, wasThrown }) => {
         if (wasThrown) return convertResultToError(result);
         return undefined; // This breakpoint can't be removed the same way
       });
@@ -696,15 +733,15 @@ function createRepl(inspector) {
     if (knownScripts[script]) {
       scriptId = script;
     } else {
-      for (const id of Object.keys(knownScripts)) {
+      ArrayPrototypeForEach(ObjectKeys(knownScripts), (id) => {
         const scriptUrl = knownScripts[id].url;
-        if (scriptUrl && scriptUrl.indexOf(script) !== -1) {
+        if (scriptUrl && StringPrototypeIncludes(scriptUrl, script)) {
           if (scriptId !== null) {
             ambiguous = true;
           }
           scriptId = id;
         }
-      }
+      });
     }
 
     if (ambiguous) {
@@ -718,19 +755,25 @@ function createRepl(inspector) {
 
     if (scriptId !== null) {
       const location = { scriptId, lineNumber: line - 1 };
-      return Debugger.setBreakpoint({ location, condition })
-        .then(registerBreakpoint);
+      return PromisePrototypeThen(
+        Debugger.setBreakpoint({ location, condition }),
+        registerBreakpoint);
     }
 
-    const escapedPath = script.replace(/([/\\.?*()^${}|[\]])/g, '\\$1');
+    const escapedPath = RegExpPrototypeSymbolReplace(/([/\\.?*()^${}|[\]])/g,
+                                                     script, '\\$1');
     const urlRegex = `^(.*[\\/\\\\])?${escapedPath}$`;
 
-    return Debugger
-      .setBreakpointByUrl({ urlRegex, lineNumber: line - 1, condition })
-      .then((bp) => {
+    return PromisePrototypeThen(
+      Debugger.setBreakpointByUrl({
+        urlRegex,
+        lineNumber: line - 1,
+        condition,
+      }),
+      (bp) => {
         // TODO: handle bp.locations in case the regex matches existing files
         if (!bp.location) { // Fake it for now.
-          Object.assign(bp, {
+          ObjectAssign(bp, {
             actualLocation: {
               scriptUrl: `.*/${script}$`,
               lineNumber: line - 1,
@@ -742,41 +785,46 @@ function createRepl(inspector) {
   }
 
   function clearBreakpoint(url, line) {
-    const breakpoint = knownBreakpoints.find(({ location }) => {
+    const breakpoint = ArrayPrototypeFind(knownBreakpoints, ({ location }) => {
       if (!location) return false;
       const script = knownScripts[location.scriptId];
       if (!script) return false;
       return (
-        script.url.indexOf(url) !== -1 && (location.lineNumber + 1) === line
+        StringPrototypeIncludes(script.url, url) &&
+        (location.lineNumber + 1) === line
       );
     });
     if (!breakpoint) {
       print(`Could not find breakpoint at ${url}:${line}`);
-      return Promise.resolve();
+      return PromiseResolve();
     }
-    return Debugger.removeBreakpoint({ breakpointId: breakpoint.breakpointId })
-      .then(() => {
-        const idx = knownBreakpoints.indexOf(breakpoint);
-        knownBreakpoints.splice(idx, 1);
+    return PromisePrototypeThen(
+      Debugger.removeBreakpoint({ breakpointId: breakpoint.breakpointId }),
+      () => {
+        const idx = ArrayPrototypeIndexOf(knownBreakpoints, breakpoint);
+        ArrayPrototypeSplice(knownBreakpoints, idx, 1);
       });
   }
 
   function restoreBreakpoints() {
-    const lastBreakpoints = knownBreakpoints.slice();
-    knownBreakpoints.length = 0;
-    const newBreakpoints = lastBreakpoints
-      .filter(({ location }) => !!location.scriptUrl)
-      .map(({ location }) =>
-        setBreakpoint(location.scriptUrl, location.lineNumber + 1));
-    if (!newBreakpoints.length) return Promise.resolve();
-    return Promise.all(newBreakpoints).then((results) => {
-      print(`${results.length} breakpoints restored.`);
-    });
+    const lastBreakpoints = ArrayPrototypeSplice(knownBreakpoints, 0);
+    const newBreakpoints = ArrayPrototypeMap(
+      ArrayPrototypeFilter(lastBreakpoints,
+                           ({ location }) => !!location.scriptUrl),
+      ({ location }) => setBreakpoint(location.scriptUrl,
+                                      location.lineNumber + 1));
+    if (!newBreakpoints.length) return PromiseResolve();
+    return PromisePrototypeThen(
+      PromiseAll(new SafeArrayIterator(newBreakpoints)),
+      (results) => {
+        print(`${results.length} breakpoints restored.`);
+      });
   }
 
   function setPauseOnExceptions(state) {
-    return Debugger.setPauseOnExceptions({ state })
-      .then(() => {
+    return PromisePrototypeThen(
+      Debugger.setPauseOnExceptions({ state }),
+      () => {
         pauseOnExceptionState = state;
       });
   }
@@ -802,13 +850,13 @@ function createRepl(inspector) {
     const header = `${breakType} in ${scriptUrl}:${lineNumber + 1}`;
 
     inspector.suspendReplWhile(() =>
-      Promise.all([formatWatchers(true), selectedFrame.list(2)])
-        .then(([watcherList, context]) => {
-          if (watcherList) {
-            return `${watcherList}\n${inspect(context)}`;
-          }
-          return inspect(context);
-        }).then((breakContext) => {
+      PromisePrototypeThen(
+        PromiseAll(new SafeArrayIterator(
+          [formatWatchers(true), selectedFrame.list(2)])),
+        ({ 0: watcherList, 1: context }) => {
+          const breakContext = watcherList ?
+            `${watcherList}\n${inspect(context)}` :
+            inspect(context);
           print(`${header}\n${breakContext}`);
         }));
   });
@@ -825,23 +873,21 @@ function createRepl(inspector) {
   Debugger.on('scriptParsed', (script) => {
     const { scriptId, url } = script;
     if (url) {
-      knownScripts[scriptId] = Object.assign({
-        isNative: isNativeUrl(url),
-      }, script);
+      knownScripts[scriptId] = { isNative: isNativeUrl(url), ...script };
     }
   });
 
   Profiler.on('consoleProfileFinished', ({ profile }) => {
     Profile.createAndRegister({ profile });
-    print([
-      'Captured new CPU profile.',
+    print(
+      'Captured new CPU profile.\n' +
       `Access it with profiles[${profiles.length - 1}]`
-    ].join('\n'));
+    );
   });
 
   function initializeContext(context) {
-    inspector.domainNames.forEach((domain) => {
-      Object.defineProperty(context, domain, {
+    ArrayPrototypeForEach(inspector.domainNames, (domain) => {
+      ObjectDefineProperty(context, domain, {
         value: inspector[domain],
         enumerable: true,
         configurable: true,
@@ -851,7 +897,7 @@ function createRepl(inspector) {
 
     copyOwnProperties(context, {
       get help() {
-        print(HELP);
+        return print(HELP);
       },
 
       get run() {
@@ -907,8 +953,8 @@ function createRepl(inspector) {
       },
 
       get profileEnd() {
-        return Profiler.stop()
-          .then(Profile.createAndRegister);
+        return PromisePrototypeThen(Profiler.stop(),
+                                    Profile.createAndRegister);
       },
 
       get profiles() {
@@ -916,7 +962,13 @@ function createRepl(inspector) {
       },
 
       takeHeapSnapshot(filename = 'node.heapsnapshot') {
-        return new Promise((resolve, reject) => {
+        if (heapSnapshotPromise) {
+          print(
+            'Cannot take heap snapshot because another snapshot is in progress.'
+          );
+          return heapSnapshotPromise;
+        }
+        heapSnapshotPromise = new Promise((resolve, reject) => {
           const absoluteFile = Path.resolve(filename);
           const writer = FS.createWriteStream(absoluteFile);
           let sizeWritten = 0;
@@ -924,25 +976,30 @@ function createRepl(inspector) {
             if (finished) {
               print('Heap snaphost prepared.');
             } else {
-              print(`Heap snapshot: ${done}/${total}`, true);
+              print(`Heap snapshot: ${done}/${total}`, false);
             }
           }
+
           function onChunk({ chunk }) {
             sizeWritten += chunk.length;
             writer.write(chunk);
-            print(`Writing snapshot: ${sizeWritten}`, true);
+            print(`Writing snapshot: ${sizeWritten}`, false);
           }
+
           function onResolve() {
             writer.end(() => {
               teardown();
               print(`Wrote snapshot: ${absoluteFile}`);
+              heapSnapshotPromise = null;
               resolve();
             });
           }
+
           function onReject(error) {
             teardown();
             reject(error);
           }
+
           function teardown() {
             HeapProfiler.removeListener(
               'reportHeapSnapshotProgress', onProgress);
@@ -952,10 +1009,12 @@ function createRepl(inspector) {
           HeapProfiler.on('reportHeapSnapshotProgress', onProgress);
           HeapProfiler.on('addHeapSnapshotChunk', onChunk);
 
-          print('Heap snapshot: 0/0', true);
-          HeapProfiler.takeHeapSnapshot({ reportProgress: true })
-            .then(onResolve, onReject);
+          print('Heap snapshot: 0/0', false);
+          PromisePrototypeThen(
+            HeapProfiler.takeHeapSnapshot({ reportProgress: true }),
+            onResolve, onReject);
         });
+        return heapSnapshotPromise;
       },
 
       get watchers() {
@@ -963,21 +1022,22 @@ function createRepl(inspector) {
       },
 
       watch(expr) {
-        watchedExpressions.push(expr);
+        ArrayPrototypePush(watchedExpressions, expr);
       },
 
       unwatch(expr) {
-        const index = watchedExpressions.indexOf(expr);
+        const index = ArrayPrototypeIndexOf(watchedExpressions, expr);
 
         // Unwatch by expression
         // or
         // Unwatch by watcher number
-        watchedExpressions.splice(index !== -1 ? index : +expr, 1);
+        ArrayPrototypeSplice(watchedExpressions,
+                             index !== -1 ? index : +expr, 1);
       },
 
       get repl() {
         // Don't display any default messages
-        const listeners = repl.listeners('SIGINT').slice(0);
+        const listeners = ArrayPrototypeSlice(repl.listeners('SIGINT'));
         repl.removeAllListeners('SIGINT');
 
         const oldContext = repl.context;
@@ -985,7 +1045,7 @@ function createRepl(inspector) {
         exitDebugRepl = () => {
           // Restore all listeners
           process.nextTick(() => {
-            listeners.forEach((listener) => {
+            ArrayPrototypeForEach(listeners, (listener) => {
               repl.on('SIGINT', listener);
             });
           });
@@ -1023,16 +1083,16 @@ function createRepl(inspector) {
 
         repl.setPrompt('> ');
 
-        print('Press Ctrl + C to leave debug repl');
-        repl.displayPrompt();
+        print('Press Ctrl+C to leave debug repl');
+        return repl.displayPrompt();
       },
 
       get version() {
-        return Runtime.evaluate({
+        return PromisePrototypeThen(Runtime.evaluate({
           expression: 'process.versions.v8',
           contextId: 1,
           returnByValue: true,
-        }).then(({ result }) => {
+        }), ({ result }) => {
           print(result.value);
         });
       },
@@ -1057,23 +1117,20 @@ function createRepl(inspector) {
     aliasProperties(context, SHORTCUTS);
   }
 
-  function initAfterStart() {
-    const setupTasks = [
-      Runtime.enable(),
-      Profiler.enable(),
-      Profiler.setSamplingInterval({ interval: 100 }),
-      Debugger.enable(),
-      Debugger.setPauseOnExceptions({ state: 'none' }),
-      Debugger.setAsyncCallStackDepth({ maxDepth: 0 }),
-      Debugger.setBlackboxPatterns({ patterns: [] }),
-      Debugger.setPauseOnExceptions({ state: pauseOnExceptionState }),
-      restoreBreakpoints(),
-      Runtime.runIfWaitingForDebugger(),
-    ];
-    return Promise.all(setupTasks);
+  async function initAfterStart() {
+    await Runtime.enable();
+    await Profiler.enable();
+    await Profiler.setSamplingInterval({ interval: 100 });
+    await Debugger.enable();
+    await Debugger.setPauseOnExceptions({ state: 'none' });
+    await Debugger.setAsyncCallStackDepth({ maxDepth: 0 });
+    await Debugger.setBlackboxPatterns({ patterns: [] });
+    await Debugger.setPauseOnExceptions({ state: pauseOnExceptionState });
+    await restoreBreakpoints();
+    return Runtime.runIfWaitingForDebugger();
   }
 
-  return function startRepl() {
+  return async function startRepl() {
     inspector.client.on('close', () => {
       resetOnStart();
     });
@@ -1081,6 +1138,9 @@ function createRepl(inspector) {
       initAfterStart();
     });
 
+    // Init once for the initial connection
+    await initAfterStart();
+
     const replOptions = {
       prompt: 'debug> ',
       input: inspector.stdin,
@@ -1090,18 +1150,15 @@ function createRepl(inspector) {
       ignoreUndefined: true,
     };
 
-    repl = Repl.start(replOptions); // eslint-disable-line prefer-const
+    repl = Repl.start(replOptions);
     initializeContext(repl.context);
     repl.on('reset', initializeContext);
 
     repl.defineCommand('interrupt', () => {
-      // We want this for testing purposes where sending CTRL-C can be tricky.
+      // We want this for testing purposes where sending Ctrl+C can be tricky.
       repl.emit('SIGINT');
     });
 
-    // Init once for the initial connection
-    initAfterStart();
-
     return repl;
   };
 }
diff --git a/lib/internal/dgram.js b/lib/internal/dgram.js
index 8a8d9ba8c0ddd4ed575899276fcf1174ccdf3f0c..950a82392c8e63b43eeec6e2f8635f745c229ab9 100644
--- a/lib/internal/dgram.js
+++ b/lib/internal/dgram.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  FunctionPrototypeBind,
   Symbol,
 } = primordials;
 
@@ -37,14 +38,14 @@ function newHandle(type, lookup) {
   if (type === 'udp4') {
     const handle = new UDP();
 
-    handle.lookup = lookup4.bind(handle, lookup);
+    handle.lookup = FunctionPrototypeBind(lookup4, handle, lookup);
     return handle;
   }
 
   if (type === 'udp6') {
     const handle = new UDP();
 
-    handle.lookup = lookup6.bind(handle, lookup);
+    handle.lookup = FunctionPrototypeBind(lookup6, handle, lookup);
     handle.bind = handle.bind6;
     handle.connect = handle.connect6;
     handle.send = handle.send6;
diff --git a/lib/internal/dns/promises.js b/lib/internal/dns/promises.js
index 16cd97e06ac5caea04da7e8494449bd64ca09a87..551828827176ff910f8ce02650adc5d705a6bb3f 100644
--- a/lib/internal/dns/promises.js
+++ b/lib/internal/dns/promises.js
@@ -1,9 +1,10 @@
 'use strict';
-
 const {
+  ArrayPrototypeMap,
   ObjectCreate,
   ObjectDefineProperty,
   Promise,
+  ReflectApply,
 } = primordials;
 
 const {
@@ -11,7 +12,9 @@ const {
   Resolver: CallbackResolver,
   validateHints,
   validateTimeout,
+  validateTries,
   emitInvalidHostnameWarning,
+  getDefaultVerbatim,
 } = require('internal/dns/utils');
 const { codes, dnsException } = require('internal/errors');
 const { toASCII } = require('internal/idna');
@@ -31,7 +34,8 @@ const {
 } = codes;
 const {
   validatePort,
-  validateString
+  validateString,
+  validateOneOf,
 } = require('internal/validators');
 
 function onlookup(err, addresses) {
@@ -100,7 +104,7 @@ function lookup(hostname, options) {
   var hints = 0;
   var family = -1;
   var all = false;
-  var verbatim = false;
+  var verbatim = getDefaultVerbatim();
 
   // Parse arguments
   if (hostname && typeof hostname !== 'string') {
@@ -109,15 +113,16 @@ function lookup(hostname, options) {
     hints = options.hints >>> 0;
     family = options.family >>> 0;
     all = options.all === true;
-    verbatim = options.verbatim === true;
+    if (typeof options.verbatim === 'boolean') {
+      verbatim = options.verbatim === true;
+    }
 
     validateHints(hints);
   } else {
     family = options >>> 0;
   }
 
-  if (family !== 0 && family !== 4 && family !== 6)
-    throw new ERR_INVALID_OPT_VALUE('family', family);
+  validateOneOf(family, 'family', [0, 4, 6], true);
 
   return createLookupPromise(family, hostname, all, hints, verbatim);
 }
@@ -169,7 +174,8 @@ function onresolve(err, result, ttls) {
   }
 
   if (ttls && this.ttl)
-    result = result.map((address, index) => ({ address, ttl: ttls[index] }));
+    result = ArrayPrototypeMap(
+      result, (address, index) => ({ address, ttl: ttls[index] }));
 
   this.resolve(result);
 }
@@ -211,15 +217,19 @@ const resolveMap = ObjectCreate(null);
 class Resolver {
   constructor(options = undefined) {
     const timeout = validateTimeout(options);
-    this._handle = new ChannelWrap(timeout);
+    const tries = validateTries(options);
+    this._handle = new ChannelWrap(timeout, tries);
   }
 }
 
 Resolver.prototype.getServers = CallbackResolver.prototype.getServers;
 Resolver.prototype.setServers = CallbackResolver.prototype.setServers;
+Resolver.prototype.cancel = CallbackResolver.prototype.cancel;
+Resolver.prototype.setLocalAddress = CallbackResolver.prototype.setLocalAddress;
 Resolver.prototype.resolveAny = resolveMap.ANY = resolver('queryAny');
 Resolver.prototype.resolve4 = resolveMap.A = resolver('queryA');
 Resolver.prototype.resolve6 = resolveMap.AAAA = resolver('queryAaaa');
+Resolver.prototype.resolveCaa = resolveMap.CAA = resolver('queryCaa');
 Resolver.prototype.resolveCname = resolveMap.CNAME = resolver('queryCname');
 Resolver.prototype.resolveMx = resolveMap.MX = resolver('queryMx');
 Resolver.prototype.resolveNs = resolveMap.NS = resolver('queryNs');
@@ -243,7 +253,7 @@ Resolver.prototype.resolve = function resolve(hostname, rrtype) {
     throw new ERR_INVALID_ARG_TYPE('rrtype', 'string', rrtype);
   }
 
-  return resolver.call(this, hostname);
+  return ReflectApply(resolver, this, [hostname]);
 };
 
 
diff --git a/lib/internal/dns/utils.js b/lib/internal/dns/utils.js
index 6642a4f090bf67c1041b92296c11595e028f3f88..0adc28a45ce3abbc347aadf4e8bea14c0b2df39b 100644
--- a/lib/internal/dns/utils.js
+++ b/lib/internal/dns/utils.js
@@ -2,11 +2,24 @@
 
 const {
   ArrayIsArray,
+  ArrayPrototypeForEach,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  FunctionPrototypeBind,
+  NumberParseInt,
+  StringPrototypeMatch,
+  StringPrototypeReplace,
 } = primordials;
 
 const errors = require('internal/errors');
 const { isIP } = require('internal/net');
-const { validateInt32 } = require('internal/validators');
+const { getOptionValue } = require('internal/options');
+const {
+  validateInt32,
+  validateOneOf,
+  validateString,
+} = require('internal/validators');
 const {
   ChannelWrap,
   strerror,
@@ -30,11 +43,18 @@ function validateTimeout(options) {
   return timeout;
 }
 
+function validateTries(options) {
+  const { tries = 4 } = { ...options };
+  validateInt32(tries, 'options.tries', 1, 2 ** 31 - 1);
+  return tries;
+}
+
 // Resolver instances correspond 1:1 to c-ares channels.
 class Resolver {
   constructor(options = undefined) {
     const timeout = validateTimeout(options);
-    this._handle = new ChannelWrap(timeout);
+    const tries = validateTries(options);
+    this._handle = new ChannelWrap(timeout, tries);
   }
 
   cancel() {
@@ -42,7 +62,7 @@ class Resolver {
   }
 
   getServers() {
-    return this._handle.getServers().map((val) => {
+    return ArrayPrototypeMap(this._handle.getServers(), (val) => {
       if (!val[1] || val[1] === IANA_DNS_PORT)
         return val[0];
 
@@ -62,30 +82,28 @@ class Resolver {
     const orig = this._handle.getServers();
     const newSet = [];
 
-    servers.forEach((serv, index) => {
-      if (typeof serv !== 'string') {
-        throw new ERR_INVALID_ARG_TYPE(`servers[${index}]`, 'string', serv);
-      }
+    ArrayPrototypeForEach(servers, (serv, index) => {
+      validateString(serv, `servers[${index}]`);
       let ipVersion = isIP(serv);
 
       if (ipVersion !== 0)
-        return newSet.push([ipVersion, serv, IANA_DNS_PORT]);
+        return ArrayPrototypePush(newSet, [ipVersion, serv, IANA_DNS_PORT]);
 
-      const match = serv.match(IPv6RE);
+      const match = StringPrototypeMatch(serv, IPv6RE);
 
       // Check for an IPv6 in brackets.
       if (match) {
         ipVersion = isIP(match[1]);
 
         if (ipVersion !== 0) {
-          const port =
-            parseInt(serv.replace(addrSplitRE, '$2')) || IANA_DNS_PORT;
-          return newSet.push([ipVersion, match[1], port]);
+          const port = NumberParseInt(
+            StringPrototypeReplace(serv, addrSplitRE, '$2')) || IANA_DNS_PORT;
+          return ArrayPrototypePush(newSet, [ipVersion, match[1], port]);
         }
       }
 
       // addr::port
-      const addrSplitMatch = serv.match(addrSplitRE);
+      const addrSplitMatch = StringPrototypeMatch(serv, addrSplitRE);
 
       if (addrSplitMatch) {
         const hostIP = addrSplitMatch[1];
@@ -94,7 +112,8 @@ class Resolver {
         ipVersion = isIP(hostIP);
 
         if (ipVersion !== 0) {
-          return newSet.push([ipVersion, hostIP, parseInt(port)]);
+          return ArrayPrototypePush(
+            newSet, [ipVersion, hostIP, NumberParseInt(port)]);
         }
       }
 
@@ -105,11 +124,21 @@ class Resolver {
 
     if (errorNumber !== 0) {
       // Reset the servers to the old servers, because ares probably unset them.
-      this._handle.setServers(orig.join(','));
+      this._handle.setServers(ArrayPrototypeJoin(orig, ','));
       const err = strerror(errorNumber);
       throw new ERR_DNS_SET_SERVERS_FAILED(err, servers);
     }
   }
+
+  setLocalAddress(ipv4, ipv6) {
+    validateString(ipv4, 'ipv4');
+
+    if (typeof ipv6 !== 'string' && ipv6 !== undefined) {
+      throw new ERR_INVALID_ARG_TYPE('ipv6', ['String', 'undefined'], ipv6);
+    }
+
+    this._handle.setLocalAddress(ipv4, ipv6);
+  }
 }
 
 let defaultResolver = new Resolver();
@@ -119,6 +148,7 @@ const resolverKeys = [
   'resolve4',
   'resolve6',
   'resolveAny',
+  'resolveCaa',
   'resolveCname',
   'resolveMx',
   'resolveNaptr',
@@ -139,8 +169,8 @@ function setDefaultResolver(resolver) {
 }
 
 function bindDefaultResolver(target, source) {
-  resolverKeys.forEach((key) => {
-    target[key] = source[key].bind(defaultResolver);
+  ArrayPrototypeForEach(resolverKeys, (key) => {
+    target[key] = FunctionPrototypeBind(source[key], defaultResolver);
   });
 }
 
@@ -165,12 +195,32 @@ function emitInvalidHostnameWarning(hostname) {
   );
 }
 
+let dnsOrder = getOptionValue('--dns-result-order') || 'ipv4first';
+
+function getDefaultVerbatim() {
+  switch (dnsOrder) {
+    case 'verbatim':
+      return true;
+    case 'ipv4first':
+    default:
+      return false;
+  }
+}
+
+function setDefaultResultOrder(value) {
+  validateOneOf(value, 'dnsOrder', ['verbatim', 'ipv4first']);
+  dnsOrder = value;
+}
+
 module.exports = {
   bindDefaultResolver,
   getDefaultResolver,
   setDefaultResolver,
   validateHints,
   validateTimeout,
+  validateTries,
   Resolver,
   emitInvalidHostnameWarning,
+  getDefaultVerbatim,
+  setDefaultResultOrder,
 };
diff --git a/lib/internal/encoding.js b/lib/internal/encoding.js
index 8562fb32ff515ddb4ea06b668ad921ddaf5376cb..2cdd453b15ba91443cc3cca19c3ee16436e65c33 100644
--- a/lib/internal/encoding.js
+++ b/lib/internal/encoding.js
@@ -4,10 +4,11 @@
 // https://encoding.spec.whatwg.org
 
 const {
-  Map,
   ObjectCreate,
   ObjectDefineProperties,
   ObjectGetOwnPropertyDescriptors,
+  SafeMap,
+  StringPrototypeSlice,
   Symbol,
   SymbolToStringTag,
   Uint32Array,
@@ -38,7 +39,10 @@ const {
   isUint8Array
 } = require('internal/util/types');
 
-const { validateString } = require('internal/validators');
+const {
+  validateString,
+  validateObject,
+} = require('internal/validators');
 
 const {
   encodeInto,
@@ -62,18 +66,13 @@ function validateDecoder(obj) {
     throw new ERR_INVALID_THIS('TextDecoder');
 }
 
-function validateArgument(prop, expected, propName, expectedName) {
-  if (typeof prop !== expected)
-    throw new ERR_INVALID_ARG_TYPE(propName, expectedName, prop);
-}
-
 const CONVERTER_FLAGS_FLUSH = 0x1;
 const CONVERTER_FLAGS_FATAL = 0x2;
 const CONVERTER_FLAGS_IGNORE_BOM = 0x4;
 
 const empty = new Uint8Array(0);
 
-const encodings = new Map([
+const encodings = new SafeMap([
   ['unicode-1-1-utf-8', 'utf-8'],
   ['utf8', 'utf-8'],
   ['utf-8', 'utf-8'],
@@ -284,7 +283,7 @@ const encodings = new Map([
   ['windows-949', 'euc-kr'],
   ['utf-16be', 'utf-16be'],
   ['utf-16le', 'utf-16le'],
-  ['utf-16', 'utf-16le']
+  ['utf-16', 'utf-16le'],
 ]);
 
 // Unfortunately, String.prototype.trim also removes non-ascii whitespace,
@@ -308,7 +307,7 @@ function trimAsciiWhitespace(label) {
     label[e - 1] === '\u0020')) {
     e--;
   }
-  return label.slice(s, e);
+  return StringPrototypeSlice(label, s, e);
 }
 
 function getEncodingFromLabel(label) {
@@ -362,10 +361,8 @@ ObjectDefineProperties(
     'encode': { enumerable: true },
     'encodeInto': { enumerable: true },
     'encoding': { enumerable: true },
-    [SymbolToStringTag]: {
-      configurable: true,
-      value: 'TextEncoder'
-    } });
+    [SymbolToStringTag]: { configurable: true, value: 'TextEncoder' },
+  });
 
 const TextDecoder =
   internalBinding('config').hasIntl ?
@@ -381,7 +378,11 @@ function makeTextDecoderICU() {
   class TextDecoder {
     constructor(encoding = 'utf-8', options = {}) {
       encoding = `${encoding}`;
-      validateArgument(options, 'object', 'options', 'Object');
+      validateObject(options, 'options', {
+        nullable: true,
+        allowArray: true,
+        allowFunction: true,
+      });
 
       const enc = getEncodingFromLabel(encoding);
       if (enc === undefined)
@@ -413,7 +414,11 @@ function makeTextDecoderICU() {
                                        ['ArrayBuffer', 'ArrayBufferView'],
                                        input);
       }
-      validateArgument(options, 'object', 'options', 'Object');
+      validateObject(options, 'options', {
+        nullable: true,
+        allowArray: true,
+        allowFunction: true,
+      });
 
       let flags = 0;
       if (options !== null)
@@ -447,7 +452,11 @@ function makeTextDecoderJS() {
   class TextDecoder {
     constructor(encoding = 'utf-8', options = {}) {
       encoding = `${encoding}`;
-      validateArgument(options, 'object', 'options', 'Object');
+      validateObject(options, 'options', {
+        nullable: true,
+        allowArray: true,
+        allowFunction: true,
+      });
 
       const enc = getEncodingFromLabel(encoding);
       if (enc === undefined || !hasConverter(enc))
@@ -481,7 +490,11 @@ function makeTextDecoderJS() {
                                        ['ArrayBuffer', 'ArrayBufferView'],
                                        input);
       }
-      validateArgument(options, 'object', 'options', 'Object');
+      validateObject(options, 'options', {
+        nullable: true,
+        allowArray: true,
+        allowFunction: true,
+      });
 
       if (this[kFlags] & CONVERTER_FLAGS_FLUSH) {
         this[kBOMSeen] = false;
@@ -503,7 +516,7 @@ function makeTextDecoderJS() {
         // If the very first result in the stream is a BOM, and we are not
         // explicitly told to ignore it, then we discard it.
         if (result[0] === '\ufeff') {
-          result = result.slice(1);
+          result = StringPrototypeSlice(result, 1);
         }
         this[kBOMSeen] = true;
       }
@@ -516,54 +529,53 @@ function makeTextDecoderJS() {
 }
 
 // Mix in some shared properties.
-{
-  ObjectDefineProperties(
-    TextDecoder.prototype,
-    ObjectGetOwnPropertyDescriptors({
-      get encoding() {
-        validateDecoder(this);
-        return this[kEncoding];
-      },
-
-      get fatal() {
-        validateDecoder(this);
-        return (this[kFlags] & CONVERTER_FLAGS_FATAL) === CONVERTER_FLAGS_FATAL;
-      },
-
-      get ignoreBOM() {
-        validateDecoder(this);
-        return (this[kFlags] & CONVERTER_FLAGS_IGNORE_BOM) ===
-               CONVERTER_FLAGS_IGNORE_BOM;
-      },
-
-      [inspect](depth, opts) {
-        validateDecoder(this);
-        if (typeof depth === 'number' && depth < 0)
-          return this;
-        const ctor = getConstructorOf(this);
-        const obj = ObjectCreate({
-          constructor: ctor === null ? TextDecoder : ctor
-        });
-        obj.encoding = this.encoding;
-        obj.fatal = this.fatal;
-        obj.ignoreBOM = this.ignoreBOM;
-        if (opts.showHidden) {
-          obj[kFlags] = this[kFlags];
-          obj[kHandle] = this[kHandle];
-        }
-        // Lazy to avoid circular dependency
-        return require('internal/util/inspect').inspect(obj, opts);
+ObjectDefineProperties(
+  TextDecoder.prototype,
+  ObjectGetOwnPropertyDescriptors({
+    get encoding() {
+      validateDecoder(this);
+      return this[kEncoding];
+    },
+
+    get fatal() {
+      validateDecoder(this);
+      return (this[kFlags] & CONVERTER_FLAGS_FATAL) === CONVERTER_FLAGS_FATAL;
+    },
+
+    get ignoreBOM() {
+      validateDecoder(this);
+      return (this[kFlags] & CONVERTER_FLAGS_IGNORE_BOM) ===
+              CONVERTER_FLAGS_IGNORE_BOM;
+    },
+
+    [inspect](depth, opts) {
+      validateDecoder(this);
+      if (typeof depth === 'number' && depth < 0)
+        return this;
+      const constructor = getConstructorOf(this) || TextDecoder;
+      const obj = ObjectCreate({ constructor });
+      obj.encoding = this.encoding;
+      obj.fatal = this.fatal;
+      obj.ignoreBOM = this.ignoreBOM;
+      if (opts.showHidden) {
+        obj[kFlags] = this[kFlags];
+        obj[kHandle] = this[kHandle];
       }
-    }));
-  ObjectDefineProperties(TextDecoder.prototype, {
-    decode: { enumerable: true },
-    [inspect]: { enumerable: false },
-    [SymbolToStringTag]: {
-      configurable: true,
-      value: 'TextDecoder'
+      // Lazy to avoid circular dependency
+      const { inspect } = require('internal/util/inspect');
+      return `${constructor.name} ${inspect(obj)}`;
     }
-  });
-}
+  })
+);
+
+ObjectDefineProperties(TextDecoder.prototype, {
+  decode: { enumerable: true },
+  [inspect]: { enumerable: false },
+  [SymbolToStringTag]: {
+    configurable: true,
+    value: 'TextDecoder'
+  }
+});
 
 module.exports = {
   getEncodingFromLabel,
diff --git a/lib/internal/error_serdes.js b/lib/internal/error_serdes.js
index 5e18448da7046c1e92a606a0f75467a521a5a7c7..47392752df631878da51874ff43ed41de83b71a8 100644
--- a/lib/internal/error_serdes.js
+++ b/lib/internal/error_serdes.js
@@ -4,6 +4,7 @@ const Buffer = require('buffer').Buffer;
 const {
   ArrayPrototypeForEach,
   Error,
+  EvalError,
   FunctionPrototypeCall,
   ObjectAssign,
   ObjectCreate,
@@ -13,8 +14,13 @@ const {
   ObjectGetPrototypeOf,
   ObjectKeys,
   ObjectPrototypeToString,
+  RangeError,
+  ReferenceError,
   SafeSet,
   SymbolToStringTag,
+  SyntaxError,
+  TypeError,
+  URIError,
 } = primordials;
 
 const kSerializedError = 0;
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 2cf7df436b5e9fee333a438aa62ffd091fe93fff..bb5902fd41a3e565c72fe3ebcc4ef791f868700e 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -11,25 +11,51 @@
 // message may change, the code should not.
 
 const {
+  ArrayFrom,
   ArrayIsArray,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
   Error,
+  ErrorCaptureStackTrace,
   ErrorPrototypeToString,
   JSONStringify,
-  Map,
+  MapPrototypeGet,
   MathAbs,
   MathMax,
+  Number,
   NumberIsInteger,
   ObjectDefineProperty,
   ObjectKeys,
+  RangeError,
+  ReflectApply,
+  RegExpPrototypeTest,
+  SafeMap,
+  SafeWeakMap,
+  String,
+  StringPrototypeEndsWith,
+  StringPrototypeIncludes,
+  StringPrototypeMatch,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
   StringPrototypeStartsWith,
+  StringPrototypeToLowerCase,
   Symbol,
   SymbolFor,
-  WeakMap,
+  SyntaxError,
+  TypeError,
+  URIError,
 } = primordials;
 
 const isWindows = process.platform === 'win32';
 
-const messages = new Map();
+const messages = new SafeMap();
 const codes = {};
 
 const classRegExp = /^([A-Z][a-z0-9]*)+$/;
@@ -44,14 +70,14 @@ const kTypes = [
   'Object',
   'boolean',
   'bigint',
-  'symbol'
+  'symbol',
 ];
 
-const { kMaxLength } = internalBinding('buffer');
-
 const MainContextError = Error;
-const overrideStackTrace = new WeakMap();
+const overrideStackTrace = new SafeWeakMap();
 const kNoOverride = Symbol('kNoOverride');
+let userStackTraceLimit;
+const nodeInternalPrefix = '__node_internal_';
 const prepareStackTrace = (globalThis, error, trace) => {
   // API for node internals to override error stack formatting
   // without interfering with userland code.
@@ -61,6 +87,21 @@ const prepareStackTrace = (globalThis, error, trace) => {
     return f(error, trace);
   }
 
+  const firstFrame = trace[0]?.getFunctionName();
+  if (firstFrame && StringPrototypeStartsWith(firstFrame, nodeInternalPrefix)) {
+    for (let l = trace.length - 1; l >= 0; l--) {
+      const fn = trace[l]?.getFunctionName();
+      if (fn && StringPrototypeStartsWith(fn, nodeInternalPrefix)) {
+        ArrayPrototypeSplice(trace, 0, l + 1);
+        break;
+      }
+    }
+    // `userStackTraceLimit` is the user value for `Error.stackTraceLimit`,
+    // it is updated at every new exception in `captureLargerStackTrace`.
+    if (trace.length > userStackTraceLimit)
+      ArrayPrototypeSplice(trace, userStackTraceLimit);
+  }
+
   const globalOverride =
     maybeOverridePrepareStackTrace(globalThis, error, trace);
   if (globalOverride !== kNoOverride) return globalOverride;
@@ -74,7 +115,7 @@ const prepareStackTrace = (globalThis, error, trace) => {
   if (trace.length === 0) {
     return errorString;
   }
-  return `${errorString}\n    at ${trace.join('\n    at ')}`;
+  return `${errorString}\n    at ${ArrayPrototypeJoin(trace, '\n    at ')}`;
 };
 
 const maybeOverridePrepareStackTrace = (globalThis, error, trace) => {
@@ -82,7 +123,7 @@ const maybeOverridePrepareStackTrace = (globalThis, error, trace) => {
   // https://crbug.com/v8/7848
   // `globalThis` is the global that contains the constructor which
   // created `error`.
-  if (typeof globalThis.Error.prepareStackTrace === 'function') {
+  if (typeof globalThis.Error?.prepareStackTrace === 'function') {
     return globalThis.Error.prepareStackTrace(error, trace);
   }
   // We still have legacy usage that depends on the main context's `Error`
@@ -95,8 +136,6 @@ const maybeOverridePrepareStackTrace = (globalThis, error, trace) => {
   return kNoOverride;
 };
 
-let excludedStackFn;
-
 // Lazily loaded
 let util;
 let assert;
@@ -124,6 +163,27 @@ function lazyBuffer() {
   return buffer;
 }
 
+const addCodeToName = hideStackFrames(function addCodeToName(err, name, code) {
+  // Set the stack
+  err = captureLargerStackTrace(err);
+  // Add the error code to the name to include it in the stack trace.
+  err.name = `${name} [${code}]`;
+  // Access the stack to generate the error message including the error code
+  // from the name.
+  err.stack; // eslint-disable-line no-unused-expressions
+  // Reset the name to the actual name.
+  if (name === 'SystemError') {
+    ObjectDefineProperty(err, 'name', {
+      value: name,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  } else {
+    delete err.name;
+  }
+});
+
 // A specialized Error that includes an additional info property with
 // additional information about the error condition.
 // It has the properties present in a UVException but with a custom error
@@ -134,15 +194,11 @@ function lazyBuffer() {
 // and may have .path and .dest.
 class SystemError extends Error {
   constructor(key, context) {
-    if (excludedStackFn === undefined) {
-      super();
-    } else {
-      const limit = Error.stackTraceLimit;
-      Error.stackTraceLimit = 0;
-      super();
-      // Reset the limit and setting the name property.
-      Error.stackTraceLimit = limit;
-    }
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    super();
+    // Reset the limit and setting the name property.
+    Error.stackTraceLimit = limit;
     const prefix = getMessage(key, [], this);
     let message = `${prefix}: ${context.syscall} returned ` +
                   `${context.code} (${context.message})`;
@@ -251,15 +307,11 @@ function makeSystemErrorWithCode(key) {
 function makeNodeErrorWithCode(Base, key) {
   return class NodeError extends Base {
     constructor(...args) {
-      if (excludedStackFn === undefined) {
-        super();
-      } else {
-        const limit = Error.stackTraceLimit;
-        Error.stackTraceLimit = 0;
-        super();
-        // Reset the limit and setting the name property.
-        Error.stackTraceLimit = limit;
-      }
+      const limit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      super();
+      // Reset the limit and setting the name property.
+      Error.stackTraceLimit = limit;
       const message = getMessage(key, args, this);
       ObjectDefineProperty(this, 'message', {
         value: message,
@@ -279,45 +331,11 @@ function makeNodeErrorWithCode(Base, key) {
 
 // This function removes unnecessary frames from Node.js core errors.
 function hideStackFrames(fn) {
-  return function hidden(...args) {
-    // Make sure the most outer `hideStackFrames()` function is used.
-    let setStackFn = false;
-    if (excludedStackFn === undefined) {
-      excludedStackFn = hidden;
-      setStackFn = true;
-    }
-    try {
-      return fn(...args);
-    } finally {
-      if (setStackFn === true) {
-        excludedStackFn = undefined;
-      }
-    }
-  };
-}
-
-function addCodeToName(err, name, code) {
-  // Set the stack
-  if (excludedStackFn !== undefined) {
-    // eslint-disable-next-line no-restricted-syntax
-    Error.captureStackTrace(err, excludedStackFn);
-  }
-  // Add the error code to the name to include it in the stack trace.
-  err.name = `${name} [${code}]`;
-  // Access the stack to generate the error message including the error code
-  // from the name.
-  err.stack;
-  // Reset the name to the actual name.
-  if (name === 'SystemError') {
-    ObjectDefineProperty(err, 'name', {
-      value: name,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    });
-  } else {
-    delete err.name;
-  }
+  // We rename the functions that will be hidden to cut off the stacktrace
+  // at the outermost one
+  const hidden = nodeInternalPrefix + fn.name;
+  ObjectDefineProperty(fn, 'name', { value: hidden });
+  return fn;
 }
 
 // Utility function for registering the error codes. Only used here. Exported
@@ -351,10 +369,11 @@ function getMessage(key, args, self) {
       `Code: ${key}; The provided arguments length (${args.length}) does not ` +
         `match the required ones (${msg.length}).`
     );
-    return msg.apply(self, args);
+    return ReflectApply(msg, self, args);
   }
 
-  const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length;
+  const expectedLength =
+    (StringPrototypeMatch(msg, /%[dfijoOs]/g) || []).length;
   assert(
     expectedLength === args.length,
     `Code: ${key}; The provided arguments length (${args.length}) does not ` +
@@ -363,8 +382,8 @@ function getMessage(key, args, self) {
   if (args.length === 0)
     return msg;
 
-  args.unshift(msg);
-  return lazyInternalUtilInspect().format.apply(null, args);
+  ArrayPrototypeUnshift(args, msg);
+  return ReflectApply(lazyInternalUtilInspect().format, null, args);
 }
 
 let uvBinding;
@@ -383,9 +402,19 @@ function uvErrmapGet(name) {
   if (!uvBinding.errmap) {
     uvBinding.errmap = uvBinding.getErrorMap();
   }
-  return uvBinding.errmap.get(name);
+  return MapPrototypeGet(uvBinding.errmap, name);
 }
 
+const captureLargerStackTrace = hideStackFrames(
+  function captureLargerStackTrace(err) {
+    userStackTraceLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = Infinity;
+    ErrorCaptureStackTrace(err);
+    // Reset the limit
+    Error.stackTraceLimit = userStackTraceLimit;
+
+    return err;
+  });
 
 /**
  * This creates an error compatible with errors produced in the C++
@@ -396,8 +425,8 @@ function uvErrmapGet(name) {
  * @param {Object} ctx
  * @returns {Error}
  */
-function uvException(ctx) {
-  const [ code, uvmsg ] = uvErrmapGet(ctx.errno) || uvUnmappedError;
+const uvException = hideStackFrames(function uvException(ctx) {
+  const { 0: code, 1: uvmsg } = uvErrmapGet(ctx.errno) || uvUnmappedError;
   let message = `${code}: ${ctx.message || uvmsg}, ${ctx.syscall}`;
 
   let path;
@@ -411,7 +440,7 @@ function uvException(ctx) {
     message += ` -> '${dest}'`;
   }
 
-  // Reducing the limit improves the performance significantly. We do not loose
+  // Reducing the limit improves the performance significantly. We do not lose
   // the stack frames due to the `captureStackTrace()` function that is called
   // later.
   const tmpLimit = Error.stackTraceLimit;
@@ -437,10 +466,8 @@ function uvException(ctx) {
     err.dest = dest;
   }
 
-  // eslint-disable-next-line no-restricted-syntax
-  Error.captureStackTrace(err, excludedStackFn || uvException);
-  return err;
-}
+  return captureLargerStackTrace(err);
+});
 
 /**
  * This creates an error compatible with errors produced in the C++
@@ -453,37 +480,36 @@ function uvException(ctx) {
  * @param {number} [port]
  * @returns {Error}
  */
-function uvExceptionWithHostPort(err, syscall, address, port) {
-  const [ code, uvmsg ] = uvErrmapGet(err) || uvUnmappedError;
-  const message = `${syscall} ${code}: ${uvmsg}`;
-  let details = '';
-
-  if (port && port > 0) {
-    details = ` ${address}:${port}`;
-  } else if (address) {
-    details = ` ${address}`;
-  }
+const uvExceptionWithHostPort = hideStackFrames(
+  function uvExceptionWithHostPort(err, syscall, address, port) {
+    const { 0: code, 1: uvmsg } = uvErrmapGet(err) || uvUnmappedError;
+    const message = `${syscall} ${code}: ${uvmsg}`;
+    let details = '';
+
+    if (port && port > 0) {
+      details = ` ${address}:${port}`;
+    } else if (address) {
+      details = ` ${address}`;
+    }
 
-  // Reducing the limit improves the performance significantly. We do not loose
-  // the stack frames due to the `captureStackTrace()` function that is called
-  // later.
-  const tmpLimit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 0;
-  // eslint-disable-next-line no-restricted-syntax
-  const ex = new Error(`${message}${details}`);
-  Error.stackTraceLimit = tmpLimit;
-  ex.code = code;
-  ex.errno = code;
-  ex.syscall = syscall;
-  ex.address = address;
-  if (port) {
-    ex.port = port;
-  }
+    // Reducing the limit improves the performance significantly. We do not
+    // lose the stack frames due to the `captureStackTrace()` function that
+    // is called later.
+    const tmpLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    // eslint-disable-next-line no-restricted-syntax
+    const ex = new Error(`${message}${details}`);
+    Error.stackTraceLimit = tmpLimit;
+    ex.code = code;
+    ex.errno = err;
+    ex.syscall = syscall;
+    ex.address = address;
+    if (port) {
+      ex.port = port;
+    }
 
-  // eslint-disable-next-line no-restricted-syntax
-  Error.captureStackTrace(ex, excludedStackFn || uvExceptionWithHostPort);
-  return ex;
-}
+    return captureLargerStackTrace(ex);
+  });
 
 /**
  * This used to be util._errnoException().
@@ -493,26 +519,28 @@ function uvExceptionWithHostPort(err, syscall, address, port) {
  * @param {string} [original]
  * @returns {Error}
  */
-function errnoException(err, syscall, original) {
-  // TODO(joyeecheung): We have to use the type-checked
-  // getSystemErrorName(err) to guard against invalid arguments from users.
-  // This can be replaced with [ code ] = errmap.get(err) when this method
-  // is no longer exposed to user land.
-  if (util === undefined) util = require('util');
-  const code = util.getSystemErrorName(err);
-  const message = original ?
-    `${syscall} ${code} ${original}` : `${syscall} ${code}`;
-
-  // eslint-disable-next-line no-restricted-syntax
-  const ex = new Error(message);
-  // TODO(joyeecheung): errno is supposed to err, like in uvException
-  ex.code = ex.errno = code;
-  ex.syscall = syscall;
+const errnoException = hideStackFrames(
+  function errnoException(err, syscall, original) {
+    // TODO(joyeecheung): We have to use the type-checked
+    // getSystemErrorName(err) to guard against invalid arguments from users.
+    // This can be replaced with [ code ] = errmap.get(err) when this method
+    // is no longer exposed to user land.
+    if (util === undefined) util = require('util');
+    const code = util.getSystemErrorName(err);
+    const message = original ?
+      `${syscall} ${code} ${original}` : `${syscall} ${code}`;
+
+    const tmpLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    // eslint-disable-next-line no-restricted-syntax
+    const ex = new Error(message);
+    Error.stackTraceLimit = tmpLimit;
+    ex.errno = err;
+    ex.code = code;
+    ex.syscall = syscall;
 
-  // eslint-disable-next-line no-restricted-syntax
-  Error.captureStackTrace(ex, excludedStackFn || errnoException);
-  return ex;
-}
+    return captureLargerStackTrace(ex);
+  });
 
 /**
  * Deprecated, new function is `uvExceptionWithHostPort()`
@@ -525,43 +553,42 @@ function errnoException(err, syscall, original) {
  * @param {string} [additional]
  * @returns {Error}
  */
-function exceptionWithHostPort(err, syscall, address, port, additional) {
-  // TODO(joyeecheung): We have to use the type-checked
-  // getSystemErrorName(err) to guard against invalid arguments from users.
-  // This can be replaced with [ code ] = errmap.get(err) when this method
-  // is no longer exposed to user land.
-  if (util === undefined) util = require('util');
-  const code = util.getSystemErrorName(err);
-  let details = '';
-  if (port && port > 0) {
-    details = ` ${address}:${port}`;
-  } else if (address) {
-    details = ` ${address}`;
-  }
-  if (additional) {
-    details += ` - Local (${additional})`;
-  }
+const exceptionWithHostPort = hideStackFrames(
+  function exceptionWithHostPort(err, syscall, address, port, additional) {
+    // TODO(joyeecheung): We have to use the type-checked
+    // getSystemErrorName(err) to guard against invalid arguments from users.
+    // This can be replaced with [ code ] = errmap.get(err) when this method
+    // is no longer exposed to user land.
+    if (util === undefined) util = require('util');
+    const code = util.getSystemErrorName(err);
+    let details = '';
+    if (port && port > 0) {
+      details = ` ${address}:${port}`;
+    } else if (address) {
+      details = ` ${address}`;
+    }
+    if (additional) {
+      details += ` - Local (${additional})`;
+    }
 
-  // Reducing the limit improves the performance significantly. We do not loose
-  // the stack frames due to the `captureStackTrace()` function that is called
-  // later.
-  const tmpLimit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 0;
-  // eslint-disable-next-line no-restricted-syntax
-  const ex = new Error(`${syscall} ${code}${details}`);
-  // TODO(joyeecheung): errno is supposed to err, like in uvException
-  Error.stackTraceLimit = tmpLimit;
-  ex.code = ex.errno = code;
-  ex.syscall = syscall;
-  ex.address = address;
-  if (port) {
-    ex.port = port;
-  }
+    // Reducing the limit improves the performance significantly. We do not
+    // lose the stack frames due to the `captureStackTrace()` function that
+    // is called later.
+    const tmpLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    // eslint-disable-next-line no-restricted-syntax
+    const ex = new Error(`${syscall} ${code}${details}`);
+    Error.stackTraceLimit = tmpLimit;
+    ex.errno = err;
+    ex.code = code;
+    ex.syscall = syscall;
+    ex.address = address;
+    if (port) {
+      ex.port = port;
+    }
 
-  // eslint-disable-next-line no-restricted-syntax
-  Error.captureStackTrace(ex, excludedStackFn || exceptionWithHostPort);
-  return ex;
-}
+    return captureLargerStackTrace(ex);
+  });
 
 /**
  * @param {number|string} code - A libuv error number or a c-ares error code
@@ -569,10 +596,17 @@ function exceptionWithHostPort(err, syscall, address, port, additional) {
  * @param {string} [hostname]
  * @returns {Error}
  */
-function dnsException(code, syscall, hostname) {
+const dnsException = hideStackFrames(function(code, syscall, hostname) {
+  let errno;
   // If `code` is of type number, it is a libuv error number, else it is a
   // c-ares error code.
+  // TODO(joyeecheung): translate c-ares error codes into numeric ones and
+  // make them available in a property that's not error.errno (since they
+  // can be in conflict with libuv error codes). Also make sure
+  // util.getSystemErrorName() can understand them when an being informed that
+  // the number is a c-ares error code.
   if (typeof code === 'number') {
+    errno = code;
     // ENOTFOUND is not a proper POSIX error, but this error has been in place
     // long enough that it's not practical to remove it.
     if (code === lazyUv().UV_EAI_NODATA || code === lazyUv().UV_EAI_NONAME) {
@@ -582,27 +616,23 @@ function dnsException(code, syscall, hostname) {
     }
   }
   const message = `${syscall} ${code}${hostname ? ` ${hostname}` : ''}`;
-  // Reducing the limit improves the performance significantly. We do not loose
+  // Reducing the limit improves the performance significantly. We do not lose
   // the stack frames due to the `captureStackTrace()` function that is called
   // later.
   const tmpLimit = Error.stackTraceLimit;
   Error.stackTraceLimit = 0;
   // eslint-disable-next-line no-restricted-syntax
   const ex = new Error(message);
-  // TODO(joyeecheung): errno is supposed to be a number / err, like in
   Error.stackTraceLimit = tmpLimit;
-  // uvException.
-  ex.errno = code;
+  ex.errno = errno;
   ex.code = code;
   ex.syscall = syscall;
   if (hostname) {
     ex.hostname = hostname;
   }
 
-  // eslint-disable-next-line no-restricted-syntax
-  Error.captureStackTrace(ex, excludedStackFn || dnsException);
-  return ex;
-}
+  return captureLargerStackTrace(ex);
+});
 
 function connResetException(msg) {
   // eslint-disable-next-line no-restricted-syntax
@@ -642,9 +672,9 @@ function addNumericalSeparator(val) {
   let i = val.length;
   const start = val[0] === '-' ? 1 : 0;
   for (; i >= start + 4; i -= 3) {
-    res = `_${val.slice(i - 3, i)}${res}`;
+    res = `_${StringPrototypeSlice(val, i - 3, i)}${res}`;
   }
-  return `${val.slice(0, i)}${res}`;
+  return `${StringPrototypeSlice(val, 0, i)}${res}`;
 }
 
 // Used to enhance the stack that will be picked up by the inspector
@@ -679,7 +709,8 @@ const fatalExceptionStackEnhancers = {
     // ANSI escape sequences is not reliable.
     if (process.platform === 'win32') {
       const info = internalBinding('os').getOSInformation();
-      const ver = info[2].split('.').map((a) => +a);
+      const ver = ArrayPrototypeMap(StringPrototypeSplit(info[2], '.'),
+                                    Number);
       if (ver[0] !== 10 || ver[2] < 14393) {
         useColors = false;
       }
@@ -706,6 +737,16 @@ const fatalExceptionStackEnhancers = {
   }
 };
 
+// Node uses an AbortError that isn't exactly the same as the DOMException
+// to make usage of the error in userland and readable-stream easier.
+// It is a regular error with `.code` and `.name`.
+class AbortError extends Error {
+  constructor() {
+    super('The operation was aborted');
+    this.code = 'ABORT_ERR';
+    this.name = 'AbortError';
+  }
+}
 module.exports = {
   addCodeToName, // Exported for NghttpError
   codes,
@@ -720,6 +761,7 @@ module.exports = {
   uvException,
   uvExceptionWithHostPort,
   SystemError,
+  AbortError,
   // This is exported only to facilitate testing.
   E,
   kNoOverride,
@@ -774,6 +816,7 @@ E('ERR_CHILD_PROCESS_STDIO_MAXBUFFER', '%s maxBuffer length exceeded',
   RangeError);
 E('ERR_CONSOLE_WRITABLE_STREAM',
   'Console expects a writable stream instance for %s', TypeError);
+E('ERR_CONTEXT_NOT_INITIALIZED', 'context used is not initialized', Error);
 E('ERR_CPU_USAGE', 'Unable to obtain cpu usage %s', Error);
 E('ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED',
   'Custom engines not supported by this OpenSSL', Error);
@@ -799,6 +842,8 @@ E('ERR_CRYPTO_SCRYPT_INVALID_PARAMETER', 'Invalid scrypt parameter', Error);
 E('ERR_CRYPTO_SCRYPT_NOT_SUPPORTED', 'Scrypt algorithm not supported', Error);
 // Switch to TypeError. The current implementation does not seem right.
 E('ERR_CRYPTO_SIGN_KEY_REQUIRED', 'No key provided to sign', Error);
+E('ERR_DEBUGGER_ERROR', '%s', Error);
+E('ERR_DEBUGGER_STARTUP_ERROR', '%s', Error);
 E('ERR_DIR_CLOSED', 'Directory handle was closed', Error);
 E('ERR_DIR_CONCURRENT_OPERATION',
   'Cannot do synchronous work on directory handle with concurrent ' +
@@ -820,13 +865,18 @@ E('ERR_ENCODING_INVALID_ENCODED_DATA', function(encoding, ret) {
 }, TypeError);
 E('ERR_ENCODING_NOT_SUPPORTED', 'The "%s" encoding is not supported',
   RangeError);
+E('ERR_EVAL_ESM_CANNOT_PRINT', '--print cannot be used with ESM input', Error);
+E('ERR_EVENT_RECURSION', 'The event "%s" is already being dispatched', Error);
 E('ERR_FALSY_VALUE_REJECTION', function(reason) {
   this.reason = reason;
   return 'Promise was rejected with falsy value';
 }, Error);
-E('ERR_FS_FILE_TOO_LARGE', 'File size (%s) is greater than possible Buffer: ' +
-    `${kMaxLength} bytes`,
-  RangeError);
+E('ERR_FEATURE_UNAVAILABLE_ON_PLATFORM',
+  'The feature %s is unavailable on the current platform' +
+  ', which is being used to run Node.js',
+  TypeError);
+E('ERR_FS_EISDIR', 'Path is a directory', SystemError);
+E('ERR_FS_FILE_TOO_LARGE', 'File size (%s) is greater than 2 GB', RangeError);
 E('ERR_FS_INVALID_SYMLINK_TYPE',
   'Symlink type must be one of "dir", "file", or "junction". Received "%s"',
   Error); // Switch to TypeError. The current implementation does not seem right
@@ -878,6 +928,7 @@ E('ERR_HTTP2_MAX_PENDING_SETTINGS_ACK',
   'Maximum number of pending settings acknowledgements', Error);
 E('ERR_HTTP2_NESTED_PUSH',
   'A push stream cannot initiate another push stream.', Error);
+E('ERR_HTTP2_NO_MEM', 'Out of memory', Error);
 E('ERR_HTTP2_NO_SOCKET_MANIPULATION',
   'HTTP/2 sockets should not be directly manipulated (e.g. read and written)',
   Error);
@@ -928,6 +979,7 @@ E('ERR_HTTP_HEADERS_SENT',
 E('ERR_HTTP_INVALID_HEADER_VALUE',
   'Invalid value "%s" for header "%s"', TypeError);
 E('ERR_HTTP_INVALID_STATUS_CODE', 'Invalid status code: %s', RangeError);
+E('ERR_HTTP_REQUEST_TIMEOUT', 'Request timeout', Error);
 E('ERR_HTTP_TRAILER_INVALID',
   'Trailers are invalid with this transfer encoding', Error);
 E('ERR_INCOMPATIBLE_OPTION_PAIR',
@@ -965,11 +1017,11 @@ E('ERR_INVALID_ARG_TYPE',
     }
 
     let msg = 'The ';
-    if (name.endsWith(' argument')) {
+    if (StringPrototypeEndsWith(name, ' argument')) {
       // For cases like 'first argument'
       msg += `${name} `;
     } else {
-      const type = name.includes('.') ? 'property' : 'argument';
+      const type = StringPrototypeIncludes(name, '.') ? 'property' : 'argument';
       msg += `"${name}" ${type} `;
     }
     msg += 'must be ';
@@ -981,31 +1033,31 @@ E('ERR_INVALID_ARG_TYPE',
     for (const value of expected) {
       assert(typeof value === 'string',
              'All expected entries have to be of type string');
-      if (kTypes.includes(value)) {
-        types.push(value.toLowerCase());
-      } else if (classRegExp.test(value)) {
-        instances.push(value);
+      if (ArrayPrototypeIncludes(kTypes, value)) {
+        ArrayPrototypePush(types, StringPrototypeToLowerCase(value));
+      } else if (RegExpPrototypeTest(classRegExp, value)) {
+        ArrayPrototypePush(instances, value);
       } else {
         assert(value !== 'object',
                'The value "object" should be written as "Object"');
-        other.push(value);
+        ArrayPrototypePush(other, value);
       }
     }
 
     // Special handle `object` in case other instances are allowed to outline
     // the differences between each other.
     if (instances.length > 0) {
-      const pos = types.indexOf('object');
+      const pos = ArrayPrototypeIndexOf(types, 'object');
       if (pos !== -1) {
-        types.splice(pos, 1);
-        instances.push('Object');
+        ArrayPrototypeSplice(types, pos, 1);
+        ArrayPrototypePush(instances, 'Object');
       }
     }
 
     if (types.length > 0) {
       if (types.length > 2) {
-        const last = types.pop();
-        msg += `one of type ${types.join(', ')}, or ${last}`;
+        const last = ArrayPrototypePop(types);
+        msg += `one of type ${ArrayPrototypeJoin(types, ', ')}, or ${last}`;
       } else if (types.length === 2) {
         msg += `one of type ${types[0]} or ${types[1]}`;
       } else {
@@ -1017,8 +1069,9 @@ E('ERR_INVALID_ARG_TYPE',
 
     if (instances.length > 0) {
       if (instances.length > 2) {
-        const last = instances.pop();
-        msg += `an instance of ${instances.join(', ')}, or ${last}`;
+        const last = ArrayPrototypePop(instances);
+        msg +=
+          `an instance of ${ArrayPrototypeJoin(instances, ', ')}, or ${last}`;
       } else {
         msg += `an instance of ${instances[0]}`;
         if (instances.length === 2) {
@@ -1031,12 +1084,12 @@ E('ERR_INVALID_ARG_TYPE',
 
     if (other.length > 0) {
       if (other.length > 2) {
-        const last = other.pop();
-        msg += `one of ${other.join(', ')}, or ${last}`;
+        const last = ArrayPrototypePop(other);
+        msg += `one of ${ArrayPrototypeJoin(other, ', ')}, or ${last}`;
       } else if (other.length === 2) {
         msg += `one of ${other[0]} or ${other[1]}`;
       } else {
-        if (other[0].toLowerCase() !== other[0])
+        if (StringPrototypeToLowerCase(other[0]) !== other[0])
           msg += 'an ';
         msg += `${other[0]}`;
       }
@@ -1058,7 +1111,7 @@ E('ERR_INVALID_ARG_TYPE',
       let inspected = lazyInternalUtilInspect()
         .inspect(actual, { colors: false });
       if (inspected.length > 25)
-        inspected = `${inspected.slice(0, 25)}...`;
+        inspected = `${StringPrototypeSlice(inspected, 0, 25)}...`;
       msg += `. Received type ${typeof actual} (${inspected})`;
     }
     return msg;
@@ -1066,7 +1119,7 @@ E('ERR_INVALID_ARG_TYPE',
 E('ERR_INVALID_ARG_VALUE', (name, value, reason = 'is invalid') => {
   let inspected = lazyInternalUtilInspect().inspect(value);
   if (inspected.length > 128) {
-    inspected = `${inspected.slice(0, 128)}...`;
+    inspected = `${StringPrototypeSlice(inspected, 0, 128)}...`;
   }
   return `The argument '${name}' ${reason}. Received ${inspected}`;
 }, TypeError, RangeError);
@@ -1192,9 +1245,11 @@ E('ERR_MANIFEST_ASSERT_INTEGRITY',
       moduleURL
     }" does not match the expected integrity.`;
     if (realIntegrities.size) {
-      const sri = [...realIntegrities.entries()].map(([alg, dgs]) => {
-        return `${alg}-${dgs}`;
-      }).join(' ');
+      const sri = ArrayPrototypeJoin(
+        ArrayFrom(realIntegrities.entries(),
+                  ({ 0: alg, 1: dgs }) => `${alg}-${dgs}`),
+        ' '
+      );
       msg += ` Integrities found are: ${sri}`;
     } else {
       msg += ' The resource was not found in the policy.';
@@ -1202,7 +1257,8 @@ E('ERR_MANIFEST_ASSERT_INTEGRITY',
     return msg;
   }, Error);
 E('ERR_MANIFEST_DEPENDENCY_MISSING',
-  'Manifest resource %s does not list %s as a dependency specifier',
+  'Manifest resource %s does not list %s as a dependency specifier for ' +
+  'conditions: %s',
   Error);
 E('ERR_MANIFEST_INTEGRITY_MISMATCH',
   'Manifest resource %s has multiple entries but integrity lists do not match',
@@ -1210,6 +1266,9 @@ E('ERR_MANIFEST_INTEGRITY_MISMATCH',
 E('ERR_MANIFEST_INVALID_RESOURCE_FIELD',
   'Manifest resource %s has invalid property value for %s',
   TypeError);
+E('ERR_MANIFEST_INVALID_SPECIFIER',
+  'Manifest resource %s has invalid dependency mapping %s',
+  TypeError);
 E('ERR_MANIFEST_TDZ', 'Manifest initialization has not yet run', Error);
 E('ERR_MANIFEST_UNKNOWN_ONERROR',
   'Manifest specified unknown error behavior "%s".',
@@ -1220,7 +1279,13 @@ E('ERR_MISSING_ARGS',
     assert(args.length > 0, 'At least one arg needs to be specified');
     let msg = 'The ';
     const len = args.length;
-    args = args.map((a) => `"${a}"`);
+    const wrap = (a) => `"${a}"`;
+    args = ArrayPrototypeMap(
+      args,
+      (a) => (ArrayIsArray(a) ?
+        ArrayPrototypeJoin(ArrayPrototypeMap(a, wrap), ' or ') :
+        wrap(a))
+    );
     switch (len) {
       case 1:
         msg += `${args[0]} argument`;
@@ -1229,15 +1294,12 @@ E('ERR_MISSING_ARGS',
         msg += `${args[0]} and ${args[1]} arguments`;
         break;
       default:
-        msg += args.slice(0, len - 1).join(', ');
+        msg += ArrayPrototypeJoin(ArrayPrototypeSlice(args, 0, len - 1), ', ');
         msg += `, and ${args[len - 1]} arguments`;
         break;
     }
     return `${msg} must be specified`;
   }, TypeError);
-E('ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK',
-  'The ES Module loader may not return a format of \'dynamic\' when no ' +
-  'dynamicInstantiate function was provided', Error);
 E('ERR_MISSING_OPTION', '%s is required', TypeError);
 E('ERR_MODULE_NOT_FOUND', (path, base, type = 'package') => {
   return `Cannot find ${type} '${path}' imported from ${base}`;
@@ -1256,6 +1318,7 @@ E('ERR_NO_CRYPTO',
   'Node.js is not compiled with OpenSSL crypto support', Error);
 E('ERR_NO_ICU',
   '%s is not supported on Node.js compiled without ICU', TypeError);
+E('ERR_OPERATION_FAILED', 'Operation failed: %s', Error);
 E('ERR_OUT_OF_RANGE',
   (str, range, input, replaceDefaultBoolean = false) => {
     assert(range, 'Missing "range" argument');
@@ -1326,7 +1389,6 @@ E('ERR_SOCKET_BAD_TYPE',
 E('ERR_SOCKET_BUFFER_SIZE',
   'Could not get or set buffer size',
   SystemError);
-E('ERR_SOCKET_CANNOT_SEND', 'Unable to send data', Error);
 E('ERR_SOCKET_CLOSED', 'Socket is closed', Error);
 E('ERR_SOCKET_DGRAM_IS_CONNECTED', 'Already connected', Error);
 E('ERR_SOCKET_DGRAM_NOT_CONNECTED', 'Not connected', Error);
@@ -1334,6 +1396,9 @@ E('ERR_SOCKET_DGRAM_NOT_RUNNING', 'Not running', Error);
 E('ERR_SRI_PARSE',
   'Subresource Integrity string %j had an unexpected %j at position %d',
   SyntaxError);
+E('ERR_STREAM_ALREADY_FINISHED',
+  'Cannot call %s after a stream was finished',
+  Error);
 E('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable', Error);
 E('ERR_STREAM_DESTROYED', 'Cannot call %s after a stream was destroyed', Error);
 E('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
@@ -1345,6 +1410,8 @@ E('ERR_STREAM_WRAP', 'Stream has StringDecoder set or is in objectMode', Error);
 E('ERR_STREAM_WRITE_AFTER_END', 'write after end', Error);
 E('ERR_SYNTHETIC', 'JavaScript Callstack', Error);
 E('ERR_SYSTEM_ERROR', 'A system error occurred', SystemError);
+E('ERR_TLS_CERT_ALTNAME_FORMAT', 'Invalid subject alternative name string',
+  SyntaxError);
 E('ERR_TLS_CERT_ALTNAME_INVALID', function(reason, host, cert) {
   this.reason = reason;
   this.host = host;
@@ -1353,11 +1420,11 @@ E('ERR_TLS_CERT_ALTNAME_INVALID', function(reason, host, cert) {
 }, Error);
 E('ERR_TLS_DH_PARAM_SIZE', 'DH parameter size %s is less than 2048', Error);
 E('ERR_TLS_HANDSHAKE_TIMEOUT', 'TLS handshake timeout', Error);
-E('ERR_TLS_INVALID_CONTEXT', '%s must be a SecureContext', TypeError),
-E('ERR_TLS_INVALID_STATE', 'TLS socket connection must be securely established',
-  Error),
+E('ERR_TLS_INVALID_CONTEXT', '%s must be a SecureContext', TypeError);
 E('ERR_TLS_INVALID_PROTOCOL_VERSION',
   '%j is not a valid %s TLS protocol version', TypeError);
+E('ERR_TLS_INVALID_STATE', 'TLS socket connection must be securely established',
+  Error);
 E('ERR_TLS_PROTOCOL_VERSION_CONFLICT',
   'TLS protocol version %j conflicts with secureProtocol %j', TypeError);
 E('ERR_TLS_RENEGOTIATION_DISABLED',
@@ -1432,7 +1499,7 @@ E('ERR_VM_MODULE_STATUS', 'Module status %s', Error);
 E('ERR_WASI_ALREADY_STARTED', 'WASI instance has already started', Error);
 E('ERR_WORKER_INIT_FAILED', 'Worker initialization failure: %s', Error);
 E('ERR_WORKER_INVALID_EXEC_ARGV', (errors, msg = 'invalid execArgv flags') =>
-  `Initiated Worker with ${msg}: ${errors.join(', ')}`,
+  `Initiated Worker with ${msg}: ${ArrayPrototypeJoin(errors, ', ')}`,
   Error);
 E('ERR_WORKER_NOT_RUNNING', 'Worker instance not running', Error);
 E('ERR_WORKER_OUT_OF_MEMORY',
@@ -1440,9 +1507,12 @@ E('ERR_WORKER_OUT_OF_MEMORY',
 E('ERR_WORKER_PATH', (filename) =>
   'The worker script or module filename must be an absolute path or a ' +
   'relative path starting with \'./\' or \'../\'.' +
-  (filename.startsWith('file://') ?
+  (StringPrototypeStartsWith(filename, 'file://') ?
     ' Wrap file:// URLs with `new URL`.' : ''
   ) +
+  (StringPrototypeStartsWith(filename, 'data:text/javascript') ?
+    ' Wrap data: URLs with `new URL`.' : ''
+  ) +
   ` Received "${filename}"`,
   TypeError);
 E('ERR_WORKER_UNSERIALIZABLE_ERROR',
diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc814b87c36138e430203aa6503ad806e4a62bab
--- /dev/null
+++ b/lib/internal/event_target.js
@@ -0,0 +1,641 @@
+'use strict';
+
+const {
+  ArrayFrom,
+  Boolean,
+  Error,
+  FunctionPrototypeBind,
+  FunctionPrototypeCall,
+  NumberIsInteger,
+  ObjectAssign,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectGetOwnPropertyDescriptor,
+  ReflectApply,
+  SafeMap,
+  String,
+  Symbol,
+  SymbolFor,
+  SymbolToStringTag,
+  SafeWeakSet,
+} = primordials;
+
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_EVENT_RECURSION,
+    ERR_MISSING_ARGS,
+    ERR_INVALID_THIS,
+  }
+} = require('internal/errors');
+const { validateObject, validateString } = require('internal/validators');
+
+const { customInspectSymbol } = require('internal/util');
+const { inspect } = require('util');
+
+const kIsEventTarget = SymbolFor('nodejs.event_target');
+
+const EventEmitter = require('events');
+const {
+  kMaxEventTargetListeners,
+  kMaxEventTargetListenersWarned,
+} = EventEmitter;
+
+const kEvents = Symbol('kEvents');
+const kStop = Symbol('kStop');
+const kTarget = Symbol('kTarget');
+const kHandlers = Symbol('khandlers');
+
+const kHybridDispatch = SymbolFor('nodejs.internal.kHybridDispatch');
+const kCreateEvent = Symbol('kCreateEvent');
+const kNewListener = Symbol('kNewListener');
+const kRemoveListener = Symbol('kRemoveListener');
+const kIsNodeStyleListener = Symbol('kIsNodeStyleListener');
+const kTrustEvent = Symbol('kTrustEvent');
+
+// Lazy load perf_hooks to avoid the additional overhead on startup
+let perf_hooks;
+function lazyNow() {
+  if (perf_hooks === undefined)
+    perf_hooks = require('perf_hooks');
+  return perf_hooks.performance.now();
+}
+
+// TODO(joyeecheung): V8 snapshot does not support instance member
+// initializers for now:
+// https://bugs.chromium.org/p/v8/issues/detail?id=10704
+const kType = Symbol('type');
+const kDefaultPrevented = Symbol('defaultPrevented');
+const kCancelable = Symbol('cancelable');
+const kTimestamp = Symbol('timestamp');
+const kBubbles = Symbol('bubbles');
+const kComposed = Symbol('composed');
+const kPropagationStopped = Symbol('propagationStopped');
+
+const isTrustedSet = new SafeWeakSet();
+const isTrusted = ObjectGetOwnPropertyDescriptor({
+  get isTrusted() {
+    return isTrustedSet.has(this);
+  }
+}, 'isTrusted').get;
+
+class Event {
+  constructor(type, options = null) {
+    if (arguments.length === 0)
+      throw new ERR_MISSING_ARGS('type');
+    validateObject(options, 'options', {
+      allowArray: true, allowFunction: true, nullable: true,
+    });
+    const { cancelable, bubbles, composed } = { ...options };
+    this[kCancelable] = !!cancelable;
+    this[kBubbles] = !!bubbles;
+    this[kComposed] = !!composed;
+    this[kType] = `${type}`;
+    this[kDefaultPrevented] = false;
+    this[kTimestamp] = lazyNow();
+    this[kPropagationStopped] = false;
+    if (options?.[kTrustEvent]) {
+      isTrustedSet.add(this);
+    }
+
+    // isTrusted is special (LegacyUnforgeable)
+    ObjectDefineProperty(this, 'isTrusted', {
+      get: isTrusted,
+      enumerable: true,
+      configurable: false
+    });
+    this[kTarget] = null;
+  }
+
+  [customInspectSymbol](depth, options) {
+    const name = this.constructor.name;
+    if (depth < 0)
+      return name;
+
+    const opts = ObjectAssign({}, options, {
+      depth: NumberIsInteger(options.depth) ? options.depth - 1 : options.depth
+    });
+
+    return `${name} ${inspect({
+      type: this[kType],
+      defaultPrevented: this[kDefaultPrevented],
+      cancelable: this[kCancelable],
+      timeStamp: this[kTimestamp],
+    }, opts)}`;
+  }
+
+  stopImmediatePropagation() {
+    this[kStop] = true;
+  }
+
+  preventDefault() {
+    this[kDefaultPrevented] = true;
+  }
+
+  get target() { return this[kTarget]; }
+  get currentTarget() { return this[kTarget]; }
+  get srcElement() { return this[kTarget]; }
+
+  get type() { return this[kType]; }
+
+  get cancelable() { return this[kCancelable]; }
+
+  get defaultPrevented() {
+    return this[kCancelable] && this[kDefaultPrevented];
+  }
+
+  get timeStamp() { return this[kTimestamp]; }
+
+
+  // The following are non-op and unused properties/methods from Web API Event.
+  // These are not supported in Node.js and are provided purely for
+  // API completeness.
+
+  composedPath() { return this[kTarget] ? [this[kTarget]] : []; }
+  get returnValue() { return !this.defaultPrevented; }
+  get bubbles() { return this[kBubbles]; }
+  get composed() { return this[kComposed]; }
+  get eventPhase() {
+    return this[kTarget] ? Event.AT_TARGET : Event.NONE;
+  }
+  get cancelBubble() { return this[kPropagationStopped]; }
+  set cancelBubble(value) {
+    if (value) {
+      this.stopPropagation();
+    }
+  }
+  stopPropagation() {
+    this[kPropagationStopped] = true;
+  }
+
+  static NONE = 0;
+  static CAPTURING_PHASE = 1;
+  static AT_TARGET = 2;
+  static BUBBLING_PHASE = 3;
+}
+
+ObjectDefineProperty(Event.prototype, SymbolToStringTag, {
+  writable: false,
+  enumerable: false,
+  configurable: true,
+  value: 'Event',
+});
+
+class NodeCustomEvent extends Event {
+  constructor(type, options) {
+    super(type, options);
+    if (options?.detail) {
+      this.detail = options.detail;
+    }
+  }
+}
+// The listeners for an EventTarget are maintained as a linked list.
+// Unfortunately, the way EventTarget is defined, listeners are accounted
+// using the tuple [handler,capture], and even if we don't actually make
+// use of capture or bubbling, in order to be spec compliant we have to
+// take on the additional complexity of supporting it. Fortunately, using
+// the linked list makes dispatching faster, even if adding/removing is
+// slower.
+class Listener {
+  constructor(previous, listener, once, capture, passive, isNodeStyleListener) {
+    this.next = undefined;
+    if (previous !== undefined)
+      previous.next = this;
+    this.previous = previous;
+    this.listener = listener;
+    this.once = once;
+    this.capture = capture;
+    this.passive = passive;
+    this.isNodeStyleListener = isNodeStyleListener;
+
+    this.callback =
+      typeof listener === 'function' ?
+        listener :
+        FunctionPrototypeBind(listener.handleEvent, listener);
+  }
+
+  same(listener, capture) {
+    return this.listener === listener && this.capture === capture;
+  }
+
+  remove() {
+    if (this.previous !== undefined)
+      this.previous.next = this.next;
+    if (this.next !== undefined)
+      this.next.previous = this.previous;
+  }
+}
+
+function initEventTarget(self) {
+  self[kEvents] = new SafeMap();
+  self[kMaxEventTargetListeners] = EventEmitter.defaultMaxListeners;
+  self[kMaxEventTargetListenersWarned] = false;
+}
+
+class EventTarget {
+  // Used in checking whether an object is an EventTarget. This is a well-known
+  // symbol as EventTarget may be used cross-realm.
+  // Ref: https://github.com/nodejs/node/pull/33661
+  static [kIsEventTarget] = true;
+
+  constructor() {
+    initEventTarget(this);
+  }
+
+  [kNewListener](size, type, listener, once, capture, passive) {
+    if (this[kMaxEventTargetListeners] > 0 &&
+        size > this[kMaxEventTargetListeners] &&
+        !this[kMaxEventTargetListenersWarned]) {
+      this[kMaxEventTargetListenersWarned] = true;
+      // No error code for this since it is a Warning
+      // eslint-disable-next-line no-restricted-syntax
+      const w = new Error('Possible EventTarget memory leak detected. ' +
+                          `${size} ${type} listeners ` +
+                          `added to ${inspect(this, { depth: -1 })}. Use ` +
+                          'events.setMaxListeners() to increase limit');
+      w.name = 'MaxListenersExceededWarning';
+      w.target = this;
+      w.type = type;
+      w.count = size;
+      process.emitWarning(w);
+    }
+  }
+  [kRemoveListener](size, type, listener, capture) {}
+
+  addEventListener(type, listener, options = {}) {
+    if (arguments.length < 2)
+      throw new ERR_MISSING_ARGS('type', 'listener');
+
+    // We validateOptions before the shouldAddListeners check because the spec
+    // requires us to hit getters.
+    const {
+      once,
+      capture,
+      passive,
+      isNodeStyleListener
+    } = validateEventListenerOptions(options);
+
+    if (!shouldAddListener(listener)) {
+      // The DOM silently allows passing undefined as a second argument
+      // No error code for this since it is a Warning
+      // eslint-disable-next-line no-restricted-syntax
+      const w = new Error(`addEventListener called with ${listener}` +
+                          ' which has no effect.');
+      w.name = 'AddEventListenerArgumentTypeWarning';
+      w.target = this;
+      w.type = type;
+      process.emitWarning(w);
+      return;
+    }
+    type = String(type);
+
+    let root = this[kEvents].get(type);
+
+    if (root === undefined) {
+      root = { size: 1, next: undefined };
+      // This is the first handler in our linked list.
+      new Listener(root, listener, once, capture, passive, isNodeStyleListener);
+      this[kNewListener](root.size, type, listener, once, capture, passive);
+      this[kEvents].set(type, root);
+      return;
+    }
+
+    let handler = root.next;
+    let previous = root;
+
+    // We have to walk the linked list to see if we have a match
+    while (handler !== undefined && !handler.same(listener, capture)) {
+      previous = handler;
+      handler = handler.next;
+    }
+
+    if (handler !== undefined) { // Duplicate! Ignore
+      return;
+    }
+
+    new Listener(previous, listener, once, capture, passive,
+                 isNodeStyleListener);
+    root.size++;
+    this[kNewListener](root.size, type, listener, once, capture, passive);
+  }
+
+  removeEventListener(type, listener, options = {}) {
+    if (!shouldAddListener(listener))
+      return;
+
+    type = String(type);
+    const capture = options?.capture === true;
+
+    const root = this[kEvents].get(type);
+    if (root === undefined || root.next === undefined)
+      return;
+
+    let handler = root.next;
+    while (handler !== undefined) {
+      if (handler.same(listener, capture)) {
+        handler.remove();
+        root.size--;
+        if (root.size === 0)
+          this[kEvents].delete(type);
+        this[kRemoveListener](root.size, type, listener, capture);
+        break;
+      }
+      handler = handler.next;
+    }
+  }
+
+  dispatchEvent(event) {
+    if (!(event instanceof Event))
+      throw new ERR_INVALID_ARG_TYPE('event', 'Event', event);
+
+    if (!isEventTarget(this))
+      throw new ERR_INVALID_THIS('EventTarget');
+
+    if (event[kTarget] !== null)
+      throw new ERR_EVENT_RECURSION(event.type);
+
+    this[kHybridDispatch](event, event.type, event);
+
+    return event.defaultPrevented !== true;
+  }
+
+  [kHybridDispatch](nodeValue, type, event) {
+    const createEvent = () => {
+      if (event === undefined) {
+        event = this[kCreateEvent](nodeValue, type);
+        event[kTarget] = this;
+      }
+      return event;
+    };
+    if (event !== undefined)
+      event[kTarget] = this;
+
+    const root = this[kEvents].get(type);
+    if (root === undefined || root.next === undefined)
+      return true;
+
+    let handler = root.next;
+    let next;
+
+    while (handler !== undefined &&
+           (handler.passive || event?.[kStop] !== true)) {
+      // Cache the next item in case this iteration removes the current one
+      next = handler.next;
+
+      if (handler.once) {
+        handler.remove();
+        root.size--;
+        const { listener, capture } = handler;
+        this[kRemoveListener](root.size, type, listener, capture);
+      }
+
+      try {
+        let arg;
+        if (handler.isNodeStyleListener) {
+          arg = nodeValue;
+        } else {
+          arg = createEvent();
+        }
+        const result = FunctionPrototypeCall(handler.callback, this, arg);
+        if (result !== undefined && result !== null)
+          addCatch(this, result, createEvent());
+      } catch (err) {
+        emitUnhandledRejectionOrErr(this, err, createEvent());
+      }
+
+      handler = next;
+    }
+
+    if (event !== undefined)
+      event[kTarget] = undefined;
+  }
+
+  [kCreateEvent](nodeValue, type) {
+    return new NodeCustomEvent(type, { detail: nodeValue });
+  }
+  [customInspectSymbol](depth, options) {
+    const name = this.constructor.name;
+    if (depth < 0)
+      return name;
+
+    const opts = ObjectAssign({}, options, {
+      depth: NumberIsInteger(options.depth) ? options.depth - 1 : options.depth
+    });
+
+    return `${name} ${inspect({}, opts)}`;
+  }
+}
+
+ObjectDefineProperties(EventTarget.prototype, {
+  addEventListener: { enumerable: true },
+  removeEventListener: { enumerable: true },
+  dispatchEvent: { enumerable: true }
+});
+ObjectDefineProperty(EventTarget.prototype, SymbolToStringTag, {
+  writable: false,
+  enumerable: false,
+  configurable: true,
+  value: 'EventTarget',
+});
+
+function initNodeEventTarget(self) {
+  initEventTarget(self);
+}
+
+class NodeEventTarget extends EventTarget {
+  static defaultMaxListeners = 10;
+
+  constructor() {
+    super();
+    initNodeEventTarget(this);
+  }
+
+  setMaxListeners(n) {
+    EventEmitter.setMaxListeners(n, this);
+  }
+
+  getMaxListeners() {
+    return this[kMaxEventTargetListeners];
+  }
+
+  eventNames() {
+    return ArrayFrom(this[kEvents].keys());
+  }
+
+  listenerCount(type) {
+    const root = this[kEvents].get(String(type));
+    return root !== undefined ? root.size : 0;
+  }
+
+  off(type, listener, options) {
+    this.removeEventListener(type, listener, options);
+    return this;
+  }
+
+  removeListener(type, listener, options) {
+    this.removeEventListener(type, listener, options);
+    return this;
+  }
+
+  on(type, listener) {
+    this.addEventListener(type, listener, { [kIsNodeStyleListener]: true });
+    return this;
+  }
+
+  addListener(type, listener) {
+    this.addEventListener(type, listener, { [kIsNodeStyleListener]: true });
+    return this;
+  }
+  emit(type, arg) {
+    validateString(type, 'type');
+    const hadListeners = this.listenerCount(type) > 0;
+    this[kHybridDispatch](arg, type);
+    return hadListeners;
+  }
+
+  once(type, listener) {
+    this.addEventListener(type, listener,
+                          { once: true, [kIsNodeStyleListener]: true });
+    return this;
+  }
+
+  removeAllListeners(type) {
+    if (type !== undefined) {
+      this[kEvents].delete(String(type));
+    } else {
+      this[kEvents].clear();
+    }
+
+    return this;
+  }
+}
+
+ObjectDefineProperties(NodeEventTarget.prototype, {
+  setMaxListeners: { enumerable: true },
+  getMaxListeners: { enumerable: true },
+  eventNames: { enumerable: true },
+  listenerCount: { enumerable: true },
+  off: { enumerable: true },
+  removeListener: { enumerable: true },
+  on: { enumerable: true },
+  addListener: { enumerable: true },
+  once: { enumerable: true },
+  emit: { enumerable: true },
+  removeAllListeners: { enumerable: true },
+});
+
+// EventTarget API
+
+function shouldAddListener(listener) {
+  if (typeof listener === 'function' ||
+      typeof listener?.handleEvent === 'function') {
+    return true;
+  }
+
+  if (listener == null)
+    return false;
+
+  throw new ERR_INVALID_ARG_TYPE('listener', 'EventListener', listener);
+}
+
+function validateEventListenerOptions(options) {
+  if (typeof options === 'boolean')
+    return { capture: options };
+
+  if (options === null)
+    return {};
+  validateObject(options, 'options', {
+    allowArray: true, allowFunction: true,
+  });
+  return {
+    once: Boolean(options.once),
+    capture: Boolean(options.capture),
+    passive: Boolean(options.passive),
+    isNodeStyleListener: Boolean(options[kIsNodeStyleListener])
+  };
+}
+
+// Test whether the argument is an event object. This is far from a fool-proof
+// test, for example this input will result in a false positive:
+// > isEventTarget({ constructor: EventTarget })
+// It stands in its current implementation as a compromise.
+// Ref: https://github.com/nodejs/node/pull/33661
+function isEventTarget(obj) {
+  return obj?.constructor?.[kIsEventTarget];
+}
+
+function addCatch(that, promise, event) {
+  const then = promise.then;
+  if (typeof then === 'function') {
+    FunctionPrototypeCall(then, promise, undefined, function(err) {
+      // The callback is called with nextTick to avoid a follow-up
+      // rejection from this promise.
+      process.nextTick(emitUnhandledRejectionOrErr, that, err, event);
+    });
+  }
+}
+
+function emitUnhandledRejectionOrErr(that, err, event) {
+  process.emit('error', err, event);
+}
+
+function makeEventHandler(handler) {
+  // Event handlers are dispatched in the order they were first set
+  // See https://github.com/nodejs/node/pull/35949#issuecomment-722496598
+  function eventHandler(...args) {
+    if (typeof eventHandler.handler !== 'function') {
+      return;
+    }
+    return ReflectApply(eventHandler.handler, this, args);
+  }
+  eventHandler.handler = handler;
+  return eventHandler;
+}
+
+function defineEventHandler(emitter, name) {
+  // 8.1.5.1 Event handlers - basically `on[eventName]` attributes
+  ObjectDefineProperty(emitter, `on${name}`, {
+    get() {
+      return this[kHandlers]?.get(name)?.handler;
+    },
+    set(value) {
+      if (!this[kHandlers]) {
+        this[kHandlers] = new SafeMap();
+      }
+      let wrappedHandler = this[kHandlers]?.get(name);
+      if (wrappedHandler) {
+        if (typeof wrappedHandler.handler === 'function') {
+          this[kEvents].get(name).size--;
+          const size = this[kEvents].get(name).size;
+          this[kRemoveListener](size, name, wrappedHandler.handler, false);
+        }
+        wrappedHandler.handler = value;
+        if (typeof wrappedHandler.handler === 'function') {
+          this[kEvents].get(name).size++;
+          const size = this[kEvents].get(name).size;
+          this[kNewListener](size, name, value, false, false, false);
+        }
+      } else {
+        wrappedHandler = makeEventHandler(value);
+        this.addEventListener(name, wrappedHandler);
+      }
+      this[kHandlers].set(name, wrappedHandler);
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+module.exports = {
+  Event,
+  EventTarget,
+  NodeEventTarget,
+  defineEventHandler,
+  initEventTarget,
+  initNodeEventTarget,
+  kCreateEvent,
+  kNewListener,
+  kTrustEvent,
+  kRemoveListener,
+  kEvents,
+  isEventTarget,
+};
diff --git a/lib/internal/freelist.js b/lib/internal/freelist.js
index 3e93e04f8dae386aa4a7b25644736c88578a2791..ac2b12c4d45a548dd6479a603e754d6d103202bb 100644
--- a/lib/internal/freelist.js
+++ b/lib/internal/freelist.js
@@ -12,10 +12,6 @@ class FreeList {
     this.list = [];
   }
 
-  hasItems() {
-    return this.list.length > 0;
-  }
-
   alloc() {
     return this.list.length > 0 ?
       this.list.pop() :
diff --git a/lib/internal/freeze_intrinsics.js b/lib/internal/freeze_intrinsics.js
index dc64c13409b2f131f387aa25f1d77eacdaefdf64..b5dd48ee07cedafb1ca965af7f4e9f46ca36bab0 100644
--- a/lib/internal/freeze_intrinsics.js
+++ b/lib/internal/freeze_intrinsics.js
@@ -15,26 +15,114 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Based upon:
-// https://github.com/google/caja/blob/master/src/com/google/caja/ses/startSES.js
-// https://github.com/google/caja/blob/master/src/com/google/caja/ses/repairES5.js
+// https://github.com/google/caja/blob/HEAD/src/com/google/caja/ses/startSES.js
+// https://github.com/google/caja/blob/HEAD/src/com/google/caja/ses/repairES5.js
 // https://github.com/tc39/proposal-ses/blob/e5271cc42a257a05dcae2fd94713ed2f46c08620/shim/src/freeze.js
 
-/* global WebAssembly, SharedArrayBuffer, console */
-/* eslint-disable no-restricted-globals */
+/* global console */
 'use strict';
 
+const {
+  Array,
+  ArrayBuffer,
+  ArrayBufferPrototype,
+  ArrayPrototype,
+  ArrayPrototypeForEach,
+  ArrayPrototypePush,
+  BigInt,
+  BigInt64Array,
+  BigInt64ArrayPrototype,
+  BigIntPrototype,
+  BigUint64Array,
+  BigUint64ArrayPrototype,
+  Boolean,
+  BooleanPrototype,
+  DataView,
+  DataViewPrototype,
+  Date,
+  DatePrototype,
+  Error,
+  ErrorPrototype,
+  EvalError,
+  EvalErrorPrototype,
+  Float32Array,
+  Float32ArrayPrototype,
+  Float64Array,
+  Float64ArrayPrototype,
+  Function,
+  FunctionPrototype,
+  Int16Array,
+  Int16ArrayPrototype,
+  Int32Array,
+  Int32ArrayPrototype,
+  Int8Array,
+  Int8ArrayPrototype,
+  Map,
+  MapPrototype,
+  Number,
+  NumberPrototype,
+  Object,
+  ObjectDefineProperty,
+  ObjectFreeze,
+  ObjectGetOwnPropertyDescriptor,
+  ObjectGetOwnPropertyDescriptors,
+  ObjectGetOwnPropertyNames,
+  ObjectGetOwnPropertySymbols,
+  ObjectGetPrototypeOf,
+  ObjectPrototype,
+  ObjectPrototypeHasOwnProperty,
+  Promise,
+  PromisePrototype,
+  Proxy,
+  RangeError,
+  RangeErrorPrototype,
+  ReferenceError,
+  ReferenceErrorPrototype,
+  ReflectOwnKeys,
+  RegExp,
+  RegExpPrototype,
+  SafeSet,
+  Set,
+  SetPrototype,
+  String,
+  StringPrototype,
+  Symbol,
+  SymbolIterator,
+  SyntaxError,
+  SyntaxErrorPrototype,
+  TypeError,
+  TypeErrorPrototype,
+  TypedArray,
+  TypedArrayPrototype,
+  Uint16Array,
+  Uint16ArrayPrototype,
+  Uint32Array,
+  Uint32ArrayPrototype,
+  Uint8Array,
+  Uint8ArrayPrototype,
+  Uint8ClampedArray,
+  Uint8ClampedArrayPrototype,
+  URIError,
+  URIErrorPrototype,
+  WeakMap,
+  WeakMapPrototype,
+  WeakSet,
+  WeakSetPrototype,
+  decodeURI,
+  decodeURIComponent,
+  encodeURI,
+  encodeURIComponent,
+  globalThis,
+} = primordials;
+
+const {
+  Atomics,
+  Intl,
+  SharedArrayBuffer,
+  WebAssembly
+} = globalThis;
+
 module.exports = function() {
-  const {
-    defineProperty,
-    freeze,
-    getOwnPropertyDescriptor,
-    getOwnPropertyDescriptors,
-    getOwnPropertyNames,
-    getOwnPropertySymbols,
-    getPrototypeOf,
-  } = Object;
-  const objectHasOwnProperty = Object.prototype.hasOwnProperty;
-  const { ownKeys } = Reflect;
   const {
     clearImmediate,
     clearInterval,
@@ -47,76 +135,76 @@ module.exports = function() {
   const intrinsicPrototypes = [
     // Anonymous Intrinsics
     // IteratorPrototype
-    getPrototypeOf(
-      getPrototypeOf(new Array()[Symbol.iterator]())
+    ObjectGetPrototypeOf(
+      ObjectGetPrototypeOf(new Array()[SymbolIterator]())
     ),
     // ArrayIteratorPrototype
-    getPrototypeOf(new Array()[Symbol.iterator]()),
+    ObjectGetPrototypeOf(new Array()[SymbolIterator]()),
     // StringIteratorPrototype
-    getPrototypeOf(new String()[Symbol.iterator]()),
+    ObjectGetPrototypeOf(new String()[SymbolIterator]()),
     // MapIteratorPrototype
-    getPrototypeOf(new Map()[Symbol.iterator]()),
+    ObjectGetPrototypeOf(new Map()[SymbolIterator]()),
     // SetIteratorPrototype
-    getPrototypeOf(new Set()[Symbol.iterator]()),
+    ObjectGetPrototypeOf(new Set()[SymbolIterator]()),
     // GeneratorFunction
-    getPrototypeOf(function* () {}),
+    ObjectGetPrototypeOf(function* () {}),
     // AsyncFunction
-    getPrototypeOf(async function() {}),
+    ObjectGetPrototypeOf(async function() {}),
     // AsyncGeneratorFunction
-    getPrototypeOf(async function* () {}),
+    ObjectGetPrototypeOf(async function* () {}),
     // TypedArray
-    getPrototypeOf(Uint8Array),
+    TypedArrayPrototype,
 
     // 19 Fundamental Objects
-    Object.prototype, // 19.1
-    Function.prototype, // 19.2
-    Boolean.prototype, // 19.3
-
-    Error.prototype, // 19.5
-    EvalError.prototype,
-    RangeError.prototype,
-    ReferenceError.prototype,
-    SyntaxError.prototype,
-    TypeError.prototype,
-    URIError.prototype,
+    ObjectPrototype, // 19.1
+    FunctionPrototype, // 19.2
+    BooleanPrototype, // 19.3
+
+    ErrorPrototype, // 19.5
+    EvalErrorPrototype,
+    RangeErrorPrototype,
+    ReferenceErrorPrototype,
+    SyntaxErrorPrototype,
+    TypeErrorPrototype,
+    URIErrorPrototype,
 
     // 20 Numbers and Dates
-    Number.prototype, // 20.1
-    Date.prototype, // 20.3
+    NumberPrototype, // 20.1
+    DatePrototype, // 20.3
 
     // 21 Text Processing
-    String.prototype, // 21.1
-    RegExp.prototype, // 21.2
+    StringPrototype, // 21.1
+    RegExpPrototype, // 21.2
 
     // 22 Indexed Collections
-    Array.prototype, // 22.1
-
-    Int8Array.prototype,
-    Uint8Array.prototype,
-    Uint8ClampedArray.prototype,
-    Int16Array.prototype,
-    Uint16Array.prototype,
-    Int32Array.prototype,
-    Uint32Array.prototype,
-    Float32Array.prototype,
-    Float64Array.prototype,
-    BigInt64Array.prototype,
-    BigUint64Array.prototype,
+    ArrayPrototype, // 22.1
+
+    Int8ArrayPrototype,
+    Uint8ArrayPrototype,
+    Uint8ClampedArrayPrototype,
+    Int16ArrayPrototype,
+    Uint16ArrayPrototype,
+    Int32ArrayPrototype,
+    Uint32ArrayPrototype,
+    Float32ArrayPrototype,
+    Float64ArrayPrototype,
+    BigInt64ArrayPrototype,
+    BigUint64ArrayPrototype,
 
     // 23 Keyed Collections
-    Map.prototype, // 23.1
-    Set.prototype, // 23.2
-    WeakMap.prototype, // 23.3
-    WeakSet.prototype, // 23.4
+    MapPrototype, // 23.1
+    SetPrototype, // 23.2
+    WeakMapPrototype, // 23.3
+    WeakSetPrototype, // 23.4
 
     // 24 Structured Data
-    ArrayBuffer.prototype, // 24.1
-    DataView.prototype, // 24.3
-    Promise.prototype, // 25.4
+    ArrayBufferPrototype, // 24.1
+    DataViewPrototype, // 24.3
+    PromisePrototype, // 25.4
 
     // Other APIs / Web Compatibility
     console.Console.prototype,
-    BigInt.prototype,
+    BigIntPrototype,
     WebAssembly.Module.prototype,
     WebAssembly.Instance.prototype,
     WebAssembly.Table.prototype,
@@ -124,38 +212,42 @@ module.exports = function() {
     WebAssembly.CompileError.prototype,
     WebAssembly.LinkError.prototype,
     WebAssembly.RuntimeError.prototype,
-    SharedArrayBuffer.prototype
+    SharedArrayBuffer.prototype,
   ];
   const intrinsics = [
     // Anonymous Intrinsics
     // ThrowTypeError
-    getOwnPropertyDescriptor(Function.prototype, 'caller').get,
+    ObjectGetOwnPropertyDescriptor(FunctionPrototype, 'caller').get,
     // IteratorPrototype
-    getPrototypeOf(
-      getPrototypeOf(new Array()[Symbol.iterator]())
+    ObjectGetPrototypeOf(
+      ObjectGetPrototypeOf(new Array()[SymbolIterator]())
     ),
     // ArrayIteratorPrototype
-    getPrototypeOf(new Array()[Symbol.iterator]()),
+    ObjectGetPrototypeOf(new Array()[SymbolIterator]()),
     // StringIteratorPrototype
-    getPrototypeOf(new String()[Symbol.iterator]()),
+    ObjectGetPrototypeOf(new String()[SymbolIterator]()),
     // MapIteratorPrototype
-    getPrototypeOf(new Map()[Symbol.iterator]()),
+    ObjectGetPrototypeOf(new Map()[SymbolIterator]()),
     // SetIteratorPrototype
-    getPrototypeOf(new Set()[Symbol.iterator]()),
+    ObjectGetPrototypeOf(new Set()[SymbolIterator]()),
     // GeneratorFunction
-    getPrototypeOf(function* () {}),
+    ObjectGetPrototypeOf(function* () {}),
     // AsyncFunction
-    getPrototypeOf(async function() {}),
+    ObjectGetPrototypeOf(async function() {}),
     // AsyncGeneratorFunction
-    getPrototypeOf(async function* () {}),
+    ObjectGetPrototypeOf(async function* () {}),
     // TypedArray
-    getPrototypeOf(Uint8Array),
+    TypedArray,
 
     // 18 The Global Object
     eval,
+    // eslint-disable-next-line node-core/prefer-primordials
     isFinite,
+    // eslint-disable-next-line node-core/prefer-primordials
     isNaN,
+    // eslint-disable-next-line node-core/prefer-primordials
     parseFloat,
+    // eslint-disable-next-line node-core/prefer-primordials
     parseInt,
     decodeURI,
     decodeURIComponent,
@@ -178,6 +270,7 @@ module.exports = function() {
 
     // 20 Numbers and Dates
     Number, // 20.1
+    // eslint-disable-next-line node-core/prefer-primordials
     Math, // 20.2
     Date, // 20.3
 
@@ -209,10 +302,12 @@ module.exports = function() {
     // 24 Structured Data
     ArrayBuffer, // 24.1
     DataView, // 24.3
+    // eslint-disable-next-line node-core/prefer-primordials
     JSON, // 24.5
     Promise, // 25.4
 
     // 26 Reflection
+    // eslint-disable-next-line node-core/prefer-primordials
     Reflect, // 26.1
     Proxy, // 26.2
 
@@ -231,23 +326,25 @@ module.exports = function() {
     BigInt,
     Atomics,
     WebAssembly,
-    SharedArrayBuffer
+    SharedArrayBuffer,
   ];
 
   if (typeof Intl !== 'undefined') {
-    intrinsicPrototypes.push(Intl.Collator.prototype);
-    intrinsicPrototypes.push(Intl.DateTimeFormat.prototype);
-    intrinsicPrototypes.push(Intl.ListFormat.prototype);
-    intrinsicPrototypes.push(Intl.NumberFormat.prototype);
-    intrinsicPrototypes.push(Intl.PluralRules.prototype);
-    intrinsicPrototypes.push(Intl.RelativeTimeFormat.prototype);
-    intrinsics.push(Intl);
+    ArrayPrototypePush(intrinsicPrototypes,
+                       Intl.Collator.prototype,
+                       Intl.DateTimeFormat.prototype,
+                       Intl.ListFormat.prototype,
+                       Intl.NumberFormat.prototype,
+                       Intl.PluralRules.prototype,
+                       Intl.RelativeTimeFormat.prototype,
+    );
+    ArrayPrototypePush(intrinsics, Intl);
   }
 
-  intrinsicPrototypes.forEach(enableDerivedOverrides);
+  ArrayPrototypeForEach(intrinsicPrototypes, enableDerivedOverrides);
 
   const frozenSet = new WeakSet();
-  intrinsics.forEach(deepFreeze);
+  ArrayPrototypeForEach(intrinsics, deepFreeze);
 
   // Objects that are deeply frozen.
   function deepFreeze(root) {
@@ -260,7 +357,7 @@ module.exports = function() {
      */
     function innerDeepFreeze(node) {
       // Objects that we have frozen in this round.
-      const freezingSet = new Set();
+      const freezingSet = new SafeSet();
 
       // If val is something we should be freezing but aren't yet,
       // add it to freezingSet.
@@ -289,16 +386,16 @@ module.exports = function() {
         // Object are verified before being enqueued,
         // therefore this is a valid candidate.
         // Throws if this fails (strict mode).
-        freeze(obj);
+        ObjectFreeze(obj);
 
         // We rely upon certain commitments of Object.freeze and proxies here
 
         // Get stable/immutable outbound links before a Proxy has a chance to do
         // something sneaky.
-        const proto = getPrototypeOf(obj);
-        const descs = getOwnPropertyDescriptors(obj);
+        const proto = ObjectGetPrototypeOf(obj);
+        const descs = ObjectGetOwnPropertyDescriptors(obj);
         enqueue(proto);
-        ownKeys(descs).forEach((name) => {
+        ArrayPrototypeForEach(ReflectOwnKeys(descs), (name) => {
           // TODO: Uncurried form
           // TODO: getOwnPropertyDescriptors is guaranteed to return well-formed
           // descriptors, but they still inherit from Object.prototype. If
@@ -378,10 +475,10 @@ module.exports = function() {
             `Cannot assign to read only property '${prop}' of object '${obj}'`
           );
         }
-        if (objectHasOwnProperty.call(this, prop)) {
+        if (ObjectPrototypeHasOwnProperty(this, prop)) {
           this[prop] = newValue;
         } else {
-          defineProperty(this, prop, {
+          ObjectDefineProperty(this, prop, {
             value: newValue,
             writable: true,
             enumerable: true,
@@ -390,7 +487,7 @@ module.exports = function() {
         }
       }
 
-      defineProperty(obj, prop, {
+      ObjectDefineProperty(obj, prop, {
         get: getter,
         set: setter,
         enumerable: desc.enumerable,
@@ -403,14 +500,14 @@ module.exports = function() {
     if (!obj) {
       return;
     }
-    const descs = getOwnPropertyDescriptors(obj);
+    const descs = ObjectGetOwnPropertyDescriptors(obj);
     if (!descs) {
       return;
     }
-    getOwnPropertyNames(obj).forEach((prop) => {
+    ArrayPrototypeForEach(ObjectGetOwnPropertyNames(obj), (prop) => {
       return enableDerivedOverride(obj, prop, descs[prop]);
     });
-    getOwnPropertySymbols(obj).forEach((prop) => {
+    ArrayPrototypeForEach(ObjectGetOwnPropertySymbols(obj), (prop) => {
       return enableDerivedOverride(obj, prop, descs[prop]);
     });
   }
diff --git a/lib/internal/fs/dir.js b/lib/internal/fs/dir.js
index b4cd72d3668e25004b24efd88d55d4ded9bfda7b..f794a62fdd358eb60c2d5e643585d5a1f4faa9a1 100644
--- a/lib/internal/fs/dir.js
+++ b/lib/internal/fs/dir.js
@@ -2,6 +2,7 @@
 
 const {
   ObjectDefineProperty,
+  PromiseReject,
   Symbol,
   SymbolAsyncIterator,
 } = primordials;
@@ -157,16 +158,24 @@ class Dir {
   }
 
   close(callback) {
-    if (this[kDirClosed] === true) {
-      throw new ERR_DIR_CLOSED();
-    }
-
+    // Promise
     if (callback === undefined) {
+      if (this[kDirClosed] === true) {
+        return PromiseReject(new ERR_DIR_CLOSED());
+      }
       return this[kDirClosePromisified]();
-    } else if (typeof callback !== 'function') {
+    }
+
+    // callback
+    if (typeof callback !== 'function') {
       throw new ERR_INVALID_CALLBACK(callback);
     }
 
+    if (this[kDirClosed] === true) {
+      process.nextTick(callback, new ERR_DIR_CLOSED());
+      return;
+    }
+
     if (this[kDirOperationQueue] !== null) {
       this[kDirOperationQueue].push(() => {
         this.close(callback);
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index fd1171be6b1b50c768adc04062b5ebc46bf5cc3a..be8d35e13e97e4d50e4e4dd71d0e5a8daff96c72 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -1,10 +1,16 @@
 'use strict';
 
 const {
+  ArrayPrototypePush,
+  Error,
   MathMax,
   MathMin,
   NumberIsSafeInteger,
+  Promise,
+  PromisePrototypeFinally,
+  PromiseResolve,
   Symbol,
+  Uint8Array,
 } = primordials;
 
 const {
@@ -15,21 +21,31 @@ const {
   S_IFREG
 } = internalBinding('constants').fs;
 const binding = internalBinding('fs');
-const { Buffer, kMaxLength } = require('buffer');
+const { Buffer } = require('buffer');
+
+const { AbortError, codes, hideStackFrames } = require('internal/errors');
 const {
   ERR_FS_FILE_TOO_LARGE,
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ARG_VALUE,
-  ERR_METHOD_NOT_IMPLEMENTED
-} = require('internal/errors').codes;
-const { isUint8Array } = require('internal/util/types');
+  ERR_METHOD_NOT_IMPLEMENTED,
+} = codes;
+const { isArrayBufferView } = require('internal/util/types');
 const { rimrafPromises } = require('internal/fs/rimraf');
 const {
+  constants: {
+    kIoMaxLength,
+    kMaxUserId,
+    kReadFileBufferLength,
+    kReadFileUnknownBufferLength,
+    kWriteFileMaxChunkSize,
+  },
   copyObject,
   getDirents,
   getOptions,
   getStatsFromBinding,
   getValidatedPath,
+  getValidMode,
   nullCheck,
   preprocessSymlinkDestination,
   stringToFlags,
@@ -38,33 +54,54 @@ const {
   validateBufferArray,
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
+  validateRmOptions,
   validateRmdirOptions,
+  validateStringAfterArrayBufferView,
   warnOnNonPortableTemplate
 } = require('internal/fs/utils');
 const { opendir } = require('internal/fs/dir');
 const {
-  parseMode,
+  parseFileMode,
+  validateAbortSignal,
   validateBuffer,
   validateInteger,
-  validateUint32
+  validateString,
 } = require('internal/validators');
 const pathModule = require('path');
 const { promisify } = require('internal/util');
+const { watch } = require('internal/fs/watchers');
+const { isIterable } = require('internal/streams/utils');
 
 const kHandle = Symbol('kHandle');
 const kFd = Symbol('kFd');
+const kRefs = Symbol('kRefs');
+const kClosePromise = Symbol('kClosePromise');
+const kCloseResolve = Symbol('kCloseResolve');
+const kCloseReject = Symbol('kCloseReject');
+
 const { kUsePromises } = binding;
 const {
   JSTransferable, kDeserialize, kTransfer, kTransferList
 } = require('internal/worker/js_transferable');
 
 const getDirectoryEntriesPromise = promisify(getDirents);
+const validateRmOptionsPromise = promisify(validateRmOptions);
+
+let DOMException;
+const lazyDOMException = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message, name);
+});
 
 class FileHandle extends JSTransferable {
   constructor(filehandle) {
     super();
     this[kHandle] = filehandle;
     this[kFd] = filehandle ? filehandle.fd : -1;
+
+    this[kRefs] = 1;
+    this[kClosePromise] = null;
   }
 
   getAsyncId() {
@@ -76,70 +113,101 @@ class FileHandle extends JSTransferable {
   }
 
   appendFile(data, options) {
-    return writeFile(this, data, options);
+    return fsCall(writeFile, this, data, options);
   }
 
   chmod(mode) {
-    return fchmod(this, mode);
+    return fsCall(fchmod, this, mode);
   }
 
   chown(uid, gid) {
-    return fchown(this, uid, gid);
+    return fsCall(fchown, this, uid, gid);
   }
 
   datasync() {
-    return fdatasync(this);
+    return fsCall(fdatasync, this);
   }
 
   sync() {
-    return fsync(this);
+    return fsCall(fsync, this);
   }
 
   read(buffer, offset, length, position) {
-    return read(this, buffer, offset, length, position);
+    return fsCall(read, this, buffer, offset, length, position);
   }
 
   readv(buffers, position) {
-    return readv(this, buffers, position);
+    return fsCall(readv, this, buffers, position);
   }
 
   readFile(options) {
-    return readFile(this, options);
+    return fsCall(readFile, this, options);
   }
 
   stat(options) {
-    return fstat(this, options);
+    return fsCall(fstat, this, options);
   }
 
   truncate(len = 0) {
-    return ftruncate(this, len);
+    return fsCall(ftruncate, this, len);
   }
 
   utimes(atime, mtime) {
-    return futimes(this, atime, mtime);
+    return fsCall(futimes, this, atime, mtime);
   }
 
   write(buffer, offset, length, position) {
-    return write(this, buffer, offset, length, position);
+    return fsCall(write, this, buffer, offset, length, position);
   }
 
   writev(buffers, position) {
-    return writev(this, buffers, position);
+    return fsCall(writev, this, buffers, position);
   }
 
   writeFile(data, options) {
-    return writeFile(this, data, options);
+    return fsCall(writeFile, this, data, options);
   }
 
   close = () => {
-    this[kFd] = -1;
-    return this[kHandle].close();
+    if (this[kFd] === -1) {
+      return PromiseResolve();
+    }
+
+    if (this[kClosePromise]) {
+      return this[kClosePromise];
+    }
+
+    this[kRefs]--;
+    if (this[kRefs] === 0) {
+      this[kFd] = -1;
+      this[kClosePromise] = this[kHandle].close().finally(() => {
+        this[kClosePromise] = undefined;
+      });
+    } else {
+      this[kClosePromise] = new Promise((resolve, reject) => {
+        this[kCloseResolve] = resolve;
+        this[kCloseReject] = reject;
+      }).finally(() => {
+        this[kClosePromise] = undefined;
+        this[kCloseReject] = undefined;
+        this[kCloseResolve] = undefined;
+      });
+    }
+
+    return this[kClosePromise];
   }
 
   [kTransfer]() {
+    if (this[kClosePromise] || this[kRefs] > 1) {
+      const DOMException = internalBinding('messaging').DOMException;
+      throw new DOMException('Cannot transfer FileHandle while in use',
+                             'DataCloneError');
+    }
+
     const handle = this[kHandle];
     this[kFd] = -1;
     this[kHandle] = null;
+    this[kRefs] = 0;
 
     return {
       data: { handle },
@@ -157,32 +225,81 @@ class FileHandle extends JSTransferable {
   }
 }
 
-function validateFileHandle(handle) {
-  if (!(handle instanceof FileHandle))
+async function fsCall(fn, handle, ...args) {
+  if (handle[kRefs] === undefined) {
     throw new ERR_INVALID_ARG_TYPE('filehandle', 'FileHandle', handle);
+  }
+
+  if (handle.fd === -1) {
+    // eslint-disable-next-line no-restricted-syntax
+    const err = new Error('file closed');
+    err.code = 'EBADF';
+    err.syscall = fn.name;
+    throw err;
+  }
+
+  try {
+    handle[kRefs]++;
+    return await fn(handle, ...args);
+  } finally {
+    handle[kRefs]--;
+    if (handle[kRefs] === 0) {
+      handle[kFd] = -1;
+      handle[kHandle]
+        .close()
+        .then(handle[kCloseResolve], handle[kCloseReject]);
+    }
+  }
+}
+
+function checkAborted(signal) {
+  if (signal && signal.aborted)
+    throw new AbortError();
 }
 
-async function writeFileHandle(filehandle, data, options) {
-  let buffer = isUint8Array(data) ?
-    data : Buffer.from('' + data, options.encoding || 'utf8');
-  let remaining = buffer.length;
+async function writeFileHandle(filehandle, data, signal, encoding) {
+  checkAborted(signal);
+  if (isCustomIterable(data)) {
+    for await (const buf of data) {
+      checkAborted(signal);
+      await write(
+        filehandle, buf, undefined,
+        isArrayBufferView(buf) ? buf.byteLength : encoding);
+      checkAborted(signal);
+    }
+    return;
+  }
+  data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  let remaining = data.byteLength;
   if (remaining === 0) return;
   do {
+    if (signal?.aborted) {
+      throw lazyDOMException('The operation was aborted', 'AbortError');
+    }
     const { bytesWritten } =
-      await write(filehandle, buffer, 0,
-                  MathMin(16384, buffer.length));
+      await write(filehandle, data, 0,
+                  MathMin(kWriteFileMaxChunkSize, data.byteLength));
     remaining -= bytesWritten;
-    buffer = buffer.slice(bytesWritten);
+    data = new Uint8Array(
+      data.buffer,
+      data.byteOffset + bytesWritten,
+      data.byteLength - bytesWritten
+    );
   } while (remaining > 0);
 }
 
-// Note: This is different from kReadFileBufferLength used for non-promisified
-// fs.readFile.
-const kReadFileMaxChunkSize = 16384;
-
 async function readFileHandle(filehandle, options) {
+  const signal = options && options.signal;
+
+  if (signal && signal.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
   const statFields = await binding.fstat(filehandle.fd, false, kUsePromises);
 
+  if (signal && signal.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
+
   let size;
   if ((statFields[1/* mode */] & S_IFMT) === S_IFREG) {
     size = statFields[8/* size */];
@@ -190,24 +307,49 @@ async function readFileHandle(filehandle, options) {
     size = 0;
   }
 
-  if (size > kMaxLength)
+  if (size > kIoMaxLength)
     throw new ERR_FS_FILE_TOO_LARGE(size);
 
-  const chunks = [];
-  const chunkSize = size === 0 ?
-    kReadFileMaxChunkSize :
-    MathMin(size, kReadFileMaxChunkSize);
   let endOfFile = false;
+  let totalRead = 0;
+  const noSize = size === 0;
+  const buffers = [];
+  const fullBuffer = noSize ? undefined : Buffer.allocUnsafeSlow(size);
   do {
-    const buf = Buffer.alloc(chunkSize);
-    const { bytesRead, buffer } =
-      await read(filehandle, buf, 0, chunkSize, -1);
-    endOfFile = bytesRead === 0;
-    if (bytesRead > 0)
-      chunks.push(buffer.slice(0, bytesRead));
+    if (signal && signal.aborted) {
+      throw lazyDOMException('The operation was aborted', 'AbortError');
+    }
+    let buffer;
+    let offset;
+    let length;
+    if (noSize) {
+      buffer = Buffer.allocUnsafeSlow(kReadFileUnknownBufferLength);
+      offset = 0;
+      length = kReadFileUnknownBufferLength;
+    } else {
+      buffer = fullBuffer;
+      offset = totalRead;
+      length = MathMin(size - totalRead, kReadFileBufferLength);
+    }
+
+    const bytesRead = (await binding.read(filehandle.fd, buffer, offset,
+                                          length, -1, kUsePromises)) || 0;
+    totalRead += bytesRead;
+    endOfFile = bytesRead === 0 || totalRead === size;
+    if (noSize && bytesRead > 0) {
+      const isBufferFull = bytesRead === kReadFileUnknownBufferLength;
+      const chunkBuffer = isBufferFull ? buffer : buffer.slice(0, bytesRead);
+      ArrayPrototypePush(buffers, chunkBuffer);
+    }
   } while (!endOfFile);
 
-  const result = Buffer.concat(chunks);
+  let result;
+  if (size > 0) {
+    result = totalRead === size ? fullBuffer : fullBuffer.slice(0, totalRead);
+  } else {
+    result = buffers.length === 1 ? buffers[0] : Buffer.concat(buffers,
+                                                               totalRead);
+  }
 
   return options.encoding ? result.toString(options.encoding) : result;
 }
@@ -217,48 +359,66 @@ async function readFileHandle(filehandle, options) {
 async function access(path, mode = F_OK) {
   path = getValidatedPath(path);
 
-  mode = mode | 0;
+  mode = getValidMode(mode, 'access');
   return binding.access(pathModule.toNamespacedPath(path), mode,
                         kUsePromises);
 }
 
-async function copyFile(src, dest, flags) {
+async function copyFile(src, dest, mode) {
   src = getValidatedPath(src, 'src');
   dest = getValidatedPath(dest, 'dest');
-  flags = flags | 0;
+  mode = getValidMode(mode, 'copyFile');
   return binding.copyFile(pathModule.toNamespacedPath(src),
                           pathModule.toNamespacedPath(dest),
-                          flags, kUsePromises);
+                          mode,
+                          kUsePromises);
 }
 
 // Note that unlike fs.open() which uses numeric file descriptors,
 // fsPromises.open() uses the fs.FileHandle class.
 async function open(path, flags, mode) {
   path = getValidatedPath(path);
-  if (arguments.length < 2) flags = 'r';
   const flagsNumber = stringToFlags(flags);
-  mode = parseMode(mode, 'mode', 0o666);
+  mode = parseFileMode(mode, 'mode', 0o666);
   return new FileHandle(
     await binding.openFileHandle(pathModule.toNamespacedPath(path),
                                  flagsNumber, mode, kUsePromises));
 }
 
-async function read(handle, buffer, offset, length, position) {
-  validateFileHandle(handle);
-  validateBuffer(buffer);
+async function read(handle, bufferOrOptions, offset, length, position) {
+  let buffer = bufferOrOptions;
+  if (!isArrayBufferView(buffer)) {
+    if (bufferOrOptions === undefined) {
+      bufferOrOptions = {};
+    }
+    if (bufferOrOptions.buffer) {
+      buffer = bufferOrOptions.buffer;
+      validateBuffer(buffer);
+    } else {
+      buffer = Buffer.alloc(16384);
+    }
+    offset = bufferOrOptions.offset || 0;
+    length = buffer.byteLength;
+    position = bufferOrOptions.position || null;
+  }
+
+  if (offset == null) {
+    offset = 0;
+  } else {
+    validateInteger(offset, 'offset', 0);
+  }
 
-  offset |= 0;
   length |= 0;
 
   if (length === 0)
     return { bytesRead: length, buffer };
 
-  if (buffer.length === 0) {
+  if (buffer.byteLength === 0) {
     throw new ERR_INVALID_ARG_VALUE('buffer', buffer,
                                     'is empty and cannot be written');
   }
 
-  validateOffsetLengthRead(offset, length, buffer.length);
+  validateOffsetLengthRead(offset, length, buffer.byteLength);
 
   if (!NumberIsSafeInteger(position))
     position = -1;
@@ -270,7 +430,6 @@ async function read(handle, buffer, offset, length, position) {
 }
 
 async function readv(handle, buffers, position) {
-  validateFileHandle(handle);
   validateBufferArray(buffers);
 
   if (typeof position !== 'number')
@@ -282,16 +441,17 @@ async function readv(handle, buffers, position) {
 }
 
 async function write(handle, buffer, offset, length, position) {
-  validateFileHandle(handle);
-
-  if (buffer.length === 0)
+  if (buffer && buffer.byteLength === 0)
     return { bytesWritten: 0, buffer };
 
-  if (isUint8Array(buffer)) {
-    if (typeof offset !== 'number')
+  if (isArrayBufferView(buffer)) {
+    if (offset == null) {
       offset = 0;
+    } else {
+      validateInteger(offset, 'offset', 0);
+    }
     if (typeof length !== 'number')
-      length = buffer.length - offset;
+      length = buffer.byteLength - offset;
     if (typeof position !== 'number')
       position = null;
     validateOffsetLengthWrite(offset, length, buffer.byteLength);
@@ -301,15 +461,13 @@ async function write(handle, buffer, offset, length, position) {
     return { bytesWritten, buffer };
   }
 
-  if (typeof buffer !== 'string')
-    buffer += '';
+  validateStringAfterArrayBufferView(buffer, 'buffer');
   const bytesWritten = (await binding.writeString(handle.fd, buffer, offset,
                                                   length, kUsePromises)) || 0;
   return { bytesWritten, buffer };
 }
 
 async function writev(handle, buffers, position) {
-  validateFileHandle(handle);
   validateBufferArray(buffers);
 
   if (typeof position !== 'number')
@@ -330,16 +488,21 @@ async function rename(oldPath, newPath) {
 
 async function truncate(path, len = 0) {
   const fd = await open(path, 'r+');
-  return ftruncate(fd, len).finally(fd.close.bind(fd));
+  return PromisePrototypeFinally(ftruncate(fd, len), fd.close);
 }
 
 async function ftruncate(handle, len = 0) {
-  validateFileHandle(handle);
   validateInteger(len, 'len');
   len = MathMax(0, len);
   return binding.ftruncate(handle.fd, len, kUsePromises);
 }
 
+async function rm(path, options) {
+  path = pathModule.toNamespacedPath(getValidatedPath(path));
+  options = await validateRmOptionsPromise(path, options);
+  return rimrafPromises(path, options);
+}
+
 async function rmdir(path, options) {
   path = pathModule.toNamespacedPath(getValidatedPath(path));
   options = validateRmdirOptions(options);
@@ -352,12 +515,10 @@ async function rmdir(path, options) {
 }
 
 async function fdatasync(handle) {
-  validateFileHandle(handle);
   return binding.fdatasync(handle.fd, kUsePromises);
 }
 
 async function fsync(handle) {
-  validateFileHandle(handle);
   return binding.fsync(handle.fd, kUsePromises);
 }
 
@@ -374,7 +535,7 @@ async function mkdir(path, options) {
     throw new ERR_INVALID_ARG_TYPE('options.recursive', 'boolean', recursive);
 
   return binding.mkdir(pathModule.toNamespacedPath(path),
-                       parseMode(mode, 'mode', 0o777), recursive,
+                       parseFileMode(mode, 'mode', 0o777), recursive,
                        kUsePromises);
 }
 
@@ -408,7 +569,6 @@ async function symlink(target, path, type_) {
 }
 
 async function fstat(handle, options = { bigint: false }) {
-  validateFileHandle(handle);
   const result = await binding.fstat(handle.fd, options.bigint, kUsePromises);
   return getStatsFromBinding(result);
 }
@@ -441,14 +601,13 @@ async function unlink(path) {
 }
 
 async function fchmod(handle, mode) {
-  validateFileHandle(handle);
-  mode = parseMode(mode, 'mode');
+  mode = parseFileMode(mode, 'mode');
   return binding.fchmod(handle.fd, mode, kUsePromises);
 }
 
 async function chmod(path, mode) {
   path = getValidatedPath(path);
-  mode = parseMode(mode, 'mode');
+  mode = parseFileMode(mode, 'mode');
   return binding.chmod(pathModule.toNamespacedPath(path), mode, kUsePromises);
 }
 
@@ -457,28 +616,27 @@ async function lchmod(path, mode) {
     throw new ERR_METHOD_NOT_IMPLEMENTED('lchmod()');
 
   const fd = await open(path, O_WRONLY | O_SYMLINK);
-  return fchmod(fd, mode).finally(fd.close);
+  return PromisePrototypeFinally(fchmod(fd, mode), fd.close);
 }
 
 async function lchown(path, uid, gid) {
   path = getValidatedPath(path);
-  validateUint32(uid, 'uid');
-  validateUint32(gid, 'gid');
+  validateInteger(uid, 'uid', -1, kMaxUserId);
+  validateInteger(gid, 'gid', -1, kMaxUserId);
   return binding.lchown(pathModule.toNamespacedPath(path),
                         uid, gid, kUsePromises);
 }
 
 async function fchown(handle, uid, gid) {
-  validateFileHandle(handle);
-  validateUint32(uid, 'uid');
-  validateUint32(gid, 'gid');
+  validateInteger(uid, 'uid', -1, kMaxUserId);
+  validateInteger(gid, 'gid', -1, kMaxUserId);
   return binding.fchown(handle.fd, uid, gid, kUsePromises);
 }
 
 async function chown(path, uid, gid) {
   path = getValidatedPath(path);
-  validateUint32(uid, 'uid');
-  validateUint32(gid, 'gid');
+  validateInteger(uid, 'uid', -1, kMaxUserId);
+  validateInteger(gid, 'gid', -1, kMaxUserId);
   return binding.chown(pathModule.toNamespacedPath(path),
                        uid, gid, kUsePromises);
 }
@@ -492,7 +650,6 @@ async function utimes(path, atime, mtime) {
 }
 
 async function futimes(handle, atime, mtime) {
-  validateFileHandle(handle);
   atime = toUnixTimestamp(atime, 'atime');
   mtime = toUnixTimestamp(mtime, 'mtime');
   return binding.futimes(handle.fd, atime, mtime, kUsePromises);
@@ -514,9 +671,8 @@ async function realpath(path, options) {
 
 async function mkdtemp(prefix, options) {
   options = getOptions(options, {});
-  if (!prefix || typeof prefix !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('prefix', 'string', prefix);
-  }
+
+  validateString(prefix, 'prefix');
   nullCheck(prefix);
   warnOnNonPortableTemplate(prefix);
   return binding.mkdtemp(`${prefix}XXXXXX`, options.encoding, kUsePromises);
@@ -526,11 +682,26 @@ async function writeFile(path, data, options) {
   options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'w' });
   const flag = options.flag || 'w';
 
+  if (!isArrayBufferView(data) && !isCustomIterable(data)) {
+    validateStringAfterArrayBufferView(data, 'data');
+    data = Buffer.from(data, options.encoding || 'utf8');
+  }
+
+  validateAbortSignal(options.signal);
   if (path instanceof FileHandle)
-    return writeFileHandle(path, data, options);
+    return writeFileHandle(path, data, options.signal, options.encoding);
+
+  if (options.signal?.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
 
   const fd = await open(path, flag, options.mode);
-  return writeFileHandle(fd, data, options).finally(fd.close);
+  return PromisePrototypeFinally(
+    writeFileHandle(fd, data, options.signal, options.encoding), fd.close);
+}
+
+function isCustomIterable(obj) {
+  return isIterable(obj) && !isArrayBufferView(obj) && typeof obj !== 'string';
 }
 
 async function appendFile(path, data, options) {
@@ -547,8 +718,12 @@ async function readFile(path, options) {
   if (path instanceof FileHandle)
     return readFileHandle(path, options);
 
+  if (options.signal?.aborted) {
+    throw lazyDOMException('The operation was aborted', 'AbortError');
+  }
+
   const fd = await open(path, flag, 0o666);
-  return readFileHandle(fd, options).finally(fd.close);
+  return PromisePrototypeFinally(readFileHandle(fd, options), fd.close);
 }
 
 module.exports = {
@@ -559,6 +734,7 @@ module.exports = {
     opendir: promisify(opendir),
     rename,
     truncate,
+    rm,
     rmdir,
     mkdir,
     readdir,
@@ -579,6 +755,7 @@ module.exports = {
     writeFile,
     appendFile,
     readFile,
+    watch,
   },
 
   FileHandle
diff --git a/lib/internal/fs/read_file_context.js b/lib/internal/fs/read_file_context.js
index d7b0e368006f054fbf52650cf421e1b7fd05e549..4976a7a1deb8d85a5cfa7a694e80faba7e09dafe 100644
--- a/lib/internal/fs/read_file_context.js
+++ b/lib/internal/fs/read_file_context.js
@@ -4,18 +4,26 @@ const {
   MathMin,
 } = primordials;
 
+const {
+  constants: {
+    kReadFileBufferLength,
+    kReadFileUnknownBufferLength,
+  }
+} = require('internal/fs/utils');
+
 const { Buffer } = require('buffer');
 
 const { FSReqCallback, close, read } = internalBinding('fs');
 
-// Use 64kb in case the file type is not a regular file and thus do not know the
-// actual file size. Increasing the value further results in more frequent over
-// allocation for small files and consumes CPU time and memory that should be
-// used else wise.
-// Use up to 512kb per read otherwise to partition reading big files to prevent
-// blocking other threads in case the available threads are all in use.
-const kReadFileUnknownBufferLength = 64 * 1024;
-const kReadFileBufferLength = 512 * 1024;
+const { hideStackFrames } = require('internal/errors');
+
+
+let DOMException;
+const lazyDOMException = hideStackFrames((message, name) => {
+  if (DOMException === undefined)
+    DOMException = internalBinding('messaging').DOMException;
+  return new DOMException(message, name);
+});
 
 function readFileAfterRead(err, bytesRead) {
   const context = this.context;
@@ -74,6 +82,7 @@ class ReadFileContext {
     this.pos = 0;
     this.encoding = encoding;
     this.err = null;
+    this.signal = undefined;
   }
 
   read() {
@@ -81,6 +90,11 @@ class ReadFileContext {
     let offset;
     let length;
 
+    if (this.signal && this.signal.aborted) {
+      return this.close(
+        lazyDOMException('The operation was aborted', 'AbortError')
+      );
+    }
     if (this.size === 0) {
       buffer = Buffer.allocUnsafeSlow(kReadFileUnknownBufferLength);
       offset = 0;
@@ -100,18 +114,18 @@ class ReadFileContext {
   }
 
   close(err) {
+    if (this.isUserFd) {
+      process.nextTick(function tick(context) {
+        readFileAfterClose.call({ context }, null);
+      }, this);
+      return;
+    }
+
     const req = new FSReqCallback();
     req.oncomplete = readFileAfterClose;
     req.context = this;
     this.err = err;
 
-    if (this.isUserFd) {
-      process.nextTick(function tick() {
-        req.oncomplete(null);
-      });
-      return;
-    }
-
     close(this.fd, req);
   }
 }
diff --git a/lib/internal/fs/rimraf.js b/lib/internal/fs/rimraf.js
index e88dd9697b1938fe1a833a86a92133b7edda5237..e67b14a418c88490588eb787f4a4eb4c20c8a8c8 100644
--- a/lib/internal/fs/rimraf.js
+++ b/lib/internal/fs/rimraf.js
@@ -12,6 +12,7 @@ const {
 } = primordials;
 
 const { Buffer } = require('buffer');
+const fs = require('fs');
 const {
   chmod,
   chmodSync,
@@ -25,7 +26,7 @@ const {
   statSync,
   unlink,
   unlinkSync
-} = require('fs');
+} = fs;
 const { sep } = require('path');
 const { setTimeout } = require('timers');
 const { sleep } = require('internal/util');
@@ -249,7 +250,7 @@ function _rmdirSync(path, options, originalErr) {
 
       for (let i = 1; i <= tries; i++) {
         try {
-          return rmdirSync(path, options);
+          return fs.rmdirSync(path);
         } catch (err) {
           // Only sleep if this is not the last try, and the delay is greater
           // than zero, and an error was encountered that warrants a retry.
diff --git a/lib/internal/fs/streams.js b/lib/internal/fs/streams.js
index c5cbe9640723d7592f56f4ff08c1e37c9ac8c031..35d93f7d61cbcaf0993428f19e95e251901c766c 100644
--- a/lib/internal/fs/streams.js
+++ b/lib/internal/fs/streams.js
@@ -13,6 +13,7 @@ const {
   ERR_OUT_OF_RANGE,
   ERR_STREAM_DESTROYED
 } = require('internal/errors').codes;
+const { deprecate } = require('internal/util');
 const { validateInteger } = require('internal/validators');
 const fs = require('fs');
 const { Buffer } = require('buffer');
@@ -25,29 +26,8 @@ const { toPathIfFileURL } = require('internal/url');
 const kIoDone = Symbol('kIoDone');
 const kIsPerformingIO = Symbol('kIsPerformingIO');
 
-const kMinPoolSpace = 128;
 const kFs = Symbol('kFs');
 
-let pool;
-// It can happen that we expect to read a large chunk of data, and reserve
-// a large chunk of the pool accordingly, but the read() call only filled
-// a portion of it. If a concurrently executing read() then uses the same pool,
-// the "reserved" portion cannot be used, so we allow it to be re-used as a
-// new pool later.
-const poolFragments = [];
-
-function allocNewPool(poolSize) {
-  if (poolFragments.length > 0)
-    pool = poolFragments.pop();
-  else
-    pool = Buffer.allocUnsafe(poolSize);
-  pool.used = 0;
-}
-
-function roundUpToMultipleOf8(n) {
-  return (n + 7) & ~7;  // Align to 8 byte boundary.
-}
-
 function ReadStream(path, options) {
   if (!(this instanceof ReadStream))
     return new ReadStream(path, options);
@@ -57,9 +37,8 @@ function ReadStream(path, options) {
   if (options.highWaterMark === undefined)
     options.highWaterMark = 64 * 1024;
 
-  // For backwards compat do not emit close on destroy.
-  if (options.emitClose === undefined) {
-    options.emitClose = false;
+  if (options.autoDestroy === undefined) {
+    options.autoDestroy = false;
   }
 
   this[kFs] = options.fs || fs;
@@ -116,7 +95,7 @@ function ReadStream(path, options) {
   }
 
   if (typeof this.fd !== 'number')
-    this.open();
+    _openReadFs(this);
 
   this.on('end', function() {
     if (this.autoClose) {
@@ -127,23 +106,34 @@ function ReadStream(path, options) {
 ObjectSetPrototypeOf(ReadStream.prototype, Readable.prototype);
 ObjectSetPrototypeOf(ReadStream, Readable);
 
-ReadStream.prototype.open = function() {
-  this[kFs].open(this.path, this.flags, this.mode, (er, fd) => {
+const openReadFs = deprecate(function() {
+  _openReadFs(this);
+}, 'ReadStream.prototype.open() is deprecated', 'DEP0135');
+ReadStream.prototype.open = openReadFs;
+
+function _openReadFs(stream) {
+  // Backwards compat for overriden open.
+  if (stream.open !== openReadFs) {
+    stream.open();
+    return;
+  }
+
+  stream[kFs].open(stream.path, stream.flags, stream.mode, (er, fd) => {
     if (er) {
-      if (this.autoClose) {
-        this.destroy();
+      if (stream.autoClose) {
+        stream.destroy();
       }
-      this.emit('error', er);
+      stream.emit('error', er);
       return;
     }
 
-    this.fd = fd;
-    this.emit('open', fd);
-    this.emit('ready');
+    stream.fd = fd;
+    stream.emit('open', fd);
+    stream.emit('ready');
     // Start the flow of data.
-    this.read();
+    stream.read();
   });
-};
+}
 
 ReadStream.prototype._read = function(n) {
   if (typeof this.fd !== 'number') {
@@ -154,73 +144,54 @@ ReadStream.prototype._read = function(n) {
 
   if (this.destroyed) return;
 
-  if (!pool || pool.length - pool.used < kMinPoolSpace) {
-    // Discard the old pool.
-    allocNewPool(this.readableHighWaterMark);
-  }
+  n = this.pos !== undefined ?
+    MathMin(this.end - this.pos + 1, n) :
+    MathMin(this.end - this.bytesRead + 1, n);
 
-  // Grab another reference to the pool in the case that while we're
-  // in the thread pool another read() finishes up the pool, and
-  // allocates a new one.
-  const thisPool = pool;
-  let toRead = MathMin(pool.length - pool.used, n);
-  const start = pool.used;
-
-  if (this.pos !== undefined)
-    toRead = MathMin(this.end - this.pos + 1, toRead);
-  else
-    toRead = MathMin(this.end - this.bytesRead + 1, toRead);
+  if (n <= 0) {
+    this.push(null);
+    return;
+  }
 
-  // Already read everything we were supposed to read!
-  // treat as EOF.
-  if (toRead <= 0)
-    return this.push(null);
+  const buf = Buffer.allocUnsafeSlow(n);
 
-  // the actual read.
   this[kIsPerformingIO] = true;
-  this[kFs].read(
-    this.fd, pool, pool.used, toRead, this.pos, (er, bytesRead) => {
+  this[kFs]
+    .read(this.fd, buf, 0, n, this.pos, (er, bytesRead, buf) => {
       this[kIsPerformingIO] = false;
+
       // Tell ._destroy() that it's safe to close the fd now.
-      if (this.destroyed) return this.emit(kIoDone, er);
+      if (this.destroyed) {
+        this.emit(kIoDone, er);
+        return;
+      }
 
       if (er) {
         if (this.autoClose) {
           this.destroy();
         }
         this.emit('error', er);
-      } else {
-        let b = null;
-        // Now that we know how much data we have actually read, re-wind the
-        // 'used' field if we can, and otherwise allow the remainder of our
-        // reservation to be used as a new pool later.
-        if (start + toRead === thisPool.used && thisPool === pool) {
-          const newUsed = thisPool.used + bytesRead - toRead;
-          thisPool.used = roundUpToMultipleOf8(newUsed);
-        } else {
-          // Round down to the next lowest multiple of 8 to ensure the new pool
-          // fragment start and end positions are aligned to an 8 byte boundary.
-          const alignedEnd = (start + toRead) & ~7;
-          const alignedStart = roundUpToMultipleOf8(start + bytesRead);
-          if (alignedEnd - alignedStart >= kMinPoolSpace) {
-            poolFragments.push(thisPool.slice(alignedStart, alignedEnd));
-          }
+      } else if (bytesRead > 0) {
+        if (this.pos !== undefined) {
+          this.pos += bytesRead;
         }
 
-        if (bytesRead > 0) {
-          this.bytesRead += bytesRead;
-          b = thisPool.slice(start, start + bytesRead);
+        this.bytesRead += bytesRead;
+
+        if (bytesRead !== buf.length) {
+          // Slow path. Shrink to fit.
+          // Copy instead of slice so that we don't retain
+          // large backing buffer for small reads.
+          const dst = Buffer.allocUnsafeSlow(bytesRead);
+          buf.copy(dst, 0, 0, bytesRead);
+          buf = dst;
         }
 
-        this.push(b);
+        this.push(buf);
+      } else {
+        this.push(null);
       }
     });
-
-  // Move the pool positions, and internal position for reading.
-  if (this.pos !== undefined)
-    this.pos += toRead;
-
-  pool.used = roundUpToMultipleOf8(pool.used + toRead);
 };
 
 ReadStream.prototype._destroy = function(err, cb) {
@@ -239,12 +210,8 @@ ReadStream.prototype._destroy = function(err, cb) {
 
 function closeFsStream(stream, cb, err) {
   stream[kFs].close(stream.fd, (er) => {
-    er = er || err;
-    cb(er);
     stream.closed = true;
-    const s = stream._writableState || stream._readableState;
-    if (!er && !s.emitClose)
-      stream.emit('close');
+    cb(er || err);
   });
 
   stream.fd = null;
@@ -269,9 +236,9 @@ function WriteStream(path, options) {
   // Only buffers are supported.
   options.decodeStrings = true;
 
-  // For backwards compat do not emit close on destroy.
-  if (options.emitClose === undefined) {
-    options.emitClose = false;
+  if (options.autoDestroy === undefined) {
+    options.autoDestroy = options.autoClose === undefined ?
+      true : (options.autoClose || false);
   }
 
   this[kFs] = options.fs || fs;
@@ -317,7 +284,7 @@ function WriteStream(path, options) {
   this.mode = options.mode === undefined ? 0o666 : options.mode;
 
   this.start = options.start;
-  this.autoClose = options.autoClose === undefined ? true : !!options.autoClose;
+  this.autoClose = options.autoDestroy;
   this.pos = undefined;
   this.bytesWritten = 0;
   this.closed = false;
@@ -333,7 +300,7 @@ function WriteStream(path, options) {
     this.setDefaultEncoding(options.encoding);
 
   if (typeof this.fd !== 'number')
-    this.open();
+    _openWriteFs(this);
 }
 ObjectSetPrototypeOf(WriteStream.prototype, Writable.prototype);
 ObjectSetPrototypeOf(WriteStream, Writable);
@@ -345,28 +312,35 @@ WriteStream.prototype._final = function(callback) {
     });
   }
 
-  if (this.autoClose) {
-    this.destroy();
-  }
-
   callback();
 };
 
-WriteStream.prototype.open = function() {
-  this[kFs].open(this.path, this.flags, this.mode, (er, fd) => {
+const openWriteFs = deprecate(function() {
+  _openWriteFs(this);
+}, 'WriteStream.prototype.open() is deprecated', 'DEP0135');
+WriteStream.prototype.open = openWriteFs;
+
+function _openWriteFs(stream) {
+  // Backwards compat for overriden open.
+  if (stream.open !== openWriteFs) {
+    stream.open();
+    return;
+  }
+
+  stream[kFs].open(stream.path, stream.flags, stream.mode, (er, fd) => {
     if (er) {
-      if (this.autoClose) {
-        this.destroy();
+      if (stream.autoClose) {
+        stream.destroy();
       }
-      this.emit('error', er);
+      stream.emit('error', er);
       return;
     }
 
-    this.fd = fd;
-    this.emit('open', fd);
-    this.emit('ready');
+    stream.fd = fd;
+    stream.emit('open', fd);
+    stream.emit('ready');
   });
-};
+}
 
 
 WriteStream.prototype._write = function(data, encoding, cb) {
@@ -388,9 +362,6 @@ WriteStream.prototype._write = function(data, encoding, cb) {
     }
 
     if (er) {
-      if (this.autoClose) {
-        this.destroy();
-      }
       return cb(er);
     }
     this.bytesWritten += bytes;
@@ -433,7 +404,7 @@ WriteStream.prototype._writev = function(data, cb) {
 
     if (er) {
       if (this.autoClose) {
-        this.destroy();
+        this.destroy(er);
       }
       return cb(er);
     }
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index ed4e9bb66ad79ffd542b769ab17a28bb801764c6..6af79033f452b6fe2e2af79e870d26e5382f257c 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -3,18 +3,23 @@
 const {
   ArrayIsArray,
   BigInt,
+  Date,
   DateNow,
-  Error,
+  ErrorCaptureStackTrace,
+  ObjectPrototypeHasOwnProperty,
   Number,
   NumberIsFinite,
+  NumberIsInteger,
+  MathMin,
   ObjectSetPrototypeOf,
   ReflectOwnKeys,
   Symbol,
 } = primordials;
 
-const { Buffer, kMaxLength } = require('buffer');
+const { Buffer } = require('buffer');
 const {
   codes: {
+    ERR_FS_EISDIR,
     ERR_FS_INVALID_SYMLINK_TYPE,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
@@ -34,41 +39,96 @@ const {
 const { once } = require('internal/util');
 const { toPathIfFileURL } = require('internal/url');
 const {
+  validateAbortSignal,
+  validateBoolean,
   validateInt32,
-  validateUint32
+  validateInteger,
+  validateUint32,
 } = require('internal/validators');
 const pathModule = require('path');
 const kType = Symbol('type');
 const kStats = Symbol('stats');
+const assert = require('internal/assert');
 
 const {
-  O_APPEND,
-  O_CREAT,
-  O_EXCL,
-  O_RDONLY,
-  O_RDWR,
-  O_SYNC,
-  O_TRUNC,
-  O_WRONLY,
-  S_IFBLK,
-  S_IFCHR,
-  S_IFDIR,
-  S_IFIFO,
-  S_IFLNK,
-  S_IFMT,
-  S_IFREG,
-  S_IFSOCK,
-  UV_FS_SYMLINK_DIR,
-  UV_FS_SYMLINK_JUNCTION,
-  UV_DIRENT_UNKNOWN,
-  UV_DIRENT_FILE,
-  UV_DIRENT_DIR,
-  UV_DIRENT_LINK,
-  UV_DIRENT_FIFO,
-  UV_DIRENT_SOCKET,
-  UV_DIRENT_CHAR,
-  UV_DIRENT_BLOCK
-} = internalBinding('constants').fs;
+  fs: {
+    F_OK = 0,
+    W_OK = 0,
+    R_OK = 0,
+    X_OK = 0,
+    COPYFILE_EXCL,
+    COPYFILE_FICLONE,
+    COPYFILE_FICLONE_FORCE,
+    O_APPEND,
+    O_CREAT,
+    O_EXCL,
+    O_RDONLY,
+    O_RDWR,
+    O_SYNC,
+    O_TRUNC,
+    O_WRONLY,
+    S_IFBLK,
+    S_IFCHR,
+    S_IFDIR,
+    S_IFIFO,
+    S_IFLNK,
+    S_IFMT,
+    S_IFREG,
+    S_IFSOCK,
+    UV_FS_SYMLINK_DIR,
+    UV_FS_SYMLINK_JUNCTION,
+    UV_DIRENT_UNKNOWN,
+    UV_DIRENT_FILE,
+    UV_DIRENT_DIR,
+    UV_DIRENT_LINK,
+    UV_DIRENT_FIFO,
+    UV_DIRENT_SOCKET,
+    UV_DIRENT_CHAR,
+    UV_DIRENT_BLOCK
+  },
+  os: {
+    errno: {
+      EISDIR
+    }
+  }
+} = internalBinding('constants');
+
+// The access modes can be any of F_OK, R_OK, W_OK or X_OK. Some might not be
+// available on specific systems. They can be used in combination as well
+// (F_OK | R_OK | W_OK | X_OK).
+const kMinimumAccessMode = MathMin(F_OK, W_OK, R_OK, X_OK);
+const kMaximumAccessMode = F_OK | W_OK | R_OK | X_OK;
+
+const kDefaultCopyMode = 0;
+// The copy modes can be any of COPYFILE_EXCL, COPYFILE_FICLONE or
+// COPYFILE_FICLONE_FORCE. They can be used in combination as well
+// (COPYFILE_EXCL | COPYFILE_FICLONE | COPYFILE_FICLONE_FORCE).
+const kMinimumCopyMode = MathMin(
+  kDefaultCopyMode,
+  COPYFILE_EXCL,
+  COPYFILE_FICLONE,
+  COPYFILE_FICLONE_FORCE
+);
+const kMaximumCopyMode = COPYFILE_EXCL |
+                         COPYFILE_FICLONE |
+                         COPYFILE_FICLONE_FORCE;
+
+// Most platforms don't allow reads or writes >= 2 GB.
+// See https://github.com/libuv/libuv/pull/1501.
+const kIoMaxLength = 2 ** 31 - 1;
+
+// Use 64kb in case the file type is not a regular file and thus do not know the
+// actual file size. Increasing the value further results in more frequent over
+// allocation for small files and consumes CPU time and memory that should be
+// used else wise.
+// Use up to 512kb per read otherwise to partition reading big files to prevent
+// blocking other threads in case the available threads are all in use.
+const kReadFileUnknownBufferLength = 64 * 1024;
+const kReadFileBufferLength = 512 * 1024;
+
+const kWriteFileMaxChunkSize = 512 * 1024;
+
+const kMaxUserId = 2 ** 32 - 1;
 
 const isWindows = process.platform === 'win32';
 
@@ -258,22 +318,24 @@ function getOptions(options, defaultOptions) {
 
   if (options.encoding !== 'buffer')
     assertEncoding(options.encoding);
+
+  if (options.signal !== undefined) {
+    validateAbortSignal(options.signal, 'options.signal');
+  }
   return options;
 }
 
 function handleErrorFromBinding(ctx) {
   if (ctx.errno !== undefined) {  // libuv error numbers
     const err = uvException(ctx);
-    // eslint-disable-next-line no-restricted-syntax
-    Error.captureStackTrace(err, handleErrorFromBinding);
+    ErrorCaptureStackTrace(err, handleErrorFromBinding);
     throw err;
   }
   if (ctx.error !== undefined) {  // Errors created in C++ land.
     // TODO(joyeecheung): currently, ctx.error are encoding errors
     // usually caused by memory problems. We need to figure out proper error
     // code(s) for this.
-    // eslint-disable-next-line no-restricted-syntax
-    Error.captureStackTrace(ctx.error, handleErrorFromBinding);
+    ErrorCaptureStackTrace(ctx.error, handleErrorFromBinding);
     throw ctx.error;
   }
 }
@@ -307,19 +369,19 @@ function preprocessSymlinkDestination(path, type, linkPath) {
     // No preprocessing is needed on Unix.
     return path;
   }
+  path = '' + path;
   if (type === 'junction') {
     // Junctions paths need to be absolute and \\?\-prefixed.
     // A relative target is relative to the link's parent directory.
     path = pathModule.resolve(linkPath, '..', path);
     return pathModule.toNamespacedPath(path);
   }
-
   if (pathModule.isAbsolute(path)) {
     // If the path is absolute, use the \\?\-prefix to enable long filenames
     return pathModule.toNamespacedPath(path);
   }
   // Windows symlinks don't tolerate forward slashes.
-  return ('' + path).replace(/\//g, '\\');
+  return path.replace(/\//g, '\\');
 }
 
 // Constructor for file stats.
@@ -478,6 +540,10 @@ function stringToFlags(flags) {
     return flags;
   }
 
+  if (flags == null) {
+    return O_RDONLY;
+  }
+
   switch (flags) {
     case 'r' : return O_RDONLY;
     case 'rs' : // Fall through.
@@ -569,10 +635,15 @@ const validateOffsetLengthWrite = hideStackFrames(
       throw new ERR_OUT_OF_RANGE('offset', `<= ${byteLength}`, offset);
     }
 
-    const max = byteLength > kMaxLength ? kMaxLength : byteLength;
-    if (length > max - offset) {
-      throw new ERR_OUT_OF_RANGE('length', `<= ${max - offset}`, length);
+    if (length > byteLength - offset) {
+      throw new ERR_OUT_OF_RANGE('length', `<= ${byteLength - offset}`, length);
     }
+
+    if (length < 0) {
+      throw new ERR_OUT_OF_RANGE('length', '>= 0', length);
+    }
+
+    validateInt32(length, 'length', 0);
   }
 );
 
@@ -618,31 +689,156 @@ function warnOnNonPortableTemplate(template) {
   }
 }
 
+const defaultRmOptions = {
+  recursive: false,
+  force: false,
+  retryDelay: 100,
+  maxRetries: 0
+};
+
 const defaultRmdirOptions = {
   retryDelay: 100,
   maxRetries: 0,
   recursive: false,
 };
 
-const validateRmdirOptions = hideStackFrames((options) => {
-  if (options === undefined)
-    return defaultRmdirOptions;
-  if (options === null || typeof options !== 'object')
-    throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
+const validateRmOptions = hideStackFrames((path, options, callback) => {
+  options = validateRmdirOptions(options, defaultRmOptions);
+  validateBoolean(options.force, 'options.force');
+
+  lazyLoadFs().stat(path, (err, stats) => {
+    if (err) {
+      if (options.force && err.code === 'ENOENT') {
+        return callback(null, options);
+      }
+      return callback(err, options);
+    }
+
+    if (stats.isDirectory() && !options.recursive) {
+      return callback(new ERR_FS_EISDIR({
+        code: 'EISDIR',
+        message: 'is a directory',
+        path,
+        syscall: 'rm',
+        errno: EISDIR
+      }));
+    }
+    return callback(null, options);
+  });
+});
 
-  options = { ...defaultRmdirOptions, ...options };
+const validateRmOptionsSync = hideStackFrames((path, options) => {
+  options = validateRmdirOptions(options, defaultRmOptions);
+  validateBoolean(options.force, 'options.force');
 
-  if (typeof options.recursive !== 'boolean')
-    throw new ERR_INVALID_ARG_TYPE('recursive', 'boolean', options.recursive);
+  try {
+    const stats = lazyLoadFs().statSync(path);
 
-  validateInt32(options.retryDelay, 'retryDelay', 0);
-  validateUint32(options.maxRetries, 'maxRetries');
+    if (stats.isDirectory() && !options.recursive) {
+      throw new ERR_FS_EISDIR({
+        code: 'EISDIR',
+        message: 'is a directory',
+        path,
+        syscall: 'rm',
+        errno: EISDIR
+      });
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      throw err;
+    } else if (err.code === 'ENOENT' && !options.force) {
+      throw err;
+    }
+  }
 
   return options;
 });
 
+const validateRmdirOptions = hideStackFrames(
+  (options, defaults = defaultRmdirOptions) => {
+    if (options === undefined)
+      return defaults;
+    if (options === null || typeof options !== 'object')
+      throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
+
+    options = { ...defaults, ...options };
+
+    validateBoolean(options.recursive, 'options.recursive');
+    validateInt32(options.retryDelay, 'options.retryDelay', 0);
+    validateUint32(options.maxRetries, 'options.maxRetries');
+
+    return options;
+  });
+
+const getValidMode = hideStackFrames((mode, type) => {
+  let min = kMinimumAccessMode;
+  let max = kMaximumAccessMode;
+  let def = F_OK;
+  if (type === 'copyFile') {
+    min = kMinimumCopyMode;
+    max = kMaximumCopyMode;
+    def = mode || kDefaultCopyMode;
+  } else {
+    assert(type === 'access');
+  }
+  if (mode == null) {
+    return def;
+  }
+  if (NumberIsInteger(mode) && mode >= min && mode <= max) {
+    return mode;
+  }
+  if (typeof mode !== 'number') {
+    throw new ERR_INVALID_ARG_TYPE('mode', 'integer', mode);
+  }
+  throw new ERR_OUT_OF_RANGE(
+    'mode', `an integer >= ${min} && <= ${max}`, mode);
+});
+
+const validateStringAfterArrayBufferView = hideStackFrames((buffer, name) => {
+  if (typeof buffer === 'string') {
+    return;
+  }
+
+  if (
+    typeof buffer === 'object' &&
+    buffer !== null &&
+    typeof buffer.toString === 'function' &&
+    ObjectPrototypeHasOwnProperty(buffer, 'toString')
+  ) {
+    return;
+  }
+
+  throw new ERR_INVALID_ARG_TYPE(
+    name,
+    ['string', 'Buffer', 'TypedArray', 'DataView'],
+    buffer
+  );
+});
+
+const validatePosition = hideStackFrames((position, name) => {
+  if (typeof position === 'number') {
+    validateInteger(position, 'position');
+  } else if (typeof position === 'bigint') {
+    if (!(position >= -(2n ** 63n) && position <= 2n ** 63n - 1n)) {
+      throw new ERR_OUT_OF_RANGE('position',
+                                 `>= ${-(2n ** 63n)} && <= ${2n ** 63n - 1n}`,
+                                 position);
+    }
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('position',
+                                   ['integer', 'bigint'],
+                                   position);
+  }
+});
 
 module.exports = {
+  constants: {
+    kIoMaxLength,
+    kMaxUserId,
+    kReadFileBufferLength,
+    kReadFileUnknownBufferLength,
+    kWriteFileMaxChunkSize,
+  },
   assertEncoding,
   BigIntStats,  // for testing
   copyObject,
@@ -651,6 +847,7 @@ module.exports = {
   getDirents,
   getOptions,
   getValidatedPath,
+  getValidMode,
   handleErrorFromBinding,
   nullCheck,
   preprocessSymlinkDestination,
@@ -664,6 +861,10 @@ module.exports = {
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
   validatePath,
+  validatePosition,
+  validateRmOptions,
+  validateRmOptionsSync,
   validateRmdirOptions,
+  validateStringAfterArrayBufferView,
   warnOnNonPortableTemplate
 };
diff --git a/lib/internal/fs/watchers.js b/lib/internal/fs/watchers.js
index 1ffe70323f3bf37781a0378edf3814d53eb8304b..40d35d815f7886b1d775f9dd713c49c27de23c6e 100644
--- a/lib/internal/fs/watchers.js
+++ b/lib/internal/fs/watchers.js
@@ -3,32 +3,59 @@
 const {
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
+  Promise,
   Symbol,
 } = primordials;
 
-const errors = require('internal/errors');
+const {
+  AbortError,
+  uvException,
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+  },
+} = require('internal/errors');
+
 const {
   kFsStatsFieldsNumber,
   StatWatcher: _StatWatcher
 } = internalBinding('fs');
+
 const { FSEvent } = internalBinding('fs_event_wrap');
 const { UV_ENOSPC } = internalBinding('uv');
 const { EventEmitter } = require('events');
+
 const {
   getStatsFromBinding,
   getValidatedPath
 } = require('internal/fs/utils');
+
 const {
   defaultTriggerAsyncIdScope,
   symbols: { owner_symbol }
 } = require('internal/async_hooks');
+
 const { toNamespacedPath } = require('path');
-const { validateUint32 } = require('internal/validators');
+
+const {
+  validateAbortSignal,
+  validateBoolean,
+  validateObject,
+  validateUint32,
+} = require('internal/validators');
+
+const {
+  Buffer: {
+    isEncoding,
+  },
+} = require('buffer');
+
 const assert = require('internal/assert');
 
 const kOldStatus = Symbol('kOldStatus');
 const kUseBigint = Symbol('kUseBigint');
 
+const kFSWatchStart = Symbol('kFSWatchStart');
+const kFSStatWatcherStart = Symbol('kFSStatWatcherStart');
 const KFSStatWatcherRefCount = Symbol('KFSStatWatcherRefCount');
 const KFSStatWatcherMaxRefCount = Symbol('KFSStatWatcherMaxRefCount');
 const kFSStatWatcherAddOrCleanRef = Symbol('kFSStatWatcherAddOrCleanRef');
@@ -62,13 +89,15 @@ function onchange(newStatus, stats) {
             getStatsFromBinding(stats, kFsStatsFieldsNumber));
 }
 
-// FIXME(joyeecheung): this method is not documented.
 // At the moment if filename is undefined, we
-// 1. Throw an Error if it's the first time .start() is called
-// 2. Return silently if .start() has already been called
+// 1. Throw an Error if it's the first
+//    time Symbol('kFSStatWatcherStart') is called
+// 2. Return silently if Symbol('kFSStatWatcherStart') has already been called
 //    on a valid filename and the wrap has been initialized
 // This method is a noop if the watcher has already been started.
-StatWatcher.prototype.start = function(filename, persistent, interval) {
+StatWatcher.prototype[kFSStatWatcherStart] = function(filename,
+                                                      persistent,
+                                                      interval) {
   if (this._handle !== null)
     return;
 
@@ -79,14 +108,14 @@ StatWatcher.prototype.start = function(filename, persistent, interval) {
     this.unref();
 
   // uv_fs_poll is a little more powerful than ev_stat but we curb it for
-  // the sake of backwards compatibility
+  // the sake of backwards compatibility.
   this[kOldStatus] = -1;
 
   filename = getValidatedPath(filename, 'filename');
   validateUint32(interval, 'interval');
   const err = this._handle.start(toNamespacedPath(filename), interval);
   if (err) {
-    const error = errors.uvException({
+    const error = uvException({
       errno: err,
       syscall: 'watch',
       path: filename
@@ -96,6 +125,12 @@ StatWatcher.prototype.start = function(filename, persistent, interval) {
   }
 };
 
+// To maximize backward-compatibility for the end user,
+// a no-op stub method has been added instead of
+// totally removing StatWatcher.prototype.start.
+// This should not be documented.
+StatWatcher.prototype.start = () => {};
+
 // FIXME(joyeecheung): this method is not documented while there is
 // another documented fs.unwatchFile(). The counterpart in
 // FSWatcher is .close()
@@ -163,9 +198,9 @@ function FSWatcher() {
       if (this._handle !== null) {
         // We don't use this.close() here to avoid firing the close event.
         this._handle.close();
-        this._handle = null;  // Make the handle garbage collectable
+        this._handle = null;  // Make the handle garbage collectable.
       }
-      const error = errors.uvException({
+      const error = uvException({
         errno: status,
         syscall: 'watch',
         path: filename
@@ -180,18 +215,16 @@ function FSWatcher() {
 ObjectSetPrototypeOf(FSWatcher.prototype, EventEmitter.prototype);
 ObjectSetPrototypeOf(FSWatcher, EventEmitter);
 
-
-// FIXME(joyeecheung): this method is not documented.
 // At the moment if filename is undefined, we
-// 1. Throw an Error if it's the first time .start() is called
-// 2. Return silently if .start() has already been called
+// 1. Throw an Error if it's the first time Symbol('kFSWatchStart') is called
+// 2. Return silently if Symbol('kFSWatchStart') has already been called
 //    on a valid filename and the wrap has been initialized
 // 3. Return silently if the watcher has already been closed
 // This method is a noop if the watcher has already been started.
-FSWatcher.prototype.start = function(filename,
-                                     persistent,
-                                     recursive,
-                                     encoding) {
+FSWatcher.prototype[kFSWatchStart] = function(filename,
+                                              persistent,
+                                              recursive,
+                                              encoding) {
   if (this._handle === null) {  // closed
     return;
   }
@@ -207,7 +240,7 @@ FSWatcher.prototype.start = function(filename,
                                  recursive,
                                  encoding);
   if (err) {
-    const error = errors.uvException({
+    const error = uvException({
       errno: err,
       syscall: 'watch',
       path: filename,
@@ -219,6 +252,12 @@ FSWatcher.prototype.start = function(filename,
   }
 };
 
+// To maximize backward-compatibility for the end user,
+// a no-op stub method has been added instead of
+// totally removing FSWatcher.prototype.start.
+// This should not be documented.
+FSWatcher.prototype.start = () => {};
+
 // This method is a noop if the watcher has not been started or
 // has already been closed.
 FSWatcher.prototype.close = function() {
@@ -230,7 +269,7 @@ FSWatcher.prototype.close = function() {
     return;
   }
   this._handle.close();
-  this._handle = null;  // Make the handle garbage collectable
+  this._handle = null;  // Make the handle garbage collectable.
   process.nextTick(emitCloseNT, this);
 };
 
@@ -255,8 +294,94 @@ ObjectDefineProperty(FSEvent.prototype, 'owner', {
   set(v) { return this[owner_symbol] = v; }
 });
 
+async function* watch(filename, options = {}) {
+  const path = toNamespacedPath(getValidatedPath(filename));
+  validateObject(options, 'options');
+
+  const {
+    persistent = true,
+    recursive = false,
+    encoding = 'utf8',
+    signal,
+  } = options;
+
+  validateBoolean(persistent, 'options.persistent');
+  validateBoolean(recursive, 'options.recursive');
+  validateAbortSignal(signal, 'options.signal');
+
+  if (encoding && !isEncoding(encoding)) {
+    const reason = 'is invalid encoding';
+    throw new ERR_INVALID_ARG_VALUE(encoding, 'encoding', reason);
+  }
+
+  if (signal?.aborted)
+    throw new AbortError();
+
+  const handle = new FSEvent();
+  let res;
+  let rej;
+  const oncancel = () => {
+    handle.close();
+    rej(new AbortError());
+  };
+
+  try {
+    signal?.addEventListener('abort', oncancel, { once: true });
+
+    let promise = new Promise((resolve, reject) => {
+      res = resolve;
+      rej = reject;
+    });
+
+    handle.onchange = (status, eventType, filename) => {
+      if (status < 0) {
+        const error = uvException({
+          errno: status,
+          syscall: 'watch',
+          path: filename
+        });
+        error.filename = filename;
+        handle.close();
+        rej(error);
+        return;
+      }
+
+      res({ eventType, filename });
+    };
+
+    const err = handle.start(path, persistent, recursive, encoding);
+    if (err) {
+      const error = uvException({
+        errno: err,
+        syscall: 'watch',
+        path: filename,
+        message: err === UV_ENOSPC ?
+          'System limit for number of file watchers reached' : ''
+      });
+      error.filename = filename;
+      handle.close();
+      throw error;
+    }
+
+    while (!signal?.aborted) {
+      yield await promise;
+      promise = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+    }
+    throw new AbortError();
+  } finally {
+    handle.close();
+    signal?.removeEventListener('abort', oncancel);
+  }
+}
+
 module.exports = {
   FSWatcher,
   StatWatcher,
+  kFSWatchStart,
+  kFSStatWatcherStart,
   kFSStatWatcherAddOrCleanRef,
+  watch,
 };
diff --git a/lib/internal/histogram.js b/lib/internal/histogram.js
index 6deb8314a41bbb5203019094580dbca605b5042d..4a8e51f958f3bb6ddfb17e095eec3cc8ef71a720 100644
--- a/lib/internal/histogram.js
+++ b/lib/internal/histogram.js
@@ -1,94 +1,196 @@
 'use strict';
 
+const {
+  NumberIsNaN,
+  NumberIsInteger,
+  NumberMAX_SAFE_INTEGER,
+  ObjectSetPrototypeOf,
+  SafeMap,
+  Symbol,
+  TypeError,
+} = primordials;
+
+const {
+  Histogram: _Histogram
+} = internalBinding('performance');
+
 const {
   customInspectSymbol: kInspect,
 } = require('internal/util');
 
-const { format } = require('util');
-const { Map, Symbol } = primordials;
+const { inspect } = require('util');
 
 const {
-  ERR_INVALID_ARG_TYPE,
-  ERR_INVALID_ARG_VALUE,
-} = require('internal/errors').codes;
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_ARG_TYPE,
+    ERR_OUT_OF_RANGE,
+  },
+} = require('internal/errors');
 
 const kDestroy = Symbol('kDestroy');
 const kHandle = Symbol('kHandle');
+const kMap = Symbol('kMap');
 
-// Histograms are created internally by Node.js and used to
-// record various metrics. This Histogram class provides a
-// generally read-only view of the internal histogram.
-class Histogram {
-  #handle = undefined;
-  #map = new Map();
+const {
+  kClone,
+  kDeserialize,
+  JSTransferable,
+} = require('internal/worker/js_transferable');
 
+class Histogram extends JSTransferable {
   constructor(internal) {
-    this.#handle = internal;
+    super();
+    this[kHandle] = internal;
+    this[kMap] = new SafeMap();
   }
 
-  [kInspect]() {
-    const obj = {
+  [kInspect](depth, options) {
+    if (depth < 0)
+      return this;
+
+    const opts = {
+      ...options,
+      depth: options.depth == null ? null : options.depth - 1
+    };
+
+    return `Histogram ${inspect({
       min: this.min,
       max: this.max,
       mean: this.mean,
       exceeds: this.exceeds,
       stddev: this.stddev,
       percentiles: this.percentiles,
-    };
-    return `Histogram ${format(obj)}`;
+    }, opts)}`;
   }
 
   get min() {
-    return this.#handle ? this.#handle.min() : undefined;
+    return this[kHandle]?.min();
   }
 
   get max() {
-    return this.#handle ? this.#handle.max() : undefined;
+    return this[kHandle]?.max();
   }
 
   get mean() {
-    return this.#handle ? this.#handle.mean() : undefined;
+    return this[kHandle]?.mean();
   }
 
   get exceeds() {
-    return this.#handle ? this.#handle.exceeds() : undefined;
+    return this[kHandle]?.exceeds();
   }
 
   get stddev() {
-    return this.#handle ? this.#handle.stddev() : undefined;
+    return this[kHandle]?.stddev();
   }
 
   percentile(percentile) {
     if (typeof percentile !== 'number')
       throw new ERR_INVALID_ARG_TYPE('percentile', 'number', percentile);
 
-    if (percentile <= 0 || percentile > 100)
+    if (NumberIsNaN(percentile) || percentile <= 0 || percentile > 100)
       throw new ERR_INVALID_ARG_VALUE.RangeError('percentile', percentile);
 
-    return this.#handle ? this.#handle.percentile(percentile) : undefined;
+    return this[kHandle]?.percentile(percentile);
   }
 
   get percentiles() {
-    this.#map.clear();
-    if (this.#handle)
-      this.#handle.percentiles(this.#map);
-    return this.#map;
+    this[kMap].clear();
+    this[kHandle]?.percentiles(this[kMap]);
+    return this[kMap];
   }
 
   reset() {
-    if (this.#handle)
-      this.#handle.reset();
+    this[kHandle]?.reset();
   }
 
   [kDestroy]() {
-    this.#handle = undefined;
+    this[kHandle] = undefined;
+  }
+
+  [kClone]() {
+    const handle = this[kHandle];
+    return {
+      data: { handle },
+      deserializeInfo: 'internal/histogram:InternalHistogram'
+    };
+  }
+
+  [kDeserialize]({ handle }) {
+    this[kHandle] = handle;
+  }
+}
+
+class RecordableHistogram extends Histogram {
+  constructor() {
+    // eslint-disable-next-line no-restricted-syntax
+    throw new TypeError('illegal constructor');
+  }
+
+  record(val) {
+    if (typeof val === 'bigint') {
+      this[kHandle]?.record(val);
+      return;
+    }
+
+    if (!NumberIsInteger(val))
+      throw new ERR_INVALID_ARG_TYPE('val', ['integer', 'bigint'], val);
+
+    if (val < 1 || val > NumberMAX_SAFE_INTEGER)
+      throw new ERR_OUT_OF_RANGE('val', 'a safe integer greater than 0', val);
+
+    this[kHandle]?.record(val);
+  }
+
+  recordDelta() {
+    this[kHandle]?.recordDelta();
+  }
+
+  [kClone]() {
+    const handle = this[kHandle];
+    return {
+      data: { handle },
+      deserializeInfo: 'internal/histogram:InternalRecordableHistogram'
+    };
   }
+}
+
+class InternalHistogram extends JSTransferable {
+  constructor(handle) {
+    super();
+    this[kHandle] = handle;
+    this[kMap] = new SafeMap();
+  }
+}
+
+class InternalRecordableHistogram extends JSTransferable {
+  constructor(handle) {
+    super();
+    this[kHandle] = handle;
+    this[kMap] = new SafeMap();
+  }
+}
+
+InternalHistogram.prototype.constructor = Histogram;
+ObjectSetPrototypeOf(
+  InternalHistogram.prototype,
+  Histogram.prototype);
+
+InternalRecordableHistogram.prototype.constructor = RecordableHistogram;
+ObjectSetPrototypeOf(
+  InternalRecordableHistogram.prototype,
+  RecordableHistogram.prototype);
 
-  get [kHandle]() { return this.#handle; }
+function createHistogram() {
+  return new InternalRecordableHistogram(new _Histogram());
 }
 
 module.exports = {
   Histogram,
+  RecordableHistogram,
+  InternalHistogram,
+  InternalRecordableHistogram,
   kDestroy,
   kHandle,
+  createHistogram,
 };
diff --git a/lib/internal/http.js b/lib/internal/http.js
index aab4170a2f0e063e763e9811c8d821ac8f71ab22..e2f083be6ebc06818520220c95add96b8ee209ae 100644
--- a/lib/internal/http.js
+++ b/lib/internal/http.js
@@ -2,19 +2,14 @@
 
 const {
   Symbol,
+  Date,
 } = primordials;
 
 const { setUnrefTimeout } = require('internal/timers');
 const { PerformanceEntry, notify } = internalBinding('performance');
 
-let nowCache;
 let utcCache;
 
-function nowDate() {
-  if (!nowCache) cache();
-  return nowCache;
-}
-
 function utcDate() {
   if (!utcCache) cache();
   return utcCache;
@@ -22,13 +17,11 @@ function utcDate() {
 
 function cache() {
   const d = new Date();
-  nowCache = d.valueOf();
   utcCache = d.toUTCString();
   setUnrefTimeout(resetCache, 1000 - d.getMilliseconds());
 }
 
 function resetCache() {
-  nowCache = undefined;
   utcCache = undefined;
 }
 
@@ -51,7 +44,6 @@ function emitStatistics(statistics) {
 module.exports = {
   kOutHeaders: Symbol('kOutHeaders'),
   kNeedDrain: Symbol('kNeedDrain'),
-  nowDate,
   utcDate,
   emitStatistics
 };
diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index 2bff3ff62868e6af3bc6859e259232fea2158517..407b0ee30b79b83becd661b91fc3a75b4b89e9e9 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -7,6 +7,7 @@ const {
   ObjectCreate,
   ObjectKeys,
   ObjectPrototypeHasOwnProperty,
+  Proxy,
   ReflectGetPrototypeOf,
   Symbol,
 } = primordials;
@@ -181,6 +182,11 @@ function resumeStream(stream) {
 }
 
 const proxySocketHandler = {
+  has(stream, prop) {
+    const ref = stream.session !== undefined ? stream.session[kSocket] : stream;
+    return (prop in stream) || (prop in ref);
+  },
+
   get(stream, prop) {
     switch (prop) {
       case 'on':
@@ -282,7 +288,7 @@ function onStreamTimeout(kind) {
 
 class Http2ServerRequest extends Readable {
   constructor(stream, headers, options, rawHeaders) {
-    super(options);
+    super({ autoDestroy: false, ...options });
     this[kState] = {
       closed: false,
       didRead: false,
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index 1c6767c4dcaeba54acfcd0898a224f126c4512f9..4f1a3f8b577c83792d084f9e8bef893cb868054e 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -12,7 +12,11 @@ const {
   ObjectDefineProperty,
   ObjectPrototypeHasOwnProperty,
   Promise,
+  Proxy,
+  ReflectApply,
+  ReflectGet,
   ReflectGetPrototypeOf,
+  ReflectSet,
   Set,
   Symbol,
   Uint32Array,
@@ -31,6 +35,7 @@ const assert = require('assert');
 const EventEmitter = require('events');
 const fs = require('fs');
 const http = require('http');
+const { readUInt16BE, readUInt32BE } = require('internal/buffer');
 const net = require('net');
 const { Duplex } = require('stream');
 const tls = require('tls');
@@ -66,6 +71,7 @@ const {
     ERR_HTTP2_INVALID_STREAM,
     ERR_HTTP2_MAX_PENDING_SETTINGS_ACK,
     ERR_HTTP2_NESTED_PUSH,
+    ERR_HTTP2_NO_MEM,
     ERR_HTTP2_NO_SOCKET_MANIPULATION,
     ERR_HTTP2_ORIGIN_LENGTH,
     ERR_HTTP2_OUT_OF_STREAMS,
@@ -94,18 +100,23 @@ const {
     ERR_OUT_OF_RANGE,
     ERR_SOCKET_CLOSED
   },
-  hideStackFrames
+  hideStackFrames,
+  AbortError
 } = require('internal/errors');
-const { validateNumber,
-        validateString,
-        validateUint32,
-        isUint32,
+const {
+  isUint32,
+  validateInt32,
+  validateNumber,
+  validateString,
+  validateUint32,
+  validateAbortSignal,
 } = require('internal/validators');
 const fsPromisesInternal = require('internal/fs/promises');
 const { utcDate } = require('internal/http');
-const { onServerStream,
-        Http2ServerRequest,
-        Http2ServerResponse,
+const {
+  Http2ServerRequest,
+  Http2ServerResponse,
+  onServerStream,
 } = require('internal/http2/compat');
 
 const {
@@ -118,6 +129,7 @@ const {
   getSettings,
   getStreamState,
   isPayloadMeaningless,
+  kSensitiveHeaders,
   kSocket,
   kRequest,
   kProxySocket,
@@ -157,7 +169,6 @@ const { _connectionListener: httpConnectionListener } = http;
 let debug = require('internal/util/debuglog').debuglog('http2', (fn) => {
   debug = fn;
 });
-const { getOptionValue } = require('internal/options');
 
 // TODO(addaleax): See if this can be made more efficient by figuring out
 // whether debugging is enabled before we perform any further steps. Currently,
@@ -168,7 +179,9 @@ function debugStream(id, sessionType, message, ...args) {
 }
 
 function debugStreamObj(stream, message, ...args) {
-  debugStream(stream[kID], stream[kSession][kType], message, ...args);
+  const session = stream[kSession];
+  const type = session ? session[kType] : undefined;
+  debugStream(stream[kID], type, message, ...args);
 }
 
 function debugSession(sessionType, message, ...args) {
@@ -215,14 +228,7 @@ const kState = Symbol('state');
 const kType = Symbol('type');
 const kWriteGeneric = Symbol('write-generic');
 
-const kDefaultHttpServerTimeout =
-  getOptionValue('--http-server-default-timeout');
-
 const {
-  paddingBuffer,
-  PADDING_BUF_FRAME_LENGTH,
-  PADDING_BUF_MAX_PAYLOAD_LENGTH,
-  PADDING_BUF_RETURN_VALUE,
   kBitfield,
   kSessionPriorityListenerCount,
   kSessionFrameErrorListenerCount,
@@ -249,6 +255,7 @@ const {
   NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE,
   NGHTTP2_ERR_INVALID_ARGUMENT,
   NGHTTP2_ERR_STREAM_CLOSED,
+  NGHTTP2_ERR_NOMEM,
 
   HTTP2_HEADER_AUTHORITY,
   HTTP2_HEADER_DATE,
@@ -306,7 +313,7 @@ function emit(self, ...args) {
 // create the associated Http2Stream instance and emit the 'stream'
 // event. If the stream is not new, emit the 'headers' event to pass
 // the block of headers on.
-function onSessionHeaders(handle, id, cat, flags, headers) {
+function onSessionHeaders(handle, id, cat, flags, headers, sensitiveHeaders) {
   const session = this[kOwner];
   if (session.destroyed)
     return;
@@ -320,7 +327,7 @@ function onSessionHeaders(handle, id, cat, flags, headers) {
   let stream = streams.get(id);
 
   // Convert the array of header name value pairs into an object
-  const obj = toHeaderObject(headers);
+  const obj = toHeaderObject(headers, sensitiveHeaders);
 
   if (stream === undefined) {
     if (session.closed) {
@@ -653,20 +660,6 @@ function onGoawayData(code, lastStreamID, buf) {
   }
 }
 
-// Returns the padding to use per frame. The selectPadding callback is set
-// on the options. It is invoked with two arguments, the frameLen, and the
-// maxPayloadLen. The method must return a numeric value within the range
-// frameLen <= n <= maxPayloadLen.
-function onSelectPadding() {
-  const session = this[kOwner];
-  if (session.destroyed)
-    return;
-  const fn = session[kSelectPadding];
-  const frameLen = paddingBuffer[PADDING_BUF_FRAME_LENGTH];
-  const maxFramePayloadLen = paddingBuffer[PADDING_BUF_MAX_PAYLOAD_LENGTH];
-  paddingBuffer[PADDING_BUF_RETURN_VALUE] = fn(frameLen, maxFramePayloadLen);
-}
-
 // When a ClientHttp2Session is first created, the socket may not yet be
 // connected. If request() is called during this time, the actual request
 // will be deferred until the socket is ready to go.
@@ -947,6 +940,36 @@ const validateSettings = hideStackFrames((settings) => {
   }
 });
 
+// Wrap a typed array in a proxy, and allow selectively copying the entries
+// that have explicitly been set to another typed array.
+function trackAssignmentsTypedArray(typedArray) {
+  const typedArrayLength = typedArray.length;
+  const modifiedEntries = new Uint8Array(typedArrayLength);
+
+  function copyAssigned(target) {
+    for (let i = 0; i < typedArrayLength; i++) {
+      if (modifiedEntries[i]) {
+        target[i] = typedArray[i];
+      }
+    }
+  }
+
+  return new Proxy(typedArray, {
+    get(obj, prop, receiver) {
+      if (prop === 'copyAssigned') {
+        return copyAssigned;
+      }
+      return ReflectGet(obj, prop, receiver);
+    },
+    set(obj, prop, value) {
+      if (`${+prop}` === prop) {
+        modifiedEntries[prop] = 1;
+      }
+      return ReflectSet(obj, prop, value);
+    }
+  });
+}
+
 // Creates the internal binding.Http2Session handle for an Http2Session
 // instance. This occurs only after the socket connection has been
 // established. Note: the binding.Http2Session will take over ownership
@@ -977,10 +1000,13 @@ function setupHandle(socket, type, options) {
   handle.consume(socket._handle);
 
   this[kHandle] = handle;
-  if (this[kNativeFields])
-    handle.fields.set(this[kNativeFields]);
-  else
-    this[kNativeFields] = handle.fields;
+  if (this[kNativeFields]) {
+    // If some options have already been set before the handle existed, copy
+    // those (and only those) that have manually been set over.
+    this[kNativeFields].copyAssigned(handle.fields);
+  }
+
+  this[kNativeFields] = handle.fields;
 
   if (socket.encrypted) {
     this[kAlpnProtocol] = socket.alpnProtocol;
@@ -1032,7 +1058,8 @@ function cleanupSession(session) {
   session[kProxySocket] = undefined;
   session[kSocket] = undefined;
   session[kHandle] = undefined;
-  session[kNativeFields] = new Uint8Array(kSessionUint8FieldCount);
+  session[kNativeFields] = trackAssignmentsTypedArray(
+    new Uint8Array(kSessionUint8FieldCount));
   if (handle)
     handle.ondone = null;
   if (socket) {
@@ -1050,7 +1077,7 @@ function finishSessionClose(session, error) {
   if (socket && !socket.destroyed) {
     // Always wait for writable side to finish.
     socket.end((err) => {
-      debugSessionObj(session, 'finishSessionClose socket end', err);
+      debugSessionObj(session, 'finishSessionClose socket end', err, error);
       // Due to the way the underlying stream is handled in Http2Session we
       // won't get graceful Readable end from the other side even if it was sent
       // as the stream is already considered closed and will neither be read
@@ -1068,7 +1095,7 @@ function finishSessionClose(session, error) {
 }
 
 function closeSession(session, code, error) {
-  debugSessionObj(session, 'start closing/destroying');
+  debugSessionObj(session, 'start closing/destroying', error);
 
   const state = session[kState];
   state.flags |= SESSION_FLAGS_DESTROYED;
@@ -1140,6 +1167,8 @@ class Http2Session extends EventEmitter {
     if (!socket._handle || !socket._handle.isStreamBase) {
       socket = new JSStreamSocket(socket);
     }
+    socket.on('error', socketOnError);
+    socket.on('close', socketOnClose);
 
     // No validation is performed on the input parameters because this
     // constructor is not exported directly for users.
@@ -1196,8 +1225,10 @@ class Http2Session extends EventEmitter {
       setupFn();
     }
 
-    if (!this[kNativeFields])
-      this[kNativeFields] = new Uint8Array(kSessionUint8FieldCount);
+    if (!this[kNativeFields]) {
+      this[kNativeFields] = trackAssignmentsTypedArray(
+        new Uint8Array(kSessionUint8FieldCount));
+    }
     this.on('newListener', sessionListenerAdded);
     this.on('removeListener', sessionListenerRemoved);
 
@@ -1263,8 +1294,23 @@ class Http2Session extends EventEmitter {
     this[kHandle].setNextStreamID(id);
   }
 
+  // Sets the local window size (local endpoints's window size)
+  // Returns 0 if sucess or throw an exception if NGHTTP2_ERR_NOMEM
+  // if the window allocation fails
+  setLocalWindowSize(windowSize) {
+    if (this.destroyed)
+      throw new ERR_HTTP2_INVALID_SESSION();
+
+    validateInt32(windowSize, 'windowSize', 0);
+    const ret = this[kHandle].setLocalWindowSize(windowSize);
+
+    if (ret === NGHTTP2_ERR_NOMEM) {
+      this.destroy(new ERR_HTTP2_NO_MEM());
+    }
+  }
+
   // If ping is called while we are still connecting, or after close() has
-  // been called, the ping callback will be invoked immediately will a ping
+  // been called, the ping callback will be invoked immediately with a ping
   // cancelled error and a duration of 0.0.
   ping(payload, callback) {
     if (this.destroyed)
@@ -1394,7 +1440,7 @@ class Http2Session extends EventEmitter {
     settingsFn();
   }
 
-  // Sumits a GOAWAY frame to be sent to the remote peer. Note that this
+  // Submits a GOAWAY frame to be sent to the remote peer. Note that this
   // is only a notification, and does not affect the usable state of the
   // session with the notable exception that new incoming streams will
   // be rejected automatically.
@@ -1684,6 +1730,20 @@ class ClientHttp2Session extends Http2Session {
     if (options.waitForTrailers)
       stream[kState].flags |= STREAM_FLAGS_HAS_TRAILERS;
 
+    const { signal } = options;
+    if (signal) {
+      validateAbortSignal(signal, 'options.signal');
+      const aborter = () => stream.destroy(new AbortError());
+      if (signal.aborted) {
+        aborter();
+      } else {
+        signal.addEventListener('abort', aborter);
+        stream.once('close', () => {
+          signal.removeEventListener('abort', aborter);
+        });
+      }
+    }
+
     const onConnect = requestOnConnect.bind(stream, headersList, options);
     if (this.connecting) {
       if (this[kPendingRequestCalls] !== null) {
@@ -1732,7 +1792,7 @@ function shutdownWritable(callback) {
   if (!handle) return callback();
   const state = this[kState];
   if (state.shutdownWritableCalled) {
-    // Backport v12.x: Session required for debugging stream object
+    // Backport v14.x: Session required for debugging stream object
     // debugStreamObj(this, 'shutdownWritable() already called');
     return callback();
   }
@@ -1821,6 +1881,7 @@ class Http2Stream extends Duplex {
   constructor(session, options) {
     options.allowHalfOpen = true;
     options.decodeStrings = false;
+    options.autoDestroy = false;
     super(options);
     this[async_id_symbol] = -1;
 
@@ -2036,12 +2097,10 @@ class Http2Stream extends Duplex {
     process.nextTick(() => {
       if (writeCallbackErr ||
         !this._writableState.ending ||
-        // Backport v12.x: _writableState.buffered does not exist
-        // this._writableState.buffered.length ||
-        this._writableState.bufferedRequest ||
+        this._writableState.buffered.length ||
         (this[kState].flags & STREAM_FLAGS_HAS_TRAILERS))
         return endCheckCallback();
-      // Backport v12.x: Session required for debugging stream object
+      // Backport v14.x: Session required for debugging stream object
       // debugStreamObj(this, 'shutting down writable on last write');
       shutdownWritable.call(this, endCheckCallback);
     });
@@ -2067,7 +2126,7 @@ class Http2Stream extends Duplex {
       this.once('ready', () => this._final(cb));
       return;
     }
-    // Backport v12.x: Session required for debugging stream object
+    // Backport v14.x: Session required for debugging stream object
     // debugStreamObj(this, 'shutting down writable on _final');
     shutdownWritable.call(this, cb);
   }
@@ -2293,6 +2352,7 @@ function processHeaders(oldHeaders, options) {
         headers[key] = oldHeaders[key];
       }
     }
+    headers[kSensitiveHeaders] = oldHeaders[kSensitiveHeaders];
   }
 
   const statusCode =
@@ -2315,6 +2375,10 @@ function processHeaders(oldHeaders, options) {
   if (statusCode < 200 || statusCode > 599)
     throw new ERR_HTTP2_STATUS_INVALID(headers[HTTP2_HEADER_STATUS]);
 
+  const neverIndex = headers[kSensitiveHeaders];
+  if (neverIndex !== undefined && !ArrayIsArray(neverIndex))
+    throw new ERR_INVALID_OPT_VALUE('headers[http2.neverIndex]', neverIndex);
+
   return headers;
 }
 
@@ -2924,9 +2988,6 @@ function connectionListener(socket) {
     return;
   }
 
-  socket.on('error', socketOnError);
-  socket.on('close', socketOnClose);
-
   // Set up the Session
   const session = new ServerHttp2Session(options, socket, this);
 
@@ -3000,7 +3061,7 @@ class Http2SecureServer extends TLSServer {
     options = initializeTLSOptions(options);
     super(options, connectionListener);
     this[kOptions] = options;
-    this.timeout = kDefaultHttpServerTimeout;
+    this.timeout = 0;
     this.on('newListener', setupCompat);
     if (typeof requestListener === 'function')
       this.on('request', requestListener);
@@ -3016,6 +3077,12 @@ class Http2SecureServer extends TLSServer {
     }
     return this;
   }
+
+  updateSettings(settings) {
+    assertIsObject(settings, 'settings');
+    validateSettings(settings);
+    this[kOptions].settings = { ...this[kOptions].settings, ...settings };
+  }
 }
 
 class Http2Server extends NETServer {
@@ -3023,7 +3090,7 @@ class Http2Server extends NETServer {
     options = initializeOptions(options);
     super(options, connectionListener);
     this[kOptions] = options;
-    this.timeout = kDefaultHttpServerTimeout;
+    this.timeout = 0;
     this.on('newListener', setupCompat);
     if (typeof requestListener === 'function')
       this.on('request', requestListener);
@@ -3038,6 +3105,12 @@ class Http2Server extends NETServer {
     }
     return this;
   }
+
+  updateSettings(settings) {
+    assertIsObject(settings, 'settings');
+    validateSettings(settings);
+    this[kOptions].settings = { ...this[kOptions].settings, ...settings };
+  }
 }
 
 Http2Server.prototype[EventEmitter.captureRejectionSymbol] = function(
@@ -3142,9 +3215,6 @@ function connect(authority, options, listener) {
     }
   }
 
-  socket.on('error', socketOnError);
-  socket.on('close', socketOnClose);
-
   const session = new ClientHttp2Session(options, socket);
 
   session[kAuthority] = `${options.servername || host}:${port}`;
@@ -3152,6 +3222,22 @@ function connect(authority, options, listener) {
 
   if (typeof listener === 'function')
     session.once('connect', listener);
+
+  // Process data on the next tick - a remoteSettings handler may be attached.
+  // https://github.com/nodejs/node/issues/35981
+  process.nextTick(() => {
+    debug('Http2Session connect', options.createConnection);
+    // Socket already has some buffered data - emulate receiving it
+    // https://github.com/nodejs/node/issues/35475
+    if (socket && socket.readableLength) {
+      let buf;
+      while ((buf = socket.read()) !== null) {
+        debug(`Http2Session connect: ${buf.length} bytes already in buffer`);
+        session[kHandle].receive(buf);
+      }
+    }
+  });
+
   return session;
 }
 
@@ -3187,18 +3273,18 @@ function getPackedSettings(settings) {
 }
 
 function getUnpackedSettings(buf, options = {}) {
-  if (!isArrayBufferView(buf)) {
+  if (!isArrayBufferView(buf) || buf.length === undefined) {
     throw new ERR_INVALID_ARG_TYPE('buf',
-                                   ['Buffer', 'TypedArray', 'DataView'], buf);
+                                   ['Buffer', 'TypedArray'], buf);
   }
   if (buf.length % 6 !== 0)
     throw new ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH();
   const settings = {};
   let offset = 0;
   while (offset < buf.length) {
-    const id = buf.readUInt16BE(offset);
+    const id = ReflectApply(readUInt16BE, buf, [offset]);
     offset += 2;
-    const value = buf.readUInt32BE(offset);
+    const value = ReflectApply(readUInt32BE, buf, [offset]);
     switch (id) {
       case NGHTTP2_SETTINGS_HEADER_TABLE_SIZE:
         settings.headerTableSize = value;
@@ -3240,7 +3326,6 @@ binding.setCallbackFunctions(
   onGoawayData,
   onAltSvc,
   onOrigin,
-  onSelectPadding,
   onStreamTrailers,
   onStreamClose
 );
@@ -3254,6 +3339,7 @@ module.exports = {
   getDefaultSettings,
   getPackedSettings,
   getUnpackedSettings,
+  sensitiveHeaders: kSensitiveHeaders,
   Http2Session,
   Http2Stream,
   Http2ServerRequest,
diff --git a/lib/internal/http2/util.js b/lib/internal/http2/util.js
index 8d47dbd53c0ca3dd29999a684d5244c117fead12..414ce3649a49fcb5d41d9a6b8695791da31e8acb 100644
--- a/lib/internal/http2/util.js
+++ b/lib/internal/http2/util.js
@@ -8,6 +8,9 @@ const {
   ObjectCreate,
   ObjectKeys,
   Set,
+  String,
+  StringFromCharCode,
+  StringPrototypeToLowerCase,
   Symbol,
 } = primordials;
 
@@ -24,11 +27,14 @@ const {
   hideStackFrames
 } = require('internal/errors');
 
+const kSensitiveHeaders = Symbol('nodejs.http2.sensitiveHeaders');
 const kSocket = Symbol('socket');
 const kProxySocket = Symbol('proxySocket');
 const kRequest = Symbol('request');
 
 const {
+  NGHTTP2_NV_FLAG_NONE,
+  NGHTTP2_NV_FLAG_NO_INDEX,
   NGHTTP2_SESSION_CLIENT,
   NGHTTP2_SESSION_SERVER,
 
@@ -97,7 +103,7 @@ const kValidPseudoHeaders = new Set([
   HTTP2_HEADER_AUTHORITY,
   HTTP2_HEADER_SCHEME,
   HTTP2_HEADER_PATH,
-  HTTP2_HEADER_PROTOCOL
+  HTTP2_HEADER_PROTOCOL,
 ]);
 
 // This set contains headers that are permitted to have only a single
@@ -141,7 +147,7 @@ const kSingleValueHeaders = new Set([
   HTTP2_HEADER_TK,
   HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS,
   HTTP2_HEADER_USER_AGENT,
-  HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS
+  HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS,
 ]);
 
 // The HTTP methods in this set are specifically defined as assigning no
@@ -151,7 +157,7 @@ const kSingleValueHeaders = new Set([
 const kNoPayloadMethods = new Set([
   HTTP2_METHOD_DELETE,
   HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD
+  HTTP2_METHOD_HEAD,
 ]);
 
 // The following ArrayBuffer instances are used to share memory more efficiently
@@ -453,6 +459,9 @@ const assertValidPseudoHeaderTrailer = hideStackFrames((key) => {
   throw new ERR_HTTP2_INVALID_PSEUDOHEADER(key);
 });
 
+const emptyArray = [];
+const kNeverIndexFlag = StringFromCharCode(NGHTTP2_NV_FLAG_NO_INDEX);
+const kNoHeaderFlags = StringFromCharCode(NGHTTP2_NV_FLAG_NONE);
 function mapToHeaders(map,
                       assertValuePseudoHeader = assertValidPseudoHeader) {
   let ret = '';
@@ -465,6 +474,8 @@ function mapToHeaders(map,
   let value;
   let isSingleValueHeader;
   let err;
+  const neverIndex =
+    (map[kSensitiveHeaders] || emptyArray).map(StringPrototypeToLowerCase);
   for (i = 0; i < keys.length; ++i) {
     key = keys[i];
     value = map[key];
@@ -493,11 +504,12 @@ function mapToHeaders(map,
         throw new ERR_HTTP2_HEADER_SINGLE_VALUE(key);
       singles.add(key);
     }
+    const flags = neverIndex.includes(key) ? kNeverIndexFlag : kNoHeaderFlags;
     if (key[0] === ':') {
       err = assertValuePseudoHeader(key);
       if (err !== undefined)
         throw err;
-      ret = `${key}\0${value}\0${ret}`;
+      ret = `${key}\0${value}\0${flags}${ret}`;
       count++;
       continue;
     }
@@ -507,12 +519,12 @@ function mapToHeaders(map,
     if (isArray) {
       for (j = 0; j < value.length; ++j) {
         const val = String(value[j]);
-        ret += `${key}\0${val}\0`;
+        ret += `${key}\0${val}\0${flags}`;
       }
       count += value.length;
       continue;
     }
-    ret += `${key}\0${value}\0`;
+    ret += `${key}\0${value}\0${flags}`;
     count++;
   }
 
@@ -551,7 +563,7 @@ const assertWithinRange = hideStackFrames(
   }
 );
 
-function toHeaderObject(headers) {
+function toHeaderObject(headers, sensitiveHeaders) {
   const obj = ObjectCreate(null);
   for (var n = 0; n < headers.length; n += 2) {
     const name = headers[n];
@@ -592,6 +604,7 @@ function toHeaderObject(headers) {
       }
     }
   }
+  obj[kSensitiveHeaders] = sensitiveHeaders;
   return obj;
 }
 
@@ -620,6 +633,7 @@ module.exports = {
   getSettings,
   getStreamState,
   isPayloadMeaningless,
+  kSensitiveHeaders,
   kSocket,
   kProxySocket,
   kRequest,
diff --git a/lib/internal/inspector_async_hook.js b/lib/internal/inspector_async_hook.js
index a6112697cfdaa26b81c2dca253a102d21f23ac4e..bd3aa635051c5bbebb22eab8ec377f455a467d19 100644
--- a/lib/internal/inspector_async_hook.js
+++ b/lib/internal/inspector_async_hook.js
@@ -4,7 +4,7 @@ let hook;
 let config;
 
 const {
-  Set,
+  SafeSet,
 } = primordials;
 
 function lazyHookCreation() {
@@ -44,7 +44,7 @@ function lazyHookCreation() {
     },
   });
 
-  hook.promiseIds = new Set();
+  hook.promiseIds = new SafeSet();
 }
 
 function enable() {
diff --git a/lib/internal/main/eval_string.js b/lib/internal/main/eval_string.js
index 124e4842308c551a65d438a3516aa4d837ae3787..ad068b935dfee0c019e32bf3f1af4a3215cacb77 100644
--- a/lib/internal/main/eval_string.js
+++ b/lib/internal/main/eval_string.js
@@ -3,6 +3,10 @@
 // User passed `-e` or `--eval` arguments to Node without `-i` or
 // `--interactive`.
 
+const {
+  globalThis,
+} = primordials;
+
 const {
   prepareMainThreadExecution
 } = require('internal/bootstrap/pre_execution');
@@ -12,7 +16,7 @@ const { addBuiltinLibsToObject } = require('internal/modules/cjs/helpers');
 const { getOptionValue } = require('internal/options');
 
 prepareMainThreadExecution();
-addBuiltinLibsToObject(global);
+addBuiltinLibsToObject(globalThis);
 markBootstrapComplete();
 
 const source = getOptionValue('--eval');
diff --git a/lib/internal/main/inspect.js b/lib/internal/main/inspect.js
index f6777fe852bcfc06027958bf05a8133b6961ac7c..38ebc9b83074db34d0b18629652ac06f35062c27 100644
--- a/lib/internal/main/inspect.js
+++ b/lib/internal/main/inspect.js
@@ -18,5 +18,5 @@ markBootstrapComplete();
 
 // Start the debugger agent.
 process.nextTick(() => {
-  require('internal/deps/node-inspect/lib/_inspect').start();
+  require('internal/debugger/inspect').start();
 });
diff --git a/lib/internal/main/print_help.js b/lib/internal/main/print_help.js
index 34a8e19f08ec31a014dfa908bb94678e12b9356a..6aa422c657b2d0f7811c923af497efe48e9fec49 100644
--- a/lib/internal/main/print_help.js
+++ b/lib/internal/main/print_help.js
@@ -1,6 +1,20 @@
 'use strict';
 
-/* eslint-disable no-restricted-globals */
+const {
+  ArrayPrototypeConcat,
+  ArrayPrototypeSort,
+  Boolean,
+  MathFloor,
+  MathMax,
+  ObjectKeys,
+  RegExp,
+  StringPrototypeLocaleCompare,
+  StringPrototypeSlice,
+  StringPrototypeTrimLeft,
+  StringPrototypeRepeat,
+  StringPrototypeReplace,
+  SafeMap,
+} = primordials;
 
 const { types } = internalBinding('options');
 const hasCrypto = Boolean(process.versions.openssl);
@@ -10,13 +24,16 @@ const {
 } = require('internal/bootstrap/pre_execution');
 
 const typeLookup = [];
-for (const key of Object.keys(types))
+for (const key of ObjectKeys(types))
   typeLookup[types[key]] = key;
 
 // Environment variables are parsed ad-hoc throughout the code base,
 // so we gather the documentation here.
 const { hasIntl, hasSmallICU, hasNodeOptions } = internalBinding('config');
-const envVars = new Map([
+const envVars = new SafeMap(ArrayPrototypeConcat([
+  ['FORCE_COLOR', { helpText: "when set to 'true', 1, 2, 3, or an empty " +
+   'string causes NO_COLOR and NODE_DISABLE_COLORS to be ignored.' }],
+  ['NO_COLOR', { helpText: 'Alias for NODE_DISABLE_COLORS' }],
   ['NODE_DEBUG', { helpText: "','-separated list of core modules that " +
     'should print debug information' }],
   ['NODE_DEBUG_NATIVE', { helpText: "','-separated list of C++ core debug " +
@@ -24,7 +41,7 @@ const envVars = new Map([
   ['NODE_DISABLE_COLORS', { helpText: 'set to 1 to disable colors in ' +
     'the REPL' }],
   ['NODE_EXTRA_CA_CERTS', { helpText: 'path to additional CA certificates ' +
-    'file' }],
+    'file. Only read once during process startup.' }],
   ['NODE_NO_WARNINGS', { helpText: 'set to 1 to silence process warnings' }],
   ['NODE_PATH', { helpText: `'${require('path').delimiter}'-separated list ` +
     'of directories prefixed to the module search path' }],
@@ -43,29 +60,31 @@ const envVars = new Map([
   ['NODE_V8_COVERAGE', { helpText: 'directory to output v8 coverage JSON ' +
     'to' }],
   ['UV_THREADPOOL_SIZE', { helpText: 'sets the number of threads used in ' +
-    'libuv\'s threadpool' }]
-].concat(hasIntl ? [
+    'libuv\'s threadpool' }],
+], hasIntl ? [
   ['NODE_ICU_DATA', { helpText: 'data path for ICU (Intl object) data' +
-    hasSmallICU ? '' : ' (will extend linked-in data)' }]
-] : []).concat(hasNodeOptions ? [
+    hasSmallICU ? '' : ' (will extend linked-in data)' }],
+] : []), (hasNodeOptions ? [
   ['NODE_OPTIONS', { helpText: 'set CLI options in the environment via a ' +
-    'space-separated list' }]
-] : []).concat(hasCrypto ? [
+    'space-separated list' }],
+] : []), hasCrypto ? [
   ['OPENSSL_CONF', { helpText: 'load OpenSSL configuration from file' }],
   ['SSL_CERT_DIR', { helpText: 'sets OpenSSL\'s directory of trusted ' +
     'certificates when used in conjunction with --use-openssl-ca' }],
   ['SSL_CERT_FILE', { helpText: 'sets OpenSSL\'s trusted certificate file ' +
     'when used in conjunction with --use-openssl-ca' }],
-] : []));
+] : []);
 
 
 function indent(text, depth) {
-  return text.replace(/^/gm, ' '.repeat(depth));
+  return StringPrototypeReplace(text, /^/gm, StringPrototypeRepeat(' ', depth));
 }
 
 function fold(text, width) {
-  return text.replace(new RegExp(`([^\n]{0,${width}})( |$)`, 'g'),
-                      (_, newLine, end) => newLine + (end === ' ' ? '\n' : ''));
+  return StringPrototypeReplace(text,
+                                new RegExp(`([^\n]{0,${width}})( |$)`, 'g'),
+                                (_, newLine, end) =>
+                                  newLine + (end === ' ' ? '\n' : ''));
 }
 
 function getArgDescription(type) {
@@ -87,21 +106,41 @@ function getArgDescription(type) {
   }
 }
 
-function format({ options, aliases = new Map(), firstColumn, secondColumn }) {
+function format(
+  { options, aliases = new SafeMap(), firstColumn, secondColumn }
+) {
   let text = '';
   let maxFirstColumnUsed = 0;
 
-  for (const [
-    name, { helpText, type, value }
-  ] of [...options.entries()].sort()) {
+  const sortedOptions = ArrayPrototypeSort(
+    [...options.entries()],
+    ({ 0: name1, 1: option1 }, { 0: name2, 1: option2 }) => {
+      if (option1.defaultIsTrue) {
+        name1 = `--no-${StringPrototypeSlice(name1, 2)}`;
+      }
+      if (option2.defaultIsTrue) {
+        name2 = `--no-${StringPrototypeSlice(name2, 2)}`;
+      }
+      return StringPrototypeLocaleCompare(name1, name2);
+    },
+  );
+
+  for (const {
+    0: name, 1: { helpText, type, value, defaultIsTrue }
+  } of sortedOptions) {
     if (!helpText) continue;
 
     let displayName = name;
+
+    if (defaultIsTrue) {
+      displayName = `--no-${StringPrototypeSlice(displayName, 2)}`;
+    }
+
     const argDescription = getArgDescription(type);
     if (argDescription)
       displayName += `=${argDescription}`;
 
-    for (const [ from, to ] of aliases) {
+    for (const { 0: from, 1: to } of aliases) {
       // For cases like e.g. `-e, --eval`.
       if (to[0] === name && to.length === 1) {
         displayName = `${from}, ${displayName}`;
@@ -119,7 +158,7 @@ function format({ options, aliases = new Map(), firstColumn, secondColumn }) {
     }
 
     let displayHelpText = helpText;
-    if (value === true) {
+    if (value === !defaultIsTrue) {
       // Mark boolean options we currently have enabled.
       // In particular, it indicates whether --use-openssl-ca
       // or --use-bundled-ca is the (current) default.
@@ -127,14 +166,14 @@ function format({ options, aliases = new Map(), firstColumn, secondColumn }) {
     }
 
     text += displayName;
-    maxFirstColumnUsed = Math.max(maxFirstColumnUsed, displayName.length);
+    maxFirstColumnUsed = MathMax(maxFirstColumnUsed, displayName.length);
     if (displayName.length >= firstColumn)
-      text += '\n' + ' '.repeat(firstColumn);
+      text += '\n' + StringPrototypeRepeat(' ', firstColumn);
     else
-      text += ' '.repeat(firstColumn - displayName.length);
+      text += StringPrototypeRepeat(' ', firstColumn - displayName.length);
 
-    text += indent(fold(displayHelpText, secondColumn),
-                   firstColumn).trimLeft() + '\n';
+    text += StringPrototypeTrimLeft(
+      indent(fold(displayHelpText, secondColumn), firstColumn)) + '\n';
   }
 
   if (maxFirstColumnUsed < firstColumn - 4) {
@@ -154,9 +193,9 @@ function print(stream) {
   const { options, aliases } = require('internal/options');
 
   // Use 75 % of the available width, and at least 70 characters.
-  const width = Math.max(70, (stream.columns || 0) * 0.75);
-  const firstColumn = Math.floor(width * 0.4);
-  const secondColumn = Math.floor(width * 0.57);
+  const width = MathMax(70, (stream.columns || 0) * 0.75);
+  const firstColumn = MathFloor(width * 0.4);
+  const secondColumn = MathFloor(width * 0.57);
 
   options.set('-', { helpText: 'script read from stdin ' +
                                '(default if no file name is provided, ' +
diff --git a/lib/internal/main/repl.js b/lib/internal/main/repl.js
index d5ee9b0a7d3643d877b66a658c077bacf631807a..a8356687ccedf53d8dba1b1456ea68611ccd8e2e 100644
--- a/lib/internal/main/repl.js
+++ b/lib/internal/main/repl.js
@@ -61,5 +61,5 @@ if (process.env.NODE_REPL_EXTERNAL_MODULE) {
                  getOptionValue('--inspect-brk'),
                  getOptionValue('--print'));
     }
-  }, false);
+  });
 }
diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index bc542d74b312b9143fd031e7f8168bc8387c81b1..955d8ec301065c22a2e98834a2caec995854c58c 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -4,7 +4,12 @@
 // message port.
 
 const {
+  ArrayPrototypeConcat,
+  ArrayPrototypeForEach,
+  ArrayPrototypeSplice,
   ObjectDefineProperty,
+  PromisePrototypeCatch,
+  globalThis: { Atomics },
 } = primordials;
 
 const {
@@ -13,12 +18,14 @@ const {
   setupInspectorHooks,
   setupWarningHandler,
   setupDebugEnv,
+  initializeAbortController,
   initializeDeprecations,
   initializeWASI,
   initializeCJSLoader,
   initializeESMLoader,
   initializeFrozenIntrinsics,
   initializeReport,
+  initializeSourceMapsHandlers,
   loadPreloadModules,
   setupTraceCategoryState
 } = require('internal/bootstrap/pre_execution');
@@ -60,6 +67,7 @@ setupInspectorHooks();
 setupDebugEnv();
 
 setupWarningHandler();
+initializeSourceMapsHandlers();
 
 // Since worker threads cannot switch cwd, we do not need to
 // overwrite the process.env.NODE_V8_COVERAGE variable.
@@ -101,6 +109,7 @@ port.on('message', (message) => {
       filename,
       doEval,
       workerData,
+      environmentData,
       publicPort,
       manifestSrc,
       manifestURL,
@@ -112,39 +121,48 @@ port.on('message', (message) => {
     if (manifestSrc) {
       require('internal/process/policy').setup(manifestSrc, manifestURL);
     }
+    initializeAbortController();
     initializeDeprecations();
     initializeWASI();
     initializeCJSLoader();
     initializeESMLoader();
 
-    const CJSLoader = require('internal/modules/cjs/loader');
-    assert(!CJSLoader.hasLoadedAnyUserCJSModule);
-    loadPreloadModules();
-    initializeFrozenIntrinsics();
     if (argv !== undefined) {
-      process.argv = process.argv.concat(argv);
+      process.argv = ArrayPrototypeConcat(process.argv, argv);
     }
     publicWorker.parentPort = publicPort;
     publicWorker.workerData = workerData;
 
+    require('internal/worker').assignEnvironmentData(environmentData);
+
     // The counter is only passed to the workers created by the main thread, not
     // to workers created by other workers.
     let cachedCwd = '';
+    let lastCounter = -1;
     const originalCwd = process.cwd;
 
     process.cwd = function() {
+      const currentCounter = Atomics.load(cwdCounter, 0);
+      if (currentCounter === lastCounter)
+        return cachedCwd;
+      lastCounter = currentCounter;
       cachedCwd = originalCwd();
       return cachedCwd;
     };
     workerIo.sharedCwdCounter = cwdCounter;
 
+    const CJSLoader = require('internal/modules/cjs/loader');
+    assert(!CJSLoader.hasLoadedAnyUserCJSModule);
+    loadPreloadModules();
+    initializeFrozenIntrinsics();
+
     if (!hasStdin)
       process.stdin.push(null);
 
     debug(`[${threadId}] starts worker script ${filename} ` +
           `(eval = ${eval}) at cwd = ${process.cwd()}`);
     port.postMessage({ type: UP_AND_RUNNING });
-    if (doEval) {
+    if (doEval === 'classic') {
       const { evalScript } = require('internal/process/execution');
       const name = '[worker eval]';
       // This is necessary for CJS module compilation.
@@ -154,19 +172,25 @@ port.on('message', (message) => {
         enumerable: true,
         value: filename,
       });
-      process.argv.splice(1, 0, name);
+      ArrayPrototypeSplice(process.argv, 1, 0, name);
       evalScript(name, filename);
+    } else if (doEval === 'module') {
+      const { evalModule } = require('internal/process/execution');
+      PromisePrototypeCatch(evalModule(filename), (e) => {
+        workerOnGlobalUncaughtException(e, true);
+      });
     } else {
       // script filename
       // runMain here might be monkey-patched by users in --require.
       // XXX: the monkey-patchability here should probably be deprecated.
-      process.argv.splice(1, 0, filename);
+      ArrayPrototypeSplice(process.argv, 1, 0, filename);
       CJSLoader.Module.runMain(filename);
     }
   } else if (message.type === STDIO_PAYLOAD) {
     const { stream, chunks } = message;
-    for (const { chunk, encoding } of chunks)
+    ArrayPrototypeForEach(chunks, ({ chunk, encoding }) => {
       process[stream].push(chunk, encoding);
+    });
   } else {
     assert(
       message.type === STDIO_WANTS_MORE_DATA,
@@ -180,10 +204,12 @@ port.on('message', (message) => {
 function workerOnGlobalUncaughtException(error, fromPromise) {
   debug(`[${threadId}] gets uncaught exception`);
   let handled = false;
+  let handlerThrew = false;
   try {
     handled = onGlobalUncaughtException(error, fromPromise);
   } catch (e) {
     error = e;
+    handlerThrew = true;
   }
   debug(`[${threadId}] uncaught exception handled = ${handled}`);
 
@@ -191,6 +217,16 @@ function workerOnGlobalUncaughtException(error, fromPromise) {
     return true;
   }
 
+  if (!process._exiting) {
+    try {
+      process._exiting = true;
+      process.exitCode = 1;
+      if (!handlerThrew) {
+        process.emit('exit', process.exitCode);
+      }
+    } catch {}
+  }
+
   let serialized;
   try {
     const { serializeError } = require('internal/error_serdes');
diff --git a/lib/internal/modules/cjs/helpers.js b/lib/internal/modules/cjs/helpers.js
index cc9e40f4401e61cb38b92db838aee54244b0120b..94602b5309efff20216753cceb60f5b61212f350 100644
--- a/lib/internal/modules/cjs/helpers.js
+++ b/lib/internal/modules/cjs/helpers.js
@@ -1,8 +1,16 @@
 'use strict';
 
 const {
+  ArrayPrototypeForEach,
+  ArrayPrototypeJoin,
   ObjectDefineProperty,
+  ObjectPrototypeHasOwnProperty,
   SafeMap,
+  SafeSet,
+  StringPrototypeCharCodeAt,
+  StringPrototypeIncludes,
+  StringPrototypeSlice,
+  StringPrototypeStartsWith,
 } = primordials;
 const {
   ERR_MANIFEST_DEPENDENCY_MISSING,
@@ -12,17 +20,23 @@ const { NativeModule } = require('internal/bootstrap/loaders');
 
 const { validateString } = require('internal/validators');
 const path = require('path');
-const { pathToFileURL, fileURLToPath } = require('internal/url');
-const { URL } = require('url');
+const { pathToFileURL, fileURLToPath, URL } = require('internal/url');
+
+const { getOptionValue } = require('internal/options');
+const userConditions = getOptionValue('--conditions');
 
 let debug = require('internal/util/debuglog').debuglog('module', (fn) => {
   debug = fn;
 });
 
+// TODO: Use this set when resolving pkg#exports conditions in loader.js.
+const cjsConditions = new SafeSet(['require', 'node', ...userConditions]);
+
 function loadNativeModule(filename, request) {
   const mod = NativeModule.map.get(filename);
-  if (mod) {
+  if (mod?.canBeRequiredByUsers) {
     debug('load native module %s', request);
+    // compileForPublicLoader() throws if mod.canBeRequiredByUsers is false:
     mod.compileForPublicLoader();
     return mod;
   }
@@ -37,11 +51,12 @@ function makeRequireFunction(mod, redirects) {
 
   let require;
   if (redirects) {
-    const { resolve, reaction } = redirects;
     const id = mod.filename || mod.id;
-    require = function require(path) {
+    const conditions = cjsConditions;
+    const { resolve, reaction } = redirects;
+    require = function require(specifier) {
       let missing = true;
-      const destination = resolve(path);
+      const destination = resolve(specifier, conditions);
       if (destination === true) {
         missing = false;
       } else if (destination) {
@@ -65,9 +80,13 @@ function makeRequireFunction(mod, redirects) {
         }
       }
       if (missing) {
-        reaction(new ERR_MANIFEST_DEPENDENCY_MISSING(id, path));
+        reaction(new ERR_MANIFEST_DEPENDENCY_MISSING(
+          id,
+          specifier,
+          ArrayPrototypeJoin([...conditions], ', ')
+        ));
       }
-      return mod.require(path);
+      return mod.require(specifier);
     };
   } else {
     require = function require(path) {
@@ -105,61 +124,23 @@ function makeRequireFunction(mod, redirects) {
  * translates it to FEFF, the UTF-16 BOM.
  */
 function stripBOM(content) {
-  if (content.charCodeAt(0) === 0xFEFF) {
-    content = content.slice(1);
+  if (StringPrototypeCharCodeAt(content) === 0xFEFF) {
+    content = StringPrototypeSlice(content, 1);
   }
   return content;
 }
 
-const builtinLibs = [
-  'assert',
-  'async_hooks',
-  'buffer',
-  'child_process',
-  'cluster',
-  'crypto',
-  'dgram',
-  'dns',
-  'domain',
-  'events',
-  'fs',
-  'http',
-  'http2',
-  'https',
-  'net',
-  'os',
-  'path',
-  'perf_hooks',
-  'punycode',
-  'querystring',
-  'readline',
-  'repl',
-  'stream',
-  'string_decoder',
-  'tls',
-  'trace_events',
-  'tty',
-  'url',
-  'util',
-  'v8',
-  'vm',
-  'worker_threads',
-  'zlib',
-];
-
-if (internalBinding('config').experimentalWasi) {
-  builtinLibs.push('wasi');
-  builtinLibs.sort();
-}
-
-if (typeof internalBinding('inspector').open === 'function') {
-  builtinLibs.push('inspector');
-  builtinLibs.sort();
-}
-
 function addBuiltinLibsToObject(object) {
   // Make built-in modules available directly (loaded lazily).
-  builtinLibs.forEach((name) => {
+  const { builtinModules } = require('internal/modules/cjs/loader').Module;
+  ArrayPrototypeForEach(builtinModules, (name) => {
+    // Neither add underscored modules, nor ones that contain slashes (e.g.,
+    // 'fs/promises') or ones that are already defined.
+    if (StringPrototypeStartsWith(name, '_') ||
+        StringPrototypeIncludes(name, '/') ||
+        ObjectPrototypeHasOwnProperty(object, name)) {
+      return;
+    }
     // Goals of this mechanism are:
     // - Lazy loading of built-in modules
     // - Having all built-in modules available as non-enumerable properties
@@ -205,7 +186,7 @@ function normalizeReferrerURL(referrer) {
 
 module.exports = {
   addBuiltinLibsToObject,
-  builtinLibs,
+  cjsConditions,
   loadNativeModule,
   makeRequireFunction,
   normalizeReferrerURL,
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 99579d6ad62c810d272a49a30cd32d6790f87760..92071f641a7169de48da2c856f5c9f1876b66701 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -23,24 +23,42 @@
 
 const {
   ArrayIsArray,
+  ArrayPrototypeConcat,
+  ArrayPrototypeFilter,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf,
   ArrayPrototypeJoin,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  Boolean,
   Error,
   JSONParse,
-  Map,
   ObjectCreate,
   ObjectDefineProperty,
   ObjectFreeze,
+  ObjectGetOwnPropertyDescriptor,
+  ObjectGetPrototypeOf,
   ObjectKeys,
+  ObjectPrototype,
+  ObjectPrototypeHasOwnProperty,
+  ObjectSetPrototypeOf,
+  Proxy,
+  ReflectApply,
   ReflectSet,
   RegExpPrototypeTest,
   SafeMap,
-  SafeSet,
   SafeWeakMap,
+  String,
+  StringPrototypeCharAt,
+  StringPrototypeCharCodeAt,
   StringPrototypeEndsWith,
-  StringPrototypeIndexOf,
   StringPrototypeLastIndexOf,
+  StringPrototypeIndexOf,
   StringPrototypeMatch,
   StringPrototypeSlice,
+  StringPrototypeSplit,
   StringPrototypeStartsWith,
 } = primordials;
 
@@ -56,7 +74,6 @@ module.exports = {
 const { NativeModule } = require('internal/bootstrap/loaders');
 const {
   maybeCacheSourceMap,
-  rekeySourceMap
 } = require('internal/source_map/source_map_cache');
 const { pathToFileURL, fileURLToPath, isURLInstance } = require('internal/url');
 const { deprecate } = require('internal/util');
@@ -73,17 +90,17 @@ const {
   makeRequireFunction,
   normalizeReferrerURL,
   stripBOM,
+  cjsConditions,
   loadNativeModule
 } = require('internal/modules/cjs/helpers');
 const { getOptionValue } = require('internal/options');
-const enableSourceMaps = getOptionValue('--enable-source-maps');
 const preserveSymlinks = getOptionValue('--preserve-symlinks');
 const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main');
-const manifest = getOptionValue('--experimental-policy') ?
-  require('internal/process/policy').manifest :
+// Do not eagerly grab .manifest, it may be in TDZ
+const policy = getOptionValue('--experimental-policy') ?
+  require('internal/process/policy') :
   null;
 const { compileFunction } = internalBinding('contextify');
-const userConditions = getOptionValue('--conditions');
 
 // Whether any user-provided CJS modules had been loaded (executed).
 // Used for internal assertions.
@@ -93,7 +110,8 @@ const {
   ERR_INVALID_ARG_VALUE,
   ERR_INVALID_OPT_VALUE,
   ERR_INVALID_MODULE_SPECIFIER,
-  ERR_REQUIRE_ESM
+  ERR_REQUIRE_ESM,
+  ERR_UNKNOWN_BUILTIN_MODULE,
 } = require('internal/errors').codes;
 const { validateString } = require('internal/validators');
 const pendingDeprecation = getOptionValue('--pending-deprecation');
@@ -104,6 +122,10 @@ const {
   CHAR_COLON
 } = require('internal/constants');
 
+const {
+  isProxy
+} = require('internal/util/types');
+
 const asyncESM = require('internal/process/esm_loader');
 const { enrichCJSError } = require('internal/modules/esm/translators');
 const { kEvaluated } = internalBinding('module_wrap');
@@ -119,6 +141,7 @@ const relativeResolveCache = ObjectCreate(null);
 
 let requireDepth = 0;
 let statCache = null;
+let isPreloading = false;
 
 function stat(filename) {
   filename = path.toNamespacedPath(filename);
@@ -133,8 +156,8 @@ function stat(filename) {
 
 function updateChildren(parent, child, scan) {
   const children = parent && parent.children;
-  if (children && !(scan && children.includes(child)))
-    children.push(child);
+  if (children && !(scan && ArrayPrototypeIncludes(children, child)))
+    ArrayPrototypePush(children, child);
 }
 
 function Module(id = '', parent) {
@@ -149,9 +172,9 @@ function Module(id = '', parent) {
 }
 
 const builtinModules = [];
-for (const [id, mod] of NativeModule.map) {
+for (const { 0: id, 1: mod } of NativeModule.map) {
   if (mod.canBeRequiredByUsers) {
-    builtinModules.push(id);
+    ArrayPrototypePush(builtinModules, id);
   }
 }
 
@@ -173,7 +196,7 @@ let wrap = function(script) {
 
 const wrapper = [
   '(function (exports, require, module, __filename, __dirname) { ',
-  '\n});'
+  '\n});',
 ];
 
 let wrapperProxy = new Proxy(wrapper, {
@@ -210,6 +233,10 @@ ObjectDefineProperty(Module, 'wrapper', {
   }
 });
 
+const isPreloadingDesc = { get() { return isPreloading; } };
+ObjectDefineProperty(Module.prototype, 'isPreloading', isPreloadingDesc);
+ObjectDefineProperty(NativeModule.prototype, 'isPreloading', isPreloadingDesc);
+
 let debug = require('internal/util/debuglog').debuglog('module', (fn) => {
   debug = fn;
 });
@@ -277,14 +304,13 @@ function readPackageScope(checkPath) {
 }
 
 function tryPackage(requestPath, exts, isMain, originalPath) {
-  const pkg = readPackage(requestPath);
-  const pkgMain = pkg && pkg.main;
+  const pkg = readPackage(requestPath)?.main;
 
-  if (!pkgMain) {
+  if (!pkg) {
     return tryExtensions(path.resolve(requestPath, 'index'), exts, isMain);
   }
 
-  const filename = path.resolve(requestPath, pkgMain);
+  const filename = path.resolve(requestPath, pkg);
   let actual = tryFile(filename, isMain) ||
     tryExtensions(filename, exts, isMain) ||
     tryExtensions(path.resolve(filename, 'index'), exts, isMain);
@@ -304,7 +330,7 @@ function tryPackage(requestPath, exts, isMain, originalPath) {
     } else if (pendingDeprecation) {
       const jsonPath = path.resolve(requestPath, 'package.json');
       process.emitWarning(
-        `Invalid 'main' field in '${jsonPath}' of '${pkgMain}'. ` +
+        `Invalid 'main' field in '${jsonPath}' of '${pkg}'. ` +
           'Please either fix that or report it to the module author',
         'DeprecationWarning',
         'DEP0128'
@@ -317,7 +343,7 @@ function tryPackage(requestPath, exts, isMain, originalPath) {
 // In order to minimize unnecessary lstat() calls,
 // this cache is a list of known-real paths.
 // Set to an empty Map to reset.
-const realpathCache = new Map();
+const realpathCache = new SafeMap();
 
 // Check if the file exists and is not a directory
 // if using --preserve-symlinks and isMain is false,
@@ -357,10 +383,10 @@ function findLongestRegisteredExtension(filename) {
   let currentExtension;
   let index;
   let startIndex = 0;
-  while ((index = name.indexOf('.', startIndex)) !== -1) {
+  while ((index = StringPrototypeIndexOf(name, '.', startIndex)) !== -1) {
     startIndex = index + 1;
     if (index === 0) continue; // Skip dotfiles like .gitignore
-    currentExtension = name.slice(index);
+    currentExtension = StringPrototypeSlice(name, index);
     if (Module._extensions[currentExtension]) return currentExtension;
   }
   return '.js';
@@ -413,7 +439,7 @@ function trySelf(parentPath, request) {
 const EXPORTS_PATTERN = /^((?:@[^/\\%]+\/)?[^./\\%][^/\\%]*)(\/.*)?$/;
 function resolveExports(nmPath, request) {
   // The implementation's behavior is meant to mirror resolution in ESM.
-  const [, name, expansion = ''] =
+  const { 1: name, 2: expansion = '' } =
     StringPrototypeMatch(request, EXPORTS_PATTERN) || [];
   if (!name)
     return;
@@ -441,15 +467,15 @@ Module._findPath = function(request, paths, isMain) {
     return false;
   }
 
-  const cacheKey = request + '\x00' +
-                (paths.length === 1 ? paths[0] : paths.join('\x00'));
+  const cacheKey = request + '\x00' + ArrayPrototypeJoin(paths, '\x00');
   const entry = Module._pathCache[cacheKey];
   if (entry)
     return entry;
 
   let exts;
   let trailingSlash = request.length > 0 &&
-    request.charCodeAt(request.length - 1) === CHAR_FORWARD_SLASH;
+    StringPrototypeCharCodeAt(request, request.length - 1) ===
+    CHAR_FORWARD_SLASH;
   if (!trailingSlash) {
     trailingSlash = RegExpPrototypeTest(trailingSlashRegex, request);
   }
@@ -532,13 +558,14 @@ if (isWindows) {
 
     // return root node_modules when path is 'D:\\'.
     // path.resolve will make sure from.length >=3 in Windows.
-    if (from.charCodeAt(from.length - 1) === CHAR_BACKWARD_SLASH &&
-        from.charCodeAt(from.length - 2) === CHAR_COLON)
+    if (StringPrototypeCharCodeAt(from, from.length - 1) ===
+          CHAR_BACKWARD_SLASH &&
+        StringPrototypeCharCodeAt(from, from.length - 2) === CHAR_COLON)
       return [from + 'node_modules'];
 
     const paths = [];
     for (let i = from.length - 1, p = 0, last = from.length; i >= 0; --i) {
-      const code = from.charCodeAt(i);
+      const code = StringPrototypeCharCodeAt(from, i);
       // The path segment separator check ('\' and '/') was used to get
       // node_modules path for every path segment.
       // Use colon as an extra condition since we can get node_modules
@@ -548,7 +575,10 @@ if (isWindows) {
           code === CHAR_FORWARD_SLASH ||
           code === CHAR_COLON) {
         if (p !== nmLen)
-          paths.push(from.slice(0, last) + '\\node_modules');
+          ArrayPrototypePush(
+            paths,
+            StringPrototypeSlice(from, 0, last) + '\\node_modules'
+          );
         last = i;
         p = 0;
       } else if (p !== -1) {
@@ -577,10 +607,13 @@ if (isWindows) {
     // that works on both Windows and Posix is non-trivial.
     const paths = [];
     for (let i = from.length - 1, p = 0, last = from.length; i >= 0; --i) {
-      const code = from.charCodeAt(i);
+      const code = StringPrototypeCharCodeAt(from, i);
       if (code === CHAR_FORWARD_SLASH) {
         if (p !== nmLen)
-          paths.push(from.slice(0, last) + '/node_modules');
+          ArrayPrototypePush(
+            paths,
+            StringPrototypeSlice(from, 0, last) + '/node_modules'
+          );
         last = i;
         p = 0;
       } else if (p !== -1) {
@@ -593,7 +626,7 @@ if (isWindows) {
     }
 
     // Append /node_modules to handle root paths.
-    paths.push('/node_modules');
+    ArrayPrototypePush(paths, '/node_modules');
 
     return paths;
   };
@@ -606,15 +639,15 @@ Module._resolveLookupPaths = function(request, parent) {
   }
 
   // Check for node modules paths.
-  if (request.charAt(0) !== '.' ||
+  if (StringPrototypeCharAt(request, 0) !== '.' ||
       (request.length > 1 &&
-      request.charAt(1) !== '.' &&
-      request.charAt(1) !== '/' &&
-      (!isWindows || request.charAt(1) !== '\\'))) {
+      StringPrototypeCharAt(request, 1) !== '.' &&
+      StringPrototypeCharAt(request, 1) !== '/' &&
+      (!isWindows || StringPrototypeCharAt(request, 1) !== '\\'))) {
 
     let paths = modulePaths;
     if (parent != null && parent.paths && parent.paths.length) {
-      paths = parent.paths.concat(paths);
+      paths = ArrayPrototypeConcat(parent.paths, paths);
     }
 
     debug('looking for %j in %j', request, paths);
@@ -638,6 +671,50 @@ Module._resolveLookupPaths = function(request, parent) {
   return parentDir;
 };
 
+function emitCircularRequireWarning(prop) {
+  process.emitWarning(
+    `Accessing non-existent property '${String(prop)}' of module exports ` +
+    'inside circular dependency'
+  );
+}
+
+// A Proxy that can be used as the prototype of a module.exports object and
+// warns when non-existent properties are accessed.
+const CircularRequirePrototypeWarningProxy = new Proxy({}, {
+  get(target, prop) {
+    // Allow __esModule access in any case because it is used in the output
+    // of transpiled code to determine whether something comes from an
+    // ES module, and is not used as a regular key of `module.exports`.
+    if (prop in target || prop === '__esModule') return target[prop];
+    emitCircularRequireWarning(prop);
+    return undefined;
+  },
+
+  getOwnPropertyDescriptor(target, prop) {
+    if (ObjectPrototypeHasOwnProperty(target, prop) || prop === '__esModule')
+      return ObjectGetOwnPropertyDescriptor(target, prop);
+    emitCircularRequireWarning(prop);
+    return undefined;
+  }
+});
+
+function getExportsForCircularRequire(module) {
+  if (module.exports &&
+      !isProxy(module.exports) &&
+      ObjectGetPrototypeOf(module.exports) === ObjectPrototype &&
+      // Exclude transpiled ES6 modules / TypeScript code because those may
+      // employ unusual patterns for accessing 'module.exports'. That should
+      // be okay because ES6 modules have a different approach to circular
+      // dependencies anyway.
+      !module.exports.__esModule) {
+    // This is later unset once the module is done loading.
+    ObjectSetPrototypeOf(
+      module.exports, CircularRequirePrototypeWarningProxy);
+  }
+
+  return module.exports;
+}
+
 // Check the cache for the requested file.
 // 1. If a module already exists in the cache: return its exports object.
 // 2. If the module is native: call
@@ -658,6 +735,8 @@ Module._load = function(request, parent, isMain) {
       const cachedModule = Module._cache[filename];
       if (cachedModule !== undefined) {
         updateChildren(parent, cachedModule, true);
+        if (!cachedModule.loaded)
+          return getExportsForCircularRequire(cachedModule);
         return cachedModule.exports;
       }
       delete relativeResolveCache[relResolveCacheIdentifier];
@@ -665,15 +744,29 @@ Module._load = function(request, parent, isMain) {
   }
 
   const filename = Module._resolveFilename(request, parent, isMain);
+  if (StringPrototypeStartsWith(filename, 'node:')) {
+    // Slice 'node:' prefix
+    const id = StringPrototypeSlice(filename, 5);
+
+    const module = loadNativeModule(id, request);
+    if (!module?.canBeRequiredByUsers) {
+      throw new ERR_UNKNOWN_BUILTIN_MODULE(filename);
+    }
+
+    return module.exports;
+  }
 
   const cachedModule = Module._cache[filename];
   if (cachedModule !== undefined) {
     updateChildren(parent, cachedModule, true);
-    const parseCachedModule = cjsParseCache.get(cachedModule);
-    if (parseCachedModule && !parseCachedModule.loaded)
+    if (!cachedModule.loaded) {
+      const parseCachedModule = cjsParseCache.get(cachedModule);
+      if (!parseCachedModule || parseCachedModule.loaded)
+        return getExportsForCircularRequire(cachedModule);
       parseCachedModule.loaded = true;
-    else
+    } else {
       return cachedModule.exports;
+    }
   }
 
   const mod = loadNativeModule(filename, request);
@@ -694,19 +787,7 @@ Module._load = function(request, parent, isMain) {
 
   let threw = true;
   try {
-    // Intercept exceptions that occur during the first tick and rekey them
-    // on error instance rather than module instance (which will immediately be
-    // garbage collected).
-    if (enableSourceMaps) {
-      try {
-        module.load(filename);
-      } catch (err) {
-        rekeySourceMap(Module._cache[filename], err);
-        throw err; /* node-do-not-add-exception-line */
-      }
-    } else {
-      module.load(filename);
-    }
+    module.load(filename);
     threw = false;
   } finally {
     if (threw) {
@@ -715,21 +796,26 @@ Module._load = function(request, parent, isMain) {
         delete relativeResolveCache[relResolveCacheIdentifier];
         const children = parent && parent.children;
         if (ArrayIsArray(children)) {
-          const index = children.indexOf(module);
+          const index = ArrayPrototypeIndexOf(children, module);
           if (index !== -1) {
-            children.splice(index, 1);
+            ArrayPrototypeSplice(children, index, 1);
           }
         }
       }
+    } else if (module.exports &&
+               !isProxy(module.exports) &&
+               ObjectGetPrototypeOf(module.exports) ===
+                 CircularRequirePrototypeWarningProxy) {
+      ObjectSetPrototypeOf(module.exports, ObjectPrototype);
     }
   }
 
   return module.exports;
 };
 
-const cjsConditions = new SafeSet(['require', 'node', ...userConditions]);
 Module._resolveFilename = function(request, parent, isMain, options) {
-  if (NativeModule.canBeRequiredByUsers(request)) {
+  if (StringPrototypeStartsWith(request, 'node:') ||
+      NativeModule.canBeRequiredByUsers(request)) {
     return request;
   }
 
@@ -737,10 +823,10 @@ Module._resolveFilename = function(request, parent, isMain, options) {
 
   if (typeof options === 'object' && options !== null) {
     if (ArrayIsArray(options.paths)) {
-      const isRelative = request.startsWith('./') ||
-          request.startsWith('../') ||
-          ((isWindows && request.startsWith('.\\')) ||
-          request.startsWith('..\\'));
+      const isRelative = StringPrototypeStartsWith(request, './') ||
+          StringPrototypeStartsWith(request, '../') ||
+          ((isWindows && StringPrototypeStartsWith(request, '.\\')) ||
+          StringPrototypeStartsWith(request, '..\\'));
 
       if (isRelative) {
         paths = options.paths;
@@ -755,8 +841,8 @@ Module._resolveFilename = function(request, parent, isMain, options) {
           const lookupPaths = Module._resolveLookupPaths(request, fakeParent);
 
           for (let j = 0; j < lookupPaths.length; j++) {
-            if (!paths.includes(lookupPaths[j]))
-              paths.push(lookupPaths[j]);
+            if (!ArrayPrototypeIncludes(paths, lookupPaths[j]))
+              ArrayPrototypePush(paths, lookupPaths[j]);
           }
         }
       }
@@ -788,7 +874,7 @@ Module._resolveFilename = function(request, parent, isMain, options) {
     }
   }
 
-  // Try module self resoultion first
+  // Try module self resolution first
   const parentPath = trySelfParentPath(parent);
   const selfResolved = trySelf(parentPath, request);
   if (selfResolved) {
@@ -805,11 +891,12 @@ Module._resolveFilename = function(request, parent, isMain, options) {
   for (let cursor = parent;
     cursor;
     cursor = cursor.parent) {
-    requireStack.push(cursor.filename || cursor.id);
+    ArrayPrototypePush(requireStack, cursor.filename || cursor.id);
   }
   let message = `Cannot find module '${request}'`;
   if (requireStack.length > 0) {
-    message = message + '\nRequire stack:\n- ' + requireStack.join('\n- ');
+    message = message + '\nRequire stack:\n- ' +
+              ArrayPrototypeJoin(requireStack, '\n- ');
   }
   // eslint-disable-next-line no-restricted-syntax
   const err = new Error(message);
@@ -820,7 +907,7 @@ Module._resolveFilename = function(request, parent, isMain, options) {
 
 function finalizeEsmResolution(match, request, parentPath, pkgPath) {
   const { resolved, exact } = match;
-  if (StringPrototypeMatch(resolved, encodedSepRegEx))
+  if (RegExpPrototypeTest(encodedSepRegEx, resolved))
     throw new ERR_INVALID_MODULE_SPECIFIER(
       resolved, 'must not include encoded "/" or "\\" characters', parentPath);
   const filename = fileURLToPath(resolved);
@@ -857,9 +944,9 @@ Module.prototype.load = function(filename) {
 
   const extension = findLongestRegisteredExtension(filename);
   // allow .mjs to be overridden
-  if (filename.endsWith('.mjs') && !Module._extensions['.mjs']) {
+  if (StringPrototypeEndsWith(filename, '.mjs') && !Module._extensions['.mjs'])
     throw new ERR_REQUIRE_ESM(filename);
-  }
+
   Module._extensions[extension](this, filename);
   this.loaded = true;
 
@@ -867,7 +954,7 @@ Module.prototype.load = function(filename) {
   // Create module entry at load time to snapshot exports correctly
   const exports = this.exports;
   // Preemptively cache
-  if ((!module || module.module === undefined ||
+  if ((module?.module === undefined ||
        module.module.getStatus() < kEvaluated) &&
       !ESMLoader.cjsCache.has(this))
     ESMLoader.cjsCache.set(this, exports);
@@ -909,7 +996,6 @@ function wrapSafe(filename, content, cjsModuleInstance) {
       },
     });
   }
-
   let compiled;
   try {
     compiled = compileFunction(
@@ -953,16 +1039,16 @@ function wrapSafe(filename, content, cjsModuleInstance) {
 Module.prototype._compile = function(content, filename) {
   let moduleURL;
   let redirects;
-  if (manifest) {
+  if (policy?.manifest) {
     moduleURL = pathToFileURL(filename);
-    redirects = manifest.getRedirector(moduleURL);
-    manifest.assertIntegrity(moduleURL, content);
+    redirects = policy.manifest.getDependencyMapper(moduleURL);
+    policy.manifest.assertIntegrity(moduleURL, content);
   }
 
   maybeCacheSourceMap(filename, content, this);
   const compiledWrapper = wrapSafe(filename, content, this);
 
-  var inspectorWrapper = null;
+  let inspectorWrapper = null;
   if (getOptionValue('--inspect-brk') && process._eval == null) {
     if (!resolvedArgv) {
       // We enter the repl if we're not given a filename argument.
@@ -991,13 +1077,13 @@ Module.prototype._compile = function(content, filename) {
   const exports = this.exports;
   const thisValue = exports;
   const module = this;
-  if (requireDepth === 0) statCache = new Map();
+  if (requireDepth === 0) statCache = new SafeMap();
   if (inspectorWrapper) {
     result = inspectorWrapper(compiledWrapper, thisValue, exports,
                               require, module, filename, dirname);
   } else {
-    result = compiledWrapper.call(thisValue, exports, require, module,
-                                  filename, dirname);
+    result = ReflectApply(compiledWrapper, thisValue,
+                          [exports, require, module, filename, dirname]);
   }
   hasLoadedAnyUserCJSModule = true;
   if (requireDepth === 0) statCache = null;
@@ -1006,11 +1092,12 @@ Module.prototype._compile = function(content, filename) {
 
 // Native extension for .js
 Module._extensions['.js'] = function(module, filename) {
-  if (filename.endsWith('.js')) {
+  if (StringPrototypeEndsWith(filename, '.js')) {
     const pkg = readPackageScope(filename);
     // Function require shouldn't be used in ES modules.
     if (pkg && pkg.data && pkg.data.type === 'module') {
-      const parentPath = module.parent && module.parent.filename;
+      const { parent } = module;
+      const parentPath = parent && parent.filename;
       const packageJsonPath = path.resolve(pkg.path, 'package.json');
       throw new ERR_REQUIRE_ESM(filename, parentPath, packageJsonPath);
     }
@@ -1032,9 +1119,9 @@ Module._extensions['.js'] = function(module, filename) {
 Module._extensions['.json'] = function(module, filename) {
   const content = fs.readFileSync(filename, 'utf8');
 
-  if (manifest) {
+  if (policy?.manifest) {
     const moduleURL = pathToFileURL(filename);
-    manifest.assertIntegrity(moduleURL, content);
+    policy.manifest.assertIntegrity(moduleURL, content);
   }
 
   try {
@@ -1048,10 +1135,10 @@ Module._extensions['.json'] = function(module, filename) {
 
 // Native extension for .node
 Module._extensions['.node'] = function(module, filename) {
-  if (manifest) {
+  if (policy?.manifest) {
     const content = fs.readFileSync(filename);
     const moduleURL = pathToFileURL(filename);
-    manifest.assertIntegrity(moduleURL, content);
+    policy.manifest.assertIntegrity(moduleURL, content);
   }
   // Be aware this doesn't use `content`
   return process.dlopen(module, path.toNamespacedPath(filename));
@@ -1060,7 +1147,8 @@ Module._extensions['.node'] = function(module, filename) {
 function createRequireFromPath(filename) {
   // Allow a directory to be passed as the filename
   const trailingSlash =
-    filename.endsWith('/') || (isWindows && filename.endsWith('\\'));
+    StringPrototypeEndsWith(filename, '/') ||
+    (isWindows && StringPrototypeEndsWith(filename, '\\'));
 
   const proxyPath = trailingSlash ?
     path.join(filename, 'noop.js') :
@@ -1073,7 +1161,12 @@ function createRequireFromPath(filename) {
   return makeRequireFunction(m, null);
 }
 
-Module.createRequireFromPath = createRequireFromPath;
+Module.createRequireFromPath = deprecate(
+  createRequireFromPath,
+  'Module.createRequireFromPath() is deprecated. ' +
+  'Use Module.createRequire() instead.',
+  'DEP0130'
+);
 
 const createRequireError = 'must be a file URL object, file URL string, or ' +
   'absolute path string';
@@ -1112,26 +1205,29 @@ Module._initPaths = function() {
   let paths = [path.resolve(prefixDir, 'lib', 'node')];
 
   if (homeDir) {
-    paths.unshift(path.resolve(homeDir, '.node_libraries'));
-    paths.unshift(path.resolve(homeDir, '.node_modules'));
+    ArrayPrototypeUnshift(paths, path.resolve(homeDir, '.node_libraries'));
+    ArrayPrototypeUnshift(paths, path.resolve(homeDir, '.node_modules'));
   }
 
   if (nodePath) {
-    paths = nodePath.split(path.delimiter).filter(function pathsFilterCB(path) {
-      return !!path;
-    }).concat(paths);
+    paths = ArrayPrototypeConcat(ArrayPrototypeFilter(
+      StringPrototypeSplit(nodePath, path.delimiter),
+      Boolean
+    ), paths);
   }
 
   modulePaths = paths;
 
   // Clone as a shallow copy, for introspection.
-  Module.globalPaths = modulePaths.slice(0);
+  Module.globalPaths = ArrayPrototypeSlice(modulePaths);
 };
 
 Module._preloadModules = function(requests) {
   if (!ArrayIsArray(requests))
     return;
 
+  isPreloading = true;
+
   // Preloaded modules have a dummy parent module which is deemed to exist
   // in the current working directory. This seeds the search path for
   // preloaded modules.
@@ -1140,11 +1236,13 @@ Module._preloadModules = function(requests) {
     parent.paths = Module._nodeModulePaths(process.cwd());
   } catch (e) {
     if (e.code !== 'ENOENT') {
+      isPreloading = false;
       throw e;
     }
   }
   for (let n = 0; n < requests.length; n++)
     parent.require(requests[n]);
+  isPreloading = false;
 };
 
 Module.syncBuiltinESMExports = function syncBuiltinESMExports() {
diff --git a/lib/internal/modules/esm/create_dynamic_module.js b/lib/internal/modules/esm/create_dynamic_module.js
index e831db8daaf47696e0bc02a90d6d7ad1a3f7d77b..f7c20083b6c918a98566e3b2612c2b48ead570bd 100644
--- a/lib/internal/modules/esm/create_dynamic_module.js
+++ b/lib/internal/modules/esm/create_dynamic_module.js
@@ -5,7 +5,7 @@ const {
   ArrayPrototypeMap,
   JSONStringify,
   ObjectCreate,
-  Set,
+  SafeSet,
 } = primordials;
 
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
@@ -38,7 +38,7 @@ import.meta.done();
   const { ModuleWrap, callbackMap } = internalBinding('module_wrap');
   const m = new ModuleWrap(`${url}`, undefined, source, 0, 0);
 
-  const readyfns = new Set();
+  const readyfns = new SafeSet();
   const reflect = {
     exports: ObjectCreate(null),
     onReady: (cb) => { readyfns.add(cb); },
diff --git a/lib/internal/modules/esm/get_format.js b/lib/internal/modules/esm/get_format.js
index 16e2ad5e2d5c3eff02c28966d93bd6872353cf34..43661533cc3357c004c58c230f9661030e2a79f1 100644
--- a/lib/internal/modules/esm/get_format.js
+++ b/lib/internal/modules/esm/get_format.js
@@ -1,10 +1,13 @@
 'use strict';
-const { StringPrototypeStartsWith } = primordials;
+const {
+  RegExpPrototypeExec,
+  StringPrototypeStartsWith,
+} = primordials;
 const { extname } = require('path');
 const { getOptionValue } = require('internal/options');
 
 const experimentalJsonModules = getOptionValue('--experimental-json-modules');
-const experimentalSpeciferResolution =
+const experimentalSpecifierResolution =
   getOptionValue('--experimental-specifier-resolution');
 const experimentalWasmModules = getOptionValue('--experimental-wasm-modules');
 const { getPackageType } = require('internal/modules/esm/resolve');
@@ -39,7 +42,10 @@ function defaultGetFormat(url, context, defaultGetFormatUnused) {
   }
   const parsed = new URL(url);
   if (parsed.protocol === 'data:') {
-    const [ , mime ] = /^([^/]+\/[^;,]+)(?:[^,]*?)(;base64)?,/.exec(parsed.pathname) || [ null, null, null ];
+    const [ , mime ] = RegExpPrototypeExec(
+      /^([^/]+\/[^;,]+)(?:[^,]*?)(;base64)?,/,
+      parsed.pathname,
+    ) || [ null, null, null ];
     const format = ({
       '__proto__': null,
       'text/javascript': 'module',
@@ -56,7 +62,7 @@ function defaultGetFormat(url, context, defaultGetFormatUnused) {
       format = extensionFormatMap[ext];
     }
     if (!format) {
-      if (experimentalSpeciferResolution === 'node') {
+      if (experimentalSpecifierResolution === 'node') {
         process.emitWarning(
           'The Node.js specifier resolution in ESM is experimental.',
           'ExperimentalWarning');
@@ -69,4 +75,9 @@ function defaultGetFormat(url, context, defaultGetFormatUnused) {
   }
   return { format: null };
 }
-exports.defaultGetFormat = defaultGetFormat;
+
+module.exports = {
+  defaultGetFormat,
+  extensionFormatMap,
+  legacyExtensionFormatMap,
+};
diff --git a/lib/internal/modules/esm/get_source.js b/lib/internal/modules/esm/get_source.js
index 2f7b74fb74406cb211aefa042aca760f764c876f..092f61c0b0090021ff7eb216131963b6483a2743 100644
--- a/lib/internal/modules/esm/get_source.js
+++ b/lib/internal/modules/esm/get_source.js
@@ -1,23 +1,24 @@
 'use strict';
 
 const {
+  RegExpPrototypeExec,
   decodeURIComponent,
 } = primordials;
 const { getOptionValue } = require('internal/options');
-const manifest = getOptionValue('--experimental-policy') ?
-  require('internal/process/policy').manifest :
+// Do not eagerly grab .manifest, it may be in TDZ
+const policy = getOptionValue('--experimental-policy') ?
+  require('internal/process/policy') :
   null;
 
 const { Buffer } = require('buffer');
 
-const fs = require('fs');
-const { URL } = require('url');
-const { promisify } = require('internal/util');
+const fs = require('internal/fs/promises').exports;
+const { URL } = require('internal/url');
 const {
   ERR_INVALID_URL,
   ERR_INVALID_URL_SCHEME,
 } = require('internal/errors').codes;
-const readFileAsync = promisify(fs.readFile);
+const readFileAsync = fs.readFile;
 
 const DATA_URL_PATTERN = /^[^/]+\/[^,;]+(?:[^,]*?)(;base64)?,([\s\S]*)$/;
 
@@ -27,7 +28,7 @@ async function defaultGetSource(url, { format } = {}, defaultGetSource) {
   if (parsed.protocol === 'file:') {
     source = await readFileAsync(parsed);
   } else if (parsed.protocol === 'data:') {
-    const match = DATA_URL_PATTERN.exec(parsed.pathname);
+    const match = RegExpPrototypeExec(DATA_URL_PATTERN, parsed.pathname);
     if (!match) {
       throw new ERR_INVALID_URL(url);
     }
@@ -36,8 +37,8 @@ async function defaultGetSource(url, { format } = {}, defaultGetSource) {
   } else {
     throw new ERR_INVALID_URL_SCHEME(['file', 'data']);
   }
-  if (manifest) {
-    manifest.assertIntegrity(parsed, source);
+  if (policy?.manifest) {
+    policy.manifest.assertIntegrity(parsed, source);
   }
   return { source };
 }
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 0d1c09f3d38c7f2e48656579d2c52f1fe75cc86b..de9863ed71ce8aa8186723a6b68acd4a31f0e3e0 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -6,19 +6,22 @@ require('internal/modules/cjs/loader');
 const {
   FunctionPrototypeBind,
   ObjectSetPrototypeOf,
+  RegExpPrototypeExec,
   SafeWeakMap,
+  StringPrototypeStartsWith,
+  globalThis,
 } = primordials;
 
 const {
+  ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ARG_VALUE,
+  ERR_INVALID_MODULE_SPECIFIER,
   ERR_INVALID_RETURN_PROPERTY,
   ERR_INVALID_RETURN_PROPERTY_VALUE,
   ERR_INVALID_RETURN_VALUE,
-  ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK,
   ERR_UNKNOWN_MODULE_FORMAT
 } = require('internal/errors').codes;
-const { URL, pathToFileURL } = require('internal/url');
-const { validateString } = require('internal/validators');
+const { URL, pathToFileURL, isURLInstance } = require('internal/url');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
 
@@ -31,14 +34,10 @@ const { defaultGetSource } = require(
   'internal/modules/esm/get_source');
 const { defaultTransformSource } = require(
   'internal/modules/esm/transform_source');
-const createDynamicModule = require(
-  'internal/modules/esm/create_dynamic_module');
 const { translators } = require(
   'internal/modules/esm/translators');
 const { getOptionValue } = require('internal/options');
 
-const debug = require('internal/util/debuglog').debuglog('esm');
-
 /* A Loader instance is used as the main entry point for loading ES modules.
  * Currently, this is a singleton -- there is only one used for loading
  * the main module and everything in its dependency graph. */
@@ -71,8 +70,6 @@ class Loader {
     // This hook is called after the module is resolved but before a translator
     // is chosen to load it; the format returned by this function is the name
     // of a translator.
-    // If `.format` on the returned value is 'dynamic', .dynamicInstantiate
-    // will be used as described below.
     this._getFormat = defaultGetFormat;
     // This hook is called just before the source code of an ES module file
     // is loaded.
@@ -80,22 +77,14 @@ class Loader {
     // This hook is called just after the source code of an ES module file
     // is loaded, but before anything is done with the string.
     this._transformSource = defaultTransformSource;
-    // This hook is only called when getFormat is 'dynamic' and
-    // has the signature
-    //   (url : string) -> Promise<{ exports: { ... }, execute: function }>
-    // Where `exports` is an object whose property names define the exported
-    // names of the generated module. `execute` is a function that receives
-    // an object with the same keys as `exports`, whose values are get/set
-    // functions for the actual exported values.
-    this._dynamicInstantiate = undefined;
     // The index for assigning unique URLs to anonymous module evaluation
     this.evalIndex = 0;
   }
 
   async resolve(specifier, parentURL) {
     const isMain = parentURL === undefined;
-    if (!isMain)
-      validateString(parentURL, 'parentURL');
+    if (!isMain && typeof parentURL !== 'string' && !isURLInstance(parentURL))
+      throw new ERR_INVALID_ARG_TYPE('parentURL', ['string', 'URL'], parentURL);
 
     const resolveResponse = await this._resolve(
       specifier, { parentURL, conditions: DEFAULT_CONDITIONS }, defaultResolve);
@@ -121,6 +110,15 @@ class Loader {
     }
 
     const { format } = getFormatResponse;
+    if (format === null) {
+      const dataUrl = RegExpPrototypeExec(
+        /^data:([^/]+\/[^;,]+)(?:[^,]*?)(;base64)?,/,
+        url,
+      );
+      throw new ERR_INVALID_MODULE_SPECIFIER(
+        url,
+        dataUrl ? `has an unsupported MIME type "${dataUrl[1]}"` : '');
+    }
     if (typeof format !== 'string') {
       throw new ERR_INVALID_RETURN_PROPERTY_VALUE(
         'string', 'loader getFormat', 'format', format);
@@ -141,9 +139,8 @@ class Loader {
     }
 
     if (this._resolve === defaultResolve &&
-      format !== 'dynamic' &&
-      !url.startsWith('file:') &&
-      !url.startsWith('data:')
+      !StringPrototypeStartsWith(url, 'file:') &&
+      !StringPrototypeStartsWith(url, 'data:')
     ) {
       throw new ERR_INVALID_RETURN_PROPERTY(
         'file: or data: url', 'loader resolve', 'url', url
@@ -170,10 +167,9 @@ class Loader {
     };
     const job = new ModuleJob(this, url, evalInstance, false, false);
     this.moduleMap.set(url, job);
-    const { module, result } = await job.run();
+    const { module } = await job.run();
     return {
       namespace: module.getNamespace(),
-      result
     };
   }
 
@@ -197,8 +193,8 @@ class Loader {
     if (resolve !== undefined)
       this._resolve = FunctionPrototypeBind(resolve, null);
     if (dynamicInstantiate !== undefined) {
-      this._dynamicInstantiate =
-        FunctionPrototypeBind(dynamicInstantiate, null);
+      process.emitWarning(
+        'The dynamicInstantiate loader hook has been removed.');
     }
     if (getFormat !== undefined) {
       this._getFormat = FunctionPrototypeBind(getFormat, null);
@@ -252,25 +248,10 @@ class Loader {
     if (job !== undefined)
       return job;
 
-    let loaderInstance;
-    if (format === 'dynamic') {
-      if (typeof this._dynamicInstantiate !== 'function')
-        throw new ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK();
-
-      loaderInstance = async (url) => {
-        debug(`Translating dynamic ${url}`);
-        const { exports, execute } = await this._dynamicInstantiate(url);
-        return createDynamicModule([], exports, url, (reflect) => {
-          debug(`Loading dynamic ${url}`);
-          execute(reflect.exports);
-        }).module;
-      };
-    } else {
-      if (!translators.has(format))
-        throw new ERR_UNKNOWN_MODULE_FORMAT(format);
+    if (!translators.has(format))
+      throw new ERR_UNKNOWN_MODULE_FORMAT(format);
 
-      loaderInstance = translators.get(format);
-    }
+    const loaderInstance = translators.get(format);
 
     const inspectBrk = parentURL === undefined &&
         format === 'module' && getOptionValue('--inspect-brk');
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index e2f7523ea25402e039378d43ced447d82c5353d5..0ef8ebdeb9245bd175e6c97f9fa66b5179eef205 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -2,26 +2,51 @@
 
 const {
   ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeSome,
+  FunctionPrototype,
   ObjectSetPrototypeOf,
   PromiseAll,
+  PromiseResolve,
+  PromisePrototypeCatch,
+  ReflectApply,
+  RegExpPrototypeTest,
+  SafeArrayIterator,
   SafeSet,
-  SafePromise,
   StringPrototypeIncludes,
   StringPrototypeMatch,
   StringPrototypeReplace,
   StringPrototypeSplit,
+  StringPrototypeStartsWith,
 } = primordials;
 
 const { ModuleWrap } = internalBinding('module_wrap');
 
 const { decorateErrorStack } = require('internal/util');
+const {
+  getSourceMapsEnabled,
+} = require('internal/source_map/source_map_cache');
 const assert = require('internal/assert');
-const resolvedPromise = SafePromise.resolve();
+const resolvedPromise = PromiseResolve();
 
-function noop() {}
+const noop = FunctionPrototype;
 
 let hasPausedEntry = false;
 
+const CJSGlobalLike = [
+  'require',
+  'module',
+  'exports',
+  '__filename',
+  '__dirname',
+];
+const isCommonJSGlobalLikeNotDefinedError = (errorMessage) =>
+  ArrayPrototypeSome(
+    CJSGlobalLike,
+    (globalLike) => errorMessage === `${globalLike} is not defined`
+  );
+
 /* A ModuleJob tracks the loading of a single Module, and the ModuleJobs of
  * its dependencies, over time. */
 class ModuleJob {
@@ -32,62 +57,64 @@ class ModuleJob {
     this.isMain = isMain;
     this.inspectBrk = inspectBrk;
 
-    // This is a Promise<{ module, reflect }>, whose fields will be copied
-    // onto `this` by `link()` below once it has been resolved.
-    this.modulePromise = moduleProvider.call(loader, url, isMain);
     this.module = undefined;
+    // Expose the promise to the ModuleWrap directly for linking below.
+    // `this.module` is also filled in below.
+    this.modulePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
 
     // Wait for the ModuleWrap instance being linked with all dependencies.
     const link = async () => {
       this.module = await this.modulePromise;
       assert(this.module instanceof ModuleWrap);
 
+      // Explicitly keeping track of dependency jobs is needed in order
+      // to flatten out the dependency graph below in `_instantiate()`,
+      // so that circular dependencies can't cause a deadlock by two of
+      // these `link` callbacks depending on each other.
       const dependencyJobs = [];
       const promises = this.module.link(async (specifier) => {
         const jobPromise = this.loader.getModuleJob(specifier, url);
-        dependencyJobs.push(jobPromise);
-        return (await jobPromise).modulePromise;
+        ArrayPrototypePush(dependencyJobs, jobPromise);
+        const job = await jobPromise;
+        return job.modulePromise;
       });
 
       if (promises !== undefined)
-        await SafePromise.all(promises);
+        await PromiseAll(new SafeArrayIterator(promises));
 
-      return SafePromise.all(dependencyJobs);
+      return PromiseAll(new SafeArrayIterator(dependencyJobs));
     };
     // Promise for the list of all dependencyJobs.
     this.linked = link();
     // This promise is awaited later anyway, so silence
     // 'unhandled rejection' warnings.
-    this.linked.catch(noop);
+    PromisePrototypeCatch(this.linked, noop);
 
-    // instantiated == deep dependency jobs wrappers instantiated,
-    // module wrapper instantiated
+    // instantiated == deep dependency jobs wrappers are instantiated,
+    // and module wrapper is instantiated.
     this.instantiated = undefined;
   }
 
-  async instantiate() {
-    if (!this.instantiated) {
-      return this.instantiated = this._instantiate();
+  instantiate() {
+    if (this.instantiated === undefined) {
+      this.instantiated = this._instantiate();
     }
-    await this.instantiated;
-    return this.module;
+    return this.instantiated;
   }
 
-  // This method instantiates the module associated with this job and its
-  // entire dependency graph, i.e. creates all the module namespaces and the
-  // exported/imported variables.
   async _instantiate() {
     const jobsInGraph = new SafeSet();
-
     const addJobsToDependencyGraph = async (moduleJob) => {
       if (jobsInGraph.has(moduleJob)) {
         return;
       }
       jobsInGraph.add(moduleJob);
       const dependencyJobs = await moduleJob.linked;
-      return PromiseAll(dependencyJobs.map(addJobsToDependencyGraph));
+      return PromiseAll(new SafeArrayIterator(
+        ArrayPrototypeMap(dependencyJobs, addJobsToDependencyGraph)));
     };
     await addJobsToDependencyGraph(this);
+
     try {
       if (!hasPausedEntry && this.inspectBrk) {
         hasPausedEntry = true;
@@ -98,12 +125,22 @@ class ModuleJob {
       }
     } catch (e) {
       decorateErrorStack(e);
-      if (StringPrototypeIncludes(e.message,
+      // TODO(@bcoe): Add source map support to exception that occurs as result
+      // of missing named export. This is currently not possible because
+      // stack trace originates in module_job, not the file itself. A hidden
+      // symbol with filename could be set in node_errors.cc to facilitate this.
+      if (!getSourceMapsEnabled() &&
+          StringPrototypeIncludes(e.message,
                                   ' does not provide an export named')) {
         const splitStack = StringPrototypeSplit(e.stack, '\n');
-        const parentFileUrl = splitStack[0];
-        const [, childSpecifier, name] = StringPrototypeMatch(e.message,
-                                                              /module '(.*)' does not provide an export named '(.+)'/);
+        const parentFileUrl = StringPrototypeReplace(
+          splitStack[0],
+          /:\d+$/,
+          ''
+        );
+        const { 1: childSpecifier, 2: name } = StringPrototypeMatch(
+          e.message,
+          /module '(.*)' does not provide an export named '(.+)'/);
         const childFileURL =
             await this.loader.resolve(childSpecifier, parentFileUrl);
         const format = await this.loader.getFormat(childFileURL);
@@ -111,7 +148,7 @@ class ModuleJob {
           const importStatement = splitStack[1];
           // TODO(@ctavan): The original error stack only provides the single
           // line which causes the error. For multi-line import statements we
-          // cannot generate an equivalent object descructuring assignment by
+          // cannot generate an equivalent object destructuring assignment by
           // just parsing the error stack.
           const oneLineNamedImports = StringPrototypeMatch(importStatement, /{.*}/);
           const destructuringAssignment = oneLineNamedImports &&
@@ -130,19 +167,45 @@ class ModuleJob {
       }
       throw e;
     }
+
     for (const dependencyJob of jobsInGraph) {
       // Calling `this.module.instantiate()` instantiates not only the
       // ModuleWrap in this module, but all modules in the graph.
       dependencyJob.instantiated = resolvedPromise;
     }
-    return this.module;
   }
 
   async run() {
-    const module = await this.instantiate();
+    await this.instantiate();
     const timeout = -1;
     const breakOnSigint = false;
-    return { module, result: module.evaluate(timeout, breakOnSigint) };
+    try {
+      await this.module.evaluate(timeout, breakOnSigint);
+    } catch (e) {
+      if (e?.name === 'ReferenceError' &&
+          isCommonJSGlobalLikeNotDefinedError(e.message)) {
+        e.message += ' in ES module scope';
+
+        if (StringPrototypeStartsWith(e.message, 'require ')) {
+          e.message += ', you can use import instead';
+        }
+
+        const packageConfig =
+          StringPrototypeStartsWith(this.module.url, 'file://') &&
+            RegExpPrototypeTest(/\.js(\?[^#]*)?(#.*)?$/, this.module.url) &&
+            require('internal/modules/esm/resolve')
+              .getPackageScopeConfig(this.module.url);
+        if (packageConfig.type === 'module') {
+          e.message +=
+            '\nThis file is being treated as an ES module because it has a ' +
+            `'.js' file extension and '${packageConfig.pjsonPath}' contains ` +
+            '"type": "module". To treat it as a CommonJS script, rename it ' +
+            'to use the \'.cjs\' file extension.';
+        }
+      }
+      throw e;
+    }
+    return { module: this.module };
   }
 }
 ObjectSetPrototypeOf(ModuleJob.prototype, null);
diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js
index bd07bc5b23694ca5bbe7ec828899608569000aa6..1abc8ee0936da31fdb187ff162c1d8fe101b9550 100644
--- a/lib/internal/modules/esm/resolve.js
+++ b/lib/internal/modules/esm/resolve.js
@@ -30,6 +30,10 @@ const {
   Stats,
 } = require('fs');
 const { getOptionValue } = require('internal/options');
+// Do not eagerly grab .manifest, it may be in TDZ
+const policy = getOptionValue('--experimental-policy') ?
+  require('internal/process/policy') :
+  null;
 const { sep, relative, resolve } = require('path');
 const preserveSymlinks = getOptionValue('--preserve-symlinks');
 const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main');
@@ -41,6 +45,7 @@ const {
   ERR_INVALID_MODULE_SPECIFIER,
   ERR_INVALID_PACKAGE_CONFIG,
   ERR_INVALID_PACKAGE_TARGET,
+  ERR_MANIFEST_DEPENDENCY_MISSING,
   ERR_MODULE_NOT_FOUND,
   ERR_PACKAGE_IMPORT_NOT_DEFINED,
   ERR_PACKAGE_PATH_NOT_EXPORTED,
@@ -54,6 +59,37 @@ const userConditions = getOptionValue('--conditions');
 const DEFAULT_CONDITIONS = ObjectFreeze(['node', 'import', ...userConditions]);
 const DEFAULT_CONDITIONS_SET = new SafeSet(DEFAULT_CONDITIONS);
 
+const pendingDeprecation = getOptionValue('--pending-deprecation');
+
+function emitLegacyIndexDeprecation(url, packageJSONUrl, base, main) {
+  if (!pendingDeprecation)
+    return;
+  const { format } = defaultGetFormat(url);
+  if (format !== 'module')
+    return;
+  const path = fileURLToPath(url);
+  const pkgPath = fileURLToPath(new URL('.', packageJSONUrl));
+  const basePath = fileURLToPath(base);
+  if (main)
+    process.emitWarning(
+      `Package ${pkgPath} has a "main" field set to ${JSONStringify(main)}, ` +
+      `excluding the full filename and extension to the resolved file at "${
+        StringPrototypeSlice(path, pkgPath.length)}", imported from ${
+        basePath}.\n Automatic extension resolution of the "main" field is` +
+      'deprecated for ES modules.',
+      'DeprecationWarning',
+      'DEP0151'
+    );
+  else
+    process.emitWarning(
+      `No "main" or "exports" field defined in the package.json for ${pkgPath
+      } resolving the main entry point "${
+        StringPrototypeSlice(path, pkgPath.length)}", imported from ${basePath
+      }.\nDefault "index" lookups for the main are deprecated for ES modules.`,
+      'DeprecationWarning',
+      'DEP0151'
+    );
+}
 
 function getConditionsSet(conditions) {
   if (conditions !== undefined && conditions !== DEFAULT_CONDITIONS) {
@@ -69,13 +105,8 @@ function getConditionsSet(conditions) {
 const realpathCache = new SafeMap();
 const packageJSONCache = new SafeMap();  /* string -> PackageConfig */
 
-function tryStatSync(path) {
-  try {
-    return statSync(path);
-  } catch {
-    return new Stats();
-  }
-}
+const tryStatSync =
+  (path) => statSync(path, { throwIfNoEntry: false }) ?? new Stats();
 
 function getPackageConfig(path, specifier, base) {
   const existing = packageJSONCache.get(path);
@@ -171,7 +202,7 @@ function getPackageScopeConfig(resolved) {
  * @returns {boolean}
  */
 function fileExists(url) {
-  return tryStatSync(url).isFile();
+  return statSync(url, { throwIfNoEntry: false })?.isFile() ?? false;
 }
 
 function legacyMainResolve(packageJSONUrl, packageConfig, base) {
@@ -181,41 +212,33 @@ function legacyMainResolve(packageJSONUrl, packageConfig, base) {
     if (fileExists(guess = new URL(`./${packageConfig.main}`,
                                    packageJSONUrl))) {
       return guess;
-    }
-    if (fileExists(guess = new URL(`./${packageConfig.main}.js`,
-                                   packageJSONUrl))) {
-      return guess;
-    }
-    if (fileExists(guess = new URL(`./${packageConfig.main}.json`,
-                                   packageJSONUrl))) {
-      return guess;
-    }
-    if (fileExists(guess = new URL(`./${packageConfig.main}.node`,
-                                   packageJSONUrl))) {
-      return guess;
-    }
-    if (fileExists(guess = new URL(`./${packageConfig.main}/index.js`,
-                                   packageJSONUrl))) {
-      return guess;
-    }
-    if (fileExists(guess = new URL(`./${packageConfig.main}/index.json`,
-                                   packageJSONUrl))) {
-      return guess;
-    }
-    if (fileExists(guess = new URL(`./${packageConfig.main}/index.node`,
-                                   packageJSONUrl))) {
+    } else if (fileExists(guess = new URL(`./${packageConfig.main}.js`,
+                                          packageJSONUrl)));
+    else if (fileExists(guess = new URL(`./${packageConfig.main}.json`,
+                                        packageJSONUrl)));
+    else if (fileExists(guess = new URL(`./${packageConfig.main}.node`,
+                                        packageJSONUrl)));
+    else if (fileExists(guess = new URL(`./${packageConfig.main}/index.js`,
+                                        packageJSONUrl)));
+    else if (fileExists(guess = new URL(`./${packageConfig.main}/index.json`,
+                                        packageJSONUrl)));
+    else if (fileExists(guess = new URL(`./${packageConfig.main}/index.node`,
+                                        packageJSONUrl)));
+    else guess = undefined;
+    if (guess) {
+      emitLegacyIndexDeprecation(guess, packageJSONUrl, base,
+                                 packageConfig.main);
       return guess;
     }
     // Fallthrough.
   }
-  if (fileExists(guess = new URL('./index.js', packageJSONUrl))) {
-    return guess;
-  }
+  if (fileExists(guess = new URL('./index.js', packageJSONUrl)));
   // So fs.
-  if (fileExists(guess = new URL('./index.json', packageJSONUrl))) {
-    return guess;
-  }
-  if (fileExists(guess = new URL('./index.node', packageJSONUrl))) {
+  else if (fileExists(guess = new URL('./index.json', packageJSONUrl)));
+  else if (fileExists(guess = new URL('./index.node', packageJSONUrl)));
+  else guess = undefined;
+  if (guess) {
+    emitLegacyIndexDeprecation(guess, packageJSONUrl, base, packageConfig.main);
     return guess;
   }
   // Not found.
@@ -254,7 +277,7 @@ function resolveDirectoryEntry(search) {
   return resolveExtensions(new URL('index', search));
 }
 
-const encodedSepRegEx = /%2F|%2C/i;
+const encodedSepRegEx = /%2F|%5C/i;
 function finalizeResolution(resolved, base) {
   if (RegExpPrototypeTest(encodedSepRegEx, resolved.pathname))
     throw new ERR_INVALID_MODULE_SPECIFIER(
@@ -755,6 +778,27 @@ function resolveAsCommonJS(specifier, parentURL) {
 
 function defaultResolve(specifier, context = {}, defaultResolveUnused) {
   let { parentURL, conditions } = context;
+  if (parentURL && policy?.manifest) {
+    const redirects = policy.manifest.getDependencyMapper(parentURL);
+    if (redirects) {
+      const { resolve, reaction } = redirects;
+      const destination = resolve(specifier, new SafeSet(conditions));
+      let missing = true;
+      if (destination === true) {
+        missing = false;
+      } else if (destination) {
+        const href = destination.href;
+        return { url: href };
+      }
+      if (missing) {
+        reaction(new ERR_MANIFEST_DEPENDENCY_MISSING(
+          parentURL,
+          specifier,
+          ArrayPrototypeJoin([...conditions], ', '))
+        );
+      }
+    }
+  }
   let parsed;
   try {
     parsed = new URL(specifier);
@@ -825,7 +869,8 @@ function defaultResolve(specifier, context = {}, defaultResolveUnused) {
       [internalFS.realpathCacheKey]: realpathCache
     });
     const old = url;
-    url = pathToFileURL(real + (urlPath.endsWith(sep) ? '/' : ''));
+    url = pathToFileURL(
+      real + (StringPrototypeEndsWith(urlPath, sep) ? '/' : ''));
     url.search = old.search;
     url.hash = old.hash;
   }
@@ -837,7 +882,11 @@ module.exports = {
   DEFAULT_CONDITIONS,
   defaultResolve,
   encodedSepRegEx,
+  getPackageScopeConfig,
   getPackageType,
   packageExportsResolve,
   packageImportsResolve
 };
+
+// cycle
+const { defaultGetFormat } = require('internal/modules/esm/get_format');
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 12121f37b48c35b047a581940c00c9c9cfbd7748..70fcc4fb7eb0c75f6633f152308f219fc6f3c084 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -1,10 +1,10 @@
 'use strict';
 
-/* global WebAssembly */
-
 const {
+  ArrayPrototypeMap,
   Boolean,
   JSONParse,
+  ObjectGetPrototypeOf,
   ObjectPrototypeHasOwnProperty,
   ObjectKeys,
   PromisePrototypeCatch,
@@ -13,8 +13,11 @@ const {
   SafeMap,
   SafeSet,
   StringPrototypeReplace,
+  StringPrototypeSlice,
   StringPrototypeSplit,
   StringPrototypeStartsWith,
+  SyntaxErrorPrototype,
+  globalThis: { WebAssembly },
 } = primordials;
 
 let _TYPES = null;
@@ -56,6 +59,8 @@ const { getOptionValue } = require('internal/options');
 const experimentalImportMetaResolve =
     getOptionValue('--experimental-import-meta-resolve');
 const asyncESM = require('internal/process/esm_loader');
+const { emitWarningSync } = require('internal/process/warning');
+const { TextDecoder } = require('internal/encoding');
 
 let cjsParse;
 async function initCJSParse() {
@@ -145,26 +150,25 @@ translators.set('module', async function moduleStrategy(url) {
   return module;
 });
 
-
 function enrichCJSError(err) {
+  if (err == null || ObjectGetPrototypeOf(err) !== SyntaxErrorPrototype) {
+    return;
+  }
   const stack = StringPrototypeSplit(err.stack, '\n');
   /*
-    The regular expression below targets the most common import statement
-    usage. However, some cases are not matching, cases like import statement
-    after a comment block and/or after a variable definition.
+  * The regular expression below targets the most common import statement
+  * usage. However, some cases are not matching, cases like import statement
+  * after a comment block and/or after a variable definition.
   */
   if (StringPrototypeStartsWith(err.message, 'Unexpected token \'export\'') ||
-    (RegExpPrototypeTest(/^\s*import(?=[ {'"*])\s*(?![ (])/, stack[1]))) {
+    RegExpPrototypeTest(/^\s*import(?=[ {'"*])\s*(?![ (])/, stack[1])) {
     // Emit the warning synchronously because we are in the middle of handling
     // a SyntaxError that will throw and likely terminate the process before an
     // asynchronous warning would be emitted.
-    process.emitWarning(
+    emitWarningSync(
       'To load an ES module, set "type": "module" in the package.json or use ' +
-      'the .mjs extension.',
-      undefined,
-      undefined,
-      undefined,
-      true);
+      'the .mjs extension.'
+    );
   }
 }
 
@@ -275,9 +279,9 @@ function cjsPreparseModuleExports(filename) {
 translators.set('builtin', async function builtinStrategy(url) {
   debug(`Translating BuiltinModule ${url}`);
   // Slice 'node:' scheme
-  const id = url.slice(5);
-  const module = loadNativeModule(id, url, true);
-  if (!url.startsWith('node:') || !module) {
+  const id = StringPrototypeSlice(url, 5);
+  const module = loadNativeModule(id, url);
+  if (!StringPrototypeStartsWith(url, 'node:') || !module) {
     throw new ERR_UNKNOWN_BUILTIN_MODULE(url);
   }
   debug(`Loading BuiltinModule ${url}`);
@@ -289,7 +293,8 @@ translators.set('json', async function jsonStrategy(url) {
   emitExperimentalWarning('Importing JSON modules');
   debug(`Translating JSONModule ${url}`);
   debug(`Loading JSONModule ${url}`);
-  const pathname = url.startsWith('file:') ? fileURLToPath(url) : null;
+  const pathname = StringPrototypeStartsWith(url, 'file:') ?
+    fileURLToPath(url) : null;
   let modulePath;
   let module;
   if (pathname) {
@@ -363,8 +368,11 @@ translators.set('wasm', async function(url) {
   }
 
   const imports =
-      WebAssembly.Module.imports(compiled).map(({ module }) => module);
-  const exports = WebAssembly.Module.exports(compiled).map(({ name }) => name);
+      ArrayPrototypeMap(WebAssembly.Module.imports(compiled),
+                        ({ module }) => module);
+  const exports =
+    ArrayPrototypeMap(WebAssembly.Module.exports(compiled),
+                      ({ name }) => name);
 
   return createDynamicModule(imports, exports, url, (reflect) => {
     const { exports } = new WebAssembly.Instance(compiled, reflect.imports);
diff --git a/lib/internal/modules/package_json_reader.js b/lib/internal/modules/package_json_reader.js
index 25edfee027c35baba9d8add054895d0aa48bbafa..4a2b0e6ddb3ed8881f896c6f556c9debaf778b81 100644
--- a/lib/internal/modules/package_json_reader.js
+++ b/lib/internal/modules/package_json_reader.js
@@ -7,6 +7,8 @@ const { toNamespacedPath } = require('path');
 
 const cache = new SafeMap();
 
+let manifest;
+
 /**
  *
  * @param {string} jsonPath
@@ -22,10 +24,12 @@ function read(jsonPath) {
   const result = { string, containsKeys };
   const { getOptionValue } = require('internal/options');
   if (string !== undefined) {
-    const manifest = getOptionValue('--experimental-policy') ?
-      require('internal/process/policy').manifest :
-      null;
-    if (manifest) {
+    if (manifest === undefined) {
+      manifest = getOptionValue('--experimental-policy') ?
+        require('internal/process/policy').manifest :
+        null;
+    }
+    if (manifest !== null) {
       const jsonURL = pathToFileURL(jsonPath);
       manifest.assertIntegrity(jsonURL, string);
     }
diff --git a/lib/internal/modules/run_main.js b/lib/internal/modules/run_main.js
index a94b88f83269faa26a109cbdae95fc215f169ba1..bc6f90ce7d089a68ddbc162d6fac6f88ac495725 100644
--- a/lib/internal/modules/run_main.js
+++ b/lib/internal/modules/run_main.js
@@ -1,5 +1,9 @@
 'use strict';
 
+const {
+  PromisePrototypeFinally,
+  StringPrototypeEndsWith,
+} = primordials;
 const CJSLoader = require('internal/modules/cjs/loader');
 const { Module, toRealPath, readPackageScope } = CJSLoader;
 const { getOptionValue } = require('internal/options');
@@ -24,14 +28,14 @@ function shouldUseESMLoader(mainPath) {
   const userLoader = getOptionValue('--experimental-loader');
   if (userLoader)
     return true;
-  const experimentalSpecifierResolution =
+  const esModuleSpecifierResolution =
     getOptionValue('--experimental-specifier-resolution');
-  if (experimentalSpecifierResolution === 'node')
+  if (esModuleSpecifierResolution === 'node')
     return true;
   // Determine the module format of the main
-  if (mainPath && mainPath.endsWith('.mjs'))
+  if (mainPath && StringPrototypeEndsWith(mainPath, '.mjs'))
     return true;
-  if (!mainPath || mainPath.endsWith('.cjs'))
+  if (!mainPath || StringPrototypeEndsWith(mainPath, '.cjs'))
     return false;
   const pkg = readPackageScope(mainPath);
   return pkg && pkg.data.type === 'module';
@@ -40,11 +44,23 @@ function shouldUseESMLoader(mainPath) {
 function runMainESM(mainPath) {
   const esmLoader = require('internal/process/esm_loader');
   const { pathToFileURL } = require('internal/url');
-  esmLoader.loadESM((ESMLoader) => {
+  handleMainPromise(esmLoader.loadESM((ESMLoader) => {
     const main = path.isAbsolute(mainPath) ?
       pathToFileURL(mainPath).href : mainPath;
     return ESMLoader.import(main);
-  });
+  }));
+}
+
+function handleMainPromise(promise) {
+  // Handle a Promise from running code that potentially does Top-Level Await.
+  // In that case, it makes sense to set the exit code to a specific non-zero
+  // value if the main code never finishes running.
+  function handler() {
+    if (process.exitCode === undefined)
+      process.exitCode = 13;
+  }
+  process.on('exit', handler);
+  return PromisePrototypeFinally(promise, () => process.off('exit', handler));
 }
 
 // For backwards compatibility, we have to run a bunch of
@@ -62,5 +78,6 @@ function executeUserEntryPoint(main = process.argv[1]) {
 }
 
 module.exports = {
-  executeUserEntryPoint
+  executeUserEntryPoint,
+  handleMainPromise,
 };
diff --git a/lib/internal/net.js b/lib/internal/net.js
index db85dc91e66d6fea2f5033af7099102e16ed9ac5..8ae3170228dc32d6c7d56a044032b831bfedd3ea 100644
--- a/lib/internal/net.js
+++ b/lib/internal/net.js
@@ -2,6 +2,7 @@
 
 const {
   RegExp,
+  RegExpPrototypeTest,
   Symbol,
 } = primordials;
 
@@ -28,11 +29,11 @@ const IPv6Reg = new RegExp('^(' +
 ')(%[0-9a-zA-Z-.:]{1,})?$');
 
 function isIPv4(s) {
-  return IPv4Reg.test(s);
+  return RegExpPrototypeTest(IPv4Reg, s);
 }
 
 function isIPv6(s) {
-  return IPv6Reg.test(s);
+  return RegExpPrototypeTest(IPv6Reg, s);
 }
 
 function isIP(s) {
@@ -52,9 +53,7 @@ function makeSyncWrite(fd) {
     writeBuffer(fd, chunk, 0, chunk.length, null, undefined, ctx);
     if (ctx.errno !== undefined) {
       const ex = errors.uvException(ctx);
-      // Legacy: net writes have .code === .errno, whereas writeBuffer gives the
-      // raw errno number in .errno.
-      ex.errno = ex.code;
+      ex.errno = ctx.errno;
       return cb(ex);
     }
     cb();
diff --git a/lib/internal/options.js b/lib/internal/options.js
index 10c6aa2d9a0978abcde10477276be6f7a0404219..aa9c52e6988d65dcc2950b3fffce2ba0e1488cec 100644
--- a/lib/internal/options.js
+++ b/lib/internal/options.js
@@ -1,16 +1,37 @@
 'use strict';
 
 const { getOptions, shouldNotRegisterESMLoader } = internalBinding('options');
-const { options, aliases } = getOptions();
 
 let warnOnAllowUnauthorized = true;
 
-function getOptionValue(option) {
-  const result = options.get(option);
-  if (!result) {
-    return undefined;
+let optionsMap;
+let aliasesMap;
+
+// getOptions() would serialize the option values from C++ land.
+// It would error if the values are queried before bootstrap is
+// complete so that we don't accidentally include runtime-dependent
+// states into a runtime-independent snapshot.
+function getOptionsFromBinding() {
+  if (!optionsMap) {
+    ({ options: optionsMap } = getOptions());
+  }
+  return optionsMap;
+}
+
+function getAliasesFromBinding() {
+  if (!aliasesMap) {
+    ({ aliases: aliasesMap } = getOptions());
+  }
+  return aliasesMap;
+}
+
+function getOptionValue(optionName) {
+  const options = getOptionsFromBinding();
+  if (optionName.startsWith('--no-')) {
+    const option = options.get('--' + optionName.slice(5));
+    return option && !option.value;
   }
-  return result.value;
+  return options.get(optionName)?.value;
 }
 
 function getAllowUnauthorized() {
@@ -28,8 +49,12 @@ function getAllowUnauthorized() {
 }
 
 module.exports = {
-  options,
-  aliases,
+  get options() {
+    return getOptionsFromBinding();
+  },
+  get aliases() {
+    return getAliasesFromBinding();
+  },
   getOptionValue,
   getAllowUnauthorized,
   shouldNotRegisterESMLoader
diff --git a/lib/internal/per_context/domexception.js b/lib/internal/per_context/domexception.js
index c6d6370c5547cd8feb54f25503f039c3d28df332..06bb3fa3053cd56307e4f9cbe45633ab89148bc9 100644
--- a/lib/internal/per_context/domexception.js
+++ b/lib/internal/per_context/domexception.js
@@ -7,6 +7,7 @@ const {
   SafeWeakMap,
   SafeMap,
   SymbolToStringTag,
+  TypeError,
 } = primordials;
 
 class ERR_INVALID_THIS extends TypeError {
diff --git a/lib/internal/per_context/messageport.js b/lib/internal/per_context/messageport.js
index ee08a596122a51fbe91afe44f83ad79beb36f394..43587319b040de955198dc0fe0f5af074d5ac3fa 100644
--- a/lib/internal/per_context/messageport.js
+++ b/lib/internal/per_context/messageport.js
@@ -1,12 +1,31 @@
 'use strict';
+const {
+  SymbolFor,
+} = primordials;
+
 class MessageEvent {
-  constructor(data, target) {
+  constructor(data, target, type) {
     this.data = data;
     this.target = target;
+    this.type = type;
   }
 }
 
-exports.emitMessage = function(data) {
-  if (typeof this.onmessage === 'function')
-    this.onmessage(new MessageEvent(data, this));
+const kHybridDispatch = SymbolFor('nodejs.internal.kHybridDispatch');
+
+exports.emitMessage = function(data, type) {
+  if (typeof this[kHybridDispatch] === 'function') {
+    this[kHybridDispatch](data, type, undefined);
+    return;
+  }
+
+  const event = new MessageEvent(data, this, type);
+  if (type === 'message') {
+    if (typeof this.onmessage === 'function')
+      this.onmessage(event);
+  } else {
+    // eslint-disable-next-line no-lonely-if
+    if (typeof this.onmessageerror === 'function')
+      this.onmessageerror(event);
+  }
 };
diff --git a/lib/internal/per_context/primordials.js b/lib/internal/per_context/primordials.js
index 6a960f36feda455fa8f956965d73a567f90d0e0d..b3663c7c60b1bb458b747306a2874f4f1ddcfbe8 100644
--- a/lib/internal/per_context/primordials.js
+++ b/lib/internal/per_context/primordials.js
@@ -1,110 +1,148 @@
 'use strict';
 
-/* eslint-disable no-restricted-globals */
+/* eslint-disable node-core/prefer-primordials */
 
 // This file subclasses and stores the JS builtins that come from the VM
 // so that Node.js's builtin modules do not need to later look these up from
 // the global proxy, which can be mutated by users.
 
-// TODO(joyeecheung): we can restrict access to these globals in builtin
-// modules through the JS linter, for example: ban access such as `Object`
-// (which falls back to a lookup in the global proxy) in favor of
-// `primordials.Object` where `primordials` is a lexical variable passed
-// by the native module compiler.
-
-const ReflectApply = Reflect.apply;
-
-// This function is borrowed from the function with the same name on V8 Extras'
-// `utils` object. V8 implements Reflect.apply very efficiently in conjunction
-// with the spread syntax, such that no additional special case is needed for
-// function calls w/o arguments.
-// Refs: https://github.com/v8/v8/blob/d6ead37d265d7215cf9c5f768f279e21bd170212/src/js/prologue.js#L152-L156
-function uncurryThis(func) {
-  return (thisArg, ...args) => ReflectApply(func, thisArg, args);
-}
+// Use of primordials have sometimes a dramatic impact on performance, please
+// benchmark all changes made in performance-sensitive areas of the codebase.
+// See: https://github.com/nodejs/node/pull/38248
+
+const {
+  defineProperty: ReflectDefineProperty,
+  getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
+  ownKeys: ReflectOwnKeys,
+} = Reflect;
 
+// `uncurryThis` is equivalent to `func => Function.prototype.call.bind(func)`.
+// It is using `bind.bind(call)` to avoid using `Function.prototype.bind`
+// and `Function.prototype.call` after it may have been mutated by users.
+const { apply, bind, call } = Function.prototype;
+const uncurryThis = bind.bind(call);
 primordials.uncurryThis = uncurryThis;
 
-function copyProps(src, dest) {
-  for (const key of Reflect.ownKeys(src)) {
-    if (!Reflect.getOwnPropertyDescriptor(dest, key)) {
-      Reflect.defineProperty(
-        dest,
-        key,
-        Reflect.getOwnPropertyDescriptor(src, key));
-    }
+// `applyBind` is equivalent to `func => Function.prototype.apply.bind(func)`.
+// It is using `bind.bind(apply)` to avoid using `Function.prototype.bind`
+// and `Function.prototype.apply` after it may have been mutated by users.
+const applyBind = bind.bind(apply);
+primordials.applyBind = applyBind;
+
+// Methods that accept a variable number of arguments, and thus it's useful to
+// also create `${prefix}${key}Apply`, which uses `Function.prototype.apply`,
+// instead of `Function.prototype.call`, and thus doesn't require iterator
+// destructuring.
+const varargsMethods = [
+  // 'ArrayPrototypeConcat' is omitted, because it performs the spread
+  // on its own for arrays and array-likes with a truthy
+  // @@isConcatSpreadable symbol property.
+  'ArrayOf',
+  'ArrayPrototypePush',
+  'ArrayPrototypeUnshift',
+  // 'FunctionPrototypeCall' is omitted, since there's 'ReflectApply'
+  // and 'FunctionPrototypeApply'.
+  'MathHypot',
+  'MathMax',
+  'MathMin',
+  'StringPrototypeConcat',
+  'TypedArrayOf',
+];
+
+function getNewKey(key) {
+  return typeof key === 'symbol' ?
+    `Symbol${key.description[7].toUpperCase()}${key.description.slice(8)}` :
+    `${key[0].toUpperCase()}${key.slice(1)}`;
+}
+
+function copyAccessor(dest, prefix, key, { enumerable, get, set }) {
+  ReflectDefineProperty(dest, `${prefix}Get${key}`, {
+    value: uncurryThis(get),
+    enumerable
+  });
+  if (set !== undefined) {
+    ReflectDefineProperty(dest, `${prefix}Set${key}`, {
+      value: uncurryThis(set),
+      enumerable
+    });
   }
 }
 
 function copyPropsRenamed(src, dest, prefix) {
-  for (const key of Reflect.ownKeys(src)) {
-    if (typeof key === 'string') {
-      Reflect.defineProperty(
-        dest,
-        `${prefix}${key[0].toUpperCase()}${key.slice(1)}`,
-        Reflect.getOwnPropertyDescriptor(src, key));
+  for (const key of ReflectOwnKeys(src)) {
+    const newKey = getNewKey(key);
+    const desc = ReflectGetOwnPropertyDescriptor(src, key);
+    if ('get' in desc) {
+      copyAccessor(dest, prefix, newKey, desc);
+    } else {
+      const name = `${prefix}${newKey}`;
+      ReflectDefineProperty(dest, name, desc);
+      if (varargsMethods.includes(name)) {
+        ReflectDefineProperty(dest, `${name}Apply`, {
+          // `src` is bound as the `this` so that the static `this` points
+          // to the object it was defined on,
+          // e.g.: `ArrayOfApply` gets a `this` of `Array`:
+          value: applyBind(desc.value, src),
+        });
+      }
     }
   }
 }
 
 function copyPropsRenamedBound(src, dest, prefix) {
-  for (const key of Reflect.ownKeys(src)) {
-    if (typeof key === 'string') {
-      const desc = Reflect.getOwnPropertyDescriptor(src, key);
-      if (typeof desc.value === 'function') {
-        desc.value = desc.value.bind(src);
+  for (const key of ReflectOwnKeys(src)) {
+    const newKey = getNewKey(key);
+    const desc = ReflectGetOwnPropertyDescriptor(src, key);
+    if ('get' in desc) {
+      copyAccessor(dest, prefix, newKey, desc);
+    } else {
+      const { value } = desc;
+      if (typeof value === 'function') {
+        desc.value = value.bind(src);
+      }
+
+      const name = `${prefix}${newKey}`;
+      ReflectDefineProperty(dest, name, desc);
+      if (varargsMethods.includes(name)) {
+        ReflectDefineProperty(dest, `${name}Apply`, {
+          value: applyBind(value, src),
+        });
       }
-      Reflect.defineProperty(
-        dest,
-        `${prefix}${key[0].toUpperCase()}${key.slice(1)}`,
-        desc
-      );
     }
   }
 }
 
 function copyPrototype(src, dest, prefix) {
-  for (const key of Reflect.ownKeys(src)) {
-    if (typeof key === 'string') {
-      const desc = Reflect.getOwnPropertyDescriptor(src, key);
-      if (typeof desc.value === 'function') {
-        desc.value = uncurryThis(desc.value);
+  for (const key of ReflectOwnKeys(src)) {
+    const newKey = getNewKey(key);
+    const desc = ReflectGetOwnPropertyDescriptor(src, key);
+    if ('get' in desc) {
+      copyAccessor(dest, prefix, newKey, desc);
+    } else {
+      const { value } = desc;
+      if (typeof value === 'function') {
+        desc.value = uncurryThis(value);
+      }
+
+      const name = `${prefix}${newKey}`;
+      ReflectDefineProperty(dest, name, desc);
+      if (varargsMethods.includes(name)) {
+        ReflectDefineProperty(dest, `${name}Apply`, {
+          value: applyBind(value),
+        });
       }
-      Reflect.defineProperty(
-        dest,
-        `${prefix}${key[0].toUpperCase()}${key.slice(1)}`,
-        desc);
     }
   }
 }
 
-function makeSafe(unsafe, safe) {
-  copyProps(unsafe.prototype, safe.prototype);
-  copyProps(unsafe, safe);
-  Object.setPrototypeOf(safe.prototype, null);
-  Object.freeze(safe.prototype);
-  Object.freeze(safe);
-  return safe;
-}
-
-// Subclass the constructors because we need to use their prototype
-// methods later.
-primordials.SafeMap = makeSafe(
-  Map,
-  class SafeMap extends Map {}
-);
-primordials.SafeWeakMap = makeSafe(
-  WeakMap,
-  class SafeWeakMap extends WeakMap {}
-);
-primordials.SafeSet = makeSafe(
-  Set,
-  class SafeSet extends Set {}
-);
-primordials.SafePromise = makeSafe(
-  Promise,
-  class SafePromise extends Promise {}
-);
+// Create copies of configurable value properties of the global object
+[
+  'Proxy',
+  'globalThis',
+].forEach((name) => {
+  // eslint-disable-next-line no-restricted-globals
+  primordials[name] = globalThis[name];
+});
 
 // Create copies of URI handling functions
 [
@@ -120,8 +158,10 @@ primordials.SafePromise = makeSafe(
 [
   'JSON',
   'Math',
-  'Reflect'
+  'Proxy',
+  'Reflect',
 ].forEach((name) => {
+  // eslint-disable-next-line no-restricted-globals
   copyPropsRenamed(global[name], primordials, name);
 });
 
@@ -133,8 +173,10 @@ primordials.SafePromise = makeSafe(
   'BigInt64Array',
   'BigUint64Array',
   'Boolean',
+  'DataView',
   'Date',
   'Error',
+  'EvalError',
   'Float32Array',
   'Float64Array',
   'Function',
@@ -144,10 +186,15 @@ primordials.SafePromise = makeSafe(
   'Map',
   'Number',
   'Object',
+  'RangeError',
+  'ReferenceError',
   'RegExp',
   'Set',
   'String',
   'Symbol',
+  'SyntaxError',
+  'TypeError',
+  'URIError',
   'Uint16Array',
   'Uint32Array',
   'Uint8Array',
@@ -155,6 +202,7 @@ primordials.SafePromise = makeSafe(
   'WeakMap',
   'WeakSet',
 ].forEach((name) => {
+  // eslint-disable-next-line no-restricted-globals
   const original = global[name];
   primordials[name] = original;
   copyPropsRenamed(original, primordials, name);
@@ -167,11 +215,150 @@ primordials.SafePromise = makeSafe(
 [
   'Promise',
 ].forEach((name) => {
+  // eslint-disable-next-line no-restricted-globals
   const original = global[name];
   primordials[name] = original;
   copyPropsRenamedBound(original, primordials, name);
   copyPrototype(original.prototype, primordials, `${name}Prototype`);
 });
 
-Object.setPrototypeOf(primordials, null);
-Object.freeze(primordials);
+// Create copies of abstract intrinsic objects that are not directly exposed
+// on the global object.
+// Refs: https://tc39.es/ecma262/#sec-%typedarray%-intrinsic-object
+[
+  { name: 'TypedArray', original: Reflect.getPrototypeOf(Uint8Array) },
+  { name: 'ArrayIterator', original: {
+    prototype: Reflect.getPrototypeOf(Array.prototype[Symbol.iterator]()),
+  } },
+  { name: 'StringIterator', original: {
+    prototype: Reflect.getPrototypeOf(String.prototype[Symbol.iterator]()),
+  } },
+].forEach(({ name, original }) => {
+  primordials[name] = original;
+  // The static %TypedArray% methods require a valid `this`, but can't be bound,
+  // as they need a subclass constructor as the receiver:
+  copyPrototype(original, primordials, name);
+  copyPrototype(original.prototype, primordials, `${name}Prototype`);
+});
+
+/* eslint-enable node-core/prefer-primordials */
+
+const {
+  ArrayPrototypeForEach,
+  FunctionPrototypeCall,
+  Map,
+  ObjectFreeze,
+  ObjectSetPrototypeOf,
+  Set,
+  SymbolIterator,
+  WeakMap,
+  WeakSet,
+} = primordials;
+
+// Because these functions are used by `makeSafe`, which is exposed
+// on the `primordials` object, it's important to use const references
+// to the primordials that they use:
+const createSafeIterator = (factory, next) => {
+  class SafeIterator {
+    constructor(iterable) {
+      this._iterator = factory(iterable);
+    }
+    next() {
+      return next(this._iterator);
+    }
+    [SymbolIterator]() {
+      return this;
+    }
+  }
+  ObjectSetPrototypeOf(SafeIterator.prototype, null);
+  ObjectFreeze(SafeIterator.prototype);
+  ObjectFreeze(SafeIterator);
+  return SafeIterator;
+};
+
+primordials.SafeArrayIterator = createSafeIterator(
+  primordials.ArrayPrototypeSymbolIterator,
+  primordials.ArrayIteratorPrototypeNext
+);
+primordials.SafeStringIterator = createSafeIterator(
+  primordials.StringPrototypeSymbolIterator,
+  primordials.StringIteratorPrototypeNext
+);
+
+const copyProps = (src, dest) => {
+  ArrayPrototypeForEach(ReflectOwnKeys(src), (key) => {
+    if (!ReflectGetOwnPropertyDescriptor(dest, key)) {
+      ReflectDefineProperty(
+        dest,
+        key,
+        ReflectGetOwnPropertyDescriptor(src, key));
+    }
+  });
+};
+
+const makeSafe = (unsafe, safe) => {
+  if (SymbolIterator in unsafe.prototype) {
+    const dummy = new unsafe();
+    let next; // We can reuse the same `next` method.
+
+    ArrayPrototypeForEach(ReflectOwnKeys(unsafe.prototype), (key) => {
+      if (!ReflectGetOwnPropertyDescriptor(safe.prototype, key)) {
+        const desc = ReflectGetOwnPropertyDescriptor(unsafe.prototype, key);
+        if (
+          typeof desc.value === 'function' &&
+          desc.value.length === 0 &&
+          SymbolIterator in (FunctionPrototypeCall(desc.value, dummy) ?? {})
+        ) {
+          const createIterator = uncurryThis(desc.value);
+          next = next ?? uncurryThis(createIterator(dummy).next);
+          const SafeIterator = createSafeIterator(createIterator, next);
+          desc.value = function() {
+            return new SafeIterator(this);
+          };
+        }
+        ReflectDefineProperty(safe.prototype, key, desc);
+      }
+    });
+  } else {
+    copyProps(unsafe.prototype, safe.prototype);
+  }
+  copyProps(unsafe, safe);
+
+  ObjectSetPrototypeOf(safe.prototype, null);
+  ObjectFreeze(safe.prototype);
+  ObjectFreeze(safe);
+  return safe;
+};
+primordials.makeSafe = makeSafe;
+
+// Subclass the constructors because we need to use their prototype
+// methods later.
+// Defining the `constructor` is necessary here to avoid the default
+// constructor which uses the user-mutable `%ArrayIteratorPrototype%.next`.
+primordials.SafeMap = makeSafe(
+  Map,
+  class SafeMap extends Map {
+    constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
+  }
+);
+primordials.SafeWeakMap = makeSafe(
+  WeakMap,
+  class SafeWeakMap extends WeakMap {
+    constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
+  }
+);
+primordials.SafeSet = makeSafe(
+  Set,
+  class SafeSet extends Set {
+    constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
+  }
+);
+primordials.SafeWeakSet = makeSafe(
+  WeakSet,
+  class SafeWeakSet extends WeakSet {
+    constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
+  }
+);
+
+ObjectSetPrototypeOf(primordials, null);
+ObjectFreeze(primordials);
diff --git a/lib/internal/policy/manifest.js b/lib/internal/policy/manifest.js
index 0531f198f2197180b2b53493801334c974430476..42ff63e87dc9cfe6d2dc93806c7990d049409325 100644
--- a/lib/internal/policy/manifest.js
+++ b/lib/internal/policy/manifest.js
@@ -1,25 +1,27 @@
 'use strict';
 
+// #region imports
 const {
   ArrayIsArray,
-  Map,
-  MapPrototypeSet,
+  ArrayPrototypeSort,
   ObjectCreate,
   ObjectEntries,
   ObjectFreeze,
+  ObjectKeys,
   ObjectSetPrototypeOf,
+  RegExpPrototypeExec,
   RegExpPrototypeTest,
   SafeMap,
+  SafeSet,
+  StringPrototypeEndsWith,
+  StringPrototypeReplace,
+  Symbol,
   uncurryThis,
 } = primordials;
-const {
-  canBeRequiredByUsers
-} = require('internal/bootstrap/loaders').NativeModule;
-
 const {
   ERR_MANIFEST_ASSERT_INTEGRITY,
-  ERR_MANIFEST_INTEGRITY_MISMATCH,
   ERR_MANIFEST_INVALID_RESOURCE_FIELD,
+  ERR_MANIFEST_INVALID_SPECIFIER,
   ERR_MANIFEST_UNKNOWN_ONERROR,
 } = require('internal/errors').codes;
 let debug = require('internal/util/debuglog').debuglog('policy', (fn) => {
@@ -35,9 +37,31 @@ const HashDigest = uncurryThis(crypto.Hash.prototype.digest);
 const BufferToString = uncurryThis(Buffer.prototype.toString);
 const kRelativeURLStringPattern = /^\.{0,2}\//;
 const { getOptionValue } = require('internal/options');
-const shouldAbortOnUncaughtException =
-  getOptionValue('--abort-on-uncaught-exception');
+const shouldAbortOnUncaughtException = getOptionValue(
+  '--abort-on-uncaught-exception'
+);
 const { abort, exit, _rawDebug } = process;
+// #endregion
+
+// #region constants
+// From https://url.spec.whatwg.org/#special-scheme
+const kSpecialSchemes = new SafeSet([
+  'file:',
+  'ftp:',
+  'http:',
+  'https:',
+  'ws:',
+  'wss:',
+]);
+
+/**
+ * @type {symbol}
+ */
+const kCascade = Symbol('cascade');
+/**
+ * @type {symbol}
+ */
+const kFallThrough = Symbol('fall through');
 
 function REACTION_THROW(error) {
   throw error;
@@ -55,9 +79,307 @@ function REACTION_LOG(error) {
   _rawDebug(error.stack);
 }
 
+// #endregion
+
+// #region DependencyMapperInstance
+class DependencyMapperInstance {
+  /**
+   * @type {string}
+   */
+  href;
+  /**
+   * @type {DependencyMap | undefined}
+   */
+  #dependencies;
+  /**
+   * @type {PatternDependencyMap | undefined}
+   */
+  #patternDependencies;
+  /**
+   * @type {DependencyMapperInstance | null | undefined}
+   */
+  #parentDependencyMapper;
+  /**
+   * @type {boolean}
+   */
+  #normalized = false;
+  /**
+   * @type {boolean}
+   */
+  cascade;
+  /**
+   * @type {boolean}
+   */
+  allowSameHREFScope;
+  /**
+   * @param {string} parentHREF
+   * @param {DependencyMap | undefined} dependencies
+   * @param {boolean} cascade
+   * @param {boolean} allowSameHREFScope
+   */
+  constructor(
+    parentHREF,
+    dependencies,
+    cascade = false,
+    allowSameHREFScope = false) {
+    this.href = parentHREF;
+    if (dependencies === kFallThrough ||
+        dependencies === undefined ||
+        dependencies === null) {
+      this.#dependencies = dependencies;
+      this.#patternDependencies = undefined;
+    } else {
+      const patterns = [];
+      for (const { 0: key } of ObjectEntries(dependencies)) {
+        if (StringPrototypeEndsWith(key, '*')) {
+          const target = RegExpPrototypeExec(/^([^*]*)\*([^*]*)$/);
+          if (!target) {
+            throw new ERR_MANIFEST_INVALID_SPECIFIER(
+              this.href,
+              target +
+                ', pattern needs to have a single' +
+                'trailing "*" in target');
+          }
+          const prefix = target[1];
+          const suffix = target[2];
+          patterns.push([
+            target.slice(0, -1),
+            [prefix, suffix],
+          ]);
+        }
+      }
+      ArrayPrototypeSort(patterns, (a, b) => {
+        return a[0] < b[0] ? -1 : 1;
+      });
+      this.#dependencies = dependencies;
+      this.#patternDependencies = patterns;
+    }
+    this.cascade = cascade;
+    this.allowSameHREFScope = allowSameHREFScope;
+    ObjectFreeze(this);
+  }
+  /**
+   *
+   * @param {string} normalizedSpecifier
+   * @param {Set<string>} conditions
+   * @param {Manifest} manifest
+   * @returns {URL | typeof kFallThrough | null}
+   */
+  _resolveAlreadyNormalized(normalizedSpecifier, conditions, manifest) {
+    let dependencies = this.#dependencies;
+    debug(this.href, 'resolving', normalizedSpecifier);
+    if (dependencies === kFallThrough) return true;
+    if (dependencies !== undefined && typeof dependencies === 'object') {
+      const normalized = this.#normalized;
+      if (normalized !== true) {
+        /**
+         * @type {Record<string, string>}
+         */
+        const normalizedDependencyMap = ObjectCreate(null);
+        for (let specifier in dependencies) {
+          const target = dependencies[specifier];
+          specifier = canonicalizeSpecifier(specifier, manifest.href);
+          normalizedDependencyMap[specifier] = target;
+        }
+        ObjectFreeze(normalizedDependencyMap);
+        dependencies = normalizedDependencyMap;
+        this.#dependencies = normalizedDependencyMap;
+        this.#normalized = true;
+      }
+      debug(dependencies);
+      if (normalizedSpecifier in dependencies === true) {
+        const to = searchDependencies(
+          this.href,
+          dependencies[normalizedSpecifier],
+          conditions
+        );
+        debug({ to });
+        if (to === true) {
+          return true;
+        }
+        let ret;
+        if (parsedURLs && parsedURLs.has(to)) {
+          ret = parsedURLs.get(to);
+        } else if (RegExpPrototypeTest(kRelativeURLStringPattern, to)) {
+          ret = resolve(to, manifest.href);
+        } else {
+          ret = resolve(to);
+        }
+        return ret;
+      }
+    }
+    const { cascade } = this;
+    if (cascade !== true) {
+      return null;
+    }
+    let parentDependencyMapper = this.#parentDependencyMapper;
+    if (parentDependencyMapper === undefined) {
+      parentDependencyMapper = manifest.getScopeDependencyMapper(
+        this.href,
+        this.allowSameHREFScope
+      );
+      this.#parentDependencyMapper = parentDependencyMapper;
+    }
+    if (parentDependencyMapper === null) {
+      return null;
+    }
+    return parentDependencyMapper._resolveAlreadyNormalized(
+      normalizedSpecifier,
+      conditions,
+      manifest
+    );
+  }
+}
+
+const kArbitraryDependencies = new DependencyMapperInstance(
+  'arbitrary dependencies',
+  kFallThrough,
+  false,
+  true
+);
+const kNoDependencies = new DependencyMapperInstance(
+  'no dependencies',
+  null,
+  false,
+  true
+);
+/**
+ * @param {string} href
+ * @param {JSONDependencyMap} dependencies
+ * @param {boolean} cascade
+ * @param {Map<string | null | undefined, DependencyMapperInstance>} store
+ */
+const insertDependencyMap = (
+  href,
+  dependencies,
+  cascade,
+  allowSameHREFScope,
+  store
+) => {
+  if (cascade !== undefined && typeof cascade !== 'boolean') {
+    throw new ERR_MANIFEST_INVALID_RESOURCE_FIELD(href, 'cascade');
+  }
+  if (dependencies === true) {
+    store.set(href, kArbitraryDependencies);
+    return;
+  }
+  if (dependencies === null || dependencies === undefined) {
+    store.set(
+      href,
+      cascade ?
+        new DependencyMapperInstance(href, null, true, allowSameHREFScope) :
+        kNoDependencies
+    );
+    return;
+  }
+  if (objectButNotArray(dependencies)) {
+    store.set(
+      href,
+      new DependencyMapperInstance(
+        href,
+        dependencies,
+        cascade,
+        allowSameHREFScope
+      )
+    );
+    return;
+  }
+  throw new ERR_MANIFEST_INVALID_RESOURCE_FIELD(href, 'dependencies');
+};
+/**
+ * Finds the longest key within `this.#scopeDependencies` that covers a
+ * specific HREF
+ * @param {string} href
+ * @param {ScopeStore} scopeStore
+ * @returns {null | string}
+ */
+function findScopeHREF(href, scopeStore, allowSame) {
+  let protocol;
+  if (href !== '') {
+    // default URL parser does some stuff to special urls... skip if this is
+    // just the protocol
+    if (RegExpPrototypeTest(/^[^:]*[:]$/, href)) {
+      protocol = href;
+    } else {
+      let currentURL = new URL(href);
+      const normalizedHREF = currentURL.href;
+      protocol = currentURL.protocol;
+      // Non-opaque blobs adopt origins
+      if (protocol === 'blob:' && currentURL.origin !== 'null') {
+        currentURL = new URL(currentURL.origin);
+        protocol = currentURL.protocol;
+      }
+      // Only a few schemes are hierarchical
+      if (kSpecialSchemes.has(currentURL.protocol)) {
+        // Make first '..' act like '.'
+        if (!StringPrototypeEndsWith(currentURL.pathname, '/')) {
+          currentURL.pathname += '/';
+        }
+        let lastHREF;
+        let currentHREF = currentURL.href;
+        do {
+          if (scopeStore.has(currentHREF)) {
+            if (allowSame || currentHREF !== normalizedHREF) {
+              return currentHREF;
+            }
+          }
+          lastHREF = currentHREF;
+          currentURL = new URL('..', currentURL);
+          currentHREF = currentURL.href;
+        } while (lastHREF !== currentHREF);
+      }
+    }
+  }
+  if (scopeStore.has(protocol)) {
+    if (allowSame || protocol !== href) return protocol;
+  }
+  if (scopeStore.has('')) {
+    if (allowSame || '' !== href) return '';
+  }
+  return null;
+}
+// #endregion
+
+/**
+ * @typedef {Record<string, string> | typeof kFallThrough} DependencyMap
+ * @typedef {Array<[string, [string, string]]>} PatternDependencyMap
+ * @typedef {Record<string, string> | null | true} JSONDependencyMap
+ */
+/**
+ * @typedef {Map<string, any>} ScopeStore
+ * @typedef {(specifier: string) => true | URL} DependencyMapper
+ * @typedef {boolean | string | SRI[] | typeof kCascade} Integrity
+ */
+
 class Manifest {
+  #defaultDependencies;
+  /**
+   * @type {string}
+   */
+  href;
   /**
-   * @type {Map<string, true | string | SRI[]>}
+   * @type {(err: Error) => void}
+   *
+   * Performs default action for what happens when a manifest encounters
+   * a violation such as abort()ing or exiting the process, throwing the error,
+   * or logging the error.
+   */
+  #reaction;
+  /**
+   * @type {Map<string, DependencyMapperInstance>}
+   *
+   * Used to find where a dependency is located.
+   *
+   * This stores functions to lazily calculate locations as needed.
+   * `true` is used to signify that the location is not specified
+   * by the manifest and default resolution should be allowed.
+   *
+   * The functions return `null` to signify that a dependency is
+   * not found
+   */
+  #resourceDependencies = new SafeMap();
+  /**
+   * @type {Map<string, Integrity>}
    *
    * Used to compare a resource to the content body at the resource.
    * `true` is used to signify that all integrities are allowed, otherwise,
@@ -68,25 +390,25 @@ class Manifest {
    * This avoids needing to parse all SRI strings at startup even
    * if some never end up being used.
    */
-  #integrities = new SafeMap();
+  #resourceIntegrities = new SafeMap();
   /**
-   * @type {Map<string, (specifier: string) => true | URL>}
+   * @type {ScopeStore}
    *
-   * Used to find where a dependency is located.
+   * Used to compare a resource to the content body at the resource.
+   * `true` is used to signify that all integrities are allowed, otherwise,
+   * SRI strings are parsed to compare with the body.
    *
-   * This stores functions to lazily calculate locations as needed.
-   * `true` is used to signify that the location is not specified
-   * by the manifest and default resolution should be allowed.
+   * Separate from #resourceDependencies due to conflicts with things like
+   * `blob:` being both a scope and a resource potentially as well as
+   * `file:` being parsed to `file:///` instead of remaining host neutral.
    */
-  #dependencies = new SafeMap();
+  #scopeDependencies = new SafeMap();
   /**
-   * @type {(err: Error) => void}
+   * @type {Map<string, boolean | null | typeof kCascade>}
    *
-   * Performs default action for what happens when a manifest encounters
-   * a violation such as abort()ing or exiting the process, throwing the error,
-   * or logging the error.
+   * Used to allow arbitrary loading within a scope
    */
-  #reaction = null;
+  #scopeIntegrities = new SafeMap();
   /**
    * `obj` should match the policy file format described in the docs
    * it is expected to not have prototype pollution issues either by reassigning
@@ -95,14 +417,16 @@ class Manifest {
    * `manifestURL` is a URL to resolve relative locations against.
    *
    * @param {object} obj
-   * @param {string} manifestURL
+   * @param {string} manifestHREF
    */
-  constructor(obj, manifestURL) {
-    const integrities = this.#integrities;
-    const dependencies = this.#dependencies;
+  constructor(obj, manifestHREF) {
+    this.href = manifestHREF;
+    const scopes = this.#scopeDependencies;
+    const integrities = this.#resourceIntegrities;
+    const resourceDependencies = this.#resourceDependencies;
     let reaction = REACTION_THROW;
 
-    if (obj.onerror) {
+    if (objectButNotArray(obj) && 'onerror' in obj) {
       const behavior = obj.onerror;
       if (behavior === 'throw') {
       } else if (behavior === 'exit') {
@@ -115,113 +439,104 @@ class Manifest {
     }
 
     this.#reaction = reaction;
-    const manifestEntries = ObjectEntries(obj.resources);
+    const jsonResourcesEntries = ObjectEntries(
+      obj.resources ?? ObjectCreate(null)
+    );
+    const jsonScopesEntries = ObjectEntries(obj.scopes ?? ObjectCreate(null));
+    const defaultDependencies = obj.dependencies ?? ObjectCreate(null);
 
-    const parsedURLs = new SafeMap();
-    for (let i = 0; i < manifestEntries.length; i++) {
-      let resourceHREF = manifestEntries[i][0];
-      const originalHREF = resourceHREF;
-      let resourceURL;
-      if (parsedURLs.has(resourceHREF)) {
-        resourceURL = parsedURLs.get(resourceHREF);
-        resourceHREF = resourceURL.href;
-      } else if (
-        RegExpPrototypeTest(kRelativeURLStringPattern, resourceHREF)
-      ) {
-        resourceURL = new URL(resourceHREF, manifestURL);
-        resourceHREF = resourceURL.href;
-        parsedURLs.set(originalHREF, resourceURL);
-        parsedURLs.set(resourceHREF, resourceURL);
-      }
-      let integrity = manifestEntries[i][1].integrity;
-      if (!integrity) integrity = null;
-      if (integrity != null) {
-        debug('Manifest contains integrity for url %s', originalHREF);
+    this.#defaultDependencies = new DependencyMapperInstance(
+      'default',
+      defaultDependencies === true ? kFallThrough : defaultDependencies,
+      false
+    );
+
+    for (let i = 0; i < jsonResourcesEntries.length; i++) {
+      const { 0: originalHREF, 1: descriptor } = jsonResourcesEntries[i];
+      const { cascade, dependencies, integrity } = descriptor;
+      const href = resolve(originalHREF, manifestHREF).href;
+
+      if (typeof integrity !== 'undefined') {
+        debug('Manifest contains integrity for resource %s', originalHREF);
         if (typeof integrity === 'string') {
-          if (integrities.has(resourceHREF)) {
-            if (integrities.get(resourceHREF) !== integrity) {
-              throw new ERR_MANIFEST_INTEGRITY_MISMATCH(resourceURL);
-            }
-          }
-          integrities.set(resourceHREF, integrity);
+          integrities.set(href, integrity);
         } else if (integrity === true) {
-          integrities.set(resourceHREF, true);
+          integrities.set(href, true);
         } else {
-          throw new ERR_MANIFEST_INVALID_RESOURCE_FIELD(
-            resourceHREF,
-            'integrity');
+          throw new ERR_MANIFEST_INVALID_RESOURCE_FIELD(href, 'integrity');
         }
+      } else {
+        integrities.set(href, cascade === true ? kCascade : false);
       }
+      insertDependencyMap(
+        href,
+        dependencies,
+        cascade,
+        true,
+        resourceDependencies
+      );
+    }
 
-      let dependencyMap = manifestEntries[i][1].dependencies;
-      if (dependencyMap === null || dependencyMap === undefined) {
-        dependencyMap = ObjectCreate(null);
-      }
-      if (typeof dependencyMap === 'object' && !ArrayIsArray(dependencyMap)) {
-        /**
-         * @returns {true | URL}
-         */
-        const dependencyRedirectList = (toSpecifier) => {
-          if (toSpecifier in dependencyMap !== true) {
-            return null;
-          }
-          const to = dependencyMap[toSpecifier];
-          if (to === true) {
-            return true;
-          }
-          if (parsedURLs.has(to)) {
-            return parsedURLs.get(to);
-          } else if (canBeRequiredByUsers(to)) {
-            const href = `node:${to}`;
-            const resolvedURL = new URL(href);
-            parsedURLs.set(to, resolvedURL);
-            parsedURLs.set(href, resolvedURL);
-            return resolvedURL;
-          } else if (RegExpPrototypeTest(kRelativeURLStringPattern, to)) {
-            const resolvedURL = new URL(to, manifestURL);
-            const href = resourceURL.href;
-            parsedURLs.set(to, resolvedURL);
-            parsedURLs.set(href, resolvedURL);
-            return resolvedURL;
-          }
-          const resolvedURL = new URL(to);
-          const href = resourceURL.href;
-          parsedURLs.set(to, resolvedURL);
-          parsedURLs.set(href, resolvedURL);
-          return resolvedURL;
-        };
-        dependencies.set(resourceHREF, dependencyRedirectList);
-      } else if (dependencyMap === true) {
-        const arbitraryDependencies = () => true;
-        dependencies.set(resourceHREF, arbitraryDependencies);
+    const scopeIntegrities = this.#scopeIntegrities;
+    for (let i = 0; i < jsonScopesEntries.length; i++) {
+      const { 0: originalHREF, 1: descriptor } = jsonScopesEntries[i];
+      const { cascade, dependencies, integrity } = descriptor;
+      const href = emptyOrProtocolOrResolve(originalHREF, manifestHREF);
+      if (typeof integrity !== 'undefined') {
+        debug('Manifest contains integrity for scope %s', originalHREF);
+        if (integrity === true) {
+          scopeIntegrities.set(href, true);
+        } else {
+          throw new ERR_MANIFEST_INVALID_RESOURCE_FIELD(href, 'integrity');
+        }
       } else {
-        throw new ERR_MANIFEST_INVALID_RESOURCE_FIELD(
-          resourceHREF,
-          'dependencies');
+        scopeIntegrities.set(href, cascade === true ? kCascade : false);
       }
+      insertDependencyMap(href, dependencies, cascade, false, scopes);
     }
+
     ObjectFreeze(this);
   }
 
-  getRedirector(requester) {
-    requester = `${requester}`;
-    const dependencies = this.#dependencies;
-    if (dependencies.has(requester)) {
-      return {
-        resolve: (to) => dependencies.get(requester)(`${to}`),
-        reaction: this.#reaction
-      };
-    }
-    return null;
+  /**
+   * @param {string} requester
+   * @returns {{resolve: any, reaction: (err: any) => void}}
+   */
+  getDependencyMapper(requester) {
+    const requesterHREF = `${requester}`;
+    const dependencies = this.#resourceDependencies;
+    /**
+     * @type {DependencyMapperInstance}
+     */
+    const instance = (
+      dependencies.has(requesterHREF) ?
+        dependencies.get(requesterHREF) ?? null :
+        this.getScopeDependencyMapper(requesterHREF, true)
+    ) ?? this.#defaultDependencies;
+    return {
+      resolve: (specifier, conditions) => {
+        const normalizedSpecifier = canonicalizeSpecifier(
+          specifier,
+          requesterHREF
+        );
+        const result = instance._resolveAlreadyNormalized(
+          normalizedSpecifier,
+          conditions,
+          this
+        );
+        if (result === kFallThrough) return true;
+        return result;
+      },
+      reaction: this.#reaction,
+    };
   }
 
   assertIntegrity(url, content) {
     const href = `${url}`;
     debug('Checking integrity of %s', href);
-    const integrities = this.#integrities;
-    const realIntegrities = new Map();
-
-    if (integrities.has(href)) {
+    const realIntegrities = new SafeMap();
+    const integrities = this.#resourceIntegrities;
+    function processEntry(href) {
       let integrityEntries = integrities.get(href);
       if (integrityEntries === true) return true;
       if (typeof integrityEntries === 'string') {
@@ -229,29 +544,71 @@ class Manifest {
         integrities.set(href, sri);
         integrityEntries = sri;
       }
-      // Avoid clobbered Symbol.iterator
-      for (let i = 0; i < integrityEntries.length; i++) {
-        const {
-          algorithm,
-          value: expected
-        } = integrityEntries[i];
-        const hash = createHash(algorithm);
-        HashUpdate(hash, content);
-        const digest = HashDigest(hash);
-        if (digest.length === expected.length &&
-          timingSafeEqual(digest, expected)) {
+      return integrityEntries;
+    }
+    if (integrities.has(href)) {
+      const integrityEntries = processEntry(href);
+      if (integrityEntries === true) return true;
+      if (ArrayIsArray(integrityEntries)) {
+        // Avoid clobbered Symbol.iterator
+        for (let i = 0; i < integrityEntries.length; i++) {
+          const { algorithm, value: expected } = integrityEntries[i];
+          const hash = createHash(algorithm);
+          // TODO(tniessen): the content should not be passed as a string in the
+          // first place, see https://github.com/nodejs/node/issues/39707
+          HashUpdate(hash, content, 'utf8');
+          const digest = HashDigest(hash, 'buffer');
+          if (digest.length === expected.length &&
+            timingSafeEqual(digest, expected)) {
+            return true;
+          }
+          realIntegrities.set(algorithm, BufferToString(digest, 'base64'));
+        }
+      }
+
+      if (integrityEntries !== kCascade) {
+        const error = new ERR_MANIFEST_ASSERT_INTEGRITY(url, realIntegrities);
+        this.#reaction(error);
+      }
+    }
+    let scope = findScopeHREF(href, this.#scopeIntegrities, true);
+    while (scope !== null) {
+      if (this.#scopeIntegrities.has(scope)) {
+        const entry = this.#scopeIntegrities.get(scope);
+        if (entry === true) {
           return true;
+        } else if (entry === kCascade) {
+        } else {
+          break;
         }
-        MapPrototypeSet(
-          realIntegrities,
-          algorithm,
-          BufferToString(digest, 'base64')
-        );
       }
+      const nextScope = findScopeHREF(scope, this.#scopeDependencies, false);
+      if (!nextScope) {
+        break;
+      }
+      scope = nextScope;
     }
     const error = new ERR_MANIFEST_ASSERT_INTEGRITY(url, realIntegrities);
     this.#reaction(error);
   }
+  /**
+   * @param {string} href
+   * @param {boolean} allowSameHREFScope
+   * @returns {DependencyMapperInstance | null}
+   */
+  getScopeDependencyMapper(href, allowSameHREFScope) {
+    if (href === null) {
+      return this.#defaultDependencies;
+    }
+    /** @type {string | null} */
+    const scopeHREF = findScopeHREF(
+      href,
+      this.#scopeDependencies,
+      allowSameHREFScope
+    );
+    if (scopeHREF === null) return this.#defaultDependencies;
+    return this.#scopeDependencies.get(scopeHREF);
+  }
 }
 
 // Lock everything down to avoid problems even if reference is leaked somehow
@@ -260,3 +617,107 @@ ObjectSetPrototypeOf(Manifest.prototype, null);
 ObjectFreeze(Manifest);
 ObjectFreeze(Manifest.prototype);
 module.exports = ObjectFreeze({ Manifest });
+
+// #region URL utils
+
+/**
+ * Attempts to canonicalize relative URL strings against a base URL string
+ * Does not perform I/O
+ * If not able to canonicalize, returns the original specifier
+ *
+ * This effectively removes the possibility of the return value being a relative
+ * URL string
+ * @param {string} specifier
+ * @param {string} base
+ * @returns {string}
+ */
+function canonicalizeSpecifier(specifier, base) {
+  try {
+    if (RegExpPrototypeTest(kRelativeURLStringPattern, specifier)) {
+      return resolve(specifier, base).href;
+    }
+    return resolve(specifier).href;
+  } catch {}
+  return specifier;
+}
+
+/**
+ * Does a special allowance for scopes to be non-valid URLs
+ * that are only protocol strings or the empty string
+ * @param {string} resourceHREF
+ * @param {string} [base]
+ * @returns {string}
+ */
+const emptyOrProtocolOrResolve = (resourceHREF, base) => {
+  if (resourceHREF === '') return '';
+  if (StringPrototypeEndsWith(resourceHREF, ':')) {
+    // URL parse will trim these anyway, save the compute
+    resourceHREF = StringPrototypeReplace(
+      resourceHREF,
+      // eslint-disable-next-line
+      /^[\x00-\x1F\x20]|\x09\x0A\x0D|[\x00-\x1F\x20]$/g,
+      ''
+    );
+    if (RegExpPrototypeTest(/^[a-zA-Z][a-zA-Z+\-.]*:$/, resourceHREF)) {
+      return resourceHREF;
+    }
+  }
+  return resolve(resourceHREF, base).href;
+};
+
+/**
+ * @type {Map<string, URL>}
+ */
+let parsedURLs;
+/**
+ * Resolves a valid url string and uses the parsed cache to avoid double parsing
+ * costs.
+ * @param {string} originalHREF
+ * @param {string} [base]
+ * @returns {Readonly<URL>}
+ */
+const resolve = (originalHREF, base) => {
+  parsedURLs = parsedURLs ?? new SafeMap();
+  if (parsedURLs.has(originalHREF)) {
+    return parsedURLs.get(originalHREF);
+  } else if (RegExpPrototypeTest(kRelativeURLStringPattern, originalHREF)) {
+    const resourceURL = new URL(originalHREF, base);
+    parsedURLs.set(resourceURL.href, resourceURL);
+    return resourceURL;
+  }
+  const resourceURL = new URL(originalHREF);
+  parsedURLs.set(originalHREF, resourceURL);
+  return resourceURL;
+};
+
+// #endregion
+
+/**
+ * @param {any} o
+ * @returns {o is object}
+ */
+function objectButNotArray(o) {
+  return o && typeof o === 'object' && !ArrayIsArray(o);
+}
+
+function searchDependencies(href, target, conditions) {
+  if (objectButNotArray(target)) {
+    const keys = ObjectKeys(target);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (conditions.has(key)) {
+        const ret = searchDependencies(href, target[key], conditions);
+        if (ret != null) {
+          return ret;
+        }
+      }
+    }
+  } else if (typeof target === 'string') {
+    return target;
+  } else if (target === true) {
+    return target;
+  } else {
+    throw new ERR_MANIFEST_INVALID_RESOURCE_FIELD(href, 'dependencies');
+  }
+  return null;
+}
diff --git a/lib/internal/policy/sri.js b/lib/internal/policy/sri.js
index ddb06a2e1a6051e209d7d6375df869a1ce83c710..6728ff4de22bd16124ee38de086cb45938953fe0 100644
--- a/lib/internal/policy/sri.js
+++ b/lib/internal/policy/sri.js
@@ -3,9 +3,9 @@
 // https://w3c.github.io/webappsec-subresource-integrity/#the-integrity-attribute
 
 const {
+  ArrayPrototype,
   ObjectDefineProperty,
   ObjectFreeze,
-  ObjectGetPrototypeOf,
   ObjectSeal,
   ObjectSetPrototypeOf,
   RegExp,
@@ -32,7 +32,6 @@ const kAllWSP = RegExp(`^${kWSP}*$`);
 ObjectSeal(kAllWSP);
 
 const BufferFrom = require('buffer').Buffer.from;
-const RealArrayPrototype = ObjectGetPrototypeOf([]);
 
 // Returns {algorithm, value (in base64 string), options,}[]
 const parse = (str) => {
@@ -41,10 +40,10 @@ const parse = (str) => {
   const entries = [];
   while (match = RegExpPrototypeExec(kSRIPattern, str)) {
     if (match.index !== prevIndex) {
-      throw new ERR_SRI_PARSE(str, str.charAt(prevIndex), prevIndex);
+      throw new ERR_SRI_PARSE(str, str[prevIndex], prevIndex);
     }
     if (entries.length > 0 && match[1] === '') {
-      throw new ERR_SRI_PARSE(str, str.charAt(prevIndex), prevIndex);
+      throw new ERR_SRI_PARSE(str, str[prevIndex], prevIndex);
     }
 
     // Avoid setters being fired
@@ -63,10 +62,10 @@ const parse = (str) => {
 
   if (prevIndex !== str.length) {
     if (!RegExpPrototypeTest(kAllWSP, StringPrototypeSlice(str, prevIndex))) {
-      throw new ERR_SRI_PARSE(str, str.charAt(prevIndex), prevIndex);
+      throw new ERR_SRI_PARSE(str, str[prevIndex], prevIndex);
     }
   }
-  return ObjectSetPrototypeOf(entries, RealArrayPrototype);
+  return ObjectSetPrototypeOf(entries, ArrayPrototype);
 };
 
 module.exports = {
diff --git a/lib/internal/priority_queue.js b/lib/internal/priority_queue.js
index c31c1eea385857d29b3c1c7d9cc6b16adf50d717..84db200b1cea96b35a345b72dbe183bb46359f24 100644
--- a/lib/internal/priority_queue.js
+++ b/lib/internal/priority_queue.js
@@ -104,17 +104,6 @@ module.exports = class PriorityQueue {
     }
   }
 
-  remove(value) {
-    const heap = this[kHeap];
-    const pos = heap.indexOf(value);
-    if (pos < 1)
-      return false;
-
-    this.removeAt(pos);
-
-    return true;
-  }
-
   shift() {
     const heap = this[kHeap];
     const value = heap[1];
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 15e3a2cafda9b6ebcc0d62d6e6f73f66ca63833f..8f076b3ef32efdbdbf36060f8314694c68ddf28d 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -11,8 +11,6 @@ const { pathToFileURL } = require('internal/url');
 const {
   getModuleFromWrap,
 } = require('internal/vm/module');
-const { getOptionValue } = require('internal/options');
-const userLoader = getOptionValue('--experimental-loader');
 
 exports.initializeImportMetaObject = function(wrap, meta) {
   const { callbackMap } = internalBinding('module_wrap');
@@ -40,6 +38,8 @@ let ESMLoader = new Loader();
 exports.ESMLoader = ESMLoader;
 
 async function initializeLoader() {
+  const { getOptionValue } = require('internal/options');
+  const userLoader = getOptionValue('--experimental-loader');
   if (!userLoader)
     return;
   let cwd;
diff --git a/lib/internal/process/execution.js b/lib/internal/process/execution.js
index 6f2f39500d9821a326331252d03153908500d4ba..e370770643ca6fff1285428185e9f6edfa509d2b 100644
--- a/lib/internal/process/execution.js
+++ b/lib/internal/process/execution.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const {
-  JSONStringify,
-  PromiseResolve,
+  globalThis,
 } = primordials;
 
 const path = require('path');
@@ -10,8 +9,9 @@ const path = require('path');
 const {
   codes: {
     ERR_INVALID_ARG_TYPE,
-    ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET
-  }
+    ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET,
+    ERR_EVAL_ESM_CANNOT_PRINT,
+  },
 } = require('internal/errors');
 
 const {
@@ -39,20 +39,18 @@ function tryGetCwd() {
 }
 
 function evalModule(source, print) {
-  const { log, error } = require('internal/console/global');
-  const { decorateErrorStack } = require('internal/util');
-  const asyncESM = require('internal/process/esm_loader');
-  PromiseResolve(asyncESM.ESMLoader).then(async (loader) => {
+  if (print) {
+    throw new ERR_EVAL_ESM_CANNOT_PRINT();
+  }
+  const { log } = require('internal/console/global');
+  const { loadESM } = require('internal/process/esm_loader');
+  const { handleMainPromise } = require('internal/modules/run_main');
+  return handleMainPromise(loadESM(async (loader) => {
     const { result } = await loader.eval(source);
     if (print) {
       log(result);
     }
-  })
-  .catch((e) => {
-    decorateErrorStack(e);
-    error(e);
-    process.exit(1);
-  });
+  }));
 }
 
 function evalScript(name, body, breakFirstLine, print) {
@@ -61,52 +59,53 @@ function evalScript(name, body, breakFirstLine, print) {
   const { pathToFileURL } = require('url');
 
   const cwd = tryGetCwd();
-  const origModule = global.module;  // Set e.g. when called from the REPL.
+  const origModule = globalThis.module;  // Set e.g. when called from the REPL.
 
   const module = new CJSModule(name);
   module.filename = path.join(cwd, name);
   module.paths = CJSModule._nodeModulePaths(cwd);
 
-  global.kVmBreakFirstLineSymbol = kVmBreakFirstLineSymbol;
-  global.asyncESM = require('internal/process/esm_loader');
-
+  const asyncESM = require('internal/process/esm_loader');
   const baseUrl = pathToFileURL(module.filename).href;
 
+  // Create wrapper for cache entry
   const script = `
-    global.__filename = ${JSONStringify(name)};
-    global.exports = exports;
-    global.module = module;
-    global.__dirname = __dirname;
-    global.require = require;
-    const { kVmBreakFirstLineSymbol, asyncESM } = global;
-    delete global.kVmBreakFirstLineSymbol;
-    delete global.asyncESM;
-    return require("vm").runInThisContext(
-      ${JSONStringify(body)}, {
-        filename: ${JSONStringify(name)},
-        displayErrors: true,
-        [kVmBreakFirstLineSymbol]: ${!!breakFirstLine},
-        async importModuleDynamically (specifier) {
-          const loader = await asyncESM.ESMLoader;
-          return loader.import(specifier, ${JSONStringify(baseUrl)});
-        }
-      });\n`;
-  const result = module._compile(script, `${name}-wrapper`);
+    globalThis.module = module;
+    globalThis.exports = exports;
+    globalThis.__dirname = __dirname;
+    globalThis.require = require;
+    return (main) => main();
+  `;
+  globalThis.__filename = name;
+  const result = module._compile(script, `${name}-wrapper`)(() =>
+    require('vm').runInThisContext(body, {
+      filename: name,
+      displayErrors: true,
+      [kVmBreakFirstLineSymbol]: !!breakFirstLine,
+      async importModuleDynamically(specifier) {
+        const loader = await asyncESM.ESMLoader;
+        return loader.import(specifier, baseUrl);
+      }
+    }));
   if (print) {
     const { log } = require('internal/console/global');
     log(result);
   }
 
   if (origModule !== undefined)
-    global.module = origModule;
+    globalThis.module = origModule;
 }
 
-const exceptionHandlerState = { captureFn: null };
+const exceptionHandlerState = {
+  captureFn: null,
+  reportFlag: false
+};
 
 function setUncaughtExceptionCaptureCallback(fn) {
   if (fn === null) {
     exceptionHandlerState.captureFn = fn;
     shouldAbortOnUncaughtToggle[0] = 1;
+    process.report.reportOnUncaughtException = exceptionHandlerState.reportFlag;
     return;
   }
   if (typeof fn !== 'function') {
@@ -117,6 +116,9 @@ function setUncaughtExceptionCaptureCallback(fn) {
   }
   exceptionHandlerState.captureFn = fn;
   shouldAbortOnUncaughtToggle[0] = 0;
+  exceptionHandlerState.reportFlag =
+    process.report.reportOnUncaughtException === true;
+  process.report.reportOnUncaughtException = false;
 }
 
 function hasUncaughtExceptionCaptureCallback() {
diff --git a/lib/internal/process/per_thread.js b/lib/internal/process/per_thread.js
index 5d8e826d816bf89c81d25b2a3a4b055fd62b154e..44a724073c4511c04f60a3781bfea6df312ce984 100644
--- a/lib/internal/process/per_thread.js
+++ b/lib/internal/process/per_thread.js
@@ -6,7 +6,9 @@
 
 const {
   ArrayIsArray,
+  ArrayPrototypePush,
   BigUint64Array,
+  Float64Array,
   NumberMAX_SAFE_INTEGER,
   ObjectDefineProperties,
   ObjectDefineProperty,
@@ -45,6 +47,7 @@ function wrapProcessMethods(binding) {
     hrtimeBigInt: _hrtimeBigInt,
     cpuUsage: _cpuUsage,
     memoryUsage: _memoryUsage,
+    rss,
     resourceUsage: _resourceUsage
   } = binding;
 
@@ -135,7 +138,7 @@ function wrapProcessMethods(binding) {
 
     return [
       hrValues[0] * 0x100000000 + hrValues[1],
-      hrValues[2]
+      hrValues[2],
     ];
   }
 
@@ -159,6 +162,8 @@ function wrapProcessMethods(binding) {
     };
   }
 
+  memoryUsage.rss = rss;
+
   function exit(code) {
     if (code || code === 0)
       process.exitCode = code;
@@ -245,14 +250,19 @@ const trailingValuesRegex = /=.*$/;
 // from data in the config binding.
 function buildAllowedFlags() {
   const {
-    envSettings: { kAllowedInEnvironment }
+    envSettings: { kAllowedInEnvironment },
+    types: { kBoolean },
   } = internalBinding('options');
   const { options, aliases } = require('internal/options');
 
   const allowedNodeEnvironmentFlags = [];
   for (const [name, info] of options) {
     if (info.envVarSettings === kAllowedInEnvironment) {
-      allowedNodeEnvironmentFlags.push(name);
+      ArrayPrototypePush(allowedNodeEnvironmentFlags, name);
+      if (info.type === kBoolean) {
+        const negatedName = `--no-${name.slice(2)}`;
+        ArrayPrototypePush(allowedNodeEnvironmentFlags, negatedName);
+      }
     }
   }
 
diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index 1a0ed06f213df84b7ad6dbdbbcc47b6da077576b..f2145d425c620faa000d6136d5f9b9db28727ed2 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -30,22 +30,37 @@ const pendingUnhandledRejections = [];
 const asyncHandledRejections = [];
 let lastPromiseId = 0;
 
-// --unhandled-rejection=none:
+// --unhandled-rejections=none:
 // Emit 'unhandledRejection', but do not emit any warning.
 const kIgnoreUnhandledRejections = 0;
-// --unhandled-rejection=warn:
+
+// --unhandled-rejections=warn:
 // Emit 'unhandledRejection', then emit 'UnhandledPromiseRejectionWarning'.
 const kAlwaysWarnUnhandledRejections = 1;
-// --unhandled-rejection=strict:
+
+// --unhandled-rejections=strict:
 // Emit 'uncaughtException'. If it's not handled, print the error to stderr
 // and exit the process.
 // Otherwise, emit 'unhandledRejection'. If 'unhandledRejection' is not
 // handled, emit 'UnhandledPromiseRejectionWarning'.
-const kThrowUnhandledRejections = 2;
-// --unhandled-rejection is unset:
-// Emit 'unhandledRejection', if it's handled, emit
+const kStrictUnhandledRejections = 2;
+
+// --unhandled-rejections=throw:
+// Emit 'unhandledRejection', if it's unhandled, emit
+// 'uncaughtException'. If it's not handled, print the error to stderr
+// and exit the process.
+const kThrowUnhandledRejections = 3;
+
+// --unhandled-rejections=warn-with-error-code:
+// Emit 'unhandledRejection', if it's unhandled, emit
+// 'UnhandledPromiseRejectionWarning', then set process exit code to 1.
+
+const kWarnWithErrorCodeUnhandledRejections = 4;
+
+// --unhandled-rejections is unset:
+// Emit 'unhandledRejection', if it's unhandled, emit
 // 'UnhandledPromiseRejectionWarning', then emit deprecation warning.
-const kDefaultUnhandledRejections = 3;
+const kDefaultUnhandledRejections = 5;
 
 let unhandledRejectionsMode;
 
@@ -65,7 +80,11 @@ function getUnhandledRejectionsMode() {
     case 'warn':
       return kAlwaysWarnUnhandledRejections;
     case 'strict':
+      return kStrictUnhandledRejections;
+    case 'throw':
       return kThrowUnhandledRejections;
+    case 'warn-with-error-code':
+      return kWarnWithErrorCodeUnhandledRejections;
     default:
       return kDefaultUnhandledRejections;
   }
@@ -188,7 +207,7 @@ function processPromiseRejections() {
     promiseInfo.warned = true;
     const { reason, uid } = promiseInfo;
     switch (unhandledRejectionsMode) {
-      case kThrowUnhandledRejections: {
+      case kStrictUnhandledRejections: {
         const err = reason instanceof Error ?
           reason : generateUnhandledRejectionError(reason);
         triggerUncaughtException(err, true /* fromPromise */);
@@ -205,6 +224,23 @@ function processPromiseRejections() {
         emitUnhandledRejectionWarning(uid, reason);
         break;
       }
+      case kThrowUnhandledRejections: {
+        const handled = process.emit('unhandledRejection', reason, promise);
+        if (!handled) {
+          const err = reason instanceof Error ?
+            reason : generateUnhandledRejectionError(reason);
+          triggerUncaughtException(err, true /* fromPromise */);
+        }
+        break;
+      }
+      case kWarnWithErrorCodeUnhandledRejections: {
+        const handled = process.emit('unhandledRejection', reason, promise);
+        if (!handled) {
+          emitUnhandledRejectionWarning(uid, reason);
+          process.exitCode = 1;
+        }
+        break;
+      }
       case kDefaultUnhandledRejections: {
         const handled = process.emit('unhandledRejection', reason, promise);
         if (!handled) {
diff --git a/lib/internal/process/task_queues.js b/lib/internal/process/task_queues.js
index c07942587ca9c2b14131579db4f8018d33bc0928..76147473b04f9b223f6510aa32a0be6dc7da65f5 100644
--- a/lib/internal/process/task_queues.js
+++ b/lib/internal/process/task_queues.js
@@ -15,10 +15,6 @@ const {
   enqueueMicrotask
 } = internalBinding('task_queue');
 
-const {
-  triggerUncaughtException
-} = internalBinding('errors');
-
 const {
   setHasRejectionToWarn,
   hasRejectionToWarn,
@@ -43,6 +39,8 @@ const {
 } = require('internal/errors').codes;
 const FixedQueue = require('internal/fixed_queue');
 
+const { AsyncResource } = require('async_hooks');
+
 // *Must* match Environment::TickInfo::Fields in src/env.h.
 const kHasTickScheduled = 0;
 
@@ -136,37 +134,28 @@ function nextTick(callback) {
   queue.push(tickObject);
 }
 
-let AsyncResource;
-const defaultMicrotaskResourceOpts = { requireManualDestroy: true };
-function createMicrotaskResource() {
-  // Lazy load the async_hooks module
-  if (AsyncResource === undefined) {
-    AsyncResource = require('async_hooks').AsyncResource;
-  }
-  return new AsyncResource('Microtask', defaultMicrotaskResourceOpts);
-}
-
 function runMicrotask() {
   this.runInAsyncScope(() => {
     const callback = this.callback;
     try {
       callback();
-    } catch (error) {
-      // runInAsyncScope() swallows the error so we need to catch
-      // it and handle it here.
-      triggerUncaughtException(error, false /* fromPromise */);
     } finally {
       this.emitDestroy();
     }
   });
 }
 
+const defaultMicrotaskResourceOpts = { requireManualDestroy: true };
+
 function queueMicrotask(callback) {
   if (typeof callback !== 'function') {
     throw new ERR_INVALID_ARG_TYPE('callback', 'function', callback);
   }
 
-  const asyncResource = createMicrotaskResource();
+  const asyncResource = new AsyncResource(
+    'Microtask',
+    defaultMicrotaskResourceOpts
+  );
   asyncResource.callback = callback;
 
   enqueueMicrotask(FunctionPrototypeBind(runMicrotask, asyncResource));
diff --git a/lib/internal/process/warning.js b/lib/internal/process/warning.js
index e80e1974f821b127095bc8bac053eaf276a6014c..37b80216c11ae979df6296565089e6ce9a20ba7f 100644
--- a/lib/internal/process/warning.js
+++ b/lib/internal/process/warning.js
@@ -3,9 +3,14 @@
 const {
   ArrayIsArray,
   Error,
+  ErrorPrototypeToString,
+  ErrorCaptureStackTrace,
+  String,
 } = primordials;
 
+const assert = require('internal/assert');
 const { ERR_INVALID_ARG_TYPE } = require('internal/errors').codes;
+const { validateString } = require('internal/validators');
 
 // Lazily loaded
 let fs;
@@ -62,9 +67,10 @@ function writeToFile(message) {
 }
 
 function doEmitWarning(warning) {
-  return () => process.emit('warning', warning);
+  process.emit('warning', warning);
 }
 
+let traceWarningHelperShown = false;
 function onWarning(warning) {
   if (!(warning instanceof Error)) return;
   const isDeprecation = warning.name === 'DeprecationWarning';
@@ -77,14 +83,21 @@ function onWarning(warning) {
   if (trace && warning.stack) {
     msg += `${warning.stack}`;
   } else {
-    const toString =
+    msg +=
       typeof warning.toString === 'function' ?
-        warning.toString : Error.prototype.toString;
-    msg += `${toString.apply(warning)}`;
+        `${warning.toString()}` :
+        ErrorPrototypeToString(warning);
   }
   if (typeof warning.detail === 'string') {
     msg += `\n${warning.detail}`;
   }
+  if (!trace && !traceWarningHelperShown) {
+    const flag = isDeprecation ? '--trace-deprecation' : '--trace-warnings';
+    const argv0 = require('path').basename(process.argv0 || 'node', '.exe');
+    msg += `\n(Use \`${argv0} ${flag} ...\` to show where the warning ` +
+           'was created)';
+    traceWarningHelperShown = true;
+  }
   const warningFile = lazyOption();
   if (warningFile) {
     return writeToFile(msg);
@@ -95,7 +108,7 @@ function onWarning(warning) {
 // process.emitWarning(error)
 // process.emitWarning(str[, type[, code]][, ctor])
 // process.emitWarning(str[, options])
-function emitWarning(warning, type, code, ctor, now) {
+function emitWarning(warning, type, code, ctor) {
   let detail;
   if (type !== null && typeof type === 'object' && !ArrayIsArray(type)) {
     ctor = type.ctor;
@@ -108,28 +121,16 @@ function emitWarning(warning, type, code, ctor, now) {
     code = undefined;
     type = 'Warning';
   }
-  if (type !== undefined && typeof type !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('type', 'string', type);
-  }
+  if (type !== undefined)
+    validateString(type, 'type');
   if (typeof code === 'function') {
     ctor = code;
     code = undefined;
-  } else if (code !== undefined && typeof code !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('code', 'string', code);
+  } else if (code !== undefined) {
+    validateString(code, 'code');
   }
   if (typeof warning === 'string') {
-    // Improve error creation performance by skipping the error frames.
-    // They are added in the `captureStackTrace()` function below.
-    const tmpStackLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 0;
-    // eslint-disable-next-line no-restricted-syntax
-    warning = new Error(warning);
-    Error.stackTraceLimit = tmpStackLimit;
-    warning.name = String(type || 'Warning');
-    if (code !== undefined) warning.code = code;
-    if (detail !== undefined) warning.detail = detail;
-    // eslint-disable-next-line no-restricted-syntax
-    Error.captureStackTrace(warning, ctor || process.emitWarning);
+    warning = createWarningObject(warning, type, code, ctor, detail);
   } else if (!(warning instanceof Error)) {
     throw new ERR_INVALID_ARG_TYPE('warning', ['Error', 'string'], warning);
   }
@@ -139,11 +140,31 @@ function emitWarning(warning, type, code, ctor, now) {
     if (process.throwDeprecation)
       throw warning;
   }
-  if (now) process.emit('warning', warning);
-  else process.nextTick(doEmitWarning(warning));
+  process.nextTick(doEmitWarning, warning);
+}
+
+function emitWarningSync(warning) {
+  process.emit('warning', createWarningObject(warning));
+}
+
+function createWarningObject(warning, type, code, ctor, detail) {
+  assert(typeof warning === 'string');
+  // Improve error creation performance by skipping the error frames.
+  // They are added in the `captureStackTrace()` function below.
+  const tmpStackLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
+  // eslint-disable-next-line no-restricted-syntax
+  warning = new Error(warning);
+  Error.stackTraceLimit = tmpStackLimit;
+  warning.name = String(type || 'Warning');
+  if (code !== undefined) warning.code = code;
+  if (detail !== undefined) warning.detail = detail;
+  ErrorCaptureStackTrace(warning, ctor || process.emitWarning);
+  return warning;
 }
 
 module.exports = {
+  emitWarning,
+  emitWarningSync,
   onWarning,
-  emitWarning
 };
diff --git a/lib/internal/querystring.js b/lib/internal/querystring.js
index ee589e1984294dd4f0bf6f1d02a443f9aabe4ae7..68f52c90c27237116171a5a3f98596fd1524b028 100644
--- a/lib/internal/querystring.js
+++ b/lib/internal/querystring.js
@@ -2,15 +2,22 @@
 
 const {
   Array,
+  Int8Array,
+  NumberPrototypeToString,
+  StringPrototypeCharCodeAt,
+  StringPrototypeSlice,
+  StringPrototypeToUpperCase,
 } = primordials;
 
 const { ERR_INVALID_URI } = require('internal/errors').codes;
 
 const hexTable = new Array(256);
 for (let i = 0; i < 256; ++i)
-  hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();
+  hexTable[i] = '%' +
+                StringPrototypeToUpperCase((i < 16 ? '0' : '') +
+                                           NumberPrototypeToString(i, 16));
 
-const isHexTable = [
+const isHexTable = new Int8Array([
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32 - 47
@@ -26,9 +33,15 @@ const isHexTable = [
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  // ... 256
-];
-
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // ... 256
+]);
+
+/**
+ * @param {string} str
+ * @param {Int8Array} noEscapeTable
+ * @param {string[]} hexTable
+ * @returns {string}
+ */
 function encodeStr(str, noEscapeTable, hexTable) {
   const len = str.length;
   if (len === 0)
@@ -40,13 +53,13 @@ function encodeStr(str, noEscapeTable, hexTable) {
 
   outer:
   for (; i < len; i++) {
-    let c = str.charCodeAt(i);
+    let c = StringPrototypeCharCodeAt(str, i);
 
     // ASCII
     while (c < 0x80) {
       if (noEscapeTable[c] !== 1) {
         if (lastPos < i)
-          out += str.slice(lastPos, i);
+          out += StringPrototypeSlice(str, lastPos, i);
         lastPos = i + 1;
         out += hexTable[c];
       }
@@ -54,11 +67,11 @@ function encodeStr(str, noEscapeTable, hexTable) {
       if (++i === len)
         break outer;
 
-      c = str.charCodeAt(i);
+      c = StringPrototypeCharCodeAt(str, i);
     }
 
     if (lastPos < i)
-      out += str.slice(lastPos, i);
+      out += StringPrototypeSlice(str, lastPos, i);
 
     // Multi-byte characters ...
     if (c < 0x800) {
@@ -83,7 +96,7 @@ function encodeStr(str, noEscapeTable, hexTable) {
     if (i >= len)
       throw new ERR_INVALID_URI();
 
-    const c2 = str.charCodeAt(i) & 0x3FF;
+    const c2 = StringPrototypeCharCodeAt(str, i) & 0x3FF;
 
     lastPos = i + 1;
     c = 0x10000 + (((c & 0x3FF) << 10) | c2);
@@ -95,7 +108,7 @@ function encodeStr(str, noEscapeTable, hexTable) {
   if (lastPos === 0)
     return str;
   if (lastPos < len)
-    return out + str.slice(lastPos);
+    return out + StringPrototypeSlice(str, lastPos);
   return out;
 }
 
diff --git a/lib/internal/readline/utils.js b/lib/internal/readline/utils.js
index 0b9fe8cde4f5ce7575e213c9d6ce4a416addd77c..55b3e07b4c1782bbd8e2ef1f22632af4c9dedf38 100644
--- a/lib/internal/readline/utils.js
+++ b/lib/internal/readline/utils.js
@@ -1,6 +1,15 @@
 'use strict';
 
 const {
+  ArrayPrototypeSlice,
+  ArrayPrototypeSort,
+  RegExpPrototypeTest,
+  StringFromCharCode,
+  StringPrototypeCharCodeAt,
+  StringPrototypeCodePointAt,
+  StringPrototypeMatch,
+  StringPrototypeSlice,
+  StringPrototypeToLowerCase,
   Symbol,
 } = primordials;
 
@@ -31,8 +40,9 @@ CSI.kClearScreenDown = CSI`0J`;
 function charLengthLeft(str, i) {
   if (i <= 0)
     return 0;
-  if ((i > 1 && str.codePointAt(i - 2) >= kUTF16SurrogateThreshold) ||
-      str.codePointAt(i - 1) >= kUTF16SurrogateThreshold) {
+  if ((i > 1 &&
+      StringPrototypeCodePointAt(str, i - 2) >= kUTF16SurrogateThreshold) ||
+      StringPrototypeCodePointAt(str, i - 1) >= kUTF16SurrogateThreshold) {
     return 2;
   }
   return 1;
@@ -44,7 +54,7 @@ function charLengthAt(str, i) {
     // moving to the right.
     return 1;
   }
-  return str.codePointAt(i) >= kUTF16SurrogateThreshold ? 2 : 1;
+  return StringPrototypeCodePointAt(str, i) >= kUTF16SurrogateThreshold ? 2 : 1;
 }
 
 /*
@@ -177,13 +187,15 @@ function* emitKeys(stream) {
          * We buffered enough data, now trying to extract code
          * and modifier from it
          */
-        const cmd = s.slice(cmdStart);
+        const cmd = StringPrototypeSlice(s, cmdStart);
         let match;
 
-        if ((match = cmd.match(/^(\d\d?)(;(\d))?([~^$])$/))) {
+        if ((match = StringPrototypeMatch(cmd, /^(\d\d?)(;(\d))?([~^$])$/))) {
           code += match[1] + match[4];
           modifier = (match[3] || 1) - 1;
-        } else if ((match = cmd.match(/^((\d;)?(\d))?([A-Za-z])$/))) {
+        } else if (
+          (match = StringPrototypeMatch(cmd, /^((\d;)?(\d))?([A-Za-z])$/))
+        ) {
           code += match[4];
           modifier = (match[3] || 1) - 1;
         } else {
@@ -199,7 +211,13 @@ function* emitKeys(stream) {
 
       // Parse the key itself
       switch (code) {
-        /* xterm/gnome ESC O letter */
+        /* xterm/gnome ESC [ letter (with modifier) */
+        case '[P': key.name = 'f1'; break;
+        case '[Q': key.name = 'f2'; break;
+        case '[R': key.name = 'f3'; break;
+        case '[S': key.name = 'f4'; break;
+
+        /* xterm/gnome ESC O letter (without modifier) */
         case 'OP': key.name = 'f1'; break;
         case 'OQ': key.name = 'f2'; break;
         case 'OR': key.name = 'f3'; break;
@@ -296,12 +314,15 @@ function* emitKeys(stream) {
     } else if (ch === '\r') {
       // carriage return
       key.name = 'return';
+      key.meta = escaped;
     } else if (ch === '\n') {
       // Enter, should have been called linefeed
       key.name = 'enter';
+      key.meta = escaped;
     } else if (ch === '\t') {
       // tab
       key.name = 'tab';
+      key.meta = escaped;
     } else if (ch === '\b' || ch === '\x7f') {
       // backspace or ctrl+h
       key.name = 'backspace';
@@ -315,12 +336,14 @@ function* emitKeys(stream) {
       key.meta = escaped;
     } else if (!escaped && ch <= '\x1a') {
       // ctrl+letter
-      key.name = String.fromCharCode(ch.charCodeAt(0) + 'a'.charCodeAt(0) - 1);
+      key.name = StringFromCharCode(
+        StringPrototypeCharCodeAt(ch) + StringPrototypeCharCodeAt('a') - 1
+      );
       key.ctrl = true;
-    } else if (/^[0-9A-Za-z]$/.test(ch)) {
+    } else if (RegExpPrototypeTest(/^[0-9A-Za-z]$/, ch)) {
       // Letter, number, shift+letter
-      key.name = ch.toLowerCase();
-      key.shift = /^[A-Z]$/.test(ch);
+      key.name = StringPrototypeToLowerCase(ch);
+      key.shift = RegExpPrototypeTest(/^[A-Z]$/, ch);
       key.meta = escaped;
     } else if (escaped) {
       // Escape sequence timeout
@@ -346,12 +369,12 @@ function commonPrefix(strings) {
   if (strings.length === 1) {
     return strings[0];
   }
-  const sorted = strings.slice().sort();
+  const sorted = ArrayPrototypeSort(ArrayPrototypeSlice(strings));
   const min = sorted[0];
   const max = sorted[sorted.length - 1];
   for (let i = 0; i < min.length; i++) {
     if (min[i] !== max[i]) {
-      return min.slice(0, i);
+      return StringPrototypeSlice(min, 0, i);
     }
   }
   return min;
diff --git a/lib/internal/repl.js b/lib/internal/repl.js
index 565ab049c7148722ce90664a1adaf25577f88f04..5eeb2e349031b2564ed09311a34890d71216014d 100644
--- a/lib/internal/repl.js
+++ b/lib/internal/repl.js
@@ -3,6 +3,7 @@
 const {
   Number,
   NumberIsNaN,
+  NumberParseInt,
   ObjectCreate,
 } = primordials;
 
@@ -25,7 +26,7 @@ function createRepl(env, opts, cb) {
     ...opts
   };
 
-  if (parseInt(env.NODE_NO_READLINE)) {
+  if (NumberParseInt(env.NODE_NO_READLINE)) {
     opts.terminal = false;
   }
 
diff --git a/lib/internal/repl/await.js b/lib/internal/repl/await.js
index b437221ca22e779c05b4d8ed3bdfb2351d7c3fef..f28a7ea412bc3fade33d88382df7487633c2541e 100644
--- a/lib/internal/repl/await.js
+++ b/lib/internal/repl/await.js
@@ -1,33 +1,43 @@
 'use strict';
 
 const {
+  ArrayFrom,
+  ArrayPrototypeForEach,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeJoin,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  FunctionPrototype,
   ObjectKeys,
+  RegExpPrototypeSymbolReplace,
+  StringPrototypeEndsWith,
+  StringPrototypeIncludes,
+  StringPrototypeIndexOf,
+  StringPrototypeRepeat,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+  SyntaxError,
 } = primordials;
 
-const acorn = require('internal/deps/acorn/acorn/dist/acorn');
+const parser = require('internal/deps/acorn/acorn/dist/acorn').Parser;
 const walk = require('internal/deps/acorn/acorn-walk/dist/walk');
-const privateMethods =
-  require('internal/deps/acorn-plugins/acorn-private-methods/index');
-const classFields =
-  require('internal/deps/acorn-plugins/acorn-class-fields/index');
-const numericSeparator =
-  require('internal/deps/acorn-plugins/acorn-numeric-separator/index');
-const staticClassFeatures =
-  require('internal/deps/acorn-plugins/acorn-static-class-features/index');
-
-const parser = acorn.Parser.extend(
-  privateMethods,
-  classFields,
-  numericSeparator,
-  staticClassFeatures
-);
-
-const noop = () => {};
+const { Recoverable } = require('internal/repl');
+
+function isTopLevelDeclaration(state) {
+  return state.ancestors[state.ancestors.length - 2] === state.body;
+}
+
+const noop = FunctionPrototype;
 const visitorsWithoutAncestors = {
   ClassDeclaration(node, state, c) {
-    if (state.ancestors[state.ancestors.length - 2] === state.body) {
+    if (isTopLevelDeclaration(state)) {
       state.prepend(node, `${node.id.name}=`);
+      ArrayPrototypePush(
+        state.hoistedDeclarationStatements,
+        `let ${node.id.name}; `
+      );
     }
+
     walk.base.ClassDeclaration(node, state, c);
   },
   ForOfStatement(node, state, c) {
@@ -37,7 +47,11 @@ const visitorsWithoutAncestors = {
     walk.base.ForOfStatement(node, state, c);
   },
   FunctionDeclaration(node, state, c) {
-    state.prepend(node, `${node.id.name}=`);
+    state.prepend(node, `this.${node.id.name} = ${node.id.name}; `);
+    ArrayPrototypePush(
+      state.hoistedDeclarationStatements,
+      `var ${node.id.name}; `
+    );
   },
   FunctionExpression: noop,
   ArrowFunctionExpression: noop,
@@ -51,22 +65,72 @@ const visitorsWithoutAncestors = {
     walk.base.ReturnStatement(node, state, c);
   },
   VariableDeclaration(node, state, c) {
-    if (node.kind === 'var' ||
-        state.ancestors[state.ancestors.length - 2] === state.body) {
-      if (node.declarations.length === 1) {
-        state.replace(node.start, node.start + node.kind.length, 'void');
-      } else {
-        state.replace(node.start, node.start + node.kind.length, 'void (');
-      }
+    const variableKind = node.kind;
+    const isIterableForDeclaration = ArrayPrototypeIncludes(
+      ['ForOfStatement', 'ForInStatement'],
+      state.ancestors[state.ancestors.length - 2].type
+    );
 
-      for (const decl of node.declarations) {
-        state.prepend(decl, '(');
-        state.append(decl, decl.init ? ')' : '=undefined)');
+    if (variableKind === 'var' || isTopLevelDeclaration(state)) {
+      state.replace(
+        node.start,
+        node.start + variableKind.length + (isIterableForDeclaration ? 1 : 0),
+        variableKind === 'var' && isIterableForDeclaration ?
+          '' :
+          'void' + (node.declarations.length === 1 ? '' : ' (')
+      );
+
+      if (!isIterableForDeclaration) {
+        ArrayPrototypeForEach(node.declarations, (decl) => {
+          state.prepend(decl, '(');
+          state.append(decl, decl.init ? ')' : '=undefined)');
+        });
+
+        if (node.declarations.length !== 1) {
+          state.append(node.declarations[node.declarations.length - 1], ')');
+        }
       }
 
-      if (node.declarations.length !== 1) {
-        state.append(node.declarations[node.declarations.length - 1], ')');
+      const variableIdentifiersToHoist = [
+        ['var', []],
+        ['let', []],
+      ];
+      function registerVariableDeclarationIdentifiers(node) {
+        switch (node.type) {
+          case 'Identifier':
+            ArrayPrototypePush(
+              variableIdentifiersToHoist[variableKind === 'var' ? 0 : 1][1],
+              node.name
+            );
+            break;
+          case 'ObjectPattern':
+            ArrayPrototypeForEach(node.properties, (property) => {
+              registerVariableDeclarationIdentifiers(property.value);
+            });
+            break;
+          case 'ArrayPattern':
+            ArrayPrototypeForEach(node.elements, (element) => {
+              registerVariableDeclarationIdentifiers(element);
+            });
+            break;
+        }
       }
+
+      ArrayPrototypeForEach(node.declarations, (decl) => {
+        registerVariableDeclarationIdentifiers(decl.id);
+      });
+
+      ArrayPrototypeForEach(
+        variableIdentifiersToHoist,
+        ({ 0: kind, 1: identifiers }) => {
+          if (identifiers.length > 0) {
+            ArrayPrototypePush(
+              state.hoistedDeclarationStatements,
+              `${kind} ${ArrayPrototypeJoin(identifiers, ', ')}; `
+            );
+          }
+        }
+      );
     }
 
     walk.base.VariableDeclaration(node, state, c);
@@ -79,28 +143,59 @@ for (const nodeType of ObjectKeys(walk.base)) {
   visitors[nodeType] = (node, state, c) => {
     const isNew = node !== state.ancestors[state.ancestors.length - 1];
     if (isNew) {
-      state.ancestors.push(node);
+      ArrayPrototypePush(state.ancestors, node);
     }
     callback(node, state, c);
     if (isNew) {
-      state.ancestors.pop();
+      ArrayPrototypePop(state.ancestors);
     }
   };
 }
 
 function processTopLevelAwait(src) {
-  const wrapped = `(async () => { ${src} })()`;
-  const wrappedArray = wrapped.split('');
+  const wrapPrefix = '(async () => { ';
+  const wrapped = `${wrapPrefix}${src} })()`;
+  const wrappedArray = ArrayFrom(wrapped);
   let root;
   try {
-    root = parser.parse(wrapped, { ecmaVersion: 11 });
-  } catch {
-    return null;
+    root = parser.parse(wrapped, { ecmaVersion: 'latest' });
+  } catch (e) {
+    if (StringPrototypeStartsWith(e.message, 'Unterminated '))
+      throw new Recoverable(e);
+    // If the parse error is before the first "await", then use the execution
+    // error. Otherwise we must emit this parse error, making it look like a
+    // proper syntax error.
+    const awaitPos = StringPrototypeIndexOf(src, 'await');
+    const errPos = e.pos - wrapPrefix.length;
+    if (awaitPos > errPos)
+      return null;
+    // Convert keyword parse errors on await into their original errors when
+    // possible.
+    if (errPos === awaitPos + 6 &&
+        StringPrototypeIncludes(e.message, 'Expecting Unicode escape sequence'))
+      return null;
+    if (errPos === awaitPos + 7 &&
+        StringPrototypeIncludes(e.message, 'Unexpected token'))
+      return null;
+    const line = e.loc.line;
+    const column = line === 1 ? e.loc.column - wrapPrefix.length : e.loc.column;
+    let message = '\n' + StringPrototypeSplit(src, '\n')[line - 1] + '\n' +
+        StringPrototypeRepeat(' ', column) +
+        '^\n\n' + RegExpPrototypeSymbolReplace(/ \([^)]+\)/, e.message, '');
+    // V8 unexpected token errors include the token string.
+    if (StringPrototypeEndsWith(message, 'Unexpected token'))
+      message += " '" +
+        // Wrapper end may cause acorn to report error position after the source
+        (src[e.pos - wrapPrefix.length] ?? src[src.length - 1]) +
+        "'";
+    // eslint-disable-next-line no-restricted-syntax
+    throw new SyntaxError(message);
   }
   const body = root.body[0].expression.callee.body;
   const state = {
     body,
     ancestors: [],
+    hoistedDeclarationStatements: [],
     replace(from, to, str) {
       for (let i = from; i < to; i++) {
         wrappedArray[i] = '';
@@ -145,7 +240,10 @@ function processTopLevelAwait(src) {
     state.append(last.expression, ')');
   }
 
-  return wrappedArray.join('');
+  return (
+    ArrayPrototypeJoin(state.hoistedDeclarationStatements, '') +
+    ArrayPrototypeJoin(wrappedArray, '')
+  );
 }
 
 module.exports = {
diff --git a/lib/internal/repl/history.js b/lib/internal/repl/history.js
index eb0394cc3b110e15aa22be0c9bcbc67816c2b924..74ef94e81070dcabc4f887dde904e437bdd4593f 100644
--- a/lib/internal/repl/history.js
+++ b/lib/internal/repl/history.js
@@ -1,7 +1,11 @@
 'use strict';
 
 const {
+  ArrayPrototypeJoin,
   Boolean,
+  FunctionPrototype,
+  StringPrototypeSplit,
+  StringPrototypeTrim,
 } = primordials;
 
 const { Interface } = require('readline');
@@ -13,6 +17,8 @@ let debug = require('internal/util/debuglog').debuglog('repl', (fn) => {
 });
 const { clearTimeout, setTimeout } = require('timers');
 
+const noop = FunctionPrototype;
+
 // XXX(chrisdickinson): The 15ms debounce value is somewhat arbitrary.
 // The debounce is to guard against code pasted into the REPL.
 const kDebounceHistoryMS = 15;
@@ -27,7 +33,7 @@ function _writeToOutput(repl, message) {
 function setupHistory(repl, historyPath, ready) {
   // Empty string disables persistent history
   if (typeof historyPath === 'string')
-    historyPath = historyPath.trim();
+    historyPath = StringPrototypeTrim(historyPath);
 
   if (historyPath === '') {
     repl._historyPrev = _replHistoryMessage;
@@ -84,7 +90,7 @@ function setupHistory(repl, historyPath, ready) {
     }
 
     if (data) {
-      repl.history = data.split(/[\n\r]+/, repl.historySize);
+      repl.history = StringPrototypeSplit(data, /[\n\r]+/, repl.historySize);
     } else {
       repl.history = [];
     }
@@ -99,6 +105,7 @@ function setupHistory(repl, historyPath, ready) {
     fs.ftruncate(hnd, 0, (err) => {
       repl._historyHandle = hnd;
       repl.on('line', online);
+      repl.once('exit', onexit);
 
       // Reading the file data out erases it
       repl.once('flushHistory', function() {
@@ -127,7 +134,7 @@ function setupHistory(repl, historyPath, ready) {
       return;
     }
     writing = true;
-    const historyData = repl.history.join(os.EOL);
+    const historyData = ArrayPrototypeJoin(repl.history, os.EOL);
     fs.write(repl._historyHandle, historyData, 0, 'utf8', onwritten);
   }
 
@@ -143,6 +150,15 @@ function setupHistory(repl, historyPath, ready) {
       }
     }
   }
+
+  function onexit() {
+    if (repl._flushing) {
+      repl.once('flushHistory', onexit);
+      return;
+    }
+    repl.off('line', online);
+    fs.close(repl._historyHandle, noop);
+  }
 }
 
 function _replHistoryMessage() {
diff --git a/lib/internal/repl/utils.js b/lib/internal/repl/utils.js
index 5c77cf9aa7aa02a3c30d004524f944cfaea5e4ed..7512db1b58991fb5e00475bd7d13ed5fadfe6bc9 100644
--- a/lib/internal/repl/utils.js
+++ b/lib/internal/repl/utils.js
@@ -1,21 +1,28 @@
 'use strict';
 
 const {
+  ArrayPrototypeFilter,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeMap,
+  Boolean,
+  FunctionPrototypeBind,
   MathMin,
-  Set,
+  RegExpPrototypeTest,
+  SafeSet,
+  SafeStringIterator,
+  StringPrototypeEndsWith,
+  StringPrototypeIndexOf,
+  StringPrototypeLastIndexOf,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeStartsWith,
+  StringPrototypeToLowerCase,
+  StringPrototypeTrim,
   Symbol,
 } = primordials;
 
 const { tokTypes: tt, Parser: AcornParser } =
   require('internal/deps/acorn/acorn/dist/acorn');
-const privateMethods =
-  require('internal/deps/acorn-plugins/acorn-private-methods/index');
-const classFields =
-  require('internal/deps/acorn-plugins/acorn-class-fields/index');
-const numericSeparator =
-  require('internal/deps/acorn-plugins/acorn-numeric-separator/index');
-const staticClassFeatures =
-  require('internal/deps/acorn-plugins/acorn-static-class-features/index');
 
 const { sendInspectorCommand } = require('internal/util/inspector');
 
@@ -50,6 +57,8 @@ const previewOptions = {
   showHidden: false
 };
 
+const REPL_MODE_STRICT = Symbol('repl-strict');
+
 // If the error is that we've unexpectedly ended the input,
 // then let the user try to recover by adding more input.
 // Note: `e` (the original exception) is not used by the current implementation,
@@ -59,7 +68,9 @@ function isRecoverableError(e, code) {
   // curly brace with parenthesis.  Note: only the open parenthesis is added
   // here as the point is to test for potentially valid but incomplete
   // expressions.
-  if (/^\s*\{/.test(code) && isRecoverableError(e, `(${code}`)) return true;
+  if (RegExpPrototypeTest(/^\s*\{/, code) &&
+      isRecoverableError(e, `(${code}`))
+    return true;
 
   let recoverable = false;
 
@@ -81,10 +92,6 @@ function isRecoverableError(e, code) {
   //
   const RecoverableParser = AcornParser
     .extend(
-      privateMethods,
-      classFields,
-      numericSeparator,
-      staticClassFeatures,
       (Parser) => {
         return class extends Parser {
           nextToken() {
@@ -100,9 +107,11 @@ function isRecoverableError(e, code) {
                 break;
 
               case 'Unterminated string constant':
-                const token = this.input.slice(this.lastTokStart, this.pos);
+                const token = StringPrototypeSlice(this.input,
+                                                   this.lastTokStart, this.pos);
                 // See https://www.ecma-international.org/ecma-262/#sec-line-terminators
-                if (/\\(?:\r\n?|\n|\u2028|\u2029)$/.test(token)) {
+                if (RegExpPrototypeTest(/\\(?:\r\n?|\n|\u2028|\u2029)$/,
+                                        token)) {
                   recoverable = true;
                 }
             }
@@ -115,7 +124,7 @@ function isRecoverableError(e, code) {
   // Try to parse the code with acorn.  If the parse fails, ignore the acorn
   // error and return the recoverable status.
   try {
-    RecoverableParser.parse(code, { ecmaVersion: 11 });
+    RecoverableParser.parse(code, { ecmaVersion: 'latest' });
 
     // Odd case: the underlying JS engine (V8, Chakra) rejected this input
     // but Acorn detected no issue.  Presume that additional text won't
@@ -138,17 +147,27 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
   let previewCompletionCounter = 0;
   let completionPreview = null;
 
+  let hasCompletions = false;
+
   let wrapped = false;
 
+  let escaped = null;
+
   function getPreviewPos() {
-    const displayPos = repl._getDisplayPos(`${repl._prompt}${repl.line}`);
+    const displayPos = repl._getDisplayPos(`${repl.getPrompt()}${repl.line}`);
     const cursorPos = repl.line.length !== repl.cursor ?
       repl.getCursorPos() :
       displayPos;
     return { displayPos, cursorPos };
   }
 
-  const clearPreview = () => {
+  function isCursorAtInputEnd() {
+    const { cursorPos, displayPos } = getPreviewPos();
+    return cursorPos.rows === displayPos.rows &&
+           cursorPos.cols === displayPos.cols;
+  }
+
+  const clearPreview = (key) => {
     if (inputPreview !== null) {
       const { displayPos, cursorPos } = getPreviewPos();
       const rows = displayPos.rows - cursorPos.rows + 1;
@@ -168,7 +187,7 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
         rows = pos.displayPos.rows - pos.cursorPos.rows;
         moveCursor(repl.output, 0, rows);
       }
-      const totalLine = `${repl._prompt}${repl.line}${completionPreview}`;
+      const totalLine = `${repl.getPrompt()}${repl.line}${completionPreview}`;
       const newPos = repl._getDisplayPos(totalLine);
       // Minimize work for the terminal. It is enough to clear the right part of
       // the current line in case the preview is visible on a single line.
@@ -181,8 +200,23 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
         cursorTo(repl.output, pos.cursorPos.cols);
         moveCursor(repl.output, 0, -rows);
       }
+      if (!key.ctrl && !key.shift) {
+        if (key.name === 'escape') {
+          if (escaped === null && key.meta) {
+            escaped = repl.line;
+          }
+        } else if ((key.name === 'return' || key.name === 'enter') &&
+                   !key.meta &&
+                   escaped !== repl.line &&
+                   isCursorAtInputEnd()) {
+          repl._insertString(completionPreview);
+        }
+      }
       completionPreview = null;
     }
+    if (escaped !== repl.line) {
+      escaped = null;
+    }
   };
 
   function showCompletionPreview(line, insertPreview) {
@@ -202,14 +236,16 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
       }
 
       // Result and the text that was completed.
-      const [rawCompletions, completeOn] = data;
+      const { 0: rawCompletions, 1: completeOn } = data;
 
       if (!rawCompletions || rawCompletions.length === 0) {
         return;
       }
 
+      hasCompletions = true;
+
       // If there is a common prefix to all matches, then apply that portion.
-      const completions = rawCompletions.filter((e) => e);
+      const completions = ArrayPrototypeFilter(rawCompletions, Boolean);
       const prefix = commonPrefix(completions);
 
       // No common prefix found.
@@ -217,7 +253,7 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
         return;
       }
 
-      const suffix = prefix.slice(completeOn.length);
+      const suffix = StringPrototypeSlice(prefix, completeOn.length);
 
       if (insertPreview) {
         repl._insertString(suffix);
@@ -237,18 +273,30 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
       }
       repl.output.write(result);
       cursorTo(repl.output, cursorPos.cols);
-      const totalLine = `${repl._prompt}${repl.line}${suffix}`;
+      const totalLine = `${repl.getPrompt()}${repl.line}${suffix}`;
       const newPos = repl._getDisplayPos(totalLine);
       const rows = newPos.rows - cursorPos.rows - (newPos.cols === 0 ? 1 : 0);
       moveCursor(repl.output, 0, -rows);
     });
   }
 
+  function isInStrictMode(repl) {
+    return repl.replMode === REPL_MODE_STRICT || ArrayPrototypeIncludes(
+      ArrayPrototypeMap(process.execArgv,
+                        (e) => StringPrototypeReplace(
+                          StringPrototypeToLowerCase(e),
+                          /_/g,
+                          '-'
+                        )),
+      '--use-strict');
+  }
+
   // This returns a code preview for arbitrary input code.
   function getInputPreview(input, callback) {
     // For similar reasons as `defaultEval`, wrap expressions starting with a
     // curly brace with parenthesis.
-    if (input.startsWith('{') && !input.endsWith(';') && !wrapped) {
+    if (StringPrototypeStartsWith(input, '{') &&
+        !StringPrototypeEndsWith(input, ';') && !wrapped) {
       input = `(${input})`;
       wrapped = true;
     }
@@ -271,8 +319,11 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
         // may be inspected.
         } else if (preview.exceptionDetails &&
                    (result.className === 'EvalError' ||
-                     result.className === 'SyntaxError' ||
-                     result.className === 'ReferenceError')) {
+                    result.className === 'SyntaxError' ||
+                    // Report ReferenceError in case the strict mode is active
+                    // for input that has no completions.
+                    (result.className === 'ReferenceError' &&
+                     (hasCompletions || !isInStrictMode(repl))))) {
           callback(null, null);
         } else if (result.objectId) {
           // The writer options might change and have influence on the inspect
@@ -311,21 +362,16 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
       return;
     }
 
-    const line = repl.line.trim();
+    const line = StringPrototypeTrim(repl.line);
 
     // Do not preview in case the line only contains whitespace.
     if (line === '') {
       return;
     }
 
+    hasCompletions = false;
+
     // Add the autocompletion preview.
-    // TODO(BridgeAR): Trigger the input preview after the completion preview.
-    // That way it's possible to trigger the input prefix including the
-    // potential completion suffix. To do so, we also have to change the
-    // behavior of `enter` and `escape`:
-    // Enter should automatically add the suffix to the current line as long as
-    // escape was not pressed. We might even remove the preview in case any
-    // cursor movement is triggered.
     const insertPreview = false;
     showCompletionPreview(repl.line, insertPreview);
 
@@ -371,7 +417,7 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
           getStringWidth(inspected) > maxColumns) {
         maxColumns -= 4 + (repl.useColors ? 0 : 3);
         let res = '';
-        for (const char of inspected) {
+        for (const char of new SafeStringIterator(inspected)) {
           maxColumns -= getStringWidth(char);
           if (maxColumns < 0)
             break;
@@ -382,9 +428,9 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
 
       // Line breaks are very rare and probably only occur in case of error
       // messages with line breaks.
-      const lineBreakPos = inspected.indexOf('\n');
+      const lineBreakPos = StringPrototypeIndexOf(inspected, '\n');
       if (lineBreakPos !== -1) {
-        inspected = `${inspected.slice(0, lineBreakPos)}`;
+        inspected = `${StringPrototypeSlice(inspected, 0, lineBreakPos)}`;
       }
 
       const result = repl.useColors ?
@@ -399,9 +445,17 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
       moveCursor(repl.output, 0, -rows - 1);
     };
 
-    getInputPreview(line, inputPreviewCallback);
+    let previewLine = line;
+
+    if (completionPreview !== null &&
+        isCursorAtInputEnd() &&
+        escaped !== repl.line) {
+      previewLine += completionPreview;
+    }
+
+    getInputPreview(previewLine, inputPreviewCallback);
     if (wrapped) {
-      getInputPreview(line, inputPreviewCallback);
+      getInputPreview(previewLine, inputPreviewCallback);
     }
     wrapped = false;
   };
@@ -414,7 +468,7 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
   // Refresh prints the whole screen again and the preview will be removed
   // during that procedure. Print the preview again. This also makes sure
   // the preview is always correct after resizing the terminal window.
-  const originalRefresh = repl._refreshLine.bind(repl);
+  const originalRefresh = FunctionPrototypeBind(repl._refreshLine, repl);
   repl._refreshLine = () => {
     inputPreview = null;
     originalRefresh();
@@ -424,7 +478,7 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
   let insertCompletionPreview = true;
   // Insert the longest common suffix of the current input in case the user
   // moves to the right while already being at the current input end.
-  const originalMoveCursor = repl._moveCursor.bind(repl);
+  const originalMoveCursor = FunctionPrototypeBind(repl._moveCursor, repl);
   repl._moveCursor = (dx) => {
     const currentCursor = repl.cursor;
     originalMoveCursor(dx);
@@ -438,7 +492,7 @@ function setupPreview(repl, contextSymbol, bufferSymbol, active) {
 
   // This is the only function that interferes with the completion insertion.
   // Monkey patch it to prevent inserting the completion when it shouldn't be.
-  const originalClearLine = repl.clearLine.bind(repl);
+  const originalClearLine = FunctionPrototypeBind(repl.clearLine, repl);
   repl.clearLine = () => {
     insertCompletionPreview = false;
     originalClearLine();
@@ -454,7 +508,7 @@ function setupReverseSearch(repl) {
     return { reverseSearch() { return false; } };
   }
 
-  const alreadyMatched = new Set();
+  const alreadyMatched = new SafeSet();
   const labels = {
     r: 'bck-i-search: ',
     s: 'fwd-i-search: '
@@ -518,9 +572,9 @@ function setupReverseSearch(repl) {
         if (cursor === -1) {
           cursor = entry.length;
         }
-        cursor = entry.lastIndexOf(input, cursor - 1);
+        cursor = StringPrototypeLastIndexOf(entry, input, cursor - 1);
       } else {
-        cursor = entry.indexOf(input, cursor + 1);
+        cursor = StringPrototypeIndexOf(entry, input, cursor + 1);
       }
       // Match not found.
       if (cursor === -1) {
@@ -528,8 +582,8 @@ function setupReverseSearch(repl) {
       // Match found.
       } else {
         if (repl.useColors) {
-          const start = entry.slice(0, cursor);
-          const end = entry.slice(cursor + input.length);
+          const start = StringPrototypeSlice(entry, 0, cursor);
+          const end = StringPrototypeSlice(entry, cursor + input.length);
           entry = `${start}\x1B[4m${input}\x1B[24m${end}`;
         }
         print(entry, `${labels[dir]}${input}_`, cursor);
@@ -572,8 +626,8 @@ function setupReverseSearch(repl) {
     // tick end instead of after each operation.
     let rows = 0;
     if (lastMatch !== -1) {
-      const line = repl.history[lastMatch].slice(0, lastCursor);
-      rows = repl._getDisplayPos(`${repl._prompt}${line}`).rows;
+      const line = StringPrototypeSlice(repl.history[lastMatch], 0, lastCursor);
+      rows = repl._getDisplayPos(`${repl.getPrompt()}${line}`).rows;
       cursorTo(repl.output, promptPos.cols);
     } else if (isInReverseSearch && repl.line !== '') {
       rows = repl.getCursorPos().rows;
@@ -593,8 +647,8 @@ function setupReverseSearch(repl) {
 
     // To know exactly how many rows we have to move the cursor back we need the
     // cursor rows, the output rows and the input rows.
-    const prompt = repl._prompt;
-    const cursorLine = `${prompt}${outputLine.slice(0, cursor)}`;
+    const prompt = repl.getPrompt();
+    const cursorLine = prompt + StringPrototypeSlice(outputLine, 0, cursor);
     const cursorPos = repl._getDisplayPos(cursorLine);
     const outputPos = repl._getDisplayPos(`${prompt}${outputLine}`);
     const inputPos = repl._getDisplayPos(inputLine);
@@ -644,7 +698,7 @@ function setupReverseSearch(repl) {
     if (!isInReverseSearch) {
       if (key.ctrl && checkAndSetDirectionKey(key.name)) {
         historyIndex = repl.historyIndex;
-        promptPos = repl._getDisplayPos(`${repl._prompt}`);
+        promptPos = repl._getDisplayPos(`${repl.getPrompt()}`);
         print(repl.line, `${labels[dir]}_`);
         isInReverseSearch = true;
       }
@@ -652,7 +706,7 @@ function setupReverseSearch(repl) {
       search();
     } else if (key.name === 'backspace' ||
         (key.ctrl && (key.name === 'h' || key.name === 'w'))) {
-      reset(input.slice(0, input.length - 1));
+      reset(StringPrototypeSlice(input, 0, input.length - 1));
       search();
       // Special handle <ctrl> + c and escape. Those should only cancel the
       // reverse search. The original line is visible afterwards again.
@@ -681,6 +735,8 @@ function setupReverseSearch(repl) {
 }
 
 module.exports = {
+  REPL_MODE_SLOPPY: Symbol('repl-sloppy'),
+  REPL_MODE_STRICT,
   isRecoverableError,
   kStandaloneREPL: Symbol('kStandaloneREPL'),
   setupPreview,
diff --git a/lib/internal/socketaddress.js b/lib/internal/socketaddress.js
new file mode 100644
index 0000000000000000000000000000000000000000..f3603e0521e96bb8ebe849f380873d5b969f4c17
--- /dev/null
+++ b/lib/internal/socketaddress.js
@@ -0,0 +1,156 @@
+'use strict';
+
+const {
+  ObjectSetPrototypeOf,
+  Symbol,
+} = primordials;
+
+const {
+  SocketAddress: _SocketAddress,
+  AF_INET,
+  AF_INET6,
+} = internalBinding('block_list');
+
+const {
+  validateObject,
+  validateString,
+  validatePort,
+  validateUint32,
+} = require('internal/validators');
+
+const {
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+  },
+} = require('internal/errors');
+
+const {
+  customInspectSymbol: kInspect,
+} = require('internal/util');
+
+const { inspect } = require('internal/util/inspect');
+
+const {
+  JSTransferable,
+  kClone,
+  kDeserialize,
+} = require('internal/worker/js_transferable');
+
+const kHandle = Symbol('kHandle');
+const kDetail = Symbol('kDetail');
+
+class SocketAddress extends JSTransferable {
+  static isSocketAddress(value) {
+    return value?.[kHandle] !== undefined;
+  }
+
+  constructor(options = {}) {
+    super();
+    validateObject(options, 'options');
+    let { family = 'ipv4' } = options;
+    const {
+      address = (family === 'ipv4' ? '127.0.0.1' : '::'),
+      port = 0,
+      flowlabel = 0,
+    } = options;
+
+    let type;
+    if (typeof family?.toLowerCase === 'function')
+      family = family.toLowerCase();
+    switch (family) {
+      case 'ipv4':
+        type = AF_INET;
+        break;
+      case 'ipv6':
+        type = AF_INET6;
+        break;
+      default:
+        throw new ERR_INVALID_ARG_VALUE('options.family', options.family);
+    }
+
+    validateString(address, 'options.address');
+    validatePort(port, 'options.port');
+    validateUint32(flowlabel, 'options.flowlabel', false);
+
+    this[kHandle] = new _SocketAddress(address, port, type, flowlabel);
+    this[kDetail] = this[kHandle].detail({
+      address: undefined,
+      port: undefined,
+      family: undefined,
+      flowlabel: undefined,
+    });
+  }
+
+  get address() {
+    return this[kDetail].address;
+  }
+
+  get port() {
+    return this[kDetail].port;
+  }
+
+  get family() {
+    return this[kDetail].family === AF_INET ? 'ipv4' : 'ipv6';
+  }
+
+  get flowlabel() {
+    // The flow label can be changed internally.
+    return this[kHandle].flowlabel();
+  }
+
+  [kInspect](depth, options) {
+    if (depth < 0)
+      return this;
+
+    const opts = {
+      ...options,
+      depth: options.depth == null ? null : options.depth - 1
+    };
+
+    return `SocketAddress ${inspect(this.toJSON(), opts)}`;
+  }
+
+  [kClone]() {
+    const handle = this[kHandle];
+    return {
+      data: { handle },
+      deserializeInfo: 'internal/socketaddress:InternalSocketAddress',
+    };
+  }
+
+  [kDeserialize]({ handle }) {
+    this[kHandle] = handle;
+    this[kDetail] = handle.detail({
+      address: undefined,
+      port: undefined,
+      family: undefined,
+      flowlabel: undefined,
+    });
+  }
+
+  toJSON() {
+    return {
+      address: this.address,
+      port: this.port,
+      family: this.family,
+      flowlabel: this.flowlabel,
+    };
+  }
+}
+
+class InternalSocketAddress extends JSTransferable {
+  constructor(handle) {
+    super();
+    this[kHandle] = handle;
+  }
+}
+
+InternalSocketAddress.prototype.constructor =
+  SocketAddress.prototype.construtor;
+ObjectSetPrototypeOf(InternalSocketAddress.prototype, SocketAddress.prototype);
+
+module.exports = {
+  SocketAddress,
+  InternalSocketAddress,
+  kHandle,
+};
diff --git a/lib/internal/source_map/prepare_stack_trace.js b/lib/internal/source_map/prepare_stack_trace.js
index 8a10470d077fed1aafb5c98c684af20905951a70..6b8d4e566ff1b1cd5ed5da04992f1d8a764c22f4 100644
--- a/lib/internal/source_map/prepare_stack_trace.js
+++ b/lib/internal/source_map/prepare_stack_trace.js
@@ -1,22 +1,32 @@
 'use strict';
 
 const {
-  Error,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ErrorPrototypeToString,
+  StringPrototypeRepeat,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+  SafeStringIterator,
 } = primordials;
 
 let debug = require('internal/util/debuglog').debuglog('source_map', (fn) => {
   debug = fn;
 });
+const { getStringWidth } = require('internal/util/inspect');
+const { readFileSync } = require('fs');
 const { findSourceMap } = require('internal/source_map/source_map_cache');
 const {
   kNoOverride,
   overrideStackTrace,
   maybeOverridePrepareStackTrace
 } = require('internal/errors');
+const { fileURLToPath } = require('internal/url');
 
 // Create a prettified stacktrace, inserting context from source maps
 // if possible.
-const ErrorToString = Error.prototype.toString; // Capture original toString.
 const prepareStackTrace = (globalThis, error, trace) => {
   // API for node internals to override error stack formatting
   // without interfering with userland code.
@@ -31,38 +41,153 @@ const prepareStackTrace = (globalThis, error, trace) => {
     maybeOverridePrepareStackTrace(globalThis, error, trace);
   if (globalOverride !== kNoOverride) return globalOverride;
 
-  const errorString = ErrorToString.call(error);
+  const errorString = ErrorPrototypeToString(error);
 
   if (trace.length === 0) {
     return errorString;
   }
-  const preparedTrace = trace.map((t, i) => {
-    let str = i !== 0 ? '\n    at ' : '';
-    str = `${str}${t}`;
+
+  let errorSource = '';
+  let lastSourceMap;
+  let lastFileName;
+  const preparedTrace = ArrayPrototypeJoin(ArrayPrototypeMap(trace, (t, i) => {
+    const str = i !== 0 ? '\n    at ' : '';
     try {
-      const sm = findSourceMap(t.getFileName(), error);
+      // A stack trace will often have several call sites in a row within the
+      // same file, cache the source map and file content accordingly:
+      const fileName = t.getFileName();
+      const sm = fileName === lastFileName ?
+        lastSourceMap :
+        findSourceMap(fileName);
+      lastSourceMap = sm;
+      lastFileName = fileName;
       if (sm) {
-        // Source Map V3 lines/columns use zero-based offsets whereas, in
-        // stack traces, they start at 1/1.
+        // Source Map V3 lines/columns start at 0/0 whereas stack traces
+        // start at 1/1:
         const {
           originalLine,
           originalColumn,
-          originalSource
+          originalSource,
         } = sm.findEntry(t.getLineNumber() - 1, t.getColumnNumber() - 1);
         if (originalSource && originalLine !== undefined &&
             originalColumn !== undefined) {
-          str +=
-`\n        -> ${originalSource.replace('file://', '')}:${originalLine + 1}:${originalColumn + 1}`;
+          const name = getOriginalSymbolName(sm, trace, i);
+          if (i === 0) {
+            errorSource = getErrorSource(
+              sm,
+              originalSource,
+              originalLine,
+              originalColumn
+            );
+          }
+          // Construct call site name based on: v8.dev/docs/stack-trace-api:
+          const fnName = t.getFunctionName() ?? t.getMethodName();
+          const originalName = `${t.getTypeName() !== 'global' ?
+            `${t.getTypeName()}.` : ''}${fnName ? fnName : '<anonymous>'}`;
+          // The original call site may have a different symbol name
+          // associated with it, use it:
+          const prefix = (name && name !== originalName) ?
+            `${name}` :
+            `${originalName ? originalName : ''}`;
+          const hasName = !!(name || originalName);
+          const originalSourceNoScheme =
+            StringPrototypeStartsWith(originalSource, 'file://') ?
+              fileURLToPath(originalSource) : originalSource;
+          // Replace the transpiled call site with the original:
+          return `${str}${prefix}${hasName ? ' (' : ''}` +
+            `${originalSourceNoScheme}:${originalLine + 1}:` +
+            `${originalColumn + 1}${hasName ? ')' : ''}`;
         }
       }
     } catch (err) {
       debug(err.stack);
     }
-    return str;
-  });
-  return `${errorString}\n    at ${preparedTrace.join('')}`;
+    return `${str}${t}`;
+  }), '');
+  return `${errorSource}${errorString}\n    at ${preparedTrace}`;
 };
 
+// Transpilers may have removed the original symbol name used in the stack
+// trace, if possible restore it from the names field of the source map:
+function getOriginalSymbolName(sourceMap, trace, curIndex) {
+  // First check for a symbol name associated with the enclosing function:
+  const enclosingEntry = sourceMap.findEntry(
+    trace[curIndex].getEnclosingLineNumber() - 1,
+    trace[curIndex].getEnclosingColumnNumber() - 1
+  );
+  if (enclosingEntry.name) return enclosingEntry.name;
+  // Fallback to using the symbol name attached to the next stack frame:
+  const currentFileName = trace[curIndex].getFileName();
+  const nextCallSite = trace[curIndex + 1];
+  if (nextCallSite && currentFileName === nextCallSite.getFileName()) {
+    const { name } = sourceMap.findEntry(
+      nextCallSite.getLineNumber() - 1,
+      nextCallSite.getColumnNumber() - 1
+    );
+    return name;
+  }
+}
+
+// Places a snippet of code from where the exception was originally thrown
+// above the stack trace. This logic is modeled after GetErrorSource in
+// node_errors.cc.
+function getErrorSource(
+  sourceMap,
+  originalSourcePath,
+  originalLine,
+  originalColumn
+) {
+  let exceptionLine = '';
+  const originalSourcePathNoScheme =
+    StringPrototypeStartsWith(originalSourcePath, 'file://') ?
+      fileURLToPath(originalSourcePath) : originalSourcePath;
+  const source = getOriginalSource(
+    sourceMap.payload,
+    originalSourcePathNoScheme
+  );
+  const lines = StringPrototypeSplit(source, /\r?\n/, originalLine + 1);
+  const line = lines[originalLine];
+  if (!line) return exceptionLine;
+
+  // Display ^ in appropriate position, regardless of whether tabs or
+  // spaces are used:
+  let prefix = '';
+  for (const character of new SafeStringIterator(
+    StringPrototypeSlice(line, 0, originalColumn + 1))) {
+    prefix += (character === '\t') ? '\t' :
+      StringPrototypeRepeat(' ', getStringWidth(character));
+  }
+  prefix = StringPrototypeSlice(prefix, 0, -1); // The last character is '^'.
+
+  exceptionLine =
+   `${originalSourcePathNoScheme}:${originalLine + 1}\n${line}\n${prefix}^\n\n`;
+  return exceptionLine;
+}
+
+function getOriginalSource(payload, originalSourcePath) {
+  let source;
+  const originalSourcePathNoScheme =
+    StringPrototypeStartsWith(originalSourcePath, 'file://') ?
+      fileURLToPath(originalSourcePath) : originalSourcePath;
+  const sourceContentIndex =
+    ArrayPrototypeIndexOf(payload.sources, originalSourcePath);
+  if (payload.sourcesContent?.[sourceContentIndex]) {
+    // First we check if the original source content was provided in the
+    // source map itself:
+    source = payload.sourcesContent[sourceContentIndex];
+  } else {
+    // If no sourcesContent was found, attempt to load the original source
+    // from disk:
+    try {
+      source = readFileSync(originalSourcePathNoScheme, 'utf8');
+    } catch (err) {
+      debug(err);
+      source = '';
+    }
+  }
+  return source;
+}
+
 module.exports = {
   prepareStackTrace,
 };
diff --git a/lib/internal/source_map/source_map.js b/lib/internal/source_map/source_map.js
index 7d21e02429a08672e6b80dcf3d138dab81b4bccb..99091a48465d50a4c34015fda349705c30b2a669 100644
--- a/lib/internal/source_map/source_map.js
+++ b/lib/internal/source_map/source_map.js
@@ -67,7 +67,12 @@
 'use strict';
 
 const {
-  ArrayIsArray
+  ArrayIsArray,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSort,
+  ObjectPrototypeHasOwnProperty,
+  StringPrototypeCharAt,
 } = primordials;
 
 const {
@@ -94,14 +99,14 @@ class StringCharIterator {
    * @return {string}
    */
   next() {
-    return this._string.charAt(this._position++);
+    return StringPrototypeCharAt(this._string, this._position++);
   }
 
   /**
    * @return {string}
    */
   peek() {
-    return this._string.charAt(this._position);
+    return StringPrototypeCharAt(this._string, this._position);
   }
 
   /**
@@ -158,7 +163,7 @@ class SourceMap {
     } else {
       this.#parseMap(this.#payload, 0, 0);
     }
-    this.#mappings.sort(compareSourceMapEntry);
+    ArrayPrototypeSort(this.#mappings, compareSourceMapEntry);
   }
 
   /**
@@ -203,24 +208,26 @@ class SourceMap {
       generatedColumn: entry[1],
       originalSource: entry[2],
       originalLine: entry[3],
-      originalColumn: entry[4]
+      originalColumn: entry[4],
+      name: entry[5],
     };
   }
 
   /**
    * @override
    */
-  #parseMap = (map, lineNumber, columnNumber) => {
+  #parseMap(map, lineNumber, columnNumber) {
     let sourceIndex = 0;
     let sourceLineNumber = 0;
     let sourceColumnNumber = 0;
+    let nameIndex = 0;
 
     const sources = [];
     const originalToCanonicalURLMap = {};
     for (let i = 0; i < map.sources.length; ++i) {
       const url = map.sources[i];
       originalToCanonicalURLMap[url] = url;
-      sources.push(url);
+      ArrayPrototypePush(sources, url);
       this.#sources[url] = true;
 
       if (map.sourcesContent && map.sourcesContent[i])
@@ -229,7 +236,6 @@ class SourceMap {
 
     const stringCharIterator = new StringCharIterator(map.mappings);
     let sourceURL = sources[sourceIndex];
-
     while (true) {
       if (stringCharIterator.peek() === ',')
         stringCharIterator.next();
@@ -245,7 +251,7 @@ class SourceMap {
 
       columnNumber += decodeVLQ(stringCharIterator);
       if (isSeparator(stringCharIterator.peek())) {
-        this.#mappings.push([lineNumber, columnNumber]);
+        ArrayPrototypePush(this.#mappings, [lineNumber, columnNumber]);
         continue;
       }
 
@@ -256,14 +262,20 @@ class SourceMap {
       }
       sourceLineNumber += decodeVLQ(stringCharIterator);
       sourceColumnNumber += decodeVLQ(stringCharIterator);
-      if (!isSeparator(stringCharIterator.peek()))
-        // Unused index into the names list.
-        decodeVLQ(stringCharIterator);
 
-      this.#mappings.push([lineNumber, columnNumber, sourceURL,
-                           sourceLineNumber, sourceColumnNumber]);
+      let name;
+      if (!isSeparator(stringCharIterator.peek())) {
+        nameIndex += decodeVLQ(stringCharIterator);
+        name = map.names?.[nameIndex];
+      }
+
+      ArrayPrototypePush(
+        this.#mappings,
+        [lineNumber, columnNumber, sourceURL, sourceLineNumber,
+         sourceColumnNumber, name]
+      );
     }
-  };
+  }
 }
 
 /**
@@ -316,8 +328,9 @@ function cloneSourceMapV3(payload) {
   }
   payload = { ...payload };
   for (const key in payload) {
-    if (payload.hasOwnProperty(key) && ArrayIsArray(payload[key])) {
-      payload[key] = payload[key].slice(0);
+    if (ObjectPrototypeHasOwnProperty(payload, key) &&
+        ArrayIsArray(payload[key])) {
+      payload[key] = ArrayPrototypeSlice(payload[key]);
     }
   }
   return payload;
@@ -330,8 +343,8 @@ function cloneSourceMapV3(payload) {
  * @return {number}
  */
 function compareSourceMapEntry(entry1, entry2) {
-  const [lineNumber1, columnNumber1] = entry1;
-  const [lineNumber2, columnNumber2] = entry2;
+  const { 0: lineNumber1, 1: columnNumber1 } = entry1;
+  const { 0: lineNumber2, 1: columnNumber2 } = entry2;
   if (lineNumber1 !== lineNumber2) {
     return lineNumber1 - lineNumber2;
   }
diff --git a/lib/internal/source_map/source_map_cache.js b/lib/internal/source_map/source_map_cache.js
index 8952940920b88fbf3537abc88f9029d1888f5b98..c0de6aeb51868f21b557c217acc96bd81dd5b1e9 100644
--- a/lib/internal/source_map/source_map_cache.js
+++ b/lib/internal/source_map/source_map_cache.js
@@ -1,20 +1,18 @@
 'use strict';
 
 const {
+  ArrayPrototypeMap,
   JSONParse,
   ObjectCreate,
   ObjectKeys,
   ObjectGetOwnPropertyDescriptor,
   ObjectPrototypeHasOwnProperty,
-  Map,
-  MapPrototypeEntries,
-  WeakMap,
-  WeakMapPrototypeGet,
-  uncurryThis,
+  RegExpPrototypeTest,
+  SafeMap,
+  StringPrototypeMatch,
+  StringPrototypeSplit,
 } = primordials;
 
-const MapIteratorNext = uncurryThis(MapPrototypeEntries(new Map()).next);
-
 function ObjectGetValueSafe(obj, key) {
   const desc = ObjectGetOwnPropertyDescriptor(obj, key);
   return ObjectPrototypeHasOwnProperty(desc, 'value') ? desc.value : undefined;
@@ -25,45 +23,73 @@ const { Buffer } = require('buffer');
 let debug = require('internal/util/debuglog').debuglog('source_map', (fn) => {
   debug = fn;
 });
-const { dirname, resolve } = require('path');
 const fs = require('fs');
 const { getOptionValue } = require('internal/options');
+const { IterableWeakMap } = require('internal/util/iterable_weak_map');
 const {
   normalizeReferrerURL,
 } = require('internal/modules/cjs/helpers');
-// For cjs, since Module._cache is exposed to users, we use a WeakMap
-// keyed on module, facilitating garbage collection.
-const cjsSourceMapCache = new WeakMap();
-// The esm cache is not exposed to users, so we can use a Map keyed
-// on filenames.
-const esmSourceMapCache = new Map();
-const { fileURLToPath, URL } = require('url');
-let Module;
+const { validateBoolean } = require('internal/validators');
+// Since the CJS module cache is mutable, which leads to memory leaks when
+// modules are deleted, we use a WeakMap so that the source map cache will
+// be purged automatically:
+const cjsSourceMapCache = new IterableWeakMap();
+// The esm cache is not mutable, so we can use a Map without memory concerns:
+const esmSourceMapCache = new SafeMap();
+const { fileURLToPath, pathToFileURL, URL } = require('internal/url');
 let SourceMap;
 
-let experimentalSourceMaps;
-function maybeCacheSourceMap(filename, content, cjsModuleInstance) {
-  if (experimentalSourceMaps === undefined) {
-    experimentalSourceMaps = getOptionValue('--enable-source-maps');
+let sourceMapsEnabled;
+function getSourceMapsEnabled() {
+  if (sourceMapsEnabled === undefined) {
+    setSourceMapsEnabled(getOptionValue('--enable-source-maps'));
+  }
+  return sourceMapsEnabled;
+}
+
+function setSourceMapsEnabled(val) {
+  validateBoolean(val, 'val');
+
+  const {
+    setSourceMapsEnabled,
+    setPrepareStackTraceCallback
+  } = internalBinding('errors');
+  setSourceMapsEnabled(val);
+  if (val) {
+    const {
+      prepareStackTrace
+    } = require('internal/source_map/prepare_stack_trace');
+    setPrepareStackTraceCallback(prepareStackTrace);
+  } else if (sourceMapsEnabled !== undefined) {
+    // Reset prepare stack trace callback only when disabling source maps.
+    const {
+      prepareStackTrace,
+    } = require('internal/errors');
+    setPrepareStackTraceCallback(prepareStackTrace);
   }
-  if (!(process.env.NODE_V8_COVERAGE || experimentalSourceMaps)) return;
-  let basePath;
+
+  sourceMapsEnabled = val;
+}
+
+function maybeCacheSourceMap(filename, content, cjsModuleInstance) {
+  const sourceMapsEnabled = getSourceMapsEnabled();
+  if (!(process.env.NODE_V8_COVERAGE || sourceMapsEnabled)) return;
   try {
     filename = normalizeReferrerURL(filename);
-    basePath = dirname(fileURLToPath(filename));
   } catch (err) {
     // This is most likely an [eval]-wrapper, which is currently not
     // supported.
     debug(err.stack);
     return;
   }
-
-  const match = content.match(/\/[*/]#\s+sourceMappingURL=(?<sourceMappingURL>[^\s]+)/);
+  const match = StringPrototypeMatch(
+    content,
+    /\/[*/]#\s+sourceMappingURL=(?<sourceMappingURL>[^\s]+)/
+  );
   if (match) {
-    const data = dataFromUrl(basePath, match.groups.sourceMappingURL);
+    const data = dataFromUrl(filename, match.groups.sourceMappingURL);
     const url = data ? null : match.groups.sourceMappingURL;
     if (cjsModuleInstance) {
-      if (!Module) Module = require('internal/modules/cjs/loader').Module;
       cjsSourceMapCache.set(cjsModuleInstance, {
         filename,
         lineLengths: lineLengths(content),
@@ -82,12 +108,12 @@ function maybeCacheSourceMap(filename, content, cjsModuleInstance) {
   }
 }
 
-function dataFromUrl(basePath, sourceMappingURL) {
+function dataFromUrl(sourceURL, sourceMappingURL) {
   try {
     const url = new URL(sourceMappingURL);
     switch (url.protocol) {
       case 'data:':
-        return sourceMapFromDataUrl(basePath, url.pathname);
+        return sourceMapFromDataUrl(sourceURL, url.pathname);
       default:
         debug(`unknown protocol ${url.protocol}`);
         return null;
@@ -95,8 +121,8 @@ function dataFromUrl(basePath, sourceMappingURL) {
   } catch (err) {
     debug(err.stack);
     // If no scheme is present, we assume we are dealing with a file path.
-    const sourceMapFile = resolve(basePath, sourceMappingURL);
-    return sourceMapFromFile(sourceMapFile);
+    const mapURL = new URL(sourceMappingURL, sourceURL).href;
+    return sourceMapFromFile(mapURL);
   }
 }
 
@@ -107,16 +133,16 @@ function lineLengths(content) {
   // We purposefully keep \r as part of the line-length calculation, in
   // cases where there is a \r\n separator, so that this can be taken into
   // account in coverage calculations.
-  return content.split(/\n|\u2028|\u2029/).map((line) => {
+  return ArrayPrototypeMap(StringPrototypeSplit(content, /\n|\u2028|\u2029/), (line) => {
     return line.length;
   });
 }
 
-function sourceMapFromFile(sourceMapFile) {
+function sourceMapFromFile(mapURL) {
   try {
-    const content = fs.readFileSync(sourceMapFile, 'utf8');
+    const content = fs.readFileSync(fileURLToPath(mapURL), 'utf8');
     const data = JSONParse(content);
-    return sourcesToAbsolute(dirname(sourceMapFile), data);
+    return sourcesToAbsolute(mapURL, data);
   } catch (err) {
     debug(err.stack);
     return null;
@@ -125,9 +151,9 @@ function sourceMapFromFile(sourceMapFile) {
 
 // data:[<mediatype>][;base64],<data> see:
 // https://tools.ietf.org/html/rfc2397#section-2
-function sourceMapFromDataUrl(basePath, url) {
-  const [format, data] = url.split(',');
-  const splitFormat = format.split(';');
+function sourceMapFromDataUrl(sourceURL, url) {
+  const { 0: format, 1: data } = StringPrototypeSplit(url, ',');
+  const splitFormat = StringPrototypeSplit(format, ';');
   const contentType = splitFormat[0];
   const base64 = splitFormat[splitFormat.length - 1] === 'base64';
   if (contentType === 'application/json') {
@@ -135,7 +161,7 @@ function sourceMapFromDataUrl(basePath, url) {
       Buffer.from(data, 'base64').toString('utf8') : data;
     try {
       const parsedData = JSONParse(decodedData);
-      return sourcesToAbsolute(basePath, parsedData);
+      return sourcesToAbsolute(sourceURL, parsedData);
     } catch (err) {
       debug(err.stack);
       return null;
@@ -149,14 +175,10 @@ function sourceMapFromDataUrl(basePath, url) {
 // If the sources are not absolute URLs after prepending of the "sourceRoot",
 // the sources are resolved relative to the SourceMap (like resolving script
 // src in a html document).
-function sourcesToAbsolute(base, data) {
+function sourcesToAbsolute(baseURL, data) {
   data.sources = data.sources.map((source) => {
     source = (data.sourceRoot || '') + source;
-    if (!/^[\\/]/.test(source[0])) {
-      source = resolve(base, source);
-    }
-    if (!source.startsWith('file://')) source = `file://${source}`;
-    return source;
+    return new URL(source, baseURL).href;
   });
   // The sources array is now resolved to absolute URLs, sourceRoot should
   // be updated to noop.
@@ -164,14 +186,6 @@ function sourcesToAbsolute(base, data) {
   return data;
 }
 
-// Move source map from garbage collected module to alternate key.
-function rekeySourceMap(cjsModuleInstance, newInstance) {
-  const sourceMap = cjsSourceMapCache.get(cjsModuleInstance);
-  if (sourceMap) {
-    cjsSourceMapCache.set(newInstance, sourceMap);
-  }
-}
-
 // WARNING: The `sourceMapCacheToObject` and `appendCJSCache` run during
 // shutdown. In particular, they also run when Workers are terminated, making
 // it important that they do not call out to any user-provided code, including
@@ -182,11 +196,7 @@ function rekeySourceMap(cjsModuleInstance, newInstance) {
 function sourceMapCacheToObject() {
   const obj = ObjectCreate(null);
 
-  const it = MapPrototypeEntries(esmSourceMapCache);
-  let entry;
-  while (!(entry = MapIteratorNext(it)).done) {
-    const k = entry.value[0];
-    const v = entry.value[1];
+  for (const { 0: k, 1: v } of esmSourceMapCache) {
     obj[k] = v;
   }
 
@@ -198,48 +208,32 @@ function sourceMapCacheToObject() {
   return obj;
 }
 
-// Since WeakMap can't be iterated over, we use Module._cache's
-// keys to facilitate Source Map serialization.
-//
-// TODO(bcoe): this means we don't currently serialize source-maps attached
-// to error instances, only module instances.
 function appendCJSCache(obj) {
-  if (!Module) return;
-  const cjsModuleCache = ObjectGetValueSafe(Module, '_cache');
-  const cjsModules = ObjectKeys(cjsModuleCache);
-  for (let i = 0; i < cjsModules.length; i++) {
-    const key = cjsModules[i];
-    const module = ObjectGetValueSafe(cjsModuleCache, key);
-    const value = WeakMapPrototypeGet(cjsSourceMapCache, module);
-    if (value) {
-      // This is okay because `obj` has a null prototype.
-      obj[`file://${key}`] = {
-        lineLengths: ObjectGetValueSafe(value, 'lineLengths'),
-        data: ObjectGetValueSafe(value, 'data'),
-        url: ObjectGetValueSafe(value, 'url')
-      };
-    }
+  for (const value of cjsSourceMapCache) {
+    obj[ObjectGetValueSafe(value, 'filename')] = {
+      lineLengths: ObjectGetValueSafe(value, 'lineLengths'),
+      data: ObjectGetValueSafe(value, 'data'),
+      url: ObjectGetValueSafe(value, 'url')
+    };
   }
 }
 
-// Attempt to lookup a source map, which is either attached to a file URI, or
-// keyed on an error instance.
-// TODO(bcoe): once WeakRefs are available in Node.js, refactor to drop
-// requirement of error parameter.
-function findSourceMap(uri, error) {
-  if (!Module) Module = require('internal/modules/cjs/loader').Module;
+function findSourceMap(sourceURL) {
+  if (!RegExpPrototypeTest(/^\w+:\/\//, sourceURL)) {
+    sourceURL = pathToFileURL(sourceURL).href;
+  }
   if (!SourceMap) {
     SourceMap = require('internal/source_map/source_map').SourceMap;
   }
-  let sourceMap = cjsSourceMapCache.get(Module._cache[uri]);
-  if (!uri.startsWith('file://')) uri = normalizeReferrerURL(uri);
-  if (sourceMap === undefined) {
-    sourceMap = esmSourceMapCache.get(uri);
-  }
+  let sourceMap = esmSourceMapCache.get(sourceURL);
   if (sourceMap === undefined) {
-    const candidateSourceMap = cjsSourceMapCache.get(error);
-    if (candidateSourceMap && uri === candidateSourceMap.filename) {
-      sourceMap = candidateSourceMap;
+    for (const value of cjsSourceMapCache) {
+      const filename = ObjectGetValueSafe(value, 'filename');
+      if (sourceURL === filename) {
+        sourceMap = {
+          data: ObjectGetValueSafe(value, 'data')
+        };
+      }
     }
   }
   if (sourceMap && sourceMap.data) {
@@ -250,7 +244,8 @@ function findSourceMap(uri, error) {
 
 module.exports = {
   findSourceMap,
+  getSourceMapsEnabled,
+  setSourceMapsEnabled,
   maybeCacheSourceMap,
-  rekeySourceMap,
   sourceMapCacheToObject,
 };
diff --git a/lib/internal/streams/async_iterator.js b/lib/internal/streams/async_iterator.js
deleted file mode 100644
index ced9c77c4f50e23bea16826468dcc2754b02675f..0000000000000000000000000000000000000000
--- a/lib/internal/streams/async_iterator.js
+++ /dev/null
@@ -1,205 +0,0 @@
-'use strict';
-
-const {
-  ObjectCreate,
-  ObjectGetPrototypeOf,
-  ObjectSetPrototypeOf,
-  Promise,
-  PromiseReject,
-  PromiseResolve,
-  Symbol,
-} = primordials;
-
-const finished = require('internal/streams/end-of-stream');
-
-const kLastResolve = Symbol('lastResolve');
-const kLastReject = Symbol('lastReject');
-const kError = Symbol('error');
-const kEnded = Symbol('ended');
-const kLastPromise = Symbol('lastPromise');
-const kHandlePromise = Symbol('handlePromise');
-const kStream = Symbol('stream');
-
-function createIterResult(value, done) {
-  return { value, done };
-}
-
-function readAndResolve(iter) {
-  const resolve = iter[kLastResolve];
-  if (resolve !== null) {
-    const data = iter[kStream].read();
-    // We defer if data is null. We can be expecting either 'end' or 'error'.
-    if (data !== null) {
-      iter[kLastPromise] = null;
-      iter[kLastResolve] = null;
-      iter[kLastReject] = null;
-      resolve(createIterResult(data, false));
-    }
-  }
-}
-
-function onReadable(iter) {
-  // We wait for the next tick, because it might
-  // emit an error with `process.nextTick()`.
-  process.nextTick(readAndResolve, iter);
-}
-
-function wrapForNext(lastPromise, iter) {
-  return (resolve, reject) => {
-    lastPromise.then(() => {
-      if (iter[kEnded]) {
-        resolve(createIterResult(undefined, true));
-        return;
-      }
-
-      iter[kHandlePromise](resolve, reject);
-    }, reject);
-  };
-}
-
-const AsyncIteratorPrototype = ObjectGetPrototypeOf(
-  ObjectGetPrototypeOf(async function* () {}).prototype);
-
-const ReadableStreamAsyncIteratorPrototype = ObjectSetPrototypeOf({
-  get stream() {
-    return this[kStream];
-  },
-
-  next() {
-    // If we have detected an error in the meanwhile
-    // reject straight away.
-    const error = this[kError];
-    if (error !== null) {
-      return PromiseReject(error);
-    }
-
-    if (this[kEnded]) {
-      return PromiseResolve(createIterResult(undefined, true));
-    }
-
-    if (this[kStream].destroyed) {
-      // We need to defer via nextTick because if .destroy(err) is
-      // called, the error will be emitted via nextTick, and
-      // we cannot guarantee that there is no error lingering around
-      // waiting to be emitted.
-      return new Promise((resolve, reject) => {
-        process.nextTick(() => {
-          if (this[kError]) {
-            reject(this[kError]);
-          } else {
-            resolve(createIterResult(undefined, true));
-          }
-        });
-      });
-    }
-
-    // If we have multiple next() calls we will wait for the previous Promise to
-    // finish. This logic is optimized to support for await loops, where next()
-    // is only called once at a time.
-    const lastPromise = this[kLastPromise];
-    let promise;
-
-    if (lastPromise) {
-      promise = new Promise(wrapForNext(lastPromise, this));
-    } else {
-      // Fast path needed to support multiple this.push()
-      // without triggering the next() queue.
-      const data = this[kStream].read();
-      if (data !== null) {
-        return PromiseResolve(createIterResult(data, false));
-      }
-
-      promise = new Promise(this[kHandlePromise]);
-    }
-
-    this[kLastPromise] = promise;
-
-    return promise;
-  },
-
-  return() {
-    return new Promise((resolve, reject) => {
-      const stream = this[kStream];
-
-      // TODO(ronag): Remove this check once finished() handles
-      // already ended and/or destroyed streams.
-      const ended = stream.destroyed || stream.readableEnded ||
-        (stream._readableState && stream._readableState.endEmitted);
-      if (ended) {
-        resolve(createIterResult(undefined, true));
-        return;
-      }
-
-      finished(stream, (err) => {
-        if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
-          reject(err);
-        } else {
-          resolve(createIterResult(undefined, true));
-        }
-      });
-      stream.destroy();
-    });
-  },
-}, AsyncIteratorPrototype);
-
-const createReadableStreamAsyncIterator = (stream) => {
-  const iterator = ObjectCreate(ReadableStreamAsyncIteratorPrototype, {
-    [kStream]: { value: stream, writable: true },
-    [kLastResolve]: { value: null, writable: true },
-    [kLastReject]: { value: null, writable: true },
-    [kError]: { value: null, writable: true },
-    [kEnded]: {
-      value: stream.readableEnded || stream._readableState.endEmitted,
-      writable: true
-    },
-    // The function passed to new Promise is cached so we avoid allocating a new
-    // closure at every run.
-    [kHandlePromise]: {
-      value: (resolve, reject) => {
-        const data = iterator[kStream].read();
-        if (data) {
-          iterator[kLastPromise] = null;
-          iterator[kLastResolve] = null;
-          iterator[kLastReject] = null;
-          resolve(createIterResult(data, false));
-        } else {
-          iterator[kLastResolve] = resolve;
-          iterator[kLastReject] = reject;
-        }
-      },
-      writable: true,
-    },
-  });
-  iterator[kLastPromise] = null;
-
-  finished(stream, { writable: false }, (err) => {
-    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
-      const reject = iterator[kLastReject];
-      // Reject if we are waiting for data in the Promise returned by next() and
-      // store the error.
-      if (reject !== null) {
-        iterator[kLastPromise] = null;
-        iterator[kLastResolve] = null;
-        iterator[kLastReject] = null;
-        reject(err);
-      }
-      iterator[kError] = err;
-      return;
-    }
-
-    const resolve = iterator[kLastResolve];
-    if (resolve !== null) {
-      iterator[kLastPromise] = null;
-      iterator[kLastResolve] = null;
-      iterator[kLastReject] = null;
-      resolve(createIterResult(undefined, true));
-    }
-    iterator[kEnded] = true;
-  });
-
-  stream.on('readable', onReadable.bind(null, iterator));
-
-  return iterator;
-};
-
-module.exports = createReadableStreamAsyncIterator;
diff --git a/lib/internal/streams/destroy.js b/lib/internal/streams/destroy.js
index e59a61de1feef5d03b0eeb3ad80519429ed73e49..c1a04ed6d8f6fba1ba69ded8730f43a0d38ff0fd 100644
--- a/lib/internal/streams/destroy.js
+++ b/lib/internal/streams/destroy.js
@@ -1,53 +1,67 @@
 'use strict';
 
-// Undocumented cb() API, needed for core, not for public API.
-// The cb() will be invoked synchronously if _destroy is synchronous.
+// Backwards compat. cb() is undocumented and unused in core but
+// unfortunately might be used by modules.
 function destroy(err, cb) {
-  const readableDestroyed = this._readableState &&
-    this._readableState.destroyed;
-  const writableDestroyed = this._writableState &&
-    this._writableState.destroyed;
+  const r = this._readableState;
+  const w = this._writableState;
 
-  if (readableDestroyed || writableDestroyed) {
-    if (cb) {
-      cb(err);
-    } else if (err) {
-      if (!this._writableState) {
-        process.nextTick(emitErrorNT, this, err);
-      } else if (!this._writableState.errorEmitted) {
-        this._writableState.errorEmitted = true;
-        process.nextTick(emitErrorNT, this, err);
-      }
+  if ((w && w.destroyed) || (r && r.destroyed)) {
+    if (typeof cb === 'function') {
+      cb();
     }
 
     return this;
   }
 
+  if (err) {
+    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
+    err.stack; // eslint-disable-line no-unused-expressions
+
+    if (w && !w.errored) {
+      w.errored = err;
+    }
+    if (r && !r.errored) {
+      r.errored = err;
+    }
+  }
+
   // We set destroyed to true before firing error callbacks in order
   // to make it re-entrance safe in case destroy() is called within callbacks
 
-  if (this._readableState) {
-    this._readableState.destroyed = true;
+  if (w) {
+    w.destroyed = true;
   }
-
-  // If this is a duplex stream mark the writable part as destroyed as well
-  if (this._writableState) {
-    this._writableState.destroyed = true;
+  if (r) {
+    r.destroyed = true;
   }
 
   this._destroy(err || null, (err) => {
-    if (!cb && err) {
-      if (!this._writableState) {
-        process.nextTick(emitErrorAndCloseNT, this, err);
-      } else if (!this._writableState.errorEmitted) {
-        this._writableState.errorEmitted = true;
-        process.nextTick(emitErrorAndCloseNT, this, err);
-      } else {
-        process.nextTick(emitCloseNT, this);
+    if (err) {
+      // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
+      err.stack; // eslint-disable-line no-unused-expressions
+
+      if (w && !w.errored) {
+        w.errored = err;
       }
-    } else if (cb) {
-      process.nextTick(emitCloseNT, this);
+      if (r && !r.errored) {
+        r.errored = err;
+      }
+    }
+
+    if (w) {
+      w.closed = true;
+    }
+    if (r) {
+      r.closed = true;
+    }
+
+    if (typeof cb === 'function') {
       cb(err);
+    }
+
+    if (err) {
+      process.nextTick(emitErrorCloseNT, this, err);
     } else {
       process.nextTick(emitCloseNT, this);
     }
@@ -56,60 +70,120 @@ function destroy(err, cb) {
   return this;
 }
 
-function emitErrorAndCloseNT(self, err) {
+function emitErrorCloseNT(self, err) {
   emitErrorNT(self, err);
   emitCloseNT(self);
 }
 
 function emitCloseNT(self) {
-  if (self._writableState && !self._writableState.emitClose)
-    return;
-  if (self._readableState && !self._readableState.emitClose)
-    return;
-  self.emit('close');
-}
+  const r = self._readableState;
+  const w = self._writableState;
 
-function undestroy() {
-  if (this._readableState) {
-    this._readableState.destroyed = false;
-    this._readableState.reading = false;
-    this._readableState.ended = false;
-    this._readableState.endEmitted = false;
+  if (r) {
+    r.closeEmitted = true;
   }
 
-  if (this._writableState) {
-    this._writableState.destroyed = false;
-    this._writableState.ended = false;
-    this._writableState.ending = false;
-    this._writableState.finalCalled = false;
-    this._writableState.prefinished = false;
-    this._writableState.finished = false;
-    this._writableState.errorEmitted = false;
+  if ((w && w.emitClose) || (r && r.emitClose)) {
+    self.emit('close');
   }
 }
 
 function emitErrorNT(self, err) {
+  const r = self._readableState;
+  const w = self._writableState;
+
+  if ((w && w.errorEmitted) || (r && r.errorEmitted)) {
+    return;
+  }
+
+  if (w) {
+    w.errorEmitted = true;
+  }
+  if (r) {
+    r.errorEmitted = true;
+  }
+
   self.emit('error', err);
 }
 
-function errorOrDestroy(stream, err) {
+function undestroy() {
+  const r = this._readableState;
+  const w = this._writableState;
+
+  if (r) {
+    r.closed = false;
+    r.closeEmitted = false;
+    r.destroyed = false;
+    r.errored = null;
+    r.errorEmitted = false;
+    r.reading = false;
+    r.ended = false;
+    r.endEmitted = false;
+  }
+
+  if (w) {
+    w.closed = false;
+    w.closeEmitted = false;
+    w.destroyed = false;
+    w.errored = null;
+    w.ended = false;
+    w.ending = false;
+    w.finalCalled = false;
+    w.prefinished = false;
+    w.finished = false;
+    w.errorEmitted = false;
+  }
+}
+
+function errorOrDestroy(stream, err, sync) {
   // We have tests that rely on errors being emitted
   // in the same tick, so changing this is semver major.
   // For now when you opt-in to autoDestroy we allow
   // the error to be emitted nextTick. In a future
   // semver major update we should change the default to this.
 
-  const rState = stream._readableState;
-  const wState = stream._writableState;
+  const r = stream._readableState;
+  const w = stream._writableState;
+
+  if ((w && w.destroyed) || (r && r.destroyed)) {
+    return this;
+  }
 
-  if ((rState && rState.autoDestroy) || (wState && wState.autoDestroy))
+  if ((r && r.autoDestroy) || (w && w.autoDestroy))
     stream.destroy(err);
-  else
-    stream.emit('error', err);
+  else if (err) {
+    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
+    err.stack; // eslint-disable-line no-unused-expressions
+
+    if (w && !w.errored) {
+      w.errored = err;
+    }
+    if (r && !r.errored) {
+      r.errored = err;
+    }
+
+    if (sync) {
+      process.nextTick(emitErrorNT, stream, err);
+    } else {
+      emitErrorNT(stream, err);
+    }
+  }
 }
 
+function isRequest(stream) {
+  return stream && stream.setHeader && typeof stream.abort === 'function';
+}
+
+// Normalize destroy for legacy.
+function destroyer(stream, err) {
+  if (isRequest(stream)) return stream.abort();
+  if (isRequest(stream.req)) return stream.req.abort();
+  if (typeof stream.destroy === 'function') return stream.destroy(err);
+  if (typeof stream.close === 'function') return stream.close();
+}
 
 module.exports = {
+  destroyer,
   destroy,
   undestroy,
   errorOrDestroy
diff --git a/lib/internal/streams/duplex.js b/lib/internal/streams/duplex.js
new file mode 100644
index 0000000000000000000000000000000000000000..596d30a90a0418e96f8dd8c6c85e5c3d1434a919
--- /dev/null
+++ b/lib/internal/streams/duplex.js
@@ -0,0 +1,110 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototype inheritance, this class
+// prototypically inherits from Readable, and then parasitically from
+// Writable.
+
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  ObjectGetOwnPropertyDescriptor,
+  ObjectKeys,
+  ObjectSetPrototypeOf,
+} = primordials;
+
+module.exports = Duplex;
+
+const Readable = require('internal/streams/readable');
+const Writable = require('internal/streams/writable');
+
+ObjectSetPrototypeOf(Duplex.prototype, Readable.prototype);
+ObjectSetPrototypeOf(Duplex, Readable);
+
+{
+  // Allow the keys array to be GC'ed.
+  for (const method of ObjectKeys(Writable.prototype)) {
+    if (!Duplex.prototype[method])
+      Duplex.prototype[method] = Writable.prototype[method];
+  }
+}
+
+function Duplex(options) {
+  if (!(this instanceof Duplex))
+    return new Duplex(options);
+
+  Readable.call(this, options);
+  Writable.call(this, options);
+  this.allowHalfOpen = true;
+
+  if (options) {
+    if (options.readable === false)
+      this.readable = false;
+
+    if (options.writable === false)
+      this.writable = false;
+
+    if (options.allowHalfOpen === false) {
+      this.allowHalfOpen = false;
+    }
+  }
+}
+
+ObjectDefineProperties(Duplex.prototype, {
+  writable:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writable'),
+  writableHighWaterMark:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableHighWaterMark'),
+  writableObjectMode:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableObjectMode'),
+  writableBuffer:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableBuffer'),
+  writableLength:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableLength'),
+  writableFinished:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableFinished'),
+  writableCorked:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableCorked'),
+  writableEnded:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableEnded'),
+  writableNeedDrain:
+    ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableNeedDrain'),
+
+  destroyed: {
+    get() {
+      if (this._readableState === undefined ||
+        this._writableState === undefined) {
+        return false;
+      }
+      return this._readableState.destroyed && this._writableState.destroyed;
+    },
+    set(value) {
+      // Backward compatibility, the user is explicitly
+      // managing destroyed.
+      if (this._readableState && this._writableState) {
+        this._readableState.destroyed = value;
+        this._writableState.destroyed = value;
+      }
+    }
+  }
+});
diff --git a/lib/internal/streams/end-of-stream.js b/lib/internal/streams/end-of-stream.js
index 877db6fbe1cb34a7d97bcfd364d3f0dab1b076e8..0d7067cd9caf6bde10ca6f60e25e385c17ee2301 100644
--- a/lib/internal/streams/end-of-stream.js
+++ b/lib/internal/streams/end-of-stream.js
@@ -25,14 +25,30 @@ function isWritable(stream) {
     !!stream._writableState;
 }
 
-function eos(stream, opts, callback) {
+function isWritableFinished(stream) {
+  if (stream.writableFinished) return true;
+  const wState = stream._writableState;
+  if (!wState || wState.errored) return false;
+  return wState.finished || (wState.ended && wState.length === 0);
+}
+
+function nop() {}
+
+function isReadableEnded(stream) {
+  if (stream.readableEnded) return true;
+  const rState = stream._readableState;
+  if (!rState || rState.errored) return false;
+  return rState.endEmitted || (rState.ended && rState.length === 0);
+}
+
+function eos(stream, options, callback) {
   if (arguments.length === 2) {
-    callback = opts;
-    opts = {};
-  } else if (opts == null) {
-    opts = {};
-  } else if (typeof opts !== 'object') {
-    throw new ERR_INVALID_ARG_TYPE('opts', 'object', opts);
+    callback = options;
+    options = {};
+  } else if (options == null) {
+    options = {};
+  } else if (typeof options !== 'object') {
+    throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
   }
   if (typeof callback !== 'function') {
     throw new ERR_INVALID_ARG_TYPE('callback', 'function', callback);
@@ -40,28 +56,55 @@ function eos(stream, opts, callback) {
 
   callback = once(callback);
 
-  let readable = opts.readable ||
-    (opts.readable !== false && isReadable(stream));
-  let writable = opts.writable ||
-    (opts.writable !== false && isWritable(stream));
+  const readable = options.readable ||
+    (options.readable !== false && isReadable(stream));
+  const writable = options.writable ||
+    (options.writable !== false && isWritable(stream));
+
+  const wState = stream._writableState;
+  const rState = stream._readableState;
+  const state = wState || rState;
 
   const onlegacyfinish = () => {
     if (!stream.writable) onfinish();
   };
 
-  let writableEnded = stream._writableState && stream._writableState.finished;
+  // TODO (ronag): Improve soft detection to include core modules and
+  // common ecosystem modules that do properly emit 'close' but fail
+  // this generic check.
+  let willEmitClose = (
+    state &&
+    state.autoDestroy &&
+    state.emitClose &&
+    state.closed === false &&
+    isReadable(stream) === readable &&
+    isWritable(stream) === writable
+  );
+
+  let writableFinished = stream.writableFinished ||
+    (wState && wState.finished);
   const onfinish = () => {
-    writable = false;
-    writableEnded = true;
-    if (!readable) callback.call(stream);
+    writableFinished = true;
+    // Stream should not be destroyed here. If it is that
+    // means that user space is doing something differently and
+    // we cannot trust willEmitClose.
+    if (stream.destroyed) willEmitClose = false;
+
+    if (willEmitClose && (!stream.readable || readable)) return;
+    if (!readable || readableEnded) callback.call(stream);
   };
 
   let readableEnded = stream.readableEnded ||
-    (stream._readableState && stream._readableState.endEmitted);
+    (rState && rState.endEmitted);
   const onend = () => {
-    readable = false;
     readableEnded = true;
-    if (!writable) callback.call(stream);
+    // Stream should not be destroyed here. If it is that
+    // means that user space is doing something differently and
+    // we cannot trust willEmitClose.
+    if (stream.destroyed) willEmitClose = false;
+
+    if (willEmitClose && (!stream.writable || writable)) return;
+    if (!writable || writableFinished) callback.call(stream);
   };
 
   const onerror = (err) => {
@@ -69,17 +112,15 @@ function eos(stream, opts, callback) {
   };
 
   const onclose = () => {
-    let err;
     if (readable && !readableEnded) {
-      if (!stream._readableState || !stream._readableState.ended)
-        err = new ERR_STREAM_PREMATURE_CLOSE();
-      return callback.call(stream, err);
+      if (!isReadableEnded(stream))
+        return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE());
     }
-    if (writable && !writableEnded) {
-      if (!stream._writableState || !stream._writableState.ended)
-        err = new ERR_STREAM_PREMATURE_CLOSE();
-      return callback.call(stream, err);
+    if (writable && !writableFinished) {
+      if (!isWritableFinished(stream))
+        return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE());
     }
+    callback.call(stream);
   };
 
   const onrequest = () => {
@@ -88,25 +129,52 @@ function eos(stream, opts, callback) {
 
   if (isRequest(stream)) {
     stream.on('complete', onfinish);
-    stream.on('abort', onclose);
+    if (!willEmitClose) {
+      stream.on('abort', onclose);
+    }
     if (stream.req) onrequest();
     else stream.on('request', onrequest);
-  } else if (writable && !stream._writableState) { // legacy streams
+  } else if (writable && !wState) { // legacy streams
     stream.on('end', onlegacyfinish);
     stream.on('close', onlegacyfinish);
   }
 
   // Not all streams will emit 'close' after 'aborted'.
-  if (typeof stream.aborted === 'boolean') {
+  if (!willEmitClose && typeof stream.aborted === 'boolean') {
     stream.on('aborted', onclose);
   }
 
   stream.on('end', onend);
   stream.on('finish', onfinish);
-  if (opts.error !== false) stream.on('error', onerror);
+  if (options.error !== false) stream.on('error', onerror);
   stream.on('close', onclose);
 
+  const closed = (
+    (wState && wState.closed) ||
+    (rState && rState.closed) ||
+    (wState && wState.errorEmitted) ||
+    (rState && rState.errorEmitted) ||
+    (rState && stream.req && stream.aborted) ||
+    (
+      (!writable || (wState && wState.finished)) &&
+      (!readable || (rState && rState.endEmitted))
+    )
+  );
+
+  if (closed) {
+    // TODO(ronag): Re-throw error if errorEmitted?
+    // TODO(ronag): Throw premature close as if finished was called?
+    // before being closed? i.e. if closed but not errored, ended or finished.
+    // TODO(ronag): Throw some kind of error? Does it make sense
+    // to call finished() on a "finished" stream?
+    // TODO(ronag): willEmitClose?
+    process.nextTick(() => {
+      callback();
+    });
+  }
+
   return function() {
+    callback = nop;
     stream.removeListener('aborted', onclose);
     stream.removeListener('complete', onfinish);
     stream.removeListener('abort', onclose);
diff --git a/lib/internal/streams/from.js b/lib/internal/streams/from.js
index 13e8a73980ddd17fe8f675d07107fe0a9363c144..949d0ceb6dae505fbb4bbd4e6d7adb573ffba717 100644
--- a/lib/internal/streams/from.js
+++ b/lib/internal/streams/from.js
@@ -38,11 +38,11 @@ function from(Readable, iterable, opts) {
     ...opts
   });
 
-  // Reading boolean to protect against _read
+  // Flag to protect against _read
   // being called before last iteration completion.
   let reading = false;
 
-  // needToClose boolean if iterator needs to be explicitly closed
+  // Flag for when iterator needs to be explicitly closed.
   let needToClose = false;
 
   readable._read = function() {
diff --git a/lib/internal/streams/legacy.js b/lib/internal/streams/legacy.js
index 2bc7a86aa050b622eb0ca96034c5d3e0bf9e6005..0a0d0571c46378b65f83a67867212fc46b679294 100644
--- a/lib/internal/streams/legacy.js
+++ b/lib/internal/streams/legacy.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   ObjectSetPrototypeOf,
 } = primordials;
 
@@ -58,12 +59,12 @@ Stream.prototype.pipe = function(dest, options) {
   function onerror(er) {
     cleanup();
     if (EE.listenerCount(this, 'error') === 0) {
-      throw er; // Unhandled stream error in pipe.
+      this.emit('error', er);
     }
   }
 
-  source.on('error', onerror);
-  dest.on('error', onerror);
+  prependListener(source, 'error', onerror);
+  prependListener(dest, 'error', onerror);
 
   // Remove all the event listeners that were added.
   function cleanup() {
@@ -92,4 +93,22 @@ Stream.prototype.pipe = function(dest, options) {
   return dest;
 };
 
-module.exports = Stream;
+function prependListener(emitter, event, fn) {
+  // Sadly this is not cacheable as some libraries bundle their own
+  // event emitter implementation with them.
+  if (typeof emitter.prependListener === 'function')
+    return emitter.prependListener(event, fn);
+
+  // This is a hack to make sure that our error handler is attached before any
+  // userland ones.  NEVER DO THIS. This is here only because this code needs
+  // to continue to work with older versions of Node.js that do not include
+  // the prependListener() method. The goal is to eventually remove this hack.
+  if (!emitter._events || !emitter._events[event])
+    emitter.on(event, fn);
+  else if (ArrayIsArray(emitter._events[event]))
+    emitter._events[event].unshift(fn);
+  else
+    emitter._events[event] = [fn, emitter._events[event]];
+}
+
+module.exports = { Stream, prependListener };
diff --git a/test/parallel/test-http-flush.js b/lib/internal/streams/passthrough.js
similarity index 65%
rename from test/parallel/test-http-flush.js
rename to lib/internal/streams/passthrough.js
index 24f43d5efecfa4689146eb3de659f3ae0b49402f..d37f9caf0116b57fd64b62402db9b0161bc66e4a 100644
--- a/test/parallel/test-http-flush.js
+++ b/lib/internal/streams/passthrough.js
@@ -19,19 +19,29 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
 'use strict';
-require('../common');
-const http = require('http');
-
-http.createServer(function(req, res) {
-  res.end('ok');
-  this.close();
-}).listen(0, '127.0.0.1', function() {
-  const req = http.request({
-    method: 'POST',
-    host: '127.0.0.1',
-    port: this.address().port,
-  });
-  req.flush();  // Flush the request headers.
-  req.flush();  // Should be idempotent.
-});
+
+const {
+  ObjectSetPrototypeOf,
+} = primordials;
+
+module.exports = PassThrough;
+
+const Transform = require('internal/streams/transform');
+ObjectSetPrototypeOf(PassThrough.prototype, Transform.prototype);
+ObjectSetPrototypeOf(PassThrough, Transform);
+
+function PassThrough(options) {
+  if (!(this instanceof PassThrough))
+    return new PassThrough(options);
+
+  Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+  cb(null, chunk);
+};
diff --git a/lib/internal/streams/pipeline.js b/lib/internal/streams/pipeline.js
index 92a91c30171af142f68fb7d1489d610c9eb4c9b8..16a5d2bbce9feb17ee0211a0f42a0bb977e5c6f7 100644
--- a/lib/internal/streams/pipeline.js
+++ b/lib/internal/streams/pipeline.js
@@ -5,55 +5,75 @@
 
 const {
   ArrayIsArray,
+  ReflectApply,
+  SymbolAsyncIterator,
 } = primordials;
 
 let eos;
 
 const { once } = require('internal/util');
+const destroyImpl = require('internal/streams/destroy');
 const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_RETURN_VALUE,
   ERR_INVALID_CALLBACK,
   ERR_MISSING_ARGS,
   ERR_STREAM_DESTROYED
 } = require('internal/errors').codes;
 
-function isRequest(stream) {
-  return stream && stream.setHeader && typeof stream.abort === 'function';
-}
+const {
+  isIterable,
+  isReadable,
+  isStream,
+} = require('internal/streams/utils');
+
+let EE;
+let PassThrough;
+let Readable;
 
 function destroyer(stream, reading, writing, callback) {
   callback = once(callback);
 
-  let closed = false;
+  let finished = false;
   stream.on('close', () => {
-    closed = true;
+    finished = true;
   });
 
   if (eos === undefined) eos = require('internal/streams/end-of-stream');
   eos(stream, { readable: reading, writable: writing }, (err) => {
-    if (err) return callback(err);
-    closed = true;
-    callback();
+    finished = !err;
+
+    const rState = stream._readableState;
+    if (
+      err &&
+      err.code === 'ERR_STREAM_PREMATURE_CLOSE' &&
+      reading &&
+      (rState && rState.ended && !rState.errored && !rState.errorEmitted)
+    ) {
+      // Some readable streams will emit 'close' before 'end'. However, since
+      // this is on the readable side 'end' should still be emitted if the
+      // stream has been ended and no error emitted. This should be allowed in
+      // favor of backwards compatibility. Since the stream is piped to a
+      // destination this should not result in any observable difference.
+      // We don't need to check if this is a writable premature close since
+      // eos will only fail with premature close on the reading side for
+      // duplex streams.
+      stream
+        .once('end', callback)
+        .once('error', callback);
+    } else {
+      callback(err);
+    }
   });
 
-  let destroyed = false;
   return (err) => {
-    if (closed) return;
-    if (destroyed) return;
-    destroyed = true;
-
-    // request.destroy just do .end - .abort is what we want
-    if (isRequest(stream)) return stream.abort();
-    if (isRequest(stream.req)) return stream.req.abort();
-    if (typeof stream.destroy === 'function') return stream.destroy(err);
-
+    if (finished) return;
+    finished = true;
+    destroyImpl.destroyer(stream, err);
     callback(err || new ERR_STREAM_DESTROYED('pipe'));
   };
 }
 
-function pipe(from, to) {
-  return from.pipe(to);
-}
-
 function popCallback(streams) {
   // Streams should never be an empty array. It should always contain at least
   // a single stream. Therefore optimize for the average case instead of
@@ -63,35 +83,187 @@ function popCallback(streams) {
   return streams.pop();
 }
 
+function makeAsyncIterable(val) {
+  if (isIterable(val)) {
+    return val;
+  } else if (isReadable(val)) {
+    // Legacy streams are not Iterable.
+    return fromReadable(val);
+  }
+  throw new ERR_INVALID_ARG_TYPE(
+    'val', ['Readable', 'Iterable', 'AsyncIterable'], val);
+}
+
+async function* fromReadable(val) {
+  if (!Readable) {
+    Readable = require('_stream_readable');
+  }
+  yield* Readable.prototype[SymbolAsyncIterator].call(val);
+}
+
+async function pump(iterable, writable, finish) {
+  if (!EE) {
+    EE = require('events');
+  }
+  let error;
+  try {
+    if (writable.writableNeedDrain === true) {
+      await EE.once(writable, 'drain');
+    }
+
+    for await (const chunk of iterable) {
+      if (!writable.write(chunk)) {
+        if (writable.destroyed) return;
+        await EE.once(writable, 'drain');
+      }
+    }
+    writable.end();
+  } catch (err) {
+    error = err;
+  } finally {
+    finish(error);
+  }
+}
+
 function pipeline(...streams) {
-  const callback = popCallback(streams);
+  const callback = once(popCallback(streams));
 
-  if (ArrayIsArray(streams[0])) streams = streams[0];
+  // stream.pipeline(streams, callback)
+  if (ArrayIsArray(streams[0]) && streams.length === 1) {
+    streams = streams[0];
+  }
 
   if (streams.length < 2) {
     throw new ERR_MISSING_ARGS('streams');
   }
 
   let error;
-  const destroys = streams.map(function(stream, i) {
+  let value;
+  const destroys = [];
+
+  let finishCount = 0;
+
+  function finish(err) {
+    const final = --finishCount === 0;
+
+    if (err && (!error || error.code === 'ERR_STREAM_PREMATURE_CLOSE')) {
+      error = err;
+    }
+
+    if (!error && !final) {
+      return;
+    }
+
+    while (destroys.length) {
+      destroys.shift()(error);
+    }
+
+    if (final) {
+      callback(error, value);
+    }
+  }
+
+  let ret;
+  for (let i = 0; i < streams.length; i++) {
+    const stream = streams[i];
     const reading = i < streams.length - 1;
     const writing = i > 0;
-    return destroyer(stream, reading, writing, function(err) {
-      if (!error) error = err;
-      if (err) {
-        for (const destroy of destroys) {
-          destroy(err);
+
+    if (isStream(stream)) {
+      finishCount++;
+      destroys.push(destroyer(stream, reading, writing, finish));
+    }
+
+    if (i === 0) {
+      if (typeof stream === 'function') {
+        ret = stream();
+        if (!isIterable(ret)) {
+          throw new ERR_INVALID_RETURN_VALUE(
+            'Iterable, AsyncIterable or Stream', 'source', ret);
         }
+      } else if (isIterable(stream) || isReadable(stream)) {
+        ret = stream;
+      } else {
+        throw new ERR_INVALID_ARG_TYPE(
+          'source', ['Stream', 'Iterable', 'AsyncIterable', 'Function'],
+          stream);
       }
-      if (reading) return;
-      for (const destroy of destroys) {
-        destroy();
+    } else if (typeof stream === 'function') {
+      ret = makeAsyncIterable(ret);
+      ret = stream(ret);
+
+      if (reading) {
+        if (!isIterable(ret, true)) {
+          throw new ERR_INVALID_RETURN_VALUE(
+            'AsyncIterable', `transform[${i - 1}]`, ret);
+        }
+      } else {
+        if (!PassThrough) {
+          PassThrough = require('internal/streams/passthrough');
+        }
+
+        // If the last argument to pipeline is not a stream
+        // we must create a proxy stream so that pipeline(...)
+        // always returns a stream which can be further
+        // composed through `.pipe(stream)`.
+
+        const pt = new PassThrough({
+          objectMode: true
+        });
+
+        // Handle Promises/A+ spec, `then` could be a getter that throws on
+        // second use.
+        const then = ret?.then;
+        if (typeof then === 'function') {
+          ReflectApply(then, ret, [
+            (val) => {
+              value = val;
+              pt.end(val);
+            }, (err) => {
+              pt.destroy(err);
+            },
+          ]);
+        } else if (isIterable(ret, true)) {
+          finishCount++;
+          pump(ret, pt, finish);
+        } else {
+          throw new ERR_INVALID_RETURN_VALUE(
+            'AsyncIterable or Promise', 'destination', ret);
+        }
+
+        ret = pt;
+
+        finishCount++;
+        destroys.push(destroyer(ret, false, true, finish));
       }
-      callback(error);
-    });
-  });
+    } else if (isStream(stream)) {
+      if (isReadable(ret)) {
+        ret.pipe(stream);
+
+        // Compat. Before node v10.12.0 stdio used to throw an error so
+        // pipe() did/does not end() stdio destinations.
+        // Now they allow it but "secretly" don't close the underlying fd.
+        if (stream === process.stdout || stream === process.stderr) {
+          ret.on('end', () => stream.end());
+        }
+      } else {
+        ret = makeAsyncIterable(ret);
+
+        finishCount++;
+        pump(ret, stream, finish);
+      }
+      ret = stream;
+    } else {
+      const name = reading ? `transform[${i - 1}]` : 'destination';
+      throw new ERR_INVALID_ARG_TYPE(
+        name, ['Stream', 'Function'], stream);
+    }
+  }
 
-  return streams.reduce(pipe);
+  // TODO(ronag): Consider returning a Duplex proxy if the first argument
+  // is a writable. Would improve composability.
+  // See, https://github.com/nodejs/node/issues/32020
+  return ret;
 }
 
 module.exports = pipeline;
diff --git a/lib/internal/streams/readable.js b/lib/internal/streams/readable.js
new file mode 100644
index 0000000000000000000000000000000000000000..30032360b3da60ae115e20a4616f031864a93ef5
--- /dev/null
+++ b/lib/internal/streams/readable.js
@@ -0,0 +1,1369 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const {
+  NumberIsInteger,
+  NumberIsNaN,
+  NumberParseInt,
+  ObjectDefineProperties,
+  ObjectSetPrototypeOf,
+  Promise,
+  Set,
+  SymbolAsyncIterator,
+  Symbol
+} = primordials;
+
+module.exports = Readable;
+Readable.ReadableState = ReadableState;
+
+const EE = require('events');
+const { Stream, prependListener } = require('internal/streams/legacy');
+const { Buffer } = require('buffer');
+
+let debug = require('internal/util/debuglog').debuglog('stream', (fn) => {
+  debug = fn;
+});
+const BufferList = require('internal/streams/buffer_list');
+const destroyImpl = require('internal/streams/destroy');
+const {
+  getHighWaterMark,
+  getDefaultHighWaterMark
+} = require('internal/streams/state');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_STREAM_PUSH_AFTER_EOF,
+  ERR_METHOD_NOT_IMPLEMENTED,
+  ERR_STREAM_UNSHIFT_AFTER_END_EVENT
+} = require('internal/errors').codes;
+
+const kPaused = Symbol('kPaused');
+
+// Lazy loaded to improve the startup performance.
+let StringDecoder;
+let from;
+
+ObjectSetPrototypeOf(Readable.prototype, Stream.prototype);
+ObjectSetPrototypeOf(Readable, Stream);
+function nop() {}
+
+const { errorOrDestroy } = destroyImpl;
+
+function ReadableState(options, stream, isDuplex) {
+  // Duplex streams are both readable and writable, but share
+  // the same options object.
+  // However, some cases require setting options to different
+  // values for the readable and the writable sides of the duplex stream.
+  // These options can be provided separately as readableXXX and writableXXX.
+  if (typeof isDuplex !== 'boolean')
+    isDuplex = stream instanceof Stream.Duplex;
+
+  // Object stream flag. Used to make read(n) ignore n and to
+  // make all the buffer merging and length checks go away.
+  this.objectMode = !!(options && options.objectMode);
+
+  if (isDuplex)
+    this.objectMode = this.objectMode ||
+      !!(options && options.readableObjectMode);
+
+  // The point at which it stops calling _read() to fill the buffer
+  // Note: 0 is a valid value, means "don't call _read preemptively ever"
+  this.highWaterMark = options ?
+    getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex) :
+    getDefaultHighWaterMark(false);
+
+  // A linked list is used to store data chunks instead of an array because the
+  // linked list can remove elements from the beginning faster than
+  // array.shift().
+  this.buffer = new BufferList();
+  this.length = 0;
+  this.pipes = [];
+  this.flowing = null;
+  this.ended = false;
+  this.endEmitted = false;
+  this.reading = false;
+
+  // A flag to be able to tell if the event 'readable'/'data' is emitted
+  // immediately, or on a later tick.  We set this to true at first, because
+  // any actions that shouldn't happen until "later" should generally also
+  // not happen before the first read call.
+  this.sync = true;
+
+  // Whenever we return null, then we set a flag to say
+  // that we're awaiting a 'readable' event emission.
+  this.needReadable = false;
+  this.emittedReadable = false;
+  this.readableListening = false;
+  this.resumeScheduled = false;
+  this[kPaused] = null;
+
+  // True if the error was already emitted and should not be thrown again.
+  this.errorEmitted = false;
+
+  // Should close be emitted on destroy. Defaults to true.
+  this.emitClose = !options || options.emitClose !== false;
+
+  // Should .destroy() be called after 'end' (and potentially 'finish').
+  this.autoDestroy = !options || options.autoDestroy !== false;
+
+  // Has it been destroyed.
+  this.destroyed = false;
+
+  // Indicates whether the stream has errored. When true no further
+  // _read calls, 'data' or 'readable' events should occur. This is needed
+  // since when autoDestroy is disabled we need a way to tell whether the
+  // stream has failed.
+  this.errored = null;
+
+  // Indicates whether the stream has finished destroying.
+  this.closed = false;
+
+  // True if close has been emitted or would have been emitted
+  // depending on emitClose.
+  this.closeEmitted = false;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8';
+
+  // Ref the piped dest which we need a drain event on it
+  // type: null | Writable | Set<Writable>.
+  this.awaitDrainWriters = null;
+  this.multiAwaitDrain = false;
+
+  // If true, a maybeReadMore has been scheduled.
+  this.readingMore = false;
+
+  this.dataEmitted = false;
+
+  this.decoder = null;
+  this.encoding = null;
+  if (options && options.encoding) {
+    if (!StringDecoder)
+      StringDecoder = require('string_decoder').StringDecoder;
+    this.decoder = new StringDecoder(options.encoding);
+    this.encoding = options.encoding;
+  }
+}
+
+
+function Readable(options) {
+  if (!(this instanceof Readable))
+    return new Readable(options);
+
+  // Checking for a Stream.Duplex instance is faster here instead of inside
+  // the ReadableState constructor, at least with V8 6.5.
+  const isDuplex = this instanceof Stream.Duplex;
+
+  this._readableState = new ReadableState(options, this, isDuplex);
+
+  if (options) {
+    if (typeof options.read === 'function')
+      this._read = options.read;
+
+    if (typeof options.destroy === 'function')
+      this._destroy = options.destroy;
+  }
+
+  Stream.call(this, options);
+}
+
+Readable.prototype.destroy = destroyImpl.destroy;
+Readable.prototype._undestroy = destroyImpl.undestroy;
+Readable.prototype._destroy = function(err, cb) {
+  cb(err);
+};
+
+Readable.prototype[EE.captureRejectionSymbol] = function(err) {
+  this.destroy(err);
+};
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+  return readableAddChunk(this, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read().
+Readable.prototype.unshift = function(chunk, encoding) {
+  return readableAddChunk(this, chunk, encoding, true);
+};
+
+function readableAddChunk(stream, chunk, encoding, addToFront) {
+  debug('readableAddChunk', chunk);
+  const state = stream._readableState;
+
+  let err;
+  if (!state.objectMode) {
+    if (typeof chunk === 'string') {
+      encoding = encoding || state.defaultEncoding;
+      if (state.encoding !== encoding) {
+        if (addToFront && state.encoding) {
+          // When unshifting, if state.encoding is set, we have to save
+          // the string in the BufferList with the state encoding.
+          chunk = Buffer.from(chunk, encoding).toString(state.encoding);
+        } else {
+          chunk = Buffer.from(chunk, encoding);
+          encoding = '';
+        }
+      }
+    } else if (chunk instanceof Buffer) {
+      encoding = '';
+    } else if (Stream._isUint8Array(chunk)) {
+      chunk = Stream._uint8ArrayToBuffer(chunk);
+      encoding = '';
+    } else if (chunk != null) {
+      err = new ERR_INVALID_ARG_TYPE(
+        'chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
+    }
+  }
+
+  if (err) {
+    errorOrDestroy(stream, err);
+  } else if (chunk === null) {
+    state.reading = false;
+    onEofChunk(stream, state);
+  } else if (state.objectMode || (chunk && chunk.length > 0)) {
+    if (addToFront) {
+      if (state.endEmitted)
+        errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
+      else
+        addChunk(stream, state, chunk, true);
+    } else if (state.ended) {
+      errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
+    } else if (state.destroyed) {
+      return false;
+    } else {
+      state.reading = false;
+      if (state.decoder && !encoding) {
+        chunk = state.decoder.write(chunk);
+        if (state.objectMode || chunk.length !== 0)
+          addChunk(stream, state, chunk, false);
+        else
+          maybeReadMore(stream, state);
+      } else {
+        addChunk(stream, state, chunk, false);
+      }
+    }
+  } else if (!addToFront) {
+    state.reading = false;
+    maybeReadMore(stream, state);
+  }
+
+  // We can push more data if we are below the highWaterMark.
+  // Also, if we have no data yet, we can stand some more bytes.
+  // This is to work around cases where hwm=0, such as the repl.
+  return !state.ended &&
+    (state.length < state.highWaterMark || state.length === 0);
+}
+
+function addChunk(stream, state, chunk, addToFront) {
+  if (state.flowing && state.length === 0 && !state.sync &&
+      stream.listenerCount('data') > 0) {
+    // Use the guard to avoid creating `Set()` repeatedly
+    // when we have multiple pipes.
+    if (state.multiAwaitDrain) {
+      state.awaitDrainWriters.clear();
+    } else {
+      state.awaitDrainWriters = null;
+    }
+    state.dataEmitted = true;
+    stream.emit('data', chunk);
+  } else {
+    // Update the buffer info.
+    state.length += state.objectMode ? 1 : chunk.length;
+    if (addToFront)
+      state.buffer.unshift(chunk);
+    else
+      state.buffer.push(chunk);
+
+    if (state.needReadable)
+      emitReadable(stream);
+  }
+  maybeReadMore(stream, state);
+}
+
+Readable.prototype.isPaused = function() {
+  const state = this._readableState;
+  return state[kPaused] === true || state.flowing === false;
+};
+
+// Backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+  if (!StringDecoder)
+    StringDecoder = require('string_decoder').StringDecoder;
+  const decoder = new StringDecoder(enc);
+  this._readableState.decoder = decoder;
+  // If setEncoding(null), decoder.encoding equals utf8.
+  this._readableState.encoding = this._readableState.decoder.encoding;
+
+  const buffer = this._readableState.buffer;
+  // Iterate over current buffer to convert already stored Buffers:
+  let content = '';
+  for (const data of buffer) {
+    content += decoder.write(data);
+  }
+  buffer.clear();
+  if (content !== '')
+    buffer.push(content);
+  this._readableState.length = content.length;
+  return this;
+};
+
+// Don't raise the hwm > 1GB.
+const MAX_HWM = 0x40000000;
+function computeNewHighWaterMark(n) {
+  if (n >= MAX_HWM) {
+    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
+    n = MAX_HWM;
+  } else {
+    // Get the next highest power of 2 to prevent increasing hwm excessively in
+    // tiny amounts.
+    n--;
+    n |= n >>> 1;
+    n |= n >>> 2;
+    n |= n >>> 4;
+    n |= n >>> 8;
+    n |= n >>> 16;
+    n++;
+  }
+  return n;
+}
+
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function howMuchToRead(n, state) {
+  if (n <= 0 || (state.length === 0 && state.ended))
+    return 0;
+  if (state.objectMode)
+    return 1;
+  if (NumberIsNaN(n)) {
+    // Only flow one buffer at a time.
+    if (state.flowing && state.length)
+      return state.buffer.first().length;
+    return state.length;
+  }
+  if (n <= state.length)
+    return n;
+  return state.ended ? state.length : 0;
+}
+
+// You can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+  debug('read', n);
+  // Same as NumberParseInt(undefined, 10), however V8 7.3 performance regressed
+  // in this scenario, so we are doing it manually.
+  if (n === undefined) {
+    n = NaN;
+  } else if (!NumberIsInteger(n)) {
+    n = NumberParseInt(n, 10);
+  }
+  const state = this._readableState;
+  const nOrig = n;
+
+  // If we're asking for more than the current hwm, then raise the hwm.
+  if (n > state.highWaterMark)
+    state.highWaterMark = computeNewHighWaterMark(n);
+
+  if (n !== 0)
+    state.emittedReadable = false;
+
+  // If we're doing read(0) to trigger a readable event, but we
+  // already have a bunch of data in the buffer, then just trigger
+  // the 'readable' event and move on.
+  if (n === 0 &&
+      state.needReadable &&
+      ((state.highWaterMark !== 0 ?
+        state.length >= state.highWaterMark :
+        state.length > 0) ||
+       state.ended)) {
+    debug('read: emitReadable', state.length, state.ended);
+    if (state.length === 0 && state.ended)
+      endReadable(this);
+    else
+      emitReadable(this);
+    return null;
+  }
+
+  n = howMuchToRead(n, state);
+
+  // If we've ended, and we're now clear, then finish it up.
+  if (n === 0 && state.ended) {
+    if (state.length === 0)
+      endReadable(this);
+    return null;
+  }
+
+  // All the actual chunk generation logic needs to be
+  // *below* the call to _read.  The reason is that in certain
+  // synthetic stream cases, such as passthrough streams, _read
+  // may be a completely synchronous operation which may change
+  // the state of the read buffer, providing enough data when
+  // before there was *not* enough.
+  //
+  // So, the steps are:
+  // 1. Figure out what the state of things will be after we do
+  // a read from the buffer.
+  //
+  // 2. If that resulting state will trigger a _read, then call _read.
+  // Note that this may be asynchronous, or synchronous.  Yes, it is
+  // deeply ugly to write APIs this way, but that still doesn't mean
+  // that the Readable class should behave improperly, as streams are
+  // designed to be sync/async agnostic.
+  // Take note if the _read call is sync or async (ie, if the read call
+  // has returned yet), so that we know whether or not it's safe to emit
+  // 'readable' etc.
+  //
+  // 3. Actually pull the requested chunks out of the buffer and return.
+
+  // if we need a readable event, then we need to do some reading.
+  let doRead = state.needReadable;
+  debug('need readable', doRead);
+
+  // If we currently have less than the highWaterMark, then also read some.
+  if (state.length === 0 || state.length - n < state.highWaterMark) {
+    doRead = true;
+    debug('length less than watermark', doRead);
+  }
+
+  // However, if we've ended, then there's no point, if we're already
+  // reading, then it's unnecessary, and if we're destroyed, then it's
+  // not allowed.
+  if (state.ended || state.reading || state.destroyed) {
+    doRead = false;
+    debug('reading or ended', doRead);
+  } else if (doRead) {
+    debug('do read');
+    state.reading = true;
+    state.sync = true;
+    // If the length is currently zero, then we *need* a readable event.
+    if (state.length === 0)
+      state.needReadable = true;
+    // Call internal read method
+    this._read(state.highWaterMark);
+    state.sync = false;
+    // If _read pushed data synchronously, then `reading` will be false,
+    // and we need to re-evaluate how much data we can return to the user.
+    if (!state.reading)
+      n = howMuchToRead(nOrig, state);
+  }
+
+  let ret;
+  if (n > 0)
+    ret = fromList(n, state);
+  else
+    ret = null;
+
+  if (ret === null) {
+    state.needReadable = state.length <= state.highWaterMark;
+    n = 0;
+  } else {
+    state.length -= n;
+    if (state.multiAwaitDrain) {
+      state.awaitDrainWriters.clear();
+    } else {
+      state.awaitDrainWriters = null;
+    }
+  }
+
+  if (state.length === 0) {
+    // If we have nothing in the buffer, then we want to know
+    // as soon as we *do* get something into the buffer.
+    if (!state.ended)
+      state.needReadable = true;
+
+    // If we tried to read() past the EOF, then emit end on the next tick.
+    if (nOrig !== n && state.ended)
+      endReadable(this);
+  }
+
+  if (ret !== null) {
+    state.dataEmitted = true;
+    this.emit('data', ret);
+  }
+
+  return ret;
+};
+
+function onEofChunk(stream, state) {
+  debug('onEofChunk');
+  if (state.ended) return;
+  if (state.decoder) {
+    const chunk = state.decoder.end();
+    if (chunk && chunk.length) {
+      state.buffer.push(chunk);
+      state.length += state.objectMode ? 1 : chunk.length;
+    }
+  }
+  state.ended = true;
+
+  if (state.sync) {
+    // If we are sync, wait until next tick to emit the data.
+    // Otherwise we risk emitting data in the flow()
+    // the readable code triggers during a read() call.
+    emitReadable(stream);
+  } else {
+    // Emit 'readable' now to make sure it gets picked up.
+    state.needReadable = false;
+    state.emittedReadable = true;
+    // We have to emit readable now that we are EOF. Modules
+    // in the ecosystem (e.g. dicer) rely on this event being sync.
+    emitReadable_(stream);
+  }
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow.  This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+  const state = stream._readableState;
+  debug('emitReadable', state.needReadable, state.emittedReadable);
+  state.needReadable = false;
+  if (!state.emittedReadable) {
+    debug('emitReadable', state.flowing);
+    state.emittedReadable = true;
+    process.nextTick(emitReadable_, stream);
+  }
+}
+
+function emitReadable_(stream) {
+  const state = stream._readableState;
+  debug('emitReadable_', state.destroyed, state.length, state.ended);
+  if (!state.destroyed && (state.length || state.ended)) {
+    stream.emit('readable');
+    state.emittedReadable = false;
+  }
+
+  // The stream needs another readable event if:
+  // 1. It is not flowing, as the flow mechanism will take
+  //    care of it.
+  // 2. It is not ended.
+  // 3. It is below the highWaterMark, so we can schedule
+  //    another readable later.
+  state.needReadable =
+    !state.flowing &&
+    !state.ended &&
+    state.length <= state.highWaterMark;
+  flow(stream);
+}
+
+
+// At this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data.  that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+  if (!state.readingMore) {
+    state.readingMore = true;
+    process.nextTick(maybeReadMore_, stream, state);
+  }
+}
+
+function maybeReadMore_(stream, state) {
+  // Attempt to read more data if we should.
+  //
+  // The conditions for reading more data are (one of):
+  // - Not enough data buffered (state.length < state.highWaterMark). The loop
+  //   is responsible for filling the buffer with enough data if such data
+  //   is available. If highWaterMark is 0 and we are not in the flowing mode
+  //   we should _not_ attempt to buffer any extra data. We'll get more data
+  //   when the stream consumer calls read() instead.
+  // - No data in the buffer, and the stream is in flowing mode. In this mode
+  //   the loop below is responsible for ensuring read() is called. Failing to
+  //   call read here would abort the flow and there's no other mechanism for
+  //   continuing the flow if the stream consumer has just subscribed to the
+  //   'data' event.
+  //
+  // In addition to the above conditions to keep reading data, the following
+  // conditions prevent the data from being read:
+  // - The stream has ended (state.ended).
+  // - There is already a pending 'read' operation (state.reading). This is a
+  //   case where the stream has called the implementation defined _read()
+  //   method, but they are processing the call asynchronously and have _not_
+  //   called push() with new data. In this case we skip performing more
+  //   read()s. The execution ends in this method again after the _read() ends
+  //   up calling push() with more data.
+  while (!state.reading && !state.ended &&
+         (state.length < state.highWaterMark ||
+          (state.flowing && state.length === 0))) {
+    const len = state.length;
+    debug('maybeReadMore read 0');
+    stream.read(0);
+    if (len === state.length)
+      // Didn't get any data, stop spinning.
+      break;
+  }
+  state.readingMore = false;
+}
+
+// Abstract method.  to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+  throw new ERR_METHOD_NOT_IMPLEMENTED('_read()');
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+  const src = this;
+  const state = this._readableState;
+
+  if (state.pipes.length === 1) {
+    if (!state.multiAwaitDrain) {
+      state.multiAwaitDrain = true;
+      state.awaitDrainWriters = new Set(
+        state.awaitDrainWriters ? [state.awaitDrainWriters] : []
+      );
+    }
+  }
+
+  state.pipes.push(dest);
+  debug('pipe count=%d opts=%j', state.pipes.length, pipeOpts);
+
+  const doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+              dest !== process.stdout &&
+              dest !== process.stderr;
+
+  const endFn = doEnd ? onend : unpipe;
+  if (state.endEmitted)
+    process.nextTick(endFn);
+  else
+    src.once('end', endFn);
+
+  dest.on('unpipe', onunpipe);
+  function onunpipe(readable, unpipeInfo) {
+    debug('onunpipe');
+    if (readable === src) {
+      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+        unpipeInfo.hasUnpiped = true;
+        cleanup();
+      }
+    }
+  }
+
+  function onend() {
+    debug('onend');
+    dest.end();
+  }
+
+  let ondrain;
+
+  let cleanedUp = false;
+  function cleanup() {
+    debug('cleanup');
+    // Cleanup event handlers once the pipe is broken.
+    dest.removeListener('close', onclose);
+    dest.removeListener('finish', onfinish);
+    if (ondrain) {
+      dest.removeListener('drain', ondrain);
+    }
+    dest.removeListener('error', onerror);
+    dest.removeListener('unpipe', onunpipe);
+    src.removeListener('end', onend);
+    src.removeListener('end', unpipe);
+    src.removeListener('data', ondata);
+
+    cleanedUp = true;
+
+    // If the reader is waiting for a drain event from this
+    // specific writer, then it would cause it to never start
+    // flowing again.
+    // So, if this is awaiting a drain, then we just call it now.
+    // If we don't know, then assume that we are waiting for one.
+    if (ondrain && state.awaitDrainWriters &&
+        (!dest._writableState || dest._writableState.needDrain))
+      ondrain();
+  }
+
+  function pause() {
+    // If the user unpiped during `dest.write()`, it is possible
+    // to get stuck in a permanently paused state if that write
+    // also returned false.
+    // => Check whether `dest` is still a piping destination.
+    if (!cleanedUp) {
+      if (state.pipes.length === 1 && state.pipes[0] === dest) {
+        debug('false write response, pause', 0);
+        state.awaitDrainWriters = dest;
+        state.multiAwaitDrain = false;
+      } else if (state.pipes.length > 1 && state.pipes.includes(dest)) {
+        debug('false write response, pause', state.awaitDrainWriters.size);
+        state.awaitDrainWriters.add(dest);
+      }
+      src.pause();
+    }
+    if (!ondrain) {
+      // When the dest drains, it reduces the awaitDrain counter
+      // on the source.  This would be more elegant with a .once()
+      // handler in flow(), but adding and removing repeatedly is
+      // too slow.
+      ondrain = pipeOnDrain(src, dest);
+      dest.on('drain', ondrain);
+    }
+  }
+
+  src.on('data', ondata);
+  function ondata(chunk) {
+    debug('ondata');
+    const ret = dest.write(chunk);
+    debug('dest.write', ret);
+    if (ret === false) {
+      pause();
+    }
+  }
+
+  // If the dest has an error, then stop piping into it.
+  // However, don't suppress the throwing behavior for this.
+  function onerror(er) {
+    debug('onerror', er);
+    unpipe();
+    dest.removeListener('error', onerror);
+    if (EE.listenerCount(dest, 'error') === 0) {
+      const s = dest._writableState || dest._readableState;
+      if (s && !s.errorEmitted) {
+        // User incorrectly emitted 'error' directly on the stream.
+        errorOrDestroy(dest, er);
+      } else {
+        dest.emit('error', er);
+      }
+    }
+  }
+
+  // Make sure our error handler is attached before userland ones.
+  prependListener(dest, 'error', onerror);
+
+  // Both close and finish should trigger unpipe, but only once.
+  function onclose() {
+    dest.removeListener('finish', onfinish);
+    unpipe();
+  }
+  dest.once('close', onclose);
+  function onfinish() {
+    debug('onfinish');
+    dest.removeListener('close', onclose);
+    unpipe();
+  }
+  dest.once('finish', onfinish);
+
+  function unpipe() {
+    debug('unpipe');
+    src.unpipe(dest);
+  }
+
+  // Tell the dest that it's being piped to.
+  dest.emit('pipe', src);
+
+  // Start the flow if it hasn't been started already.
+
+  if (dest.writableNeedDrain === true) {
+    if (state.flowing) {
+      pause();
+    }
+  } else if (!state.flowing) {
+    debug('pipe resume');
+    src.resume();
+  }
+
+  return dest;
+};
+
+function pipeOnDrain(src, dest) {
+  return function pipeOnDrainFunctionResult() {
+    const state = src._readableState;
+
+    // `ondrain` will call directly,
+    // `this` maybe not a reference to dest,
+    // so we use the real dest here.
+    if (state.awaitDrainWriters === dest) {
+      debug('pipeOnDrain', 1);
+      state.awaitDrainWriters = null;
+    } else if (state.multiAwaitDrain) {
+      debug('pipeOnDrain', state.awaitDrainWriters.size);
+      state.awaitDrainWriters.delete(dest);
+    }
+
+    if ((!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) &&
+      EE.listenerCount(src, 'data')) {
+      state.flowing = true;
+      flow(src);
+    }
+  };
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+  const state = this._readableState;
+  const unpipeInfo = { hasUnpiped: false };
+
+  // If we're not piping anywhere, then do nothing.
+  if (state.pipes.length === 0)
+    return this;
+
+  if (!dest) {
+    // remove all.
+    const dests = state.pipes;
+    state.pipes = [];
+    this.pause();
+
+    for (let i = 0; i < dests.length; i++)
+      dests[i].emit('unpipe', this, { hasUnpiped: false });
+    return this;
+  }
+
+  // Try to find the right one.
+  const index = state.pipes.indexOf(dest);
+  if (index === -1)
+    return this;
+
+  state.pipes.splice(index, 1);
+  if (state.pipes.length === 0)
+    this.pause();
+
+  dest.emit('unpipe', this, unpipeInfo);
+
+  return this;
+};
+
+// Set up data events if they are asked for
+// Ensure readable listeners eventually get something.
+Readable.prototype.on = function(ev, fn) {
+  const res = Stream.prototype.on.call(this, ev, fn);
+  const state = this._readableState;
+
+  if (ev === 'data') {
+    // Update readableListening so that resume() may be a no-op
+    // a few lines down. This is needed to support once('readable').
+    state.readableListening = this.listenerCount('readable') > 0;
+
+    // Try start flowing on next tick if stream isn't explicitly paused.
+    if (state.flowing !== false)
+      this.resume();
+  } else if (ev === 'readable') {
+    if (!state.endEmitted && !state.readableListening) {
+      state.readableListening = state.needReadable = true;
+      state.flowing = false;
+      state.emittedReadable = false;
+      debug('on readable', state.length, state.reading);
+      if (state.length) {
+        emitReadable(this);
+      } else if (!state.reading) {
+        process.nextTick(nReadingNextTick, this);
+      }
+    }
+  }
+
+  return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+Readable.prototype.removeListener = function(ev, fn) {
+  const res = Stream.prototype.removeListener.call(this, ev, fn);
+
+  if (ev === 'readable') {
+    // We need to check if there is someone still listening to
+    // readable and reset the state. However this needs to happen
+    // after readable has been emitted but before I/O (nextTick) to
+    // support once('readable', fn) cycles. This means that calling
+    // resume within the same tick will have no
+    // effect.
+    process.nextTick(updateReadableListening, this);
+  }
+
+  return res;
+};
+Readable.prototype.off = Readable.prototype.removeListener;
+
+Readable.prototype.removeAllListeners = function(ev) {
+  const res = Stream.prototype.removeAllListeners.apply(this, arguments);
+
+  if (ev === 'readable' || ev === undefined) {
+    // We need to check if there is someone still listening to
+    // readable and reset the state. However this needs to happen
+    // after readable has been emitted but before I/O (nextTick) to
+    // support once('readable', fn) cycles. This means that calling
+    // resume within the same tick will have no
+    // effect.
+    process.nextTick(updateReadableListening, this);
+  }
+
+  return res;
+};
+
+function updateReadableListening(self) {
+  const state = self._readableState;
+  state.readableListening = self.listenerCount('readable') > 0;
+
+  if (state.resumeScheduled && state[kPaused] === false) {
+    // Flowing needs to be set to true now, otherwise
+    // the upcoming resume will not flow.
+    state.flowing = true;
+
+    // Crude way to check if we should resume.
+  } else if (self.listenerCount('data') > 0) {
+    self.resume();
+  } else if (!state.readableListening) {
+    state.flowing = null;
+  }
+}
+
+function nReadingNextTick(self) {
+  debug('readable nexttick read 0');
+  self.read(0);
+}
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+  const state = this._readableState;
+  if (!state.flowing) {
+    debug('resume');
+    // We flow only if there is no one listening
+    // for readable, but we still have to call
+    // resume().
+    state.flowing = !state.readableListening;
+    resume(this, state);
+  }
+  state[kPaused] = false;
+  return this;
+};
+
+function resume(stream, state) {
+  if (!state.resumeScheduled) {
+    state.resumeScheduled = true;
+    process.nextTick(resume_, stream, state);
+  }
+}
+
+function resume_(stream, state) {
+  debug('resume', state.reading);
+  if (!state.reading) {
+    stream.read(0);
+  }
+
+  state.resumeScheduled = false;
+  stream.emit('resume');
+  flow(stream);
+  if (state.flowing && !state.reading)
+    stream.read(0);
+}
+
+Readable.prototype.pause = function() {
+  debug('call pause flowing=%j', this._readableState.flowing);
+  if (this._readableState.flowing !== false) {
+    debug('pause');
+    this._readableState.flowing = false;
+    this.emit('pause');
+  }
+  this._readableState[kPaused] = true;
+  return this;
+};
+
+function flow(stream) {
+  const state = stream._readableState;
+  debug('flow', state.flowing);
+  while (state.flowing && stream.read() !== null);
+}
+
+// Wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+  const state = this._readableState;
+  let paused = false;
+
+  stream.on('end', () => {
+    debug('wrapped end');
+    if (state.decoder && !state.ended) {
+      const chunk = state.decoder.end();
+      if (chunk && chunk.length)
+        this.push(chunk);
+    }
+
+    this.push(null);
+  });
+
+  stream.on('data', (chunk) => {
+    debug('wrapped data');
+    if (state.decoder)
+      chunk = state.decoder.write(chunk);
+
+    // Don't skip over falsy values in objectMode.
+    if (state.objectMode && (chunk === null || chunk === undefined))
+      return;
+    else if (!state.objectMode && (!chunk || !chunk.length))
+      return;
+
+    const ret = this.push(chunk);
+    if (!ret) {
+      paused = true;
+      stream.pause();
+    }
+  });
+
+  // Proxy all the other methods. Important when wrapping filters and duplexes.
+  for (const i in stream) {
+    if (this[i] === undefined && typeof stream[i] === 'function') {
+      this[i] = function methodWrap(method) {
+        return function methodWrapReturnFunction() {
+          return stream[method].apply(stream, arguments);
+        };
+      }(i);
+    }
+  }
+
+  stream.on('error', (err) => {
+    errorOrDestroy(this, err);
+  });
+
+  stream.on('close', () => {
+    // TODO(ronag): Update readable state?
+    this.emit('close');
+  });
+
+  stream.on('destroy', () => {
+    // TODO(ronag): this.destroy()?
+    this.emit('destroy');
+  });
+
+  stream.on('pause', () => {
+    // TODO(ronag): this.pause()?
+    this.emit('pause');
+  });
+
+  stream.on('resume', () => {
+    // TODO(ronag): this.resume()?
+    this.emit('resume');
+  });
+
+  // When we try to consume some more bytes, simply unpause the
+  // underlying stream.
+  this._read = (n) => {
+    debug('wrapped _read', n);
+    if (paused) {
+      paused = false;
+      stream.resume();
+    }
+  };
+
+  return this;
+};
+
+Readable.prototype[SymbolAsyncIterator] = function() {
+  let stream = this;
+
+  if (typeof stream.read !== 'function') {
+    // v1 stream
+    const src = stream;
+    stream = new Readable({
+      objectMode: true,
+      destroy(err, callback) {
+        destroyImpl.destroyer(src, err);
+        callback(err);
+      }
+    }).wrap(src);
+  }
+
+  const iter = createAsyncIterator(stream);
+  iter.stream = stream;
+  return iter;
+};
+
+async function* createAsyncIterator(stream) {
+  let callback = nop;
+
+  function next(resolve) {
+    if (this === stream) {
+      callback();
+      callback = nop;
+    } else {
+      callback = resolve;
+    }
+  }
+
+  const state = stream._readableState;
+
+  let error = state.errored;
+  let errorEmitted = state.errorEmitted;
+  let endEmitted = state.endEmitted;
+  let closeEmitted = state.closeEmitted;
+
+  stream
+    .on('readable', next)
+    .on('error', function(err) {
+      error = err;
+      errorEmitted = true;
+      next.call(this);
+    })
+    .on('end', function() {
+      endEmitted = true;
+      next.call(this);
+    })
+    .on('close', function() {
+      closeEmitted = true;
+      next.call(this);
+    });
+
+  try {
+    while (true) {
+      const chunk = stream.destroyed ? null : stream.read();
+      if (chunk !== null) {
+        yield chunk;
+      } else if (errorEmitted) {
+        throw error;
+      } else if (endEmitted) {
+        break;
+      } else if (closeEmitted) {
+        break;
+      } else {
+        await new Promise(next);
+      }
+    }
+  } catch (err) {
+    destroyImpl.destroyer(stream, err);
+    throw err;
+  } finally {
+    if (state.autoDestroy || !endEmitted) {
+      // TODO(ronag): ERR_PREMATURE_CLOSE?
+      destroyImpl.destroyer(stream, null);
+    }
+  }
+}
+
+// Making it explicit these properties are not enumerable
+// because otherwise some prototype manipulation in
+// userland will fail.
+ObjectDefineProperties(Readable.prototype, {
+  readable: {
+    get() {
+      const r = this._readableState;
+      // r.readable === false means that this is part of a Duplex stream
+      // where the readable side was disabled upon construction.
+      // Compat. The user might manually disable readable side through
+      // deprecated setter.
+      return !!r && r.readable !== false && !r.destroyed && !r.errorEmitted &&
+        !r.endEmitted;
+    },
+    set(val) {
+      // Backwards compat.
+      if (this._readableState) {
+        this._readableState.readable = !!val;
+      }
+    }
+  },
+
+  readableDidRead: {
+    enumerable: false,
+    get: function() {
+      return (
+        this._readableState.dataEmitted ||
+        this._readableState.endEmitted ||
+        this._readableState.errorEmitted ||
+        this._readableState.closeEmitted
+      );
+    }
+  },
+
+  readableHighWaterMark: {
+    enumerable: false,
+    get: function() {
+      return this._readableState.highWaterMark;
+    }
+  },
+
+  readableBuffer: {
+    enumerable: false,
+    get: function() {
+      return this._readableState && this._readableState.buffer;
+    }
+  },
+
+  readableFlowing: {
+    enumerable: false,
+    get: function() {
+      return this._readableState.flowing;
+    },
+    set: function(state) {
+      if (this._readableState) {
+        this._readableState.flowing = state;
+      }
+    }
+  },
+
+  readableLength: {
+    enumerable: false,
+    get() {
+      return this._readableState.length;
+    }
+  },
+
+  readableObjectMode: {
+    enumerable: false,
+    get() {
+      return this._readableState ? this._readableState.objectMode : false;
+    }
+  },
+
+  readableEncoding: {
+    enumerable: false,
+    get() {
+      return this._readableState ? this._readableState.encoding : null;
+    }
+  },
+
+  destroyed: {
+    enumerable: false,
+    get() {
+      if (this._readableState === undefined) {
+        return false;
+      }
+      return this._readableState.destroyed;
+    },
+    set(value) {
+      // We ignore the value if the stream
+      // has not been initialized yet.
+      if (!this._readableState) {
+        return;
+      }
+
+      // Backward compatibility, the user is explicitly
+      // managing destroyed.
+      this._readableState.destroyed = value;
+    }
+  },
+
+  readableEnded: {
+    enumerable: false,
+    get() {
+      return this._readableState ? this._readableState.endEmitted : false;
+    }
+  },
+
+});
+
+ObjectDefineProperties(ReadableState.prototype, {
+  // Legacy getter for `pipesCount`.
+  pipesCount: {
+    get() {
+      return this.pipes.length;
+    }
+  },
+
+  // Legacy property for `paused`.
+  paused: {
+    get() {
+      return this[kPaused] !== false;
+    },
+    set(value) {
+      this[kPaused] = !!value;
+    }
+  }
+});
+
+// Exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromList(n, state) {
+  // nothing buffered.
+  if (state.length === 0)
+    return null;
+
+  let ret;
+  if (state.objectMode)
+    ret = state.buffer.shift();
+  else if (!n || n >= state.length) {
+    // Read it all, truncate the list.
+    if (state.decoder)
+      ret = state.buffer.join('');
+    else if (state.buffer.length === 1)
+      ret = state.buffer.first();
+    else
+      ret = state.buffer.concat(state.length);
+    state.buffer.clear();
+  } else {
+    // read part of list.
+    ret = state.buffer.consume(n, state.decoder);
+  }
+
+  return ret;
+}
+
+function endReadable(stream) {
+  const state = stream._readableState;
+
+  debug('endReadable', state.endEmitted);
+  if (!state.endEmitted) {
+    state.ended = true;
+    process.nextTick(endReadableNT, state, stream);
+  }
+}
+
+function endReadableNT(state, stream) {
+  debug('endReadableNT', state.endEmitted, state.length);
+
+  // Check that we didn't get one last unshift.
+  if (!state.errorEmitted && !state.closeEmitted &&
+      !state.endEmitted && state.length === 0) {
+    state.endEmitted = true;
+    stream.emit('end');
+
+    if (stream.writable && stream.allowHalfOpen === false) {
+      process.nextTick(endWritableNT, stream);
+    } else if (state.autoDestroy) {
+      // In case of duplex streams we need a way to detect
+      // if the writable side is ready for autoDestroy as well.
+      const wState = stream._writableState;
+      const autoDestroy = !wState || (
+        wState.autoDestroy &&
+        // We don't expect the writable to ever 'finish'
+        // if writable is explicitly set to false.
+        (wState.finished || wState.writable === false)
+      );
+
+      if (autoDestroy) {
+        stream.destroy();
+      }
+    }
+  }
+}
+
+function endWritableNT(stream) {
+  const writable = stream.writable && !stream.writableEnded &&
+    !stream.destroyed;
+  if (writable) {
+    stream.end();
+  }
+}
+
+Readable.from = function(iterable, opts) {
+  if (from === undefined) {
+    from = require('internal/streams/from');
+  }
+  return from(Readable, iterable, opts);
+};
diff --git a/lib/internal/streams/transform.js b/lib/internal/streams/transform.js
new file mode 100644
index 0000000000000000000000000000000000000000..b64c57e022eef56d713799f2f481942d1452a910
--- /dev/null
+++ b/lib/internal/streams/transform.js
@@ -0,0 +1,235 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data.  Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored.  (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation.  For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up.  When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer.  When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks.  If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk.  However,
+// a pathological inflate type of transform can cause excessive buffering
+// here.  For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output.  In this case, you could write a very small
+// amount of input, and end up with a very large amount of output.  In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform.  A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+'use strict';
+
+const {
+  ObjectDefineProperty,
+  ObjectSetPrototypeOf,
+  Symbol
+} = primordials;
+
+module.exports = Transform;
+const {
+  ERR_METHOD_NOT_IMPLEMENTED,
+  ERR_MULTIPLE_CALLBACK,
+  ERR_TRANSFORM_ALREADY_TRANSFORMING,
+  ERR_TRANSFORM_WITH_LENGTH_0
+} = require('internal/errors').codes;
+const Duplex = require('internal/streams/duplex');
+const internalUtil = require('internal/util');
+
+ObjectSetPrototypeOf(Transform.prototype, Duplex.prototype);
+ObjectSetPrototypeOf(Transform, Duplex);
+
+const kTransformState = Symbol('kTransformState');
+
+function afterTransform(er, data) {
+  const ts = this[kTransformState];
+  ts.transforming = false;
+
+  const cb = ts.writecb;
+
+  if (cb === null) {
+    return this.emit('error', new ERR_MULTIPLE_CALLBACK());
+  }
+
+  ts.writechunk = null;
+  ts.writecb = null;
+
+  if (data != null) // Single equals check for both `null` and `undefined`
+    this.push(data);
+
+  cb(er);
+
+  const rs = this._readableState;
+  rs.reading = false;
+  if (rs.needReadable || rs.length < rs.highWaterMark) {
+    this._read(rs.highWaterMark);
+  }
+}
+
+
+function Transform(options) {
+  if (!(this instanceof Transform))
+    return new Transform(options);
+
+  Duplex.call(this, options);
+
+  this[kTransformState] = {
+    afterTransform: afterTransform.bind(this),
+    needTransform: false,
+    transforming: false,
+    writecb: null,
+    writechunk: null,
+    writeencoding: null
+  };
+
+  // We have implemented the _read method, and done the other things
+  // that Readable wants before the first _read call, so unset the
+  // sync guard flag.
+  this._readableState.sync = false;
+
+  if (options) {
+    if (typeof options.transform === 'function')
+      this._transform = options.transform;
+
+    if (typeof options.flush === 'function')
+      this._flush = options.flush;
+  }
+
+  // When the writable side finishes, then flush out anything remaining.
+  this.on('prefinish', prefinish);
+}
+
+function prefinish() {
+  if (typeof this._flush === 'function' && !this._readableState.destroyed) {
+    this._flush((er, data) => {
+      done(this, er, data);
+    });
+  } else {
+    done(this, null, null);
+  }
+}
+
+ObjectDefineProperty(Transform.prototype, '_transformState', {
+  get: internalUtil.deprecate(function() {
+    return this[kTransformState];
+  }, 'Transform.prototype._transformState is deprecated', 'DEP0143'),
+  set: internalUtil.deprecate(function(val) {
+    this[kTransformState] = val;
+  }, 'Transform.prototype._transformState is deprecated', 'DEP0143')
+});
+
+Transform.prototype.push = function(chunk, encoding) {
+  this[kTransformState].needTransform = false;
+  return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side.  You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk.  If you pass
+// an error, then that'll put the hurt on the whole operation.  If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+  throw new ERR_METHOD_NOT_IMPLEMENTED('_transform()');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+  const ts = this[kTransformState];
+  ts.writecb = cb;
+  ts.writechunk = chunk;
+  ts.writeencoding = encoding;
+  if (!ts.transforming) {
+    const rs = this._readableState;
+    if (ts.needTransform ||
+        rs.needReadable ||
+        rs.length < rs.highWaterMark)
+      this._read(rs.highWaterMark);
+  }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+  const ts = this[kTransformState];
+
+  if (ts.writechunk !== null && !ts.transforming) {
+    ts.transforming = true;
+    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+  } else {
+    // Mark that we need a transform, so that any data that comes in
+    // will get processed, now that we've asked for it.
+    ts.needTransform = true;
+  }
+};
+
+
+Transform.prototype._destroy = function(err, cb) {
+  Duplex.prototype._destroy.call(this, err, (err2) => {
+    cb(err2);
+  });
+};
+
+
+function done(stream, er, data) {
+  if (er)
+    return stream.emit('error', er);
+
+  if (data != null) // Single equals check for both `null` and `undefined`
+    stream.push(data);
+
+  // These two error cases are coherence checks that can likely not be tested.
+  if (stream._writableState.length)
+    throw new ERR_TRANSFORM_WITH_LENGTH_0();
+
+  if (stream[kTransformState].transforming)
+    throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
+  return stream.push(null);
+}
diff --git a/lib/internal/streams/utils.js b/lib/internal/streams/utils.js
new file mode 100644
index 0000000000000000000000000000000000000000..b6e744250799c6de66d5ccb95a5caec8300a3066
--- /dev/null
+++ b/lib/internal/streams/utils.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const {
+  SymbolAsyncIterator,
+  SymbolIterator,
+} = primordials;
+
+function isReadable(obj) {
+  return !!(obj && typeof obj.pipe === 'function' &&
+            typeof obj.on === 'function');
+}
+
+function isWritable(obj) {
+  return !!(obj && typeof obj.write === 'function' &&
+            typeof obj.on === 'function');
+}
+
+function isStream(obj) {
+  return isReadable(obj) || isWritable(obj);
+}
+
+function isIterable(obj, isAsync) {
+  if (!obj) return false;
+  if (isAsync === true) return typeof obj[SymbolAsyncIterator] === 'function';
+  if (isAsync === false) return typeof obj[SymbolIterator] === 'function';
+  return typeof obj[SymbolAsyncIterator] === 'function' ||
+    typeof obj[SymbolIterator] === 'function';
+}
+
+module.exports = {
+  isIterable,
+  isReadable,
+  isStream,
+};
diff --git a/lib/internal/streams/writable.js b/lib/internal/streams/writable.js
new file mode 100644
index 0000000000000000000000000000000000000000..421836f34414d7885e240d57411bd7d3c7857457
--- /dev/null
+++ b/lib/internal/streams/writable.js
@@ -0,0 +1,796 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+
+'use strict';
+
+const {
+  FunctionPrototype,
+  ObjectDefineProperty,
+  ObjectDefineProperties,
+  ObjectSetPrototypeOf,
+  Symbol,
+  SymbolHasInstance,
+} = primordials;
+
+module.exports = Writable;
+Writable.WritableState = WritableState;
+
+const EE = require('events');
+const Stream = require('internal/streams/legacy').Stream;
+const { Buffer } = require('buffer');
+const destroyImpl = require('internal/streams/destroy');
+const {
+  getHighWaterMark,
+  getDefaultHighWaterMark
+} = require('internal/streams/state');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_METHOD_NOT_IMPLEMENTED,
+  ERR_MULTIPLE_CALLBACK,
+  ERR_STREAM_CANNOT_PIPE,
+  ERR_STREAM_DESTROYED,
+  ERR_STREAM_ALREADY_FINISHED,
+  ERR_STREAM_NULL_VALUES,
+  ERR_STREAM_WRITE_AFTER_END,
+  ERR_UNKNOWN_ENCODING
+} = require('internal/errors').codes;
+
+const { errorOrDestroy } = destroyImpl;
+
+ObjectSetPrototypeOf(Writable.prototype, Stream.prototype);
+ObjectSetPrototypeOf(Writable, Stream);
+
+function nop() {}
+
+function WritableState(options, stream, isDuplex) {
+  // Duplex streams are both readable and writable, but share
+  // the same options object.
+  // However, some cases require setting options to different
+  // values for the readable and the writable sides of the duplex stream,
+  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
+  if (typeof isDuplex !== 'boolean')
+    isDuplex = stream instanceof Stream.Duplex;
+
+  // Object stream flag to indicate whether or not this stream
+  // contains buffers or objects.
+  this.objectMode = !!(options && options.objectMode);
+
+  if (isDuplex)
+    this.objectMode = this.objectMode ||
+      !!(options && options.writableObjectMode);
+
+  // The point at which write() starts returning false
+  // Note: 0 is a valid value, means that we always return false if
+  // the entire buffer is not flushed immediately on write().
+  this.highWaterMark = options ?
+    getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex) :
+    getDefaultHighWaterMark(false);
+
+  // if _final has been called.
+  this.finalCalled = false;
+
+  // drain event flag.
+  this.needDrain = false;
+  // At the start of calling end()
+  this.ending = false;
+  // When end() has been called, and returned.
+  this.ended = false;
+  // When 'finish' is emitted.
+  this.finished = false;
+
+  // Has it been destroyed
+  this.destroyed = false;
+
+  // Should we decode strings into buffers before passing to _write?
+  // this is here so that some node-core streams can optimize string
+  // handling at a lower level.
+  const noDecode = !!(options && options.decodeStrings === false);
+  this.decodeStrings = !noDecode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8';
+
+  // Not an actual buffer we keep track of, but a measurement
+  // of how much we're waiting to get pushed to some underlying
+  // socket or file.
+  this.length = 0;
+
+  // A flag to see when we're in the middle of a write.
+  this.writing = false;
+
+  // When true all writes will be buffered until .uncork() call.
+  this.corked = 0;
+
+  // A flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, because any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // A flag to know if we're processing previously buffered items, which
+  // may call the _write() callback in the same tick, so that we don't
+  // end up in an overlapped onwrite situation.
+  this.bufferProcessing = false;
+
+  // The callback that's passed to _write(chunk, cb).
+  this.onwrite = onwrite.bind(undefined, stream);
+
+  // The callback that the user supplies to write(chunk, encoding, cb).
+  this.writecb = null;
+
+  // The amount that is being written when _write is called.
+  this.writelen = 0;
+
+  // Storage for data passed to the afterWrite() callback in case of
+  // synchronous _write() completion.
+  this.afterWriteTickInfo = null;
+
+  resetBuffer(this);
+
+  // Number of pending user-supplied write callbacks
+  // this must be 0 before 'finish' can be emitted.
+  this.pendingcb = 0;
+
+  // Emit prefinish if the only thing we're waiting for is _write cbs
+  // This is relevant for synchronous Transform streams.
+  this.prefinished = false;
+
+  // True if the error was already emitted and should not be thrown again.
+  this.errorEmitted = false;
+
+  // Should close be emitted on destroy. Defaults to true.
+  this.emitClose = !options || options.emitClose !== false;
+
+  // Should .destroy() be called after 'finish' (and potentially 'end').
+  this.autoDestroy = !options || options.autoDestroy !== false;
+
+  // Indicates whether the stream has errored. When true all write() calls
+  // should return false. This is needed since when autoDestroy
+  // is disabled we need a way to tell whether the stream has failed.
+  this.errored = null;
+
+  // Indicates whether the stream has finished destroying.
+  this.closed = false;
+}
+
+function resetBuffer(state) {
+  state.buffered = [];
+  state.bufferedIndex = 0;
+  state.allBuffers = true;
+  state.allNoop = true;
+}
+
+WritableState.prototype.getBuffer = function getBuffer() {
+  return this.buffered.slice(this.bufferedIndex);
+};
+
+ObjectDefineProperty(WritableState.prototype, 'bufferedRequestCount', {
+  get() {
+    return this.buffered.length - this.bufferedIndex;
+  }
+});
+
+// Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
+let realHasInstance;
+if (typeof Symbol === 'function' && SymbolHasInstance) {
+  realHasInstance = FunctionPrototype[SymbolHasInstance];
+  ObjectDefineProperty(Writable, SymbolHasInstance, {
+    value: function(object) {
+      if (realHasInstance.call(this, object))
+        return true;
+      if (this !== Writable)
+        return false;
+
+      return object && object._writableState instanceof WritableState;
+    }
+  });
+} else {
+  realHasInstance = function(object) {
+    return object instanceof this;
+  };
+}
+
+function Writable(options) {
+  // Writable ctor is applied to Duplexes, too.
+  // `realHasInstance` is necessary because using plain `instanceof`
+  // would return false, as no `_writableState` property is attached.
+
+  // Trying to use the custom `instanceof` for Writable here will also break the
+  // Node.js LazyTransform implementation, which has a non-trivial getter for
+  // `_writableState` that would lead to infinite recursion.
+
+  // Checking for a Stream.Duplex instance is faster here instead of inside
+  // the WritableState constructor, at least with V8 6.5.
+  const isDuplex = (this instanceof Stream.Duplex);
+
+  if (!isDuplex && !realHasInstance.call(Writable, this))
+    return new Writable(options);
+
+  this._writableState = new WritableState(options, this, isDuplex);
+
+  if (options) {
+    if (typeof options.write === 'function')
+      this._write = options.write;
+
+    if (typeof options.writev === 'function')
+      this._writev = options.writev;
+
+    if (typeof options.destroy === 'function')
+      this._destroy = options.destroy;
+
+    if (typeof options.final === 'function')
+      this._final = options.final;
+  }
+
+  Stream.call(this, options);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
+};
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+  const state = this._writableState;
+
+  if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = state.defaultEncoding;
+  } else {
+    if (!encoding)
+      encoding = state.defaultEncoding;
+    if (typeof cb !== 'function')
+      cb = nop;
+  }
+
+  if (chunk === null) {
+    throw new ERR_STREAM_NULL_VALUES();
+  } else if (!state.objectMode) {
+    if (typeof chunk === 'string') {
+      if (state.decodeStrings !== false) {
+        chunk = Buffer.from(chunk, encoding);
+        encoding = 'buffer';
+      }
+    } else if (chunk instanceof Buffer) {
+      encoding = 'buffer';
+    } else if (Stream._isUint8Array(chunk)) {
+      chunk = Stream._uint8ArrayToBuffer(chunk);
+      encoding = 'buffer';
+    } else {
+      throw new ERR_INVALID_ARG_TYPE(
+        'chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
+    }
+  }
+
+  let err;
+  if (state.ending) {
+    err = new ERR_STREAM_WRITE_AFTER_END();
+  } else if (state.destroyed) {
+    err = new ERR_STREAM_DESTROYED('write');
+  }
+
+  if (err) {
+    process.nextTick(cb, err);
+    errorOrDestroy(this, err, true);
+    return false;
+  }
+  state.pendingcb++;
+  return writeOrBuffer(this, state, chunk, encoding, cb);
+};
+
+Writable.prototype.cork = function() {
+  this._writableState.corked++;
+};
+
+Writable.prototype.uncork = function() {
+  const state = this._writableState;
+
+  if (state.corked) {
+    state.corked--;
+
+    if (!state.writing)
+      clearBuffer(this, state);
+  }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+  // node::ParseEncoding() requires lower case.
+  if (typeof encoding === 'string')
+    encoding = encoding.toLowerCase();
+  if (!Buffer.isEncoding(encoding))
+    throw new ERR_UNKNOWN_ENCODING(encoding);
+  this._writableState.defaultEncoding = encoding;
+  return this;
+};
+
+// If we're already writing something, then just put this
+// in the queue, and wait our turn.  Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, callback) {
+  const len = state.objectMode ? 1 : chunk.length;
+
+  state.length += len;
+
+  // stream._write resets state.length
+  const ret = state.length < state.highWaterMark;
+  // We must ensure that previous needDrain will not be reset to false.
+  if (!ret)
+    state.needDrain = true;
+
+  if (state.writing || state.corked || state.errored) {
+    state.buffered.push({ chunk, encoding, callback });
+    if (state.allBuffers && encoding !== 'buffer') {
+      state.allBuffers = false;
+    }
+    if (state.allNoop && callback !== nop) {
+      state.allNoop = false;
+    }
+  } else {
+    state.writelen = len;
+    state.writecb = callback;
+    state.writing = true;
+    state.sync = true;
+    stream._write(chunk, encoding, state.onwrite);
+    state.sync = false;
+  }
+
+  // Return false if errored or destroyed in order to break
+  // any synchronous while(stream.write(data)) loops.
+  return ret && !state.errored && !state.destroyed;
+}
+
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+  state.writelen = len;
+  state.writecb = cb;
+  state.writing = true;
+  state.sync = true;
+  if (state.destroyed)
+    state.onwrite(new ERR_STREAM_DESTROYED('write'));
+  else if (writev)
+    stream._writev(chunk, state.onwrite);
+  else
+    stream._write(chunk, encoding, state.onwrite);
+  state.sync = false;
+}
+
+function onwriteError(stream, state, er, cb) {
+  --state.pendingcb;
+
+  cb(er);
+  // Ensure callbacks are invoked even when autoDestroy is
+  // not enabled. Passing `er` here doesn't make sense since
+  // it's related to one specific write, not to the buffered
+  // writes.
+  errorBuffer(state, new ERR_STREAM_DESTROYED('write'));
+  // This can emit error, but error must always follow cb.
+  errorOrDestroy(stream, er);
+}
+
+function onwrite(stream, er) {
+  const state = stream._writableState;
+  const sync = state.sync;
+  const cb = state.writecb;
+
+  if (typeof cb !== 'function') {
+    errorOrDestroy(stream, new ERR_MULTIPLE_CALLBACK());
+    return;
+  }
+
+  state.writing = false;
+  state.writecb = null;
+  state.length -= state.writelen;
+  state.writelen = 0;
+
+  if (er) {
+    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
+    er.stack; // eslint-disable-line no-unused-expressions
+
+    if (!state.errored) {
+      state.errored = er;
+    }
+
+    // In case of duplex streams we need to notify the readable side of the
+    // error.
+    if (stream._readableState && !stream._readableState.errored) {
+      stream._readableState.errored = er;
+    }
+
+    if (sync) {
+      process.nextTick(onwriteError, stream, state, er, cb);
+    } else {
+      onwriteError(stream, state, er, cb);
+    }
+  } else {
+    if (state.buffered.length > state.bufferedIndex) {
+      clearBuffer(stream, state);
+    }
+
+    if (sync) {
+      // It is a common case that the callback passed to .write() is always
+      // the same. In that case, we do not schedule a new nextTick(), but
+      // rather just increase a counter, to improve performance and avoid
+      // memory allocations.
+      if (state.afterWriteTickInfo !== null &&
+          state.afterWriteTickInfo.cb === cb) {
+        state.afterWriteTickInfo.count++;
+      } else {
+        state.afterWriteTickInfo = { count: 1, cb, stream, state };
+        process.nextTick(afterWriteTick, state.afterWriteTickInfo);
+      }
+    } else {
+      afterWrite(stream, state, 1, cb);
+    }
+  }
+}
+
+function afterWriteTick({ stream, state, count, cb }) {
+  state.afterWriteTickInfo = null;
+  return afterWrite(stream, state, count, cb);
+}
+
+function afterWrite(stream, state, count, cb) {
+  const needDrain = !state.ending && !stream.destroyed && state.length === 0 &&
+    state.needDrain;
+  if (needDrain) {
+    state.needDrain = false;
+    stream.emit('drain');
+  }
+
+  while (count-- > 0) {
+    state.pendingcb--;
+    cb();
+  }
+
+  if (state.destroyed) {
+    errorBuffer(state, new ERR_STREAM_DESTROYED('write'));
+  }
+
+  finishMaybe(stream, state);
+}
+
+// If there's something in the buffer waiting, then invoke callbacks.
+function errorBuffer(state, err) {
+  if (state.writing) {
+    return;
+  }
+
+  for (let n = state.bufferedIndex; n < state.buffered.length; ++n) {
+    const { chunk, callback } = state.buffered[n];
+    const len = state.objectMode ? 1 : chunk.length;
+    state.length -= len;
+    callback(err);
+  }
+
+  resetBuffer(state);
+}
+
+// If there's something in the buffer waiting, then process it.
+function clearBuffer(stream, state) {
+  if (state.corked || state.bufferProcessing || state.destroyed) {
+    return;
+  }
+
+  const { buffered, bufferedIndex, objectMode } = state;
+  const bufferedLength = buffered.length - bufferedIndex;
+
+  if (!bufferedLength) {
+    return;
+  }
+
+  let i = bufferedIndex;
+
+  state.bufferProcessing = true;
+  if (bufferedLength > 1 && stream._writev) {
+    state.pendingcb -= bufferedLength - 1;
+
+    const callback = state.allNoop ? nop : (err) => {
+      for (let n = i; n < buffered.length; ++n) {
+        buffered[n].callback(err);
+      }
+    };
+    // Make a copy of `buffered` if it's going to be used by `callback` above,
+    // since `doWrite` will mutate the array.
+    const chunks = state.allNoop && i === 0 ? buffered : buffered.slice(i);
+    chunks.allBuffers = state.allBuffers;
+
+    doWrite(stream, state, true, state.length, chunks, '', callback);
+
+    resetBuffer(state);
+  } else {
+    do {
+      const { chunk, encoding, callback } = buffered[i];
+      buffered[i++] = null;
+      const len = objectMode ? 1 : chunk.length;
+      doWrite(stream, state, false, len, chunk, encoding, callback);
+    } while (i < buffered.length && !state.writing);
+
+    if (i === buffered.length) {
+      resetBuffer(state);
+    } else if (i > 256) {
+      buffered.splice(0, i);
+      state.bufferedIndex = 0;
+    } else {
+      state.bufferedIndex = i;
+    }
+  }
+  state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+  if (this._writev) {
+    this._writev([{ chunk, encoding }], cb);
+  } else {
+    throw new ERR_METHOD_NOT_IMPLEMENTED('_write()');
+  }
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+  const state = this._writableState;
+
+  if (typeof chunk === 'function') {
+    cb = chunk;
+    chunk = null;
+    encoding = null;
+  } else if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (chunk !== null && chunk !== undefined)
+    this.write(chunk, encoding);
+
+  // .end() fully uncorks.
+  if (state.corked) {
+    state.corked = 1;
+    this.uncork();
+  }
+
+  // This is forgiving in terms of unnecessary calls to end() and can hide
+  // logic errors. However, usually such errors are harmless and causing a
+  // hard error can be disproportionately destructive. It is not always
+  // trivial for the user to determine whether end() needs to be called or not.
+  let err;
+  if (!state.errored && !state.ending) {
+    state.ending = true;
+    finishMaybe(this, state, true);
+    state.ended = true;
+  } else if (state.finished) {
+    err = new ERR_STREAM_ALREADY_FINISHED('end');
+  } else if (state.destroyed) {
+    err = new ERR_STREAM_DESTROYED('end');
+  }
+
+  if (typeof cb === 'function') {
+    if (err || state.finished)
+      process.nextTick(cb, err);
+    else
+      onFinished(this, cb);
+  }
+
+  return this;
+};
+
+function needFinish(state) {
+  return (state.ending &&
+          state.length === 0 &&
+          !state.errored &&
+          state.buffered.length === 0 &&
+          !state.finished &&
+          !state.writing);
+}
+
+function callFinal(stream, state) {
+  stream._final((err) => {
+    state.pendingcb--;
+    if (err) {
+      errorOrDestroy(stream, err);
+    } else {
+      state.prefinished = true;
+      stream.emit('prefinish');
+      finishMaybe(stream, state);
+    }
+  });
+}
+
+function prefinish(stream, state) {
+  if (!state.prefinished && !state.finalCalled) {
+    if (typeof stream._final === 'function' && !state.destroyed) {
+      state.pendingcb++;
+      state.finalCalled = true;
+      process.nextTick(callFinal, stream, state);
+    } else {
+      state.prefinished = true;
+      stream.emit('prefinish');
+    }
+  }
+}
+
+function finishMaybe(stream, state, sync) {
+  const need = needFinish(state);
+  if (need) {
+    prefinish(stream, state);
+    if (state.pendingcb === 0) {
+      state.pendingcb++;
+      if (sync) {
+        process.nextTick(finish, stream, state);
+      } else {
+        finish(stream, state);
+      }
+    }
+  }
+  return need;
+}
+
+function finish(stream, state) {
+  state.pendingcb--;
+  if (state.errorEmitted)
+    return;
+
+  state.finished = true;
+  stream.emit('finish');
+
+  if (state.autoDestroy) {
+    // In case of duplex streams we need a way to detect
+    // if the readable side is ready for autoDestroy as well.
+    const rState = stream._readableState;
+    const autoDestroy = !rState || (
+      rState.autoDestroy &&
+      // We don't expect the readable to ever 'end'
+      // if readable is explicitly set to false.
+      (rState.endEmitted || rState.readable === false)
+    );
+    if (autoDestroy) {
+      stream.destroy();
+    }
+  }
+}
+
+// TODO(ronag): Avoid using events to implement internal logic.
+function onFinished(stream, cb) {
+  function onerror(err) {
+    stream.removeListener('finish', onfinish);
+    stream.removeListener('error', onerror);
+    cb(err);
+    if (stream.listenerCount('error') === 0) {
+      stream.emit('error', err);
+    }
+  }
+
+  function onfinish() {
+    stream.removeListener('finish', onfinish);
+    stream.removeListener('error', onerror);
+    cb();
+  }
+  stream.on('finish', onfinish);
+  stream.prependListener('error', onerror);
+}
+
+ObjectDefineProperties(Writable.prototype, {
+
+  destroyed: {
+    get() {
+      return this._writableState ? this._writableState.destroyed : false;
+    },
+    set(value) {
+      // Backward compatibility, the user is explicitly managing destroyed.
+      if (this._writableState) {
+        this._writableState.destroyed = value;
+      }
+    }
+  },
+
+  writable: {
+    get() {
+      const w = this._writableState;
+      // w.writable === false means that this is part of a Duplex stream
+      // where the writable side was disabled upon construction.
+      // Compat. The user might manually disable writable side through
+      // deprecated setter.
+      return !!w && w.writable !== false && !w.destroyed && !w.errored &&
+        !w.ending && !w.ended;
+    },
+    set(val) {
+      // Backwards compatible.
+      if (this._writableState) {
+        this._writableState.writable = !!val;
+      }
+    }
+  },
+
+  writableFinished: {
+    get() {
+      return this._writableState ? this._writableState.finished : false;
+    }
+  },
+
+  writableObjectMode: {
+    get() {
+      return this._writableState ? this._writableState.objectMode : false;
+    }
+  },
+
+  writableBuffer: {
+    get() {
+      return this._writableState && this._writableState.getBuffer();
+    }
+  },
+
+  writableEnded: {
+    get() {
+      return this._writableState ? this._writableState.ending : false;
+    }
+  },
+
+  writableNeedDrain: {
+    get() {
+      const wState = this._writableState;
+      if (!wState) return false;
+      return !wState.destroyed && !wState.ending && wState.needDrain;
+    }
+  },
+
+  writableHighWaterMark: {
+    get() {
+      return this._writableState && this._writableState.highWaterMark;
+    }
+  },
+
+  writableCorked: {
+    get() {
+      return this._writableState ? this._writableState.corked : 0;
+    }
+  },
+
+  writableLength: {
+    get() {
+      return this._writableState && this._writableState.length;
+    }
+  }
+});
+
+const destroy = destroyImpl.destroy;
+Writable.prototype.destroy = function(err, cb) {
+  const state = this._writableState;
+
+  if (!state.destroyed) {
+    process.nextTick(errorBuffer, state, new ERR_STREAM_DESTROYED('write'));
+  }
+  destroy.call(this, err, cb);
+  return this;
+};
+
+Writable.prototype._undestroy = destroyImpl.undestroy;
+Writable.prototype._destroy = function(err, cb) {
+  cb(err);
+};
+
+Writable.prototype[EE.captureRejectionSymbol] = function(err) {
+  this.destroy(err);
+};
diff --git a/lib/internal/test/binding.js b/lib/internal/test/binding.js
index 882ea90093d03914f718df4dde30264d9ab63381..d00ef89a16111b10e67a138b34cd1c6401800a8f 100644
--- a/lib/internal/test/binding.js
+++ b/lib/internal/test/binding.js
@@ -1,7 +1,16 @@
 'use strict';
 
+const {
+  globalThis,
+} = primordials;
+
 process.emitWarning(
   'These APIs are for internal testing only. Do not use them.',
   'internal/test/binding');
 
-module.exports = { internalBinding };
+if (module.isPreloading) {
+  globalThis.internalBinding = internalBinding;
+  globalThis.primordials = primordials;
+}
+
+module.exports = { internalBinding, primordials };
diff --git a/lib/internal/timers.js b/lib/internal/timers.js
index c478a43de9b7d8949cfd8937aae1d1ad8da33f81..c3bc720390b06c53abfea184b411ad12bc4cbdc7 100644
--- a/lib/internal/timers.js
+++ b/lib/internal/timers.js
@@ -75,8 +75,10 @@
 const {
   MathMax,
   MathTrunc,
+  NumberIsFinite,
   NumberMIN_SAFE_INTEGER,
   ObjectCreate,
+  ReflectApply,
   Symbol,
 } = primordials;
 
@@ -84,7 +86,8 @@ const {
   scheduleTimer,
   toggleTimerRef,
   getLibuvNow,
-  immediateInfo
+  immediateInfo,
+  toggleImmediateRef
 } = internalBinding('timers');
 
 const {
@@ -260,7 +263,7 @@ function ImmediateList() {
 }
 
 // Appends an item to the end of the linked list, adjusting the current tail's
-// previous and next pointers where applicable
+// next pointer and the item's previous pointer where applicable
 ImmediateList.prototype.append = function(item) {
   if (this.tail !== null) {
     this.tail._idleNext = item;
@@ -274,11 +277,11 @@ ImmediateList.prototype.append = function(item) {
 // Removes an item from the linked list, adjusting the pointers of adjacent
 // items and the linked list's head or tail pointers as necessary
 ImmediateList.prototype.remove = function(item) {
-  if (item._idleNext !== null) {
+  if (item._idleNext) {
     item._idleNext._idlePrev = item._idlePrev;
   }
 
-  if (item._idlePrev !== null) {
+  if (item._idlePrev) {
     item._idlePrev._idleNext = item._idleNext;
   }
 
@@ -379,7 +382,7 @@ function setUnrefTimeout(callback, after) {
 // Type checking used by timers.enroll() and Socket#setTimeout()
 function getTimerDuration(msecs, name) {
   validateNumber(msecs, name);
-  if (msecs < 0 || !isFinite(msecs)) {
+  if (msecs < 0 || !NumberIsFinite(msecs)) {
     throw new ERR_OUT_OF_RANGE(name, 'a non-negative finite number', msecs);
   }
 
@@ -553,7 +556,7 @@ function getTimerCallbacks(runNextTicks) {
         if (args === undefined)
           timer._onTimeout();
         else
-          timer._onTimeout(...args);
+          ReflectApply(timer._onTimeout, timer, args);
       } finally {
         if (timer._repeat && timer._idleTimeout !== -1) {
           timer._idleTimeout = timer._repeat;
@@ -593,12 +596,53 @@ function getTimerCallbacks(runNextTicks) {
   };
 }
 
+class Immediate {
+  constructor(callback, args) {
+    this._idleNext = null;
+    this._idlePrev = null;
+    this._onImmediate = callback;
+    this._argv = args;
+    this._destroyed = false;
+    this[kRefed] = false;
+
+    initAsyncResource(this, 'Immediate');
+
+    this.ref();
+    immediateInfo[kCount]++;
+
+    immediateQueue.append(this);
+  }
+
+  ref() {
+    if (this[kRefed] === false) {
+      this[kRefed] = true;
+      if (immediateInfo[kRefCount]++ === 0)
+        toggleImmediateRef(true);
+    }
+    return this;
+  }
+
+  unref() {
+    if (this[kRefed] === true) {
+      this[kRefed] = false;
+      if (--immediateInfo[kRefCount] === 0)
+        toggleImmediateRef(false);
+    }
+    return this;
+  }
+
+  hasRef() {
+    return !!this[kRefed];
+  }
+}
+
 module.exports = {
   TIMEOUT_MAX,
   kTimeout: Symbol('timeout'), // For hiding Timeouts on other internals.
   async_id_symbol,
   trigger_async_id_symbol,
   Timeout,
+  Immediate,
   kRefed,
   kHasPrimitive,
   initAsyncResource,
diff --git a/lib/internal/timers/promises.js b/lib/internal/timers/promises.js
new file mode 100644
index 0000000000000000000000000000000000000000..55d554bb838e959f95427b2909cb4c15900f4adf
--- /dev/null
+++ b/lib/internal/timers/promises.js
@@ -0,0 +1,123 @@
+'use strict';
+
+const {
+  FunctionPrototypeBind,
+  Promise,
+  PromisePrototypeFinally,
+  PromiseReject,
+} = primordials;
+
+const {
+  Timeout,
+  Immediate,
+  insert
+} = require('internal/timers');
+
+const {
+  AbortError,
+  codes: { ERR_INVALID_ARG_TYPE }
+} = require('internal/errors');
+
+const { validateAbortSignal } = require('internal/validators');
+
+function cancelListenerHandler(clear, reject) {
+  if (!this._destroyed) {
+    clear(this);
+    reject(new AbortError());
+  }
+}
+
+function setTimeout(after, value, options = {}) {
+  const args = value !== undefined ? [value] : value;
+  if (options == null || typeof options !== 'object') {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options',
+        'Object',
+        options));
+  }
+  const { signal, ref = true } = options;
+  try {
+    validateAbortSignal(signal, 'options.signal');
+  } catch (err) {
+    return PromiseReject(err);
+  }
+  if (typeof ref !== 'boolean') {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options.ref',
+        'boolean',
+        ref));
+  }
+  // TODO(@jasnell): If a decision is made that this cannot be backported
+  // to 12.x, then this can be converted to use optional chaining to
+  // simplify the check.
+  if (signal && signal.aborted) {
+    return PromiseReject(new AbortError());
+  }
+  let oncancel;
+  const ret = new Promise((resolve, reject) => {
+    const timeout = new Timeout(resolve, after, args, false, true);
+    if (!ref) timeout.unref();
+    insert(timeout, timeout._idleTimeout);
+    if (signal) {
+      oncancel = FunctionPrototypeBind(cancelListenerHandler,
+                                       // eslint-disable-next-line no-undef
+                                       timeout, clearTimeout, reject);
+      signal.addEventListener('abort', oncancel);
+    }
+  });
+  return oncancel !== undefined ?
+    PromisePrototypeFinally(
+      ret,
+      () => signal.removeEventListener('abort', oncancel)) : ret;
+}
+
+function setImmediate(value, options = {}) {
+  if (options == null || typeof options !== 'object') {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options',
+        'Object',
+        options));
+  }
+  const { signal, ref = true } = options;
+  try {
+    validateAbortSignal(signal, 'options.signal');
+  } catch (err) {
+    return PromiseReject(err);
+  }
+  if (typeof ref !== 'boolean') {
+    return PromiseReject(
+      new ERR_INVALID_ARG_TYPE(
+        'options.ref',
+        'boolean',
+        ref));
+  }
+  // TODO(@jasnell): If a decision is made that this cannot be backported
+  // to 12.x, then this can be converted to use optional chaining to
+  // simplify the check.
+  if (signal && signal.aborted) {
+    return PromiseReject(new AbortError());
+  }
+  let oncancel;
+  const ret = new Promise((resolve, reject) => {
+    const immediate = new Immediate(resolve, [value]);
+    if (!ref) immediate.unref();
+    if (signal) {
+      oncancel = FunctionPrototypeBind(cancelListenerHandler,
+                                       // eslint-disable-next-line no-undef
+                                       immediate, clearImmediate, reject);
+      signal.addEventListener('abort', oncancel);
+    }
+  });
+  return oncancel !== undefined ?
+    PromisePrototypeFinally(
+      ret,
+      () => signal.removeEventListener('abort', oncancel)) : ret;
+}
+
+module.exports = {
+  setTimeout,
+  setImmediate,
+};
diff --git a/lib/internal/trace_events_async_hooks.js b/lib/internal/trace_events_async_hooks.js
index 9796f6866d96c8d360c070f0e69405ecb9650502..482a635f25edb2624285df46bbc88be9012a28ca 100644
--- a/lib/internal/trace_events_async_hooks.js
+++ b/lib/internal/trace_events_async_hooks.js
@@ -32,6 +32,9 @@ const kEnabled = Symbol('enabled');
 const nativeProviders = new SafeSet(ObjectKeys(async_wrap.Providers));
 const typeMemory = new SafeMap();
 
+// Promises are not AsyncWrap resources so they should emit trace_events here.
+nativeProviders.delete('PROMISE');
+
 function createHook() {
   // In traceEvents it is not only the id but also the name that needs to be
   // repeated. Since async_hooks doesn't expose the provider type in the
diff --git a/lib/internal/tty.js b/lib/internal/tty.js
index 1ebd09193ef57ef4b40cd3dbb232ad576ea74639..f8bfe8cf21a32b49628dbd475360aa46fa5af34d 100644
--- a/lib/internal/tty.js
+++ b/lib/internal/tty.js
@@ -23,9 +23,13 @@
 'use strict';
 
 const {
-  ERR_INVALID_ARG_TYPE,
-  ERR_OUT_OF_RANGE
-} = require('internal/errors').codes;
+  ArrayPrototypeSome,
+  RegExpPrototypeTest,
+  StringPrototypeSplit,
+  StringPrototypeToLowerCase,
+} = primordials;
+
+const { validateInteger } = require('internal/validators');
 
 let OSRelease;
 
@@ -70,7 +74,7 @@ const TERM_ENVS_REG_EXP = [
   /^rxvt/,
   /^screen/,
   /^xterm/,
-  /^vt100/
+  /^vt100/,
 ];
 
 let warned = false;
@@ -134,7 +138,7 @@ function getColorDepth(env = process.env) {
     // Lazy load for startup performance.
     if (OSRelease === undefined) {
       const { release } = require('os');
-      OSRelease = release().split('.');
+      OSRelease = StringPrototypeSplit(release(), '.');
     }
     // Windows 10 build 10586 is the first Windows release that supports 256
     // colors. Windows 10 build 14931 is the first release that supports
@@ -163,14 +167,15 @@ function getColorDepth(env = process.env) {
   }
 
   if ('TEAMCITY_VERSION' in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ?
+    return RegExpPrototypeTest(/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/, env.TEAMCITY_VERSION) ?
       COLORS_16 : COLORS_2;
   }
 
   switch (env.TERM_PROGRAM) {
     case 'iTerm.app':
       if (!env.TERM_PROGRAM_VERSION ||
-        /^[0-2]\./.test(env.TERM_PROGRAM_VERSION)) {
+        RegExpPrototypeTest(/^[0-2]\./, env.TERM_PROGRAM_VERSION)
+      ) {
         return COLORS_256;
       }
       return COLORS_16m;
@@ -186,18 +191,18 @@ function getColorDepth(env = process.env) {
   }
 
   if (env.TERM) {
-    if (/^xterm-256/.test(env.TERM))
+    if (RegExpPrototypeTest(/^xterm-256/, env.TERM)) {
       return COLORS_256;
+    }
 
-    const termEnv = env.TERM.toLowerCase();
+    const termEnv = StringPrototypeToLowerCase(env.TERM);
 
     if (TERM_ENVS[termEnv]) {
       return TERM_ENVS[termEnv];
     }
-    for (const term of TERM_ENVS_REG_EXP) {
-      if (term.test(termEnv)) {
-        return COLORS_16;
-      }
+    if (ArrayPrototypeSome(TERM_ENVS_REG_EXP,
+                           (term) => RegExpPrototypeTest(term, termEnv))) {
+      return COLORS_16;
     }
   }
   // Move 16 color COLORTERM below 16m and 256
@@ -213,13 +218,9 @@ function hasColors(count, env) {
     env = count;
     count = 16;
   } else {
-    if (typeof count !== 'number') {
-      throw new ERR_INVALID_ARG_TYPE('count', 'number', count);
-    }
-    if (count < 2) {
-      throw new ERR_OUT_OF_RANGE('count', '>= 2', count);
-    }
+    validateInteger(count, 'count', 2);
   }
+
   return count <= 2 ** getColorDepth(env);
 }
 
diff --git a/lib/internal/url.js b/lib/internal/url.js
index 2c0b1f518a70915cd63715153be912281f1ddb81..f4167212687bbf8179dff03b7db6d0ea84de0eb9 100644
--- a/lib/internal/url.js
+++ b/lib/internal/url.js
@@ -2,6 +2,13 @@
 
 const {
   Array,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeReduce,
+  ArrayPrototypeSlice,
+  FunctionPrototypeBind,
+  Int8Array,
   Number,
   ObjectCreate,
   ObjectDefineProperties,
@@ -9,8 +16,16 @@ const {
   ObjectGetOwnPropertySymbols,
   ObjectGetPrototypeOf,
   ObjectKeys,
+  ReflectApply,
   ReflectGetOwnPropertyDescriptor,
   ReflectOwnKeys,
+  String,
+  StringPrototypeCharCodeAt,
+  StringPrototypeIncludes,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
   Symbol,
   SymbolIterator,
   SymbolToStringTag,
@@ -24,7 +39,12 @@ const {
   isHexTable
 } = require('internal/querystring');
 
-const { getConstructorOf, removeColors } = require('internal/util');
+const {
+  getConstructorOf,
+  removeColors,
+  toUSVString,
+} = require('internal/util');
+
 const {
   ERR_ARG_NOT_ITERABLE,
   ERR_INVALID_ARG_TYPE,
@@ -60,7 +80,6 @@ const {
   domainToASCII: _domainToASCII,
   domainToUnicode: _domainToUnicode,
   encodeAuth,
-  toUSVString: _toUSVString,
   parse,
   setURLConstructor,
   URL_FLAGS_CANNOT_BE_BASE,
@@ -94,18 +113,6 @@ const IteratorPrototype = ObjectGetPrototypeOf(
   ObjectGetPrototypeOf([][SymbolIterator]())
 );
 
-const unpairedSurrogateRe =
-    /(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])/;
-function toUSVString(val) {
-  const str = `${val}`;
-  // As of V8 5.5, `str.search()` (and `unpairedSurrogateRe[@@search]()`) are
-  // slower than `unpairedSurrogateRe.exec()`.
-  const match = unpairedSurrogateRe.exec(str);
-  if (!match)
-    return str;
-  return _toUSVString(str, match.index);
-}
-
 // Refs: https://html.spec.whatwg.org/multipage/browsers.html#concept-origin-opaque
 const kOpaqueOrigin = 'null';
 
@@ -165,8 +172,8 @@ class URLSearchParams {
           }
           const convertedPair = [];
           for (const element of pair)
-            convertedPair.push(toUSVString(element));
-          pairs.push(convertedPair);
+            ArrayPrototypePush(convertedPair, toUSVString(element));
+          ArrayPrototypePush(pairs, convertedPair);
         }
 
         this[searchParams] = [];
@@ -174,7 +181,7 @@ class URLSearchParams {
           if (pair.length !== 2) {
             throw new ERR_INVALID_TUPLE('Each query pair', '[name, value]');
           }
-          this[searchParams].push(pair[0], pair[1]);
+          ArrayPrototypePush(this[searchParams], pair[0], pair[1]);
         }
       } else {
         // Record<USVString, USVString>
@@ -220,16 +227,21 @@ class URLSearchParams {
     const list = this[searchParams];
     const output = [];
     for (let i = 0; i < list.length; i += 2)
-      output.push(`${innerInspect(list[i])} => ${innerInspect(list[i + 1])}`);
+      ArrayPrototypePush(
+        output,
+        `${innerInspect(list[i])} => ${innerInspect(list[i + 1])}`);
 
-    const length = output.reduce(
+    const length = ArrayPrototypeReduce(
+      output,
       (prev, cur) => prev + removeColors(cur).length + separator.length,
       -separator.length
     );
     if (length > ctx.breakLength) {
-      return `${this.constructor.name} {\n  ${output.join(',\n  ')} }`;
+      return `${this.constructor.name} {\n` +
+      `  ${ArrayPrototypeJoin(output, ',\n  ')} }`;
     } else if (output.length) {
-      return `${this.constructor.name} { ${output.join(separator)} }`;
+      return `${this.constructor.name} { ` +
+      `${ArrayPrototypeJoin(output, separator)} }`;
     }
     return `${this.constructor.name} {}`;
   }
@@ -289,9 +301,9 @@ function onParsePortComplete(flags, protocol, username, password,
 
 function onParseHostComplete(flags, protocol, username, password,
                              host, port, path, query, fragment) {
-  onParseHostnameComplete.apply(this, arguments);
+  ReflectApply(onParseHostnameComplete, this, arguments);
   if (port !== null || ((flags & URL_FLAGS_IS_DEFAULT_SCHEME_PORT) !== 0))
-    onParsePortComplete.apply(this, arguments);
+    ReflectApply(onParsePortComplete, this, arguments);
 }
 
 function onParsePathComplete(flags, protocol, username, password,
@@ -331,8 +343,8 @@ class URL {
       base_context = new URL(base)[context];
     }
     this[context] = new URLContext();
-    parse(input, -1, base_context, undefined, onParseComplete.bind(this),
-          onParseError);
+    parse(input, -1, base_context, undefined,
+          FunctionPrototypeBind(onParseComplete, this), onParseError);
   }
 
   get [special]() {
@@ -360,11 +372,8 @@ class URL {
     if (typeof depth === 'number' && depth < 0)
       return this;
 
-    const ctor = getConstructorOf(this);
-
-    const obj = ObjectCreate({
-      constructor: ctor === null ? URL : ctor
-    });
+    const constructor = getConstructorOf(this) || URL;
+    const obj = ObjectCreate({ constructor });
 
     obj.href = this.href;
     obj.origin = this.origin;
@@ -385,7 +394,7 @@ class URL {
       obj[context] = this[context];
     }
 
-    return inspect(obj, opts);
+    return `${constructor.name} ${inspect(obj, opts)}`;
   }
 }
 
@@ -418,7 +427,7 @@ ObjectDefineProperties(URL.prototype, {
           ret += '@';
         }
         ret += options.unicode ?
-          domainToUnicode(this.hostname) : this.hostname;
+          domainToUnicode(ctx.host) : ctx.host;
         if (ctx.port !== null)
           ret += `:${ctx.port}`;
       } else if (ctx.scheme === 'file:') {
@@ -456,8 +465,8 @@ ObjectDefineProperties(URL.prototype, {
     set(input) {
       // toUSVString is not needed.
       input = `${input}`;
-      parse(input, -1, undefined, undefined, onParseComplete.bind(this),
-            onParseError);
+      parse(input, -1, undefined, undefined,
+            FunctionPrototypeBind(onParseComplete, this), onParseError);
     }
   },
   origin: {  // readonly
@@ -504,7 +513,7 @@ ObjectDefineProperties(URL.prototype, {
         return;
       }
       parse(scheme, kSchemeStart, null, ctx,
-            onParseProtocolComplete.bind(this));
+            FunctionPrototypeBind(onParseProtocolComplete, this));
     }
   },
   username: {
@@ -567,7 +576,8 @@ ObjectDefineProperties(URL.prototype, {
         // Cannot set the host if cannot-be-base is set
         return;
       }
-      parse(host, kHost, null, ctx, onParseHostComplete.bind(this));
+      parse(host, kHost, null, ctx,
+            FunctionPrototypeBind(onParseHostComplete, this));
     }
   },
   hostname: {
@@ -604,7 +614,8 @@ ObjectDefineProperties(URL.prototype, {
         ctx.port = null;
         return;
       }
-      parse(port, kPort, null, ctx, onParsePortComplete.bind(this));
+      parse(port, kPort, null, ctx,
+            FunctionPrototypeBind(onParsePortComplete, this));
     }
   },
   pathname: {
@@ -616,7 +627,7 @@ ObjectDefineProperties(URL.prototype, {
         return ctx.path[0];
       if (ctx.path.length === 0)
         return '';
-      return `/${ctx.path.join('/')}`;
+      return `/${ArrayPrototypeJoin(ctx.path, '/')}`;
     },
     set(path) {
       // toUSVString is not needed.
@@ -643,11 +654,12 @@ ObjectDefineProperties(URL.prototype, {
         ctx.query = null;
         ctx.flags &= ~URL_FLAGS_HAS_QUERY;
       } else {
-        if (search[0] === '?') search = search.slice(1);
+        if (search[0] === '?') search = StringPrototypeSlice(search, 1);
         ctx.query = '';
         ctx.flags |= URL_FLAGS_HAS_QUERY;
         if (search) {
-          parse(search, kQuery, null, ctx, onParseSearchComplete.bind(this));
+          parse(search, kQuery, null, ctx,
+                FunctionPrototypeBind(onParseSearchComplete, this));
         }
       }
       initSearchParams(this[searchParams], search);
@@ -678,10 +690,11 @@ ObjectDefineProperties(URL.prototype, {
         ctx.flags &= ~URL_FLAGS_HAS_FRAGMENT;
         return;
       }
-      if (hash[0] === '#') hash = hash.slice(1);
+      if (hash[0] === '#') hash = StringPrototypeSlice(hash, 1);
       ctx.fragment = '';
       ctx.flags |= URL_FLAGS_HAS_FRAGMENT;
-      parse(hash, kFragment, null, ctx, onParseHashComplete.bind(this));
+      parse(hash, kFragment, null, ctx,
+            FunctionPrototypeBind(onParseHashComplete, this));
     }
   },
   toJSON: {
@@ -730,7 +743,7 @@ function parseParams(qs) {
   let encodeCheck = 0;
   let i;
   for (i = 0; i < qs.length; ++i) {
-    const code = qs.charCodeAt(i);
+    const code = StringPrototypeCharCodeAt(qs, i);
 
     // Try matching key/value pair separator
     if (code === CHAR_AMPERSAND) {
@@ -778,7 +791,7 @@ function parseParams(qs) {
     // Handle + and percent decoding.
     if (code === CHAR_PLUS) {
       if (lastPos < i)
-        buf += qs.slice(lastPos, i);
+        buf += StringPrototypeSlice(qs, lastPos, i);
       buf += ' ';
       lastPos = i + 1;
     } else if (!encoded) {
@@ -806,21 +819,21 @@ function parseParams(qs) {
     return out;
 
   if (lastPos < i)
-    buf += qs.slice(lastPos, i);
+    buf += StringPrototypeSlice(qs, lastPos, i);
   if (encoded)
     buf = querystring.unescape(buf);
-  out.push(buf);
+  ArrayPrototypePush(out, buf);
 
   // If `buf` is the key, add an empty value.
   if (!seenSep)
-    out.push('');
+    ArrayPrototypePush(out, '');
 
   return out;
 }
 
 // Adapted from querystring's implementation.
 // Ref: https://url.spec.whatwg.org/#concept-urlencoded-byte-serializer
-const noEscape = [
+const noEscape = new Int8Array([
 /*
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
 */
@@ -831,8 +844,8 @@ const noEscape = [
   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 - 0x4F
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 0x50 - 0x5F
   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 0x6F
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0  // 0x70 - 0x7F
-];
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  // 0x70 - 0x7F
+]);
 
 // Special version of hexTable that uses `+` for U+0020 SPACE.
 const paramHexTable = hexTable.slice();
@@ -927,7 +940,7 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
 
     name = toUSVString(name);
     value = toUSVString(value);
-    this[searchParams].push(name, value);
+    ArrayPrototypePush(this[searchParams], name, value);
     update(this[context], this);
   },
 
@@ -1041,7 +1054,7 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
     // Otherwise, append a new name-value pair whose name is `name` and value
     // is `value`, to `list`.
     if (!found) {
-      list.push(name, value);
+      ArrayPrototypePush(list, name, value);
     }
 
     update(this[context], this);
@@ -1227,24 +1240,28 @@ defineIDLClass(URLSearchParamsIteratorPrototype, 'URLSearchParams Iterator', {
       kind,
       index
     } = this[context];
-    const output = target[searchParams].slice(index).reduce((prev, cur, i) => {
-      const key = i % 2 === 0;
-      if (kind === 'key' && key) {
-        prev.push(cur);
-      } else if (kind === 'value' && !key) {
-        prev.push(cur);
-      } else if (kind === 'key+value' && !key) {
-        prev.push([target[searchParams][index + i - 1], cur]);
-      }
-      return prev;
-    }, []);
+    const output = ArrayPrototypeReduce(
+      ArrayPrototypeSlice(target[searchParams], index),
+      (prev, cur, i) => {
+        const key = i % 2 === 0;
+        if (kind === 'key' && key) {
+          ArrayPrototypePush(prev, cur);
+        } else if (kind === 'value' && !key) {
+          ArrayPrototypePush(prev, cur);
+        } else if (kind === 'key+value' && !key) {
+          ArrayPrototypePush(prev, [target[searchParams][index + i - 1], cur]);
+        }
+        return prev;
+      },
+      []
+    );
     const breakLn = inspect(output, innerOpts).includes('\n');
-    const outputStrs = output.map((p) => inspect(p, innerOpts));
+    const outputStrs = ArrayPrototypeMap(output, (p) => inspect(p, innerOpts));
     let outputStr;
     if (breakLn) {
-      outputStr = `\n  ${outputStrs.join(',\n  ')}`;
+      outputStr = `\n  ${ArrayPrototypeJoin(outputStrs, ',\n  ')}`;
     } else {
-      outputStr = ` ${outputStrs.join(', ')}`;
+      outputStr = ` ${ArrayPrototypeJoin(outputStrs, ', ')}`;
     }
     return `${this[SymbolToStringTag]} {${outputStr} }`;
   }
@@ -1269,11 +1286,12 @@ function domainToUnicode(domain) {
 // Utility function that converts a URL object into an ordinary
 // options object as expected by the http.request and https.request
 // APIs.
-function urlToOptions(url) {
+function urlToHttpOptions(url) {
   const options = {
     protocol: url.protocol,
-    hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[') ?
-      url.hostname.slice(1, -1) :
+    hostname: typeof url.hostname === 'string' &&
+              StringPrototypeStartsWith(url.hostname, '[') ?
+      StringPrototypeSlice(url.hostname, 1, -1) :
       url.hostname,
     hash: url.hash,
     search: url.search,
@@ -1285,7 +1303,7 @@ function urlToOptions(url) {
     options.port = Number(url.port);
   }
   if (url.username || url.password) {
-    options.auth = `${url.username}:${url.password}`;
+    options.auth = `${decodeURIComponent(url.username)}:${decodeURIComponent(url.password)}`;
   }
   return options;
 }
@@ -1373,25 +1391,25 @@ const carriageReturnRegEx = /\r/g;
 const tabRegEx = /\t/g;
 
 function encodePathChars(filepath) {
-  if (filepath.includes('%'))
-    filepath = filepath.replace(percentRegEx, '%25');
+  if (StringPrototypeIncludes(filepath, '%'))
+    filepath = StringPrototypeReplace(filepath, percentRegEx, '%25');
   // In posix, backslash is a valid character in paths:
-  if (!isWindows && filepath.includes('\\'))
-    filepath = filepath.replace(backslashRegEx, '%5C');
-  if (filepath.includes('\n'))
-    filepath = filepath.replace(newlineRegEx, '%0A');
-  if (filepath.includes('\r'))
-    filepath = filepath.replace(carriageReturnRegEx, '%0D');
-  if (filepath.includes('\t'))
-    filepath = filepath.replace(tabRegEx, '%09');
+  if (!isWindows && StringPrototypeIncludes(filepath, '\\'))
+    filepath = StringPrototypeReplace(filepath, backslashRegEx, '%5C');
+  if (StringPrototypeIncludes(filepath, '\n'))
+    filepath = StringPrototypeReplace(filepath, newlineRegEx, '%0A');
+  if (StringPrototypeIncludes(filepath, '\r'))
+    filepath = StringPrototypeReplace(filepath, carriageReturnRegEx, '%0D');
+  if (StringPrototypeIncludes(filepath, '\t'))
+    filepath = StringPrototypeReplace(filepath, tabRegEx, '%09');
   return filepath;
 }
 
 function pathToFileURL(filepath) {
   const outURL = new URL('file://');
-  if (isWindows && filepath.startsWith('\\\\')) {
+  if (isWindows && StringPrototypeStartsWith(filepath, '\\\\')) {
     // UNC path format: \\server\share\resource
-    const paths = filepath.split('\\');
+    const paths = StringPrototypeSplit(filepath, '\\');
     if (paths.length <= 3) {
       throw new ERR_INVALID_ARG_VALUE(
         'filepath',
@@ -1408,11 +1426,13 @@ function pathToFileURL(filepath) {
       );
     }
     outURL.hostname = domainToASCII(hostname);
-    outURL.pathname = encodePathChars(paths.slice(3).join('/'));
+    outURL.pathname = encodePathChars(
+      ArrayPrototypeJoin(ArrayPrototypeSlice(paths, 3), '/'));
   } else {
     let resolved = path.resolve(filepath);
     // path.resolve strips trailing slashes so we must add them back
-    const filePathLast = filepath.charCodeAt(filepath.length - 1);
+    const filePathLast = StringPrototypeCharCodeAt(filepath,
+                                                   filepath.length - 1);
     if ((filePathLast === CHAR_FORWARD_SLASH ||
          (isWindows && filePathLast === CHAR_BACKWARD_SLASH)) &&
         resolved[resolved.length - 1] !== path.sep)
@@ -1465,7 +1485,7 @@ module.exports = {
   URLSearchParams,
   domainToASCII,
   domainToUnicode,
-  urlToOptions,
+  urlToHttpOptions,
   formatSymbol: kFormat,
   searchParamsSymbol: searchParams,
   encodeStr
diff --git a/lib/internal/util.js b/lib/internal/util.js
index f26ea970e8dce08b960d72d9ab17eb28389f16eb..f8cbac7ec7cbf9fd27cb19f590e4660e7a856c71 100644
--- a/lib/internal/util.js
+++ b/lib/internal/util.js
@@ -14,14 +14,18 @@ const {
   ObjectSetPrototypeOf,
   Promise,
   ReflectConstruct,
+  RegExpPrototypeExec,
   Set,
   Symbol,
   SymbolFor,
 } = primordials;
 
+const {
+  toUSVString: _toUSVString,
+} = internalBinding('url');
+
 const {
   codes: {
-    ERR_INVALID_ARG_TYPE,
     ERR_NO_CRYPTO,
     ERR_UNKNOWN_SIGNAL
   },
@@ -44,6 +48,25 @@ const experimentalWarnings = new Set();
 
 const colorRegExp = /\u001b\[\d\d?m/g; // eslint-disable-line no-control-regex
 
+const unpairedSurrogateRe =
+  /(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])/;
+function toUSVString(val) {
+  const str = `${val}`;
+  // As of V8 5.5, `str.search()` (and `unpairedSurrogateRe[@@search]()`) are
+  // slower than `unpairedSurrogateRe.exec()`.
+  const match = RegExpPrototypeExec(unpairedSurrogateRe, str);
+  if (!match)
+    return str;
+  return _toUSVString(str, match.index);
+}
+
+let uvBinding;
+
+function lazyUv() {
+  uvBinding = uvBinding ?? internalBinding('uv');
+  return uvBinding;
+}
+
 function removeColors(str) {
   return str.replace(colorRegExp, '');
 }
@@ -59,6 +82,8 @@ function isError(e) {
 // each one once.
 const codesWarned = new Set();
 
+let validateString;
+
 // Mark that a method should not be used.
 // Returns a modified function which warns once by default.
 // If --no-deprecation is set, then it is a no-op.
@@ -67,8 +92,12 @@ function deprecate(fn, msg, code) {
     return fn;
   }
 
-  if (code !== undefined && typeof code !== 'string')
-    throw new ERR_INVALID_ARG_TYPE('code', 'string', code);
+  // Lazy-load to avoid a circular dependency.
+  if (validateString === undefined)
+    ({ validateString } = require('internal/validators'));
+
+  if (code !== undefined)
+    validateString(code, 'code');
 
   let warned = false;
   function deprecated(...args) {
@@ -170,6 +199,11 @@ function slowCases(enc) {
         `${enc}`.toLowerCase() === 'utf-16le')
         return 'utf16le';
       break;
+    case 9:
+      if (enc === 'base64url' || enc === 'BASE64URL' ||
+          `${enc}`.toLowerCase() === 'base64url')
+        return 'base64url';
+      break;
     default:
       if (enc === '') return 'utf8';
   }
@@ -271,18 +305,27 @@ function getSystemErrorName(err) {
   return entry ? entry[0] : `Unknown system error ${err}`;
 }
 
+function getSystemErrorMap() {
+  return lazyUv().getErrorMap();
+}
+
 const kCustomPromisifiedSymbol = SymbolFor('nodejs.util.promisify.custom');
 const kCustomPromisifyArgsSymbol = Symbol('customPromisifyArgs');
 
+let validateFunction;
+
 function promisify(original) {
-  if (typeof original !== 'function')
-    throw new ERR_INVALID_ARG_TYPE('original', 'Function', original);
+  // Lazy-load to avoid a circular dependency.
+  if (validateFunction === undefined)
+    ({ validateFunction } = require('internal/validators'));
+
+  validateFunction(original, 'original');
 
   if (original[kCustomPromisifiedSymbol]) {
     const fn = original[kCustomPromisifiedSymbol];
-    if (typeof fn !== 'function') {
-      throw new ERR_INVALID_ARG_TYPE('util.promisify.custom', 'Function', fn);
-    }
+
+    validateFunction(fn, 'util.promisify.custom');
+
     return ObjectDefineProperty(fn, kCustomPromisifiedSymbol, {
       value: fn, enumerable: false, writable: false, configurable: true
     });
@@ -323,7 +366,7 @@ function promisify(original) {
 
 promisify.custom = kCustomPromisifiedSymbol;
 
-// The build-in Array#join is slower in v8 6.0
+// The built-in Array#join is slower in v8 6.0
 function join(output, separator) {
   let str = '';
   if (output.length !== 0) {
@@ -404,16 +447,29 @@ function sleep(msec) {
   _sleep(msec);
 }
 
+function createDeferredPromise() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return { promise, resolve, reject };
+}
+
 module.exports = {
   assertCrypto,
   cachedResult,
   convertToValidSignal,
   createClassWrapper,
+  createDeferredPromise,
   decorateErrorStack,
   deprecate,
   emitExperimentalWarning,
   filterDuplicateStrings,
   getConstructorOf,
+  getSystemErrorMap,
   getSystemErrorName,
   isError,
   isInsideNodeModules,
@@ -423,6 +479,7 @@ module.exports = {
   promisify,
   sleep,
   spliceOne,
+  toUSVString,
   removeColors,
 
   // Symbol used to customize promisify conversion
diff --git a/lib/internal/util/comparisons.js b/lib/internal/util/comparisons.js
index 66be3fe701a2fbe714d4bcec633364f62fe225ed..d4f4597d9b090882ef44d50a2d1274c625b74be9 100644
--- a/lib/internal/util/comparisons.js
+++ b/lib/internal/util/comparisons.js
@@ -142,7 +142,7 @@ function isIdenticalTypedArrayType(a, b) {
     isBigInt64Array,
     isBigUint64Array,
     isUint8ClampedArray,
-    isUint8Array
+    isUint8Array,
   ]) {
     if (check(a)) {
       return check(b);
@@ -191,7 +191,7 @@ function innerDeepEqual(val1, val2, strict, memos) {
     if (val1 === null || typeof val1 !== 'object') {
       if (val2 === null || typeof val2 !== 'object') {
         // eslint-disable-next-line eqeqeq
-        return val1 == val2;
+        return val1 == val2 || (NumberIsNaN(val1) && NumberIsNaN(val2));
       }
       return false;
     }
@@ -315,7 +315,7 @@ function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
   // Cheap key test
   let i = 0;
   for (; i < aKeys.length; i++) {
-    if (!ObjectPrototypeHasOwnProperty(val2, aKeys[i])) {
+    if (!ObjectPrototypePropertyIsEnumerable(val2, aKeys[i])) {
       return false;
     }
   }
@@ -460,9 +460,9 @@ function setEquiv(a, b, strict, memo) {
       if (set === null) {
         set = new Set();
       }
-      // If the specified value doesn't exist in the second set its an not null
+      // If the specified value doesn't exist in the second set it's a non-null
       // object (or non strict only: a not matching primitive) we'll need to go
-      // hunting for something thats deep-(strict-)equal to it. To make this
+      // hunting for something that's deep-(strict-)equal to it. To make this
       // O(n log n) complexity we have to copy these values in a new set first.
       set.add(val);
     } else if (!b.has(val)) {
@@ -518,7 +518,7 @@ function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
 function mapEquiv(a, b, strict, memo) {
   let set = null;
 
-  for (const [key, item1] of a) {
+  for (const { 0: key, 1: item1 } of a) {
     if (typeof key === 'object' && key !== null) {
       if (set === null) {
         set = new Set();
@@ -545,7 +545,7 @@ function mapEquiv(a, b, strict, memo) {
   }
 
   if (set !== null) {
-    for (const [key, item] of b) {
+    for (const { 0: key, 1: item } of b) {
       if (typeof key === 'object' && key !== null) {
         if (!mapHasEqualEntry(set, a, key, item, strict, memo))
           return false;
diff --git a/lib/internal/util/debuglog.js b/lib/internal/util/debuglog.js
index 35c1d918aedc5c0b580419ce1731207430999ee9..46d3ed5613246ecbd9100b29a84706ed1dab5473 100644
--- a/lib/internal/util/debuglog.js
+++ b/lib/internal/util/debuglog.js
@@ -1,18 +1,27 @@
 'use strict';
 
-const { inspect, format, formatWithOptions } = require('internal/util/inspect');
+const {
+  FunctionPrototypeBind,
+  ObjectCreate,
+  ObjectDefineProperty,
+  RegExp,
+  RegExpPrototypeTest,
+  SafeArrayIterator,
+  StringPrototypeToUpperCase
+} = primordials;
 
-const { RegExp } = primordials;
+const { inspect, format, formatWithOptions } = require('internal/util/inspect');
 
 // `debugs` is deliberately initialized to undefined so any call to
 // debuglog() before initializeDebugEnv() is called will throw.
-let debugs;
+let debugImpls;
 
 let debugEnvRegex = /^$/;
+let testEnabled;
 
 // `debugEnv` is initial value of process.env.NODE_DEBUG
 function initializeDebugEnv(debugEnv) {
-  debugs = {};
+  debugImpls = ObjectCreate(null);
   if (debugEnv) {
     debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, '\\$&')
       .replace(/\*/g, '.*')
@@ -20,6 +29,7 @@ function initializeDebugEnv(debugEnv) {
       .toUpperCase();
     debugEnvRegex = new RegExp(`^${debugEnv}$`, 'i');
   }
+  testEnabled = FunctionPrototypeBind(RegExpPrototypeTest, null, debugEnvRegex);
 }
 
 // Emits warning when user sets
@@ -35,23 +45,22 @@ function emitWarningIfNeeded(set) {
 
 function noop() {}
 
-function debuglogImpl(set) {
-  set = set.toUpperCase();
-  if (debugs[set] === undefined) {
-    if (debugEnvRegex.test(set)) {
+function debuglogImpl(enabled, set) {
+  if (debugImpls[set] === undefined) {
+    if (enabled) {
       const pid = process.pid;
       emitWarningIfNeeded(set);
-      debugs[set] = function debug(...args) {
+      debugImpls[set] = function debug(...args) {
         const colors = process.stderr.hasColors && process.stderr.hasColors();
         const msg = formatWithOptions({ colors }, ...args);
         const coloredPID = inspect(pid, { colors });
         process.stderr.write(format('%s %s: %s\n', set, coloredPID, msg));
       };
     } else {
-      debugs[set] = noop;
+      debugImpls[set] = noop;
     }
   }
-  return debugs[set];
+  return debugImpls[set];
 }
 
 // debuglogImpl depends on process.pid and process.env.NODE_DEBUG,
@@ -59,17 +68,34 @@ function debuglogImpl(set) {
 // that may be loaded before these run time states are allowed to
 // be accessed.
 function debuglog(set, cb) {
+  function init() {
+    set = StringPrototypeToUpperCase(set);
+    enabled = testEnabled(set);
+  }
   let debug = (...args) => {
+    init();
     // Only invokes debuglogImpl() when the debug function is
     // called for the first time.
-    debug = debuglogImpl(set);
+    debug = debuglogImpl(enabled, set);
     if (typeof cb === 'function')
       cb(debug);
-    debug(...args);
+    debug(...new SafeArrayIterator(args));
   };
-  return (...args) => {
-    debug(...args);
+  let enabled;
+  let test = () => {
+    init();
+    test = () => enabled;
+    return enabled;
   };
+  const logger = (...args) => debug(...new SafeArrayIterator(args));
+  ObjectDefineProperty(logger, 'enabled', {
+    get() {
+      return test();
+    },
+    configurable: true,
+    enumerable: true
+  });
+  return logger;
 }
 
 module.exports = {
diff --git a/lib/internal/util/inspect.js b/lib/internal/util/inspect.js
index 7d35301bb6a06e5739daf13fca49b661c9650607..b39d1bacc3dd9a427344bcf50624195db8f99d6f 100644
--- a/lib/internal/util/inspect.js
+++ b/lib/internal/util/inspect.js
@@ -3,21 +3,19 @@
 const {
   Array,
   ArrayIsArray,
-  BigInt64Array,
+  ArrayPrototypeFilter,
+  ArrayPrototypePushApply,
   BigIntPrototypeValueOf,
-  BigUint64Array,
   BooleanPrototypeValueOf,
   DatePrototypeGetTime,
   DatePrototypeToISOString,
   DatePrototypeToString,
   ErrorPrototypeToString,
-  Float32Array,
   FunctionPrototypeCall,
   FunctionPrototypeToString,
-  Int16Array,
   JSONStringify,
   Map,
-  MapPrototype,
+  MapPrototypeGetSize,
   MapPrototypeEntries,
   MathFloor,
   MathMax,
@@ -26,6 +24,8 @@ const {
   MathSqrt,
   Number,
   NumberIsNaN,
+  NumberParseFloat,
+  NumberParseInt,
   NumberPrototypeValueOf,
   Object,
   ObjectAssign,
@@ -41,21 +41,25 @@ const {
   ObjectPrototypePropertyIsEnumerable,
   ObjectSeal,
   ObjectSetPrototypeOf,
+  ReflectApply,
   RegExp,
+  RegExpPrototypeExec,
   RegExpPrototypeToString,
+  SafeSet,
+  SafeStringIterator,
   Set,
-  SetPrototype,
+  SetPrototypeGetSize,
   SetPrototypeValues,
+  String,
   StringPrototypeValueOf,
   SymbolPrototypeToString,
   SymbolPrototypeValueOf,
   SymbolIterator,
   SymbolToStringTag,
-  Uint16Array,
-  Uint32Array,
+  TypedArrayPrototypeGetLength,
+  TypedArrayPrototypeGetSymbolToStringTag,
   Uint8Array,
-  Uint8ArrayPrototype,
-  Uint8ClampedArray,
+  globalThis,
   uncurryThis,
 } = primordials;
 
@@ -113,35 +117,19 @@ const {
   isNumberObject,
   isBooleanObject,
   isBigIntObject,
-  isUint8Array,
-  isUint8ClampedArray,
-  isUint16Array,
-  isUint32Array,
-  isInt8Array,
-  isInt16Array,
-  isInt32Array,
-  isFloat32Array,
-  isFloat64Array,
-  isBigInt64Array,
-  isBigUint64Array
 } = require('internal/util/types');
 
 const assert = require('internal/assert');
 
 const { NativeModule } = require('internal/bootstrap/loaders');
 
-const setSizeGetter = uncurryThis(
-  ObjectGetOwnPropertyDescriptor(SetPrototype, 'size').get);
-const mapSizeGetter = uncurryThis(
-  ObjectGetOwnPropertyDescriptor(MapPrototype, 'size').get);
-const typedArraySizeGetter = uncurryThis(
-  ObjectGetOwnPropertyDescriptor(
-    ObjectGetPrototypeOf(Uint8ArrayPrototype), 'length').get);
-
 let hexSlice;
 
-const builtInObjects = new Set(
-  ObjectGetOwnPropertyNames(global).filter((e) => /^[A-Z][a-zA-Z0-9]+$/.test(e))
+const builtInObjects = new SafeSet(
+  ArrayPrototypeFilter(
+    ObjectGetOwnPropertyNames(globalThis),
+    (e) => RegExpPrototypeExec(/^[A-Z][a-zA-Z0-9]+$/, e) !== null
+  )
 );
 
 // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
@@ -168,10 +156,10 @@ const kArrayType = 1;
 const kArrayExtrasType = 2;
 
 /* eslint-disable no-control-regex */
-const strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c]/;
-const strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c]/g;
-const strEscapeSequencesRegExpSingle = /[\x00-\x1f\x5c]/;
-const strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c]/g;
+const strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c\x7f-\x9f]/;
+const strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c\x7f-\x9f]/g;
+const strEscapeSequencesRegExpSingle = /[\x00-\x1f\x5c\x7f-\x9f]/;
+const strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c\x7f-\x9f]/g;
 /* eslint-enable no-control-regex */
 
 const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
@@ -191,25 +179,27 @@ const kWeak = 0;
 const kIterator = 1;
 const kMapEntries = 2;
 
-// Escaped special characters. Use empty strings to fill up unused entries.
+// Escaped control characters (plus the single quote and the backslash). Use
+// empty strings to fill up unused entries.
 const meta = [
-  '\\u0000', '\\u0001', '\\u0002', '\\u0003', '\\u0004',
-  '\\u0005', '\\u0006', '\\u0007', '\\b', '\\t',
-  '\\n', '\\u000b', '\\f', '\\r', '\\u000e',
-  '\\u000f', '\\u0010', '\\u0011', '\\u0012', '\\u0013',
-  '\\u0014', '\\u0015', '\\u0016', '\\u0017', '\\u0018',
-  '\\u0019', '\\u001a', '\\u001b', '\\u001c', '\\u001d',
-  '\\u001e', '\\u001f', '', '', '',
-  '', '', '', '', "\\'", '', '', '', '', '',
-  '', '', '', '', '', '', '', '', '', '',
-  '', '', '', '', '', '', '', '', '', '',
-  '', '', '', '', '', '', '', '', '', '',
-  '', '', '', '', '', '', '', '', '', '',
-  '', '', '', '', '', '', '', '\\\\'
+  '\\x00', '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\x07', // x07
+  '\\b', '\\t', '\\n', '\\x0B', '\\f', '\\r', '\\x0E', '\\x0F',           // x0F
+  '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17', // x17
+  '\\x18', '\\x19', '\\x1A', '\\x1B', '\\x1C', '\\x1D', '\\x1E', '\\x1F', // x1F
+  '', '', '', '', '', '', '', "\\'", '', '', '', '', '', '', '', '',      // x2F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x3F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x4F
+  '', '', '', '', '', '', '', '', '', '', '', '', '\\\\', '', '', '',     // x5F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x6F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '\\x7F',    // x7F
+  '\\x80', '\\x81', '\\x82', '\\x83', '\\x84', '\\x85', '\\x86', '\\x87', // x87
+  '\\x88', '\\x89', '\\x8A', '\\x8B', '\\x8C', '\\x8D', '\\x8E', '\\x8F', // x8F
+  '\\x90', '\\x91', '\\x92', '\\x93', '\\x94', '\\x95', '\\x96', '\\x97', // x97
+  '\\x98', '\\x99', '\\x9A', '\\x9B', '\\x9C', '\\x9D', '\\x9E', '\\x9F', // x9F
 ];
 
 // Regex used for ansi escape code splitting
-// Adopted from https://github.com/chalk/ansi-regex/blob/master/index.js
+// Adopted from https://github.com/chalk/ansi-regex/blob/HEAD/index.js
 // License: MIT, authors: @sindresorhus, Qix-, arjunmehta and LitoMore
 // Matches all ansi escape code sequences in a string
 const ansiPattern = '[\\u001B\\u009B][[\\]()#;?]*' +
@@ -307,7 +297,8 @@ function inspect(value, opts) {
       ctx.showHidden = opts;
     } else if (opts) {
       const optKeys = ObjectKeys(opts);
-      for (const key of optKeys) {
+      for (let i = 0; i < optKeys.length; ++i) {
+        const key = optKeys[i];
         // TODO(BridgeAR): Find a solution what to do about stylize. Either make
         // this function public or add a new API with a similar or better
         // functionality.
@@ -353,7 +344,7 @@ inspect.colors = ObjectAssign(ObjectCreate(null), {
   italic: [3, 23],
   underline: [4, 24],
   blink: [5, 25],
-  // Swap forground and background colors
+  // Swap foreground and background colors
   inverse: [7, 27], // Alias: swapcolors, swapColors
   hidden: [8, 28], // Alias: conceal
   strikethrough: [9, 29], // Alias: strikeThrough, crossedout, crossedOut
@@ -488,7 +479,10 @@ function strEscape(str) {
   const lastIndex = str.length;
   for (let i = 0; i < lastIndex; i++) {
     const point = str.charCodeAt(i);
-    if (point === singleQuote || point === 92 || point < 32) {
+    if (point === singleQuote ||
+        point === 92 ||
+        point < 32 ||
+        (point > 126 && point < 160)) {
       if (last === i) {
         result += meta[point];
       } else {
@@ -523,6 +517,14 @@ function getEmptyFormatArray() {
   return [];
 }
 
+function isInstanceof(object, proto) {
+  try {
+    return object instanceof proto;
+  } catch {
+    return false;
+  }
+}
+
 function getConstructorName(obj, ctx, recurseTimes, protoProps) {
   let firstProto;
   const tmp = obj;
@@ -530,7 +532,8 @@ function getConstructorName(obj, ctx, recurseTimes, protoProps) {
     const descriptor = ObjectGetOwnPropertyDescriptor(obj, 'constructor');
     if (descriptor !== undefined &&
         typeof descriptor.value === 'function' &&
-        descriptor.value.name !== '') {
+        descriptor.value.name !== '' &&
+        isInstanceof(tmp, descriptor.value)) {
       if (protoProps !== undefined &&
          (firstProto !== obj ||
          !builtInObjects.has(descriptor.value.name))) {
@@ -616,7 +619,7 @@ function addPrototypeProperties(ctx, main, obj, recurseTimes, output) {
         continue;
       }
       const value = formatProperty(
-        ctx, obj, recurseTimes, key, kObjectType, desc);
+        ctx, obj, recurseTimes, key, kObjectType, desc, main);
       if (ctx.colors) {
         // Faint!
         output.push(`\u001b[2m${value}\u001b[22m`);
@@ -632,7 +635,7 @@ function addPrototypeProperties(ctx, main, obj, recurseTimes, output) {
 
 function getPrefix(constructor, tag, fallback, size = '') {
   if (constructor === null) {
-    if (tag !== '') {
+    if (tag !== '' && fallback !== tag) {
       return `[${fallback}${size}: null prototype] [${tag}] `;
     }
     return `[${fallback}${size}: null prototype] `;
@@ -651,7 +654,7 @@ function getKeys(value, showHidden) {
   if (showHidden) {
     keys = ObjectGetOwnPropertyNames(value);
     if (symbols.length !== 0)
-      keys.push(...symbols);
+      ArrayPrototypePushApply(keys, symbols);
   } else {
     // This might throw if `value` is a Module Namespace Object from an
     // unevaluated module, but we don't want to perform the actual type
@@ -667,7 +670,7 @@ function getKeys(value, showHidden) {
     }
     if (symbols.length !== 0) {
       const filter = (key) => ObjectPrototypePropertyIsEnumerable(value, key);
-      keys.push(...symbols.filter(filter));
+      ArrayPrototypePushApply(keys, ArrayPrototypeFilter(symbols, filter));
     }
   }
   return keys;
@@ -692,33 +695,13 @@ function formatProxy(ctx, proxy, recurseTimes) {
   ctx.indentationLvl += 2;
   const res = [
     formatValue(ctx, proxy[0], recurseTimes),
-    formatValue(ctx, proxy[1], recurseTimes)
+    formatValue(ctx, proxy[1], recurseTimes),
   ];
   ctx.indentationLvl -= 2;
   return reduceToSingleString(
     ctx, res, '', ['Proxy [', ']'], kArrayExtrasType, recurseTimes);
 }
 
-function findTypedConstructor(value) {
-  for (const [check, clazz] of [
-    [isUint8Array, Uint8Array],
-    [isUint8ClampedArray, Uint8ClampedArray],
-    [isUint16Array, Uint16Array],
-    [isUint32Array, Uint32Array],
-    [isInt8Array, Int8Array],
-    [isInt16Array, Int16Array],
-    [isInt32Array, Int32Array],
-    [isFloat32Array, Float32Array],
-    [isFloat64Array, Float64Array],
-    [isBigInt64Array, BigInt64Array],
-    [isBigUint64Array, BigUint64Array]
-  ]) {
-    if (check(value)) {
-      return clazz;
-    }
-  }
-}
-
 // Note: using `formatValue` directly requires the indentation level to be
 // corrected by setting `ctx.indentationLvL += diff` and then to decrease the
 // value afterwards again.
@@ -785,7 +768,7 @@ function formatValue(ctx, value, recurseTimes, typedArray) {
         ctx.circular.set(value, index);
       }
     }
-    return ctx.stylize('[Circular]', 'special');
+    return ctx.stylize(`[Circular *${index}]`, 'special');
   }
 
   return formatRaw(ctx, value, recurseTimes, typedArray);
@@ -842,22 +825,22 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
       extrasType = kArrayExtrasType;
       formatter = formatArray;
     } else if (isSet(value)) {
-      const size = setSizeGetter(value);
-      const prefix = getPrefix(constructor, tag, 'Set');
+      const size = SetPrototypeGetSize(value);
+      const prefix = getPrefix(constructor, tag, 'Set', `(${size})`);
       keys = getKeys(value, ctx.showHidden);
       formatter = constructor !== null ?
-        formatSet.bind(null, value, size) :
-        formatSet.bind(null, SetPrototypeValues(value), size);
+        formatSet.bind(null, value) :
+        formatSet.bind(null, SetPrototypeValues(value));
       if (size === 0 && keys.length === 0 && protoProps === undefined)
         return `${prefix}{}`;
       braces = [`${prefix}{`, '}'];
     } else if (isMap(value)) {
-      const size = mapSizeGetter(value);
-      const prefix = getPrefix(constructor, tag, 'Map');
+      const size = MapPrototypeGetSize(value);
+      const prefix = getPrefix(constructor, tag, 'Map', `(${size})`);
       keys = getKeys(value, ctx.showHidden);
       formatter = constructor !== null ?
-        formatMap.bind(null, value, size) :
-        formatMap.bind(null, MapPrototypeEntries(value), size);
+        formatMap.bind(null, value) :
+        formatMap.bind(null, MapPrototypeEntries(value));
       if (size === 0 && keys.length === 0 && protoProps === undefined)
         return `${prefix}{}`;
       braces = [`${prefix}{`, '}'];
@@ -866,12 +849,11 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
       let bound = value;
       let fallback = '';
       if (constructor === null) {
-        const constr = findTypedConstructor(value);
-        fallback = constr.name;
+        fallback = TypedArrayPrototypeGetSymbolToStringTag(value);
         // Reconstruct the array information.
-        bound = new constr(value);
+        bound = new primordials[fallback](value);
       }
-      const size = typedArraySizeGetter(value);
+      const size = TypedArrayPrototypeGetLength(value);
       const prefix = getPrefix(constructor, tag, fallback, `(${size})`);
       braces = [`${prefix}[`, ']'];
       if (value.length === 0 && keys.length === 0 && !ctx.showHidden)
@@ -966,7 +948,7 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
       braces[0] = `${getPrefix(constructor, tag, 'WeakMap')}{`;
       formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection;
     } else if (isModuleNamespaceObject(value)) {
-      braces[0] = `[${tag}] {`;
+      braces[0] = `${getPrefix(constructor, tag, 'Module')}{`;
       // Special handle keys for namespace objects.
       formatter = formatNamespaceObject.bind(null, keys);
     } else if (isBoxedPrimitive(value)) {
@@ -1014,11 +996,12 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
   if (ctx.circular !== undefined) {
     const index = ctx.circular.get(value);
     if (index !== undefined) {
+      const reference = ctx.stylize(`<ref *${index}>`, 'special');
       // Add reference always to the very beginning of the output.
       if (ctx.compact !== true) {
-        base = base === '' ? '' : `${base}`;
+        base = base === '' ? reference : `${reference} ${base}`;
       } else {
-        braces[0] = `${braces[0]}`;
+        braces[0] = `${reference} ${braces[0]}`;
       }
     }
   }
@@ -1145,7 +1128,9 @@ function getFunctionBase(value, constructor, tag) {
   if (constructor === null) {
     base += ' (null prototype)';
   }
-  if (value.name !== '') {
+  if (value.name === '') {
+    base += ' (anonymous)';
+  } else {
     base += `: ${value.name}`;
   }
   base += ']';
@@ -1362,7 +1347,8 @@ function handleMaxCallStackSize(ctx, err, constructorName, indentationLvl) {
       'special'
     );
   }
-  throw err;
+  /* c8 ignore next */
+  assert.fail(err.stack);
 }
 
 function formatNumber(fn, value) {
@@ -1413,9 +1399,7 @@ function formatNamespaceObject(keys, ctx, value, recurseTimes) {
       output[i] = formatProperty(ctx, value, recurseTimes, keys[i],
                                  kObjectType);
     } catch (err) {
-      if (!(isNativeError(err) && err.name === 'ReferenceError')) {
-        throw err;
-      }
+      assert(isNativeError(err) && err.name === 'ReferenceError');
       // Use the existing functionality. This makes sure the indentation and
       // line breaks are always correct. Otherwise it is very difficult to keep
       // this aligned, even though this is a hacky way of dealing with this.
@@ -1529,7 +1513,7 @@ function formatTypedArray(value, length, ctx, ignored, recurseTimes) {
       'length',
       'byteLength',
       'byteOffset',
-      'buffer'
+      'buffer',
     ]) {
       const str = formatValue(ctx, value[key], recurseTimes, true);
       output.push(`[${key}]: ${str}`);
@@ -1539,32 +1523,25 @@ function formatTypedArray(value, length, ctx, ignored, recurseTimes) {
   return output;
 }
 
-function formatSet(value, size, ctx, ignored, recurseTimes) {
+function formatSet(value, ctx, ignored, recurseTimes) {
   const output = [];
   ctx.indentationLvl += 2;
   for (const v of value) {
     output.push(formatValue(ctx, v, recurseTimes));
   }
   ctx.indentationLvl -= 2;
-  // With `showHidden`, `length` will display as a hidden property for
-  // arrays. For consistency's sake, do the same for `size`, even though this
-  // property isn't selected by ObjectGetOwnPropertyNames().
-  if (ctx.showHidden)
-    output.push(`[size]: ${ctx.stylize(`${size}`, 'number')}`);
   return output;
 }
 
-function formatMap(value, size, ctx, ignored, recurseTimes) {
+function formatMap(value, ctx, ignored, recurseTimes) {
   const output = [];
   ctx.indentationLvl += 2;
-  for (const [k, v] of value) {
-    output.push(`${formatValue(ctx, k, recurseTimes)} => ` +
-                formatValue(ctx, v, recurseTimes));
+  for (const { 0: k, 1: v } of value) {
+    output.push(
+      `${formatValue(ctx, k, recurseTimes)} => ${formatValue(ctx, v, recurseTimes)}`
+    );
   }
   ctx.indentationLvl -= 2;
-  // See comment in formatSet
-  if (ctx.showHidden)
-    output.push(`[size]: ${ctx.stylize(`${size}`, 'number')}`);
   return output;
 }
 
@@ -1602,8 +1579,8 @@ function formatMapIterInner(ctx, recurseTimes, entries, state) {
   if (state === kWeak) {
     for (; i < maxLength; i++) {
       const pos = i * 2;
-      output[i] = `${formatValue(ctx, entries[pos], recurseTimes)}` +
-        ` => ${formatValue(ctx, entries[pos + 1], recurseTimes)}`;
+      output[i] =
+        `${formatValue(ctx, entries[pos], recurseTimes)} => ${formatValue(ctx, entries[pos + 1], recurseTimes)}`;
     }
     // Sort all entries to have a halfway reliable output (if more entries than
     // retrieved ones exist, we can not reliably return the same output) if the
@@ -1615,7 +1592,7 @@ function formatMapIterInner(ctx, recurseTimes, entries, state) {
       const pos = i * 2;
       const res = [
         formatValue(ctx, entries[pos], recurseTimes),
-        formatValue(ctx, entries[pos + 1], recurseTimes)
+        formatValue(ctx, entries[pos + 1], recurseTimes),
       ];
       output[i] = reduceToSingleString(
         ctx, res, '', ['[', ']'], kArrayExtrasType, recurseTimes);
@@ -1643,7 +1620,7 @@ function formatWeakMap(ctx, value, recurseTimes) {
 }
 
 function formatIterator(braces, ctx, value, recurseTimes) {
-  const [entries, isKeyValue] = previewEntries(value, true);
+  const { 0: entries, 1: isKeyValue } = previewEntries(value, true);
   if (isKeyValue) {
     // Mark entry iterators as such.
     braces[0] = braces[0].replace(/ Iterator] {$/, ' Entries] {');
@@ -1655,7 +1632,7 @@ function formatIterator(braces, ctx, value, recurseTimes) {
 
 function formatPromise(ctx, value, recurseTimes) {
   let output;
-  const [state, result] = getPromiseDetails(value);
+  const { 0: state, 1: result } = getPromiseDetails(value);
   if (state === kPending) {
     output = [ctx.stylize('<pending>', 'special')];
   } else {
@@ -1665,13 +1642,14 @@ function formatPromise(ctx, value, recurseTimes) {
     output = [
       state === kRejected ?
         `${ctx.stylize('<rejected>', 'special')} ${str}` :
-        str
+        str,
     ];
   }
   return output;
 }
 
-function formatProperty(ctx, value, recurseTimes, key, type, desc) {
+function formatProperty(ctx, value, recurseTimes, key, type, desc,
+                        original = value) {
   let name, str;
   let extra = ' ';
   desc = desc || ObjectGetOwnPropertyDescriptor(value, key) ||
@@ -1692,7 +1670,7 @@ function formatProperty(ctx, value, recurseTimes, key, type, desc) {
           (ctx.getters === 'get' && desc.set === undefined) ||
           (ctx.getters === 'set' && desc.set !== undefined))) {
       try {
-        const tmp = value[key];
+        const tmp = ReflectApply(desc.get, original, []);
         ctx.indentationLvl += 2;
         if (tmp === null) {
           str = `${s(`[${label}:`, sp)} ${s('null', 'null')}${s(']', sp)}`;
@@ -1721,6 +1699,8 @@ function formatProperty(ctx, value, recurseTimes, key, type, desc) {
   if (typeof key === 'symbol') {
     const tmp = key.toString().replace(strEscapeSequencesReplacer, escapeFn);
     name = `[${ctx.stylize(tmp, 'symbol')}]`;
+  } else if (key === '__proto__') {
+    name = "['__proto__']";
   } else if (desc.enumerable === false) {
     name = `[${key.replace(strEscapeSequencesReplacer, escapeFn)}]`;
   } else if (keyStrRegExp.test(key)) {
@@ -1759,7 +1739,7 @@ function reduceToSingleString(
   ctx, output, base, braces, extrasType, recurseTimes, value) {
   if (ctx.compact !== true) {
     if (typeof ctx.compact === 'number' && ctx.compact >= 1) {
-      // Memorize the original output length. In case the the output is grouped,
+      // Memorize the original output length. In case the output is grouped,
       // prevent lining up the entries on a single line.
       const entries = output.length;
       // Group array elements together if the array contains at least six
@@ -1815,10 +1795,6 @@ function reduceToSingleString(
   return `${braces[0]}${ln}${join(output, `,\n${indentation}  `)} ${braces[1]}`;
 }
 
-function format(...args) {
-  return formatWithOptions(undefined, ...args);
-}
-
 function hasBuiltInToString(value) {
   // Prevent triggering proxy traps.
   const getFullProxy = false;
@@ -1873,7 +1849,19 @@ function tryStringify(arg) {
   }
 }
 
+function format(...args) {
+  return formatWithOptionsInternal(undefined, args);
+}
+
 function formatWithOptions(inspectOptions, ...args) {
+  if (typeof inspectOptions !== 'object' || inspectOptions === null) {
+    throw new ERR_INVALID_ARG_TYPE(
+      'inspectOptions', 'object', inspectOptions);
+  }
+  return formatWithOptionsInternal(inspectOptions, args);
+}
+
+function formatWithOptionsInternal(inspectOptions, args) {
   const first = args[0];
   let a = 0;
   let str = '';
@@ -1941,7 +1929,8 @@ function formatWithOptions(inspectOptions, ...args) {
               } else if (typeof tempInteger === 'symbol') {
                 tempStr = 'NaN';
               } else {
-                tempStr = formatNumber(stylizeNoColor, parseInt(tempInteger));
+                tempStr = formatNumber(stylizeNoColor,
+                                       NumberParseInt(tempInteger));
               }
               break;
             case 102: // 'f'
@@ -1949,7 +1938,8 @@ function formatWithOptions(inspectOptions, ...args) {
               if (typeof tempFloat === 'symbol') {
                 tempStr = 'NaN';
               } else {
-                tempStr = formatNumber(stylizeNoColor, parseFloat(tempFloat));
+                tempStr = formatNumber(stylizeNoColor,
+                                       NumberParseFloat(tempFloat));
               }
               break;
             case 99: // 'c'
@@ -2027,7 +2017,7 @@ if (internalBinding('config').hasIntl) {
     if (removeControlChars)
       str = stripVTControlCharacters(str);
     str = str.normalize('NFC');
-    for (const char of str) {
+    for (const char of new SafeStringIterator(str)) {
       const code = char.codePointAt(0);
       if (isFullWidthCodePoint(code)) {
         width += 2;
diff --git a/lib/internal/util/iterable_weak_map.js b/lib/internal/util/iterable_weak_map.js
new file mode 100644
index 0000000000000000000000000000000000000000..06d0001970635fb870f3389e1609f606bf94fcdc
--- /dev/null
+++ b/lib/internal/util/iterable_weak_map.js
@@ -0,0 +1,96 @@
+'use strict';
+
+const {
+  makeSafe,
+  ObjectFreeze,
+  SafeSet,
+  SafeWeakMap,
+  SymbolIterator,
+  globalThis,
+} = primordials;
+
+// TODO(aduh95): Add FinalizationRegistry to primordials
+const SafeFinalizationRegistry = makeSafe(
+  globalThis.FinalizationRegistry,
+  class SafeFinalizationRegistry extends globalThis.FinalizationRegistry {}
+);
+
+// TODO(aduh95): Add WeakRef to primordials
+const SafeWeakRef = makeSafe(
+  globalThis.WeakRef,
+  class SafeWeakRef extends globalThis.WeakRef {}
+);
+
+// This class is modified from the example code in the WeakRefs specification:
+// https://github.com/tc39/proposal-weakrefs
+// Licensed under ECMA's MIT-style license, see:
+// https://github.com/tc39/ecma262/blob/HEAD/LICENSE.md
+class IterableWeakMap {
+  #weakMap = new SafeWeakMap();
+  #refSet = new SafeSet();
+  #finalizationGroup = new SafeFinalizationRegistry(cleanup);
+
+  set(key, value) {
+    const entry = this.#weakMap.get(key);
+    if (entry) {
+      // If there's already an entry for the object represented by "key",
+      // the value can be updated without creating a new WeakRef:
+      this.#weakMap.set(key, { value, ref: entry.ref });
+    } else {
+      const ref = new SafeWeakRef(key);
+      this.#weakMap.set(key, { value, ref });
+      this.#refSet.add(ref);
+      this.#finalizationGroup.register(key, {
+        set: this.#refSet,
+        ref
+      }, ref);
+    }
+  }
+
+  get(key) {
+    return this.#weakMap.get(key)?.value;
+  }
+
+  has(key) {
+    return this.#weakMap.has(key);
+  }
+
+  delete(key) {
+    const entry = this.#weakMap.get(key);
+    if (!entry) {
+      return false;
+    }
+    this.#weakMap.delete(key);
+    this.#refSet.delete(entry.ref);
+    this.#finalizationGroup.unregister(entry.ref);
+    return true;
+  }
+
+  [SymbolIterator]() {
+    const iterator = this.#refSet[SymbolIterator]();
+
+    const next = () => {
+      const result = iterator.next();
+      if (result.done) return result;
+      const key = result.value.deref();
+      if (key == null) return next();
+      const { value } = this.#weakMap.get(key);
+      return { done: false, value };
+    };
+
+    return {
+      [SymbolIterator]() { return this; },
+      next,
+    };
+  }
+}
+
+function cleanup({ set, ref }) {
+  set.delete(ref);
+}
+
+ObjectFreeze(IterableWeakMap.prototype);
+
+module.exports = {
+  IterableWeakMap,
+};
diff --git a/lib/internal/util/types.js b/lib/internal/util/types.js
index 4b9eeb469b2d19c0d876edf1071e6b213ddd3d55..6f5309a41c3d79c6da631b49631d9f507048764b 100644
--- a/lib/internal/util/types.js
+++ b/lib/internal/util/types.js
@@ -2,66 +2,55 @@
 
 const {
   ArrayBufferIsView,
-  ObjectGetOwnPropertyDescriptor,
-  ObjectGetPrototypeOf,
-  SymbolToStringTag,
-  Uint8ArrayPrototype,
-  uncurryThis,
+  TypedArrayPrototypeGetSymbolToStringTag,
 } = primordials;
 
-const TypedArrayPrototype = ObjectGetPrototypeOf(Uint8ArrayPrototype);
-
-const TypedArrayProto_toStringTag =
-    uncurryThis(
-      ObjectGetOwnPropertyDescriptor(TypedArrayPrototype,
-                                     SymbolToStringTag).get);
-
 function isTypedArray(value) {
-  return TypedArrayProto_toStringTag(value) !== undefined;
+  return TypedArrayPrototypeGetSymbolToStringTag(value) !== undefined;
 }
 
 function isUint8Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'Uint8Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Uint8Array';
 }
 
 function isUint8ClampedArray(value) {
-  return TypedArrayProto_toStringTag(value) === 'Uint8ClampedArray';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Uint8ClampedArray';
 }
 
 function isUint16Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'Uint16Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Uint16Array';
 }
 
 function isUint32Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'Uint32Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Uint32Array';
 }
 
 function isInt8Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'Int8Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Int8Array';
 }
 
 function isInt16Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'Int16Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Int16Array';
 }
 
 function isInt32Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'Int32Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Int32Array';
 }
 
 function isFloat32Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'Float32Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Float32Array';
 }
 
 function isFloat64Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'Float64Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Float64Array';
 }
 
 function isBigInt64Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'BigInt64Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'BigInt64Array';
 }
 
 function isBigUint64Array(value) {
-  return TypedArrayProto_toStringTag(value) === 'BigUint64Array';
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === 'BigUint64Array';
 }
 
 module.exports = {
diff --git a/lib/internal/v8_prof_polyfill.js b/lib/internal/v8_prof_polyfill.js
index 5f5922c5386543189d6ae9293108425cf212b054..369da5f9a34741a98649dd0fdbbf0eec54ea90c6 100644
--- a/lib/internal/v8_prof_polyfill.js
+++ b/lib/internal/v8_prof_polyfill.js
@@ -25,7 +25,10 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-/* eslint-disable no-restricted-globals */
+'use strict';
+
+/* eslint-disable node-core/prefer-primordials */
+/* global console */
 
 module.exports = { versionCheck };
 
@@ -37,7 +40,8 @@ if (module.id === 'internal/v8_prof_polyfill') return;
 // Node polyfill
 const fs = require('fs');
 const cp = require('child_process');
-const os = {
+const { Buffer } = require('buffer');
+const os = { // eslint-disable-line no-unused-vars
   system: function(name, args) {
     if (process.platform === 'linux' && name === 'nm') {
       // Filter out vdso and vsyscall entries.
@@ -51,28 +55,29 @@ const os = {
     let out = cp.spawnSync(name, args).stdout.toString();
     // Auto c++filt names, but not [iItT]
     if (process.platform === 'darwin' && name === 'nm') {
-      // nm prints an error along the lines of "Run xcodebuild -license" and
+      // `nm` prints an error along the lines of "Run xcodebuild -license" and
       // exits when Xcode hasn't been properly installed or when its license
       // hasn't been accepted yet. Basically any mention of xcodebuild in
       // the output means the nm command is non-functional.
       const match = out.match(/(?:^|\n)([^\n]*xcodebuild[^\n]*)(?:\n|$)/);
+      // eslint-disable-next-line no-restricted-syntax
       if (match) throw new Error(match[1]);
       out = macCppfiltNm(out);
     }
     return out;
   }
 };
-const print = console.log;
-function read(fileName) {
+const print = console.log; // eslint-disable-line no-unused-vars
+function read(fileName) { // eslint-disable-line no-unused-vars
   return fs.readFileSync(fileName, 'utf8');
 }
-const quit = process.exit;
+const quit = process.exit; // eslint-disable-line no-unused-vars
 
 // Polyfill "readline()".
-const logFile = arguments[arguments.length - 1];
+const logFile = arguments[arguments.length - 1]; // eslint-disable-line no-undef
 try {
   fs.accessSync(logFile);
-} catch(e) {
+} catch {
   console.error('Please provide a valid isolate file as the final argument.');
   process.exit(1);
 }
@@ -121,8 +126,8 @@ function versionCheck(firstLine, expected) {
   // whereas process.versions.v8 is either "$major.$minor.$build-$embedder" or
   // "$major.$minor.$build.$patch-$embedder".
   firstLine = firstLine.split(',');
-  const curVer = expected.split(/[.\-]/);
-  if (firstLine.length !== 6 && firstLine.length !== 7 ||
+  const curVer = expected.split(/[.-]/);
+  if ((firstLine.length !== 6 && firstLine.length !== 7) ||
       firstLine[0] !== 'v8-version') {
     return 'Unable to read v8-version from log file.';
   }
@@ -140,13 +145,11 @@ function macCppfiltNm(out) {
   if (entries === null)
     return out;
 
-  entries = entries.map((entry) => {
-    return entry.replace(CLEAN_RE, '')
-  });
+  entries = entries.map((entry) => entry.replace(CLEAN_RE, ''));
 
   let filtered;
   try {
-    filtered = cp.spawnSync('c++filt', [ '-p' , '-i' ], {
+    filtered = cp.spawnSync('c++filt', [ '-p', '-i' ], {
       input: entries.join('\n')
     }).stdout.toString();
   } catch {
diff --git a/lib/internal/v8_prof_processor.js b/lib/internal/v8_prof_processor.js
index d647d4749f9adc12111c803bb5dbfa81350bc655..0136bc7ba486234c96550552087fd01ab8a4e5c4 100644
--- a/lib/internal/v8_prof_processor.js
+++ b/lib/internal/v8_prof_processor.js
@@ -1,6 +1,8 @@
 'use strict';
 
 const {
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
   JSONStringify,
 } = primordials;
 
@@ -18,21 +20,22 @@ const scriptFiles = [
   'internal/deps/v8/tools/arguments',
   'internal/deps/v8/tools/tickprocessor',
   'internal/deps/v8/tools/SourceMap',
-  'internal/deps/v8/tools/tickprocessor-driver'
+  'internal/deps/v8/tools/tickprocessor-driver',
 ];
 let script = '';
 
-scriptFiles.forEach((s) => {
+for (const s of scriptFiles) {
   script += internalBinding('natives')[s] + '\n';
-});
+}
 
 const tickArguments = [];
 if (process.platform === 'darwin') {
-  tickArguments.push('--mac');
+  ArrayPrototypePush(tickArguments, '--mac');
 } else if (process.platform === 'win32') {
-  tickArguments.push('--windows');
+  ArrayPrototypePush(tickArguments, '--windows');
 }
-tickArguments.push.apply(tickArguments, process.argv.slice(1));
+ArrayPrototypePush(tickArguments,
+                   ...ArrayPrototypeSlice(process.argv, 1));
 script = `(function(module, require) {
   arguments = ${JSONStringify(tickArguments)};
   function write (s) { process.stdout.write(s) }
diff --git a/lib/internal/validators.js b/lib/internal/validators.js
index 1d7bf1baa19fa1e209423eea35c916b3e1cf9063..e20e66cc7e8a7618ead78bbd321f6047502494d9 100644
--- a/lib/internal/validators.js
+++ b/lib/internal/validators.js
@@ -5,6 +5,8 @@ const {
   NumberIsInteger,
   NumberMAX_SAFE_INTEGER,
   NumberMIN_SAFE_INTEGER,
+  NumberParseInt,
+  String,
 } = primordials;
 
 const {
@@ -13,11 +15,13 @@ const {
     ERR_SOCKET_BAD_PORT,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_OPT_VALUE,
     ERR_OUT_OF_RANGE,
     ERR_UNKNOWN_SIGNAL,
     ERR_INVALID_CALLBACK,
   }
 } = require('internal/errors');
+const { normalizeEncoding } = require('internal/util');
 const {
   isArrayBufferView
 } = require('internal/util/types');
@@ -46,7 +50,11 @@ const modeDesc = 'must be a 32-bit unsigned integer or an octal string';
  * @param {number} def If specified, will be returned for invalid values
  * @returns {number}
  */
-function parseMode(value, name, def) {
+function parseFileMode(value, name, def) {
+  if (value == null && def !== undefined) {
+    return def;
+  }
+
   if (isUint32(value)) {
     return value;
   }
@@ -59,11 +67,7 @@ function parseMode(value, name, def) {
     if (!octalReg.test(value)) {
       throw new ERR_INVALID_ARG_VALUE(name, value, modeDesc);
     }
-    return parseInt(value, 8);
-  }
-
-  if (def !== undefined && value == null) {
-    return def;
+    return NumberParseInt(value, 8);
   }
 
   throw new ERR_INVALID_ARG_VALUE(name, value, modeDesc);
@@ -125,21 +129,42 @@ function validateNumber(value, name) {
     throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
 }
 
+const validateOneOf = hideStackFrames((value, name, oneOf, option = false) => {
+  if (!oneOf.includes(value)) {
+    const allowed = oneOf
+      .map((v) => (typeof v === 'string' ? `'${v}'` : String(v)))
+      .join(', ');
+    if (!option) {
+      const reason = 'must be one of: ' + allowed;
+      throw new ERR_INVALID_ARG_VALUE(name, value, reason);
+    } else {
+      const reason = 'Must be one of: ' + allowed;
+      throw new ERR_INVALID_OPT_VALUE(name, value, reason);
+    }
+  }
+});
+
 function validateBoolean(value, name) {
   if (typeof value !== 'boolean')
     throw new ERR_INVALID_ARG_TYPE(name, 'boolean', value);
 }
 
 const validateObject = hideStackFrames(
-  (value, name, { nullable = false } = {}) => {
+  (value, name, {
+    nullable = false,
+    allowArray = false,
+    allowFunction = false,
+  } = {}) => {
     if ((!nullable && value === null) ||
-        ArrayIsArray(value) ||
-        typeof value !== 'object') {
+        (!allowArray && ArrayIsArray(value)) ||
+        (typeof value !== 'object' && (
+          !allowFunction || typeof value !== 'function'
+        ))) {
       throw new ERR_INVALID_ARG_TYPE(name, 'Object', value);
     }
   });
 
-const validateArray = hideStackFrames((value, name, { minLength = 0 } = {}) => {
+const validateArray = hideStackFrames((value, name, minLength = 0) => {
   if (!ArrayIsArray(value)) {
     throw new ERR_INVALID_ARG_TYPE(name, 'Array', value);
   }
@@ -150,8 +175,7 @@ const validateArray = hideStackFrames((value, name, { minLength = 0 } = {}) => {
 });
 
 function validateSignalName(signal, name = 'signal') {
-  if (typeof signal !== 'string')
-    throw new ERR_INVALID_ARG_TYPE(name, 'string', signal);
+  validateString(signal, name);
 
   if (signals[signal] === undefined) {
     if (signals[signal.toUpperCase()] !== undefined) {
@@ -171,9 +195,19 @@ const validateBuffer = hideStackFrames((buffer, name = 'buffer') => {
   }
 });
 
+function validateEncoding(data, encoding) {
+  const normalizedEncoding = normalizeEncoding(encoding);
+  const length = data.length;
+
+  if (normalizedEncoding === 'hex' && length % 2 !== 0) {
+    throw new ERR_INVALID_ARG_VALUE('encoding', encoding,
+                                    `is invalid for data of length ${length}`);
+  }
+}
+
 // Check that the port number is not NaN when coerced to a number,
 // is an integer and that it falls within the legal range of port numbers.
-function validatePort(port, name = 'Port', { allowZero = true } = {}) {
+function validatePort(port, name = 'Port', allowZero = true) {
   if ((typeof port !== 'number' && typeof port !== 'string') ||
       (typeof port === 'string' && port.trim().length === 0) ||
       +port !== (+port >>> 0) ||
@@ -189,20 +223,38 @@ const validateCallback = hideStackFrames((callback) => {
     throw new ERR_INVALID_CALLBACK(callback);
 });
 
+const validateAbortSignal = hideStackFrames((signal, name) => {
+  if (signal !== undefined &&
+      (signal === null ||
+       typeof signal !== 'object' ||
+       !('aborted' in signal))) {
+    throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal);
+  }
+});
+
+const validateFunction = hideStackFrames((value, name) => {
+  if (typeof value !== 'function')
+    throw new ERR_INVALID_ARG_TYPE(name, 'Function', value);
+});
+
 module.exports = {
   isInt32,
   isUint32,
-  parseMode,
+  parseFileMode,
   validateArray,
   validateBoolean,
   validateBuffer,
+  validateEncoding,
+  validateFunction,
   validateInt32,
   validateInteger,
   validateNumber,
   validateObject,
+  validateOneOf,
   validatePort,
   validateSignalName,
   validateString,
   validateUint32,
   validateCallback,
+  validateAbortSignal,
 };
diff --git a/lib/internal/vm/module.js b/lib/internal/vm/module.js
index 992753ef680dbb077247c4b1d5c79a4249817fa7..6bf73291be00c76675ff6d6eb301b0aa519406e4 100644
--- a/lib/internal/vm/module.js
+++ b/lib/internal/vm/module.js
@@ -3,11 +3,19 @@
 const assert = require('internal/assert');
 const {
   ArrayIsArray,
+  ArrayPrototypeForEach,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeSome,
   ObjectCreate,
   ObjectDefineProperty,
-  SafePromise,
+  ObjectGetPrototypeOf,
+  ObjectSetPrototypeOf,
+  PromiseAll,
+  ReflectApply,
+  SafeWeakMap,
   Symbol,
-  WeakMap,
+  SymbolToStringTag,
+  TypeError,
 } = primordials;
 
 const { isContext } = internalBinding('contextify');
@@ -58,7 +66,7 @@ const STATUS_MAP = {
 
 let globalModuleId = 0;
 const defaultModuleName = 'vm:module';
-const wrapToModuleMap = new WeakMap();
+const wrapToModuleMap = new SafeWeakMap();
 
 const kWrap = Symbol('kWrap');
 const kContext = Symbol('kContext');
@@ -219,22 +227,31 @@ class Module {
         'must be one of linked, evaluated, or errored'
       );
     }
-    const result = this[kWrap].evaluate(timeout, breakOnSigint);
-    return { __proto__: null, result };
+    await this[kWrap].evaluate(timeout, breakOnSigint);
   }
 
   [customInspectSymbol](depth, options) {
-    let ctor = getConstructorOf(this);
-    ctor = ctor === null ? Module : ctor;
-
+    if (this[kWrap] === undefined) {
+      throw new ERR_VM_MODULE_NOT_MODULE();
+    }
     if (typeof depth === 'number' && depth < 0)
-      return options.stylize(`[${ctor.name}]`, 'special');
+      return this;
 
-    const o = ObjectCreate({ constructor: ctor });
+    const constructor = getConstructorOf(this) || Module;
+    const o = ObjectCreate({ constructor });
     o.status = this.status;
     o.identifier = this.identifier;
     o.context = this.context;
-    return require('internal/util/inspect').inspect(o, options);
+
+    ObjectSetPrototypeOf(o, ObjectGetPrototypeOf(this));
+    ObjectDefineProperty(o, SymbolToStringTag, {
+      value: constructor.name,
+      configurable: true
+    });
+
+    // Lazy to avoid circular dependency
+    const { inspect } = require('internal/util/inspect');
+    return inspect(o, { ...options, customInspect: false });
   }
 }
 
@@ -309,6 +326,8 @@ class SourceTextModule extends Module {
           throw new ERR_VM_MODULE_DIFFERENT_CONTEXT();
         }
         if (module.status === 'errored') {
+          // TODO(devsnek): replace with ERR_VM_MODULE_LINK_FAILURE
+          // and error cause proposal.
           throw new ERR_VM_MODULE_LINKING_ERRORED();
         }
         if (module.status === 'unlinked') {
@@ -319,7 +338,7 @@ class SourceTextModule extends Module {
 
       try {
         if (promises !== undefined) {
-          await SafePromise.all(promises);
+          await PromiseAll(promises);
         }
       } catch (e) {
         this.#error = e;
@@ -379,13 +398,13 @@ class SourceTextModule extends Module {
 class SyntheticModule extends Module {
   constructor(exportNames, evaluateCallback, options = {}) {
     if (!ArrayIsArray(exportNames) ||
-      exportNames.some((e) => typeof e !== 'string')) {
+      ArrayPrototypeSome(exportNames, (e) => typeof e !== 'string')) {
       throw new ERR_INVALID_ARG_TYPE('exportNames',
                                      'Array of unique strings',
                                      exportNames);
     } else {
-      exportNames.forEach((name, i) => {
-        if (exportNames.indexOf(name, i + 1) !== -1) {
+      ArrayPrototypeForEach(exportNames, (name, i) => {
+        if (ArrayPrototypeIndexOf(exportNames, name, i + 1) !== -1) {
           throw new ERR_INVALID_ARG_VALUE(`exportNames.${name}`,
                                           name,
                                           'is duplicated');
@@ -429,7 +448,7 @@ class SyntheticModule extends Module {
 
 function importModuleDynamicallyWrap(importModuleDynamically) {
   const importModuleDynamicallyWrapper = async (...args) => {
-    const m = await importModuleDynamically(...args);
+    const m = await ReflectApply(importModuleDynamically, this, args);
     if (isModuleNamespaceObject(m)) {
       return m;
     }
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index a4591c03912709a2c99f7ab5334775f45e91654f..2bf1d3de567b2309625e96ac137ebd7975d2c5d0 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -1,17 +1,25 @@
 'use strict';
 
-/* global SharedArrayBuffer */
-
 const {
   ArrayIsArray,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  Float64Array,
+  FunctionPrototypeBind,
+  JSONStringify,
   MathMax,
   ObjectCreate,
   ObjectEntries,
   Promise,
   PromiseResolve,
+  RegExpPrototypeTest,
+  SafeMap,
+  String,
   Symbol,
   SymbolFor,
+  TypedArrayPrototypeFill,
   Uint32Array,
+  globalThis: { Atomics, SharedArrayBuffer },
 } = primordials;
 
 const EventEmitter = require('events');
@@ -78,6 +86,8 @@ let debug = require('internal/util/debuglog').debuglog('worker', (fn) => {
 
 let cwdCounter;
 
+const environmentData = new SafeMap();
+
 if (isMainThread) {
   cwdCounter = new Uint32Array(new SharedArrayBuffer(4));
   const originalChdir = process.chdir;
@@ -87,6 +97,24 @@ if (isMainThread) {
   };
 }
 
+function setEnvironmentData(key, value) {
+  if (value === undefined)
+    environmentData.delete(key);
+  else
+    environmentData.set(key, value);
+}
+
+function getEnvironmentData(key) {
+  return environmentData.get(key);
+}
+
+function assignEnvironmentData(data) {
+  if (data === undefined) return;
+  data.forEach((value, key) => {
+    environmentData.set(key, value);
+  });
+}
+
 class Worker extends EventEmitter {
   constructor(filename, options = {}) {
     super();
@@ -101,10 +129,10 @@ class Worker extends EventEmitter {
       if (!ArrayIsArray(options.argv)) {
         throw new ERR_INVALID_ARG_TYPE('options.argv', 'Array', options.argv);
       }
-      argv = options.argv.map(String);
+      argv = ArrayPrototypeMap(options.argv, String);
     }
 
-    let url;
+    let url, doEval;
     if (options.eval) {
       if (typeof filename !== 'string') {
         throw new ERR_INVALID_ARG_VALUE(
@@ -114,7 +142,13 @@ class Worker extends EventEmitter {
         );
       }
       url = null;
+      doEval = 'classic';
+    } else if (isURLInstance(filename) && filename.protocol === 'data:') {
+      url = null;
+      doEval = 'module';
+      filename = `import ${JSONStringify(`${filename}`)}`;
     } else {
+      doEval = false;
       if (isURLInstance(filename)) {
         url = filename;
         filename = fileURLToPath(filename);
@@ -124,7 +158,8 @@ class Worker extends EventEmitter {
           ['string', 'URL'],
           filename
         );
-      } else if (path.isAbsolute(filename) || /^\.\.?[\\/]/.test(filename)) {
+      } else if (path.isAbsolute(filename) ||
+                 RegExpPrototypeTest(/^\.\.?[\\/]/, filename)) {
         filename = path.resolve(filename);
         url = pathToFileURL(filename);
       } else {
@@ -194,7 +229,7 @@ class Worker extends EventEmitter {
     const transferList = [port2];
     // If transferList is provided.
     if (options.transferList)
-      transferList.push(...options.transferList);
+      ArrayPrototypePush(transferList, ...options.transferList);
 
     this[kPublicPort] = port1;
     for (const event of ['message', 'messageerror']) {
@@ -205,9 +240,10 @@ class Worker extends EventEmitter {
       argv,
       type: messageTypes.LOAD_SCRIPT,
       filename,
-      doEval: !!options.eval,
+      doEval,
       cwdCounter: cwdCounter || workerIo.sharedCwdCounter,
       workerData: options.workerData,
+      environmentData,
       publicPort: port2,
       manifestURL: getOptionValue('--experimental-policy') ?
         require('internal/process/policy').url :
@@ -221,10 +257,12 @@ class Worker extends EventEmitter {
     this[kLoopStartTime] = -1;
     this[kIsOnline] = false;
     this.performance = {
-      eventLoopUtilization: eventLoopUtilization.bind(this),
+      eventLoopUtilization: FunctionPrototypeBind(eventLoopUtilization, this),
     };
     // Actually start the new thread now that everything is in place.
     this[kHandle].startThread();
+
+    process.nextTick(() => process.emit('worker', this));
   }
 
   [kOnExit](code, customErr, customErrReason) {
@@ -393,7 +431,7 @@ function pipeWithoutWarning(source, dest) {
 const resourceLimitsArray = new Float64Array(kTotalResourceLimitCount);
 function parseResourceLimits(obj) {
   const ret = resourceLimitsArray;
-  ret.fill(-1);
+  TypedArrayPrototypeFill(ret, -1);
   if (typeof obj !== 'object' || obj === null) return ret;
 
   if (typeof obj.maxOldGenerationSizeMb === 'number')
@@ -468,6 +506,9 @@ module.exports = {
   SHARE_ENV,
   resourceLimits:
     !isMainThread ? makeResourceLimits(resourceLimitsRaw) : {},
+  setEnvironmentData,
+  getEnvironmentData,
+  assignEnvironmentData,
   threadId,
   Worker,
 };
diff --git a/lib/internal/worker/io.js b/lib/internal/worker/io.js
index 60dd8cd67d61863932fd3e5a40d185cd989cef12..492a6cc575e27fc1a636401d58b12b681b150399 100644
--- a/lib/internal/worker/io.js
+++ b/lib/internal/worker/io.js
@@ -1,12 +1,17 @@
 'use strict';
 
 const {
+  ArrayPrototypeForEach,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  FunctionPrototypeCall,
   ObjectAssign,
   ObjectCreate,
   ObjectDefineProperty,
   ObjectGetOwnPropertyDescriptors,
   ObjectGetPrototypeOf,
   ObjectSetPrototypeOf,
+  ReflectApply,
   Symbol,
 } = primordials;
 
@@ -24,20 +29,24 @@ const {
   stopMessagePort
 } = internalBinding('messaging');
 const {
-  threadId,
   getEnvMessagePort
 } = internalBinding('worker');
 
 const { Readable, Writable } = require('stream');
-const EventEmitter = require('events');
+const {
+  Event,
+  EventTarget,
+  NodeEventTarget,
+  defineEventHandler,
+  initNodeEventTarget,
+  kCreateEvent,
+  kNewListener,
+  kRemoveListener,
+} = require('internal/event_target');
 const { inspect } = require('internal/util/inspect');
-let debug = require('internal/util/debuglog').debuglog('worker', (fn) => {
-  debug = fn;
-});
 
 const kIncrementsPortRef = Symbol('kIncrementsPortRef');
 const kName = Symbol('kName');
-const kOnMessageListener = Symbol('kOnMessageListener');
 const kPort = Symbol('kPort');
 const kWaitingStreams = Symbol('kWaitingStreams');
 const kWritableCallbacks = Symbol('kWritableCallbacks');
@@ -54,7 +63,7 @@ const messageTypes = {
 };
 
 // We have to mess with the MessagePort prototype a bit, so that a) we can make
-// it inherit from EventEmitter, even though it is a C++ class, and b) we do
+// it inherit from NodeEventTarget, even though it is a C++ class, and b) we do
 // not provide methods that are not present in the Browser and not documented
 // on our side (e.g. hasRef).
 // Save a copy of the original set of methods as a shallow clone.
@@ -62,59 +71,60 @@ const MessagePortPrototype = ObjectCreate(
   ObjectGetPrototypeOf(MessagePort.prototype),
   ObjectGetOwnPropertyDescriptors(MessagePort.prototype));
 // Set up the new inheritance chain.
-ObjectSetPrototypeOf(MessagePort, EventEmitter);
-ObjectSetPrototypeOf(MessagePort.prototype, EventEmitter.prototype);
+ObjectSetPrototypeOf(MessagePort, NodeEventTarget);
+ObjectSetPrototypeOf(MessagePort.prototype, NodeEventTarget.prototype);
 // Copy methods that are inherited from HandleWrap, because
 // changing the prototype of MessagePort.prototype implicitly removed them.
 MessagePort.prototype.ref = MessagePortPrototype.ref;
 MessagePort.prototype.unref = MessagePortPrototype.unref;
 
-// A communication channel consisting of a handle (that wraps around an
-// uv_async_t) which can receive information from other threads and emits
-// .onmessage events, and a function used for sending data to a MessagePort
-// in some other thread.
-MessagePort.prototype[kOnMessageListener] = function onmessage(event) {
-  if (event.data && event.data.type !== messageTypes.STDIO_WANTS_MORE_DATA)
-    debug(`[${threadId}] received message`, event);
-  // Emit the deserialized object to userland.
-  this.emit('message', event.data);
-};
-
-// This is for compatibility with the Web's MessagePort API. It makes sense to
-// provide it as an `EventEmitter` in Node.js, but if somebody overrides
-// `onmessage`, we'll switch over to the Web API model.
-ObjectDefineProperty(MessagePort.prototype, 'onmessage', {
-  enumerable: true,
-  configurable: true,
-  get() {
-    return this[kOnMessageListener];
-  },
-  set(value) {
-    this[kOnMessageListener] = value;
-    if (typeof value === 'function') {
-      this.ref();
-      MessagePortPrototype.start.call(this);
-    } else {
-      this.unref();
-      stopMessagePort(this);
-    }
+class MessageEvent extends Event {
+  constructor(data, target, type) {
+    super(type);
+    this.data = data;
   }
-});
+}
+
+const originalCreateEvent = EventTarget.prototype[kCreateEvent];
+ObjectDefineProperty(
+  MessagePort.prototype,
+  kCreateEvent,
+  {
+    value: function(data, type) {
+      if (type !== 'message' && type !== 'messageerror') {
+        return ReflectApply(originalCreateEvent, this, arguments);
+      }
+      return new MessageEvent(data, this, type);
+    },
+    configurable: false,
+    writable: false,
+    enumerable: false,
+  });
 
 // This is called from inside the `MessagePort` constructor.
 function oninit() {
+  initNodeEventTarget(this);
   setupPortReferencing(this, this, 'message');
 }
 
+defineEventHandler(MessagePort.prototype, 'message');
+defineEventHandler(MessagePort.prototype, 'messageerror');
+
 ObjectDefineProperty(MessagePort.prototype, onInitSymbol, {
   enumerable: true,
   writable: false,
   value: oninit
 });
 
+class MessagePortCloseEvent extends Event {
+  constructor() {
+    super('close');
+  }
+}
+
 // This is called after the underlying `uv_async_t` has been closed.
 function onclose() {
-  this.emit('close');
+  this.dispatchEvent(new MessagePortCloseEvent());
 }
 
 ObjectDefineProperty(MessagePort.prototype, handleOnCloseSymbol, {
@@ -126,7 +136,7 @@ ObjectDefineProperty(MessagePort.prototype, handleOnCloseSymbol, {
 MessagePort.prototype.close = function(cb) {
   if (typeof cb === 'function')
     this.once('close', cb);
-  MessagePortPrototype.close.call(this);
+  FunctionPrototypeCall(MessagePortPrototype.close, this);
 };
 
 ObjectDefineProperty(MessagePort.prototype, inspect.custom, {
@@ -137,7 +147,7 @@ ObjectDefineProperty(MessagePort.prototype, inspect.custom, {
     try {
       // This may throw when `this` does not refer to a native object,
       // e.g. when accessing the prototype directly.
-      ref = MessagePortPrototype.hasRef.call(this);
+      ref = FunctionPrototypeCall(MessagePortPrototype.hasRef, this);
     } catch { return this; }
     return ObjectAssign(ObjectCreate(MessagePort.prototype),
                         ref === undefined ? {
@@ -156,18 +166,36 @@ function setupPortReferencing(port, eventEmitter, eventName) {
   // If there are none or all are removed, unref() the channel so the worker
   // can shutdown gracefully.
   port.unref();
-  eventEmitter.on('newListener', (name) => {
-    if (name === eventName && eventEmitter.listenerCount(eventName) === 0) {
+  eventEmitter.on('newListener', function(name) {
+    if (name === eventName) newListener(eventEmitter.listenerCount(name));
+  });
+  eventEmitter.on('removeListener', function(name) {
+    if (name === eventName) removeListener(eventEmitter.listenerCount(name));
+  });
+  const origNewListener = eventEmitter[kNewListener];
+  eventEmitter[kNewListener] = function(size, type, ...args) {
+    if (type === eventName) newListener(size - 1);
+    return ReflectApply(origNewListener, this, arguments);
+  };
+  const origRemoveListener = eventEmitter[kRemoveListener];
+  eventEmitter[kRemoveListener] = function(size, type, ...args) {
+    if (type === eventName) removeListener(size);
+    return ReflectApply(origRemoveListener, this, arguments);
+  };
+
+  function newListener(size) {
+    if (size === 0) {
       port.ref();
-      MessagePortPrototype.start.call(port);
+      FunctionPrototypeCall(MessagePortPrototype.start, port);
     }
-  });
-  eventEmitter.on('removeListener', (name) => {
-    if (name === eventName && eventEmitter.listenerCount(eventName) === 0) {
+  }
+
+  function removeListener(size) {
+    if (size === 0) {
       stopMessagePort(port);
       port.unref();
     }
-  });
+  }
 }
 
 
@@ -212,9 +240,10 @@ class WritableWorkerStdio extends Writable {
     this[kPort].postMessage({
       type: messageTypes.STDIO_PAYLOAD,
       stream: this[kName],
-      chunks: chunks.map(({ chunk, encoding }) => ({ chunk, encoding }))
+      chunks: ArrayPrototypeMap(chunks,
+                                ({ chunk, encoding }) => ({ chunk, encoding })),
     });
-    this[kWritableCallbacks].push(cb);
+    ArrayPrototypePush(this[kWritableCallbacks], cb);
     if (this[kPort][kWaitingStreams]++ === 0)
       this[kPort].ref();
   }
@@ -231,8 +260,7 @@ class WritableWorkerStdio extends Writable {
   [kStdioWantsMoreDataCallback]() {
     const cbs = this[kWritableCallbacks];
     this[kWritableCallbacks] = [];
-    for (const cb of cbs)
-      cb();
+    ArrayPrototypeForEach(cbs, (cb) => cb());
     if ((this[kPort][kWaitingStreams] -= cbs.length) === 0)
       this[kPort].unref();
   }
diff --git a/lib/internal/worker/js_transferable.js b/lib/internal/worker/js_transferable.js
index 707fd03f2f6d0e8cce9f3ecad269038c93eb47c3..ce95cf64e219874d88ed712a4effb5eaffe2fb75 100644
--- a/lib/internal/worker/js_transferable.js
+++ b/lib/internal/worker/js_transferable.js
@@ -1,5 +1,8 @@
 'use strict';
-const { Error } = primordials;
+const {
+  Error,
+  StringPrototypeSplit,
+} = primordials;
 const {
   messaging_deserialize_symbol,
   messaging_transfer_symbol,
@@ -16,7 +19,7 @@ function setup() {
   // from .postMessage() calls. The format of `deserializeInfo` is generally
   // 'module:Constructor', e.g. 'internal/fs/promises:FileHandle'.
   setDeserializerCreateObjectFunction((deserializeInfo) => {
-    const [ module, ctor ] = deserializeInfo.split(':');
+    const { 0: module, 1: ctor } = StringPrototypeSplit(deserializeInfo, ':');
     const Ctor = require(module)[ctor];
     if (typeof Ctor !== 'function' ||
         !(Ctor.prototype instanceof JSTransferable)) {
diff --git a/lib/net.js b/lib/net.js
index 3f5767fa6c547c587b97dee1f19134c6c446a830..cacce2a2ee99cbff4ef106bff22a78ef378f9fa8 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -23,10 +23,12 @@
 
 const {
   ArrayIsArray,
+  ArrayPrototypeIndexOf,
   Boolean,
   Error,
   Number,
   NumberIsNaN,
+  NumberParseInt,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
   Symbol,
@@ -113,6 +115,8 @@ const {
 // Lazy loaded to improve startup performance.
 let cluster;
 let dns;
+let BlockList;
+let SocketAddress;
 
 const { clearTimeout } = require('timers');
 const { kTimeout } = require('internal/timers');
@@ -122,7 +126,7 @@ const DEFAULT_IPV6_ADDR = '::';
 
 const isWindows = process.platform === 'win32';
 
-function noop() {}
+const noop = () => {};
 
 function getFlags(ipv6Only) {
   return ipv6Only === true ? TCPConstants.UV_TCP_IPV6ONLY : 0;
@@ -157,6 +161,16 @@ function isPipeName(s) {
   return typeof s === 'string' && toNumber(s) === false;
 }
 
+/**
+ * Creates a new TCP or IPC server
+ * @param {{
+ *   allowHalfOpen?: boolean;
+ *   pauseOnConnect?: boolean;
+ *   }} [options]
+ * @param {Function} [connectionListener]
+ * @returns {Server}
+ */
+
 function createServer(options, connectionListener) {
   return new Server(options, connectionListener);
 }
@@ -288,14 +302,13 @@ function Socket(options) {
   else
     options = { ...options };
 
-  options.readable = options.readable || false;
-  options.writable = options.writable || false;
   const { allowHalfOpen } = options;
 
   // Prevent the "no-half-open enforcer" from being inherited from `Duplex`.
   options.allowHalfOpen = true;
   // For backwards compat do not emit close on destroy.
   options.emitClose = false;
+  options.autoDestroy = false;
   // Handle strings directly.
   options.decodeStrings = false;
   stream.Duplex.call(this, options);
@@ -306,55 +319,54 @@ function Socket(options) {
   if (options.handle) {
     this._handle = options.handle; // private
     this[async_id_symbol] = getNewAsyncId(this._handle);
-  } else {
-    const onread = options.onread;
-    if (onread !== null && typeof onread === 'object' &&
-        (isUint8Array(onread.buffer) || typeof onread.buffer === 'function') &&
-        typeof onread.callback === 'function') {
-      if (typeof onread.buffer === 'function') {
-        this[kBuffer] = true;
-        this[kBufferGen] = onread.buffer;
-      } else {
-        this[kBuffer] = onread.buffer;
-      }
-      this[kBufferCb] = onread.callback;
-    }
-    if (options.fd !== undefined) {
-      const { fd } = options;
-      let err;
+  } else if (options.fd !== undefined) {
+    const { fd } = options;
+    let err;
 
-      // createHandle will throw ERR_INVALID_FD_TYPE if `fd` is not
-      // a valid `PIPE` or `TCP` descriptor
-      this._handle = createHandle(fd, false);
+    // createHandle will throw ERR_INVALID_FD_TYPE if `fd` is not
+    // a valid `PIPE` or `TCP` descriptor
+    this._handle = createHandle(fd, false);
 
-      err = this._handle.open(fd);
+    err = this._handle.open(fd);
 
-      // While difficult to fabricate, in some architectures
-      // `open` may return an error code for valid file descriptors
-      // which cannot be opened. This is difficult to test as most
-      // un-openable fds will throw on `createHandle`
+    // While difficult to fabricate, in some architectures
+    // `open` may return an error code for valid file descriptors
+    // which cannot be opened. This is difficult to test as most
+    // un-openable fds will throw on `createHandle`
+    if (err)
+      throw errnoException(err, 'open');
+
+    this[async_id_symbol] = this._handle.getAsyncId();
+
+    if ((fd === 1 || fd === 2) &&
+        (this._handle instanceof Pipe) && isWindows) {
+      // Make stdout and stderr blocking on Windows
+      err = this._handle.setBlocking(true);
       if (err)
-        throw errnoException(err, 'open');
-
-      this[async_id_symbol] = this._handle.getAsyncId();
-
-      if ((fd === 1 || fd === 2) &&
-          (this._handle instanceof Pipe) && isWindows) {
-        // Make stdout and stderr blocking on Windows
-        err = this._handle.setBlocking(true);
-        if (err)
-          throw errnoException(err, 'setBlocking');
-
-        this._writev = null;
-        this._write = makeSyncWrite(fd);
-        // makeSyncWrite adjusts this value like the original handle would, so
-        // we need to let it do that by turning it into a writable, own
-        // property.
-        ObjectDefineProperty(this._handle, 'bytesWritten', {
-          value: 0, writable: true
-        });
-      }
+        throw errnoException(err, 'setBlocking');
+
+      this._writev = null;
+      this._write = makeSyncWrite(fd);
+      // makeSyncWrite adjusts this value like the original handle would, so
+      // we need to let it do that by turning it into a writable, own
+      // property.
+      ObjectDefineProperty(this._handle, 'bytesWritten', {
+        value: 0, writable: true
+      });
+    }
+  }
+
+  const onread = options.onread;
+  if (onread !== null && typeof onread === 'object' &&
+      (isUint8Array(onread.buffer) || typeof onread.buffer === 'function') &&
+      typeof onread.callback === 'function') {
+    if (typeof onread.buffer === 'function') {
+      this[kBuffer] = true;
+      this[kBufferGen] = onread.buffer;
+    } else {
+      this[kBuffer] = onread.buffer;
     }
+    this[kBufferCb] = onread.callback;
   }
 
   // Shut down the socket when we're finished with it.
@@ -588,7 +600,8 @@ Socket.prototype._read = function(n) {
 
 
 Socket.prototype.end = function(data, encoding, callback) {
-  stream.Duplex.prototype.end.call(this, data, encoding, callback);
+  stream.Duplex.prototype.end.call(this,
+                                   data, encoding, callback);
   DTRACE_NET_STREAM_END(this);
   return this;
 };
@@ -655,8 +668,6 @@ Socket.prototype._destroy = function(exception, cb) {
 
   this.connecting = false;
 
-  this.readable = this.writable = false;
-
   for (let s = this; s !== null; s = s._parent) {
     clearTimeout(s[kTimeout]);
   }
@@ -1122,9 +1133,13 @@ function afterConnect(status, handle, req, readable, writable) {
   self._sockname = null;
 
   if (status === 0) {
-    self.readable = readable;
-    if (!self._writableState.ended)
-      self.writable = writable;
+    if (self.readable && !readable) {
+      self.push(null);
+      self.read();
+    }
+    if (self.writable && !writable) {
+      self.end();
+    }
     self._unrefTimer();
 
     self.emit('connect');
@@ -1231,7 +1246,7 @@ function createServerHandle(address, port, addressType, fd, flags) {
   } else if (port === -1 && addressType === -1) {
     handle = new Pipe(PipeConstants.SERVER);
     if (isWindows) {
-      const instances = parseInt(process.env.NODE_PENDING_PIPE_INSTANCES);
+      const instances = NumberParseInt(process.env.NODE_PENDING_PIPE_INSTANCES);
       if (!NumberIsNaN(instances)) {
         handle.setPendingInstances(instances);
       }
@@ -1558,6 +1573,11 @@ function onconnection(err, clientHandle) {
   self.emit('connection', socket);
 }
 
+/**
+ * Gets the number of concurrent connections on the server
+ * @param {Function} cb
+ * @returns {Server}
+ */
 
 Server.prototype.getConnections = function(cb) {
   const self = this;
@@ -1687,7 +1707,7 @@ Server.prototype._setupWorker = function(socketList) {
   this._usingWorkers = true;
   this._workers.push(socketList);
   socketList.once('exit', (socketList) => {
-    const index = this._workers.indexOf(socketList);
+    const index = ArrayPrototypeIndexOf(this._workers, socketList);
     this._workers.splice(index, 1);
   });
 };
@@ -1752,6 +1772,15 @@ module.exports = {
   _createServerHandle: createServerHandle,
   _normalizeArgs: normalizeArgs,
   _setSimultaneousAccepts,
+  get BlockList() {
+    BlockList = BlockList ?? require('internal/blocklist').BlockList;
+    return BlockList;
+  },
+  get SocketAddress() {
+    SocketAddress =
+      SocketAddress ?? require('internal/socketaddress').SocketAddress;
+    return SocketAddress;
+  },
   connect,
   createConnection: connect,
   createServer,
diff --git a/lib/os.js b/lib/os.js
index f533c3f18f13fde1f1c7fd4ad044777a6775c0c5..f0f0fdb15f61c018ddee6e3db34fbd957d9f2477 100644
--- a/lib/os.js
+++ b/lib/os.js
@@ -22,13 +22,18 @@
 'use strict';
 
 const {
+  ArrayPrototypePush,
+  Float64Array,
+  NumberParseInt,
   ObjectDefineProperties,
+  StringPrototypeEndsWith,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
   SymbolToPrimitive,
 } = primordials;
 
 const { safeGetenv } = internalBinding('credentials');
 const constants = internalBinding('constants').os;
-const { deprecate } = require('internal/util');
 const isWindows = process.platform === 'win32';
 
 const {
@@ -46,8 +51,8 @@ const {
   getHostname: _getHostname,
   getInterfaceAddresses: _getInterfaceAddresses,
   getLoadAvg,
-  getOSInformation: _getOSInformation,
   getPriority: _getPriority,
+  getOSInformation: _getOSInformation,
   getTotalMem,
   getUserInfo,
   getUptime,
@@ -66,47 +71,72 @@ function getCheckedFunction(fn) {
   });
 }
 
-const [
-  type,
-  version,
-  release
-] = _getOSInformation();
+const {
+  0: type,
+  1: version,
+  2: release,
+} = _getOSInformation();
 
 const getHomeDirectory = getCheckedFunction(_getHomeDirectory);
 const getHostname = getCheckedFunction(_getHostname);
 const getInterfaceAddresses = getCheckedFunction(_getInterfaceAddresses);
+/**
+ * @returns {string}
+ */
 const getOSRelease = () => release;
+/**
+ * @returns {string}
+ */
 const getOSType = () => type;
+/**
+ * @returns {string}
+ */
 const getOSVersion = () => version;
 
 getFreeMem[SymbolToPrimitive] = () => getFreeMem();
 getHostname[SymbolToPrimitive] = () => getHostname();
-getHomeDirectory[SymbolToPrimitive] = () => getHomeDirectory();
-getOSRelease[SymbolToPrimitive] = () => getOSRelease();
-getOSType[SymbolToPrimitive] = () => getOSType();
 getOSVersion[SymbolToPrimitive] = () => getOSVersion();
+getOSType[SymbolToPrimitive] = () => getOSType();
+getOSRelease[SymbolToPrimitive] = () => getOSRelease();
+getHomeDirectory[SymbolToPrimitive] = () => getHomeDirectory();
 getTotalMem[SymbolToPrimitive] = () => getTotalMem();
 getUptime[SymbolToPrimitive] = () => getUptime();
 
 const kEndianness = isBigEndian ? 'BE' : 'LE';
 
-const tmpDirDeprecationMsg =
-  'os.tmpDir() is deprecated. Use os.tmpdir() instead.';
-
 const avgValues = new Float64Array(3);
 
+/**
+ * @returns {[number, number, number]}
+ */
 function loadavg() {
   getLoadAvg(avgValues);
   return [avgValues[0], avgValues[1], avgValues[2]];
 }
 
+/**
+ * Returns an array of objects containing information about each
+ * logical CPU core.
+ *
+ * @returns {Array<{
+ *  model: string
+ *  speed: number
+ *  times: {
+ *    user: number
+ *    nice: number
+ *    sys: number
+ *    idle: number
+ *    irq: number
+ *  }
+ * }>}
+ */
 function cpus() {
   // [] is a bugfix for a regression introduced in 51cea61
   const data = getCPUs() || [];
   const result = [];
   let i = 0;
   while (i < data.length) {
-    result.push({
+    ArrayPrototypePush(result, {
       model: data[i++],
       speed: data[i++],
       times: {
@@ -121,37 +151,50 @@ function cpus() {
   return result;
 }
 
+/**
+ * @returns {string}
+ */
 function arch() {
   return process.arch;
 }
 arch[SymbolToPrimitive] = () => process.arch;
 
+/**
+ * @returns {string}
+ */
 function platform() {
   return process.platform;
 }
 platform[SymbolToPrimitive] = () => process.platform;
 
+/**
+ * @returns {string}
+ */
 function tmpdir() {
   var path;
   if (isWindows) {
     path = process.env.TEMP ||
            process.env.TMP ||
            (process.env.SystemRoot || process.env.windir) + '\\temp';
-    if (path.length > 1 && path.endsWith('\\') && !path.endsWith(':\\'))
-      path = path.slice(0, -1);
+    if (path.length > 1 && StringPrototypeEndsWith(path, '\\') &&
+        !StringPrototypeEndsWith(path, ':\\'))
+      path = StringPrototypeSlice(path, 0, -1);
   } else {
     path = safeGetenv('TMPDIR') ||
            safeGetenv('TMP') ||
            safeGetenv('TEMP') ||
            '/tmp';
-    if (path.length > 1 && path.endsWith('/'))
-      path = path.slice(0, -1);
+    if (path.length > 1 && StringPrototypeEndsWith(path, '/'))
+      path = StringPrototypeSlice(path, 0, -1);
   }
 
   return path;
 }
 tmpdir[SymbolToPrimitive] = () => tmpdir();
 
+/**
+ * @returns {'BE' | 'LE'}
+ */
 function endianness() {
   return kEndianness;
 }
@@ -179,10 +222,10 @@ function getCIDR(address, netmask, family) {
     groupLength = 16;
   }
 
-  const parts = netmask.split(split);
+  const parts = StringPrototypeSplit(netmask, split);
   for (var i = 0; i < parts.length; i++) {
     if (parts[i] !== '') {
-      const binary = parseInt(parts[i], range);
+      const binary = NumberParseInt(parts[i], range);
       const tmp = countBinaryOnes(binary);
       ones += tmp;
       if (hasZeros) {
@@ -201,6 +244,17 @@ function getCIDR(address, netmask, family) {
   return `${address}/${ones}`;
 }
 
+/**
+ * @returns {Record<string, Array<{
+ *  address: string
+ *  netmask: string
+ *  family: 'IPv4' | 'IPv6'
+ *  mac: string
+ *  internal: boolean
+ *  scopeid: number
+ *  cidr: string | null
+ * }>>}
+ */
 function networkInterfaces() {
   const data = getInterfaceAddresses();
   const result = {};
@@ -223,7 +277,7 @@ function networkInterfaces() {
 
     const existing = result[name];
     if (existing !== undefined)
-      existing.push(entry);
+      ArrayPrototypePush(existing, entry);
     else
       result[name] = [entry];
   }
@@ -231,6 +285,11 @@ function networkInterfaces() {
   return result;
 }
 
+/**
+ * @param {number} [pid=0]
+ * @param {number} priority
+ * @returns {void}
+ */
 function setPriority(pid, priority) {
   if (priority === undefined) {
     priority = pid;
@@ -246,6 +305,10 @@ function setPriority(pid, priority) {
     throw new ERR_SYSTEM_ERROR(ctx);
 }
 
+/**
+ * @param {number} [pid=0]
+ * @returns {number}
+ */
 function getPriority(pid) {
   if (pid === undefined)
     pid = 0;
@@ -261,6 +324,18 @@ function getPriority(pid) {
   return priority;
 }
 
+/**
+ * @param {{ encoding?: string }} [options=utf8] If `encoding` is set to
+ * `'buffer'`, the `username`, `shell`, and `homedir` values will
+ * be `Buffer` instances.
+ * @returns {{
+ *   uid: number
+ *   gid: number
+ *   username: string
+ *   homedir: string
+ *   shell: string | null
+ * }}
+ */
 function userInfo(options) {
   if (typeof options !== 'object')
     options = null;
@@ -290,12 +365,9 @@ module.exports = {
   tmpdir,
   totalmem: getTotalMem,
   type: getOSType,
-  version: getOSVersion,
   userInfo,
   uptime: getUptime,
-
-  // Deprecated APIs
-  tmpDir: deprecate(tmpdir, tmpDirDeprecationMsg, 'DEP0022')
+  version: getOSVersion
 };
 
 ObjectDefineProperties(module.exports, {
@@ -310,5 +382,12 @@ ObjectDefineProperties(module.exports, {
     enumerable: true,
     writable: false,
     value: isWindows ? '\r\n' : '\n'
+  },
+
+  devNull: {
+    configurable: true,
+    enumerable: true,
+    writable: false,
+    value: isWindows ? '\\\\.\\nul' : '/dev/null'
   }
 });
diff --git a/lib/path.js b/lib/path.js
index 7532b795bf63f7190bb46946d2db69459bce08a7..e9f3adec9ef3943481429e91f337176ce1533605 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -21,6 +21,13 @@
 
 'use strict';
 
+const {
+  FunctionPrototypeBind,
+  StringPrototypeCharCodeAt,
+  StringPrototypeLastIndexOf,
+  StringPrototypeSlice,
+  StringPrototypeToLowerCase,
+} = primordials;
 const { ERR_INVALID_ARG_TYPE } = require('internal/errors').codes;
 const {
   CHAR_UPPERCASE_A,
@@ -57,7 +64,7 @@ function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
   let code = 0;
   for (let i = 0; i <= path.length; ++i) {
     if (i < path.length)
-      code = path.charCodeAt(i);
+      code = StringPrototypeCharCodeAt(path, i);
     else if (isPathSeparator(code))
       break;
     else
@@ -68,16 +75,17 @@ function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
         // NOOP
       } else if (dots === 2) {
         if (res.length < 2 || lastSegmentLength !== 2 ||
-            res.charCodeAt(res.length - 1) !== CHAR_DOT ||
-            res.charCodeAt(res.length - 2) !== CHAR_DOT) {
+            StringPrototypeCharCodeAt(res, res.length - 1) !== CHAR_DOT ||
+            StringPrototypeCharCodeAt(res, res.length - 2) !== CHAR_DOT) {
           if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf(separator);
+            const lastSlashIndex = StringPrototypeLastIndexOf(res, separator);
             if (lastSlashIndex === -1) {
               res = '';
               lastSegmentLength = 0;
             } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+              res = StringPrototypeSlice(res, 0, lastSlashIndex);
+              lastSegmentLength =
+                res.length - 1 - StringPrototypeLastIndexOf(res, separator);
             }
             lastSlash = i;
             dots = 0;
@@ -96,9 +104,9 @@ function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
         }
       } else {
         if (res.length > 0)
-          res += `${separator}${path.slice(lastSlash + 1, i)}`;
+          res += `${separator}${StringPrototypeSlice(path, lastSlash + 1, i)}`;
         else
-          res = path.slice(lastSlash + 1, i);
+          res = StringPrototypeSlice(path, lastSlash + 1, i);
         lastSegmentLength = i - lastSlash - 1;
       }
       lastSlash = i;
@@ -112,6 +120,17 @@ function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
   return res;
 }
 
+/**
+ * @param {string} sep
+ * @param {{
+ *  dir?: string;
+ *  root?: string;
+ *  base?: string;
+ *  name?: string;
+ *  ext?: string;
+ *  }} pathObject
+ * @returns {string}
+ */
 function _format(sep, pathObject) {
   if (pathObject === null || typeof pathObject !== 'object') {
     throw new ERR_INVALID_ARG_TYPE('pathObject', 'Object', pathObject);
@@ -126,7 +145,11 @@ function _format(sep, pathObject) {
 }
 
 const win32 = {
-  // path.resolve([from ...], to)
+  /**
+   * path.resolve([from ...], to)
+   * @param {...string} args
+   * @returns {string}
+   */
   resolve(...args) {
     let resolvedDevice = '';
     let resolvedTail = '';
@@ -155,8 +178,9 @@ const win32 = {
         // Verify that a cwd was found and that it actually points
         // to our drive. If not, default to the drive's root.
         if (path === undefined ||
-            (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() &&
-            path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) {
+            (StringPrototypeToLowerCase(StringPrototypeSlice(path, 0, 2)) !==
+            StringPrototypeToLowerCase(resolvedDevice) &&
+            StringPrototypeCharCodeAt(path, 2) === CHAR_BACKWARD_SLASH)) {
           path = `${resolvedDevice}\\`;
         }
       }
@@ -165,7 +189,7 @@ const win32 = {
       let rootEnd = 0;
       let device = '';
       let isAbsolute = false;
-      const code = path.charCodeAt(0);
+      const code = StringPrototypeCharCodeAt(path, 0);
 
       // Try to match a root
       if (len === 1) {
@@ -181,32 +205,36 @@ const win32 = {
         // absolute path of some kind (UNC or otherwise)
         isAbsolute = true;
 
-        if (isPathSeparator(path.charCodeAt(1))) {
+        if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
           // Matched double path separator at beginning
           let j = 2;
           let last = j;
           // Match 1 or more non-path separators
-          while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+          while (j < len &&
+                 !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
             j++;
           }
           if (j < len && j !== last) {
-            const firstPart = path.slice(last, j);
+            const firstPart = StringPrototypeSlice(path, last, j);
             // Matched!
             last = j;
             // Match 1 or more path separators
-            while (j < len && isPathSeparator(path.charCodeAt(j))) {
+            while (j < len &&
+                   isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
               j++;
             }
             if (j < len && j !== last) {
               // Matched!
               last = j;
               // Match 1 or more non-path separators
-              while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+              while (j < len &&
+                     !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
                 j++;
               }
               if (j === len || j !== last) {
                 // We matched a UNC root
-                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                device =
+                  `\\\\${firstPart}\\${StringPrototypeSlice(path, last, j)}`;
                 rootEnd = j;
               }
             }
@@ -215,11 +243,11 @@ const win32 = {
           rootEnd = 1;
         }
       } else if (isWindowsDeviceRoot(code) &&
-                  path.charCodeAt(1) === CHAR_COLON) {
+                  StringPrototypeCharCodeAt(path, 1) === CHAR_COLON) {
         // Possible device root
-        device = path.slice(0, 2);
+        device = StringPrototypeSlice(path, 0, 2);
         rootEnd = 2;
-        if (len > 2 && isPathSeparator(path.charCodeAt(2))) {
+        if (len > 2 && isPathSeparator(StringPrototypeCharCodeAt(path, 2))) {
           // Treat separator following drive name as an absolute path
           // indicator
           isAbsolute = true;
@@ -229,7 +257,8 @@ const win32 = {
 
       if (device.length > 0) {
         if (resolvedDevice.length > 0) {
-          if (device.toLowerCase() !== resolvedDevice.toLowerCase())
+          if (StringPrototypeToLowerCase(device) !==
+              StringPrototypeToLowerCase(resolvedDevice))
             // This path points to another device so it is not applicable
             continue;
         } else {
@@ -241,7 +270,8 @@ const win32 = {
         if (resolvedDevice.length > 0)
           break;
       } else {
-        resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
+        resolvedTail =
+          `${StringPrototypeSlice(path, rootEnd)}\\${resolvedTail}`;
         resolvedAbsolute = isAbsolute;
         if (isAbsolute && resolvedDevice.length > 0) {
           break;
@@ -262,6 +292,10 @@ const win32 = {
       `${resolvedDevice}${resolvedTail}` || '.';
   },
 
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
   normalize(path) {
     validateString(path, 'path');
     const len = path.length;
@@ -270,7 +304,7 @@ const win32 = {
     let rootEnd = 0;
     let device;
     let isAbsolute = false;
-    const code = path.charCodeAt(0);
+    const code = StringPrototypeCharCodeAt(path, 0);
 
     // Try to match a root
     if (len === 1) {
@@ -285,38 +319,42 @@ const win32 = {
       // path of some kind (UNC or otherwise)
       isAbsolute = true;
 
-      if (isPathSeparator(path.charCodeAt(1))) {
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
         // Matched double path separator at beginning
         let j = 2;
         let last = j;
         // Match 1 or more non-path separators
-        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+        while (j < len &&
+               !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
           j++;
         }
         if (j < len && j !== last) {
-          const firstPart = path.slice(last, j);
+          const firstPart = StringPrototypeSlice(path, last, j);
           // Matched!
           last = j;
           // Match 1 or more path separators
-          while (j < len && isPathSeparator(path.charCodeAt(j))) {
+          while (j < len &&
+                 isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
             j++;
           }
           if (j < len && j !== last) {
             // Matched!
             last = j;
             // Match 1 or more non-path separators
-            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+            while (j < len &&
+                   !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
               j++;
             }
             if (j === len) {
               // We matched a UNC root only
               // Return the normalized version of the UNC root since there
               // is nothing left to process
-              return `\\\\${firstPart}\\${path.slice(last)}\\`;
+              return `\\\\${firstPart}\\${StringPrototypeSlice(path, last)}\\`;
             }
             if (j !== last) {
               // We matched a UNC root with leftovers
-              device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+              device =
+                `\\\\${firstPart}\\${StringPrototypeSlice(path, last, j)}`;
               rootEnd = j;
             }
           }
@@ -324,11 +362,12 @@ const win32 = {
       } else {
         rootEnd = 1;
       }
-    } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
+    } else if (isWindowsDeviceRoot(code) &&
+               StringPrototypeCharCodeAt(path, 1) === CHAR_COLON) {
       // Possible device root
-      device = path.slice(0, 2);
+      device = StringPrototypeSlice(path, 0, 2);
       rootEnd = 2;
-      if (len > 2 && isPathSeparator(path.charCodeAt(2))) {
+      if (len > 2 && isPathSeparator(StringPrototypeCharCodeAt(path, 2))) {
         // Treat separator following drive name as an absolute path
         // indicator
         isAbsolute = true;
@@ -337,11 +376,13 @@ const win32 = {
     }
 
     let tail = rootEnd < len ?
-      normalizeString(path.slice(rootEnd), !isAbsolute, '\\', isPathSeparator) :
+      normalizeString(StringPrototypeSlice(path, rootEnd),
+                      !isAbsolute, '\\', isPathSeparator) :
       '';
     if (tail.length === 0 && !isAbsolute)
       tail = '.';
-    if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1)))
+    if (tail.length > 0 &&
+        isPathSeparator(StringPrototypeCharCodeAt(path, len - 1)))
       tail += '\\';
     if (device === undefined) {
       return isAbsolute ? `\\${tail}` : tail;
@@ -349,21 +390,29 @@ const win32 = {
     return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`;
   },
 
+  /**
+   * @param {string} path
+   * @returns {boolean}
+   */
   isAbsolute(path) {
     validateString(path, 'path');
     const len = path.length;
     if (len === 0)
       return false;
 
-    const code = path.charCodeAt(0);
+    const code = StringPrototypeCharCodeAt(path, 0);
     return isPathSeparator(code) ||
       // Possible device root
       (len > 2 &&
       isWindowsDeviceRoot(code) &&
-      path.charCodeAt(1) === CHAR_COLON &&
-      isPathSeparator(path.charCodeAt(2)));
+      StringPrototypeCharCodeAt(path, 1) === CHAR_COLON &&
+      isPathSeparator(StringPrototypeCharCodeAt(path, 2)));
   },
 
+  /**
+   * @param {...string} args
+   * @returns {string}
+   */
   join(...args) {
     if (args.length === 0)
       return '.';
@@ -399,13 +448,14 @@ const win32 = {
     //   path.join('//server', 'share') -> '\\\\server\\share\\')
     let needsReplace = true;
     let slashCount = 0;
-    if (isPathSeparator(firstPart.charCodeAt(0))) {
+    if (isPathSeparator(StringPrototypeCharCodeAt(firstPart, 0))) {
       ++slashCount;
       const firstLen = firstPart.length;
-      if (firstLen > 1 && isPathSeparator(firstPart.charCodeAt(1))) {
+      if (firstLen > 1 &&
+          isPathSeparator(StringPrototypeCharCodeAt(firstPart, 1))) {
         ++slashCount;
         if (firstLen > 2) {
-          if (isPathSeparator(firstPart.charCodeAt(2)))
+          if (isPathSeparator(StringPrototypeCharCodeAt(firstPart, 2)))
             ++slashCount;
           else {
             // We matched a UNC path in the first part
@@ -417,22 +467,27 @@ const win32 = {
     if (needsReplace) {
       // Find any more consecutive slashes we need to replace
       while (slashCount < joined.length &&
-             isPathSeparator(joined.charCodeAt(slashCount))) {
+             isPathSeparator(StringPrototypeCharCodeAt(joined, slashCount))) {
         slashCount++;
       }
 
       // Replace the slashes if needed
       if (slashCount >= 2)
-        joined = `\\${joined.slice(slashCount)}`;
+        joined = `\\${StringPrototypeSlice(joined, slashCount)}`;
     }
 
     return win32.normalize(joined);
   },
 
-  // It will solve the relative path from `from` to `to`, for instance:
-  //  from = 'C:\\orandea\\test\\aaa'
-  //  to = 'C:\\orandea\\impl\\bbb'
-  // The output of the function should be: '..\\..\\impl\\bbb'
+  /**
+   * It will solve the relative path from `from` to `to`, for instancee
+   * from = 'C:\\orandea\\test\\aaa'
+   * to = 'C:\\orandea\\impl\\bbb'
+   * The output of the function should be: '..\\..\\impl\\bbb'
+   * @param {string} from
+   * @param {string} to
+   * @returns {string}
+   */
   relative(from, to) {
     validateString(from, 'from');
     validateString(to, 'to');
@@ -446,8 +501,8 @@ const win32 = {
     if (fromOrig === toOrig)
       return '';
 
-    from = fromOrig.toLowerCase();
-    to = toOrig.toLowerCase();
+    from = StringPrototypeToLowerCase(fromOrig);
+    to = StringPrototypeToLowerCase(toOrig);
 
     if (from === to)
       return '';
@@ -455,13 +510,15 @@ const win32 = {
     // Trim any leading backslashes
     let fromStart = 0;
     while (fromStart < from.length &&
-           from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {
+           StringPrototypeCharCodeAt(from, fromStart) === CHAR_BACKWARD_SLASH) {
       fromStart++;
     }
     // Trim trailing backslashes (applicable to UNC paths only)
     let fromEnd = from.length;
-    while (fromEnd - 1 > fromStart &&
-           from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {
+    while (
+      fromEnd - 1 > fromStart &&
+      StringPrototypeCharCodeAt(from, fromEnd - 1) === CHAR_BACKWARD_SLASH
+    ) {
       fromEnd--;
     }
     const fromLen = fromEnd - fromStart;
@@ -469,13 +526,13 @@ const win32 = {
     // Trim any leading backslashes
     let toStart = 0;
     while (toStart < to.length &&
-           to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
+           StringPrototypeCharCodeAt(to, toStart) === CHAR_BACKWARD_SLASH) {
       toStart++;
     }
     // Trim trailing backslashes (applicable to UNC paths only)
     let toEnd = to.length;
     while (toEnd - 1 > toStart &&
-           to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {
+           StringPrototypeCharCodeAt(to, toEnd - 1) === CHAR_BACKWARD_SLASH) {
       toEnd--;
     }
     const toLen = toEnd - toStart;
@@ -485,8 +542,8 @@ const win32 = {
     let lastCommonSep = -1;
     let i = 0;
     for (; i < length; i++) {
-      const fromCode = from.charCodeAt(fromStart + i);
-      if (fromCode !== to.charCodeAt(toStart + i))
+      const fromCode = StringPrototypeCharCodeAt(from, fromStart + i);
+      if (fromCode !== StringPrototypeCharCodeAt(to, toStart + i))
         break;
       else if (fromCode === CHAR_BACKWARD_SLASH)
         lastCommonSep = i;
@@ -499,19 +556,21 @@ const win32 = {
         return toOrig;
     } else {
       if (toLen > length) {
-        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
+        if (StringPrototypeCharCodeAt(to, toStart + i) ===
+            CHAR_BACKWARD_SLASH) {
           // We get here if `from` is the exact base path for `to`.
           // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz'
-          return toOrig.slice(toStart + i + 1);
+          return StringPrototypeSlice(toOrig, toStart + i + 1);
         }
         if (i === 2) {
           // We get here if `from` is the device root.
           // For example: from='C:\\'; to='C:\\foo'
-          return toOrig.slice(toStart + i);
+          return StringPrototypeSlice(toOrig, toStart + i);
         }
       }
       if (fromLen > length) {
-        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
+        if (StringPrototypeCharCodeAt(from, fromStart + i) ===
+            CHAR_BACKWARD_SLASH) {
           // We get here if `to` is the exact base path for `from`.
           // For example: from='C:\\foo\\bar'; to='C:\\foo'
           lastCommonSep = i;
@@ -529,7 +588,8 @@ const win32 = {
     // Generate the relative path based on the path difference between `to` and
     // `from`
     for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-      if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
+      if (i === fromEnd ||
+          StringPrototypeCharCodeAt(from, i) === CHAR_BACKWARD_SLASH) {
         out += out.length === 0 ? '..' : '\\..';
       }
     }
@@ -539,39 +599,37 @@ const win32 = {
     // Lastly, append the rest of the destination (`to`) path that comes after
     // the common path parts
     if (out.length > 0)
-      return `${out}${toOrig.slice(toStart, toEnd)}`;
+      return `${out}${StringPrototypeSlice(toOrig, toStart, toEnd)}`;
 
-    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH)
+    if (StringPrototypeCharCodeAt(toOrig, toStart) === CHAR_BACKWARD_SLASH)
       ++toStart;
-    return toOrig.slice(toStart, toEnd);
+    return StringPrototypeSlice(toOrig, toStart, toEnd);
   },
 
   toNamespacedPath(path) {
     // Note: this will *probably* throw somewhere.
-    if (typeof path !== 'string')
+    if (typeof path !== 'string' || path.length === 0)
       return path;
 
-    if (path.length === 0) {
-      return '';
-    }
-
     const resolvedPath = win32.resolve(path);
 
     if (resolvedPath.length <= 2)
       return path;
 
-    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
+    if (StringPrototypeCharCodeAt(resolvedPath, 0) === CHAR_BACKWARD_SLASH) {
       // Possible UNC root
-      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
-        const code = resolvedPath.charCodeAt(2);
+      if (StringPrototypeCharCodeAt(resolvedPath, 1) === CHAR_BACKWARD_SLASH) {
+        const code = StringPrototypeCharCodeAt(resolvedPath, 2);
         if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
           // Matched non-long UNC root, convert the path to a long UNC path
-          return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+          return `\\\\?\\UNC\\${StringPrototypeSlice(resolvedPath, 2)}`;
         }
       }
-    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) &&
-               resolvedPath.charCodeAt(1) === CHAR_COLON &&
-               resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
+    } else if (
+      isWindowsDeviceRoot(StringPrototypeCharCodeAt(resolvedPath, 0)) &&
+      StringPrototypeCharCodeAt(resolvedPath, 1) === CHAR_COLON &&
+      StringPrototypeCharCodeAt(resolvedPath, 2) === CHAR_BACKWARD_SLASH
+    ) {
       // Matched device root, convert the path to a long UNC path
       return `\\\\?\\${resolvedPath}`;
     }
@@ -579,6 +637,10 @@ const win32 = {
     return path;
   },
 
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
   dirname(path) {
     validateString(path, 'path');
     const len = path.length;
@@ -586,7 +648,7 @@ const win32 = {
       return '.';
     let rootEnd = -1;
     let offset = 0;
-    const code = path.charCodeAt(0);
+    const code = StringPrototypeCharCodeAt(path, 0);
 
     if (len === 1) {
       // `path` contains just a path separator, exit early to avoid
@@ -600,26 +662,29 @@ const win32 = {
 
       rootEnd = offset = 1;
 
-      if (isPathSeparator(path.charCodeAt(1))) {
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
         // Matched double path separator at beginning
         let j = 2;
         let last = j;
         // Match 1 or more non-path separators
-        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+        while (j < len &&
+               !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
           j++;
         }
         if (j < len && j !== last) {
           // Matched!
           last = j;
           // Match 1 or more path separators
-          while (j < len && isPathSeparator(path.charCodeAt(j))) {
+          while (j < len &&
+                 isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
             j++;
           }
           if (j < len && j !== last) {
             // Matched!
             last = j;
             // Match 1 or more non-path separators
-            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+            while (j < len &&
+                   !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
               j++;
             }
             if (j === len) {
@@ -637,15 +702,17 @@ const win32 = {
         }
       }
     // Possible device root
-    } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
-      rootEnd = len > 2 && isPathSeparator(path.charCodeAt(2)) ? 3 : 2;
+    } else if (isWindowsDeviceRoot(code) &&
+               StringPrototypeCharCodeAt(path, 1) === CHAR_COLON) {
+      rootEnd =
+        len > 2 && isPathSeparator(StringPrototypeCharCodeAt(path, 2)) ? 3 : 2;
       offset = rootEnd;
     }
 
     let end = -1;
     let matchedSlash = true;
     for (let i = len - 1; i >= offset; --i) {
-      if (isPathSeparator(path.charCodeAt(i))) {
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, i))) {
         if (!matchedSlash) {
           end = i;
           break;
@@ -662,9 +729,14 @@ const win32 = {
 
       end = rootEnd;
     }
-    return path.slice(0, end);
+    return StringPrototypeSlice(path, 0, end);
   },
 
+  /**
+   * @param {string} path
+   * @param {string} [ext]
+   * @returns {string}
+   */
   basename(path, ext) {
     if (ext !== undefined)
       validateString(ext, 'ext');
@@ -677,8 +749,8 @@ const win32 = {
     // path separator as an extra separator at the end of the path that can be
     // disregarded
     if (path.length >= 2 &&
-        isWindowsDeviceRoot(path.charCodeAt(0)) &&
-        path.charCodeAt(1) === CHAR_COLON) {
+        isWindowsDeviceRoot(StringPrototypeCharCodeAt(path, 0)) &&
+        StringPrototypeCharCodeAt(path, 1) === CHAR_COLON) {
       start = 2;
     }
 
@@ -688,7 +760,7 @@ const win32 = {
       let extIdx = ext.length - 1;
       let firstNonSlashEnd = -1;
       for (let i = path.length - 1; i >= start; --i) {
-        const code = path.charCodeAt(i);
+        const code = StringPrototypeCharCodeAt(path, i);
         if (isPathSeparator(code)) {
           // If we reached a path separator that was not part of a set of path
           // separators at the end of the string, stop now
@@ -705,7 +777,7 @@ const win32 = {
           }
           if (extIdx >= 0) {
             // Try to match the explicit extension
-            if (code === ext.charCodeAt(extIdx)) {
+            if (code === StringPrototypeCharCodeAt(ext, extIdx)) {
               if (--extIdx === -1) {
                 // We matched the extension, so mark this as the end of our path
                 // component
@@ -725,10 +797,10 @@ const win32 = {
         end = firstNonSlashEnd;
       else if (end === -1)
         end = path.length;
-      return path.slice(start, end);
+      return StringPrototypeSlice(path, start, end);
     }
     for (let i = path.length - 1; i >= start; --i) {
-      if (isPathSeparator(path.charCodeAt(i))) {
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, i))) {
         // If we reached a path separator that was not part of a set of path
         // separators at the end of the string, stop now
         if (!matchedSlash) {
@@ -745,9 +817,13 @@ const win32 = {
 
     if (end === -1)
       return '';
-    return path.slice(start, end);
+    return StringPrototypeSlice(path, start, end);
   },
 
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
   extname(path) {
     validateString(path, 'path');
     let start = 0;
@@ -764,13 +840,13 @@ const win32 = {
     // disregarded
 
     if (path.length >= 2 &&
-        path.charCodeAt(1) === CHAR_COLON &&
-        isWindowsDeviceRoot(path.charCodeAt(0))) {
+        StringPrototypeCharCodeAt(path, 1) === CHAR_COLON &&
+        isWindowsDeviceRoot(StringPrototypeCharCodeAt(path, 0))) {
       start = startPart = 2;
     }
 
     for (let i = path.length - 1; i >= start; --i) {
-      const code = path.charCodeAt(i);
+      const code = StringPrototypeCharCodeAt(path, i);
       if (isPathSeparator(code)) {
         // If we reached a path separator that was not part of a set of path
         // separators at the end of the string, stop now
@@ -809,11 +885,21 @@ const win32 = {
          startDot === startPart + 1)) {
       return '';
     }
-    return path.slice(startDot, end);
+    return StringPrototypeSlice(path, startDot, end);
   },
 
-  format: _format.bind(null, '\\'),
-
+  format: FunctionPrototypeBind(_format, null, '\\'),
+
+  /**
+   * @param {string} path
+   * @returns {{
+   *  dir: string;
+   *  root: string;
+   *  base: string;
+   *  name: string;
+   *  ext: string;
+   *  }}
+   */
   parse(path) {
     validateString(path, 'path');
 
@@ -823,7 +909,7 @@ const win32 = {
 
     const len = path.length;
     let rootEnd = 0;
-    let code = path.charCodeAt(0);
+    let code = StringPrototypeCharCodeAt(path, 0);
 
     if (len === 1) {
       if (isPathSeparator(code)) {
@@ -840,26 +926,29 @@ const win32 = {
       // Possible UNC root
 
       rootEnd = 1;
-      if (isPathSeparator(path.charCodeAt(1))) {
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
         // Matched double path separator at beginning
         let j = 2;
         let last = j;
         // Match 1 or more non-path separators
-        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+        while (j < len &&
+               !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
           j++;
         }
         if (j < len && j !== last) {
           // Matched!
           last = j;
           // Match 1 or more path separators
-          while (j < len && isPathSeparator(path.charCodeAt(j))) {
+          while (j < len &&
+                 isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
             j++;
           }
           if (j < len && j !== last) {
             // Matched!
             last = j;
             // Match 1 or more non-path separators
-            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+            while (j < len &&
+                   !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
               j++;
             }
             if (j === len) {
@@ -872,7 +961,8 @@ const win32 = {
           }
         }
       }
-    } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
+    } else if (isWindowsDeviceRoot(code) &&
+               StringPrototypeCharCodeAt(path, 1) === CHAR_COLON) {
       // Possible device root
       if (len <= 2) {
         // `path` contains just a drive root, exit early to avoid
@@ -881,7 +971,7 @@ const win32 = {
         return ret;
       }
       rootEnd = 2;
-      if (isPathSeparator(path.charCodeAt(2))) {
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, 2))) {
         if (len === 3) {
           // `path` contains just a drive root, exit early to avoid
           // unnecessary work
@@ -892,7 +982,7 @@ const win32 = {
       }
     }
     if (rootEnd > 0)
-      ret.root = path.slice(0, rootEnd);
+      ret.root = StringPrototypeSlice(path, 0, rootEnd);
 
     let startDot = -1;
     let startPart = rootEnd;
@@ -906,7 +996,7 @@ const win32 = {
 
     // Get non-dir info
     for (; i >= rootEnd; --i) {
-      code = path.charCodeAt(i);
+      code = StringPrototypeCharCodeAt(path, i);
       if (isPathSeparator(code)) {
         // If we reached a path separator that was not part of a set of path
         // separators at the end of the string, stop now
@@ -943,11 +1033,11 @@ const win32 = {
           (preDotState === 1 &&
            startDot === end - 1 &&
            startDot === startPart + 1)) {
-        ret.base = ret.name = path.slice(startPart, end);
+        ret.base = ret.name = StringPrototypeSlice(path, startPart, end);
       } else {
-        ret.name = path.slice(startPart, startDot);
-        ret.base = path.slice(startPart, end);
-        ret.ext = path.slice(startDot, end);
+        ret.name = StringPrototypeSlice(path, startPart, startDot);
+        ret.base = StringPrototypeSlice(path, startPart, end);
+        ret.ext = StringPrototypeSlice(path, startDot, end);
       }
     }
 
@@ -955,7 +1045,7 @@ const win32 = {
     // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
     // trailing slash (`C:\abc\def` -> `C:\abc`).
     if (startPart > 0 && startPart !== rootEnd)
-      ret.dir = path.slice(0, startPart - 1);
+      ret.dir = StringPrototypeSlice(path, 0, startPart - 1);
     else
       ret.dir = ret.root;
 
@@ -969,7 +1059,11 @@ const win32 = {
 };
 
 const posix = {
-  // path.resolve([from ...], to)
+  /**
+   * path.resolve([from ...], to)
+   * @param {...string} args
+   * @returns {string}
+   */
   resolve(...args) {
     let resolvedPath = '';
     let resolvedAbsolute = false;
@@ -985,7 +1079,8 @@ const posix = {
       }
 
       resolvedPath = `${path}/${resolvedPath}`;
-      resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+      resolvedAbsolute =
+        StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
     }
 
     // At this point the path should be resolved to a full absolute path, but
@@ -1001,15 +1096,20 @@ const posix = {
     return resolvedPath.length > 0 ? resolvedPath : '.';
   },
 
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
   normalize(path) {
     validateString(path, 'path');
 
     if (path.length === 0)
       return '.';
 
-    const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+    const isAbsolute =
+      StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
     const trailingSeparator =
-      path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
+      StringPrototypeCharCodeAt(path, path.length - 1) === CHAR_FORWARD_SLASH;
 
     // Normalize the path
     path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator);
@@ -1025,11 +1125,20 @@ const posix = {
     return isAbsolute ? `/${path}` : path;
   },
 
+  /**
+   * @param {string} path
+   * @returns {boolean}
+   */
   isAbsolute(path) {
     validateString(path, 'path');
-    return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+    return path.length > 0 &&
+           StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
   },
 
+  /**
+   * @param {...string} args
+   * @returns {string}
+   */
   join(...args) {
     if (args.length === 0)
       return '.';
@@ -1049,6 +1158,11 @@ const posix = {
     return posix.normalize(joined);
   },
 
+  /**
+   * @param {string} from
+   * @param {string} to
+   * @returns {string}
+   */
   relative(from, to) {
     validateString(from, 'from');
     validateString(to, 'to');
@@ -1074,26 +1188,27 @@ const posix = {
     let lastCommonSep = -1;
     let i = 0;
     for (; i < length; i++) {
-      const fromCode = from.charCodeAt(fromStart + i);
-      if (fromCode !== to.charCodeAt(toStart + i))
+      const fromCode = StringPrototypeCharCodeAt(from, fromStart + i);
+      if (fromCode !== StringPrototypeCharCodeAt(to, toStart + i))
         break;
       else if (fromCode === CHAR_FORWARD_SLASH)
         lastCommonSep = i;
     }
     if (i === length) {
       if (toLen > length) {
-        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
+        if (StringPrototypeCharCodeAt(to, toStart + i) === CHAR_FORWARD_SLASH) {
           // We get here if `from` is the exact base path for `to`.
           // For example: from='/foo/bar'; to='/foo/bar/baz'
-          return to.slice(toStart + i + 1);
+          return StringPrototypeSlice(to, toStart + i + 1);
         }
         if (i === 0) {
           // We get here if `from` is the root
           // For example: from='/'; to='/foo'
-          return to.slice(toStart + i);
+          return StringPrototypeSlice(to, toStart + i);
         }
       } else if (fromLen > length) {
-        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
+        if (StringPrototypeCharCodeAt(from, fromStart + i) ===
+            CHAR_FORWARD_SLASH) {
           // We get here if `to` is the exact base path for `from`.
           // For example: from='/foo/bar/baz'; to='/foo/bar'
           lastCommonSep = i;
@@ -1109,14 +1224,15 @@ const posix = {
     // Generate the relative path based on the path difference between `to`
     // and `from`.
     for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-      if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (i === fromEnd ||
+          StringPrototypeCharCodeAt(from, i) === CHAR_FORWARD_SLASH) {
         out += out.length === 0 ? '..' : '/..';
       }
     }
 
     // Lastly, append the rest of the destination (`to`) path that comes after
     // the common path parts.
-    return `${out}${to.slice(toStart + lastCommonSep)}`;
+    return `${out}${StringPrototypeSlice(to, toStart + lastCommonSep)}`;
   },
 
   toNamespacedPath(path) {
@@ -1124,15 +1240,19 @@ const posix = {
     return path;
   },
 
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
   dirname(path) {
     validateString(path, 'path');
     if (path.length === 0)
       return '.';
-    const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+    const hasRoot = StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
     let end = -1;
     let matchedSlash = true;
     for (let i = path.length - 1; i >= 1; --i) {
-      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (StringPrototypeCharCodeAt(path, i) === CHAR_FORWARD_SLASH) {
         if (!matchedSlash) {
           end = i;
           break;
@@ -1147,9 +1267,14 @@ const posix = {
       return hasRoot ? '/' : '.';
     if (hasRoot && end === 1)
       return '//';
-    return path.slice(0, end);
+    return StringPrototypeSlice(path, 0, end);
   },
 
+  /**
+   * @param {string} path
+   * @param {string} [ext]
+   * @returns {string}
+   */
   basename(path, ext) {
     if (ext !== undefined)
       validateString(ext, 'ext');
@@ -1165,7 +1290,7 @@ const posix = {
       let extIdx = ext.length - 1;
       let firstNonSlashEnd = -1;
       for (let i = path.length - 1; i >= 0; --i) {
-        const code = path.charCodeAt(i);
+        const code = StringPrototypeCharCodeAt(path, i);
         if (code === CHAR_FORWARD_SLASH) {
           // If we reached a path separator that was not part of a set of path
           // separators at the end of the string, stop now
@@ -1182,7 +1307,7 @@ const posix = {
           }
           if (extIdx >= 0) {
             // Try to match the explicit extension
-            if (code === ext.charCodeAt(extIdx)) {
+            if (code === StringPrototypeCharCodeAt(ext, extIdx)) {
               if (--extIdx === -1) {
                 // We matched the extension, so mark this as the end of our path
                 // component
@@ -1202,10 +1327,10 @@ const posix = {
         end = firstNonSlashEnd;
       else if (end === -1)
         end = path.length;
-      return path.slice(start, end);
+      return StringPrototypeSlice(path, start, end);
     }
     for (let i = path.length - 1; i >= 0; --i) {
-      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (StringPrototypeCharCodeAt(path, i) === CHAR_FORWARD_SLASH) {
         // If we reached a path separator that was not part of a set of path
         // separators at the end of the string, stop now
         if (!matchedSlash) {
@@ -1222,9 +1347,13 @@ const posix = {
 
     if (end === -1)
       return '';
-    return path.slice(start, end);
+    return StringPrototypeSlice(path, start, end);
   },
 
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
   extname(path) {
     validateString(path, 'path');
     let startDot = -1;
@@ -1235,7 +1364,7 @@ const posix = {
     // after any path separator we find
     let preDotState = 0;
     for (let i = path.length - 1; i >= 0; --i) {
-      const code = path.charCodeAt(i);
+      const code = StringPrototypeCharCodeAt(path, i);
       if (code === CHAR_FORWARD_SLASH) {
         // If we reached a path separator that was not part of a set of path
         // separators at the end of the string, stop now
@@ -1274,18 +1403,29 @@ const posix = {
          startDot === startPart + 1)) {
       return '';
     }
-    return path.slice(startDot, end);
+    return StringPrototypeSlice(path, startDot, end);
   },
 
-  format: _format.bind(null, '/'),
-
+  format: FunctionPrototypeBind(_format, null, '/'),
+
+  /**
+   * @param {string} path
+   * @returns {{
+   *   dir: string;
+   *   root: string;
+   *   base: string;
+   *   name: string;
+   *   ext: string;
+   *   }}
+   */
   parse(path) {
     validateString(path, 'path');
 
     const ret = { root: '', dir: '', base: '', ext: '', name: '' };
     if (path.length === 0)
       return ret;
-    const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+    const isAbsolute =
+      StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
     let start;
     if (isAbsolute) {
       ret.root = '/';
@@ -1305,7 +1445,7 @@ const posix = {
 
     // Get non-dir info
     for (; i >= start; --i) {
-      const code = path.charCodeAt(i);
+      const code = StringPrototypeCharCodeAt(path, i);
       if (code === CHAR_FORWARD_SLASH) {
         // If we reached a path separator that was not part of a set of path
         // separators at the end of the string, stop now
@@ -1343,16 +1483,16 @@ const posix = {
           (preDotState === 1 &&
           startDot === end - 1 &&
           startDot === startPart + 1)) {
-        ret.base = ret.name = path.slice(start, end);
+        ret.base = ret.name = StringPrototypeSlice(path, start, end);
       } else {
-        ret.name = path.slice(start, startDot);
-        ret.base = path.slice(start, end);
-        ret.ext = path.slice(startDot, end);
+        ret.name = StringPrototypeSlice(path, start, startDot);
+        ret.base = StringPrototypeSlice(path, start, end);
+        ret.ext = StringPrototypeSlice(path, startDot, end);
       }
     }
 
     if (startPart > 0)
-      ret.dir = path.slice(0, startPart - 1);
+      ret.dir = StringPrototypeSlice(path, 0, startPart - 1);
     else if (isAbsolute)
       ret.dir = '/';
 
diff --git a/lib/perf_hooks.js b/lib/perf_hooks.js
index 683dec3a90a61de6356aa0f93d419e9312a39589..40e20cbc3e2540df1692c974677d7e27026bc4d6 100644
--- a/lib/perf_hooks.js
+++ b/lib/perf_hooks.js
@@ -2,13 +2,21 @@
 
 const {
   ArrayIsArray,
+  ArrayPrototypeFilter,
+  ArrayPrototypeForEach,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
   Boolean,
   NumberIsSafeInteger,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectKeys,
-  Set,
+  SafeSet,
   Symbol,
+  TypeError,
 } = primordials;
 
 const {
@@ -60,6 +68,7 @@ const {
 
 const {
   Histogram,
+  createHistogram,
   kHandle,
 } = require('internal/histogram');
 
@@ -75,7 +84,7 @@ const kInsertEntry = Symbol('insert-entry');
 const kGetEntries = Symbol('get-entries');
 const kIndex = Symbol('index');
 const kMarks = Symbol('marks');
-const kCount = Symbol('count');
+const kEnabled = Symbol('kEnabled');
 
 const observers = {};
 const observerableTypes = [
@@ -85,7 +94,7 @@ const observerableTypes = [
   'gc',
   'function',
   'http2',
-  'http'
+  'http',
 ];
 
 const IDX_STREAM_STATS_ID = 0;
@@ -166,50 +175,94 @@ function getMilestoneTimestamp(milestoneIdx) {
 }
 
 class PerformanceNodeTiming extends PerformanceEntry {
-  get name() {
-    return 'node';
-  }
+  constructor() {
+    super();
 
-  get entryType() {
-    return 'node';
-  }
+    ObjectDefineProperties(this, {
+      name: {
+        enumerable: true,
+        configurable: true,
+        value: 'node'
+      },
 
-  get startTime() {
-    return 0;
-  }
+      entryType: {
+        enumerable: true,
+        configurable: true,
+        value: 'node'
+      },
 
-  get duration() {
-    return now() - timeOrigin;
-  }
+      startTime: {
+        enumerable: true,
+        configurable: true,
+        value: 0
+      },
 
-  get nodeStart() {
-    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_NODE_START);
-  }
+      duration: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return now() - timeOrigin;
+        }
+      },
 
-  get v8Start() {
-    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_V8_START);
-  }
+      nodeStart: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_NODE_START);
+        }
+      },
 
-  get environment() {
-    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_ENVIRONMENT);
-  }
+      v8Start: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_V8_START);
+        }
+      },
 
-  get loopStart() {
-    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_LOOP_START);
-  }
+      environment: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_ENVIRONMENT);
+        }
+      },
 
-  get loopExit() {
-    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_LOOP_EXIT);
-  }
+      loopStart: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_LOOP_START);
+        }
+      },
 
-  get bootstrapComplete() {
-    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE);
-  }
+      loopExit: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_LOOP_EXIT);
+        }
+      },
 
-  get idleTime() {
-    return loopIdleTime();
-  }
+      bootstrapComplete: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return getMilestoneTimestamp(
+            NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE);
+        }
+      },
 
+      idleTime: {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return loopIdleTime();
+        }
+      }
+    });
+  }
   [kInspect]() {
     return {
       name: 'node',
@@ -236,11 +289,6 @@ class PerformanceObserverEntryList {
         writable: true,
         enumerable: false,
         value: {}
-      },
-      [kCount]: {
-        writable: true,
-        enumerable: false,
-        value: 0
       }
     });
     L.init(this[kEntries]);
@@ -249,11 +297,6 @@ class PerformanceObserverEntryList {
   [kInsertEntry](entry) {
     const item = { entry };
     L.append(this[kEntries], item);
-    this[kCount]++;
-  }
-
-  get length() {
-    return this[kCount];
   }
 
   [kGetEntries](name, type) {
@@ -328,13 +371,13 @@ class PerformanceObserver extends AsyncResource {
   disconnect() {
     const observerCountsGC = observerCounts[NODE_PERFORMANCE_ENTRY_TYPE_GC];
     const types = this[kTypes];
-    for (const key of ObjectKeys(types)) {
+    ArrayPrototypeForEach(ObjectKeys(types), (key) => {
       const item = types[key];
       if (item) {
         L.remove(item);
         observerCounts[key]--;
       }
-    }
+    });
     this[kTypes] = {};
     if (observerCountsGC === 1 &&
       observerCounts[NODE_PERFORMANCE_ENTRY_TYPE_GC] === 0) {
@@ -350,7 +393,9 @@ class PerformanceObserver extends AsyncResource {
     if (!ArrayIsArray(entryTypes)) {
       throw new ERR_INVALID_OPT_VALUE('entryTypes', entryTypes);
     }
-    const filteredEntryTypes = entryTypes.filter(filterTypes).map(mapTypes);
+    const filteredEntryTypes =
+      ArrayPrototypeMap(ArrayPrototypeFilter(entryTypes, filterTypes),
+                        mapTypes);
     if (filteredEntryTypes.length === 0) {
       throw new ERR_VALID_PERFORMANCE_ENTRY_TYPE();
     }
@@ -359,14 +404,14 @@ class PerformanceObserver extends AsyncResource {
     this[kBuffer][kEntries] = [];
     L.init(this[kBuffer][kEntries]);
     this[kBuffering] = Boolean(options.buffered);
-    for (const entryType of filteredEntryTypes) {
+    ArrayPrototypeForEach(filteredEntryTypes, (entryType) => {
       const list = getObserversList(entryType);
-      if (this[kTypes][entryType]) continue;
+      if (this[kTypes][entryType]) return;
       const item = { obs: this };
       this[kTypes][entryType] = item;
       L.append(list, item);
       observerCounts[entryType]++;
-    }
+    });
     if (observerCountsGC === 0 &&
       observerCounts[NODE_PERFORMANCE_ENTRY_TYPE_GC] === 1) {
       installGarbageCollectionTracking();
@@ -377,7 +422,7 @@ class PerformanceObserver extends AsyncResource {
 class Performance {
   constructor() {
     this[kIndex] = {
-      [kMarks]: new Set()
+      [kMarks]: new SafeSet()
     };
   }
 
@@ -544,7 +589,7 @@ function observersCallback(entry) {
 setupObservers(observersCallback);
 
 function filterTypes(i) {
-  return observerableTypes.indexOf(`${i}`) >= 0;
+  return ArrayPrototypeIncludes(observerableTypes, `${i}`);
 }
 
 function mapTypes(i) {
@@ -582,20 +627,38 @@ function sortedInsert(list, entry) {
   const entryStartTime = entry.startTime;
   if (list.length === 0 ||
       (list[list.length - 1].startTime < entryStartTime)) {
-    list.push(entry);
+    ArrayPrototypePush(list, entry);
     return;
   }
   if (list[0] && (list[0].startTime > entryStartTime)) {
-    list.unshift(entry);
+    ArrayPrototypeUnshift(list, entry);
     return;
   }
   const location = getInsertLocation(list, entryStartTime);
-  list.splice(location, 0, entry);
+  ArrayPrototypeSplice(list, location, 0, entry);
 }
 
 class ELDHistogram extends Histogram {
-  enable() { return this[kHandle].enable(); }
-  disable() { return this[kHandle].disable(); }
+  constructor(i) {
+    if (!(i instanceof _ELDHistogram)) {
+      // eslint-disable-next-line no-restricted-syntax
+      throw new TypeError('illegal constructor');
+    }
+    super(i);
+    this[kEnabled] = false;
+  }
+  enable() {
+    if (this[kEnabled]) return false;
+    this[kEnabled] = true;
+    this[kHandle].start();
+    return true;
+  }
+  disable() {
+    if (!this[kEnabled]) return false;
+    this[kEnabled] = false;
+    this[kHandle].stop();
+    return true;
+  }
 }
 
 function monitorEventLoopDelay(options = {}) {
@@ -616,7 +679,8 @@ function monitorEventLoopDelay(options = {}) {
 module.exports = {
   performance,
   PerformanceObserver,
-  monitorEventLoopDelay
+  monitorEventLoopDelay,
+  createHistogram,
 };
 
 ObjectDefineProperty(module.exports, 'constants', {
diff --git a/lib/querystring.js b/lib/querystring.js
index 7bc6684f4001740cd4d16853ff3693672fc38480..5bcfa13a6a5b13730348d4bb7d25f7f4a784bb47 100644
--- a/lib/querystring.js
+++ b/lib/querystring.js
@@ -26,9 +26,14 @@
 const {
   Array,
   ArrayIsArray,
+  Int8Array,
   MathAbs,
+  NumberIsFinite,
   ObjectCreate,
   ObjectKeys,
+  String,
+  StringPrototypeCharCodeAt,
+  StringPrototypeSlice,
   decodeURIComponent,
 } = primordials;
 
@@ -53,7 +58,7 @@ const QueryString = module.exports = {
   decode: parse
 };
 
-const unhexTable = [
+const unhexTable = new Int8Array([
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0 - 15
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 16 - 31
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 32 - 47
@@ -69,9 +74,14 @@ const unhexTable = [
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1  // ... 255
-];
-// A safe fast alternative to decodeURIComponent
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  // ... 255
+]);
+/**
+ * A safe fast alternative to decodeURIComponent
+ * @param {string} s
+ * @param {boolean} decodeSpaces
+ * @returns {string}
+ */
 function unescapeBuffer(s, decodeSpaces) {
   const out = Buffer.allocUnsafe(s.length);
   let index = 0;
@@ -84,20 +94,20 @@ function unescapeBuffer(s, decodeSpaces) {
   // Flag to know if some hex chars have been decoded
   let hasHex = false;
   while (index < s.length) {
-    currentChar = s.charCodeAt(index);
+    currentChar = StringPrototypeCharCodeAt(s, index);
     if (currentChar === 43 /* '+' */ && decodeSpaces) {
       out[outIndex++] = 32; // ' '
       index++;
       continue;
     }
     if (currentChar === 37 /* '%' */ && index < maxLength) {
-      currentChar = s.charCodeAt(++index);
+      currentChar = StringPrototypeCharCodeAt(s, ++index);
       hexHigh = unhexTable[currentChar];
       if (!(hexHigh >= 0)) {
         out[outIndex++] = 37; // '%'
         continue;
       } else {
-        nextChar = s.charCodeAt(++index);
+        nextChar = StringPrototypeCharCodeAt(s, ++index);
         hexLow = unhexTable[nextChar];
         if (!(hexLow >= 0)) {
           out[outIndex++] = 37; // '%'
@@ -114,7 +124,11 @@ function unescapeBuffer(s, decodeSpaces) {
   return hasHex ? out.slice(0, outIndex) : out;
 }
 
-
+/**
+ * @param {string} s
+ * @param {boolean} decodeSpaces
+ * @returns {string}
+ */
 function qsUnescape(s, decodeSpaces) {
   try {
     return decodeURIComponent(s);
@@ -130,7 +144,7 @@ function qsUnescape(s, decodeSpaces) {
 // digits
 // alpha (uppercase)
 // alpha (lowercase)
-const noEscape = [
+const noEscape = new Int8Array([
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
   0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, // 32 - 47
@@ -138,10 +152,15 @@ const noEscape = [
   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 80 - 95
   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0  // 112 - 127
-];
-// QueryString.escape() replaces encodeURIComponent()
-// https://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3.4
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,  // 112 - 127
+]);
+
+/**
+ * QueryString.escape() replaces encodeURIComponent()
+ * @see https://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3.4
+ * @param {any} str
+ * @returns {string}
+ */
 function qsEscape(str) {
   if (typeof str !== 'string') {
     if (typeof str === 'object')
@@ -153,36 +172,59 @@ function qsEscape(str) {
   return encodeStr(str, noEscape, hexTable);
 }
 
+/**
+ * @param {string | number | bigint | boolean | symbol | undefined | null} v
+ * @returns {string}
+ */
 function stringifyPrimitive(v) {
   if (typeof v === 'string')
     return v;
-  if (typeof v === 'number' && isFinite(v))
+  if (typeof v === 'number' && NumberIsFinite(v))
+    return '' + v;
+  if (typeof v === 'bigint')
     return '' + v;
   if (typeof v === 'boolean')
     return v ? 'true' : 'false';
   return '';
 }
 
-
+/**
+ * @param {string | number | bigint | boolean} v
+ * @param {(v: string) => string} encode
+ * @returns
+ */
 function encodeStringified(v, encode) {
   if (typeof v === 'string')
     return (v.length ? encode(v) : '');
-  if (typeof v === 'number' && isFinite(v)) {
+  if (typeof v === 'number' && NumberIsFinite(v)) {
     // Values >= 1e21 automatically switch to scientific notation which requires
     // escaping due to the inclusion of a '+' in the output
     return (MathAbs(v) < 1e21 ? '' + v : encode('' + v));
   }
+  if (typeof v === 'bigint')
+    return '' + v;
   if (typeof v === 'boolean')
     return v ? 'true' : 'false';
   return '';
 }
 
-
+/**
+ * @param {string | number | boolean | null} v
+ * @param {(v: string) => string} encode
+ * @returns {string}
+ */
 function encodeStringifiedCustom(v, encode) {
   return encode(stringifyPrimitive(v));
 }
 
-
+/**
+ * @param {Record<string, string | number | boolean
+ * | ReadonlyArray<string | number | boolean> | null>} obj
+ * @param {string} [sep]
+ * @param {string} [eq]
+ * @param {{ encodeURIComponent?: (v: string) => string }} [options]
+ * @returns {string}
+ */
 function stringify(obj, sep, eq, options) {
   sep = sep || '&';
   eq = eq || '=';
@@ -227,12 +269,16 @@ function stringify(obj, sep, eq, options) {
   return '';
 }
 
+/**
+ * @param {string} str
+ * @returns {number[]}
+ */
 function charCodes(str) {
   if (str.length === 0) return [];
-  if (str.length === 1) return [str.charCodeAt(0)];
+  if (str.length === 1) return [StringPrototypeCharCodeAt(str, 0)];
   const ret = new Array(str.length);
   for (let i = 0; i < str.length; ++i)
-    ret[i] = str.charCodeAt(i);
+    ret[i] = StringPrototypeCharCodeAt(str, i);
   return ret;
 }
 const defSepCodes = [38]; // &
@@ -258,7 +304,17 @@ function addKeyVal(obj, key, value, keyEncoded, valEncoded, decode) {
   }
 }
 
-// Parse a key/val string.
+/**
+ * Parse a key/val string.
+ * @param {string} qs
+ * @param {string} sep
+ * @param {string} eq
+ * @param {{
+ *   maxKeys?: number;
+ *   decodeURIComponent?(v: string): string;
+ *   }} [options]
+ * @returns {Record<string, string | string[]>}
+ */
 function parse(qs, sep, eq, options) {
   const obj = ObjectCreate(null);
 
@@ -266,8 +322,8 @@ function parse(qs, sep, eq, options) {
     return obj;
   }
 
-  const sepCodes = (!sep ? defSepCodes : charCodes(sep + ''));
-  const eqCodes = (!eq ? defEqCodes : charCodes(eq + ''));
+  const sepCodes = (!sep ? defSepCodes : charCodes(String(sep)));
+  const eqCodes = (!eq ? defEqCodes : charCodes(String(eq)));
   const sepLen = sepCodes.length;
   const eqLen = eqCodes.length;
 
@@ -298,7 +354,7 @@ function parse(qs, sep, eq, options) {
   const plusChar = (customDecode ? '%20' : ' ');
   let encodeCheck = 0;
   for (let i = 0; i < qs.length; ++i) {
-    const code = qs.charCodeAt(i);
+    const code = StringPrototypeCharCodeAt(qs, i);
 
     // Try matching key/value pair separator (e.g. '&')
     if (code === sepCodes[sepIdx]) {
@@ -309,7 +365,7 @@ function parse(qs, sep, eq, options) {
           // We didn't find the (entire) key/value separator
           if (lastPos < end) {
             // Treat the substring as part of the key instead of the value
-            key += qs.slice(lastPos, end);
+            key += StringPrototypeSlice(qs, lastPos, end);
           } else if (key.length === 0) {
             // We saw an empty substring between separators
             if (--pairs === 0)
@@ -319,7 +375,7 @@ function parse(qs, sep, eq, options) {
             continue;
           }
         } else if (lastPos < end) {
-          value += qs.slice(lastPos, end);
+          value += StringPrototypeSlice(qs, lastPos, end);
         }
 
         addKeyVal(obj, key, value, keyEncoded, valEncoded, decode);
@@ -341,7 +397,7 @@ function parse(qs, sep, eq, options) {
             // Key/value separator match!
             const end = i - eqIdx + 1;
             if (lastPos < end)
-              key += qs.slice(lastPos, end);
+              key += StringPrototypeSlice(qs, lastPos, end);
             encodeCheck = 0;
             lastPos = i + 1;
           }
@@ -367,7 +423,7 @@ function parse(qs, sep, eq, options) {
         }
         if (code === 43/* + */) {
           if (lastPos < i)
-            key += qs.slice(lastPos, i);
+            key += StringPrototypeSlice(qs, lastPos, i);
           key += plusChar;
           lastPos = i + 1;
           continue;
@@ -375,7 +431,7 @@ function parse(qs, sep, eq, options) {
       }
       if (code === 43/* + */) {
         if (lastPos < i)
-          value += qs.slice(lastPos, i);
+          value += StringPrototypeSlice(qs, lastPos, i);
         value += plusChar;
         lastPos = i + 1;
       } else if (!valEncoded) {
@@ -398,9 +454,9 @@ function parse(qs, sep, eq, options) {
   // Deal with any leftover key or value data
   if (lastPos < qs.length) {
     if (eqIdx < eqLen)
-      key += qs.slice(lastPos);
+      key += StringPrototypeSlice(qs, lastPos);
     else if (sepIdx < sepLen)
-      value += qs.slice(lastPos);
+      value += StringPrototypeSlice(qs, lastPos);
   } else if (eqIdx === 0 && key.length === 0) {
     // We ended on an empty substring
     return obj;
@@ -412,9 +468,14 @@ function parse(qs, sep, eq, options) {
 }
 
 
-// v8 does not optimize functions with try-catch blocks, so we isolate them here
-// to minimize the damage (Note: no longer true as of V8 5.4 -- but still will
-// not be inlined).
+/**
+ * V8 does not optimize functions with try-catch blocks, so we isolate them here
+ * to minimize the damage (Note: no longer true as of V8 5.4 -- but still will
+ * not be inlined).
+ * @param {string} s
+ * @param {(v: string) => string} decoder
+ * @returns {string}
+ */
 function decodeStr(s, decoder) {
   try {
     return decoder(s);
diff --git a/lib/readline.js b/lib/readline.js
index 5515d9b3a91cc0511fb9a258664c48840c208783..fea190c08f34fd85ebc5327ea991410c386f93c4 100644
--- a/lib/readline.js
+++ b/lib/readline.js
@@ -28,24 +28,58 @@
 'use strict';
 
 const {
+  ArrayFrom,
+  ArrayPrototypeFilter,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePop,
+  ArrayPrototypeReverse,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
   DateNow,
+  FunctionPrototypeBind,
+  FunctionPrototypeCall,
   MathCeil,
   MathFloor,
   MathMax,
+  MathMaxApply,
   NumberIsFinite,
   NumberIsNaN,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
+  RegExpPrototypeTest,
+  StringPrototypeCodePointAt,
+  StringPrototypeEndsWith,
+  StringPrototypeMatch,
+  StringPrototypeRepeat,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+  StringPrototypeTrim,
+  Promise,
   Symbol,
   SymbolAsyncIterator,
+  SafeStringIterator,
 } = primordials;
 
+const {
+  AbortError,
+  codes
+} = require('internal/errors');
+
 const {
   ERR_INVALID_CALLBACK,
   ERR_INVALID_CURSOR_POS,
-  ERR_INVALID_OPT_VALUE
-} = require('internal/errors').codes;
-const { validateString } = require('internal/validators');
+  ERR_INVALID_OPT_VALUE,
+} = codes;
+const {
+  validateAbortSignal,
+  validateArray,
+  validateString,
+  validateUint32,
+} = require('internal/validators');
 const {
   inspect,
   getStringWidth,
@@ -61,6 +95,8 @@ const {
   kSubstringSearch,
 } = require('internal/readline/utils');
 
+const { promisify } = require('internal/util');
+
 const { clearTimeout, setTimeout } = require('timers');
 const {
   kEscape,
@@ -70,6 +106,7 @@ const {
   kClearScreenDown
 } = CSI;
 
+
 const { StringDecoder } = require('string_decoder');
 
 // Lazy load Readable for startup performance.
@@ -105,19 +142,27 @@ function Interface(input, output, completer, terminal) {
   this._sawKeyPress = false;
   this._previousKey = null;
   this.escapeCodeTimeout = ESCAPE_CODE_TIMEOUT;
+  this.tabSize = 8;
 
-  EventEmitter.call(this);
+  FunctionPrototypeCall(EventEmitter, this);
+  let history;
   let historySize;
   let removeHistoryDuplicates = false;
   let crlfDelay;
   let prompt = '> ';
-
+  let signal;
   if (input && input.input) {
     // An options object was given
     output = input.output;
     completer = input.completer;
     terminal = input.terminal;
+    history = input.history;
     historySize = input.historySize;
+    signal = input.signal;
+    if (input.tabSize !== undefined) {
+      validateUint32(input.tabSize, 'tabSize', true);
+      this.tabSize = input.tabSize;
+    }
     removeHistoryDuplicates = input.removeHistoryDuplicates;
     if (input.prompt !== undefined) {
       prompt = input.prompt;
@@ -132,14 +177,25 @@ function Interface(input, output, completer, terminal) {
         );
       }
     }
+
+    if (signal) {
+      validateAbortSignal(signal, 'options.signal');
+    }
+
     crlfDelay = input.crlfDelay;
     input = input.input;
   }
 
-  if (completer && typeof completer !== 'function') {
+  if (completer !== undefined && typeof completer !== 'function') {
     throw new ERR_INVALID_OPT_VALUE('completer', completer);
   }
 
+  if (history === undefined) {
+    history = [];
+  } else {
+    validateArray(history, 'history');
+  }
+
   if (historySize === undefined) {
     historySize = kHistorySize;
   }
@@ -158,9 +214,11 @@ function Interface(input, output, completer, terminal) {
 
   const self = this;
 
+  this.line = '';
   this[kSubstringSearch] = null;
   this.output = output;
   this.input = input;
+  this.history = history;
   this.historySize = historySize;
   this.removeHistoryDuplicates = !!removeHistoryDuplicates;
   this.crlfDelay = crlfDelay ?
@@ -174,12 +232,14 @@ function Interface(input, output, completer, terminal) {
       };
   }
 
+  this._questionCancel = FunctionPrototypeBind(_questionCancel, this);
+
   this.setPrompt(prompt);
 
   this.terminal = !!terminal;
 
   if (process.env.TERM === 'dumb') {
-    this._ttyWrite = _ttyWriteDumb.bind(this);
+    this._ttyWrite = FunctionPrototypeBind(_ttyWriteDumb, this);
   }
 
   function ondata(data) {
@@ -207,7 +267,7 @@ function Interface(input, output, completer, terminal) {
       // If the key.sequence is half of a surrogate pair
       // (>= 0xd800 and <= 0xdfff), refresh the line so
       // the character is displayed appropriately.
-      const ch = key.sequence.codePointAt(0);
+      const ch = StringPrototypeCodePointAt(key.sequence, 0);
       if (ch >= 0xd800 && ch <= 0xdfff)
         self._refreshLine();
     }
@@ -244,16 +304,12 @@ function Interface(input, output, completer, terminal) {
     input.on('keypress', onkeypress);
     input.on('end', ontermend);
 
-    // Current line
-    this.line = '';
-
     this._setRawMode(true);
     this.terminal = true;
 
     // Cursor position on the line.
     this.cursor = 0;
 
-    this.history = [];
     this.historyIndex = -1;
 
     if (output !== null && output !== undefined)
@@ -262,6 +318,19 @@ function Interface(input, output, completer, terminal) {
     self.once('close', onSelfCloseWithTerminal);
   }
 
+  if (signal) {
+    const onAborted = () => self.close();
+    if (signal.aborted) {
+      process.nextTick(onAborted);
+    } else {
+      signal.addEventListener('abort', onAborted, { once: true });
+      self.once('close', () => signal.removeEventListener('abort', onAborted));
+    }
+  }
+
+  // Current line
+  this.line = '';
+
   input.resume();
 }
 
@@ -283,6 +352,11 @@ Interface.prototype.setPrompt = function(prompt) {
 };
 
 
+Interface.prototype.getPrompt = function() {
+  return this._prompt;
+};
+
+
 Interface.prototype._setRawMode = function(mode) {
   const wasInRawMode = this.input.isRaw;
 
@@ -305,7 +379,16 @@ Interface.prototype.prompt = function(preserveCursor) {
 };
 
 
-Interface.prototype.question = function(query, cb) {
+Interface.prototype.question = function(query, options, cb) {
+  cb = typeof options === 'function' ? options : cb;
+  options = typeof options === 'object' ? options : {};
+
+  if (options.signal) {
+    options.signal.addEventListener('abort', () => {
+      this._questionCancel();
+    }, { once: true });
+  }
+
   if (typeof cb === 'function') {
     if (this._questionCallback) {
       this.prompt();
@@ -318,6 +401,28 @@ Interface.prototype.question = function(query, cb) {
   }
 };
 
+Interface.prototype.question[promisify.custom] = function(query, options) {
+  options = typeof options === 'object' ? options : {};
+
+  return new Promise((resolve, reject) => {
+    this.question(query, options, resolve);
+
+    if (options.signal) {
+      options.signal.addEventListener('abort', () => {
+        reject(new AbortError());
+      }, { once: true });
+    }
+  });
+};
+
+function _questionCancel() {
+  if (this._questionCallback) {
+    this._questionCallback = null;
+    this.setPrompt(this._oldPrompt);
+    this.clearLine();
+  }
+}
+
 
 Interface.prototype._onLine = function(line) {
   if (this._questionCallback) {
@@ -345,23 +450,32 @@ Interface.prototype._addHistory = function() {
   if (this.historySize === 0) return this.line;
 
   // If the trimmed line is empty then return the line
-  if (this.line.trim().length === 0) return this.line;
+  if (StringPrototypeTrim(this.line).length === 0) return this.line;
 
   if (this.history.length === 0 || this.history[0] !== this.line) {
     if (this.removeHistoryDuplicates) {
       // Remove older history line if identical to new one
-      const dupIndex = this.history.indexOf(this.line);
-      if (dupIndex !== -1) this.history.splice(dupIndex, 1);
+      const dupIndex = ArrayPrototypeIndexOf(this.history, this.line);
+      if (dupIndex !== -1) ArrayPrototypeSplice(this.history, dupIndex, 1);
     }
 
-    this.history.unshift(this.line);
+    ArrayPrototypeUnshift(this.history, this.line);
 
     // Only store so many
-    if (this.history.length > this.historySize) this.history.pop();
+    if (this.history.length > this.historySize) ArrayPrototypePop(this.history);
   }
 
   this.historyIndex = -1;
-  return this.history[0];
+
+  // The listener could change the history object, possibly
+  // to remove the last added entry if it is sensitive and should
+  // not be persisted in the history, like a password
+  const line = this.history[0];
+
+  // Emit history event to notify listeners of update
+  this.emit('history', this.history);
+
+  return line;
 };
 
 
@@ -451,24 +565,24 @@ Interface.prototype._normalWrite = function(b) {
   let string = this._decoder.write(b);
   if (this._sawReturnAt &&
       DateNow() - this._sawReturnAt <= this.crlfDelay) {
-    string = string.replace(/^\n/, '');
+    string = StringPrototypeReplace(string, /^\n/, '');
     this._sawReturnAt = 0;
   }
 
   // Run test() on the new string chunk, not on the entire line buffer.
-  const newPartContainsEnding = lineEnding.test(string);
+  const newPartContainsEnding = RegExpPrototypeTest(lineEnding, string);
 
   if (this._line_buffer) {
     string = this._line_buffer + string;
     this._line_buffer = null;
   }
   if (newPartContainsEnding) {
-    this._sawReturnAt = string.endsWith('\r') ? DateNow() : 0;
+    this._sawReturnAt = StringPrototypeEndsWith(string, '\r') ? DateNow() : 0;
 
     // Got one or more newlines; process into "line" events
-    const lines = string.split(lineEnding);
+    const lines = StringPrototypeSplit(string, lineEnding);
     // Either '' or (conceivably) the unfinished portion of the next line
-    string = lines.pop();
+    string = ArrayPrototypePop(lines);
     this._line_buffer = string;
     for (let n = 0; n < lines.length; n++)
       this._onLine(lines[n]);
@@ -480,8 +594,8 @@ Interface.prototype._normalWrite = function(b) {
 
 Interface.prototype._insertString = function(c) {
   if (this.cursor < this.line.length) {
-    const beg = this.line.slice(0, this.cursor);
-    const end = this.line.slice(this.cursor, this.line.length);
+    const beg = StringPrototypeSlice(this.line, 0, this.cursor);
+    const end = StringPrototypeSlice(this.line, this.cursor, this.line.length);
     this.line = beg + c + end;
     this.cursor += c.length;
     this._refreshLine();
@@ -499,7 +613,8 @@ Interface.prototype._insertString = function(c) {
 
 Interface.prototype._tabComplete = function(lastKeypressWasTab) {
   this.pause();
-  this.completer(this.line.slice(0, this.cursor), (err, value) => {
+  const string = StringPrototypeSlice(this.line, 0, this.cursor);
+  this.completer(string, (err, value) => {
     this.resume();
 
     if (err) {
@@ -508,16 +623,29 @@ Interface.prototype._tabComplete = function(lastKeypressWasTab) {
     }
 
     // Result and the text that was completed.
-    const [completions, completeOn] = value;
+    const { 0: completions, 1: completeOn } = value;
 
     if (!completions || completions.length === 0) {
       return;
     }
 
     // If there is a common prefix to all matches, then apply that portion.
-    const prefix = commonPrefix(completions.filter((e) => e !== ''));
-    if (prefix.length > completeOn.length) {
-      this._insertString(prefix.slice(completeOn.length));
+    const prefix = commonPrefix(ArrayPrototypeFilter(completions,
+                                                     (e) => e !== ''));
+    if (StringPrototypeStartsWith(prefix, completeOn) &&
+        prefix.length > completeOn.length) {
+      this._insertString(StringPrototypeSlice(prefix, completeOn.length));
+      return;
+    } else if (!StringPrototypeStartsWith(completeOn, prefix)) {
+      this.line = StringPrototypeSlice(this.line,
+                                       0,
+                                       this.cursor - completeOn.length) +
+                  prefix +
+                  StringPrototypeSlice(this.line,
+                                       this.cursor,
+                                       this.line.length);
+      this.cursor = this.cursor - completeOn.length + prefix.length;
+      this._refreshLine();
       return;
     }
 
@@ -526,8 +654,9 @@ Interface.prototype._tabComplete = function(lastKeypressWasTab) {
     }
 
     // Apply/show completions.
-    const completionsWidth = completions.map((e) => getStringWidth(e));
-    const width = MathMax(...completionsWidth) + 2; // 2 space padding
+    const completionsWidth = ArrayPrototypeMap(completions,
+                                               (e) => getStringWidth(e));
+    const width = MathMaxApply(completionsWidth) + 2; // 2 space padding
     let maxColumns = MathFloor(this.columns / width) || 1;
     if (maxColumns === Infinity) {
       maxColumns = 1;
@@ -542,7 +671,7 @@ Interface.prototype._tabComplete = function(lastKeypressWasTab) {
         lineIndex = 0;
         whitespace = 0;
       } else {
-        output += ' '.repeat(whitespace);
+        output += StringPrototypeRepeat(' ', whitespace);
       }
       if (completion !== '') {
         output += completion;
@@ -564,9 +693,10 @@ Interface.prototype._wordLeft = function() {
   if (this.cursor > 0) {
     // Reverse the string and match a word near beginning
     // to avoid quadratic time complexity
-    const leading = this.line.slice(0, this.cursor);
-    const reversed = leading.split('').reverse().join('');
-    const match = reversed.match(/^\s*(?:[^\w\s]+|\w+)?/);
+    const leading = StringPrototypeSlice(this.line, 0, this.cursor);
+    const reversed = ArrayPrototypeJoin(
+      ArrayPrototypeReverse(ArrayFrom(leading)), '');
+    const match = StringPrototypeMatch(reversed, /^\s*(?:[^\w\s]+|\w+)?/);
     this._moveCursor(-match[0].length);
   }
 };
@@ -574,8 +704,8 @@ Interface.prototype._wordLeft = function() {
 
 Interface.prototype._wordRight = function() {
   if (this.cursor < this.line.length) {
-    const trailing = this.line.slice(this.cursor);
-    const match = trailing.match(/^(?:\s+|[^\w\s]+|\w+)\s*/);
+    const trailing = StringPrototypeSlice(this.line, this.cursor);
+    const match = StringPrototypeMatch(trailing, /^(?:\s+|[^\w\s]+|\w+)\s*/);
     this._moveCursor(match[0].length);
   }
 };
@@ -584,8 +714,8 @@ Interface.prototype._deleteLeft = function() {
   if (this.cursor > 0 && this.line.length > 0) {
     // The number of UTF-16 units comprising the character to the left
     const charSize = charLengthLeft(this.line, this.cursor);
-    this.line = this.line.slice(0, this.cursor - charSize) +
-                this.line.slice(this.cursor, this.line.length);
+    this.line = StringPrototypeSlice(this.line, 0, this.cursor - charSize) +
+                StringPrototypeSlice(this.line, this.cursor, this.line.length);
 
     this.cursor -= charSize;
     this._refreshLine();
@@ -597,8 +727,8 @@ Interface.prototype._deleteRight = function() {
   if (this.cursor < this.line.length) {
     // The number of UTF-16 units comprising the character to the left
     const charSize = charLengthAt(this.line, this.cursor);
-    this.line = this.line.slice(0, this.cursor) +
-      this.line.slice(this.cursor + charSize, this.line.length);
+    this.line = StringPrototypeSlice(this.line, 0, this.cursor) +
+      StringPrototypeSlice(this.line, this.cursor + charSize, this.line.length);
     this._refreshLine();
   }
 };
@@ -608,11 +738,14 @@ Interface.prototype._deleteWordLeft = function() {
   if (this.cursor > 0) {
     // Reverse the string and match a word near beginning
     // to avoid quadratic time complexity
-    let leading = this.line.slice(0, this.cursor);
-    const reversed = leading.split('').reverse().join('');
-    const match = reversed.match(/^\s*(?:[^\w\s]+|\w+)?/);
-    leading = leading.slice(0, leading.length - match[0].length);
-    this.line = leading + this.line.slice(this.cursor, this.line.length);
+    let leading = StringPrototypeSlice(this.line, 0, this.cursor);
+    const reversed = ArrayPrototypeJoin(
+      ArrayPrototypeReverse(ArrayFrom(leading)), '');
+    const match = StringPrototypeMatch(reversed, /^\s*(?:[^\w\s]+|\w+)?/);
+    leading = StringPrototypeSlice(leading, 0,
+                                   leading.length - match[0].length);
+    this.line = leading + StringPrototypeSlice(this.line, this.cursor,
+                                               this.line.length);
     this.cursor = leading.length;
     this._refreshLine();
   }
@@ -621,24 +754,24 @@ Interface.prototype._deleteWordLeft = function() {
 
 Interface.prototype._deleteWordRight = function() {
   if (this.cursor < this.line.length) {
-    const trailing = this.line.slice(this.cursor);
-    const match = trailing.match(/^(?:\s+|\W+|\w+)\s*/);
-    this.line = this.line.slice(0, this.cursor) +
-                trailing.slice(match[0].length);
+    const trailing = StringPrototypeSlice(this.line, this.cursor);
+    const match = StringPrototypeMatch(trailing, /^(?:\s+|\W+|\w+)\s*/);
+    this.line = StringPrototypeSlice(this.line, 0, this.cursor) +
+                StringPrototypeSlice(trailing, match[0].length);
     this._refreshLine();
   }
 };
 
 
 Interface.prototype._deleteLineLeft = function() {
-  this.line = this.line.slice(this.cursor);
+  this.line = StringPrototypeSlice(this.line, this.cursor);
   this.cursor = 0;
   this._refreshLine();
 };
 
 
 Interface.prototype._deleteLineRight = function() {
-  this.line = this.line.slice(0, this.cursor);
+  this.line = StringPrototypeSlice(this.line, 0, this.cursor);
   this._refreshLine();
 };
 
@@ -670,7 +803,7 @@ Interface.prototype._historyNext = function() {
     const search = this[kSubstringSearch] || '';
     let index = this.historyIndex - 1;
     while (index >= 0 &&
-           (!this.history[index].startsWith(search) ||
+           (!StringPrototypeStartsWith(this.history[index], search) ||
              this.line === this.history[index])) {
       index--;
     }
@@ -690,7 +823,7 @@ Interface.prototype._historyPrev = function() {
     const search = this[kSubstringSearch] || '';
     let index = this.historyIndex + 1;
     while (index < this.history.length &&
-           (!this.history[index].startsWith(search) ||
+           (!StringPrototypeStartsWith(this.history[index], search) ||
              this.line === this.history[index])) {
       index++;
     }
@@ -711,17 +844,16 @@ Interface.prototype._getDisplayPos = function(str) {
   const col = this.columns;
   let rows = 0;
   str = stripVTControlCharacters(str);
-  for (const char of str) {
+  for (const char of new SafeStringIterator(str)) {
     if (char === '\n') {
       // Rows must be incremented by 1 even if offset = 0 or col = +Infinity.
       rows += MathCeil(offset / col) || 1;
       offset = 0;
       continue;
     }
-    // Tabs must be aligned by an offset of 8.
-    // TODO(BridgeAR): Make the tab size configurable.
+    // Tabs must be aligned by an offset of the tab size.
     if (char === '\t') {
-      offset += 8 - (offset % 8);
+      offset += this.tabSize - (offset % this.tabSize);
       continue;
     }
     const width = getStringWidth(char);
@@ -741,7 +873,8 @@ Interface.prototype._getDisplayPos = function(str) {
 
 // Returns current cursor's position and line
 Interface.prototype.getCursorPos = function() {
-  const strBeforeCursor = this._prompt + this.line.substring(0, this.cursor);
+  const strBeforeCursor = this._prompt +
+                          StringPrototypeSlice(this.line, 0, this.cursor);
   return this._getDisplayPos(strBeforeCursor);
 };
 Interface.prototype._getCursorPos = Interface.prototype.getCursorPos;
@@ -831,7 +964,7 @@ Interface.prototype._ttyWrite = function(s, key) {
   if ((key.name === 'up' || key.name === 'down') &&
       !key.ctrl && !key.meta && !key.shift) {
     if (this[kSubstringSearch] === null) {
-      this[kSubstringSearch] = this.line.slice(0, this.cursor);
+      this[kSubstringSearch] = StringPrototypeSlice(this.line, 0, this.cursor);
     }
   } else if (this[kSubstringSearch] !== null) {
     this[kSubstringSearch] = null;
@@ -1055,7 +1188,7 @@ Interface.prototype._ttyWrite = function(s, key) {
       // falls through
       default:
         if (typeof s === 'string' && s) {
-          const lines = s.split(/\r\n|\n|\r/);
+          const lines = StringPrototypeSplit(s, /\r\n|\n|\r/);
           for (let i = 0, len = lines.length; i < len; i++) {
             if (i > 0) {
               this._line();
@@ -1127,7 +1260,7 @@ function emitKeypressEvents(stream, iface = {}) {
         iface.isCompletionEnabled = false;
 
         let length = 0;
-        for (const character of string) {
+        for (const character of new SafeStringIterator(string)) {
           length += character.length;
           if (length === string.length) {
             iface.isCompletionEnabled = true;
diff --git a/lib/repl.js b/lib/repl.js
index 10ca72f0e79d26227cf32528da84d0cb6f51623d..d11a50f22db43e5f362a4b04657d675d50d19c88 100644
--- a/lib/repl.js
+++ b/lib/repl.js
@@ -19,7 +19,7 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-/* A repl library that you can include in your own code to get a runtime
+/* A REPL library that you can include in your own code to get a runtime
  * interface to your program.
  *
  *   const repl = require("repl");
@@ -43,9 +43,28 @@
 'use strict';
 
 const {
+  ArrayPrototypeConcat,
+  ArrayPrototypeFilter,
+  ArrayPrototypeFindIndex,
+  ArrayPrototypeForEach,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  ArrayPrototypeReverse,
+  ArrayPrototypeShift,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSome,
+  ArrayPrototypeSort,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  Boolean,
   Error,
+  FunctionPrototypeBind,
   MathMax,
   NumberIsNaN,
+  NumberParseFloat,
   ObjectAssign,
   ObjectCreate,
   ObjectDefineProperty,
@@ -56,15 +75,32 @@ const {
   ObjectSetPrototypeOf,
   Promise,
   PromiseRace,
+  ReflectApply,
   RegExp,
-  Set,
+  RegExpPrototypeExec,
+  RegExpPrototypeSymbolReplace,
+  RegExpPrototypeTest,
+  SafeSet,
+  SafeWeakSet,
+  StringPrototypeCharAt,
+  StringPrototypeCodePointAt,
+  StringPrototypeEndsWith,
   StringPrototypeIncludes,
+  StringPrototypeMatch,
+  StringPrototypeRepeat,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+  StringPrototypeTrim,
+  StringPrototypeTrimLeft,
   Symbol,
-  WeakSet,
+  SyntaxError,
+  SyntaxErrorPrototype,
+  globalThis,
 } = primordials;
 
 const {
-  builtinLibs,
   makeRequireFunction,
   addBuiltinLibsToObject
 } = require('internal/modules/cjs/helpers');
@@ -86,8 +122,13 @@ const {
   commonPrefix
 } = require('internal/readline/utils');
 const { Console } = require('console');
-const cjsLoader = require('internal/modules/cjs/loader');
-const { Module: CJSModule } = cjsLoader;
+const CJSModule = require('internal/modules/cjs/loader').Module;
+let _builtinLibs = ArrayPrototypeFilter(
+  CJSModule.builtinModules,
+  (e) => !StringPrototypeStartsWith(e, '_') && !StringPrototypeIncludes(e, '/')
+);
+const nodeSchemeBuiltinLibs = ArrayPrototypeMap(
+  _builtinLibs, (lib) => `node:${lib}`);
 const domain = require('domain');
 let debug = require('internal/util/debuglog').debuglog('repl', (fn) => {
   debug = fn;
@@ -103,10 +144,14 @@ const {
   overrideStackTrace,
 } = require('internal/errors');
 const { sendInspectorCommand } = require('internal/util/inspector');
-const experimentalREPLAwait = require('internal/options').getOptionValue(
+const { getOptionValue } = require('internal/options');
+const experimentalREPLAwait = getOptionValue(
   '--experimental-repl-await'
 );
+const pendingDeprecation = getOptionValue('--pending-deprecation');
 const {
+  REPL_MODE_SLOPPY,
+  REPL_MODE_STRICT,
   isRecoverableError,
   kStandaloneREPL,
   setupPreview,
@@ -125,6 +170,11 @@ const {
 } = internalBinding('contextify');
 
 const history = require('internal/repl/history');
+const {
+  extensionFormatMap,
+  legacyExtensionFormatMap,
+} = require('internal/modules/esm/get_format');
+
 let nextREPLResourceNumber = 1;
 // This prevents v8 code cache from getting confused and using a different
 // cache from a resource of the same name
@@ -136,10 +186,10 @@ function getREPLResourceName() {
 let processTopLevelAwait;
 
 const globalBuiltins =
-  new Set(vm.runInNewContext('Object.getOwnPropertyNames(globalThis)'));
+  new SafeSet(vm.runInNewContext('Object.getOwnPropertyNames(globalThis)'));
 
 const parentModule = module;
-const domainSet = new WeakSet();
+const domainSet = new SafeWeakSet();
 
 const kBufferedCommandSymbol = Symbol('bufferedCommand');
 const kContextId = Symbol('contextId');
@@ -163,11 +213,9 @@ module.paths = CJSModule._nodeModulePaths(module.filename);
 // This is the default "writer" value, if none is passed in the REPL options,
 // and it can be overridden by custom print functions, such as `probe` or
 // `eyes.js`.
-const writer = exports.writer = (obj) => inspect(obj, writer.options);
+const writer = (obj) => inspect(obj, writer.options);
 writer.options = { ...inspect.defaultOptions, showProxy: true };
 
-exports._builtinLibs = builtinLibs;
-
 function REPLServer(prompt,
                     stream,
                     eval_,
@@ -227,13 +275,45 @@ function REPLServer(prompt,
   const preview = options.terminal &&
     (options.preview !== undefined ? !!options.preview : !eval_);
 
-  this.inputStream = options.input;
-  this.outputStream = options.output;
+  ObjectDefineProperty(this, 'inputStream', {
+    get: pendingDeprecation ?
+      deprecate(() => this.input,
+                'repl.inputStream and repl.outputStream are deprecated. ' +
+                  'Use repl.input and repl.output instead',
+                'DEP0141') :
+      () => this.input,
+    set: pendingDeprecation ?
+      deprecate((val) => this.input = val,
+                'repl.inputStream and repl.outputStream are deprecated. ' +
+                  'Use repl.input and repl.output instead',
+                'DEP0141') :
+      (val) => this.input = val,
+    enumerable: false,
+    configurable: true
+  });
+  ObjectDefineProperty(this, 'outputStream', {
+    get: pendingDeprecation ?
+      deprecate(() => this.output,
+                'repl.inputStream and repl.outputStream are deprecated. ' +
+                  'Use repl.input and repl.output instead',
+                'DEP0141') :
+      () => this.output,
+    set: pendingDeprecation ?
+      deprecate((val) => this.output = val,
+                'repl.inputStream and repl.outputStream are deprecated. ' +
+                  'Use repl.input and repl.output instead',
+                'DEP0141') :
+      (val) => this.output = val,
+    enumerable: false,
+    configurable: true
+  });
+
+  this.allowBlockingCompletions = !!options.allowBlockingCompletions;
   this.useColors = !!options.useColors;
   this._domain = options.domain || domain.create();
   this.useGlobal = !!useGlobal;
   this.ignoreUndefined = !!ignoreUndefined;
-  this.replMode = replMode || exports.REPL_MODE_SLOPPY;
+  this.replMode = replMode || module.exports.REPL_MODE_SLOPPY;
   this.underscoreAssigned = false;
   this.last = undefined;
   this.underscoreErrAssigned = false;
@@ -249,10 +329,14 @@ function REPLServer(prompt,
     throw new ERR_INVALID_REPL_EVAL_CONFIG();
   }
 
-  // Add this listener only once and use a WeakSet that contains the REPLs
-  // domains. Otherwise we'd have to add a single listener to each REPL instance
-  // and that could trigger the `MaxListenersExceededWarning`.
-  if (!options[kStandaloneREPL] && !addedNewListener) {
+  if (options[kStandaloneREPL]) {
+    // It is possible to introspect the running REPL accessing this variable
+    // from inside the REPL. This is useful for anyone working on the REPL.
+    module.exports.repl = this;
+  } else if (!addedNewListener) {
+    // Add this listener only once and use a WeakSet that contains the REPLs
+    // domains. Otherwise we'd have to add a single listener to each REPL
+    // instance and that could trigger the `MaxListenersExceededWarning`.
     process.prependListener('newListener', (event, listener) => {
       if (event === 'uncaughtException' &&
           process.domain &&
@@ -303,11 +387,11 @@ function REPLServer(prompt,
     paused = false;
     let entry;
     const tmpCompletionEnabled = self.isCompletionEnabled;
-    while (entry = pausedBuffer.shift()) {
-      const [type, payload, isCompletionEnabled] = entry;
+    while (entry = ArrayPrototypeShift(pausedBuffer)) {
+      const { 0: type, 1: payload, 2: isCompletionEnabled } = entry;
       switch (type) {
         case 'key': {
-          const [d, key] = payload;
+          const { 0: d, 1: key } = payload;
           self.isCompletionEnabled = isCompletionEnabled;
           self._ttyWrite(d, key);
           break;
@@ -337,21 +421,58 @@ function REPLServer(prompt,
     // to wrap it in parentheses, so that it will be interpreted as
     // an expression.  Note that if the above condition changes,
     // lib/internal/repl/utils.js needs to be changed to match.
-    if (/^\s*{/.test(code) && !/;\s*$/.test(code)) {
-      code = `(${code.trim()})\n`;
+    if (RegExpPrototypeTest(/^\s*{/, code) &&
+        !RegExpPrototypeTest(/;\s*$/, code)) {
+      code = `(${StringPrototypeTrim(code)})\n`;
       wrappedCmd = true;
     }
 
-    if (experimentalREPLAwait && code.includes('await')) {
+    if (experimentalREPLAwait && StringPrototypeIncludes(code, 'await')) {
       if (processTopLevelAwait === undefined) {
         ({ processTopLevelAwait } = require('internal/repl/await'));
       }
 
-      const potentialWrappedCode = processTopLevelAwait(code);
-      if (potentialWrappedCode !== null) {
-        code = potentialWrappedCode;
-        wrappedCmd = true;
-        awaitPromise = true;
+      try {
+        const potentialWrappedCode = processTopLevelAwait(code);
+        if (potentialWrappedCode !== null) {
+          code = potentialWrappedCode;
+          wrappedCmd = true;
+          awaitPromise = true;
+        }
+      } catch (e) {
+        let recoverableError = false;
+        if (e.name === 'SyntaxError') {
+          let parentURL;
+          try {
+            const { pathToFileURL } = require('url');
+            // Adding `/repl` prevents dynamic imports from loading relative
+            // to the parent of `process.cwd()`.
+            parentURL = pathToFileURL(path.join(process.cwd(), 'repl')).href;
+          } catch {
+          }
+
+          // Remove all "await"s and attempt running the script
+          // in order to detect if error is truly non recoverable
+          const fallbackCode = RegExpPrototypeSymbolReplace(/\bawait\b/g, code, '');
+          try {
+            vm.createScript(fallbackCode, {
+              filename: file,
+              displayErrors: true,
+              importModuleDynamically: async (specifier) => {
+                return asyncESM.ESMLoader.import(specifier, parentURL);
+              }
+            });
+          } catch (fallbackError) {
+            if (isRecoverableError(fallbackError, fallbackCode)) {
+              recoverableError = true;
+              err = new Recoverable(e);
+            }
+          }
+        }
+        if (!recoverableError) {
+          decorateErrorStack(e);
+          err = e;
+        }
       }
     }
 
@@ -359,52 +480,55 @@ function REPLServer(prompt,
     if (code === '\n')
       return cb(null);
 
-    let parentURL;
-    try {
-      const { pathToFileURL } = require('url');
-      // Adding `/repl` prevents dynamic imports from loading relative
-      // to the parent of `process.cwd()`.
-      parentURL = pathToFileURL(path.join(process.cwd(), 'repl')).href;
-    } catch {
-    }
-    while (true) {
+    if (err === null) {
+      let parentURL;
       try {
-        if (!/^\s*$/.test(code) &&
-            self.replMode === exports.REPL_MODE_STRICT) {
-          // "void 0" keeps the repl from returning "use strict" as the result
-          // value for statements and declarations that don't return a value.
-          code = `'use strict'; void 0;\n${code}`;
-        }
-        script = vm.createScript(code, {
-          filename: file,
-          displayErrors: true,
-          importModuleDynamically: async (specifier) => {
-            return asyncESM.ESMLoader.import(specifier, parentURL);
+        const { pathToFileURL } = require('url');
+        // Adding `/repl` prevents dynamic imports from loading relative
+        // to the parent of `process.cwd()`.
+        parentURL = pathToFileURL(path.join(process.cwd(), 'repl')).href;
+      } catch {
+      }
+      while (true) {
+        try {
+          if (self.replMode === module.exports.REPL_MODE_STRICT &&
+              !RegExpPrototypeTest(/^\s*$/, code)) {
+            // "void 0" keeps the repl from returning "use strict" as the result
+            // value for statements and declarations that don't return a value.
+            code = `'use strict'; void 0;\n${code}`;
           }
-        });
-      } catch (e) {
-        debug('parse error %j', code, e);
-        if (wrappedCmd) {
-          // Unwrap and try again
-          wrappedCmd = false;
-          awaitPromise = false;
-          code = input;
-          wrappedErr = e;
-          continue;
+          script = vm.createScript(code, {
+            filename: file,
+            displayErrors: true,
+            importModuleDynamically: async (specifier) => {
+              return asyncESM.ESMLoader.import(specifier, parentURL);
+            }
+          });
+        } catch (e) {
+          debug('parse error %j', code, e);
+          if (wrappedCmd) {
+            // Unwrap and try again
+            wrappedCmd = false;
+            awaitPromise = false;
+            code = input;
+            wrappedErr = e;
+            continue;
+          }
+          // Preserve original error for wrapped command
+          const error = wrappedErr || e;
+          if (isRecoverableError(error, code))
+            err = new Recoverable(error);
+          else
+            err = error;
         }
-        // Preserve original error for wrapped command
-        const error = wrappedErr || e;
-        if (isRecoverableError(error, code))
-          err = new Recoverable(error);
-        else
-          err = error;
+        break;
       }
-      break;
     }
 
     // This will set the values from `savedRegExMatches` to corresponding
     // predefined RegExp properties `RegExp.$1`, `RegExp.$2` ... `RegExp.$9`
-    regExMatcher.test(savedRegExMatches.join(sep));
+    RegExpPrototypeTest(regExMatcher,
+                        ArrayPrototypeJoin(savedRegExMatches, sep));
 
     let finished = false;
     function finishExecution(err, result) {
@@ -484,21 +608,24 @@ function REPLServer(prompt,
           promise = PromiseRace([promise, interrupt]);
         }
 
-        promise.then((result) => {
-          finishExecution(null, result);
-        }, (err) => {
-          if (err && process.domain) {
-            debug('not recoverable, send to domain');
-            process.domain.emit('error', err);
-            process.domain.exit();
-            return;
+        (async () => {
+          try {
+            const result = await promise;
+            finishExecution(null, result);
+          } catch (err) {
+            if (err && process.domain) {
+              debug('not recoverable, send to domain');
+              process.domain.emit('error', err);
+              process.domain.exit();
+              return;
+            }
+            finishExecution(err);
+          } finally {
+            // Remove prioritized SIGINT listener if it was not called.
+            prioritizedSigintQueue.delete(sigintListener);
+            unpause();
           }
-          finishExecution(err);
-        }).finally(() => {
-          // Remove prioritized SIGINT listener if it was not called.
-          prioritizedSigintQueue.delete(sigintListener);
-          unpause();
-        });
+        })();
       }
     }
 
@@ -519,11 +646,12 @@ function REPLServer(prompt,
         if (typeof stackFrames === 'object') {
           // Search from the bottom of the call stack to
           // find the first frame with a null function name
-          const idx = stackFrames
-            .reverse()
-            .findIndex((frame) => frame.getFunctionName() === null);
+          const idx = ArrayPrototypeFindIndex(
+            ArrayPrototypeReverse(stackFrames),
+            (frame) => frame.getFunctionName() === null
+          );
           // If found, get rid of it and everything below it
-          frames = stackFrames.splice(idx + 1);
+          frames = ArrayPrototypeSplice(stackFrames, idx + 1);
         } else {
           frames = stackFrames;
         }
@@ -533,8 +661,8 @@ function REPLServer(prompt,
         if (typeof Error.prepareStackTrace === 'function') {
           return Error.prepareStackTrace(error, frames);
         }
-        frames.push(error);
-        return frames.reverse().join('\n    at ');
+        ArrayPrototypePush(frames, error);
+        return ArrayPrototypeJoin(ArrayPrototypeReverse(frames), '\n    at ');
       });
       decorateErrorStack(e);
 
@@ -547,27 +675,31 @@ function REPLServer(prompt,
         if (e.stack) {
           if (e.name === 'SyntaxError') {
             // Remove stack trace.
-            e.stack = e.stack
-              .replace(/^REPL\d+:\d+\r?\n/, '')
-              .replace(/^\s+at\s.*\n?/gm, '');
+            e.stack = StringPrototypeReplace(StringPrototypeReplace(e.stack,
+                                                                    /^REPL\d+:\d+\r?\n/, ''),
+                                             /^\s+at\s.*\n?/gm, '');
             const importErrorStr = 'Cannot use import statement outside a ' +
               'module';
             if (StringPrototypeIncludes(e.message, importErrorStr)) {
               e.message = 'Cannot use import statement inside the Node.js ' +
-                'repl, alternatively use dynamic import';
-              e.stack = e.stack.replace(/SyntaxError:.*\n/,
-                                        `SyntaxError: ${e.message}\n`);
+                'REPL, alternatively use dynamic import';
+              e.stack = StringPrototypeReplace(e.stack,
+                                               /SyntaxError:.*\n/,
+                                               `SyntaxError: ${e.message}\n`);
             }
-          } else if (self.replMode === exports.REPL_MODE_STRICT) {
-            e.stack = e.stack.replace(/(\s+at\s+REPL\d+:)(\d+)/,
-                                      (_, pre, line) => pre + (line - 1));
+          } else if (self.replMode === module.exports.REPL_MODE_STRICT) {
+            e.stack = StringPrototypeReplace(
+              e.stack,
+              /(\s+at\s+REPL\d+:)(\d+)/,
+              (_, pre, line) => pre + (line - 1)
+            );
           }
         }
         errStack = self.writer(e);
 
         // Remove one line error braces to keep the old style in place.
-        if (errStack[errStack.length - 1] === ']') {
-          errStack = errStack.slice(1, -1);
+        if (errStack[0] === '[' && errStack[errStack.length - 1] === ']') {
+          errStack = StringPrototypeSlice(errStack, 1, -1);
         }
       }
     }
@@ -588,12 +720,13 @@ function REPLServer(prompt,
       if (errStack === '') {
         errStack = self.writer(e);
       }
-      const lines = errStack.split(/(?<=\n)/);
+      const lines = StringPrototypeSplit(errStack, /(?<=\n)/);
       let matched = false;
 
       errStack = '';
-      for (const line of lines) {
-        if (!matched && /^\[?([A-Z][a-z0-9_]*)*Error/.test(line)) {
+      ArrayPrototypeForEach(lines, (line) => {
+        if (!matched &&
+            RegExpPrototypeTest(/^\[?([A-Z][a-z0-9_]*)*Error/, line)) {
           errStack += writer.options.breakLength >= line.length ?
             `Uncaught ${line}` :
             `Uncaught:\n${line}`;
@@ -601,23 +734,20 @@ function REPLServer(prompt,
         } else {
           errStack += line;
         }
-      }
+      });
       if (!matched) {
         const ln = lines.length === 1 ? ' ' : ':\n';
         errStack = `Uncaught${ln}${errStack}`;
       }
       // Normalize line endings.
-      errStack += errStack.endsWith('\n') ? '' : '\n';
-      self.outputStream.write(errStack);
+      errStack += StringPrototypeEndsWith(errStack, '\n') ? '' : '\n';
+      self.output.write(errStack);
       self.clearBufferedCommand();
       self.lines.level = [];
       self.displayPrompt();
     }
   });
 
-  self.resetContext();
-  self.lines.level = [];
-
   self.clearBufferedCommand();
   ObjectDefineProperty(this, 'bufferedCommand', {
     get: deprecate(() => self[kBufferedCommandSymbol],
@@ -629,29 +759,27 @@ function REPLServer(prompt,
     enumerable: true
   });
 
-  // Figure out which "complete" function to use.
-  self.completer = (typeof options.completer === 'function') ?
-    options.completer : completer;
-
   function completer(text, cb) {
-    complete.call(self, text, self.editorMode ?
-      self.completeOnEditorMode(cb) : cb);
+    ReflectApply(complete, self,
+                 [text, self.editorMode ? self.completeOnEditorMode(cb) : cb]);
   }
 
-  Interface.call(this, {
-    input: self.inputStream,
-    output: self.outputStream,
-    completer: self.completer,
+  ReflectApply(Interface, this, [{
+    input: options.input,
+    output: options.output,
+    completer: options.completer || completer,
     terminal: options.terminal,
     historySize: options.historySize,
     prompt
-  });
+  }]);
+
+  self.resetContext();
 
   this.commands = ObjectCreate(null);
   defineDefaultCommands(this);
 
   // Figure out which "writer" function to use
-  self.writer = options.writer || exports.writer;
+  self.writer = options.writer || module.exports.writer;
 
   if (self.writer === writer) {
     // Conditionally turn on ANSI coloring.
@@ -677,7 +805,7 @@ function REPLServer(prompt,
   function _parseREPLKeyword(keyword, rest) {
     const cmd = this.commands[keyword];
     if (cmd) {
-      cmd.action.call(this, rest);
+      ReflectApply(cmd.action, this, [rest]);
       return true;
     }
     return false;
@@ -690,7 +818,7 @@ function REPLServer(prompt,
 
   self.on('close', function emitExit() {
     if (paused) {
-      pausedBuffer.push(['close']);
+      ArrayPrototypePush(pausedBuffer, ['close']);
       return;
     }
     self.emit('exit');
@@ -698,7 +826,7 @@ function REPLServer(prompt,
 
   let sawSIGINT = false;
   let sawCtrlD = false;
-  const prioritizedSigintQueue = new Set();
+  const prioritizedSigintQueue = new SafeSet();
   self.on('SIGINT', function onSigInt() {
     if (prioritizedSigintQueue.size > 0) {
       for (const task of prioritizedSigintQueue) {
@@ -718,7 +846,9 @@ function REPLServer(prompt,
         sawSIGINT = false;
         return;
       }
-      self.output.write('(To exit, press ^C again or ^D or type .exit)\n');
+      self.output.write(
+        '(To exit, press Ctrl+C again or Ctrl+D or type .exit)\n'
+      );
       sawSIGINT = true;
     } else {
       sawSIGINT = false;
@@ -738,33 +868,35 @@ function REPLServer(prompt,
       self[kBufferedCommandSymbol] += cmd + '\n';
 
       // code alignment
-      const matches = self._sawKeyPress ? cmd.match(/^\s+/) : null;
+      const matches = self._sawKeyPress ?
+        StringPrototypeMatch(cmd, /^\s+/) : null;
       if (matches) {
         const prefix = matches[0];
         self.write(prefix);
         self.line = prefix;
         self.cursor = prefix.length;
       }
-      _memory.call(self, cmd);
+      ReflectApply(_memory, self, [cmd]);
       return;
     }
 
     // Check REPL keywords and empty lines against a trimmed line input.
-    const trimmedCmd = cmd.trim();
+    const trimmedCmd = StringPrototypeTrim(cmd);
 
     // Check to see if a REPL keyword was used. If it returns true,
     // display next prompt and return.
     if (trimmedCmd) {
-      if (trimmedCmd.charAt(0) === '.' && trimmedCmd.charAt(1) !== '.' &&
-          NumberIsNaN(parseFloat(trimmedCmd))) {
-        const matches = trimmedCmd.match(/^\.([^\s]+)\s*(.*)$/);
+      if (StringPrototypeCharAt(trimmedCmd, 0) === '.' &&
+          StringPrototypeCharAt(trimmedCmd, 1) !== '.' &&
+          NumberIsNaN(NumberParseFloat(trimmedCmd))) {
+        const matches = StringPrototypeMatch(trimmedCmd, /^\.([^\s]+)\s*(.*)$/);
         const keyword = matches && matches[1];
         const rest = matches && matches[2];
-        if (_parseREPLKeyword.call(self, keyword, rest) === true) {
+        if (ReflectApply(_parseREPLKeyword, self, [keyword, rest]) === true) {
           return;
         }
         if (!self[kBufferedCommandSymbol]) {
-          self.outputStream.write('Invalid REPL keyword\n');
+          self.output.write('Invalid REPL keyword\n');
           finish(null);
           return;
         }
@@ -778,12 +910,13 @@ function REPLServer(prompt,
 
     function finish(e, ret) {
       debug('finish', e, ret);
-      _memory.call(self, cmd);
+      ReflectApply(_memory, self, [cmd]);
 
-      if (e && !self[kBufferedCommandSymbol] && cmd.trim().startsWith('npm ')) {
-        self.outputStream.write('npm should be run outside of the ' +
-                                'node repl, in your normal shell.\n' +
-                                '(Press Control-D to exit.)\n');
+      if (e && !self[kBufferedCommandSymbol] &&
+          StringPrototypeStartsWith(StringPrototypeTrim(cmd), 'npm ')) {
+        self.output.write('npm should be run outside of the ' +
+                                'Node.js REPL, in your normal shell.\n' +
+                                '(Press Ctrl+D to exit.)\n');
         self.displayPrompt();
         return;
       }
@@ -816,20 +949,23 @@ function REPLServer(prompt,
         if (!self.underscoreAssigned) {
           self.last = ret;
         }
-        self.outputStream.write(self.writer(ret) + '\n');
+        self.output.write(self.writer(ret) + '\n');
       }
 
-      // Display prompt again
-      self.displayPrompt();
+      // Display prompt again (unless we already did by emitting the 'error'
+      // event on the domain instance).
+      if (!e) {
+        self.displayPrompt();
+      }
     }
   });
 
   self.on('SIGCONT', function onSigCont() {
     if (self.editorMode) {
-      self.outputStream.write(`${self._initialPrompt}.editor\n`);
-      self.outputStream.write(
-        '// Entering editor mode (^D to finish, ^C to cancel)\n');
-      self.outputStream.write(`${self[kBufferedCommandSymbol]}\n`);
+      self.output.write(`${self._initialPrompt}.editor\n`);
+      self.output.write(
+        '// Entering editor mode (Ctrl+D to finish, Ctrl+C to cancel)\n');
+      self.output.write(`${self[kBufferedCommandSymbol]}\n`);
       self.prompt(true);
     } else {
       self.displayPrompt(true);
@@ -849,11 +985,12 @@ function REPLServer(prompt,
   );
 
   // Wrap readline tty to enable editor mode and pausing.
-  const ttyWrite = self._ttyWrite.bind(self);
+  const ttyWrite = FunctionPrototypeBind(self._ttyWrite, self);
   self._ttyWrite = (d, key) => {
     key = key || {};
     if (paused && !(self.breakEvalOnSigint && key.ctrl && key.name === 'c')) {
-      pausedBuffer.push(['key', [d, key], self.isCompletionEnabled]);
+      ArrayPrototypePush(pausedBuffer,
+                         ['key', [d, key], self.isCompletionEnabled]);
       return;
     }
     if (!self.editorMode || !self.terminal) {
@@ -862,7 +999,7 @@ function REPLServer(prompt,
           self.cursor === 0 && self.line.length === 0) {
         self.clearLine();
       }
-      clearPreview();
+      clearPreview(key);
       if (!reverseSearch(d, key)) {
         ttyWrite(d, key);
         showPreview();
@@ -907,28 +1044,12 @@ function REPLServer(prompt,
 ObjectSetPrototypeOf(REPLServer.prototype, Interface.prototype);
 ObjectSetPrototypeOf(REPLServer, Interface);
 
-exports.REPLServer = REPLServer;
-
-exports.REPL_MODE_SLOPPY = Symbol('repl-sloppy');
-exports.REPL_MODE_STRICT = Symbol('repl-strict');
-
 // Prompt is a string to print on each line for the prompt,
 // source is a stream to use for I/O, defaulting to stdin/stdout.
-exports.start = function(prompt,
-                         source,
-                         eval_,
-                         useGlobal,
-                         ignoreUndefined,
-                         replMode) {
-  const repl = new REPLServer(prompt,
-                              source,
-                              eval_,
-                              useGlobal,
-                              ignoreUndefined,
-                              replMode);
-  if (!exports.repl) exports.repl = repl;
-  return repl;
-};
+function start(prompt, source, eval_, useGlobal, ignoreUndefined, replMode) {
+  return new REPLServer(
+    prompt, source, eval_, useGlobal, ignoreUndefined, replMode);
+}
 
 REPLServer.prototype.setupHistory = function setupHistory(historyFile, cb) {
   history(this, historyFile, cb);
@@ -942,20 +1063,20 @@ REPLServer.prototype.close = function close() {
   if (this.terminal && this._flushing && !this._closingOnFlush) {
     this._closingOnFlush = true;
     this.once('flushHistory', () =>
-      Interface.prototype.close.call(this)
+      ReflectApply(Interface.prototype.close, this, [])
     );
 
     return;
   }
   process.nextTick(() =>
-    Interface.prototype.close.call(this)
+    ReflectApply(Interface.prototype.close, this, [])
   );
 };
 
 REPLServer.prototype.createContext = function() {
   let context;
   if (this.useGlobal) {
-    context = global;
+    context = globalThis;
   } else {
     sendInspectorCommand((session) => {
       session.post('Runtime.enable');
@@ -967,15 +1088,15 @@ REPLServer.prototype.createContext = function() {
     }, () => {
       context = vm.createContext();
     });
-    for (const name of ObjectGetOwnPropertyNames(global)) {
+    ArrayPrototypeForEach(ObjectGetOwnPropertyNames(globalThis), (name) => {
       // Only set properties that do not already exist as a global builtin.
       if (!globalBuiltins.has(name)) {
         ObjectDefineProperty(context, name,
-                             ObjectGetOwnPropertyDescriptor(global, name));
+                             ObjectGetOwnPropertyDescriptor(globalThis, name));
       }
-    }
+    });
     context.global = context;
-    const _console = new Console(this.outputStream);
+    const _console = new Console(this.output);
     ObjectDefineProperty(context, 'console', {
       configurable: true,
       writable: true,
@@ -983,18 +1104,18 @@ REPLServer.prototype.createContext = function() {
     });
   }
 
-  const module = new CJSModule('<repl>');
-  module.paths = CJSModule._resolveLookupPaths('<repl>', parentModule);
+  const replModule = new CJSModule('<repl>');
+  replModule.paths = CJSModule._resolveLookupPaths('<repl>', parentModule);
 
   ObjectDefineProperty(context, 'module', {
     configurable: true,
     writable: true,
-    value: module
+    value: replModule
   });
   ObjectDefineProperty(context, 'require', {
     configurable: true,
     writable: true,
-    value: makeRequireFunction(module)
+    value: makeRequireFunction(replModule)
   });
 
   addBuiltinLibsToObject(context);
@@ -1006,6 +1127,7 @@ REPLServer.prototype.resetContext = function() {
   this.context = this.createContext();
   this.underscoreAssigned = false;
   this.underscoreErrAssigned = false;
+  // TODO(BridgeAR): Deprecate the lines.
   this.lines = [];
   this.lines.level = [];
 
@@ -1016,7 +1138,7 @@ REPLServer.prototype.resetContext = function() {
       this.last = value;
       if (!this.underscoreAssigned) {
         this.underscoreAssigned = true;
-        this.outputStream.write('Expression assignment to _ now disabled.\n');
+        this.output.write('Expression assignment to _ now disabled.\n');
       }
     }
   });
@@ -1028,7 +1150,7 @@ REPLServer.prototype.resetContext = function() {
       this.lastError = value;
       if (!this.underscoreErrAssigned) {
         this.underscoreErrAssigned = true;
-        this.outputStream.write(
+        this.output.write(
           'Expression assignment to _error now disabled.\n');
       }
     }
@@ -1043,19 +1165,19 @@ REPLServer.prototype.displayPrompt = function(preserveCursor) {
   if (this[kBufferedCommandSymbol].length) {
     prompt = '...';
     const len = this.lines.level.length ? this.lines.level.length - 1 : 0;
-    const levelInd = '..'.repeat(len);
+    const levelInd = StringPrototypeRepeat('..', len);
     prompt += levelInd + ' ';
   }
 
   // Do not overwrite `_initialPrompt` here
-  Interface.prototype.setPrompt.call(this, prompt);
+  ReflectApply(Interface.prototype.setPrompt, this, [prompt]);
   this.prompt(preserveCursor);
 };
 
 // When invoked as an API method, overwrite _initialPrompt
 REPLServer.prototype.setPrompt = function setPrompt(prompt) {
   this._initialPrompt = prompt;
-  Interface.prototype.setPrompt.call(this, prompt);
+  ReflectApply(Interface.prototype.setPrompt, this, [prompt]);
 };
 
 REPLServer.prototype.turnOffEditorMode = deprecate(
@@ -1063,22 +1185,24 @@ REPLServer.prototype.turnOffEditorMode = deprecate(
   'REPLServer.turnOffEditorMode() is deprecated',
   'DEP0078');
 
-const requireRE = /\brequire\s*\(['"](([\w@./-]+\/)?(?:[\w@./-]*))/;
+const importRE = /\bimport\s*\(\s*['"`](([\w@./:-]+\/)?(?:[\w@./:-]*))(?![^'"`])$/;
+const requireRE = /\brequire\s*\(\s*['"`](([\w@./:-]+\/)?(?:[\w@./:-]*))(?![^'"`])$/;
 const fsAutoCompleteRE = /fs(?:\.promises)?\.\s*[a-z][a-zA-Z]+\(\s*["'](.*)/;
 const simpleExpressionRE =
-    /(?:[a-zA-Z_$](?:\w|\$)*\.)*[a-zA-Z_$](?:\w|\$)*\.?$/;
+    /(?:[a-zA-Z_$](?:\w|\$)*\??\.)*[a-zA-Z_$](?:\w|\$)*\??\.?$/;
+const versionedFileNamesRe = /-\d+\.\d+/;
 
 function isIdentifier(str) {
   if (str === '') {
     return false;
   }
-  const first = str.codePointAt(0);
+  const first = StringPrototypeCodePointAt(str, 0);
   if (!isIdentifierStart(first)) {
     return false;
   }
   const firstLen = first > 0xffff ? 2 : 1;
   for (let i = firstLen; i < str.length; i += 1) {
-    const cp = str.codePointAt(i);
+    const cp = StringPrototypeCodePointAt(str, i);
     if (!isIdentifierChar(cp)) {
       return false;
     }
@@ -1089,10 +1213,31 @@ function isIdentifier(str) {
   return true;
 }
 
+function isNotLegacyObjectPrototypeMethod(str) {
+  return isIdentifier(str) &&
+    str !== '__defineGetter__' &&
+    str !== '__defineSetter__' &&
+    str !== '__lookupGetter__' &&
+    str !== '__lookupSetter__';
+}
+
 function filteredOwnPropertyNames(obj) {
   if (!obj) return [];
+  // `Object.prototype` is the only non-contrived object that fulfills
+  // `Object.getPrototypeOf(X) === null &&
+  //  Object.getPrototypeOf(Object.getPrototypeOf(X.constructor)) === X`.
+  let isObjectPrototype = false;
+  if (ObjectGetPrototypeOf(obj) === null) {
+    const ctorDescriptor = ObjectGetOwnPropertyDescriptor(obj, 'constructor');
+    if (ctorDescriptor && ctorDescriptor.value) {
+      const ctorProto = ObjectGetPrototypeOf(ctorDescriptor.value);
+      isObjectPrototype = ctorProto && ObjectGetPrototypeOf(ctorProto) === obj;
+    }
+  }
   const filter = ALL_PROPERTIES | SKIP_SYMBOLS;
-  return getOwnNonIndexProperties(obj, filter).filter(isIdentifier);
+  return ArrayPrototypeFilter(
+    getOwnNonIndexProperties(obj, filter),
+    isObjectPrototype ? isNotLegacyObjectPrototypeMethod : isIdentifier);
 }
 
 function getGlobalLexicalScopeNames(contextId) {
@@ -1108,11 +1253,36 @@ function getGlobalLexicalScopeNames(contextId) {
 }
 
 REPLServer.prototype.complete = function() {
-  this.completer.apply(this, arguments);
+  ReflectApply(this.completer, this, arguments);
 };
 
-// TODO: Native module names should be auto-resolved.
-// That improves the auto completion.
+function gracefulReaddir(...args) {
+  try {
+    return ReflectApply(fs.readdirSync, null, args);
+  } catch {}
+}
+
+function completeFSFunctions(line) {
+  let baseName = '';
+  let filePath = StringPrototypeMatch(line, fsAutoCompleteRE)[1];
+  let fileList = gracefulReaddir(filePath, { withFileTypes: true });
+
+  if (!fileList) {
+    baseName = path.basename(filePath);
+    filePath = path.dirname(filePath);
+    fileList = gracefulReaddir(filePath, { withFileTypes: true }) || [];
+  }
+
+  const completions = ArrayPrototypeMap(
+    ArrayPrototypeFilter(
+      fileList,
+      (dirent) => StringPrototypeStartsWith(dirent.name, baseName)
+    ),
+    (d) => d.name
+  );
+
+  return [[completions], baseName];
+}
 
 // Provide a list of completions for the given leading text. This is
 // given to the readline interface for handling tab completion.
@@ -1130,30 +1300,28 @@ function complete(line, callback) {
   let completeOn, group;
 
   // Ignore right whitespace. It could change the outcome.
-  line = line.trimLeft();
+  line = StringPrototypeTrimLeft(line);
 
   // REPL commands (e.g. ".break").
-  let filter;
-  let match = line.match(/^\s*\.(\w*)$/);
-  if (match) {
-    completionGroups.push(ObjectKeys(this.commands));
-    completeOn = match[1];
-    if (match[1].length) {
-      filter = match[1];
+  let filter = '';
+  if (RegExpPrototypeTest(/^\s*\.(\w*)$/, line)) {
+    ArrayPrototypePush(completionGroups, ObjectKeys(this.commands));
+    completeOn = StringPrototypeMatch(line, /^\s*\.(\w*)$/)[1];
+    if (completeOn.length) {
+      filter = completeOn;
     }
-
-    completionGroupsLoaded();
-  } else if (match = line.match(requireRE)) {
+  } else if (RegExpPrototypeTest(requireRE, line) &&
+             this.allowBlockingCompletions) {
     // require('...<Tab>')
-    const exts = ObjectKeys(this.context.require.extensions);
-    const indexRe = new RegExp('^index(?:' + exts.map(regexpEscape).join('|') +
-                             ')$');
-    const versionedFileNamesRe = /-\d+\.\d+/;
+    const extensions = ObjectKeys(this.context.require.extensions);
+    const indexes = ArrayPrototypeMap(extensions,
+                                      (extension) => `index${extension}`);
+    ArrayPrototypePush(indexes, 'package.json', 'index');
 
+    const match = StringPrototypeMatch(line, requireRE);
     completeOn = match[1];
     const subdir = match[2] || '';
-    filter = match[1];
-    let dir, files, subfiles, isDirectory;
+    filter = completeOn;
     group = [];
     let paths = [];
 
@@ -1161,83 +1329,119 @@ function complete(line, callback) {
       group = ['./', '../'];
     } else if (completeOn === '..') {
       group = ['../'];
-    } else if (/^\.\.?\//.test(completeOn)) {
+    } else if (RegExpPrototypeTest(/^\.\.?\//, completeOn)) {
       paths = [process.cwd()];
     } else {
-      paths = module.paths.concat(CJSModule.globalPaths);
+      paths = ArrayPrototypeConcat(module.paths, CJSModule.globalPaths);
     }
 
-    for (let i = 0; i < paths.length; i++) {
-      dir = path.resolve(paths[i], subdir);
-      try {
-        files = fs.readdirSync(dir);
-      } catch {
-        continue;
-      }
-      for (let f = 0; f < files.length; f++) {
-        const name = files[f];
-        const ext = path.extname(name);
-        const base = name.slice(0, -ext.length);
-        if (versionedFileNamesRe.test(base) || name === '.npm') {
+    ArrayPrototypeForEach(paths, (dir) => {
+      dir = path.resolve(dir, subdir);
+      const dirents = gracefulReaddir(dir, { withFileTypes: true }) || [];
+      ArrayPrototypeForEach(dirents, (dirent) => {
+        if (RegExpPrototypeTest(versionedFileNamesRe, dirent.name) ||
+            dirent.name === '.npm') {
           // Exclude versioned names that 'npm' installs.
-          continue;
-        }
-        const abs = path.resolve(dir, name);
-        try {
-          isDirectory = fs.statSync(abs).isDirectory();
-        } catch {
-          continue;
+          return;
         }
-        if (isDirectory) {
-          group.push(subdir + name + '/');
-          try {
-            subfiles = fs.readdirSync(abs);
-          } catch {
-            continue;
-          }
-          for (let s = 0; s < subfiles.length; s++) {
-            if (indexRe.test(subfiles[s])) {
-              group.push(subdir + name);
-            }
+        const extension = path.extname(dirent.name);
+        const base = StringPrototypeSlice(dirent.name, 0, -extension.length);
+        if (!dirent.isDirectory()) {
+          if (StringPrototypeIncludes(extensions, extension) &&
+              (!subdir || base !== 'index')) {
+            ArrayPrototypePush(group, `${subdir}${base}`);
           }
-        } else if (exts.includes(ext) && (!subdir || base !== 'index')) {
-          group.push(subdir + base);
+          return;
         }
-      }
-    }
+        ArrayPrototypePush(group, `${subdir}${dirent.name}/`);
+        const absolute = path.resolve(dir, dirent.name);
+        if (ArrayPrototypeSome(
+          gracefulReaddir(absolute) || [],
+          (subfile) => ArrayPrototypeIncludes(indexes, subfile)
+        )) {
+          ArrayPrototypePush(group, `${subdir}${dirent.name}`);
+        }
+      });
+    });
     if (group.length) {
-      completionGroups.push(group);
+      ArrayPrototypePush(completionGroups, group);
     }
 
     if (!subdir) {
-      completionGroups.push(exports._builtinLibs);
+      ArrayPrototypePush(completionGroups, _builtinLibs, nodeSchemeBuiltinLibs);
+    }
+  } else if (RegExpPrototypeTest(importRE, line) &&
+             this.allowBlockingCompletions) {
+    // import('...<Tab>')
+    // File extensions that can be imported:
+    const extensions = ObjectKeys(
+      getOptionValue('--experimental-specifier-resolution') === 'node' ?
+        legacyExtensionFormatMap :
+        extensionFormatMap);
+
+    // Only used when loading bare module specifiers from `node_modules`:
+    const indexes = ArrayPrototypeMap(extensions, (ext) => `index${ext}`);
+    ArrayPrototypePush(indexes, 'package.json');
+
+    const match = StringPrototypeMatch(line, importRE);
+    completeOn = match[1];
+    const subdir = match[2] || '';
+    filter = completeOn;
+    group = [];
+    let paths = [];
+    if (completeOn === '.') {
+      group = ['./', '../'];
+    } else if (completeOn === '..') {
+      group = ['../'];
+    } else if (RegExpPrototypeTest(/^\.\.?\//, completeOn)) {
+      paths = [process.cwd()];
+    } else {
+      paths = ArrayPrototypeSlice(module.paths);
     }
 
-    completionGroupsLoaded();
-  } else if (match = line.match(fsAutoCompleteRE)) {
+    ArrayPrototypeForEach(paths, (dir) => {
+      dir = path.resolve(dir, subdir);
+      const isInNodeModules = path.basename(dir) === 'node_modules';
+      const dirents = gracefulReaddir(dir, { withFileTypes: true }) || [];
+      ArrayPrototypeForEach(dirents, (dirent) => {
+        const { name } = dirent;
+        if (RegExpPrototypeTest(versionedFileNamesRe, name) ||
+            name === '.npm') {
+          // Exclude versioned names that 'npm' installs.
+          return;
+        }
+
+        if (!dirent.isDirectory()) {
+          const extension = path.extname(name);
+          if (StringPrototypeIncludes(extensions, extension)) {
+            ArrayPrototypePush(group, `${subdir}${name}`);
+          }
+          return;
+        }
 
-    let filePath = match[1];
-    let fileList;
-    filter = '';
+        ArrayPrototypePush(group, `${subdir}${name}/`);
+        if (!subdir && isInNodeModules) {
+          const absolute = path.resolve(dir, name);
+          const subfiles = gracefulReaddir(absolute) || [];
+          if (ArrayPrototypeSome(subfiles, (subfile) => {
+            return ArrayPrototypeIncludes(indexes, subfile);
+          })) {
+            ArrayPrototypePush(group, `${subdir}${name}`);
+          }
+        }
+      });
+    });
 
-    try {
-      fileList = fs.readdirSync(filePath, { withFileTypes: true });
-      completionGroups.push(fileList.map((dirent) => dirent.name));
-      completeOn = '';
-    } catch {
-      try {
-        const baseName = path.basename(filePath);
-        filePath = path.dirname(filePath);
-        fileList = fs.readdirSync(filePath, { withFileTypes: true });
-        const filteredValue = fileList.filter((d) =>
-          d.name.startsWith(baseName))
-          .map((d) => d.name);
-        completionGroups.push(filteredValue);
-        completeOn = baseName;
-      } catch {}
+    if (group.length) {
+      ArrayPrototypePush(completionGroups, group);
     }
 
-    completionGroupsLoaded();
+    if (!subdir) {
+      ArrayPrototypePush(completionGroups, _builtinLibs, nodeSchemeBuiltinLibs);
+    }
+  } else if (RegExpPrototypeTest(fsAutoCompleteRE, line) &&
+             this.allowBlockingCompletions) {
+    ({ 0: completionGroups, 1: completeOn } = completeFSFunctions(line));
   // Handle variable member lookup.
   // We support simple chained expressions like the following (no function
   // calls, etc.). That is for simplicity and also because we *eval* that
@@ -1248,132 +1452,138 @@ function complete(line, callback) {
   //   spam.eggs.<|>  # completions for 'spam.eggs' with filter ''
   //   foo<|>         # all scope vars with filter 'foo'
   //   foo.<|>        # completions for 'foo' with filter ''
-  } else if (line.length === 0 || /\w|\.|\$/.test(line[line.length - 1])) {
-    match = simpleExpressionRE.exec(line);
+  } else if (line.length === 0 ||
+             RegExpPrototypeTest(/\w|\.|\$/, line[line.length - 1])) {
+    const { 0: match } = RegExpPrototypeExec(simpleExpressionRE, line) || [''];
     if (line.length !== 0 && !match) {
       completionGroupsLoaded();
       return;
     }
-    let expr;
-    completeOn = (match ? match[0] : '');
-    if (line.length === 0) {
-      filter = '';
-      expr = '';
-    } else if (line[line.length - 1] === '.') {
-      filter = '';
-      expr = match[0].slice(0, match[0].length - 1);
-    } else {
-      const bits = match[0].split('.');
-      filter = bits.pop();
-      expr = bits.join('.');
+    let expr = '';
+    completeOn = match;
+    if (StringPrototypeEndsWith(line, '.')) {
+      expr = StringPrototypeSlice(match, 0, -1);
+    } else if (line.length !== 0) {
+      const bits = StringPrototypeSplit(match, '.');
+      filter = ArrayPrototypePop(bits);
+      expr = ArrayPrototypeJoin(bits, '.');
     }
 
     // Resolve expr and get its completions.
-    const memberGroups = [];
     if (!expr) {
       // Get global vars synchronously
-      completionGroups.push(getGlobalLexicalScopeNames(this[kContextId]));
+      ArrayPrototypePush(completionGroups,
+                         getGlobalLexicalScopeNames(this[kContextId]));
       let contextProto = this.context;
       while (contextProto = ObjectGetPrototypeOf(contextProto)) {
-        completionGroups.push(filteredOwnPropertyNames(contextProto));
+        ArrayPrototypePush(completionGroups,
+                           filteredOwnPropertyNames(contextProto));
       }
       const contextOwnNames = filteredOwnPropertyNames(this.context);
       if (!this.useGlobal) {
         // When the context is not `global`, builtins are not own
         // properties of it.
-        contextOwnNames.push(...globalBuiltins);
+        // `globalBuiltins` is a `SafeSet`, not an Array-like.
+        ArrayPrototypePush(contextOwnNames, ...globalBuiltins);
       }
-      completionGroups.push(contextOwnNames);
+      ArrayPrototypePush(completionGroups, contextOwnNames);
       if (filter !== '') addCommonWords(completionGroups);
       completionGroupsLoaded();
       return;
     }
 
+    let chaining = '.';
+    if (StringPrototypeEndsWith(expr, '?')) {
+      expr = StringPrototypeSlice(expr, 0, -1);
+      chaining = '?.';
+    }
+
+    const memberGroups = [];
     const evalExpr = `try { ${expr} } catch {}`;
     this.eval(evalExpr, this.context, getREPLResourceName(), (e, obj) => {
-      if (obj != null) {
-        if (typeof obj === 'object' || typeof obj === 'function') {
-          try {
-            memberGroups.push(filteredOwnPropertyNames(obj));
-          } catch {
-            // Probably a Proxy object without `getOwnPropertyNames` trap.
-            // We simply ignore it here, as we don't want to break the
-            // autocompletion. Fixes the bug
-            // https://github.com/nodejs/node/issues/2119
-          }
+      try {
+        let p;
+        if ((typeof obj === 'object' && obj !== null) ||
+            typeof obj === 'function') {
+          memberGroups.push(filteredOwnPropertyNames(obj));
+          p = ObjectGetPrototypeOf(obj);
+        } else {
+          p = obj.constructor ? obj.constructor.prototype : null;
         }
-        // Works for non-objects
-        try {
-          let p;
-          if (typeof obj === 'object' || typeof obj === 'function') {
-            p = ObjectGetPrototypeOf(obj);
-          } else {
-            p = obj.constructor ? obj.constructor.prototype : null;
-          }
-          // Circular refs possible? Let's guard against that.
-          let sentinel = 5;
-          while (p !== null && sentinel-- !== 0) {
-            memberGroups.push(filteredOwnPropertyNames(p));
-            p = ObjectGetPrototypeOf(p);
-          }
-        } catch {}
+        // Circular refs possible? Let's guard against that.
+        let sentinel = 5;
+        while (p !== null && sentinel-- !== 0) {
+          memberGroups.push(filteredOwnPropertyNames(p));
+          p = ObjectGetPrototypeOf(p);
+        }
+      } catch {
+        // Maybe a Proxy object without `getOwnPropertyNames` trap.
+        // We simply ignore it here, as we don't want to break the
+        // autocompletion. Fixes the bug
+        // https://github.com/nodejs/node/issues/2119
       }
 
       if (memberGroups.length) {
-        for (let i = 0; i < memberGroups.length; i++) {
-          completionGroups.push(
-            memberGroups[i].map((member) => `${expr}.${member}`));
-        }
+        expr += chaining;
+        ArrayPrototypeForEach(memberGroups, (group) => {
+          ArrayPrototypePush(completionGroups,
+                             ArrayPrototypeMap(group,
+                                               (member) => `${expr}${member}`));
+        });
         if (filter) {
-          filter = `${expr}.${filter}`;
+          filter = `${expr}${filter}`;
         }
       }
 
       completionGroupsLoaded();
     });
-  } else {
-    completionGroupsLoaded();
+    return;
   }
 
+  return completionGroupsLoaded();
+
   // Will be called when all completionGroups are in place
   // Useful for async autocompletion
   function completionGroupsLoaded() {
     // Filter, sort (within each group), uniq and merge the completion groups.
     if (completionGroups.length && filter) {
       const newCompletionGroups = [];
-      for (let i = 0; i < completionGroups.length; i++) {
-        group = completionGroups[i]
-          .filter((elem) => elem.indexOf(filter) === 0);
-        if (group.length) {
-          newCompletionGroups.push(group);
+      ArrayPrototypeForEach(completionGroups, (group) => {
+        const filteredGroup = ArrayPrototypeFilter(
+          group,
+          (str) => StringPrototypeStartsWith(str, filter)
+        );
+        if (filteredGroup.length) {
+          ArrayPrototypePush(newCompletionGroups, filteredGroup);
         }
-      }
+      });
       completionGroups = newCompletionGroups;
     }
 
     const completions = [];
     // Unique completions across all groups.
-    const uniqueSet = new Set(['']);
+    const uniqueSet = new SafeSet();
+    uniqueSet.add('');
     // Completion group 0 is the "closest" (least far up the inheritance
     // chain) so we put its completions last: to be closest in the REPL.
-    for (const group of completionGroups) {
-      group.sort((a, b) => (b > a ? 1 : -1));
+    ArrayPrototypeForEach(completionGroups, (group) => {
+      ArrayPrototypeSort(group, (a, b) => (b > a ? 1 : -1));
       const setSize = uniqueSet.size;
-      for (const entry of group) {
+      ArrayPrototypeForEach(group, (entry) => {
         if (!uniqueSet.has(entry)) {
-          completions.unshift(entry);
+          ArrayPrototypeUnshift(completions, entry);
           uniqueSet.add(entry);
         }
-      }
+      });
       // Add a separator between groups.
       if (uniqueSet.size !== setSize) {
-        completions.unshift('');
+        ArrayPrototypeUnshift(completions, '');
       }
-    }
+    });
 
     // Remove obsolete group entry, if present.
     if (completions[0] === '') {
-      completions.shift();
+      ArrayPrototypeShift(completions);
     }
 
     callback(null, [completions, completeOn]);
@@ -1383,8 +1593,8 @@ function complete(line, callback) {
 REPLServer.prototype.completeOnEditorMode = (callback) => (err, results) => {
   if (err) return callback(err);
 
-  const [completions, completeOn = ''] = results;
-  let result = completions.filter((v) => v);
+  const { 0: completions, 1: completeOn = '' } = results;
+  let result = ArrayPrototypeFilter(completions, Boolean);
 
   if (completeOn && result.length !== 0) {
     result = [commonPrefix(result)];
@@ -1418,10 +1628,10 @@ function _memory(cmd) {
   // Save the line so I can do magic later
   if (cmd) {
     const len = self.lines.level.length ? self.lines.level.length - 1 : 0;
-    self.lines.push('  '.repeat(len) + cmd);
+    ArrayPrototypePush(self.lines, StringPrototypeRepeat('  ', len) + cmd);
   } else {
     // I don't want to not change the format too much...
-    self.lines.push('');
+    ArrayPrototypePush(self.lines, '');
   }
 
   if (!cmd) {
@@ -1435,8 +1645,8 @@ function _memory(cmd) {
 
   // Going down is { and (   e.g. function() {
   // going up is } and )
-  let dw = cmd.match(/[{(]/g);
-  let up = cmd.match(/[})]/g);
+  let dw = StringPrototypeMatch(cmd, /[{(]/g);
+  let up = StringPrototypeMatch(cmd, /[})]/g);
   up = up ? up.length : 0;
   dw = dw ? dw.length : 0;
   let depth = dw - up;
@@ -1451,13 +1661,13 @@ function _memory(cmd) {
         // "function()
         // {" but nothing should break, only tab completion for local
         // scope will not work for this function.
-        self.lines.level.push({
+        ArrayPrototypePush(self.lines.level, {
           line: self.lines.length - 1,
           depth: depth
         });
       } else if (depth < 0) {
         // Going... up.
-        const curr = self.lines.level.pop();
+        const curr = ArrayPrototypePop(self.lines.level);
         if (curr) {
           const tmp = curr.depth + depth;
           if (tmp < 0) {
@@ -1467,7 +1677,7 @@ function _memory(cmd) {
           } else if (tmp > 0) {
             // Remove and push back
             curr.depth += depth;
-            self.lines.level.push(curr);
+            ArrayPrototypePush(self.lines.level, curr);
           }
         }
       }
@@ -1478,18 +1688,18 @@ function _memory(cmd) {
 function addCommonWords(completionGroups) {
   // Only words which do not yet exist as global property should be added to
   // this list.
-  completionGroups.push([
+  ArrayPrototypePush(completionGroups, [
     'async', 'await', 'break', 'case', 'catch', 'const', 'continue',
     'debugger', 'default', 'delete', 'do', 'else', 'export', 'false',
     'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'let',
     'new', 'null', 'return', 'switch', 'this', 'throw', 'true', 'try',
-    'typeof', 'var', 'void', 'while', 'with', 'yield'
+    'typeof', 'var', 'void', 'while', 'with', 'yield',
   ]);
 }
 
 function _turnOnEditorMode(repl) {
   repl.editorMode = true;
-  Interface.prototype.setPrompt.call(repl, '');
+  ReflectApply(Interface.prototype.setPrompt, repl, ['']);
 }
 
 function _turnOffEditorMode(repl) {
@@ -1517,7 +1727,7 @@ function defineDefaultCommands(repl) {
     action: function() {
       this.clearBufferedCommand();
       if (!this.useGlobal) {
-        this.outputStream.write('Clearing context...\n');
+        this.output.write('Clearing context...\n');
         this.resetContext();
       }
       this.displayPrompt();
@@ -1525,7 +1735,7 @@ function defineDefaultCommands(repl) {
   });
 
   repl.defineCommand('exit', {
-    help: 'Exit the repl',
+    help: 'Exit the REPL',
     action: function() {
       this.close();
     }
@@ -1534,20 +1744,19 @@ function defineDefaultCommands(repl) {
   repl.defineCommand('help', {
     help: 'Print this help message',
     action: function() {
-      const names = ObjectKeys(this.commands).sort();
-      const longestNameLength = names.reduce(
-        (max, name) => MathMax(max, name.length),
-        0
+      const names = ArrayPrototypeSort(ObjectKeys(this.commands));
+      const longestNameLength = MathMax(
+        ...ArrayPrototypeMap(names, (name) => name.length)
       );
-      for (let n = 0; n < names.length; n++) {
-        const name = names[n];
+      ArrayPrototypeForEach(names, (name) => {
         const cmd = this.commands[name];
-        const spaces = ' '.repeat(longestNameLength - name.length + 3);
+        const spaces =
+          StringPrototypeRepeat(' ', longestNameLength - name.length + 3);
         const line = `.${name}${cmd.help ? spaces + cmd.help : ''}\n`;
-        this.outputStream.write(line);
-      }
-      this.outputStream.write('\nPress ^C to abort current expression, ' +
-        '^D to exit the repl\n');
+        this.output.write(line);
+      });
+      this.output.write('\nPress Ctrl+C to abort current expression, ' +
+        'Ctrl+D to exit the REPL\n');
       this.displayPrompt();
     }
   });
@@ -1556,10 +1765,10 @@ function defineDefaultCommands(repl) {
     help: 'Save all evaluated commands in this REPL session to a file',
     action: function(file) {
       try {
-        fs.writeFileSync(file, this.lines.join('\n'));
-        this.outputStream.write(`Session saved to: ${file}\n`);
+        fs.writeFileSync(file, ArrayPrototypeJoin(this.lines, '\n'));
+        this.output.write(`Session saved to: ${file}\n`);
       } catch {
-        this.outputStream.write(`Failed to save: ${file}\n`);
+        this.output.write(`Failed to save: ${file}\n`);
       }
       this.displayPrompt();
     }
@@ -1577,12 +1786,12 @@ function defineDefaultCommands(repl) {
           _turnOffEditorMode(this);
           this.write('\n');
         } else {
-          this.outputStream.write(
+          this.output.write(
             `Failed to load: ${file} is not a valid file\n`
           );
         }
       } catch {
-        this.outputStream.write(`Failed to load: ${file}\n`);
+        this.output.write(`Failed to load: ${file}\n`);
       }
       this.displayPrompt();
     }
@@ -1592,20 +1801,46 @@ function defineDefaultCommands(repl) {
       help: 'Enter editor mode',
       action() {
         _turnOnEditorMode(this);
-        this.outputStream.write(
-          '// Entering editor mode (^D to finish, ^C to cancel)\n');
+        this.output.write(
+          '// Entering editor mode (Ctrl+D to finish, Ctrl+C to cancel)\n');
       }
     });
   }
 }
 
-function regexpEscape(s) {
-  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-}
-
 function Recoverable(err) {
   this.err = err;
 }
-ObjectSetPrototypeOf(Recoverable.prototype, SyntaxError.prototype);
+ObjectSetPrototypeOf(Recoverable.prototype, SyntaxErrorPrototype);
 ObjectSetPrototypeOf(Recoverable, SyntaxError);
-exports.Recoverable = Recoverable;
+
+module.exports = {
+  start,
+  writer,
+  REPLServer,
+  REPL_MODE_SLOPPY,
+  REPL_MODE_STRICT,
+  Recoverable
+};
+
+ObjectDefineProperty(module.exports, 'builtinModules', {
+  get: () => _builtinLibs,
+  set: (val) => _builtinLibs = val,
+  enumerable: true,
+  configurable: true
+});
+
+ObjectDefineProperty(module.exports, '_builtinLibs', {
+  get: pendingDeprecation ? deprecate(
+    () => _builtinLibs,
+    'repl._builtinLibs is deprecated. Check module.builtinModules instead',
+    'DEP0142'
+  ) : () => _builtinLibs,
+  set: pendingDeprecation ? deprecate(
+    (val) => _builtinLibs = val,
+    'repl._builtinLibs is deprecated. Check module.builtinModules instead',
+    'DEP0142'
+  ) : (val) => _builtinLibs = val,
+  enumerable: false,
+  configurable: true
+});
diff --git a/lib/stream.js b/lib/stream.js
index 725038ba9c0d1c4341a264a7131f94c92726de79..5f842d1d4d1ea4e5e848fb8e7e57f8989fd47222 100644
--- a/lib/stream.js
+++ b/lib/stream.js
@@ -25,16 +25,12 @@ const pipeline = require('internal/streams/pipeline');
 const eos = require('internal/streams/end-of-stream');
 const internalBuffer = require('internal/buffer');
 
-// Note: export Stream before Readable/Writable/Duplex/...
-// to avoid a cross-reference(require) issues
-const Stream = module.exports = require('internal/streams/legacy');
-
-Stream.Readable = require('_stream_readable');
-Stream.Writable = require('_stream_writable');
-Stream.Duplex = require('_stream_duplex');
-Stream.Transform = require('_stream_transform');
-Stream.PassThrough = require('_stream_passthrough');
-
+const Stream = module.exports = require('internal/streams/legacy').Stream;
+Stream.Readable = require('internal/streams/readable');
+Stream.Writable = require('internal/streams/writable');
+Stream.Duplex = require('internal/streams/duplex');
+Stream.Transform = require('internal/streams/transform');
+Stream.PassThrough = require('internal/streams/passthrough');
 Stream.pipeline = pipeline;
 Stream.finished = eos;
 
diff --git a/lib/string_decoder.js b/lib/string_decoder.js
index 3d2cc2fcb6ab51b0859851c27737816051f96e6c..2891e0a1d1a43afe5671cc58a9fa7812d052ce56 100644
--- a/lib/string_decoder.js
+++ b/lib/string_decoder.js
@@ -25,6 +25,7 @@ const {
   ArrayBufferIsView,
   ObjectDefineProperties,
   Symbol,
+  TypedArrayPrototypeSubarray,
 } = primordials;
 
 const { Buffer } = require('buffer');
@@ -104,8 +105,9 @@ ObjectDefineProperties(StringDecoder.prototype, {
     configurable: true,
     enumerable: true,
     get() {
-      return this[kNativeDecoder].subarray(kIncompleteCharactersStart,
-                                           kIncompleteCharactersEnd);
+      return TypedArrayPrototypeSubarray(this[kNativeDecoder],
+                                         kIncompleteCharactersStart,
+                                         kIncompleteCharactersEnd);
     }
   },
   lastNeed: {
diff --git a/lib/timers.js b/lib/timers.js
index de50e56a11909a16085a23c0453245e0118b15ef..3064b67f4437ec2842aa251615b3ad202e93ef82 100644
--- a/lib/timers.js
+++ b/lib/timers.js
@@ -22,9 +22,9 @@
 'use strict';
 
 const {
-  ObjectCreate,
   MathTrunc,
-  Promise,
+  ObjectCreate,
+  ObjectDefineProperty,
   SymbolToPrimitive
 } = primordials;
 
@@ -36,6 +36,7 @@ const L = require('internal/linkedlist');
 const {
   async_id_symbol,
   Timeout,
+  Immediate,
   decRefCount,
   immediateInfoFields: {
     kCount,
@@ -43,7 +44,6 @@ const {
   },
   kRefed,
   kHasPrimitive,
-  initAsyncResource,
   getTimerDuration,
   timerListMap,
   timerListQueue,
@@ -61,6 +61,8 @@ let debug = require('internal/util/debuglog').debuglog('timer', (fn) => {
 });
 const { validateCallback } = require('internal/validators');
 
+let timersPromises;
+
 const {
   destroyHooksExist,
   // The needed emit*() functions.
@@ -125,11 +127,16 @@ function enroll(item, msecs) {
 }
 
 
-/*
- * DOM-style timers
+/**
+ * Schedules the execution of a one-time `callback`
+ * after `after` milliseconds.
+ * @param {Function} callback
+ * @param {number} [after]
+ * @param {any} [arg1]
+ * @param {any} [arg2]
+ * @param {any} [arg3]
+ * @returns {Timeout}
  */
-
-
 function setTimeout(callback, after, arg1, arg2, arg3) {
   validateCallback(callback);
 
@@ -160,14 +167,20 @@ function setTimeout(callback, after, arg1, arg2, arg3) {
   return timeout;
 }
 
-setTimeout[customPromisify] = function(after, value) {
-  const args = value !== undefined ? [value] : value;
-  return new Promise((resolve) => {
-    const timeout = new Timeout(resolve, after, args, false, true);
-    insert(timeout, timeout._idleTimeout);
-  });
-};
+ObjectDefineProperty(setTimeout, customPromisify, {
+  enumerable: true,
+  get() {
+    if (!timersPromises)
+      timersPromises = require('internal/timers/promises');
+    return timersPromises.setTimeout;
+  }
+});
 
+/**
+ * Cancels a timeout.
+ * @param {Timeout | string | number} timer
+ * @returns {void}
+ */
 function clearTimeout(timer) {
   if (timer && timer._onTimeout) {
     timer._onTimeout = null;
@@ -183,6 +196,16 @@ function clearTimeout(timer) {
   }
 }
 
+/**
+ * Schedules repeated execution of `callback`
+ * every `repeat` milliseconds.
+ * @param {Function} callback
+ * @param {number} [repeat]
+ * @param {any} [arg1]
+ * @param {any} [arg2]
+ * @param {any} [arg3]
+ * @returns {Timeout}
+ */
 function setInterval(callback, repeat, arg1, arg2, arg3) {
   validateCallback(callback);
 
@@ -213,6 +236,11 @@ function setInterval(callback, repeat, arg1, arg2, arg3) {
   return timeout;
 }
 
+/**
+ * Cancels an interval.
+ * @param {Timeout | string | number} timer
+ * @returns {void}
+ */
 function clearInterval(timer) {
   // clearTimeout and clearInterval can be used to clear timers created from
   // both setTimeout and setInterval, as specified by HTML Living Standard:
@@ -225,6 +253,10 @@ Timeout.prototype.close = function() {
   return this;
 };
 
+/**
+ * Coerces a `Timeout` to a primitive.
+ * @returns {number}
+ */
 Timeout.prototype[SymbolToPrimitive] = function() {
   const id = this[async_id_symbol];
   if (!this[kHasPrimitive]) {
@@ -234,46 +266,15 @@ Timeout.prototype[SymbolToPrimitive] = function() {
   return id;
 };
 
-const Immediate = class Immediate {
-  constructor(callback, args) {
-    this._idleNext = null;
-    this._idlePrev = null;
-    this._onImmediate = callback;
-    this._argv = args;
-    this._destroyed = false;
-    this[kRefed] = false;
-
-    initAsyncResource(this, 'Immediate');
-
-    this.ref();
-    immediateInfo[kCount]++;
-
-    immediateQueue.append(this);
-  }
-
-  ref() {
-    if (this[kRefed] === false) {
-      this[kRefed] = true;
-      if (immediateInfo[kRefCount]++ === 0)
-        toggleImmediateRef(true);
-    }
-    return this;
-  }
-
-  unref() {
-    if (this[kRefed] === true) {
-      this[kRefed] = false;
-      if (--immediateInfo[kRefCount] === 0)
-        toggleImmediateRef(false);
-    }
-    return this;
-  }
-
-  hasRef() {
-    return !!this[kRefed];
-  }
-};
-
+/**
+ * Schedules the immediate execution of `callback`
+ * after I/O events' callbacks.
+ * @param {Function} callback
+ * @param {any} [arg1]
+ * @param {any} [arg2]
+ * @param {any} [arg3]
+ * @returns {Immediate}
+ */
 function setImmediate(callback, arg1, arg2, arg3) {
   validateCallback(callback);
 
@@ -300,10 +301,20 @@ function setImmediate(callback, arg1, arg2, arg3) {
   return new Immediate(callback, args);
 }
 
-setImmediate[customPromisify] = function(value) {
-  return new Promise((resolve) => new Immediate(resolve, [value]));
-};
+ObjectDefineProperty(setImmediate, customPromisify, {
+  enumerable: true,
+  get() {
+    if (!timersPromises)
+      timersPromises = require('internal/timers/promises');
+    return timersPromises.setImmediate;
+  }
+});
 
+/**
+ * Cancels an immediate.
+ * @param {Immediate} immediate
+ * @returns {void}
+ */
 function clearImmediate(immediate) {
   if (!immediate || immediate._destroyed)
     return;
@@ -315,7 +326,7 @@ function clearImmediate(immediate) {
     toggleImmediateRef(false);
   immediate[kRefed] = null;
 
-  if (destroyHooksExist()) {
+  if (destroyHooksExist() && immediate[async_id_symbol] !== undefined) {
     emitDestroy(immediate[async_id_symbol]);
   }
 
diff --git a/lib/tls.js b/lib/tls.js
index 2ccbe409c96c2d62a6b885b3d2540788202dbd15..7854f20fca66758df2c083d0350169e62a25255e 100644
--- a/lib/tls.js
+++ b/lib/tls.js
@@ -24,11 +24,22 @@
 const {
   Array,
   ArrayIsArray,
+  ArrayPrototypePush,
+  JSONParse,
   ObjectDefineProperty,
   ObjectFreeze,
+  RegExpPrototypeExec,
+  StringFromCharCode,
+  StringPrototypeCharCodeAt,
+  StringPrototypeIncludes,
+  StringPrototypeIndexOf,
+  StringPrototypeReplace,
+  StringPrototypeSplit,
+  StringPrototypeSubstring,
 } = primordials;
 
 const {
+  ERR_TLS_CERT_ALTNAME_FORMAT,
   ERR_TLS_CERT_ALTNAME_INVALID,
   ERR_OUT_OF_RANGE
 } = require('internal/errors').codes;
@@ -137,11 +148,17 @@ function unfqdn(host) {
   return host.replace(/[.]$/, '');
 }
 
+// String#toLowerCase() is locale-sensitive so we use
+// a conservative version that only lowercases A-Z.
+function toLowerCase(c) {
+  return StringFromCharCode(32 + StringPrototypeCharCodeAt(c, 0));
+}
+
 function splitHost(host) {
-  // String#toLowerCase() is locale-sensitive so we use
-  // a conservative version that only lowercases A-Z.
-  const replacer = (c) => String.fromCharCode(32 + c.charCodeAt(0));
-  return unfqdn(host).replace(/[A-Z]/g, replacer).split('.');
+  return StringPrototypeSplit(
+    StringPrototypeReplace(unfqdn(host), /[A-Z]/g, toLowerCase),
+    '.'
+  );
 }
 
 function check(hostParts, pattern, wildcards) {
@@ -207,6 +224,45 @@ function check(hostParts, pattern, wildcards) {
   return true;
 }
 
+// This pattern is used to determine the length of escaped sequences within
+// the subject alt names string. It allows any valid JSON string literal.
+// This MUST match the JSON specification (ECMA-404 / RFC8259) exactly.
+const jsonStringPattern =
+  // eslint-disable-next-line no-control-regex
+  /^"(?:[^"\\\u0000-\u001f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"/;
+
+function splitEscapedAltNames(altNames) {
+  const result = [];
+  let currentToken = '';
+  let offset = 0;
+  while (offset !== altNames.length) {
+    const nextSep = StringPrototypeIndexOf(altNames, ', ', offset);
+    const nextQuote = StringPrototypeIndexOf(altNames, '"', offset);
+    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {
+      // There is a quote character and there is no separator before the quote.
+      currentToken += StringPrototypeSubstring(altNames, offset, nextQuote);
+      const match = RegExpPrototypeExec(
+        jsonStringPattern, StringPrototypeSubstring(altNames, nextQuote));
+      if (!match) {
+        throw new ERR_TLS_CERT_ALTNAME_FORMAT();
+      }
+      currentToken += JSONParse(match[0]);
+      offset = nextQuote + match[0].length;
+    } else if (nextSep !== -1) {
+      // There is a separator and no quote before it.
+      currentToken += StringPrototypeSubstring(altNames, offset, nextSep);
+      ArrayPrototypePush(result, currentToken);
+      currentToken = '';
+      offset = nextSep + 2;
+    } else {
+      currentToken += StringPrototypeSubstring(altNames, offset);
+      offset = altNames.length;
+    }
+  }
+  ArrayPrototypePush(result, currentToken);
+  return result;
+}
+
 let urlWarningEmitted = false;
 exports.checkServerIdentity = function checkServerIdentity(hostname, cert) {
   const subject = cert.subject;
@@ -218,10 +274,13 @@ exports.checkServerIdentity = function checkServerIdentity(hostname, cert) {
   hostname = '' + hostname;
 
   if (altNames) {
-    for (const name of altNames.split(', ')) {
+    const splitAltNames = StringPrototypeIncludes(altNames, '"') ?
+      splitEscapedAltNames(altNames) :
+      StringPrototypeSplit(altNames, ', ');
+    for (const name of splitAltNames) {
       if (name.startsWith('DNS:')) {
         dnsNames.push(name.slice(4));
-      } else if (name.startsWith('URI:')) {
+      } else if (process.REVERT_CVE_2021_44531 && name.startsWith('URI:')) {
         let uri;
         try {
           uri = new URL(name.slice(4));
@@ -236,7 +295,6 @@ exports.checkServerIdentity = function checkServerIdentity(hostname, cert) {
               'DeprecationWarning', 'DEP0109');
           }
         }
-
         uriNames.push(uri.hostname);  // TODO(bnoordhuis) Also use scheme.
       } else if (name.startsWith('IP Address:')) {
         ips.push(canonicalizeIP(name.slice(11)));
@@ -257,11 +315,13 @@ exports.checkServerIdentity = function checkServerIdentity(hostname, cert) {
     if (!valid)
       reason = `IP: ${hostname} is not in the cert's list: ${ips.join(', ')}`;
     // TODO(bnoordhuis) Also check URI SANs that are IP addresses.
-  } else if (hasAltNames || subject) {
+  } else if ((process.REVERT_CVE_2021_44531 && (hasAltNames || subject)) ||
+         (dnsNames.length > 0 || (subject && subject.CN))) {
     const hostParts = splitHost(hostname);
     const wildcard = (pattern) => check(hostParts, pattern, true);
 
-    if (hasAltNames) {
+    if ((process.REVERT_CVE_2021_44531 && hasAltNames) ||
+           (dnsNames.length > 0)) {
       const noWildcard = (pattern) => check(hostParts, pattern, false);
       valid = dnsNames.some(wildcard) || uriNames.some(noWildcard);
       if (!valid)
@@ -280,7 +340,7 @@ exports.checkServerIdentity = function checkServerIdentity(hostname, cert) {
         reason = `Host: ${hostname}. is not cert's CN: ${cn}`;
     }
   } else {
-    reason = 'Cert is empty';
+    reason = 'Cert does not contain a DNS name';
   }
 
   if (!valid) {
diff --git a/lib/trace_events.js b/lib/trace_events.js
index 35f776ad53c31053f9276fac9431377993861377..85101e7930d9775f881618403ad7abb8bdb6d0d9 100644
--- a/lib/trace_events.js
+++ b/lib/trace_events.js
@@ -2,7 +2,8 @@
 
 const {
   ArrayIsArray,
-  Set,
+  ArrayPrototypeJoin,
+  SafeSet,
   Symbol,
 } = primordials;
 
@@ -27,7 +28,7 @@ const { CategorySet, getEnabledCategories } = internalBinding('trace_events');
 const { customInspectSymbol } = require('internal/util');
 const { format } = require('internal/util/inspect');
 
-const enabledTracingObjects = new Set();
+const enabledTracingObjects = new SafeSet();
 
 class Tracing {
   constructor(categories) {
@@ -63,7 +64,7 @@ class Tracing {
   }
 
   get categories() {
-    return this[kCategories].join(',');
+    return ArrayPrototypeJoin(this[kCategories], ',');
   }
 
   [customInspectSymbol](depth, opts) {
diff --git a/lib/tty.js b/lib/tty.js
index 583cc1329830c902d87764948dd33a50a90f2169..e61a5c3ac3f9050c83ebb5f71548889a0ff7a23a 100644
--- a/lib/tty.js
+++ b/lib/tty.js
@@ -40,7 +40,8 @@ const {
 let readline;
 
 function isatty(fd) {
-  return NumberIsInteger(fd) && fd >= 0 && isTTY(fd);
+  return NumberIsInteger(fd) && fd >= 0 && fd <= 2147483647 &&
+         isTTY(fd);
 }
 
 function ReadStream(fd, options) {
@@ -132,7 +133,7 @@ WriteStream.prototype._refreshSize = function() {
     this.emit('error', errors.errnoException(err, 'getWindowSize'));
     return;
   }
-  const [newCols, newRows] = winSize;
+  const { 0: newCols, 1: newRows } = winSize;
   if (oldCols !== newCols || oldRows !== newRows) {
     this.columns = newCols;
     this.rows = newRows;
diff --git a/lib/url.js b/lib/url.js
index f7dbebea5ac125ad57929f45382f941dad444cec..177bd9eb59ca4483018d42b431035b25547a9528 100644
--- a/lib/url.js
+++ b/lib/url.js
@@ -22,9 +22,11 @@
 'use strict';
 
 const {
+  Int8Array,
   ObjectCreate,
   ObjectKeys,
   SafeSet,
+  StringPrototypeCharCodeAt,
   decodeURIComponent,
 } = primordials;
 
@@ -46,9 +48,10 @@ const {
   URLSearchParams,
   domainToASCII,
   domainToUnicode,
+  fileURLToPath,
   formatSymbol,
   pathToFileURL,
-  fileURLToPath
+  urlToHttpOptions,
 } = require('internal/url');
 
 // Original url.parse() API
@@ -83,12 +86,12 @@ const hostnameMaxLen = 255;
 // Protocols that can allow "unsafe" and "unwise" chars.
 const unsafeProtocol = new SafeSet([
   'javascript',
-  'javascript:'
+  'javascript:',
 ]);
 // Protocols that never have a hostname.
 const hostlessProtocol = new SafeSet([
   'javascript',
-  'javascript:'
+  'javascript:',
 ]);
 // Protocols that always contain a // bit.
 const slashedProtocol = new SafeSet([
@@ -105,7 +108,7 @@ const slashedProtocol = new SafeSet([
   'ws',
   'ws:',
   'wss',
-  'wss:'
+  'wss:',
 ]);
 const {
   CHAR_SPACE,
@@ -156,6 +159,14 @@ function urlParse(url, parseQueryString, slashesDenoteHost) {
   return urlObject;
 }
 
+function isIpv6Hostname(hostname) {
+  return (
+    StringPrototypeCharCodeAt(hostname, 0) === CHAR_LEFT_SQUARE_BRACKET &&
+    StringPrototypeCharCodeAt(hostname, hostname.length - 1) ===
+    CHAR_RIGHT_SQUARE_BRACKET
+  );
+}
+
 Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
   validateString(url, 'url');
 
@@ -364,8 +375,7 @@ Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
 
     // If hostname begins with [ and ends with ]
     // assume that it's an IPv6 address.
-    const ipv6Hostname = hostname.charCodeAt(0) === CHAR_LEFT_SQUARE_BRACKET &&
-      hostname.charCodeAt(hostname.length - 1) === CHAR_RIGHT_SQUARE_BRACKET;
+    const ipv6Hostname = isIpv6Hostname(hostname);
 
     // validate a little.
     if (!ipv6Hostname) {
@@ -506,7 +516,7 @@ const escapedCodes = [
   /* 90 - 99 */ '', '', '%5C', '', '%5E', '', '%60', '', '', '',
   /* 100 - 109 */ '', '', '', '', '', '', '', '', '', '',
   /* 110 - 119 */ '', '', '', '', '', '', '', '', '', '',
-  /* 120 - 125 */ '', '', '', '%7B', '%7C', '%7D'
+  /* 120 - 125 */ '', '', '', '%7B', '%7C', '%7D',
 ];
 
 // Automatically escape all delimiters and unwise characters from RFC 2396.
@@ -562,7 +572,7 @@ function urlFormat(urlObject, options) {
 // digits
 // alpha (uppercase)
 // alpha (lowercase)
-const noEscapeAuth = [
+const noEscapeAuth = new Int8Array([
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x00 - 0x0F
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x10 - 0x1F
   0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, // 0x20 - 0x2F
@@ -570,8 +580,8 @@ const noEscapeAuth = [
   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 - 0x4F
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 0x50 - 0x5F
   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 0x6F
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0  // 0x70 - 0x7F
-];
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,  // 0x70 - 0x7F
+]);
 
 Url.prototype.format = function format() {
   let auth = this.auth || '';
@@ -590,7 +600,7 @@ Url.prototype.format = function format() {
     host = auth + this.host;
   } else if (this.hostname) {
     host = auth + (
-      this.hostname.includes(':') ?
+      this.hostname.includes(':') && !isIpv6Hostname(this.hostname) ?
         '[' + this.hostname + ']' :
         this.hostname
     );
@@ -979,5 +989,6 @@ module.exports = {
 
   // Utilities
   pathToFileURL,
-  fileURLToPath
+  fileURLToPath,
+  urlToHttpOptions,
 };
diff --git a/lib/util.js b/lib/util.js
index f9337598e69dc2ed1b2417de23884c43e153f3ff..47f9154a820108d26e1f13142efe976693a1bf51 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -23,6 +23,7 @@
 
 const {
   ArrayIsArray,
+  Date,
   Error,
   NumberIsSafeInteger,
   ObjectDefineProperties,
@@ -57,57 +58,117 @@ const types = require('internal/util/types');
 
 const {
   deprecate,
+  getSystemErrorMap,
   getSystemErrorName: internalErrorName,
-  promisify
+  promisify,
+  toUSVString,
 } = require('internal/util');
 
 let internalDeepEqual;
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {arg is boolean}
+ */
 function isBoolean(arg) {
   return typeof arg === 'boolean';
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {arg is null}
+ */
 function isNull(arg) {
   return arg === null;
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {arg is (null | undefined)}
+ */
 function isNullOrUndefined(arg) {
   return arg === null || arg === undefined;
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {arg is number}
+ */
 function isNumber(arg) {
   return typeof arg === 'number';
 }
 
+/**
+ * @param {any} arg
+ * @returns {arg is string}
+ */
 function isString(arg) {
   return typeof arg === 'string';
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {arg is symbol}
+ */
 function isSymbol(arg) {
   return typeof arg === 'symbol';
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {arg is undefined}
+ */
 function isUndefined(arg) {
   return arg === undefined;
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {a is NonNullable<object>}
+ */
 function isObject(arg) {
   return arg !== null && typeof arg === 'object';
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} e
+ * @returns {arg is Error}
+ */
 function isError(e) {
   return ObjectPrototypeToString(e) === '[object Error]' || e instanceof Error;
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {arg is Function}
+ */
 function isFunction(arg) {
   return typeof arg === 'function';
 }
 
+/**
+ * @deprecated since v4.0.0
+ * @param {any} arg
+ * @returns {arg is (boolean | null | number | string | symbol | undefined)}
+ */
 function isPrimitive(arg) {
   return arg === null ||
          (typeof arg !== 'object' && typeof arg !== 'function');
 }
 
+/**
+ * @param {number} n
+ * @returns {string}
+ */
 function pad(n) {
   return n.toString().padStart(2, '0');
 }
@@ -115,7 +176,9 @@ function pad(n) {
 const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
                 'Oct', 'Nov', 'Dec'];
 
-// 26 Feb 16:19:34
+/**
+ * @returns {string}  26 Feb 16:19:34
+ */
 function timestamp() {
   const d = new Date();
   const time = [pad(d.getHours()),
@@ -125,7 +188,11 @@ function timestamp() {
 }
 
 let console;
-// Log is just a thin wrapper to console.log that prepends a timestamp
+/**
+ * Log is just a thin wrapper to console.log that prepends a timestamp
+ * @deprecated since v6.0.0
+ * @type {(...args: any[]) => void}
+ */
 function log(...args) {
   if (!console) {
     console = require('internal/console/global');
@@ -142,9 +209,9 @@ function log(...args) {
  * functions as prototype setup using normal JavaScript does not work as
  * expected during bootstrapping (see mirror.js in r114903).
  *
- * @param {function} ctor Constructor function which needs to inherit the
+ * @param {Function} ctor Constructor function which needs to inherit the
  *     prototype.
- * @param {function} superCtor Constructor function to inherit prototype from.
+ * @param {Function} superCtor Constructor function to inherit prototype from.
  * @throws {TypeError} Will error if either constructor is null, or if
  *     the super constructor lacks a prototype.
  */
@@ -168,6 +235,14 @@ function inherits(ctor, superCtor) {
   ObjectSetPrototypeOf(ctor.prototype, superCtor.prototype);
 }
 
+/**
+ * @deprecated since v6.0.0
+ * @template T
+ * @template S
+ * @param {T} target
+ * @param {S} source
+ * @returns {S extends null ? T : (T & S)}
+ */
 function _extend(target, source) {
   // Don't do anything if source isn't an object
   if (source === null || typeof source !== 'object') return target;
@@ -191,6 +266,14 @@ const callbackifyOnRejected = hideStackFrames((reason, cb) => {
   return cb(reason);
 });
 
+/**
+ * @template {(...args: any[]) => Promise<any>} T
+ * @param {T} original
+ * @returns {T extends (...args: infer TArgs) => Promise<infer TReturn> ?
+ *   ((...params: [...TArgs, ((err: Error, ret: TReturn) => any)]) => void) :
+ *   never
+ * }
+ */
 function callbackify(original) {
   if (typeof original !== 'function') {
     throw new ERR_INVALID_ARG_TYPE('original', 'Function', original);
@@ -225,6 +308,10 @@ function callbackify(original) {
   return callbackified;
 }
 
+/**
+ * @param {number} err
+ * @returns {string}
+ */
 function getSystemErrorName(err) {
   validateNumber(err, 'err');
   if (err >= 0 || !NumberIsSafeInteger(err)) {
@@ -239,10 +326,12 @@ module.exports = {
   _exceptionWithHostPort: exceptionWithHostPort,
   _extend,
   callbackify,
+  debug: debuglog,
   debuglog,
   deprecate,
   format,
   formatWithOptions,
+  getSystemErrorMap,
   getSystemErrorName,
   inherits,
   inspect,
@@ -270,6 +359,7 @@ module.exports = {
   isPrimitive,
   log,
   promisify,
+  toUSVString,
   TextDecoder,
   TextEncoder,
   types
diff --git a/lib/v8.js b/lib/v8.js
index 2143e07274775dccbe4c9b59474a735b5a43fb7b..5c83c5f54dc50197e222d01319d496521d9097f3 100644
--- a/lib/v8.js
+++ b/lib/v8.js
@@ -17,14 +17,17 @@
 const {
   Array,
   ArrayBuffer,
+  ArrayPrototypeForEach,
+  ArrayPrototypePush,
+  DataView,
   Error,
   Float32Array,
   Float64Array,
   Int16Array,
   Int32Array,
   Int8Array,
-  Map,
   ObjectPrototypeToString,
+  SafeMap,
   Uint16Array,
   Uint32Array,
   Uint8Array,
@@ -34,8 +37,8 @@ const {
 const { Buffer } = require('buffer');
 const { validateString } = require('internal/validators');
 const {
-  Serializer: _Serializer,
-  Deserializer: _Deserializer
+  Serializer,
+  Deserializer
 } = internalBinding('serdes');
 
 let profiler = {};
@@ -55,6 +58,12 @@ const {
 } = internalBinding('heap_utils');
 const { HeapSnapshotStream } = require('internal/heap_utils');
 
+/**
+ * Generates a snapshot of the current V8 heap
+ * and writes it to a JSON file.
+ * @param {string} [filename]
+ * @returns {string}
+ */
 function writeHeapSnapshot(filename) {
   if (filename !== undefined) {
     filename = getValidatedPath(filename);
@@ -63,28 +72,26 @@ function writeHeapSnapshot(filename) {
   return triggerHeapSnapshot(filename);
 }
 
+/**
+ * Generates a snapshot of the current V8 heap
+ * and returns a Readable Stream.
+ * @returns {import('./stream.js').Readable}
+ */
 function getHeapSnapshot() {
   const handle = createHeapSnapshotStream();
   assert(handle);
   return new HeapSnapshotStream(handle);
 }
 
-// Calling exposed c++ functions directly throws exception as it expected to be
-// called with new operator and caused an assert to fire.
-// Creating JS wrapper so that it gets caught at JS layer.
-class Serializer extends _Serializer { }
-
-class Deserializer extends _Deserializer { }
-
 const {
   cachedDataVersionTag,
   setFlagsFromString: _setFlagsFromString,
-  heapStatisticsArrayBuffer,
-  heapSpaceStatisticsArrayBuffer,
-  heapCodeStatisticsArrayBuffer,
-  updateHeapStatisticsArrayBuffer,
-  updateHeapSpaceStatisticsArrayBuffer,
-  updateHeapCodeStatisticsArrayBuffer,
+  heapStatisticsBuffer,
+  heapSpaceStatisticsBuffer,
+  heapCodeStatisticsBuffer,
+  updateHeapStatisticsBuffer,
+  updateHeapSpaceStatisticsBuffer,
+  updateHeapCodeStatisticsBuffer,
 
   // Properties for heap statistics buffer extraction.
   kTotalHeapSizeIndex,
@@ -101,7 +108,6 @@ const {
 
   // Properties for heap spaces statistics buffer extraction.
   kHeapSpaces,
-  kHeapSpaceStatisticsPropertiesCount,
   kSpaceSizeIndex,
   kSpaceUsedSizeIndex,
   kSpaceAvailableSizeIndex,
@@ -115,24 +121,36 @@ const {
 
 const kNumberOfHeapSpaces = kHeapSpaces.length;
 
-const heapStatisticsBuffer =
-    new Float64Array(heapStatisticsArrayBuffer);
-
-const heapSpaceStatisticsBuffer =
-    new Float64Array(heapSpaceStatisticsArrayBuffer);
-
-const heapCodeStatisticsBuffer =
-    new Float64Array(heapCodeStatisticsArrayBuffer);
-
+/**
+ * Sets V8 command-line flags.
+ * @param {string} flags
+ * @returns {void}
+ */
 function setFlagsFromString(flags) {
   validateString(flags, 'flags');
   _setFlagsFromString(flags);
 }
 
+/**
+ * Gets the current V8 heap statistics.
+ * @returns {{
+ *   total_heap_size: number;
+ *   total_heap_size_executable: number;
+ *   total_physical_size: number;
+ *   total_available_size: number;
+ *   used_heap_size: number;
+ *   heap_size_limit: number;
+ *   malloced_memory: number;
+ *   peak_malloced_memory: number;
+ *   does_zap_garbage: number;
+ *   number_of_native_contexts: number;
+ *   number_of_detached_contexts: number;
+ *   }}
+ */
 function getHeapStatistics() {
   const buffer = heapStatisticsBuffer;
 
-  updateHeapStatisticsArrayBuffer();
+  updateHeapStatisticsBuffer();
 
   return {
     'total_heap_size': buffer[kTotalHeapSizeIndex],
@@ -149,29 +167,46 @@ function getHeapStatistics() {
   };
 }
 
+/**
+ * Gets the current V8 heap space statistics.
+ * @returns {{
+ *   space_name: string;
+ *   space_size: number;
+ *   space_used_size: number;
+ *   space_available_size: number;
+ *   physical_space_size: number;
+ *   }[]}
+ */
 function getHeapSpaceStatistics() {
   const heapSpaceStatistics = new Array(kNumberOfHeapSpaces);
   const buffer = heapSpaceStatisticsBuffer;
-  updateHeapSpaceStatisticsArrayBuffer();
 
   for (let i = 0; i < kNumberOfHeapSpaces; i++) {
-    const propertyOffset = i * kHeapSpaceStatisticsPropertiesCount;
+    updateHeapSpaceStatisticsBuffer(i);
     heapSpaceStatistics[i] = {
       space_name: kHeapSpaces[i],
-      space_size: buffer[propertyOffset + kSpaceSizeIndex],
-      space_used_size: buffer[propertyOffset + kSpaceUsedSizeIndex],
-      space_available_size: buffer[propertyOffset + kSpaceAvailableSizeIndex],
-      physical_space_size: buffer[propertyOffset + kPhysicalSpaceSizeIndex]
+      space_size: buffer[kSpaceSizeIndex],
+      space_used_size: buffer[kSpaceUsedSizeIndex],
+      space_available_size: buffer[kSpaceAvailableSizeIndex],
+      physical_space_size: buffer[kPhysicalSpaceSizeIndex]
     };
   }
 
   return heapSpaceStatistics;
 }
 
+/**
+ * Gets the current V8 heap code statistics.
+ * @returns {{
+ *   code_and_metadata_size: number;
+ *   bytecode_and_metadata_size: number;
+ *   external_script_source_size: number;
+ *   }}
+ */
 function getHeapCodeStatistics() {
   const buffer = heapCodeStatisticsBuffer;
 
-  updateHeapCodeStatisticsArrayBuffer();
+  updateHeapCodeStatisticsBuffer();
   return {
     'code_and_metadata_size': buffer[kCodeAndMetadataSizeIndex],
     'bytecode_and_metadata_size': buffer[kBytecodeAndMetadataSizeIndex],
@@ -184,6 +219,11 @@ function getHeapCodeStatistics() {
 /* JS methods for the base objects */
 Serializer.prototype._getDataCloneError = Error;
 
+/**
+ * Reads raw bytes from the deserializer's internal buffer.
+ * @param {number} length
+ * @returns {Buffer}
+ */
 Deserializer.prototype.readRawBytes = function readRawBytes(length) {
   const offset = this._readRawBytes(length);
   // `this.buffer` can be a Buffer or a plain Uint8Array, so just calling
@@ -204,17 +244,18 @@ const arrayBufferViewTypes = [Int8Array, Uint8Array, Uint8ClampedArray,
                               Int16Array, Uint16Array, Int32Array, Uint32Array,
                               Float32Array, Float64Array, DataView];
 
-const arrayBufferViewTypeToIndex = new Map();
+const arrayBufferViewTypeToIndex = new SafeMap();
 
 {
   const dummy = new ArrayBuffer();
-  for (const [i, ctor] of arrayBufferViewTypes.entries()) {
+  ArrayPrototypeForEach(arrayBufferViewTypes, (ctor, i) => {
     const tag = ObjectPrototypeToString(new ctor(dummy));
     arrayBufferViewTypeToIndex.set(tag, i);
-  }
+  });
 }
 
-const bufferConstructorIndex = arrayBufferViewTypes.push(FastBuffer) - 1;
+const bufferConstructorIndex =
+  ArrayPrototypePush(arrayBufferViewTypes, FastBuffer) - 1;
 
 class DefaultSerializer extends Serializer {
   constructor() {
@@ -223,6 +264,12 @@ class DefaultSerializer extends Serializer {
     this._setTreatArrayBufferViewsAsHostObjects(true);
   }
 
+  /**
+   * Used to write some kind of host object, i.e. an
+   * object that is created by native C++ bindings.
+   * @param {Object} abView
+   * @returns {void}
+   */
   _writeHostObject(abView) {
     let i = 0;
     if (abView.constructor === Buffer) {
@@ -245,6 +292,11 @@ class DefaultSerializer extends Serializer {
 }
 
 class DefaultDeserializer extends Deserializer {
+  /**
+   * Used to read some kind of host object, i.e. an
+   * object that is created by native C++ bindings.
+   * @returns {any}
+   */
   _readHostObject() {
     const typeIndex = this.readUint32();
     const ctor = arrayBufferViewTypes[typeIndex];
@@ -267,6 +319,12 @@ class DefaultDeserializer extends Deserializer {
   }
 }
 
+/**
+ * Uses a `DefaultSerializer` to serialize `value`
+ * into a buffer.
+ * @param {any} value
+ * @returns {Buffer}
+ */
 function serialize(value) {
   const ser = new DefaultSerializer();
   ser.writeHeader();
@@ -274,6 +332,12 @@ function serialize(value) {
   return ser.releaseBuffer();
 }
 
+/**
+ * Uses a `DefaultDeserializer` with default options
+ * to read a JavaScript value from a buffer.
+ * @param {Buffer | TypedArray | DataView} buffer
+ * @returns {any}
+ */
 function deserialize(buffer) {
   const der = new DefaultDeserializer(buffer);
   der.readHeader();
diff --git a/lib/vm.js b/lib/vm.js
index 448b9ef0daabb061adb45737ba896c88f7c50a5d..bad7f21a9b1398a757b0099961e011cf2d9fbb08 100644
--- a/lib/vm.js
+++ b/lib/vm.js
@@ -22,18 +22,24 @@
 'use strict';
 
 const {
-  ArrayIsArray,
   ArrayPrototypeForEach,
+  ArrayPrototypeUnshift,
   Symbol,
+  PromiseReject,
+  ReflectApply,
 } = primordials;
 
 const {
   ContextifyScript,
+  MicrotaskQueue,
   makeContext,
   isContext: _isContext,
-  compileFunction: _compileFunction
+  constants,
+  compileFunction: _compileFunction,
+  measureMemory: _measureMemory,
 } = internalBinding('contextify');
 const {
+  ERR_CONTEXT_NOT_INITIALIZED,
   ERR_INVALID_ARG_TYPE,
 } = require('internal/errors').codes;
 const {
@@ -42,9 +48,17 @@ const {
 const {
   validateInt32,
   validateUint32,
-  validateString
+  validateString,
+  validateArray,
+  validateBoolean,
+  validateBuffer,
+  validateObject,
+  validateOneOf,
 } = require('internal/validators');
-const { kVmBreakFirstLineSymbol } = require('internal/util');
+const {
+  kVmBreakFirstLineSymbol,
+  emitExperimentalWarning,
+} = require('internal/util');
 const kParsingContext = Symbol('script parsing context');
 
 class Script extends ContextifyScript {
@@ -117,17 +131,17 @@ class Script extends ContextifyScript {
     if (breakOnSigint && process.listenerCount('SIGINT') > 0) {
       return sigintHandlersWrap(super.runInThisContext, this, args);
     }
-    return super.runInThisContext(...args);
+    return ReflectApply(super.runInThisContext, this, args);
   }
 
   runInContext(contextifiedObject, options) {
     validateContext(contextifiedObject);
     const { breakOnSigint, args } = getRunInContextArgs(options);
+    ArrayPrototypeUnshift(args, contextifiedObject);
     if (breakOnSigint && process.listenerCount('SIGINT') > 0) {
-      return sigintHandlersWrap(super.runInContext, this,
-                                [contextifiedObject, ...args]);
+      return sigintHandlersWrap(super.runInContext, this, args);
     }
-    return super.runInContext(contextifiedObject, ...args);
+    return ReflectApply(super.runInContext, this, args);
   }
 
   runInNewContext(contextObject, options) {
@@ -137,30 +151,14 @@ class Script extends ContextifyScript {
 }
 
 function validateContext(contextifiedObject) {
-  if (typeof contextifiedObject !== 'object' || contextifiedObject === null) {
-    throw new ERR_INVALID_ARG_TYPE('contextifiedObject', 'Object',
-                                   contextifiedObject);
-  }
-  if (!_isContext(contextifiedObject)) {
+  if (!isContext(contextifiedObject)) {
     throw new ERR_INVALID_ARG_TYPE('contextifiedObject', 'vm.Context',
                                    contextifiedObject);
   }
 }
 
-function validateBool(prop, propName) {
-  if (prop !== undefined && typeof prop !== 'boolean')
-    throw new ERR_INVALID_ARG_TYPE(propName, 'boolean', prop);
-}
-
-function validateObject(prop, propName) {
-  if (prop !== undefined && (typeof prop !== 'object' || prop === null))
-    throw new ERR_INVALID_ARG_TYPE(propName, 'Object', prop);
-}
-
 function getRunInContextArgs(options = {}) {
-  if (typeof options !== 'object' || options === null) {
-    throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
-  }
+  validateObject(options, 'options');
 
   let timeout = options.timeout;
   if (timeout === undefined) {
@@ -175,14 +173,8 @@ function getRunInContextArgs(options = {}) {
     [kVmBreakFirstLineSymbol]: breakFirstLine = false,
   } = options;
 
-  if (typeof displayErrors !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE('options.displayErrors', 'boolean',
-                                   displayErrors);
-  }
-  if (typeof breakOnSigint !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE('options.breakOnSigint', 'boolean',
-                                   breakOnSigint);
-  }
+  validateBoolean(displayErrors, 'options.displayErrors');
+  validateBoolean(breakOnSigint, 'options.breakOnSigint');
 
   return {
     breakOnSigint,
@@ -191,36 +183,36 @@ function getRunInContextArgs(options = {}) {
 }
 
 function getContextOptions(options) {
-  if (options) {
+  if (!options)
+    return {};
+  const contextOptions = {
+    name: options.contextName,
+    origin: options.contextOrigin,
+    codeGeneration: undefined,
+    microtaskMode: options.microtaskMode,
+  };
+  if (contextOptions.name !== undefined)
+    validateString(contextOptions.name, 'options.contextName');
+  if (contextOptions.origin !== undefined)
+    validateString(contextOptions.origin, 'options.contextOrigin');
+  if (options.contextCodeGeneration !== undefined) {
     validateObject(options.contextCodeGeneration,
                    'options.contextCodeGeneration');
-    const contextOptions = {
-      name: options.contextName,
-      origin: options.contextOrigin,
-      codeGeneration: typeof options.contextCodeGeneration === 'object' ? {
-        strings: options.contextCodeGeneration.strings,
-        wasm: options.contextCodeGeneration.wasm,
-      } : undefined,
-    };
-    if (contextOptions.name !== undefined)
-      validateString(contextOptions.name, 'options.contextName');
-    if (contextOptions.origin !== undefined)
-      validateString(contextOptions.origin, 'options.contextOrigin');
-    if (contextOptions.codeGeneration) {
-      validateBool(contextOptions.codeGeneration.strings,
-                   'options.contextCodeGeneration.strings');
-      validateBool(contextOptions.codeGeneration.wasm,
-                   'options.contextCodeGeneration.wasm');
-    }
-    return contextOptions;
+    const { strings, wasm } = options.contextCodeGeneration;
+    if (strings !== undefined)
+      validateBoolean(strings, 'options.contextCodeGeneration.strings');
+    if (wasm !== undefined)
+      validateBoolean(wasm, 'options.contextCodeGeneration.wasm');
+    contextOptions.codeGeneration = { strings, wasm };
   }
-  return {};
+  if (options.microtaskMode !== undefined)
+    validateString(options.microtaskMode, 'options.microtaskMode');
+  return contextOptions;
 }
 
 function isContext(object) {
-  if (typeof object !== 'object' || object === null) {
-    throw new ERR_INVALID_ARG_TYPE('object', 'Object', object);
-  }
+  validateObject(object, 'object', { allowArray: true });
+
   return _isContext(object);
 }
 
@@ -230,30 +222,39 @@ function createContext(contextObject = {}, options = {}) {
     return contextObject;
   }
 
-  if (typeof options !== 'object' || options === null) {
-    throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
-  }
+  validateObject(options, 'options');
 
   const {
     name = `VM Context ${defaultContextNameIndex++}`,
     origin,
-    codeGeneration
+    codeGeneration,
+    microtaskMode
   } = options;
 
   validateString(name, 'options.name');
   if (origin !== undefined)
     validateString(origin, 'options.origin');
-  validateObject(codeGeneration, 'options.codeGeneration');
+  if (codeGeneration !== undefined)
+    validateObject(codeGeneration, 'options.codeGeneration');
 
   let strings = true;
   let wasm = true;
   if (codeGeneration !== undefined) {
     ({ strings = true, wasm = true } = codeGeneration);
-    validateBool(strings, 'options.codeGeneration.strings');
-    validateBool(wasm, 'options.codeGeneration.wasm');
+    validateBoolean(strings, 'options.codeGeneration.strings');
+    validateBoolean(wasm, 'options.codeGeneration.wasm');
   }
 
-  makeContext(contextObject, name, origin, strings, wasm);
+  let microtaskQueue = null;
+  if (microtaskMode !== undefined) {
+    validateOneOf(microtaskMode, 'options.microtaskMode',
+                  ['afterEvaluate', undefined]);
+
+    if (microtaskMode === 'afterEvaluate')
+      microtaskQueue = new MicrotaskQueue();
+  }
+
+  makeContext(contextObject, name, origin, strings, wasm, microtaskQueue);
   return contextObject;
 }
 
@@ -269,13 +270,13 @@ function sigintHandlersWrap(fn, thisArg, argsArray) {
   process.removeAllListeners('SIGINT');
 
   try {
-    return fn.apply(thisArg, argsArray);
+    return ReflectApply(fn, thisArg, argsArray);
   } finally {
     // Add using the public methods so that the `newListener` handler of
     // process can re-attach the listeners.
-    for (const listener of sigintListeners) {
+    ArrayPrototypeForEach(sigintListeners, (listener) => {
       process.addListener('SIGINT', listener);
-    }
+    });
   }
 }
 
@@ -312,9 +313,7 @@ function runInThisContext(code, options) {
 function compileFunction(code, params, options = {}) {
   validateString(code, 'code');
   if (params !== undefined) {
-    if (!ArrayIsArray(params)) {
-      throw new ERR_INVALID_ARG_TYPE('params', 'Array', params);
-    }
+    validateArray(params, 'params');
     ArrayPrototypeForEach(params,
                           (param, i) => validateString(param, `params[${i}]`));
   }
@@ -332,20 +331,9 @@ function compileFunction(code, params, options = {}) {
   validateString(filename, 'options.filename');
   validateUint32(columnOffset, 'options.columnOffset');
   validateUint32(lineOffset, 'options.lineOffset');
-  if (cachedData !== undefined && !isArrayBufferView(cachedData)) {
-    throw new ERR_INVALID_ARG_TYPE(
-      'options.cachedData',
-      ['Buffer', 'TypedArray', 'DataView'],
-      cachedData
-    );
-  }
-  if (typeof produceCachedData !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE(
-      'options.produceCachedData',
-      'boolean',
-      produceCachedData
-    );
-  }
+  if (cachedData !== undefined)
+    validateBuffer(cachedData, 'options.cachedData');
+  validateBoolean(produceCachedData, 'options.produceCachedData');
   if (parsingContext !== undefined) {
     if (
       typeof parsingContext !== 'object' ||
@@ -359,21 +347,10 @@ function compileFunction(code, params, options = {}) {
       );
     }
   }
-  if (!ArrayIsArray(contextExtensions)) {
-    throw new ERR_INVALID_ARG_TYPE(
-      'options.contextExtensions',
-      'Array',
-      contextExtensions
-    );
-  }
+  validateArray(contextExtensions, 'options.contextExtensions');
   ArrayPrototypeForEach(contextExtensions, (extension, i) => {
-    if (typeof extension !== 'object') {
-      throw new ERR_INVALID_ARG_TYPE(
-        `options.contextExtensions[${i}]`,
-        'object',
-        extension
-      );
-    }
+    const name = `options.contextExtensions[${i}]`;
+    validateObject(extension, name, { nullable: true });
   });
 
   const result = _compileFunction(
@@ -399,6 +376,29 @@ function compileFunction(code, params, options = {}) {
   return result.function;
 }
 
+const measureMemoryModes = {
+  summary: constants.measureMemory.mode.SUMMARY,
+  detailed: constants.measureMemory.mode.DETAILED,
+};
+
+const measureMemoryExecutions = {
+  default: constants.measureMemory.execution.DEFAULT,
+  eager: constants.measureMemory.execution.EAGER,
+};
+
+function measureMemory(options = {}) {
+  emitExperimentalWarning('vm.measureMemory');
+  validateObject(options, 'options');
+  const { mode = 'summary', execution = 'default' } = options;
+  validateOneOf(mode, 'options.mode', ['summary', 'detailed']);
+  validateOneOf(execution, 'options.execution', ['default', 'eager']);
+  const result = _measureMemory(measureMemoryModes[mode],
+                                measureMemoryExecutions[execution]);
+  if (result === undefined) {
+    return PromiseReject(new ERR_CONTEXT_NOT_INITIALIZED());
+  }
+  return result;
+}
 
 module.exports = {
   Script,
@@ -409,6 +409,7 @@ module.exports = {
   runInThisContext,
   isContext,
   compileFunction,
+  measureMemory,
 };
 
 if (require('internal/options').getOptionValue('--experimental-vm-modules')) {
diff --git a/lib/wasi.js b/lib/wasi.js
index 8205bbc51349085ebd834c37e294926360a5d8c2..b3c14fc2f1484010a19b9078a81629b5d95c9fe0 100644
--- a/lib/wasi.js
+++ b/lib/wasi.js
@@ -1,11 +1,14 @@
 'use strict';
 const {
+  ArrayPrototypeForEach,
   ArrayPrototypeMap,
   ArrayPrototypePush,
   FunctionPrototypeBind,
   ObjectEntries,
+  String,
   Symbol,
 } = primordials;
+
 const {
   ERR_INVALID_ARG_TYPE,
   ERR_WASI_ALREADY_STARTED
@@ -60,18 +63,22 @@ class WASI {
     const env = [];
     if (options.env !== undefined) {
       validateObject(options.env, 'options.env');
-      for (const [key, value] of ObjectEntries(options.env)) {
-        if (value !== undefined)
-          ArrayPrototypePush(env, `${key}=${value}`);
-      }
+      ArrayPrototypeForEach(
+        ObjectEntries(options.env),
+        ({ 0: key, 1: value }) => {
+          if (value !== undefined)
+            ArrayPrototypePush(env, `${key}=${value}`);
+        });
     }
 
     const preopens = [];
     if (options.preopens !== undefined) {
       validateObject(options.preopens, 'options.preopens');
-      for (const [key, value] of ObjectEntries(options.preopens)) {
-        ArrayPrototypePush(preopens, String(key), String(value));
-      }
+      ArrayPrototypeForEach(
+        ObjectEntries(options.preopens),
+        ({ 0: key, 1: value }) =>
+          ArrayPrototypePush(preopens, String(key), String(value))
+      );
     }
 
     const { stdin = 0, stdout = 1, stderr = 2 } = options;
diff --git a/lib/worker_threads.js b/lib/worker_threads.js
index 1b9c6ae945e530fab7ac2b8a53e263634367c6fc..969e8f29794cb11ef2b95c62d34b2f788ef7eba4 100644
--- a/lib/worker_threads.js
+++ b/lib/worker_threads.js
@@ -4,6 +4,8 @@ const {
   isMainThread,
   SHARE_ENV,
   resourceLimits,
+  setEnvironmentData,
+  getEnvironmentData,
   threadId,
   Worker
 } = require('internal/worker');
@@ -32,4 +34,6 @@ module.exports = {
   Worker,
   parentPort: null,
   workerData: null,
+  setEnvironmentData,
+  getEnvironmentData,
 };
diff --git a/lib/zlib.js b/lib/zlib.js
index a3641d6c92511f71328d9640f861d5ae760d470b..6fcf0b6e46ce9b5a384a2fc598b8628fd3445346 100644
--- a/lib/zlib.js
+++ b/lib/zlib.js
@@ -23,17 +23,23 @@
 
 const {
   ArrayBuffer,
+  ArrayPrototypeForEach,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
   Error,
-  MathMax,
+  FunctionPrototypeBind,
+  MathMaxApply,
   NumberIsFinite,
   NumberIsNaN,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectFreeze,
-  ObjectGetPrototypeOf,
   ObjectKeys,
   ObjectSetPrototypeOf,
+  ReflectApply,
+  StringPrototypeStartsWith,
   Symbol,
+  TypedArrayPrototypeFill,
   Uint32Array,
 } = primordials;
 
@@ -47,13 +53,14 @@ const {
   },
   hideStackFrames
 } = require('internal/errors');
-const Transform = require('_stream_transform');
+const { Transform, finished } = require('stream');
 const {
   deprecate
 } = require('internal/util');
 const {
   isArrayBufferView,
-  isAnyArrayBuffer
+  isAnyArrayBuffer,
+  isUint8Array,
 } = require('internal/util/types');
 const binding = internalBinding('zlib');
 const assert = require('internal/assert');
@@ -64,6 +71,7 @@ const {
 const { owner_symbol } = require('internal/async_hooks').symbols;
 
 const kFlushFlag = Symbol('kFlushFlag');
+const kError = Symbol('kError');
 
 const constants = internalBinding('constants').zlib;
 const {
@@ -78,7 +86,7 @@ const {
   BROTLI_DECODE, BROTLI_ENCODE,
   // Brotli operations (~flush levels)
   BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_FLUSH,
-  BROTLI_OPERATION_FINISH
+  BROTLI_OPERATION_FINISH, BROTLI_OPERATION_EMIT_METADATA,
 } = constants;
 
 // Translation table for return codes.
@@ -101,10 +109,9 @@ for (const ckey of ObjectKeys(codes)) {
 function zlibBuffer(engine, buffer, callback) {
   if (typeof callback !== 'function')
     throw new ERR_INVALID_ARG_TYPE('callback', 'function', callback);
-  // Streams do not support non-Buffer ArrayBufferViews yet. Convert it to a
+  // Streams do not support non-Uint8Array ArrayBufferViews yet. Convert it to a
   // Buffer without copying.
-  if (isArrayBufferView(buffer) &&
-      ObjectGetPrototypeOf(buffer) !== Buffer.prototype) {
+  if (isArrayBufferView(buffer) && !isUint8Array(buffer)) {
     buffer = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
   } else if (isAnyArrayBuffer(buffer)) {
     buffer = Buffer.from(buffer);
@@ -122,7 +129,7 @@ function zlibBufferOnData(chunk) {
   if (!this.buffers)
     this.buffers = [chunk];
   else
-    this.buffers.push(chunk);
+    ArrayPrototypePush(this.buffers, chunk);
   this.nread += chunk.length;
   if (this.nread > this._maxOutputLength) {
     this.close();
@@ -175,14 +182,13 @@ function zlibOnError(message, errno, code) {
   const self = this[owner_symbol];
   // There is no way to cleanly recover.
   // Continuing only obscures problems.
-  _close(self);
-  self._hadError = true;
 
   // eslint-disable-next-line no-restricted-syntax
   const error = new Error(message);
   error.errno = errno;
   error.code = code;
-  self.emit('error', error);
+  self.destroy(error);
+  self[kError] = error;
 }
 
 // 1. Returns false for undefined and NaN
@@ -229,6 +235,13 @@ const checkRangesOrGetDefault = hideStackFrames(
   }
 );
 
+const FLUSH_BOUND = [
+  [ Z_NO_FLUSH, Z_BLOCK ],
+  [ BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_EMIT_METADATA ],
+];
+const FLUSH_BOUND_IDX_NORMAL = 0;
+const FLUSH_BOUND_IDX_BROTLI = 1;
+
 // The base class for all Zlib-style streams.
 function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
   let chunkSize = Z_DEFAULT_CHUNK;
@@ -238,6 +251,13 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
   assert(typeof mode === 'number');
   assert(mode >= DEFLATE && mode <= BROTLI_ENCODE);
 
+  let flushBoundIdx;
+  if (mode !== BROTLI_ENCODE && mode !== BROTLI_DECODE) {
+    flushBoundIdx = FLUSH_BOUND_IDX_NORMAL;
+  } else {
+    flushBoundIdx = FLUSH_BOUND_IDX_BROTLI;
+  }
+
   if (opts) {
     chunkSize = opts.chunkSize;
     if (!checkFiniteNumber(chunkSize, 'options.chunkSize')) {
@@ -249,11 +269,12 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
 
     flush = checkRangesOrGetDefault(
       opts.flush, 'options.flush',
-      Z_NO_FLUSH, Z_BLOCK, flush);
+      FLUSH_BOUND[flushBoundIdx][0], FLUSH_BOUND[flushBoundIdx][1], flush);
 
     finishFlush = checkRangesOrGetDefault(
       opts.finishFlush, 'options.finishFlush',
-      Z_NO_FLUSH, Z_BLOCK, finishFlush);
+      FLUSH_BOUND[flushBoundIdx][0], FLUSH_BOUND[flushBoundIdx][1],
+      finishFlush);
 
     maxOutputLength = checkRangesOrGetDefault(
       opts.maxOutputLength, 'options.maxOutputLength',
@@ -267,8 +288,8 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
     }
   }
 
-  Transform.call(this, opts);
-  this._hadError = false;
+  ReflectApply(Transform, this, [{ autoDestroy: true, ...opts }]);
+  this[kError] = null;
   this.bytesWritten = 0;
   this._handle = handle;
   handle[owner_symbol] = this;
@@ -281,7 +302,6 @@ function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
   this._defaultFlushFlag = flush;
   this._finishFlushFlag = finishFlush;
   this._defaultFullFlushFlag = fullFlush;
-  this.once('end', _close.bind(null, this));
   this._info = opts && opts.info;
   this._maxOutputLength = maxOutputLength;
 }
@@ -374,7 +394,7 @@ ZlibBase.prototype.flush = function(kind, callback) {
 };
 
 ZlibBase.prototype.close = function(callback) {
-  _close(this, callback);
+  if (callback) finished(this, callback);
   this.destroy();
 };
 
@@ -437,6 +457,8 @@ function processChunkSync(self, chunk, flushFlag) {
                      availOutBefore); // out_len
     if (error)
       throw error;
+    else if (self[kError])
+      throw self[kError];
 
     availOutAfter = state[0];
     availInAfter = state[1];
@@ -451,7 +473,7 @@ function processChunkSync(self, chunk, flushFlag) {
       if (!buffers)
         buffers = [out];
       else
-        buffers.push(out);
+        ArrayPrototypePush(buffers, out);
       nread += out.byteLength;
 
       if (nread > self._maxOutputLength) {
@@ -519,7 +541,7 @@ function processCallback() {
   const self = this[owner_symbol];
   const state = self._writeState;
 
-  if (self._hadError || self.destroyed) {
+  if (self.destroyed) {
     this.buffer = null;
     this.cb();
     return;
@@ -585,10 +607,7 @@ function processCallback() {
   this.cb();
 }
 
-function _close(engine, callback) {
-  if (callback)
-    process.nextTick(callback);
-
+function _close(engine) {
   // Caller may invoke .close after a zlib error (which will null _handle).
   if (!engine._handle)
     return;
@@ -667,7 +686,7 @@ function Zlib(opts, mode) {
               processCallback,
               dictionary);
 
-  ZlibBase.call(this, opts, mode, handle, zlibDefaultOpts);
+  ReflectApply(ZlibBase, this, [opts, mode, handle, zlibDefaultOpts]);
 
   this._level = level;
   this._strategy = strategy;
@@ -682,7 +701,7 @@ ObjectSetPrototypeOf(Zlib, ZlibBase);
 function paramsAfterFlushCallback(level, strategy, callback) {
   assert(this._handle, 'zlib binding closed');
   this._handle.params(level, strategy);
-  if (!this._hadError) {
+  if (!this.destroyed) {
     this._level = level;
     this._strategy = strategy;
     if (callback) callback();
@@ -695,7 +714,8 @@ Zlib.prototype.params = function params(level, strategy, callback) {
 
   if (this._level !== level || this._strategy !== strategy) {
     this.flush(Z_SYNC_FLUSH,
-               paramsAfterFlushCallback.bind(this, level, strategy, callback));
+               FunctionPrototypeBind(paramsAfterFlushCallback, this,
+                                     level, strategy, callback));
   } else {
     process.nextTick(callback);
   }
@@ -706,7 +726,7 @@ Zlib.prototype.params = function params(level, strategy, callback) {
 function Deflate(opts) {
   if (!(this instanceof Deflate))
     return new Deflate(opts);
-  Zlib.call(this, opts, DEFLATE);
+  ReflectApply(Zlib, this, [opts, DEFLATE]);
 }
 ObjectSetPrototypeOf(Deflate.prototype, Zlib.prototype);
 ObjectSetPrototypeOf(Deflate, Zlib);
@@ -714,7 +734,7 @@ ObjectSetPrototypeOf(Deflate, Zlib);
 function Inflate(opts) {
   if (!(this instanceof Inflate))
     return new Inflate(opts);
-  Zlib.call(this, opts, INFLATE);
+  ReflectApply(Zlib, this, [opts, INFLATE]);
 }
 ObjectSetPrototypeOf(Inflate.prototype, Zlib.prototype);
 ObjectSetPrototypeOf(Inflate, Zlib);
@@ -722,7 +742,7 @@ ObjectSetPrototypeOf(Inflate, Zlib);
 function Gzip(opts) {
   if (!(this instanceof Gzip))
     return new Gzip(opts);
-  Zlib.call(this, opts, GZIP);
+  ReflectApply(Zlib, this, [opts, GZIP]);
 }
 ObjectSetPrototypeOf(Gzip.prototype, Zlib.prototype);
 ObjectSetPrototypeOf(Gzip, Zlib);
@@ -730,7 +750,7 @@ ObjectSetPrototypeOf(Gzip, Zlib);
 function Gunzip(opts) {
   if (!(this instanceof Gunzip))
     return new Gunzip(opts);
-  Zlib.call(this, opts, GUNZIP);
+  ReflectApply(Zlib, this, [opts, GUNZIP]);
 }
 ObjectSetPrototypeOf(Gunzip.prototype, Zlib.prototype);
 ObjectSetPrototypeOf(Gunzip, Zlib);
@@ -739,7 +759,7 @@ function DeflateRaw(opts) {
   if (opts && opts.windowBits === 8) opts.windowBits = 9;
   if (!(this instanceof DeflateRaw))
     return new DeflateRaw(opts);
-  Zlib.call(this, opts, DEFLATERAW);
+  ReflectApply(Zlib, this, [opts, DEFLATERAW]);
 }
 ObjectSetPrototypeOf(DeflateRaw.prototype, Zlib.prototype);
 ObjectSetPrototypeOf(DeflateRaw, Zlib);
@@ -747,7 +767,7 @@ ObjectSetPrototypeOf(DeflateRaw, Zlib);
 function InflateRaw(opts) {
   if (!(this instanceof InflateRaw))
     return new InflateRaw(opts);
-  Zlib.call(this, opts, INFLATERAW);
+  ReflectApply(Zlib, this, [opts, INFLATERAW]);
 }
 ObjectSetPrototypeOf(InflateRaw.prototype, Zlib.prototype);
 ObjectSetPrototypeOf(InflateRaw, Zlib);
@@ -755,7 +775,7 @@ ObjectSetPrototypeOf(InflateRaw, Zlib);
 function Unzip(opts) {
   if (!(this instanceof Unzip))
     return new Unzip(opts);
-  Zlib.call(this, opts, UNZIP);
+  ReflectApply(Zlib, this, [opts, UNZIP]);
 }
 ObjectSetPrototypeOf(Unzip.prototype, Zlib.prototype);
 ObjectSetPrototypeOf(Unzip, Zlib);
@@ -775,9 +795,12 @@ function createConvenienceMethod(ctor, sync) {
   };
 }
 
-const kMaxBrotliParam = MathMax(...ObjectKeys(constants).map((key) => {
-  return key.startsWith('BROTLI_PARAM_') ? constants[key] : 0;
-}));
+const kMaxBrotliParam = MathMaxApply(ArrayPrototypeMap(
+  ObjectKeys(constants),
+  (key) => (StringPrototypeStartsWith(key, 'BROTLI_PARAM_') ?
+    constants[key] :
+    0)
+));
 
 const brotliInitParamsArray = new Uint32Array(kMaxBrotliParam + 1);
 
@@ -789,9 +812,9 @@ const brotliDefaultOpts = {
 function Brotli(opts, mode) {
   assert(mode === BROTLI_DECODE || mode === BROTLI_ENCODE);
 
-  brotliInitParamsArray.fill(-1);
-  if (opts && opts.params) {
-    for (const origKey of ObjectKeys(opts.params)) {
+  TypedArrayPrototypeFill(brotliInitParamsArray, -1);
+  if (opts?.params) {
+    ArrayPrototypeForEach(ObjectKeys(opts.params), (origKey) => {
       const key = +origKey;
       if (NumberIsNaN(key) || key < 0 || key > kMaxBrotliParam ||
           (brotliInitParamsArray[key] | 0) !== -1) {
@@ -804,7 +827,7 @@ function Brotli(opts, mode) {
                                        'number', opts.params[origKey]);
       }
       brotliInitParamsArray[key] = value;
-    }
+    });
   }
 
   const handle = mode === BROTLI_DECODE ?
@@ -820,7 +843,7 @@ function Brotli(opts, mode) {
     throw new ERR_ZLIB_INITIALIZATION_FAILED();
   }
 
-  ZlibBase.call(this, opts, mode, handle, brotliDefaultOpts);
+  ReflectApply(ZlibBase, this, [opts, mode, handle, brotliDefaultOpts]);
 }
 ObjectSetPrototypeOf(Brotli.prototype, Zlib.prototype);
 ObjectSetPrototypeOf(Brotli, Zlib);
@@ -828,7 +851,7 @@ ObjectSetPrototypeOf(Brotli, Zlib);
 function BrotliCompress(opts) {
   if (!(this instanceof BrotliCompress))
     return new BrotliCompress(opts);
-  Brotli.call(this, opts, BROTLI_ENCODE);
+  ReflectApply(Brotli, this, [opts, BROTLI_ENCODE]);
 }
 ObjectSetPrototypeOf(BrotliCompress.prototype, Brotli.prototype);
 ObjectSetPrototypeOf(BrotliCompress, Brotli);
@@ -836,7 +859,7 @@ ObjectSetPrototypeOf(BrotliCompress, Brotli);
 function BrotliDecompress(opts) {
   if (!(this instanceof BrotliDecompress))
     return new BrotliDecompress(opts);
-  Brotli.call(this, opts, BROTLI_DECODE);
+  ReflectApply(Brotli, this, [opts, BROTLI_DECODE]);
 }
 ObjectSetPrototypeOf(BrotliDecompress.prototype, Brotli.prototype);
 ObjectSetPrototypeOf(BrotliDecompress, Brotli);
@@ -917,7 +940,7 @@ ObjectDefineProperties(module.exports, {
 // These should be considered deprecated
 // expose all the zlib constants
 for (const bkey of ObjectKeys(constants)) {
-  if (bkey.startsWith('BROTLI')) continue;
+  if (StringPrototypeStartsWith(bkey, 'BROTLI')) continue;
   ObjectDefineProperty(module.exports, bkey, {
     enumerable: false, value: constants[bkey], writable: false
   });
diff --git a/node.gyp b/node.gyp
index 48fd7a124a6961c55016a0c14f1dae4055bf147f..63f60a924bb98a6d54872ec9b497a1adf689fdc9 100644
--- a/node.gyp
+++ b/node.gyp
@@ -1,8 +1,9 @@
 {
   'variables': {
     'v8_use_siphash%': 0,
-    'v8_use_snapshot%': 0,
     'v8_trace_maps%': 0,
+    'v8_enable_pointer_compression%': 0,
+    'v8_enable_31bit_smis_on_64bit_arch%': 0,
     'node_use_dtrace%': 'false',
     'node_use_etw%': 'false',
     'node_no_browser_globals%': 'false',
@@ -26,208 +27,15 @@
     'node_lib_target_name%': 'libnode',
     'node_intermediate_lib_type%': 'static_library',
     'node_builtin_modules_path%': '',
+    # We list the deps/ files out instead of globbing them in js2c.py since we
+    # only include a subset of all the files under these directories.
+    # The lengths of their file names combined should not exceed the
+    # Windows command length limit or there would be an error.
+    # See https://docs.microsoft.com/en-us/troubleshoot/windows-client/shell-experience/command-line-string-limitation
     'library_files': [
-      'lib/internal/bootstrap/environment.js',
-      'lib/internal/bootstrap/loaders.js',
-      'lib/internal/bootstrap/node.js',
-      'lib/internal/bootstrap/pre_execution.js',
-      'lib/internal/bootstrap/switches/does_own_process_state.js',
-      'lib/internal/bootstrap/switches/does_not_own_process_state.js',
-      'lib/internal/bootstrap/switches/is_main_thread.js',
-      'lib/internal/bootstrap/switches/is_not_main_thread.js',
-      'lib/internal/per_context/primordials.js',
-      'lib/internal/per_context/domexception.js',
-      'lib/internal/per_context/messageport.js',
-      'lib/async_hooks.js',
-      'lib/assert.js',
-      'lib/buffer.js',
-      'lib/child_process.js',
-      'lib/console.js',
-      'lib/constants.js',
-      'lib/crypto.js',
-      'lib/cluster.js',
-      'lib/dgram.js',
-      'lib/dns.js',
-      'lib/domain.js',
-      'lib/events.js',
-      'lib/fs.js',
-      'lib/http.js',
-      'lib/http2.js',
-      'lib/_http_agent.js',
-      'lib/_http_client.js',
-      'lib/_http_common.js',
-      'lib/_http_incoming.js',
-      'lib/_http_outgoing.js',
-      'lib/_http_server.js',
-      'lib/https.js',
-      'lib/inspector.js',
-      'lib/module.js',
-      'lib/net.js',
-      'lib/os.js',
-      'lib/path.js',
-      'lib/perf_hooks.js',
-      'lib/process.js',
-      'lib/punycode.js',
-      'lib/querystring.js',
-      'lib/readline.js',
-      'lib/repl.js',
-      'lib/stream.js',
-      'lib/_stream_readable.js',
-      'lib/_stream_writable.js',
-      'lib/_stream_duplex.js',
-      'lib/_stream_transform.js',
-      'lib/_stream_passthrough.js',
-      'lib/_stream_wrap.js',
-      'lib/string_decoder.js',
-      'lib/sys.js',
-      'lib/timers.js',
-      'lib/tls.js',
-      'lib/_tls_common.js',
-      'lib/_tls_wrap.js',
-      'lib/trace_events.js',
-      'lib/tty.js',
-      'lib/url.js',
-      'lib/util.js',
-      'lib/v8.js',
-      'lib/vm.js',
-      'lib/wasi.js',
-      'lib/worker_threads.js',
-      'lib/zlib.js',
-      'lib/internal/assert.js',
-      'lib/internal/assert/assertion_error.js',
-      'lib/internal/assert/calltracker.js',
-      'lib/internal/async_hooks.js',
-      'lib/internal/buffer.js',
-      'lib/internal/cli_table.js',
-      'lib/internal/child_process.js',
-      'lib/internal/child_process/serialization.js',
-      'lib/internal/cluster/child.js',
-      'lib/internal/cluster/master.js',
-      'lib/internal/cluster/round_robin_handle.js',
-      'lib/internal/cluster/shared_handle.js',
-      'lib/internal/cluster/utils.js',
-      'lib/internal/cluster/worker.js',
-      'lib/internal/console/constructor.js',
-      'lib/internal/console/global.js',
-      'lib/internal/crypto/certificate.js',
-      'lib/internal/crypto/cipher.js',
-      'lib/internal/crypto/diffiehellman.js',
-      'lib/internal/crypto/hash.js',
-      'lib/internal/crypto/keygen.js',
-      'lib/internal/crypto/keys.js',
-      'lib/internal/crypto/pbkdf2.js',
-      'lib/internal/crypto/random.js',
-      'lib/internal/crypto/scrypt.js',
-      'lib/internal/crypto/sig.js',
-      'lib/internal/crypto/util.js',
-      'lib/internal/constants.js',
-      'lib/internal/dgram.js',
-      'lib/internal/dns/promises.js',
-      'lib/internal/dns/utils.js',
-      'lib/internal/dtrace.js',
-      'lib/internal/encoding.js',
-      'lib/internal/errors.js',
-      'lib/internal/error_serdes.js',
-      'lib/internal/fixed_queue.js',
-      'lib/internal/freelist.js',
-      'lib/internal/freeze_intrinsics.js',
-      'lib/internal/fs/dir.js',
-      'lib/internal/fs/promises.js',
-      'lib/internal/fs/read_file_context.js',
-      'lib/internal/fs/rimraf.js',
-      'lib/internal/fs/streams.js',
-      'lib/internal/fs/sync_write_stream.js',
-      'lib/internal/fs/utils.js',
-      'lib/internal/fs/watchers.js',
-      'lib/internal/http.js',
-      'lib/internal/heap_utils.js',
-      'lib/internal/histogram.js',
-      'lib/internal/idna.js',
-      'lib/internal/inspector_async_hook.js',
-      'lib/internal/js_stream_socket.js',
-      'lib/internal/linkedlist.js',
-      'lib/internal/main/check_syntax.js',
-      'lib/internal/main/eval_string.js',
-      'lib/internal/main/eval_stdin.js',
-      'lib/internal/main/inspect.js',
-      'lib/internal/main/print_help.js',
-      'lib/internal/main/prof_process.js',
-      'lib/internal/main/repl.js',
-      'lib/internal/main/run_main_module.js',
-      'lib/internal/main/run_third_party_main.js',
-      'lib/internal/main/worker_thread.js',
-      'lib/internal/modules/run_main.js',
-      'lib/internal/modules/package_json_reader.js',
-      'lib/internal/modules/cjs/helpers.js',
-      'lib/internal/modules/cjs/loader.js',
-      'lib/internal/modules/esm/loader.js',
-      'lib/internal/modules/esm/create_dynamic_module.js',
-      'lib/internal/modules/esm/get_format.js',
-      'lib/internal/modules/esm/get_source.js',
-      'lib/internal/modules/esm/module_job.js',
-      'lib/internal/modules/esm/module_map.js',
-      'lib/internal/modules/esm/resolve.js',
-      'lib/internal/modules/esm/transform_source.js',
-      'lib/internal/modules/esm/translators.js',
-      'lib/internal/net.js',
-      'lib/internal/options.js',
-      'lib/internal/policy/manifest.js',
-      'lib/internal/policy/sri.js',
-      'lib/internal/priority_queue.js',
-      'lib/internal/process/esm_loader.js',
-      'lib/internal/process/execution.js',
-      'lib/internal/process/per_thread.js',
-      'lib/internal/process/policy.js',
-      'lib/internal/process/promises.js',
-      'lib/internal/process/warning.js',
-      'lib/internal/process/worker_thread_only.js',
-      'lib/internal/process/report.js',
-      'lib/internal/process/signal.js',
-      'lib/internal/process/task_queues.js',
-      'lib/internal/querystring.js',
-      'lib/internal/readline/utils.js',
-      'lib/internal/repl.js',
-      'lib/internal/repl/await.js',
-      'lib/internal/repl/history.js',
-      'lib/internal/repl/utils.js',
-      'lib/internal/socket_list.js',
-      'lib/internal/source_map/prepare_stack_trace.js',
-      'lib/internal/source_map/source_map.js',
-      'lib/internal/source_map/source_map_cache.js',
-      'lib/internal/test/binding.js',
-      'lib/internal/timers.js',
-      'lib/internal/tls.js',
-      'lib/internal/trace_events_async_hooks.js',
-      'lib/internal/tty.js',
-      'lib/internal/url.js',
-      'lib/internal/util.js',
-      'lib/internal/util/comparisons.js',
-      'lib/internal/util/debuglog.js',
-      'lib/internal/util/inspect.js',
-      'lib/internal/util/inspector.js',
-      'lib/internal/util/types.js',
-      'lib/internal/http2/core.js',
-      'lib/internal/http2/compat.js',
-      'lib/internal/http2/util.js',
-      'lib/internal/v8_prof_polyfill.js',
-      'lib/internal/v8_prof_processor.js',
-      'lib/internal/validators.js',
-      'lib/internal/stream_base_commons.js',
-      'lib/internal/vm/module.js',
-      'lib/internal/worker.js',
-      'lib/internal/worker/io.js',
-      'lib/internal/worker/js_transferable.js',
-      'lib/internal/watchdog.js',
-      'lib/internal/streams/lazy_transform.js',
-      'lib/internal/streams/async_iterator.js',
-      'lib/internal/streams/buffer_list.js',
-      'lib/internal/streams/duplexpair.js',
-      'lib/internal/streams/from.js',
-      'lib/internal/streams/legacy.js',
-      'lib/internal/streams/destroy.js',
-      'lib/internal/streams/state.js',
-      'lib/internal/streams/pipeline.js',
-      'lib/internal/streams/end-of-stream.js',
+      '<@(node_library_files)',
+    ],
+    'deps_files': [
       'deps/v8/tools/splaytree.js',
       'deps/v8/tools/codemap.js',
       'deps/v8/tools/consarray.js',
@@ -239,16 +47,8 @@
       'deps/v8/tools/tickprocessor.js',
       'deps/v8/tools/SourceMap.js',
       'deps/v8/tools/tickprocessor-driver.js',
-      'deps/node-inspect/lib/_inspect.js',
-      'deps/node-inspect/lib/internal/inspect_client.js',
-      'deps/node-inspect/lib/internal/inspect_repl.js',
       'deps/acorn/acorn/dist/acorn.js',
       'deps/acorn/acorn-walk/dist/walk.js',
-      'deps/acorn-plugins/acorn-class-fields/index.js',
-      'deps/acorn-plugins/acorn-numeric-separator/index.js',
-      'deps/acorn-plugins/acorn-private-class-elements/index.js',
-      'deps/acorn-plugins/acorn-private-methods/index.js',
-      'deps/acorn-plugins/acorn-static-class-features/index.js',
       'deps/cjs-module-lexer/lexer.js',
       'deps/cjs-module-lexer/dist/lexer.js',
     ],
@@ -327,7 +127,7 @@
       'target_name': 'node_text_start',
       'type': 'none',
       'conditions': [
-        [ 'OS in "linux freebsd" and '
+        [ 'OS in "linux freebsd solaris" and '
           'target_arch=="x64"', {
           'type': 'static_library',
           'sources': [
@@ -379,6 +179,12 @@
       'msvs_disabled_warnings!': [4244],
 
       'conditions': [
+        [ 'error_on_warn=="true"', {
+          'cflags': ['-Werror'],
+          'xcode_settings': {
+            'WARNING_CFLAGS': [ '-Werror' ],
+          },
+        }],
         [ 'node_intermediate_lib_type=="static_library" and '
             'node_shared=="true" and OS=="aix"', {
           # For AIX, shared lib is linked by static lib and .exp. In the
@@ -537,6 +343,7 @@
         '<(SHARED_INTERMEDIATE_DIR)' # for node_natives.h
       ],
       'dependencies': [
+        'deps/googletest/googletest.gyp:gtest_prod',
         'deps/histogram/histogram.gyp:histogram',
         'deps/uvwasi/uvwasi.gyp:uvwasi',
       ],
@@ -571,6 +378,7 @@
         'src/node.cc',
         'src/node_api.cc',
         'src/node_binding.cc',
+        'src/node_blob.cc',
         'src/node_buffer.cc',
         'src/node_config.cc',
         'src/node_constants.cc',
@@ -580,8 +388,7 @@
         'src/node_env_var.cc',
         'src/node_errors.cc',
         'src/node_file.cc',
-        'src/node_http_parser_llhttp.cc',
-        'src/node_http_parser_traditional.cc',
+        'src/node_http_parser.cc',
         'src/node_http2.cc',
         'src/node_i18n.cc',
         'src/node_main_instance.cc',
@@ -608,6 +415,7 @@
         'src/node_trace_events.cc',
         'src/node_types.cc',
         'src/node_url.cc',
+        'src/node_url_tables.cc',
         'src/node_util.cc',
         'src/node_v8.cc',
         'src/node_wasi.cc',
@@ -616,7 +424,6 @@
         'src/node_zlib.cc',
         'src/pipe_wrap.cc',
         'src/process_wrap.cc',
-        'src/sharedarraybuffer_metadata.cc',
         'src/signal_wrap.cc',
         'src/spawn_sync.cc',
         'src/stream_base.cc',
@@ -626,6 +433,7 @@
         'src/string_decoder.cc',
         'src/tcp_wrap.cc',
         'src/timers.cc',
+        'src/timer_wrap.cc',
         'src/tracing/agent.cc',
         'src/tracing/node_trace_buffer.cc',
         'src/tracing/node_trace_writer.cc',
@@ -637,11 +445,16 @@
         'src/uv.cc',
         # headers to make for a more pleasant IDE experience
         'src/aliased_buffer.h',
+        'src/aliased_struct.h',
+        'src/aliased_struct-inl.h',
+        'src/allocated_buffer.h',
+        'src/allocated_buffer-inl.h',
         'src/async_wrap.h',
         'src/async_wrap-inl.h',
         'src/base_object.h',
         'src/base_object-inl.h',
         'src/base64.h',
+        'src/base64-inl.h',
         'src/callback_queue.h',
         'src/callback_queue-inl.h',
         'src/connect_wrap.h',
@@ -653,7 +466,6 @@
         'src/handle_wrap.h',
         'src/histogram.h',
         'src/histogram-inl.h',
-        'src/http_parser_adaptor.h',
         'src/js_stream.h',
         'src/json_utils.h',
         'src/large_pages/node_large_page.cc',
@@ -665,6 +477,7 @@
         'src/node_api.h',
         'src/node_api_types.h',
         'src/node_binding.h',
+        'src/node_blob.h',
         'src/node_buffer.h',
         'src/node_constants.h',
         'src/node_context_data.h',
@@ -673,7 +486,8 @@
         'src/node_errors.h',
         'src/node_file.h',
         'src/node_file-inl.h',
-        'src/node_http_parser_impl.h',
+        'src/node_http_common.h',
+        'src/node_http_common-inl.h',
         'src/node_http2.h',
         'src/node_http2_state.h',
         'src/node_i18n.h',
@@ -693,6 +507,7 @@
         'src/node_perf_common.h',
         'src/node_platform.h',
         'src/node_process.h',
+        'src/node_process-inl.h',
         'src/node_report.h',
         'src/node_revert.h',
         'src/node_root_certs.h',
@@ -702,6 +517,7 @@
         'src/node_union_bytes.h',
         'src/node_url.h',
         'src/node_version.h',
+        'src/node_v8.h',
         'src/node_v8_platform-inl.h',
         'src/node_wasi.h',
         'src/node_watchdog.h',
@@ -709,7 +525,6 @@
         'src/pipe_wrap.h',
         'src/req_wrap.h',
         'src/req_wrap-inl.h',
-        'src/sharedarraybuffer_metadata.h',
         'src/spawn_sync.h',
         'src/stream_base.h',
         'src/stream_base-inl.h',
@@ -726,15 +541,16 @@
         'src/tracing/trace_event.h',
         'src/tracing/trace_event_common.h',
         'src/tracing/traced_value.h',
+        'src/timer_wrap.h',
         'src/tty_wrap.h',
         'src/udp_wrap.h',
         'src/util.h',
         'src/util-inl.h',
         # Dependency headers
-        'deps/http_parser/http_parser.h',
         'deps/v8/include/v8.h',
         # javascript files to make for an even more pleasant IDE experience
         '<@(library_files)',
+        '<@(deps_files)',
         # node.gyp is added by default, common.gypi is added for change detection
         'common.gypi',
       ],
@@ -763,6 +579,12 @@
             'NODE_OPENSSL_DEFAULT_CIPHER_LIST="<(openssl_default_cipher_list)"'
            ]
         }],
+        [ 'error_on_warn=="true"', {
+          'cflags': ['-Werror'],
+          'xcode_settings': {
+            'WARNING_CFLAGS': [ '-Werror' ],
+          },
+        }],
         [ 'node_builtin_modules_path!=""', {
           'defines': [ 'NODE_BUILTIN_MODULES_PATH="<(node_builtin_modules_path)"' ]
         }],
@@ -883,7 +705,7 @@
             'src/tls_wrap.h'
           ],
         }],
-        [ 'OS in "linux freebsd mac" and '
+        [ 'OS in "linux freebsd mac solaris" and '
           'target_arch=="x64" and '
           'node_target_type=="executable"', {
           'defines': [ 'NODE_ENABLE_LARGE_CODE_PAGES=1' ],
@@ -923,7 +745,7 @@
               'outputs': ['<(SHARED_INTERMEDIATE_DIR)/openssl.def'],
               'process_outputs_as_sources': 1,
               'action': [
-                'python',
+                '<(python)',
                 'tools/mkssldef.py',
                 '<@(mkssldef_flags)',
                 '-o',
@@ -942,14 +764,21 @@
             # Put the code first so it's a dependency and can be used for invocation.
             'tools/js2c.py',
             '<@(library_files)',
+            '<@(deps_files)',
             'config.gypi'
           ],
           'outputs': [
             '<(SHARED_INTERMEDIATE_DIR)/node_javascript.cc',
           ],
           'action': [
-            'python', '<@(_inputs)',
-            '--target', '<@(_outputs)',
+            '<(python)',
+            'tools/js2c.py',
+            '--directory',
+            'lib',
+            '--target',
+            '<@(_outputs)',
+            'config.gypi',
+            '<@(deps_files)',
           ],
         },
       ],
@@ -1193,6 +1022,8 @@
 
       'dependencies': [
         '<(node_lib_target_name)',
+        'deps/googletest/googletest.gyp:gtest',
+        'deps/googletest/googletest.gyp:gtest_main',
         'deps/histogram/histogram.gyp:histogram',
         'deps/uvwasi/uvwasi.gyp:uvwasi',
         'node_dtrace_header',
@@ -1223,8 +1054,6 @@
       'sources': [
         'src/node_snapshot_stub.cc',
         'src/node_code_cache_stub.cc',
-        'test/cctest/gtest/gtest-all.cc',
-        'test/cctest/gtest/gtest_main.cc',
         'test/cctest/node_test_fixture.cc',
         'test/cctest/node_test_fixture.h',
         'test/cctest/test_aliased_buffer.cc',
@@ -1232,7 +1061,9 @@
         'test/cctest/test_base_object_ptr.cc',
         'test/cctest/test_node_postmortem_metadata.cc',
         'test/cctest/test_environment.cc',
+        'test/cctest/test_js_native_api_v8.cc',
         'test/cctest/test_linked_binding.cc',
+        'test/cctest/test_node_api.cc',
         'test/cctest/test_per_process.cc',
         'test/cctest/test_platform.cc',
         'test/cctest/test_json_utils.cc',
@@ -1339,6 +1170,24 @@
       ],
     }, # embedtest
 
+    {
+      'target_name': 'overlapped-checker',
+      'type': 'executable',
+
+      'conditions': [
+        ['OS=="win"', {
+          'sources': [
+            'test/overlapped-checker/main_win.c'
+          ],
+        }],
+        ['OS!="win"', {
+          'sources': [
+            'test/overlapped-checker/main_unix.c'
+          ],
+        }],
+      ]
+    }, # overlapped-checker
+
     # TODO(joyeecheung): do not depend on node_lib,
     # instead create a smaller static library node_lib_base that does
     # just enough for node_native_module.cc and the cache builder to
@@ -1474,6 +1323,7 @@
           ],
           'sources': [
             '<@(library_files)',
+            '<@(deps_files)',
             'common.gypi',
           ],
           'direct_dependent_settings': {
diff --git a/node.gypi b/node.gypi
index 116c1c7149425bdba1f9e5066314c1817a4d1c11..43dbda7bbf53022f957cfc17fb2329b8677c429a 100644
--- a/node.gypi
+++ b/node.gypi
@@ -70,7 +70,7 @@
     }],
     [ 'node_use_bundled_v8=="true"', {
       'dependencies': [
-        'tools/v8_gypfiles/v8.gyp:v8_maybe_snapshot',
+        'tools/v8_gypfiles/v8.gyp:v8_snapshot',
         'tools/v8_gypfiles/v8.gyp:v8_libplatform',
       ],
     }],
@@ -146,7 +146,6 @@
 
     [ 'node_shared_http_parser=="false"', {
       'dependencies': [
-        'deps/http_parser/http_parser.gyp:http_parser',
         'deps/llhttp/llhttp.gyp:llhttp'
       ],
     } ],
diff --git a/onboarding.md b/onboarding.md
index 8036e459f5122a6ccafe78ccffec6fe41c7ab652..ae65f07f37b621d65eba411dabac69be1f1f7906 100644
--- a/onboarding.md
+++ b/onboarding.md
@@ -1,6 +1,6 @@
 # Onboarding
 
-This document is an outline of the things we tell new Collaborators at their
+This document is an outline of the things we tell new collaborators at their
 onboarding session.
 
 ## One week before the onboarding session
@@ -18,7 +18,7 @@ onboarding session.
 ## Fifteen minutes before the onboarding session
 
 * Prior to the onboarding session, add the new Collaborator to
-  [the Collaborators team](https://github.com/orgs/nodejs/teams/collaborators).
+  [the collaborators team](https://github.com/orgs/nodejs/teams/collaborators).
 * Ask them if they want to join any subsystem teams. See
   [Who to CC in the issue tracker][who-to-cc].
 
@@ -26,17 +26,17 @@ onboarding session.
 
 * This session will cover:
   * [local setup](#local-setup)
-  * [project goals & values](#project-goals--values)
+  * [project goals and values](#project-goals-and-values)
   * [managing the issue tracker](#managing-the-issue-tracker)
-  * [reviewing PRs](#reviewing-prs)
-  * [landing PRs](#landing-prs)
+  * [reviewing pull requests](#reviewing-pull-requests)
+  * [landing pull requests](#landing-pull-requests)
 
 ## Local setup
 
 * git:
   * Make sure you have whitespace=fix: `git config --global --add
     apply.whitespace fix`
-  * Always continue to PR from your own GitHub fork
+  * Always create a branch in your own GitHub fork for pull requests
     * Branches in the `nodejs/node` repository are only for release lines
   * Add the canonical nodejs repository as `upstream` remote:
     * `git remote add upstream git://github.com/nodejs/node.git`
@@ -44,29 +44,23 @@ onboarding session.
     * `git checkout master`
     * `git remote update -p` OR `git fetch --all`
     * `git merge --ff-only upstream/master` (or `REMOTENAME/BRANCH`)
-  * Make a new branch for each PR you submit.
+  * Make a new branch for each pull request you submit.
   * Membership: Consider making your membership in the Node.js GitHub
-    organization public. This makes it easier to identify Collaborators.
+    organization public. This makes it easier to identify collaborators.
     Instructions on how to do that are available at
     [Publicizing or hiding organization membership][].
 
 * Notifications:
   * Use [https://github.com/notifications](https://github.com/notifications) or
     set up email
-  * Watching the main repo will flood your inbox (several hundred notifications
-    on typical weekdays), so be prepared
+  * Watching the main repository will flood your inbox (several hundred
+    notifications on typical weekdays), so be prepared
 
 The project has two venues for real-time discussion:
 * [`#nodejs-dev`](https://openjs-foundation.slack.com/archives/C019Y2T6STH) on
   the [OpenJS Foundation](https://slack-invite.openjsf.org/)
-* `#node-dev` on [webchat.freenode.net](https://webchat.freenode.net/) is a
-  great place to interact with the TSC and other Collaborators
-  * If there are any questions after the session, a good place to ask is
-    there!
-  * Presence is not mandatory, but please drop a note there if force-pushing
-    to `master`
 
-## Project goals & values
+## Project goals and values
 
 * Collaborators are the collective owners of the project
   * The project has the goals of its contributors
@@ -83,11 +77,11 @@ The project has two venues for real-time discussion:
 ## Managing the issue tracker
 
 * You have (mostly) free rein; don't hesitate to close an issue if you are
-  confident that it should be closed
-  * Be nice about closing issues! Let people know why, and that issues and PRs
-    can be reopened if necessary
+  confident that it should be closed.
+  * Be nice about closing issues! Let people know why, and that issues and pull
+    requests can be reopened if necessary.
 
-* [**See "Labels"**](./doc/guides/onboarding-extras.md#labels)
+* See [Labels][].
   * There is [a bot](https://github.com/nodejs-github-bot/github-bot) that
     applies subsystem labels (for example, `doc`, `test`, `assert`, or `buffer`)
     so that we know what parts of the code base the pull request modifies. It is
@@ -98,7 +92,7 @@ The project has two venues for real-time discussion:
       `semver-major` label
     * When adding a `semver-*` label, add a comment explaining why you're adding
       it. Do it right away so you don't forget!
-  * Please add the [`author-ready`][] label for PRs, if applicable.
+  * Please add the [`author-ready`][] label for pull requests, if applicable.
 
 * See [Who to CC in the issue tracker][who-to-cc].
   * This will come more naturally over time
@@ -107,16 +101,16 @@ The project has two venues for real-time discussion:
     * Some are WGs with some process around adding people, others are only there
       for notifications
 
-* When a discussion gets heated, you can request that other Collaborators keep
+* When a discussion gets heated, you can request that other collaborators keep
   an eye on it by opening an issue at the private
   [nodejs/moderation](https://github.com/nodejs/moderation) repository.
   * This is a repository to which all members of the `nodejs` GitHub
-    organization (not just Collaborators on Node.js core) have access. Its
+    organization (not just collaborators on Node.js core) have access. Its
     contents should not be shared externally.
   * You can find the full moderation policy
-    [here](https://github.com/nodejs/admin/blob/master/Moderation-Policy.md).
+    [here](https://github.com/nodejs/admin/blob/HEAD/Moderation-Policy.md).
 
-## Reviewing PRs
+## Reviewing pull requests
 
 * The primary goal is for the codebase to improve.
 * Secondary (but not far off) is for the person submitting code to succeed. A
@@ -153,7 +147,7 @@ The project has two venues for real-time discussion:
     * If you see that the requested changes have been made, you can clear
       another collaborator's `Changes requested` review.
     * Use `Changes requested` to indicate that you are considering some of your
-      comments to block the PR from landing.
+      comments to block the pull request from landing.
 
 * What belongs in Node.js:
   * Opinions vary – it’s good to have a broad collaborator base for that reason!
@@ -185,38 +179,40 @@ The project has two venues for real-time discussion:
       `7006` in the `PR_ID`.
     * The remaining elements on the form are typically unchanged.
   * If you need help with something CI-related:
-    * Use #node-dev (IRC) to talk to other Collaborators.
-    * Use #node-build (IRC) to talk to the Build WG members who maintain the CI
-      infrastructure.
-    * Use the [Build WG repo](https://github.com/nodejs/build) to file issues
-      for the Build WG members who maintain the CI infrastructure.
+    * Use the [Build WG repository](https://github.com/nodejs/build) to file
+      issues for the Build WG members who maintain the CI infrastructure.
 
-## Landing PRs
+## Landing pull requests
 
-See the Collaborator Guide: [Landing Pull Requests][].
+See the Collaborator Guide: [Landing pull requests][].
 
-Commits in one PR that belong to one logical change should
+Commits in one pull request that belong to one logical change should
 be squashed. It is rarely the case in onboarding exercises, so this
 needs to be pointed out separately during the onboarding.
 
 <!-- TODO(joyeechueng): provide examples about "one logical change" -->
 
-## Exercise: Make a PR adding yourself to the README
+## Exercise: Make a pull request adding yourself to the README
 
 * Example:
-  <https://github.com/nodejs/node/commit/ce986de829457c39257cd205067602e765768fb0>
-  * For raw commit message: `git log ce986de829457c39257cd205067602e765768fb0
-    -1`
+  <https://github.com/nodejs/node/commit/b58fe52692659c0bc25ddbe6afa7f4ae2c7f14a8>
+  * For raw commit message:
+    `git show --format=%Bb58fe52692659c0bc25ddbe6afa7f4ae2c7f14a8`
 * Collaborators are in alphabetical order by GitHub username.
 * Optionally, include your personal pronouns.
+* Add the `Fixes: <collaborator-nomination-issue-url>` to the commit message
+  so that when the commit lands, the nomination issue url will be
+  automatically closed.
 * Label your pull request with the `doc`, `notable-change`, and `fast-track`
-  labels.
-* Run CI on the PR. Use the `node-test-pull-request` CI task.
+  labels. The `fast-track` label should cause the Node.js GitHub bot to post a
+  comment in the pull request asking collaborators to approve the pull request
+  by leaving a 👍 reaction on the comment.
+* Run CI on the pull request. Use the `node-test-pull-request` CI task.
 * After two Collaborator approvals for the change and two Collaborator approvals
   for fast-tracking, land the PR.
-* Leave a comment in the PR: `Please 👍 this comment to approve fast-tracking`.
 * If there are not enough approvals within a reasonable time, consider the
-  single approval of the onboarding TSC member sufficient, and land the PR.
+  single approval of the onboarding TSC member sufficient, and land the pull
+  request.
   * Be sure to add the `PR-URL: <full-pr-url>` and appropriate `Reviewed-By:`
     metadata.
   * [`node-core-utils`][] automates the generation of metadata and the landing
@@ -230,7 +226,7 @@ needs to be pointed out separately during the onboarding.
 * Don't worry about making mistakes: everybody makes them, there's a lot to
   internalize and that takes time (and we recognize that!)
 * Almost any mistake you could make can be fixed or reverted.
-* The existing Collaborators trust you and are grateful for your help!
+* The existing collaborators trust you and are grateful for your help!
 * Other repositories:
   * [https://github.com/nodejs/TSC](https://github.com/nodejs/TSC)
   * [https://github.com/nodejs/build](https://github.com/nodejs/build)
@@ -244,12 +240,13 @@ needs to be pointed out separately during the onboarding.
   including accommodations, transportation, visa fees, etc. if needed. Check out
   the [summit](https://github.com/nodejs/summit) repository for details.
 
-[Code of Conduct]: https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md
-[Landing Pull Requests]: doc/guides/collaborator-guide.md#landing-pull-requests
+[Code of Conduct]: https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md
+[Labels]: doc/guides/collaborator-guide.md#labels
+[Landing pull requests]: doc/guides/collaborator-guide.md#landing-pull-requests
 [Publicizing or hiding organization membership]: https://help.github.com/articles/publicizing-or-hiding-organization-membership/
 [`author-ready`]: doc/guides/collaborator-guide.md#author-ready-pull-requests
 [`core-validate-commit`]: https://github.com/nodejs/core-validate-commit
-[`git-node`]: https://github.com/nodejs/node-core-utils/blob/master/docs/git-node.md
+[`git-node`]: https://github.com/nodejs/node-core-utils/blob/HEAD/docs/git-node.md
 [`node-core-utils`]: https://github.com/nodejs/node-core-utils
 [set up the credentials]: https://github.com/nodejs/node-core-utils#setting-up-credentials
 [two-factor authentication]: https://help.github.com/articles/securing-your-account-with-two-factor-authentication-2fa/
diff --git a/src/README.md b/src/README.md
index 5ca45fbdbf5911682e5ef781c62648790a297b98..91b9f3817a36b0d048c093fa2bc1487dd0151b6a 100644
--- a/src/README.md
+++ b/src/README.md
@@ -38,6 +38,30 @@ the [event loop][] and other operation system abstractions to Node.js.
 
 There is a [reference documentation for the libuv API][].
 
+## File structure
+
+The Node.js C++ files follow this structure:
+
+The `.h` header files contain declarations, and sometimes definitions that don’t
+require including other headers (e.g. getters, setters, etc.). They should only
+include other `.h` header files and nothing else.
+
+The `-inl.h` header files contain definitions of inline functions from the
+corresponding `.h` header file (e.g. functions marked `inline` in the
+declaration or `template` functions).  They always include the corresponding
+`.h` header file, and can include other `.h` and `-inl.h` header files as
+needed.  It is not mandatory to split out the definitions from the `.h` file
+into an `-inl.h` file, but it becomes necessary when there are multiple
+definitions and contents of other `-inl.h` files start being used. Therefore, it
+is recommended to split a `-inl.h` file when inline functions become longer than
+a few lines to keep the corresponding `.h` file readable and clean. All visible
+definitions from the `-inl.h` file should be declared in the corresponding `.h`
+header file.
+
+The `.cc` files contain definitions of non-inline functions from the
+corresponding `.h` header file. They always include the corresponding `.h`
+header file, and can include other `.h` and `-inl.h` header files as needed.
+
 ## Helpful concepts
 
 A number of concepts are involved in putting together Node.js on top of V8 and
@@ -146,9 +170,7 @@ v8::Local<v8::Value> GetFoo(v8::Local<v8::Context> context,
   // The 'foo_string' handle cannot be returned from this function because
   // it is not “escaped” with `.Escape()`.
   v8::Local<v8::String> foo_string =
-      v8::String::NewFromUtf8(isolate,
-                              "foo",
-                              v8::NewStringType::kNormal).ToLocalChecked();
+      v8::String::NewFromUtf8(isolate, "foo").ToLocalChecked();
 
   v8::Local<v8::Value> return_value;
   if (obj->Get(context, foo_string).ToLocal(&return_value)) {
@@ -383,11 +405,7 @@ void Initialize(Local<Object> target,
 
   env->SetProtoMethodNoSideEffect(channel_wrap, "getServers", GetServers);
 
-  Local<String> channel_wrap_string =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap");
-  channel_wrap->SetClassName(channel_wrap_string);
-  target->Set(env->context(), channel_wrap_string,
-              channel_wrap->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "ChannelWrap", channel_wrap);
 }
 
 // Run the `Initialize` function when loading this module through
@@ -395,6 +413,111 @@ void Initialize(Local<Object> target,
 NODE_MODULE_CONTEXT_AWARE_INTERNAL(cares_wrap, Initialize)
 ```
 
+If the C++ binding is loaded during bootstrap, it needs to be registered
+with the utilities in `node_external_reference.h`, like this:
+
+```cpp
+namespace node {
+namespace utils {
+void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  registry->Register(GetHiddenValue);
+  registry->Register(SetHiddenValue);
+  // ... register all C++ functions used to create FunctionTemplates.
+}
+}  // namespace util
+}  // namespace node
+
+// The first argument passed to `NODE_MODULE_EXTERNAL_REFERENCE`,
+// which is `util` here, needs to be added to the
+// `EXTERNAL_REFERENCE_BINDING_LIST_BASE` list in node_external_reference.h
+NODE_MODULE_EXTERNAL_REFERENCE(util, node::util::RegisterExternalReferences)
+```
+
+Otherwise, you might see an error message like this when building the
+executables:
+
+```console
+FAILED: gen/node_snapshot.cc
+cd ../../; out/Release/node_mksnapshot out/Release/gen/node_snapshot.cc
+Unknown external reference 0x107769200.
+<unresolved>
+/bin/sh: line 1:  6963 Illegal instruction: 4  out/Release/node_mksnapshot out/Release/gen/node_snapshot.cc
+```
+
+You can try using a debugger to symbolicate the external reference. For example,
+with lldb's `image lookup --address` command (with gdb it's `info symbol`):
+
+```console
+$ lldb -- out/Release/node_mksnapshot out/Release/gen/node_snapshot.cc
+(lldb) run
+Process 7012 launched: '/Users/joyee/projects/node/out/Release/node_mksnapshot' (x86_64)
+Unknown external reference 0x1004c8200.
+<unresolved>
+Process 7012 stopped
+(lldb) image lookup --address 0x1004c8200
+      Address: node_mksnapshot[0x00000001004c8200] (node_mksnapshot.__TEXT.__text + 5009920)
+      Summary: node_mksnapshot`node::util::GetHiddenValue(v8::FunctionCallbackInfo<v8::Value> const&) at node_util.cc:159
+```
+
+Which explains that the unregistered external reference is
+`node::util::GetHiddenValue` defined in `node_util.cc`.
+
+<a id="per-binding-state"></a>
+#### Per-binding state
+
+Some internal bindings, such as the HTTP parser, maintain internal state that
+only affects that particular binding. In that case, one common way to store
+that state is through the use of `Environment::AddBindingData`, which gives
+binding functions access to an object for storing such state.
+That object is always a [`BaseObject`][].
+
+Its class needs to have a static `type_name` field based on a
+constant string, in order to disambiguate it from other classes of this type,
+and which could e.g. match the binding’s name (in the example above, that would
+be `cares_wrap`).
+
+```cpp
+// In the HTTP parser source code file:
+class BindingData : public BaseObject {
+ public:
+  BindingData(Environment* env, Local<Object> obj) : BaseObject(env, obj) {}
+
+  static constexpr FastStringKey type_name { "http_parser" };
+
+  std::vector<char> parser_buffer;
+  bool parser_buffer_in_use = false;
+
+  // ...
+};
+
+// Available for binding functions, e.g. the HTTP Parser constructor:
+static void New(const FunctionCallbackInfo<Value>& args) {
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  new Parser(binding_data, args.This());
+}
+
+// ... because the initialization function told the Environment to store the
+// BindingData object:
+void InitializeHttpParser(Local<Object> target,
+                          Local<Value> unused,
+                          Local<Context> context,
+                          void* priv) {
+  Environment* env = Environment::GetCurrent(context);
+  BindingData* const binding_data =
+      env->AddBindingData<BindingData>(context, target);
+  if (binding_data == nullptr) return;
+
+  Local<FunctionTemplate> t = env->NewFunctionTemplate(Parser::New);
+  ...
+}
+```
+
+If the binding is loaded during bootstrap, add it to the
+`SERIALIZABLE_OBJECT_TYPES` list in `src/node_snapshotable.h` and
+inherit from the `SnapshotableObject` class instead. See the comments
+of `SnapshotableObject` on how to implement its serialization and
+deserialization.
+
 <a id="exception-handling"></a>
 ### Exception handling
 
@@ -447,16 +570,16 @@ The most common reasons for this are:
 holds a value of type `Local<T>`. It has methods that perform the same
 operations as the methods of `v8::Maybe`, but with different names:
 
-| `Maybe`                | `MaybeLocal`                    |
-| ---------------------- | ------------------------------- |
-| `maybe.IsNothing()`    | `maybe_local.IsEmpty()`         |
-| `maybe.IsJust()`       | `!maybe_local.IsEmpty()`        |
-| `maybe.To(&value)`     | `maybe_local.ToLocal(&local)`   |
-| `maybe.ToChecked()`    | `maybe_local.ToLocalChecked()`  |
-| `maybe.FromJust()`     | `maybe_local.ToLocalChecked()`  |
-| `maybe.Check()`        | –                               |
-| `v8::Nothing<T>()`     | `v8::MaybeLocal<T>()`           |
-| `v8::Just<T>(value)`   | `v8::MaybeLocal<T>(value)`      |
+| `Maybe`              | `MaybeLocal`                   |
+| -------------------- | ------------------------------ |
+| `maybe.IsNothing()`  | `maybe_local.IsEmpty()`        |
+| `maybe.IsJust()`     | `!maybe_local.IsEmpty()`       |
+| `maybe.To(&value)`   | `maybe_local.ToLocal(&local)`  |
+| `maybe.ToChecked()`  | `maybe_local.ToLocalChecked()` |
+| `maybe.FromJust()`   | `maybe_local.ToLocalChecked()` |
+| `maybe.Check()`      | –                              |
+| `v8::Nothing<T>()`   | `v8::MaybeLocal<T>()`          |
+| `v8::Just<T>(value)` | `v8::MaybeLocal<T>(value)`     |
 
 ##### Handling empty `Maybe`s
 
@@ -689,7 +812,7 @@ reference to its associated JavaScript object. This can be useful when one
 `BaseObject` refers to another `BaseObject` and wants to make sure it stays
 alive during the lifetime of that reference.
 
-A `BaseObject` can be “detached” throught the `BaseObject::Detach()` method.
+A `BaseObject` can be “detached” through the `BaseObject::Detach()` method.
 In this case, it will be deleted once the last `BaseObjectPtr` referring to
 it is destroyed. There must be at least one such pointer when `Detach()` is
 called. This can be useful when one `BaseObject` fully owns another
@@ -913,7 +1036,7 @@ static void GetUserInfo(const FunctionCallbackInfo<Value>& args) {
 [exception handling]: #exception-handling
 [internal field]: #internal-fields
 [introduction for V8 embedders]: https://v8.dev/docs/embed
+[libuv]: https://libuv.org/
 [libuv handles]: #libuv-handles-and-requests
 [libuv requests]: #libuv-handles-and-requests
-[libuv]: https://libuv.org/
 [reference documentation for the libuv API]: http://docs.libuv.org/en/v1.x/
diff --git a/src/aliased_buffer.h b/src/aliased_buffer.h
index 717b1d631cb4f1de971d6f43f148965044f52b19..e762e8ede8ebee7214824907697ec1aaa4f8e50c 100644
--- a/src/aliased_buffer.h
+++ b/src/aliased_buffer.h
@@ -42,7 +42,7 @@ class AliasedBufferBase {
     // allocate v8 ArrayBuffer
     v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
         isolate_, size_in_bytes);
-    buffer_ = static_cast<NativeT*>(ab->GetContents().Data());
+    buffer_ = static_cast<NativeT*>(ab->GetBackingStore()->Data());
 
     // allocate v8 TypedArray
     v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
@@ -229,7 +229,7 @@ class AliasedBufferBase {
         isolate_, new_size_in_bytes);
 
     // allocate new native buffer
-    NativeT* new_buffer = static_cast<NativeT*>(ab->GetContents().Data());
+    NativeT* new_buffer = static_cast<NativeT*>(ab->GetBackingStore()->Data());
     // copy old content
     memcpy(new_buffer, buffer_, old_size_in_bytes);
 
diff --git a/src/aliased_struct-inl.h b/src/aliased_struct-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..17d5ff58097e22bb6943bb9dbdd91f76fb2a51a7
--- /dev/null
+++ b/src/aliased_struct-inl.h
@@ -0,0 +1,54 @@
+#ifndef SRC_ALIASED_STRUCT_INL_H_
+#define SRC_ALIASED_STRUCT_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_struct.h"
+#include "v8.h"
+#include <memory>
+
+namespace node {
+
+template <typename T>
+template <typename... Args>
+AliasedStruct<T>::AliasedStruct(v8::Isolate* isolate, Args&&... args)
+    : isolate_(isolate) {
+  const v8::HandleScope handle_scope(isolate);
+
+  store_ = v8::ArrayBuffer::NewBackingStore(isolate, sizeof(T));
+  ptr_ = new (store_->Data()) T(std::forward<Args>(args)...);
+  DCHECK_NOT_NULL(ptr_);
+
+  v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, store_);
+  buffer_ = v8::Global<v8::ArrayBuffer>(isolate, buffer);
+}
+
+template <typename T>
+AliasedStruct<T>::AliasedStruct(const AliasedStruct& that)
+    : AliasedStruct(that.isolate_, *that) {}
+
+template <typename T>
+AliasedStruct<T>& AliasedStruct<T>::operator=(
+    AliasedStruct<T>&& that) noexcept {
+  this->~AliasedStruct();
+  isolate_ = that.isolate_;
+  store_ = that.store_;
+  ptr_ = that.ptr_;
+
+  buffer_ = std::move(that.buffer_);
+
+  that.ptr_ = nullptr;
+  that.store_.reset();
+  return *this;
+}
+
+template <typename T>
+AliasedStruct<T>::~AliasedStruct() {
+  if (ptr_ != nullptr) ptr_->~T();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ALIASED_STRUCT_INL_H_
diff --git a/src/aliased_struct.h b/src/aliased_struct.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4df393f4985a3b0a6ad4ea5b7216ab471cf5c46
--- /dev/null
+++ b/src/aliased_struct.h
@@ -0,0 +1,63 @@
+#ifndef SRC_ALIASED_STRUCT_H_
+#define SRC_ALIASED_STRUCT_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+#include "v8.h"
+#include <memory>
+
+namespace node {
+
+// AliasedStruct is a utility that allows uses a V8 Backing Store
+// to be exposed to the C++/C side as a struct and to the
+// JavaScript side as an ArrayBuffer to efficiently share
+// data without marshalling. It is similar in nature to
+// AliasedBuffer.
+//
+//   struct Foo { int x; }
+//
+//   AliasedStruct<Foo> foo;
+//   foo->x = 1;
+//
+//   Local<ArrayBuffer> ab = foo.GetArrayBuffer();
+template <typename T>
+class AliasedStruct final {
+ public:
+  template <typename... Args>
+  explicit AliasedStruct(v8::Isolate* isolate, Args&&... args);
+
+  inline AliasedStruct(const AliasedStruct& that);
+
+  inline ~AliasedStruct();
+
+  inline AliasedStruct& operator=(AliasedStruct&& that) noexcept;
+
+  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const {
+    return buffer_.Get(isolate_);
+  }
+
+  const T* Data() const { return ptr_; }
+
+  T* Data() { return ptr_; }
+
+  const T& operator*() const { return *ptr_; }
+
+  T& operator*()  { return *ptr_; }
+
+  const T* operator->() const { return ptr_; }
+
+  T* operator->() { return ptr_; }
+
+ private:
+  v8::Isolate* isolate_;
+  std::shared_ptr<v8::BackingStore> store_;
+  T* ptr_;
+  v8::Global<v8::ArrayBuffer> buffer_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_ALIASED_STRUCT_H_
diff --git a/src/allocated_buffer-inl.h b/src/allocated_buffer-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..2dee6f09a3e9d4d50a7b745bb38a217b68bb668e
--- /dev/null
+++ b/src/allocated_buffer-inl.h
@@ -0,0 +1,110 @@
+#ifndef SRC_ALLOCATED_BUFFER_INL_H_
+#define SRC_ALLOCATED_BUFFER_INL_H_
+
+#include "allocated_buffer.h"
+#include "base_object-inl.h"
+#include "node_buffer.h"
+#include "env-inl.h"
+#include "uv.h"
+#include "v8.h"
+#include "util-inl.h"
+#include "node_internals.h"
+
+namespace node {
+
+// It's a bit awkward to define this Buffer::New() overload here, but it
+// avoids a circular dependency with node_internals.h.
+namespace Buffer {
+v8::MaybeLocal<v8::Uint8Array> New(Environment* env,
+                                   v8::Local<v8::ArrayBuffer> ab,
+                                   size_t byte_offset,
+                                   size_t length);
+}
+
+NoArrayBufferZeroFillScope::NoArrayBufferZeroFillScope(
+    IsolateData* isolate_data)
+  : node_allocator_(isolate_data->node_allocator()) {
+  if (node_allocator_ != nullptr) node_allocator_->zero_fill_field()[0] = 0;
+}
+
+NoArrayBufferZeroFillScope::~NoArrayBufferZeroFillScope() {
+  if (node_allocator_ != nullptr) node_allocator_->zero_fill_field()[0] = 1;
+}
+
+AllocatedBuffer AllocatedBuffer::AllocateManaged(
+    Environment* env,
+    size_t size) {
+  NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
+  std::unique_ptr<v8::BackingStore> bs =
+      v8::ArrayBuffer::NewBackingStore(env->isolate(), size);
+  return AllocatedBuffer(env, std::move(bs));
+}
+
+AllocatedBuffer::AllocatedBuffer(
+    Environment* env, std::unique_ptr<v8::BackingStore> bs)
+    : env_(env), backing_store_(std::move(bs)) {}
+
+AllocatedBuffer::AllocatedBuffer(
+    Environment* env, uv_buf_t buffer)
+    : env_(env) {
+  if (buffer.base == nullptr) return;
+  auto map = env->released_allocated_buffers();
+  auto it = map->find(buffer.base);
+  CHECK_NE(it, map->end());
+  backing_store_ = std::move(it->second);
+  map->erase(it);
+}
+
+void AllocatedBuffer::Resize(size_t len) {
+  if (len == 0) {
+    backing_store_ = v8::ArrayBuffer::NewBackingStore(env_->isolate(), 0);
+    return;
+  }
+  NoArrayBufferZeroFillScope no_zero_fill_scope(env_->isolate_data());
+  backing_store_ = v8::BackingStore::Reallocate(
+      env_->isolate(), std::move(backing_store_), len);
+}
+
+uv_buf_t AllocatedBuffer::release() {
+  if (data() == nullptr) return uv_buf_init(nullptr, 0);
+
+  CHECK_NOT_NULL(env_);
+  uv_buf_t ret = uv_buf_init(data(), size());
+  env_->released_allocated_buffers()->emplace(
+      ret.base, std::move(backing_store_));
+  return ret;
+}
+
+char* AllocatedBuffer::data() {
+  if (!backing_store_) return nullptr;
+  return static_cast<char*>(backing_store_->Data());
+}
+
+const char* AllocatedBuffer::data() const {
+  if (!backing_store_) return nullptr;
+  return static_cast<char*>(backing_store_->Data());
+}
+
+
+size_t AllocatedBuffer::size() const {
+  if (!backing_store_) return 0;
+  return backing_store_->ByteLength();
+}
+
+void AllocatedBuffer::clear() {
+  backing_store_.reset();
+}
+
+v8::MaybeLocal<v8::Object> AllocatedBuffer::ToBuffer() {
+  v8::Local<v8::ArrayBuffer> ab = ToArrayBuffer();
+  return Buffer::New(env_, ab, 0, ab->ByteLength())
+      .FromMaybe(v8::Local<v8::Uint8Array>());
+}
+
+v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() {
+  return v8::ArrayBuffer::New(env_->isolate(), std::move(backing_store_));
+}
+
+}  // namespace node
+
+#endif  // SRC_ALLOCATED_BUFFER_INL_H_
diff --git a/src/allocated_buffer.h b/src/allocated_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c984a342a8b2b89c0fba7ae2e8cc1d8a8af06c14
--- /dev/null
+++ b/src/allocated_buffer.h
@@ -0,0 +1,73 @@
+#ifndef SRC_ALLOCATED_BUFFER_H_
+#define SRC_ALLOCATED_BUFFER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "uv.h"
+#include "v8.h"
+#include "env.h"
+
+namespace node {
+
+class Environment;
+
+// Disables zero-filling for ArrayBuffer allocations in this scope. This is
+// similar to how we implement Buffer.allocUnsafe() in JS land.
+class NoArrayBufferZeroFillScope{
+ public:
+  inline explicit NoArrayBufferZeroFillScope(IsolateData* isolate_data);
+  inline ~NoArrayBufferZeroFillScope();
+
+ private:
+  NodeArrayBufferAllocator* node_allocator_;
+
+  friend class Environment;
+};
+
+// A unique-pointer-ish object that is compatible with the JS engine's
+// ArrayBuffer::Allocator.
+// TODO(addaleax): We may want to start phasing this out as it's only a
+// thin wrapper around v8::BackingStore at this point
+struct AllocatedBuffer {
+ public:
+  // Utilities that allocate memory using the Isolate's ArrayBuffer::Allocator.
+  // In particular, using AllocateManaged() will provide a RAII-style object
+  // with easy conversion to `Buffer` and `ArrayBuffer` objects.
+  inline static AllocatedBuffer AllocateManaged(Environment* env, size_t size);
+
+  AllocatedBuffer() = default;
+  inline AllocatedBuffer(
+      Environment* env, std::unique_ptr<v8::BackingStore> bs);
+  // For this constructor variant, `buffer` *must* come from an earlier call
+  // to .release
+  inline AllocatedBuffer(Environment* env, uv_buf_t buffer);
+
+  inline void Resize(size_t len);
+
+  inline uv_buf_t release();
+  inline char* data();
+  inline const char* data() const;
+  inline size_t size() const;
+  inline void clear();
+
+  inline v8::MaybeLocal<v8::Object> ToBuffer();
+  inline v8::Local<v8::ArrayBuffer> ToArrayBuffer();
+
+  AllocatedBuffer(AllocatedBuffer&& other) = default;
+  AllocatedBuffer& operator=(AllocatedBuffer&& other) = default;
+  AllocatedBuffer(const AllocatedBuffer& other) = delete;
+  AllocatedBuffer& operator=(const AllocatedBuffer& other) = delete;
+
+ private:
+  Environment* env_ = nullptr;
+  std::unique_ptr<v8::BackingStore> backing_store_;
+
+  friend class Environment;
+};
+
+}  // namespace node
+
+#endif  // NODE_WANT_INTERNALS
+
+#endif  // SRC_ALLOCATED_BUFFER_H_
diff --git a/src/api/async_resource.cc b/src/api/async_resource.cc
index 0a2437fe6eda5c82de7f707ed6c63cfa27e0839e..3c4fbdadbc462c3c6cb1e0e7f0e956779c8d7401 100644
--- a/src/api/async_resource.cc
+++ b/src/api/async_resource.cc
@@ -62,10 +62,8 @@ async_id AsyncResource::get_trigger_async_id() const {
   return async_context_.trigger_async_id;
 }
 
-// TODO(addaleax): We shouldn’t need to use env_->isolate() if we’re just going
-// to end up using the Isolate* to figure out the Environment* again.
 AsyncResource::CallbackScope::CallbackScope(AsyncResource* res)
-    : node::CallbackScope(res->env_->isolate(),
+    : node::CallbackScope(res->env_,
                           res->resource_.Get(res->env_->isolate()),
                           res->async_context_) {}
 
diff --git a/src/api/callback.cc b/src/api/callback.cc
index 67b533d2f4ddf2d6f207548813a401f476e72fe0..798a28662f3077b730c1975773039a850b42292a 100644
--- a/src/api/callback.cc
+++ b/src/api/callback.cc
@@ -13,18 +13,22 @@ using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::MicrotasksScope;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
 
 CallbackScope::CallbackScope(Isolate* isolate,
+                             Local<Object> object,
+                             async_context async_context)
+  : CallbackScope(Environment::GetCurrent(isolate), object, async_context) {}
+
+CallbackScope::CallbackScope(Environment* env,
                              Local<Object> object,
                              async_context asyncContext)
-  : private_(new InternalCallbackScope(Environment::GetCurrent(isolate),
+  : private_(new InternalCallbackScope(env,
                                        object,
                                        asyncContext)),
-    try_catch_(isolate) {
+    try_catch_(env->isolate()) {
   try_catch_.SetVerbose(true);
 }
 
@@ -62,6 +66,8 @@ InternalCallbackScope::InternalCallbackScope(Environment* env,
   // If you hit this assertion, you forgot to enter the v8::Context first.
   CHECK_EQ(Environment::GetCurrent(env->isolate()), env);
 
+  env->isolate()->SetIdle(false);
+
   env->async_hooks()->push_async_context(
     async_context_.async_id, async_context_.trigger_async_id, object);
 
@@ -83,6 +89,8 @@ void InternalCallbackScope::Close() {
   if (closed_) return;
   closed_ = true;
 
+  auto idle = OnScopeLeave([&]() { env_->isolate()->SetIdle(true); });
+
   if (!env_->can_call_into_js()) return;
   auto perform_stopping_check = [&]() {
     if (env_->is_stopping()) {
@@ -214,8 +222,7 @@ MaybeLocal<Value> MakeCallback(Isolate* isolate,
                                Local<Value> argv[],
                                async_context asyncContext) {
   Local<String> method_string =
-      String::NewFromUtf8(isolate, method, NewStringType::kNormal)
-          .ToLocalChecked();
+      String::NewFromUtf8(isolate, method).ToLocalChecked();
   return MakeCallback(isolate, recv, method_string, argc, argv, asyncContext);
 }
 
diff --git a/src/api/encoding.cc b/src/api/encoding.cc
index 6df4a7faf30393597370e00154e568b72d02b71f..f64aeee15c3b34d81c0be863396e893ddbf2c87d 100644
--- a/src/api/encoding.cc
+++ b/src/api/encoding.cc
@@ -68,6 +68,8 @@ enum encoding ParseEncoding(const char* encoding,
       } else if (encoding[1] == 'a') {
         if (strncmp(encoding + 2, "se64", 5) == 0)
           return BASE64;
+        if (strncmp(encoding + 2, "se64url", 8) == 0)
+          return BASE64URL;
       }
       if (StringEqualNoCase(encoding, "binary"))
         return LATIN1;  // BINARY is a deprecated alias of LATIN1.
@@ -75,6 +77,8 @@ enum encoding ParseEncoding(const char* encoding,
         return BUFFER;
       if (StringEqualNoCase(encoding, "base64"))
         return BASE64;
+      if (StringEqualNoCase(encoding, "base64url"))
+        return BASE64URL;
       break;
 
     case 'a':
diff --git a/src/api/environment.cc b/src/api/environment.cc
index b3c9ed72d21a946e7c63152ccc80c157af150728..52c67b91c3b034a61a666668f78d452c030c2d8f 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -16,7 +16,6 @@ using errors::TryCatchScope;
 using v8::Array;
 using v8::Context;
 using v8::EscapableHandleScope;
-using v8::FinalizationGroup;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::HandleScope;
@@ -77,15 +76,6 @@ MaybeLocal<Value> PrepareStackTraceCallback(Local<Context> context,
   return result;
 }
 
-static void HostCleanupFinalizationGroupCallback(
-    Local<Context> context, Local<FinalizationGroup> group) {
-  Environment* env = Environment::GetCurrent(context);
-  if (env == nullptr) {
-    return;
-  }
-  env->RegisterFinalizationGroupForCleanup(group);
-}
-
 void* NodeArrayBufferAllocator::Allocate(size_t size) {
   void* ret;
   if (zero_fill_field_ || per_process::cli_options->zero_fill_all_buffers)
@@ -238,9 +228,11 @@ void SetIsolateErrorHandlers(v8::Isolate* isolate, const IsolateSettings& s) {
       s.fatal_error_callback : OnFatalError;
   isolate->SetFatalErrorHandler(fatal_error_cb);
 
-  auto* prepare_stack_trace_cb = s.prepare_stack_trace_callback ?
-      s.prepare_stack_trace_callback : PrepareStackTraceCallback;
-  isolate->SetPrepareStackTraceCallback(prepare_stack_trace_cb);
+  if ((s.flags & SHOULD_NOT_SET_PREPARE_STACK_TRACE_CALLBACK) == 0) {
+    auto* prepare_stack_trace_cb = s.prepare_stack_trace_callback ?
+        s.prepare_stack_trace_callback : PrepareStackTraceCallback;
+    isolate->SetPrepareStackTraceCallback(prepare_stack_trace_cb);
+  }
 }
 
 void SetIsolateMiscHandlers(v8::Isolate* isolate, const IsolateSettings& s) {
@@ -256,11 +248,6 @@ void SetIsolateMiscHandlers(v8::Isolate* isolate, const IsolateSettings& s) {
     isolate->SetPromiseRejectCallback(promise_reject_cb);
   }
 
-  auto* host_cleanup_cb = s.host_cleanup_finalization_group_callback ?
-    s.host_cleanup_finalization_group_callback :
-    HostCleanupFinalizationGroupCallback;
-  isolate->SetHostCleanupFinalizationGroupCallback(host_cleanup_cb);
-
   if (s.flags & DETAILED_SOURCE_POSITIONS_FOR_PROFILING)
     v8::CpuProfiler::UseDetailedSourcePositionsForProfiling(isolate);
 }
@@ -307,6 +294,14 @@ Isolate* NewIsolate(ArrayBufferAllocator* allocator,
   return NewIsolate(&params, event_loop, platform);
 }
 
+Isolate* NewIsolate(std::shared_ptr<ArrayBufferAllocator> allocator,
+                    uv_loop_t* event_loop,
+                    MultiIsolatePlatform* platform) {
+  Isolate::CreateParams params;
+  if (allocator) params.array_buffer_allocator_shared = allocator;
+  return NewIsolate(&params, event_loop, platform);
+}
+
 IsolateData* CreateIsolateData(Isolate* isolate,
                                uv_loop_t* loop,
                                MultiIsolatePlatform* platform,
@@ -427,7 +422,7 @@ MaybeLocal<Value> LoadEnvironment(
     Environment* env,
     StartExecutionCallback cb,
     std::unique_ptr<InspectorParentHandle> removeme) {
-  env->InitializeLibuv(per_process::v8_is_profiling);
+  env->InitializeLibuv();
   env->InitializeDiagnostics();
 
   return StartExecution(env, cb);
@@ -444,8 +439,7 @@ MaybeLocal<Value> LoadEnvironment(
         // This is a slightly hacky way to convert UTF-8 to UTF-16.
         Local<String> str =
             String::NewFromUtf8(env->isolate(),
-                                main_script_source_utf8,
-                                v8::NewStringType::kNormal).ToLocalChecked();
+                                main_script_source_utf8).ToLocalChecked();
         auto main_utf16 = std::make_unique<String::Value>(env->isolate(), str);
 
         // TODO(addaleax): Avoid having a global table for all scripts.
@@ -472,6 +466,14 @@ MultiIsolatePlatform* GetMainThreadMultiIsolatePlatform() {
   return per_process::v8_platform.Platform();
 }
 
+IsolateData* GetEnvironmentIsolateData(Environment* env) {
+  return env->isolate_data();
+}
+
+ArrayBufferAllocator* GetArrayBufferAllocator(IsolateData* isolate_data) {
+  return isolate_data->node_allocator();
+}
+
 MultiIsolatePlatform* GetMultiIsolatePlatform(Environment* env) {
   return GetMultiIsolatePlatform(env->isolate_data());
 }
@@ -679,10 +681,14 @@ void AddLinkedBinding(Environment* env, const node_module& mod) {
   CHECK_NOT_NULL(env);
   Mutex::ScopedLock lock(env->extra_linked_bindings_mutex());
 
-  node_module* prev_head = env->extra_linked_bindings_head();
+  node_module* prev_tail = env->extra_linked_bindings_tail();
   env->extra_linked_bindings()->push_back(mod);
-  if (prev_head != nullptr)
-    prev_head->nm_link = &env->extra_linked_bindings()->back();
+  if (prev_tail != nullptr)
+    prev_tail->nm_link = &env->extra_linked_bindings()->back();
+}
+
+void AddLinkedBinding(Environment* env, const napi_module& mod) {
+  AddLinkedBinding(env, napi_module_to_node_module(&mod));
 }
 
 void AddLinkedBinding(Environment* env,
@@ -706,9 +712,7 @@ void AddLinkedBinding(Environment* env,
 static std::atomic<uint64_t> next_thread_id{0};
 
 ThreadId AllocateEnvironmentThreadId() {
-  ThreadId ret;
-  ret.id = next_thread_id++;
-  return ret;
+  return ThreadId { next_thread_id++ };
 }
 
 void DefaultProcessExitHandler(Environment* env, int exit_code) {
diff --git a/src/api/exceptions.cc b/src/api/exceptions.cc
index 998d370d3b5fd6ff7e399254512672f86a486c03..310b2acc4073d62fbcbf3bb2d6221c2df8d371d3 100644
--- a/src/api/exceptions.cc
+++ b/src/api/exceptions.cc
@@ -15,7 +15,6 @@ using v8::Exception;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
@@ -42,8 +41,7 @@ Local<Value> ErrnoException(Isolate* isolate,
   Local<String> path_string;
   if (path != nullptr) {
     // FIXME(bnoordhuis) It's questionable to interpret the file path as UTF-8.
-    path_string = String::NewFromUtf8(isolate, path, NewStringType::kNormal)
-                      .ToLocalChecked();
+    path_string = String::NewFromUtf8(isolate, path).ToLocalChecked();
   }
 
   if (path_string.IsEmpty() == false) {
@@ -78,16 +76,13 @@ static Local<String> StringFromPath(Isolate* isolate, const char* path) {
     return String::Concat(
         isolate,
         FIXED_ONE_BYTE_STRING(isolate, "\\\\"),
-        String::NewFromUtf8(isolate, path + 8, NewStringType::kNormal)
-            .ToLocalChecked());
+        String::NewFromUtf8(isolate, path + 8).ToLocalChecked());
   } else if (strncmp(path, "\\\\?\\", 4) == 0) {
-    return String::NewFromUtf8(isolate, path + 4, NewStringType::kNormal)
-        .ToLocalChecked();
+    return String::NewFromUtf8(isolate, path + 4).ToLocalChecked();
   }
 #endif
 
-  return String::NewFromUtf8(isolate, path, NewStringType::kNormal)
-      .ToLocalChecked();
+  return String::NewFromUtf8(isolate, path).ToLocalChecked();
 }
 
 
@@ -206,8 +201,7 @@ Local<Value> WinapiErrnoException(Isolate* isolate,
     Local<String> cons2 = String::Concat(
         isolate,
         cons1,
-        String::NewFromUtf8(isolate, path, NewStringType::kNormal)
-            .ToLocalChecked());
+        String::NewFromUtf8(isolate, path).ToLocalChecked());
     Local<String> cons3 =
         String::Concat(isolate, cons2, FIXED_ONE_BYTE_STRING(isolate, "'"));
     e = Exception::Error(cons3);
@@ -222,8 +216,7 @@ Local<Value> WinapiErrnoException(Isolate* isolate,
   if (path != nullptr) {
     obj->Set(env->context(),
              env->path_string(),
-             String::NewFromUtf8(isolate, path, NewStringType::kNormal)
-                 .ToLocalChecked())
+             String::NewFromUtf8(isolate, path).ToLocalChecked())
         .Check();
   }
 
diff --git a/src/api/hooks.cc b/src/api/hooks.cc
index ce1610c5c49685ca2fb2308305182cad8de8c9e2..79fa896a10e91d1147668902c78efd0229a0e415 100644
--- a/src/api/hooks.cc
+++ b/src/api/hooks.cc
@@ -1,6 +1,6 @@
 #include "env-inl.h"
 #include "node_internals.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "async_wrap.h"
 
 namespace node {
@@ -9,11 +9,14 @@ using v8::Context;
 using v8::HandleScope;
 using v8::Integer;
 using v8::Isolate;
+using v8::Just;
 using v8::Local;
+using v8::Maybe;
+using v8::NewStringType;
+using v8::Nothing;
 using v8::Object;
 using v8::String;
 using v8::Value;
-using v8::NewStringType;
 
 void RunAtExit(Environment* env) {
   env->RunAtExitCallbacks();
@@ -30,6 +33,10 @@ void AtExit(Environment* env, void (*cb)(void* arg), void* arg) {
 }
 
 void EmitBeforeExit(Environment* env) {
+  USE(EmitProcessBeforeExit(env));
+}
+
+Maybe<bool> EmitProcessBeforeExit(Environment* env) {
   TraceEventScope trace_scope(TRACING_CATEGORY_NODE1(environment),
                               "BeforeExit", env);
   if (!env->destroy_async_id_list()->empty())
@@ -40,39 +47,49 @@ void EmitBeforeExit(Environment* env) {
 
   Local<Value> exit_code_v;
   if (!env->process_object()->Get(env->context(), env->exit_code_string())
-      .ToLocal(&exit_code_v)) return;
+      .ToLocal(&exit_code_v)) return Nothing<bool>();
 
   Local<Integer> exit_code;
-  if (!exit_code_v->ToInteger(env->context()).ToLocal(&exit_code)) return;
+  if (!exit_code_v->ToInteger(env->context()).ToLocal(&exit_code)) {
+    return Nothing<bool>();
+  }
 
-  // TODO(addaleax): Provide variants of EmitExit() and EmitBeforeExit() that
-  // actually forward empty MaybeLocal<>s (and check env->can_call_into_js()).
-  USE(ProcessEmit(env, "beforeExit", exit_code));
+  return ProcessEmit(env, "beforeExit", exit_code).IsEmpty() ?
+      Nothing<bool>() : Just(true);
 }
 
 int EmitExit(Environment* env) {
+  return EmitProcessExit(env).FromMaybe(1);
+}
+
+Maybe<int> EmitProcessExit(Environment* env) {
   // process.emit('exit')
   HandleScope handle_scope(env->isolate());
   Context::Scope context_scope(env->context());
   Local<Object> process_object = env->process_object();
-  process_object
+
+  // TODO(addaleax): It might be nice to share process._exiting and
+  // process.exitCode via getter/setter pairs that pass data directly to the
+  // native side, so that we don't manually have to read and write JS properties
+  // here. These getters could use e.g. a typed array for performance.
+  if (process_object
       ->Set(env->context(),
             FIXED_ONE_BYTE_STRING(env->isolate(), "_exiting"),
-            True(env->isolate()))
-      .Check();
+            True(env->isolate())).IsNothing()) return Nothing<int>();
 
   Local<String> exit_code = env->exit_code_string();
-  int code = process_object->Get(env->context(), exit_code)
-                 .ToLocalChecked()
-                 ->Int32Value(env->context())
-                 .ToChecked();
-  ProcessEmit(env, "exit", Integer::New(env->isolate(), code));
-
-  // Reload exit code, it may be changed by `emit('exit')`
-  return process_object->Get(env->context(), exit_code)
-      .ToLocalChecked()
-      ->Int32Value(env->context())
-      .ToChecked();
+  Local<Value> code_v;
+  int code;
+  if (!process_object->Get(env->context(), exit_code).ToLocal(&code_v) ||
+      !code_v->Int32Value(env->context()).To(&code) ||
+      ProcessEmit(env, "exit", Integer::New(env->isolate(), code)).IsEmpty() ||
+      // Reload exit code, it may be changed by `emit('exit')`
+      !process_object->Get(env->context(), exit_code).ToLocal(&code_v) ||
+      !code_v->Int32Value(env->context()).To(&code)) {
+    return Nothing<int>();
+  }
+
+  return Just(code);
 }
 
 typedef void (*CleanupHook)(void* arg);
diff --git a/src/async_wrap.cc b/src/async_wrap.cc
index d748219d55212a15acb9657ae30eae5e5894ad68..7590ab0197dfd6d96ac298a3f2396cbc6cbe41a1 100644
--- a/src/async_wrap.cc
+++ b/src/async_wrap.cc
@@ -40,13 +40,10 @@ using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
+using v8::Nothing;
 using v8::Number;
 using v8::Object;
-using v8::ObjectTemplate;
-using v8::Promise;
-using v8::PromiseHookType;
 using v8::PropertyAttribute;
-using v8::PropertyCallbackInfo;
 using v8::ReadOnly;
 using v8::String;
 using v8::Uint32;
@@ -94,6 +91,12 @@ struct AsyncWrapObject : public AsyncWrap {
     return tmpl;
   }
 
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
+    // We can't really know what the underlying operation does. One of the
+    // signs that it's time to remove this class. :)
+    return true;
+  }
+
   SET_NO_MEMORY_INFO()
   SET_MEMORY_INFO_NAME(AsyncWrapObject)
   SET_SELF_SIZE(AsyncWrapObject)
@@ -187,114 +190,8 @@ void AsyncWrap::EmitAfter(Environment* env, double async_id) {
        env->async_hooks_after_function());
 }
 
-class PromiseWrap : public AsyncWrap {
- public:
-  enum InternalFields {
-    kIsChainedPromiseField = AsyncWrap::kInternalFieldCount,
-    kInternalFieldCount
-  };
-  PromiseWrap(Environment* env, Local<Object> object, bool silent)
-      : AsyncWrap(env, object, PROVIDER_PROMISE, kInvalidAsyncId, silent) {
-    MakeWeak();
-  }
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(PromiseWrap)
-  SET_SELF_SIZE(PromiseWrap)
-
-  static PromiseWrap* New(Environment* env,
-                          Local<Promise> promise,
-                          PromiseWrap* parent_wrap,
-                          bool silent);
-  static void getIsChainedPromise(Local<String> property,
-                                  const PropertyCallbackInfo<Value>& info);
-};
-
-PromiseWrap* PromiseWrap::New(Environment* env,
-                              Local<Promise> promise,
-                              PromiseWrap* parent_wrap,
-                              bool silent) {
-  Local<Object> obj;
-  if (!env->promise_wrap_template()->NewInstance(env->context()).ToLocal(&obj))
-    return nullptr;
-  obj->SetInternalField(PromiseWrap::kIsChainedPromiseField,
-                        parent_wrap != nullptr ? v8::True(env->isolate())
-                                               : v8::False(env->isolate()));
-  CHECK_NULL(promise->GetAlignedPointerFromInternalField(0));
-  promise->SetInternalField(0, obj);
-  return new PromiseWrap(env, obj, silent);
-}
-
-void PromiseWrap::getIsChainedPromise(Local<String> property,
-                                      const PropertyCallbackInfo<Value>& info) {
-  info.GetReturnValue().Set(
-      info.Holder()->GetInternalField(PromiseWrap::kIsChainedPromiseField));
-}
-
-static PromiseWrap* extractPromiseWrap(Local<Promise> promise) {
-  // This check is imperfect. If the internal field is set, it should
-  // be an object. If it's not, we just ignore it. Ideally v8 would
-  // have had GetInternalField returning a MaybeLocal but this works
-  // for now.
-  Local<Value> obj = promise->GetInternalField(0);
-  return obj->IsObject() ? Unwrap<PromiseWrap>(obj.As<Object>()) : nullptr;
-}
-
-static void PromiseHook(PromiseHookType type, Local<Promise> promise,
-                        Local<Value> parent) {
-  Local<Context> context = promise->CreationContext();
-
-  Environment* env = Environment::GetCurrent(context);
-  if (env == nullptr) return;
-  TraceEventScope trace_scope(TRACING_CATEGORY_NODE1(environment),
-                              "EnvPromiseHook", env);
-
-  PromiseWrap* wrap = extractPromiseWrap(promise);
-  if (type == PromiseHookType::kInit || wrap == nullptr) {
-    bool silent = type != PromiseHookType::kInit;
-
-    // set parent promise's async Id as this promise's triggerAsyncId
-    if (parent->IsPromise()) {
-      // parent promise exists, current promise
-      // is a chained promise, so we set parent promise's id as
-      // current promise's triggerAsyncId
-      Local<Promise> parent_promise = parent.As<Promise>();
-      PromiseWrap* parent_wrap = extractPromiseWrap(parent_promise);
-      if (parent_wrap == nullptr) {
-        parent_wrap = PromiseWrap::New(env, parent_promise, nullptr, true);
-        if (parent_wrap == nullptr) return;
-      }
-
-      AsyncHooks::DefaultTriggerAsyncIdScope trigger_scope(parent_wrap);
-      wrap = PromiseWrap::New(env, promise, parent_wrap, silent);
-    } else {
-      wrap = PromiseWrap::New(env, promise, nullptr, silent);
-    }
-  }
-
-  if (wrap == nullptr) return;
-
-  if (type == PromiseHookType::kBefore) {
-    env->async_hooks()->push_async_context(wrap->get_async_id(),
-      wrap->get_trigger_async_id(), wrap->object());
-    wrap->EmitTraceEventBefore();
-    AsyncWrap::EmitBefore(wrap->env(), wrap->get_async_id());
-  } else if (type == PromiseHookType::kAfter) {
-    wrap->EmitTraceEventAfter(wrap->provider_type(), wrap->get_async_id());
-    AsyncWrap::EmitAfter(wrap->env(), wrap->get_async_id());
-    if (env->execution_async_id() == wrap->get_async_id()) {
-      // This condition might not be true if async_hooks was enabled during
-      // the promise callback execution.
-      // Popping it off the stack can be skipped in that case, because it is
-      // known that it would correspond to exactly one call with
-      // PromiseHookType::kBefore that was not witnessed by the PromiseHook.
-      env->async_hooks()->pop_async_context(wrap->get_async_id());
-    }
-  } else if (type == PromiseHookType::kResolve) {
-    AsyncWrap::EmitPromiseResolve(wrap->env(), wrap->get_async_id());
-  }
-}
-
+// TODO(addaleax): Remove once we're on C++17.
+constexpr double AsyncWrap::kInvalidAsyncId;
 
 static void SetupHooks(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -325,37 +222,18 @@ static void SetupHooks(const FunctionCallbackInfo<Value>& args) {
   SET_HOOK_FN(destroy);
   SET_HOOK_FN(promise_resolve);
 #undef SET_HOOK_FN
-
-  {
-    Local<FunctionTemplate> ctor =
-        FunctionTemplate::New(env->isolate());
-    ctor->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "PromiseWrap"));
-    Local<ObjectTemplate> promise_wrap_template = ctor->InstanceTemplate();
-    promise_wrap_template->SetInternalFieldCount(
-        PromiseWrap::kInternalFieldCount);
-    promise_wrap_template->SetAccessor(
-        FIXED_ONE_BYTE_STRING(env->isolate(), "isChainedPromise"),
-        PromiseWrap::getIsChainedPromise);
-    env->set_promise_wrap_template(promise_wrap_template);
-  }
 }
 
+static void SetPromiseHooks(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
 
-static void EnablePromiseHook(const FunctionCallbackInfo<Value>& args) {
-  args.GetIsolate()->SetPromiseHook(PromiseHook);
-}
-
-
-static void DisablePromiseHook(const FunctionCallbackInfo<Value>& args) {
-  Isolate* isolate = args.GetIsolate();
-
-  // The per-Isolate API provides no way of knowing whether there are multiple
-  // users of the PromiseHook. That hopefully goes away when V8 introduces
-  // a per-context API.
-  isolate->SetPromiseHook(nullptr);
+  env->async_hooks()->SetJSPromiseHooks(
+    args[0]->IsFunction() ? args[0].As<Function>() : Local<Function>(),
+    args[1]->IsFunction() ? args[1].As<Function>() : Local<Function>(),
+    args[2]->IsFunction() ? args[2].As<Function>() : Local<Function>(),
+    args[3]->IsFunction() ? args[3].As<Function>() : Local<Function>());
 }
 
-
 class DestroyParam {
  public:
   double asyncId;
@@ -522,8 +400,7 @@ void AsyncWrap::Initialize(Local<Object> target,
   env->SetMethod(target, "executionAsyncResource", ExecutionAsyncResource);
   env->SetMethod(target, "clearAsyncIdStack", ClearAsyncIdStack);
   env->SetMethod(target, "queueDestroyAsyncId", QueueDestroyAsyncId);
-  env->SetMethod(target, "enablePromiseHook", EnablePromiseHook);
-  env->SetMethod(target, "disablePromiseHook", DisablePromiseHook);
+  env->SetMethod(target, "setPromiseHooks", SetPromiseHooks);
   env->SetMethod(target, "registerDestroyHook", RegisterDestroyHook);
 
   PropertyAttribute ReadOnlyDontDelete =
@@ -609,7 +486,6 @@ void AsyncWrap::Initialize(Local<Object> target,
           ->GetFunction(env->context()).ToLocalChecked()).Check();
 }
 
-
 AsyncWrap::AsyncWrap(Environment* env,
                      Local<Object> object,
                      ProviderType provider,
@@ -630,6 +506,15 @@ AsyncWrap::AsyncWrap(Environment* env,
   init_hook_ran_ = true;
 }
 
+AsyncWrap::AsyncWrap(Environment* env,
+                     Local<Object> object,
+                     ProviderType provider,
+                     double execution_async_id,
+                     double trigger_async_id)
+    : AsyncWrap(env, object, provider, execution_async_id, true) {
+  trigger_async_id_ = trigger_async_id;
+}
+
 AsyncWrap::AsyncWrap(Environment* env, Local<Object> object)
   : BaseObject(env, object) {
 }
diff --git a/src/async_wrap.h b/src/async_wrap.h
index ac1e9ccd04c4fa399dfd668513f4cbdf9d83ed5c..71012dd09c2a1b9590a70b4a7979b898be3f0ebf 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -38,6 +38,7 @@ namespace node {
   V(ELDHISTOGRAM)                                                             \
   V(FILEHANDLE)                                                               \
   V(FILEHANDLECLOSEREQ)                                                       \
+  V(FIXEDSIZEBLOBCOPY)                                                        \
   V(FSEVENTWRAP)                                                              \
   V(FSREQCALLBACK)                                                            \
   V(FSREQPROMISE)                                                             \
@@ -215,6 +216,11 @@ class AsyncWrap : public BaseObject {
             ProviderType provider,
             double execution_async_id,
             bool silent);
+  AsyncWrap(Environment* env,
+            v8::Local<v8::Object> promise,
+            ProviderType provider,
+            double execution_async_id,
+            double trigger_async_id);
   ProviderType provider_type_ = PROVIDER_NONE;
   bool init_hook_ran_ = false;
   // Because the values may be Reset(), cannot be made const.
diff --git a/src/base64-inl.h b/src/base64-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b6cdd93f002a4ca482de283151709c2c24f065b
--- /dev/null
+++ b/src/base64-inl.h
@@ -0,0 +1,189 @@
+#ifndef SRC_BASE64_INL_H_
+#define SRC_BASE64_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base64.h"
+#include "util.h"
+
+namespace node {
+
+extern const int8_t unbase64_table[256];
+
+
+inline static int8_t unbase64(uint8_t x) {
+  return unbase64_table[x];
+}
+
+
+inline uint32_t ReadUint32BE(const unsigned char* p) {
+  return static_cast<uint32_t>(p[0] << 24U) |
+         static_cast<uint32_t>(p[1] << 16U) |
+         static_cast<uint32_t>(p[2] << 8U) |
+         static_cast<uint32_t>(p[3]);
+}
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// MSVC C4003: not enough actual parameters for macro 'identifier'
+#pragma warning(disable : 4003)
+#endif
+
+template <typename TypeName>
+bool base64_decode_group_slow(char* const dst, const size_t dstlen,
+                              const TypeName* const src, const size_t srclen,
+                              size_t* const i, size_t* const k) {
+  uint8_t hi;
+  uint8_t lo;
+#define V(expr)                                                                \
+  for (;;) {                                                                   \
+    const uint8_t c = static_cast<uint8_t>(src[*i]);                           \
+    lo = unbase64(c);                                                          \
+    *i += 1;                                                                   \
+    if (lo < 64) break;                         /* Legal character. */         \
+    if (c == '=' || *i >= srclen) return false; /* Stop decoding. */           \
+  }                                                                            \
+  expr;                                                                        \
+  if (*i >= srclen) return false;                                              \
+  if (*k >= dstlen) return false;                                              \
+  hi = lo;
+  V(/* Nothing. */);
+  V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
+  V(dst[(*k)++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2));
+  V(dst[(*k)++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0));
+#undef V
+  return true;  // Continue decoding.
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+template <typename TypeName>
+size_t base64_decode_fast(char* const dst, const size_t dstlen,
+                          const TypeName* const src, const size_t srclen,
+                          const size_t decoded_size) {
+  const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
+  const size_t max_k = available / 3 * 3;
+  size_t max_i = srclen / 4 * 4;
+  size_t i = 0;
+  size_t k = 0;
+  while (i < max_i && k < max_k) {
+    const unsigned char txt[] = {
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
+    };
+
+    const uint32_t v = ReadUint32BE(txt);
+    // If MSB is set, input contains whitespace or is not valid base64.
+    if (v & 0x80808080) {
+      if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
+        return k;
+      max_i = i + (srclen - i) / 4 * 4;  // Align max_i again.
+    } else {
+      dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03);
+      dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F);
+      dst[k + 2] = ((v >>  2) & 0xC0) | ((v >>  0) & 0x3F);
+      i += 4;
+      k += 3;
+    }
+  }
+  if (i < srclen && k < dstlen) {
+    base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
+  }
+  return k;
+}
+
+
+template <typename TypeName>
+size_t base64_decoded_size(const TypeName* src, size_t size) {
+  // 1-byte input cannot be decoded
+  if (size < 2)
+    return 0;
+
+  if (src[size - 1] == '=') {
+    size--;
+    if (src[size - 1] == '=')
+      size--;
+  }
+  return base64_decoded_size_fast(size);
+}
+
+
+template <typename TypeName>
+size_t base64_decode(char* const dst, const size_t dstlen,
+                     const TypeName* const src, const size_t srclen) {
+  const size_t decoded_size = base64_decoded_size(src, srclen);
+  return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
+}
+
+
+inline size_t base64_encode(const char* src,
+                            size_t slen,
+                            char* dst,
+                            size_t dlen,
+                            Base64Mode mode) {
+  // We know how much we'll write, just make sure that there's space.
+  CHECK(dlen >= base64_encoded_size(slen, mode) &&
+        "not enough space provided for base64 encode");
+
+  dlen = base64_encoded_size(slen, mode);
+
+  unsigned a;
+  unsigned b;
+  unsigned c;
+  unsigned i;
+  unsigned k;
+  unsigned n;
+
+  const char* table = base64_select_table(mode);
+
+  i = 0;
+  k = 0;
+  n = slen / 3 * 3;
+
+  while (i < n) {
+    a = src[i + 0] & 0xff;
+    b = src[i + 1] & 0xff;
+    c = src[i + 2] & 0xff;
+
+    dst[k + 0] = table[a >> 2];
+    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
+    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
+    dst[k + 3] = table[c & 0x3f];
+
+    i += 3;
+    k += 4;
+  }
+
+  switch (slen - n) {
+    case 1:
+      a = src[i + 0] & 0xff;
+      dst[k + 0] = table[a >> 2];
+      dst[k + 1] = table[(a & 3) << 4];
+      if (mode == Base64Mode::NORMAL) {
+        dst[k + 2] = '=';
+        dst[k + 3] = '=';
+      }
+      break;
+    case 2:
+      a = src[i + 0] & 0xff;
+      b = src[i + 1] & 0xff;
+      dst[k + 0] = table[a >> 2];
+      dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
+      dst[k + 2] = table[(b & 0x0f) << 2];
+      if (mode == Base64Mode::NORMAL)
+        dst[k + 3] = '=';
+      break;
+  }
+
+  return dlen;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BASE64_INL_H_
diff --git a/src/base64.h b/src/base64.h
index 1cb90bdeba75b041684ce74ef6e5b86dc2424564..cf6e82539a5f91e2b22c6abd72b47e4c1fd2c11c 100644
--- a/src/base64.h
+++ b/src/base64.h
@@ -5,176 +5,62 @@
 
 #include "util.h"
 
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
 
 namespace node {
 //// Base 64 ////
-static inline constexpr size_t base64_encoded_size(size_t size) {
-  return ((size + 2) / 3 * 4);
-}
 
-// Doesn't check for padding at the end.  Can be 1-2 bytes over.
-static inline constexpr size_t base64_decoded_size_fast(size_t size) {
-  // 1-byte input cannot be decoded
-  return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;
-}
+enum class Base64Mode {
+  NORMAL,
+  URL
+};
 
-template <typename TypeName>
-size_t base64_decoded_size(const TypeName* src, size_t size) {
-  // 1-byte input cannot be decoded
-  if (size < 2)
-    return 0;
+static constexpr char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                       "abcdefghijklmnopqrstuvwxyz"
+                                       "0123456789+/";
+
+static constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                           "abcdefghijklmnopqrstuvwxyz"
+                                           "0123456789-_";
 
-  if (src[size - 1] == '=') {
-    size--;
-    if (src[size - 1] == '=')
-      size--;
+static inline const char* base64_select_table(Base64Mode mode) {
+  switch (mode) {
+    case Base64Mode::NORMAL: return base64_table;
+    case Base64Mode::URL: return base64_table_url;
+    default: UNREACHABLE();
   }
-  return base64_decoded_size_fast(size);
 }
 
-
-extern const int8_t unbase64_table[256];
-
-
-inline static int8_t unbase64(uint8_t x) {
-  return unbase64_table[x];
+static inline constexpr size_t base64_encoded_size(
+    size_t size,
+    Base64Mode mode = Base64Mode::NORMAL) {
+  return mode == Base64Mode::NORMAL
+      ? ((size + 2) / 3 * 4)
+      : std::ceil(static_cast<double>(size * 4) / 3);
 }
 
-
-template <typename TypeName>
-bool base64_decode_group_slow(char* const dst, const size_t dstlen,
-                              const TypeName* const src, const size_t srclen,
-                              size_t* const i, size_t* const k) {
-  uint8_t hi;
-  uint8_t lo;
-#define V(expr)                                                               \
-  for (;;) {                                                                  \
-    const uint8_t c = src[*i];                                                \
-    lo = unbase64(c);                                                         \
-    *i += 1;                                                                  \
-    if (lo < 64)                                                              \
-      break;  /* Legal character. */                                          \
-    if (c == '=' || *i >= srclen)                                             \
-      return false;  /* Stop decoding. */                                     \
-  }                                                                           \
-  expr;                                                                       \
-  if (*i >= srclen)                                                           \
-    return false;                                                             \
-  if (*k >= dstlen)                                                           \
-    return false;                                                             \
-  hi = lo;
-  V(/* Nothing. */);
-  V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
-  V(dst[(*k)++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2));
-  V(dst[(*k)++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0));
-#undef V
-  return true;  // Continue decoding.
+// Doesn't check for padding at the end.  Can be 1-2 bytes over.
+static inline constexpr size_t base64_decoded_size_fast(size_t size) {
+  // 1-byte input cannot be decoded
+  return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;
 }
 
+inline uint32_t ReadUint32BE(const unsigned char* p);
 
 template <typename TypeName>
-size_t base64_decode_fast(char* const dst, const size_t dstlen,
-                          const TypeName* const src, const size_t srclen,
-                          const size_t decoded_size) {
-  const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
-  const size_t max_k = available / 3 * 3;
-  size_t max_i = srclen / 4 * 4;
-  size_t i = 0;
-  size_t k = 0;
-  while (i < max_i && k < max_k) {
-    const uint32_t v =
-        unbase64(src[i + 0]) << 24 |
-        unbase64(src[i + 1]) << 16 |
-        unbase64(src[i + 2]) << 8 |
-        unbase64(src[i + 3]);
-    // If MSB is set, input contains whitespace or is not valid base64.
-    if (v & 0x80808080) {
-      if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
-        return k;
-      max_i = i + (srclen - i) / 4 * 4;  // Align max_i again.
-    } else {
-      dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03);
-      dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F);
-      dst[k + 2] = ((v >>  2) & 0xC0) | ((v >>  0) & 0x3F);
-      i += 4;
-      k += 3;
-    }
-  }
-  if (i < srclen && k < dstlen) {
-    base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
-  }
-  return k;
-}
-
+size_t base64_decoded_size(const TypeName* src, size_t size);
 
 template <typename TypeName>
 size_t base64_decode(char* const dst, const size_t dstlen,
-                     const TypeName* const src, const size_t srclen) {
-  const size_t decoded_size = base64_decoded_size(src, srclen);
-  return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
-}
+                     const TypeName* const src, const size_t srclen);
 
-static size_t base64_encode(const char* src,
+inline size_t base64_encode(const char* src,
                             size_t slen,
                             char* dst,
-                            size_t dlen) {
-  // We know how much we'll write, just make sure that there's space.
-  CHECK(dlen >= base64_encoded_size(slen) &&
-        "not enough space provided for base64 encode");
-
-  dlen = base64_encoded_size(slen);
-
-  unsigned a;
-  unsigned b;
-  unsigned c;
-  unsigned i;
-  unsigned k;
-  unsigned n;
-
-  static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                              "abcdefghijklmnopqrstuvwxyz"
-                              "0123456789+/";
-
-  i = 0;
-  k = 0;
-  n = slen / 3 * 3;
-
-  while (i < n) {
-    a = src[i + 0] & 0xff;
-    b = src[i + 1] & 0xff;
-    c = src[i + 2] & 0xff;
-
-    dst[k + 0] = table[a >> 2];
-    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
-    dst[k + 3] = table[c & 0x3f];
-
-    i += 3;
-    k += 4;
-  }
-
-  switch (slen - n) {
-    case 1:
-      a = src[i + 0] & 0xff;
-      dst[k + 0] = table[a >> 2];
-      dst[k + 1] = table[(a & 3) << 4];
-      dst[k + 2] = '=';
-      dst[k + 3] = '=';
-      break;
-    case 2:
-      a = src[i + 0] & 0xff;
-      b = src[i + 1] & 0xff;
-      dst[k + 0] = table[a >> 2];
-      dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-      dst[k + 2] = table[(b & 0x0f) << 2];
-      dst[k + 3] = '=';
-      break;
-  }
-
-  return dlen;
-}
+                            size_t dlen,
+                            Base64Mode mode = Base64Mode::NORMAL);
 }  // namespace node
 
 
diff --git a/src/base_object-inl.h b/src/base_object-inl.h
index 3f4aef4def983600dec6298133399219a55d657e..43bcdc6404fe793bb383810466dae4fe2bb9809d 100644
--- a/src/base_object-inl.h
+++ b/src/base_object-inl.h
@@ -100,15 +100,16 @@ Environment* BaseObject::env() const {
   return env_;
 }
 
-BaseObject* BaseObject::FromJSObject(v8::Local<v8::Object> obj) {
-  CHECK_GT(obj->InternalFieldCount(), 0);
+BaseObject* BaseObject::FromJSObject(v8::Local<v8::Value> value) {
+  v8::Local<v8::Object> obj = value.As<v8::Object>();
+  DCHECK_GE(obj->InternalFieldCount(), BaseObject::kSlot);
   return static_cast<BaseObject*>(
       obj->GetAlignedPointerFromInternalField(BaseObject::kSlot));
 }
 
 
 template <typename T>
-T* BaseObject::FromJSObject(v8::Local<v8::Object> object) {
+T* BaseObject::FromJSObject(v8::Local<v8::Value> object) {
   return static_cast<T*>(FromJSObject(object));
 }
 
@@ -145,6 +146,13 @@ void BaseObject::ClearWeak() {
   persistent_handle_.ClearWeak();
 }
 
+bool BaseObject::IsWeakOrDetached() const {
+  if (persistent_handle_.IsWeak()) return true;
+
+  if (!has_pointer_data()) return false;
+  const PointerData* pd = const_cast<BaseObject*>(this)->pointer_data();
+  return pd->wants_weak_jsobj || pd->is_detached;
+}
 
 v8::Local<v8::FunctionTemplate>
 BaseObject::MakeLazilyInitializedJSTemplate(Environment* env) {
@@ -199,7 +207,7 @@ void BaseObject::decrease_refcount() {
   unsigned int new_refcount = --metadata->strong_ptr_count;
   if (new_refcount == 0) {
     if (metadata->is_detached) {
-      delete this;
+      OnGCCollect();
     } else if (metadata->wants_weak_jsobj && !persistent_handle_.IsEmpty()) {
       MakeWeak();
     }
diff --git a/src/base_object.h b/src/base_object.h
index 3bae620d713c55c3f349bf202c9222a10e589c91..b61e19dff8b874d17d34be5bcabeaa3274ed3ed5 100644
--- a/src/base_object.h
+++ b/src/base_object.h
@@ -65,9 +65,9 @@ class BaseObject : public MemoryRetainer {
   // was also passed to the `BaseObject()` constructor initially.
   // This may return `nullptr` if the C++ object has not been constructed yet,
   // e.g. when the JS object used `MakeLazilyInitializedJSTemplate`.
-  static inline BaseObject* FromJSObject(v8::Local<v8::Object> object);
+  static inline BaseObject* FromJSObject(v8::Local<v8::Value> object);
   template <typename T>
-  static inline T* FromJSObject(v8::Local<v8::Object> object);
+  static inline T* FromJSObject(v8::Local<v8::Value> object);
 
   // Make the `v8::Global` a weak reference and, `delete` this object once
   // the JS object has been garbage collected and there are no (strong)
@@ -78,6 +78,11 @@ class BaseObject : public MemoryRetainer {
   // root and will not be touched by the garbage collector.
   inline void ClearWeak();
 
+  // Reports whether this BaseObject is using a weak reference or detached,
+  // i.e. whether is can be deleted by GC once no strong BaseObjectPtrs refer
+  // to it anymore.
+  inline bool IsWeakOrDetached() const;
+
   // Utility to create a FunctionTemplate with one internal field (used for
   // the `BaseObject*` pointer) and a constructor that initializes that field
   // to `nullptr`.
@@ -111,13 +116,13 @@ class BaseObject : public MemoryRetainer {
   // the current object:
   // - kUntransferable:
   //     No transfer is possible, either because this type of BaseObject does
-  //     not know how to be transfered, or because it is not in a state in
+  //     not know how to be transferred, or because it is not in a state in
   //     which it is possible to do so (e.g. because it has already been
-  //     transfered).
+  //     transferred).
   // - kTransferable:
-  //     This object can be transfered in a destructive fashion, i.e. will be
+  //     This object can be transferred in a destructive fashion, i.e. will be
   //     rendered unusable on the sending side of the channel in the process
-  //     of being transfered. (In C++ this would be referred to as movable but
+  //     of being transferred. (In C++ this would be referred to as movable but
   //     not copyable.) Objects of this type need to be listed in the
   //     `transferList` argument of the relevant postMessage() call in order to
   //     make sure that they are not accidentally destroyed on the sending side.
@@ -147,6 +152,10 @@ class BaseObject : public MemoryRetainer {
   virtual v8::Maybe<bool> FinalizeTransferRead(
       v8::Local<v8::Context> context, v8::ValueDeserializer* deserializer);
 
+  // Indicates whether this object is expected to use a strong reference during
+  // a clean process exit (due to an empty event loop).
+  virtual bool IsNotIndicativeOfMemoryLeakAtExit() const;
+
   virtual inline void OnGCCollect();
 
  private:
@@ -180,7 +189,7 @@ class BaseObject : public MemoryRetainer {
     // Indicates whether MakeWeak() has been called.
     bool wants_weak_jsobj = false;
     // Indicates whether Detach() has been called. If that is the case, this
-    // object will be destryoed once the strong pointer count drops to zero.
+    // object will be destroyed once the strong pointer count drops to zero.
     bool is_detached = false;
     // Reference to the original BaseObject. This is used by weak pointers.
     BaseObject* self = nullptr;
@@ -201,7 +210,7 @@ class BaseObject : public MemoryRetainer {
 
 // Global alias for FromJSObject() to avoid churn.
 template <typename T>
-inline T* Unwrap(v8::Local<v8::Object> obj) {
+inline T* Unwrap(v8::Local<v8::Value> obj) {
   return BaseObject::FromJSObject<T>(obj);
 }
 
diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index d54e7c60cff63b781bfcc339980a366dd76a096b..7f5769569d5dadc29c0cda8ee8b9833769e9f081 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -19,14 +19,17 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#define CARES_STATICLIB
-#include "ares.h"
 #include "async_wrap-inl.h"
+#include "base_object-inl.h"
+#include "base64-inl.h"
+#include "cares_wrap.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node.h"
+#include "node_errors.h"
 #include "req_wrap-inl.h"
 #include "util-inl.h"
+#include "v8.h"
 #include "uv.h"
 
 #include <cerrno>
@@ -35,11 +38,9 @@
 #include <vector>
 #include <unordered_set>
 
-#ifdef __POSIX__
-# include <netdb.h>
-#endif  // __POSIX__
-
-# include <ares_nameser.h>
+#ifndef T_CAA
+# define T_CAA    257 /* Certification Authority Authorization */
+#endif
 
 // OpenBSD does not define these
 #ifndef AI_ALL
@@ -49,6 +50,7 @@
 # define AI_V4MAPPED 0
 #endif
 
+
 namespace node {
 namespace cares_wrap {
 
@@ -61,8 +63,10 @@ using v8::HandleScope;
 using v8::Int32;
 using v8::Integer;
 using v8::Isolate;
+using v8::Just;
 using v8::Local;
-using v8::NewStringType;
+using v8::Maybe;
+using v8::Nothing;
 using v8::Null;
 using v8::Object;
 using v8::String;
@@ -76,197 +80,8 @@ inline uint16_t cares_get_16bit(const unsigned char* p) {
   return static_cast<uint32_t>(p[0] << 8U) | (static_cast<uint32_t>(p[1]));
 }
 
-inline uint32_t cares_get_32bit(const unsigned char* p) {
-  return static_cast<uint32_t>(p[0] << 24U) |
-         static_cast<uint32_t>(p[1] << 16U) |
-         static_cast<uint32_t>(p[2] << 8U) |
-         static_cast<uint32_t>(p[3]);
-}
-
-const int ns_t_cname_or_a = -1;
-
-#define DNS_ESETSRVPENDING -1000
-inline const char* ToErrorCodeString(int status) {
-  switch (status) {
-#define V(code) case ARES_##code: return #code;
-    V(EADDRGETNETWORKPARAMS)
-    V(EBADFAMILY)
-    V(EBADFLAGS)
-    V(EBADHINTS)
-    V(EBADNAME)
-    V(EBADQUERY)
-    V(EBADRESP)
-    V(EBADSTR)
-    V(ECANCELLED)
-    V(ECONNREFUSED)
-    V(EDESTRUCTION)
-    V(EFILE)
-    V(EFORMERR)
-    V(ELOADIPHLPAPI)
-    V(ENODATA)
-    V(ENOMEM)
-    V(ENONAME)
-    V(ENOTFOUND)
-    V(ENOTIMP)
-    V(ENOTINITIALIZED)
-    V(EOF)
-    V(EREFUSED)
-    V(ESERVFAIL)
-    V(ETIMEOUT)
-#undef V
-  }
-
-  return "UNKNOWN_ARES_ERROR";
-}
-
-class ChannelWrap;
-
-struct node_ares_task : public MemoryRetainer {
-  ChannelWrap* channel;
-  ares_socket_t sock;
-  uv_poll_t poll_watcher;
-
-  inline void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(node_ares_task)
-  SET_SELF_SIZE(node_ares_task)
-};
-
-struct TaskHash {
-  size_t operator()(node_ares_task* a) const {
-    return std::hash<ares_socket_t>()(a->sock);
-  }
-};
-
-struct TaskEqual {
-  inline bool operator()(node_ares_task* a, node_ares_task* b) const {
-    return a->sock == b->sock;
-  }
-};
-
-using node_ares_task_list =
-    std::unordered_set<node_ares_task*, TaskHash, TaskEqual>;
-
-class ChannelWrap : public AsyncWrap {
- public:
-  ChannelWrap(Environment* env, Local<Object> object, int timeout);
-  ~ChannelWrap() override;
-
-  static void New(const FunctionCallbackInfo<Value>& args);
-
-  void Setup();
-  void EnsureServers();
-  void StartTimer();
-  void CloseTimer();
-
-  void ModifyActivityQueryCount(int count);
-
-  inline uv_timer_t* timer_handle() { return timer_handle_; }
-  inline ares_channel cares_channel() { return channel_; }
-  inline void set_query_last_ok(bool ok) { query_last_ok_ = ok; }
-  inline void set_is_servers_default(bool is_default) {
-    is_servers_default_ = is_default;
-  }
-  inline int active_query_count() { return active_query_count_; }
-  inline node_ares_task_list* task_list() { return &task_list_; }
-
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    if (timer_handle_ != nullptr)
-      tracker->TrackField("timer_handle", *timer_handle_);
-    tracker->TrackField("task_list", task_list_, "node_ares_task_list");
-  }
-
-  SET_MEMORY_INFO_NAME(ChannelWrap)
-  SET_SELF_SIZE(ChannelWrap)
-
-  static void AresTimeout(uv_timer_t* handle);
-
- private:
-  uv_timer_t* timer_handle_;
-  ares_channel channel_;
-  bool query_last_ok_;
-  bool is_servers_default_;
-  bool library_inited_;
-  int timeout_;
-  int active_query_count_;
-  node_ares_task_list task_list_;
-};
-
-ChannelWrap::ChannelWrap(Environment* env,
-                         Local<Object> object,
-                         int timeout)
-  : AsyncWrap(env, object, PROVIDER_DNSCHANNEL),
-    timer_handle_(nullptr),
-    channel_(nullptr),
-    query_last_ok_(true),
-    is_servers_default_(true),
-    library_inited_(false),
-    timeout_(timeout),
-    active_query_count_(0) {
-  MakeWeak();
-
-  Setup();
-}
-
-void ChannelWrap::New(const FunctionCallbackInfo<Value>& args) {
-  CHECK(args.IsConstructCall());
-  CHECK_EQ(args.Length(), 1);
-  CHECK(args[0]->IsInt32());
-  const int timeout = args[0].As<Int32>()->Value();
-  Environment* env = Environment::GetCurrent(args);
-  new ChannelWrap(env, args.This(), timeout);
-}
-
-class GetAddrInfoReqWrap : public ReqWrap<uv_getaddrinfo_t> {
- public:
-  GetAddrInfoReqWrap(Environment* env,
-                     Local<Object> req_wrap_obj,
-                     bool verbatim);
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(GetAddrInfoReqWrap)
-  SET_SELF_SIZE(GetAddrInfoReqWrap)
-
-  bool verbatim() const { return verbatim_; }
-
- private:
-  const bool verbatim_;
-};
-
-GetAddrInfoReqWrap::GetAddrInfoReqWrap(Environment* env,
-                                       Local<Object> req_wrap_obj,
-                                       bool verbatim)
-    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_GETADDRINFOREQWRAP)
-    , verbatim_(verbatim) {
-}
-
-
-class GetNameInfoReqWrap : public ReqWrap<uv_getnameinfo_t> {
- public:
-  GetNameInfoReqWrap(Environment* env, Local<Object> req_wrap_obj);
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(GetNameInfoReqWrap)
-  SET_SELF_SIZE(GetNameInfoReqWrap)
-};
-
-GetNameInfoReqWrap::GetNameInfoReqWrap(Environment* env,
-                                       Local<Object> req_wrap_obj)
-    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_GETNAMEINFOREQWRAP) {
-}
-
-
-/* This is called once per second by loop->timer. It is used to constantly */
-/* call back into c-ares for possibly processing timeouts. */
-void ChannelWrap::AresTimeout(uv_timer_t* handle) {
-  ChannelWrap* channel = static_cast<ChannelWrap*>(handle->data);
-  CHECK_EQ(channel->timer_handle(), handle);
-  CHECK_EQ(false, channel->task_list()->empty());
-  ares_process_fd(channel->cares_channel(), ARES_SOCKET_BAD, ARES_SOCKET_BAD);
-}
-
-
 void ares_poll_cb(uv_poll_t* watcher, int status, int events) {
-  node_ares_task* task = ContainerOf(&node_ares_task::poll_watcher, watcher);
+  NodeAresTask* task = ContainerOf(&NodeAresTask::poll_watcher, watcher);
   ChannelWrap* channel = task->channel;
 
   /* Reset the idle timer */
@@ -287,41 +102,17 @@ void ares_poll_cb(uv_poll_t* watcher, int status, int events) {
 
 
 void ares_poll_close_cb(uv_poll_t* watcher) {
-  node_ares_task* task = ContainerOf(&node_ares_task::poll_watcher, watcher);
-  delete task;
-}
-
-void node_ares_task::MemoryInfo(MemoryTracker* tracker) const {
-  tracker->TrackField("channel", channel);
-}
-
-/* Allocates and returns a new node_ares_task */
-node_ares_task* ares_task_create(ChannelWrap* channel, ares_socket_t sock) {
-  auto task = new node_ares_task();
-
-  task->channel = channel;
-  task->sock = sock;
-
-  if (uv_poll_init_socket(channel->env()->event_loop(),
-                          &task->poll_watcher, sock) < 0) {
-    /* This should never happen. */
-    delete task;
-    return nullptr;
-  }
-
-  return task;
+  std::unique_ptr<NodeAresTask> free_me(
+        ContainerOf(&NodeAresTask::poll_watcher, watcher));
 }
 
 
 /* Callback from ares when socket operation is started */
-void ares_sockstate_cb(void* data,
-                       ares_socket_t sock,
-                       int read,
-                       int write) {
+void ares_sockstate_cb(void* data, ares_socket_t sock, int read, int write) {
   ChannelWrap* channel = static_cast<ChannelWrap*>(data);
-  node_ares_task* task;
+  NodeAresTask* task;
 
-  node_ares_task lookup_task;
+  NodeAresTask lookup_task;
   lookup_task.sock = sock;
   auto it = channel->task_list()->find(&lookup_task);
 
@@ -332,7 +123,7 @@ void ares_sockstate_cb(void* data,
       /* New socket */
       channel->StartTimer();
 
-      task = ares_task_create(channel, sock);
+      task = NodeAresTask::Create(channel, sock);
       if (task == nullptr) {
         /* This should never happen unless we're out of memory or something */
         /* is seriously wrong. The socket won't be polled, but the query will */
@@ -365,414 +156,55 @@ void ares_sockstate_cb(void* data,
   }
 }
 
-
-Local<Array> HostentToNames(Environment* env,
-                            struct hostent* host,
-                            Local<Array> append_to = Local<Array>()) {
+Local<Array> HostentToNames(Environment* env, struct hostent* host) {
   EscapableHandleScope scope(env->isolate());
-  auto context = env->context();
-  bool append = !append_to.IsEmpty();
-  Local<Array> names = append ? append_to : Array::New(env->isolate());
-  size_t offset = names->Length();
-
-  for (uint32_t i = 0; host->h_aliases[i] != nullptr; ++i) {
-    Local<String> address = OneByteString(env->isolate(), host->h_aliases[i]);
-    names->Set(context, i + offset, address).Check();
-  }
-
-  return append ? names : scope.Escape(names);
-}
-
-void safe_free_hostent(struct hostent* host) {
-  int idx;
-
-  if (host->h_addr_list != nullptr) {
-    idx = 0;
-    while (host->h_addr_list[idx]) {
-      free(host->h_addr_list[idx++]);
-    }
-    free(host->h_addr_list);
-    host->h_addr_list = nullptr;
-  }
-
-  if (host->h_aliases != nullptr) {
-    idx = 0;
-    while (host->h_aliases[idx]) {
-      free(host->h_aliases[idx++]);
-    }
-    free(host->h_aliases);
-    host->h_aliases = nullptr;
-  }
-
-  free(host->h_name);
-  free(host);
-}
 
-void cares_wrap_hostent_cpy(struct hostent* dest, const struct hostent* src) {
-  dest->h_addr_list = nullptr;
-  dest->h_addrtype = 0;
-  dest->h_aliases = nullptr;
-  dest->h_length = 0;
-  dest->h_name = nullptr;
+  std::vector<Local<Value>> names;
 
-  /* copy `h_name` */
-  size_t name_size = strlen(src->h_name) + 1;
-  dest->h_name = node::Malloc<char>(name_size);
-  memcpy(dest->h_name, src->h_name, name_size);
+  for (uint32_t i = 0; host->h_aliases[i] != nullptr; ++i)
+    names.emplace_back(OneByteString(env->isolate(), host->h_aliases[i]));
 
-  /* copy `h_aliases` */
-  size_t alias_count;
-  for (alias_count = 0;
-      src->h_aliases[alias_count] != nullptr;
-      alias_count++) {
-  }
+  Local<Array> ret = Array::New(env->isolate(), names.data(), names.size());
 
-  dest->h_aliases = node::Malloc<char*>(alias_count + 1);
-  for (size_t i = 0; i < alias_count; i++) {
-    const size_t cur_alias_size = strlen(src->h_aliases[i]) + 1;
-    dest->h_aliases[i] = node::Malloc(cur_alias_size);
-    memcpy(dest->h_aliases[i], src->h_aliases[i], cur_alias_size);
-  }
-  dest->h_aliases[alias_count] = nullptr;
-
-  /* copy `h_addr_list` */
-  size_t list_count;
-  for (list_count = 0;
-      src->h_addr_list[list_count] != nullptr;
-      list_count++) {
-  }
-
-  dest->h_addr_list = node::Malloc<char*>(list_count + 1);
-  for (size_t i = 0; i < list_count; i++) {
-    dest->h_addr_list[i] = node::Malloc(src->h_length);
-    memcpy(dest->h_addr_list[i], src->h_addr_list[i], src->h_length);
-  }
-  dest->h_addr_list[list_count] = nullptr;
-
-  /* work after work */
-  dest->h_length = src->h_length;
-  dest->h_addrtype = src->h_addrtype;
+  return scope.Escape(ret);
 }
 
-class QueryWrap;
-
-void ChannelWrap::Setup() {
-  struct ares_options options;
-  memset(&options, 0, sizeof(options));
-  options.flags = ARES_FLAG_NOCHECKRESP;
-  options.sock_state_cb = ares_sockstate_cb;
-  options.sock_state_cb_data = this;
-  options.timeout = timeout_;
-
-  int r;
-  if (!library_inited_) {
-    Mutex::ScopedLock lock(ares_library_mutex);
-    // Multiple calls to ares_library_init() increase a reference counter,
-    // so this is a no-op except for the first call to it.
-    r = ares_library_init(ARES_LIB_INIT_ALL);
-    if (r != ARES_SUCCESS)
-      return env()->ThrowError(ToErrorCodeString(r));
-  }
-
-  /* We do the call to ares_init_option for caller. */
-  const int optmask =
-      ARES_OPT_FLAGS | ARES_OPT_TIMEOUTMS | ARES_OPT_SOCK_STATE_CB;
-  r = ares_init_options(&channel_, &options, optmask);
-
-  if (r != ARES_SUCCESS) {
-    Mutex::ScopedLock lock(ares_library_mutex);
-    ares_library_cleanup();
-    return env()->ThrowError(ToErrorCodeString(r));
-  }
-
-  library_inited_ = true;
-}
-
-void ChannelWrap::StartTimer() {
-  if (timer_handle_ == nullptr) {
-    timer_handle_ = new uv_timer_t();
-    timer_handle_->data = static_cast<void*>(this);
-    uv_timer_init(env()->event_loop(), timer_handle_);
-  } else if (uv_is_active(reinterpret_cast<uv_handle_t*>(timer_handle_))) {
-    return;
-  }
-  int timeout = timeout_;
-  if (timeout == 0) timeout = 1;
-  if (timeout < 0 || timeout > 1000) timeout = 1000;
-  uv_timer_start(timer_handle_, AresTimeout, timeout, timeout);
-}
-
-void ChannelWrap::CloseTimer() {
-  if (timer_handle_ == nullptr)
-    return;
-
-  env()->CloseHandle(timer_handle_, [](uv_timer_t* handle) { delete handle; });
-  timer_handle_ = nullptr;
-}
-
-ChannelWrap::~ChannelWrap() {
-  ares_destroy(channel_);
-
-  if (library_inited_) {
-    Mutex::ScopedLock lock(ares_library_mutex);
-    // This decreases the reference counter increased by ares_library_init().
-    ares_library_cleanup();
-  }
-
-  CloseTimer();
-}
-
-
-void ChannelWrap::ModifyActivityQueryCount(int count) {
-  active_query_count_ += count;
-  CHECK_GE(active_query_count_, 0);
-}
-
-
-/**
- * This function is to check whether current servers are fallback servers
- * when cares initialized.
- *
- * The fallback servers of cares is [ "127.0.0.1" ] with no user additional
- * setting.
- */
-void ChannelWrap::EnsureServers() {
-  /* if last query is OK or servers are set by user self, do not check */
-  if (query_last_ok_ || !is_servers_default_) {
-    return;
-  }
-
-  ares_addr_port_node* servers = nullptr;
-
-  ares_get_servers_ports(channel_, &servers);
-
-  /* if no server or multi-servers, ignore */
-  if (servers == nullptr) return;
-  if (servers->next != nullptr) {
-    ares_free_data(servers);
-    is_servers_default_ = false;
-    return;
-  }
+Local<Array> HostentToNames(Environment* env,
+                            struct hostent* host,
+                            Local<Array> names) {
+  size_t offset = names->Length();
 
-  /* if the only server is not 127.0.0.1, ignore */
-  if (servers[0].family != AF_INET ||
-      servers[0].addr.addr4.s_addr != htonl(INADDR_LOOPBACK) ||
-      servers[0].tcp_port != 0 ||
-      servers[0].udp_port != 0) {
-    ares_free_data(servers);
-    is_servers_default_ = false;
-    return;
+  for (uint32_t i = 0; host->h_aliases[i] != nullptr; ++i) {
+    names->Set(
+        env->context(),
+        i + offset,
+        OneByteString(env->isolate(), host->h_aliases[i])).Check();
   }
 
-  ares_free_data(servers);
-  servers = nullptr;
-
-  /* destroy channel and reset channel */
-  ares_destroy(channel_);
-
-  CloseTimer();
-  Setup();
+  return names;
 }
 
-
-class QueryWrap : public AsyncWrap {
- public:
-  QueryWrap(ChannelWrap* channel, Local<Object> req_wrap_obj, const char* name)
-      : AsyncWrap(channel->env(), req_wrap_obj, AsyncWrap::PROVIDER_QUERYWRAP),
-        channel_(channel),
-        trace_name_(name) {
-  }
-
-  ~QueryWrap() override {
-    CHECK_EQ(false, persistent().IsEmpty());
-
-    // Let Callback() know that this object no longer exists.
-    if (callback_ptr_ != nullptr)
-      *callback_ptr_ = nullptr;
-  }
-
-  // Subclasses should implement the appropriate Send method.
-  virtual int Send(const char* name) {
-    UNREACHABLE();
-    return 0;
-  }
-
-  virtual int Send(const char* name, int family) {
-    UNREACHABLE();
-    return 0;
-  }
-
- protected:
-  void AresQuery(const char* name,
-                 int dnsclass,
-                 int type) {
-    channel_->EnsureServers();
-    TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(
-      TRACING_CATEGORY_NODE2(dns, native), trace_name_, this,
-      "name", TRACE_STR_COPY(name));
-    ares_query(channel_->cares_channel(), name, dnsclass, type, Callback,
-               MakeCallbackPointer());
-  }
-
-  struct ResponseData {
-    int status;
-    bool is_host;
-    DeleteFnPtr<hostent, safe_free_hostent> host;
-    MallocedBuffer<unsigned char> buf;
-  };
-
-  void AfterResponse() {
-    CHECK(response_data_);
-
-    const int status = response_data_->status;
-
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-    } else if (!response_data_->is_host) {
-      Parse(response_data_->buf.data, response_data_->buf.size);
-    } else {
-      Parse(response_data_->host.get());
-    }
-  }
-
-  void* MakeCallbackPointer() {
-    CHECK_NULL(callback_ptr_);
-    callback_ptr_ = new QueryWrap*(this);
-    return callback_ptr_;
-  }
-
-  static QueryWrap* FromCallbackPointer(void* arg) {
-    std::unique_ptr<QueryWrap*> wrap_ptr { static_cast<QueryWrap**>(arg) };
-    QueryWrap* wrap = *wrap_ptr.get();
-    if (wrap == nullptr) return nullptr;
-    wrap->callback_ptr_ = nullptr;
-    return wrap;
-  }
-
-  static void Callback(void* arg, int status, int timeouts,
-                       unsigned char* answer_buf, int answer_len) {
-    QueryWrap* wrap = FromCallbackPointer(arg);
-    if (wrap == nullptr) return;
-
-    unsigned char* buf_copy = nullptr;
-    if (status == ARES_SUCCESS) {
-      buf_copy = node::Malloc<unsigned char>(answer_len);
-      memcpy(buf_copy, answer_buf, answer_len);
-    }
-
-    wrap->response_data_ = std::make_unique<ResponseData>();
-    ResponseData* data = wrap->response_data_.get();
-    data->status = status;
-    data->is_host = false;
-    data->buf = MallocedBuffer<unsigned char>(buf_copy, answer_len);
-
-    wrap->QueueResponseCallback(status);
-  }
-
-  static void Callback(void* arg, int status, int timeouts,
-                       struct hostent* host) {
-    QueryWrap* wrap = FromCallbackPointer(arg);
-    if (wrap == nullptr) return;
-
-    struct hostent* host_copy = nullptr;
-    if (status == ARES_SUCCESS) {
-      host_copy = node::Malloc<hostent>(1);
-      cares_wrap_hostent_cpy(host_copy, host);
-    }
-
-    wrap->response_data_ = std::make_unique<ResponseData>();
-    ResponseData* data = wrap->response_data_.get();
-    data->status = status;
-    data->host.reset(host_copy);
-    data->is_host = true;
-
-    wrap->QueueResponseCallback(status);
-  }
-
-  void QueueResponseCallback(int status) {
-    BaseObjectPtr<QueryWrap> strong_ref{this};
-    env()->SetImmediate([this, strong_ref](Environment*) {
-      AfterResponse();
-
-      // Delete once strong_ref goes out of scope.
-      Detach();
-    });
-
-    channel_->set_query_last_ok(status != ARES_ECONNREFUSED);
-    channel_->ModifyActivityQueryCount(-1);
-  }
-
-  void CallOnComplete(Local<Value> answer,
-                      Local<Value> extra = Local<Value>()) {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
-    Local<Value> argv[] = {
-      Integer::New(env()->isolate(), 0),
-      answer,
-      extra
-    };
-    const int argc = arraysize(argv) - extra.IsEmpty();
-    TRACE_EVENT_NESTABLE_ASYNC_END0(
-        TRACING_CATEGORY_NODE2(dns, native), trace_name_, this);
-
-    MakeCallback(env()->oncomplete_string(), argc, argv);
-  }
-
-  void ParseError(int status) {
-    CHECK_NE(status, ARES_SUCCESS);
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
-    const char* code = ToErrorCodeString(status);
-    Local<Value> arg = OneByteString(env()->isolate(), code);
-    TRACE_EVENT_NESTABLE_ASYNC_END1(
-        TRACING_CATEGORY_NODE2(dns, native), trace_name_, this,
-        "error", status);
-    MakeCallback(env()->oncomplete_string(), 1, &arg);
-  }
-
-  // Subclasses should implement the appropriate Parse method.
-  virtual void Parse(unsigned char* buf, int len) {
-    UNREACHABLE();
-  }
-
-  virtual void Parse(struct hostent* host) {
-    UNREACHABLE();
-  }
-
-  BaseObjectPtr<ChannelWrap> channel_;
-
- private:
-  std::unique_ptr<ResponseData> response_data_;
-  const char* trace_name_;
-  // Pointer to pointer to 'this' that can be reset from the destructor,
-  // in order to let Callback() know that 'this' no longer exists.
-  QueryWrap** callback_ptr_ = nullptr;
-};
-
-
 template <typename T>
-Local<Array> AddrTTLToArray(Environment* env,
-                            const T* addrttls,
-                            size_t naddrttls) {
-  auto isolate = env->isolate();
-
+Local<Array> AddrTTLToArray(
+    Environment* env,
+    const T* addrttls,
+    size_t naddrttls) {
   MaybeStackBuffer<Local<Value>, 8> ttls(naddrttls);
   for (size_t i = 0; i < naddrttls; i++)
-    ttls[i] = Integer::NewFromUnsigned(isolate, addrttls[i].ttl);
+    ttls[i] = Integer::NewFromUnsigned(env->isolate(), addrttls[i].ttl);
 
-  return Array::New(isolate, ttls.out(), naddrttls);
+  return Array::New(env->isolate(), ttls.out(), naddrttls);
 }
 
-
-int ParseGeneralReply(Environment* env,
-                      const unsigned char* buf,
-                      int len,
-                      int* type,
-                      Local<Array> ret,
-                      void* addrttls = nullptr,
-                      int* naddrttls = nullptr) {
+int ParseGeneralReply(
+    Environment* env,
+    const unsigned char* buf,
+    int len,
+    int* type,
+    Local<Array> ret,
+    void* addrttls = nullptr,
+    int* naddrttls = nullptr) {
   HandleScope handle_scope(env->isolate());
-  auto context = env->context();
   hostent* host;
 
   int status;
@@ -807,18 +239,20 @@ int ParseGeneralReply(Environment* env,
   if (status != ARES_SUCCESS)
     return status;
 
+  CHECK_NOT_NULL(host);
+  HostEntPointer ptr(host);
+
   /* If it's `CNAME`, return the CNAME value;
    * And if it's `CNAME_OR_A` and it has value in `h_name` and `h_aliases[0]`,
    * we consider it's a CNAME record, otherwise we consider it's an A record. */
-  if ((*type == ns_t_cname_or_a && host->h_name && host->h_aliases[0]) ||
+  if ((*type == ns_t_cname_or_a && ptr->h_name && ptr->h_aliases[0]) ||
       *type == ns_t_cname) {
     // A cname lookup always returns a single record but we follow the
     // common API here.
     *type = ns_t_cname;
-    ret->Set(context,
+    ret->Set(env->context(),
              ret->Length(),
-             OneByteString(env->isolate(), host->h_name)).Check();
-    ares_free_hostent(host);
+             OneByteString(env->isolate(), ptr->h_name)).Check();
     return ARES_SUCCESS;
   }
 
@@ -826,79 +260,110 @@ int ParseGeneralReply(Environment* env,
     *type = ns_t_a;
 
   if (*type == ns_t_ns) {
-    HostentToNames(env, host, ret);
+    HostentToNames(env, ptr.get(), ret);
   } else if (*type == ns_t_ptr) {
     uint32_t offset = ret->Length();
-    for (uint32_t i = 0; host->h_aliases[i] != nullptr; i++) {
-      auto alias = OneByteString(env->isolate(), host->h_aliases[i]);
-      ret->Set(context, i + offset, alias).Check();
+    for (uint32_t i = 0; ptr->h_aliases[i] != nullptr; i++) {
+      auto alias = OneByteString(env->isolate(), ptr->h_aliases[i]);
+      ret->Set(env->context(), i + offset, alias).Check();
     }
   } else {
     uint32_t offset = ret->Length();
     char ip[INET6_ADDRSTRLEN];
-    for (uint32_t i = 0; host->h_addr_list[i] != nullptr; ++i) {
-      uv_inet_ntop(host->h_addrtype, host->h_addr_list[i], ip, sizeof(ip));
+    for (uint32_t i = 0; ptr->h_addr_list[i] != nullptr; ++i) {
+      uv_inet_ntop(ptr->h_addrtype, ptr->h_addr_list[i], ip, sizeof(ip));
       auto address = OneByteString(env->isolate(), ip);
-      ret->Set(context, i + offset, address).Check();
+      ret->Set(env->context(), i + offset, address).Check();
     }
   }
 
-  ares_free_hostent(host);
-
   return ARES_SUCCESS;
 }
 
-
-int ParseMxReply(Environment* env,
-                 const unsigned char* buf,
-                 int len,
-                 Local<Array> ret,
-                 bool need_type = false) {
+int ParseMxReply(
+    Environment* env,
+    const unsigned char* buf,
+    int len,
+    Local<Array> ret,
+    bool need_type = false) {
   HandleScope handle_scope(env->isolate());
-  auto context = env->context();
 
   struct ares_mx_reply* mx_start;
   int status = ares_parse_mx_reply(buf, len, &mx_start);
-  if (status != ARES_SUCCESS) {
+  if (status != ARES_SUCCESS)
     return status;
-  }
 
   uint32_t offset = ret->Length();
   ares_mx_reply* current = mx_start;
   for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
     Local<Object> mx_record = Object::New(env->isolate());
-    mx_record->Set(context,
+    mx_record->Set(env->context(),
                    env->exchange_string(),
                    OneByteString(env->isolate(), current->host)).Check();
-    mx_record->Set(context,
+    mx_record->Set(env->context(),
                    env->priority_string(),
                    Integer::New(env->isolate(), current->priority)).Check();
     if (need_type)
-      mx_record->Set(context,
+      mx_record->Set(env->context(),
                      env->type_string(),
                      env->dns_mx_string()).Check();
 
-    ret->Set(context, i + offset, mx_record).Check();
+    ret->Set(env->context(), i + offset, mx_record).Check();
   }
 
   ares_free_data(mx_start);
   return ARES_SUCCESS;
 }
 
-int ParseTxtReply(Environment* env,
-                  const unsigned char* buf,
-                  int len,
-                  Local<Array> ret,
-                  bool need_type = false) {
+int ParseCaaReply(
+    Environment* env,
+    const unsigned char* buf,
+    int len,
+    Local<Array> ret,
+    bool need_type = false) {
+  HandleScope handle_scope(env->isolate());
+
+  struct ares_caa_reply* caa_start;
+  int status = ares_parse_caa_reply(buf, len, &caa_start);
+  if (status != ARES_SUCCESS)
+    return status;
+
+  uint32_t offset = ret->Length();
+  ares_caa_reply* current = caa_start;
+  for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
+    Local<Object> caa_record = Object::New(env->isolate());
+
+    caa_record->Set(env->context(),
+                    env->dns_critical_string(),
+                    Integer::New(env->isolate(), current->critical)).Check();
+    caa_record->Set(env->context(),
+                    OneByteString(env->isolate(), current->property),
+                    OneByteString(env->isolate(), current->value)).Check();
+    if (need_type)
+      caa_record->Set(env->context(),
+                      env->type_string(),
+                      env->dns_caa_string()).Check();
+
+    ret->Set(env->context(), i + offset, caa_record).Check();
+  }
+
+  ares_free_data(caa_start);
+  return ARES_SUCCESS;
+}
+
+int ParseTxtReply(
+    Environment* env,
+    const unsigned char* buf,
+    int len,
+    Local<Array> ret,
+    bool need_type = false) {
   HandleScope handle_scope(env->isolate());
-  auto context = env->context();
 
   struct ares_txt_ext* txt_out;
 
   int status = ares_parse_txt_reply_ext(buf, len, &txt_out);
-  if (status != ARES_SUCCESS) {
+  if (status != ARES_SUCCESS)
     return status;
-  }
 
   Local<Array> txt_chunk;
 
@@ -914,13 +379,13 @@ int ParseTxtReply(Environment* env,
       if (!txt_chunk.IsEmpty()) {
         if (need_type) {
           Local<Object> elem = Object::New(env->isolate());
-          elem->Set(context, env->entries_string(), txt_chunk).Check();
-          elem->Set(context,
+          elem->Set(env->context(), env->entries_string(), txt_chunk).Check();
+          elem->Set(env->context(),
                     env->type_string(),
                     env->dns_txt_string()).Check();
-          ret->Set(context, offset + i++, elem).Check();
+          ret->Set(env->context(), offset + i++, elem).Check();
         } else {
-          ret->Set(context, offset + i++, txt_chunk).Check();
+          ret->Set(env->context(), offset + i++, txt_chunk).Check();
         }
       }
 
@@ -928,20 +393,20 @@ int ParseTxtReply(Environment* env,
       j = 0;
     }
 
-    txt_chunk->Set(context, j++, txt).Check();
+    txt_chunk->Set(env->context(), j++, txt).Check();
   }
 
   // Push last chunk if it isn't empty
   if (!txt_chunk.IsEmpty()) {
     if (need_type) {
       Local<Object> elem = Object::New(env->isolate());
-      elem->Set(context, env->entries_string(), txt_chunk).Check();
-      elem->Set(context,
+      elem->Set(env->context(), env->entries_string(), txt_chunk).Check();
+      elem->Set(env->context(),
                 env->type_string(),
                 env->dns_txt_string()).Check();
-      ret->Set(context, offset + i, elem).Check();
+      ret->Set(env->context(), offset + i, elem).Check();
     } else {
-      ret->Set(context, offset + i, txt_chunk).Check();
+      ret->Set(env->context(), offset + i, txt_chunk).Check();
     }
   }
 
@@ -950,42 +415,41 @@ int ParseTxtReply(Environment* env,
 }
 
 
-int ParseSrvReply(Environment* env,
-                  const unsigned char* buf,
-                  int len,
-                  Local<Array> ret,
-                  bool need_type = false) {
+int ParseSrvReply(
+    Environment* env,
+    const unsigned char* buf,
+    int len,
+    Local<Array> ret,
+    bool need_type = false) {
   HandleScope handle_scope(env->isolate());
-  auto context = env->context();
 
   struct ares_srv_reply* srv_start;
   int status = ares_parse_srv_reply(buf, len, &srv_start);
-  if (status != ARES_SUCCESS) {
+  if (status != ARES_SUCCESS)
     return status;
-  }
 
   ares_srv_reply* current = srv_start;
   int offset = ret->Length();
   for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
     Local<Object> srv_record = Object::New(env->isolate());
-    srv_record->Set(context,
+    srv_record->Set(env->context(),
                     env->name_string(),
                     OneByteString(env->isolate(), current->host)).Check();
-    srv_record->Set(context,
+    srv_record->Set(env->context(),
                     env->port_string(),
                     Integer::New(env->isolate(), current->port)).Check();
-    srv_record->Set(context,
+    srv_record->Set(env->context(),
                     env->priority_string(),
                     Integer::New(env->isolate(), current->priority)).Check();
-    srv_record->Set(context,
+    srv_record->Set(env->context(),
                     env->weight_string(),
                     Integer::New(env->isolate(), current->weight)).Check();
     if (need_type)
-      srv_record->Set(context,
+      srv_record->Set(env->context(),
                       env->type_string(),
                       env->dns_srv_string()).Check();
 
-    ret->Set(context, i + offset, srv_record).Check();
+    ret->Set(env->context(), i + offset, srv_record).Check();
   }
 
   ares_free_data(srv_start);
@@ -993,53 +457,52 @@ int ParseSrvReply(Environment* env,
 }
 
 
-int ParseNaptrReply(Environment* env,
-                    const unsigned char* buf,
-                    int len,
-                    Local<Array> ret,
-                    bool need_type = false) {
+int ParseNaptrReply(
+    Environment* env,
+    const unsigned char* buf,
+    int len,
+    Local<Array> ret,
+    bool need_type = false) {
   HandleScope handle_scope(env->isolate());
-  auto context = env->context();
 
   ares_naptr_reply* naptr_start;
   int status = ares_parse_naptr_reply(buf, len, &naptr_start);
 
-  if (status != ARES_SUCCESS) {
+  if (status != ARES_SUCCESS)
     return status;
-  }
 
   ares_naptr_reply* current = naptr_start;
   int offset = ret->Length();
   for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
     Local<Object> naptr_record = Object::New(env->isolate());
-    naptr_record->Set(context,
+    naptr_record->Set(env->context(),
                       env->flags_string(),
                       OneByteString(env->isolate(), current->flags)).Check();
-    naptr_record->Set(context,
+    naptr_record->Set(env->context(),
                       env->service_string(),
                       OneByteString(env->isolate(),
                                     current->service)).Check();
-    naptr_record->Set(context,
+    naptr_record->Set(env->context(),
                       env->regexp_string(),
                       OneByteString(env->isolate(),
                                     current->regexp)).Check();
-    naptr_record->Set(context,
+    naptr_record->Set(env->context(),
                       env->replacement_string(),
                       OneByteString(env->isolate(),
                                     current->replacement)).Check();
-    naptr_record->Set(context,
+    naptr_record->Set(env->context(),
                       env->order_string(),
                       Integer::New(env->isolate(), current->order)).Check();
-    naptr_record->Set(context,
+    naptr_record->Set(env->context(),
                       env->preference_string(),
                       Integer::New(env->isolate(),
                                    current->preference)).Check();
     if (need_type)
-      naptr_record->Set(context,
+      naptr_record->Set(env->context(),
                         env->type_string(),
                         env->dns_naptr_string()).Check();
 
-    ret->Set(context, i + offset, naptr_record).Check();
+    ret->Set(env->context(), i + offset, naptr_record).Check();
   }
 
   ares_free_data(naptr_start);
@@ -1047,12 +510,12 @@ int ParseNaptrReply(Environment* env,
 }
 
 
-int ParseSoaReply(Environment* env,
-                  unsigned char* buf,
-                  int len,
-                  Local<Object>* ret) {
+int ParseSoaReply(
+    Environment* env,
+    unsigned char* buf,
+    int len,
+    Local<Object>* ret) {
   EscapableHandleScope handle_scope(env->isolate());
-  auto context = env->context();
 
   // Manage memory using standardard smart pointer std::unique_tr
   struct AresDeleter {
@@ -1126,36 +589,36 @@ int ParseSoaReply(Environment* env,
         return ARES_EBADRESP;
       }
 
-      const unsigned int serial = cares_get_32bit(ptr + 0 * 4);
-      const unsigned int refresh = cares_get_32bit(ptr + 1 * 4);
-      const unsigned int retry = cares_get_32bit(ptr + 2 * 4);
-      const unsigned int expire = cares_get_32bit(ptr + 3 * 4);
-      const unsigned int minttl = cares_get_32bit(ptr + 4 * 4);
+      const unsigned int serial = ReadUint32BE(ptr + 0 * 4);
+      const unsigned int refresh = ReadUint32BE(ptr + 1 * 4);
+      const unsigned int retry = ReadUint32BE(ptr + 2 * 4);
+      const unsigned int expire = ReadUint32BE(ptr + 3 * 4);
+      const unsigned int minttl = ReadUint32BE(ptr + 4 * 4);
 
       Local<Object> soa_record = Object::New(env->isolate());
-      soa_record->Set(context,
+      soa_record->Set(env->context(),
                       env->nsname_string(),
                       OneByteString(env->isolate(), nsname.get())).Check();
-      soa_record->Set(context,
+      soa_record->Set(env->context(),
                       env->hostmaster_string(),
                       OneByteString(env->isolate(),
                                     hostmaster.get())).Check();
-      soa_record->Set(context,
+      soa_record->Set(env->context(),
                       env->serial_string(),
                       Integer::NewFromUnsigned(env->isolate(), serial)).Check();
-      soa_record->Set(context,
+      soa_record->Set(env->context(),
                       env->refresh_string(),
                       Integer::New(env->isolate(), refresh)).Check();
-      soa_record->Set(context,
+      soa_record->Set(env->context(),
                       env->retry_string(),
                       Integer::New(env->isolate(), retry)).Check();
-      soa_record->Set(context,
+      soa_record->Set(env->context(),
                       env->expire_string(),
                       Integer::New(env->isolate(), expire)).Check();
-      soa_record->Set(context,
+      soa_record->Set(env->context(),
                       env->minttl_string(),
                       Integer::NewFromUnsigned(env->isolate(), minttl)).Check();
-      soa_record->Set(context,
+      soa_record->Set(env->context(),
                       env->type_string(),
                       env->dns_soa_string()).Check();
 
@@ -1167,623 +630,775 @@ int ParseSoaReply(Environment* env,
     ptr += rr_len;
   }
 
-  return ARES_SUCCESS;
+  return ARES_SUCCESS;
+}
+}  // anonymous namespace
+
+ChannelWrap::ChannelWrap(
+      Environment* env,
+      Local<Object> object,
+      int timeout,
+      int tries)
+    : AsyncWrap(env, object, PROVIDER_DNSCHANNEL),
+      timeout_(timeout),
+      tries_(tries) {
+  MakeWeak();
+
+  Setup();
+}
+
+void ChannelWrap::MemoryInfo(MemoryTracker* tracker) const {
+  if (timer_handle_ != nullptr)
+    tracker->TrackField("timer_handle", *timer_handle_);
+  tracker->TrackField("task_list", task_list_, "NodeAresTask::List");
+}
+
+void ChannelWrap::New(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args.IsConstructCall());
+  CHECK_EQ(args.Length(), 2);
+  CHECK(args[0]->IsInt32());
+  CHECK(args[1]->IsInt32());
+  const int timeout = args[0].As<Int32>()->Value();
+  const int tries = args[1].As<Int32>()->Value();
+  Environment* env = Environment::GetCurrent(args);
+  new ChannelWrap(env, args.This(), timeout, tries);
+}
+
+GetAddrInfoReqWrap::GetAddrInfoReqWrap(
+    Environment* env,
+    Local<Object> req_wrap_obj,
+    bool verbatim)
+    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_GETADDRINFOREQWRAP),
+      verbatim_(verbatim) {}
+
+GetNameInfoReqWrap::GetNameInfoReqWrap(
+    Environment* env,
+    Local<Object> req_wrap_obj)
+    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_GETNAMEINFOREQWRAP) {}
+
+/* This is called once per second by loop->timer. It is used to constantly */
+/* call back into c-ares for possibly processing timeouts. */
+void ChannelWrap::AresTimeout(uv_timer_t* handle) {
+  ChannelWrap* channel = static_cast<ChannelWrap*>(handle->data);
+  CHECK_EQ(channel->timer_handle(), handle);
+  CHECK_EQ(false, channel->task_list()->empty());
+  ares_process_fd(channel->cares_channel(), ARES_SOCKET_BAD, ARES_SOCKET_BAD);
+}
+
+
+void NodeAresTask::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("channel", channel);
+}
+
+/* Allocates and returns a new NodeAresTask */
+NodeAresTask* NodeAresTask::Create(ChannelWrap* channel, ares_socket_t sock) {
+  auto task = new NodeAresTask();
+
+  task->channel = channel;
+  task->sock = sock;
+
+  if (uv_poll_init_socket(channel->env()->event_loop(),
+                          &task->poll_watcher, sock) < 0) {
+    /* This should never happen. */
+    delete task;
+    return nullptr;
+  }
+
+  return task;
+}
+
+void ChannelWrap::Setup() {
+  struct ares_options options;
+  memset(&options, 0, sizeof(options));
+  options.flags = ARES_FLAG_NOCHECKRESP;
+  options.sock_state_cb = ares_sockstate_cb;
+  options.sock_state_cb_data = this;
+  options.timeout = timeout_;
+  options.tries = tries_;
+
+  int r;
+  if (!library_inited_) {
+    Mutex::ScopedLock lock(ares_library_mutex);
+    // Multiple calls to ares_library_init() increase a reference counter,
+    // so this is a no-op except for the first call to it.
+    r = ares_library_init(ARES_LIB_INIT_ALL);
+    if (r != ARES_SUCCESS)
+      return env()->ThrowError(ToErrorCodeString(r));
+  }
+
+  /* We do the call to ares_init_option for caller. */
+  const int optmask =
+      ARES_OPT_FLAGS | ARES_OPT_TIMEOUTMS |
+      ARES_OPT_SOCK_STATE_CB | ARES_OPT_TRIES;
+  r = ares_init_options(&channel_, &options, optmask);
+
+  if (r != ARES_SUCCESS) {
+    Mutex::ScopedLock lock(ares_library_mutex);
+    ares_library_cleanup();
+    return env()->ThrowError(ToErrorCodeString(r));
+  }
+
+  library_inited_ = true;
+}
+
+void ChannelWrap::StartTimer() {
+  if (timer_handle_ == nullptr) {
+    timer_handle_ = new uv_timer_t();
+    timer_handle_->data = static_cast<void*>(this);
+    uv_timer_init(env()->event_loop(), timer_handle_);
+  } else if (uv_is_active(reinterpret_cast<uv_handle_t*>(timer_handle_))) {
+    return;
+  }
+  int timeout = timeout_;
+  if (timeout == 0) timeout = 1;
+  if (timeout < 0 || timeout > 1000) timeout = 1000;
+  uv_timer_start(timer_handle_, AresTimeout, timeout, timeout);
+}
+
+void ChannelWrap::CloseTimer() {
+  if (timer_handle_ == nullptr)
+    return;
+
+  env()->CloseHandle(timer_handle_, [](uv_timer_t* handle) { delete handle; });
+  timer_handle_ = nullptr;
+}
+
+ChannelWrap::~ChannelWrap() {
+  ares_destroy(channel_);
+
+  if (library_inited_) {
+    Mutex::ScopedLock lock(ares_library_mutex);
+    // This decreases the reference counter increased by ares_library_init().
+    ares_library_cleanup();
+  }
+
+  CloseTimer();
+}
+
+
+void ChannelWrap::ModifyActivityQueryCount(int count) {
+  active_query_count_ += count;
+  CHECK_GE(active_query_count_, 0);
+}
+
+
+/**
+ * This function is to check whether current servers are fallback servers
+ * when cares initialized.
+ *
+ * The fallback servers of cares is [ "127.0.0.1" ] with no user additional
+ * setting.
+ */
+void ChannelWrap::EnsureServers() {
+  /* if last query is OK or servers are set by user self, do not check */
+  if (query_last_ok_ || !is_servers_default_) {
+    return;
+  }
+
+  ares_addr_port_node* servers = nullptr;
+
+  ares_get_servers_ports(channel_, &servers);
+
+  /* if no server or multi-servers, ignore */
+  if (servers == nullptr) return;
+  if (servers->next != nullptr) {
+    ares_free_data(servers);
+    is_servers_default_ = false;
+    return;
+  }
+
+  /* if the only server is not 127.0.0.1, ignore */
+  if (servers[0].family != AF_INET ||
+      servers[0].addr.addr4.s_addr != htonl(INADDR_LOOPBACK) ||
+      servers[0].tcp_port != 0 ||
+      servers[0].udp_port != 0) {
+    ares_free_data(servers);
+    is_servers_default_ = false;
+    return;
+  }
+
+  ares_free_data(servers);
+  servers = nullptr;
+
+  /* destroy channel and reset channel */
+  ares_destroy(channel_);
+
+  CloseTimer();
+  Setup();
+}
+
+int AnyTraits::Send(QueryWrap<AnyTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_any);
+  return 0;
+}
+
+int ATraits::Send(QueryWrap<ATraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_a);
+  return 0;
+}
+
+int AaaaTraits::Send(QueryWrap<AaaaTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_aaaa);
+  return 0;
+}
+
+int CaaTraits::Send(QueryWrap<CaaTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, T_CAA);
+  return 0;
+}
+
+int CnameTraits::Send(QueryWrap<CnameTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_cname);
+  return 0;
 }
 
+int MxTraits::Send(QueryWrap<MxTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_mx);
+  return 0;
+}
 
-class QueryAnyWrap: public QueryWrap {
- public:
-  QueryAnyWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-    : QueryWrap(channel, req_wrap_obj, "resolveAny") {
-  }
+int NsTraits::Send(QueryWrap<NsTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_ns);
+  return 0;
+}
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_any);
-    return 0;
-  }
+int TxtTraits::Send(QueryWrap<TxtTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_txt);
+  return 0;
+}
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryAnyWrap)
-  SET_SELF_SIZE(QueryAnyWrap)
-
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    auto context = env()->context();
-    Context::Scope context_scope(context);
-
-    Local<Array> ret = Array::New(env()->isolate());
-    int type, status, old_count;
-
-    /* Parse A records or CNAME records */
-    ares_addrttl addrttls[256];
-    int naddrttls = arraysize(addrttls);
-
-    type = ns_t_cname_or_a;
-    status = ParseGeneralReply(env(),
-                               buf,
-                               len,
-                               &type,
-                               ret,
-                               addrttls,
-                               &naddrttls);
-    uint32_t a_count = ret->Length();
-    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
-      ParseError(status);
-      return;
-    }
+int SrvTraits::Send(QueryWrap<SrvTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_srv);
+  return 0;
+}
 
-    if (type == ns_t_a) {
-      CHECK_EQ(static_cast<uint32_t>(naddrttls), a_count);
-      for (uint32_t i = 0; i < a_count; i++) {
-        Local<Object> obj = Object::New(env()->isolate());
-        obj->Set(context,
-                 env()->address_string(),
-                 ret->Get(context, i).ToLocalChecked()).Check();
-        obj->Set(context,
-                 env()->ttl_string(),
-                 Integer::NewFromUnsigned(
-                   env()->isolate(), addrttls[i].ttl)).Check();
-        obj->Set(context,
-                 env()->type_string(),
-                 env()->dns_a_string()).Check();
-        ret->Set(context, i, obj).Check();
-      }
-    } else {
-      for (uint32_t i = 0; i < a_count; i++) {
-        Local<Object> obj = Object::New(env()->isolate());
-        obj->Set(context,
-                 env()->value_string(),
-                 ret->Get(context, i).ToLocalChecked()).Check();
-        obj->Set(context,
-                 env()->type_string(),
-                 env()->dns_cname_string()).Check();
-        ret->Set(context, i, obj).Check();
-      }
-    }
+int PtrTraits::Send(QueryWrap<PtrTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_ptr);
+  return 0;
+}
 
-    /* Parse AAAA records */
-    ares_addr6ttl addr6ttls[256];
-    int naddr6ttls = arraysize(addr6ttls);
-
-    type = ns_t_aaaa;
-    status = ParseGeneralReply(env(),
-                               buf,
-                               len,
-                               &type,
-                               ret,
-                               addr6ttls,
-                               &naddr6ttls);
-    uint32_t aaaa_count = ret->Length() - a_count;
-    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
-      ParseError(status);
-      return;
-    }
+int NaptrTraits::Send(QueryWrap<NaptrTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_naptr);
+  return 0;
+}
 
-    CHECK_EQ(aaaa_count, static_cast<uint32_t>(naddr6ttls));
-    CHECK_EQ(ret->Length(), a_count + aaaa_count);
-    for (uint32_t i = a_count; i < ret->Length(); i++) {
-      Local<Object> obj = Object::New(env()->isolate());
-      obj->Set(context,
-               env()->address_string(),
-               ret->Get(context, i).ToLocalChecked()).Check();
-      obj->Set(context,
-               env()->ttl_string(),
-               Integer::NewFromUnsigned(
-                 env()->isolate(), addr6ttls[i - a_count].ttl)).Check();
-      obj->Set(context,
-               env()->type_string(),
-               env()->dns_aaaa_string()).Check();
-      ret->Set(context, i, obj).Check();
-    }
+int SoaTraits::Send(QueryWrap<SoaTraits>* wrap, const char* name) {
+  wrap->AresQuery(name, ns_c_in, ns_t_soa);
+  return 0;
+}
 
-    /* Parse MX records */
-    status = ParseMxReply(env(), buf, len, ret, true);
-    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
-      ParseError(status);
-      return;
-    }
+int AnyTraits::Parse(
+    QueryAnyWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-    /* Parse NS records */
-    type = ns_t_ns;
-    old_count = ret->Length();
-    status = ParseGeneralReply(env(), buf, len, &type, ret);
-    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
-      ParseError(status);
-      return;
-    }
-    for (uint32_t i = old_count; i < ret->Length(); i++) {
-      Local<Object> obj = Object::New(env()->isolate());
-      obj->Set(context,
-               env()->value_string(),
-               ret->Get(context, i).ToLocalChecked()).Check();
-      obj->Set(context,
-               env()->type_string(),
-               env()->dns_ns_string()).Check();
-      ret->Set(context, i, obj).Check();
-    }
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-    /* Parse TXT records */
-    status = ParseTxtReply(env(), buf, len, ret, true);
-    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
-      ParseError(status);
-      return;
-    }
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
-    /* Parse SRV records */
-    status = ParseSrvReply(env(), buf, len, ret, true);
-    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
-      return;
-    }
+  Local<Array> ret = Array::New(env->isolate());
+  int type, status, old_count;
+
+  /* Parse A records or CNAME records */
+  ares_addrttl addrttls[256];
+  int naddrttls = arraysize(addrttls);
+
+  type = ns_t_cname_or_a;
+  status = ParseGeneralReply(env,
+                             buf,
+                             len,
+                             &type,
+                             ret,
+                             addrttls,
+                             &naddrttls);
+  uint32_t a_count = ret->Length();
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
-    /* Parse PTR records */
-    type = ns_t_ptr;
-    old_count = ret->Length();
-    status = ParseGeneralReply(env(), buf, len, &type, ret);
-    for (uint32_t i = old_count; i < ret->Length(); i++) {
-      Local<Object> obj = Object::New(env()->isolate());
-      obj->Set(context,
-               env()->value_string(),
-               ret->Get(context, i).ToLocalChecked()).Check();
-      obj->Set(context,
-               env()->type_string(),
-               env()->dns_ptr_string()).Check();
-      ret->Set(context, i, obj).Check();
+  if (type == ns_t_a) {
+    CHECK_EQ(static_cast<uint32_t>(naddrttls), a_count);
+    for (uint32_t i = 0; i < a_count; i++) {
+      Local<Object> obj = Object::New(env->isolate());
+      obj->Set(env->context(),
+                env->address_string(),
+                ret->Get(env->context(), i).ToLocalChecked()).Check();
+      obj->Set(env->context(),
+                env->ttl_string(),
+                Integer::NewFromUnsigned(
+                  env->isolate(), addrttls[i].ttl)).Check();
+      obj->Set(env->context(),
+                env->type_string(),
+                env->dns_a_string()).Check();
+      ret->Set(env->context(), i, obj).Check();
     }
-
-    /* Parse NAPTR records */
-    status = ParseNaptrReply(env(), buf, len, ret, true);
-    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
-      ParseError(status);
-      return;
+  } else {
+    for (uint32_t i = 0; i < a_count; i++) {
+      Local<Object> obj = Object::New(env->isolate());
+      obj->Set(env->context(),
+                env->value_string(),
+                ret->Get(env->context(), i).ToLocalChecked()).Check();
+      obj->Set(env->context(),
+                env->type_string(),
+                env->dns_cname_string()).Check();
+      ret->Set(env->context(), i, obj).Check();
     }
+  }
 
-    /* Parse SOA records */
-    Local<Object> soa_record = Local<Object>();
-    status = ParseSoaReply(env(), buf, len, &soa_record);
-    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
-      ParseError(status);
-      return;
-    }
-    if (!soa_record.IsEmpty())
-      ret->Set(context, ret->Length(), soa_record).Check();
+  /* Parse AAAA records */
+  ares_addr6ttl addr6ttls[256];
+  int naddr6ttls = arraysize(addr6ttls);
+
+  type = ns_t_aaaa;
+  status = ParseGeneralReply(env,
+                             buf,
+                             len,
+                             &type,
+                             ret,
+                             addr6ttls,
+                             &naddr6ttls);
+  uint32_t aaaa_count = ret->Length() - a_count;
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
-    CallOnComplete(ret);
-  }
-};
+  CHECK_EQ(aaaa_count, static_cast<uint32_t>(naddr6ttls));
+  CHECK_EQ(ret->Length(), a_count + aaaa_count);
+  for (uint32_t i = a_count; i < ret->Length(); i++) {
+    Local<Object> obj = Object::New(env->isolate());
+    obj->Set(env->context(),
+              env->address_string(),
+              ret->Get(env->context(), i).ToLocalChecked()).Check();
+    obj->Set(env->context(),
+              env->ttl_string(),
+              Integer::NewFromUnsigned(
+                env->isolate(), addr6ttls[i - a_count].ttl)).Check();
+    obj->Set(env->context(),
+              env->type_string(),
+              env->dns_aaaa_string()).Check();
+    ret->Set(env->context(), i, obj).Check();
+  }
+
+  /* Parse MX records */
+  status = ParseMxReply(env, buf, len, ret, true);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
+  /* Parse NS records */
+  type = ns_t_ns;
+  old_count = ret->Length();
+  status = ParseGeneralReply(env, buf, len, &type, ret);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
-class QueryAWrap: public QueryWrap {
- public:
-  QueryAWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolve4") {
+  for (uint32_t i = old_count; i < ret->Length(); i++) {
+    Local<Object> obj = Object::New(env->isolate());
+    obj->Set(env->context(),
+             env->value_string(),
+             ret->Get(env->context(), i).ToLocalChecked()).Check();
+    obj->Set(env->context(),
+              env->type_string(),
+              env->dns_ns_string()).Check();
+    ret->Set(env->context(), i, obj).Check();
   }
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_a);
-    return 0;
-  }
+  /* Parse TXT records */
+  status = ParseTxtReply(env, buf, len, ret, true);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryAWrap)
-  SET_SELF_SIZE(QueryAWrap)
-
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
-
-    ares_addrttl addrttls[256];
-    int naddrttls = arraysize(addrttls), status;
-    Local<Array> ret = Array::New(env()->isolate());
-
-    int type = ns_t_a;
-    status = ParseGeneralReply(env(),
-                               buf,
-                               len,
-                               &type,
-                               ret,
-                               addrttls,
-                               &naddrttls);
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  /* Parse SRV records */
+  status = ParseSrvReply(env, buf, len, ret, true);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
-    Local<Array> ttls = AddrTTLToArray<ares_addrttl>(env(),
-                                                     addrttls,
-                                                     naddrttls);
+  /* Parse PTR records */
+  type = ns_t_ptr;
+  old_count = ret->Length();
+  status = ParseGeneralReply(env, buf, len, &type, ret);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
+  for (uint32_t i = old_count; i < ret->Length(); i++) {
+    Local<Object> obj = Object::New(env->isolate());
+    obj->Set(env->context(),
+              env->value_string(),
+              ret->Get(env->context(), i).ToLocalChecked()).Check();
+    obj->Set(env->context(),
+              env->type_string(),
+              env->dns_ptr_string()).Check();
+    ret->Set(env->context(), i, obj).Check();
+  }
+
+  /* Parse NAPTR records */
+  status = ParseNaptrReply(env, buf, len, ret, true);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
-    CallOnComplete(ret, ttls);
-  }
-};
+  /* Parse SOA records */
+  Local<Object> soa_record = Local<Object>();
+  status = ParseSoaReply(env, buf, len, &soa_record);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
+  if (!soa_record.IsEmpty())
+    ret->Set(env->context(), ret->Length(), soa_record).Check();
 
-class QueryAaaaWrap: public QueryWrap {
- public:
-  QueryAaaaWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolve6") {
-  }
+  /* Parse CAA records */
+  status = ParseCaaReply(env, buf, len, ret, true);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA)
+    return status;
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_aaaa);
-    return 0;
-  }
+  wrap->CallOnComplete(ret);
+  return 0;
+}
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryAaaaWrap)
-  SET_SELF_SIZE(QueryAaaaWrap)
-
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
-
-    ares_addr6ttl addrttls[256];
-    int naddrttls = arraysize(addrttls), status;
-    Local<Array> ret = Array::New(env()->isolate());
-
-    int type = ns_t_aaaa;
-    status = ParseGeneralReply(env(),
-                               buf,
-                               len,
-                               &type,
-                               ret,
-                               addrttls,
-                               &naddrttls);
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+int ATraits::Parse(
+    QueryAWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-    Local<Array> ttls = AddrTTLToArray<ares_addr6ttl>(env(),
-                                                      addrttls,
-                                                      naddrttls);
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-    CallOnComplete(ret, ttls);
-  }
-};
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
+  ares_addrttl addrttls[256];
+  int naddrttls = arraysize(addrttls), status;
+  Local<Array> ret = Array::New(env->isolate());
+
+  int type = ns_t_a;
+  status = ParseGeneralReply(env,
+                             buf,
+                             len,
+                             &type,
+                             ret,
+                             addrttls,
+                             &naddrttls);
+  if (status != ARES_SUCCESS)
+    return status;
 
-class QueryCnameWrap: public QueryWrap {
- public:
-  QueryCnameWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolveCname") {
-  }
+  Local<Array> ttls = AddrTTLToArray<ares_addrttl>(env, addrttls, naddrttls);
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_cname);
-    return 0;
-  }
+  wrap->CallOnComplete(ret, ttls);
+  return 0;
+}
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryCnameWrap)
-  SET_SELF_SIZE(QueryCnameWrap)
+int AaaaTraits::Parse(
+    QueryAaaaWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-    Local<Array> ret = Array::New(env()->isolate());
-    int type = ns_t_cname;
-    int status = ParseGeneralReply(env(), buf, len, &type, ret);
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
-    this->CallOnComplete(ret);
-  }
-};
+  ares_addr6ttl addrttls[256];
+  int naddrttls = arraysize(addrttls), status;
+  Local<Array> ret = Array::New(env->isolate());
+
+  int type = ns_t_aaaa;
+  status = ParseGeneralReply(env,
+                             buf,
+                             len,
+                             &type,
+                             ret,
+                             addrttls,
+                             &naddrttls);
+  if (status != ARES_SUCCESS)
+    return status;
 
+  Local<Array> ttls = AddrTTLToArray<ares_addr6ttl>(env, addrttls, naddrttls);
 
-class QueryMxWrap: public QueryWrap {
- public:
-  QueryMxWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolveMx") {
-  }
+  wrap->CallOnComplete(ret, ttls);
+  return 0;
+}
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_mx);
-    return 0;
-  }
+int CaaTraits::Parse(
+    QueryCaaWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryMxWrap)
-  SET_SELF_SIZE(QueryMxWrap)
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
-    Local<Array> mx_records = Array::New(env()->isolate());
-    int status = ParseMxReply(env(), buf, len, mx_records);
+  Local<Array> ret = Array::New(env->isolate());
+  int status = ParseCaaReply(env, buf, len, ret);
+  if (status != ARES_SUCCESS)
+    return status;
 
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  wrap->CallOnComplete(ret);
+  return 0;
+}
 
-    this->CallOnComplete(mx_records);
-  }
-};
+int CnameTraits::Parse(
+    QueryCnameWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-class QueryNsWrap: public QueryWrap {
- public:
-  QueryNsWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolveNs") {
-  }
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_ns);
-    return 0;
-  }
+  Local<Array> ret = Array::New(env->isolate());
+  int type = ns_t_cname;
+  int status = ParseGeneralReply(env, buf, len, &type, ret);
+  if (status != ARES_SUCCESS)
+    return status;
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryNsWrap)
-  SET_SELF_SIZE(QueryNsWrap)
+  wrap->CallOnComplete(ret);
+  return 0;
+}
 
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
+int MxTraits::Parse(
+    QueryMxWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-    int type = ns_t_ns;
-    Local<Array> names = Array::New(env()->isolate());
-    int status = ParseGeneralReply(env(), buf, len, &type, names);
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-    this->CallOnComplete(names);
-  }
-};
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
+  Local<Array> mx_records = Array::New(env->isolate());
+  int status = ParseMxReply(env, buf, len, mx_records);
 
-class QueryTxtWrap: public QueryWrap {
- public:
-  QueryTxtWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolveTxt") {
-  }
+  if (status != ARES_SUCCESS)
+    return status;
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_txt);
-    return 0;
-  }
+  wrap->CallOnComplete(mx_records);
+  return 0;
+}
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryTxtWrap)
-  SET_SELF_SIZE(QueryTxtWrap)
+int NsTraits::Parse(
+    QueryNsWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-    Local<Array> txt_records = Array::New(env()->isolate());
-    int status = ParseTxtReply(env(), buf, len, txt_records);
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
-    this->CallOnComplete(txt_records);
-  }
-};
+  int type = ns_t_ns;
+  Local<Array> names = Array::New(env->isolate());
+  int status = ParseGeneralReply(env, buf, len, &type, names);
+  if (status != ARES_SUCCESS)
+    return status;
 
+  wrap->CallOnComplete(names);
+  return 0;
+}
 
-class QuerySrvWrap: public QueryWrap {
- public:
-  explicit QuerySrvWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolveSrv") {
-  }
+int TxtTraits::Parse(
+    QueryTxtWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_srv);
-    return 0;
-  }
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QuerySrvWrap)
-  SET_SELF_SIZE(QuerySrvWrap)
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
+  Local<Array> txt_records = Array::New(env->isolate());
+  int status = ParseTxtReply(env, buf, len, txt_records);
+  if (status != ARES_SUCCESS)
+    return status;
 
-    Local<Array> srv_records = Array::New(env()->isolate());
-    int status = ParseSrvReply(env(), buf, len, srv_records);
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  wrap->CallOnComplete(txt_records);
+  return 0;
+}
 
-    this->CallOnComplete(srv_records);
-  }
-};
+int SrvTraits::Parse(
+    QuerySrvWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-class QueryPtrWrap: public QueryWrap {
- public:
-  explicit QueryPtrWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolvePtr") {
-  }
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_ptr);
-    return 0;
-  }
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryPtrWrap)
-  SET_SELF_SIZE(QueryPtrWrap)
+  Local<Array> srv_records = Array::New(env->isolate());
+  int status = ParseSrvReply(env, buf, len, srv_records);
+  if (status != ARES_SUCCESS)
+    return status;
 
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
+  wrap->CallOnComplete(srv_records);
+  return 0;
+}
 
-    int type = ns_t_ptr;
-    Local<Array> aliases = Array::New(env()->isolate());
+int PtrTraits::Parse(
+    QueryPtrWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-    int status = ParseGeneralReply(env(), buf, len, &type, aliases);
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-    this->CallOnComplete(aliases);
-  }
-};
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
-class QueryNaptrWrap: public QueryWrap {
- public:
-  explicit QueryNaptrWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolveNaptr") {
-  }
+  int type = ns_t_ptr;
+  Local<Array> aliases = Array::New(env->isolate());
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_naptr);
-    return 0;
-  }
+  int status = ParseGeneralReply(env, buf, len, &type, aliases);
+  if (status != ARES_SUCCESS)
+    return status;
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QueryNaptrWrap)
-  SET_SELF_SIZE(QueryNaptrWrap)
+  wrap->CallOnComplete(aliases);
+  return 0;
+}
 
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
+int NaptrTraits::Parse(
+    QueryNaptrWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-    Local<Array> naptr_records = Array::New(env()->isolate());
-    int status = ParseNaptrReply(env(), buf, len, naptr_records);
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
-    this->CallOnComplete(naptr_records);
-  }
-};
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
+  Local<Array> naptr_records = Array::New(env->isolate());
+  int status = ParseNaptrReply(env, buf, len, naptr_records);
+  if (status != ARES_SUCCESS)
+    return status;
 
-class QuerySoaWrap: public QueryWrap {
- public:
-  QuerySoaWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolveSoa") {
-  }
+  wrap->CallOnComplete(naptr_records);
+  return 0;
+}
 
-  int Send(const char* name) override {
-    AresQuery(name, ns_c_in, ns_t_soa);
-    return 0;
-  }
+int SoaTraits::Parse(
+    QuerySoaWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(response->is_host))
+    return ARES_EBADRESP;
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(QuerySoaWrap)
-  SET_SELF_SIZE(QuerySoaWrap)
+  unsigned char* buf = response->buf.data;
+  int len = response->buf.size;
 
- protected:
-  void Parse(unsigned char* buf, int len) override {
-    HandleScope handle_scope(env()->isolate());
-    auto context = env()->context();
-    Context::Scope context_scope(context);
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
 
-    ares_soa_reply* soa_out;
-    int status = ares_parse_soa_reply(buf, len, &soa_out);
+  ares_soa_reply* soa_out;
+  int status = ares_parse_soa_reply(buf, len, &soa_out);
 
-    if (status != ARES_SUCCESS) {
-      ParseError(status);
-      return;
-    }
+  if (status != ARES_SUCCESS)
+    return status;
 
-    Local<Object> soa_record = Object::New(env()->isolate());
-
-    soa_record->Set(context,
-                    env()->nsname_string(),
-                    OneByteString(env()->isolate(),
-                                  soa_out->nsname)).Check();
-    soa_record->Set(context,
-                    env()->hostmaster_string(),
-                    OneByteString(env()->isolate(),
-                                  soa_out->hostmaster)).Check();
-    soa_record->Set(context,
-                    env()->serial_string(),
-                    Integer::NewFromUnsigned(
-                      env()->isolate(), soa_out->serial)).Check();
-    soa_record->Set(context,
-                    env()->refresh_string(),
-                    Integer::New(env()->isolate(),
-                                 soa_out->refresh)).Check();
-    soa_record->Set(context,
-                    env()->retry_string(),
-                    Integer::New(env()->isolate(), soa_out->retry)).Check();
-    soa_record->Set(context,
-                    env()->expire_string(),
-                    Integer::New(env()->isolate(), soa_out->expire)).Check();
-    soa_record->Set(context,
-                    env()->minttl_string(),
-                    Integer::NewFromUnsigned(
-                      env()->isolate(), soa_out->minttl)).Check();
-
-    ares_free_data(soa_out);
-
-    this->CallOnComplete(soa_record);
-  }
-};
+  Local<Object> soa_record = Object::New(env->isolate());
+
+  soa_record->Set(env->context(),
+                  env->nsname_string(),
+                  OneByteString(env->isolate(), soa_out->nsname)).Check();
+  soa_record->Set(env->context(),
+                  env->hostmaster_string(),
+                  OneByteString(env->isolate(), soa_out->hostmaster)).Check();
+  soa_record->Set(env->context(),
+                  env->serial_string(),
+                  Integer::NewFromUnsigned(
+                      env->isolate(), soa_out->serial)).Check();
+  soa_record->Set(env->context(),
+                  env->refresh_string(),
+                  Integer::New(env->isolate(), soa_out->refresh)).Check();
+  soa_record->Set(env->context(),
+                  env->retry_string(),
+                  Integer::New(env->isolate(), soa_out->retry)).Check();
+  soa_record->Set(env->context(),
+                  env->expire_string(),
+                  Integer::New(env->isolate(), soa_out->expire)).Check();
+  soa_record->Set(env->context(),
+                  env->minttl_string(),
+                  Integer::NewFromUnsigned(
+                      env->isolate(), soa_out->minttl)).Check();
+
+  ares_free_data(soa_out);
+
+  wrap->CallOnComplete(soa_record);
+  return 0;
+}
 
+int ReverseTraits::Send(GetHostByAddrWrap* wrap, const char* name) {
+  int length, family;
+  char address_buffer[sizeof(struct in6_addr)];
 
-class GetHostByAddrWrap: public QueryWrap {
- public:
-  explicit GetHostByAddrWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "reverse") {
+  if (uv_inet_pton(AF_INET, name, &address_buffer) == 0) {
+    length = sizeof(struct in_addr);
+    family = AF_INET;
+  } else if (uv_inet_pton(AF_INET6, name, &address_buffer) == 0) {
+    length = sizeof(struct in6_addr);
+    family = AF_INET6;
+  } else {
+    return UV_EINVAL;  // So errnoException() reports a proper error.
   }
 
-  int Send(const char* name) override {
-    int length, family;
-    char address_buffer[sizeof(struct in6_addr)];
-
-    if (uv_inet_pton(AF_INET, name, &address_buffer) == 0) {
-      length = sizeof(struct in_addr);
-      family = AF_INET;
-    } else if (uv_inet_pton(AF_INET6, name, &address_buffer) == 0) {
-      length = sizeof(struct in6_addr);
-      family = AF_INET6;
-    } else {
-      return UV_EINVAL;  // So errnoException() reports a proper error.
-    }
-
-    TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(
-        TRACING_CATEGORY_NODE2(dns, native), "reverse", this,
-        "name", TRACE_STR_COPY(name),
-        "family", family == AF_INET ? "ipv4" : "ipv6");
-
-    ares_gethostbyaddr(channel_->cares_channel(),
-                       address_buffer,
-                       length,
-                       family,
-                       Callback,
-                       MakeCallbackPointer());
-    return 0;
-  }
+  TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(
+      TRACING_CATEGORY_NODE2(dns, native), "reverse", wrap,
+      "name", TRACE_STR_COPY(name),
+      "family", family == AF_INET ? "ipv4" : "ipv6");
+
+  ares_gethostbyaddr(
+      wrap->channel()->cares_channel(),
+      address_buffer,
+      length,
+      family,
+      GetHostByAddrWrap::Callback,
+      wrap->MakeCallbackPointer());
+  return 0;
+}
 
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(GetHostByAddrWrap)
-  SET_SELF_SIZE(GetHostByAddrWrap)
+int ReverseTraits::Parse(
+    GetHostByAddrWrap* wrap,
+    const std::unique_ptr<ResponseData>& response) {
+  if (UNLIKELY(!response->is_host))
+    return ARES_EBADRESP;
 
- protected:
-  void Parse(struct hostent* host) override {
-    HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
-    this->CallOnComplete(HostentToNames(env(), host));
-  }
-};
+  struct hostent* host = response->host.get();
 
+  Environment* env = wrap->env();
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
+  wrap->CallOnComplete(HostentToNames(env, host));
+  return 0;
+}
 
+namespace {
 template <class Wrap>
 static void Query(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1831,7 +1446,7 @@ void AfterGetAddrInfo(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
   if (status == 0) {
     Local<Array> results = Array::New(env->isolate());
 
-    auto add = [&] (bool want_ipv4, bool want_ipv6) {
+    auto add = [&] (bool want_ipv4, bool want_ipv6) -> Maybe<bool> {
       for (auto p = res; p != nullptr; p = p->ai_next) {
         CHECK_EQ(p->ai_socktype, SOCK_STREAM);
 
@@ -1851,14 +1466,19 @@ void AfterGetAddrInfo(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
           continue;
 
         Local<String> s = OneByteString(env->isolate(), ip);
-        results->Set(env->context(), n, s).Check();
+        if (results->Set(env->context(), n, s).IsNothing())
+          return Nothing<bool>();
         n++;
       }
+      return Just(true);
     };
 
-    add(true, verbatim);
-    if (verbatim == false)
-      add(false, true);
+    if (add(true, verbatim).IsNothing())
+      return;
+    if (verbatim == false) {
+      if (add(false, true).IsNothing())
+        return;
+    }
 
     // No responses were found to return
     if (n == 0) {
@@ -1935,8 +1555,8 @@ void CanonicalizeIP(const FunctionCallbackInfo<Value>& args) {
   char canonical_ip[INET6_ADDRSTRLEN];
   const int af = (rc == 4 ? AF_INET : AF_INET6);
   CHECK_EQ(0, uv_inet_ntop(af, &result, canonical_ip, sizeof(canonical_ip)));
-  Local<String> val = String::NewFromUtf8(isolate, canonical_ip,
-      NewStringType::kNormal).ToLocalChecked();
+  Local<String> val = String::NewFromUtf8(isolate, canonical_ip)
+      .ToLocalChecked();
   args.GetReturnValue().Set(val);
 }
 
@@ -2152,6 +1772,70 @@ void SetServers(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(err);
 }
 
+void SetLocalAddress(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  ChannelWrap* channel;
+  ASSIGN_OR_RETURN_UNWRAP(&channel, args.Holder());
+
+  CHECK_EQ(args.Length(), 2);
+  CHECK(args[0]->IsString());
+
+  Isolate* isolate = args.GetIsolate();
+  node::Utf8Value ip0(isolate, args[0]);
+
+  unsigned char addr0[sizeof(struct in6_addr)];
+  unsigned char addr1[sizeof(struct in6_addr)];
+  int type0 = 0;
+
+  // This function accepts 2 arguments.  The first may be either an IPv4
+  // address or an IPv6 address.  If present, the second argument must be the
+  // other type of address.  Otherwise, the unspecified type of IP is set
+  // to 0 (any).
+
+  if (uv_inet_pton(AF_INET, *ip0, &addr0) == 0) {
+    ares_set_local_ip4(channel->cares_channel(), ReadUint32BE(addr0));
+    type0 = 4;
+  } else if (uv_inet_pton(AF_INET6, *ip0, &addr0) == 0) {
+    ares_set_local_ip6(channel->cares_channel(), addr0);
+    type0 = 6;
+  } else {
+    THROW_ERR_INVALID_ARG_VALUE(env, "Invalid IP address.");
+    return;
+  }
+
+  if (!args[1]->IsUndefined()) {
+    CHECK(args[1]->IsString());
+    node::Utf8Value ip1(isolate, args[1]);
+
+    if (uv_inet_pton(AF_INET, *ip1, &addr1) == 0) {
+      if (type0 == 4) {
+        THROW_ERR_INVALID_ARG_VALUE(env, "Cannot specify two IPv4 addresses.");
+        return;
+      } else {
+        ares_set_local_ip4(channel->cares_channel(), ReadUint32BE(addr1));
+      }
+    } else if (uv_inet_pton(AF_INET6, *ip1, &addr1) == 0) {
+      if (type0 == 6) {
+        THROW_ERR_INVALID_ARG_VALUE(env, "Cannot specify two IPv6 addresses.");
+        return;
+      } else {
+        ares_set_local_ip6(channel->cares_channel(), addr1);
+      }
+    } else {
+      THROW_ERR_INVALID_ARG_VALUE(env, "Invalid IP address.");
+      return;
+    }
+  } else {
+    // No second arg specified
+    if (type0 == 4) {
+      memset(&addr1, 0, sizeof(addr1));
+      ares_set_local_ip6(channel->cares_channel(), addr1);
+    } else {
+      ares_set_local_ip4(channel->cares_channel(), 0);
+    }
+  }
+}
+
 void Cancel(const FunctionCallbackInfo<Value>& args) {
   ChannelWrap* channel;
   ASSIGN_OR_RETURN_UNWRAP(&channel, args.Holder());
@@ -2172,6 +1856,32 @@ void StrError(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(OneByteString(env->isolate(), errmsg));
 }
 
+}  // namespace
+
+inline void safe_free_hostent(struct hostent* host) {
+  int idx;
+
+  if (host->h_addr_list != nullptr) {
+    idx = 0;
+    while (host->h_addr_list[idx]) {
+      free(host->h_addr_list[idx++]);
+    }
+    free(host->h_addr_list);
+    host->h_addr_list = nullptr;
+  }
+
+  if (host->h_aliases != nullptr) {
+    idx = 0;
+    while (host->h_aliases[idx]) {
+      free(host->h_aliases[idx++]);
+    }
+    free(host->h_aliases);
+    host->h_aliases = nullptr;
+  }
+
+  free(host->h_name);
+  free(host);
+}
 
 void Initialize(Local<Object> target,
                 Local<Value> unused,
@@ -2205,32 +1915,17 @@ void Initialize(Local<Object> target,
   Local<FunctionTemplate> aiw =
       BaseObject::MakeLazilyInitializedJSTemplate(env);
   aiw->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  Local<String> addrInfoWrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "GetAddrInfoReqWrap");
-  aiw->SetClassName(addrInfoWrapString);
-  target->Set(env->context(),
-              addrInfoWrapString,
-              aiw->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "GetAddrInfoReqWrap", aiw);
 
   Local<FunctionTemplate> niw =
       BaseObject::MakeLazilyInitializedJSTemplate(env);
   niw->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  Local<String> nameInfoWrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "GetNameInfoReqWrap");
-  niw->SetClassName(nameInfoWrapString);
-  target->Set(env->context(),
-              nameInfoWrapString,
-              niw->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "GetNameInfoReqWrap", niw);
 
   Local<FunctionTemplate> qrw =
       BaseObject::MakeLazilyInitializedJSTemplate(env);
   qrw->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  Local<String> queryWrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "QueryReqWrap");
-  qrw->SetClassName(queryWrapString);
-  target->Set(env->context(),
-              queryWrapString,
-              qrw->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "QueryReqWrap", qrw);
 
   Local<FunctionTemplate> channel_wrap =
       env->NewFunctionTemplate(ChannelWrap::New);
@@ -2241,6 +1936,7 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(channel_wrap, "queryAny", Query<QueryAnyWrap>);
   env->SetProtoMethod(channel_wrap, "queryA", Query<QueryAWrap>);
   env->SetProtoMethod(channel_wrap, "queryAaaa", Query<QueryAaaaWrap>);
+  env->SetProtoMethod(channel_wrap, "queryCaa", Query<QueryCaaWrap>);
   env->SetProtoMethod(channel_wrap, "queryCname", Query<QueryCnameWrap>);
   env->SetProtoMethod(channel_wrap, "queryMx", Query<QueryMxWrap>);
   env->SetProtoMethod(channel_wrap, "queryNs", Query<QueryNsWrap>);
@@ -2253,16 +1949,12 @@ void Initialize(Local<Object> target,
 
   env->SetProtoMethodNoSideEffect(channel_wrap, "getServers", GetServers);
   env->SetProtoMethod(channel_wrap, "setServers", SetServers);
+  env->SetProtoMethod(channel_wrap, "setLocalAddress", SetLocalAddress);
   env->SetProtoMethod(channel_wrap, "cancel", Cancel);
 
-  Local<String> channelWrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap");
-  channel_wrap->SetClassName(channelWrapString);
-  target->Set(env->context(), channelWrapString,
-              channel_wrap->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "ChannelWrap", channel_wrap);
 }
 
-}  // anonymous namespace
 }  // namespace cares_wrap
 }  // namespace node
 
diff --git a/src/cares_wrap.h b/src/cares_wrap.h
new file mode 100644
index 0000000000000000000000000000000000000000..60f99e65edf3489aa1c564f09c9012803db53fbd
--- /dev/null
+++ b/src/cares_wrap.h
@@ -0,0 +1,523 @@
+#ifndef SRC_CARES_WRAP_H_
+#define SRC_CARES_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#define CARES_STATICLIB
+
+#include "async_wrap.h"
+#include "base_object.h"
+#include "env.h"
+#include "memory_tracker.h"
+#include "util.h"
+#include "node.h"
+
+#include "ares.h"
+#include "v8.h"
+#include "uv.h"
+
+#include <unordered_set>
+
+#ifdef __POSIX__
+# include <netdb.h>
+#endif  // __POSIX__
+
+# include <ares_nameser.h>
+
+namespace node {
+namespace cares_wrap {
+
+constexpr int ns_t_cname_or_a = -1;
+constexpr int DNS_ESETSRVPENDING = -1000;
+
+class ChannelWrap;
+
+inline void safe_free_hostent(struct hostent* host);
+
+using HostEntPointer = DeleteFnPtr<hostent, ares_free_hostent>;
+using SafeHostEntPointer = DeleteFnPtr<hostent, safe_free_hostent>;
+
+inline const char* ToErrorCodeString(int status) {
+  switch (status) {
+#define V(code) case ARES_##code: return #code;
+    V(EADDRGETNETWORKPARAMS)
+    V(EBADFAMILY)
+    V(EBADFLAGS)
+    V(EBADHINTS)
+    V(EBADNAME)
+    V(EBADQUERY)
+    V(EBADRESP)
+    V(EBADSTR)
+    V(ECANCELLED)
+    V(ECONNREFUSED)
+    V(EDESTRUCTION)
+    V(EFILE)
+    V(EFORMERR)
+    V(ELOADIPHLPAPI)
+    V(ENODATA)
+    V(ENOMEM)
+    V(ENONAME)
+    V(ENOTFOUND)
+    V(ENOTIMP)
+    V(ENOTINITIALIZED)
+    V(EOF)
+    V(EREFUSED)
+    V(ESERVFAIL)
+    V(ETIMEOUT)
+#undef V
+  }
+
+  return "UNKNOWN_ARES_ERROR";
+}
+
+inline void cares_wrap_hostent_cpy(
+    struct hostent* dest,
+    const struct hostent* src) {
+  dest->h_addr_list = nullptr;
+  dest->h_addrtype = 0;
+  dest->h_aliases = nullptr;
+  dest->h_length = 0;
+  dest->h_name = nullptr;
+
+  /* copy `h_name` */
+  size_t name_size = strlen(src->h_name) + 1;
+  dest->h_name = node::Malloc<char>(name_size);
+  memcpy(dest->h_name, src->h_name, name_size);
+
+  /* copy `h_aliases` */
+  size_t alias_count;
+  for (alias_count = 0;
+      src->h_aliases[alias_count] != nullptr;
+      alias_count++) {
+  }
+
+  dest->h_aliases = node::Malloc<char*>(alias_count + 1);
+  for (size_t i = 0; i < alias_count; i++) {
+    const size_t cur_alias_size = strlen(src->h_aliases[i]) + 1;
+    dest->h_aliases[i] = node::Malloc(cur_alias_size);
+    memcpy(dest->h_aliases[i], src->h_aliases[i], cur_alias_size);
+  }
+  dest->h_aliases[alias_count] = nullptr;
+
+  /* copy `h_addr_list` */
+  size_t list_count;
+  for (list_count = 0;
+      src->h_addr_list[list_count] != nullptr;
+      list_count++) {
+  }
+
+  dest->h_addr_list = node::Malloc<char*>(list_count + 1);
+  for (size_t i = 0; i < list_count; i++) {
+    dest->h_addr_list[i] = node::Malloc(src->h_length);
+    memcpy(dest->h_addr_list[i], src->h_addr_list[i], src->h_length);
+  }
+  dest->h_addr_list[list_count] = nullptr;
+
+  /* work after work */
+  dest->h_length = src->h_length;
+  dest->h_addrtype = src->h_addrtype;
+}
+
+
+struct NodeAresTask final : public MemoryRetainer {
+  ChannelWrap* channel;
+  ares_socket_t sock;
+  uv_poll_t poll_watcher;
+
+  inline void MemoryInfo(MemoryTracker* trakcer) const override;
+  SET_MEMORY_INFO_NAME(NodeAresTask)
+  SET_SELF_SIZE(NodeAresTask)
+
+  struct Hash {
+    inline size_t operator()(NodeAresTask* a) const {
+      return std::hash<ares_socket_t>()(a->sock);
+    }
+  };
+
+  struct Equal {
+    inline bool operator()(NodeAresTask* a, NodeAresTask* b) const {
+      return a->sock == b->sock;
+    }
+  };
+
+  static NodeAresTask* Create(ChannelWrap* channel, ares_socket_t sock);
+
+  using List = std::unordered_set<NodeAresTask*, Hash, Equal>;
+};
+
+class ChannelWrap final : public AsyncWrap {
+ public:
+  ChannelWrap(
+      Environment* env,
+      v8::Local<v8::Object> object,
+      int timeout,
+      int tries);
+  ~ChannelWrap() override;
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  void Setup();
+  void EnsureServers();
+  void StartTimer();
+  void CloseTimer();
+
+  void ModifyActivityQueryCount(int count);
+
+  inline uv_timer_t* timer_handle() { return timer_handle_; }
+  inline ares_channel cares_channel() { return channel_; }
+  inline void set_query_last_ok(bool ok) { query_last_ok_ = ok; }
+  inline void set_is_servers_default(bool is_default) {
+    is_servers_default_ = is_default;
+  }
+  inline int active_query_count() { return active_query_count_; }
+  inline NodeAresTask::List* task_list() { return &task_list_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(ChannelWrap)
+  SET_SELF_SIZE(ChannelWrap)
+
+  static void AresTimeout(uv_timer_t* handle);
+
+ private:
+  uv_timer_t* timer_handle_ = nullptr;
+  ares_channel channel_ = nullptr;
+  bool query_last_ok_ = true;
+  bool is_servers_default_ = true;
+  bool library_inited_ = false;
+  int timeout_;
+  int tries_;
+  int active_query_count_ = 0;
+  NodeAresTask::List task_list_;
+};
+
+class GetAddrInfoReqWrap final : public ReqWrap<uv_getaddrinfo_t> {
+ public:
+  GetAddrInfoReqWrap(Environment* env,
+                     v8::Local<v8::Object> req_wrap_obj,
+                     bool verbatim);
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(GetAddrInfoReqWrap)
+  SET_SELF_SIZE(GetAddrInfoReqWrap)
+
+  bool verbatim() const { return verbatim_; }
+
+ private:
+  const bool verbatim_;
+};
+
+class GetNameInfoReqWrap final : public ReqWrap<uv_getnameinfo_t> {
+ public:
+  GetNameInfoReqWrap(Environment* env, v8::Local<v8::Object> req_wrap_obj);
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(GetNameInfoReqWrap)
+  SET_SELF_SIZE(GetNameInfoReqWrap)
+};
+
+struct ResponseData final {
+  int status;
+  bool is_host;
+  SafeHostEntPointer host;
+  MallocedBuffer<unsigned char> buf;
+};
+
+template <typename Traits>
+class QueryWrap final : public AsyncWrap {
+ public:
+  QueryWrap(ChannelWrap* channel, v8::Local<v8::Object> req_wrap_obj)
+      : AsyncWrap(channel->env(), req_wrap_obj, AsyncWrap::PROVIDER_QUERYWRAP),
+        channel_(channel),
+        trace_name_(Traits::name) {}
+
+  ~QueryWrap() {
+    CHECK_EQ(false, persistent().IsEmpty());
+
+    // Let Callback() know that this object no longer exists.
+    if (callback_ptr_ != nullptr)
+      *callback_ptr_ = nullptr;
+  }
+
+  int Send(const char* name) {
+    return Traits::Send(this, name);
+  }
+
+  void AresQuery(const char* name, int dnsclass, int type) {
+    channel_->EnsureServers();
+    TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(
+      TRACING_CATEGORY_NODE2(dns, native), trace_name_, this,
+      "name", TRACE_STR_COPY(name));
+    ares_query(
+        channel_->cares_channel(),
+        name,
+        dnsclass,
+        type,
+        Callback,
+        MakeCallbackPointer());
+  }
+
+  void ParseError(int status) {
+    CHECK_NE(status, ARES_SUCCESS);
+    v8::HandleScope handle_scope(env()->isolate());
+    v8::Context::Scope context_scope(env()->context());
+    const char* code = ToErrorCodeString(status);
+    v8::Local<v8::Value> arg = OneByteString(env()->isolate(), code);
+    TRACE_EVENT_NESTABLE_ASYNC_END1(
+        TRACING_CATEGORY_NODE2(dns, native), trace_name_, this,
+        "error", status);
+    MakeCallback(env()->oncomplete_string(), 1, &arg);
+  }
+
+  const BaseObjectPtr<ChannelWrap>& channel() const { return channel_; }
+
+  void AfterResponse() {
+    CHECK(response_data_);
+
+    int status = response_data_->status;
+
+    if (status != ARES_SUCCESS)
+      return ParseError(status);
+
+    status = Traits::Parse(this, response_data_);
+
+    if (status != ARES_SUCCESS)
+      ParseError(status);
+  }
+
+  void* MakeCallbackPointer() {
+    CHECK_NULL(callback_ptr_);
+    callback_ptr_ = new QueryWrap<Traits>*(this);
+    return callback_ptr_;
+  }
+
+  static QueryWrap<Traits>* FromCallbackPointer(void* arg) {
+    std::unique_ptr<QueryWrap<Traits>*> wrap_ptr {
+        static_cast<QueryWrap<Traits>**>(arg)
+    };
+    QueryWrap<Traits>* wrap = *wrap_ptr.get();
+    if (wrap == nullptr) return nullptr;
+    wrap->callback_ptr_ = nullptr;
+    return wrap;
+  }
+
+  static void Callback(
+      void* arg,
+      int status,
+      int timeouts,
+      unsigned char* answer_buf,
+      int answer_len) {
+    QueryWrap<Traits>* wrap = FromCallbackPointer(arg);
+    if (wrap == nullptr) return;
+
+    unsigned char* buf_copy = nullptr;
+    if (status == ARES_SUCCESS) {
+      buf_copy = node::Malloc<unsigned char>(answer_len);
+      memcpy(buf_copy, answer_buf, answer_len);
+    }
+
+    wrap->response_data_ = std::make_unique<ResponseData>();
+    ResponseData* data = wrap->response_data_.get();
+    data->status = status;
+    data->is_host = false;
+    data->buf = MallocedBuffer<unsigned char>(buf_copy, answer_len);
+
+    wrap->QueueResponseCallback(status);
+  }
+
+  static void Callback(
+      void* arg,
+      int status,
+      int timeouts,
+      struct hostent* host) {
+    QueryWrap<Traits>* wrap = FromCallbackPointer(arg);
+    if (wrap == nullptr) return;
+
+    struct hostent* host_copy = nullptr;
+    if (status == ARES_SUCCESS) {
+      host_copy = node::Malloc<hostent>(1);
+      cares_wrap_hostent_cpy(host_copy, host);
+    }
+
+    wrap->response_data_ = std::make_unique<ResponseData>();
+    ResponseData* data = wrap->response_data_.get();
+    data->status = status;
+    data->host.reset(host_copy);
+    data->is_host = true;
+
+    wrap->QueueResponseCallback(status);
+  }
+
+  void QueueResponseCallback(int status) {
+    BaseObjectPtr<QueryWrap<Traits>> strong_ref{this};
+    env()->SetImmediate([this, strong_ref](Environment*) {
+      AfterResponse();
+
+      // Delete once strong_ref goes out of scope.
+      Detach();
+    });
+
+    channel_->set_query_last_ok(status != ARES_ECONNREFUSED);
+    channel_->ModifyActivityQueryCount(-1);
+  }
+
+  void CallOnComplete(
+      v8::Local<v8::Value> answer,
+      v8::Local<v8::Value> extra = v8::Local<v8::Value>()) {
+    v8::HandleScope handle_scope(env()->isolate());
+    v8::Context::Scope context_scope(env()->context());
+    v8::Local<v8::Value> argv[] = {
+      v8::Integer::New(env()->isolate(), 0),
+      answer,
+      extra
+    };
+    const int argc = arraysize(argv) - extra.IsEmpty();
+    TRACE_EVENT_NESTABLE_ASYNC_END0(
+        TRACING_CATEGORY_NODE2(dns, native), trace_name_, this);
+
+    MakeCallback(env()->oncomplete_string(), argc, argv);
+  }
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackField("channel", channel_);
+    if (response_data_) {
+      tracker->TrackFieldWithSize("response", response_data_->buf.size);
+    }
+  }
+
+  SET_MEMORY_INFO_NAME(QueryWrap)
+  SET_SELF_SIZE(QueryWrap<Traits>)
+
+ private:
+  BaseObjectPtr<ChannelWrap> channel_;
+
+  std::unique_ptr<ResponseData> response_data_;
+  const char* trace_name_;
+  // Pointer to pointer to 'this' that can be reset from the destructor,
+  // in order to let Callback() know that 'this' no longer exists.
+  QueryWrap<Traits>** callback_ptr_ = nullptr;
+};
+
+struct AnyTraits final {
+  static constexpr const char* name = "resolveAny";
+  static int Send(QueryWrap<AnyTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<AnyTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct ATraits final {
+  static constexpr const char* name = "resolve4";
+  static int Send(QueryWrap<ATraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<ATraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct AaaaTraits final {
+  static constexpr const char* name = "resolve6";
+  static int Send(QueryWrap<AaaaTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<AaaaTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct CaaTraits final {
+  static constexpr const char* name = "resolveCaa";
+  static int Send(QueryWrap<CaaTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<CaaTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct CnameTraits final {
+  static constexpr const char* name = "resolveCname";
+  static int Send(QueryWrap<CnameTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<CnameTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct MxTraits final {
+  static constexpr const char* name = "resolveMx";
+  static int Send(QueryWrap<MxTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<MxTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct NsTraits final {
+  static constexpr const char* name = "resolveNs";
+  static int Send(QueryWrap<NsTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<NsTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct TxtTraits final {
+  static constexpr const char* name = "resolveTxt";
+  static int Send(QueryWrap<TxtTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<TxtTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct SrvTraits final {
+  static constexpr const char* name = "resolveSrv";
+  static int Send(QueryWrap<SrvTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<SrvTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct PtrTraits final {
+  static constexpr const char* name = "resolvePtr";
+  static int Send(QueryWrap<PtrTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<PtrTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct NaptrTraits final {
+  static constexpr const char* name = "resolveNaptr";
+  static int Send(QueryWrap<NaptrTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<NaptrTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct SoaTraits final {
+  static constexpr const char* name = "resolveSoa";
+  static int Send(QueryWrap<SoaTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<SoaTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+struct ReverseTraits final {
+  static constexpr const char* name = "reverse";
+  static int Send(QueryWrap<ReverseTraits>* wrap, const char* name);
+  static int Parse(
+      QueryWrap<ReverseTraits>* wrap,
+      const std::unique_ptr<ResponseData>& response);
+};
+
+using QueryAnyWrap = QueryWrap<AnyTraits>;
+using QueryAWrap = QueryWrap<ATraits>;
+using QueryAaaaWrap = QueryWrap<AaaaTraits>;
+using QueryCaaWrap = QueryWrap<CaaTraits>;
+using QueryCnameWrap = QueryWrap<CnameTraits>;
+using QueryMxWrap = QueryWrap<MxTraits>;
+using QueryNsWrap = QueryWrap<NsTraits>;
+using QueryTxtWrap = QueryWrap<TxtTraits>;
+using QuerySrvWrap = QueryWrap<SrvTraits>;
+using QueryPtrWrap = QueryWrap<PtrTraits>;
+using QueryNaptrWrap = QueryWrap<NaptrTraits>;
+using QuerySoaWrap = QueryWrap<SoaTraits>;
+using GetHostByAddrWrap = QueryWrap<ReverseTraits>;
+
+}  // namespace cares_wrap
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CARES_WRAP_H_
diff --git a/src/debug_utils.cc b/src/debug_utils.cc
index a601c5ecf40ea90ecbdcac4338a2621b4091a7cd..c4c476942eee77a2136740fa02dbb16f1f4c31be 100644
--- a/src/debug_utils.cc
+++ b/src/debug_utils.cc
@@ -355,7 +355,7 @@ void PrintLibuvHandleInformation(uv_loop_t* loop, FILE* stream) {
     void* first_field = nullptr;
     // `handle->data` might be any value, including `nullptr`, or something
     // cast from a completely different type; therefore, check that it’s
-    // dereferencable first.
+    // dereferenceable first.
     if (sym_ctx->IsMapped(handle->data))
       first_field = *reinterpret_cast<void**>(handle->data);
 
@@ -377,7 +377,7 @@ std::vector<std::string> NativeSymbolDebuggingContext::GetLoadedLibraries() {
       [](struct dl_phdr_info* info, size_t size, void* data) {
         auto list = static_cast<std::vector<std::string>*>(data);
         if (*info->dlpi_name != '\0') {
-          list->push_back(info->dlpi_name);
+          list->emplace_back(info->dlpi_name);
         }
         return 0;
       },
@@ -386,7 +386,7 @@ std::vector<std::string> NativeSymbolDebuggingContext::GetLoadedLibraries() {
   uint32_t i = 0;
   for (const char* name = _dyld_get_image_name(i); name != nullptr;
        name = _dyld_get_image_name(++i)) {
-    list.push_back(name);
+    list.emplace_back(name);
   }
 
 #elif _AIX
@@ -411,10 +411,10 @@ std::vector<std::string> NativeSymbolDebuggingContext::GetLoadedLibraries() {
           strlen(cur_info->ldinfo_filename) + 1;
       if (*member_name != '\0') {
         str << cur_info->ldinfo_filename << "(" << member_name << ")";
-        list.push_back(str.str());
+        list.emplace_back(str.str());
         str.str("");
       } else {
-        list.push_back(cur_info->ldinfo_filename);
+        list.emplace_back(cur_info->ldinfo_filename);
       }
       buf += cur_info->ldinfo_next;
     } while (cur_info->ldinfo_next != 0);
@@ -424,7 +424,7 @@ std::vector<std::string> NativeSymbolDebuggingContext::GetLoadedLibraries() {
 
   if (dlinfo(RTLD_SELF, RTLD_DI_LINKMAP, &p) != -1) {
     for (Link_map* l = p; l != nullptr; l = l->l_next) {
-      list.push_back(l->l_name);
+      list.emplace_back(l->l_name);
     }
   }
 
@@ -459,7 +459,7 @@ std::vector<std::string> NativeSymbolDebuggingContext::GetLoadedLibraries() {
           char* str = new char[size];
           WideCharToMultiByte(
               CP_UTF8, 0, module_name, -1, str, size, nullptr, nullptr);
-          list.push_back(str);
+          list.emplace_back(str);
         }
       }
     }
diff --git a/src/debug_utils.h b/src/debug_utils.h
index ecc53b0c2b0aa03bffe167184b8ed4f3205ba0f5..cec5eb6daf1217c7e062cabe7b75651a2ca489ab 100644
--- a/src/debug_utils.h
+++ b/src/debug_utils.h
@@ -41,6 +41,7 @@ void FWrite(FILE* file, const std::string& str);
 // from a provider type to a debug category.
 #define DEBUG_CATEGORY_NAMES(V)                                                \
   NODE_ASYNC_PROVIDER_TYPES(V)                                                 \
+  V(DIAGNOSTICS)                                                               \
   V(HUGEPAGES)                                                                 \
   V(INSPECTOR_SERVER)                                                          \
   V(INSPECTOR_PROFILER)                                                        \
diff --git a/src/env-inl.h b/src/env-inl.h
index 216dead9aa972a6e37804c8ca823bdcc13363234..533a8284e9a187e9176ca63e6df42be1aa067ae4 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -49,14 +49,6 @@ inline uv_loop_t* IsolateData::event_loop() const {
   return event_loop_;
 }
 
-inline bool IsolateData::uses_node_allocator() const {
-  return uses_node_allocator_;
-}
-
-inline v8::ArrayBuffer::Allocator* IsolateData::allocator() const {
-  return allocator_;
-}
-
 inline NodeArrayBufferAllocator* IsolateData::node_allocator() const {
   return node_allocator_;
 }
@@ -65,10 +57,6 @@ inline MultiIsolatePlatform* IsolateData::platform() const {
   return platform_;
 }
 
-inline v8::Local<v8::String> IsolateData::async_wrap_provider(int index) const {
-  return async_wrap_providers_[index].Get(isolate_);
-}
-
 inline void IsolateData::set_worker_context(worker::Worker* context) {
   CHECK_NULL(worker_context_);  // Should be set only once.
   worker_context_ = context;
@@ -78,6 +66,10 @@ inline worker::Worker* IsolateData::worker_context() const {
   return worker_context_;
 }
 
+inline v8::Local<v8::String> IsolateData::async_wrap_provider(int index) const {
+  return async_wrap_providers_[index].Get(isolate_);
+}
+
 inline AsyncHooks::AsyncHooks()
     : async_ids_stack_(env()->isolate(), 16 * 2),
       fields_(env()->isolate(), kFieldsCount),
@@ -126,6 +118,25 @@ v8::Local<v8::Object> AsyncHooks::native_execution_async_resource(size_t i) {
   return PersistentToLocal::Strong(native_execution_async_resources_[i]);
 }
 
+inline void AsyncHooks::SetJSPromiseHooks(v8::Local<v8::Function> init,
+                                          v8::Local<v8::Function> before,
+                                          v8::Local<v8::Function> after,
+                                          v8::Local<v8::Function> resolve) {
+  js_promise_hooks_[0].Reset(env()->isolate(), init);
+  js_promise_hooks_[1].Reset(env()->isolate(), before);
+  js_promise_hooks_[2].Reset(env()->isolate(), after);
+  js_promise_hooks_[3].Reset(env()->isolate(), resolve);
+  for (auto it = contexts_.begin(); it != contexts_.end(); it++) {
+    if (it->IsEmpty()) {
+      it = contexts_.erase(it);
+      it--;
+      continue;
+    }
+    PersistentToLocal::Weak(env()->isolate(), *it)
+        ->SetPromiseHooks(init, before, after, resolve);
+  }
+}
+
 inline v8::Local<v8::String> AsyncHooks::provider_string(int idx) {
   return env()->isolate_data()->async_wrap_provider(idx);
 }
@@ -248,6 +259,46 @@ void AsyncHooks::clear_async_id_stack() {
   fields_[kStackLength] = 0;
 }
 
+inline void AsyncHooks::AddContext(v8::Local<v8::Context> ctx) {
+  ctx->SetPromiseHooks(
+    js_promise_hooks_[0].IsEmpty() ?
+      v8::Local<v8::Function>() :
+      PersistentToLocal::Strong(js_promise_hooks_[0]),
+    js_promise_hooks_[1].IsEmpty() ?
+      v8::Local<v8::Function>() :
+      PersistentToLocal::Strong(js_promise_hooks_[1]),
+    js_promise_hooks_[2].IsEmpty() ?
+      v8::Local<v8::Function>() :
+      PersistentToLocal::Strong(js_promise_hooks_[2]),
+    js_promise_hooks_[3].IsEmpty() ?
+      v8::Local<v8::Function>() :
+      PersistentToLocal::Strong(js_promise_hooks_[3]));
+
+  size_t id = contexts_.size();
+  contexts_.resize(id + 1);
+  contexts_[id].Reset(env()->isolate(), ctx);
+  contexts_[id].SetWeak();
+}
+
+inline void AsyncHooks::RemoveContext(v8::Local<v8::Context> ctx) {
+  v8::Isolate* isolate = env()->isolate();
+  v8::HandleScope handle_scope(isolate);
+  for (auto it = contexts_.begin(); it != contexts_.end(); it++) {
+    if (it->IsEmpty()) {
+      it = contexts_.erase(it);
+      it--;
+      continue;
+    }
+    v8::Local<v8::Context> saved_context =
+      PersistentToLocal::Weak(isolate, *it);
+    if (saved_context == ctx) {
+      it->Reset();
+      contexts_.erase(it);
+      break;
+    }
+  }
+}
+
 // The DefaultTriggerAsyncIdScope(AsyncWrap*) constructor is defined in
 // async_wrap-inl.h to avoid a circular dependency.
 
@@ -334,9 +385,15 @@ inline void Environment::AssignToContext(v8::Local<v8::Context> context,
   // Used by Environment::GetCurrent to know that we are on a node context.
   context->SetAlignedPointerInEmbedderData(
     ContextEmbedderIndex::kContextTag, Environment::kNodeContextTagPtr);
+  // Used to retrieve bindings
+  context->SetAlignedPointerInEmbedderData(
+      ContextEmbedderIndex::kBindingListIndex, &(this->bindings_));
+
 #if HAVE_INSPECTOR
   inspector_agent()->ContextCreated(context, info);
 #endif  // HAVE_INSPECTOR
+
+  this->async_hooks()->AddContext(context);
 }
 
 inline Environment* Environment::GetCurrent(v8::Isolate* isolate) {
@@ -365,31 +422,59 @@ inline Environment* Environment::GetCurrent(v8::Local<v8::Context> context) {
 
 inline Environment* Environment::GetCurrent(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  return GetFromCallbackData(info.Data());
+  return GetCurrent(info.GetIsolate()->GetCurrentContext());
 }
 
 template <typename T>
 inline Environment* Environment::GetCurrent(
     const v8::PropertyCallbackInfo<T>& info) {
-  return GetFromCallbackData(info.Data());
+  return GetCurrent(info.GetIsolate()->GetCurrentContext());
 }
 
-inline Environment* Environment::GetFromCallbackData(v8::Local<v8::Value> val) {
-  DCHECK(val->IsObject());
-  v8::Local<v8::Object> obj = val.As<v8::Object>();
-  DCHECK_GE(obj->InternalFieldCount(), 1);
-  Environment* env =
-      static_cast<Environment*>(obj->GetAlignedPointerFromInternalField(0));
-  DCHECK(env->as_callback_data_template()->HasInstance(obj));
-  return env;
+template <typename T, typename U>
+inline T* Environment::GetBindingData(const v8::PropertyCallbackInfo<U>& info) {
+  return GetBindingData<T>(info.GetIsolate()->GetCurrentContext());
 }
 
-inline Environment* Environment::GetThreadLocalEnv() {
-  return static_cast<Environment*>(uv_key_get(&thread_local_env));
+template <typename T>
+inline T* Environment::GetBindingData(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  return GetBindingData<T>(info.GetIsolate()->GetCurrentContext());
+}
+
+template <typename T>
+inline T* Environment::GetBindingData(v8::Local<v8::Context> context) {
+  BindingDataStore* map = static_cast<BindingDataStore*>(
+      context->GetAlignedPointerFromEmbedderData(
+          ContextEmbedderIndex::kBindingListIndex));
+  DCHECK_NOT_NULL(map);
+  auto it = map->find(T::type_name);
+  if (UNLIKELY(it == map->end())) return nullptr;
+  T* result = static_cast<T*>(it->second.get());
+  DCHECK_NOT_NULL(result);
+  DCHECK_EQ(result->env(), GetCurrent(context));
+  return result;
 }
 
-inline bool Environment::profiler_idle_notifier_started() const {
-  return profiler_idle_notifier_started_;
+template <typename T>
+inline T* Environment::AddBindingData(
+    v8::Local<v8::Context> context,
+    v8::Local<v8::Object> target) {
+  DCHECK_EQ(GetCurrent(context), this);
+  // This won't compile if T is not a BaseObject subclass.
+  BaseObjectPtr<T> item = MakeDetachedBaseObject<T>(this, target);
+  BindingDataStore* map = static_cast<BindingDataStore*>(
+      context->GetAlignedPointerFromEmbedderData(
+          ContextEmbedderIndex::kBindingListIndex));
+  DCHECK_NOT_NULL(map);
+  auto result = map->emplace(T::type_name, item);
+  CHECK(result.second);
+  DCHECK_EQ(GetBindingData<T>(context), item.get());
+  return item.get();
+}
+
+inline Environment* Environment::GetThreadLocalEnv() {
+  return static_cast<Environment*>(uv_key_get(&thread_local_env));
 }
 
 inline v8::Isolate* Environment::isolate() const {
@@ -603,76 +688,6 @@ inline double Environment::get_default_trigger_async_id() {
   return default_trigger_async_id;
 }
 
-inline double* Environment::heap_statistics_buffer() const {
-  CHECK_NOT_NULL(heap_statistics_buffer_);
-  return heap_statistics_buffer_;
-}
-
-inline void Environment::set_heap_statistics_buffer(double* pointer) {
-  CHECK_NULL(heap_statistics_buffer_);  // Should be set only once.
-  heap_statistics_buffer_ = pointer;
-}
-
-inline double* Environment::heap_space_statistics_buffer() const {
-  CHECK_NOT_NULL(heap_space_statistics_buffer_);
-  return heap_space_statistics_buffer_;
-}
-
-inline void Environment::set_heap_space_statistics_buffer(double* pointer) {
-  CHECK_NULL(heap_space_statistics_buffer_);  // Should be set only once.
-  heap_space_statistics_buffer_ = pointer;
-}
-
-inline double* Environment::heap_code_statistics_buffer() const {
-  CHECK_NOT_NULL(heap_code_statistics_buffer_);
-  return heap_code_statistics_buffer_;
-}
-
-inline void Environment::set_heap_code_statistics_buffer(double* pointer) {
-  CHECK_NULL(heap_code_statistics_buffer_);  // Should be set only once.
-  heap_code_statistics_buffer_ = pointer;
-}
-
-inline char* Environment::http_parser_buffer() const {
-  return http_parser_buffer_;
-}
-
-inline void Environment::set_http_parser_buffer(char* buffer) {
-  CHECK_NULL(http_parser_buffer_);  // Should be set only once.
-  http_parser_buffer_ = buffer;
-}
-
-inline bool Environment::http_parser_buffer_in_use() const {
-  return http_parser_buffer_in_use_;
-}
-
-inline void Environment::set_http_parser_buffer_in_use(bool in_use) {
-  http_parser_buffer_in_use_ = in_use;
-}
-
-inline http2::Http2State* Environment::http2_state() const {
-  return http2_state_.get();
-}
-
-inline void Environment::set_http2_state(
-    std::unique_ptr<http2::Http2State> buffer) {
-  CHECK(!http2_state_);  // Should be set only once.
-  http2_state_ = std::move(buffer);
-}
-
-inline AliasedFloat64Array* Environment::fs_stats_field_array() {
-  return &fs_stats_field_array_;
-}
-
-inline AliasedBigUint64Array* Environment::fs_stats_field_bigint_array() {
-  return &fs_stats_field_bigint_array_;
-}
-
-inline std::vector<std::unique_ptr<fs::FileHandleReadWrap>>&
-Environment::file_handle_read_wrap_freelist() {
-  return file_handle_read_wrap_freelist_;
-}
-
 inline std::shared_ptr<EnvironmentOptions> Environment::options() {
   return options_;
 }
@@ -689,6 +704,22 @@ inline const std::string& Environment::exec_path() const {
   return exec_path_;
 }
 
+inline std::string Environment::GetCwd() {
+  char cwd[PATH_MAX_BYTES];
+  size_t size = PATH_MAX_BYTES;
+  const int err = uv_cwd(cwd, &size);
+
+  if (err == 0) {
+    CHECK_GT(size, 0);
+    return cwd;
+  }
+
+  // This can fail if the cwd is deleted. In that case, fall back to
+  // exec_path.
+  const std::string& exec_path = exec_path_;
+  return exec_path.substr(0, exec_path.find_last_of(kPathSeparator));
+}
+
 #if HAVE_INSPECTOR
 inline void Environment::set_coverage_directory(const char* dir) {
   coverage_directory_ = std::string(dir);
@@ -875,6 +906,26 @@ inline bool Environment::tracks_unmanaged_fds() const {
   return flags_ & EnvironmentFlags::kTrackUnmanagedFds;
 }
 
+inline bool Environment::hide_console_windows() const {
+  return flags_ & EnvironmentFlags::kHideConsoleWindows;
+}
+
+bool Environment::filehandle_close_warning() const {
+  return emit_filehandle_warning_;
+}
+
+void Environment::set_filehandle_close_warning(bool on) {
+  emit_filehandle_warning_ = on;
+}
+
+void Environment::set_source_maps_enabled(bool on) {
+  source_maps_enabled_ = on;
+}
+
+bool Environment::source_maps_enabled() const {
+  return source_maps_enabled_;
+}
+
 inline uint64_t Environment::thread_id() const {
   return thread_id_;
 }
@@ -922,6 +973,11 @@ inline node_module* Environment::extra_linked_bindings_head() {
       &extra_linked_bindings_.front() : nullptr;
 }
 
+inline node_module* Environment::extra_linked_bindings_tail() {
+  return extra_linked_bindings_.size() > 0 ?
+      &extra_linked_bindings_.back() : nullptr;
+}
+
 inline const Mutex& Environment::extra_linked_bindings_mutex() const {
   return extra_linked_bindings_mutex_;
 }
@@ -939,107 +995,9 @@ inline IsolateData* Environment::isolate_data() const {
   return isolate_data_;
 }
 
-inline char* Environment::AllocateUnchecked(size_t size) {
-  return static_cast<char*>(
-      isolate_data()->allocator()->AllocateUninitialized(size));
-}
-
-inline char* Environment::Allocate(size_t size) {
-  char* ret = AllocateUnchecked(size);
-  CHECK_NE(ret, nullptr);
-  return ret;
-}
-
-inline void Environment::Free(char* data, size_t size) {
-  if (data != nullptr)
-    isolate_data()->allocator()->Free(data, size);
-}
-
-inline AllocatedBuffer Environment::AllocateManaged(size_t size, bool checked) {
-  char* data = checked ? Allocate(size) : AllocateUnchecked(size);
-  if (data == nullptr) size = 0;
-  return AllocatedBuffer(this, uv_buf_init(data, size));
-}
-
-inline AllocatedBuffer::AllocatedBuffer(Environment* env, uv_buf_t buf)
-    : env_(env), buffer_(buf) {}
-
-inline void AllocatedBuffer::Resize(size_t len) {
-  // The `len` check is to make sure we don't end up with `nullptr` as our base.
-  char* new_data = env_->Reallocate(buffer_.base, buffer_.len,
-                                    len > 0 ? len : 1);
-  CHECK_NOT_NULL(new_data);
-  buffer_ = uv_buf_init(new_data, len);
-}
-
-inline uv_buf_t AllocatedBuffer::release() {
-  uv_buf_t ret = buffer_;
-  buffer_ = uv_buf_init(nullptr, 0);
-  return ret;
-}
-
-inline char* AllocatedBuffer::data() {
-  return buffer_.base;
-}
-
-inline const char* AllocatedBuffer::data() const {
-  return buffer_.base;
-}
-
-inline size_t AllocatedBuffer::size() const {
-  return buffer_.len;
-}
-
-inline AllocatedBuffer::AllocatedBuffer(Environment* env)
-    : env_(env), buffer_(uv_buf_init(nullptr, 0)) {}
-
-inline AllocatedBuffer::AllocatedBuffer(AllocatedBuffer&& other)
-    : AllocatedBuffer() {
-  *this = std::move(other);
-}
-
-inline AllocatedBuffer& AllocatedBuffer::operator=(AllocatedBuffer&& other) {
-  clear();
-  env_ = other.env_;
-  buffer_ = other.release();
-  return *this;
-}
-
-inline AllocatedBuffer::~AllocatedBuffer() {
-  clear();
-}
-
-inline void AllocatedBuffer::clear() {
-  uv_buf_t buf = release();
-  if (buf.base != nullptr) {
-    CHECK_NOT_NULL(env_);
-    env_->Free(buf.base, buf.len);
-  }
-}
-
-// It's a bit awkward to define this Buffer::New() overload here, but it
-// avoids a circular dependency with node_internals.h.
-namespace Buffer {
-v8::MaybeLocal<v8::Object> New(Environment* env,
-                               char* data,
-                               size_t length,
-                               bool uses_malloc);
-}
-
-inline v8::MaybeLocal<v8::Object> AllocatedBuffer::ToBuffer() {
-  CHECK_NOT_NULL(env_);
-  v8::MaybeLocal<v8::Object> obj = Buffer::New(env_, data(), size(), false);
-  if (!obj.IsEmpty()) release();
-  return obj;
-}
-
-inline v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() {
-  CHECK_NOT_NULL(env_);
-  uv_buf_t buf = release();
-  return v8::ArrayBuffer::New(env_->isolate(),
-                              buf.base,
-                              buf.len,
-                              v8::ArrayBufferCreationMode::kInternalized);
+std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>*
+    Environment::released_allocated_buffers() {
+  return &released_allocated_buffers_;
 }
 
 inline void Environment::ThrowError(const char* errmsg) {
@@ -1083,8 +1041,7 @@ inline v8::Local<v8::FunctionTemplate>
                                      v8::Local<v8::Signature> signature,
                                      v8::ConstructorBehavior behavior,
                                      v8::SideEffectType side_effect_type) {
-  v8::Local<v8::Object> external = as_callback_data();
-  return v8::FunctionTemplate::New(isolate(), callback, external,
+  return v8::FunctionTemplate::New(isolate(), callback, v8::Local<v8::Value>(),
                                    signature, 0, behavior, side_effect_type);
 }
 
@@ -1170,7 +1127,28 @@ inline void Environment::SetInstanceMethod(v8::Local<v8::FunctionTemplate> that,
   t->SetClassName(name_string);
 }
 
-void Environment::AddCleanupHook(void (*fn)(void*), void* arg) {
+inline void Environment::SetConstructorFunction(
+    v8::Local<v8::Object> that,
+    const char* name,
+    v8::Local<v8::FunctionTemplate> tmpl,
+    SetConstructorFunctionFlag flag) {
+  SetConstructorFunction(that, OneByteString(isolate(), name), tmpl, flag);
+}
+
+inline void Environment::SetConstructorFunction(
+    v8::Local<v8::Object> that,
+    v8::Local<v8::String> name,
+    v8::Local<v8::FunctionTemplate> tmpl,
+    SetConstructorFunctionFlag flag) {
+  if (LIKELY(flag == SetConstructorFunctionFlag::SET_CLASS_NAME))
+    tmpl->SetClassName(name);
+  that->Set(
+      context(),
+      name,
+      tmpl->GetFunction(context()).ToLocalChecked()).Check();
+}
+
+void Environment::AddCleanupHook(CleanupCallback fn, void* arg) {
   auto insertion_info = cleanup_hooks_.emplace(CleanupHookCallback {
     fn, arg, cleanup_hook_counter_++
   });
@@ -1178,18 +1156,11 @@ void Environment::AddCleanupHook(void (*fn)(void*), void* arg) {
   CHECK_EQ(insertion_info.second, true);
 }
 
-void Environment::RemoveCleanupHook(void (*fn)(void*), void* arg) {
+void Environment::RemoveCleanupHook(CleanupCallback fn, void* arg) {
   CleanupHookCallback search { fn, arg, 0 };
   cleanup_hooks_.erase(search);
 }
 
-inline void Environment::RegisterFinalizationGroupForCleanup(
-    v8::Local<v8::FinalizationGroup> group) {
-  cleanup_finalization_groups_.emplace_back(isolate(), group);
-  DCHECK(task_queues_async_initialized_);
-  uv_async_send(&task_queues_async_);
-}
-
 size_t CleanupHookCallback::Hash::operator()(
     const CleanupHookCallback& cb) const {
   return std::hash<void*>()(cb.arg_);
@@ -1221,7 +1192,7 @@ void Environment::modify_base_object_count(int64_t delta) {
 }
 
 int64_t Environment::base_object_count() const {
-  return base_object_count_;
+  return base_object_count_ - initial_base_object_count_;
 }
 
 void Environment::set_main_utf16(std::unique_ptr<v8::String::Value> str) {
@@ -1276,11 +1247,16 @@ void Environment::set_process_exit_handler(
   ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)
 #undef V
 
-  inline v8::Local<v8::Context> Environment::context() const {
-    return PersistentToLocal::Strong(context_);
-  }
+v8::Local<v8::Context> Environment::context() const {
+  return PersistentToLocal::Strong(context_);
+}
+
 }  // namespace node
 
+// These two files depend on each other. Including base_object-inl.h after this
+// file is the easiest way to avoid issues with that circular dependency.
+#include "base_object-inl.h"
+
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #endif  // SRC_ENV_INL_H_
diff --git a/src/env.cc b/src/env.cc
index 295b68741dc5c6cb5ef15186c91707b05ea134b9..870aab0d8b80ee7bf68c4c7861e1589166b00d44 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -1,18 +1,20 @@
 #include "env.h"
-
+#include "allocated_buffer-inl.h"
 #include "async_wrap.h"
+#include "base_object-inl.h"
 #include "debug_utils-inl.h"
+#include "diagnosticfilename-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"
 #include "node_context_data.h"
 #include "node_errors.h"
-#include "node_file.h"
 #include "node_internals.h"
 #include "node_options-inl.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "node_v8_platform-inl.h"
 #include "node_worker.h"
 #include "req_wrap-inl.h"
+#include "stream_base.h"
 #include "tracing/agent.h"
 #include "tracing/traced_value.h"
 #include "util-inl.h"
@@ -21,6 +23,7 @@
 #include <algorithm>
 #include <atomic>
 #include <cstdio>
+#include <limits>
 #include <memory>
 
 namespace node {
@@ -29,7 +32,6 @@ using errors::TryCatchScope;
 using v8::Boolean;
 using v8::Context;
 using v8::EmbedderGraph;
-using v8::FinalizationGroup;
 using v8::Function;
 using v8::FunctionTemplate;
 using v8::HandleScope;
@@ -92,12 +94,13 @@ void IsolateData::DeserializeProperties(const std::vector<size_t>* indexes) {
 #define VS(PropertyName, StringValue) V(String, PropertyName)
 #define V(TypeName, PropertyName)                                              \
   do {                                                                         \
-    MaybeLocal<TypeName> field =                                               \
+    MaybeLocal<TypeName> maybe_field =                                         \
         isolate_->GetDataFromSnapshotOnce<TypeName>((*indexes)[i++]);          \
-    if (field.IsEmpty()) {                                                     \
+    Local<TypeName> field;                                                     \
+    if (!maybe_field.ToLocal(&field)) {                                        \
       fprintf(stderr, "Failed to deserialize " #PropertyName "\n");            \
     }                                                                          \
-    PropertyName##_.Set(isolate_, field.ToLocalChecked());                     \
+    PropertyName##_.Set(isolate_, field);                                      \
   } while (0);
   PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
   PER_ISOLATE_SYMBOL_PROPERTIES(VY)
@@ -108,12 +111,13 @@ void IsolateData::DeserializeProperties(const std::vector<size_t>* indexes) {
 #undef VP
 
   for (size_t j = 0; j < AsyncWrap::PROVIDERS_LENGTH; j++) {
-    MaybeLocal<String> field =
+    MaybeLocal<String> maybe_field =
         isolate_->GetDataFromSnapshotOnce<String>((*indexes)[i++]);
-    if (field.IsEmpty()) {
+    Local<String> field;
+    if (!maybe_field.ToLocal(&field)) {
       fprintf(stderr, "Failed to deserialize AsyncWrap provider %zu\n", j);
     }
-    async_wrap_providers_[j].Set(isolate_, field.ToLocalChecked());
+    async_wrap_providers_[j].Set(isolate_, field);
   }
 }
 
@@ -188,13 +192,9 @@ IsolateData::IsolateData(Isolate* isolate,
                          const std::vector<size_t>* indexes)
     : isolate_(isolate),
       event_loop_(event_loop),
-      allocator_(isolate->GetArrayBufferAllocator()),
       node_allocator_(node_allocator == nullptr ? nullptr
                                                 : node_allocator->GetImpl()),
-      uses_node_allocator_(allocator_ == node_allocator_),
       platform_(platform) {
-  CHECK_NOT_NULL(allocator_);
-
   options_.reset(
       new PerIsolateOptions(*(per_process::cli_options->per_isolate)));
 
@@ -209,10 +209,7 @@ void IsolateData::MemoryInfo(MemoryTracker* tracker) const {
 #define V(PropertyName, StringValue)                                           \
   tracker->TrackField(#PropertyName, PropertyName());
   PER_ISOLATE_SYMBOL_PROPERTIES(V)
-#undef V
 
-#define V(PropertyName, StringValue)                                           \
-  tracker->TrackField(#PropertyName, PropertyName());
   PER_ISOLATE_STRING_PROPERTIES(V)
 #undef V
 
@@ -221,9 +218,6 @@ void IsolateData::MemoryInfo(MemoryTracker* tracker) const {
   if (node_allocator_ != nullptr) {
     tracker->TrackFieldWithSize(
         "node_allocator", sizeof(*node_allocator_), "NodeArrayBufferAllocator");
-  } else {
-    tracker->TrackFieldWithSize(
-        "allocator", sizeof(*allocator_), "v8::ArrayBuffer::Allocator");
   }
   tracker->TrackFieldWithSize(
       "platform", sizeof(*platform_), "MultiIsolatePlatform");
@@ -262,16 +256,16 @@ void TrackingTraceStateObserver::UpdateTraceCategoryState() {
 void Environment::CreateProperties() {
   HandleScope handle_scope(isolate_);
   Local<Context> ctx = context();
-  Local<FunctionTemplate> templ = FunctionTemplate::New(isolate());
-  templ->InstanceTemplate()->SetInternalFieldCount(1);
-  templ->Inherit(BaseObject::GetConstructorTemplate(this));
-  Local<Object> obj = templ->GetFunction(ctx)
-                          .ToLocalChecked()
-                          ->NewInstance(ctx)
-                          .ToLocalChecked();
-  obj->SetAlignedPointerInInternalField(0, this);
-  set_as_callback_data(obj);
-  set_as_callback_data_template(templ);
+
+  {
+    Context::Scope context_scope(ctx);
+    Local<FunctionTemplate> templ = FunctionTemplate::New(isolate());
+    templ->InstanceTemplate()->SetInternalFieldCount(
+        BaseObject::kInternalFieldCount);
+    templ->Inherit(BaseObject::GetConstructorTemplate(this));
+
+    set_binding_data_ctor_template(templ);
+  }
 
   // Store primordials setup by the per-context script in the environment.
   Local<Object> per_context_bindings =
@@ -281,6 +275,29 @@ void Environment::CreateProperties() {
   CHECK(primordials->IsObject());
   set_primordials(primordials.As<Object>());
 
+  Local<String> prototype_string =
+      FIXED_ONE_BYTE_STRING(isolate(), "prototype");
+
+#define V(EnvPropertyName, PrimordialsPropertyName)                            \
+  {                                                                            \
+    Local<Value> ctor =                                                        \
+        primordials.As<Object>()                                               \
+            ->Get(ctx,                                                         \
+                  FIXED_ONE_BYTE_STRING(isolate(), PrimordialsPropertyName))   \
+            .ToLocalChecked();                                                 \
+    CHECK(ctor->IsObject());                                                   \
+    Local<Value> prototype =                                                   \
+        ctor.As<Object>()->Get(ctx, prototype_string).ToLocalChecked();        \
+    CHECK(prototype->IsObject());                                              \
+    set_##EnvPropertyName(prototype.As<Object>());                             \
+  }
+
+  V(primordials_safe_map_prototype_object, "SafeMap");
+  V(primordials_safe_set_prototype_object, "SafeSet");
+  V(primordials_safe_weak_map_prototype_object, "SafeWeakMap");
+  V(primordials_safe_weak_set_prototype_object, "SafeWeakSet");
+#undef V
+
   Local<Object> process_object =
       node::CreateProcessObject(this).FromMaybe(Local<Object>());
   set_process_object(process_object);
@@ -331,8 +348,6 @@ Environment::Environment(IsolateData* isolate_data,
       flags_(flags),
       thread_id_(thread_id.id == static_cast<uint64_t>(-1) ?
           AllocateEnvironmentThreadId().id : thread_id.id),
-      fs_stats_field_array_(isolate_, kFsStatsBufferLength),
-      fs_stats_field_bigint_array_(isolate_, kFsStatsBufferLength),
       context_(context->GetIsolate(), context) {
   // We'll be creating new objects so make sure we've entered the context.
   HandleScope handle_scope(isolate());
@@ -353,9 +368,10 @@ Environment::Environment(IsolateData* isolate_data,
   // easier to modify them after Environment creation. The defaults are
   // part of the per-Isolate option set, for which in turn the defaults are
   // part of the per-process option set.
-  options_.reset(new EnvironmentOptions(*isolate_data->options()->per_env));
-  inspector_host_port_.reset(
-      new ExclusiveAccess<HostPort>(options_->debug_options().host_port));
+  options_ = std::make_shared<EnvironmentOptions>(
+      *isolate_data->options()->per_env);
+  inspector_host_port_ = std::make_shared<ExclusiveAccess<HostPort>>(
+      options_->debug_options().host_port);
 
   if (!(flags_ & EnvironmentFlags::kOwnsProcessState)) {
     set_abort_on_uncaught_exception(false);
@@ -409,13 +425,17 @@ Environment::Environment(IsolateData* isolate_data,
   // By default, always abort when --abort-on-uncaught-exception was passed.
   should_abort_on_uncaught_toggle_[0] = 1;
 
-  if (options_->no_force_async_hooks_checks) {
+  if (!options_->force_async_hooks_checks) {
     async_hooks_.no_force_checks();
   }
 
   // TODO(joyeecheung): deserialize when the snapshot covers the environment
   // properties.
   CreateProperties();
+
+  // This adjusts the return value of base_object_count() so that tests that
+  // check the count do not have to account for internally created BaseObjects.
+  initial_base_object_count_ = base_object_count();
 }
 
 Environment::~Environment() {
@@ -444,13 +464,17 @@ Environment::~Environment() {
     DCHECK(consistency_check);
   }
 
+  // FreeEnvironment() should have set this.
+  CHECK(is_stopping());
+
+  if (options_->heap_snapshot_near_heap_limit > heap_limit_snapshot_taken_) {
+    isolate_->RemoveNearHeapLimitCallback(Environment::NearHeapLimitCallback,
+                                          0);
+  }
+
   isolate()->GetHeapProfiler()->RemoveBuildEmbedderGraphCallback(
       BuildEmbedderGraph, this);
 
-  // Make sure there are no re-used libuv wrapper objects.
-  // CleanupHandles() should have removed all of them.
-  CHECK(file_handle_read_wrap_freelist_.empty());
-
   HandleScope handle_scope(isolate());
 
 #if HAVE_INSPECTOR
@@ -469,11 +493,6 @@ Environment::~Environment() {
       tracing_controller->RemoveTraceStateObserver(trace_state_observer_.get());
   }
 
-  delete[] heap_statistics_buffer_;
-  delete[] heap_space_statistics_buffer_;
-  delete[] http_parser_buffer_;
-  delete[] heap_code_statistics_buffer_;
-
   TRACE_EVENT_NESTABLE_ASYNC_END0(
     TRACING_CATEGORY_NODE1(environment), "Environment", this);
 
@@ -489,10 +508,10 @@ Environment::~Environment() {
     }
   }
 
-  CHECK_EQ(base_object_count(), 0);
+  CHECK_EQ(base_object_count_, 0);
 }
 
-void Environment::InitializeLibuv(bool start_profiler_idle_notifier) {
+void Environment::InitializeLibuv() {
   HandleScope handle_scope(isolate());
   Context::Scope context_scope(context());
 
@@ -510,20 +529,17 @@ void Environment::InitializeLibuv(bool start_profiler_idle_notifier) {
   // but not all samples are created equal; mark the wall clock time spent in
   // epoll_wait() and friends so profiling tools can filter it out.  The samples
   // still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
-  // TODO(bnoordhuis) Depends on a libuv implementation detail that we should
-  // probably fortify in the API contract, namely that the last started prepare
-  // or check watcher runs first.  It's not 100% foolproof; if an add-on starts
-  // a prepare or check watcher after us, any samples attributed to its callback
-  // will be recorded with state=IDLE.
   uv_prepare_init(event_loop(), &idle_prepare_handle_);
   uv_check_init(event_loop(), &idle_check_handle_);
+
   uv_async_init(
       event_loop(),
       &task_queues_async_,
       [](uv_async_t* async) {
         Environment* env = ContainerOf(
             &Environment::task_queues_async_, async);
-        env->CleanupFinalizationGroups();
+        HandleScope handle_scope(env->isolate());
+        Context::Scope context_scope(env->context());
         env->RunAndClearNativeImmediates();
       });
   uv_unref(reinterpret_cast<uv_handle_t*>(&idle_prepare_handle_));
@@ -545,9 +561,7 @@ void Environment::InitializeLibuv(bool start_profiler_idle_notifier) {
   // FreeEnvironment.
   RegisterHandleCleanups();
 
-  if (start_profiler_idle_notifier) {
-    StartProfilerIdleNotifier();
-  }
+  StartProfilerIdleNotifier();
 }
 
 void Environment::ExitEnv() {
@@ -606,33 +620,19 @@ void Environment::CleanupHandles() {
          !handle_wrap_queue_.IsEmpty()) {
     uv_run(event_loop(), UV_RUN_ONCE);
   }
-
-  file_handle_read_wrap_freelist_.clear();
 }
 
 void Environment::StartProfilerIdleNotifier() {
-  if (profiler_idle_notifier_started_)
-    return;
-
-  profiler_idle_notifier_started_ = true;
-
   uv_prepare_start(&idle_prepare_handle_, [](uv_prepare_t* handle) {
     Environment* env = ContainerOf(&Environment::idle_prepare_handle_, handle);
     env->isolate()->SetIdle(true);
   });
-
   uv_check_start(&idle_check_handle_, [](uv_check_t* handle) {
     Environment* env = ContainerOf(&Environment::idle_check_handle_, handle);
     env->isolate()->SetIdle(false);
   });
 }
 
-void Environment::StopProfilerIdleNotifier() {
-  profiler_idle_notifier_started_ = false;
-  uv_prepare_stop(&idle_prepare_handle_);
-  uv_check_stop(&idle_check_handle_);
-}
-
 void Environment::PrintSyncTrace() const {
   if (!trace_sync_io_) return;
 
@@ -649,6 +649,8 @@ void Environment::RunCleanup() {
   started_cleanup_ = true;
   TraceEventScope trace_scope(TRACING_CATEGORY_NODE1(environment),
                               "RunCleanup", this);
+  bindings_.clear();
+  initial_base_object_count_ = 0;
   CleanupHandles();
 
   while (!cleanup_hooks_.empty() ||
@@ -1002,6 +1004,7 @@ void AsyncHooks::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("async_ids_stack", async_ids_stack_);
   tracker->TrackField("fields", fields_);
   tracker->TrackField("async_id_fields", async_id_fields_);
+  tracker->TrackField("js_promise_hooks", js_promise_hooks_);
 }
 
 void AsyncHooks::grow_async_ids_stack() {
@@ -1071,6 +1074,55 @@ void Environment::RemoveUnmanagedFd(int fd) {
   }
 }
 
+void Environment::VerifyNoStrongBaseObjects() {
+  // When a process exits cleanly, i.e. because the event loop ends up without
+  // things to wait for, the Node.js objects that are left on the heap should
+  // be:
+  //
+  //   1. weak, i.e. ready for garbage collection once no longer referenced, or
+  //   2. detached, i.e. scheduled for destruction once no longer referenced, or
+  //   3. an unrefed libuv handle, i.e. does not keep the event loop alive, or
+  //   4. an inactive libuv handle (essentially the same here)
+  //
+  // There are a few exceptions to this rule, but generally, if there are
+  // C++-backed Node.js objects on the heap that do not fall into the above
+  // categories, we may be looking at a potential memory leak. Most likely,
+  // the cause is a missing MakeWeak() call on the corresponding object.
+  //
+  // In order to avoid this kind of problem, we check the list of BaseObjects
+  // for these criteria. Currently, we only do so when explicitly instructed to
+  // or when in debug mode (where --verify-base-objects is always-on).
+
+  if (!options()->verify_base_objects) return;
+
+  ForEachBaseObject([](BaseObject* obj) {
+    if (obj->IsNotIndicativeOfMemoryLeakAtExit()) return;
+    fprintf(stderr, "Found bad BaseObject during clean exit: %s\n",
+            obj->MemoryInfoName().c_str());
+    fflush(stderr);
+    ABORT();
+  });
+}
+
+uint64_t GuessMemoryAvailableToTheProcess() {
+  uint64_t free_in_system = uv_get_free_memory();
+  size_t allowed = uv_get_constrained_memory();
+  if (allowed == 0) {
+    return free_in_system;
+  }
+  size_t rss;
+  int err = uv_resident_set_memory(&rss);
+  if (err) {
+    return free_in_system;
+  }
+  if (allowed < rss) {
+    // Something is probably wrong. Fallback to the free memory.
+    return free_in_system;
+  }
+  // There may still be room for swap, but we will just leave it here.
+  return allowed - rss;
+}
+
 void Environment::BuildEmbedderGraph(Isolate* isolate,
                                      EmbedderGraph* graph,
                                      void* data) {
@@ -1083,6 +1135,126 @@ void Environment::BuildEmbedderGraph(Isolate* isolate,
   });
 }
 
+size_t Environment::NearHeapLimitCallback(void* data,
+                                          size_t current_heap_limit,
+                                          size_t initial_heap_limit) {
+  Environment* env = static_cast<Environment*>(data);
+
+  Debug(env,
+        DebugCategory::DIAGNOSTICS,
+        "Invoked NearHeapLimitCallback, processing=%d, "
+        "current_limit=%" PRIu64 ", "
+        "initial_limit=%" PRIu64 "\n",
+        env->is_processing_heap_limit_callback_,
+        static_cast<uint64_t>(current_heap_limit),
+        static_cast<uint64_t>(initial_heap_limit));
+
+  size_t max_young_gen_size = env->isolate_data()->max_young_gen_size;
+  size_t young_gen_size = 0;
+  size_t old_gen_size = 0;
+
+  v8::HeapSpaceStatistics stats;
+  size_t num_heap_spaces = env->isolate()->NumberOfHeapSpaces();
+  for (size_t i = 0; i < num_heap_spaces; ++i) {
+    env->isolate()->GetHeapSpaceStatistics(&stats, i);
+    if (strcmp(stats.space_name(), "new_space") == 0 ||
+        strcmp(stats.space_name(), "new_large_object_space") == 0) {
+      young_gen_size += stats.space_used_size();
+    } else {
+      old_gen_size += stats.space_used_size();
+    }
+  }
+
+  Debug(env,
+        DebugCategory::DIAGNOSTICS,
+        "max_young_gen_size=%" PRIu64 ", "
+        "young_gen_size=%" PRIu64 ", "
+        "old_gen_size=%" PRIu64 ", "
+        "total_size=%" PRIu64 "\n",
+        static_cast<uint64_t>(max_young_gen_size),
+        static_cast<uint64_t>(young_gen_size),
+        static_cast<uint64_t>(old_gen_size),
+        static_cast<uint64_t>(young_gen_size + old_gen_size));
+
+  uint64_t available = GuessMemoryAvailableToTheProcess();
+  // TODO(joyeecheung): get a better estimate about the native memory
+  // usage into the overhead, e.g. based on the count of objects.
+  uint64_t estimated_overhead = max_young_gen_size;
+  Debug(env,
+        DebugCategory::DIAGNOSTICS,
+        "Estimated available memory=%" PRIu64 ", "
+        "estimated overhead=%" PRIu64 "\n",
+        static_cast<uint64_t>(available),
+        static_cast<uint64_t>(estimated_overhead));
+
+  // This might be hit when the snapshot is being taken in another
+  // NearHeapLimitCallback invocation.
+  // When taking the snapshot, objects in the young generation may be
+  // promoted to the old generation, result in increased heap usage,
+  // but it should be no more than the young generation size.
+  // Ideally, this should be as small as possible - the heap limit
+  // can only be restored when the heap usage falls down below the
+  // new limit, so in a heap with unbounded growth the isolate
+  // may eventually crash with this new limit - effectively raising
+  // the heap limit to the new one.
+  if (env->is_processing_heap_limit_callback_) {
+    size_t new_limit = initial_heap_limit + max_young_gen_size;
+    Debug(env,
+          DebugCategory::DIAGNOSTICS,
+          "Not generating snapshots in nested callback. "
+          "new_limit=%" PRIu64 "\n",
+          static_cast<uint64_t>(new_limit));
+    return new_limit;
+  }
+
+  // Estimate whether the snapshot is going to use up all the memory
+  // available to the process. If so, just give up to prevent the system
+  // from killing the process for a system OOM.
+  if (estimated_overhead > available) {
+    Debug(env,
+          DebugCategory::DIAGNOSTICS,
+          "Not generating snapshots because it's too risky.\n");
+    env->isolate()->RemoveNearHeapLimitCallback(NearHeapLimitCallback,
+                                                initial_heap_limit);
+    return current_heap_limit;
+  }
+
+  // Take the snapshot synchronously.
+  env->is_processing_heap_limit_callback_ = true;
+
+  std::string dir = env->options()->diagnostic_dir;
+  if (dir.empty()) {
+    dir = env->GetCwd();
+  }
+  DiagnosticFilename name(env, "Heap", "heapsnapshot");
+  std::string filename = dir + kPathSeparator + (*name);
+
+  Debug(env, DebugCategory::DIAGNOSTICS, "Start generating %s...\n", *name);
+
+  // Remove the callback first in case it's triggered when generating
+  // the snapshot.
+  env->isolate()->RemoveNearHeapLimitCallback(NearHeapLimitCallback,
+                                              initial_heap_limit);
+
+  heap::WriteSnapshot(env->isolate(), filename.c_str());
+  env->heap_limit_snapshot_taken_ += 1;
+
+  // Don't take more snapshots than the number specified by
+  // --heapsnapshot-near-heap-limit.
+  if (env->heap_limit_snapshot_taken_ <
+      env->options_->heap_snapshot_near_heap_limit) {
+    env->isolate()->AddNearHeapLimitCallback(NearHeapLimitCallback, env);
+  }
+
+  FPrintF(stderr, "Wrote snapshot to %s\n", filename.c_str());
+  // Tell V8 to reset the heap limit once the heap usage falls down to
+  // 95% of the initial limit.
+  env->isolate()->AutomaticallyRestoreInitialHeapLimit(0.95);
+
+  env->is_processing_heap_limit_callback_ = false;
+  return initial_heap_limit;
+}
+
 inline size_t Environment::SelfSize() const {
   size_t size = sizeof(*this);
   // Remove non pointer fields that will be tracked in MemoryInfo()
@@ -1107,9 +1279,6 @@ void Environment::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("should_abort_on_uncaught_toggle",
                       should_abort_on_uncaught_toggle_);
   tracker->TrackField("stream_base_state", stream_base_state_);
-  tracker->TrackField("fs_stats_field_array", fs_stats_field_array_);
-  tracker->TrackField("fs_stats_field_bigint_array",
-                      fs_stats_field_bigint_array_);
   tracker->TrackFieldWithSize(
       "cleanup_hooks", cleanup_hooks_.size() * sizeof(CleanupHookCallback));
   tracker->TrackField("async_hooks", async_hooks_);
@@ -1132,64 +1301,10 @@ void Environment::MemoryInfo(MemoryTracker* tracker) const {
   // node, we shift its sizeof() size out of the Environment node.
 }
 
-char* Environment::Reallocate(char* data, size_t old_size, size_t size) {
-  if (old_size == size) return data;
-  // If we know that the allocator is our ArrayBufferAllocator, we can let
-  // if reallocate directly.
-  if (isolate_data()->uses_node_allocator()) {
-    return static_cast<char*>(
-        isolate_data()->node_allocator()->Reallocate(data, old_size, size));
-  }
-  // Generic allocators do not provide a reallocation method; we need to
-  // allocate a new chunk of memory and copy the data over.
-  char* new_data = AllocateUnchecked(size);
-  if (new_data == nullptr) return nullptr;
-  memcpy(new_data, data, std::min(size, old_size));
-  if (size > old_size)
-    memset(new_data + old_size, 0, size - old_size);
-  Free(data, old_size);
-  return new_data;
-}
-
-void Environment::AddArrayBufferAllocatorToKeepAliveUntilIsolateDispose(
-    std::shared_ptr<v8::ArrayBuffer::Allocator> allocator) {
-  if (keep_alive_allocators_ == nullptr) {
-    MultiIsolatePlatform* platform = isolate_data()->platform();
-    CHECK_NOT_NULL(platform);
-
-    keep_alive_allocators_ = new ArrayBufferAllocatorList();
-    platform->AddIsolateFinishedCallback(isolate(), [](void* data) {
-      delete static_cast<ArrayBufferAllocatorList*>(data);
-    }, static_cast<void*>(keep_alive_allocators_));
-  }
-
-  keep_alive_allocators_->insert(allocator);
-}
-
 void Environment::RunWeakRefCleanup() {
   isolate()->ClearKeptObjects();
 }
 
-void Environment::CleanupFinalizationGroups() {
-  HandleScope handle_scope(isolate());
-  Context::Scope context_scope(context());
-  TryCatchScope try_catch(this);
-
-  while (!cleanup_finalization_groups_.empty() && can_call_into_js()) {
-    Local<FinalizationGroup> fg =
-        cleanup_finalization_groups_.front().Get(isolate());
-    cleanup_finalization_groups_.pop_front();
-    if (!FinalizationGroup::Cleanup(fg).FromMaybe(false)) {
-      if (try_catch.HasCaught() && !try_catch.HasTerminated())
-        errors::TriggerUncaughtException(isolate(), try_catch);
-      // Re-schedule the execution of the remainder of the queue.
-      CHECK(task_queues_async_initialized_);
-      uv_async_send(&task_queues_async_);
-      return;
-    }
-  }
-}
-
 // Not really any better place than env.cc at this moment.
 void BaseObject::DeleteMe(void* data) {
   BaseObject* self = static_cast<BaseObject*>(data);
@@ -1220,4 +1335,8 @@ Local<FunctionTemplate> BaseObject::GetConstructorTemplate(Environment* env) {
   return tmpl;
 }
 
+bool BaseObject::IsNotIndicativeOfMemoryLeakAtExit() const {
+  return IsWeakOrDetached();
+}
+
 }  // namespace node
diff --git a/src/env.h b/src/env.h
index ed058866e94e3d62558f99db39bd432acb9eecc3..b6967afb89911491811a1b28273638307b6e44d7 100644
--- a/src/env.h
+++ b/src/env.h
@@ -34,7 +34,6 @@
 #include "handle_wrap.h"
 #include "node.h"
 #include "node_binding.h"
-#include "node_http2_state.h"
 #include "node_main_instance.h"
 #include "node_options.h"
 #include "req_wrap.h"
@@ -51,8 +50,6 @@
 #include <unordered_set>
 #include <vector>
 
-struct nghttp2_rcbuf;
-
 namespace node {
 
 namespace contextify {
@@ -60,10 +57,6 @@ class ContextifyScript;
 class CompiledFnEntry;
 }
 
-namespace fs {
-class FileHandleReadWrap;
-}
-
 namespace performance {
 class PerformanceState;
 }
@@ -159,12 +152,12 @@ constexpr size_t kFsStatsBufferLength =
   V(decorated_private_symbol, "node:decorated")                               \
   V(napi_type_tag, "node:napi:type_tag")                                      \
   V(napi_wrapper, "node:napi:wrapper")                                        \
-  V(sab_lifetimepartner_symbol, "node:sharedArrayBufferLifetimePartner")      \
   V(untransferable_object_private_symbol, "node:untransferableObject")        \
 
 // Symbols are per-isolate primitives but Environment proxies them
 // for the sake of convenience.
 #define PER_ISOLATE_SYMBOL_PROPERTIES(V)                                       \
+  V(async_id_symbol, "async_id_symbol")                                        \
   V(handle_onclose_symbol, "handle_onclose")                                   \
   V(no_message_symbol, "no_message_symbol")                                    \
   V(messaging_deserialize_symbol, "messaging_deserialize_symbol")              \
@@ -186,6 +179,7 @@ constexpr size_t kFsStatsBufferLength =
   V(asn1curve_string, "asn1Curve")                                             \
   V(async_ids_stack_string, "async_ids_stack")                                 \
   V(bits_string, "bits")                                                       \
+  V(block_list_string, "blockList")                                            \
   V(buffer_string, "buffer")                                                   \
   V(bytes_parsed_string, "bytesParsed")                                        \
   V(bytes_read_string, "bytesRead")                                            \
@@ -213,6 +207,7 @@ constexpr size_t kFsStatsBufferLength =
   V(crypto_rsa_pss_string, "rsa-pss")                                          \
   V(cwd_string, "cwd")                                                         \
   V(data_string, "data")                                                       \
+  V(default_is_true_string, "defaultIsTrue")                                   \
   V(deserialize_info_string, "deserializeInfo")                                \
   V(dest_string, "dest")                                                       \
   V(destroyed_string, "destroyed")                                             \
@@ -220,6 +215,8 @@ constexpr size_t kFsStatsBufferLength =
   V(dh_string, "DH")                                                           \
   V(dns_a_string, "A")                                                         \
   V(dns_aaaa_string, "AAAA")                                                   \
+  V(dns_caa_string, "CAA")                                                     \
+  V(dns_critical_string, "critical")                                           \
   V(dns_cname_string, "CNAME")                                                 \
   V(dns_mx_string, "MX")                                                       \
   V(dns_naptr_string, "NAPTR")                                                 \
@@ -257,6 +254,7 @@ constexpr size_t kFsStatsBufferLength =
   V(fingerprint256_string, "fingerprint256")                                   \
   V(fingerprint_string, "fingerprint")                                         \
   V(flags_string, "flags")                                                     \
+  V(flowlabel_string, "flowlabel")                                             \
   V(fragment_string, "fragment")                                               \
   V(function_string, "function")                                               \
   V(get_data_clone_error_string, "_getDataCloneError")                         \
@@ -325,6 +323,7 @@ constexpr size_t kFsStatsBufferLength =
   V(options_string, "options")                                                 \
   V(order_string, "order")                                                     \
   V(output_string, "output")                                                   \
+  V(overlapped_string, "overlapped")                                           \
   V(parse_error_string, "Parse Error")                                         \
   V(password_string, "password")                                               \
   V(path_string, "path")                                                       \
@@ -411,10 +410,12 @@ constexpr size_t kFsStatsBufferLength =
   V(zero_return_string, "ZERO_RETURN")
 
 #define ENVIRONMENT_STRONG_PERSISTENT_TEMPLATES(V)                             \
-  V(as_callback_data_template, v8::FunctionTemplate)                           \
   V(async_wrap_ctor_template, v8::FunctionTemplate)                            \
   V(async_wrap_object_ctor_template, v8::FunctionTemplate)                     \
   V(base_object_ctor_template, v8::FunctionTemplate)                           \
+  V(binding_data_ctor_template, v8::FunctionTemplate)                          \
+  V(blob_constructor_template, v8::FunctionTemplate)                           \
+  V(blocklist_constructor_template, v8::FunctionTemplate)                      \
   V(compiled_fn_entry_template, v8::ObjectTemplate)                            \
   V(dir_instance_template, v8::ObjectTemplate)                                 \
   V(fd_constructor_template, v8::ObjectTemplate)                               \
@@ -422,19 +423,22 @@ constexpr size_t kFsStatsBufferLength =
   V(filehandlereadwrap_template, v8::ObjectTemplate)                           \
   V(fsreqpromise_constructor_template, v8::ObjectTemplate)                     \
   V(handle_wrap_ctor_template, v8::FunctionTemplate)                           \
-  V(histogram_instance_template, v8::ObjectTemplate)                           \
+  V(histogram_ctor_template, v8::FunctionTemplate)                             \
   V(http2settings_constructor_template, v8::ObjectTemplate)                    \
   V(http2stream_constructor_template, v8::ObjectTemplate)                      \
   V(http2ping_constructor_template, v8::ObjectTemplate)                        \
   V(i18n_converter_template, v8::ObjectTemplate)                               \
+  V(intervalhistogram_constructor_template, v8::FunctionTemplate)              \
   V(libuv_stream_wrap_ctor_template, v8::FunctionTemplate)                     \
   V(message_port_constructor_template, v8::FunctionTemplate)                   \
+  V(microtask_queue_ctor_template, v8::FunctionTemplate)                       \
   V(pipe_constructor_template, v8::FunctionTemplate)                           \
   V(promise_wrap_template, v8::ObjectTemplate)                                 \
   V(sab_lifetimepartner_constructor_template, v8::FunctionTemplate)            \
   V(script_context_constructor_template, v8::FunctionTemplate)                 \
   V(secure_context_constructor_template, v8::FunctionTemplate)                 \
   V(shutdown_wrap_template, v8::ObjectTemplate)                                \
+  V(socketaddress_constructor_template, v8::FunctionTemplate)                  \
   V(streambaseoutputstream_constructor_template, v8::ObjectTemplate)           \
   V(tcp_constructor_template, v8::FunctionTemplate)                            \
   V(tty_constructor_template, v8::FunctionTemplate)                            \
@@ -442,7 +446,6 @@ constexpr size_t kFsStatsBufferLength =
   V(worker_heap_snapshot_taker_template, v8::ObjectTemplate)
 
 #define ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)                                \
-  V(as_callback_data, v8::Object)                                              \
   V(async_hooks_after_function, v8::Function)                                  \
   V(async_hooks_before_function, v8::Function)                                 \
   V(async_hooks_callback_trampoline, v8::Function)                             \
@@ -470,13 +473,14 @@ constexpr size_t kFsStatsBufferLength =
   V(http2session_on_origin_function, v8::Function)                             \
   V(http2session_on_ping_function, v8::Function)                               \
   V(http2session_on_priority_function, v8::Function)                           \
-  V(http2session_on_select_padding_function, v8::Function)                     \
   V(http2session_on_settings_function, v8::Function)                           \
   V(http2session_on_stream_close_function, v8::Function)                       \
   V(http2session_on_stream_trailers_function, v8::Function)                    \
   V(internal_binding_loader, v8::Function)                                     \
   V(immediate_callback_function, v8::Function)                                 \
   V(inspector_console_extension_installer, v8::Function)                       \
+  V(inspector_disable_async_hooks, v8::Function)                               \
+  V(inspector_enable_async_hooks, v8::Function)                                \
   V(messaging_deserialize_create_object, v8::Function)                         \
   V(message_port, v8::Object)                                                  \
   V(native_module_require, v8::Function)                                       \
@@ -485,6 +489,11 @@ constexpr size_t kFsStatsBufferLength =
   V(prepare_stack_trace_callback, v8::Function)                                \
   V(process_object, v8::Object)                                                \
   V(primordials, v8::Object)                                                   \
+  V(primordials_safe_map_prototype_object, v8::Object)                         \
+  V(primordials_safe_set_prototype_object, v8::Object)                         \
+  V(primordials_safe_weak_map_prototype_object, v8::Object)                    \
+  V(primordials_safe_weak_set_prototype_object, v8::Object)                    \
+  V(promise_hook_handler, v8::Function)                                        \
   V(promise_reject_callback, v8::Function)                                     \
   V(script_data_constructor_function, v8::Function)                            \
   V(source_map_cache_getter, v8::Function)                                     \
@@ -496,6 +505,7 @@ constexpr size_t kFsStatsBufferLength =
   V(url_constructor_function, v8::Function)
 
 class Environment;
+struct AllocatedBuffer;
 
 class IsolateData : public MemoryRetainer {
  public:
@@ -514,8 +524,6 @@ class IsolateData : public MemoryRetainer {
   inline std::shared_ptr<PerIsolateOptions> options();
   inline void set_options(std::shared_ptr<PerIsolateOptions> options);
 
-  inline bool uses_node_allocator() const;
-  inline v8::ArrayBuffer::Allocator* allocator() const;
   inline NodeArrayBufferAllocator* node_allocator() const;
 
   inline worker::Worker* worker_context() const;
@@ -535,7 +543,9 @@ class IsolateData : public MemoryRetainer {
 #undef VP
   inline v8::Local<v8::String> async_wrap_provider(int index) const;
 
-  std::unordered_map<nghttp2_rcbuf*, v8::Eternal<v8::String>> http2_static_strs;
+  size_t max_young_gen_size = 1;
+  std::unordered_map<const char*, v8::Eternal<v8::String>> static_str_map;
+
   inline v8::Isolate* isolate() const;
   IsolateData(const IsolateData&) = delete;
   IsolateData& operator=(const IsolateData&) = delete;
@@ -564,9 +574,7 @@ class IsolateData : public MemoryRetainer {
 
   v8::Isolate* const isolate_;
   uv_loop_t* const event_loop_;
-  v8::ArrayBuffer::Allocator* const allocator_;
   NodeArrayBufferAllocator* const node_allocator_;
-  const bool uses_node_allocator_;
   MultiIsolatePlatform* platform_;
   std::shared_ptr<PerIsolateOptions> options_;
   worker::Worker* worker_context_ = nullptr;
@@ -581,38 +589,6 @@ struct ContextInfo {
 
 class EnabledDebugList;
 
-// A unique-pointer-ish object that is compatible with the JS engine's
-// ArrayBuffer::Allocator.
-struct AllocatedBuffer {
- public:
-  explicit inline AllocatedBuffer(Environment* env = nullptr);
-  inline AllocatedBuffer(Environment* env, uv_buf_t buf);
-  inline ~AllocatedBuffer();
-  inline void Resize(size_t len);
-
-  inline uv_buf_t release();
-  inline char* data();
-  inline const char* data() const;
-  inline size_t size() const;
-  inline void clear();
-
-  inline v8::MaybeLocal<v8::Object> ToBuffer();
-  inline v8::Local<v8::ArrayBuffer> ToArrayBuffer();
-
-  inline AllocatedBuffer(AllocatedBuffer&& other);
-  inline AllocatedBuffer& operator=(AllocatedBuffer&& other);
-  AllocatedBuffer(const AllocatedBuffer& other) = delete;
-  AllocatedBuffer& operator=(const AllocatedBuffer& other) = delete;
-
- private:
-  Environment* env_;
-  // We do not pass this to libuv directly, but uv_buf_t is a convenient way
-  // to represent a chunk of memory, and plays nicely with other parts of core.
-  uv_buf_t buffer_;
-
-  friend class Environment;
-};
-
 class KVStore {
  public:
   KVStore() = default;
@@ -684,6 +660,11 @@ class AsyncHooks : public MemoryRetainer {
   // The `js_execution_async_resources` array contains the value in that case.
   inline v8::Local<v8::Object> native_execution_async_resource(size_t index);
 
+  inline void SetJSPromiseHooks(v8::Local<v8::Function> init,
+                                v8::Local<v8::Function> before,
+                                v8::Local<v8::Function> after,
+                                v8::Local<v8::Function> resolve);
+
   inline v8::Local<v8::String> provider_string(int idx);
 
   inline void no_force_checks();
@@ -694,6 +675,9 @@ class AsyncHooks : public MemoryRetainer {
   inline bool pop_async_context(double async_id);
   inline void clear_async_id_stack();  // Used in fatal exceptions.
 
+  inline void AddContext(v8::Local<v8::Context> ctx);
+  inline void RemoveContext(v8::Local<v8::Context> ctx);
+
   AsyncHooks(const AsyncHooks&) = delete;
   AsyncHooks& operator=(const AsyncHooks&) = delete;
   AsyncHooks(AsyncHooks&&) = delete;
@@ -737,6 +721,10 @@ class AsyncHooks : public MemoryRetainer {
 
   v8::Global<v8::Array> js_execution_async_resources_;
   std::vector<v8::Global<v8::Object>> native_execution_async_resources_;
+
+  std::vector<v8::Global<v8::Context>> contexts_;
+
+  std::array<v8::Global<v8::Function>, 4> js_promise_hooks_;
 };
 
 class ImmediateInfo : public MemoryRetainer {
@@ -829,7 +817,9 @@ class ShouldNotAbortOnUncaughtScope {
 
 class CleanupHookCallback {
  public:
-  CleanupHookCallback(void (*fn)(void*),
+  typedef void (*Callback)(void*);
+
+  CleanupHookCallback(Callback fn,
                       void* arg,
                       uint64_t insertion_order_counter)
       : fn_(fn), arg_(arg), insertion_order_counter_(insertion_order_counter) {}
@@ -849,7 +839,7 @@ class CleanupHookCallback {
 
  private:
   friend class Environment;
-  void (*fn_)(void*);
+  Callback fn_;
   void* arg_;
 
   // We keep track of the insertion order for these objects, so that we can
@@ -871,8 +861,12 @@ class Environment : public MemoryRetainer {
   void MemoryInfo(MemoryTracker* tracker) const override;
 
   void CreateProperties();
+  void VerifyNoStrongBaseObjects();
   // Should be called before InitializeInspector()
   void InitializeDiagnostics();
+
+  std::string GetCwd();
+
 #if HAVE_INSPECTOR
   // If the environment is created for a worker, pass parent_handle and
   // the ownership if transferred into the Environment.
@@ -897,7 +891,24 @@ class Environment : public MemoryRetainer {
   static inline Environment* GetCurrent(
       const v8::PropertyCallbackInfo<T>& info);
 
-  static inline Environment* GetFromCallbackData(v8::Local<v8::Value> val);
+  // Methods created using SetMethod(), SetPrototypeMethod(), etc. inside
+  // this scope can access the created T* object using
+  // GetBindingData<T>(args) later.
+  template <typename T>
+  T* AddBindingData(v8::Local<v8::Context> context,
+                    v8::Local<v8::Object> target);
+  template <typename T, typename U>
+  static inline T* GetBindingData(const v8::PropertyCallbackInfo<U>& info);
+  template <typename T>
+  static inline T* GetBindingData(
+      const v8::FunctionCallbackInfo<v8::Value>& info);
+  template <typename T>
+  static inline T* GetBindingData(v8::Local<v8::Context> context);
+
+  typedef std::unordered_map<
+      FastStringKey,
+      BaseObjectPtr<BaseObject>,
+      FastStringKey::Hash> BindingDataStore;
 
   static uv_key_t thread_local_env;
   static inline Environment* GetThreadLocalEnv();
@@ -910,7 +921,7 @@ class Environment : public MemoryRetainer {
               ThreadId thread_id);
   ~Environment() override;
 
-  void InitializeLibuv(bool start_profiler_idle_notifier);
+  void InitializeLibuv();
   inline const std::vector<std::string>& exec_argv();
   inline const std::vector<std::string>& argv();
   const std::string& exec_path() const;
@@ -941,8 +952,6 @@ class Environment : public MemoryRetainer {
                               const ContextInfo& info);
 
   void StartProfilerIdleNotifier();
-  void StopProfilerIdleNotifier();
-  inline bool profiler_idle_notifier_started() const;
 
   inline v8::Isolate* isolate() const;
   inline uv_loop_t* event_loop() const;
@@ -970,15 +979,6 @@ class Environment : public MemoryRetainer {
 
   inline IsolateData* isolate_data() const;
 
-  // Utilities that allocate memory using the Isolate's ArrayBuffer::Allocator.
-  // In particular, using AllocateManaged() will provide a RAII-style object
-  // with easy conversion to `Buffer` and `ArrayBuffer` objects.
-  inline AllocatedBuffer AllocateManaged(size_t size, bool checked = true);
-  inline char* Allocate(size_t size);
-  inline char* AllocateUnchecked(size_t size);
-  char* Reallocate(char* data, size_t old_size, size_t size);
-  inline void Free(char* data, size_t size);
-
   inline bool printed_error() const;
   inline void set_printed_error(bool value);
 
@@ -1021,31 +1021,8 @@ class Environment : public MemoryRetainer {
   inline uint32_t get_next_script_id();
   inline uint32_t get_next_function_id();
 
-  inline double* heap_statistics_buffer() const;
-  inline void set_heap_statistics_buffer(double* pointer);
-
-  inline double* heap_space_statistics_buffer() const;
-  inline void set_heap_space_statistics_buffer(double* pointer);
-
-  inline double* heap_code_statistics_buffer() const;
-  inline void set_heap_code_statistics_buffer(double* pointer);
-
-  inline char* http_parser_buffer() const;
-  inline void set_http_parser_buffer(char* buffer);
-  inline bool http_parser_buffer_in_use() const;
-  inline void set_http_parser_buffer_in_use(bool in_use);
-
-  inline http2::Http2State* http2_state() const;
-  inline void set_http2_state(std::unique_ptr<http2::Http2State> state);
-
   EnabledDebugList* enabled_debug_list() { return &enabled_debug_list_; }
 
-  inline AliasedFloat64Array* fs_stats_field_array();
-  inline AliasedBigUint64Array* fs_stats_field_bigint_array();
-
-  inline std::vector<std::unique_ptr<fs::FileHandleReadWrap>>&
-      file_handle_read_wrap_freelist();
-
   inline performance::PerformanceState* performance_state();
   inline std::unordered_map<std::string, uint64_t>* performance_marks();
 
@@ -1081,6 +1058,7 @@ class Environment : public MemoryRetainer {
   inline bool owns_process_state() const;
   inline bool owns_inspector() const;
   inline bool tracks_unmanaged_fds() const;
+  inline bool hide_console_windows() const;
   inline uint64_t thread_id() const;
   inline worker::Worker* worker_context() const;
   Environment* worker_parent_env() const;
@@ -1093,8 +1071,15 @@ class Environment : public MemoryRetainer {
   inline void set_stopping(bool value);
   inline std::list<node_module>* extra_linked_bindings();
   inline node_module* extra_linked_bindings_head();
+  inline node_module* extra_linked_bindings_tail();
   inline const Mutex& extra_linked_bindings_mutex() const;
 
+  inline bool filehandle_close_warning() const;
+  inline void set_filehandle_close_warning(bool on);
+
+  inline void set_source_maps_enabled(bool on);
+  inline bool source_maps_enabled() const;
+
   inline void ThrowError(const char* errmsg);
   inline void ThrowTypeError(const char* errmsg);
   inline void ThrowRangeError(const char* errmsg);
@@ -1139,12 +1124,27 @@ class Environment : public MemoryRetainer {
                                          const char* name,
                                          v8::FunctionCallback callback);
 
+  enum class SetConstructorFunctionFlag {
+    NONE,
+    SET_CLASS_NAME,
+  };
+
+  inline void SetConstructorFunction(v8::Local<v8::Object> that,
+                          const char* name,
+                          v8::Local<v8::FunctionTemplate> tmpl,
+                          SetConstructorFunctionFlag flag =
+                              SetConstructorFunctionFlag::SET_CLASS_NAME);
+
+  inline void SetConstructorFunction(v8::Local<v8::Object> that,
+                          v8::Local<v8::String> name,
+                          v8::Local<v8::FunctionTemplate> tmpl,
+                          SetConstructorFunctionFlag flag =
+                              SetConstructorFunctionFlag::SET_CLASS_NAME);
+
   void AtExit(void (*cb)(void* arg), void* arg);
   void RunAtExitCallbacks();
 
-  void RegisterFinalizationGroupForCleanup(v8::Local<v8::FinalizationGroup> fg);
   void RunWeakRefCleanup();
-  void CleanupFinalizationGroups();
 
   // Strings and private symbols are shared across shared contexts
   // The getters simply proxy to the per-isolate primitive.
@@ -1226,10 +1226,14 @@ class Environment : public MemoryRetainer {
   void ScheduleTimer(int64_t duration);
   void ToggleTimerRef(bool ref);
 
-  inline void AddCleanupHook(void (*fn)(void*), void* arg);
-  inline void RemoveCleanupHook(void (*fn)(void*), void* arg);
+  using CleanupCallback = CleanupHookCallback::Callback;
+  inline void AddCleanupHook(CleanupCallback cb, void* arg);
+  inline void RemoveCleanupHook(CleanupCallback cb, void* arg);
   void RunCleanup();
 
+  static size_t NearHeapLimitCallback(void* data,
+                                      size_t current_heap_limit,
+                                      size_t initial_heap_limit);
   static void BuildEmbedderGraph(v8::Isolate* isolate,
                                  v8::EmbedderGraph* graph,
                                  void* data);
@@ -1237,14 +1241,14 @@ class Environment : public MemoryRetainer {
   inline std::shared_ptr<EnvironmentOptions> options();
   inline std::shared_ptr<ExclusiveAccess<HostPort>> inspector_host_port();
 
-  inline int32_t stack_trace_limit() const { return 10; }
-
   // The BaseObject count is a debugging helper that makes sure that there are
   // no memory leaks caused by BaseObjects staying alive longer than expected
   // (in particular, no circular BaseObjectPtr references).
   inline void modify_base_object_count(int64_t delta);
   inline int64_t base_object_count() const;
 
+  inline int32_t stack_trace_limit() const { return 10; }
+
 #if HAVE_INSPECTOR
   void set_coverage_connection(
       std::unique_ptr<profiler::V8CoverageConnection> connection);
@@ -1281,10 +1285,6 @@ class Environment : public MemoryRetainer {
 
 #endif  // HAVE_INSPECTOR
 
-  // Only available if a MultiIsolatePlatform is in use.
-  void AddArrayBufferAllocatorToKeepAliveUntilIsolateDispose(
-      std::shared_ptr<v8::ArrayBuffer::Allocator>);
-
   inline void set_main_utf16(std::unique_ptr<v8::String::Value>);
   inline void set_process_exit_handler(
       std::function<void(Environment*, int)>&& handler);
@@ -1292,6 +1292,9 @@ class Environment : public MemoryRetainer {
   void RunAndClearNativeImmediates(bool only_refed = false);
   void RunAndClearInterrupts();
 
+  inline std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>*
+      released_allocated_buffers();
+
   void AddUnmanagedFd(int fd);
   void RemoveUnmanagedFd(int fd);
 
@@ -1309,7 +1312,6 @@ class Environment : public MemoryRetainer {
   uv_check_t idle_check_handle_;
   uv_async_t task_queues_async_;
   int64_t task_queues_async_refs_ = 0;
-  bool profiler_idle_notifier_started_ = false;
 
   AsyncHooks async_hooks_;
   ImmediateInfo immediate_info_;
@@ -1320,6 +1322,9 @@ class Environment : public MemoryRetainer {
   bool trace_sync_io_ = false;
   bool emit_env_nonstring_warning_ = true;
   bool emit_err_name_warning_ = true;
+  bool emit_filehandle_warning_ = true;
+  bool source_maps_enabled_ = false;
+
   size_t async_callback_scope_depth_ = 0;
   std::vector<double> destroy_async_id_list_;
 
@@ -1349,6 +1354,9 @@ class Environment : public MemoryRetainer {
   std::vector<std::string> argv_;
   std::string exec_path_;
 
+  bool is_processing_heap_limit_callback_ = false;
+  int64_t heap_limit_snapshot_taken_ = 0;
+
   uint32_t module_id_counter_ = 0;
   uint32_t script_id_counter_ = 0;
   uint32_t function_id_counter_ = 0;
@@ -1371,8 +1379,6 @@ class Environment : public MemoryRetainer {
   uint64_t thread_id_;
   std::unordered_set<worker::Worker*> sub_worker_contexts_;
 
-  std::deque<v8::Global<v8::FinalizationGroup>> cleanup_finalization_groups_;
-
   static void* const kNodeContextTagPtr;
   static int const kNodeContextTag;
 
@@ -1394,20 +1400,7 @@ class Environment : public MemoryRetainer {
   int handle_cleanup_waiting_ = 0;
   int request_waiting_ = 0;
 
-  double* heap_statistics_buffer_ = nullptr;
-  double* heap_space_statistics_buffer_ = nullptr;
-  double* heap_code_statistics_buffer_ = nullptr;
-
-  char* http_parser_buffer_ = nullptr;
-  bool http_parser_buffer_in_use_ = false;
-  std::unique_ptr<http2::Http2State> http2_state_;
-
   EnabledDebugList enabled_debug_list_;
-  AliasedFloat64Array fs_stats_field_array_;
-  AliasedBigUint64Array fs_stats_field_bigint_array_;
-
-  std::vector<std::unique_ptr<fs::FileHandleReadWrap>>
-      file_handle_read_wrap_freelist_;
 
   std::list<node_module> extra_linked_bindings_;
   Mutex extra_linked_bindings_mutex_;
@@ -1436,6 +1429,8 @@ class Environment : public MemoryRetainer {
   void RequestInterruptFromV8();
   static void CheckImmediate(uv_check_t* handle);
 
+  BindingDataStore bindings_;
+
   // Use an unordered_set, so that we have efficient insertion and removal.
   std::unordered_set<CleanupHookCallback,
                      CleanupHookCallback::Hash,
@@ -1444,12 +1439,9 @@ class Environment : public MemoryRetainer {
   bool started_cleanup_ = false;
 
   int64_t base_object_count_ = 0;
+  int64_t initial_base_object_count_ = 0;
   std::atomic_bool is_stopping_ { false };
 
-  typedef std::unordered_set<std::shared_ptr<v8::ArrayBuffer::Allocator>>
-      ArrayBufferAllocatorList;
-  ArrayBufferAllocatorList* keep_alive_allocators_ = nullptr;
-
   std::unordered_set<int> unmanaged_fds_;
 
   std::function<void(Environment*, int)> process_exit_handler_ {
@@ -1469,6 +1461,11 @@ class Environment : public MemoryRetainer {
   // We should probably find a way to just use plain `v8::String`s created from
   // the source passed to LoadEnvironment() directly instead.
   std::unique_ptr<v8::String::Value> main_utf16_;
+
+  // Used by AllocatedBuffer::release() to keep track of the BackingStore for
+  // a given pointer.
+  std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>
+      released_allocated_buffers_;
 };
 
 }  // namespace node
diff --git a/src/fs_event_wrap.cc b/src/fs_event_wrap.cc
index e16dc84ce8e5eee5df616e5962a17e5a25fb7a80..b79da7e83622c9598b4a99858d5d001d56899e6d 100644
--- a/src/fs_event_wrap.cc
+++ b/src/fs_event_wrap.cc
@@ -95,11 +95,9 @@ void FSEventWrap::Initialize(Local<Object> target,
                              void* priv) {
   Environment* env = Environment::GetCurrent(context);
 
-  auto fsevent_string = FIXED_ONE_BYTE_STRING(env->isolate(), "FSEvent");
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
   t->InstanceTemplate()->SetInternalFieldCount(
       FSEventWrap::kInternalFieldCount);
-  t->SetClassName(fsevent_string);
 
   t->Inherit(HandleWrap::GetConstructorTemplate(env));
   env->SetProtoMethod(t, "start", Start);
@@ -107,7 +105,7 @@ void FSEventWrap::Initialize(Local<Object> target,
   Local<FunctionTemplate> get_initialized_templ =
       FunctionTemplate::New(env->isolate(),
                             GetInitialized,
-                            env->as_callback_data(),
+                            Local<Value>(),
                             Signature::New(env->isolate(), t));
 
   t->PrototypeTemplate()->SetAccessorProperty(
@@ -116,9 +114,7 @@ void FSEventWrap::Initialize(Local<Object> target,
       Local<FunctionTemplate>(),
       static_cast<PropertyAttribute>(ReadOnly | DontDelete | DontEnum));
 
-  target->Set(env->context(),
-              fsevent_string,
-              t->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "FSEvent", t);
 }
 
 
diff --git a/src/handle_wrap.cc b/src/handle_wrap.cc
index 4e039d5dbf2d370d8f712490e5203557e5af2b32..d8582918bb616a088e5d4ab683db6b4c9e3cd0d8 100644
--- a/src/handle_wrap.cc
+++ b/src/handle_wrap.cc
@@ -84,7 +84,23 @@ void HandleWrap::Close(Local<Value> close_callback) {
 
 
 void HandleWrap::OnGCCollect() {
-  Close();
+  // When all references to a HandleWrap are lost and the object is supposed to
+  // be destroyed, we first call Close() to clean up the underlying libuv
+  // handle. The OnClose callback then acquires and destroys another reference
+  // to that object, and when that reference is lost, we perform the default
+  // action (i.e. destroying `this`).
+  if (state_ != kClosed) {
+    Close();
+  } else {
+    BaseObject::OnGCCollect();
+  }
+}
+
+
+bool HandleWrap::IsNotIndicativeOfMemoryLeakAtExit() const {
+  return IsWeakOrDetached() ||
+         !HandleWrap::HasRef(this) ||
+         !uv_is_active(GetHandle());
 }
 
 
diff --git a/src/handle_wrap.h b/src/handle_wrap.h
index a555da9479de93a4fa85852940d6dd5fc8a3413c..560b2e718176faeced539defc305f601879a2164 100644
--- a/src/handle_wrap.h
+++ b/src/handle_wrap.h
@@ -85,6 +85,7 @@ class HandleWrap : public AsyncWrap {
              AsyncWrap::ProviderType provider);
   virtual void OnClose() {}
   void OnGCCollect() final;
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override;
 
   void MarkAsInitialized();
   void MarkAsUninitialized();
diff --git a/src/heap_utils.cc b/src/heap_utils.cc
index 386bf61e4eca001a2ad33a3dc5d18d7d7e362512..71bfd59ac3ea69f8a8def41cc32c74c515302021 100644
--- a/src/heap_utils.cc
+++ b/src/heap_utils.cc
@@ -118,8 +118,7 @@ class JSGraph : public EmbedderGraph {
           name_str += " ";
           name_str += n->Name();
         }
-        if (!String::NewFromUtf8(
-                 isolate_, name_str.c_str(), v8::NewStringType::kNormal)
+        if (!String::NewFromUtf8(isolate_, name_str.c_str())
                  .ToLocal(&value) ||
             obj->Set(context, name_string, value).IsNothing() ||
             obj->Set(context,
@@ -168,9 +167,8 @@ class JSGraph : public EmbedderGraph {
         Local<Value> edge_name_value;
         const char* edge_name = edge.first;
         if (edge_name != nullptr) {
-          if (!String::NewFromUtf8(
-                  isolate_, edge_name, v8::NewStringType::kNormal)
-                  .ToLocal(&edge_name_value)) {
+          if (!String::NewFromUtf8(isolate_, edge_name)
+              .ToLocal(&edge_name_value)) {
             return MaybeLocal<Array>();
           }
         } else {
@@ -315,7 +313,9 @@ inline void TakeSnapshot(Isolate* isolate, v8::OutputStream* out) {
   snapshot->Serialize(out, HeapSnapshot::kJSON);
 }
 
-inline bool WriteSnapshot(Isolate* isolate, const char* filename) {
+}  // namespace
+
+bool WriteSnapshot(Isolate* isolate, const char* filename) {
   FILE* fp = fopen(filename, "w");
   if (fp == nullptr)
     return false;
@@ -325,8 +325,6 @@ inline bool WriteSnapshot(Isolate* isolate, const char* filename) {
   return true;
 }
 
-}  // namespace
-
 void DeleteHeapSnapshot(const HeapSnapshot* snapshot) {
   const_cast<HeapSnapshot*>(snapshot)->Delete();
 }
@@ -377,8 +375,7 @@ void TriggerHeapSnapshot(const FunctionCallbackInfo<Value>& args) {
     DiagnosticFilename name(env, "Heap", "heapsnapshot");
     if (!WriteSnapshot(isolate, *name))
       return;
-    if (String::NewFromUtf8(isolate, *name, v8::NewStringType::kNormal)
-            .ToLocal(&filename_v)) {
+    if (String::NewFromUtf8(isolate, *name).ToLocal(&filename_v)) {
       args.GetReturnValue().Set(filename_v);
     }
     return;
diff --git a/src/histogram-inl.h b/src/histogram-inl.h
index 58911dae8f2daed9a6ed0618d107bfb60f27852a..18a1668512e1ce0fc733ed5be810a1aaf73d38ce 100644
--- a/src/histogram-inl.h
+++ b/src/histogram-inl.h
@@ -10,30 +10,34 @@
 namespace node {
 
 void Histogram::Reset() {
+  Mutex::ScopedLock lock(mutex_);
   hdr_reset(histogram_.get());
-}
-
-bool Histogram::Record(int64_t value) {
-  return hdr_record_value(histogram_.get(), value);
+  exceeds_ = 0;
+  prev_ = 0;
 }
 
 int64_t Histogram::Min() {
+  Mutex::ScopedLock lock(mutex_);
   return hdr_min(histogram_.get());
 }
 
 int64_t Histogram::Max() {
+  Mutex::ScopedLock lock(mutex_);
   return hdr_max(histogram_.get());
 }
 
 double Histogram::Mean() {
+  Mutex::ScopedLock lock(mutex_);
   return hdr_mean(histogram_.get());
 }
 
 double Histogram::Stddev() {
+  Mutex::ScopedLock lock(mutex_);
   return hdr_stddev(histogram_.get());
 }
 
 double Histogram::Percentile(double percentile) {
+  Mutex::ScopedLock lock(mutex_);
   CHECK_GT(percentile, 0);
   CHECK_LE(percentile, 100);
   return static_cast<double>(
@@ -42,6 +46,7 @@ double Histogram::Percentile(double percentile) {
 
 template <typename Iterator>
 void Histogram::Percentiles(Iterator&& fn) {
+  Mutex::ScopedLock lock(mutex_);
   hdr_iter iter;
   hdr_iter_percentile_init(&iter, histogram_.get(), 1);
   while (hdr_iter_next(&iter)) {
@@ -51,29 +56,29 @@ void Histogram::Percentiles(Iterator&& fn) {
   }
 }
 
-bool HistogramBase::RecordDelta() {
+bool Histogram::Record(int64_t value) {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_record_value(histogram_.get(), value);
+}
+
+uint64_t Histogram::RecordDelta() {
+  Mutex::ScopedLock lock(mutex_);
   uint64_t time = uv_hrtime();
-  bool ret = true;
+  uint64_t delta = 0;
   if (prev_ > 0) {
-    int64_t delta = time - prev_;
+    delta = time - prev_;
     if (delta > 0) {
-      ret = Record(delta);
-      TraceDelta(delta);
-      if (!ret) {
-        if (exceeds_ < 0xFFFFFFFF)
-          exceeds_++;
-        TraceExceeds(delta);
-      }
+      if (!hdr_record_value(histogram_.get(), delta) && exceeds_ < 0xFFFFFFFF)
+        exceeds_++;
     }
   }
   prev_ = time;
-  return ret;
+  return delta;
 }
 
-void HistogramBase::ResetState() {
-  Reset();
-  exceeds_ = 0;
-  prev_ = 0;
+size_t Histogram::GetMemorySize() const {
+  Mutex::ScopedLock lock(mutex_);
+  return hdr_get_memory_size(histogram_.get());
 }
 
 }  // namespace node
diff --git a/src/histogram.cc b/src/histogram.cc
index 8d1eb77b1bc88e7347bc893ce6707a0ddb8256f0..d21cf2883a0ca834c16e65213856954531dd6417 100644
--- a/src/histogram.cc
+++ b/src/histogram.cc
@@ -1,15 +1,17 @@
 #include "histogram.h"  // NOLINT(build/include_inline)
 #include "histogram-inl.h"
+#include "base_object-inl.h"
 #include "memory_tracker-inl.h"
-
+#include "node_errors.h"
 namespace node {
 
+using v8::BigInt;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Local;
 using v8::Map;
 using v8::Number;
-using v8::ObjectTemplate;
+using v8::Object;
 using v8::String;
 using v8::Value;
 
@@ -19,71 +21,88 @@ Histogram::Histogram(int64_t lowest, int64_t highest, int figures) {
   histogram_.reset(histogram);
 }
 
+void Histogram::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("histogram", GetMemorySize());
+}
+
+HistogramImpl::HistogramImpl(int64_t lowest, int64_t highest, int figures)
+    : histogram_(new Histogram(lowest, highest, figures)) {}
+
+HistogramImpl::HistogramImpl(std::shared_ptr<Histogram> histogram)
+    : histogram_(std::move(histogram)) {}
+
 HistogramBase::HistogramBase(
     Environment* env,
-    v8::Local<v8::Object> wrap,
+    Local<Object> wrap,
     int64_t lowest,
     int64_t highest,
     int figures)
     : BaseObject(env, wrap),
-      Histogram(lowest, highest, figures) {
+      HistogramImpl(lowest, highest, figures) {
+  MakeWeak();
+}
+
+HistogramBase::HistogramBase(
+    Environment* env,
+    Local<Object> wrap,
+    std::shared_ptr<Histogram> histogram)
+    : BaseObject(env, wrap),
+      HistogramImpl(std::move(histogram)) {
   MakeWeak();
 }
 
 void HistogramBase::MemoryInfo(MemoryTracker* tracker) const {
-  tracker->TrackFieldWithSize("histogram", GetMemorySize());
+  tracker->TrackField("histogram", histogram());
 }
 
 void HistogramBase::GetMin(const FunctionCallbackInfo<Value>& args) {
   HistogramBase* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Min());
+  double value = static_cast<double>((*histogram)->Min());
   args.GetReturnValue().Set(value);
 }
 
 void HistogramBase::GetMax(const FunctionCallbackInfo<Value>& args) {
   HistogramBase* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Max());
+  double value = static_cast<double>((*histogram)->Max());
   args.GetReturnValue().Set(value);
 }
 
 void HistogramBase::GetMean(const FunctionCallbackInfo<Value>& args) {
   HistogramBase* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Mean());
+  args.GetReturnValue().Set((*histogram)->Mean());
 }
 
 void HistogramBase::GetExceeds(const FunctionCallbackInfo<Value>& args) {
   HistogramBase* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Exceeds());
+  double value = static_cast<double>((*histogram)->Exceeds());
   args.GetReturnValue().Set(value);
 }
 
 void HistogramBase::GetStddev(const FunctionCallbackInfo<Value>& args) {
   HistogramBase* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Stddev());
+  args.GetReturnValue().Set((*histogram)->Stddev());
 }
 
-void HistogramBase::GetPercentile(
-    const FunctionCallbackInfo<Value>& args) {
+void HistogramBase::GetPercentile(const FunctionCallbackInfo<Value>& args) {
   HistogramBase* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
   CHECK(args[0]->IsNumber());
   double percentile = args[0].As<Number>()->Value();
-  args.GetReturnValue().Set(histogram->Percentile(percentile));
+  args.GetReturnValue().Set((*histogram)->Percentile(percentile));
 }
 
-void HistogramBase::GetPercentiles(
-    const FunctionCallbackInfo<Value>& args) {
+void HistogramBase::GetPercentiles(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   HistogramBase* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
   CHECK(args[0]->IsMap());
   Local<Map> map = args[0].As<Map>();
-  histogram->Percentiles([map, env](double key, double value) {
+  (*histogram)->Percentiles([map, env](double key, double value) {
     map->Set(
         env->context(),
         Number::New(env->isolate(), key),
@@ -94,48 +113,254 @@ void HistogramBase::GetPercentiles(
 void HistogramBase::DoReset(const FunctionCallbackInfo<Value>& args) {
   HistogramBase* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  histogram->ResetState();
+  (*histogram)->Reset();
+}
+
+void HistogramBase::RecordDelta(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  (*histogram)->RecordDelta();
 }
 
-BaseObjectPtr<HistogramBase> HistogramBase::New(
+void HistogramBase::Record(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK_IMPLIES(!args[0]->IsNumber(), args[0]->IsBigInt());
+  bool lossless = true;
+  int64_t value = args[0]->IsBigInt()
+      ? args[0].As<BigInt>()->Int64Value(&lossless)
+      : static_cast<int64_t>(args[0].As<Number>()->Value());
+  if (!lossless || value < 1)
+    return THROW_ERR_OUT_OF_RANGE(env, "value is out of range");
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  (*histogram)->Record(value);
+}
+
+BaseObjectPtr<HistogramBase> HistogramBase::Create(
     Environment* env,
     int64_t lowest,
     int64_t highest,
     int figures) {
-  CHECK_LE(lowest, highest);
-  CHECK_GT(figures, 0);
-  v8::Local<v8::Object> obj;
-  auto tmpl = env->histogram_instance_template();
-  if (!tmpl->NewInstance(env->context()).ToLocal(&obj))
-    return {};
-
-  return MakeDetachedBaseObject<HistogramBase>(
+  Local<Object> obj;
+  if (!GetConstructorTemplate(env)
+          ->InstanceTemplate()
+          ->NewInstance(env->context()).ToLocal(&obj)) {
+    return BaseObjectPtr<HistogramBase>();
+  }
+
+  return MakeBaseObject<HistogramBase>(
       env, obj, lowest, highest, figures);
 }
 
-void HistogramBase::Initialize(Environment* env) {
-  // Guard against multiple initializations
-  if (!env->histogram_instance_template().IsEmpty())
-    return;
+BaseObjectPtr<HistogramBase> HistogramBase::Create(
+    Environment* env,
+    std::shared_ptr<Histogram> histogram) {
+  Local<Object> obj;
+  if (!GetConstructorTemplate(env)
+          ->InstanceTemplate()
+          ->NewInstance(env->context()).ToLocal(&obj)) {
+    return BaseObjectPtr<HistogramBase>();
+  }
+  return MakeBaseObject<HistogramBase>(env, obj, std::move(histogram));
+}
+
+void HistogramBase::New(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args.IsConstructCall());
+  Environment* env = Environment::GetCurrent(args);
+  new HistogramBase(env, args.This());
+}
+
+Local<FunctionTemplate> HistogramBase::GetConstructorTemplate(
+    Environment* env) {
+  Local<FunctionTemplate> tmpl = env->histogram_ctor_template();
+  if (tmpl.IsEmpty()) {
+    tmpl = env->NewFunctionTemplate(New);
+    Local<String> classname =
+        FIXED_ONE_BYTE_STRING(env->isolate(), "Histogram");
+    tmpl->SetClassName(classname);
+    tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
+
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        HistogramBase::kInternalFieldCount);
+    env->SetProtoMethodNoSideEffect(tmpl, "exceeds", GetExceeds);
+    env->SetProtoMethodNoSideEffect(tmpl, "min", GetMin);
+    env->SetProtoMethodNoSideEffect(tmpl, "max", GetMax);
+    env->SetProtoMethodNoSideEffect(tmpl, "mean", GetMean);
+    env->SetProtoMethodNoSideEffect(tmpl, "stddev", GetStddev);
+    env->SetProtoMethodNoSideEffect(tmpl, "percentile", GetPercentile);
+    env->SetProtoMethodNoSideEffect(tmpl, "percentiles", GetPercentiles);
+    env->SetProtoMethod(tmpl, "reset", DoReset);
+    env->SetProtoMethod(tmpl, "record", Record);
+    env->SetProtoMethod(tmpl, "recordDelta", RecordDelta);
+    env->set_histogram_ctor_template(tmpl);
+  }
+  return tmpl;
+}
+
+void HistogramBase::Initialize(Environment* env, Local<Object> target) {
+  env->SetConstructorFunction(target, "Histogram", GetConstructorTemplate(env));
+}
+
+BaseObjectPtr<BaseObject> HistogramBase::HistogramTransferData::Deserialize(
+    Environment* env,
+    v8::Local<v8::Context> context,
+    std::unique_ptr<worker::TransferData> self) {
+  return Create(env, std::move(histogram_));
+}
+
+std::unique_ptr<worker::TransferData> HistogramBase::CloneForMessaging() const {
+  return std::make_unique<HistogramTransferData>(this);
+}
+
+void HistogramBase::HistogramTransferData::MemoryInfo(
+    MemoryTracker* tracker) const {
+  tracker->TrackField("histogram", histogram_);
+}
+
+Local<FunctionTemplate> IntervalHistogram::GetConstructorTemplate(
+    Environment* env) {
+  Local<FunctionTemplate> tmpl = env->intervalhistogram_constructor_template();
+  if (tmpl.IsEmpty()) {
+    tmpl = FunctionTemplate::New(env->isolate());
+    tmpl->Inherit(HandleWrap::GetConstructorTemplate(env));
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        HistogramBase::kInternalFieldCount);
+    env->SetProtoMethodNoSideEffect(tmpl, "exceeds", GetExceeds);
+    env->SetProtoMethodNoSideEffect(tmpl, "min", GetMin);
+    env->SetProtoMethodNoSideEffect(tmpl, "max", GetMax);
+    env->SetProtoMethodNoSideEffect(tmpl, "mean", GetMean);
+    env->SetProtoMethodNoSideEffect(tmpl, "stddev", GetStddev);
+    env->SetProtoMethodNoSideEffect(tmpl, "percentile", GetPercentile);
+    env->SetProtoMethodNoSideEffect(tmpl, "percentiles", GetPercentiles);
+    env->SetProtoMethod(tmpl, "reset", DoReset);
+    env->SetProtoMethod(tmpl, "start", Start);
+    env->SetProtoMethod(tmpl, "stop", Stop);
+    env->set_intervalhistogram_constructor_template(tmpl);
+  }
+  return tmpl;
+}
+
+IntervalHistogram::IntervalHistogram(
+    Environment* env,
+    Local<Object> wrap,
+    AsyncWrap::ProviderType type,
+    int32_t interval,
+    int64_t lowest,
+    int64_t highest,
+    int figures)
+    : HandleWrap(
+          env,
+          wrap,
+          reinterpret_cast<uv_handle_t*>(&timer_),
+          type),
+      HistogramImpl(lowest, highest, figures),
+      interval_(interval) {
+  MakeWeak();
+  uv_timer_init(env->event_loop(), &timer_);
+}
+
+void IntervalHistogram::TimerCB(uv_timer_t* handle) {
+  IntervalHistogram* histogram =
+      ContainerOf(&IntervalHistogram::timer_, handle);
+  histogram->OnInterval();
+}
+
+void IntervalHistogram::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("histogram", histogram());
+}
+
+void IntervalHistogram::OnStart(StartFlags flags) {
+  if (enabled_ || IsHandleClosing()) return;
+  enabled_ = true;
+  if (flags == StartFlags::RESET)
+    histogram()->Reset();
+  uv_timer_start(&timer_, TimerCB, interval_, interval_);
+  uv_unref(reinterpret_cast<uv_handle_t*>(&timer_));
+}
+
+void IntervalHistogram::OnStop() {
+  if (!enabled_ || IsHandleClosing()) return;
+  enabled_ = false;
+  uv_timer_stop(&timer_);
+}
+
+void IntervalHistogram::Start(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  histogram->OnStart(args[0]->IsTrue() ? StartFlags::RESET : StartFlags::NONE);
+}
+
+void IntervalHistogram::Stop(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  histogram->OnStop();
+}
+
+void IntervalHistogram::GetMin(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>((*histogram)->Min());
+  args.GetReturnValue().Set(value);
+}
+
+void IntervalHistogram::GetMax(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>((*histogram)->Max());
+  args.GetReturnValue().Set(value);
+}
+
+void IntervalHistogram::GetMean(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  args.GetReturnValue().Set((*histogram)->Mean());
+}
+
+void IntervalHistogram::GetExceeds(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>((*histogram)->Exceeds());
+  args.GetReturnValue().Set(value);
+}
 
-  Local<FunctionTemplate> histogram = FunctionTemplate::New(env->isolate());
-  Local<String> classname = FIXED_ONE_BYTE_STRING(env->isolate(), "Histogram");
-  histogram->SetClassName(classname);
+void IntervalHistogram::GetStddev(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  args.GetReturnValue().Set((*histogram)->Stddev());
+}
 
-  Local<ObjectTemplate> histogramt =
-    histogram->InstanceTemplate();
+void IntervalHistogram::GetPercentile(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  CHECK(args[0]->IsNumber());
+  double percentile = args[0].As<Number>()->Value();
+  args.GetReturnValue().Set((*histogram)->Percentile(percentile));
+}
 
-  histogramt->SetInternalFieldCount(1);
-  env->SetProtoMethod(histogram, "exceeds", HistogramBase::GetExceeds);
-  env->SetProtoMethod(histogram, "min", HistogramBase::GetMin);
-  env->SetProtoMethod(histogram, "max", HistogramBase::GetMax);
-  env->SetProtoMethod(histogram, "mean", HistogramBase::GetMean);
-  env->SetProtoMethod(histogram, "stddev", HistogramBase::GetStddev);
-  env->SetProtoMethod(histogram, "percentile", HistogramBase::GetPercentile);
-  env->SetProtoMethod(histogram, "percentiles", HistogramBase::GetPercentiles);
-  env->SetProtoMethod(histogram, "reset", HistogramBase::DoReset);
+void IntervalHistogram::GetPercentiles(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  CHECK(args[0]->IsMap());
+  Local<Map> map = args[0].As<Map>();
+  (*histogram)->Percentiles([map, env](double key, double value) {
+    map->Set(
+        env->context(),
+        Number::New(env->isolate(), key),
+        Number::New(env->isolate(), value)).IsEmpty();
+  });
+}
+
+void IntervalHistogram::DoReset(const FunctionCallbackInfo<Value>& args) {
+  IntervalHistogram* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  (*histogram)->Reset();
+}
 
-  env->set_histogram_instance_template(histogramt);
+std::unique_ptr<worker::TransferData>
+IntervalHistogram::CloneForMessaging() const {
+  return std::make_unique<HistogramBase::HistogramTransferData>(histogram());
 }
 
 }  // namespace node
diff --git a/src/histogram.h b/src/histogram.h
index e92c31c4724ac64107cdf2faa3a7172bf3cc55f3..8c164f54cfd9ed4fb16692313b1b10ff67044a94 100644
--- a/src/histogram.h
+++ b/src/histogram.h
@@ -5,20 +5,25 @@
 
 #include "hdr_histogram.h"
 #include "base_object.h"
+#include "memory_tracker.h"
+#include "node_messaging.h"
 #include "util.h"
+#include "v8.h"
+#include "uv.h"
 
 #include <functional>
 #include <limits>
 #include <map>
+#include <string>
 
 namespace node {
 
 constexpr int kDefaultHistogramFigures = 3;
 
-class Histogram {
+class Histogram : public MemoryRetainer {
  public:
   Histogram(
-      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      int64_t lowest = 1,
       int64_t highest = std::numeric_limits<int64_t>::max(),
       int figures = kDefaultHistogramFigures);
   virtual ~Histogram() = default;
@@ -30,32 +35,61 @@ class Histogram {
   inline double Mean();
   inline double Stddev();
   inline double Percentile(double percentile);
+  inline int64_t Exceeds() const { return exceeds_; }
+
+  inline uint64_t RecordDelta();
 
   // Iterator is a function type that takes two doubles as argument, one for
   // percentile and one for the value at that percentile.
   template <typename Iterator>
   inline void Percentiles(Iterator&& fn);
 
-  size_t GetMemorySize() const {
-    return hdr_get_memory_size(histogram_.get());
-  }
+  inline size_t GetMemorySize() const;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Histogram)
+  SET_SELF_SIZE(Histogram)
 
  private:
   using HistogramPointer = DeleteFnPtr<hdr_histogram, hdr_close>;
   HistogramPointer histogram_;
+  int64_t exceeds_ = 0;
+  uint64_t prev_ = 0;
+
+  Mutex mutex_;
 };
 
-class HistogramBase : public BaseObject, public Histogram {
+class HistogramImpl {
  public:
-  virtual ~HistogramBase() = default;
+  HistogramImpl(int64_t lowest, int64_t highest, int figures);
+  explicit HistogramImpl(std::shared_ptr<Histogram> histogram);
 
-  virtual void TraceDelta(int64_t delta) {}
-  virtual void TraceExceeds(int64_t delta) {}
+  Histogram* operator->() { return histogram_.get(); }
 
-  inline bool RecordDelta();
-  inline void ResetState();
+ protected:
+  const std::shared_ptr<Histogram>& histogram() const { return histogram_; }
 
-  int64_t Exceeds() const { return exceeds_; }
+ private:
+  std::shared_ptr<Histogram> histogram_;
+};
+
+class HistogramBase : public BaseObject, public HistogramImpl {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+    Environment* env);
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+
+  static BaseObjectPtr<HistogramBase> Create(
+      Environment* env,
+      int64_t lowest = 1,
+      int64_t highest = std::numeric_limits<int64_t>::max(),
+      int figures = kDefaultHistogramFigures);
+
+  static BaseObjectPtr<HistogramBase> Create(
+      Environment* env,
+      std::shared_ptr<Histogram> histogram);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(HistogramBase)
@@ -71,24 +105,103 @@ class HistogramBase : public BaseObject, public Histogram {
   static void GetPercentiles(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Initialize(Environment* env);
+  static void Record(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RecordDelta(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static BaseObjectPtr<HistogramBase> New(
+  HistogramBase(
       Environment* env,
-      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      v8::Local<v8::Object> wrap,
+      int64_t lowest = 1,
       int64_t highest = std::numeric_limits<int64_t>::max(),
       int figures = kDefaultHistogramFigures);
 
   HistogramBase(
       Environment* env,
       v8::Local<v8::Object> wrap,
-      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      std::shared_ptr<Histogram> histogram);
+
+  TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  class HistogramTransferData : public worker::TransferData {
+   public:
+    explicit HistogramTransferData(const HistogramBase* histogram)
+        : histogram_(histogram->histogram()) {}
+
+    explicit HistogramTransferData(std::shared_ptr<Histogram> histogram)
+        : histogram_(std::move(histogram)) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(HistogramTransferData)
+    SET_SELF_SIZE(HistogramTransferData)
+
+   private:
+    std::shared_ptr<Histogram> histogram_;
+  };
+};
+
+class IntervalHistogram : public HandleWrap, public HistogramImpl {
+ public:
+  enum class StartFlags {
+    NONE,
+    RESET
+  };
+
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  static BaseObjectPtr<IntervalHistogram> Create(
+      Environment* env,
+      int64_t lowest = 1,
+      int64_t highest = std::numeric_limits<int64_t>::max(),
+      int figures = kDefaultHistogramFigures);
+
+  virtual void OnInterval() = 0;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+
+  IntervalHistogram(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      AsyncWrap::ProviderType type,
+      int32_t interval,
+      int64_t lowest = 1,
       int64_t highest = std::numeric_limits<int64_t>::max(),
       int figures = kDefaultHistogramFigures);
 
+  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentile(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentiles(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
  private:
-  int64_t exceeds_ = 0;
-  uint64_t prev_ = 0;
+  static void TimerCB(uv_timer_t* handle);
+  void OnStart(StartFlags flags = StartFlags::RESET);
+  void OnStop();
+
+  bool enabled_ = false;
+  int32_t interval_ = 0;
+  uv_timer_t timer_;
 };
 
 }  // namespace node
diff --git a/src/http_parser_adaptor.h b/src/http_parser_adaptor.h
deleted file mode 100644
index 6d786bd09519b5d40705d1c9ff9fd012adb3d45d..0000000000000000000000000000000000000000
--- a/src/http_parser_adaptor.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef SRC_HTTP_PARSER_ADAPTOR_H_
-#define SRC_HTTP_PARSER_ADAPTOR_H_
-
-#ifdef NODE_EXPERIMENTAL_HTTP
-# include "llhttp.h"
-
-typedef llhttp_type_t parser_type_t;
-typedef llhttp_errno_t parser_errno_t;
-typedef llhttp_settings_t parser_settings_t;
-typedef llhttp_t parser_t;
-
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-# include "http_parser.h"
-
-typedef enum http_parser_type parser_type_t;
-typedef enum http_errno parser_errno_t;
-typedef http_parser_settings parser_settings_t;
-typedef http_parser parser_t;
-
-#define HPE_USER HPE_UNKNOWN
-
-#endif  /* NODE_EXPERIMENTAL_HTTP */
-
-#endif  /* SRC_HTTP_PARSER_ADAPTOR_H_ */
diff --git a/src/inspector/main_thread_interface.cc b/src/inspector/main_thread_interface.cc
index a15cd52d239e4089394c8e0738a4eaaf7d507ee7..0cf75a3714672915dd747f63974cd8decb41e8c5 100644
--- a/src/inspector/main_thread_interface.cc
+++ b/src/inspector/main_thread_interface.cc
@@ -14,8 +14,8 @@ namespace node {
 namespace inspector {
 namespace {
 
-using v8_inspector::StringView;
 using v8_inspector::StringBuffer;
+using v8_inspector::StringView;
 
 template <typename T>
 class DeletableWrapper : public Deletable {
diff --git a/src/inspector/node_string.cc b/src/inspector/node_string.cc
index 0d403c66f0197b908d2d0bb172821ba43fc87687..4cb8b573cc1312e67285e57ecc2d40c18e057a66 100644
--- a/src/inspector/node_string.cc
+++ b/src/inspector/node_string.cc
@@ -71,14 +71,14 @@ String StringViewToUtf8(v8_inspector::StringView view) {
 
 String fromDouble(double d) {
   std::ostringstream stream;
-  stream.imbue(std::locale("C"));  // Ignore locale
+  stream.imbue(std::locale::classic());  // Ignore current locale
   stream << d;
   return stream.str();
 }
 
 double toDouble(const char* buffer, size_t length, bool* ok) {
   std::istringstream stream(std::string(buffer, length));
-  stream.imbue(std::locale("C"));  // Ignore locale
+  stream.imbue(std::locale::classic());  // Ignore current locale
   double d;
   stream >> d;
   *ok = !stream.fail();
diff --git a/src/inspector/worker_inspector.cc b/src/inspector/worker_inspector.cc
index deeddcc0836dd1f6fee527c4b8b3a02467ed3022..ff292ea4422b198a3053c95928d2a8c9bbfc2b56 100644
--- a/src/inspector/worker_inspector.cc
+++ b/src/inspector/worker_inspector.cc
@@ -11,7 +11,7 @@ namespace {
 class WorkerStartedRequest : public Request {
  public:
   WorkerStartedRequest(
-      int id,
+      uint64_t id,
       const std::string& url,
       std::shared_ptr<node::inspector::MainThreadHandle> worker_thread,
       bool waiting)
@@ -28,7 +28,7 @@ class WorkerStartedRequest : public Request {
     return "Worker " + std::to_string(id);
   }
 
-  int id_;
+  uint64_t id_;
   WorkerInfo info_;
   bool waiting_;
 };
@@ -42,22 +42,25 @@ void Report(const std::unique_ptr<WorkerDelegate>& delegate,
 
 class WorkerFinishedRequest : public Request {
  public:
-  explicit WorkerFinishedRequest(int worker_id) : worker_id_(worker_id) {}
+  explicit WorkerFinishedRequest(uint64_t worker_id) : worker_id_(worker_id) {}
 
   void Call(MainThreadInterface* thread) override {
     thread->inspector_agent()->GetWorkerManager()->WorkerFinished(worker_id_);
   }
 
  private:
-  int worker_id_;
+  uint64_t worker_id_;
 };
 }  // namespace
 
-
 ParentInspectorHandle::ParentInspectorHandle(
-    int id, const std::string& url,
-    std::shared_ptr<MainThreadHandle> parent_thread, bool wait_for_connect)
-    : id_(id), url_(url), parent_thread_(parent_thread),
+    uint64_t id,
+    const std::string& url,
+    std::shared_ptr<MainThreadHandle> parent_thread,
+    bool wait_for_connect)
+    : id_(id),
+      url_(url),
+      parent_thread_(parent_thread),
       wait_(wait_for_connect) {}
 
 ParentInspectorHandle::~ParentInspectorHandle() {
@@ -78,11 +81,11 @@ std::unique_ptr<inspector::InspectorSession> ParentInspectorHandle::Connect(
   return parent_thread_->Connect(std::move(delegate), prevent_shutdown);
 }
 
-void WorkerManager::WorkerFinished(int session_id) {
+void WorkerManager::WorkerFinished(uint64_t session_id) {
   children_.erase(session_id);
 }
 
-void WorkerManager::WorkerStarted(int session_id,
+void WorkerManager::WorkerStarted(uint64_t session_id,
                                   const WorkerInfo& info,
                                   bool waiting) {
   if (info.worker_thread->Expired())
@@ -93,8 +96,8 @@ void WorkerManager::WorkerStarted(int session_id,
   }
 }
 
-std::unique_ptr<ParentInspectorHandle>
-WorkerManager::NewParentHandle(int thread_id, const std::string& url) {
+std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
+    uint64_t thread_id, const std::string& url) {
   bool wait = !delegates_waiting_on_start_.empty();
   return std::make_unique<ParentInspectorHandle>(thread_id, url, thread_, wait);
 }
diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
index b01063e01fc890f5afba90ecab61d601cbb4d337..540d98c742fe057f53ed5ff825d056081e27808e 100644
--- a/src/inspector/worker_inspector.h
+++ b/src/inspector/worker_inspector.h
@@ -53,12 +53,13 @@ struct WorkerInfo {
 
 class ParentInspectorHandle {
  public:
-  ParentInspectorHandle(int id, const std::string& url,
+  ParentInspectorHandle(uint64_t id,
+                        const std::string& url,
                         std::shared_ptr<MainThreadHandle> parent_thread,
                         bool wait_for_connect);
   ~ParentInspectorHandle();
   std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
-      int thread_id, const std::string& url) {
+      uint64_t thread_id, const std::string& url) {
     return std::make_unique<ParentInspectorHandle>(thread_id,
                                                    url,
                                                    parent_thread_,
@@ -75,7 +76,7 @@ class ParentInspectorHandle {
       bool prevent_shutdown);
 
  private:
-  int id_;
+  uint64_t id_;
   std::string url_;
   std::shared_ptr<MainThreadHandle> parent_thread_;
   bool wait_;
@@ -87,9 +88,9 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
                          : thread_(thread) {}
 
   std::unique_ptr<ParentInspectorHandle> NewParentHandle(
-      int thread_id, const std::string& url);
-  void WorkerStarted(int session_id, const WorkerInfo& info, bool waiting);
-  void WorkerFinished(int session_id);
+      uint64_t thread_id, const std::string& url);
+  void WorkerStarted(uint64_t session_id, const WorkerInfo& info, bool waiting);
+  void WorkerFinished(uint64_t session_id);
   std::unique_ptr<WorkerManagerEventHandle> SetAutoAttach(
       std::unique_ptr<WorkerDelegate> attach_delegate);
   void SetWaitOnStartForDelegate(int id, bool wait);
@@ -100,7 +101,7 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
 
  private:
   std::shared_ptr<MainThreadHandle> thread_;
-  std::unordered_map<int, WorkerInfo> children_;
+  std::unordered_map<uint64_t, WorkerInfo> children_;
   std::unordered_map<int, std::unique_ptr<WorkerDelegate>> delegates_;
   // If any one needs it, workers stop for all
   std::unordered_set<int> delegates_waiting_on_start_;
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index 26101fe0e13b5e7d42233d318f385c57fe77c14e..cd2ff5617539e3ce70f587f1a8e95bcccb69038a 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -12,9 +12,10 @@
 #include "node_errors.h"
 #include "node_internals.h"
 #include "node_options-inl.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "node_url.h"
 #include "util-inl.h"
+#include "timer_wrap.h"
 #include "v8-inspector.h"
 #include "v8-platform.h"
 
@@ -39,14 +40,13 @@ using node::FatalError;
 
 using v8::Context;
 using v8::Function;
-using v8::Global;
 using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
 using v8::Message;
 using v8::Object;
-using v8::Task;
 using v8::Value;
+
 using v8_inspector::StringBuffer;
 using v8_inspector::StringView;
 using v8_inspector::V8Inspector;
@@ -73,7 +73,7 @@ void StartIoThreadAsyncCallback(uv_async_t* handle) {
 
 
 #ifdef __POSIX__
-static void StartIoThreadWakeup(int signo) {
+static void StartIoThreadWakeup(int signo, siginfo_t* info, void* ucontext) {
   uv_sem_post(&start_io_thread_semaphore);
 }
 
@@ -326,86 +326,6 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   bool retaining_context_;
 };
 
-class InspectorTimer {
- public:
-  InspectorTimer(Environment* env,
-                 double interval_s,
-                 V8InspectorClient::TimerCallback callback,
-                 void* data) : env_(env),
-                               callback_(callback),
-                               data_(data) {
-    uv_timer_init(env->event_loop(), &timer_);
-    int64_t interval_ms = 1000 * interval_s;
-    uv_timer_start(&timer_, OnTimer, interval_ms, interval_ms);
-    timer_.data = this;
-  }
-
-  InspectorTimer(const InspectorTimer&) = delete;
-
-  void Stop() {
-    if (timer_.data == nullptr) return;
-
-    timer_.data = nullptr;
-    uv_timer_stop(&timer_);
-    env_->CloseHandle(reinterpret_cast<uv_handle_t*>(&timer_), TimerClosedCb);
-  }
-
-  inline Environment* env() const { return env_; }
-
- private:
-  static void OnTimer(uv_timer_t* uvtimer) {
-    InspectorTimer* timer = node::ContainerOf(&InspectorTimer::timer_, uvtimer);
-    timer->callback_(timer->data_);
-  }
-
-  static void TimerClosedCb(uv_handle_t* uvtimer) {
-    std::unique_ptr<InspectorTimer> timer(
-        node::ContainerOf(&InspectorTimer::timer_,
-                          reinterpret_cast<uv_timer_t*>(uvtimer)));
-    // Unique_ptr goes out of scope here and pointer is deleted.
-  }
-
-  ~InspectorTimer() = default;
-
-  Environment* env_;
-  uv_timer_t timer_;
-  V8InspectorClient::TimerCallback callback_;
-  void* data_;
-
-  friend std::unique_ptr<InspectorTimer>::deleter_type;
-};
-
-class InspectorTimerHandle {
- public:
-  InspectorTimerHandle(Environment* env, double interval_s,
-                       V8InspectorClient::TimerCallback callback, void* data) {
-    timer_ = new InspectorTimer(env, interval_s, callback, data);
-
-    env->AddCleanupHook(CleanupHook, this);
-  }
-
-  InspectorTimerHandle(const InspectorTimerHandle&) = delete;
-
-  ~InspectorTimerHandle() {
-    Stop();
-  }
-
- private:
-  void Stop() {
-    if (timer_ != nullptr) {
-      timer_->env()->RemoveCleanupHook(CleanupHook, this);
-      timer_->Stop();
-    }
-    timer_ = nullptr;
-  }
-
-  static void CleanupHook(void* data) {
-    static_cast<InspectorTimerHandle*>(data)->Stop();
-  }
-
-  InspectorTimer* timer_;
-};
-
 class SameThreadInspectorSession : public InspectorSession {
  public:
   SameThreadInspectorSession(
@@ -602,9 +522,12 @@ class NodeInspectorClient : public V8InspectorClient {
   void startRepeatingTimer(double interval_s,
                            TimerCallback callback,
                            void* data) override {
-    timers_.emplace(std::piecewise_construct, std::make_tuple(data),
-                    std::make_tuple(env_, interval_s, callback,
-                                    data));
+    auto result =
+        timers_.emplace(std::piecewise_construct, std::make_tuple(data),
+                        std::make_tuple(env_, [=]() { callback(data); }));
+    CHECK(result.second);
+    uint64_t interval = static_cast<uint64_t>(1000 * interval_s);
+    result.first->second.Update(interval, interval);
   }
 
   void cancelTimer(void* data) override {
@@ -724,7 +647,7 @@ class NodeInspectorClient : public V8InspectorClient {
   bool running_nested_loop_ = false;
   std::unique_ptr<V8Inspector> client_;
   // Note: ~ChannelImpl may access timers_ so timers_ has to come first.
-  std::unordered_map<void*, InspectorTimerHandle> timers_;
+  std::unordered_map<void*, TimerWrapHandle> timers_;
   std::unordered_map<int, std::unique_ptr<ChannelImpl>> channels_;
   int next_session_id_ = 1;
   bool waiting_for_resume_ = false;
@@ -880,8 +803,8 @@ void Agent::PauseOnNextJavascriptStatement(const std::string& reason) {
 void Agent::RegisterAsyncHook(Isolate* isolate,
                               Local<Function> enable_function,
                               Local<Function> disable_function) {
-  enable_async_hook_function_.Reset(isolate, enable_function);
-  disable_async_hook_function_.Reset(isolate, disable_function);
+  parent_env_->set_inspector_enable_async_hooks(enable_function);
+  parent_env_->set_inspector_disable_async_hooks(disable_function);
   if (pending_enable_async_hook_) {
     CHECK(!pending_disable_async_hook_);
     pending_enable_async_hook_ = false;
@@ -894,8 +817,10 @@ void Agent::RegisterAsyncHook(Isolate* isolate,
 }
 
 void Agent::EnableAsyncHook() {
-  if (!enable_async_hook_function_.IsEmpty()) {
-    ToggleAsyncHook(parent_env_->isolate(), enable_async_hook_function_);
+  HandleScope scope(parent_env_->isolate());
+  Local<Function> enable = parent_env_->inspector_enable_async_hooks();
+  if (!enable.IsEmpty()) {
+    ToggleAsyncHook(parent_env_->isolate(), enable);
   } else if (pending_disable_async_hook_) {
     CHECK(!pending_enable_async_hook_);
     pending_disable_async_hook_ = false;
@@ -905,8 +830,10 @@ void Agent::EnableAsyncHook() {
 }
 
 void Agent::DisableAsyncHook() {
-  if (!disable_async_hook_function_.IsEmpty()) {
-    ToggleAsyncHook(parent_env_->isolate(), disable_async_hook_function_);
+  HandleScope scope(parent_env_->isolate());
+  Local<Function> disable = parent_env_->inspector_enable_async_hooks();
+  if (!disable.IsEmpty()) {
+    ToggleAsyncHook(parent_env_->isolate(), disable);
   } else if (pending_enable_async_hook_) {
     CHECK(!pending_disable_async_hook_);
     pending_enable_async_hook_ = false;
@@ -915,8 +842,7 @@ void Agent::DisableAsyncHook() {
   }
 }
 
-void Agent::ToggleAsyncHook(Isolate* isolate,
-                            const Global<Function>& fn) {
+void Agent::ToggleAsyncHook(Isolate* isolate, Local<Function> fn) {
   // Guard against running this during cleanup -- no async events will be
   // emitted anyway at that point anymore, and calling into JS is not possible.
   // This should probably not be something we're attempting in the first place,
@@ -927,7 +853,7 @@ void Agent::ToggleAsyncHook(Isolate* isolate,
   CHECK(!fn.IsEmpty());
   auto context = parent_env_->context();
   v8::TryCatch try_catch(isolate);
-  USE(fn.Get(isolate)->Call(context, Undefined(isolate), 0, nullptr));
+  USE(fn->Call(context, Undefined(isolate), 0, nullptr));
   if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
     PrintCaughtException(isolate, context, try_catch);
     FatalError("\nnode::inspector::Agent::ToggleAsyncHook",
@@ -976,13 +902,6 @@ void Agent::ContextCreated(Local<Context> context, const ContextInfo& info) {
   client_->contextCreated(context, info);
 }
 
-bool Agent::WillWaitForConnect() {
-  if (debug_options_.wait_for_connect()) return true;
-  if (parent_handle_)
-    return parent_handle_->WaitForConnect();
-  return false;
-}
-
 bool Agent::IsActive() {
   if (client_ == nullptr)
     return false;
@@ -995,7 +914,7 @@ void Agent::SetParentHandle(
 }
 
 std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
-    int thread_id, const std::string& url) {
+    uint64_t thread_id, const std::string& url) {
   if (!parent_handle_) {
     return client_->getWorkerManager()->NewParentHandle(thread_id, url);
   } else {
diff --git a/src/inspector_agent.h b/src/inspector_agent.h
index efd090c49b4311bcf3d8b717d6e5c65553849aed..744e139df8f87a796a7294d3f56d8ca4c97cf068 100644
--- a/src/inspector_agent.h
+++ b/src/inspector_agent.h
@@ -59,8 +59,6 @@ class Agent {
   // --inspect command line flag) or if inspector JS API had been used.
   bool IsActive();
 
-  // Option is set to wait for session connection
-  bool WillWaitForConnect();
   // Blocks till frontend connects and sends "runIfWaitingForDebugger"
   void WaitForConnect();
   // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
@@ -84,7 +82,7 @@ class Agent {
 
   void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
   std::unique_ptr<ParentInspectorHandle> GetParentHandle(
-      int thread_id, const std::string& url);
+      uint64_t thread_id, const std::string& url);
 
   // Called to create inspector sessions that can be used from the same thread.
   // The inspector responds by using the delegate to send messages back.
@@ -119,8 +117,7 @@ class Agent {
   inline Environment* env() const { return parent_env_; }
 
  private:
-  void ToggleAsyncHook(v8::Isolate* isolate,
-                       const v8::Global<v8::Function>& fn);
+  void ToggleAsyncHook(v8::Isolate* isolate, v8::Local<v8::Function> fn);
 
   node::Environment* parent_env_;
   // Encapsulates majority of the Inspector functionality
@@ -139,8 +136,6 @@ class Agent {
 
   bool pending_enable_async_hook_ = false;
   bool pending_disable_async_hook_ = false;
-  v8::Global<v8::Function> enable_async_hook_function_;
-  v8::Global<v8::Function> disable_async_hook_function_;
 };
 
 }  // namespace inspector
diff --git a/src/inspector_io.cc b/src/inspector_io.cc
index 75290317d2fcae8585ac8d91f49add5fdd0d79c0..d3bd1911214f83fbf841a91bf01072d4c12fe870 100644
--- a/src/inspector_io.cc
+++ b/src/inspector_io.cc
@@ -3,6 +3,7 @@
 #include "inspector_socket_server.h"
 #include "inspector/main_thread_interface.h"
 #include "inspector/node_string.h"
+#include "allocated_buffer-inl.h"  // Inlined functions needed by node_crypto.h.
 #include "base_object-inl.h"
 #include "debug_utils-inl.h"
 #include "node.h"
diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc
index 8616575e0661218759ca6336a943fe241bbdb999..c2d59effe0eebda3872778eaa5d8cc9e5fabc756 100644
--- a/src/inspector_js_api.cc
+++ b/src/inspector_js_api.cc
@@ -101,19 +101,17 @@ class JSBindingsConnection : public AsyncWrap {
   }
 
   static void Bind(Environment* env, Local<Object> target) {
-    Local<String> class_name = ConnectionType::GetClassName(env);
     Local<FunctionTemplate> tmpl =
         env->NewFunctionTemplate(JSBindingsConnection::New);
     tmpl->InstanceTemplate()->SetInternalFieldCount(
         JSBindingsConnection::kInternalFieldCount);
-    tmpl->SetClassName(class_name);
     tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
     env->SetProtoMethod(tmpl, "dispatch", JSBindingsConnection::Dispatch);
     env->SetProtoMethod(tmpl, "disconnect", JSBindingsConnection::Disconnect);
-    target->Set(env->context(),
-                class_name,
-                tmpl->GetFunction(env->context()).ToLocalChecked())
-        .ToChecked();
+    env->SetConstructorFunction(
+        target,
+        ConnectionType::GetClassName(env),
+        tmpl);
   }
 
   static void New(const FunctionCallbackInfo<Value>& info) {
@@ -155,6 +153,10 @@ class JSBindingsConnection : public AsyncWrap {
   SET_MEMORY_INFO_NAME(JSBindingsConnection)
   SET_SELF_SIZE(JSBindingsConnection)
 
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
+    return true;  // Binding connections emit events on their own.
+  }
+
  private:
   std::unique_ptr<InspectorSession> session_;
   Global<Function> callback_;
diff --git a/src/inspector_profiler.cc b/src/inspector_profiler.cc
index 7640a040783b855b0912b5b83434bcdbae12ae13..092b263ada2fdd9eb122df04a5815581d894ce47 100644
--- a/src/inspector_profiler.cc
+++ b/src/inspector_profiler.cc
@@ -418,22 +418,6 @@ static void EndStartedProfilers(Environment* env) {
   }
 }
 
-std::string GetCwd(Environment* env) {
-  char cwd[PATH_MAX_BYTES];
-  size_t size = PATH_MAX_BYTES;
-  const int err = uv_cwd(cwd, &size);
-
-  if (err == 0) {
-    CHECK_GT(size, 0);
-    return cwd;
-  }
-
-  // This can fail if the cwd is deleted. In that case, fall back to
-  // exec_path.
-  const std::string& exec_path = env->exec_path();
-  return exec_path.substr(0, exec_path.find_last_of(kPathSeparator));
-}
-
 void StartProfilers(Environment* env) {
   AtExit(env, [](void* env) {
     EndStartedProfilers(static_cast<Environment*>(env));
@@ -451,7 +435,7 @@ void StartProfilers(Environment* env) {
   if (env->options()->cpu_prof) {
     const std::string& dir = env->options()->cpu_prof_dir;
     env->set_cpu_prof_interval(env->options()->cpu_prof_interval);
-    env->set_cpu_prof_dir(dir.empty() ? GetCwd(env) : dir);
+    env->set_cpu_prof_dir(dir.empty() ? env->GetCwd() : dir);
     if (env->options()->cpu_prof_name.empty()) {
       DiagnosticFilename filename(env, "CPU", "cpuprofile");
       env->set_cpu_prof_name(*filename);
@@ -466,7 +450,7 @@ void StartProfilers(Environment* env) {
   if (env->options()->heap_prof) {
     const std::string& dir = env->options()->heap_prof_dir;
     env->set_heap_prof_interval(env->options()->heap_prof_interval);
-    env->set_heap_prof_dir(dir.empty() ? GetCwd(env) : dir);
+    env->set_heap_prof_dir(dir.empty() ? env->GetCwd() : dir);
     if (env->options()->heap_prof_name.empty()) {
       DiagnosticFilename filename(env, "Heap", "heapprofile");
       env->set_heap_prof_name(*filename);
diff --git a/src/inspector_socket.cc b/src/inspector_socket.cc
index 25f37871558f4f40316d7d6856da7f632fba8f44..cacff747d08bc38297f1e297af1b9d8f69a8a13a 100644
--- a/src/inspector_socket.cc
+++ b/src/inspector_socket.cc
@@ -1,13 +1,9 @@
 #include "inspector_socket.h"
+#include "llhttp.h"
 
-#define NODE_EXPERIMENTAL_HTTP
-#include "http_parser_adaptor.h"
-
+#include "base64-inl.h"
 #include "util-inl.h"
 
-#define NODE_WANT_INTERNALS 1
-#include "base64.h"
-
 #include "openssl/sha.h"  // Sha-1 hash
 
 #include <cstring>
@@ -322,7 +318,7 @@ class WsHandler : public ProtocolHandler {
   WsHandler(InspectorSocket* inspector, TcpHolder::Pointer tcp)
             : ProtocolHandler(inspector, std::move(tcp)),
               OnCloseSent(&WsHandler::WaitForCloseReply),
-              OnCloseRecieved(&WsHandler::CloseFrameReceived),
+              OnCloseReceived(&WsHandler::CloseFrameReceived),
               dispose_(false) { }
 
   void AcceptUpgrade(const std::string& accept_key) override { }
@@ -373,7 +369,7 @@ class WsHandler : public ProtocolHandler {
   }
 
   void WaitForCloseReply() {
-    OnCloseRecieved = &WsHandler::OnEof;
+    OnCloseReceived = &WsHandler::OnEof;
   }
 
   void SendClose() {
@@ -400,7 +396,7 @@ class WsHandler : public ProtocolHandler {
       OnEof();
       bytes_consumed = 0;
     } else if (r == FRAME_CLOSE) {
-      (this->*OnCloseRecieved)();
+      (this->*OnCloseReceived)();
       bytes_consumed = 0;
     } else if (r == FRAME_OK) {
       delegate()->OnWsFrame(output);
@@ -410,7 +406,7 @@ class WsHandler : public ProtocolHandler {
 
 
   Callback OnCloseSent;
-  Callback OnCloseRecieved;
+  Callback OnCloseReceived;
   bool dispose_;
 };
 
@@ -479,7 +475,7 @@ class HttpHandler : public ProtocolHandler {
   }
 
   void OnData(std::vector<char>* data) override {
-    parser_errno_t err;
+    llhttp_errno_t err;
     err = llhttp_execute(&parser_, data->data(), data->size());
 
     if (err == HPE_PAUSED_UPGRADE) {
@@ -524,14 +520,14 @@ class HttpHandler : public ProtocolHandler {
     handler->inspector()->SwitchProtocol(nullptr);
   }
 
-  static int OnHeaderValue(parser_t* parser, const char* at, size_t length) {
+  static int OnHeaderValue(llhttp_t* parser, const char* at, size_t length) {
     HttpHandler* handler = From(parser);
     handler->parsing_value_ = true;
     handler->headers_[handler->current_header_].append(at, length);
     return 0;
   }
 
-  static int OnHeaderField(parser_t* parser, const char* at, size_t length) {
+  static int OnHeaderField(llhttp_t* parser, const char* at, size_t length) {
     HttpHandler* handler = From(parser);
     if (handler->parsing_value_) {
       handler->parsing_value_ = false;
@@ -541,17 +537,17 @@ class HttpHandler : public ProtocolHandler {
     return 0;
   }
 
-  static int OnPath(parser_t* parser, const char* at, size_t length) {
+  static int OnPath(llhttp_t* parser, const char* at, size_t length) {
     HttpHandler* handler = From(parser);
     handler->path_.append(at, length);
     return 0;
   }
 
-  static HttpHandler* From(parser_t* parser) {
+  static HttpHandler* From(llhttp_t* parser) {
     return node::ContainerOf(&HttpHandler::parser_, parser);
   }
 
-  static int OnMessageComplete(parser_t* parser) {
+  static int OnMessageComplete(llhttp_t* parser) {
     // Event needs to be fired after the parser is done.
     HttpHandler* handler = From(parser);
     handler->events_.emplace_back(handler->path_,
@@ -588,8 +584,8 @@ class HttpHandler : public ProtocolHandler {
   }
 
   bool parsing_value_;
-  parser_t parser_;
-  parser_settings_t parser_settings;
+  llhttp_t parser_;
+  llhttp_settings_t parser_settings;
   std::vector<HttpEvent> events_;
   std::string current_header_;
   std::map<std::string, std::string> headers_;
diff --git a/src/inspector_socket_server.cc b/src/inspector_socket_server.cc
index 29e0c128026ed0f124f378eb0d5dc8962d9968ff..299664da9a16933df71d2f3f2b1d92db82725cfe 100644
--- a/src/inspector_socket_server.cc
+++ b/src/inspector_socket_server.cc
@@ -234,6 +234,7 @@ void PrintDebuggerReadyMessage(
     const std::string& host,
     const std::vector<InspectorSocketServer::ServerSocketPtr>& server_sockets,
     const std::vector<std::string>& ids,
+    const char* verb,
     bool publish_uid_stderr,
     FILE* out) {
   if (!publish_uid_stderr || out == nullptr) {
@@ -241,7 +242,8 @@ void PrintDebuggerReadyMessage(
   }
   for (const auto& server_socket : server_sockets) {
     for (const std::string& id : ids) {
-      fprintf(out, "Debugger listening on %s\n",
+      fprintf(out, "Debugger %s on %s\n",
+              verb,
               FormatWsAddress(host, server_socket->port(), id, true).c_str());
     }
   }
@@ -300,6 +302,7 @@ void InspectorSocketServer::SessionTerminated(int session_id) {
       PrintDebuggerReadyMessage(host_,
                                 server_sockets_,
                                 delegate_->GetTargetIds(),
+                                "ending",
                                 inspect_publish_uid_.console,
                                 out_);
     }
@@ -425,6 +428,7 @@ bool InspectorSocketServer::Start() {
   PrintDebuggerReadyMessage(host_,
                             server_sockets_,
                             delegate_->GetTargetIds(),
+                            "listening",
                             inspect_publish_uid_.console,
                             out_);
   return true;
diff --git a/src/js_native_api_types.h b/src/js_native_api_types.h
index 179428e95a4554d74346dc68fef9a05566f78eca..6aba06629b31543c13698dbb02b82db309587c4a 100644
--- a/src/js_native_api_types.h
+++ b/src/js_native_api_types.h
@@ -92,11 +92,15 @@ typedef enum {
   napi_date_expected,
   napi_arraybuffer_expected,
   napi_detachable_arraybuffer_expected,
+  napi_would_deadlock  // unused
 } napi_status;
 // Note: when adding a new enum value to `napi_status`, please also update
-// `const int last_status` in `napi_get_last_error_info()' definition,
-// in file js_native_api_v8.cc. Please also update the definition of
-// `napi_status` in doc/api/n-api.md to reflect the newly added value(s).
+//   * `const int last_status` in the definition of `napi_get_last_error_info()'
+//     in file js_native_api_v8.cc.
+//   * `const char* error_messages[]` in file js_native_api_v8.cc with a brief
+//     message explaining the error.
+//   * the definition of `napi_status` in doc/api/n-api.md to reflect the newly
+//     added value(s).
 
 typedef napi_value (*napi_callback)(napi_env env,
                                     napi_callback_info info);
diff --git a/src/js_native_api_v8.cc b/src/js_native_api_v8.cc
index 6a205fafcaa95fd2742d0b4bd4161017be499414..e71c2222232e1b33c3a52e308169de1081e1c215 100644
--- a/src/js_native_api_v8.cc
+++ b/src/js_native_api_v8.cc
@@ -169,7 +169,7 @@ inline static napi_status ConcludeDeferred(napi_env env,
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, result);
 
-  v8::Local<v8::Context> context = env->isolate->GetCurrentContext();
+  v8::Local<v8::Context> context = env->context();
   v8impl::Persistent<v8::Value>* deferred_ref =
       NodePersistentFromJsDeferred(deferred);
   v8::Local<v8::Value> v8_deferred =
@@ -188,220 +188,6 @@ inline static napi_status ConcludeDeferred(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
-// Wrapper around v8impl::Persistent that implements reference counting.
-class RefBase : protected Finalizer, RefTracker {
- protected:
-  RefBase(napi_env env,
-          uint32_t initial_refcount,
-          bool delete_self,
-          napi_finalize finalize_callback,
-          void* finalize_data,
-          void* finalize_hint)
-       : Finalizer(env, finalize_callback, finalize_data, finalize_hint),
-        _refcount(initial_refcount),
-        _delete_self(delete_self) {
-    Link(finalize_callback == nullptr
-        ? &env->reflist
-        : &env->finalizing_reflist);
-  }
-
- public:
-  static RefBase* New(napi_env env,
-                      uint32_t initial_refcount,
-                      bool delete_self,
-                      napi_finalize finalize_callback,
-                      void* finalize_data,
-                      void* finalize_hint) {
-    return new RefBase(env,
-                       initial_refcount,
-                       delete_self,
-                       finalize_callback,
-                       finalize_data,
-                       finalize_hint);
-  }
-
-  inline void* Data() {
-    return _finalize_data;
-  }
-
-  // Delete is called in 2 ways. Either from the finalizer or
-  // from one of Unwrap or napi_delete_reference.
-  //
-  // When it is called from Unwrap or napi_delete_reference we only
-  // want to do the delete if the finalizer has already run or
-  // cannot have been queued to run (ie the reference count is > 0),
-  // otherwise we may crash when the finalizer does run.
-  // If the finalizer may have been queued and has not already run
-  // delay the delete until the finalizer runs by not doing the delete
-  // and setting _delete_self to true so that the finalizer will
-  // delete it when it runs.
-  //
-  // The second way this is called is from
-  // the finalizer and _delete_self is set. In this case we
-  // know we need to do the deletion so just do it.
-  static inline void Delete(RefBase* reference) {
-    reference->Unlink();
-    if ((reference->RefCount() != 0) ||
-        (reference->_delete_self) ||
-        (reference->_finalize_ran)) {
-      delete reference;
-    } else {
-      // defer until finalizer runs as
-      // it may alread be queued
-      reference->_delete_self = true;
-    }
-  }
-
-  inline uint32_t Ref() {
-    return ++_refcount;
-  }
-
-  inline uint32_t Unref() {
-    if (_refcount == 0) {
-        return 0;
-    }
-    return --_refcount;
-  }
-
-  inline uint32_t RefCount() {
-    return _refcount;
-  }
-
- protected:
-  inline void Finalize(bool is_env_teardown = false) override {
-    if (_finalize_callback != nullptr) {
-      _env->CallFinalizer(_finalize_callback, _finalize_data, _finalize_hint);
-    }
-
-    // this is safe because if a request to delete the reference
-    // is made in the finalize_callback it will defer deletion
-    // to this block and set _delete_self to true
-    if (_delete_self || is_env_teardown) {
-      Delete(this);
-    } else {
-      _finalize_ran = true;
-    }
-  }
-
- private:
-  uint32_t _refcount;
-  bool _delete_self;
-};
-
-class Reference : public RefBase {
- protected:
-  template <typename... Args>
-  Reference(napi_env env,
-            v8::Local<v8::Value> value,
-            Args&&... args)
-      : RefBase(env, std::forward<Args>(args)...),
-            _persistent(env->isolate, value) {
-    if (RefCount() == 0) {
-      _persistent.SetWeak(
-          this, FinalizeCallback, v8::WeakCallbackType::kParameter);
-    }
-  }
-
- public:
-  static inline Reference* New(napi_env env,
-                             v8::Local<v8::Value> value,
-                             uint32_t initial_refcount,
-                             bool delete_self,
-                             napi_finalize finalize_callback = nullptr,
-                             void* finalize_data = nullptr,
-                             void* finalize_hint = nullptr) {
-    return new Reference(env,
-                         value,
-                         initial_refcount,
-                         delete_self,
-                         finalize_callback,
-                         finalize_data,
-                         finalize_hint);
-  }
-
-  inline uint32_t Ref() {
-    uint32_t refcount = RefBase::Ref();
-    if (refcount == 1) {
-      _persistent.ClearWeak();
-    }
-    return refcount;
-  }
-
-  inline uint32_t Unref() {
-    uint32_t old_refcount = RefCount();
-    uint32_t refcount = RefBase::Unref();
-    if (old_refcount == 1 && refcount == 0) {
-      _persistent.SetWeak(
-          this, FinalizeCallback, v8::WeakCallbackType::kParameter);
-    }
-    return refcount;
-  }
-
-  inline v8::Local<v8::Value> Get() {
-    if (_persistent.IsEmpty()) {
-      return v8::Local<v8::Value>();
-    } else {
-      return v8::Local<v8::Value>::New(_env->isolate, _persistent);
-    }
-  }
-
- private:
-  // The N-API finalizer callback may make calls into the engine. V8's heap is
-  // not in a consistent state during the weak callback, and therefore it does
-  // not support calls back into it. However, it provides a mechanism for adding
-  // a finalizer which may make calls back into the engine by allowing us to
-  // attach such a second-pass finalizer from the first pass finalizer. Thus,
-  // we do that here to ensure that the N-API finalizer callback is free to call
-  // into the engine.
-  static void FinalizeCallback(const v8::WeakCallbackInfo<Reference>& data) {
-    Reference* reference = data.GetParameter();
-
-    // The reference must be reset during the first pass.
-    reference->_persistent.Reset();
-
-    data.SetSecondPassCallback(SecondPassCallback);
-  }
-
-  static void SecondPassCallback(const v8::WeakCallbackInfo<Reference>& data) {
-    data.GetParameter()->Finalize();
-  }
-
-  v8impl::Persistent<v8::Value> _persistent;
-};
-
-class ArrayBufferReference final : public Reference {
- public:
-  // Same signatures for ctor and New() as Reference, except this only works
-  // with ArrayBuffers:
-  template <typename... Args>
-  explicit ArrayBufferReference(napi_env env,
-                                v8::Local<v8::ArrayBuffer> value,
-                                Args&&... args)
-    : Reference(env, value, std::forward<Args>(args)...) {}
-
-  template <typename... Args>
-  static ArrayBufferReference* New(napi_env env,
-                                   v8::Local<v8::ArrayBuffer> value,
-                                   Args&&... args) {
-    return new ArrayBufferReference(env, value, std::forward<Args>(args)...);
-  }
-
- private:
-  inline void Finalize(bool is_env_teardown) override {
-    if (is_env_teardown) {
-      v8::HandleScope handle_scope(_env->isolate);
-      v8::Local<v8::Value> obj = Get();
-      CHECK(!obj.IsEmpty());
-      CHECK(obj->IsArrayBuffer());
-      v8::Local<v8::ArrayBuffer> ab = obj.As<v8::ArrayBuffer>();
-      if (ab->IsDetachable())
-        ab->Detach();
-    }
-
-    Reference::Finalize(is_env_teardown);
-  }
-};
-
 enum UnwrapAction {
   KeepWrap,
   RemoveWrap
@@ -417,8 +203,7 @@ inline static napi_status Unwrap(napi_env env,
     CHECK_ARG(env, result);
   }
 
-  v8::Isolate* isolate = env->isolate;
-  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Context> context = env->context();
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(js_object);
   RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
@@ -451,18 +236,36 @@ inline static napi_status Unwrap(napi_env env,
 // calling through N-API.
 // Ref: benchmark/misc/function_call
 // Discussion (incl. perf. data): https://github.com/nodejs/node/pull/21072
-struct CallbackBundle {
+class CallbackBundle {
+ public:
+  // Creates an object to be made available to the static function callback
+  // wrapper, used to retrieve the native callback function and data pointer.
+  static inline v8::Local<v8::Value>
+  New(napi_env env, napi_callback cb, void* data) {
+    CallbackBundle* bundle = new CallbackBundle();
+    bundle->cb = cb;
+    bundle->cb_data = data;
+    bundle->env = env;
+
+    v8::Local<v8::Value> cbdata = v8::External::New(env->isolate, bundle);
+    Reference::New(env, cbdata, 0, true, Delete, bundle, nullptr);
+    return cbdata;
+  }
   napi_env       env;      // Necessary to invoke C++ NAPI callback
   void*          cb_data;  // The user provided callback data
-  napi_callback  function_or_getter;
-  napi_callback  setter;
+  napi_callback  cb;
+ private:
+  static void Delete(napi_env env, void* data, void* hint) {
+    CallbackBundle* bundle = static_cast<CallbackBundle*>(data);
+    delete bundle;
+  }
 };
 
 // Base class extended by classes that wrap V8 function and property callback
 // info.
 class CallbackWrapper {
  public:
-  CallbackWrapper(napi_value this_arg, size_t args_length, void* data)
+  inline CallbackWrapper(napi_value this_arg, size_t args_length, void* data)
       : _this(this_arg), _args_length(args_length), _data(data) {}
 
   virtual napi_value GetNewTarget() = 0;
@@ -481,10 +284,10 @@ class CallbackWrapper {
   void* _data;
 };
 
-template <typename Info, napi_callback CallbackBundle::*FunctionField>
 class CallbackWrapperBase : public CallbackWrapper {
  public:
-  CallbackWrapperBase(const Info& cbinfo, const size_t args_length)
+  inline CallbackWrapperBase(const v8::FunctionCallbackInfo<v8::Value>& cbinfo,
+                             const size_t args_length)
       : CallbackWrapper(JsValueFromV8LocalValue(cbinfo.This()),
                         args_length,
                         nullptr),
@@ -494,40 +297,68 @@ class CallbackWrapperBase : public CallbackWrapper {
     _data = _bundle->cb_data;
   }
 
-  napi_value GetNewTarget() override { return nullptr; }
-
  protected:
-  void InvokeCallback() {
+  inline void InvokeCallback() {
     napi_callback_info cbinfo_wrapper = reinterpret_cast<napi_callback_info>(
         static_cast<CallbackWrapper*>(this));
 
     // All other pointers we need are stored in `_bundle`
     napi_env env = _bundle->env;
-    napi_callback cb = _bundle->*FunctionField;
+    napi_callback cb = _bundle->cb;
 
-    napi_value result;
+    napi_value result = nullptr;
+    bool exceptionOccurred = false;
     env->CallIntoModule([&](napi_env env) {
       result = cb(env, cbinfo_wrapper);
+    }, [&](napi_env env, v8::Local<v8::Value> value) {
+      exceptionOccurred = true;
+      env->isolate->ThrowException(value);
     });
 
-    if (result != nullptr) {
+    if (!exceptionOccurred && (result != nullptr)) {
       this->SetReturnValue(result);
     }
   }
 
-  const Info& _cbinfo;
+  const v8::FunctionCallbackInfo<v8::Value>& _cbinfo;
   CallbackBundle* _bundle;
 };
 
 class FunctionCallbackWrapper
-    : public CallbackWrapperBase<v8::FunctionCallbackInfo<v8::Value>,
-                                 &CallbackBundle::function_or_getter> {
+    : public CallbackWrapperBase {
  public:
   static void Invoke(const v8::FunctionCallbackInfo<v8::Value>& info) {
     FunctionCallbackWrapper cbwrapper(info);
     cbwrapper.InvokeCallback();
   }
 
+  static inline napi_status NewFunction(napi_env env,
+                                        napi_callback cb,
+                                        void* cb_data,
+                                        v8::Local<v8::Function>* result) {
+    v8::Local<v8::Value> cbdata = v8impl::CallbackBundle::New(env, cb, cb_data);
+    RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
+
+    v8::MaybeLocal<v8::Function> maybe_function =
+        v8::Function::New(env->context(), Invoke, cbdata);
+    CHECK_MAYBE_EMPTY(env, maybe_function, napi_generic_failure);
+
+    *result = maybe_function.ToLocalChecked();
+    return napi_clear_last_error(env);
+  }
+
+  static inline napi_status NewTemplate(napi_env env,
+                    napi_callback cb,
+                    void* cb_data,
+                    v8::Local<v8::FunctionTemplate>* result,
+                    v8::Local<v8::Signature> sig = v8::Local<v8::Signature>()) {
+    v8::Local<v8::Value> cbdata = v8impl::CallbackBundle::New(env, cb, cb_data);
+    RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
+
+    *result = v8::FunctionTemplate::New(env->isolate, Invoke, cbdata, sig);
+    return napi_clear_last_error(env);
+  }
+
   explicit FunctionCallbackWrapper(
       const v8::FunctionCallbackInfo<v8::Value>& cbinfo)
       : CallbackWrapperBase(cbinfo, cbinfo.Length()) {}
@@ -565,98 +396,6 @@ class FunctionCallbackWrapper
   }
 };
 
-class GetterCallbackWrapper
-    : public CallbackWrapperBase<v8::PropertyCallbackInfo<v8::Value>,
-                                 &CallbackBundle::function_or_getter> {
- public:
-  static void Invoke(v8::Local<v8::Name> property,
-                     const v8::PropertyCallbackInfo<v8::Value>& info) {
-    GetterCallbackWrapper cbwrapper(info);
-    cbwrapper.InvokeCallback();
-  }
-
-  explicit GetterCallbackWrapper(
-      const v8::PropertyCallbackInfo<v8::Value>& cbinfo)
-      : CallbackWrapperBase(cbinfo, 0) {}
-
-  /*virtual*/
-  void Args(napi_value* buffer, size_t buffer_length) override {
-    if (buffer_length > 0) {
-      napi_value undefined =
-          v8impl::JsValueFromV8LocalValue(v8::Undefined(_cbinfo.GetIsolate()));
-      for (size_t i = 0; i < buffer_length; i += 1) {
-        buffer[i] = undefined;
-      }
-    }
-  }
-
-  /*virtual*/
-  void SetReturnValue(napi_value value) override {
-    v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-    _cbinfo.GetReturnValue().Set(val);
-  }
-};
-
-class SetterCallbackWrapper
-    : public CallbackWrapperBase<v8::PropertyCallbackInfo<void>,
-                                 &CallbackBundle::setter> {
- public:
-  static void Invoke(v8::Local<v8::Name> property,
-                     v8::Local<v8::Value> value,
-                     const v8::PropertyCallbackInfo<void>& info) {
-    SetterCallbackWrapper cbwrapper(info, value);
-    cbwrapper.InvokeCallback();
-  }
-
-  SetterCallbackWrapper(const v8::PropertyCallbackInfo<void>& cbinfo,
-                        const v8::Local<v8::Value>& value)
-      : CallbackWrapperBase(cbinfo, 1), _value(value) {}
-
-  /*virtual*/
-  void Args(napi_value* buffer, size_t buffer_length) override {
-    if (buffer_length > 0) {
-      buffer[0] = v8impl::JsValueFromV8LocalValue(_value);
-
-      if (buffer_length > 1) {
-        napi_value undefined = v8impl::JsValueFromV8LocalValue(
-            v8::Undefined(_cbinfo.GetIsolate()));
-        for (size_t i = 1; i < buffer_length; i += 1) {
-          buffer[i] = undefined;
-        }
-      }
-    }
-  }
-
-  /*virtual*/
-  void SetReturnValue(napi_value value) override {
-    // Ignore any value returned from a setter callback.
-  }
-
- private:
-  const v8::Local<v8::Value>& _value;
-};
-
-static void DeleteCallbackBundle(napi_env env, void* data, void* hint) {
-  CallbackBundle* bundle = static_cast<CallbackBundle*>(data);
-  delete bundle;
-}
-
-// Creates an object to be made available to the static function callback
-// wrapper, used to retrieve the native callback function and data pointer.
-static
-v8::Local<v8::Value> CreateFunctionCallbackData(napi_env env,
-                                                napi_callback cb,
-                                                void* data) {
-  CallbackBundle* bundle = new CallbackBundle();
-  bundle->function_or_getter = cb;
-  bundle->cb_data = data;
-  bundle->env = env;
-  v8::Local<v8::Value> cbdata = v8::External::New(env->isolate, bundle);
-  Reference::New(env, cbdata, 0, true, DeleteCallbackBundle, bundle, nullptr);
-
-  return cbdata;
-}
-
 enum WrapType {
   retrievable,
   anonymous
@@ -715,6 +454,270 @@ inline napi_status Wrap(napi_env env,
 
 }  // end of anonymous namespace
 
+// Wrapper around v8impl::Persistent that implements reference counting.
+RefBase::RefBase(napi_env env,
+                 uint32_t initial_refcount,
+                 bool delete_self,
+                 napi_finalize finalize_callback,
+                 void* finalize_data,
+                 void* finalize_hint)
+    : Finalizer(env, finalize_callback, finalize_data, finalize_hint),
+      _refcount(initial_refcount),
+      _delete_self(delete_self) {
+  Link(finalize_callback == nullptr ? &env->reflist : &env->finalizing_reflist);
+}
+
+RefBase* RefBase::New(napi_env env,
+                      uint32_t initial_refcount,
+                      bool delete_self,
+                      napi_finalize finalize_callback,
+                      void* finalize_data,
+                      void* finalize_hint) {
+  return new RefBase(env,
+                     initial_refcount,
+                     delete_self,
+                     finalize_callback,
+                     finalize_data,
+                     finalize_hint);
+}
+
+RefBase::~RefBase() {
+  Unlink();
+}
+
+void* RefBase::Data() {
+  return _finalize_data;
+}
+
+// Delete is called in 2 ways. Either from the finalizer or
+// from one of Unwrap or napi_delete_reference.
+//
+// When it is called from Unwrap or napi_delete_reference we only
+// want to do the delete if the finalizer has already run or
+// cannot have been queued to run (ie the reference count is > 0),
+// otherwise we may crash when the finalizer does run.
+// If the finalizer may have been queued and has not already run
+// delay the delete until the finalizer runs by not doing the delete
+// and setting _delete_self to true so that the finalizer will
+// delete it when it runs.
+//
+// The second way this is called is from
+// the finalizer and _delete_self is set. In this case we
+// know we need to do the deletion so just do it.
+void RefBase::Delete(RefBase* reference) {
+  if ((reference->RefCount() != 0) || (reference->_delete_self) ||
+      (reference->_finalize_ran)) {
+    delete reference;
+  } else {
+    // defer until finalizer runs as
+    // it may already be queued
+    reference->_delete_self = true;
+  }
+}
+
+uint32_t RefBase::Ref() {
+  return ++_refcount;
+}
+
+uint32_t RefBase::Unref() {
+  if (_refcount == 0) {
+    return 0;
+  }
+  return --_refcount;
+}
+
+uint32_t RefBase::RefCount() {
+  return _refcount;
+}
+
+void RefBase::Finalize(bool is_env_teardown) {
+  // In addition to being called during environment teardown, this method is
+  // also the entry point for the garbage collector. During environment
+  // teardown we have to remove the garbage collector's reference to this
+  // method so that, if, as part of the user's callback, JS gets executed,
+  // resulting in a garbage collection pass, this method is not re-entered as
+  // part of that pass, because that'll cause a double free (as seen in
+  // https://github.com/nodejs/node/issues/37236).
+  //
+  // Since this class does not have access to the V8 persistent reference,
+  // this method is overridden in the `Reference` class below. Therein the
+  // weak callback is removed, ensuring that the garbage collector does not
+  // re-enter this method, and the method chains up to continue the process of
+  // environment-teardown-induced finalization.
+
+  // During environment teardown we have to convert a strong reference to
+  // a weak reference to force the deferring behavior if the user's finalizer
+  // happens to delete this reference so that the code in this function that
+  // follows the call to the user's finalizer may safely access variables from
+  // this instance.
+  if (is_env_teardown && RefCount() > 0) _refcount = 0;
+
+  if (_finalize_callback != nullptr) {
+    // This ensures that we never call the finalizer twice.
+    napi_finalize fini = _finalize_callback;
+    _finalize_callback = nullptr;
+    _env->CallFinalizer(fini, _finalize_data, _finalize_hint);
+  }
+
+  // this is safe because if a request to delete the reference
+  // is made in the finalize_callback it will defer deletion
+  // to this block and set _delete_self to true
+  if (_delete_self || is_env_teardown) {
+    Delete(this);
+  } else {
+    _finalize_ran = true;
+  }
+}
+
+template <typename... Args>
+Reference::Reference(napi_env env, v8::Local<v8::Value> value, Args&&... args)
+    : RefBase(env, std::forward<Args>(args)...),
+      _persistent(env->isolate, value),
+      _secondPassParameter(new SecondPassCallParameterRef(this)),
+      _secondPassScheduled(false) {
+  if (RefCount() == 0) {
+    SetWeak();
+  }
+}
+
+Reference* Reference::New(napi_env env,
+                          v8::Local<v8::Value> value,
+                          uint32_t initial_refcount,
+                          bool delete_self,
+                          napi_finalize finalize_callback,
+                          void* finalize_data,
+                          void* finalize_hint) {
+  return new Reference(env,
+                       value,
+                       initial_refcount,
+                       delete_self,
+                       finalize_callback,
+                       finalize_data,
+                       finalize_hint);
+}
+
+Reference::~Reference() {
+  // If the second pass callback is scheduled, it will delete the
+  // parameter passed to it, otherwise it will never be scheduled
+  // and we need to delete it here.
+  if (!_secondPassScheduled) {
+    delete _secondPassParameter;
+  }
+}
+
+uint32_t Reference::Ref() {
+  uint32_t refcount = RefBase::Ref();
+  if (refcount == 1) {
+    ClearWeak();
+  }
+  return refcount;
+}
+
+uint32_t Reference::Unref() {
+  uint32_t old_refcount = RefCount();
+  uint32_t refcount = RefBase::Unref();
+  if (old_refcount == 1 && refcount == 0) {
+    SetWeak();
+  }
+  return refcount;
+}
+
+v8::Local<v8::Value> Reference::Get() {
+  if (_persistent.IsEmpty()) {
+    return v8::Local<v8::Value>();
+  } else {
+    return v8::Local<v8::Value>::New(_env->isolate, _persistent);
+  }
+}
+
+void Reference::Finalize(bool is_env_teardown) {
+  // During env teardown, `~napi_env()` alone is responsible for finalizing.
+  // Thus, we don't want any stray gc passes to trigger a second call to
+  // `RefBase::Finalize()`. ClearWeak will ensure that even if the
+  // gc is in progress no Finalization will be run for this Reference
+  // by the gc.
+  if (is_env_teardown) {
+    ClearWeak();
+  }
+
+  // Chain up to perform the rest of the finalization.
+  RefBase::Finalize(is_env_teardown);
+}
+
+// ClearWeak is marking the Reference so that the gc should not
+// collect it, but it is possible that a second pass callback
+// may have been scheduled already if we are in shutdown. We clear
+// the secondPassParameter so that even if it has been
+// scheduled no Finalization will be run.
+void Reference::ClearWeak() {
+  if (!_persistent.IsEmpty()) {
+    _persistent.ClearWeak();
+  }
+  if (_secondPassParameter != nullptr) {
+    *_secondPassParameter = nullptr;
+  }
+}
+
+// Mark the reference as weak and eligible for collection
+// by the gc.
+void Reference::SetWeak() {
+  if (_secondPassParameter == nullptr) {
+    // This means that the Reference has already been processed
+    // by the second pass callback, so its already been Finalized, do
+    // nothing
+    return;
+  }
+  _persistent.SetWeak(
+      _secondPassParameter, FinalizeCallback, v8::WeakCallbackType::kParameter);
+  *_secondPassParameter = this;
+}
+
+// The N-API finalizer callback may make calls into the engine. V8's heap is
+// not in a consistent state during the weak callback, and therefore it does
+// not support calls back into it. However, it provides a mechanism for adding
+// a finalizer which may make calls back into the engine by allowing us to
+// attach such a second-pass finalizer from the first pass finalizer. Thus,
+// we do that here to ensure that the N-API finalizer callback is free to call
+// into the engine.
+void Reference::FinalizeCallback(
+    const v8::WeakCallbackInfo<SecondPassCallParameterRef>& data) {
+  SecondPassCallParameterRef* parameter = data.GetParameter();
+  Reference* reference = *parameter;
+  if (reference == nullptr) {
+    return;
+  }
+
+  // The reference must be reset during the first pass.
+  reference->_persistent.Reset();
+  // Mark the parameter not delete-able until the second pass callback is
+  // invoked.
+  reference->_secondPassScheduled = true;
+
+  data.SetSecondPassCallback(SecondPassCallback);
+}
+
+// Second pass callbacks are scheduled with platform tasks. At env teardown,
+// the tasks may have already be scheduled and we are unable to cancel the
+// second pass callback task. We have to make sure that parameter is kept
+// alive until the second pass callback is been invoked. In order to do
+// this and still allow our code to Finalize/delete the Reference during
+// shutdown we have to use a separately allocated parameter instead
+// of a parameter within the Reference object itself. This is what
+// is stored in _secondPassParameter and it is allocated in the
+// constructor for the Reference.
+void Reference::SecondPassCallback(
+    const v8::WeakCallbackInfo<SecondPassCallParameterRef>& data) {
+  SecondPassCallParameterRef* parameter = data.GetParameter();
+  Reference* reference = *parameter;
+  delete parameter;
+  if (reference == nullptr) {
+    // the reference itself has already been deleted so nothing to do
+    return;
+  }
+  reference->_secondPassParameter = nullptr;
+  reference->Finalize();
+}
+
 }  // end of namespace v8impl
 
 // Warning: Keep in-sync with napi_status enum
@@ -740,6 +743,7 @@ const char* error_messages[] = {nullptr,
                                 "A date was expected",
                                 "An arraybuffer was expected",
                                 "A detachable arraybuffer was expected",
+                                "Main thread would deadlock",
 };
 
 napi_status napi_get_last_error_info(napi_env env,
@@ -751,7 +755,7 @@ napi_status napi_get_last_error_info(napi_env env,
   // message in the `napi_status` enum each time a new error message is added.
   // We don't have a napi_status_last as this would result in an ABI
   // change each time a message was added.
-  const int last_status = napi_detachable_arraybuffer_expected;
+  const int last_status = napi_would_deadlock;
 
   static_assert(
       NAPI_ARRAYSIZE(error_messages) == last_status + 1,
@@ -777,22 +781,12 @@ napi_status napi_create_function(napi_env env,
   CHECK_ARG(env, result);
   CHECK_ARG(env, cb);
 
-  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Function> return_value;
-  v8::EscapableHandleScope scope(isolate);
-  v8::Local<v8::Value> cbdata =
-      v8impl::CreateFunctionCallbackData(env, cb, callback_data);
-
-  RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
-
-  v8::Local<v8::Context> context = env->context();
-  v8::MaybeLocal<v8::Function> maybe_function =
-      v8::Function::New(context,
-                        v8impl::FunctionCallbackWrapper::Invoke,
-                        cbdata);
-  CHECK_MAYBE_EMPTY(env, maybe_function, napi_generic_failure);
-
-  return_value = scope.Escape(maybe_function.ToLocalChecked());
+  v8::EscapableHandleScope scope(env->isolate);
+  v8::Local<v8::Function> fn;
+  STATUS_CALL(v8impl::FunctionCallbackWrapper::NewFunction(
+      env, cb, callback_data, &fn));
+  return_value = scope.Escape(fn);
 
   if (utf8name != nullptr) {
     v8::Local<v8::String> name_string;
@@ -824,13 +818,9 @@ napi_status napi_define_class(napi_env env,
   v8::Isolate* isolate = env->isolate;
 
   v8::EscapableHandleScope scope(isolate);
-  v8::Local<v8::Value> cbdata =
-      v8impl::CreateFunctionCallbackData(env, constructor, callback_data);
-
-  RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
-
-  v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(
-      isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
+  v8::Local<v8::FunctionTemplate> tpl;
+  STATUS_CALL(v8impl::FunctionCallbackWrapper::NewTemplate(
+      env, constructor, callback_data, &tpl));
 
   v8::Local<v8::String> name_string;
   CHECK_NEW_FROM_UTF8_LEN(env, name_string, utf8name, length);
@@ -847,12 +837,7 @@ napi_status napi_define_class(napi_env env,
     }
 
     v8::Local<v8::Name> property_name;
-    napi_status status =
-        v8impl::V8NameFromPropertyDescriptor(env, p, &property_name);
-
-    if (status != napi_ok) {
-      return napi_set_last_error(env, status);
-    }
+    STATUS_CALL(v8impl::V8NameFromPropertyDescriptor(env, p, &property_name));
 
     v8::PropertyAttribute attributes =
         v8impl::V8PropertyAttributesFromDescriptor(p);
@@ -865,18 +850,12 @@ napi_status napi_define_class(napi_env env,
       v8::Local<v8::FunctionTemplate> getter_tpl;
       v8::Local<v8::FunctionTemplate> setter_tpl;
       if (p->getter != nullptr) {
-        v8::Local<v8::Value> getter_data =
-            v8impl::CreateFunctionCallbackData(env, p->getter, p->data);
-
-        getter_tpl = v8::FunctionTemplate::New(
-            isolate, v8impl::FunctionCallbackWrapper::Invoke, getter_data);
+        STATUS_CALL(v8impl::FunctionCallbackWrapper::NewTemplate(
+            env, p->getter, p->data, &getter_tpl));
       }
       if (p->setter != nullptr) {
-        v8::Local<v8::Value> setter_data =
-            v8impl::CreateFunctionCallbackData(env, p->setter, p->data);
-
-        setter_tpl = v8::FunctionTemplate::New(
-            isolate, v8impl::FunctionCallbackWrapper::Invoke, setter_data);
+        STATUS_CALL(v8impl::FunctionCallbackWrapper::NewTemplate(
+            env, p->setter, p->data, &setter_tpl));
       }
 
       tpl->PrototypeTemplate()->SetAccessorProperty(
@@ -886,16 +865,9 @@ napi_status napi_define_class(napi_env env,
         attributes,
         v8::AccessControl::DEFAULT);
     } else if (p->method != nullptr) {
-      v8::Local<v8::Value> cbdata =
-          v8impl::CreateFunctionCallbackData(env, p->method, p->data);
-
-      RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
-
-      v8::Local<v8::FunctionTemplate> t =
-        v8::FunctionTemplate::New(isolate,
-          v8impl::FunctionCallbackWrapper::Invoke,
-          cbdata,
-          v8::Signature::New(isolate, tpl));
+      v8::Local<v8::FunctionTemplate> t;
+      STATUS_CALL(v8impl::FunctionCallbackWrapper::NewTemplate(
+          env, p->method, p->data, &t, v8::Signature::New(isolate, tpl)));
 
       tpl->PrototypeTemplate()->Set(property_name, t, attributes);
     } else {
@@ -919,12 +891,10 @@ napi_status napi_define_class(napi_env env,
       }
     }
 
-    napi_status status =
-        napi_define_properties(env,
-                               *result,
-                               static_descriptors.size(),
-                               static_descriptors.data());
-    if (status != napi_ok) return status;
+    STATUS_CALL(napi_define_properties(env,
+                                       *result,
+                                       static_descriptors.size(),
+                                       static_descriptors.data()));
   }
 
   return GET_RETURN_STATUS(env);
@@ -1299,41 +1269,19 @@ napi_status napi_define_properties(napi_env env,
     const napi_property_descriptor* p = &properties[i];
 
     v8::Local<v8::Name> property_name;
-    napi_status status =
-        v8impl::V8NameFromPropertyDescriptor(env, p, &property_name);
-
-    if (status != napi_ok) {
-      return napi_set_last_error(env, status);
-    }
+    STATUS_CALL(v8impl::V8NameFromPropertyDescriptor(env, p, &property_name));
 
     if (p->getter != nullptr || p->setter != nullptr) {
-      v8::Local<v8::Value> local_getter;
-      v8::Local<v8::Value> local_setter;
+      v8::Local<v8::Function> local_getter;
+      v8::Local<v8::Function> local_setter;
 
       if (p->getter != nullptr) {
-        v8::Local<v8::Value> getter_data =
-            v8impl::CreateFunctionCallbackData(env, p->getter, p->data);
-        CHECK_MAYBE_EMPTY(env, getter_data, napi_generic_failure);
-
-        v8::MaybeLocal<v8::Function> maybe_getter =
-            v8::Function::New(context,
-                              v8impl::FunctionCallbackWrapper::Invoke,
-                              getter_data);
-        CHECK_MAYBE_EMPTY(env, maybe_getter, napi_generic_failure);
-
-        local_getter = maybe_getter.ToLocalChecked();
+        STATUS_CALL(v8impl::FunctionCallbackWrapper::NewFunction(
+            env, p->getter, p->data, &local_getter));
       }
       if (p->setter != nullptr) {
-        v8::Local<v8::Value> setter_data =
-            v8impl::CreateFunctionCallbackData(env, p->setter, p->data);
-        CHECK_MAYBE_EMPTY(env, setter_data, napi_generic_failure);
-
-        v8::MaybeLocal<v8::Function> maybe_setter =
-            v8::Function::New(context,
-                              v8impl::FunctionCallbackWrapper::Invoke,
-                              setter_data);
-        CHECK_MAYBE_EMPTY(env, maybe_setter, napi_generic_failure);
-        local_setter = maybe_setter.ToLocalChecked();
+        STATUS_CALL(v8impl::FunctionCallbackWrapper::NewFunction(
+            env, p->setter, p->data, &local_setter));
       }
 
       v8::PropertyDescriptor descriptor(local_getter, local_setter);
@@ -1348,19 +1296,10 @@ napi_status napi_define_properties(napi_env env,
         return napi_set_last_error(env, napi_invalid_arg);
       }
     } else if (p->method != nullptr) {
-      v8::Local<v8::Value> cbdata =
-          v8impl::CreateFunctionCallbackData(env, p->method, p->data);
-
-      CHECK_MAYBE_EMPTY(env, cbdata, napi_generic_failure);
-
-      v8::MaybeLocal<v8::Function> maybe_fn =
-          v8::Function::New(context,
-                            v8impl::FunctionCallbackWrapper::Invoke,
-                            cbdata);
-
-      CHECK_MAYBE_EMPTY(env, maybe_fn, napi_generic_failure);
-
-      v8::PropertyDescriptor descriptor(maybe_fn.ToLocalChecked(),
+      v8::Local<v8::Function> method;
+      STATUS_CALL(v8impl::FunctionCallbackWrapper::NewFunction(
+          env, p->method, p->data, &method));
+      v8::PropertyDescriptor descriptor(method,
                                         (p->attributes & napi_writable) != 0);
       descriptor.set_enumerable((p->attributes & napi_enumerable) != 0);
       descriptor.set_configurable((p->attributes & napi_configurable) != 0);
@@ -1755,8 +1694,7 @@ napi_status napi_create_error(napi_env env,
 
   v8::Local<v8::Value> error_obj =
       v8::Exception::Error(message_value.As<v8::String>());
-  napi_status status = set_error_code(env, error_obj, code, nullptr);
-  if (status != napi_ok) return status;
+  STATUS_CALL(set_error_code(env, error_obj, code, nullptr));
 
   *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
@@ -1776,8 +1714,7 @@ napi_status napi_create_type_error(napi_env env,
 
   v8::Local<v8::Value> error_obj =
       v8::Exception::TypeError(message_value.As<v8::String>());
-  napi_status status = set_error_code(env, error_obj, code, nullptr);
-  if (status != napi_ok) return status;
+  STATUS_CALL(set_error_code(env, error_obj, code, nullptr));
 
   *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
@@ -1797,8 +1734,7 @@ napi_status napi_create_range_error(napi_env env,
 
   v8::Local<v8::Value> error_obj =
       v8::Exception::RangeError(message_value.As<v8::String>());
-  napi_status status = set_error_code(env, error_obj, code, nullptr);
-  if (status != napi_ok) return status;
+  STATUS_CALL(set_error_code(env, error_obj, code, nullptr));
 
   *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
@@ -1978,8 +1914,7 @@ napi_status napi_throw_error(napi_env env,
   CHECK_NEW_FROM_UTF8(env, str, msg);
 
   v8::Local<v8::Value> error_obj = v8::Exception::Error(str);
-  napi_status status = set_error_code(env, error_obj, nullptr, code);
-  if (status != napi_ok) return status;
+  STATUS_CALL(set_error_code(env, error_obj, nullptr, code));
 
   isolate->ThrowException(error_obj);
   // any VM calls after this point and before returning
@@ -1997,8 +1932,7 @@ napi_status napi_throw_type_error(napi_env env,
   CHECK_NEW_FROM_UTF8(env, str, msg);
 
   v8::Local<v8::Value> error_obj = v8::Exception::TypeError(str);
-  napi_status status = set_error_code(env, error_obj, nullptr, code);
-  if (status != napi_ok) return status;
+  STATUS_CALL(set_error_code(env, error_obj, nullptr, code));
 
   isolate->ThrowException(error_obj);
   // any VM calls after this point and before returning
@@ -2016,8 +1950,7 @@ napi_status napi_throw_range_error(napi_env env,
   CHECK_NEW_FROM_UTF8(env, str, msg);
 
   v8::Local<v8::Value> error_obj = v8::Exception::RangeError(str);
-  napi_status status = set_error_code(env, error_obj, nullptr, code);
-  if (status != napi_ok) return status;
+  STATUS_CALL(set_error_code(env, error_obj, nullptr, code));
 
   isolate->ThrowException(error_obj);
   // any VM calls after this point and before returning
@@ -2707,7 +2640,7 @@ napi_status napi_new_instance(napi_env env,
   auto maybe = ctor->NewInstance(context, argc,
     reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
 
-  CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe, napi_pending_exception);
 
   *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
   return GET_RETURN_STATUS(env);
@@ -2799,7 +2732,7 @@ napi_status napi_create_arraybuffer(napi_env env,
   // Optionally return a pointer to the buffer's data, to avoid another call to
   // retrieve it.
   if (data != nullptr) {
-    *data = buffer->GetContents().Data();
+    *data = buffer->GetBackingStore()->Data();
   }
 
   *result = v8impl::JsValueFromV8LocalValue(buffer);
@@ -2812,30 +2745,25 @@ napi_status napi_create_external_arraybuffer(napi_env env,
                                              napi_finalize finalize_cb,
                                              void* finalize_hint,
                                              napi_value* result) {
-  NAPI_PREAMBLE(env);
-  CHECK_ARG(env, result);
-
-  v8::Isolate* isolate = env->isolate;
-  v8::Local<v8::ArrayBuffer> buffer =
-      v8::ArrayBuffer::New(isolate, external_data, byte_length);
-  v8::Maybe<bool> marked = env->mark_arraybuffer_as_untransferable(buffer);
-  CHECK_MAYBE_NOTHING(env, marked, napi_generic_failure);
-
-  if (finalize_cb != nullptr) {
-    // Create a self-deleting weak reference that invokes the finalizer
-    // callback and detaches the ArrayBuffer if it still exists on Environment
-    // teardown.
-    v8impl::ArrayBufferReference::New(env,
-        buffer,
-        0,
-        true,
-        finalize_cb,
-        external_data,
-        finalize_hint);
-  }
-
-  *result = v8impl::JsValueFromV8LocalValue(buffer);
-  return GET_RETURN_STATUS(env);
+  // The API contract here is that the cleanup function runs on the JS thread,
+  // and is able to use napi_env. Implementing that properly is hard, so use the
+  // `Buffer` variant for easier implementation.
+  napi_value buffer;
+  STATUS_CALL(napi_create_external_buffer(
+      env,
+      byte_length,
+      external_data,
+      finalize_cb,
+      finalize_hint,
+      &buffer));
+  return napi_get_typedarray_info(
+      env,
+      buffer,
+      nullptr,
+      nullptr,
+      nullptr,
+      result,
+      nullptr);
 }
 
 napi_status napi_get_arraybuffer_info(napi_env env,
@@ -2848,15 +2776,15 @@ napi_status napi_get_arraybuffer_info(napi_env env,
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
   RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg);
 
-  v8::ArrayBuffer::Contents contents =
-      value.As<v8::ArrayBuffer>()->GetContents();
+  std::shared_ptr<v8::BackingStore> backing_store =
+      value.As<v8::ArrayBuffer>()->GetBackingStore();
 
   if (data != nullptr) {
-    *data = contents.Data();
+    *data = backing_store->Data();
   }
 
   if (byte_length != nullptr) {
-    *byte_length = contents.ByteLength();
+    *byte_length = backing_store->ByteLength();
   }
 
   return napi_clear_last_error(env);
@@ -2987,9 +2915,15 @@ napi_status napi_get_typedarray_info(napi_env env,
     *length = array->Length();
   }
 
-  v8::Local<v8::ArrayBuffer> buffer = array->Buffer();
+  v8::Local<v8::ArrayBuffer> buffer;
+  if (data != nullptr || arraybuffer != nullptr) {
+    // Calling Buffer() may have the side effect of allocating the buffer,
+    // so only do this when it’s needed.
+    buffer = array->Buffer();
+  }
+
   if (data != nullptr) {
-    *data = static_cast<uint8_t*>(buffer->GetContents().Data()) +
+    *data = static_cast<uint8_t*>(buffer->GetBackingStore()->Data()) +
             array->ByteOffset();
   }
 
@@ -3061,9 +2995,15 @@ napi_status napi_get_dataview_info(napi_env env,
     *byte_length = array->ByteLength();
   }
 
-  v8::Local<v8::ArrayBuffer> buffer = array->Buffer();
+  v8::Local<v8::ArrayBuffer> buffer;
+  if (data != nullptr || arraybuffer != nullptr) {
+    // Calling Buffer() may have the side effect of allocating the buffer,
+    // so only do this when it’s needed.
+    buffer = array->Buffer();
+  }
+
   if (data != nullptr) {
-    *data = static_cast<uint8_t*>(buffer->GetContents().Data()) +
+    *data = static_cast<uint8_t*>(buffer->GetBackingStore()->Data()) +
             array->ByteOffset();
   }
 
@@ -3267,8 +3207,6 @@ napi_status napi_detach_arraybuffer(napi_env env, napi_value arraybuffer) {
       env, value->IsArrayBuffer(), napi_arraybuffer_expected);
 
   v8::Local<v8::ArrayBuffer> it = value.As<v8::ArrayBuffer>();
-  RETURN_STATUS_IF_FALSE(
-      env, it->IsExternal(), napi_detachable_arraybuffer_expected);
   RETURN_STATUS_IF_FALSE(
       env, it->IsDetachable(), napi_detachable_arraybuffer_expected);
 
@@ -3287,7 +3225,7 @@ napi_status napi_is_detached_arraybuffer(napi_env env,
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
 
   *result = value->IsArrayBuffer() &&
-            value.As<v8::ArrayBuffer>()->GetContents().Data() == nullptr;
+            value.As<v8::ArrayBuffer>()->GetBackingStore()->Data() == nullptr;
 
   return napi_clear_last_error(env);
 }
diff --git a/src/js_native_api_v8.h b/src/js_native_api_v8.h
index 06b8049ec46db0b05541034f3af66dd6516a33a3..91c2eeb98989ca284adfe6ceb3971f0e7f499c20 100644
--- a/src/js_native_api_v8.h
+++ b/src/js_native_api_v8.h
@@ -122,6 +122,37 @@ struct napi_env__ {
   void* instance_data = nullptr;
 };
 
+// This class is used to keep a napi_env live in a way that
+// is exception safe versus calling Ref/Unref directly
+class EnvRefHolder {
+ public:
+  explicit EnvRefHolder(napi_env env) : _env(env) {
+      _env->Ref();
+  }
+
+  explicit EnvRefHolder(const EnvRefHolder& other): _env(other.env()) {
+    _env->Ref();
+  }
+
+  EnvRefHolder(EnvRefHolder&& other) {
+    _env = other._env;
+    other._env = nullptr;
+  }
+
+  ~EnvRefHolder() {
+    if (_env != nullptr) {
+      _env->Unref();
+    }
+  }
+
+  napi_env env(void) const {
+    return _env;
+  }
+
+ private:
+  napi_env _env;
+};
+
 static inline napi_status napi_clear_last_error(napi_env env) {
   env->last_error.error_code = napi_ok;
 
@@ -335,6 +366,86 @@ class TryCatch : public v8::TryCatch {
   napi_env _env;
 };
 
+// Wrapper around v8impl::Persistent that implements reference counting.
+class RefBase : protected Finalizer, RefTracker {
+ protected:
+  RefBase(napi_env env,
+          uint32_t initial_refcount,
+          bool delete_self,
+          napi_finalize finalize_callback,
+          void* finalize_data,
+          void* finalize_hint);
+
+ public:
+  static RefBase* New(napi_env env,
+                      uint32_t initial_refcount,
+                      bool delete_self,
+                      napi_finalize finalize_callback,
+                      void* finalize_data,
+                      void* finalize_hint);
+
+  static inline void Delete(RefBase* reference);
+
+  virtual ~RefBase();
+  void* Data();
+  uint32_t Ref();
+  uint32_t Unref();
+  uint32_t RefCount();
+
+ protected:
+  void Finalize(bool is_env_teardown = false) override;
+
+ private:
+  uint32_t _refcount;
+  bool _delete_self;
+};
+
+class Reference : public RefBase {
+  using SecondPassCallParameterRef = Reference*;
+
+ protected:
+  template <typename... Args>
+  Reference(napi_env env, v8::Local<v8::Value> value, Args&&... args);
+
+ public:
+  static Reference* New(napi_env env,
+                        v8::Local<v8::Value> value,
+                        uint32_t initial_refcount,
+                        bool delete_self,
+                        napi_finalize finalize_callback = nullptr,
+                        void* finalize_data = nullptr,
+                        void* finalize_hint = nullptr);
+
+  virtual ~Reference();
+  uint32_t Ref();
+  uint32_t Unref();
+  v8::Local<v8::Value> Get();
+
+ protected:
+  void Finalize(bool is_env_teardown = false) override;
+
+ private:
+  void ClearWeak();
+  void SetWeak();
+
+  static void FinalizeCallback(
+      const v8::WeakCallbackInfo<SecondPassCallParameterRef>& data);
+  static void SecondPassCallback(
+      const v8::WeakCallbackInfo<SecondPassCallParameterRef>& data);
+
+  v8impl::Persistent<v8::Value> _persistent;
+  SecondPassCallParameterRef* _secondPassParameter;
+  bool _secondPassScheduled;
+
+  FRIEND_TEST(JsNativeApiV8Test, Reference);
+};
+
 }  // end of namespace v8impl
 
+#define STATUS_CALL(call)                 \
+  do {                                    \
+    napi_status status = (call);          \
+    if (status != napi_ok) return status; \
+  } while (0)
+
 #endif  // SRC_JS_NATIVE_API_V8_H_
diff --git a/src/js_native_api_v8_internals.h b/src/js_native_api_v8_internals.h
index ddd219818cdfa97115432682c2ddd049aff2802e..8428390ef1eaf34e8a9e083a259d382790abf094 100644
--- a/src/js_native_api_v8_internals.h
+++ b/src/js_native_api_v8_internals.h
@@ -16,6 +16,7 @@
 #include "node_version.h"
 #include "env.h"
 #include "node_internals.h"
+#include "gtest/gtest_prod.h"
 
 #define NAPI_ARRAYSIZE(array) \
   node::arraysize((array))
diff --git a/src/js_stream.cc b/src/js_stream.cc
index e4da0ce747e3a0a865664115066390f5aaeed411..399e073efba69771e391c7893c8b0d10e8eecca2 100644
--- a/src/js_stream.cc
+++ b/src/js_stream.cc
@@ -19,7 +19,6 @@ using v8::HandleScope;
 using v8::Int32;
 using v8::Local;
 using v8::Object;
-using v8::String;
 using v8::Value;
 
 
@@ -200,9 +199,6 @@ void JSStream::Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  Local<String> jsStreamString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "JSStream");
-  t->SetClassName(jsStreamString);
   t->InstanceTemplate()
     ->SetInternalFieldCount(StreamBase::kInternalFieldCount);
   t->Inherit(AsyncWrap::GetConstructorTemplate(env));
@@ -213,9 +209,7 @@ void JSStream::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "emitEOF", EmitEOF);
 
   StreamBase::AddMethods(env, t);
-  target->Set(env->context(),
-              jsStreamString,
-              t->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "JSStream", t);
 }
 
 }  // namespace node
diff --git a/src/js_udp_wrap.cc b/src/js_udp_wrap.cc
index c51683141186f07f1b033c832fe3581d4c05a493..6a9bda5cad1ecb739ae573a57aea3ab6937f5b26 100644
--- a/src/js_udp_wrap.cc
+++ b/src/js_udp_wrap.cc
@@ -16,7 +16,6 @@ using v8::HandleScope;
 using v8::Int32;
 using v8::Local;
 using v8::Object;
-using v8::String;
 using v8::Value;
 
 // JSUDPWrap is a testing utility used by test/common/udppair.js
@@ -195,9 +194,6 @@ void JSUDPWrap::Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  Local<String> js_udp_wrap_string =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "JSUDPWrap");
-  t->SetClassName(js_udp_wrap_string);
   t->InstanceTemplate()
     ->SetInternalFieldCount(UDPWrapBase::kUDPWrapBaseField + 1);
   t->Inherit(AsyncWrap::GetConstructorTemplate(env));
@@ -207,9 +203,7 @@ void JSUDPWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "onSendDone", OnSendDone);
   env->SetProtoMethod(t, "onAfterBind", OnAfterBind);
 
-  target->Set(env->context(),
-              js_udp_wrap_string,
-              t->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "JSUDPWrap", t);
 }
 
 
diff --git a/src/large_pages/node_large_page.cc b/src/large_pages/node_large_page.cc
index a4b109d1b0ef69b6182c773f1bee5851d5db995c..eb546c581a165211af3e6e58a13526c03c9e729a 100644
--- a/src/large_pages/node_large_page.cc
+++ b/src/large_pages/node_large_page.cc
@@ -258,21 +258,21 @@ struct text_region FindNodeTextRegion() {
 
 #if defined(__linux__)
 bool IsTransparentHugePagesEnabled() {
-  std::ifstream ifs;
-
-  ifs.open("/sys/kernel/mm/transparent_hugepage/enabled");
-  if (!ifs) {
+  // File format reference:
+  // https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/huge_memory.c?id=13391c60da3308ed9980de0168f74cce6c62ac1d#n163
+  const char* filename = "/sys/kernel/mm/transparent_hugepage/enabled";
+  std::ifstream config_stream(filename, std::ios::in);
+  if (!config_stream.good()) {
     PrintWarning("could not open /sys/kernel/mm/transparent_hugepage/enabled");
     return false;
   }
 
-  std::string always, madvise;
-  if (ifs.is_open()) {
-    while (ifs >> always >> madvise) {}
-  }
-  ifs.close();
-
-  return always == "[always]" || madvise == "[madvise]";
+  std::string token;
+  config_stream >> token;
+  if ("[always]" == token) return true;
+  config_stream >> token;
+  if ("[madvise]" == token) return true;
+  return false;
 }
 #elif defined(__FreeBSD__)
 bool IsSuperPagesEnabled() {
diff --git a/src/large_pages/node_text_start.S b/src/large_pages/node_text_start.S
index 1609b254f0495a32f8896ba96d96bad03f6f2321..d27dd39cc236f0e6be4e68113bfff7b531a37455 100644
--- a/src/large_pages/node_text_start.S
+++ b/src/large_pages/node_text_start.S
@@ -1,3 +1,6 @@
+#if defined(__ELF__)
+.section .note.GNU-stack,"",%progbits
+#endif
 .text
 .align 0x2000
 .global __node_text_start
diff --git a/src/memory_tracker-inl.h b/src/memory_tracker-inl.h
index 36ef0f5b38403cb77ecac73ea029fd8410db5db6..0ba44f1f16efbb4b0b4aef96051294952bd5f3af 100644
--- a/src/memory_tracker-inl.h
+++ b/src/memory_tracker-inl.h
@@ -22,7 +22,7 @@ inline const char* GetNodeName(const char* node_name, const char* edge_name) {
 class MemoryRetainerNode : public v8::EmbedderGraph::Node {
  public:
   inline MemoryRetainerNode(MemoryTracker* tracker,
-                                     const MemoryRetainer* retainer)
+                            const MemoryRetainer* retainer)
       : retainer_(retainer) {
     CHECK_NOT_NULL(retainer_);
     v8::HandleScope handle_scope(tracker->isolate());
@@ -34,9 +34,9 @@ class MemoryRetainerNode : public v8::EmbedderGraph::Node {
   }
 
   inline MemoryRetainerNode(MemoryTracker* tracker,
-                                     const char* name,
-                                     size_t size,
-                                     bool is_root_node = false)
+                            const char* name,
+                            size_t size,
+                            bool is_root_node = false)
       : retainer_(nullptr) {
     name_ = name;
     size_ = size;
@@ -117,6 +117,16 @@ void MemoryTracker::TrackField(const char* edge_name,
   TrackField(edge_name, value.get(), node_name);
 }
 
+template <typename T>
+void MemoryTracker::TrackField(const char* edge_name,
+                               const std::shared_ptr<T>& value,
+                               const char* node_name) {
+  if (value.get() == nullptr) {
+    return;
+  }
+  TrackField(edge_name, value.get(), node_name);
+}
+
 template <typename T, bool kIsWeak>
 void MemoryTracker::TrackField(const char* edge_name,
                                const BaseObjectPtrImpl<T, kIsWeak>& value,
@@ -223,6 +233,12 @@ void MemoryTracker::TrackField(const char* edge_name,
   TrackFieldWithSize(edge_name, value.size, "MallocedBuffer");
 }
 
+void MemoryTracker::TrackField(const char* edge_name,
+                               const v8::BackingStore* value,
+                               const char* node_name) {
+  TrackFieldWithSize(edge_name, value->ByteLength(), "BackingStore");
+}
+
 void MemoryTracker::TrackField(const char* name,
                                const uv_buf_t& value,
                                const char* node_name) {
diff --git a/src/memory_tracker.h b/src/memory_tracker.h
index 83443cbd6bf6794d9985985bb1752f9225cadbd4..1896624bbeb9dd25579627cc9fa9e1fc0e38ef37 100644
--- a/src/memory_tracker.h
+++ b/src/memory_tracker.h
@@ -145,6 +145,11 @@ class MemoryTracker {
                          const std::unique_ptr<T, D>& value,
                          const char* node_name = nullptr);
 
+  template <typename T>
+  inline void TrackField(const char* edge_name,
+                         const std::shared_ptr<T>& value,
+                         const char* node_name = nullptr);
+
   template <typename T, bool kIsWeak>
   void TrackField(const char* edge_name,
                   const BaseObjectPtrImpl<T, kIsWeak>& value,
@@ -208,6 +213,9 @@ class MemoryTracker {
   inline void TrackField(const char* edge_name,
                          const MallocedBuffer<T>& value,
                          const char* node_name = nullptr);
+  inline void TrackField(const char* edge_name,
+                         const v8::BackingStore* value,
+                         const char* node_name = nullptr);
   inline void TrackField(const char* edge_name,
                          const uv_buf_t& value,
                          const char* node_name = nullptr);
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index 6f052f554518e73ad8de02305f04bda22757c83b..b80e23327e818e84ed426b41bdb304c1c6f9c658 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -5,7 +5,7 @@
 #include "node_contextify.h"
 #include "node_errors.h"
 #include "node_internals.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "node_url.h"
 #include "node_watchdog.h"
 #include "util-inl.h"
@@ -23,7 +23,6 @@ using node::contextify::ContextifyContext;
 using node::url::URL;
 using node::url::URL_FLAGS_FAILED;
 using v8::Array;
-using v8::ArrayBuffer;
 using v8::ArrayBufferView;
 using v8::Context;
 using v8::EscapableHandleScope;
@@ -36,6 +35,7 @@ using v8::IntegrityLevel;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
+using v8::MicrotaskQueue;
 using v8::Module;
 using v8::Number;
 using v8::Object;
@@ -55,9 +55,13 @@ ModuleWrap::ModuleWrap(Environment* env,
                        Local<String> url)
   : BaseObject(env, object),
     module_(env->isolate(), module),
-    url_(env->isolate(), url),
     id_(env->get_next_module_id()) {
   env->id_to_module_map.emplace(id_, this);
+
+  Local<Value> undefined = Undefined(env->isolate());
+  object->SetInternalField(kURLSlot, url);
+  object->SetInternalField(kSyntheticEvaluationStepsSlot, undefined);
+  object->SetInternalField(kContextObjectSlot, undefined);
 }
 
 ModuleWrap::~ModuleWrap() {
@@ -73,6 +77,12 @@ ModuleWrap::~ModuleWrap() {
   }
 }
 
+Local<Context> ModuleWrap::context() const {
+  Local<Value> obj = object()->GetInternalField(kContextObjectSlot);
+  if (obj.IsEmpty()) return {};
+  return obj.As<Object>()->CreationContext();
+}
+
 ModuleWrap* ModuleWrap::GetFromModule(Environment* env,
                                       Local<Module> module) {
   auto range = env->hash_to_module_map.equal_range(module->GetIdentityHash());
@@ -107,15 +117,15 @@ void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
   Local<String> url = args[0].As<String>();
 
   Local<Context> context;
+  ContextifyContext* contextify_context = nullptr;
   if (args[1]->IsUndefined()) {
     context = that->CreationContext();
   } else {
     CHECK(args[1]->IsObject());
-    ContextifyContext* sandbox =
-        ContextifyContext::ContextFromContextifiedSandbox(
-            env, args[1].As<Object>());
-    CHECK_NOT_NULL(sandbox);
-    context = sandbox->context();
+    contextify_context = ContextifyContext::ContextFromContextifiedSandbox(
+        env, args[1].As<Object>());
+    CHECK_NOT_NULL(contextify_context);
+    context = contextify_context->context();
   }
 
   Local<Integer> line_offset;
@@ -166,9 +176,8 @@ void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
       if (!args[5]->IsUndefined()) {
         CHECK(args[5]->IsArrayBufferView());
         Local<ArrayBufferView> cached_data_buf = args[5].As<ArrayBufferView>();
-        ArrayBuffer::Contents contents =
-            cached_data_buf->Buffer()->GetContents();
-        uint8_t* data = static_cast<uint8_t*>(contents.Data());
+        uint8_t* data = static_cast<uint8_t*>(
+            cached_data_buf->Buffer()->GetBackingStore()->Data());
         cached_data =
             new ScriptCompiler::CachedData(data + cached_data_buf->ByteOffset(),
                                            cached_data_buf->ByteLength());
@@ -221,11 +230,15 @@ void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
 
   if (synthetic) {
     obj->synthetic_ = true;
-    obj->synthetic_evaluation_steps_.Reset(
-        env->isolate(), args[3].As<Function>());
+    obj->object()->SetInternalField(kSyntheticEvaluationStepsSlot, args[3]);
   }
 
-  obj->context_.Reset(isolate, context);
+  // Use the extras object as an object whose CreationContext() will be the
+  // original `context`, since the `Context` itself strictly speaking cannot
+  // be stored in an internal field.
+  obj->object()->SetInternalField(kContextObjectSlot,
+      context->GetExtrasBindingObject());
+  obj->contextify_context_ = contextify_context;
 
   env->hash_to_module_map.emplace(module->GetIdentityHash(), obj);
 
@@ -254,7 +267,7 @@ void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
 
   Local<Function> resolver_arg = args[0].As<Function>();
 
-  Local<Context> mod_context = obj->context_.Get(isolate);
+  Local<Context> mod_context = obj->context();
   Local<Module> module = obj->module_.Get(isolate);
 
   const int module_requests_length = module->GetModuleRequestsLength();
@@ -278,7 +291,9 @@ void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
     Local<Value> resolve_return_value =
         maybe_resolve_return_value.ToLocalChecked();
     if (!resolve_return_value->IsPromise()) {
-      env->ThrowError("linking error, expected resolver to return a promise");
+      THROW_ERR_VM_MODULE_LINK_FAILURE(
+          env, "request for '%s' did not return promise", specifier_std);
+      return;
     }
     Local<Promise> resolve_promise = resolve_return_value.As<Promise>();
     obj->resolve_cache_[specifier_std].Reset(env->isolate(), resolve_promise);
@@ -295,7 +310,7 @@ void ModuleWrap::Instantiate(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   ModuleWrap* obj;
   ASSIGN_OR_RETURN_UNWRAP(&obj, args.This());
-  Local<Context> context = obj->context_.Get(isolate);
+  Local<Context> context = obj->context();
   Local<Module> module = obj->module_.Get(isolate);
   TryCatchScope try_catch(env);
   USE(module->InstantiateModule(context, ResolveCallback));
@@ -318,9 +333,14 @@ void ModuleWrap::Evaluate(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = env->isolate();
   ModuleWrap* obj;
   ASSIGN_OR_RETURN_UNWRAP(&obj, args.This());
-  Local<Context> context = obj->context_.Get(isolate);
+  Local<Context> context = obj->context();
   Local<Module> module = obj->module_.Get(isolate);
 
+  ContextifyContext* contextify_context = obj->contextify_context_;
+  std::shared_ptr<MicrotaskQueue> microtask_queue;
+  if (contextify_context != nullptr)
+      microtask_queue = contextify_context->microtask_queue();
+
   // module.evaluate(timeout, breakOnSigint)
   CHECK_EQ(args.Length(), 2);
 
@@ -332,22 +352,29 @@ void ModuleWrap::Evaluate(const FunctionCallbackInfo<Value>& args) {
 
   ShouldNotAbortOnUncaughtScope no_abort_scope(env);
   TryCatchScope try_catch(env);
+  Isolate::SafeForTerminationScope safe_for_termination(env->isolate());
 
   bool timed_out = false;
   bool received_signal = false;
   MaybeLocal<Value> result;
+  auto run = [&]() {
+    MaybeLocal<Value> result = module->Evaluate(context);
+    if (!result.IsEmpty() && microtask_queue)
+      microtask_queue->PerformCheckpoint(isolate);
+    return result;
+  };
   if (break_on_sigint && timeout != -1) {
     Watchdog wd(isolate, timeout, &timed_out);
     SigintWatchdog swd(isolate, &received_signal);
-    result = module->Evaluate(context);
+    result = run();
   } else if (break_on_sigint) {
     SigintWatchdog swd(isolate, &received_signal);
-    result = module->Evaluate(context);
+    result = run();
   } else if (timeout != -1) {
     Watchdog wd(isolate, timeout, &timed_out);
-    result = module->Evaluate(context);
+    result = run();
   } else {
-    result = module->Evaluate(context);
+    result = run();
   }
 
   if (result.IsEmpty()) {
@@ -375,7 +402,13 @@ void ModuleWrap::Evaluate(const FunctionCallbackInfo<Value>& args) {
     return;
   }
 
-  args.GetReturnValue().Set(result.ToLocalChecked());
+  // If TLA is enabled, `result` is the evaluation's promise.
+  // Otherwise, `result` is the last evaluated value of the module,
+  // which could be a promise, which would result in it being incorrectly
+  // unwrapped when the higher level code awaits the evaluation.
+  if (env->isolate_data()->options()->experimental_top_level_await) {
+    args.GetReturnValue().Set(result.ToLocalChecked());
+  }
 }
 
 void ModuleWrap::GetNamespace(const FunctionCallbackInfo<Value>& args) {
@@ -387,13 +420,17 @@ void ModuleWrap::GetNamespace(const FunctionCallbackInfo<Value>& args) {
   Local<Module> module = obj->module_.Get(isolate);
 
   switch (module->GetStatus()) {
-    default:
+    case v8::Module::Status::kUninstantiated:
+    case v8::Module::Status::kInstantiating:
       return env->ThrowError(
-          "cannot get namespace, Module has not been instantiated");
+          "cannot get namespace, module has not been instantiated");
     case v8::Module::Status::kInstantiated:
     case v8::Module::Status::kEvaluating:
     case v8::Module::Status::kEvaluated:
+    case v8::Module::Status::kErrored:
       break;
+    default:
+      UNREACHABLE();
   }
 
   Local<Value> result = module->GetModuleNamespace();
@@ -450,17 +487,19 @@ MaybeLocal<Module> ModuleWrap::ResolveCallback(Local<Context> context,
 
   Isolate* isolate = env->isolate();
 
+  Utf8Value specifier_utf8(isolate, specifier);
+  std::string specifier_std(*specifier_utf8, specifier_utf8.length());
+
   ModuleWrap* dependent = GetFromModule(env, referrer);
   if (dependent == nullptr) {
-    env->ThrowError("linking error, null dep");
+    THROW_ERR_VM_MODULE_LINK_FAILURE(
+        env, "request for '%s' is from invalid module", specifier_std);
     return MaybeLocal<Module>();
   }
 
-  Utf8Value specifier_utf8(isolate, specifier);
-  std::string specifier_std(*specifier_utf8, specifier_utf8.length());
-
   if (dependent->resolve_cache_.count(specifier_std) != 1) {
-    env->ThrowError("linking error, not in local cache");
+    THROW_ERR_VM_MODULE_LINK_FAILURE(
+        env, "request for '%s' is not in cache", specifier_std);
     return MaybeLocal<Module>();
   }
 
@@ -468,15 +507,15 @@ MaybeLocal<Module> ModuleWrap::ResolveCallback(Local<Context> context,
       dependent->resolve_cache_[specifier_std].Get(isolate);
 
   if (resolve_promise->State() != Promise::kFulfilled) {
-    env->ThrowError("linking error, dependency promises must be resolved on "
-                    "instantiate");
+    THROW_ERR_VM_MODULE_LINK_FAILURE(
+        env, "request for '%s' is not yet fulfilled", specifier_std);
     return MaybeLocal<Module>();
   }
 
   Local<Object> module_object = resolve_promise->Result().As<Object>();
   if (module_object.IsEmpty() || !module_object->IsObject()) {
-    env->ThrowError("linking error, expected a valid module object from "
-                    "resolver");
+    THROW_ERR_VM_MODULE_LINK_FAILURE(
+        env, "request for '%s' did not return an object", specifier_std);
     return MaybeLocal<Module>();
   }
 
@@ -615,20 +654,29 @@ MaybeLocal<Value> ModuleWrap::SyntheticModuleEvaluationStepsCallback(
 
   TryCatchScope try_catch(env);
   Local<Function> synthetic_evaluation_steps =
-      obj->synthetic_evaluation_steps_.Get(isolate);
+      obj->object()->GetInternalField(kSyntheticEvaluationStepsSlot)
+          .As<Function>();
+  obj->object()->SetInternalField(
+      kSyntheticEvaluationStepsSlot, Undefined(isolate));
   MaybeLocal<Value> ret = synthetic_evaluation_steps->Call(context,
       obj->object(), 0, nullptr);
   if (ret.IsEmpty()) {
     CHECK(try_catch.HasCaught());
   }
-  obj->synthetic_evaluation_steps_.Reset();
   if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
     CHECK(!try_catch.Message().IsEmpty());
     CHECK(!try_catch.Exception().IsEmpty());
     try_catch.ReThrow();
     return MaybeLocal<Value>();
   }
-  return ret;
+
+  Local<Promise::Resolver> resolver;
+  if (!Promise::Resolver::New(context).ToLocal(&resolver)) {
+    return MaybeLocal<Value>();
+  }
+
+  resolver->Resolve(context, Undefined(isolate)).ToChecked();
+  return resolver->GetPromise();
 }
 
 void ModuleWrap::SetSyntheticExport(const FunctionCallbackInfo<Value>& args) {
@@ -685,10 +733,8 @@ void ModuleWrap::Initialize(Local<Object> target,
                             Local<Context> context,
                             void* priv) {
   Environment* env = Environment::GetCurrent(context);
-  Isolate* isolate = env->isolate();
 
   Local<FunctionTemplate> tpl = env->NewFunctionTemplate(New);
-  tpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"));
   tpl->InstanceTemplate()->SetInternalFieldCount(
       ModuleWrap::kInternalFieldCount);
   tpl->Inherit(BaseObject::GetConstructorTemplate(env));
@@ -704,8 +750,8 @@ void ModuleWrap::Initialize(Local<Object> target,
   env->SetProtoMethodNoSideEffect(tpl, "getStaticDependencySpecifiers",
                                   GetStaticDependencySpecifiers);
 
-  target->Set(env->context(), FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"),
-              tpl->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "ModuleWrap", tpl);
+
   env->SetMethod(target,
                  "setImportModuleDynamicallyCallback",
                  SetImportModuleDynamicallyCallback);
diff --git a/src/module_wrap.h b/src/module_wrap.h
index cd51a497acd87e01371f7c9fc12a4065fe9ee81b..dc7726f11d94fd961b0bb629ebe0633b3e41428f 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -12,6 +12,10 @@ namespace node {
 
 class Environment;
 
+namespace contextify {
+class ContextifyContext;
+}
+
 namespace loader {
 
 enum ScriptType : int {
@@ -28,6 +32,14 @@ enum HostDefinedOptions : int {
 
 class ModuleWrap : public BaseObject {
  public:
+  enum InternalFields {
+    kModuleWrapBaseField = BaseObject::kInternalFieldCount,
+    kURLSlot,
+    kSyntheticEvaluationStepsSlot,
+    kContextObjectSlot,  // Object whose creation context is the target Context
+    kInternalFieldCount
+  };
+
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context,
@@ -38,16 +50,22 @@ class ModuleWrap : public BaseObject {
       v8::Local<v8::Object> meta);
 
   void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("url", url_);
     tracker->TrackField("resolve_cache", resolve_cache_);
   }
 
   inline uint32_t id() { return id_; }
+  v8::Local<v8::Context> context() const;
   static ModuleWrap* GetFromID(node::Environment*, uint32_t id);
 
   SET_MEMORY_INFO_NAME(ModuleWrap)
   SET_SELF_SIZE(ModuleWrap)
 
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
+    // XXX: The garbage collection rules for ModuleWrap are *super* unclear.
+    // Do these objects ever get GC'd? Are we just okay with leaking them?
+    return true;
+  }
+
  private:
   ModuleWrap(Environment* env,
              v8::Local<v8::Object> object,
@@ -81,13 +99,11 @@ class ModuleWrap : public BaseObject {
       v8::Local<v8::Module> referrer);
   static ModuleWrap* GetFromModule(node::Environment*, v8::Local<v8::Module>);
 
-  v8::Global<v8::Function> synthetic_evaluation_steps_;
-  bool synthetic_ = false;
   v8::Global<v8::Module> module_;
-  v8::Global<v8::String> url_;
-  bool linked_ = false;
   std::unordered_map<std::string, v8::Global<v8::Promise>> resolve_cache_;
-  v8::Global<v8::Context> context_;
+  contextify::ContextifyContext* contextify_context_ = nullptr;
+  bool synthetic_ = false;
+  bool linked_ = false;
   uint32_t id_;
 };
 
diff --git a/src/node.cc b/src/node.cc
index 46e8f74cc286f73f5c45132d96907250d3620568..e0e74d83c3010d37f72bbda38423118e9f741a60 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -26,6 +26,7 @@
 #include "debug_utils-inl.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
+#include "histogram-inl.h"
 #include "node_binding.h"
 #include "node_errors.h"
 #include "node_internals.h"
@@ -34,13 +35,14 @@
 #include "node_native_module_env.h"
 #include "node_options-inl.h"
 #include "node_perf.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "node_report.h"
 #include "node_revert.h"
 #include "node_v8_platform-inl.h"
 #include "node_version.h"
 
 #if HAVE_OPENSSL
+#include "allocated_buffer-inl.h"  // Inlined functions needed by node_crypto.h
 #include "node_crypto.h"
 #endif
 
@@ -68,6 +70,17 @@
 
 #include "large_pages/node_large_page.h"
 
+#if defined(__APPLE__) || defined(__linux__)
+#define NODE_USE_V8_WASM_TRAP_HANDLER 1
+#else
+#define NODE_USE_V8_WASM_TRAP_HANDLER 0
+#endif
+
+#if NODE_USE_V8_WASM_TRAP_HANDLER
+#include <atomic>
+#include "v8-wasm-trap-handler-posix.h"
+#endif  // NODE_USE_V8_WASM_TRAP_HANDLER
+
 // ========== global C headers ==========
 
 #include <fcntl.h>  // _O_RDWR
@@ -136,24 +149,17 @@ bool v8_initialized = false;
 // node_internals.h
 // process-relative uptime base in nanoseconds, initialized in node::Start()
 uint64_t node_start_time;
-// Tells whether --prof is passed.
-bool v8_is_profiling = false;
 
 // node_v8_platform-inl.h
 struct V8Platform v8_platform;
 }  // namespace per_process
 
-void SignalExit(int signo) {
+#ifdef __POSIX__
+void SignalExit(int signo, siginfo_t* info, void* ucontext) {
   ResetStdio();
-#ifdef __FreeBSD__
-  // FreeBSD has a nasty bug, see RegisterSignalHandler for details
-  struct sigaction sa;
-  memset(&sa, 0, sizeof(sa));
-  sa.sa_handler = SIG_DFL;
-  CHECK_EQ(sigaction(signo, &sa, nullptr), 0);
-#endif
   raise(signo);
 }
+#endif  // __POSIX__
 
 MaybeLocal<Value> ExecuteBootstrapper(Environment* env,
                                       const char* id,
@@ -221,11 +227,60 @@ int Environment::InitializeInspector(
 }
 #endif  // HAVE_INSPECTOR && NODE_USE_V8_PLATFORM
 
+#define ATOMIC_WAIT_EVENTS(V)                                               \
+  V(kStartWait,           "started")                                        \
+  V(kWokenUp,             "was woken up by another thread")                 \
+  V(kTimedOut,            "timed out")                                      \
+  V(kTerminatedExecution, "was stopped by terminated execution")            \
+  V(kAPIStopped,          "was stopped through the embedder API")           \
+  V(kNotEqual,            "did not wait because the values mismatched")     \
+
+static void AtomicsWaitCallback(Isolate::AtomicsWaitEvent event,
+                                Local<v8::SharedArrayBuffer> array_buffer,
+                                size_t offset_in_bytes, int64_t value,
+                                double timeout_in_ms,
+                                Isolate::AtomicsWaitWakeHandle* stop_handle,
+                                void* data) {
+  Environment* env = static_cast<Environment*>(data);
+
+  const char* message = "(unknown event)";
+  switch (event) {
+#define V(key, msg)                         \
+    case Isolate::AtomicsWaitEvent::key:    \
+      message = msg;                        \
+      break;
+    ATOMIC_WAIT_EVENTS(V)
+#undef V
+  }
+
+  fprintf(stderr,
+          "(node:%d) [Thread %" PRIu64 "] Atomics.wait(%p + %zx, %" PRId64
+              ", %.f) %s\n",
+          static_cast<int>(uv_os_getpid()),
+          env->thread_id(),
+          array_buffer->GetBackingStore()->Data(),
+          offset_in_bytes,
+          value,
+          timeout_in_ms,
+          message);
+}
+
 void Environment::InitializeDiagnostics() {
   isolate_->GetHeapProfiler()->AddBuildEmbedderGraphCallback(
       Environment::BuildEmbedderGraph, this);
+  if (options_->heap_snapshot_near_heap_limit > 0) {
+    isolate_->AddNearHeapLimitCallback(Environment::NearHeapLimitCallback,
+                                       this);
+  }
   if (options_->trace_uncaught)
     isolate_->SetCaptureStackTraceForUncaughtExceptions(true);
+  if (options_->trace_atomics_wait) {
+    isolate_->SetAtomicsWaitCallback(AtomicsWaitCallback, this);
+    AddCleanupHook([](void* data) {
+      Environment* env = static_cast<Environment*>(data);
+      env->isolate()->SetAtomicsWaitCallback(nullptr, nullptr);
+    }, this);
+  }
 
 #if defined HAVE_DTRACE || defined HAVE_ETW
   InitDTrace(this);
@@ -323,8 +378,7 @@ MaybeLocal<Value> Environment::BootstrapNode() {
 
   Local<String> env_string = FIXED_ONE_BYTE_STRING(isolate_, "env");
   Local<Object> env_var_proxy;
-  if (!CreateEnvVarProxy(context(), isolate_, as_callback_data())
-           .ToLocal(&env_var_proxy) ||
+  if (!CreateEnvVarProxy(context(), isolate_).ToLocal(&env_var_proxy) ||
       process_object()->Set(context(), env_string, env_var_proxy).IsNothing()) {
     return MaybeLocal<Value>();
   }
@@ -486,17 +540,21 @@ void TrapWebAssemblyOrContinue(int signo, siginfo_t* info, void* ucontext) {
 
 #ifdef __POSIX__
 void RegisterSignalHandler(int signal,
-                           void (*handler)(int signal),
+                           sigaction_cb handler,
                            bool reset_handler) {
+  CHECK_NOT_NULL(handler);
+#if NODE_USE_V8_WASM_TRAP_HANDLER
+  if (signal == SIGSEGV) {
+    CHECK(previous_sigsegv_action.is_lock_free());
+    CHECK(!reset_handler);
+    previous_sigsegv_action.store(handler);
+    return;
+  }
+#endif  // NODE_USE_V8_WASM_TRAP_HANDLER
   struct sigaction sa;
   memset(&sa, 0, sizeof(sa));
-  sa.sa_handler = handler;
-#ifndef __FreeBSD__
-  // FreeBSD has a nasty bug with SA_RESETHAND reseting the SA_SIGINFO, that is
-  // in turn set for a libthr wrapper. This leads to a crash.
-  // Work around the issue by manually setting SIG_DFL in the signal handler
+  sa.sa_sigaction = handler;
   sa.sa_flags = reset_handler ? SA_RESETHAND : 0;
-#endif
   sigfillset(&sa.sa_mask);
   CHECK_EQ(sigaction(signal, &sa, nullptr), 0);
 }
@@ -582,6 +640,21 @@ inline void PlatformInit() {
   RegisterSignalHandler(SIGINT, SignalExit, true);
   RegisterSignalHandler(SIGTERM, SignalExit, true);
 
+#if NODE_USE_V8_WASM_TRAP_HANDLER
+  // Tell V8 to disable emitting WebAssembly
+  // memory bounds checks. This means that we have
+  // to catch the SIGSEGV in TrapWebAssemblyOrContinue
+  // and pass the signal context to V8.
+  {
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_sigaction = TrapWebAssemblyOrContinue;
+    sa.sa_flags = SA_SIGINFO;
+    CHECK_EQ(sigaction(SIGSEGV, &sa, nullptr), 0);
+  }
+  V8::EnableWebAssemblyTrapHandler(false);
+#endif  // NODE_USE_V8_WASM_TRAP_HANDLER
+
   // Raise the open file descriptor limit.
   struct rlimit lim;
   if (getrlimit(RLIMIT_NOFILE, &lim) == 0 && lim.rlim_cur != lim.rlim_max) {
@@ -712,6 +785,13 @@ int ProcessGlobalArgs(std::vector<std::string>* args,
     return 12;
   }
 
+  // TODO(mylesborins): remove this when the harmony-top-level-await flag
+  // is removed in V8
+  if (std::find(v8_args.begin(), v8_args.end(),
+                "--no-harmony-top-level-await") == v8_args.end()) {
+    v8_args.push_back("--harmony-top-level-await");
+  }
+
   auto env_opts = per_process::cli_options->per_isolate->per_env;
   if (std::find(v8_args.begin(), v8_args.end(),
                 "--abort-on-uncaught-exception") != v8_args.end() ||
@@ -720,19 +800,11 @@ int ProcessGlobalArgs(std::vector<std::string>* args,
     env_opts->abort_on_uncaught_exception = true;
   }
 
-  // TODO(bnoordhuis) Intercept --prof arguments and start the CPU profiler
-  // manually?  That would give us a little more control over its runtime
-  // behavior but it could also interfere with the user's intentions in ways
-  // we fail to anticipate.  Dillema.
-  if (std::find(v8_args.begin(), v8_args.end(), "--prof") != v8_args.end()) {
-    per_process::v8_is_profiling = true;
-  }
-
 #ifdef __POSIX__
   // Block SIGPROF signals when sleeping in epoll_wait/kevent/etc.  Avoids the
   // performance penalty of frequent EINTR wakeups when the profiler is running.
   // Only do this for v8.log profiling, as it breaks v8::CpuProfiler users.
-  if (per_process::v8_is_profiling) {
+  if (std::find(v8_args.begin(), v8_args.end(), "--prof") != v8_args.end()) {
     uv_loop_configure(uv_default_loop(), UV_LOOP_BLOCK_SIGNAL, SIGPROF);
   }
 #endif
@@ -887,8 +959,8 @@ void Init(int* argc,
   }
 
   if (per_process::cli_options->print_v8_help) {
-    V8::SetFlagsFromString("--help", 6);  // Doesn't return.
-    UNREACHABLE();
+    V8::SetFlagsFromString("--help", static_cast<size_t>(6));
+    exit(0);
   }
 
   *argc = argv_.size();
@@ -950,12 +1022,16 @@ InitializationResult InitializeOncePerProcess(int argc, char** argv) {
   if (per_process::cli_options->print_bash_completion) {
     std::string completion = options_parser::GetBashCompletion();
     printf("%s\n", completion.c_str());
-    exit(0);
+    result.exit_code = 0;
+    result.early_return = true;
+    return result;
   }
 
   if (per_process::cli_options->print_v8_help) {
-    V8::SetFlagsFromString("--help", 6);  // Doesn't return.
-    UNREACHABLE();
+    V8::SetFlagsFromString("--help", static_cast<size_t>(6));
+    result.exit_code = 0;
+    result.early_return = true;
+    return result;
   }
 
 #if HAVE_OPENSSL
@@ -1006,9 +1082,9 @@ int Start(int argc, char** argv) {
     const std::vector<size_t>* indexes = nullptr;
     std::vector<intptr_t> external_references;
 
-    bool force_no_snapshot =
-        per_process::cli_options->per_isolate->no_node_snapshot;
-    if (!force_no_snapshot) {
+    bool use_no_snapshot =
+        per_process::cli_options->per_isolate->node_snapshot;
+    if (use_no_snapshot) {
       v8::StartupData* blob = NodeMainInstance::GetEmbeddedSnapshotBlob();
       if (blob != nullptr) {
         // TODO(joyeecheung): collect external references and set it in
diff --git a/src/node.h b/src/node.h
index e41af9d2c0c49ea382ecaeb0c4a7b787ed134d72..8d4ec2276b19900db3a4b2f24b7c946e39e6ff6e 100644
--- a/src/node.h
+++ b/src/node.h
@@ -75,6 +75,12 @@
 #include <memory>
 #include <functional>
 
+// We cannot use __POSIX__ in this header because that's only defined when
+// building Node.js.
+#ifndef _WIN32
+#include <signal.h>
+#endif  // _WIN32
+
 #define NODE_MAKE_VERSION(major, minor, patch)                                \
   ((major) * 0x1000 + (minor) * 0x100 + (patch))
 
@@ -111,6 +117,8 @@
 // Forward-declare libuv loop
 struct uv_loop_s;
 
+struct napi_module;
+
 // Forward-declare these functions now to stop MSVS from becoming
 // terminally confused when it's done in node_internals.h
 namespace node {
@@ -221,15 +229,14 @@ NODE_EXTERN int Start(int argc, char* argv[]);
 // in the loop and / or actively executing JavaScript code).
 NODE_EXTERN int Stop(Environment* env);
 
-// TODO(addaleax): Officially deprecate this and replace it with something
-// better suited for a public embedder API.
 // It is recommended to use InitializeNodeWithArgs() instead as an embedder.
 // Init() calls InitializeNodeWithArgs() and exits the process with the exit
 // code returned from it.
-NODE_EXTERN void Init(int* argc,
-                      const char** argv,
-                      int* exec_argc,
-                      const char*** exec_argv);
+NODE_DEPRECATED("Use InitializeNodeWithArgs() instead",
+    NODE_EXTERN void Init(int* argc,
+                          const char** argv,
+                          int* exec_argc,
+                          const char*** exec_argv));
 // Set up per-process state needed to run Node.js. This will consume arguments
 // from argv, fill exec_argv, and possibly add errors resulting from parsing
 // the arguments to `errors`. The return value is a suggested exit code for the
@@ -275,6 +282,12 @@ class NODE_EXTERN ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
 NODE_EXTERN ArrayBufferAllocator* CreateArrayBufferAllocator();
 NODE_EXTERN void FreeArrayBufferAllocator(ArrayBufferAllocator* allocator);
 
+class NODE_EXTERN IsolatePlatformDelegate {
+ public:
+  virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner() = 0;
+  virtual bool IdleTasksEnabled() = 0;
+};
+
 class NODE_EXTERN MultiIsolatePlatform : public v8::Platform {
  public:
   ~MultiIsolatePlatform() override = default;
@@ -296,6 +309,12 @@ class NODE_EXTERN MultiIsolatePlatform : public v8::Platform {
   // This function may only be called once per `Isolate`.
   virtual void RegisterIsolate(v8::Isolate* isolate,
                                struct uv_loop_s* loop) = 0;
+  // This method can be used when an application handles task scheduling on its
+  // own through `IsolatePlatformDelegate`. Upon registering an isolate with
+  // this overload any other method in this class with the exception of
+  // `UnregisterIsolate` *must not* be used on that isolate.
+  virtual void RegisterIsolate(v8::Isolate* isolate,
+                               IsolatePlatformDelegate* delegate) = 0;
 
   // This function may only be called once per `Isolate`, and discard any
   // pending delayed tasks scheduled for that isolate.
@@ -317,7 +336,8 @@ class NODE_EXTERN MultiIsolatePlatform : public v8::Platform {
 enum IsolateSettingsFlags {
   MESSAGE_LISTENER_WITH_ERROR_LEVEL = 1 << 0,
   DETAILED_SOURCE_POSITIONS_FOR_PROFILING = 1 << 1,
-  SHOULD_NOT_SET_PROMISE_REJECTION_CALLBACK = 1 << 2
+  SHOULD_NOT_SET_PROMISE_REJECTION_CALLBACK = 1 << 2,
+  SHOULD_NOT_SET_PREPARE_STACK_TRACE_CALLBACK = 1 << 3
 };
 
 struct IsolateSettings {
@@ -335,8 +355,6 @@ struct IsolateSettings {
   v8::PromiseRejectCallback promise_reject_callback = nullptr;
   v8::AllowWasmCodeGenerationCallback
       allow_wasm_code_generation_callback = nullptr;
-  v8::HostCleanupFinalizationGroupCallback
-      host_cleanup_finalization_group_callback = nullptr;
 };
 
 // Overriding IsolateSettings may produce unexpected behavior
@@ -357,6 +375,10 @@ NODE_EXTERN v8::Isolate* NewIsolate(ArrayBufferAllocator* allocator,
 NODE_EXTERN v8::Isolate* NewIsolate(ArrayBufferAllocator* allocator,
                                     struct uv_loop_s* event_loop,
                                     MultiIsolatePlatform* platform);
+NODE_EXTERN v8::Isolate* NewIsolate(
+    std::shared_ptr<ArrayBufferAllocator> allocator,
+    struct uv_loop_s* event_loop,
+    MultiIsolatePlatform* platform);
 
 // Creates a new context with Node.js-specific tweaks.
 NODE_EXTERN v8::Local<v8::Context> NewContext(
@@ -402,7 +424,11 @@ enum Flags : uint64_t {
   kNoRegisterESMLoader = 1 << 3,
   // Set this flag to make Node.js track "raw" file descriptors, i.e. managed
   // by fs.open() and fs.close(), and close them during FreeEnvironment().
-  kTrackUnmanagedFds = 1 << 4
+  kTrackUnmanagedFds = 1 << 4,
+  // Set this flag to force hiding console windows when spawning child
+  // processes. This is usually used when embedding Node.js in GUI programs on
+  // Windows.
+  kHideConsoleWindows = 1 << 5
 };
 }  // namespace EnvironmentFlags
 
@@ -414,12 +440,13 @@ struct InspectorParentHandle {
 // Returns nullptr when the Environment cannot be created e.g. there are
 // pending JavaScript exceptions.
 // It is recommended to use the second variant taking a flags argument.
-NODE_EXTERN Environment* CreateEnvironment(IsolateData* isolate_data,
-                                           v8::Local<v8::Context> context,
-                                           int argc,
-                                           const char* const* argv,
-                                           int exec_argc,
-                                           const char* const* exec_argv);
+NODE_DEPRECATED("Use overload taking a flags argument",
+    NODE_EXTERN Environment* CreateEnvironment(IsolateData* isolate_data,
+                                               v8::Local<v8::Context> context,
+                                               int argc,
+                                               const char* const* argv,
+                                               int exec_argc,
+                                               const char* const* exec_argv));
 NODE_EXTERN Environment* CreateEnvironment(
     IsolateData* isolate_data,
     v8::Local<v8::Context> context,
@@ -449,8 +476,8 @@ struct StartExecutionCallbackInfo {
 using StartExecutionCallback =
     std::function<v8::MaybeLocal<v8::Value>(const StartExecutionCallbackInfo&)>;
 
-// TODO(addaleax): Deprecate this in favour of the MaybeLocal<> overload.
-NODE_EXTERN void LoadEnvironment(Environment* env);
+NODE_DEPRECATED("Use variants returning MaybeLocal<> instead",
+    NODE_EXTERN void LoadEnvironment(Environment* env));
 // The `InspectorParentHandle` arguments here are ignored and not used.
 // For passing `InspectorParentHandle`, use `CreateEnvironment()`.
 NODE_EXTERN v8::MaybeLocal<v8::Value> LoadEnvironment(
@@ -477,6 +504,8 @@ NODE_EXTERN void DefaultProcessExitHandler(Environment* env, int exit_code);
 
 // This may return nullptr if context is not associated with a Node instance.
 NODE_EXTERN Environment* GetCurrentEnvironment(v8::Local<v8::Context> context);
+NODE_EXTERN IsolateData* GetEnvironmentIsolateData(Environment* env);
+NODE_EXTERN ArrayBufferAllocator* GetArrayBufferAllocator(IsolateData* data);
 
 NODE_EXTERN void OnFatalError(const char* location, const char* message);
 NODE_EXTERN void PromiseRejectCallback(v8::PromiseRejectMessage message);
@@ -491,18 +520,18 @@ NODE_EXTERN v8::MaybeLocal<v8::Value> PrepareStackTraceCallback(
 // This returns the MultiIsolatePlatform used in the main thread of Node.js.
 // If NODE_USE_V8_PLATFORM has not been defined when Node.js was built,
 // it returns nullptr.
-// TODO(addaleax): Deprecate in favour of GetMultiIsolatePlatform().
-NODE_EXTERN MultiIsolatePlatform* GetMainThreadMultiIsolatePlatform();
+NODE_DEPRECATED("Use GetMultiIsolatePlatform(env) instead",
+    NODE_EXTERN MultiIsolatePlatform* GetMainThreadMultiIsolatePlatform());
 // This returns the MultiIsolatePlatform used for an Environment or IsolateData
 // instance, if one exists.
 NODE_EXTERN MultiIsolatePlatform* GetMultiIsolatePlatform(Environment* env);
 NODE_EXTERN MultiIsolatePlatform* GetMultiIsolatePlatform(IsolateData* env);
 
 // Legacy variants of MultiIsolatePlatform::Create().
-// TODO(addaleax): Deprecate in favour of the v8::TracingController variant.
-NODE_EXTERN MultiIsolatePlatform* CreatePlatform(
-    int thread_pool_size,
-    node::tracing::TracingController* tracing_controller);
+NODE_DEPRECATED("Use variant taking a v8::TracingController* pointer instead",
+    NODE_EXTERN MultiIsolatePlatform* CreatePlatform(
+        int thread_pool_size,
+        node::tracing::TracingController* tracing_controller));
 NODE_EXTERN MultiIsolatePlatform* CreatePlatform(
     int thread_pool_size,
     v8::TracingController* tracing_controller);
@@ -517,8 +546,19 @@ NODE_EXTERN void FreePlatform(MultiIsolatePlatform* platform);
 NODE_EXTERN v8::TracingController* GetTracingController();
 NODE_EXTERN void SetTracingController(v8::TracingController* controller);
 
-NODE_EXTERN void EmitBeforeExit(Environment* env);
-NODE_EXTERN int EmitExit(Environment* env);
+// Run `process.emit('beforeExit')` as it would usually happen when Node.js is
+// run in standalone mode.
+NODE_EXTERN v8::Maybe<bool> EmitProcessBeforeExit(Environment* env);
+NODE_DEPRECATED("Use Maybe version (EmitProcessBeforeExit) instead",
+    NODE_EXTERN void EmitBeforeExit(Environment* env));
+// Run `process.emit('exit')` as it would usually happen when Node.js is run
+// in standalone mode. The return value corresponds to the exit code.
+NODE_EXTERN v8::Maybe<int> EmitProcessExit(Environment* env);
+NODE_DEPRECATED("Use Maybe version (EmitProcessExit) instead",
+    NODE_EXTERN int EmitExit(Environment* env));
+
+// Runs hooks added through `AtExit()`. This is part of `FreeEnvironment()`,
+// so calling it manually is typically not necessary.
 NODE_EXTERN void RunAtExit(Environment* env);
 
 // This may return nullptr if the current v8::Context is not associated
@@ -628,7 +668,18 @@ inline void NODE_SET_PROTOTYPE_METHOD(v8::Local<v8::FunctionTemplate> recv,
 #define NODE_SET_PROTOTYPE_METHOD node::NODE_SET_PROTOTYPE_METHOD
 
 // BINARY is a deprecated alias of LATIN1.
-enum encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER, LATIN1 = BINARY};
+// BASE64URL is not currently exposed to the JavaScript side.
+enum encoding {
+  ASCII,
+  UTF8,
+  BASE64,
+  UCS2,
+  BINARY,
+  HEX,
+  BUFFER,
+  BASE64URL,
+  LATIN1 = BINARY
+};
 
 NODE_EXTERN enum encoding ParseEncoding(
     v8::Isolate* isolate,
@@ -814,6 +865,8 @@ extern "C" NODE_EXTERN void node_module_register(void* mod);
 // In each variant, the registration function needs to be usable at least for
 // the time during which the Environment exists.
 NODE_EXTERN void AddLinkedBinding(Environment* env, const node_module& mod);
+NODE_EXTERN void AddLinkedBinding(Environment* env,
+                                  const struct napi_module& mod);
 NODE_EXTERN void AddLinkedBinding(Environment* env,
                                   const char* name,
                                   addon_context_register_func fn,
@@ -934,6 +987,9 @@ class NODE_EXTERN CallbackScope {
   CallbackScope(v8::Isolate* isolate,
                 v8::Local<v8::Object> resource,
                 async_context asyncContext);
+  CallbackScope(Environment* env,
+                v8::Local<v8::Object> resource,
+                async_context asyncContext);
   ~CallbackScope();
 
   void operator=(const CallbackScope&) = delete;
@@ -1024,6 +1080,21 @@ class NODE_EXTERN AsyncResource {
   async_context async_context_;
 };
 
+#ifndef _WIN32
+// Register a signal handler without interrupting any handlers that node
+// itself needs. This does override handlers registered through
+// process.on('SIG...', function() { ... }). The `reset_handler` flag indicates
+// whether the signal handler for the given signal should be reset to its
+// default value before executing the handler (i.e. it works like SA_RESETHAND).
+// The `reset_handler` flag is invalid when `signal` is SIGSEGV.
+NODE_EXTERN
+void RegisterSignalHandler(int signal,
+                           void (*handler)(int signal,
+                                           siginfo_t* info,
+                                           void* ucontext),
+                           bool reset_handler = false);
+#endif  // _WIN32
+
 }  // namespace node
 
 #endif  // SRC_NODE_H_
diff --git a/src/node_api.cc b/src/node_api.cc
index 211386ba6d502d178196786ee0a5af13de16fb71..b1b85073508672f7bee49b03a105b87bc3693c47 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1,56 +1,51 @@
+#include "async_wrap-inl.h"
 #include "env-inl.h"
 #define NAPI_EXPERIMENTAL
 #include "js_native_api_v8.h"
+#include "memory_tracker-inl.h"
 #include "node_api.h"
+#include "node_api_internals.h"
 #include "node_binding.h"
 #include "node_buffer.h"
 #include "node_errors.h"
 #include "node_internals.h"
 #include "threadpoolwork-inl.h"
+#include "tracing/traced_value.h"
 #include "util-inl.h"
 
+#include <atomic>
 #include <memory>
 
-struct node_napi_env__ : public napi_env__ {
-  explicit node_napi_env__(v8::Local<v8::Context> context,
-                           const std::string& module_filename):
-      napi_env__(context), filename(module_filename) {
-    CHECK_NOT_NULL(node_env());
-  }
-
-  inline node::Environment* node_env() const {
-    return node::Environment::GetCurrent(context());
-  }
+node_napi_env__::node_napi_env__(v8::Local<v8::Context> context,
+                                 const std::string& module_filename)
+    : napi_env__(context), filename(module_filename) {
+  CHECK_NOT_NULL(node_env());
+}
 
-  bool can_call_into_js() const override {
-    return node_env()->can_call_into_js();
-  }
+bool node_napi_env__::can_call_into_js() const {
+  return node_env()->can_call_into_js();
+}
 
-  v8::Maybe<bool> mark_arraybuffer_as_untransferable(
-      v8::Local<v8::ArrayBuffer> ab) const override {
-    return ab->SetPrivate(
-        context(),
-        node_env()->untransferable_object_private_symbol(),
-        v8::True(isolate));
-  }
+v8::Maybe<bool> node_napi_env__::mark_arraybuffer_as_untransferable(
+    v8::Local<v8::ArrayBuffer> ab) const {
+  return ab->SetPrivate(context(),
+                        node_env()->untransferable_object_private_symbol(),
+                        v8::True(isolate));
+}
 
-  void CallFinalizer(napi_finalize cb, void* data, void* hint) override {
-    napi_env env = static_cast<napi_env>(this);
-    node_env()->SetImmediate([=](node::Environment* node_env) {
-      v8::HandleScope handle_scope(env->isolate);
-      v8::Context::Scope context_scope(env->context());
-      env->CallIntoModule([&](napi_env env) {
-        cb(env, data, hint);
+void node_napi_env__::CallFinalizer(napi_finalize cb, void* data, void* hint) {
+  // we need to keep the env live until the finalizer has been run
+  // EnvRefHolder provides an exception safe wrapper to Ref and then
+  // Unref once the lamba is freed
+  EnvRefHolder liveEnv(static_cast<napi_env>(this));
+  node_env()->SetImmediate(
+      [=, liveEnv = std::move(liveEnv)](node::Environment* node_env) {
+        napi_env env = liveEnv.env();
+        v8::HandleScope handle_scope(env->isolate);
+        v8::Context::Scope context_scope(env->context());
+        env->CallIntoModule([&](napi_env env) { cb(env, data, hint); });
       });
-    });
-  }
-
-  const char* GetFilename() const { return filename.c_str(); }
-
-  std::string filename;
-};
-
-typedef node_napi_env__* node_napi_env;
+}
 
 namespace v8impl {
 
@@ -110,16 +105,6 @@ NewEnv(v8::Local<v8::Context> context, const std::string& module_filename) {
   return result;
 }
 
-static inline napi_callback_scope
-JsCallbackScopeFromV8CallbackScope(node::CallbackScope* s) {
-  return reinterpret_cast<napi_callback_scope>(s);
-}
-
-static inline node::CallbackScope*
-V8CallbackScopeFromJsCallbackScope(napi_callback_scope s) {
-  return reinterpret_cast<node::CallbackScope*>(s);
-}
-
 static inline void trigger_fatal_exception(
     napi_env env, v8::Local<v8::Value> local_err) {
   v8::Local<v8::Message> local_msg =
@@ -144,6 +129,7 @@ class ThreadSafeFunction : public node::AsyncResource {
                                    *v8::String::Utf8Value(env_->isolate, name)),
       thread_count(thread_count_),
       is_closing(false),
+      dispatch_state(kDispatchIdle),
       context(context_),
       max_queue_size(max_queue_size_),
       env(env_),
@@ -183,10 +169,8 @@ class ThreadSafeFunction : public node::AsyncResource {
         return napi_closing;
       }
     } else {
-      if (uv_async_send(&async) != 0) {
-        return napi_generic_failure;
-      }
       queue.push(data);
+      Send();
       return napi_ok;
     }
   }
@@ -218,9 +202,7 @@ class ThreadSafeFunction : public node::AsyncResource {
         if (is_closing && max_queue_size > 0) {
           cond->Signal(lock);
         }
-        if (uv_async_send(&async) != 0) {
-          return napi_generic_failure;
-        }
+        Send();
       }
     }
 
@@ -245,7 +227,6 @@ class ThreadSafeFunction : public node::AsyncResource {
         cond = std::make_unique<node::ConditionVariable>();
       }
       if (max_queue_size == 0 || cond) {
-        CHECK_EQ(0, uv_idle_init(loop, &idle));
         return napi_ok;
       }
 
@@ -270,21 +251,46 @@ class ThreadSafeFunction : public node::AsyncResource {
 
   napi_status Unref() {
     uv_unref(reinterpret_cast<uv_handle_t*>(&async));
-    uv_unref(reinterpret_cast<uv_handle_t*>(&idle));
 
     return napi_ok;
   }
 
   napi_status Ref() {
     uv_ref(reinterpret_cast<uv_handle_t*>(&async));
-    uv_ref(reinterpret_cast<uv_handle_t*>(&idle));
 
     return napi_ok;
   }
 
-  void DispatchOne() {
+  inline void* Context() {
+    return context;
+  }
+
+ protected:
+  void Dispatch() {
+    bool has_more = true;
+
+    // Limit maximum synchronous iteration count to prevent event loop
+    // starvation. See `src/node_messaging.cc` for an inspiration.
+    unsigned int iterations_left = kMaxIterationCount;
+    while (has_more && --iterations_left != 0) {
+      dispatch_state = kDispatchRunning;
+      has_more = DispatchOne();
+
+      // Send() was called while we were executing the JS function
+      if (dispatch_state.exchange(kDispatchIdle) != kDispatchRunning) {
+        has_more = true;
+      }
+    }
+
+    if (has_more) {
+      Send();
+    }
+  }
+
+  bool DispatchOne() {
     void* data = nullptr;
     bool popped_value = false;
+    bool has_more = false;
 
     {
       node::Mutex::ScopedLock lock(this->mutex);
@@ -309,9 +315,9 @@ class ThreadSafeFunction : public node::AsyncResource {
               cond->Signal(lock);
             }
             CloseHandlesAndMaybeDelete();
-          } else {
-            CHECK_EQ(0, uv_idle_stop(&idle));
           }
+        } else {
+          has_more = true;
         }
       }
     }
@@ -329,6 +335,8 @@ class ThreadSafeFunction : public node::AsyncResource {
         call_js_cb(env, js_callback, context, data);
       });
     }
+
+    return has_more;
   }
 
   void Finalize() {
@@ -342,10 +350,6 @@ class ThreadSafeFunction : public node::AsyncResource {
     EmptyQueueAndDelete();
   }
 
-  inline void* Context() {
-    return context;
-  }
-
   void CloseHandlesAndMaybeDelete(bool set_closing = false) {
     v8::HandleScope scope(env->isolate);
     if (set_closing) {
@@ -365,18 +369,20 @@ class ThreadSafeFunction : public node::AsyncResource {
           ThreadSafeFunction* ts_fn =
               node::ContainerOf(&ThreadSafeFunction::async,
                                 reinterpret_cast<uv_async_t*>(handle));
-          v8::HandleScope scope(ts_fn->env->isolate);
-          ts_fn->env->node_env()->CloseHandle(
-              reinterpret_cast<uv_handle_t*>(&ts_fn->idle),
-              [](uv_handle_t* handle) -> void {
-                ThreadSafeFunction* ts_fn =
-                    node::ContainerOf(&ThreadSafeFunction::idle,
-                                      reinterpret_cast<uv_idle_t*>(handle));
-                ts_fn->Finalize();
-              });
+          ts_fn->Finalize();
         });
   }
 
+  void Send() {
+    // Ask currently running Dispatch() to make one more iteration
+    unsigned char current_state = dispatch_state.fetch_or(kDispatchPending);
+    if ((current_state & kDispatchRunning) == kDispatchRunning) {
+      return;
+    }
+
+    CHECK_EQ(0, uv_async_send(&async));
+  }
+
   // Default way of calling into JavaScript. Used when ThreadSafeFunction is
   //  without a call_js_cb_.
   static void CallJs(napi_env env, napi_value cb, void* context, void* data) {
@@ -400,16 +406,10 @@ class ThreadSafeFunction : public node::AsyncResource {
     }
   }
 
-  static void IdleCb(uv_idle_t* idle) {
-    ThreadSafeFunction* ts_fn =
-        node::ContainerOf(&ThreadSafeFunction::idle, idle);
-    ts_fn->DispatchOne();
-  }
-
   static void AsyncCb(uv_async_t* async) {
     ThreadSafeFunction* ts_fn =
         node::ContainerOf(&ThreadSafeFunction::async, async);
-    CHECK_EQ(0, uv_idle_start(&ts_fn->idle, IdleCb));
+    ts_fn->Dispatch();
   }
 
   static void Cleanup(void* data) {
@@ -418,14 +418,20 @@ class ThreadSafeFunction : public node::AsyncResource {
   }
 
  private:
+  static const unsigned char kDispatchIdle = 0;
+  static const unsigned char kDispatchRunning = 1 << 0;
+  static const unsigned char kDispatchPending = 1 << 1;
+
+  static const unsigned int kMaxIterationCount = 1000;
+
   // These are variables protected by the mutex.
   node::Mutex mutex;
   std::unique_ptr<node::ConditionVariable> cond;
   std::queue<void*> queue;
   uv_async_t async;
-  uv_idle_t idle;
   size_t thread_count;
   bool is_closing;
+  std::atomic_uchar dispatch_state;
 
   // These are variables set once, upon creation, and then never again, which
   // means we don't need the mutex to read them.
@@ -441,6 +447,111 @@ class ThreadSafeFunction : public node::AsyncResource {
   bool handles_closing;
 };
 
+/**
+ * Compared to node::AsyncResource, the resource object in AsyncContext is
+ * gc-able. AsyncContext holds a weak reference to the resource object.
+ * AsyncContext::MakeCallback doesn't implicitly set the receiver of the
+ * callback to the resource object.
+ */
+class AsyncContext {
+ public:
+  AsyncContext(node_napi_env env,
+               v8::Local<v8::Object> resource_object,
+               const v8::Local<v8::String> resource_name,
+               bool externally_managed_resource)
+      : env_(env) {
+    async_id_ = node_env()->new_async_id();
+    trigger_async_id_ = node_env()->get_default_trigger_async_id();
+    resource_.Reset(node_env()->isolate(), resource_object);
+    lost_reference_ = false;
+    if (externally_managed_resource) {
+      resource_.SetWeak(
+          this, AsyncContext::WeakCallback, v8::WeakCallbackType::kParameter);
+    }
+
+    node::AsyncWrap::EmitAsyncInit(node_env(),
+                                   resource_object,
+                                   resource_name,
+                                   async_id_,
+                                   trigger_async_id_);
+  }
+
+  ~AsyncContext() {
+    resource_.Reset();
+    lost_reference_ = true;
+    node::AsyncWrap::EmitDestroy(node_env(), async_id_);
+  }
+
+  inline v8::MaybeLocal<v8::Value> MakeCallback(
+      v8::Local<v8::Object> recv,
+      const v8::Local<v8::Function> callback,
+      int argc,
+      v8::Local<v8::Value> argv[]) {
+    EnsureReference();
+    return node::InternalMakeCallback(node_env(),
+                                      resource(),
+                                      recv,
+                                      callback,
+                                      argc,
+                                      argv,
+                                      {async_id_, trigger_async_id_});
+  }
+
+  inline napi_callback_scope OpenCallbackScope() {
+    EnsureReference();
+    napi_callback_scope it =
+        reinterpret_cast<napi_callback_scope>(new CallbackScope(this));
+    env_->open_callback_scopes++;
+    return it;
+  }
+
+  inline void EnsureReference() {
+    if (lost_reference_) {
+      const v8::HandleScope handle_scope(node_env()->isolate());
+      resource_.Reset(node_env()->isolate(),
+                      v8::Object::New(node_env()->isolate()));
+      lost_reference_ = false;
+    }
+  }
+
+  inline node::Environment* node_env() { return env_->node_env(); }
+  inline v8::Local<v8::Object> resource() {
+    return resource_.Get(node_env()->isolate());
+  }
+  inline node::async_context async_context() {
+    return {async_id_, trigger_async_id_};
+  }
+
+  static inline void CloseCallbackScope(node_napi_env env,
+                                        napi_callback_scope s) {
+    CallbackScope* callback_scope = reinterpret_cast<CallbackScope*>(s);
+    delete callback_scope;
+    env->open_callback_scopes--;
+  }
+
+  static void WeakCallback(const v8::WeakCallbackInfo<AsyncContext>& data) {
+    AsyncContext* async_context = data.GetParameter();
+    async_context->resource_.Reset();
+    async_context->lost_reference_ = true;
+  }
+
+ private:
+  class CallbackScope : public node::CallbackScope {
+   public:
+    explicit CallbackScope(AsyncContext* async_context)
+        : node::CallbackScope(async_context->node_env(),
+                              async_context->resource_.Get(
+                                  async_context->node_env()->isolate()),
+                              async_context->async_context()) {}
+  };
+
+  node_napi_env env_;
+  double async_id_;
+  double trigger_async_id_;
+  v8::Global<v8::Object> resource_;
+  bool lost_reference_;
+};
+
 }  // end of anonymous namespace
 
 }  // end of namespace v8impl
@@ -453,7 +564,7 @@ static void napi_module_register_cb(v8::Local<v8::Object> exports,
                                     v8::Local<v8::Context> context,
                                     void* priv) {
   napi_module_register_by_symbol(exports, module, context,
-      static_cast<napi_module*>(priv)->nm_register_func);
+      static_cast<const napi_module*>(priv)->nm_register_func);
 }
 
 void napi_module_register_by_symbol(v8::Local<v8::Object> exports,
@@ -505,9 +616,9 @@ void napi_module_register_by_symbol(v8::Local<v8::Object> exports,
   }
 }
 
-// Registers a NAPI module.
-void napi_module_register(napi_module* mod) {
-  node::node_module* nm = new node::node_module {
+namespace node {
+node_module napi_module_to_node_module(const napi_module* mod) {
+  return {
     -1,
     mod->nm_flags | NM_F_DELETEME,
     nullptr,
@@ -515,9 +626,16 @@ void napi_module_register(napi_module* mod) {
     nullptr,
     napi_module_register_cb,
     mod->nm_modname,
-    mod,  // priv
+    const_cast<napi_module*>(mod),  // priv
     nullptr,
   };
+}
+}  // namespace node
+
+// Registers a NAPI module.
+void napi_module_register(napi_module* mod) {
+  node::node_module* nm = new node::node_module(
+      node::napi_module_to_node_module(mod));
   node::node_module_register(nm);
 }
 
@@ -566,7 +684,8 @@ struct napi_async_cleanup_hook_handle__ {
   }
 
   static void Hook(void* data, void (*done_cb)(void*), void* done_data) {
-    auto handle = static_cast<napi_async_cleanup_hook_handle__*>(data);
+    napi_async_cleanup_hook_handle__* handle =
+        static_cast<napi_async_cleanup_hook_handle__*>(data);
     handle->done_cb_ = done_cb;
     handle->done_data_ = done_data;
     handle->user_hook_(handle, handle->user_data_);
@@ -645,7 +764,7 @@ NAPI_NO_RETURN void napi_fatal_error(const char* location,
 }
 
 napi_status napi_open_callback_scope(napi_env env,
-                                     napi_value resource_object,
+                                     napi_value /** ignored */,
                                      napi_async_context async_context_handle,
                                      napi_callback_scope* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
@@ -653,20 +772,11 @@ napi_status napi_open_callback_scope(napi_env env,
   CHECK_ENV(env);
   CHECK_ARG(env, result);
 
-  v8::Local<v8::Context> context = env->context();
-
-  node::async_context* node_async_context =
-      reinterpret_cast<node::async_context*>(async_context_handle);
+  v8impl::AsyncContext* node_async_context =
+      reinterpret_cast<v8impl::AsyncContext*>(async_context_handle);
 
-  v8::Local<v8::Object> resource;
-  CHECK_TO_OBJECT(env, context, resource, resource_object);
+  *result = node_async_context->OpenCallbackScope();
 
-  *result = v8impl::JsCallbackScopeFromV8CallbackScope(
-      new node::CallbackScope(env->isolate,
-                              resource,
-                              *node_async_context));
-
-  env->open_callback_scopes++;
   return napi_clear_last_error(env);
 }
 
@@ -679,8 +789,9 @@ napi_status napi_close_callback_scope(napi_env env, napi_callback_scope scope) {
     return napi_callback_scope_mismatch;
   }
 
-  env->open_callback_scopes--;
-  delete v8impl::V8CallbackScopeFromJsCallbackScope(scope);
+  v8impl::AsyncContext::CloseCallbackScope(reinterpret_cast<node_napi_env>(env),
+                                           scope);
+
   return napi_clear_last_error(env);
 }
 
@@ -696,20 +807,24 @@ napi_status napi_async_init(napi_env env,
   v8::Local<v8::Context> context = env->context();
 
   v8::Local<v8::Object> v8_resource;
+  bool externally_managed_resource;
   if (async_resource != nullptr) {
     CHECK_TO_OBJECT(env, context, v8_resource, async_resource);
+    externally_managed_resource = true;
   } else {
     v8_resource = v8::Object::New(isolate);
+    externally_managed_resource = false;
   }
 
   v8::Local<v8::String> v8_resource_name;
   CHECK_TO_STRING(env, context, v8_resource_name, async_resource_name);
 
-  // TODO(jasongin): Consider avoiding allocation here by using
-  // a tagged pointer with 2×31 bit fields instead.
-  node::async_context* async_context = new node::async_context();
+  v8impl::AsyncContext* async_context =
+      new v8impl::AsyncContext(reinterpret_cast<node_napi_env>(env),
+                               v8_resource,
+                               v8_resource_name,
+                               externally_managed_resource);
 
-  *async_context = node::EmitAsyncInit(isolate, v8_resource, v8_resource_name);
   *result = reinterpret_cast<napi_async_context>(async_context);
 
   return napi_clear_last_error(env);
@@ -720,11 +835,8 @@ napi_status napi_async_destroy(napi_env env,
   CHECK_ENV(env);
   CHECK_ARG(env, async_context);
 
-  node::async_context* node_async_context =
-      reinterpret_cast<node::async_context*>(async_context);
-  node::EmitAsyncDestroy(
-      reinterpret_cast<node_napi_env>(env)->node_env(),
-      *node_async_context);
+  v8impl::AsyncContext* node_async_context =
+      reinterpret_cast<v8impl::AsyncContext*>(async_context);
 
   delete node_async_context;
 
@@ -752,17 +864,25 @@ napi_status napi_make_callback(napi_env env,
   v8::Local<v8::Function> v8func;
   CHECK_TO_FUNCTION(env, v8func, func);
 
-  node::async_context* node_async_context =
-    reinterpret_cast<node::async_context*>(async_context);
-  if (node_async_context == nullptr) {
-    static node::async_context empty_context = { 0, 0 };
-    node_async_context = &empty_context;
-  }
+  v8::MaybeLocal<v8::Value> callback_result;
 
-  v8::MaybeLocal<v8::Value> callback_result = node::MakeCallback(
-      env->isolate, v8recv, v8func, argc,
-      reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)),
-      *node_async_context);
+  if (async_context == nullptr) {
+    callback_result = node::MakeCallback(
+        env->isolate,
+        v8recv,
+        v8func,
+        argc,
+        reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)),
+        {0, 0});
+  } else {
+    v8impl::AsyncContext* node_async_context =
+        reinterpret_cast<v8impl::AsyncContext*>(async_context);
+    callback_result = node_async_context->MakeCallback(
+        v8recv,
+        v8func,
+        argc,
+        reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
+  }
 
   if (try_catch.HasCaught()) {
     return napi_set_last_error(env, napi_pending_exception);
@@ -784,7 +904,7 @@ napi_status napi_create_buffer(napi_env env,
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, result);
 
-  auto maybe = node::Buffer::New(env->isolate, length);
+  v8::MaybeLocal<v8::Object> maybe = node::Buffer::New(env->isolate, length);
 
   CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
 
@@ -815,11 +935,12 @@ napi_status napi_create_external_buffer(napi_env env,
       env, finalize_cb, nullptr, finalize_hint,
       v8impl::Finalizer::kKeepEnvReference);
 
-  auto maybe = node::Buffer::New(isolate,
-                                static_cast<char*>(data),
-                                length,
-                                v8impl::BufferFinalizer::FinalizeBufferCallback,
-                                finalizer);
+  v8::MaybeLocal<v8::Object> maybe = node::Buffer::New(
+      isolate,
+      static_cast<char*>(data),
+      length,
+      v8impl::BufferFinalizer::FinalizeBufferCallback,
+      finalizer);
 
   CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
 
@@ -839,8 +960,9 @@ napi_status napi_create_buffer_copy(napi_env env,
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, result);
 
-  auto maybe = node::Buffer::Copy(env->isolate,
-    static_cast<const char*>(data), length);
+  v8::MaybeLocal<v8::Object> maybe = node::Buffer::Copy(
+      env->isolate,
+      static_cast<const char*>(data), length);
 
   CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
 
@@ -1049,11 +1171,8 @@ napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
   CHECK_ENV(env);
   CHECK_ARG(env, work);
 
-  napi_status status;
   uv_loop_t* event_loop = nullptr;
-  status = napi_get_uv_event_loop(env, &event_loop);
-  if (status != napi_ok)
-    return napi_set_last_error(env, status);
+  STATUS_CALL(napi_get_uv_event_loop(env, &event_loop));
 
   uvimpl::Work* w = reinterpret_cast<uvimpl::Work*>(work);
 
diff --git a/src/node_api.h b/src/node_api.h
index 61a5404314a5df4c752b330c4cb89feac7904c53..1772c67c15afb2d2712b1900a584f627852e3d7e 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -31,7 +31,7 @@ struct uv_loop_s;  // Forward declaration.
 typedef napi_value (*napi_addon_register_func)(napi_env env,
                                                napi_value exports);
 
-typedef struct {
+typedef struct napi_module {
   int nm_version;
   unsigned int nm_flags;
   const char* nm_filename;
diff --git a/src/node_api_internals.h b/src/node_api_internals.h
new file mode 100644
index 0000000000000000000000000000000000000000..318ada38083435043fc86af8c7b4a01bdb59cf3c
--- /dev/null
+++ b/src/node_api_internals.h
@@ -0,0 +1,30 @@
+#ifndef SRC_NODE_API_INTERNALS_H_
+#define SRC_NODE_API_INTERNALS_H_
+
+#include "v8.h"
+#define NAPI_EXPERIMENTAL
+#include "env-inl.h"
+#include "js_native_api_v8.h"
+#include "node_api.h"
+#include "util-inl.h"
+
+struct node_napi_env__ : public napi_env__ {
+  node_napi_env__(v8::Local<v8::Context> context,
+                  const std::string& module_filename);
+
+  bool can_call_into_js() const override;
+  v8::Maybe<bool> mark_arraybuffer_as_untransferable(
+      v8::Local<v8::ArrayBuffer> ab) const override;
+  void CallFinalizer(napi_finalize cb, void* data, void* hint) override;
+
+  inline node::Environment* node_env() const {
+    return node::Environment::GetCurrent(context());
+  }
+  inline const char* GetFilename() const { return filename.c_str(); }
+
+  std::string filename;
+};
+
+using node_napi_env = node_napi_env__*;
+
+#endif  // SRC_NODE_API_INTERNALS_H_
diff --git a/src/node_binding.cc b/src/node_binding.cc
index 28963c169e3990b0123149251ab24962ef6a3c06..8b34d601146579eb3c56a1265968cbfb33c7861a 100644
--- a/src/node_binding.cc
+++ b/src/node_binding.cc
@@ -5,6 +5,8 @@
 #include "node_native_module_env.h"
 #include "util.h"
 
+#include <string>
+
 #if HAVE_OPENSSL
 #define NODE_BUILTIN_OPENSSL_MODULES(V) V(crypto) V(tls_wrap)
 #else
@@ -37,6 +39,7 @@
 // __attribute__((constructor)) like mechanism in GCC.
 #define NODE_BUILTIN_STANDARD_MODULES(V)                                       \
   V(async_wrap)                                                                \
+  V(block_list)                                                                \
   V(buffer)                                                                    \
   V(cares_wrap)                                                                \
   V(config)                                                                    \
@@ -49,7 +52,6 @@
   V(heap_utils)                                                                \
   V(http2)                                                                     \
   V(http_parser)                                                               \
-  V(http_parser_llhttp)                                                        \
   V(inspector)                                                                 \
   V(js_stream)                                                                 \
   V(js_udp_wrap)                                                               \
@@ -231,9 +233,9 @@ namespace node {
 
 using v8::Context;
 using v8::Exception;
+using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::Value;
@@ -416,13 +418,13 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
   CHECK_NULL(thread_local_modpending);
 
   if (args.Length() < 2) {
-    env->ThrowError("process.dlopen needs at least 2 arguments.");
-    return;
+    return THROW_ERR_MISSING_ARGS(
+        env, "process.dlopen needs at least 2 arguments");
   }
 
   int32_t flags = DLib::kDefaultFlags;
   if (args.Length() > 2 && !args[2]->Int32Value(context).To(&flags)) {
-    return env->ThrowTypeError("flag argument must be an integer.");
+    return THROW_ERR_INVALID_ARG_TYPE(env, "flag argument must be an integer.");
   }
 
   Local<Object> module;
@@ -448,15 +450,13 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
     thread_local_modpending = nullptr;
 
     if (!is_opened) {
-      Local<String> errmsg =
-          OneByteString(env->isolate(), dlib->errmsg_.c_str());
+      std::string errmsg = dlib->errmsg_.c_str();
       dlib->Close();
 #ifdef _WIN32
       // Windows needs to add the filename into the error message
-      errmsg = String::Concat(
-          env->isolate(), errmsg, args[1]->ToString(context).ToLocalChecked());
+      errmsg += *filename;
 #endif  // _WIN32
-      env->isolate()->ThrowException(Exception::Error(errmsg));
+      THROW_ERR_DLOPEN_FAILED(env, errmsg.c_str());
       return false;
     }
 
@@ -486,7 +486,7 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
                    sizeof(errmsg),
                    "Module did not self-register: '%s'.",
                    *filename);
-          env->ThrowError(errmsg);
+          THROW_ERR_DLOPEN_FAILED(env, errmsg);
           return false;
         }
       }
@@ -517,7 +517,7 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
       // NOTE: `mp` is allocated inside of the shared library's memory, calling
       // `dlclose` will deallocate it
       dlib->Close();
-      env->ThrowError(errmsg);
+      THROW_ERR_DLOPEN_FAILED(env, errmsg);
       return false;
     }
     CHECK_EQ(mp->nm_flags & NM_F_BUILTIN, 0);
@@ -530,7 +530,7 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
       mp->nm_register_func(exports, module, mp->nm_priv);
     } else {
       dlib->Close();
-      env->ThrowError("Module has no declared entry point.");
+      THROW_ERR_DLOPEN_FAILED(env, "Module has no declared entry point.");
       return false;
     }
 
@@ -557,8 +557,11 @@ inline struct node_module* FindModule(struct node_module* list,
 static Local<Object> InitModule(Environment* env,
                                 node_module* mod,
                                 Local<String> module) {
-  Local<Object> exports = Object::New(env->isolate());
   // Internal bindings don't have a "module" object, only exports.
+  Local<Function> ctor = env->binding_data_ctor_template()
+                             ->GetFunction(env->context())
+                             .ToLocalChecked();
+  Local<Object> exports = ctor->NewInstance(env->context()).ToLocalChecked();
   CHECK_NULL(mod->nm_register_func);
   CHECK_NOT_NULL(mod->nm_context_register_func);
   Local<Value> unused = Undefined(env->isolate());
@@ -566,12 +569,6 @@ static Local<Object> InitModule(Environment* env,
   return exports;
 }
 
-static void ThrowIfNoSuchModule(Environment* env, const char* module_v) {
-  char errmsg[1024];
-  snprintf(errmsg, sizeof(errmsg), "No such module: %s", module_v);
-  env->ThrowError(errmsg);
-}
-
 void GetInternalBinding(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
@@ -600,7 +597,9 @@ void GetInternalBinding(const FunctionCallbackInfo<Value>& args) {
                         env->isolate()))
               .FromJust());
   } else {
-    return ThrowIfNoSuchModule(env, *module_v);
+    char errmsg[1024];
+    snprintf(errmsg, sizeof(errmsg), "No such module: %s", *module_v);
+    return THROW_ERR_INVALID_MODULE(env, errmsg);
   }
 
   args.GetReturnValue().Set(exports);
@@ -635,14 +634,13 @@ void GetLinkedBinding(const FunctionCallbackInfo<Value>& args) {
              sizeof(errmsg),
              "No such module was linked: %s",
              *module_name_v);
-    return env->ThrowError(errmsg);
+    return THROW_ERR_INVALID_MODULE(env, errmsg);
   }
 
   Local<Object> module = Object::New(env->isolate());
   Local<Object> exports = Object::New(env->isolate());
   Local<String> exports_prop =
-      String::NewFromUtf8(env->isolate(), "exports", NewStringType::kNormal)
-          .ToLocalChecked();
+      String::NewFromUtf8Literal(env->isolate(), "exports");
   module->Set(env->context(), exports_prop, exports).Check();
 
   if (mod->nm_context_register_func != nullptr) {
@@ -651,7 +649,9 @@ void GetLinkedBinding(const FunctionCallbackInfo<Value>& args) {
   } else if (mod->nm_register_func != nullptr) {
     mod->nm_register_func(exports, module, mod->nm_priv);
   } else {
-    return env->ThrowError("Linked module has no declared entry point.");
+    return THROW_ERR_INVALID_MODULE(
+        env,
+        "Linked moduled has no declared entry point.");
   }
 
   auto effective_exports =
diff --git a/src/node_blob.cc b/src/node_blob.cc
new file mode 100644
index 0000000000000000000000000000000000000000..aaea61fb65357cb385c4b7d7865ff2b9197cb464
--- /dev/null
+++ b/src/node_blob.cc
@@ -0,0 +1,324 @@
+#include "node_blob.h"
+#include "async_wrap-inl.h"
+#include "base_object-inl.h"
+#include "env-inl.h"
+#include "memory_tracker-inl.h"
+#include "node_errors.h"
+#include "threadpoolwork-inl.h"
+#include "v8.h"
+
+#include <algorithm>
+
+namespace node {
+
+using v8::Array;
+using v8::ArrayBuffer;
+using v8::ArrayBufferView;
+using v8::BackingStore;
+using v8::Context;
+using v8::EscapableHandleScope;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::HandleScope;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Number;
+using v8::Object;
+using v8::Uint32;
+using v8::Undefined;
+using v8::Value;
+
+void Blob::Initialize(Environment* env, v8::Local<v8::Object> target) {
+  env->SetMethod(target, "createBlob", New);
+  FixedSizeBlobCopyJob::Initialize(env, target);
+}
+
+Local<FunctionTemplate> Blob::GetConstructorTemplate(Environment* env) {
+  Local<FunctionTemplate> tmpl = env->blob_constructor_template();
+  if (tmpl.IsEmpty()) {
+    tmpl = FunctionTemplate::New(env->isolate());
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        BaseObject::kInternalFieldCount);
+    tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
+    tmpl->SetClassName(
+        FIXED_ONE_BYTE_STRING(env->isolate(), "Blob"));
+    env->SetProtoMethod(tmpl, "toArrayBuffer", ToArrayBuffer);
+    env->SetProtoMethod(tmpl, "slice", ToSlice);
+    env->set_blob_constructor_template(tmpl);
+  }
+  return tmpl;
+}
+
+bool Blob::HasInstance(Environment* env, v8::Local<v8::Value> object) {
+  return GetConstructorTemplate(env)->HasInstance(object);
+}
+
+BaseObjectPtr<Blob> Blob::Create(
+    Environment* env,
+    const std::vector<BlobEntry> store,
+    size_t length) {
+
+  HandleScope scope(env->isolate());
+
+  Local<Function> ctor;
+  if (!GetConstructorTemplate(env)->GetFunction(env->context()).ToLocal(&ctor))
+    return BaseObjectPtr<Blob>();
+
+  Local<Object> obj;
+  if (!ctor->NewInstance(env->context()).ToLocal(&obj))
+    return BaseObjectPtr<Blob>();
+
+  return MakeBaseObject<Blob>(env, obj, store, length);
+}
+
+void Blob::New(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args[0]->IsArray());  // sources
+  CHECK(args[1]->IsUint32());  // length
+
+  std::vector<BlobEntry> entries;
+
+  size_t length = args[1].As<Uint32>()->Value();
+  size_t len = 0;
+  Local<Array> ary = args[0].As<Array>();
+  for (size_t n = 0; n < ary->Length(); n++) {
+    Local<Value> entry;
+    if (!ary->Get(env->context(), n).ToLocal(&entry))
+      return;
+    CHECK(entry->IsArrayBufferView() || Blob::HasInstance(env, entry));
+    if (entry->IsArrayBufferView()) {
+      Local<ArrayBufferView> view = entry.As<ArrayBufferView>();
+      CHECK_EQ(view->ByteOffset(), 0);
+      std::shared_ptr<BackingStore> store = view->Buffer()->GetBackingStore();
+      size_t byte_length = view->ByteLength();
+      view->Buffer()->Detach();  // The Blob will own the backing store now.
+      entries.emplace_back(BlobEntry{std::move(store), byte_length, 0});
+      len += byte_length;
+    } else {
+      Blob* blob;
+      ASSIGN_OR_RETURN_UNWRAP(&blob, entry);
+      auto source = blob->entries();
+      entries.insert(entries.end(), source.begin(), source.end());
+      len += blob->length();
+    }
+  }
+  CHECK_EQ(length, len);
+
+  BaseObjectPtr<Blob> blob = Create(env, entries, length);
+  if (blob)
+    args.GetReturnValue().Set(blob->object());
+}
+
+void Blob::ToArrayBuffer(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Blob* blob;
+  ASSIGN_OR_RETURN_UNWRAP(&blob, args.Holder());
+  Local<Value> ret;
+  if (blob->GetArrayBuffer(env).ToLocal(&ret))
+    args.GetReturnValue().Set(ret);
+}
+
+void Blob::ToSlice(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Blob* blob;
+  ASSIGN_OR_RETURN_UNWRAP(&blob, args.Holder());
+  CHECK(args[0]->IsUint32());
+  CHECK(args[1]->IsUint32());
+  size_t start = args[0].As<Uint32>()->Value();
+  size_t end = args[1].As<Uint32>()->Value();
+  BaseObjectPtr<Blob> slice = blob->Slice(env, start, end);
+  if (slice)
+    args.GetReturnValue().Set(slice->object());
+}
+
+void Blob::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("store", length_);
+}
+
+MaybeLocal<Value> Blob::GetArrayBuffer(Environment* env) {
+  EscapableHandleScope scope(env->isolate());
+  size_t len = length();
+  std::shared_ptr<BackingStore> store =
+      ArrayBuffer::NewBackingStore(env->isolate(), len);
+  if (len > 0) {
+    unsigned char* dest = static_cast<unsigned char*>(store->Data());
+    size_t total = 0;
+    for (const auto& entry : entries()) {
+      unsigned char* src = static_cast<unsigned char*>(entry.store->Data());
+      src += entry.offset;
+      memcpy(dest, src, entry.length);
+      dest += entry.length;
+      total += entry.length;
+      CHECK_LE(total, len);
+    }
+  }
+
+  return scope.Escape(ArrayBuffer::New(env->isolate(), store));
+}
+
+BaseObjectPtr<Blob> Blob::Slice(Environment* env, size_t start, size_t end) {
+  CHECK_LE(start, length());
+  CHECK_LE(end, length());
+  CHECK_LE(start, end);
+
+  std::vector<BlobEntry> slices;
+  size_t total = end - start;
+  size_t remaining = total;
+
+  if (total == 0) return Create(env, slices, 0);
+
+  for (const auto& entry : entries()) {
+    if (start + entry.offset > entry.store->ByteLength()) {
+      start -= entry.length;
+      continue;
+    }
+
+    size_t offset = entry.offset + start;
+    size_t len = std::min(remaining, entry.store->ByteLength() - offset);
+    slices.emplace_back(BlobEntry{entry.store, len, offset});
+
+    remaining -= len;
+    start = 0;
+
+    if (remaining == 0)
+      break;
+  }
+
+  return Create(env, slices, total);
+}
+
+Blob::Blob(
+    Environment* env,
+    v8::Local<v8::Object> obj,
+    const std::vector<BlobEntry>& store,
+    size_t length)
+    : BaseObject(env, obj),
+      store_(store),
+      length_(length) {
+  MakeWeak();
+}
+
+BaseObjectPtr<BaseObject>
+Blob::BlobTransferData::Deserialize(
+    Environment* env,
+    Local<Context> context,
+    std::unique_ptr<worker::TransferData> self) {
+  if (context != env->context()) {
+    THROW_ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE(env);
+    return {};
+  }
+  return Blob::Create(env, store_, length_);
+}
+
+BaseObject::TransferMode Blob::GetTransferMode() const {
+  return BaseObject::TransferMode::kCloneable;
+}
+
+std::unique_ptr<worker::TransferData> Blob::CloneForMessaging() const {
+  return std::make_unique<BlobTransferData>(store_, length_);
+}
+
+FixedSizeBlobCopyJob::FixedSizeBlobCopyJob(
+    Environment* env,
+    Local<Object> object,
+    Blob* blob,
+    FixedSizeBlobCopyJob::Mode mode)
+    : AsyncWrap(env, object, AsyncWrap::PROVIDER_FIXEDSIZEBLOBCOPY),
+      ThreadPoolWork(env),
+      mode_(mode) {
+  if (mode == FixedSizeBlobCopyJob::Mode::SYNC) MakeWeak();
+  source_ = blob->entries();
+  length_ = blob->length();
+}
+
+void FixedSizeBlobCopyJob::AfterThreadPoolWork(int status) {
+  Environment* env = AsyncWrap::env();
+  CHECK_EQ(mode_, Mode::ASYNC);
+  CHECK(status == 0 || status == UV_ECANCELED);
+  std::unique_ptr<FixedSizeBlobCopyJob> ptr(this);
+  HandleScope handle_scope(env->isolate());
+  Context::Scope context_scope(env->context());
+  Local<Value> args[2];
+
+  if (status == UV_ECANCELED) {
+    args[0] = Number::New(env->isolate(), status),
+    args[1] = Undefined(env->isolate());
+  } else {
+    args[0] = Undefined(env->isolate());
+    args[1] = ArrayBuffer::New(env->isolate(), destination_);
+  }
+
+  ptr->MakeCallback(env->ondone_string(), arraysize(args), args);
+}
+
+void FixedSizeBlobCopyJob::DoThreadPoolWork() {
+  unsigned char* dest = static_cast<unsigned char*>(destination_->Data());
+  if (length_ > 0) {
+    size_t total = 0;
+    for (const auto& entry : source_) {
+      unsigned char* src = static_cast<unsigned char*>(entry.store->Data());
+      src += entry.offset;
+      memcpy(dest, src, entry.length);
+      dest += entry.length;
+      total += entry.length;
+      CHECK_LE(total, length_);
+    }
+  }
+}
+
+void FixedSizeBlobCopyJob::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("source", length_);
+  tracker->TrackFieldWithSize(
+      "destination",
+      destination_ ? destination_->ByteLength() : 0);
+}
+
+void FixedSizeBlobCopyJob::Initialize(Environment* env, Local<Object> target) {
+  v8::Local<v8::FunctionTemplate> job = env->NewFunctionTemplate(New);
+  job->Inherit(AsyncWrap::GetConstructorTemplate(env));
+  job->InstanceTemplate()->SetInternalFieldCount(
+      AsyncWrap::kInternalFieldCount);
+  env->SetProtoMethod(job, "run", Run);
+  env->SetConstructorFunction(target, "FixedSizeBlobCopyJob", job);
+}
+
+void FixedSizeBlobCopyJob::New(const FunctionCallbackInfo<Value>& args) {
+  static constexpr size_t kMaxSyncLength = 4096;
+  static constexpr size_t kMaxEntryCount = 4;
+
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args.IsConstructCall());
+  CHECK(args[0]->IsObject());
+  CHECK(Blob::HasInstance(env, args[0]));
+
+  Blob* blob;
+  ASSIGN_OR_RETURN_UNWRAP(&blob, args[0]);
+
+  // This is a fairly arbitrary heuristic. We want to avoid deferring to
+  // the threadpool if the amount of data being copied is small and there
+  // aren't that many entries to copy.
+  FixedSizeBlobCopyJob::Mode mode =
+      (blob->length() < kMaxSyncLength &&
+       blob->entries().size() < kMaxEntryCount) ?
+          FixedSizeBlobCopyJob::Mode::SYNC :
+          FixedSizeBlobCopyJob::Mode::ASYNC;
+
+  new FixedSizeBlobCopyJob(env, args.This(), blob, mode);
+}
+
+void FixedSizeBlobCopyJob::Run(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  FixedSizeBlobCopyJob* job;
+  ASSIGN_OR_RETURN_UNWRAP(&job, args.Holder());
+  job->destination_ =
+      ArrayBuffer::NewBackingStore(env->isolate(), job->length_);
+  if (job->mode() == FixedSizeBlobCopyJob::Mode::ASYNC)
+    return job->ScheduleWork();
+
+  job->DoThreadPoolWork();
+  args.GetReturnValue().Set(
+      ArrayBuffer::New(env->isolate(), job->destination_));
+}
+
+}  // namespace node
diff --git a/src/node_blob.h b/src/node_blob.h
new file mode 100644
index 0000000000000000000000000000000000000000..c54ed2f29203858de20c8cc221413155c32b42ad
--- /dev/null
+++ b/src/node_blob.h
@@ -0,0 +1,133 @@
+#ifndef SRC_NODE_BLOB_H_
+#define SRC_NODE_BLOB_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "base_object.h"
+#include "env.h"
+#include "memory_tracker.h"
+#include "node_internals.h"
+#include "node_worker.h"
+#include "v8.h"
+
+#include <vector>
+
+namespace node {
+
+struct BlobEntry {
+  std::shared_ptr<v8::BackingStore> store;
+  size_t length;
+  size_t offset;
+};
+
+class Blob : public BaseObject {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ToArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ToSlice(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  static BaseObjectPtr<Blob> Create(
+      Environment* env,
+      const std::vector<BlobEntry> store,
+      size_t length);
+
+  static bool HasInstance(Environment* env, v8::Local<v8::Value> object);
+
+  const std::vector<BlobEntry> entries() const {
+    return store_;
+  }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Blob)
+  SET_SELF_SIZE(Blob)
+
+  // Copies the contents of the Blob into an ArrayBuffer.
+  v8::MaybeLocal<v8::Value> GetArrayBuffer(Environment* env);
+
+  BaseObjectPtr<Blob> Slice(Environment* env, size_t start, size_t end);
+
+  inline size_t length() const { return length_; }
+
+  class BlobTransferData : public worker::TransferData {
+   public:
+    explicit BlobTransferData(
+        const std::vector<BlobEntry>& store,
+      size_t length)
+        : store_(store),
+          length_(length) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    SET_MEMORY_INFO_NAME(BlobTransferData)
+    SET_SELF_SIZE(BlobTransferData)
+    SET_NO_MEMORY_INFO()
+
+   private:
+    std::vector<BlobEntry> store_;
+    size_t length_ = 0;
+  };
+
+  BaseObject::TransferMode GetTransferMode() const override;
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  Blob(
+      Environment* env,
+      v8::Local<v8::Object> obj,
+      const std::vector<BlobEntry>& store,
+      size_t length);
+
+ private:
+  std::vector<BlobEntry> store_;
+  size_t length_ = 0;
+};
+
+class FixedSizeBlobCopyJob : public AsyncWrap, public ThreadPoolWork {
+ public:
+  enum class Mode {
+    SYNC,
+    ASYNC
+  };
+
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Run(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
+    return true;
+  }
+
+  void DoThreadPoolWork() override;
+  void AfterThreadPoolWork(int status) override;
+
+  Mode mode() const { return mode_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(FixedSizeBlobCopyJob)
+  SET_SELF_SIZE(FixedSizeBlobCopyJob)
+
+ private:
+  FixedSizeBlobCopyJob(
+    Environment* env,
+    v8::Local<v8::Object> object,
+    Blob* blob,
+    Mode mode = Mode::ASYNC);
+
+  Mode mode_;
+  std::vector<BlobEntry> source_;
+  std::shared_ptr<v8::BackingStore> destination_;
+  size_t length_ = 0;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_BLOB_H_
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index be9e17296a6c0289c0bcd1306f71df27c09a603f..6a66bd833ae34586c9475eb1dbcab8a46ef09a07 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -20,7 +20,9 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "node_buffer.h"
+#include "allocated_buffer-inl.h"
 #include "node.h"
+#include "node_blob.h"
 #include "node_errors.h"
 #include "node_internals.h"
 
@@ -47,8 +49,8 @@ namespace node {
 namespace Buffer {
 
 using v8::ArrayBuffer;
-using v8::ArrayBufferCreationMode;
 using v8::ArrayBufferView;
+using v8::BackingStore;
 using v8::Context;
 using v8::EscapableHandleScope;
 using v8::FunctionCallbackInfo;
@@ -62,115 +64,137 @@ using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
+using v8::Number;
 using v8::Object;
 using v8::String;
 using v8::Uint32;
 using v8::Uint32Array;
 using v8::Uint8Array;
 using v8::Value;
-using v8::WeakCallbackInfo;
 
 namespace {
 
 class CallbackInfo {
  public:
-  ~CallbackInfo();
-
-  static inline void Free(char* data, void* hint);
-  static inline CallbackInfo* New(Environment* env,
-                                  Local<ArrayBuffer> object,
-                                  FreeCallback callback,
-                                  char* data,
-                                  void* hint = nullptr);
+  static inline Local<ArrayBuffer> CreateTrackedArrayBuffer(
+      Environment* env,
+      char* data,
+      size_t length,
+      FreeCallback callback,
+      void* hint);
 
   CallbackInfo(const CallbackInfo&) = delete;
   CallbackInfo& operator=(const CallbackInfo&) = delete;
 
  private:
   static void CleanupHook(void* data);
-  static void WeakCallback(const WeakCallbackInfo<CallbackInfo>&);
-  inline void WeakCallback(Isolate* isolate);
+  inline void OnBackingStoreFree();
+  inline void CallAndResetCallback();
   inline CallbackInfo(Environment* env,
-                      Local<ArrayBuffer> object,
                       FreeCallback callback,
                       char* data,
                       void* hint);
   Global<ArrayBuffer> persistent_;
-  FreeCallback const callback_;
+  Mutex mutex_;  // Protects callback_.
+  FreeCallback callback_;
   char* const data_;
   void* const hint_;
   Environment* const env_;
 };
 
 
-void CallbackInfo::Free(char* data, void*) {
-  ::free(data);
-}
-
+Local<ArrayBuffer> CallbackInfo::CreateTrackedArrayBuffer(
+    Environment* env,
+    char* data,
+    size_t length,
+    FreeCallback callback,
+    void* hint) {
+  CHECK_NOT_NULL(callback);
+  CHECK_IMPLIES(data == nullptr, length == 0);
+
+  CallbackInfo* self = new CallbackInfo(env, callback, data, hint);
+  std::unique_ptr<BackingStore> bs =
+      ArrayBuffer::NewBackingStore(data, length, [](void*, size_t, void* arg) {
+        static_cast<CallbackInfo*>(arg)->OnBackingStoreFree();
+      }, self);
+  Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), std::move(bs));
+
+  // V8 simply ignores the BackingStore deleter callback if data == nullptr,
+  // but our API contract requires it being called.
+  if (data == nullptr) {
+    ab->Detach();
+    self->OnBackingStoreFree();  // This calls `callback` asynchronously.
+  } else {
+    // Store the ArrayBuffer so that we can detach it later.
+    self->persistent_.Reset(env->isolate(), ab);
+    self->persistent_.SetWeak();
+  }
 
-CallbackInfo* CallbackInfo::New(Environment* env,
-                                Local<ArrayBuffer> object,
-                                FreeCallback callback,
-                                char* data,
-                                void* hint) {
-  return new CallbackInfo(env, object, callback, data, hint);
+  return ab;
 }
 
 
 CallbackInfo::CallbackInfo(Environment* env,
-                           Local<ArrayBuffer> object,
                            FreeCallback callback,
                            char* data,
                            void* hint)
-    : persistent_(env->isolate(), object),
-      callback_(callback),
+    : callback_(callback),
       data_(data),
       hint_(hint),
       env_(env) {
-  ArrayBuffer::Contents obj_c = object->GetContents();
-  CHECK_EQ(data_, static_cast<char*>(obj_c.Data()));
-  if (object->ByteLength() != 0)
-    CHECK_NOT_NULL(data_);
-
-  persistent_.SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
   env->AddCleanupHook(CleanupHook, this);
   env->isolate()->AdjustAmountOfExternalAllocatedMemory(sizeof(*this));
 }
 
-
-CallbackInfo::~CallbackInfo() {
-  persistent_.Reset();
-  env_->RemoveCleanupHook(CleanupHook, this);
-}
-
-
 void CallbackInfo::CleanupHook(void* data) {
   CallbackInfo* self = static_cast<CallbackInfo*>(data);
 
   {
     HandleScope handle_scope(self->env_->isolate());
     Local<ArrayBuffer> ab = self->persistent_.Get(self->env_->isolate());
-    CHECK(!ab.IsEmpty());
-    if (ab->IsDetachable())
+    if (!ab.IsEmpty() && ab->IsDetachable()) {
       ab->Detach();
+      self->persistent_.Reset();
+    }
   }
 
-  self->WeakCallback(self->env_->isolate());
+  // Call the callback in this case, but don't delete `this` yet because the
+  // BackingStore deleter callback will do so later.
+  self->CallAndResetCallback();
 }
 
+void CallbackInfo::CallAndResetCallback() {
+  FreeCallback callback;
+  {
+    Mutex::ScopedLock lock(mutex_);
+    callback = callback_;
+    callback_ = nullptr;
+  }
+  if (callback != nullptr) {
+    // Clean up all Environment-related state and run the callback.
+    env_->RemoveCleanupHook(CleanupHook, this);
+    int64_t change_in_bytes = -static_cast<int64_t>(sizeof(*this));
+    env_->isolate()->AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
 
-void CallbackInfo::WeakCallback(
-    const WeakCallbackInfo<CallbackInfo>& data) {
-  CallbackInfo* self = data.GetParameter();
-  self->WeakCallback(data.GetIsolate());
+    callback(data_, hint_);
+  }
 }
 
-
-void CallbackInfo::WeakCallback(Isolate* isolate) {
-  callback_(data_, hint_);
-  int64_t change_in_bytes = -static_cast<int64_t>(sizeof(*this));
-  isolate->AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
-  delete this;
+void CallbackInfo::OnBackingStoreFree() {
+  // This method should always release the memory for `this`.
+  std::unique_ptr<CallbackInfo> self { this };
+  Mutex::ScopedLock lock(mutex_);
+  // If callback_ == nullptr, that means that the callback has already run from
+  // the cleanup hook, and there is nothing left to do here besides to clean
+  // up the memory involved. In particular, the underlying `Environment` may
+  // be gone at this point, so don’t attempt to call SetImmediateThreadsafe().
+  if (callback_ == nullptr) return;
+
+  env_->SetImmediateThreadsafe([self = std::move(self)](Environment* env) {
+    CHECK_EQ(self->env_, env);  // Consistency check.
+
+    self->CallAndResetCallback();
+  });
 }
 
 
@@ -219,16 +243,13 @@ bool HasInstance(Local<Object> obj) {
 char* Data(Local<Value> val) {
   CHECK(val->IsArrayBufferView());
   Local<ArrayBufferView> ui = val.As<ArrayBufferView>();
-  ArrayBuffer::Contents ab_c = ui->Buffer()->GetContents();
-  return static_cast<char*>(ab_c.Data()) + ui->ByteOffset();
+  return static_cast<char*>(ui->Buffer()->GetBackingStore()->Data()) +
+      ui->ByteOffset();
 }
 
 
 char* Data(Local<Object> obj) {
-  CHECK(obj->IsArrayBufferView());
-  Local<ArrayBufferView> ui = obj.As<ArrayBufferView>();
-  ArrayBuffer::Contents ab_c = ui->Buffer()->GetContents();
-  return static_cast<char*>(ab_c.Data()) + ui->ByteOffset();
+  return Data(obj.As<Value>());
 }
 
 
@@ -281,28 +302,36 @@ MaybeLocal<Object> New(Isolate* isolate,
   if (!StringBytes::Size(isolate, string, enc).To(&length))
     return Local<Object>();
   size_t actual = 0;
-  char* data = nullptr;
+  std::unique_ptr<BackingStore> store;
 
   if (length > 0) {
-    data = UncheckedMalloc(length);
+    store = ArrayBuffer::NewBackingStore(isolate, length);
 
-    if (data == nullptr) {
+    if (UNLIKELY(!store)) {
       THROW_ERR_MEMORY_ALLOCATION_FAILED(isolate);
       return Local<Object>();
     }
 
-    actual = StringBytes::Write(isolate, data, length, string, enc);
+    actual = StringBytes::Write(
+        isolate,
+        static_cast<char*>(store->Data()),
+        length,
+        string,
+        enc);
     CHECK(actual <= length);
 
-    if (actual == 0) {
-      free(data);
-      data = nullptr;
-    } else if (actual < length) {
-      data = node::Realloc(data, actual);
+    if (LIKELY(actual > 0)) {
+      if (actual < length)
+        store = BackingStore::Reallocate(isolate, std::move(store), actual);
+      Local<ArrayBuffer> buf = ArrayBuffer::New(isolate, std::move(store));
+      Local<Object> obj;
+      if (UNLIKELY(!New(isolate, buf, 0, actual).ToLocal(&obj)))
+        return MaybeLocal<Object>();
+      return scope.Escape(obj);
     }
   }
 
-  return scope.EscapeMaybe(New(isolate, data, actual));
+  return scope.EscapeMaybe(New(isolate, 0));
 }
 
 
@@ -329,16 +358,8 @@ MaybeLocal<Object> New(Environment* env, size_t length) {
     return Local<Object>();
   }
 
-  AllocatedBuffer ret(env);
-  if (length > 0) {
-    ret = env->AllocateManaged(length, false);
-    if (ret.data() == nullptr) {
-      THROW_ERR_MEMORY_ALLOCATION_FAILED(env);
-      return Local<Object>();
-    }
-  }
-
-  return scope.EscapeMaybe(ret.ToBuffer());
+  return scope.EscapeMaybe(
+      AllocatedBuffer::AllocateManaged(env, length).ToBuffer());
 }
 
 
@@ -365,14 +386,8 @@ MaybeLocal<Object> Copy(Environment* env, const char* data, size_t length) {
     return Local<Object>();
   }
 
-  AllocatedBuffer ret(env);
+  AllocatedBuffer ret = AllocatedBuffer::AllocateManaged(env, length);
   if (length > 0) {
-    CHECK_NOT_NULL(data);
-    ret = env->AllocateManaged(length, false);
-    if (ret.data() == nullptr) {
-      THROW_ERR_MEMORY_ALLOCATION_FAILED(env);
-      return Local<Object>();
-    }
     memcpy(ret.data(), data, length);
   }
 
@@ -410,21 +425,20 @@ MaybeLocal<Object> New(Environment* env,
     return Local<Object>();
   }
 
-  Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), data, length);
+  Local<ArrayBuffer> ab =
+      CallbackInfo::CreateTrackedArrayBuffer(env, data, length, callback, hint);
   if (ab->SetPrivate(env->context(),
                      env->untransferable_object_private_symbol(),
                      True(env->isolate())).IsNothing()) {
-    callback(data, hint);
     return Local<Object>();
   }
-  MaybeLocal<Uint8Array> ui = Buffer::New(env, ab, 0, length);
+  MaybeLocal<Uint8Array> maybe_ui = Buffer::New(env, ab, 0, length);
 
-  CallbackInfo::New(env, ab, callback, data, hint);
-
-  if (ui.IsEmpty())
+  Local<Uint8Array> ui;
+  if (!maybe_ui.ToLocal(&ui))
     return MaybeLocal<Object>();
 
-  return scope.Escape(ui.ToLocalChecked());
+  return scope.Escape(ui);
 }
 
 // Warning: This function needs `data` to be allocated with malloc() and not
@@ -438,43 +452,23 @@ MaybeLocal<Object> New(Isolate* isolate, char* data, size_t length) {
     return MaybeLocal<Object>();
   }
   Local<Object> obj;
-  if (Buffer::New(env, data, length, true).ToLocal(&obj))
+  if (Buffer::New(env, data, length).ToLocal(&obj))
     return handle_scope.Escape(obj);
   return Local<Object>();
 }
 
-// Warning: If this call comes through the public node_buffer.h API,
-// the contract for this function is that `data` is allocated with malloc()
+// The contract for this function is that `data` is allocated with malloc()
 // and not necessarily isolate's ArrayBuffer::Allocator.
 MaybeLocal<Object> New(Environment* env,
                        char* data,
-                       size_t length,
-                       bool uses_malloc) {
+                       size_t length) {
   if (length > 0) {
     CHECK_NOT_NULL(data);
     CHECK(length <= kMaxLength);
   }
 
-  if (uses_malloc) {
-    if (!env->isolate_data()->uses_node_allocator()) {
-      // We don't know for sure that the allocator is malloc()-based, so we need
-      // to fall back to the FreeCallback variant.
-      auto free_callback = [](char* data, void* hint) { free(data); };
-      return New(env, data, length, free_callback, nullptr);
-    } else {
-      // This is malloc()-based, so we can acquire it into our own
-      // ArrayBufferAllocator.
-      CHECK_NOT_NULL(env->isolate_data()->node_allocator());
-      env->isolate_data()->node_allocator()->RegisterPointer(data, length);
-    }
-  }
-
-  Local<ArrayBuffer> ab =
-      ArrayBuffer::New(env->isolate(),
-                       data,
-                       length,
-                       ArrayBufferCreationMode::kInternalized);
-  return Buffer::New(env, ab, 0, length).FromMaybe(Local<Object>());
+  auto free_callback = [](char* data, void* hint) { free(data); };
+  return New(env, data, length, free_callback, nullptr);
 }
 
 namespace {
@@ -510,18 +504,19 @@ void StringSlice(const FunctionCallbackInfo<Value>& args) {
   size_t length = end - start;
 
   Local<Value> error;
-  MaybeLocal<Value> ret =
+  MaybeLocal<Value> maybe_ret =
       StringBytes::Encode(isolate,
                           buffer.data() + start,
                           length,
                           encoding,
                           &error);
-  if (ret.IsEmpty()) {
+  Local<Value> ret;
+  if (!maybe_ret.ToLocal(&ret)) {
     CHECK(!error.IsEmpty());
     isolate->ThrowException(error);
     return;
   }
-  args.GetReturnValue().Set(ret.ToLocalChecked());
+  args.GetReturnValue().Set(ret);
 }
 
 
@@ -571,7 +566,7 @@ void Fill(const FunctionCallbackInfo<Value>& args) {
   THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);
   SPREAD_BUFFER_ARG(args[0], ts_obj);
 
-  size_t start;
+  size_t start = 0;
   THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[2], 0, &start));
   size_t end;
   THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[3], 0, &end));
@@ -633,7 +628,7 @@ void Fill(const FunctionCallbackInfo<Value>& args) {
                                     nullptr);
   }
 
- start_fill:
+start_fill:
 
   if (str_length >= fill_length)
     return;
@@ -672,8 +667,8 @@ void StringWrite(const FunctionCallbackInfo<Value>& args) {
 
   Local<String> str = args[0]->ToString(env->context()).ToLocalChecked();
 
-  size_t offset;
-  size_t max_length;
+  size_t offset = 0;
+  size_t max_length = 0;
 
   THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[1], 0, &offset));
   if (offset > ts_obj_length) {
@@ -884,7 +879,7 @@ void IndexOfString(const FunctionCallbackInfo<Value>& args) {
 
     if (IsBigEndian()) {
       StringBytes::InlineDecoder decoder;
-      if (decoder.Decode(env, needle, args[3], UCS2).IsNothing()) return;
+      if (decoder.Decode(env, needle, enc).IsNothing()) return;
       const uint16_t* decoded_string =
           reinterpret_cast<const uint16_t*>(decoder.out());
 
@@ -1080,7 +1075,7 @@ static void EncodeUtf8String(const FunctionCallbackInfo<Value>& args) {
 
   Local<String> str = args[0].As<String>();
   size_t length = str->Utf8Length(isolate);
-  AllocatedBuffer buf = env->AllocateManaged(length);
+  AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, length);
   str->WriteUtf8(isolate,
                  buf.data(),
                  -1,  // We are certain that `data` is sufficiently large
@@ -1104,13 +1099,13 @@ static void EncodeInto(const FunctionCallbackInfo<Value>& args) {
   Local<Uint8Array> dest = args[1].As<Uint8Array>();
   Local<ArrayBuffer> buf = dest->Buffer();
   char* write_result =
-      static_cast<char*>(buf->GetContents().Data()) + dest->ByteOffset();
+      static_cast<char*>(buf->GetBackingStore()->Data()) + dest->ByteOffset();
   size_t dest_length = dest->ByteLength();
 
   // results = [ read, written ]
   Local<Uint32Array> result_arr = args[2].As<Uint32Array>();
   uint32_t* results = reinterpret_cast<uint32_t*>(
-      static_cast<char*>(result_arr->Buffer()->GetContents().Data()) +
+      static_cast<char*>(result_arr->Buffer()->GetBackingStore()->Data()) +
       result_arr->ByteOffset());
 
   int nchars;
@@ -1161,7 +1156,7 @@ void Initialize(Local<Object> target,
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"),
-              Integer::NewFromUnsigned(env->isolate(), kMaxLength)).Check();
+              Number::New(env->isolate(), kMaxLength)).Check();
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "kStringMaxLength"),
@@ -1169,6 +1164,7 @@ void Initialize(Local<Object> target,
 
   env->SetMethodNoSideEffect(target, "asciiSlice", StringSlice<ASCII>);
   env->SetMethodNoSideEffect(target, "base64Slice", StringSlice<BASE64>);
+  env->SetMethodNoSideEffect(target, "base64urlSlice", StringSlice<BASE64URL>);
   env->SetMethodNoSideEffect(target, "latin1Slice", StringSlice<LATIN1>);
   env->SetMethodNoSideEffect(target, "hexSlice", StringSlice<HEX>);
   env->SetMethodNoSideEffect(target, "ucs2Slice", StringSlice<UCS2>);
@@ -1176,18 +1172,26 @@ void Initialize(Local<Object> target,
 
   env->SetMethod(target, "asciiWrite", StringWrite<ASCII>);
   env->SetMethod(target, "base64Write", StringWrite<BASE64>);
+  env->SetMethod(target, "base64urlWrite", StringWrite<BASE64URL>);
   env->SetMethod(target, "latin1Write", StringWrite<LATIN1>);
   env->SetMethod(target, "hexWrite", StringWrite<HEX>);
   env->SetMethod(target, "ucs2Write", StringWrite<UCS2>);
   env->SetMethod(target, "utf8Write", StringWrite<UTF8>);
 
+  Blob::Initialize(env, target);
+
   // It can be a nullptr when running inside an isolate where we
   // do not own the ArrayBuffer allocator.
   if (NodeArrayBufferAllocator* allocator =
           env->isolate_data()->node_allocator()) {
     uint32_t* zero_fill_field = allocator->zero_fill_field();
-    Local<ArrayBuffer> array_buffer = ArrayBuffer::New(
-        env->isolate(), zero_fill_field, sizeof(*zero_fill_field));
+    std::unique_ptr<BackingStore> backing =
+      ArrayBuffer::NewBackingStore(zero_fill_field,
+                                   sizeof(*zero_fill_field),
+                                   [](void*, size_t, void*){},
+                                   nullptr);
+    Local<ArrayBuffer> array_buffer =
+        ArrayBuffer::New(env->isolate(), std::move(backing));
     array_buffer->SetPrivate(
         env->context(),
         env->untransferable_object_private_symbol(),
diff --git a/src/node_buffer.h b/src/node_buffer.h
index 11010017ce0df8367b1992bd9df57117ff50454d..606a6f5caa3b11b6d2a9068ed2fd65800530a5eb 100644
--- a/src/node_buffer.h
+++ b/src/node_buffer.h
@@ -29,7 +29,7 @@ namespace node {
 
 namespace Buffer {
 
-static const unsigned int kMaxLength = v8::TypedArray::kMaxLength;
+static const size_t kMaxLength = v8::TypedArray::kMaxLength;
 
 typedef void (*FreeCallback)(char* data, void* hint);
 
diff --git a/src/node_context_data.h b/src/node_context_data.h
index 807ba56c7c69fbfc76ac888648305d1bae7b55a5..912e65b42707fae46eb1b679d83e27afa124749e 100644
--- a/src/node_context_data.h
+++ b/src/node_context_data.h
@@ -25,11 +25,16 @@ namespace node {
 #define NODE_CONTEXT_TAG 35
 #endif
 
+#ifndef NODE_BINDING_LIST
+#define NODE_BINDING_LIST_INDEX 36
+#endif
+
 enum ContextEmbedderIndex {
   kEnvironment = NODE_CONTEXT_EMBEDDER_DATA_INDEX,
   kSandboxObject = NODE_CONTEXT_SANDBOX_OBJECT_INDEX,
   kAllowWasmCodeGeneration = NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX,
   kContextTag = NODE_CONTEXT_TAG,
+  kBindingListIndex = NODE_BINDING_LIST_INDEX
 };
 
 }  // namespace node
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index c22247b95c5402ccfe6f10f7e698f80565c37c19..c17018be6e32bfbb596de6fc3209b2f4b26bbc36 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -36,7 +36,6 @@ namespace contextify {
 using errors::TryCatchScope;
 
 using v8::Array;
-using v8::ArrayBuffer;
 using v8::ArrayBufferView;
 using v8::Boolean;
 using v8::Context;
@@ -47,17 +46,23 @@ using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
 using v8::IndexedPropertyHandlerConfiguration;
+using v8::Int32;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
+using v8::MeasureMemoryExecution;
+using v8::MeasureMemoryMode;
+using v8::MicrotaskQueue;
+using v8::MicrotasksPolicy;
 using v8::Name;
 using v8::NamedPropertyHandlerConfiguration;
 using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::PrimitiveArray;
+using v8::Promise;
 using v8::PropertyAttribute;
 using v8::PropertyCallbackInfo;
 using v8::PropertyDescriptor;
@@ -105,7 +110,10 @@ Local<Name> Uint32ToName(Local<Context> context, uint32_t index) {
 
 ContextifyContext::ContextifyContext(
     Environment* env,
-    Local<Object> sandbox_obj, const ContextOptions& options) : env_(env) {
+    Local<Object> sandbox_obj,
+    const ContextOptions& options)
+  : env_(env),
+    microtask_queue_wrap_(options.microtask_queue_wrap) {
   MaybeLocal<Context> v8_context = CreateV8Context(env, sandbox_obj, options);
 
   // Allocation failure, maximum call stack size reached, termination, etc.
@@ -119,6 +127,11 @@ ContextifyContext::ContextifyContext(
 
 ContextifyContext::~ContextifyContext() {
   env()->RemoveCleanupHook(CleanupHook, this);
+  Isolate* isolate = env()->isolate();
+  HandleScope scope(isolate);
+
+  env()->async_hooks()
+    ->RemoveContext(PersistentToLocal::Weak(isolate, context_));
 }
 
 
@@ -185,7 +198,13 @@ MaybeLocal<Context> ContextifyContext::CreateV8Context(
 
   object_template->SetHandler(config);
   object_template->SetHandler(indexed_config);
-  Local<Context> ctx = Context::New(env->isolate(), nullptr, object_template);
+  Local<Context> ctx = Context::New(
+      env->isolate(),
+      nullptr,  // extensions
+      object_template,
+      {},       // global object
+      {},       // deserialization callback
+      microtask_queue() ? microtask_queue().get() : nullptr);
   if (ctx.IsEmpty()) return MaybeLocal<Context>();
   // Only partially initialize the context - the primordials are left out
   // and only initialized when necessary.
@@ -195,7 +214,8 @@ MaybeLocal<Context> ContextifyContext::CreateV8Context(
     return MaybeLocal<Context>();
   }
 
-  ctx->SetSecurityToken(env->context()->GetSecurityToken());
+  Local<Context> context = env->context();
+  ctx->SetSecurityToken(context->GetSecurityToken());
 
   // We need to tie the lifetime of the sandbox object with the lifetime of
   // newly created context. We do this by making them hold references to each
@@ -204,7 +224,7 @@ MaybeLocal<Context> ContextifyContext::CreateV8Context(
   // directly in an Object, we instead hold onto the new context's global
   // object instead (which then has a reference to the context).
   ctx->SetEmbedderData(ContextEmbedderIndex::kSandboxObject, sandbox_obj);
-  sandbox_obj->SetPrivate(env->context(),
+  sandbox_obj->SetPrivate(context,
                           env->contextify_global_private_symbol(),
                           ctx->Global());
 
@@ -244,7 +264,7 @@ void ContextifyContext::Init(Environment* env, Local<Object> target) {
 void ContextifyContext::MakeContext(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
-  CHECK_EQ(args.Length(), 5);
+  CHECK_EQ(args.Length(), 6);
   CHECK(args[0]->IsObject());
   Local<Object> sandbox = args[0].As<Object>();
 
@@ -270,8 +290,16 @@ void ContextifyContext::MakeContext(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[4]->IsBoolean());
   options.allow_code_gen_wasm = args[4].As<Boolean>();
 
+  if (args[5]->IsObject() &&
+      !env->microtask_queue_ctor_template().IsEmpty() &&
+      env->microtask_queue_ctor_template()->HasInstance(args[5])) {
+    options.microtask_queue_wrap.reset(
+        Unwrap<MicrotaskQueueWrap>(args[5].As<Object>()));
+  }
+
   TryCatchScope try_catch(env);
-  auto context_ptr = std::make_unique<ContextifyContext>(env, sandbox, options);
+  std::unique_ptr<ContextifyContext> context_ptr =
+      std::make_unique<ContextifyContext>(env, sandbox, options);
 
   if (try_catch.HasCaught()) {
     if (!try_catch.HasTerminated())
@@ -372,16 +400,17 @@ void ContextifyContext::PropertySetterCallback(
   if (ctx->context_.IsEmpty())
     return;
 
-  auto attributes = PropertyAttribute::None;
+  Local<Context> context = ctx->context();
+  PropertyAttribute attributes = PropertyAttribute::None;
   bool is_declared_on_global_proxy = ctx->global_proxy()
-      ->GetRealNamedPropertyAttributes(ctx->context(), property)
+      ->GetRealNamedPropertyAttributes(context, property)
       .To(&attributes);
   bool read_only =
       static_cast<int>(attributes) &
       static_cast<int>(PropertyAttribute::ReadOnly);
 
   bool is_declared_on_sandbox = ctx->sandbox()
-      ->GetRealNamedPropertyAttributes(ctx->context(), property)
+      ->GetRealNamedPropertyAttributes(context, property)
       .To(&attributes);
   read_only = read_only ||
       (static_cast<int>(attributes) &
@@ -419,7 +448,7 @@ void ContextifyContext::PropertySetterCallback(
     args.GetReturnValue().Set(false);
   }
 
-  USE(ctx->sandbox()->Set(ctx->context(), property, value));
+  USE(ctx->sandbox()->Set(context, property, value));
 }
 
 // static
@@ -458,9 +487,9 @@ void ContextifyContext::PropertyDefinerCallback(
   Local<Context> context = ctx->context();
   Isolate* isolate = context->GetIsolate();
 
-  auto attributes = PropertyAttribute::None;
+  PropertyAttribute attributes = PropertyAttribute::None;
   bool is_declared =
-      ctx->global_proxy()->GetRealNamedPropertyAttributes(ctx->context(),
+      ctx->global_proxy()->GetRealNamedPropertyAttributes(context,
                                                           property)
           .To(&attributes);
   bool read_only =
@@ -634,8 +663,10 @@ void ContextifyScript::Init(Environment* env, Local<Object> target) {
   env->SetProtoMethod(script_tmpl, "runInContext", RunInContext);
   env->SetProtoMethod(script_tmpl, "runInThisContext", RunInThisContext);
 
-  target->Set(env->context(), class_name,
-      script_tmpl->GetFunction(env->context()).ToLocalChecked()).Check();
+  Local<Context> context = env->context();
+
+  target->Set(context, class_name,
+      script_tmpl->GetFunction(context).ToLocalChecked()).Check();
   env->set_script_context_constructor_template(script_tmpl);
 }
 
@@ -703,8 +734,8 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
 
   ScriptCompiler::CachedData* cached_data = nullptr;
   if (!cached_data_buf.IsEmpty()) {
-    ArrayBuffer::Contents contents = cached_data_buf->Buffer()->GetContents();
-    uint8_t* data = static_cast<uint8_t*>(contents.Data());
+    uint8_t* data = static_cast<uint8_t*>(
+        cached_data_buf->Buffer()->GetBackingStore()->Data());
     cached_data = new ScriptCompiler::CachedData(
         data + cached_data_buf->ByteOffset(), cached_data_buf->ByteLength());
   }
@@ -755,9 +786,10 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
   }
   contextify_script->script_.Reset(isolate, v8_script.ToLocalChecked());
 
+  Local<Context> env_context = env->context();
   if (compile_options == ScriptCompiler::kConsumeCodeCache) {
     args.This()->Set(
-        env->context(),
+        env_context,
         env->cached_data_rejected_string(),
         Boolean::New(isolate, source.GetCachedData()->rejected)).Check();
   } else if (produce_cached_data) {
@@ -769,12 +801,12 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
           env,
           reinterpret_cast<const char*>(cached_data->data),
           cached_data->length);
-      args.This()->Set(env->context(),
+      args.This()->Set(env_context,
                        env->cached_data_string(),
                        buf.ToLocalChecked()).Check();
     }
     args.This()->Set(
-        env->context(),
+        env_context,
         env->cached_data_produced_string(),
         Boolean::New(isolate, cached_data_produced)).Check();
   }
@@ -842,6 +874,7 @@ void ContextifyScript::RunInThisContext(
               display_errors,
               break_on_sigint,
               break_on_first_line,
+              nullptr,  // microtask_queue
               args);
 
   TRACE_EVENT_NESTABLE_ASYNC_END0(
@@ -863,7 +896,8 @@ void ContextifyScript::RunInContext(const FunctionCallbackInfo<Value>& args) {
       ContextifyContext::ContextFromContextifiedSandbox(env, sandbox);
   CHECK_NOT_NULL(contextify_context);
 
-  if (contextify_context->context().IsEmpty())
+  Local<Context> context = contextify_context->context();
+  if (context.IsEmpty())
     return;
 
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(
@@ -882,12 +916,13 @@ void ContextifyScript::RunInContext(const FunctionCallbackInfo<Value>& args) {
   bool break_on_first_line = args[4]->IsTrue();
 
   // Do the eval within the context
-  Context::Scope context_scope(contextify_context->context());
+  Context::Scope context_scope(context);
   EvalMachine(contextify_context->env(),
               timeout,
               display_errors,
               break_on_sigint,
               break_on_first_line,
+              contextify_context->microtask_queue(),
               args);
 
   TRACE_EVENT_NESTABLE_ASYNC_END0(
@@ -899,6 +934,7 @@ bool ContextifyScript::EvalMachine(Environment* env,
                                    const bool display_errors,
                                    const bool break_on_sigint,
                                    const bool break_on_first_line,
+                                   std::shared_ptr<MicrotaskQueue> mtask_queue,
                                    const FunctionCallbackInfo<Value>& args) {
   if (!env->can_call_into_js())
     return false;
@@ -909,6 +945,7 @@ bool ContextifyScript::EvalMachine(Environment* env,
     return false;
   }
   TryCatchScope try_catch(env);
+  Isolate::SafeForTerminationScope safe_for_termination(env->isolate());
   ContextifyScript* wrapped_script;
   ASSIGN_OR_RETURN_UNWRAP(&wrapped_script, args.Holder(), false);
   Local<UnboundScript> unbound_script =
@@ -924,18 +961,24 @@ bool ContextifyScript::EvalMachine(Environment* env,
   MaybeLocal<Value> result;
   bool timed_out = false;
   bool received_signal = false;
+  auto run = [&]() {
+    MaybeLocal<Value> result = script->Run(env->context());
+    if (!result.IsEmpty() && mtask_queue)
+      mtask_queue->PerformCheckpoint(env->isolate());
+    return result;
+  };
   if (break_on_sigint && timeout != -1) {
     Watchdog wd(env->isolate(), timeout, &timed_out);
     SigintWatchdog swd(env->isolate(), &received_signal);
-    result = script->Run(env->context());
+    result = run();
   } else if (break_on_sigint) {
     SigintWatchdog swd(env->isolate(), &received_signal);
-    result = script->Run(env->context());
+    result = run();
   } else if (timeout != -1) {
     Watchdog wd(env->isolate(), timeout, &timed_out);
-    result = script->Run(env->context());
+    result = run();
   } else {
-    result = script->Run(env->context());
+    result = run();
   }
 
   // Convert the termination exception into a regular exception.
@@ -1051,8 +1094,8 @@ void ContextifyContext::CompileFunction(
   // Read cache from cached data buffer
   ScriptCompiler::CachedData* cached_data = nullptr;
   if (!cached_data_buf.IsEmpty()) {
-    ArrayBuffer::Contents contents = cached_data_buf->Buffer()->GetContents();
-    uint8_t* data = static_cast<uint8_t*>(contents.Data());
+    uint8_t* data = static_cast<uint8_t*>(
+        cached_data_buf->Buffer()->GetBackingStore()->Data());
     cached_data = new ScriptCompiler::CachedData(
       data + cached_data_buf->ByteOffset(), cached_data_buf->ByteLength());
   }
@@ -1207,13 +1250,65 @@ static void WatchdogHasPendingSigint(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(ret);
 }
 
+static void MeasureMemory(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args[0]->IsInt32());
+  CHECK(args[1]->IsInt32());
+  int32_t mode = args[0].As<v8::Int32>()->Value();
+  int32_t execution = args[1].As<v8::Int32>()->Value();
+  Isolate* isolate = args.GetIsolate();
+
+  Local<Context> current_context = isolate->GetCurrentContext();
+  Local<Promise::Resolver> resolver;
+  if (!Promise::Resolver::New(current_context).ToLocal(&resolver)) return;
+  std::unique_ptr<v8::MeasureMemoryDelegate> delegate =
+      v8::MeasureMemoryDelegate::Default(
+          isolate,
+          current_context,
+          resolver,
+          static_cast<v8::MeasureMemoryMode>(mode));
+  isolate->MeasureMemory(std::move(delegate),
+                         static_cast<v8::MeasureMemoryExecution>(execution));
+  v8::Local<v8::Promise> promise = resolver->GetPromise();
+
+  args.GetReturnValue().Set(promise);
+}
+
+MicrotaskQueueWrap::MicrotaskQueueWrap(Environment* env, Local<Object> obj)
+  : BaseObject(env, obj),
+    microtask_queue_(
+        MicrotaskQueue::New(env->isolate(), MicrotasksPolicy::kExplicit)) {
+  MakeWeak();
+}
+
+const std::shared_ptr<MicrotaskQueue>&
+MicrotaskQueueWrap::microtask_queue() const {
+  return microtask_queue_;
+}
+
+void MicrotaskQueueWrap::New(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args.IsConstructCall());
+  new MicrotaskQueueWrap(Environment::GetCurrent(args), args.This());
+}
+
+void MicrotaskQueueWrap::Init(Environment* env, Local<Object> target) {
+  HandleScope scope(env->isolate());
+  Local<FunctionTemplate> tmpl = env->NewFunctionTemplate(New);
+  tmpl->InstanceTemplate()->SetInternalFieldCount(
+      ContextifyScript::kInternalFieldCount);
+  env->set_microtask_queue_ctor_template(tmpl);
+  env->SetConstructorFunction(target, "MicrotaskQueue", tmpl);
+}
+
+
 void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context,
                 void* priv) {
   Environment* env = Environment::GetCurrent(context);
+  Isolate* isolate = env->isolate();
   ContextifyContext::Init(env, target);
   ContextifyScript::Init(env, target);
+  MicrotaskQueueWrap::Init(env, target);
 
   env->SetMethod(target, "startSigintWatchdog", StartSigintWatchdog);
   env->SetMethod(target, "stopSigintWatchdog", StopSigintWatchdog);
@@ -1229,6 +1324,33 @@ void Initialize(Local<Object> target,
 
     env->set_compiled_fn_entry_template(tpl->InstanceTemplate());
   }
+
+  Local<Object> constants = Object::New(env->isolate());
+  Local<Object> measure_memory = Object::New(env->isolate());
+  Local<Object> memory_execution = Object::New(env->isolate());
+
+  {
+    Local<Object> memory_mode = Object::New(env->isolate());
+    MeasureMemoryMode SUMMARY = MeasureMemoryMode::kSummary;
+    MeasureMemoryMode DETAILED = MeasureMemoryMode::kDetailed;
+    NODE_DEFINE_CONSTANT(memory_mode, SUMMARY);
+    NODE_DEFINE_CONSTANT(memory_mode, DETAILED);
+    READONLY_PROPERTY(measure_memory, "mode", memory_mode);
+  }
+
+  {
+    MeasureMemoryExecution DEFAULT = MeasureMemoryExecution::kDefault;
+    MeasureMemoryExecution EAGER = MeasureMemoryExecution::kEager;
+    NODE_DEFINE_CONSTANT(memory_execution, DEFAULT);
+    NODE_DEFINE_CONSTANT(memory_execution, EAGER);
+    READONLY_PROPERTY(measure_memory, "execution", memory_execution);
+  }
+
+  READONLY_PROPERTY(constants, "measureMemory", measure_memory);
+
+  target->Set(context, env->constants_string(), constants).Check();
+
+  env->SetMethod(target, "measureMemory", MeasureMemory);
 }
 
 }  // namespace contextify
diff --git a/src/node_contextify.h b/src/node_contextify.h
index f04ea86f41abaca2e618f6a9971c5a2bf718d5a7..357029d8e18312673ccb5b53f8d0195332505b9a 100644
--- a/src/node_contextify.h
+++ b/src/node_contextify.h
@@ -10,11 +10,32 @@
 namespace node {
 namespace contextify {
 
+class MicrotaskQueueWrap : public BaseObject {
+ public:
+  MicrotaskQueueWrap(Environment* env, v8::Local<v8::Object> obj);
+
+  const std::shared_ptr<v8::MicrotaskQueue>& microtask_queue() const;
+
+  static void Init(Environment* env, v8::Local<v8::Object> target);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // This could have methods for running the microtask queue, if we ever decide
+  // to make that fully customizable from userland.
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(MicrotaskQueueWrap)
+  SET_SELF_SIZE(MicrotaskQueueWrap)
+
+ private:
+  std::shared_ptr<v8::MicrotaskQueue> microtask_queue_;
+};
+
 struct ContextOptions {
   v8::Local<v8::String> name;
   v8::Local<v8::String> origin;
   v8::Local<v8::Boolean> allow_code_gen_strings;
   v8::Local<v8::Boolean> allow_code_gen_wasm;
+  BaseObjectPtr<MicrotaskQueueWrap> microtask_queue_wrap;
 };
 
 class ContextifyContext {
@@ -53,6 +74,11 @@ class ContextifyContext {
         context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject));
   }
 
+  inline std::shared_ptr<v8::MicrotaskQueue> microtask_queue() const {
+    if (!microtask_queue_wrap_) return {};
+    return microtask_queue_wrap_->microtask_queue();
+  }
+
 
   template <typename T>
   static ContextifyContext* Get(const v8::PropertyCallbackInfo<T>& args);
@@ -102,6 +128,7 @@ class ContextifyContext {
       const v8::PropertyCallbackInfo<v8::Boolean>& args);
   Environment* const env_;
   v8::Global<v8::Context> context_;
+  BaseObjectPtr<MicrotaskQueueWrap> microtask_queue_wrap_;
 };
 
 class ContextifyScript : public BaseObject {
@@ -125,6 +152,7 @@ class ContextifyScript : public BaseObject {
                           const bool display_errors,
                           const bool break_on_sigint,
                           const bool break_on_first_line,
+                          std::shared_ptr<v8::MicrotaskQueue> microtask_queue,
                           const v8::FunctionCallbackInfo<v8::Value>& args);
 
   inline uint32_t id() { return id_; }
@@ -146,6 +174,8 @@ class CompiledFnEntry final : public BaseObject {
                   v8::Local<v8::ScriptOrModule> script);
   ~CompiledFnEntry();
 
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override { return true; }
+
  private:
   uint32_t id_;
   v8::Global<v8::ScriptOrModule> script_;
diff --git a/src/node_credentials.cc b/src/node_credentials.cc
index 7c7a4f84c860844641d6931a6352ea4473ab4eac..b07067580af8507c6f24a2e8717555d14a1336b1 100644
--- a/src/node_credentials.cc
+++ b/src/node_credentials.cc
@@ -20,7 +20,6 @@ using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
-using v8::NewStringType;
 using v8::Object;
 using v8::String;
 using v8::TryCatch;
@@ -46,8 +45,7 @@ bool SafeGetenv(const char* key, std::string* text, Environment* env) {
     TryCatch ignore_errors(env->isolate());
     MaybeLocal<String> maybe_value = env->env_vars()->Get(
         env->isolate(),
-        String::NewFromUtf8(env->isolate(), key, NewStringType::kNormal)
-            .ToLocalChecked());
+        String::NewFromUtf8(env->isolate(), key).ToLocalChecked());
     Local<String> value;
     if (!maybe_value.ToLocal(&value)) goto fail;
     String::Utf8Value utf8_value(env->isolate(), value);
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 764dcb872093ba1f2eec145f3e0b7f17677cd702..61db9f04bba143fd2aa03b695206908c731afb08 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -27,7 +27,8 @@
 #include "node_crypto_groups.h"
 #include "node_errors.h"
 #include "node_mutex.h"
-#include "node_process.h"
+#include "node_process-inl.h"
+#include "allocated_buffer-inl.h"
 #include "tls_wrap.h"  // TLSWrap
 
 #include "async_wrap-inl.h"
@@ -66,7 +67,9 @@ namespace crypto {
 using node::THROW_ERR_TLS_INVALID_PROTOCOL_METHOD;
 
 using v8::Array;
+using v8::ArrayBuffer;
 using v8::ArrayBufferView;
+using v8::BackingStore;
 using v8::Boolean;
 using v8::ConstructorBehavior;
 using v8::Context;
@@ -96,6 +99,7 @@ using v8::SideEffectType;
 using v8::Signature;
 using v8::String;
 using v8::Uint32;
+using v8::Uint8Array;
 using v8::Undefined;
 using v8::Value;
 
@@ -145,6 +149,26 @@ template int SSLWrap<TLSWrap>::SelectALPNCallback(
     unsigned int inlen,
     void* arg);
 
+template <typename T>
+void Decode(const FunctionCallbackInfo<Value>& args,
+            void (*callback)(T*, const FunctionCallbackInfo<Value>&,
+                             const char*, size_t)) {
+  T* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Holder());
+
+  if (args[0]->IsString()) {
+    StringBytes::InlineDecoder decoder;
+    Environment* env = Environment::GetCurrent(args);
+    enum encoding enc = ParseEncoding(env->isolate(), args[1], UTF8);
+    if (decoder.Decode(env, args[0].As<String>(), enc).IsNothing())
+      return;
+    callback(ctx, args, decoder.out(), decoder.size());
+  } else {
+    ArrayBufferViewContents<char> buf(args[0]);
+    callback(ctx, args, buf.data(), buf.length());
+  }
+}
+
 static int PasswordCallback(char* buf, int size, int rwflag, void* u) {
   const char* passphrase = static_cast<char*>(u);
   if (passphrase != nullptr) {
@@ -371,8 +395,7 @@ void ThrowCryptoError(Environment* env,
   }
   HandleScope scope(env->isolate());
   Local<String> exception_string =
-      String::NewFromUtf8(env->isolate(), message, NewStringType::kNormal)
-      .ToLocalChecked();
+      String::NewFromUtf8(env->isolate(), message).ToLocalChecked();
   CryptoErrorVector errors;
   errors.Capture();
   Local<Value> exception;
@@ -486,7 +509,7 @@ void SecureContext::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> ctx_getter_templ =
       FunctionTemplate::New(env->isolate(),
                             CtxGetter,
-                            env->as_callback_data(),
+                            Local<Value>(),
                             Signature::New(env->isolate(), t));
 
 
@@ -988,8 +1011,8 @@ void GetRootCertificates(const FunctionCallbackInfo<Value>& args) {
   for (size_t i = 0; i < arraysize(root_certs); i++) {
     if (!String::NewFromOneByte(
             env->isolate(),
-            reinterpret_cast<const uint8_t*>(root_certs[i]),
-            NewStringType::kNormal).ToLocal(&result[i])) {
+            reinterpret_cast<const uint8_t*>(root_certs[i]))
+            .ToLocal(&result[i])) {
       return;
     }
   }
@@ -1889,7 +1912,7 @@ void SSLWrap<Base>::GetFinished(const FunctionCallbackInfo<Value>& args) {
   if (len == 0)
     return;
 
-  AllocatedBuffer buf = env->AllocateManaged(len);
+  AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, len);
   CHECK_EQ(len, SSL_get_finished(w->ssl_.get(), buf.data(), len));
   args.GetReturnValue().Set(buf.ToBuffer().ToLocalChecked());
 }
@@ -1912,7 +1935,7 @@ void SSLWrap<Base>::GetPeerFinished(const FunctionCallbackInfo<Value>& args) {
   if (len == 0)
     return;
 
-  AllocatedBuffer buf = env->AllocateManaged(len);
+  AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, len);
   CHECK_EQ(len, SSL_get_peer_finished(w->ssl_.get(), buf.data(), len));
   args.GetReturnValue().Set(buf.ToBuffer().ToLocalChecked());
 }
@@ -1933,7 +1956,7 @@ void SSLWrap<Base>::GetSession(const FunctionCallbackInfo<Value>& args) {
   if (slen <= 0)
     return;  // Invalid or malformed session.
 
-  AllocatedBuffer sbuf = env->AllocateManaged(slen);
+  AllocatedBuffer sbuf = AllocatedBuffer::AllocateManaged(env, slen);
   unsigned char* p = reinterpret_cast<unsigned char*>(sbuf.data());
   CHECK_LT(0, i2d_SSL_SESSION(sess, &p));
   args.GetReturnValue().Set(sbuf.ToBuffer().ToLocalChecked());
@@ -2240,7 +2263,7 @@ void SSLWrap<Base>::ExportKeyingMaterial(
   uint32_t olen = args[0].As<Uint32>()->Value();
   node::Utf8Value label(env->isolate(), args[1]);
 
-  AllocatedBuffer out = env->AllocateManaged(olen);
+  AllocatedBuffer out = AllocatedBuffer::AllocateManaged(env, olen);
 
   ByteSource context;
   bool use_context = !args[2]->IsUndefined();
@@ -3998,7 +4021,7 @@ CipherBase::UpdateResult CipherBase::Update(const char* data,
     return kErrorState;
   }
 
-  *out = env()->AllocateManaged(buf_len);
+  *out = AllocatedBuffer::AllocateManaged(env(), buf_len);
   int r = EVP_CipherUpdate(ctx_.get(),
                            reinterpret_cast<unsigned char*>(out->data()),
                            &buf_len,
@@ -4019,37 +4042,24 @@ CipherBase::UpdateResult CipherBase::Update(const char* data,
 
 
 void CipherBase::Update(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-
-  CipherBase* cipher;
-  ASSIGN_OR_RETURN_UNWRAP(&cipher, args.Holder());
-
-  AllocatedBuffer out;
-  UpdateResult r;
-
-  // Only copy the data if we have to, because it's a string
-  if (args[0]->IsString()) {
-    StringBytes::InlineDecoder decoder;
-    if (!decoder.Decode(env, args[0].As<String>(), args[1], UTF8)
-             .FromMaybe(false))
+  Decode<CipherBase>(args, [](CipherBase* cipher,
+                              const FunctionCallbackInfo<Value>& args,
+                              const char* data, size_t size) {
+    AllocatedBuffer out;
+    UpdateResult r = cipher->Update(data, size, &out);
+
+    if (r != kSuccess) {
+      if (r == kErrorState) {
+        Environment* env = Environment::GetCurrent(args);
+        ThrowCryptoError(env, ERR_get_error(),
+                         "Trying to add data in unsupported state");
+      }
       return;
-    r = cipher->Update(decoder.out(), decoder.size(), &out);
-  } else {
-    ArrayBufferViewContents<char> buf(args[0]);
-    r = cipher->Update(buf.data(), buf.length(), &out);
-  }
-
-  if (r != kSuccess) {
-    if (r == kErrorState) {
-      ThrowCryptoError(env, ERR_get_error(),
-                       "Trying to add data in unsupported state");
     }
-    return;
-  }
-
-  CHECK(out.data() != nullptr || out.size() == 0);
 
-  args.GetReturnValue().Set(out.ToBuffer().ToLocalChecked());
+    CHECK(out.data() != nullptr || out.size() == 0);
+    args.GetReturnValue().Set(out.ToBuffer().ToLocalChecked());
+  });
 }
 
 
@@ -4075,7 +4085,8 @@ bool CipherBase::Final(AllocatedBuffer* out) {
 
   const int mode = EVP_CIPHER_CTX_mode(ctx_.get());
 
-  *out = env()->AllocateManaged(
+  *out = AllocatedBuffer::AllocateManaged(
+      env(),
       static_cast<size_t>(EVP_CIPHER_CTX_block_size(ctx_.get())));
 
   if (kind_ == kDecipher && IsSupportedAuthenticatedMode(ctx_.get())) {
@@ -4087,7 +4098,7 @@ bool CipherBase::Final(AllocatedBuffer* out) {
   bool ok;
   if (kind_ == kDecipher && mode == EVP_CIPH_CCM_MODE) {
     ok = !pending_auth_failed_;
-    *out = AllocatedBuffer(env());  // Empty buffer.
+    *out = AllocatedBuffer::AllocateManaged(env(), 0);  // Empty buffer.
   } else {
     int out_len = out->size();
     ok = EVP_CipherFinal_ex(ctx_.get(),
@@ -4212,25 +4223,11 @@ bool Hmac::HmacUpdate(const char* data, int len) {
 
 
 void Hmac::HmacUpdate(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-
-  Hmac* hmac;
-  ASSIGN_OR_RETURN_UNWRAP(&hmac, args.Holder());
-
-  // Only copy the data if we have to, because it's a string
-  bool r = false;
-  if (args[0]->IsString()) {
-    StringBytes::InlineDecoder decoder;
-    if (decoder.Decode(env, args[0].As<String>(), args[1], UTF8)
-            .FromMaybe(false)) {
-      r = hmac->HmacUpdate(decoder.out(), decoder.size());
-    }
-  } else {
-    ArrayBufferViewContents<char> buf(args[0]);
-    r = hmac->HmacUpdate(buf.data(), buf.length());
-  }
-
-  args.GetReturnValue().Set(r);
+  Decode<Hmac>(args, [](Hmac* hmac, const FunctionCallbackInfo<Value>& args,
+                        const char* data, size_t size) {
+    bool r = hmac->HmacUpdate(data, size);
+    args.GetReturnValue().Set(r);
+  });
 }
 
 
@@ -4360,27 +4357,11 @@ bool Hash::HashUpdate(const char* data, int len) {
 
 
 void Hash::HashUpdate(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-
-  Hash* hash;
-  ASSIGN_OR_RETURN_UNWRAP(&hash, args.Holder());
-
-  // Only copy the data if we have to, because it's a string
-  bool r = true;
-  if (args[0]->IsString()) {
-    StringBytes::InlineDecoder decoder;
-    if (!decoder.Decode(env, args[0].As<String>(), args[1], UTF8)
-             .FromMaybe(false)) {
-      args.GetReturnValue().Set(false);
-      return;
-    }
-    r = hash->HashUpdate(decoder.out(), decoder.size());
-  } else if (args[0]->IsArrayBufferView()) {
-    ArrayBufferViewContents<char> buf(args[0].As<ArrayBufferView>());
-    r = hash->HashUpdate(buf.data(), buf.length());
-  }
-
-  args.GetReturnValue().Set(r);
+  Decode<Hash>(args, [](Hash* hash, const FunctionCallbackInfo<Value>& args,
+                        const char* data, size_t size) {
+    bool r = hash->HashUpdate(data, size);
+    args.GetReturnValue().Set(r);
+  });
 }
 
 
@@ -4582,14 +4563,11 @@ void Sign::SignInit(const FunctionCallbackInfo<Value>& args) {
 
 
 void Sign::SignUpdate(const FunctionCallbackInfo<Value>& args) {
-  Sign* sign;
-  ASSIGN_OR_RETURN_UNWRAP(&sign, args.Holder());
-
-  Error err;
-  ArrayBufferViewContents<char> buf(args[0]);
-  err = sign->Update(buf.data(), buf.length());
-
-  sign->CheckThrow(err);
+  Decode<Sign>(args, [](Sign* sign, const FunctionCallbackInfo<Value>& args,
+                        const char* data, size_t size) {
+    Error err = sign->Update(data, size);
+    sign->CheckThrow(err);
+  });
 }
 
 static int GetDefaultSignPadding(const ManagedEVPPKey& key) {
@@ -4632,7 +4610,7 @@ static AllocatedBuffer ConvertSignatureToP1363(Environment* env,
   if (!asn1_sig)
     return AllocatedBuffer();
 
-  AllocatedBuffer buf = env->AllocateManaged(2 * n);
+  AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, 2 * n);
   unsigned char* data = reinterpret_cast<unsigned char*>(buf.data());
 
   const BIGNUM* r = ECDSA_SIG_get0_r(asn1_sig.get());
@@ -4691,7 +4669,7 @@ static AllocatedBuffer Node_SignFinal(Environment* env,
   int signed_sig_len = EVP_PKEY_size(pkey.get());
   CHECK_GE(signed_sig_len, 0);
   size_t sig_len = static_cast<size_t>(signed_sig_len);
-  AllocatedBuffer sig = env->AllocateManaged(sig_len);
+  AllocatedBuffer sig = AllocatedBuffer::AllocateManaged(env, sig_len);
 
   EVPKeyCtxPointer pkctx(EVP_PKEY_CTX_new(pkey.get(), nullptr));
   if (pkctx &&
@@ -4852,7 +4830,7 @@ void SignOneShot(const FunctionCallbackInfo<Value>& args) {
   if (!EVP_DigestSign(mdctx.get(), nullptr, &sig_len, input, data.length()))
     return CheckThrow(env, SignBase::Error::kSignPrivateKey);
 
-  AllocatedBuffer signature = env->AllocateManaged(sig_len);
+  AllocatedBuffer signature = AllocatedBuffer::AllocateManaged(env, sig_len);
   if (!EVP_DigestSign(mdctx.get(),
                       reinterpret_cast<unsigned char*>(signature.data()),
                       &sig_len,
@@ -4908,14 +4886,12 @@ void Verify::VerifyInit(const FunctionCallbackInfo<Value>& args) {
 
 
 void Verify::VerifyUpdate(const FunctionCallbackInfo<Value>& args) {
-  Verify* verify;
-  ASSIGN_OR_RETURN_UNWRAP(&verify, args.Holder());
-
-  Error err;
-  ArrayBufferViewContents<char> buf(args[0]);
-  err = verify->Update(buf.data(), buf.length());
-
-  verify->CheckThrow(err);
+  Decode<Verify>(args, [](Verify* verify,
+                          const FunctionCallbackInfo<Value>& args,
+                          const char* data, size_t size) {
+    Error err = verify->Update(data, size);
+    verify->CheckThrow(err);
+  });
 }
 
 
@@ -5112,7 +5088,7 @@ bool PublicKeyCipher::Cipher(Environment* env,
   if (EVP_PKEY_cipher(ctx.get(), nullptr, &out_len, data, len) <= 0)
     return false;
 
-  *out = env->AllocateManaged(out_len);
+  *out = AllocatedBuffer::AllocateManaged(env, out_len);
 
   if (EVP_PKEY_cipher(ctx.get(),
                       reinterpret_cast<unsigned char*>(out->data()),
@@ -5207,7 +5183,7 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
     Local<FunctionTemplate> verify_error_getter_templ =
         FunctionTemplate::New(env->isolate(),
                               DiffieHellman::VerifyErrorGetter,
-                              env->as_callback_data(),
+                              Local<Value>(),
                               Signature::New(env->isolate(), t),
                               /* length */ 0,
                               ConstructorBehavior::kThrow,
@@ -5309,7 +5285,7 @@ void DiffieHellman::DiffieHellmanGroup(
   const node::Utf8Value group_name(env->isolate(), args[0]);
   const modp_group* group = FindDiffieHellmanGroup(*group_name);
   if (group == nullptr)
-    return THROW_ERR_CRYPTO_UNKNOWN_DH_GROUP(env, "Unknown group");
+    return THROW_ERR_CRYPTO_UNKNOWN_DH_GROUP(env);
 
   initialized = diffieHellman->Init(group->prime,
                                     group->prime_size,
@@ -5365,7 +5341,7 @@ void DiffieHellman::GenerateKeys(const FunctionCallbackInfo<Value>& args) {
   DH_get0_key(diffieHellman->dh_.get(), &pub_key, nullptr);
   const int size = BN_num_bytes(pub_key);
   CHECK_GE(size, 0);
-  AllocatedBuffer data = env->AllocateManaged(size);
+  AllocatedBuffer data = AllocatedBuffer::AllocateManaged(env, size);
   CHECK_EQ(size,
            BN_bn2binpad(
                pub_key, reinterpret_cast<unsigned char*>(data.data()), size));
@@ -5386,7 +5362,7 @@ void DiffieHellman::GetField(const FunctionCallbackInfo<Value>& args,
 
   const int size = BN_num_bytes(num);
   CHECK_GE(size, 0);
-  AllocatedBuffer data = env->AllocateManaged(size);
+  AllocatedBuffer data = AllocatedBuffer::AllocateManaged(env, size);
   CHECK_EQ(
       size,
       BN_bn2binpad(num, reinterpret_cast<unsigned char*>(data.data()), size));
@@ -5456,7 +5432,8 @@ void DiffieHellman::ComputeSecret(const FunctionCallbackInfo<Value>& args) {
   ArrayBufferViewContents<unsigned char> key_buf(args[0].As<ArrayBufferView>());
   BignumPointer key(BN_bin2bn(key_buf.data(), key_buf.length(), nullptr));
 
-  AllocatedBuffer ret = env->AllocateManaged(DH_size(diffieHellman->dh_.get()));
+  AllocatedBuffer ret =
+      AllocatedBuffer::AllocateManaged(env, DH_size(diffieHellman->dh_.get()));
 
   int size = DH_compute_key(reinterpret_cast<unsigned char*>(ret.data()),
                             key.get(),
@@ -5663,7 +5640,7 @@ void ECDH::ComputeSecret(const FunctionCallbackInfo<Value>& args) {
   // NOTE: field_size is in bits
   int field_size = EC_GROUP_get_degree(ecdh->group_);
   size_t out_len = (field_size + 7) / 8;
-  AllocatedBuffer out = env->AllocateManaged(out_len);
+  AllocatedBuffer out = AllocatedBuffer::AllocateManaged(env, out_len);
 
   int r = ECDH_compute_key(
       out.data(), out_len, pub.get(), ecdh->key_.get(), nullptr);
@@ -5712,7 +5689,7 @@ void ECDH::GetPrivateKey(const FunctionCallbackInfo<Value>& args) {
     return env->ThrowError("Failed to get ECDH private key");
 
   const int size = BN_num_bytes(b);
-  AllocatedBuffer out = env->AllocateManaged(size);
+  AllocatedBuffer out = AllocatedBuffer::AllocateManaged(env, size);
   CHECK_EQ(size, BN_bn2binpad(b,
                               reinterpret_cast<unsigned char*>(out.data()),
                               size));
@@ -6702,7 +6679,7 @@ AllocatedBuffer ExportPublicKey(Environment* env,
   BIO_get_mem_ptr(bio.get(), &ptr);
 
   *size = ptr->length;
-  AllocatedBuffer buf = env->AllocateManaged(*size);
+  AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, *size);
   memcpy(buf.data(), ptr->data, *size);
 
   return buf;
@@ -6811,7 +6788,7 @@ AllocatedBuffer StatelessDiffieHellman(Environment* env, ManagedEVPPKey our_key,
       EVP_PKEY_derive(ctx.get(), nullptr, &out_size) <= 0)
     return AllocatedBuffer();
 
-  AllocatedBuffer result = env->AllocateManaged(out_size);
+  AllocatedBuffer result = AllocatedBuffer::AllocateManaged(env, out_size);
   CHECK_NOT_NULL(result.data());
 
   unsigned char* data = reinterpret_cast<unsigned char*>(result.data());
@@ -6970,6 +6947,35 @@ void SetFipsCrypto(const FunctionCallbackInfo<Value>& args) {
 }
 #endif /* NODE_FIPS_MODE */
 
+namespace {
+// SecureBuffer uses openssl to allocate a Uint8Array using
+// OPENSSL_secure_malloc. Because we do not yet actually
+// make use of secure heap, this has the same semantics as
+// using OPENSSL_malloc. However, if the secure heap is
+// initialized, SecureBuffer will automatically use it.
+void SecureBuffer(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args[0]->IsUint32());
+  Environment* env = Environment::GetCurrent(args);
+  uint32_t len = args[0].As<Uint32>()->Value();
+  char* data = static_cast<char*>(OPENSSL_secure_malloc(len));
+  if (data == nullptr) {
+    // There's no memory available for the allocation.
+    // Return nothing.
+    return;
+  }
+  memset(data, 0, len);
+  std::shared_ptr<BackingStore> store =
+      ArrayBuffer::NewBackingStore(
+          data,
+          len,
+          [](void* data, size_t len, void* deleter_data) {
+            OPENSSL_secure_clear_free(data, len);
+          },
+          data);
+  Local<ArrayBuffer> buffer = ArrayBuffer::New(env->isolate(), store);
+  args.GetReturnValue().Set(Uint8Array::New(buffer, 0, len));
+}
+}  // namespace
 
 void Initialize(Local<Object> target,
                 Local<Value> unused,
@@ -7064,6 +7070,8 @@ void Initialize(Local<Object> target,
 #ifndef OPENSSL_NO_SCRYPT
   env->SetMethod(target, "scrypt", Scrypt);
 #endif  // OPENSSL_NO_SCRYPT
+
+  env->SetMethod(target, "secureBuffer", SecureBuffer);
 }
 
 }  // namespace crypto
diff --git a/src/node_crypto.h b/src/node_crypto.h
index 573d59ddf41771a2aad126c8a8a6683593f431bf..bef98b3e244d9e9032158152ebf4bafab1642974 100644
--- a/src/node_crypto.h
+++ b/src/node_crypto.h
@@ -27,6 +27,7 @@
 // ClientHelloParser
 #include "node_crypto_clienthello.h"
 
+#include "allocated_buffer.h"
 #include "env.h"
 #include "base_object.h"
 #include "util.h"
diff --git a/src/node_crypto_bio.cc b/src/node_crypto_bio.cc
index 55f5e8a5a37650eba8e0cfb85cda129dbf0cd5d6..8c58e31f86b3fa276e462f4f643c414c221b21f2 100644
--- a/src/node_crypto_bio.cc
+++ b/src/node_crypto_bio.cc
@@ -21,6 +21,7 @@
 
 #include "base_object-inl.h"
 #include "memory_tracker-inl.h"
+#include "allocated_buffer-inl.h"  // Inlined functions needed by node_crypto.h.
 #include "node_crypto_bio.h"
 #include "openssl/bio.h"
 #include "util-inl.h"
diff --git a/src/node_crypto_common.cc b/src/node_crypto_common.cc
index 6c3bb0b1b650fa4ecfd4a31dc8da6bd16f3a9462..d43e5af2b5d95b2cc988e85b31f54a980266d49b 100644
--- a/src/node_crypto_common.cc
+++ b/src/node_crypto_common.cc
@@ -1,3 +1,4 @@
+#include "allocated_buffer-inl.h"
 #include "base_object-inl.h"
 #include "env-inl.h"
 #include "node_buffer.h"
@@ -5,6 +6,7 @@
 #include "node_crypto_common.h"
 #include "node.h"
 #include "node_internals.h"
+#include "node_revert.h"
 #include "node_url.h"
 #include "string_bytes.h"
 #include "v8.h"
@@ -40,6 +42,7 @@ using v8::Value;
 namespace crypto {
 
 static constexpr int X509_NAME_FLAGS =
+    ASN1_STRFLGS_ESC_2253 |
     ASN1_STRFLGS_ESC_CTRL |
     ASN1_STRFLGS_UTF8_CONVERT |
     XN_FLAG_SEP_MULTILINE |
@@ -133,76 +136,6 @@ SSLSessionPointer GetTLSSession(const unsigned char* buf, size_t length) {
   return SSLSessionPointer(d2i_SSL_SESSION(nullptr, &buf, length));
 }
 
-std::unordered_multimap<std::string, std::string>
-GetCertificateAltNames(X509* cert) {
-  std::unordered_multimap<std::string, std::string> map;
-  BIOPointer bio(BIO_new(BIO_s_mem()));
-  BUF_MEM* mem;
-  int idx = X509_get_ext_by_NID(cert, NID_subject_alt_name, -1);
-  if (idx < 0)  // There is no subject alt name
-    return map;
-
-  X509_EXTENSION* ext = X509_get_ext(cert, idx);
-  CHECK_NOT_NULL(ext);
-  const X509V3_EXT_METHOD* method = X509V3_EXT_get(ext);
-  CHECK_EQ(method, X509V3_EXT_get_nid(NID_subject_alt_name));
-
-  GENERAL_NAMES* names = static_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(ext));
-  if (names == nullptr)  // There are no names
-    return map;
-
-  for (int i = 0; i < sk_GENERAL_NAME_num(names); i++) {
-    USE(BIO_reset(bio.get()));
-    GENERAL_NAME* gen = sk_GENERAL_NAME_value(names, i);
-    if (gen->type == GEN_DNS) {
-      ASN1_IA5STRING* name = gen->d.dNSName;
-      BIO_write(bio.get(), name->data, name->length);
-      BIO_get_mem_ptr(bio.get(), &mem);
-      map.emplace("dns", std::string(mem->data, mem->length));
-    } else {
-      STACK_OF(CONF_VALUE)* nval = i2v_GENERAL_NAME(
-          const_cast<X509V3_EXT_METHOD*>(method), gen, nullptr);
-      if (nval == nullptr)
-        continue;
-      X509V3_EXT_val_prn(bio.get(), nval, 0, 0);
-      sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
-      BIO_get_mem_ptr(bio.get(), &mem);
-      std::string value(mem->data, mem->length);
-      if (value.compare(0, 11, "IP Address:") == 0) {
-        map.emplace("ip", value.substr(11));
-      } else if (value.compare(0, 4, "URI:") == 0) {
-        url::URL url(value.substr(4));
-        if (url.flags() & url::URL_FLAGS_CANNOT_BE_BASE ||
-            url.flags() & url::URL_FLAGS_FAILED) {
-          continue;  // Skip this one
-        }
-        map.emplace("uri", url.host());
-      }
-    }
-  }
-  sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
-  return map;
-}
-
-std::string GetCertificateCN(X509* cert) {
-  X509_NAME* subject = X509_get_subject_name(cert);
-  if (subject != nullptr) {
-    int nid = OBJ_txt2nid("CN");
-    int idx = X509_NAME_get_index_by_NID(subject, nid, -1);
-    if (idx != -1) {
-      X509_NAME_ENTRY* cn = X509_NAME_get_entry(subject, idx);
-      if (cn != nullptr) {
-        ASN1_STRING* cn_str = X509_NAME_ENTRY_get_data(cn);
-        if (cn_str != nullptr) {
-          return std::string(reinterpret_cast<const char*>(
-              ASN1_STRING_get0_data(cn_str)));
-        }
-      }
-    }
-  }
-  return std::string();
-}
-
 long VerifyPeerCertificate(  // NOLINT(runtime/int)
     const SSLPointer& ssl,
     long def) {  // NOLINT(runtime/int)
@@ -487,7 +420,7 @@ MaybeLocal<Object> GetLastIssuedCert(
 MaybeLocal<Object> GetRawDERCertificate(Environment* env, X509* cert) {
   int size = i2d_X509(cert, nullptr);
 
-  AllocatedBuffer buffer = env->AllocateManaged(size);
+  AllocatedBuffer buffer = AllocatedBuffer::AllocateManaged(env, size);
   unsigned char* serialized =
       reinterpret_cast<unsigned char*>(buffer.data());
   i2d_X509(cert, &serialized);
@@ -550,6 +483,7 @@ void AddFingerprintDigest(
   }
 }
 
+// deprecated, only used for security revert
 bool SafeX509ExtPrint(const BIOPointer& out, X509_EXTENSION* ext) {
   const X509V3_EXT_METHOD* method = X509V3_EXT_get(ext);
 
@@ -574,8 +508,10 @@ bool SafeX509ExtPrint(const BIOPointer& out, X509_EXTENSION* ext) {
     } else {
       STACK_OF(CONF_VALUE)* nval = i2v_GENERAL_NAME(
           const_cast<X509V3_EXT_METHOD*>(method), gen, nullptr);
-      if (nval == nullptr)
+      if (nval == nullptr) {
+        sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
         return false;
+      }
       X509V3_EXT_val_prn(out.get(), nval, 0, 0);
       sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
     }
@@ -585,6 +521,418 @@ bool SafeX509ExtPrint(const BIOPointer& out, X509_EXTENSION* ext) {
   return true;
 }
 
+static inline bool IsSafeAltName(const char* name, size_t length, bool utf8) {
+  for (size_t i = 0; i < length; i++) {
+    char c = name[i];
+    switch (c) {
+    case '"':
+    case '\\':
+      // These mess with encoding rules.
+      // Fall through.
+    case ',':
+      // Commas make it impossible to split the list of subject alternative
+      // names unambiguously, which is why we have to escape.
+      // Fall through.
+    case '\'':
+      // Single quotes are unlikely to appear in any legitimate values, but they
+      // could be used to make a value look like it was escaped (i.e., enclosed
+      // in single/double quotes).
+      return false;
+    default:
+      if (utf8) {
+        // In UTF8 strings, we require escaping for any ASCII control character,
+        // but NOT for non-ASCII characters. Note that all bytes of any code
+        // point that consists of more than a single byte have their MSB set.
+        if (static_cast<unsigned char>(c) < ' ' || c == '\x7f') {
+          return false;
+        }
+      } else {
+        // Check if the char is a control character or non-ASCII character. Note
+        // that char may or may not be a signed type. Regardless, non-ASCII
+        // values will always be outside of this range.
+        if (c < ' ' || c > '~') {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+static inline void PrintAltName(const BIOPointer& out, const char* name,
+                                size_t length, bool utf8,
+                                const char* safe_prefix) {
+  if (IsSafeAltName(name, length, utf8)) {
+    // For backward-compatibility, append "safe" names without any
+    // modifications.
+    if (safe_prefix != nullptr) {
+      BIO_printf(out.get(), "%s:", safe_prefix);
+    }
+    BIO_write(out.get(), name, length);
+  } else {
+    // If a name is not "safe", we cannot embed it without special
+    // encoding. This does not usually happen, but we don't want to hide
+    // it from the user either. We use JSON compatible escaping here.
+    BIO_write(out.get(), "\"", 1);
+    if (safe_prefix != nullptr) {
+      BIO_printf(out.get(), "%s:", safe_prefix);
+    }
+    for (size_t j = 0; j < length; j++) {
+      char c = static_cast<char>(name[j]);
+      if (c == '\\') {
+        BIO_write(out.get(), "\\\\", 2);
+      } else if (c == '"') {
+        BIO_write(out.get(), "\\\"", 2);
+      } else if ((c >= ' ' && c != ',' && c <= '~') || (utf8 && (c & 0x80))) {
+        // Note that the above condition explicitly excludes commas, which means
+        // that those are encoded as Unicode escape sequences in the "else"
+        // block. That is not strictly necessary, and Node.js itself would parse
+        // it correctly either way. We only do this to account for third-party
+        // code that might be splitting the string at commas (as Node.js itself
+        // used to do).
+        BIO_write(out.get(), &c, 1);
+      } else {
+        // Control character or non-ASCII character. We treat everything as
+        // Latin-1, which corresponds to the first 255 Unicode code points.
+        const char hex[] = "0123456789abcdef";
+        char u[] = { '\\', 'u', '0', '0', hex[(c & 0xf0) >> 4], hex[c & 0x0f] };
+        BIO_write(out.get(), u, sizeof(u));
+      }
+    }
+    BIO_write(out.get(), "\"", 1);
+  }
+}
+
+static inline void PrintLatin1AltName(const BIOPointer& out,
+                                      const ASN1_IA5STRING* name,
+                                      const char* safe_prefix = nullptr) {
+  PrintAltName(out, reinterpret_cast<const char*>(name->data), name->length,
+               false, safe_prefix);
+}
+
+static inline void PrintUtf8AltName(const BIOPointer& out,
+                                    const ASN1_UTF8STRING* name,
+                                    const char* safe_prefix = nullptr) {
+  PrintAltName(out, reinterpret_cast<const char*>(name->data), name->length,
+               true, safe_prefix);
+}
+
+// This function currently emulates the behavior of i2v_GENERAL_NAME in a safer
+// and less ambiguous way.
+// TODO(tniessen): gradually improve the format in the next major version(s)
+static bool PrintGeneralName(const BIOPointer& out, const GENERAL_NAME* gen) {
+  if (gen->type == GEN_DNS) {
+    ASN1_IA5STRING* name = gen->d.dNSName;
+    BIO_write(out.get(), "DNS:", 4);
+    // Note that the preferred name syntax (see RFCs 5280 and 1034) with
+    // wildcards is a subset of what we consider "safe", so spec-compliant DNS
+    // names will never need to be escaped.
+    PrintLatin1AltName(out, name);
+  } else if (gen->type == GEN_EMAIL) {
+    ASN1_IA5STRING* name = gen->d.rfc822Name;
+    BIO_write(out.get(), "email:", 6);
+    PrintLatin1AltName(out, name);
+  } else if (gen->type == GEN_URI) {
+    ASN1_IA5STRING* name = gen->d.uniformResourceIdentifier;
+    BIO_write(out.get(), "URI:", 4);
+    // The set of "safe" names was designed to include just about any URI,
+    // with a few exceptions, most notably URIs that contains commas (see
+    // RFC 2396). In other words, most legitimate URIs will not require
+    // escaping.
+    PrintLatin1AltName(out, name);
+  } else if (gen->type == GEN_DIRNAME) {
+    // For backward compatibility, use X509_NAME_oneline to print the
+    // X509_NAME object. The format is non standard and should be avoided
+    // elsewhere, but conveniently, the function produces ASCII and the output
+    // is unlikely to contains commas or other characters that would require
+    // escaping. With that in mind, note that it SHOULD NOT produce ASCII
+    // output since an RFC5280 AttributeValue may be a UTF8String.
+    // TODO(tniessen): switch to RFC2253 rules in a major release
+    BIO_printf(out.get(), "DirName:");
+    char oline[256];
+    if (X509_NAME_oneline(gen->d.dirn, oline, sizeof(oline)) != nullptr) {
+      PrintAltName(out, oline, strlen(oline), false, nullptr);
+    } else {
+      return false;
+    }
+  } else if (gen->type == GEN_IPADD) {
+    BIO_printf(out.get(), "IP Address:");
+    const ASN1_OCTET_STRING* ip = gen->d.ip;
+    const unsigned char* b = ip->data;
+    if (ip->length == 4) {
+      BIO_printf(out.get(), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
+    } else if (ip->length == 16) {
+      for (unsigned int j = 0; j < 8; j++) {
+        uint16_t pair = (b[2 * j] << 8) | b[2 * j + 1];
+        BIO_printf(out.get(), (j == 0) ? "%X" : ":%X", pair);
+      }
+    } else {
+#if OPENSSL_VERSION_MAJOR >= 3
+      BIO_printf(out.get(), "<invalid length=%d>", ip->length);
+#else
+      BIO_printf(out.get(), "<invalid>");
+#endif
+    }
+  } else if (gen->type == GEN_RID) {
+    // TODO(tniessen): unlike OpenSSL's default implementation, never print the
+    // OID as text and instead always print its numeric representation, which is
+    // backward compatible in practice and more future proof (see OBJ_obj2txt).
+    char oline[256];
+    i2t_ASN1_OBJECT(oline, sizeof(oline), gen->d.rid);
+    BIO_printf(out.get(), "Registered ID:%s", oline);
+  } else if (gen->type == GEN_OTHERNAME) {
+    // TODO(tniessen): the format that is used here is based on OpenSSL's
+    // implementation of i2v_GENERAL_NAME (as of OpenSSL 3.0.1), mostly for
+    // backward compatibility. It is somewhat awkward, especially when passed to
+    // translatePeerCertificate, and should be changed in the future, probably
+    // to the format used by GENERAL_NAME_print (in a major release).
+    bool unicode = true;
+    const char* prefix = nullptr;
+    // OpenSSL 1.1.1 does not support othername in i2v_GENERAL_NAME and may not
+    // define these NIDs.
+#if OPENSSL_VERSION_MAJOR >= 3
+    int nid = OBJ_obj2nid(gen->d.otherName->type_id);
+    switch (nid) {
+      case NID_id_on_SmtpUTF8Mailbox:
+        prefix = " SmtpUTF8Mailbox:";
+        break;
+      case NID_XmppAddr:
+        prefix = " XmppAddr:";
+        break;
+      case NID_SRVName:
+        prefix = " SRVName:";
+        unicode = false;
+        break;
+      case NID_ms_upn:
+        prefix = " UPN:";
+        break;
+      case NID_NAIRealm:
+        prefix = " NAIRealm:";
+        break;
+    }
+#endif  // OPENSSL_VERSION_MAJOR >= 3
+    int val_type = gen->d.otherName->value->type;
+    if (prefix == nullptr ||
+        (unicode && val_type != V_ASN1_UTF8STRING) ||
+        (!unicode && val_type != V_ASN1_IA5STRING)) {
+      BIO_printf(out.get(), "othername:<unsupported>");
+    } else {
+      BIO_printf(out.get(), "othername:");
+      if (unicode) {
+        PrintUtf8AltName(out, gen->d.otherName->value->value.utf8string,
+                         prefix);
+      } else {
+        PrintLatin1AltName(out, gen->d.otherName->value->value.ia5string,
+                           prefix);
+      }
+    }
+  } else if (gen->type == GEN_X400) {
+    // TODO(tniessen): this is what OpenSSL does, implement properly instead
+    BIO_printf(out.get(), "X400Name:<unsupported>");
+  } else if (gen->type == GEN_EDIPARTY) {
+    // TODO(tniessen): this is what OpenSSL does, implement properly instead
+    BIO_printf(out.get(), "EdiPartyName:<unsupported>");
+  } else {
+    // This is safe because X509V3_EXT_d2i would have returned nullptr in this
+    // case already.
+    UNREACHABLE();
+  }
+
+  return true;
+}
+
+bool SafeX509SubjectAltNamePrint(const BIOPointer& out, X509_EXTENSION* ext) {
+  const X509V3_EXT_METHOD* method = X509V3_EXT_get(ext);
+  CHECK(method == X509V3_EXT_get_nid(NID_subject_alt_name));
+
+  if (IsReverted(SECURITY_REVERT_CVE_2021_44532)) {
+    return  SafeX509ExtPrint(out, ext);
+  }
+
+  GENERAL_NAMES* names = static_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(ext));
+  if (names == nullptr)
+    return false;
+
+  bool ok = true;
+
+  for (int i = 0; i < sk_GENERAL_NAME_num(names); i++) {
+    GENERAL_NAME* gen = sk_GENERAL_NAME_value(names, i);
+
+    if (i != 0)
+      BIO_write(out.get(), ", ", 2);
+
+    if (!(ok = PrintGeneralName(out, gen))) {
+      break;
+    }
+  }
+  sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
+
+  return ok;
+}
+
+bool SafeX509InfoAccessPrint(const BIOPointer& out, X509_EXTENSION* ext) {
+  const X509V3_EXT_METHOD* method = X509V3_EXT_get(ext);
+  CHECK(method == X509V3_EXT_get_nid(NID_info_access));
+
+  if (IsReverted(SECURITY_REVERT_CVE_2021_44532)) {
+    return (X509V3_EXT_print(out.get(), ext, 0, 0) == 1);
+  }
+
+  AUTHORITY_INFO_ACCESS* descs =
+      static_cast<AUTHORITY_INFO_ACCESS*>(X509V3_EXT_d2i(ext));
+  if (descs == nullptr)
+    return false;
+
+  bool ok = true;
+
+  for (int i = 0; i < sk_ACCESS_DESCRIPTION_num(descs); i++) {
+    ACCESS_DESCRIPTION* desc = sk_ACCESS_DESCRIPTION_value(descs, i);
+
+    if (i != 0)
+      BIO_write(out.get(), "\n", 1);
+
+    char objtmp[80];
+    i2t_ASN1_OBJECT(objtmp, sizeof(objtmp), desc->method);
+    BIO_printf(out.get(), "%s - ", objtmp);
+    if (!(ok = PrintGeneralName(out, desc->location))) {
+      break;
+    }
+  }
+  sk_ACCESS_DESCRIPTION_pop_free(descs, ACCESS_DESCRIPTION_free);
+
+#if OPENSSL_VERSION_MAJOR < 3
+  BIO_write(out.get(), "\n", 1);
+#endif
+
+  return ok;
+}
+
+v8::MaybeLocal<v8::Value> GetSubjectAltNameString(
+    Environment* env,
+    const BIOPointer& bio,
+    X509* cert) {
+  int index = X509_get_ext_by_NID(cert, NID_subject_alt_name, -1);
+  if (index < 0)
+    return Undefined(env->isolate());
+
+  X509_EXTENSION* ext = X509_get_ext(cert, index);
+  CHECK_NOT_NULL(ext);
+
+  if (!SafeX509SubjectAltNamePrint(bio, ext)) {
+    USE(BIO_reset(bio.get()));
+    return v8::Null(env->isolate());
+  }
+
+  return ToV8Value(env, bio);
+}
+
+v8::MaybeLocal<v8::Value> GetInfoAccessString(
+    Environment* env,
+    const BIOPointer& bio,
+    X509* cert) {
+  int index = X509_get_ext_by_NID(cert, NID_info_access, -1);
+  if (index < 0)
+    return Undefined(env->isolate());
+
+  X509_EXTENSION* ext = X509_get_ext(cert, index);
+  CHECK_NOT_NULL(ext);
+
+  if (!SafeX509InfoAccessPrint(bio, ext)) {
+    USE(BIO_reset(bio.get()));
+    return v8::Null(env->isolate());
+  }
+
+  return ToV8Value(env, bio);
+}
+
+template <X509_NAME* get_name(const X509*)>
+static MaybeLocal<Value> GetX509NameObject(Environment* env, X509* cert) {
+  X509_NAME* name = get_name(cert);
+  CHECK_NOT_NULL(name);
+
+  int cnt = X509_NAME_entry_count(name);
+  CHECK_GE(cnt, 0);
+
+  Local<Object> result =
+      Object::New(env->isolate(), Null(env->isolate()), nullptr, nullptr, 0);
+  if (result.IsEmpty()) {
+    return MaybeLocal<Value>();
+  }
+
+  for (int i = 0; i < cnt; i++) {
+    X509_NAME_ENTRY* entry = X509_NAME_get_entry(name, i);
+    CHECK_NOT_NULL(entry);
+
+    // We intentionally ignore the value of X509_NAME_ENTRY_set because the
+    // representation as an object does not allow grouping entries into sets
+    // anyway, and multi-value RDNs are rare, i.e., the vast majority of
+    // Relative Distinguished Names contains a single type-value pair only.
+    const ASN1_OBJECT* type = X509_NAME_ENTRY_get_object(entry);
+    const ASN1_STRING* value = X509_NAME_ENTRY_get_data(entry);
+
+    // If OpenSSL knows the type, use the short name of the type as the key, and
+    // the numeric representation of the type's OID otherwise.
+    int type_nid = OBJ_obj2nid(type);
+    char type_buf[80];
+    const char* type_str;
+    if (type_nid != NID_undef) {
+      type_str = OBJ_nid2sn(type_nid);
+      CHECK_NOT_NULL(type_str);
+    } else {
+      OBJ_obj2txt(type_buf, sizeof(type_buf), type, true);
+      type_str = type_buf;
+    }
+
+    Local<String> v8_name;
+    if (!String::NewFromUtf8(env->isolate(), type_str,
+                             NewStringType::kNormal).ToLocal(&v8_name)) {
+      return MaybeLocal<Value>();
+    }
+
+    // The previous implementation used X509_NAME_print_ex, which escapes some
+    // characters in the value. The old implementation did not decode/unescape
+    // values correctly though, leading to ambiguous and incorrect
+    // representations. The new implementation only converts to Unicode and does
+    // not escape anything.
+    unsigned char* value_str;
+    int value_str_size = ASN1_STRING_to_UTF8(&value_str, value);
+    if (value_str_size < 0) {
+      return Undefined(env->isolate());
+    }
+
+    Local<String> v8_value;
+    if (!String::NewFromUtf8(env->isolate(),
+                             reinterpret_cast<const char*>(value_str),
+                             NewStringType::kNormal,
+                             value_str_size).ToLocal(&v8_value)) {
+      OPENSSL_free(value_str);
+      return MaybeLocal<Value>();
+    }
+
+    OPENSSL_free(value_str);
+
+    // For backward compatibility, we only create arrays if multiple values
+    // exist for the same key. That is not great but there is not much we can
+    // change here without breaking things. Note that this creates nested data
+    // structures, yet still does not allow representing Distinguished Names
+    // accurately.
+    if (result->HasOwnProperty(env->context(), v8_name).ToChecked()) {
+      Local<Value> accum =
+          result->Get(env->context(), v8_name).ToLocalChecked();
+      if (!accum->IsArray()) {
+        accum = Array::New(env->isolate(), &accum, 1);
+        result->Set(env->context(), v8_name, accum).Check();
+      }
+      Local<Array> array = accum.As<Array>();
+      array->Set(env->context(), array->Length(), v8_value).Check();
+    } else {
+      result->Set(env->context(), v8_name, v8_value).Check();
+    }
+  }
+
+  return result;
+}
+
 MaybeLocal<Value> GetFingerprintDigest(
     Environment* env,
     const EVP_MD* method,
@@ -664,7 +1012,7 @@ MaybeLocal<Object> GetPubKey(Environment* env, const RSAPointer& rsa) {
   int size = i2d_RSA_PUBKEY(rsa.get(), nullptr);
   CHECK_GE(size, 0);
 
-  AllocatedBuffer buffer = env->AllocateManaged(size);
+  AllocatedBuffer buffer = AllocatedBuffer::AllocateManaged(env, size);
   unsigned char* serialized =
       reinterpret_cast<unsigned char*>(buffer.data());
   i2d_RSA_PUBKEY(rsa.get(), &serialized);
@@ -698,27 +1046,6 @@ MaybeLocal<Value> GetModulusString(
   return ToV8Value(env, bio);
 }
 
-template <int nid>
-MaybeLocal<Value> GetInfoString(
-    Environment* env,
-    const BIOPointer& bio,
-    X509* cert) {
-  int index = X509_get_ext_by_NID(cert, nid, -1);
-  if (index < 0)
-    return Undefined(env->isolate());
-
-  X509_EXTENSION* ext = X509_get_ext(cert, index);
-  CHECK_NOT_NULL(ext);
-
-  if (!SafeX509ExtPrint(bio, ext) &&
-      X509V3_EXT_print(bio.get(), ext, 0, 0) != 1) {
-    USE(BIO_reset(bio.get()));
-    return Null(env->isolate());
-  }
-
-  return ToV8Value(env, bio);
-}
-
 MaybeLocal<Value> GetIssuerString(
     Environment* env,
     const BIOPointer& bio,
@@ -886,7 +1213,7 @@ MaybeLocal<Object> ECPointToBuffer(Environment* env,
     if (error != nullptr) *error = "Failed to get public key length";
     return MaybeLocal<Object>();
   }
-  AllocatedBuffer buf = env->AllocateManaged(len);
+  AllocatedBuffer buf = AllocatedBuffer::AllocateManaged(env, len);
   len = EC_POINT_point2oct(group,
                            point,
                            form,
@@ -969,29 +1296,51 @@ MaybeLocal<Value> GetPeerCert(
   return result;
 }
 
-MaybeLocal<Object> X509ToObject(Environment* env, X509* cert) {
+MaybeLocal<Object> X509ToObject(
+    Environment* env,
+    X509* cert,
+    bool names_as_string) {
   EscapableHandleScope scope(env->isolate());
   Local<Context> context = env->context();
   Local<Object> info = Object::New(env->isolate());
 
   BIOPointer bio(BIO_new(BIO_s_mem()));
 
+  if (names_as_string) {
+    // TODO(tniessen): this branch should not have to exist. It is only here
+    // because toLegacyObject() does not actually return a legacy object, and
+    // instead represents subject and issuer as strings.
+    if (!Set<Value>(context,
+                    info,
+                    env->subject_string(),
+                    GetSubject(env, bio, cert)) ||
+        !Set<Value>(context,
+                    info,
+                    env->issuer_string(),
+                    GetIssuerString(env, bio, cert))) {
+      return MaybeLocal<Object>();
+    }
+  } else {
+    if (!Set<Value>(context,
+                    info,
+                    env->subject_string(),
+                    GetX509NameObject<X509_get_subject_name>(env, cert)) ||
+        !Set<Value>(context,
+                    info,
+                    env->issuer_string(),
+                    GetX509NameObject<X509_get_issuer_name>(env, cert))) {
+      return MaybeLocal<Object>();
+    }
+  }
+
   if (!Set<Value>(context,
-                  info,
-                  env->subject_string(),
-                  GetSubject(env, bio, cert)) ||
-      !Set<Value>(context,
-                  info,
-                  env->issuer_string(),
-                  GetIssuerString(env, bio, cert)) ||
-      !Set<Value>(context,
                   info,
                   env->subjectaltname_string(),
-                  GetInfoString<NID_subject_alt_name>(env, bio, cert)) ||
+                  GetSubjectAltNameString(env, bio, cert)) ||
       !Set<Value>(context,
                   info,
                   env->infoaccess_string(),
-                  GetInfoString<NID_info_access>(env, bio, cert))) {
+                  GetInfoAccessString(env, bio, cert))) {
     return MaybeLocal<Object>();
   }
 
diff --git a/src/node_crypto_common.h b/src/node_crypto_common.h
index c373a97e4763a439714ffcf2a9839e8af574929f..bf58df18f69f4d777858cb4cb4a9b4684a9183c8 100644
--- a/src/node_crypto_common.h
+++ b/src/node_crypto_common.h
@@ -9,7 +9,6 @@
 #include <openssl/x509v3.h>
 
 #include <string>
-#include <unordered_map>
 
 namespace node {
 namespace crypto {
@@ -62,11 +61,6 @@ SSLSessionPointer GetTLSSession(v8::Local<v8::Value> val);
 
 SSLSessionPointer GetTLSSession(const unsigned char* buf, size_t length);
 
-std::unordered_multimap<std::string, std::string>
-GetCertificateAltNames(X509* cert);
-
-std::string GetCertificateCN(X509* cert);
-
 long VerifyPeerCertificate(  // NOLINT(runtime/int)
     const SSLPointer& ssl,
     long def = X509_V_ERR_UNSPECIFIED);  // NOLINT(runtime/int)
@@ -128,7 +122,8 @@ v8::MaybeLocal<v8::Object> ECPointToBuffer(
 
 v8::MaybeLocal<v8::Object> X509ToObject(
     Environment* env,
-    X509* cert);
+    X509* cert,
+    bool names_as_string = false);
 
 }  // namespace crypto
 }  // namespace node
diff --git a/src/node_dir.cc b/src/node_dir.cc
index f4d2d1efbdc6e7f18b42ac2e055fefb72f3d875a..9275aac17d6b339d774e361a8f285adbead2b72f 100644
--- a/src/node_dir.cc
+++ b/src/node_dir.cc
@@ -1,6 +1,6 @@
 #include "node_dir.h"
 #include "node_file-inl.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "memory_tracker-inl.h"
 #include "util.h"
 
@@ -39,7 +39,6 @@ using v8::Null;
 using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
-using v8::String;
 using v8::Value;
 
 #define TRACE_NAME(name) "fs_dir.sync." #name
@@ -149,7 +148,7 @@ void DirHandle::Close(const FunctionCallbackInfo<Value>& args) {
   dir->closing_ = false;
   dir->closed_ = true;
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[0]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 0);
   if (req_wrap_async != nullptr) {  // close(req)
     AsyncCall(env, req_wrap_async, args, "closedir", UTF8, AfterClose,
               uv_fs_closedir, dir->dir());
@@ -253,7 +252,7 @@ void DirHandle::Read(const FunctionCallbackInfo<Value>& args) {
     dir->dir_->dirents = dir->dirents_.data();
   }
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // dir.read(encoding, bufferSize, req)
     AsyncCall(env, req_wrap_async, args, "readdir", encoding,
               AfterDirRead, uv_fs_readdir, dir->dir());
@@ -321,7 +320,7 @@ static void OpenDir(const FunctionCallbackInfo<Value>& args) {
 
   const enum encoding encoding = ParseEncoding(isolate, args[1], UTF8);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // openDir(path, encoding, req)
     AsyncCall(env, req_wrap_async, args, "opendir", encoding, AfterOpenDir,
               uv_fs_opendir, *path);
@@ -349,7 +348,6 @@ void Initialize(Local<Object> target,
                 Local<Context> context,
                 void* priv) {
   Environment* env = Environment::GetCurrent(context);
-  Isolate* isolate = env->isolate();
 
   env->SetMethod(target, "opendir", OpenDir);
 
@@ -360,13 +358,7 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(dir, "close", DirHandle::Close);
   Local<ObjectTemplate> dirt = dir->InstanceTemplate();
   dirt->SetInternalFieldCount(DirHandle::kInternalFieldCount);
-  Local<String> handleString =
-       FIXED_ONE_BYTE_STRING(isolate, "DirHandle");
-  dir->SetClassName(handleString);
-  target
-      ->Set(context, handleString,
-            dir->GetFunction(env->context()).ToLocalChecked())
-      .FromJust();
+  env->SetConstructorFunction(target, "DirHandle", dir);
   env->set_dir_instance_template(dirt);
 }
 
diff --git a/src/node_env_var.cc b/src/node_env_var.cc
index 9b634337043cef633a3de4f723269ea4eb555cfb..9192ea334be4c1885317fefb9d0eedc720aeaa8d 100644
--- a/src/node_env_var.cc
+++ b/src/node_env_var.cc
@@ -1,12 +1,16 @@
 #include "debug_utils-inl.h"
 #include "env-inl.h"
 #include "node_errors.h"
-#include "node_process.h"
+#include "node_process-inl.h"
+
+#include <time.h>  // tzset(), _tzset()
 
 namespace node {
 using v8::Array;
 using v8::Boolean;
 using v8::Context;
+using v8::DontDelete;
+using v8::DontEnum;
 using v8::EscapableHandleScope;
 using v8::HandleScope;
 using v8::Integer;
@@ -23,6 +27,7 @@ using v8::Object;
 using v8::ObjectTemplate;
 using v8::PropertyCallbackInfo;
 using v8::PropertyHandlerFlags;
+using v8::ReadOnly;
 using v8::String;
 using v8::Value;
 
@@ -62,6 +67,19 @@ Mutex env_var_mutex;
 std::shared_ptr<KVStore> system_environment = std::make_shared<RealEnvStore>();
 }  // namespace per_process
 
+template <typename T>
+void DateTimeConfigurationChangeNotification(Isolate* isolate, const T& key) {
+  if (key.length() == 2 && key[0] == 'T' && key[1] == 'Z') {
+#ifdef __POSIX__
+    tzset();
+#else
+    _tzset();
+#endif
+    auto constexpr time_zone_detection = Isolate::TimeZoneDetection::kRedetect;
+    isolate->DateTimeConfigurationChangeNotification(time_zone_detection);
+  }
+}
+
 Maybe<std::string> RealEnvStore::Get(const char* key) const {
   Mutex::ScopedLock lock(per_process::env_var_mutex);
 
@@ -77,10 +95,10 @@ Maybe<std::string> RealEnvStore::Get(const char* key) const {
   }
 
   if (ret >= 0) {  // Env key value fetch success.
-    return v8::Just(std::string(*val, init_sz));
+    return Just(std::string(*val, init_sz));
   }
 
-  return v8::Nothing<std::string>();
+  return Nothing<std::string>();
 }
 
 MaybeLocal<String> RealEnvStore::Get(Isolate* isolate,
@@ -109,6 +127,7 @@ void RealEnvStore::Set(Isolate* isolate,
   if (key.length() > 0 && key[0] == '=') return;
 #endif
   uv_os_setenv(*key, *val);
+  DateTimeConfigurationChangeNotification(isolate, key);
 }
 
 int32_t RealEnvStore::Query(const char* key) const {
@@ -124,9 +143,9 @@ int32_t RealEnvStore::Query(const char* key) const {
 
 #ifdef _WIN32
   if (key[0] == '=') {
-    return static_cast<int32_t>(v8::ReadOnly) |
-           static_cast<int32_t>(v8::DontDelete) |
-           static_cast<int32_t>(v8::DontEnum);
+    return static_cast<int32_t>(ReadOnly) |
+           static_cast<int32_t>(DontDelete) |
+           static_cast<int32_t>(DontEnum);
   }
 #endif
 
@@ -143,6 +162,7 @@ void RealEnvStore::Delete(Isolate* isolate, Local<String> property) {
 
   node::Utf8Value key(isolate, property);
   uv_os_unsetenv(*key);
+  DateTimeConfigurationChangeNotification(isolate, key);
 }
 
 Local<Array> RealEnvStore::Enumerate(Isolate* isolate) const {
@@ -158,12 +178,9 @@ Local<Array> RealEnvStore::Enumerate(Isolate* isolate) const {
   for (int i = 0; i < count; i++) {
 #ifdef _WIN32
     // If the key starts with '=' it is a hidden environment variable.
-    // The '\0' check is a workaround for the bug behind
-    // https://github.com/libuv/libuv/pull/2473 and can be removed later.
-    if (items[i].name[0] == '=' || items[i].name[0] == '\0') continue;
+    if (items[i].name[0] == '=') continue;
 #endif
-    MaybeLocal<String> str = String::NewFromUtf8(
-        isolate, items[i].name, NewStringType::kNormal);
+    MaybeLocal<String> str = String::NewFromUtf8(isolate, items[i].name);
     if (str.IsEmpty()) {
       isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
       return Local<Array>();
@@ -174,7 +191,7 @@ Local<Array> RealEnvStore::Enumerate(Isolate* isolate) const {
   return Array::New(isolate, env_v.out(), env_v_index);
 }
 
-std::shared_ptr<KVStore> KVStore::Clone(v8::Isolate* isolate) const {
+std::shared_ptr<KVStore> KVStore::Clone(Isolate* isolate) const {
   HandleScope handle_scope(isolate);
   Local<Context> context = isolate->GetCurrentContext();
 
@@ -194,7 +211,7 @@ std::shared_ptr<KVStore> KVStore::Clone(v8::Isolate* isolate) const {
 Maybe<std::string> MapKVStore::Get(const char* key) const {
   Mutex::ScopedLock lock(mutex_);
   auto it = map_.find(key);
-  return it == map_.end() ? v8::Nothing<std::string>() : v8::Just(it->second);
+  return it == map_.end() ? Nothing<std::string>() : Just(it->second);
 }
 
 MaybeLocal<String> MapKVStore::Get(Isolate* isolate, Local<String> key) const {
@@ -360,13 +377,11 @@ static void EnvEnumerator(const PropertyCallbackInfo<Array>& info) {
       env->env_vars()->Enumerate(env->isolate()));
 }
 
-MaybeLocal<Object> CreateEnvVarProxy(Local<Context> context,
-                                     Isolate* isolate,
-                                     Local<Object> data) {
+MaybeLocal<Object> CreateEnvVarProxy(Local<Context> context, Isolate* isolate) {
   EscapableHandleScope scope(isolate);
   Local<ObjectTemplate> env_proxy_template = ObjectTemplate::New(isolate);
   env_proxy_template->SetHandler(NamedPropertyHandlerConfiguration(
-      EnvGetter, EnvSetter, EnvQuery, EnvDeleter, EnvEnumerator, data,
+      EnvGetter, EnvSetter, EnvQuery, EnvDeleter, EnvEnumerator, Local<Value>(),
       PropertyHandlerFlags::kHasNoSideEffect));
   return scope.EscapeMaybe(env_proxy_template->NewInstance(context));
 }
diff --git a/src/node_errors.cc b/src/node_errors.cc
index 6961e748c06ad9950e633f6560c0f8f7495f08f5..94e19f70aa288fbae1db1726b5a26d33be08b021 100644
--- a/src/node_errors.cc
+++ b/src/node_errors.cc
@@ -5,7 +5,7 @@
 #include "node_errors.h"
 #include "node_internals.h"
 #include "node_report.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "node_v8_platform-inl.h"
 #include "util-inl.h"
 
@@ -55,9 +55,18 @@ static std::string GetErrorSource(Isolate* isolate,
   MaybeLocal<String> source_line_maybe = message->GetSourceLine(context);
   node::Utf8Value encoded_source(isolate, source_line_maybe.ToLocalChecked());
   std::string sourceline(*encoded_source, encoded_source.length());
+  *added_exception_line = false;
+
+  // If source maps have been enabled, the exception line will instead be
+  // added in the JavaScript context:
+  Environment* env = Environment::GetCurrent(isolate);
+  const bool has_source_map_url =
+      !message->GetScriptOrigin().SourceMapUrl().IsEmpty();
+  if (has_source_map_url && env != nullptr && env->source_maps_enabled()) {
+    return sourceline;
+  }
 
   if (sourceline.find("node-do-not-add-exception-line") != std::string::npos) {
-    *added_exception_line = false;
     return sourceline;
   }
 
@@ -104,6 +113,13 @@ static std::string GetErrorSource(Isolate* isolate,
                             linenum,
                             sourceline.c_str());
   CHECK_GT(buf.size(), 0);
+  *added_exception_line = true;
+
+  if (start > end ||
+      start < 0 ||
+      static_cast<size_t>(end) > sourceline.size()) {
+    return buf;
+  }
 
   constexpr int kUnderlineBufsize = 1020;
   char underline_buf[kUnderlineBufsize + 4];
@@ -126,7 +142,6 @@ static std::string GetErrorSource(Isolate* isolate,
   CHECK_LE(off, kUnderlineBufsize);
   underline_buf[off++] = '\n';
 
-  *added_exception_line = true;
   return buf + std::string(underline_buf, off);
 }
 
@@ -409,7 +424,10 @@ void OnFatalError(const char* location, const char* message) {
   }
 
   Isolate* isolate = Isolate::GetCurrent();
-  Environment* env = Environment::GetCurrent(isolate);
+  Environment* env = nullptr;
+  if (isolate != nullptr) {
+    env = Environment::GetCurrent(isolate);
+  }
   bool report_on_fatalerror;
   {
     Mutex::ScopedLock lock(node::per_process::cli_options_mutex);
@@ -801,6 +819,12 @@ void SetPrepareStackTraceCallback(const FunctionCallbackInfo<Value>& args) {
   env->set_prepare_stack_trace_callback(args[0].As<Function>());
 }
 
+static void SetSourceMapsEnabled(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args[0]->IsBoolean());
+  env->set_source_maps_enabled(args[0].As<Boolean>()->Value());
+}
+
 static void SetEnhanceStackForFatalException(
     const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -839,6 +863,7 @@ void Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
   env->SetMethod(
       target, "setPrepareStackTraceCallback", SetPrepareStackTraceCallback);
+  env->SetMethod(target, "setSourceMapsEnabled", SetSourceMapsEnabled);
   env->SetMethod(target,
                  "setEnhanceStackForFatalException",
                  SetEnhanceStackForFatalException);
@@ -924,7 +949,7 @@ void TriggerUncaughtException(Isolate* isolate,
     return;
   }
 
-  MaybeLocal<Value> handled;
+  MaybeLocal<Value> maybe_handled;
   if (env->can_call_into_js()) {
     // We do not expect the global uncaught exception itself to throw any more
     // exceptions. If it does, exit the current Node.js instance.
@@ -938,7 +963,7 @@ void TriggerUncaughtException(Isolate* isolate,
     Local<Value> argv[2] = { error,
                              Boolean::New(env->isolate(), from_promise) };
 
-    handled = fatal_exception_function.As<Function>()->Call(
+    maybe_handled = fatal_exception_function.As<Function>()->Call(
         env->context(), process_object, arraysize(argv), argv);
   }
 
@@ -946,7 +971,8 @@ void TriggerUncaughtException(Isolate* isolate,
   // instance so return to continue the exit routine.
   // TODO(joyeecheung): return a Maybe here to prevent the caller from
   // stepping on the exit.
-  if (handled.IsEmpty()) {
+  Local<Value> handled;
+  if (!maybe_handled.ToLocal(&handled)) {
     return;
   }
 
@@ -956,7 +982,7 @@ void TriggerUncaughtException(Isolate* isolate,
   // TODO(joyeecheung): This has been only checking that the return value is
   // exactly false. Investigate whether this can be turned to an "if true"
   // similar to how the worker global uncaught exception handler handles it.
-  if (!handled.ToLocalChecked()->IsFalse()) {
+  if (!handled->IsFalse()) {
     return;
   }
 
diff --git a/src/node_errors.h b/src/node_errors.h
index a47f096b43430ba35355bb01bba9bb0249b88e2d..7b67c4e9eb95b7e8f291f2b59354aa4119222232 100644
--- a/src/node_errors.h
+++ b/src/node_errors.h
@@ -3,6 +3,7 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "debug_utils-inl.h"
 #include "env.h"
 #include "v8.h"
 
@@ -31,15 +32,19 @@ void OnFatalError(const char* location, const char* message);
   V(ERR_BUFFER_CONTEXT_NOT_AVAILABLE, Error)                                   \
   V(ERR_BUFFER_OUT_OF_BOUNDS, RangeError)                                      \
   V(ERR_BUFFER_TOO_LARGE, Error)                                               \
+  V(ERR_CLOSED_MESSAGE_PORT, Error)                                            \
   V(ERR_CONSTRUCT_CALL_REQUIRED, TypeError)                                    \
   V(ERR_CONSTRUCT_CALL_INVALID, TypeError)                                     \
   V(ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH, RangeError)                           \
   V(ERR_CRYPTO_UNKNOWN_CIPHER, Error)                                          \
   V(ERR_CRYPTO_UNKNOWN_DH_GROUP, Error)                                        \
+  V(ERR_DLOPEN_FAILED, Error)                                                  \
   V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE, Error)                            \
+  V(ERR_INVALID_ADDRESS, Error)                                                \
   V(ERR_INVALID_ARG_VALUE, TypeError)                                          \
   V(ERR_OSSL_EVP_INVALID_DIGEST, Error)                                        \
   V(ERR_INVALID_ARG_TYPE, TypeError)                                           \
+  V(ERR_INVALID_MODULE, Error)                                                 \
   V(ERR_INVALID_THIS, TypeError)                                               \
   V(ERR_INVALID_TRANSFER_OBJECT, TypeError)                                    \
   V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                       \
@@ -54,32 +59,42 @@ void OnFatalError(const char* location, const char* message);
   V(ERR_SCRIPT_EXECUTION_TIMEOUT, Error)                                       \
   V(ERR_STRING_TOO_LONG, Error)                                                \
   V(ERR_TLS_INVALID_PROTOCOL_METHOD, TypeError)                                \
-  V(ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER, TypeError)                \
   V(ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED, Error)                                \
   V(ERR_VM_MODULE_CACHED_DATA_REJECTED, Error)                                 \
+  V(ERR_VM_MODULE_LINK_FAILURE, Error)                                         \
   V(ERR_WASI_NOT_STARTED, Error)                                               \
   V(ERR_WORKER_INIT_FAILED, Error)                                             \
   V(ERR_PROTO_ACCESS, Error)
 
-#define V(code, type)                                                         \
-  inline v8::Local<v8::Value> code(v8::Isolate* isolate,                      \
-                                   const char* message)       {               \
-    v8::Local<v8::String> js_code = OneByteString(isolate, #code);            \
-    v8::Local<v8::String> js_msg = OneByteString(isolate, message);           \
-    v8::Local<v8::Object> e =                                                 \
-        v8::Exception::type(js_msg)->ToObject(                                \
-            isolate->GetCurrentContext()).ToLocalChecked();                   \
-    e->Set(isolate->GetCurrentContext(), OneByteString(isolate, "code"),      \
-           js_code).Check();                                                  \
-    return e;                                                                 \
-  }                                                                           \
-  inline void THROW_ ## code(v8::Isolate* isolate, const char* message) {     \
-    isolate->ThrowException(code(isolate, message));                          \
-  }                                                                           \
-  inline void THROW_ ## code(Environment* env, const char* message) {         \
-    THROW_ ## code(env->isolate(), message);                                  \
+#define V(code, type)                                                          \
+  template <typename... Args>                                                  \
+  inline v8::Local<v8::Value> code(                                            \
+      v8::Isolate* isolate, const char* format, Args&&... args) {              \
+    std::string message = SPrintF(format, std::forward<Args>(args)...);        \
+    v8::Local<v8::String> js_code = OneByteString(isolate, #code);             \
+    v8::Local<v8::String> js_msg =                                             \
+        OneByteString(isolate, message.c_str(), message.length());             \
+    v8::Local<v8::Object> e = v8::Exception::type(js_msg)                      \
+                                  ->ToObject(isolate->GetCurrentContext())     \
+                                  .ToLocalChecked();                           \
+    e->Set(isolate->GetCurrentContext(),                                       \
+           OneByteString(isolate, "code"),                                     \
+           js_code)                                                            \
+        .Check();                                                              \
+    return e;                                                                  \
+  }                                                                            \
+  template <typename... Args>                                                  \
+  inline void THROW_##code(                                                    \
+      v8::Isolate* isolate, const char* format, Args&&... args) {              \
+    isolate->ThrowException(                                                   \
+        code(isolate, format, std::forward<Args>(args)...));                   \
+  }                                                                            \
+  template <typename... Args>                                                  \
+  inline void THROW_##code(                                                    \
+      Environment* env, const char* format, Args&&... args) {                  \
+    THROW_##code(env->isolate(), format, std::forward<Args>(args)...);         \
   }
-  ERRORS_WITH_CODE(V)
+ERRORS_WITH_CODE(V)
 #undef V
 
 // Errors with predefined static messages
@@ -87,14 +102,18 @@ void OnFatalError(const char* location, const char* message);
 #define PREDEFINED_ERROR_MESSAGES(V)                                           \
   V(ERR_BUFFER_CONTEXT_NOT_AVAILABLE,                                          \
     "Buffer is not available for the current Context")                         \
+  V(ERR_CLOSED_MESSAGE_PORT, "Cannot send data on closed MessagePort")         \
   V(ERR_CONSTRUCT_CALL_INVALID, "Constructor cannot be called")                \
   V(ERR_CONSTRUCT_CALL_REQUIRED, "Cannot call constructor without `new`")      \
   V(ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH,                                       \
     "Input buffers must have the same byte length")                            \
   V(ERR_CRYPTO_UNKNOWN_CIPHER, "Unknown cipher")                               \
   V(ERR_CRYPTO_UNKNOWN_DH_GROUP, "Unknown DH group")                           \
+  V(ERR_DLOPEN_FAILED, "DLOpen failed")                                        \
   V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE,                                   \
     "Context not associated with Node.js environment")                         \
+  V(ERR_INVALID_ADDRESS, "Invalid socket address")                             \
+  V(ERR_INVALID_MODULE, "No such module")                                      \
   V(ERR_INVALID_THIS, "Value of \"this\" is the wrong type")                   \
   V(ERR_INVALID_TRANSFER_OBJECT, "Found invalid object in transferList")       \
   V(ERR_MEMORY_ALLOCATION_FAILED, "Failed to allocate memory")                 \
@@ -112,8 +131,6 @@ void OnFatalError(const char* location, const char* message);
     "Loading non context-aware native modules has been disabled")              \
   V(ERR_SCRIPT_EXECUTION_INTERRUPTED,                                          \
     "Script execution was interrupted by `SIGINT`")                            \
-  V(ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER,                           \
-    "Cannot serialize externalized SharedArrayBuffer")                         \
   V(ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED, "Failed to set PSK identity hint")    \
   V(ERR_WASI_NOT_STARTED, "wasi.start() has not been called")                  \
   V(ERR_WORKER_INIT_FAILED, "Worker initialization failure")                   \
diff --git a/src/node_file-inl.h b/src/node_file-inl.h
index 1d58eeb9a7662e47051fa10dc2d807d5eb5b4d9f..0188261b7dcbb486bdecccf4fb760275e030c44f 100644
--- a/src/node_file-inl.h
+++ b/src/node_file-inl.h
@@ -39,11 +39,13 @@ void FSContinuationData::Done(int result) {
   done_cb_(req_);
 }
 
-FSReqBase::FSReqBase(Environment* env,
-          v8::Local<v8::Object> req,
-          AsyncWrap::ProviderType type,
-          bool use_bigint)
-  : ReqWrap(env, req, type), use_bigint_(use_bigint) {
+FSReqBase::FSReqBase(BindingData* binding_data,
+                     v8::Local<v8::Object> req,
+                     AsyncWrap::ProviderType type,
+                     bool use_bigint)
+  : ReqWrap(binding_data->env(), req, type),
+    use_bigint_(use_bigint),
+    binding_data_(binding_data) {
 }
 
 void FSReqBase::Init(const char* syscall,
@@ -72,9 +74,13 @@ FSReqBase::Init(const char* syscall, size_t len, enum encoding encoding) {
   return buffer_;
 }
 
-FSReqCallback::FSReqCallback(Environment* env,
-                             v8::Local<v8::Object> req, bool use_bigint)
-  : FSReqBase(env, req, AsyncWrap::PROVIDER_FSREQCALLBACK, use_bigint) {}
+FSReqCallback::FSReqCallback(BindingData* binding_data,
+                             v8::Local<v8::Object> req,
+                             bool use_bigint)
+  : FSReqBase(binding_data,
+              req,
+              AsyncWrap::PROVIDER_FSREQCALLBACK,
+              use_bigint) {}
 
 template <typename NativeT, typename V8T>
 void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
@@ -112,18 +118,18 @@ void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
 #undef SET_FIELD_WITH_STAT
 }
 
-v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
+v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
                                           const bool use_bigint,
                                           const uv_stat_t* s,
                                           const bool second) {
   const ptrdiff_t offset =
       second ? static_cast<ptrdiff_t>(FsStatsOffset::kFsStatsFieldsNumber) : 0;
   if (use_bigint) {
-    auto* const arr = env->fs_stats_field_bigint_array();
+    auto* const arr = &binding_data->stats_field_bigint_array;
     FillStatsArray(arr, s, offset);
     return arr->GetJSArray();
   } else {
-    auto* const arr = env->fs_stats_field_array();
+    auto* const arr = &binding_data->stats_field_array;
     FillStatsArray(arr, s, offset);
     return arr->GetJSArray();
   }
@@ -131,7 +137,9 @@ v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
 
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>*
-FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {
+FSReqPromise<AliasedBufferT>::New(BindingData* binding_data,
+                                  bool use_bigint) {
+  Environment* env = binding_data->env();
   v8::Local<v8::Object> obj;
   if (!env->fsreqpromise_constructor_template()
            ->NewInstance(env->context())
@@ -143,7 +151,7 @@ FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {
       obj->Set(env->context(), env->promise_string(), resolver).IsNothing()) {
     return nullptr;
   }
-  return new FSReqPromise(env, obj, use_bigint);
+  return new FSReqPromise(binding_data, obj, use_bigint);
 }
 
 template <typename AliasedBufferT>
@@ -154,12 +162,15 @@ FSReqPromise<AliasedBufferT>::~FSReqPromise() {
 
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>::FSReqPromise(
-    Environment* env,
+    BindingData* binding_data,
     v8::Local<v8::Object> obj,
     bool use_bigint)
-  : FSReqBase(env, obj, AsyncWrap::PROVIDER_FSREQPROMISE, use_bigint),
+  : FSReqBase(binding_data,
+              obj,
+              AsyncWrap::PROVIDER_FSREQPROMISE,
+              use_bigint),
     stats_field_array_(
-        env->isolate(),
+        env()->isolate(),
         static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
 
 template <typename AliasedBufferT>
@@ -208,15 +219,21 @@ void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("stats_field_array", stats_field_array_);
 }
 
-FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,
+FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
+                      int index,
                       bool use_bigint) {
+  v8::Local<v8::Value> value = args[index];
   if (value->IsObject()) {
     return Unwrap<FSReqBase>(value.As<v8::Object>());
-  } else if (value->StrictEquals(env->fs_use_promises_symbol())) {
+  }
+
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  Environment* env = binding_data->env();
+  if (value->StrictEquals(env->fs_use_promises_symbol())) {
     if (use_bigint) {
-      return FSReqPromise<AliasedBigUint64Array>::New(env, use_bigint);
+      return FSReqPromise<AliasedBigUint64Array>::New(binding_data, use_bigint);
     } else {
-      return FSReqPromise<AliasedFloat64Array>::New(env, use_bigint);
+      return FSReqPromise<AliasedFloat64Array>::New(binding_data, use_bigint);
     }
   }
   return nullptr;
diff --git a/src/node_file.cc b/src/node_file.cc
index 968cf6f27c4f7445d0d54f04a43b9fd9b1533e19..118796a48df7c80e8e572de65030f1c8d4d5586d 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -23,7 +23,7 @@
 #include "aliased_buffer.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "node_stat_watcher.h"
 #include "util-inl.h"
 
@@ -51,6 +51,7 @@ namespace node {
 namespace fs {
 
 using v8::Array;
+using v8::BigInt;
 using v8::Boolean;
 using v8::Context;
 using v8::EscapableHandleScope;
@@ -69,7 +70,6 @@ using v8::ObjectTemplate;
 using v8::Promise;
 using v8::String;
 using v8::Symbol;
-using v8::Uint32;
 using v8::Undefined;
 using v8::Value;
 
@@ -84,23 +84,30 @@ const char* const kPathSeparator = "\\/";
 #endif
 
 std::string Basename(const std::string& str, const std::string& extension) {
-  std::string ret = str;
-
   // Remove everything leading up to and including the final path separator.
-  std::string::size_type pos = ret.find_last_of(kPathSeparator);
-  if (pos != std::string::npos) ret = ret.substr(pos + 1);
+  std::string::size_type pos = str.find_last_of(kPathSeparator);
+
+  // Starting index for the resulting string
+  std::size_t start_pos = 0;
+  // String size to return
+  std::size_t str_size = str.size();
+  if (pos != std::string::npos) {
+    start_pos = pos + 1;
+    str_size -= start_pos;
+  }
 
   // Strip away the extension, if any.
-  if (ret.size() >= extension.size() &&
-      ret.substr(ret.size() - extension.size()) == extension) {
-    ret = ret.substr(0, ret.size() - extension.size());
+  if (str_size >= extension.size() &&
+      str.compare(str.size() - extension.size(),
+        extension.size(), extension) == 0) {
+    str_size -= extension.size();
   }
 
-  return ret;
+  return str.substr(start_pos, str_size);
 }
 
 inline int64_t GetOffset(Local<Value> value) {
-  return value->IsNumber() ? value.As<Integer>()->Value() : -1;
+  return IsSafeJsInt(value) ? value.As<Integer>()->Value() : -1;
 }
 
 #define TRACE_NAME(name) "fs.sync." #name
@@ -137,30 +144,35 @@ void FSReqBase::MemoryInfo(MemoryTracker* tracker) const {
 // The FileHandle object wraps a file descriptor and will close it on garbage
 // collection if necessary. If that happens, a process warning will be
 // emitted (or a fatal exception will occur if the fd cannot be closed.)
-FileHandle::FileHandle(Environment* env, Local<Object> obj, int fd)
-    : AsyncWrap(env, obj, AsyncWrap::PROVIDER_FILEHANDLE),
-      StreamBase(env),
-      fd_(fd) {
+FileHandle::FileHandle(BindingData* binding_data,
+                       Local<Object> obj, int fd)
+    : AsyncWrap(binding_data->env(), obj, AsyncWrap::PROVIDER_FILEHANDLE),
+      StreamBase(env()),
+      fd_(fd),
+      binding_data_(binding_data) {
   MakeWeak();
   StreamBase::AttachToObject(GetObject());
 }
 
-FileHandle* FileHandle::New(Environment* env, int fd, Local<Object> obj) {
+FileHandle* FileHandle::New(BindingData* binding_data,
+                            int fd, Local<Object> obj) {
+  Environment* env = binding_data->env();
   if (obj.IsEmpty() && !env->fd_constructor_template()
                             ->NewInstance(env->context())
                             .ToLocal(&obj)) {
     return nullptr;
   }
-  return new FileHandle(env, obj, fd);
+  return new FileHandle(binding_data, obj, fd);
 }
 
 void FileHandle::New(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  Environment* env = binding_data->env();
   CHECK(args.IsConstructCall());
   CHECK(args[0]->IsInt32());
 
   FileHandle* handle =
-      FileHandle::New(env, args[0].As<Int32>()->Value(), args.This());
+      FileHandle::New(binding_data, args[0].As<Int32>()->Value(), args.This());
   if (handle == nullptr) return;
   if (args[1]->IsNumber())
     handle->read_offset_ = args[1]->IntegerValue(env->context()).FromJust();
@@ -194,7 +206,7 @@ std::unique_ptr<worker::TransferData> FileHandle::TransferForMessaging() {
   CHECK_NE(GetTransferMode(), TransferMode::kUntransferable);
   auto ret = std::make_unique<TransferData>(fd_);
   closed_ = true;
-  return std::move(ret);
+  return ret;
 }
 
 FileHandle::TransferData::TransferData(int fd) : fd_(fd) {}
@@ -208,15 +220,15 @@ FileHandle::TransferData::~TransferData() {
 }
 
 BaseObjectPtr<BaseObject> FileHandle::TransferData::Deserialize(
-    Environment* env_,
+    Environment* env,
     v8::Local<v8::Context> context,
     std::unique_ptr<worker::TransferData> self) {
-  Environment* env = Environment::GetCurrent(context);
-  if (env == nullptr) return {};
+  BindingData* bd = Environment::GetBindingData<BindingData>(context);
+  if (bd == nullptr) return {};
 
   int fd = fd_;
   fd_ = -1;
-  return BaseObjectPtr<BaseObject> { FileHandle::New(env, fd) };
+  return BaseObjectPtr<BaseObject> { FileHandle::New(bd, fd) };
 }
 
 // Close the file descriptor if it hasn't already been closed. A process
@@ -260,12 +272,23 @@ inline void FileHandle::Close() {
     ProcessEmitWarning(env,
                        "Closing file descriptor %d on garbage collection",
                        detail.fd);
+    if (env->filehandle_close_warning()) {
+      env->set_filehandle_close_warning(false);
+      ProcessEmitDeprecationWarning(
+          env,
+          "Closing a FileHandle object on garbage collection is deprecated. "
+          "Please close FileHandle objects explicitly using "
+          "FileHandle.prototype.close(). In the future, an error will be "
+          "thrown if a file descriptor is closed during garbage collection.",
+          "DEP0137").IsNothing();
+    }
   }, CallbackFlags::kUnrefed);
 }
 
 void FileHandle::CloseReq::Resolve() {
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
+  Context::Scope context_scope(env()->context());
   InternalCallbackScope callback_scope(this);
   Local<Promise> promise = promise_.Get(isolate);
   Local<Promise::Resolver> resolver = promise.As<Promise::Resolver>();
@@ -275,6 +298,7 @@ void FileHandle::CloseReq::Resolve() {
 void FileHandle::CloseReq::Reject(Local<Value> reason) {
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
+  Context::Scope context_scope(env()->context());
   InternalCallbackScope callback_scope(this);
   Local<Promise> promise = promise_.Get(isolate);
   Local<Promise::Resolver> resolver = promise.As<Promise::Resolver>();
@@ -403,7 +427,7 @@ int FileHandle::ReadStart() {
   if (current_read_)
     return 0;
 
-  std::unique_ptr<FileHandleReadWrap> read_wrap;
+  BaseObjectPtr<FileHandleReadWrap> read_wrap;
 
   if (read_length_ == 0) {
     EmitRead(UV_EOF);
@@ -417,7 +441,7 @@ int FileHandle::ReadStart() {
     HandleScope handle_scope(env()->isolate());
     AsyncHooks::DefaultTriggerAsyncIdScope trigger_scope(this);
 
-    auto& freelist = env()->file_handle_read_wrap_freelist();
+    auto& freelist = binding_data_->file_handle_read_wrap_freelist;
     if (freelist.size() > 0) {
       read_wrap = std::move(freelist.back());
       freelist.pop_back();
@@ -436,7 +460,7 @@ int FileHandle::ReadStart() {
                .ToLocal(&wrap_obj)) {
         return UV_EBUSY;
       }
-      read_wrap = std::make_unique<FileHandleReadWrap>(this, wrap_obj);
+      read_wrap = MakeDetachedBaseObject<FileHandleReadWrap>(this, wrap_obj);
     }
   }
   int64_t recommended_read = 65536;
@@ -463,7 +487,7 @@ int FileHandle::ReadStart() {
     // ReadStart() checks whether current_read_ is set to determine whether
     // a read is in progress. Moving it into a local variable makes sure that
     // the ReadStart() call below doesn't think we're still actively reading.
-    std::unique_ptr<FileHandleReadWrap> read_wrap =
+    BaseObjectPtr<FileHandleReadWrap> read_wrap =
         std::move(handle->current_read_);
 
     int result = req->result;
@@ -474,7 +498,7 @@ int FileHandle::ReadStart() {
     // Push the read wrap back to the freelist, or let it be destroyed
     // once we’re exiting the current scope.
     constexpr size_t kWantedFreelistFill = 100;
-    auto& freelist = handle->env()->file_handle_read_wrap_freelist();
+    auto& freelist = handle->binding_data_->file_handle_read_wrap_freelist;
     if (freelist.size() < kWantedFreelistFill) {
       read_wrap->Reset();
       freelist.emplace_back(std::move(read_wrap));
@@ -544,7 +568,7 @@ void FSReqCallback::Reject(Local<Value> reject) {
 }
 
 void FSReqCallback::ResolveStat(const uv_stat_t* stat) {
-  Resolve(FillGlobalStatsArray(env(), use_bigint(), stat));
+  Resolve(FillGlobalStatsArray(binding_data(), use_bigint(), stat));
 }
 
 void FSReqCallback::Resolve(Local<Value> value) {
@@ -563,8 +587,8 @@ void FSReqCallback::SetReturnValue(const FunctionCallbackInfo<Value>& args) {
 
 void NewFSReqCallback(const FunctionCallbackInfo<Value>& args) {
   CHECK(args.IsConstructCall());
-  Environment* env = Environment::GetCurrent(args);
-  new FSReqCallback(env, args.This(), args[0]->IsTrue());
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  new FSReqCallback(binding_data, args.This(), args[0]->IsTrue());
 }
 
 FSReqAfterScope::FSReqAfterScope(FSReqBase* wrap, uv_fs_t* req)
@@ -650,7 +674,7 @@ void AfterOpenFileHandle(uv_fs_t* req) {
   FSReqAfterScope after(req_wrap, req);
 
   if (after.Proceed()) {
-    FileHandle* fd = FileHandle::New(req_wrap->env(), req->result);
+    FileHandle* fd = FileHandle::New(req_wrap->binding_data(), req->result);
     if (fd == nullptr) return;
     req_wrap->Resolve(fd->object());
   }
@@ -828,7 +852,7 @@ void Access(const FunctionCallbackInfo<Value>& args) {
   BufferValue path(isolate, args[0]);
   CHECK_NOT_NULL(*path);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // access(path, mode, req)
     AsyncCall(env, req_wrap_async, args, "access", UTF8, AfterNoArgs,
               uv_fs_access, *path, mode);
@@ -852,7 +876,7 @@ void Close(const FunctionCallbackInfo<Value>& args) {
   int fd = args[0].As<Int32>()->Value();
   env->RemoveUnmanagedFd(fd);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[1]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 1);
   if (req_wrap_async != nullptr) {  // close(fd, req)
     AsyncCall(env, req_wrap_async, args, "close", UTF8, AfterNoArgs,
               uv_fs_close, fd);
@@ -983,7 +1007,8 @@ static void InternalModuleStat(const FunctionCallbackInfo<Value>& args) {
 }
 
 static void Stat(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  Environment* env = binding_data->env();
 
   const int argc = args.Length();
   CHECK_GE(argc, 2);
@@ -992,7 +1017,7 @@ static void Stat(const FunctionCallbackInfo<Value>& args) {
   CHECK_NOT_NULL(*path);
 
   bool use_bigint = args[1]->IsTrue();
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2], use_bigint);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2, use_bigint);
   if (req_wrap_async != nullptr) {  // stat(path, use_bigint, req)
     AsyncCall(env, req_wrap_async, args, "stat", UTF8, AfterStat,
               uv_fs_stat, *path);
@@ -1006,14 +1031,15 @@ static void Stat(const FunctionCallbackInfo<Value>& args) {
       return;  // error info is in ctx
     }
 
-    Local<Value> arr = FillGlobalStatsArray(env, use_bigint,
+    Local<Value> arr = FillGlobalStatsArray(binding_data, use_bigint,
         static_cast<const uv_stat_t*>(req_wrap_sync.req.ptr));
     args.GetReturnValue().Set(arr);
   }
 }
 
 static void LStat(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  Environment* env = binding_data->env();
 
   const int argc = args.Length();
   CHECK_GE(argc, 3);
@@ -1022,7 +1048,7 @@ static void LStat(const FunctionCallbackInfo<Value>& args) {
   CHECK_NOT_NULL(*path);
 
   bool use_bigint = args[1]->IsTrue();
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2], use_bigint);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2, use_bigint);
   if (req_wrap_async != nullptr) {  // lstat(path, use_bigint, req)
     AsyncCall(env, req_wrap_async, args, "lstat", UTF8, AfterStat,
               uv_fs_lstat, *path);
@@ -1037,14 +1063,15 @@ static void LStat(const FunctionCallbackInfo<Value>& args) {
       return;  // error info is in ctx
     }
 
-    Local<Value> arr = FillGlobalStatsArray(env, use_bigint,
+    Local<Value> arr = FillGlobalStatsArray(binding_data, use_bigint,
         static_cast<const uv_stat_t*>(req_wrap_sync.req.ptr));
     args.GetReturnValue().Set(arr);
   }
 }
 
 static void FStat(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  Environment* env = binding_data->env();
 
   const int argc = args.Length();
   CHECK_GE(argc, 2);
@@ -1053,7 +1080,7 @@ static void FStat(const FunctionCallbackInfo<Value>& args) {
   int fd = args[0].As<Int32>()->Value();
 
   bool use_bigint = args[1]->IsTrue();
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2], use_bigint);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2, use_bigint);
   if (req_wrap_async != nullptr) {  // fstat(fd, use_bigint, req)
     AsyncCall(env, req_wrap_async, args, "fstat", UTF8, AfterStat,
               uv_fs_fstat, fd);
@@ -1067,7 +1094,7 @@ static void FStat(const FunctionCallbackInfo<Value>& args) {
       return;  // error info is in ctx
     }
 
-    Local<Value> arr = FillGlobalStatsArray(env, use_bigint,
+    Local<Value> arr = FillGlobalStatsArray(binding_data, use_bigint,
         static_cast<const uv_stat_t*>(req_wrap_sync.req.ptr));
     args.GetReturnValue().Set(arr);
   }
@@ -1088,7 +1115,7 @@ static void Symlink(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[2]->IsInt32());
   int flags = args[2].As<Int32>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // symlink(target, path, flags, req)
     AsyncDestCall(env, req_wrap_async, args, "symlink", *path, path.length(),
                   UTF8, AfterNoArgs, uv_fs_symlink, *target, *path, flags);
@@ -1115,7 +1142,7 @@ static void Link(const FunctionCallbackInfo<Value>& args) {
   BufferValue dest(isolate, args[1]);
   CHECK_NOT_NULL(*dest);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // link(src, dest, req)
     AsyncDestCall(env, req_wrap_async, args, "link", *dest, dest.length(), UTF8,
                   AfterNoArgs, uv_fs_link, *src, *dest);
@@ -1141,7 +1168,7 @@ static void ReadLink(const FunctionCallbackInfo<Value>& args) {
 
   const enum encoding encoding = ParseEncoding(isolate, args[1], UTF8);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // readlink(path, encoding, req)
     AsyncCall(env, req_wrap_async, args, "readlink", encoding, AfterStringPtr,
               uv_fs_readlink, *path);
@@ -1184,7 +1211,7 @@ static void Rename(const FunctionCallbackInfo<Value>& args) {
   BufferValue new_path(isolate, args[1]);
   CHECK_NOT_NULL(*new_path);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {
     AsyncDestCall(env, req_wrap_async, args, "rename", *new_path,
                   new_path.length(), UTF8, AfterNoArgs, uv_fs_rename,
@@ -1208,10 +1235,10 @@ static void FTruncate(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsInt32());
   const int fd = args[0].As<Int32>()->Value();
 
-  CHECK(args[1]->IsNumber());
+  CHECK(IsSafeJsInt(args[1]));
   const int64_t len = args[1].As<Integer>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {
     AsyncCall(env, req_wrap_async, args, "ftruncate", UTF8, AfterNoArgs,
               uv_fs_ftruncate, fd, len);
@@ -1234,7 +1261,7 @@ static void Fdatasync(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsInt32());
   const int fd = args[0].As<Int32>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[1]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 1);
   if (req_wrap_async != nullptr) {
     AsyncCall(env, req_wrap_async, args, "fdatasync", UTF8, AfterNoArgs,
               uv_fs_fdatasync, fd);
@@ -1256,7 +1283,7 @@ static void Fsync(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsInt32());
   const int fd = args[0].As<Int32>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[1]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 1);
   if (req_wrap_async != nullptr) {
     AsyncCall(env, req_wrap_async, args, "fsync", UTF8, AfterNoArgs,
               uv_fs_fsync, fd);
@@ -1278,7 +1305,7 @@ static void Unlink(const FunctionCallbackInfo<Value>& args) {
   BufferValue path(env->isolate(), args[0]);
   CHECK_NOT_NULL(*path);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[1]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 1);
   if (req_wrap_async != nullptr) {
     AsyncCall(env, req_wrap_async, args, "unlink", UTF8, AfterNoArgs,
               uv_fs_unlink, *path);
@@ -1300,7 +1327,7 @@ static void RMDir(const FunctionCallbackInfo<Value>& args) {
   BufferValue path(env->isolate(), args[0]);
   CHECK_NOT_NULL(*path);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[1]);  // rmdir(path, req)
+  FSReqBase* req_wrap_async = GetReqWrap(args, 1);  // rmdir(path, req)
   if (req_wrap_async != nullptr) {
     AsyncCall(env, req_wrap_async, args, "rmdir", UTF8, AfterNoArgs,
               uv_fs_rmdir, *path);
@@ -1510,7 +1537,7 @@ static void MKDir(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[2]->IsBoolean());
   bool mkdirp = args[2]->IsTrue();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // mkdir(path, mode, req)
     AsyncCall(env, req_wrap_async, args, "mkdir", UTF8,
               mkdirp ? AfterMkdirp : AfterNoArgs,
@@ -1556,7 +1583,7 @@ static void RealPath(const FunctionCallbackInfo<Value>& args) {
 
   const enum encoding encoding = ParseEncoding(isolate, args[1], UTF8);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // realpath(path, encoding, req)
     AsyncCall(env, req_wrap_async, args, "realpath", encoding, AfterStringPtr,
               uv_fs_realpath, *path);
@@ -1602,7 +1629,7 @@ static void ReadDir(const FunctionCallbackInfo<Value>& args) {
 
   bool with_types = args[2]->IsTrue();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // readdir(path, encoding, withTypes, req)
     if (with_types) {
       AsyncCall(env, req_wrap_async, args, "scandir", encoding,
@@ -1690,7 +1717,7 @@ static void Open(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[2]->IsInt32());
   const int mode = args[2].As<Int32>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // open(path, flags, mode, req)
     req_wrap_async->set_is_plain_open(true);
     AsyncCall(env, req_wrap_async, args, "open", UTF8, AfterInteger,
@@ -1708,7 +1735,8 @@ static void Open(const FunctionCallbackInfo<Value>& args) {
 }
 
 static void OpenFileHandle(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  Environment* env = binding_data->env();
   Isolate* isolate = env->isolate();
 
   const int argc = args.Length();
@@ -1723,7 +1751,7 @@ static void OpenFileHandle(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[2]->IsInt32());
   const int mode = args[2].As<Int32>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // openFileHandle(path, flags, mode, req)
     AsyncCall(env, req_wrap_async, args, "open", UTF8, AfterOpenFileHandle,
               uv_fs_open, *path, flags, mode);
@@ -1737,7 +1765,7 @@ static void OpenFileHandle(const FunctionCallbackInfo<Value>& args) {
     if (result < 0) {
       return;  // syscall failed, no need to continue, error info is in ctx
     }
-    FileHandle* fd = FileHandle::New(env, result);
+    FileHandle* fd = FileHandle::New(binding_data, result);
     if (fd == nullptr) return;
     args.GetReturnValue().Set(fd->object());
   }
@@ -1759,7 +1787,7 @@ static void CopyFile(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[2]->IsInt32());
   const int flags = args[2].As<Int32>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // copyFile(src, dest, flags, req)
     AsyncDestCall(env, req_wrap_async, args, "copyfile",
                   *dest, dest.length(), UTF8, AfterNoArgs,
@@ -1798,9 +1826,11 @@ static void WriteBuffer(const FunctionCallbackInfo<Value>& args) {
   char* buffer_data = Buffer::Data(buffer_obj);
   size_t buffer_length = Buffer::Length(buffer_obj);
 
-  CHECK(args[2]->IsInt32());
-  const size_t off = static_cast<size_t>(args[2].As<Int32>()->Value());
-  CHECK_LE(off, buffer_length);
+  CHECK(IsSafeJsInt(args[2]));
+  const int64_t off_64 = args[2].As<Integer>()->Value();
+  CHECK_GE(off_64, 0);
+  CHECK_LE(static_cast<uint64_t>(off_64), buffer_length);
+  const size_t off = static_cast<size_t>(off_64);
 
   CHECK(args[3]->IsInt32());
   const size_t len = static_cast<size_t>(args[3].As<Int32>()->Value());
@@ -1813,7 +1843,7 @@ static void WriteBuffer(const FunctionCallbackInfo<Value>& args) {
   char* buf = buffer_data + off;
   uv_buf_t uvbuf = uv_buf_init(buf, len);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[5]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 5);
   if (req_wrap_async != nullptr) {  // write(fd, buffer, off, len, pos, req)
     AsyncCall(env, req_wrap_async, args, "write", UTF8, AfterInteger,
               uv_fs_write, fd, &uvbuf, 1, pos);
@@ -1858,7 +1888,7 @@ static void WriteBuffers(const FunctionCallbackInfo<Value>& args) {
     iovs[i] = uv_buf_init(Buffer::Data(chunk), Buffer::Length(chunk));
   }
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // writeBuffers(fd, chunks, pos, req)
     AsyncCall(env, req_wrap_async, args, "write", UTF8, AfterInteger,
               uv_fs_write, fd, *iovs, iovs.length(), pos);
@@ -1900,7 +1930,7 @@ static void WriteString(const FunctionCallbackInfo<Value>& args) {
   char* buf = nullptr;
   size_t len;
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[4]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 4);
   const bool is_async = req_wrap_async != nullptr;
 
   // Avoid copying the string when it is externalized but only when:
@@ -1980,7 +2010,7 @@ static void WriteString(const FunctionCallbackInfo<Value>& args) {
  *
  * 0 fd        int32. file descriptor
  * 1 buffer    instance of Buffer
- * 2 offset    int32. offset to start reading into inside buffer
+ * 2 offset    int64. offset to start reading into inside buffer
  * 3 length    int32. length to read
  * 4 position  int64. file position - -1 for current position
  */
@@ -1998,21 +2028,25 @@ static void Read(const FunctionCallbackInfo<Value>& args) {
   char* buffer_data = Buffer::Data(buffer_obj);
   size_t buffer_length = Buffer::Length(buffer_obj);
 
-  CHECK(args[2]->IsInt32());
-  const size_t off = static_cast<size_t>(args[2].As<Int32>()->Value());
-  CHECK_LT(off, buffer_length);
+  CHECK(IsSafeJsInt(args[2]));
+  const int64_t off_64 = args[2].As<Integer>()->Value();
+  CHECK_GE(off_64, 0);
+  CHECK_LT(static_cast<uint64_t>(off_64), buffer_length);
+  const size_t off = static_cast<size_t>(off_64);
 
   CHECK(args[3]->IsInt32());
   const size_t len = static_cast<size_t>(args[3].As<Int32>()->Value());
   CHECK(Buffer::IsWithinBounds(off, len, buffer_length));
 
-  CHECK(args[4]->IsNumber());
-  const int64_t pos = args[4].As<Integer>()->Value();
+  CHECK(IsSafeJsInt(args[4]) || args[4]->IsBigInt());
+  const int64_t pos = args[4]->IsNumber() ?
+                      args[4].As<Integer>()->Value() :
+                      args[4].As<BigInt>()->Int64Value();
 
   char* buf = buffer_data + off;
   uv_buf_t uvbuf = uv_buf_init(buf, len);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[5]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 5);
   if (req_wrap_async != nullptr) {  // read(fd, buffer, offset, len, pos, req)
     AsyncCall(env, req_wrap_async, args, "read", UTF8, AfterInteger,
               uv_fs_read, fd, &uvbuf, 1, pos);
@@ -2058,7 +2092,7 @@ static void ReadBuffers(const FunctionCallbackInfo<Value>& args) {
     iovs[i] = uv_buf_init(Buffer::Data(buffer), Buffer::Length(buffer));
   }
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // readBuffers(fd, buffers, pos, req)
     AsyncCall(env, req_wrap_async, args, "read", UTF8, AfterInteger,
               uv_fs_read, fd, *iovs, iovs.length(), pos);
@@ -2089,7 +2123,7 @@ static void Chmod(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[1]->IsInt32());
   int mode = args[1].As<Int32>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // chmod(path, mode, req)
     AsyncCall(env, req_wrap_async, args, "chmod", UTF8, AfterNoArgs,
               uv_fs_chmod, *path, mode);
@@ -2119,7 +2153,7 @@ static void FChmod(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[1]->IsInt32());
   const int mode = args[1].As<Int32>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // fchmod(fd, mode, req)
     AsyncCall(env, req_wrap_async, args, "fchmod", UTF8, AfterNoArgs,
               uv_fs_fchmod, fd, mode);
@@ -2146,13 +2180,13 @@ static void Chown(const FunctionCallbackInfo<Value>& args) {
   BufferValue path(env->isolate(), args[0]);
   CHECK_NOT_NULL(*path);
 
-  CHECK(args[1]->IsUint32());
-  const uv_uid_t uid = static_cast<uv_uid_t>(args[1].As<Uint32>()->Value());
+  CHECK(IsSafeJsInt(args[1]));
+  const uv_uid_t uid = static_cast<uv_uid_t>(args[1].As<Integer>()->Value());
 
-  CHECK(args[2]->IsUint32());
-  const uv_gid_t gid = static_cast<uv_gid_t>(args[2].As<Uint32>()->Value());
+  CHECK(IsSafeJsInt(args[2]));
+  const uv_gid_t gid = static_cast<uv_gid_t>(args[2].As<Integer>()->Value());
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // chown(path, uid, gid, req)
     AsyncCall(env, req_wrap_async, args, "chown", UTF8, AfterNoArgs,
               uv_fs_chown, *path, uid, gid);
@@ -2179,13 +2213,13 @@ static void FChown(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsInt32());
   const int fd = args[0].As<Int32>()->Value();
 
-  CHECK(args[1]->IsUint32());
-  const uv_uid_t uid = static_cast<uv_uid_t>(args[1].As<Uint32>()->Value());
+  CHECK(IsSafeJsInt(args[1]));
+  const uv_uid_t uid = static_cast<uv_uid_t>(args[1].As<Integer>()->Value());
 
-  CHECK(args[2]->IsUint32());
-  const uv_gid_t gid = static_cast<uv_gid_t>(args[2].As<Uint32>()->Value());
+  CHECK(IsSafeJsInt(args[2]));
+  const uv_gid_t gid = static_cast<uv_gid_t>(args[2].As<Integer>()->Value());
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // fchown(fd, uid, gid, req)
     AsyncCall(env, req_wrap_async, args, "fchown", UTF8, AfterNoArgs,
               uv_fs_fchown, fd, uid, gid);
@@ -2209,13 +2243,13 @@ static void LChown(const FunctionCallbackInfo<Value>& args) {
   BufferValue path(env->isolate(), args[0]);
   CHECK_NOT_NULL(*path);
 
-  CHECK(args[1]->IsUint32());
-  const uv_uid_t uid = static_cast<uv_uid_t>(args[1].As<Uint32>()->Value());
+  CHECK(IsSafeJsInt(args[1]));
+  const uv_uid_t uid = static_cast<uv_uid_t>(args[1].As<Integer>()->Value());
 
-  CHECK(args[2]->IsUint32());
-  const uv_gid_t gid = static_cast<uv_gid_t>(args[2].As<Uint32>()->Value());
+  CHECK(IsSafeJsInt(args[2]));
+  const uv_gid_t gid = static_cast<uv_gid_t>(args[2].As<Integer>()->Value());
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // lchown(path, uid, gid, req)
     AsyncCall(env, req_wrap_async, args, "lchown", UTF8, AfterNoArgs,
               uv_fs_lchown, *path, uid, gid);
@@ -2245,7 +2279,7 @@ static void UTimes(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[2]->IsNumber());
   const double mtime = args[2].As<Number>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // utimes(path, atime, mtime, req)
     AsyncCall(env, req_wrap_async, args, "utime", UTF8, AfterNoArgs,
               uv_fs_utime, *path, atime, mtime);
@@ -2274,7 +2308,7 @@ static void FUTimes(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[2]->IsNumber());
   const double mtime = args[2].As<Number>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // futimes(fd, atime, mtime, req)
     AsyncCall(env, req_wrap_async, args, "futime", UTF8, AfterNoArgs,
               uv_fs_futime, fd, atime, mtime);
@@ -2303,7 +2337,7 @@ static void LUTimes(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[2]->IsNumber());
   const double mtime = args[2].As<Number>()->Value();
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 3);
   if (req_wrap_async != nullptr) {  // lutimes(path, atime, mtime, req)
     AsyncCall(env, req_wrap_async, args, "lutime", UTF8, AfterNoArgs,
               uv_fs_lutime, *path, atime, mtime);
@@ -2329,7 +2363,7 @@ static void Mkdtemp(const FunctionCallbackInfo<Value>& args) {
 
   const enum encoding encoding = ParseEncoding(isolate, args[1], UTF8);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+  FSReqBase* req_wrap_async = GetReqWrap(args, 2);
   if (req_wrap_async != nullptr) {  // mkdtemp(tmpl, encoding, req)
     AsyncCall(env, req_wrap_async, args, "mkdtemp", encoding, AfterStringPath,
               uv_fs_mkdtemp, *tmpl);
@@ -2354,12 +2388,25 @@ static void Mkdtemp(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+void BindingData::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("stats_field_array", stats_field_array);
+  tracker->TrackField("stats_field_bigint_array", stats_field_bigint_array);
+  tracker->TrackField("file_handle_read_wrap_freelist",
+                      file_handle_read_wrap_freelist);
+}
+
+// TODO(addaleax): Remove once we're on C++17.
+constexpr FastStringKey BindingData::type_name;
+
 void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context,
                 void* priv) {
   Environment* env = Environment::GetCurrent(context);
   Isolate* isolate = env->isolate();
+  BindingData* const binding_data =
+      env->AddBindingData<BindingData>(context, target);
+  if (binding_data == nullptr) return;
 
   env->SetMethod(target, "access", Access);
   env->SetMethod(target, "close", Close);
@@ -2391,7 +2438,6 @@ void Initialize(Local<Object> target,
 
   env->SetMethod(target, "chmod", Chmod);
   env->SetMethod(target, "fchmod", FChmod);
-  // env->SetMethod(target, "lchmod", LChmod);
 
   env->SetMethod(target, "chown", Chown);
   env->SetMethod(target, "fchown", FChown);
@@ -2413,11 +2459,11 @@ void Initialize(Local<Object> target,
 
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "statValues"),
-              env->fs_stats_field_array()->GetJSArray()).Check();
+              binding_data->stats_field_array.GetJSArray()).Check();
 
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "bigintStatValues"),
-              env->fs_stats_field_bigint_array()->GetJSArray()).Check();
+              binding_data->stats_field_bigint_array.GetJSArray()).Check();
 
   StatWatcher::Initialize(env, target);
 
@@ -2426,13 +2472,7 @@ void Initialize(Local<Object> target,
   fst->InstanceTemplate()->SetInternalFieldCount(
       FSReqBase::kInternalFieldCount);
   fst->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  Local<String> wrapString =
-      FIXED_ONE_BYTE_STRING(isolate, "FSReqCallback");
-  fst->SetClassName(wrapString);
-  target
-      ->Set(context, wrapString,
-            fst->GetFunction(env->context()).ToLocalChecked())
-      .Check();
+  env->SetConstructorFunction(target, "FSReqCallback", fst);
 
   // Create FunctionTemplate for FileHandleReadWrap. There’s no need
   // to do anything in the constructor, so we only store the instance template.
@@ -2463,14 +2503,8 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(fd, "releaseFD", FileHandle::ReleaseFD);
   Local<ObjectTemplate> fdt = fd->InstanceTemplate();
   fdt->SetInternalFieldCount(StreamBase::kInternalFieldCount);
-  Local<String> handleString =
-       FIXED_ONE_BYTE_STRING(isolate, "FileHandle");
-  fd->SetClassName(handleString);
   StreamBase::AddMethods(env, fd);
-  target
-      ->Set(context, handleString,
-            fd->GetFunction(env->context()).ToLocalChecked())
-      .Check();
+  env->SetConstructorFunction(target, "FileHandle", fd);
   env->set_fd_constructor_template(fdt);
 
   // Create FunctionTemplate for FileHandle::CloseReq
@@ -2491,6 +2525,9 @@ void Initialize(Local<Object> target,
               use_promises_symbol).Check();
 }
 
+BindingData* FSReqBase::binding_data() {
+  return binding_data_.get();
+}
 }  // namespace fs
 
 }  // end namespace node
diff --git a/src/node_file.h b/src/node_file.h
index f80f906f5f863212a27b4c1d5c703ef7a8078e8c..9e652dc7a4afa4c80c2384502be1c06cddb1bf52 100644
--- a/src/node_file.h
+++ b/src/node_file.h
@@ -12,6 +12,28 @@
 namespace node {
 namespace fs {
 
+class FileHandleReadWrap;
+
+class BindingData : public BaseObject {
+ public:
+  explicit BindingData(Environment* env, v8::Local<v8::Object> wrap)
+      : BaseObject(env, wrap),
+        stats_field_array(env->isolate(), kFsStatsBufferLength),
+        stats_field_bigint_array(env->isolate(), kFsStatsBufferLength) {}
+
+  AliasedFloat64Array stats_field_array;
+  AliasedBigUint64Array stats_field_bigint_array;
+
+  std::vector<BaseObjectPtr<FileHandleReadWrap>>
+      file_handle_read_wrap_freelist;
+
+  static constexpr FastStringKey type_name { "fs" };
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+};
+
 // structure used to store state during a complex operation, e.g., mkdirp.
 class FSContinuationData : public MemoryRetainer {
  public:
@@ -44,7 +66,7 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
  public:
   typedef MaybeStackBuffer<char, 64> FSReqBuffer;
 
-  inline FSReqBase(Environment* env,
+  inline FSReqBase(BindingData* binding_data,
                    v8::Local<v8::Object> req,
                    AsyncWrap::ProviderType type,
                    bool use_bigint);
@@ -87,6 +109,8 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
 
   void MemoryInfo(MemoryTracker* tracker) const override;
 
+  BindingData* binding_data();
+
  private:
   std::unique_ptr<FSContinuationData> continuation_data_;
   enum encoding encoding_ = UTF8;
@@ -95,6 +119,8 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
   bool is_plain_open_ = false;
   const char* syscall_ = nullptr;
 
+  BaseObjectPtr<BindingData> binding_data_;
+
   // Typically, the content of buffer_ is something like a file name, so
   // something around 64 bytes should be enough.
   FSReqBuffer buffer_;
@@ -102,7 +128,7 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
 
 class FSReqCallback final : public FSReqBase {
  public:
-  inline FSReqCallback(Environment* env,
+  inline FSReqCallback(BindingData* binding_data,
                        v8::Local<v8::Object> req,
                        bool use_bigint);
 
@@ -123,7 +149,7 @@ void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
                     const uv_stat_t* s,
                     const size_t offset = 0);
 
-inline v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
+inline v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
                                                  const bool use_bigint,
                                                  const uv_stat_t* s,
                                                  const bool second = false);
@@ -131,7 +157,8 @@ inline v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
 template <typename AliasedBufferT>
 class FSReqPromise final : public FSReqBase {
  public:
-  static inline FSReqPromise* New(Environment* env, bool use_bigint);
+  static inline FSReqPromise* New(BindingData* binding_data,
+                                  bool use_bigint);
   inline ~FSReqPromise() override;
 
   inline void Reject(v8::Local<v8::Value> reject) override;
@@ -150,7 +177,7 @@ class FSReqPromise final : public FSReqBase {
   FSReqPromise& operator=(const FSReqPromise&&) = delete;
 
  private:
-  inline FSReqPromise(Environment* env,
+  inline FSReqPromise(BindingData* binding_data,
                       v8::Local<v8::Object> obj,
                       bool use_bigint);
 
@@ -208,7 +235,7 @@ class FileHandleReadWrap final : public ReqWrap<uv_fs_t> {
 // the object is garbage collected
 class FileHandle final : public AsyncWrap, public StreamBase {
  public:
-  static FileHandle* New(Environment* env,
+  static FileHandle* New(BindingData* binding_data,
                          int fd,
                          v8::Local<v8::Object> obj = v8::Local<v8::Object>());
   ~FileHandle() override;
@@ -273,7 +300,7 @@ class FileHandle final : public AsyncWrap, public StreamBase {
     int fd_;
   };
 
-  FileHandle(Environment* env, v8::Local<v8::Object> obj, int fd);
+  FileHandle(BindingData* binding_data, v8::Local<v8::Object> obj, int fd);
 
   // Synchronous close that emits a warning
   void Close();
@@ -318,11 +345,13 @@ class FileHandle final : public AsyncWrap, public StreamBase {
   int fd_;
   bool closing_ = false;
   bool closed_ = false;
+  bool reading_ = false;
   int64_t read_offset_ = -1;
   int64_t read_length_ = -1;
 
-  bool reading_ = false;
-  std::unique_ptr<FileHandleReadWrap> current_read_ = nullptr;
+  BaseObjectPtr<FileHandleReadWrap> current_read_;
+
+  BaseObjectPtr<BindingData> binding_data_;
 };
 
 int MKDirpSync(uv_loop_t* loop,
@@ -354,7 +383,8 @@ class FSReqWrapSync {
 // TODO(addaleax): Currently, callers check the return value and assume
 // that nullptr indicates a synchronous call, rather than a failure.
 // Failure conditions should be disambiguated and handled appropriately.
-inline FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,
+inline FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
+                             int index,
                              bool use_bigint = false);
 
 // Returns nullptr if the operation fails from the start.
diff --git a/src/node_http2.cc b/src/node_http2.cc
index 5156aa34df55a1bbfa33664d3d14954f04948720..83e8b5fc6bfee50bdd5f87cb0bf0dc1b5026feb6 100644
--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -1,32 +1,44 @@
 #include "aliased_buffer.h"
+#include "allocated_buffer-inl.h"
+#include "aliased_struct-inl.h"
 #include "debug_utils-inl.h"
+#include "histogram-inl.h"
 #include "memory_tracker-inl.h"
 #include "node.h"
 #include "node_buffer.h"
 #include "node_http2.h"
-#include "node_http2_state.h"
+#include "node_http_common-inl.h"
 #include "node_mem-inl.h"
 #include "node_perf.h"
 #include "node_revert.h"
+#include "stream_base-inl.h"
 #include "util-inl.h"
 
 #include <algorithm>
 
 namespace node {
 
+using v8::Array;
 using v8::ArrayBuffer;
 using v8::ArrayBufferView;
 using v8::Boolean;
 using v8::Context;
+using v8::EscapableHandleScope;
 using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::HandleScope;
 using v8::Integer;
-using v8::NewStringType;
+using v8::Isolate;
+using v8::Local;
+using v8::MaybeLocal;
 using v8::Number;
+using v8::Object;
 using v8::ObjectTemplate;
 using v8::String;
-using v8::Uint32;
 using v8::Uint8Array;
 using v8::Undefined;
+using v8::Value;
 
 using node::performance::PerformanceEntry;
 namespace http2 {
@@ -35,15 +47,9 @@ namespace {
 
 const char zero_bytes_256[256] = {};
 
-inline Http2Stream* GetStream(Http2Session* session,
-                              int32_t id,
-                              nghttp2_data_source* source) {
-  Http2Stream* stream = static_cast<Http2Stream*>(source->ptr);
-  if (stream == nullptr)
-    stream = session->FindStream(id);
-  CHECK_NOT_NULL(stream);
-  CHECK_EQ(id, stream->id());
-  return stream;
+bool HasHttp2Observer(Environment* env) {
+  AliasedUint32Array& observers = env->performance_state()->observers;
+  return observers[performance::NODE_PERFORMANCE_ENTRY_TYPE_HTTP2] != 0;
 }
 
 }  // anonymous namespace
@@ -62,37 +68,28 @@ const Http2Session::Callbacks Http2Session::callback_struct_saved[2] = {
 // For example:
 //
 // Http2Scope h2scope(session);
-// nghttp2_submit_ping(**session, ... );
+// nghttp2_submit_ping(session->session(), ... );
 //
 // When the Http2Scope passes out of scope and is deconstructed, it will
 // call Http2Session::MaybeScheduleWrite().
 Http2Scope::Http2Scope(Http2Stream* stream) : Http2Scope(stream->session()) {}
 
-Http2Scope::Http2Scope(Http2Session* session) {
-  if (session == nullptr)
-    return;
+Http2Scope::Http2Scope(Http2Session* session) : session_(session) {
+  if (!session_) return;
 
-  if (session->flags_ & (SESSION_STATE_HAS_SCOPE |
-                         SESSION_STATE_WRITE_SCHEDULED)) {
-    // There is another scope further below on the stack, or it is already
-    // known that a write is scheduled. In either case, there is nothing to do.
+  // If there is another scope further below on the stack, or
+  // a write is already scheduled, there's nothing to do.
+  if (session_->is_in_scope() || session_->is_write_scheduled()) {
+    session_.reset();
     return;
   }
-  session->flags_ |= SESSION_STATE_HAS_SCOPE;
-  session_ = session;
-
-  // Always keep the session object alive for at least as long as
-  // this scope is active.
-  session_handle_ = session->object();
-  CHECK(!session_handle_.IsEmpty());
+  session_->set_in_scope();
 }
 
 Http2Scope::~Http2Scope() {
-  if (session_ == nullptr)
-    return;
-
-  session_->flags_ &= ~SESSION_STATE_HAS_SCOPE;
-  if (!(session_->flags_ & SESSION_STATE_WRITE_SCHEDULED))
+  if (!session_) return;
+  session_->set_in_scope(false);
+  if (!session_->is_write_scheduled())
     session_->MaybeScheduleWrite();
 }
 
@@ -100,12 +97,15 @@ Http2Scope::~Http2Scope() {
 // instances to configure an appropriate nghttp2_options struct. The class
 // uses a single TypedArray instance that is shared with the JavaScript side
 // to more efficiently pass values back and forth.
-Http2Options::Http2Options(Environment* env, nghttp2_session_type type) {
-  nghttp2_option_new(&options_);
+Http2Options::Http2Options(Http2State* http2_state, SessionType type) {
+  nghttp2_option* option;
+  CHECK_EQ(nghttp2_option_new(&option), 0);
+  CHECK_NOT_NULL(option);
+  options_.reset(option);
 
   // Make sure closed connections aren't kept around, taking up memory.
   // Note that this breaks the priority tree, which we don't use.
-  nghttp2_option_set_no_closed_streams(options_, 1);
+  nghttp2_option_set_no_closed_streams(option, 1);
 
   // We manually handle flow control within a session in order to
   // implement backpressure -- that is, we only send WINDOW_UPDATE
@@ -113,83 +113,77 @@ Http2Options::Http2Options(Environment* env, nghttp2_session_type type) {
   // code. This ensures that the flow of data over the connection
   // does not move too quickly and limits the amount of data we
   // are required to buffer.
-  nghttp2_option_set_no_auto_window_update(options_, 1);
+  nghttp2_option_set_no_auto_window_update(option, 1);
 
   // Enable built in support for receiving ALTSVC and ORIGIN frames (but
   // only on client side sessions
   if (type == NGHTTP2_SESSION_CLIENT) {
-    nghttp2_option_set_builtin_recv_extension_type(options_, NGHTTP2_ALTSVC);
-    nghttp2_option_set_builtin_recv_extension_type(options_, NGHTTP2_ORIGIN);
+    nghttp2_option_set_builtin_recv_extension_type(option, NGHTTP2_ALTSVC);
+    nghttp2_option_set_builtin_recv_extension_type(option, NGHTTP2_ORIGIN);
   }
 
-  AliasedUint32Array& buffer = env->http2_state()->options_buffer;
+  AliasedUint32Array& buffer = http2_state->options_buffer;
   uint32_t flags = buffer[IDX_OPTIONS_FLAGS];
 
   if (flags & (1 << IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE)) {
     nghttp2_option_set_max_deflate_dynamic_table_size(
-        options_,
+        option,
         buffer[IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE]);
   }
 
   if (flags & (1 << IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS)) {
     nghttp2_option_set_max_reserved_remote_streams(
-        options_,
+        option,
         buffer[IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS]);
   }
 
   if (flags & (1 << IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH)) {
     nghttp2_option_set_max_send_header_block_length(
-        options_,
+        option,
         buffer[IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH]);
   }
 
   // Recommended default
-  nghttp2_option_set_peer_max_concurrent_streams(options_, 100);
+  nghttp2_option_set_peer_max_concurrent_streams(option, 100);
   if (flags & (1 << IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS)) {
     nghttp2_option_set_peer_max_concurrent_streams(
-        options_,
+        option,
         buffer[IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS]);
   }
 
-  if (IsReverted(SECURITY_REVERT_CVE_2019_9512))
-    nghttp2_option_set_max_outbound_ack(options_, 10000);
-
   // The padding strategy sets the mechanism by which we determine how much
   // additional frame padding to apply to DATA and HEADERS frames. Currently
   // this is set on a per-session basis, but eventually we may switch to
   // a per-stream setting, giving users greater control
   if (flags & (1 << IDX_OPTIONS_PADDING_STRATEGY)) {
-    padding_strategy_type strategy =
-        static_cast<padding_strategy_type>(
+    PaddingStrategy strategy =
+        static_cast<PaddingStrategy>(
             buffer.GetValue(IDX_OPTIONS_PADDING_STRATEGY));
-    SetPaddingStrategy(strategy);
+    set_padding_strategy(strategy);
   }
 
   // The max header list pairs option controls the maximum number of
   // header pairs the session may accept. This is a hard limit.. that is,
   // if the remote peer sends more than this amount, the stream will be
   // automatically closed with an RST_STREAM.
-  if (flags & (1 << IDX_OPTIONS_MAX_HEADER_LIST_PAIRS)) {
-    SetMaxHeaderPairs(buffer[IDX_OPTIONS_MAX_HEADER_LIST_PAIRS]);
-  }
+  if (flags & (1 << IDX_OPTIONS_MAX_HEADER_LIST_PAIRS))
+    set_max_header_pairs(buffer[IDX_OPTIONS_MAX_HEADER_LIST_PAIRS]);
 
   // The HTTP2 specification places no limits on the number of HTTP2
   // PING frames that can be sent. In order to prevent PINGS from being
   // abused as an attack vector, however, we place a strict upper limit
   // on the number of unacknowledged PINGS that can be sent at any given
   // time.
-  if (flags & (1 << IDX_OPTIONS_MAX_OUTSTANDING_PINGS)) {
-    SetMaxOutstandingPings(buffer[IDX_OPTIONS_MAX_OUTSTANDING_PINGS]);
-  }
+  if (flags & (1 << IDX_OPTIONS_MAX_OUTSTANDING_PINGS))
+    set_max_outstanding_pings(buffer[IDX_OPTIONS_MAX_OUTSTANDING_PINGS]);
 
   // The HTTP2 specification places no limits on the number of HTTP2
   // SETTINGS frames that can be sent. In order to prevent PINGS from being
   // abused as an attack vector, however, we place a strict upper limit
   // on the number of unacknowledged SETTINGS that can be sent at any given
   // time.
-  if (flags & (1 << IDX_OPTIONS_MAX_OUTSTANDING_SETTINGS)) {
-    SetMaxOutstandingSettings(buffer[IDX_OPTIONS_MAX_OUTSTANDING_SETTINGS]);
-  }
+  if (flags & (1 << IDX_OPTIONS_MAX_OUTSTANDING_SETTINGS))
+    set_max_outstanding_settings(buffer[IDX_OPTIONS_MAX_OUTSTANDING_SETTINGS]);
 
   // The HTTP2 specification places no limits on the amount of memory
   // that a session can consume. In order to prevent abuse, we place a
@@ -199,140 +193,140 @@ Http2Options::Http2Options(Environment* env, nghttp2_session_type type) {
   // created.
   // Important: The maxSessionMemory option in javascript is expressed in
   //            terms of MB increments (i.e. the value 1 == 1 MB)
-  if (flags & (1 << IDX_OPTIONS_MAX_SESSION_MEMORY)) {
-    SetMaxSessionMemory(buffer[IDX_OPTIONS_MAX_SESSION_MEMORY] * 1e6);
-  }
+  if (flags & (1 << IDX_OPTIONS_MAX_SESSION_MEMORY))
+    set_max_session_memory(buffer[IDX_OPTIONS_MAX_SESSION_MEMORY] * 1000000);
 
   if (flags & (1 << IDX_OPTIONS_MAX_SETTINGS)) {
     nghttp2_option_set_max_settings(
-        options_,
+        option,
         static_cast<size_t>(buffer[IDX_OPTIONS_MAX_SETTINGS]));
   }
 }
 
-void Http2Session::Http2Settings::Init() {
-  AliasedUint32Array& buffer = env()->http2_state()->settings_buffer;
-  uint32_t flags = buffer[IDX_SETTINGS_COUNT];
-
-  size_t n = 0;
+#define GRABSETTING(entries, count, name)                                      \
+  do {                                                                         \
+    if (flags & (1 << IDX_SETTINGS_ ## name)) {                                \
+      uint32_t val = buffer[IDX_SETTINGS_ ## name];                            \
+      entries[count++] =                                                       \
+          nghttp2_settings_entry {NGHTTP2_SETTINGS_ ## name, val};             \
+    } } while (0)
 
-#define GRABSETTING(N, trace)                                                 \
-  if (flags & (1 << IDX_SETTINGS_##N)) {                                      \
-    uint32_t val = buffer[IDX_SETTINGS_##N];                                  \
-    if (session_ != nullptr)                                                  \
-      Debug(session_, "setting " trace ": %d\n", val);                        \
-    entries_[n++] =                                                           \
-        nghttp2_settings_entry {NGHTTP2_SETTINGS_##N, val};                   \
-  }
+size_t Http2Settings::Init(
+    Http2State* http2_state,
+    nghttp2_settings_entry* entries) {
+  AliasedUint32Array& buffer = http2_state->settings_buffer;
+  uint32_t flags = buffer[IDX_SETTINGS_COUNT];
 
-  GRABSETTING(HEADER_TABLE_SIZE, "header table size");
-  GRABSETTING(MAX_CONCURRENT_STREAMS, "max concurrent streams");
-  GRABSETTING(MAX_FRAME_SIZE, "max frame size");
-  GRABSETTING(INITIAL_WINDOW_SIZE, "initial window size");
-  GRABSETTING(MAX_HEADER_LIST_SIZE, "max header list size");
-  GRABSETTING(ENABLE_PUSH, "enable push");
-  GRABSETTING(ENABLE_CONNECT_PROTOCOL, "enable connect protocol");
+  size_t count = 0;
 
-#undef GRABSETTING
+#define V(name) GRABSETTING(entries, count, name);
+  HTTP2_SETTINGS(V)
+#undef V
 
-  count_ = n;
+  return count;
 }
+#undef GRABSETTING
 
 // The Http2Settings class is used to configure a SETTINGS frame that is
 // to be sent to the connected peer. The settings are set using a TypedArray
 // that is shared with the JavaScript side.
-Http2Session::Http2Settings::Http2Settings(Environment* env,
-                                           Http2Session* session,
-                                           Local<Object> obj,
-                                           uint64_t start_time)
-    : AsyncWrap(env, obj, PROVIDER_HTTP2SETTINGS),
+Http2Settings::Http2Settings(Http2Session* session,
+                             Local<Object> obj,
+                             Local<Function> callback,
+                             uint64_t start_time)
+    : AsyncWrap(session->env(), obj, PROVIDER_HTTP2SETTINGS),
       session_(session),
       startTime_(start_time) {
-  Init();
+  callback_.Reset(env()->isolate(), callback);
+  count_ = Init(session->http2_state(), entries_);
+}
+
+Local<Function> Http2Settings::callback() const {
+  return callback_.Get(env()->isolate());
+}
+
+void Http2Settings::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("callback", callback_);
 }
 
 // Generates a Buffer that contains the serialized payload of a SETTINGS
 // frame. This can be used, for instance, to create the Base64-encoded
 // content of an Http2-Settings header field.
-Local<Value> Http2Session::Http2Settings::Pack() {
-  const size_t len = count_ * 6;
-  Local<Value> buf = Buffer::New(env(), len).ToLocalChecked();
+Local<Value> Http2Settings::Pack() {
+  return Pack(session_->env(), count_, entries_);
+}
+
+Local<Value> Http2Settings::Pack(Http2State* state) {
+  nghttp2_settings_entry entries[IDX_SETTINGS_COUNT];
+  size_t count = Init(state, entries);
+  return Pack(state->env(), count, entries);
+}
+
+Local<Value> Http2Settings::Pack(
+    Environment* env,
+    size_t count,
+    const nghttp2_settings_entry* entries) {
+  EscapableHandleScope scope(env->isolate());
+  const size_t size = count * 6;
+  AllocatedBuffer buffer = AllocatedBuffer::AllocateManaged(env, size);
   ssize_t ret =
       nghttp2_pack_settings_payload(
-        reinterpret_cast<uint8_t*>(Buffer::Data(buf)), len,
-        &entries_[0], count_);
-  if (ret >= 0)
-    return buf;
-  else
-    return Undefined(env()->isolate());
+          reinterpret_cast<uint8_t*>(buffer.data()),
+          size,
+          entries,
+          count);
+  Local<Value> buf = Undefined(env->isolate());
+  if (ret >= 0) buf = buffer.ToBuffer().ToLocalChecked();
+  return scope.Escape(buf);
 }
 
 // Updates the shared TypedArray with the current remote or local settings for
 // the session.
-void Http2Session::Http2Settings::Update(Environment* env,
-                                         Http2Session* session,
-                                         get_setting fn) {
-  AliasedUint32Array& buffer = env->http2_state()->settings_buffer;
-  buffer[IDX_SETTINGS_HEADER_TABLE_SIZE] =
-      fn(**session, NGHTTP2_SETTINGS_HEADER_TABLE_SIZE);
-  buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS] =
-      fn(**session, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);
-  buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE] =
-      fn(**session, NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE);
-  buffer[IDX_SETTINGS_MAX_FRAME_SIZE] =
-      fn(**session, NGHTTP2_SETTINGS_MAX_FRAME_SIZE);
-  buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE] =
-      fn(**session, NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE);
-  buffer[IDX_SETTINGS_ENABLE_PUSH] =
-      fn(**session, NGHTTP2_SETTINGS_ENABLE_PUSH);
-  buffer[IDX_SETTINGS_ENABLE_CONNECT_PROTOCOL] =
-      fn(**session, NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL);
+void Http2Settings::Update(Http2Session* session, get_setting fn) {
+  AliasedUint32Array& buffer = session->http2_state()->settings_buffer;
+
+#define V(name)                                                                \
+  buffer[IDX_SETTINGS_ ## name] =                                              \
+      fn(session->session(), NGHTTP2_SETTINGS_ ## name);
+  HTTP2_SETTINGS(V)
+#undef V
 }
 
 // Initializes the shared TypedArray with the default settings values.
-void Http2Session::Http2Settings::RefreshDefaults(Environment* env) {
-  AliasedUint32Array& buffer = env->http2_state()->settings_buffer;
-
-  buffer[IDX_SETTINGS_HEADER_TABLE_SIZE] =
-      DEFAULT_SETTINGS_HEADER_TABLE_SIZE;
-  buffer[IDX_SETTINGS_ENABLE_PUSH] =
-      DEFAULT_SETTINGS_ENABLE_PUSH;
-  buffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS] =
-      DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS;
-  buffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE] =
-      DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE;
-  buffer[IDX_SETTINGS_MAX_FRAME_SIZE] =
-      DEFAULT_SETTINGS_MAX_FRAME_SIZE;
-  buffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE] =
-      DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE;
-  buffer[IDX_SETTINGS_ENABLE_CONNECT_PROTOCOL] =
-      DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL;
-  buffer[IDX_SETTINGS_COUNT] =
-    (1 << IDX_SETTINGS_HEADER_TABLE_SIZE) |
-    (1 << IDX_SETTINGS_ENABLE_PUSH) |
-    (1 << IDX_SETTINGS_MAX_CONCURRENT_STREAMS) |
-    (1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE) |
-    (1 << IDX_SETTINGS_MAX_FRAME_SIZE) |
-    (1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE) |
-    (1 << IDX_SETTINGS_ENABLE_CONNECT_PROTOCOL);
-}
-
-
-void Http2Session::Http2Settings::Send() {
-  Http2Scope h2scope(session_);
-  CHECK_EQ(nghttp2_submit_settings(**session_, NGHTTP2_FLAG_NONE,
-                                   &entries_[0], count_), 0);
-}
-
-void Http2Session::Http2Settings::Done(bool ack) {
+void Http2Settings::RefreshDefaults(Http2State* http2_state) {
+  AliasedUint32Array& buffer = http2_state->settings_buffer;
+  uint32_t flags = 0;
+
+#define V(name)                                                            \
+  do {                                                                     \
+    buffer[IDX_SETTINGS_ ## name] = DEFAULT_SETTINGS_ ## name;             \
+    flags |= 1 << IDX_SETTINGS_ ## name;                                   \
+  } while (0);
+  HTTP2_SETTINGS(V)
+#undef V
+
+  buffer[IDX_SETTINGS_COUNT] = flags;
+}
+
+
+void Http2Settings::Send() {
+  Http2Scope h2scope(session_.get());
+  CHECK_EQ(nghttp2_submit_settings(
+      session_->session(),
+      NGHTTP2_FLAG_NONE,
+      &entries_[0],
+      count_), 0);
+}
+
+void Http2Settings::Done(bool ack) {
   uint64_t end = uv_hrtime();
   double duration = (end - startTime_) / 1e6;
 
   Local<Value> argv[] = {
-    Boolean::New(env()->isolate(), ack),
+    ack ? v8::True(env()->isolate()) : v8::False(env()->isolate()),
     Number::New(env()->isolate(), duration)
   };
-  MakeCallback(env()->ondone_string(), arraysize(argv), argv);
+  MakeCallback(callback(), arraysize(argv), argv);
 }
 
 // The Http2Priority class initializes an appropriate nghttp2_priority_spec
@@ -345,11 +339,11 @@ Http2Priority::Http2Priority(Environment* env,
   Local<Context> context = env->context();
   int32_t parent_ = parent->Int32Value(context).ToChecked();
   int32_t weight_ = weight->Int32Value(context).ToChecked();
-  bool exclusive_ = exclusive->BooleanValue(env->isolate());
+  bool exclusive_ = exclusive->IsTrue();
   Debug(env, DebugCategory::HTTP2STREAM,
-        "Http2Priority: parent: %d, weight: %d, exclusive: %d\n",
-        parent_, weight_, exclusive_);
-  nghttp2_priority_spec_init(&spec, parent_, weight_, exclusive_ ? 1 : 0);
+        "Http2Priority: parent: %d, weight: %d, exclusive: %s\n",
+        parent_, weight_, exclusive_ ? "yes" : "no");
+  nghttp2_priority_spec_init(this, parent_, weight_, exclusive_ ? 1 : 0);
 }
 
 
@@ -363,94 +357,32 @@ const char* Http2Session::TypeName() const {
   }
 }
 
-// The Headers class initializes a proper array of nghttp2_nv structs
-// containing the header name value pairs.
-Headers::Headers(Isolate* isolate,
-                 Local<Context> context,
-                 Local<Array> headers) {
-  Local<Value> header_string = headers->Get(context, 0).ToLocalChecked();
-  Local<Value> header_count = headers->Get(context, 1).ToLocalChecked();
-  count_ = header_count.As<Uint32>()->Value();
-  int header_string_len = header_string.As<String>()->Length();
-
-  if (count_ == 0) {
-    CHECK_EQ(header_string_len, 0);
-    return;
-  }
-
-  // Allocate a single buffer with count_ nghttp2_nv structs, followed
-  // by the raw header data as passed from JS. This looks like:
-  // | possible padding | nghttp2_nv | nghttp2_nv | ... | header contents |
-  buf_.AllocateSufficientStorage((alignof(nghttp2_nv) - 1) +
-                                 count_ * sizeof(nghttp2_nv) +
-                                 header_string_len);
-  // Make sure the start address is aligned appropriately for an nghttp2_nv*.
-  char* start = reinterpret_cast<char*>(
-      RoundUp(reinterpret_cast<uintptr_t>(*buf_), alignof(nghttp2_nv)));
-  char* header_contents = start + (count_ * sizeof(nghttp2_nv));
-  nghttp2_nv* const nva = reinterpret_cast<nghttp2_nv*>(start);
-
-  CHECK_LE(header_contents + header_string_len, *buf_ + buf_.length());
-  CHECK_EQ(header_string.As<String>()->WriteOneByte(
-               isolate,
-               reinterpret_cast<uint8_t*>(header_contents),
-               0,
-               header_string_len,
-               String::NO_NULL_TERMINATION),
-           header_string_len);
-
-  size_t n = 0;
-  char* p;
-  for (p = header_contents; p < header_contents + header_string_len; n++) {
-    if (n >= count_) {
-      // This can happen if a passed header contained a null byte. In that
-      // case, just provide nghttp2 with an invalid header to make it reject
-      // the headers list.
-      static uint8_t zero = '\0';
-      nva[0].name = nva[0].value = &zero;
-      nva[0].namelen = nva[0].valuelen = 1;
-      count_ = 1;
-      return;
-    }
-
-    nva[n].flags = NGHTTP2_NV_FLAG_NONE;
-    nva[n].name = reinterpret_cast<uint8_t*>(p);
-    nva[n].namelen = strlen(p);
-    p += nva[n].namelen + 1;
-    nva[n].value = reinterpret_cast<uint8_t*>(p);
-    nva[n].valuelen = strlen(p);
-    p += nva[n].valuelen + 1;
-  }
-}
-
-Origins::Origins(Isolate* isolate,
-                 Local<Context> context,
-                 Local<String> origin_string,
-                 size_t origin_count) : count_(origin_count) {
+Origins::Origins(
+    Environment* env,
+    Local<String> origin_string,
+    size_t origin_count)
+    : count_(origin_count) {
   int origin_string_len = origin_string->Length();
   if (count_ == 0) {
     CHECK_EQ(origin_string_len, 0);
     return;
   }
 
-  // Allocate a single buffer with count_ nghttp2_nv structs, followed
-  // by the raw header data as passed from JS. This looks like:
-  // | possible padding | nghttp2_nv | nghttp2_nv | ... | header contents |
-  buf_.AllocateSufficientStorage((alignof(nghttp2_origin_entry) - 1) +
-                                 count_ * sizeof(nghttp2_origin_entry) +
-                                 origin_string_len);
+  buf_ = AllocatedBuffer::AllocateManaged(
+      env,
+      (alignof(nghttp2_origin_entry) - 1) +
+       count_ * sizeof(nghttp2_origin_entry) +
+                              origin_string_len);
 
   // Make sure the start address is aligned appropriately for an nghttp2_nv*.
-  char* start = reinterpret_cast<char*>(
-      RoundUp(reinterpret_cast<uintptr_t>(*buf_),
-              alignof(nghttp2_origin_entry)));
+  char* start = AlignUp(buf_.data(), alignof(nghttp2_origin_entry));
   char* origin_contents = start + (count_ * sizeof(nghttp2_origin_entry));
   nghttp2_origin_entry* const nva =
       reinterpret_cast<nghttp2_origin_entry*>(start);
 
-  CHECK_LE(origin_contents + origin_string_len, *buf_ + buf_.length());
+  CHECK_LE(origin_contents + origin_string_len, buf_.data() + buf_.size());
   CHECK_EQ(origin_string->WriteOneByte(
-               isolate,
+               env->isolate(),
                reinterpret_cast<uint8_t*>(origin_contents),
                0,
                origin_string_len,
@@ -477,42 +409,39 @@ Origins::Origins(Isolate* isolate,
 // Sets the various callback functions that nghttp2 will use to notify us
 // about significant events while processing http2 stuff.
 Http2Session::Callbacks::Callbacks(bool kHasGetPaddingCallback) {
-  CHECK_EQ(nghttp2_session_callbacks_new(&callbacks), 0);
+  nghttp2_session_callbacks* callbacks_;
+  CHECK_EQ(nghttp2_session_callbacks_new(&callbacks_), 0);
+  callbacks.reset(callbacks_);
 
   nghttp2_session_callbacks_set_on_begin_headers_callback(
-    callbacks, OnBeginHeadersCallback);
+    callbacks_, OnBeginHeadersCallback);
   nghttp2_session_callbacks_set_on_header_callback2(
-    callbacks, OnHeaderCallback);
+    callbacks_, OnHeaderCallback);
   nghttp2_session_callbacks_set_on_frame_recv_callback(
-    callbacks, OnFrameReceive);
+    callbacks_, OnFrameReceive);
   nghttp2_session_callbacks_set_on_stream_close_callback(
-    callbacks, OnStreamClose);
+    callbacks_, OnStreamClose);
   nghttp2_session_callbacks_set_on_data_chunk_recv_callback(
-    callbacks, OnDataChunkReceived);
+    callbacks_, OnDataChunkReceived);
   nghttp2_session_callbacks_set_on_frame_not_send_callback(
-    callbacks, OnFrameNotSent);
+    callbacks_, OnFrameNotSent);
   nghttp2_session_callbacks_set_on_invalid_header_callback2(
-    callbacks, OnInvalidHeader);
+    callbacks_, OnInvalidHeader);
   nghttp2_session_callbacks_set_error_callback(
-    callbacks, OnNghttpError);
+    callbacks_, OnNghttpError);
   nghttp2_session_callbacks_set_send_data_callback(
-    callbacks, OnSendData);
+    callbacks_, OnSendData);
   nghttp2_session_callbacks_set_on_invalid_frame_recv_callback(
-    callbacks, OnInvalidFrame);
+    callbacks_, OnInvalidFrame);
   nghttp2_session_callbacks_set_on_frame_send_callback(
-    callbacks, OnFrameSent);
+    callbacks_, OnFrameSent);
 
   if (kHasGetPaddingCallback) {
     nghttp2_session_callbacks_set_select_padding_callback(
-      callbacks, OnSelectPadding);
+      callbacks_, OnSelectPadding);
   }
 }
 
-
-Http2Session::Callbacks::~Callbacks() {
-  nghttp2_session_callbacks_del(callbacks);
-}
-
 void Http2Session::StopTrackingRcbuf(nghttp2_rcbuf* buf) {
   StopTrackingMemory(buf);
 }
@@ -529,36 +458,35 @@ void Http2Session::DecreaseAllocatedSize(size_t size) {
   current_nghttp2_memory_ -= size;
 }
 
-Http2Session::Http2Session(Environment* env,
+Http2Session::Http2Session(Http2State* http2_state,
                            Local<Object> wrap,
-                           nghttp2_session_type type)
-    : AsyncWrap(env, wrap, AsyncWrap::PROVIDER_HTTP2SESSION),
-      session_type_(type) {
+                           SessionType type)
+    : AsyncWrap(http2_state->env(), wrap, AsyncWrap::PROVIDER_HTTP2SESSION),
+      js_fields_(http2_state->env()->isolate()),
+      session_type_(type),
+      http2_state_(http2_state) {
   MakeWeak();
   statistics_.start_time = uv_hrtime();
 
   // Capture the configuration options for this session
-  Http2Options opts(env, type);
+  Http2Options opts(http2_state, type);
 
-  max_session_memory_ = opts.GetMaxSessionMemory();
+  max_session_memory_ = opts.max_session_memory();
 
-  uint32_t maxHeaderPairs = opts.GetMaxHeaderPairs();
+  uint32_t maxHeaderPairs = opts.max_header_pairs();
   max_header_pairs_ =
       type == NGHTTP2_SESSION_SERVER
-          ? std::max(maxHeaderPairs, 4U)     // minimum # of request headers
-          : std::max(maxHeaderPairs, 1U);    // minimum # of response headers
+          ? GetServerMaxHeaderPairs(maxHeaderPairs)
+          : GetClientMaxHeaderPairs(maxHeaderPairs);
 
-  max_outstanding_pings_ = opts.GetMaxOutstandingPings();
-  max_outstanding_settings_ = opts.GetMaxOutstandingSettings();
+  max_outstanding_pings_ = opts.max_outstanding_pings();
+  max_outstanding_settings_ = opts.max_outstanding_settings();
 
-  padding_strategy_ = opts.GetPaddingStrategy();
+  padding_strategy_ = opts.padding_strategy();
 
   bool hasGetPaddingCallback =
       padding_strategy_ != PADDING_STRATEGY_NONE;
 
-  nghttp2_session_callbacks* callbacks
-      = callback_struct_saved[hasGetPaddingCallback ? 1 : 0].callbacks;
-
   auto fn = type == NGHTTP2_SESSION_SERVER ?
       nghttp2_session_server_new3 :
       nghttp2_session_client_new3;
@@ -570,50 +498,61 @@ Http2Session::Http2Session(Environment* env,
   // of the options are out of acceptable range, which we should
   // be catching before it gets this far. Either way, crash if this
   // fails.
-  CHECK_EQ(fn(&session_, callbacks, this, *opts, &alloc_info), 0);
+  nghttp2_session* session;
+  CHECK_EQ(fn(
+      &session,
+      callback_struct_saved[hasGetPaddingCallback ? 1 : 0].callbacks.get(),
+      this,
+      *opts,
+      &alloc_info), 0);
+  session_.reset(session);
 
   outgoing_storage_.reserve(1024);
   outgoing_buffers_.reserve(32);
 
-  {
-    // Make the js_fields_ property accessible to JS land.
-    Local<ArrayBuffer> ab =
-        ArrayBuffer::New(env->isolate(),
-                         reinterpret_cast<uint8_t*>(&js_fields_),
-                         kSessionUint8FieldCount);
-    Local<Uint8Array> uint8_arr =
-        Uint8Array::New(ab, 0, kSessionUint8FieldCount);
-    USE(wrap->Set(env->context(), env->fields_string(), uint8_arr));
-  }
+  Local<Uint8Array> uint8_arr =
+      Uint8Array::New(js_fields_.GetArrayBuffer(), 0, kSessionUint8FieldCount);
+  USE(wrap->Set(env()->context(), env()->fields_string(), uint8_arr));
 }
 
 Http2Session::~Http2Session() {
-  CHECK_EQ(flags_ & SESSION_STATE_HAS_SCOPE, 0);
+  CHECK(!is_in_scope());
   Debug(this, "freeing nghttp2 session");
-  nghttp2_session_del(session_);
+  // Explicitly reset session_ so the subsequent
+  // current_nghttp2_memory_ check passes.
+  session_.reset();
   CHECK_EQ(current_nghttp2_memory_, 0);
 }
 
+void Http2Session::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("streams", streams_);
+  tracker->TrackField("outstanding_pings", outstanding_pings_);
+  tracker->TrackField("outstanding_settings", outstanding_settings_);
+  tracker->TrackField("outgoing_buffers", outgoing_buffers_);
+  tracker->TrackFieldWithSize("stream_buf", stream_buf_.len);
+  tracker->TrackFieldWithSize("outgoing_storage", outgoing_storage_.size());
+  tracker->TrackFieldWithSize("pending_rst_streams",
+                              pending_rst_streams_.size() * sizeof(int32_t));
+  tracker->TrackFieldWithSize("nghttp2_memory", current_nghttp2_memory_);
+}
+
 std::string Http2Session::diagnostic_name() const {
   return std::string("Http2Session ") + TypeName() + " (" +
       std::to_string(static_cast<int64_t>(get_async_id())) + ")";
 }
 
-inline bool HasHttp2Observer(Environment* env) {
-  AliasedUint32Array& observers = env->performance_state()->observers;
-  return observers[performance::NODE_PERFORMANCE_ENTRY_TYPE_HTTP2] != 0;
-}
-
 void Http2Stream::EmitStatistics() {
+  CHECK_NOT_NULL(session());
   if (!HasHttp2Observer(env()))
     return;
   auto entry =
-      std::make_unique<Http2StreamPerformanceEntry>(env(), id_, statistics_);
+      std::make_unique<Http2StreamPerformanceEntry>(
+          session()->http2_state(), id_, statistics_);
   env()->SetImmediate([entry = move(entry)](Environment* env) {
     if (!HasHttp2Observer(env))
       return;
     HandleScope handle_scope(env->isolate());
-    AliasedFloat64Array& buffer = env->http2_state()->stream_stats_buffer;
+    AliasedFloat64Array& buffer = entry->http2_state()->stream_stats_buffer;
     buffer[IDX_STREAM_STATS_ID] = entry->id();
     if (entry->first_byte() != 0) {
       buffer[IDX_STREAM_STATS_TIMETOFIRSTBYTE] =
@@ -633,8 +572,10 @@ void Http2Stream::EmitStatistics() {
     } else {
       buffer[IDX_STREAM_STATS_TIMETOFIRSTBYTESENT] = 0;
     }
-    buffer[IDX_STREAM_STATS_SENTBYTES] = entry->sent_bytes();
-    buffer[IDX_STREAM_STATS_RECEIVEDBYTES] = entry->received_bytes();
+    buffer[IDX_STREAM_STATS_SENTBYTES] =
+        static_cast<double>(entry->sent_bytes());
+    buffer[IDX_STREAM_STATS_RECEIVEDBYTES] =
+        static_cast<double>(entry->received_bytes());
     Local<Object> obj;
     if (entry->ToObject().ToLocal(&obj)) entry->Notify(obj);
   });
@@ -644,12 +585,12 @@ void Http2Session::EmitStatistics() {
   if (!HasHttp2Observer(env()))
     return;
   auto entry = std::make_unique<Http2SessionPerformanceEntry>(
-      env(), statistics_, session_type_);
+      http2_state(), statistics_, session_type_);
   env()->SetImmediate([entry = std::move(entry)](Environment* env) {
     if (!HasHttp2Observer(env))
       return;
     HandleScope handle_scope(env->isolate());
-    AliasedFloat64Array& buffer = env->http2_state()->session_stats_buffer;
+    AliasedFloat64Array& buffer = entry->http2_state()->session_stats_buffer;
     buffer[IDX_SESSION_STATS_TYPE] = entry->type();
     buffer[IDX_SESSION_STATS_PINGRTT] = entry->ping_rtt() / 1e6;
     buffer[IDX_SESSION_STATS_FRAMESRECEIVED] = entry->frame_count();
@@ -657,10 +598,12 @@ void Http2Session::EmitStatistics() {
     buffer[IDX_SESSION_STATS_STREAMCOUNT] = entry->stream_count();
     buffer[IDX_SESSION_STATS_STREAMAVERAGEDURATION] =
         entry->stream_average_duration();
-    buffer[IDX_SESSION_STATS_DATA_SENT] = entry->data_sent();
-    buffer[IDX_SESSION_STATS_DATA_RECEIVED] = entry->data_received();
+    buffer[IDX_SESSION_STATS_DATA_SENT] =
+        static_cast<double>(entry->data_sent());
+    buffer[IDX_SESSION_STATS_DATA_RECEIVED] =
+        static_cast<double>(entry->data_received());
     buffer[IDX_SESSION_STATS_MAX_CONCURRENT_STREAMS] =
-        entry->max_concurrent_streams();
+        static_cast<double>(entry->max_concurrent_streams());
     Local<Object> obj;
     if (entry->ToObject().ToLocal(&obj)) entry->Notify(obj);
   });
@@ -670,13 +613,13 @@ void Http2Session::EmitStatistics() {
 void Http2Session::Close(uint32_t code, bool socket_closed) {
   Debug(this, "closing session");
 
-  if (flags_ & SESSION_STATE_CLOSING)
+  if (is_closing())
     return;
-  flags_ |= SESSION_STATE_CLOSING;
+  set_closing();
 
   // Stop reading on the i/o stream
   if (stream_ != nullptr) {
-    flags_ |= SESSION_STATE_READING_STOPPED;
+    set_reading_stopped();
     stream_->ReadStop();
   }
 
@@ -686,16 +629,16 @@ void Http2Session::Close(uint32_t code, bool socket_closed) {
   // make a best effort.
   if (!socket_closed) {
     Debug(this, "terminating session with code %d", code);
-    CHECK_EQ(nghttp2_session_terminate_session(session_, code), 0);
+    CHECK_EQ(nghttp2_session_terminate_session(session_.get(), code), 0);
     SendPendingData();
   } else if (stream_ != nullptr) {
     stream_->RemoveStreamListener(this);
   }
 
-  flags_ |= SESSION_STATE_CLOSED;
+  set_destroyed();
 
   // If we are writing we will get to make the callback in OnStreamAfterWrite.
-  if ((flags_ & SESSION_STATE_WRITE_IN_PROGRESS) == 0) {
+  if (!is_write_in_progress()) {
     Debug(this, "make done session callback");
     HandleScope scope(env()->isolate());
     MakeCallback(env()->ondone_string(), 0, nullptr);
@@ -718,26 +661,26 @@ void Http2Session::Close(uint32_t code, bool socket_closed) {
 
 // Locates an existing known stream by ID. nghttp2 has a similar method
 // but this is faster and does not fail if the stream is not found.
-inline Http2Stream* Http2Session::FindStream(int32_t id) {
+BaseObjectPtr<Http2Stream> Http2Session::FindStream(int32_t id) {
   auto s = streams_.find(id);
-  return s != streams_.end() ? s->second : nullptr;
+  return s != streams_.end() ? s->second : BaseObjectPtr<Http2Stream>();
 }
 
-inline bool Http2Session::CanAddStream() {
+bool Http2Session::CanAddStream() {
   uint32_t maxConcurrentStreams =
       nghttp2_session_get_local_settings(
-          session_, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);
+          session_.get(), NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);
   size_t maxSize =
       std::min(streams_.max_size(), static_cast<size_t>(maxConcurrentStreams));
   // We can add a new stream so long as we are less than the current
   // maximum on concurrent streams and there's enough available memory
   return streams_.size() < maxSize &&
-         IsAvailableSessionMemory(sizeof(Http2Stream));
+         has_available_session_memory(sizeof(Http2Stream));
 }
 
-inline void Http2Session::AddStream(Http2Stream* stream) {
+void Http2Session::AddStream(Http2Stream* stream) {
   CHECK_GE(++statistics_.stream_count, 0);
-  streams_[stream->id()] = stream;
+  streams_[stream->id()] = BaseObjectPtr<Http2Stream>(stream);
   size_t size = streams_.size();
   if (size > statistics_.max_concurrent_streams)
     statistics_.max_concurrent_streams = size;
@@ -745,11 +688,16 @@ inline void Http2Session::AddStream(Http2Stream* stream) {
 }
 
 
-inline void Http2Session::RemoveStream(Http2Stream* stream) {
-  if (streams_.empty() || stream == nullptr)
-    return;  // Nothing to remove, item was never added?
-  streams_.erase(stream->id());
-  DecrementCurrentSessionMemory(sizeof(*stream));
+BaseObjectPtr<Http2Stream> Http2Session::RemoveStream(int32_t id) {
+  BaseObjectPtr<Http2Stream> stream;
+  if (streams_.empty())
+    return stream;
+  stream = FindStream(id);
+  if (stream) {
+    streams_.erase(id);
+    DecrementCurrentSessionMemory(sizeof(*stream));
+  }
+  return stream;
 }
 
 // Used as one of the Padding Strategy functions. Will attempt to ensure
@@ -779,32 +727,6 @@ ssize_t Http2Session::OnMaxFrameSizePadding(size_t frameLen,
   return maxPayloadLen;
 }
 
-// Used as one of the Padding Strategy functions. Uses a callback to JS land
-// to determine the amount of padding for the current frame. This option is
-// rather more expensive because of the JS boundary cross. It generally should
-// not be the preferred option.
-ssize_t Http2Session::OnCallbackPadding(size_t frameLen,
-                                        size_t maxPayloadLen) {
-  if (frameLen == 0) return 0;
-  Debug(this, "using callback to determine padding");
-  Isolate* isolate = env()->isolate();
-  HandleScope handle_scope(isolate);
-  Local<Context> context = env()->context();
-  Context::Scope context_scope(context);
-
-  AliasedUint32Array& buffer = env()->http2_state()->padding_buffer;
-  buffer[PADDING_BUF_FRAME_LENGTH] = frameLen;
-  buffer[PADDING_BUF_MAX_PAYLOAD_LENGTH] = maxPayloadLen;
-  buffer[PADDING_BUF_RETURN_VALUE] = frameLen;
-  MakeCallback(env()->http2session_on_select_padding_function(), 0, nullptr);
-  uint32_t retval = buffer[PADDING_BUF_RETURN_VALUE];
-  retval = std::min(retval, static_cast<uint32_t>(maxPayloadLen));
-  retval = std::max(retval, static_cast<uint32_t>(frameLen));
-  Debug(this, "using padding size %d", retval);
-  return retval;
-}
-
-
 // Write data received from the i/o stream to the underlying nghttp2_session.
 // On each call to nghttp2_session_mem_recv, nghttp2 will begin calling the
 // various callback functions. Each of these will typically result in a call
@@ -818,17 +740,17 @@ ssize_t Http2Session::ConsumeHTTP2Data() {
   // multiple side effects.
   Debug(this, "receiving %d bytes [wants data? %d]",
         read_len,
-        nghttp2_session_want_read(session_));
-  flags_ &= ~SESSION_STATE_NGHTTP2_RECV_PAUSED;
+        nghttp2_session_want_read(session_.get()));
+  set_receive_paused(false);
   ssize_t ret =
-    nghttp2_session_mem_recv(session_,
+    nghttp2_session_mem_recv(session_.get(),
                              reinterpret_cast<uint8_t*>(stream_buf_.base) +
                                  stream_buf_offset_,
                              read_len);
   CHECK_NE(ret, NGHTTP2_ERR_NOMEM);
 
-  if (flags_ & SESSION_STATE_NGHTTP2_RECV_PAUSED) {
-    CHECK_NE(flags_ & SESSION_STATE_READING_STOPPED, 0);
+  if (is_receive_paused()) {
+    CHECK(is_reading_stopped());
 
     CHECK_GT(ret, 0);
     CHECK_LE(static_cast<size_t>(ret), read_len);
@@ -851,14 +773,14 @@ ssize_t Http2Session::ConsumeHTTP2Data() {
     return ret;
 
   // Send any data that was queued up while processing the received data.
-  if (!IsDestroyed()) {
+  if (!is_destroyed()) {
     SendPendingData();
   }
   return ret;
 }
 
 
-inline int32_t GetFrameID(const nghttp2_frame* frame) {
+int32_t GetFrameID(const nghttp2_frame* frame) {
   // If this is a push promise, we want to grab the id of the promised stream
   return (frame->hd.type == NGHTTP2_PUSH_PROMISE) ?
       frame->push_promise.promised_stream_id :
@@ -877,26 +799,27 @@ int Http2Session::OnBeginHeadersCallback(nghttp2_session* handle,
   int32_t id = GetFrameID(frame);
   Debug(session, "beginning headers for stream %d", id);
 
-  Http2Stream* stream = session->FindStream(id);
+  BaseObjectPtr<Http2Stream> stream = session->FindStream(id);
   // The common case is that we're creating a new stream. The less likely
   // case is that we're receiving a set of trailers
-  if (LIKELY(stream == nullptr)) {
+  if (LIKELY(!stream)) {
     if (UNLIKELY(!session->CanAddStream() ||
                  Http2Stream::New(session, id, frame->headers.cat) ==
                      nullptr)) {
       if (session->rejected_stream_count_++ >
-              session->js_fields_.max_rejected_streams &&
-          !IsReverted(SECURITY_REVERT_CVE_2019_9514)) {
+          session->js_fields_->max_rejected_streams)
         return NGHTTP2_ERR_CALLBACK_FAILURE;
-      }
       // Too many concurrent streams being opened
-      nghttp2_submit_rst_stream(**session, NGHTTP2_FLAG_NONE, id,
-                                NGHTTP2_ENHANCE_YOUR_CALM);
+      nghttp2_submit_rst_stream(
+          session->session(),
+          NGHTTP2_FLAG_NONE,
+          id,
+          NGHTTP2_ENHANCE_YOUR_CALM);
       return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
     }
 
     session->rejected_stream_count_ = 0;
-  } else if (!stream->IsDestroyed()) {
+  } else if (!stream->is_destroyed()) {
     stream->StartHeaders(frame->headers.cat);
   }
   return 0;
@@ -913,15 +836,15 @@ int Http2Session::OnHeaderCallback(nghttp2_session* handle,
                                    void* user_data) {
   Http2Session* session = static_cast<Http2Session*>(user_data);
   int32_t id = GetFrameID(frame);
-  Http2Stream* stream = session->FindStream(id);
+  BaseObjectPtr<Http2Stream> stream = session->FindStream(id);
   // If stream is null at this point, either something odd has happened
   // or the stream was closed locally while header processing was occurring.
   // either way, do not proceed and close the stream.
-  if (UNLIKELY(stream == nullptr))
+  if (UNLIKELY(!stream))
     return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
 
   // If the stream has already been destroyed, ignore.
-  if (!stream->IsDestroyed() && !stream->AddHeader(name, value, flags)) {
+  if (!stream->is_destroyed() && !stream->AddHeader(name, value, flags)) {
     // This will only happen if the connected peer sends us more
     // than the allowed number of header items at any given time
     stream->SubmitRstStream(NGHTTP2_ENHANCE_YOUR_CALM);
@@ -981,13 +904,10 @@ int Http2Session::OnInvalidFrame(nghttp2_session* handle,
   Debug(session,
         "invalid frame received (%u/%u), code: %d",
         session->invalid_frame_count_,
-        session->js_fields_.max_invalid_frames,
+        session->js_fields_->max_invalid_frames,
         lib_error_code);
-  if (session->invalid_frame_count_++ >
-          session->js_fields_.max_invalid_frames &&
-      !IsReverted(SECURITY_REVERT_CVE_2019_9514)) {
+  if (session->invalid_frame_count_++ > session->js_fields_->max_invalid_frames)
     return 1;
-  }
 
   // If the error is fatal or if error code is ERR_STREAM_CLOSED... emit error
   if (nghttp2_is_fatal(lib_error_code) ||
@@ -1022,7 +942,7 @@ int Http2Session::OnFrameNotSent(nghttp2_session* handle,
   if (error_code == NGHTTP2_ERR_SESSION_CLOSING ||
       error_code == NGHTTP2_ERR_STREAM_CLOSED ||
       error_code == NGHTTP2_ERR_STREAM_CLOSING ||
-      session->js_fields_.frame_error_listener_count == 0) {
+      session->js_fields_->frame_error_listener_count == 0) {
     return 0;
   }
 
@@ -1062,10 +982,10 @@ int Http2Session::OnStreamClose(nghttp2_session* handle,
   Local<Context> context = env->context();
   Context::Scope context_scope(context);
   Debug(session, "stream %d closed with code: %d", id, code);
-  Http2Stream* stream = session->FindStream(id);
+  BaseObjectPtr<Http2Stream> stream = session->FindStream(id);
   // Intentionally ignore the callback if the stream does not exist or has
   // already been destroyed
-  if (stream == nullptr || stream->IsDestroyed())
+  if (!stream || stream->is_destroyed())
     return 0;
 
   stream->Close(code);
@@ -1077,8 +997,7 @@ int Http2Session::OnStreamClose(nghttp2_session* handle,
   MaybeLocal<Value> answer =
     stream->MakeCallback(env->http2session_on_stream_close_function(),
                           1, &arg);
-  if (answer.IsEmpty() ||
-      !(answer.ToLocalChecked()->BooleanValue(env->isolate()))) {
+  if (answer.IsEmpty() || answer.ToLocalChecked()->IsFalse()) {
     // Skip to destroy
     stream->Destroy();
   }
@@ -1124,9 +1043,10 @@ int Http2Session::OnDataChunkReceived(nghttp2_session* handle,
   // so that it can send a WINDOW_UPDATE frame. This is a critical part of
   // the flow control process in http2
   CHECK_EQ(nghttp2_session_consume_connection(handle, len), 0);
-  Http2Stream* stream = session->FindStream(id);
+  BaseObjectPtr<Http2Stream> stream = session->FindStream(id);
+
   // If the stream has been destroyed, ignore this chunk
-  if (stream->IsDestroyed())
+  if (!stream || stream->is_destroyed())
     return 0;
 
   stream->statistics_.received_bytes += len;
@@ -1158,7 +1078,7 @@ int Http2Session::OnDataChunkReceived(nghttp2_session* handle,
     // If the stream owner (e.g. the JS Http2Stream) wants more data, just
     // tell nghttp2 that all data has been consumed. Otherwise, defer until
     // more data is being requested.
-    if (stream->IsReading())
+    if (stream->is_reading())
       nghttp2_session_consume_stream(handle, id, avail);
     else
       stream->inbound_consumed_data_while_paused_ += avail;
@@ -1172,9 +1092,9 @@ int Http2Session::OnDataChunkReceived(nghttp2_session* handle,
 
   // If we are currently waiting for a write operation to finish, we should
   // tell nghttp2 that we want to wait before we process more input data.
-  if (session->flags_ & SESSION_STATE_WRITE_IN_PROGRESS) {
-    CHECK_NE(session->flags_ & SESSION_STATE_READING_STOPPED, 0);
-    session->flags_ |= SESSION_STATE_NGHTTP2_RECV_PAUSED;
+  if (session->is_write_in_progress()) {
+    CHECK(session->is_reading_stopped());
+    session->set_receive_paused();
     Debug(session, "receive paused");
     return NGHTTP2_ERR_PAUSE;
   }
@@ -1201,9 +1121,6 @@ ssize_t Http2Session::OnSelectPadding(nghttp2_session* handle,
     case PADDING_STRATEGY_ALIGNED:
       padding = session->OnDWordAlignedPadding(padding, maxPayloadLen);
       break;
-    case PADDING_STRATEGY_CALLBACK:
-      padding = session->OnCallbackPadding(padding, maxPayloadLen);
-      break;
   }
   return padding;
 }
@@ -1221,7 +1138,7 @@ int Http2Session::OnNghttpError(nghttp2_session* handle,
   // Unfortunately, this is currently the only way for us to know if
   // the session errored because the peer is not an http2 peer.
   Http2Session* session = static_cast<Http2Session*>(user_data);
-  Debug(session, "Error '%.*s'", len, message);
+  Debug(session, "Error '%s'", message);
   if (strncmp(message, BAD_PEER_MESSAGE, len) == 0) {
     Environment* env = session->env();
     Isolate* isolate = env->isolate();
@@ -1285,40 +1202,43 @@ void Http2Session::HandleHeadersFrame(const nghttp2_frame* frame) {
 
   int32_t id = GetFrameID(frame);
   Debug(this, "handle headers frame for stream %d", id);
-  Http2Stream* stream = FindStream(id);
+  BaseObjectPtr<Http2Stream> stream = FindStream(id);
 
   // If the stream has already been destroyed, ignore.
-  if (stream->IsDestroyed())
+  if (!stream || stream->is_destroyed())
     return;
 
-  std::vector<nghttp2_header> headers(stream->move_headers());
-  DecrementCurrentSessionMemory(stream->current_headers_length_);
-  stream->current_headers_length_ = 0;
-
-  // The headers are passed in above as a queue of nghttp2_header structs.
+  // The headers are stored as a vector of Http2Header instances.
   // The following converts that into a JS array with the structure:
   // [name1, value1, name2, value2, name3, value3, name3, value4] and so on.
   // That array is passed up to the JS layer and converted into an Object form
   // like {name1: value1, name2: value2, name3: [value3, value4]}. We do it
   // this way for performance reasons (it's faster to generate and pass an
   // array than it is to generate and pass the object).
-  size_t headers_size = headers.size();
-  std::vector<Local<Value>> headers_v(headers_size * 2);
-  for (size_t i = 0; i < headers_size; ++i) {
-    const nghttp2_header& item = headers[i];
-    // The header name and value are passed as external one-byte strings
-    headers_v[i * 2] =
-        ExternalHeader::New<true>(this, item.name).ToLocalChecked();
-    headers_v[i * 2 + 1] =
-        ExternalHeader::New<false>(this, item.value).ToLocalChecked();
-  }
-
-  Local<Value> args[5] = {
-      stream->object(),
-      Integer::New(isolate, id),
-      Integer::New(isolate, stream->headers_category()),
-      Integer::New(isolate, frame->hd.flags),
-      Array::New(isolate, headers_v.data(), headers_size * 2)};
+
+  MaybeStackBuffer<Local<Value>, 64> headers_v(stream->headers_count() * 2);
+  MaybeStackBuffer<Local<Value>, 32> sensitive_v(stream->headers_count());
+  size_t sensitive_count = 0;
+
+  stream->TransferHeaders([&](const Http2Header& header, size_t i) {
+    headers_v[i * 2] = header.GetName(this).ToLocalChecked();
+    headers_v[i * 2 + 1] = header.GetValue(this).ToLocalChecked();
+    if (header.flags() & NGHTTP2_NV_FLAG_NO_INDEX)
+      sensitive_v[sensitive_count++] = headers_v[i * 2];
+  });
+  CHECK_EQ(stream->headers_count(), 0);
+
+  DecrementCurrentSessionMemory(stream->current_headers_length_);
+  stream->current_headers_length_ = 0;
+
+  Local<Value> args[] = {
+    stream->object(),
+    Integer::New(isolate, id),
+    Integer::New(isolate, stream->headers_category()),
+    Integer::New(isolate, frame->hd.flags),
+    Array::New(isolate, headers_v.out(), headers_v.length()),
+    Array::New(isolate, sensitive_v.out(), sensitive_count),
+  };
   MakeCallback(env()->http2session_on_headers_function(),
                arraysize(args), args);
 }
@@ -1329,7 +1249,7 @@ void Http2Session::HandleHeadersFrame(const nghttp2_frame* frame) {
 // are considered advisory only, so this has no real effect other than to
 // simply let user code know that the priority has changed.
 void Http2Session::HandlePriorityFrame(const nghttp2_frame* frame) {
-  if (js_fields_.priority_listener_count == 0) return;
+  if (js_fields_->priority_listener_count == 0) return;
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
   Local<Context> context = env()->context();
@@ -1358,13 +1278,18 @@ void Http2Session::HandlePriorityFrame(const nghttp2_frame* frame) {
 int Http2Session::HandleDataFrame(const nghttp2_frame* frame) {
   int32_t id = GetFrameID(frame);
   Debug(this, "handling data frame for stream %d", id);
-  Http2Stream* stream = FindStream(id);
+  BaseObjectPtr<Http2Stream> stream = FindStream(id);
 
-  if (!stream->IsDestroyed() && frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
+  if (stream &&
+      !stream->is_destroyed() &&
+      frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
     stream->EmitRead(UV_EOF);
-  } else if (frame->hd.length == 0 &&
-           !IsReverted(SECURITY_REVERT_CVE_2019_9518)) {
-    return 1;  // Consider 0-length frame without END_STREAM an error.
+  } else if (frame->hd.length == 0) {
+    if (invalid_frame_count_++ > js_fields_->max_invalid_frames) {
+      Debug(this, "rejecting empty-frame-without-END_STREAM flood\n");
+      // Consider a flood of 0-length frames without END_STREAM an error.
+      return 1;
+    }
   }
   return 0;
 }
@@ -1388,6 +1313,9 @@ void Http2Session::HandleGoawayFrame(const nghttp2_frame* frame) {
 
   size_t length = goaway_frame.opaque_data_len;
   if (length > 0) {
+    // If the copy fails for any reason here, we just ignore it.
+    // The additional goaway data is completely optional and we
+    // shouldn't fail if we're not able to process it.
     argv[2] = Buffer::Copy(isolate,
                            reinterpret_cast<char*>(goaway_frame.opaque_data),
                            length).ToLocalChecked();
@@ -1399,7 +1327,7 @@ void Http2Session::HandleGoawayFrame(const nghttp2_frame* frame) {
 
 // Called by OnFrameReceived when a complete ALTSVC frame has been received.
 void Http2Session::HandleAltSvcFrame(const nghttp2_frame* frame) {
-  if (!(js_fields_.bitfield & (1 << kSessionHasAltsvcListeners))) return;
+  if (!(js_fields_->bitfield & (1 << kSessionHasAltsvcListeners))) return;
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
   Local<Context> context = env()->context();
@@ -1413,14 +1341,8 @@ void Http2Session::HandleAltSvcFrame(const nghttp2_frame* frame) {
 
   Local<Value> argv[3] = {
     Integer::New(isolate, id),
-    String::NewFromOneByte(isolate,
-                           altsvc->origin,
-                           NewStringType::kNormal,
-                           altsvc->origin_len).ToLocalChecked(),
-    String::NewFromOneByte(isolate,
-                           altsvc->field_value,
-                           NewStringType::kNormal,
-                           altsvc->field_value_len).ToLocalChecked(),
+    OneByteString(isolate, altsvc->origin, altsvc->origin_len),
+    OneByteString(isolate, altsvc->field_value, altsvc->field_value_len)
   };
 
   MakeCallback(env()->http2session_on_altsvc_function(),
@@ -1443,10 +1365,7 @@ void Http2Session::HandleOriginFrame(const nghttp2_frame* frame) {
 
   for (size_t i = 0; i < nov; ++i) {
     const nghttp2_origin_entry& entry = origin->ov[i];
-    origin_v[i] =
-        String::NewFromOneByte(
-            isolate, entry.origin, NewStringType::kNormal, entry.origin_len)
-            .ToLocalChecked();
+    origin_v[i] = OneByteString(isolate, entry.origin, entry.origin_len);
   }
   Local<Value> holder = Array::New(isolate, origin_v.data(), origin_v.size());
   MakeCallback(env()->http2session_on_origin_function(), 1, &holder);
@@ -1478,11 +1397,12 @@ void Http2Session::HandlePingFrame(const nghttp2_frame* frame) {
     return;
   }
 
-  if (!(js_fields_.bitfield & (1 << kSessionHasPingListeners))) return;
+  if (!(js_fields_->bitfield & (1 << kSessionHasPingListeners))) return;
   // Notify the session that a ping occurred
-  arg = Buffer::Copy(env(),
-                      reinterpret_cast<const char*>(frame->ping.opaque_data),
-                      8).ToLocalChecked();
+  arg = Buffer::Copy(
+      env(),
+      reinterpret_cast<const char*>(frame->ping.opaque_data),
+      8).ToLocalChecked();
   MakeCallback(env()->http2session_on_ping_function(), 1, &arg);
 }
 
@@ -1490,8 +1410,8 @@ void Http2Session::HandlePingFrame(const nghttp2_frame* frame) {
 void Http2Session::HandleSettingsFrame(const nghttp2_frame* frame) {
   bool ack = frame->hd.flags & NGHTTP2_FLAG_ACK;
   if (!ack) {
-    js_fields_.bitfield &= ~(1 << kSessionRemoteSettingsIsUpToDate);
-    if (!(js_fields_.bitfield & (1 << kSessionHasRemoteSettingsListeners)))
+    js_fields_->bitfield &= ~(1 << kSessionRemoteSettingsIsUpToDate);
+    if (!(js_fields_->bitfield & (1 << kSessionHasRemoteSettingsListeners)))
       return;
     // This is not a SETTINGS acknowledgement, notify and return
     MakeCallback(env()->http2session_on_settings_function(), 0, nullptr);
@@ -1526,20 +1446,20 @@ void Http2Session::HandleSettingsFrame(const nghttp2_frame* frame) {
 void Http2Session::OnStreamAfterWrite(WriteWrap* w, int status) {
   Debug(this, "write finished with status %d", status);
 
-  CHECK_NE(flags_ & SESSION_STATE_WRITE_IN_PROGRESS, 0);
-  flags_ &= ~SESSION_STATE_WRITE_IN_PROGRESS;
+  CHECK(is_write_in_progress());
+  set_write_in_progress(false);
 
   // Inform all pending writes about their completion.
   ClearOutgoing(status);
 
-  if ((flags_ & SESSION_STATE_READING_STOPPED) &&
-      !(flags_ & SESSION_STATE_WRITE_IN_PROGRESS) &&
-      nghttp2_session_want_read(session_)) {
-    flags_ &= ~SESSION_STATE_READING_STOPPED;
+  if (is_reading_stopped() &&
+      !is_write_in_progress() &&
+      nghttp2_session_want_read(session_.get())) {
+    set_reading_stopped(false);
     stream_->ReadStart();
   }
 
-  if ((flags_ & SESSION_STATE_CLOSED) != 0) {
+  if (is_destroyed()) {
     HandleScope scope(env()->isolate());
     MakeCallback(env()->ondone_string(), 0, nullptr);
     return;
@@ -1550,7 +1470,7 @@ void Http2Session::OnStreamAfterWrite(WriteWrap* w, int status) {
     ConsumeHTTP2Data();
   }
 
-  if (!(flags_ & SESSION_STATE_WRITE_SCHEDULED)) {
+  if (!is_write_scheduled()) {
     // Schedule a new write if nghttp2 wants to send data.
     MaybeScheduleWrite();
   }
@@ -1561,17 +1481,17 @@ void Http2Session::OnStreamAfterWrite(WriteWrap* w, int status) {
 // on the next iteration of the Node.js event loop (using the SetImmediate
 // queue), but only if a write has not already been scheduled.
 void Http2Session::MaybeScheduleWrite() {
-  CHECK_EQ(flags_ & SESSION_STATE_WRITE_SCHEDULED, 0);
-  if (UNLIKELY(session_ == nullptr))
+  CHECK(!is_write_scheduled());
+  if (UNLIKELY(!session_))
     return;
 
-  if (nghttp2_session_want_write(session_)) {
+  if (nghttp2_session_want_write(session_.get())) {
     HandleScope handle_scope(env()->isolate());
     Debug(this, "scheduling write");
-    flags_ |= SESSION_STATE_WRITE_SCHEDULED;
+    set_write_scheduled();
     BaseObjectPtr<Http2Session> strong_ref{this};
     env()->SetImmediate([this, strong_ref](Environment* env) {
-      if (session_ == nullptr || !(flags_ & SESSION_STATE_WRITE_SCHEDULED)) {
+      if (!session_ || !is_write_scheduled()) {
         // This can happen e.g. when a stream was reset before this turn
         // of the event loop, in which case SendPendingData() is called early,
         // or the session was destroyed in the meantime.
@@ -1588,11 +1508,11 @@ void Http2Session::MaybeScheduleWrite() {
 }
 
 void Http2Session::MaybeStopReading() {
-  if (flags_ & SESSION_STATE_READING_STOPPED) return;
-  int want_read = nghttp2_session_want_read(session_);
+  if (is_reading_stopped()) return;
+  int want_read = nghttp2_session_want_read(session_.get());
   Debug(this, "wants read? %d", want_read);
-  if (want_read == 0 || (flags_ & SESSION_STATE_WRITE_IN_PROGRESS)) {
-    flags_ |= SESSION_STATE_READING_STOPPED;
+  if (want_read == 0 || is_write_in_progress()) {
+    set_reading_stopped();
     stream_->ReadStop();
   }
 }
@@ -1600,23 +1520,23 @@ void Http2Session::MaybeStopReading() {
 // Unset the sending state, finish up all current writes, and reset
 // storage for data and metadata that was associated with these writes.
 void Http2Session::ClearOutgoing(int status) {
-  CHECK_NE(flags_ & SESSION_STATE_SENDING, 0);
+  CHECK(is_sending());
 
-  flags_ &= ~SESSION_STATE_SENDING;
+  set_sending(false);
 
   if (!outgoing_buffers_.empty()) {
     outgoing_storage_.clear();
     outgoing_length_ = 0;
 
-    std::vector<nghttp2_stream_write> current_outgoing_buffers_;
+    std::vector<NgHttp2StreamWrite> current_outgoing_buffers_;
     current_outgoing_buffers_.swap(outgoing_buffers_);
-    for (const nghttp2_stream_write& wr : current_outgoing_buffers_) {
-      WriteWrap* wrap = wr.req_wrap;
-      if (wrap != nullptr) {
+    for (const NgHttp2StreamWrite& wr : current_outgoing_buffers_) {
+      BaseObjectPtr<AsyncWrap> wrap = std::move(wr.req_wrap);
+      if (wrap) {
         // TODO(addaleax): Pass `status` instead of 0, so that we actually error
         // out with the error from the write to the underlying protocol,
         // if one occurred.
-        wrap->Done(0);
+        WriteWrap::FromObject(wrap)->Done(0);
       }
     }
   }
@@ -1630,14 +1550,14 @@ void Http2Session::ClearOutgoing(int status) {
     SendPendingData();
 
     for (int32_t stream_id : current_pending_rst_streams) {
-      Http2Stream* stream = FindStream(stream_id);
-      if (LIKELY(stream != nullptr))
+      BaseObjectPtr<Http2Stream> stream = FindStream(stream_id);
+      if (LIKELY(stream))
         stream->FlushRstStream();
     }
   }
 }
 
-void Http2Session::PushOutgoingBuffer(nghttp2_stream_write&& write) {
+void Http2Session::PushOutgoingBuffer(NgHttp2StreamWrite&& write) {
   outgoing_length_ += write.buf.len;
   outgoing_buffers_.emplace_back(std::move(write));
 }
@@ -1654,7 +1574,7 @@ void Http2Session::CopyDataIntoOutgoing(const uint8_t* src, size_t src_length) {
   // of the outgoing_buffers_ vector may invalidate the pointer.
   // The correct base pointers will be set later, before writing to the
   // underlying socket.
-  PushOutgoingBuffer(nghttp2_stream_write {
+  PushOutgoingBuffer(NgHttp2StreamWrite {
     uv_buf_init(nullptr, src_length)
   });
 }
@@ -1669,15 +1589,15 @@ uint8_t Http2Session::SendPendingData() {
   // Do not attempt to send data on the socket if the destroying flag has
   // been set. That means everything is shutting down and the socket
   // will not be usable.
-  if (IsDestroyed())
+  if (is_destroyed())
     return 0;
-  flags_ &= ~SESSION_STATE_WRITE_SCHEDULED;
+  set_write_scheduled(false);
 
   // SendPendingData should not be called recursively.
-  if (flags_ & SESSION_STATE_SENDING)
+  if (is_sending())
     return 1;
   // This is cleared by ClearOutgoing().
-  flags_ |= SESSION_STATE_SENDING;
+  set_sending();
 
   ssize_t src_length;
   const uint8_t* src;
@@ -1687,7 +1607,7 @@ uint8_t Http2Session::SendPendingData() {
 
   // Part One: Gather data from nghttp2
 
-  while ((src_length = nghttp2_session_mem_send(session_, &src)) > 0) {
+  while ((src_length = nghttp2_session_mem_send(session_.get(), &src)) > 0) {
     Debug(this, "nghttp2 has %d bytes to send", src_length);
     CopyDataIntoOutgoing(src, src_length);
   }
@@ -1717,7 +1637,7 @@ uint8_t Http2Session::SendPendingData() {
   // (Those are marked by having .base == nullptr.)
   size_t offset = 0;
   size_t i = 0;
-  for (const nghttp2_stream_write& write : outgoing_buffers_) {
+  for (const NgHttp2StreamWrite& write : outgoing_buffers_) {
     statistics_.data_sent += write.buf.len;
     if (write.buf.base == nullptr) {
       bufs[i++] = uv_buf_init(
@@ -1731,11 +1651,11 @@ uint8_t Http2Session::SendPendingData() {
 
   chunks_sent_since_last_write_++;
 
-  CHECK_EQ(flags_ & SESSION_STATE_WRITE_IN_PROGRESS, 0);
-  flags_ |= SESSION_STATE_WRITE_IN_PROGRESS;
+  CHECK(!is_write_in_progress());
+  set_write_in_progress();
   StreamWriteResult res = underlying_stream()->Write(*bufs, count);
   if (!res.async) {
-    flags_ &= ~SESSION_STATE_WRITE_IN_PROGRESS;
+    set_write_in_progress(false);
     ClearOutgoing(res.err);
   }
 
@@ -1757,7 +1677,8 @@ int Http2Session::OnSendData(
       nghttp2_data_source* source,
       void* user_data) {
   Http2Session* session = static_cast<Http2Session*>(user_data);
-  Http2Stream* stream = GetStream(session, frame->hd.stream_id, source);
+  BaseObjectPtr<Http2Stream> stream = session->FindStream(frame->hd.stream_id);
+  if (!stream) return 0;
 
   // Send the frame header + a byte that indicates padding length.
   session->CopyDataIntoOutgoing(framehd, 9);
@@ -1773,7 +1694,7 @@ int Http2Session::OnSendData(
     // we told it so, which means that we *should* have data available.
     CHECK(!stream->queue_.empty());
 
-    nghttp2_stream_write& write = stream->queue_.front();
+    NgHttp2StreamWrite& write = stream->queue_.front();
     if (write.buf.len <= length) {
       // This write does not suffice by itself, so we can consume it completely.
       length -= write.buf.len;
@@ -1783,7 +1704,7 @@ int Http2Session::OnSendData(
     }
 
     // Slice off `length` bytes of the first write in the queue.
-    session->PushOutgoingBuffer(nghttp2_stream_write {
+    session->PushOutgoingBuffer(NgHttp2StreamWrite {
       uv_buf_init(write.buf.base, length)
     });
     write.buf.base += length;
@@ -1793,7 +1714,7 @@ int Http2Session::OnSendData(
 
   if (frame->data.padlen > 0) {
     // Send padding if that was requested.
-    session->PushOutgoingBuffer(nghttp2_stream_write {
+    session->PushOutgoingBuffer(NgHttp2StreamWrite {
       uv_buf_init(const_cast<char*>(zero_bytes_256), frame->data.padlen - 1)
     });
   }
@@ -1803,16 +1724,21 @@ int Http2Session::OnSendData(
 
 // Creates a new Http2Stream and submits a new http2 request.
 Http2Stream* Http2Session::SubmitRequest(
-    nghttp2_priority_spec* prispec,
-    nghttp2_nv* nva,
-    size_t len,
+    const Http2Priority& priority,
+    const Http2Headers& headers,
     int32_t* ret,
     int options) {
   Debug(this, "submitting request");
   Http2Scope h2scope(this);
   Http2Stream* stream = nullptr;
   Http2Stream::Provider::Stream prov(options);
-  *ret = nghttp2_submit_request(session_, prispec, nva, len, *prov, nullptr);
+  *ret = nghttp2_submit_request(
+      session_.get(),
+      &priority,
+      headers.data(),
+      headers.length(),
+      *prov,
+      nullptr);
   CHECK_NE(*ret, NGHTTP2_ERR_NOMEM);
   if (LIKELY(*ret > 0))
     stream = Http2Stream::New(this, *ret, NGHTTP2_HCAT_HEADERS, options);
@@ -1820,7 +1746,7 @@ Http2Stream* Http2Session::SubmitRequest(
 }
 
 uv_buf_t Http2Session::OnStreamAlloc(size_t suggested_size) {
-  return env()->AllocateManaged(suggested_size).release();
+  return AllocatedBuffer::AllocateManaged(env(), suggested_size).release();
 }
 
 // Callback used to receive inbound data from the i/o stream
@@ -1851,7 +1777,8 @@ void Http2Session::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
     // happen, we concatenate the data we received with the already-stored
     // pending input data, slicing off the already processed part.
     size_t pending_len = stream_buf_.len - stream_buf_offset_;
-    AllocatedBuffer new_buf = env()->AllocateManaged(pending_len + nread);
+    AllocatedBuffer new_buf =
+        AllocatedBuffer::AllocateManaged(env(), pending_len + nread);
     memcpy(new_buf.data(), stream_buf_.base + stream_buf_offset_, pending_len);
     memcpy(new_buf.data() + pending_len, buf.data(), nread);
 
@@ -1869,7 +1796,7 @@ void Http2Session::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
 
   // Remember the current buffer, so that OnDataChunkReceived knows the
   // offset of a DATA frame's data into the socket read buffer.
-  stream_buf_ = uv_buf_init(buf.data(), nread);
+  stream_buf_ = uv_buf_init(buf.data(), static_cast<unsigned int>(nread));
 
   Isolate* isolate = env()->isolate();
 
@@ -1882,7 +1809,7 @@ void Http2Session::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
 
   if (UNLIKELY(ret < 0)) {
     Debug(this, "fatal error receiving data: %d", ret);
-    Local<Value> arg = Integer::New(isolate, ret);
+    Local<Value> arg = Integer::New(isolate, static_cast<int32_t>(ret));
     MakeCallback(env()->http2session_on_error_function(), 1, &arg);
     return;
   }
@@ -1891,8 +1818,8 @@ void Http2Session::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
 }
 
 bool Http2Session::HasWritesOnSocketForStream(Http2Stream* stream) {
-  for (const nghttp2_stream_write& wr : outgoing_buffers_) {
-    if (wr.req_wrap != nullptr && wr.req_wrap->stream() == stream)
+  for (const NgHttp2StreamWrite& wr : outgoing_buffers_) {
+    if (wr.req_wrap && WriteWrap::FromObject(wr.req_wrap)->stream() == stream)
       return true;
   }
   return false;
@@ -1908,6 +1835,33 @@ void Http2Session::Consume(Local<Object> stream_obj) {
   Debug(this, "i/o stream consumed");
 }
 
+// Allow injecting of data from JS
+// This is used when the socket has already some data received
+// before our listener was attached
+// https://github.com/nodejs/node/issues/35475
+void Http2Session::Receive(const FunctionCallbackInfo<Value>& args) {
+  Http2Session* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
+  CHECK(args[0]->IsObject());
+
+  ArrayBufferViewContents<char> buffer(args[0]);
+  const char* data = buffer.data();
+  size_t len = buffer.length();
+  Debug(session, "Receiving %zu bytes injected from JS", len);
+
+  // Copy given buffer
+  while (len > 0) {
+    uv_buf_t buf = session->OnStreamAlloc(len);
+    size_t copy = buf.len > len ? len : buf.len;
+    memcpy(buf.base, data, copy);
+    buf.len = copy;
+    session->OnStreamRead(copy, buf);
+
+    data += copy;
+    len -= copy;
+  }
+}
+
 Http2Stream* Http2Stream::New(Http2Session* session,
                               int32_t id,
                               nghttp2_headers_category category,
@@ -1937,7 +1891,7 @@ Http2Stream::Http2Stream(Http2Session* session,
   statistics_.start_time = uv_hrtime();
 
   // Limit the number of header pairs
-  max_header_pairs_ = session->GetMaxHeaderPairs();
+  max_header_pairs_ = session->max_header_pairs();
   if (max_header_pairs_ == 0) {
     max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;
   }
@@ -1952,7 +1906,7 @@ Http2Stream::Http2Stream(Http2Session* session,
       MAX_MAX_HEADER_LIST_SIZE);
 
   if (options & STREAM_OPTION_GET_TRAILERS)
-    flags_ |= NGHTTP2_STREAM_FLAG_TRAILERS;
+    set_has_trailers();
 
   PushStreamListener(&stream_listener_);
 
@@ -1961,18 +1915,13 @@ Http2Stream::Http2Stream(Http2Session* session,
   session->AddStream(this);
 }
 
-
 Http2Stream::~Http2Stream() {
-  for (nghttp2_header& header : current_headers_) {
-    nghttp2_rcbuf_decref(header.name);
-    nghttp2_rcbuf_decref(header.value);
-  }
-
-  if (!session_)
-    return;
   Debug(this, "tearing down stream");
-  session_->DecrementCurrentSessionMemory(current_headers_length_);
-  session_->RemoveStream(this);
+}
+
+void Http2Stream::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("current_headers", current_headers_);
+  tracker->TrackField("queue", queue_);
 }
 
 std::string Http2Stream::diagnostic_name() const {
@@ -1984,7 +1933,7 @@ std::string Http2Stream::diagnostic_name() const {
 // Notify the Http2Stream that a new block of HEADERS is being processed.
 void Http2Stream::StartHeaders(nghttp2_headers_category category) {
   Debug(this, "starting headers, category: %d", category);
-  CHECK(!this->IsDestroyed());
+  CHECK(!this->is_destroyed());
   session_->DecrementCurrentSessionMemory(current_headers_length_);
   current_headers_length_ = 0;
   current_headers_.clear();
@@ -1992,13 +1941,15 @@ void Http2Stream::StartHeaders(nghttp2_headers_category category) {
 }
 
 
-nghttp2_stream* Http2Stream::operator*() {
-  return nghttp2_session_find_stream(**session_, id_);
+nghttp2_stream* Http2Stream::operator*() const { return stream(); }
+
+nghttp2_stream* Http2Stream::stream() const {
+  return nghttp2_session_find_stream(session_->session(), id_);
 }
 
 void Http2Stream::Close(int32_t code) {
-  CHECK(!this->IsDestroyed());
-  flags_ |= NGHTTP2_STREAM_FLAG_CLOSED;
+  CHECK(!this->is_destroyed());
+  set_closed();
   code_ = code;
   Debug(this, "closed with code %d", code);
 }
@@ -2010,14 +1961,15 @@ ShutdownWrap* Http2Stream::CreateShutdownWrap(v8::Local<v8::Object> object) {
 }
 
 int Http2Stream::DoShutdown(ShutdownWrap* req_wrap) {
-  if (IsDestroyed())
+  if (is_destroyed())
     return UV_EPIPE;
 
   {
     Http2Scope h2scope(this);
-    flags_ |= NGHTTP2_STREAM_FLAG_SHUT;
-    CHECK_NE(nghttp2_session_resume_data(**session_, id_),
-             NGHTTP2_ERR_NOMEM);
+    set_not_writable();
+    CHECK_NE(nghttp2_session_resume_data(
+        session_->session(), id_),
+        NGHTTP2_ERR_NOMEM);
     Debug(this, "writable side shutdown");
   }
   return 1;
@@ -2028,36 +1980,40 @@ int Http2Stream::DoShutdown(ShutdownWrap* req_wrap) {
 // using the SetImmediate queue.
 void Http2Stream::Destroy() {
   // Do nothing if this stream instance is already destroyed
-  if (IsDestroyed())
+  if (is_destroyed())
     return;
-  if (session_->HasPendingRstStream(id_))
+  if (session_->has_pending_rststream(id_))
     FlushRstStream();
-  flags_ |= NGHTTP2_STREAM_FLAG_DESTROYED;
+  set_destroyed();
 
   Debug(this, "destroying stream");
 
   // Wait until the start of the next loop to delete because there
   // may still be some pending operations queued for this stream.
-  BaseObjectPtr<Http2Stream> strong_ref{this};
-  env()->SetImmediate([this, strong_ref](Environment* env) {
-    // Free any remaining outgoing data chunks here. This should be done
-    // here because it's possible for destroy to have been called while
-    // we still have queued outbound writes.
-    while (!queue_.empty()) {
-      nghttp2_stream_write& head = queue_.front();
-      if (head.req_wrap != nullptr)
-        head.req_wrap->Done(UV_ECANCELED);
-      queue_.pop();
-    }
+  BaseObjectPtr<Http2Stream> strong_ref = session_->RemoveStream(id_);
+  if (strong_ref) {
+    env()->SetImmediate([this, strong_ref = std::move(strong_ref)](
+        Environment* env) {
+      // Free any remaining outgoing data chunks here. This should be done
+      // here because it's possible for destroy to have been called while
+      // we still have queued outbound writes.
+      while (!queue_.empty()) {
+        NgHttp2StreamWrite& head = queue_.front();
+        if (head.req_wrap)
+          WriteWrap::FromObject(head.req_wrap)->Done(UV_ECANCELED);
+        queue_.pop();
+      }
 
-    // We can destroy the stream now if there are no writes for it
-    // already on the socket. Otherwise, we'll wait for the garbage collector
-    // to take care of cleaning up.
-    if (session() == nullptr || !session()->HasWritesOnSocketForStream(this)) {
-      // Delete once strong_ref goes out of scope.
-      Detach();
-    }
-  });
+      // We can destroy the stream now if there are no writes for it
+      // already on the socket. Otherwise, we'll wait for the garbage collector
+      // to take care of cleaning up.
+      if (session() == nullptr ||
+          !session()->HasWritesOnSocketForStream(this)) {
+        // Delete once strong_ref goes out of scope.
+        Detach();
+      }
+    });
+  }
 
   statistics_.end_time = uv_hrtime();
   session_->statistics_.stream_average_duration =
@@ -2069,78 +2025,98 @@ void Http2Stream::Destroy() {
 
 // Initiates a response on the Http2Stream using data provided via the
 // StreamBase Streams API.
-int Http2Stream::SubmitResponse(nghttp2_nv* nva, size_t len, int options) {
-  CHECK(!this->IsDestroyed());
+int Http2Stream::SubmitResponse(const Http2Headers& headers, int options) {
+  CHECK(!this->is_destroyed());
   Http2Scope h2scope(this);
   Debug(this, "submitting response");
   if (options & STREAM_OPTION_GET_TRAILERS)
-    flags_ |= NGHTTP2_STREAM_FLAG_TRAILERS;
+    set_has_trailers();
 
-  if (!IsWritable())
+  if (!is_writable())
     options |= STREAM_OPTION_EMPTY_PAYLOAD;
 
   Http2Stream::Provider::Stream prov(this, options);
-  int ret = nghttp2_submit_response(**session_, id_, nva, len, *prov);
+  int ret = nghttp2_submit_response(
+      session_->session(),
+      id_,
+      headers.data(),
+      headers.length(),
+      *prov);
   CHECK_NE(ret, NGHTTP2_ERR_NOMEM);
   return ret;
 }
 
 
 // Submit informational headers for a stream.
-int Http2Stream::SubmitInfo(nghttp2_nv* nva, size_t len) {
-  CHECK(!this->IsDestroyed());
+int Http2Stream::SubmitInfo(const Http2Headers& headers) {
+  CHECK(!this->is_destroyed());
   Http2Scope h2scope(this);
-  Debug(this, "sending %d informational headers", len);
-  int ret = nghttp2_submit_headers(**session_,
-                                   NGHTTP2_FLAG_NONE,
-                                   id_, nullptr,
-                                   nva, len, nullptr);
+  Debug(this, "sending %d informational headers", headers.length());
+  int ret = nghttp2_submit_headers(
+      session_->session(),
+      NGHTTP2_FLAG_NONE,
+      id_,
+      nullptr,
+      headers.data(),
+      headers.length(),
+      nullptr);
   CHECK_NE(ret, NGHTTP2_ERR_NOMEM);
   return ret;
 }
 
 void Http2Stream::OnTrailers() {
   Debug(this, "let javascript know we are ready for trailers");
-  CHECK(!this->IsDestroyed());
+  CHECK(!this->is_destroyed());
   Isolate* isolate = env()->isolate();
   HandleScope scope(isolate);
   Local<Context> context = env()->context();
   Context::Scope context_scope(context);
-  flags_ &= ~NGHTTP2_STREAM_FLAG_TRAILERS;
+  set_has_trailers(false);
   MakeCallback(env()->http2session_on_stream_trailers_function(), 0, nullptr);
 }
 
 // Submit informational headers for a stream.
-int Http2Stream::SubmitTrailers(nghttp2_nv* nva, size_t len) {
-  CHECK(!this->IsDestroyed());
+int Http2Stream::SubmitTrailers(const Http2Headers& headers) {
+  CHECK(!this->is_destroyed());
   Http2Scope h2scope(this);
-  Debug(this, "sending %d trailers", len);
+  Debug(this, "sending %d trailers", headers.length());
   int ret;
   // Sending an empty trailers frame poses problems in Safari, Edge & IE.
   // Instead we can just send an empty data frame with NGHTTP2_FLAG_END_STREAM
   // to indicate that the stream is ready to be closed.
-  if (len == 0) {
+  if (headers.length() == 0) {
     Http2Stream::Provider::Stream prov(this, 0);
-    ret = nghttp2_submit_data(**session_, NGHTTP2_FLAG_END_STREAM, id_, *prov);
+    ret = nghttp2_submit_data(
+        session_->session(),
+        NGHTTP2_FLAG_END_STREAM,
+        id_,
+        *prov);
   } else {
-    ret = nghttp2_submit_trailer(**session_, id_, nva, len);
+    ret = nghttp2_submit_trailer(
+        session_->session(),
+        id_,
+        headers.data(),
+        headers.length());
   }
   CHECK_NE(ret, NGHTTP2_ERR_NOMEM);
   return ret;
 }
 
 // Submit a PRIORITY frame to the connected peer.
-int Http2Stream::SubmitPriority(nghttp2_priority_spec* prispec,
+int Http2Stream::SubmitPriority(const Http2Priority& priority,
                                 bool silent) {
-  CHECK(!this->IsDestroyed());
+  CHECK(!this->is_destroyed());
   Http2Scope h2scope(this);
   Debug(this, "sending priority spec");
   int ret = silent ?
-      nghttp2_session_change_stream_priority(**session_,
-                                             id_, prispec) :
-      nghttp2_submit_priority(**session_,
-                              NGHTTP2_FLAG_NONE,
-                              id_, prispec);
+      nghttp2_session_change_stream_priority(
+          session_->session(),
+          id_,
+          &priority) :
+      nghttp2_submit_priority(
+          session_->session(),
+          NGHTTP2_FLAG_NONE,
+          id_, &priority);
   CHECK_NE(ret, NGHTTP2_ERR_NOMEM);
   return ret;
 }
@@ -2148,7 +2124,7 @@ int Http2Stream::SubmitPriority(nghttp2_priority_spec* prispec,
 // Closes the Http2Stream by submitting an RST_STREAM frame to the connected
 // peer.
 void Http2Stream::SubmitRstStream(const uint32_t code) {
-  CHECK(!this->IsDestroyed());
+  CHECK(!this->is_destroyed());
   code_ = code;
 
   auto is_stream_cancel = [](const uint32_t code) {
@@ -2168,6 +2144,7 @@ void Http2Stream::SubmitRstStream(const uint32_t code) {
       return;
   }
 
+
   // If possible, force a purge of any currently pending data here to make sure
   // it is sent before closing the stream. If it returns non-zero then we need
   // to wait until the current write finishes and try again to avoid nghttp2
@@ -2181,24 +2158,31 @@ void Http2Stream::SubmitRstStream(const uint32_t code) {
 }
 
 void Http2Stream::FlushRstStream() {
-  if (IsDestroyed())
+  if (is_destroyed())
     return;
   Http2Scope h2scope(this);
-  CHECK_EQ(nghttp2_submit_rst_stream(**session_, NGHTTP2_FLAG_NONE,
-                                     id_, code_), 0);
+  CHECK_EQ(nghttp2_submit_rst_stream(
+      session_->session(),
+      NGHTTP2_FLAG_NONE,
+      id_,
+      code_), 0);
 }
 
 
 // Submit a push promise and create the associated Http2Stream if successful.
-Http2Stream* Http2Stream::SubmitPushPromise(nghttp2_nv* nva,
-                                            size_t len,
+Http2Stream* Http2Stream::SubmitPushPromise(const Http2Headers& headers,
                                             int32_t* ret,
                                             int options) {
-  CHECK(!this->IsDestroyed());
+  CHECK(!this->is_destroyed());
   Http2Scope h2scope(this);
   Debug(this, "sending push promise");
-  *ret = nghttp2_submit_push_promise(**session_, NGHTTP2_FLAG_NONE,
-                                     id_, nva, len, nullptr);
+  *ret = nghttp2_submit_push_promise(
+      session_->session(),
+      NGHTTP2_FLAG_NONE,
+      id_,
+      headers.data(),
+      headers.length(),
+      nullptr);
   CHECK_NE(*ret, NGHTTP2_ERR_NOMEM);
   Http2Stream* stream = nullptr;
   if (*ret > 0) {
@@ -2213,17 +2197,17 @@ Http2Stream* Http2Stream::SubmitPushPromise(nghttp2_nv* nva,
 // out to JS land.
 int Http2Stream::ReadStart() {
   Http2Scope h2scope(this);
-  CHECK(!this->IsDestroyed());
-  flags_ |= NGHTTP2_STREAM_FLAG_READ_START;
-  flags_ &= ~NGHTTP2_STREAM_FLAG_READ_PAUSED;
+  CHECK(!this->is_destroyed());
+  set_reading();
 
   Debug(this, "reading starting");
 
   // Tell nghttp2 about our consumption of the data that was handed
   // off to JS land.
-  nghttp2_session_consume_stream(**session_,
-                                 id_,
-                                 inbound_consumed_data_while_paused_);
+  nghttp2_session_consume_stream(
+      session_->session(),
+      id_,
+      inbound_consumed_data_while_paused_);
   inbound_consumed_data_while_paused_ = 0;
 
   return 0;
@@ -2231,10 +2215,10 @@ int Http2Stream::ReadStart() {
 
 // Switch the StreamBase into paused mode.
 int Http2Stream::ReadStop() {
-  CHECK(!this->IsDestroyed());
-  if (!IsReading())
+  CHECK(!this->is_destroyed());
+  if (!is_reading())
     return 0;
-  flags_ |= NGHTTP2_STREAM_FLAG_READ_PAUSED;
+  set_paused();
   Debug(this, "reading stopped");
   return 0;
 }
@@ -2255,7 +2239,7 @@ int Http2Stream::DoWrite(WriteWrap* req_wrap,
                          uv_stream_t* send_handle) {
   CHECK_NULL(send_handle);
   Http2Scope h2scope(this);
-  if (!IsWritable() || IsDestroyed()) {
+  if (!is_writable() || is_destroyed()) {
     req_wrap->Done(UV_EOF);
     return 0;
   }
@@ -2263,13 +2247,16 @@ int Http2Stream::DoWrite(WriteWrap* req_wrap,
   for (size_t i = 0; i < nbufs; ++i) {
     // Store the req_wrap on the last write info in the queue, so that it is
     // only marked as finished once all buffers associated with it are finished.
-    queue_.emplace(nghttp2_stream_write {
-      i == nbufs - 1 ? req_wrap : nullptr,
+    queue_.emplace(NgHttp2StreamWrite {
+      BaseObjectPtr<AsyncWrap>(
+          i == nbufs - 1 ? req_wrap->GetAsyncWrap() : nullptr),
       bufs[i]
     });
     IncrementAvailableOutboundLength(bufs[i].len);
   }
-  CHECK_NE(nghttp2_session_resume_data(**session_, id_), NGHTTP2_ERR_NOMEM);
+  CHECK_NE(nghttp2_session_resume_data(
+      session_->session(),
+      id_), NGHTTP2_ERR_NOMEM);
   return 0;
 }
 
@@ -2281,29 +2268,26 @@ int Http2Stream::DoWrite(WriteWrap* req_wrap,
 bool Http2Stream::AddHeader(nghttp2_rcbuf* name,
                             nghttp2_rcbuf* value,
                             uint8_t flags) {
-  CHECK(!this->IsDestroyed());
-  if (this->statistics_.first_header == 0)
-    this->statistics_.first_header = uv_hrtime();
-  size_t name_len = nghttp2_rcbuf_get_buf(name).len;
-  if (name_len == 0 && !IsReverted(SECURITY_REVERT_CVE_2019_9516)) {
-    return true;  // Ignore headers with empty names.
-  }
-  size_t value_len = nghttp2_rcbuf_get_buf(value).len;
-  size_t length = name_len + value_len + 32;
+  CHECK(!this->is_destroyed());
+
+  if (Http2RcBufferPointer::IsZeroLength(name))
+    return true;  // Ignore empty headers.
+
+  Http2Header header(env(), name, value, flags);
+  size_t length = header.length() + 32;
   // A header can only be added if we have not exceeded the maximum number
   // of headers and the session has memory available for it.
-  if (!session_->IsAvailableSessionMemory(length) ||
+  if (!session_->has_available_session_memory(length) ||
       current_headers_.size() == max_header_pairs_ ||
       current_headers_length_ + length > max_header_length_) {
     return false;
   }
-  nghttp2_header header;
-  header.name = name;
-  header.value = value;
-  header.flags = flags;
-  current_headers_.push_back(header);
-  nghttp2_rcbuf_incref(name);
-  nghttp2_rcbuf_incref(value);
+
+  if (statistics_.first_header == 0)
+    statistics_.first_header = uv_hrtime();
+
+  current_headers_.push_back(std::move(header));
+
   current_headers_length_ += length;
   session_->IncrementCurrentSessionMemory(length);
   return true;
@@ -2311,7 +2295,7 @@ bool Http2Stream::AddHeader(nghttp2_rcbuf* name,
 
 // A Provider is the thing that provides outbound DATA frame data.
 Http2Stream::Provider::Provider(Http2Stream* stream, int options) {
-  CHECK(!stream->IsDestroyed());
+  CHECK(!stream->is_destroyed());
   provider_.source.ptr = stream;
   empty_ = options & STREAM_OPTION_EMPTY_PAYLOAD;
 }
@@ -2346,7 +2330,8 @@ ssize_t Http2Stream::Provider::Stream::OnRead(nghttp2_session* handle,
                                               void* user_data) {
   Http2Session* session = static_cast<Http2Session*>(user_data);
   Debug(session, "reading outbound data for stream %d", id);
-  Http2Stream* stream = GetStream(session, id, source);
+  BaseObjectPtr<Http2Stream> stream = session->FindStream(id);
+  if (!stream) return 0;
   if (stream->statistics_.first_byte_sent == 0)
     stream->statistics_.first_byte_sent = uv_hrtime();
   CHECK_EQ(id, stream->id());
@@ -2358,10 +2343,11 @@ ssize_t Http2Stream::Provider::Stream::OnRead(nghttp2_session* handle,
   // find out when the HTTP2 stream wants to consume data, and because the
   // StreamBase API allows empty input chunks.
   while (!stream->queue_.empty() && stream->queue_.front().buf.len == 0) {
-    WriteWrap* finished = stream->queue_.front().req_wrap;
+    BaseObjectPtr<AsyncWrap> finished =
+        std::move(stream->queue_.front().req_wrap);
     stream->queue_.pop();
-    if (finished != nullptr)
-      finished->Done(0);
+    if (finished)
+      WriteWrap::FromObject(finished)->Done(0);
   }
 
   if (!stream->queue_.empty()) {
@@ -2376,21 +2362,21 @@ ssize_t Http2Stream::Provider::Stream::OnRead(nghttp2_session* handle,
     }
   }
 
-  if (amount == 0 && stream->IsWritable()) {
+  if (amount == 0 && stream->is_writable()) {
     CHECK(stream->queue_.empty());
     Debug(session, "deferring stream %d", id);
     stream->EmitWantsWrite(length);
-    if (stream->available_outbound_length_ > 0 || !stream->IsWritable()) {
+    if (stream->available_outbound_length_ > 0 || !stream->is_writable()) {
       // EmitWantsWrite() did something interesting synchronously, restart:
       return OnRead(handle, id, buf, length, flags, source, user_data);
     }
     return NGHTTP2_ERR_DEFERRED;
   }
 
-  if (stream->available_outbound_length_ == 0 && !stream->IsWritable()) {
+  if (stream->available_outbound_length_ == 0 && !stream->is_writable()) {
     Debug(session, "no more data for stream %d", id);
     *flags |= NGHTTP2_DATA_FLAG_EOF;
-    if (stream->HasTrailers()) {
+    if (stream->has_trailers()) {
       *flags |= NGHTTP2_DATA_FLAG_NO_END_STREAM;
       stream->OnTrailers();
     }
@@ -2400,12 +2386,12 @@ ssize_t Http2Stream::Provider::Stream::OnRead(nghttp2_session* handle,
   return amount;
 }
 
-inline void Http2Stream::IncrementAvailableOutboundLength(size_t amount) {
+void Http2Stream::IncrementAvailableOutboundLength(size_t amount) {
   available_outbound_length_ += amount;
   session_->IncrementCurrentSessionMemory(amount);
 }
 
-inline void Http2Stream::DecrementAvailableOutboundLength(size_t amount) {
+void Http2Stream::DecrementAvailableOutboundLength(size_t amount) {
   available_outbound_length_ -= amount;
   session_->DecrementCurrentSessionMemory(amount);
 }
@@ -2419,10 +2405,9 @@ void HttpErrorString(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   uint32_t val = args[0]->Uint32Value(env->context()).ToChecked();
   args.GetReturnValue().Set(
-      String::NewFromOneByte(
+      OneByteString(
           env->isolate(),
-          reinterpret_cast<const uint8_t*>(nghttp2_strerror(val)),
-          NewStringType::kInternalized).ToLocalChecked());
+          reinterpret_cast<const uint8_t*>(nghttp2_strerror(val))));
 }
 
 
@@ -2430,24 +2415,16 @@ void HttpErrorString(const FunctionCallbackInfo<Value>& args) {
 // would be suitable, for instance, for creating the Base64
 // output for an HTTP2-Settings header field.
 void PackSettings(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  // TODO(addaleax): We should not be creating a full AsyncWrap for this.
-  Local<Object> obj;
-  if (!env->http2settings_constructor_template()
-           ->NewInstance(env->context())
-           .ToLocal(&obj)) {
-    return;
-  }
-  Http2Session::Http2Settings settings(env, nullptr, obj);
-  args.GetReturnValue().Set(settings.Pack());
+  Http2State* state = Environment::GetBindingData<Http2State>(args);
+  args.GetReturnValue().Set(Http2Settings::Pack(state));
 }
 
 // A TypedArray instance is shared between C++ and JS land to contain the
 // default SETTINGS. RefreshDefaultSettings updates that TypedArray with the
 // default values.
 void RefreshDefaultSettings(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  Http2Session::Http2Settings::RefreshDefaults(env);
+  Http2State* state = Environment::GetBindingData<Http2State>(args);
+  Http2Settings::RefreshDefaults(state);
 }
 
 // Sets the next stream ID the Http2Session. If successful, returns true.
@@ -2456,7 +2433,7 @@ void Http2Session::SetNextStreamID(const FunctionCallbackInfo<Value>& args) {
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
   int32_t id = args[0]->Int32Value(env->context()).ToChecked();
-  if (nghttp2_session_set_next_stream_id(**session, id) < 0) {
+  if (nghttp2_session_set_next_stream_id(session->session(), id) < 0) {
     Debug(session, "failed to set next stream id to %d", id);
     return args.GetReturnValue().Set(false);
   }
@@ -2464,15 +2441,33 @@ void Http2Session::SetNextStreamID(const FunctionCallbackInfo<Value>& args) {
   Debug(session, "set next stream id to %d", id);
 }
 
+// Set local window size (local endpoints's window size) to the given
+// window_size for the stream denoted by 0.
+// This function returns 0 if it succeeds, or one of a negative codes
+void Http2Session::SetLocalWindowSize(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Http2Session* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
+
+  int32_t window_size = args[0]->Int32Value(env->context()).ToChecked();
+
+  int result = nghttp2_session_set_local_window_size(
+      session->session(), NGHTTP2_FLAG_NONE, 0, window_size);
+
+  args.GetReturnValue().Set(result);
+
+  Debug(session, "set local window size to %d", window_size);
+}
+
 // A TypedArray instance is shared between C++ and JS land to contain the
 // SETTINGS (either remote or local). RefreshSettings updates the current
 // values established for each of the settings so those can be read in JS land.
 template <get_setting fn>
 void Http2Session::RefreshSettings(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
-  Http2Settings::Update(env, session, fn);
+  Http2Settings::Update(session, fn);
   Debug(session, "settings refreshed for session");
 }
 
@@ -2480,14 +2475,13 @@ void Http2Session::RefreshSettings(const FunctionCallbackInfo<Value>& args) {
 // information of the current Http2Session. This updates the values in the
 // TypedArray so those can be read in JS land.
 void Http2Session::RefreshState(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
   Debug(session, "refreshing state");
 
-  AliasedFloat64Array& buffer = env->http2_state()->session_state_buffer;
+  AliasedFloat64Array& buffer = session->http2_state()->session_state_buffer;
 
-  nghttp2_session* s = **session;
+  nghttp2_session* s = session->session();
 
   buffer[IDX_SESSION_STATE_EFFECTIVE_LOCAL_WINDOW_SIZE] =
       nghttp2_session_get_effective_local_window_size(s);
@@ -2502,21 +2496,23 @@ void Http2Session::RefreshState(const FunctionCallbackInfo<Value>& args) {
   buffer[IDX_SESSION_STATE_REMOTE_WINDOW_SIZE] =
       nghttp2_session_get_remote_window_size(s);
   buffer[IDX_SESSION_STATE_OUTBOUND_QUEUE_SIZE] =
-      nghttp2_session_get_outbound_queue_size(s);
+      static_cast<double>(nghttp2_session_get_outbound_queue_size(s));
   buffer[IDX_SESSION_STATE_HD_DEFLATE_DYNAMIC_TABLE_SIZE] =
-      nghttp2_session_get_hd_deflate_dynamic_table_size(s);
+      static_cast<double>(nghttp2_session_get_hd_deflate_dynamic_table_size(s));
   buffer[IDX_SESSION_STATE_HD_INFLATE_DYNAMIC_TABLE_SIZE] =
-      nghttp2_session_get_hd_inflate_dynamic_table_size(s);
+      static_cast<double>(nghttp2_session_get_hd_inflate_dynamic_table_size(s));
 }
 
 
 // Constructor for new Http2Session instances.
 void Http2Session::New(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+  Http2State* state = Environment::GetBindingData<Http2State>(args);
+  Environment* env = state->env();
   CHECK(args.IsConstructCall());
-  int val = args[0]->IntegerValue(env->context()).ToChecked();
-  nghttp2_session_type type = static_cast<nghttp2_session_type>(val);
-  Http2Session* session = new Http2Session(env, args.This(), type);
+  SessionType type =
+      static_cast<SessionType>(
+          args[0]->Int32Value(env->context()).ToChecked());
+  Http2Session* session = new Http2Session(state, args.This(), type);
   session->get_async_id();  // avoid compiler warning
   Debug(session, "session created");
 }
@@ -2539,9 +2535,7 @@ void Http2Session::Destroy(const FunctionCallbackInfo<Value>& args) {
   Local<Context> context = env->context();
 
   uint32_t code = args[0]->Uint32Value(context).ToChecked();
-  bool socketDestroyed = args[1]->BooleanValue(env->isolate());
-
-  session->Close(code, socketDestroyed);
+  session->Close(code, args[1]->IsTrue());
 }
 
 // Submits a new request on the Http2Session and returns either an error code
@@ -2550,21 +2544,19 @@ void Http2Session::Request(const FunctionCallbackInfo<Value>& args) {
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
   Environment* env = session->env();
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
 
   Local<Array> headers = args[0].As<Array>();
-  int options = args[1]->IntegerValue(context).ToChecked();
-  Http2Priority priority(env, args[2], args[3], args[4]);
-
-  Headers list(isolate, context, headers);
+  int32_t options = args[1]->Int32Value(env->context()).ToChecked();
 
   Debug(session, "request submitted");
 
   int32_t ret = 0;
   Http2Stream* stream =
-      session->Http2Session::SubmitRequest(*priority, *list, list.length(),
-                                           &ret, options);
+      session->Http2Session::SubmitRequest(
+          Http2Priority(env, args[2], args[3], args[4]),
+          Http2Headers(env, headers),
+          &ret,
+          static_cast<int>(options));
 
   if (ret <= 0 || stream == nullptr) {
     Debug(session, "could not submit request: %s", nghttp2_strerror(ret));
@@ -2582,15 +2574,15 @@ void Http2Session::Goaway(uint32_t code,
                           int32_t lastStreamID,
                           const uint8_t* data,
                           size_t len) {
-  if (IsDestroyed())
+  if (is_destroyed())
     return;
 
   Http2Scope h2scope(this);
   // the last proc stream id is the most recently created Http2Stream.
   if (lastStreamID <= 0)
-    lastStreamID = nghttp2_session_get_last_proc_stream_id(session_);
+    lastStreamID = nghttp2_session_get_last_proc_stream_id(session_.get());
   Debug(this, "submitting goaway");
-  nghttp2_submit_goaway(session_, NGHTTP2_FLAG_NONE,
+  nghttp2_submit_goaway(session_.get(), NGHTTP2_FLAG_NONE,
                         lastStreamID, code, data, len);
 }
 
@@ -2649,18 +2641,16 @@ void Http2Stream::RstStream(const FunctionCallbackInfo<Value>& args) {
 // outbound DATA frames.
 void Http2Stream::Respond(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
 
   Local<Array> headers = args[0].As<Array>();
-  int options = args[1]->IntegerValue(context).ToChecked();
-
-  Headers list(isolate, context, headers);
+  int32_t options = args[1]->Int32Value(env->context()).ToChecked();
 
   args.GetReturnValue().Set(
-      stream->SubmitResponse(*list, list.length(), options));
+      stream->SubmitResponse(
+          Http2Headers(env, headers),
+          static_cast<int>(options)));
   Debug(stream, "response submitted");
 }
 
@@ -2668,31 +2658,24 @@ void Http2Stream::Respond(const FunctionCallbackInfo<Value>& args) {
 // Submits informational headers on the Http2Stream
 void Http2Stream::Info(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
 
   Local<Array> headers = args[0].As<Array>();
 
-  Headers list(isolate, context, headers);
-  args.GetReturnValue().Set(stream->SubmitInfo(*list, list.length()));
-  Debug(stream, "%d informational headers sent", list.length());
+  args.GetReturnValue().Set(stream->SubmitInfo(Http2Headers(env, headers)));
 }
 
 // Submits trailing headers on the Http2Stream
 void Http2Stream::Trailers(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
 
   Local<Array> headers = args[0].As<Array>();
 
-  Headers list(isolate, context, headers);
-  args.GetReturnValue().Set(stream->SubmitTrailers(*list, list.length()));
-  Debug(stream, "%d trailing headers sent", list.length());
+  args.GetReturnValue().Set(
+      stream->SubmitTrailers(Http2Headers(env, headers)));
 }
 
 // Grab the numeric id of the Http2Stream
@@ -2713,21 +2696,21 @@ void Http2Stream::Destroy(const FunctionCallbackInfo<Value>& args) {
 // Initiate a Push Promise and create the associated Http2Stream
 void Http2Stream::PushPromise(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
-  Isolate* isolate = env->isolate();
   Http2Stream* parent;
   ASSIGN_OR_RETURN_UNWRAP(&parent, args.Holder());
 
   Local<Array> headers = args[0].As<Array>();
-  int options = args[1]->IntegerValue(context).ToChecked();
-
-  Headers list(isolate, context, headers);
+  int32_t options = args[1]->Int32Value(env->context()).ToChecked();
 
   Debug(parent, "creating push promise");
 
   int32_t ret = 0;
-  Http2Stream* stream = parent->SubmitPushPromise(*list, list.length(),
-                                                  &ret, options);
+  Http2Stream* stream =
+      parent->SubmitPushPromise(
+          Http2Headers(env, headers),
+          &ret,
+          static_cast<int>(options));
+
   if (ret <= 0 || stream == nullptr) {
     Debug(parent, "failed to create push stream: %d", ret);
     return args.GetReturnValue().Set(ret);
@@ -2742,10 +2725,9 @@ void Http2Stream::Priority(const FunctionCallbackInfo<Value>& args) {
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
 
-  Http2Priority priority(env, args[0], args[1], args[2]);
-  bool silent = args[3]->BooleanValue(env->isolate());
-
-  CHECK_EQ(stream->SubmitPriority(*priority, silent), 0);
+  CHECK_EQ(stream->SubmitPriority(
+      Http2Priority(env, args[0], args[1], args[2]),
+      args[3]->IsTrue()), 0);
   Debug(stream, "priority submitted");
 }
 
@@ -2753,16 +2735,17 @@ void Http2Stream::Priority(const FunctionCallbackInfo<Value>& args) {
 // information about the Http2Stream. This updates the values in that
 // TypedArray so that the state can be read by JS.
 void Http2Stream::RefreshState(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
   Http2Stream* stream;
   ASSIGN_OR_RETURN_UNWRAP(&stream, args.Holder());
 
   Debug(stream, "refreshing state");
 
-  AliasedFloat64Array& buffer = env->http2_state()->stream_state_buffer;
+  CHECK_NOT_NULL(stream->session());
+  AliasedFloat64Array& buffer =
+      stream->session()->http2_state()->stream_state_buffer;
 
-  nghttp2_stream* str = **stream;
-  nghttp2_session* s = **(stream->session());
+  nghttp2_stream* str = stream->stream();
+  nghttp2_session* s = stream->session()->session();
 
   if (str == nullptr) {
     buffer[IDX_STREAM_STATE] = NGHTTP2_STREAM_STATE_IDLE;
@@ -2793,13 +2776,17 @@ void Http2Session::AltSvc(int32_t id,
                           uint8_t* value,
                           size_t value_len) {
   Http2Scope h2scope(this);
-  CHECK_EQ(nghttp2_submit_altsvc(session_, NGHTTP2_FLAG_NONE, id,
+  CHECK_EQ(nghttp2_submit_altsvc(session_.get(), NGHTTP2_FLAG_NONE, id,
                                  origin, origin_len, value, value_len), 0);
 }
 
-void Http2Session::Origin(nghttp2_origin_entry* ov, size_t count) {
+void Http2Session::Origin(const Origins& origins) {
   Http2Scope h2scope(this);
-  CHECK_EQ(nghttp2_submit_origin(session_, NGHTTP2_FLAG_NONE, ov, count), 0);
+  CHECK_EQ(nghttp2_submit_origin(
+      session_.get(),
+      NGHTTP2_FLAG_NONE,
+      *origins,
+      origins.length()), 0);
 }
 
 // Submits an AltSvc frame to be sent to the connected peer.
@@ -2814,6 +2801,9 @@ void Http2Session::AltSvc(const FunctionCallbackInfo<Value>& args) {
   Local<String> origin_str = args[1]->ToString(env->context()).ToLocalChecked();
   Local<String> value_str = args[2]->ToString(env->context()).ToLocalChecked();
 
+  if (origin_str.IsEmpty() || value_str.IsEmpty())
+    return;
+
   size_t origin_len = origin_str->Length();
   size_t value_len = value_str->Length();
 
@@ -2837,20 +2827,13 @@ void Http2Session::Origin(const FunctionCallbackInfo<Value>& args) {
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
 
   Local<String> origin_string = args[0].As<String>();
-  int count = args[1]->IntegerValue(context).ToChecked();
-
+  size_t count = args[1]->Int32Value(context).ToChecked();
 
-  Origins origins(env->isolate(),
-                  env->context(),
-                  origin_string,
-                  count);
-
-  session->Origin(*origins, origins.length());
+  session->Origin(Origins(env, origin_string, count));
 }
 
 // Submits a PING frame to be sent to the connected peer.
 void Http2Session::Ping(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
 
@@ -2862,54 +2845,20 @@ void Http2Session::Ping(const FunctionCallbackInfo<Value>& args) {
     CHECK_EQ(payload.length(), 8);
   }
 
-  Local<Object> obj;
-  if (!env->http2ping_constructor_template()
-           ->NewInstance(env->context())
-           .ToLocal(&obj)) {
-    return;
-  }
-  if (obj->Set(env->context(), env->ondone_string(), args[1]).IsNothing())
-    return;
-
-  Http2Ping* ping = session->AddPing(
-      MakeDetachedBaseObject<Http2Ping>(session, obj));
-  // To prevent abuse, we strictly limit the number of unacknowledged PING
-  // frames that may be sent at any given time. This is configurable in the
-  // Options when creating a Http2Session.
-  if (ping == nullptr) return args.GetReturnValue().Set(false);
-
-  // The Ping itself is an Async resource. When the acknowledgement is received,
-  // the callback will be invoked and a notification sent out to JS land. The
-  // notification will include the duration of the ping, allowing the round
-  // trip to be measured.
-  ping->Send(payload.data());
-  args.GetReturnValue().Set(true);
+  CHECK(args[1]->IsFunction());
+  args.GetReturnValue().Set(
+      session->AddPing(payload.data(), args[1].As<Function>()));
 }
 
 // Submits a SETTINGS frame for the Http2Session
 void Http2Session::Settings(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
   Http2Session* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
-
-  Local<Object> obj;
-  if (!env->http2settings_constructor_template()
-           ->NewInstance(env->context())
-           .ToLocal(&obj)) {
-    return;
-  }
-  if (obj->Set(env->context(), env->ondone_string(), args[0]).IsNothing())
-    return;
-
-  Http2Settings* settings = session->AddSettings(
-      MakeDetachedBaseObject<Http2Settings>(session->env(), session, obj, 0));
-  if (settings == nullptr) return args.GetReturnValue().Set(false);
-
-  settings->Send();
-  args.GetReturnValue().Set(true);
+  CHECK(args[0]->IsFunction());
+  args.GetReturnValue().Set(session->AddSettings(args[0].As<Function>()));
 }
 
-BaseObjectPtr<Http2Session::Http2Ping> Http2Session::PopPing() {
+BaseObjectPtr<Http2Ping> Http2Session::PopPing() {
   BaseObjectPtr<Http2Ping> ping;
   if (!outstanding_pings_.empty()) {
     ping = std::move(outstanding_pings_.front());
@@ -2919,19 +2868,36 @@ BaseObjectPtr<Http2Session::Http2Ping> Http2Session::PopPing() {
   return ping;
 }
 
-Http2Session::Http2Ping* Http2Session::AddPing(
-    BaseObjectPtr<Http2Session::Http2Ping> ping) {
+bool Http2Session::AddPing(const uint8_t* payload, Local<Function> callback) {
+  Local<Object> obj;
+  if (!env()->http2ping_constructor_template()
+          ->NewInstance(env()->context())
+              .ToLocal(&obj)) {
+    return false;
+  }
+
+  BaseObjectPtr<Http2Ping> ping =
+      MakeDetachedBaseObject<Http2Ping>(this, obj, callback);
+  if (!ping)
+    return false;
+
   if (outstanding_pings_.size() == max_outstanding_pings_) {
     ping->Done(false);
-    return nullptr;
+    return false;
   }
-  Http2Ping* ptr = ping.get();
-  outstanding_pings_.emplace(std::move(ping));
+
   IncrementCurrentSessionMemory(sizeof(*ping));
-  return ptr;
+  // The Ping itself is an Async resource. When the acknowledgement is received,
+  // the callback will be invoked and a notification sent out to JS land. The
+  // notification will include the duration of the ping, allowing the round
+  // trip to be measured.
+  ping->Send(payload);
+
+  outstanding_pings_.emplace(std::move(ping));
+  return true;
 }
 
-BaseObjectPtr<Http2Session::Http2Settings> Http2Session::PopSettings() {
+BaseObjectPtr<Http2Settings> Http2Session::PopSettings() {
   BaseObjectPtr<Http2Settings> settings;
   if (!outstanding_settings_.empty()) {
     settings = std::move(outstanding_settings_.front());
@@ -2941,77 +2907,99 @@ BaseObjectPtr<Http2Session::Http2Settings> Http2Session::PopSettings() {
   return settings;
 }
 
-Http2Session::Http2Settings* Http2Session::AddSettings(
-    BaseObjectPtr<Http2Session::Http2Settings> settings) {
+bool Http2Session::AddSettings(Local<Function> callback) {
+  Local<Object> obj;
+  if (!env()->http2settings_constructor_template()
+          ->NewInstance(env()->context())
+              .ToLocal(&obj)) {
+    return false;
+  }
+
+  BaseObjectPtr<Http2Settings> settings =
+      MakeDetachedBaseObject<Http2Settings>(this, obj, callback, 0);
+  if (!settings)
+    return false;
+
   if (outstanding_settings_.size() == max_outstanding_settings_) {
     settings->Done(false);
-    return nullptr;
+    return false;
   }
-  Http2Settings* ptr = settings.get();
-  outstanding_settings_.emplace(std::move(settings));
+
   IncrementCurrentSessionMemory(sizeof(*settings));
-  return ptr;
+  settings->Send();
+  outstanding_settings_.emplace(std::move(settings));
+  return true;
 }
 
-Http2Session::Http2Ping::Http2Ping(Http2Session* session, Local<Object> obj)
+Http2Ping::Http2Ping(
+    Http2Session* session,
+    Local<Object> obj,
+    Local<Function> callback)
     : AsyncWrap(session->env(), obj, AsyncWrap::PROVIDER_HTTP2PING),
       session_(session),
       startTime_(uv_hrtime()) {
+  callback_.Reset(env()->isolate(), callback);
+}
+
+void Http2Ping::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("callback", callback_);
+}
+
+Local<Function> Http2Ping::callback() const {
+  return callback_.Get(env()->isolate());
 }
 
-void Http2Session::Http2Ping::Send(const uint8_t* payload) {
-  CHECK_NOT_NULL(session_);
+void Http2Ping::Send(const uint8_t* payload) {
+  CHECK(session_);
   uint8_t data[8];
   if (payload == nullptr) {
     memcpy(&data, &startTime_, arraysize(data));
     payload = data;
   }
-  Http2Scope h2scope(session_);
-  CHECK_EQ(nghttp2_submit_ping(**session_, NGHTTP2_FLAG_NONE, payload), 0);
+  Http2Scope h2scope(session_.get());
+  CHECK_EQ(nghttp2_submit_ping(
+      session_->session(),
+      NGHTTP2_FLAG_NONE,
+      payload), 0);
 }
 
-void Http2Session::Http2Ping::Done(bool ack, const uint8_t* payload) {
+void Http2Ping::Done(bool ack, const uint8_t* payload) {
   uint64_t duration_ns = uv_hrtime() - startTime_;
   double duration_ms = duration_ns / 1e6;
-  if (session_ != nullptr) session_->statistics_.ping_rtt = duration_ns;
+  if (session_) session_->statistics_.ping_rtt = duration_ns;
 
-  HandleScope handle_scope(env()->isolate());
+  Isolate* isolate = env()->isolate();
+  HandleScope handle_scope(isolate);
   Context::Scope context_scope(env()->context());
 
-  Local<Value> buf = Undefined(env()->isolate());
+  Local<Value> buf = Undefined(isolate);
   if (payload != nullptr) {
-    buf = Buffer::Copy(env()->isolate(),
+    buf = Buffer::Copy(isolate,
                        reinterpret_cast<const char*>(payload),
                        8).ToLocalChecked();
   }
 
   Local<Value> argv[] = {
-    Boolean::New(env()->isolate(), ack),
-    Number::New(env()->isolate(), duration_ms),
+    ack ? v8::True(isolate) : v8::False(isolate),
+    Number::New(isolate, duration_ms),
     buf
   };
-  MakeCallback(env()->ondone_string(), arraysize(argv), argv);
+  MakeCallback(callback(), arraysize(argv), argv);
 }
 
-void Http2Session::Http2Ping::DetachFromSession() {
-  session_ = nullptr;
+void Http2Ping::DetachFromSession() {
+  session_.reset();
 }
 
-void nghttp2_stream_write::MemoryInfo(MemoryTracker* tracker) const {
-  if (req_wrap != nullptr)
-    tracker->TrackField("req_wrap", req_wrap->GetAsyncWrap());
+void NgHttp2StreamWrite::MemoryInfo(MemoryTracker* tracker) const {
+  if (req_wrap)
+    tracker->TrackField("req_wrap", req_wrap);
   tracker->TrackField("buf", buf);
 }
 
-
-void nghttp2_header::MemoryInfo(MemoryTracker* tracker) const {
-  tracker->TrackFieldWithSize("name", nghttp2_rcbuf_get_buf(name).len);
-  tracker->TrackFieldWithSize("value", nghttp2_rcbuf_get_buf(value).len);
-}
-
 void SetCallbackFunctions(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  CHECK_EQ(args.Length(), 12);
+  CHECK_EQ(args.Length(), 11);
 
 #define SET_FUNCTION(arg, name)                                               \
   CHECK(args[arg]->IsFunction());                                             \
@@ -3026,13 +3014,19 @@ void SetCallbackFunctions(const FunctionCallbackInfo<Value>& args) {
   SET_FUNCTION(6, goaway_data)
   SET_FUNCTION(7, altsvc)
   SET_FUNCTION(8, origin)
-  SET_FUNCTION(9, select_padding)
-  SET_FUNCTION(10, stream_trailers)
-  SET_FUNCTION(11, stream_close)
+  SET_FUNCTION(9, stream_trailers)
+  SET_FUNCTION(10, stream_close)
 
 #undef SET_FUNCTION
 }
 
+void Http2State::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("root_buffer", root_buffer);
+}
+
+// TODO(addaleax): Remove once we're on C++17.
+constexpr FastStringKey Http2State::type_name;
+
 // Set up the process.binding('http2') binding.
 void Initialize(Local<Object> target,
                 Local<Value> unused,
@@ -3040,18 +3034,16 @@ void Initialize(Local<Object> target,
                 void* priv) {
   Environment* env = Environment::GetCurrent(context);
   Isolate* isolate = env->isolate();
-  HandleScope scope(isolate);
+  HandleScope handle_scope(isolate);
 
-  std::unique_ptr<Http2State> state(new Http2State(isolate));
+  Http2State* const state = env->AddBindingData<Http2State>(context, target);
+  if (state == nullptr) return;
 
 #define SET_STATE_TYPEDARRAY(name, field)             \
   target->Set(context,                                \
               FIXED_ONE_BYTE_STRING(isolate, (name)), \
               (field)).FromJust()
 
-  // Initialize the buffer used for padding callbacks
-  SET_STATE_TYPEDARRAY(
-    "paddingBuffer", state->padding_buffer.GetJSArray());
   // Initialize the buffer used to store the session state
   SET_STATE_TYPEDARRAY(
     "sessionState", state->session_state_buffer.GetJSArray());
@@ -3068,12 +3060,6 @@ void Initialize(Local<Object> target,
     "sessionStats", state->session_stats_buffer.GetJSArray());
 #undef SET_STATE_TYPEDARRAY
 
-  env->set_http2_state(std::move(state));
-
-  NODE_DEFINE_CONSTANT(target, PADDING_BUF_FRAME_LENGTH);
-  NODE_DEFINE_CONSTANT(target, PADDING_BUF_MAX_PAYLOAD_LENGTH);
-  NODE_DEFINE_CONSTANT(target, PADDING_BUF_RETURN_VALUE);
-
   NODE_DEFINE_CONSTANT(target, kBitfield);
   NODE_DEFINE_CONSTANT(target, kSessionPriorityListenerCount);
   NODE_DEFINE_CONSTANT(target, kSessionFrameErrorListenerCount);
@@ -3088,26 +3074,24 @@ void Initialize(Local<Object> target,
 
   // Method to fetch the nghttp2 string description of an nghttp2 error code
   env->SetMethod(target, "nghttp2ErrorString", HttpErrorString);
-
-  Local<String> http2SessionClassName =
-    FIXED_ONE_BYTE_STRING(isolate, "Http2Session");
+  env->SetMethod(target, "refreshDefaultSettings", RefreshDefaultSettings);
+  env->SetMethod(target, "packSettings", PackSettings);
+  env->SetMethod(target, "setCallbackFunctions", SetCallbackFunctions);
 
   Local<FunctionTemplate> ping = FunctionTemplate::New(env->isolate());
   ping->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Ping"));
   ping->Inherit(AsyncWrap::GetConstructorTemplate(env));
   Local<ObjectTemplate> pingt = ping->InstanceTemplate();
-  pingt->SetInternalFieldCount(Http2Session::Http2Ping::kInternalFieldCount);
+  pingt->SetInternalFieldCount(Http2Ping::kInternalFieldCount);
   env->set_http2ping_constructor_template(pingt);
 
   Local<FunctionTemplate> setting = FunctionTemplate::New(env->isolate());
-  setting->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Setting"));
   setting->Inherit(AsyncWrap::GetConstructorTemplate(env));
   Local<ObjectTemplate> settingt = setting->InstanceTemplate();
   settingt->SetInternalFieldCount(AsyncWrap::kInternalFieldCount);
   env->set_http2settings_constructor_template(settingt);
 
   Local<FunctionTemplate> stream = FunctionTemplate::New(env->isolate());
-  stream->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Stream"));
   env->SetProtoMethod(stream, "id", Http2Stream::GetID);
   env->SetProtoMethod(stream, "destroy", Http2Stream::Destroy);
   env->SetProtoMethod(stream, "priority", Http2Stream::Priority);
@@ -3122,13 +3106,10 @@ void Initialize(Local<Object> target,
   Local<ObjectTemplate> streamt = stream->InstanceTemplate();
   streamt->SetInternalFieldCount(StreamBase::kInternalFieldCount);
   env->set_http2stream_constructor_template(streamt);
-  target->Set(context,
-              FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Stream"),
-              stream->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "Http2Stream", stream);
 
   Local<FunctionTemplate> session =
       env->NewFunctionTemplate(Http2Session::New);
-  session->SetClassName(http2SessionClassName);
   session->InstanceTemplate()->SetInternalFieldCount(
       Http2Session::kInternalFieldCount);
   session->Inherit(AsyncWrap::GetConstructorTemplate(env));
@@ -3136,12 +3117,15 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(session, "altsvc", Http2Session::AltSvc);
   env->SetProtoMethod(session, "ping", Http2Session::Ping);
   env->SetProtoMethod(session, "consume", Http2Session::Consume);
+  env->SetProtoMethod(session, "receive", Http2Session::Receive);
   env->SetProtoMethod(session, "destroy", Http2Session::Destroy);
   env->SetProtoMethod(session, "goaway", Http2Session::Goaway);
   env->SetProtoMethod(session, "settings", Http2Session::Settings);
   env->SetProtoMethod(session, "request", Http2Session::Request);
   env->SetProtoMethod(session, "setNextStreamID",
                       Http2Session::SetNextStreamID);
+  env->SetProtoMethod(session, "setLocalWindowSize",
+                      Http2Session::SetLocalWindowSize);
   env->SetProtoMethod(session, "updateChunksSent",
                       Http2Session::UpdateChunksSent);
   env->SetProtoMethod(session, "refreshState", Http2Session::RefreshState);
@@ -3151,118 +3135,55 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(
       session, "remoteSettings",
       Http2Session::RefreshSettings<nghttp2_session_get_remote_settings>);
-  target->Set(context,
-              http2SessionClassName,
-              session->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "Http2Session", session);
 
   Local<Object> constants = Object::New(isolate);
-  Local<Array> name_for_error_code = Array::New(isolate);
-
-#define NODE_NGHTTP2_ERROR_CODES(V)                       \
-  V(NGHTTP2_SESSION_SERVER);                              \
-  V(NGHTTP2_SESSION_CLIENT);                              \
-  V(NGHTTP2_STREAM_STATE_IDLE);                           \
-  V(NGHTTP2_STREAM_STATE_OPEN);                           \
-  V(NGHTTP2_STREAM_STATE_RESERVED_LOCAL);                 \
-  V(NGHTTP2_STREAM_STATE_RESERVED_REMOTE);                \
-  V(NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL);              \
-  V(NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE);             \
-  V(NGHTTP2_STREAM_STATE_CLOSED);                         \
-  V(NGHTTP2_NO_ERROR);                                    \
-  V(NGHTTP2_PROTOCOL_ERROR);                              \
-  V(NGHTTP2_INTERNAL_ERROR);                              \
-  V(NGHTTP2_FLOW_CONTROL_ERROR);                          \
-  V(NGHTTP2_SETTINGS_TIMEOUT);                            \
-  V(NGHTTP2_STREAM_CLOSED);                               \
-  V(NGHTTP2_FRAME_SIZE_ERROR);                            \
-  V(NGHTTP2_REFUSED_STREAM);                              \
-  V(NGHTTP2_CANCEL);                                      \
-  V(NGHTTP2_COMPRESSION_ERROR);                           \
-  V(NGHTTP2_CONNECT_ERROR);                               \
-  V(NGHTTP2_ENHANCE_YOUR_CALM);                           \
-  V(NGHTTP2_INADEQUATE_SECURITY);                         \
-  V(NGHTTP2_HTTP_1_1_REQUIRED);                           \
-
-#define V(name)                                                         \
-  NODE_DEFINE_CONSTANT(constants, name);                                \
-  name_for_error_code->Set(env->context(),                              \
-                           static_cast<int>(name),                      \
-                           FIXED_ONE_BYTE_STRING(isolate,               \
-                                                 #name)).Check();
-  NODE_NGHTTP2_ERROR_CODES(V)
+
+  // This does allocate one more slot than needed but it's not used.
+#define V(name) FIXED_ONE_BYTE_STRING(isolate, #name),
+  Local<Value> error_code_names[] = {
+    HTTP2_ERROR_CODES(V)
+  };
 #undef V
 
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_HCAT_REQUEST);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_HCAT_RESPONSE);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_HCAT_PUSH_RESPONSE);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_HCAT_HEADERS);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_NV_FLAG_NONE);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_NV_FLAG_NO_INDEX);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_ERR_DEFERRED);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_ERR_INVALID_ARGUMENT);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, NGHTTP2_ERR_STREAM_CLOSED);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_ERR_FRAME_SIZE_ERROR);
-
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, STREAM_OPTION_EMPTY_PAYLOAD);
-  NODE_DEFINE_HIDDEN_CONSTANT(constants, STREAM_OPTION_GET_TRAILERS);
-
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_FLAG_NONE);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_FLAG_END_STREAM);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_FLAG_END_HEADERS);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_FLAG_ACK);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_FLAG_PADDED);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_FLAG_PRIORITY);
-
-  NODE_DEFINE_CONSTANT(constants, DEFAULT_SETTINGS_HEADER_TABLE_SIZE);
-  NODE_DEFINE_CONSTANT(constants, DEFAULT_SETTINGS_ENABLE_PUSH);
-  NODE_DEFINE_CONSTANT(constants, DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS);
-  NODE_DEFINE_CONSTANT(constants, DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE);
-  NODE_DEFINE_CONSTANT(constants, DEFAULT_SETTINGS_MAX_FRAME_SIZE);
-  NODE_DEFINE_CONSTANT(constants, DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE);
-  NODE_DEFINE_CONSTANT(constants, DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL);
-  NODE_DEFINE_CONSTANT(constants, MAX_MAX_FRAME_SIZE);
-  NODE_DEFINE_CONSTANT(constants, MIN_MAX_FRAME_SIZE);
-  NODE_DEFINE_CONSTANT(constants, MAX_INITIAL_WINDOW_SIZE);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_DEFAULT_WEIGHT);
+  Local<Array> name_for_error_code =
+      Array::New(
+          isolate,
+          error_code_names,
+          arraysize(error_code_names));
 
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_SETTINGS_HEADER_TABLE_SIZE);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_SETTINGS_ENABLE_PUSH);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_SETTINGS_MAX_FRAME_SIZE);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE);
-  NODE_DEFINE_CONSTANT(constants, NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL);
+  target->Set(context,
+              FIXED_ONE_BYTE_STRING(isolate, "nameForErrorCode"),
+              name_for_error_code).Check();
+
+#define V(constant) NODE_DEFINE_HIDDEN_CONSTANT(constants, constant);
+  HTTP2_HIDDEN_CONSTANTS(V)
+#undef V
+
+#define V(constant) NODE_DEFINE_CONSTANT(constants, constant);
+  HTTP2_CONSTANTS(V)
+#undef V
 
-  NODE_DEFINE_CONSTANT(constants, PADDING_STRATEGY_NONE);
-  NODE_DEFINE_CONSTANT(constants, PADDING_STRATEGY_ALIGNED);
-  NODE_DEFINE_CONSTANT(constants, PADDING_STRATEGY_MAX);
-  NODE_DEFINE_CONSTANT(constants, PADDING_STRATEGY_CALLBACK);
+  // NGHTTP2_DEFAULT_WEIGHT is a macro and not a regular define
+  // it won't be set properly on the constants object if included
+  // in the HTTP2_CONSTANTS macro.
+  NODE_DEFINE_CONSTANT(constants, NGHTTP2_DEFAULT_WEIGHT);
 
-#define STRING_CONSTANT(NAME, VALUE)                                          \
+#define V(NAME, VALUE)                                          \
   NODE_DEFINE_STRING_CONSTANT(constants, "HTTP2_HEADER_" # NAME, VALUE);
-HTTP_KNOWN_HEADERS(STRING_CONSTANT)
-#undef STRING_CONSTANT
+  HTTP_KNOWN_HEADERS(V)
+#undef V
 
-#define STRING_CONSTANT(NAME, VALUE)                                          \
+#define V(NAME, VALUE)                                          \
   NODE_DEFINE_STRING_CONSTANT(constants, "HTTP2_METHOD_" # NAME, VALUE);
-HTTP_KNOWN_METHODS(STRING_CONSTANT)
-#undef STRING_CONSTANT
+  HTTP_KNOWN_METHODS(V)
+#undef V
 
 #define V(name, _) NODE_DEFINE_CONSTANT(constants, HTTP_STATUS_##name);
-HTTP_STATUS_CODES(V)
+  HTTP_STATUS_CODES(V)
 #undef V
 
-  env->SetMethod(target, "refreshDefaultSettings", RefreshDefaultSettings);
-  env->SetMethod(target, "packSettings", PackSettings);
-  env->SetMethod(target, "setCallbackFunctions", SetCallbackFunctions);
-
-  target->Set(context,
-              env->constants_string(),
-              constants).Check();
-  target->Set(context,
-              FIXED_ONE_BYTE_STRING(isolate, "nameForErrorCode"),
-              name_for_error_code).Check();
+  target->Set(context, env->constants_string(), constants).Check();
 }
 }  // namespace http2
 }  // namespace node
diff --git a/src/node_http2.h b/src/node_http2.h
index a59de18f920acacdfbb2b5d21f04a58743bb53d5..9c7ffce2c4195541c77aed5709ec8eff30f19f62 100644
--- a/src/node_http2.h
+++ b/src/node_http2.h
@@ -7,10 +7,13 @@
 #include <cstdint>
 #include "nghttp2/nghttp2.h"
 
+#include "allocated_buffer.h"
+#include "aliased_struct.h"
 #include "node_http2_state.h"
+#include "node_http_common.h"
 #include "node_mem.h"
 #include "node_perf.h"
-#include "stream_base-inl.h"
+#include "stream_base.h"
 #include "string_bytes.h"
 
 #include <algorithm>
@@ -19,335 +22,148 @@
 namespace node {
 namespace http2 {
 
-using v8::Array;
-using v8::Context;
-using v8::Isolate;
-using v8::MaybeLocal;
-
-using performance::PerformanceEntry;
+// Constants in all caps are exported as user-facing constants
+// in JavaScript. Constants using the kName pattern are internal
+// only.
 
 // We strictly limit the number of outstanding unacknowledged PINGS a user
 // may send in order to prevent abuse. The current default cap is 10. The
 // user may set a different limit using a per Http2Session configuration
 // option.
-#define DEFAULT_MAX_PINGS 10
+constexpr size_t kDefaultMaxPings = 10;
 
 // Also strictly limit the number of outstanding SETTINGS frames a user sends
-#define DEFAULT_MAX_SETTINGS 10
+constexpr size_t kDefaultMaxSettings = 10;
 
 // Default maximum total memory cap for Http2Session.
-#define DEFAULT_MAX_SESSION_MEMORY 1e7
+constexpr uint64_t kDefaultMaxSessionMemory = 10000000;
 
 // These are the standard HTTP/2 defaults as specified by the RFC
-#define DEFAULT_SETTINGS_HEADER_TABLE_SIZE 4096
-#define DEFAULT_SETTINGS_ENABLE_PUSH 1
-#define DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS 0xffffffffu
-#define DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE 65535
-#define DEFAULT_SETTINGS_MAX_FRAME_SIZE 16384
-#define DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE 65535
-#define DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL 0
-#define MAX_MAX_FRAME_SIZE 16777215
-#define MIN_MAX_FRAME_SIZE DEFAULT_SETTINGS_MAX_FRAME_SIZE
-#define MAX_INITIAL_WINDOW_SIZE 2147483647
-
-#define MAX_MAX_HEADER_LIST_SIZE 16777215u
-#define DEFAULT_MAX_HEADER_LIST_PAIRS 128u
-
-enum nghttp2_session_type {
+constexpr uint32_t DEFAULT_SETTINGS_HEADER_TABLE_SIZE = 4096;
+constexpr uint32_t DEFAULT_SETTINGS_ENABLE_PUSH = 1;
+constexpr uint32_t DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS = 0xffffffffu;
+constexpr uint32_t DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE = 65535;
+constexpr uint32_t DEFAULT_SETTINGS_MAX_FRAME_SIZE = 16384;
+constexpr uint32_t DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE = 65535;
+constexpr uint32_t DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL = 0;
+constexpr uint32_t MAX_MAX_FRAME_SIZE = 16777215;
+constexpr uint32_t MIN_MAX_FRAME_SIZE = DEFAULT_SETTINGS_MAX_FRAME_SIZE;
+constexpr uint32_t MAX_INITIAL_WINDOW_SIZE = 2147483647;
+
+// Stream is not going to have any DATA frames
+constexpr int STREAM_OPTION_EMPTY_PAYLOAD = 0x1;
+
+// Stream might have trailing headers
+constexpr int STREAM_OPTION_GET_TRAILERS = 0x2;
+
+// Http2Stream internal states
+constexpr int kStreamStateNone = 0x0;
+constexpr int kStreamStateShut = 0x1;
+constexpr int kStreamStateReadStart = 0x2;
+constexpr int kStreamStateReadPaused = 0x4;
+constexpr int kStreamStateClosed = 0x8;
+constexpr int kStreamStateDestroyed = 0x10;
+constexpr int kStreamStateTrailers = 0x20;
+
+// Http2Session internal states
+constexpr int kSessionStateNone = 0x0;
+constexpr int kSessionStateHasScope = 0x1;
+constexpr int kSessionStateWriteScheduled = 0x2;
+constexpr int kSessionStateClosed = 0x4;
+constexpr int kSessionStateClosing = 0x8;
+constexpr int kSessionStateSending = 0x10;
+constexpr int kSessionStateWriteInProgress = 0x20;
+constexpr int kSessionStateReadingStopped = 0x40;
+constexpr int kSessionStateReceivePaused = 0x80;
+
+// The Padding Strategy determines the method by which extra padding is
+// selected for HEADERS and DATA frames. These are configurable via the
+// options passed in to a Http2Session object.
+enum PaddingStrategy {
+  // No padding strategy. This is the default.
+  PADDING_STRATEGY_NONE,
+  // Attempts to ensure that the frame is 8-byte aligned
+  PADDING_STRATEGY_ALIGNED,
+  // Padding will ensure all data frames are maxFrameSize
+  PADDING_STRATEGY_MAX,
+  // Removed and turned into an alias because it is unreasonably expensive for
+  // very little benefit.
+  PADDING_STRATEGY_CALLBACK = PADDING_STRATEGY_ALIGNED
+};
+
+enum SessionType {
   NGHTTP2_SESSION_SERVER,
   NGHTTP2_SESSION_CLIENT
 };
 
-enum nghttp2_stream_flags {
-  NGHTTP2_STREAM_FLAG_NONE = 0x0,
-  // Writable side has ended
-  NGHTTP2_STREAM_FLAG_SHUT = 0x1,
-  // Reading has started
-  NGHTTP2_STREAM_FLAG_READ_START = 0x2,
-  // Reading is paused
-  NGHTTP2_STREAM_FLAG_READ_PAUSED = 0x4,
-  // Stream is closed
-  NGHTTP2_STREAM_FLAG_CLOSED = 0x8,
-  // Stream is destroyed
-  NGHTTP2_STREAM_FLAG_DESTROYED = 0x10,
-  // Stream has trailers
-  NGHTTP2_STREAM_FLAG_TRAILERS = 0x20,
-  // Stream has received all the data it can
-  NGHTTP2_STREAM_FLAG_EOS = 0x40
+template <typename T, void(*fn)(T*)>
+struct Nghttp2Deleter {
+  void operator()(T* ptr) const noexcept { fn(ptr); }
 };
 
-enum nghttp2_stream_options {
-  // Stream is not going to have any DATA frames
-  STREAM_OPTION_EMPTY_PAYLOAD = 0x1,
-  // Stream might have trailing headers
-  STREAM_OPTION_GET_TRAILERS = 0x2,
-};
+using Nghttp2OptionPointer =
+    std::unique_ptr<nghttp2_option,
+                    Nghttp2Deleter<nghttp2_option, nghttp2_option_del>>;
 
-struct nghttp2_stream_write : public MemoryRetainer {
-  WriteWrap* req_wrap = nullptr;
-  uv_buf_t buf;
+using Nghttp2SessionPointer =
+    std::unique_ptr<nghttp2_session,
+                    Nghttp2Deleter<nghttp2_session, nghttp2_session_del>>;
 
-  inline explicit nghttp2_stream_write(uv_buf_t buf_) : buf(buf_) {}
-  inline nghttp2_stream_write(WriteWrap* req, uv_buf_t buf_) :
-      req_wrap(req), buf(buf_) {}
+using Nghttp2SessionCallbacksPointer =
+    std::unique_ptr<nghttp2_session_callbacks,
+                    Nghttp2Deleter<nghttp2_session_callbacks,
+                                   nghttp2_session_callbacks_del>>;
 
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(nghttp2_stream_write)
-  SET_SELF_SIZE(nghttp2_stream_write)
+struct Http2HeadersTraits {
+  typedef nghttp2_nv nv_t;
 };
 
-struct nghttp2_header : public MemoryRetainer {
-  nghttp2_rcbuf* name = nullptr;
-  nghttp2_rcbuf* value = nullptr;
-  uint8_t flags = 0;
+struct Http2RcBufferPointerTraits {
+  typedef nghttp2_rcbuf rcbuf_t;
+  typedef nghttp2_vec vector_t;
 
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(nghttp2_header)
-  SET_SELF_SIZE(nghttp2_header)
+  static void inc(rcbuf_t* buf) {
+    CHECK_NOT_NULL(buf);
+    nghttp2_rcbuf_incref(buf);
+  }
+  static void dec(rcbuf_t* buf) {
+    CHECK_NOT_NULL(buf);
+    nghttp2_rcbuf_decref(buf);
+  }
+  static vector_t get_vec(rcbuf_t* buf) {
+    CHECK_NOT_NULL(buf);
+    return nghttp2_rcbuf_get_buf(buf);
+  }
+  static bool is_static(const rcbuf_t* buf) {
+    CHECK_NOT_NULL(buf);
+    return nghttp2_rcbuf_is_static(buf);
+  }
 };
 
+using Http2Headers = NgHeaders<Http2HeadersTraits>;
+using Http2RcBufferPointer = NgRcBufPointer<Http2RcBufferPointerTraits>;
 
-// Unlike the HTTP/1 implementation, the HTTP/2 implementation is not limited
-// to a fixed number of known supported HTTP methods. These constants, therefore
-// are provided strictly as a convenience to users and are exposed via the
-// require('http2').constants object.
-#define HTTP_KNOWN_METHODS(V)                                                 \
-  V(ACL, "ACL")                                                               \
-  V(BASELINE_CONTROL, "BASELINE-CONTROL")                                     \
-  V(BIND, "BIND")                                                             \
-  V(CHECKIN, "CHECKIN")                                                       \
-  V(CHECKOUT, "CHECKOUT")                                                     \
-  V(CONNECT, "CONNECT")                                                       \
-  V(COPY, "COPY")                                                             \
-  V(DELETE, "DELETE")                                                         \
-  V(GET, "GET")                                                               \
-  V(HEAD, "HEAD")                                                             \
-  V(LABEL, "LABEL")                                                           \
-  V(LINK, "LINK")                                                             \
-  V(LOCK, "LOCK")                                                             \
-  V(MERGE, "MERGE")                                                           \
-  V(MKACTIVITY, "MKACTIVITY")                                                 \
-  V(MKCALENDAR, "MKCALENDAR")                                                 \
-  V(MKCOL, "MKCOL")                                                           \
-  V(MKREDIRECTREF, "MKREDIRECTREF")                                           \
-  V(MKWORKSPACE, "MKWORKSPACE")                                               \
-  V(MOVE, "MOVE")                                                             \
-  V(OPTIONS, "OPTIONS")                                                       \
-  V(ORDERPATCH, "ORDERPATCH")                                                 \
-  V(PATCH, "PATCH")                                                           \
-  V(POST, "POST")                                                             \
-  V(PRI, "PRI")                                                               \
-  V(PROPFIND, "PROPFIND")                                                     \
-  V(PROPPATCH, "PROPPATCH")                                                   \
-  V(PUT, "PUT")                                                               \
-  V(REBIND, "REBIND")                                                         \
-  V(REPORT, "REPORT")                                                         \
-  V(SEARCH, "SEARCH")                                                         \
-  V(TRACE, "TRACE")                                                           \
-  V(UNBIND, "UNBIND")                                                         \
-  V(UNCHECKOUT, "UNCHECKOUT")                                                 \
-  V(UNLINK, "UNLINK")                                                         \
-  V(UNLOCK, "UNLOCK")                                                         \
-  V(UPDATE, "UPDATE")                                                         \
-  V(UPDATEREDIRECTREF, "UPDATEREDIRECTREF")                                   \
-  V(VERSION_CONTROL, "VERSION-CONTROL")
-
-// These are provided strictly as a convenience to users and are exposed via the
-// require('http2').constants objects
-#define HTTP_KNOWN_HEADERS(V)                                                 \
-  V(STATUS, ":status")                                                        \
-  V(METHOD, ":method")                                                        \
-  V(AUTHORITY, ":authority")                                                  \
-  V(SCHEME, ":scheme")                                                        \
-  V(PATH, ":path")                                                            \
-  V(PROTOCOL, ":protocol")                                                    \
-  V(ACCEPT_CHARSET, "accept-charset")                                         \
-  V(ACCEPT_ENCODING, "accept-encoding")                                       \
-  V(ACCEPT_LANGUAGE, "accept-language")                                       \
-  V(ACCEPT_RANGES, "accept-ranges")                                           \
-  V(ACCEPT, "accept")                                                         \
-  V(ACCESS_CONTROL_ALLOW_CREDENTIALS, "access-control-allow-credentials")     \
-  V(ACCESS_CONTROL_ALLOW_HEADERS, "access-control-allow-headers")             \
-  V(ACCESS_CONTROL_ALLOW_METHODS, "access-control-allow-methods")             \
-  V(ACCESS_CONTROL_ALLOW_ORIGIN, "access-control-allow-origin")               \
-  V(ACCESS_CONTROL_EXPOSE_HEADERS, "access-control-expose-headers")           \
-  V(ACCESS_CONTROL_MAX_AGE, "access-control-max-age")                         \
-  V(ACCESS_CONTROL_REQUEST_HEADERS, "access-control-request-headers")         \
-  V(ACCESS_CONTROL_REQUEST_METHOD, "access-control-request-method")           \
-  V(AGE, "age")                                                               \
-  V(ALLOW, "allow")                                                           \
-  V(AUTHORIZATION, "authorization")                                           \
-  V(CACHE_CONTROL, "cache-control")                                           \
-  V(CONNECTION, "connection")                                                 \
-  V(CONTENT_DISPOSITION, "content-disposition")                               \
-  V(CONTENT_ENCODING, "content-encoding")                                     \
-  V(CONTENT_LANGUAGE, "content-language")                                     \
-  V(CONTENT_LENGTH, "content-length")                                         \
-  V(CONTENT_LOCATION, "content-location")                                     \
-  V(CONTENT_MD5, "content-md5")                                               \
-  V(CONTENT_RANGE, "content-range")                                           \
-  V(CONTENT_TYPE, "content-type")                                             \
-  V(COOKIE, "cookie")                                                         \
-  V(DATE, "date")                                                             \
-  V(DNT, "dnt")                                                               \
-  V(ETAG, "etag")                                                             \
-  V(EXPECT, "expect")                                                         \
-  V(EXPIRES, "expires")                                                       \
-  V(FORWARDED, "forwarded")                                                   \
-  V(FROM, "from")                                                             \
-  V(HOST, "host")                                                             \
-  V(IF_MATCH, "if-match")                                                     \
-  V(IF_MODIFIED_SINCE, "if-modified-since")                                   \
-  V(IF_NONE_MATCH, "if-none-match")                                           \
-  V(IF_RANGE, "if-range")                                                     \
-  V(IF_UNMODIFIED_SINCE, "if-unmodified-since")                               \
-  V(LAST_MODIFIED, "last-modified")                                           \
-  V(LINK, "link")                                                             \
-  V(LOCATION, "location")                                                     \
-  V(MAX_FORWARDS, "max-forwards")                                             \
-  V(PREFER, "prefer")                                                         \
-  V(PROXY_AUTHENTICATE, "proxy-authenticate")                                 \
-  V(PROXY_AUTHORIZATION, "proxy-authorization")                               \
-  V(RANGE, "range")                                                           \
-  V(REFERER, "referer")                                                       \
-  V(REFRESH, "refresh")                                                       \
-  V(RETRY_AFTER, "retry-after")                                               \
-  V(SERVER, "server")                                                         \
-  V(SET_COOKIE, "set-cookie")                                                 \
-  V(STRICT_TRANSPORT_SECURITY, "strict-transport-security")                   \
-  V(TRAILER, "trailer")                                                       \
-  V(TRANSFER_ENCODING, "transfer-encoding")                                   \
-  V(TE, "te")                                                                 \
-  V(TK, "tk")                                                                 \
-  V(UPGRADE_INSECURE_REQUESTS, "upgrade-insecure-requests")                   \
-  V(UPGRADE, "upgrade")                                                       \
-  V(USER_AGENT, "user-agent")                                                 \
-  V(VARY, "vary")                                                             \
-  V(VIA, "via")                                                               \
-  V(WARNING, "warning")                                                       \
-  V(WWW_AUTHENTICATE, "www-authenticate")                                     \
-  V(X_CONTENT_TYPE_OPTIONS, "x-content-type-options")                         \
-  V(X_FRAME_OPTIONS, "x-frame-options")                                       \
-  V(HTTP2_SETTINGS, "http2-settings")                                         \
-  V(KEEP_ALIVE, "keep-alive")                                                 \
-  V(PROXY_CONNECTION, "proxy-connection")
-
-enum http_known_headers {
-  HTTP_KNOWN_HEADER_MIN,
-#define V(name, value) HTTP_HEADER_##name,
-  HTTP_KNOWN_HEADERS(V)
-#undef V
-  HTTP_KNOWN_HEADER_MAX
-};
-
-// While some of these codes are used within the HTTP/2 implementation in
-// core, they are provided strictly as a convenience to users and are exposed
-// via the require('http2').constants object.
-#define HTTP_STATUS_CODES(V)                                                  \
-  V(CONTINUE, 100)                                                            \
-  V(SWITCHING_PROTOCOLS, 101)                                                 \
-  V(PROCESSING, 102)                                                          \
-  V(EARLY_HINTS, 103)                                                         \
-  V(OK, 200)                                                                  \
-  V(CREATED, 201)                                                             \
-  V(ACCEPTED, 202)                                                            \
-  V(NON_AUTHORITATIVE_INFORMATION, 203)                                       \
-  V(NO_CONTENT, 204)                                                          \
-  V(RESET_CONTENT, 205)                                                       \
-  V(PARTIAL_CONTENT, 206)                                                     \
-  V(MULTI_STATUS, 207)                                                        \
-  V(ALREADY_REPORTED, 208)                                                    \
-  V(IM_USED, 226)                                                             \
-  V(MULTIPLE_CHOICES, 300)                                                    \
-  V(MOVED_PERMANENTLY, 301)                                                   \
-  V(FOUND, 302)                                                               \
-  V(SEE_OTHER, 303)                                                           \
-  V(NOT_MODIFIED, 304)                                                        \
-  V(USE_PROXY, 305)                                                           \
-  V(TEMPORARY_REDIRECT, 307)                                                  \
-  V(PERMANENT_REDIRECT, 308)                                                  \
-  V(BAD_REQUEST, 400)                                                         \
-  V(UNAUTHORIZED, 401)                                                        \
-  V(PAYMENT_REQUIRED, 402)                                                    \
-  V(FORBIDDEN, 403)                                                           \
-  V(NOT_FOUND, 404)                                                           \
-  V(METHOD_NOT_ALLOWED, 405)                                                  \
-  V(NOT_ACCEPTABLE, 406)                                                      \
-  V(PROXY_AUTHENTICATION_REQUIRED, 407)                                       \
-  V(REQUEST_TIMEOUT, 408)                                                     \
-  V(CONFLICT, 409)                                                            \
-  V(GONE, 410)                                                                \
-  V(LENGTH_REQUIRED, 411)                                                     \
-  V(PRECONDITION_FAILED, 412)                                                 \
-  V(PAYLOAD_TOO_LARGE, 413)                                                   \
-  V(URI_TOO_LONG, 414)                                                        \
-  V(UNSUPPORTED_MEDIA_TYPE, 415)                                              \
-  V(RANGE_NOT_SATISFIABLE, 416)                                               \
-  V(EXPECTATION_FAILED, 417)                                                  \
-  V(TEAPOT, 418)                                                              \
-  V(MISDIRECTED_REQUEST, 421)                                                 \
-  V(UNPROCESSABLE_ENTITY, 422)                                                \
-  V(LOCKED, 423)                                                              \
-  V(FAILED_DEPENDENCY, 424)                                                   \
-  V(UNORDERED_COLLECTION, 425)                                                \
-  V(UPGRADE_REQUIRED, 426)                                                    \
-  V(PRECONDITION_REQUIRED, 428)                                               \
-  V(TOO_MANY_REQUESTS, 429)                                                   \
-  V(REQUEST_HEADER_FIELDS_TOO_LARGE, 431)                                     \
-  V(UNAVAILABLE_FOR_LEGAL_REASONS, 451)                                       \
-  V(INTERNAL_SERVER_ERROR, 500)                                               \
-  V(NOT_IMPLEMENTED, 501)                                                     \
-  V(BAD_GATEWAY, 502)                                                         \
-  V(SERVICE_UNAVAILABLE, 503)                                                 \
-  V(GATEWAY_TIMEOUT, 504)                                                     \
-  V(HTTP_VERSION_NOT_SUPPORTED, 505)                                          \
-  V(VARIANT_ALSO_NEGOTIATES, 506)                                             \
-  V(INSUFFICIENT_STORAGE, 507)                                                \
-  V(LOOP_DETECTED, 508)                                                       \
-  V(BANDWIDTH_LIMIT_EXCEEDED, 509)                                            \
-  V(NOT_EXTENDED, 510)                                                        \
-  V(NETWORK_AUTHENTICATION_REQUIRED, 511)
-
-enum http_status_codes {
-#define V(name, code) HTTP_STATUS_##name = code,
-  HTTP_STATUS_CODES(V)
-#undef V
-};
+struct NgHttp2StreamWrite : public MemoryRetainer {
+  BaseObjectPtr<AsyncWrap> req_wrap;
+  uv_buf_t buf;
 
-// The Padding Strategy determines the method by which extra padding is
-// selected for HEADERS and DATA frames. These are configurable via the
-// options passed in to a Http2Session object.
-enum padding_strategy_type {
-  // No padding strategy. This is the default.
-  PADDING_STRATEGY_NONE,
-  // Attempts to ensure that the frame is 8-byte aligned
-  PADDING_STRATEGY_ALIGNED,
-  // Padding will ensure all data frames are maxFrameSize
-  PADDING_STRATEGY_MAX,
-  // Padding will be determined via a JS callback. Note that this can be
-  // expensive because the callback is called once for every DATA and
-  // HEADERS frame. For performance reasons, this strategy should be
-  // avoided.
-  PADDING_STRATEGY_CALLBACK
-};
+  inline explicit NgHttp2StreamWrite(uv_buf_t buf_) : buf(buf_) {}
+  inline NgHttp2StreamWrite(BaseObjectPtr<AsyncWrap> req_wrap, uv_buf_t buf_) :
+      req_wrap(std::move(req_wrap)), buf(buf_) {}
 
-enum session_state_flags {
-  SESSION_STATE_NONE = 0x0,
-  SESSION_STATE_HAS_SCOPE = 0x1,
-  SESSION_STATE_WRITE_SCHEDULED = 0x2,
-  SESSION_STATE_CLOSED = 0x4,
-  SESSION_STATE_CLOSING = 0x8,
-  SESSION_STATE_SENDING = 0x10,
-  SESSION_STATE_WRITE_IN_PROGRESS = 0x20,
-  SESSION_STATE_READING_STOPPED = 0x40,
-  SESSION_STATE_NGHTTP2_RECV_PAUSED = 0x80
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(NgHttp2StreamWrite)
+  SET_SELF_SIZE(NgHttp2StreamWrite)
 };
 
 typedef uint32_t(*get_setting)(nghttp2_session* session,
                                nghttp2_settings_id id);
 
+class Http2Ping;
 class Http2Session;
+class Http2Settings;
 class Http2Stream;
+class Origins;
 
 // This scope should be present when any call into nghttp2 that may schedule
 // data to be written to the underlying transport is made, and schedules
@@ -359,8 +175,7 @@ class Http2Scope {
   ~Http2Scope();
 
  private:
-  Http2Session* session_ = nullptr;
-  Local<Object> session_handle_;
+  BaseObjectPtr<Http2Session> session_;
 };
 
 // The Http2Options class is used to parse the options object passed in to
@@ -369,77 +184,69 @@ class Http2Scope {
 // configured.
 class Http2Options {
  public:
-  Http2Options(Environment* env, nghttp2_session_type type);
+  Http2Options(Http2State* http2_state,
+               SessionType type);
 
-  ~Http2Options() {
-    nghttp2_option_del(options_);
-  }
+  ~Http2Options() = default;
 
   nghttp2_option* operator*() const {
-    return options_;
+    return options_.get();
   }
 
-  void SetMaxHeaderPairs(uint32_t max) {
+  void set_max_header_pairs(uint32_t max) {
     max_header_pairs_ = max;
   }
 
-  uint32_t GetMaxHeaderPairs() const {
+  uint32_t max_header_pairs() const {
     return max_header_pairs_;
   }
 
-  void SetPaddingStrategy(padding_strategy_type val) {
+  void set_padding_strategy(PaddingStrategy val) {
     padding_strategy_ = val;
   }
 
-  padding_strategy_type GetPaddingStrategy() const {
+  PaddingStrategy padding_strategy() const {
     return padding_strategy_;
   }
 
-  void SetMaxOutstandingPings(size_t max) {
+  void set_max_outstanding_pings(size_t max) {
     max_outstanding_pings_ = max;
   }
 
-  size_t GetMaxOutstandingPings() {
+  size_t max_outstanding_pings() const {
     return max_outstanding_pings_;
   }
 
-  void SetMaxOutstandingSettings(size_t max) {
+  void set_max_outstanding_settings(size_t max) {
     max_outstanding_settings_ = max;
   }
 
-  size_t GetMaxOutstandingSettings() {
+  size_t max_outstanding_settings() const {
     return max_outstanding_settings_;
   }
 
-  void SetMaxSessionMemory(uint64_t max) {
+  void set_max_session_memory(uint64_t max) {
     max_session_memory_ = max;
   }
 
-  uint64_t GetMaxSessionMemory() {
+  uint64_t max_session_memory() const {
     return max_session_memory_;
   }
 
  private:
-  nghttp2_option* options_;
-  uint64_t max_session_memory_ = DEFAULT_MAX_SESSION_MEMORY;
+  Nghttp2OptionPointer options_;
+  uint64_t max_session_memory_ = kDefaultMaxSessionMemory;
   uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;
-  padding_strategy_type padding_strategy_ = PADDING_STRATEGY_NONE;
-  size_t max_outstanding_pings_ = DEFAULT_MAX_PINGS;
-  size_t max_outstanding_settings_ = DEFAULT_MAX_SETTINGS;
+  PaddingStrategy padding_strategy_ = PADDING_STRATEGY_NONE;
+  size_t max_outstanding_pings_ = kDefaultMaxPings;
+  size_t max_outstanding_settings_ = kDefaultMaxSettings;
 };
 
-class Http2Priority {
- public:
+struct Http2Priority : public nghttp2_priority_spec {
   Http2Priority(Environment* env,
-                Local<Value> parent,
-                Local<Value> weight,
-                Local<Value> exclusive);
-
-  nghttp2_priority_spec* operator*() {
-    return &spec;
-  }
- private:
-  nghttp2_priority_spec spec;
+                v8::Local<v8::Value> parent,
+                v8::Local<v8::Value> weight,
+                v8::Local<v8::Value> exclusive);
 };
 
 class Http2StreamListener : public StreamListener {
@@ -448,6 +255,17 @@ class Http2StreamListener : public StreamListener {
   void OnStreamRead(ssize_t nread, const uv_buf_t& buf) override;
 };
 
+struct Http2HeaderTraits {
+  typedef Http2RcBufferPointer rcbufferpointer_t;
+  typedef Http2Session allocator_t;
+
+  // HTTP/2 does not support identifying header names by token id.
+  // HTTP/3 will, however, so we prepare for that now.
+  static const char* ToHttpHeaderName(int32_t token) { return nullptr; }
+};
+
+using Http2Header = NgHeader<Http2HeaderTraits>;
+
 class Http2Stream : public AsyncWrap,
                     public StreamBase {
  public:
@@ -458,13 +276,13 @@ class Http2Stream : public AsyncWrap,
       int options = 0);
   ~Http2Stream() override;
 
-  nghttp2_stream* operator*();
+  nghttp2_stream* operator*() const;
+
+  nghttp2_stream* stream() const;
 
   Http2Session* session() { return session_.get(); }
   const Http2Session* session() const { return session_.get(); }
 
-  void EmitStatistics();
-
   // Required for StreamBase
   int ReadStart() override;
 
@@ -478,17 +296,17 @@ class Http2Stream : public AsyncWrap,
   bool HasWantsWrite() const override { return true; }
 
   // Initiate a response on this stream.
-  int SubmitResponse(nghttp2_nv* nva, size_t len, int options);
+  int SubmitResponse(const Http2Headers& headers, int options);
 
   // Submit informational headers for this stream
-  int SubmitInfo(nghttp2_nv* nva, size_t len);
+  int SubmitInfo(const Http2Headers& headers);
 
   // Submit trailing headers for this stream
-  int SubmitTrailers(nghttp2_nv* nva, size_t len);
+  int SubmitTrailers(const Http2Headers& headers);
   void OnTrailers();
 
   // Submit a PRIORITY frame for this stream
-  int SubmitPriority(nghttp2_priority_spec* prispec, bool silent = false);
+  int SubmitPriority(const Http2Priority& priority, bool silent = false);
 
   // Submits an RST_STREAM frame using the given code
   void SubmitRstStream(const uint32_t code);
@@ -497,8 +315,7 @@ class Http2Stream : public AsyncWrap,
 
   // Submits a PUSH_PROMISE frame with this stream as the parent.
   Http2Stream* SubmitPushPromise(
-      nghttp2_nv* nva,
-      size_t len,
+      const Http2Headers& headers,
       int32_t* ret,
       int options = 0);
 
@@ -508,50 +325,90 @@ class Http2Stream : public AsyncWrap,
   // Destroy this stream instance and free all held memory.
   void Destroy();
 
-  inline bool IsDestroyed() const {
-    return flags_ & NGHTTP2_STREAM_FLAG_DESTROYED;
+  bool is_destroyed() const {
+    return flags_ & kStreamStateDestroyed;
   }
 
-  inline bool IsWritable() const {
-    return !(flags_ & NGHTTP2_STREAM_FLAG_SHUT);
+  bool is_writable() const {
+    return !(flags_ & kStreamStateShut);
   }
 
-  inline bool IsPaused() const {
-    return flags_ & NGHTTP2_STREAM_FLAG_READ_PAUSED;
+  bool is_paused() const {
+    return flags_ & kStreamStateReadPaused;
   }
 
-  inline bool IsClosed() const {
-    return flags_ & NGHTTP2_STREAM_FLAG_CLOSED;
+  bool is_closed() const {
+    return flags_ & kStreamStateClosed;
   }
 
-  inline bool HasTrailers() const {
-    return flags_ & NGHTTP2_STREAM_FLAG_TRAILERS;
+  bool has_trailers() const {
+    return flags_ & kStreamStateTrailers;
+  }
+
+  void set_has_trailers(bool on = true) {
+    if (on)
+      flags_ |= kStreamStateTrailers;
+    else
+      flags_ &= ~kStreamStateTrailers;
+  }
+
+  void set_closed() {
+    flags_ |= kStreamStateClosed;
+  }
+
+  void set_destroyed() {
+    flags_ |= kStreamStateDestroyed;
+  }
+
+  void set_not_writable() {
+    flags_ |= kStreamStateShut;
+  }
+
+  void set_reading(bool on = true) {
+    if (on) {
+      flags_ |= kStreamStateReadStart;
+      set_paused(false);
+    } else {}
+  }
+
+  void set_paused(bool on = true) {
+    if (on)
+      flags_ |= kStreamStateReadPaused;
+    else
+      flags_ &= ~kStreamStateReadPaused;
   }
 
   // Returns true if this stream is in the reading state, which occurs when
-  // the NGHTTP2_STREAM_FLAG_READ_START flag has been set and the
-  // NGHTTP2_STREAM_FLAG_READ_PAUSED flag is *not* set.
-  inline bool IsReading() const {
-    return flags_ & NGHTTP2_STREAM_FLAG_READ_START &&
-           !(flags_ & NGHTTP2_STREAM_FLAG_READ_PAUSED);
+  // the kStreamStateReadStart flag has been set and the
+  // kStreamStateReadPaused flag is *not* set.
+  bool is_reading() const {
+    return flags_ & kStreamStateReadStart && !is_paused();
   }
 
   // Returns the RST_STREAM code used to close this stream
-  inline int32_t code() const { return code_; }
+  int32_t code() const { return code_; }
 
   // Returns the stream identifier for this stream
-  inline int32_t id() const { return id_; }
+  int32_t id() const { return id_; }
 
-  inline void IncrementAvailableOutboundLength(size_t amount);
-  inline void DecrementAvailableOutboundLength(size_t amount);
+  void IncrementAvailableOutboundLength(size_t amount);
+  void DecrementAvailableOutboundLength(size_t amount);
 
   bool AddHeader(nghttp2_rcbuf* name, nghttp2_rcbuf* value, uint8_t flags);
 
-  inline std::vector<nghttp2_header> move_headers() {
-    return std::move(current_headers_);
+  template <typename Fn>
+  void TransferHeaders(Fn&& fn) {
+    size_t i = 0;
+    for (const auto& header : current_headers_ )
+      fn(header, i++);
+    current_headers_.clear();
   }
 
-  inline nghttp2_headers_category headers_category() const {
+  size_t headers_count() const {
+    return current_headers_.size();
+  }
+
+  nghttp2_headers_category headers_category() const {
     return current_headers_category_;
   }
 
@@ -572,26 +429,22 @@ class Http2Stream : public AsyncWrap,
   int DoWrite(WriteWrap* w, uv_buf_t* bufs, size_t count,
               uv_stream_t* send_handle) override;
 
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("current_headers", current_headers_);
-    tracker->TrackField("queue", queue_);
-  }
-
+  void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Http2Stream)
   SET_SELF_SIZE(Http2Stream)
 
   std::string diagnostic_name() const override;
 
   // JavaScript API
-  static void GetID(const FunctionCallbackInfo<Value>& args);
-  static void Destroy(const FunctionCallbackInfo<Value>& args);
-  static void Priority(const FunctionCallbackInfo<Value>& args);
-  static void PushPromise(const FunctionCallbackInfo<Value>& args);
-  static void RefreshState(const FunctionCallbackInfo<Value>& args);
-  static void Info(const FunctionCallbackInfo<Value>& args);
-  static void Trailers(const FunctionCallbackInfo<Value>& args);
-  static void Respond(const FunctionCallbackInfo<Value>& args);
-  static void RstStream(const FunctionCallbackInfo<Value>& args);
+  static void GetID(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Priority(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void PushPromise(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RefreshState(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Info(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Trailers(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Respond(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RstStream(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   class Provider;
 
@@ -614,10 +467,12 @@ class Http2Stream : public AsyncWrap,
               nghttp2_headers_category category,
               int options);
 
+  void EmitStatistics();
+
   BaseObjectWeakPtr<Http2Session> session_;     // The Parent HTTP/2 Session
   int32_t id_ = 0;                              // The Stream Identifier
   int32_t code_ = NGHTTP2_NO_ERROR;             // The RST_STREAM code (if any)
-  int flags_ = NGHTTP2_STREAM_FLAG_NONE;        // Internal state flags
+  int flags_ = kStreamStateNone;        // Internal state flags
 
   uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;
   uint32_t max_header_length_ = DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE;
@@ -627,7 +482,7 @@ class Http2Stream : public AsyncWrap,
   // signalling the end of the HEADERS frame
   nghttp2_headers_category current_headers_category_ = NGHTTP2_HCAT_HEADERS;
   uint32_t current_headers_length_ = 0;  // total number of octets
-  std::vector<nghttp2_header> current_headers_;
+  std::vector<Http2Header> current_headers_;
 
   // This keeps track of the amount of data read from the socket while the
   // socket was in paused mode. When `ReadStart()` is called (and not before
@@ -637,7 +492,7 @@ class Http2Stream : public AsyncWrap,
 
   // Outbound Data... This is the data written by the JS layer that is
   // waiting to be written out to the socket.
-  std::queue<nghttp2_stream_write> queue_;
+  std::queue<NgHttp2StreamWrite> queue_;
   size_t available_outbound_length_ = 0;
 
   Http2StreamListener stream_listener_;
@@ -712,31 +567,30 @@ class Http2Session : public AsyncWrap,
                      public StreamListener,
                      public mem::NgLibMemoryManager<Http2Session, nghttp2_mem> {
  public:
-  Http2Session(Environment* env,
-               Local<Object> wrap,
-               nghttp2_session_type type = NGHTTP2_SESSION_SERVER);
+  Http2Session(Http2State* http2_state,
+               v8::Local<v8::Object> wrap,
+               SessionType type = NGHTTP2_SESSION_SERVER);
   ~Http2Session() override;
 
-  class Http2Ping;
-  class Http2Settings;
-
-  void EmitStatistics();
-
-  inline StreamBase* underlying_stream() {
+  StreamBase* underlying_stream() {
     return static_cast<StreamBase*>(stream_);
   }
 
   void Close(uint32_t code = NGHTTP2_NO_ERROR,
              bool socket_closed = false);
-  void Consume(Local<Object> stream);
+
+  void Consume(v8::Local<v8::Object> stream);
+
   void Goaway(uint32_t code, int32_t lastStreamID,
               const uint8_t* data, size_t len);
+
   void AltSvc(int32_t id,
               uint8_t* origin,
               size_t origin_len,
               uint8_t* value,
               size_t value_len);
-  void Origin(nghttp2_origin_entry* ov, size_t count);
+
+  void Origin(const Origins& origins);
 
   uint8_t SendPendingData();
 
@@ -744,39 +598,45 @@ class Http2Session : public AsyncWrap,
   // will be a pointer to the Http2Stream instance assigned.
   // This only works if the session is a client session.
   Http2Stream* SubmitRequest(
-      nghttp2_priority_spec* prispec,
-      nghttp2_nv* nva,
-      size_t len,
+      const Http2Priority& priority,
+      const Http2Headers& headers,
       int32_t* ret,
       int options = 0);
 
-  inline nghttp2_session_type type() const { return session_type_; }
+  SessionType type() const { return session_type_; }
 
-  inline nghttp2_session* session() const { return session_; }
+  nghttp2_session* session() const { return session_.get(); }
 
-  inline nghttp2_session* operator*() { return session_; }
+  nghttp2_session* operator*() { return session_.get(); }
 
-  inline uint32_t GetMaxHeaderPairs() const { return max_header_pairs_; }
+  uint32_t max_header_pairs() const { return max_header_pairs_; }
 
-  inline const char* TypeName() const;
+  const char* TypeName() const;
 
-  inline bool IsDestroyed() {
-    return (flags_ & SESSION_STATE_CLOSED) || session_ == nullptr;
+  bool is_destroyed() {
+    return (flags_ & kSessionStateClosed) || session_ == nullptr;
   }
 
+  void set_destroyed() {
+    flags_ |= kSessionStateClosed;
+  }
 
-  // The changes are backported and exposes APIs to check the
-  // status flag of `Http2Session`
 #define IS_FLAG(name, flag)                                                    \
-  bool is_##name() const { return flags_ & flag; }
+  bool is_##name() const { return flags_ & flag; }                             \
+  void set_##name(bool on = true) {                                            \
+    if (on)                                                                    \
+      flags_ |= flag;                                                          \
+    else                                                                       \
+      flags_ &= ~flag;                                                         \
+  }
 
-  IS_FLAG(in_scope, SESSION_STATE_HAS_SCOPE)
-  IS_FLAG(write_scheduled, SESSION_STATE_WRITE_SCHEDULED)
-  IS_FLAG(closing, SESSION_STATE_CLOSING)
-  IS_FLAG(sending, SESSION_STATE_SENDING)
-  IS_FLAG(write_in_progress, SESSION_STATE_WRITE_IN_PROGRESS)
-  IS_FLAG(reading_stopped, SESSION_STATE_READING_STOPPED)
-  IS_FLAG(receive_paused, SESSION_STATE_NGHTTP2_RECV_PAUSED)
+  IS_FLAG(in_scope, kSessionStateHasScope)
+  IS_FLAG(write_scheduled, kSessionStateWriteScheduled)
+  IS_FLAG(closing, kSessionStateClosing)
+  IS_FLAG(sending, kSessionStateSending)
+  IS_FLAG(write_in_progress, kSessionStateWriteInProgress)
+  IS_FLAG(reading_stopped, kSessionStateReadingStopped)
+  IS_FLAG(receive_paused, kSessionStateReceivePaused)
 
 #undef IS_FLAG
 
@@ -787,15 +647,15 @@ class Http2Session : public AsyncWrap,
   void MaybeStopReading();
 
   // Returns pointer to the stream, or nullptr if stream does not exist
-  inline Http2Stream* FindStream(int32_t id);
+  BaseObjectPtr<Http2Stream> FindStream(int32_t id);
 
-  inline bool CanAddStream();
+  bool CanAddStream();
 
   // Adds a stream instance to this session
-  inline void AddStream(Http2Stream* stream);
+  void AddStream(Http2Stream* stream);
 
   // Removes a stream instance from this session
-  inline void RemoveStream(Http2Stream* stream);
+  BaseObjectPtr<Http2Stream> RemoveStream(int32_t id);
 
   // Indicates whether there currently exist outgoing buffers for this stream.
   bool HasWritesOnSocketForStream(Http2Stream* stream);
@@ -803,32 +663,22 @@ class Http2Session : public AsyncWrap,
   // Write data from stream_buf_ to the session
   ssize_t ConsumeHTTP2Data();
 
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("streams", streams_);
-    tracker->TrackField("outstanding_pings", outstanding_pings_);
-    tracker->TrackField("outstanding_settings", outstanding_settings_);
-    tracker->TrackField("outgoing_buffers", outgoing_buffers_);
-    tracker->TrackFieldWithSize("stream_buf", stream_buf_.len);
-    tracker->TrackFieldWithSize("outgoing_storage", outgoing_storage_.size());
-    tracker->TrackFieldWithSize("pending_rst_streams",
-                                pending_rst_streams_.size() * sizeof(int32_t));
-    tracker->TrackFieldWithSize("nghttp2_memory", current_nghttp2_memory_);
-  }
-
+  void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Http2Session)
   SET_SELF_SIZE(Http2Session)
 
   std::string diagnostic_name() const override;
 
   // Schedule an RstStream for after the current write finishes.
-  inline void AddPendingRstStream(int32_t stream_id) {
+  void AddPendingRstStream(int32_t stream_id) {
     pending_rst_streams_.emplace_back(stream_id);
   }
 
-  inline bool HasPendingRstStream(int32_t stream_id) {
-    return pending_rst_streams_.end() != std::find(pending_rst_streams_.begin(),
-                                                   pending_rst_streams_.end(),
-                                                   stream_id);
+  bool has_pending_rststream(int32_t stream_id) {
+    return pending_rst_streams_.end() !=
+        std::find(pending_rst_streams_.begin(),
+            pending_rst_streams_.end(),
+            stream_id);
   }
 
   // Handle reads/writes from the underlying network transport.
@@ -842,31 +692,36 @@ class Http2Session : public AsyncWrap,
   void DecreaseAllocatedSize(size_t size);
 
   // The JavaScript API
-  static void New(const FunctionCallbackInfo<Value>& args);
-  static void Consume(const FunctionCallbackInfo<Value>& args);
-  static void Destroy(const FunctionCallbackInfo<Value>& args);
-  static void Settings(const FunctionCallbackInfo<Value>& args);
-  static void Request(const FunctionCallbackInfo<Value>& args);
-  static void SetNextStreamID(const FunctionCallbackInfo<Value>& args);
-  static void Goaway(const FunctionCallbackInfo<Value>& args);
-  static void UpdateChunksSent(const FunctionCallbackInfo<Value>& args);
-  static void RefreshState(const FunctionCallbackInfo<Value>& args);
-  static void Ping(const FunctionCallbackInfo<Value>& args);
-  static void AltSvc(const FunctionCallbackInfo<Value>& args);
-  static void Origin(const FunctionCallbackInfo<Value>& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Consume(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Receive(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Settings(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Request(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetNextStreamID(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetLocalWindowSize(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Goaway(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void UpdateChunksSent(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RefreshState(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Ping(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AltSvc(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Origin(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   template <get_setting fn>
-  static void RefreshSettings(const FunctionCallbackInfo<Value>& args);
+  static void RefreshSettings(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   uv_loop_t* event_loop() const {
     return env()->event_loop();
   }
 
+  Http2State* http2_state() const { return http2_state_.get(); }
+
   BaseObjectPtr<Http2Ping> PopPing();
-  Http2Ping* AddPing(BaseObjectPtr<Http2Ping> ping);
+  bool AddPing(const uint8_t* data, v8::Local<v8::Function> callback);
 
   BaseObjectPtr<Http2Settings> PopSettings();
-  Http2Settings* AddSettings(BaseObjectPtr<Http2Settings> settings);
+  bool AddSettings(v8::Local<v8::Function> callback);
 
   void IncrementCurrentSessionMemory(uint64_t amount) {
     current_session_memory_ += amount;
@@ -883,7 +738,7 @@ class Http2Session : public AsyncWrap,
 
   // Returns the current session memory including memory allocated by nghttp2,
   // the current outbound storage queue, and pending writes.
-  uint64_t GetCurrentSessionMemory() {
+  uint64_t current_session_memory() const {
     uint64_t total = current_session_memory_ + sizeof(Http2Session);
     total += current_nghttp2_memory_;
     total += outgoing_storage_.size();
@@ -891,8 +746,8 @@ class Http2Session : public AsyncWrap,
   }
 
   // Return true if current_session_memory + amount is less than the max
-  bool IsAvailableSessionMemory(uint64_t amount) {
-    return GetCurrentSessionMemory() + amount <= max_session_memory_;
+  bool has_available_session_memory(uint64_t amount) const {
+    return current_session_memory() + amount <= max_session_memory_;
   }
 
   struct Statistics {
@@ -911,13 +766,13 @@ class Http2Session : public AsyncWrap,
   Statistics statistics_ = {};
 
  private:
+  void EmitStatistics();
+
   // Frame Padding Strategies
   ssize_t OnDWordAlignedPadding(size_t frameLength,
                                 size_t maxPayloadLen);
   ssize_t OnMaxFrameSizePadding(size_t frameLength,
                                 size_t maxPayloadLen);
-  ssize_t OnCallbackPadding(size_t frameLength,
-                            size_t maxPayloadLen);
 
   // Frame Handler
   int HandleDataFrame(const nghttp2_frame* frame);
@@ -997,40 +852,39 @@ class Http2Session : public AsyncWrap,
       void* user_data);
 
   struct Callbacks {
-    inline explicit Callbacks(bool kHasGetPaddingCallback);
-    inline ~Callbacks();
+    explicit Callbacks(bool kHasGetPaddingCallback);
 
-    nghttp2_session_callbacks* callbacks;
+    Nghttp2SessionCallbacksPointer callbacks;
   };
 
   /* Use callback_struct_saved[kHasGetPaddingCallback ? 1 : 0] */
   static const Callbacks callback_struct_saved[2];
 
   // The underlying nghttp2_session handle
-  nghttp2_session* session_;
+  Nghttp2SessionPointer session_;
 
   // JS-accessible numeric fields, as indexed by SessionUint8Fields.
-  SessionJSFields js_fields_ = {};
+  AliasedStruct<SessionJSFields> js_fields_;
 
   // The session type: client or server
-  nghttp2_session_type session_type_;
+  SessionType session_type_;
 
   // The maximum number of header pairs permitted for streams on this session
   uint32_t max_header_pairs_ = DEFAULT_MAX_HEADER_LIST_PAIRS;
 
   // The maximum amount of memory allocated for this session
-  uint64_t max_session_memory_ = DEFAULT_MAX_SESSION_MEMORY;
+  uint64_t max_session_memory_ = kDefaultMaxSessionMemory;
   uint64_t current_session_memory_ = 0;
   // The amount of memory allocated by nghttp2 internals
   uint64_t current_nghttp2_memory_ = 0;
 
   // The collection of active Http2Streams associated with this session
-  std::unordered_map<int32_t, Http2Stream*> streams_;
+  std::unordered_map<int32_t, BaseObjectPtr<Http2Stream>> streams_;
 
-  int flags_ = SESSION_STATE_NONE;
+  int flags_ = kSessionStateNone;
 
   // The StreamBase instance being used for i/o
-  padding_strategy_type padding_strategy_ = PADDING_STRATEGY_NONE;
+  PaddingStrategy padding_strategy_ = PADDING_STRATEGY_NONE;
 
   // use this to allow timeout tracking during long-lasting writes
   uint32_t chunks_sent_since_last_write_ = 0;
@@ -1042,13 +896,13 @@ class Http2Session : public AsyncWrap,
   AllocatedBuffer stream_buf_allocation_;
   size_t stream_buf_offset_ = 0;
 
-  size_t max_outstanding_pings_ = DEFAULT_MAX_PINGS;
+  size_t max_outstanding_pings_ = kDefaultMaxPings;
   std::queue<BaseObjectPtr<Http2Ping>> outstanding_pings_;
 
-  size_t max_outstanding_settings_ = DEFAULT_MAX_SETTINGS;
+  size_t max_outstanding_settings_ = kDefaultMaxSettings;
   std::queue<BaseObjectPtr<Http2Settings>> outstanding_settings_;
 
-  std::vector<nghttp2_stream_write> outgoing_buffers_;
+  std::vector<NgHttp2StreamWrite> outgoing_buffers_;
   std::vector<uint8_t> outgoing_storage_;
   size_t outgoing_length_ = 0;
   std::vector<int32_t> pending_rst_streams_;
@@ -1060,7 +914,10 @@ class Http2Session : public AsyncWrap,
   // Also use the invalid frame count as a measure for rejecting input frames.
   uint32_t invalid_frame_count_ = 0;
 
-  void PushOutgoingBuffer(nghttp2_stream_write&& write);
+  void PushOutgoingBuffer(NgHttp2StreamWrite&& write);
+
+  BaseObjectPtr<Http2State> http2_state_;
+
   void CopyDataIntoOutgoing(const uint8_t* src, size_t src_length);
   void ClearOutgoing(int status);
 
@@ -1068,15 +925,16 @@ class Http2Session : public AsyncWrap,
   friend class Http2StreamListener;
 };
 
-class Http2SessionPerformanceEntry : public PerformanceEntry {
+class Http2SessionPerformanceEntry : public performance::PerformanceEntry {
  public:
   Http2SessionPerformanceEntry(
-      Environment* env,
+      Http2State* http2_state,
       const Http2Session::Statistics& stats,
-      nghttp2_session_type type) :
-          PerformanceEntry(env, "Http2Session", "http2",
-                           stats.start_time,
-                           stats.end_time),
+      SessionType type) :
+          performance::PerformanceEntry(
+              http2_state->env(), "Http2Session", "http2",
+              stats.start_time,
+              stats.end_time),
           ping_rtt_(stats.ping_rtt),
           data_sent_(stats.data_sent),
           data_received_(stats.data_received),
@@ -1085,7 +943,8 @@ class Http2SessionPerformanceEntry : public PerformanceEntry {
           stream_count_(stats.stream_count),
           max_concurrent_streams_(stats.max_concurrent_streams),
           stream_average_duration_(stats.stream_average_duration),
-          session_type_(type) { }
+          session_type_(type),
+          http2_state_(http2_state) { }
 
   uint64_t ping_rtt() const { return ping_rtt_; }
   uint64_t data_sent() const { return data_sent_; }
@@ -1095,10 +954,11 @@ class Http2SessionPerformanceEntry : public PerformanceEntry {
   int32_t stream_count() const { return stream_count_; }
   size_t max_concurrent_streams() const { return max_concurrent_streams_; }
   double stream_average_duration() const { return stream_average_duration_; }
-  nghttp2_session_type type() const { return session_type_; }
+  SessionType type() const { return session_type_; }
+  Http2State* http2_state() const { return http2_state_.get(); }
 
-  void Notify(Local<Value> obj) {
-    PerformanceEntry::Notify(env(), kind(), obj);
+  void Notify(v8::Local<v8::Value> obj) {
+    performance::PerformanceEntry::Notify(env(), kind(), obj);
   }
 
  private:
@@ -1110,24 +970,28 @@ class Http2SessionPerformanceEntry : public PerformanceEntry {
   int32_t stream_count_;
   size_t max_concurrent_streams_;
   double stream_average_duration_;
-  nghttp2_session_type session_type_;
+  SessionType session_type_;
+  BaseObjectPtr<Http2State> http2_state_;
 };
 
-class Http2StreamPerformanceEntry : public PerformanceEntry {
+class Http2StreamPerformanceEntry
+    : public performance::PerformanceEntry {
  public:
   Http2StreamPerformanceEntry(
-      Environment* env,
+      Http2State* http2_state,
       int32_t id,
       const Http2Stream::Statistics& stats) :
-          PerformanceEntry(env, "Http2Stream", "http2",
-                           stats.start_time,
-                           stats.end_time),
+          performance::PerformanceEntry(
+              http2_state->env(), "Http2Stream", "http2",
+              stats.start_time,
+              stats.end_time),
           id_(id),
           first_header_(stats.first_header),
           first_byte_(stats.first_byte),
           first_byte_sent_(stats.first_byte_sent),
           sent_bytes_(stats.sent_bytes),
-          received_bytes_(stats.received_bytes) { }
+          received_bytes_(stats.received_bytes),
+          http2_state_(http2_state) { }
 
   int32_t id() const { return id_; }
   uint64_t first_header() const { return first_header_; }
@@ -1135,9 +999,10 @@ class Http2StreamPerformanceEntry : public PerformanceEntry {
   uint64_t first_byte_sent() const { return first_byte_sent_; }
   uint64_t sent_bytes() const { return sent_bytes_; }
   uint64_t received_bytes() const { return received_bytes_; }
+  Http2State* http2_state() const { return http2_state_.get(); }
 
-  void Notify(Local<Value> obj) {
-    PerformanceEntry::Notify(env(), kind(), obj);
+  void Notify(v8::Local<v8::Value> obj) {
+    performance::PerformanceEntry::Notify(env(), kind(), obj);
   }
 
  private:
@@ -1147,16 +1012,17 @@ class Http2StreamPerformanceEntry : public PerformanceEntry {
   uint64_t first_byte_sent_;
   uint64_t sent_bytes_;
   uint64_t received_bytes_;
+  BaseObjectPtr<Http2State> http2_state_;
 };
 
-class Http2Session::Http2Ping : public AsyncWrap {
+class Http2Ping : public AsyncWrap {
  public:
-  explicit Http2Ping(Http2Session* session, v8::Local<v8::Object> obj);
-
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("session", session_);
-  }
+  explicit Http2Ping(
+      Http2Session* session,
+      v8::Local<v8::Object> obj,
+      v8::Local<v8::Function> callback);
 
+  void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Http2Ping)
   SET_SELF_SIZE(Http2Ping)
 
@@ -1164,150 +1030,71 @@ class Http2Session::Http2Ping : public AsyncWrap {
   void Done(bool ack, const uint8_t* payload = nullptr);
   void DetachFromSession();
 
+  v8::Local<v8::Function> callback() const;
+
  private:
-  Http2Session* session_;
+  BaseObjectWeakPtr<Http2Session> session_;
+  v8::Global<v8::Function> callback_;
   uint64_t startTime_;
 };
 
 // The Http2Settings class is used to parse the settings passed in for
 // an Http2Session, converting those into an array of nghttp2_settings_entry
 // structs.
-class Http2Session::Http2Settings : public AsyncWrap {
+class Http2Settings : public AsyncWrap {
  public:
-  Http2Settings(Environment* env,
-                Http2Session* session,
+  Http2Settings(Http2Session* session,
                 v8::Local<v8::Object> obj,
+                v8::Local<v8::Function> callback,
                 uint64_t start_time = uv_hrtime());
 
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("session", session_);
-  }
-
+  void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Http2Settings)
   SET_SELF_SIZE(Http2Settings)
 
   void Send();
   void Done(bool ack);
 
+  v8::Local<v8::Function> callback() const;
+
   // Returns a Buffer instance with the serialized SETTINGS payload
-  Local<Value> Pack();
+  v8::Local<v8::Value> Pack();
+
+  static v8::Local<v8::Value> Pack(Http2State* state);
 
   // Resets the default values in the settings buffer
-  static void RefreshDefaults(Environment* env);
+  static void RefreshDefaults(Http2State* http2_state);
 
   // Update the local or remote settings for the given session
-  static void Update(Environment* env,
-                     Http2Session* session,
+  static void Update(Http2Session* session,
                      get_setting fn);
 
  private:
-  void Init();
-  Http2Session* session_;
+  static size_t Init(
+      Http2State* http2_state,
+      nghttp2_settings_entry* entries);
+
+  static v8::Local<v8::Value> Pack(
+      Environment* env,
+      size_t count,
+      const nghttp2_settings_entry* entries);
+
+  BaseObjectWeakPtr<Http2Session> session_;
+  v8::Global<v8::Function> callback_;
   uint64_t startTime_;
   size_t count_ = 0;
   nghttp2_settings_entry entries_[IDX_SETTINGS_COUNT];
 };
 
-class ExternalHeader :
-    public String::ExternalOneByteStringResource {
- public:
-  explicit ExternalHeader(nghttp2_rcbuf* buf)
-     : buf_(buf), vec_(nghttp2_rcbuf_get_buf(buf)) {
-  }
-
-  ~ExternalHeader() override {
-    nghttp2_rcbuf_decref(buf_);
-    buf_ = nullptr;
-  }
-
-  const char* data() const override {
-    return const_cast<const char*>(reinterpret_cast<char*>(vec_.base));
-  }
-
-  size_t length() const override {
-    return vec_.len;
-  }
-
-  static inline
-  MaybeLocal<String> GetInternalizedString(Environment* env,
-                                           const nghttp2_vec& vec) {
-    return String::NewFromOneByte(env->isolate(),
-                                  vec.base,
-                                  v8::NewStringType::kInternalized,
-                                  vec.len);
-  }
-
-  template <bool may_internalize>
-  static MaybeLocal<String> New(Http2Session* session, nghttp2_rcbuf* buf) {
-    Environment* env = session->env();
-    if (nghttp2_rcbuf_is_static(buf)) {
-      auto& static_str_map = env->isolate_data()->http2_static_strs;
-      v8::Eternal<v8::String>& eternal = static_str_map[buf];
-      if (eternal.IsEmpty()) {
-        Local<String> str =
-            GetInternalizedString(env, nghttp2_rcbuf_get_buf(buf))
-                .ToLocalChecked();
-        eternal.Set(env->isolate(), str);
-        return str;
-      }
-      return eternal.Get(env->isolate());
-    }
-
-    nghttp2_vec vec = nghttp2_rcbuf_get_buf(buf);
-    if (vec.len == 0) {
-      nghttp2_rcbuf_decref(buf);
-      return String::Empty(env->isolate());
-    }
-
-    if (may_internalize && vec.len < 64) {
-      nghttp2_rcbuf_decref(buf);
-      // This is a short header name, so there is a good chance V8 already has
-      // it internalized.
-      return GetInternalizedString(env, vec);
-    }
-
-    session->StopTrackingRcbuf(buf);
-    ExternalHeader* h_str = new ExternalHeader(buf);
-    MaybeLocal<String> str = String::NewExternalOneByte(env->isolate(), h_str);
-    if (str.IsEmpty())
-      delete h_str;
-
-    return str;
-  }
-
- private:
-  nghttp2_rcbuf* buf_;
-  nghttp2_vec vec_;
-};
-
-class Headers {
- public:
-  Headers(Isolate* isolate, Local<Context> context, Local<Array> headers);
-  ~Headers() = default;
-
-  nghttp2_nv* operator*() {
-    return reinterpret_cast<nghttp2_nv*>(*buf_);
-  }
-
-  size_t length() const {
-    return count_;
-  }
-
- private:
-  size_t count_;
-  MaybeStackBuffer<char, 3000> buf_;
-};
-
 class Origins {
  public:
-  Origins(Isolate* isolate,
-          Local<Context> context,
-          Local<v8::String> origin_string,
+  Origins(Environment* env,
+          v8::Local<v8::String> origin_string,
           size_t origin_count);
   ~Origins() = default;
 
-  nghttp2_origin_entry* operator*() {
-    return reinterpret_cast<nghttp2_origin_entry*>(*buf_);
+  const nghttp2_origin_entry* operator*() const {
+    return reinterpret_cast<const nghttp2_origin_entry*>(buf_.data());
   }
 
   size_t length() const {
@@ -1316,9 +1103,89 @@ class Origins {
 
  private:
   size_t count_;
-  MaybeStackBuffer<char, 512> buf_;
+  AllocatedBuffer buf_;
 };
 
+#define HTTP2_HIDDEN_CONSTANTS(V)                                              \
+  V(NGHTTP2_HCAT_REQUEST)                                                      \
+  V(NGHTTP2_HCAT_RESPONSE)                                                     \
+  V(NGHTTP2_HCAT_PUSH_RESPONSE)                                                \
+  V(NGHTTP2_HCAT_HEADERS)                                                      \
+  V(NGHTTP2_NV_FLAG_NONE)                                                      \
+  V(NGHTTP2_NV_FLAG_NO_INDEX)                                                  \
+  V(NGHTTP2_ERR_DEFERRED)                                                      \
+  V(NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE)                                       \
+  V(NGHTTP2_ERR_INVALID_ARGUMENT)                                              \
+  V(NGHTTP2_ERR_STREAM_CLOSED)                                                 \
+  V(NGHTTP2_ERR_NOMEM)                                                         \
+  V(STREAM_OPTION_EMPTY_PAYLOAD)                                               \
+  V(STREAM_OPTION_GET_TRAILERS)
+
+#define HTTP2_ERROR_CODES(V)                                                   \
+  V(NGHTTP2_NO_ERROR)                                                          \
+  V(NGHTTP2_PROTOCOL_ERROR)                                                    \
+  V(NGHTTP2_INTERNAL_ERROR)                                                    \
+  V(NGHTTP2_FLOW_CONTROL_ERROR)                                                \
+  V(NGHTTP2_SETTINGS_TIMEOUT)                                                  \
+  V(NGHTTP2_STREAM_CLOSED)                                                     \
+  V(NGHTTP2_FRAME_SIZE_ERROR)                                                  \
+  V(NGHTTP2_REFUSED_STREAM)                                                    \
+  V(NGHTTP2_CANCEL)                                                            \
+  V(NGHTTP2_COMPRESSION_ERROR)                                                 \
+  V(NGHTTP2_CONNECT_ERROR)                                                     \
+  V(NGHTTP2_ENHANCE_YOUR_CALM)                                                 \
+  V(NGHTTP2_INADEQUATE_SECURITY)                                               \
+  V(NGHTTP2_HTTP_1_1_REQUIRED)                                                 \
+
+#define HTTP2_CONSTANTS(V)                                                     \
+  V(NGHTTP2_ERR_FRAME_SIZE_ERROR)                                              \
+  V(NGHTTP2_SESSION_SERVER)                                                    \
+  V(NGHTTP2_SESSION_CLIENT)                                                    \
+  V(NGHTTP2_STREAM_STATE_IDLE)                                                 \
+  V(NGHTTP2_STREAM_STATE_OPEN)                                                 \
+  V(NGHTTP2_STREAM_STATE_RESERVED_LOCAL)                                       \
+  V(NGHTTP2_STREAM_STATE_RESERVED_REMOTE)                                      \
+  V(NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL)                                    \
+  V(NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE)                                   \
+  V(NGHTTP2_STREAM_STATE_CLOSED)                                               \
+  V(NGHTTP2_FLAG_NONE)                                                         \
+  V(NGHTTP2_FLAG_END_STREAM)                                                   \
+  V(NGHTTP2_FLAG_END_HEADERS)                                                  \
+  V(NGHTTP2_FLAG_ACK)                                                          \
+  V(NGHTTP2_FLAG_PADDED)                                                       \
+  V(NGHTTP2_FLAG_PRIORITY)                                                     \
+  V(DEFAULT_SETTINGS_HEADER_TABLE_SIZE)                                        \
+  V(DEFAULT_SETTINGS_ENABLE_PUSH)                                              \
+  V(DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS)                                   \
+  V(DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE)                                      \
+  V(DEFAULT_SETTINGS_MAX_FRAME_SIZE)                                           \
+  V(DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE)                                     \
+  V(DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL)                                  \
+  V(MAX_MAX_FRAME_SIZE)                                                        \
+  V(MIN_MAX_FRAME_SIZE)                                                        \
+  V(MAX_INITIAL_WINDOW_SIZE)                                                   \
+  V(NGHTTP2_SETTINGS_HEADER_TABLE_SIZE)                                        \
+  V(NGHTTP2_SETTINGS_ENABLE_PUSH)                                              \
+  V(NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS)                                   \
+  V(NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE)                                      \
+  V(NGHTTP2_SETTINGS_MAX_FRAME_SIZE)                                           \
+  V(NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE)                                     \
+  V(NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL)                                  \
+  V(PADDING_STRATEGY_NONE)                                                     \
+  V(PADDING_STRATEGY_ALIGNED)                                                  \
+  V(PADDING_STRATEGY_MAX)                                                      \
+  V(PADDING_STRATEGY_CALLBACK)                                                 \
+  HTTP2_ERROR_CODES(V)
+
+#define HTTP2_SETTINGS(V)                                                      \
+  V(HEADER_TABLE_SIZE)                                                         \
+  V(ENABLE_PUSH)                                                               \
+  V(MAX_CONCURRENT_STREAMS)                                                    \
+  V(INITIAL_WINDOW_SIZE)                                                       \
+  V(MAX_FRAME_SIZE)                                                            \
+  V(MAX_HEADER_LIST_SIZE)                                                      \
+  V(ENABLE_CONNECT_PROTOCOL)                                                   \
+
 }  // namespace http2
 }  // namespace node
 
diff --git a/src/node_http2_state.h b/src/node_http2_state.h
index fd8f1c56607b1457f921382f729abfc6c63bfb0d..7cf40ff1017ca33cce5af244b071e713749d7abc 100644
--- a/src/node_http2_state.h
+++ b/src/node_http2_state.h
@@ -5,6 +5,8 @@
 
 #include "aliased_buffer.h"
 
+struct nghttp2_rcbuf;
+
 namespace node {
 namespace http2 {
 
@@ -56,13 +58,6 @@ namespace http2 {
     IDX_OPTIONS_FLAGS
   };
 
-  enum Http2PaddingBufferFields {
-    PADDING_BUF_FRAME_LENGTH,
-    PADDING_BUF_MAX_PAYLOAD_LENGTH,
-    PADDING_BUF_RETURN_VALUE,
-    PADDING_BUF_FIELD_COUNT
-  };
-
   enum Http2StreamStatisticsIndex {
     IDX_STREAM_STATS_ID,
     IDX_STREAM_STATS_TIMETOFIRSTBYTE,
@@ -86,58 +81,54 @@ namespace http2 {
     IDX_SESSION_STATS_COUNT
   };
 
-class Http2State {
+class Http2State : public BaseObject {
  public:
-  explicit Http2State(v8::Isolate* isolate) :
-    root_buffer(
-      isolate,
-      sizeof(http2_state_internal)),
-    session_state_buffer(
-      isolate,
-      offsetof(http2_state_internal, session_state_buffer),
-      IDX_SESSION_STATE_COUNT,
-      root_buffer),
-    stream_state_buffer(
-      isolate,
-      offsetof(http2_state_internal, stream_state_buffer),
-      IDX_STREAM_STATE_COUNT,
-      root_buffer),
-    stream_stats_buffer(
-      isolate,
-      offsetof(http2_state_internal, stream_stats_buffer),
-      IDX_STREAM_STATS_COUNT,
-      root_buffer),
-    session_stats_buffer(
-      isolate,
-      offsetof(http2_state_internal, session_stats_buffer),
-      IDX_SESSION_STATS_COUNT,
-      root_buffer),
-    padding_buffer(
-      isolate,
-      offsetof(http2_state_internal, padding_buffer),
-      PADDING_BUF_FIELD_COUNT,
-      root_buffer),
-    options_buffer(
-      isolate,
-      offsetof(http2_state_internal, options_buffer),
-      IDX_OPTIONS_FLAGS + 1,
-      root_buffer),
-    settings_buffer(
-      isolate,
-      offsetof(http2_state_internal, settings_buffer),
-      IDX_SETTINGS_COUNT + 1,
-      root_buffer) {
-  }
+  Http2State(Environment* env, v8::Local<v8::Object> obj)
+      : BaseObject(env, obj),
+        root_buffer(env->isolate(), sizeof(http2_state_internal)),
+        session_state_buffer(
+            env->isolate(),
+            offsetof(http2_state_internal, session_state_buffer),
+            IDX_SESSION_STATE_COUNT,
+            root_buffer),
+        stream_state_buffer(
+            env->isolate(),
+            offsetof(http2_state_internal, stream_state_buffer),
+            IDX_STREAM_STATE_COUNT,
+            root_buffer),
+        stream_stats_buffer(
+            env->isolate(),
+            offsetof(http2_state_internal, stream_stats_buffer),
+            IDX_STREAM_STATS_COUNT,
+            root_buffer),
+        session_stats_buffer(
+            env->isolate(),
+            offsetof(http2_state_internal, session_stats_buffer),
+            IDX_SESSION_STATS_COUNT,
+            root_buffer),
+        options_buffer(env->isolate(),
+                        offsetof(http2_state_internal, options_buffer),
+                        IDX_OPTIONS_FLAGS + 1,
+                        root_buffer),
+        settings_buffer(env->isolate(),
+                        offsetof(http2_state_internal, settings_buffer),
+                        IDX_SETTINGS_COUNT + 1,
+                        root_buffer) {}
 
   AliasedUint8Array root_buffer;
   AliasedFloat64Array session_state_buffer;
   AliasedFloat64Array stream_state_buffer;
   AliasedFloat64Array stream_stats_buffer;
   AliasedFloat64Array session_stats_buffer;
-  AliasedUint32Array padding_buffer;
   AliasedUint32Array options_buffer;
   AliasedUint32Array settings_buffer;
 
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(Http2State)
+  SET_MEMORY_INFO_NAME(Http2State)
+
+  static constexpr FastStringKey type_name { "http2" };
+
  private:
   struct http2_state_internal {
     // doubles first so that they are always sizeof(double)-aligned
@@ -145,7 +136,6 @@ class Http2State {
     double stream_state_buffer[IDX_STREAM_STATE_COUNT];
     double stream_stats_buffer[IDX_STREAM_STATS_COUNT];
     double session_stats_buffer[IDX_SESSION_STATS_COUNT];
-    uint32_t padding_buffer[PADDING_BUF_FIELD_COUNT];
     uint32_t options_buffer[IDX_OPTIONS_FLAGS + 1];
     uint32_t settings_buffer[IDX_SETTINGS_COUNT + 1];
   };
diff --git a/src/node_http_common-inl.h b/src/node_http_common-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ddc99e7d4e8971a7cde69c69f6317612b2eaaaf
--- /dev/null
+++ b/src/node_http_common-inl.h
@@ -0,0 +1,200 @@
+#ifndef SRC_NODE_HTTP_COMMON_INL_H_
+#define SRC_NODE_HTTP_COMMON_INL_H_
+
+#include "node_http_common.h"
+#include "node.h"
+#include "node_mem-inl.h"
+#include "env-inl.h"
+#include "v8.h"
+
+#include <algorithm>
+
+namespace node {
+
+template <typename T>
+NgHeaders<T>::NgHeaders(Environment* env, v8::Local<v8::Array> headers) {
+  v8::Local<v8::Value> header_string =
+      headers->Get(env->context(), 0).ToLocalChecked();
+  v8::Local<v8::Value> header_count =
+      headers->Get(env->context(), 1).ToLocalChecked();
+  CHECK(header_count->IsUint32());
+  CHECK(header_string->IsString());
+  count_ = header_count.As<v8::Uint32>()->Value();
+  int header_string_len = header_string.As<v8::String>()->Length();
+
+  if (count_ == 0) {
+    CHECK_EQ(header_string_len, 0);
+    return;
+  }
+
+  buf_.AllocateSufficientStorage((alignof(nv_t) - 1) +
+                                 count_ * sizeof(nv_t) +
+                                 header_string_len);
+
+  char* start = AlignUp(buf_.out(), alignof(nv_t));
+  char* header_contents = start + (count_ * sizeof(nv_t));
+  nv_t* const nva = reinterpret_cast<nv_t*>(start);
+
+  CHECK_LE(header_contents + header_string_len, *buf_ + buf_.length());
+  CHECK_EQ(header_string.As<v8::String>()->WriteOneByte(
+               env->isolate(),
+               reinterpret_cast<uint8_t*>(header_contents),
+               0,
+               header_string_len,
+               v8::String::NO_NULL_TERMINATION),
+           header_string_len);
+
+  size_t n = 0;
+  char* p;
+  for (p = header_contents; p < header_contents + header_string_len; n++) {
+    if (n >= count_) {
+      static uint8_t zero = '\0';
+      nva[0].name = nva[0].value = &zero;
+      nva[0].namelen = nva[0].valuelen = 1;
+      count_ = 1;
+      return;
+    }
+
+    nva[n].name = reinterpret_cast<uint8_t*>(p);
+    nva[n].namelen = strlen(p);
+    p += nva[n].namelen + 1;
+    nva[n].value = reinterpret_cast<uint8_t*>(p);
+    nva[n].valuelen = strlen(p);
+    p += nva[n].valuelen + 1;
+    nva[n].flags = *p;
+    p++;
+  }
+}
+
+size_t GetClientMaxHeaderPairs(size_t max_header_pairs) {
+  static constexpr size_t min_header_pairs = 1;
+  return std::max(max_header_pairs, min_header_pairs);
+}
+
+size_t GetServerMaxHeaderPairs(size_t max_header_pairs) {
+  static constexpr size_t min_header_pairs = 4;
+  return std::max(max_header_pairs, min_header_pairs);
+}
+
+template <typename allocator_t>
+std::string NgHeaderBase<allocator_t>::ToString() const {
+  std::string ret = name();
+  ret += " = ";
+  ret += value();
+  return ret;
+}
+
+template <typename T>
+bool NgHeader<T>::IsZeroLength(
+    NgHeader<T>::rcbuf_t* name,
+    NgHeader<T>::rcbuf_t* value) {
+  return IsZeroLength(-1, name, value);
+}
+
+template <typename T>
+bool NgHeader<T>::IsZeroLength(
+    int32_t token,
+    NgHeader<T>::rcbuf_t* name,
+    NgHeader<T>::rcbuf_t* value) {
+
+  if (NgHeader<T>::rcbufferpointer_t::IsZeroLength(value))
+    return true;
+
+  const char* header_name = T::ToHttpHeaderName(token);
+  return header_name != nullptr ||
+      NgHeader<T>::rcbufferpointer_t::IsZeroLength(name);
+}
+
+template <typename T>
+NgHeader<T>::NgHeader(
+    Environment* env,
+    NgHeader<T>::rcbuf_t* name,
+    NgHeader<T>::rcbuf_t* value,
+    uint8_t flags)
+    : NgHeader<T>(env, -1, name, value, flags) {}
+
+template <typename T>
+NgHeader<T>::NgHeader(
+    Environment* env,
+    int32_t token,
+    NgHeader<T>::rcbuf_t* name,
+    NgHeader<T>::rcbuf_t* value,
+    uint8_t flags) : env_(env), token_(token), flags_(flags) {
+  if (token == -1) {
+    CHECK_NOT_NULL(name);
+    name_.reset(name, true);  // Internalizable
+  }
+  CHECK_NOT_NULL(value);
+  name_.reset(name, true);  // Internalizable
+  value_.reset(value);
+}
+
+template <typename T>
+NgHeader<T>::NgHeader(NgHeader<T>&& other) noexcept
+    : name_(std::move(other.name_)),
+      value_(std::move(other.value_)),
+      token_(other.token_),
+      flags_(other.flags_) {
+  other.token_ = -1;
+  other.flags_ = 0;
+  other.env_ = nullptr;
+}
+
+template <typename T>
+void NgHeader<T>::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("name", name_);
+  tracker->TrackField("value", value_);
+}
+
+template <typename T>
+v8::MaybeLocal<v8::String> NgHeader<T>::GetName(
+    NgHeader<T>::allocator_t* allocator) const {
+
+  // Not all instances will support using token id's for header names.
+  // HTTP/2 specifically does not support it.
+  const char* header_name = T::ToHttpHeaderName(token_);
+
+  // If header_name is not nullptr, then it is a known header with
+  // a statically defined name. We can safely internalize it here.
+  if (header_name != nullptr) {
+    auto& static_str_map = env_->isolate_data()->static_str_map;
+    v8::Eternal<v8::String> eternal = static_str_map[header_name];
+    if (eternal.IsEmpty()) {
+      v8::Local<v8::String> str = OneByteString(env_->isolate(), header_name);
+      eternal.Set(env_->isolate(), str);
+      return str;
+    }
+    return eternal.Get(env_->isolate());
+  }
+  return rcbufferpointer_t::External::New(allocator, name_);
+}
+
+template <typename T>
+v8::MaybeLocal<v8::String> NgHeader<T>::GetValue(
+    NgHeader<T>::allocator_t* allocator) const {
+  return rcbufferpointer_t::External::New(allocator, value_);
+}
+
+template <typename T>
+std::string NgHeader<T>::name() const {
+  return name_.str();
+}
+
+template <typename T>
+std::string NgHeader<T>::value() const {
+  return value_.str();
+}
+
+template <typename T>
+size_t NgHeader<T>::length() const {
+  return name_.len() + value_.len();
+}
+
+template <typename T>
+uint8_t NgHeader<T>::flags() const {
+  return flags_;
+}
+
+}  // namespace node
+
+#endif  // SRC_NODE_HTTP_COMMON_INL_H_
diff --git a/src/node_http_common.h b/src/node_http_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..8017c0d7aad30c7ac1172b09c7c748a243a656e5
--- /dev/null
+++ b/src/node_http_common.h
@@ -0,0 +1,531 @@
+#ifndef SRC_NODE_HTTP_COMMON_H_
+#define SRC_NODE_HTTP_COMMON_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "v8.h"
+#include "node_mem.h"
+
+#include <string>
+
+namespace node {
+
+class Environment;
+
+#define MAX_MAX_HEADER_LIST_SIZE 16777215u
+#define DEFAULT_MAX_HEADER_LIST_PAIRS 128u
+#define DEFAULT_MAX_HEADER_LENGTH 8192
+
+#define HTTP_SPECIAL_HEADERS(V)                                               \
+  V(STATUS, ":status")                                                        \
+  V(METHOD, ":method")                                                        \
+  V(AUTHORITY, ":authority")                                                  \
+  V(SCHEME, ":scheme")                                                        \
+  V(PATH, ":path")                                                            \
+  V(PROTOCOL, ":protocol")
+
+#define HTTP_REGULAR_HEADERS(V)                                               \
+  V(ACCEPT_ENCODING, "accept-encoding")                                       \
+  V(ACCEPT_LANGUAGE, "accept-language")                                       \
+  V(ACCEPT_RANGES, "accept-ranges")                                           \
+  V(ACCEPT, "accept")                                                         \
+  V(ACCESS_CONTROL_ALLOW_CREDENTIALS, "access-control-allow-credentials")     \
+  V(ACCESS_CONTROL_ALLOW_HEADERS, "access-control-allow-headers")             \
+  V(ACCESS_CONTROL_ALLOW_METHODS, "access-control-allow-methods")             \
+  V(ACCESS_CONTROL_ALLOW_ORIGIN, "access-control-allow-origin")               \
+  V(ACCESS_CONTROL_EXPOSE_HEADERS, "access-control-expose-headers")           \
+  V(ACCESS_CONTROL_REQUEST_HEADERS, "access-control-request-headers")         \
+  V(ACCESS_CONTROL_REQUEST_METHOD, "access-control-request-method")           \
+  V(AGE, "age")                                                               \
+  V(AUTHORIZATION, "authorization")                                           \
+  V(CACHE_CONTROL, "cache-control")                                           \
+  V(CONNECTION, "connection")                                                 \
+  V(CONTENT_DISPOSITION, "content-disposition")                               \
+  V(CONTENT_ENCODING, "content-encoding")                                     \
+  V(CONTENT_LENGTH, "content-length")                                         \
+  V(CONTENT_TYPE, "content-type")                                             \
+  V(COOKIE, "cookie")                                                         \
+  V(DATE, "date")                                                             \
+  V(ETAG, "etag")                                                             \
+  V(FORWARDED, "forwarded")                                                   \
+  V(HOST, "host")                                                             \
+  V(IF_MODIFIED_SINCE, "if-modified-since")                                   \
+  V(IF_NONE_MATCH, "if-none-match")                                           \
+  V(IF_RANGE, "if-range")                                                     \
+  V(LAST_MODIFIED, "last-modified")                                           \
+  V(LINK, "link")                                                             \
+  V(LOCATION, "location")                                                     \
+  V(RANGE, "range")                                                           \
+  V(REFERER, "referer")                                                       \
+  V(SERVER, "server")                                                         \
+  V(SET_COOKIE, "set-cookie")                                                 \
+  V(STRICT_TRANSPORT_SECURITY, "strict-transport-security")                   \
+  V(TRANSFER_ENCODING, "transfer-encoding")                                   \
+  V(TE, "te")                                                                 \
+  V(UPGRADE_INSECURE_REQUESTS, "upgrade-insecure-requests")                   \
+  V(UPGRADE, "upgrade")                                                       \
+  V(USER_AGENT, "user-agent")                                                 \
+  V(VARY, "vary")                                                             \
+  V(X_CONTENT_TYPE_OPTIONS, "x-content-type-options")                         \
+  V(X_FRAME_OPTIONS, "x-frame-options")                                       \
+  V(KEEP_ALIVE, "keep-alive")                                                 \
+  V(PROXY_CONNECTION, "proxy-connection")                                     \
+  V(X_XSS_PROTECTION, "x-xss-protection")                                     \
+  V(ALT_SVC, "alt-svc")                                                       \
+  V(CONTENT_SECURITY_POLICY, "content-security-policy")                       \
+  V(EARLY_DATA, "early-data")                                                 \
+  V(EXPECT_CT, "expect-ct")                                                   \
+  V(ORIGIN, "origin")                                                         \
+  V(PURPOSE, "purpose")                                                       \
+  V(TIMING_ALLOW_ORIGIN, "timing-allow-origin")                               \
+  V(X_FORWARDED_FOR, "x-forwarded-for")
+
+#define HTTP_ADDITIONAL_HEADERS(V)                                            \
+  V(ACCEPT_CHARSET, "accept-charset")                                         \
+  V(ACCESS_CONTROL_MAX_AGE, "access-control-max-age")                         \
+  V(ALLOW, "allow")                                                           \
+  V(CONTENT_LANGUAGE, "content-language")                                     \
+  V(CONTENT_LOCATION, "content-location")                                     \
+  V(CONTENT_MD5, "content-md5")                                               \
+  V(CONTENT_RANGE, "content-range")                                           \
+  V(DNT, "dnt")                                                               \
+  V(EXPECT, "expect")                                                         \
+  V(EXPIRES, "expires")                                                       \
+  V(FROM, "from")                                                             \
+  V(IF_MATCH, "if-match")                                                     \
+  V(IF_UNMODIFIED_SINCE, "if-unmodified-since")                               \
+  V(MAX_FORWARDS, "max-forwards")                                             \
+  V(PREFER, "prefer")                                                         \
+  V(PROXY_AUTHENTICATE, "proxy-authenticate")                                 \
+  V(PROXY_AUTHORIZATION, "proxy-authorization")                               \
+  V(REFRESH, "refresh")                                                       \
+  V(RETRY_AFTER, "retry-after")                                               \
+  V(TRAILER, "trailer")                                                       \
+  V(TK, "tk")                                                                 \
+  V(VIA, "via")                                                               \
+  V(WARNING, "warning")                                                       \
+  V(WWW_AUTHENTICATE, "www-authenticate")                                     \
+  V(HTTP2_SETTINGS, "http2-settings")
+
+// Special and regular headers are handled specifically by the HTTP/2 (and
+// later HTTP/3) implementation.
+#define HTTP_KNOWN_HEADERS(V)                                                 \
+  HTTP_SPECIAL_HEADERS(V)                                                     \
+  HTTP_REGULAR_HEADERS(V)                                                     \
+  HTTP_ADDITIONAL_HEADERS(V)
+
+enum http_known_headers {
+  HTTP_KNOWN_HEADER_MIN,
+#define V(name, value) HTTP_HEADER_##name,
+  HTTP_KNOWN_HEADERS(V)
+#undef V
+  HTTP_KNOWN_HEADER_MAX
+};
+
+#define HTTP_STATUS_CODES(V)                                                  \
+  V(CONTINUE, 100)                                                            \
+  V(SWITCHING_PROTOCOLS, 101)                                                 \
+  V(PROCESSING, 102)                                                          \
+  V(EARLY_HINTS, 103)                                                         \
+  V(OK, 200)                                                                  \
+  V(CREATED, 201)                                                             \
+  V(ACCEPTED, 202)                                                            \
+  V(NON_AUTHORITATIVE_INFORMATION, 203)                                       \
+  V(NO_CONTENT, 204)                                                          \
+  V(RESET_CONTENT, 205)                                                       \
+  V(PARTIAL_CONTENT, 206)                                                     \
+  V(MULTI_STATUS, 207)                                                        \
+  V(ALREADY_REPORTED, 208)                                                    \
+  V(IM_USED, 226)                                                             \
+  V(MULTIPLE_CHOICES, 300)                                                    \
+  V(MOVED_PERMANENTLY, 301)                                                   \
+  V(FOUND, 302)                                                               \
+  V(SEE_OTHER, 303)                                                           \
+  V(NOT_MODIFIED, 304)                                                        \
+  V(USE_PROXY, 305)                                                           \
+  V(TEMPORARY_REDIRECT, 307)                                                  \
+  V(PERMANENT_REDIRECT, 308)                                                  \
+  V(BAD_REQUEST, 400)                                                         \
+  V(UNAUTHORIZED, 401)                                                        \
+  V(PAYMENT_REQUIRED, 402)                                                    \
+  V(FORBIDDEN, 403)                                                           \
+  V(NOT_FOUND, 404)                                                           \
+  V(METHOD_NOT_ALLOWED, 405)                                                  \
+  V(NOT_ACCEPTABLE, 406)                                                      \
+  V(PROXY_AUTHENTICATION_REQUIRED, 407)                                       \
+  V(REQUEST_TIMEOUT, 408)                                                     \
+  V(CONFLICT, 409)                                                            \
+  V(GONE, 410)                                                                \
+  V(LENGTH_REQUIRED, 411)                                                     \
+  V(PRECONDITION_FAILED, 412)                                                 \
+  V(PAYLOAD_TOO_LARGE, 413)                                                   \
+  V(URI_TOO_LONG, 414)                                                        \
+  V(UNSUPPORTED_MEDIA_TYPE, 415)                                              \
+  V(RANGE_NOT_SATISFIABLE, 416)                                               \
+  V(EXPECTATION_FAILED, 417)                                                  \
+  V(TEAPOT, 418)                                                              \
+  V(MISDIRECTED_REQUEST, 421)                                                 \
+  V(UNPROCESSABLE_ENTITY, 422)                                                \
+  V(LOCKED, 423)                                                              \
+  V(FAILED_DEPENDENCY, 424)                                                   \
+  V(TOO_EARLY, 425)                                                           \
+  V(UPGRADE_REQUIRED, 426)                                                    \
+  V(PRECONDITION_REQUIRED, 428)                                               \
+  V(TOO_MANY_REQUESTS, 429)                                                   \
+  V(REQUEST_HEADER_FIELDS_TOO_LARGE, 431)                                     \
+  V(UNAVAILABLE_FOR_LEGAL_REASONS, 451)                                       \
+  V(INTERNAL_SERVER_ERROR, 500)                                               \
+  V(NOT_IMPLEMENTED, 501)                                                     \
+  V(BAD_GATEWAY, 502)                                                         \
+  V(SERVICE_UNAVAILABLE, 503)                                                 \
+  V(GATEWAY_TIMEOUT, 504)                                                     \
+  V(HTTP_VERSION_NOT_SUPPORTED, 505)                                          \
+  V(VARIANT_ALSO_NEGOTIATES, 506)                                             \
+  V(INSUFFICIENT_STORAGE, 507)                                                \
+  V(LOOP_DETECTED, 508)                                                       \
+  V(BANDWIDTH_LIMIT_EXCEEDED, 509)                                            \
+  V(NOT_EXTENDED, 510)                                                        \
+  V(NETWORK_AUTHENTICATION_REQUIRED, 511)
+
+enum http_status_codes {
+#define V(name, code) HTTP_STATUS_##name = code,
+  HTTP_STATUS_CODES(V)
+#undef V
+};
+
+// Unlike the HTTP/1 implementation, the HTTP/2 implementation is not limited
+// to a fixed number of known supported HTTP methods. These constants, therefore
+// are provided strictly as a convenience to users and are exposed via the
+// require('http2').constants object.
+#define HTTP_KNOWN_METHODS(V)                                                 \
+  V(ACL, "ACL")                                                               \
+  V(BASELINE_CONTROL, "BASELINE-CONTROL")                                     \
+  V(BIND, "BIND")                                                             \
+  V(CHECKIN, "CHECKIN")                                                       \
+  V(CHECKOUT, "CHECKOUT")                                                     \
+  V(CONNECT, "CONNECT")                                                       \
+  V(COPY, "COPY")                                                             \
+  V(DELETE, "DELETE")                                                         \
+  V(GET, "GET")                                                               \
+  V(HEAD, "HEAD")                                                             \
+  V(LABEL, "LABEL")                                                           \
+  V(LINK, "LINK")                                                             \
+  V(LOCK, "LOCK")                                                             \
+  V(MERGE, "MERGE")                                                           \
+  V(MKACTIVITY, "MKACTIVITY")                                                 \
+  V(MKCALENDAR, "MKCALENDAR")                                                 \
+  V(MKCOL, "MKCOL")                                                           \
+  V(MKREDIRECTREF, "MKREDIRECTREF")                                           \
+  V(MKWORKSPACE, "MKWORKSPACE")                                               \
+  V(MOVE, "MOVE")                                                             \
+  V(OPTIONS, "OPTIONS")                                                       \
+  V(ORDERPATCH, "ORDERPATCH")                                                 \
+  V(PATCH, "PATCH")                                                           \
+  V(POST, "POST")                                                             \
+  V(PRI, "PRI")                                                               \
+  V(PROPFIND, "PROPFIND")                                                     \
+  V(PROPPATCH, "PROPPATCH")                                                   \
+  V(PUT, "PUT")                                                               \
+  V(REBIND, "REBIND")                                                         \
+  V(REPORT, "REPORT")                                                         \
+  V(SEARCH, "SEARCH")                                                         \
+  V(TRACE, "TRACE")                                                           \
+  V(UNBIND, "UNBIND")                                                         \
+  V(UNCHECKOUT, "UNCHECKOUT")                                                 \
+  V(UNLINK, "UNLINK")                                                         \
+  V(UNLOCK, "UNLOCK")                                                         \
+  V(UPDATE, "UPDATE")                                                         \
+  V(UPDATEREDIRECTREF, "UPDATEREDIRECTREF")                                   \
+  V(VERSION_CONTROL, "VERSION-CONTROL")
+
+// NgHeaders takes as input a block of headers provided by the
+// JavaScript side (see http2's mapToHeaders function) and
+// converts it into a array of ng header structs. This is done
+// generically to handle both http/2 and (in the future) http/3,
+// which use nearly identical structs. The template parameter
+// takes a Traits type that defines the ng header struct and
+// the kNoneFlag value. See Http2HeaderTraits in node_http2.h
+// for an example.
+template <typename T>
+class NgHeaders {
+ public:
+  typedef typename T::nv_t nv_t;
+  inline NgHeaders(Environment* env, v8::Local<v8::Array> headers);
+  ~NgHeaders() = default;
+
+  const nv_t* operator*() const {
+    return reinterpret_cast<const nv_t*>(*buf_);
+  }
+
+  const nv_t* data() const {
+    return reinterpret_cast<const nv_t*>(*buf_);
+  }
+
+  size_t length() const {
+    return count_;
+  }
+
+ private:
+  size_t count_;
+  MaybeStackBuffer<char, 3000> buf_;
+};
+
+// The ng libraries (nghttp2 and nghttp3) each use nearly identical
+// reference counted structures for retaining header name and value
+// information in memory until the application is done with it.
+// The NgRcBufPointer is an intelligent pointer capable of working
+// with either type, handling the ref counting increment and
+// decrement as appropriate. The Template takes a single Traits
+// type that provides the rc buffer and vec type, as well as
+// implementations for multiple static functions.
+// See Http2RcBufferPointerTraits in node_http2.h for an example.
+template <typename T>
+class NgRcBufPointer : public MemoryRetainer {
+ public:
+  typedef typename T::rcbuf_t rcbuf_t;
+  typedef typename T::vector_t vector_t;
+
+  NgRcBufPointer() = default;
+
+  explicit NgRcBufPointer(rcbuf_t* buf) {
+    reset(buf);
+  }
+
+  template <typename B>
+  NgRcBufPointer(const NgRcBufPointer<B>& other) {
+    reset(other.get());
+  }
+
+  NgRcBufPointer(const NgRcBufPointer& other) {
+    reset(other.get());
+  }
+
+  template <typename B>
+  NgRcBufPointer& operator=(const NgRcBufPointer<B>& other) {
+    if (other.get() == get()) return *this;
+    this->~NgRcBufPointer();
+    return *new (this) NgRcBufPointer(other);
+  }
+
+  NgRcBufPointer& operator=(const NgRcBufPointer& other) {
+    if (other.get() == get()) return *this;
+    this->~NgRcBufPointer();
+    return *new (this) NgRcBufPointer(other);
+  }
+
+  NgRcBufPointer(NgRcBufPointer&& other) {
+    this->~NgRcBufPointer();
+    buf_ = other.buf_;
+    other.buf_ = nullptr;
+  }
+
+  NgRcBufPointer& operator=(NgRcBufPointer&& other) {
+    this->~NgRcBufPointer();
+    return *new (this) NgRcBufPointer(std::move(other));
+  }
+
+  ~NgRcBufPointer() {
+    reset();
+  }
+
+  // Returns the underlying ngvec for this rcbuf
+  uint8_t* data() const {
+    vector_t v = T::get_vec(buf_);
+    return v.base;
+  }
+
+  size_t len() const {
+    vector_t v = T::get_vec(buf_);
+    return v.len;
+  }
+
+  std::string str() const {
+    return std::string(reinterpret_cast<const char*>(data()), len());
+  }
+
+  void reset(rcbuf_t* ptr = nullptr, bool internalizable = false) {
+    if (buf_ == ptr)
+      return;
+
+    if (buf_ != nullptr)
+      T::dec(buf_);
+
+    buf_ = ptr;
+
+    if (ptr != nullptr) {
+      T::inc(ptr);
+      internalizable_ = internalizable;
+    }
+  }
+
+  rcbuf_t* get() const { return buf_; }
+  rcbuf_t& operator*() const { return *get(); }
+  rcbuf_t* operator->() const { return buf_; }
+  operator bool() const { return buf_ != nullptr; }
+  bool IsStatic() const { return T::is_static(buf_) != 0; }
+  void SetInternalizable() { internalizable_ = true; }
+  bool IsInternalizable() const { return internalizable_; }
+
+  static inline bool IsZeroLength(rcbuf_t* buf) {
+    if (buf == nullptr)
+      return true;
+    vector_t b = T::get_vec(buf);
+    return b.len == 0;
+  }
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackFieldWithSize("buf", len(), "buf");
+  }
+
+  SET_MEMORY_INFO_NAME(NgRcBufPointer)
+  SET_SELF_SIZE(NgRcBufPointer)
+
+  class External : public v8::String::ExternalOneByteStringResource {
+   public:
+    explicit External(const NgRcBufPointer<T>& ptr) : ptr_(ptr) {}
+
+    const char* data() const override {
+      return const_cast<const char*>(reinterpret_cast<char*>(ptr_.data()));
+    }
+
+    size_t length() const override {
+      return ptr_.len();
+    }
+
+    static inline
+    v8::MaybeLocal<v8::String> GetInternalizedString(
+        Environment* env,
+        const NgRcBufPointer<T>& ptr) {
+      return v8::String::NewFromOneByte(
+          env->isolate(),
+          ptr.data(),
+          v8::NewStringType::kInternalized,
+          ptr.len());
+    }
+
+    template <typename Allocator>
+    static v8::MaybeLocal<v8::String> New(
+        Allocator* allocator,
+        NgRcBufPointer<T> ptr) {
+      Environment* env = allocator->env();
+      if (ptr.IsStatic()) {
+        auto& static_str_map = env->isolate_data()->static_str_map;
+        const char* header_name = reinterpret_cast<const char*>(ptr.data());
+        v8::Eternal<v8::String>& eternal = static_str_map[header_name];
+        if (eternal.IsEmpty()) {
+          v8::Local<v8::String> str =
+              GetInternalizedString(env, ptr).ToLocalChecked();
+          eternal.Set(env->isolate(), str);
+          return str;
+        }
+        return eternal.Get(env->isolate());
+      }
+
+      size_t len = ptr.len();
+
+      if (len == 0) {
+        ptr.reset();
+        return v8::String::Empty(env->isolate());
+      }
+
+      if (ptr.IsInternalizable() && len < 64) {
+        v8::MaybeLocal<v8::String> ret = GetInternalizedString(env, ptr);
+        ptr.reset();
+        return ret;
+      }
+
+      allocator->StopTrackingMemory(ptr.get());
+      External* h_str = new External(std::move(ptr));
+      v8::MaybeLocal<v8::String> str =
+          v8::String::NewExternalOneByte(env->isolate(), h_str);
+      if (str.IsEmpty())
+        delete h_str;
+
+      return str;
+    }
+
+   private:
+    NgRcBufPointer<T> ptr_;
+  };
+
+ private:
+  rcbuf_t* buf_ = nullptr;
+  bool internalizable_ = false;
+};
+
+template <typename allocator_t>
+struct NgHeaderBase : public MemoryRetainer {
+  virtual v8::MaybeLocal<v8::String> GetName(allocator_t* allocator) const = 0;
+  virtual v8::MaybeLocal<v8::String> GetValue(allocator_t* allocator) const = 0;
+  virtual std::string name() const = 0;
+  virtual std::string value() const = 0;
+  virtual size_t length() const = 0;
+  virtual uint8_t flags() const = 0;
+  virtual std::string ToString() const;
+};
+
+// The ng libraries use nearly identical structs to represent
+// received http headers. The NgHeader class wraps those in a
+// consistent way and allows converting the name and value to
+// v8 strings. The template is given a Traits type that provides
+// the NgRcBufPointer type, the NgLibMemoryManager to use for
+// memory tracking, and implementation of static utility functions.
+// See Http2HeaderTraits in node_http2.h for an example.
+template <typename T>
+class NgHeader final : public NgHeaderBase<typename T::allocator_t> {
+ public:
+  typedef typename T::rcbufferpointer_t rcbufferpointer_t;
+  typedef typename T::rcbufferpointer_t::rcbuf_t rcbuf_t;
+  typedef typename T::allocator_t allocator_t;
+
+  inline static bool IsZeroLength(rcbuf_t* name, rcbuf_t* value);
+  inline static bool IsZeroLength(int32_t token, rcbuf_t* name, rcbuf_t* value);
+  inline NgHeader(
+      Environment* env,
+      rcbuf_t* name,
+      rcbuf_t* value,
+      uint8_t flags);
+  inline NgHeader(
+      Environment* env,
+      int32_t token,
+      rcbuf_t* name,
+      rcbuf_t* value,
+      uint8_t flags);
+  inline NgHeader(NgHeader<T>&& other) noexcept;
+
+  // Calling GetName and GetValue will have the effect of releasing
+  // control over the reference counted buffer from this NgHeader
+  // object to the v8 string. Once the v8 string is garbage collected,
+  // the reference counter will be decremented.
+
+  inline v8::MaybeLocal<v8::String> GetName(
+      allocator_t* allocator) const override;
+  inline v8::MaybeLocal<v8::String> GetValue(
+      allocator_t* allocator) const override;
+
+  inline std::string name() const override;
+  inline std::string value() const override;
+  inline size_t length() const override;
+  inline uint8_t flags() const override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+
+  SET_MEMORY_INFO_NAME(NgHeader)
+  SET_SELF_SIZE(NgHeader)
+
+ private:
+  Environment* env_;
+  rcbufferpointer_t name_;
+  rcbufferpointer_t value_;
+  int32_t token_ = -1;
+  uint8_t flags_ = 0;
+};
+
+inline size_t GetServerMaxHeaderPairs(size_t max_header_pairs);
+inline size_t GetClientMaxHeaderPairs(size_t max_header_pairs);
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_HTTP_COMMON_H_
diff --git a/src/node_http_parser_impl.h b/src/node_http_parser.cc
similarity index 84%
rename from src/node_http_parser_impl.h
rename to src/node_http_parser.cc
index 77d09a939cb72bd8393d99825886a953a8ffe761..d3184bb1a14c9252981ee21cdabc91c99b9c0da1 100644
--- a/src/node_http_parser_impl.h
+++ b/src/node_http_parser.cc
@@ -19,30 +19,22 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-// This file is included from 2 files, node_http_parser_traditional.cc
-// and node_http_parser_llhttp.cc.
-
-#pragma once
-
 #include "node.h"
 #include "node_buffer.h"
-#ifndef NODE_EXPERIMENTAL_HTTP
-#include "node_process.h"
-#endif  /* NODE_EXPERIMENTAL_HTTP */
 #include "util.h"
 
 #include "async_wrap-inl.h"
 #include "env-inl.h"
+#include "memory_tracker-inl.h"
 #include "stream_base-inl.h"
 #include "v8.h"
-
-#include "http_parser_adaptor.h"
+#include "llhttp.h"
 
 #include <cstdlib>  // free()
 #include <cstring>  // strdup(), strchr()
 
 
-// This is a binding to http_parser (https://github.com/nodejs/http-parser)
+// This is a binding to llhttp (https://github.com/nodejs/llhttp)
 // The goal is to decouple sockets from parsing for more javascript-level
 // agility. A Buffer is read from a socket and passed to parser.execute().
 // The parser then issues callbacks with slices of the data
@@ -70,18 +62,20 @@ using v8::Int32;
 using v8::Integer;
 using v8::Local;
 using v8::MaybeLocal;
+using v8::Number;
 using v8::Object;
 using v8::String;
 using v8::Uint32;
 using v8::Undefined;
 using v8::Value;
 
-const uint32_t kOnHeaders = 0;
-const uint32_t kOnHeadersComplete = 1;
-const uint32_t kOnBody = 2;
-const uint32_t kOnMessageComplete = 3;
-const uint32_t kOnExecute = 4;
-const uint32_t kOnTimeout = 5;
+const uint32_t kOnMessageBegin = 0;
+const uint32_t kOnHeaders = 1;
+const uint32_t kOnHeadersComplete = 2;
+const uint32_t kOnBody = 3;
+const uint32_t kOnMessageComplete = 4;
+const uint32_t kOnExecute = 5;
+const uint32_t kOnTimeout = 6;
 // Any more fields than this will be flushed into JS
 const size_t kMaxHeaderFieldsCount = 32;
 
@@ -89,6 +83,26 @@ inline bool IsOWS(char c) {
   return c == ' ' || c == '\t';
 }
 
+class BindingData : public BaseObject {
+ public:
+  BindingData(Environment* env, Local<Object> obj)
+      : BaseObject(env, obj) {}
+
+  static constexpr FastStringKey type_name { "http_parser" };
+
+  std::vector<char> parser_buffer;
+  bool parser_buffer_in_use = false;
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackField("parser_buffer", parser_buffer);
+  }
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+};
+
+// TODO(addaleax): Remove once we're on C++17.
+constexpr FastStringKey BindingData::type_name;
+
 // helper class for the Parser
 struct StringPtr {
   StringPtr() {
@@ -171,10 +185,11 @@ struct StringPtr {
 
 class Parser : public AsyncWrap, public StreamListener {
  public:
-  Parser(Environment* env, Local<Object> wrap)
-      : AsyncWrap(env, wrap),
+  Parser(BindingData* binding_data, Local<Object> wrap)
+      : AsyncWrap(binding_data->env(), wrap),
         current_buffer_len_(0),
-        current_buffer_data_(nullptr) {
+        current_buffer_data_(nullptr),
+        binding_data_(binding_data) {
   }
 
 
@@ -190,6 +205,19 @@ class Parser : public AsyncWrap, public StreamListener {
     url_.Reset();
     status_message_.Reset();
     header_parsing_start_time_ = uv_hrtime();
+
+    Local<Value> cb = object()->Get(env()->context(), kOnMessageBegin)
+                              .ToLocalChecked();
+    if (cb->IsFunction()) {
+      InternalCallbackScope callback_scope(
+        this, InternalCallbackScope::kSkipTaskQueues);
+
+      MaybeLocal<Value> r = cb.As<Function>()->Call(
+        env()->context(), object(), 0, nullptr);
+
+      if (r.IsEmpty()) callback_scope.MarkAsFailed();
+    }
+
     return 0;
   }
 
@@ -265,9 +293,7 @@ class Parser : public AsyncWrap, public StreamListener {
 
 
   int on_headers_complete() {
-#ifdef NODE_EXPERIMENTAL_HTTP
     header_nread_ = 0;
-#endif  /* NODE_EXPERIMENTAL_HTTP */
     header_parsing_start_time_ = 0;
 
     // Arguments for the on-headers-complete javascript callback. This
@@ -329,11 +355,7 @@ class Parser : public AsyncWrap, public StreamListener {
     argv[A_VERSION_MINOR] = Integer::New(env()->isolate(), parser_.http_minor);
 
     bool should_keep_alive;
-#ifdef NODE_EXPERIMENTAL_HTTP
     should_keep_alive = llhttp_should_keep_alive(&parser_);
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-    should_keep_alive = http_should_keep_alive(&parser_);
-#endif  /* NODE_EXPERIMENTAL_HTTP */
 
     argv[A_SHOULD_KEEP_ALIVE] =
         Boolean::New(env()->isolate(), should_keep_alive);
@@ -392,9 +414,7 @@ class Parser : public AsyncWrap, public StreamListener {
 
     if (r.IsEmpty()) {
       got_exception_ = true;
-#ifdef NODE_EXPERIMENTAL_HTTP
       llhttp_set_error_reason(&parser_, "HPE_JS_EXCEPTION:JS Exception");
-#endif  /* NODE_EXPERIMENTAL_HTTP */
       return HPE_USER;
     }
 
@@ -431,7 +451,6 @@ class Parser : public AsyncWrap, public StreamListener {
     return 0;
   }
 
-#ifdef NODE_EXPERIMENTAL_HTTP
   // Reset nread for the next chunk
   int on_chunk_header() {
     header_nread_ = 0;
@@ -444,12 +463,10 @@ class Parser : public AsyncWrap, public StreamListener {
     header_nread_ = 0;
     return 0;
   }
-#endif  /* NODE_EXPERIMENTAL_HTTP */
-
 
   static void New(const FunctionCallbackInfo<Value>& args) {
-    Environment* env = Environment::GetCurrent(args);
-    new Parser(env, args.This());
+    BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+    new Parser(binding_data, args.This());
   }
 
 
@@ -522,20 +539,29 @@ class Parser : public AsyncWrap, public StreamListener {
 
   static void Initialize(const FunctionCallbackInfo<Value>& args) {
     Environment* env = Environment::GetCurrent(args);
-    bool lenient = args[2]->IsTrue();
+    bool lenient = args[3]->IsTrue();
 
+    uint64_t max_http_header_size = 0;
     uint64_t headers_timeout = 0;
 
     CHECK(args[0]->IsInt32());
     CHECK(args[1]->IsObject());
 
-    if (args.Length() > 3) {
-      CHECK(args[3]->IsInt32());
-      headers_timeout = args[3].As<Int32>()->Value();
+    if (args.Length() > 2) {
+      CHECK(args[2]->IsNumber());
+      max_http_header_size = args[2].As<Number>()->Value();
+    }
+    if (max_http_header_size == 0) {
+      max_http_header_size = env->options()->max_http_header_size;
+    }
+
+    if (args.Length() > 4) {
+      CHECK(args[4]->IsInt32());
+      headers_timeout = args[4].As<Number>()->Value();
     }
 
-    parser_type_t type =
-        static_cast<parser_type_t>(args[0].As<Int32>()->Value());
+    llhttp_type_t type =
+        static_cast<llhttp_type_t>(args[0].As<Int32>()->Value());
 
     CHECK(type == HTTP_REQUEST || type == HTTP_RESPONSE);
     Parser* parser;
@@ -550,7 +576,7 @@ class Parser : public AsyncWrap, public StreamListener {
 
     parser->set_provider_type(provider);
     parser->AsyncReset(args[1].As<Object>());
-    parser->Init(type, lenient, headers_timeout);
+    parser->Init(type, max_http_header_size, lenient, headers_timeout);
   }
 
   template <bool should_pause>
@@ -561,7 +587,6 @@ class Parser : public AsyncWrap, public StreamListener {
     // Should always be called from the same context.
     CHECK_EQ(env, parser->env());
 
-#ifdef NODE_EXPERIMENTAL_HTTP
     if (parser->execute_depth_) {
       parser->pending_pause_ = should_pause;
       return;
@@ -572,9 +597,6 @@ class Parser : public AsyncWrap, public StreamListener {
     } else {
       llhttp_resume(&parser->parser_);
     }
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-    http_parser_pause(&parser->parser_, should_pause);
-#endif  /* NODE_EXPERIMENTAL_HTTP */
   }
 
 
@@ -619,14 +641,14 @@ class Parser : public AsyncWrap, public StreamListener {
     // For most types of streams, OnStreamRead will be immediately after
     // OnStreamAlloc, and will consume all data, so using a static buffer for
     // reading is more efficient. For other streams, just use Malloc() directly.
-    if (env()->http_parser_buffer_in_use())
+    if (binding_data_->parser_buffer_in_use)
       return uv_buf_init(Malloc(suggested_size), suggested_size);
-    env()->set_http_parser_buffer_in_use(true);
+    binding_data_->parser_buffer_in_use = true;
 
-    if (env()->http_parser_buffer() == nullptr)
-      env()->set_http_parser_buffer(new char[kAllocBufferSize]);
+    if (binding_data_->parser_buffer.empty())
+      binding_data_->parser_buffer.resize(kAllocBufferSize);
 
-    return uv_buf_init(env()->http_parser_buffer(), kAllocBufferSize);
+    return uv_buf_init(binding_data_->parser_buffer.data(), kAllocBufferSize);
   }
 
 
@@ -636,8 +658,8 @@ class Parser : public AsyncWrap, public StreamListener {
     // is free for re-use, or free() the data if it didn’t come from there
     // in the first place.
     auto on_scope_leave = OnScopeLeave([&]() {
-      if (buf.base == env()->http_parser_buffer())
-        env()->set_http_parser_buffer_in_use(false);
+      if (buf.base == binding_data_->parser_buffer.data())
+        binding_data_->parser_buffer_in_use = false;
       else
         free(buf.base);
     });
@@ -700,9 +722,8 @@ class Parser : public AsyncWrap, public StreamListener {
     current_buffer_data_ = data;
     got_exception_ = false;
 
-    parser_errno_t err;
+    llhttp_errno_t err;
 
-#ifdef NODE_EXPERIMENTAL_HTTP
     // Do not allow re-entering `http_parser_execute()`
     CHECK_EQ(execute_depth_, 0);
 
@@ -732,31 +753,6 @@ class Parser : public AsyncWrap, public StreamListener {
       pending_pause_ = false;
       llhttp_pause(&parser_);
     }
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-    size_t nread = http_parser_execute(&parser_, &settings, data, len);
-    err = HTTP_PARSER_ERRNO(&parser_);
-
-    // Finish()
-    if (data == nullptr) {
-      // `http_parser_execute()` returns either `0` or `1` when `len` is 0
-      // (part of the finishing sequence).
-      CHECK_EQ(len, 0);
-      switch (nread) {
-        case 0:
-          err = HPE_OK;
-          break;
-        case 1:
-          nread = 0;
-          break;
-        default:
-          UNREACHABLE();
-      }
-
-    // Regular Execute()
-    } else {
-      Save();
-    }
-#endif  /* NODE_EXPERIMENTAL_HTTP */
 
     // Unassign the 'buffer_' variable
     current_buffer_.Clear();
@@ -778,7 +774,6 @@ class Parser : public AsyncWrap, public StreamListener {
       obj->Set(env()->context(),
                env()->bytes_parsed_string(),
                nread_obj).Check();
-#ifdef NODE_EXPERIMENTAL_HTTP
       const char* errno_reason = llhttp_get_error_reason(&parser_);
 
       Local<String> code;
@@ -796,12 +791,6 @@ class Parser : public AsyncWrap, public StreamListener {
 
       obj->Set(env()->context(), env()->code_string(), code).Check();
       obj->Set(env()->context(), env()->reason_string(), reason).Check();
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-      obj->Set(env()->context(),
-               env()->code_string(),
-               OneByteString(env()->isolate(),
-                             http_errno_name(err))).Check();
-#endif  /* NODE_EXPERIMENTAL_HTTP */
       return scope.Escape(e);
     }
 
@@ -852,40 +841,34 @@ class Parser : public AsyncWrap, public StreamListener {
   }
 
 
-  void Init(parser_type_t type, bool lenient, uint64_t headers_timeout) {
-#ifdef NODE_EXPERIMENTAL_HTTP
+  void Init(llhttp_type_t type, uint64_t max_http_header_size,
+            bool lenient, uint64_t headers_timeout) {
     llhttp_init(&parser_, type, &settings);
     llhttp_set_lenient(&parser_, lenient);
     header_nread_ = 0;
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-    http_parser_init(&parser_, type);
-    parser_.lenient_http_headers = lenient;
-#endif  /* NODE_EXPERIMENTAL_HTTP */
     url_.Reset();
     status_message_.Reset();
     num_fields_ = 0;
     num_values_ = 0;
     have_flushed_ = false;
     got_exception_ = false;
+    max_http_header_size_ = max_http_header_size;
     header_parsing_start_time_ = 0;
     headers_timeout_ = headers_timeout;
   }
 
 
   int TrackHeader(size_t len) {
-#ifdef NODE_EXPERIMENTAL_HTTP
     header_nread_ += len;
-    if (header_nread_ >= per_process::cli_options->max_http_header_size) {
+    if (header_nread_ >= max_http_header_size_) {
       llhttp_set_error_reason(&parser_, "HPE_HEADER_OVERFLOW:Header overflow");
       return HPE_USER;
     }
-#endif  /* NODE_EXPERIMENTAL_HTTP */
     return 0;
   }
 
 
   int MaybePause() {
-#ifdef NODE_EXPERIMENTAL_HTTP
     CHECK_NE(execute_depth_, 0);
 
     if (!pending_pause_) {
@@ -895,12 +878,18 @@ class Parser : public AsyncWrap, public StreamListener {
     pending_pause_ = false;
     llhttp_set_error_reason(&parser_, "Paused in callback");
     return HPE_PAUSED;
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-    return 0;
-#endif  /* NODE_EXPERIMENTAL_HTTP */
   }
 
-  parser_t parser_;
+
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
+    // HTTP parsers are able to emit events without any GC root referring
+    // to them, because they receive events directly from the underlying
+    // libuv resource.
+    return true;
+  }
+
+
+  llhttp_t parser_;
   StringPtr fields_[kMaxHeaderFieldsCount];  // header fields
   StringPtr values_[kMaxHeaderFieldsCount];  // header values
   StringPtr url_;
@@ -912,20 +901,21 @@ class Parser : public AsyncWrap, public StreamListener {
   Local<Object> current_buffer_;
   size_t current_buffer_len_;
   const char* current_buffer_data_;
-#ifdef NODE_EXPERIMENTAL_HTTP
   unsigned int execute_depth_ = 0;
   bool pending_pause_ = false;
   uint64_t header_nread_ = 0;
-#endif  /* NODE_EXPERIMENTAL_HTTP */
+  uint64_t max_http_header_size_;
   uint64_t headers_timeout_;
   uint64_t header_parsing_start_time_ = 0;
 
+  BaseObjectPtr<BindingData> binding_data_;
+
   // These are helper functions for filling `http_parser_settings`, which turn
   // a member function of Parser into a C-style HTTP parser callback.
   template <typename Parser, Parser> struct Proxy;
   template <typename Parser, typename ...Args, int (Parser::*Member)(Args...)>
   struct Proxy<int (Parser::*)(Args...), Member> {
-    static int Raw(parser_t* p, Args ... args) {
+    static int Raw(llhttp_t* p, Args ... args) {
       Parser* parser = ContainerOf(&Parser::parser_, p);
       int rv = (parser->*Member)(std::forward<Args>(args)...);
       if (rv == 0) {
@@ -938,10 +928,10 @@ class Parser : public AsyncWrap, public StreamListener {
   typedef int (Parser::*Call)();
   typedef int (Parser::*DataCall)(const char* at, size_t length);
 
-  static const parser_settings_t settings;
+  static const llhttp_settings_t settings;
 };
 
-const parser_settings_t Parser::settings = {
+const llhttp_settings_t Parser::settings = {
   Proxy<Call, &Parser::on_message_begin>::Raw,
   Proxy<DataCall, &Parser::on_url>::Raw,
   Proxy<DataCall, &Parser::on_status>::Raw,
@@ -950,38 +940,29 @@ const parser_settings_t Parser::settings = {
   Proxy<Call, &Parser::on_headers_complete>::Raw,
   Proxy<DataCall, &Parser::on_body>::Raw,
   Proxy<Call, &Parser::on_message_complete>::Raw,
-#ifdef NODE_EXPERIMENTAL_HTTP
   Proxy<Call, &Parser::on_chunk_header>::Raw,
   Proxy<Call, &Parser::on_chunk_complete>::Raw,
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-  nullptr,
-  nullptr,
-#endif  /* NODE_EXPERIMENTAL_HTTP */
 };
 
 
-#ifndef NODE_EXPERIMENTAL_HTTP
-void InitMaxHttpHeaderSizeOnce() {
-  const uint32_t max_http_header_size =
-      per_process::cli_options->max_http_header_size;
-  http_parser_set_max_header_size(max_http_header_size);
-}
-#endif  /* NODE_EXPERIMENTAL_HTTP */
-
-
 void InitializeHttpParser(Local<Object> target,
                           Local<Value> unused,
                           Local<Context> context,
                           void* priv) {
   Environment* env = Environment::GetCurrent(context);
+  BindingData* const binding_data =
+      env->AddBindingData<BindingData>(context, target);
+  if (binding_data == nullptr) return;
+
   Local<FunctionTemplate> t = env->NewFunctionTemplate(Parser::New);
   t->InstanceTemplate()->SetInternalFieldCount(Parser::kInternalFieldCount);
-  t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "HTTPParser"));
 
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "REQUEST"),
          Integer::New(env->isolate(), HTTP_REQUEST));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "RESPONSE"),
          Integer::New(env->isolate(), HTTP_RESPONSE));
+  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnMessageBegin"),
+         Integer::NewFromUnsigned(env->isolate(), kOnMessageBegin));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnHeaders"),
          Integer::NewFromUnsigned(env->isolate(), kOnHeaders));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnHeadersComplete"),
@@ -1017,19 +998,10 @@ void InitializeHttpParser(Local<Object> target,
   env->SetProtoMethod(t, "unconsume", Parser::Unconsume);
   env->SetProtoMethod(t, "getCurrentBuffer", Parser::GetCurrentBuffer);
 
-  target->Set(env->context(),
-              FIXED_ONE_BYTE_STRING(env->isolate(), "HTTPParser"),
-              t->GetFunction(env->context()).ToLocalChecked()).Check();
-
-#ifndef NODE_EXPERIMENTAL_HTTP
-  static uv_once_t init_once = UV_ONCE_INIT;
-  uv_once(&init_once, InitMaxHttpHeaderSizeOnce);
-  ProcessEmitDeprecationWarning(
-    env,
-    "The legacy HTTP parser is deprecated.",
-    "DEP0131").IsNothing();
-#endif  /* NODE_EXPERIMENTAL_HTTP */
+  env->SetConstructorFunction(target, "HTTPParser", t);
 }
 
 }  // anonymous namespace
 }  // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(http_parser, node::InitializeHttpParser)
diff --git a/src/node_http_parser_llhttp.cc b/src/node_http_parser_llhttp.cc
deleted file mode 100644
index 6e1d18d3af94ffe475519d36283b1a36e56851c7..0000000000000000000000000000000000000000
--- a/src/node_http_parser_llhttp.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-#define NODE_EXPERIMENTAL_HTTP 1
-
-#include "node_http_parser_impl.h"
-#include "memory_tracker-inl.h"
-#include "node_metadata.h"
-#include "util-inl.h"
-
-namespace node {
-
-namespace per_process {
-const char* const llhttp_version =
-    NODE_STRINGIFY(LLHTTP_VERSION_MAJOR)
-    "."
-    NODE_STRINGIFY(LLHTTP_VERSION_MINOR)
-    "."
-    NODE_STRINGIFY(LLHTTP_VERSION_PATCH);
-}  // namespace per_process
-}  // namespace node
-
-NODE_MODULE_CONTEXT_AWARE_INTERNAL(http_parser_llhttp,
-                                   node::InitializeHttpParser)
diff --git a/src/node_http_parser_traditional.cc b/src/node_http_parser_traditional.cc
deleted file mode 100644
index 11aa387f109828a7816bef32736ec84bc0ba4d8e..0000000000000000000000000000000000000000
--- a/src/node_http_parser_traditional.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifdef NODE_EXPERIMENTAL_HTTP
-#undef NODE_EXPERIMENTAL_HTTP
-#endif
-
-#include "memory_tracker-inl.h"
-#include "node_http_parser_impl.h"
-#include "node_metadata.h"
-#include "util-inl.h"
-
-namespace node {
-namespace per_process {
-const char* const http_parser_version =
-  NODE_STRINGIFY(HTTP_PARSER_VERSION_MAJOR)
-  "."
-  NODE_STRINGIFY(HTTP_PARSER_VERSION_MINOR)
-  "."
-  NODE_STRINGIFY(HTTP_PARSER_VERSION_PATCH);
-}  // namespace per_process
-}  // namespace node
-
-NODE_MODULE_CONTEXT_AWARE_INTERNAL(http_parser, node::InitializeHttpParser)
diff --git a/src/node_i18n.cc b/src/node_i18n.cc
index 5382e469a4087ceeb8d06eb219ab3277f71b8541..e4bc79ebc208005192eb347ca51f33869f78813a 100644
--- a/src/node_i18n.cc
+++ b/src/node_i18n.cc
@@ -147,8 +147,13 @@ MaybeLocal<Object> Transcode(Environment* env,
   *status = U_ZERO_ERROR;
   MaybeLocal<Object> ret;
   MaybeStackBuffer<char> result;
-  Converter to(toEncoding, "?");
+  Converter to(toEncoding);
   Converter from(fromEncoding);
+
+  size_t sublen = ucnv_getMinCharSize(to.conv());
+  std::string sub(sublen, '?');
+  to.set_subst_chars(sub.c_str());
+
   const uint32_t limit = source_length * to.max_char_size();
   result.AllocateSufficientStorage(limit);
   char* target = *result;
@@ -189,7 +194,12 @@ MaybeLocal<Object> TranscodeFromUcs2(Environment* env,
   *status = U_ZERO_ERROR;
   MaybeStackBuffer<UChar> sourcebuf;
   MaybeLocal<Object> ret;
-  Converter to(toEncoding, "?");
+  Converter to(toEncoding);
+
+  size_t sublen = ucnv_getMinCharSize(to.conv());
+  std::string sub(sublen, '?');
+  to.set_subst_chars(sub.c_str());
+
   const size_t length_in_chars = source_length / sizeof(UChar);
   CopySourceBuffer(&sourcebuf, source, source_length, length_in_chars);
   MaybeStackBuffer<char> destbuf(length_in_chars);
@@ -338,8 +348,7 @@ void ICUErrorName(const FunctionCallbackInfo<Value>& args) {
   UErrorCode status = static_cast<UErrorCode>(args[0].As<Int32>()->Value());
   args.GetReturnValue().Set(
       String::NewFromUtf8(env->isolate(),
-                          u_errorName(status),
-                          NewStringType::kNormal).ToLocalChecked());
+                          u_errorName(status)).ToLocalChecked());
 }
 
 }  // anonymous namespace
@@ -432,11 +441,24 @@ void ConverterObject::Decode(const FunctionCallbackInfo<Value>& args) {
   UErrorCode status = U_ZERO_ERROR;
   MaybeStackBuffer<UChar> result;
   MaybeLocal<Object> ret;
-  size_t limit = converter->min_char_size() * input.length();
+
+  UBool flush = (flags & CONVERTER_FLAGS_FLUSH) == CONVERTER_FLAGS_FLUSH;
+
+  // When flushing the final chunk, the limit is the maximum
+  // of either the input buffer length or the number of pending
+  // characters times the min char size.
+  size_t limit = converter->min_char_size() *
+      (!flush ?
+          input.length() :
+          std::max(
+              input.length(),
+              static_cast<size_t>(
+                  ucnv_toUCountPending(converter->conv(), &status))));
+  status = U_ZERO_ERROR;
+
   if (limit > 0)
     result.AllocateSufficientStorage(limit);
 
-  UBool flush = (flags & CONVERTER_FLAGS_FLUSH) == CONVERTER_FLAGS_FLUSH;
   auto cleanup = OnScopeLeave([&]() {
     if (flush) {
       // Reset the converter state.
@@ -475,7 +497,7 @@ void ConverterObject::Decode(const FunctionCallbackInfo<Value>& args) {
     }
     ret = ToBufferEndian(env, &result);
     if (omit_initial_bom && !ret.IsEmpty()) {
-      // Peform `ret = ret.slice(2)`.
+      // Perform `ret = ret.slice(2)`.
       CHECK(ret.ToLocalChecked()->IsUint8Array());
       Local<Uint8Array> orig_ret = ret.ToLocalChecked().As<Uint8Array>();
       ret = Buffer::New(env,
diff --git a/src/node_internals.h b/src/node_internals.h
index fd0b14b02845326b4aee4955ec6fd48cbc0ebf62..7d31640bedffc1e298d7aff60bfd8b2864c9b812 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -39,11 +39,6 @@
 #include <string>
 #include <vector>
 
-// Custom constants used by both node_constants.cc and node_zlib.cc
-#define Z_MIN_WINDOWBITS 8
-#define Z_MAX_WINDOWBITS 15
-#define Z_DEFAULT_WINDOWBITS 15
-
 struct sockaddr;
 
 namespace node {
@@ -55,7 +50,6 @@ class NativeModuleLoader;
 namespace per_process {
 extern Mutex env_var_mutex;
 extern uint64_t node_start_time;
-extern bool v8_is_profiling;
 }  // namespace per_process
 
 // Forward declaration
@@ -91,11 +85,8 @@ void PrintCaughtException(v8::Isolate* isolate,
                           const v8::TryCatch& try_catch);
 
 void ResetStdio();  // Safe to call more than once and from signal handlers.
-void SignalExit(int signo);
 #ifdef __POSIX__
-void RegisterSignalHandler(int signal,
-                           void (*handler)(int signal),
-                           bool reset_handler = false);
+void SignalExit(int signal, siginfo_t* info, void* ucontext);
 #endif
 
 std::string GetProcessTitle(const char* default_title);
@@ -111,7 +102,7 @@ class NodeArrayBufferAllocator : public ArrayBufferAllocator {
   void* Allocate(size_t size) override;  // Defined in src/node.cc
   void* AllocateUninitialized(size_t size) override;
   void Free(void* data, size_t size) override;
-  virtual void* Reallocate(void* data, size_t old_size, size_t size);
+  void* Reallocate(void* data, size_t old_size, size_t size) override;
   virtual void RegisterPointer(void* data, size_t size) {
     total_mem_usage_.fetch_add(size, std::memory_order_relaxed);
   }
@@ -159,8 +150,7 @@ v8::MaybeLocal<v8::Object> New(Environment* env,
 // ArrayBuffer::Allocator().
 v8::MaybeLocal<v8::Object> New(Environment* env,
                                char* data,
-                               size_t length,
-                               bool uses_malloc);
+                               size_t length);
 // Creates a Buffer instance over an existing ArrayBuffer.
 v8::MaybeLocal<v8::Uint8Array> New(Environment* env,
                                    v8::Local<v8::ArrayBuffer> ab,
@@ -182,7 +172,7 @@ static v8::MaybeLocal<v8::Object> New(Environment* env,
   const size_t len_in_bytes = buf->length() * sizeof(buf->out()[0]);
 
   if (buf->IsAllocated())
-    ret = New(env, src, len_in_bytes, true);
+    ret = New(env, src, len_in_bytes);
   else if (!buf->IsInvalidated())
     ret = Copy(env, src, len_in_bytes);
 
@@ -368,6 +358,10 @@ class DiagnosticFilename {
   std::string filename_;
 };
 
+namespace heap {
+bool WriteSnapshot(v8::Isolate* isolate, const char* filename);
+}
+
 class TraceEventScope {
  public:
   TraceEventScope(const char* category,
@@ -399,6 +393,8 @@ namespace fs {
 std::string Basename(const std::string& str, const std::string& extension);
 }  // namespace fs
 
+node_module napi_module_to_node_module(const napi_module* mod);
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/node_main.cc b/src/node_main.cc
index e92c0df94297e2ece43dbdf71166e555713ef6f2..9f4ea22d12c6e884c3d6bfeac0b9b36b5d245eb2 100644
--- a/src/node_main.cc
+++ b/src/node_main.cc
@@ -27,10 +27,25 @@
 #include <VersionHelpers.h>
 #include <WinError.h>
 
+#define SKIP_CHECK_VAR "NODE_SKIP_PLATFORM_CHECK"
+#define SKIP_CHECK_SIZE 1
+#define SKIP_CHECK_VALUE "1"
+
 int wmain(int argc, wchar_t* wargv[]) {
-  if (!IsWindows7OrGreater()) {
-    fprintf(stderr, "This application is only supported on Windows 7, "
-                    "Windows Server 2008 R2, or higher.");
+  // Windows Server 2012 (not R2) is supported until 10/10/2023, so we allow it
+  // to run in the experimental support tier.
+  char buf[SKIP_CHECK_SIZE + 1];
+  if (!IsWindows8Point1OrGreater() &&
+      !(IsWindowsServer() && IsWindows8OrGreater()) &&
+      (GetEnvironmentVariableA(SKIP_CHECK_VAR, buf, sizeof(buf)) !=
+       SKIP_CHECK_SIZE ||
+       strncmp(buf, SKIP_CHECK_VALUE, SKIP_CHECK_SIZE + 1) != 0)) {
+    fprintf(stderr, "Node.js is only supported on Windows 8.1, Windows "
+                    "Server 2012 R2, or higher.\n"
+                    "Setting the " SKIP_CHECK_VAR " environment variable "
+                    "to 1 skips this\ncheck, but Node.js might not execute "
+                    "correctly. Any issues encountered on\nunsupported "
+                    "platforms will not be fixed.");
     exit(ERROR_EXE_MACHINE_TYPE_MISMATCH);
   }
 
diff --git a/src/node_main_instance.cc b/src/node_main_instance.cc
index f638e26dba5a043107e81f87b47d143893d366c3..c0db2764525dad4b178c405c326e810459fbe541 100644
--- a/src/node_main_instance.cc
+++ b/src/node_main_instance.cc
@@ -89,6 +89,8 @@ NodeMainInstance::NodeMainInstance(
     // complete.
     SetIsolateErrorHandlers(isolate_, s);
   }
+  isolate_data_->max_young_gen_size =
+      params->constraints.max_young_generation_size_in_bytes();
 }
 
 void NodeMainInstance::Dispose() {
@@ -135,7 +137,8 @@ int NodeMainInstance::Run() {
         if (more && !env->is_stopping()) continue;
 
         if (!uv_loop_alive(env->event_loop())) {
-          EmitBeforeExit(env.get());
+          if (EmitProcessBeforeExit(env.get()).IsNothing())
+            break;
         }
 
         // Emit `beforeExit` if the loop became alive either after emitting
@@ -147,7 +150,8 @@ int NodeMainInstance::Run() {
     }
 
     env->set_trace_sync_io(false);
-    exit_code = EmitExit(env.get());
+    if (!env->is_stopping()) env->VerifyNoStrongBaseObjects();
+    exit_code = EmitProcessExit(env.get()).FromMaybe(1);
   }
 
   ResetStdio();
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index ab8e7366c3ddb435c950a9726d3b6f56829528ff..b743ec72b45ee28f1790da9df7bb8849df4c4534 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -6,14 +6,15 @@
 #include "node_contextify.h"
 #include "node_buffer.h"
 #include "node_errors.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "util-inl.h"
 
 using node::contextify::ContextifyContext;
 using node::errors::TryCatchScope;
 using v8::Array;
 using v8::ArrayBuffer;
-using v8::ArrayBufferCreationMode;
+using v8::BackingStore;
+using v8::CompiledWasmModule;
 using v8::Context;
 using v8::EscapableHandleScope;
 using v8::Function;
@@ -86,7 +87,7 @@ class DeserializerDelegate : public ValueDeserializer::Delegate {
       Environment* env,
       const std::vector<BaseObjectPtr<BaseObject>>& host_objects,
       const std::vector<Local<SharedArrayBuffer>>& shared_array_buffers,
-      const std::vector<WasmModuleObject::TransferrableModule>& wasm_modules)
+      const std::vector<CompiledWasmModule>& wasm_modules)
       : host_objects_(host_objects),
         shared_array_buffers_(shared_array_buffers),
         wasm_modules_(wasm_modules) {}
@@ -109,7 +110,7 @@ class DeserializerDelegate : public ValueDeserializer::Delegate {
   MaybeLocal<WasmModuleObject> GetWasmModuleFromId(
       Isolate* isolate, uint32_t transfer_id) override {
     CHECK_LE(transfer_id, wasm_modules_.size());
-    return WasmModuleObject::FromTransferrableModule(
+    return WasmModuleObject::FromCompiledModule(
         isolate, wasm_modules_[transfer_id]);
   }
 
@@ -118,7 +119,7 @@ class DeserializerDelegate : public ValueDeserializer::Delegate {
  private:
   const std::vector<BaseObjectPtr<BaseObject>>& host_objects_;
   const std::vector<Local<SharedArrayBuffer>>& shared_array_buffers_;
-  const std::vector<WasmModuleObject::TransferrableModule>& wasm_modules_;
+  const std::vector<CompiledWasmModule>& wasm_modules_;
 };
 
 }  // anonymous namespace
@@ -154,10 +155,9 @@ MaybeLocal<Value> Message::Deserialize(Environment* env,
   std::vector<Local<SharedArrayBuffer>> shared_array_buffers;
   // Attach all transferred SharedArrayBuffers to their new Isolate.
   for (uint32_t i = 0; i < shared_array_buffers_.size(); ++i) {
-    Local<SharedArrayBuffer> sab;
-    if (!shared_array_buffers_[i]->GetSharedArrayBuffer(env, context)
-            .ToLocal(&sab))
-      return MaybeLocal<Value>();
+    Local<SharedArrayBuffer> sab =
+        SharedArrayBuffer::New(env->isolate(),
+                               std::move(shared_array_buffers_[i]));
     shared_array_buffers.push_back(sab);
   }
   shared_array_buffers_.clear();
@@ -172,30 +172,12 @@ MaybeLocal<Value> Message::Deserialize(Environment* env,
   delegate.deserializer = &deserializer;
 
   // Attach all transferred ArrayBuffers to their new Isolate.
-  for (uint32_t i = 0; i < array_buffer_contents_.size(); ++i) {
-    if (!env->isolate_data()->uses_node_allocator()) {
-      // We don't use Node's allocator on the receiving side, so we have
-      // to create the ArrayBuffer from a copy of the memory.
-      AllocatedBuffer buf =
-          env->AllocateManaged(array_buffer_contents_[i].size);
-      memcpy(buf.data(),
-             array_buffer_contents_[i].data,
-             array_buffer_contents_[i].size);
-      deserializer.TransferArrayBuffer(i, buf.ToArrayBuffer());
-      continue;
-    }
-
-    env->isolate_data()->node_allocator()->RegisterPointer(
-        array_buffer_contents_[i].data, array_buffer_contents_[i].size);
-
+  for (uint32_t i = 0; i < array_buffers_.size(); ++i) {
     Local<ArrayBuffer> ab =
-        ArrayBuffer::New(env->isolate(),
-                         array_buffer_contents_[i].release(),
-                         array_buffer_contents_[i].size,
-                         ArrayBufferCreationMode::kInternalized);
+        ArrayBuffer::New(env->isolate(), std::move(array_buffers_[i]));
     deserializer.TransferArrayBuffer(i, ab);
   }
-  array_buffer_contents_.clear();
+  array_buffers_.clear();
 
   if (deserializer.ReadHeader(context).IsNothing())
     return {};
@@ -213,15 +195,15 @@ MaybeLocal<Value> Message::Deserialize(Environment* env,
 }
 
 void Message::AddSharedArrayBuffer(
-    const SharedArrayBufferMetadataReference& reference) {
-  shared_array_buffers_.push_back(reference);
+    std::shared_ptr<BackingStore> backing_store) {
+  shared_array_buffers_.emplace_back(std::move(backing_store));
 }
 
 void Message::AddTransferable(std::unique_ptr<TransferData>&& data) {
   transferables_.emplace_back(std::move(data));
 }
 
-uint32_t Message::AddWASMModule(WasmModuleObject::TransferrableModule&& mod) {
+uint32_t Message::AddWASMModule(CompiledWasmModule&& mod) {
   wasm_modules_.emplace_back(std::move(mod));
   return wasm_modules_.size() - 1;
 }
@@ -304,22 +286,15 @@ class SerializerDelegate : public ValueSerializer::Delegate {
       }
     }
 
-    auto reference = SharedArrayBufferMetadata::ForSharedArrayBuffer(
-        env_,
-        context_,
-        shared_array_buffer);
-    if (!reference) {
-      return Nothing<uint32_t>();
-    }
     seen_shared_array_buffers_.emplace_back(
       Global<SharedArrayBuffer> { isolate, shared_array_buffer });
-    msg_->AddSharedArrayBuffer(reference);
+    msg_->AddSharedArrayBuffer(shared_array_buffer->GetBackingStore());
     return Just(i);
   }
 
   Maybe<uint32_t> GetWasmModuleTransferId(
       Isolate* isolate, Local<WasmModuleObject> module) override {
-    return Just(msg_->AddWASMModule(module->GetTransferrableModule()));
+    return Just(msg_->AddWASMModule(module->GetCompiledModule()));
   }
 
   Maybe<bool> Finish(Local<Context> context) {
@@ -443,13 +418,15 @@ Maybe<bool> Message::Serialize(Environment* env,
     // GetTransferMode() does not return kUntransferable.
     if (entry->IsArrayBuffer()) {
       Local<ArrayBuffer> ab = entry.As<ArrayBuffer>();
-      // If we cannot render the ArrayBuffer unusable in this Isolate and
-      // take ownership of its memory, copying the buffer will have to do.
-      if (!ab->IsDetachable() || ab->IsExternal() ||
-          !env->isolate_data()->uses_node_allocator()) {
-        continue;
-      }
-
+      // If we cannot render the ArrayBuffer unusable in this Isolate,
+      // copying the buffer will have to do.
+      // Note that we can currently transfer ArrayBuffers even if they were
+      // not allocated by Node’s ArrayBufferAllocator in the first place,
+      // because we pass the underlying v8::BackingStore around rather than
+      // raw data *and* an Isolate with a non-default ArrayBuffer allocator
+      // is always going to outlive any Workers it creates, and so will its
+      // allocator along with it.
+      if (!ab->IsDetachable()) continue;
       if (std::find(array_buffers.begin(), array_buffers.end(), ab) !=
           array_buffers.end()) {
         ThrowDataCloneException(
@@ -517,18 +494,11 @@ Maybe<bool> Message::Serialize(Environment* env,
   }
 
   for (Local<ArrayBuffer> ab : array_buffers) {
-    // If serialization succeeded, we want to take ownership of
-    // (a.k.a. externalize) the underlying memory region and render
-    // it inaccessible in this Isolate.
-    ArrayBuffer::Contents contents = ab->Externalize();
+    // If serialization succeeded, we render it inaccessible in this Isolate.
+    std::shared_ptr<BackingStore> backing_store = ab->GetBackingStore();
     ab->Detach();
 
-    CHECK(env->isolate_data()->uses_node_allocator());
-    env->isolate_data()->node_allocator()->UnregisterPointer(
-        contents.Data(), contents.ByteLength());
-
-    array_buffer_contents_.emplace_back(MallocedBuffer<char>{
-        static_cast<char*>(contents.Data()), contents.ByteLength()});
+    array_buffers_.emplace_back(std::move(backing_store));
   }
 
   if (delegate.Finish(context).IsNothing())
@@ -543,9 +513,8 @@ Maybe<bool> Message::Serialize(Environment* env,
 }
 
 void Message::MemoryInfo(MemoryTracker* tracker) const {
-  tracker->TrackField("array_buffer_contents", array_buffer_contents_);
-  tracker->TrackFieldWithSize("shared_array_buffers",
-      shared_array_buffers_.size() * sizeof(shared_array_buffers_[0]));
+  tracker->TrackField("array_buffers_", array_buffers_);
+  tracker->TrackField("shared_array_buffers", shared_array_buffers_);
   tracker->TrackField("transferables", transferables_);
 }
 
@@ -767,7 +736,7 @@ void MessagePort::OnMessage() {
       // interruption that were already present when the OnMessage() call was
       // first triggered, but at least 1000 messages because otherwise the
       // overhead of repeatedly triggering the uv_async_t instance becomes
-      // noticable, at least on Windows.
+      // noticeable, at least on Windows.
       // (That might require more investigation by somebody more familiar with
       // Windows.)
       TriggerAsync();
@@ -780,6 +749,8 @@ void MessagePort::OnMessage() {
 
     Local<Value> payload;
     Local<Value> message_error;
+    Local<Value> argv[2];
+
     {
       // Catch any exceptions from parsing the message itself (not from
       // emitting it) as 'messageeror' events.
@@ -798,16 +769,15 @@ void MessagePort::OnMessage() {
       continue;
     }
 
-    if (MakeCallback(emit_message, 1, &payload).IsEmpty()) {
+    argv[0] = payload;
+    argv[1] = env()->message_string();
+
+    if (MakeCallback(emit_message, arraysize(argv), argv).IsEmpty()) {
     reschedule:
       if (!message_error.IsEmpty()) {
-        // This should become a `messageerror` event in the sense of the
-        // EventTarget API at some point.
-        Local<Value> argv[] = {
-          env()->messageerror_string(),
-          message_error
-        };
-        USE(MakeCallback(env()->emit_string(), arraysize(argv), argv));
+        argv[0] = message_error;
+        argv[1] = env()->messageerror_string();
+        USE(MakeCallback(emit_message, arraysize(argv), argv));
       }
 
       // Re-schedule OnMessage() execution in case of failure.
@@ -854,11 +824,11 @@ BaseObjectPtr<BaseObject> MessagePortData::Deserialize(
 }
 
 Maybe<bool> MessagePort::PostMessage(Environment* env,
+                                     Local<Context> context,
                                      Local<Value> message_v,
                                      const TransferList& transfer_v) {
   Isolate* isolate = env->isolate();
   Local<Object> obj = object(isolate);
-  Local<Context> context = obj->CreationContext();
 
   Message msg;
 
@@ -1000,7 +970,9 @@ void MessagePort::PostMessage(const FunctionCallbackInfo<Value>& args) {
     return;
   }
 
-  port->PostMessage(env, args[0], transfer_list);
+  Maybe<bool> res = port->PostMessage(env, context, args[0], transfer_list);
+  if (res.IsJust())
+    args.GetReturnValue().Set(res.FromJust());
 }
 
 void MessagePort::Start() {
@@ -1046,7 +1018,7 @@ void MessagePort::ReceiveMessage(const FunctionCallbackInfo<Value>& args) {
   if (!args[0]->IsObject() ||
       !env->message_port_constructor_template()->HasInstance(args[0])) {
     return THROW_ERR_INVALID_ARG_TYPE(env,
-        "First argument needs to be a MessagePort instance");
+        "The \"port\" argument must be a MessagePort instance");
   }
   MessagePort* port = Unwrap<MessagePort>(args[0].As<Object>());
   if (port == nullptr) {
@@ -1067,10 +1039,14 @@ void MessagePort::MoveToContext(const FunctionCallbackInfo<Value>& args) {
   if (!args[0]->IsObject() ||
       !env->message_port_constructor_template()->HasInstance(args[0])) {
     return THROW_ERR_INVALID_ARG_TYPE(env,
-        "First argument needs to be a MessagePort instance");
+        "The \"port\" argument must be a MessagePort instance");
   }
   MessagePort* port = Unwrap<MessagePort>(args[0].As<Object>());
-  CHECK_NOT_NULL(port);
+  if (port == nullptr || port->IsHandleClosing()) {
+    Isolate* isolate = env->isolate();
+    THROW_ERR_CLOSED_MESSAGE_PORT(isolate);
+    return;
+  }
 
   Local<Value> context_arg = args[1];
   ContextifyContext* context_wrapper;
@@ -1230,7 +1206,7 @@ JSTransferable::NestedTransferables() const {
     if (!list->Get(context, i).ToLocal(&value))
       return Nothing<BaseObjectList>();
     if (env()->base_object_ctor_template()->HasInstance(value))
-      ret.emplace_back(Unwrap<BaseObject>(value.As<Object>()));
+      ret.emplace_back(Unwrap<BaseObject>(value));
   }
   return Just(ret);
 }
@@ -1287,7 +1263,7 @@ BaseObjectPtr<BaseObject> JSTransferable::Data::Deserialize(
     return {};
   }
 
-  return BaseObjectPtr<BaseObject> { Unwrap<BaseObject>(ret.As<Object>()) };
+  return BaseObjectPtr<BaseObject> { Unwrap<BaseObject>(ret) };
 }
 
 Maybe<bool> JSTransferable::Data::FinalizeTransferWrite(
@@ -1340,32 +1316,24 @@ static void InitMessaging(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   {
-    Local<String> message_channel_string =
-        FIXED_ONE_BYTE_STRING(env->isolate(), "MessageChannel");
-    Local<FunctionTemplate> templ = env->NewFunctionTemplate(MessageChannel);
-    templ->SetClassName(message_channel_string);
-    target->Set(context,
-                message_channel_string,
-                templ->GetFunction(context).ToLocalChecked()).Check();
+    env->SetConstructorFunction(
+        target,
+        "MessageChannel",
+        env->NewFunctionTemplate(MessageChannel));
   }
 
   {
-    Local<String> js_transferable_string =
-        FIXED_ONE_BYTE_STRING(env->isolate(), "JSTransferable");
     Local<FunctionTemplate> t = env->NewFunctionTemplate(JSTransferable::New);
     t->Inherit(BaseObject::GetConstructorTemplate(env));
-    t->SetClassName(js_transferable_string);
     t->InstanceTemplate()->SetInternalFieldCount(
         JSTransferable::kInternalFieldCount);
-    target->Set(context,
-                js_transferable_string,
-                t->GetFunction(context).ToLocalChecked()).Check();
+    env->SetConstructorFunction(target, "JSTransferable", t);
   }
 
-  target->Set(context,
-              env->message_port_constructor_string(),
-              GetMessagePortConstructorTemplate(env)
-                  ->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(
+      target,
+      env->message_port_constructor_string(),
+      GetMessagePortConstructorTemplate(env));
 
   // These are not methods on the MessagePort prototype, because
   // the browser equivalents do not provide them.
diff --git a/src/node_messaging.h b/src/node_messaging.h
index c70408f9591e71f8e0d3b7fb5799562183e8afb3..76fc2898430baa4dfc02745d4b098e2b6f03a545 100644
--- a/src/node_messaging.h
+++ b/src/node_messaging.h
@@ -5,7 +5,6 @@
 
 #include "env.h"
 #include "node_mutex.h"
-#include "sharedarraybuffer_metadata.h"
 #include <list>
 
 namespace node {
@@ -17,7 +16,7 @@ class MessagePort;
 typedef MaybeStackBuffer<v8::Local<v8::Value>, 8> TransferList;
 
 // Used to represent the in-flight structure of an object that is being
-// transfered or cloned using postMessage().
+// transferred or cloned using postMessage().
 class TransferData : public MemoryRetainer {
  public:
   // Deserialize this object on the receiving end after a .postMessage() call.
@@ -75,13 +74,13 @@ class Message : public MemoryRetainer {
 
   // Internal method of Message that is called when a new SharedArrayBuffer
   // object is encountered in the incoming value's structure.
-  void AddSharedArrayBuffer(const SharedArrayBufferMetadataReference& ref);
+  void AddSharedArrayBuffer(std::shared_ptr<v8::BackingStore> backing_store);
   // Internal method of Message that is called once serialization finishes
   // and that transfers ownership of `data` to this message.
   void AddTransferable(std::unique_ptr<TransferData>&& data);
   // Internal method of Message that is called when a new WebAssembly.Module
   // object is encountered in the incoming value's structure.
-  uint32_t AddWASMModule(v8::WasmModuleObject::TransferrableModule&& mod);
+  uint32_t AddWASMModule(v8::CompiledWasmModule&& mod);
 
   // The host objects that will be transferred, as recorded by Serialize()
   // (e.g. MessagePorts).
@@ -98,10 +97,10 @@ class Message : public MemoryRetainer {
 
  private:
   MallocedBuffer<char> main_message_buf_;
-  std::vector<MallocedBuffer<char>> array_buffer_contents_;
-  std::vector<SharedArrayBufferMetadataReference> shared_array_buffers_;
+  std::vector<std::shared_ptr<v8::BackingStore>> array_buffers_;
+  std::vector<std::shared_ptr<v8::BackingStore>> shared_array_buffers_;
   std::vector<std::unique_ptr<TransferData>> transferables_;
-  std::vector<v8::WasmModuleObject::TransferrableModule> wasm_modules_;
+  std::vector<v8::CompiledWasmModule> wasm_modules_;
 
   friend class MessagePort;
 };
@@ -182,6 +181,7 @@ class MessagePort : public HandleWrap {
   // If this port is closed, or if there is no sibling, this message is
   // serialized with transfers, then silently discarded.
   v8::Maybe<bool> PostMessage(Environment* env,
+                              v8::Local<v8::Context> context,
                               v8::Local<v8::Value> message,
                               const TransferList& transfer);
 
diff --git a/src/node_metadata.cc b/src/node_metadata.cc
index 8c787138b46b6f49935271d005e7041885ceebd1..8d0a725de454214a6162391e09d79cddc3a42b16 100644
--- a/src/node_metadata.cc
+++ b/src/node_metadata.cc
@@ -1,6 +1,7 @@
 #include "node_metadata.h"
 #include "ares.h"
 #include "brotli/encode.h"
+#include "llhttp.h"
 #include "nghttp2/nghttp2ver.h"
 #include "node.h"
 #include "util.h"
@@ -72,8 +73,12 @@ Metadata::Versions::Versions() {
   modules = NODE_STRINGIFY(NODE_MODULE_VERSION);
   nghttp2 = NGHTTP2_VERSION;
   napi = NODE_STRINGIFY(NAPI_VERSION);
-  llhttp = per_process::llhttp_version;
-  http_parser = per_process::http_parser_version;
+  llhttp =
+      NODE_STRINGIFY(LLHTTP_VERSION_MAJOR)
+      "."
+      NODE_STRINGIFY(LLHTTP_VERSION_MINOR)
+      "."
+      NODE_STRINGIFY(LLHTTP_VERSION_PATCH);
 
   brotli =
     std::to_string(BrotliEncoderVersion() >> 24) +
diff --git a/src/node_metadata.h b/src/node_metadata.h
index c6f379f085de03daa37c3cdb3d52fd0a7ae1db8d..bf7e5d3ff4e81103674da65a37200eab79ad0b06 100644
--- a/src/node_metadata.h
+++ b/src/node_metadata.h
@@ -31,7 +31,6 @@ namespace node {
   V(nghttp2)                                                                   \
   V(napi)                                                                      \
   V(llhttp)                                                                    \
-  V(http_parser)                                                               \
 
 #if HAVE_OPENSSL
 #define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl)
@@ -102,8 +101,6 @@ class Metadata {
 // Per-process global
 namespace per_process {
 extern Metadata metadata;
-extern const char* const llhttp_version;
-extern const char* const http_parser_version;
 }
 
 }  // namespace node
diff --git a/src/node_mutex.h b/src/node_mutex.h
index b82505cc639b7a6d12779c40b6e8ceaf4cec02a9..40c44c6d4fadb101ba16d2a2a8ef88434ab38c3a 100644
--- a/src/node_mutex.h
+++ b/src/node_mutex.h
@@ -32,7 +32,7 @@ class ExclusiveAccess {
 
   class Scoped {
    public:
-    // ExclusiveAccess will commonly be used in conjuction with std::shared_ptr
+    // ExclusiveAccess will commonly be used in conjunction with std::shared_ptr
     // and without this constructor it's too easy to forget to keep a reference
     // around to the shared_ptr while operating on the ExclusiveAccess object.
     explicit Scoped(const std::shared_ptr<ExclusiveAccess>& shared)
diff --git a/src/node_native_module.cc b/src/node_native_module.cc
index 4c3633e06c60265c974bdd2a5a3d2e615e4aeb82..5dab47f8208e431f07d7689cfd3f33668f969612 100644
--- a/src/node_native_module.cc
+++ b/src/node_native_module.cc
@@ -1,5 +1,6 @@
 #include "node_native_module.h"
 #include "util-inl.h"
+#include "debug_utils-inl.h"
 
 namespace node {
 namespace native_module {
@@ -70,6 +71,7 @@ void NativeModuleLoader::InitializeModuleCategories() {
   std::vector<std::string> prefixes = {
 #if !HAVE_OPENSSL
     "internal/crypto/",
+    "internal/debugger/",
 #endif  // !HAVE_OPENSSL
 
     "internal/bootstrap/",
@@ -205,38 +207,25 @@ MaybeLocal<String> NativeModuleLoader::LoadBuiltinModuleSource(Isolate* isolate,
 #ifdef NODE_BUILTIN_MODULES_PATH
   std::string filename = OnDiskFileName(id);
 
-  uv_fs_t req;
-  uv_file file =
-      uv_fs_open(nullptr, &req, filename.c_str(), O_RDONLY, 0, nullptr);
-  CHECK_GE(req.result, 0);
-  uv_fs_req_cleanup(&req);
-
-  auto defer_close = OnScopeLeave([file]() {
-    uv_fs_t close_req;
-    CHECK_EQ(0, uv_fs_close(nullptr, &close_req, file, nullptr));
-    uv_fs_req_cleanup(&close_req);
-  });
-
   std::string contents;
-  char buffer[4096];
-  uv_buf_t buf = uv_buf_init(buffer, sizeof(buffer));
-
-  while (true) {
-    const int r =
-        uv_fs_read(nullptr, &req, file, &buf, 1, contents.length(), nullptr);
-    CHECK_GE(req.result, 0);
-    uv_fs_req_cleanup(&req);
-    if (r <= 0) {
-      break;
-    }
-    contents.append(buf.base, r);
+  int r = ReadFileSync(&contents, filename.c_str());
+  if (r != 0) {
+    const std::string buf = SPrintF("Cannot read local builtin. %s: %s \"%s\"",
+                                    uv_err_name(r),
+                                    uv_strerror(r),
+                                    filename);
+    Local<String> message = OneByteString(isolate, buf.c_str());
+    isolate->ThrowException(v8::Exception::Error(message));
+    return MaybeLocal<String>();
   }
-
   return String::NewFromUtf8(
       isolate, contents.c_str(), v8::NewStringType::kNormal, contents.length());
 #else
   const auto source_it = source_.find(id);
-  CHECK_NE(source_it, source_.end());
+  if (UNLIKELY(source_it == source_.end())) {
+    fprintf(stderr, "Cannot find native builtin: \"%s\".\n", id);
+    ABORT();
+  }
   return source_it->second.ToStringChecked(isolate);
 #endif  // NODE_BUILTIN_MODULES_PATH
 }
diff --git a/src/node_native_module_env.cc b/src/node_native_module_env.cc
index cdd98e8220eb4640df631d2b60984c7c048d0a50..a3a42a3ec4b9a6c33ad203800e92362218194748 100644
--- a/src/node_native_module_env.cc
+++ b/src/node_native_module_env.cc
@@ -190,7 +190,7 @@ void NativeModuleEnv::Initialize(Local<Object> target,
                     FIXED_ONE_BYTE_STRING(env->isolate(), "moduleCategories"),
                     GetModuleCategories,
                     nullptr,
-                    env->as_callback_data(),
+                    Local<Value>(),
                     DEFAULT,
                     None,
                     SideEffectType::kHasNoSideEffect)
diff --git a/src/node_options-inl.h b/src/node_options-inl.h
index 682a1c6c47d020d2d3455c887238ac67a42f83ac..7facb22afc3c9bd7b52a61626cca1d7733acb7fc 100644
--- a/src/node_options-inl.h
+++ b/src/node_options-inl.h
@@ -23,12 +23,14 @@ template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
                                        bool Options::* field,
-                                       OptionEnvvarSettings env_setting) {
+                                       OptionEnvvarSettings env_setting,
+                                       bool default_is_true) {
   options_.emplace(name,
                    OptionInfo{kBoolean,
                               std::make_shared<SimpleOptionField<bool>>(field),
                               env_setting,
-                              help_text});
+                              help_text,
+                              default_is_true});
 }
 
 template <typename Options>
@@ -138,10 +140,9 @@ void OptionsParser<Options>::Implies(const char* from,
                                      const char* to) {
   auto it = options_.find(to);
   CHECK_NE(it, options_.end());
-  CHECK_EQ(it->second.type, kBoolean);
-  implications_.emplace(from, Implication {
-    it->second.field, true
-  });
+  CHECK(it->second.type == kBoolean || it->second.type == kV8Option);
+  implications_.emplace(
+      from, Implication{it->second.type, to, it->second.field, true});
 }
 
 template <typename Options>
@@ -150,9 +151,8 @@ void OptionsParser<Options>::ImpliesNot(const char* from,
   auto it = options_.find(to);
   CHECK_NE(it, options_.end());
   CHECK_EQ(it->second.type, kBoolean);
-  implications_.emplace(from, Implication {
-    it->second.field, false
-  });
+  implications_.emplace(
+      from, Implication{it->second.type, to, it->second.field, false});
 }
 
 template <typename Options>
@@ -188,7 +188,8 @@ auto OptionsParser<Options>::Convert(
   return OptionInfo{original.type,
                     Convert(original.field, get_child),
                     original.env_setting,
-                    original.help_text};
+                    original.help_text,
+                    original.default_is_true};
 }
 
 template <typename Options>
@@ -196,9 +197,11 @@ template <typename ChildOptions>
 auto OptionsParser<Options>::Convert(
     typename OptionsParser<ChildOptions>::Implication original,
     ChildOptions* (Options::* get_child)()) {
-  return Implication {
-    Convert(original.target_field, get_child),
-    original.target_value
+  return Implication{
+      original.type,
+      original.name,
+      Convert(original.target_field, get_child),
+      original.target_value,
   };
 }
 
@@ -225,6 +228,10 @@ inline std::string RequiresArgumentErr(const std::string& arg) {
   return arg + " requires an argument";
 }
 
+inline std::string NegationImpliesBooleanError(const std::string& arg) {
+  return arg + " is an invalid negation because it is not a boolean option";
+}
+
 // We store some of the basic information around a single Parse call inside
 // this struct, to separate storage of command line arguments and their
 // handling. In particular, this makes it easier to introduce 'synthetic'
@@ -325,6 +332,13 @@ void OptionsParser<Options>::Parse(
         name[i] = '-';
     }
 
+    // Convert --no-foo to --foo and keep in mind that we're negating.
+    bool is_negation = false;
+    if (name.find("--no-") == 0) {
+      name.erase(2, 3);  // remove no-
+      is_negation = true;
+    }
+
     {
       auto it = aliases_.end();
       // Expand aliases:
@@ -366,20 +380,36 @@ void OptionsParser<Options>::Parse(
       break;
     }
 
+    {
+      std::string implied_name = name;
+      if (is_negation) {
+        // Implications for negated options are defined with "--no-".
+        implied_name.insert(2, "no-");
+      }
+      auto implications = implications_.equal_range(implied_name);
+      for (auto it = implications.first; it != implications.second; ++it) {
+        if (it->second.type == kV8Option) {
+          v8_args->push_back(it->second.name);
+        } else {
+          *it->second.target_field->template Lookup<bool>(options) =
+              it->second.target_value;
+        }
+      }
+    }
+
     if (it == options_.end()) {
       v8_args->push_back(arg);
       continue;
     }
 
-    {
-      auto implications = implications_.equal_range(name);
-      for (auto it = implications.first; it != implications.second; ++it) {
-        *it->second.target_field->template Lookup<bool>(options) =
-            it->second.target_value;
-      }
+    const OptionInfo& info = it->second;
+
+    // Some V8 options can be negated and they are validated by V8 later.
+    if (is_negation && info.type != kBoolean && info.type != kV8Option) {
+      errors->push_back(NegationImpliesBooleanError(arg));
+      break;
     }
 
-    const OptionInfo& info = it->second;
     std::string value;
     if (info.type != kBoolean && info.type != kNoOp && info.type != kV8Option) {
       if (equals_index != std::string::npos) {
@@ -408,7 +438,7 @@ void OptionsParser<Options>::Parse(
 
     switch (info.type) {
       case kBoolean:
-        *Lookup<bool>(info.field, options) = true;
+        *Lookup<bool>(info.field, options) = !is_negation;
         break;
       case kInteger:
         *Lookup<int64_t>(info.field, options) = std::atoll(value.c_str());
diff --git a/src/node_options.cc b/src/node_options.cc
index 0240b2ef58ae7a03d69968951a589ae29678487f..cee6fc1773140b9636c0f9f154d9875f83c6c938 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -104,11 +104,9 @@ void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors) {
     errors->push_back("either --check or --eval can be used, not both");
   }
 
-  if (http_parser != "legacy" && http_parser != "llhttp") {
-    errors->push_back("invalid value for --http-parser");
-  }
-
   if (!unhandled_rejections.empty() &&
+      unhandled_rejections != "warn-with-error-code" &&
+      unhandled_rejections != "throw" &&
       unhandled_rejections != "strict" &&
       unhandled_rejections != "warn" &&
       unhandled_rejections != "none") {
@@ -120,6 +118,10 @@ void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors) {
                       "used, not both");
   }
 
+  if (heap_snapshot_near_heap_limit < 0) {
+    errors->push_back("--heap-snapshot-near-heap-limit must not be negative");
+  }
+
 #if HAVE_INSPECTOR
   if (!cpu_prof) {
     if (!cpu_prof_name.empty()) {
@@ -274,15 +276,27 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "additional user conditions for conditional exports and imports",
             &EnvironmentOptions::conditions,
             kAllowedInEnvironment);
+  AddAlias("-C", "--conditions");
   AddOption("--diagnostic-dir",
             "set dir for all output files"
             " (default: current working directory)",
             &EnvironmentOptions::diagnostic_dir,
             kAllowedInEnvironment);
+  AddOption("--dns-result-order",
+            "set default value of verbatim in dns.lookup. Options are "
+            "'ipv4first' (IPv4 addresses are placed before IPv6 addresses) "
+            "'verbatim' (addresses are in the order the DNS resolver "
+            "returned)",
+            &EnvironmentOptions::dns_result_order,
+            kAllowedInEnvironment);
   AddOption("--enable-source-maps",
             "experimental Source Map V3 support",
             &EnvironmentOptions::enable_source_maps,
             kAllowedInEnvironment);
+  AddOption("--experimental-abortcontroller",
+            "experimental AbortController support",
+            &EnvironmentOptions::experimental_abortcontroller,
+            kAllowedInEnvironment);
   AddOption("--experimental-json-modules",
             "experimental JSON interop support for the ES Module loader",
             &EnvironmentOptions::experimental_json_modules,
@@ -341,18 +355,15 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "Generate heap snapshot on specified signal",
             &EnvironmentOptions::heap_snapshot_signal,
             kAllowedInEnvironment);
-  AddOption("--http-parser",
-            "Select which HTTP parser to use; either 'legacy' or 'llhttp' "
-            "(default: llhttp).",
-            &EnvironmentOptions::http_parser,
-            kAllowedInEnvironment);
-  AddOption("--http-server-default-timeout",
-            "Default http server socket timeout in ms "
-            "(default: 120000)",
-            &EnvironmentOptions::http_server_default_timeout,
+  AddOption("--heapsnapshot-near-heap-limit",
+            "Generate heap snapshots whenever V8 is approaching "
+            "the heap limit. No more than the specified number of "
+            "heap snapshots will be generated.",
+            &EnvironmentOptions::heap_snapshot_near_heap_limit,
             kAllowedInEnvironment);
+  AddOption("--http-parser", "", NoOp{}, kAllowedInEnvironment);
   AddOption("--insecure-http-parser",
-            "Use an insecure HTTP parser that accepts invalid HTTP headers",
+            "use an insecure HTTP parser that accepts invalid HTTP headers",
             &EnvironmentOptions::insecure_http_parser,
             kAllowedInEnvironment);
   AddOption("--input-type",
@@ -366,18 +377,21 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             kAllowedInEnvironment);
   AddAlias("--es-module-specifier-resolution",
            "--experimental-specifier-resolution");
-  AddOption("--no-deprecation",
+  AddOption("--deprecation",
             "silence deprecation warnings",
-            &EnvironmentOptions::no_deprecation,
-            kAllowedInEnvironment);
-  AddOption("--no-force-async-hooks-checks",
+            &EnvironmentOptions::deprecation,
+            kAllowedInEnvironment,
+            true);
+  AddOption("--force-async-hooks-checks",
             "disable checks for async_hooks",
-            &EnvironmentOptions::no_force_async_hooks_checks,
-            kAllowedInEnvironment);
-  AddOption("--no-warnings",
+            &EnvironmentOptions::force_async_hooks_checks,
+            kAllowedInEnvironment,
+            true);
+  AddOption("--warnings",
             "silence all process warnings",
-            &EnvironmentOptions::no_warnings,
-            kAllowedInEnvironment);
+            &EnvironmentOptions::warnings,
+            kAllowedInEnvironment,
+            true);
   AddOption("--force-context-aware",
             "disable loading non-context-aware addons",
             &EnvironmentOptions::force_context_aware,
@@ -394,6 +408,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "preserve symbolic links when resolving the main module",
             &EnvironmentOptions::preserve_symlinks_main,
             kAllowedInEnvironment);
+  AddOption("--prof",
+            "Generate V8 profiler output.",
+            V8Option{});
   AddOption("--prof-process",
             "process V8 profiler output generated using --prof",
             &EnvironmentOptions::prof_process);
@@ -436,6 +453,10 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "profile generated with --heap-prof. (default: 512 * 1024)",
             &EnvironmentOptions::heap_prof_interval);
 #endif  // HAVE_INSPECTOR
+  AddOption("--max-http-header-size",
+            "set the maximum size of HTTP headers (default: 16384 (16KB))",
+            &EnvironmentOptions::max_http_header_size,
+            kAllowedInEnvironment);
   AddOption("--redirect-warnings",
             "write warnings to file instead of stderr",
             &EnvironmentOptions::redirect_warnings,
@@ -446,6 +467,10 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "throw an exception on deprecations",
             &EnvironmentOptions::throw_deprecation,
             kAllowedInEnvironment);
+  AddOption("--trace-atomics-wait",
+            "trace Atomics.wait() operations",
+            &EnvironmentOptions::trace_atomics_wait,
+            kAllowedInEnvironment);
   AddOption("--trace-deprecation",
             "show stack traces on deprecations",
             &EnvironmentOptions::trace_deprecation,
@@ -472,10 +497,17 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             &EnvironmentOptions::trace_warnings,
             kAllowedInEnvironment);
   AddOption("--unhandled-rejections",
-            "define unhandled rejections behavior. Options are 'strict' (raise "
-            "an error), 'warn' (enforce warnings) or 'none' (silence warnings)",
+            "define unhandled rejections behavior. Options are 'strict' "
+            "(always raise an error), 'throw' (raise an error unless "
+            "'unhandledRejection' hook is set), 'warn' (log a warning), 'none' "
+            "(silence warnings), 'warn-with-error-code' (log a warning and set "
+            "exit code 1 unless 'unhandledRejection' hook is set).",
             &EnvironmentOptions::unhandled_rejections,
             kAllowedInEnvironment);
+  AddOption("--verify-base-objects",
+            "", /* undocumented, only for debugging */
+            &EnvironmentOptions::verify_base_objects,
+            kAllowedInEnvironment);
 
   AddOption("--check",
             "syntax check script without executing",
@@ -550,9 +582,9 @@ PerIsolateOptionsParser::PerIsolateOptionsParser(
             "track heap object allocations for heap snapshots",
             &PerIsolateOptions::track_heap_objects,
             kAllowedInEnvironment);
-  AddOption("--no-node-snapshot",
+  AddOption("--node-snapshot",
             "",  // It's a debug-only option.
-            &PerIsolateOptions::no_node_snapshot,
+            &PerIsolateOptions::node_snapshot,
             kAllowedInEnvironment);
 
   // Explicitly add some V8 flags to mark them as allowed in NODE_OPTIONS.
@@ -604,6 +636,15 @@ PerIsolateOptionsParser::PerIsolateOptionsParser(
             kAllowedInEnvironment);
   Implies("--report-signal", "--report-on-signal");
 
+  AddOption("--experimental-top-level-await",
+            "",
+            &PerIsolateOptions::experimental_top_level_await,
+            kAllowedInEnvironment);
+  AddOption("--harmony-top-level-await", "", V8Option{});
+  Implies("--experimental-top-level-await", "--harmony-top-level-await");
+  Implies("--harmony-top-level-await", "--experimental-top-level-await");
+  ImpliesNot("--no-harmony-top-level-await", "--experimental-top-level-await");
+
   Insert(eop, &PerIsolateOptions::get_per_env_options);
 }
 
@@ -624,10 +665,6 @@ PerProcessOptionsParser::PerProcessOptionsParser(
             kAllowedInEnvironment);
   AddAlias("--trace-events-enabled", {
     "--trace-event-categories", "v8,node,node.async_hooks" });
-  AddOption("--max-http-header-size",
-            "set the maximum size of HTTP headers (default: 8KB)",
-            &PerProcessOptions::max_http_header_size,
-            kAllowedInEnvironment);
   AddOption("--v8-pool-size",
             "set V8's thread pool size",
             &PerProcessOptions::v8_thread_pool_size,
@@ -688,7 +725,7 @@ PerProcessOptionsParser::PerProcessOptionsParser(
   AddOption("--icu-data-dir",
             "set ICU data load path to dir (overrides NODE_ICU_DATA)"
 #ifndef NODE_HAVE_SMALL_ICU
-            " (note: linked-in ICU data is present)\n"
+            " (note: linked-in ICU data is present)"
 #endif
             ,
             &PerProcessOptions::icu_data_dir,
@@ -748,16 +785,18 @@ PerProcessOptionsParser::PerProcessOptionsParser(
             &PerProcessOptions::use_largepages,
             kAllowedInEnvironment);
 
-  // v12.x backwards compat flags removed in V8 7.9.
-  AddOption("--fast_calls_with_arguments_mismatches", "", NoOp{});
-  AddOption("--harmony_numeric_separator", "", NoOp{});
-
   AddOption("--trace-sigint",
             "enable printing JavaScript stacktrace on SIGINT",
             &PerProcessOptions::trace_sigint,
             kAllowedInEnvironment);
 
   Insert(iop, &PerProcessOptions::get_per_isolate_options);
+
+  AddOption("--node-memory-debug",
+            "Run with extra debug checks for memory leaks in Node.js itself",
+            NoOp{}, kAllowedInEnvironment);
+  Implies("--node-memory-debug", "--debug-arraybuffer-allocations");
+  Implies("--node-memory-debug", "--verify-base-objects");
 }
 
 inline std::string RemoveBrackets(const std::string& host) {
@@ -870,6 +909,12 @@ void GetOptions(const FunctionCallbackInfo<Value>& args) {
   });
 
   Local<Map> options = Map::New(isolate);
+  if (options
+          ->SetPrototype(context, env->primordials_safe_map_prototype_object())
+          .IsNothing()) {
+    return;
+  }
+
   for (const auto& item : _ppop_instance.options_) {
     Local<Value> value;
     const auto& option_info = item.second;
@@ -949,6 +994,10 @@ void GetOptions(const FunctionCallbackInfo<Value>& args) {
                    env->type_string(),
                    Integer::New(isolate, static_cast<int>(option_info.type)))
              .FromMaybe(false) ||
+        !info->Set(context,
+                   env->default_is_true_string(),
+                   Boolean::New(isolate, option_info.default_is_true))
+             .FromMaybe(false) ||
         info->Set(context, env->value_string(), value).IsNothing() ||
         options->Set(context, name, info).IsEmpty()) {
       return;
@@ -958,6 +1007,12 @@ void GetOptions(const FunctionCallbackInfo<Value>& args) {
   Local<Value> aliases;
   if (!ToV8Value(context, _ppop_instance.aliases_).ToLocal(&aliases)) return;
 
+  if (aliases.As<Object>()
+          ->SetPrototype(context, env->primordials_safe_map_prototype_object())
+          .IsNothing()) {
+    return;
+  }
+
   Local<Object> ret = Object::New(isolate);
   if (ret->Set(context, env->options_string(), options).IsNothing() ||
       ret->Set(context, env->aliases_string(), aliases).IsNothing()) {
diff --git a/src/node_options.h b/src/node_options.h
index aa138c6970be45cc5718dc48e2eadef8792d49e0..a02d43bf5f98df0bd890c725224279c4293a277a 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -101,7 +101,9 @@ class EnvironmentOptions : public Options {
  public:
   bool abort_on_uncaught_exception = false;
   std::vector<std::string> conditions;
+  std::string dns_result_order;
   bool enable_source_maps = false;
+  bool experimental_abortcontroller = false;
   bool experimental_json_modules = false;
   bool experimental_modules = false;
   std::string experimental_specifier_resolution;
@@ -115,12 +117,12 @@ class EnvironmentOptions : public Options {
   bool experimental_vm_modules = false;
   bool expose_internals = false;
   bool frozen_intrinsics = false;
+  int64_t heap_snapshot_near_heap_limit = 0;
   std::string heap_snapshot_signal;
-  std::string http_parser = "llhttp";
-  uint64_t http_server_default_timeout = 120000;
-  bool no_deprecation = false;
-  bool no_force_async_hooks_checks = false;
-  bool no_warnings = false;
+  uint64_t max_http_header_size = 16 * 1024;
+  bool deprecation = true;
+  bool force_async_hooks_checks = true;
+  bool warnings = true;
   bool force_context_aware = false;
   bool pending_deprecation = false;
   bool preserve_symlinks = false;
@@ -142,6 +144,7 @@ class EnvironmentOptions : public Options {
   std::string diagnostic_dir;
   bool test_udp_no_try_send = false;
   bool throw_deprecation = false;
+  bool trace_atomics_wait = false;
   bool trace_deprecation = false;
   bool trace_exit = false;
   bool trace_sync_io = false;
@@ -150,6 +153,12 @@ class EnvironmentOptions : public Options {
   bool trace_warnings = false;
   std::string unhandled_rejections;
   std::string userland_loader;
+  bool verify_base_objects =
+#ifdef DEBUG
+      true;
+#else
+      false;
+#endif  // DEBUG
 
   bool syntax_check_only = false;
   bool has_eval_string = false;
@@ -185,9 +194,10 @@ class PerIsolateOptions : public Options {
  public:
   std::shared_ptr<EnvironmentOptions> per_env { new EnvironmentOptions() };
   bool track_heap_objects = false;
-  bool no_node_snapshot = false;
+  bool node_snapshot = true;
   bool report_uncaught_exception = false;
   bool report_on_signal = false;
+  bool experimental_top_level_await = true;
   std::string report_signal = "SIGUSR2";
   inline EnvironmentOptions* get_per_env_options();
   void CheckOptions(std::vector<std::string>* errors) override;
@@ -208,7 +218,6 @@ class PerProcessOptions : public Options {
   std::string title;
   std::string trace_event_categories;
   std::string trace_event_file_pattern = "node_trace.${rotation}.log";
-  uint64_t max_http_header_size = 8 * 1024;
   int64_t v8_thread_pool_size = 4;
   bool zero_fill_all_buffers = false;
   bool debug_arraybuffer_allocations = false;
@@ -225,7 +234,7 @@ class PerProcessOptions : public Options {
 #endif
 
   // Per-process because they affect singleton OpenSSL shared library state,
-  // or are used once during process intialization.
+  // or are used once during process initialization.
 #if HAVE_OPENSSL
   std::string openssl_config;
   std::string tls_cipher_list = DEFAULT_CIPHER_LIST_CORE;
@@ -293,7 +302,8 @@ class OptionsParser {
   void AddOption(const char* name,
                  const char* help_text,
                  bool Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
+                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment,
+                 bool default_is_true = false);
   void AddOption(const char* name,
                  const char* help_text,
                  uint64_t Options::* field,
@@ -416,11 +426,14 @@ class OptionsParser {
     std::shared_ptr<BaseOptionField> field;
     OptionEnvvarSettings env_setting;
     std::string help_text;
+    bool default_is_true = false;
   };
 
   // An implied option is composed of the information on where to store a
   // specific boolean value (if another specific option is encountered).
   struct Implication {
+    OptionType type;
+    std::string name;
     std::shared_ptr<BaseOptionField> target_field;
     bool target_value;
   };
diff --git a/src/node_os.cc b/src/node_os.cc
index b6fbb126b2f7bcc0f7d04dfc59835bacc8eb8d44..3cde80996f095fb89eeb365ac270192d817fedcd 100644
--- a/src/node_os.cc
+++ b/src/node_os.cc
@@ -71,11 +71,9 @@ static void GetHostname(const FunctionCallbackInfo<Value>& args) {
   }
 
   args.GetReturnValue().Set(
-      String::NewFromUtf8(env->isolate(), buf, NewStringType::kNormal)
-          .ToLocalChecked());
+      String::NewFromUtf8(env->isolate(), buf).ToLocalChecked());
 }
 
-
 static void GetOSInformation(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   uv_utsname_t info;
@@ -89,12 +87,9 @@ static void GetOSInformation(const FunctionCallbackInfo<Value>& args) {
 
   // [sysname, version, release]
   Local<Value> osInformation[] = {
-    String::NewFromUtf8(
-        env->isolate(), info.sysname, NewStringType::kNormal).ToLocalChecked(),
-    String::NewFromUtf8(
-        env->isolate(), info.version, NewStringType::kNormal).ToLocalChecked(),
-    String::NewFromUtf8(
-        env->isolate(), info.release, NewStringType::kNormal).ToLocalChecked()
+    String::NewFromUtf8(env->isolate(), info.sysname).ToLocalChecked(),
+    String::NewFromUtf8(env->isolate(), info.version).ToLocalChecked(),
+    String::NewFromUtf8(env->isolate(), info.release).ToLocalChecked()
   };
 
   args.GetReturnValue().Set(Array::New(env->isolate(),
@@ -102,7 +97,6 @@ static void GetOSInformation(const FunctionCallbackInfo<Value>& args) {
                                        arraysize(osInformation)));
 }
 
-
 static void GetCPUInfo(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Isolate* isolate = env->isolate();
@@ -118,16 +112,17 @@ static void GetCPUInfo(const FunctionCallbackInfo<Value>& args) {
   // assemble them into objects in JS than to call Object::Set() repeatedly
   // The array is in the format
   // [model, speed, (5 entries of cpu_times), model2, speed2, ...]
-  std::vector<Local<Value>> result(count * 7);
-  for (int i = 0, j = 0; i < count; i++) {
+  std::vector<Local<Value>> result;
+  result.reserve(count * 7);
+  for (int i = 0; i < count; i++) {
     uv_cpu_info_t* ci = cpu_infos + i;
-    result[j++] = OneByteString(isolate, ci->model);
-    result[j++] = Number::New(isolate, ci->speed);
-    result[j++] = Number::New(isolate, ci->cpu_times.user);
-    result[j++] = Number::New(isolate, ci->cpu_times.nice);
-    result[j++] = Number::New(isolate, ci->cpu_times.sys);
-    result[j++] = Number::New(isolate, ci->cpu_times.idle);
-    result[j++] = Number::New(isolate, ci->cpu_times.irq);
+    result.emplace_back(OneByteString(isolate, ci->model));
+    result.emplace_back(Number::New(isolate, ci->speed));
+    result.emplace_back(Number::New(isolate, ci->cpu_times.user));
+    result.emplace_back(Number::New(isolate, ci->cpu_times.nice));
+    result.emplace_back(Number::New(isolate, ci->cpu_times.sys));
+    result.emplace_back(Number::New(isolate, ci->cpu_times.idle));
+    result.emplace_back(Number::New(isolate, ci->cpu_times.irq));
   }
 
   uv_free_cpu_info(cpu_infos, count);
@@ -160,7 +155,7 @@ static void GetLoadAvg(const FunctionCallbackInfo<Value>& args) {
   Local<Float64Array> array = args[0].As<Float64Array>();
   CHECK_EQ(array->Length(), 3);
   Local<ArrayBuffer> ab = array->Buffer();
-  double* loadavg = static_cast<double*>(ab->GetContents().Data());
+  double* loadavg = static_cast<double*>(ab->GetBackingStore()->Data());
   uv_loadavg(loadavg);
 }
 
@@ -188,7 +183,8 @@ static void GetInterfaceAddresses(const FunctionCallbackInfo<Value>& args) {
   }
 
   Local<Value> no_scope_id = Integer::New(isolate, -1);
-  std::vector<Local<Value>> result(count * 7);
+  std::vector<Local<Value>> result;
+  result.reserve(count * 7);
   for (i = 0; i < count; i++) {
     const char* const raw_name = interfaces[i].name;
 
@@ -197,8 +193,7 @@ static void GetInterfaceAddresses(const FunctionCallbackInfo<Value>& args) {
     // to assume UTF8 as the default as well. It’s what people will expect if
     // they name the interface from any input that uses UTF-8, which should be
     // the most frequent case by far these days.)
-    name = String::NewFromUtf8(isolate, raw_name,
-        NewStringType::kNormal).ToLocalChecked();
+    name = String::NewFromUtf8(isolate, raw_name).ToLocalChecked();
 
     snprintf(mac.data(),
              mac.size(),
@@ -223,18 +218,18 @@ static void GetInterfaceAddresses(const FunctionCallbackInfo<Value>& args) {
       family = env->unknown_string();
     }
 
-    result[i * 7] = name;
-    result[i * 7 + 1] = OneByteString(isolate, ip);
-    result[i * 7 + 2] = OneByteString(isolate, netmask);
-    result[i * 7 + 3] = family;
-    result[i * 7 + 4] = FIXED_ONE_BYTE_STRING(isolate, mac);
-    result[i * 7 + 5] =
-      interfaces[i].is_internal ? True(isolate) : False(isolate);
+    result.emplace_back(name);
+    result.emplace_back(OneByteString(isolate, ip));
+    result.emplace_back(OneByteString(isolate, netmask));
+    result.emplace_back(family);
+    result.emplace_back(FIXED_ONE_BYTE_STRING(isolate, mac));
+    result.emplace_back(
+        interfaces[i].is_internal ? True(isolate) : False(isolate));
     if (interfaces[i].address.address4.sin_family == AF_INET6) {
       uint32_t scopeid = interfaces[i].address.address6.sin6_scope_id;
-      result[i * 7 + 6] = Integer::NewFromUnsigned(isolate, scopeid);
+      result.emplace_back(Integer::NewFromUnsigned(isolate, scopeid));
     } else {
-      result[i * 7 + 6] = no_scope_id;
+      result.emplace_back(no_scope_id);
     }
   }
 
@@ -387,12 +382,12 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "getTotalMem", GetTotalMemory);
   env->SetMethod(target, "getFreeMem", GetFreeMemory);
   env->SetMethod(target, "getCPUs", GetCPUInfo);
-  env->SetMethod(target, "getOSInformation", GetOSInformation);
   env->SetMethod(target, "getInterfaceAddresses", GetInterfaceAddresses);
   env->SetMethod(target, "getHomeDirectory", GetHomeDirectory);
   env->SetMethod(target, "getUserInfo", GetUserInfo);
   env->SetMethod(target, "setPriority", SetPriority);
   env->SetMethod(target, "getPriority", GetPriority);
+  env->SetMethod(target, "getOSInformation", GetOSInformation);
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "isBigEndian"),
               Boolean::New(env->isolate(), IsBigEndian())).Check();
diff --git a/src/node_perf.cc b/src/node_perf.cc
index fdc3c732c92bc24f450b28033ba3ef0610608311..2f6fab9242f6560b2504f81ed82bf61c5497f0fa 100644
--- a/src/node_perf.cc
+++ b/src/node_perf.cc
@@ -1,9 +1,10 @@
 #include "aliased_buffer.h"
+#include "histogram-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_internals.h"
 #include "node_perf.h"
 #include "node_buffer.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "util-inl.h"
 
 #include <cinttypes>
@@ -19,12 +20,11 @@ using v8::FunctionTemplate;
 using v8::GCCallbackFlags;
 using v8::GCType;
 using v8::HandleScope;
+using v8::Int32;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
-using v8::Map;
 using v8::MaybeLocal;
-using v8::NewStringType;
 using v8::Number;
 using v8::Object;
 using v8::PropertyAttribute;
@@ -60,16 +60,14 @@ inline void InitObject(const PerformanceEntry& entry, Local<Object> obj) {
   obj->DefineOwnProperty(context,
                          env->name_string(),
                          String::NewFromUtf8(isolate,
-                                             entry.name().c_str(),
-                                             NewStringType::kNormal)
+                                             entry.name().c_str())
                              .ToLocalChecked(),
                          attr)
       .Check();
   obj->DefineOwnProperty(context,
                          env->entry_type_string(),
                          String::NewFromUtf8(isolate,
-                                             entry.type().c_str(),
-                                             NewStringType::kNormal)
+                                             entry.type().c_str())
                              .ToLocalChecked(),
                          attr)
       .Check();
@@ -404,156 +402,45 @@ void LoopIdleTime(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(1.0 * idle_time / 1e6);
 }
 
-
 // Event Loop Timing Histogram
-namespace {
-static void ELDHistogramMin(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Min());
-  args.GetReturnValue().Set(value);
-}
-
-static void ELDHistogramMax(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Max());
-  args.GetReturnValue().Set(value);
-}
-
-static void ELDHistogramMean(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Mean());
-}
-
-static void ELDHistogramExceeds(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Exceeds());
-  args.GetReturnValue().Set(value);
-}
-
-static void ELDHistogramStddev(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Stddev());
-}
-
-static void ELDHistogramPercentile(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  CHECK(args[0]->IsNumber());
-  double percentile = args[0].As<Number>()->Value();
-  args.GetReturnValue().Set(histogram->Percentile(percentile));
-}
-
-static void ELDHistogramPercentiles(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  CHECK(args[0]->IsMap());
-  Local<Map> map = args[0].As<Map>();
-  histogram->Percentiles([&](double key, double value) {
-    map->Set(env->context(),
-             Number::New(env->isolate(), key),
-             Number::New(env->isolate(), value)).IsEmpty();
-  });
-}
-
-static void ELDHistogramEnable(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Enable());
-}
-
-static void ELDHistogramDisable(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Disable());
-}
-
-static void ELDHistogramReset(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  histogram->ResetState();
-}
-
-static void ELDHistogramNew(const FunctionCallbackInfo<Value>& args) {
+void ELDHistogram::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK(args.IsConstructCall());
-  int32_t resolution = args[0]->IntegerValue(env->context()).FromJust();
+  int32_t resolution = args[0].As<Int32>()->Value();
   CHECK_GT(resolution, 0);
   new ELDHistogram(env, args.This(), resolution);
 }
-}  // namespace
+
+void ELDHistogram::Initialize(Environment* env, Local<Object> target) {
+  Local<FunctionTemplate> tmpl = env->NewFunctionTemplate(New);
+  tmpl->Inherit(IntervalHistogram::GetConstructorTemplate(env));
+  tmpl->InstanceTemplate()->SetInternalFieldCount(
+      ELDHistogram::kInternalFieldCount);
+  env->SetConstructorFunction(target, "ELDHistogram", tmpl);
+}
 
 ELDHistogram::ELDHistogram(
     Environment* env,
     Local<Object> wrap,
-    int32_t resolution) : HandleWrap(env,
-                                     wrap,
-                                     reinterpret_cast<uv_handle_t*>(&timer_),
-                                     AsyncWrap::PROVIDER_ELDHISTOGRAM),
-                          Histogram(1, 3.6e12),
-                          resolution_(resolution) {
-  MakeWeak();
-  uv_timer_init(env->event_loop(), &timer_);
-}
-
-void ELDHistogram::DelayIntervalCallback(uv_timer_t* req) {
-  ELDHistogram* histogram = ContainerOf(&ELDHistogram::timer_, req);
-  histogram->RecordDelta();
+    int32_t interval)
+    : IntervalHistogram(
+          env,
+          wrap,
+          AsyncWrap::PROVIDER_ELDHISTOGRAM,
+          interval, 1, 3.6e12, 3) {}
+
+void ELDHistogram::OnInterval() {
+  uint64_t delta = histogram()->RecordDelta();
   TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                 "min", histogram->Min());
+                  "delay", delta);
   TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                 "max", histogram->Max());
+                 "min", histogram()->Min());
   TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                 "mean", histogram->Mean());
+                 "max", histogram()->Max());
   TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                 "stddev", histogram->Stddev());
-}
-
-bool ELDHistogram::RecordDelta() {
-  uint64_t time = uv_hrtime();
-  bool ret = true;
-  if (prev_ > 0) {
-    int64_t delta = time - prev_;
-    if (delta > 0) {
-      ret = Record(delta);
-      TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                     "delay", delta);
-      if (!ret) {
-        if (exceeds_ < 0xFFFFFFFF)
-          exceeds_++;
-        ProcessEmitWarning(
-            env(),
-            "Event loop delay exceeded 1 hour: %" PRId64 " nanoseconds",
-            delta);
-      }
-    }
-  }
-  prev_ = time;
-  return ret;
-}
-
-bool ELDHistogram::Enable() {
-  if (enabled_ || IsHandleClosing()) return false;
-  enabled_ = true;
-  prev_ = 0;
-  uv_timer_start(&timer_,
-                 DelayIntervalCallback,
-                 resolution_,
-                 resolution_);
-  uv_unref(reinterpret_cast<uv_handle_t*>(&timer_));
-  return true;
-}
-
-bool ELDHistogram::Disable() {
-  if (!enabled_ || IsHandleClosing()) return false;
-  enabled_ = false;
-  uv_timer_stop(&timer_);
-  return true;
+                 "mean", histogram()->Mean());
+  TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
+                 "stddev", histogram()->Stddev());
 }
 
 void Initialize(Local<Object> target,
@@ -646,25 +533,8 @@ void Initialize(Local<Object> target,
                             constants,
                             attr).ToChecked();
 
-  Local<String> eldh_classname = FIXED_ONE_BYTE_STRING(isolate, "ELDHistogram");
-  Local<FunctionTemplate> eldh =
-      env->NewFunctionTemplate(ELDHistogramNew);
-  eldh->SetClassName(eldh_classname);
-  eldh->InstanceTemplate()->SetInternalFieldCount(
-      ELDHistogram::kInternalFieldCount);
-  eldh->Inherit(BaseObject::GetConstructorTemplate(env));
-  env->SetProtoMethod(eldh, "exceeds", ELDHistogramExceeds);
-  env->SetProtoMethod(eldh, "min", ELDHistogramMin);
-  env->SetProtoMethod(eldh, "max", ELDHistogramMax);
-  env->SetProtoMethod(eldh, "mean", ELDHistogramMean);
-  env->SetProtoMethod(eldh, "stddev", ELDHistogramStddev);
-  env->SetProtoMethod(eldh, "percentile", ELDHistogramPercentile);
-  env->SetProtoMethod(eldh, "percentiles", ELDHistogramPercentiles);
-  env->SetProtoMethod(eldh, "enable", ELDHistogramEnable);
-  env->SetProtoMethod(eldh, "disable", ELDHistogramDisable);
-  env->SetProtoMethod(eldh, "reset", ELDHistogramReset);
-  target->Set(context, eldh_classname,
-              eldh->GetFunction(env->context()).ToLocalChecked()).Check();
+  HistogramBase::Initialize(env, target);
+  ELDHistogram::Initialize(env, target);
 }
 
 }  // namespace performance
diff --git a/src/node_perf.h b/src/node_perf.h
index a8a913bddeaad0966414360ed59fd660a54b5eab..ddd99b330403815949247877e8f31de77bc4a85f 100644
--- a/src/node_perf.h
+++ b/src/node_perf.h
@@ -6,7 +6,7 @@
 #include "node.h"
 #include "node_perf_common.h"
 #include "base_object-inl.h"
-#include "histogram-inl.h"
+#include "histogram.h"
 
 #include "v8.h"
 #include "uv.h"
@@ -140,37 +140,20 @@ class GCPerformanceEntry : public PerformanceEntry {
   PerformanceGCFlags gcflags_;
 };
 
-class ELDHistogram : public HandleWrap, public Histogram {
+class ELDHistogram : public IntervalHistogram {
  public:
-  ELDHistogram(Environment* env,
-               v8::Local<v8::Object> wrap,
-               int32_t resolution);
-
-  bool RecordDelta();
-  bool Enable();
-  bool Disable();
-  void ResetState() {
-    Reset();
-    exceeds_ = 0;
-    prev_ = 0;
-  }
-  int64_t Exceeds() const { return exceeds_; }
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackFieldWithSize("histogram", GetMemorySize());
-  }
+  ELDHistogram(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      int32_t interval);
+
+  void OnInterval() override;
 
   SET_MEMORY_INFO_NAME(ELDHistogram)
   SET_SELF_SIZE(ELDHistogram)
-
- private:
-  static void DelayIntervalCallback(uv_timer_t* req);
-
-  bool enabled_ = false;
-  int32_t resolution_ = 0;
-  int64_t exceeds_ = 0;
-  uint64_t prev_ = 0;
-  uv_timer_t timer_;
 };
 
 }  // namespace performance
diff --git a/src/node_perf_common.h b/src/node_perf_common.h
index 75d266afc257e9eb06592c460b3929251972a64c..ba396740c27de55de819df3810a6fb8121af1dec 100644
--- a/src/node_perf_common.h
+++ b/src/node_perf_common.h
@@ -3,6 +3,7 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "aliased_buffer.h"
 #include "node.h"
 #include "uv.h"
 #include "v8.h"
diff --git a/src/node_platform.cc b/src/node_platform.cc
index 8703372818770b847c35455612100e6895546f53..7e68b7af891ffb87ce083081775015cc7b62fc42 100644
--- a/src/node_platform.cc
+++ b/src/node_platform.cc
@@ -228,6 +228,11 @@ PerIsolatePlatformData::PerIsolatePlatformData(
   uv_unref(reinterpret_cast<uv_handle_t*>(flush_tasks_));
 }
 
+std::shared_ptr<v8::TaskRunner>
+PerIsolatePlatformData::GetForegroundTaskRunner() {
+  return shared_from_this();
+}
+
 void PerIsolatePlatformData::FlushTasks(uv_async_t* handle) {
   auto platform_data = static_cast<PerIsolatePlatformData*>(handle->data);
   platform_data->FlushForegroundTasksInternal();
@@ -273,7 +278,7 @@ void PerIsolatePlatformData::PostNonNestableDelayedTask(
 }
 
 PerIsolatePlatformData::~PerIsolatePlatformData() {
-  Shutdown();
+  CHECK(!flush_tasks_);
 }
 
 void PerIsolatePlatformData::AddShutdownCallback(void (*callback)(void*),
@@ -340,18 +345,32 @@ NodePlatform::~NodePlatform() {
 
 void NodePlatform::RegisterIsolate(Isolate* isolate, uv_loop_t* loop) {
   Mutex::ScopedLock lock(per_isolate_mutex_);
-  std::shared_ptr<PerIsolatePlatformData> existing = per_isolate_[isolate];
-  CHECK(!existing);
-  per_isolate_[isolate] =
-      std::make_shared<PerIsolatePlatformData>(isolate, loop);
+  auto delegate = std::make_shared<PerIsolatePlatformData>(isolate, loop);
+  IsolatePlatformDelegate* ptr = delegate.get();
+  auto insertion = per_isolate_.emplace(
+    isolate,
+    std::make_pair(ptr, std::move(delegate)));
+  CHECK(insertion.second);
+}
+
+void NodePlatform::RegisterIsolate(Isolate* isolate,
+                                   IsolatePlatformDelegate* delegate) {
+  Mutex::ScopedLock lock(per_isolate_mutex_);
+  auto insertion = per_isolate_.emplace(
+    isolate,
+    std::make_pair(delegate, std::shared_ptr<PerIsolatePlatformData>{}));
+  CHECK(insertion.second);
 }
 
 void NodePlatform::UnregisterIsolate(Isolate* isolate) {
   Mutex::ScopedLock lock(per_isolate_mutex_);
-  std::shared_ptr<PerIsolatePlatformData> existing = per_isolate_[isolate];
-  CHECK(existing);
-  existing->Shutdown();
-  per_isolate_.erase(isolate);
+  auto existing_it = per_isolate_.find(isolate);
+  CHECK_NE(existing_it, per_isolate_.end());
+  auto& existing = existing_it->second;
+  if (existing.second) {
+    existing.second->Shutdown();
+  }
+  per_isolate_.erase(existing_it);
 }
 
 void NodePlatform::AddIsolateFinishedCallback(Isolate* isolate,
@@ -362,8 +381,8 @@ void NodePlatform::AddIsolateFinishedCallback(Isolate* isolate,
     cb(data);
     return;
   }
-  CHECK(it->second);
-  it->second->AddShutdownCallback(cb, data);
+  CHECK(it->second.second);
+  it->second.second->AddShutdownCallback(cb, data);
 }
 
 void NodePlatform::Shutdown() {
@@ -390,6 +409,9 @@ void PerIsolatePlatformData::RunForegroundTask(std::unique_ptr<Task> task) {
                                    InternalCallbackScope::kNoFlags);
     task->Run();
   } else {
+    // The task is moved out of InternalCallbackScope if env is not available.
+    // This is a required else block, and should not be removed.
+    // See comment: https://github.com/nodejs/node/pull/34688#pullrequestreview-463867489
     task->Run();
   }
 }
@@ -411,7 +433,7 @@ void PerIsolatePlatformData::RunForegroundTask(uv_timer_t* handle) {
 }
 
 void NodePlatform::DrainTasks(Isolate* isolate) {
-  std::shared_ptr<PerIsolatePlatformData> per_isolate = ForIsolate(isolate);
+  std::shared_ptr<PerIsolatePlatformData> per_isolate = ForNodeIsolate(isolate);
   if (!per_isolate) return;
 
   do {
@@ -470,25 +492,34 @@ void NodePlatform::CallDelayedOnWorkerThread(std::unique_ptr<Task> task,
 }
 
 
+IsolatePlatformDelegate* NodePlatform::ForIsolate(Isolate* isolate) {
+  Mutex::ScopedLock lock(per_isolate_mutex_);
+  auto data = per_isolate_[isolate];
+  CHECK_NOT_NULL(data.first);
+  return data.first;
+}
+
 std::shared_ptr<PerIsolatePlatformData>
-NodePlatform::ForIsolate(Isolate* isolate) {
+NodePlatform::ForNodeIsolate(Isolate* isolate) {
   Mutex::ScopedLock lock(per_isolate_mutex_);
-  std::shared_ptr<PerIsolatePlatformData> data = per_isolate_[isolate];
-  CHECK(data);
-  return data;
+  auto data = per_isolate_[isolate];
+  CHECK_NOT_NULL(data.first);
+  return data.second;
 }
 
 bool NodePlatform::FlushForegroundTasks(Isolate* isolate) {
-  std::shared_ptr<PerIsolatePlatformData> per_isolate = ForIsolate(isolate);
+  std::shared_ptr<PerIsolatePlatformData> per_isolate = ForNodeIsolate(isolate);
   if (!per_isolate) return false;
   return per_isolate->FlushForegroundTasksInternal();
 }
 
-bool NodePlatform::IdleTasksEnabled(Isolate* isolate) { return false; }
+bool NodePlatform::IdleTasksEnabled(Isolate* isolate) {
+  return ForIsolate(isolate)->IdleTasksEnabled();
+}
 
 std::shared_ptr<v8::TaskRunner>
 NodePlatform::GetForegroundTaskRunner(Isolate* isolate) {
-  return ForIsolate(isolate);
+  return ForIsolate(isolate)->GetForegroundTaskRunner();
 }
 
 double NodePlatform::MonotonicallyIncreasingTime() {
diff --git a/src/node_platform.h b/src/node_platform.h
index 3d70718344bf9e9dcf2b2932171c12a9b4f08a3f..dc512ddf08facf1ebb0d8c9e7677d349d0d2c87c 100644
--- a/src/node_platform.h
+++ b/src/node_platform.h
@@ -51,12 +51,14 @@ struct DelayedTask {
 
 // This acts as the foreground task runner for a given Isolate.
 class PerIsolatePlatformData :
+    public IsolatePlatformDelegate,
     public v8::TaskRunner,
     public std::enable_shared_from_this<PerIsolatePlatformData> {
  public:
   PerIsolatePlatformData(v8::Isolate* isolate, uv_loop_t* loop);
   ~PerIsolatePlatformData() override;
 
+  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner() override;
   void PostTask(std::unique_ptr<v8::Task> task) override;
   void PostIdleTask(std::unique_ptr<v8::IdleTask> task) override;
   void PostDelayedTask(std::unique_ptr<v8::Task> task,
@@ -147,14 +149,6 @@ class NodePlatform : public MultiIsolatePlatform {
   void CallOnWorkerThread(std::unique_ptr<v8::Task> task) override;
   void CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> task,
                                  double delay_in_seconds) override;
-  void CallOnForegroundThread(v8::Isolate* isolate, v8::Task* task) override {
-    UNREACHABLE();
-  }
-  void CallDelayedOnForegroundThread(v8::Isolate* isolate,
-                                     v8::Task* task,
-                                     double delay_in_seconds) override {
-    UNREACHABLE();
-  }
   bool IdleTasksEnabled(v8::Isolate* isolate) override;
   double MonotonicallyIncreasingTime() override;
   double CurrentClockTimeMillis() override;
@@ -162,6 +156,9 @@ class NodePlatform : public MultiIsolatePlatform {
   bool FlushForegroundTasks(v8::Isolate* isolate) override;
 
   void RegisterIsolate(v8::Isolate* isolate, uv_loop_t* loop) override;
+  void RegisterIsolate(v8::Isolate* isolate,
+                       IsolatePlatformDelegate* delegate) override;
+
   void UnregisterIsolate(v8::Isolate* isolate) override;
   void AddIsolateFinishedCallback(v8::Isolate* isolate,
                                   void (*callback)(void*), void* data) override;
@@ -172,11 +169,13 @@ class NodePlatform : public MultiIsolatePlatform {
   Platform::StackTracePrinter GetStackTracePrinter() override;
 
  private:
-  std::shared_ptr<PerIsolatePlatformData> ForIsolate(v8::Isolate* isolate);
+  IsolatePlatformDelegate* ForIsolate(v8::Isolate* isolate);
+  std::shared_ptr<PerIsolatePlatformData> ForNodeIsolate(v8::Isolate* isolate);
 
   Mutex per_isolate_mutex_;
-  std::unordered_map<v8::Isolate*,
-                     std::shared_ptr<PerIsolatePlatformData>> per_isolate_;
+  using DelegatePair = std::pair<
+    IsolatePlatformDelegate*, std::shared_ptr<PerIsolatePlatformData>>;
+  std::unordered_map<v8::Isolate*, DelegatePair> per_isolate_;
 
   v8::TracingController* tracing_controller_;
   std::shared_ptr<WorkerThreadsTaskRunner> worker_thread_task_runner_;
diff --git a/src/node_postmortem_metadata.cc b/src/node_postmortem_metadata.cc
index ccb347e95175c139220dce6696dd6b4cc48b7af7..2dc534f59bf80a6b9bcc79a6927c4508395a719f 100644
--- a/src/node_postmortem_metadata.cc
+++ b/src/node_postmortem_metadata.cc
@@ -36,6 +36,7 @@
 
 extern "C" {
 int nodedbg_const_ContextEmbedderIndex__kEnvironment__int;
+int nodedbg_const_BaseObject__kInternalFieldCount__int;
 uintptr_t nodedbg_offset_ExternalString__data__uintptr_t;
 uintptr_t nodedbg_offset_ReqWrap__req_wrap_queue___ListNode_ReqWrapQueue;
 
@@ -50,6 +51,8 @@ namespace node {
 int GenDebugSymbols() {
   nodedbg_const_ContextEmbedderIndex__kEnvironment__int =
       ContextEmbedderIndex::kEnvironment;
+  nodedbg_const_BaseObject__kInternalFieldCount__int =
+      BaseObject::kInternalFieldCount;
 
   nodedbg_offset_ExternalString__data__uintptr_t = NODE_OFF_EXTSTR_DATA;
   nodedbg_offset_ReqWrap__req_wrap_queue___ListNode_ReqWrapQueue =
diff --git a/src/node_process-inl.h b/src/node_process-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..21a448cfdb2a75837ce86976238e75dab5c3b6c5
--- /dev/null
+++ b/src/node_process-inl.h
@@ -0,0 +1,26 @@
+#ifndef SRC_NODE_PROCESS_INL_H_
+#define SRC_NODE_PROCESS_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_process.h"
+#include "v8.h"
+#include "debug_utils-inl.h"
+
+namespace node {
+
+// Call process.emitWarning(str), fmt is a snprintf() format string
+template <typename... Args>
+inline v8::Maybe<bool> ProcessEmitWarning(Environment* env,
+                                          const char* fmt,
+                                          Args&&... args) {
+  std::string warning = SPrintF(fmt, std::forward<Args>(args)...);
+
+  return ProcessEmitWarningGeneric(env, warning.c_str());
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PROCESS_INL_H_
diff --git a/src/node_process.h b/src/node_process.h
index ad86b449f95290c36103c65212ba3d072a495baf..14c8f659168975f0592da75c754840f583444493 100644
--- a/src/node_process.h
+++ b/src/node_process.h
@@ -8,8 +8,7 @@
 namespace node {
 
 v8::MaybeLocal<v8::Object> CreateEnvVarProxy(v8::Local<v8::Context> context,
-                                             v8::Isolate* isolate,
-                                             v8::Local<v8::Object> data);
+                                             v8::Isolate* isolate);
 
 // Most of the time, it's best to use `console.error` to write
 // to the process.stderr stream.  However, in some cases, such as
@@ -26,7 +25,10 @@ v8::Maybe<bool> ProcessEmitWarningGeneric(Environment* env,
                                           const char* type = nullptr,
                                           const char* code = nullptr);
 
-v8::Maybe<bool> ProcessEmitWarning(Environment* env, const char* fmt, ...);
+template <typename... Args>
+inline v8::Maybe<bool> ProcessEmitWarning(Environment* env,
+                                          const char* fmt,
+                                          Args&&... args);
 v8::Maybe<bool> ProcessEmitExperimentalWarning(Environment* env,
                                               const char* warning);
 v8::Maybe<bool> ProcessEmitDeprecationWarning(Environment* env,
diff --git a/src/node_process_events.cc b/src/node_process_events.cc
index ae387de447753e8ac1d7abba1787e81996c167c9..34f0251cabc02b8fa09f4d86a08d86c8d98a2f54 100644
--- a/src/node_process_events.cc
+++ b/src/node_process_events.cc
@@ -1,8 +1,7 @@
-#include <cstdarg>
 #include <set>
 
 #include "env-inl.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "util.h"
 
 namespace node {
@@ -14,7 +13,6 @@ using v8::Just;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
-using v8::NewStringType;
 using v8::Nothing;
 using v8::Object;
 using v8::String;
@@ -27,9 +25,7 @@ MaybeLocal<Value> ProcessEmit(Environment* env,
   Isolate* isolate = env->isolate();
 
   Local<String> event_string;
-  if (!String::NewFromOneByte(isolate,
-                              reinterpret_cast<const uint8_t*>(event),
-                              NewStringType::kNormal)
+  if (!String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(event))
       .ToLocal(&event_string)) return MaybeLocal<Value>();
 
   Local<Object> process = env->process_object();
@@ -60,21 +56,18 @@ Maybe<bool> ProcessEmitWarningGeneric(Environment* env,
 
   // The caller has to be able to handle a failure anyway, so we might as well
   // do proper error checking for string creation.
-  if (!String::NewFromUtf8(env->isolate(), warning, NewStringType::kNormal)
-           .ToLocal(&args[argc++])) {
+  if (!String::NewFromUtf8(env->isolate(), warning).ToLocal(&args[argc++]))
     return Nothing<bool>();
-  }
+
   if (type != nullptr) {
     if (!String::NewFromOneByte(env->isolate(),
-                                reinterpret_cast<const uint8_t*>(type),
-                                NewStringType::kNormal)
+                                reinterpret_cast<const uint8_t*>(type))
              .ToLocal(&args[argc++])) {
       return Nothing<bool>();
     }
     if (code != nullptr &&
         !String::NewFromOneByte(env->isolate(),
-                                reinterpret_cast<const uint8_t*>(code),
-                                NewStringType::kNormal)
+                                reinterpret_cast<const uint8_t*>(code))
              .ToLocal(&args[argc++])) {
       return Nothing<bool>();
     }
@@ -90,18 +83,6 @@ Maybe<bool> ProcessEmitWarningGeneric(Environment* env,
   return Just(true);
 }
 
-// Call process.emitWarning(str), fmt is a snprintf() format string
-Maybe<bool> ProcessEmitWarning(Environment* env, const char* fmt, ...) {
-  char warning[1024];
-  va_list ap;
-
-  va_start(ap, fmt);
-  vsnprintf(warning, sizeof(warning), fmt, ap);
-  va_end(ap);
-
-  return ProcessEmitWarningGeneric(env, warning);
-}
-
 
 std::set<std::string> experimental_warnings;
 
diff --git a/src/node_process_methods.cc b/src/node_process_methods.cc
index b506050e50755913c225c6963d8ed4ce3a738a45..69e910a85988817c46753ab3f3df0ff5beca6d79 100644
--- a/src/node_process_methods.cc
+++ b/src/node_process_methods.cc
@@ -4,7 +4,7 @@
 #include "node.h"
 #include "node_errors.h"
 #include "node_internals.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "util-inl.h"
 #include "uv.h"
 #include "v8.h"
@@ -62,6 +62,13 @@ static void Abort(const FunctionCallbackInfo<Value>& args) {
   Abort();
 }
 
+// For internal testing only, not exposed to userland.
+static void CauseSegfault(const FunctionCallbackInfo<Value>& args) {
+  // This should crash hard all platforms.
+  volatile void** d = static_cast<volatile void**>(nullptr);
+  *d = nullptr;
+}
+
 static void Chdir(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK(env->owns_process_state());
@@ -80,6 +87,16 @@ static void Chdir(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+inline Local<ArrayBuffer> get_fields_array_buffer(
+    const FunctionCallbackInfo<Value>& args,
+    size_t index,
+    size_t array_length) {
+  CHECK(args[index]->IsFloat64Array());
+  Local<Float64Array> arr = args[index].As<Float64Array>();
+  CHECK_EQ(arr->Length(), array_length);
+  return arr->Buffer();
+}
+
 // CPUUsage use libuv's uv_getrusage() this-process resource usage accessor,
 // to access ru_utime (user CPU time used) and ru_stime (system CPU time used),
 // which are uv_timeval_t structs (long tv_sec, long tv_usec).
@@ -97,11 +114,8 @@ static void CPUUsage(const FunctionCallbackInfo<Value>& args) {
   }
 
   // Get the double array pointer from the Float64Array argument.
-  CHECK(args[0]->IsFloat64Array());
-  Local<Float64Array> array = args[0].As<Float64Array>();
-  CHECK_EQ(array->Length(), 2);
-  Local<ArrayBuffer> ab = array->Buffer();
-  double* fields = static_cast<double*>(ab->GetContents().Data());
+  Local<ArrayBuffer> ab = get_fields_array_buffer(args, 0, 2);
+  double* fields = static_cast<double*>(ab->GetBackingStore()->Data());
 
   // Set the Float64Array elements to be user / system values in microseconds.
   fields[0] = MICROS_PER_SEC * rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec;
@@ -140,7 +154,7 @@ static void Hrtime(const FunctionCallbackInfo<Value>& args) {
   uint64_t t = uv_hrtime();
 
   Local<ArrayBuffer> ab = args[0].As<Uint32Array>()->Buffer();
-  uint32_t* fields = static_cast<uint32_t*>(ab->GetContents().Data());
+  uint32_t* fields = static_cast<uint32_t*>(ab->GetBackingStore()->Data());
 
   fields[0] = (t / NANOS_PER_SEC) >> 32;
   fields[1] = (t / NANOS_PER_SEC) & 0xffffffff;
@@ -149,7 +163,7 @@ static void Hrtime(const FunctionCallbackInfo<Value>& args) {
 
 static void HrtimeBigInt(const FunctionCallbackInfo<Value>& args) {
   Local<ArrayBuffer> ab = args[0].As<BigUint64Array>()->Buffer();
-  uint64_t* fields = static_cast<uint64_t*>(ab->GetContents().Data());
+  uint64_t* fields = static_cast<uint64_t*>(ab->GetBackingStore()->Data());
   fields[0] = uv_hrtime();
 }
 
@@ -179,7 +193,7 @@ static void Kill(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(err);
 }
 
-static void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
+static void Rss(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
   size_t rss;
@@ -187,6 +201,12 @@ static void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
   if (err)
     return env->ThrowUVException(err, "uv_resident_set_memory");
 
+  args.GetReturnValue().Set(static_cast<double>(rss));
+}
+
+static void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
   Isolate* isolate = env->isolate();
   // V8 memory usage
   HeapStatistics v8_heap_stats;
@@ -196,11 +216,13 @@ static void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
       env->isolate_data()->node_allocator();
 
   // Get the double array pointer from the Float64Array argument.
-  CHECK(args[0]->IsFloat64Array());
-  Local<Float64Array> array = args[0].As<Float64Array>();
-  CHECK_EQ(array->Length(), 5);
-  Local<ArrayBuffer> ab = array->Buffer();
-  double* fields = static_cast<double*>(ab->GetContents().Data());
+  Local<ArrayBuffer> ab = get_fields_array_buffer(args, 0, 5);
+  double* fields = static_cast<double*>(ab->GetBackingStore()->Data());
+
+  size_t rss;
+  int err = uv_resident_set_memory(&rss);
+  if (err)
+    return env->ThrowUVException(err, "uv_resident_set_memory");
 
   fields[0] = rss;
   fields[1] = v8_heap_stats.total_heap_size();
@@ -218,16 +240,6 @@ void RawDebug(const FunctionCallbackInfo<Value>& args) {
   fflush(stderr);
 }
 
-static void StartProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  env->StartProfilerIdleNotifier();
-}
-
-static void StopProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  env->StopProfilerIdleNotifier();
-}
-
 static void Umask(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK(env->has_run_bootstrapping_code());
@@ -295,11 +307,8 @@ static void ResourceUsage(const FunctionCallbackInfo<Value>& args) {
   if (err)
     return env->ThrowUVException(err, "uv_getrusage");
 
-  CHECK(args[0]->IsFloat64Array());
-  Local<Float64Array> array = args[0].As<Float64Array>();
-  CHECK_EQ(array->Length(), 16);
-  Local<ArrayBuffer> ab = array->Buffer();
-  double* fields = static_cast<double*>(ab->GetContents().Data());
+  Local<ArrayBuffer> ab = get_fields_array_buffer(args, 0, 16);
+  double* fields = static_cast<double*>(ab->GetBackingStore()->Data());
 
   fields[0] = MICROS_PER_SEC * rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec;
   fields[1] = MICROS_PER_SEC * rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec;
@@ -445,16 +454,14 @@ static void InitializeProcessMethods(Local<Object> target,
     env->SetMethod(target, "_debugProcess", DebugProcess);
     env->SetMethod(target, "_debugEnd", DebugEnd);
     env->SetMethod(target, "abort", Abort);
+    env->SetMethod(target, "causeSegfault", CauseSegfault);
     env->SetMethod(target, "chdir", Chdir);
   }
 
-  env->SetMethod(
-      target, "_startProfilerIdleNotifier", StartProfilerIdleNotifier);
-  env->SetMethod(target, "_stopProfilerIdleNotifier", StopProfilerIdleNotifier);
-
   env->SetMethod(target, "umask", Umask);
   env->SetMethod(target, "_rawDebug", RawDebug);
   env->SetMethod(target, "memoryUsage", MemoryUsage);
+  env->SetMethod(target, "rss", Rss);
   env->SetMethod(target, "cpuUsage", CPUUsage);
   env->SetMethod(target, "hrtime", Hrtime);
   env->SetMethod(target, "hrtimeBigInt", HrtimeBigInt);
diff --git a/src/node_process_object.cc b/src/node_process_object.cc
index 941840389161d37bc0d309c61dcd9d96e0d6fbd4..a11241cd3a7247893ad3f74698d179ce4732d79c 100644
--- a/src/node_process_object.cc
+++ b/src/node_process_object.cc
@@ -2,7 +2,7 @@
 #include "node_internals.h"
 #include "node_options-inl.h"
 #include "node_metadata.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "node_revert.h"
 #include "util-inl.h"
 
@@ -145,7 +145,7 @@ void PatchProcessObject(const FunctionCallbackInfo<Value>& args) {
                 FIXED_ONE_BYTE_STRING(isolate, "title"),
                 ProcessTitleGetter,
                 env->owns_process_state() ? ProcessTitleSetter : nullptr,
-                env->as_callback_data(),
+                Local<Value>(),
                 DEFAULT,
                 None,
                 SideEffectType::kHasNoSideEffect)
@@ -196,7 +196,7 @@ void PatchProcessObject(const FunctionCallbackInfo<Value>& args) {
                           FIXED_ONE_BYTE_STRING(isolate, "debugPort"),
                           DebugPortGetter,
                           env->owns_process_state() ? DebugPortSetter : nullptr,
-                          env->as_callback_data())
+                          Local<Value>())
             .FromJust());
 }
 
diff --git a/src/node_report.cc b/src/node_report.cc
index c93e03afe639183f95079759abf025deed26da73..a91d16d5f11e64d7a10aafa3e4b9fc7d1827e49a 100644
--- a/src/node_report.cc
+++ b/src/node_report.cc
@@ -12,8 +12,8 @@
 #ifdef _WIN32
 #include <Windows.h>
 #else  // !_WIN32
-#include <sys/resource.h>
 #include <cxxabi.h>
+#include <sys/resource.h>
 #include <dlfcn.h>
 #endif
 
@@ -43,13 +43,11 @@ using v8::HeapSpaceStatistics;
 using v8::HeapStatistics;
 using v8::Isolate;
 using v8::Local;
-using v8::Number;
 using v8::Object;
-using v8::StackTrace;
 using v8::String;
 using v8::TryCatch;
-using v8::Value;
 using v8::V8;
+using v8::Value;
 
 namespace per_process = node::per_process;
 
@@ -269,20 +267,22 @@ static void WriteNodeReport(Isolate* isolate,
   PrintVersionInformation(&writer);
   writer.json_objectend();
 
-  writer.json_objectstart("javascriptStack");
-  // Report summary JavaScript error stack backtrace
-  PrintJavaScriptErrorStack(&writer, isolate, error, trigger);
+  if (isolate != nullptr) {
+    writer.json_objectstart("javascriptStack");
+    // Report summary JavaScript error stack backtrace
+    PrintJavaScriptErrorStack(&writer, isolate, error, trigger);
 
-  // Report summary JavaScript error properties backtrace
-  PrintJavaScriptErrorProperties(&writer, isolate, error);
-  writer.json_objectend();  // the end of 'javascriptStack'
+    // Report summary JavaScript error properties backtrace
+    PrintJavaScriptErrorProperties(&writer, isolate, error);
+    writer.json_objectend();  // the end of 'javascriptStack'
+
+    // Report V8 Heap and Garbage Collector information
+    PrintGCStatistics(&writer, isolate);
+  }
 
   // Report native stack backtrace
   PrintNativeStack(&writer);
 
-  // Report V8 Heap and Garbage Collector information
-  PrintGCStatistics(&writer, isolate);
-
   // Report OS and current thread resource usage
   PrintResourceUsage(&writer);
 
@@ -296,6 +296,10 @@ static void WriteNodeReport(Isolate* isolate,
         static_cast<bool>(uv_loop_alive(env->event_loop())));
     writer.json_keyvalue("address",
         ValueToHexString(reinterpret_cast<int64_t>(env->event_loop())));
+
+    // Report Event loop idle time
+    uint64_t idle_time = uv_metrics_idle_time(env->event_loop());
+    writer.json_keyvalue("loopIdleTimeSeconds", 1.0 * idle_time / 1e9);
     writer.json_end();
   }
 
diff --git a/src/node_report_module.cc b/src/node_report_module.cc
index d9dad28221a5cfdd1e23191776a5008d2b6d3201..97c6bea3ad5ec57d06e75f73a1fb56088f87c7bf 100644
--- a/src/node_report_module.cc
+++ b/src/node_report_module.cc
@@ -49,8 +49,7 @@ void WriteReport(const FunctionCallbackInfo<Value>& info) {
       isolate, env, *message, *trigger, filename, error);
   // Return value is the report filename
   info.GetReturnValue().Set(
-      String::NewFromUtf8(isolate, filename.c_str(), v8::NewStringType::kNormal)
-          .ToLocalChecked());
+      String::NewFromUtf8(isolate, filename.c_str()).ToLocalChecked());
 }
 
 // External JavaScript API for returning a report
@@ -71,10 +70,8 @@ void GetReport(const FunctionCallbackInfo<Value>& info) {
       isolate, env, "JavaScript API", __func__, error, out);
 
   // Return value is the contents of a report as a string.
-  info.GetReturnValue().Set(String::NewFromUtf8(isolate,
-                                                out.str().c_str(),
-                                                v8::NewStringType::kNormal)
-                                .ToLocalChecked());
+  info.GetReturnValue().Set(
+      String::NewFromUtf8(isolate, out.str().c_str()).ToLocalChecked());
 }
 
 static void GetCompact(const FunctionCallbackInfo<Value>& info) {
@@ -94,9 +91,7 @@ static void GetDirectory(const FunctionCallbackInfo<Value>& info) {
   node::Mutex::ScopedLock lock(node::per_process::cli_options_mutex);
   Environment* env = Environment::GetCurrent(info);
   std::string directory = node::per_process::cli_options->report_directory;
-  auto result = String::NewFromUtf8(env->isolate(),
-                                    directory.c_str(),
-                                    v8::NewStringType::kNormal);
+  auto result = String::NewFromUtf8(env->isolate(), directory.c_str());
   info.GetReturnValue().Set(result.ToLocalChecked());
 }
 
@@ -112,9 +107,7 @@ static void GetFilename(const FunctionCallbackInfo<Value>& info) {
   node::Mutex::ScopedLock lock(node::per_process::cli_options_mutex);
   Environment* env = Environment::GetCurrent(info);
   std::string filename = node::per_process::cli_options->report_filename;
-  auto result = String::NewFromUtf8(env->isolate(),
-                                    filename.c_str(),
-                                    v8::NewStringType::kNormal);
+  auto result = String::NewFromUtf8(env->isolate(), filename.c_str());
   info.GetReturnValue().Set(result.ToLocalChecked());
 }
 
@@ -129,9 +122,7 @@ static void SetFilename(const FunctionCallbackInfo<Value>& info) {
 static void GetSignal(const FunctionCallbackInfo<Value>& info) {
   Environment* env = Environment::GetCurrent(info);
   std::string signal = env->isolate_data()->options()->report_signal;
-  auto result = String::NewFromUtf8(env->isolate(),
-                                    signal.c_str(),
-                                    v8::NewStringType::kNormal);
+  auto result = String::NewFromUtf8(env->isolate(), signal.c_str());
   info.GetReturnValue().Set(result.ToLocalChecked());
 }
 
diff --git a/src/node_report_utils.cc b/src/node_report_utils.cc
index abbf6d529d0ef73df95444e134c8ec7eaff30db7..82ed385ad176bdb5f859af324e0bff2e6a40c16c 100644
--- a/src/node_report_utils.cc
+++ b/src/node_report_utils.cc
@@ -82,6 +82,42 @@ static void ReportEndpoints(uv_handle_t* h, JSONWriter* writer) {
   ReportEndpoint(h, rc == 0 ? addr : nullptr, "remoteEndpoint", writer);
 }
 
+// Utility function to format libuv pipe information.
+static void ReportPipeEndpoints(uv_handle_t* h, JSONWriter* writer) {
+  uv_any_handle* handle = reinterpret_cast<uv_any_handle*>(h);
+  MallocedBuffer<char> buffer(0);
+  size_t buffer_size = 0;
+  int rc = -1;
+
+  // First call to get required buffer size.
+  rc = uv_pipe_getsockname(&handle->pipe, buffer.data, &buffer_size);
+  if (rc == UV_ENOBUFS) {
+    buffer = MallocedBuffer<char>(buffer_size);
+    if (buffer.data != nullptr) {
+      rc = uv_pipe_getsockname(&handle->pipe, buffer.data, &buffer_size);
+    }
+  }
+  if (rc == 0 && buffer_size != 0 && buffer.data != nullptr) {
+    writer->json_keyvalue("localEndpoint", buffer.data);
+  } else {
+    writer->json_keyvalue("localEndpoint", null);
+  }
+
+  // First call to get required buffer size.
+  rc = uv_pipe_getpeername(&handle->pipe, buffer.data, &buffer_size);
+  if (rc == UV_ENOBUFS) {
+    buffer = MallocedBuffer<char>(buffer_size);
+    if (buffer.data != nullptr) {
+      rc = uv_pipe_getpeername(&handle->pipe, buffer.data, &buffer_size);
+    }
+  }
+  if (rc == 0 && buffer_size != 0 && buffer.data != nullptr) {
+    writer->json_keyvalue("remoteEndpoint", buffer.data);
+  } else {
+    writer->json_keyvalue("remoteEndpoint", null);
+  }
+}
+
 // Utility function to format libuv path information.
 static void ReportPath(uv_handle_t* h, JSONWriter* writer) {
   MallocedBuffer<char> buffer(0);
@@ -147,6 +183,9 @@ void WalkHandle(uv_handle_t* h, void* arg) {
     case UV_UDP:
       ReportEndpoints(h, writer);
       break;
+    case UV_NAMED_PIPE:
+      ReportPipeEndpoints(h, writer);
+      break;
     case UV_TIMER: {
       uint64_t due = handle->timer.timeout;
       uint64_t now = uv_now(handle->timer.loop);
diff --git a/src/node_revert.h b/src/node_revert.h
index 66161c9c9b204815a3312e1ca9fe52f17ff32777..83dcb62c37a34228ef2c75119f475433228a25f2 100644
--- a/src/node_revert.h
+++ b/src/node_revert.h
@@ -16,13 +16,9 @@
 namespace node {
 
 #define SECURITY_REVERSIONS(XX)                                            \
-  XX(CVE_2019_9512, "CVE-2019-9512", "HTTP/2 Ping/Settings Flood")         \
-  XX(CVE_2019_9514, "CVE-2019-9514", "HTTP/2 Reset Flood")                 \
-  XX(CVE_2019_9516, "CVE-2019-9516", "HTTP/2 0-Length Headers Leak")       \
-  XX(CVE_2019_9518, "CVE-2019-9518", "HTTP/2 Empty DATA Frame Flooding")   \
+  XX(CVE_2021_44531, "CVE-2021-44531", "Cert Verif Bypass via URI SAN")    \
+  XX(CVE_2021_44532, "CVE-2021-44532", "Cert Verif Bypass via Str Inject") \
 //  XX(CVE_2016_PEND, "CVE-2016-PEND", "Vulnerability Title")
-  // TODO(addaleax): Remove all of the above before Node.js 13 as the comment
-  // at the start of the file indicates.
 
 enum reversion {
 #define V(code, ...) SECURITY_REVERT_##code,
@@ -34,6 +30,12 @@ namespace per_process {
 extern unsigned int reverted_cve;
 }
 
+#ifdef _MSC_VER
+#pragma warning(push)
+// MSVC C4065: switch statement contains 'default' but no 'case' labels
+#pragma warning(disable : 4065)
+#endif
+
 inline const char* RevertMessage(const reversion cve) {
 #define V(code, label, msg) case SECURITY_REVERT_##code: return label ": " msg;
   switch (cve) {
@@ -44,6 +46,10 @@ inline const char* RevertMessage(const reversion cve) {
 #undef V
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 inline void Revert(const reversion cve) {
   per_process::reverted_cve |= 1 << cve;
   printf("SECURITY WARNING: Reverting %s\n", RevertMessage(cve));
diff --git a/src/node_serdes.cc b/src/node_serdes.cc
index 0efb09066ae6dae2425e4aa5596340a8f6256386..835179d511417a1662d85e48add706fea0f0c7f3 100644
--- a/src/node_serdes.cc
+++ b/src/node_serdes.cc
@@ -169,6 +169,10 @@ Maybe<bool> SerializerContext::WriteHostObject(Isolate* isolate,
 
 void SerializerContext::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
+  if (!args.IsConstructCall()) {
+    return THROW_ERR_CONSTRUCT_CALL_REQUIRED(
+        env, "Class constructor Serializer cannot be invoked without 'new'");
+  }
 
   new SerializerContext(env, args.This());
 }
@@ -206,8 +210,7 @@ void SerializerContext::ReleaseBuffer(const FunctionCallbackInfo<Value>& args) {
   std::pair<uint8_t*, size_t> ret = ctx->serializer_.Release();
   auto buf = Buffer::New(ctx->env(),
                          reinterpret_cast<char*>(ret.first),
-                         ret.second,
-                         true /* uses_malloc */);
+                         ret.second);
 
   if (!buf.IsEmpty()) {
     args.GetReturnValue().Set(buf.ToLocalChecked());
@@ -286,7 +289,6 @@ DeserializerContext::DeserializerContext(Environment* env,
     length_(Buffer::Length(buffer)),
     deserializer_(env->isolate(), data_, length_, this) {
   object()->Set(env->context(), env->buffer_string(), buffer).Check();
-  deserializer_.SetExpectInlineWasm(true);
 
   MakeWeak();
 }
@@ -321,6 +323,10 @@ MaybeLocal<Object> DeserializerContext::ReadHostObject(Isolate* isolate) {
 
 void DeserializerContext::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
+  if (!args.IsConstructCall()) {
+    return THROW_ERR_CONSTRUCT_CALL_REQUIRED(
+        env, "Class constructor Deserializer cannot be invoked without 'new'");
+  }
 
   if (!args[0]->IsArrayBufferView()) {
     return node::THROW_ERR_INVALID_ARG_TYPE(
@@ -437,7 +443,7 @@ void DeserializerContext::ReadRawBytes(
   CHECK_GE(position, ctx->data_);
   CHECK_LE(position + length, ctx->data_ + ctx->length_);
 
-  const uint32_t offset = position - ctx->data_;
+  const uint32_t offset = static_cast<uint32_t>(position - ctx->data_);
   CHECK_EQ(ctx->data_ + offset, position);
 
   args.GetReturnValue().Set(offset);
@@ -469,12 +475,8 @@ void Initialize(Local<Object> target,
                       "_setTreatArrayBufferViewsAsHostObjects",
                       SerializerContext::SetTreatArrayBufferViewsAsHostObjects);
 
-  Local<String> serializerString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "Serializer");
-  ser->SetClassName(serializerString);
-  target->Set(env->context(),
-              serializerString,
-              ser->GetFunction(env->context()).ToLocalChecked()).Check();
+  ser->ReadOnlyPrototype();
+  env->SetConstructorFunction(target, "Serializer", ser);
 
   Local<FunctionTemplate> des =
       env->NewFunctionTemplate(DeserializerContext::New);
@@ -496,12 +498,9 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(des, "readDouble", DeserializerContext::ReadDouble);
   env->SetProtoMethod(des, "_readRawBytes", DeserializerContext::ReadRawBytes);
 
-  Local<String> deserializerString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "Deserializer");
-  des->SetClassName(deserializerString);
-  target->Set(env->context(),
-              deserializerString,
-              des->GetFunction(env->context()).ToLocalChecked()).Check();
+  des->SetLength(1);
+  des->ReadOnlyPrototype();
+  env->SetConstructorFunction(target, "Deserializer", des);
 }
 
 }  // anonymous namespace
diff --git a/src/node_sockaddr-inl.h b/src/node_sockaddr-inl.h
index a9d0ed061a126c4926332bba0246d5c0261949f6..e5d8985771ebf2f48d0b5371428a58ff6256e916 100644
--- a/src/node_sockaddr-inl.h
+++ b/src/node_sockaddr-inl.h
@@ -4,9 +4,11 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "node.h"
+#include "env-inl.h"
 #include "node_internals.h"
 #include "node_sockaddr.h"
 #include "util-inl.h"
+#include "memory_tracker-inl.h"
 
 #include <string>
 
@@ -87,11 +89,11 @@ SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
 }
 
 const sockaddr& SocketAddress::operator*() const {
-  return *this->data();
+  return *data();
 }
 
 const sockaddr* SocketAddress::operator->() const {
-  return this->data();
+  return data();
 }
 
 size_t SocketAddress::length() const {
@@ -164,6 +166,95 @@ bool SocketAddress::operator==(const SocketAddress& other) const {
 bool SocketAddress::operator!=(const SocketAddress& other) const {
   return !(*this == other);
 }
+
+bool SocketAddress::operator<(const SocketAddress& other) const {
+  return compare(other) == CompareResult::LESS_THAN;
+}
+
+bool SocketAddress::operator>(const SocketAddress& other) const {
+  return compare(other) == CompareResult::GREATER_THAN;
+}
+
+bool SocketAddress::operator<=(const SocketAddress& other) const {
+  CompareResult c = compare(other);
+  return c == CompareResult::NOT_COMPARABLE ? false :
+              c <= CompareResult::SAME;
+}
+
+bool SocketAddress::operator>=(const SocketAddress& other) const {
+  return compare(other) >= CompareResult::SAME;
+}
+
+template <typename T>
+SocketAddressLRU<T>::SocketAddressLRU(
+    size_t max_size)
+    : max_size_(max_size) {}
+
+template <typename T>
+typename T::Type* SocketAddressLRU<T>::Peek(
+    const SocketAddress& address) const {
+  auto it = map_.find(address);
+  return it == std::end(map_) ? nullptr : &it->second->second;
+}
+
+template <typename T>
+void SocketAddressLRU<T>::CheckExpired() {
+  auto it = list_.rbegin();
+  while (it != list_.rend()) {
+    if (T::CheckExpired(it->first, it->second)) {
+      map_.erase(it->first);
+      list_.pop_back();
+      it = list_.rbegin();
+      continue;
+    } else {
+      break;
+    }
+  }
+}
+
+template <typename T>
+void SocketAddressLRU<T>::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("list", size() * sizeof(Pair));
+}
+
+// If an item already exists for the given address, bump up it's
+// position in the LRU list and return it. If the item does not
+// exist, create it. If an item is created, check the size of the
+// cache and adjust if necessary. Whether the item exists or not,
+// purge expired items.
+template <typename T>
+typename T::Type* SocketAddressLRU<T>::Upsert(
+    const SocketAddress& address) {
+
+  auto on_exit = OnScopeLeave([&]() { CheckExpired(); });
+
+  auto it = map_.find(address);
+  if (it != std::end(map_)) {
+    list_.splice(list_.begin(), list_, it->second);
+    T::Touch(it->first, &it->second->second);
+    return &it->second->second;
+  }
+
+  list_.push_front(Pair(address, { }));
+  map_[address] = list_.begin();
+  T::Touch(list_.begin()->first, &list_.begin()->second);
+
+  // Drop the last item in the list if we are
+  // over the size limit...
+  if (map_.size() > max_size_) {
+    auto last = list_.end();
+    map_.erase((--last)->first);
+    list_.pop_back();
+  }
+
+  return &map_[address]->second;
+}
+
+v8::MaybeLocal<v8::Value> SocketAddressBlockList::Rule::ToV8String(
+    Environment* env) {
+  std::string str = ToString();
+  return ToV8Value(env->context(), str);
+}
 }  // namespace node
 
 #endif  // NODE_WANT_INTERNALS
diff --git a/src/node_sockaddr.cc b/src/node_sockaddr.cc
index 74fe123529abbd7a95fc7898c21db3364d1105c4..ff160064a729e92707620f84fa42d24e49520ee9 100644
--- a/src/node_sockaddr.cc
+++ b/src/node_sockaddr.cc
@@ -1,8 +1,27 @@
 #include "node_sockaddr-inl.h"  // NOLINT(build/include)
+#include "env-inl.h"
+#include "base_object-inl.h"
+#include "memory_tracker-inl.h"
+#include "node_errors.h"
 #include "uv.h"
 
+#include <memory>
+#include <string>
+#include <vector>
+
 namespace node {
 
+using v8::Array;
+using v8::Context;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::Int32;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Object;
+using v8::Uint32;
+using v8::Value;
+
 namespace {
 template <typename T, typename F>
 SocketAddress FromUVHandle(F fn, const T& handle) {
@@ -92,4 +111,775 @@ SocketAddress SocketAddress::FromPeerName(const uv_udp_t& handle) {
   return FromUVHandle(uv_udp_getpeername, handle);
 }
 
+namespace {
+constexpr uint8_t mask[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };
+
+bool is_match_ipv4(
+    const SocketAddress& one,
+    const SocketAddress& two) {
+  const sockaddr_in* one_in =
+      reinterpret_cast<const sockaddr_in*>(one.data());
+  const sockaddr_in* two_in =
+      reinterpret_cast<const sockaddr_in*>(two.data());
+  return memcmp(&one_in->sin_addr, &two_in->sin_addr, sizeof(uint32_t)) == 0;
+}
+
+bool is_match_ipv6(
+    const SocketAddress& one,
+    const SocketAddress& two) {
+  const sockaddr_in6* one_in =
+      reinterpret_cast<const sockaddr_in6*>(one.data());
+  const sockaddr_in6* two_in =
+      reinterpret_cast<const sockaddr_in6*>(two.data());
+  return memcmp(&one_in->sin6_addr, &two_in->sin6_addr, 16) == 0;
+}
+
+bool is_match_ipv4_ipv6(
+    const SocketAddress& ipv4,
+    const SocketAddress& ipv6) {
+  const sockaddr_in* check_ipv4 =
+      reinterpret_cast<const sockaddr_in*>(ipv4.data());
+  const sockaddr_in6* check_ipv6 =
+      reinterpret_cast<const sockaddr_in6*>(ipv6.data());
+
+  const uint8_t* ptr =
+      reinterpret_cast<const uint8_t*>(&check_ipv6->sin6_addr);
+
+  return memcmp(ptr, mask, sizeof(mask)) == 0 &&
+         memcmp(ptr + sizeof(mask),
+                &check_ipv4->sin_addr,
+                sizeof(uint32_t)) == 0;
+}
+
+SocketAddress::CompareResult compare_ipv4(
+    const SocketAddress& one,
+    const SocketAddress& two) {
+  const sockaddr_in* one_in =
+      reinterpret_cast<const sockaddr_in*>(one.data());
+  const sockaddr_in* two_in =
+      reinterpret_cast<const sockaddr_in*>(two.data());
+  const uint32_t s_addr_one = ntohl(one_in->sin_addr.s_addr);
+  const uint32_t s_addr_two = ntohl(two_in->sin_addr.s_addr);
+
+  if (s_addr_one < s_addr_two)
+    return SocketAddress::CompareResult::LESS_THAN;
+  else if (s_addr_one == s_addr_two)
+    return SocketAddress::CompareResult::SAME;
+  else
+    return SocketAddress::CompareResult::GREATER_THAN;
+}
+
+SocketAddress::CompareResult compare_ipv6(
+    const SocketAddress& one,
+    const SocketAddress& two) {
+  const sockaddr_in6* one_in =
+      reinterpret_cast<const sockaddr_in6*>(one.data());
+  const sockaddr_in6* two_in =
+      reinterpret_cast<const sockaddr_in6*>(two.data());
+  int ret = memcmp(&one_in->sin6_addr, &two_in->sin6_addr, 16);
+  if (ret < 0)
+    return SocketAddress::CompareResult::LESS_THAN;
+  else if (ret > 0)
+    return SocketAddress::CompareResult::GREATER_THAN;
+  return SocketAddress::CompareResult::SAME;
+}
+
+SocketAddress::CompareResult compare_ipv4_ipv6(
+    const SocketAddress& ipv4,
+    const SocketAddress& ipv6) {
+  const sockaddr_in* ipv4_in =
+      reinterpret_cast<const sockaddr_in*>(ipv4.data());
+  const sockaddr_in6 * ipv6_in =
+      reinterpret_cast<const sockaddr_in6*>(ipv6.data());
+
+  const uint8_t* ptr =
+      reinterpret_cast<const uint8_t*>(&ipv6_in->sin6_addr);
+
+  if (memcmp(ptr, mask, sizeof(mask)) != 0)
+    return SocketAddress::CompareResult::NOT_COMPARABLE;
+
+  int ret = memcmp(
+      &ipv4_in->sin_addr,
+      ptr + sizeof(mask),
+      sizeof(uint32_t));
+
+  if (ret < 0)
+    return SocketAddress::CompareResult::LESS_THAN;
+  else if (ret > 0)
+    return SocketAddress::CompareResult::GREATER_THAN;
+  return SocketAddress::CompareResult::SAME;
+}
+
+bool in_network_ipv4(
+    const SocketAddress& ip,
+    const SocketAddress& net,
+    int prefix) {
+  uint32_t mask = ((1 << prefix) - 1) << (32 - prefix);
+
+  const sockaddr_in* ip_in =
+      reinterpret_cast<const sockaddr_in*>(ip.data());
+  const sockaddr_in* net_in =
+      reinterpret_cast<const sockaddr_in*>(net.data());
+
+  return (htonl(ip_in->sin_addr.s_addr) & mask) ==
+         (htonl(net_in->sin_addr.s_addr) & mask);
+}
+
+bool in_network_ipv6(
+    const SocketAddress& ip,
+    const SocketAddress& net,
+    int prefix) {
+  // Special case, if prefix == 128, then just do a
+  // straight comparison.
+  if (prefix == 128)
+    return compare_ipv6(ip, net) == SocketAddress::CompareResult::SAME;
+
+  uint8_t r = prefix % 8;
+  int len = (prefix - r) / 8;
+  uint8_t mask = ((1 << r) - 1) << (8 - r);
+
+  const sockaddr_in6* ip_in =
+      reinterpret_cast<const sockaddr_in6*>(ip.data());
+  const sockaddr_in6* net_in =
+      reinterpret_cast<const sockaddr_in6*>(net.data());
+
+  if (memcmp(&ip_in->sin6_addr, &net_in->sin6_addr, len) != 0)
+    return false;
+
+  const uint8_t* p1 = reinterpret_cast<const uint8_t*>(
+      ip_in->sin6_addr.s6_addr);
+  const uint8_t* p2 = reinterpret_cast<const uint8_t*>(
+      net_in->sin6_addr.s6_addr);
+
+  return (p1[len] & mask) == (p2[len] & mask);
+}
+
+bool in_network_ipv4_ipv6(
+    const SocketAddress& ip,
+    const SocketAddress& net,
+    int prefix) {
+
+  if (prefix == 128)
+    return compare_ipv4_ipv6(ip, net) == SocketAddress::CompareResult::SAME;
+
+  uint8_t r = prefix % 8;
+  int len = (prefix - r) / 8;
+  uint8_t mask = ((1 << r) - 1) << (8 - r);
+
+  const sockaddr_in* ip_in =
+      reinterpret_cast<const sockaddr_in*>(ip.data());
+  const sockaddr_in6* net_in =
+      reinterpret_cast<const sockaddr_in6*>(net.data());
+
+  uint8_t ip_mask[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 0, 0, 0};
+  uint8_t* ptr = ip_mask;
+  memcpy(ptr + 12, &ip_in->sin_addr, 4);
+
+  if (memcmp(ptr, &net_in->sin6_addr, len) != 0)
+    return false;
+
+  ptr += len;
+  const uint8_t* p2 = reinterpret_cast<const uint8_t*>(
+      net_in->sin6_addr.s6_addr);
+
+  return (ptr[0] & mask) == (p2[len] & mask);
+}
+
+bool in_network_ipv6_ipv4(
+    const SocketAddress& ip,
+    const SocketAddress& net,
+    int prefix) {
+  if (prefix == 32)
+    return compare_ipv4_ipv6(net, ip) == SocketAddress::CompareResult::SAME;
+
+  uint32_t m = ((1 << prefix) - 1) << (32 - prefix);
+
+  const sockaddr_in6* ip_in =
+      reinterpret_cast<const sockaddr_in6*>(ip.data());
+  const sockaddr_in* net_in =
+      reinterpret_cast<const sockaddr_in*>(net.data());
+
+  const uint8_t* ptr =
+      reinterpret_cast<const uint8_t*>(&ip_in->sin6_addr);
+
+  if (memcmp(ptr, mask, sizeof(mask)) != 0)
+    return false;
+
+  ptr += sizeof(mask);
+  uint32_t check = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
+
+  return (check & m) == (htonl(net_in->sin_addr.s_addr) & m);
+}
+}  // namespace
+
+// TODO(@jasnell): The implementations of is_match, compare, and
+// is_in_network have not been performance optimized and could
+// likely benefit from work on more performant approaches.
+
+bool SocketAddress::is_match(const SocketAddress& other) const {
+  switch (family()) {
+    case AF_INET:
+      switch (other.family()) {
+        case AF_INET: return is_match_ipv4(*this, other);
+        case AF_INET6: return is_match_ipv4_ipv6(*this, other);
+      }
+      break;
+    case AF_INET6:
+      switch (other.family()) {
+        case AF_INET: return is_match_ipv4_ipv6(other, *this);
+        case AF_INET6: return is_match_ipv6(*this, other);
+      }
+      break;
+  }
+  return false;
+}
+
+SocketAddress::CompareResult SocketAddress::compare(
+    const SocketAddress& other) const {
+  switch (family()) {
+    case AF_INET:
+      switch (other.family()) {
+        case AF_INET: return compare_ipv4(*this, other);
+        case AF_INET6: return compare_ipv4_ipv6(*this, other);
+      }
+      break;
+    case AF_INET6:
+      switch (other.family()) {
+        case AF_INET: {
+          CompareResult c = compare_ipv4_ipv6(other, *this);
+          switch (c) {
+            case SocketAddress::CompareResult::NOT_COMPARABLE:
+              // Fall through
+            case SocketAddress::CompareResult::SAME:
+              return c;
+            case SocketAddress::CompareResult::GREATER_THAN:
+              return SocketAddress::CompareResult::LESS_THAN;
+            case SocketAddress::CompareResult::LESS_THAN:
+              return SocketAddress::CompareResult::GREATER_THAN;
+          }
+          break;
+        }
+        case AF_INET6: return compare_ipv6(*this, other);
+      }
+      break;
+  }
+  return SocketAddress::CompareResult::NOT_COMPARABLE;
+}
+
+bool SocketAddress::is_in_network(
+    const SocketAddress& other,
+    int prefix) const {
+
+  switch (family()) {
+    case AF_INET:
+      switch (other.family()) {
+        case AF_INET: return in_network_ipv4(*this, other, prefix);
+        case AF_INET6: return in_network_ipv4_ipv6(*this, other, prefix);
+      }
+      break;
+    case AF_INET6:
+      switch (other.family()) {
+        case AF_INET: return in_network_ipv6_ipv4(*this, other, prefix);
+        case AF_INET6: return in_network_ipv6(*this, other, prefix);
+      }
+      break;
+  }
+
+  return false;
+}
+
+SocketAddressBlockList::SocketAddressBlockList(
+    std::shared_ptr<SocketAddressBlockList> parent)
+    : parent_(parent) {}
+
+void SocketAddressBlockList::AddSocketAddress(
+    const std::shared_ptr<SocketAddress>& address) {
+  Mutex::ScopedLock lock(mutex_);
+  std::unique_ptr<Rule> rule =
+      std::make_unique<SocketAddressRule>(address);
+  rules_.emplace_front(std::move(rule));
+  address_rules_[*address.get()] = rules_.begin();
+}
+
+void SocketAddressBlockList::RemoveSocketAddress(
+    const std::shared_ptr<SocketAddress>& address) {
+  Mutex::ScopedLock lock(mutex_);
+  auto it = address_rules_.find(*address.get());
+  if (it != std::end(address_rules_)) {
+    rules_.erase(it->second);
+    address_rules_.erase(it);
+  }
+}
+
+void SocketAddressBlockList::AddSocketAddressRange(
+    const std::shared_ptr<SocketAddress>& start,
+    const std::shared_ptr<SocketAddress>& end) {
+  Mutex::ScopedLock lock(mutex_);
+  std::unique_ptr<Rule> rule =
+      std::make_unique<SocketAddressRangeRule>(start, end);
+  rules_.emplace_front(std::move(rule));
+}
+
+void SocketAddressBlockList::AddSocketAddressMask(
+    const std::shared_ptr<SocketAddress>& network,
+    int prefix) {
+  Mutex::ScopedLock lock(mutex_);
+  std::unique_ptr<Rule> rule =
+      std::make_unique<SocketAddressMaskRule>(network, prefix);
+  rules_.emplace_front(std::move(rule));
+}
+
+bool SocketAddressBlockList::Apply(
+    const std::shared_ptr<SocketAddress>& address) {
+  Mutex::ScopedLock lock(mutex_);
+  for (const auto& rule : rules_) {
+    if (rule->Apply(address))
+      return true;
+  }
+  return parent_ ? parent_->Apply(address) : false;
+}
+
+SocketAddressBlockList::SocketAddressRule::SocketAddressRule(
+    const std::shared_ptr<SocketAddress>& address_)
+    : address(address_) {}
+
+SocketAddressBlockList::SocketAddressRangeRule::SocketAddressRangeRule(
+    const std::shared_ptr<SocketAddress>& start_,
+    const std::shared_ptr<SocketAddress>& end_)
+    : start(start_),
+      end(end_) {}
+
+SocketAddressBlockList::SocketAddressMaskRule::SocketAddressMaskRule(
+    const std::shared_ptr<SocketAddress>& network_,
+    int prefix_)
+    : network(network_),
+      prefix(prefix_) {}
+
+bool SocketAddressBlockList::SocketAddressRule::Apply(
+    const std::shared_ptr<SocketAddress>& address) {
+  return this->address->is_match(*address.get());
+}
+
+std::string SocketAddressBlockList::SocketAddressRule::ToString() {
+  std::string ret = "Address: ";
+  ret += address->family() == AF_INET ? "IPv4" : "IPv6";
+  ret += " ";
+  ret += address->address();
+  return ret;
+}
+
+bool SocketAddressBlockList::SocketAddressRangeRule::Apply(
+    const std::shared_ptr<SocketAddress>& address) {
+  return *address.get() >= *start.get() &&
+         *address.get() <= *end.get();
+}
+
+std::string SocketAddressBlockList::SocketAddressRangeRule::ToString() {
+  std::string ret = "Range: ";
+  ret += start->family() == AF_INET ? "IPv4" : "IPv6";
+  ret += " ";
+  ret += start->address();
+  ret += "-";
+  ret += end->address();
+  return ret;
+}
+
+bool SocketAddressBlockList::SocketAddressMaskRule::Apply(
+    const std::shared_ptr<SocketAddress>& address) {
+  return address->is_in_network(*network.get(), prefix);
+}
+
+std::string SocketAddressBlockList::SocketAddressMaskRule::ToString() {
+  std::string ret = "Subnet: ";
+  ret += network->family() == AF_INET ? "IPv4" : "IPv6";
+  ret += " ";
+  ret += network->address();
+  ret += "/" + std::to_string(prefix);
+  return ret;
+}
+
+MaybeLocal<Array> SocketAddressBlockList::ListRules(Environment* env) {
+  Mutex::ScopedLock lock(mutex_);
+  std::vector<Local<Value>> rules;
+  if (!ListRules(env, &rules))
+    return MaybeLocal<Array>();
+  return Array::New(env->isolate(), rules.data(), rules.size());
+}
+
+bool SocketAddressBlockList::ListRules(
+    Environment* env,
+    std::vector<v8::Local<v8::Value>>* rules) {
+  if (parent_ && !parent_->ListRules(env, rules))
+    return false;
+  for (const auto& rule : rules_) {
+    Local<Value> str;
+    if (!rule->ToV8String(env).ToLocal(&str))
+      return false;
+    rules->push_back(str);
+  }
+  return true;
+}
+
+void SocketAddressBlockList::MemoryInfo(node::MemoryTracker* tracker) const {
+  tracker->TrackField("rules", rules_);
+}
+
+void SocketAddressBlockList::SocketAddressRule::MemoryInfo(
+    node::MemoryTracker* tracker) const {
+  tracker->TrackField("address", address);
+}
+
+void SocketAddressBlockList::SocketAddressRangeRule::MemoryInfo(
+    node::MemoryTracker* tracker) const {
+  tracker->TrackField("start", start);
+  tracker->TrackField("end", end);
+}
+
+void SocketAddressBlockList::SocketAddressMaskRule::MemoryInfo(
+    node::MemoryTracker* tracker) const {
+  tracker->TrackField("network", network);
+}
+
+SocketAddressBlockListWrap::SocketAddressBlockListWrap(
+    Environment* env,
+    Local<Object> wrap,
+    std::shared_ptr<SocketAddressBlockList> blocklist)
+    : BaseObject(env, wrap),
+      blocklist_(std::move(blocklist)) {
+  MakeWeak();
+}
+
+BaseObjectPtr<SocketAddressBlockListWrap> SocketAddressBlockListWrap::New(
+    Environment* env) {
+  Local<Object> obj;
+  if (!env->blocklist_constructor_template()
+          ->InstanceTemplate()
+          ->NewInstance(env->context()).ToLocal(&obj)) {
+    return BaseObjectPtr<SocketAddressBlockListWrap>();
+  }
+  BaseObjectPtr<SocketAddressBlockListWrap> wrap =
+      MakeBaseObject<SocketAddressBlockListWrap>(env, obj);
+  CHECK(wrap);
+  return wrap;
+}
+
+BaseObjectPtr<SocketAddressBlockListWrap> SocketAddressBlockListWrap::New(
+    Environment* env,
+    std::shared_ptr<SocketAddressBlockList> blocklist) {
+  Local<Object> obj;
+  if (!env->blocklist_constructor_template()
+          ->InstanceTemplate()
+          ->NewInstance(env->context()).ToLocal(&obj)) {
+    return BaseObjectPtr<SocketAddressBlockListWrap>();
+  }
+  BaseObjectPtr<SocketAddressBlockListWrap> wrap =
+      MakeBaseObject<SocketAddressBlockListWrap>(
+          env,
+          obj,
+          std::move(blocklist));
+  CHECK(wrap);
+  return wrap;
+}
+
+void SocketAddressBlockListWrap::New(
+    const FunctionCallbackInfo<Value>& args) {
+  CHECK(args.IsConstructCall());
+  Environment* env = Environment::GetCurrent(args);
+  new SocketAddressBlockListWrap(env, args.This());
+}
+
+void SocketAddressBlockListWrap::AddAddress(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  SocketAddressBlockListWrap* wrap;
+  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
+
+  CHECK(SocketAddressBase::HasInstance(env, args[0]));
+  SocketAddressBase* addr;
+  ASSIGN_OR_RETURN_UNWRAP(&addr, args[0]);
+
+  wrap->blocklist_->AddSocketAddress(addr->address());
+
+  args.GetReturnValue().Set(true);
+}
+
+void SocketAddressBlockListWrap::AddRange(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  SocketAddressBlockListWrap* wrap;
+  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
+
+  CHECK(SocketAddressBase::HasInstance(env, args[0]));
+  CHECK(SocketAddressBase::HasInstance(env, args[1]));
+
+  SocketAddressBase* start_addr;
+  SocketAddressBase* end_addr;
+  ASSIGN_OR_RETURN_UNWRAP(&start_addr, args[0]);
+  ASSIGN_OR_RETURN_UNWRAP(&end_addr, args[1]);
+
+  // Starting address must come before the end address
+  if (*start_addr->address().get() > *end_addr->address().get())
+    return args.GetReturnValue().Set(false);
+
+  wrap->blocklist_->AddSocketAddressRange(
+      start_addr->address(),
+      end_addr->address());
+
+  args.GetReturnValue().Set(true);
+}
+
+void SocketAddressBlockListWrap::AddSubnet(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  SocketAddressBlockListWrap* wrap;
+  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
+
+  CHECK(SocketAddressBase::HasInstance(env, args[0]));
+  CHECK(args[1]->IsInt32());
+
+  SocketAddressBase* addr;
+  ASSIGN_OR_RETURN_UNWRAP(&addr, args[0]);
+
+  int32_t prefix;
+  if (!args[1]->Int32Value(env->context()).To(&prefix)) {
+    return;
+  }
+
+  CHECK_IMPLIES(addr->address()->family() == AF_INET, prefix <= 32);
+  CHECK_IMPLIES(addr->address()->family() == AF_INET6, prefix <= 128);
+  CHECK_GE(prefix, 0);
+
+  wrap->blocklist_->AddSocketAddressMask(addr->address(), prefix);
+
+  args.GetReturnValue().Set(true);
+}
+
+void SocketAddressBlockListWrap::Check(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  SocketAddressBlockListWrap* wrap;
+  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
+
+  CHECK(SocketAddressBase::HasInstance(env, args[0]));
+  SocketAddressBase* addr;
+  ASSIGN_OR_RETURN_UNWRAP(&addr, args[0]);
+
+  args.GetReturnValue().Set(wrap->blocklist_->Apply(addr->address()));
+}
+
+void SocketAddressBlockListWrap::GetRules(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  SocketAddressBlockListWrap* wrap;
+  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
+  Local<Array> rules;
+  if (wrap->blocklist_->ListRules(env).ToLocal(&rules))
+    args.GetReturnValue().Set(rules);
+}
+
+void SocketAddressBlockListWrap::MemoryInfo(MemoryTracker* tracker) const {
+  blocklist_->MemoryInfo(tracker);
+}
+
+std::unique_ptr<worker::TransferData>
+SocketAddressBlockListWrap::CloneForMessaging() const {
+  return std::make_unique<TransferData>(this);
+}
+
+bool SocketAddressBlockListWrap::HasInstance(
+    Environment* env,
+    Local<Value> value) {
+  return GetConstructorTemplate(env)->HasInstance(value);
+}
+
+Local<FunctionTemplate> SocketAddressBlockListWrap::GetConstructorTemplate(
+    Environment* env) {
+  Local<FunctionTemplate> tmpl = env->blocklist_constructor_template();
+  if (tmpl.IsEmpty()) {
+    tmpl = env->NewFunctionTemplate(SocketAddressBlockListWrap::New);
+    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "BlockList"));
+    tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
+    tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);
+    env->SetProtoMethod(tmpl, "addAddress", AddAddress);
+    env->SetProtoMethod(tmpl, "addRange", AddRange);
+    env->SetProtoMethod(tmpl, "addSubnet", AddSubnet);
+    env->SetProtoMethod(tmpl, "check", Check);
+    env->SetProtoMethod(tmpl, "getRules", GetRules);
+    env->set_blocklist_constructor_template(tmpl);
+  }
+  return tmpl;
+}
+
+void SocketAddressBlockListWrap::Initialize(
+    Local<Object> target,
+    Local<Value> unused,
+    Local<Context> context,
+    void* priv) {
+  Environment* env = Environment::GetCurrent(context);
+
+  env->SetConstructorFunction(
+      target,
+      "BlockList",
+      GetConstructorTemplate(env),
+      Environment::SetConstructorFunctionFlag::NONE);
+
+  SocketAddressBase::Initialize(env, target);
+
+  NODE_DEFINE_CONSTANT(target, AF_INET);
+  NODE_DEFINE_CONSTANT(target, AF_INET6);
+}
+
+BaseObjectPtr<BaseObject> SocketAddressBlockListWrap::TransferData::Deserialize(
+    Environment* env,
+    Local<Context> context,
+    std::unique_ptr<worker::TransferData> self) {
+  return New(env, std::move(blocklist_));
+}
+
+void SocketAddressBlockListWrap::TransferData::MemoryInfo(
+    MemoryTracker* tracker) const {
+  blocklist_->MemoryInfo(tracker);
+}
+
+bool SocketAddressBase::HasInstance(Environment* env, Local<Value> value) {
+  return GetConstructorTemplate(env)->HasInstance(value);
+}
+
+Local<FunctionTemplate> SocketAddressBase::GetConstructorTemplate(
+    Environment* env) {
+  Local<FunctionTemplate> tmpl = env->socketaddress_constructor_template();
+  if (tmpl.IsEmpty()) {
+    tmpl = env->NewFunctionTemplate(New);
+    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "SocketAddress"));
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        SocketAddressBase::kInternalFieldCount);
+    tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
+    env->SetProtoMethod(tmpl, "detail", Detail);
+    env->SetProtoMethod(tmpl, "legacyDetail", LegacyDetail);
+    env->SetProtoMethodNoSideEffect(tmpl, "flowlabel", GetFlowLabel);
+    env->set_socketaddress_constructor_template(tmpl);
+  }
+  return tmpl;
+}
+
+void SocketAddressBase::Initialize(Environment* env, Local<Object> target) {
+  env->SetConstructorFunction(
+      target,
+      "SocketAddress",
+      GetConstructorTemplate(env),
+      Environment::SetConstructorFunctionFlag::NONE);
+}
+
+BaseObjectPtr<SocketAddressBase> SocketAddressBase::Create(
+    Environment* env,
+    std::shared_ptr<SocketAddress> address) {
+  Local<Object> obj;
+  if (!GetConstructorTemplate(env)
+          ->InstanceTemplate()
+          ->NewInstance(env->context()).ToLocal(&obj)) {
+    return BaseObjectPtr<SocketAddressBase>();
+  }
+
+  return MakeBaseObject<SocketAddressBase>(env, obj, std::move(address));
+}
+
+void SocketAddressBase::New(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args.IsConstructCall());
+  CHECK(args[0]->IsString());  // address
+  CHECK(args[1]->IsInt32());  // port
+  CHECK(args[2]->IsInt32());  // family
+  CHECK(args[3]->IsUint32());  // flow label
+
+  Utf8Value address(env->isolate(), args[0]);
+  int32_t port = args[1].As<Int32>()->Value();
+  int32_t family = args[2].As<Int32>()->Value();
+  uint32_t flow_label = args[3].As<Uint32>()->Value();
+
+  std::shared_ptr<SocketAddress> addr = std::make_shared<SocketAddress>();
+
+  if (!SocketAddress::New(family, *address, port, addr.get()))
+    return THROW_ERR_INVALID_ADDRESS(env);
+
+  addr->set_flow_label(flow_label);
+
+  new SocketAddressBase(env, args.This(), std::move(addr));
+}
+
+void SocketAddressBase::Detail(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args[0]->IsObject());
+  Local<Object> detail = args[0].As<Object>();
+
+  SocketAddressBase* base;
+  ASSIGN_OR_RETURN_UNWRAP(&base, args.Holder());
+
+  Local<Value> address;
+  if (!ToV8Value(env->context(), base->address_->address()).ToLocal(&address))
+    return;
+
+  if (detail->Set(env->context(), env->address_string(), address).IsJust() &&
+      detail->Set(
+          env->context(),
+          env->port_string(),
+          Int32::New(env->isolate(), base->address_->port())).IsJust() &&
+      detail->Set(
+          env->context(),
+          env->family_string(),
+          Int32::New(env->isolate(), base->address_->family())).IsJust() &&
+      detail->Set(
+          env->context(),
+          env->flowlabel_string(),
+          Uint32::New(env->isolate(), base->address_->flow_label()))
+              .IsJust()) {
+    args.GetReturnValue().Set(detail);
+  }
+}
+
+void SocketAddressBase::GetFlowLabel(const FunctionCallbackInfo<Value>& args) {
+  SocketAddressBase* base;
+  ASSIGN_OR_RETURN_UNWRAP(&base, args.Holder());
+  args.GetReturnValue().Set(base->address_->flow_label());
+}
+
+void SocketAddressBase::LegacyDetail(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  SocketAddressBase* base;
+  ASSIGN_OR_RETURN_UNWRAP(&base, args.Holder());
+  args.GetReturnValue().Set(base->address_->ToJS(env));
+}
+
+SocketAddressBase::SocketAddressBase(
+    Environment* env,
+    Local<Object> wrap,
+    std::shared_ptr<SocketAddress> address)
+    : BaseObject(env, wrap),
+      address_(std::move(address)) {
+  MakeWeak();
+}
+
+void SocketAddressBase::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("address", address_);
+}
+
+std::unique_ptr<worker::TransferData>
+SocketAddressBase::CloneForMessaging() const {
+  return std::make_unique<TransferData>(this);
+}
+
+void SocketAddressBase::TransferData::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("address", address_);
+}
+
+BaseObjectPtr<BaseObject> SocketAddressBase::TransferData::Deserialize(
+    Environment* env,
+    v8::Local<v8::Context> context,
+    std::unique_ptr<worker::TransferData> self) {
+  return SocketAddressBase::Create(env, std::move(address_));
+}
+
 }  // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(
+    block_list,
+    node::SocketAddressBlockListWrap::Initialize)
diff --git a/src/node_sockaddr.h b/src/node_sockaddr.h
index c0d006a4d6e681f2b83e258b3c1227321ed1fa1f..abd28d3e4aa7c51389afa4e6b4f000dde5f05d1d 100644
--- a/src/node_sockaddr.h
+++ b/src/node_sockaddr.h
@@ -3,12 +3,17 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "env.h"
 #include "memory_tracker.h"
+#include "base_object.h"
 #include "node.h"
+#include "node_worker.h"
 #include "uv.h"
 #include "v8.h"
 
+#include <memory>
 #include <string>
+#include <list>
 #include <unordered_map>
 
 namespace node {
@@ -17,6 +22,13 @@ class Environment;
 
 class SocketAddress : public MemoryRetainer {
  public:
+  enum class CompareResult {
+    NOT_COMPARABLE = -2,
+    LESS_THAN,
+    SAME,
+    GREATER_THAN
+  };
+
   struct Hash {
     size_t operator()(const SocketAddress& addr) const;
   };
@@ -24,6 +36,11 @@ class SocketAddress : public MemoryRetainer {
   inline bool operator==(const SocketAddress& other) const;
   inline bool operator!=(const SocketAddress& other) const;
 
+  inline bool operator<(const SocketAddress& other) const;
+  inline bool operator>(const SocketAddress& other) const;
+  inline bool operator<=(const SocketAddress& other) const;
+  inline bool operator>=(const SocketAddress& other) const;
+
   inline static bool is_numeric_host(const char* hostname);
   inline static bool is_numeric_host(const char* hostname, int family);
 
@@ -77,6 +94,20 @@ class SocketAddress : public MemoryRetainer {
   inline std::string address() const;
   inline int port() const;
 
+  // Returns true if the given other SocketAddress is a match
+  // for this one. The addresses are a match if:
+  // 1. They are the same family and match identically
+  // 2. They are different family but match semantically (
+  //     for instance, an IPv4 addres in IPv6 notation)
+  bool is_match(const SocketAddress& other) const;
+
+  // Compares this SocketAddress to the given other SocketAddress.
+  CompareResult compare(const SocketAddress& other) const;
+
+  // Returns true if this SocketAddress is within the subnet
+  // identified by the given network address and CIDR prefix.
+  bool is_in_network(const SocketAddress& network, int prefix) const;
+
   // If the SocketAddress is an IPv6 address, returns the
   // current value of the IPv6 flow label, if set. Otherwise
   // returns 0.
@@ -116,6 +147,256 @@ class SocketAddress : public MemoryRetainer {
   sockaddr_storage address_;
 };
 
+class SocketAddressBase : public BaseObject {
+ public:
+  static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static BaseObjectPtr<SocketAddressBase> Create(
+      Environment* env,
+      std::shared_ptr<SocketAddress> address);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Detail(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LegacyDetail(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetFlowLabel(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  SocketAddressBase(
+    Environment* env,
+    v8::Local<v8::Object> wrap,
+    std::shared_ptr<SocketAddress> address);
+
+  inline const std::shared_ptr<SocketAddress>& address() const {
+    return address_;
+  }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SocketAddressBase)
+  SET_SELF_SIZE(SocketAddressBase)
+
+  TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  class TransferData : public worker::TransferData {
+   public:
+    inline explicit TransferData(const SocketAddressBase* wrap)
+        : address_(wrap->address_) {}
+
+    inline explicit TransferData(std::shared_ptr<SocketAddress> address)
+        : address_(std::move(address)) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressBase::TransferData)
+    SET_SELF_SIZE(TransferData)
+
+   private:
+    std::shared_ptr<SocketAddress> address_;
+  };
+
+ private:
+  std::shared_ptr<SocketAddress> address_;
+};
+
+template <typename T>
+class SocketAddressLRU : public MemoryRetainer {
+ public:
+  using Type = typename T::Type;
+
+  inline explicit SocketAddressLRU(size_t max_size);
+
+  // If the item already exists, returns a reference to
+  // the existing item, adjusting items position in the
+  // LRU. If the item does not exist, emplaces the item
+  // and returns the new item.
+  Type* Upsert(const SocketAddress& address);
+
+  // Returns a reference to the item if it exists, or
+  // nullptr. The position in the LRU is not modified.
+  Type* Peek(const SocketAddress& address) const;
+
+  size_t size() const { return map_.size(); }
+  size_t max_size() const { return max_size_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SocketAddressLRU)
+  SET_SELF_SIZE(SocketAddressLRU)
+
+ private:
+  using Pair = std::pair<SocketAddress, Type>;
+  using Iterator = typename std::list<Pair>::iterator;
+
+  void CheckExpired();
+
+  std::list<Pair> list_;
+  SocketAddress::Map<Iterator> map_;
+  size_t max_size_;
+};
+
+// A BlockList is used to evaluate whether a given
+// SocketAddress should be accepted for inbound or
+// outbound network activity.
+class SocketAddressBlockList : public MemoryRetainer {
+ public:
+  explicit SocketAddressBlockList(
+      std::shared_ptr<SocketAddressBlockList> parent = {});
+  ~SocketAddressBlockList() = default;
+
+  void AddSocketAddress(const std::shared_ptr<SocketAddress>& address);
+
+  void RemoveSocketAddress(const std::shared_ptr<SocketAddress>& address);
+
+  void AddSocketAddressRange(
+      const std::shared_ptr<SocketAddress>& start,
+      const std::shared_ptr<SocketAddress>& end);
+
+  void AddSocketAddressMask(
+      const std::shared_ptr<SocketAddress>& address,
+      int prefix);
+
+  bool Apply(const std::shared_ptr<SocketAddress>& address);
+
+  size_t size() const { return rules_.size(); }
+
+  v8::MaybeLocal<v8::Array> ListRules(Environment* env);
+
+  struct Rule : public MemoryRetainer {
+    virtual bool Apply(const std::shared_ptr<SocketAddress>& address) = 0;
+    inline v8::MaybeLocal<v8::Value> ToV8String(Environment* env);
+    virtual std::string ToString() = 0;
+  };
+
+  struct SocketAddressRule final : Rule {
+    std::shared_ptr<SocketAddress> address;
+
+    explicit SocketAddressRule(const std::shared_ptr<SocketAddress>& address);
+
+    bool Apply(const std::shared_ptr<SocketAddress>& address) override;
+    std::string ToString() override;
+
+    void MemoryInfo(node::MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressRule)
+    SET_SELF_SIZE(SocketAddressRule)
+  };
+
+  struct SocketAddressRangeRule final : Rule {
+    std::shared_ptr<SocketAddress> start;
+    std::shared_ptr<SocketAddress> end;
+
+    SocketAddressRangeRule(
+        const std::shared_ptr<SocketAddress>& start,
+        const std::shared_ptr<SocketAddress>& end);
+
+    bool Apply(const std::shared_ptr<SocketAddress>& address) override;
+    std::string ToString() override;
+
+    void MemoryInfo(node::MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressRangeRule)
+    SET_SELF_SIZE(SocketAddressRangeRule)
+  };
+
+  struct SocketAddressMaskRule final : Rule {
+    std::shared_ptr<SocketAddress> network;
+    int prefix;
+
+    SocketAddressMaskRule(
+        const std::shared_ptr<SocketAddress>& address,
+        int prefix);
+
+    bool Apply(const std::shared_ptr<SocketAddress>& address) override;
+    std::string ToString() override;
+
+    void MemoryInfo(node::MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressMaskRule)
+    SET_SELF_SIZE(SocketAddressMaskRule)
+  };
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SocketAddressBlockList)
+  SET_SELF_SIZE(SocketAddressBlockList)
+
+ private:
+  bool ListRules(
+      Environment* env,
+      std::vector<v8::Local<v8::Value>>* vec);
+
+  std::shared_ptr<SocketAddressBlockList> parent_;
+  std::list<std::unique_ptr<Rule>> rules_;
+  SocketAddress::Map<std::list<std::unique_ptr<Rule>>::iterator> address_rules_;
+
+  Mutex mutex_;
+};
+
+class SocketAddressBlockListWrap : public BaseObject {
+ public:
+  static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context,
+                         void* priv);
+
+  static BaseObjectPtr<SocketAddressBlockListWrap> New(Environment* env);
+  static BaseObjectPtr<SocketAddressBlockListWrap> New(
+      Environment* env,
+      std::shared_ptr<SocketAddressBlockList> blocklist);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddAddress(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddRange(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddSubnet(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Check(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetRules(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  SocketAddressBlockListWrap(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      std::shared_ptr<SocketAddressBlockList> blocklist =
+          std::make_shared<SocketAddressBlockList>());
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SocketAddressBlockListWrap)
+  SET_SELF_SIZE(SocketAddressBlockListWrap)
+
+  TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  class TransferData : public worker::TransferData {
+   public:
+    inline explicit TransferData(const SocketAddressBlockListWrap* wrap)
+        : blocklist_(wrap->blocklist_) {}
+
+    inline explicit TransferData(
+        std::shared_ptr<SocketAddressBlockList> blocklist)
+        : blocklist_(std::move(blocklist)) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressBlockListWrap::TransferData)
+    SET_SELF_SIZE(TransferData)
+
+   private:
+    std::shared_ptr<SocketAddressBlockList> blocklist_;
+  };
+
+ private:
+  std::shared_ptr<SocketAddressBlockList> blocklist_;
+};
+
 }  // namespace node
 
 #endif  // NOE_WANT_INTERNALS
diff --git a/src/node_stat_watcher.cc b/src/node_stat_watcher.cc
index 05c540bbff17cc1f096742f57ce17ace62f6e605..344ea6bb7ea2e62ee37c5c1310082c394a1c6e80 100644
--- a/src/node_stat_watcher.cc
+++ b/src/node_stat_watcher.cc
@@ -38,7 +38,6 @@ using v8::HandleScope;
 using v8::Integer;
 using v8::Local;
 using v8::Object;
-using v8::String;
 using v8::Uint32;
 using v8::Value;
 
@@ -49,27 +48,24 @@ void StatWatcher::Initialize(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> t = env->NewFunctionTemplate(StatWatcher::New);
   t->InstanceTemplate()->SetInternalFieldCount(
       StatWatcher::kInternalFieldCount);
-  Local<String> statWatcherString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "StatWatcher");
-  t->SetClassName(statWatcherString);
   t->Inherit(HandleWrap::GetConstructorTemplate(env));
 
   env->SetProtoMethod(t, "start", StatWatcher::Start);
 
-  target->Set(env->context(), statWatcherString,
-              t->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "StatWatcher", t);
 }
 
 
-StatWatcher::StatWatcher(Environment* env,
+StatWatcher::StatWatcher(fs::BindingData* binding_data,
                          Local<Object> wrap,
                          bool use_bigint)
-    : HandleWrap(env,
+    : HandleWrap(binding_data->env(),
                  wrap,
                  reinterpret_cast<uv_handle_t*>(&watcher_),
                  AsyncWrap::PROVIDER_STATWATCHER),
-      use_bigint_(use_bigint) {
-  CHECK_EQ(0, uv_fs_poll_init(env->event_loop(), &watcher_));
+      use_bigint_(use_bigint),
+      binding_data_(binding_data) {
+  CHECK_EQ(0, uv_fs_poll_init(env()->event_loop(), &watcher_));
 }
 
 
@@ -82,8 +78,10 @@ void StatWatcher::Callback(uv_fs_poll_t* handle,
   HandleScope handle_scope(env->isolate());
   Context::Scope context_scope(env->context());
 
-  Local<Value> arr = fs::FillGlobalStatsArray(env, wrap->use_bigint_, curr);
-  USE(fs::FillGlobalStatsArray(env, wrap->use_bigint_, prev, true));
+  Local<Value> arr = fs::FillGlobalStatsArray(
+      wrap->binding_data_.get(), wrap->use_bigint_, curr);
+  USE(fs::FillGlobalStatsArray(
+      wrap->binding_data_.get(), wrap->use_bigint_, prev, true));
 
   Local<Value> argv[2] = { Integer::New(env->isolate(), status), arr };
   wrap->MakeCallback(env->onchange_string(), arraysize(argv), argv);
@@ -92,8 +90,9 @@ void StatWatcher::Callback(uv_fs_poll_t* handle,
 
 void StatWatcher::New(const FunctionCallbackInfo<Value>& args) {
   CHECK(args.IsConstructCall());
-  Environment* env = Environment::GetCurrent(args);
-  new StatWatcher(env, args.This(), args[0]->IsTrue());
+  fs::BindingData* binding_data =
+      Environment::GetBindingData<fs::BindingData>(args);
+  new StatWatcher(binding_data, args.This(), args[0]->IsTrue());
 }
 
 // wrap.start(filename, interval)
diff --git a/src/node_stat_watcher.h b/src/node_stat_watcher.h
index 9669806ce796c9a236176c33a62ac5d7e45d17e2..c1d6ccce69bdbb14479e6ee16ad571b289f4f131 100644
--- a/src/node_stat_watcher.h
+++ b/src/node_stat_watcher.h
@@ -30,6 +30,9 @@
 #include "v8.h"
 
 namespace node {
+namespace fs {
+class BindingData;
+}
 
 class Environment;
 
@@ -38,7 +41,7 @@ class StatWatcher : public HandleWrap {
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
 
  protected:
-  StatWatcher(Environment* env,
+  StatWatcher(fs::BindingData* binding_data,
               v8::Local<v8::Object> wrap,
               bool use_bigint);
 
@@ -57,6 +60,7 @@ class StatWatcher : public HandleWrap {
 
   uv_fs_poll_t watcher_;
   const bool use_bigint_;
+  BaseObjectPtr<fs::BindingData> binding_data_;
 };
 
 }  // namespace node
diff --git a/src/node_symbols.cc b/src/node_symbols.cc
index cb6c5583bb83958aae3d121b580d3056d993dc2f..31d2487fdcf82b888f59d5caf9dd7807ba741bd9 100644
--- a/src/node_symbols.cc
+++ b/src/node_symbols.cc
@@ -16,10 +16,10 @@ static void Initialize(Local<Object> target,
                        Local<Context> context,
                        void* priv) {
   Environment* env = Environment::GetCurrent(context);
-#define V(PropertyName, StringValue)                                           \
-  target                                                                       \
-      ->Set(env->context(), env->PropertyName()->Name(), env->PropertyName())  \
-      .Check();
+#define V(PropertyName, StringValue)                                          \
+  target->Set(env->context(),                                                 \
+              env->PropertyName()->Description(),                             \
+              env->PropertyName()).Check();
   PER_ISOLATE_SYMBOL_PROPERTIES(V)
 #undef V
 }
diff --git a/src/node_task_queue.cc b/src/node_task_queue.cc
index b55a2a4387d655b8a7a199919f9afb20c80a1729..de38e8e7d2ee4293d78bdc0b4eae30921321451c 100644
--- a/src/node_task_queue.cc
+++ b/src/node_task_queue.cc
@@ -2,7 +2,7 @@
 #include "node.h"
 #include "node_errors.h"
 #include "node_internals.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "util-inl.h"
 #include "v8.h"
 
diff --git a/src/node_trace_events.cc b/src/node_trace_events.cc
index 58813a9083a560eb75440d594d51779742e264d4..b36a5fc0bf774a6ddacf142ccc06bb339096bd00 100644
--- a/src/node_trace_events.cc
+++ b/src/node_trace_events.cc
@@ -135,10 +135,7 @@ void NodeCategorySet::Initialize(Local<Object> target,
   env->SetProtoMethod(category_set, "enable", NodeCategorySet::Enable);
   env->SetProtoMethod(category_set, "disable", NodeCategorySet::Disable);
 
-  target->Set(env->context(),
-              FIXED_ONE_BYTE_STRING(env->isolate(), "CategorySet"),
-              category_set->GetFunction(env->context()).ToLocalChecked())
-              .Check();
+  env->SetConstructorFunction(target, "CategorySet", category_set);
 
   Local<String> isTraceCategoryEnabled =
       FIXED_ONE_BYTE_STRING(env->isolate(), "isTraceCategoryEnabled");
diff --git a/src/node_types.cc b/src/node_types.cc
index a53bcba555448fd99d582da7dc0c7af528627ca5..9643a66668144eecf4ad819fb9bff0425d84b415 100644
--- a/src/node_types.cc
+++ b/src/node_types.cc
@@ -35,7 +35,6 @@ namespace {
   V(DataView)                                                                 \
   V(SharedArrayBuffer)                                                        \
   V(Proxy)                                                                    \
-  V(WebAssemblyCompiledModule)                                                \
   V(ModuleNamespaceObject)                                                    \
 
 
diff --git a/src/node_url.cc b/src/node_url.cc
index 73ceafa636b187268ef9052255a88e322a0bd491..a97b83cee7e0ddea67e14dd49b2adda48f81bc3a 100644
--- a/src/node_url.cc
+++ b/src/node_url.cc
@@ -13,6 +13,14 @@ namespace node {
 
 using errors::TryCatchScope;
 
+using url::table_data::hex;
+using url::table_data::C0_CONTROL_ENCODE_SET;
+using url::table_data::FRAGMENT_ENCODE_SET;
+using url::table_data::PATH_ENCODE_SET;
+using url::table_data::USERINFO_ENCODE_SET;
+using url::table_data::QUERY_ENCODE_SET_NONSPECIAL;
+using url::table_data::QUERY_ENCODE_SET_SPECIAL;
+
 using v8::Array;
 using v8::Context;
 using v8::Function;
@@ -38,7 +46,6 @@ Local<String> Utf8String(Isolate* isolate, const std::string& str) {
 }
 
 namespace url {
-
 namespace {
 
 // https://url.spec.whatwg.org/#eof-code-point
@@ -228,444 +235,6 @@ CHAR_TEST(16, IsUnicodeSurrogateTrail, (ch & 0x400) != 0)
 #undef CHAR_TEST
 #undef TWO_CHAR_STRING_TEST
 
-const char* hex[256] = {
-  "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
-  "%08", "%09", "%0A", "%0B", "%0C", "%0D", "%0E", "%0F",
-  "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
-  "%18", "%19", "%1A", "%1B", "%1C", "%1D", "%1E", "%1F",
-  "%20", "%21", "%22", "%23", "%24", "%25", "%26", "%27",
-  "%28", "%29", "%2A", "%2B", "%2C", "%2D", "%2E", "%2F",
-  "%30", "%31", "%32", "%33", "%34", "%35", "%36", "%37",
-  "%38", "%39", "%3A", "%3B", "%3C", "%3D", "%3E", "%3F",
-  "%40", "%41", "%42", "%43", "%44", "%45", "%46", "%47",
-  "%48", "%49", "%4A", "%4B", "%4C", "%4D", "%4E", "%4F",
-  "%50", "%51", "%52", "%53", "%54", "%55", "%56", "%57",
-  "%58", "%59", "%5A", "%5B", "%5C", "%5D", "%5E", "%5F",
-  "%60", "%61", "%62", "%63", "%64", "%65", "%66", "%67",
-  "%68", "%69", "%6A", "%6B", "%6C", "%6D", "%6E", "%6F",
-  "%70", "%71", "%72", "%73", "%74", "%75", "%76", "%77",
-  "%78", "%79", "%7A", "%7B", "%7C", "%7D", "%7E", "%7F",
-  "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
-  "%88", "%89", "%8A", "%8B", "%8C", "%8D", "%8E", "%8F",
-  "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
-  "%98", "%99", "%9A", "%9B", "%9C", "%9D", "%9E", "%9F",
-  "%A0", "%A1", "%A2", "%A3", "%A4", "%A5", "%A6", "%A7",
-  "%A8", "%A9", "%AA", "%AB", "%AC", "%AD", "%AE", "%AF",
-  "%B0", "%B1", "%B2", "%B3", "%B4", "%B5", "%B6", "%B7",
-  "%B8", "%B9", "%BA", "%BB", "%BC", "%BD", "%BE", "%BF",
-  "%C0", "%C1", "%C2", "%C3", "%C4", "%C5", "%C6", "%C7",
-  "%C8", "%C9", "%CA", "%CB", "%CC", "%CD", "%CE", "%CF",
-  "%D0", "%D1", "%D2", "%D3", "%D4", "%D5", "%D6", "%D7",
-  "%D8", "%D9", "%DA", "%DB", "%DC", "%DD", "%DE", "%DF",
-  "%E0", "%E1", "%E2", "%E3", "%E4", "%E5", "%E6", "%E7",
-  "%E8", "%E9", "%EA", "%EB", "%EC", "%ED", "%EE", "%EF",
-  "%F0", "%F1", "%F2", "%F3", "%F4", "%F5", "%F6", "%F7",
-  "%F8", "%F9", "%FA", "%FB", "%FC", "%FD", "%FE", "%FF"
-};
-
-const uint8_t C0_CONTROL_ENCODE_SET[32] = {
-  // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 20     21     22     23     24     25     26     27
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 60     61     62     63     64     65     66     67
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-  // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
-};
-
-const uint8_t FRAGMENT_ENCODE_SET[32] = {
-  // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
-  // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 60     61     62     63     64     65     66     67
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-  // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
-};
-
-
-const uint8_t PATH_ENCODE_SET[32] = {
-  // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x80,
-  // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 60     61     62     63     64     65     66     67
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x08 | 0x00 | 0x20 | 0x00 | 0x80,
-  // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
-};
-
-const uint8_t USERINFO_ENCODE_SET[32] = {
-  // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-  // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 40     41     42     43     44     45     46     47
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x08 | 0x10 | 0x20 | 0x40 | 0x00,
-  // 60     61     62     63     64     65     66     67
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x08 | 0x10 | 0x20 | 0x00 | 0x80,
-  // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
-};
-
-const uint8_t QUERY_ENCODE_SET_NONSPECIAL[32] = {
-  // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
-  // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 60     61     62     63     64     65     66     67
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-  // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
-};
-
-// Same as QUERY_ENCODE_SET_NONSPECIAL, but with 0x27 (') encoded.
-const uint8_t QUERY_ENCODE_SET_SPECIAL[32] = {
-  // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x80,
-  // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
-  // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 60     61     62     63     64     65     66     67
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-  // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-  // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-  // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
-};
 
 bool BitAt(const uint8_t a[], const uint8_t i) {
   return !!(a[i >> 3] & (1 << (i & 7)));
@@ -674,10 +243,10 @@ bool BitAt(const uint8_t a[], const uint8_t i) {
 // Appends ch to str. If ch position in encode_set is set, the ch will
 // be percent-encoded then appended.
 void AppendOrEscape(std::string* str,
-                           const unsigned char ch,
-                           const uint8_t encode_set[]) {
+                    const unsigned char ch,
+                    const uint8_t encode_set[]) {
   if (BitAt(encode_set, ch))
-    *str += hex[ch];
+    *str += hex + ch * 4;  // "%XX\0" has a length of 4
   else
     *str += ch;
 }
@@ -794,119 +363,28 @@ bool ToASCII(const std::string& input, std::string* output) {
 }
 #endif
 
+#define NS_IN6ADDRSZ 16
+
 void URLHost::ParseIPv6Host(const char* input, size_t length) {
   CHECK_EQ(type_, HostType::H_FAILED);
-  unsigned size = arraysize(value_.ipv6);
-  for (unsigned n = 0; n < size; n++)
-    value_.ipv6[n] = 0;
-  uint16_t* piece_pointer = &value_.ipv6[0];
-  uint16_t* const buffer_end = piece_pointer + size;
-  uint16_t* compress_pointer = nullptr;
-  const char* pointer = input;
-  const char* end = pointer + length;
-  unsigned value, len, numbers_seen;
-  char ch = pointer < end ? pointer[0] : kEOL;
-  if (ch == ':') {
-    if (length < 2 || pointer[1] != ':')
-      return;
-    pointer += 2;
-    ch = pointer < end ? pointer[0] : kEOL;
-    piece_pointer++;
-    compress_pointer = piece_pointer;
-  }
-  while (ch != kEOL) {
-    if (piece_pointer >= buffer_end)
-      return;
-    if (ch == ':') {
-      if (compress_pointer != nullptr)
-        return;
-      pointer++;
-      ch = pointer < end ? pointer[0] : kEOL;
-      piece_pointer++;
-      compress_pointer = piece_pointer;
-      continue;
-    }
-    value = 0;
-    len = 0;
-    while (len < 4 && IsASCIIHexDigit(ch)) {
-      value = value * 0x10 + hex2bin(ch);
-      pointer++;
-      ch = pointer < end ? pointer[0] : kEOL;
-      len++;
-    }
-    switch (ch) {
-      case '.':
-        if (len == 0)
-          return;
-        pointer -= len;
-        ch = pointer < end ? pointer[0] : kEOL;
-        if (piece_pointer > buffer_end - 2)
-          return;
-        numbers_seen = 0;
-        while (ch != kEOL) {
-          value = 0xffffffff;
-          if (numbers_seen > 0) {
-            if (ch == '.' && numbers_seen < 4) {
-              pointer++;
-              ch = pointer < end ? pointer[0] : kEOL;
-            } else {
-              return;
-            }
-          }
-          if (!IsASCIIDigit(ch))
-            return;
-          while (IsASCIIDigit(ch)) {
-            unsigned number = ch - '0';
-            if (value == 0xffffffff) {
-              value = number;
-            } else if (value == 0) {
-              return;
-            } else {
-              value = value * 10 + number;
-            }
-            if (value > 255)
-              return;
-            pointer++;
-            ch = pointer < end ? pointer[0] : kEOL;
-          }
-          *piece_pointer = *piece_pointer * 0x100 + value;
-          numbers_seen++;
-          if (numbers_seen == 2 || numbers_seen == 4)
-            piece_pointer++;
-        }
-        if (numbers_seen != 4)
-          return;
-        continue;
-      case ':':
-        pointer++;
-        ch = pointer < end ? pointer[0] : kEOL;
-        if (ch == kEOL)
-          return;
-        break;
-      case kEOL:
-        break;
-      default:
-        return;
-    }
-    *piece_pointer = value;
-    piece_pointer++;
-  }
 
-  if (compress_pointer != nullptr) {
-    unsigned swaps = piece_pointer - compress_pointer;
-    piece_pointer = buffer_end - 1;
-    while (piece_pointer != &value_.ipv6[0] && swaps > 0) {
-      uint16_t temp = *piece_pointer;
-      uint16_t* swap_piece = compress_pointer + swaps - 1;
-      *piece_pointer = *swap_piece;
-      *swap_piece = temp;
-       piece_pointer--;
-       swaps--;
-    }
-  } else if (compress_pointer == nullptr &&
-             piece_pointer != buffer_end) {
+  unsigned char buf[sizeof(struct in6_addr)];
+  MaybeStackBuffer<char> ipv6(length + 1);
+  *(*ipv6 + length) = 0;
+  memset(buf, 0, sizeof(buf));
+  memcpy(*ipv6, input, sizeof(const char) * length);
+
+  int ret = uv_inet_pton(AF_INET6, *ipv6, buf);
+
+  if (ret != 0) {
     return;
   }
+
+  // Ref: https://sourceware.org/git/?p=glibc.git;a=blob;f=resolv/inet_ntop.c;h=c4d38c0f951013e51a4fc6eaa8a9b82e146abe5a;hb=HEAD#l119
+  for (int i = 0; i < NS_IN6ADDRSZ; i += 2) {
+    value_.ipv6[i >> 1] = (buf[i] << 8) | buf[i + 1];
+  }
+
   type_ = HostType::H_IPV6;
 }
 
@@ -960,7 +438,7 @@ void URLHost::ParseIPv4Host(const char* input, size_t length, bool* is_ipv4) {
 
   while (pointer <= end) {
     const char ch = pointer < end ? pointer[0] : kEOL;
-    int remaining = end - pointer - 1;
+    int64_t remaining = end - pointer - 1;
     if (ch == '.' || ch == kEOL) {
       if (++parts > static_cast<int>(arraysize(numbers)))
         return;
@@ -993,10 +471,11 @@ void URLHost::ParseIPv4Host(const char* input, size_t length, bool* is_ipv4) {
   }
 
   type_ = HostType::H_IPV4;
-  val = numbers[parts - 1];
+  val = static_cast<uint32_t>(numbers[parts - 1]);
   for (int n = 0; n < parts - 1; n++) {
     double b = 3 - n;
-    val += numbers[n] * pow(256, b);
+    val +=
+        static_cast<uint32_t>(numbers[n]) * static_cast<uint32_t>(pow(256, b));
   }
 
   value_.ipv4 = val;
@@ -1426,7 +905,7 @@ void URL::Parse(const char* input,
     const char ch = p < end ? p[0] : kEOL;
     bool special = (url->flags & URL_FLAGS_SPECIAL);
     bool cannot_be_base;
-    const bool special_back_slash = (special && ch == '\\');
+    bool special_back_slash = (special && ch == '\\');
 
     switch (state) {
       case kSchemeStart:
@@ -1476,6 +955,7 @@ void URL::Parse(const char* input,
             url->flags &= ~URL_FLAGS_SPECIAL;
             special = false;
           }
+          special_back_slash = (special && ch == '\\');
           buffer.clear();
           if (has_state_override)
             return;
@@ -1520,6 +1000,7 @@ void URL::Parse(const char* input,
             url->flags &= ~URL_FLAGS_SPECIAL;
             special = false;
           }
+          special_back_slash = (special && ch == '\\');
           if (base->flags & URL_FLAGS_HAS_PATH) {
             url->flags |= URL_FLAGS_HAS_PATH;
             url->path = base->path;
@@ -1543,6 +1024,7 @@ void URL::Parse(const char* input,
           url->flags |= URL_FLAGS_SPECIAL;
           special = true;
           state = kFile;
+          special_back_slash = (special && ch == '\\');
           continue;
         }
         break;
@@ -1572,6 +1054,7 @@ void URL::Parse(const char* input,
           url->flags &= ~URL_FLAGS_SPECIAL;
           special = false;
         }
+        special_back_slash = (special && ch == '\\');
         switch (ch) {
           case kEOL:
             if (base->flags & URL_FLAGS_HAS_USERNAME) {
@@ -2175,9 +1658,7 @@ void Parse(Environment* env,
     Local<Value> argv[2] = { undef, undef };
     argv[ERR_ARG_FLAGS] = Integer::NewFromUnsigned(isolate, url.flags);
     argv[ERR_ARG_INPUT] =
-      String::NewFromUtf8(env->isolate(),
-                          input,
-                          NewStringType::kNormal).ToLocalChecked();
+      String::NewFromUtf8(env->isolate(), input).ToLocalChecked();
     error_cb.As<Function>()->Call(context, recv, arraysize(argv), argv)
         .FromMaybe(Local<Value>());
   }
@@ -2225,9 +1706,7 @@ void EncodeAuthSet(const FunctionCallbackInfo<Value>& args) {
     AppendOrEscape(&output, ch, USERINFO_ENCODE_SET);
   }
   args.GetReturnValue().Set(
-      String::NewFromUtf8(env->isolate(),
-                          output.c_str(),
-                          NewStringType::kNormal).ToLocalChecked());
+      String::NewFromUtf8(env->isolate(), output.c_str()).ToLocalChecked());
 }
 
 void ToUSVString(const FunctionCallbackInfo<Value>& args) {
@@ -2279,9 +1758,7 @@ void DomainToASCII(const FunctionCallbackInfo<Value>& args) {
   }
   std::string out = host.ToStringMove();
   args.GetReturnValue().Set(
-      String::NewFromUtf8(env->isolate(),
-                          out.c_str(),
-                          NewStringType::kNormal).ToLocalChecked());
+      String::NewFromUtf8(env->isolate(), out.c_str()).ToLocalChecked());
 }
 
 void DomainToUnicode(const FunctionCallbackInfo<Value>& args) {
@@ -2299,9 +1776,7 @@ void DomainToUnicode(const FunctionCallbackInfo<Value>& args) {
   }
   std::string out = host.ToStringMove();
   args.GetReturnValue().Set(
-      String::NewFromUtf8(env->isolate(),
-                          out.c_str(),
-                          NewStringType::kNormal).ToLocalChecked());
+      String::NewFromUtf8(env->isolate(), out.c_str()).ToLocalChecked());
 }
 
 void SetURLConstructor(const FunctionCallbackInfo<Value>& args) {
diff --git a/src/node_url.h b/src/node_url.h
index 6439a4a087be776a04477c66df6092484d830e30..8fd993407d4360add9dd9460d2487617202aa820 100644
--- a/src/node_url.h
+++ b/src/node_url.h
@@ -73,6 +73,16 @@ struct url_data {
   std::vector<std::string> path;
 };
 
+namespace table_data {
+extern const char hex[1024];
+extern const uint8_t C0_CONTROL_ENCODE_SET[32];
+extern const uint8_t FRAGMENT_ENCODE_SET[32];
+extern const uint8_t PATH_ENCODE_SET[32];
+extern const uint8_t USERINFO_ENCODE_SET[32];
+extern const uint8_t QUERY_ENCODE_SET_NONSPECIAL[32];
+extern const uint8_t QUERY_ENCODE_SET_SPECIAL[32];
+}
+
 class URL {
  public:
   static void Parse(const char* input,
diff --git a/src/node_url_tables.cc b/src/node_url_tables.cc
new file mode 100644
index 0000000000000000000000000000000000000000..801badf838dc8300fbac37e5ec2b0ef6663e4985
--- /dev/null
+++ b/src/node_url_tables.cc
@@ -0,0 +1,448 @@
+#include <cstdint>
+#include "node_url.h"
+
+namespace node {
+namespace url {
+namespace table_data {
+
+const char hex[1024] =
+  "%00\0%01\0%02\0%03\0%04\0%05\0%06\0%07\0"
+  "%08\0%09\0%0A\0%0B\0%0C\0%0D\0%0E\0%0F\0"
+  "%10\0%11\0%12\0%13\0%14\0%15\0%16\0%17\0"
+  "%18\0%19\0%1A\0%1B\0%1C\0%1D\0%1E\0%1F\0"
+  "%20\0%21\0%22\0%23\0%24\0%25\0%26\0%27\0"
+  "%28\0%29\0%2A\0%2B\0%2C\0%2D\0%2E\0%2F\0"
+  "%30\0%31\0%32\0%33\0%34\0%35\0%36\0%37\0"
+  "%38\0%39\0%3A\0%3B\0%3C\0%3D\0%3E\0%3F\0"
+  "%40\0%41\0%42\0%43\0%44\0%45\0%46\0%47\0"
+  "%48\0%49\0%4A\0%4B\0%4C\0%4D\0%4E\0%4F\0"
+  "%50\0%51\0%52\0%53\0%54\0%55\0%56\0%57\0"
+  "%58\0%59\0%5A\0%5B\0%5C\0%5D\0%5E\0%5F\0"
+  "%60\0%61\0%62\0%63\0%64\0%65\0%66\0%67\0"
+  "%68\0%69\0%6A\0%6B\0%6C\0%6D\0%6E\0%6F\0"
+  "%70\0%71\0%72\0%73\0%74\0%75\0%76\0%77\0"
+  "%78\0%79\0%7A\0%7B\0%7C\0%7D\0%7E\0%7F\0"
+  "%80\0%81\0%82\0%83\0%84\0%85\0%86\0%87\0"
+  "%88\0%89\0%8A\0%8B\0%8C\0%8D\0%8E\0%8F\0"
+  "%90\0%91\0%92\0%93\0%94\0%95\0%96\0%97\0"
+  "%98\0%99\0%9A\0%9B\0%9C\0%9D\0%9E\0%9F\0"
+  "%A0\0%A1\0%A2\0%A3\0%A4\0%A5\0%A6\0%A7\0"
+  "%A8\0%A9\0%AA\0%AB\0%AC\0%AD\0%AE\0%AF\0"
+  "%B0\0%B1\0%B2\0%B3\0%B4\0%B5\0%B6\0%B7\0"
+  "%B8\0%B9\0%BA\0%BB\0%BC\0%BD\0%BE\0%BF\0"
+  "%C0\0%C1\0%C2\0%C3\0%C4\0%C5\0%C6\0%C7\0"
+  "%C8\0%C9\0%CA\0%CB\0%CC\0%CD\0%CE\0%CF\0"
+  "%D0\0%D1\0%D2\0%D3\0%D4\0%D5\0%D6\0%D7\0"
+  "%D8\0%D9\0%DA\0%DB\0%DC\0%DD\0%DE\0%DF\0"
+  "%E0\0%E1\0%E2\0%E3\0%E4\0%E5\0%E6\0%E7\0"
+  "%E8\0%E9\0%EA\0%EB\0%EC\0%ED\0%EE\0%EF\0"
+  "%F0\0%F1\0%F2\0%F3\0%F4\0%F5\0%F6\0%F7\0"
+  "%F8\0%F9\0%FA\0%FB\0%FC\0%FD\0%FE\0%FF";
+
+const uint8_t C0_CONTROL_ENCODE_SET[32] = {
+  // 00     01     02     03     04     05     06     07
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 08     09     0A     0B     0C     0D     0E     0F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 10     11     12     13     14     15     16     17
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 18     19     1A     1B     1C     1D     1E     1F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 20     21     22     23     24     25     26     27
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 28     29     2A     2B     2C     2D     2E     2F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 30     31     32     33     34     35     36     37
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 38     39     3A     3B     3C     3D     3E     3F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 40     41     42     43     44     45     46     47
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 48     49     4A     4B     4C     4D     4E     4F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 50     51     52     53     54     55     56     57
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 58     59     5A     5B     5C     5D     5E     5F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 60     61     62     63     64     65     66     67
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 68     69     6A     6B     6C     6D     6E     6F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 70     71     72     73     74     75     76     77
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 78     79     7A     7B     7C     7D     7E     7F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
+  // 80     81     82     83     84     85     86     87
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 88     89     8A     8B     8C     8D     8E     8F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 90     91     92     93     94     95     96     97
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 98     99     9A     9B     9C     9D     9E     9F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A0     A1     A2     A3     A4     A5     A6     A7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A8     A9     AA     AB     AC     AD     AE     AF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B0     B1     B2     B3     B4     B5     B6     B7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B8     B9     BA     BB     BC     BD     BE     BF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C0     C1     C2     C3     C4     C5     C6     C7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C8     C9     CA     CB     CC     CD     CE     CF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D0     D1     D2     D3     D4     D5     D6     D7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D8     D9     DA     DB     DC     DD     DE     DF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E0     E1     E2     E3     E4     E5     E6     E7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E8     E9     EA     EB     EC     ED     EE     EF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F0     F1     F2     F3     F4     F5     F6     F7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F8     F9     FA     FB     FC     FD     FE     FF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
+};
+
+const uint8_t FRAGMENT_ENCODE_SET[32] = {
+  // 00     01     02     03     04     05     06     07
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 08     09     0A     0B     0C     0D     0E     0F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 10     11     12     13     14     15     16     17
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 18     19     1A     1B     1C     1D     1E     1F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 20     21     22     23     24     25     26     27
+    0x01 | 0x00 | 0x04 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 28     29     2A     2B     2C     2D     2E     2F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 30     31     32     33     34     35     36     37
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 38     39     3A     3B     3C     3D     3E     3F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
+  // 40     41     42     43     44     45     46     47
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 48     49     4A     4B     4C     4D     4E     4F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 50     51     52     53     54     55     56     57
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 58     59     5A     5B     5C     5D     5E     5F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 60     61     62     63     64     65     66     67
+    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 68     69     6A     6B     6C     6D     6E     6F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 70     71     72     73     74     75     76     77
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 78     79     7A     7B     7C     7D     7E     7F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
+  // 80     81     82     83     84     85     86     87
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 88     89     8A     8B     8C     8D     8E     8F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 90     91     92     93     94     95     96     97
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 98     99     9A     9B     9C     9D     9E     9F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A0     A1     A2     A3     A4     A5     A6     A7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A8     A9     AA     AB     AC     AD     AE     AF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B0     B1     B2     B3     B4     B5     B6     B7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B8     B9     BA     BB     BC     BD     BE     BF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C0     C1     C2     C3     C4     C5     C6     C7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C8     C9     CA     CB     CC     CD     CE     CF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D0     D1     D2     D3     D4     D5     D6     D7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D8     D9     DA     DB     DC     DD     DE     DF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E0     E1     E2     E3     E4     E5     E6     E7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E8     E9     EA     EB     EC     ED     EE     EF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F0     F1     F2     F3     F4     F5     F6     F7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F8     F9     FA     FB     FC     FD     FE     FF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
+};
+
+
+const uint8_t PATH_ENCODE_SET[32] = {
+  // 00     01     02     03     04     05     06     07
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 08     09     0A     0B     0C     0D     0E     0F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 10     11     12     13     14     15     16     17
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 18     19     1A     1B     1C     1D     1E     1F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 20     21     22     23     24     25     26     27
+    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 28     29     2A     2B     2C     2D     2E     2F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 30     31     32     33     34     35     36     37
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 38     39     3A     3B     3C     3D     3E     3F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x80,
+  // 40     41     42     43     44     45     46     47
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 48     49     4A     4B     4C     4D     4E     4F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 50     51     52     53     54     55     56     57
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 58     59     5A     5B     5C     5D     5E     5F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 60     61     62     63     64     65     66     67
+    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 68     69     6A     6B     6C     6D     6E     6F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 70     71     72     73     74     75     76     77
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 78     79     7A     7B     7C     7D     7E     7F
+    0x00 | 0x00 | 0x00 | 0x08 | 0x00 | 0x20 | 0x00 | 0x80,
+  // 80     81     82     83     84     85     86     87
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 88     89     8A     8B     8C     8D     8E     8F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 90     91     92     93     94     95     96     97
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 98     99     9A     9B     9C     9D     9E     9F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A0     A1     A2     A3     A4     A5     A6     A7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A8     A9     AA     AB     AC     AD     AE     AF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B0     B1     B2     B3     B4     B5     B6     B7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B8     B9     BA     BB     BC     BD     BE     BF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C0     C1     C2     C3     C4     C5     C6     C7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C8     C9     CA     CB     CC     CD     CE     CF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D0     D1     D2     D3     D4     D5     D6     D7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D8     D9     DA     DB     DC     DD     DE     DF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E0     E1     E2     E3     E4     E5     E6     E7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E8     E9     EA     EB     EC     ED     EE     EF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F0     F1     F2     F3     F4     F5     F6     F7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F8     F9     FA     FB     FC     FD     FE     FF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
+};
+
+const uint8_t USERINFO_ENCODE_SET[32] = {
+  // 00     01     02     03     04     05     06     07
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 08     09     0A     0B     0C     0D     0E     0F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 10     11     12     13     14     15     16     17
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 18     19     1A     1B     1C     1D     1E     1F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 20     21     22     23     24     25     26     27
+    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 28     29     2A     2B     2C     2D     2E     2F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
+  // 30     31     32     33     34     35     36     37
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 38     39     3A     3B     3C     3D     3E     3F
+    0x00 | 0x00 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 40     41     42     43     44     45     46     47
+    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 48     49     4A     4B     4C     4D     4E     4F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 50     51     52     53     54     55     56     57
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 58     59     5A     5B     5C     5D     5E     5F
+    0x00 | 0x00 | 0x00 | 0x08 | 0x10 | 0x20 | 0x40 | 0x00,
+  // 60     61     62     63     64     65     66     67
+    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 68     69     6A     6B     6C     6D     6E     6F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 70     71     72     73     74     75     76     77
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 78     79     7A     7B     7C     7D     7E     7F
+    0x00 | 0x00 | 0x00 | 0x08 | 0x10 | 0x20 | 0x00 | 0x80,
+  // 80     81     82     83     84     85     86     87
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 88     89     8A     8B     8C     8D     8E     8F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 90     91     92     93     94     95     96     97
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 98     99     9A     9B     9C     9D     9E     9F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A0     A1     A2     A3     A4     A5     A6     A7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A8     A9     AA     AB     AC     AD     AE     AF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B0     B1     B2     B3     B4     B5     B6     B7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B8     B9     BA     BB     BC     BD     BE     BF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C0     C1     C2     C3     C4     C5     C6     C7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C8     C9     CA     CB     CC     CD     CE     CF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D0     D1     D2     D3     D4     D5     D6     D7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D8     D9     DA     DB     DC     DD     DE     DF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E0     E1     E2     E3     E4     E5     E6     E7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E8     E9     EA     EB     EC     ED     EE     EF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F0     F1     F2     F3     F4     F5     F6     F7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F8     F9     FA     FB     FC     FD     FE     FF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
+};
+
+const uint8_t QUERY_ENCODE_SET_NONSPECIAL[32] = {
+  // 00     01     02     03     04     05     06     07
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 08     09     0A     0B     0C     0D     0E     0F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 10     11     12     13     14     15     16     17
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 18     19     1A     1B     1C     1D     1E     1F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 20     21     22     23     24     25     26     27
+    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 28     29     2A     2B     2C     2D     2E     2F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 30     31     32     33     34     35     36     37
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 38     39     3A     3B     3C     3D     3E     3F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
+  // 40     41     42     43     44     45     46     47
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 48     49     4A     4B     4C     4D     4E     4F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 50     51     52     53     54     55     56     57
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 58     59     5A     5B     5C     5D     5E     5F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 60     61     62     63     64     65     66     67
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 68     69     6A     6B     6C     6D     6E     6F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 70     71     72     73     74     75     76     77
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 78     79     7A     7B     7C     7D     7E     7F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
+  // 80     81     82     83     84     85     86     87
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 88     89     8A     8B     8C     8D     8E     8F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 90     91     92     93     94     95     96     97
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 98     99     9A     9B     9C     9D     9E     9F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A0     A1     A2     A3     A4     A5     A6     A7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A8     A9     AA     AB     AC     AD     AE     AF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B0     B1     B2     B3     B4     B5     B6     B7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B8     B9     BA     BB     BC     BD     BE     BF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C0     C1     C2     C3     C4     C5     C6     C7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C8     C9     CA     CB     CC     CD     CE     CF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D0     D1     D2     D3     D4     D5     D6     D7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D8     D9     DA     DB     DC     DD     DE     DF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E0     E1     E2     E3     E4     E5     E6     E7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E8     E9     EA     EB     EC     ED     EE     EF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F0     F1     F2     F3     F4     F5     F6     F7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F8     F9     FA     FB     FC     FD     FE     FF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
+};
+
+// Same as QUERY_ENCODE_SET_NONSPECIAL, but with 0x27 (') encoded.
+const uint8_t QUERY_ENCODE_SET_SPECIAL[32] = {
+  // 00     01     02     03     04     05     06     07
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 08     09     0A     0B     0C     0D     0E     0F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 10     11     12     13     14     15     16     17
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 18     19     1A     1B     1C     1D     1E     1F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 20     21     22     23     24     25     26     27
+    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x80,
+  // 28     29     2A     2B     2C     2D     2E     2F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 30     31     32     33     34     35     36     37
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 38     39     3A     3B     3C     3D     3E     3F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
+  // 40     41     42     43     44     45     46     47
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 48     49     4A     4B     4C     4D     4E     4F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 50     51     52     53     54     55     56     57
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 58     59     5A     5B     5C     5D     5E     5F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 60     61     62     63     64     65     66     67
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 68     69     6A     6B     6C     6D     6E     6F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 70     71     72     73     74     75     76     77
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
+  // 78     79     7A     7B     7C     7D     7E     7F
+    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
+  // 80     81     82     83     84     85     86     87
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 88     89     8A     8B     8C     8D     8E     8F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 90     91     92     93     94     95     96     97
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // 98     99     9A     9B     9C     9D     9E     9F
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A0     A1     A2     A3     A4     A5     A6     A7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // A8     A9     AA     AB     AC     AD     AE     AF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B0     B1     B2     B3     B4     B5     B6     B7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // B8     B9     BA     BB     BC     BD     BE     BF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C0     C1     C2     C3     C4     C5     C6     C7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // C8     C9     CA     CB     CC     CD     CE     CF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D0     D1     D2     D3     D4     D5     D6     D7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // D8     D9     DA     DB     DC     DD     DE     DF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E0     E1     E2     E3     E4     E5     E6     E7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // E8     E9     EA     EB     EC     ED     EE     EF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F0     F1     F2     F3     F4     F5     F6     F7
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
+  // F8     F9     FA     FB     FC     FD     FE     FF
+    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80
+};
+
+}  // namespace table_data
+}  // namespace url
+}  // namespace node
diff --git a/src/node_util.cc b/src/node_util.cc
index eac09f8d44fcbd0c43e7a84cd31bff8727f54610..7ea8cf8fe6bfc8530e0b3cfd3259590db1019fa5 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -333,19 +333,15 @@ void Initialize(Local<Object> target,
                   env->should_abort_on_uncaught_toggle().GetJSArray())
             .FromJust());
 
-  Local<String> weak_ref_string =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "WeakReference");
   Local<FunctionTemplate> weak_ref =
       env->NewFunctionTemplate(WeakReference::New);
   weak_ref->InstanceTemplate()->SetInternalFieldCount(
       WeakReference::kInternalFieldCount);
-  weak_ref->SetClassName(weak_ref_string);
   weak_ref->Inherit(BaseObject::GetConstructorTemplate(env));
   env->SetProtoMethod(weak_ref, "get", WeakReference::Get);
   env->SetProtoMethod(weak_ref, "incRef", WeakReference::IncRef);
   env->SetProtoMethod(weak_ref, "decRef", WeakReference::DecRef);
-  target->Set(context, weak_ref_string,
-              weak_ref->GetFunction(context).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "WeakReference", weak_ref);
 
   env->SetMethod(target, "guessHandleType", GuessHandleType);
 }
diff --git a/src/node_v8.cc b/src/node_v8.cc
index bfc4580fd02a6892ed45e04ff5faa298d541cc5c..4354e1e1772d824392296363078f235c71613ab3 100644
--- a/src/node_v8.cc
+++ b/src/node_v8.cc
@@ -19,15 +19,17 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#include "node.h"
+#include "node_v8.h"
+#include "base_object-inl.h"
 #include "env-inl.h"
+#include "memory_tracker-inl.h"
+#include "node.h"
 #include "util-inl.h"
 #include "v8.h"
 
 namespace node {
-
+namespace v8_utils {
 using v8::Array;
-using v8::ArrayBuffer;
 using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::HeapCodeStatistics;
@@ -36,7 +38,6 @@ using v8::HeapStatistics;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
-using v8::NewStringType;
 using v8::Object;
 using v8::ScriptCompiler;
 using v8::String;
@@ -44,7 +45,6 @@ using v8::Uint32;
 using v8::V8;
 using v8::Value;
 
-
 #define HEAP_STATISTICS_PROPERTIES(V)                                         \
   V(0, total_heap_size, kTotalHeapSizeIndex)                                  \
   V(1, total_heap_size_executable, kTotalHeapSizeExecutableIndex)             \
@@ -59,11 +59,10 @@ using v8::Value;
   V(10, number_of_detached_contexts, kNumberOfDetachedContextsIndex)
 
 #define V(a, b, c) +1
-static const size_t kHeapStatisticsPropertiesCount =
+static constexpr size_t kHeapStatisticsPropertiesCount =
     HEAP_STATISTICS_PROPERTIES(V);
 #undef V
 
-
 #define HEAP_SPACE_STATISTICS_PROPERTIES(V)                                   \
   V(0, space_size, kSpaceSizeIndex)                                           \
   V(1, space_used_size, kSpaceUsedSizeIndex)                                  \
@@ -71,14 +70,13 @@ static const size_t kHeapStatisticsPropertiesCount =
   V(3, physical_space_size, kPhysicalSpaceSizeIndex)
 
 #define V(a, b, c) +1
-static const size_t kHeapSpaceStatisticsPropertiesCount =
+static constexpr size_t kHeapSpaceStatisticsPropertiesCount =
     HEAP_SPACE_STATISTICS_PROPERTIES(V);
 #undef V
 
-
-#define HEAP_CODE_STATISTICS_PROPERTIES(V)                                    \
-  V(0, code_and_metadata_size, kCodeAndMetadataSizeIndex)                    \
-  V(1, bytecode_and_metadata_size, kBytecodeAndMetadataSizeIndex)             \
+#define HEAP_CODE_STATISTICS_PROPERTIES(V)                                     \
+  V(0, code_and_metadata_size, kCodeAndMetadataSizeIndex)                      \
+  V(1, bytecode_and_metadata_size, kBytecodeAndMetadataSizeIndex)              \
   V(2, external_script_source_size, kExternalScriptSourceSizeIndex)
 
 #define V(a, b, c) +1
@@ -86,6 +84,38 @@ static const size_t kHeapCodeStatisticsPropertiesCount =
     HEAP_CODE_STATISTICS_PROPERTIES(V);
 #undef V
 
+BindingData::BindingData(Environment* env, Local<Object> obj)
+    : BaseObject(env, obj),
+      heap_statistics_buffer(env->isolate(), kHeapStatisticsPropertiesCount),
+      heap_space_statistics_buffer(env->isolate(),
+                                   kHeapSpaceStatisticsPropertiesCount),
+      heap_code_statistics_buffer(env->isolate(),
+                                  kHeapCodeStatisticsPropertiesCount) {
+  obj->Set(env->context(),
+           FIXED_ONE_BYTE_STRING(env->isolate(), "heapStatisticsBuffer"),
+           heap_statistics_buffer.GetJSArray())
+      .Check();
+  obj->Set(env->context(),
+           FIXED_ONE_BYTE_STRING(env->isolate(), "heapCodeStatisticsBuffer"),
+           heap_code_statistics_buffer.GetJSArray())
+      .Check();
+  obj->Set(env->context(),
+           FIXED_ONE_BYTE_STRING(env->isolate(), "heapSpaceStatisticsBuffer"),
+           heap_space_statistics_buffer.GetJSArray())
+      .Check();
+}
+
+void BindingData::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("heap_statistics_buffer", heap_statistics_buffer);
+  tracker->TrackField("heap_space_statistics_buffer",
+                      heap_space_statistics_buffer);
+  tracker->TrackField("heap_code_statistics_buffer",
+                      heap_code_statistics_buffer);
+}
+
+// TODO(addaleax): Remove once we're on C++17.
+constexpr FastStringKey BindingData::type_name;
+
 void CachedDataVersionTag(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Local<Integer> result =
@@ -94,12 +124,11 @@ void CachedDataVersionTag(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(result);
 }
 
-
-void UpdateHeapStatisticsArrayBuffer(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+void UpdateHeapStatisticsBuffer(const FunctionCallbackInfo<Value>& args) {
+  BindingData* data = Environment::GetBindingData<BindingData>(args);
   HeapStatistics s;
-  env->isolate()->GetHeapStatistics(&s);
-  double* const buffer = env->heap_statistics_buffer();
+  args.GetIsolate()->GetHeapStatistics(&s);
+  AliasedFloat64Array& buffer = data->heap_statistics_buffer;
 #define V(index, name, _) buffer[index] = static_cast<double>(s.name());
   HEAP_STATISTICS_PROPERTIES(V)
 #undef V
@@ -107,29 +136,26 @@ void UpdateHeapStatisticsArrayBuffer(const FunctionCallbackInfo<Value>& args) {
 
 
 void UpdateHeapSpaceStatisticsBuffer(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+  BindingData* data = Environment::GetBindingData<BindingData>(args);
   HeapSpaceStatistics s;
-  Isolate* const isolate = env->isolate();
-  double* buffer = env->heap_space_statistics_buffer();
-  size_t number_of_heap_spaces = env->isolate()->NumberOfHeapSpaces();
+  Isolate* const isolate = args.GetIsolate();
+  CHECK(args[0]->IsUint32());
+  size_t space_index = static_cast<size_t>(args[0].As<v8::Uint32>()->Value());
+  isolate->GetHeapSpaceStatistics(&s, space_index);
 
-  for (size_t i = 0; i < number_of_heap_spaces; i++) {
-    isolate->GetHeapSpaceStatistics(&s, i);
-    size_t const property_offset = i * kHeapSpaceStatisticsPropertiesCount;
-#define V(index, name, _) buffer[property_offset + index] = \
-                              static_cast<double>(s.name());
-      HEAP_SPACE_STATISTICS_PROPERTIES(V)
+  AliasedFloat64Array& buffer = data->heap_space_statistics_buffer;
+
+#define V(index, name, _) buffer[index] = static_cast<double>(s.name());
+  HEAP_SPACE_STATISTICS_PROPERTIES(V)
 #undef V
-  }
 }
 
-
-void UpdateHeapCodeStatisticsArrayBuffer(
-    const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
+void UpdateHeapCodeStatisticsBuffer(const FunctionCallbackInfo<Value>& args) {
+  BindingData* data = Environment::GetBindingData<BindingData>(args);
   HeapCodeStatistics s;
-  env->isolate()->GetHeapCodeAndMetadataStatistics(&s);
-  double* const buffer = env->heap_code_statistics_buffer();
+  args.GetIsolate()->GetHeapCodeAndMetadataStatistics(&s);
+  AliasedFloat64Array& buffer = data->heap_code_statistics_buffer;
+
 #define V(index, name, _) buffer[index] = static_cast<double>(s.name());
   HEAP_CODE_STATISTICS_PROPERTIES(V)
 #undef V
@@ -139,7 +165,7 @@ void UpdateHeapCodeStatisticsArrayBuffer(
 void SetFlagsFromString(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsString());
   String::Utf8Value flags(args.GetIsolate(), args[0]);
-  V8::SetFlagsFromString(*flags, flags.length());
+  V8::SetFlagsFromString(*flags, static_cast<size_t>(flags.length()));
 }
 
 
@@ -148,70 +174,17 @@ void Initialize(Local<Object> target,
                 Local<Context> context,
                 void* priv) {
   Environment* env = Environment::GetCurrent(context);
+  BindingData* const binding_data =
+      env->AddBindingData<BindingData>(context, target);
+  if (binding_data == nullptr) return;
 
   env->SetMethodNoSideEffect(target, "cachedDataVersionTag",
                              CachedDataVersionTag);
+  env->SetMethod(
+      target, "updateHeapStatisticsBuffer", UpdateHeapStatisticsBuffer);
 
-  // Export symbols used by v8.getHeapStatistics()
-  env->SetMethod(target,
-                 "updateHeapStatisticsArrayBuffer",
-                 UpdateHeapStatisticsArrayBuffer);
-
-  env->set_heap_statistics_buffer(new double[kHeapStatisticsPropertiesCount]);
-
-  const size_t heap_statistics_buffer_byte_length =
-      sizeof(*env->heap_statistics_buffer()) * kHeapStatisticsPropertiesCount;
-
-  target->Set(env->context(),
-              FIXED_ONE_BYTE_STRING(env->isolate(),
-                                    "heapStatisticsArrayBuffer"),
-              ArrayBuffer::New(env->isolate(),
-                               env->heap_statistics_buffer(),
-                               heap_statistics_buffer_byte_length)).Check();
-
-#define V(i, _, name)                                                         \
-  target->Set(env->context(),                                                 \
-              FIXED_ONE_BYTE_STRING(env->isolate(), #name),                   \
-              Uint32::NewFromUnsigned(env->isolate(), i)).Check();
-
-  HEAP_STATISTICS_PROPERTIES(V)
-#undef V
-
-  // Export symbols used by v8.getHeapCodeStatistics()
-  env->SetMethod(target,
-                 "updateHeapCodeStatisticsArrayBuffer",
-                 UpdateHeapCodeStatisticsArrayBuffer);
-
-  env->set_heap_code_statistics_buffer(
-    new double[kHeapCodeStatisticsPropertiesCount]);
-
-  const size_t heap_code_statistics_buffer_byte_length =
-      sizeof(*env->heap_code_statistics_buffer())
-      * kHeapCodeStatisticsPropertiesCount;
-
-  target->Set(env->context(),
-              FIXED_ONE_BYTE_STRING(env->isolate(),
-                                    "heapCodeStatisticsArrayBuffer"),
-              ArrayBuffer::New(env->isolate(),
-                               env->heap_code_statistics_buffer(),
-                               heap_code_statistics_buffer_byte_length))
-  .Check();
-
-#define V(i, _, name)                                                         \
-  target->Set(env->context(),                                                 \
-              FIXED_ONE_BYTE_STRING(env->isolate(), #name),                   \
-              Uint32::NewFromUnsigned(env->isolate(), i)).Check();
-
-  HEAP_CODE_STATISTICS_PROPERTIES(V)
-#undef V
-
-  // Export symbols used by v8.getHeapSpaceStatistics()
-  target->Set(env->context(),
-              FIXED_ONE_BYTE_STRING(env->isolate(),
-                                    "kHeapSpaceStatisticsPropertiesCount"),
-              Uint32::NewFromUnsigned(env->isolate(),
-                                      kHeapSpaceStatisticsPropertiesCount))
-              .Check();
+  env->SetMethod(
+      target, "updateHeapCodeStatisticsBuffer", UpdateHeapCodeStatisticsBuffer);
 
   size_t number_of_heap_spaces = env->isolate()->NumberOfHeapSpaces();
 
@@ -221,9 +194,7 @@ void Initialize(Local<Object> target,
   MaybeStackBuffer<Local<Value>, 16> heap_spaces(number_of_heap_spaces);
   for (size_t i = 0; i < number_of_heap_spaces; i++) {
     env->isolate()->GetHeapSpaceStatistics(&s, i);
-    heap_spaces[i] = String::NewFromUtf8(env->isolate(),
-                                         s.space_name(),
-                                         NewStringType::kNormal)
+    heap_spaces[i] = String::NewFromUtf8(env->isolate(), s.space_name())
                                              .ToLocalChecked();
   }
   target->Set(env->context(),
@@ -233,30 +204,18 @@ void Initialize(Local<Object> target,
                          number_of_heap_spaces)).Check();
 
   env->SetMethod(target,
-                 "updateHeapSpaceStatisticsArrayBuffer",
+                 "updateHeapSpaceStatisticsBuffer",
                  UpdateHeapSpaceStatisticsBuffer);
 
-  env->set_heap_space_statistics_buffer(
-    new double[kHeapSpaceStatisticsPropertiesCount * number_of_heap_spaces]);
-
-  const size_t heap_space_statistics_buffer_byte_length =
-      sizeof(*env->heap_space_statistics_buffer()) *
-      kHeapSpaceStatisticsPropertiesCount *
-      number_of_heap_spaces;
-
-  target->Set(env->context(),
-              FIXED_ONE_BYTE_STRING(env->isolate(),
-                                    "heapSpaceStatisticsArrayBuffer"),
-              ArrayBuffer::New(env->isolate(),
-                               env->heap_space_statistics_buffer(),
-                               heap_space_statistics_buffer_byte_length))
-              .Check();
-
-#define V(i, _, name)                                                         \
-  target->Set(env->context(),                                                 \
-              FIXED_ONE_BYTE_STRING(env->isolate(), #name),                   \
-              Uint32::NewFromUnsigned(env->isolate(), i)).Check();
+#define V(i, _, name)                                                          \
+  target                                                                       \
+      ->Set(env->context(),                                                    \
+            FIXED_ONE_BYTE_STRING(env->isolate(), #name),                      \
+            Uint32::NewFromUnsigned(env->isolate(), i))                        \
+      .Check();
 
+  HEAP_STATISTICS_PROPERTIES(V)
+  HEAP_CODE_STATISTICS_PROPERTIES(V)
   HEAP_SPACE_STATISTICS_PROPERTIES(V)
 #undef V
 
@@ -264,6 +223,7 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "setFlagsFromString", SetFlagsFromString);
 }
 
+}  // namespace v8_utils
 }  // namespace node
 
-NODE_MODULE_CONTEXT_AWARE_INTERNAL(v8, node::Initialize)
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(v8, node::v8_utils::Initialize)
diff --git a/src/node_v8.h b/src/node_v8.h
new file mode 100644
index 0000000000000000000000000000000000000000..745c6580b844f4f2f7defbee87dc110d05e44a88
--- /dev/null
+++ b/src/node_v8.h
@@ -0,0 +1,36 @@
+#ifndef SRC_NODE_V8_H_
+#define SRC_NODE_V8_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+#include "base_object.h"
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+class Environment;
+
+namespace v8_utils {
+class BindingData : public BaseObject {
+ public:
+  BindingData(Environment* env, v8::Local<v8::Object> obj);
+
+  static constexpr FastStringKey type_name{"node::v8::BindingData"};
+
+  AliasedFloat64Array heap_statistics_buffer;
+  AliasedFloat64Array heap_space_statistics_buffer;
+  AliasedFloat64Array heap_code_statistics_buffer;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+};
+
+}  // namespace v8_utils
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_H_
diff --git a/src/node_version.h b/src/node_version.h
index 89368822e552677443c2e1901142ab93d3d9b208..d898f1b8874ded79e5fb7222acee775ecde53245 100644
--- a/src/node_version.h
+++ b/src/node_version.h
@@ -22,12 +22,12 @@
 #ifndef SRC_NODE_VERSION_H_
 #define SRC_NODE_VERSION_H_
 
-#define NODE_MAJOR_VERSION 12
-#define NODE_MINOR_VERSION 22
-#define NODE_PATCH_VERSION 7
+#define NODE_MAJOR_VERSION 14
+#define NODE_MINOR_VERSION 18
+#define NODE_PATCH_VERSION 3
 
 #define NODE_VERSION_IS_LTS 1
-#define NODE_VERSION_LTS_CODENAME "Erbium"
+#define NODE_VERSION_LTS_CODENAME "Fermium"
 
 #define NODE_VERSION_IS_RELEASE 1
 
@@ -84,12 +84,12 @@
  * if it can be made ABI compatible with the previous version.
  *
  * The registry of used NODE_MODULE_VERSION numbers is located at
- *   https://github.com/nodejs/node/blob/master/doc/abi_version_registry.json
+ *   https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json
  * Extenders, embedders and other consumers of Node.js that require ABI
  * version matching should open a pull request to reserve a number in this
  * registry.
  */
-#define NODE_MODULE_VERSION 72
+#define NODE_MODULE_VERSION 83
 
 // The NAPI_VERSION provided by this version of the runtime. This is the version
 // which the Node binary being built supports.
diff --git a/src/node_wasi.cc b/src/node_wasi.cc
index fb965d90fbef31ac7b2733a8fcccd96ce058ed6f..ffcc37c5274c98f1f0a92f13fe0186ecc6c9741c 100644
--- a/src/node_wasi.cc
+++ b/src/node_wasi.cc
@@ -75,6 +75,7 @@ inline void Debug(WASI* wasi, Args&&... args) {
 
 using v8::Array;
 using v8::ArrayBuffer;
+using v8::BackingStore;
 using v8::BigInt;
 using v8::Context;
 using v8::Exception;
@@ -278,7 +279,8 @@ void WASI::ArgsGet(const FunctionCallbackInfo<Value>& args) {
 
   if (err == UVWASI_ESUCCESS) {
     for (size_t i = 0; i < wasi->uvw_.argc; i++) {
-      uint32_t offset = argv_buf_offset + (argv[i] - argv[0]);
+      uint32_t offset =
+          static_cast<uint32_t>(argv_buf_offset + (argv[i] - argv[0]));
       uvwasi_serdes_write_uint32_t(memory,
                                    argv_offset +
                                    (i * UVWASI_SERDES_SIZE_uint32_t),
@@ -409,7 +411,8 @@ void WASI::EnvironGet(const FunctionCallbackInfo<Value>& args) {
 
   if (err == UVWASI_ESUCCESS) {
     for (size_t i = 0; i < wasi->uvw_.envc; i++) {
-      uint32_t offset = environ_buf_offset + (environment[i] - environment[0]);
+      uint32_t offset = static_cast<uint32_t>(
+          environ_buf_offset + (environment[i] - environment[0]));
 
       uvwasi_serdes_write_uint32_t(memory,
                                    environ_offset +
@@ -1660,9 +1663,9 @@ uvwasi_errno_t WASI::backingStore(char** store, size_t* byte_length) {
     return UVWASI_EINVAL;
 
   Local<ArrayBuffer> ab = prop.As<ArrayBuffer>();
-  ArrayBuffer::Contents contents = ab->GetContents();
-  *byte_length = ab->ByteLength();
-  *store = static_cast<char*>(contents.Data());
+  std::shared_ptr<BackingStore> backing_store = ab->GetBackingStore();
+  *byte_length = backing_store->ByteLength();
+  *store = static_cast<char*>(backing_store->Data());
   CHECK_NOT_NULL(*store);
   return UVWASI_ESUCCESS;
 }
@@ -1675,9 +1678,7 @@ static void Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> tmpl = env->NewFunctionTemplate(WASI::New);
-  auto wasi_wrap_string = FIXED_ONE_BYTE_STRING(env->isolate(), "WASI");
   tmpl->InstanceTemplate()->SetInternalFieldCount(WASI::kInternalFieldCount);
-  tmpl->SetClassName(wasi_wrap_string);
   tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
 
   env->SetProtoMethod(tmpl, "args_get", WASI::ArgsGet);
@@ -1730,9 +1731,7 @@ static void Initialize(Local<Object> target,
 
   env->SetInstanceMethod(tmpl, "_setMemory", WASI::_SetMemory);
 
-  target->Set(env->context(),
-              wasi_wrap_string,
-              tmpl->GetFunction(context).ToLocalChecked()).ToChecked();
+  env->SetConstructorFunction(target, "WASI", tmpl);
 }
 
 
diff --git a/src/node_watchdog.cc b/src/node_watchdog.cc
index 3ed390678962890d90d385cf2bca9deaca023c89..ff2a02290871381e56321bf0218122169ffb799f 100644
--- a/src/node_watchdog.cc
+++ b/src/node_watchdog.cc
@@ -124,19 +124,12 @@ void TraceSigintWatchdog::Init(Environment* env, Local<Object> target) {
   Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
   constructor->InstanceTemplate()->SetInternalFieldCount(
       TraceSigintWatchdog::kInternalFieldCount);
-  Local<v8::String> js_sigint_watch_dog =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "TraceSigintWatchdog");
-  constructor->SetClassName(js_sigint_watch_dog);
   constructor->Inherit(HandleWrap::GetConstructorTemplate(env));
 
   env->SetProtoMethod(constructor, "start", Start);
   env->SetProtoMethod(constructor, "stop", Stop);
 
-  target
-      ->Set(env->context(),
-            js_sigint_watch_dog,
-            constructor->GetFunction(env->context()).ToLocalChecked())
-      .Check();
+  env->SetConstructorFunction(target, "TraceSigintWatchdog", constructor);
 }
 
 void TraceSigintWatchdog::New(const FunctionCallbackInfo<Value>& args) {
@@ -240,8 +233,9 @@ void* SigintWatchdogHelper::RunSigintWatchdog(void* arg) {
   return nullptr;
 }
 
-
-void SigintWatchdogHelper::HandleSignal(int signum) {
+void SigintWatchdogHelper::HandleSignal(int signum,
+                                        siginfo_t* info,
+                                        void* ucontext) {
   uv_sem_post(&instance.sem_);
 }
 
diff --git a/src/node_watchdog.h b/src/node_watchdog.h
index eb99c3b72a516b9ea7f4da05e5a9fe254179c8bb..8bccfceef3c52143f3a1beb75546c620c82f9476 100644
--- a/src/node_watchdog.h
+++ b/src/node_watchdog.h
@@ -138,7 +138,7 @@ class SigintWatchdogHelper {
   bool stopping_;
 
   static void* RunSigintWatchdog(void* arg);
-  static void HandleSignal(int signum);
+  static void HandleSignal(int signum, siginfo_t* info, void* ucontext);
 #else
   bool watchdog_disabled_;
   static BOOL WINAPI WinCtrlCHandlerRoutine(DWORD dwCtrlType);
diff --git a/src/node_win32_etw_provider-inl.h b/src/node_win32_etw_provider-inl.h
index a7846f413a204cb63f8540b9a5912d09caecfe02..9238ea22a3a179cf95fc8b6db48a71996411f4ae 100644
--- a/src/node_win32_etw_provider-inl.h
+++ b/src/node_win32_etw_provider-inl.h
@@ -111,13 +111,12 @@ extern int events_enabled;
                              dataDescriptors);                                \
   CHECK_EQ(status, ERROR_SUCCESS);
 
-#define ETW_WRITE_EMPTY_EVENT(eventDescriptor)                                \
-  DWORD status = event_write(node_provider,                                   \
-                             &eventDescriptor,                                \
-                             0,                                               \
-                             NULL);  // NOLINT (readability/null_usage)       \
-  CHECK_EQ(status, ERROR_SUCCESS);
+// NOLINTNEXTLINE (readability/null_usage)
+#define NULL_NOLINT NULL
 
+#define ETW_WRITE_EMPTY_EVENT(eventDescriptor)                                 \
+  DWORD status = event_write(node_provider, &eventDescriptor, 0, NULL_NOLINT); \
+  CHECK_EQ(status, ERROR_SUCCESS);
 
 void NODE_HTTP_SERVER_REQUEST(node_dtrace_http_server_request_t* req,
     node_dtrace_connection_t* conn, const char* remote, int port,
@@ -271,6 +270,8 @@ void NODE_V8SYMBOL_ADD(LPCSTR symbol,
 }
 #undef SETSYMBUF
 
+#undef NULL_NOLINT
+
 
 bool NODE_HTTP_SERVER_REQUEST_ENABLED() { return events_enabled > 0; }
 bool NODE_HTTP_SERVER_RESPONSE_ENABLED() { return events_enabled > 0; }
diff --git a/src/node_worker.cc b/src/node_worker.cc
index bda7351d3e8fa0e3047aa6d82d531c7259284575..600b888d415e1c6068134dce78e8b0b15ae36714 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -1,5 +1,6 @@
 #include "node_worker.h"
 #include "debug_utils-inl.h"
+#include "histogram-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_errors.h"
 #include "node_buffer.h"
@@ -51,7 +52,6 @@ Worker::Worker(Environment* env,
       per_isolate_opts_(per_isolate_opts),
       exec_argv_(exec_argv),
       platform_(env->isolate_data()->platform()),
-      array_buffer_allocator_(ArrayBufferAllocator::Create()),
       thread_id_(AllocateEnvironmentThreadId()),
       env_vars_(env_vars) {
   Debug(this, "Creating new worker instance with thread id %llu",
@@ -93,10 +93,6 @@ bool Worker::is_stopped() const {
   return stopped_;
 }
 
-std::shared_ptr<ArrayBufferAllocator> Worker::array_buffer_allocator() {
-  return array_buffer_allocator_;
-}
-
 void Worker::UpdateResourceConstraints(ResourceConstraints* constraints) {
   constraints->set_stack_limit(reinterpret_cast<uint32_t*>(stack_base_));
 
@@ -142,9 +138,11 @@ class WorkerThreadData {
     loop_init_failed_ = false;
     uv_loop_configure(&loop_, UV_METRICS_IDLE_TIME);
 
+    std::shared_ptr<ArrayBufferAllocator> allocator =
+        ArrayBufferAllocator::Create();
     Isolate::CreateParams params;
     SetIsolateCreateParamsForNode(&params);
-    params.array_buffer_allocator = w->array_buffer_allocator_.get();
+    params.array_buffer_allocator_shared = allocator;
 
     w->UpdateResourceConstraints(&params.constraints);
 
@@ -160,6 +158,9 @@ class WorkerThreadData {
     Isolate::Initialize(isolate, params);
     SetIsolateUpForNode(isolate);
 
+    // Be sure it's called before Environment::InitializeDiagnostics()
+    // so that this callback stays when the callback of
+    // --heapsnapshot-near-heap-limit gets is popped.
     isolate->AddNearHeapLimitCallback(Worker::NearHeapLimit, w);
 
     {
@@ -173,11 +174,13 @@ class WorkerThreadData {
       isolate_data_.reset(CreateIsolateData(isolate,
                                             &loop_,
                                             w_->platform_,
-                                            w->array_buffer_allocator_.get()));
+                                            allocator.get()));
       CHECK(isolate_data_);
       if (w_->per_isolate_opts_)
         isolate_data_->set_options(std::move(w_->per_isolate_opts_));
       isolate_data_->set_worker_context(w_);
+      isolate_data_->max_young_gen_size =
+          params.constraints.max_young_generation_size_in_bytes();
     }
 
     Mutex::ScopedLock lock(w_->mutex_);
@@ -331,7 +334,10 @@ void Worker::Run() {
       Debug(this, "Created Environment for worker with id %llu", thread_id_.id);
       if (is_stopped()) return;
       {
-        CreateEnvMessagePort(env_.get());
+        if (!CreateEnvMessagePort(env_.get())) {
+          return;
+        }
+
         Debug(this, "Created message port for worker %llu", thread_id_.id);
         if (LoadEnvironment(env_.get(), StartExecutionCallback{}).IsEmpty())
           return;
@@ -355,7 +361,8 @@ void Worker::Run() {
           more = uv_loop_alive(&data.loop_);
           if (more && !is_stopped()) continue;
 
-          EmitBeforeExit(env_.get());
+          if (EmitProcessBeforeExit(env_.get()).IsNothing())
+            break;
 
           // Emit `beforeExit` if the loop became alive either after emitting
           // event, or after running some callbacks.
@@ -369,8 +376,10 @@ void Worker::Run() {
     {
       int exit_code;
       bool stopped = is_stopped();
-      if (!stopped)
-        exit_code = EmitExit(env_.get());
+      if (!stopped) {
+        env_->VerifyNoStrongBaseObjects();
+        exit_code = EmitProcessExit(env_.get()).FromMaybe(1);
+      }
       Mutex::ScopedLock lock(mutex_);
       if (exit_code_ == 0 && !stopped)
         exit_code_ = exit_code;
@@ -383,17 +392,24 @@ void Worker::Run() {
   Debug(this, "Worker %llu thread stops", thread_id_.id);
 }
 
-void Worker::CreateEnvMessagePort(Environment* env) {
+bool Worker::CreateEnvMessagePort(Environment* env) {
   HandleScope handle_scope(isolate_);
-  Mutex::ScopedLock lock(mutex_);
+  std::unique_ptr<MessagePortData> data;
+  {
+    Mutex::ScopedLock lock(mutex_);
+    data = std::move(child_port_data_);
+  }
+
   // Set up the message channel for receiving messages in the child.
   MessagePort* child_port = MessagePort::New(env,
                                              env->context(),
-                                             std::move(child_port_data_));
+                                             std::move(data));
   // MessagePort::New() may return nullptr if execution is terminated
   // within it.
   if (child_port != nullptr)
     env->set_message_port(child_port->object(isolate_));
+
+  return child_port;
 }
 
 void Worker::JoinThread() {
@@ -589,6 +605,8 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[4]->IsBoolean());
   if (args[4]->IsTrue() || env->tracks_unmanaged_fds())
     worker->environment_flags_ |= EnvironmentFlags::kTrackUnmanagedFds;
+  if (env->hide_console_windows())
+    worker->environment_flags_ |= EnvironmentFlags::kHideConsoleWindows;
 }
 
 void Worker::StartThread(const FunctionCallbackInfo<Value>& args) {
@@ -692,7 +710,10 @@ void Worker::GetResourceLimits(const FunctionCallbackInfo<Value>& args) {
 
 Local<Float64Array> Worker::GetResourceLimits(Isolate* isolate) const {
   Local<ArrayBuffer> ab = ArrayBuffer::New(isolate, sizeof(resource_limits_));
-  memcpy(ab->GetContents().Data(), resource_limits_, sizeof(resource_limits_));
+
+  memcpy(ab->GetBackingStore()->Data(),
+         resource_limits_,
+         sizeof(resource_limits_));
   return Float64Array::New(ab, 0, kTotalResourceLimitCount);
 }
 
@@ -718,6 +739,12 @@ void Worker::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("parent_port", parent_port_);
 }
 
+bool Worker::IsNotIndicativeOfMemoryLeakAtExit() const {
+  // Worker objects always stay alive as long as the child thread, regardless
+  // of whether they are being referenced in the parent thread.
+  return true;
+}
+
 class WorkerHeapSnapshotTaker : public AsyncWrap {
  public:
   WorkerHeapSnapshotTaker(Environment* env, Local<Object> obj)
@@ -834,12 +861,7 @@ void InitWorker(Local<Object> target,
     env->SetProtoMethod(w, "loopIdleTime", Worker::LoopIdleTime);
     env->SetProtoMethod(w, "loopStartTime", Worker::LoopStartTime);
 
-    Local<String> workerString =
-        FIXED_ONE_BYTE_STRING(env->isolate(), "Worker");
-    w->SetClassName(workerString);
-    target->Set(env->context(),
-                workerString,
-                w->GetFunction(env->context()).ToLocalChecked()).Check();
+    env->SetConstructorFunction(target, "Worker", w);
   }
 
   {
diff --git a/src/node_worker.h b/src/node_worker.h
index 253ffdc48448189425ea0a95bc2e12d646fb52da..077d2b8390e6f8b29957577ee5d31ea2e1827cb4 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -50,9 +50,9 @@ class Worker : public AsyncWrap {
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Worker)
   SET_SELF_SIZE(Worker)
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override;
 
   bool is_stopped() const;
-  std::shared_ptr<ArrayBufferAllocator> array_buffer_allocator();
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void CloneParentEnvVars(
@@ -70,7 +70,7 @@ class Worker : public AsyncWrap {
   static void LoopStartTime(const v8::FunctionCallbackInfo<v8::Value>& args);
 
  private:
-  void CreateEnvMessagePort(Environment* env);
+  bool CreateEnvMessagePort(Environment* env);
   static size_t NearHeapLimit(void* data, size_t current_heap_limit,
                               size_t initial_heap_limit);
 
@@ -79,7 +79,6 @@ class Worker : public AsyncWrap {
   std::vector<std::string> argv_;
 
   MultiIsolatePlatform* platform_;
-  std::shared_ptr<ArrayBufferAllocator> array_buffer_allocator_;
   v8::Isolate* isolate_ = nullptr;
   uv_thread_t tid_;
 
diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index ddf658cc63e786aeaf4ad112e77b16b6fac22775..b8733229b0b06b8986fe3ab30f15d9c9c2b0f89c 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -54,7 +54,6 @@ using v8::Int32;
 using v8::Integer;
 using v8::Local;
 using v8::Object;
-using v8::String;
 using v8::Uint32Array;
 using v8::Value;
 
@@ -72,6 +71,9 @@ namespace {
 #define Z_MIN_LEVEL -1
 #define Z_MAX_LEVEL 9
 #define Z_DEFAULT_LEVEL Z_DEFAULT_COMPRESSION
+#define Z_MIN_WINDOWBITS 8
+#define Z_MAX_WINDOWBITS 15
+#define Z_DEFAULT_WINDOWBITS 15
 
 #define ZLIB_ERROR_CODES(V)      \
   V(Z_OK)                        \
@@ -598,7 +600,8 @@ class ZlibStream : public CompressionStream<ZlibContext> {
     CHECK(args[4]->IsUint32Array());
     Local<Uint32Array> array = args[4].As<Uint32Array>();
     Local<ArrayBuffer> ab = array->Buffer();
-    uint32_t* write_result = static_cast<uint32_t*>(ab->GetContents().Data());
+    uint32_t* write_result = static_cast<uint32_t*>(
+        ab->GetBackingStore()->Data());
 
     CHECK(args[5]->IsFunction());
     Local<Function> write_js_callback = args[5].As<Function>();
@@ -1261,11 +1264,7 @@ struct MakeClass {
     env->SetProtoMethod(z, "params", Stream::Params);
     env->SetProtoMethod(z, "reset", Stream::Reset);
 
-    Local<String> zlibString = OneByteString(env->isolate(), name);
-    z->SetClassName(zlibString);
-    target->Set(env->context(),
-                zlibString,
-                z->GetFunction(env->context()).ToLocalChecked()).Check();
+    env->SetConstructorFunction(target, name, z);
   }
 };
 
diff --git a/src/pipe_wrap.cc b/src/pipe_wrap.cc
index 1396395463dfeda5f6d3eb8a8ca7d0038172241d..7ec3c66a78bb95bca2c2c8ea7608c0b9f03f0c97 100644
--- a/src/pipe_wrap.cc
+++ b/src/pipe_wrap.cc
@@ -43,7 +43,6 @@ using v8::Int32;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Object;
-using v8::String;
 using v8::Value;
 
 MaybeLocal<Object> PipeWrap::Instantiate(Environment* env,
@@ -69,8 +68,6 @@ void PipeWrap::Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  Local<String> pipeString = FIXED_ONE_BYTE_STRING(env->isolate(), "Pipe");
-  t->SetClassName(pipeString);
   t->InstanceTemplate()
     ->SetInternalFieldCount(StreamBase::kInternalFieldCount);
 
@@ -87,20 +84,13 @@ void PipeWrap::Initialize(Local<Object> target,
 
   env->SetProtoMethod(t, "fchmod", Fchmod);
 
-  target->Set(env->context(),
-              pipeString,
-              t->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "Pipe", t);
   env->set_pipe_constructor_template(t);
 
   // Create FunctionTemplate for PipeConnectWrap.
   auto cwt = BaseObject::MakeLazilyInitializedJSTemplate(env);
   cwt->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  Local<String> wrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "PipeConnectWrap");
-  cwt->SetClassName(wrapString);
-  target->Set(env->context(),
-              wrapString,
-              cwt->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "PipeConnectWrap", cwt);
 
   // Define constants
   Local<Object> constants = Object::New(env->isolate());
diff --git a/src/process_wrap.cc b/src/process_wrap.cc
index 3d1065c9922183f691d3498c4e1ab0825867c1b8..679429286b89071d66322bfc248fe16c2b5b91b1 100644
--- a/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@ -54,18 +54,13 @@ class ProcessWrap : public HandleWrap {
     Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
     constructor->InstanceTemplate()->SetInternalFieldCount(
         ProcessWrap::kInternalFieldCount);
-    Local<String> processString =
-        FIXED_ONE_BYTE_STRING(env->isolate(), "Process");
-    constructor->SetClassName(processString);
 
     constructor->Inherit(HandleWrap::GetConstructorTemplate(env));
 
     env->SetProtoMethod(constructor, "spawn", Spawn);
     env->SetProtoMethod(constructor, "kill", Kill);
 
-    target->Set(env->context(),
-                processString,
-                constructor->GetFunction(context).ToLocalChecked()).Check();
+    env->SetConstructorFunction(target, "Process", constructor);
   }
 
   SET_NO_MEMORY_INFO()
@@ -125,6 +120,11 @@ class ProcessWrap : public HandleWrap {
         options->stdio[i].flags = static_cast<uv_stdio_flags>(
             UV_CREATE_PIPE | UV_READABLE_PIPE | UV_WRITABLE_PIPE);
         options->stdio[i].data.stream = StreamForWrap(env, stdio);
+      } else if (type->StrictEquals(env->overlapped_string())) {
+        options->stdio[i].flags = static_cast<uv_stdio_flags>(
+            UV_CREATE_PIPE | UV_READABLE_PIPE | UV_WRITABLE_PIPE |
+            UV_OVERLAPPED_PIPE);
+        options->stdio[i].data.stream = StreamForWrap(env, stdio);
       } else if (type->StrictEquals(env->wrap_string())) {
         options->stdio[i].flags = UV_INHERIT_STREAM;
         options->stdio[i].data.stream = StreamForWrap(env, stdio);
@@ -238,6 +238,10 @@ class ProcessWrap : public HandleWrap {
       options.flags |= UV_PROCESS_WINDOWS_HIDE;
     }
 
+    if (env->hide_console_windows()) {
+      options.flags |= UV_PROCESS_WINDOWS_HIDE_CONSOLE;
+    }
+
     // options.windows_verbatim_arguments
     Local<Value> wva_v =
         js_options->Get(context, env->windows_verbatim_arguments_string())
diff --git a/src/res/node.ico b/src/res/node.ico
deleted file mode 100644
index f74a07430f3c5a1af35fb2305f62a4925ddc068e..0000000000000000000000000000000000000000
Binary files a/src/res/node.ico and /dev/null differ
diff --git a/src/res/node.rc b/src/res/node.rc
index 9403e68be70aca24f7d55c79da77786f0fc3c5e7..7af45a03c229b2dfbde2755d905b2306f911080d 100644
--- a/src/res/node.rc
+++ b/src/res/node.rc
@@ -52,7 +52,7 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "Node.js"
             VALUE "ProductName", "Node.js"
-            VALUE "FileDescription", "Node.js: Server-side JavaScript"
+            VALUE "FileDescription", "Node.js JavaScript Runtime"
             VALUE "FileVersion", NODE_EXE_VERSION
             VALUE "ProductVersion", NODE_EXE_VERSION
             VALUE "OriginalFilename", "node.exe"
diff --git a/src/sharedarraybuffer_metadata.cc b/src/sharedarraybuffer_metadata.cc
deleted file mode 100644
index fc3bcdf3d3b6b78319c0110ef7981bca1b067dd9..0000000000000000000000000000000000000000
--- a/src/sharedarraybuffer_metadata.cc
+++ /dev/null
@@ -1,175 +0,0 @@
-#include "sharedarraybuffer_metadata.h"
-
-#include "base_object-inl.h"
-#include "memory_tracker-inl.h"
-#include "node_errors.h"
-#include "node_worker.h"
-#include "util-inl.h"
-
-#include <utility>
-
-using v8::Context;
-using v8::Function;
-using v8::FunctionTemplate;
-using v8::Local;
-using v8::Maybe;
-using v8::MaybeLocal;
-using v8::Nothing;
-using v8::Object;
-using v8::SharedArrayBuffer;
-using v8::Value;
-
-namespace node {
-namespace worker {
-
-namespace {
-
-// Yield a JS constructor for SABLifetimePartner objects in the form of a
-// standard API object, that has a single field for containing the raw
-// SABLifetimePartner* pointer.
-Local<Function> GetSABLifetimePartnerConstructor(
-    Environment* env, Local<Context> context) {
-  Local<FunctionTemplate> templ;
-  templ = env->sab_lifetimepartner_constructor_template();
-  if (!templ.IsEmpty())
-    return templ->GetFunction(context).ToLocalChecked();
-
-  templ = BaseObject::MakeLazilyInitializedJSTemplate(env);
-  templ->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(),
-                                            "SABLifetimePartner"));
-  env->set_sab_lifetimepartner_constructor_template(templ);
-
-  return GetSABLifetimePartnerConstructor(env, context);
-}
-
-class SABLifetimePartner : public BaseObject {
- public:
-  SABLifetimePartner(Environment* env,
-                     Local<Object> obj,
-                     SharedArrayBufferMetadataReference r)
-    : BaseObject(env, obj),
-      reference(std::move(r)) {
-    MakeWeak();
-    env->AddCleanupHook(CleanupHook, static_cast<void*>(this));
-  }
-
-  ~SABLifetimePartner() {
-    env()->RemoveCleanupHook(CleanupHook, static_cast<void*>(this));
-  }
-
-  static void CleanupHook(void* data) {
-    // There is another cleanup hook attached to this object because it is a
-    // BaseObject. Cleanup hooks are triggered in reverse order of addition,
-    // so if this object is destroyed through GC, the destructor removes all
-    // hooks associated with this object, meaning that this cleanup hook
-    // only runs at the end of the Environment’s lifetime.
-    // In that case, V8 still knows about the SharedArrayBuffer and tries to
-    // free it when the last Isolate with access to it is disposed; for that,
-    // the ArrayBuffer::Allocator needs to be kept alive longer than this
-    // object and longer than the Environment instance.
-    //
-    // This is a workaround for https://github.com/nodejs/node-v8/issues/115
-    // (introduced in V8 7.9) and we should be able to remove it once V8
-    // ArrayBuffer::Allocator refactoring/removal is complete.
-    SABLifetimePartner* self = static_cast<SABLifetimePartner*>(data);
-    self->env()->AddArrayBufferAllocatorToKeepAliveUntilIsolateDispose(
-        self->reference->allocator());
-  }
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(SABLifetimePartner)
-  SET_SELF_SIZE(SABLifetimePartner)
-
-  SharedArrayBufferMetadataReference reference;
-};
-
-}  // anonymous namespace
-
-SharedArrayBufferMetadataReference
-SharedArrayBufferMetadata::ForSharedArrayBuffer(
-    Environment* env,
-    Local<Context> context,
-    Local<SharedArrayBuffer> source) {
-  Local<Value> lifetime_partner;
-
-  if (!source->GetPrivate(context,
-                          env->sab_lifetimepartner_symbol())
-                              .ToLocal(&lifetime_partner)) {
-    return nullptr;
-  }
-
-  if (lifetime_partner->IsObject() &&
-      env->sab_lifetimepartner_constructor_template()
-         ->HasInstance(lifetime_partner)) {
-    CHECK(source->IsExternal());
-    SABLifetimePartner* partner =
-        Unwrap<SABLifetimePartner>(lifetime_partner.As<Object>());
-    CHECK_NOT_NULL(partner);
-    return partner->reference;
-  }
-
-  if (source->IsExternal()) {
-    // If this is an external SharedArrayBuffer but we do not see a lifetime
-    // partner object, it was not us who externalized it. In that case, there
-    // is no way to serialize it, because it's unclear how the memory
-    // is actually owned.
-    THROW_ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER(env);
-    return nullptr;
-  }
-
-  // If the SharedArrayBuffer is coming from a Worker, we need to make sure
-  // that the corresponding ArrayBuffer::Allocator lives at least as long as
-  // the SharedArrayBuffer itself.
-  worker::Worker* w = env->worker_context();
-  std::shared_ptr<v8::ArrayBuffer::Allocator> allocator =
-      w != nullptr ? w->array_buffer_allocator() : nullptr;
-
-  SharedArrayBuffer::Contents contents = source->Externalize();
-  SharedArrayBufferMetadataReference r(
-      new SharedArrayBufferMetadata(contents, allocator));
-  if (r->AssignToSharedArrayBuffer(env, context, source).IsNothing())
-    return nullptr;
-  return r;
-}
-
-Maybe<bool> SharedArrayBufferMetadata::AssignToSharedArrayBuffer(
-    Environment* env, Local<Context> context,
-    Local<SharedArrayBuffer> target) {
-  CHECK(target->IsExternal());
-  Local<Function> ctor = GetSABLifetimePartnerConstructor(env, context);
-  Local<Object> obj;
-  if (!ctor->NewInstance(context).ToLocal(&obj))
-    return Nothing<bool>();
-
-  new SABLifetimePartner(env, obj, shared_from_this());
-  return target->SetPrivate(context,
-                            env->sab_lifetimepartner_symbol(),
-                            obj);
-}
-
-SharedArrayBufferMetadata::SharedArrayBufferMetadata(
-    const SharedArrayBuffer::Contents& contents,
-    std::shared_ptr<v8::ArrayBuffer::Allocator> allocator)
-  : contents_(contents), allocator_(allocator) { }
-
-SharedArrayBufferMetadata::~SharedArrayBufferMetadata() {
-  contents_.Deleter()(contents_.Data(),
-                      contents_.ByteLength(),
-                      contents_.DeleterData());
-}
-
-MaybeLocal<SharedArrayBuffer> SharedArrayBufferMetadata::GetSharedArrayBuffer(
-    Environment* env, Local<Context> context) {
-  Local<SharedArrayBuffer> obj =
-      SharedArrayBuffer::New(env->isolate(),
-                             contents_.Data(),
-                             contents_.ByteLength());
-
-  if (AssignToSharedArrayBuffer(env, context, obj).IsNothing())
-    return MaybeLocal<SharedArrayBuffer>();
-
-  return obj;
-}
-
-}  // namespace worker
-}  // namespace node
diff --git a/src/sharedarraybuffer_metadata.h b/src/sharedarraybuffer_metadata.h
deleted file mode 100644
index 4d89f08ee10daf79dd9f35be5503e9aac16ac92f..0000000000000000000000000000000000000000
--- a/src/sharedarraybuffer_metadata.h
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef SRC_SHAREDARRAYBUFFER_METADATA_H_
-#define SRC_SHAREDARRAYBUFFER_METADATA_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-#include <memory>
-
-namespace node {
-namespace worker {
-
-class SharedArrayBufferMetadata;
-
-// This is an object associated with a SharedArrayBuffer, which keeps track
-// of a cross-thread reference count. Once a SharedArrayBuffer is transferred
-// for the first time (or is attempted to be transferred), one of these objects
-// is created, and the SharedArrayBuffer is moved from internalized mode into
-// externalized mode (i.e. the JS engine no longer frees the memory on its own).
-//
-// This will always be referred to using a std::shared_ptr, since it keeps
-// a reference count and is guaranteed to be thread-safe.
-typedef std::shared_ptr<SharedArrayBufferMetadata>
-    SharedArrayBufferMetadataReference;
-
-class SharedArrayBufferMetadata
-    : public std::enable_shared_from_this<SharedArrayBufferMetadata> {
- public:
-  static SharedArrayBufferMetadataReference ForSharedArrayBuffer(
-      Environment* env,
-      v8::Local<v8::Context> context,
-      v8::Local<v8::SharedArrayBuffer> source);
-  ~SharedArrayBufferMetadata();
-
-  // Create a SharedArrayBuffer object for a specific Environment and Context.
-  // The created SharedArrayBuffer will be in externalized mode and has
-  // a hidden object attached to it, during whose lifetime the reference
-  // count is increased by 1.
-  v8::MaybeLocal<v8::SharedArrayBuffer> GetSharedArrayBuffer(
-      Environment* env, v8::Local<v8::Context> context);
-  std::shared_ptr<v8::ArrayBuffer::Allocator> allocator() const {
-    return allocator_;
-  }
-
-  SharedArrayBufferMetadata(SharedArrayBufferMetadata&& other) = delete;
-  SharedArrayBufferMetadata& operator=(
-      SharedArrayBufferMetadata&& other) = delete;
-  SharedArrayBufferMetadata& operator=(
-      const SharedArrayBufferMetadata&) = delete;
-  SharedArrayBufferMetadata(const SharedArrayBufferMetadata&) = delete;
-
- private:
-  SharedArrayBufferMetadata(
-      const v8::SharedArrayBuffer::Contents&,
-      std::shared_ptr<v8::ArrayBuffer::Allocator>);
-
-  // Attach a lifetime tracker object with a reference count to `target`.
-  v8::Maybe<bool> AssignToSharedArrayBuffer(
-      Environment* env,
-      v8::Local<v8::Context> context,
-      v8::Local<v8::SharedArrayBuffer> target);
-
-  v8::SharedArrayBuffer::Contents contents_;
-  std::shared_ptr<v8::ArrayBuffer::Allocator> allocator_;
-};
-
-}  // namespace worker
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-
-#endif  // SRC_SHAREDARRAYBUFFER_METADATA_H_
diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
index 2be7ac9834100b035170015f6171bff492ea99ab..e8a1500d2e996145b2893d8b9d207a84a847b044 100644
--- a/src/signal_wrap.cc
+++ b/src/signal_wrap.cc
@@ -22,7 +22,7 @@
 #include "async_wrap-inl.h"
 #include "env-inl.h"
 #include "handle_wrap.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 #include "util-inl.h"
 #include "v8.h"
 
@@ -35,7 +35,6 @@ using v8::HandleScope;
 using v8::Integer;
 using v8::Local;
 using v8::Object;
-using v8::String;
 using v8::Value;
 
 void DecreaseSignalHandlerCount(int signum);
@@ -55,17 +54,12 @@ class SignalWrap : public HandleWrap {
     Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
     constructor->InstanceTemplate()->SetInternalFieldCount(
         SignalWrap::kInternalFieldCount);
-    Local<String> signalString =
-        FIXED_ONE_BYTE_STRING(env->isolate(), "Signal");
-    constructor->SetClassName(signalString);
     constructor->Inherit(HandleWrap::GetConstructorTemplate(env));
 
     env->SetProtoMethod(constructor, "start", Start);
     env->SetProtoMethod(constructor, "stop", Stop);
 
-    target->Set(env->context(), signalString,
-                constructor->GetFunction(env->context()).ToLocalChecked())
-                .Check();
+    env->SetConstructorFunction(target, "Signal", constructor);
   }
 
   SET_NO_MEMORY_INFO()
@@ -159,7 +153,7 @@ class SignalWrap : public HandleWrap {
 
 void DecreaseSignalHandlerCount(int signum) {
   Mutex::ScopedLock lock(handled_signals_mutex);
-  int new_handler_count = --handled_signals[signum];
+  int64_t new_handler_count = --handled_signals[signum];
   CHECK_GE(new_handler_count, 0);
   if (new_handler_count == 0)
     handled_signals.erase(signum);
diff --git a/src/spawn_sync.cc b/src/spawn_sync.cc
index db5a66bc54cc5449a85c26102721ce1514bc1555..1141aceae984fba6ed07cd272a79d4007b9b03fe 100644
--- a/src/spawn_sync.cc
+++ b/src/spawn_sync.cc
@@ -703,8 +703,7 @@ Local<Object> SyncProcessRunner::BuildResultObject() {
   if (term_signal_ > 0)
     js_result->Set(context, env()->signal_string(),
                    String::NewFromUtf8(env()->isolate(),
-                                       signo_string(term_signal_),
-                                       v8::NewStringType::kNormal)
+                                       signo_string(term_signal_))
                        .ToLocalChecked())
         .Check();
   else
diff --git a/src/stream_base-inl.h b/src/stream_base-inl.h
index 1603a2fb2e013cb26463108fc5664499b8e62c5a..28b0b209922cc2c6f1c975ca52e2b5dd7174ba52 100644
--- a/src/stream_base-inl.h
+++ b/src/stream_base-inl.h
@@ -3,6 +3,7 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
 #include "base_object-inl.h"
 #include "node.h"
@@ -11,18 +12,13 @@
 
 namespace node {
 
-using v8::Signature;
-using v8::FunctionCallbackInfo;
-using v8::FunctionTemplate;
-using v8::HandleScope;
-using v8::Local;
-using v8::Object;
-using v8::PropertyAttribute;
-using v8::PropertyCallbackInfo;
-using v8::String;
-using v8::Value;
-
-inline void StreamReq::AttachToObject(v8::Local<v8::Object> req_wrap_obj) {
+StreamReq::StreamReq(
+    StreamBase* stream,
+    v8::Local<v8::Object> req_wrap_obj) : stream_(stream) {
+  AttachToObject(req_wrap_obj);
+}
+
+void StreamReq::AttachToObject(v8::Local<v8::Object> req_wrap_obj) {
   CHECK_EQ(req_wrap_obj->GetAlignedPointerFromInternalField(
                StreamReq::kStreamReqField),
            nullptr);
@@ -30,57 +26,39 @@ inline void StreamReq::AttachToObject(v8::Local<v8::Object> req_wrap_obj) {
       StreamReq::kStreamReqField, this);
 }
 
-inline StreamReq* StreamReq::FromObject(v8::Local<v8::Object> req_wrap_obj) {
+StreamReq* StreamReq::FromObject(v8::Local<v8::Object> req_wrap_obj) {
   return static_cast<StreamReq*>(
       req_wrap_obj->GetAlignedPointerFromInternalField(
           StreamReq::kStreamReqField));
 }
 
-inline void StreamReq::Dispose() {
+void StreamReq::Dispose() {
   BaseObjectPtr<AsyncWrap> destroy_me{GetAsyncWrap()};
   object()->SetAlignedPointerInInternalField(
       StreamReq::kStreamReqField, nullptr);
   destroy_me->Detach();
 }
 
-inline v8::Local<v8::Object> StreamReq::object() {
+v8::Local<v8::Object> StreamReq::object() {
   return GetAsyncWrap()->object();
 }
 
-inline StreamListener::~StreamListener() {
-  if (stream_ != nullptr)
-    stream_->RemoveStreamListener(this);
-}
-
-inline void StreamListener::PassReadErrorToPreviousListener(ssize_t nread) {
-  CHECK_NOT_NULL(previous_listener_);
-  previous_listener_->OnStreamRead(nread, uv_buf_init(nullptr, 0));
-}
+ShutdownWrap::ShutdownWrap(
+    StreamBase* stream,
+    v8::Local<v8::Object> req_wrap_obj)
+    : StreamReq(stream, req_wrap_obj) { }
 
-inline void StreamListener::OnStreamAfterShutdown(ShutdownWrap* w, int status) {
-  CHECK_NOT_NULL(previous_listener_);
-  previous_listener_->OnStreamAfterShutdown(w, status);
-}
+WriteWrap::WriteWrap(
+    StreamBase* stream,
+    v8::Local<v8::Object> req_wrap_obj)
+    : StreamReq(stream, req_wrap_obj) { }
 
-inline void StreamListener::OnStreamAfterWrite(WriteWrap* w, int status) {
+void StreamListener::PassReadErrorToPreviousListener(ssize_t nread) {
   CHECK_NOT_NULL(previous_listener_);
-  previous_listener_->OnStreamAfterWrite(w, status);
-}
-
-inline StreamResource::~StreamResource() {
-  while (listener_ != nullptr) {
-    StreamListener* listener = listener_;
-    listener->OnStreamDestroy();
-    // Remove the listener if it didn’t remove itself. This makes the logic
-    // in `OnStreamDestroy()` implementations easier, because they
-    // may call generic cleanup functions which can just remove the
-    // listener unconditionally.
-    if (listener == listener_)
-      RemoveStreamListener(listener_);
-  }
+  previous_listener_->OnStreamRead(nread, uv_buf_init(nullptr, 0));
 }
 
-inline void StreamResource::PushStreamListener(StreamListener* listener) {
+void StreamResource::PushStreamListener(StreamListener* listener) {
   CHECK_NOT_NULL(listener);
   CHECK_NULL(listener->stream_);
 
@@ -90,7 +68,7 @@ inline void StreamResource::PushStreamListener(StreamListener* listener) {
   listener_ = listener;
 }
 
-inline void StreamResource::RemoveStreamListener(StreamListener* listener) {
+void StreamResource::RemoveStreamListener(StreamListener* listener) {
   CHECK_NOT_NULL(listener);
 
   StreamListener* previous;
@@ -114,45 +92,41 @@ inline void StreamResource::RemoveStreamListener(StreamListener* listener) {
   listener->previous_listener_ = nullptr;
 }
 
-inline uv_buf_t StreamResource::EmitAlloc(size_t suggested_size) {
+uv_buf_t StreamResource::EmitAlloc(size_t suggested_size) {
   DebugSealHandleScope seal_handle_scope;
   return listener_->OnStreamAlloc(suggested_size);
 }
 
-inline void StreamResource::EmitRead(ssize_t nread, const uv_buf_t& buf) {
+void StreamResource::EmitRead(ssize_t nread, const uv_buf_t& buf) {
   DebugSealHandleScope seal_handle_scope;
   if (nread > 0)
     bytes_read_ += static_cast<uint64_t>(nread);
   listener_->OnStreamRead(nread, buf);
 }
 
-inline void StreamResource::EmitAfterWrite(WriteWrap* w, int status) {
+void StreamResource::EmitAfterWrite(WriteWrap* w, int status) {
   DebugSealHandleScope seal_handle_scope;
   listener_->OnStreamAfterWrite(w, status);
 }
 
-inline void StreamResource::EmitAfterShutdown(ShutdownWrap* w, int status) {
+void StreamResource::EmitAfterShutdown(ShutdownWrap* w, int status) {
   DebugSealHandleScope seal_handle_scope;
   listener_->OnStreamAfterShutdown(w, status);
 }
 
-inline void StreamResource::EmitWantsWrite(size_t suggested_size) {
+void StreamResource::EmitWantsWrite(size_t suggested_size) {
   DebugSealHandleScope seal_handle_scope;
   listener_->OnStreamWantsWrite(suggested_size);
 }
 
-inline StreamBase::StreamBase(Environment* env) : env_(env) {
+StreamBase::StreamBase(Environment* env) : env_(env) {
   PushStreamListener(&default_listener_);
 }
 
-inline Environment* StreamBase::stream_env() const {
-  return env_;
-}
-
-inline int StreamBase::Shutdown(v8::Local<v8::Object> req_wrap_obj) {
+int StreamBase::Shutdown(v8::Local<v8::Object> req_wrap_obj) {
   Environment* env = stream_env();
 
-  HandleScope handle_scope(env->isolate());
+  v8::HandleScope handle_scope(env->isolate());
 
   if (req_wrap_obj.IsEmpty()) {
     if (!env->shutdown_wrap_template()
@@ -185,7 +159,7 @@ inline int StreamBase::Shutdown(v8::Local<v8::Object> req_wrap_obj) {
   return err;
 }
 
-inline StreamWriteResult StreamBase::Write(
+StreamWriteResult StreamBase::Write(
     uv_buf_t* bufs,
     size_t count,
     uv_stream_t* send_handle,
@@ -205,7 +179,7 @@ inline StreamWriteResult StreamBase::Write(
     }
   }
 
-  HandleScope handle_scope(env->isolate());
+  v8::HandleScope handle_scope(env->isolate());
 
   if (req_wrap_obj.IsEmpty()) {
     if (!env->write_wrap_template()
@@ -250,11 +224,6 @@ SimpleShutdownWrap<OtherBase>::SimpleShutdownWrap(
               AsyncWrap::PROVIDER_SHUTDOWNWRAP) {
 }
 
-inline ShutdownWrap* StreamBase::CreateShutdownWrap(
-    v8::Local<v8::Object> object) {
-  return new SimpleShutdownWrap<AsyncWrap>(this, object);
-}
-
 template <typename OtherBase>
 SimpleWriteWrap<OtherBase>::SimpleWriteWrap(
     StreamBase* stream,
@@ -265,17 +234,12 @@ SimpleWriteWrap<OtherBase>::SimpleWriteWrap(
               AsyncWrap::PROVIDER_WRITEWRAP) {
 }
 
-inline WriteWrap* StreamBase::CreateWriteWrap(
-    v8::Local<v8::Object> object) {
-  return new SimpleWriteWrap<AsyncWrap>(this, object);
-}
-
-inline void StreamBase::AttachToObject(v8::Local<v8::Object> obj) {
+void StreamBase::AttachToObject(v8::Local<v8::Object> obj) {
   obj->SetAlignedPointerInInternalField(
       StreamBase::kStreamBaseField, this);
 }
 
-inline StreamBase* StreamBase::FromObject(v8::Local<v8::Object> obj) {
+StreamBase* StreamBase::FromObject(v8::Local<v8::Object> obj) {
   if (obj->GetAlignedPointerFromInternalField(StreamBase::kSlot) == nullptr)
     return nullptr;
 
@@ -284,26 +248,38 @@ inline StreamBase* StreamBase::FromObject(v8::Local<v8::Object> obj) {
           StreamBase::kStreamBaseField));
 }
 
+WriteWrap* WriteWrap::FromObject(v8::Local<v8::Object> req_wrap_obj) {
+  return static_cast<WriteWrap*>(StreamReq::FromObject(req_wrap_obj));
+}
 
-inline void ShutdownWrap::OnDone(int status) {
-  stream()->EmitAfterShutdown(this, status);
-  Dispose();
+template <typename T, bool kIsWeak>
+WriteWrap* WriteWrap::FromObject(
+    const BaseObjectPtrImpl<T, kIsWeak>& base_obj) {
+  if (!base_obj) return nullptr;
+  return FromObject(base_obj->object());
 }
 
-inline void WriteWrap::SetAllocatedStorage(AllocatedBuffer&& storage) {
-  CHECK_NULL(storage_.data());
-  storage_ = std::move(storage);
+ShutdownWrap* ShutdownWrap::FromObject(v8::Local<v8::Object> req_wrap_obj) {
+  return static_cast<ShutdownWrap*>(StreamReq::FromObject(req_wrap_obj));
+}
+
+template <typename T, bool kIsWeak>
+ShutdownWrap* ShutdownWrap::FromObject(
+    const BaseObjectPtrImpl<T, kIsWeak>& base_obj) {
+  if (!base_obj) return nullptr;
+  return FromObject(base_obj->object());
 }
 
-inline void WriteWrap::OnDone(int status) {
-  stream()->EmitAfterWrite(this, status);
-  Dispose();
+void WriteWrap::SetAllocatedStorage(AllocatedBuffer&& storage) {
+  CHECK_NULL(storage_.data());
+  storage_ = std::move(storage);
 }
 
-inline void StreamReq::Done(int status, const char* error_str) {
+void StreamReq::Done(int status, const char* error_str) {
   AsyncWrap* async_wrap = GetAsyncWrap();
   Environment* env = async_wrap->env();
   if (error_str != nullptr) {
+    v8::HandleScope handle_scope(env->isolate());
     async_wrap->object()->Set(env->context(),
                               env->error_string(),
                               OneByteString(env->isolate(), error_str))
@@ -313,14 +289,13 @@ inline void StreamReq::Done(int status, const char* error_str) {
   OnDone(status);
 }
 
-inline void StreamReq::ResetObject(v8::Local<v8::Object> obj) {
+void StreamReq::ResetObject(v8::Local<v8::Object> obj) {
   DCHECK_GT(obj->InternalFieldCount(), StreamReq::kStreamReqField);
 
   obj->SetAlignedPointerInInternalField(StreamReq::kSlot, nullptr);
   obj->SetAlignedPointerInInternalField(StreamReq::kStreamReqField, nullptr);
 }
 
-
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/stream_base.cc b/src/stream_base.cc
index 06032e2c0969eeb5f087240438ce466f731da4b7..8e2585bf5d56ebd332527e3e2d9a53fdbccbf707 100644
--- a/src/stream_base.cc
+++ b/src/stream_base.cc
@@ -1,6 +1,7 @@
 #include "stream_base.h"  // NOLINT(build/include_inline)
 #include "stream_base-inl.h"
 #include "stream_wrap.h"
+#include "allocated_buffer-inl.h"
 
 #include "node.h"
 #include "node_buffer.h"
@@ -17,18 +18,23 @@ namespace node {
 
 using v8::Array;
 using v8::ArrayBuffer;
+using v8::ConstructorBehavior;
 using v8::Context;
 using v8::DontDelete;
 using v8::DontEnum;
 using v8::External;
 using v8::Function;
 using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
 using v8::HandleScope;
 using v8::Integer;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Object;
+using v8::PropertyAttribute;
 using v8::ReadOnly;
+using v8::SideEffectType;
+using v8::Signature;
 using v8::String;
 using v8::Value;
 
@@ -127,7 +133,7 @@ int StreamBase::Writev(const FunctionCallbackInfo<Value>& args) {
 
   AllocatedBuffer storage;
   if (storage_size > 0)
-    storage = env->AllocateManaged(storage_size);
+    storage = AllocatedBuffer::AllocateManaged(env, storage_size);
 
   offset = 0;
   if (!all_buffers) {
@@ -271,12 +277,12 @@ int StreamBase::WriteString(const FunctionCallbackInfo<Value>& args) {
 
   if (try_write) {
     // Copy partial data
-    data = env->AllocateManaged(buf.len);
+    data = AllocatedBuffer::AllocateManaged(env, buf.len);
     memcpy(data.data(), buf.base, buf.len);
     data_size = buf.len;
   } else {
     // Write it
-    data = env->AllocateManaged(storage_size);
+    data = AllocatedBuffer::AllocateManaged(env, storage_size);
     data_size = StringBytes::Write(env->isolate(),
                                    data.data(),
                                    storage_size,
@@ -331,7 +337,7 @@ MaybeLocal<Value> StreamBase::CallJSOnreadMethod(ssize_t nread,
     }
   }
 
-  env->stream_base_state()[kReadBytesOrError] = nread;
+  env->stream_base_state()[kReadBytesOrError] = static_cast<int32_t>(nread);
   env->stream_base_state()[kArrayBufferOffset] = offset;
 
   Local<Value> argv[] = {
@@ -370,8 +376,8 @@ void StreamBase::AddMethod(Environment* env,
   Local<FunctionTemplate> templ =
       env->NewFunctionTemplate(stream_method,
                                signature,
-                               v8::ConstructorBehavior::kThrow,
-                               v8::SideEffectType::kHasNoSideEffect);
+                               ConstructorBehavior::kThrow,
+                               SideEffectType::kHasNoSideEffect);
   t->PrototypeTemplate()->SetAccessorProperty(
       string, templ, Local<FunctionTemplate>(), attributes);
 }
@@ -481,7 +487,7 @@ void StreamResource::ClearError() {
 uv_buf_t EmitToJSStreamListener::OnStreamAlloc(size_t suggested_size) {
   CHECK_NOT_NULL(stream_);
   Environment* env = static_cast<StreamBase*>(stream_)->stream_env();
-  return env->AllocateManaged(suggested_size).release();
+  return AllocatedBuffer::AllocateManaged(env, suggested_size).release();
 }
 
 void EmitToJSStreamListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
@@ -575,5 +581,56 @@ void ReportWritesToJSStreamListener::OnStreamAfterShutdown(
   OnStreamAfterReqFinished(req_wrap, status);
 }
 
+void ShutdownWrap::OnDone(int status) {
+  stream()->EmitAfterShutdown(this, status);
+  Dispose();
+}
+
+void WriteWrap::OnDone(int status) {
+  stream()->EmitAfterWrite(this, status);
+  Dispose();
+}
+
+StreamListener::~StreamListener() {
+  if (stream_ != nullptr)
+    stream_->RemoveStreamListener(this);
+}
+
+void StreamListener::OnStreamAfterShutdown(ShutdownWrap* w, int status) {
+  CHECK_NOT_NULL(previous_listener_);
+  previous_listener_->OnStreamAfterShutdown(w, status);
+}
+
+void StreamListener::OnStreamAfterWrite(WriteWrap* w, int status) {
+  CHECK_NOT_NULL(previous_listener_);
+  previous_listener_->OnStreamAfterWrite(w, status);
+}
+
+StreamResource::~StreamResource() {
+  while (listener_ != nullptr) {
+    StreamListener* listener = listener_;
+    listener->OnStreamDestroy();
+    // Remove the listener if it didn’t remove itself. This makes the logic
+    // in `OnStreamDestroy()` implementations easier, because they
+    // may call generic cleanup functions which can just remove the
+    // listener unconditionally.
+    if (listener == listener_)
+      RemoveStreamListener(listener_);
+  }
+}
+
+ShutdownWrap* StreamBase::CreateShutdownWrap(
+    Local<Object> object) {
+  auto* wrap = new SimpleShutdownWrap<AsyncWrap>(this, object);
+  wrap->MakeWeak();
+  return wrap;
+}
+
+WriteWrap* StreamBase::CreateWriteWrap(
+    Local<Object> object) {
+  auto* wrap = new SimpleWriteWrap<AsyncWrap>(this, object);
+  wrap->MakeWeak();
+  return wrap;
+}
 
 }  // namespace node
diff --git a/src/stream_base.h b/src/stream_base.h
index fafd327d75d1a08c742d6cbf63adf624871508f5..a5680ba8860d4946b1407eb0749bf8e1cf0e20d6 100644
--- a/src/stream_base.h
+++ b/src/stream_base.h
@@ -4,6 +4,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "env.h"
+#include "allocated_buffer.h"
 #include "async_wrap.h"
 #include "node.h"
 #include "util.h"
@@ -40,21 +41,20 @@ class StreamReq {
     kInternalFieldCount
   };
 
-  explicit StreamReq(StreamBase* stream,
-                     v8::Local<v8::Object> req_wrap_obj) : stream_(stream) {
-    AttachToObject(req_wrap_obj);
-  }
+  inline explicit StreamReq(
+      StreamBase* stream,
+      v8::Local<v8::Object> req_wrap_obj);
 
   virtual ~StreamReq() = default;
   virtual AsyncWrap* GetAsyncWrap() = 0;
-  v8::Local<v8::Object> object();
+  inline v8::Local<v8::Object> object();
 
-  void Done(int status, const char* error_str = nullptr);
-  void Dispose();
+  inline void Done(int status, const char* error_str = nullptr);
+  inline void Dispose();
 
-  inline StreamBase* stream() const { return stream_; }
+  StreamBase* stream() const { return stream_; }
 
-  static StreamReq* FromObject(v8::Local<v8::Object> req_wrap_obj);
+  static inline StreamReq* FromObject(v8::Local<v8::Object> req_wrap_obj);
 
   // Sets all internal fields of `req_wrap_obj` to `nullptr`.
   // This is what the `WriteWrap` and `ShutdownWrap` JS constructors do,
@@ -66,7 +66,7 @@ class StreamReq {
  protected:
   virtual void OnDone(int status) = 0;
 
-  void AttachToObject(v8::Local<v8::Object> req_wrap_obj);
+  inline void AttachToObject(v8::Local<v8::Object> req_wrap_obj);
 
  private:
   StreamBase* const stream_;
@@ -74,9 +74,14 @@ class StreamReq {
 
 class ShutdownWrap : public StreamReq {
  public:
-  ShutdownWrap(StreamBase* stream,
-               v8::Local<v8::Object> req_wrap_obj)
-    : StreamReq(stream, req_wrap_obj) { }
+  inline ShutdownWrap(
+      StreamBase* stream,
+      v8::Local<v8::Object> req_wrap_obj);
+
+  static inline ShutdownWrap* FromObject(v8::Local<v8::Object> req_wrap_obj);
+  template <typename T, bool kIsWeak>
+  static inline ShutdownWrap* FromObject(
+      const BaseObjectPtrImpl<T, kIsWeak>& base_obj);
 
   // Call stream()->EmitAfterShutdown() and dispose of this request wrap.
   void OnDone(int status) override;
@@ -84,11 +89,16 @@ class ShutdownWrap : public StreamReq {
 
 class WriteWrap : public StreamReq {
  public:
-  void SetAllocatedStorage(AllocatedBuffer&& storage);
+  inline void SetAllocatedStorage(AllocatedBuffer&& storage);
+
+  inline WriteWrap(
+      StreamBase* stream,
+      v8::Local<v8::Object> req_wrap_obj);
 
-  WriteWrap(StreamBase* stream,
-            v8::Local<v8::Object> req_wrap_obj)
-    : StreamReq(stream, req_wrap_obj) { }
+  static inline WriteWrap* FromObject(v8::Local<v8::Object> req_wrap_obj);
+  template <typename T, bool kIsWeak>
+  static inline WriteWrap* FromObject(
+      const BaseObjectPtrImpl<T, kIsWeak>& base_obj);
 
   // Call stream()->EmitAfterWrite() and dispose of this request wrap.
   void OnDone(int status) override;
@@ -152,14 +162,14 @@ class StreamListener {
   virtual void OnStreamDestroy() {}
 
   // The stream this is currently associated with, or nullptr if there is none.
-  inline StreamResource* stream() { return stream_; }
+  StreamResource* stream() const { return stream_; }
 
  protected:
   // Pass along a read error to the `StreamListener` instance that was active
   // before this one. For example, a protocol parser does not care about read
   // errors and may instead want to let the original handler
   // (e.g. the JS handler) take care of the situation.
-  void PassReadErrorToPreviousListener(ssize_t nread);
+  inline void PassReadErrorToPreviousListener(ssize_t nread);
 
   StreamResource* stream_ = nullptr;
   StreamListener* previous_listener_ = nullptr;
@@ -256,23 +266,25 @@ class StreamResource {
 
   // Transfer ownership of this stream to `listener`. The previous listener
   // will not receive any more callbacks while the new listener was active.
-  void PushStreamListener(StreamListener* listener);
+  inline void PushStreamListener(StreamListener* listener);
   // Remove a listener, and, if this was the currently active one,
   // transfer ownership back to the previous listener.
-  void RemoveStreamListener(StreamListener* listener);
+  inline void RemoveStreamListener(StreamListener* listener);
 
  protected:
   // Call the current listener's OnStreamAlloc() method.
-  uv_buf_t EmitAlloc(size_t suggested_size);
+  inline uv_buf_t EmitAlloc(size_t suggested_size);
   // Call the current listener's OnStreamRead() method and update the
   // stream's read byte counter.
-  void EmitRead(ssize_t nread, const uv_buf_t& buf = uv_buf_init(nullptr, 0));
+  inline void EmitRead(
+      ssize_t nread,
+      const uv_buf_t& buf = uv_buf_init(nullptr, 0));
   // Call the current listener's OnStreamAfterWrite() method.
-  void EmitAfterWrite(WriteWrap* w, int status);
+  inline void EmitAfterWrite(WriteWrap* w, int status);
   // Call the current listener's OnStreamAfterShutdown() method.
-  void EmitAfterShutdown(ShutdownWrap* w, int status);
+  inline void EmitAfterShutdown(ShutdownWrap* w, int status);
   // Call the current listener's OnStreamWantsWrite() method.
-  void EmitWantsWrite(size_t suggested_size);
+  inline void EmitWantsWrite(size_t suggested_size);
 
   StreamListener* listener_ = nullptr;
   uint64_t bytes_read_ = 0;
@@ -312,13 +324,14 @@ class StreamBase : public StreamResource {
 
   // This is named `stream_env` to avoid name clashes, because a lot of
   // subclasses are also `BaseObject`s.
-  Environment* stream_env() const;
+  Environment* stream_env() const { return env_; }
 
   // Shut down the current stream. This request can use an existing
   // ShutdownWrap object (that was created in JS), or a new one will be created.
   // Returns 1 in case of a synchronous completion, 0 in case of asynchronous
   // completion, and a libuv error case in case of synchronous failure.
-  int Shutdown(v8::Local<v8::Object> req_wrap_obj = v8::Local<v8::Object>());
+  inline int Shutdown(
+      v8::Local<v8::Object> req_wrap_obj = v8::Local<v8::Object>());
 
   // Write data to the current stream. This request can use an existing
   // WriteWrap object (that was created in JS), or a new one will be created.
@@ -326,7 +339,7 @@ class StreamBase : public StreamResource {
   // asynchronously using `DoWrite()`.
   // If the return value indicates a synchronous completion, no callback will
   // be invoked.
-  StreamWriteResult Write(
+  inline StreamWriteResult Write(
       uv_buf_t* bufs,
       size_t count,
       uv_stream_t* send_handle = nullptr,
@@ -343,10 +356,10 @@ class StreamBase : public StreamResource {
   virtual AsyncWrap* GetAsyncWrap() = 0;
   virtual v8::Local<v8::Object> GetObject();
 
-  static StreamBase* FromObject(v8::Local<v8::Object> obj);
+  static inline StreamBase* FromObject(v8::Local<v8::Object> obj);
 
  protected:
-  explicit StreamBase(Environment* env);
+  inline explicit StreamBase(Environment* env);
 
   // JS Methods
   int ReadStartJS(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -362,7 +375,7 @@ class StreamBase : public StreamResource {
   static void GetExternal(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetBytesRead(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetBytesWritten(const v8::FunctionCallbackInfo<v8::Value>& args);
-  void AttachToObject(v8::Local<v8::Object> obj);
+  inline void AttachToObject(v8::Local<v8::Object> obj);
 
   template <int (StreamBase::*Method)(
       const v8::FunctionCallbackInfo<v8::Value>& args)>
@@ -410,6 +423,10 @@ class SimpleShutdownWrap : public ShutdownWrap, public OtherBase {
   SET_NO_MEMORY_INFO()
   SET_MEMORY_INFO_NAME(SimpleShutdownWrap)
   SET_SELF_SIZE(SimpleShutdownWrap)
+
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
+    return OtherBase::IsNotIndicativeOfMemoryLeakAtExit();
+  }
 };
 
 template <typename OtherBase>
@@ -423,6 +440,10 @@ class SimpleWriteWrap : public WriteWrap, public OtherBase {
   SET_NO_MEMORY_INFO()
   SET_MEMORY_INFO_NAME(SimpleWriteWrap)
   SET_SELF_SIZE(SimpleWriteWrap)
+
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
+    return OtherBase::IsNotIndicativeOfMemoryLeakAtExit();
+  }
 };
 
 }  // namespace node
diff --git a/src/stream_pipe.cc b/src/stream_pipe.cc
index 40b094ab5930a52454acd69dd43ad753413ce490..afd7ec36eef2944cef4655498cd83bc8a848ad56 100644
--- a/src/stream_pipe.cc
+++ b/src/stream_pipe.cc
@@ -1,18 +1,20 @@
 #include "stream_pipe.h"
+#include "allocated_buffer-inl.h"
 #include "stream_base-inl.h"
 #include "node_buffer.h"
 #include "util-inl.h"
 
+namespace node {
+
 using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
+using v8::HandleScope;
 using v8::Local;
 using v8::Object;
 using v8::Value;
 
-namespace node {
-
 StreamPipe::StreamPipe(StreamBase* source,
                        StreamBase* sink,
                        Local<Object> obj)
@@ -116,7 +118,7 @@ uv_buf_t StreamPipe::ReadableListener::OnStreamAlloc(size_t suggested_size) {
   StreamPipe* pipe = ContainerOf(&StreamPipe::readable_listener_, this);
   size_t size = std::min(suggested_size, pipe->wanted_data_);
   CHECK_GT(size, 0);
-  return pipe->env()->AllocateManaged(size).release();
+  return AllocatedBuffer::AllocateManaged(pipe->env(), size).release();
 }
 
 void StreamPipe::ReadableListener::OnStreamRead(ssize_t nread,
@@ -290,20 +292,14 @@ void InitializeStreamPipe(Local<Object> target,
 
   // Create FunctionTemplate for FileHandle::CloseReq
   Local<FunctionTemplate> pipe = env->NewFunctionTemplate(StreamPipe::New);
-  Local<String> stream_pipe_string =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "StreamPipe");
   env->SetProtoMethod(pipe, "unpipe", StreamPipe::Unpipe);
   env->SetProtoMethod(pipe, "start", StreamPipe::Start);
   env->SetProtoMethod(pipe, "isClosed", StreamPipe::IsClosed);
   env->SetProtoMethod(pipe, "pendingWrites", StreamPipe::PendingWrites);
   pipe->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  pipe->SetClassName(stream_pipe_string);
   pipe->InstanceTemplate()->SetInternalFieldCount(
       StreamPipe::kInternalFieldCount);
-  target
-      ->Set(context, stream_pipe_string,
-            pipe->GetFunction(context).ToLocalChecked())
-      .Check();
+  env->SetConstructorFunction(target, "StreamPipe", pipe);
 }
 
 }  // anonymous namespace
diff --git a/src/stream_pipe.h b/src/stream_pipe.h
index e22abab0115c8a72abade78b1cb6da3f93c974c5..36179c95f74a93d6af28952b10031485a591846f 100644
--- a/src/stream_pipe.h
+++ b/src/stream_pipe.h
@@ -4,6 +4,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "stream_base.h"
+#include "allocated_buffer.h"
 
 namespace node {
 
diff --git a/src/stream_wrap.cc b/src/stream_wrap.cc
index 7548516e477a367d796a3e56caaf70768f5f178f..a1fa5e94b7371106169fcd25633e2f3a3069771b 100644
--- a/src/stream_wrap.cc
+++ b/src/stream_wrap.cc
@@ -46,6 +46,7 @@ using v8::HandleScope;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Object;
+using v8::PropertyAttribute;
 using v8::ReadOnly;
 using v8::Signature;
 using v8::Value;
@@ -65,9 +66,6 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
   Local<FunctionTemplate> sw =
       FunctionTemplate::New(env->isolate(), is_construct_call_callback);
   sw->InstanceTemplate()->SetInternalFieldCount(StreamReq::kInternalFieldCount);
-  Local<String> wrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "ShutdownWrap");
-  sw->SetClassName(wrapString);
 
   // we need to set handle and callback to null,
   // so that those fields are created and functions
@@ -86,22 +84,15 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
 
   sw->Inherit(AsyncWrap::GetConstructorTemplate(env));
 
-  target->Set(env->context(),
-              wrapString,
-              sw->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "ShutdownWrap", sw);
   env->set_shutdown_wrap_template(sw->InstanceTemplate());
 
   Local<FunctionTemplate> ww =
       FunctionTemplate::New(env->isolate(), is_construct_call_callback);
   ww->InstanceTemplate()->SetInternalFieldCount(
       StreamReq::kInternalFieldCount);
-  Local<String> writeWrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "WriteWrap");
-  ww->SetClassName(writeWrapString);
   ww->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  target->Set(env->context(),
-              writeWrapString,
-              ww->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "WriteWrap", ww);
   env->set_write_wrap_template(ww->InstanceTemplate());
 
   NODE_DEFINE_CONSTANT(target, kReadBytesOrError);
@@ -140,7 +131,7 @@ Local<FunctionTemplate> LibuvStreamWrap::GetConstructorTemplate(
     Local<FunctionTemplate> get_write_queue_size =
         FunctionTemplate::New(env->isolate(),
                               GetWriteQueueSize,
-                              env->as_callback_data(),
+                              Local<Value>(),
                               Signature::New(env->isolate(), tmpl));
     tmpl->PrototypeTemplate()->SetAccessorProperty(
         env->write_queue_size_string(),
diff --git a/src/string_bytes.cc b/src/string_bytes.cc
index ebf57c6be8d64c8a40f1bb0c098ea73d7e1ae66e..daff1424d22e5a2672173eb2bab0a0542b0406f2 100644
--- a/src/string_bytes.cc
+++ b/src/string_bytes.cc
@@ -21,7 +21,7 @@
 
 #include "string_bytes.h"
 
-#include "base64.h"
+#include "base64-inl.h"
 #include "env-inl.h"
 #include "node_buffer.h"
 #include "node_errors.h"
@@ -250,8 +250,8 @@ static size_t hex_decode(char* buf,
                          const size_t srcLen) {
   size_t i;
   for (i = 0; i < len && i * 2 + 1 < srcLen; ++i) {
-    unsigned a = unhex(src[i * 2 + 0]);
-    unsigned b = unhex(src[i * 2 + 1]);
+    unsigned a = unhex(static_cast<uint8_t>(src[i * 2 + 0]));
+    unsigned b = unhex(static_cast<uint8_t>(src[i * 2 + 1]));
     if (!~a || !~b)
       return i;
     buf[i] = (a << 4) | b;
@@ -273,16 +273,14 @@ size_t StringBytes::WriteUCS2(Isolate* isolate,
     return 0;
   }
 
+  uint16_t* const aligned_dst = AlignUp(dst, sizeof(*dst));
   size_t nchars;
-  size_t alignment = reinterpret_cast<uintptr_t>(dst) % sizeof(*dst);
-  if (alignment == 0) {
+  if (aligned_dst == dst) {
     nchars = str->Write(isolate, dst, 0, max_chars, flags);
     *chars_written = nchars;
     return nchars * sizeof(*dst);
   }
 
-  uint16_t* aligned_dst =
-      reinterpret_cast<uint16_t*>(buf + sizeof(*dst) - alignment);
   CHECK_EQ(reinterpret_cast<uintptr_t>(aligned_dst) % sizeof(*dst), 0);
 
   // Write all but the last char
@@ -360,6 +358,8 @@ size_t StringBytes::Write(Isolate* isolate,
       break;
     }
 
+    case BASE64URL:
+      // Fall through
     case BASE64:
       if (str->IsExternalOneByte()) {
         auto ext = str->GetExternalOneByteStringResource();
@@ -391,15 +391,6 @@ size_t StringBytes::Write(Isolate* isolate,
 }
 
 
-bool StringBytes::IsValidString(Local<String> string,
-                                enum encoding enc) {
-  if (enc == HEX && string->Length() % 2 != 0)
-    return false;
-  // TODO(bnoordhuis) Add BASE64 check?
-  return true;
-}
-
-
 // Quick and dirty size calculation
 // Will always be at least big enough, but may have some extra
 // UTF8 can be as much as 3x the size, Base64 can have 1-2 extra bytes
@@ -436,6 +427,8 @@ Maybe<size_t> StringBytes::StorageSize(Isolate* isolate,
       data_size = str->Length() * sizeof(uint16_t);
       break;
 
+    case BASE64URL:
+      // Fall through
     case BASE64:
       data_size = base64_decoded_size_fast(str->Length());
       break;
@@ -477,6 +470,8 @@ Maybe<size_t> StringBytes::Size(Isolate* isolate,
     case UCS2:
       return Just(str->Length() * sizeof(uint16_t));
 
+    case BASE64URL:
+      // Fall through
     case BASE64: {
       String::Value value(isolate, str);
       return Just(base64_decoded_size(*value, value.length()));
@@ -702,6 +697,20 @@ MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
       return ExternOneByteString::New(isolate, dst, dlen, error);
     }
 
+    case BASE64URL: {
+      size_t dlen = base64_encoded_size(buflen, Base64Mode::URL);
+      char* dst = node::UncheckedMalloc(dlen);
+      if (dst == nullptr) {
+        *error = node::ERR_MEMORY_ALLOCATION_FAILED(isolate);
+        return MaybeLocal<Value>();
+      }
+
+      size_t written = base64_encode(buf, buflen, dst, dlen, Base64Mode::URL);
+      CHECK_EQ(written, dlen);
+
+      return ExternOneByteString::New(isolate, dst, dlen, error);
+    }
+
     case HEX: {
       size_t dlen = buflen * 2;
       char* dst = node::UncheckedMalloc(dlen);
diff --git a/src/string_bytes.h b/src/string_bytes.h
index 7902bf0b618255c6c765713ce5f3a68da3e1bdb2..e11b73b69e10b7f086079fde92f689b998f77ddb 100644
--- a/src/string_bytes.h
+++ b/src/string_bytes.h
@@ -46,14 +46,7 @@ class StringBytes {
    public:
     inline v8::Maybe<bool> Decode(Environment* env,
                                   v8::Local<v8::String> string,
-                                  v8::Local<v8::Value> encoding,
-                                  enum encoding _default) {
-      enum encoding enc = ParseEncoding(env->isolate(), encoding, _default);
-      if (!StringBytes::IsValidString(string, enc)) {
-        env->ThrowTypeError("Bad input string");
-        return v8::Nothing<bool>();
-      }
-
+                                  enum encoding enc) {
       size_t storage;
       if (!StringBytes::StorageSize(env->isolate(), string, enc).To(&storage))
         return v8::Nothing<bool>();
@@ -69,12 +62,6 @@ class StringBytes {
     inline size_t size() const { return length(); }
   };
 
-  // Does the string match the encoding? Quick but non-exhaustive.
-  // Example: a HEX string must have a length that's a multiple of two.
-  // FIXME(bnoordhuis) IsMaybeValidString()? Naming things is hard...
-  static bool IsValidString(v8::Local<v8::String> string,
-                            enum encoding enc);
-
   // Fast, but can be 2 bytes oversized for Base64, and
   // as much as triple UTF-8 strings <= 65536 chars in length
   static v8::Maybe<size_t> StorageSize(v8::Isolate* isolate,
diff --git a/src/string_decoder.cc b/src/string_decoder.cc
index 6ec84e0e11ed31f4ffe3efa957b94afaca4878c2..fc37cbe29e40bf7b8c4ead06f24fc4c0cc564b35 100644
--- a/src/string_decoder.cc
+++ b/src/string_decoder.cc
@@ -3,6 +3,7 @@
 
 #include "env-inl.h"
 #include "node_buffer.h"
+#include "node_errors.h"
 #include "string_bytes.h"
 #include "util.h"
 
@@ -29,11 +30,17 @@ MaybeLocal<String> MakeString(Isolate* isolate,
   Local<Value> error;
   MaybeLocal<Value> ret;
   if (encoding == UTF8) {
-    return String::NewFromUtf8(
+    MaybeLocal<String> utf8_string = String::NewFromUtf8(
         isolate,
         data,
         v8::NewStringType::kNormal,
         length);
+    if (utf8_string.IsEmpty()) {
+      isolate->ThrowException(node::ERR_STRING_TOO_LONG(isolate));
+      return MaybeLocal<String>();
+    } else {
+      return utf8_string;
+    }
   } else {
     ret = StringBytes::Encode(
         isolate,
@@ -62,7 +69,10 @@ MaybeLocal<String> StringDecoder::DecodeData(Isolate* isolate,
 
   size_t nread = *nread_ptr;
 
-  if (Encoding() == UTF8 || Encoding() == UCS2 || Encoding() == BASE64) {
+  if (Encoding() == UTF8 ||
+      Encoding() == UCS2 ||
+      Encoding() == BASE64 ||
+      Encoding() == BASE64URL) {
     // See if we want bytes to finish a character from the previous
     // chunk; if so, copy the new bytes to the missing bytes buffer
     // and create a small string from it that is to be prepended to the
@@ -190,7 +200,7 @@ MaybeLocal<String> StringDecoder::DecodeData(Isolate* isolate,
           state_[kBufferedBytes] = 2;
           state_[kMissingBytes] = 2;
         }
-      } else if (Encoding() == BASE64) {
+      } else if (Encoding() == BASE64 || Encoding() == BASE64URL) {
         state_[kBufferedBytes] = nread % 3;
         if (state_[kBufferedBytes] > 0)
           state_[kMissingBytes] = 3 - BufferedBytes();
@@ -303,6 +313,7 @@ void InitializeStringDecoder(Local<Object> target,
   ADD_TO_ENCODINGS_ARRAY(ASCII, "ascii");
   ADD_TO_ENCODINGS_ARRAY(UTF8, "utf8");
   ADD_TO_ENCODINGS_ARRAY(BASE64, "base64");
+  ADD_TO_ENCODINGS_ARRAY(BASE64URL, "base64url");
   ADD_TO_ENCODINGS_ARRAY(UCS2, "utf16le");
   ADD_TO_ENCODINGS_ARRAY(HEX, "hex");
   ADD_TO_ENCODINGS_ARRAY(BUFFER, "buffer");
diff --git a/src/string_search.h b/src/string_search.h
index 3d06f32058f673388d4c2d1802ef86b386faef2f..cd9ef320a81112b607dbf90abf47370c5fb70afc 100644
--- a/src/string_search.h
+++ b/src/string_search.h
@@ -32,7 +32,7 @@ class Vector {
 
   // Returns true if the Vector is front-to-back, false if back-to-front.
   // In the latter case, v[0] corresponds to the *end* of the memory range.
-  size_t forward() const { return is_forward_; }
+  bool forward() const { return is_forward_; }
 
   // Access individual vector elements - checks bounds in debug mode.
   T& operator[](size_t index) const {
@@ -458,7 +458,7 @@ size_t StringSearch<Char>::BoyerMooreHorspoolSearch(
   const size_t subject_length = subject.length();
   const size_t pattern_length = pattern_.length();
   int* char_occurrences = bad_char_shift_table_;
-  int64_t badness = -pattern_length;
+  int64_t badness = -static_cast<int64_t>(pattern_length);
 
   // How bad we are doing without a good-suffix table.
   Char last_char = pattern_[pattern_length - 1];
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index fa45bd118d4724179be0e0ea08a7229ce825c43f..cd7174984e2e368138f54244d3a60dbb4fc93ad6 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -74,8 +74,6 @@ void TCPWrap::Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
-  Local<String> tcpString = FIXED_ONE_BYTE_STRING(env->isolate(), "TCP");
-  t->SetClassName(tcpString);
   t->InstanceTemplate()->SetInternalFieldCount(StreamBase::kInternalFieldCount);
 
   // Init properties
@@ -103,21 +101,14 @@ void TCPWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "setSimultaneousAccepts", SetSimultaneousAccepts);
 #endif
 
-  target->Set(env->context(),
-              tcpString,
-              t->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "TCP", t);
   env->set_tcp_constructor_template(t);
 
   // Create FunctionTemplate for TCPConnectWrap.
   Local<FunctionTemplate> cwt =
       BaseObject::MakeLazilyInitializedJSTemplate(env);
   cwt->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  Local<String> wrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "TCPConnectWrap");
-  cwt->SetClassName(wrapString);
-  target->Set(env->context(),
-              wrapString,
-              cwt->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "TCPConnectWrap", cwt);
 
   // Define constants
   Local<Object> constants = Object::New(env->isolate());
diff --git a/src/timer_wrap.cc b/src/timer_wrap.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6660b8c958810c14f3b70709bde50d119fab9097
--- /dev/null
+++ b/src/timer_wrap.cc
@@ -0,0 +1,95 @@
+#include "env-inl.h"
+#include "memory_tracker-inl.h"
+#include "timer_wrap.h"
+#include "uv.h"
+
+namespace node {
+
+TimerWrap::TimerWrap(Environment* env, const TimerCb& fn)
+    : env_(env),
+      fn_(fn) {
+  uv_timer_init(env->event_loop(), &timer_);
+  timer_.data = this;
+}
+
+void TimerWrap::Stop() {
+  if (timer_.data == nullptr) return;
+  uv_timer_stop(&timer_);
+}
+
+void TimerWrap::Close() {
+  timer_.data = nullptr;
+  env_->CloseHandle(reinterpret_cast<uv_handle_t*>(&timer_), TimerClosedCb);
+}
+
+void TimerWrap::TimerClosedCb(uv_handle_t* handle) {
+  std::unique_ptr<TimerWrap> ptr(
+      ContainerOf(&TimerWrap::timer_,
+                  reinterpret_cast<uv_timer_t*>(handle)));
+}
+
+void TimerWrap::Update(uint64_t interval, uint64_t repeat) {
+  if (timer_.data == nullptr) return;
+  uv_timer_start(&timer_, OnTimeout, interval, repeat);
+}
+
+void TimerWrap::Ref() {
+  if (timer_.data == nullptr) return;
+  uv_ref(reinterpret_cast<uv_handle_t*>(&timer_));
+}
+
+void TimerWrap::Unref() {
+  if (timer_.data == nullptr) return;
+  uv_unref(reinterpret_cast<uv_handle_t*>(&timer_));
+}
+
+void TimerWrap::OnTimeout(uv_timer_t* timer) {
+  TimerWrap* t = ContainerOf(&TimerWrap::timer_, timer);
+  t->fn_();
+}
+
+TimerWrapHandle::TimerWrapHandle(
+    Environment* env,
+    const TimerWrap::TimerCb& fn) {
+  timer_ = new TimerWrap(env, fn);
+  env->AddCleanupHook(CleanupHook, this);
+}
+
+void TimerWrapHandle::Stop() {
+  if (timer_ != nullptr)
+    return timer_->Stop();
+}
+
+void TimerWrapHandle::Close() {
+  if (timer_ != nullptr) {
+    timer_->env()->RemoveCleanupHook(CleanupHook, this);
+    timer_->Close();
+  }
+  timer_ = nullptr;
+}
+
+void TimerWrapHandle::Ref() {
+  if (timer_ != nullptr)
+    timer_->Ref();
+}
+
+void TimerWrapHandle::Unref() {
+  if (timer_ != nullptr)
+    timer_->Unref();
+}
+
+void TimerWrapHandle::Update(uint64_t interval, uint64_t repeat) {
+  if (timer_ != nullptr)
+    timer_->Update(interval, repeat);
+}
+
+void TimerWrapHandle::MemoryInfo(MemoryTracker* tracker) const {
+  if (timer_ != nullptr)
+    tracker->TrackField("timer", *timer_);
+}
+
+void TimerWrapHandle::CleanupHook(void* data) {
+  static_cast<TimerWrapHandle*>(data)->Close();
+}
+
+}  // namespace node
diff --git a/src/timer_wrap.h b/src/timer_wrap.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbc23b442bea39d4556a21bb7f365dd68239095d
--- /dev/null
+++ b/src/timer_wrap.h
@@ -0,0 +1,84 @@
+#ifndef SRC_TIMER_WRAP_H_
+#define SRC_TIMER_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "memory_tracker.h"
+#include "env.h"
+#include "uv.h"
+
+#include <functional>
+
+namespace node {
+
+// Utility class that makes working with libuv timers a bit easier.
+class TimerWrap final : public MemoryRetainer {
+ public:
+  using TimerCb = std::function<void()>;
+
+  TimerWrap(Environment* env, const TimerCb& fn);
+  TimerWrap(const TimerWrap&) = delete;
+
+  inline Environment* env() const { return env_; }
+
+  // Stop calling the timer callback.
+  void Stop();
+  // Render the timer unusable and delete this object.
+  void Close();
+
+  // Starts / Restarts the Timer
+  void Update(uint64_t interval, uint64_t repeat = 0);
+
+  void Ref();
+  void Unref();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(TimerWrap)
+  SET_SELF_SIZE(TimerWrap)
+
+ private:
+  static void TimerClosedCb(uv_handle_t* handle);
+  static void OnTimeout(uv_timer_t* timer);
+  ~TimerWrap() = default;
+
+  Environment* env_;
+  TimerCb fn_;
+  uv_timer_t timer_;
+
+  friend std::unique_ptr<TimerWrap>::deleter_type;
+};
+
+class TimerWrapHandle : public MemoryRetainer  {
+ public:
+  TimerWrapHandle(
+      Environment* env,
+      const TimerWrap::TimerCb& fn);
+
+  TimerWrapHandle(const TimerWrapHandle&) = delete;
+
+  ~TimerWrapHandle() { Close(); }
+
+  void Update(uint64_t interval, uint64_t repeat = 0);
+
+  void Ref();
+  void Unref();
+
+  void Stop();
+  void Close();
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+
+  SET_MEMORY_INFO_NAME(TimerWrapHandle)
+  SET_SELF_SIZE(TimerWrapHandle)
+
+ private:
+  static void CleanupHook(void* data);
+
+  TimerWrap* timer_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMER_WRAP_H_
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index 95bbc4c6a62ccf19a9d94a6afa4f2ce277c9bd4c..85591902d5fabd6fcca192df0180a17e683f40e1 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -20,6 +20,7 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "tls_wrap.h"
+#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
 #include "debug_utils-inl.h"
 #include "memory_tracker-inl.h"
@@ -43,11 +44,13 @@ using v8::Exception;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
+using v8::HandleScope;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Object;
+using v8::PropertyAttribute;
 using v8::ReadOnly;
 using v8::Signature;
 using v8::String;
@@ -92,9 +95,10 @@ bool TLSWrap::InvokeQueued(int status, const char* error_str) {
   if (!write_callback_scheduled_)
     return false;
 
-  if (current_write_ != nullptr) {
-    WriteWrap* w = current_write_;
-    current_write_ = nullptr;
+  if (current_write_) {
+    BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
+    current_write_.reset();
+    WriteWrap* w = WriteWrap::FromObject(current_write);
     w->Done(status, error_str);
   }
 
@@ -298,7 +302,7 @@ void TLSWrap::EncOut() {
   }
 
   // Split-off queue
-  if (established_ && current_write_ != nullptr) {
+  if (established_ && current_write_) {
     Debug(this, "EncOut() setting write_callback_scheduled_");
     write_callback_scheduled_ = true;
   }
@@ -369,10 +373,12 @@ void TLSWrap::EncOut() {
 
 void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
   Debug(this, "OnStreamAfterWrite(status = %d)", status);
-  if (current_empty_write_ != nullptr) {
+  if (current_empty_write_) {
     Debug(this, "Had empty write");
-    WriteWrap* finishing = current_empty_write_;
-    current_empty_write_ = nullptr;
+    BaseObjectPtr<AsyncWrap> current_empty_write =
+        std::move(current_empty_write_);
+    current_empty_write_.reset();
+    WriteWrap* finishing = WriteWrap::FromObject(current_empty_write);
     finishing->Done(status);
     return;
   }
@@ -732,14 +738,14 @@ int TLSWrap::DoWrite(WriteWrap* w,
     ClearOut();
     if (BIO_pending(enc_out_) == 0) {
       Debug(this, "No pending encrypted output, writing to underlying stream");
-      CHECK_NULL(current_empty_write_);
-      current_empty_write_ = w;
+      CHECK(!current_empty_write_);
+      current_empty_write_.reset(w->GetAsyncWrap());
       StreamWriteResult res =
           underlying_stream()->Write(bufs, count, send_handle);
       if (!res.async) {
         BaseObjectPtr<TLSWrap> strong_ref{this};
         env()->SetImmediate([this, strong_ref](Environment* env) {
-          OnStreamAfterWrite(current_empty_write_, 0);
+          OnStreamAfterWrite(WriteWrap::FromObject(current_empty_write_), 0);
         });
       }
       return 0;
@@ -747,8 +753,8 @@ int TLSWrap::DoWrite(WriteWrap* w,
   }
 
   // Store the current write wrap
-  CHECK_NULL(current_write_);
-  current_write_ = w;
+  CHECK(!current_write_);
+  current_write_.reset(w->GetAsyncWrap());
 
   // Write encrypted data to underlying stream and call Done().
   if (length == 0) {
@@ -770,7 +776,7 @@ int TLSWrap::DoWrite(WriteWrap* w,
   // and copying it when it could just be used.
 
   if (nonempty_count != 1) {
-    data = env()->AllocateManaged(length);
+    data = AllocatedBuffer::AllocateManaged(env(), length);
     size_t offset = 0;
     for (i = 0; i < count; i++) {
       memcpy(data.data() + offset, bufs[i].base, bufs[i].len);
@@ -786,7 +792,7 @@ int TLSWrap::DoWrite(WriteWrap* w,
     written = SSL_write(ssl_.get(), buf->base, buf->len);
 
     if (written == -1) {
-      data = env()->AllocateManaged(length);
+      data = AllocatedBuffer::AllocateManaged(env(), length);
       memcpy(data.data(), buf->base, buf->len);
     }
   }
@@ -801,7 +807,7 @@ int TLSWrap::DoWrite(WriteWrap* w,
     // If we stopped writing because of an error, it's fatal, discard the data.
     if (!arg.IsEmpty()) {
       Debug(this, "Got SSL error (%d), returning UV_EPROTO", err);
-      current_write_ = nullptr;
+      current_write_.reset();
       return UV_EPROTO;
     }
 
@@ -1146,7 +1152,7 @@ unsigned int TLSWrap::PskServerCallback(SSL* s,
   HandleScope scope(isolate);
 
   MaybeLocal<String> maybe_identity_str =
-      v8::String::NewFromUtf8(isolate, identity, v8::NewStringType::kNormal);
+      String::NewFromUtf8(isolate, identity);
 
   v8::Local<v8::String> identity_str;
   if (!maybe_identity_str.ToLocal(&identity_str)) return 0;
@@ -1279,7 +1285,7 @@ void TLSWrap::Initialize(Local<Object> target,
   Local<FunctionTemplate> get_write_queue_size =
       FunctionTemplate::New(env->isolate(),
                             GetWriteQueueSize,
-                            env->as_callback_data(),
+                            Local<Value>(),
                             Signature::New(env->isolate(), t));
   t->PrototypeTemplate()->SetAccessorProperty(
       env->write_queue_size_string(),
diff --git a/src/tls_wrap.h b/src/tls_wrap.h
index 7bb33b4a3cb69aa1aef99aaf0c97c62eac36e128..579f53cf9a391acb05930bc1371026b7ab9ae602 100644
--- a/src/tls_wrap.h
+++ b/src/tls_wrap.h
@@ -26,6 +26,7 @@
 
 #include "node_crypto.h"  // SSLWrap
 
+#include "allocated_buffer.h"
 #include "async_wrap.h"
 #include "stream_wrap.h"
 #include "v8.h"
@@ -193,9 +194,9 @@ class TLSWrap : public AsyncWrap,
   // Waiting for ClearIn() to pass to SSL_write().
   AllocatedBuffer pending_cleartext_input_;
   size_t write_size_ = 0;
-  WriteWrap* current_write_ = nullptr;
+  BaseObjectPtr<AsyncWrap> current_write_;
   bool in_dowrite_ = false;
-  WriteWrap* current_empty_write_ = nullptr;
+  BaseObjectPtr<AsyncWrap> current_empty_write_;
   bool write_callback_scheduled_ = false;
   bool started_ = false;
   bool established_ = false;
diff --git a/src/tracing/traced_value.cc b/src/tracing/traced_value.cc
index dfc11658e7e4e3e64ba1590b6abd0fc6a7134b55..662b0357a19305833ffb53c138050c7143682aca 100644
--- a/src/tracing/traced_value.cc
+++ b/src/tracing/traced_value.cc
@@ -94,7 +94,7 @@ std::string DoubleToCString(double v) {
     default:
       // This is a far less sophisticated version than the one used inside v8.
       std::ostringstream stream;
-      stream.imbue(std::locale("C"));  // Ignore locale
+      stream.imbue(std::locale::classic());  // Ignore current locale
       stream << v;
       return stream.str();
   }
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 82406d0eaf19bcbb55d12de2243796794190382c..203eb1e94159261ff5dcb46fc8a0d6634f161cea 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -20,6 +20,7 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "udp_wrap.h"
+#include "allocated_buffer-inl.h"
 #include "env-inl.h"
 #include "node_buffer.h"
 #include "node_sockaddr-inl.h"
@@ -42,7 +43,6 @@ using v8::Object;
 using v8::PropertyAttribute;
 using v8::ReadOnly;
 using v8::Signature;
-using v8::String;
 using v8::Uint32;
 using v8::Undefined;
 using v8::Value;
@@ -133,9 +133,6 @@ void UDPWrap::Initialize(Local<Object> target,
   Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
   t->InstanceTemplate()->SetInternalFieldCount(
       UDPWrapBase::kInternalFieldCount);
-  Local<String> udpString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "UDP");
-  t->SetClassName(udpString);
 
   enum PropertyAttribute attributes =
       static_cast<PropertyAttribute>(ReadOnly | DontDelete);
@@ -145,7 +142,7 @@ void UDPWrap::Initialize(Local<Object> target,
   Local<FunctionTemplate> get_fd_templ =
       FunctionTemplate::New(env->isolate(),
                             UDPWrap::GetFD,
-                            env->as_callback_data(),
+                            Local<Value>(),
                             signature);
 
   t->PrototypeTemplate()->SetAccessorProperty(env->fd_string(),
@@ -181,9 +178,7 @@ void UDPWrap::Initialize(Local<Object> target,
 
   t->Inherit(HandleWrap::GetConstructorTemplate(env));
 
-  target->Set(env->context(),
-              udpString,
-              t->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "UDP", t);
   env->set_udp_constructor_function(
       t->GetFunction(env->context()).ToLocalChecked());
 
@@ -191,12 +186,7 @@ void UDPWrap::Initialize(Local<Object> target,
   Local<FunctionTemplate> swt =
       BaseObject::MakeLazilyInitializedJSTemplate(env);
   swt->Inherit(AsyncWrap::GetConstructorTemplate(env));
-  Local<String> sendWrapString =
-      FIXED_ONE_BYTE_STRING(env->isolate(), "SendWrap");
-  swt->SetClassName(sendWrapString);
-  target->Set(env->context(),
-              sendWrapString,
-              swt->GetFunction(env->context()).ToLocalChecked()).Check();
+  env->SetConstructorFunction(target, "SendWrap", swt);
 
   Local<Object> constants = Object::New(env->isolate());
   NODE_DEFINE_CONSTANT(constants, UV_UDP_IPV6ONLY);
@@ -540,7 +530,7 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
     wrap->current_send_has_callback_ =
         sendto ? args[5]->IsTrue() : args[3]->IsTrue();
 
-    err = wrap->Send(*bufs, count, addr);
+    err = static_cast<int>(wrap->Send(*bufs, count, addr));
 
     wrap->current_send_req_wrap_.Clear();
     wrap->current_send_has_callback_ = false;
@@ -688,7 +678,7 @@ void UDPWrap::OnAlloc(uv_handle_t* handle,
 }
 
 uv_buf_t UDPWrap::OnAlloc(size_t suggested_size) {
-  return env()->AllocateManaged(suggested_size).release();
+  return AllocatedBuffer::AllocateManaged(env(), suggested_size).release();
 }
 
 void UDPWrap::OnRecv(uv_udp_t* handle,
@@ -714,11 +704,10 @@ void UDPWrap::OnRecv(ssize_t nread,
   Context::Scope context_scope(env->context());
 
   Local<Value> argv[] = {
-    Integer::New(env->isolate(), nread),
-    object(),
-    Undefined(env->isolate()),
-    Undefined(env->isolate())
-  };
+      Integer::New(env->isolate(), static_cast<int32_t>(nread)),
+      object(),
+      Undefined(env->isolate()),
+      Undefined(env->isolate())};
 
   if (nread < 0) {
     MakeCallback(env->onmessage_string(), arraysize(argv), argv);
diff --git a/src/util-inl.h b/src/util-inl.h
index 16404b27c7ce38d469ae0fcd461d844916f1f224..517da707170586c3404700b5c4e07e5d483016d8 100644
--- a/src/util-inl.h
+++ b/src/util-inl.h
@@ -26,6 +26,7 @@
 
 #include <cmath>
 #include <cstring>
+#include <locale>
 #include "util.h"
 
 // These are defined by <sys/byteorder.h> or <netinet/in.h> on some systems.
@@ -208,8 +209,7 @@ void SwapBytes16(char* data, size_t nbytes) {
   CHECK_EQ(nbytes % 2, 0);
 
 #if defined(_MSC_VER)
-  int align = reinterpret_cast<uintptr_t>(data) % sizeof(uint16_t);
-  if (align == 0) {
+  if (AlignUp(data, sizeof(uint16_t)) == data) {
     // MSVC has no strict aliasing, and is able to highly optimize this case.
     uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
     size_t len16 = nbytes / sizeof(*data16);
@@ -232,9 +232,8 @@ void SwapBytes32(char* data, size_t nbytes) {
   CHECK_EQ(nbytes % 4, 0);
 
 #if defined(_MSC_VER)
-  int align = reinterpret_cast<uintptr_t>(data) % sizeof(uint32_t);
   // MSVC has no strict aliasing, and is able to highly optimize this case.
-  if (align == 0) {
+  if (AlignUp(data, sizeof(uint32_t)) == data) {
     uint32_t* data32 = reinterpret_cast<uint32_t*>(data);
     size_t len32 = nbytes / sizeof(*data32);
     for (size_t i = 0; i < len32; i++) {
@@ -256,8 +255,7 @@ void SwapBytes64(char* data, size_t nbytes) {
   CHECK_EQ(nbytes % 8, 0);
 
 #if defined(_MSC_VER)
-  int align = reinterpret_cast<uintptr_t>(data) % sizeof(uint64_t);
-  if (align == 0) {
+  if (AlignUp(data, sizeof(uint64_t)) == data) {
     // MSVC has no strict aliasing, and is able to highly optimize this case.
     uint64_t* data64 = reinterpret_cast<uint64_t*>(data);
     size_t len64 = nbytes / sizeof(*data64);
@@ -277,7 +275,7 @@ void SwapBytes64(char* data, size_t nbytes) {
 }
 
 char ToLower(char c) {
-  return c >= 'A' && c <= 'Z' ? c + ('a' - 'A') : c;
+  return std::tolower(c, std::locale::classic());
 }
 
 std::string ToLower(const std::string& in) {
@@ -288,7 +286,7 @@ std::string ToLower(const std::string& in) {
 }
 
 char ToUpper(char c) {
-  return c >= 'a' && c <= 'z' ? (c - 'a') + 'A' : c;
+  return std::toupper(c, std::locale::classic());
 }
 
 std::string ToUpper(const std::string& in) {
@@ -512,7 +510,7 @@ void ArrayBufferViewContents<T, S>::Read(v8::Local<v8::ArrayBufferView> abv) {
   static_assert(sizeof(T) == 1, "Only supports one-byte data at the moment");
   length_ = abv->ByteLength();
   if (length_ > sizeof(stack_storage_) || abv->HasBuffer()) {
-    data_ = static_cast<T*>(abv->Buffer()->GetContents().Data()) +
+    data_ = static_cast<T*>(abv->Buffer()->GetBackingStore()->Data()) +
         abv->ByteOffset();
   } else {
     abv->CopyContents(stack_storage_, sizeof(stack_storage_));
@@ -520,6 +518,48 @@ void ArrayBufferViewContents<T, S>::Read(v8::Local<v8::ArrayBufferView> abv) {
   }
 }
 
+// ECMA262 20.1.2.5
+inline bool IsSafeJsInt(v8::Local<v8::Value> v) {
+  if (!v->IsNumber()) return false;
+  double v_d = v.As<v8::Number>()->Value();
+  if (std::isnan(v_d)) return false;
+  if (std::isinf(v_d)) return false;
+  if (std::trunc(v_d) != v_d) return false;  // not int
+  if (std::abs(v_d) <= static_cast<double>(kMaxSafeJsInteger)) return true;
+  return false;
+}
+
+constexpr size_t FastStringKey::HashImpl(const char* str) {
+  // Low-quality hash (djb2), but just fine for current use cases.
+  size_t h = 5381;
+  while (*str != '\0') {
+    h = h * 33 + *(str++);  // NOLINT(readability/pointer_notation)
+  }
+  return h;
+}
+
+constexpr size_t FastStringKey::Hash::operator()(
+    const FastStringKey& key) const {
+  return key.cached_hash_;
+}
+
+constexpr bool FastStringKey::operator==(const FastStringKey& other) const {
+  const char* p1 = name_;
+  const char* p2 = other.name_;
+  if (p1 == p2) return true;
+  do {
+    if (*(p1++) != *(p2++)) return false;
+  } while (*p1 != '\0');
+  return *p2 == '\0';
+}
+
+constexpr FastStringKey::FastStringKey(const char* name)
+  : name_(name), cached_hash_(HashImpl(name)) {}
+
+constexpr const char* FastStringKey::c_str() const {
+  return name_;
+}
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/util.cc b/src/util.cc
index c604c4c9555b6047e4f6de5dbec9520eb9ea2ee6..e181fdf568cd18da23f3f72fd852ecf9ba976f5a 100644
--- a/src/util.cc
+++ b/src/util.cc
@@ -144,7 +144,10 @@ std::string GetProcessTitle(const char* default_title) {
     if (rc == 0)
       break;
 
-    if (rc != UV_ENOBUFS)
+    // If uv_setup_args() was not called, `uv_get_process_title()` will always
+    // return `UV_ENOBUFS`, no matter the input size. Guard against a possible
+    // infinite loop by limiting the buffer size.
+    if (rc != UV_ENOBUFS || buf.size() >= 1024 * 1024)
       return default_title;
 
     buf.resize(2 * buf.size());
@@ -218,6 +221,45 @@ int WriteFileSync(v8::Isolate* isolate,
   return WriteFileSync(path, buf);
 }
 
+int ReadFileSync(std::string* result, const char* path) {
+  uv_fs_t req;
+  auto defer_req_cleanup = OnScopeLeave([&req]() {
+    uv_fs_req_cleanup(&req);
+  });
+
+  uv_file file = uv_fs_open(nullptr, &req, path, O_RDONLY, 0, nullptr);
+  if (req.result < 0) {
+    // req will be cleaned up by scope leave.
+    return req.result;
+  }
+  uv_fs_req_cleanup(&req);
+
+  auto defer_close = OnScopeLeave([file]() {
+    uv_fs_t close_req;
+    CHECK_EQ(0, uv_fs_close(nullptr, &close_req, file, nullptr));
+    uv_fs_req_cleanup(&close_req);
+  });
+
+  *result = std::string("");
+  char buffer[4096];
+  uv_buf_t buf = uv_buf_init(buffer, sizeof(buffer));
+
+  while (true) {
+    const int r =
+        uv_fs_read(nullptr, &req, file, &buf, 1, result->length(), nullptr);
+    if (req.result < 0) {
+      // req will be cleaned up by scope leave.
+      return req.result;
+    }
+    uv_fs_req_cleanup(&req);
+    if (r <= 0) {
+      break;
+    }
+    result->append(buf.base, r);
+  }
+  return 0;
+}
+
 void DiagnosticFilename::LocalTime(TIME_TYPE* tm_struct) {
 #ifdef _WIN32
   GetLocalTime(tm_struct);
diff --git a/src/util.h b/src/util.h
index f406e3ad0e58499dd0aad6fe9cb96375001da194..4188ac4ef8aa851fac2a7b6a6134f1d899728761 100644
--- a/src/util.h
+++ b/src/util.h
@@ -195,6 +195,11 @@ void DumpBacktrace(FILE* fp);
 #define UNREACHABLE(...)                                                      \
   ERROR_AND_ABORT("Unreachable code reached" __VA_OPT__(": ") __VA_ARGS__)
 
+// ECMA262 20.1.2.6 Number.MAX_SAFE_INTEGER (2^53-1)
+constexpr int64_t kMaxSafeJsInteger = 9007199254740991;
+
+inline bool IsSafeJsInt(v8::Local<v8::Value> v);
+
 // TAILQ-style intrusive list node.
 template <typename T>
 class ListNode;
@@ -401,7 +406,7 @@ class MaybeStackBuffer {
     buf_[length] = T();
   }
 
-  // Make derefencing this object return nullptr.
+  // Make dereferencing this object return nullptr.
   // This method can be called multiple times throughout the lifetime of the
   // buffer, but once this has been called AllocateSufficientStorage() cannot
   // be used.
@@ -502,11 +507,12 @@ class BufferValue : public MaybeStackBuffer<char> {
 #define SPREAD_BUFFER_ARG(val, name)                                          \
   CHECK((val)->IsArrayBufferView());                                          \
   v8::Local<v8::ArrayBufferView> name = (val).As<v8::ArrayBufferView>();      \
-  v8::ArrayBuffer::Contents name##_c = name->Buffer()->GetContents();         \
+  std::shared_ptr<v8::BackingStore> name##_bs =                               \
+      name->Buffer()->GetBackingStore();                                      \
   const size_t name##_offset = name->ByteOffset();                            \
   const size_t name##_length = name->ByteLength();                            \
   char* const name##_data =                                                   \
-      static_cast<char*>(name##_c.Data()) + name##_offset;                    \
+      static_cast<char*>(name##_bs->Data()) + name##_offset;                  \
   if (name##_length > 0)                                                      \
     CHECK_NE(name##_data, nullptr);
 
@@ -674,11 +680,9 @@ inline v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
   do {                                                                         \
     v8::Isolate* isolate = target->GetIsolate();                               \
     v8::Local<v8::String> constant_name =                                      \
-        v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kNormal)     \
-            .ToLocalChecked();                                                 \
+        v8::String::NewFromUtf8(isolate, name).ToLocalChecked();               \
     v8::Local<v8::String> constant_value =                                     \
-        v8::String::NewFromUtf8(isolate, constant, v8::NewStringType::kNormal) \
-            .ToLocalChecked();                                                 \
+        v8::String::NewFromUtf8(isolate, constant).ToLocalChecked();           \
     v8::PropertyAttribute constant_attributes =                                \
         static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);     \
     target                                                                     \
@@ -717,6 +721,13 @@ constexpr T RoundUp(T a, T b) {
   return a % b != 0 ? a + b - (a % b) : a;
 }
 
+// Align ptr to an `alignment`-bytes boundary.
+template <typename T, typename U>
+constexpr T* AlignUp(T* ptr, U alignment) {
+  return reinterpret_cast<T*>(
+      RoundUp(reinterpret_cast<uintptr_t>(ptr), alignment));
+}
+
 class SlicedArguments : public MaybeStackBuffer<v8::Local<v8::Value>> {
  public:
   inline explicit SlicedArguments(
@@ -749,6 +760,7 @@ class PersistentToLocal {
   template <class TypeName>
   static inline v8::Local<TypeName> Strong(
       const v8::PersistentBase<TypeName>& persistent) {
+    DCHECK(!persistent.IsWeak());
     return *reinterpret_cast<v8::Local<TypeName>*>(
         const_cast<v8::PersistentBase<TypeName>*>(&persistent));
   }
@@ -761,12 +773,36 @@ class PersistentToLocal {
   }
 };
 
+// Can be used as a key for std::unordered_map when lookup performance is more
+// important than size and the keys are statically used to avoid redundant hash
+// computations.
+class FastStringKey {
+ public:
+  constexpr explicit FastStringKey(const char* name);
+
+  struct Hash {
+    constexpr size_t operator()(const FastStringKey& key) const;
+  };
+  constexpr bool operator==(const FastStringKey& other) const;
+
+  constexpr const char* c_str() const;
+
+ private:
+  static constexpr size_t HashImpl(const char* str);
+
+  const char* name_;
+  size_t cached_hash_;
+};
+
 // Like std::static_pointer_cast but for unique_ptr with the default deleter.
 template <typename T, typename U>
 std::unique_ptr<T> static_unique_pointer_cast(std::unique_ptr<U>&& ptr) {
   return std::unique_ptr<T>(static_cast<T*>(ptr.release()));
 }
 
+// Returns a non-zero code if it fails to open or read the file,
+// aborts if it fails to close the file.
+int ReadFileSync(std::string* result, const char* path);
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/uv.cc b/src/uv.cc
index bf50c88111fa903c33e62b50a24b0e2ada8fc8fe..009136cef6bac53f985dbcbfce88b5e806137653 100644
--- a/src/uv.cc
+++ b/src/uv.cc
@@ -22,7 +22,7 @@
 #include "uv.h"
 #include "env-inl.h"
 #include "node.h"
-#include "node_process.h"
+#include "node_process-inl.h"
 
 namespace node {
 
@@ -81,6 +81,8 @@ void GetErrMap(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = env->isolate();
   Local<Context> context = env->context();
 
+  // This can't return a SafeMap, because the uv binding can be referenced
+  // by user code by using `process.binding('uv').getErrorMap()`:
   Local<Map> err_map = Map::New(isolate);
 
   size_t errors_len = arraysize(per_process::uv_errors_map);
@@ -106,11 +108,10 @@ void Initialize(Local<Object> target,
                 void* priv) {
   Environment* env = Environment::GetCurrent(context);
   Isolate* isolate = env->isolate();
-  target->Set(env->context(),
-              FIXED_ONE_BYTE_STRING(isolate, "errname"),
-              env->NewFunctionTemplate(ErrName)
-                  ->GetFunction(env->context())
-                  .ToLocalChecked()).Check();
+  env->SetConstructorFunction(
+      target,
+      "errname",
+      env->NewFunctionTemplate(ErrName));
 
   // TODO(joyeecheung): This should be deprecated in user land in favor of
   // `util.getSystemErrorName(err)`.
diff --git a/src/v8abbr.h b/src/v8abbr.h
index 3cfcb37c907f61d7734be4fc12587e1713f23818..6fa5624fbd9d86458359488def7de319564956b5 100644
--- a/src/v8abbr.h
+++ b/src/v8abbr.h
@@ -91,7 +91,8 @@
     V8_OFF_HEAP(             \
       V8DBG_CLASS_SHAREDFUNCTIONINFO__NAME_OR_SCOPE_INFO__OBJECT)
 #define V8_OFF_SHARED_SCRIPT  \
-    V8_OFF_HEAP(V8DBG_CLASS_SHAREDFUNCTIONINFO__SCRIPT_OR_DEBUG_INFO__OBJECT)
+    V8_OFF_HEAP(              \
+        V8DBG_CLASS_SHAREDFUNCTIONINFO__SCRIPT_OR_DEBUG_INFO__HEAPOBJECT)
 #define V8_OFF_SHARED_FUNIDENT \
     V8_OFF_HEAP(               \
       V8DBG_CLASS_SHAREDFUNCTIONINFO__NAME_OR_SCOPE_INFO__OBJECT)
diff --git a/test/README.md b/test/README.md
index ad9d87a7e930513f231f166db44dd20d09672d1d..cc3725764da54375af470ea3cc4bf2f2e308c33c 100644
--- a/test/README.md
+++ b/test/README.md
@@ -13,27 +13,27 @@ For the tests to run on Windows, be sure to clone Node.js source code with the
 
 ## Test Directories
 
-| Directory           | Runs on CI      | Purpose         |
-| ------------------- | --------------- | --------------- |
-| `abort`             | Yes             | Tests for when the `--abort-on-uncaught-exception` flag is used. |
-| `addons`            | Yes             | Tests for [addon](https://nodejs.org/api/addons.html) functionality along with some tests that require an addon. |
-| `async-hooks`        | Yes            | Tests for [async_hooks](https://nodejs.org/api/async_hooks.html) functionality. |
-| `benchmark`          | No             | Test minimal functionality of benchmarks. |
-| `cctest`             | Yes            | C++ tests that are run as part of the build process. |
-| `code-cache`         | No             | Tests for a Node.js binary compiled with V8 code cache. |
-| `common`             |                | Common modules shared among many tests. [Documentation](./common/README.md) |
-| `doctool`            | Yes            | Tests for the documentation generator. |
-| `es-module`          | Yes            | Test ESM module loading. |
-| `fixtures`           |                | Test fixtures used in various tests throughout the test suite. |
-| `internet`           | No             | Tests that make real outbound network connections. Tests for networking related modules may also be present in other directories, but those tests do not make outbound connections. |
-| `js-native-api`      | Yes            | Tests for Node.js-agnostic [n-api](https://nodejs.org/api/n-api.html) functionality. |
-| `known_issues`       | Yes            | Tests reproducing known issues within the system. All tests inside of this directory are expected to fail. If a test doesn't fail on certain platforms, those should be skipped via `known_issues.status`. |
-| `message`            | Yes            | Tests for messages that are output for various conditions (`console.log`, error messages etc.) |
-| `node-api`           | Yes            | Tests for Node.js-specific [n-api](https://nodejs.org/api/n-api.html) functionality. |
-| `parallel`           | Yes            | Various tests that are able to be run in parallel. |
-| `pseudo-tty`         | Yes            | Tests that require stdin/stdout/stderr to be a TTY. |
-| `pummel`             | No             | Various tests for various modules / system functionality operating under load. |
-| `sequential`         | Yes            | Various tests that must not run in parallel. |
-| `testpy`             |                | Test configuration utility used by various test suites. |
-| `tick-processor`     | No             | Tests for the V8 tick processor integration. The tests are for the logic in `lib/internal/v8_prof_processor.js` and `lib/internal/v8_prof_polyfill.js`. The tests confirm that the profile processor packages the correct set of scripts from V8 and introduces the correct platform specific logic. |
-| `v8-updates`         | No             | Tests for V8 performance integration. |
+| Directory        | Runs on CI | Purpose         |
+| ---------------- | ---------- | --------------- |
+| `abort`          | Yes        | Tests that use `--abort-on-uncaught-exception` and other situations where we want to test something but avoid generating a core file. |
+| `addons`         | Yes        | Tests for [addon](https://nodejs.org/api/addons.html) functionality along with some tests that require an addon. |
+| `async-hooks`    | Yes       | Tests for [async_hooks](https://nodejs.org/api/async_hooks.html) functionality. |
+| `benchmark`      | Yes       | Test minimal functionality of benchmarks. |
+| `cctest`         | Yes       | C++ tests that are run as part of the build process. |
+| `code-cache`     | No        | Tests for a Node.js binary compiled with V8 code cache. |
+| `common`         |           | Common modules shared among many tests. [Documentation](./common/README.md) |
+| `doctool`        | Yes       | Tests for the documentation generator. |
+| `es-module`      | Yes       | Test ESM module loading. |
+| `fixtures`       |                | Test fixtures used in various tests throughout the test suite. |
+| `internet`       | No        | Tests that make real outbound network connections. Tests for networking related modules may also be present in other directories, but those tests do not make outbound connections. |
+| `js-native-api`  | Yes       | Tests for Node.js-agnostic [n-api](https://nodejs.org/api/n-api.html) functionality. |
+| `known_issues`   | Yes       | Tests reproducing known issues within the system. All tests inside of this directory are expected to fail. If a test doesn't fail on certain platforms, those should be skipped via `known_issues.status`. |
+| `message`        | Yes       | Tests for messages that are output for various conditions (`console.log`, error messages etc.) |
+| `node-api`       | Yes       | Tests for Node.js-specific [n-api](https://nodejs.org/api/n-api.html) functionality. |
+| `parallel`       | Yes       | Various tests that are able to be run in parallel. |
+| `pseudo-tty`     | Yes       | Tests that require stdin/stdout/stderr to be a TTY. |
+| `pummel`         | No        | Various tests for various modules / system functionality operating under load. |
+| `sequential`     | Yes       | Various tests that must not run in parallel. |
+| `testpy`         |           | Test configuration utility used by various test suites. |
+| `tick-processor` | No        | Tests for the V8 tick processor integration. The tests are for the logic in `lib/internal/v8_prof_processor.js` and `lib/internal/v8_prof_polyfill.js`. The tests confirm that the profile processor packages the correct set of scripts from V8 and introduces the correct platform specific logic. |
+| `v8-updates`     | No        | Tests for V8 performance integration. |
diff --git a/test/abort/abort.status b/test/abort/abort.status
new file mode 100644
index 0000000000000000000000000000000000000000..e56c24ff433d63e44a3e1f84deb7974442e6741f
--- /dev/null
+++ b/test/abort/abort.status
@@ -0,0 +1,11 @@
+prefix abort
+
+# To mark a test as flaky, list the test name in the appropriate section
+# below, without ".js", followed by ": PASS,FLAKY". Example:
+# sample-test                        : PASS,FLAKY
+
+[true] # This section applies to all platforms
+
+[$system==ibmi]
+# https://github.com/nodejs/node/issues/34410
+test-addon-register-signal-handler: PASS,FLAKY
diff --git a/test/pummel/test-abort-fatal-error.js b/test/abort/test-abort-fatal-error.js
similarity index 100%
rename from test/pummel/test-abort-fatal-error.js
rename to test/abort/test-abort-fatal-error.js
diff --git a/test/abort/test-addon-register-signal-handler.js b/test/abort/test-addon-register-signal-handler.js
new file mode 100644
index 0000000000000000000000000000000000000000..63ce4e1dbe38c5446fcd1066f9c91e8aec53eb86
--- /dev/null
+++ b/test/abort/test-addon-register-signal-handler.js
@@ -0,0 +1,7 @@
+'use strict';
+require('../common');
+
+// This is a sibling test to test/addons/register-signal-handler/
+
+process.env.ALLOW_CRASHES = true;
+require('../addons/register-signal-handler/test');
diff --git a/test/abort/test-signal-handler.js b/test/abort/test-signal-handler.js
new file mode 100644
index 0000000000000000000000000000000000000000..6ee7e4098af70299ff1562b989fd36d29612be9a
--- /dev/null
+++ b/test/abort/test-signal-handler.js
@@ -0,0 +1,24 @@
+'use strict';
+const common = require('../common');
+if (common.isWindows)
+  common.skip('No signals on Window');
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+// Test that a hard crash does not cause an endless loop.
+
+if (process.argv[2] === 'child') {
+  const { internalBinding } = require('internal/test/binding');
+  const { causeSegfault } = internalBinding('process_methods');
+
+  causeSegfault();
+} else {
+  const child = spawnSync(process.execPath,
+                          ['--expose-internals', __filename, 'child'],
+                          { stdio: 'inherit' });
+  // FreeBSD uses SIGILL for this kind of crash.
+  // macOS uses SIGILL or SIGTRAP (arm64) for this kind of crash.
+  assert(child.signal === 'SIGSEGV' || child.signal === 'SIGILL' ||
+          child.signal === 'SIGTRAP', `child.signal = ${child.signal}`);
+}
diff --git a/test/abort/test-worker-abort-uncaught-exception.js b/test/abort/test-worker-abort-uncaught-exception.js
index 63f7acdddc7fd7b51e4a7b278fdeea2dc83a916a..141e2cacdbe69bbeb6a1ff76ea78d564af77783f 100644
--- a/test/abort/test-worker-abort-uncaught-exception.js
+++ b/test/abort/test-worker-abort-uncaught-exception.js
@@ -12,7 +12,7 @@ if (process.argv[2] === 'child') {
 }
 
 const child = spawn(process.execPath, [
-  '--abort-on-uncaught-exception', __filename, 'child'
+  '--abort-on-uncaught-exception', __filename, 'child',
 ]);
 child.on('exit', common.mustCall((code, sig) => {
   if (common.isWindows) {
diff --git a/test/addons/addon.status b/test/addons/addons.status
similarity index 77%
rename from test/addons/addon.status
rename to test/addons/addons.status
index 951cddc48465d138b2716c005fe4d1560133fd4f..74c29ecd99888b5e5ec2371419d69cf3daffa5f6 100644
--- a/test/addons/addon.status
+++ b/test/addons/addons.status
@@ -9,7 +9,10 @@ prefix addons
 [$arch==arm]
 # https://github.com/nodejs/node/issues/30786
 openssl-binding/test: PASS,FLAKY
+zlib-binding/test: PASS,FLAKY
 
 [$system==ibmi]
 openssl-binding/test: SKIP
 zlib-binding/test: SKIP
+# https://github.com/nodejs/node/issues/34410
+register-signal-handler/test: PASS,FLAKY
diff --git a/test/addons/async-cleanup-hook/binding.cc b/test/addons/async-cleanup-hook/binding.cc
index d18da7a094f71a94fdb5f3aa832bd54388706f6a..0a11220850fca2907f056128c4cae8d8c067651d 100644
--- a/test/addons/async-cleanup-hook/binding.cc
+++ b/test/addons/async-cleanup-hook/binding.cc
@@ -1,6 +1,6 @@
-#include <assert.h>
 #include <node.h>
 #include <uv.h>
+#include <assert.h>
 
 void MustNotCall(void* arg, void(*cb)(void*), void* cbarg) {
   assert(0);
diff --git a/test/addons/async-hooks-promise/binding.cc b/test/addons/async-hooks-promise/binding.cc
deleted file mode 100644
index 1571690edead24638f436c628084a1b2a3db12aa..0000000000000000000000000000000000000000
--- a/test/addons/async-hooks-promise/binding.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <node.h>
-#include <v8.h>
-
-namespace {
-
-using v8::FunctionCallbackInfo;
-using v8::Isolate;
-using v8::Local;
-using v8::NewStringType;
-using v8::Object;
-using v8::Promise;
-using v8::String;
-using v8::Value;
-
-static void ThrowError(Isolate* isolate, const char* err_msg) {
-  Local<String> str = String::NewFromOneByte(
-      isolate,
-      reinterpret_cast<const uint8_t*>(err_msg),
-      NewStringType::kNormal).ToLocalChecked();
-  isolate->ThrowException(str);
-}
-
-static void GetPromiseField(const FunctionCallbackInfo<Value>& args) {
-  auto isolate = args.GetIsolate();
-
-  if (!args[0]->IsPromise())
-    return ThrowError(isolate, "arg is not an Promise");
-
-  auto p = args[0].As<Promise>();
-  if (p->InternalFieldCount() < 1)
-    return ThrowError(isolate, "Promise has no internal field");
-
-  auto l = p->GetInternalField(0);
-  args.GetReturnValue().Set(l);
-}
-
-inline void Initialize(v8::Local<v8::Object> binding) {
-  NODE_SET_METHOD(binding, "getPromiseField", GetPromiseField);
-}
-
-NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
-
-}  // anonymous namespace
diff --git a/test/addons/async-hooks-promise/test.js b/test/addons/async-hooks-promise/test.js
deleted file mode 100644
index a6c48e94a34f074f22d702acfe7d5c81643f5924..0000000000000000000000000000000000000000
--- a/test/addons/async-hooks-promise/test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-'use strict';
-
-const common = require('../../common');
-const assert = require('assert');
-const async_hooks = require('async_hooks');
-const binding = require(`./build/${common.buildType}/binding`);
-
-if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) {
-  common.skip('cannot test with env var NODE_TEST_WITH_ASYNC_HOOKS');
-  return;
-}
-
-// Baseline to make sure the internal field isn't being set.
-assert.strictEqual(
-  binding.getPromiseField(Promise.resolve(1)),
-  0);
-
-const hook0 = async_hooks.createHook({}).enable();
-
-// Check that no PromiseWrap is created when there are no hook callbacks.
-assert.strictEqual(
-  binding.getPromiseField(Promise.resolve(1)),
-  0);
-
-hook0.disable();
-
-let pwrap = null;
-const hook1 = async_hooks.createHook({
-  init(id, type, tid, resource) {
-    pwrap = resource;
-  }
-}).enable();
-
-// Check that the internal field returns the same PromiseWrap passed to init().
-assert.strictEqual(
-  binding.getPromiseField(Promise.resolve(1)),
-  pwrap);
-
-hook1.disable();
-
-// Check that internal fields are no longer being set. This needs to be delayed
-// a bit because the `disable()` call only schedules disabling the hook in a
-// future microtask.
-setImmediate(() => {
-  assert.strictEqual(
-    binding.getPromiseField(Promise.resolve(1)),
-    0);
-});
diff --git a/test/addons/async-resource/binding.cc b/test/addons/async-resource/binding.cc
index ab33858c233dd03ef28f88e7354d90a781286610..6fd9b37cbeda40f7e107ac1df0fa8920cd74ee71 100644
--- a/test/addons/async-resource/binding.cc
+++ b/test/addons/async-resource/binding.cc
@@ -55,8 +55,7 @@ void CallViaFunction(const FunctionCallbackInfo<Value>& args) {
   auto r = static_cast<AsyncResource*>(args[0].As<External>()->Value());
 
   Local<String> name =
-      String::NewFromUtf8(isolate, "methöd", v8::NewStringType::kNormal)
-      .ToLocalChecked();
+      String::NewFromUtf8(isolate, "methöd").ToLocalChecked();
   Local<Value> fn =
       r->get_resource()->Get(isolate->GetCurrentContext(), name)
       .ToLocalChecked();
@@ -73,8 +72,7 @@ void CallViaString(const FunctionCallbackInfo<Value>& args) {
   auto r = static_cast<AsyncResource*>(args[0].As<External>()->Value());
 
   Local<String> name =
-      String::NewFromUtf8(isolate, "methöd", v8::NewStringType::kNormal)
-      .ToLocalChecked();
+      String::NewFromUtf8(isolate, "methöd").ToLocalChecked();
 
   Local<Value> arg = Integer::New(isolate, 42);
   MaybeLocal<Value> ret = r->MakeCallback(name, 1, &arg);
diff --git a/test/addons/dlopen-ping-pong/binding.cc b/test/addons/dlopen-ping-pong/binding.cc
index 7b211be1195bf7c2d533b018631f32e3c0978726..be33708c9317d3f97e9c2ddbf4c2ad5f3f231e50 100644
--- a/test/addons/dlopen-ping-pong/binding.cc
+++ b/test/addons/dlopen-ping-pong/binding.cc
@@ -17,7 +17,6 @@ using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
 using v8::Object;
-using v8::NewStringType;
 using v8::String;
 using v8::Value;
 
@@ -38,7 +37,7 @@ void Ping(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   assert(ping_func != nullptr);
   args.GetReturnValue().Set(String::NewFromUtf8(
-        isolate, ping_func(), NewStringType::kNormal).ToLocalChecked());
+        isolate, ping_func()).ToLocalChecked());
 }
 
 void init(Local<Object> exports) {
diff --git a/test/addons/heap-profiler/binding.cc b/test/addons/heap-profiler/binding.cc
index 9e1e97e9fc2afc4493776f16a852ec0ed0d594c4..98156d5548960ebe60c91873c72c5c38bc8d81d8 100644
--- a/test/addons/heap-profiler/binding.cc
+++ b/test/addons/heap-profiler/binding.cc
@@ -20,7 +20,7 @@ inline void Initialize(v8::Local<v8::Object> binding) {
   v8::Isolate* const isolate = binding->GetIsolate();
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   binding->Set(context, v8::String::NewFromUtf8(
-        isolate, "test", v8::NewStringType::kNormal).ToLocalChecked(),
+        isolate, "test").ToLocalChecked(),
                v8::FunctionTemplate::New(isolate, Test)
                    ->GetFunction(context)
                    .ToLocalChecked()).FromJust();
diff --git a/test/addons/hello-world-function-export/binding.cc b/test/addons/hello-world-function-export/binding.cc
index e5476c4ee1e3640863ea5b81e71b177502e50b4c..525b8cc732b4b1c4915b5c1408c23193320b1e00 100644
--- a/test/addons/hello-world-function-export/binding.cc
+++ b/test/addons/hello-world-function-export/binding.cc
@@ -4,7 +4,7 @@
 void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(v8::String::NewFromUtf8(
-        isolate, "world", v8::NewStringType::kNormal).ToLocalChecked());
+        isolate, "world").ToLocalChecked());
 }
 
 void init(v8::Local<v8::Object> exports, v8::Local<v8::Object> module) {
diff --git a/test/addons/hello-world/binding.cc b/test/addons/hello-world/binding.cc
index f2d26b53e985cffe2238862f1b33261f491cd480..77de6c45a3a8f18adce8ca1a7cb13f29b399389e 100644
--- a/test/addons/hello-world/binding.cc
+++ b/test/addons/hello-world/binding.cc
@@ -4,7 +4,7 @@
 static void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(v8::String::NewFromUtf8(
-        isolate, "world", v8::NewStringType::kNormal).ToLocalChecked());
+        isolate, "world").ToLocalChecked());
 }
 
 // Not using the full NODE_MODULE_INIT() macro here because we want to test the
@@ -21,8 +21,7 @@ static void FakeInit(v8::Local<v8::Object> exports,
                      v8::Local<v8::Context> context) {
   auto isolate = context->GetIsolate();
   auto exception = v8::Exception::Error(v8::String::NewFromUtf8(isolate,
-      "FakeInit should never run!", v8::NewStringType::kNormal)
-          .ToLocalChecked());
+      "FakeInit should never run!").ToLocalChecked());
   isolate->ThrowException(exception);
 }
 
diff --git a/test/addons/load-long-path/binding.cc b/test/addons/load-long-path/binding.cc
index 02eecec099807a1add9d1fdc8dad4e0798abd7cf..cd9fdf7f406c664fd7507804e526e7bddccafc51 100644
--- a/test/addons/load-long-path/binding.cc
+++ b/test/addons/load-long-path/binding.cc
@@ -4,7 +4,7 @@
 void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(v8::String::NewFromUtf8(
-        isolate, "world", v8::NewStringType::kNormal).ToLocalChecked());
+        isolate, "world").ToLocalChecked());
 }
 
 void init(v8::Local<v8::Object> exports) {
diff --git a/test/addons/load-long-path/test.js b/test/addons/load-long-path/test.js
index 0160591746dc2ec97bcfdff7c0464cd8ad7ddc8a..9a9d0763994b0843989284d8c5308a843adb4984 100644
--- a/test/addons/load-long-path/test.js
+++ b/test/addons/load-long-path/test.js
@@ -6,9 +6,9 @@ if (common.isWindows && (process.env.PROCESSOR_ARCHITEW6432 !== undefined))
 const fs = require('fs');
 const path = require('path');
 const assert = require('assert');
+const { fork } = require('child_process');
 
 const tmpdir = require('../../common/tmpdir');
-tmpdir.refresh();
 
 // Make a path that is more than 260 chars long.
 // Any given folder cannot have a name longer than 260 characters,
@@ -17,7 +17,6 @@ let addonDestinationDir = path.resolve(tmpdir.path);
 
 for (let i = 0; i < 10; i++) {
   addonDestinationDir = path.join(addonDestinationDir, 'x'.repeat(30));
-  fs.mkdirSync(addonDestinationDir);
 }
 
 const addonPath = path.join(__dirname,
@@ -26,11 +25,29 @@ const addonPath = path.join(__dirname,
                             'binding.node');
 const addonDestinationPath = path.join(addonDestinationDir, 'binding.node');
 
+// Loading an addon keeps the file open until the process terminates. Load
+// the addon in a child process so that when the parent terminates the file
+// is already closed and the tmpdir can be cleaned up.
+
+// Child
+if (process.argv[2] === 'child') {
+  // Attempt to load at long path destination
+  const addon = require(addonDestinationPath);
+  assert.notStrictEqual(addon, null);
+  assert.strictEqual(addon.hello(), 'world');
+  return;
+}
+
+// Parent
+tmpdir.refresh();
+
 // Copy binary to long path destination
+fs.mkdirSync(addonDestinationDir, { recursive: true });
 const contents = fs.readFileSync(addonPath);
 fs.writeFileSync(addonDestinationPath, contents);
 
-// Attempt to load at long path destination
-const addon = require(addonDestinationPath);
-assert.notStrictEqual(addon, null);
-assert.strictEqual(addon.hello(), 'world');
+// Run test
+const child = fork(__filename, ['child'], { stdio: 'inherit' });
+child.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 0);
+}));
diff --git a/test/addons/make-callback-domain-warning/test.js b/test/addons/make-callback-domain-warning/test.js
index 0377415e1269aa8236cccc4a6677c02707a0dd30..e6eaa9d337c179d508e33e630d0d4c13742c5fc5 100644
--- a/test/addons/make-callback-domain-warning/test.js
+++ b/test/addons/make-callback-domain-warning/test.js
@@ -6,7 +6,7 @@ const domain = require('domain');
 const binding = require(`./build/${common.buildType}/binding`);
 
 function makeCallback(object, cb) {
-  binding.makeCallback(object, () => setImmediate(cb));
+  binding.makeCallback(object, function someMethod() { setImmediate(cb); });
 }
 
 let latestWarning = null;
@@ -16,8 +16,14 @@ process.on('warning', (warning) => {
 
 const d = domain.create();
 
+class Resource {
+  constructor(domain) {
+    this.domain = domain;
+  }
+}
+
 // When domain is disabled, no warning will be emitted
-makeCallback({ domain: d }, common.mustCall(() => {
+makeCallback(new Resource(d), common.mustCall(() => {
   assert.strictEqual(latestWarning, null);
 
   d.run(common.mustCall(() => {
@@ -26,7 +32,9 @@ makeCallback({ domain: d }, common.mustCall(() => {
       assert.strictEqual(latestWarning, null);
 
       // Warning is emitted when domain property is used and domain is enabled
-      makeCallback({ domain: d }, common.mustCall(() => {
+      makeCallback(new Resource(d), common.mustCall(() => {
+        assert.match(latestWarning.message,
+                     /Triggered by calling someMethod on Resource\./);
         assert.strictEqual(latestWarning.name, 'DeprecationWarning');
         assert.strictEqual(latestWarning.code, 'DEP0097');
       }));
diff --git a/test/addons/new-target/binding.cc b/test/addons/new-target/binding.cc
index 48ceeb55ca1aae140a702e49339268d6eb398460..ba747fbbe87ea7f1dad5972e98034bfc47c67701 100644
--- a/test/addons/new-target/binding.cc
+++ b/test/addons/new-target/binding.cc
@@ -13,7 +13,7 @@ inline void Initialize(v8::Local<v8::Object> binding) {
   auto isolate = binding->GetIsolate();
   auto context = isolate->GetCurrentContext();
   binding->Set(context, v8::String::NewFromUtf8(
-        isolate, "Class", v8::NewStringType::kNormal).ToLocalChecked(),
+        isolate, "Class").ToLocalChecked(),
                v8::FunctionTemplate::New(isolate, NewClass)
                    ->GetFunction(context)
                    .ToLocalChecked()).FromJust();
diff --git a/test/addons/non-node-context/binding.cc b/test/addons/non-node-context/binding.cc
index 776786cef5180f4c1ba460c512c2f0653ebc8c8d..8423d2b1d7a5a5ec8c0e74c2aa901a34c09b26e8 100644
--- a/test/addons/non-node-context/binding.cc
+++ b/test/addons/non-node-context/binding.cc
@@ -5,12 +5,9 @@
 namespace {
 
 using v8::Context;
-using v8::Function;
-using v8::FunctionTemplate;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
-using v8::NewStringType;
 using v8::Object;
 using v8::Script;
 using v8::String;
@@ -35,8 +32,7 @@ inline void RunInNewContext(
 
   context->Global()->Set(
       context,
-      String::NewFromUtf8(isolate, "data", NewStringType::kNormal)
-          .ToLocalChecked(),
+      String::NewFromUtf8(isolate, "data").ToLocalChecked(),
       args[1]).FromJust();
 
   assert(args[0]->IsString());  // source code
diff --git a/test/addons/null-buffer-neuter/binding.cc b/test/addons/null-buffer-neuter/binding.cc
index 4c9dbf902589d90da4765dd8263176b1ceeb2aa2..7575e29fa85084aba45e4f303eb4f646dd06df0c 100644
--- a/test/addons/null-buffer-neuter/binding.cc
+++ b/test/addons/null-buffer-neuter/binding.cc
@@ -11,6 +11,10 @@ static void FreeCallback(char* data, void* hint) {
   alive--;
 }
 
+void IsAlive(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  args.GetReturnValue().Set(alive);
+}
+
 void Run(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   alive++;
@@ -27,15 +31,11 @@ void Run(const v8::FunctionCallbackInfo<v8::Value>& args) {
     char* data = node::Buffer::Data(buf);
     assert(data == nullptr);
   }
-
-  isolate->RequestGarbageCollectionForTesting(
-      v8::Isolate::kFullGarbageCollection);
-
-  assert(alive == 0);
 }
 
 void init(v8::Local<v8::Object> exports) {
   NODE_SET_METHOD(exports, "run", Run);
+  NODE_SET_METHOD(exports, "isAlive", IsAlive);
 }
 
 NODE_MODULE(NODE_GYP_MODULE_NAME, init)
diff --git a/test/addons/null-buffer-neuter/test.js b/test/addons/null-buffer-neuter/test.js
index 3fc335914c9a44de79b0e198f6dec60048bc7f70..d99690542a4d843d395a769aad495910084e3604 100644
--- a/test/addons/null-buffer-neuter/test.js
+++ b/test/addons/null-buffer-neuter/test.js
@@ -1,7 +1,11 @@
 'use strict';
 // Flags: --expose-gc
-
 const common = require('../../common');
+const assert = require('assert');
 const binding = require(`./build/${common.buildType}/binding`);
 
 binding.run();
+global.gc();
+setImmediate(() => {
+  assert.strictEqual(binding.isAlive(), 0);
+});
diff --git a/test/addons/openssl-binding/binding.cc b/test/addons/openssl-binding/binding.cc
index ecda40f4cb50a3872f8edb4a56d050494eb385fa..79472dd7f25272e21087c124a6f8a71bfd4ad9c9 100644
--- a/test/addons/openssl-binding/binding.cc
+++ b/test/addons/openssl-binding/binding.cc
@@ -1,7 +1,7 @@
-#include <node.h>
-#include <assert.h>
 #include <openssl/rand.h>
 #include <openssl/ssl.h>
+#include <node.h>
+#include <assert.h>
 
 namespace {
 
@@ -12,8 +12,8 @@ inline void RandomBytes(const v8::FunctionCallbackInfo<v8::Value>& info) {
   auto byte_length = view->ByteLength();
   assert(view->HasBuffer());
   auto buffer = view->Buffer();
-  auto contents = buffer->GetContents();
-  auto data = static_cast<unsigned char*>(contents.Data()) + byte_offset;
+  auto contents = buffer->GetBackingStore();
+  auto data = static_cast<unsigned char*>(contents->Data()) + byte_offset;
   assert(RAND_poll());
   auto rval = RAND_bytes(data, static_cast<int>(byte_length));
   info.GetReturnValue().Set(rval > 0);
@@ -24,7 +24,7 @@ inline void Initialize(v8::Local<v8::Object> exports,
                        v8::Local<v8::Context> context) {
   auto isolate = context->GetIsolate();
   auto key = v8::String::NewFromUtf8(
-      isolate, "randomBytes", v8::NewStringType::kNormal).ToLocalChecked();
+      isolate, "randomBytes").ToLocalChecked();
   auto value = v8::FunctionTemplate::New(isolate, RandomBytes)
                    ->GetFunction(context)
                    .ToLocalChecked();
diff --git a/test/addons/openssl-client-cert-engine/testengine.cc b/test/addons/openssl-client-cert-engine/testengine.cc
index 7ccb56e08015a7153fdc98ddde7e1a4d98a382a3..95712901e69c8bdff9b7e0b72ab5ea7a33152654 100644
--- a/test/addons/openssl-client-cert-engine/testengine.cc
+++ b/test/addons/openssl-client-cert-engine/testengine.cc
@@ -1,10 +1,10 @@
+#include <openssl/engine.h>
+#include <openssl/pem.h>
+
 #include <assert.h>
 #include <string.h>
 #include <stdlib.h>
 
-#include <openssl/engine.h>
-#include <openssl/pem.h>
-
 #include <fstream>
 #include <iterator>
 #include <string>
diff --git a/test/addons/openssl-key-engine/testkeyengine.cc b/test/addons/openssl-key-engine/testkeyengine.cc
index e1dc22164ac4c137d245f3df4d9e8c9e24f0eab8..704027ba5a43d268a853bc5c322353b8b4b086d5 100644
--- a/test/addons/openssl-key-engine/testkeyengine.cc
+++ b/test/addons/openssl-key-engine/testkeyengine.cc
@@ -1,10 +1,10 @@
+#include <openssl/engine.h>
+#include <openssl/pem.h>
+
 #include <assert.h>
 #include <string.h>
 #include <stdlib.h>
 
-#include <openssl/engine.h>
-#include <openssl/pem.h>
-
 #include <fstream>
 #include <iterator>
 #include <string>
diff --git a/test/addons/parse-encoding/binding.cc b/test/addons/parse-encoding/binding.cc
index 1501544153ad62e379627ac84317ede01d05c915..7fae5bf4bdb61c50b3c533886700274737bc1d30 100644
--- a/test/addons/parse-encoding/binding.cc
+++ b/test/addons/parse-encoding/binding.cc
@@ -6,6 +6,7 @@ namespace {
 #define ENCODING_MAP(V) \
   V(ASCII)              \
   V(BASE64)             \
+  V(BASE64URL)          \
   V(BUFFER)             \
   V(HEX)                \
   V(LATIN1)             \
@@ -23,8 +24,7 @@ void ParseEncoding(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ENCODING_MAP(V)
 #undef V
   auto encoding_string =
-      v8::String::NewFromUtf8(args.GetIsolate(), encoding_name,
-                              v8::NewStringType::kNormal)
+      v8::String::NewFromUtf8(args.GetIsolate(), encoding_name)
       .ToLocalChecked();
   args.GetReturnValue().Set(encoding_string);
 }
diff --git a/test/addons/parse-encoding/test.js b/test/addons/parse-encoding/test.js
index 1456115a926f3e4b8c33ea174ce5844fccdbc059..da52f2dc4248afedd0f3705b185da479aacb6869 100644
--- a/test/addons/parse-encoding/test.js
+++ b/test/addons/parse-encoding/test.js
@@ -8,6 +8,7 @@ assert.strictEqual(parseEncoding(''), 'UNKNOWN');
 
 assert.strictEqual(parseEncoding('ascii'), 'ASCII');
 assert.strictEqual(parseEncoding('base64'), 'BASE64');
+assert.strictEqual(parseEncoding('base64url'), 'BASE64URL');
 assert.strictEqual(parseEncoding('binary'), 'LATIN1');
 assert.strictEqual(parseEncoding('buffer'), 'BUFFER');
 assert.strictEqual(parseEncoding('hex'), 'HEX');
diff --git a/test/addons/register-signal-handler/binding.cc b/test/addons/register-signal-handler/binding.cc
new file mode 100644
index 0000000000000000000000000000000000000000..01580578d159c4d5ea77c693b4ccda21a27fb23e
--- /dev/null
+++ b/test/addons/register-signal-handler/binding.cc
@@ -0,0 +1,36 @@
+#ifndef _WIN32
+#include <node.h>
+#include <v8.h>
+#include <uv.h>
+#include <assert.h>
+#include <unistd.h>
+
+using v8::Boolean;
+using v8::FunctionCallbackInfo;
+using v8::Int32;
+using v8::Value;
+
+void Handler(int signo, siginfo_t* siginfo, void* ucontext) {
+  char signo_char = signo;
+  int written;
+  do {
+    written = write(1, &signo_char, 1);  // write() is signal-safe.
+  } while (written == -1 && errno == EINTR);
+  assert(written == 1);
+}
+
+void RegisterSignalHandler(const FunctionCallbackInfo<Value>& args) {
+  assert(args[0]->IsInt32());
+  assert(args[1]->IsBoolean());
+
+  int32_t signo = args[0].As<Int32>()->Value();
+  bool reset_handler = args[1].As<Boolean>()->Value();
+
+  node::RegisterSignalHandler(signo, Handler, reset_handler);
+}
+
+NODE_MODULE_INIT() {
+  NODE_SET_METHOD(exports, "registerSignalHandler", RegisterSignalHandler);
+}
+
+#endif  // _WIN32
diff --git a/test/addons/async-hooks-promise/binding.gyp b/test/addons/register-signal-handler/binding.gyp
similarity index 100%
rename from test/addons/async-hooks-promise/binding.gyp
rename to test/addons/register-signal-handler/binding.gyp
diff --git a/test/addons/register-signal-handler/test.js b/test/addons/register-signal-handler/test.js
new file mode 100644
index 0000000000000000000000000000000000000000..145baf2da610e661cb14fbef0cc5ec35096e4315
--- /dev/null
+++ b/test/addons/register-signal-handler/test.js
@@ -0,0 +1,56 @@
+'use strict';
+const common = require('../../common');
+if (common.isWindows)
+  common.skip('No RegisterSignalHandler() on Windows');
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { signals } = require('os').constants;
+const { spawnSync } = require('child_process');
+
+const bindingPath = path.resolve(
+  __dirname, 'build', common.buildType, 'binding.node');
+
+if (!fs.existsSync(bindingPath))
+  common.skip('binding not built yet');
+
+const binding = require(bindingPath);
+
+if (process.argv[2] === 'child') {
+  const signo = +process.argv[3];
+  const reset = process.argv[4] === 'reset';
+  const count = +process.argv[5];
+
+  binding.registerSignalHandler(signo, reset);
+  for (let i = 0; i < count; i++)
+    process.kill(process.pid, signo);
+  return;
+}
+
+for (const raiseSignal of [ 'SIGABRT', 'SIGSEGV' ]) {
+  const signo = signals[raiseSignal];
+  for (const { reset, count, stderr, code, signal } of [
+    { reset: true, count: 1, stderr: [signo], code: 0, signal: null },
+    { reset: true, count: 2, stderr: [signo], code: null, signal: raiseSignal },
+    { reset: false, count: 1, stderr: [signo], code: 0, signal: null },
+    { reset: false, count: 2, stderr: [signo, signo], code: 0, signal: null },
+  ]) {
+    // We do not want to generate core files when running this test as an
+    // addon test. We require this file as an abort test as well, though,
+    // with ALLOW_CRASHES set.
+    if (signal !== null && !process.env.ALLOW_CRASHES)
+      continue;
+    // reset_handler does not work with SIGSEGV.
+    if (reset && signo === signals.SIGSEGV)
+      continue;
+
+    const args = [__filename, 'child', signo, reset ? 'reset' : '', count];
+    console.log(`Running: node ${args.join(' ')}`);
+    const result = spawnSync(
+      process.execPath, args, { stdio: ['inherit', 'pipe', 'inherit'] });
+    assert.strictEqual(result.status, code);
+    assert.strictEqual(result.signal, signal);
+    assert.deepStrictEqual([...result.stdout], stderr);
+  }
+}
diff --git a/test/addons/repl-domain-abort/binding.cc b/test/addons/repl-domain-abort/binding.cc
index 3e716443540229655672f8637c88750cac6ace6b..f5e82d3718ccac7251ac16b93f3b6effe72a8786 100644
--- a/test/addons/repl-domain-abort/binding.cc
+++ b/test/addons/repl-domain-abort/binding.cc
@@ -25,8 +25,8 @@
 using v8::Boolean;
 using v8::Function;
 using v8::FunctionCallbackInfo;
-using v8::Local;
 using v8::Isolate;
+using v8::Local;
 using v8::Object;
 using v8::Value;
 
diff --git a/test/addons/stringbytes-external-exceed-max/binding.cc b/test/addons/stringbytes-external-exceed-max/binding.cc
index 0e3cd3f4d0a1a16e17c2b531fe267ec83e0bfe4a..c452a093849213f71a74e0d933f739354973f4ba 100644
--- a/test/addons/stringbytes-external-exceed-max/binding.cc
+++ b/test/addons/stringbytes-external-exceed-max/binding.cc
@@ -1,6 +1,6 @@
-#include <stdlib.h>
 #include <node.h>
 #include <v8.h>
+#include <stdlib.h>
 
 #ifdef _AIX
 // AIX allows over-allocation, and will SIGKILL when the allocated pages are
diff --git a/test/addons/symlinked-module/binding.cc b/test/addons/symlinked-module/binding.cc
index 02eecec099807a1add9d1fdc8dad4e0798abd7cf..cd9fdf7f406c664fd7507804e526e7bddccafc51 100644
--- a/test/addons/symlinked-module/binding.cc
+++ b/test/addons/symlinked-module/binding.cc
@@ -4,7 +4,7 @@
 void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(v8::String::NewFromUtf8(
-        isolate, "world", v8::NewStringType::kNormal).ToLocalChecked());
+        isolate, "world").ToLocalChecked());
 }
 
 void init(v8::Local<v8::Object> exports) {
diff --git a/test/addons/testcfg.py b/test/addons/testcfg.py
index 908fd6a475cc39f554265ec0dcba18503c082bff..6c61081fbb0bac7f45b64cc614f29264d9ad8712 100644
--- a/test/addons/testcfg.py
+++ b/test/addons/testcfg.py
@@ -3,4 +3,4 @@ sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 import testpy
 
 def GetConfiguration(context, root):
-  return testpy.AddonTestConfiguration(context, root, 'addon')
+  return testpy.AddonTestConfiguration(context, root, 'addons')
diff --git a/test/addons/uv-handle-leak/binding.cc b/test/addons/uv-handle-leak/binding.cc
index 1b769b141c0076bcd4001cc6a00794040b1e1ab4..20ddfac6802e9701a76f9a1732366cc89f2cf8e4 100644
--- a/test/addons/uv-handle-leak/binding.cc
+++ b/test/addons/uv-handle-leak/binding.cc
@@ -6,7 +6,6 @@ using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::Object;
 using v8::Value;
 
 // Give these things names in the public namespace so that we can see
diff --git a/test/addons/worker-addon/binding.cc b/test/addons/worker-addon/binding.cc
index 01c857c43ebcfc622e2568066bf05d2032a93760..5c443e9af1caae21f0efedbf4c693a77f8dd4859 100644
--- a/test/addons/worker-addon/binding.cc
+++ b/test/addons/worker-addon/binding.cc
@@ -1,13 +1,11 @@
-#include <assert.h>
 #include <node.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <v8.h>
 #include <uv.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
 
 using v8::Context;
-using v8::HandleScope;
-using v8::Isolate;
 using v8::Local;
 using v8::Object;
 using v8::Value;
diff --git a/test/addons/worker-addon/test.js b/test/addons/worker-addon/test.js
index f2df4665f53068438be4b8eb45fbea9ea1d239f5..f9923638d48767e1ac60e2314af76a98f3938447 100644
--- a/test/addons/worker-addon/test.js
+++ b/test/addons/worker-addon/test.js
@@ -48,7 +48,7 @@ for (const { test, expected } of [
     // musl doesn't support unloading, so the output may be missing
     // a dtor + ctor pair.
     expected: [
-      'ctor cleanup dtor ctor cleanup dtor '
+      'ctor cleanup dtor ctor cleanup dtor ',
     ].concat(libcMayBeMusl ? [
       'ctor cleanup cleanup dtor ',
     ] : [])
@@ -57,7 +57,7 @@ for (const { test, expected } of [
   console.log('spawning test', test);
   const proc = child_process.spawnSync(process.execPath, [
     __filename,
-    test
+    test,
   ]);
   process.stderr.write(proc.stderr.toString());
   assert.strictEqual(proc.stderr.toString(), '');
diff --git a/test/addons/worker-buffer-callback/binding.cc b/test/addons/worker-buffer-callback/binding.cc
index 3b0ecf82f02ccbaa283624c33a5171e7bc77ef66..9cacc6996243bdb6c41d6b61ea1ad5741ca9c25b 100644
--- a/test/addons/worker-buffer-callback/binding.cc
+++ b/test/addons/worker-buffer-callback/binding.cc
@@ -10,7 +10,6 @@ using v8::Object;
 using v8::Value;
 
 uint32_t free_call_count = 0;
-char data[] = "hello";
 
 void GetFreeCallCount(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(free_call_count);
@@ -21,15 +20,18 @@ void Initialize(Local<Object> exports,
                 Local<Context> context) {
   Isolate* isolate = context->GetIsolate();
   NODE_SET_METHOD(exports, "getFreeCallCount", GetFreeCallCount);
+
+  char* data = new char;
+
   exports->Set(context,
                v8::String::NewFromUtf8(
-                   isolate, "buffer", v8::NewStringType::kNormal)
-                   .ToLocalChecked(),
+                   isolate, "buffer").ToLocalChecked(),
                node::Buffer::New(
                    isolate,
                    data,
                    sizeof(char),
                    [](char* data, void* hint) {
+                     delete data;
                      free_call_count++;
                    },
                    nullptr).ToLocalChecked()).Check();
diff --git a/test/addons/worker-buffer-callback/test.js b/test/addons/worker-buffer-callback/test.js
index b04984f15764329ec7bba28e78f8f2d25e70204c..08625b72384eb1cdcb33e9f983ee790bfe0ba2c7 100644
--- a/test/addons/worker-buffer-callback/test.js
+++ b/test/addons/worker-buffer-callback/test.js
@@ -5,7 +5,7 @@ const { MessageChannel } = require('worker_threads');
 const { buffer } = require(`./build/${common.buildType}/binding`);
 
 // Test that buffers allocated with a free callback through our APIs are not
-// transfered.
+// transferred.
 
 const { port1 } = new MessageChannel();
 const origByteLength = buffer.byteLength;
diff --git a/test/addons/zlib-binding/binding.cc b/test/addons/zlib-binding/binding.cc
index 0b82de211a8430e35c41f541f235786830af2438..3a958f26af1ac6d34ced7640e610e1947cf8ccdd 100644
--- a/test/addons/zlib-binding/binding.cc
+++ b/test/addons/zlib-binding/binding.cc
@@ -1,7 +1,7 @@
 #include <node.h>
 #include <node_buffer.h>
-#include <assert.h>
 #include <zlib.h>
+#include <assert.h>
 
 namespace {
 
@@ -12,8 +12,8 @@ inline void CompressBytes(const v8::FunctionCallbackInfo<v8::Value>& info) {
   auto byte_length = view->ByteLength();
   assert(view->HasBuffer());
   auto buffer = view->Buffer();
-  auto contents = buffer->GetContents();
-  auto data = static_cast<unsigned char*>(contents.Data()) + byte_offset;
+  auto contents = buffer->GetBackingStore();
+  auto data = static_cast<unsigned char*>(contents->Data()) + byte_offset;
 
   Bytef buf[1024];
 
@@ -46,7 +46,7 @@ inline void Initialize(v8::Local<v8::Object> exports,
                        v8::Local<v8::Context> context) {
   auto isolate = context->GetIsolate();
   auto key = v8::String::NewFromUtf8(
-      isolate, "compressBytes", v8::NewStringType::kNormal).ToLocalChecked();
+      isolate, "compressBytes").ToLocalChecked();
   auto value = v8::FunctionTemplate::New(isolate, CompressBytes)
                    ->GetFunction(context)
                    .ToLocalChecked();
diff --git a/test/async-hooks/coverage.md b/test/async-hooks/coverage.md
index 1ba18a938330a9903c748ae34217a59a6f71fa5c..5470297d20625aa7d306f5cbbbe73598b234ffab 100644
--- a/test/async-hooks/coverage.md
+++ b/test/async-hooks/coverage.md
@@ -2,31 +2,31 @@
 
 Showing which kind of async resource is covered by which test:
 
-| Resource Type        | Test                                       |
-|----------------------|--------------------------------------------|
-| CONNECTION           | test-connection.ssl.js                     |
-| FSEVENTWRAP          | test-fseventwrap.js                        |
-| FSREQCALLBACK        | test-fsreqcallback-{access,readFile}.js    |
-| GETADDRINFOREQWRAP   | test-getaddrinforeqwrap.js                 |
-| GETNAMEINFOREQWRAP   | test-getnameinforeqwrap.js                 |
-| HTTPINCOMINGMESSAGE  | test-httpparser.request.js                 |
-| HTTPCLIENTREQUEST    | test-httpparser.response.js                |
-| Immediate            | test-immediate.js                          |
-| JSSTREAM             | TODO (crashes when accessing directly)     |
-| PBKDF2REQUEST        | test-crypto-pbkdf2.js                      |
-| PIPECONNECTWRAP      | test-pipeconnectwrap.js                    |
-| PIPEWRAP             | test-pipewrap.js                           |
-| PROCESSWRAP          | test-pipewrap.js                           |
-| QUERYWRAP            | test-querywrap.js                          |
-| RANDOMBYTESREQUEST   | test-crypto-randomBytes.js                 |
-| SHUTDOWNWRAP         | test-shutdownwrap.js                       |
-| SIGNALWRAP           | test-signalwrap.js                         |
-| STATWATCHER          | test-statwatcher.js                        |
-| TCPCONNECTWRAP       | test-tcpwrap.js                            |
-| TCPWRAP              | test-tcpwrap.js                            |
-| TLSWRAP              | test-tlswrap.js                            |
-| TTYWRAP              | test-ttywrap.{read,write}stream.js         |
-| UDPSENDWRAP          | test-udpsendwrap.js                        |
-| UDPWRAP              | test-udpwrap.js                            |
-| WRITEWRAP            | test-writewrap.js                          |
-| ZLIB                 | test-zlib.zlib-binding.deflate.js          |
+| Resource Type       | Test                                    |
+|---------------------|-----------------------------------------|
+| CONNECTION          | test-connection.ssl.js                  |
+| FSEVENTWRAP         | test-fseventwrap.js                     |
+| FSREQCALLBACK       | test-fsreqcallback-{access,readFile}.js |
+| GETADDRINFOREQWRAP  | test-getaddrinforeqwrap.js              |
+| GETNAMEINFOREQWRAP  | test-getnameinforeqwrap.js              |
+| HTTPINCOMINGMESSAGE | test-httpparser.request.js              |
+| HTTPCLIENTREQUEST   | test-httpparser.response.js             |
+| Immediate           | test-immediate.js                       |
+| JSSTREAM            | TODO (crashes when accessing directly)  |
+| PBKDF2REQUEST       | test-crypto-pbkdf2.js                   |
+| PIPECONNECTWRAP     | test-pipeconnectwrap.js                 |
+| PIPEWRAP            | test-pipewrap.js                        |
+| PROCESSWRAP         | test-pipewrap.js                        |
+| QUERYWRAP           | test-querywrap.js                       |
+| RANDOMBYTESREQUEST  | test-crypto-randomBytes.js              |
+| SHUTDOWNWRAP        | test-shutdownwrap.js                    |
+| SIGNALWRAP          | test-signalwrap.js                      |
+| STATWATCHER         | test-statwatcher.js                     |
+| TCPCONNECTWRAP      | test-tcpwrap.js                         |
+| TCPWRAP             | test-tcpwrap.js                         |
+| TLSWRAP             | test-tlswrap.js                         |
+| TTYWRAP             | test-ttywrap.{read,write}stream.js      |
+| UDPSENDWRAP         | test-udpsendwrap.js                     |
+| UDPWRAP             | test-udpwrap.js                         |
+| WRITEWRAP           | test-writewrap.js                       |
+| ZLIB                | test-zlib.zlib-binding.deflate.js       |
diff --git a/test/async-hooks/test-async-local-storage-enable-disable.js b/test/async-hooks/test-async-local-storage-enable-disable.js
index 15ab2f5d9ebbb2f3b08ec1fb68ae20d5ffdda70d..c7248d6cec40a8b4a83322cc5e59f8bf6429641f 100644
--- a/test/async-hooks/test-async-local-storage-enable-disable.js
+++ b/test/async-hooks/test-async-local-storage-enable-disable.js
@@ -24,8 +24,8 @@ asyncLocalStorage.run(new Map(), () => {
 
     process.nextTick(() => {
       assert.strictEqual(asyncLocalStorage.getStore(), undefined);
-      asyncLocalStorage.run(new Map(), () => {
-        assert.notStrictEqual(asyncLocalStorage.getStore(), undefined);
+      asyncLocalStorage.run(new Map().set('bar', 'foo'), () => {
+        assert.strictEqual(asyncLocalStorage.getStore().get('bar'), 'foo');
       });
     });
   });
diff --git a/test/async-hooks/test-async-local-storage-http-agent.js b/test/async-hooks/test-async-local-storage-http-agent.js
new file mode 100644
index 0000000000000000000000000000000000000000..1de535aa709687a04cd9187f56ab70fc46db2e99
--- /dev/null
+++ b/test/async-hooks/test-async-local-storage-http-agent.js
@@ -0,0 +1,35 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { AsyncLocalStorage } = require('async_hooks');
+const http = require('http');
+
+const asyncLocalStorage = new AsyncLocalStorage();
+
+const agent = new http.Agent({
+  maxSockets: 1
+});
+
+const N = 3;
+let responses = 0;
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end('ok');
+}, N));
+
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+
+  for (let i = 0; i < N; i++) {
+    asyncLocalStorage.run(i, () => {
+      http.get({ agent, port }, common.mustCall((res) => {
+        assert.strictEqual(asyncLocalStorage.getStore(), i);
+        if (++responses === N) {
+          server.close();
+          agent.destroy();
+        }
+        res.resume();
+      }));
+    });
+  }
+}));
diff --git a/test/async-hooks/test-async-local-storage-run-resource.js b/test/async-hooks/test-async-local-storage-run-resource.js
deleted file mode 100644
index 21bc70051bd718bc6c4a44a482f6c6d2f0ab8512..0000000000000000000000000000000000000000
--- a/test/async-hooks/test-async-local-storage-run-resource.js
+++ /dev/null
@@ -1,30 +0,0 @@
-'use strict';
-require('../common');
-const assert = require('assert');
-const {
-  AsyncLocalStorage,
-  executionAsyncResource
-} = require('async_hooks');
-
-const asyncLocalStorage = new AsyncLocalStorage();
-
-const outerResource = executionAsyncResource();
-
-const store = new Map();
-asyncLocalStorage.run(store, () => {
-  assert.strictEqual(asyncLocalStorage.getStore(), store);
-  const innerResource = executionAsyncResource();
-  assert.notStrictEqual(innerResource, outerResource);
-  asyncLocalStorage.run(store, () => {
-    assert.strictEqual(asyncLocalStorage.getStore(), store);
-    assert.strictEqual(executionAsyncResource(), innerResource);
-    const otherStore = new Map();
-    asyncLocalStorage.run(otherStore, () => {
-      assert.strictEqual(asyncLocalStorage.getStore(), otherStore);
-      assert.notStrictEqual(executionAsyncResource(), innerResource);
-      assert.notStrictEqual(executionAsyncResource(), outerResource);
-    });
-  });
-});
-
-assert.strictEqual(executionAsyncResource(), outerResource);
diff --git a/test/async-hooks/test-enable-disable.js b/test/async-hooks/test-enable-disable.js
index f71fd63e1c77567e1bc635f6201ab9644d8897d5..64139408a4820930f62d4580b0de2f3934ec6fb3 100644
--- a/test/async-hooks/test-enable-disable.js
+++ b/test/async-hooks/test-enable-disable.js
@@ -1,85 +1,84 @@
-/*
- *  Test Steps Explained
- *  ====================
- *
- *  Initializing hooks:
- *
- *  We initialize 3 hooks. For hook2 and hook3 we register a callback for the
- *  "before" and in case of hook3 also for the "after" invocations.
- *
- *  Enabling hooks initially:
- *
- *  We only enable hook1 and hook3 initially.
- *
- *  Enabling hook2:
- *
- *  When hook3's "before" invocation occurs we enable hook2.  Since this
- *  happens right before calling `onfirstImmediate` hook2 will miss all hook
- *  invocations until then, including the "init" and "before" of the first
- *  Immediate.
- *  However afterwards it collects all invocations that follow on the first
- *  Immediate as well as all invocations on the second Immediate.
- *
- *  This shows that a hook can enable another hook inside a life time event
- *  callback.
- *
- *
- *  Disabling hook1
- *
- *  Since we registered the "before" callback for hook2 it will execute it
- *  right before `onsecondImmediate` is called.
- *  At that point we disable hook1 which is why it will miss all invocations
- *  afterwards and thus won't include the second "after" as well as the
- *  "destroy" invocations
- *
- *  This shows that a hook can disable another hook inside a life time event
- *  callback.
- *
- *  Disabling hook3
- *
- *  When the second "after" invocation occurs (after onsecondImmediate), hook3
- *  disables itself.
- *  As a result it will not receive the "destroy" invocation.
- *
- *  This shows that a hook can disable itself inside a life time event callback.
- *
- *  Sample Test Log
- *  ===============
- *
- *  - setting up first Immediate
- *  hook1.init.uid-5
- *  hook3.init.uid-5
- *  - finished setting first Immediate
-
- *  hook1.before.uid-5
- *  hook3.before.uid-5
- *  - enabled hook2
- *  - entering onfirstImmediate
-
- *  - setting up second Immediate
- *  hook1.init.uid-6
- *  hook3.init.uid-6
- *  hook2.init.uid-6
- *  - finished setting second Immediate
+//  Test Steps Explained
+//  ====================
+//
+//  Initializing hooks:
+//
+//  We initialize 3 hooks. For hook2 and hook3 we register a callback for the
+//  "before" and in case of hook3 also for the "after" invocations.
+//
+//  Enabling hooks initially:
+//
+//  We only enable hook1 and hook3 initially.
+//
+//  Enabling hook2:
+//
+//  When hook3's "before" invocation occurs we enable hook2.  Since this
+//  happens right before calling `onfirstImmediate` hook2 will miss all hook
+//  invocations until then, including the "init" and "before" of the first
+//  Immediate.
+//  However afterwards it collects all invocations that follow on the first
+//  Immediate as well as all invocations on the second Immediate.
+//
+//  This shows that a hook can enable another hook inside a life time event
+//  callback.
+//
+//
+//  Disabling hook1
+//
+//  Since we registered the "before" callback for hook2 it will execute it
+//  right before `onsecondImmediate` is called.
+//  At that point we disable hook1 which is why it will miss all invocations
+//  afterwards and thus won't include the second "after" as well as the
+//  "destroy" invocations
+//
+//  This shows that a hook can disable another hook inside a life time event
+//  callback.
+//
+//  Disabling hook3
+//
+//  When the second "after" invocation occurs (after onsecondImmediate), hook3
+//  disables itself.
+//  As a result it will not receive the "destroy" invocation.
+//
+//  This shows that a hook can disable itself inside a life time event callback.
+//
+//  Sample Test Log
+//  ===============
+//
+//  - setting up first Immediate
+//  hook1.init.uid-5
+//  hook3.init.uid-5
+//  - finished setting first Immediate
+//
+//  hook1.before.uid-5
+//  hook3.before.uid-5
+//  - enabled hook2
+//  - entering onfirstImmediate
+//
+//  - setting up second Immediate
+//  hook1.init.uid-6
+//  hook3.init.uid-6
+//  hook2.init.uid-6
+//  - finished setting second Immediate
+//
+//  - exiting onfirstImmediate
+//  hook1.after.uid-5
+//  hook3.after.uid-5
+//  hook2.after.uid-5
+//  hook1.destroy.uid-5
+//  hook3.destroy.uid-5
+//  hook2.destroy.uid-5
+//  hook1.before.uid-6
+//  hook3.before.uid-6
+//  hook2.before.uid-6
+//  - disabled hook1
+//  - entering onsecondImmediate
+//  - exiting onsecondImmediate
+//  hook3.after.uid-6
+//  - disabled hook3
+//  hook2.after.uid-6
+//  hook2.destroy.uid-6
 
- *  - exiting onfirstImmediate
- *  hook1.after.uid-5
- *  hook3.after.uid-5
- *  hook2.after.uid-5
- *  hook1.destroy.uid-5
- *  hook3.destroy.uid-5
- *  hook2.destroy.uid-5
- *  hook1.before.uid-6
- *  hook3.before.uid-6
- *  hook2.before.uid-6
- *  - disabled hook1
- *  - entering onsecondImmediate
- *  - exiting onsecondImmediate
- *  hook3.after.uid-6
- *  - disabled hook3
- *  hook2.after.uid-6
- *  hook2.destroy.uid-6
- */
 
 'use strict';
 
diff --git a/test/async-hooks/test-fseventwrap.js b/test/async-hooks/test-fseventwrap.js
index 6092856287254966501d3a4b957e92829e630b3e..12a439f8033cbc382d0d526a4db6a4f0a7d39778 100644
--- a/test/async-hooks/test-fseventwrap.js
+++ b/test/async-hooks/test-fseventwrap.js
@@ -11,7 +11,7 @@ if (!common.isMainThread)
   common.skip('Worker bootstrapping works differently -> different async IDs');
 
 if (common.isIBMi)
-  common.skip('IBMi does not suppport fs.watch()');
+  common.skip('IBMi does not support fs.watch()');
 
 const hooks = initHooks();
 
diff --git a/test/async-hooks/test-graph.http.js b/test/async-hooks/test-graph.http.js
index 924259ffe28c05a40fe21470e57c2b3ddf4fee57..3e36646e54e2ee13b9ea8620afce0901693fa28a 100644
--- a/test/async-hooks/test-graph.http.js
+++ b/test/async-hooks/test-graph.http.js
@@ -39,7 +39,6 @@ process.on('exit', () => {
         id: 'httpclientrequest:1',
         triggerAsyncId: 'tcpserver:1' },
       { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
-      { type: 'Timeout', id: 'timeout:1', triggerAsyncId: 'tcp:2' },
       { type: 'HTTPINCOMINGMESSAGE',
         id: 'httpincomingmessage:1',
         triggerAsyncId: 'tcp:2' },
diff --git a/test/async-hooks/test-graph.tls-write.js b/test/async-hooks/test-graph.tls-write.js
index 078dd27c36088c13e012c0ffb7aeed04a0243fd5..b493ac819dfbcd59013e5b2e3ff489d1732cbd56 100644
--- a/test/async-hooks/test-graph.tls-write.js
+++ b/test/async-hooks/test-graph.tls-write.js
@@ -65,7 +65,7 @@ function onexit() {
       { type: 'TCPCONNECTWRAP',
         id: 'tcpconnect:1', triggerAsyncId: 'tcp:1' },
       { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
-      { type: 'TLSWRAP', id: 'tls:2', triggerAsyncId: 'tcpserver:1' }
+      { type: 'TLSWRAP', id: 'tls:2', triggerAsyncId: 'tcpserver:1' },
     ]
   );
 }
diff --git a/test/async-hooks/test-http-agent-handle-reuse-parallel.js b/test/async-hooks/test-http-agent-handle-reuse-parallel.js
new file mode 100644
index 0000000000000000000000000000000000000000..cd73b3ed2cb61c16df1562bae98d96ae98c4e52a
--- /dev/null
+++ b/test/async-hooks/test-http-agent-handle-reuse-parallel.js
@@ -0,0 +1,92 @@
+'use strict';
+// Flags: --expose-internals
+const common = require('../common');
+const initHooks = require('./init-hooks');
+const { checkInvocations } = require('./hook-checks');
+const assert = require('assert');
+const { async_id_symbol } = require('internal/async_hooks').symbols;
+const http = require('http');
+
+// Checks that the async resource used in init in case of a reused handle
+// is not reused. Test is based on parallel\test-async-hooks-http-agent.js.
+
+const hooks = initHooks();
+hooks.enable();
+
+const reqAsyncIds = [];
+let socket;
+let responses = 0;
+
+// Make sure a single socket is transparently reused for 2 requests.
+const agent = new http.Agent({
+  keepAlive: true,
+  keepAliveMsecs: Infinity,
+  maxSockets: 1
+});
+
+const verifyRequest = (idx) => (res) => {
+  reqAsyncIds[idx] = res.socket[async_id_symbol];
+  assert.ok(reqAsyncIds[idx] > 0, `${reqAsyncIds[idx]} > 0`);
+  if (socket) {
+    // Check that both requests share their socket.
+    assert.strictEqual(res.socket, socket);
+  } else {
+    socket = res.socket;
+  }
+
+  res.on('data', common.mustCallAtLeast(() => {}));
+  res.on('end', common.mustCall(() => {
+    if (++responses === 2) {
+      // Clean up to let the event loop stop.
+      server.close();
+      agent.destroy();
+    }
+  }));
+};
+
+const server = http.createServer(common.mustCall((req, res) => {
+  req.once('data', common.mustCallAtLeast(() => {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write('foo');
+  }));
+  req.on('end', common.mustCall(() => {
+    res.end('bar');
+  }));
+}, 2)).listen(0, common.mustCall(() => {
+  const port = server.address().port;
+  const payload = 'hello world';
+
+  // First request.
+  const r1 = http.request({
+    agent, port, method: 'POST'
+  }, common.mustCall(verifyRequest(0)));
+  r1.end(payload);
+
+  // Second request. Sent in parallel with the first one.
+  const r2 = http.request({
+    agent, port, method: 'POST'
+  }, common.mustCall(verifyRequest(1)));
+  r2.end(payload);
+}));
+
+
+process.on('exit', onExit);
+
+function onExit() {
+  hooks.disable();
+  hooks.sanityCheck();
+  const activities = hooks.activities;
+
+  // Verify both invocations
+  const first = activities.filter((x) => x.uid === reqAsyncIds[0])[0];
+  checkInvocations(first, { init: 1, destroy: 1 }, 'when process exits');
+
+  const second = activities.filter((x) => x.uid === reqAsyncIds[1])[0];
+  checkInvocations(second, { init: 1, destroy: 1 }, 'when process exits');
+
+  // Verify reuse handle has been wrapped
+  assert.strictEqual(first.type, second.type);
+  assert.ok(first.handle !== second.handle, 'Resource reused');
+  assert.ok(first.handle === second.handle.handle,
+            'Resource not wrapped correctly');
+}
diff --git a/test/async-hooks/test-http-agent-handle-reuse.js b/test/async-hooks/test-http-agent-handle-reuse-serial.js
similarity index 98%
rename from test/async-hooks/test-http-agent-handle-reuse.js
rename to test/async-hooks/test-http-agent-handle-reuse-serial.js
index 4db83bec54a7bf25d70c1a04c55e2fdbd54202d5..bbc7183d6e72cab7b70ac92e68b53461abba0971 100644
--- a/test/async-hooks/test-http-agent-handle-reuse.js
+++ b/test/async-hooks/test-http-agent-handle-reuse-serial.js
@@ -7,7 +7,7 @@ const assert = require('assert');
 const { async_id_symbol } = require('internal/async_hooks').symbols;
 const http = require('http');
 
-// Checks that the async resource used in init in case of a resused handle
+// Checks that the async resource used in init in case of a reused handle
 // is not reused. Test is based on parallel\test-async-hooks-http-agent.js.
 
 const hooks = initHooks();
diff --git a/test/benchmark/benchmark.status b/test/benchmark/benchmark.status
index 0db4181af0d76075b24e042c8fbc1d71ec3e5d7f..6a966743aab26b60ae7d264c28e3ac9470ee454a 100644
--- a/test/benchmark/benchmark.status
+++ b/test/benchmark/benchmark.status
@@ -19,7 +19,3 @@ prefix benchmark
 [$system==aix]
 
 [$arch==arm]
-# https://github.com/nodejs/node/issues/34266
-test-benchmark-fs: SKIP
-# https://github.com/nodejs/build/issues/2382
-test-benchmark-napi: SKIP
diff --git a/test/benchmark/test-benchmark-fs.js b/test/benchmark/test-benchmark-fs.js
index 4b9fde8b6620d6de2e3ca804ade4d8b3ef3d2b85..3ef6be2b7ebaedcbda9f1e5cc98066b08245aa64 100644
--- a/test/benchmark/test-benchmark-fs.js
+++ b/test/benchmark/test-benchmark-fs.js
@@ -6,7 +6,4 @@ const runBenchmark = require('../common/benchmark');
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-runBenchmark('fs', {
-  NODE_TMPDIR: tmpdir.path,
-  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
-});
+runBenchmark('fs', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
diff --git a/test/cctest/gtest/LICENSE b/test/cctest/gtest/LICENSE
deleted file mode 100644
index 1941a11f8ce94389160b458927a29ba217542818..0000000000000000000000000000000000000000
--- a/test/cctest/gtest/LICENSE
+++ /dev/null
@@ -1,28 +0,0 @@
-Copyright 2008, Google Inc.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/test/cctest/gtest/gtest-all.cc b/test/cctest/gtest/gtest-all.cc
deleted file mode 100644
index ffa5f77859ab5f31064b39c3dffef2f715bcf6ce..0000000000000000000000000000000000000000
--- a/test/cctest/gtest/gtest-all.cc
+++ /dev/null
@@ -1,11735 +0,0 @@
-// Copyright 2008, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// Google C++ Testing and Mocking Framework (Google Test)
-//
-// Sometimes it's desirable to build Google Test by compiling a single file.
-// This file serves this purpose.
-
-// This line ensures that gtest.h can be compiled on its own, even
-// when it's fused.
-#include "gtest/gtest.h"
-
-// The following lines pull in the real gtest *.cc files.
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-
-// Copyright 2007, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// Utilities for testing Google Test itself and code that uses Google Test
-// (e.g. frameworks built on top of Google Test).
-
-// GOOGLETEST_CM0004 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
-#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
-
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-namespace testing {
-
-// This helper class can be used to mock out Google Test failure reporting
-// so that we can test Google Test or code that builds on Google Test.
-//
-// An object of this class appends a TestPartResult object to the
-// TestPartResultArray object given in the constructor whenever a Google Test
-// failure is reported. It can either intercept only failures that are
-// generated in the same thread that created this object or it can intercept
-// all generated failures. The scope of this mock object can be controlled with
-// the second argument to the two arguments constructor.
-class GTEST_API_ ScopedFakeTestPartResultReporter
-    : public TestPartResultReporterInterface {
- public:
-  // The two possible mocking modes of this object.
-  enum InterceptMode {
-    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
-    INTERCEPT_ALL_THREADS           // Intercepts all failures.
-  };
-
-  // The c'tor sets this object as the test part result reporter used
-  // by Google Test.  The 'result' parameter specifies where to report the
-  // results. This reporter will only catch failures generated in the current
-  // thread. DEPRECATED
-  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
-
-  // Same as above, but you can choose the interception scope of this object.
-  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
-                                   TestPartResultArray* result);
-
-  // The d'tor restores the previous test part result reporter.
-  ~ScopedFakeTestPartResultReporter() override;
-
-  // Appends the TestPartResult object to the TestPartResultArray
-  // received in the constructor.
-  //
-  // This method is from the TestPartResultReporterInterface
-  // interface.
-  void ReportTestPartResult(const TestPartResult& result) override;
-
- private:
-  void Init();
-
-  const InterceptMode intercept_mode_;
-  TestPartResultReporterInterface* old_reporter_;
-  TestPartResultArray* const result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
-};
-
-namespace internal {
-
-// A helper class for implementing EXPECT_FATAL_FAILURE() and
-// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
-// TestPartResultArray contains exactly one failure that has the given
-// type and contains the given substring.  If that's not the case, a
-// non-fatal failure will be generated.
-class GTEST_API_ SingleFailureChecker {
- public:
-  // The constructor remembers the arguments.
-  SingleFailureChecker(const TestPartResultArray* results,
-                       TestPartResult::Type type, const std::string& substr);
-  ~SingleFailureChecker();
- private:
-  const TestPartResultArray* const results_;
-  const TestPartResult::Type type_;
-  const std::string substr_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
-};
-
-}  // namespace internal
-
-}  // namespace testing
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-// A set of macros for testing Google Test assertions or code that's expected
-// to generate Google Test fatal failures.  It verifies that the given
-// statement will cause exactly one fatal Google Test failure with 'substr'
-// being part of the failure message.
-//
-// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
-// affects and considers failures generated in the current thread and
-// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
-//
-// The verification of the assertion is done correctly even when the statement
-// throws an exception or aborts the current function.
-//
-// Known restrictions:
-//   - 'statement' cannot reference local non-static variables or
-//     non-static members of the current object.
-//   - 'statement' cannot return a value.
-//   - You cannot stream a failure message to this macro.
-//
-// Note that even though the implementations of the following two
-// macros are much alike, we cannot refactor them to use a common
-// helper macro, due to some peculiarity in how the preprocessor
-// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
-// gtest_unittest.cc will fail to compile if we do that.
-#define EXPECT_FATAL_FAILURE(statement, substr) \
-  do { \
-    class GTestExpectFatalFailureHelper {\
-     public:\
-      static void Execute() { statement; }\
-    };\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
-      GTestExpectFatalFailureHelper::Execute();\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
-  do { \
-    class GTestExpectFatalFailureHelper {\
-     public:\
-      static void Execute() { statement; }\
-    };\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ALL_THREADS, &gtest_failures);\
-      GTestExpectFatalFailureHelper::Execute();\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-// A macro for testing Google Test assertions or code that's expected to
-// generate Google Test non-fatal failures.  It asserts that the given
-// statement will cause exactly one non-fatal Google Test failure with 'substr'
-// being part of the failure message.
-//
-// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
-// affects and considers failures generated in the current thread and
-// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
-//
-// 'statement' is allowed to reference local variables and members of
-// the current object.
-//
-// The verification of the assertion is done correctly even when the statement
-// throws an exception or aborts the current function.
-//
-// Known restrictions:
-//   - You cannot stream a failure message to this macro.
-//
-// Note that even though the implementations of the following two
-// macros are much alike, we cannot refactor them to use a common
-// helper macro, due to some peculiarity in how the preprocessor
-// works.  If we do that, the code won't compile when the user gives
-// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
-// expands to code containing an unprotected comma.  The
-// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
-// catches that.
-//
-// For the same reason, we have to write
-//   if (::testing::internal::AlwaysTrue()) { statement; }
-// instead of
-//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
-// to avoid an MSVC warning on unreachable code.
-#define EXPECT_NONFATAL_FAILURE(statement, substr) \
-  do {\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
-        (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
-      if (::testing::internal::AlwaysTrue()) { statement; }\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
-  do {\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
-        (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
-          &gtest_failures);\
-      if (::testing::internal::AlwaysTrue()) { statement; }\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
-
-#include <ctype.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#include <wchar.h>
-#include <wctype.h>
-
-#include <algorithm>
-#include <iomanip>
-#include <limits>
-#include <list>
-#include <map>
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <vector>
-
-#if GTEST_OS_LINUX
-
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-
-# include <fcntl.h>  // NOLINT
-# include <limits.h>  // NOLINT
-# include <sched.h>  // NOLINT
-// Declares vsnprintf().  This header is not available on Windows.
-# include <strings.h>  // NOLINT
-# include <sys/mman.h>  // NOLINT
-# include <sys/time.h>  // NOLINT
-# include <unistd.h>  // NOLINT
-# include <string>
-
-#elif GTEST_OS_ZOS
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-# include <sys/time.h>  // NOLINT
-
-// On z/OS we additionally need strings.h for strcasecmp.
-# include <strings.h>  // NOLINT
-
-#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
-
-# include <windows.h>  // NOLINT
-# undef min
-
-#elif GTEST_OS_WINDOWS  // We are on Windows proper.
-
-# include <io.h>  // NOLINT
-# include <sys/timeb.h>  // NOLINT
-# include <sys/types.h>  // NOLINT
-# include <sys/stat.h>  // NOLINT
-
-# if GTEST_OS_WINDOWS_MINGW
-// MinGW has gettimeofday() but not _ftime64().
-#  define GTEST_HAS_GETTIMEOFDAY_ 1
-#  include <sys/time.h>  // NOLINT
-# endif  // GTEST_OS_WINDOWS_MINGW
-
-// cpplint thinks that the header is already included, so we want to
-// silence it.
-# include <windows.h>  // NOLINT
-# undef min
-
-#else
-
-// Assume other platforms have gettimeofday().
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-
-// cpplint thinks that the header is already included, so we want to
-// silence it.
-# include <sys/time.h>  // NOLINT
-# include <unistd.h>  // NOLINT
-
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>
-#endif
-
-#if GTEST_CAN_STREAM_RESULTS_
-# include <arpa/inet.h>  // NOLINT
-# include <netdb.h>  // NOLINT
-# include <sys/socket.h>  // NOLINT
-# include <sys/types.h>  // NOLINT
-#endif
-
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Utility functions and classes used by the Google C++ testing framework.//
-// This file contains purely Google Test's internal implementation.  Please
-// DO NOT #INCLUDE IT IN A USER PROGRAM.
-
-#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
-#define GTEST_SRC_GTEST_INTERNAL_INL_H_
-
-#ifndef _WIN32_WCE
-# include <errno.h>
-#endif  // !_WIN32_WCE
-#include <stddef.h>
-#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
-#include <string.h>  // For memmove.
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <vector>
-
-
-#if GTEST_CAN_STREAM_RESULTS_
-# include <arpa/inet.h>  // NOLINT
-# include <netdb.h>  // NOLINT
-#endif
-
-#if GTEST_OS_WINDOWS
-# include <windows.h>  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-namespace testing {
-
-// Declares the flags.
-//
-// We don't want the users to modify this flag in the code, but want
-// Google Test's own unit tests to be able to access it. Therefore we
-// declare it here as opposed to in gtest.h.
-GTEST_DECLARE_bool_(death_test_use_fork);
-
-namespace internal {
-
-// The value of GetTestTypeId() as seen from within the Google Test
-// library.  This is solely for testing GetTestTypeId().
-GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
-
-// Names of the flags (needed for parsing Google Test flags).
-const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
-const char kBreakOnFailureFlag[] = "break_on_failure";
-const char kCatchExceptionsFlag[] = "catch_exceptions";
-const char kColorFlag[] = "color";
-const char kFilterFlag[] = "filter";
-const char kListTestsFlag[] = "list_tests";
-const char kOutputFlag[] = "output";
-const char kPrintTimeFlag[] = "print_time";
-const char kPrintUTF8Flag[] = "print_utf8";
-const char kRandomSeedFlag[] = "random_seed";
-const char kRepeatFlag[] = "repeat";
-const char kShuffleFlag[] = "shuffle";
-const char kStackTraceDepthFlag[] = "stack_trace_depth";
-const char kStreamResultToFlag[] = "stream_result_to";
-const char kThrowOnFailureFlag[] = "throw_on_failure";
-const char kFlagfileFlag[] = "flagfile";
-
-// A valid random seed must be in [1, kMaxRandomSeed].
-const int kMaxRandomSeed = 99999;
-
-// g_help_flag is true iff the --help flag or an equivalent form is
-// specified on the command line.
-GTEST_API_ extern bool g_help_flag;
-
-// Returns the current time in milliseconds.
-GTEST_API_ TimeInMillis GetTimeInMillis();
-
-// Returns true iff Google Test should use colors in the output.
-GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
-
-// Formats the given time in milliseconds as seconds.
-GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
-
-// Converts the given time in milliseconds to a date string in the ISO 8601
-// format, without the timezone information.  N.B.: due to the use the
-// non-reentrant localtime() function, this function is not thread safe.  Do
-// not use it in any code that can be called from multiple threads.
-GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
-
-// Parses a string for an Int32 flag, in the form of "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-GTEST_API_ bool ParseInt32Flag(
-    const char* str, const char* flag, Int32* value);
-
-// Returns a random seed in range [1, kMaxRandomSeed] based on the
-// given --gtest_random_seed flag value.
-inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
-  const unsigned int raw_seed = (random_seed_flag == 0) ?
-      static_cast<unsigned int>(GetTimeInMillis()) :
-      static_cast<unsigned int>(random_seed_flag);
-
-  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
-  // it's easy to type.
-  const int normalized_seed =
-      static_cast<int>((raw_seed - 1U) %
-                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
-  return normalized_seed;
-}
-
-// Returns the first valid random seed after 'seed'.  The behavior is
-// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
-// considered to be 1.
-inline int GetNextRandomSeed(int seed) {
-  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
-      << "Invalid random seed " << seed << " - must be in [1, "
-      << kMaxRandomSeed << "].";
-  const int next_seed = seed + 1;
-  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
-}
-
-// This class saves the values of all Google Test flags in its c'tor, and
-// restores them in its d'tor.
-class GTestFlagSaver {
- public:
-  // The c'tor.
-  GTestFlagSaver() {
-    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
-    break_on_failure_ = GTEST_FLAG(break_on_failure);
-    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
-    color_ = GTEST_FLAG(color);
-    death_test_style_ = GTEST_FLAG(death_test_style);
-    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
-    filter_ = GTEST_FLAG(filter);
-    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
-    list_tests_ = GTEST_FLAG(list_tests);
-    output_ = GTEST_FLAG(output);
-    print_time_ = GTEST_FLAG(print_time);
-    print_utf8_ = GTEST_FLAG(print_utf8);
-    random_seed_ = GTEST_FLAG(random_seed);
-    repeat_ = GTEST_FLAG(repeat);
-    shuffle_ = GTEST_FLAG(shuffle);
-    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
-    stream_result_to_ = GTEST_FLAG(stream_result_to);
-    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
-  }
-
-  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
-  ~GTestFlagSaver() {
-    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
-    GTEST_FLAG(break_on_failure) = break_on_failure_;
-    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
-    GTEST_FLAG(color) = color_;
-    GTEST_FLAG(death_test_style) = death_test_style_;
-    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
-    GTEST_FLAG(filter) = filter_;
-    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
-    GTEST_FLAG(list_tests) = list_tests_;
-    GTEST_FLAG(output) = output_;
-    GTEST_FLAG(print_time) = print_time_;
-    GTEST_FLAG(print_utf8) = print_utf8_;
-    GTEST_FLAG(random_seed) = random_seed_;
-    GTEST_FLAG(repeat) = repeat_;
-    GTEST_FLAG(shuffle) = shuffle_;
-    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
-    GTEST_FLAG(stream_result_to) = stream_result_to_;
-    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
-  }
-
- private:
-  // Fields for saving the original values of flags.
-  bool also_run_disabled_tests_;
-  bool break_on_failure_;
-  bool catch_exceptions_;
-  std::string color_;
-  std::string death_test_style_;
-  bool death_test_use_fork_;
-  std::string filter_;
-  std::string internal_run_death_test_;
-  bool list_tests_;
-  std::string output_;
-  bool print_time_;
-  bool print_utf8_;
-  internal::Int32 random_seed_;
-  internal::Int32 repeat_;
-  bool shuffle_;
-  internal::Int32 stack_trace_depth_;
-  std::string stream_result_to_;
-  bool throw_on_failure_;
-} GTEST_ATTRIBUTE_UNUSED_;
-
-// Converts a Unicode code point to a narrow string in UTF-8 encoding.
-// code_point parameter is of type UInt32 because wchar_t may not be
-// wide enough to contain a code point.
-// If the code_point is not a valid Unicode code point
-// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
-// to "(Invalid Unicode 0xXXXXXXXX)".
-GTEST_API_ std::string CodePointToUtf8(UInt32 code_point);
-
-// Converts a wide string to a narrow string in UTF-8 encoding.
-// The wide string is assumed to have the following encoding:
-//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
-//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
-// Parameter str points to a null-terminated wide string.
-// Parameter num_chars may additionally limit the number
-// of wchar_t characters processed. -1 is used when the entire string
-// should be processed.
-// If the string contains code points that are not valid Unicode code points
-// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
-// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
-// and contains invalid UTF-16 surrogate pairs, values in those pairs
-// will be encoded as individual Unicode characters from Basic Normal Plane.
-GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
-
-// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
-// if the variable is present. If a file already exists at this location, this
-// function will write over it. If the variable is present, but the file cannot
-// be created, prints an error and exits.
-void WriteToShardStatusFileIfNeeded();
-
-// Checks whether sharding is enabled by examining the relevant
-// environment variable values. If the variables are present,
-// but inconsistent (e.g., shard_index >= total_shards), prints
-// an error and exits. If in_subprocess_for_death_test, sharding is
-// disabled because it must only be applied to the original test
-// process. Otherwise, we could filter out death tests we intended to execute.
-GTEST_API_ bool ShouldShard(const char* total_shards_str,
-                            const char* shard_index_str,
-                            bool in_subprocess_for_death_test);
-
-// Parses the environment variable var as an Int32. If it is unset,
-// returns default_val. If it is not an Int32, prints an error and
-// and aborts.
-GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);
-
-// Given the total number of shards, the shard index, and the test id,
-// returns true iff the test should be run on this shard. The test id is
-// some arbitrary but unique non-negative integer assigned to each test
-// method. Assumes that 0 <= shard_index < total_shards.
-GTEST_API_ bool ShouldRunTestOnShard(
-    int total_shards, int shard_index, int test_id);
-
-// STL container utilities.
-
-// Returns the number of elements in the given container that satisfy
-// the given predicate.
-template <class Container, typename Predicate>
-inline int CountIf(const Container& c, Predicate predicate) {
-  // Implemented as an explicit loop since std::count_if() in libCstd on
-  // Solaris has a non-standard signature.
-  int count = 0;
-  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
-    if (predicate(*it))
-      ++count;
-  }
-  return count;
-}
-
-// Applies a function/functor to each element in the container.
-template <class Container, typename Functor>
-void ForEach(const Container& c, Functor functor) {
-  std::for_each(c.begin(), c.end(), functor);
-}
-
-// Returns the i-th element of the vector, or default_value if i is not
-// in range [0, v.size()).
-template <typename E>
-inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
-  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i];
-}
-
-// Performs an in-place shuffle of a range of the vector's elements.
-// 'begin' and 'end' are element indices as an STL-style range;
-// i.e. [begin, end) are shuffled, where 'end' == size() means to
-// shuffle to the end of the vector.
-template <typename E>
-void ShuffleRange(internal::Random* random, int begin, int end,
-                  std::vector<E>* v) {
-  const int size = static_cast<int>(v->size());
-  GTEST_CHECK_(0 <= begin && begin <= size)
-      << "Invalid shuffle range start " << begin << ": must be in range [0, "
-      << size << "].";
-  GTEST_CHECK_(begin <= end && end <= size)
-      << "Invalid shuffle range finish " << end << ": must be in range ["
-      << begin << ", " << size << "].";
-
-  // Fisher-Yates shuffle, from
-  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
-  for (int range_width = end - begin; range_width >= 2; range_width--) {
-    const int last_in_range = begin + range_width - 1;
-    const int selected = begin + random->Generate(range_width);
-    std::swap((*v)[selected], (*v)[last_in_range]);
-  }
-}
-
-// Performs an in-place shuffle of the vector's elements.
-template <typename E>
-inline void Shuffle(internal::Random* random, std::vector<E>* v) {
-  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
-}
-
-// A function for deleting an object.  Handy for being used as a
-// functor.
-template <typename T>
-static void Delete(T* x) {
-  delete x;
-}
-
-// A predicate that checks the key of a TestProperty against a known key.
-//
-// TestPropertyKeyIs is copyable.
-class TestPropertyKeyIs {
- public:
-  // Constructor.
-  //
-  // TestPropertyKeyIs has NO default constructor.
-  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
-
-  // Returns true iff the test name of test property matches on key_.
-  bool operator()(const TestProperty& test_property) const {
-    return test_property.key() == key_;
-  }
-
- private:
-  std::string key_;
-};
-
-// Class UnitTestOptions.
-//
-// This class contains functions for processing options the user
-// specifies when running the tests.  It has only static members.
-//
-// In most cases, the user can specify an option using either an
-// environment variable or a command line flag.  E.g. you can set the
-// test filter using either GTEST_FILTER or --gtest_filter.  If both
-// the variable and the flag are present, the latter overrides the
-// former.
-class GTEST_API_ UnitTestOptions {
- public:
-  // Functions for processing the gtest_output flag.
-
-  // Returns the output format, or "" for normal printed output.
-  static std::string GetOutputFormat();
-
-  // Returns the absolute path of the requested output file, or the
-  // default (test_detail.xml in the original working directory) if
-  // none was explicitly specified.
-  static std::string GetAbsolutePathToOutputFile();
-
-  // Functions for processing the gtest_filter flag.
-
-  // Returns true iff the wildcard pattern matches the string.  The
-  // first ':' or '\0' character in pattern marks the end of it.
-  //
-  // This recursive algorithm isn't very efficient, but is clear and
-  // works well enough for matching test names, which are short.
-  static bool PatternMatchesString(const char *pattern, const char *str);
-
-  // Returns true iff the user-specified filter matches the test suite
-  // name and the test name.
-  static bool FilterMatchesTest(const std::string& test_suite_name,
-                                const std::string& test_name);
-
-#if GTEST_OS_WINDOWS
-  // Function for supporting the gtest_catch_exception flag.
-
-  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
-  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
-  // This function is useful as an __except condition.
-  static int GTestShouldProcessSEH(DWORD exception_code);
-#endif  // GTEST_OS_WINDOWS
-
-  // Returns true if "name" matches the ':' separated list of glob-style
-  // filters in "filter".
-  static bool MatchesFilter(const std::string& name, const char* filter);
-};
-
-// Returns the current application's name, removing directory path if that
-// is present.  Used by UnitTestOptions::GetOutputFile.
-GTEST_API_ FilePath GetCurrentExecutableName();
-
-// The role interface for getting the OS stack trace as a string.
-class OsStackTraceGetterInterface {
- public:
-  OsStackTraceGetterInterface() {}
-  virtual ~OsStackTraceGetterInterface() {}
-
-  // Returns the current OS stack trace as an std::string.  Parameters:
-  //
-  //   max_depth  - the maximum number of stack frames to be included
-  //                in the trace.
-  //   skip_count - the number of top frames to be skipped; doesn't count
-  //                against max_depth.
-  virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0;
-
-  // UponLeavingGTest() should be called immediately before Google Test calls
-  // user code. It saves some information about the current stack that
-  // CurrentStackTrace() will use to find and hide Google Test stack frames.
-  virtual void UponLeavingGTest() = 0;
-
-  // This string is inserted in place of stack frames that are part of
-  // Google Test's implementation.
-  static const char* const kElidedFramesMarker;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
-};
-
-// A working implementation of the OsStackTraceGetterInterface interface.
-class OsStackTraceGetter : public OsStackTraceGetterInterface {
- public:
-  OsStackTraceGetter() {}
-
-  std::string CurrentStackTrace(int max_depth, int skip_count) override;
-  void UponLeavingGTest() override;
-
- private:
-#if GTEST_HAS_ABSL
-  Mutex mutex_;  // Protects all internal state.
-
-  // We save the stack frame below the frame that calls user code.
-  // We do this because the address of the frame immediately below
-  // the user code changes between the call to UponLeavingGTest()
-  // and any calls to the stack trace code from within the user code.
-  void* caller_frame_ = nullptr;
-#endif  // GTEST_HAS_ABSL
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
-};
-
-// Information about a Google Test trace point.
-struct TraceInfo {
-  const char* file;
-  int line;
-  std::string message;
-};
-
-// This is the default global test part result reporter used in UnitTestImpl.
-// This class should only be used by UnitTestImpl.
-class DefaultGlobalTestPartResultReporter
-  : public TestPartResultReporterInterface {
- public:
-  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
-  // Implements the TestPartResultReporterInterface. Reports the test part
-  // result in the current test.
-  void ReportTestPartResult(const TestPartResult& result) override;
-
- private:
-  UnitTestImpl* const unit_test_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
-};
-
-// This is the default per thread test part result reporter used in
-// UnitTestImpl. This class should only be used by UnitTestImpl.
-class DefaultPerThreadTestPartResultReporter
-    : public TestPartResultReporterInterface {
- public:
-  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
-  // Implements the TestPartResultReporterInterface. The implementation just
-  // delegates to the current global test part result reporter of *unit_test_.
-  void ReportTestPartResult(const TestPartResult& result) override;
-
- private:
-  UnitTestImpl* const unit_test_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
-};
-
-// The private implementation of the UnitTest class.  We don't protect
-// the methods under a mutex, as this class is not accessible by a
-// user and the UnitTest class that delegates work to this class does
-// proper locking.
-class GTEST_API_ UnitTestImpl {
- public:
-  explicit UnitTestImpl(UnitTest* parent);
-  virtual ~UnitTestImpl();
-
-  // There are two different ways to register your own TestPartResultReporter.
-  // You can register your own repoter to listen either only for test results
-  // from the current thread or for results from all threads.
-  // By default, each per-thread test result repoter just passes a new
-  // TestPartResult to the global test result reporter, which registers the
-  // test part result for the currently running test.
-
-  // Returns the global test part result reporter.
-  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
-
-  // Sets the global test part result reporter.
-  void SetGlobalTestPartResultReporter(
-      TestPartResultReporterInterface* reporter);
-
-  // Returns the test part result reporter for the current thread.
-  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();
-
-  // Sets the test part result reporter for the current thread.
-  void SetTestPartResultReporterForCurrentThread(
-      TestPartResultReporterInterface* reporter);
-
-  // Gets the number of successful test suites.
-  int successful_test_suite_count() const;
-
-  // Gets the number of failed test suites.
-  int failed_test_suite_count() const;
-
-  // Gets the number of all test suites.
-  int total_test_suite_count() const;
-
-  // Gets the number of all test suites that contain at least one test
-  // that should run.
-  int test_suite_to_run_count() const;
-
-  // Gets the number of successful tests.
-  int successful_test_count() const;
-
-  // Gets the number of skipped tests.
-  int skipped_test_count() const;
-
-  // Gets the number of failed tests.
-  int failed_test_count() const;
-
-  // Gets the number of disabled tests that will be reported in the XML report.
-  int reportable_disabled_test_count() const;
-
-  // Gets the number of disabled tests.
-  int disabled_test_count() const;
-
-  // Gets the number of tests to be printed in the XML report.
-  int reportable_test_count() const;
-
-  // Gets the number of all tests.
-  int total_test_count() const;
-
-  // Gets the number of tests that should run.
-  int test_to_run_count() const;
-
-  // Gets the time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp() const { return start_timestamp_; }
-
-  // Gets the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns true iff the unit test passed (i.e. all test suites passed).
-  bool Passed() const { return !Failed(); }
-
-  // Returns true iff the unit test failed (i.e. some test suite failed
-  // or something outside of all tests failed).
-  bool Failed() const {
-    return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed();
-  }
-
-  // Gets the i-th test suite among all the test suites. i can range from 0 to
-  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
-  const TestSuite* GetTestSuite(int i) const {
-    const int index = GetElementOr(test_suite_indices_, i, -1);
-    return index < 0 ? nullptr : test_suites_[i];
-  }
-
-  //  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  const TestCase* GetTestCase(int i) const { return GetTestSuite(i); }
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  // Gets the i-th test suite among all the test suites. i can range from 0 to
-  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
-  TestSuite* GetMutableSuiteCase(int i) {
-    const int index = GetElementOr(test_suite_indices_, i, -1);
-    return index < 0 ? nullptr : test_suites_[index];
-  }
-
-  // Provides access to the event listener list.
-  TestEventListeners* listeners() { return &listeners_; }
-
-  // Returns the TestResult for the test that's currently running, or
-  // the TestResult for the ad hoc test if no test is running.
-  TestResult* current_test_result();
-
-  // Returns the TestResult for the ad hoc test.
-  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
-
-  // Sets the OS stack trace getter.
-  //
-  // Does nothing if the input and the current OS stack trace getter
-  // are the same; otherwise, deletes the old getter and makes the
-  // input the current getter.
-  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
-
-  // Returns the current OS stack trace getter if it is not NULL;
-  // otherwise, creates an OsStackTraceGetter, makes it the current
-  // getter, and returns it.
-  OsStackTraceGetterInterface* os_stack_trace_getter();
-
-  // Returns the current OS stack trace as an std::string.
-  //
-  // The maximum number of stack frames to be included is specified by
-  // the gtest_stack_trace_depth flag.  The skip_count parameter
-  // specifies the number of top frames to be skipped, which doesn't
-  // count against the number of frames to be included.
-  //
-  // For example, if Foo() calls Bar(), which in turn calls
-  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
-  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
-
-  // Finds and returns a TestSuite with the given name.  If one doesn't
-  // exist, creates one and returns it.
-  //
-  // Arguments:
-  //
-  //   test_suite_name: name of the test suite
-  //   type_param:     the name of the test's type parameter, or NULL if
-  //                   this is not a typed or a type-parameterized test.
-  //   set_up_tc:      pointer to the function that sets up the test suite
-  //   tear_down_tc:   pointer to the function that tears down the test suite
-  TestSuite* GetTestSuite(const char* test_suite_name, const char* type_param,
-                          internal::SetUpTestSuiteFunc set_up_tc,
-                          internal::TearDownTestSuiteFunc tear_down_tc);
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  TestCase* GetTestCase(const char* test_case_name, const char* type_param,
-                        internal::SetUpTestSuiteFunc set_up_tc,
-                        internal::TearDownTestSuiteFunc tear_down_tc) {
-    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc);
-  }
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  // Adds a TestInfo to the unit test.
-  //
-  // Arguments:
-  //
-  //   set_up_tc:    pointer to the function that sets up the test suite
-  //   tear_down_tc: pointer to the function that tears down the test suite
-  //   test_info:    the TestInfo object
-  void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
-                   internal::TearDownTestSuiteFunc tear_down_tc,
-                   TestInfo* test_info) {
-    // In order to support thread-safe death tests, we need to
-    // remember the original working directory when the test program
-    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
-    // the user may have changed the current directory before calling
-    // RUN_ALL_TESTS().  Therefore we capture the current directory in
-    // AddTestInfo(), which is called to register a TEST or TEST_F
-    // before main() is reached.
-    if (original_working_dir_.IsEmpty()) {
-      original_working_dir_.Set(FilePath::GetCurrentDir());
-      GTEST_CHECK_(!original_working_dir_.IsEmpty())
-          << "Failed to get the current working directory.";
-    }
-
-    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
-                 set_up_tc, tear_down_tc)
-        ->AddTestInfo(test_info);
-  }
-
-  // Returns ParameterizedTestSuiteRegistry object used to keep track of
-  // value-parameterized tests and instantiate and register them.
-  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() {
-    return parameterized_test_registry_;
-  }
-
-  // Sets the TestSuite object for the test that's currently running.
-  void set_current_test_suite(TestSuite* a_current_test_suite) {
-    current_test_suite_ = a_current_test_suite;
-  }
-
-  // Sets the TestInfo object for the test that's currently running.  If
-  // current_test_info is NULL, the assertion results will be stored in
-  // ad_hoc_test_result_.
-  void set_current_test_info(TestInfo* a_current_test_info) {
-    current_test_info_ = a_current_test_info;
-  }
-
-  // Registers all parameterized tests defined using TEST_P and
-  // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter
-  // combination. This method can be called more then once; it has guards
-  // protecting from registering the tests more then once.  If
-  // value-parameterized tests are disabled, RegisterParameterizedTests is
-  // present but does nothing.
-  void RegisterParameterizedTests();
-
-  // Runs all tests in this UnitTest object, prints the result, and
-  // returns true if all tests are successful.  If any exception is
-  // thrown during a test, this test is considered to be failed, but
-  // the rest of the tests will still be run.
-  bool RunAllTests();
-
-  // Clears the results of all tests, except the ad hoc tests.
-  void ClearNonAdHocTestResult() {
-    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
-  }
-
-  // Clears the results of ad-hoc test assertions.
-  void ClearAdHocTestResult() {
-    ad_hoc_test_result_.Clear();
-  }
-
-  // Adds a TestProperty to the current TestResult object when invoked in a
-  // context of a test or a test suite, or to the global property set. If the
-  // result already contains a property with the same key, the value will be
-  // updated.
-  void RecordProperty(const TestProperty& test_property);
-
-  enum ReactionToSharding {
-    HONOR_SHARDING_PROTOCOL,
-    IGNORE_SHARDING_PROTOCOL
-  };
-
-  // Matches the full name of each test against the user-specified
-  // filter to decide whether the test should run, then records the
-  // result in each TestSuite and TestInfo object.
-  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
-  // based on sharding variables in the environment.
-  // Returns the number of tests that should run.
-  int FilterTests(ReactionToSharding shard_tests);
-
-  // Prints the names of the tests matching the user-specified filter flag.
-  void ListTestsMatchingFilter();
-
-  const TestSuite* current_test_suite() const { return current_test_suite_; }
-  TestInfo* current_test_info() { return current_test_info_; }
-  const TestInfo* current_test_info() const { return current_test_info_; }
-
-  // Returns the vector of environments that need to be set-up/torn-down
-  // before/after the tests are run.
-  std::vector<Environment*>& environments() { return environments_; }
-
-  // Getters for the per-thread Google Test trace stack.
-  std::vector<TraceInfo>& gtest_trace_stack() {
-    return *(gtest_trace_stack_.pointer());
-  }
-  const std::vector<TraceInfo>& gtest_trace_stack() const {
-    return gtest_trace_stack_.get();
-  }
-
-#if GTEST_HAS_DEATH_TEST
-  void InitDeathTestSubprocessControlInfo() {
-    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
-  }
-  // Returns a pointer to the parsed --gtest_internal_run_death_test
-  // flag, or NULL if that flag was not specified.
-  // This information is useful only in a death test child process.
-  // Must not be called before a call to InitGoogleTest.
-  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
-    return internal_run_death_test_flag_.get();
-  }
-
-  // Returns a pointer to the current death test factory.
-  internal::DeathTestFactory* death_test_factory() {
-    return death_test_factory_.get();
-  }
-
-  void SuppressTestEventsIfInSubprocess();
-
-  friend class ReplaceDeathTestFactory;
-#endif  // GTEST_HAS_DEATH_TEST
-
-  // Initializes the event listener performing XML output as specified by
-  // UnitTestOptions. Must not be called before InitGoogleTest.
-  void ConfigureXmlOutput();
-
-#if GTEST_CAN_STREAM_RESULTS_
-  // Initializes the event listener for streaming test results to a socket.
-  // Must not be called before InitGoogleTest.
-  void ConfigureStreamingOutput();
-#endif
-
-  // Performs initialization dependent upon flag values obtained in
-  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
-  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
-  // this function is also called from RunAllTests.  Since this function can be
-  // called more than once, it has to be idempotent.
-  void PostFlagParsingInit();
-
-  // Gets the random seed used at the start of the current test iteration.
-  int random_seed() const { return random_seed_; }
-
-  // Gets the random number generator.
-  internal::Random* random() { return &random_; }
-
-  // Shuffles all test suites, and the tests within each test suite,
-  // making sure that death tests are still run first.
-  void ShuffleTests();
-
-  // Restores the test suites and tests to their order before the first shuffle.
-  void UnshuffleTests();
-
-  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
-  // UnitTest::Run() starts.
-  bool catch_exceptions() const { return catch_exceptions_; }
-
- private:
-  friend class ::testing::UnitTest;
-
-  // Used by UnitTest::Run() to capture the state of
-  // GTEST_FLAG(catch_exceptions) at the moment it starts.
-  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
-
-  // The UnitTest object that owns this implementation object.
-  UnitTest* const parent_;
-
-  // The working directory when the first TEST() or TEST_F() was
-  // executed.
-  internal::FilePath original_working_dir_;
-
-  // The default test part result reporters.
-  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
-  DefaultPerThreadTestPartResultReporter
-      default_per_thread_test_part_result_reporter_;
-
-  // Points to (but doesn't own) the global test part result reporter.
-  TestPartResultReporterInterface* global_test_part_result_repoter_;
-
-  // Protects read and write access to global_test_part_result_reporter_.
-  internal::Mutex global_test_part_result_reporter_mutex_;
-
-  // Points to (but doesn't own) the per-thread test part result reporter.
-  internal::ThreadLocal<TestPartResultReporterInterface*>
-      per_thread_test_part_result_reporter_;
-
-  // The vector of environments that need to be set-up/torn-down
-  // before/after the tests are run.
-  std::vector<Environment*> environments_;
-
-  // The vector of TestSuites in their original order.  It owns the
-  // elements in the vector.
-  std::vector<TestSuite*> test_suites_;
-
-  // Provides a level of indirection for the test suite list to allow
-  // easy shuffling and restoring the test suite order.  The i-th
-  // element of this vector is the index of the i-th test suite in the
-  // shuffled order.
-  std::vector<int> test_suite_indices_;
-
-  // ParameterizedTestRegistry object used to register value-parameterized
-  // tests.
-  internal::ParameterizedTestSuiteRegistry parameterized_test_registry_;
-
-  // Indicates whether RegisterParameterizedTests() has been called already.
-  bool parameterized_tests_registered_;
-
-  // Index of the last death test suite registered.  Initially -1.
-  int last_death_test_suite_;
-
-  // This points to the TestSuite for the currently running test.  It
-  // changes as Google Test goes through one test suite after another.
-  // When no test is running, this is set to NULL and Google Test
-  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
-  TestSuite* current_test_suite_;
-
-  // This points to the TestInfo for the currently running test.  It
-  // changes as Google Test goes through one test after another.  When
-  // no test is running, this is set to NULL and Google Test stores
-  // assertion results in ad_hoc_test_result_.  Initially NULL.
-  TestInfo* current_test_info_;
-
-  // Normally, a user only writes assertions inside a TEST or TEST_F,
-  // or inside a function called by a TEST or TEST_F.  Since Google
-  // Test keeps track of which test is current running, it can
-  // associate such an assertion with the test it belongs to.
-  //
-  // If an assertion is encountered when no TEST or TEST_F is running,
-  // Google Test attributes the assertion result to an imaginary "ad hoc"
-  // test, and records the result in ad_hoc_test_result_.
-  TestResult ad_hoc_test_result_;
-
-  // The list of event listeners that can be used to track events inside
-  // Google Test.
-  TestEventListeners listeners_;
-
-  // The OS stack trace getter.  Will be deleted when the UnitTest
-  // object is destructed.  By default, an OsStackTraceGetter is used,
-  // but the user can set this field to use a custom getter if that is
-  // desired.
-  OsStackTraceGetterInterface* os_stack_trace_getter_;
-
-  // True iff PostFlagParsingInit() has been called.
-  bool post_flag_parse_init_performed_;
-
-  // The random number seed used at the beginning of the test run.
-  int random_seed_;
-
-  // Our random number generator.
-  internal::Random random_;
-
-  // The time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp_;
-
-  // How long the test took to run, in milliseconds.
-  TimeInMillis elapsed_time_;
-
-#if GTEST_HAS_DEATH_TEST
-  // The decomposed components of the gtest_internal_run_death_test flag,
-  // parsed when RUN_ALL_TESTS is called.
-  std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
-  std::unique_ptr<internal::DeathTestFactory> death_test_factory_;
-#endif  // GTEST_HAS_DEATH_TEST
-
-  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
-  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
-
-  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
-  // starts.
-  bool catch_exceptions_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
-};  // class UnitTestImpl
-
-// Convenience function for accessing the global UnitTest
-// implementation object.
-inline UnitTestImpl* GetUnitTestImpl() {
-  return UnitTest::GetInstance()->impl();
-}
-
-#if GTEST_USES_SIMPLE_RE
-
-// Internal helper functions for implementing the simple regular
-// expression matcher.
-GTEST_API_ bool IsInSet(char ch, const char* str);
-GTEST_API_ bool IsAsciiDigit(char ch);
-GTEST_API_ bool IsAsciiPunct(char ch);
-GTEST_API_ bool IsRepeat(char ch);
-GTEST_API_ bool IsAsciiWhiteSpace(char ch);
-GTEST_API_ bool IsAsciiWordChar(char ch);
-GTEST_API_ bool IsValidEscape(char ch);
-GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
-GTEST_API_ bool ValidateRegex(const char* regex);
-GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
-GTEST_API_ bool MatchRepetitionAndRegexAtHead(
-    bool escaped, char ch, char repeat, const char* regex, const char* str);
-GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
-
-#endif  // GTEST_USES_SIMPLE_RE
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.
-GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
-GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
-
-#if GTEST_HAS_DEATH_TEST
-
-// Returns the message describing the last system error, regardless of the
-// platform.
-GTEST_API_ std::string GetLastErrnoDescription();
-
-// Attempts to parse a string into a positive integer pointed to by the
-// number parameter.  Returns true if that is possible.
-// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
-// it here.
-template <typename Integer>
-bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
-  // Fail fast if the given string does not begin with a digit;
-  // this bypasses strtoXXX's "optional leading whitespace and plus
-  // or minus sign" semantics, which are undesirable here.
-  if (str.empty() || !IsDigit(str[0])) {
-    return false;
-  }
-  errno = 0;
-
-  char* end;
-  // BiggestConvertible is the largest integer type that system-provided
-  // string-to-number conversion routines can return.
-
-# if GTEST_OS_WINDOWS && !defined(__GNUC__)
-
-  // MSVC and C++ Builder define __int64 instead of the standard long long.
-  typedef unsigned __int64 BiggestConvertible;
-  const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
-
-# else
-
-  typedef unsigned long long BiggestConvertible;  // NOLINT
-  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
-
-# endif  // GTEST_OS_WINDOWS && !defined(__GNUC__)
-
-  const bool parse_success = *end == '\0' && errno == 0;
-
-  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
-
-  const Integer result = static_cast<Integer>(parsed);
-  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
-    *number = result;
-    return true;
-  }
-  return false;
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-// TestResult contains some private methods that should be hidden from
-// Google Test user but are required for testing. This class allow our tests
-// to access them.
-//
-// This class is supplied only for the purpose of testing Google Test's own
-// constructs. Do not use it in user tests, either directly or indirectly.
-class TestResultAccessor {
- public:
-  static void RecordProperty(TestResult* test_result,
-                             const std::string& xml_element,
-                             const TestProperty& property) {
-    test_result->RecordProperty(xml_element, property);
-  }
-
-  static void ClearTestPartResults(TestResult* test_result) {
-    test_result->ClearTestPartResults();
-  }
-
-  static const std::vector<testing::TestPartResult>& test_part_results(
-      const TestResult& test_result) {
-    return test_result.test_part_results();
-  }
-};
-
-#if GTEST_CAN_STREAM_RESULTS_
-
-// Streams test results to the given port on the given host machine.
-class StreamingListener : public EmptyTestEventListener {
- public:
-  // Abstract base class for writing strings to a socket.
-  class AbstractSocketWriter {
-   public:
-    virtual ~AbstractSocketWriter() {}
-
-    // Sends a string to the socket.
-    virtual void Send(const std::string& message) = 0;
-
-    // Closes the socket.
-    virtual void CloseConnection() {}
-
-    // Sends a string and a newline to the socket.
-    void SendLn(const std::string& message) { Send(message + "\n"); }
-  };
-
-  // Concrete class for actually writing strings to a socket.
-  class SocketWriter : public AbstractSocketWriter {
-   public:
-    SocketWriter(const std::string& host, const std::string& port)
-        : sockfd_(-1), host_name_(host), port_num_(port) {
-      MakeConnection();
-    }
-
-    ~SocketWriter() override {
-      if (sockfd_ != -1)
-        CloseConnection();
-    }
-
-    // Sends a string to the socket.
-    void Send(const std::string& message) override {
-      GTEST_CHECK_(sockfd_ != -1)
-          << "Send() can be called only when there is a connection.";
-
-      const int len = static_cast<int>(message.length());
-      if (write(sockfd_, message.c_str(), len) != len) {
-        GTEST_LOG_(WARNING)
-            << "stream_result_to: failed to stream to "
-            << host_name_ << ":" << port_num_;
-      }
-    }
-
-   private:
-    // Creates a client socket and connects to the server.
-    void MakeConnection();
-
-    // Closes the socket.
-    void CloseConnection() override {
-      GTEST_CHECK_(sockfd_ != -1)
-          << "CloseConnection() can be called only when there is a connection.";
-
-      close(sockfd_);
-      sockfd_ = -1;
-    }
-
-    int sockfd_;  // socket file descriptor
-    const std::string host_name_;
-    const std::string port_num_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
-  };  // class SocketWriter
-
-  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
-  static std::string UrlEncode(const char* str);
-
-  StreamingListener(const std::string& host, const std::string& port)
-      : socket_writer_(new SocketWriter(host, port)) {
-    Start();
-  }
-
-  explicit StreamingListener(AbstractSocketWriter* socket_writer)
-      : socket_writer_(socket_writer) { Start(); }
-
-  void OnTestProgramStart(const UnitTest& /* unit_test */) override {
-    SendLn("event=TestProgramStart");
-  }
-
-  void OnTestProgramEnd(const UnitTest& unit_test) override {
-    // Note that Google Test current only report elapsed time for each
-    // test iteration, not for the entire test program.
-    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
-
-    // Notify the streaming server to stop.
-    socket_writer_->CloseConnection();
-  }
-
-  void OnTestIterationStart(const UnitTest& /* unit_test */,
-                            int iteration) override {
-    SendLn("event=TestIterationStart&iteration=" +
-           StreamableToString(iteration));
-  }
-
-  void OnTestIterationEnd(const UnitTest& unit_test,
-                          int /* iteration */) override {
-    SendLn("event=TestIterationEnd&passed=" +
-           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
-           StreamableToString(unit_test.elapsed_time()) + "ms");
-  }
-
-  // Note that "event=TestCaseStart" is a wire format and has to remain
-  // "case" for compatibilty
-  void OnTestCaseStart(const TestCase& test_case) override {
-    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
-  }
-
-  // Note that "event=TestCaseEnd" is a wire format and has to remain
-  // "case" for compatibilty
-  void OnTestCaseEnd(const TestCase& test_case) override {
-    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
-           "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) +
-           "ms");
-  }
-
-  void OnTestStart(const TestInfo& test_info) override {
-    SendLn(std::string("event=TestStart&name=") + test_info.name());
-  }
-
-  void OnTestEnd(const TestInfo& test_info) override {
-    SendLn("event=TestEnd&passed=" +
-           FormatBool((test_info.result())->Passed()) +
-           "&elapsed_time=" +
-           StreamableToString((test_info.result())->elapsed_time()) + "ms");
-  }
-
-  void OnTestPartResult(const TestPartResult& test_part_result) override {
-    const char* file_name = test_part_result.file_name();
-    if (file_name == nullptr) file_name = "";
-    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
-           "&line=" + StreamableToString(test_part_result.line_number()) +
-           "&message=" + UrlEncode(test_part_result.message()));
-  }
-
- private:
-  // Sends the given message and a newline to the socket.
-  void SendLn(const std::string& message) { socket_writer_->SendLn(message); }
-
-  // Called at the start of streaming to notify the receiver what
-  // protocol we are using.
-  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
-
-  std::string FormatBool(bool value) { return value ? "1" : "0"; }
-
-  const std::unique_ptr<AbstractSocketWriter> socket_writer_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
-};  // class StreamingListener
-
-#endif  // GTEST_CAN_STREAM_RESULTS_
-
-}  // namespace internal
-}  // namespace testing
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_
-
-#if GTEST_OS_WINDOWS
-# define vsnprintf _vsnprintf
-#endif  // GTEST_OS_WINDOWS
-
-#if GTEST_OS_MAC
-#ifndef GTEST_OS_IOS
-#include <crt_externs.h>
-#endif
-#endif
-
-#if GTEST_HAS_ABSL
-#include "absl/debugging/failure_signal_handler.h"
-#include "absl/debugging/stacktrace.h"
-#include "absl/debugging/symbolize.h"
-#include "absl/strings/str_cat.h"
-#endif  // GTEST_HAS_ABSL
-
-namespace testing {
-
-using internal::CountIf;
-using internal::ForEach;
-using internal::GetElementOr;
-using internal::Shuffle;
-
-// Constants.
-
-// A test whose test suite name or test name matches this filter is
-// disabled and not run.
-static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
-
-// A test suite whose name matches this filter is considered a death
-// test suite and will be run before test suites whose name doesn't
-// match this filter.
-static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";
-
-// A test filter that matches everything.
-static const char kUniversalFilter[] = "*";
-
-// The default output format.
-static const char kDefaultOutputFormat[] = "xml";
-// The default output file.
-static const char kDefaultOutputFile[] = "test_detail";
-
-// The environment variable name for the test shard index.
-static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
-// The environment variable name for the total number of test shards.
-static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
-// The environment variable name for the test shard status file.
-static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
-
-namespace internal {
-
-// The text used in failure messages to indicate the start of the
-// stack trace.
-const char kStackTraceMarker[] = "\nStack trace:\n";
-
-// g_help_flag is true iff the --help flag or an equivalent form is
-// specified on the command line.
-bool g_help_flag = false;
-
-// Utilty function to Open File for Writing
-static FILE* OpenFileForWriting(const std::string& output_file) {
-  FILE* fileout = nullptr;
-  FilePath output_file_path(output_file);
-  FilePath output_dir(output_file_path.RemoveFileName());
-
-  if (output_dir.CreateDirectoriesRecursively()) {
-    fileout = posix::FOpen(output_file.c_str(), "w");
-  }
-  if (fileout == nullptr) {
-    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
-  }
-  return fileout;
-}
-
-}  // namespace internal
-
-// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY
-// environment variable.
-static const char* GetDefaultFilter() {
-  const char* const testbridge_test_only =
-      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
-  if (testbridge_test_only != nullptr) {
-    return testbridge_test_only;
-  }
-  return kUniversalFilter;
-}
-
-GTEST_DEFINE_bool_(
-    also_run_disabled_tests,
-    internal::BoolFromGTestEnv("also_run_disabled_tests", false),
-    "Run disabled tests too, in addition to the tests normally being run.");
-
-GTEST_DEFINE_bool_(
-    break_on_failure,
-    internal::BoolFromGTestEnv("break_on_failure", false),
-    "True iff a failed assertion should be a debugger break-point.");
-
-GTEST_DEFINE_bool_(
-    catch_exceptions,
-    internal::BoolFromGTestEnv("catch_exceptions", true),
-    "True iff " GTEST_NAME_
-    " should catch exceptions and treat them as test failures.");
-
-GTEST_DEFINE_string_(
-    color,
-    internal::StringFromGTestEnv("color", "auto"),
-    "Whether to use colors in the output.  Valid values: yes, no, "
-    "and auto.  'auto' means to use colors if the output is "
-    "being sent to a terminal and the TERM environment variable "
-    "is set to a terminal type that supports colors.");
-
-GTEST_DEFINE_string_(
-    filter,
-    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
-    "A colon-separated list of glob (not regex) patterns "
-    "for filtering the tests to run, optionally followed by a "
-    "'-' and a : separated list of negative patterns (tests to "
-    "exclude).  A test is run if it matches one of the positive "
-    "patterns and does not match any of the negative patterns.");
-
-GTEST_DEFINE_bool_(
-    install_failure_signal_handler,
-    internal::BoolFromGTestEnv("install_failure_signal_handler", false),
-    "If true and supported on the current platform, " GTEST_NAME_ " should "
-    "install a signal handler that dumps debugging information when fatal "
-    "signals are raised.");
-
-GTEST_DEFINE_bool_(list_tests, false,
-                   "List all tests without running them.");
-
-// The net priority order after flag processing is thus:
-//   --gtest_output command line flag
-//   GTEST_OUTPUT environment variable
-//   XML_OUTPUT_FILE environment variable
-//   ''
-GTEST_DEFINE_string_(
-    output,
-    internal::StringFromGTestEnv("output",
-      internal::OutputFlagAlsoCheckEnvVar().c_str()),
-    "A format (defaults to \"xml\" but can be specified to be \"json\"), "
-    "optionally followed by a colon and an output file name or directory. "
-    "A directory is indicated by a trailing pathname separator. "
-    "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
-    "If a directory is specified, output files will be created "
-    "within that directory, with file-names based on the test "
-    "executable's name and, if necessary, made unique by adding "
-    "digits.");
-
-GTEST_DEFINE_bool_(
-    print_time,
-    internal::BoolFromGTestEnv("print_time", true),
-    "True iff " GTEST_NAME_
-    " should display elapsed time in text output.");
-
-GTEST_DEFINE_bool_(
-    print_utf8,
-    internal::BoolFromGTestEnv("print_utf8", true),
-    "True iff " GTEST_NAME_
-    " prints UTF8 characters as text.");
-
-GTEST_DEFINE_int32_(
-    random_seed,
-    internal::Int32FromGTestEnv("random_seed", 0),
-    "Random number seed to use when shuffling test orders.  Must be in range "
-    "[1, 99999], or 0 to use a seed based on the current time.");
-
-GTEST_DEFINE_int32_(
-    repeat,
-    internal::Int32FromGTestEnv("repeat", 1),
-    "How many times to repeat each test.  Specify a negative number "
-    "for repeating forever.  Useful for shaking out flaky tests.");
-
-GTEST_DEFINE_bool_(
-    show_internal_stack_frames, false,
-    "True iff " GTEST_NAME_ " should include internal stack frames when "
-    "printing test failure stack traces.");
-
-GTEST_DEFINE_bool_(
-    shuffle,
-    internal::BoolFromGTestEnv("shuffle", false),
-    "True iff " GTEST_NAME_
-    " should randomize tests' order on every run.");
-
-GTEST_DEFINE_int32_(
-    stack_trace_depth,
-    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
-    "The maximum number of stack frames to print when an "
-    "assertion fails.  The valid range is 0 through 100, inclusive.");
-
-GTEST_DEFINE_string_(
-    stream_result_to,
-    internal::StringFromGTestEnv("stream_result_to", ""),
-    "This flag specifies the host name and the port number on which to stream "
-    "test results. Example: \"localhost:555\". The flag is effective only on "
-    "Linux.");
-
-GTEST_DEFINE_bool_(
-    throw_on_failure,
-    internal::BoolFromGTestEnv("throw_on_failure", false),
-    "When this flag is specified, a failed assertion will throw an exception "
-    "if exceptions are enabled or exit the program with a non-zero code "
-    "otherwise. For use with an external test framework.");
-
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-GTEST_DEFINE_string_(
-    flagfile,
-    internal::StringFromGTestEnv("flagfile", ""),
-    "This flag specifies the flagfile to read command-line flags from.");
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-
-namespace internal {
-
-// Generates a random number from [0, range), using a Linear
-// Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
-// than kMaxRange.
-UInt32 Random::Generate(UInt32 range) {
-  // These constants are the same as are used in glibc's rand(3).
-  // Use wider types than necessary to prevent unsigned overflow diagnostics.
-  state_ = static_cast<UInt32>(1103515245ULL*state_ + 12345U) % kMaxRange;
-
-  GTEST_CHECK_(range > 0)
-      << "Cannot generate a number in the range [0, 0).";
-  GTEST_CHECK_(range <= kMaxRange)
-      << "Generation of a number in [0, " << range << ") was requested, "
-      << "but this can only generate numbers in [0, " << kMaxRange << ").";
-
-  // Converting via modulus introduces a bit of downward bias, but
-  // it's simple, and a linear congruential generator isn't too good
-  // to begin with.
-  return state_ % range;
-}
-
-// GTestIsInitialized() returns true iff the user has initialized
-// Google Test.  Useful for catching the user mistake of not initializing
-// Google Test before calling RUN_ALL_TESTS().
-static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
-
-// Iterates over a vector of TestSuites, keeping a running sum of the
-// results of calling a given int-returning method on each.
-// Returns the sum.
-static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
-                                int (TestSuite::*method)() const) {
-  int sum = 0;
-  for (size_t i = 0; i < case_list.size(); i++) {
-    sum += (case_list[i]->*method)();
-  }
-  return sum;
-}
-
-// Returns true iff the test suite passed.
-static bool TestSuitePassed(const TestSuite* test_suite) {
-  return test_suite->should_run() && test_suite->Passed();
-}
-
-// Returns true iff the test suite failed.
-static bool TestSuiteFailed(const TestSuite* test_suite) {
-  return test_suite->should_run() && test_suite->Failed();
-}
-
-// Returns true iff test_suite contains at least one test that should
-// run.
-static bool ShouldRunTestSuite(const TestSuite* test_suite) {
-  return test_suite->should_run();
-}
-
-// AssertHelper constructor.
-AssertHelper::AssertHelper(TestPartResult::Type type,
-                           const char* file,
-                           int line,
-                           const char* message)
-    : data_(new AssertHelperData(type, file, line, message)) {
-}
-
-AssertHelper::~AssertHelper() {
-  delete data_;
-}
-
-// Message assignment, for assertion streaming support.
-void AssertHelper::operator=(const Message& message) const {
-  UnitTest::GetInstance()->
-    AddTestPartResult(data_->type, data_->file, data_->line,
-                      AppendUserMessage(data_->message, message),
-                      UnitTest::GetInstance()->impl()
-                      ->CurrentOsStackTraceExceptTop(1)
-                      // Skips the stack frame for this function itself.
-                      );  // NOLINT
-}
-
-// A copy of all command line arguments.  Set by InitGoogleTest().
-static ::std::vector<std::string> g_argvs;
-
-::std::vector<std::string> GetArgvs() {
-#if defined(GTEST_CUSTOM_GET_ARGVS_)
-  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
-  // ::string. This code converts it to the appropriate type.
-  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
-  return ::std::vector<std::string>(custom.begin(), custom.end());
-#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
-  return g_argvs;
-#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
-}
-
-// Returns the current application's name, removing directory path if that
-// is present.
-FilePath GetCurrentExecutableName() {
-  FilePath result;
-
-#if GTEST_OS_WINDOWS || GTEST_OS_OS2
-  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
-#else
-  result.Set(FilePath(GetArgvs()[0]));
-#endif  // GTEST_OS_WINDOWS
-
-  return result.RemoveDirectoryName();
-}
-
-// Functions for processing the gtest_output flag.
-
-// Returns the output format, or "" for normal printed output.
-std::string UnitTestOptions::GetOutputFormat() {
-  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
-  const char* const colon = strchr(gtest_output_flag, ':');
-  return (colon == nullptr)
-             ? std::string(gtest_output_flag)
-             : std::string(gtest_output_flag, colon - gtest_output_flag);
-}
-
-// Returns the name of the requested output file, or the default if none
-// was explicitly specified.
-std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
-  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
-
-  std::string format = GetOutputFormat();
-  if (format.empty())
-    format = std::string(kDefaultOutputFormat);
-
-  const char* const colon = strchr(gtest_output_flag, ':');
-  if (colon == nullptr)
-    return internal::FilePath::MakeFileName(
-        internal::FilePath(
-            UnitTest::GetInstance()->original_working_dir()),
-        internal::FilePath(kDefaultOutputFile), 0,
-        format.c_str()).string();
-
-  internal::FilePath output_name(colon + 1);
-  if (!output_name.IsAbsolutePath())
-    output_name = internal::FilePath::ConcatPaths(
-        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
-        internal::FilePath(colon + 1));
-
-  if (!output_name.IsDirectory())
-    return output_name.string();
-
-  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
-      output_name, internal::GetCurrentExecutableName(),
-      GetOutputFormat().c_str()));
-  return result.string();
-}
-
-// Returns true iff the wildcard pattern matches the string.  The
-// first ':' or '\0' character in pattern marks the end of it.
-//
-// This recursive algorithm isn't very efficient, but is clear and
-// works well enough for matching test names, which are short.
-bool UnitTestOptions::PatternMatchesString(const char *pattern,
-                                           const char *str) {
-  switch (*pattern) {
-    case '\0':
-    case ':':  // Either ':' or '\0' marks the end of the pattern.
-      return *str == '\0';
-    case '?':  // Matches any single character.
-      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
-    case '*':  // Matches any string (possibly empty) of characters.
-      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
-          PatternMatchesString(pattern + 1, str);
-    default:  // Non-special character.  Matches itself.
-      return *pattern == *str &&
-          PatternMatchesString(pattern + 1, str + 1);
-  }
-}
-
-bool UnitTestOptions::MatchesFilter(
-    const std::string& name, const char* filter) {
-  const char *cur_pattern = filter;
-  for (;;) {
-    if (PatternMatchesString(cur_pattern, name.c_str())) {
-      return true;
-    }
-
-    // Finds the next pattern in the filter.
-    cur_pattern = strchr(cur_pattern, ':');
-
-    // Returns if no more pattern can be found.
-    if (cur_pattern == nullptr) {
-      return false;
-    }
-
-    // Skips the pattern separater (the ':' character).
-    cur_pattern++;
-  }
-}
-
-// Returns true iff the user-specified filter matches the test suite
-// name and the test name.
-bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
-                                        const std::string& test_name) {
-  const std::string& full_name = test_suite_name + "." + test_name.c_str();
-
-  // Split --gtest_filter at '-', if there is one, to separate into
-  // positive filter and negative filter portions
-  const char* const p = GTEST_FLAG(filter).c_str();
-  const char* const dash = strchr(p, '-');
-  std::string positive;
-  std::string negative;
-  if (dash == nullptr) {
-    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
-    negative = "";
-  } else {
-    positive = std::string(p, dash);   // Everything up to the dash
-    negative = std::string(dash + 1);  // Everything after the dash
-    if (positive.empty()) {
-      // Treat '-test1' as the same as '*-test1'
-      positive = kUniversalFilter;
-    }
-  }
-
-  // A filter is a colon-separated list of patterns.  It matches a
-  // test if any pattern in it matches the test.
-  return (MatchesFilter(full_name, positive.c_str()) &&
-          !MatchesFilter(full_name, negative.c_str()));
-}
-
-#if GTEST_HAS_SEH
-// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
-// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
-// This function is useful as an __except condition.
-int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
-  // Google Test should handle a SEH exception if:
-  //   1. the user wants it to, AND
-  //   2. this is not a breakpoint exception, AND
-  //   3. this is not a C++ exception (VC++ implements them via SEH,
-  //      apparently).
-  //
-  // SEH exception code for C++ exceptions.
-  // (see http://support.microsoft.com/kb/185294 for more information).
-  const DWORD kCxxExceptionCode = 0xe06d7363;
-
-  bool should_handle = true;
-
-  if (!GTEST_FLAG(catch_exceptions))
-    should_handle = false;
-  else if (exception_code == EXCEPTION_BREAKPOINT)
-    should_handle = false;
-  else if (exception_code == kCxxExceptionCode)
-    should_handle = false;
-
-  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
-}
-#endif  // GTEST_HAS_SEH
-
-}  // namespace internal
-
-// The c'tor sets this object as the test part result reporter used by
-// Google Test.  The 'result' parameter specifies where to report the
-// results. Intercepts only failures from the current thread.
-ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
-    TestPartResultArray* result)
-    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
-      result_(result) {
-  Init();
-}
-
-// The c'tor sets this object as the test part result reporter used by
-// Google Test.  The 'result' parameter specifies where to report the
-// results.
-ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
-    InterceptMode intercept_mode, TestPartResultArray* result)
-    : intercept_mode_(intercept_mode),
-      result_(result) {
-  Init();
-}
-
-void ScopedFakeTestPartResultReporter::Init() {
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
-    old_reporter_ = impl->GetGlobalTestPartResultReporter();
-    impl->SetGlobalTestPartResultReporter(this);
-  } else {
-    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
-    impl->SetTestPartResultReporterForCurrentThread(this);
-  }
-}
-
-// The d'tor restores the test part result reporter used by Google Test
-// before.
-ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
-    impl->SetGlobalTestPartResultReporter(old_reporter_);
-  } else {
-    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
-  }
-}
-
-// Increments the test part result count and remembers the result.
-// This method is from the TestPartResultReporterInterface interface.
-void ScopedFakeTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  result_->Append(result);
-}
-
-namespace internal {
-
-// Returns the type ID of ::testing::Test.  We should always call this
-// instead of GetTypeId< ::testing::Test>() to get the type ID of
-// testing::Test.  This is to work around a suspected linker bug when
-// using Google Test as a framework on Mac OS X.  The bug causes
-// GetTypeId< ::testing::Test>() to return different values depending
-// on whether the call is from the Google Test framework itself or
-// from user test code.  GetTestTypeId() is guaranteed to always
-// return the same value, as it always calls GetTypeId<>() from the
-// gtest.cc, which is within the Google Test framework.
-TypeId GetTestTypeId() {
-  return GetTypeId<Test>();
-}
-
-// The value of GetTestTypeId() as seen from within the Google Test
-// library.  This is solely for testing GetTestTypeId().
-extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
-
-// This predicate-formatter checks that 'results' contains a test part
-// failure of the given type and that the failure message contains the
-// given substring.
-static AssertionResult HasOneFailure(const char* /* results_expr */,
-                                     const char* /* type_expr */,
-                                     const char* /* substr_expr */,
-                                     const TestPartResultArray& results,
-                                     TestPartResult::Type type,
-                                     const std::string& substr) {
-  const std::string expected(type == TestPartResult::kFatalFailure ?
-                        "1 fatal failure" :
-                        "1 non-fatal failure");
-  Message msg;
-  if (results.size() != 1) {
-    msg << "Expected: " << expected << "\n"
-        << "  Actual: " << results.size() << " failures";
-    for (int i = 0; i < results.size(); i++) {
-      msg << "\n" << results.GetTestPartResult(i);
-    }
-    return AssertionFailure() << msg;
-  }
-
-  const TestPartResult& r = results.GetTestPartResult(0);
-  if (r.type() != type) {
-    return AssertionFailure() << "Expected: " << expected << "\n"
-                              << "  Actual:\n"
-                              << r;
-  }
-
-  if (strstr(r.message(), substr.c_str()) == nullptr) {
-    return AssertionFailure() << "Expected: " << expected << " containing \""
-                              << substr << "\"\n"
-                              << "  Actual:\n"
-                              << r;
-  }
-
-  return AssertionSuccess();
-}
-
-// The constructor of SingleFailureChecker remembers where to look up
-// test part results, what type of failure we expect, and what
-// substring the failure message should contain.
-SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results,
-                                           TestPartResult::Type type,
-                                           const std::string& substr)
-    : results_(results), type_(type), substr_(substr) {}
-
-// The destructor of SingleFailureChecker verifies that the given
-// TestPartResultArray contains exactly one failure that has the given
-// type and contains the given substring.  If that's not the case, a
-// non-fatal failure will be generated.
-SingleFailureChecker::~SingleFailureChecker() {
-  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
-}
-
-DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
-    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
-
-void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  unit_test_->current_test_result()->AddTestPartResult(result);
-  unit_test_->listeners()->repeater()->OnTestPartResult(result);
-}
-
-DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
-    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
-
-void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
-}
-
-// Returns the global test part result reporter.
-TestPartResultReporterInterface*
-UnitTestImpl::GetGlobalTestPartResultReporter() {
-  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
-  return global_test_part_result_repoter_;
-}
-
-// Sets the global test part result reporter.
-void UnitTestImpl::SetGlobalTestPartResultReporter(
-    TestPartResultReporterInterface* reporter) {
-  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
-  global_test_part_result_repoter_ = reporter;
-}
-
-// Returns the test part result reporter for the current thread.
-TestPartResultReporterInterface*
-UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
-  return per_thread_test_part_result_reporter_.get();
-}
-
-// Sets the test part result reporter for the current thread.
-void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
-    TestPartResultReporterInterface* reporter) {
-  per_thread_test_part_result_reporter_.set(reporter);
-}
-
-// Gets the number of successful test suites.
-int UnitTestImpl::successful_test_suite_count() const {
-  return CountIf(test_suites_, TestSuitePassed);
-}
-
-// Gets the number of failed test suites.
-int UnitTestImpl::failed_test_suite_count() const {
-  return CountIf(test_suites_, TestSuiteFailed);
-}
-
-// Gets the number of all test suites.
-int UnitTestImpl::total_test_suite_count() const {
-  return static_cast<int>(test_suites_.size());
-}
-
-// Gets the number of all test suites that contain at least one test
-// that should run.
-int UnitTestImpl::test_suite_to_run_count() const {
-  return CountIf(test_suites_, ShouldRunTestSuite);
-}
-
-// Gets the number of successful tests.
-int UnitTestImpl::successful_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);
-}
-
-// Gets the number of skipped tests.
-int UnitTestImpl::skipped_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
-}
-
-// Gets the number of failed tests.
-int UnitTestImpl::failed_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
-}
-
-// Gets the number of disabled tests that will be reported in the XML report.
-int UnitTestImpl::reportable_disabled_test_count() const {
-  return SumOverTestSuiteList(test_suites_,
-                              &TestSuite::reportable_disabled_test_count);
-}
-
-// Gets the number of disabled tests.
-int UnitTestImpl::disabled_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);
-}
-
-// Gets the number of tests to be printed in the XML report.
-int UnitTestImpl::reportable_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);
-}
-
-// Gets the number of all tests.
-int UnitTestImpl::total_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
-}
-
-// Gets the number of tests that should run.
-int UnitTestImpl::test_to_run_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
-}
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
-// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
-  return os_stack_trace_getter()->CurrentStackTrace(
-      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
-      skip_count + 1
-      // Skips the user-specified number of frames plus this function
-      // itself.
-      );  // NOLINT
-}
-
-// Returns the current time in milliseconds.
-TimeInMillis GetTimeInMillis() {
-#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
-  // Difference between 1970-01-01 and 1601-01-01 in milliseconds.
-  // http://analogous.blogspot.com/2005/04/epoch.html
-  const TimeInMillis kJavaEpochToWinFileTimeDelta =
-    static_cast<TimeInMillis>(116444736UL) * 100000UL;
-  const DWORD kTenthMicrosInMilliSecond = 10000;
-
-  SYSTEMTIME now_systime;
-  FILETIME now_filetime;
-  ULARGE_INTEGER now_int64;
-  GetSystemTime(&now_systime);
-  if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
-    now_int64.LowPart = now_filetime.dwLowDateTime;
-    now_int64.HighPart = now_filetime.dwHighDateTime;
-    now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
-      kJavaEpochToWinFileTimeDelta;
-    return now_int64.QuadPart;
-  }
-  return 0;
-#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_
-  __timeb64 now;
-
-  // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
-  // (deprecated function) there.
-  GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
-  _ftime64(&now);
-  GTEST_DISABLE_MSC_DEPRECATED_POP_()
-
-  return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
-#elif GTEST_HAS_GETTIMEOFDAY_
-  struct timeval now;
-  gettimeofday(&now, nullptr);
-  return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
-#else
-# error "Don't know how to get the current time on your system."
-#endif
-}
-
-// Utilities
-
-// class String.
-
-#if GTEST_OS_WINDOWS_MOBILE
-// Creates a UTF-16 wide string from the given ANSI string, allocating
-// memory using new. The caller is responsible for deleting the return
-// value using delete[]. Returns the wide string, or NULL if the
-// input is NULL.
-LPCWSTR String::AnsiToUtf16(const char* ansi) {
-  if (!ansi) return nullptr;
-  const int length = strlen(ansi);
-  const int unicode_length =
-      MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);
-  WCHAR* unicode = new WCHAR[unicode_length + 1];
-  MultiByteToWideChar(CP_ACP, 0, ansi, length,
-                      unicode, unicode_length);
-  unicode[unicode_length] = 0;
-  return unicode;
-}
-
-// Creates an ANSI string from the given wide string, allocating
-// memory using new. The caller is responsible for deleting the return
-// value using delete[]. Returns the ANSI string, or NULL if the
-// input is NULL.
-const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
-  if (!utf16_str) return nullptr;
-  const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr,
-                                              0, nullptr, nullptr);
-  char* ansi = new char[ansi_length + 1];
-  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr,
-                      nullptr);
-  ansi[ansi_length] = 0;
-  return ansi;
-}
-
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-// Compares two C strings.  Returns true iff they have the same content.
-//
-// Unlike strcmp(), this function can handle NULL argument(s).  A NULL
-// C string is considered different to any non-NULL C string,
-// including the empty string.
-bool String::CStringEquals(const char * lhs, const char * rhs) {
-  if (lhs == nullptr) return rhs == nullptr;
-
-  if (rhs == nullptr) return false;
-
-  return strcmp(lhs, rhs) == 0;
-}
-
-#if GTEST_HAS_STD_WSTRING
-
-// Converts an array of wide chars to a narrow string using the UTF-8
-// encoding, and streams the result to the given Message object.
-static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
-                                     Message* msg) {
-  for (size_t i = 0; i != length; ) {  // NOLINT
-    if (wstr[i] != L'\0') {
-      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
-      while (i != length && wstr[i] != L'\0')
-        i++;
-    } else {
-      *msg << '\0';
-      i++;
-    }
-  }
-}
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-void SplitString(const ::std::string& str, char delimiter,
-                 ::std::vector< ::std::string>* dest) {
-  ::std::vector< ::std::string> parsed;
-  ::std::string::size_type pos = 0;
-  while (::testing::internal::AlwaysTrue()) {
-    const ::std::string::size_type colon = str.find(delimiter, pos);
-    if (colon == ::std::string::npos) {
-      parsed.push_back(str.substr(pos));
-      break;
-    } else {
-      parsed.push_back(str.substr(pos, colon - pos));
-      pos = colon + 1;
-    }
-  }
-  dest->swap(parsed);
-}
-
-}  // namespace internal
-
-// Constructs an empty Message.
-// We allocate the stringstream separately because otherwise each use of
-// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
-// stack frame leading to huge stack frames in some cases; gcc does not reuse
-// the stack space.
-Message::Message() : ss_(new ::std::stringstream) {
-  // By default, we want there to be enough precision when printing
-  // a double to a Message.
-  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
-}
-
-// These two overloads allow streaming a wide C string to a Message
-// using the UTF-8 encoding.
-Message& Message::operator <<(const wchar_t* wide_c_str) {
-  return *this << internal::String::ShowWideCString(wide_c_str);
-}
-Message& Message::operator <<(wchar_t* wide_c_str) {
-  return *this << internal::String::ShowWideCString(wide_c_str);
-}
-
-#if GTEST_HAS_STD_WSTRING
-// Converts the given wide string to a narrow string using the UTF-8
-// encoding, and streams the result to this Message object.
-Message& Message::operator <<(const ::std::wstring& wstr) {
-  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
-  return *this;
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-// Gets the text streamed to this object so far as an std::string.
-// Each '\0' character in the buffer is replaced with "\\0".
-std::string Message::GetString() const {
-  return internal::StringStreamToString(ss_.get());
-}
-
-// AssertionResult constructors.
-// Used in EXPECT_TRUE/FALSE(assertion_result).
-AssertionResult::AssertionResult(const AssertionResult& other)
-    : success_(other.success_),
-      message_(other.message_.get() != nullptr
-                   ? new ::std::string(*other.message_)
-                   : static_cast< ::std::string*>(nullptr)) {}
-
-// Swaps two AssertionResults.
-void AssertionResult::swap(AssertionResult& other) {
-  using std::swap;
-  swap(success_, other.success_);
-  swap(message_, other.message_);
-}
-
-// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
-AssertionResult AssertionResult::operator!() const {
-  AssertionResult negation(!success_);
-  if (message_.get() != nullptr) negation << *message_;
-  return negation;
-}
-
-// Makes a successful assertion result.
-AssertionResult AssertionSuccess() {
-  return AssertionResult(true);
-}
-
-// Makes a failed assertion result.
-AssertionResult AssertionFailure() {
-  return AssertionResult(false);
-}
-
-// Makes a failed assertion result with the given failure message.
-// Deprecated; use AssertionFailure() << message.
-AssertionResult AssertionFailure(const Message& message) {
-  return AssertionFailure() << message;
-}
-
-namespace internal {
-
-namespace edit_distance {
-std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
-                                            const std::vector<size_t>& right) {
-  std::vector<std::vector<double> > costs(
-      left.size() + 1, std::vector<double>(right.size() + 1));
-  std::vector<std::vector<EditType> > best_move(
-      left.size() + 1, std::vector<EditType>(right.size() + 1));
-
-  // Populate for empty right.
-  for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
-    costs[l_i][0] = static_cast<double>(l_i);
-    best_move[l_i][0] = kRemove;
-  }
-  // Populate for empty left.
-  for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
-    costs[0][r_i] = static_cast<double>(r_i);
-    best_move[0][r_i] = kAdd;
-  }
-
-  for (size_t l_i = 0; l_i < left.size(); ++l_i) {
-    for (size_t r_i = 0; r_i < right.size(); ++r_i) {
-      if (left[l_i] == right[r_i]) {
-        // Found a match. Consume it.
-        costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
-        best_move[l_i + 1][r_i + 1] = kMatch;
-        continue;
-      }
-
-      const double add = costs[l_i + 1][r_i];
-      const double remove = costs[l_i][r_i + 1];
-      const double replace = costs[l_i][r_i];
-      if (add < remove && add < replace) {
-        costs[l_i + 1][r_i + 1] = add + 1;
-        best_move[l_i + 1][r_i + 1] = kAdd;
-      } else if (remove < add && remove < replace) {
-        costs[l_i + 1][r_i + 1] = remove + 1;
-        best_move[l_i + 1][r_i + 1] = kRemove;
-      } else {
-        // We make replace a little more expensive than add/remove to lower
-        // their priority.
-        costs[l_i + 1][r_i + 1] = replace + 1.00001;
-        best_move[l_i + 1][r_i + 1] = kReplace;
-      }
-    }
-  }
-
-  // Reconstruct the best path. We do it in reverse order.
-  std::vector<EditType> best_path;
-  for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
-    EditType move = best_move[l_i][r_i];
-    best_path.push_back(move);
-    l_i -= move != kAdd;
-    r_i -= move != kRemove;
-  }
-  std::reverse(best_path.begin(), best_path.end());
-  return best_path;
-}
-
-namespace {
-
-// Helper class to convert string into ids with deduplication.
-class InternalStrings {
- public:
-  size_t GetId(const std::string& str) {
-    IdMap::iterator it = ids_.find(str);
-    if (it != ids_.end()) return it->second;
-    size_t id = ids_.size();
-    return ids_[str] = id;
-  }
-
- private:
-  typedef std::map<std::string, size_t> IdMap;
-  IdMap ids_;
-};
-
-}  // namespace
-
-std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<std::string>& left,
-    const std::vector<std::string>& right) {
-  std::vector<size_t> left_ids, right_ids;
-  {
-    InternalStrings intern_table;
-    for (size_t i = 0; i < left.size(); ++i) {
-      left_ids.push_back(intern_table.GetId(left[i]));
-    }
-    for (size_t i = 0; i < right.size(); ++i) {
-      right_ids.push_back(intern_table.GetId(right[i]));
-    }
-  }
-  return CalculateOptimalEdits(left_ids, right_ids);
-}
-
-namespace {
-
-// Helper class that holds the state for one hunk and prints it out to the
-// stream.
-// It reorders adds/removes when possible to group all removes before all
-// adds. It also adds the hunk header before printint into the stream.
-class Hunk {
- public:
-  Hunk(size_t left_start, size_t right_start)
-      : left_start_(left_start),
-        right_start_(right_start),
-        adds_(),
-        removes_(),
-        common_() {}
-
-  void PushLine(char edit, const char* line) {
-    switch (edit) {
-      case ' ':
-        ++common_;
-        FlushEdits();
-        hunk_.push_back(std::make_pair(' ', line));
-        break;
-      case '-':
-        ++removes_;
-        hunk_removes_.push_back(std::make_pair('-', line));
-        break;
-      case '+':
-        ++adds_;
-        hunk_adds_.push_back(std::make_pair('+', line));
-        break;
-    }
-  }
-
-  void PrintTo(std::ostream* os) {
-    PrintHeader(os);
-    FlushEdits();
-    for (std::list<std::pair<char, const char*> >::const_iterator it =
-             hunk_.begin();
-         it != hunk_.end(); ++it) {
-      *os << it->first << it->second << "\n";
-    }
-  }
-
-  bool has_edits() const { return adds_ || removes_; }
-
- private:
-  void FlushEdits() {
-    hunk_.splice(hunk_.end(), hunk_removes_);
-    hunk_.splice(hunk_.end(), hunk_adds_);
-  }
-
-  // Print a unified diff header for one hunk.
-  // The format is
-  //   "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
-  // where the left/right parts are omitted if unnecessary.
-  void PrintHeader(std::ostream* ss) const {
-    *ss << "@@ ";
-    if (removes_) {
-      *ss << "-" << left_start_ << "," << (removes_ + common_);
-    }
-    if (removes_ && adds_) {
-      *ss << " ";
-    }
-    if (adds_) {
-      *ss << "+" << right_start_ << "," << (adds_ + common_);
-    }
-    *ss << " @@\n";
-  }
-
-  size_t left_start_, right_start_;
-  size_t adds_, removes_, common_;
-  std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
-};
-
-}  // namespace
-
-// Create a list of diff hunks in Unified diff format.
-// Each hunk has a header generated by PrintHeader above plus a body with
-// lines prefixed with ' ' for no change, '-' for deletion and '+' for
-// addition.
-// 'context' represents the desired unchanged prefix/suffix around the diff.
-// If two hunks are close enough that their contexts overlap, then they are
-// joined into one hunk.
-std::string CreateUnifiedDiff(const std::vector<std::string>& left,
-                              const std::vector<std::string>& right,
-                              size_t context) {
-  const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
-
-  size_t l_i = 0, r_i = 0, edit_i = 0;
-  std::stringstream ss;
-  while (edit_i < edits.size()) {
-    // Find first edit.
-    while (edit_i < edits.size() && edits[edit_i] == kMatch) {
-      ++l_i;
-      ++r_i;
-      ++edit_i;
-    }
-
-    // Find the first line to include in the hunk.
-    const size_t prefix_context = std::min(l_i, context);
-    Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
-    for (size_t i = prefix_context; i > 0; --i) {
-      hunk.PushLine(' ', left[l_i - i].c_str());
-    }
-
-    // Iterate the edits until we found enough suffix for the hunk or the input
-    // is over.
-    size_t n_suffix = 0;
-    for (; edit_i < edits.size(); ++edit_i) {
-      if (n_suffix >= context) {
-        // Continue only if the next hunk is very close.
-        std::vector<EditType>::const_iterator it = edits.begin() + edit_i;
-        while (it != edits.end() && *it == kMatch) ++it;
-        if (it == edits.end() || (it - edits.begin()) - edit_i >= context) {
-          // There is no next edit or it is too far away.
-          break;
-        }
-      }
-
-      EditType edit = edits[edit_i];
-      // Reset count when a non match is found.
-      n_suffix = edit == kMatch ? n_suffix + 1 : 0;
-
-      if (edit == kMatch || edit == kRemove || edit == kReplace) {
-        hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
-      }
-      if (edit == kAdd || edit == kReplace) {
-        hunk.PushLine('+', right[r_i].c_str());
-      }
-
-      // Advance indices, depending on edit type.
-      l_i += edit != kAdd;
-      r_i += edit != kRemove;
-    }
-
-    if (!hunk.has_edits()) {
-      // We are done. We don't want this hunk.
-      break;
-    }
-
-    hunk.PrintTo(&ss);
-  }
-  return ss.str();
-}
-
-}  // namespace edit_distance
-
-namespace {
-
-// The string representation of the values received in EqFailure() are already
-// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
-// characters the same.
-std::vector<std::string> SplitEscapedString(const std::string& str) {
-  std::vector<std::string> lines;
-  size_t start = 0, end = str.size();
-  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
-    ++start;
-    --end;
-  }
-  bool escaped = false;
-  for (size_t i = start; i + 1 < end; ++i) {
-    if (escaped) {
-      escaped = false;
-      if (str[i] == 'n') {
-        lines.push_back(str.substr(start, i - start - 1));
-        start = i + 1;
-      }
-    } else {
-      escaped = str[i] == '\\';
-    }
-  }
-  lines.push_back(str.substr(start, end - start));
-  return lines;
-}
-
-}  // namespace
-
-// Constructs and returns the message for an equality assertion
-// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
-//
-// The first four parameters are the expressions used in the assertion
-// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
-// where foo is 5 and bar is 6, we have:
-//
-//   lhs_expression: "foo"
-//   rhs_expression: "bar"
-//   lhs_value:      "5"
-//   rhs_value:      "6"
-//
-// The ignoring_case parameter is true iff the assertion is a
-// *_STRCASEEQ*.  When it's true, the string "Ignoring case" will
-// be inserted into the message.
-AssertionResult EqFailure(const char* lhs_expression,
-                          const char* rhs_expression,
-                          const std::string& lhs_value,
-                          const std::string& rhs_value,
-                          bool ignoring_case) {
-  Message msg;
-  msg << "Expected equality of these values:";
-  msg << "\n  " << lhs_expression;
-  if (lhs_value != lhs_expression) {
-    msg << "\n    Which is: " << lhs_value;
-  }
-  msg << "\n  " << rhs_expression;
-  if (rhs_value != rhs_expression) {
-    msg << "\n    Which is: " << rhs_value;
-  }
-
-  if (ignoring_case) {
-    msg << "\nIgnoring case";
-  }
-
-  if (!lhs_value.empty() && !rhs_value.empty()) {
-    const std::vector<std::string> lhs_lines =
-        SplitEscapedString(lhs_value);
-    const std::vector<std::string> rhs_lines =
-        SplitEscapedString(rhs_value);
-    if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
-      msg << "\nWith diff:\n"
-          << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
-    }
-  }
-
-  return AssertionFailure() << msg;
-}
-
-// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
-std::string GetBoolAssertionFailureMessage(
-    const AssertionResult& assertion_result,
-    const char* expression_text,
-    const char* actual_predicate_value,
-    const char* expected_predicate_value) {
-  const char* actual_message = assertion_result.message();
-  Message msg;
-  msg << "Value of: " << expression_text
-      << "\n  Actual: " << actual_predicate_value;
-  if (actual_message[0] != '\0')
-    msg << " (" << actual_message << ")";
-  msg << "\nExpected: " << expected_predicate_value;
-  return msg.GetString();
-}
-
-// Helper function for implementing ASSERT_NEAR.
-AssertionResult DoubleNearPredFormat(const char* expr1,
-                                     const char* expr2,
-                                     const char* abs_error_expr,
-                                     double val1,
-                                     double val2,
-                                     double abs_error) {
-  const double diff = fabs(val1 - val2);
-  if (diff <= abs_error) return AssertionSuccess();
-
-  return AssertionFailure()
-      << "The difference between " << expr1 << " and " << expr2
-      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
-      << expr1 << " evaluates to " << val1 << ",\n"
-      << expr2 << " evaluates to " << val2 << ", and\n"
-      << abs_error_expr << " evaluates to " << abs_error << ".";
-}
-
-
-// Helper template for implementing FloatLE() and DoubleLE().
-template <typename RawType>
-AssertionResult FloatingPointLE(const char* expr1,
-                                const char* expr2,
-                                RawType val1,
-                                RawType val2) {
-  // Returns success if val1 is less than val2,
-  if (val1 < val2) {
-    return AssertionSuccess();
-  }
-
-  // or if val1 is almost equal to val2.
-  const FloatingPoint<RawType> lhs(val1), rhs(val2);
-  if (lhs.AlmostEquals(rhs)) {
-    return AssertionSuccess();
-  }
-
-  // Note that the above two checks will both fail if either val1 or
-  // val2 is NaN, as the IEEE floating-point standard requires that
-  // any predicate involving a NaN must return false.
-
-  ::std::stringstream val1_ss;
-  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-          << val1;
-
-  ::std::stringstream val2_ss;
-  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-          << val2;
-
-  return AssertionFailure()
-      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
-      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
-      << StringStreamToString(&val2_ss);
-}
-
-}  // namespace internal
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-AssertionResult FloatLE(const char* expr1, const char* expr2,
-                        float val1, float val2) {
-  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
-}
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-AssertionResult DoubleLE(const char* expr1, const char* expr2,
-                         double val1, double val2) {
-  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
-}
-
-namespace internal {
-
-// The helper function for {ASSERT|EXPECT}_EQ with int or enum
-// arguments.
-AssertionResult CmpHelperEQ(const char* lhs_expression,
-                            const char* rhs_expression,
-                            BiggestInt lhs,
-                            BiggestInt rhs) {
-  if (lhs == rhs) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   FormatForComparisonFailureMessage(lhs, rhs),
-                   FormatForComparisonFailureMessage(rhs, lhs),
-                   false);
-}
-
-// A macro for implementing the helper functions needed to implement
-// ASSERT_?? and EXPECT_?? with integer or enum arguments.  It is here
-// just to avoid copy-and-paste of similar code.
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
-AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
-                                   BiggestInt val1, BiggestInt val2) {\
-  if (val1 op val2) {\
-    return AssertionSuccess();\
-  } else {\
-    return AssertionFailure() \
-        << "Expected: (" << expr1 << ") " #op " (" << expr2\
-        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
-        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
-  }\
-}
-
-// Implements the helper function for {ASSERT|EXPECT}_NE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(NE, !=)
-// Implements the helper function for {ASSERT|EXPECT}_LE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(LE, <=)
-// Implements the helper function for {ASSERT|EXPECT}_LT with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(LT, < )
-// Implements the helper function for {ASSERT|EXPECT}_GE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(GE, >=)
-// Implements the helper function for {ASSERT|EXPECT}_GT with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(GT, > )
-
-#undef GTEST_IMPL_CMP_HELPER_
-
-// The helper function for {ASSERT|EXPECT}_STREQ.
-AssertionResult CmpHelperSTREQ(const char* lhs_expression,
-                               const char* rhs_expression,
-                               const char* lhs,
-                               const char* rhs) {
-  if (String::CStringEquals(lhs, rhs)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   false);
-}
-
-// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
-AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
-                                   const char* rhs_expression,
-                                   const char* lhs,
-                                   const char* rhs) {
-  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   true);
-}
-
-// The helper function for {ASSERT|EXPECT}_STRNE.
-AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                               const char* s2_expression,
-                               const char* s1,
-                               const char* s2) {
-  if (!String::CStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  } else {
-    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
-                              << s2_expression << "), actual: \""
-                              << s1 << "\" vs \"" << s2 << "\"";
-  }
-}
-
-// The helper function for {ASSERT|EXPECT}_STRCASENE.
-AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
-                                   const char* s2_expression,
-                                   const char* s1,
-                                   const char* s2) {
-  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  } else {
-    return AssertionFailure()
-        << "Expected: (" << s1_expression << ") != ("
-        << s2_expression << ") (ignoring case), actual: \""
-        << s1 << "\" vs \"" << s2 << "\"";
-  }
-}
-
-}  // namespace internal
-
-namespace {
-
-// Helper functions for implementing IsSubString() and IsNotSubstring().
-
-// This group of overloaded functions return true iff needle is a
-// substring of haystack.  NULL is considered a substring of itself
-// only.
-
-bool IsSubstringPred(const char* needle, const char* haystack) {
-  if (needle == nullptr || haystack == nullptr) return needle == haystack;
-
-  return strstr(haystack, needle) != nullptr;
-}
-
-bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
-  if (needle == nullptr || haystack == nullptr) return needle == haystack;
-
-  return wcsstr(haystack, needle) != nullptr;
-}
-
-// StringType here can be either ::std::string or ::std::wstring.
-template <typename StringType>
-bool IsSubstringPred(const StringType& needle,
-                     const StringType& haystack) {
-  return haystack.find(needle) != StringType::npos;
-}
-
-// This function implements either IsSubstring() or IsNotSubstring(),
-// depending on the value of the expected_to_be_substring parameter.
-// StringType here can be const char*, const wchar_t*, ::std::string,
-// or ::std::wstring.
-template <typename StringType>
-AssertionResult IsSubstringImpl(
-    bool expected_to_be_substring,
-    const char* needle_expr, const char* haystack_expr,
-    const StringType& needle, const StringType& haystack) {
-  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
-    return AssertionSuccess();
-
-  const bool is_wide_string = sizeof(needle[0]) > 1;
-  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
-  return AssertionFailure()
-      << "Value of: " << needle_expr << "\n"
-      << "  Actual: " << begin_string_quote << needle << "\"\n"
-      << "Expected: " << (expected_to_be_substring ? "" : "not ")
-      << "a substring of " << haystack_expr << "\n"
-      << "Which is: " << begin_string_quote << haystack << "\"";
-}
-
-}  // namespace
-
-// IsSubstring() and IsNotSubstring() check whether needle is a
-// substring of haystack (NULL is considered a substring of itself
-// only), and return an appropriate error message when they fail.
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-#if GTEST_HAS_STD_WSTRING
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-namespace internal {
-
-#if GTEST_OS_WINDOWS
-
-namespace {
-
-// Helper function for IsHRESULT{SuccessFailure} predicates
-AssertionResult HRESULTFailureHelper(const char* expr,
-                                     const char* expected,
-                                     long hr) {  // NOLINT
-# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
-
-  // Windows CE doesn't support FormatMessage.
-  const char error_text[] = "";
-
-# else
-
-  // Looks up the human-readable system message for the HRESULT code
-  // and since we're not passing any params to FormatMessage, we don't
-  // want inserts expanded.
-  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
-                       FORMAT_MESSAGE_IGNORE_INSERTS;
-  const DWORD kBufSize = 4096;
-  // Gets the system's human readable message string for this HRESULT.
-  char error_text[kBufSize] = { '\0' };
-  DWORD message_length = ::FormatMessageA(kFlags,
-                                          0,   // no source, we're asking system
-                                          hr,  // the error
-                                          0,   // no line width restrictions
-                                          error_text,  // output buffer
-                                          kBufSize,    // buf size
-                                          nullptr);  // no arguments for inserts
-  // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
-  for (; message_length && IsSpace(error_text[message_length - 1]);
-          --message_length) {
-    error_text[message_length - 1] = '\0';
-  }
-
-# endif  // GTEST_OS_WINDOWS_MOBILE
-
-  const std::string error_hex("0x" + String::FormatHexInt(hr));
-  return ::testing::AssertionFailure()
-      << "Expected: " << expr << " " << expected << ".\n"
-      << "  Actual: " << error_hex << " " << error_text << "\n";
-}
-
-}  // namespace
-
-AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
-  if (SUCCEEDED(hr)) {
-    return AssertionSuccess();
-  }
-  return HRESULTFailureHelper(expr, "succeeds", hr);
-}
-
-AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
-  if (FAILED(hr)) {
-    return AssertionSuccess();
-  }
-  return HRESULTFailureHelper(expr, "fails", hr);
-}
-
-#endif  // GTEST_OS_WINDOWS
-
-// Utility functions for encoding Unicode text (wide strings) in
-// UTF-8.
-
-// A Unicode code-point can have up to 21 bits, and is encoded in UTF-8
-// like this:
-//
-// Code-point length   Encoding
-//   0 -  7 bits       0xxxxxxx
-//   8 - 11 bits       110xxxxx 10xxxxxx
-//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
-//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-
-// The maximum code-point a one-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) <<  7) - 1;
-
-// The maximum code-point a two-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
-
-// The maximum code-point a three-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
-
-// The maximum code-point a four-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1;
-
-// Chops off the n lowest bits from a bit pattern.  Returns the n
-// lowest bits.  As a side effect, the original bit pattern will be
-// shifted to the right by n bits.
-inline UInt32 ChopLowBits(UInt32* bits, int n) {
-  const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1);
-  *bits >>= n;
-  return low_bits;
-}
-
-// Converts a Unicode code point to a narrow string in UTF-8 encoding.
-// code_point parameter is of type UInt32 because wchar_t may not be
-// wide enough to contain a code point.
-// If the code_point is not a valid Unicode code point
-// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
-// to "(Invalid Unicode 0xXXXXXXXX)".
-std::string CodePointToUtf8(UInt32 code_point) {
-  if (code_point > kMaxCodePoint4) {
-    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
-  }
-
-  char str[5];  // Big enough for the largest valid code point.
-  if (code_point <= kMaxCodePoint1) {
-    str[1] = '\0';
-    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
-  } else if (code_point <= kMaxCodePoint2) {
-    str[2] = '\0';
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
-  } else if (code_point <= kMaxCodePoint3) {
-    str[3] = '\0';
-    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
-  } else {  // code_point <= kMaxCodePoint4
-    str[4] = '\0';
-    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
-  }
-  return str;
-}
-
-// The following two functions only make sense if the system
-// uses UTF-16 for wide string encoding. All supported systems
-// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.
-
-// Determines if the arguments constitute UTF-16 surrogate pair
-// and thus should be combined into a single Unicode code point
-// using CreateCodePointFromUtf16SurrogatePair.
-inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
-  return sizeof(wchar_t) == 2 &&
-      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
-}
-
-// Creates a Unicode code point from UTF16 surrogate pair.
-inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
-                                                    wchar_t second) {
-  const UInt32 mask = (1 << 10) - 1;
-  return (sizeof(wchar_t) == 2) ?
-      (((first & mask) << 10) | (second & mask)) + 0x10000 :
-      // This function should not be called when the condition is
-      // false, but we provide a sensible default in case it is.
-      static_cast<UInt32>(first);
-}
-
-// Converts a wide string to a narrow string in UTF-8 encoding.
-// The wide string is assumed to have the following encoding:
-//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
-//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
-// Parameter str points to a null-terminated wide string.
-// Parameter num_chars may additionally limit the number
-// of wchar_t characters processed. -1 is used when the entire string
-// should be processed.
-// If the string contains code points that are not valid Unicode code points
-// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
-// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
-// and contains invalid UTF-16 surrogate pairs, values in those pairs
-// will be encoded as individual Unicode characters from Basic Normal Plane.
-std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
-  if (num_chars == -1)
-    num_chars = static_cast<int>(wcslen(str));
-
-  ::std::stringstream stream;
-  for (int i = 0; i < num_chars; ++i) {
-    UInt32 unicode_code_point;
-
-    if (str[i] == L'\0') {
-      break;
-    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
-      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
-                                                                 str[i + 1]);
-      i++;
-    } else {
-      unicode_code_point = static_cast<UInt32>(str[i]);
-    }
-
-    stream << CodePointToUtf8(unicode_code_point);
-  }
-  return StringStreamToString(&stream);
-}
-
-// Converts a wide C string to an std::string using the UTF-8 encoding.
-// NULL will be converted to "(null)".
-std::string String::ShowWideCString(const wchar_t * wide_c_str) {
-  if (wide_c_str == nullptr) return "(null)";
-
-  return internal::WideStringToUtf8(wide_c_str, -1);
-}
-
-// Compares two wide C strings.  Returns true iff they have the same
-// content.
-//
-// Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
-// C string is considered different to any non-NULL C string,
-// including the empty string.
-bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
-  if (lhs == nullptr) return rhs == nullptr;
-
-  if (rhs == nullptr) return false;
-
-  return wcscmp(lhs, rhs) == 0;
-}
-
-// Helper function for *_STREQ on wide strings.
-AssertionResult CmpHelperSTREQ(const char* lhs_expression,
-                               const char* rhs_expression,
-                               const wchar_t* lhs,
-                               const wchar_t* rhs) {
-  if (String::WideCStringEquals(lhs, rhs)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   false);
-}
-
-// Helper function for *_STRNE on wide strings.
-AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                               const char* s2_expression,
-                               const wchar_t* s1,
-                               const wchar_t* s2) {
-  if (!String::WideCStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  }
-
-  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
-                            << s2_expression << "), actual: "
-                            << PrintToString(s1)
-                            << " vs " << PrintToString(s2);
-}
-
-// Compares two C strings, ignoring case.  Returns true iff they have
-// the same content.
-//
-// Unlike strcasecmp(), this function can handle NULL argument(s).  A
-// NULL C string is considered different to any non-NULL C string,
-// including the empty string.
-bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
-  if (lhs == nullptr) return rhs == nullptr;
-  if (rhs == nullptr) return false;
-  return posix::StrCaseCmp(lhs, rhs) == 0;
-}
-
-  // Compares two wide C strings, ignoring case.  Returns true iff they
-  // have the same content.
-  //
-  // Unlike wcscasecmp(), this function can handle NULL argument(s).
-  // A NULL C string is considered different to any non-NULL wide C string,
-  // including the empty string.
-  // NB: The implementations on different platforms slightly differ.
-  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
-  // environment variable. On GNU platform this method uses wcscasecmp
-  // which compares according to LC_CTYPE category of the current locale.
-  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
-  // current locale.
-bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
-                                              const wchar_t* rhs) {
-  if (lhs == nullptr) return rhs == nullptr;
-
-  if (rhs == nullptr) return false;
-
-#if GTEST_OS_WINDOWS
-  return _wcsicmp(lhs, rhs) == 0;
-#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
-  return wcscasecmp(lhs, rhs) == 0;
-#else
-  // Android, Mac OS X and Cygwin don't define wcscasecmp.
-  // Other unknown OSes may not define it either.
-  wint_t left, right;
-  do {
-    left = towlower(*lhs++);
-    right = towlower(*rhs++);
-  } while (left && left == right);
-  return left == right;
-#endif  // OS selector
-}
-
-// Returns true iff str ends with the given suffix, ignoring case.
-// Any string is considered to end with an empty suffix.
-bool String::EndsWithCaseInsensitive(
-    const std::string& str, const std::string& suffix) {
-  const size_t str_len = str.length();
-  const size_t suffix_len = suffix.length();
-  return (str_len >= suffix_len) &&
-         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
-                                      suffix.c_str());
-}
-
-// Formats an int value as "%02d".
-std::string String::FormatIntWidth2(int value) {
-  std::stringstream ss;
-  ss << std::setfill('0') << std::setw(2) << value;
-  return ss.str();
-}
-
-// Formats an int value as "%X".
-std::string String::FormatHexInt(int value) {
-  std::stringstream ss;
-  ss << std::hex << std::uppercase << value;
-  return ss.str();
-}
-
-// Formats a byte as "%02X".
-std::string String::FormatByte(unsigned char value) {
-  std::stringstream ss;
-  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
-     << static_cast<unsigned int>(value);
-  return ss.str();
-}
-
-// Converts the buffer in a stringstream to an std::string, converting NUL
-// bytes to "\\0" along the way.
-std::string StringStreamToString(::std::stringstream* ss) {
-  const ::std::string& str = ss->str();
-  const char* const start = str.c_str();
-  const char* const end = start + str.length();
-
-  std::string result;
-  result.reserve(2 * (end - start));
-  for (const char* ch = start; ch != end; ++ch) {
-    if (*ch == '\0') {
-      result += "\\0";  // Replaces NUL with "\\0";
-    } else {
-      result += *ch;
-    }
-  }
-
-  return result;
-}
-
-// Appends the user-supplied message to the Google-Test-generated message.
-std::string AppendUserMessage(const std::string& gtest_msg,
-                              const Message& user_msg) {
-  // Appends the user message if it's non-empty.
-  const std::string user_msg_string = user_msg.GetString();
-  if (user_msg_string.empty()) {
-    return gtest_msg;
-  }
-
-  return gtest_msg + "\n" + user_msg_string;
-}
-
-}  // namespace internal
-
-// class TestResult
-
-// Creates an empty TestResult.
-TestResult::TestResult()
-    : death_test_count_(0),
-      elapsed_time_(0) {
-}
-
-// D'tor.
-TestResult::~TestResult() {
-}
-
-// Returns the i-th test part result among all the results. i can
-// range from 0 to total_part_count() - 1. If i is not in that range,
-// aborts the program.
-const TestPartResult& TestResult::GetTestPartResult(int i) const {
-  if (i < 0 || i >= total_part_count())
-    internal::posix::Abort();
-  return test_part_results_.at(i);
-}
-
-// Returns the i-th test property. i can range from 0 to
-// test_property_count() - 1. If i is not in that range, aborts the
-// program.
-const TestProperty& TestResult::GetTestProperty(int i) const {
-  if (i < 0 || i >= test_property_count())
-    internal::posix::Abort();
-  return test_properties_.at(i);
-}
-
-// Clears the test part results.
-void TestResult::ClearTestPartResults() {
-  test_part_results_.clear();
-}
-
-// Adds a test part result to the list.
-void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
-  test_part_results_.push_back(test_part_result);
-}
-
-// Adds a test property to the list. If a property with the same key as the
-// supplied property is already represented, the value of this test_property
-// replaces the old value for that key.
-void TestResult::RecordProperty(const std::string& xml_element,
-                                const TestProperty& test_property) {
-  if (!ValidateTestProperty(xml_element, test_property)) {
-    return;
-  }
-  internal::MutexLock lock(&test_properites_mutex_);
-  const std::vector<TestProperty>::iterator property_with_matching_key =
-      std::find_if(test_properties_.begin(), test_properties_.end(),
-                   internal::TestPropertyKeyIs(test_property.key()));
-  if (property_with_matching_key == test_properties_.end()) {
-    test_properties_.push_back(test_property);
-    return;
-  }
-  property_with_matching_key->SetValue(test_property.value());
-}
-
-// The list of reserved attributes used in the <testsuites> element of XML
-// output.
-static const char* const kReservedTestSuitesAttributes[] = {
-  "disabled",
-  "errors",
-  "failures",
-  "name",
-  "random_seed",
-  "tests",
-  "time",
-  "timestamp"
-};
-
-// The list of reserved attributes used in the <testsuite> element of XML
-// output.
-static const char* const kReservedTestSuiteAttributes[] = {
-  "disabled",
-  "errors",
-  "failures",
-  "name",
-  "tests",
-  "time"
-};
-
-// The list of reserved attributes used in the <testcase> element of XML output.
-static const char* const kReservedTestCaseAttributes[] = {
-    "classname",   "name", "status", "time",  "type_param",
-    "value_param", "file", "line"};
-
-// Use a slightly different set for allowed output to ensure existing tests can
-// still RecordProperty("result")
-static const char* const kReservedOutputTestCaseAttributes[] = {
-    "classname",   "name", "status", "time",  "type_param",
-    "value_param", "file", "line", "result"};
-
-template <int kSize>
-std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
-  return std::vector<std::string>(array, array + kSize);
-}
-
-static std::vector<std::string> GetReservedAttributesForElement(
-    const std::string& xml_element) {
-  if (xml_element == "testsuites") {
-    return ArrayAsVector(kReservedTestSuitesAttributes);
-  } else if (xml_element == "testsuite") {
-    return ArrayAsVector(kReservedTestSuiteAttributes);
-  } else if (xml_element == "testcase") {
-    return ArrayAsVector(kReservedTestCaseAttributes);
-  } else {
-    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
-  }
-  // This code is unreachable but some compilers may not realizes that.
-  return std::vector<std::string>();
-}
-
-// TODO(jdesprez): Merge the two getReserved attributes once skip is improved
-static std::vector<std::string> GetReservedOutputAttributesForElement(
-    const std::string& xml_element) {
-  if (xml_element == "testsuites") {
-    return ArrayAsVector(kReservedTestSuitesAttributes);
-  } else if (xml_element == "testsuite") {
-    return ArrayAsVector(kReservedTestSuiteAttributes);
-  } else if (xml_element == "testcase") {
-    return ArrayAsVector(kReservedOutputTestCaseAttributes);
-  } else {
-    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
-  }
-  // This code is unreachable but some compilers may not realizes that.
-  return std::vector<std::string>();
-}
-
-static std::string FormatWordList(const std::vector<std::string>& words) {
-  Message word_list;
-  for (size_t i = 0; i < words.size(); ++i) {
-    if (i > 0 && words.size() > 2) {
-      word_list << ", ";
-    }
-    if (i == words.size() - 1) {
-      word_list << "and ";
-    }
-    word_list << "'" << words[i] << "'";
-  }
-  return word_list.GetString();
-}
-
-static bool ValidateTestPropertyName(
-    const std::string& property_name,
-    const std::vector<std::string>& reserved_names) {
-  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
-          reserved_names.end()) {
-    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
-                  << " (" << FormatWordList(reserved_names)
-                  << " are reserved by " << GTEST_NAME_ << ")";
-    return false;
-  }
-  return true;
-}
-
-// Adds a failure if the key is a reserved attribute of the element named
-// xml_element.  Returns true if the property is valid.
-bool TestResult::ValidateTestProperty(const std::string& xml_element,
-                                      const TestProperty& test_property) {
-  return ValidateTestPropertyName(test_property.key(),
-                                  GetReservedAttributesForElement(xml_element));
-}
-
-// Clears the object.
-void TestResult::Clear() {
-  test_part_results_.clear();
-  test_properties_.clear();
-  death_test_count_ = 0;
-  elapsed_time_ = 0;
-}
-
-// Returns true off the test part was skipped.
-static bool TestPartSkipped(const TestPartResult& result) {
-  return result.skipped();
-}
-
-// Returns true iff the test was skipped.
-bool TestResult::Skipped() const {
-  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
-}
-
-// Returns true iff the test failed.
-bool TestResult::Failed() const {
-  for (int i = 0; i < total_part_count(); ++i) {
-    if (GetTestPartResult(i).failed())
-      return true;
-  }
-  return false;
-}
-
-// Returns true iff the test part fatally failed.
-static bool TestPartFatallyFailed(const TestPartResult& result) {
-  return result.fatally_failed();
-}
-
-// Returns true iff the test fatally failed.
-bool TestResult::HasFatalFailure() const {
-  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
-}
-
-// Returns true iff the test part non-fatally failed.
-static bool TestPartNonfatallyFailed(const TestPartResult& result) {
-  return result.nonfatally_failed();
-}
-
-// Returns true iff the test has a non-fatal failure.
-bool TestResult::HasNonfatalFailure() const {
-  return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
-}
-
-// Gets the number of all test parts.  This is the sum of the number
-// of successful test parts and the number of failed test parts.
-int TestResult::total_part_count() const {
-  return static_cast<int>(test_part_results_.size());
-}
-
-// Returns the number of the test properties.
-int TestResult::test_property_count() const {
-  return static_cast<int>(test_properties_.size());
-}
-
-// class Test
-
-// Creates a Test object.
-
-// The c'tor saves the states of all flags.
-Test::Test()
-    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
-}
-
-// The d'tor restores the states of all flags.  The actual work is
-// done by the d'tor of the gtest_flag_saver_ field, and thus not
-// visible here.
-Test::~Test() {
-}
-
-// Sets up the test fixture.
-//
-// A sub-class may override this.
-void Test::SetUp() {
-}
-
-// Tears down the test fixture.
-//
-// A sub-class may override this.
-void Test::TearDown() {
-}
-
-// Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const std::string& key, const std::string& value) {
-  UnitTest::GetInstance()->RecordProperty(key, value);
-}
-
-// Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const std::string& key, int value) {
-  Message value_message;
-  value_message << value;
-  RecordProperty(key, value_message.GetString().c_str());
-}
-
-namespace internal {
-
-void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
-                                    const std::string& message) {
-  // This function is a friend of UnitTest and as such has access to
-  // AddTestPartResult.
-  UnitTest::GetInstance()->AddTestPartResult(
-      result_type,
-      nullptr,  // No info about the source file where the exception occurred.
-      -1,       // We have no info on which line caused the exception.
-      message,
-      "");  // No stack trace, either.
-}
-
-}  // namespace internal
-
-// Google Test requires all tests in the same test suite to use the same test
-// fixture class.  This function checks if the current test has the
-// same fixture class as the first test in the current test suite.  If
-// yes, it returns true; otherwise it generates a Google Test failure and
-// returns false.
-bool Test::HasSameFixtureClass() {
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  const TestSuite* const test_suite = impl->current_test_suite();
-
-  // Info about the first test in the current test suite.
-  const TestInfo* const first_test_info = test_suite->test_info_list()[0];
-  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
-  const char* const first_test_name = first_test_info->name();
-
-  // Info about the current test.
-  const TestInfo* const this_test_info = impl->current_test_info();
-  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
-  const char* const this_test_name = this_test_info->name();
-
-  if (this_fixture_id != first_fixture_id) {
-    // Is the first test defined using TEST?
-    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
-    // Is this test defined using TEST?
-    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
-
-    if (first_is_TEST || this_is_TEST) {
-      // Both TEST and TEST_F appear in same test suite, which is incorrect.
-      // Tell the user how to fix this.
-
-      // Gets the name of the TEST and the name of the TEST_F.  Note
-      // that first_is_TEST and this_is_TEST cannot both be true, as
-      // the fixture IDs are different for the two tests.
-      const char* const TEST_name =
-          first_is_TEST ? first_test_name : this_test_name;
-      const char* const TEST_F_name =
-          first_is_TEST ? this_test_name : first_test_name;
-
-      ADD_FAILURE()
-          << "All tests in the same test suite must use the same test fixture\n"
-          << "class, so mixing TEST_F and TEST in the same test suite is\n"
-          << "illegal.  In test suite " << this_test_info->test_suite_name()
-          << ",\n"
-          << "test " << TEST_F_name << " is defined using TEST_F but\n"
-          << "test " << TEST_name << " is defined using TEST.  You probably\n"
-          << "want to change the TEST to TEST_F or move it to another test\n"
-          << "case.";
-    } else {
-      // Two fixture classes with the same name appear in two different
-      // namespaces, which is not allowed. Tell the user how to fix this.
-      ADD_FAILURE()
-          << "All tests in the same test suite must use the same test fixture\n"
-          << "class.  However, in test suite "
-          << this_test_info->test_suite_name() << ",\n"
-          << "you defined test " << first_test_name << " and test "
-          << this_test_name << "\n"
-          << "using two different test fixture classes.  This can happen if\n"
-          << "the two classes are from different namespaces or translation\n"
-          << "units and have the same name.  You should probably rename one\n"
-          << "of the classes to put the tests into different test suites.";
-    }
-    return false;
-  }
-
-  return true;
-}
-
-#if GTEST_HAS_SEH
-
-// Adds an "exception thrown" fatal failure to the current test.  This
-// function returns its result via an output parameter pointer because VC++
-// prohibits creation of objects with destructors on stack in functions
-// using __try (see error C2712).
-static std::string* FormatSehExceptionMessage(DWORD exception_code,
-                                              const char* location) {
-  Message message;
-  message << "SEH exception with code 0x" << std::setbase(16) <<
-    exception_code << std::setbase(10) << " thrown in " << location << ".";
-
-  return new std::string(message.GetString());
-}
-
-#endif  // GTEST_HAS_SEH
-
-namespace internal {
-
-#if GTEST_HAS_EXCEPTIONS
-
-// Adds an "exception thrown" fatal failure to the current test.
-static std::string FormatCxxExceptionMessage(const char* description,
-                                             const char* location) {
-  Message message;
-  if (description != nullptr) {
-    message << "C++ exception with description \"" << description << "\"";
-  } else {
-    message << "Unknown C++ exception";
-  }
-  message << " thrown in " << location << ".";
-
-  return message.GetString();
-}
-
-static std::string PrintTestPartResultToString(
-    const TestPartResult& test_part_result);
-
-GoogleTestFailureException::GoogleTestFailureException(
-    const TestPartResult& failure)
-    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// We put these helper functions in the internal namespace as IBM's xlC
-// compiler rejects the code if they were declared static.
-
-// Runs the given method and handles SEH exceptions it throws, when
-// SEH is supported; returns the 0-value for type Result in case of an
-// SEH exception.  (Microsoft compilers cannot handle SEH and C++
-// exceptions in the same function.  Therefore, we provide a separate
-// wrapper function for handling SEH exceptions.)
-template <class T, typename Result>
-Result HandleSehExceptionsInMethodIfSupported(
-    T* object, Result (T::*method)(), const char* location) {
-#if GTEST_HAS_SEH
-  __try {
-    return (object->*method)();
-  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
-      GetExceptionCode())) {
-    // We create the exception message on the heap because VC++ prohibits
-    // creation of objects with destructors on stack in functions using __try
-    // (see error C2712).
-    std::string* exception_message = FormatSehExceptionMessage(
-        GetExceptionCode(), location);
-    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
-                                             *exception_message);
-    delete exception_message;
-    return static_cast<Result>(0);
-  }
-#else
-  (void)location;
-  return (object->*method)();
-#endif  // GTEST_HAS_SEH
-}
-
-// Runs the given method and catches and reports C++ and/or SEH-style
-// exceptions, if they are supported; returns the 0-value for type
-// Result in case of an SEH exception.
-template <class T, typename Result>
-Result HandleExceptionsInMethodIfSupported(
-    T* object, Result (T::*method)(), const char* location) {
-  // NOTE: The user code can affect the way in which Google Test handles
-  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
-  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
-  // after the exception is caught and either report or re-throw the
-  // exception based on the flag's value:
-  //
-  // try {
-  //   // Perform the test method.
-  // } catch (...) {
-  //   if (GTEST_FLAG(catch_exceptions))
-  //     // Report the exception as failure.
-  //   else
-  //     throw;  // Re-throws the original exception.
-  // }
-  //
-  // However, the purpose of this flag is to allow the program to drop into
-  // the debugger when the exception is thrown. On most platforms, once the
-  // control enters the catch block, the exception origin information is
-  // lost and the debugger will stop the program at the point of the
-  // re-throw in this function -- instead of at the point of the original
-  // throw statement in the code under test.  For this reason, we perform
-  // the check early, sacrificing the ability to affect Google Test's
-  // exception handling in the method where the exception is thrown.
-  if (internal::GetUnitTestImpl()->catch_exceptions()) {
-#if GTEST_HAS_EXCEPTIONS
-    try {
-      return HandleSehExceptionsInMethodIfSupported(object, method, location);
-    } catch (const AssertionException&) {  // NOLINT
-      // This failure was reported already.
-    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
-      // This exception type can only be thrown by a failed Google
-      // Test assertion with the intention of letting another testing
-      // framework catch it.  Therefore we just re-throw it.
-      throw;
-    } catch (const std::exception& e) {  // NOLINT
-      internal::ReportFailureInUnknownLocation(
-          TestPartResult::kFatalFailure,
-          FormatCxxExceptionMessage(e.what(), location));
-    } catch (...) {  // NOLINT
-      internal::ReportFailureInUnknownLocation(
-          TestPartResult::kFatalFailure,
-          FormatCxxExceptionMessage(nullptr, location));
-    }
-    return static_cast<Result>(0);
-#else
-    return HandleSehExceptionsInMethodIfSupported(object, method, location);
-#endif  // GTEST_HAS_EXCEPTIONS
-  } else {
-    return (object->*method)();
-  }
-}
-
-}  // namespace internal
-
-// Runs the test and updates the test result.
-void Test::Run() {
-  if (!HasSameFixtureClass()) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
-  // We will run the test only if SetUp() was successful and didn't call
-  // GTEST_SKIP().
-  if (!HasFatalFailure() && !IsSkipped()) {
-    impl->os_stack_trace_getter()->UponLeavingGTest();
-    internal::HandleExceptionsInMethodIfSupported(
-        this, &Test::TestBody, "the test body");
-  }
-
-  // However, we want to clean up as much as possible.  Hence we will
-  // always call TearDown(), even if SetUp() or the test body has
-  // failed.
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &Test::TearDown, "TearDown()");
-}
-
-// Returns true iff the current test has a fatal failure.
-bool Test::HasFatalFailure() {
-  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
-}
-
-// Returns true iff the current test has a non-fatal failure.
-bool Test::HasNonfatalFailure() {
-  return internal::GetUnitTestImpl()->current_test_result()->
-      HasNonfatalFailure();
-}
-
-// Returns true iff the current test was skipped.
-bool Test::IsSkipped() {
-  return internal::GetUnitTestImpl()->current_test_result()->Skipped();
-}
-
-// class TestInfo
-
-// Constructs a TestInfo object. It assumes ownership of the test factory
-// object.
-TestInfo::TestInfo(const std::string& a_test_suite_name,
-                   const std::string& a_name, const char* a_type_param,
-                   const char* a_value_param,
-                   internal::CodeLocation a_code_location,
-                   internal::TypeId fixture_class_id,
-                   internal::TestFactoryBase* factory)
-    : test_suite_name_(a_test_suite_name),
-      name_(a_name),
-      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
-      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
-      location_(a_code_location),
-      fixture_class_id_(fixture_class_id),
-      should_run_(false),
-      is_disabled_(false),
-      matches_filter_(false),
-      factory_(factory),
-      result_() {}
-
-// Destructs a TestInfo object.
-TestInfo::~TestInfo() { delete factory_; }
-
-namespace internal {
-
-// Creates a new TestInfo object and registers it with Google Test;
-// returns the created object.
-//
-// Arguments:
-//
-//   test_suite_name:   name of the test suite
-//   name:             name of the test
-//   type_param:       the name of the test's type parameter, or NULL if
-//                     this is not a typed or a type-parameterized test.
-//   value_param:      text representation of the test's value parameter,
-//                     or NULL if this is not a value-parameterized test.
-//   code_location:    code location where the test is defined
-//   fixture_class_id: ID of the test fixture class
-//   set_up_tc:        pointer to the function that sets up the test suite
-//   tear_down_tc:     pointer to the function that tears down the test suite
-//   factory:          pointer to the factory that creates a test object.
-//                     The newly created TestInfo instance will assume
-//                     ownership of the factory object.
-TestInfo* MakeAndRegisterTestInfo(
-    const char* test_suite_name, const char* name, const char* type_param,
-    const char* value_param, CodeLocation code_location,
-    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
-    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
-  TestInfo* const test_info =
-      new TestInfo(test_suite_name, name, type_param, value_param,
-                   code_location, fixture_class_id, factory);
-  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
-  return test_info;
-}
-
-void ReportInvalidTestSuiteType(const char* test_suite_name,
-                                CodeLocation code_location) {
-  Message errors;
-  errors
-      << "Attempted redefinition of test suite " << test_suite_name << ".\n"
-      << "All tests in the same test suite must use the same test fixture\n"
-      << "class.  However, in test suite " << test_suite_name << ", you tried\n"
-      << "to define a test using a fixture class different from the one\n"
-      << "used earlier. This can happen if the two fixture classes are\n"
-      << "from different namespaces and have the same name. You should\n"
-      << "probably rename one of the classes to put the tests into different\n"
-      << "test suites.";
-
-  GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
-                                          code_location.line)
-                    << " " << errors.GetString();
-}
-}  // namespace internal
-
-namespace {
-
-// A predicate that checks the test name of a TestInfo against a known
-// value.
-//
-// This is used for implementation of the TestSuite class only.  We put
-// it in the anonymous namespace to prevent polluting the outer
-// namespace.
-//
-// TestNameIs is copyable.
-class TestNameIs {
- public:
-  // Constructor.
-  //
-  // TestNameIs has NO default constructor.
-  explicit TestNameIs(const char* name)
-      : name_(name) {}
-
-  // Returns true iff the test name of test_info matches name_.
-  bool operator()(const TestInfo * test_info) const {
-    return test_info && test_info->name() == name_;
-  }
-
- private:
-  std::string name_;
-};
-
-}  // namespace
-
-namespace internal {
-
-// This method expands all parameterized tests registered with macros TEST_P
-// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
-// This will be done just once during the program runtime.
-void UnitTestImpl::RegisterParameterizedTests() {
-  if (!parameterized_tests_registered_) {
-    parameterized_test_registry_.RegisterTests();
-    parameterized_tests_registered_ = true;
-  }
-}
-
-}  // namespace internal
-
-// Creates the test object, runs it, records its result, and then
-// deletes it.
-void TestInfo::Run() {
-  if (!should_run_) return;
-
-  // Tells UnitTest where to store test result.
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_info(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  // Notifies the unit test event listeners that a test is about to start.
-  repeater->OnTestStart(*this);
-
-  const TimeInMillis start = internal::GetTimeInMillis();
-
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-
-  // Creates the test object.
-  Test* const test = internal::HandleExceptionsInMethodIfSupported(
-      factory_, &internal::TestFactoryBase::CreateTest,
-      "the test fixture's constructor");
-
-  // Runs the test if the constructor didn't generate a fatal failure or invoke
-  // GTEST_SKIP().
-  // Note that the object will not be null
-  if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
-    // This doesn't throw as all user code that can throw are wrapped into
-    // exception handling code.
-    test->Run();
-  }
-
-  if (test != nullptr) {
-    // Deletes the test object.
-    impl->os_stack_trace_getter()->UponLeavingGTest();
-    internal::HandleExceptionsInMethodIfSupported(
-        test, &Test::DeleteSelf_, "the test fixture's destructor");
-  }
-
-  result_.set_elapsed_time(internal::GetTimeInMillis() - start);
-
-  // Notifies the unit test event listener that a test has just finished.
-  repeater->OnTestEnd(*this);
-
-  // Tells UnitTest to stop associating assertion results to this
-  // test.
-  impl->set_current_test_info(nullptr);
-}
-
-// class TestSuite
-
-// Gets the number of successful tests in this test suite.
-int TestSuite::successful_test_count() const {
-  return CountIf(test_info_list_, TestPassed);
-}
-
-// Gets the number of successful tests in this test suite.
-int TestSuite::skipped_test_count() const {
-  return CountIf(test_info_list_, TestSkipped);
-}
-
-// Gets the number of failed tests in this test suite.
-int TestSuite::failed_test_count() const {
-  return CountIf(test_info_list_, TestFailed);
-}
-
-// Gets the number of disabled tests that will be reported in the XML report.
-int TestSuite::reportable_disabled_test_count() const {
-  return CountIf(test_info_list_, TestReportableDisabled);
-}
-
-// Gets the number of disabled tests in this test suite.
-int TestSuite::disabled_test_count() const {
-  return CountIf(test_info_list_, TestDisabled);
-}
-
-// Gets the number of tests to be printed in the XML report.
-int TestSuite::reportable_test_count() const {
-  return CountIf(test_info_list_, TestReportable);
-}
-
-// Get the number of tests in this test suite that should run.
-int TestSuite::test_to_run_count() const {
-  return CountIf(test_info_list_, ShouldRunTest);
-}
-
-// Gets the number of all tests.
-int TestSuite::total_test_count() const {
-  return static_cast<int>(test_info_list_.size());
-}
-
-// Creates a TestSuite with the given name.
-//
-// Arguments:
-//
-//   name:         name of the test suite
-//   a_type_param: the name of the test suite's type parameter, or NULL if
-//                 this is not a typed or a type-parameterized test suite.
-//   set_up_tc:    pointer to the function that sets up the test suite
-//   tear_down_tc: pointer to the function that tears down the test suite
-TestSuite::TestSuite(const char* a_name, const char* a_type_param,
-                     internal::SetUpTestSuiteFunc set_up_tc,
-                     internal::TearDownTestSuiteFunc tear_down_tc)
-    : name_(a_name),
-      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
-      set_up_tc_(set_up_tc),
-      tear_down_tc_(tear_down_tc),
-      should_run_(false),
-      elapsed_time_(0) {}
-
-// Destructor of TestSuite.
-TestSuite::~TestSuite() {
-  // Deletes every Test in the collection.
-  ForEach(test_info_list_, internal::Delete<TestInfo>);
-}
-
-// Returns the i-th test among all the tests. i can range from 0 to
-// total_test_count() - 1. If i is not in that range, returns NULL.
-const TestInfo* TestSuite::GetTestInfo(int i) const {
-  const int index = GetElementOr(test_indices_, i, -1);
-  return index < 0 ? nullptr : test_info_list_[index];
-}
-
-// Returns the i-th test among all the tests. i can range from 0 to
-// total_test_count() - 1. If i is not in that range, returns NULL.
-TestInfo* TestSuite::GetMutableTestInfo(int i) {
-  const int index = GetElementOr(test_indices_, i, -1);
-  return index < 0 ? nullptr : test_info_list_[index];
-}
-
-// Adds a test to this test suite.  Will delete the test upon
-// destruction of the TestSuite object.
-void TestSuite::AddTestInfo(TestInfo* test_info) {
-  test_info_list_.push_back(test_info);
-  test_indices_.push_back(static_cast<int>(test_indices_.size()));
-}
-
-// Runs every test in this TestSuite.
-void TestSuite::Run() {
-  if (!should_run_) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_suite(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  // Call both legacy and the new API
-  repeater->OnTestSuiteStart(*this);
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
-  repeater->OnTestCaseStart(*this);
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI
-
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
-
-  const internal::TimeInMillis start = internal::GetTimeInMillis();
-  for (int i = 0; i < total_test_count(); i++) {
-    GetMutableTestInfo(i)->Run();
-  }
-  elapsed_time_ = internal::GetTimeInMillis() - start;
-
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
-
-  // Call both legacy and the new API
-  repeater->OnTestSuiteEnd(*this);
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
-  repeater->OnTestCaseEnd(*this);
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI
-
-  impl->set_current_test_suite(nullptr);
-}
-
-// Clears the results of all tests in this test suite.
-void TestSuite::ClearResult() {
-  ad_hoc_test_result_.Clear();
-  ForEach(test_info_list_, TestInfo::ClearTestResult);
-}
-
-// Shuffles the tests in this test suite.
-void TestSuite::ShuffleTests(internal::Random* random) {
-  Shuffle(random, &test_indices_);
-}
-
-// Restores the test order to before the first shuffle.
-void TestSuite::UnshuffleTests() {
-  for (size_t i = 0; i < test_indices_.size(); i++) {
-    test_indices_[i] = static_cast<int>(i);
-  }
-}
-
-// Formats a countable noun.  Depending on its quantity, either the
-// singular form or the plural form is used. e.g.
-//
-// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
-// FormatCountableNoun(5, "book", "books") returns "5 books".
-static std::string FormatCountableNoun(int count,
-                                       const char * singular_form,
-                                       const char * plural_form) {
-  return internal::StreamableToString(count) + " " +
-      (count == 1 ? singular_form : plural_form);
-}
-
-// Formats the count of tests.
-static std::string FormatTestCount(int test_count) {
-  return FormatCountableNoun(test_count, "test", "tests");
-}
-
-// Formats the count of test suites.
-static std::string FormatTestSuiteCount(int test_suite_count) {
-  return FormatCountableNoun(test_suite_count, "test suite", "test suites");
-}
-
-// Converts a TestPartResult::Type enum to human-friendly string
-// representation.  Both kNonFatalFailure and kFatalFailure are translated
-// to "Failure", as the user usually doesn't care about the difference
-// between the two when viewing the test result.
-static const char * TestPartResultTypeToString(TestPartResult::Type type) {
-  switch (type) {
-    case TestPartResult::kSkip:
-      return "Skipped";
-    case TestPartResult::kSuccess:
-      return "Success";
-
-    case TestPartResult::kNonFatalFailure:
-    case TestPartResult::kFatalFailure:
-#ifdef _MSC_VER
-      return "error: ";
-#else
-      return "Failure\n";
-#endif
-    default:
-      return "Unknown result type";
-  }
-}
-
-namespace internal {
-
-// Prints a TestPartResult to an std::string.
-static std::string PrintTestPartResultToString(
-    const TestPartResult& test_part_result) {
-  return (Message()
-          << internal::FormatFileLocation(test_part_result.file_name(),
-                                          test_part_result.line_number())
-          << " " << TestPartResultTypeToString(test_part_result.type())
-          << test_part_result.message()).GetString();
-}
-
-// Prints a TestPartResult.
-static void PrintTestPartResult(const TestPartResult& test_part_result) {
-  const std::string& result =
-      PrintTestPartResultToString(test_part_result);
-  printf("%s\n", result.c_str());
-  fflush(stdout);
-  // If the test program runs in Visual Studio or a debugger, the
-  // following statements add the test part result message to the Output
-  // window such that the user can double-click on it to jump to the
-  // corresponding source code location; otherwise they do nothing.
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-  // We don't call OutputDebugString*() on Windows Mobile, as printing
-  // to stdout is done by OutputDebugString() there already - we don't
-  // want the same message printed twice.
-  ::OutputDebugStringA(result.c_str());
-  ::OutputDebugStringA("\n");
-#endif
-}
-
-// class PrettyUnitTestResultPrinter
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
-
-// Returns the character attribute for the given color.
-static WORD GetColorAttribute(GTestColor color) {
-  switch (color) {
-    case COLOR_RED:    return FOREGROUND_RED;
-    case COLOR_GREEN:  return FOREGROUND_GREEN;
-    case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
-    default:           return 0;
-  }
-}
-
-static int GetBitOffset(WORD color_mask) {
-  if (color_mask == 0) return 0;
-
-  int bitOffset = 0;
-  while ((color_mask & 1) == 0) {
-    color_mask >>= 1;
-    ++bitOffset;
-  }
-  return bitOffset;
-}
-
-static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
-  // Let's reuse the BG
-  static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
-                                      BACKGROUND_RED | BACKGROUND_INTENSITY;
-  static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
-                                      FOREGROUND_RED | FOREGROUND_INTENSITY;
-  const WORD existing_bg = old_color_attrs & background_mask;
-
-  WORD new_color =
-      GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY;
-  static const int bg_bitOffset = GetBitOffset(background_mask);
-  static const int fg_bitOffset = GetBitOffset(foreground_mask);
-
-  if (((new_color & background_mask) >> bg_bitOffset) ==
-      ((new_color & foreground_mask) >> fg_bitOffset)) {
-    new_color ^= FOREGROUND_INTENSITY;  // invert intensity
-  }
-  return new_color;
-}
-
-#else
-
-// Returns the ANSI color code for the given color.  COLOR_DEFAULT is
-// an invalid input.
-static const char* GetAnsiColorCode(GTestColor color) {
-  switch (color) {
-    case COLOR_RED:     return "1";
-    case COLOR_GREEN:   return "2";
-    case COLOR_YELLOW:  return "3";
-    default:
-      return nullptr;
-  }
-}
-
-#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-
-// Returns true iff Google Test should use colors in the output.
-bool ShouldUseColor(bool stdout_is_tty) {
-  const char* const gtest_color = GTEST_FLAG(color).c_str();
-
-  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
-    // On Windows the TERM variable is usually not set, but the
-    // console there does support colors.
-    return stdout_is_tty;
-#else
-    // On non-Windows platforms, we rely on the TERM variable.
-    const char* const term = posix::GetEnv("TERM");
-    const bool term_supports_color =
-        String::CStringEquals(term, "xterm") ||
-        String::CStringEquals(term, "xterm-color") ||
-        String::CStringEquals(term, "xterm-256color") ||
-        String::CStringEquals(term, "screen") ||
-        String::CStringEquals(term, "screen-256color") ||
-        String::CStringEquals(term, "tmux") ||
-        String::CStringEquals(term, "tmux-256color") ||
-        String::CStringEquals(term, "rxvt-unicode") ||
-        String::CStringEquals(term, "rxvt-unicode-256color") ||
-        String::CStringEquals(term, "linux") ||
-        String::CStringEquals(term, "cygwin");
-    return stdout_is_tty && term_supports_color;
-#endif  // GTEST_OS_WINDOWS
-  }
-
-  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
-      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
-      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
-      String::CStringEquals(gtest_color, "1");
-  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
-  // value is neither one of these nor "auto", we treat it as "no" to
-  // be conservative.
-}
-
-// Helpers for printing colored strings to stdout. Note that on Windows, we
-// cannot simply emit special characters and have the terminal change colors.
-// This routine must actually emit the characters rather than return a string
-// that would be colored when printed, as can be done on Linux.
-void ColoredPrintf(GTestColor color, const char* fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
-    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-  const bool use_color = AlwaysFalse();
-#else
-  static const bool in_color_mode =
-      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
-  const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
-#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
-
-  if (!use_color) {
-    vprintf(fmt, args);
-    va_end(args);
-    return;
-  }
-
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
-  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
-
-  // Gets the current text color.
-  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
-  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
-  const WORD old_color_attrs = buffer_info.wAttributes;
-  const WORD new_color = GetNewColor(color, old_color_attrs);
-
-  // We need to flush the stream buffers into the console before each
-  // SetConsoleTextAttribute call lest it affect the text that is already
-  // printed but has not yet reached the console.
-  fflush(stdout);
-  SetConsoleTextAttribute(stdout_handle, new_color);
-
-  vprintf(fmt, args);
-
-  fflush(stdout);
-  // Restores the text color.
-  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
-#else
-  printf("\033[0;3%sm", GetAnsiColorCode(color));
-  vprintf(fmt, args);
-  printf("\033[m");  // Resets the terminal to default.
-#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-  va_end(args);
-}
-
-// Text printed in Google Test's text output and --gtest_list_tests
-// output to label the type parameter and value parameter for a test.
-static const char kTypeParamLabel[] = "TypeParam";
-static const char kValueParamLabel[] = "GetParam()";
-
-static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
-  const char* const type_param = test_info.type_param();
-  const char* const value_param = test_info.value_param();
-
-  if (type_param != nullptr || value_param != nullptr) {
-    printf(", where ");
-    if (type_param != nullptr) {
-      printf("%s = %s", kTypeParamLabel, type_param);
-      if (value_param != nullptr) printf(" and ");
-    }
-    if (value_param != nullptr) {
-      printf("%s = %s", kValueParamLabel, value_param);
-    }
-  }
-}
-
-// This class implements the TestEventListener interface.
-//
-// Class PrettyUnitTestResultPrinter is copyable.
-class PrettyUnitTestResultPrinter : public TestEventListener {
- public:
-  PrettyUnitTestResultPrinter() {}
-  static void PrintTestName(const char* test_suite, const char* test) {
-    printf("%s.%s", test_suite, test);
-  }
-
-  // The following methods override what's in the TestEventListener class.
-  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
-  void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
-  void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
-  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
-  void OnTestCaseStart(const TestSuite& test_suite) override;
-  void OnTestStart(const TestInfo& test_info) override;
-  void OnTestPartResult(const TestPartResult& result) override;
-  void OnTestEnd(const TestInfo& test_info) override;
-  void OnTestCaseEnd(const TestSuite& test_suite) override;
-  void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
-  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
-  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
-  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
-
- private:
-  static void PrintFailedTests(const UnitTest& unit_test);
-  static void PrintSkippedTests(const UnitTest& unit_test);
-};
-
-  // Fired before each iteration of tests starts.
-void PrettyUnitTestResultPrinter::OnTestIterationStart(
-    const UnitTest& unit_test, int iteration) {
-  if (GTEST_FLAG(repeat) != 1)
-    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
-
-  const char* const filter = GTEST_FLAG(filter).c_str();
-
-  // Prints the filter if it's not *.  This reminds the user that some
-  // tests may be skipped.
-  if (!String::CStringEquals(filter, kUniversalFilter)) {
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: %s filter = %s\n", GTEST_NAME_, filter);
-  }
-
-  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
-    const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: This is test shard %d of %s.\n",
-                  static_cast<int>(shard_index) + 1,
-                  internal::posix::GetEnv(kTestTotalShards));
-  }
-
-  if (GTEST_FLAG(shuffle)) {
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: Randomizing tests' orders with a seed of %d .\n",
-                  unit_test.random_seed());
-  }
-
-  ColoredPrintf(COLOR_GREEN,  "[==========] ");
-  printf("Running %s from %s.\n",
-         FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
-    const UnitTest& /*unit_test*/) {
-  ColoredPrintf(COLOR_GREEN,  "[----------] ");
-  printf("Global test environment set-up.\n");
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestSuite& test_suite) {
-  const std::string counts =
-      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
-  ColoredPrintf(COLOR_GREEN, "[----------] ");
-  printf("%s from %s", counts.c_str(), test_suite.name());
-  if (test_suite.type_param() == nullptr) {
-    printf("\n");
-  } else {
-    printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param());
-  }
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
-  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
-  PrintTestName(test_info.test_suite_name(), test_info.name());
-  printf("\n");
-  fflush(stdout);
-}
-
-// Called after an assertion failure.
-void PrettyUnitTestResultPrinter::OnTestPartResult(
-    const TestPartResult& result) {
-  switch (result.type()) {
-    // If the test part succeeded, or was skipped,
-    // we don't need to do anything.
-    case TestPartResult::kSkip:
-    case TestPartResult::kSuccess:
-      return;
-    default:
-      // Print failure message from the assertion
-      // (e.g. expected this and got that).
-      PrintTestPartResult(result);
-      fflush(stdout);
-  }
-}
-
-void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
-  if (test_info.result()->Passed()) {
-    ColoredPrintf(COLOR_GREEN, "[       OK ] ");
-  } else if (test_info.result()->Skipped()) {
-    ColoredPrintf(COLOR_GREEN, "[  SKIPPED ] ");
-  } else {
-    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
-  }
-  PrintTestName(test_info.test_suite_name(), test_info.name());
-  if (test_info.result()->Failed())
-    PrintFullTestCommentIfPresent(test_info);
-
-  if (GTEST_FLAG(print_time)) {
-    printf(" (%s ms)\n", internal::StreamableToString(
-           test_info.result()->elapsed_time()).c_str());
-  } else {
-    printf("\n");
-  }
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestSuite& test_suite) {
-  if (!GTEST_FLAG(print_time)) return;
-
-  const std::string counts =
-      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
-  ColoredPrintf(COLOR_GREEN, "[----------] ");
-  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),
-         internal::StreamableToString(test_suite.elapsed_time()).c_str());
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
-    const UnitTest& /*unit_test*/) {
-  ColoredPrintf(COLOR_GREEN,  "[----------] ");
-  printf("Global test environment tear-down\n");
-  fflush(stdout);
-}
-
-// Internal helper for printing the list of failed tests.
-void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
-  const int failed_test_count = unit_test.failed_test_count();
-  if (failed_test_count == 0) {
-    return;
-  }
-
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
-    if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
-      continue;
-    }
-    for (int j = 0; j < test_suite.total_test_count(); ++j) {
-      const TestInfo& test_info = *test_suite.GetTestInfo(j);
-      if (!test_info.should_run() || !test_info.result()->Failed()) {
-        continue;
-      }
-      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
-      printf("%s.%s", test_suite.name(), test_info.name());
-      PrintFullTestCommentIfPresent(test_info);
-      printf("\n");
-    }
-  }
-}
-
-// Internal helper for printing the list of skipped tests.
-void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
-  const int skipped_test_count = unit_test.skipped_test_count();
-  if (skipped_test_count == 0) {
-    return;
-  }
-
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
-    if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
-      continue;
-    }
-    for (int j = 0; j < test_suite.total_test_count(); ++j) {
-      const TestInfo& test_info = *test_suite.GetTestInfo(j);
-      if (!test_info.should_run() || !test_info.result()->Skipped()) {
-        continue;
-      }
-      ColoredPrintf(COLOR_GREEN, "[  SKIPPED ] ");
-      printf("%s.%s", test_suite.name(), test_info.name());
-      printf("\n");
-    }
-  }
-}
-
-void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                     int /*iteration*/) {
-  ColoredPrintf(COLOR_GREEN,  "[==========] ");
-  printf("%s from %s ran.",
-         FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
-  if (GTEST_FLAG(print_time)) {
-    printf(" (%s ms total)",
-           internal::StreamableToString(unit_test.elapsed_time()).c_str());
-  }
-  printf("\n");
-  ColoredPrintf(COLOR_GREEN,  "[  PASSED  ] ");
-  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
-
-  const int skipped_test_count = unit_test.skipped_test_count();
-  if (skipped_test_count > 0) {
-    ColoredPrintf(COLOR_GREEN, "[  SKIPPED ] ");
-    printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
-    PrintSkippedTests(unit_test);
-  }
-
-  int num_failures = unit_test.failed_test_count();
-  if (!unit_test.Passed()) {
-    const int failed_test_count = unit_test.failed_test_count();
-    ColoredPrintf(COLOR_RED,  "[  FAILED  ] ");
-    printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
-    PrintFailedTests(unit_test);
-    printf("\n%2d FAILED %s\n", num_failures,
-                        num_failures == 1 ? "TEST" : "TESTS");
-  }
-
-  int num_disabled = unit_test.reportable_disabled_test_count();
-  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
-    if (!num_failures) {
-      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
-    }
-    ColoredPrintf(COLOR_YELLOW,
-                  "  YOU HAVE %d DISABLED %s\n\n",
-                  num_disabled,
-                  num_disabled == 1 ? "TEST" : "TESTS");
-  }
-  // Ensure that Google Test output is printed before, e.g., heapchecker output.
-  fflush(stdout);
-}
-
-// End PrettyUnitTestResultPrinter
-
-// class TestEventRepeater
-//
-// This class forwards events to other event listeners.
-class TestEventRepeater : public TestEventListener {
- public:
-  TestEventRepeater() : forwarding_enabled_(true) {}
-  ~TestEventRepeater() override;
-  void Append(TestEventListener *listener);
-  TestEventListener* Release(TestEventListener* listener);
-
-  // Controls whether events will be forwarded to listeners_. Set to false
-  // in death test child processes.
-  bool forwarding_enabled() const { return forwarding_enabled_; }
-  void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
-
-  void OnTestProgramStart(const UnitTest& unit_test) override;
-  void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
-  void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
-  void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override;
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
-  void OnTestCaseStart(const TestSuite& parameter) override;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI
-  void OnTestSuiteStart(const TestSuite& parameter) override;
-  void OnTestStart(const TestInfo& test_info) override;
-  void OnTestPartResult(const TestPartResult& result) override;
-  void OnTestEnd(const TestInfo& test_info) override;
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
-  void OnTestCaseEnd(const TestSuite& parameter) override;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI
-  void OnTestSuiteEnd(const TestSuite& parameter) override;
-  void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
-  void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) override;
-  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
-  void OnTestProgramEnd(const UnitTest& unit_test) override;
-
- private:
-  // Controls whether events will be forwarded to listeners_. Set to false
-  // in death test child processes.
-  bool forwarding_enabled_;
-  // The list of listeners that receive events.
-  std::vector<TestEventListener*> listeners_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
-};
-
-TestEventRepeater::~TestEventRepeater() {
-  ForEach(listeners_, Delete<TestEventListener>);
-}
-
-void TestEventRepeater::Append(TestEventListener *listener) {
-  listeners_.push_back(listener);
-}
-
-TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
-  for (size_t i = 0; i < listeners_.size(); ++i) {
-    if (listeners_[i] == listener) {
-      listeners_.erase(listeners_.begin() + i);
-      return listener;
-    }
-  }
-
-  return nullptr;
-}
-
-// Since most methods are very similar, use macros to reduce boilerplate.
-// This defines a member that forwards the call to all listeners.
-#define GTEST_REPEATER_METHOD_(Name, Type) \
-void TestEventRepeater::Name(const Type& parameter) { \
-  if (forwarding_enabled_) { \
-    for (size_t i = 0; i < listeners_.size(); i++) { \
-      listeners_[i]->Name(parameter); \
-    } \
-  } \
-}
-// This defines a member that forwards the call to all listeners in reverse
-// order.
-#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \
-void TestEventRepeater::Name(const Type& parameter) { \
-  if (forwarding_enabled_) { \
-    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
-      listeners_[i]->Name(parameter); \
-    } \
-  } \
-}
-
-GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
-GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
-GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
-GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
-GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
-GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
-GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
-GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
-GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
-
-#undef GTEST_REPEATER_METHOD_
-#undef GTEST_REVERSE_REPEATER_METHOD_
-
-void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
-                                             int iteration) {
-  if (forwarding_enabled_) {
-    for (size_t i = 0; i < listeners_.size(); i++) {
-      listeners_[i]->OnTestIterationStart(unit_test, iteration);
-    }
-  }
-}
-
-void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
-                                           int iteration) {
-  if (forwarding_enabled_) {
-    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) {
-      listeners_[i]->OnTestIterationEnd(unit_test, iteration);
-    }
-  }
-}
-
-// End TestEventRepeater
-
-// This class generates an XML output file.
-class XmlUnitTestResultPrinter : public EmptyTestEventListener {
- public:
-  explicit XmlUnitTestResultPrinter(const char* output_file);
-
-  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
-  void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites);
-
-  // Prints an XML summary of all unit tests.
-  static void PrintXmlTestsList(std::ostream* stream,
-                                const std::vector<TestSuite*>& test_suites);
-
- private:
-  // Is c a whitespace character that is normalized to a space character
-  // when it appears in an XML attribute value?
-  static bool IsNormalizableWhitespace(char c) {
-    return c == 0x9 || c == 0xA || c == 0xD;
-  }
-
-  // May c appear in a well-formed XML document?
-  static bool IsValidXmlCharacter(char c) {
-    return IsNormalizableWhitespace(c) || c >= 0x20;
-  }
-
-  // Returns an XML-escaped copy of the input string str.  If
-  // is_attribute is true, the text is meant to appear as an attribute
-  // value, and normalizable whitespace is preserved by replacing it
-  // with character references.
-  static std::string EscapeXml(const std::string& str, bool is_attribute);
-
-  // Returns the given string with all characters invalid in XML removed.
-  static std::string RemoveInvalidXmlCharacters(const std::string& str);
-
-  // Convenience wrapper around EscapeXml when str is an attribute value.
-  static std::string EscapeXmlAttribute(const std::string& str) {
-    return EscapeXml(str, true);
-  }
-
-  // Convenience wrapper around EscapeXml when str is not an attribute value.
-  static std::string EscapeXmlText(const char* str) {
-    return EscapeXml(str, false);
-  }
-
-  // Verifies that the given attribute belongs to the given element and
-  // streams the attribute as XML.
-  static void OutputXmlAttribute(std::ostream* stream,
-                                 const std::string& element_name,
-                                 const std::string& name,
-                                 const std::string& value);
-
-  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
-  static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
-
-  // Streams an XML representation of a TestInfo object.
-  static void OutputXmlTestInfo(::std::ostream* stream,
-                                const char* test_suite_name,
-                                const TestInfo& test_info);
-
-  // Prints an XML representation of a TestSuite object
-  static void PrintXmlTestSuite(::std::ostream* stream,
-                                const TestSuite& test_suite);
-
-  // Prints an XML summary of unit_test to output stream out.
-  static void PrintXmlUnitTest(::std::ostream* stream,
-                               const UnitTest& unit_test);
-
-  // Produces a string representing the test properties in a result as space
-  // delimited XML attributes based on the property key="value" pairs.
-  // When the std::string is not empty, it includes a space at the beginning,
-  // to delimit this attribute from prior attributes.
-  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
-
-  // Streams an XML representation of the test properties of a TestResult
-  // object.
-  static void OutputXmlTestProperties(std::ostream* stream,
-                                      const TestResult& result);
-
-  // The output file.
-  const std::string output_file_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
-};
-
-// Creates a new XmlUnitTestResultPrinter.
-XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
-    : output_file_(output_file) {
-  if (output_file_.empty()) {
-    GTEST_LOG_(FATAL) << "XML output file may not be null";
-  }
-}
-
-// Called after the unit test ends.
-void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                  int /*iteration*/) {
-  FILE* xmlout = OpenFileForWriting(output_file_);
-  std::stringstream stream;
-  PrintXmlUnitTest(&stream, unit_test);
-  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
-  fclose(xmlout);
-}
-
-void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
-    const std::vector<TestSuite*>& test_suites) {
-  FILE* xmlout = OpenFileForWriting(output_file_);
-  std::stringstream stream;
-  PrintXmlTestsList(&stream, test_suites);
-  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
-  fclose(xmlout);
-}
-
-// Returns an XML-escaped copy of the input string str.  If is_attribute
-// is true, the text is meant to appear as an attribute value, and
-// normalizable whitespace is preserved by replacing it with character
-// references.
-//
-// Invalid XML characters in str, if any, are stripped from the output.
-// It is expected that most, if not all, of the text processed by this
-// module will consist of ordinary English text.
-// If this module is ever modified to produce version 1.1 XML output,
-// most invalid characters can be retained using character references.
-std::string XmlUnitTestResultPrinter::EscapeXml(
-    const std::string& str, bool is_attribute) {
-  Message m;
-
-  for (size_t i = 0; i < str.size(); ++i) {
-    const char ch = str[i];
-    switch (ch) {
-      case '<':
-        m << "&lt;";
-        break;
-      case '>':
-        m << "&gt;";
-        break;
-      case '&':
-        m << "&amp;";
-        break;
-      case '\'':
-        if (is_attribute)
-          m << "&apos;";
-        else
-          m << '\'';
-        break;
-      case '"':
-        if (is_attribute)
-          m << "&quot;";
-        else
-          m << '"';
-        break;
-      default:
-        if (IsValidXmlCharacter(ch)) {
-          if (is_attribute && IsNormalizableWhitespace(ch))
-            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
-              << ";";
-          else
-            m << ch;
-        }
-        break;
-    }
-  }
-
-  return m.GetString();
-}
-
-// Returns the given string with all characters invalid in XML removed.
-// Currently invalid characters are dropped from the string. An
-// alternative is to replace them with certain characters such as . or ?.
-std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
-    const std::string& str) {
-  std::string output;
-  output.reserve(str.size());
-  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
-    if (IsValidXmlCharacter(*it))
-      output.push_back(*it);
-
-  return output;
-}
-
-// The following routines generate an XML representation of a UnitTest
-// object.
-// GOOGLETEST_CM0009 DO NOT DELETE
-//
-// This is how Google Test concepts map to the DTD:
-//
-// <testsuites name="AllTests">        <-- corresponds to a UnitTest object
-//   <testsuite name="testcase-name">  <-- corresponds to a TestSuite object
-//     <testcase name="test-name">     <-- corresponds to a TestInfo object
-//       <failure message="...">...</failure>
-//       <failure message="...">...</failure>
-//       <failure message="...">...</failure>
-//                                     <-- individual assertion failures
-//     </testcase>
-//   </testsuite>
-// </testsuites>
-
-// Formats the given time in milliseconds as seconds.
-std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
-  ::std::stringstream ss;
-  ss << (static_cast<double>(ms) * 1e-3);
-  return ss.str();
-}
-
-static bool PortableLocaltime(time_t seconds, struct tm* out) {
-#if defined(_MSC_VER)
-  return localtime_s(out, &seconds) == 0;
-#elif defined(__MINGW32__) || defined(__MINGW64__)
-  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
-  // Windows' localtime(), which has a thread-local tm buffer.
-  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
-  if (tm_ptr == nullptr) return false;
-  *out = *tm_ptr;
-  return true;
-#else
-  return localtime_r(&seconds, out) != nullptr;
-#endif
-}
-
-// Converts the given epoch time in milliseconds to a date string in the ISO
-// 8601 format, without the timezone information.
-std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
-  struct tm time_struct;
-  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
-    return "";
-  // YYYY-MM-DDThh:mm:ss
-  return StreamableToString(time_struct.tm_year + 1900) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
-      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
-      String::FormatIntWidth2(time_struct.tm_min) + ":" +
-      String::FormatIntWidth2(time_struct.tm_sec);
-}
-
-// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
-void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
-                                                     const char* data) {
-  const char* segment = data;
-  *stream << "<![CDATA[";
-  for (;;) {
-    const char* const next_segment = strstr(segment, "]]>");
-    if (next_segment != nullptr) {
-      stream->write(
-          segment, static_cast<std::streamsize>(next_segment - segment));
-      *stream << "]]>]]&gt;<![CDATA[";
-      segment = next_segment + strlen("]]>");
-    } else {
-      *stream << segment;
-      break;
-    }
-  }
-  *stream << "]]>";
-}
-
-void XmlUnitTestResultPrinter::OutputXmlAttribute(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    const std::string& value) {
-  const std::vector<std::string>& allowed_names =
-      GetReservedOutputAttributesForElement(element_name);
-
-  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
-      << "Attribute " << name << " is not allowed for element <" << element_name
-      << ">.";
-
-  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
-}
-
-// Prints an XML representation of a TestInfo object.
-void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
-                                                 const char* test_suite_name,
-                                                 const TestInfo& test_info) {
-  const TestResult& result = *test_info.result();
-  const std::string kTestsuite = "testcase";
-
-  if (test_info.is_in_another_shard()) {
-    return;
-  }
-
-  *stream << "    <testcase";
-  OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
-
-  if (test_info.value_param() != nullptr) {
-    OutputXmlAttribute(stream, kTestsuite, "value_param",
-                       test_info.value_param());
-  }
-  if (test_info.type_param() != nullptr) {
-    OutputXmlAttribute(stream, kTestsuite, "type_param",
-                       test_info.type_param());
-  }
-  if (GTEST_FLAG(list_tests)) {
-    OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
-    OutputXmlAttribute(stream, kTestsuite, "line",
-                       StreamableToString(test_info.line()));
-    *stream << " />\n";
-    return;
-  }
-
-  OutputXmlAttribute(stream, kTestsuite, "status",
-                     test_info.should_run() ? "run" : "notrun");
-  OutputXmlAttribute(stream, kTestsuite, "result",
-                     test_info.should_run()
-                         ? (result.Skipped() ? "skipped" : "completed")
-                         : "suppressed");
-  OutputXmlAttribute(stream, kTestsuite, "time",
-                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
-  OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
-
-  int failures = 0;
-  for (int i = 0; i < result.total_part_count(); ++i) {
-    const TestPartResult& part = result.GetTestPartResult(i);
-    if (part.failed()) {
-      if (++failures == 1) {
-        *stream << ">\n";
-      }
-      const std::string location =
-          internal::FormatCompilerIndependentFileLocation(part.file_name(),
-                                                          part.line_number());
-      const std::string summary = location + "\n" + part.summary();
-      *stream << "      <failure message=\""
-              << EscapeXmlAttribute(summary.c_str())
-              << "\" type=\"\">";
-      const std::string detail = location + "\n" + part.message();
-      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
-      *stream << "</failure>\n";
-    }
-  }
-
-  if (failures == 0 && result.test_property_count() == 0) {
-    *stream << " />\n";
-  } else {
-    if (failures == 0) {
-      *stream << ">\n";
-    }
-    OutputXmlTestProperties(stream, result);
-    *stream << "    </testcase>\n";
-  }
-}
-
-// Prints an XML representation of a TestSuite object
-void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
-                                                 const TestSuite& test_suite) {
-  const std::string kTestsuite = "testsuite";
-  *stream << "  <" << kTestsuite;
-  OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
-  OutputXmlAttribute(stream, kTestsuite, "tests",
-                     StreamableToString(test_suite.reportable_test_count()));
-  if (!GTEST_FLAG(list_tests)) {
-    OutputXmlAttribute(stream, kTestsuite, "failures",
-                       StreamableToString(test_suite.failed_test_count()));
-    OutputXmlAttribute(
-        stream, kTestsuite, "disabled",
-        StreamableToString(test_suite.reportable_disabled_test_count()));
-    OutputXmlAttribute(stream, kTestsuite, "errors", "0");
-    OutputXmlAttribute(stream, kTestsuite, "time",
-                       FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
-    *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
-  }
-  *stream << ">\n";
-  for (int i = 0; i < test_suite.total_test_count(); ++i) {
-    if (test_suite.GetTestInfo(i)->is_reportable())
-      OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
-  }
-  *stream << "  </" << kTestsuite << ">\n";
-}
-
-// Prints an XML summary of unit_test to output stream out.
-void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
-                                                const UnitTest& unit_test) {
-  const std::string kTestsuites = "testsuites";
-
-  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-  *stream << "<" << kTestsuites;
-
-  OutputXmlAttribute(stream, kTestsuites, "tests",
-                     StreamableToString(unit_test.reportable_test_count()));
-  OutputXmlAttribute(stream, kTestsuites, "failures",
-                     StreamableToString(unit_test.failed_test_count()));
-  OutputXmlAttribute(
-      stream, kTestsuites, "disabled",
-      StreamableToString(unit_test.reportable_disabled_test_count()));
-  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
-  OutputXmlAttribute(
-      stream, kTestsuites, "timestamp",
-      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
-  OutputXmlAttribute(stream, kTestsuites, "time",
-                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
-
-  if (GTEST_FLAG(shuffle)) {
-    OutputXmlAttribute(stream, kTestsuites, "random_seed",
-                       StreamableToString(unit_test.random_seed()));
-  }
-  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
-
-  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
-  *stream << ">\n";
-
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
-      PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
-  }
-  *stream << "</" << kTestsuites << ">\n";
-}
-
-void XmlUnitTestResultPrinter::PrintXmlTestsList(
-    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
-  const std::string kTestsuites = "testsuites";
-
-  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-  *stream << "<" << kTestsuites;
-
-  int total_tests = 0;
-  for (auto test_suite : test_suites) {
-    total_tests += test_suite->total_test_count();
-  }
-  OutputXmlAttribute(stream, kTestsuites, "tests",
-                     StreamableToString(total_tests));
-  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
-  *stream << ">\n";
-
-  for (auto test_suite : test_suites) {
-    PrintXmlTestSuite(stream, *test_suite);
-  }
-  *stream << "</" << kTestsuites << ">\n";
-}
-
-// Produces a string representing the test properties in a result as space
-// delimited XML attributes based on the property key="value" pairs.
-std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
-    const TestResult& result) {
-  Message attributes;
-  for (int i = 0; i < result.test_property_count(); ++i) {
-    const TestProperty& property = result.GetTestProperty(i);
-    attributes << " " << property.key() << "="
-        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
-  }
-  return attributes.GetString();
-}
-
-void XmlUnitTestResultPrinter::OutputXmlTestProperties(
-    std::ostream* stream, const TestResult& result) {
-  const std::string kProperties = "properties";
-  const std::string kProperty = "property";
-
-  if (result.test_property_count() <= 0) {
-    return;
-  }
-
-  *stream << "<" << kProperties << ">\n";
-  for (int i = 0; i < result.test_property_count(); ++i) {
-    const TestProperty& property = result.GetTestProperty(i);
-    *stream << "<" << kProperty;
-    *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
-    *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
-    *stream << "/>\n";
-  }
-  *stream << "</" << kProperties << ">\n";
-}
-
-// End XmlUnitTestResultPrinter
-
-// This class generates an JSON output file.
-class JsonUnitTestResultPrinter : public EmptyTestEventListener {
- public:
-  explicit JsonUnitTestResultPrinter(const char* output_file);
-
-  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
-
-  // Prints an JSON summary of all unit tests.
-  static void PrintJsonTestList(::std::ostream* stream,
-                                const std::vector<TestSuite*>& test_suites);
-
- private:
-  // Returns an JSON-escaped copy of the input string str.
-  static std::string EscapeJson(const std::string& str);
-
-  //// Verifies that the given attribute belongs to the given element and
-  //// streams the attribute as JSON.
-  static void OutputJsonKey(std::ostream* stream,
-                            const std::string& element_name,
-                            const std::string& name,
-                            const std::string& value,
-                            const std::string& indent,
-                            bool comma = true);
-  static void OutputJsonKey(std::ostream* stream,
-                            const std::string& element_name,
-                            const std::string& name,
-                            int value,
-                            const std::string& indent,
-                            bool comma = true);
-
-  // Streams a JSON representation of a TestInfo object.
-  static void OutputJsonTestInfo(::std::ostream* stream,
-                                 const char* test_suite_name,
-                                 const TestInfo& test_info);
-
-  // Prints a JSON representation of a TestSuite object
-  static void PrintJsonTestSuite(::std::ostream* stream,
-                                 const TestSuite& test_suite);
-
-  // Prints a JSON summary of unit_test to output stream out.
-  static void PrintJsonUnitTest(::std::ostream* stream,
-                                const UnitTest& unit_test);
-
-  // Produces a string representing the test properties in a result as
-  // a JSON dictionary.
-  static std::string TestPropertiesAsJson(const TestResult& result,
-                                          const std::string& indent);
-
-  // The output file.
-  const std::string output_file_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
-};
-
-// Creates a new JsonUnitTestResultPrinter.
-JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
-    : output_file_(output_file) {
-  if (output_file_.empty()) {
-    GTEST_LOG_(FATAL) << "JSON output file may not be null";
-  }
-}
-
-void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                  int /*iteration*/) {
-  FILE* jsonout = OpenFileForWriting(output_file_);
-  std::stringstream stream;
-  PrintJsonUnitTest(&stream, unit_test);
-  fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
-  fclose(jsonout);
-}
-
-// Returns an JSON-escaped copy of the input string str.
-std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
-  Message m;
-
-  for (size_t i = 0; i < str.size(); ++i) {
-    const char ch = str[i];
-    switch (ch) {
-      case '\\':
-      case '"':
-      case '/':
-        m << '\\' << ch;
-        break;
-      case '\b':
-        m << "\\b";
-        break;
-      case '\t':
-        m << "\\t";
-        break;
-      case '\n':
-        m << "\\n";
-        break;
-      case '\f':
-        m << "\\f";
-        break;
-      case '\r':
-        m << "\\r";
-        break;
-      default:
-        if (ch < ' ') {
-          m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));
-        } else {
-          m << ch;
-        }
-        break;
-    }
-  }
-
-  return m.GetString();
-}
-
-// The following routines generate an JSON representation of a UnitTest
-// object.
-
-// Formats the given time in milliseconds as seconds.
-static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
-  ::std::stringstream ss;
-  ss << (static_cast<double>(ms) * 1e-3) << "s";
-  return ss.str();
-}
-
-// Converts the given epoch time in milliseconds to a date string in the
-// RFC3339 format, without the timezone information.
-static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
-  struct tm time_struct;
-  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
-    return "";
-  // YYYY-MM-DDThh:mm:ss
-  return StreamableToString(time_struct.tm_year + 1900) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
-      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
-      String::FormatIntWidth2(time_struct.tm_min) + ":" +
-      String::FormatIntWidth2(time_struct.tm_sec) + "Z";
-}
-
-static inline std::string Indent(int width) {
-  return std::string(width, ' ');
-}
-
-void JsonUnitTestResultPrinter::OutputJsonKey(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    const std::string& value,
-    const std::string& indent,
-    bool comma) {
-  const std::vector<std::string>& allowed_names =
-      GetReservedOutputAttributesForElement(element_name);
-
-  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
-      << "Key \"" << name << "\" is not allowed for value \"" << element_name
-      << "\".";
-
-  *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
-  if (comma)
-    *stream << ",\n";
-}
-
-void JsonUnitTestResultPrinter::OutputJsonKey(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    int value,
-    const std::string& indent,
-    bool comma) {
-  const std::vector<std::string>& allowed_names =
-      GetReservedOutputAttributesForElement(element_name);
-
-  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
-      << "Key \"" << name << "\" is not allowed for value \"" << element_name
-      << "\".";
-
-  *stream << indent << "\"" << name << "\": " << StreamableToString(value);
-  if (comma)
-    *stream << ",\n";
-}
-
-// Prints a JSON representation of a TestInfo object.
-void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
-                                                   const char* test_suite_name,
-                                                   const TestInfo& test_info) {
-  const TestResult& result = *test_info.result();
-  const std::string kTestsuite = "testcase";
-  const std::string kIndent = Indent(10);
-
-  *stream << Indent(8) << "{\n";
-  OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);
-
-  if (test_info.value_param() != nullptr) {
-    OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),
-                  kIndent);
-  }
-  if (test_info.type_param() != nullptr) {
-    OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
-                  kIndent);
-  }
-  if (GTEST_FLAG(list_tests)) {
-    OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
-    OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
-    *stream << "\n" << Indent(8) << "}";
-    return;
-  }
-
-  OutputJsonKey(stream, kTestsuite, "status",
-                test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
-  OutputJsonKey(stream, kTestsuite, "result",
-                test_info.should_run()
-                    ? (result.Skipped() ? "SKIPPED" : "COMPLETED")
-                    : "SUPPRESSED",
-                kIndent);
-  OutputJsonKey(stream, kTestsuite, "time",
-                FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
-  OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
-                false);
-  *stream << TestPropertiesAsJson(result, kIndent);
-
-  int failures = 0;
-  for (int i = 0; i < result.total_part_count(); ++i) {
-    const TestPartResult& part = result.GetTestPartResult(i);
-    if (part.failed()) {
-      *stream << ",\n";
-      if (++failures == 1) {
-        *stream << kIndent << "\"" << "failures" << "\": [\n";
-      }
-      const std::string location =
-          internal::FormatCompilerIndependentFileLocation(part.file_name(),
-                                                          part.line_number());
-      const std::string message = EscapeJson(location + "\n" + part.message());
-      *stream << kIndent << "  {\n"
-              << kIndent << "    \"failure\": \"" << message << "\",\n"
-              << kIndent << "    \"type\": \"\"\n"
-              << kIndent << "  }";
-    }
-  }
-
-  if (failures > 0)
-    *stream << "\n" << kIndent << "]";
-  *stream << "\n" << Indent(8) << "}";
-}
-
-// Prints an JSON representation of a TestSuite object
-void JsonUnitTestResultPrinter::PrintJsonTestSuite(
-    std::ostream* stream, const TestSuite& test_suite) {
-  const std::string kTestsuite = "testsuite";
-  const std::string kIndent = Indent(6);
-
-  *stream << Indent(4) << "{\n";
-  OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
-  OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
-                kIndent);
-  if (!GTEST_FLAG(list_tests)) {
-    OutputJsonKey(stream, kTestsuite, "failures",
-                  test_suite.failed_test_count(), kIndent);
-    OutputJsonKey(stream, kTestsuite, "disabled",
-                  test_suite.reportable_disabled_test_count(), kIndent);
-    OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
-    OutputJsonKey(stream, kTestsuite, "time",
-                  FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
-                  kIndent, false);
-    *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
-            << ",\n";
-  }
-
-  *stream << kIndent << "\"" << kTestsuite << "\": [\n";
-
-  bool comma = false;
-  for (int i = 0; i < test_suite.total_test_count(); ++i) {
-    if (test_suite.GetTestInfo(i)->is_reportable()) {
-      if (comma) {
-        *stream << ",\n";
-      } else {
-        comma = true;
-      }
-      OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
-    }
-  }
-  *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
-}
-
-// Prints a JSON summary of unit_test to output stream out.
-void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
-                                                  const UnitTest& unit_test) {
-  const std::string kTestsuites = "testsuites";
-  const std::string kIndent = Indent(2);
-  *stream << "{\n";
-
-  OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(),
-                kIndent);
-  OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(),
-                kIndent);
-  OutputJsonKey(stream, kTestsuites, "disabled",
-                unit_test.reportable_disabled_test_count(), kIndent);
-  OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);
-  if (GTEST_FLAG(shuffle)) {
-    OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),
-                  kIndent);
-  }
-  OutputJsonKey(stream, kTestsuites, "timestamp",
-                FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),
-                kIndent);
-  OutputJsonKey(stream, kTestsuites, "time",
-                FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,
-                false);
-
-  *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)
-          << ",\n";
-
-  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
-  *stream << kIndent << "\"" << kTestsuites << "\": [\n";
-
-  bool comma = false;
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
-      if (comma) {
-        *stream << ",\n";
-      } else {
-        comma = true;
-      }
-      PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
-    }
-  }
-
-  *stream << "\n" << kIndent << "]\n" << "}\n";
-}
-
-void JsonUnitTestResultPrinter::PrintJsonTestList(
-    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
-  const std::string kTestsuites = "testsuites";
-  const std::string kIndent = Indent(2);
-  *stream << "{\n";
-  int total_tests = 0;
-  for (auto test_suite : test_suites) {
-    total_tests += test_suite->total_test_count();
-  }
-  OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
-
-  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
-  *stream << kIndent << "\"" << kTestsuites << "\": [\n";
-
-  for (size_t i = 0; i < test_suites.size(); ++i) {
-    if (i != 0) {
-      *stream << ",\n";
-    }
-    PrintJsonTestSuite(stream, *test_suites[i]);
-  }
-
-  *stream << "\n"
-          << kIndent << "]\n"
-          << "}\n";
-}
-// Produces a string representing the test properties in a result as
-// a JSON dictionary.
-std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
-    const TestResult& result, const std::string& indent) {
-  Message attributes;
-  for (int i = 0; i < result.test_property_count(); ++i) {
-    const TestProperty& property = result.GetTestProperty(i);
-    attributes << ",\n" << indent << "\"" << property.key() << "\": "
-               << "\"" << EscapeJson(property.value()) << "\"";
-  }
-  return attributes.GetString();
-}
-
-// End JsonUnitTestResultPrinter
-
-#if GTEST_CAN_STREAM_RESULTS_
-
-// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
-// replaces them by "%xx" where xx is their hexadecimal value. For
-// example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
-// in both time and space -- important as the input str may contain an
-// arbitrarily long test failure message and stack trace.
-std::string StreamingListener::UrlEncode(const char* str) {
-  std::string result;
-  result.reserve(strlen(str) + 1);
-  for (char ch = *str; ch != '\0'; ch = *++str) {
-    switch (ch) {
-      case '%':
-      case '=':
-      case '&':
-      case '\n':
-        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
-        break;
-      default:
-        result.push_back(ch);
-        break;
-    }
-  }
-  return result;
-}
-
-void StreamingListener::SocketWriter::MakeConnection() {
-  GTEST_CHECK_(sockfd_ == -1)
-      << "MakeConnection() can't be called when there is already a connection.";
-
-  addrinfo hints;
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
-  hints.ai_socktype = SOCK_STREAM;
-  addrinfo* servinfo = nullptr;
-
-  // Use the getaddrinfo() to get a linked list of IP addresses for
-  // the given host name.
-  const int error_num = getaddrinfo(
-      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
-  if (error_num != 0) {
-    GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
-                        << gai_strerror(error_num);
-  }
-
-  // Loop through all the results and connect to the first we can.
-  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
-       cur_addr = cur_addr->ai_next) {
-    sockfd_ = socket(
-        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
-    if (sockfd_ != -1) {
-      // Connect the client socket to the server socket.
-      if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
-        close(sockfd_);
-        sockfd_ = -1;
-      }
-    }
-  }
-
-  freeaddrinfo(servinfo);  // all done with this structure
-
-  if (sockfd_ == -1) {
-    GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
-                        << host_name_ << ":" << port_num_;
-  }
-}
-
-// End of class Streaming Listener
-#endif  // GTEST_CAN_STREAM_RESULTS__
-
-// class OsStackTraceGetter
-
-const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
-    "... " GTEST_NAME_ " internal frames ...";
-
-std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-#if GTEST_HAS_ABSL
-  std::string result;
-
-  if (max_depth <= 0) {
-    return result;
-  }
-
-  max_depth = std::min(max_depth, kMaxStackTraceDepth);
-
-  std::vector<void*> raw_stack(max_depth);
-  // Skips the frames requested by the caller, plus this function.
-  const int raw_stack_size =
-      absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);
-
-  void* caller_frame = nullptr;
-  {
-    MutexLock lock(&mutex_);
-    caller_frame = caller_frame_;
-  }
-
-  for (int i = 0; i < raw_stack_size; ++i) {
-    if (raw_stack[i] == caller_frame &&
-        !GTEST_FLAG(show_internal_stack_frames)) {
-      // Add a marker to the trace and stop adding frames.
-      absl::StrAppend(&result, kElidedFramesMarker, "\n");
-      break;
-    }
-
-    char tmp[1024];
-    const char* symbol = "(unknown)";
-    if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {
-      symbol = tmp;
-    }
-
-    char line[1024];
-    snprintf(line, sizeof(line), "  %p: %s\n", raw_stack[i], symbol);
-    result += line;
-  }
-
-  return result;
-
-#else  // !GTEST_HAS_ABSL
-  static_cast<void>(max_depth);
-  static_cast<void>(skip_count);
-  return "";
-#endif  // GTEST_HAS_ABSL
-}
-
-void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
-#if GTEST_HAS_ABSL
-  void* caller_frame = nullptr;
-  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
-    caller_frame = nullptr;
-  }
-
-  MutexLock lock(&mutex_);
-  caller_frame_ = caller_frame;
-#endif  // GTEST_HAS_ABSL
-}
-
-// A helper class that creates the premature-exit file in its
-// constructor and deletes the file in its destructor.
-class ScopedPrematureExitFile {
- public:
-  explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
-      : premature_exit_filepath_(premature_exit_filepath ?
-                                 premature_exit_filepath : "") {
-    // If a path to the premature-exit file is specified...
-    if (!premature_exit_filepath_.empty()) {
-      // create the file with a single "0" character in it.  I/O
-      // errors are ignored as there's nothing better we can do and we
-      // don't want to fail the test because of this.
-      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
-      fwrite("0", 1, 1, pfile);
-      fclose(pfile);
-    }
-  }
-
-  ~ScopedPrematureExitFile() {
-    if (!premature_exit_filepath_.empty()) {
-      int retval = remove(premature_exit_filepath_.c_str());
-      if (retval) {
-        GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
-                          << premature_exit_filepath_ << "\" with error "
-                          << retval;
-      }
-    }
-  }
-
- private:
-  const std::string premature_exit_filepath_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
-};
-
-}  // namespace internal
-
-// class TestEventListeners
-
-TestEventListeners::TestEventListeners()
-    : repeater_(new internal::TestEventRepeater()),
-      default_result_printer_(nullptr),
-      default_xml_generator_(nullptr) {}
-
-TestEventListeners::~TestEventListeners() { delete repeater_; }
-
-// Returns the standard listener responsible for the default console
-// output.  Can be removed from the listeners list to shut down default
-// console output.  Note that removing this object from the listener list
-// with Release transfers its ownership to the user.
-void TestEventListeners::Append(TestEventListener* listener) {
-  repeater_->Append(listener);
-}
-
-// Removes the given event listener from the list and returns it.  It then
-// becomes the caller's responsibility to delete the listener. Returns
-// NULL if the listener is not found in the list.
-TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
-  if (listener == default_result_printer_)
-    default_result_printer_ = nullptr;
-  else if (listener == default_xml_generator_)
-    default_xml_generator_ = nullptr;
-  return repeater_->Release(listener);
-}
-
-// Returns repeater that broadcasts the TestEventListener events to all
-// subscribers.
-TestEventListener* TestEventListeners::repeater() { return repeater_; }
-
-// Sets the default_result_printer attribute to the provided listener.
-// The listener is also added to the listener list and previous
-// default_result_printer is removed from it and deleted. The listener can
-// also be NULL in which case it will not be added to the list. Does
-// nothing if the previous and the current listener objects are the same.
-void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
-  if (default_result_printer_ != listener) {
-    // It is an error to pass this method a listener that is already in the
-    // list.
-    delete Release(default_result_printer_);
-    default_result_printer_ = listener;
-    if (listener != nullptr) Append(listener);
-  }
-}
-
-// Sets the default_xml_generator attribute to the provided listener.  The
-// listener is also added to the listener list and previous
-// default_xml_generator is removed from it and deleted. The listener can
-// also be NULL in which case it will not be added to the list. Does
-// nothing if the previous and the current listener objects are the same.
-void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
-  if (default_xml_generator_ != listener) {
-    // It is an error to pass this method a listener that is already in the
-    // list.
-    delete Release(default_xml_generator_);
-    default_xml_generator_ = listener;
-    if (listener != nullptr) Append(listener);
-  }
-}
-
-// Controls whether events will be forwarded by the repeater to the
-// listeners in the list.
-bool TestEventListeners::EventForwardingEnabled() const {
-  return repeater_->forwarding_enabled();
-}
-
-void TestEventListeners::SuppressEventForwarding() {
-  repeater_->set_forwarding_enabled(false);
-}
-
-// class UnitTest
-
-// Gets the singleton UnitTest object.  The first time this method is
-// called, a UnitTest object is constructed and returned.  Consecutive
-// calls will return the same object.
-//
-// We don't protect this under mutex_ as a user is not supposed to
-// call this before main() starts, from which point on the return
-// value will never change.
-UnitTest* UnitTest::GetInstance() {
-  // CodeGear C++Builder insists on a public destructor for the
-  // default implementation.  Use this implementation to keep good OO
-  // design with private destructor.
-
-#if defined(__BORLANDC__)
-  static UnitTest* const instance = new UnitTest;
-  return instance;
-#else
-  static UnitTest instance;
-  return &instance;
-#endif  // defined(__BORLANDC__)
-}
-
-// Gets the number of successful test suites.
-int UnitTest::successful_test_suite_count() const {
-  return impl()->successful_test_suite_count();
-}
-
-// Gets the number of failed test suites.
-int UnitTest::failed_test_suite_count() const {
-  return impl()->failed_test_suite_count();
-}
-
-// Gets the number of all test suites.
-int UnitTest::total_test_suite_count() const {
-  return impl()->total_test_suite_count();
-}
-
-// Gets the number of all test suites that contain at least one test
-// that should run.
-int UnitTest::test_suite_to_run_count() const {
-  return impl()->test_suite_to_run_count();
-}
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-int UnitTest::successful_test_case_count() const {
-  return impl()->successful_test_suite_count();
-}
-int UnitTest::failed_test_case_count() const {
-  return impl()->failed_test_suite_count();
-}
-int UnitTest::total_test_case_count() const {
-  return impl()->total_test_suite_count();
-}
-int UnitTest::test_case_to_run_count() const {
-  return impl()->test_suite_to_run_count();
-}
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-// Gets the number of successful tests.
-int UnitTest::successful_test_count() const {
-  return impl()->successful_test_count();
-}
-
-// Gets the number of skipped tests.
-int UnitTest::skipped_test_count() const {
-  return impl()->skipped_test_count();
-}
-
-// Gets the number of failed tests.
-int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
-
-// Gets the number of disabled tests that will be reported in the XML report.
-int UnitTest::reportable_disabled_test_count() const {
-  return impl()->reportable_disabled_test_count();
-}
-
-// Gets the number of disabled tests.
-int UnitTest::disabled_test_count() const {
-  return impl()->disabled_test_count();
-}
-
-// Gets the number of tests to be printed in the XML report.
-int UnitTest::reportable_test_count() const {
-  return impl()->reportable_test_count();
-}
-
-// Gets the number of all tests.
-int UnitTest::total_test_count() const { return impl()->total_test_count(); }
-
-// Gets the number of tests that should run.
-int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
-
-// Gets the time of the test program start, in ms from the start of the
-// UNIX epoch.
-internal::TimeInMillis UnitTest::start_timestamp() const {
-    return impl()->start_timestamp();
-}
-
-// Gets the elapsed time, in milliseconds.
-internal::TimeInMillis UnitTest::elapsed_time() const {
-  return impl()->elapsed_time();
-}
-
-// Returns true iff the unit test passed (i.e. all test suites passed).
-bool UnitTest::Passed() const { return impl()->Passed(); }
-
-// Returns true iff the unit test failed (i.e. some test suite failed
-// or something outside of all tests failed).
-bool UnitTest::Failed() const { return impl()->Failed(); }
-
-// Gets the i-th test suite among all the test suites. i can range from 0 to
-// total_test_suite_count() - 1. If i is not in that range, returns NULL.
-const TestSuite* UnitTest::GetTestSuite(int i) const {
-  return impl()->GetTestSuite(i);
-}
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-const TestCase* UnitTest::GetTestCase(int i) const {
-  return impl()->GetTestCase(i);
-}
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-// Returns the TestResult containing information on test failures and
-// properties logged outside of individual test suites.
-const TestResult& UnitTest::ad_hoc_test_result() const {
-  return *impl()->ad_hoc_test_result();
-}
-
-// Gets the i-th test suite among all the test suites. i can range from 0 to
-// total_test_suite_count() - 1. If i is not in that range, returns NULL.
-TestSuite* UnitTest::GetMutableTestSuite(int i) {
-  return impl()->GetMutableSuiteCase(i);
-}
-
-// Returns the list of event listeners that can be used to track events
-// inside Google Test.
-TestEventListeners& UnitTest::listeners() {
-  return *impl()->listeners();
-}
-
-// Registers and returns a global test environment.  When a test
-// program is run, all global test environments will be set-up in the
-// order they were registered.  After all tests in the program have
-// finished, all global test environments will be torn-down in the
-// *reverse* order they were registered.
-//
-// The UnitTest object takes ownership of the given environment.
-//
-// We don't protect this under mutex_, as we only support calling it
-// from the main thread.
-Environment* UnitTest::AddEnvironment(Environment* env) {
-  if (env == nullptr) {
-    return nullptr;
-  }
-
-  impl_->environments().push_back(env);
-  return env;
-}
-
-// Adds a TestPartResult to the current TestResult object.  All Google Test
-// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
-// this to report their results.  The user code should use the
-// assertion macros instead of calling this directly.
-void UnitTest::AddTestPartResult(
-    TestPartResult::Type result_type,
-    const char* file_name,
-    int line_number,
-    const std::string& message,
-    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
-  Message msg;
-  msg << message;
-
-  internal::MutexLock lock(&mutex_);
-  if (impl_->gtest_trace_stack().size() > 0) {
-    msg << "\n" << GTEST_NAME_ << " trace:";
-
-    for (int i = static_cast<int>(impl_->gtest_trace_stack().size());
-         i > 0; --i) {
-      const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
-      msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
-          << " " << trace.message;
-    }
-  }
-
-  if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
-    msg << internal::kStackTraceMarker << os_stack_trace;
-  }
-
-  const TestPartResult result = TestPartResult(
-      result_type, file_name, line_number, msg.GetString().c_str());
-  impl_->GetTestPartResultReporterForCurrentThread()->
-      ReportTestPartResult(result);
-
-  if (result_type != TestPartResult::kSuccess &&
-      result_type != TestPartResult::kSkip) {
-    // gtest_break_on_failure takes precedence over
-    // gtest_throw_on_failure.  This allows a user to set the latter
-    // in the code (perhaps in order to use Google Test assertions
-    // with another testing framework) and specify the former on the
-    // command line for debugging.
-    if (GTEST_FLAG(break_on_failure)) {
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-      // Using DebugBreak on Windows allows gtest to still break into a debugger
-      // when a failure happens and both the --gtest_break_on_failure and
-      // the --gtest_catch_exceptions flags are specified.
-      DebugBreak();
-#elif (!defined(__native_client__)) &&            \
-    ((defined(__clang__) || defined(__GNUC__)) && \
-     (defined(__x86_64__) || defined(__i386__)))
-      // with clang/gcc we can achieve the same effect on x86 by invoking int3
-      asm("int3");
-#else
-      // Dereference nullptr through a volatile pointer to prevent the compiler
-      // from removing. We use this rather than abort() or __builtin_trap() for
-      // portability: some debuggers don't correctly trap abort().
-      *static_cast<volatile int*>(nullptr) = 1;
-#endif  // GTEST_OS_WINDOWS
-    } else if (GTEST_FLAG(throw_on_failure)) {
-#if GTEST_HAS_EXCEPTIONS
-      throw internal::GoogleTestFailureException(result);
-#else
-      // We cannot call abort() as it generates a pop-up in debug mode
-      // that cannot be suppressed in VC 7.1 or below.
-      exit(1);
-#endif
-    }
-  }
-}
-
-// Adds a TestProperty to the current TestResult object when invoked from
-// inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
-// from SetUpTestSuite or TearDownTestSuite, or to the global property set
-// when invoked elsewhere.  If the result already contains a property with
-// the same key, the value will be updated.
-void UnitTest::RecordProperty(const std::string& key,
-                              const std::string& value) {
-  impl_->RecordProperty(TestProperty(key, value));
-}
-
-// Runs all tests in this UnitTest object and prints the result.
-// Returns 0 if successful, or 1 otherwise.
-//
-// We don't protect this under mutex_, as we only support calling it
-// from the main thread.
-int UnitTest::Run() {
-  const bool in_death_test_child_process =
-      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
-
-  // Google Test implements this protocol for catching that a test
-  // program exits before returning control to Google Test:
-  //
-  //   1. Upon start, Google Test creates a file whose absolute path
-  //      is specified by the environment variable
-  //      TEST_PREMATURE_EXIT_FILE.
-  //   2. When Google Test has finished its work, it deletes the file.
-  //
-  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
-  // running a Google-Test-based test program and check the existence
-  // of the file at the end of the test execution to see if it has
-  // exited prematurely.
-
-  // If we are in the child process of a death test, don't
-  // create/delete the premature exit file, as doing so is unnecessary
-  // and will confuse the parent process.  Otherwise, create/delete
-  // the file upon entering/leaving this function.  If the program
-  // somehow exits before this function has a chance to return, the
-  // premature-exit file will be left undeleted, causing a test runner
-  // that understands the premature-exit-file protocol to report the
-  // test as having failed.
-  const internal::ScopedPrematureExitFile premature_exit_file(
-      in_death_test_child_process
-          ? nullptr
-          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
-
-  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
-  // used for the duration of the program.
-  impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
-
-#if GTEST_OS_WINDOWS
-  // Either the user wants Google Test to catch exceptions thrown by the
-  // tests or this is executing in the context of death test child
-  // process. In either case the user does not want to see pop-up dialogs
-  // about crashes - they are expected.
-  if (impl()->catch_exceptions() || in_death_test_child_process) {
-# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-    // SetErrorMode doesn't exist on CE.
-    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
-                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
-# endif  // !GTEST_OS_WINDOWS_MOBILE
-
-# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
-    // Death test children can be terminated with _abort().  On Windows,
-    // _abort() can show a dialog with a warning message.  This forces the
-    // abort message to go to stderr instead.
-    _set_error_mode(_OUT_TO_STDERR);
-# endif
-
-# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
-    // In the debug version, Visual Studio pops up a separate dialog
-    // offering a choice to debug the aborted program. We need to suppress
-    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
-    // executed. Google Test will notify the user of any unexpected
-    // failure via stderr.
-    if (!GTEST_FLAG(break_on_failure))
-      _set_abort_behavior(
-          0x0,                                    // Clear the following flags:
-          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
-# endif
-  }
-#endif  // GTEST_OS_WINDOWS
-
-  return internal::HandleExceptionsInMethodIfSupported(
-      impl(),
-      &internal::UnitTestImpl::RunAllTests,
-      "auxiliary test code (environments or event listeners)") ? 0 : 1;
-}
-
-// Returns the working directory when the first TEST() or TEST_F() was
-// executed.
-const char* UnitTest::original_working_dir() const {
-  return impl_->original_working_dir_.c_str();
-}
-
-// Returns the TestSuite object for the test that's currently running,
-// or NULL if no test is running.
-const TestSuite* UnitTest::current_test_suite() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  return impl_->current_test_suite();
-}
-
-// Legacy API is still available but deprecated
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-const TestCase* UnitTest::current_test_case() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  return impl_->current_test_suite();
-}
-#endif
-
-// Returns the TestInfo object for the test that's currently running,
-// or NULL if no test is running.
-const TestInfo* UnitTest::current_test_info() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  return impl_->current_test_info();
-}
-
-// Returns the random seed used at the start of the current test run.
-int UnitTest::random_seed() const { return impl_->random_seed(); }
-
-// Returns ParameterizedTestSuiteRegistry object used to keep track of
-// value-parameterized tests and instantiate and register them.
-internal::ParameterizedTestSuiteRegistry&
-UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
-  return impl_->parameterized_test_registry();
-}
-
-// Creates an empty UnitTest.
-UnitTest::UnitTest() {
-  impl_ = new internal::UnitTestImpl(this);
-}
-
-// Destructor of UnitTest.
-UnitTest::~UnitTest() {
-  delete impl_;
-}
-
-// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
-// Google Test trace stack.
-void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  impl_->gtest_trace_stack().push_back(trace);
-}
-
-// Pops a trace from the per-thread Google Test trace stack.
-void UnitTest::PopGTestTrace()
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  impl_->gtest_trace_stack().pop_back();
-}
-
-namespace internal {
-
-UnitTestImpl::UnitTestImpl(UnitTest* parent)
-    : parent_(parent),
-      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
-          default_global_test_part_result_reporter_(this),
-      default_per_thread_test_part_result_reporter_(this),
-      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
-          &default_global_test_part_result_reporter_),
-      per_thread_test_part_result_reporter_(
-          &default_per_thread_test_part_result_reporter_),
-      parameterized_test_registry_(),
-      parameterized_tests_registered_(false),
-      last_death_test_suite_(-1),
-      current_test_suite_(nullptr),
-      current_test_info_(nullptr),
-      ad_hoc_test_result_(),
-      os_stack_trace_getter_(nullptr),
-      post_flag_parse_init_performed_(false),
-      random_seed_(0),  // Will be overridden by the flag before first use.
-      random_(0),       // Will be reseeded before first use.
-      start_timestamp_(0),
-      elapsed_time_(0),
-#if GTEST_HAS_DEATH_TEST
-      death_test_factory_(new DefaultDeathTestFactory),
-#endif
-      // Will be overridden by the flag before first use.
-      catch_exceptions_(false) {
-  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
-}
-
-UnitTestImpl::~UnitTestImpl() {
-  // Deletes every TestSuite.
-  ForEach(test_suites_, internal::Delete<TestSuite>);
-
-  // Deletes every Environment.
-  ForEach(environments_, internal::Delete<Environment>);
-
-  delete os_stack_trace_getter_;
-}
-
-// Adds a TestProperty to the current TestResult object when invoked in a
-// context of a test, to current test suite's ad_hoc_test_result when invoke
-// from SetUpTestSuite/TearDownTestSuite, or to the global property set
-// otherwise.  If the result already contains a property with the same key,
-// the value will be updated.
-void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
-  std::string xml_element;
-  TestResult* test_result;  // TestResult appropriate for property recording.
-
-  if (current_test_info_ != nullptr) {
-    xml_element = "testcase";
-    test_result = &(current_test_info_->result_);
-  } else if (current_test_suite_ != nullptr) {
-    xml_element = "testsuite";
-    test_result = &(current_test_suite_->ad_hoc_test_result_);
-  } else {
-    xml_element = "testsuites";
-    test_result = &ad_hoc_test_result_;
-  }
-  test_result->RecordProperty(xml_element, test_property);
-}
-
-#if GTEST_HAS_DEATH_TEST
-// Disables event forwarding if the control is currently in a death test
-// subprocess. Must not be called before InitGoogleTest.
-void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
-  if (internal_run_death_test_flag_.get() != nullptr)
-    listeners()->SuppressEventForwarding();
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-// Initializes event listeners performing XML output as specified by
-// UnitTestOptions. Must not be called before InitGoogleTest.
-void UnitTestImpl::ConfigureXmlOutput() {
-  const std::string& output_format = UnitTestOptions::GetOutputFormat();
-  if (output_format == "xml") {
-    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
-        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
-  } else if (output_format == "json") {
-    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
-        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
-  } else if (output_format != "") {
-    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
-                        << output_format << "\" ignored.";
-  }
-}
-
-#if GTEST_CAN_STREAM_RESULTS_
-// Initializes event listeners for streaming test results in string form.
-// Must not be called before InitGoogleTest.
-void UnitTestImpl::ConfigureStreamingOutput() {
-  const std::string& target = GTEST_FLAG(stream_result_to);
-  if (!target.empty()) {
-    const size_t pos = target.find(':');
-    if (pos != std::string::npos) {
-      listeners()->Append(new StreamingListener(target.substr(0, pos),
-                                                target.substr(pos+1)));
-    } else {
-      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
-                          << "\" ignored.";
-    }
-  }
-}
-#endif  // GTEST_CAN_STREAM_RESULTS_
-
-// Performs initialization dependent upon flag values obtained in
-// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
-// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
-// this function is also called from RunAllTests.  Since this function can be
-// called more than once, it has to be idempotent.
-void UnitTestImpl::PostFlagParsingInit() {
-  // Ensures that this function does not execute more than once.
-  if (!post_flag_parse_init_performed_) {
-    post_flag_parse_init_performed_ = true;
-
-#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
-    // Register to send notifications about key process state changes.
-    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
-#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
-
-#if GTEST_HAS_DEATH_TEST
-    InitDeathTestSubprocessControlInfo();
-    SuppressTestEventsIfInSubprocess();
-#endif  // GTEST_HAS_DEATH_TEST
-
-    // Registers parameterized tests. This makes parameterized tests
-    // available to the UnitTest reflection API without running
-    // RUN_ALL_TESTS.
-    RegisterParameterizedTests();
-
-    // Configures listeners for XML output. This makes it possible for users
-    // to shut down the default XML output before invoking RUN_ALL_TESTS.
-    ConfigureXmlOutput();
-
-#if GTEST_CAN_STREAM_RESULTS_
-    // Configures listeners for streaming test results to the specified server.
-    ConfigureStreamingOutput();
-#endif  // GTEST_CAN_STREAM_RESULTS_
-
-#if GTEST_HAS_ABSL
-    if (GTEST_FLAG(install_failure_signal_handler)) {
-      absl::FailureSignalHandlerOptions options;
-      absl::InstallFailureSignalHandler(options);
-    }
-#endif  // GTEST_HAS_ABSL
-  }
-}
-
-// A predicate that checks the name of a TestSuite against a known
-// value.
-//
-// This is used for implementation of the UnitTest class only.  We put
-// it in the anonymous namespace to prevent polluting the outer
-// namespace.
-//
-// TestSuiteNameIs is copyable.
-class TestSuiteNameIs {
- public:
-  // Constructor.
-  explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
-
-  // Returns true iff the name of test_suite matches name_.
-  bool operator()(const TestSuite* test_suite) const {
-    return test_suite != nullptr &&
-           strcmp(test_suite->name(), name_.c_str()) == 0;
-  }
-
- private:
-  std::string name_;
-};
-
-// Finds and returns a TestSuite with the given name.  If one doesn't
-// exist, creates one and returns it.  It's the CALLER'S
-// RESPONSIBILITY to ensure that this function is only called WHEN THE
-// TESTS ARE NOT SHUFFLED.
-//
-// Arguments:
-//
-//   test_suite_name: name of the test suite
-//   type_param:     the name of the test suite's type parameter, or NULL if
-//                   this is not a typed or a type-parameterized test suite.
-//   set_up_tc:      pointer to the function that sets up the test suite
-//   tear_down_tc:   pointer to the function that tears down the test suite
-TestSuite* UnitTestImpl::GetTestSuite(
-    const char* test_suite_name, const char* type_param,
-    internal::SetUpTestSuiteFunc set_up_tc,
-    internal::TearDownTestSuiteFunc tear_down_tc) {
-  // Can we find a TestSuite with the given name?
-  const auto test_suite =
-      std::find_if(test_suites_.rbegin(), test_suites_.rend(),
-                   TestSuiteNameIs(test_suite_name));
-
-  if (test_suite != test_suites_.rend()) return *test_suite;
-
-  // No.  Let's create one.
-  auto* const new_test_suite =
-      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
-
-  // Is this a death test suite?
-  if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
-                                               kDeathTestSuiteFilter)) {
-    // Yes.  Inserts the test suite after the last death test suite
-    // defined so far.  This only works when the test suites haven't
-    // been shuffled.  Otherwise we may end up running a death test
-    // after a non-death test.
-    ++last_death_test_suite_;
-    test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
-                        new_test_suite);
-  } else {
-    // No.  Appends to the end of the list.
-    test_suites_.push_back(new_test_suite);
-  }
-
-  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
-  return new_test_suite;
-}
-
-// Helpers for setting up / tearing down the given environment.  They
-// are for use in the ForEach() function.
-static void SetUpEnvironment(Environment* env) { env->SetUp(); }
-static void TearDownEnvironment(Environment* env) { env->TearDown(); }
-
-// Runs all tests in this UnitTest object, prints the result, and
-// returns true if all tests are successful.  If any exception is
-// thrown during a test, the test is considered to be failed, but the
-// rest of the tests will still be run.
-//
-// When parameterized tests are enabled, it expands and registers
-// parameterized tests first in RegisterParameterizedTests().
-// All other functions called from RunAllTests() may safely assume that
-// parameterized tests are ready to be counted and run.
-bool UnitTestImpl::RunAllTests() {
-  // True iff Google Test is initialized before RUN_ALL_TESTS() is called.
-  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
-
-  // Do not run any test if the --help flag was specified.
-  if (g_help_flag)
-    return true;
-
-  // Repeats the call to the post-flag parsing initialization in case the
-  // user didn't call InitGoogleTest.
-  PostFlagParsingInit();
-
-  // Even if sharding is not on, test runners may want to use the
-  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
-  // protocol.
-  internal::WriteToShardStatusFileIfNeeded();
-
-  // True iff we are in a subprocess for running a thread-safe-style
-  // death test.
-  bool in_subprocess_for_death_test = false;
-
-#if GTEST_HAS_DEATH_TEST
-  in_subprocess_for_death_test =
-      (internal_run_death_test_flag_.get() != nullptr);
-# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
-  if (in_subprocess_for_death_test) {
-    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
-  }
-# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
-#endif  // GTEST_HAS_DEATH_TEST
-
-  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
-                                        in_subprocess_for_death_test);
-
-  // Compares the full test names with the filter to decide which
-  // tests to run.
-  const bool has_tests_to_run = FilterTests(should_shard
-                                              ? HONOR_SHARDING_PROTOCOL
-                                              : IGNORE_SHARDING_PROTOCOL) > 0;
-
-  // Lists the tests and exits if the --gtest_list_tests flag was specified.
-  if (GTEST_FLAG(list_tests)) {
-    // This must be called *after* FilterTests() has been called.
-    ListTestsMatchingFilter();
-    return true;
-  }
-
-  random_seed_ = GTEST_FLAG(shuffle) ?
-      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
-
-  // True iff at least one test has failed.
-  bool failed = false;
-
-  TestEventListener* repeater = listeners()->repeater();
-
-  start_timestamp_ = GetTimeInMillis();
-  repeater->OnTestProgramStart(*parent_);
-
-  // How many times to repeat the tests?  We don't want to repeat them
-  // when we are inside the subprocess of a death test.
-  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
-  // Repeats forever if the repeat count is negative.
-  const bool forever = repeat < 0;
-  for (int i = 0; forever || i != repeat; i++) {
-    // We want to preserve failures generated by ad-hoc test
-    // assertions executed before RUN_ALL_TESTS().
-    ClearNonAdHocTestResult();
-
-    const TimeInMillis start = GetTimeInMillis();
-
-    // Shuffles test suites and tests if requested.
-    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
-      random()->Reseed(random_seed_);
-      // This should be done before calling OnTestIterationStart(),
-      // such that a test event listener can see the actual test order
-      // in the event.
-      ShuffleTests();
-    }
-
-    // Tells the unit test event listeners that the tests are about to start.
-    repeater->OnTestIterationStart(*parent_, i);
-
-    // Runs each test suite if there is at least one test to run.
-    if (has_tests_to_run) {
-      // Sets up all environments beforehand.
-      repeater->OnEnvironmentsSetUpStart(*parent_);
-      ForEach(environments_, SetUpEnvironment);
-      repeater->OnEnvironmentsSetUpEnd(*parent_);
-
-      // Runs the tests only if there was no fatal failure or skip triggered
-      // during global set-up.
-      if (Test::IsSkipped()) {
-        // Emit diagnostics when global set-up calls skip, as it will not be
-        // emitted by default.
-        TestResult& test_result =
-            *internal::GetUnitTestImpl()->current_test_result();
-        for (int j = 0; j < test_result.total_part_count(); ++j) {
-          const TestPartResult& test_part_result =
-              test_result.GetTestPartResult(j);
-          if (test_part_result.type() == TestPartResult::kSkip) {
-            const std::string& result = test_part_result.message();
-            printf("%s\n", result.c_str());
-          }
-        }
-        fflush(stdout);
-      } else if (!Test::HasFatalFailure()) {
-        for (int test_index = 0; test_index < total_test_suite_count();
-             test_index++) {
-          GetMutableSuiteCase(test_index)->Run();
-        }
-      }
-
-      // Tears down all environments in reverse order afterwards.
-      repeater->OnEnvironmentsTearDownStart(*parent_);
-      std::for_each(environments_.rbegin(), environments_.rend(),
-                    TearDownEnvironment);
-      repeater->OnEnvironmentsTearDownEnd(*parent_);
-    }
-
-    elapsed_time_ = GetTimeInMillis() - start;
-
-    // Tells the unit test event listener that the tests have just finished.
-    repeater->OnTestIterationEnd(*parent_, i);
-
-    // Gets the result and clears it.
-    if (!Passed()) {
-      failed = true;
-    }
-
-    // Restores the original test order after the iteration.  This
-    // allows the user to quickly repro a failure that happens in the
-    // N-th iteration without repeating the first (N - 1) iterations.
-    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
-    // case the user somehow changes the value of the flag somewhere
-    // (it's always safe to unshuffle the tests).
-    UnshuffleTests();
-
-    if (GTEST_FLAG(shuffle)) {
-      // Picks a new random seed for each iteration.
-      random_seed_ = GetNextRandomSeed(random_seed_);
-    }
-  }
-
-  repeater->OnTestProgramEnd(*parent_);
-
-  if (!gtest_is_initialized_before_run_all_tests) {
-    ColoredPrintf(
-        COLOR_RED,
-        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
-        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
-        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
-        " will start to enforce the valid usage. "
-        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
-#if GTEST_FOR_GOOGLE_
-    ColoredPrintf(COLOR_RED,
-                  "For more details, see http://wiki/Main/ValidGUnitMain.\n");
-#endif  // GTEST_FOR_GOOGLE_
-  }
-
-  return !failed;
-}
-
-// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
-// if the variable is present. If a file already exists at this location, this
-// function will write over it. If the variable is present, but the file cannot
-// be created, prints an error and exits.
-void WriteToShardStatusFileIfNeeded() {
-  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
-  if (test_shard_file != nullptr) {
-    FILE* const file = posix::FOpen(test_shard_file, "w");
-    if (file == nullptr) {
-      ColoredPrintf(COLOR_RED,
-                    "Could not write to the test shard status file \"%s\" "
-                    "specified by the %s environment variable.\n",
-                    test_shard_file, kTestShardStatusFile);
-      fflush(stdout);
-      exit(EXIT_FAILURE);
-    }
-    fclose(file);
-  }
-}
-
-// Checks whether sharding is enabled by examining the relevant
-// environment variable values. If the variables are present,
-// but inconsistent (i.e., shard_index >= total_shards), prints
-// an error and exits. If in_subprocess_for_death_test, sharding is
-// disabled because it must only be applied to the original test
-// process. Otherwise, we could filter out death tests we intended to execute.
-bool ShouldShard(const char* total_shards_env,
-                 const char* shard_index_env,
-                 bool in_subprocess_for_death_test) {
-  if (in_subprocess_for_death_test) {
-    return false;
-  }
-
-  const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
-  const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1);
-
-  if (total_shards == -1 && shard_index == -1) {
-    return false;
-  } else if (total_shards == -1 && shard_index != -1) {
-    const Message msg = Message()
-      << "Invalid environment variables: you have "
-      << kTestShardIndex << " = " << shard_index
-      << ", but have left " << kTestTotalShards << " unset.\n";
-    ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  } else if (total_shards != -1 && shard_index == -1) {
-    const Message msg = Message()
-      << "Invalid environment variables: you have "
-      << kTestTotalShards << " = " << total_shards
-      << ", but have left " << kTestShardIndex << " unset.\n";
-    ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  } else if (shard_index < 0 || shard_index >= total_shards) {
-    const Message msg = Message()
-      << "Invalid environment variables: we require 0 <= "
-      << kTestShardIndex << " < " << kTestTotalShards
-      << ", but you have " << kTestShardIndex << "=" << shard_index
-      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
-    ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  }
-
-  return total_shards > 1;
-}
-
-// Parses the environment variable var as an Int32. If it is unset,
-// returns default_val. If it is not an Int32, prints an error
-// and aborts.
-Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
-  const char* str_val = posix::GetEnv(var);
-  if (str_val == nullptr) {
-    return default_val;
-  }
-
-  Int32 result;
-  if (!ParseInt32(Message() << "The value of environment variable " << var,
-                  str_val, &result)) {
-    exit(EXIT_FAILURE);
-  }
-  return result;
-}
-
-// Given the total number of shards, the shard index, and the test id,
-// returns true iff the test should be run on this shard. The test id is
-// some arbitrary but unique non-negative integer assigned to each test
-// method. Assumes that 0 <= shard_index < total_shards.
-bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
-  return (test_id % total_shards) == shard_index;
-}
-
-// Compares the name of each test with the user-specified filter to
-// decide whether the test should be run, then records the result in
-// each TestSuite and TestInfo object.
-// If shard_tests == true, further filters tests based on sharding
-// variables in the environment - see
-// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
-// . Returns the number of tests that should run.
-int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
-  const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
-      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
-  const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
-      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
-
-  // num_runnable_tests are the number of tests that will
-  // run across all shards (i.e., match filter and are not disabled).
-  // num_selected_tests are the number of tests to be run on
-  // this shard.
-  int num_runnable_tests = 0;
-  int num_selected_tests = 0;
-  for (auto* test_suite : test_suites_) {
-    const std::string& test_suite_name = test_suite->name();
-    test_suite->set_should_run(false);
-
-    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
-      TestInfo* const test_info = test_suite->test_info_list()[j];
-      const std::string test_name(test_info->name());
-      // A test is disabled if test suite name or test name matches
-      // kDisableTestFilter.
-      const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
-                                   test_suite_name, kDisableTestFilter) ||
-                               internal::UnitTestOptions::MatchesFilter(
-                                   test_name, kDisableTestFilter);
-      test_info->is_disabled_ = is_disabled;
-
-      const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
-          test_suite_name, test_name);
-      test_info->matches_filter_ = matches_filter;
-
-      const bool is_runnable =
-          (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
-          matches_filter;
-
-      const bool is_in_another_shard =
-          shard_tests != IGNORE_SHARDING_PROTOCOL &&
-          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
-      test_info->is_in_another_shard_ = is_in_another_shard;
-      const bool is_selected = is_runnable && !is_in_another_shard;
-
-      num_runnable_tests += is_runnable;
-      num_selected_tests += is_selected;
-
-      test_info->should_run_ = is_selected;
-      test_suite->set_should_run(test_suite->should_run() || is_selected);
-    }
-  }
-  return num_selected_tests;
-}
-
-// Prints the given C-string on a single line by replacing all '\n'
-// characters with string "\\n".  If the output takes more than
-// max_length characters, only prints the first max_length characters
-// and "...".
-static void PrintOnOneLine(const char* str, int max_length) {
-  if (str != nullptr) {
-    for (int i = 0; *str != '\0'; ++str) {
-      if (i >= max_length) {
-        printf("...");
-        break;
-      }
-      if (*str == '\n') {
-        printf("\\n");
-        i += 2;
-      } else {
-        printf("%c", *str);
-        ++i;
-      }
-    }
-  }
-}
-
-// Prints the names of the tests matching the user-specified filter flag.
-void UnitTestImpl::ListTestsMatchingFilter() {
-  // Print at most this many characters for each type/value parameter.
-  const int kMaxParamLength = 250;
-
-  for (auto* test_suite : test_suites_) {
-    bool printed_test_suite_name = false;
-
-    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
-      const TestInfo* const test_info = test_suite->test_info_list()[j];
-      if (test_info->matches_filter_) {
-        if (!printed_test_suite_name) {
-          printed_test_suite_name = true;
-          printf("%s.", test_suite->name());
-          if (test_suite->type_param() != nullptr) {
-            printf("  # %s = ", kTypeParamLabel);
-            // We print the type parameter on a single line to make
-            // the output easy to parse by a program.
-            PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
-          }
-          printf("\n");
-        }
-        printf("  %s", test_info->name());
-        if (test_info->value_param() != nullptr) {
-          printf("  # %s = ", kValueParamLabel);
-          // We print the value parameter on a single line to make the
-          // output easy to parse by a program.
-          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
-        }
-        printf("\n");
-      }
-    }
-  }
-  fflush(stdout);
-  const std::string& output_format = UnitTestOptions::GetOutputFormat();
-  if (output_format == "xml" || output_format == "json") {
-    FILE* fileout = OpenFileForWriting(
-        UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
-    std::stringstream stream;
-    if (output_format == "xml") {
-      XmlUnitTestResultPrinter(
-          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
-          .PrintXmlTestsList(&stream, test_suites_);
-    } else if (output_format == "json") {
-      JsonUnitTestResultPrinter(
-          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
-          .PrintJsonTestList(&stream, test_suites_);
-    }
-    fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
-    fclose(fileout);
-  }
-}
-
-// Sets the OS stack trace getter.
-//
-// Does nothing if the input and the current OS stack trace getter are
-// the same; otherwise, deletes the old getter and makes the input the
-// current getter.
-void UnitTestImpl::set_os_stack_trace_getter(
-    OsStackTraceGetterInterface* getter) {
-  if (os_stack_trace_getter_ != getter) {
-    delete os_stack_trace_getter_;
-    os_stack_trace_getter_ = getter;
-  }
-}
-
-// Returns the current OS stack trace getter if it is not NULL;
-// otherwise, creates an OsStackTraceGetter, makes it the current
-// getter, and returns it.
-OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
-  if (os_stack_trace_getter_ == nullptr) {
-#ifdef GTEST_OS_STACK_TRACE_GETTER_
-    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
-#else
-    os_stack_trace_getter_ = new OsStackTraceGetter;
-#endif  // GTEST_OS_STACK_TRACE_GETTER_
-  }
-
-  return os_stack_trace_getter_;
-}
-
-// Returns the most specific TestResult currently running.
-TestResult* UnitTestImpl::current_test_result() {
-  if (current_test_info_ != nullptr) {
-    return &current_test_info_->result_;
-  }
-  if (current_test_suite_ != nullptr) {
-    return &current_test_suite_->ad_hoc_test_result_;
-  }
-  return &ad_hoc_test_result_;
-}
-
-// Shuffles all test suites, and the tests within each test suite,
-// making sure that death tests are still run first.
-void UnitTestImpl::ShuffleTests() {
-  // Shuffles the death test suites.
-  ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
-
-  // Shuffles the non-death test suites.
-  ShuffleRange(random(), last_death_test_suite_ + 1,
-               static_cast<int>(test_suites_.size()), &test_suite_indices_);
-
-  // Shuffles the tests inside each test suite.
-  for (auto& test_suite : test_suites_) {
-    test_suite->ShuffleTests(random());
-  }
-}
-
-// Restores the test suites and tests to their order before the first shuffle.
-void UnitTestImpl::UnshuffleTests() {
-  for (size_t i = 0; i < test_suites_.size(); i++) {
-    // Unshuffles the tests in each test suite.
-    test_suites_[i]->UnshuffleTests();
-    // Resets the index of each test suite.
-    test_suite_indices_[i] = static_cast<int>(i);
-  }
-}
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
-// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
-                                            int skip_count) {
-  // We pass skip_count + 1 to skip this wrapper function in addition
-  // to what the user really wants to skip.
-  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
-}
-
-// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
-// suppress unreachable code warnings.
-namespace {
-class ClassUniqueToAlwaysTrue {};
-}
-
-bool IsTrue(bool condition) { return condition; }
-
-bool AlwaysTrue() {
-#if GTEST_HAS_EXCEPTIONS
-  // This condition is always false so AlwaysTrue() never actually throws,
-  // but it makes the compiler think that it may throw.
-  if (IsTrue(false))
-    throw ClassUniqueToAlwaysTrue();
-#endif  // GTEST_HAS_EXCEPTIONS
-  return true;
-}
-
-// If *pstr starts with the given prefix, modifies *pstr to be right
-// past the prefix and returns true; otherwise leaves *pstr unchanged
-// and returns false.  None of pstr, *pstr, and prefix can be NULL.
-bool SkipPrefix(const char* prefix, const char** pstr) {
-  const size_t prefix_len = strlen(prefix);
-  if (strncmp(*pstr, prefix, prefix_len) == 0) {
-    *pstr += prefix_len;
-    return true;
-  }
-  return false;
-}
-
-// Parses a string as a command line flag.  The string should have
-// the format "--flag=value".  When def_optional is true, the "=value"
-// part can be omitted.
-//
-// Returns the value of the flag, or NULL if the parsing failed.
-static const char* ParseFlagValue(const char* str, const char* flag,
-                                  bool def_optional) {
-  // str and flag must not be NULL.
-  if (str == nullptr || flag == nullptr) return nullptr;
-
-  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
-  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
-  const size_t flag_len = flag_str.length();
-  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
-
-  // Skips the flag name.
-  const char* flag_end = str + flag_len;
-
-  // When def_optional is true, it's OK to not have a "=value" part.
-  if (def_optional && (flag_end[0] == '\0')) {
-    return flag_end;
-  }
-
-  // If def_optional is true and there are more characters after the
-  // flag name, or if def_optional is false, there must be a '=' after
-  // the flag name.
-  if (flag_end[0] != '=') return nullptr;
-
-  // Returns the string after "=".
-  return flag_end + 1;
-}
-
-// Parses a string for a bool flag, in the form of either
-// "--flag=value" or "--flag".
-//
-// In the former case, the value is taken as true as long as it does
-// not start with '0', 'f', or 'F'.
-//
-// In the latter case, the value is taken as true.
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, true);
-
-  // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
-
-  // Converts the string value to a bool.
-  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
-  return true;
-}
-
-// Parses a string for an Int32 flag, in the form of
-// "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, false);
-
-  // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
-
-  // Sets *value to the value of the flag.
-  return ParseInt32(Message() << "The value of flag --" << flag,
-                    value_str, value);
-}
-
-// Parses a string for a string flag, in the form of
-// "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-template <typename String>
-static bool ParseStringFlag(const char* str, const char* flag, String* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, false);
-
-  // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
-
-  // Sets *value to the value of the flag.
-  *value = value_str;
-  return true;
-}
-
-// Determines whether a string has a prefix that Google Test uses for its
-// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
-// If Google Test detects that a command line flag has its prefix but is not
-// recognized, it will print its help message. Flags starting with
-// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
-// internal flags and do not trigger the help message.
-static bool HasGoogleTestFlagPrefix(const char* str) {
-  return (SkipPrefix("--", &str) ||
-          SkipPrefix("-", &str) ||
-          SkipPrefix("/", &str)) &&
-         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
-         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
-          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
-}
-
-// Prints a string containing code-encoded text.  The following escape
-// sequences can be used in the string to control the text color:
-//
-//   @@    prints a single '@' character.
-//   @R    changes the color to red.
-//   @G    changes the color to green.
-//   @Y    changes the color to yellow.
-//   @D    changes to the default terminal text color.
-//
-static void PrintColorEncoded(const char* str) {
-  GTestColor color = COLOR_DEFAULT;  // The current color.
-
-  // Conceptually, we split the string into segments divided by escape
-  // sequences.  Then we print one segment at a time.  At the end of
-  // each iteration, the str pointer advances to the beginning of the
-  // next segment.
-  for (;;) {
-    const char* p = strchr(str, '@');
-    if (p == nullptr) {
-      ColoredPrintf(color, "%s", str);
-      return;
-    }
-
-    ColoredPrintf(color, "%s", std::string(str, p).c_str());
-
-    const char ch = p[1];
-    str = p + 2;
-    if (ch == '@') {
-      ColoredPrintf(color, "@");
-    } else if (ch == 'D') {
-      color = COLOR_DEFAULT;
-    } else if (ch == 'R') {
-      color = COLOR_RED;
-    } else if (ch == 'G') {
-      color = COLOR_GREEN;
-    } else if (ch == 'Y') {
-      color = COLOR_YELLOW;
-    } else {
-      --str;
-    }
-  }
-}
-
-static const char kColorEncodedHelpMessage[] =
-"This program contains tests written using " GTEST_NAME_ ". You can use the\n"
-"following command line flags to control its behavior:\n"
-"\n"
-"Test Selection:\n"
-"  @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n"
-"      List the names of all tests instead of running them. The name of\n"
-"      TEST(Foo, Bar) is \"Foo.Bar\".\n"
-"  @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS"
-    "[@G-@YNEGATIVE_PATTERNS]@D\n"
-"      Run only the tests whose name matches one of the positive patterns but\n"
-"      none of the negative patterns. '?' matches any single character; '*'\n"
-"      matches any substring; ':' separates two patterns.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n"
-"      Run all disabled tests too.\n"
-"\n"
-"Test Execution:\n"
-"  @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n"
-"      Run the tests repeatedly; use a negative count to repeat forever.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n"
-"      Randomize tests' orders on every iteration.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n"
-"      Random number seed to use for shuffling test orders (between 1 and\n"
-"      99999, or 0 to use a seed based on the current time).\n"
-"\n"
-"Test Output:\n"
-"  @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
-"      Enable/disable colored output. The default is @Gauto@D.\n"
-"  -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n"
-"      Don't print the elapsed time of each test.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G"
-    GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n"
-"      Generate a JSON or XML report in the given directory or with the given\n"
-"      file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
-# if GTEST_CAN_STREAM_RESULTS_
-"  @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n"
-"      Stream test results to the given server.\n"
-# endif  // GTEST_CAN_STREAM_RESULTS_
-"\n"
-"Assertion Behavior:\n"
-# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
-"  @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
-"      Set the default death test style.\n"
-# endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
-"  @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n"
-"      Turn assertion failures into debugger break-points.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n"
-"      Turn assertion failures into C++ exceptions for use by an external\n"
-"      test framework.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n"
-"      Do not report exceptions as test failures. Instead, allow them\n"
-"      to crash the program or throw a pop-up (on Windows).\n"
-"\n"
-"Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set "
-    "the corresponding\n"
-"environment variable of a flag (all letters in upper-case). For example, to\n"
-"disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_
-    "color=no@D or set\n"
-"the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n"
-"\n"
-"For more information, please read the " GTEST_NAME_ " documentation at\n"
-"@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n"
-"(not one in your own code or tests), please report it to\n"
-"@G<" GTEST_DEV_EMAIL_ ">@D.\n";
-
-static bool ParseGoogleTestFlag(const char* const arg) {
-  return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
-                       &GTEST_FLAG(also_run_disabled_tests)) ||
-      ParseBoolFlag(arg, kBreakOnFailureFlag,
-                    &GTEST_FLAG(break_on_failure)) ||
-      ParseBoolFlag(arg, kCatchExceptionsFlag,
-                    &GTEST_FLAG(catch_exceptions)) ||
-      ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
-      ParseStringFlag(arg, kDeathTestStyleFlag,
-                      &GTEST_FLAG(death_test_style)) ||
-      ParseBoolFlag(arg, kDeathTestUseFork,
-                    &GTEST_FLAG(death_test_use_fork)) ||
-      ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
-      ParseStringFlag(arg, kInternalRunDeathTestFlag,
-                      &GTEST_FLAG(internal_run_death_test)) ||
-      ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
-      ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
-      ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
-      ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
-      ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
-      ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
-      ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
-      ParseInt32Flag(arg, kStackTraceDepthFlag,
-                     &GTEST_FLAG(stack_trace_depth)) ||
-      ParseStringFlag(arg, kStreamResultToFlag,
-                      &GTEST_FLAG(stream_result_to)) ||
-      ParseBoolFlag(arg, kThrowOnFailureFlag,
-                    &GTEST_FLAG(throw_on_failure));
-}
-
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-static void LoadFlagsFromFile(const std::string& path) {
-  FILE* flagfile = posix::FOpen(path.c_str(), "r");
-  if (!flagfile) {
-    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
-                      << "\"";
-  }
-  std::string contents(ReadEntireFile(flagfile));
-  posix::FClose(flagfile);
-  std::vector<std::string> lines;
-  SplitString(contents, '\n', &lines);
-  for (size_t i = 0; i < lines.size(); ++i) {
-    if (lines[i].empty())
-      continue;
-    if (!ParseGoogleTestFlag(lines[i].c_str()))
-      g_help_flag = true;
-  }
-}
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.  The type parameter CharType can be
-// instantiated to either char or wchar_t.
-template <typename CharType>
-void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
-  for (int i = 1; i < *argc; i++) {
-    const std::string arg_string = StreamableToString(argv[i]);
-    const char* const arg = arg_string.c_str();
-
-    using internal::ParseBoolFlag;
-    using internal::ParseInt32Flag;
-    using internal::ParseStringFlag;
-
-    bool remove_flag = false;
-    if (ParseGoogleTestFlag(arg)) {
-      remove_flag = true;
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
-      LoadFlagsFromFile(GTEST_FLAG(flagfile));
-      remove_flag = true;
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-    } else if (arg_string == "--help" || arg_string == "-h" ||
-               arg_string == "-?" || arg_string == "/?" ||
-               HasGoogleTestFlagPrefix(arg)) {
-      // Both help flag and unrecognized Google Test flags (excluding
-      // internal ones) trigger help display.
-      g_help_flag = true;
-    }
-
-    if (remove_flag) {
-      // Shift the remainder of the argv list left by one.  Note
-      // that argv has (*argc + 1) elements, the last one always being
-      // NULL.  The following loop moves the trailing NULL element as
-      // well.
-      for (int j = i; j != *argc; j++) {
-        argv[j] = argv[j + 1];
-      }
-
-      // Decrements the argument count.
-      (*argc)--;
-
-      // We also need to decrement the iterator as we just removed
-      // an element.
-      i--;
-    }
-  }
-
-  if (g_help_flag) {
-    // We print the help here instead of in RUN_ALL_TESTS(), as the
-    // latter may not be called at all if the user is using Google
-    // Test with another testing framework.
-    PrintColorEncoded(kColorEncodedHelpMessage);
-  }
-}
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.
-void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
-  ParseGoogleTestFlagsOnlyImpl(argc, argv);
-
-  // Fix the value of *_NSGetArgc() on macOS, but iff
-  // *_NSGetArgv() == argv
-  // Only applicable to char** version of argv
-#if GTEST_OS_MAC
-#ifndef GTEST_OS_IOS
-  if (*_NSGetArgv() == argv) {
-    *_NSGetArgc() = *argc;
-  }
-#endif
-#endif
-}
-void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
-  ParseGoogleTestFlagsOnlyImpl(argc, argv);
-}
-
-// The internal implementation of InitGoogleTest().
-//
-// The type parameter CharType can be instantiated to either char or
-// wchar_t.
-template <typename CharType>
-void InitGoogleTestImpl(int* argc, CharType** argv) {
-  // We don't want to run the initialization code twice.
-  if (GTestIsInitialized()) return;
-
-  if (*argc <= 0) return;
-
-  g_argvs.clear();
-  for (int i = 0; i != *argc; i++) {
-    g_argvs.push_back(StreamableToString(argv[i]));
-  }
-
-#if GTEST_HAS_ABSL
-  absl::InitializeSymbolizer(g_argvs[0].c_str());
-#endif  // GTEST_HAS_ABSL
-
-  ParseGoogleTestFlagsOnly(argc, argv);
-  GetUnitTestImpl()->PostFlagParsingInit();
-}
-
-}  // namespace internal
-
-// Initializes Google Test.  This must be called before calling
-// RUN_ALL_TESTS().  In particular, it parses a command line for the
-// flags that Google Test recognizes.  Whenever a Google Test flag is
-// seen, it is removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Test flag variables are
-// updated.
-//
-// Calling the function for the second time has no user-visible effect.
-void InitGoogleTest(int* argc, char** argv) {
-#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  internal::InitGoogleTestImpl(argc, argv);
-#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-}
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-void InitGoogleTest(int* argc, wchar_t** argv) {
-#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  internal::InitGoogleTestImpl(argc, argv);
-#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-}
-
-// This overloaded version can be used on Arduino/embedded platforms where
-// there is no argc/argv.
-void InitGoogleTest() {
-  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
-  int argc = 1;
-  const auto arg0 = "dummy";
-  char* argv0 = const_cast<char*>(arg0);
-  char** argv = &argv0;
-
-#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  internal::InitGoogleTestImpl(&argc, argv);
-#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-}
-
-std::string TempDir() {
-#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
-  return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
-#endif
-
-#if GTEST_OS_WINDOWS_MOBILE
-  return "\\temp\\";
-#elif GTEST_OS_WINDOWS
-  const char* temp_dir = internal::posix::GetEnv("TEMP");
-  if (temp_dir == nullptr || temp_dir[0] == '\0')
-    return "\\temp\\";
-  else if (temp_dir[strlen(temp_dir) - 1] == '\\')
-    return temp_dir;
-  else
-    return std::string(temp_dir) + "\\";
-#elif GTEST_OS_LINUX_ANDROID
-  return "/sdcard/";
-#else
-  return "/tmp/";
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-// Class ScopedTrace
-
-// Pushes the given source file location and message onto a per-thread
-// trace stack maintained by Google Test.
-void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
-  internal::TraceInfo trace;
-  trace.file = file;
-  trace.line = line;
-  trace.message.swap(message);
-
-  UnitTest::GetInstance()->PushGTestTrace(trace);
-}
-
-// Pops the info pushed by the c'tor.
-ScopedTrace::~ScopedTrace()
-    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
-  UnitTest::GetInstance()->PopGTestTrace();
-}
-
-}  // namespace testing
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// This file implements death tests.
-
-
-#include <utility>
-
-
-#if GTEST_HAS_DEATH_TEST
-
-# if GTEST_OS_MAC
-#  include <crt_externs.h>
-# endif  // GTEST_OS_MAC
-
-# include <errno.h>
-# include <fcntl.h>
-# include <limits.h>
-
-# if GTEST_OS_LINUX
-#  include <signal.h>
-# endif  // GTEST_OS_LINUX
-
-# include <stdarg.h>
-
-# if GTEST_OS_WINDOWS
-#  include <windows.h>
-# else
-#  include <sys/mman.h>
-#  include <sys/wait.h>
-# endif  // GTEST_OS_WINDOWS
-
-# if GTEST_OS_QNX
-#  include <spawn.h>
-# endif  // GTEST_OS_QNX
-
-# if GTEST_OS_FUCHSIA
-#  include <lib/fdio/fd.h>
-#  include <lib/fdio/io.h>
-#  include <lib/fdio/spawn.h>
-#  include <lib/zx/port.h>
-#  include <lib/zx/process.h>
-#  include <lib/zx/socket.h>
-#  include <zircon/processargs.h>
-#  include <zircon/syscalls.h>
-#  include <zircon/syscalls/policy.h>
-#  include <zircon/syscalls/port.h>
-# endif  // GTEST_OS_FUCHSIA
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-
-namespace testing {
-
-// Constants.
-
-// The default death test style.
-//
-// This is defined in internal/gtest-port.h as "fast", but can be overridden by
-// a definition in internal/custom/gtest-port.h. The recommended value, which is
-// used internally at Google, is "threadsafe".
-static const char kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE;
-
-GTEST_DEFINE_string_(
-    death_test_style,
-    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
-    "Indicates how to run a death test in a forked child process: "
-    "\"threadsafe\" (child process re-executes the test binary "
-    "from the beginning, running only the specific death test) or "
-    "\"fast\" (child process runs the death test immediately "
-    "after forking).");
-
-GTEST_DEFINE_bool_(
-    death_test_use_fork,
-    internal::BoolFromGTestEnv("death_test_use_fork", false),
-    "Instructs to use fork()/_exit() instead of clone() in death tests. "
-    "Ignored and always uses fork() on POSIX systems where clone() is not "
-    "implemented. Useful when running under valgrind or similar tools if "
-    "those do not support clone(). Valgrind 3.3.1 will just fail if "
-    "it sees an unsupported combination of clone() flags. "
-    "It is not recommended to use this flag w/o valgrind though it will "
-    "work in 99% of the cases. Once valgrind is fixed, this flag will "
-    "most likely be removed.");
-
-namespace internal {
-GTEST_DEFINE_string_(
-    internal_run_death_test, "",
-    "Indicates the file, line number, temporal index of "
-    "the single death test to run, and a file descriptor to "
-    "which a success code may be sent, all separated by "
-    "the '|' characters.  This flag is specified if and only if the current "
-    "process is a sub-process launched for running a thread-safe "
-    "death test.  FOR INTERNAL USE ONLY.");
-}  // namespace internal
-
-#if GTEST_HAS_DEATH_TEST
-
-namespace internal {
-
-// Valid only for fast death tests. Indicates the code is running in the
-// child process of a fast style death test.
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
-static bool g_in_fast_death_test_child = false;
-# endif
-
-// Returns a Boolean value indicating whether the caller is currently
-// executing in the context of the death test child process.  Tools such as
-// Valgrind heap checkers may need this to modify their behavior in death
-// tests.  IMPORTANT: This is an internal utility.  Using it may break the
-// implementation of death tests.  User code MUST NOT use it.
-bool InDeathTestChild() {
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
-
-  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
-  // of the death_test_style flag.
-  return !GTEST_FLAG(internal_run_death_test).empty();
-
-# else
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe")
-    return !GTEST_FLAG(internal_run_death_test).empty();
-  else
-    return g_in_fast_death_test_child;
-#endif
-}
-
-}  // namespace internal
-
-// ExitedWithCode constructor.
-ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
-}
-
-// ExitedWithCode function-call operator.
-bool ExitedWithCode::operator()(int exit_status) const {
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
-
-  return exit_status == exit_code_;
-
-# else
-
-  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
-
-# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
-}
-
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
-// KilledBySignal constructor.
-KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
-}
-
-// KilledBySignal function-call operator.
-bool KilledBySignal::operator()(int exit_status) const {
-#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
-  {
-    bool result;
-    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
-      return result;
-    }
-  }
-#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
-  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
-}
-# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
-
-namespace internal {
-
-// Utilities needed for death tests.
-
-// Generates a textual description of a given exit code, in the format
-// specified by wait(2).
-static std::string ExitSummary(int exit_code) {
-  Message m;
-
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
-
-  m << "Exited with exit status " << exit_code;
-
-# else
-
-  if (WIFEXITED(exit_code)) {
-    m << "Exited with exit status " << WEXITSTATUS(exit_code);
-  } else if (WIFSIGNALED(exit_code)) {
-    m << "Terminated by signal " << WTERMSIG(exit_code);
-  }
-#  ifdef WCOREDUMP
-  if (WCOREDUMP(exit_code)) {
-    m << " (core dumped)";
-  }
-#  endif
-# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
-
-  return m.GetString();
-}
-
-// Returns true if exit_status describes a process that was terminated
-// by a signal, or exited normally with a nonzero exit code.
-bool ExitedUnsuccessfully(int exit_status) {
-  return !ExitedWithCode(0)(exit_status);
-}
-
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
-// Generates a textual failure message when a death test finds more than
-// one thread running, or cannot determine the number of threads, prior
-// to executing the given statement.  It is the responsibility of the
-// caller not to pass a thread_count of 1.
-static std::string DeathTestThreadWarning(size_t thread_count) {
-  Message msg;
-  msg << "Death tests use fork(), which is unsafe particularly"
-      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
-  if (thread_count == 0) {
-    msg << "couldn't detect the number of threads.";
-  } else {
-    msg << "detected " << thread_count << " threads.";
-  }
-  msg << " See "
-         "https://github.com/google/googletest/blob/master/googletest/docs/"
-         "advanced.md#death-tests-and-threads"
-      << " for more explanation and suggested solutions, especially if"
-      << " this is the last message you see before your test times out.";
-  return msg.GetString();
-}
-# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
-
-// Flag characters for reporting a death test that did not die.
-static const char kDeathTestLived = 'L';
-static const char kDeathTestReturned = 'R';
-static const char kDeathTestThrew = 'T';
-static const char kDeathTestInternalError = 'I';
-
-#if GTEST_OS_FUCHSIA
-
-// File descriptor used for the pipe in the child process.
-static const int kFuchsiaReadPipeFd = 3;
-
-#endif
-
-// An enumeration describing all of the possible ways that a death test can
-// conclude.  DIED means that the process died while executing the test
-// code; LIVED means that process lived beyond the end of the test code;
-// RETURNED means that the test statement attempted to execute a return
-// statement, which is not allowed; THREW means that the test statement
-// returned control by throwing an exception.  IN_PROGRESS means the test
-// has not yet concluded.
-enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
-
-// Routine for aborting the program which is safe to call from an
-// exec-style death test child process, in which case the error
-// message is propagated back to the parent process.  Otherwise, the
-// message is simply printed to stderr.  In either case, the program
-// then exits with status 1.
-static void DeathTestAbort(const std::string& message) {
-  // On a POSIX system, this function may be called from a threadsafe-style
-  // death test child process, which operates on a very small stack.  Use
-  // the heap for any additional non-minuscule memory requirements.
-  const InternalRunDeathTestFlag* const flag =
-      GetUnitTestImpl()->internal_run_death_test_flag();
-  if (flag != nullptr) {
-    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
-    fputc(kDeathTestInternalError, parent);
-    fprintf(parent, "%s", message.c_str());
-    fflush(parent);
-    _exit(1);
-  } else {
-    fprintf(stderr, "%s", message.c_str());
-    fflush(stderr);
-    posix::Abort();
-  }
-}
-
-// A replacement for CHECK that calls DeathTestAbort if the assertion
-// fails.
-# define GTEST_DEATH_TEST_CHECK_(expression) \
-  do { \
-    if (!::testing::internal::IsTrue(expression)) { \
-      DeathTestAbort( \
-          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
-          + ::testing::internal::StreamableToString(__LINE__) + ": " \
-          + #expression); \
-    } \
-  } while (::testing::internal::AlwaysFalse())
-
-// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
-// evaluating any system call that fulfills two conditions: it must return
-// -1 on failure, and set errno to EINTR when it is interrupted and
-// should be tried again.  The macro expands to a loop that repeatedly
-// evaluates the expression as long as it evaluates to -1 and sets
-// errno to EINTR.  If the expression evaluates to -1 but errno is
-// something other than EINTR, DeathTestAbort is called.
-# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
-  do { \
-    int gtest_retval; \
-    do { \
-      gtest_retval = (expression); \
-    } while (gtest_retval == -1 && errno == EINTR); \
-    if (gtest_retval == -1) { \
-      DeathTestAbort( \
-          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
-          + ::testing::internal::StreamableToString(__LINE__) + ": " \
-          + #expression + " != -1"); \
-    } \
-  } while (::testing::internal::AlwaysFalse())
-
-// Returns the message describing the last system error in errno.
-std::string GetLastErrnoDescription() {
-    return errno == 0 ? "" : posix::StrError(errno);
-}
-
-// This is called from a death test parent process to read a failure
-// message from the death test child process and log it with the FATAL
-// severity. On Windows, the message is read from a pipe handle. On other
-// platforms, it is read from a file descriptor.
-static void FailFromInternalError(int fd) {
-  Message error;
-  char buffer[256];
-  int num_read;
-
-  do {
-    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
-      buffer[num_read] = '\0';
-      error << buffer;
-    }
-  } while (num_read == -1 && errno == EINTR);
-
-  if (num_read == 0) {
-    GTEST_LOG_(FATAL) << error.GetString();
-  } else {
-    const int last_error = errno;
-    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
-                      << GetLastErrnoDescription() << " [" << last_error << "]";
-  }
-}
-
-// Death test constructor.  Increments the running death test count
-// for the current test.
-DeathTest::DeathTest() {
-  TestInfo* const info = GetUnitTestImpl()->current_test_info();
-  if (info == nullptr) {
-    DeathTestAbort("Cannot run a death test outside of a TEST or "
-                   "TEST_F construct");
-  }
-}
-
-// Creates and returns a death test by dispatching to the current
-// death test factory.
-bool DeathTest::Create(const char* statement,
-                       Matcher<const std::string&> matcher, const char* file,
-                       int line, DeathTest** test) {
-  return GetUnitTestImpl()->death_test_factory()->Create(
-      statement, std::move(matcher), file, line, test);
-}
-
-const char* DeathTest::LastMessage() {
-  return last_death_test_message_.c_str();
-}
-
-void DeathTest::set_last_death_test_message(const std::string& message) {
-  last_death_test_message_ = message;
-}
-
-std::string DeathTest::last_death_test_message_;
-
-// Provides cross platform implementation for some death functionality.
-class DeathTestImpl : public DeathTest {
- protected:
-  DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher)
-      : statement_(a_statement),
-        matcher_(std::move(matcher)),
-        spawned_(false),
-        status_(-1),
-        outcome_(IN_PROGRESS),
-        read_fd_(-1),
-        write_fd_(-1) {}
-
-  // read_fd_ is expected to be closed and cleared by a derived class.
-  ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
-
-  void Abort(AbortReason reason) override;
-  bool Passed(bool status_ok) override;
-
-  const char* statement() const { return statement_; }
-  bool spawned() const { return spawned_; }
-  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
-  int status() const { return status_; }
-  void set_status(int a_status) { status_ = a_status; }
-  DeathTestOutcome outcome() const { return outcome_; }
-  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
-  int read_fd() const { return read_fd_; }
-  void set_read_fd(int fd) { read_fd_ = fd; }
-  int write_fd() const { return write_fd_; }
-  void set_write_fd(int fd) { write_fd_ = fd; }
-
-  // Called in the parent process only. Reads the result code of the death
-  // test child process via a pipe, interprets it to set the outcome_
-  // member, and closes read_fd_.  Outputs diagnostics and terminates in
-  // case of unexpected codes.
-  void ReadAndInterpretStatusByte();
-
-  // Returns stderr output from the child process.
-  virtual std::string GetErrorLogs();
-
- private:
-  // The textual content of the code this object is testing.  This class
-  // doesn't own this string and should not attempt to delete it.
-  const char* const statement_;
-  // A matcher that's expected to match the stderr output by the child process.
-  Matcher<const std::string&> matcher_;
-  // True if the death test child process has been successfully spawned.
-  bool spawned_;
-  // The exit status of the child process.
-  int status_;
-  // How the death test concluded.
-  DeathTestOutcome outcome_;
-  // Descriptor to the read end of the pipe to the child process.  It is
-  // always -1 in the child process.  The child keeps its write end of the
-  // pipe in write_fd_.
-  int read_fd_;
-  // Descriptor to the child's write end of the pipe to the parent process.
-  // It is always -1 in the parent process.  The parent keeps its end of the
-  // pipe in read_fd_.
-  int write_fd_;
-};
-
-// Called in the parent process only. Reads the result code of the death
-// test child process via a pipe, interprets it to set the outcome_
-// member, and closes read_fd_.  Outputs diagnostics and terminates in
-// case of unexpected codes.
-void DeathTestImpl::ReadAndInterpretStatusByte() {
-  char flag;
-  int bytes_read;
-
-  // The read() here blocks until data is available (signifying the
-  // failure of the death test) or until the pipe is closed (signifying
-  // its success), so it's okay to call this in the parent before
-  // the child process has exited.
-  do {
-    bytes_read = posix::Read(read_fd(), &flag, 1);
-  } while (bytes_read == -1 && errno == EINTR);
-
-  if (bytes_read == 0) {
-    set_outcome(DIED);
-  } else if (bytes_read == 1) {
-    switch (flag) {
-      case kDeathTestReturned:
-        set_outcome(RETURNED);
-        break;
-      case kDeathTestThrew:
-        set_outcome(THREW);
-        break;
-      case kDeathTestLived:
-        set_outcome(LIVED);
-        break;
-      case kDeathTestInternalError:
-        FailFromInternalError(read_fd());  // Does not return.
-        break;
-      default:
-        GTEST_LOG_(FATAL) << "Death test child process reported "
-                          << "unexpected status byte ("
-                          << static_cast<unsigned int>(flag) << ")";
-    }
-  } else {
-    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
-                      << GetLastErrnoDescription();
-  }
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
-  set_read_fd(-1);
-}
-
-std::string DeathTestImpl::GetErrorLogs() {
-  return GetCapturedStderr();
-}
-
-// Signals that the death test code which should have exited, didn't.
-// Should be called only in a death test child process.
-// Writes a status byte to the child's status file descriptor, then
-// calls _exit(1).
-void DeathTestImpl::Abort(AbortReason reason) {
-  // The parent process considers the death test to be a failure if
-  // it finds any data in our pipe.  So, here we write a single flag byte
-  // to the pipe, then exit.
-  const char status_ch =
-      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
-      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
-
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
-  // We are leaking the descriptor here because on some platforms (i.e.,
-  // when built as Windows DLL), destructors of global objects will still
-  // run after calling _exit(). On such systems, write_fd_ will be
-  // indirectly closed from the destructor of UnitTestImpl, causing double
-  // close if it is also closed here. On debug configurations, double close
-  // may assert. As there are no in-process buffers to flush here, we are
-  // relying on the OS to close the descriptor after the process terminates
-  // when the destructors are not run.
-  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
-}
-
-// Returns an indented copy of stderr output for a death test.
-// This makes distinguishing death test output lines from regular log lines
-// much easier.
-static ::std::string FormatDeathTestOutput(const ::std::string& output) {
-  ::std::string ret;
-  for (size_t at = 0; ; ) {
-    const size_t line_end = output.find('\n', at);
-    ret += "[  DEATH   ] ";
-    if (line_end == ::std::string::npos) {
-      ret += output.substr(at);
-      break;
-    }
-    ret += output.substr(at, line_end + 1 - at);
-    at = line_end + 1;
-  }
-  return ret;
-}
-
-// Assesses the success or failure of a death test, using both private
-// members which have previously been set, and one argument:
-//
-// Private data members:
-//   outcome:  An enumeration describing how the death test
-//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
-//             fails in the latter three cases.
-//   status:   The exit status of the child process. On *nix, it is in the
-//             in the format specified by wait(2). On Windows, this is the
-//             value supplied to the ExitProcess() API or a numeric code
-//             of the exception that terminated the program.
-//   matcher_: A matcher that's expected to match the stderr output by the child
-//             process.
-//
-// Argument:
-//   status_ok: true if exit_status is acceptable in the context of
-//              this particular death test, which fails if it is false
-//
-// Returns true iff all of the above conditions are met.  Otherwise, the
-// first failing condition, in the order given above, is the one that is
-// reported. Also sets the last death test message string.
-bool DeathTestImpl::Passed(bool status_ok) {
-  if (!spawned())
-    return false;
-
-  const std::string error_message = GetErrorLogs();
-
-  bool success = false;
-  Message buffer;
-
-  buffer << "Death test: " << statement() << "\n";
-  switch (outcome()) {
-    case LIVED:
-      buffer << "    Result: failed to die.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case THREW:
-      buffer << "    Result: threw an exception.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case RETURNED:
-      buffer << "    Result: illegal return in test statement.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case DIED:
-      if (status_ok) {
-        if (matcher_.Matches(error_message)) {
-          success = true;
-        } else {
-          std::ostringstream stream;
-          matcher_.DescribeTo(&stream);
-          buffer << "    Result: died but not with expected error.\n"
-                 << "  Expected: " << stream.str() << "\n"
-                 << "Actual msg:\n"
-                 << FormatDeathTestOutput(error_message);
-        }
-      } else {
-        buffer << "    Result: died but not with expected exit code:\n"
-               << "            " << ExitSummary(status()) << "\n"
-               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
-      }
-      break;
-    case IN_PROGRESS:
-    default:
-      GTEST_LOG_(FATAL)
-          << "DeathTest::Passed somehow called before conclusion of test";
-  }
-
-  DeathTest::set_last_death_test_message(buffer.GetString());
-  return success;
-}
-
-# if GTEST_OS_WINDOWS
-// WindowsDeathTest implements death tests on Windows. Due to the
-// specifics of starting new processes on Windows, death tests there are
-// always threadsafe, and Google Test considers the
-// --gtest_death_test_style=fast setting to be equivalent to
-// --gtest_death_test_style=threadsafe there.
-//
-// A few implementation notes:  Like the Linux version, the Windows
-// implementation uses pipes for child-to-parent communication. But due to
-// the specifics of pipes on Windows, some extra steps are required:
-//
-// 1. The parent creates a communication pipe and stores handles to both
-//    ends of it.
-// 2. The parent starts the child and provides it with the information
-//    necessary to acquire the handle to the write end of the pipe.
-// 3. The child acquires the write end of the pipe and signals the parent
-//    using a Windows event.
-// 4. Now the parent can release the write end of the pipe on its side. If
-//    this is done before step 3, the object's reference count goes down to
-//    0 and it is destroyed, preventing the child from acquiring it. The
-//    parent now has to release it, or read operations on the read end of
-//    the pipe will not return when the child terminates.
-// 5. The parent reads child's output through the pipe (outcome code and
-//    any possible error messages) from the pipe, and its stderr and then
-//    determines whether to fail the test.
-//
-// Note: to distinguish Win32 API calls from the local method and function
-// calls, the former are explicitly resolved in the global namespace.
-//
-class WindowsDeathTest : public DeathTestImpl {
- public:
-  WindowsDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
-                   const char* file, int line)
-      : DeathTestImpl(a_statement, std::move(matcher)),
-        file_(file),
-        line_(line) {}
-
-  // All of these virtual functions are inherited from DeathTest.
-  virtual int Wait();
-  virtual TestRole AssumeRole();
-
- private:
-  // The name of the file in which the death test is located.
-  const char* const file_;
-  // The line number on which the death test is located.
-  const int line_;
-  // Handle to the write end of the pipe to the child process.
-  AutoHandle write_handle_;
-  // Child process handle.
-  AutoHandle child_handle_;
-  // Event the child process uses to signal the parent that it has
-  // acquired the handle to the write end of the pipe. After seeing this
-  // event the parent can release its own handles to make sure its
-  // ReadFile() calls return when the child terminates.
-  AutoHandle event_handle_;
-};
-
-// Waits for the child in a death test to exit, returning its exit
-// status, or 0 if no child process exists.  As a side effect, sets the
-// outcome data member.
-int WindowsDeathTest::Wait() {
-  if (!spawned())
-    return 0;
-
-  // Wait until the child either signals that it has acquired the write end
-  // of the pipe or it dies.
-  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
-  switch (::WaitForMultipleObjects(2,
-                                   wait_handles,
-                                   FALSE,  // Waits for any of the handles.
-                                   INFINITE)) {
-    case WAIT_OBJECT_0:
-    case WAIT_OBJECT_0 + 1:
-      break;
-    default:
-      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
-  }
-
-  // The child has acquired the write end of the pipe or exited.
-  // We release the handle on our side and continue.
-  write_handle_.Reset();
-  event_handle_.Reset();
-
-  ReadAndInterpretStatusByte();
-
-  // Waits for the child process to exit if it haven't already. This
-  // returns immediately if the child has already exited, regardless of
-  // whether previous calls to WaitForMultipleObjects synchronized on this
-  // handle or not.
-  GTEST_DEATH_TEST_CHECK_(
-      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
-                                             INFINITE));
-  DWORD status_code;
-  GTEST_DEATH_TEST_CHECK_(
-      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
-  child_handle_.Reset();
-  set_status(static_cast<int>(status_code));
-  return status();
-}
-
-// The AssumeRole process for a Windows death test.  It creates a child
-// process with the same executable as the current process to run the
-// death test.  The child process is given the --gtest_filter and
-// --gtest_internal_run_death_test flags such that it knows to run the
-// current death test only.
-DeathTest::TestRole WindowsDeathTest::AssumeRole() {
-  const UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const TestInfo* const info = impl->current_test_info();
-  const int death_test_index = info->result()->death_test_count();
-
-  if (flag != nullptr) {
-    // ParseInternalRunDeathTestFlag() has performed all the necessary
-    // processing.
-    set_write_fd(flag->write_fd());
-    return EXECUTE_TEST;
-  }
-
-  // WindowsDeathTest uses an anonymous pipe to communicate results of
-  // a death test.
-  SECURITY_ATTRIBUTES handles_are_inheritable = {sizeof(SECURITY_ATTRIBUTES),
-                                                 nullptr, TRUE};
-  HANDLE read_handle, write_handle;
-  GTEST_DEATH_TEST_CHECK_(
-      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
-                   0)  // Default buffer size.
-      != FALSE);
-  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
-                                O_RDONLY));
-  write_handle_.Reset(write_handle);
-  event_handle_.Reset(::CreateEvent(
-      &handles_are_inheritable,
-      TRUE,       // The event will automatically reset to non-signaled state.
-      FALSE,      // The initial state is non-signalled.
-      nullptr));  // The even is unnamed.
-  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr);
-  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
-      "=" + file_ + "|" + StreamableToString(line_) + "|" +
-      StreamableToString(death_test_index) + "|" +
-      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
-      // size_t has the same width as pointers on both 32-bit and 64-bit
-      // Windows platforms.
-      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
-      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
-      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
-
-  char executable_path[_MAX_PATH + 1];  // NOLINT
-  GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr,
-                                                                executable_path,
-                                                                _MAX_PATH));
-
-  std::string command_line =
-      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
-      internal_flag + "\"";
-
-  DeathTest::set_last_death_test_message("");
-
-  CaptureStderr();
-  // Flush the log buffers since the log streams are shared with the child.
-  FlushInfoLog();
-
-  // The child process will share the standard handles with the parent.
-  STARTUPINFOA startup_info;
-  memset(&startup_info, 0, sizeof(STARTUPINFO));
-  startup_info.dwFlags = STARTF_USESTDHANDLES;
-  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
-  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
-  startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
-
-  PROCESS_INFORMATION process_info;
-  GTEST_DEATH_TEST_CHECK_(
-      ::CreateProcessA(
-          executable_path, const_cast<char*>(command_line.c_str()),
-          nullptr,  // Retuned process handle is not inheritable.
-          nullptr,  // Retuned thread handle is not inheritable.
-          TRUE,  // Child inherits all inheritable handles (for write_handle_).
-          0x0,   // Default creation flags.
-          nullptr,  // Inherit the parent's environment.
-          UnitTest::GetInstance()->original_working_dir(), &startup_info,
-          &process_info) != FALSE);
-  child_handle_.Reset(process_info.hProcess);
-  ::CloseHandle(process_info.hThread);
-  set_spawned(true);
-  return OVERSEE_TEST;
-}
-
-# elif GTEST_OS_FUCHSIA
-
-class FuchsiaDeathTest : public DeathTestImpl {
- public:
-  FuchsiaDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
-                   const char* file, int line)
-      : DeathTestImpl(a_statement, std::move(matcher)),
-        file_(file),
-        line_(line) {}
-
-  // All of these virtual functions are inherited from DeathTest.
-  int Wait() override;
-  TestRole AssumeRole() override;
-  std::string GetErrorLogs() override;
-
- private:
-  // The name of the file in which the death test is located.
-  const char* const file_;
-  // The line number on which the death test is located.
-  const int line_;
-  // The stderr data captured by the child process.
-  std::string captured_stderr_;
-
-  zx::process child_process_;
-  zx::port port_;
-  zx::socket stderr_socket_;
-};
-
-// Utility class for accumulating command-line arguments.
-class Arguments {
- public:
-  Arguments() { args_.push_back(nullptr); }
-
-  ~Arguments() {
-    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
-         ++i) {
-      free(*i);
-    }
-  }
-  void AddArgument(const char* argument) {
-    args_.insert(args_.end() - 1, posix::StrDup(argument));
-  }
-
-  template <typename Str>
-  void AddArguments(const ::std::vector<Str>& arguments) {
-    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
-         i != arguments.end();
-         ++i) {
-      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
-    }
-  }
-  char* const* Argv() {
-    return &args_[0];
-  }
-
-  int size() {
-    return args_.size() - 1;
-  }
-
- private:
-  std::vector<char*> args_;
-};
-
-// Waits for the child in a death test to exit, returning its exit
-// status, or 0 if no child process exists.  As a side effect, sets the
-// outcome data member.
-int FuchsiaDeathTest::Wait() {
-  const int kProcessKey = 0;
-  const int kSocketKey = 1;
-
-  if (!spawned())
-    return 0;
-
-  // Register to wait for the child process to terminate.
-  zx_status_t status_zx;
-  status_zx = child_process_.wait_async(
-      port_, kProcessKey, ZX_PROCESS_TERMINATED, ZX_WAIT_ASYNC_ONCE);
-  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-  // Register to wait for the socket to be readable or closed.
-  status_zx = stderr_socket_.wait_async(
-      port_, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED,
-      ZX_WAIT_ASYNC_REPEATING);
-  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-  bool process_terminated = false;
-  bool socket_closed = false;
-  do {
-    zx_port_packet_t packet = {};
-    status_zx = port_.wait(zx::time::infinite(), &packet);
-    GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-    if (packet.key == kProcessKey) {
-      if (ZX_PKT_IS_EXCEPTION(packet.type)) {
-        // Process encountered an exception. Kill it directly rather than
-        // letting other handlers process the event. We will get a second
-        // kProcessKey event when the process actually terminates.
-        status_zx = child_process_.kill();
-        GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-      } else {
-        // Process terminated.
-        GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
-        GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_PROCESS_TERMINATED);
-        process_terminated = true;
-      }
-    } else if (packet.key == kSocketKey) {
-      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_REP(packet.type));
-      if (packet.signal.observed & ZX_SOCKET_READABLE) {
-        // Read data from the socket.
-        constexpr size_t kBufferSize = 1024;
-        do {
-          size_t old_length = captured_stderr_.length();
-          size_t bytes_read = 0;
-          captured_stderr_.resize(old_length + kBufferSize);
-          status_zx = stderr_socket_.read(
-              0, &captured_stderr_.front() + old_length, kBufferSize,
-              &bytes_read);
-          captured_stderr_.resize(old_length + bytes_read);
-        } while (status_zx == ZX_OK);
-        if (status_zx == ZX_ERR_PEER_CLOSED) {
-          socket_closed = true;
-        } else {
-          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_ERR_SHOULD_WAIT);
-        }
-      } else {
-        GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_SOCKET_PEER_CLOSED);
-        socket_closed = true;
-      }
-    }
-  } while (!process_terminated && !socket_closed);
-
-  ReadAndInterpretStatusByte();
-
-  zx_info_process_t buffer;
-  status_zx = child_process_.get_info(
-      ZX_INFO_PROCESS, &buffer, sizeof(buffer), nullptr, nullptr);
-  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-  GTEST_DEATH_TEST_CHECK_(buffer.exited);
-  set_status(buffer.return_code);
-  return status();
-}
-
-// The AssumeRole process for a Fuchsia death test.  It creates a child
-// process with the same executable as the current process to run the
-// death test.  The child process is given the --gtest_filter and
-// --gtest_internal_run_death_test flags such that it knows to run the
-// current death test only.
-DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
-  const UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const TestInfo* const info = impl->current_test_info();
-  const int death_test_index = info->result()->death_test_count();
-
-  if (flag != nullptr) {
-    // ParseInternalRunDeathTestFlag() has performed all the necessary
-    // processing.
-    set_write_fd(kFuchsiaReadPipeFd);
-    return EXECUTE_TEST;
-  }
-
-  // Flush the log buffers since the log streams are shared with the child.
-  FlushInfoLog();
-
-  // Build the child process command line.
-  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
-      + file_ + "|"
-      + StreamableToString(line_) + "|"
-      + StreamableToString(death_test_index);
-  Arguments args;
-  args.AddArguments(GetInjectableArgvs());
-  args.AddArgument(filter_flag.c_str());
-  args.AddArgument(internal_flag.c_str());
-
-  // Build the pipe for communication with the child.
-  zx_status_t status;
-  zx_handle_t child_pipe_handle;
-  int child_pipe_fd;
-  status = fdio_pipe_half2(&child_pipe_fd, &child_pipe_handle);
-  GTEST_DEATH_TEST_CHECK_(status != ZX_OK);
-  set_read_fd(child_pipe_fd);
-
-  // Set the pipe handle for the child.
-  fdio_spawn_action_t spawn_actions[2] = {};
-  fdio_spawn_action_t* add_handle_action = &spawn_actions[0];
-  add_handle_action->action = FDIO_SPAWN_ACTION_ADD_HANDLE;
-  add_handle_action->h.id = PA_HND(PA_FD, kFuchsiaReadPipeFd);
-  add_handle_action->h.handle = child_pipe_handle;
-
-  // Create a socket pair will be used to receive the child process' stderr.
-  zx::socket stderr_producer_socket;
-  status =
-      zx::socket::create(0, &stderr_producer_socket, &stderr_socket_);
-  GTEST_DEATH_TEST_CHECK_(status >= 0);
-  int stderr_producer_fd = -1;
-  status =
-      fdio_fd_create(stderr_producer_socket.release(), &stderr_producer_fd);
-  GTEST_DEATH_TEST_CHECK_(status >= 0);
-
-  // Make the stderr socket nonblocking.
-  GTEST_DEATH_TEST_CHECK_(fcntl(stderr_producer_fd, F_SETFL, 0) == 0);
-
-  fdio_spawn_action_t* add_stderr_action = &spawn_actions[1];
-  add_stderr_action->action = FDIO_SPAWN_ACTION_CLONE_FD;
-  add_stderr_action->fd.local_fd = stderr_producer_fd;
-  add_stderr_action->fd.target_fd = STDERR_FILENO;
-
-  // Create a child job.
-  zx_handle_t child_job = ZX_HANDLE_INVALID;
-  status = zx_job_create(zx_job_default(), 0, & child_job);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-  zx_policy_basic_t policy;
-  policy.condition = ZX_POL_NEW_ANY;
-  policy.policy = ZX_POL_ACTION_ALLOW;
-  status = zx_job_set_policy(
-      child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-
-  // Create an exception port and attach it to the |child_job|, to allow
-  // us to suppress the system default exception handler from firing.
-  status = zx::port::create(0, &port_);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-  status = zx_task_bind_exception_port(
-      child_job, port_.get(), 0 /* key */, 0 /*options */);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-
-  // Spawn the child process.
-  status = fdio_spawn_etc(
-      child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(), nullptr,
-      2, spawn_actions, child_process_.reset_and_get_address(), nullptr);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-
-  set_spawned(true);
-  return OVERSEE_TEST;
-}
-
-std::string FuchsiaDeathTest::GetErrorLogs() {
-  return captured_stderr_;
-}
-
-#else  // We are neither on Windows, nor on Fuchsia.
-
-// ForkingDeathTest provides implementations for most of the abstract
-// methods of the DeathTest interface.  Only the AssumeRole method is
-// left undefined.
-class ForkingDeathTest : public DeathTestImpl {
- public:
-  ForkingDeathTest(const char* statement, Matcher<const std::string&> matcher);
-
-  // All of these virtual functions are inherited from DeathTest.
-  int Wait() override;
-
- protected:
-  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
-
- private:
-  // PID of child process during death test; 0 in the child process itself.
-  pid_t child_pid_;
-};
-
-// Constructs a ForkingDeathTest.
-ForkingDeathTest::ForkingDeathTest(const char* a_statement,
-                                   Matcher<const std::string&> matcher)
-    : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {}
-
-// Waits for the child in a death test to exit, returning its exit
-// status, or 0 if no child process exists.  As a side effect, sets the
-// outcome data member.
-int ForkingDeathTest::Wait() {
-  if (!spawned())
-    return 0;
-
-  ReadAndInterpretStatusByte();
-
-  int status_value;
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
-  set_status(status_value);
-  return status_value;
-}
-
-// A concrete death test class that forks, then immediately runs the test
-// in the child process.
-class NoExecDeathTest : public ForkingDeathTest {
- public:
-  NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
-      : ForkingDeathTest(a_statement, std::move(matcher)) {}
-  TestRole AssumeRole() override;
-};
-
-// The AssumeRole process for a fork-and-run death test.  It implements a
-// straightforward fork, with a simple pipe to transmit the status byte.
-DeathTest::TestRole NoExecDeathTest::AssumeRole() {
-  const size_t thread_count = GetThreadCount();
-  if (thread_count != 1) {
-    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
-  }
-
-  int pipe_fd[2];
-  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
-
-  DeathTest::set_last_death_test_message("");
-  CaptureStderr();
-  // When we fork the process below, the log file buffers are copied, but the
-  // file descriptors are shared.  We flush all log files here so that closing
-  // the file descriptors in the child process doesn't throw off the
-  // synchronization between descriptors and buffers in the parent process.
-  // This is as close to the fork as possible to avoid a race condition in case
-  // there are multiple threads running before the death test, and another
-  // thread writes to the log file.
-  FlushInfoLog();
-
-  const pid_t child_pid = fork();
-  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
-  set_child_pid(child_pid);
-  if (child_pid == 0) {
-    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
-    set_write_fd(pipe_fd[1]);
-    // Redirects all logging to stderr in the child process to prevent
-    // concurrent writes to the log files.  We capture stderr in the parent
-    // process and append the child process' output to a log.
-    LogToStderr();
-    // Event forwarding to the listeners of event listener API mush be shut
-    // down in death test subprocesses.
-    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
-    g_in_fast_death_test_child = true;
-    return EXECUTE_TEST;
-  } else {
-    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
-    set_read_fd(pipe_fd[0]);
-    set_spawned(true);
-    return OVERSEE_TEST;
-  }
-}
-
-// A concrete death test class that forks and re-executes the main
-// program from the beginning, with command-line flags set that cause
-// only this specific death test to be run.
-class ExecDeathTest : public ForkingDeathTest {
- public:
-  ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
-                const char* file, int line)
-      : ForkingDeathTest(a_statement, std::move(matcher)),
-        file_(file),
-        line_(line) {}
-  TestRole AssumeRole() override;
-
- private:
-  static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() {
-    ::std::vector<std::string> args = GetInjectableArgvs();
-#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
-    ::std::vector<std::string> extra_args =
-        GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_();
-    args.insert(args.end(), extra_args.begin(), extra_args.end());
-#  endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
-    return args;
-  }
-  // The name of the file in which the death test is located.
-  const char* const file_;
-  // The line number on which the death test is located.
-  const int line_;
-};
-
-// Utility class for accumulating command-line arguments.
-class Arguments {
- public:
-  Arguments() { args_.push_back(nullptr); }
-
-  ~Arguments() {
-    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
-         ++i) {
-      free(*i);
-    }
-  }
-  void AddArgument(const char* argument) {
-    args_.insert(args_.end() - 1, posix::StrDup(argument));
-  }
-
-  template <typename Str>
-  void AddArguments(const ::std::vector<Str>& arguments) {
-    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
-         i != arguments.end();
-         ++i) {
-      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
-    }
-  }
-  char* const* Argv() {
-    return &args_[0];
-  }
-
- private:
-  std::vector<char*> args_;
-};
-
-// A struct that encompasses the arguments to the child process of a
-// threadsafe-style death test process.
-struct ExecDeathTestArgs {
-  char* const* argv;  // Command-line arguments for the child's call to exec
-  int close_fd;       // File descriptor to close; the read end of a pipe
-};
-
-#  if GTEST_OS_MAC
-inline char** GetEnviron() {
-  // When Google Test is built as a framework on MacOS X, the environ variable
-  // is unavailable. Apple's documentation (man environ) recommends using
-  // _NSGetEnviron() instead.
-  return *_NSGetEnviron();
-}
-#  else
-// Some POSIX platforms expect you to declare environ. extern "C" makes
-// it reside in the global namespace.
-extern "C" char** environ;
-inline char** GetEnviron() { return environ; }
-#  endif  // GTEST_OS_MAC
-
-#  if !GTEST_OS_QNX
-// The main function for a threadsafe-style death test child process.
-// This function is called in a clone()-ed process and thus must avoid
-// any potentially unsafe operations like malloc or libc functions.
-static int ExecDeathTestChildMain(void* child_arg) {
-  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
-
-  // We need to execute the test program in the same environment where
-  // it was originally invoked.  Therefore we change to the original
-  // working directory first.
-  const char* const original_dir =
-      UnitTest::GetInstance()->original_working_dir();
-  // We can safely call chdir() as it's a direct system call.
-  if (chdir(original_dir) != 0) {
-    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
-                   GetLastErrnoDescription());
-    return EXIT_FAILURE;
-  }
-
-  // We can safely call execve() as it's a direct system call.  We
-  // cannot use execvp() as it's a libc function and thus potentially
-  // unsafe.  Since execve() doesn't search the PATH, the user must
-  // invoke the test program via a valid path that contains at least
-  // one path separator.
-  execve(args->argv[0], args->argv, GetEnviron());
-  DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
-                 original_dir + " failed: " +
-                 GetLastErrnoDescription());
-  return EXIT_FAILURE;
-}
-#  endif  // !GTEST_OS_QNX
-
-#  if GTEST_HAS_CLONE
-// Two utility routines that together determine the direction the stack
-// grows.
-// This could be accomplished more elegantly by a single recursive
-// function, but we want to guard against the unlikely possibility of
-// a smart compiler optimizing the recursion away.
-//
-// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
-// StackLowerThanAddress into StackGrowsDown, which then doesn't give
-// correct answer.
-static void StackLowerThanAddress(const void* ptr,
-                                  bool* result) GTEST_NO_INLINE_;
-// HWAddressSanitizer add a random tag to the MSB of the local variable address,
-// making comparison result unpredictable.
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-static void StackLowerThanAddress(const void* ptr, bool* result) {
-  int dummy;
-  *result = (&dummy < ptr);
-}
-
-// Make sure AddressSanitizer does not tamper with the stack here.
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-static bool StackGrowsDown() {
-  int dummy;
-  bool result;
-  StackLowerThanAddress(&dummy, &result);
-  return result;
-}
-#  endif  // GTEST_HAS_CLONE
-
-// Spawns a child process with the same executable as the current process in
-// a thread-safe manner and instructs it to run the death test.  The
-// implementation uses fork(2) + exec.  On systems where clone(2) is
-// available, it is used instead, being slightly more thread-safe.  On QNX,
-// fork supports only single-threaded environments, so this function uses
-// spawn(2) there instead.  The function dies with an error message if
-// anything goes wrong.
-static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
-  ExecDeathTestArgs args = { argv, close_fd };
-  pid_t child_pid = -1;
-
-#  if GTEST_OS_QNX
-  // Obtains the current directory and sets it to be closed in the child
-  // process.
-  const int cwd_fd = open(".", O_RDONLY);
-  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
-  // We need to execute the test program in the same environment where
-  // it was originally invoked.  Therefore we change to the original
-  // working directory first.
-  const char* const original_dir =
-      UnitTest::GetInstance()->original_working_dir();
-  // We can safely call chdir() as it's a direct system call.
-  if (chdir(original_dir) != 0) {
-    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
-                   GetLastErrnoDescription());
-    return EXIT_FAILURE;
-  }
-
-  int fd_flags;
-  // Set close_fd to be closed after spawn.
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
-                                        fd_flags | FD_CLOEXEC));
-  struct inheritance inherit = {0};
-  // spawn is a system call.
-  child_pid =
-      spawn(args.argv[0], 0, nullptr, &inherit, args.argv, GetEnviron());
-  // Restores the current working directory.
-  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
-
-#  else   // GTEST_OS_QNX
-#   if GTEST_OS_LINUX
-  // When a SIGPROF signal is received while fork() or clone() are executing,
-  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
-  // it after the call to fork()/clone() is complete.
-  struct sigaction saved_sigprof_action;
-  struct sigaction ignore_sigprof_action;
-  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
-  sigemptyset(&ignore_sigprof_action.sa_mask);
-  ignore_sigprof_action.sa_handler = SIG_IGN;
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
-      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
-#   endif  // GTEST_OS_LINUX
-
-#   if GTEST_HAS_CLONE
-  const bool use_fork = GTEST_FLAG(death_test_use_fork);
-
-  if (!use_fork) {
-    static const bool stack_grows_down = StackGrowsDown();
-    const size_t stack_size = getpagesize();
-    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
-    void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE,
-                             MAP_ANON | MAP_PRIVATE, -1, 0);
-    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
-
-    // Maximum stack alignment in bytes:  For a downward-growing stack, this
-    // amount is subtracted from size of the stack space to get an address
-    // that is within the stack space and is aligned on all systems we care
-    // about.  As far as I know there is no ABI with stack alignment greater
-    // than 64.  We assume stack and stack_size already have alignment of
-    // kMaxStackAlignment.
-    const size_t kMaxStackAlignment = 64;
-    void* const stack_top =
-        static_cast<char*>(stack) +
-            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
-    GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
-        reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0);
-
-    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
-
-    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
-  }
-#   else
-  const bool use_fork = true;
-#   endif  // GTEST_HAS_CLONE
-
-  if (use_fork && (child_pid = fork()) == 0) {
-      ExecDeathTestChildMain(&args);
-      _exit(0);
-  }
-#  endif  // GTEST_OS_QNX
-#  if GTEST_OS_LINUX
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(
-      sigaction(SIGPROF, &saved_sigprof_action, nullptr));
-#  endif  // GTEST_OS_LINUX
-
-  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
-  return child_pid;
-}
-
-// The AssumeRole process for a fork-and-exec death test.  It re-executes the
-// main program from the beginning, setting the --gtest_filter
-// and --gtest_internal_run_death_test flags to cause only the current
-// death test to be re-run.
-DeathTest::TestRole ExecDeathTest::AssumeRole() {
-  const UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const TestInfo* const info = impl->current_test_info();
-  const int death_test_index = info->result()->death_test_count();
-
-  if (flag != nullptr) {
-    set_write_fd(flag->write_fd());
-    return EXECUTE_TEST;
-  }
-
-  int pipe_fd[2];
-  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
-  // Clear the close-on-exec flag on the write end of the pipe, lest
-  // it be closed when the child process does an exec:
-  GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
-
-  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
-      + file_ + "|" + StreamableToString(line_) + "|"
-      + StreamableToString(death_test_index) + "|"
-      + StreamableToString(pipe_fd[1]);
-  Arguments args;
-  args.AddArguments(GetArgvsForDeathTestChildProcess());
-  args.AddArgument(filter_flag.c_str());
-  args.AddArgument(internal_flag.c_str());
-
-  DeathTest::set_last_death_test_message("");
-
-  CaptureStderr();
-  // See the comment in NoExecDeathTest::AssumeRole for why the next line
-  // is necessary.
-  FlushInfoLog();
-
-  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
-  set_child_pid(child_pid);
-  set_read_fd(pipe_fd[0]);
-  set_spawned(true);
-  return OVERSEE_TEST;
-}
-
-# endif  // !GTEST_OS_WINDOWS
-
-// Creates a concrete DeathTest-derived class that depends on the
-// --gtest_death_test_style flag, and sets the pointer pointed to
-// by the "test" argument to its address.  If the test should be
-// skipped, sets that pointer to NULL.  Returns true, unless the
-// flag is set to an invalid value.
-bool DefaultDeathTestFactory::Create(const char* statement,
-                                     Matcher<const std::string&> matcher,
-                                     const char* file, int line,
-                                     DeathTest** test) {
-  UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const int death_test_index = impl->current_test_info()
-      ->increment_death_test_count();
-
-  if (flag != nullptr) {
-    if (death_test_index > flag->index()) {
-      DeathTest::set_last_death_test_message(
-          "Death test count (" + StreamableToString(death_test_index)
-          + ") somehow exceeded expected maximum ("
-          + StreamableToString(flag->index()) + ")");
-      return false;
-    }
-
-    if (!(flag->file() == file && flag->line() == line &&
-          flag->index() == death_test_index)) {
-      *test = nullptr;
-      return true;
-    }
-  }
-
-# if GTEST_OS_WINDOWS
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
-      GTEST_FLAG(death_test_style) == "fast") {
-    *test = new WindowsDeathTest(statement, std::move(matcher), file, line);
-  }
-
-# elif GTEST_OS_FUCHSIA
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
-      GTEST_FLAG(death_test_style) == "fast") {
-    *test = new FuchsiaDeathTest(statement, std::move(matcher), file, line);
-  }
-
-# else
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe") {
-    *test = new ExecDeathTest(statement, std::move(matcher), file, line);
-  } else if (GTEST_FLAG(death_test_style) == "fast") {
-    *test = new NoExecDeathTest(statement, std::move(matcher));
-  }
-
-# endif  // GTEST_OS_WINDOWS
-
-  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
-    DeathTest::set_last_death_test_message(
-        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
-        + "\" encountered");
-    return false;
-  }
-
-  return true;
-}
-
-# if GTEST_OS_WINDOWS
-// Recreates the pipe and event handles from the provided parameters,
-// signals the event, and returns a file descriptor wrapped around the pipe
-// handle. This function is called in the child process only.
-static int GetStatusFileDescriptor(unsigned int parent_process_id,
-                            size_t write_handle_as_size_t,
-                            size_t event_handle_as_size_t) {
-  AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
-                                                   FALSE,  // Non-inheritable.
-                                                   parent_process_id));
-  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
-    DeathTestAbort("Unable to open parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
-
-  const HANDLE write_handle =
-      reinterpret_cast<HANDLE>(write_handle_as_size_t);
-  HANDLE dup_write_handle;
-
-  // The newly initialized handle is accessible only in the parent
-  // process. To obtain one accessible within the child, we need to use
-  // DuplicateHandle.
-  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
-                         ::GetCurrentProcess(), &dup_write_handle,
-                         0x0,    // Requested privileges ignored since
-                                 // DUPLICATE_SAME_ACCESS is used.
-                         FALSE,  // Request non-inheritable handler.
-                         DUPLICATE_SAME_ACCESS)) {
-    DeathTestAbort("Unable to duplicate the pipe handle " +
-                   StreamableToString(write_handle_as_size_t) +
-                   " from the parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
-  HANDLE dup_event_handle;
-
-  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
-                         ::GetCurrentProcess(), &dup_event_handle,
-                         0x0,
-                         FALSE,
-                         DUPLICATE_SAME_ACCESS)) {
-    DeathTestAbort("Unable to duplicate the event handle " +
-                   StreamableToString(event_handle_as_size_t) +
-                   " from the parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  const int write_fd =
-      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
-  if (write_fd == -1) {
-    DeathTestAbort("Unable to convert pipe handle " +
-                   StreamableToString(write_handle_as_size_t) +
-                   " to a file descriptor");
-  }
-
-  // Signals the parent that the write end of the pipe has been acquired
-  // so the parent can release its own write end.
-  ::SetEvent(dup_event_handle);
-
-  return write_fd;
-}
-# endif  // GTEST_OS_WINDOWS
-
-// Returns a newly created InternalRunDeathTestFlag object with fields
-// initialized from the GTEST_FLAG(internal_run_death_test) flag if
-// the flag is specified; otherwise returns NULL.
-InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
-  if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;
-
-  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
-  // can use it here.
-  int line = -1;
-  int index = -1;
-  ::std::vector< ::std::string> fields;
-  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
-  int write_fd = -1;
-
-# if GTEST_OS_WINDOWS
-
-  unsigned int parent_process_id = 0;
-  size_t write_handle_as_size_t = 0;
-  size_t event_handle_as_size_t = 0;
-
-  if (fields.size() != 6
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)
-      || !ParseNaturalNumber(fields[3], &parent_process_id)
-      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
-      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
-                   GTEST_FLAG(internal_run_death_test));
-  }
-  write_fd = GetStatusFileDescriptor(parent_process_id,
-                                     write_handle_as_size_t,
-                                     event_handle_as_size_t);
-
-# elif GTEST_OS_FUCHSIA
-
-  if (fields.size() != 3
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
-        + GTEST_FLAG(internal_run_death_test));
-  }
-
-# else
-
-  if (fields.size() != 4
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)
-      || !ParseNaturalNumber(fields[3], &write_fd)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
-        + GTEST_FLAG(internal_run_death_test));
-  }
-
-# endif  // GTEST_OS_WINDOWS
-
-  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
-}
-
-}  // namespace internal
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-}  // namespace testing
-// Copyright 2008, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-#include <stdlib.h>
-
-#if GTEST_OS_WINDOWS_MOBILE
-# include <windows.h>
-#elif GTEST_OS_WINDOWS
-# include <direct.h>
-# include <io.h>
-#else
-# include <limits.h>
-# include <climits>  // Some Linux distributions define PATH_MAX here.
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-
-#if GTEST_OS_WINDOWS
-# define GTEST_PATH_MAX_ _MAX_PATH
-#elif defined(PATH_MAX)
-# define GTEST_PATH_MAX_ PATH_MAX
-#elif defined(_XOPEN_PATH_MAX)
-# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
-#else
-# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
-#endif  // GTEST_OS_WINDOWS
-
-namespace testing {
-namespace internal {
-
-#if GTEST_OS_WINDOWS
-// On Windows, '\\' is the standard path separator, but many tools and the
-// Windows API also accept '/' as an alternate path separator. Unless otherwise
-// noted, a file path can contain either kind of path separators, or a mixture
-// of them.
-const char kPathSeparator = '\\';
-const char kAlternatePathSeparator = '/';
-const char kAlternatePathSeparatorString[] = "/";
-# if GTEST_OS_WINDOWS_MOBILE
-// Windows CE doesn't have a current directory. You should not use
-// the current directory in tests on Windows CE, but this at least
-// provides a reasonable fallback.
-const char kCurrentDirectoryString[] = "\\";
-// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
-const DWORD kInvalidFileAttributes = 0xffffffff;
-# else
-const char kCurrentDirectoryString[] = ".\\";
-# endif  // GTEST_OS_WINDOWS_MOBILE
-#else
-const char kPathSeparator = '/';
-const char kCurrentDirectoryString[] = "./";
-#endif  // GTEST_OS_WINDOWS
-
-// Returns whether the given character is a valid path separator.
-static bool IsPathSeparator(char c) {
-#if GTEST_HAS_ALT_PATH_SEP_
-  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
-#else
-  return c == kPathSeparator;
-#endif
-}
-
-// Returns the current working directory, or "" if unsuccessful.
-FilePath FilePath::GetCurrentDir() {
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
-    GTEST_OS_WINDOWS_RT || ARDUINO
-  // Windows CE and Arduino don't have a current directory, so we just return
-  // something reasonable.
-  return FilePath(kCurrentDirectoryString);
-#elif GTEST_OS_WINDOWS
-  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
-  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
-#else
-  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
-  char* result = getcwd(cwd, sizeof(cwd));
-# if GTEST_OS_NACL
-  // getcwd will likely fail in NaCl due to the sandbox, so return something
-  // reasonable. The user may have provided a shim implementation for getcwd,
-  // however, so fallback only when failure is detected.
-  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
-# endif  // GTEST_OS_NACL
-  return FilePath(result == nullptr ? "" : cwd);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-// Returns a copy of the FilePath with the case-insensitive extension removed.
-// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
-// FilePath("dir/file"). If a case-insensitive extension is not
-// found, returns a copy of the original FilePath.
-FilePath FilePath::RemoveExtension(const char* extension) const {
-  const std::string dot_extension = std::string(".") + extension;
-  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
-    return FilePath(pathname_.substr(
-        0, pathname_.length() - dot_extension.length()));
-  }
-  return *this;
-}
-
-// Returns a pointer to the last occurrence of a valid path separator in
-// the FilePath. On Windows, for example, both '/' and '\' are valid path
-// separators. Returns NULL if no path separator was found.
-const char* FilePath::FindLastPathSeparator() const {
-  const char* const last_sep = strrchr(c_str(), kPathSeparator);
-#if GTEST_HAS_ALT_PATH_SEP_
-  const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
-  // Comparing two pointers of which only one is NULL is undefined.
-  if (last_alt_sep != nullptr &&
-      (last_sep == nullptr || last_alt_sep > last_sep)) {
-    return last_alt_sep;
-  }
-#endif
-  return last_sep;
-}
-
-// Returns a copy of the FilePath with the directory part removed.
-// Example: FilePath("path/to/file").RemoveDirectoryName() returns
-// FilePath("file"). If there is no directory part ("just_a_file"), it returns
-// the FilePath unmodified. If there is no file part ("just_a_dir/") it
-// returns an empty FilePath ("").
-// On Windows platform, '\' is the path separator, otherwise it is '/'.
-FilePath FilePath::RemoveDirectoryName() const {
-  const char* const last_sep = FindLastPathSeparator();
-  return last_sep ? FilePath(last_sep + 1) : *this;
-}
-
-// RemoveFileName returns the directory path with the filename removed.
-// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
-// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
-// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
-// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
-// On Windows platform, '\' is the path separator, otherwise it is '/'.
-FilePath FilePath::RemoveFileName() const {
-  const char* const last_sep = FindLastPathSeparator();
-  std::string dir;
-  if (last_sep) {
-    dir = std::string(c_str(), last_sep + 1 - c_str());
-  } else {
-    dir = kCurrentDirectoryString;
-  }
-  return FilePath(dir);
-}
-
-// Helper functions for naming files in a directory for xml output.
-
-// Given directory = "dir", base_name = "test", number = 0,
-// extension = "xml", returns "dir/test.xml". If number is greater
-// than zero (e.g., 12), returns "dir/test_12.xml".
-// On Windows platform, uses \ as the separator rather than /.
-FilePath FilePath::MakeFileName(const FilePath& directory,
-                                const FilePath& base_name,
-                                int number,
-                                const char* extension) {
-  std::string file;
-  if (number == 0) {
-    file = base_name.string() + "." + extension;
-  } else {
-    file = base_name.string() + "_" + StreamableToString(number)
-        + "." + extension;
-  }
-  return ConcatPaths(directory, FilePath(file));
-}
-
-// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
-// On Windows, uses \ as the separator rather than /.
-FilePath FilePath::ConcatPaths(const FilePath& directory,
-                               const FilePath& relative_path) {
-  if (directory.IsEmpty())
-    return relative_path;
-  const FilePath dir(directory.RemoveTrailingPathSeparator());
-  return FilePath(dir.string() + kPathSeparator + relative_path.string());
-}
-
-// Returns true if pathname describes something findable in the file-system,
-// either a file, directory, or whatever.
-bool FilePath::FileOrDirectoryExists() const {
-#if GTEST_OS_WINDOWS_MOBILE
-  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
-  const DWORD attributes = GetFileAttributes(unicode);
-  delete [] unicode;
-  return attributes != kInvalidFileAttributes;
-#else
-  posix::StatStruct file_stat;
-  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-// Returns true if pathname describes a directory in the file-system
-// that exists.
-bool FilePath::DirectoryExists() const {
-  bool result = false;
-#if GTEST_OS_WINDOWS
-  // Don't strip off trailing separator if path is a root directory on
-  // Windows (like "C:\\").
-  const FilePath& path(IsRootDirectory() ? *this :
-                                           RemoveTrailingPathSeparator());
-#else
-  const FilePath& path(*this);
-#endif
-
-#if GTEST_OS_WINDOWS_MOBILE
-  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
-  const DWORD attributes = GetFileAttributes(unicode);
-  delete [] unicode;
-  if ((attributes != kInvalidFileAttributes) &&
-      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
-    result = true;
-  }
-#else
-  posix::StatStruct file_stat;
-  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
-      posix::IsDir(file_stat);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-  return result;
-}
-
-// Returns true if pathname describes a root directory. (Windows has one
-// root directory per disk drive.)
-bool FilePath::IsRootDirectory() const {
-#if GTEST_OS_WINDOWS
-  return pathname_.length() == 3 && IsAbsolutePath();
-#else
-  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
-#endif
-}
-
-// Returns true if pathname describes an absolute path.
-bool FilePath::IsAbsolutePath() const {
-  const char* const name = pathname_.c_str();
-#if GTEST_OS_WINDOWS
-  return pathname_.length() >= 3 &&
-     ((name[0] >= 'a' && name[0] <= 'z') ||
-      (name[0] >= 'A' && name[0] <= 'Z')) &&
-     name[1] == ':' &&
-     IsPathSeparator(name[2]);
-#else
-  return IsPathSeparator(name[0]);
-#endif
-}
-
-// Returns a pathname for a file that does not currently exist. The pathname
-// will be directory/base_name.extension or
-// directory/base_name_<number>.extension if directory/base_name.extension
-// already exists. The number will be incremented until a pathname is found
-// that does not already exist.
-// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
-// There could be a race condition if two or more processes are calling this
-// function at the same time -- they could both pick the same filename.
-FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
-                                          const FilePath& base_name,
-                                          const char* extension) {
-  FilePath full_pathname;
-  int number = 0;
-  do {
-    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
-  } while (full_pathname.FileOrDirectoryExists());
-  return full_pathname;
-}
-
-// Returns true if FilePath ends with a path separator, which indicates that
-// it is intended to represent a directory. Returns false otherwise.
-// This does NOT check that a directory (or file) actually exists.
-bool FilePath::IsDirectory() const {
-  return !pathname_.empty() &&
-         IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
-}
-
-// Create directories so that path exists. Returns true if successful or if
-// the directories already exist; returns false if unable to create directories
-// for any reason.
-bool FilePath::CreateDirectoriesRecursively() const {
-  if (!this->IsDirectory()) {
-    return false;
-  }
-
-  if (pathname_.length() == 0 || this->DirectoryExists()) {
-    return true;
-  }
-
-  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
-  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
-}
-
-// Create the directory so that path exists. Returns true if successful or
-// if the directory already exists; returns false if unable to create the
-// directory for any reason, including if the parent directory does not
-// exist. Not named "CreateDirectory" because that's a macro on Windows.
-bool FilePath::CreateFolder() const {
-#if GTEST_OS_WINDOWS_MOBILE
-  FilePath removed_sep(this->RemoveTrailingPathSeparator());
-  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
-  int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
-  delete [] unicode;
-#elif GTEST_OS_WINDOWS
-  int result = _mkdir(pathname_.c_str());
-#else
-  int result = mkdir(pathname_.c_str(), 0777);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-  if (result == -1) {
-    return this->DirectoryExists();  // An error is OK if the directory exists.
-  }
-  return true;  // No error.
-}
-
-// If input name has a trailing separator character, remove it and return the
-// name, otherwise return the name string unmodified.
-// On Windows platform, uses \ as the separator, other platforms use /.
-FilePath FilePath::RemoveTrailingPathSeparator() const {
-  return IsDirectory()
-      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
-      : *this;
-}
-
-// Removes any redundant separators that might be in the pathname.
-// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
-// redundancies that might be in a pathname involving "." or "..".
-void FilePath::Normalize() {
-  if (pathname_.c_str() == nullptr) {
-    pathname_ = "";
-    return;
-  }
-  const char* src = pathname_.c_str();
-  char* const dest = new char[pathname_.length() + 1];
-  char* dest_ptr = dest;
-  memset(dest_ptr, 0, pathname_.length() + 1);
-
-  while (*src != '\0') {
-    *dest_ptr = *src;
-    if (!IsPathSeparator(*src)) {
-      src++;
-    } else {
-#if GTEST_HAS_ALT_PATH_SEP_
-      if (*dest_ptr == kAlternatePathSeparator) {
-        *dest_ptr = kPathSeparator;
-      }
-#endif
-      while (IsPathSeparator(*src))
-        src++;
-    }
-    dest_ptr++;
-  }
-  *dest_ptr = '\0';
-  pathname_ = dest;
-  delete[] dest;
-}
-
-}  // namespace internal
-}  // namespace testing
-// Copyright 2007, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This file implements just enough of the matcher interface to allow
-// EXPECT_DEATH and friends to accept a matcher argument.
-
-
-#include <string>
-
-namespace testing {
-
-// Constructs a matcher that matches a const std::string& whose value is
-// equal to s.
-Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); }
-
-// Constructs a matcher that matches a const std::string& whose value is
-// equal to s.
-Matcher<const std::string&>::Matcher(const char* s) {
-  *this = Eq(std::string(s));
-}
-
-// Constructs a matcher that matches a std::string whose value is equal to
-// s.
-Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }
-
-// Constructs a matcher that matches a std::string whose value is equal to
-// s.
-Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); }
-
-#if GTEST_HAS_ABSL
-// Constructs a matcher that matches a const absl::string_view& whose value is
-// equal to s.
-Matcher<const absl::string_view&>::Matcher(const std::string& s) {
-  *this = Eq(s);
-}
-
-// Constructs a matcher that matches a const absl::string_view& whose value is
-// equal to s.
-Matcher<const absl::string_view&>::Matcher(const char* s) {
-  *this = Eq(std::string(s));
-}
-
-// Constructs a matcher that matches a const absl::string_view& whose value is
-// equal to s.
-Matcher<const absl::string_view&>::Matcher(absl::string_view s) {
-  *this = Eq(std::string(s));
-}
-
-// Constructs a matcher that matches a absl::string_view whose value is equal to
-// s.
-Matcher<absl::string_view>::Matcher(const std::string& s) { *this = Eq(s); }
-
-// Constructs a matcher that matches a absl::string_view whose value is equal to
-// s.
-Matcher<absl::string_view>::Matcher(const char* s) {
-  *this = Eq(std::string(s));
-}
-
-// Constructs a matcher that matches a absl::string_view whose value is equal to
-// s.
-Matcher<absl::string_view>::Matcher(absl::string_view s) {
-  *this = Eq(std::string(s));
-}
-#endif  // GTEST_HAS_ABSL
-
-}  // namespace testing
-// Copyright 2008, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <fstream>
-#include <memory>
-
-#if GTEST_OS_WINDOWS
-# include <windows.h>
-# include <io.h>
-# include <sys/stat.h>
-# include <map>  // Used in ThreadLocal.
-# ifdef _MSC_VER
-#  include <crtdbg.h>
-# endif  // _MSC_VER
-#else
-# include <unistd.h>
-#endif  // GTEST_OS_WINDOWS
-
-#if GTEST_OS_MAC
-# include <mach/mach_init.h>
-# include <mach/task.h>
-# include <mach/vm_map.h>
-#endif  // GTEST_OS_MAC
-
-#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
-    GTEST_OS_NETBSD || GTEST_OS_OPENBSD
-# include <sys/sysctl.h>
-# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
-#  include <sys/user.h>
-# endif
-#endif
-
-#if GTEST_OS_QNX
-# include <devctl.h>
-# include <fcntl.h>
-# include <sys/procfs.h>
-#endif  // GTEST_OS_QNX
-
-#if GTEST_OS_AIX
-# include <procinfo.h>
-# include <sys/types.h>
-#endif  // GTEST_OS_AIX
-
-#if GTEST_OS_FUCHSIA
-# include <zircon/process.h>
-# include <zircon/syscalls.h>
-#endif  // GTEST_OS_FUCHSIA
-
-
-namespace testing {
-namespace internal {
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
-const int kStdOutFileno = 1;
-const int kStdErrFileno = 2;
-#else
-const int kStdOutFileno = STDOUT_FILENO;
-const int kStdErrFileno = STDERR_FILENO;
-#endif  // _MSC_VER
-
-#if GTEST_OS_LINUX
-
-namespace {
-template <typename T>
-T ReadProcFileField(const std::string& filename, int field) {
-  std::string dummy;
-  std::ifstream file(filename.c_str());
-  while (field-- > 0) {
-    file >> dummy;
-  }
-  T output = 0;
-  file >> output;
-  return output;
-}
-}  // namespace
-
-// Returns the number of active threads, or 0 when there is an error.
-size_t GetThreadCount() {
-  const std::string filename =
-      (Message() << "/proc/" << getpid() << "/stat").GetString();
-  return ReadProcFileField<int>(filename, 19);
-}
-
-#elif GTEST_OS_MAC
-
-size_t GetThreadCount() {
-  const task_t task = mach_task_self();
-  mach_msg_type_number_t thread_count;
-  thread_act_array_t thread_list;
-  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
-  if (status == KERN_SUCCESS) {
-    // task_threads allocates resources in thread_list and we need to free them
-    // to avoid leaks.
-    vm_deallocate(task,
-                  reinterpret_cast<vm_address_t>(thread_list),
-                  sizeof(thread_t) * thread_count);
-    return static_cast<size_t>(thread_count);
-  } else {
-    return 0;
-  }
-}
-
-#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
-      GTEST_OS_NETBSD
-
-#if GTEST_OS_NETBSD
-#undef KERN_PROC
-#define KERN_PROC KERN_PROC2
-#define kinfo_proc kinfo_proc2
-#endif
-
-#if GTEST_OS_DRAGONFLY
-#define KP_NLWP(kp) (kp.kp_nthreads)
-#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
-#define KP_NLWP(kp) (kp.ki_numthreads)
-#elif GTEST_OS_NETBSD
-#define KP_NLWP(kp) (kp.p_nlwps)
-#endif
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-size_t GetThreadCount() {
-  int mib[] = {
-    CTL_KERN,
-    KERN_PROC,
-    KERN_PROC_PID,
-    getpid(),
-#if GTEST_OS_NETBSD
-    sizeof(struct kinfo_proc),
-    1,
-#endif
-  };
-  u_int miblen = sizeof(mib) / sizeof(mib[0]);
-  struct kinfo_proc info;
-  size_t size = sizeof(info);
-  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
-    return 0;
-  }
-  return KP_NLWP(info);
-}
-#elif GTEST_OS_OPENBSD
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-size_t GetThreadCount() {
-  int mib[] = {
-    CTL_KERN,
-    KERN_PROC,
-    KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
-    getpid(),
-    sizeof(struct kinfo_proc),
-    0,
-  };
-  u_int miblen = sizeof(mib) / sizeof(mib[0]);
-
-  // get number of structs
-  size_t size;
-  if (sysctl(mib, miblen, NULL, &size, NULL, 0)) {
-    return 0;
-  }
-  mib[5] = size / mib[4];
-
-  // populate array of structs
-  struct kinfo_proc info[mib[5]];
-  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
-    return 0;
-  }
-
-  // exclude empty members
-  int nthreads = 0;
-  for (int i = 0; i < size / mib[4]; i++) {
-    if (info[i].p_tid != -1)
-      nthreads++;
-  }
-  return nthreads;
-}
-
-#elif GTEST_OS_QNX
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-size_t GetThreadCount() {
-  const int fd = open("/proc/self/as", O_RDONLY);
-  if (fd < 0) {
-    return 0;
-  }
-  procfs_info process_info;
-  const int status =
-      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), nullptr);
-  close(fd);
-  if (status == EOK) {
-    return static_cast<size_t>(process_info.num_threads);
-  } else {
-    return 0;
-  }
-}
-
-#elif GTEST_OS_AIX
-
-size_t GetThreadCount() {
-  struct procentry64 entry;
-  pid_t pid = getpid();
-  int status = getprocs64(&entry, sizeof(entry), nullptr, 0, &pid, 1);
-  if (status == 1) {
-    return entry.pi_thcount;
-  } else {
-    return 0;
-  }
-}
-
-#elif GTEST_OS_FUCHSIA
-
-size_t GetThreadCount() {
-  int dummy_buffer;
-  size_t avail;
-  zx_status_t status = zx_object_get_info(
-      zx_process_self(),
-      ZX_INFO_PROCESS_THREADS,
-      &dummy_buffer,
-      0,
-      nullptr,
-      &avail);
-  if (status == ZX_OK) {
-    return avail;
-  } else {
-    return 0;
-  }
-}
-
-#else
-
-size_t GetThreadCount() {
-  // There's no portable way to detect the number of threads, so we just
-  // return 0 to indicate that we cannot detect it.
-  return 0;
-}
-
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
-
-void SleepMilliseconds(int n) {
-  ::Sleep(n);
-}
-
-AutoHandle::AutoHandle()
-    : handle_(INVALID_HANDLE_VALUE) {}
-
-AutoHandle::AutoHandle(Handle handle)
-    : handle_(handle) {}
-
-AutoHandle::~AutoHandle() {
-  Reset();
-}
-
-AutoHandle::Handle AutoHandle::Get() const {
-  return handle_;
-}
-
-void AutoHandle::Reset() {
-  Reset(INVALID_HANDLE_VALUE);
-}
-
-void AutoHandle::Reset(HANDLE handle) {
-  // Resetting with the same handle we already own is invalid.
-  if (handle_ != handle) {
-    if (IsCloseable()) {
-      ::CloseHandle(handle_);
-    }
-    handle_ = handle;
-  } else {
-    GTEST_CHECK_(!IsCloseable())
-        << "Resetting a valid handle to itself is likely a programmer error "
-            "and thus not allowed.";
-  }
-}
-
-bool AutoHandle::IsCloseable() const {
-  // Different Windows APIs may use either of these values to represent an
-  // invalid handle.
-  return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE;
-}
-
-Notification::Notification()
-    : event_(::CreateEvent(nullptr,     // Default security attributes.
-                           TRUE,        // Do not reset automatically.
-                           FALSE,       // Initially unset.
-                           nullptr)) {  // Anonymous event.
-  GTEST_CHECK_(event_.Get() != nullptr);
-}
-
-void Notification::Notify() {
-  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
-}
-
-void Notification::WaitForNotification() {
-  GTEST_CHECK_(
-      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
-}
-
-Mutex::Mutex()
-    : owner_thread_id_(0),
-      type_(kDynamic),
-      critical_section_init_phase_(0),
-      critical_section_(new CRITICAL_SECTION) {
-  ::InitializeCriticalSection(critical_section_);
-}
-
-Mutex::~Mutex() {
-  // Static mutexes are leaked intentionally. It is not thread-safe to try
-  // to clean them up.
-  if (type_ == kDynamic) {
-    ::DeleteCriticalSection(critical_section_);
-    delete critical_section_;
-    critical_section_ = nullptr;
-  }
-}
-
-void Mutex::Lock() {
-  ThreadSafeLazyInit();
-  ::EnterCriticalSection(critical_section_);
-  owner_thread_id_ = ::GetCurrentThreadId();
-}
-
-void Mutex::Unlock() {
-  ThreadSafeLazyInit();
-  // We don't protect writing to owner_thread_id_ here, as it's the
-  // caller's responsibility to ensure that the current thread holds the
-  // mutex when this is called.
-  owner_thread_id_ = 0;
-  ::LeaveCriticalSection(critical_section_);
-}
-
-// Does nothing if the current thread holds the mutex. Otherwise, crashes
-// with high probability.
-void Mutex::AssertHeld() {
-  ThreadSafeLazyInit();
-  GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
-      << "The current thread is not holding the mutex @" << this;
-}
-
-namespace {
-
-#ifdef _MSC_VER
-// Use the RAII idiom to flag mem allocs that are intentionally never
-// deallocated. The motivation is to silence the false positive mem leaks
-// that are reported by the debug version of MS's CRT which can only detect
-// if an alloc is missing a matching deallocation.
-// Example:
-//    MemoryIsNotDeallocated memory_is_not_deallocated;
-//    critical_section_ = new CRITICAL_SECTION;
-//
-class MemoryIsNotDeallocated
-{
- public:
-  MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
-    old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-    // Set heap allocation block type to _IGNORE_BLOCK so that MS debug CRT
-    // doesn't report mem leak if there's no matching deallocation.
-    _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF);
-  }
-
-  ~MemoryIsNotDeallocated() {
-    // Restore the original _CRTDBG_ALLOC_MEM_DF flag
-    _CrtSetDbgFlag(old_crtdbg_flag_);
-  }
-
- private:
-  int old_crtdbg_flag_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
-};
-#endif  // _MSC_VER
-
-}  // namespace
-
-// Initializes owner_thread_id_ and critical_section_ in static mutexes.
-void Mutex::ThreadSafeLazyInit() {
-  // Dynamic mutexes are initialized in the constructor.
-  if (type_ == kStatic) {
-    switch (
-        ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
-      case 0:
-        // If critical_section_init_phase_ was 0 before the exchange, we
-        // are the first to test it and need to perform the initialization.
-        owner_thread_id_ = 0;
-        {
-          // Use RAII to flag that following mem alloc is never deallocated.
-#ifdef _MSC_VER
-          MemoryIsNotDeallocated memory_is_not_deallocated;
-#endif  // _MSC_VER
-          critical_section_ = new CRITICAL_SECTION;
-        }
-        ::InitializeCriticalSection(critical_section_);
-        // Updates the critical_section_init_phase_ to 2 to signal
-        // initialization complete.
-        GTEST_CHECK_(::InterlockedCompareExchange(
-                          &critical_section_init_phase_, 2L, 1L) ==
-                      1L);
-        break;
-      case 1:
-        // Somebody else is already initializing the mutex; spin until they
-        // are done.
-        while (::InterlockedCompareExchange(&critical_section_init_phase_,
-                                            2L,
-                                            2L) != 2L) {
-          // Possibly yields the rest of the thread's time slice to other
-          // threads.
-          ::Sleep(0);
-        }
-        break;
-
-      case 2:
-        break;  // The mutex is already initialized and ready for use.
-
-      default:
-        GTEST_CHECK_(false)
-            << "Unexpected value of critical_section_init_phase_ "
-            << "while initializing a static mutex.";
-    }
-  }
-}
-
-namespace {
-
-class ThreadWithParamSupport : public ThreadWithParamBase {
- public:
-  static HANDLE CreateThread(Runnable* runnable,
-                             Notification* thread_can_start) {
-    ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
-    DWORD thread_id;
-    HANDLE thread_handle = ::CreateThread(
-        nullptr,  // Default security.
-        0,        // Default stack size.
-        &ThreadWithParamSupport::ThreadMain,
-        param,        // Parameter to ThreadMainStatic
-        0x0,          // Default creation flags.
-        &thread_id);  // Need a valid pointer for the call to work under Win98.
-    GTEST_CHECK_(thread_handle != nullptr)
-        << "CreateThread failed with error " << ::GetLastError() << ".";
-    if (thread_handle == nullptr) {
-      delete param;
-    }
-    return thread_handle;
-  }
-
- private:
-  struct ThreadMainParam {
-    ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
-        : runnable_(runnable),
-          thread_can_start_(thread_can_start) {
-    }
-    std::unique_ptr<Runnable> runnable_;
-    // Does not own.
-    Notification* thread_can_start_;
-  };
-
-  static DWORD WINAPI ThreadMain(void* ptr) {
-    // Transfers ownership.
-    std::unique_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
-    if (param->thread_can_start_ != nullptr)
-      param->thread_can_start_->WaitForNotification();
-    param->runnable_->Run();
-    return 0;
-  }
-
-  // Prohibit instantiation.
-  ThreadWithParamSupport();
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
-};
-
-}  // namespace
-
-ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
-                                         Notification* thread_can_start)
-      : thread_(ThreadWithParamSupport::CreateThread(runnable,
-                                                     thread_can_start)) {
-}
-
-ThreadWithParamBase::~ThreadWithParamBase() {
-  Join();
-}
-
-void ThreadWithParamBase::Join() {
-  GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
-      << "Failed to join the thread with error " << ::GetLastError() << ".";
-}
-
-// Maps a thread to a set of ThreadIdToThreadLocals that have values
-// instantiated on that thread and notifies them when the thread exits.  A
-// ThreadLocal instance is expected to persist until all threads it has
-// values on have terminated.
-class ThreadLocalRegistryImpl {
- public:
-  // Registers thread_local_instance as having value on the current thread.
-  // Returns a value that can be used to identify the thread from other threads.
-  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance) {
-    DWORD current_thread = ::GetCurrentThreadId();
-    MutexLock lock(&mutex_);
-    ThreadIdToThreadLocals* const thread_to_thread_locals =
-        GetThreadLocalsMapLocked();
-    ThreadIdToThreadLocals::iterator thread_local_pos =
-        thread_to_thread_locals->find(current_thread);
-    if (thread_local_pos == thread_to_thread_locals->end()) {
-      thread_local_pos = thread_to_thread_locals->insert(
-          std::make_pair(current_thread, ThreadLocalValues())).first;
-      StartWatcherThreadFor(current_thread);
-    }
-    ThreadLocalValues& thread_local_values = thread_local_pos->second;
-    ThreadLocalValues::iterator value_pos =
-        thread_local_values.find(thread_local_instance);
-    if (value_pos == thread_local_values.end()) {
-      value_pos =
-          thread_local_values
-              .insert(std::make_pair(
-                  thread_local_instance,
-                  std::shared_ptr<ThreadLocalValueHolderBase>(
-                      thread_local_instance->NewValueForCurrentThread())))
-              .first;
-    }
-    return value_pos->second.get();
-  }
-
-  static void OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance) {
-    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
-    // Clean up the ThreadLocalValues data structure while holding the lock, but
-    // defer the destruction of the ThreadLocalValueHolderBases.
-    {
-      MutexLock lock(&mutex_);
-      ThreadIdToThreadLocals* const thread_to_thread_locals =
-          GetThreadLocalsMapLocked();
-      for (ThreadIdToThreadLocals::iterator it =
-          thread_to_thread_locals->begin();
-          it != thread_to_thread_locals->end();
-          ++it) {
-        ThreadLocalValues& thread_local_values = it->second;
-        ThreadLocalValues::iterator value_pos =
-            thread_local_values.find(thread_local_instance);
-        if (value_pos != thread_local_values.end()) {
-          value_holders.push_back(value_pos->second);
-          thread_local_values.erase(value_pos);
-          // This 'if' can only be successful at most once, so theoretically we
-          // could break out of the loop here, but we don't bother doing so.
-        }
-      }
-    }
-    // Outside the lock, let the destructor for 'value_holders' deallocate the
-    // ThreadLocalValueHolderBases.
-  }
-
-  static void OnThreadExit(DWORD thread_id) {
-    GTEST_CHECK_(thread_id != 0) << ::GetLastError();
-    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
-    // Clean up the ThreadIdToThreadLocals data structure while holding the
-    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
-    {
-      MutexLock lock(&mutex_);
-      ThreadIdToThreadLocals* const thread_to_thread_locals =
-          GetThreadLocalsMapLocked();
-      ThreadIdToThreadLocals::iterator thread_local_pos =
-          thread_to_thread_locals->find(thread_id);
-      if (thread_local_pos != thread_to_thread_locals->end()) {
-        ThreadLocalValues& thread_local_values = thread_local_pos->second;
-        for (ThreadLocalValues::iterator value_pos =
-            thread_local_values.begin();
-            value_pos != thread_local_values.end();
-            ++value_pos) {
-          value_holders.push_back(value_pos->second);
-        }
-        thread_to_thread_locals->erase(thread_local_pos);
-      }
-    }
-    // Outside the lock, let the destructor for 'value_holders' deallocate the
-    // ThreadLocalValueHolderBases.
-  }
-
- private:
-  // In a particular thread, maps a ThreadLocal object to its value.
-  typedef std::map<const ThreadLocalBase*,
-                   std::shared_ptr<ThreadLocalValueHolderBase> >
-      ThreadLocalValues;
-  // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
-  // thread's ID.
-  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
-
-  // Holds the thread id and thread handle that we pass from
-  // StartWatcherThreadFor to WatcherThreadFunc.
-  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;
-
-  static void StartWatcherThreadFor(DWORD thread_id) {
-    // The returned handle will be kept in thread_map and closed by
-    // watcher_thread in WatcherThreadFunc.
-    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
-                                 FALSE,
-                                 thread_id);
-    GTEST_CHECK_(thread != nullptr);
-    // We need to pass a valid thread ID pointer into CreateThread for it
-    // to work correctly under Win98.
-    DWORD watcher_thread_id;
-    HANDLE watcher_thread = ::CreateThread(
-        nullptr,  // Default security.
-        0,        // Default stack size
-        &ThreadLocalRegistryImpl::WatcherThreadFunc,
-        reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
-        CREATE_SUSPENDED, &watcher_thread_id);
-    GTEST_CHECK_(watcher_thread != nullptr);
-    // Give the watcher thread the same priority as ours to avoid being
-    // blocked by it.
-    ::SetThreadPriority(watcher_thread,
-                        ::GetThreadPriority(::GetCurrentThread()));
-    ::ResumeThread(watcher_thread);
-    ::CloseHandle(watcher_thread);
-  }
-
-  // Monitors exit from a given thread and notifies those
-  // ThreadIdToThreadLocals about thread termination.
-  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
-    const ThreadIdAndHandle* tah =
-        reinterpret_cast<const ThreadIdAndHandle*>(param);
-    GTEST_CHECK_(
-        ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
-    OnThreadExit(tah->first);
-    ::CloseHandle(tah->second);
-    delete tah;
-    return 0;
-  }
-
-  // Returns map of thread local instances.
-  static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
-    mutex_.AssertHeld();
-#ifdef _MSC_VER
-    MemoryIsNotDeallocated memory_is_not_deallocated;
-#endif  // _MSC_VER
-    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals();
-    return map;
-  }
-
-  // Protects access to GetThreadLocalsMapLocked() and its return value.
-  static Mutex mutex_;
-  // Protects access to GetThreadMapLocked() and its return value.
-  static Mutex thread_map_mutex_;
-};
-
-Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);
-Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);
-
-ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance) {
-  return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
-      thread_local_instance);
-}
-
-void ThreadLocalRegistry::OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance) {
-  ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
-}
-
-#endif  // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
-
-#if GTEST_USES_POSIX_RE
-
-// Implements RE.  Currently only needed for death tests.
-
-RE::~RE() {
-  if (is_valid_) {
-    // regfree'ing an invalid regex might crash because the content
-    // of the regex is undefined. Since the regex's are essentially
-    // the same, one cannot be valid (or invalid) without the other
-    // being so too.
-    regfree(&partial_regex_);
-    regfree(&full_regex_);
-  }
-  free(const_cast<char*>(pattern_));
-}
-
-// Returns true iff regular expression re matches the entire str.
-bool RE::FullMatch(const char* str, const RE& re) {
-  if (!re.is_valid_) return false;
-
-  regmatch_t match;
-  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
-}
-
-// Returns true iff regular expression re matches a substring of str
-// (including str itself).
-bool RE::PartialMatch(const char* str, const RE& re) {
-  if (!re.is_valid_) return false;
-
-  regmatch_t match;
-  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
-}
-
-// Initializes an RE from its string representation.
-void RE::Init(const char* regex) {
-  pattern_ = posix::StrDup(regex);
-
-  // Reserves enough bytes to hold the regular expression used for a
-  // full match.
-  const size_t full_regex_len = strlen(regex) + 10;
-  char* const full_pattern = new char[full_regex_len];
-
-  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
-  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
-  // We want to call regcomp(&partial_regex_, ...) even if the
-  // previous expression returns false.  Otherwise partial_regex_ may
-  // not be properly initialized can may cause trouble when it's
-  // freed.
-  //
-  // Some implementation of POSIX regex (e.g. on at least some
-  // versions of Cygwin) doesn't accept the empty string as a valid
-  // regex.  We change it to an equivalent form "()" to be safe.
-  if (is_valid_) {
-    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
-    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
-  }
-  EXPECT_TRUE(is_valid_)
-      << "Regular expression \"" << regex
-      << "\" is not a valid POSIX Extended regular expression.";
-
-  delete[] full_pattern;
-}
-
-#elif GTEST_USES_SIMPLE_RE
-
-// Returns true iff ch appears anywhere in str (excluding the
-// terminating '\0' character).
-bool IsInSet(char ch, const char* str) {
-  return ch != '\0' && strchr(str, ch) != nullptr;
-}
-
-// Returns true iff ch belongs to the given classification.  Unlike
-// similar functions in <ctype.h>, these aren't affected by the
-// current locale.
-bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
-bool IsAsciiPunct(char ch) {
-  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
-}
-bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
-bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
-bool IsAsciiWordChar(char ch) {
-  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
-      ('0' <= ch && ch <= '9') || ch == '_';
-}
-
-// Returns true iff "\\c" is a supported escape sequence.
-bool IsValidEscape(char c) {
-  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
-}
-
-// Returns true iff the given atom (specified by escaped and pattern)
-// matches ch.  The result is undefined if the atom is invalid.
-bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
-  if (escaped) {  // "\\p" where p is pattern_char.
-    switch (pattern_char) {
-      case 'd': return IsAsciiDigit(ch);
-      case 'D': return !IsAsciiDigit(ch);
-      case 'f': return ch == '\f';
-      case 'n': return ch == '\n';
-      case 'r': return ch == '\r';
-      case 's': return IsAsciiWhiteSpace(ch);
-      case 'S': return !IsAsciiWhiteSpace(ch);
-      case 't': return ch == '\t';
-      case 'v': return ch == '\v';
-      case 'w': return IsAsciiWordChar(ch);
-      case 'W': return !IsAsciiWordChar(ch);
-    }
-    return IsAsciiPunct(pattern_char) && pattern_char == ch;
-  }
-
-  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
-}
-
-// Helper function used by ValidateRegex() to format error messages.
-static std::string FormatRegexSyntaxError(const char* regex, int index) {
-  return (Message() << "Syntax error at index " << index
-          << " in simple regular expression \"" << regex << "\": ").GetString();
-}
-
-// Generates non-fatal failures and returns false if regex is invalid;
-// otherwise returns true.
-bool ValidateRegex(const char* regex) {
-  if (regex == nullptr) {
-    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
-    return false;
-  }
-
-  bool is_valid = true;
-
-  // True iff ?, *, or + can follow the previous atom.
-  bool prev_repeatable = false;
-  for (int i = 0; regex[i]; i++) {
-    if (regex[i] == '\\') {  // An escape sequence
-      i++;
-      if (regex[i] == '\0') {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
-                      << "'\\' cannot appear at the end.";
-        return false;
-      }
-
-      if (!IsValidEscape(regex[i])) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
-                      << "invalid escape sequence \"\\" << regex[i] << "\".";
-        is_valid = false;
-      }
-      prev_repeatable = true;
-    } else {  // Not an escape sequence.
-      const char ch = regex[i];
-
-      if (ch == '^' && i > 0) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'^' can only appear at the beginning.";
-        is_valid = false;
-      } else if (ch == '$' && regex[i + 1] != '\0') {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'$' can only appear at the end.";
-        is_valid = false;
-      } else if (IsInSet(ch, "()[]{}|")) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'" << ch << "' is unsupported.";
-        is_valid = false;
-      } else if (IsRepeat(ch) && !prev_repeatable) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'" << ch << "' can only follow a repeatable token.";
-        is_valid = false;
-      }
-
-      prev_repeatable = !IsInSet(ch, "^$?*+");
-    }
-  }
-
-  return is_valid;
-}
-
-// Matches a repeated regex atom followed by a valid simple regular
-// expression.  The regex atom is defined as c if escaped is false,
-// or \c otherwise.  repeat is the repetition meta character (?, *,
-// or +).  The behavior is undefined if str contains too many
-// characters to be indexable by size_t, in which case the test will
-// probably time out anyway.  We are fine with this limitation as
-// std::string has it too.
-bool MatchRepetitionAndRegexAtHead(
-    bool escaped, char c, char repeat, const char* regex,
-    const char* str) {
-  const size_t min_count = (repeat == '+') ? 1 : 0;
-  const size_t max_count = (repeat == '?') ? 1 :
-      static_cast<size_t>(-1) - 1;
-  // We cannot call numeric_limits::max() as it conflicts with the
-  // max() macro on Windows.
-
-  for (size_t i = 0; i <= max_count; ++i) {
-    // We know that the atom matches each of the first i characters in str.
-    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
-      // We have enough matches at the head, and the tail matches too.
-      // Since we only care about *whether* the pattern matches str
-      // (as opposed to *how* it matches), there is no need to find a
-      // greedy match.
-      return true;
-    }
-    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
-      return false;
-  }
-  return false;
-}
-
-// Returns true iff regex matches a prefix of str.  regex must be a
-// valid simple regular expression and not start with "^", or the
-// result is undefined.
-bool MatchRegexAtHead(const char* regex, const char* str) {
-  if (*regex == '\0')  // An empty regex matches a prefix of anything.
-    return true;
-
-  // "$" only matches the end of a string.  Note that regex being
-  // valid guarantees that there's nothing after "$" in it.
-  if (*regex == '$')
-    return *str == '\0';
-
-  // Is the first thing in regex an escape sequence?
-  const bool escaped = *regex == '\\';
-  if (escaped)
-    ++regex;
-  if (IsRepeat(regex[1])) {
-    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
-    // here's an indirect recursion.  It terminates as the regex gets
-    // shorter in each recursion.
-    return MatchRepetitionAndRegexAtHead(
-        escaped, regex[0], regex[1], regex + 2, str);
-  } else {
-    // regex isn't empty, isn't "$", and doesn't start with a
-    // repetition.  We match the first atom of regex with the first
-    // character of str and recurse.
-    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
-        MatchRegexAtHead(regex + 1, str + 1);
-  }
-}
-
-// Returns true iff regex matches any substring of str.  regex must be
-// a valid simple regular expression, or the result is undefined.
-//
-// The algorithm is recursive, but the recursion depth doesn't exceed
-// the regex length, so we won't need to worry about running out of
-// stack space normally.  In rare cases the time complexity can be
-// exponential with respect to the regex length + the string length,
-// but usually it's must faster (often close to linear).
-bool MatchRegexAnywhere(const char* regex, const char* str) {
-  if (regex == nullptr || str == nullptr) return false;
-
-  if (*regex == '^')
-    return MatchRegexAtHead(regex + 1, str);
-
-  // A successful match can be anywhere in str.
-  do {
-    if (MatchRegexAtHead(regex, str))
-      return true;
-  } while (*str++ != '\0');
-  return false;
-}
-
-// Implements the RE class.
-
-RE::~RE() {
-  free(const_cast<char*>(pattern_));
-  free(const_cast<char*>(full_pattern_));
-}
-
-// Returns true iff regular expression re matches the entire str.
-bool RE::FullMatch(const char* str, const RE& re) {
-  return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
-}
-
-// Returns true iff regular expression re matches a substring of str
-// (including str itself).
-bool RE::PartialMatch(const char* str, const RE& re) {
-  return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
-}
-
-// Initializes an RE from its string representation.
-void RE::Init(const char* regex) {
-  pattern_ = full_pattern_ = nullptr;
-  if (regex != nullptr) {
-    pattern_ = posix::StrDup(regex);
-  }
-
-  is_valid_ = ValidateRegex(regex);
-  if (!is_valid_) {
-    // No need to calculate the full pattern when the regex is invalid.
-    return;
-  }
-
-  const size_t len = strlen(regex);
-  // Reserves enough bytes to hold the regular expression used for a
-  // full match: we need space to prepend a '^', append a '$', and
-  // terminate the string with '\0'.
-  char* buffer = static_cast<char*>(malloc(len + 3));
-  full_pattern_ = buffer;
-
-  if (*regex != '^')
-    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.
-
-  // We don't use snprintf or strncpy, as they trigger a warning when
-  // compiled with VC++ 8.0.
-  memcpy(buffer, regex, len);
-  buffer += len;
-
-  if (len == 0 || regex[len - 1] != '$')
-    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.
-
-  *buffer = '\0';
-}
-
-#endif  // GTEST_USES_POSIX_RE
-
-const char kUnknownFile[] = "unknown file";
-
-// Formats a source file path and a line number as they would appear
-// in an error message from the compiler used to compile this code.
-GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
-  const std::string file_name(file == nullptr ? kUnknownFile : file);
-
-  if (line < 0) {
-    return file_name + ":";
-  }
-#ifdef _MSC_VER
-  return file_name + "(" + StreamableToString(line) + "):";
-#else
-  return file_name + ":" + StreamableToString(line) + ":";
-#endif  // _MSC_VER
-}
-
-// Formats a file location for compiler-independent XML output.
-// Although this function is not platform dependent, we put it next to
-// FormatFileLocation in order to contrast the two functions.
-// Note that FormatCompilerIndependentFileLocation() does NOT append colon
-// to the file location it produces, unlike FormatFileLocation().
-GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
-    const char* file, int line) {
-  const std::string file_name(file == nullptr ? kUnknownFile : file);
-
-  if (line < 0)
-    return file_name;
-  else
-    return file_name + ":" + StreamableToString(line);
-}
-
-GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
-    : severity_(severity) {
-  const char* const marker =
-      severity == GTEST_INFO ?    "[  INFO ]" :
-      severity == GTEST_WARNING ? "[WARNING]" :
-      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
-  GetStream() << ::std::endl << marker << " "
-              << FormatFileLocation(file, line).c_str() << ": ";
-}
-
-// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
-GTestLog::~GTestLog() {
-  GetStream() << ::std::endl;
-  if (severity_ == GTEST_FATAL) {
-    fflush(stderr);
-    posix::Abort();
-  }
-}
-
-// Disable Microsoft deprecation warnings for POSIX functions called from
-// this class (creat, dup, dup2, and close)
-GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Object that captures an output stream (stdout/stderr).
-class CapturedStream {
- public:
-  // The ctor redirects the stream to a temporary file.
-  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
-# if GTEST_OS_WINDOWS
-    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
-    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
-
-    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
-    const UINT success = ::GetTempFileNameA(temp_dir_path,
-                                            "gtest_redir",
-                                            0,  // Generate unique file name.
-                                            temp_file_path);
-    GTEST_CHECK_(success != 0)
-        << "Unable to create a temporary file in " << temp_dir_path;
-    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
-    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
-                                    << temp_file_path;
-    filename_ = temp_file_path;
-# else
-    // There's no guarantee that a test has write access to the current
-    // directory, so we create the temporary file in the /tmp directory
-    // instead. We use /tmp on most systems, and /sdcard on Android.
-    // That's because Android doesn't have /tmp.
-#  if GTEST_OS_LINUX_ANDROID
-    // Note: Android applications are expected to call the framework's
-    // Context.getExternalStorageDirectory() method through JNI to get
-    // the location of the world-writable SD Card directory. However,
-    // this requires a Context handle, which cannot be retrieved
-    // globally from native code. Doing so also precludes running the
-    // code as part of a regular standalone executable, which doesn't
-    // run in a Dalvik process (e.g. when running it through 'adb shell').
-    //
-    // The location /sdcard is directly accessible from native code
-    // and is the only location (unofficially) supported by the Android
-    // team. It's generally a symlink to the real SD Card mount point
-    // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
-    // other OEM-customized locations. Never rely on these, and always
-    // use /sdcard.
-    char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
-#  else
-    char name_template[] = "/tmp/captured_stream.XXXXXX";
-#  endif  // GTEST_OS_LINUX_ANDROID
-    const int captured_fd = mkstemp(name_template);
-    filename_ = name_template;
-# endif  // GTEST_OS_WINDOWS
-    fflush(nullptr);
-    dup2(captured_fd, fd_);
-    close(captured_fd);
-  }
-
-  ~CapturedStream() {
-    remove(filename_.c_str());
-  }
-
-  std::string GetCapturedString() {
-    if (uncaptured_fd_ != -1) {
-      // Restores the original stream.
-      fflush(nullptr);
-      dup2(uncaptured_fd_, fd_);
-      close(uncaptured_fd_);
-      uncaptured_fd_ = -1;
-    }
-
-    FILE* const file = posix::FOpen(filename_.c_str(), "r");
-    const std::string content = ReadEntireFile(file);
-    posix::FClose(file);
-    return content;
-  }
-
- private:
-  const int fd_;  // A stream to capture.
-  int uncaptured_fd_;
-  // Name of the temporary file holding the stderr output.
-  ::std::string filename_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
-};
-
-GTEST_DISABLE_MSC_DEPRECATED_POP_()
-
-static CapturedStream* g_captured_stderr = nullptr;
-static CapturedStream* g_captured_stdout = nullptr;
-
-// Starts capturing an output stream (stdout/stderr).
-static void CaptureStream(int fd, const char* stream_name,
-                          CapturedStream** stream) {
-  if (*stream != nullptr) {
-    GTEST_LOG_(FATAL) << "Only one " << stream_name
-                      << " capturer can exist at a time.";
-  }
-  *stream = new CapturedStream(fd);
-}
-
-// Stops capturing the output stream and returns the captured string.
-static std::string GetCapturedStream(CapturedStream** captured_stream) {
-  const std::string content = (*captured_stream)->GetCapturedString();
-
-  delete *captured_stream;
-  *captured_stream = nullptr;
-
-  return content;
-}
-
-// Starts capturing stdout.
-void CaptureStdout() {
-  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
-}
-
-// Starts capturing stderr.
-void CaptureStderr() {
-  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
-}
-
-// Stops capturing stdout and returns the captured string.
-std::string GetCapturedStdout() {
-  return GetCapturedStream(&g_captured_stdout);
-}
-
-// Stops capturing stderr and returns the captured string.
-std::string GetCapturedStderr() {
-  return GetCapturedStream(&g_captured_stderr);
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-
-
-
-
-size_t GetFileSize(FILE* file) {
-  fseek(file, 0, SEEK_END);
-  return static_cast<size_t>(ftell(file));
-}
-
-std::string ReadEntireFile(FILE* file) {
-  const size_t file_size = GetFileSize(file);
-  char* const buffer = new char[file_size];
-
-  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
-  size_t bytes_read = 0;       // # of bytes read so far
-
-  fseek(file, 0, SEEK_SET);
-
-  // Keeps reading the file until we cannot read further or the
-  // pre-determined file size is reached.
-  do {
-    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
-    bytes_read += bytes_last_read;
-  } while (bytes_last_read > 0 && bytes_read < file_size);
-
-  const std::string content(buffer, bytes_read);
-  delete[] buffer;
-
-  return content;
-}
-
-#if GTEST_HAS_DEATH_TEST
-static const std::vector<std::string>* g_injected_test_argvs =
-    nullptr;  // Owned.
-
-std::vector<std::string> GetInjectableArgvs() {
-  if (g_injected_test_argvs != nullptr) {
-    return *g_injected_test_argvs;
-  }
-  return GetArgvs();
-}
-
-void SetInjectableArgvs(const std::vector<std::string>* new_argvs) {
-  if (g_injected_test_argvs != new_argvs) delete g_injected_test_argvs;
-  g_injected_test_argvs = new_argvs;
-}
-
-void SetInjectableArgvs(const std::vector<std::string>& new_argvs) {
-  SetInjectableArgvs(
-      new std::vector<std::string>(new_argvs.begin(), new_argvs.end()));
-}
-
-void ClearInjectableArgvs() {
-  delete g_injected_test_argvs;
-  g_injected_test_argvs = nullptr;
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-#if GTEST_OS_WINDOWS_MOBILE
-namespace posix {
-void Abort() {
-  DebugBreak();
-  TerminateProcess(GetCurrentProcess(), 1);
-}
-}  // namespace posix
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-// Returns the name of the environment variable corresponding to the
-// given flag.  For example, FlagToEnvVar("foo") will return
-// "GTEST_FOO" in the open-source version.
-static std::string FlagToEnvVar(const char* flag) {
-  const std::string full_flag =
-      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
-
-  Message env_var;
-  for (size_t i = 0; i != full_flag.length(); i++) {
-    env_var << ToUpper(full_flag.c_str()[i]);
-  }
-
-  return env_var.GetString();
-}
-
-// Parses 'str' for a 32-bit signed integer.  If successful, writes
-// the result to *value and returns true; otherwise leaves *value
-// unchanged and returns false.
-bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
-  // Parses the environment variable as a decimal integer.
-  char* end = nullptr;
-  const long long_value = strtol(str, &end, 10);  // NOLINT
-
-  // Has strtol() consumed all characters in the string?
-  if (*end != '\0') {
-    // No - an invalid character was encountered.
-    Message msg;
-    msg << "WARNING: " << src_text
-        << " is expected to be a 32-bit integer, but actually"
-        << " has value \"" << str << "\".\n";
-    printf("%s", msg.GetString().c_str());
-    fflush(stdout);
-    return false;
-  }
-
-  // Is the parsed value in the range of an Int32?
-  const Int32 result = static_cast<Int32>(long_value);
-  if (long_value == LONG_MAX || long_value == LONG_MIN ||
-      // The parsed value overflows as a long.  (strtol() returns
-      // LONG_MAX or LONG_MIN when the input overflows.)
-      result != long_value
-      // The parsed value overflows as an Int32.
-      ) {
-    Message msg;
-    msg << "WARNING: " << src_text
-        << " is expected to be a 32-bit integer, but actually"
-        << " has value " << str << ", which overflows.\n";
-    printf("%s", msg.GetString().c_str());
-    fflush(stdout);
-    return false;
-  }
-
-  *value = result;
-  return true;
-}
-
-// Reads and returns the Boolean environment variable corresponding to
-// the given flag; if it's not set, returns default_value.
-//
-// The value is considered true iff it's not "0".
-bool BoolFromGTestEnv(const char* flag, bool default_value) {
-#if defined(GTEST_GET_BOOL_FROM_ENV_)
-  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
-#else
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const string_value = posix::GetEnv(env_var.c_str());
-  return string_value == nullptr ? default_value
-                                 : strcmp(string_value, "0") != 0;
-#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
-}
-
-// Reads and returns a 32-bit integer stored in the environment
-// variable corresponding to the given flag; if it isn't set or
-// doesn't represent a valid 32-bit integer, returns default_value.
-Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
-#if defined(GTEST_GET_INT32_FROM_ENV_)
-  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
-#else
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const string_value = posix::GetEnv(env_var.c_str());
-  if (string_value == nullptr) {
-    // The environment variable is not set.
-    return default_value;
-  }
-
-  Int32 result = default_value;
-  if (!ParseInt32(Message() << "Environment variable " << env_var,
-                  string_value, &result)) {
-    printf("The default value %s is used.\n",
-           (Message() << default_value).GetString().c_str());
-    fflush(stdout);
-    return default_value;
-  }
-
-  return result;
-#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
-}
-
-// As a special case for the 'output' flag, if GTEST_OUTPUT is not
-// set, we look for XML_OUTPUT_FILE, which is set by the Bazel build
-// system.  The value of XML_OUTPUT_FILE is a filename without the
-// "xml:" prefix of GTEST_OUTPUT.
-// Note that this is meant to be called at the call site so it does
-// not check that the flag is 'output'
-// In essence this checks an env variable called XML_OUTPUT_FILE
-// and if it is set we prepend "xml:" to its value, if it not set we return ""
-std::string OutputFlagAlsoCheckEnvVar(){
-  std::string default_value_for_output_flag = "";
-  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
-  if (nullptr != xml_output_file_env) {
-    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
-  }
-  return default_value_for_output_flag;
-}
-
-// Reads and returns the string environment variable corresponding to
-// the given flag; if it's not set, returns default_value.
-const char* StringFromGTestEnv(const char* flag, const char* default_value) {
-#if defined(GTEST_GET_STRING_FROM_ENV_)
-  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
-#else
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const value = posix::GetEnv(env_var.c_str());
-  return value == nullptr ? default_value : value;
-#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
-}
-
-}  // namespace internal
-}  // namespace testing
-// Copyright 2007, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-// Google Test - The Google C++ Testing and Mocking Framework
-//
-// This file implements a universal value printer that can print a
-// value of any type T:
-//
-//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
-//
-// It uses the << operator when possible, and prints the bytes in the
-// object otherwise.  A user can override its behavior for a class
-// type Foo by defining either operator<<(::std::ostream&, const Foo&)
-// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
-// defines Foo.
-
-#include <stdio.h>
-#include <cctype>
-#include <cwchar>
-#include <ostream>  // NOLINT
-#include <string>
-
-namespace testing {
-
-namespace {
-
-using ::std::ostream;
-
-// Prints a segment of bytes in the given object.
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
-                                size_t count, ostream* os) {
-  char text[5] = "";
-  for (size_t i = 0; i != count; i++) {
-    const size_t j = start + i;
-    if (i != 0) {
-      // Organizes the bytes into groups of 2 for easy parsing by
-      // human.
-      if ((j % 2) == 0)
-        *os << ' ';
-      else
-        *os << '-';
-    }
-    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
-    *os << text;
-  }
-}
-
-// Prints the bytes in the given value to the given ostream.
-void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
-                              ostream* os) {
-  // Tells the user how big the object is.
-  *os << count << "-byte object <";
-
-  const size_t kThreshold = 132;
-  const size_t kChunkSize = 64;
-  // If the object size is bigger than kThreshold, we'll have to omit
-  // some details by printing only the first and the last kChunkSize
-  // bytes.
-  if (count < kThreshold) {
-    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
-  } else {
-    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
-    *os << " ... ";
-    // Rounds up to 2-byte boundary.
-    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
-    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
-  }
-  *os << ">";
-}
-
-}  // namespace
-
-namespace internal2 {
-
-// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
-// given object.  The delegation simplifies the implementation, which
-// uses the << operator and thus is easier done outside of the
-// ::testing::internal namespace, which contains a << operator that
-// sometimes conflicts with the one in STL.
-void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
-                          ostream* os) {
-  PrintBytesInObjectToImpl(obj_bytes, count, os);
-}
-
-}  // namespace internal2
-
-namespace internal {
-
-// Depending on the value of a char (or wchar_t), we print it in one
-// of three formats:
-//   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
-//   - as a hexadecimal escape sequence (e.g. '\x7F'), or
-//   - as a special escape sequence (e.g. '\r', '\n').
-enum CharFormat {
-  kAsIs,
-  kHexEscape,
-  kSpecialEscape
-};
-
-// Returns true if c is a printable ASCII character.  We test the
-// value of c directly instead of calling isprint(), which is buggy on
-// Windows Mobile.
-inline bool IsPrintableAscii(wchar_t c) {
-  return 0x20 <= c && c <= 0x7E;
-}
-
-// Prints a wide or narrow char c as a character literal without the
-// quotes, escaping it when necessary; returns how c was formatted.
-// The template argument UnsignedChar is the unsigned version of Char,
-// which is the type of c.
-template <typename UnsignedChar, typename Char>
-static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
-  switch (static_cast<wchar_t>(c)) {
-    case L'\0':
-      *os << "\\0";
-      break;
-    case L'\'':
-      *os << "\\'";
-      break;
-    case L'\\':
-      *os << "\\\\";
-      break;
-    case L'\a':
-      *os << "\\a";
-      break;
-    case L'\b':
-      *os << "\\b";
-      break;
-    case L'\f':
-      *os << "\\f";
-      break;
-    case L'\n':
-      *os << "\\n";
-      break;
-    case L'\r':
-      *os << "\\r";
-      break;
-    case L'\t':
-      *os << "\\t";
-      break;
-    case L'\v':
-      *os << "\\v";
-      break;
-    default:
-      if (IsPrintableAscii(c)) {
-        *os << static_cast<char>(c);
-        return kAsIs;
-      } else {
-        ostream::fmtflags flags = os->flags();
-        *os << "\\x" << std::hex << std::uppercase
-            << static_cast<int>(static_cast<UnsignedChar>(c));
-        os->flags(flags);
-        return kHexEscape;
-      }
-  }
-  return kSpecialEscape;
-}
-
-// Prints a wchar_t c as if it's part of a string literal, escaping it when
-// necessary; returns how c was formatted.
-static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
-  switch (c) {
-    case L'\'':
-      *os << "'";
-      return kAsIs;
-    case L'"':
-      *os << "\\\"";
-      return kSpecialEscape;
-    default:
-      return PrintAsCharLiteralTo<wchar_t>(c, os);
-  }
-}
-
-// Prints a char c as if it's part of a string literal, escaping it when
-// necessary; returns how c was formatted.
-static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
-  return PrintAsStringLiteralTo(
-      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
-}
-
-// Prints a wide or narrow character c and its code.  '\0' is printed
-// as "'\\0'", other unprintable characters are also properly escaped
-// using the standard C++ escape sequence.  The template argument
-// UnsignedChar is the unsigned version of Char, which is the type of c.
-template <typename UnsignedChar, typename Char>
-void PrintCharAndCodeTo(Char c, ostream* os) {
-  // First, print c as a literal in the most readable form we can find.
-  *os << ((sizeof(c) > 1) ? "L'" : "'");
-  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
-  *os << "'";
-
-  // To aid user debugging, we also print c's code in decimal, unless
-  // it's 0 (in which case c was printed as '\\0', making the code
-  // obvious).
-  if (c == 0)
-    return;
-  *os << " (" << static_cast<int>(c);
-
-  // For more convenience, we print c's code again in hexadecimal,
-  // unless c was already printed in the form '\x##' or the code is in
-  // [1, 9].
-  if (format == kHexEscape || (1 <= c && c <= 9)) {
-    // Do nothing.
-  } else {
-    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
-  }
-  *os << ")";
-}
-
-void PrintTo(unsigned char c, ::std::ostream* os) {
-  PrintCharAndCodeTo<unsigned char>(c, os);
-}
-void PrintTo(signed char c, ::std::ostream* os) {
-  PrintCharAndCodeTo<unsigned char>(c, os);
-}
-
-// Prints a wchar_t as a symbol if it is printable or as its internal
-// code otherwise and also as its code.  L'\0' is printed as "L'\\0'".
-void PrintTo(wchar_t wc, ostream* os) {
-  PrintCharAndCodeTo<wchar_t>(wc, os);
-}
-
-// Prints the given array of characters to the ostream.  CharType must be either
-// char or wchar_t.
-// The array starts at begin, the length is len, it may include '\0' characters
-// and may not be NUL-terminated.
-template <typename CharType>
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-static CharFormat PrintCharsAsStringTo(
-    const CharType* begin, size_t len, ostream* os) {
-  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
-  *os << kQuoteBegin;
-  bool is_previous_hex = false;
-  CharFormat print_format = kAsIs;
-  for (size_t index = 0; index < len; ++index) {
-    const CharType cur = begin[index];
-    if (is_previous_hex && IsXDigit(cur)) {
-      // Previous character is of '\x..' form and this character can be
-      // interpreted as another hexadecimal digit in its number. Break string to
-      // disambiguate.
-      *os << "\" " << kQuoteBegin;
-    }
-    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
-    // Remember if any characters required hex escaping.
-    if (is_previous_hex) {
-      print_format = kHexEscape;
-    }
-  }
-  *os << "\"";
-  return print_format;
-}
-
-// Prints a (const) char/wchar_t array of 'len' elements, starting at address
-// 'begin'.  CharType must be either char or wchar_t.
-template <typename CharType>
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-static void UniversalPrintCharArray(
-    const CharType* begin, size_t len, ostream* os) {
-  // The code
-  //   const char kFoo[] = "foo";
-  // generates an array of 4, not 3, elements, with the last one being '\0'.
-  //
-  // Therefore when printing a char array, we don't print the last element if
-  // it's '\0', such that the output matches the string literal as it's
-  // written in the source code.
-  if (len > 0 && begin[len - 1] == '\0') {
-    PrintCharsAsStringTo(begin, len - 1, os);
-    return;
-  }
-
-  // If, however, the last element in the array is not '\0', e.g.
-  //    const char kFoo[] = { 'f', 'o', 'o' };
-  // we must print the entire array.  We also print a message to indicate
-  // that the array is not NUL-terminated.
-  PrintCharsAsStringTo(begin, len, os);
-  *os << " (no terminating NUL)";
-}
-
-// Prints a (const) char array of 'len' elements, starting at address 'begin'.
-void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
-  UniversalPrintCharArray(begin, len, os);
-}
-
-// Prints a (const) wchar_t array of 'len' elements, starting at address
-// 'begin'.
-void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
-  UniversalPrintCharArray(begin, len, os);
-}
-
-// Prints the given C string to the ostream.
-void PrintTo(const char* s, ostream* os) {
-  if (s == nullptr) {
-    *os << "NULL";
-  } else {
-    *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, strlen(s), os);
-  }
-}
-
-// MSVC compiler can be configured to define whar_t as a typedef
-// of unsigned short. Defining an overload for const wchar_t* in that case
-// would cause pointers to unsigned shorts be printed as wide strings,
-// possibly accessing more memory than intended and causing invalid
-// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
-// wchar_t is implemented as a native type.
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-// Prints the given wide C string to the ostream.
-void PrintTo(const wchar_t* s, ostream* os) {
-  if (s == nullptr) {
-    *os << "NULL";
-  } else {
-    *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, wcslen(s), os);
-  }
-}
-#endif  // wchar_t is native
-
-namespace {
-
-bool ContainsUnprintableControlCodes(const char* str, size_t length) {
-  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
-
-  for (size_t i = 0; i < length; i++) {
-    unsigned char ch = *s++;
-    if (std::iscntrl(ch)) {
-        switch (ch) {
-        case '\t':
-        case '\n':
-        case '\r':
-          break;
-        default:
-          return true;
-        }
-      }
-  }
-  return false;
-}
-
-bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; }
-
-bool IsValidUTF8(const char* str, size_t length) {
-  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
-
-  for (size_t i = 0; i < length;) {
-    unsigned char lead = s[i++];
-
-    if (lead <= 0x7f) {
-      continue;  // single-byte character (ASCII) 0..7F
-    }
-    if (lead < 0xc2) {
-      return false;  // trail byte or non-shortest form
-    } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) {
-      ++i;  // 2-byte character
-    } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length &&
-               IsUTF8TrailByte(s[i]) &&
-               IsUTF8TrailByte(s[i + 1]) &&
-               // check for non-shortest form and surrogate
-               (lead != 0xe0 || s[i] >= 0xa0) &&
-               (lead != 0xed || s[i] < 0xa0)) {
-      i += 2;  // 3-byte character
-    } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length &&
-               IsUTF8TrailByte(s[i]) &&
-               IsUTF8TrailByte(s[i + 1]) &&
-               IsUTF8TrailByte(s[i + 2]) &&
-               // check for non-shortest form
-               (lead != 0xf0 || s[i] >= 0x90) &&
-               (lead != 0xf4 || s[i] < 0x90)) {
-      i += 3;  // 4-byte character
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
-void ConditionalPrintAsText(const char* str, size_t length, ostream* os) {
-  if (!ContainsUnprintableControlCodes(str, length) &&
-      IsValidUTF8(str, length)) {
-    *os << "\n    As Text: \"" << str << "\"";
-  }
-}
-
-}  // anonymous namespace
-
-void PrintStringTo(const ::std::string& s, ostream* os) {
-  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
-    if (GTEST_FLAG(print_utf8)) {
-      ConditionalPrintAsText(s.data(), s.size(), os);
-    }
-  }
-}
-
-#if GTEST_HAS_STD_WSTRING
-void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-}  // namespace internal
-
-}  // namespace testing
-// Copyright 2008, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-
-
-namespace testing {
-
-using internal::GetUnitTestImpl;
-
-// Gets the summary of the failure message by omitting the stack trace
-// in it.
-std::string TestPartResult::ExtractSummary(const char* message) {
-  const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
-  return stack_trace == nullptr ? message : std::string(message, stack_trace);
-}
-
-// Prints a TestPartResult object.
-std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
-  return os << result.file_name() << ":" << result.line_number() << ": "
-            << (result.type() == TestPartResult::kSuccess
-                    ? "Success"
-                    : result.type() == TestPartResult::kSkip
-                          ? "Skipped"
-                          : result.type() == TestPartResult::kFatalFailure
-                                ? "Fatal failure"
-                                : "Non-fatal failure")
-            << ":\n"
-            << result.message() << std::endl;
-}
-
-// Appends a TestPartResult to the array.
-void TestPartResultArray::Append(const TestPartResult& result) {
-  array_.push_back(result);
-}
-
-// Returns the TestPartResult at the given index (0-based).
-const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
-  if (index < 0 || index >= size()) {
-    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
-    internal::posix::Abort();
-  }
-
-  return array_[index];
-}
-
-// Returns the number of TestPartResult objects in the array.
-int TestPartResultArray::size() const {
-  return static_cast<int>(array_.size());
-}
-
-namespace internal {
-
-HasNewFatalFailureHelper::HasNewFatalFailureHelper()
-    : has_new_fatal_failure_(false),
-      original_reporter_(GetUnitTestImpl()->
-                         GetTestPartResultReporterForCurrentThread()) {
-  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
-}
-
-HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
-  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
-      original_reporter_);
-}
-
-void HasNewFatalFailureHelper::ReportTestPartResult(
-    const TestPartResult& result) {
-  if (result.fatally_failed())
-    has_new_fatal_failure_ = true;
-  original_reporter_->ReportTestPartResult(result);
-}
-
-}  // namespace internal
-
-}  // namespace testing
-// Copyright 2008 Google Inc.
-// All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-
-
-namespace testing {
-namespace internal {
-
-#if GTEST_HAS_TYPED_TEST_P
-
-// Skips to the first non-space char in str. Returns an empty string if str
-// contains only whitespace characters.
-static const char* SkipSpaces(const char* str) {
-  while (IsSpace(*str))
-    str++;
-  return str;
-}
-
-static std::vector<std::string> SplitIntoTestNames(const char* src) {
-  std::vector<std::string> name_vec;
-  src = SkipSpaces(src);
-  for (; src != nullptr; src = SkipComma(src)) {
-    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
-  }
-  return name_vec;
-}
-
-// Verifies that registered_tests match the test names in
-// registered_tests_; returns registered_tests if successful, or
-// aborts the program otherwise.
-const char* TypedTestSuitePState::VerifyRegisteredTestNames(
-    const char* file, int line, const char* registered_tests) {
-  typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
-  registered_ = true;
-
-  std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
-
-  Message errors;
-
-  std::set<std::string> tests;
-  for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
-       name_it != name_vec.end(); ++name_it) {
-    const std::string& name = *name_it;
-    if (tests.count(name) != 0) {
-      errors << "Test " << name << " is listed more than once.\n";
-      continue;
-    }
-
-    bool found = false;
-    for (RegisteredTestIter it = registered_tests_.begin();
-         it != registered_tests_.end();
-         ++it) {
-      if (name == it->first) {
-        found = true;
-        break;
-      }
-    }
-
-    if (found) {
-      tests.insert(name);
-    } else {
-      errors << "No test named " << name
-             << " can be found in this test suite.\n";
-    }
-  }
-
-  for (RegisteredTestIter it = registered_tests_.begin();
-       it != registered_tests_.end();
-       ++it) {
-    if (tests.count(it->first) == 0) {
-      errors << "You forgot to list test " << it->first << ".\n";
-    }
-  }
-
-  const std::string& errors_str = errors.GetString();
-  if (errors_str != "") {
-    fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
-            errors_str.c_str());
-    fflush(stderr);
-    posix::Abort();
-  }
-
-  return registered_tests;
-}
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-}  // namespace internal
-}  // namespace testing
diff --git a/test/cctest/gtest/gtest.h b/test/cctest/gtest/gtest.h
deleted file mode 100644
index dbbf5680bd946ed4a486f117803adbc3b8da5131..0000000000000000000000000000000000000000
--- a/test/cctest/gtest/gtest.h
+++ /dev/null
@@ -1,14901 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This header file defines the public API for Google Test.  It should be
-// included by any test program that uses Google Test.
-//
-// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
-// leave some internal implementation details in this header file.
-// They are clearly marked by comments like this:
-//
-//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-//
-// Such code is NOT meant to be used by a user directly, and is subject
-// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
-// program!
-//
-// Acknowledgment: Google Test borrowed the idea of automatic test
-// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
-// easyUnit framework.
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_H_
-
-#include <cstddef>
-#include <limits>
-#include <memory>
-#include <ostream>
-#include <type_traits>
-#include <vector>
-
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This header file declares functions and macros used internally by
-// Google Test.  They are subject to change without notice.
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Low-level types and utilities for porting Google Test to various
-// platforms.  All macros ending with _ and symbols defined in an
-// internal namespace are subject to change without notice.  Code
-// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
-// end with _ are part of Google Test's public API and can be used by
-// code outside Google Test.
-//
-// This file is fundamental to Google Test.  All other Google Test source
-// files are expected to #include this.  Therefore, it cannot #include
-// any other Google Test header.
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-
-// Environment-describing macros
-// -----------------------------
-//
-// Google Test can be used in many different environments.  Macros in
-// this section tell Google Test what kind of environment it is being
-// used in, such that Google Test can provide environment-specific
-// features and implementations.
-//
-// Google Test tries to automatically detect the properties of its
-// environment, so users usually don't need to worry about these
-// macros.  However, the automatic detection is not perfect.
-// Sometimes it's necessary for a user to define some of the following
-// macros in the build script to override Google Test's decisions.
-//
-// If the user doesn't define a macro in the list, Google Test will
-// provide a default definition.  After this header is #included, all
-// macros in this list will be defined to either 1 or 0.
-//
-// Notes to maintainers:
-//   - Each macro here is a user-tweakable knob; do not grow the list
-//     lightly.
-//   - Use #if to key off these macros.  Don't use #ifdef or "#if
-//     defined(...)", which will not work as these macros are ALWAYS
-//     defined.
-//
-//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
-//                              is/isn't available.
-//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
-//                              are enabled.
-//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
-//                              expressions are/aren't available.
-//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
-//                              is/isn't available.
-//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
-//                              enabled.
-//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
-//                              std::wstring does/doesn't work (Google Test can
-//                              be used where std::wstring is unavailable).
-//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
-//                              compiler supports Microsoft's "Structured
-//                              Exception Handling".
-//   GTEST_HAS_STREAM_REDIRECTION
-//                            - Define it to 1/0 to indicate whether the
-//                              platform supports I/O stream redirection using
-//                              dup() and dup2().
-//   GTEST_LINKED_AS_SHARED_LIBRARY
-//                            - Define to 1 when compiling tests that use
-//                              Google Test as a shared library (known as
-//                              DLL on Windows).
-//   GTEST_CREATE_SHARED_LIBRARY
-//                            - Define to 1 when compiling Google Test itself
-//                              as a shared library.
-//   GTEST_DEFAULT_DEATH_TEST_STYLE
-//                            - The default value of --gtest_death_test_style.
-//                              The legacy default has been "fast" in the open
-//                              source version since 2008. The recommended value
-//                              is "threadsafe", and can be set in
-//                              custom/gtest-port.h.
-
-// Platform-indicating macros
-// --------------------------
-//
-// Macros indicating the platform on which Google Test is being used
-// (a macro is defined to 1 if compiled on the given platform;
-// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
-// defines these macros automatically.  Code outside Google Test MUST
-// NOT define them.
-//
-//   GTEST_OS_AIX      - IBM AIX
-//   GTEST_OS_CYGWIN   - Cygwin
-//   GTEST_OS_DRAGONFLY - DragonFlyBSD
-//   GTEST_OS_FREEBSD  - FreeBSD
-//   GTEST_OS_FUCHSIA  - Fuchsia
-//   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD
-//   GTEST_OS_HAIKU    - Haiku
-//   GTEST_OS_HPUX     - HP-UX
-//   GTEST_OS_LINUX    - Linux
-//     GTEST_OS_LINUX_ANDROID - Google Android
-//   GTEST_OS_MAC      - Mac OS X
-//     GTEST_OS_IOS    - iOS
-//   GTEST_OS_NACL     - Google Native Client (NaCl)
-//   GTEST_OS_NETBSD   - NetBSD
-//   GTEST_OS_OPENBSD  - OpenBSD
-//   GTEST_OS_OS2      - OS/2
-//   GTEST_OS_QNX      - QNX
-//   GTEST_OS_SOLARIS  - Sun Solaris
-//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
-//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
-//     GTEST_OS_WINDOWS_MINGW    - MinGW
-//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
-//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
-//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
-//   GTEST_OS_ZOS      - z/OS
-//
-// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the
-// most stable support.  Since core members of the Google Test project
-// don't have access to other platforms, support for them may be less
-// stable.  If you notice any problems on your platform, please notify
-// googletestframework@googlegroups.com (patches for fixing them are
-// even more welcome!).
-//
-// It is possible that none of the GTEST_OS_* macros are defined.
-
-// Feature-indicating macros
-// -------------------------
-//
-// Macros indicating which Google Test features are available (a macro
-// is defined to 1 if the corresponding feature is supported;
-// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
-// defines these macros automatically.  Code outside Google Test MUST
-// NOT define them.
-//
-// These macros are public so that portable tests can be written.
-// Such tests typically surround code using a feature with an #if
-// which controls that code.  For example:
-//
-// #if GTEST_HAS_DEATH_TEST
-//   EXPECT_DEATH(DoSomethingDeadly());
-// #endif
-//
-//   GTEST_HAS_DEATH_TEST   - death tests
-//   GTEST_HAS_TYPED_TEST   - typed tests
-//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
-//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
-//   GOOGLETEST_CM0007 DO NOT DELETE
-//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
-//                            GTEST_HAS_POSIX_RE (see above) which users can
-//                            define themselves.
-//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
-//                            the above RE\b(s) are mutually exclusive.
-
-// Misc public macros
-// ------------------
-//
-//   GTEST_FLAG(flag_name)  - references the variable corresponding to
-//                            the given Google Test flag.
-
-// Internal utilities
-// ------------------
-//
-// The following macros and utilities are for Google Test's INTERNAL
-// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
-//
-// Macros for basic C++ coding:
-//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
-//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
-//                              variable don't have to be used.
-//   GTEST_DISALLOW_ASSIGN_   - disables operator=.
-//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
-//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
-//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
-//                                        suppressed (constant conditional).
-//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
-//                                        is suppressed.
-//
-// Synchronization:
-//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
-//                            - synchronization primitives.
-//
-// Template meta programming:
-//   IteratorTraits - partial implementation of std::iterator_traits, which
-//                    is not available in libCstd when compiled with Sun C++.
-//
-//
-// Regular expressions:
-//   RE             - a simple regular expression class using the POSIX
-//                    Extended Regular Expression syntax on UNIX-like platforms
-//                    GOOGLETEST_CM0008 DO NOT DELETE
-//                    or a reduced regular exception syntax on other
-//                    platforms, including Windows.
-// Logging:
-//   GTEST_LOG_()   - logs messages at the specified severity level.
-//   LogToStderr()  - directs all log messages to stderr.
-//   FlushInfoLog() - flushes informational log messages.
-//
-// Stdout and stderr capturing:
-//   CaptureStdout()     - starts capturing stdout.
-//   GetCapturedStdout() - stops capturing stdout and returns the captured
-//                         string.
-//   CaptureStderr()     - starts capturing stderr.
-//   GetCapturedStderr() - stops capturing stderr and returns the captured
-//                         string.
-//
-// Integer types:
-//   TypeWithSize   - maps an integer to a int type.
-//   Int32, UInt32, Int64, UInt64, TimeInMillis
-//                  - integers of known sizes.
-//   BiggestInt     - the biggest signed integer type.
-//
-// Command-line utilities:
-//   GTEST_DECLARE_*()  - declares a flag.
-//   GTEST_DEFINE_*()   - defines a flag.
-//   GetInjectableArgvs() - returns the command line as a vector of strings.
-//
-// Environment variable utilities:
-//   GetEnv()             - gets the value of an environment variable.
-//   BoolFromGTestEnv()   - parses a bool environment variable.
-//   Int32FromGTestEnv()  - parses an Int32 environment variable.
-//   StringFromGTestEnv() - parses a string environment variable.
-//
-// Deprecation warnings:
-//   GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as
-//                                        deprecated; calling a marked function
-//                                        should generate a compiler warning
-
-#include <ctype.h>   // for isspace, etc
-#include <stddef.h>  // for ptrdiff_t
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <memory>
-#include <type_traits>
-
-#ifndef _WIN32_WCE
-# include <sys/types.h>
-# include <sys/stat.h>
-#endif  // !_WIN32_WCE
-
-#if defined __APPLE__
-# include <AvailabilityMacros.h>
-# include <TargetConditionals.h>
-#endif
-
-#include <algorithm>  // NOLINT
-#include <iostream>   // NOLINT
-#include <sstream>    // NOLINT
-#include <string>     // NOLINT
-#include <tuple>
-#include <utility>
-#include <vector>  // NOLINT
-
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This header file defines the GTEST_OS_* macro.
-// It is separate from gtest-port.h so that custom/gtest-port.h can include it.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
-
-// Determines the platform on which Google Test is compiled.
-#ifdef __CYGWIN__
-# define GTEST_OS_CYGWIN 1
-# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
-#  define GTEST_OS_WINDOWS_MINGW 1
-#  define GTEST_OS_WINDOWS 1
-#elif defined _WIN32
-# define GTEST_OS_WINDOWS 1
-# ifdef _WIN32_WCE
-#  define GTEST_OS_WINDOWS_MOBILE 1
-# elif defined(WINAPI_FAMILY)
-#  include <winapifamily.h>
-#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#   define GTEST_OS_WINDOWS_DESKTOP 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
-#   define GTEST_OS_WINDOWS_PHONE 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
-#   define GTEST_OS_WINDOWS_RT 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
-#   define GTEST_OS_WINDOWS_PHONE 1
-#   define GTEST_OS_WINDOWS_TV_TITLE 1
-#  else
-    // WINAPI_FAMILY defined but no known partition matched.
-    // Default to desktop.
-#   define GTEST_OS_WINDOWS_DESKTOP 1
-#  endif
-# else
-#  define GTEST_OS_WINDOWS_DESKTOP 1
-# endif  // _WIN32_WCE
-#elif defined __OS2__
-# define GTEST_OS_OS2 1
-#elif defined __APPLE__
-# define GTEST_OS_MAC 1
-# if TARGET_OS_IPHONE
-#  define GTEST_OS_IOS 1
-# endif
-#elif defined __DragonFly__
-# define GTEST_OS_DRAGONFLY 1
-#elif defined __FreeBSD__
-# define GTEST_OS_FREEBSD 1
-#elif defined __Fuchsia__
-# define GTEST_OS_FUCHSIA 1
-#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__)
-# define GTEST_OS_GNU_KFREEBSD 1
-#elif defined __linux__
-# define GTEST_OS_LINUX 1
-# if defined __ANDROID__
-#  define GTEST_OS_LINUX_ANDROID 1
-# endif
-#elif defined __MVS__
-# define GTEST_OS_ZOS 1
-#elif defined(__sun) && defined(__SVR4)
-# define GTEST_OS_SOLARIS 1
-#elif defined(_AIX)
-# define GTEST_OS_AIX 1
-#elif defined(__hpux)
-# define GTEST_OS_HPUX 1
-#elif defined __native_client__
-# define GTEST_OS_NACL 1
-#elif defined __NetBSD__
-# define GTEST_OS_NETBSD 1
-#elif defined __OpenBSD__
-# define GTEST_OS_OPENBSD 1
-#elif defined __QNX__
-# define GTEST_OS_QNX 1
-#elif defined(__HAIKU__)
-#define GTEST_OS_HAIKU 1
-#endif  // __CYGWIN__
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Injection point for custom user configurations. See README for details
-//
-// ** Custom implementation starts here **
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
-
-#if !defined(GTEST_DEV_EMAIL_)
-# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
-# define GTEST_FLAG_PREFIX_ "gtest_"
-# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
-# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
-# define GTEST_NAME_ "Google Test"
-# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
-#endif  // !defined(GTEST_DEV_EMAIL_)
-
-#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
-# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
-#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
-
-// Determines the version of gcc that is used to compile this.
-#ifdef __GNUC__
-// 40302 means version 4.3.2.
-# define GTEST_GCC_VER_ \
-    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
-#endif  // __GNUC__
-
-// Macros for disabling Microsoft Visual C++ warnings.
-//
-//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
-//   /* code that triggers warnings C4800 and C4385 */
-//   GTEST_DISABLE_MSC_WARNINGS_POP_()
-#if defined(_MSC_VER)
-# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
-    __pragma(warning(push))                        \
-    __pragma(warning(disable: warnings))
-# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
-    __pragma(warning(pop))
-#else
-// Not all compilers are MSVC
-# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
-# define GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif
-
-// Clang on Windows does not understand MSVC's pragma warning.
-// We need clang-specific way to disable function deprecation warning.
-#ifdef __clang__
-# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                         \
-    _Pragma("clang diagnostic push")                                  \
-    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
-    _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
-#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
-    _Pragma("clang diagnostic pop")
-#else
-# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
-# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif
-
-// Brings in definitions for functions used in the testing::internal::posix
-// namespace (read, write, close, chdir, isatty, stat). We do not currently
-// use them on Windows Mobile.
-#if GTEST_OS_WINDOWS
-# if !GTEST_OS_WINDOWS_MOBILE
-#  include <direct.h>
-#  include <io.h>
-# endif
-// In order to avoid having to include <windows.h>, use forward declaration
-#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
-// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two
-// separate (equivalent) structs, instead of using typedef
-typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
-#else
-// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
-// This assumption is verified by
-// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
-typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
-#endif
-#else
-// This assumes that non-Windows OSes provide unistd.h. For OSes where this
-// is not the case, we need to include headers that provide the functions
-// mentioned above.
-# include <unistd.h>
-# include <strings.h>
-#endif  // GTEST_OS_WINDOWS
-
-#if GTEST_OS_LINUX_ANDROID
-// Used to define __ANDROID_API__ matching the target NDK API level.
-#  include <android/api-level.h>  // NOLINT
-#endif
-
-// Defines this to true iff Google Test can use POSIX regular expressions.
-#ifndef GTEST_HAS_POSIX_RE
-# if GTEST_OS_LINUX_ANDROID
-// On Android, <regex.h> is only available starting with Gingerbread.
-#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
-# else
-#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
-# endif
-#endif
-
-#if GTEST_USES_PCRE
-// The appropriate headers have already been included.
-
-#elif GTEST_HAS_POSIX_RE
-
-// On some platforms, <regex.h> needs someone to define size_t, and
-// won't compile otherwise.  We can #include it here as we already
-// included <stdlib.h>, which is guaranteed to define size_t through
-// <stddef.h>.
-# include <regex.h>  // NOLINT
-
-# define GTEST_USES_POSIX_RE 1
-
-#elif GTEST_OS_WINDOWS
-
-// <regex.h> is not available on Windows.  Use our own simple regex
-// implementation instead.
-# define GTEST_USES_SIMPLE_RE 1
-
-#else
-
-// <regex.h> may not be available on this platform.  Use our own
-// simple regex implementation instead.
-# define GTEST_USES_SIMPLE_RE 1
-
-#endif  // GTEST_USES_PCRE
-
-#ifndef GTEST_HAS_EXCEPTIONS
-// The user didn't tell us whether exceptions are enabled, so we need
-// to figure it out.
-# if defined(_MSC_VER) && defined(_CPPUNWIND)
-// MSVC defines _CPPUNWIND to 1 iff exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__BORLANDC__)
-// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
-// macro to enable exceptions, so we'll do the same.
-// Assumes that exceptions are enabled by default.
-#  ifndef _HAS_EXCEPTIONS
-#   define _HAS_EXCEPTIONS 1
-#  endif  // _HAS_EXCEPTIONS
-#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
-# elif defined(__clang__)
-// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,
-// but iff cleanups are enabled after that. In Obj-C++ files, there can be
-// cleanups for ObjC exceptions which also need cleanups, even if C++ exceptions
-// are disabled. clang has __has_feature(cxx_exceptions) which checks for C++
-// exceptions starting at clang r206352, but which checked for cleanups prior to
-// that. To reliably check for C++ exception availability with clang, check for
-// __EXCEPTIONS && __has_feature(cxx_exceptions).
-#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
-# elif defined(__GNUC__) && __EXCEPTIONS
-// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__SUNPRO_CC)
-// Sun Pro CC supports exceptions.  However, there is no compile-time way of
-// detecting whether they are enabled or not.  Therefore, we assume that
-// they are enabled unless the user tells us otherwise.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__IBMCPP__) && __EXCEPTIONS
-// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__HP_aCC)
-// Exception handling is in effect by default in HP aCC compiler. It has to
-// be turned of by +noeh compiler option if desired.
-#  define GTEST_HAS_EXCEPTIONS 1
-# else
-// For other compilers, we assume exceptions are disabled to be
-// conservative.
-#  define GTEST_HAS_EXCEPTIONS 0
-# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
-#endif  // GTEST_HAS_EXCEPTIONS
-
-#if !defined(GTEST_HAS_STD_STRING)
-// Even though we don't use this macro any longer, we keep it in case
-// some clients still depend on it.
-# define GTEST_HAS_STD_STRING 1
-#elif !GTEST_HAS_STD_STRING
-// The user told us that ::std::string isn't available.
-# error "::std::string isn't available."
-#endif  // !defined(GTEST_HAS_STD_STRING)
-
-#ifndef GTEST_HAS_STD_WSTRING
-// The user didn't tell us whether ::std::wstring is available, so we need
-// to figure it out.
-// Cygwin 1.7 and below doesn't support ::std::wstring.
-// Solaris' libc++ doesn't support it either.  Android has
-// no support for it at least as recent as Froyo (2.2).
-#define GTEST_HAS_STD_WSTRING                                         \
-  (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
-     GTEST_OS_HAIKU))
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-// Determines whether RTTI is available.
-#ifndef GTEST_HAS_RTTI
-// The user didn't tell us whether RTTI is enabled, so we need to
-// figure it out.
-
-# ifdef _MSC_VER
-
-#  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
-#   define GTEST_HAS_RTTI 1
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif
-
-// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
-# elif defined(__GNUC__)
-
-#  ifdef __GXX_RTTI
-// When building against STLport with the Android NDK and with
-// -frtti -fno-exceptions, the build fails at link time with undefined
-// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
-// so disable RTTI when detected.
-#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
-       !defined(__EXCEPTIONS)
-#    define GTEST_HAS_RTTI 0
-#   else
-#    define GTEST_HAS_RTTI 1
-#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif  // __GXX_RTTI
-
-// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
-// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
-// first version with C++ support.
-# elif defined(__clang__)
-
-#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
-
-// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
-// both the typeid and dynamic_cast features are present.
-# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
-
-#  ifdef __RTTI_ALL__
-#   define GTEST_HAS_RTTI 1
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif
-
-# else
-
-// For all other compilers, we assume RTTI is enabled.
-#  define GTEST_HAS_RTTI 1
-
-# endif  // _MSC_VER
-
-#endif  // GTEST_HAS_RTTI
-
-// It's this header's responsibility to #include <typeinfo> when RTTI
-// is enabled.
-#if GTEST_HAS_RTTI
-# include <typeinfo>
-#endif
-
-// Determines whether Google Test can use the pthreads library.
-#ifndef GTEST_HAS_PTHREAD
-// The user didn't tell us explicitly, so we make reasonable assumptions about
-// which platforms have pthreads support.
-//
-// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
-// to your compiler flags.
-#define GTEST_HAS_PTHREAD                                                      \
-  (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||          \
-   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
-   GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||          \
-   GTEST_OS_HAIKU)
-#endif  // GTEST_HAS_PTHREAD
-
-#if GTEST_HAS_PTHREAD
-// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
-// true.
-# include <pthread.h>  // NOLINT
-
-// For timespec and nanosleep, used below.
-# include <time.h>  // NOLINT
-#endif
-
-// Determines whether clone(2) is supported.
-// Usually it will only be available on Linux, excluding
-// Linux on the Itanium architecture.
-// Also see http://linux.die.net/man/2/clone.
-#ifndef GTEST_HAS_CLONE
-// The user didn't tell us, so we need to figure it out.
-
-# if GTEST_OS_LINUX && !defined(__ia64__)
-#  if GTEST_OS_LINUX_ANDROID
-// On Android, clone() became available at different API levels for each 32-bit
-// architecture.
-#    if defined(__LP64__) || \
-        (defined(__arm__) && __ANDROID_API__ >= 9) || \
-        (defined(__mips__) && __ANDROID_API__ >= 12) || \
-        (defined(__i386__) && __ANDROID_API__ >= 17)
-#     define GTEST_HAS_CLONE 1
-#    else
-#     define GTEST_HAS_CLONE 0
-#    endif
-#  else
-#   define GTEST_HAS_CLONE 1
-#  endif
-# else
-#  define GTEST_HAS_CLONE 0
-# endif  // GTEST_OS_LINUX && !defined(__ia64__)
-
-#endif  // GTEST_HAS_CLONE
-
-// Determines whether to support stream redirection. This is used to test
-// output correctness and to implement death tests.
-#ifndef GTEST_HAS_STREAM_REDIRECTION
-// By default, we assume that stream redirection is supported on all
-// platforms except known mobile ones.
-# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-#  define GTEST_HAS_STREAM_REDIRECTION 0
-# else
-#  define GTEST_HAS_STREAM_REDIRECTION 1
-# endif  // !GTEST_OS_WINDOWS_MOBILE
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Determines whether to support death tests.
-// pops up a dialog window that cannot be suppressed programmatically.
-#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||             \
-     (GTEST_OS_MAC && !GTEST_OS_IOS) ||                                   \
-     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||  \
-     GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
-     GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||           \
-     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
-# define GTEST_HAS_DEATH_TEST 1
-#endif
-
-// Determines whether to support type-driven tests.
-
-// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
-// Sun Pro CC, IBM Visual Age, and HP aCC support.
-#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
-    defined(__IBMCPP__) || defined(__HP_aCC)
-# define GTEST_HAS_TYPED_TEST 1
-# define GTEST_HAS_TYPED_TEST_P 1
-#endif
-
-// Determines whether the system compiler uses UTF-16 for encoding wide strings.
-#define GTEST_WIDE_STRING_USES_UTF16_ \
-  (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
-
-// Determines whether test results can be streamed to a socket.
-#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
-    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
-# define GTEST_CAN_STREAM_RESULTS_ 1
-#endif
-
-// Defines some utility macros.
-
-// The GNU compiler emits a warning if nested "if" statements are followed by
-// an "else" statement and braces are not used to explicitly disambiguate the
-// "else" binding.  This leads to problems with code like:
-//
-//   if (gate)
-//     ASSERT_*(condition) << "Some message";
-//
-// The "switch (0) case 0:" idiom is used to suppress this.
-#ifdef __INTEL_COMPILER
-# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
-#else
-# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
-#endif
-
-// Use this annotation at the end of a struct/class definition to
-// prevent the compiler from optimizing away instances that are never
-// used.  This is useful when all interesting logic happens inside the
-// c'tor and / or d'tor.  Example:
-//
-//   struct Foo {
-//     Foo() { ... }
-//   } GTEST_ATTRIBUTE_UNUSED_;
-//
-// Also use it after a variable or parameter declaration to tell the
-// compiler the variable/parameter does not have to be used.
-#if defined(__GNUC__) && !defined(COMPILER_ICC)
-# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
-#elif defined(__clang__)
-# if __has_attribute(unused)
-#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
-# endif
-#endif
-#ifndef GTEST_ATTRIBUTE_UNUSED_
-# define GTEST_ATTRIBUTE_UNUSED_
-#endif
-
-// Use this annotation before a function that takes a printf format string.
-#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
-# if defined(__MINGW_PRINTF_FORMAT)
-// MinGW has two different printf implementations. Ensure the format macro
-// matches the selected implementation. See
-// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
-#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
-       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
-                                 first_to_check)))
-# else
-#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
-       __attribute__((__format__(__printf__, string_index, first_to_check)))
-# endif
-#else
-# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
-#endif
-
-
-// A macro to disallow operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_ASSIGN_(type) \
-  void operator=(type const &) = delete
-
-// A macro to disallow copy constructor and operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
-  type(type const &) = delete; \
-  GTEST_DISALLOW_ASSIGN_(type)
-
-// Tell the compiler to warn about unused return values for functions declared
-// with this macro.  The macro should be used on function declarations
-// following the argument list:
-//
-//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
-#if defined(__GNUC__) && !defined(COMPILER_ICC)
-# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
-#else
-# define GTEST_MUST_USE_RESULT_
-#endif  // __GNUC__ && !COMPILER_ICC
-
-// MS C++ compiler emits warning when a conditional expression is compile time
-// constant. In some contexts this warning is false positive and needs to be
-// suppressed. Use the following two macros in such cases:
-//
-// GTEST_INTENTIONAL_CONST_COND_PUSH_()
-// while (true) {
-// GTEST_INTENTIONAL_CONST_COND_POP_()
-// }
-# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
-# define GTEST_INTENTIONAL_CONST_COND_POP_() \
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-// Determine whether the compiler supports Microsoft's Structured Exception
-// Handling.  This is supported by several Windows compilers but generally
-// does not exist on any other system.
-#ifndef GTEST_HAS_SEH
-// The user didn't tell us, so we need to figure it out.
-
-# if defined(_MSC_VER) || defined(__BORLANDC__)
-// These two compilers are known to support SEH.
-#  define GTEST_HAS_SEH 1
-# else
-// Assume no SEH.
-#  define GTEST_HAS_SEH 0
-# endif
-
-#endif  // GTEST_HAS_SEH
-
-#ifndef GTEST_IS_THREADSAFE
-
-#define GTEST_IS_THREADSAFE                                                 \
-  (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                                     \
-   (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
-   GTEST_HAS_PTHREAD)
-
-#endif  // GTEST_IS_THREADSAFE
-
-// GTEST_API_ qualifies all symbols that must be exported. The definitions below
-// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in
-// gtest/internal/custom/gtest-port.h
-#ifndef GTEST_API_
-
-#ifdef _MSC_VER
-# if GTEST_LINKED_AS_SHARED_LIBRARY
-#  define GTEST_API_ __declspec(dllimport)
-# elif GTEST_CREATE_SHARED_LIBRARY
-#  define GTEST_API_ __declspec(dllexport)
-# endif
-#elif __GNUC__ >= 4 || defined(__clang__)
-# define GTEST_API_ __attribute__((visibility ("default")))
-#endif  // _MSC_VER
-
-#endif  // GTEST_API_
-
-#ifndef GTEST_API_
-# define GTEST_API_
-#endif  // GTEST_API_
-
-#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
-# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast"
-#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE
-
-#ifdef __GNUC__
-// Ask the compiler to never inline a given function.
-# define GTEST_NO_INLINE_ __attribute__((noinline))
-#else
-# define GTEST_NO_INLINE_
-#endif
-
-// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
-#if !defined(GTEST_HAS_CXXABI_H_)
-# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
-#  define GTEST_HAS_CXXABI_H_ 1
-# else
-#  define GTEST_HAS_CXXABI_H_ 0
-# endif
-#endif
-
-// A function level attribute to disable checking for use of uninitialized
-// memory when built with MemorySanitizer.
-#if defined(__clang__)
-# if __has_feature(memory_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
-       __attribute__((no_sanitize_memory))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-# endif  // __has_feature(memory_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-#endif  // __clang__
-
-// A function level attribute to disable AddressSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(address_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
-       __attribute__((no_sanitize_address))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-# endif  // __has_feature(address_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-#endif  // __clang__
-
-// A function level attribute to disable HWAddressSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(hwaddress_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
-       __attribute__((no_sanitize("hwaddress")))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-# endif  // __has_feature(hwaddress_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-#endif  // __clang__
-
-// A function level attribute to disable ThreadSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(thread_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
-       __attribute__((no_sanitize_thread))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-# endif  // __has_feature(thread_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-#endif  // __clang__
-
-namespace testing {
-
-class Message;
-
-// Legacy imports for backwards compatibility.
-// New code should use std:: names directly.
-using std::get;
-using std::make_tuple;
-using std::tuple;
-using std::tuple_element;
-using std::tuple_size;
-
-namespace internal {
-
-// A secret type that Google Test users don't know about.  It has no
-// definition on purpose.  Therefore it's impossible to create a
-// Secret object, which is what we want.
-class Secret;
-
-// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
-// time expression is true (in new code, use static_assert instead). For
-// example, you could use it to verify the size of a static array:
-//
-//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
-//                         names_incorrect_size);
-//
-// The second argument to the macro must be a valid C++ identifier. If the
-// expression is false, compiler will issue an error containing this identifier.
-#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
-
-// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
-//
-// This template is declared, but intentionally undefined.
-template <typename T1, typename T2>
-struct StaticAssertTypeEqHelper;
-
-template <typename T>
-struct StaticAssertTypeEqHelper<T, T> {
-  enum { value = true };
-};
-
-// Same as std::is_same<>.
-template <typename T, typename U>
-struct IsSame {
-  enum { value = false };
-};
-template <typename T>
-struct IsSame<T, T> {
-  enum { value = true };
-};
-
-// Evaluates to the number of elements in 'array'.
-#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))
-
-// A helper for suppressing warnings on constant condition.  It just
-// returns 'condition'.
-GTEST_API_ bool IsTrue(bool condition);
-
-// Defines RE.
-
-#if GTEST_USES_PCRE
-// if used, PCRE is injected by custom/gtest-port.h
-#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
-
-// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
-// Regular Expression syntax.
-class GTEST_API_ RE {
- public:
-  // A copy constructor is required by the Standard to initialize object
-  // references from r-values.
-  RE(const RE& other) { Init(other.pattern()); }
-
-  // Constructs an RE from a string.
-  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
-
-  RE(const char* regex) { Init(regex); }  // NOLINT
-  ~RE();
-
-  // Returns the string representation of the regex.
-  const char* pattern() const { return pattern_; }
-
-  // FullMatch(str, re) returns true iff regular expression re matches
-  // the entire str.
-  // PartialMatch(str, re) returns true iff regular expression re
-  // matches a substring of str (including str itself).
-  static bool FullMatch(const ::std::string& str, const RE& re) {
-    return FullMatch(str.c_str(), re);
-  }
-  static bool PartialMatch(const ::std::string& str, const RE& re) {
-    return PartialMatch(str.c_str(), re);
-  }
-
-  static bool FullMatch(const char* str, const RE& re);
-  static bool PartialMatch(const char* str, const RE& re);
-
- private:
-  void Init(const char* regex);
-  const char* pattern_;
-  bool is_valid_;
-
-# if GTEST_USES_POSIX_RE
-
-  regex_t full_regex_;     // For FullMatch().
-  regex_t partial_regex_;  // For PartialMatch().
-
-# else  // GTEST_USES_SIMPLE_RE
-
-  const char* full_pattern_;  // For FullMatch();
-
-# endif
-
-  GTEST_DISALLOW_ASSIGN_(RE);
-};
-
-#endif  // GTEST_USES_PCRE
-
-// Formats a source file path and a line number as they would appear
-// in an error message from the compiler used to compile this code.
-GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
-
-// Formats a file location for compiler-independent XML output.
-// Although this function is not platform dependent, we put it next to
-// FormatFileLocation in order to contrast the two functions.
-GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
-                                                               int line);
-
-// Defines logging utilities:
-//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
-//                          message itself is streamed into the macro.
-//   LogToStderr()  - directs all log messages to stderr.
-//   FlushInfoLog() - flushes informational log messages.
-
-enum GTestLogSeverity {
-  GTEST_INFO,
-  GTEST_WARNING,
-  GTEST_ERROR,
-  GTEST_FATAL
-};
-
-// Formats log entry severity, provides a stream object for streaming the
-// log message, and terminates the message with a newline when going out of
-// scope.
-class GTEST_API_ GTestLog {
- public:
-  GTestLog(GTestLogSeverity severity, const char* file, int line);
-
-  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
-  ~GTestLog();
-
-  ::std::ostream& GetStream() { return ::std::cerr; }
-
- private:
-  const GTestLogSeverity severity_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
-};
-
-#if !defined(GTEST_LOG_)
-
-# define GTEST_LOG_(severity) \
-    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
-                                  __FILE__, __LINE__).GetStream()
-
-inline void LogToStderr() {}
-inline void FlushInfoLog() { fflush(nullptr); }
-
-#endif  // !defined(GTEST_LOG_)
-
-#if !defined(GTEST_CHECK_)
-// INTERNAL IMPLEMENTATION - DO NOT USE.
-//
-// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
-// is not satisfied.
-//  Synopsys:
-//    GTEST_CHECK_(boolean_condition);
-//     or
-//    GTEST_CHECK_(boolean_condition) << "Additional message";
-//
-//    This checks the condition and if the condition is not satisfied
-//    it prints message about the condition violation, including the
-//    condition itself, plus additional message streamed into it, if any,
-//    and then it aborts the program. It aborts the program irrespective of
-//    whether it is built in the debug mode or not.
-# define GTEST_CHECK_(condition) \
-    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-    if (::testing::internal::IsTrue(condition)) \
-      ; \
-    else \
-      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
-#endif  // !defined(GTEST_CHECK_)
-
-// An all-mode assert to verify that the given POSIX-style function
-// call returns 0 (indicating success).  Known limitation: this
-// doesn't expand to a balanced 'if' statement, so enclose the macro
-// in {} if you need to use it as the only statement in an 'if'
-// branch.
-#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
-  if (const int gtest_error = (posix_call)) \
-    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
-                      << gtest_error
-
-// Adds reference to a type if it is not a reference type,
-// otherwise leaves it unchanged.  This is the same as
-// tr1::add_reference, which is not widely available yet.
-template <typename T>
-struct AddReference { typedef T& type; };  // NOLINT
-template <typename T>
-struct AddReference<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper around AddReference that works when the argument T
-// depends on template parameters.
-#define GTEST_ADD_REFERENCE_(T) \
-    typename ::testing::internal::AddReference<T>::type
-
-// Transforms "T" into "const T&" according to standard reference collapsing
-// rules (this is only needed as a backport for C++98 compilers that do not
-// support reference collapsing). Specifically, it transforms:
-//
-//   char         ==> const char&
-//   const char   ==> const char&
-//   char&        ==> char&
-//   const char&  ==> const char&
-//
-// Note that the non-const reference will not have "const" added. This is
-// standard, and necessary so that "T" can always bind to "const T&".
-template <typename T>
-struct ConstRef { typedef const T& type; };
-template <typename T>
-struct ConstRef<T&> { typedef T& type; };
-
-// The argument T must depend on some template parameters.
-#define GTEST_REFERENCE_TO_CONST_(T) \
-  typename ::testing::internal::ConstRef<T>::type
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Use ImplicitCast_ as a safe version of static_cast for upcasting in
-// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
-// const Foo*).  When you use ImplicitCast_, the compiler checks that
-// the cast is safe.  Such explicit ImplicitCast_s are necessary in
-// surprisingly many situations where C++ demands an exact type match
-// instead of an argument type convertable to a target type.
-//
-// The syntax for using ImplicitCast_ is the same as for static_cast:
-//
-//   ImplicitCast_<ToType>(expr)
-//
-// ImplicitCast_ would have been part of the C++ standard library,
-// but the proposal was submitted too late.  It will probably make
-// its way into the language in the future.
-//
-// This relatively ugly name is intentional. It prevents clashes with
-// similar functions users may have (e.g., implicit_cast). The internal
-// namespace alone is not enough because the function can be found by ADL.
-template<typename To>
-inline To ImplicitCast_(To x) { return x; }
-
-// When you upcast (that is, cast a pointer from type Foo to type
-// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
-// always succeed.  When you downcast (that is, cast a pointer from
-// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
-// how do you know the pointer is really of type SubclassOfFoo?  It
-// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
-// when you downcast, you should use this macro.  In debug mode, we
-// use dynamic_cast<> to double-check the downcast is legal (we die
-// if it's not).  In normal mode, we do the efficient static_cast<>
-// instead.  Thus, it's important to test in debug mode to make sure
-// the cast is legal!
-//    This is the only place in the code we should use dynamic_cast<>.
-// In particular, you SHOULDN'T be using dynamic_cast<> in order to
-// do RTTI (eg code like this:
-//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
-//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
-// You should design the code some other way not to need this.
-//
-// This relatively ugly name is intentional. It prevents clashes with
-// similar functions users may have (e.g., down_cast). The internal
-// namespace alone is not enough because the function can be found by ADL.
-template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
-inline To DownCast_(From* f) {  // so we only accept pointers
-  // Ensures that To is a sub-type of From *.  This test is here only
-  // for compile-time type checking, and has no overhead in an
-  // optimized build at run-time, as it will be optimized away
-  // completely.
-  GTEST_INTENTIONAL_CONST_COND_PUSH_()
-  if (false) {
-  GTEST_INTENTIONAL_CONST_COND_POP_()
-  const To to = nullptr;
-  ::testing::internal::ImplicitCast_<From*>(to);
-  }
-
-#if GTEST_HAS_RTTI
-  // RTTI: debug mode only!
-  GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr);
-#endif
-  return static_cast<To>(f);
-}
-
-// Downcasts the pointer of type Base to Derived.
-// Derived must be a subclass of Base. The parameter MUST
-// point to a class of type Derived, not any subclass of it.
-// When RTTI is available, the function performs a runtime
-// check to enforce this.
-template <class Derived, class Base>
-Derived* CheckedDowncastToActualType(Base* base) {
-#if GTEST_HAS_RTTI
-  GTEST_CHECK_(typeid(*base) == typeid(Derived));
-#endif
-
-#if GTEST_HAS_DOWNCAST_
-  return ::down_cast<Derived*>(base);
-#elif GTEST_HAS_RTTI
-  return dynamic_cast<Derived*>(base);  // NOLINT
-#else
-  return static_cast<Derived*>(base);  // Poor man's downcast.
-#endif
-}
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Defines the stderr capturer:
-//   CaptureStdout     - starts capturing stdout.
-//   GetCapturedStdout - stops capturing stdout and returns the captured string.
-//   CaptureStderr     - starts capturing stderr.
-//   GetCapturedStderr - stops capturing stderr and returns the captured string.
-//
-GTEST_API_ void CaptureStdout();
-GTEST_API_ std::string GetCapturedStdout();
-GTEST_API_ void CaptureStderr();
-GTEST_API_ std::string GetCapturedStderr();
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-// Returns the size (in bytes) of a file.
-GTEST_API_ size_t GetFileSize(FILE* file);
-
-// Reads the entire content of a file as a string.
-GTEST_API_ std::string ReadEntireFile(FILE* file);
-
-// All command line arguments.
-GTEST_API_ std::vector<std::string> GetArgvs();
-
-#if GTEST_HAS_DEATH_TEST
-
-std::vector<std::string> GetInjectableArgvs();
-// Deprecated: pass the args vector by value instead.
-void SetInjectableArgvs(const std::vector<std::string>* new_argvs);
-void SetInjectableArgvs(const std::vector<std::string>& new_argvs);
-void ClearInjectableArgvs();
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-// Defines synchronization primitives.
-#if GTEST_IS_THREADSAFE
-# if GTEST_HAS_PTHREAD
-// Sleeps for (roughly) n milliseconds.  This function is only for testing
-// Google Test's own constructs.  Don't use it in user tests, either
-// directly or indirectly.
-inline void SleepMilliseconds(int n) {
-  const timespec time = {
-    0,                  // 0 seconds.
-    n * 1000L * 1000L,  // And n ms.
-  };
-  nanosleep(&time, nullptr);
-}
-# endif  // GTEST_HAS_PTHREAD
-
-# if GTEST_HAS_NOTIFICATION_
-// Notification has already been imported into the namespace.
-// Nothing to do here.
-
-# elif GTEST_HAS_PTHREAD
-// Allows a controller thread to pause execution of newly created
-// threads until notified.  Instances of this class must be created
-// and destroyed in the controller thread.
-//
-// This class is only for testing Google Test's own constructs. Do not
-// use it in user tests, either directly or indirectly.
-class Notification {
- public:
-  Notification() : notified_(false) {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
-  }
-  ~Notification() {
-    pthread_mutex_destroy(&mutex_);
-  }
-
-  // Notifies all threads created with this notification to start. Must
-  // be called from the controller thread.
-  void Notify() {
-    pthread_mutex_lock(&mutex_);
-    notified_ = true;
-    pthread_mutex_unlock(&mutex_);
-  }
-
-  // Blocks until the controller thread notifies. Must be called from a test
-  // thread.
-  void WaitForNotification() {
-    for (;;) {
-      pthread_mutex_lock(&mutex_);
-      const bool notified = notified_;
-      pthread_mutex_unlock(&mutex_);
-      if (notified)
-        break;
-      SleepMilliseconds(10);
-    }
-  }
-
- private:
-  pthread_mutex_t mutex_;
-  bool notified_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
-};
-
-# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-GTEST_API_ void SleepMilliseconds(int n);
-
-// Provides leak-safe Windows kernel handle ownership.
-// Used in death tests and in threading support.
-class GTEST_API_ AutoHandle {
- public:
-  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
-  // avoid including <windows.h> in this header file. Including <windows.h> is
-  // undesirable because it defines a lot of symbols and macros that tend to
-  // conflict with client code. This assumption is verified by
-  // WindowsTypesTest.HANDLEIsVoidStar.
-  typedef void* Handle;
-  AutoHandle();
-  explicit AutoHandle(Handle handle);
-
-  ~AutoHandle();
-
-  Handle Get() const;
-  void Reset();
-  void Reset(Handle handle);
-
- private:
-  // Returns true iff the handle is a valid handle object that can be closed.
-  bool IsCloseable() const;
-
-  Handle handle_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
-};
-
-// Allows a controller thread to pause execution of newly created
-// threads until notified.  Instances of this class must be created
-// and destroyed in the controller thread.
-//
-// This class is only for testing Google Test's own constructs. Do not
-// use it in user tests, either directly or indirectly.
-class GTEST_API_ Notification {
- public:
-  Notification();
-  void Notify();
-  void WaitForNotification();
-
- private:
-  AutoHandle event_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
-};
-# endif  // GTEST_HAS_NOTIFICATION_
-
-// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
-// defined, but we don't want to use MinGW's pthreads implementation, which
-// has conformance problems with some versions of the POSIX standard.
-# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
-
-// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
-// Consequently, it cannot select a correct instantiation of ThreadWithParam
-// in order to call its Run(). Introducing ThreadWithParamBase as a
-// non-templated base class for ThreadWithParam allows us to bypass this
-// problem.
-class ThreadWithParamBase {
- public:
-  virtual ~ThreadWithParamBase() {}
-  virtual void Run() = 0;
-};
-
-// pthread_create() accepts a pointer to a function type with the C linkage.
-// According to the Standard (7.5/1), function types with different linkages
-// are different even if they are otherwise identical.  Some compilers (for
-// example, SunStudio) treat them as different types.  Since class methods
-// cannot be defined with C-linkage we need to define a free C-function to
-// pass into pthread_create().
-extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
-  static_cast<ThreadWithParamBase*>(thread)->Run();
-  return nullptr;
-}
-
-// Helper class for testing Google Test's multi-threading constructs.
-// To use it, write:
-//
-//   void ThreadFunc(int param) { /* Do things with param */ }
-//   Notification thread_can_start;
-//   ...
-//   // The thread_can_start parameter is optional; you can supply NULL.
-//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
-//   thread_can_start.Notify();
-//
-// These classes are only for testing Google Test's own constructs. Do
-// not use them in user tests, either directly or indirectly.
-template <typename T>
-class ThreadWithParam : public ThreadWithParamBase {
- public:
-  typedef void UserThreadFunc(T);
-
-  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
-      : func_(func),
-        param_(param),
-        thread_can_start_(thread_can_start),
-        finished_(false) {
-    ThreadWithParamBase* const base = this;
-    // The thread can be created only after all fields except thread_
-    // have been initialized.
-    GTEST_CHECK_POSIX_SUCCESS_(
-        pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));
-  }
-  ~ThreadWithParam() override { Join(); }
-
-  void Join() {
-    if (!finished_) {
-      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));
-      finished_ = true;
-    }
-  }
-
-  void Run() override {
-    if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification();
-    func_(param_);
-  }
-
- private:
-  UserThreadFunc* const func_;  // User-supplied thread function.
-  const T param_;  // User-supplied parameter to the thread function.
-  // When non-NULL, used to block execution until the controller thread
-  // notifies.
-  Notification* const thread_can_start_;
-  bool finished_;  // true iff we know that the thread function has finished.
-  pthread_t thread_;  // The native thread object.
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
-};
-# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
-         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-
-# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-// Mutex and ThreadLocal have already been imported into the namespace.
-// Nothing to do here.
-
-# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-// Mutex implements mutex on Windows platforms.  It is used in conjunction
-// with class MutexLock:
-//
-//   Mutex mutex;
-//   ...
-//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
-//                            // end of the current scope.
-//
-// A static Mutex *must* be defined or declared using one of the following
-// macros:
-//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
-//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
-//
-// (A non-static Mutex is defined/declared in the usual way).
-class GTEST_API_ Mutex {
- public:
-  enum MutexType { kStatic = 0, kDynamic = 1 };
-  // We rely on kStaticMutex being 0 as it is to what the linker initializes
-  // type_ in static mutexes.  critical_section_ will be initialized lazily
-  // in ThreadSafeLazyInit().
-  enum StaticConstructorSelector { kStaticMutex = 0 };
-
-  // This constructor intentionally does nothing.  It relies on type_ being
-  // statically initialized to 0 (effectively setting it to kStatic) and on
-  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
-  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
-
-  Mutex();
-  ~Mutex();
-
-  void Lock();
-
-  void Unlock();
-
-  // Does nothing if the current thread holds the mutex. Otherwise, crashes
-  // with high probability.
-  void AssertHeld();
-
- private:
-  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
-  void ThreadSafeLazyInit();
-
-  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503,
-  // we assume that 0 is an invalid value for thread IDs.
-  unsigned int owner_thread_id_;
-
-  // For static mutexes, we rely on these members being initialized to zeros
-  // by the linker.
-  MutexType type_;
-  long critical_section_init_phase_;  // NOLINT
-  GTEST_CRITICAL_SECTION* critical_section_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
-};
-
-# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-    extern ::testing::internal::Mutex mutex
-
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(Mutex* mutex)
-      : mutex_(mutex) { mutex_->Lock(); }
-
-  ~GTestMutexLock() { mutex_->Unlock(); }
-
- private:
-  Mutex* const mutex_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
-};
-
-typedef GTestMutexLock MutexLock;
-
-// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
-// without knowing its type.
-class ThreadLocalValueHolderBase {
- public:
-  virtual ~ThreadLocalValueHolderBase() {}
-};
-
-// Provides a way for a thread to send notifications to a ThreadLocal
-// regardless of its parameter type.
-class ThreadLocalBase {
- public:
-  // Creates a new ValueHolder<T> object holding a default value passed to
-  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
-  // responsibility not to call this when the ThreadLocal<T> instance already
-  // has a value on the current thread.
-  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
-
- protected:
-  ThreadLocalBase() {}
-  virtual ~ThreadLocalBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
-};
-
-// Maps a thread to a set of ThreadLocals that have values instantiated on that
-// thread and notifies them when the thread exits.  A ThreadLocal instance is
-// expected to persist until all threads it has values on have terminated.
-class GTEST_API_ ThreadLocalRegistry {
- public:
-  // Registers thread_local_instance as having value on the current thread.
-  // Returns a value that can be used to identify the thread from other threads.
-  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance);
-
-  // Invoked when a ThreadLocal instance is destroyed.
-  static void OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance);
-};
-
-class GTEST_API_ ThreadWithParamBase {
- public:
-  void Join();
-
- protected:
-  class Runnable {
-   public:
-    virtual ~Runnable() {}
-    virtual void Run() = 0;
-  };
-
-  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
-  virtual ~ThreadWithParamBase();
-
- private:
-  AutoHandle thread_;
-};
-
-// Helper class for testing Google Test's multi-threading constructs.
-template <typename T>
-class ThreadWithParam : public ThreadWithParamBase {
- public:
-  typedef void UserThreadFunc(T);
-
-  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
-      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
-  }
-  virtual ~ThreadWithParam() {}
-
- private:
-  class RunnableImpl : public Runnable {
-   public:
-    RunnableImpl(UserThreadFunc* func, T param)
-        : func_(func),
-          param_(param) {
-    }
-    virtual ~RunnableImpl() {}
-    virtual void Run() {
-      func_(param_);
-    }
-
-   private:
-    UserThreadFunc* const func_;
-    const T param_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
-  };
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
-};
-
-// Implements thread-local storage on Windows systems.
-//
-//   // Thread 1
-//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
-//
-//   // Thread 2
-//   tl.set(150);  // Changes the value for thread 2 only.
-//   EXPECT_EQ(150, tl.get());
-//
-//   // Thread 1
-//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
-//   tl.set(200);
-//   EXPECT_EQ(200, tl.get());
-//
-// The template type argument T must have a public copy constructor.
-// In addition, the default ThreadLocal constructor requires T to have
-// a public default constructor.
-//
-// The users of a TheadLocal instance have to make sure that all but one
-// threads (including the main one) using that instance have exited before
-// destroying it. Otherwise, the per-thread objects managed for them by the
-// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
-//
-// Google Test only uses global ThreadLocal objects.  That means they
-// will die after main() has returned.  Therefore, no per-thread
-// object managed by Google Test will be leaked as long as all threads
-// using Google Test have exited when main() returns.
-template <typename T>
-class ThreadLocal : public ThreadLocalBase {
- public:
-  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
-  explicit ThreadLocal(const T& value)
-      : default_factory_(new InstanceValueHolderFactory(value)) {}
-
-  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
-
-  T* pointer() { return GetOrCreateValue(); }
-  const T* pointer() const { return GetOrCreateValue(); }
-  const T& get() const { return *pointer(); }
-  void set(const T& value) { *pointer() = value; }
-
- private:
-  // Holds a value of T.  Can be deleted via its base class without the caller
-  // knowing the type of T.
-  class ValueHolder : public ThreadLocalValueHolderBase {
-   public:
-    ValueHolder() : value_() {}
-    explicit ValueHolder(const T& value) : value_(value) {}
-
-    T* pointer() { return &value_; }
-
-   private:
-    T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
-  };
-
-
-  T* GetOrCreateValue() const {
-    return static_cast<ValueHolder*>(
-        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
-  }
-
-  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
-    return default_factory_->MakeNewHolder();
-  }
-
-  class ValueHolderFactory {
-   public:
-    ValueHolderFactory() {}
-    virtual ~ValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const = 0;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
-  };
-
-  class DefaultValueHolderFactory : public ValueHolderFactory {
-   public:
-    DefaultValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
-  };
-
-  class InstanceValueHolderFactory : public ValueHolderFactory {
-   public:
-    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
-    virtual ValueHolder* MakeNewHolder() const {
-      return new ValueHolder(value_);
-    }
-
-   private:
-    const T value_;  // The value for each thread.
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
-  };
-
-  std::unique_ptr<ValueHolderFactory> default_factory_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
-};
-
-# elif GTEST_HAS_PTHREAD
-
-// MutexBase and Mutex implement mutex on pthreads-based platforms.
-class MutexBase {
- public:
-  // Acquires this mutex.
-  void Lock() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
-    owner_ = pthread_self();
-    has_owner_ = true;
-  }
-
-  // Releases this mutex.
-  void Unlock() {
-    // Since the lock is being released the owner_ field should no longer be
-    // considered valid. We don't protect writing to has_owner_ here, as it's
-    // the caller's responsibility to ensure that the current thread holds the
-    // mutex when this is called.
-    has_owner_ = false;
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
-  }
-
-  // Does nothing if the current thread holds the mutex. Otherwise, crashes
-  // with high probability.
-  void AssertHeld() const {
-    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
-        << "The current thread is not holding the mutex @" << this;
-  }
-
-  // A static mutex may be used before main() is entered.  It may even
-  // be used before the dynamic initialization stage.  Therefore we
-  // must be able to initialize a static mutex object at link time.
-  // This means MutexBase has to be a POD and its member variables
-  // have to be public.
- public:
-  pthread_mutex_t mutex_;  // The underlying pthread mutex.
-  // has_owner_ indicates whether the owner_ field below contains a valid thread
-  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
-  // accesses to the owner_ field should be protected by a check of this field.
-  // An alternative might be to memset() owner_ to all zeros, but there's no
-  // guarantee that a zero'd pthread_t is necessarily invalid or even different
-  // from pthread_self().
-  bool has_owner_;
-  pthread_t owner_;  // The thread holding the mutex.
-};
-
-// Forward-declares a static mutex.
-#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-     extern ::testing::internal::MutexBase mutex
-
-// Defines and statically (i.e. at link time) initializes a static mutex.
-// The initialization list here does not explicitly initialize each field,
-// instead relying on default initialization for the unspecified fields. In
-// particular, the owner_ field (a pthread_t) is not explicitly initialized.
-// This allows initialization to work whether pthread_t is a scalar or struct.
-// The flag -Wmissing-field-initializers must not be specified for this to work.
-#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-  ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}
-
-// The Mutex class can only be used for mutexes created at runtime. It
-// shares its API with MutexBase otherwise.
-class Mutex : public MutexBase {
- public:
-  Mutex() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
-    has_owner_ = false;
-  }
-  ~Mutex() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
-};
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(MutexBase* mutex)
-      : mutex_(mutex) { mutex_->Lock(); }
-
-  ~GTestMutexLock() { mutex_->Unlock(); }
-
- private:
-  MutexBase* const mutex_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
-};
-
-typedef GTestMutexLock MutexLock;
-
-// Helpers for ThreadLocal.
-
-// pthread_key_create() requires DeleteThreadLocalValue() to have
-// C-linkage.  Therefore it cannot be templatized to access
-// ThreadLocal<T>.  Hence the need for class
-// ThreadLocalValueHolderBase.
-class ThreadLocalValueHolderBase {
- public:
-  virtual ~ThreadLocalValueHolderBase() {}
-};
-
-// Called by pthread to delete thread-local data stored by
-// pthread_setspecific().
-extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
-  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
-}
-
-// Implements thread-local storage on pthreads-based systems.
-template <typename T>
-class GTEST_API_ ThreadLocal {
- public:
-  ThreadLocal()
-      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
-  explicit ThreadLocal(const T& value)
-      : key_(CreateKey()),
-        default_factory_(new InstanceValueHolderFactory(value)) {}
-
-  ~ThreadLocal() {
-    // Destroys the managed object for the current thread, if any.
-    DeleteThreadLocalValue(pthread_getspecific(key_));
-
-    // Releases resources associated with the key.  This will *not*
-    // delete managed objects for other threads.
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
-  }
-
-  T* pointer() { return GetOrCreateValue(); }
-  const T* pointer() const { return GetOrCreateValue(); }
-  const T& get() const { return *pointer(); }
-  void set(const T& value) { *pointer() = value; }
-
- private:
-  // Holds a value of type T.
-  class ValueHolder : public ThreadLocalValueHolderBase {
-   public:
-    ValueHolder() : value_() {}
-    explicit ValueHolder(const T& value) : value_(value) {}
-
-    T* pointer() { return &value_; }
-
-   private:
-    T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
-  };
-
-  static pthread_key_t CreateKey() {
-    pthread_key_t key;
-    // When a thread exits, DeleteThreadLocalValue() will be called on
-    // the object managed for that thread.
-    GTEST_CHECK_POSIX_SUCCESS_(
-        pthread_key_create(&key, &DeleteThreadLocalValue));
-    return key;
-  }
-
-  T* GetOrCreateValue() const {
-    ThreadLocalValueHolderBase* const holder =
-        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
-    if (holder != nullptr) {
-      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
-    }
-
-    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
-    ThreadLocalValueHolderBase* const holder_base = new_holder;
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
-    return new_holder->pointer();
-  }
-
-  class ValueHolderFactory {
-   public:
-    ValueHolderFactory() {}
-    virtual ~ValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const = 0;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
-  };
-
-  class DefaultValueHolderFactory : public ValueHolderFactory {
-   public:
-    DefaultValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
-  };
-
-  class InstanceValueHolderFactory : public ValueHolderFactory {
-   public:
-    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
-    virtual ValueHolder* MakeNewHolder() const {
-      return new ValueHolder(value_);
-    }
-
-   private:
-    const T value_;  // The value for each thread.
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
-  };
-
-  // A key pthreads uses for looking up per-thread values.
-  const pthread_key_t key_;
-  std::unique_ptr<ValueHolderFactory> default_factory_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
-};
-
-# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-
-#else  // GTEST_IS_THREADSAFE
-
-// A dummy implementation of synchronization primitives (mutex, lock,
-// and thread-local variable).  Necessary for compiling Google Test where
-// mutex is not supported - using Google Test in multiple threads is not
-// supported on such platforms.
-
-class Mutex {
- public:
-  Mutex() {}
-  void Lock() {}
-  void Unlock() {}
-  void AssertHeld() const {}
-};
-
-# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-  extern ::testing::internal::Mutex mutex
-
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(Mutex*) {}  // NOLINT
-};
-
-typedef GTestMutexLock MutexLock;
-
-template <typename T>
-class GTEST_API_ ThreadLocal {
- public:
-  ThreadLocal() : value_() {}
-  explicit ThreadLocal(const T& value) : value_(value) {}
-  T* pointer() { return &value_; }
-  const T* pointer() const { return &value_; }
-  const T& get() const { return value_; }
-  void set(const T& value) { value_ = value; }
- private:
-  T value_;
-};
-
-#endif  // GTEST_IS_THREADSAFE
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-GTEST_API_ size_t GetThreadCount();
-
-template <bool bool_value>
-struct bool_constant {
-  typedef bool_constant<bool_value> type;
-  static const bool value = bool_value;
-};
-template <bool bool_value> const bool bool_constant<bool_value>::value;
-
-typedef bool_constant<false> false_type;
-typedef bool_constant<true> true_type;
-
-template <typename T, typename U>
-struct is_same : public false_type {};
-
-template <typename T>
-struct is_same<T, T> : public true_type {};
-
-template <typename Iterator>
-struct IteratorTraits {
-  typedef typename Iterator::value_type value_type;
-};
-
-
-template <typename T>
-struct IteratorTraits<T*> {
-  typedef T value_type;
-};
-
-template <typename T>
-struct IteratorTraits<const T*> {
-  typedef T value_type;
-};
-
-#if GTEST_OS_WINDOWS
-# define GTEST_PATH_SEP_ "\\"
-# define GTEST_HAS_ALT_PATH_SEP_ 1
-// The biggest signed integer type the compiler supports.
-typedef __int64 BiggestInt;
-#else
-# define GTEST_PATH_SEP_ "/"
-# define GTEST_HAS_ALT_PATH_SEP_ 0
-typedef long long BiggestInt;  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-
-// Utilities for char.
-
-// isspace(int ch) and friends accept an unsigned char or EOF.  char
-// may be signed, depending on the compiler (or compiler flags).
-// Therefore we need to cast a char to unsigned char before calling
-// isspace(), etc.
-
-inline bool IsAlpha(char ch) {
-  return isalpha(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsAlNum(char ch) {
-  return isalnum(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsDigit(char ch) {
-  return isdigit(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsLower(char ch) {
-  return islower(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsSpace(char ch) {
-  return isspace(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsUpper(char ch) {
-  return isupper(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsXDigit(char ch) {
-  return isxdigit(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsXDigit(wchar_t ch) {
-  const unsigned char low_byte = static_cast<unsigned char>(ch);
-  return ch == low_byte && isxdigit(low_byte) != 0;
-}
-
-inline char ToLower(char ch) {
-  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
-}
-inline char ToUpper(char ch) {
-  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
-}
-
-inline std::string StripTrailingSpaces(std::string str) {
-  std::string::iterator it = str.end();
-  while (it != str.begin() && IsSpace(*--it))
-    it = str.erase(it);
-  return str;
-}
-
-// The testing::internal::posix namespace holds wrappers for common
-// POSIX functions.  These wrappers hide the differences between
-// Windows/MSVC and POSIX systems.  Since some compilers define these
-// standard functions as macros, the wrapper cannot have the same name
-// as the wrapped function.
-
-namespace posix {
-
-// Functions with a different name on Windows.
-
-#if GTEST_OS_WINDOWS
-
-typedef struct _stat StatStruct;
-
-# ifdef __BORLANDC__
-inline int IsATTY(int fd) { return isatty(fd); }
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return stricmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return strdup(src); }
-# else  // !__BORLANDC__
-#  if GTEST_OS_WINDOWS_MOBILE
-inline int IsATTY(int /* fd */) { return 0; }
-#  else
-inline int IsATTY(int fd) { return _isatty(fd); }
-#  endif  // GTEST_OS_WINDOWS_MOBILE
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return _stricmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return _strdup(src); }
-# endif  // __BORLANDC__
-
-# if GTEST_OS_WINDOWS_MOBILE
-inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
-// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
-// time and thus not defined there.
-# else
-inline int FileNo(FILE* file) { return _fileno(file); }
-inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
-inline int RmDir(const char* dir) { return _rmdir(dir); }
-inline bool IsDir(const StatStruct& st) {
-  return (_S_IFDIR & st.st_mode) != 0;
-}
-# endif  // GTEST_OS_WINDOWS_MOBILE
-
-#else
-
-typedef struct stat StatStruct;
-
-inline int FileNo(FILE* file) { return fileno(file); }
-inline int IsATTY(int fd) { return isatty(fd); }
-inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return strcasecmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return strdup(src); }
-inline int RmDir(const char* dir) { return rmdir(dir); }
-inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
-
-#endif  // GTEST_OS_WINDOWS
-
-// Functions deprecated by MSVC 8.0.
-
-GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
-
-inline const char* StrNCpy(char* dest, const char* src, size_t n) {
-  return strncpy(dest, src, n);
-}
-
-// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
-// StrError() aren't needed on Windows CE at this time and thus not
-// defined there.
-
-#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-inline int ChDir(const char* dir) { return chdir(dir); }
-#endif
-inline FILE* FOpen(const char* path, const char* mode) {
-  return fopen(path, mode);
-}
-#if !GTEST_OS_WINDOWS_MOBILE
-inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
-  return freopen(path, mode, stream);
-}
-inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
-#endif
-inline int FClose(FILE* fp) { return fclose(fp); }
-#if !GTEST_OS_WINDOWS_MOBILE
-inline int Read(int fd, void* buf, unsigned int count) {
-  return static_cast<int>(read(fd, buf, count));
-}
-inline int Write(int fd, const void* buf, unsigned int count) {
-  return static_cast<int>(write(fd, buf, count));
-}
-inline int Close(int fd) { return close(fd); }
-inline const char* StrError(int errnum) { return strerror(errnum); }
-#endif
-inline const char* GetEnv(const char* name) {
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-  // We are on Windows CE, which has no environment variables.
-  static_cast<void>(name);  // To prevent 'unused argument' warning.
-  return nullptr;
-#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
-  // Environment variables which we programmatically clear will be set to the
-  // empty string rather than unset (NULL).  Handle that case.
-  const char* const env = getenv(name);
-  return (env != nullptr && env[0] != '\0') ? env : nullptr;
-#else
-  return getenv(name);
-#endif
-}
-
-GTEST_DISABLE_MSC_DEPRECATED_POP_()
-
-#if GTEST_OS_WINDOWS_MOBILE
-// Windows CE has no C library. The abort() function is used in
-// several places in Google Test. This implementation provides a reasonable
-// imitation of standard behaviour.
-[[noreturn]] void Abort();
-#else
-[[noreturn]] inline void Abort() { abort(); }
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-}  // namespace posix
-
-// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
-// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
-// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
-// function in order to achieve that.  We use macro definition here because
-// snprintf is a variadic function.
-#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
-// MSVC 2005 and above support variadic macros.
-# define GTEST_SNPRINTF_(buffer, size, format, ...) \
-     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
-#elif defined(_MSC_VER)
-// Windows CE does not define _snprintf_s
-# define GTEST_SNPRINTF_ _snprintf
-#else
-# define GTEST_SNPRINTF_ snprintf
-#endif
-
-// The maximum number a BiggestInt can represent.  This definition
-// works no matter BiggestInt is represented in one's complement or
-// two's complement.
-//
-// We cannot rely on numeric_limits in STL, as __int64 and long long
-// are not part of standard C++ and numeric_limits doesn't need to be
-// defined for them.
-const BiggestInt kMaxBiggestInt =
-    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
-
-// This template class serves as a compile-time function from size to
-// type.  It maps a size in bytes to a primitive type with that
-// size. e.g.
-//
-//   TypeWithSize<4>::UInt
-//
-// is typedef-ed to be unsigned int (unsigned integer made up of 4
-// bytes).
-//
-// Such functionality should belong to STL, but I cannot find it
-// there.
-//
-// Google Test uses this class in the implementation of floating-point
-// comparison.
-//
-// For now it only handles UInt (unsigned int) as that's all Google Test
-// needs.  Other types can be easily added in the future if need
-// arises.
-template <size_t size>
-class TypeWithSize {
- public:
-  // This prevents the user from using TypeWithSize<N> with incorrect
-  // values of N.
-  typedef void UInt;
-};
-
-// The specialization for size 4.
-template <>
-class TypeWithSize<4> {
- public:
-  // unsigned int has size 4 in both gcc and MSVC.
-  //
-  // As base/basictypes.h doesn't compile on Windows, we cannot use
-  // uint32, uint64, and etc here.
-  typedef int Int;
-  typedef unsigned int UInt;
-};
-
-// The specialization for size 8.
-template <>
-class TypeWithSize<8> {
- public:
-#if GTEST_OS_WINDOWS
-  typedef __int64 Int;
-  typedef unsigned __int64 UInt;
-#else
-  typedef long long Int;  // NOLINT
-  typedef unsigned long long UInt;  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-};
-
-// Integer types of known sizes.
-typedef TypeWithSize<4>::Int Int32;
-typedef TypeWithSize<4>::UInt UInt32;
-typedef TypeWithSize<8>::Int Int64;
-typedef TypeWithSize<8>::UInt UInt64;
-typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
-
-// Utilities for command line flags and environment variables.
-
-// Macro for referencing flags.
-#if !defined(GTEST_FLAG)
-# define GTEST_FLAG(name) FLAGS_gtest_##name
-#endif  // !defined(GTEST_FLAG)
-
-#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
-# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
-#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
-
-#if !defined(GTEST_DECLARE_bool_)
-# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
-
-// Macros for declaring flags.
-# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
-# define GTEST_DECLARE_int32_(name) \
-    GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
-# define GTEST_DECLARE_string_(name) \
-    GTEST_API_ extern ::std::string GTEST_FLAG(name)
-
-// Macros for defining flags.
-# define GTEST_DEFINE_bool_(name, default_val, doc) \
-    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
-# define GTEST_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
-# define GTEST_DEFINE_string_(name, default_val, doc) \
-    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
-
-#endif  // !defined(GTEST_DECLARE_bool_)
-
-// Thread annotations
-#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
-# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
-# define GTEST_LOCK_EXCLUDED_(locks)
-#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
-
-// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
-// to *value and returns true; otherwise leaves *value unchanged and returns
-// false.
-bool ParseInt32(const Message& src_text, const char* str, Int32* value);
-
-// Parses a bool/Int32/string from the environment variable
-// corresponding to the given Google Test flag.
-bool BoolFromGTestEnv(const char* flag, bool default_val);
-GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
-std::string OutputFlagAlsoCheckEnvVar();
-const char* StringFromGTestEnv(const char* flag, const char* default_val);
-
-}  // namespace internal
-}  // namespace testing
-
-#if !defined(GTEST_INTERNAL_DEPRECATED)
-
-// Internal Macro to mark an API deprecated, for googletest usage only
-// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or
-// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of
-// a deprecated entity will trigger a warning when compiled with
-// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler).
-// For msvc /W3 option will need to be used
-// Note that for 'other' compilers this macro evaluates to nothing to prevent
-// compilations errors.
-#if defined(_MSC_VER)
-#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
-#elif defined(__GNUC__)
-#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
-#else
-#define GTEST_INTERNAL_DEPRECATED(message)
-#endif
-
-#endif  // !defined(GTEST_INTERNAL_DEPRECATED)
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-
-#if GTEST_OS_LINUX
-# include <stdlib.h>
-# include <sys/types.h>
-# include <sys/wait.h>
-# include <unistd.h>
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>
-#endif
-
-#include <ctype.h>
-#include <float.h>
-#include <string.h>
-#include <iomanip>
-#include <limits>
-#include <map>
-#include <set>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This header file defines the Message class.
-//
-// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
-// leave some internal implementation details in this header file.
-// They are clearly marked by comments like this:
-//
-//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-//
-// Such code is NOT meant to be used by a user directly, and is subject
-// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
-// program!
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-
-#include <limits>
-#include <memory>
-
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-// Ensures that there is at least one operator<< in the global namespace.
-// See Message& operator<<(...) below for why.
-void operator<<(const testing::internal::Secret&, int);
-
-namespace testing {
-
-// The Message class works like an ostream repeater.
-//
-// Typical usage:
-//
-//   1. You stream a bunch of values to a Message object.
-//      It will remember the text in a stringstream.
-//   2. Then you stream the Message object to an ostream.
-//      This causes the text in the Message to be streamed
-//      to the ostream.
-//
-// For example;
-//
-//   testing::Message foo;
-//   foo << 1 << " != " << 2;
-//   std::cout << foo;
-//
-// will print "1 != 2".
-//
-// Message is not intended to be inherited from.  In particular, its
-// destructor is not virtual.
-//
-// Note that stringstream behaves differently in gcc and in MSVC.  You
-// can stream a NULL char pointer to it in the former, but not in the
-// latter (it causes an access violation if you do).  The Message
-// class hides this difference by treating a NULL char pointer as
-// "(null)".
-class GTEST_API_ Message {
- private:
-  // The type of basic IO manipulators (endl, ends, and flush) for
-  // narrow streams.
-  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
-
- public:
-  // Constructs an empty Message.
-  Message();
-
-  // Copy constructor.
-  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
-    *ss_ << msg.GetString();
-  }
-
-  // Constructs a Message from a C-string.
-  explicit Message(const char* str) : ss_(new ::std::stringstream) {
-    *ss_ << str;
-  }
-
-  // Streams a non-pointer value to this object.
-  template <typename T>
-  inline Message& operator <<(const T& val) {
-    // Some libraries overload << for STL containers.  These
-    // overloads are defined in the global namespace instead of ::std.
-    //
-    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
-    // overloads are visible in either the std namespace or the global
-    // namespace, but not other namespaces, including the testing
-    // namespace which Google Test's Message class is in.
-    //
-    // To allow STL containers (and other types that has a << operator
-    // defined in the global namespace) to be used in Google Test
-    // assertions, testing::Message must access the custom << operator
-    // from the global namespace.  With this using declaration,
-    // overloads of << defined in the global namespace and those
-    // visible via Koenig lookup are both exposed in this function.
-    using ::operator <<;
-    *ss_ << val;
-    return *this;
-  }
-
-  // Streams a pointer value to this object.
-  //
-  // This function is an overload of the previous one.  When you
-  // stream a pointer to a Message, this definition will be used as it
-  // is more specialized.  (The C++ Standard, section
-  // [temp.func.order].)  If you stream a non-pointer, then the
-  // previous definition will be used.
-  //
-  // The reason for this overload is that streaming a NULL pointer to
-  // ostream is undefined behavior.  Depending on the compiler, you
-  // may get "0", "(nil)", "(null)", or an access violation.  To
-  // ensure consistent result across compilers, we always treat NULL
-  // as "(null)".
-  template <typename T>
-  inline Message& operator <<(T* const& pointer) {  // NOLINT
-    if (pointer == nullptr) {
-      *ss_ << "(null)";
-    } else {
-      *ss_ << pointer;
-    }
-    return *this;
-  }
-
-  // Since the basic IO manipulators are overloaded for both narrow
-  // and wide streams, we have to provide this specialized definition
-  // of operator <<, even though its body is the same as the
-  // templatized version above.  Without this definition, streaming
-  // endl or other basic IO manipulators to Message will confuse the
-  // compiler.
-  Message& operator <<(BasicNarrowIoManip val) {
-    *ss_ << val;
-    return *this;
-  }
-
-  // Instead of 1/0, we want to see true/false for bool values.
-  Message& operator <<(bool b) {
-    return *this << (b ? "true" : "false");
-  }
-
-  // These two overloads allow streaming a wide C string to a Message
-  // using the UTF-8 encoding.
-  Message& operator <<(const wchar_t* wide_c_str);
-  Message& operator <<(wchar_t* wide_c_str);
-
-#if GTEST_HAS_STD_WSTRING
-  // Converts the given wide string to a narrow string using the UTF-8
-  // encoding, and streams the result to this Message object.
-  Message& operator <<(const ::std::wstring& wstr);
-#endif  // GTEST_HAS_STD_WSTRING
-
-  // Gets the text streamed to this object so far as an std::string.
-  // Each '\0' character in the buffer is replaced with "\\0".
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  std::string GetString() const;
-
- private:
-  // We'll hold the text streamed to this object here.
-  const std::unique_ptr< ::std::stringstream> ss_;
-
-  // We declare (but don't implement) this to prevent the compiler
-  // from implementing the assignment operator.
-  void operator=(const Message&);
-};
-
-// Streams a Message to an ostream.
-inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
-  return os << sb.GetString();
-}
-
-namespace internal {
-
-// Converts a streamable value to an std::string.  A NULL pointer is
-// converted to "(null)".  When the input value is a ::string,
-// ::std::string, ::wstring, or ::std::wstring object, each NUL
-// character in it is replaced with "\\0".
-template <typename T>
-std::string StreamableToString(const T& streamable) {
-  return (Message() << streamable).GetString();
-}
-
-}  // namespace internal
-}  // namespace testing
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-// Copyright 2008, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Google Test filepath utilities
-//
-// This header file declares classes and functions used internally by
-// Google Test.  They are subject to change without notice.
-//
-// This file is #included in gtest/internal/gtest-internal.h.
-// Do not include this header file separately!
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This header file declares the String class and functions used internally by
-// Google Test.  They are subject to change without notice. They should not used
-// by code external to Google Test.
-//
-// This header file is #included by gtest-internal.h.
-// It should not be #included by other files.
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-
-#ifdef __BORLANDC__
-// string.h is not guaranteed to provide strcpy on C++ Builder.
-# include <mem.h>
-#endif
-
-#include <string.h>
-#include <string>
-
-
-namespace testing {
-namespace internal {
-
-// String - an abstract class holding static string utilities.
-class GTEST_API_ String {
- public:
-  // Static utility methods
-
-  // Clones a 0-terminated C string, allocating memory using new.  The
-  // caller is responsible for deleting the return value using
-  // delete[].  Returns the cloned string, or NULL if the input is
-  // NULL.
-  //
-  // This is different from strdup() in string.h, which allocates
-  // memory using malloc().
-  static const char* CloneCString(const char* c_str);
-
-#if GTEST_OS_WINDOWS_MOBILE
-  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
-  // able to pass strings to Win32 APIs on CE we need to convert them
-  // to 'Unicode', UTF-16.
-
-  // Creates a UTF-16 wide string from the given ANSI string, allocating
-  // memory using new. The caller is responsible for deleting the return
-  // value using delete[]. Returns the wide string, or NULL if the
-  // input is NULL.
-  //
-  // The wide string is created using the ANSI codepage (CP_ACP) to
-  // match the behaviour of the ANSI versions of Win32 calls and the
-  // C runtime.
-  static LPCWSTR AnsiToUtf16(const char* c_str);
-
-  // Creates an ANSI string from the given wide string, allocating
-  // memory using new. The caller is responsible for deleting the return
-  // value using delete[]. Returns the ANSI string, or NULL if the
-  // input is NULL.
-  //
-  // The returned string is created using the ANSI codepage (CP_ACP) to
-  // match the behaviour of the ANSI versions of Win32 calls and the
-  // C runtime.
-  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
-#endif
-
-  // Compares two C strings.  Returns true iff they have the same content.
-  //
-  // Unlike strcmp(), this function can handle NULL argument(s).  A
-  // NULL C string is considered different to any non-NULL C string,
-  // including the empty string.
-  static bool CStringEquals(const char* lhs, const char* rhs);
-
-  // Converts a wide C string to a String using the UTF-8 encoding.
-  // NULL will be converted to "(null)".  If an error occurred during
-  // the conversion, "(failed to convert from wide string)" is
-  // returned.
-  static std::string ShowWideCString(const wchar_t* wide_c_str);
-
-  // Compares two wide C strings.  Returns true iff they have the same
-  // content.
-  //
-  // Unlike wcscmp(), this function can handle NULL argument(s).  A
-  // NULL C string is considered different to any non-NULL C string,
-  // including the empty string.
-  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
-
-  // Compares two C strings, ignoring case.  Returns true iff they
-  // have the same content.
-  //
-  // Unlike strcasecmp(), this function can handle NULL argument(s).
-  // A NULL C string is considered different to any non-NULL C string,
-  // including the empty string.
-  static bool CaseInsensitiveCStringEquals(const char* lhs,
-                                           const char* rhs);
-
-  // Compares two wide C strings, ignoring case.  Returns true iff they
-  // have the same content.
-  //
-  // Unlike wcscasecmp(), this function can handle NULL argument(s).
-  // A NULL C string is considered different to any non-NULL wide C string,
-  // including the empty string.
-  // NB: The implementations on different platforms slightly differ.
-  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
-  // environment variable. On GNU platform this method uses wcscasecmp
-  // which compares according to LC_CTYPE category of the current locale.
-  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
-  // current locale.
-  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
-                                               const wchar_t* rhs);
-
-  // Returns true iff the given string ends with the given suffix, ignoring
-  // case. Any string is considered to end with an empty suffix.
-  static bool EndsWithCaseInsensitive(
-      const std::string& str, const std::string& suffix);
-
-  // Formats an int value as "%02d".
-  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
-
-  // Formats an int value as "%X".
-  static std::string FormatHexInt(int value);
-
-  // Formats a byte as "%02X".
-  static std::string FormatByte(unsigned char value);
-
- private:
-  String();  // Not meant to be instantiated.
-};  // class String
-
-// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
-// character in the buffer is replaced with "\\0".
-GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-namespace testing {
-namespace internal {
-
-// FilePath - a class for file and directory pathname manipulation which
-// handles platform-specific conventions (like the pathname separator).
-// Used for helper functions for naming files in a directory for xml output.
-// Except for Set methods, all methods are const or static, which provides an
-// "immutable value object" -- useful for peace of mind.
-// A FilePath with a value ending in a path separator ("like/this/") represents
-// a directory, otherwise it is assumed to represent a file. In either case,
-// it may or may not represent an actual file or directory in the file system.
-// Names are NOT checked for syntax correctness -- no checking for illegal
-// characters, malformed paths, etc.
-
-class GTEST_API_ FilePath {
- public:
-  FilePath() : pathname_("") { }
-  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
-
-  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
-    Normalize();
-  }
-
-  FilePath& operator=(const FilePath& rhs) {
-    Set(rhs);
-    return *this;
-  }
-
-  void Set(const FilePath& rhs) {
-    pathname_ = rhs.pathname_;
-  }
-
-  const std::string& string() const { return pathname_; }
-  const char* c_str() const { return pathname_.c_str(); }
-
-  // Returns the current working directory, or "" if unsuccessful.
-  static FilePath GetCurrentDir();
-
-  // Given directory = "dir", base_name = "test", number = 0,
-  // extension = "xml", returns "dir/test.xml". If number is greater
-  // than zero (e.g., 12), returns "dir/test_12.xml".
-  // On Windows platform, uses \ as the separator rather than /.
-  static FilePath MakeFileName(const FilePath& directory,
-                               const FilePath& base_name,
-                               int number,
-                               const char* extension);
-
-  // Given directory = "dir", relative_path = "test.xml",
-  // returns "dir/test.xml".
-  // On Windows, uses \ as the separator rather than /.
-  static FilePath ConcatPaths(const FilePath& directory,
-                              const FilePath& relative_path);
-
-  // Returns a pathname for a file that does not currently exist. The pathname
-  // will be directory/base_name.extension or
-  // directory/base_name_<number>.extension if directory/base_name.extension
-  // already exists. The number will be incremented until a pathname is found
-  // that does not already exist.
-  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
-  // There could be a race condition if two or more processes are calling this
-  // function at the same time -- they could both pick the same filename.
-  static FilePath GenerateUniqueFileName(const FilePath& directory,
-                                         const FilePath& base_name,
-                                         const char* extension);
-
-  // Returns true iff the path is "".
-  bool IsEmpty() const { return pathname_.empty(); }
-
-  // If input name has a trailing separator character, removes it and returns
-  // the name, otherwise return the name string unmodified.
-  // On Windows platform, uses \ as the separator, other platforms use /.
-  FilePath RemoveTrailingPathSeparator() const;
-
-  // Returns a copy of the FilePath with the directory part removed.
-  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
-  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
-  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
-  // returns an empty FilePath ("").
-  // On Windows platform, '\' is the path separator, otherwise it is '/'.
-  FilePath RemoveDirectoryName() const;
-
-  // RemoveFileName returns the directory path with the filename removed.
-  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
-  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
-  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
-  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
-  // On Windows platform, '\' is the path separator, otherwise it is '/'.
-  FilePath RemoveFileName() const;
-
-  // Returns a copy of the FilePath with the case-insensitive extension removed.
-  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
-  // FilePath("dir/file"). If a case-insensitive extension is not
-  // found, returns a copy of the original FilePath.
-  FilePath RemoveExtension(const char* extension) const;
-
-  // Creates directories so that path exists. Returns true if successful or if
-  // the directories already exist; returns false if unable to create
-  // directories for any reason. Will also return false if the FilePath does
-  // not represent a directory (that is, it doesn't end with a path separator).
-  bool CreateDirectoriesRecursively() const;
-
-  // Create the directory so that path exists. Returns true if successful or
-  // if the directory already exists; returns false if unable to create the
-  // directory for any reason, including if the parent directory does not
-  // exist. Not named "CreateDirectory" because that's a macro on Windows.
-  bool CreateFolder() const;
-
-  // Returns true if FilePath describes something in the file-system,
-  // either a file, directory, or whatever, and that something exists.
-  bool FileOrDirectoryExists() const;
-
-  // Returns true if pathname describes a directory in the file-system
-  // that exists.
-  bool DirectoryExists() const;
-
-  // Returns true if FilePath ends with a path separator, which indicates that
-  // it is intended to represent a directory. Returns false otherwise.
-  // This does NOT check that a directory (or file) actually exists.
-  bool IsDirectory() const;
-
-  // Returns true if pathname describes a root directory. (Windows has one
-  // root directory per disk drive.)
-  bool IsRootDirectory() const;
-
-  // Returns true if pathname describes an absolute path.
-  bool IsAbsolutePath() const;
-
- private:
-  // Replaces multiple consecutive separators with a single separator.
-  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
-  // redundancies that might be in a pathname involving "." or "..".
-  //
-  // A pathname with multiple consecutive separators may occur either through
-  // user error or as a result of some scripts or APIs that generate a pathname
-  // with a trailing separator. On other platforms the same API or script
-  // may NOT generate a pathname with a trailing "/". Then elsewhere that
-  // pathname may have another "/" and pathname components added to it,
-  // without checking for the separator already being there.
-  // The script language and operating system may allow paths like "foo//bar"
-  // but some of the functions in FilePath will not handle that correctly. In
-  // particular, RemoveTrailingPathSeparator() only removes one separator, and
-  // it is called in CreateDirectoriesRecursively() assuming that it will change
-  // a pathname from directory syntax (trailing separator) to filename syntax.
-  //
-  // On Windows this method also replaces the alternate path separator '/' with
-  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
-  // "bar\\foo".
-
-  void Normalize();
-
-  // Returns a pointer to the last occurence of a valid path separator in
-  // the FilePath. On Windows, for example, both '/' and '\' are valid path
-  // separators. Returns NULL if no path separator was found.
-  const char* FindLastPathSeparator() const;
-
-  std::string pathname_;
-};  // class FilePath
-
-}  // namespace internal
-}  // namespace testing
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-// This file was GENERATED by command:
-//     pump.py gtest-type-util.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2008 Google Inc.
-// All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Type utilities needed for implementing typed and type-parameterized
-// tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-// Currently we support at most 50 types in a list, and at most 50
-// type-parameterized tests in one type-parameterized test suite.
-// Please contact googletestframework@googlegroups.com if you need
-// more.
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-
-
-// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
-// libstdc++ (which is where cxxabi.h comes from).
-# if GTEST_HAS_CXXABI_H_
-#  include <cxxabi.h>
-# elif defined(__HP_aCC)
-#  include <acxx_demangle.h>
-# endif  // GTEST_HASH_CXXABI_H_
-
-namespace testing {
-namespace internal {
-
-// Canonicalizes a given name with respect to the Standard C++ Library.
-// This handles removing the inline namespace within `std` that is
-// used by various standard libraries (e.g., `std::__1`).  Names outside
-// of namespace std are returned unmodified.
-inline std::string CanonicalizeForStdLibVersioning(std::string s) {
-  static const char prefix[] = "std::__";
-  if (s.compare(0, strlen(prefix), prefix) == 0) {
-    std::string::size_type end = s.find("::", strlen(prefix));
-    if (end != s.npos) {
-      // Erase everything between the initial `std` and the second `::`.
-      s.erase(strlen("std"), end - strlen("std"));
-    }
-  }
-  return s;
-}
-
-// GetTypeName<T>() returns a human-readable name of type T.
-// NB: This function is also used in Google Mock, so don't move it inside of
-// the typed-test-only section below.
-template <typename T>
-std::string GetTypeName() {
-# if GTEST_HAS_RTTI
-
-  const char* const name = typeid(T).name();
-#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
-  int status = 0;
-  // gcc's implementation of typeid(T).name() mangles the type name,
-  // so we have to demangle it.
-#   if GTEST_HAS_CXXABI_H_
-  using abi::__cxa_demangle;
-#   endif  // GTEST_HAS_CXXABI_H_
-  char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status);
-  const std::string name_str(status == 0 ? readable_name : name);
-  free(readable_name);
-  return CanonicalizeForStdLibVersioning(name_str);
-#  else
-  return name;
-#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
-
-# else
-
-  return "<type>";
-
-# endif  // GTEST_HAS_RTTI
-}
-
-#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
-// type.  This can be used as a compile-time assertion to ensure that
-// two types are equal.
-
-template <typename T1, typename T2>
-struct AssertTypeEq;
-
-template <typename T>
-struct AssertTypeEq<T, T> {
-  typedef bool type;
-};
-
-// A unique type used as the default value for the arguments of class
-// template Types.  This allows us to simulate variadic templates
-// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
-// support directly.
-struct None {};
-
-// The following family of struct and struct templates are used to
-// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
-// represents a type list with N types (T1, T2, ..., and TN) in it.
-// Except for Types0, every struct in the family has two member types:
-// Head for the first type in the list, and Tail for the rest of the
-// list.
-
-// The empty type list.
-struct Types0 {};
-
-// Type lists of length 1, 2, 3, and so on.
-
-template <typename T1>
-struct Types1 {
-  typedef T1 Head;
-  typedef Types0 Tail;
-};
-template <typename T1, typename T2>
-struct Types2 {
-  typedef T1 Head;
-  typedef Types1<T2> Tail;
-};
-
-template <typename T1, typename T2, typename T3>
-struct Types3 {
-  typedef T1 Head;
-  typedef Types2<T2, T3> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4>
-struct Types4 {
-  typedef T1 Head;
-  typedef Types3<T2, T3, T4> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-struct Types5 {
-  typedef T1 Head;
-  typedef Types4<T2, T3, T4, T5> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-struct Types6 {
-  typedef T1 Head;
-  typedef Types5<T2, T3, T4, T5, T6> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-struct Types7 {
-  typedef T1 Head;
-  typedef Types6<T2, T3, T4, T5, T6, T7> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-struct Types8 {
-  typedef T1 Head;
-  typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-struct Types9 {
-  typedef T1 Head;
-  typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-struct Types10 {
-  typedef T1 Head;
-  typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-struct Types11 {
-  typedef T1 Head;
-  typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-struct Types12 {
-  typedef T1 Head;
-  typedef Types11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-struct Types13 {
-  typedef T1 Head;
-  typedef Types12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-struct Types14 {
-  typedef T1 Head;
-  typedef Types13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-struct Types15 {
-  typedef T1 Head;
-  typedef Types14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-struct Types16 {
-  typedef T1 Head;
-  typedef Types15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-struct Types17 {
-  typedef T1 Head;
-  typedef Types16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-struct Types18 {
-  typedef T1 Head;
-  typedef Types17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-struct Types19 {
-  typedef T1 Head;
-  typedef Types18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-struct Types20 {
-  typedef T1 Head;
-  typedef Types19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-struct Types21 {
-  typedef T1 Head;
-  typedef Types20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-struct Types22 {
-  typedef T1 Head;
-  typedef Types21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-struct Types23 {
-  typedef T1 Head;
-  typedef Types22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-struct Types24 {
-  typedef T1 Head;
-  typedef Types23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-struct Types25 {
-  typedef T1 Head;
-  typedef Types24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-struct Types26 {
-  typedef T1 Head;
-  typedef Types25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-struct Types27 {
-  typedef T1 Head;
-  typedef Types26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-struct Types28 {
-  typedef T1 Head;
-  typedef Types27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-struct Types29 {
-  typedef T1 Head;
-  typedef Types28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-struct Types30 {
-  typedef T1 Head;
-  typedef Types29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-struct Types31 {
-  typedef T1 Head;
-  typedef Types30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-struct Types32 {
-  typedef T1 Head;
-  typedef Types31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-struct Types33 {
-  typedef T1 Head;
-  typedef Types32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-struct Types34 {
-  typedef T1 Head;
-  typedef Types33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-struct Types35 {
-  typedef T1 Head;
-  typedef Types34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-struct Types36 {
-  typedef T1 Head;
-  typedef Types35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-struct Types37 {
-  typedef T1 Head;
-  typedef Types36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-struct Types38 {
-  typedef T1 Head;
-  typedef Types37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-struct Types39 {
-  typedef T1 Head;
-  typedef Types38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-struct Types40 {
-  typedef T1 Head;
-  typedef Types39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-struct Types41 {
-  typedef T1 Head;
-  typedef Types40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-struct Types42 {
-  typedef T1 Head;
-  typedef Types41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-struct Types43 {
-  typedef T1 Head;
-  typedef Types42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-struct Types44 {
-  typedef T1 Head;
-  typedef Types43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-struct Types45 {
-  typedef T1 Head;
-  typedef Types44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-struct Types46 {
-  typedef T1 Head;
-  typedef Types45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-struct Types47 {
-  typedef T1 Head;
-  typedef Types46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-struct Types48 {
-  typedef T1 Head;
-  typedef Types47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-struct Types49 {
-  typedef T1 Head;
-  typedef Types48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48, T49> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-struct Types50 {
-  typedef T1 Head;
-  typedef Types49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48, T49, T50> Tail;
-};
-
-
-}  // namespace internal
-
-// We don't want to require the users to write TypesN<...> directly,
-// as that would require them to count the length.  Types<...> is much
-// easier to write, but generates horrible messages when there is a
-// compiler error, as gcc insists on printing out each template
-// argument, even if it has the default value (this means Types<int>
-// will appear as Types<int, None, None, ..., None> in the compiler
-// errors).
-//
-// Our solution is to combine the best part of the two approaches: a
-// user would write Types<T1, ..., TN>, and Google Test will translate
-// that to TypesN<T1, ..., TN> internally to make error messages
-// readable.  The translation is done by the 'type' member of the
-// Types template.
-template <typename T1 = internal::None, typename T2 = internal::None,
-    typename T3 = internal::None, typename T4 = internal::None,
-    typename T5 = internal::None, typename T6 = internal::None,
-    typename T7 = internal::None, typename T8 = internal::None,
-    typename T9 = internal::None, typename T10 = internal::None,
-    typename T11 = internal::None, typename T12 = internal::None,
-    typename T13 = internal::None, typename T14 = internal::None,
-    typename T15 = internal::None, typename T16 = internal::None,
-    typename T17 = internal::None, typename T18 = internal::None,
-    typename T19 = internal::None, typename T20 = internal::None,
-    typename T21 = internal::None, typename T22 = internal::None,
-    typename T23 = internal::None, typename T24 = internal::None,
-    typename T25 = internal::None, typename T26 = internal::None,
-    typename T27 = internal::None, typename T28 = internal::None,
-    typename T29 = internal::None, typename T30 = internal::None,
-    typename T31 = internal::None, typename T32 = internal::None,
-    typename T33 = internal::None, typename T34 = internal::None,
-    typename T35 = internal::None, typename T36 = internal::None,
-    typename T37 = internal::None, typename T38 = internal::None,
-    typename T39 = internal::None, typename T40 = internal::None,
-    typename T41 = internal::None, typename T42 = internal::None,
-    typename T43 = internal::None, typename T44 = internal::None,
-    typename T45 = internal::None, typename T46 = internal::None,
-    typename T47 = internal::None, typename T48 = internal::None,
-    typename T49 = internal::None, typename T50 = internal::None>
-struct Types {
-  typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
-};
-
-template <>
-struct Types<internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types0 type;
-};
-template <typename T1>
-struct Types<T1, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types1<T1> type;
-};
-template <typename T1, typename T2>
-struct Types<T1, T2, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types2<T1, T2> type;
-};
-template <typename T1, typename T2, typename T3>
-struct Types<T1, T2, T3, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types3<T1, T2, T3> type;
-};
-template <typename T1, typename T2, typename T3, typename T4>
-struct Types<T1, T2, T3, T4, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types4<T1, T2, T3, T4> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-struct Types<T1, T2, T3, T4, T5, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types5<T1, T2, T3, T4, T5> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-struct Types<T1, T2, T3, T4, T5, T6, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-struct Types<T1, T2, T3, T4, T5, T6, T7, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, internal::None, internal::None, internal::None> {
-  typedef internal::Types47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, T48, internal::None, internal::None> {
-  typedef internal::Types48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, T48, T49, internal::None> {
-  typedef internal::Types49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49> type;
-};
-
-namespace internal {
-
-# define GTEST_TEMPLATE_ template <typename T> class
-
-// The template "selector" struct TemplateSel<Tmpl> is used to
-// represent Tmpl, which must be a class template with one type
-// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
-// as the type Tmpl<T>.  This allows us to actually instantiate the
-// template "selected" by TemplateSel<Tmpl>.
-//
-// This trick is necessary for simulating typedef for class templates,
-// which C++ doesn't support directly.
-template <GTEST_TEMPLATE_ Tmpl>
-struct TemplateSel {
-  template <typename T>
-  struct Bind {
-    typedef Tmpl<T> type;
-  };
-};
-
-# define GTEST_BIND_(TmplSel, T) \
-  TmplSel::template Bind<T>::type
-
-// A unique struct template used as the default value for the
-// arguments of class template Templates.  This allows us to simulate
-// variadic templates (e.g. Templates<int>, Templates<int, double>,
-// and etc), which C++ doesn't support directly.
-template <typename T>
-struct NoneT {};
-
-// The following family of struct and struct templates are used to
-// represent template lists.  In particular, TemplatesN<T1, T2, ...,
-// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
-// for Templates0, every struct in the family has two member types:
-// Head for the selector of the first template in the list, and Tail
-// for the rest of the list.
-
-// The empty template list.
-struct Templates0 {};
-
-// Template lists of length 1, 2, 3, and so on.
-
-template <GTEST_TEMPLATE_ T1>
-struct Templates1 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates0 Tail;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
-struct Templates2 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates1<T2> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
-struct Templates3 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates2<T2, T3> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4>
-struct Templates4 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates3<T2, T3, T4> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
-struct Templates5 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates4<T2, T3, T4, T5> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
-struct Templates6 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates5<T2, T3, T4, T5, T6> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7>
-struct Templates7 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
-struct Templates8 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
-struct Templates9 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10>
-struct Templates10 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
-struct Templates11 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
-struct Templates12 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13>
-struct Templates13 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
-struct Templates14 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
-struct Templates15 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16>
-struct Templates16 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
-struct Templates17 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
-struct Templates18 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19>
-struct Templates19 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
-struct Templates20 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
-struct Templates21 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22>
-struct Templates22 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
-struct Templates23 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
-struct Templates24 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25>
-struct Templates25 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
-struct Templates26 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
-struct Templates27 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28>
-struct Templates28 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
-struct Templates29 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
-struct Templates30 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31>
-struct Templates31 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
-struct Templates32 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
-struct Templates33 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34>
-struct Templates34 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
-struct Templates35 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
-struct Templates36 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37>
-struct Templates37 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
-struct Templates38 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
-struct Templates39 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40>
-struct Templates40 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
-struct Templates41 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
-struct Templates42 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43>
-struct Templates43 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
-struct Templates44 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
-struct Templates45 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46>
-struct Templates46 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
-struct Templates47 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
-struct Templates48 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49>
-struct Templates49 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48, T49> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49, GTEST_TEMPLATE_ T50>
-struct Templates50 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48, T49, T50> Tail;
-};
-
-
-// We don't want to require the users to write TemplatesN<...> directly,
-// as that would require them to count the length.  Templates<...> is much
-// easier to write, but generates horrible messages when there is a
-// compiler error, as gcc insists on printing out each template
-// argument, even if it has the default value (this means Templates<list>
-// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
-// errors).
-//
-// Our solution is to combine the best part of the two approaches: a
-// user would write Templates<T1, ..., TN>, and Google Test will translate
-// that to TemplatesN<T1, ..., TN> internally to make error messages
-// readable.  The translation is done by the 'type' member of the
-// Templates template.
-template <GTEST_TEMPLATE_ T1 = NoneT, GTEST_TEMPLATE_ T2 = NoneT,
-    GTEST_TEMPLATE_ T3 = NoneT, GTEST_TEMPLATE_ T4 = NoneT,
-    GTEST_TEMPLATE_ T5 = NoneT, GTEST_TEMPLATE_ T6 = NoneT,
-    GTEST_TEMPLATE_ T7 = NoneT, GTEST_TEMPLATE_ T8 = NoneT,
-    GTEST_TEMPLATE_ T9 = NoneT, GTEST_TEMPLATE_ T10 = NoneT,
-    GTEST_TEMPLATE_ T11 = NoneT, GTEST_TEMPLATE_ T12 = NoneT,
-    GTEST_TEMPLATE_ T13 = NoneT, GTEST_TEMPLATE_ T14 = NoneT,
-    GTEST_TEMPLATE_ T15 = NoneT, GTEST_TEMPLATE_ T16 = NoneT,
-    GTEST_TEMPLATE_ T17 = NoneT, GTEST_TEMPLATE_ T18 = NoneT,
-    GTEST_TEMPLATE_ T19 = NoneT, GTEST_TEMPLATE_ T20 = NoneT,
-    GTEST_TEMPLATE_ T21 = NoneT, GTEST_TEMPLATE_ T22 = NoneT,
-    GTEST_TEMPLATE_ T23 = NoneT, GTEST_TEMPLATE_ T24 = NoneT,
-    GTEST_TEMPLATE_ T25 = NoneT, GTEST_TEMPLATE_ T26 = NoneT,
-    GTEST_TEMPLATE_ T27 = NoneT, GTEST_TEMPLATE_ T28 = NoneT,
-    GTEST_TEMPLATE_ T29 = NoneT, GTEST_TEMPLATE_ T30 = NoneT,
-    GTEST_TEMPLATE_ T31 = NoneT, GTEST_TEMPLATE_ T32 = NoneT,
-    GTEST_TEMPLATE_ T33 = NoneT, GTEST_TEMPLATE_ T34 = NoneT,
-    GTEST_TEMPLATE_ T35 = NoneT, GTEST_TEMPLATE_ T36 = NoneT,
-    GTEST_TEMPLATE_ T37 = NoneT, GTEST_TEMPLATE_ T38 = NoneT,
-    GTEST_TEMPLATE_ T39 = NoneT, GTEST_TEMPLATE_ T40 = NoneT,
-    GTEST_TEMPLATE_ T41 = NoneT, GTEST_TEMPLATE_ T42 = NoneT,
-    GTEST_TEMPLATE_ T43 = NoneT, GTEST_TEMPLATE_ T44 = NoneT,
-    GTEST_TEMPLATE_ T45 = NoneT, GTEST_TEMPLATE_ T46 = NoneT,
-    GTEST_TEMPLATE_ T47 = NoneT, GTEST_TEMPLATE_ T48 = NoneT,
-    GTEST_TEMPLATE_ T49 = NoneT, GTEST_TEMPLATE_ T50 = NoneT>
-struct Templates {
-  typedef Templates50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
-};
-
-template <>
-struct Templates<NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates0 type;
-};
-template <GTEST_TEMPLATE_ T1>
-struct Templates<T1, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates1<T1> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
-struct Templates<T1, T2, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates2<T1, T2> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
-struct Templates<T1, T2, T3, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates3<T1, T2, T3> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4>
-struct Templates<T1, T2, T3, T4, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates4<T1, T2, T3, T4> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
-struct Templates<T1, T2, T3, T4, T5, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates5<T1, T2, T3, T4, T5> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
-struct Templates<T1, T2, T3, T4, T5, T6, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates6<T1, T2, T3, T4, T5, T6> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates7<T1, T2, T3, T4, T5, T6, T7> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates8<T1, T2, T3, T4, T5, T6, T7, T8> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, NoneT, NoneT, NoneT> {
-  typedef Templates47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, T48, NoneT, NoneT> {
-  typedef Templates48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, T48, T49, NoneT> {
-  typedef Templates49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48, T49> type;
-};
-
-// The TypeList template makes it possible to use either a single type
-// or a Types<...> list in TYPED_TEST_SUITE() and
-// INSTANTIATE_TYPED_TEST_SUITE_P().
-
-template <typename T>
-struct TypeList {
-  typedef Types1<T> type;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-struct TypeList<Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48, T49, T50> > {
-  typedef typename Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>::type type;
-};
-
-#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-
-// Due to C++ preprocessor weirdness, we need double indirection to
-// concatenate two tokens when one of them is __LINE__.  Writing
-//
-//   foo ## __LINE__
-//
-// will result in the token foo__LINE__, instead of foo followed by
-// the current line number.  For more details, see
-// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
-#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
-#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
-
-// Stringifies its argument.
-#define GTEST_STRINGIFY_(name) #name
-
-namespace proto2 { class Message; }
-
-namespace testing {
-
-// Forward declarations.
-
-class AssertionResult;                 // Result of an assertion.
-class Message;                         // Represents a failure message.
-class Test;                            // Represents a test.
-class TestInfo;                        // Information about a test.
-class TestPartResult;                  // Result of a test part.
-class UnitTest;                        // A collection of test suites.
-
-template <typename T>
-::std::string PrintToString(const T& value);
-
-namespace internal {
-
-struct TraceInfo;                      // Information about a trace point.
-class TestInfoImpl;                    // Opaque implementation of TestInfo
-class UnitTestImpl;                    // Opaque implementation of UnitTest
-
-// The text used in failure messages to indicate the start of the
-// stack trace.
-GTEST_API_ extern const char kStackTraceMarker[];
-
-// An IgnoredValue object can be implicitly constructed from ANY value.
-class IgnoredValue {
-  struct Sink {};
- public:
-  // This constructor template allows any value to be implicitly
-  // converted to IgnoredValue.  The object has no data member and
-  // doesn't try to remember anything about the argument.  We
-  // deliberately omit the 'explicit' keyword in order to allow the
-  // conversion to be implicit.
-  // Disable the conversion if T already has a magical conversion operator.
-  // Otherwise we get ambiguity.
-  template <typename T,
-            typename std::enable_if<!std::is_convertible<T, Sink>::value,
-                                    int>::type = 0>
-  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
-};
-
-// Appends the user-supplied message to the Google-Test-generated message.
-GTEST_API_ std::string AppendUserMessage(
-    const std::string& gtest_msg, const Message& user_msg);
-
-#if GTEST_HAS_EXCEPTIONS
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \
-/* an exported class was derived from a class that was not exported */)
-
-// This exception is thrown by (and only by) a failed Google Test
-// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
-// are enabled).  We derive it from std::runtime_error, which is for
-// errors presumably detectable only at run time.  Since
-// std::runtime_error inherits from std::exception, many testing
-// frameworks know how to extract and print the message inside it.
-class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
- public:
-  explicit GoogleTestFailureException(const TestPartResult& failure);
-};
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4275
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-namespace edit_distance {
-// Returns the optimal edits to go from 'left' to 'right'.
-// All edits cost the same, with replace having lower priority than
-// add/remove.
-// Simple implementation of the Wagner-Fischer algorithm.
-// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
-enum EditType { kMatch, kAdd, kRemove, kReplace };
-GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<size_t>& left, const std::vector<size_t>& right);
-
-// Same as above, but the input is represented as strings.
-GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<std::string>& left,
-    const std::vector<std::string>& right);
-
-// Create a diff of the input strings in Unified diff format.
-GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
-                                         const std::vector<std::string>& right,
-                                         size_t context = 2);
-
-}  // namespace edit_distance
-
-// Calculate the diff between 'left' and 'right' and return it in unified diff
-// format.
-// If not null, stores in 'total_line_count' the total number of lines found
-// in left + right.
-GTEST_API_ std::string DiffStrings(const std::string& left,
-                                   const std::string& right,
-                                   size_t* total_line_count);
-
-// Constructs and returns the message for an equality assertion
-// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
-//
-// The first four parameters are the expressions used in the assertion
-// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
-// where foo is 5 and bar is 6, we have:
-//
-//   expected_expression: "foo"
-//   actual_expression:   "bar"
-//   expected_value:      "5"
-//   actual_value:        "6"
-//
-// The ignoring_case parameter is true iff the assertion is a
-// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
-// be inserted into the message.
-GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
-                                     const char* actual_expression,
-                                     const std::string& expected_value,
-                                     const std::string& actual_value,
-                                     bool ignoring_case);
-
-// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
-GTEST_API_ std::string GetBoolAssertionFailureMessage(
-    const AssertionResult& assertion_result,
-    const char* expression_text,
-    const char* actual_predicate_value,
-    const char* expected_predicate_value);
-
-// This template class represents an IEEE floating-point number
-// (either single-precision or double-precision, depending on the
-// template parameters).
-//
-// The purpose of this class is to do more sophisticated number
-// comparison.  (Due to round-off error, etc, it's very unlikely that
-// two floating-points will be equal exactly.  Hence a naive
-// comparison by the == operation often doesn't work.)
-//
-// Format of IEEE floating-point:
-//
-//   The most-significant bit being the leftmost, an IEEE
-//   floating-point looks like
-//
-//     sign_bit exponent_bits fraction_bits
-//
-//   Here, sign_bit is a single bit that designates the sign of the
-//   number.
-//
-//   For float, there are 8 exponent bits and 23 fraction bits.
-//
-//   For double, there are 11 exponent bits and 52 fraction bits.
-//
-//   More details can be found at
-//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
-//
-// Template parameter:
-//
-//   RawType: the raw floating-point type (either float or double)
-template <typename RawType>
-class FloatingPoint {
- public:
-  // Defines the unsigned integer type that has the same size as the
-  // floating point number.
-  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
-
-  // Constants.
-
-  // # of bits in a number.
-  static const size_t kBitCount = 8*sizeof(RawType);
-
-  // # of fraction bits in a number.
-  static const size_t kFractionBitCount =
-    std::numeric_limits<RawType>::digits - 1;
-
-  // # of exponent bits in a number.
-  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
-
-  // The mask for the sign bit.
-  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
-
-  // The mask for the fraction bits.
-  static const Bits kFractionBitMask =
-    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
-
-  // The mask for the exponent bits.
-  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
-
-  // How many ULP's (Units in the Last Place) we want to tolerate when
-  // comparing two numbers.  The larger the value, the more error we
-  // allow.  A 0 value means that two numbers must be exactly the same
-  // to be considered equal.
-  //
-  // The maximum error of a single floating-point operation is 0.5
-  // units in the last place.  On Intel CPU's, all floating-point
-  // calculations are done with 80-bit precision, while double has 64
-  // bits.  Therefore, 4 should be enough for ordinary use.
-  //
-  // See the following article for more details on ULP:
-  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
-  static const size_t kMaxUlps = 4;
-
-  // Constructs a FloatingPoint from a raw floating-point number.
-  //
-  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
-  // around may change its bits, although the new value is guaranteed
-  // to be also a NAN.  Therefore, don't expect this constructor to
-  // preserve the bits in x when x is a NAN.
-  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
-
-  // Static methods
-
-  // Reinterprets a bit pattern as a floating-point number.
-  //
-  // This function is needed to test the AlmostEquals() method.
-  static RawType ReinterpretBits(const Bits bits) {
-    FloatingPoint fp(0);
-    fp.u_.bits_ = bits;
-    return fp.u_.value_;
-  }
-
-  // Returns the floating-point number that represent positive infinity.
-  static RawType Infinity() {
-    return ReinterpretBits(kExponentBitMask);
-  }
-
-  // Returns the maximum representable finite floating-point number.
-  static RawType Max();
-
-  // Non-static methods
-
-  // Returns the bits that represents this number.
-  const Bits &bits() const { return u_.bits_; }
-
-  // Returns the exponent bits of this number.
-  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
-
-  // Returns the fraction bits of this number.
-  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
-
-  // Returns the sign bit of this number.
-  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
-
-  // Returns true iff this is NAN (not a number).
-  bool is_nan() const {
-    // It's a NAN if the exponent bits are all ones and the fraction
-    // bits are not entirely zeros.
-    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
-  }
-
-  // Returns true iff this number is at most kMaxUlps ULP's away from
-  // rhs.  In particular, this function:
-  //
-  //   - returns false if either number is (or both are) NAN.
-  //   - treats really large numbers as almost equal to infinity.
-  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
-  bool AlmostEquals(const FloatingPoint& rhs) const {
-    // The IEEE standard says that any comparison operation involving
-    // a NAN must return false.
-    if (is_nan() || rhs.is_nan()) return false;
-
-    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
-        <= kMaxUlps;
-  }
-
- private:
-  // The data type used to store the actual floating-point number.
-  union FloatingPointUnion {
-    RawType value_;  // The raw floating-point number.
-    Bits bits_;      // The bits that represent the number.
-  };
-
-  // Converts an integer from the sign-and-magnitude representation to
-  // the biased representation.  More precisely, let N be 2 to the
-  // power of (kBitCount - 1), an integer x is represented by the
-  // unsigned number x + N.
-  //
-  // For instance,
-  //
-  //   -N + 1 (the most negative number representable using
-  //          sign-and-magnitude) is represented by 1;
-  //   0      is represented by N; and
-  //   N - 1  (the biggest number representable using
-  //          sign-and-magnitude) is represented by 2N - 1.
-  //
-  // Read http://en.wikipedia.org/wiki/Signed_number_representations
-  // for more details on signed number representations.
-  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
-    if (kSignBitMask & sam) {
-      // sam represents a negative number.
-      return ~sam + 1;
-    } else {
-      // sam represents a positive number.
-      return kSignBitMask | sam;
-    }
-  }
-
-  // Given two numbers in the sign-and-magnitude representation,
-  // returns the distance between them as an unsigned number.
-  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
-                                                     const Bits &sam2) {
-    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
-    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
-    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
-  }
-
-  FloatingPointUnion u_;
-};
-
-// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
-// macro defined by <windows.h>.
-template <>
-inline float FloatingPoint<float>::Max() { return FLT_MAX; }
-template <>
-inline double FloatingPoint<double>::Max() { return DBL_MAX; }
-
-// Typedefs the instances of the FloatingPoint template class that we
-// care to use.
-typedef FloatingPoint<float> Float;
-typedef FloatingPoint<double> Double;
-
-// In order to catch the mistake of putting tests that use different
-// test fixture classes in the same test suite, we need to assign
-// unique IDs to fixture classes and compare them.  The TypeId type is
-// used to hold such IDs.  The user should treat TypeId as an opaque
-// type: the only operation allowed on TypeId values is to compare
-// them for equality using the == operator.
-typedef const void* TypeId;
-
-template <typename T>
-class TypeIdHelper {
- public:
-  // dummy_ must not have a const type.  Otherwise an overly eager
-  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
-  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
-  static bool dummy_;
-};
-
-template <typename T>
-bool TypeIdHelper<T>::dummy_ = false;
-
-// GetTypeId<T>() returns the ID of type T.  Different values will be
-// returned for different types.  Calling the function twice with the
-// same type argument is guaranteed to return the same ID.
-template <typename T>
-TypeId GetTypeId() {
-  // The compiler is required to allocate a different
-  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
-  // the template.  Therefore, the address of dummy_ is guaranteed to
-  // be unique.
-  return &(TypeIdHelper<T>::dummy_);
-}
-
-// Returns the type ID of ::testing::Test.  Always call this instead
-// of GetTypeId< ::testing::Test>() to get the type ID of
-// ::testing::Test, as the latter may give the wrong result due to a
-// suspected linker bug when compiling Google Test as a Mac OS X
-// framework.
-GTEST_API_ TypeId GetTestTypeId();
-
-// Defines the abstract factory interface that creates instances
-// of a Test object.
-class TestFactoryBase {
- public:
-  virtual ~TestFactoryBase() {}
-
-  // Creates a test instance to run. The instance is both created and destroyed
-  // within TestInfoImpl::Run()
-  virtual Test* CreateTest() = 0;
-
- protected:
-  TestFactoryBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
-};
-
-// This class provides implementation of TeastFactoryBase interface.
-// It is used in TEST and TEST_F macros.
-template <class TestClass>
-class TestFactoryImpl : public TestFactoryBase {
- public:
-  Test* CreateTest() override { return new TestClass; }
-};
-
-#if GTEST_OS_WINDOWS
-
-// Predicate-formatters for implementing the HRESULT checking macros
-// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
-// We pass a long instead of HRESULT to avoid causing an
-// include dependency for the HRESULT type.
-GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
-                                            long hr);  // NOLINT
-GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
-                                            long hr);  // NOLINT
-
-#endif  // GTEST_OS_WINDOWS
-
-// Types of SetUpTestSuite() and TearDownTestSuite() functions.
-using SetUpTestSuiteFunc = void (*)();
-using TearDownTestSuiteFunc = void (*)();
-
-struct CodeLocation {
-  CodeLocation(const std::string& a_file, int a_line)
-      : file(a_file), line(a_line) {}
-
-  std::string file;
-  int line;
-};
-
-//  Helper to identify which setup function for TestCase / TestSuite to call.
-//  Only one function is allowed, either TestCase or TestSute but not both.
-
-// Utility functions to help SuiteApiResolver
-using SetUpTearDownSuiteFuncType = void (*)();
-
-inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
-    SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
-  return a == def ? nullptr : a;
-}
-
-template <typename T>
-//  Note that SuiteApiResolver inherits from T because
-//  SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way
-//  SuiteApiResolver can access them.
-struct SuiteApiResolver : T {
-  // testing::Test is only forward declared at this point. So we make it a
-  // dependend class for the compiler to be OK with it.
-  using Test =
-      typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;
-
-  static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite() {
-    SetUpTearDownSuiteFuncType test_case_fp =
-        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
-    SetUpTearDownSuiteFuncType test_suite_fp =
-        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
-
-    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
-        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
-           "make sure there is only one present ";
-
-    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
-  }
-
-  static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite() {
-    SetUpTearDownSuiteFuncType test_case_fp =
-        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
-    SetUpTearDownSuiteFuncType test_suite_fp =
-        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
-
-    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
-        << "Test can not provide both TearDownTestSuite and TearDownTestCase,"
-           " please make sure there is only one present ";
-
-    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
-  }
-};
-
-// Creates a new TestInfo object and registers it with Google Test;
-// returns the created object.
-//
-// Arguments:
-//
-//   test_suite_name:   name of the test suite
-//   name:             name of the test
-//   type_param        the name of the test's type parameter, or NULL if
-//                     this is not a typed or a type-parameterized test.
-//   value_param       text representation of the test's value parameter,
-//                     or NULL if this is not a type-parameterized test.
-//   code_location:    code location where the test is defined
-//   fixture_class_id: ID of the test fixture class
-//   set_up_tc:        pointer to the function that sets up the test suite
-//   tear_down_tc:     pointer to the function that tears down the test suite
-//   factory:          pointer to the factory that creates a test object.
-//                     The newly created TestInfo instance will assume
-//                     ownership of the factory object.
-GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
-    const char* test_suite_name, const char* name, const char* type_param,
-    const char* value_param, CodeLocation code_location,
-    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
-    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
-
-// If *pstr starts with the given prefix, modifies *pstr to be right
-// past the prefix and returns true; otherwise leaves *pstr unchanged
-// and returns false.  None of pstr, *pstr, and prefix can be NULL.
-GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
-
-#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-// State of the definition of a type-parameterized test suite.
-class GTEST_API_ TypedTestSuitePState {
- public:
-  TypedTestSuitePState() : registered_(false) {}
-
-  // Adds the given test name to defined_test_names_ and return true
-  // if the test suite hasn't been registered; otherwise aborts the
-  // program.
-  bool AddTestName(const char* file, int line, const char* case_name,
-                   const char* test_name) {
-    if (registered_) {
-      fprintf(stderr,
-              "%s Test %s must be defined before "
-              "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
-              FormatFileLocation(file, line).c_str(), test_name, case_name);
-      fflush(stderr);
-      posix::Abort();
-    }
-    registered_tests_.insert(
-        ::std::make_pair(test_name, CodeLocation(file, line)));
-    return true;
-  }
-
-  bool TestExists(const std::string& test_name) const {
-    return registered_tests_.count(test_name) > 0;
-  }
-
-  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
-    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
-    GTEST_CHECK_(it != registered_tests_.end());
-    return it->second;
-  }
-
-  // Verifies that registered_tests match the test names in
-  // defined_test_names_; returns registered_tests if successful, or
-  // aborts the program otherwise.
-  const char* VerifyRegisteredTestNames(
-      const char* file, int line, const char* registered_tests);
-
- private:
-  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
-
-  bool registered_;
-  RegisteredTestsMap registered_tests_;
-};
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-using TypedTestCasePState = TypedTestSuitePState;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-// Skips to the first non-space char after the first comma in 'str';
-// returns NULL if no comma is found in 'str'.
-inline const char* SkipComma(const char* str) {
-  const char* comma = strchr(str, ',');
-  if (comma == nullptr) {
-    return nullptr;
-  }
-  while (IsSpace(*(++comma))) {}
-  return comma;
-}
-
-// Returns the prefix of 'str' before the first comma in it; returns
-// the entire string if it contains no comma.
-inline std::string GetPrefixUntilComma(const char* str) {
-  const char* comma = strchr(str, ',');
-  return comma == nullptr ? str : std::string(str, comma);
-}
-
-// Splits a given string on a given delimiter, populating a given
-// vector with the fields.
-void SplitString(const ::std::string& str, char delimiter,
-                 ::std::vector< ::std::string>* dest);
-
-// The default argument to the template below for the case when the user does
-// not provide a name generator.
-struct DefaultNameGenerator {
-  template <typename T>
-  static std::string GetName(int i) {
-    return StreamableToString(i);
-  }
-};
-
-template <typename Provided = DefaultNameGenerator>
-struct NameGeneratorSelector {
-  typedef Provided type;
-};
-
-template <typename NameGenerator>
-void GenerateNamesRecursively(Types0, std::vector<std::string>*, int) {}
-
-template <typename NameGenerator, typename Types>
-void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) {
-  result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
-  GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result,
-                                          i + 1);
-}
-
-template <typename NameGenerator, typename Types>
-std::vector<std::string> GenerateNames() {
-  std::vector<std::string> result;
-  GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
-  return result;
-}
-
-// TypeParameterizedTest<Fixture, TestSel, Types>::Register()
-// registers a list of type-parameterized tests with Google Test.  The
-// return value is insignificant - we just need to return something
-// such that we can call this function in a namespace scope.
-//
-// Implementation note: The GTEST_TEMPLATE_ macro declares a template
-// template parameter.  It's defined in gtest-type-util.h.
-template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
-class TypeParameterizedTest {
- public:
-  // 'index' is the index of the test in the type list 'Types'
-  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
-  // Types).  Valid values for 'index' are [0, N - 1] where N is the
-  // length of Types.
-  static bool Register(const char* prefix, const CodeLocation& code_location,
-                       const char* case_name, const char* test_names, int index,
-                       const std::vector<std::string>& type_names =
-                           GenerateNames<DefaultNameGenerator, Types>()) {
-    typedef typename Types::Head Type;
-    typedef Fixture<Type> FixtureClass;
-    typedef typename GTEST_BIND_(TestSel, Type) TestClass;
-
-    // First, registers the first type-parameterized test in the type
-    // list.
-    MakeAndRegisterTestInfo(
-        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
-         "/" + type_names[index])
-            .c_str(),
-        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
-        GetTypeName<Type>().c_str(),
-        nullptr,  // No value parameter.
-        code_location, GetTypeId<FixtureClass>(),
-        SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(),
-        SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(),
-        new TestFactoryImpl<TestClass>);
-
-    // Next, recurses (at compile time) with the tail of the type list.
-    return TypeParameterizedTest<Fixture, TestSel,
-                                 typename Types::Tail>::Register(prefix,
-                                                                 code_location,
-                                                                 case_name,
-                                                                 test_names,
-                                                                 index + 1,
-                                                                 type_names);
-  }
-};
-
-// The base case for the compile time recursion.
-template <GTEST_TEMPLATE_ Fixture, class TestSel>
-class TypeParameterizedTest<Fixture, TestSel, Types0> {
- public:
-  static bool Register(const char* /*prefix*/, const CodeLocation&,
-                       const char* /*case_name*/, const char* /*test_names*/,
-                       int /*index*/,
-                       const std::vector<std::string>& =
-                           std::vector<std::string>() /*type_names*/) {
-    return true;
-  }
-};
-
-// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register()
-// registers *all combinations* of 'Tests' and 'Types' with Google
-// Test.  The return value is insignificant - we just need to return
-// something such that we can call this function in a namespace scope.
-template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
-class TypeParameterizedTestSuite {
- public:
-  static bool Register(const char* prefix, CodeLocation code_location,
-                       const TypedTestSuitePState* state, const char* case_name,
-                       const char* test_names,
-                       const std::vector<std::string>& type_names =
-                           GenerateNames<DefaultNameGenerator, Types>()) {
-    std::string test_name = StripTrailingSpaces(
-        GetPrefixUntilComma(test_names));
-    if (!state->TestExists(test_name)) {
-      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
-              case_name, test_name.c_str(),
-              FormatFileLocation(code_location.file.c_str(),
-                                 code_location.line).c_str());
-      fflush(stderr);
-      posix::Abort();
-    }
-    const CodeLocation& test_location = state->GetCodeLocation(test_name);
-
-    typedef typename Tests::Head Head;
-
-    // First, register the first test in 'Test' for each type in 'Types'.
-    TypeParameterizedTest<Fixture, Head, Types>::Register(
-        prefix, test_location, case_name, test_names, 0, type_names);
-
-    // Next, recurses (at compile time) with the tail of the test list.
-    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
-                                      Types>::Register(prefix, code_location,
-                                                       state, case_name,
-                                                       SkipComma(test_names),
-                                                       type_names);
-  }
-};
-
-// The base case for the compile time recursion.
-template <GTEST_TEMPLATE_ Fixture, typename Types>
-class TypeParameterizedTestSuite<Fixture, Templates0, Types> {
- public:
-  static bool Register(const char* /*prefix*/, const CodeLocation&,
-                       const TypedTestSuitePState* /*state*/,
-                       const char* /*case_name*/, const char* /*test_names*/,
-                       const std::vector<std::string>& =
-                           std::vector<std::string>() /*type_names*/) {
-    return true;
-  }
-};
-
-#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
-// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
-    UnitTest* unit_test, int skip_count);
-
-// Helpers for suppressing warnings on unreachable code or constant
-// condition.
-
-// Always returns true.
-GTEST_API_ bool AlwaysTrue();
-
-// Always returns false.
-inline bool AlwaysFalse() { return !AlwaysTrue(); }
-
-// Helper for suppressing false warning from Clang on a const char*
-// variable declared in a conditional expression always being NULL in
-// the else branch.
-struct GTEST_API_ ConstCharPtr {
-  ConstCharPtr(const char* str) : value(str) {}
-  operator bool() const { return true; }
-  const char* value;
-};
-
-// A simple Linear Congruential Generator for generating random
-// numbers with a uniform distribution.  Unlike rand() and srand(), it
-// doesn't use global state (and therefore can't interfere with user
-// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
-// but it's good enough for our purposes.
-class GTEST_API_ Random {
- public:
-  static const UInt32 kMaxRange = 1u << 31;
-
-  explicit Random(UInt32 seed) : state_(seed) {}
-
-  void Reseed(UInt32 seed) { state_ = seed; }
-
-  // Generates a random number from [0, range).  Crashes if 'range' is
-  // 0 or greater than kMaxRange.
-  UInt32 Generate(UInt32 range);
-
- private:
-  UInt32 state_;
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
-};
-
-// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
-// compiler error iff T1 and T2 are different types.
-template <typename T1, typename T2>
-struct CompileAssertTypesEqual;
-
-template <typename T>
-struct CompileAssertTypesEqual<T, T> {
-};
-
-// Removes the reference from a type if it is a reference type,
-// otherwise leaves it unchanged.  This is the same as
-// tr1::remove_reference, which is not widely available yet.
-template <typename T>
-struct RemoveReference { typedef T type; };  // NOLINT
-template <typename T>
-struct RemoveReference<T&> { typedef T type; };  // NOLINT
-
-// A handy wrapper around RemoveReference that works when the argument
-// T depends on template parameters.
-#define GTEST_REMOVE_REFERENCE_(T) \
-    typename ::testing::internal::RemoveReference<T>::type
-
-// Removes const from a type if it is a const type, otherwise leaves
-// it unchanged.  This is the same as tr1::remove_const, which is not
-// widely available yet.
-template <typename T>
-struct RemoveConst { typedef T type; };  // NOLINT
-template <typename T>
-struct RemoveConst<const T> { typedef T type; };  // NOLINT
-
-// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
-// definition to fail to remove the const in 'const int[3]' and 'const
-// char[3][4]'.  The following specialization works around the bug.
-template <typename T, size_t N>
-struct RemoveConst<const T[N]> {
-  typedef typename RemoveConst<T>::type type[N];
-};
-
-// A handy wrapper around RemoveConst that works when the argument
-// T depends on template parameters.
-#define GTEST_REMOVE_CONST_(T) \
-    typename ::testing::internal::RemoveConst<T>::type
-
-// Turns const U&, U&, const U, and U all into U.
-#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
-    GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
-
-// IsAProtocolMessage<T>::value is a compile-time bool constant that's
-// true iff T is type proto2::Message or a subclass of it.
-template <typename T>
-struct IsAProtocolMessage
-    : public bool_constant<
-  std::is_convertible<const T*, const ::proto2::Message*>::value> {
-};
-
-// When the compiler sees expression IsContainerTest<C>(0), if C is an
-// STL-style container class, the first overload of IsContainerTest
-// will be viable (since both C::iterator* and C::const_iterator* are
-// valid types and NULL can be implicitly converted to them).  It will
-// be picked over the second overload as 'int' is a perfect match for
-// the type of argument 0.  If C::iterator or C::const_iterator is not
-// a valid type, the first overload is not viable, and the second
-// overload will be picked.  Therefore, we can determine whether C is
-// a container class by checking the type of IsContainerTest<C>(0).
-// The value of the expression is insignificant.
-//
-// In C++11 mode we check the existence of a const_iterator and that an
-// iterator is properly implemented for the container.
-//
-// For pre-C++11 that we look for both C::iterator and C::const_iterator.
-// The reason is that C++ injects the name of a class as a member of the
-// class itself (e.g. you can refer to class iterator as either
-// 'iterator' or 'iterator::iterator').  If we look for C::iterator
-// only, for example, we would mistakenly think that a class named
-// iterator is an STL container.
-//
-// Also note that the simpler approach of overloading
-// IsContainerTest(typename C::const_iterator*) and
-// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
-typedef int IsContainer;
-template <class C,
-          class Iterator = decltype(::std::declval<const C&>().begin()),
-          class = decltype(::std::declval<const C&>().end()),
-          class = decltype(++::std::declval<Iterator&>()),
-          class = decltype(*::std::declval<Iterator>()),
-          class = typename C::const_iterator>
-IsContainer IsContainerTest(int /* dummy */) {
-  return 0;
-}
-
-typedef char IsNotContainer;
-template <class C>
-IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
-
-// Trait to detect whether a type T is a hash table.
-// The heuristic used is that the type contains an inner type `hasher` and does
-// not contain an inner type `reverse_iterator`.
-// If the container is iterable in reverse, then order might actually matter.
-template <typename T>
-struct IsHashTable {
- private:
-  template <typename U>
-  static char test(typename U::hasher*, typename U::reverse_iterator*);
-  template <typename U>
-  static int test(typename U::hasher*, ...);
-  template <typename U>
-  static char test(...);
-
- public:
-  static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int);
-};
-
-template <typename T>
-const bool IsHashTable<T>::value;
-
-template <typename C,
-          bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)>
-struct IsRecursiveContainerImpl;
-
-template <typename C>
-struct IsRecursiveContainerImpl<C, false> : public false_type {};
-
-// Since the IsRecursiveContainerImpl depends on the IsContainerTest we need to
-// obey the same inconsistencies as the IsContainerTest, namely check if
-// something is a container is relying on only const_iterator in C++11 and
-// is relying on both const_iterator and iterator otherwise
-template <typename C>
-struct IsRecursiveContainerImpl<C, true> {
-  using value_type = decltype(*std::declval<typename C::const_iterator>());
-  using type =
-      is_same<typename std::remove_const<
-                  typename std::remove_reference<value_type>::type>::type,
-              C>;
-};
-
-// IsRecursiveContainer<Type> is a unary compile-time predicate that
-// evaluates whether C is a recursive container type. A recursive container
-// type is a container type whose value_type is equal to the container type
-// itself. An example for a recursive container type is
-// boost::filesystem::path, whose iterator has a value_type that is equal to
-// boost::filesystem::path.
-template <typename C>
-struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {};
-
-// EnableIf<condition>::type is void when 'Cond' is true, and
-// undefined when 'Cond' is false.  To use SFINAE to make a function
-// overload only apply when a particular expression is true, add
-// "typename EnableIf<expression>::type* = 0" as the last parameter.
-template<bool> struct EnableIf;
-template<> struct EnableIf<true> { typedef void type; };  // NOLINT
-
-// Utilities for native arrays.
-
-// ArrayEq() compares two k-dimensional native arrays using the
-// elements' operator==, where k can be any integer >= 0.  When k is
-// 0, ArrayEq() degenerates into comparing a single pair of values.
-
-template <typename T, typename U>
-bool ArrayEq(const T* lhs, size_t size, const U* rhs);
-
-// This generic version is used when k is 0.
-template <typename T, typename U>
-inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
-
-// This overload is used when k >= 1.
-template <typename T, typename U, size_t N>
-inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
-  return internal::ArrayEq(lhs, N, rhs);
-}
-
-// This helper reduces code bloat.  If we instead put its logic inside
-// the previous ArrayEq() function, arrays with different sizes would
-// lead to different copies of the template code.
-template <typename T, typename U>
-bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
-  for (size_t i = 0; i != size; i++) {
-    if (!internal::ArrayEq(lhs[i], rhs[i]))
-      return false;
-  }
-  return true;
-}
-
-// Finds the first element in the iterator range [begin, end) that
-// equals elem.  Element may be a native array type itself.
-template <typename Iter, typename Element>
-Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
-  for (Iter it = begin; it != end; ++it) {
-    if (internal::ArrayEq(*it, elem))
-      return it;
-  }
-  return end;
-}
-
-// CopyArray() copies a k-dimensional native array using the elements'
-// operator=, where k can be any integer >= 0.  When k is 0,
-// CopyArray() degenerates into copying a single value.
-
-template <typename T, typename U>
-void CopyArray(const T* from, size_t size, U* to);
-
-// This generic version is used when k is 0.
-template <typename T, typename U>
-inline void CopyArray(const T& from, U* to) { *to = from; }
-
-// This overload is used when k >= 1.
-template <typename T, typename U, size_t N>
-inline void CopyArray(const T(&from)[N], U(*to)[N]) {
-  internal::CopyArray(from, N, *to);
-}
-
-// This helper reduces code bloat.  If we instead put its logic inside
-// the previous CopyArray() function, arrays with different sizes
-// would lead to different copies of the template code.
-template <typename T, typename U>
-void CopyArray(const T* from, size_t size, U* to) {
-  for (size_t i = 0; i != size; i++) {
-    internal::CopyArray(from[i], to + i);
-  }
-}
-
-// The relation between an NativeArray object (see below) and the
-// native array it represents.
-// We use 2 different structs to allow non-copyable types to be used, as long
-// as RelationToSourceReference() is passed.
-struct RelationToSourceReference {};
-struct RelationToSourceCopy {};
-
-// Adapts a native array to a read-only STL-style container.  Instead
-// of the complete STL container concept, this adaptor only implements
-// members useful for Google Mock's container matchers.  New members
-// should be added as needed.  To simplify the implementation, we only
-// support Element being a raw type (i.e. having no top-level const or
-// reference modifier).  It's the client's responsibility to satisfy
-// this requirement.  Element can be an array type itself (hence
-// multi-dimensional arrays are supported).
-template <typename Element>
-class NativeArray {
- public:
-  // STL-style container typedefs.
-  typedef Element value_type;
-  typedef Element* iterator;
-  typedef const Element* const_iterator;
-
-  // Constructs from a native array. References the source.
-  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
-    InitRef(array, count);
-  }
-
-  // Constructs from a native array. Copies the source.
-  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
-    InitCopy(array, count);
-  }
-
-  // Copy constructor.
-  NativeArray(const NativeArray& rhs) {
-    (this->*rhs.clone_)(rhs.array_, rhs.size_);
-  }
-
-  ~NativeArray() {
-    if (clone_ != &NativeArray::InitRef)
-      delete[] array_;
-  }
-
-  // STL-style container methods.
-  size_t size() const { return size_; }
-  const_iterator begin() const { return array_; }
-  const_iterator end() const { return array_ + size_; }
-  bool operator==(const NativeArray& rhs) const {
-    return size() == rhs.size() &&
-        ArrayEq(begin(), size(), rhs.begin());
-  }
-
- private:
-  enum {
-    kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper<
-        Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value
-  };
-
-  // Initializes this object with a copy of the input.
-  void InitCopy(const Element* array, size_t a_size) {
-    Element* const copy = new Element[a_size];
-    CopyArray(array, a_size, copy);
-    array_ = copy;
-    size_ = a_size;
-    clone_ = &NativeArray::InitCopy;
-  }
-
-  // Initializes this object with a reference of the input.
-  void InitRef(const Element* array, size_t a_size) {
-    array_ = array;
-    size_ = a_size;
-    clone_ = &NativeArray::InitRef;
-  }
-
-  const Element* array_;
-  size_t size_;
-  void (NativeArray::*clone_)(const Element*, size_t);
-
-  GTEST_DISALLOW_ASSIGN_(NativeArray);
-};
-
-// Backport of std::index_sequence.
-template <size_t... Is>
-struct IndexSequence {
-  using type = IndexSequence;
-};
-
-// Double the IndexSequence, and one if plus_one is true.
-template <bool plus_one, typename T, size_t sizeofT>
-struct DoubleSequence;
-template <size_t... I, size_t sizeofT>
-struct DoubleSequence<true, IndexSequence<I...>, sizeofT> {
-  using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>;
-};
-template <size_t... I, size_t sizeofT>
-struct DoubleSequence<false, IndexSequence<I...>, sizeofT> {
-  using type = IndexSequence<I..., (sizeofT + I)...>;
-};
-
-// Backport of std::make_index_sequence.
-// It uses O(ln(N)) instantiation depth.
-template <size_t N>
-struct MakeIndexSequence
-    : DoubleSequence<N % 2 == 1, typename MakeIndexSequence<N / 2>::type,
-                     N / 2>::type {};
-
-template <>
-struct MakeIndexSequence<0> : IndexSequence<> {};
-
-// FIXME: This implementation of ElemFromList is O(1) in instantiation depth,
-// but it is O(N^2) in total instantiations. Not sure if this is the best
-// tradeoff, as it will make it somewhat slow to compile.
-template <typename T, size_t, size_t>
-struct ElemFromListImpl {};
-
-template <typename T, size_t I>
-struct ElemFromListImpl<T, I, I> {
-  using type = T;
-};
-
-// Get the Nth element from T...
-// It uses O(1) instantiation depth.
-template <size_t N, typename I, typename... T>
-struct ElemFromList;
-
-template <size_t N, size_t... I, typename... T>
-struct ElemFromList<N, IndexSequence<I...>, T...>
-    : ElemFromListImpl<T, N, I>... {};
-
-template <typename... T>
-class FlatTuple;
-
-template <typename Derived, size_t I>
-struct FlatTupleElemBase;
-
-template <typename... T, size_t I>
-struct FlatTupleElemBase<FlatTuple<T...>, I> {
-  using value_type =
-      typename ElemFromList<I, typename MakeIndexSequence<sizeof...(T)>::type,
-                            T...>::type;
-  FlatTupleElemBase() = default;
-  explicit FlatTupleElemBase(value_type t) : value(std::move(t)) {}
-  value_type value;
-};
-
-template <typename Derived, typename Idx>
-struct FlatTupleBase;
-
-template <size_t... Idx, typename... T>
-struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
-    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
-  using Indices = IndexSequence<Idx...>;
-  FlatTupleBase() = default;
-  explicit FlatTupleBase(T... t)
-      : FlatTupleElemBase<FlatTuple<T...>, Idx>(std::move(t))... {}
-};
-
-// Analog to std::tuple but with different tradeoffs.
-// This class minimizes the template instantiation depth, thus allowing more
-// elements that std::tuple would. std::tuple has been seen to require an
-// instantiation depth of more than 10x the number of elements in some
-// implementations.
-// FlatTuple and ElemFromList are not recursive and have a fixed depth
-// regardless of T...
-// MakeIndexSequence, on the other hand, it is recursive but with an
-// instantiation depth of O(ln(N)).
-template <typename... T>
-class FlatTuple
-    : private FlatTupleBase<FlatTuple<T...>,
-                            typename MakeIndexSequence<sizeof...(T)>::type> {
-  using Indices = typename FlatTuple::FlatTupleBase::Indices;
-
- public:
-  FlatTuple() = default;
-  explicit FlatTuple(T... t) : FlatTuple::FlatTupleBase(std::move(t)...) {}
-
-  template <size_t I>
-  const typename ElemFromList<I, Indices, T...>::type& Get() const {
-    return static_cast<const FlatTupleElemBase<FlatTuple, I>*>(this)->value;
-  }
-
-  template <size_t I>
-  typename ElemFromList<I, Indices, T...>::type& Get() {
-    return static_cast<FlatTupleElemBase<FlatTuple, I>*>(this)->value;
-  }
-};
-
-// Utility functions to be called with static_assert to induce deprecation
-// warnings.
-GTEST_INTERNAL_DEPRECATED(
-    "INSTANTIATE_TEST_CASE_P is deprecated, please use "
-    "INSTANTIATE_TEST_SUITE_P")
-constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }
-
-GTEST_INTERNAL_DEPRECATED(
-    "TYPED_TEST_CASE_P is deprecated, please use "
-    "TYPED_TEST_SUITE_P")
-constexpr bool TypedTestCase_P_IsDeprecated() { return true; }
-
-GTEST_INTERNAL_DEPRECATED(
-    "TYPED_TEST_CASE is deprecated, please use "
-    "TYPED_TEST_SUITE")
-constexpr bool TypedTestCaseIsDeprecated() { return true; }
-
-GTEST_INTERNAL_DEPRECATED(
-    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
-    "REGISTER_TYPED_TEST_SUITE_P")
-constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }
-
-GTEST_INTERNAL_DEPRECATED(
-    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
-    "INSTANTIATE_TYPED_TEST_SUITE_P")
-constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }
-
-}  // namespace internal
-}  // namespace testing
-
-#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
-  ::testing::internal::AssertHelper(result_type, file, line, message) \
-    = ::testing::Message()
-
-#define GTEST_MESSAGE_(message, result_type) \
-  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
-
-#define GTEST_FATAL_FAILURE_(message) \
-  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
-
-#define GTEST_NONFATAL_FAILURE_(message) \
-  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
-
-#define GTEST_SUCCESS_(message) \
-  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
-
-#define GTEST_SKIP_(message) \
-  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
-
-// Suppress MSVC warning 4072 (unreachable code) for the code following
-// statement if it returns or throws (or doesn't return or throw in some
-// situations).
-#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
-  if (::testing::internal::AlwaysTrue()) { statement; }
-
-#define GTEST_TEST_THROW_(statement, expected_exception, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
-    bool gtest_caught_expected = false; \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (expected_exception const&) { \
-      gtest_caught_expected = true; \
-    } \
-    catch (...) { \
-      gtest_msg.value = \
-          "Expected: " #statement " throws an exception of type " \
-          #expected_exception ".\n  Actual: it throws a different type."; \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
-    } \
-    if (!gtest_caught_expected) { \
-      gtest_msg.value = \
-          "Expected: " #statement " throws an exception of type " \
-          #expected_exception ".\n  Actual: it throws nothing."; \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
-      fail(gtest_msg.value)
-
-#define GTEST_TEST_NO_THROW_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (...) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
-      fail("Expected: " #statement " doesn't throw an exception.\n" \
-           "  Actual: it throws.")
-
-#define GTEST_TEST_ANY_THROW_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    bool gtest_caught_any = false; \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (...) { \
-      gtest_caught_any = true; \
-    } \
-    if (!gtest_caught_any) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
-      fail("Expected: " #statement " throws an exception.\n" \
-           "  Actual: it doesn't.")
-
-
-// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
-// either a boolean expression or an AssertionResult. text is a textual
-// represenation of expression as it was passed into the EXPECT_TRUE.
-#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (const ::testing::AssertionResult gtest_ar_ = \
-      ::testing::AssertionResult(expression)) \
-    ; \
-  else \
-    fail(::testing::internal::GetBoolAssertionFailureMessage(\
-        gtest_ar_, text, #actual, #expected).c_str())
-
-#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
-      fail("Expected: " #statement " doesn't generate new fatal " \
-           "failures in the current thread.\n" \
-           "  Actual: it does.")
-
-// Expands to the name of the class that implements the given test.
-#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
-  test_suite_name##_##test_name##_Test
-
-// Helper macro for defining tests.
-#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)      \
-  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
-      : public parent_class {                                                 \
-   public:                                                                    \
-    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                   \
-                                                                              \
-   private:                                                                   \
-    virtual void TestBody();                                                  \
-    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;     \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
-                                                           test_name));       \
-  };                                                                          \
-                                                                              \
-  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \
-                                                    test_name)::test_info_ =  \
-      ::testing::internal::MakeAndRegisterTestInfo(                           \
-          #test_suite_name, #test_name, nullptr, nullptr,                     \
-          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
-          ::testing::internal::SuiteApiResolver<                              \
-              parent_class>::GetSetUpCaseOrSuite(),                           \
-          ::testing::internal::SuiteApiResolver<                              \
-              parent_class>::GetTearDownCaseOrSuite(),                        \
-          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \
-              test_suite_name, test_name)>);                                  \
-  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This header file defines the public API for death tests.  It is
-// #included by gtest.h so a user doesn't need to include this
-// directly.
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This header file defines internal utilities needed for implementing
-// death tests.  They are subject to change without notice.
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-
-// Copyright 2007, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// The Google C++ Testing and Mocking Framework (Google Test)
-//
-// This file implements just enough of the matcher interface to allow
-// EXPECT_DEATH and friends to accept a matcher argument.
-
-// IWYU pragma: private, include "testing/base/public/gunit.h"
-// IWYU pragma: friend third_party/googletest/googlemock/.*
-// IWYU pragma: friend third_party/googletest/googletest/.*
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
-#define GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
-
-#include <memory>
-#include <ostream>
-#include <string>
-
-// Copyright 2007, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-// Google Test - The Google C++ Testing and Mocking Framework
-//
-// This file implements a universal value printer that can print a
-// value of any type T:
-//
-//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
-//
-// A user can teach this function how to print a class type T by
-// defining either operator<<() or PrintTo() in the namespace that
-// defines T.  More specifically, the FIRST defined function in the
-// following list will be used (assuming T is defined in namespace
-// foo):
-//
-//   1. foo::PrintTo(const T&, ostream*)
-//   2. operator<<(ostream&, const T&) defined in either foo or the
-//      global namespace.
-//
-// However if T is an STL-style container then it is printed element-wise
-// unless foo::PrintTo(const T&, ostream*) is defined. Note that
-// operator<<() is ignored for container types.
-//
-// If none of the above is defined, it will print the debug string of
-// the value if it is a protocol buffer, or print the raw bytes in the
-// value otherwise.
-//
-// To aid debugging: when T is a reference type, the address of the
-// value is also printed; when T is a (const) char pointer, both the
-// pointer value and the NUL-terminated string it points to are
-// printed.
-//
-// We also provide some convenient wrappers:
-//
-//   // Prints a value to a string.  For a (const or not) char
-//   // pointer, the NUL-terminated string (but not the pointer) is
-//   // printed.
-//   std::string ::testing::PrintToString(const T& value);
-//
-//   // Prints a value tersely: for a reference type, the referenced
-//   // value (but not the address) is printed; for a (const or not) char
-//   // pointer, the NUL-terminated string (but not the pointer) is
-//   // printed.
-//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
-//
-//   // Prints value using the type inferred by the compiler.  The difference
-//   // from UniversalTersePrint() is that this function prints both the
-//   // pointer and the NUL-terminated string for a (const or not) char pointer.
-//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
-//
-//   // Prints the fields of a tuple tersely to a string vector, one
-//   // element for each field. Tuple support must be enabled in
-//   // gtest-port.h.
-//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
-//       const Tuple& value);
-//
-// Known limitation:
-//
-// The print primitives print the elements of an STL-style container
-// using the compiler-inferred type of *iter where iter is a
-// const_iterator of the container.  When const_iterator is an input
-// iterator but not a forward iterator, this inferred type may not
-// match value_type, and the print output may be incorrect.  In
-// practice, this is rarely a problem as for most containers
-// const_iterator is a forward iterator.  We'll fix this if there's an
-// actual need for it.  Note that this fix cannot rely on value_type
-// being defined as many user-defined container types don't have
-// value_type.
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-
-#include <functional>
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#if GTEST_HAS_ABSL
-#include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
-#endif  // GTEST_HAS_ABSL
-
-namespace testing {
-
-// Definitions in the 'internal' and 'internal2' name spaces are
-// subject to change without notice.  DO NOT USE THEM IN USER CODE!
-namespace internal2 {
-
-// Prints the given number of bytes in the given object to the given
-// ostream.
-GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
-                                     size_t count,
-                                     ::std::ostream* os);
-
-// For selecting which printer to use when a given type has neither <<
-// nor PrintTo().
-enum TypeKind {
-  kProtobuf,              // a protobuf type
-  kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
-                          // (e.g. a named or unnamed enum type)
-#if GTEST_HAS_ABSL
-  kConvertibleToStringView,  // a type implicitly convertible to
-                             // absl::string_view
-#endif
-  kOtherType  // anything else
-};
-
-// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
-// by the universal printer to print a value of type T when neither
-// operator<< nor PrintTo() is defined for T, where kTypeKind is the
-// "kind" of T as defined by enum TypeKind.
-template <typename T, TypeKind kTypeKind>
-class TypeWithoutFormatter {
- public:
-  // This default version is called when kTypeKind is kOtherType.
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    PrintBytesInObjectTo(static_cast<const unsigned char*>(
-                             reinterpret_cast<const void*>(&value)),
-                         sizeof(value), os);
-  }
-};
-
-// We print a protobuf using its ShortDebugString() when the string
-// doesn't exceed this many characters; otherwise we print it using
-// DebugString() for better readability.
-const size_t kProtobufOneLinerMaxLength = 50;
-
-template <typename T>
-class TypeWithoutFormatter<T, kProtobuf> {
- public:
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    std::string pretty_str = value.ShortDebugString();
-    if (pretty_str.length() > kProtobufOneLinerMaxLength) {
-      pretty_str = "\n" + value.DebugString();
-    }
-    *os << ("<" + pretty_str + ">");
-  }
-};
-
-template <typename T>
-class TypeWithoutFormatter<T, kConvertibleToInteger> {
- public:
-  // Since T has no << operator or PrintTo() but can be implicitly
-  // converted to BiggestInt, we print it as a BiggestInt.
-  //
-  // Most likely T is an enum type (either named or unnamed), in which
-  // case printing it as an integer is the desired behavior.  In case
-  // T is not an enum, printing it as an integer is the best we can do
-  // given that it has no user-defined printer.
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    const internal::BiggestInt kBigInt = value;
-    *os << kBigInt;
-  }
-};
-
-#if GTEST_HAS_ABSL
-template <typename T>
-class TypeWithoutFormatter<T, kConvertibleToStringView> {
- public:
-  // Since T has neither operator<< nor PrintTo() but can be implicitly
-  // converted to absl::string_view, we print it as a absl::string_view.
-  //
-  // Note: the implementation is further below, as it depends on
-  // internal::PrintTo symbol which is defined later in the file.
-  static void PrintValue(const T& value, ::std::ostream* os);
-};
-#endif
-
-// Prints the given value to the given ostream.  If the value is a
-// protocol message, its debug string is printed; if it's an enum or
-// of a type implicitly convertible to BiggestInt, it's printed as an
-// integer; otherwise the bytes in the value are printed.  This is
-// what UniversalPrinter<T>::Print() does when it knows nothing about
-// type T and T has neither << operator nor PrintTo().
-//
-// A user can override this behavior for a class type Foo by defining
-// a << operator in the namespace where Foo is defined.
-//
-// We put this operator in namespace 'internal2' instead of 'internal'
-// to simplify the implementation, as much code in 'internal' needs to
-// use << in STL, which would conflict with our own << were it defined
-// in 'internal'.
-//
-// Note that this operator<< takes a generic std::basic_ostream<Char,
-// CharTraits> type instead of the more restricted std::ostream.  If
-// we define it to take an std::ostream instead, we'll get an
-// "ambiguous overloads" compiler error when trying to print a type
-// Foo that supports streaming to std::basic_ostream<Char,
-// CharTraits>, as the compiler cannot tell whether
-// operator<<(std::ostream&, const T&) or
-// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
-// specific.
-template <typename Char, typename CharTraits, typename T>
-::std::basic_ostream<Char, CharTraits>& operator<<(
-    ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
-  TypeWithoutFormatter<T, (internal::IsAProtocolMessage<T>::value
-                               ? kProtobuf
-                               : std::is_convertible<
-                                     const T&, internal::BiggestInt>::value
-                                     ? kConvertibleToInteger
-                                     :
-#if GTEST_HAS_ABSL
-                                     std::is_convertible<
-                                         const T&, absl::string_view>::value
-                                         ? kConvertibleToStringView
-                                         :
-#endif
-                                         kOtherType)>::PrintValue(x, &os);
-  return os;
-}
-
-}  // namespace internal2
-}  // namespace testing
-
-// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
-// magic needed for implementing UniversalPrinter won't work.
-namespace testing_internal {
-
-// Used to print a value that is not an STL-style container when the
-// user doesn't define PrintTo() for it.
-template <typename T>
-void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
-  // With the following statement, during unqualified name lookup,
-  // testing::internal2::operator<< appears as if it was declared in
-  // the nearest enclosing namespace that contains both
-  // ::testing_internal and ::testing::internal2, i.e. the global
-  // namespace.  For more details, refer to the C++ Standard section
-  // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
-  // testing::internal2::operator<< in case T doesn't come with a <<
-  // operator.
-  //
-  // We cannot write 'using ::testing::internal2::operator<<;', which
-  // gcc 3.3 fails to compile due to a compiler bug.
-  using namespace ::testing::internal2;  // NOLINT
-
-  // Assuming T is defined in namespace foo, in the next statement,
-  // the compiler will consider all of:
-  //
-  //   1. foo::operator<< (thanks to Koenig look-up),
-  //   2. ::operator<< (as the current namespace is enclosed in ::),
-  //   3. testing::internal2::operator<< (thanks to the using statement above).
-  //
-  // The operator<< whose type matches T best will be picked.
-  //
-  // We deliberately allow #2 to be a candidate, as sometimes it's
-  // impossible to define #1 (e.g. when foo is ::std, defining
-  // anything in it is undefined behavior unless you are a compiler
-  // vendor.).
-  *os << value;
-}
-
-}  // namespace testing_internal
-
-namespace testing {
-namespace internal {
-
-// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
-// value of type ToPrint that is an operand of a comparison assertion
-// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
-// the comparison, and is used to help determine the best way to
-// format the value.  In particular, when the value is a C string
-// (char pointer) and the other operand is an STL string object, we
-// want to format the C string as a string, since we know it is
-// compared by value with the string object.  If the value is a char
-// pointer but the other operand is not an STL string object, we don't
-// know whether the pointer is supposed to point to a NUL-terminated
-// string, and thus want to print it as a pointer to be safe.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-// The default case.
-template <typename ToPrint, typename OtherOperand>
-class FormatForComparison {
- public:
-  static ::std::string Format(const ToPrint& value) {
-    return ::testing::PrintToString(value);
-  }
-};
-
-// Array.
-template <typename ToPrint, size_t N, typename OtherOperand>
-class FormatForComparison<ToPrint[N], OtherOperand> {
- public:
-  static ::std::string Format(const ToPrint* value) {
-    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
-  }
-};
-
-// By default, print C string as pointers to be safe, as we don't know
-// whether they actually point to a NUL-terminated string.
-
-#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
-  template <typename OtherOperand>                                      \
-  class FormatForComparison<CharType*, OtherOperand> {                  \
-   public:                                                              \
-    static ::std::string Format(CharType* value) {                      \
-      return ::testing::PrintToString(static_cast<const void*>(value)); \
-    }                                                                   \
-  }
-
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
-
-#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
-
-// If a C string is compared with an STL string object, we know it's meant
-// to point to a NUL-terminated string, and thus can print it as a string.
-
-#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
-  template <>                                                           \
-  class FormatForComparison<CharType*, OtherStringType> {               \
-   public:                                                              \
-    static ::std::string Format(CharType* value) {                      \
-      return ::testing::PrintToString(value);                           \
-    }                                                                   \
-  }
-
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
-
-#if GTEST_HAS_STD_WSTRING
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
-#endif
-
-#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
-
-// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
-// operand to be used in a failure message.  The type (but not value)
-// of the other operand may affect the format.  This allows us to
-// print a char* as a raw pointer when it is compared against another
-// char* or void*, and print it as a C string when it is compared
-// against an std::string object, for example.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-template <typename T1, typename T2>
-std::string FormatForComparisonFailureMessage(
-    const T1& value, const T2& /* other_operand */) {
-  return FormatForComparison<T1, T2>::Format(value);
-}
-
-// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
-// value to the given ostream.  The caller must ensure that
-// 'ostream_ptr' is not NULL, or the behavior is undefined.
-//
-// We define UniversalPrinter as a class template (as opposed to a
-// function template), as we need to partially specialize it for
-// reference types, which cannot be done with function templates.
-template <typename T>
-class UniversalPrinter;
-
-template <typename T>
-void UniversalPrint(const T& value, ::std::ostream* os);
-
-enum DefaultPrinterType {
-  kPrintContainer,
-  kPrintPointer,
-  kPrintFunctionPointer,
-  kPrintOther,
-};
-template <DefaultPrinterType type> struct WrapPrinterType {};
-
-// Used to print an STL-style container when the user doesn't define
-// a PrintTo() for it.
-template <typename C>
-void DefaultPrintTo(WrapPrinterType<kPrintContainer> /* dummy */,
-                    const C& container, ::std::ostream* os) {
-  const size_t kMaxCount = 32;  // The maximum number of elements to print.
-  *os << '{';
-  size_t count = 0;
-  for (typename C::const_iterator it = container.begin();
-       it != container.end(); ++it, ++count) {
-    if (count > 0) {
-      *os << ',';
-      if (count == kMaxCount) {  // Enough has been printed.
-        *os << " ...";
-        break;
-      }
-    }
-    *os << ' ';
-    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
-    // handle *it being a native array.
-    internal::UniversalPrint(*it, os);
-  }
-
-  if (count > 0) {
-    *os << ' ';
-  }
-  *os << '}';
-}
-
-// Used to print a pointer that is neither a char pointer nor a member
-// pointer, when the user doesn't define PrintTo() for it.  (A member
-// variable pointer or member function pointer doesn't really point to
-// a location in the address space.  Their representation is
-// implementation-defined.  Therefore they will be printed as raw
-// bytes.)
-template <typename T>
-void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */,
-                    T* p, ::std::ostream* os) {
-  if (p == nullptr) {
-    *os << "NULL";
-  } else {
-    // T is not a function type.  We just call << to print p,
-    // relying on ADL to pick up user-defined << for their pointer
-    // types, if any.
-    *os << p;
-  }
-}
-template <typename T>
-void DefaultPrintTo(WrapPrinterType<kPrintFunctionPointer> /* dummy */,
-                    T* p, ::std::ostream* os) {
-  if (p == nullptr) {
-    *os << "NULL";
-  } else {
-    // T is a function type, so '*os << p' doesn't do what we want
-    // (it just prints p as bool).  We want to print p as a const
-    // void*.
-    *os << reinterpret_cast<const void*>(p);
-  }
-}
-
-// Used to print a non-container, non-pointer value when the user
-// doesn't define PrintTo() for it.
-template <typename T>
-void DefaultPrintTo(WrapPrinterType<kPrintOther> /* dummy */,
-                    const T& value, ::std::ostream* os) {
-  ::testing_internal::DefaultPrintNonContainerTo(value, os);
-}
-
-// Prints the given value using the << operator if it has one;
-// otherwise prints the bytes in it.  This is what
-// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
-// or overloaded for type T.
-//
-// A user can override this behavior for a class type Foo by defining
-// an overload of PrintTo() in the namespace where Foo is defined.  We
-// give the user this option as sometimes defining a << operator for
-// Foo is not desirable (e.g. the coding style may prevent doing it,
-// or there is already a << operator but it doesn't do what the user
-// wants).
-template <typename T>
-void PrintTo(const T& value, ::std::ostream* os) {
-  // DefaultPrintTo() is overloaded.  The type of its first argument
-  // determines which version will be picked.
-  //
-  // Note that we check for container types here, prior to we check
-  // for protocol message types in our operator<<.  The rationale is:
-  //
-  // For protocol messages, we want to give people a chance to
-  // override Google Mock's format by defining a PrintTo() or
-  // operator<<.  For STL containers, other formats can be
-  // incompatible with Google Mock's format for the container
-  // elements; therefore we check for container types here to ensure
-  // that our format is used.
-  //
-  // Note that MSVC and clang-cl do allow an implicit conversion from
-  // pointer-to-function to pointer-to-object, but clang-cl warns on it.
-  // So don't use ImplicitlyConvertible if it can be helped since it will
-  // cause this warning, and use a separate overload of DefaultPrintTo for
-  // function pointers so that the `*os << p` in the object pointer overload
-  // doesn't cause that warning either.
-  DefaultPrintTo(
-      WrapPrinterType <
-                  (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
-              !IsRecursiveContainer<T>::value
-          ? kPrintContainer
-          : !std::is_pointer<T>::value
-                ? kPrintOther
-                : std::is_function<typename std::remove_pointer<T>::type>::value
-                      ? kPrintFunctionPointer
-                      : kPrintPointer > (),
-      value, os);
-}
-
-// The following list of PrintTo() overloads tells
-// UniversalPrinter<T>::Print() how to print standard types (built-in
-// types, strings, plain arrays, and pointers).
-
-// Overloads for various char types.
-GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
-GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
-inline void PrintTo(char c, ::std::ostream* os) {
-  // When printing a plain char, we always treat it as unsigned.  This
-  // way, the output won't be affected by whether the compiler thinks
-  // char is signed or not.
-  PrintTo(static_cast<unsigned char>(c), os);
-}
-
-// Overloads for other simple built-in types.
-inline void PrintTo(bool x, ::std::ostream* os) {
-  *os << (x ? "true" : "false");
-}
-
-// Overload for wchar_t type.
-// Prints a wchar_t as a symbol if it is printable or as its internal
-// code otherwise and also as its decimal code (except for L'\0').
-// The L'\0' char is printed as "L'\\0'". The decimal code is printed
-// as signed integer when wchar_t is implemented by the compiler
-// as a signed type and is printed as an unsigned integer when wchar_t
-// is implemented as an unsigned type.
-GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
-
-// Overloads for C strings.
-GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
-inline void PrintTo(char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const char*>(s), os);
-}
-
-// signed/unsigned char is often used for representing binary data, so
-// we print pointers to it as void* to be safe.
-inline void PrintTo(const signed char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(signed char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(unsigned char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-
-// MSVC can be configured to define wchar_t as a typedef of unsigned
-// short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
-// type.  When wchar_t is a typedef, defining an overload for const
-// wchar_t* would cause unsigned short* be printed as a wide string,
-// possibly causing invalid memory accesses.
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-// Overloads for wide C strings
-GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
-inline void PrintTo(wchar_t* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
-}
-#endif
-
-// Overload for C arrays.  Multi-dimensional arrays are printed
-// properly.
-
-// Prints the given number of elements in an array, without printing
-// the curly braces.
-template <typename T>
-void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
-  UniversalPrint(a[0], os);
-  for (size_t i = 1; i != count; i++) {
-    *os << ", ";
-    UniversalPrint(a[i], os);
-  }
-}
-
-// Overloads for ::std::string.
-GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
-inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
-  PrintStringTo(s, os);
-}
-
-// Overloads for ::std::wstring.
-#if GTEST_HAS_STD_WSTRING
-GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
-inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
-  PrintWideStringTo(s, os);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_ABSL
-// Overload for absl::string_view.
-inline void PrintTo(absl::string_view sp, ::std::ostream* os) {
-  PrintTo(::std::string(sp), os);
-}
-#endif  // GTEST_HAS_ABSL
-
-inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
-
-template <typename T>
-void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
-  UniversalPrinter<T&>::Print(ref.get(), os);
-}
-
-// Helper function for printing a tuple.  T must be instantiated with
-// a tuple type.
-template <typename T>
-void PrintTupleTo(const T&, std::integral_constant<size_t, 0>,
-                  ::std::ostream*) {}
-
-template <typename T, size_t I>
-void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
-                  ::std::ostream* os) {
-  PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
-  GTEST_INTENTIONAL_CONST_COND_PUSH_()
-  if (I > 1) {
-    GTEST_INTENTIONAL_CONST_COND_POP_()
-    *os << ", ";
-  }
-  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
-      std::get<I - 1>(t), os);
-}
-
-template <typename... Types>
-void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
-  *os << "(";
-  PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
-  *os << ")";
-}
-
-// Overload for std::pair.
-template <typename T1, typename T2>
-void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
-  *os << '(';
-  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
-  // a reference type.  The same for printing value.second.
-  UniversalPrinter<T1>::Print(value.first, os);
-  *os << ", ";
-  UniversalPrinter<T2>::Print(value.second, os);
-  *os << ')';
-}
-
-// Implements printing a non-reference type T by letting the compiler
-// pick the right overload of PrintTo() for T.
-template <typename T>
-class UniversalPrinter {
- public:
-  // MSVC warns about adding const to a function type, so we want to
-  // disable the warning.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
-
-  // Note: we deliberately don't call this PrintTo(), as that name
-  // conflicts with ::testing::internal::PrintTo in the body of the
-  // function.
-  static void Print(const T& value, ::std::ostream* os) {
-    // By default, ::testing::internal::PrintTo() is used for printing
-    // the value.
-    //
-    // Thanks to Koenig look-up, if T is a class and has its own
-    // PrintTo() function defined in its namespace, that function will
-    // be visible here.  Since it is more specific than the generic ones
-    // in ::testing::internal, it will be picked by the compiler in the
-    // following statement - exactly what we want.
-    PrintTo(value, os);
-  }
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-};
-
-#if GTEST_HAS_ABSL
-
-// Printer for absl::optional
-
-template <typename T>
-class UniversalPrinter<::absl::optional<T>> {
- public:
-  static void Print(const ::absl::optional<T>& value, ::std::ostream* os) {
-    *os << '(';
-    if (!value) {
-      *os << "nullopt";
-    } else {
-      UniversalPrint(*value, os);
-    }
-    *os << ')';
-  }
-};
-
-// Printer for absl::variant
-
-template <typename... T>
-class UniversalPrinter<::absl::variant<T...>> {
- public:
-  static void Print(const ::absl::variant<T...>& value, ::std::ostream* os) {
-    *os << '(';
-    absl::visit(Visitor{os}, value);
-    *os << ')';
-  }
-
- private:
-  struct Visitor {
-    template <typename U>
-    void operator()(const U& u) const {
-      *os << "'" << GetTypeName<U>() << "' with value ";
-      UniversalPrint(u, os);
-    }
-    ::std::ostream* os;
-  };
-};
-
-#endif  // GTEST_HAS_ABSL
-
-// UniversalPrintArray(begin, len, os) prints an array of 'len'
-// elements, starting at address 'begin'.
-template <typename T>
-void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
-  if (len == 0) {
-    *os << "{}";
-  } else {
-    *os << "{ ";
-    const size_t kThreshold = 18;
-    const size_t kChunkSize = 8;
-    // If the array has more than kThreshold elements, we'll have to
-    // omit some details by printing only the first and the last
-    // kChunkSize elements.
-    if (len <= kThreshold) {
-      PrintRawArrayTo(begin, len, os);
-    } else {
-      PrintRawArrayTo(begin, kChunkSize, os);
-      *os << ", ..., ";
-      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
-    }
-    *os << " }";
-  }
-}
-// This overload prints a (const) char array compactly.
-GTEST_API_ void UniversalPrintArray(
-    const char* begin, size_t len, ::std::ostream* os);
-
-// This overload prints a (const) wchar_t array compactly.
-GTEST_API_ void UniversalPrintArray(
-    const wchar_t* begin, size_t len, ::std::ostream* os);
-
-// Implements printing an array type T[N].
-template <typename T, size_t N>
-class UniversalPrinter<T[N]> {
- public:
-  // Prints the given array, omitting some elements when there are too
-  // many.
-  static void Print(const T (&a)[N], ::std::ostream* os) {
-    UniversalPrintArray(a, N, os);
-  }
-};
-
-// Implements printing a reference type T&.
-template <typename T>
-class UniversalPrinter<T&> {
- public:
-  // MSVC warns about adding const to a function type, so we want to
-  // disable the warning.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
-
-  static void Print(const T& value, ::std::ostream* os) {
-    // Prints the address of the value.  We use reinterpret_cast here
-    // as static_cast doesn't compile when T is a function type.
-    *os << "@" << reinterpret_cast<const void*>(&value) << " ";
-
-    // Then prints the value itself.
-    UniversalPrint(value, os);
-  }
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-};
-
-// Prints a value tersely: for a reference type, the referenced value
-// (but not the address) is printed; for a (const) char pointer, the
-// NUL-terminated string (but not the pointer) is printed.
-
-template <typename T>
-class UniversalTersePrinter {
- public:
-  static void Print(const T& value, ::std::ostream* os) {
-    UniversalPrint(value, os);
-  }
-};
-template <typename T>
-class UniversalTersePrinter<T&> {
- public:
-  static void Print(const T& value, ::std::ostream* os) {
-    UniversalPrint(value, os);
-  }
-};
-template <typename T, size_t N>
-class UniversalTersePrinter<T[N]> {
- public:
-  static void Print(const T (&value)[N], ::std::ostream* os) {
-    UniversalPrinter<T[N]>::Print(value, os);
-  }
-};
-template <>
-class UniversalTersePrinter<const char*> {
- public:
-  static void Print(const char* str, ::std::ostream* os) {
-    if (str == nullptr) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(std::string(str), os);
-    }
-  }
-};
-template <>
-class UniversalTersePrinter<char*> {
- public:
-  static void Print(char* str, ::std::ostream* os) {
-    UniversalTersePrinter<const char*>::Print(str, os);
-  }
-};
-
-#if GTEST_HAS_STD_WSTRING
-template <>
-class UniversalTersePrinter<const wchar_t*> {
- public:
-  static void Print(const wchar_t* str, ::std::ostream* os) {
-    if (str == nullptr) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(::std::wstring(str), os);
-    }
-  }
-};
-#endif
-
-template <>
-class UniversalTersePrinter<wchar_t*> {
- public:
-  static void Print(wchar_t* str, ::std::ostream* os) {
-    UniversalTersePrinter<const wchar_t*>::Print(str, os);
-  }
-};
-
-template <typename T>
-void UniversalTersePrint(const T& value, ::std::ostream* os) {
-  UniversalTersePrinter<T>::Print(value, os);
-}
-
-// Prints a value using the type inferred by the compiler.  The
-// difference between this and UniversalTersePrint() is that for a
-// (const) char pointer, this prints both the pointer and the
-// NUL-terminated string.
-template <typename T>
-void UniversalPrint(const T& value, ::std::ostream* os) {
-  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
-  // UniversalPrinter with T directly.
-  typedef T T1;
-  UniversalPrinter<T1>::Print(value, os);
-}
-
-typedef ::std::vector< ::std::string> Strings;
-
-  // Tersely prints the first N fields of a tuple to a string vector,
-  // one element for each field.
-template <typename Tuple>
-void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
-                               Strings*) {}
-template <typename Tuple, size_t I>
-void TersePrintPrefixToStrings(const Tuple& t,
-                               std::integral_constant<size_t, I>,
-                               Strings* strings) {
-  TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
-                            strings);
-  ::std::stringstream ss;
-  UniversalTersePrint(std::get<I - 1>(t), &ss);
-  strings->push_back(ss.str());
-}
-
-// Prints the fields of a tuple tersely to a string vector, one
-// element for each field.  See the comment before
-// UniversalTersePrint() for how we define "tersely".
-template <typename Tuple>
-Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
-  Strings result;
-  TersePrintPrefixToStrings(
-      value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
-      &result);
-  return result;
-}
-
-}  // namespace internal
-
-#if GTEST_HAS_ABSL
-namespace internal2 {
-template <typename T>
-void TypeWithoutFormatter<T, kConvertibleToStringView>::PrintValue(
-    const T& value, ::std::ostream* os) {
-  internal::PrintTo(absl::string_view(value), os);
-}
-}  // namespace internal2
-#endif
-
-template <typename T>
-::std::string PrintToString(const T& value) {
-  ::std::stringstream ss;
-  internal::UniversalTersePrinter<T>::Print(value, &ss);
-  return ss.str();
-}
-
-}  // namespace testing
-
-// Include any custom printer added by the local installation.
-// We must include this header at the end to make sure it can use the
-// declarations from this file.
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// This file provides an injection point for custom printers in a local
-// installation of gTest.
-// It will be included from gtest-printers.h and the overrides in this file
-// will be visible to everyone.
-//
-// Injection point for custom user configurations. See README for details
-//
-// ** Custom implementation starts here **
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-
-// MSVC warning C5046 is new as of VS2017 version 15.8.
-#if defined(_MSC_VER) && _MSC_VER >= 1915
-#define GTEST_MAYBE_5046_ 5046
-#else
-#define GTEST_MAYBE_5046_
-#endif
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(
-    4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by
-                              clients of class B */
-    /* Symbol involving type with internal linkage not defined */)
-
-namespace testing {
-
-// To implement a matcher Foo for type T, define:
-//   1. a class FooMatcherImpl that implements the
-//      MatcherInterface<T> interface, and
-//   2. a factory function that creates a Matcher<T> object from a
-//      FooMatcherImpl*.
-//
-// The two-level delegation design makes it possible to allow a user
-// to write "v" instead of "Eq(v)" where a Matcher is expected, which
-// is impossible if we pass matchers by pointers.  It also eases
-// ownership management as Matcher objects can now be copied like
-// plain values.
-
-// MatchResultListener is an abstract class.  Its << operator can be
-// used by a matcher to explain why a value matches or doesn't match.
-//
-class MatchResultListener {
- public:
-  // Creates a listener object with the given underlying ostream.  The
-  // listener does not own the ostream, and does not dereference it
-  // in the constructor or destructor.
-  explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
-  virtual ~MatchResultListener() = 0;  // Makes this class abstract.
-
-  // Streams x to the underlying ostream; does nothing if the ostream
-  // is NULL.
-  template <typename T>
-  MatchResultListener& operator<<(const T& x) {
-    if (stream_ != nullptr) *stream_ << x;
-    return *this;
-  }
-
-  // Returns the underlying ostream.
-  ::std::ostream* stream() { return stream_; }
-
-  // Returns true iff the listener is interested in an explanation of
-  // the match result.  A matcher's MatchAndExplain() method can use
-  // this information to avoid generating the explanation when no one
-  // intends to hear it.
-  bool IsInterested() const { return stream_ != nullptr; }
-
- private:
-  ::std::ostream* const stream_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
-};
-
-inline MatchResultListener::~MatchResultListener() {
-}
-
-// An instance of a subclass of this knows how to describe itself as a
-// matcher.
-class MatcherDescriberInterface {
- public:
-  virtual ~MatcherDescriberInterface() {}
-
-  // Describes this matcher to an ostream.  The function should print
-  // a verb phrase that describes the property a value matching this
-  // matcher should have.  The subject of the verb phrase is the value
-  // being matched.  For example, the DescribeTo() method of the Gt(7)
-  // matcher prints "is greater than 7".
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-
-  // Describes the negation of this matcher to an ostream.  For
-  // example, if the description of this matcher is "is greater than
-  // 7", the negated description could be "is not greater than 7".
-  // You are not required to override this when implementing
-  // MatcherInterface, but it is highly advised so that your matcher
-  // can produce good error messages.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "not (";
-    DescribeTo(os);
-    *os << ")";
-  }
-};
-
-// The implementation of a matcher.
-template <typename T>
-class MatcherInterface : public MatcherDescriberInterface {
- public:
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener' if necessary (see the next paragraph), in
-  // the form of a non-restrictive relative clause ("which ...",
-  // "whose ...", etc) that describes x.  For example, the
-  // MatchAndExplain() method of the Pointee(...) matcher should
-  // generate an explanation like "which points to ...".
-  //
-  // Implementations of MatchAndExplain() should add an explanation of
-  // the match result *if and only if* they can provide additional
-  // information that's not already present (or not obvious) in the
-  // print-out of x and the matcher's description.  Whether the match
-  // succeeds is not a factor in deciding whether an explanation is
-  // needed, as sometimes the caller needs to print a failure message
-  // when the match succeeds (e.g. when the matcher is used inside
-  // Not()).
-  //
-  // For example, a "has at least 10 elements" matcher should explain
-  // what the actual element count is, regardless of the match result,
-  // as it is useful information to the reader; on the other hand, an
-  // "is empty" matcher probably only needs to explain what the actual
-  // size is when the match fails, as it's redundant to say that the
-  // size is 0 when the value is already known to be empty.
-  //
-  // You should override this method when defining a new matcher.
-  //
-  // It's the responsibility of the caller (Google Test) to guarantee
-  // that 'listener' is not NULL.  This helps to simplify a matcher's
-  // implementation when it doesn't care about the performance, as it
-  // can talk to 'listener' without checking its validity first.
-  // However, in order to implement dummy listeners efficiently,
-  // listener->stream() may be NULL.
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
-
-  // Inherits these methods from MatcherDescriberInterface:
-  //   virtual void DescribeTo(::std::ostream* os) const = 0;
-  //   virtual void DescribeNegationTo(::std::ostream* os) const;
-};
-
-namespace internal {
-
-// Converts a MatcherInterface<T> to a MatcherInterface<const T&>.
-template <typename T>
-class MatcherInterfaceAdapter : public MatcherInterface<const T&> {
- public:
-  explicit MatcherInterfaceAdapter(const MatcherInterface<T>* impl)
-      : impl_(impl) {}
-  ~MatcherInterfaceAdapter() override { delete impl_; }
-
-  void DescribeTo(::std::ostream* os) const override { impl_->DescribeTo(os); }
-
-  void DescribeNegationTo(::std::ostream* os) const override {
-    impl_->DescribeNegationTo(os);
-  }
-
-  bool MatchAndExplain(const T& x,
-                       MatchResultListener* listener) const override {
-    return impl_->MatchAndExplain(x, listener);
-  }
-
- private:
-  const MatcherInterface<T>* const impl_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatcherInterfaceAdapter);
-};
-
-struct AnyEq {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a == b; }
-};
-struct AnyNe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a != b; }
-};
-struct AnyLt {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a < b; }
-};
-struct AnyGt {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a > b; }
-};
-struct AnyLe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a <= b; }
-};
-struct AnyGe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a >= b; }
-};
-
-// A match result listener that ignores the explanation.
-class DummyMatchResultListener : public MatchResultListener {
- public:
-  DummyMatchResultListener() : MatchResultListener(nullptr) {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
-};
-
-// A match result listener that forwards the explanation to a given
-// ostream.  The difference between this and MatchResultListener is
-// that the former is concrete.
-class StreamMatchResultListener : public MatchResultListener {
- public:
-  explicit StreamMatchResultListener(::std::ostream* os)
-      : MatchResultListener(os) {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
-};
-
-// An internal class for implementing Matcher<T>, which will derive
-// from it.  We put functionalities common to all Matcher<T>
-// specializations here to avoid code duplication.
-template <typename T>
-class MatcherBase {
- public:
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener'.
-  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
-    return impl_->MatchAndExplain(x, listener);
-  }
-
-  // Returns true iff this matcher matches x.
-  bool Matches(const T& x) const {
-    DummyMatchResultListener dummy;
-    return MatchAndExplain(x, &dummy);
-  }
-
-  // Describes this matcher to an ostream.
-  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
-
-  // Describes the negation of this matcher to an ostream.
-  void DescribeNegationTo(::std::ostream* os) const {
-    impl_->DescribeNegationTo(os);
-  }
-
-  // Explains why x matches, or doesn't match, the matcher.
-  void ExplainMatchResultTo(const T& x, ::std::ostream* os) const {
-    StreamMatchResultListener listener(os);
-    MatchAndExplain(x, &listener);
-  }
-
-  // Returns the describer for this matcher object; retains ownership
-  // of the describer, which is only guaranteed to be alive when
-  // this matcher object is alive.
-  const MatcherDescriberInterface* GetDescriber() const {
-    return impl_.get();
-  }
-
- protected:
-  MatcherBase() {}
-
-  // Constructs a matcher from its implementation.
-  explicit MatcherBase(const MatcherInterface<const T&>* impl) : impl_(impl) {}
-
-  template <typename U>
-  explicit MatcherBase(
-      const MatcherInterface<U>* impl,
-      typename internal::EnableIf<
-          !internal::IsSame<U, const U&>::value>::type* = nullptr)
-      : impl_(new internal::MatcherInterfaceAdapter<U>(impl)) {}
-
-  MatcherBase(const MatcherBase&) = default;
-  MatcherBase& operator=(const MatcherBase&) = default;
-  MatcherBase(MatcherBase&&) = default;
-  MatcherBase& operator=(MatcherBase&&) = default;
-
-  virtual ~MatcherBase() {}
-
- private:
-  std::shared_ptr<const MatcherInterface<const T&>> impl_;
-};
-
-}  // namespace internal
-
-// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
-// object that can check whether a value of type T matches.  The
-// implementation of Matcher<T> is just a std::shared_ptr to const
-// MatcherInterface<T>.  Don't inherit from Matcher!
-template <typename T>
-class Matcher : public internal::MatcherBase<T> {
- public:
-  // Constructs a null matcher.  Needed for storing Matcher objects in STL
-  // containers.  A default-constructed matcher is not yet initialized.  You
-  // cannot use it until a valid value has been assigned to it.
-  explicit Matcher() {}  // NOLINT
-
-  // Constructs a matcher from its implementation.
-  explicit Matcher(const MatcherInterface<const T&>* impl)
-      : internal::MatcherBase<T>(impl) {}
-
-  template <typename U>
-  explicit Matcher(const MatcherInterface<U>* impl,
-                   typename internal::EnableIf<
-                       !internal::IsSame<U, const U&>::value>::type* = nullptr)
-      : internal::MatcherBase<T>(impl) {}
-
-  // Implicit constructor here allows people to write
-  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
-  Matcher(T value);  // NOLINT
-};
-
-// The following two specializations allow the user to write str
-// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
-// matcher is expected.
-template <>
-class GTEST_API_ Matcher<const std::string&>
-    : public internal::MatcherBase<const std::string&> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const std::string&>* impl)
-      : internal::MatcherBase<const std::string&>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a std::string object.
-  Matcher(const std::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-};
-
-template <>
-class GTEST_API_ Matcher<std::string>
-    : public internal::MatcherBase<std::string> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const std::string&>* impl)
-      : internal::MatcherBase<std::string>(impl) {}
-  explicit Matcher(const MatcherInterface<std::string>* impl)
-      : internal::MatcherBase<std::string>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const std::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-};
-
-#if GTEST_HAS_ABSL
-// The following two specializations allow the user to write str
-// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
-// matcher is expected.
-template <>
-class GTEST_API_ Matcher<const absl::string_view&>
-    : public internal::MatcherBase<const absl::string_view&> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const absl::string_view&>* impl)
-      : internal::MatcherBase<const absl::string_view&>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a std::string object.
-  Matcher(const std::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-
-  // Allows the user to pass absl::string_views directly.
-  Matcher(absl::string_view s);  // NOLINT
-};
-
-template <>
-class GTEST_API_ Matcher<absl::string_view>
-    : public internal::MatcherBase<absl::string_view> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const absl::string_view&>* impl)
-      : internal::MatcherBase<absl::string_view>(impl) {}
-  explicit Matcher(const MatcherInterface<absl::string_view>* impl)
-      : internal::MatcherBase<absl::string_view>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a std::string object.
-  Matcher(const std::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-
-  // Allows the user to pass absl::string_views directly.
-  Matcher(absl::string_view s);  // NOLINT
-};
-#endif  // GTEST_HAS_ABSL
-
-// Prints a matcher in a human-readable format.
-template <typename T>
-std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
-  matcher.DescribeTo(&os);
-  return os;
-}
-
-// The PolymorphicMatcher class template makes it easy to implement a
-// polymorphic matcher (i.e. a matcher that can match values of more
-// than one type, e.g. Eq(n) and NotNull()).
-//
-// To define a polymorphic matcher, a user should provide an Impl
-// class that has a DescribeTo() method and a DescribeNegationTo()
-// method, and define a member function (or member function template)
-//
-//   bool MatchAndExplain(const Value& value,
-//                        MatchResultListener* listener) const;
-//
-// See the definition of NotNull() for a complete example.
-template <class Impl>
-class PolymorphicMatcher {
- public:
-  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
-
-  // Returns a mutable reference to the underlying matcher
-  // implementation object.
-  Impl& mutable_impl() { return impl_; }
-
-  // Returns an immutable reference to the underlying matcher
-  // implementation object.
-  const Impl& impl() const { return impl_; }
-
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new MonomorphicImpl<const T&>(impl_));
-  }
-
- private:
-  template <typename T>
-  class MonomorphicImpl : public MatcherInterface<T> {
-   public:
-    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
-
-    virtual void DescribeTo(::std::ostream* os) const { impl_.DescribeTo(os); }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      impl_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-      return impl_.MatchAndExplain(x, listener);
-    }
-
-   private:
-    const Impl impl_;
-  };
-
-  Impl impl_;
-};
-
-// Creates a matcher from its implementation.
-// DEPRECATED: Especially in the generic code, prefer:
-//   Matcher<T>(new MyMatcherImpl<const T&>(...));
-//
-// MakeMatcher may create a Matcher that accepts its argument by value, which
-// leads to unnecessary copies & lack of support for non-copyable types.
-template <typename T>
-inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
-  return Matcher<T>(impl);
-}
-
-// Creates a polymorphic matcher from its implementation.  This is
-// easier to use than the PolymorphicMatcher<Impl> constructor as it
-// doesn't require you to explicitly write the template argument, e.g.
-//
-//   MakePolymorphicMatcher(foo);
-// vs
-//   PolymorphicMatcher<TypeOfFoo>(foo);
-template <class Impl>
-inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
-  return PolymorphicMatcher<Impl>(impl);
-}
-
-namespace internal {
-// Implements a matcher that compares a given value with a
-// pre-supplied value using one of the ==, <=, <, etc, operators.  The
-// two values being compared don't have to have the same type.
-//
-// The matcher defined here is polymorphic (for example, Eq(5) can be
-// used to match an int, a short, a double, etc).  Therefore we use
-// a template type conversion operator in the implementation.
-//
-// The following template definition assumes that the Rhs parameter is
-// a "bare" type (i.e. neither 'const T' nor 'T&').
-template <typename D, typename Rhs, typename Op>
-class ComparisonBase {
- public:
-  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
-  template <typename Lhs>
-  operator Matcher<Lhs>() const {
-    return Matcher<Lhs>(new Impl<const Lhs&>(rhs_));
-  }
-
- private:
-  template <typename T>
-  static const T& Unwrap(const T& v) { return v; }
-  template <typename T>
-  static const T& Unwrap(std::reference_wrapper<T> v) { return v; }
-
-  template <typename Lhs, typename = Rhs>
-  class Impl : public MatcherInterface<Lhs> {
-   public:
-    explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
-    bool MatchAndExplain(Lhs lhs,
-                         MatchResultListener* /* listener */) const override {
-      return Op()(lhs, Unwrap(rhs_));
-    }
-    void DescribeTo(::std::ostream* os) const override {
-      *os << D::Desc() << " ";
-      UniversalPrint(Unwrap(rhs_), os);
-    }
-    void DescribeNegationTo(::std::ostream* os) const override {
-      *os << D::NegatedDesc() <<  " ";
-      UniversalPrint(Unwrap(rhs_), os);
-    }
-
-   private:
-    Rhs rhs_;
-  };
-  Rhs rhs_;
-};
-
-template <typename Rhs>
-class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
- public:
-  explicit EqMatcher(const Rhs& rhs)
-      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
-  static const char* Desc() { return "is equal to"; }
-  static const char* NegatedDesc() { return "isn't equal to"; }
-};
-template <typename Rhs>
-class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
- public:
-  explicit NeMatcher(const Rhs& rhs)
-      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
-  static const char* Desc() { return "isn't equal to"; }
-  static const char* NegatedDesc() { return "is equal to"; }
-};
-template <typename Rhs>
-class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
- public:
-  explicit LtMatcher(const Rhs& rhs)
-      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
-  static const char* Desc() { return "is <"; }
-  static const char* NegatedDesc() { return "isn't <"; }
-};
-template <typename Rhs>
-class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
- public:
-  explicit GtMatcher(const Rhs& rhs)
-      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
-  static const char* Desc() { return "is >"; }
-  static const char* NegatedDesc() { return "isn't >"; }
-};
-template <typename Rhs>
-class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
- public:
-  explicit LeMatcher(const Rhs& rhs)
-      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
-  static const char* Desc() { return "is <="; }
-  static const char* NegatedDesc() { return "isn't <="; }
-};
-template <typename Rhs>
-class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
- public:
-  explicit GeMatcher(const Rhs& rhs)
-      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
-  static const char* Desc() { return "is >="; }
-  static const char* NegatedDesc() { return "isn't >="; }
-};
-
-// Implements polymorphic matchers MatchesRegex(regex) and
-// ContainsRegex(regex), which can be used as a Matcher<T> as long as
-// T can be converted to a string.
-class MatchesRegexMatcher {
- public:
-  MatchesRegexMatcher(const RE* regex, bool full_match)
-      : regex_(regex), full_match_(full_match) {}
-
-#if GTEST_HAS_ABSL
-  bool MatchAndExplain(const absl::string_view& s,
-                       MatchResultListener* listener) const {
-    return MatchAndExplain(std::string(s), listener);
-  }
-#endif  // GTEST_HAS_ABSL
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != nullptr && MatchAndExplain(std::string(s), listener);
-  }
-
-  // Matches anything that can convert to std::string.
-  //
-  // This is a template, not just a plain function with const std::string&,
-  // because absl::string_view has some interfering non-explicit constructors.
-  template <class MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const std::string& s2(s);
-    return full_match_ ? RE::FullMatch(s2, *regex_)
-                       : RE::PartialMatch(s2, *regex_);
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << (full_match_ ? "matches" : "contains") << " regular expression ";
-    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't " << (full_match_ ? "match" : "contain")
-        << " regular expression ";
-    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
-  }
-
- private:
-  const std::shared_ptr<const RE> regex_;
-  const bool full_match_;
-};
-}  // namespace internal
-
-// Matches a string that fully matches regular expression 'regex'.
-// The matcher takes ownership of 'regex'.
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
-    const internal::RE* regex) {
-  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
-}
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
-    const std::string& regex) {
-  return MatchesRegex(new internal::RE(regex));
-}
-
-// Matches a string that contains regular expression 'regex'.
-// The matcher takes ownership of 'regex'.
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
-    const internal::RE* regex) {
-  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
-}
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
-    const std::string& regex) {
-  return ContainsRegex(new internal::RE(regex));
-}
-
-// Creates a polymorphic matcher that matches anything equal to x.
-// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
-// wouldn't compile.
-template <typename T>
-inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
-
-// Constructs a Matcher<T> from a 'value' of type T.  The constructed
-// matcher matches any value that's equal to 'value'.
-template <typename T>
-Matcher<T>::Matcher(T value) { *this = Eq(value); }
-
-// Creates a monomorphic matcher that matches anything with type Lhs
-// and equal to rhs.  A user may need to use this instead of Eq(...)
-// in order to resolve an overloading ambiguity.
-//
-// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
-// or Matcher<T>(x), but more readable than the latter.
-//
-// We could define similar monomorphic matchers for other comparison
-// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
-// it yet as those are used much less than Eq() in practice.  A user
-// can always write Matcher<T>(Lt(5)) to be explicit about the type,
-// for example.
-template <typename Lhs, typename Rhs>
-inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
-
-// Creates a polymorphic matcher that matches anything >= x.
-template <typename Rhs>
-inline internal::GeMatcher<Rhs> Ge(Rhs x) {
-  return internal::GeMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything > x.
-template <typename Rhs>
-inline internal::GtMatcher<Rhs> Gt(Rhs x) {
-  return internal::GtMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything <= x.
-template <typename Rhs>
-inline internal::LeMatcher<Rhs> Le(Rhs x) {
-  return internal::LeMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything < x.
-template <typename Rhs>
-inline internal::LtMatcher<Rhs> Lt(Rhs x) {
-  return internal::LtMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything != x.
-template <typename Rhs>
-inline internal::NeMatcher<Rhs> Ne(Rhs x) {
-  return internal::NeMatcher<Rhs>(x);
-}
-}  // namespace testing
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
-
-#include <stdio.h>
-#include <memory>
-
-namespace testing {
-namespace internal {
-
-GTEST_DECLARE_string_(internal_run_death_test);
-
-// Names of the flags (needed for parsing Google Test flags).
-const char kDeathTestStyleFlag[] = "death_test_style";
-const char kDeathTestUseFork[] = "death_test_use_fork";
-const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
-
-#if GTEST_HAS_DEATH_TEST
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-// DeathTest is a class that hides much of the complexity of the
-// GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
-// returns a concrete class that depends on the prevailing death test
-// style, as defined by the --gtest_death_test_style and/or
-// --gtest_internal_run_death_test flags.
-
-// In describing the results of death tests, these terms are used with
-// the corresponding definitions:
-//
-// exit status:  The integer exit information in the format specified
-//               by wait(2)
-// exit code:    The integer code passed to exit(3), _exit(2), or
-//               returned from main()
-class GTEST_API_ DeathTest {
- public:
-  // Create returns false if there was an error determining the
-  // appropriate action to take for the current death test; for example,
-  // if the gtest_death_test_style flag is set to an invalid value.
-  // The LastMessage method will return a more detailed message in that
-  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
-  // argument is set.  If the death test should be skipped, the pointer
-  // is set to NULL; otherwise, it is set to the address of a new concrete
-  // DeathTest object that controls the execution of the current test.
-  static bool Create(const char* statement, Matcher<const std::string&> matcher,
-                     const char* file, int line, DeathTest** test);
-  DeathTest();
-  virtual ~DeathTest() { }
-
-  // A helper class that aborts a death test when it's deleted.
-  class ReturnSentinel {
-   public:
-    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
-    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
-   private:
-    DeathTest* const test_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
-  } GTEST_ATTRIBUTE_UNUSED_;
-
-  // An enumeration of possible roles that may be taken when a death
-  // test is encountered.  EXECUTE means that the death test logic should
-  // be executed immediately.  OVERSEE means that the program should prepare
-  // the appropriate environment for a child process to execute the death
-  // test, then wait for it to complete.
-  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
-
-  // An enumeration of the three reasons that a test might be aborted.
-  enum AbortReason {
-    TEST_ENCOUNTERED_RETURN_STATEMENT,
-    TEST_THREW_EXCEPTION,
-    TEST_DID_NOT_DIE
-  };
-
-  // Assumes one of the above roles.
-  virtual TestRole AssumeRole() = 0;
-
-  // Waits for the death test to finish and returns its status.
-  virtual int Wait() = 0;
-
-  // Returns true if the death test passed; that is, the test process
-  // exited during the test, its exit status matches a user-supplied
-  // predicate, and its stderr output matches a user-supplied regular
-  // expression.
-  // The user-supplied predicate may be a macro expression rather
-  // than a function pointer or functor, or else Wait and Passed could
-  // be combined.
-  virtual bool Passed(bool exit_status_ok) = 0;
-
-  // Signals that the death test did not die as expected.
-  virtual void Abort(AbortReason reason) = 0;
-
-  // Returns a human-readable outcome message regarding the outcome of
-  // the last death test.
-  static const char* LastMessage();
-
-  static void set_last_death_test_message(const std::string& message);
-
- private:
-  // A string containing a description of the outcome of the last death test.
-  static std::string last_death_test_message_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
-};
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-// Factory interface for death tests.  May be mocked out for testing.
-class DeathTestFactory {
- public:
-  virtual ~DeathTestFactory() { }
-  virtual bool Create(const char* statement,
-                      Matcher<const std::string&> matcher, const char* file,
-                      int line, DeathTest** test) = 0;
-};
-
-// A concrete DeathTestFactory implementation for normal use.
-class DefaultDeathTestFactory : public DeathTestFactory {
- public:
-  bool Create(const char* statement, Matcher<const std::string&> matcher,
-              const char* file, int line, DeathTest** test) override;
-};
-
-// Returns true if exit_status describes a process that was terminated
-// by a signal, or exited normally with a nonzero exit code.
-GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
-
-// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
-// and interpreted as a regex (rather than an Eq matcher) for legacy
-// compatibility.
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    ::testing::internal::RE regex) {
-  return ContainsRegex(regex.pattern());
-}
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
-  return ContainsRegex(regex);
-}
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    const ::std::string& regex) {
-  return ContainsRegex(regex);
-}
-
-// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
-// used directly.
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    Matcher<const ::std::string&> matcher) {
-  return matcher;
-}
-
-// Traps C++ exceptions escaping statement and reports them as test
-// failures. Note that trapping SEH exceptions is not implemented here.
-# if GTEST_HAS_EXCEPTIONS
-#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
-  try { \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-  } catch (const ::std::exception& gtest_exception) { \
-    fprintf(\
-        stderr, \
-        "\n%s: Caught std::exception-derived exception escaping the " \
-        "death test statement. Exception message: %s\n", \
-        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
-        gtest_exception.what()); \
-    fflush(stderr); \
-    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
-  } catch (...) { \
-    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
-  }
-
-# else
-#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
-  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
-
-# endif
-
-// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
-// ASSERT_EXIT*, and EXPECT_EXIT*.
-#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)        \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
-  if (::testing::internal::AlwaysTrue()) {                                     \
-    ::testing::internal::DeathTest* gtest_dt;                                  \
-    if (!::testing::internal::DeathTest::Create(                               \
-            #statement,                                                        \
-            ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),       \
-            __FILE__, __LINE__, &gtest_dt)) {                                  \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
-    }                                                                          \
-    if (gtest_dt != nullptr) {                                                 \
-      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
-      switch (gtest_dt->AssumeRole()) {                                        \
-        case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
-          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \
-            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                  \
-          }                                                                    \
-          break;                                                               \
-        case ::testing::internal::DeathTest::EXECUTE_TEST: {                   \
-          ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(       \
-              gtest_dt);                                                       \
-          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);            \
-          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \
-          break;                                                               \
-        }                                                                      \
-        default:                                                               \
-          break;                                                               \
-      }                                                                        \
-    }                                                                          \
-  } else                                                                       \
-    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)                                \
-        : fail(::testing::internal::DeathTest::LastMessage())
-// The symbol "fail" here expands to something into which a message
-// can be streamed.
-
-// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
-// NDEBUG mode. In this case we need the statements to be executed and the macro
-// must accept a streamed message even though the message is never printed.
-// The regex object is not evaluated, but it is used to prevent "unused"
-// warnings and to avoid an expression that doesn't compile in debug mode.
-#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher)    \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                  \
-  if (::testing::internal::AlwaysTrue()) {                       \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);   \
-  } else if (!::testing::internal::AlwaysTrue()) {               \
-    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
-  } else                                                         \
-    ::testing::Message()
-
-// A class representing the parsed contents of the
-// --gtest_internal_run_death_test flag, as it existed when
-// RUN_ALL_TESTS was called.
-class InternalRunDeathTestFlag {
- public:
-  InternalRunDeathTestFlag(const std::string& a_file,
-                           int a_line,
-                           int an_index,
-                           int a_write_fd)
-      : file_(a_file), line_(a_line), index_(an_index),
-        write_fd_(a_write_fd) {}
-
-  ~InternalRunDeathTestFlag() {
-    if (write_fd_ >= 0)
-      posix::Close(write_fd_);
-  }
-
-  const std::string& file() const { return file_; }
-  int line() const { return line_; }
-  int index() const { return index_; }
-  int write_fd() const { return write_fd_; }
-
- private:
-  std::string file_;
-  int line_;
-  int index_;
-  int write_fd_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
-};
-
-// Returns a newly created InternalRunDeathTestFlag object with fields
-// initialized from the GTEST_FLAG(internal_run_death_test) flag if
-// the flag is specified; otherwise returns NULL.
-InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-
-namespace testing {
-
-// This flag controls the style of death tests.  Valid values are "threadsafe",
-// meaning that the death test child process will re-execute the test binary
-// from the start, running only a single death test, or "fast",
-// meaning that the child process will execute the test logic immediately
-// after forking.
-GTEST_DECLARE_string_(death_test_style);
-
-#if GTEST_HAS_DEATH_TEST
-
-namespace internal {
-
-// Returns a Boolean value indicating whether the caller is currently
-// executing in the context of the death test child process.  Tools such as
-// Valgrind heap checkers may need this to modify their behavior in death
-// tests.  IMPORTANT: This is an internal utility.  Using it may break the
-// implementation of death tests.  User code MUST NOT use it.
-GTEST_API_ bool InDeathTestChild();
-
-}  // namespace internal
-
-// The following macros are useful for writing death tests.
-
-// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
-// executed:
-//
-//   1. It generates a warning if there is more than one active
-//   thread.  This is because it's safe to fork() or clone() only
-//   when there is a single thread.
-//
-//   2. The parent process clone()s a sub-process and runs the death
-//   test in it; the sub-process exits with code 0 at the end of the
-//   death test, if it hasn't exited already.
-//
-//   3. The parent process waits for the sub-process to terminate.
-//
-//   4. The parent process checks the exit code and error message of
-//   the sub-process.
-//
-// Examples:
-//
-//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
-//   for (int i = 0; i < 5; i++) {
-//     EXPECT_DEATH(server.ProcessRequest(i),
-//                  "Invalid request .* in ProcessRequest()")
-//                  << "Failed to die on request " << i;
-//   }
-//
-//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
-//
-//   bool KilledBySIGHUP(int exit_code) {
-//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
-//   }
-//
-//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
-//
-// On the regular expressions used in death tests:
-//
-//   GOOGLETEST_CM0005 DO NOT DELETE
-//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
-//   which uses the POSIX extended regex syntax.
-//
-//   On other platforms (e.g. Windows or Mac), we only support a simple regex
-//   syntax implemented as part of Google Test.  This limited
-//   implementation should be enough most of the time when writing
-//   death tests; though it lacks many features you can find in PCRE
-//   or POSIX extended regex syntax.  For example, we don't support
-//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
-//   repetition count ("x{5,7}"), among others.
-//
-//   Below is the syntax that we do support.  We chose it to be a
-//   subset of both PCRE and POSIX extended regex, so it's easy to
-//   learn wherever you come from.  In the following: 'A' denotes a
-//   literal character, period (.), or a single \\ escape sequence;
-//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
-//   natural numbers.
-//
-//     c     matches any literal character c
-//     \\d   matches any decimal digit
-//     \\D   matches any character that's not a decimal digit
-//     \\f   matches \f
-//     \\n   matches \n
-//     \\r   matches \r
-//     \\s   matches any ASCII whitespace, including \n
-//     \\S   matches any character that's not a whitespace
-//     \\t   matches \t
-//     \\v   matches \v
-//     \\w   matches any letter, _, or decimal digit
-//     \\W   matches any character that \\w doesn't match
-//     \\c   matches any literal character c, which must be a punctuation
-//     .     matches any single character except \n
-//     A?    matches 0 or 1 occurrences of A
-//     A*    matches 0 or many occurrences of A
-//     A+    matches 1 or many occurrences of A
-//     ^     matches the beginning of a string (not that of each line)
-//     $     matches the end of a string (not that of each line)
-//     xy    matches x followed by y
-//
-//   If you accidentally use PCRE or POSIX extended regex features
-//   not implemented by us, you will get a run-time failure.  In that
-//   case, please try to rewrite your regular expression within the
-//   above syntax.
-//
-//   This implementation is *not* meant to be as highly tuned or robust
-//   as a compiled regex library, but should perform well enough for a
-//   death test, which already incurs significant overhead by launching
-//   a child process.
-//
-// Known caveats:
-//
-//   A "threadsafe" style death test obtains the path to the test
-//   program from argv[0] and re-executes it in the sub-process.  For
-//   simplicity, the current implementation doesn't search the PATH
-//   when launching the sub-process.  This means that the user must
-//   invoke the test program via a path that contains at least one
-//   path separator (e.g. path/to/foo_test and
-//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
-//   is rarely a problem as people usually don't put the test binary
-//   directory in PATH.
-//
-
-// Asserts that a given statement causes the program to exit, with an
-// integer exit status that satisfies predicate, and emitting error output
-// that matches regex.
-# define ASSERT_EXIT(statement, predicate, regex) \
-    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
-
-// Like ASSERT_EXIT, but continues on to successive tests in the
-// test suite, if any:
-# define EXPECT_EXIT(statement, predicate, regex) \
-    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
-
-// Asserts that a given statement causes the program to exit, either by
-// explicitly exiting with a nonzero exit code or being killed by a
-// signal, and emitting error output that matches regex.
-# define ASSERT_DEATH(statement, regex) \
-    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
-
-// Like ASSERT_DEATH, but continues on to successive tests in the
-// test suite, if any:
-# define EXPECT_DEATH(statement, regex) \
-    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
-
-// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
-
-// Tests that an exit code describes a normal exit with a given exit code.
-class GTEST_API_ ExitedWithCode {
- public:
-  explicit ExitedWithCode(int exit_code);
-  bool operator()(int exit_status) const;
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ExitedWithCode& other);
-
-  const int exit_code_;
-};
-
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
-// Tests that an exit code describes an exit due to termination by a
-// given signal.
-// GOOGLETEST_CM0006 DO NOT DELETE
-class GTEST_API_ KilledBySignal {
- public:
-  explicit KilledBySignal(int signum);
-  bool operator()(int exit_status) const;
- private:
-  const int signum_;
-};
-# endif  // !GTEST_OS_WINDOWS
-
-// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
-// The death testing framework causes this to have interesting semantics,
-// since the sideeffects of the call are only visible in opt mode, and not
-// in debug mode.
-//
-// In practice, this can be used to test functions that utilize the
-// LOG(DFATAL) macro using the following style:
-//
-// int DieInDebugOr12(int* sideeffect) {
-//   if (sideeffect) {
-//     *sideeffect = 12;
-//   }
-//   LOG(DFATAL) << "death";
-//   return 12;
-// }
-//
-// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) {
-//   int sideeffect = 0;
-//   // Only asserts in dbg.
-//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
-//
-// #ifdef NDEBUG
-//   // opt-mode has sideeffect visible.
-//   EXPECT_EQ(12, sideeffect);
-// #else
-//   // dbg-mode no visible sideeffect.
-//   EXPECT_EQ(0, sideeffect);
-// #endif
-// }
-//
-// This will assert that DieInDebugReturn12InOpt() crashes in debug
-// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
-// appropriate fallback value (12 in this case) in opt mode. If you
-// need to test that a function has appropriate side-effects in opt
-// mode, include assertions against the side-effects.  A general
-// pattern for this is:
-//
-// EXPECT_DEBUG_DEATH({
-//   // Side-effects here will have an effect after this statement in
-//   // opt mode, but none in debug mode.
-//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
-// }, "death");
-//
-# ifdef NDEBUG
-
-#  define EXPECT_DEBUG_DEATH(statement, regex) \
-  GTEST_EXECUTE_STATEMENT_(statement, regex)
-
-#  define ASSERT_DEBUG_DEATH(statement, regex) \
-  GTEST_EXECUTE_STATEMENT_(statement, regex)
-
-# else
-
-#  define EXPECT_DEBUG_DEATH(statement, regex) \
-  EXPECT_DEATH(statement, regex)
-
-#  define ASSERT_DEBUG_DEATH(statement, regex) \
-  ASSERT_DEATH(statement, regex)
-
-# endif  // NDEBUG for EXPECT_DEBUG_DEATH
-#endif  // GTEST_HAS_DEATH_TEST
-
-// This macro is used for implementing macros such as
-// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
-// death tests are not supported. Those macros must compile on such systems
-// iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on
-// systems that support death tests. This allows one to write such a macro
-// on a system that does not support death tests and be sure that it will
-// compile on a death-test supporting system. It is exposed publicly so that
-// systems that have death-tests with stricter requirements than
-// GTEST_HAS_DEATH_TEST can write their own equivalent of
-// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED.
-//
-// Parameters:
-//   statement -  A statement that a macro such as EXPECT_DEATH would test
-//                for program termination. This macro has to make sure this
-//                statement is compiled but not executed, to ensure that
-//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
-//                parameter iff EXPECT_DEATH compiles with it.
-//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
-//                the output of statement.  This parameter has to be
-//                compiled but not evaluated by this macro, to ensure that
-//                this macro only accepts expressions that a macro such as
-//                EXPECT_DEATH would accept.
-//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
-//                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
-//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
-//                compile inside functions where ASSERT_DEATH doesn't
-//                compile.
-//
-//  The branch that has an always false condition is used to ensure that
-//  statement and regex are compiled (and thus syntactically correct) but
-//  never executed. The unreachable code macro protects the terminator
-//  statement from generating an 'unreachable code' warning in case
-//  statement unconditionally returns or throws. The Message constructor at
-//  the end allows the syntax of streaming additional messages into the
-//  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
-# define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \
-    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-    if (::testing::internal::AlwaysTrue()) { \
-      GTEST_LOG_(WARNING) \
-          << "Death tests are not supported on this platform.\n" \
-          << "Statement '" #statement "' cannot be verified."; \
-    } else if (::testing::internal::AlwaysFalse()) { \
-      ::testing::internal::RE::PartialMatch(".*", (regex)); \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-      terminator; \
-    } else \
-      ::testing::Message()
-
-// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
-// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
-// death tests are supported; otherwise they just issue a warning.  This is
-// useful when you are combining death test assertions with normal test
-// assertions in one test.
-#if GTEST_HAS_DEATH_TEST
-# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    EXPECT_DEATH(statement, regex)
-# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    ASSERT_DEATH(statement, regex)
-#else
-# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
-# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
-#endif
-
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-// Copyright 2008, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Macros and functions for implementing parameterized tests
-// in Google C++ Testing and Mocking Framework (Google Test)
-//
-// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-// GOOGLETEST_CM0001 DO NOT DELETE
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-
-
-// Value-parameterized tests allow you to test your code with different
-// parameters without writing multiple copies of the same test.
-//
-// Here is how you use value-parameterized tests:
-
-#if 0
-
-// To write value-parameterized tests, first you should define a fixture
-// class. It is usually derived from testing::TestWithParam<T> (see below for
-// another inheritance scheme that's sometimes useful in more complicated
-// class hierarchies), where the type of your parameter values.
-// TestWithParam<T> is itself derived from testing::Test. T can be any
-// copyable type. If it's a raw pointer, you are responsible for managing the
-// lifespan of the pointed values.
-
-class FooTest : public ::testing::TestWithParam<const char*> {
-  // You can implement all the usual class fixture members here.
-};
-
-// Then, use the TEST_P macro to define as many parameterized tests
-// for this fixture as you want. The _P suffix is for "parameterized"
-// or "pattern", whichever you prefer to think.
-
-TEST_P(FooTest, DoesBlah) {
-  // Inside a test, access the test parameter with the GetParam() method
-  // of the TestWithParam<T> class:
-  EXPECT_TRUE(foo.Blah(GetParam()));
-  ...
-}
-
-TEST_P(FooTest, HasBlahBlah) {
-  ...
-}
-
-// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test
-// case with any set of parameters you want. Google Test defines a number
-// of functions for generating test parameters. They return what we call
-// (surprise!) parameter generators. Here is a summary of them, which
-// are all in the testing namespace:
-//
-//
-//  Range(begin, end [, step]) - Yields values {begin, begin+step,
-//                               begin+step+step, ...}. The values do not
-//                               include end. step defaults to 1.
-//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
-//  ValuesIn(container)        - Yields values from a C-style array, an STL
-//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
-//  Bool()                     - Yields sequence {false, true}.
-//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
-//                               for the math savvy) of the values generated
-//                               by the N generators.
-//
-// For more details, see comments at the definitions of these functions below
-// in this file.
-//
-// The following statement will instantiate tests from the FooTest test suite
-// each with parameter values "meeny", "miny", and "moe".
-
-INSTANTIATE_TEST_SUITE_P(InstantiationName,
-                         FooTest,
-                         Values("meeny", "miny", "moe"));
-
-// To distinguish different instances of the pattern, (yes, you
-// can instantiate it more than once) the first argument to the
-// INSTANTIATE_TEST_SUITE_P macro is a prefix that will be added to the
-// actual test suite name. Remember to pick unique prefixes for different
-// instantiations. The tests from the instantiation above will have
-// these names:
-//
-//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
-//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
-//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
-//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
-//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
-//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
-//
-// You can use these names in --gtest_filter.
-//
-// This statement will instantiate all tests from FooTest again, each
-// with parameter values "cat" and "dog":
-
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
-
-// The tests from the instantiation above will have these names:
-//
-//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
-//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
-//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
-//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
-//
-// Please note that INSTANTIATE_TEST_SUITE_P will instantiate all tests
-// in the given test suite, whether their definitions come before or
-// AFTER the INSTANTIATE_TEST_SUITE_P statement.
-//
-// Please also note that generator expressions (including parameters to the
-// generators) are evaluated in InitGoogleTest(), after main() has started.
-// This allows the user on one hand, to adjust generator parameters in order
-// to dynamically determine a set of tests to run and on the other hand,
-// give the user a chance to inspect the generated tests with Google Test
-// reflection API before RUN_ALL_TESTS() is executed.
-//
-// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
-// for more examples.
-//
-// In the future, we plan to publish the API for defining new parameter
-// generators. But for now this interface remains part of the internal
-// implementation and is subject to change.
-//
-//
-// A parameterized test fixture must be derived from testing::Test and from
-// testing::WithParamInterface<T>, where T is the type of the parameter
-// values. Inheriting from TestWithParam<T> satisfies that requirement because
-// TestWithParam<T> inherits from both Test and WithParamInterface. In more
-// complicated hierarchies, however, it is occasionally useful to inherit
-// separately from Test and WithParamInterface. For example:
-
-class BaseTest : public ::testing::Test {
-  // You can inherit all the usual members for a non-parameterized test
-  // fixture here.
-};
-
-class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
-  // The usual test fixture members go here too.
-};
-
-TEST_F(BaseTest, HasFoo) {
-  // This is an ordinary non-parameterized test.
-}
-
-TEST_P(DerivedTest, DoesBlah) {
-  // GetParam works just the same here as if you inherit from TestWithParam.
-  EXPECT_TRUE(foo.Blah(GetParam()));
-}
-
-#endif  // 0
-
-#include <utility>
-
-// Copyright 2008 Google Inc.
-// All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-// Type and function utilities for implementing parameterized tests.
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-
-#include <ctype.h>
-
-#include <cassert>
-#include <iterator>
-#include <memory>
-#include <set>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-
-namespace testing {
-// Input to a parameterized test name generator, describing a test parameter.
-// Consists of the parameter value and the integer parameter index.
-template <class ParamType>
-struct TestParamInfo {
-  TestParamInfo(const ParamType& a_param, size_t an_index) :
-    param(a_param),
-    index(an_index) {}
-  ParamType param;
-  size_t index;
-};
-
-// A builtin parameterized test name generator which returns the result of
-// testing::PrintToString.
-struct PrintToStringParamName {
-  template <class ParamType>
-  std::string operator()(const TestParamInfo<ParamType>& info) const {
-    return PrintToString(info.param);
-  }
-};
-
-namespace internal {
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-// Utility Functions
-
-// Outputs a message explaining invalid registration of different
-// fixture class for the same test suite. This may happen when
-// TEST_P macro is used to define two tests with the same name
-// but in different namespaces.
-GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
-                                           CodeLocation code_location);
-
-template <typename> class ParamGeneratorInterface;
-template <typename> class ParamGenerator;
-
-// Interface for iterating over elements provided by an implementation
-// of ParamGeneratorInterface<T>.
-template <typename T>
-class ParamIteratorInterface {
- public:
-  virtual ~ParamIteratorInterface() {}
-  // A pointer to the base generator instance.
-  // Used only for the purposes of iterator comparison
-  // to make sure that two iterators belong to the same generator.
-  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
-  // Advances iterator to point to the next element
-  // provided by the generator. The caller is responsible
-  // for not calling Advance() on an iterator equal to
-  // BaseGenerator()->End().
-  virtual void Advance() = 0;
-  // Clones the iterator object. Used for implementing copy semantics
-  // of ParamIterator<T>.
-  virtual ParamIteratorInterface* Clone() const = 0;
-  // Dereferences the current iterator and provides (read-only) access
-  // to the pointed value. It is the caller's responsibility not to call
-  // Current() on an iterator equal to BaseGenerator()->End().
-  // Used for implementing ParamGenerator<T>::operator*().
-  virtual const T* Current() const = 0;
-  // Determines whether the given iterator and other point to the same
-  // element in the sequence generated by the generator.
-  // Used for implementing ParamGenerator<T>::operator==().
-  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
-};
-
-// Class iterating over elements provided by an implementation of
-// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
-// and implements the const forward iterator concept.
-template <typename T>
-class ParamIterator {
- public:
-  typedef T value_type;
-  typedef const T& reference;
-  typedef ptrdiff_t difference_type;
-
-  // ParamIterator assumes ownership of the impl_ pointer.
-  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
-  ParamIterator& operator=(const ParamIterator& other) {
-    if (this != &other)
-      impl_.reset(other.impl_->Clone());
-    return *this;
-  }
-
-  const T& operator*() const { return *impl_->Current(); }
-  const T* operator->() const { return impl_->Current(); }
-  // Prefix version of operator++.
-  ParamIterator& operator++() {
-    impl_->Advance();
-    return *this;
-  }
-  // Postfix version of operator++.
-  ParamIterator operator++(int /*unused*/) {
-    ParamIteratorInterface<T>* clone = impl_->Clone();
-    impl_->Advance();
-    return ParamIterator(clone);
-  }
-  bool operator==(const ParamIterator& other) const {
-    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
-  }
-  bool operator!=(const ParamIterator& other) const {
-    return !(*this == other);
-  }
-
- private:
-  friend class ParamGenerator<T>;
-  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
-  std::unique_ptr<ParamIteratorInterface<T> > impl_;
-};
-
-// ParamGeneratorInterface<T> is the binary interface to access generators
-// defined in other translation units.
-template <typename T>
-class ParamGeneratorInterface {
- public:
-  typedef T ParamType;
-
-  virtual ~ParamGeneratorInterface() {}
-
-  // Generator interface definition
-  virtual ParamIteratorInterface<T>* Begin() const = 0;
-  virtual ParamIteratorInterface<T>* End() const = 0;
-};
-
-// Wraps ParamGeneratorInterface<T> and provides general generator syntax
-// compatible with the STL Container concept.
-// This class implements copy initialization semantics and the contained
-// ParamGeneratorInterface<T> instance is shared among all copies
-// of the original object. This is possible because that instance is immutable.
-template<typename T>
-class ParamGenerator {
- public:
-  typedef ParamIterator<T> iterator;
-
-  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
-  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
-
-  ParamGenerator& operator=(const ParamGenerator& other) {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  iterator begin() const { return iterator(impl_->Begin()); }
-  iterator end() const { return iterator(impl_->End()); }
-
- private:
-  std::shared_ptr<const ParamGeneratorInterface<T> > impl_;
-};
-
-// Generates values from a range of two comparable values. Can be used to
-// generate sequences of user-defined types that implement operator+() and
-// operator<().
-// This class is used in the Range() function.
-template <typename T, typename IncrementT>
-class RangeGenerator : public ParamGeneratorInterface<T> {
- public:
-  RangeGenerator(T begin, T end, IncrementT step)
-      : begin_(begin), end_(end),
-        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
-  ~RangeGenerator() override {}
-
-  ParamIteratorInterface<T>* Begin() const override {
-    return new Iterator(this, begin_, 0, step_);
-  }
-  ParamIteratorInterface<T>* End() const override {
-    return new Iterator(this, end_, end_index_, step_);
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<T> {
-   public:
-    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
-             IncrementT step)
-        : base_(base), value_(value), index_(index), step_(step) {}
-    ~Iterator() override {}
-
-    const ParamGeneratorInterface<T>* BaseGenerator() const override {
-      return base_;
-    }
-    void Advance() override {
-      value_ = static_cast<T>(value_ + step_);
-      index_++;
-    }
-    ParamIteratorInterface<T>* Clone() const override {
-      return new Iterator(*this);
-    }
-    const T* Current() const override { return &value_; }
-    bool Equals(const ParamIteratorInterface<T>& other) const override {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const int other_index =
-          CheckedDowncastToActualType<const Iterator>(&other)->index_;
-      return index_ == other_index;
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : ParamIteratorInterface<T>(),
-          base_(other.base_), value_(other.value_), index_(other.index_),
-          step_(other.step_) {}
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<T>* const base_;
-    T value_;
-    int index_;
-    const IncrementT step_;
-  };  // class RangeGenerator::Iterator
-
-  static int CalculateEndIndex(const T& begin,
-                               const T& end,
-                               const IncrementT& step) {
-    int end_index = 0;
-    for (T i = begin; i < end; i = static_cast<T>(i + step))
-      end_index++;
-    return end_index;
-  }
-
-  // No implementation - assignment is unsupported.
-  void operator=(const RangeGenerator& other);
-
-  const T begin_;
-  const T end_;
-  const IncrementT step_;
-  // The index for the end() iterator. All the elements in the generated
-  // sequence are indexed (0-based) to aid iterator comparison.
-  const int end_index_;
-};  // class RangeGenerator
-
-
-// Generates values from a pair of STL-style iterators. Used in the
-// ValuesIn() function. The elements are copied from the source range
-// since the source can be located on the stack, and the generator
-// is likely to persist beyond that stack frame.
-template <typename T>
-class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
- public:
-  template <typename ForwardIterator>
-  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
-      : container_(begin, end) {}
-  ~ValuesInIteratorRangeGenerator() override {}
-
-  ParamIteratorInterface<T>* Begin() const override {
-    return new Iterator(this, container_.begin());
-  }
-  ParamIteratorInterface<T>* End() const override {
-    return new Iterator(this, container_.end());
-  }
-
- private:
-  typedef typename ::std::vector<T> ContainerType;
-
-  class Iterator : public ParamIteratorInterface<T> {
-   public:
-    Iterator(const ParamGeneratorInterface<T>* base,
-             typename ContainerType::const_iterator iterator)
-        : base_(base), iterator_(iterator) {}
-    ~Iterator() override {}
-
-    const ParamGeneratorInterface<T>* BaseGenerator() const override {
-      return base_;
-    }
-    void Advance() override {
-      ++iterator_;
-      value_.reset();
-    }
-    ParamIteratorInterface<T>* Clone() const override {
-      return new Iterator(*this);
-    }
-    // We need to use cached value referenced by iterator_ because *iterator_
-    // can return a temporary object (and of type other then T), so just
-    // having "return &*iterator_;" doesn't work.
-    // value_ is updated here and not in Advance() because Advance()
-    // can advance iterator_ beyond the end of the range, and we cannot
-    // detect that fact. The client code, on the other hand, is
-    // responsible for not calling Current() on an out-of-range iterator.
-    const T* Current() const override {
-      if (value_.get() == nullptr) value_.reset(new T(*iterator_));
-      return value_.get();
-    }
-    bool Equals(const ParamIteratorInterface<T>& other) const override {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      return iterator_ ==
-          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
-    }
-
-   private:
-    Iterator(const Iterator& other)
-          // The explicit constructor call suppresses a false warning
-          // emitted by gcc when supplied with the -Wextra option.
-        : ParamIteratorInterface<T>(),
-          base_(other.base_),
-          iterator_(other.iterator_) {}
-
-    const ParamGeneratorInterface<T>* const base_;
-    typename ContainerType::const_iterator iterator_;
-    // A cached value of *iterator_. We keep it here to allow access by
-    // pointer in the wrapping iterator's operator->().
-    // value_ needs to be mutable to be accessed in Current().
-    // Use of std::unique_ptr helps manage cached value's lifetime,
-    // which is bound by the lifespan of the iterator itself.
-    mutable std::unique_ptr<const T> value_;
-  };  // class ValuesInIteratorRangeGenerator::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const ValuesInIteratorRangeGenerator& other);
-
-  const ContainerType container_;
-};  // class ValuesInIteratorRangeGenerator
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Default parameterized test name generator, returns a string containing the
-// integer test parameter index.
-template <class ParamType>
-std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
-  Message name_stream;
-  name_stream << info.index;
-  return name_stream.GetString();
-}
-
-template <typename T = int>
-void TestNotEmpty() {
-  static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
-}
-template <typename T = int>
-void TestNotEmpty(const T&) {}
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Stores a parameter value and later creates tests parameterized with that
-// value.
-template <class TestClass>
-class ParameterizedTestFactory : public TestFactoryBase {
- public:
-  typedef typename TestClass::ParamType ParamType;
-  explicit ParameterizedTestFactory(ParamType parameter) :
-      parameter_(parameter) {}
-  Test* CreateTest() override {
-    TestClass::SetParam(&parameter_);
-    return new TestClass();
-  }
-
- private:
-  const ParamType parameter_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// TestMetaFactoryBase is a base class for meta-factories that create
-// test factories for passing into MakeAndRegisterTestInfo function.
-template <class ParamType>
-class TestMetaFactoryBase {
- public:
-  virtual ~TestMetaFactoryBase() {}
-
-  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// TestMetaFactory creates test factories for passing into
-// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
-// ownership of test factory pointer, same factory object cannot be passed
-// into that method twice. But ParameterizedTestSuiteInfo is going to call
-// it for each Test/Parameter value combination. Thus it needs meta factory
-// creator class.
-template <class TestSuite>
-class TestMetaFactory
-    : public TestMetaFactoryBase<typename TestSuite::ParamType> {
- public:
-  using ParamType = typename TestSuite::ParamType;
-
-  TestMetaFactory() {}
-
-  TestFactoryBase* CreateTestFactory(ParamType parameter) override {
-    return new ParameterizedTestFactory<TestSuite>(parameter);
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestSuiteInfoBase is a generic interface
-// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
-// accumulates test information provided by TEST_P macro invocations
-// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
-// and uses that information to register all resulting test instances
-// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
-// a collection of pointers to the ParameterizedTestSuiteInfo objects
-// and calls RegisterTests() on each of them when asked.
-class ParameterizedTestSuiteInfoBase {
- public:
-  virtual ~ParameterizedTestSuiteInfoBase() {}
-
-  // Base part of test suite name for display purposes.
-  virtual const std::string& GetTestSuiteName() const = 0;
-  // Test case id to verify identity.
-  virtual TypeId GetTestSuiteTypeId() const = 0;
-  // UnitTest class invokes this method to register tests in this
-  // test suite right before running them in RUN_ALL_TESTS macro.
-  // This method should not be called more than once on any single
-  // instance of a ParameterizedTestSuiteInfoBase derived class.
-  virtual void RegisterTests() = 0;
-
- protected:
-  ParameterizedTestSuiteInfoBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
-// macro invocations for a particular test suite and generators
-// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
-// test suite. It registers tests with all values generated by all
-// generators when asked.
-template <class TestSuite>
-class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
- public:
-  // ParamType and GeneratorCreationFunc are private types but are required
-  // for declarations of public methods AddTestPattern() and
-  // AddTestSuiteInstantiation().
-  using ParamType = typename TestSuite::ParamType;
-  // A function that returns an instance of appropriate generator type.
-  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
-  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);
-
-  explicit ParameterizedTestSuiteInfo(const char* name,
-                                      CodeLocation code_location)
-      : test_suite_name_(name), code_location_(code_location) {}
-
-  // Test case base name for display purposes.
-  const std::string& GetTestSuiteName() const override {
-    return test_suite_name_;
-  }
-  // Test case id to verify identity.
-  TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); }
-  // TEST_P macro uses AddTestPattern() to record information
-  // about a single test in a LocalTestInfo structure.
-  // test_suite_name is the base name of the test suite (without invocation
-  // prefix). test_base_name is the name of an individual test without
-  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
-  // test suite base name and DoBar is test base name.
-  void AddTestPattern(const char* test_suite_name, const char* test_base_name,
-                      TestMetaFactoryBase<ParamType>* meta_factory) {
-    tests_.push_back(std::shared_ptr<TestInfo>(
-        new TestInfo(test_suite_name, test_base_name, meta_factory)));
-  }
-  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
-  // about a generator.
-  int AddTestSuiteInstantiation(const std::string& instantiation_name,
-                                GeneratorCreationFunc* func,
-                                ParamNameGeneratorFunc* name_func,
-                                const char* file, int line) {
-    instantiations_.push_back(
-        InstantiationInfo(instantiation_name, func, name_func, file, line));
-    return 0;  // Return value used only to run this method in namespace scope.
-  }
-  // UnitTest class invokes this method to register tests in this test suite
-  // test suites right before running tests in RUN_ALL_TESTS macro.
-  // This method should not be called more than once on any single
-  // instance of a ParameterizedTestSuiteInfoBase derived class.
-  // UnitTest has a guard to prevent from calling this method more than once.
-  void RegisterTests() override {
-    for (typename TestInfoContainer::iterator test_it = tests_.begin();
-         test_it != tests_.end(); ++test_it) {
-      std::shared_ptr<TestInfo> test_info = *test_it;
-      for (typename InstantiationContainer::iterator gen_it =
-               instantiations_.begin(); gen_it != instantiations_.end();
-               ++gen_it) {
-        const std::string& instantiation_name = gen_it->name;
-        ParamGenerator<ParamType> generator((*gen_it->generator)());
-        ParamNameGeneratorFunc* name_func = gen_it->name_func;
-        const char* file = gen_it->file;
-        int line = gen_it->line;
-
-        std::string test_suite_name;
-        if ( !instantiation_name.empty() )
-          test_suite_name = instantiation_name + "/";
-        test_suite_name += test_info->test_suite_base_name;
-
-        size_t i = 0;
-        std::set<std::string> test_param_names;
-        for (typename ParamGenerator<ParamType>::iterator param_it =
-                 generator.begin();
-             param_it != generator.end(); ++param_it, ++i) {
-          Message test_name_stream;
-
-          std::string param_name = name_func(
-              TestParamInfo<ParamType>(*param_it, i));
-
-          GTEST_CHECK_(IsValidParamName(param_name))
-              << "Parameterized test name '" << param_name
-              << "' is invalid, in " << file
-              << " line " << line << std::endl;
-
-          GTEST_CHECK_(test_param_names.count(param_name) == 0)
-              << "Duplicate parameterized test name '" << param_name
-              << "', in " << file << " line " << line << std::endl;
-
-          test_param_names.insert(param_name);
-
-          test_name_stream << test_info->test_base_name << "/" << param_name;
-          MakeAndRegisterTestInfo(
-              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
-              nullptr,  // No type parameter.
-              PrintToString(*param_it).c_str(), code_location_,
-              GetTestSuiteTypeId(),
-              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(),
-              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(),
-              test_info->test_meta_factory->CreateTestFactory(*param_it));
-        }  // for param_it
-      }  // for gen_it
-    }  // for test_it
-  }    // RegisterTests
-
- private:
-  // LocalTestInfo structure keeps information about a single test registered
-  // with TEST_P macro.
-  struct TestInfo {
-    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
-             TestMetaFactoryBase<ParamType>* a_test_meta_factory)
-        : test_suite_base_name(a_test_suite_base_name),
-          test_base_name(a_test_base_name),
-          test_meta_factory(a_test_meta_factory) {}
-
-    const std::string test_suite_base_name;
-    const std::string test_base_name;
-    const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
-  };
-  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
-  // Records data received from INSTANTIATE_TEST_SUITE_P macros:
-  //  <Instantiation name, Sequence generator creation function,
-  //     Name generator function, Source file, Source line>
-  struct InstantiationInfo {
-      InstantiationInfo(const std::string &name_in,
-                        GeneratorCreationFunc* generator_in,
-                        ParamNameGeneratorFunc* name_func_in,
-                        const char* file_in,
-                        int line_in)
-          : name(name_in),
-            generator(generator_in),
-            name_func(name_func_in),
-            file(file_in),
-            line(line_in) {}
-
-      std::string name;
-      GeneratorCreationFunc* generator;
-      ParamNameGeneratorFunc* name_func;
-      const char* file;
-      int line;
-  };
-  typedef ::std::vector<InstantiationInfo> InstantiationContainer;
-
-  static bool IsValidParamName(const std::string& name) {
-    // Check for empty string
-    if (name.empty())
-      return false;
-
-    // Check for invalid characters
-    for (std::string::size_type index = 0; index < name.size(); ++index) {
-      if (!isalnum(name[index]) && name[index] != '_')
-        return false;
-    }
-
-    return true;
-  }
-
-  const std::string test_suite_name_;
-  CodeLocation code_location_;
-  TestInfoContainer tests_;
-  InstantiationContainer instantiations_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
-};  // class ParameterizedTestSuiteInfo
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-template <class TestCase>
-using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestSuiteRegistry contains a map of
-// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
-// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
-// ParameterizedTestSuiteInfo descriptors.
-class ParameterizedTestSuiteRegistry {
- public:
-  ParameterizedTestSuiteRegistry() {}
-  ~ParameterizedTestSuiteRegistry() {
-    for (auto& test_suite_info : test_suite_infos_) {
-      delete test_suite_info;
-    }
-  }
-
-  // Looks up or creates and returns a structure containing information about
-  // tests and instantiations of a particular test suite.
-  template <class TestSuite>
-  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
-      const char* test_suite_name, CodeLocation code_location) {
-    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
-    for (auto& test_suite_info : test_suite_infos_) {
-      if (test_suite_info->GetTestSuiteName() == test_suite_name) {
-        if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
-          // Complain about incorrect usage of Google Test facilities
-          // and terminate the program since we cannot guaranty correct
-          // test suite setup and tear-down in this case.
-          ReportInvalidTestSuiteType(test_suite_name, code_location);
-          posix::Abort();
-        } else {
-          // At this point we are sure that the object we found is of the same
-          // type we are looking for, so we downcast it to that type
-          // without further checks.
-          typed_test_info = CheckedDowncastToActualType<
-              ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info);
-        }
-        break;
-      }
-    }
-    if (typed_test_info == nullptr) {
-      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
-          test_suite_name, code_location);
-      test_suite_infos_.push_back(typed_test_info);
-    }
-    return typed_test_info;
-  }
-  void RegisterTests() {
-    for (auto& test_suite_info : test_suite_infos_) {
-      test_suite_info->RegisterTests();
-    }
-  }
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  template <class TestCase>
-  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
-      const char* test_case_name, CodeLocation code_location) {
-    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
-  }
-
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
- private:
-  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
-
-  TestSuiteInfoContainer test_suite_infos_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
-};
-
-}  // namespace internal
-
-// Forward declarations of ValuesIn(), which is implemented in
-// include/gtest/gtest-param-test.h.
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container);
-
-namespace internal {
-// Used in the Values() function to provide polymorphic capabilities.
-
-template <typename... Ts>
-class ValueArray {
- public:
-  ValueArray(Ts... v) : v_{std::move(v)...} {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {  // NOLINT
-    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
-  }
-
- private:
-  template <typename T, size_t... I>
-  std::vector<T> MakeVector(IndexSequence<I...>) const {
-    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
-  }
-
-  FlatTuple<Ts...> v_;
-};
-
-template <typename... T>
-class CartesianProductGenerator
-    : public ParamGeneratorInterface<::std::tuple<T...>> {
- public:
-  typedef ::std::tuple<T...> ParamType;
-
-  CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
-      : generators_(g) {}
-  ~CartesianProductGenerator() override {}
-
-  ParamIteratorInterface<ParamType>* Begin() const override {
-    return new Iterator(this, generators_, false);
-  }
-  ParamIteratorInterface<ParamType>* End() const override {
-    return new Iterator(this, generators_, true);
-  }
-
- private:
-  template <class I>
-  class IteratorImpl;
-  template <size_t... I>
-  class IteratorImpl<IndexSequence<I...>>
-      : public ParamIteratorInterface<ParamType> {
-   public:
-    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
-             const std::tuple<ParamGenerator<T>...>& generators, bool is_end)
-        : base_(base),
-          begin_(std::get<I>(generators).begin()...),
-          end_(std::get<I>(generators).end()...),
-          current_(is_end ? end_ : begin_) {
-      ComputeCurrentValue();
-    }
-    ~IteratorImpl() override {}
-
-    const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    void Advance() override {
-      assert(!AtEnd());
-      // Advance the last iterator.
-      ++std::get<sizeof...(T) - 1>(current_);
-      // if that reaches end, propagate that up.
-      AdvanceIfEnd<sizeof...(T) - 1>();
-      ComputeCurrentValue();
-    }
-    ParamIteratorInterface<ParamType>* Clone() const override {
-      return new IteratorImpl(*this);
-    }
-
-    const ParamType* Current() const override { return current_value_.get(); }
-
-    bool Equals(const ParamIteratorInterface<ParamType>& other) const override {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const IteratorImpl* typed_other =
-          CheckedDowncastToActualType<const IteratorImpl>(&other);
-
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      if (AtEnd() && typed_other->AtEnd()) return true;
-
-      bool same = true;
-      bool dummy[] = {
-          (same = same && std::get<I>(current_) ==
-                              std::get<I>(typed_other->current_))...};
-      (void)dummy;
-      return same;
-    }
-
-   private:
-    template <size_t ThisI>
-    void AdvanceIfEnd() {
-      if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;
-
-      bool last = ThisI == 0;
-      if (last) {
-        // We are done. Nothing else to propagate.
-        return;
-      }
-
-      constexpr size_t NextI = ThisI - (ThisI != 0);
-      std::get<ThisI>(current_) = std::get<ThisI>(begin_);
-      ++std::get<NextI>(current_);
-      AdvanceIfEnd<NextI>();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
-    }
-    bool AtEnd() const {
-      bool at_end = false;
-      bool dummy[] = {
-          (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
-      (void)dummy;
-      return at_end;
-    }
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    std::tuple<typename ParamGenerator<T>::iterator...> begin_;
-    std::tuple<typename ParamGenerator<T>::iterator...> end_;
-    std::tuple<typename ParamGenerator<T>::iterator...> current_;
-    std::shared_ptr<ParamType> current_value_;
-  };
-
-  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;
-
-  std::tuple<ParamGenerator<T>...> generators_;
-};
-
-template <class... Gen>
-class CartesianProductHolder {
- public:
-  CartesianProductHolder(const Gen&... g) : generators_(g...) {}
-  template <typename... T>
-  operator ParamGenerator<::std::tuple<T...>>() const {
-    return ParamGenerator<::std::tuple<T...>>(
-        new CartesianProductGenerator<T...>(generators_));
-  }
-
- private:
-  std::tuple<Gen...> generators_;
-};
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-
-namespace testing {
-
-// Functions producing parameter generators.
-//
-// Google Test uses these generators to produce parameters for value-
-// parameterized tests. When a parameterized test suite is instantiated
-// with a particular generator, Google Test creates and runs tests
-// for each element in the sequence produced by the generator.
-//
-// In the following sample, tests from test suite FooTest are instantiated
-// each three times with parameter values 3, 5, and 8:
-//
-// class FooTest : public TestWithParam<int> { ... };
-//
-// TEST_P(FooTest, TestThis) {
-// }
-// TEST_P(FooTest, TestThat) {
-// }
-// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8));
-//
-
-// Range() returns generators providing sequences of values in a range.
-//
-// Synopsis:
-// Range(start, end)
-//   - returns a generator producing a sequence of values {start, start+1,
-//     start+2, ..., }.
-// Range(start, end, step)
-//   - returns a generator producing a sequence of values {start, start+step,
-//     start+step+step, ..., }.
-// Notes:
-//   * The generated sequences never include end. For example, Range(1, 5)
-//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
-//     returns a generator producing {1, 3, 5, 7}.
-//   * start and end must have the same type. That type may be any integral or
-//     floating-point type or a user defined type satisfying these conditions:
-//     * It must be assignable (have operator=() defined).
-//     * It must have operator+() (operator+(int-compatible type) for
-//       two-operand version).
-//     * It must have operator<() defined.
-//     Elements in the resulting sequences will also have that type.
-//   * Condition start < end must be satisfied in order for resulting sequences
-//     to contain any elements.
-//
-template <typename T, typename IncrementT>
-internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
-  return internal::ParamGenerator<T>(
-      new internal::RangeGenerator<T, IncrementT>(start, end, step));
-}
-
-template <typename T>
-internal::ParamGenerator<T> Range(T start, T end) {
-  return Range(start, end, 1);
-}
-
-// ValuesIn() function allows generation of tests with parameters coming from
-// a container.
-//
-// Synopsis:
-// ValuesIn(const T (&array)[N])
-//   - returns a generator producing sequences with elements from
-//     a C-style array.
-// ValuesIn(const Container& container)
-//   - returns a generator producing sequences with elements from
-//     an STL-style container.
-// ValuesIn(Iterator begin, Iterator end)
-//   - returns a generator producing sequences with elements from
-//     a range [begin, end) defined by a pair of STL-style iterators. These
-//     iterators can also be plain C pointers.
-//
-// Please note that ValuesIn copies the values from the containers
-// passed in and keeps them to generate tests in RUN_ALL_TESTS().
-//
-// Examples:
-//
-// This instantiates tests from test suite StringTest
-// each with C-string values of "foo", "bar", and "baz":
-//
-// const char* strings[] = {"foo", "bar", "baz"};
-// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest, ValuesIn(strings));
-//
-// This instantiates tests from test suite StlStringTest
-// each with STL strings with values "a" and "b":
-//
-// ::std::vector< ::std::string> GetParameterStrings() {
-//   ::std::vector< ::std::string> v;
-//   v.push_back("a");
-//   v.push_back("b");
-//   return v;
-// }
-//
-// INSTANTIATE_TEST_SUITE_P(CharSequence,
-//                          StlStringTest,
-//                          ValuesIn(GetParameterStrings()));
-//
-//
-// This will also instantiate tests from CharTest
-// each with parameter values 'a' and 'b':
-//
-// ::std::list<char> GetParameterChars() {
-//   ::std::list<char> list;
-//   list.push_back('a');
-//   list.push_back('b');
-//   return list;
-// }
-// ::std::list<char> l = GetParameterChars();
-// INSTANTIATE_TEST_SUITE_P(CharSequence2,
-//                          CharTest,
-//                          ValuesIn(l.begin(), l.end()));
-//
-template <typename ForwardIterator>
-internal::ParamGenerator<
-  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
-ValuesIn(ForwardIterator begin, ForwardIterator end) {
-  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
-      ::value_type ParamType;
-  return internal::ParamGenerator<ParamType>(
-      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
-}
-
-template <typename T, size_t N>
-internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
-  return ValuesIn(array, array + N);
-}
-
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container) {
-  return ValuesIn(container.begin(), container.end());
-}
-
-// Values() allows generating tests from explicitly specified list of
-// parameters.
-//
-// Synopsis:
-// Values(T v1, T v2, ..., T vN)
-//   - returns a generator producing sequences with elements v1, v2, ..., vN.
-//
-// For example, this instantiates tests from test suite BarTest each
-// with values "one", "two", and "three":
-//
-// INSTANTIATE_TEST_SUITE_P(NumSequence,
-//                          BarTest,
-//                          Values("one", "two", "three"));
-//
-// This instantiates tests from test suite BazTest each with values 1, 2, 3.5.
-// The exact type of values will depend on the type of parameter in BazTest.
-//
-// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
-//
-//
-template <typename... T>
-internal::ValueArray<T...> Values(T... v) {
-  return internal::ValueArray<T...>(std::move(v)...);
-}
-
-// Bool() allows generating tests with parameters in a set of (false, true).
-//
-// Synopsis:
-// Bool()
-//   - returns a generator producing sequences with elements {false, true}.
-//
-// It is useful when testing code that depends on Boolean flags. Combinations
-// of multiple flags can be tested when several Bool()'s are combined using
-// Combine() function.
-//
-// In the following example all tests in the test suite FlagDependentTest
-// will be instantiated twice with parameters false and true.
-//
-// class FlagDependentTest : public testing::TestWithParam<bool> {
-//   virtual void SetUp() {
-//     external_flag = GetParam();
-//   }
-// }
-// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool());
-//
-inline internal::ParamGenerator<bool> Bool() {
-  return Values(false, true);
-}
-
-// Combine() allows the user to combine two or more sequences to produce
-// values of a Cartesian product of those sequences' elements.
-//
-// Synopsis:
-// Combine(gen1, gen2, ..., genN)
-//   - returns a generator producing sequences with elements coming from
-//     the Cartesian product of elements from the sequences generated by
-//     gen1, gen2, ..., genN. The sequence elements will have a type of
-//     std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
-//     of elements from sequences produces by gen1, gen2, ..., genN.
-//
-// Combine can have up to 10 arguments.
-//
-// Example:
-//
-// This will instantiate tests in test suite AnimalTest each one with
-// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
-// tuple("dog", BLACK), and tuple("dog", WHITE):
-//
-// enum Color { BLACK, GRAY, WHITE };
-// class AnimalTest
-//     : public testing::TestWithParam<std::tuple<const char*, Color> > {...};
-//
-// TEST_P(AnimalTest, AnimalLooksNice) {...}
-//
-// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
-//                          Combine(Values("cat", "dog"),
-//                                  Values(BLACK, WHITE)));
-//
-// This will instantiate tests in FlagDependentTest with all variations of two
-// Boolean flags:
-//
-// class FlagDependentTest
-//     : public testing::TestWithParam<std::tuple<bool, bool> > {
-//   virtual void SetUp() {
-//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
-//     std::tie(external_flag_1, external_flag_2) = GetParam();
-//   }
-// };
-//
-// TEST_P(FlagDependentTest, TestFeature1) {
-//   // Test your code using external_flag_1 and external_flag_2 here.
-// }
-// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest,
-//                          Combine(Bool(), Bool()));
-//
-template <typename... Generator>
-internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
-  return internal::CartesianProductHolder<Generator...>(g...);
-}
-
-#define TEST_P(test_suite_name, test_name)                                     \
-  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
-      : public test_suite_name {                                               \
-   public:                                                                     \
-    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \
-    virtual void TestBody();                                                   \
-                                                                               \
-   private:                                                                    \
-    static int AddToRegistry() {                                               \
-      ::testing::UnitTest::GetInstance()                                       \
-          ->parameterized_test_registry()                                      \
-          .GetTestSuitePatternHolder<test_suite_name>(                         \
-              #test_suite_name,                                                \
-              ::testing::internal::CodeLocation(__FILE__, __LINE__))           \
-          ->AddTestPattern(                                                    \
-              GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name),  \
-              new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \
-                  test_suite_name, test_name)>());                             \
-      return 0;                                                                \
-    }                                                                          \
-    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \
-                                                           test_name));        \
-  };                                                                           \
-  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
-                             test_name)::gtest_registering_dummy_ =            \
-      GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry();     \
-  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
-
-// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to specify
-// generator and an optional function or functor that generates custom test name
-// suffixes based on the test parameters. Such a function or functor should
-// accept one argument of type testing::TestParamInfo<class ParamType>, and
-// return std::string.
-//
-// testing::PrintToStringParamName is a builtin test suffix generator that
-// returns the value of testing::PrintToString(GetParam()).
-//
-// Note: test names must be non-empty, unique, and may only contain ASCII
-// alphanumeric characters or underscore. Because PrintToString adds quotes
-// to std::string and C strings, it won't work for these types.
-
-#define GTEST_EXPAND_(arg) arg
-#define GTEST_GET_FIRST_(first, ...) first
-#define GTEST_GET_SECOND_(first, second, ...) second
-
-#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)                \
-  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \
-      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \
-    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));        \
-  }                                                                           \
-  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \
-      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \
-    if (::testing::internal::AlwaysFalse()) {                                 \
-      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(      \
-          __VA_ARGS__,                                                        \
-          ::testing::internal::DefaultParamName<test_suite_name::ParamType>,  \
-          DUMMY_PARAM_)));                                                    \
-      auto t = std::make_tuple(__VA_ARGS__);                                  \
-      static_assert(std::tuple_size<decltype(t)>::value <= 2,                 \
-                    "Too Many Args!");                                        \
-    }                                                                         \
-    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                 \
-        __VA_ARGS__,                                                          \
-        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \
-        DUMMY_PARAM_))))(info);                                               \
-  }                                                                           \
-  static int gtest_##prefix##test_suite_name##_dummy_                         \
-      GTEST_ATTRIBUTE_UNUSED_ =                                               \
-          ::testing::UnitTest::GetInstance()                                  \
-              ->parameterized_test_registry()                                 \
-              .GetTestSuitePatternHolder<test_suite_name>(                    \
-                  #test_suite_name,                                           \
-                  ::testing::internal::CodeLocation(__FILE__, __LINE__))      \
-              ->AddTestSuiteInstantiation(                                    \
-                  #prefix, &gtest_##prefix##test_suite_name##_EvalGenerator_, \
-                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \
-                  __FILE__, __LINE__)
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define INSTANTIATE_TEST_CASE_P                                            \
-  static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \
-                "");                                                       \
-  INSTANTIATE_TEST_SUITE_P
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-// Copyright 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-//
-// Google C++ Testing and Mocking Framework definitions useful in production code.
-// GOOGLETEST_CM0003 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_
-
-// When you need to test the private or protected members of a class,
-// use the FRIEND_TEST macro to declare your tests as friends of the
-// class.  For example:
-//
-// class MyClass {
-//  private:
-//   void PrivateMethod();
-//   FRIEND_TEST(MyClassTest, PrivateMethodWorks);
-// };
-//
-// class MyClassTest : public testing::Test {
-//   // ...
-// };
-//
-// TEST_F(MyClassTest, PrivateMethodWorks) {
-//   // Can call MyClass::PrivateMethod() here.
-// }
-//
-// Note: The test class must be in the same namespace as the class being tested.
-// For example, putting MyClassTest in an anonymous namespace will not work.
-
-#define FRIEND_TEST(test_case_name, test_name)\
-friend class test_case_name##_##test_name##_Test
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
-// Copyright 2008, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-
-#include <iosfwd>
-#include <vector>
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-namespace testing {
-
-// A copyable object representing the result of a test part (i.e. an
-// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
-//
-// Don't inherit from TestPartResult as its destructor is not virtual.
-class GTEST_API_ TestPartResult {
- public:
-  // The possible outcomes of a test part (i.e. an assertion or an
-  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
-  enum Type {
-    kSuccess,          // Succeeded.
-    kNonFatalFailure,  // Failed but the test can continue.
-    kFatalFailure,     // Failed and the test should be terminated.
-    kSkip              // Skipped.
-  };
-
-  // C'tor.  TestPartResult does NOT have a default constructor.
-  // Always use this constructor (with parameters) to create a
-  // TestPartResult object.
-  TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
-                 const char* a_message)
-      : type_(a_type),
-        file_name_(a_file_name == nullptr ? "" : a_file_name),
-        line_number_(a_line_number),
-        summary_(ExtractSummary(a_message)),
-        message_(a_message) {}
-
-  // Gets the outcome of the test part.
-  Type type() const { return type_; }
-
-  // Gets the name of the source file where the test part took place, or
-  // NULL if it's unknown.
-  const char* file_name() const {
-    return file_name_.empty() ? nullptr : file_name_.c_str();
-  }
-
-  // Gets the line in the source file where the test part took place,
-  // or -1 if it's unknown.
-  int line_number() const { return line_number_; }
-
-  // Gets the summary of the failure message.
-  const char* summary() const { return summary_.c_str(); }
-
-  // Gets the message associated with the test part.
-  const char* message() const { return message_.c_str(); }
-
-  // Returns true iff the test part was skipped.
-  bool skipped() const { return type_ == kSkip; }
-
-  // Returns true iff the test part passed.
-  bool passed() const { return type_ == kSuccess; }
-
-  // Returns true iff the test part non-fatally failed.
-  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
-
-  // Returns true iff the test part fatally failed.
-  bool fatally_failed() const { return type_ == kFatalFailure; }
-
-  // Returns true iff the test part failed.
-  bool failed() const { return fatally_failed() || nonfatally_failed(); }
-
- private:
-  Type type_;
-
-  // Gets the summary of the failure message by omitting the stack
-  // trace in it.
-  static std::string ExtractSummary(const char* message);
-
-  // The name of the source file where the test part took place, or
-  // "" if the source file is unknown.
-  std::string file_name_;
-  // The line in the source file where the test part took place, or -1
-  // if the line number is unknown.
-  int line_number_;
-  std::string summary_;  // The test failure summary.
-  std::string message_;  // The test failure message.
-};
-
-// Prints a TestPartResult object.
-std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
-
-// An array of TestPartResult objects.
-//
-// Don't inherit from TestPartResultArray as its destructor is not
-// virtual.
-class GTEST_API_ TestPartResultArray {
- public:
-  TestPartResultArray() {}
-
-  // Appends the given TestPartResult to the array.
-  void Append(const TestPartResult& result);
-
-  // Returns the TestPartResult at the given index (0-based).
-  const TestPartResult& GetTestPartResult(int index) const;
-
-  // Returns the number of TestPartResult objects in the array.
-  int size() const;
-
- private:
-  std::vector<TestPartResult> array_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
-};
-
-// This interface knows how to report a test part result.
-class GTEST_API_ TestPartResultReporterInterface {
- public:
-  virtual ~TestPartResultReporterInterface() {}
-
-  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
-};
-
-namespace internal {
-
-// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
-// statement generates new fatal failures. To do so it registers itself as the
-// current test part result reporter. Besides checking if fatal failures were
-// reported, it only delegates the reporting to the former result reporter.
-// The original result reporter is restored in the destructor.
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-class GTEST_API_ HasNewFatalFailureHelper
-    : public TestPartResultReporterInterface {
- public:
-  HasNewFatalFailureHelper();
-  ~HasNewFatalFailureHelper() override;
-  void ReportTestPartResult(const TestPartResult& result) override;
-  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
- private:
-  bool has_new_fatal_failure_;
-  TestPartResultReporterInterface* original_reporter_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
-};
-
-}  // namespace internal
-
-}  // namespace testing
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-// Copyright 2008 Google Inc.
-// All Rights Reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-
-// This header implements typed tests and type-parameterized tests.
-
-// Typed (aka type-driven) tests repeat the same test for types in a
-// list.  You must know which types you want to test with when writing
-// typed tests. Here's how you do it:
-
-#if 0
-
-// First, define a fixture class template.  It should be parameterized
-// by a type.  Remember to derive it from testing::Test.
-template <typename T>
-class FooTest : public testing::Test {
- public:
-  ...
-  typedef std::list<T> List;
-  static T shared_;
-  T value_;
-};
-
-// Next, associate a list of types with the test suite, which will be
-// repeated for each type in the list.  The typedef is necessary for
-// the macro to parse correctly.
-typedef testing::Types<char, int, unsigned int> MyTypes;
-TYPED_TEST_SUITE(FooTest, MyTypes);
-
-// If the type list contains only one type, you can write that type
-// directly without Types<...>:
-//   TYPED_TEST_SUITE(FooTest, int);
-
-// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
-// tests for this test suite as you want.
-TYPED_TEST(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  // Since we are inside a derived class template, C++ requires use to
-  // visit the members of FooTest via 'this'.
-  TypeParam n = this->value_;
-
-  // To visit static members of the fixture, add the TestFixture::
-  // prefix.
-  n += TestFixture::shared_;
-
-  // To refer to typedefs in the fixture, add the "typename
-  // TestFixture::" prefix.
-  typename TestFixture::List values;
-  values.push_back(n);
-  ...
-}
-
-TYPED_TEST(FooTest, HasPropertyA) { ... }
-
-// TYPED_TEST_SUITE takes an optional third argument which allows to specify a
-// class that generates custom test name suffixes based on the type. This should
-// be a class which has a static template function GetName(int index) returning
-// a string for each type. The provided integer index equals the index of the
-// type in the provided type list. In many cases the index can be ignored.
-//
-// For example:
-//   class MyTypeNames {
-//    public:
-//     template <typename T>
-//     static std::string GetName(int) {
-//       if (std::is_same<T, char>()) return "char";
-//       if (std::is_same<T, int>()) return "int";
-//       if (std::is_same<T, unsigned int>()) return "unsignedInt";
-//     }
-//   };
-//   TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames);
-
-#endif  // 0
-
-// Type-parameterized tests are abstract test patterns parameterized
-// by a type.  Compared with typed tests, type-parameterized tests
-// allow you to define the test pattern without knowing what the type
-// parameters are.  The defined pattern can be instantiated with
-// different types any number of times, in any number of translation
-// units.
-//
-// If you are designing an interface or concept, you can define a
-// suite of type-parameterized tests to verify properties that any
-// valid implementation of the interface/concept should have.  Then,
-// each implementation can easily instantiate the test suite to verify
-// that it conforms to the requirements, without having to write
-// similar tests repeatedly.  Here's an example:
-
-#if 0
-
-// First, define a fixture class template.  It should be parameterized
-// by a type.  Remember to derive it from testing::Test.
-template <typename T>
-class FooTest : public testing::Test {
-  ...
-};
-
-// Next, declare that you will define a type-parameterized test suite
-// (the _P suffix is for "parameterized" or "pattern", whichever you
-// prefer):
-TYPED_TEST_SUITE_P(FooTest);
-
-// Then, use TYPED_TEST_P() to define as many type-parameterized tests
-// for this type-parameterized test suite as you want.
-TYPED_TEST_P(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  TypeParam n = 0;
-  ...
-}
-
-TYPED_TEST_P(FooTest, HasPropertyA) { ... }
-
-// Now the tricky part: you need to register all test patterns before
-// you can instantiate them.  The first argument of the macro is the
-// test suite name; the rest are the names of the tests in this test
-// case.
-REGISTER_TYPED_TEST_SUITE_P(FooTest,
-                            DoesBlah, HasPropertyA);
-
-// Finally, you are free to instantiate the pattern with the types you
-// want.  If you put the above code in a header file, you can #include
-// it in multiple C++ source files and instantiate it multiple times.
-//
-// To distinguish different instances of the pattern, the first
-// argument to the INSTANTIATE_* macro is a prefix that will be added
-// to the actual test suite name.  Remember to pick unique prefixes for
-// different instances.
-typedef testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
-
-// If the type list contains only one type, you can write that type
-// directly without Types<...>:
-//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int);
-//
-// Similar to the optional argument of TYPED_TEST_SUITE above,
-// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which allows to
-// generate custom names.
-//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames);
-
-#endif  // 0
-
-
-// Implements typed tests.
-
-#if GTEST_HAS_TYPED_TEST
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Expands to the name of the typedef for the type parameters of the
-// given test suite.
-#define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_
-
-// Expands to the name of the typedef for the NameGenerator, responsible for
-// creating the suffixes of the name.
-#define GTEST_NAME_GENERATOR_(TestSuiteName) \
-  gtest_type_params_##TestSuiteName##_NameGenerator
-
-// The 'Types' template argument below must have spaces around it
-// since some compilers may choke on '>>' when passing a template
-// instance (e.g. Types<int>)
-#define TYPED_TEST_SUITE(CaseName, Types, ...)                           \
-  typedef ::testing::internal::TypeList<Types>::type GTEST_TYPE_PARAMS_( \
-      CaseName);                                                         \
-  typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type  \
-      GTEST_NAME_GENERATOR_(CaseName)
-
-# define TYPED_TEST(CaseName, TestName)                                       \
-  template <typename gtest_TypeParam_>                                        \
-  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                            \
-      : public CaseName<gtest_TypeParam_> {                                   \
-   private:                                                                   \
-    typedef CaseName<gtest_TypeParam_> TestFixture;                           \
-    typedef gtest_TypeParam_ TypeParam;                                       \
-    virtual void TestBody();                                                  \
-  };                                                                          \
-  static bool gtest_##CaseName##_##TestName##_registered_                     \
-        GTEST_ATTRIBUTE_UNUSED_ =                                             \
-      ::testing::internal::TypeParameterizedTest<                             \
-          CaseName,                                                           \
-          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
-                                                                  TestName)>, \
-          GTEST_TYPE_PARAMS_(                                                 \
-              CaseName)>::Register("",                                        \
-                                   ::testing::internal::CodeLocation(         \
-                                       __FILE__, __LINE__),                   \
-                                   #CaseName, #TestName, 0,                   \
-                                   ::testing::internal::GenerateNames<        \
-                                       GTEST_NAME_GENERATOR_(CaseName),       \
-                                       GTEST_TYPE_PARAMS_(CaseName)>());      \
-  template <typename gtest_TypeParam_>                                        \
-  void GTEST_TEST_CLASS_NAME_(CaseName,                                       \
-                              TestName)<gtest_TypeParam_>::TestBody()
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define TYPED_TEST_CASE                                                \
-  static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \
-  TYPED_TEST_SUITE
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-#endif  // GTEST_HAS_TYPED_TEST
-
-// Implements type-parameterized tests.
-
-#if GTEST_HAS_TYPED_TEST_P
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Expands to the namespace name that the type-parameterized tests for
-// the given type-parameterized test suite are defined in.  The exact
-// name of the namespace is subject to change without notice.
-#define GTEST_SUITE_NAMESPACE_(TestSuiteName) gtest_suite_##TestSuiteName##_
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Expands to the name of the variable used to remember the names of
-// the defined tests in the given test suite.
-#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \
-  gtest_typed_test_suite_p_state_##TestSuiteName##_
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
-//
-// Expands to the name of the variable used to remember the names of
-// the registered tests in the given test suite.
-#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \
-  gtest_registered_test_names_##TestSuiteName##_
-
-// The variables defined in the type-parameterized test macros are
-// static as typically these macros are used in a .h file that can be
-// #included in multiple translation units linked together.
-#define TYPED_TEST_SUITE_P(SuiteName)              \
-  static ::testing::internal::TypedTestSuitePState \
-      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define TYPED_TEST_CASE_P                                                 \
-  static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), ""); \
-  TYPED_TEST_SUITE_P
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-#define TYPED_TEST_P(SuiteName, TestName)                             \
-  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                       \
-    template <typename gtest_TypeParam_>                              \
-    class TestName : public SuiteName<gtest_TypeParam_> {             \
-     private:                                                         \
-      typedef SuiteName<gtest_TypeParam_> TestFixture;                \
-      typedef gtest_TypeParam_ TypeParam;                             \
-      virtual void TestBody();                                        \
-    };                                                                \
-    static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
-        GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName(       \
-            __FILE__, __LINE__, #SuiteName, #TestName);               \
-  }                                                                   \
-  template <typename gtest_TypeParam_>                                \
-  void GTEST_SUITE_NAMESPACE_(                                        \
-      SuiteName)::TestName<gtest_TypeParam_>::TestBody()
-
-#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...)                            \
-  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                                \
-    typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
-  }                                                                            \
-  static const char* const GTEST_REGISTERED_TEST_NAMES_(                       \
-      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                     \
-      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames(    \
-          __FILE__, __LINE__, #__VA_ARGS__)
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define REGISTER_TYPED_TEST_CASE_P                                           \
-  static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \
-                "");                                                         \
-  REGISTER_TYPED_TEST_SUITE_P
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-// The 'Types' template argument below must have spaces around it
-// since some compilers may choke on '>>' when passing a template
-// instance (e.g. Types<int>)
-#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)       \
-  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =        \
-      ::testing::internal::TypeParameterizedTestSuite<                      \
-          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,    \
-          ::testing::internal::TypeList<Types>::type>::                     \
-          Register(#Prefix,                                                 \
-                   ::testing::internal::CodeLocation(__FILE__, __LINE__),   \
-                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName), #SuiteName, \
-                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),                 \
-                   ::testing::internal::GenerateNames<                      \
-                       ::testing::internal::NameGeneratorSelector<          \
-                           __VA_ARGS__>::type,                              \
-                       ::testing::internal::TypeList<Types>::type>())
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define INSTANTIATE_TYPED_TEST_CASE_P                                      \
-  static_assert(                                                           \
-      ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(), ""); \
-  INSTANTIATE_TYPED_TEST_SUITE_P
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-namespace testing {
-
-// Silence C4100 (unreferenced formal parameter) and 4805
-// unsafe mix of type 'const int' and type 'const bool'
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4805)
-# pragma warning(disable:4100)
-#endif
-
-
-// Declares the flags.
-
-// This flag temporary enables the disabled tests.
-GTEST_DECLARE_bool_(also_run_disabled_tests);
-
-// This flag brings the debugger on an assertion failure.
-GTEST_DECLARE_bool_(break_on_failure);
-
-// This flag controls whether Google Test catches all test-thrown exceptions
-// and logs them as failures.
-GTEST_DECLARE_bool_(catch_exceptions);
-
-// This flag enables using colors in terminal output. Available values are
-// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
-// to let Google Test decide.
-GTEST_DECLARE_string_(color);
-
-// This flag sets up the filter to select by name using a glob pattern
-// the tests to run. If the filter is not given all tests are executed.
-GTEST_DECLARE_string_(filter);
-
-// This flag controls whether Google Test installs a signal handler that dumps
-// debugging information when fatal signals are raised.
-GTEST_DECLARE_bool_(install_failure_signal_handler);
-
-// This flag causes the Google Test to list tests. None of the tests listed
-// are actually run if the flag is provided.
-GTEST_DECLARE_bool_(list_tests);
-
-// This flag controls whether Google Test emits a detailed XML report to a file
-// in addition to its normal textual output.
-GTEST_DECLARE_string_(output);
-
-// This flags control whether Google Test prints the elapsed time for each
-// test.
-GTEST_DECLARE_bool_(print_time);
-
-// This flags control whether Google Test prints UTF8 characters as text.
-GTEST_DECLARE_bool_(print_utf8);
-
-// This flag specifies the random number seed.
-GTEST_DECLARE_int32_(random_seed);
-
-// This flag sets how many times the tests are repeated. The default value
-// is 1. If the value is -1 the tests are repeating forever.
-GTEST_DECLARE_int32_(repeat);
-
-// This flag controls whether Google Test includes Google Test internal
-// stack frames in failure stack traces.
-GTEST_DECLARE_bool_(show_internal_stack_frames);
-
-// When this flag is specified, tests' order is randomized on every iteration.
-GTEST_DECLARE_bool_(shuffle);
-
-// This flag specifies the maximum number of stack frames to be
-// printed in a failure message.
-GTEST_DECLARE_int32_(stack_trace_depth);
-
-// When this flag is specified, a failed assertion will throw an
-// exception if exceptions are enabled, or exit the program with a
-// non-zero code otherwise. For use with an external test framework.
-GTEST_DECLARE_bool_(throw_on_failure);
-
-// When this flag is set with a "host:port" string, on supported
-// platforms test results are streamed to the specified port on
-// the specified host machine.
-GTEST_DECLARE_string_(stream_result_to);
-
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-GTEST_DECLARE_string_(flagfile);
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-
-// The upper limit for valid stack trace depths.
-const int kMaxStackTraceDepth = 100;
-
-namespace internal {
-
-class AssertHelper;
-class DefaultGlobalTestPartResultReporter;
-class ExecDeathTest;
-class NoExecDeathTest;
-class FinalSuccessChecker;
-class GTestFlagSaver;
-class StreamingListenerTest;
-class TestResultAccessor;
-class TestEventListenersAccessor;
-class TestEventRepeater;
-class UnitTestRecordPropertyTestHelper;
-class WindowsDeathTest;
-class FuchsiaDeathTest;
-class UnitTestImpl* GetUnitTestImpl();
-void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
-                                    const std::string& message);
-
-}  // namespace internal
-
-// The friend relationship of some of these classes is cyclic.
-// If we don't forward declare them the compiler might confuse the classes
-// in friendship clauses with same named classes on the scope.
-class Test;
-class TestSuite;
-
-// Old API is still available but deprecated
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-using TestCase = TestSuite;
-#endif
-class TestInfo;
-class UnitTest;
-
-// A class for indicating whether an assertion was successful.  When
-// the assertion wasn't successful, the AssertionResult object
-// remembers a non-empty message that describes how it failed.
-//
-// To create an instance of this class, use one of the factory functions
-// (AssertionSuccess() and AssertionFailure()).
-//
-// This class is useful for two purposes:
-//   1. Defining predicate functions to be used with Boolean test assertions
-//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
-//   2. Defining predicate-format functions to be
-//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
-//
-// For example, if you define IsEven predicate:
-//
-//   testing::AssertionResult IsEven(int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess();
-//     else
-//       return testing::AssertionFailure() << n << " is odd";
-//   }
-//
-// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
-// will print the message
-//
-//   Value of: IsEven(Fib(5))
-//     Actual: false (5 is odd)
-//   Expected: true
-//
-// instead of a more opaque
-//
-//   Value of: IsEven(Fib(5))
-//     Actual: false
-//   Expected: true
-//
-// in case IsEven is a simple Boolean predicate.
-//
-// If you expect your predicate to be reused and want to support informative
-// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
-// about half as often as positive ones in our tests), supply messages for
-// both success and failure cases:
-//
-//   testing::AssertionResult IsEven(int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess() << n << " is even";
-//     else
-//       return testing::AssertionFailure() << n << " is odd";
-//   }
-//
-// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
-//
-//   Value of: IsEven(Fib(6))
-//     Actual: true (8 is even)
-//   Expected: false
-//
-// NB: Predicates that support negative Boolean assertions have reduced
-// performance in positive ones so be careful not to use them in tests
-// that have lots (tens of thousands) of positive Boolean assertions.
-//
-// To use this class with EXPECT_PRED_FORMAT assertions such as:
-//
-//   // Verifies that Foo() returns an even number.
-//   EXPECT_PRED_FORMAT1(IsEven, Foo());
-//
-// you need to define:
-//
-//   testing::AssertionResult IsEven(const char* expr, int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess();
-//     else
-//       return testing::AssertionFailure()
-//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
-//   }
-//
-// If Foo() returns 5, you will see the following message:
-//
-//   Expected: Foo() is even
-//     Actual: it's 5
-//
-class GTEST_API_ AssertionResult {
- public:
-  // Copy constructor.
-  // Used in EXPECT_TRUE/FALSE(assertion_result).
-  AssertionResult(const AssertionResult& other);
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
-#endif
-
-  // Used in the EXPECT_TRUE/FALSE(bool_expression).
-  //
-  // T must be contextually convertible to bool.
-  //
-  // The second parameter prevents this overload from being considered if
-  // the argument is implicitly convertible to AssertionResult. In that case
-  // we want AssertionResult's copy constructor to be used.
-  template <typename T>
-  explicit AssertionResult(
-      const T& success,
-      typename internal::EnableIf<
-          !std::is_convertible<T, AssertionResult>::value>::type*
-      /*enabler*/
-      = nullptr)
-      : success_(success) {}
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif
-
-  // Assignment operator.
-  AssertionResult& operator=(AssertionResult other) {
-    swap(other);
-    return *this;
-  }
-
-  // Returns true iff the assertion succeeded.
-  operator bool() const { return success_; }  // NOLINT
-
-  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
-  AssertionResult operator!() const;
-
-  // Returns the text streamed into this AssertionResult. Test assertions
-  // use it when they fail (i.e., the predicate's outcome doesn't match the
-  // assertion's expectation). When nothing has been streamed into the
-  // object, returns an empty string.
-  const char* message() const {
-    return message_.get() != nullptr ? message_->c_str() : "";
-  }
-  // Deprecated; please use message() instead.
-  const char* failure_message() const { return message(); }
-
-  // Streams a custom failure message into this object.
-  template <typename T> AssertionResult& operator<<(const T& value) {
-    AppendMessage(Message() << value);
-    return *this;
-  }
-
-  // Allows streaming basic output manipulators such as endl or flush into
-  // this object.
-  AssertionResult& operator<<(
-      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
-    AppendMessage(Message() << basic_manipulator);
-    return *this;
-  }
-
- private:
-  // Appends the contents of message to message_.
-  void AppendMessage(const Message& a_message) {
-    if (message_.get() == nullptr) message_.reset(new ::std::string);
-    message_->append(a_message.GetString().c_str());
-  }
-
-  // Swap the contents of this AssertionResult with other.
-  void swap(AssertionResult& other);
-
-  // Stores result of the assertion predicate.
-  bool success_;
-  // Stores the message describing the condition in case the expectation
-  // construct is not satisfied with the predicate's outcome.
-  // Referenced via a pointer to avoid taking too much stack frame space
-  // with test assertions.
-  std::unique_ptr< ::std::string> message_;
-};
-
-// Makes a successful assertion result.
-GTEST_API_ AssertionResult AssertionSuccess();
-
-// Makes a failed assertion result.
-GTEST_API_ AssertionResult AssertionFailure();
-
-// Makes a failed assertion result with the given failure message.
-// Deprecated; use AssertionFailure() << msg.
-GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
-
-}  // namespace testing
-
-// Includes the auto-generated header that implements a family of generic
-// predicate assertion macros. This include comes late because it relies on
-// APIs declared above.
-// Copyright 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command
-// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
-//
-// Implements a family of generic predicate assertion macros.
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-
-
-namespace testing {
-
-// This header implements a family of generic predicate assertion
-// macros:
-//
-//   ASSERT_PRED_FORMAT1(pred_format, v1)
-//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
-//   ...
-//
-// where pred_format is a function or functor that takes n (in the
-// case of ASSERT_PRED_FORMATn) values and their source expression
-// text, and returns a testing::AssertionResult.  See the definition
-// of ASSERT_EQ in gtest.h for an example.
-//
-// If you don't care about formatting, you can use the more
-// restrictive version:
-//
-//   ASSERT_PRED1(pred, v1)
-//   ASSERT_PRED2(pred, v1, v2)
-//   ...
-//
-// where pred is an n-ary function or functor that returns bool,
-// and the values v1, v2, ..., must support the << operator for
-// streaming to std::ostream.
-//
-// We also define the EXPECT_* variations.
-//
-// For now we only support predicates whose arity is at most 5.
-// Please email googletestframework@googlegroups.com if you need
-// support for higher arities.
-
-// GTEST_ASSERT_ is the basic statement to which all of the assertions
-// in this file reduce.  Don't use this in your code.
-
-#define GTEST_ASSERT_(expression, on_failure) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (const ::testing::AssertionResult gtest_ar = (expression)) \
-    ; \
-  else \
-    on_failure(gtest_ar.failure_message())
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1>
-AssertionResult AssertPred1Helper(const char* pred_text,
-                                  const char* e1,
-                                  Pred pred,
-                                  const T1& v1) {
-  if (pred(v1)) return AssertionSuccess();
-
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1);
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, v1), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
-// this in your code.
-#define GTEST_PRED1_(pred, v1, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
-                                             #v1, \
-                                             pred, \
-                                             v1), on_failure)
-
-// Unary predicate assertion macros.
-#define EXPECT_PRED_FORMAT1(pred_format, v1) \
-  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED1(pred, v1) \
-  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT1(pred_format, v1) \
-  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED1(pred, v1) \
-  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2>
-AssertionResult AssertPred2Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2) {
-  if (pred(v1, v2)) return AssertionSuccess();
-
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ", " << e2
-         << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
-         << e2 << " evaluates to " << ::testing::PrintToString(v2);
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
-// this in your code.
-#define GTEST_PRED2_(pred, v1, v2, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             pred, \
-                                             v1, \
-                                             v2), on_failure)
-
-// Binary predicate assertion macros.
-#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
-  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED2(pred, v1, v2) \
-  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
-  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED2(pred, v1, v2) \
-  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3>
-AssertionResult AssertPred3Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3) {
-  if (pred(v1, v2, v3)) return AssertionSuccess();
-
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ", " << e2 << ", " << e3
-         << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
-         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
-         << e3 << " evaluates to " << ::testing::PrintToString(v3);
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
-// this in your code.
-#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3), on_failure)
-
-// Ternary predicate assertion macros.
-#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
-  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED3(pred, v1, v2, v3) \
-  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
-  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED3(pred, v1, v2, v3) \
-  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4>
-AssertionResult AssertPred4Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  const char* e4,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3,
-                                  const T4& v4) {
-  if (pred(v1, v2, v3, v4)) return AssertionSuccess();
-
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
-         << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
-         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
-         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
-         << e4 << " evaluates to " << ::testing::PrintToString(v4);
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
-// this in your code.
-#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             #v4, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3, \
-                                             v4), on_failure)
-
-// 4-ary predicate assertion macros.
-#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
-  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
-  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
-  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
-  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5>
-AssertionResult AssertPred5Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  const char* e4,
-                                  const char* e5,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3,
-                                  const T4& v4,
-                                  const T5& v5) {
-  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
-
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
-         << ", " << e5 << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
-         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
-         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
-         << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n"
-         << e5 << " evaluates to " << ::testing::PrintToString(v5);
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
-// this in your code.
-#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             #v4, \
-                                             #v5, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3, \
-                                             v4, \
-                                             v5), on_failure)
-
-// 5-ary predicate assertion macros.
-#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
-  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
-  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
-  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
-  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
-
-
-
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-
-namespace testing {
-
-// The abstract class that all tests inherit from.
-//
-// In Google Test, a unit test program contains one or many TestSuites, and
-// each TestSuite contains one or many Tests.
-//
-// When you define a test using the TEST macro, you don't need to
-// explicitly derive from Test - the TEST macro automatically does
-// this for you.
-//
-// The only time you derive from Test is when defining a test fixture
-// to be used in a TEST_F.  For example:
-//
-//   class FooTest : public testing::Test {
-//    protected:
-//     void SetUp() override { ... }
-//     void TearDown() override { ... }
-//     ...
-//   };
-//
-//   TEST_F(FooTest, Bar) { ... }
-//   TEST_F(FooTest, Baz) { ... }
-//
-// Test is not copyable.
-class GTEST_API_ Test {
- public:
-  friend class TestInfo;
-
-  // The d'tor is virtual as we intend to inherit from Test.
-  virtual ~Test();
-
-  // Sets up the stuff shared by all tests in this test case.
-  //
-  // Google Test will call Foo::SetUpTestSuite() before running the first
-  // test in test case Foo.  Hence a sub-class can define its own
-  // SetUpTestSuite() method to shadow the one defined in the super
-  // class.
-  static void SetUpTestSuite() {}
-
-  // Tears down the stuff shared by all tests in this test case.
-  //
-  // Google Test will call Foo::TearDownTestSuite() after running the last
-  // test in test case Foo.  Hence a sub-class can define its own
-  // TearDownTestSuite() method to shadow the one defined in the super
-  // class.
-  static void TearDownTestSuite() {}
-
-  // Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  static void TearDownTestCase() {}
-  static void SetUpTestCase() {}
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  // Returns true iff the current test has a fatal failure.
-  static bool HasFatalFailure();
-
-  // Returns true iff the current test has a non-fatal failure.
-  static bool HasNonfatalFailure();
-
-  // Returns true iff the current test was skipped.
-  static bool IsSkipped();
-
-  // Returns true iff the current test has a (either fatal or
-  // non-fatal) failure.
-  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
-
-  // Logs a property for the current test, test suite, or for the entire
-  // invocation of the test program when used outside of the context of a
-  // test suite.  Only the last value for a given key is remembered.  These
-  // are public static so they can be called from utility functions that are
-  // not members of the test fixture.  Calls to RecordProperty made during
-  // lifespan of the test (from the moment its constructor starts to the
-  // moment its destructor finishes) will be output in XML as attributes of
-  // the <testcase> element.  Properties recorded from fixture's
-  // SetUpTestSuite or TearDownTestSuite are logged as attributes of the
-  // corresponding <testsuite> element.  Calls to RecordProperty made in the
-  // global context (before or after invocation of RUN_ALL_TESTS and from
-  // SetUp/TearDown method of Environment objects registered with Google
-  // Test) will be output as attributes of the <testsuites> element.
-  static void RecordProperty(const std::string& key, const std::string& value);
-  static void RecordProperty(const std::string& key, int value);
-
- protected:
-  // Creates a Test object.
-  Test();
-
-  // Sets up the test fixture.
-  virtual void SetUp();
-
-  // Tears down the test fixture.
-  virtual void TearDown();
-
- private:
-  // Returns true iff the current test has the same fixture class as
-  // the first test in the current test suite.
-  static bool HasSameFixtureClass();
-
-  // Runs the test after the test fixture has been set up.
-  //
-  // A sub-class must implement this to define the test logic.
-  //
-  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
-  // Instead, use the TEST or TEST_F macro.
-  virtual void TestBody() = 0;
-
-  // Sets up, executes, and tears down the test.
-  void Run();
-
-  // Deletes self.  We deliberately pick an unusual name for this
-  // internal method to avoid clashing with names used in user TESTs.
-  void DeleteSelf_() { delete this; }
-
-  const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_;
-
-  // Often a user misspells SetUp() as Setup() and spends a long time
-  // wondering why it is never called by Google Test.  The declaration of
-  // the following method is solely for catching such an error at
-  // compile time:
-  //
-  //   - The return type is deliberately chosen to be not void, so it
-  //   will be a conflict if void Setup() is declared in the user's
-  //   test fixture.
-  //
-  //   - This method is private, so it will be another compiler error
-  //   if the method is called from the user's test fixture.
-  //
-  // DO NOT OVERRIDE THIS FUNCTION.
-  //
-  // If you see an error about overriding the following function or
-  // about it being private, you have mis-spelled SetUp() as Setup().
-  struct Setup_should_be_spelled_SetUp {};
-  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
-
-  // We disallow copying Tests.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
-};
-
-typedef internal::TimeInMillis TimeInMillis;
-
-// A copyable object representing a user specified test property which can be
-// output as a key/value string pair.
-//
-// Don't inherit from TestProperty as its destructor is not virtual.
-class TestProperty {
- public:
-  // C'tor.  TestProperty does NOT have a default constructor.
-  // Always use this constructor (with parameters) to create a
-  // TestProperty object.
-  TestProperty(const std::string& a_key, const std::string& a_value) :
-    key_(a_key), value_(a_value) {
-  }
-
-  // Gets the user supplied key.
-  const char* key() const {
-    return key_.c_str();
-  }
-
-  // Gets the user supplied value.
-  const char* value() const {
-    return value_.c_str();
-  }
-
-  // Sets a new value, overriding the one supplied in the constructor.
-  void SetValue(const std::string& new_value) {
-    value_ = new_value;
-  }
-
- private:
-  // The key supplied by the user.
-  std::string key_;
-  // The value supplied by the user.
-  std::string value_;
-};
-
-// The result of a single Test.  This includes a list of
-// TestPartResults, a list of TestProperties, a count of how many
-// death tests there are in the Test, and how much time it took to run
-// the Test.
-//
-// TestResult is not copyable.
-class GTEST_API_ TestResult {
- public:
-  // Creates an empty TestResult.
-  TestResult();
-
-  // D'tor.  Do not inherit from TestResult.
-  ~TestResult();
-
-  // Gets the number of all test parts.  This is the sum of the number
-  // of successful test parts and the number of failed test parts.
-  int total_part_count() const;
-
-  // Returns the number of the test properties.
-  int test_property_count() const;
-
-  // Returns true iff the test passed (i.e. no test part failed).
-  bool Passed() const { return !Skipped() && !Failed(); }
-
-  // Returns true iff the test was skipped.
-  bool Skipped() const;
-
-  // Returns true iff the test failed.
-  bool Failed() const;
-
-  // Returns true iff the test fatally failed.
-  bool HasFatalFailure() const;
-
-  // Returns true iff the test has a non-fatal failure.
-  bool HasNonfatalFailure() const;
-
-  // Returns the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns the i-th test part result among all the results. i can range from 0
-  // to total_part_count() - 1. If i is not in that range, aborts the program.
-  const TestPartResult& GetTestPartResult(int i) const;
-
-  // Returns the i-th test property. i can range from 0 to
-  // test_property_count() - 1. If i is not in that range, aborts the
-  // program.
-  const TestProperty& GetTestProperty(int i) const;
-
- private:
-  friend class TestInfo;
-  friend class TestSuite;
-  friend class UnitTest;
-  friend class internal::DefaultGlobalTestPartResultReporter;
-  friend class internal::ExecDeathTest;
-  friend class internal::TestResultAccessor;
-  friend class internal::UnitTestImpl;
-  friend class internal::WindowsDeathTest;
-  friend class internal::FuchsiaDeathTest;
-
-  // Gets the vector of TestPartResults.
-  const std::vector<TestPartResult>& test_part_results() const {
-    return test_part_results_;
-  }
-
-  // Gets the vector of TestProperties.
-  const std::vector<TestProperty>& test_properties() const {
-    return test_properties_;
-  }
-
-  // Sets the elapsed time.
-  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
-
-  // Adds a test property to the list. The property is validated and may add
-  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
-  // key names). If a property is already recorded for the same key, the
-  // value will be updated, rather than storing multiple values for the same
-  // key.  xml_element specifies the element for which the property is being
-  // recorded and is used for validation.
-  void RecordProperty(const std::string& xml_element,
-                      const TestProperty& test_property);
-
-  // Adds a failure if the key is a reserved attribute of Google Test
-  // testsuite tags.  Returns true if the property is valid.
-  // FIXME: Validate attribute names are legal and human readable.
-  static bool ValidateTestProperty(const std::string& xml_element,
-                                   const TestProperty& test_property);
-
-  // Adds a test part result to the list.
-  void AddTestPartResult(const TestPartResult& test_part_result);
-
-  // Returns the death test count.
-  int death_test_count() const { return death_test_count_; }
-
-  // Increments the death test count, returning the new count.
-  int increment_death_test_count() { return ++death_test_count_; }
-
-  // Clears the test part results.
-  void ClearTestPartResults();
-
-  // Clears the object.
-  void Clear();
-
-  // Protects mutable state of the property vector and of owned
-  // properties, whose values may be updated.
-  internal::Mutex test_properites_mutex_;
-
-  // The vector of TestPartResults
-  std::vector<TestPartResult> test_part_results_;
-  // The vector of TestProperties
-  std::vector<TestProperty> test_properties_;
-  // Running count of death tests.
-  int death_test_count_;
-  // The elapsed time, in milliseconds.
-  TimeInMillis elapsed_time_;
-
-  // We disallow copying TestResult.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
-};  // class TestResult
-
-// A TestInfo object stores the following information about a test:
-//
-//   Test suite name
-//   Test name
-//   Whether the test should be run
-//   A function pointer that creates the test object when invoked
-//   Test result
-//
-// The constructor of TestInfo registers itself with the UnitTest
-// singleton such that the RUN_ALL_TESTS() macro knows which tests to
-// run.
-class GTEST_API_ TestInfo {
- public:
-  // Destructs a TestInfo object.  This function is not virtual, so
-  // don't inherit from TestInfo.
-  ~TestInfo();
-
-  // Returns the test suite name.
-  const char* test_suite_name() const { return test_suite_name_.c_str(); }
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  const char* test_case_name() const { return test_suite_name(); }
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  // Returns the test name.
-  const char* name() const { return name_.c_str(); }
-
-  // Returns the name of the parameter type, or NULL if this is not a typed
-  // or a type-parameterized test.
-  const char* type_param() const {
-    if (type_param_.get() != nullptr) return type_param_->c_str();
-    return nullptr;
-  }
-
-  // Returns the text representation of the value parameter, or NULL if this
-  // is not a value-parameterized test.
-  const char* value_param() const {
-    if (value_param_.get() != nullptr) return value_param_->c_str();
-    return nullptr;
-  }
-
-  // Returns the file name where this test is defined.
-  const char* file() const { return location_.file.c_str(); }
-
-  // Returns the line where this test is defined.
-  int line() const { return location_.line; }
-
-  // Return true if this test should not be run because it's in another shard.
-  bool is_in_another_shard() const { return is_in_another_shard_; }
-
-  // Returns true if this test should run, that is if the test is not
-  // disabled (or it is disabled but the also_run_disabled_tests flag has
-  // been specified) and its full name matches the user-specified filter.
-  //
-  // Google Test allows the user to filter the tests by their full names.
-  // The full name of a test Bar in test suite Foo is defined as
-  // "Foo.Bar".  Only the tests that match the filter will run.
-  //
-  // A filter is a colon-separated list of glob (not regex) patterns,
-  // optionally followed by a '-' and a colon-separated list of
-  // negative patterns (tests to exclude).  A test is run if it
-  // matches one of the positive patterns and does not match any of
-  // the negative patterns.
-  //
-  // For example, *A*:Foo.* is a filter that matches any string that
-  // contains the character 'A' or starts with "Foo.".
-  bool should_run() const { return should_run_; }
-
-  // Returns true iff this test will appear in the XML report.
-  bool is_reportable() const {
-    // The XML report includes tests matching the filter, excluding those
-    // run in other shards.
-    return matches_filter_ && !is_in_another_shard_;
-  }
-
-  // Returns the result of the test.
-  const TestResult* result() const { return &result_; }
-
- private:
-#if GTEST_HAS_DEATH_TEST
-  friend class internal::DefaultDeathTestFactory;
-#endif  // GTEST_HAS_DEATH_TEST
-  friend class Test;
-  friend class TestSuite;
-  friend class internal::UnitTestImpl;
-  friend class internal::StreamingListenerTest;
-  friend TestInfo* internal::MakeAndRegisterTestInfo(
-      const char* test_suite_name, const char* name, const char* type_param,
-      const char* value_param, internal::CodeLocation code_location,
-      internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
-      internal::TearDownTestSuiteFunc tear_down_tc,
-      internal::TestFactoryBase* factory);
-
-  // Constructs a TestInfo object. The newly constructed instance assumes
-  // ownership of the factory object.
-  TestInfo(const std::string& test_suite_name, const std::string& name,
-           const char* a_type_param,   // NULL if not a type-parameterized test
-           const char* a_value_param,  // NULL if not a value-parameterized test
-           internal::CodeLocation a_code_location,
-           internal::TypeId fixture_class_id,
-           internal::TestFactoryBase* factory);
-
-  // Increments the number of death tests encountered in this test so
-  // far.
-  int increment_death_test_count() {
-    return result_.increment_death_test_count();
-  }
-
-  // Creates the test object, runs it, records its result, and then
-  // deletes it.
-  void Run();
-
-  static void ClearTestResult(TestInfo* test_info) {
-    test_info->result_.Clear();
-  }
-
-  // These fields are immutable properties of the test.
-  const std::string test_suite_name_;    // test suite name
-  const std::string name_;               // Test name
-  // Name of the parameter type, or NULL if this is not a typed or a
-  // type-parameterized test.
-  const std::unique_ptr<const ::std::string> type_param_;
-  // Text representation of the value parameter, or NULL if this is not a
-  // value-parameterized test.
-  const std::unique_ptr<const ::std::string> value_param_;
-  internal::CodeLocation location_;
-  const internal::TypeId fixture_class_id_;   // ID of the test fixture class
-  bool should_run_;                 // True iff this test should run
-  bool is_disabled_;                // True iff this test is disabled
-  bool matches_filter_;             // True if this test matches the
-                                    // user-specified filter.
-  bool is_in_another_shard_;        // Will be run in another shard.
-  internal::TestFactoryBase* const factory_;  // The factory that creates
-                                              // the test object
-
-  // This field is mutable and needs to be reset before running the
-  // test for the second time.
-  TestResult result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
-};
-
-// A test suite, which consists of a vector of TestInfos.
-//
-// TestSuite is not copyable.
-class GTEST_API_ TestSuite {
- public:
-  // Creates a TestSuite with the given name.
-  //
-  // TestSuite does NOT have a default constructor.  Always use this
-  // constructor to create a TestSuite object.
-  //
-  // Arguments:
-  //
-  //   name:         name of the test suite
-  //   a_type_param: the name of the test's type parameter, or NULL if
-  //                 this is not a type-parameterized test.
-  //   set_up_tc:    pointer to the function that sets up the test suite
-  //   tear_down_tc: pointer to the function that tears down the test suite
-  TestSuite(const char* name, const char* a_type_param,
-            internal::SetUpTestSuiteFunc set_up_tc,
-            internal::TearDownTestSuiteFunc tear_down_tc);
-
-  // Destructor of TestSuite.
-  virtual ~TestSuite();
-
-  // Gets the name of the TestSuite.
-  const char* name() const { return name_.c_str(); }
-
-  // Returns the name of the parameter type, or NULL if this is not a
-  // type-parameterized test suite.
-  const char* type_param() const {
-    if (type_param_.get() != nullptr) return type_param_->c_str();
-    return nullptr;
-  }
-
-  // Returns true if any test in this test suite should run.
-  bool should_run() const { return should_run_; }
-
-  // Gets the number of successful tests in this test suite.
-  int successful_test_count() const;
-
-  // Gets the number of skipped tests in this test suite.
-  int skipped_test_count() const;
-
-  // Gets the number of failed tests in this test suite.
-  int failed_test_count() const;
-
-  // Gets the number of disabled tests that will be reported in the XML report.
-  int reportable_disabled_test_count() const;
-
-  // Gets the number of disabled tests in this test suite.
-  int disabled_test_count() const;
-
-  // Gets the number of tests to be printed in the XML report.
-  int reportable_test_count() const;
-
-  // Get the number of tests in this test suite that should run.
-  int test_to_run_count() const;
-
-  // Gets the number of all tests in this test suite.
-  int total_test_count() const;
-
-  // Returns true iff the test suite passed.
-  bool Passed() const { return !Failed(); }
-
-  // Returns true iff the test suite failed.
-  bool Failed() const { return failed_test_count() > 0; }
-
-  // Returns the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns the i-th test among all the tests. i can range from 0 to
-  // total_test_count() - 1. If i is not in that range, returns NULL.
-  const TestInfo* GetTestInfo(int i) const;
-
-  // Returns the TestResult that holds test properties recorded during
-  // execution of SetUpTestSuite and TearDownTestSuite.
-  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
-
- private:
-  friend class Test;
-  friend class internal::UnitTestImpl;
-
-  // Gets the (mutable) vector of TestInfos in this TestSuite.
-  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
-
-  // Gets the (immutable) vector of TestInfos in this TestSuite.
-  const std::vector<TestInfo*>& test_info_list() const {
-    return test_info_list_;
-  }
-
-  // Returns the i-th test among all the tests. i can range from 0 to
-  // total_test_count() - 1. If i is not in that range, returns NULL.
-  TestInfo* GetMutableTestInfo(int i);
-
-  // Sets the should_run member.
-  void set_should_run(bool should) { should_run_ = should; }
-
-  // Adds a TestInfo to this test suite.  Will delete the TestInfo upon
-  // destruction of the TestSuite object.
-  void AddTestInfo(TestInfo * test_info);
-
-  // Clears the results of all tests in this test suite.
-  void ClearResult();
-
-  // Clears the results of all tests in the given test suite.
-  static void ClearTestSuiteResult(TestSuite* test_suite) {
-    test_suite->ClearResult();
-  }
-
-  // Runs every test in this TestSuite.
-  void Run();
-
-  // Runs SetUpTestSuite() for this TestSuite.  This wrapper is needed
-  // for catching exceptions thrown from SetUpTestSuite().
-  void RunSetUpTestSuite() {
-    if (set_up_tc_ != nullptr) {
-      (*set_up_tc_)();
-    }
-  }
-
-  // Runs TearDownTestSuite() for this TestSuite.  This wrapper is
-  // needed for catching exceptions thrown from TearDownTestSuite().
-  void RunTearDownTestSuite() {
-    if (tear_down_tc_ != nullptr) {
-      (*tear_down_tc_)();
-    }
-  }
-
-  // Returns true iff test passed.
-  static bool TestPassed(const TestInfo* test_info) {
-    return test_info->should_run() && test_info->result()->Passed();
-  }
-
-  // Returns true iff test skipped.
-  static bool TestSkipped(const TestInfo* test_info) {
-    return test_info->should_run() && test_info->result()->Skipped();
-  }
-
-  // Returns true iff test failed.
-  static bool TestFailed(const TestInfo* test_info) {
-    return test_info->should_run() && test_info->result()->Failed();
-  }
-
-  // Returns true iff the test is disabled and will be reported in the XML
-  // report.
-  static bool TestReportableDisabled(const TestInfo* test_info) {
-    return test_info->is_reportable() && test_info->is_disabled_;
-  }
-
-  // Returns true iff test is disabled.
-  static bool TestDisabled(const TestInfo* test_info) {
-    return test_info->is_disabled_;
-  }
-
-  // Returns true iff this test will appear in the XML report.
-  static bool TestReportable(const TestInfo* test_info) {
-    return test_info->is_reportable();
-  }
-
-  // Returns true if the given test should run.
-  static bool ShouldRunTest(const TestInfo* test_info) {
-    return test_info->should_run();
-  }
-
-  // Shuffles the tests in this test suite.
-  void ShuffleTests(internal::Random* random);
-
-  // Restores the test order to before the first shuffle.
-  void UnshuffleTests();
-
-  // Name of the test suite.
-  std::string name_;
-  // Name of the parameter type, or NULL if this is not a typed or a
-  // type-parameterized test.
-  const std::unique_ptr<const ::std::string> type_param_;
-  // The vector of TestInfos in their original order.  It owns the
-  // elements in the vector.
-  std::vector<TestInfo*> test_info_list_;
-  // Provides a level of indirection for the test list to allow easy
-  // shuffling and restoring the test order.  The i-th element in this
-  // vector is the index of the i-th test in the shuffled test list.
-  std::vector<int> test_indices_;
-  // Pointer to the function that sets up the test suite.
-  internal::SetUpTestSuiteFunc set_up_tc_;
-  // Pointer to the function that tears down the test suite.
-  internal::TearDownTestSuiteFunc tear_down_tc_;
-  // True iff any test in this test suite should run.
-  bool should_run_;
-  // Elapsed time, in milliseconds.
-  TimeInMillis elapsed_time_;
-  // Holds test properties recorded during execution of SetUpTestSuite and
-  // TearDownTestSuite.
-  TestResult ad_hoc_test_result_;
-
-  // We disallow copying TestSuites.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
-};
-
-// An Environment object is capable of setting up and tearing down an
-// environment.  You should subclass this to define your own
-// environment(s).
-//
-// An Environment object does the set-up and tear-down in virtual
-// methods SetUp() and TearDown() instead of the constructor and the
-// destructor, as:
-//
-//   1. You cannot safely throw from a destructor.  This is a problem
-//      as in some cases Google Test is used where exceptions are enabled, and
-//      we may want to implement ASSERT_* using exceptions where they are
-//      available.
-//   2. You cannot use ASSERT_* directly in a constructor or
-//      destructor.
-class Environment {
- public:
-  // The d'tor is virtual as we need to subclass Environment.
-  virtual ~Environment() {}
-
-  // Override this to define how to set up the environment.
-  virtual void SetUp() {}
-
-  // Override this to define how to tear down the environment.
-  virtual void TearDown() {}
- private:
-  // If you see an error about overriding the following function or
-  // about it being private, you have mis-spelled SetUp() as Setup().
-  struct Setup_should_be_spelled_SetUp {};
-  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
-};
-
-#if GTEST_HAS_EXCEPTIONS
-
-// Exception which can be thrown from TestEventListener::OnTestPartResult.
-class GTEST_API_ AssertionException
-    : public internal::GoogleTestFailureException {
- public:
-  explicit AssertionException(const TestPartResult& result)
-      : GoogleTestFailureException(result) {}
-};
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// The interface for tracing execution of tests. The methods are organized in
-// the order the corresponding events are fired.
-class TestEventListener {
- public:
-  virtual ~TestEventListener() {}
-
-  // Fired before any test activity starts.
-  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
-
-  // Fired before each iteration of tests starts.  There may be more than
-  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
-  // index, starting from 0.
-  virtual void OnTestIterationStart(const UnitTest& unit_test,
-                                    int iteration) = 0;
-
-  // Fired before environment set-up for each iteration of tests starts.
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
-
-  // Fired after environment set-up for each iteration of tests ends.
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
-
-  // Fired before the test suite starts.
-  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}
-
-  //  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  // Fired before the test starts.
-  virtual void OnTestStart(const TestInfo& test_info) = 0;
-
-  // Fired after a failed assertion or a SUCCEED() invocation.
-  // If you want to throw an exception from this function to skip to the next
-  // TEST, it must be AssertionException defined above, or inherited from it.
-  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
-
-  // Fired after the test ends.
-  virtual void OnTestEnd(const TestInfo& test_info) = 0;
-
-  // Fired after the test suite ends.
-  virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  // Fired before environment tear-down for each iteration of tests starts.
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
-
-  // Fired after environment tear-down for each iteration of tests ends.
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
-
-  // Fired after each iteration of tests finishes.
-  virtual void OnTestIterationEnd(const UnitTest& unit_test,
-                                  int iteration) = 0;
-
-  // Fired after all test activities have ended.
-  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
-};
-
-// The convenience class for users who need to override just one or two
-// methods and are not concerned that a possible change to a signature of
-// the methods they override will not be caught during the build.  For
-// comments about each method please see the definition of TestEventListener
-// above.
-class EmptyTestEventListener : public TestEventListener {
- public:
-  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
-  void OnTestIterationStart(const UnitTest& /*unit_test*/,
-                            int /*iteration*/) override {}
-  void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
-  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
-  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  void OnTestStart(const TestInfo& /*test_info*/) override {}
-  void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {}
-  void OnTestEnd(const TestInfo& /*test_info*/) override {}
-  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
-  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
-  void OnTestIterationEnd(const UnitTest& /*unit_test*/,
-                          int /*iteration*/) override {}
-  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
-};
-
-// TestEventListeners lets users add listeners to track events in Google Test.
-class GTEST_API_ TestEventListeners {
- public:
-  TestEventListeners();
-  ~TestEventListeners();
-
-  // Appends an event listener to the end of the list. Google Test assumes
-  // the ownership of the listener (i.e. it will delete the listener when
-  // the test program finishes).
-  void Append(TestEventListener* listener);
-
-  // Removes the given event listener from the list and returns it.  It then
-  // becomes the caller's responsibility to delete the listener. Returns
-  // NULL if the listener is not found in the list.
-  TestEventListener* Release(TestEventListener* listener);
-
-  // Returns the standard listener responsible for the default console
-  // output.  Can be removed from the listeners list to shut down default
-  // console output.  Note that removing this object from the listener list
-  // with Release transfers its ownership to the caller and makes this
-  // function return NULL the next time.
-  TestEventListener* default_result_printer() const {
-    return default_result_printer_;
-  }
-
-  // Returns the standard listener responsible for the default XML output
-  // controlled by the --gtest_output=xml flag.  Can be removed from the
-  // listeners list by users who want to shut down the default XML output
-  // controlled by this flag and substitute it with custom one.  Note that
-  // removing this object from the listener list with Release transfers its
-  // ownership to the caller and makes this function return NULL the next
-  // time.
-  TestEventListener* default_xml_generator() const {
-    return default_xml_generator_;
-  }
-
- private:
-  friend class TestSuite;
-  friend class TestInfo;
-  friend class internal::DefaultGlobalTestPartResultReporter;
-  friend class internal::NoExecDeathTest;
-  friend class internal::TestEventListenersAccessor;
-  friend class internal::UnitTestImpl;
-
-  // Returns repeater that broadcasts the TestEventListener events to all
-  // subscribers.
-  TestEventListener* repeater();
-
-  // Sets the default_result_printer attribute to the provided listener.
-  // The listener is also added to the listener list and previous
-  // default_result_printer is removed from it and deleted. The listener can
-  // also be NULL in which case it will not be added to the list. Does
-  // nothing if the previous and the current listener objects are the same.
-  void SetDefaultResultPrinter(TestEventListener* listener);
-
-  // Sets the default_xml_generator attribute to the provided listener.  The
-  // listener is also added to the listener list and previous
-  // default_xml_generator is removed from it and deleted. The listener can
-  // also be NULL in which case it will not be added to the list. Does
-  // nothing if the previous and the current listener objects are the same.
-  void SetDefaultXmlGenerator(TestEventListener* listener);
-
-  // Controls whether events will be forwarded by the repeater to the
-  // listeners in the list.
-  bool EventForwardingEnabled() const;
-  void SuppressEventForwarding();
-
-  // The actual list of listeners.
-  internal::TestEventRepeater* repeater_;
-  // Listener responsible for the standard result output.
-  TestEventListener* default_result_printer_;
-  // Listener responsible for the creation of the XML output file.
-  TestEventListener* default_xml_generator_;
-
-  // We disallow copying TestEventListeners.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
-};
-
-// A UnitTest consists of a vector of TestSuites.
-//
-// This is a singleton class.  The only instance of UnitTest is
-// created when UnitTest::GetInstance() is first called.  This
-// instance is never deleted.
-//
-// UnitTest is not copyable.
-//
-// This class is thread-safe as long as the methods are called
-// according to their specification.
-class GTEST_API_ UnitTest {
- public:
-  // Gets the singleton UnitTest object.  The first time this method
-  // is called, a UnitTest object is constructed and returned.
-  // Consecutive calls will return the same object.
-  static UnitTest* GetInstance();
-
-  // Runs all tests in this UnitTest object and prints the result.
-  // Returns 0 if successful, or 1 otherwise.
-  //
-  // This method can only be called from the main thread.
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  int Run() GTEST_MUST_USE_RESULT_;
-
-  // Returns the working directory when the first TEST() or TEST_F()
-  // was executed.  The UnitTest object owns the string.
-  const char* original_working_dir() const;
-
-  // Returns the TestSuite object for the test that's currently running,
-  // or NULL if no test is running.
-  const TestSuite* current_test_suite() const GTEST_LOCK_EXCLUDED_(mutex_);
-
-// Legacy API is still available but deprecated
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_);
-#endif
-
-  // Returns the TestInfo object for the test that's currently running,
-  // or NULL if no test is running.
-  const TestInfo* current_test_info() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Returns the random seed used at the start of the current test run.
-  int random_seed() const;
-
-  // Returns the ParameterizedTestSuiteRegistry object used to keep track of
-  // value-parameterized tests and instantiate and register them.
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Gets the number of successful test suites.
-  int successful_test_suite_count() const;
-
-  // Gets the number of failed test suites.
-  int failed_test_suite_count() const;
-
-  // Gets the number of all test suites.
-  int total_test_suite_count() const;
-
-  // Gets the number of all test suites that contain at least one test
-  // that should run.
-  int test_suite_to_run_count() const;
-
-  //  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  int successful_test_case_count() const;
-  int failed_test_case_count() const;
-  int total_test_case_count() const;
-  int test_case_to_run_count() const;
-#endif  //  EMOVE_LEGACY_TEST_CASEAPI
-
-  // Gets the number of successful tests.
-  int successful_test_count() const;
-
-  // Gets the number of skipped tests.
-  int skipped_test_count() const;
-
-  // Gets the number of failed tests.
-  int failed_test_count() const;
-
-  // Gets the number of disabled tests that will be reported in the XML report.
-  int reportable_disabled_test_count() const;
-
-  // Gets the number of disabled tests.
-  int disabled_test_count() const;
-
-  // Gets the number of tests to be printed in the XML report.
-  int reportable_test_count() const;
-
-  // Gets the number of all tests.
-  int total_test_count() const;
-
-  // Gets the number of tests that should run.
-  int test_to_run_count() const;
-
-  // Gets the time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp() const;
-
-  // Gets the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const;
-
-  // Returns true iff the unit test passed (i.e. all test suites passed).
-  bool Passed() const;
-
-  // Returns true iff the unit test failed (i.e. some test suite failed
-  // or something outside of all tests failed).
-  bool Failed() const;
-
-  // Gets the i-th test suite among all the test suites. i can range from 0 to
-  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
-  const TestSuite* GetTestSuite(int i) const;
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  const TestCase* GetTestCase(int i) const;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  // Returns the TestResult containing information on test failures and
-  // properties logged outside of individual test suites.
-  const TestResult& ad_hoc_test_result() const;
-
-  // Returns the list of event listeners that can be used to track events
-  // inside Google Test.
-  TestEventListeners& listeners();
-
- private:
-  // Registers and returns a global test environment.  When a test
-  // program is run, all global test environments will be set-up in
-  // the order they were registered.  After all tests in the program
-  // have finished, all global test environments will be torn-down in
-  // the *reverse* order they were registered.
-  //
-  // The UnitTest object takes ownership of the given environment.
-  //
-  // This method can only be called from the main thread.
-  Environment* AddEnvironment(Environment* env);
-
-  // Adds a TestPartResult to the current TestResult object.  All
-  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
-  // eventually call this to report their results.  The user code
-  // should use the assertion macros instead of calling this directly.
-  void AddTestPartResult(TestPartResult::Type result_type,
-                         const char* file_name,
-                         int line_number,
-                         const std::string& message,
-                         const std::string& os_stack_trace)
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Adds a TestProperty to the current TestResult object when invoked from
-  // inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
-  // from SetUpTestSuite or TearDownTestSuite, or to the global property set
-  // when invoked elsewhere.  If the result already contains a property with
-  // the same key, the value will be updated.
-  void RecordProperty(const std::string& key, const std::string& value);
-
-  // Gets the i-th test suite among all the test suites. i can range from 0 to
-  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
-  TestSuite* GetMutableTestSuite(int i);
-
-  // Accessors for the implementation object.
-  internal::UnitTestImpl* impl() { return impl_; }
-  const internal::UnitTestImpl* impl() const { return impl_; }
-
-  // These classes and functions are friends as they need to access private
-  // members of UnitTest.
-  friend class ScopedTrace;
-  friend class Test;
-  friend class internal::AssertHelper;
-  friend class internal::StreamingListenerTest;
-  friend class internal::UnitTestRecordPropertyTestHelper;
-  friend Environment* AddGlobalTestEnvironment(Environment* env);
-  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
-  friend void internal::ReportFailureInUnknownLocation(
-      TestPartResult::Type result_type,
-      const std::string& message);
-
-  // Creates an empty UnitTest.
-  UnitTest();
-
-  // D'tor
-  virtual ~UnitTest();
-
-  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
-  // Google Test trace stack.
-  void PushGTestTrace(const internal::TraceInfo& trace)
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Pops a trace from the per-thread Google Test trace stack.
-  void PopGTestTrace()
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Protects mutable state in *impl_.  This is mutable as some const
-  // methods need to lock it too.
-  mutable internal::Mutex mutex_;
-
-  // Opaque implementation object.  This field is never changed once
-  // the object is constructed.  We don't mark it as const here, as
-  // doing so will cause a warning in the constructor of UnitTest.
-  // Mutable state in *impl_ is protected by mutex_.
-  internal::UnitTestImpl* impl_;
-
-  // We disallow copying UnitTest.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
-};
-
-// A convenient wrapper for adding an environment for the test
-// program.
-//
-// You should call this before RUN_ALL_TESTS() is called, probably in
-// main().  If you use gtest_main, you need to call this before main()
-// starts for it to take effect.  For example, you can define a global
-// variable like this:
-//
-//   testing::Environment* const foo_env =
-//       testing::AddGlobalTestEnvironment(new FooEnvironment);
-//
-// However, we strongly recommend you to write your own main() and
-// call AddGlobalTestEnvironment() there, as relying on initialization
-// of global variables makes the code harder to read and may cause
-// problems when you register multiple environments from different
-// translation units and the environments have dependencies among them
-// (remember that the compiler doesn't guarantee the order in which
-// global variables from different translation units are initialized).
-inline Environment* AddGlobalTestEnvironment(Environment* env) {
-  return UnitTest::GetInstance()->AddEnvironment(env);
-}
-
-// Initializes Google Test.  This must be called before calling
-// RUN_ALL_TESTS().  In particular, it parses a command line for the
-// flags that Google Test recognizes.  Whenever a Google Test flag is
-// seen, it is removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Test flag variables are
-// updated.
-//
-// Calling the function for the second time has no user-visible effect.
-GTEST_API_ void InitGoogleTest(int* argc, char** argv);
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
-
-// This overloaded version can be used on Arduino/embedded platforms where
-// there is no argc/argv.
-GTEST_API_ void InitGoogleTest();
-
-namespace internal {
-
-// Separate the error generating code from the code path to reduce the stack
-// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
-// when calling EXPECT_* in a tight loop.
-template <typename T1, typename T2>
-AssertionResult CmpHelperEQFailure(const char* lhs_expression,
-                                   const char* rhs_expression,
-                                   const T1& lhs, const T2& rhs) {
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   FormatForComparisonFailureMessage(lhs, rhs),
-                   FormatForComparisonFailureMessage(rhs, lhs),
-                   false);
-}
-
-// This block of code defines operator==/!=
-// to block lexical scope lookup.
-// It prevents using invalid operator==/!= defined at namespace scope.
-struct faketype {};
-inline bool operator==(faketype, faketype) { return true; }
-inline bool operator!=(faketype, faketype) { return false; }
-
-// The helper function for {ASSERT|EXPECT}_EQ.
-template <typename T1, typename T2>
-AssertionResult CmpHelperEQ(const char* lhs_expression,
-                            const char* rhs_expression,
-                            const T1& lhs,
-                            const T2& rhs) {
-  if (lhs == rhs) {
-    return AssertionSuccess();
-  }
-
-  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
-}
-
-// With this overloaded version, we allow anonymous enums to be used
-// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
-// can be implicitly cast to BiggestInt.
-GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression,
-                                       const char* rhs_expression,
-                                       BiggestInt lhs,
-                                       BiggestInt rhs);
-
-class EqHelper {
- public:
-  // This templatized version is for the general case.
-  template <
-      typename T1, typename T2,
-      // Disable this overload for cases where one argument is a pointer
-      // and the other is the null pointer constant.
-      typename std::enable_if<!std::is_integral<T1>::value ||
-                              !std::is_pointer<T2>::value>::type* = nullptr>
-  static AssertionResult Compare(const char* lhs_expression,
-                                 const char* rhs_expression, const T1& lhs,
-                                 const T2& rhs) {
-    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
-  }
-
-  // With this overloaded version, we allow anonymous enums to be used
-  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
-  // enums can be implicitly cast to BiggestInt.
-  //
-  // Even though its body looks the same as the above version, we
-  // cannot merge the two, as it will make anonymous enums unhappy.
-  static AssertionResult Compare(const char* lhs_expression,
-                                 const char* rhs_expression,
-                                 BiggestInt lhs,
-                                 BiggestInt rhs) {
-    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
-  }
-
-  template <typename T>
-  static AssertionResult Compare(
-      const char* lhs_expression, const char* rhs_expression,
-      // Handle cases where '0' is used as a null pointer literal.
-      std::nullptr_t /* lhs */, T* rhs) {
-    // We already know that 'lhs' is a null pointer.
-    return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
-                       rhs);
-  }
-};
-
-// Separate the error generating code from the code path to reduce the stack
-// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
-// when calling EXPECT_OP in a tight loop.
-template <typename T1, typename T2>
-AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
-                                   const T1& val1, const T2& val2,
-                                   const char* op) {
-  return AssertionFailure()
-         << "Expected: (" << expr1 << ") " << op << " (" << expr2
-         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
-         << " vs " << FormatForComparisonFailureMessage(val2, val1);
-}
-
-// A macro for implementing the helper functions needed to implement
-// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
-// of similar code.
-//
-// For each templatized helper function, we also define an overloaded
-// version for BiggestInt in order to reduce code bloat and allow
-// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
-// with gcc 4.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
-template <typename T1, typename T2>\
-AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
-                                   const T1& val1, const T2& val2) {\
-  if (val1 op val2) {\
-    return AssertionSuccess();\
-  } else {\
-    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
-  }\
-}\
-GTEST_API_ AssertionResult CmpHelper##op_name(\
-    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-// Implements the helper function for {ASSERT|EXPECT}_NE
-GTEST_IMPL_CMP_HELPER_(NE, !=);
-// Implements the helper function for {ASSERT|EXPECT}_LE
-GTEST_IMPL_CMP_HELPER_(LE, <=);
-// Implements the helper function for {ASSERT|EXPECT}_LT
-GTEST_IMPL_CMP_HELPER_(LT, <);
-// Implements the helper function for {ASSERT|EXPECT}_GE
-GTEST_IMPL_CMP_HELPER_(GE, >=);
-// Implements the helper function for {ASSERT|EXPECT}_GT
-GTEST_IMPL_CMP_HELPER_(GT, >);
-
-#undef GTEST_IMPL_CMP_HELPER_
-
-// The helper function for {ASSERT|EXPECT}_STREQ.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const char* s1,
-                                          const char* s2);
-
-// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
-                                              const char* s2_expression,
-                                              const char* s1,
-                                              const char* s2);
-
-// The helper function for {ASSERT|EXPECT}_STRNE.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const char* s1,
-                                          const char* s2);
-
-// The helper function for {ASSERT|EXPECT}_STRCASENE.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
-                                              const char* s2_expression,
-                                              const char* s1,
-                                              const char* s2);
-
-
-// Helper function for *_STREQ on wide strings.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const wchar_t* s1,
-                                          const wchar_t* s2);
-
-// Helper function for *_STRNE on wide strings.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const wchar_t* s1,
-                                          const wchar_t* s2);
-
-}  // namespace internal
-
-// IsSubstring() and IsNotSubstring() are intended to be used as the
-// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
-// themselves.  They check whether needle is a substring of haystack
-// (NULL is considered a substring of itself only), and return an
-// appropriate error message when they fail.
-//
-// The {needle,haystack}_expr arguments are the stringified
-// expressions that generated the two real arguments.
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack);
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack);
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack);
-
-#if GTEST_HAS_STD_WSTRING
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack);
-#endif  // GTEST_HAS_STD_WSTRING
-
-namespace internal {
-
-// Helper template function for comparing floating-points.
-//
-// Template parameter:
-//
-//   RawType: the raw floating-point type (either float or double)
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-template <typename RawType>
-AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
-                                         const char* rhs_expression,
-                                         RawType lhs_value,
-                                         RawType rhs_value) {
-  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
-
-  if (lhs.AlmostEquals(rhs)) {
-    return AssertionSuccess();
-  }
-
-  ::std::stringstream lhs_ss;
-  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-         << lhs_value;
-
-  ::std::stringstream rhs_ss;
-  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-         << rhs_value;
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   StringStreamToString(&lhs_ss),
-                   StringStreamToString(&rhs_ss),
-                   false);
-}
-
-// Helper function for implementing ASSERT_NEAR.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
-                                                const char* expr2,
-                                                const char* abs_error_expr,
-                                                double val1,
-                                                double val2,
-                                                double abs_error);
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-// A class that enables one to stream messages to assertion macros
-class GTEST_API_ AssertHelper {
- public:
-  // Constructor.
-  AssertHelper(TestPartResult::Type type,
-               const char* file,
-               int line,
-               const char* message);
-  ~AssertHelper();
-
-  // Message assignment is a semantic trick to enable assertion
-  // streaming; see the GTEST_MESSAGE_ macro below.
-  void operator=(const Message& message) const;
-
- private:
-  // We put our data in a struct so that the size of the AssertHelper class can
-  // be as small as possible.  This is important because gcc is incapable of
-  // re-using stack space even for temporary variables, so every EXPECT_EQ
-  // reserves stack space for another AssertHelper.
-  struct AssertHelperData {
-    AssertHelperData(TestPartResult::Type t,
-                     const char* srcfile,
-                     int line_num,
-                     const char* msg)
-        : type(t), file(srcfile), line(line_num), message(msg) { }
-
-    TestPartResult::Type const type;
-    const char* const file;
-    int const line;
-    std::string const message;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
-  };
-
-  AssertHelperData* const data_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
-};
-
-enum GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW };
-
-GTEST_API_ GTEST_ATTRIBUTE_PRINTF_(2, 3) void ColoredPrintf(GTestColor color,
-                                                            const char* fmt,
-                                                            ...);
-
-}  // namespace internal
-
-// The pure interface class that all value-parameterized tests inherit from.
-// A value-parameterized class must inherit from both ::testing::Test and
-// ::testing::WithParamInterface. In most cases that just means inheriting
-// from ::testing::TestWithParam, but more complicated test hierarchies
-// may need to inherit from Test and WithParamInterface at different levels.
-//
-// This interface has support for accessing the test parameter value via
-// the GetParam() method.
-//
-// Use it with one of the parameter generator defining functions, like Range(),
-// Values(), ValuesIn(), Bool(), and Combine().
-//
-// class FooTest : public ::testing::TestWithParam<int> {
-//  protected:
-//   FooTest() {
-//     // Can use GetParam() here.
-//   }
-//   ~FooTest() override {
-//     // Can use GetParam() here.
-//   }
-//   void SetUp() override {
-//     // Can use GetParam() here.
-//   }
-//   void TearDown override {
-//     // Can use GetParam() here.
-//   }
-// };
-// TEST_P(FooTest, DoesBar) {
-//   // Can use GetParam() method here.
-//   Foo foo;
-//   ASSERT_TRUE(foo.DoesBar(GetParam()));
-// }
-// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
-
-template <typename T>
-class WithParamInterface {
- public:
-  typedef T ParamType;
-  virtual ~WithParamInterface() {}
-
-  // The current parameter value. Is also available in the test fixture's
-  // constructor.
-  static const ParamType& GetParam() {
-    GTEST_CHECK_(parameter_ != nullptr)
-        << "GetParam() can only be called inside a value-parameterized test "
-        << "-- did you intend to write TEST_P instead of TEST_F?";
-    return *parameter_;
-  }
-
- private:
-  // Sets parameter value. The caller is responsible for making sure the value
-  // remains alive and unchanged throughout the current test.
-  static void SetParam(const ParamType* parameter) {
-    parameter_ = parameter;
-  }
-
-  // Static value used for accessing parameter during a test lifetime.
-  static const ParamType* parameter_;
-
-  // TestClass must be a subclass of WithParamInterface<T> and Test.
-  template <class TestClass> friend class internal::ParameterizedTestFactory;
-};
-
-template <typename T>
-const T* WithParamInterface<T>::parameter_ = nullptr;
-
-// Most value-parameterized classes can ignore the existence of
-// WithParamInterface, and can just inherit from ::testing::TestWithParam.
-
-template <typename T>
-class TestWithParam : public Test, public WithParamInterface<T> {
-};
-
-// Macros for indicating success/failure in test code.
-
-// Skips test in runtime.
-// Skipping test aborts current function.
-// Skipped tests are neither successful nor failed.
-#define GTEST_SKIP() GTEST_SKIP_("Skipped")
-
-// ADD_FAILURE unconditionally adds a failure to the current test.
-// SUCCEED generates a success - it doesn't automatically make the
-// current test successful, as a test is only successful when it has
-// no failure.
-//
-// EXPECT_* verifies that a certain condition is satisfied.  If not,
-// it behaves like ADD_FAILURE.  In particular:
-//
-//   EXPECT_TRUE  verifies that a Boolean condition is true.
-//   EXPECT_FALSE verifies that a Boolean condition is false.
-//
-// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
-// that they will also abort the current function on failure.  People
-// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
-// writing data-driven tests often find themselves using ADD_FAILURE
-// and EXPECT_* more.
-
-// Generates a nonfatal failure with a generic message.
-#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
-
-// Generates a nonfatal failure at the given source file location with
-// a generic message.
-#define ADD_FAILURE_AT(file, line) \
-  GTEST_MESSAGE_AT_(file, line, "Failed", \
-                    ::testing::TestPartResult::kNonFatalFailure)
-
-// Generates a fatal failure with a generic message.
-#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
-
-// Define this macro to 1 to omit the definition of FAIL(), which is a
-// generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_FAIL
-# define FAIL() GTEST_FAIL()
-#endif
-
-// Generates a success with a generic message.
-#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
-
-// Define this macro to 1 to omit the definition of SUCCEED(), which
-// is a generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_SUCCEED
-# define SUCCEED() GTEST_SUCCEED()
-#endif
-
-// Macros for testing exceptions.
-//
-//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
-//         Tests that the statement throws the expected exception.
-//    * {ASSERT|EXPECT}_NO_THROW(statement):
-//         Tests that the statement doesn't throw any exception.
-//    * {ASSERT|EXPECT}_ANY_THROW(statement):
-//         Tests that the statement throws an exception.
-
-#define EXPECT_THROW(statement, expected_exception) \
-  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_NO_THROW(statement) \
-  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_ANY_THROW(statement) \
-  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_THROW(statement, expected_exception) \
-  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
-#define ASSERT_NO_THROW(statement) \
-  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
-#define ASSERT_ANY_THROW(statement) \
-  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
-
-// Boolean assertions. Condition can be either a Boolean expression or an
-// AssertionResult. For more information on how to use AssertionResult with
-// these macros see comments on that class.
-#define EXPECT_TRUE(condition) \
-  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
-                      GTEST_NONFATAL_FAILURE_)
-#define EXPECT_FALSE(condition) \
-  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
-                      GTEST_NONFATAL_FAILURE_)
-#define ASSERT_TRUE(condition) \
-  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
-                      GTEST_FATAL_FAILURE_)
-#define ASSERT_FALSE(condition) \
-  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
-                      GTEST_FATAL_FAILURE_)
-
-// Macros for testing equalities and inequalities.
-//
-//    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
-//    * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
-//    * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
-//    * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
-//    * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
-//    * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
-//
-// When they are not, Google Test prints both the tested expressions and
-// their actual values.  The values must be compatible built-in types,
-// or you will get a compiler error.  By "compatible" we mean that the
-// values can be compared by the respective operator.
-//
-// Note:
-//
-//   1. It is possible to make a user-defined type work with
-//   {ASSERT|EXPECT}_??(), but that requires overloading the
-//   comparison operators and is thus discouraged by the Google C++
-//   Usage Guide.  Therefore, you are advised to use the
-//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
-//   equal.
-//
-//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
-//   pointers (in particular, C strings).  Therefore, if you use it
-//   with two C strings, you are testing how their locations in memory
-//   are related, not how their content is related.  To compare two C
-//   strings by content, use {ASSERT|EXPECT}_STR*().
-//
-//   3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to
-//   {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you
-//   what the actual value is when it fails, and similarly for the
-//   other comparisons.
-//
-//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
-//   evaluate their arguments, which is undefined.
-//
-//   5. These macros evaluate their arguments exactly once.
-//
-// Examples:
-//
-//   EXPECT_NE(Foo(), 5);
-//   EXPECT_EQ(a_pointer, NULL);
-//   ASSERT_LT(i, array_size);
-//   ASSERT_GT(records.size(), 0) << "There is no record left.";
-
-#define EXPECT_EQ(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
-#define EXPECT_NE(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
-#define EXPECT_LE(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
-#define EXPECT_LT(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
-#define EXPECT_GE(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
-#define EXPECT_GT(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
-
-#define GTEST_ASSERT_EQ(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
-#define GTEST_ASSERT_NE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
-#define GTEST_ASSERT_LE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
-#define GTEST_ASSERT_LT(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
-#define GTEST_ASSERT_GE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
-#define GTEST_ASSERT_GT(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
-
-// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
-// ASSERT_XY(), which clashes with some users' own code.
-
-#if !GTEST_DONT_DEFINE_ASSERT_EQ
-# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_NE
-# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_LE
-# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_LT
-# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_GE
-# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_GT
-# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
-#endif
-
-// C-string Comparisons.  All tests treat NULL and any non-NULL string
-// as different.  Two NULLs are equal.
-//
-//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
-//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
-//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
-//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
-//
-// For wide or narrow string objects, you can use the
-// {ASSERT|EXPECT}_??() macros.
-//
-// Don't depend on the order in which the arguments are evaluated,
-// which is undefined.
-//
-// These macros evaluate their arguments exactly once.
-
-#define EXPECT_STREQ(s1, s2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
-#define EXPECT_STRNE(s1, s2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
-#define EXPECT_STRCASEEQ(s1, s2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
-#define EXPECT_STRCASENE(s1, s2)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
-
-#define ASSERT_STREQ(s1, s2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
-#define ASSERT_STRNE(s1, s2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
-#define ASSERT_STRCASEEQ(s1, s2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
-#define ASSERT_STRCASENE(s1, s2)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
-
-// Macros for comparing floating-point numbers.
-//
-//    * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2):
-//         Tests that two float values are almost equal.
-//    * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2):
-//         Tests that two double values are almost equal.
-//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
-//         Tests that v1 and v2 are within the given distance to each other.
-//
-// Google Test uses ULP-based comparison to automatically pick a default
-// error bound that is appropriate for the operands.  See the
-// FloatingPoint template class in gtest-internal.h if you are
-// interested in the implementation details.
-
-#define EXPECT_FLOAT_EQ(val1, val2)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
-                      val1, val2)
-
-#define EXPECT_DOUBLE_EQ(val1, val2)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
-                      val1, val2)
-
-#define ASSERT_FLOAT_EQ(val1, val2)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
-                      val1, val2)
-
-#define ASSERT_DOUBLE_EQ(val1, val2)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
-                      val1, val2)
-
-#define EXPECT_NEAR(val1, val2, abs_error)\
-  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
-                      val1, val2, abs_error)
-
-#define ASSERT_NEAR(val1, val2, abs_error)\
-  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
-                      val1, val2, abs_error)
-
-// These predicate format functions work on floating-point values, and
-// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
-//
-//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
-                                   float val1, float val2);
-GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
-                                    double val1, double val2);
-
-
-#if GTEST_OS_WINDOWS
-
-// Macros that test for HRESULT failure and success, these are only useful
-// on Windows, and rely on Windows SDK macros and APIs to compile.
-//
-//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
-//
-// When expr unexpectedly fails or succeeds, Google Test prints the
-// expected result and the actual result with both a human-readable
-// string representation of the error, if available, as well as the
-// hex result code.
-# define EXPECT_HRESULT_SUCCEEDED(expr) \
-    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
-
-# define ASSERT_HRESULT_SUCCEEDED(expr) \
-    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
-
-# define EXPECT_HRESULT_FAILED(expr) \
-    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
-
-# define ASSERT_HRESULT_FAILED(expr) \
-    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
-
-#endif  // GTEST_OS_WINDOWS
-
-// Macros that execute statement and check that it doesn't generate new fatal
-// failures in the current thread.
-//
-//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
-//
-// Examples:
-//
-//   EXPECT_NO_FATAL_FAILURE(Process());
-//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
-//
-#define ASSERT_NO_FATAL_FAILURE(statement) \
-    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
-#define EXPECT_NO_FATAL_FAILURE(statement) \
-    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
-
-// Causes a trace (including the given source file path and line number,
-// and the given message) to be included in every test failure message generated
-// by code in the scope of the lifetime of an instance of this class. The effect
-// is undone with the destruction of the instance.
-//
-// The message argument can be anything streamable to std::ostream.
-//
-// Example:
-//   testing::ScopedTrace trace("file.cc", 123, "message");
-//
-class GTEST_API_ ScopedTrace {
- public:
-  // The c'tor pushes the given source file location and message onto
-  // a trace stack maintained by Google Test.
-
-  // Template version. Uses Message() to convert the values into strings.
-  // Slow, but flexible.
-  template <typename T>
-  ScopedTrace(const char* file, int line, const T& message) {
-    PushTrace(file, line, (Message() << message).GetString());
-  }
-
-  // Optimize for some known types.
-  ScopedTrace(const char* file, int line, const char* message) {
-    PushTrace(file, line, message ? message : "(null)");
-  }
-
-  ScopedTrace(const char* file, int line, const std::string& message) {
-    PushTrace(file, line, message);
-  }
-
-  // The d'tor pops the info pushed by the c'tor.
-  //
-  // Note that the d'tor is not virtual in order to be efficient.
-  // Don't inherit from ScopedTrace!
-  ~ScopedTrace();
-
- private:
-  void PushTrace(const char* file, int line, std::string message);
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
-} GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
-                            // c'tor and d'tor.  Therefore it doesn't
-                            // need to be used otherwise.
-
-// Causes a trace (including the source file path, the current line
-// number, and the given message) to be included in every test failure
-// message generated by code in the current scope.  The effect is
-// undone when the control leaves the current scope.
-//
-// The message argument can be anything streamable to std::ostream.
-//
-// In the implementation, we include the current line number as part
-// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
-// to appear in the same block - as long as they are on different
-// lines.
-//
-// Assuming that each thread maintains its own stack of traces.
-// Therefore, a SCOPED_TRACE() would (correctly) only affect the
-// assertions in its own thread.
-#define SCOPED_TRACE(message) \
-  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
-    __FILE__, __LINE__, (message))
-
-
-// Compile-time assertion for type equality.
-// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
-// the same type.  The value it returns is not interesting.
-//
-// Instead of making StaticAssertTypeEq a class template, we make it a
-// function template that invokes a helper class template.  This
-// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
-// defining objects of that type.
-//
-// CAVEAT:
-//
-// When used inside a method of a class template,
-// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
-// instantiated.  For example, given:
-//
-//   template <typename T> class Foo {
-//    public:
-//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
-//   };
-//
-// the code:
-//
-//   void Test1() { Foo<bool> foo; }
-//
-// will NOT generate a compiler error, as Foo<bool>::Bar() is never
-// actually instantiated.  Instead, you need:
-//
-//   void Test2() { Foo<bool> foo; foo.Bar(); }
-//
-// to cause a compiler error.
-template <typename T1, typename T2>
-bool StaticAssertTypeEq() {
-  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
-  return true;
-}
-
-// Defines a test.
-//
-// The first parameter is the name of the test suite, and the second
-// parameter is the name of the test within the test suite.
-//
-// The convention is to end the test suite name with "Test".  For
-// example, a test suite for the Foo class can be named FooTest.
-//
-// Test code should appear between braces after an invocation of
-// this macro.  Example:
-//
-//   TEST(FooTest, InitializesCorrectly) {
-//     Foo foo;
-//     EXPECT_TRUE(foo.StatusIsOK());
-//   }
-
-// Note that we call GetTestTypeId() instead of GetTypeId<
-// ::testing::Test>() here to get the type ID of testing::Test.  This
-// is to work around a suspected linker bug when using Google Test as
-// a framework on Mac OS X.  The bug causes GetTypeId<
-// ::testing::Test>() to return different values depending on whether
-// the call is from the Google Test framework itself or from user test
-// code.  GetTestTypeId() is guaranteed to always return the same
-// value, as it always calls GetTypeId<>() from the Google Test
-// framework.
-#define GTEST_TEST(test_suite_name, test_name)             \
-  GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
-              ::testing::internal::GetTestTypeId())
-
-// Define this macro to 1 to omit the definition of TEST(), which
-// is a generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_TEST
-#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
-#endif
-
-// Defines a test that uses a test fixture.
-//
-// The first parameter is the name of the test fixture class, which
-// also doubles as the test suite name.  The second parameter is the
-// name of the test within the test suite.
-//
-// A test fixture class must be declared earlier.  The user should put
-// the test code between braces after using this macro.  Example:
-//
-//   class FooTest : public testing::Test {
-//    protected:
-//     void SetUp() override { b_.AddElement(3); }
-//
-//     Foo a_;
-//     Foo b_;
-//   };
-//
-//   TEST_F(FooTest, InitializesCorrectly) {
-//     EXPECT_TRUE(a_.StatusIsOK());
-//   }
-//
-//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
-//     EXPECT_EQ(a_.size(), 0);
-//     EXPECT_EQ(b_.size(), 1);
-//   }
-//
-// GOOGLETEST_CM0011 DO NOT DELETE
-#define TEST_F(test_fixture, test_name)\
-  GTEST_TEST_(test_fixture, test_name, test_fixture, \
-              ::testing::internal::GetTypeId<test_fixture>())
-
-// Returns a path to temporary directory.
-// Tries to determine an appropriate directory for the platform.
-GTEST_API_ std::string TempDir();
-
-#ifdef _MSC_VER
-#  pragma warning(pop)
-#endif
-
-// Dynamically registers a test with the framework.
-//
-// This is an advanced API only to be used when the `TEST` macros are
-// insufficient. The macros should be preferred when possible, as they avoid
-// most of the complexity of calling this function.
-//
-// The `factory` argument is a factory callable (move-constructible) object or
-// function pointer that creates a new instance of the Test object. It
-// handles ownership to the caller. The signature of the callable is
-// `Fixture*()`, where `Fixture` is the test fixture class for the test. All
-// tests registered with the same `test_suite_name` must return the same
-// fixture type. This is checked at runtime.
-//
-// The framework will infer the fixture class from the factory and will call
-// the `SetUpTestSuite` and `TearDownTestSuite` for it.
-//
-// Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is
-// undefined.
-//
-// Use case example:
-//
-// class MyFixture : public ::testing::Test {
-//  public:
-//   // All of these optional, just like in regular macro usage.
-//   static void SetUpTestSuite() { ... }
-//   static void TearDownTestSuite() { ... }
-//   void SetUp() override { ... }
-//   void TearDown() override { ... }
-// };
-//
-// class MyTest : public MyFixture {
-//  public:
-//   explicit MyTest(int data) : data_(data) {}
-//   void TestBody() override { ... }
-//
-//  private:
-//   int data_;
-// };
-//
-// void RegisterMyTests(const std::vector<int>& values) {
-//   for (int v : values) {
-//     ::testing::RegisterTest(
-//         "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr,
-//         std::to_string(v).c_str(),
-//         __FILE__, __LINE__,
-//         // Important to use the fixture type as the return type here.
-//         [=]() -> MyFixture* { return new MyTest(v); });
-//   }
-// }
-// ...
-// int main(int argc, char** argv) {
-//   std::vector<int> values_to_test = LoadValuesFromConfig();
-//   RegisterMyTests(values_to_test);
-//   ...
-//   return RUN_ALL_TESTS();
-// }
-//
-template <int&... ExplicitParameterBarrier, typename Factory>
-TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
-                       const char* type_param, const char* value_param,
-                       const char* file, int line, Factory factory) {
-  using TestT = typename std::remove_pointer<decltype(factory())>::type;
-
-  class FactoryImpl : public internal::TestFactoryBase {
-   public:
-    explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
-    Test* CreateTest() override { return factory_(); }
-
-   private:
-    Factory factory_;
-  };
-
-  return internal::MakeAndRegisterTestInfo(
-      test_suite_name, test_name, type_param, value_param,
-      internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
-      internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(),
-      internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(),
-      new FactoryImpl{std::move(factory)});
-}
-
-}  // namespace testing
-
-// Use this function in main() to run all tests.  It returns 0 if all
-// tests are successful, or 1 otherwise.
-//
-// RUN_ALL_TESTS() should be invoked after the command line has been
-// parsed by InitGoogleTest().
-//
-// This function was formerly a macro; thus, it is in the global
-// namespace and has an all-caps name.
-int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
-
-inline int RUN_ALL_TESTS() {
-  return ::testing::UnitTest::GetInstance()->Run();
-}
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
diff --git a/test/cctest/gtest/gtest_main.cc b/test/cctest/gtest/gtest_main.cc
deleted file mode 100644
index 345044407a499a2b0ea69aab464de17390f1a16a..0000000000000000000000000000000000000000
--- a/test/cctest/gtest/gtest_main.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2006, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include <cstdio>
-#include <uv.h>
-#include "gtest.h"
-
-#ifdef ARDUINO
-void setup() {
-  testing::InitGoogleTest();
-}
-
-void loop() { RUN_ALL_TESTS(); }
-
-#else
-
-GTEST_API_ int main(int argc, char **argv) {
-  argv = uv_setup_args(argc, argv);
-  printf("Running main() from %s\n", __FILE__);
-  testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-#endif
diff --git a/test/cctest/node_test_fixture.cc b/test/cctest/node_test_fixture.cc
index 1a50e58dd9e8fa01a54554005f5560a1babc84fc..b6f4af6b9e70e089fbfed3b17bad4d845a56884d 100644
--- a/test/cctest/node_test_fixture.cc
+++ b/test/cctest/node_test_fixture.cc
@@ -1,7 +1,7 @@
 #include "node_test_fixture.h"
 
-ArrayBufferUniquePtr NodeTestFixture::allocator{nullptr, nullptr};
-uv_loop_t NodeTestFixture::current_loop;
-NodePlatformUniquePtr NodeTestFixture::platform;
-TracingAgentUniquePtr NodeTestFixture::tracing_agent;
-bool NodeTestFixture::node_initialized = false;
+ArrayBufferUniquePtr NodeZeroIsolateTestFixture::allocator{nullptr, nullptr};
+uv_loop_t NodeZeroIsolateTestFixture::current_loop;
+NodePlatformUniquePtr NodeZeroIsolateTestFixture::platform;
+TracingAgentUniquePtr NodeZeroIsolateTestFixture::tracing_agent;
+bool NodeZeroIsolateTestFixture::node_initialized = false;
diff --git a/test/cctest/node_test_fixture.h b/test/cctest/node_test_fixture.h
index 903900ac9c94f19374aca339f67fcc57e7821955..86991d505a0018e78e35897a5d5623f539399a23 100644
--- a/test/cctest/node_test_fixture.h
+++ b/test/cctest/node_test_fixture.h
@@ -60,14 +60,13 @@ using ArrayBufferUniquePtr = std::unique_ptr<node::ArrayBufferAllocator,
 using TracingAgentUniquePtr = std::unique_ptr<node::tracing::Agent>;
 using NodePlatformUniquePtr = std::unique_ptr<node::NodePlatform>;
 
-class NodeTestFixture : public ::testing::Test {
+class NodeZeroIsolateTestFixture : public ::testing::Test {
  protected:
   static ArrayBufferUniquePtr allocator;
   static TracingAgentUniquePtr tracing_agent;
   static NodePlatformUniquePtr platform;
   static uv_loop_t current_loop;
   static bool node_initialized;
-  v8::Isolate* isolate_;
 
   static void SetUpTestCase() {
     if (!node_initialized) {
@@ -85,7 +84,7 @@ class NodeTestFixture : public ::testing::Test {
     tracing_agent = std::make_unique<node::tracing::Agent>();
     node::tracing::TraceEventHelper::SetAgent(tracing_agent.get());
     node::tracing::TracingController* tracing_controller =
-            tracing_agent->GetTracingController();
+        tracing_agent->GetTracingController();
     CHECK_EQ(0, uv_loop_init(&current_loop));
     static constexpr int kV8ThreadPoolSize = 4;
     platform.reset(
@@ -106,8 +105,18 @@ class NodeTestFixture : public ::testing::Test {
   void SetUp() override {
     allocator = ArrayBufferUniquePtr(node::CreateArrayBufferAllocator(),
                                      &node::FreeArrayBufferAllocator);
+  }
+};
+
+
+class NodeTestFixture : public NodeZeroIsolateTestFixture {
+ protected:
+  v8::Isolate* isolate_;
+
+  void SetUp() override {
+    NodeZeroIsolateTestFixture::SetUp();
     isolate_ = NewIsolate(allocator.get(), &current_loop, platform.get());
-    CHECK_NE(isolate_, nullptr);
+    CHECK_NOT_NULL(isolate_);
     isolate_->Enter();
   }
 
@@ -117,6 +126,7 @@ class NodeTestFixture : public ::testing::Test {
     platform->UnregisterIsolate(isolate_);
     isolate_->Dispose();
     isolate_ = nullptr;
+    NodeZeroIsolateTestFixture::TearDown();
   }
 };
 
diff --git a/test/cctest/test_base64.cc b/test/cctest/test_base64.cc
index 5e39a1052bc057f7130161f4fc94330994a8e5b6..167e5e27bb05fefa98a826eac59aabb4052deef8 100644
--- a/test/cctest/test_base64.cc
+++ b/test/cctest/test_base64.cc
@@ -1,12 +1,12 @@
-#include "base64.h"
+#include "base64-inl.h"
 
 #include <cstddef>
 #include <cstring>
 
 #include "gtest/gtest.h"
 
-using node::base64_encode;
 using node::base64_decode;
+using node::base64_encode;
 
 TEST(Base64Test, Encode) {
   auto test = [](const char* string, const char* base64_string) {
@@ -44,6 +44,20 @@ TEST(Base64Test, Encode) {
        "IGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLg==");
 }
 
+TEST(Base64Test, EncodeURL) {
+  auto test = [](const char* string, const char* base64_string) {
+    const size_t len = strlen(base64_string);
+    char* const buffer = new char[len + 1];
+    buffer[len] = 0;
+    base64_encode(string, strlen(string), buffer, len, node::Base64Mode::URL);
+    EXPECT_STREQ(base64_string, buffer);
+    delete[] buffer;
+  };
+
+  test("\x68\xd9\x16\x25\x5c\x1e\x40\x92\x2d\xfb", "aNkWJVweQJIt-w");
+  test("\xac\xc7\x93\xaa\x83\x6f\xc3\xe3\x3f\x75", "rMeTqoNvw-M_dQ");
+}
+
 TEST(Base64Test, Decode) {
   auto test = [](const char* base64_string, const char* string) {
     const size_t len = strlen(string);
@@ -75,6 +89,7 @@ TEST(Base64Test, Decode) {
   test("YWJj ZGVm", "abcdef");
   test("Y W J j Z G V m", "abcdef");
   test("Y   W\n JjZ \nG Vm", "abcdef");
+  test("rMeTqoNvw-M_dQ", "\xac\xc7\x93\xaa\x83\x6f\xc3\xe3\x3f\x75");
 
   const char* text =
       "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do "
diff --git a/test/cctest/test_environment.cc b/test/cctest/test_environment.cc
index 7e6e665ee4f62bf25b835546c25ae9e5318f4d21..0dc789b0a79914d1b257c695710a63d457ac3eb5 100644
--- a/test/cctest/test_environment.cc
+++ b/test/cctest/test_environment.cc
@@ -1,13 +1,17 @@
 #include "node_buffer.h"
 #include "node_internals.h"
 #include "libplatform/libplatform.h"
+#include "util.h"
 
 #include <string>
 #include "gtest/gtest.h"
 #include "node_test_fixture.h"
+#include <stdio.h>
+#include <cstdio>
 
 using node::AtExit;
 using node::RunAtExit;
+using node::USE;
 
 static bool called_cb_1 = false;
 static bool called_cb_2 = false;
@@ -66,7 +70,34 @@ TEST_F(EnvironmentTest, EnvironmentWithESMLoader) {
       "})()");
 }
 
+class RedirectStdErr {
+ public:
+  explicit RedirectStdErr(const char* filename) : filename_(filename) {
+    fflush(stderr);
+    fgetpos(stderr, &pos_);
+    fd_ = dup(fileno(stderr));
+    USE(freopen(filename_, "w", stderr));
+  }
+
+  ~RedirectStdErr() {
+    fflush(stderr);
+    dup2(fd_, fileno(stderr));
+    close(fd_);
+    remove(filename_);
+    clearerr(stderr);
+    fsetpos(stderr, &pos_);
+  }
+
+ private:
+  int fd_;
+  fpos_t pos_;
+  const char* filename_;
+};
+
 TEST_F(EnvironmentTest, EnvironmentWithNoESMLoader) {
+  // The following line will cause stderr to get redirected to avoid the
+  // error that would otherwise be printed to the console by this test.
+  RedirectStdErr redirect_scope("environment_test.log");
   const v8::HandleScope handle_scope(isolate_);
   Argv argv;
   Env env {handle_scope, argv, node::EnvironmentFlags::kNoRegisterESMLoader};
@@ -114,8 +145,8 @@ TEST_F(EnvironmentTest, PreExecutionPreparation) {
   v8::Local<v8::Script> script = v8::Script::Compile(
       context,
       v8::String::NewFromOneByte(isolate_,
-                                 reinterpret_cast<const uint8_t*>(run_script),
-                                 v8::NewStringType::kNormal).ToLocalChecked())
+                                 reinterpret_cast<const uint8_t*>(run_script))
+                                 .ToLocalChecked())
       .ToLocalChecked();
   v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
   CHECK(result->IsString());
@@ -140,8 +171,8 @@ TEST_F(EnvironmentTest, LoadEnvironmentWithCallback) {
         context,
         v8::String::NewFromOneByte(
             isolate_,
-            reinterpret_cast<const uint8_t*>("argv0"),
-            v8::NewStringType::kNormal).ToLocalChecked()).ToLocalChecked();
+            reinterpret_cast<const uint8_t*>("argv0"))
+            .ToLocalChecked()).ToLocalChecked();
     CHECK(argv0->IsString());
 
     return info.process_object;
@@ -165,15 +196,15 @@ TEST_F(EnvironmentTest, LoadEnvironmentWithSource) {
       context,
       v8::String::NewFromOneByte(
           isolate_,
-          reinterpret_cast<const uint8_t*>("process"),
-          v8::NewStringType::kNormal).ToLocalChecked())
+          reinterpret_cast<const uint8_t*>("process"))
+          .ToLocalChecked())
           .ToLocalChecked()->IsObject());
   CHECK(main_ret.As<v8::Object>()->Get(
       context,
       v8::String::NewFromOneByte(
           isolate_,
-          reinterpret_cast<const uint8_t*>("require"),
-          v8::NewStringType::kNormal).ToLocalChecked())
+          reinterpret_cast<const uint8_t*>("require"))
+          .ToLocalChecked())
           .ToLocalChecked()->IsFunction());
 }
 
@@ -310,8 +341,8 @@ static void at_exit_js(void* arg) {
   v8::Isolate* isolate = static_cast<v8::Isolate*>(arg);
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Object> obj = v8::Object::New(isolate);
-  assert(!obj.IsEmpty());  // Assert VM is still alive.
-  assert(obj->IsObject());
+  EXPECT_FALSE(obj.IsEmpty());  // Assert VM is still alive.
+  EXPECT_TRUE(obj->IsObject());
   called_at_exit_js = true;
 }
 
@@ -333,7 +364,7 @@ TEST_F(EnvironmentTest, SetImmediateCleanup) {
     (*env)->SetImmediate([&](node::Environment* env_arg) {
       EXPECT_EQ(env_arg, *env);
       called++;
-    });
+    }, node::CallbackFlags::kRefed);
     (*env)->SetImmediate([&](node::Environment* env_arg) {
       EXPECT_EQ(env_arg, *env);
       called_unref++;
@@ -447,7 +478,7 @@ TEST_F(EnvironmentTest, InspectorMultipleEmbeddedEnvironments) {
         node::ArrayBufferAllocator::Create();
     uv_loop_t loop;
     uv_loop_init(&loop);
-    v8::Isolate* isolate = NewIsolate(aba.get(), &loop, data->platform);
+    v8::Isolate* isolate = NewIsolate(aba, &loop, data->platform);
     CHECK_NOT_NULL(isolate);
 
     {
@@ -509,8 +540,8 @@ TEST_F(EnvironmentTest, InspectorMultipleEmbeddedEnvironments) {
           context,
           v8::String::NewFromOneByte(
               isolate_,
-              reinterpret_cast<const uint8_t*>("messageFromWorker"),
-              v8::NewStringType::kNormal).ToLocalChecked())
+              reinterpret_cast<const uint8_t*>("messageFromWorker"))
+              .ToLocalChecked())
               .ToLocalChecked();
   CHECK_EQ(data.extracted_value, 42);
   CHECK_EQ(from_inspector->IntegerValue(context).FromJust(), 42);
@@ -553,9 +584,71 @@ TEST_F(EnvironmentTest, SetImmediateMicrotasks) {
       isolate_->EnqueueMicrotask([](void* arg) {
         ++*static_cast<int*>(arg);
       }, &called);
-    });
+    }, node::CallbackFlags::kRefed);
     uv_run(&current_loop, UV_RUN_DEFAULT);
   }
 
   EXPECT_EQ(called, 1);
 }
+
+#ifndef _WIN32  // No SIGINT on Windows.
+TEST_F(NodeZeroIsolateTestFixture, CtrlCWithOnlySafeTerminationTest) {
+  // We need to go through the whole setup dance here because we want to
+  // set only_terminate_in_safe_scope.
+  // Allocate and initialize Isolate.
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = allocator.get();
+  create_params.only_terminate_in_safe_scope = true;
+  v8::Isolate* isolate = v8::Isolate::Allocate();
+  CHECK_NOT_NULL(isolate);
+  platform->RegisterIsolate(isolate, &current_loop);
+  v8::Isolate::Initialize(isolate, create_params);
+
+  // Try creating Context + IsolateData + Environment.
+  {
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto context = node::NewContext(isolate);
+    CHECK(!context.IsEmpty());
+    v8::Context::Scope context_scope(context);
+
+    std::unique_ptr<node::IsolateData, decltype(&node::FreeIsolateData)>
+      isolate_data{node::CreateIsolateData(isolate,
+                                           &current_loop,
+                                           platform.get()),
+                   node::FreeIsolateData};
+    CHECK(isolate_data);
+
+    std::unique_ptr<node::Environment, decltype(&node::FreeEnvironment)>
+      environment{node::CreateEnvironment(isolate_data.get(),
+                                          context,
+                                          {},
+                                          {}),
+                  node::FreeEnvironment};
+    CHECK(environment);
+    EXPECT_EQ(node::GetEnvironmentIsolateData(environment.get()),
+              isolate_data.get());
+    EXPECT_EQ(node::GetArrayBufferAllocator(isolate_data.get()), nullptr);
+
+    v8::Local<v8::Value> main_ret =
+        node::LoadEnvironment(environment.get(),
+            "'use strict';\n"
+            "const { runInThisContext } = require('vm');\n"
+            "try {\n"
+            "  runInThisContext("
+            "    `process.kill(process.pid, 'SIGINT'); while(true){}`, "
+            "    { breakOnSigint: true });\n"
+            "  return 'unreachable';\n"
+            "} catch (err) {\n"
+            "  return err.code;\n"
+            "}").ToLocalChecked();
+    node::Utf8Value main_ret_str(isolate, main_ret);
+    EXPECT_EQ(std::string(*main_ret_str), "ERR_SCRIPT_EXECUTION_INTERRUPTED");
+  }
+
+  // Cleanup.
+  platform->UnregisterIsolate(isolate);
+  isolate->Dispose();
+}
+#endif  // _WIN32
diff --git a/test/cctest/test_js_native_api_v8.cc b/test/cctest/test_js_native_api_v8.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2d95c86d09d5d59f531579dc7076cc94a2f05d1a
--- /dev/null
+++ b/test/cctest/test_js_native_api_v8.cc
@@ -0,0 +1,102 @@
+#include <stdio.h>
+#include <cstdio>
+#include <string>
+#include "env-inl.h"
+#include "gtest/gtest.h"
+#include "js_native_api_v8.h"
+#include "node_api_internals.h"
+#include "node_binding.h"
+#include "node_test_fixture.h"
+
+namespace v8impl {
+
+using v8::Local;
+using v8::Object;
+
+static napi_env addon_env;
+static uint32_t finalizer_call_count = 0;
+
+class JsNativeApiV8Test : public EnvironmentTestFixture {
+ private:
+  void SetUp() override {
+    EnvironmentTestFixture::SetUp();
+    finalizer_call_count = 0;
+  }
+
+  void TearDown() override { NodeTestFixture::TearDown(); }
+};
+
+TEST_F(JsNativeApiV8Test, Reference) {
+  const v8::HandleScope handle_scope(isolate_);
+  Argv argv;
+
+  napi_ref ref;
+  void* embedder_fields[v8::kEmbedderFieldsInWeakCallback] = {nullptr, nullptr};
+  v8::WeakCallbackInfo<Reference::SecondPassCallParameterRef>::Callback
+      callback;
+  Reference::SecondPassCallParameterRef* parameter = nullptr;
+
+  {
+    Env test_env{handle_scope, argv};
+
+    node::Environment* env = *test_env;
+    node::LoadEnvironment(env, "");
+
+    napi_addon_register_func init = [](napi_env env, napi_value exports) {
+      addon_env = env;
+      return exports;
+    };
+    Local<Object> module_obj = Object::New(isolate_);
+    Local<Object> exports_obj = Object::New(isolate_);
+    napi_module_register_by_symbol(
+        exports_obj, module_obj, env->context(), init);
+    ASSERT_NE(addon_env, nullptr);
+    node_napi_env internal_env = reinterpret_cast<node_napi_env>(addon_env);
+    EXPECT_EQ(internal_env->node_env(), env);
+
+    // Create a new scope to manage the handles.
+    {
+      const v8::HandleScope handle_scope(isolate_);
+      napi_value value;
+      napi_create_object(addon_env, &value);
+      // Create a weak reference;
+      napi_add_finalizer(
+          addon_env,
+          value,
+          nullptr,
+          [](napi_env env, void* finalize_data, void* finalize_hint) {
+            finalizer_call_count++;
+          },
+          nullptr,
+          &ref);
+      parameter = reinterpret_cast<Reference*>(ref)->_secondPassParameter;
+    }
+
+    // We can hardly trigger a non-forced Garbage Collection in a stable way.
+    // Here we just invoke the weak callbacks directly.
+    // The persistant handles should be reset in the weak callback in respect
+    // to the API contract of v8 weak callbacks.
+    v8::WeakCallbackInfo<Reference::SecondPassCallParameterRef> data(
+        reinterpret_cast<v8::Isolate*>(isolate_),
+        parameter,
+        embedder_fields,
+        &callback);
+    Reference::FinalizeCallback(data);
+    EXPECT_EQ(callback, &Reference::SecondPassCallback);
+  }
+  // Env goes out of scope, the environment has been teardown. All node-api ref
+  // trackers should have been destroyed.
+
+  // Now we call the second pass callback to verify the method do not abort with
+  // memory violations.
+  v8::WeakCallbackInfo<Reference::SecondPassCallParameterRef> data(
+      reinterpret_cast<v8::Isolate*>(isolate_),
+      parameter,
+      embedder_fields,
+      nullptr);
+  Reference::SecondPassCallback(data);
+
+  // After Environment Teardown
+  EXPECT_EQ(finalizer_call_count, uint32_t(1));
+}
+}  // namespace v8impl
diff --git a/test/cctest/test_linked_binding.cc b/test/cctest/test_linked_binding.cc
index 6724402c55aef15b9d64326c0c7e580774d3df1f..7e40068b5db79939c09812c3bb3d11c86686ebd7 100644
--- a/test/cctest/test_linked_binding.cc
+++ b/test/cctest/test_linked_binding.cc
@@ -1,5 +1,5 @@
 #include "node_test_fixture.h"
-#include "node_internals.h"  // RunBootstrapping()
+#include "node_api.h"
 
 void InitializeBinding(v8::Local<v8::Object> exports,
                        v8::Local<v8::Value> module,
@@ -9,11 +9,11 @@ void InitializeBinding(v8::Local<v8::Object> exports,
   exports->Set(
       context,
       v8::String::NewFromOneByte(isolate,
-                                 reinterpret_cast<const uint8_t*>("key"),
-                                 v8::NewStringType::kNormal).ToLocalChecked(),
+                                 reinterpret_cast<const uint8_t*>("key"))
+                                 .ToLocalChecked(),
       v8::String::NewFromOneByte(isolate,
-                                 reinterpret_cast<const uint8_t*>("value"),
-                                 v8::NewStringType::kNormal).ToLocalChecked())
+                                 reinterpret_cast<const uint8_t*>("value"))
+                                 .ToLocalChecked())
       .FromJust();
 }
 
@@ -33,8 +33,8 @@ TEST_F(LinkedBindingTest, SimpleTest) {
   v8::Local<v8::Script> script = v8::Script::Compile(
       context,
       v8::String::NewFromOneByte(isolate_,
-                                 reinterpret_cast<const uint8_t*>(run_script),
-                                 v8::NewStringType::kNormal).ToLocalChecked())
+                                 reinterpret_cast<const uint8_t*>(run_script))
+                                 .ToLocalChecked())
       .ToLocalChecked();
   v8::Local<v8::Value> completion_value = script->Run(context).ToLocalChecked();
   v8::String::Utf8Value utf8val(isolate_, completion_value);
@@ -51,11 +51,11 @@ void InitializeLocalBinding(v8::Local<v8::Object> exports,
   exports->Set(
       context,
       v8::String::NewFromOneByte(isolate,
-                                 reinterpret_cast<const uint8_t*>("key"),
-                                 v8::NewStringType::kNormal).ToLocalChecked(),
+                                 reinterpret_cast<const uint8_t*>("key"))
+                                 .ToLocalChecked(),
       v8::String::NewFromOneByte(isolate,
-                                 reinterpret_cast<const uint8_t*>("value"),
-                                 v8::NewStringType::kNormal).ToLocalChecked())
+                                 reinterpret_cast<const uint8_t*>("value"))
+                                 .ToLocalChecked())
       .FromJust();
 }
 
@@ -74,8 +74,8 @@ TEST_F(LinkedBindingTest, LocallyDefinedLinkedBindingTest) {
   v8::Local<v8::Script> script = v8::Script::Compile(
       context,
       v8::String::NewFromOneByte(isolate_,
-                                 reinterpret_cast<const uint8_t*>(run_script),
-                                 v8::NewStringType::kNormal).ToLocalChecked())
+                                 reinterpret_cast<const uint8_t*>(run_script))
+                                 .ToLocalChecked())
       .ToLocalChecked();
   v8::Local<v8::Value> completion_value = script->Run(context).ToLocalChecked();
   v8::String::Utf8Value utf8val(isolate_, completion_value);
@@ -83,3 +83,142 @@ TEST_F(LinkedBindingTest, LocallyDefinedLinkedBindingTest) {
   CHECK_EQ(strcmp(*utf8val, "value"), 0);
   CHECK_EQ(calls, 1);
 }
+
+napi_value InitializeLocalNapiBinding(napi_env env, napi_value exports) {
+  napi_value key, value;
+  CHECK_EQ(
+      napi_create_string_utf8(env, "hello", NAPI_AUTO_LENGTH, &key), napi_ok);
+  CHECK_EQ(
+      napi_create_string_utf8(env, "world", NAPI_AUTO_LENGTH, &value), napi_ok);
+  CHECK_EQ(napi_set_property(env, exports, key, value), napi_ok);
+  return nullptr;
+}
+
+static napi_module local_linked_napi = {
+  NAPI_MODULE_VERSION,
+  node::ModuleFlags::kLinked,
+  nullptr,
+  InitializeLocalNapiBinding,
+  "local_linked_napi",
+  nullptr,
+  {0},
+};
+
+TEST_F(LinkedBindingTest, LocallyDefinedLinkedBindingNapiTest) {
+  const v8::HandleScope handle_scope(isolate_);
+  const Argv argv;
+  Env test_env {handle_scope, argv};
+
+  AddLinkedBinding(*test_env, local_linked_napi);
+
+  v8::Local<v8::Context> context = isolate_->GetCurrentContext();
+
+  const char* run_script =
+      "process._linkedBinding('local_linked_napi').hello";
+  v8::Local<v8::Script> script = v8::Script::Compile(
+      context,
+      v8::String::NewFromOneByte(isolate_,
+                                 reinterpret_cast<const uint8_t*>(run_script))
+                                 .ToLocalChecked())
+      .ToLocalChecked();
+  v8::Local<v8::Value> completion_value = script->Run(context).ToLocalChecked();
+  v8::String::Utf8Value utf8val(isolate_, completion_value);
+  CHECK_NOT_NULL(*utf8val);
+  CHECK_EQ(strcmp(*utf8val, "world"), 0);
+}
+
+napi_value NapiLinkedWithInstanceData(napi_env env, napi_value exports) {
+  int* instance_data = new int(0);
+  CHECK_EQ(
+      napi_set_instance_data(
+          env,
+          instance_data,
+          [](napi_env env, void* data, void* hint) {
+            ++*static_cast<int*>(data);
+          }, nullptr),
+      napi_ok);
+
+  napi_value key, value;
+  CHECK_EQ(
+      napi_create_string_utf8(env, "hello", NAPI_AUTO_LENGTH, &key), napi_ok);
+  CHECK_EQ(
+      napi_create_external(env, instance_data, nullptr, nullptr, &value),
+      napi_ok);
+  CHECK_EQ(napi_set_property(env, exports, key, value), napi_ok);
+  return nullptr;
+}
+
+static napi_module local_linked_napi_id = {
+  NAPI_MODULE_VERSION,
+  node::ModuleFlags::kLinked,
+  nullptr,
+  NapiLinkedWithInstanceData,
+  "local_linked_napi_id",
+  nullptr,
+  {0},
+};
+
+TEST_F(LinkedBindingTest, LocallyDefinedLinkedBindingNapiInstanceDataTest) {
+  const v8::HandleScope handle_scope(isolate_);
+  int* instance_data = nullptr;
+
+  {
+    const Argv argv;
+    Env test_env {handle_scope, argv};
+
+    AddLinkedBinding(*test_env, local_linked_napi_id);
+
+    v8::Local<v8::Context> context = isolate_->GetCurrentContext();
+
+    const char* run_script =
+        "process._linkedBinding('local_linked_napi_id').hello";
+    v8::Local<v8::Script> script = v8::Script::Compile(
+        context,
+        v8::String::NewFromOneByte(isolate_,
+                                   reinterpret_cast<const uint8_t*>(run_script))
+                                   .ToLocalChecked())
+        .ToLocalChecked();
+    v8::Local<v8::Value> completion_value =
+        script->Run(context).ToLocalChecked();
+    CHECK(completion_value->IsExternal());
+    instance_data = static_cast<int*>(
+        completion_value.As<v8::External>()->Value());
+    CHECK_NE(instance_data, nullptr);
+    CHECK_EQ(*instance_data, 0);
+  }
+
+  CHECK_EQ(*instance_data, 1);
+  delete instance_data;
+}
+
+TEST_F(LinkedBindingTest, ManyBindingsTest) {
+  const v8::HandleScope handle_scope(isolate_);
+  const Argv argv;
+  Env test_env {handle_scope, argv};
+
+  int calls = 0;
+  AddLinkedBinding(*test_env, "local_linked1", InitializeLocalBinding, &calls);
+  AddLinkedBinding(*test_env, "local_linked2", InitializeLocalBinding, &calls);
+  AddLinkedBinding(*test_env, "local_linked3", InitializeLocalBinding, &calls);
+  AddLinkedBinding(*test_env, local_linked_napi);  // Add a N-API addon as well.
+  AddLinkedBinding(*test_env, "local_linked4", InitializeLocalBinding, &calls);
+  AddLinkedBinding(*test_env, "local_linked5", InitializeLocalBinding, &calls);
+
+  v8::Local<v8::Context> context = isolate_->GetCurrentContext();
+
+  const char* run_script =
+      "for (let i = 1; i <= 5; i++)process._linkedBinding(`local_linked${i}`);"
+      "process._linkedBinding('local_linked_napi').hello";
+  v8::Local<v8::Script> script = v8::Script::Compile(
+      context,
+      v8::String::NewFromOneByte(isolate_,
+                                 reinterpret_cast<const uint8_t*>(run_script))
+                                 .ToLocalChecked())
+      .ToLocalChecked();
+  v8::Local<v8::Value> completion_value = script->Run(context).ToLocalChecked();
+  v8::String::Utf8Value utf8val(isolate_, completion_value);
+  CHECK_NOT_NULL(*utf8val);
+  CHECK_EQ(strcmp(*utf8val, "world"), 0);
+  CHECK_EQ(calls, 5);
+}
+
diff --git a/test/cctest/test_node_api.cc b/test/cctest/test_node_api.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ad5be52fc8ffcc2ed5d65c1bd003cc75d115d4fd
--- /dev/null
+++ b/test/cctest/test_node_api.cc
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <cstdio>
+#include <string>
+#include "env-inl.h"
+#include "gtest/gtest.h"
+#include "node_api_internals.h"
+#include "node_binding.h"
+#include "node_test_fixture.h"
+
+using v8::Local;
+using v8::Object;
+
+static napi_env addon_env;
+
+class NodeApiTest : public EnvironmentTestFixture {
+ private:
+  void SetUp() override { EnvironmentTestFixture::SetUp(); }
+
+  void TearDown() override { NodeTestFixture::TearDown(); }
+};
+
+TEST_F(NodeApiTest, CreateNodeApiEnv) {
+  const v8::HandleScope handle_scope(isolate_);
+  Argv argv;
+
+  Env test_env{handle_scope, argv};
+
+  node::Environment* env = *test_env;
+  node::LoadEnvironment(env, "");
+
+  napi_addon_register_func init = [](napi_env env, napi_value exports) {
+    addon_env = env;
+    return exports;
+  };
+  Local<Object> module_obj = Object::New(isolate_);
+  Local<Object> exports_obj = Object::New(isolate_);
+  napi_module_register_by_symbol(exports_obj, module_obj, env->context(), init);
+  ASSERT_NE(addon_env, nullptr);
+  node_napi_env internal_env = reinterpret_cast<node_napi_env>(addon_env);
+  EXPECT_EQ(internal_env->node_env(), env);
+}
diff --git a/test/cctest/test_node_postmortem_metadata.cc b/test/cctest/test_node_postmortem_metadata.cc
index 3fb67ecbca265e405e1f1bf059843f3e8a6d9f4f..4cee7db4c8ee5b318d43ad2f91b03fd834acf854 100644
--- a/test/cctest/test_node_postmortem_metadata.cc
+++ b/test/cctest/test_node_postmortem_metadata.cc
@@ -14,6 +14,7 @@ extern uintptr_t
     nodedbg_offset_Environment__handle_wrap_queue___Environment_HandleWrapQueue;
 extern int debug_symbols_generated;
 extern int nodedbg_const_ContextEmbedderIndex__kEnvironment__int;
+extern int nodedbg_const_BaseObject__kInternalFieldCount__int;
 extern uintptr_t
     nodedbg_offset_Environment_HandleWrapQueue__head___ListNode_HandleWrap;
 extern uintptr_t
@@ -68,6 +69,12 @@ TEST_F(DebugSymbolsTest, ContextEmbedderEnvironmentIndex) {
             kEnvironmentIndex);
 }
 
+TEST_F(DebugSymbolsTest, BaseObjectkInternalFieldCount) {
+  int kInternalFieldCount = node::BaseObject::kInternalFieldCount;
+  EXPECT_EQ(nodedbg_const_BaseObject__kInternalFieldCount__int,
+            kInternalFieldCount);
+}
+
 TEST_F(DebugSymbolsTest, ExternalStringDataOffset) {
   EXPECT_EQ(nodedbg_offset_ExternalString__data__uintptr_t,
             NODE_OFF_EXTSTR_DATA);
@@ -89,7 +96,8 @@ TEST_F(DebugSymbolsTest, BaseObjectPersistentHandle) {
   Env env{handle_scope, argv};
 
   v8::Local<v8::ObjectTemplate> obj_templ = v8::ObjectTemplate::New(isolate_);
-  obj_templ->SetInternalFieldCount(1);
+  obj_templ->SetInternalFieldCount(
+      nodedbg_const_BaseObject__kInternalFieldCount__int);
 
   v8::Local<v8::Object> object =
       obj_templ->NewInstance(env.context()).ToLocalChecked();
@@ -139,7 +147,8 @@ TEST_F(DebugSymbolsTest, HandleWrapList) {
   uv_tcp_t handle;
 
   auto obj_template = v8::FunctionTemplate::New(isolate_);
-  obj_template->InstanceTemplate()->SetInternalFieldCount(1);
+  obj_template->InstanceTemplate()->SetInternalFieldCount(
+      nodedbg_const_BaseObject__kInternalFieldCount__int);
 
   v8::Local<v8::Object> object = obj_template->GetFunction(env.context())
                                      .ToLocalChecked()
@@ -171,7 +180,8 @@ TEST_F(DebugSymbolsTest, ReqWrapList) {
   tail = *reinterpret_cast<uintptr_t*>(tail);
 
   auto obj_template = v8::FunctionTemplate::New(isolate_);
-  obj_template->InstanceTemplate()->SetInternalFieldCount(1);
+  obj_template->InstanceTemplate()->SetInternalFieldCount(
+      nodedbg_const_BaseObject__kInternalFieldCount__int);
 
   v8::Local<v8::Object> object = obj_template->GetFunction(env.context())
                                      .ToLocalChecked()
diff --git a/test/cctest/test_platform.cc b/test/cctest/test_platform.cc
index 48e0c7f6d3fbb34a91b3a644350d0907e4f44276..07bea57b314bf0054af056df8d836d0c6ab53576 100644
--- a/test/cctest/test_platform.cc
+++ b/test/cctest/test_platform.cc
@@ -58,6 +58,53 @@ TEST_F(PlatformTest, SkipNewTasksInFlushForegroundTasks) {
   EXPECT_FALSE(platform->FlushForegroundTasks(isolate_));
 }
 
+// Tests the registration of an abstract `IsolatePlatformDelegate` instance as
+// opposed to the more common `uv_loop_s*` version of `RegisterIsolate`.
+TEST_F(NodeZeroIsolateTestFixture, IsolatePlatformDelegateTest) {
+  // Allocate isolate
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = allocator.get();
+  auto isolate = v8::Isolate::Allocate();
+  CHECK_NOT_NULL(isolate);
+
+  // Register *first*, then initialize
+  auto delegate = std::make_shared<node::PerIsolatePlatformData>(
+    isolate,
+    &current_loop);
+  platform->RegisterIsolate(isolate, delegate.get());
+  v8::Isolate::Initialize(isolate, create_params);
+
+  // Try creating Context + IsolateData + Environment
+  {
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto context = node::NewContext(isolate);
+    CHECK(!context.IsEmpty());
+    v8::Context::Scope context_scope(context);
+
+    std::unique_ptr<node::IsolateData, decltype(&node::FreeIsolateData)>
+      isolate_data{node::CreateIsolateData(isolate,
+                                           &current_loop,
+                                           platform.get()),
+                   node::FreeIsolateData};
+    CHECK(isolate_data);
+
+    std::unique_ptr<node::Environment, decltype(&node::FreeEnvironment)>
+      environment{node::CreateEnvironment(isolate_data.get(),
+                                          context,
+                                          0, nullptr,
+                                          0, nullptr),
+                  node::FreeEnvironment};
+    CHECK(environment);
+  }
+
+  // Graceful shutdown
+  delegate->Shutdown();
+  platform->UnregisterIsolate(isolate);
+  isolate->Dispose();
+}
+
 TEST_F(PlatformTest, TracingControllerNullptr) {
   v8::TracingController* orig_controller = node::GetTracingController();
   node::SetTracingController(nullptr);
diff --git a/test/cctest/test_sockaddr.cc b/test/cctest/test_sockaddr.cc
index 8c23463f11d2d1cab966565848864d1536c8ab8c..bd80d59f821e5d5db919fa9726cc0b5d794b4d40 100644
--- a/test/cctest/test_sockaddr.cc
+++ b/test/cctest/test_sockaddr.cc
@@ -2,6 +2,8 @@
 #include "gtest/gtest.h"
 
 using node::SocketAddress;
+using node::SocketAddressBlockList;
+using node::SocketAddressLRU;
 
 TEST(SocketAddress, SocketAddress) {
   CHECK(SocketAddress::is_numeric_host("123.123.123.123"));
@@ -55,3 +57,161 @@ TEST(SocketAddress, SocketAddressIPv6) {
   addr.set_flow_label(12345);
   CHECK_EQ(addr.flow_label(), 12345);
 }
+
+TEST(SocketAddressLRU, SocketAddressLRU) {
+  struct Foo {
+    int c;
+    bool expired;
+  };
+
+  struct FooLRUTraits {
+    using Type = Foo;
+
+    static bool CheckExpired(const SocketAddress& address, const Type& type) {
+      return type.expired;
+    }
+
+    static void Touch(const SocketAddress& address, Type* type) {
+      type->expired = false;
+    }
+  };
+
+  SocketAddressLRU<FooLRUTraits> lru(2);
+
+  sockaddr_storage storage[4];
+
+  SocketAddress::ToSockAddr(AF_INET, "123.123.123.123", 443, &storage[0]);
+  SocketAddress::ToSockAddr(AF_INET, "123.123.123.124", 443, &storage[1]);
+  SocketAddress::ToSockAddr(AF_INET, "123.123.123.125", 443, &storage[2]);
+  SocketAddress::ToSockAddr(AF_INET, "123.123.123.123", 443, &storage[3]);
+
+
+  SocketAddress addr1(reinterpret_cast<const sockaddr*>(&storage[0]));
+  SocketAddress addr2(reinterpret_cast<const sockaddr*>(&storage[1]));
+  SocketAddress addr3(reinterpret_cast<const sockaddr*>(&storage[2]));
+  SocketAddress addr4(reinterpret_cast<const sockaddr*>(&storage[3]));
+
+  Foo* foo = lru.Upsert(addr1);
+  CHECK_NOT_NULL(foo);
+  CHECK_EQ(foo->c, 0);
+  CHECK_EQ(foo->expired, false);
+
+  foo->c = 1;
+  foo->expired = true;
+
+  foo = lru.Upsert(addr1);
+  CHECK_NOT_NULL(lru.Peek(addr1));
+  CHECK_EQ(lru.Peek(addr1), lru.Peek(addr4));
+  CHECK_EQ(lru.Peek(addr1)->c, 1);
+  CHECK_EQ(lru.Peek(addr1)->expired, false);
+  CHECK_EQ(lru.size(), 1);
+
+  foo = lru.Upsert(addr2);
+  foo->c = 2;
+  foo->expired = true;
+  CHECK_NOT_NULL(lru.Peek(addr2));
+  CHECK_EQ(lru.Peek(addr2)->c, 2);
+  CHECK_EQ(lru.size(), 2);
+
+  foo->expired = true;
+
+  foo = lru.Upsert(addr3);
+  foo->c = 3;
+  foo->expired = false;
+  CHECK_NOT_NULL(lru.Peek(addr3));
+  CHECK_EQ(lru.Peek(addr3)->c, 3);
+  CHECK_EQ(lru.size(), 1);
+
+  // addr1 was removed because we exceeded size.
+  // addr2 was removed because it was expired.
+  CHECK_NULL(lru.Peek(addr1));
+  CHECK_NULL(lru.Peek(addr2));
+}
+
+TEST(SocketAddress, Comparison) {
+  sockaddr_storage storage[6];
+
+  SocketAddress::ToSockAddr(AF_INET, "10.0.0.1", 0, &storage[0]);
+  SocketAddress::ToSockAddr(AF_INET, "10.0.0.2", 0, &storage[1]);
+  SocketAddress::ToSockAddr(AF_INET6, "::1", 0, &storage[2]);
+  SocketAddress::ToSockAddr(AF_INET6, "::2", 0, &storage[3]);
+  SocketAddress::ToSockAddr(AF_INET6, "::ffff:10.0.0.1", 0, &storage[4]);
+  SocketAddress::ToSockAddr(AF_INET6, "::ffff:10.0.0.2", 0, &storage[5]);
+
+  SocketAddress addr1(reinterpret_cast<const sockaddr*>(&storage[0]));
+  SocketAddress addr2(reinterpret_cast<const sockaddr*>(&storage[1]));
+  SocketAddress addr3(reinterpret_cast<const sockaddr*>(&storage[2]));
+  SocketAddress addr4(reinterpret_cast<const sockaddr*>(&storage[3]));
+  SocketAddress addr5(reinterpret_cast<const sockaddr*>(&storage[4]));
+  SocketAddress addr6(reinterpret_cast<const sockaddr*>(&storage[5]));
+
+  CHECK_EQ(addr1.compare(addr1), SocketAddress::CompareResult::SAME);
+  CHECK_EQ(addr1.compare(addr2), SocketAddress::CompareResult::LESS_THAN);
+  CHECK_EQ(addr2.compare(addr1), SocketAddress::CompareResult::GREATER_THAN);
+  CHECK(addr1 <= addr1);
+  CHECK(addr1 < addr2);
+  CHECK(addr1 <= addr2);
+  CHECK(addr2 >= addr2);
+  CHECK(addr2 > addr1);
+  CHECK(addr2 >= addr1);
+
+  CHECK_EQ(addr3.compare(addr3), SocketAddress::CompareResult::SAME);
+  CHECK_EQ(addr3.compare(addr4), SocketAddress::CompareResult::LESS_THAN);
+  CHECK_EQ(addr4.compare(addr3), SocketAddress::CompareResult::GREATER_THAN);
+  CHECK(addr3 <= addr3);
+  CHECK(addr3 < addr4);
+  CHECK(addr3 <= addr4);
+  CHECK(addr4 >= addr4);
+  CHECK(addr4 > addr3);
+  CHECK(addr4 >= addr3);
+
+  // Not comparable
+  CHECK_EQ(addr1.compare(addr3), SocketAddress::CompareResult::NOT_COMPARABLE);
+  CHECK_EQ(addr3.compare(addr1), SocketAddress::CompareResult::NOT_COMPARABLE);
+  CHECK(!(addr1 < addr3));
+  CHECK(!(addr1 > addr3));
+  CHECK(!(addr1 >= addr3));
+  CHECK(!(addr1 <= addr3));
+  CHECK(!(addr3 < addr1));
+  CHECK(!(addr3 > addr1));
+  CHECK(!(addr3 >= addr1));
+  CHECK(!(addr3 <= addr1));
+
+  // Comparable
+  CHECK_EQ(addr1.compare(addr5), SocketAddress::CompareResult::SAME);
+  CHECK_EQ(addr2.compare(addr6), SocketAddress::CompareResult::SAME);
+  CHECK_EQ(addr1.compare(addr6), SocketAddress::CompareResult::LESS_THAN);
+  CHECK_EQ(addr6.compare(addr1), SocketAddress::CompareResult::GREATER_THAN);
+  CHECK(addr1 <= addr5);
+  CHECK(addr1 <= addr6);
+  CHECK(addr1 < addr6);
+  CHECK(addr6 > addr1);
+  CHECK(addr6 >= addr1);
+  CHECK(addr2 >= addr6);
+  CHECK(addr2 >= addr5);
+}
+
+TEST(SocketAddressBlockList, Simple) {
+  SocketAddressBlockList bl;
+
+  sockaddr_storage storage[2];
+  SocketAddress::ToSockAddr(AF_INET, "10.0.0.1", 0, &storage[0]);
+  SocketAddress::ToSockAddr(AF_INET, "10.0.0.2", 0, &storage[1]);
+  std::shared_ptr<SocketAddress> addr1 =
+      std::make_shared<SocketAddress>(
+          reinterpret_cast<const sockaddr*>(&storage[0]));
+  std::shared_ptr<SocketAddress> addr2 =
+      std::make_shared<SocketAddress>(
+          reinterpret_cast<const sockaddr*>(&storage[1]));
+
+  bl.AddSocketAddress(addr1);
+  bl.AddSocketAddress(addr2);
+
+  CHECK(bl.Apply(addr1));
+  CHECK(bl.Apply(addr2));
+
+  bl.RemoveSocketAddress(addr1);
+
+  CHECK(!bl.Apply(addr1));
+  CHECK(bl.Apply(addr2));
+}
diff --git a/test/cctest/test_url.cc b/test/cctest/test_url.cc
index 2e78b24a5e34242bd1c258c5c09f27736d9d8912..ad729ab1c7ffbd0b8d7cebe6aeff46d14a514058 100644
--- a/test/cctest/test_url.cc
+++ b/test/cctest/test_url.cc
@@ -81,6 +81,52 @@ TEST_F(URLTest, Base3) {
   EXPECT_EQ(simple.path(), "/baz");
 }
 
+TEST_F(URLTest, Base4) {
+  const char* input = "\\x";
+  const char* base = "http://example.org/foo/bar";
+
+  URL simple(input, strlen(input), base, strlen(base));
+
+  EXPECT_FALSE(simple.flags() & URL_FLAGS_FAILED);
+  EXPECT_EQ(simple.protocol(), "http:");
+  EXPECT_EQ(simple.host(), "example.org");
+  EXPECT_EQ(simple.path(), "/x");
+}
+
+TEST_F(URLTest, Base5) {
+  const char* input = "/x";
+  const char* base = "http://example.org/foo/bar";
+
+  URL simple(input, strlen(input), base, strlen(base));
+
+  EXPECT_FALSE(simple.flags() & URL_FLAGS_FAILED);
+  EXPECT_EQ(simple.protocol(), "http:");
+  EXPECT_EQ(simple.host(), "example.org");
+  EXPECT_EQ(simple.path(), "/x");
+}
+
+TEST_F(URLTest, Base6) {
+  const char* input = "\\\\x";
+  const char* base = "http://example.org/foo/bar";
+
+  URL simple(input, strlen(input), base, strlen(base));
+
+  EXPECT_FALSE(simple.flags() & URL_FLAGS_FAILED);
+  EXPECT_EQ(simple.protocol(), "http:");
+  EXPECT_EQ(simple.host(), "x");
+}
+
+TEST_F(URLTest, Base7) {
+  const char* input = "//x";
+  const char* base = "http://example.org/foo/bar";
+
+  URL simple(input, strlen(input), base, strlen(base));
+
+  EXPECT_FALSE(simple.flags() & URL_FLAGS_FAILED);
+  EXPECT_EQ(simple.protocol(), "http:");
+  EXPECT_EQ(simple.host(), "x");
+}
+
 TEST_F(URLTest, TruncatedAfterProtocol) {
   char input[2] = { 'q', ':' };
   URL simple(input, sizeof(input));
diff --git a/test/cctest/test_util.cc b/test/cctest/test_util.cc
index 6cfd5d317f7982b851fc1ba735b647a36e07aada..a64942a8a35009c3d753574fa5aaab701047b9dd 100644
--- a/test/cctest/test_util.cc
+++ b/test/cctest/test_util.cc
@@ -3,6 +3,16 @@
 #include "env-inl.h"
 #include "gtest/gtest.h"
 
+using node::Calloc;
+using node::Malloc;
+using node::MaybeStackBuffer;
+using node::SPrintF;
+using node::StringEqualNoCase;
+using node::StringEqualNoCaseN;
+using node::ToLower;
+using node::UncheckedCalloc;
+using node::UncheckedMalloc;
+
 TEST(UtilTest, ListHead) {
   struct Item { node::ListNode<Item> node_; };
   typedef node::ListHead<Item, &Item::node_> List;
@@ -58,7 +68,6 @@ TEST(UtilTest, ListHead) {
 }
 
 TEST(UtilTest, StringEqualNoCase) {
-  using node::StringEqualNoCase;
   EXPECT_FALSE(StringEqualNoCase("a", "b"));
   EXPECT_TRUE(StringEqualNoCase("", ""));
   EXPECT_TRUE(StringEqualNoCase("equal", "equal"));
@@ -69,7 +78,6 @@ TEST(UtilTest, StringEqualNoCase) {
 }
 
 TEST(UtilTest, StringEqualNoCaseN) {
-  using node::StringEqualNoCaseN;
   EXPECT_FALSE(StringEqualNoCaseN("a", "b", strlen("a")));
   EXPECT_TRUE(StringEqualNoCaseN("", "", strlen("")));
   EXPECT_TRUE(StringEqualNoCaseN("equal", "equal", strlen("equal")));
@@ -84,7 +92,6 @@ TEST(UtilTest, StringEqualNoCaseN) {
 }
 
 TEST(UtilTest, ToLower) {
-  using node::ToLower;
   EXPECT_EQ('0', ToLower('0'));
   EXPECT_EQ('a', ToLower('a'));
   EXPECT_EQ('a', ToLower('A'));
@@ -98,7 +105,6 @@ TEST(UtilTest, ToLower) {
   } while (0)
 
 TEST(UtilTest, Malloc) {
-  using node::Malloc;
   TEST_AND_FREE(Malloc<char>(0));
   TEST_AND_FREE(Malloc<char>(1));
   TEST_AND_FREE(Malloc(0));
@@ -106,7 +112,6 @@ TEST(UtilTest, Malloc) {
 }
 
 TEST(UtilTest, Calloc) {
-  using node::Calloc;
   TEST_AND_FREE(Calloc<char>(0));
   TEST_AND_FREE(Calloc<char>(1));
   TEST_AND_FREE(Calloc(0));
@@ -114,7 +119,6 @@ TEST(UtilTest, Calloc) {
 }
 
 TEST(UtilTest, UncheckedMalloc) {
-  using node::UncheckedMalloc;
   TEST_AND_FREE(UncheckedMalloc<char>(0));
   TEST_AND_FREE(UncheckedMalloc<char>(1));
   TEST_AND_FREE(UncheckedMalloc(0));
@@ -122,7 +126,6 @@ TEST(UtilTest, UncheckedMalloc) {
 }
 
 TEST(UtilTest, UncheckedCalloc) {
-  using node::UncheckedCalloc;
   TEST_AND_FREE(UncheckedCalloc<char>(0));
   TEST_AND_FREE(UncheckedCalloc<char>(1));
   TEST_AND_FREE(UncheckedCalloc(0));
@@ -131,33 +134,31 @@ TEST(UtilTest, UncheckedCalloc) {
 
 template <typename T>
 static void MaybeStackBufferBasic() {
-  using node::MaybeStackBuffer;
-
   MaybeStackBuffer<T> buf;
   size_t old_length;
   size_t old_capacity;
 
-  /* Default constructor */
+  // Default constructor.
   EXPECT_EQ(0U, buf.length());
   EXPECT_FALSE(buf.IsAllocated());
   EXPECT_GT(buf.capacity(), buf.length());
 
-  /* SetLength() expansion */
+  // SetLength() expansion.
   buf.SetLength(buf.capacity());
   EXPECT_EQ(buf.capacity(), buf.length());
   EXPECT_FALSE(buf.IsAllocated());
 
-  /* Means of accessing raw buffer */
+  // Means of accessing raw buffer.
   EXPECT_EQ(buf.out(), *buf);
   EXPECT_EQ(&buf[0], *buf);
 
-  /* Basic I/O */
+  // Basic I/O.
   for (size_t i = 0; i < buf.length(); i++)
     buf[i] = static_cast<T>(i);
   for (size_t i = 0; i < buf.length(); i++)
     EXPECT_EQ(static_cast<T>(i), buf[i]);
 
-  /* SetLengthAndZeroTerminate() */
+  // SetLengthAndZeroTerminate().
   buf.SetLengthAndZeroTerminate(buf.capacity() - 1);
   EXPECT_EQ(buf.capacity() - 1, buf.length());
   for (size_t i = 0; i < buf.length(); i++)
@@ -165,7 +166,7 @@ static void MaybeStackBufferBasic() {
   buf.SetLength(buf.capacity());
   EXPECT_EQ(0, buf[buf.length() - 1]);
 
-  /* Initial Realloc */
+  // Initial Realloc.
   old_length = buf.length() - 1;
   old_capacity = buf.capacity();
   buf.AllocateSufficientStorage(buf.capacity() * 2);
@@ -175,7 +176,7 @@ static void MaybeStackBufferBasic() {
     EXPECT_EQ(static_cast<T>(i), buf[i]);
   EXPECT_EQ(0, buf[old_length]);
 
-  /* SetLength() reduction and expansion */
+  // SetLength() reduction and expansion.
   for (size_t i = 0; i < buf.length(); i++)
     buf[i] = static_cast<T>(i);
   buf.SetLength(10);
@@ -185,7 +186,7 @@ static void MaybeStackBufferBasic() {
   for (size_t i = 0; i < buf.length(); i++)
     EXPECT_EQ(static_cast<T>(i), buf[i]);
 
-  /* Subsequent Realloc */
+  // Subsequent Realloc.
   old_length = buf.length();
   old_capacity = buf.capacity();
   buf.AllocateSufficientStorage(old_capacity * 1.5);
@@ -195,13 +196,13 @@ static void MaybeStackBufferBasic() {
   for (size_t i = 0; i < old_length; i++)
     EXPECT_EQ(static_cast<T>(i), buf[i]);
 
-  /* Basic I/O on Realloc'd buffer */
+  // Basic I/O on Realloc'd buffer.
   for (size_t i = 0; i < buf.length(); i++)
     buf[i] = static_cast<T>(i);
   for (size_t i = 0; i < buf.length(); i++)
     EXPECT_EQ(static_cast<T>(i), buf[i]);
 
-  /* Release() */
+  // Release().
   T* rawbuf = buf.out();
   buf.Release();
   EXPECT_EQ(0U, buf.length());
@@ -211,12 +212,10 @@ static void MaybeStackBufferBasic() {
 }
 
 TEST(UtilTest, MaybeStackBuffer) {
-  using node::MaybeStackBuffer;
-
   MaybeStackBufferBasic<uint8_t>();
   MaybeStackBufferBasic<uint16_t>();
 
-  // Constructor with size parameter
+  // Constructor with size parameter.
   {
     MaybeStackBuffer<unsigned char> buf(100);
     EXPECT_EQ(100U, buf.length());
@@ -240,7 +239,7 @@ TEST(UtilTest, MaybeStackBuffer) {
       EXPECT_EQ(static_cast<unsigned char>(i), bigbuf[i]);
   }
 
-  // Invalidated buffer
+  // Invalidated buffer.
   {
     MaybeStackBuffer<char> buf;
     buf.Invalidate();
@@ -254,8 +253,6 @@ TEST(UtilTest, MaybeStackBuffer) {
 }
 
 TEST(UtilTest, SPrintF) {
-  using node::SPrintF;
-
   // %d, %u and %s all do the same thing. The actual C++ type is used to infer
   // the right representation.
   EXPECT_EQ(SPrintF("%s", false), "false");
diff --git a/test/common/.eslintrc.yaml b/test/common/.eslintrc.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..b3981bdd272ecab95536b7ca1b070ccff6860de5
--- /dev/null
+++ b/test/common/.eslintrc.yaml
@@ -0,0 +1,3 @@
+rules:
+  node-core/required-modules: off
+  node-core/require-common-first: off
diff --git a/test/common/README.md b/test/common/README.md
index 49ce50cc495871aa987c56084acc4c5d14f521b2..f961185f75e4902cd129b2b7d6024724779c11ad 100644
--- a/test/common/README.md
+++ b/test/common/README.md
@@ -9,6 +9,7 @@ This directory contains modules used to test the Node.js implementation.
 * [Common module API](#common-module-api)
 * [Countdown module](#countdown-module)
 * [CPU Profiler module](#cpu-profiler-module)
+* [Debugger module](#debugger-module)
 * [DNS module](#dns-module)
 * [Duplex pair helper](#duplex-pair-helper)
 * [Environment variables](#environment-variables)
@@ -39,12 +40,12 @@ The `benchmark` module is used by tests to run benchmarks.
 The `common` module is used by tests for consistency across repeated
 tasks.
 
-### `allowGlobals(...whitelist)`
+### `allowGlobals(...allowlist)`
 
-* `whitelist` [&lt;Array>][] Array of Globals
+* `allowlist` [&lt;Array>][] Array of Globals
 * return [&lt;Array>][]
 
-Takes `whitelist` and concats that with predefined `knownGlobals`.
+Takes `allowlist` and concats that with predefined `knownGlobals`.
 
 ### `canCreateSymLink()`
 
@@ -81,7 +82,8 @@ least 1 GHz.
 
 Indicates if there is more than 1gb of total memory.
 
-### expectsError(validator\[, exact\])
+### `expectsError(validator[, exact])`
+
 * `validator` [&lt;Object>][] | [&lt;RegExp>][] | [&lt;Function>][] |
   [&lt;Error>][] The validator behaves identical to
   `assert.throws(fn, validator)`.
@@ -113,12 +115,12 @@ expectWarning('Warning', 'Foobar is really bad');
 expectWarning('DeprecationWarning', 'Foobar is deprecated', 'DEP0XXX');
 
 expectWarning('DeprecationWarning', [
-  'Foobar is deprecated', 'DEP0XXX'
+  'Foobar is deprecated', 'DEP0XXX',
 ]);
 
 expectWarning('DeprecationWarning', [
   ['Foobar is deprecated', 'DEP0XXX'],
-  ['Baz is also deprecated', 'DEP0XX2']
+  ['Baz is also deprecated', 'DEP0XX2'],
 ]);
 
 expectWarning('DeprecationWarning', {
@@ -133,7 +135,7 @@ expectWarning({
   },
   Warning: [
     ['Multiple array entries are fine', 'SpecialWarningCode'],
-    ['No code is also fine']
+    ['No code is also fine'],
   ],
   SingleEntry: ['This will also work', 'WarningCode'],
   SingleString: 'Single string entries without code will also work'
@@ -312,6 +314,15 @@ If `fn` is not provided, an empty function will be used.
 Returns a function that triggers an `AssertionError` if it is invoked. `msg` is
 used as the error message for the `AssertionError`.
 
+### `mustSucceed([fn])`
+
+* `fn` [&lt;Function>][] default = () => {}
+* return [&lt;Function>][]
+
+Returns a function that accepts arguments `(err, ...args)`. If `err` is not
+`undefined` or `null`, it triggers an `AssertionError`. Otherwise, it calls
+`fn(...args)`.
+
 ### `nodeProcessAborted(exitCode, signal)`
 
 * `exitCode` [&lt;number>][]
@@ -367,6 +378,13 @@ const { spawn } = require('child_process');
 spawn(...common.pwdCommand, { stdio: ['pipe'] });
 ```
 
+### `requireNoPackageJSONAbove([dir])`
+
+* `dir` [&lt;string>][] default = \_\_dirname
+
+Throws an `AssertionError` if a `package.json` file exists in any ancestor
+directory above `dir`. Such files may interfere with proper test functionality.
+
 ### `runWithInvalidFD(func)`
 
 * `func` [&lt;Function>][]
@@ -495,6 +513,34 @@ Sampling interval in microseconds.
 Throws an `AssertionError` if there are no call frames with the expected
 `suffix` in the profiling data contained in `file`.
 
+## Debugger module
+
+Provides common functionality for tests for `node inspect`.
+
+### `startCLI(args[[, flags], spawnOpts])`
+
+* `args` [&lt;string>][]
+* `flags` [&lt;string>][] default = []
+* `showOpts` [&lt;Object>][] default = {}
+* return [&lt;Object>][]
+
+Returns a null-prototype object with properties that are functions and getters
+used to interact with the `node inspect` CLI. These functions are:
+
+* `flushOutput()`
+* `waitFor()`
+* `waitForPrompt()`
+* `waitForInitialBreak()`
+* `breakInfo`
+* `ctrlC()`
+* `output`
+* `rawOutput`
+* `parseSourceLines()`
+* `writeLine()`
+* `command()`
+* `stepCommand()`
+* `quit()`
+
 ## `DNS` Module
 
 The `DNS` module provides utilities related to the `dns` built-in module.
@@ -585,7 +631,7 @@ If set, crypto tests are skipped.
 ### `NODE_TEST_KNOWN_GLOBALS`
 
 A comma-separated list of variables names that are appended to the global
-variable whitelist. Alternatively, if `NODE_TEST_KNOWN_GLOBALS` is set to `'0'`,
+variable allowlist. Alternatively, if `NODE_TEST_KNOWN_GLOBALS` is set to `'0'`,
 global leak detection is disabled.
 
 ## Fixtures Module
@@ -649,9 +695,9 @@ validateSnapshotNodes('TLSWRAP', [
     children: [
       { name: 'enc_out' },
       { name: 'enc_in' },
-      { name: 'TLSWrap' }
+      { name: 'TLSWrap' },
     ]
-  }
+  },
 ]);
 ```
 
@@ -886,8 +932,8 @@ functionality.
 * `dir` [&lt;string>][] Directory to search for diagnostic report files.
 * return [&lt;Array>][]
 
-Returns an array of diagnotic report file names found in `dir`. The files should
-have been generated by a process whose PID matches `pid`.
+Returns an array of diagnostic report file names found in `dir`. The files
+should have been generated by a process whose PID matches `pid`.
 
 ### `validate(filepath)`
 
@@ -929,6 +975,18 @@ The realpath of the testing temporary directory.
 
 Deletes and recreates the testing temporary directory.
 
+The first time `refresh()` runs, it adds a listener to process `'exit'` that
+cleans the temporary directory. Thus, every file under `tmpdir.path` needs to
+be closed before the test completes. A good way to do this is to add a
+listener to process `'beforeExit'`. If a file needs to be left open until
+Node.js completes, use a child process and call `refresh()` only in the
+parent.
+
+It is usually only necessary to call `refresh()` once in a test file.
+Avoid calling it more than once in an asynchronous context as one call
+might refresh the temporary directory of a different context, causing
+the test to fail somewhat mysteriously.
+
 ## UDP pair helper
 
 The `common/udppair` module exports a function `makeUDPPair` and a class
diff --git a/test/common/arraystream.js b/test/common/arraystream.js
index 408d57712c73efeb25f485603e3d919dba4fdaa4..c9dae0512b52ccf3e67c5a31586f12e4100b9c6e 100644
--- a/test/common/arraystream.js
+++ b/test/common/arraystream.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
 const { Stream } = require('stream');
diff --git a/test/common/benchmark.js b/test/common/benchmark.js
index 56351c92505efab4ef44c967f26781023f567dbb..88c918766fd76c8f89e280826d06d3dc37a13050 100644
--- a/test/common/benchmark.js
+++ b/test/common/benchmark.js
@@ -1,5 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
-
 'use strict';
 
 const assert = require('assert');
diff --git a/test/common/countdown.js b/test/common/countdown.js
index 31507b612576336664f826fa1229c585949c168f..4aa86b425339037f6104654d9673f679ef79254a 100644
--- a/test/common/countdown.js
+++ b/test/common/countdown.js
@@ -1,5 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
-
 'use strict';
 
 const assert = require('assert');
diff --git a/test/common/cpu-prof.js b/test/common/cpu-prof.js
index ae81eefd45c307b852a8c1fbbb45aefeb1490e3c..e4bba24037dff995b370bafc231783c71726eb9b 100644
--- a/test/common/cpu-prof.js
+++ b/test/common/cpu-prof.js
@@ -1,5 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
-
 'use strict';
 
 require('./');
diff --git a/deps/node-inspect/test/cli/start-cli.js b/test/common/debugger.js
similarity index 67%
rename from deps/node-inspect/test/cli/start-cli.js
rename to test/common/debugger.js
index 32c666c7647c685d7f2ae5a88e6d716bcf9cdb80..63d66ba3a8f2c0b2a0828a9f32706cca70dcadb0 100644
--- a/deps/node-inspect/test/cli/start-cli.js
+++ b/test/common/debugger.js
@@ -1,42 +1,33 @@
 'use strict';
+const common = require('../common');
 const spawn = require('child_process').spawn;
 
-// This allows us to keep the helper inside of `test/` without tap warning
-// about "pending" test files.
-const tap = require('tap');
-tap.test('startCLI', (t) => t.end());
-
-const CLI =
-  process.env.USE_EMBEDDED_NODE_INSPECT === '1' ?
-    'inspect' :
-    require.resolve('../../cli.js');
-
 const BREAK_MESSAGE = new RegExp('(?:' + [
   'assert', 'break', 'break on start', 'debugCommand',
   'exception', 'other', 'promiseRejection',
 ].join('|') + ') in', 'i');
 
+const TIMEOUT = common.platformTimeout(5000);
+
 function isPreBreak(output) {
   return /Break on start/.test(output) && /1 \(function \(exports/.test(output);
 }
 
 function startCLI(args, flags = [], spawnOpts = {}) {
-  const child = spawn(process.execPath, [...flags, CLI, ...args], spawnOpts);
-  let isFirstStdoutChunk = true;
+  let stderrOutput = '';
+  const child =
+    spawn(process.execPath, [...flags, 'inspect', ...args], spawnOpts);
 
   const outputBuffer = [];
   function bufferOutput(chunk) {
-    if (isFirstStdoutChunk) {
-      isFirstStdoutChunk = false;
-      outputBuffer.push(chunk.replace(/^debug>\s*/, ''));
-    } else {
-      outputBuffer.push(chunk);
+    if (this === child.stderr) {
+      stderrOutput += chunk;
     }
+    outputBuffer.push(chunk);
   }
 
   function getOutput() {
-    return outputBuffer.join('').toString()
-      .replace(/^[^\n]*?[\b]/mg, '');
+    return outputBuffer.join('\n').replace(/\b/g, '');
   }
 
   child.stdout.setEncoding('utf8');
@@ -45,7 +36,7 @@ function startCLI(args, flags = [], spawnOpts = {}) {
   child.stderr.on('data', bufferOutput);
 
   if (process.env.VERBOSE === '1') {
-    child.stdout.pipe(process.stderr);
+    child.stdout.pipe(process.stdout);
     child.stderr.pipe(process.stderr);
   }
 
@@ -56,7 +47,7 @@ function startCLI(args, flags = [], spawnOpts = {}) {
       return output;
     },
 
-    waitFor(pattern, timeout = 2000) {
+    waitFor(pattern) {
       function checkPattern(str) {
         if (Array.isArray(pattern)) {
           return pattern.every((p) => p.test(str));
@@ -67,47 +58,57 @@ function startCLI(args, flags = [], spawnOpts = {}) {
       return new Promise((resolve, reject) => {
         function checkOutput() {
           if (checkPattern(getOutput())) {
-            tearDown(); // eslint-disable-line no-use-before-define
+            tearDown();
             resolve();
           }
         }
 
-        function onChildExit() {
-          tearDown(); // eslint-disable-line no-use-before-define
-          reject(new Error(
-            `Child quit while waiting for ${pattern}; found: ${this.output}`));
+        function onChildClose(code, signal) {
+          tearDown();
+          let message = 'Child exited';
+          if (code) {
+            message += `, code ${code}`;
+          }
+          if (signal) {
+            message += `, signal ${signal}`;
+          }
+          message += ` while waiting for ${pattern}; found: ${this.output}`;
+          if (stderrOutput) {
+            message += `\n STDERR: ${stderrOutput}`;
+          }
+          reject(new Error(message));
         }
 
         const timer = setTimeout(() => {
-          tearDown(); // eslint-disable-line no-use-before-define
+          tearDown();
           reject(new Error([
-            `Timeout (${timeout}) while waiting for ${pattern}`,
+            `Timeout (${TIMEOUT}) while waiting for ${pattern}`,
             `found: ${this.output}`,
           ].join('; ')));
-        }, timeout);
+        }, TIMEOUT);
 
         function tearDown() {
           clearTimeout(timer);
           child.stdout.removeListener('data', checkOutput);
-          child.removeListener('exit', onChildExit);
+          child.removeListener('close', onChildClose);
         }
 
-        child.on('exit', onChildExit);
+        child.on('close', onChildClose);
         child.stdout.on('data', checkOutput);
         checkOutput();
       });
     },
 
-    waitForPrompt(timeout = 2000) {
-      return this.waitFor(/>\s+$/, timeout);
+    waitForPrompt() {
+      return this.waitFor(/>\s+$/);
     },
 
-    waitForInitialBreak(timeout = 2000) {
-      return this.waitFor(/break (?:on start )?in/i, timeout)
+    waitForInitialBreak() {
+      return this.waitFor(/break (?:on start )?in/i)
         .then(() => {
           if (isPreBreak(this.output)) {
             return this.command('next', false)
-              .then(() => this.waitFor(/break in/, timeout));
+              .then(() => this.waitFor(/break in/));
           }
         });
     },
@@ -169,7 +170,7 @@ function startCLI(args, flags = [], spawnOpts = {}) {
     quit() {
       return new Promise((resolve) => {
         child.stdin.end();
-        child.on('exit', resolve);
+        child.on('close', resolve);
       });
     },
   };
diff --git a/test/common/dns.js b/test/common/dns.js
index d8a703cc53be86cf8638b105c1cebead3882e411..70e171695ff20de92b061c83c12847bf4db2fc9d 100644
--- a/test/common/dns.js
+++ b/test/common/dns.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
 const assert = require('assert');
@@ -13,7 +12,8 @@ const types = {
   PTR: 12,
   MX: 15,
   TXT: 16,
-  ANY: 255
+  ANY: 255,
+  CAA: 257
 };
 
 const classes = {
@@ -59,7 +59,7 @@ function parseDNSPacket(buffer) {
     ['questions', buffer.readUInt16BE(4)],
     ['answers', buffer.readUInt16BE(6)],
     ['authorityAnswers', buffer.readUInt16BE(8)],
-    ['additionalRecords', buffer.readUInt16BE(10)]
+    ['additionalRecords', buffer.readUInt16BE(10)],
   ];
 
   let offset = 12;
@@ -184,7 +184,7 @@ function writeDomainName(domain) {
     assert(label.length < 64);
     return Buffer.concat([
       Buffer.from([label.length]),
-      Buffer.from(label, 'ascii')
+      Buffer.from(label, 'ascii'),
     ]);
   }).concat([Buffer.alloc(1)]));
 }
@@ -207,7 +207,7 @@ function writeDNSPacket(parsed) {
     buffers.push(writeDomainName(q.domain));
     buffers.push(new Uint16Array([
       types[q.type],
-      q.cls === undefined ? classes.IN : q.cls
+      q.cls === undefined ? classes.IN : q.cls,
     ]));
   }
 
@@ -220,7 +220,7 @@ function writeDNSPacket(parsed) {
     buffers.push(writeDomainName(rr.domain));
     buffers.push(new Uint16Array([
       types[rr.type],
-      rr.cls === undefined ? classes.IN : rr.cls
+      rr.cls === undefined ? classes.IN : rr.cls,
     ]));
     buffers.push(new Int32Array([rr.ttl]));
 
@@ -265,10 +265,18 @@ function writeDNSPacket(parsed) {
         rdLengthBuf[0] = mname.length + rname.length + 20;
         buffers.push(mname, rname);
         buffers.push(new Uint32Array([
-          rr.serial, rr.refresh, rr.retry, rr.expire, rr.minttl
+          rr.serial, rr.refresh, rr.retry, rr.expire, rr.minttl,
         ]));
         break;
       }
+      case 'CAA':
+      {
+        rdLengthBuf[0] = 5 + rr.issue.length + 2;
+        buffers.push(Buffer.from([Number(rr.critical)]));
+        buffers.push(Buffer.from([Number(5)]));
+        buffers.push(Buffer.from('issue' + rr.issue));
+        break;
+      }
       default:
         throw new Error(`Unknown RR type ${rr.type}`);
     }
diff --git a/test/common/duplexpair.js b/test/common/duplexpair.js
index 4eb4f326f2d295d6c0e6659df0f8070967308ed0..1f41ed32f1b9e9cbed2e6adf4fc42b1d6518a196 100644
--- a/test/common/duplexpair.js
+++ b/test/common/duplexpair.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 const { Duplex } = require('stream');
 const assert = require('assert');
diff --git a/test/common/fixtures.js b/test/common/fixtures.js
index 2390ee8284e4213d56082ae9a70283c32c77b8b0..76e72a22ec9fecffba6d87859510e21a1951a431 100644
--- a/test/common/fixtures.js
+++ b/test/common/fixtures.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
 const path = require('path');
diff --git a/test/common/fixtures.mjs b/test/common/fixtures.mjs
index 3eeef6d6077c4a582803438309eb6fb4a85aadf3..06564de6fa3bb951bf37be4eaf96f47e1a220b7e 100644
--- a/test/common/fixtures.mjs
+++ b/test/common/fixtures.mjs
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 import fixtures from './fixtures.js';
 
 const {
diff --git a/test/common/heap.js b/test/common/heap.js
index a6232177ba9fd3d1d44c35fb326e9d17c5428ad6..fa74e606f03ee073e16afcba862c1faf10321b13 100644
--- a/test/common/heap.js
+++ b/test/common/heap.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 const assert = require('assert');
 const util = require('util');
diff --git a/test/common/hijackstdio.js b/test/common/hijackstdio.js
index 6995f6665891d32e827d866f547b6a59c2866991..44e00ed0b11cc2a280e314818b732ca6afc25f0f 100644
--- a/test/common/hijackstdio.js
+++ b/test/common/hijackstdio.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
 // Hijack stdout and stderr
diff --git a/test/common/http2.js b/test/common/http2.js
index c4d430d1d93f985ed26468c41056b00855543b40..baaed492e5a9a33e94803e1dd3075367b3832c18 100644
--- a/test/common/http2.js
+++ b/test/common/http2.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
 // An HTTP/2 testing tool used to create mock frames for direct testing
diff --git a/test/common/index.js b/test/common/index.js
index 8cd984152702d581da97e81c5aca39dfb26bf478..ae5632d35feaddc8b5ba552d54ee802f7d2cb95b 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -19,7 +19,6 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 /* eslint-disable node-core/crypto-check */
 'use strict';
 const process = global.process;  // Some tests tamper with the process global.
@@ -51,6 +50,11 @@ const noop = () => {};
 const hasCrypto = Boolean(process.versions.openssl) &&
                   !process.env.NODE_SKIP_CRYPTO;
 
+const hasOpenSSL3 = hasCrypto &&
+    require('crypto').constants.OPENSSL_VERSION_NUMBER >= 805306368;
+
+const hasQuic = hasCrypto && !!process.config.variables.openssl_quic;
+
 // Check for flags. Skip this for workers (both, the `cluster` module and
 // `worker_threads`) and child processes.
 // If the binary was built without-ssl then the crypto flags are
@@ -59,12 +63,12 @@ if (process.argv.length === 2 &&
     !process.env.NODE_SKIP_FLAG_CHECK &&
     isMainThread &&
     hasCrypto &&
-    module.parent &&
+    require.main &&
     require('cluster').isMaster) {
   // The copyright notice is relatively big and the flags could come afterwards.
   const bytesToRead = 1500;
   const buffer = Buffer.allocUnsafe(bytesToRead);
-  const fd = fs.openSync(module.parent.filename, 'r');
+  const fd = fs.openSync(require.main.filename, 'r');
   const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead);
   fs.closeSync(fd);
   const source = buffer.toString('utf8', 0, bytesRead);
@@ -194,11 +198,9 @@ const PIPE = (() => {
   return path.join(pipePrefix, pipeName);
 })();
 
-/*
- * Check that when running a test with
- * `$node --abort-on-uncaught-exception $file child`
- * the process aborts.
- */
+// Check that when running a test with
+// `$node --abort-on-uncaught-exception $file child`
+// the process aborts.
 function childShouldThrowAndAbort() {
   let testCmd = '';
   if (!isWindows) {
@@ -264,12 +266,21 @@ let knownGlobals = [
   queueMicrotask,
 ];
 
+// TODO(@jasnell): This check can be temporary. AbortController is
+// not currently supported in either Node.js 12 or 10, making it
+// difficult to run tests comparitively on those versions. Once
+// all supported versions have AbortController as a global, this
+// check can be removed and AbortController can be added to the
+// knownGlobals list above.
+if (global.AbortController)
+  knownGlobals.push(global.AbortController);
+
 if (global.gc) {
   knownGlobals.push(global.gc);
 }
 
-function allowGlobals(...whitelist) {
-  knownGlobals = knownGlobals.concat(whitelist);
+function allowGlobals(...allowlist) {
+  knownGlobals = knownGlobals.concat(allowlist);
 }
 
 if (process.env.NODE_TEST_KNOWN_GLOBALS !== '0') {
@@ -327,6 +338,14 @@ function mustCall(fn, exact) {
   return _mustCallInner(fn, exact, 'exact');
 }
 
+function mustSucceed(fn, exact) {
+  return mustCall(function(err, ...args) {
+    assert.ifError(err);
+    if (typeof fn === 'function')
+      return fn.apply(this, args);
+  }, exact);
+}
+
 function mustCallAtLeast(fn, minimum) {
   return _mustCallInner(fn, minimum, 'minimum');
 }
@@ -356,10 +375,28 @@ function _mustCallInner(fn, criteria = 1, field) {
 
   mustCallChecks.push(context);
 
-  return function() {
+  const _return = function() { // eslint-disable-line func-style
     context.actual++;
     return fn.apply(this, arguments);
   };
+  // Function instances have own properties that may be relevant.
+  // Let's replicate those properties to the returned function.
+  // Refs: https://tc39.es/ecma262/#sec-function-instances
+  Object.defineProperties(_return, {
+    name: {
+      value: fn.name,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+    },
+    length: {
+      value: fn.length,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+    },
+  });
+  return _return;
 }
 
 function hasMultiLocalhost() {
@@ -408,7 +445,7 @@ function getCallSite(top) {
   const err = new Error();
   Error.captureStackTrace(err, top);
   // With the V8 Error API, the stack is not formatted until it is accessed
-  err.stack;
+  err.stack; // eslint-disable-line no-unused-expressions
   Error.prepareStackTrace = originalStackFormatter;
   return err.stack;
 }
@@ -548,19 +585,6 @@ function expectsError(validator, exact) {
   }, exact);
 }
 
-const suffix = 'This is caused by either a bug in Node.js ' +
-  'or incorrect usage of Node.js internals.\n' +
-  'Please open an issue with this stack trace at ' +
-  'https://github.com/nodejs/node/issues\n';
-
-function expectsInternalAssertion(fn, message) {
-  assert.throws(fn, {
-    message: `${message}\n${suffix}`,
-    name: 'Error',
-    code: 'ERR_INTERNAL_ASSERTION'
-  });
-}
-
 function skipIfInspectorDisabled() {
   if (!process.features.inspector) {
     skip('V8 inspector is disabled');
@@ -594,7 +618,7 @@ function getArrayBufferViews(buf) {
     Uint32Array,
     Float32Array,
     Float64Array,
-    DataView
+    DataView,
   ];
 
   for (const type of arrayBufferViews) {
@@ -697,6 +721,20 @@ function gcUntil(name, condition) {
   });
 }
 
+function requireNoPackageJSONAbove(dir = __dirname) {
+  let possiblePackage = path.join(dir, '..', 'package.json');
+  let lastPackage = null;
+  while (possiblePackage !== lastPackage) {
+    if (fs.existsSync(possiblePackage)) {
+      assert.fail(
+        'This test shouldn\'t load properties from a package.json above ' +
+        `its file location. Found package.json at ${possiblePackage}.`);
+    }
+    lastPackage = possiblePackage;
+    possiblePackage = path.join(possiblePackage, '..', '..', 'package.json');
+  }
+}
+
 const common = {
   allowGlobals,
   buildType,
@@ -705,7 +743,6 @@ const common = {
   createZeroFilledFile,
   disableCrashOnUnhandledRejection,
   expectsError,
-  expectsInternalAssertion,
   expectWarning,
   gcUntil,
   getArrayBufferViews,
@@ -714,6 +751,8 @@ const common = {
   getTTYfd,
   hasIntl,
   hasCrypto,
+  hasOpenSSL3,
+  hasQuic,
   hasMultiLocalhost,
   invalidArgTypeHelper,
   isAIX,
@@ -730,11 +769,13 @@ const common = {
   mustCall,
   mustCallAtLeast,
   mustNotCall,
+  mustSucceed,
   nodeProcessAborted,
   PIPE,
   platformTimeout,
   printSkipMessage,
   pwdCommand,
+  requireNoPackageJSONAbove,
   runWithInvalidFD,
   skip,
   skipIf32Bits,
diff --git a/test/common/index.mjs b/test/common/index.mjs
index c0bbb9d74e1cda07e2feebce71c844cbbbe6970b..a7fd6ed1bff0981cf59fa7de2be0f9fca936bc19 100644
--- a/test/common/index.mjs
+++ b/test/common/index.mjs
@@ -1,5 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
-
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -30,6 +28,7 @@ const {
   allowGlobals,
   mustCall,
   mustCallAtLeast,
+  mustSucceed,
   hasMultiLocalhost,
   skipIfDumbTerminal,
   skipIfEslintMissing,
@@ -76,6 +75,7 @@ export {
   allowGlobals,
   mustCall,
   mustCallAtLeast,
+  mustSucceed,
   hasMultiLocalhost,
   skipIfDumbTerminal,
   skipIfEslintMissing,
diff --git a/test/common/inspector-helper.js b/test/common/inspector-helper.js
index 5aea807b7c0b815a8035a75f715aec4379622e10..3ab4975ce09c307ca840c075a24f69907e1c5c9c 100644
--- a/test/common/inspector-helper.js
+++ b/test/common/inspector-helper.js
@@ -228,7 +228,7 @@ class InspectorSession {
 
   waitForNotification(methodOrPredicate, description) {
     const desc = description || methodOrPredicate;
-    const message = `Timed out waiting for matching notification (${desc}))`;
+    const message = `Timed out waiting for matching notification (${desc})`;
     return fires(
       this._asyncWaitForNotification(methodOrPredicate), message, TIMEOUT);
   }
@@ -515,7 +515,7 @@ function fires(promise, error, timeoutMs) {
   const timeout = timeoutPromise(error, timeoutMs);
   return Promise.race([
     onResolvedOrRejected(promise, () => timeout.clear()),
-    timeout
+    timeout,
   ]);
 }
 
diff --git a/test/common/internet.js b/test/common/internet.js
index 88153960f0d59c069b8cbc1d87c3ea95c4eb4c08..227e979d3b8c75abe0fb62d7c4a919fe0da4b839 100644
--- a/test/common/internet.js
+++ b/test/common/internet.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
 // Utilities for internet-related tests
@@ -22,6 +21,9 @@ const addresses = {
   INVALID_HOST: 'something.invalid',
   // A host with MX records registered
   MX_HOST: 'nodejs.org',
+  // On some systems, .invalid returns a server failure/try again rather than
+  // record not found. Use this to guarantee record not found.
+  NOT_FOUND: 'come.on.fhqwhgads.test',
   // A host with SRV records registered
   SRV_HOST: '_jabber._tcp.google.com',
   // A host with PTR records registered
@@ -30,6 +32,8 @@ const addresses = {
   NAPTR_HOST: 'sip2sip.info',
   // A host with SOA records registered
   SOA_HOST: 'nodejs.org',
+  // A host with CAA record registred
+  CAA_HOST: 'google.com',
   // A host with CNAME records registered
   CNAME_HOST: 'blog.nodejs.org',
   // A host with NS records registered
diff --git a/test/common/measure-memory.js b/test/common/measure-memory.js
new file mode 100644
index 0000000000000000000000000000000000000000..a42f6344268d1261d67575ae261231df2a2364f4
--- /dev/null
+++ b/test/common/measure-memory.js
@@ -0,0 +1,56 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('./');
+
+// The formats could change when V8 is updated, then the tests should be
+// updated accordingly.
+function assertResultShape(result) {
+  assert.strictEqual(typeof result.jsMemoryEstimate, 'number');
+  assert.strictEqual(typeof result.jsMemoryRange[0], 'number');
+  assert.strictEqual(typeof result.jsMemoryRange[1], 'number');
+}
+
+function assertSummaryShape(result) {
+  assert.strictEqual(typeof result, 'object');
+  assert.strictEqual(typeof result.total, 'object');
+  assertResultShape(result.total);
+}
+
+function assertDetailedShape(result, contexts = 0) {
+  assert.strictEqual(typeof result, 'object');
+  assert.strictEqual(typeof result.total, 'object');
+  assert.strictEqual(typeof result.current, 'object');
+  assertResultShape(result.total);
+  assertResultShape(result.current);
+  if (contexts === 0) {
+    assert.deepStrictEqual(result.other, []);
+  } else {
+    assert.strictEqual(result.other.length, contexts);
+    for (const item of result.other) {
+      assertResultShape(item);
+    }
+  }
+}
+
+function assertSingleDetailedShape(result) {
+  assert.strictEqual(typeof result, 'object');
+  assert.strictEqual(typeof result.total, 'object');
+  assert.strictEqual(typeof result.current, 'object');
+  assert.deepStrictEqual(result.other, []);
+  assertResultShape(result.total);
+  assertResultShape(result.current);
+}
+
+function expectExperimentalWarning() {
+  common.expectWarning('ExperimentalWarning',
+                       'vm.measureMemory is an experimental feature. ' +
+                       'This feature could change at any time');
+}
+
+module.exports = {
+  assertSummaryShape,
+  assertDetailedShape,
+  assertSingleDetailedShape,
+  expectExperimentalWarning
+};
diff --git a/test/common/report.js b/test/common/report.js
index f49493b443edeab01f51d28cc35f9f5e2057f673..b1d6b05817259064665567d8a4936e59e99edef7 100644
--- a/test/common/report.js
+++ b/test/common/report.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 const assert = require('assert');
 const fs = require('fs');
@@ -54,10 +53,10 @@ function validateContent(report, fields = []) {
 
 function _validateContent(report, fields = []) {
   const isWindows = process.platform === 'win32';
+  const isJavaScriptThreadReport = report.javascriptStack != null;
 
   // Verify that all sections are present as own properties of the report.
-  const sections = ['header', 'javascriptStack', 'nativeStack',
-                    'javascriptHeap', 'libuv', 'environmentVariables',
+  const sections = ['header', 'nativeStack', 'libuv', 'environmentVariables',
                     'sharedObjects', 'resourceUsage', 'workers'];
   if (!isWindows)
     sections.push('userLimits');
@@ -65,6 +64,9 @@ function _validateContent(report, fields = []) {
   if (report.uvthreadResourceUsage)
     sections.push('uvthreadResourceUsage');
 
+  if (isJavaScriptThreadReport)
+    sections.push('javascriptStack', 'javascriptHeap');
+
   checkForUnknownFields(report, sections);
   sections.forEach((section) => {
     assert(report.hasOwnProperty(section));
@@ -163,19 +165,6 @@ function _validateContent(report, fields = []) {
   });
   assert.strictEqual(header.host, os.hostname());
 
-  // Verify the format of the javascriptStack section.
-  checkForUnknownFields(report.javascriptStack,
-                        ['message', 'stack', 'errorProperties']);
-  assert.strictEqual(typeof report.javascriptStack.errorProperties,
-                     'object');
-  assert.strictEqual(typeof report.javascriptStack.message, 'string');
-  if (report.javascriptStack.stack !== undefined) {
-    assert(Array.isArray(report.javascriptStack.stack));
-    report.javascriptStack.stack.forEach((frame) => {
-      assert.strictEqual(typeof frame, 'string');
-    });
-  }
-
   // Verify the format of the nativeStack section.
   assert(Array.isArray(report.nativeStack));
   report.nativeStack.forEach((frame) => {
@@ -186,26 +175,41 @@ function _validateContent(report, fields = []) {
     assert.strictEqual(typeof frame.symbol, 'string');
   });
 
-  // Verify the format of the javascriptHeap section.
-  const heap = report.javascriptHeap;
-  const jsHeapFields = ['totalMemory', 'totalCommittedMemory', 'usedMemory',
-                        'availableMemory', 'memoryLimit', 'heapSpaces'];
-  checkForUnknownFields(heap, jsHeapFields);
-  assert(Number.isSafeInteger(heap.totalMemory));
-  assert(Number.isSafeInteger(heap.totalCommittedMemory));
-  assert(Number.isSafeInteger(heap.usedMemory));
-  assert(Number.isSafeInteger(heap.availableMemory));
-  assert(Number.isSafeInteger(heap.memoryLimit));
-  assert(typeof heap.heapSpaces === 'object' && heap.heapSpaces !== null);
-  const heapSpaceFields = ['memorySize', 'committedMemory', 'capacity', 'used',
-                           'available'];
-  Object.keys(heap.heapSpaces).forEach((spaceName) => {
-    const space = heap.heapSpaces[spaceName];
-    checkForUnknownFields(space, heapSpaceFields);
-    heapSpaceFields.forEach((field) => {
-      assert(Number.isSafeInteger(space[field]));
+  if (isJavaScriptThreadReport) {
+    // Verify the format of the javascriptStack section.
+    checkForUnknownFields(report.javascriptStack,
+                          ['message', 'stack', 'errorProperties']);
+    assert.strictEqual(typeof report.javascriptStack.errorProperties,
+                       'object');
+    assert.strictEqual(typeof report.javascriptStack.message, 'string');
+    if (report.javascriptStack.stack !== undefined) {
+      assert(Array.isArray(report.javascriptStack.stack));
+      report.javascriptStack.stack.forEach((frame) => {
+        assert.strictEqual(typeof frame, 'string');
+      });
+    }
+
+    // Verify the format of the javascriptHeap section.
+    const heap = report.javascriptHeap;
+    const jsHeapFields = ['totalMemory', 'totalCommittedMemory', 'usedMemory',
+                          'availableMemory', 'memoryLimit', 'heapSpaces'];
+    checkForUnknownFields(heap, jsHeapFields);
+    assert(Number.isSafeInteger(heap.totalMemory));
+    assert(Number.isSafeInteger(heap.totalCommittedMemory));
+    assert(Number.isSafeInteger(heap.usedMemory));
+    assert(Number.isSafeInteger(heap.availableMemory));
+    assert(Number.isSafeInteger(heap.memoryLimit));
+    assert(typeof heap.heapSpaces === 'object' && heap.heapSpaces !== null);
+    const heapSpaceFields = ['memorySize', 'committedMemory', 'capacity',
+                             'used', 'available'];
+    Object.keys(heap.heapSpaces).forEach((spaceName) => {
+      const space = heap.heapSpaces[spaceName];
+      checkForUnknownFields(space, heapSpaceFields);
+      heapSpaceFields.forEach((field) => {
+        assert(Number.isSafeInteger(space[field]));
+      });
     });
-  });
+  }
 
   // Verify the format of the resourceUsage section.
   const usage = report.resourceUsage;
diff --git a/test/common/require-as.js b/test/common/require-as.js
index f55c1a67c49ec22e6fd82ae055a6e3a87cae9caa..9425404fa1416dcb37f526801264c845e2844cb1 100644
--- a/test/common/require-as.js
+++ b/test/common/require-as.js
@@ -1,7 +1,6 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
-if (module.parent) {
+if (require.main !== module) {
   const { spawnSync } = require('child_process');
 
   function runModuleAs(filename, flags, spawnOptions, role) {
diff --git a/test/common/shared-lib-util.js b/test/common/shared-lib-util.js
index 9f891a6043ef3ddfedb6abf3e34fe078426eeec2..f40acd783ba0e7610332c3af859faf4777affd9d 100644
--- a/test/common/shared-lib-util.js
+++ b/test/common/shared-lib-util.js
@@ -17,11 +17,11 @@ function addLibraryPath(env) {
 
   env.LD_LIBRARY_PATH =
     (env.LD_LIBRARY_PATH ? env.LD_LIBRARY_PATH + path.delimiter : '') +
-    path.join(kExecPath, 'lib.target');
+    kExecPath;
   // For AIX.
   env.LIBPATH =
     (env.LIBPATH ? env.LIBPATH + path.delimiter : '') +
-    path.join(kExecPath, 'lib.target');
+    kExecPath;
   // For Mac OSX.
   env.DYLD_LIBRARY_PATH =
     (env.DYLD_LIBRARY_PATH ? env.DYLD_LIBRARY_PATH + path.delimiter : '') +
@@ -34,10 +34,8 @@ function addLibraryPath(env) {
 function getSharedLibPath() {
   if (common.isWindows) {
     return path.join(kExecPath, 'node.dll');
-  } else if (common.isOSX) {
-    return path.join(kExecPath, `libnode.${kShlibSuffix}`);
   }
-  return path.join(kExecPath, 'lib.target', `libnode.${kShlibSuffix}`);
+  return path.join(kExecPath, `libnode.${kShlibSuffix}`);
 }
 
 // Get the binary path of stack frames.
diff --git a/test/common/tls.js b/test/common/tls.js
index e7cacde74567075ed03b040ca189fa5265637557..2c91241c3b20b773e0abaea58e3a8eb37afe15ff 100644
--- a/test/common/tls.js
+++ b/test/common/tls.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 /* eslint-disable node-core/crypto-check */
 
 'use strict';
@@ -15,9 +14,9 @@ class TestTLSSocket extends net.Socket {
     this.handshake_list = [];
     // AES128-GCM-SHA256
     this.ciphers = Buffer.from('000002009c0', 'hex');
-    this.pre_master_secret =
+    this.pre_primary_secret =
       Buffer.concat([this.version, crypto.randomBytes(46)]);
-    this.master_secret = null;
+    this.primary_secret = null;
     this.write_seq = 0;
     this.client_random = crypto.randomBytes(32);
 
@@ -26,12 +25,12 @@ class TestTLSSocket extends net.Socket {
     });
 
     this.on('server_random', (server_random) => {
-      this.master_secret = PRF12('sha256', this.pre_master_secret,
-                                 'master secret',
-                                 Buffer.concat([this.client_random,
-                                                server_random]),
-                                 48);
-      const key_block = PRF12('sha256', this.master_secret,
+      this.primary_secret = PRF12('sha256', this.pre_primary_secret,
+                                  'primary secret',
+                                  Buffer.concat([this.client_random,
+                                                 server_random]),
+                                  48);
+      const key_block = PRF12('sha256', this.primary_secret,
                               'key expansion',
                               Buffer.concat([server_random,
                                              this.client_random]),
@@ -44,21 +43,21 @@ class TestTLSSocket extends net.Socket {
   createClientHello() {
     const compressions = Buffer.from('0100', 'hex'); // null
     const msg = addHandshakeHeader(0x01, Buffer.concat([
-      this.version, this.client_random, this.ciphers, compressions
+      this.version, this.client_random, this.ciphers, compressions,
     ]));
     this.emit('handshake', msg);
     return addRecordHeader(0x16, msg);
   }
 
   createClientKeyExchange() {
-    const encrypted_pre_master_secret = crypto.publicEncrypt({
+    const encrypted_pre_primary_secret = crypto.publicEncrypt({
       key: this.server_cert,
       padding: crypto.constants.RSA_PKCS1_PADDING
-    }, this.pre_master_secret);
+    }, this.pre_primary_secret);
     const length = Buffer.alloc(2);
-    length.writeUIntBE(encrypted_pre_master_secret.length, 0, 2);
+    length.writeUIntBE(encrypted_pre_primary_secret.length, 0, 2);
     const msg = addHandshakeHeader(0x10, Buffer.concat([
-      length, encrypted_pre_master_secret]));
+      length, encrypted_pre_primary_secret]));
     this.emit('handshake', msg);
     return addRecordHeader(0x16, msg);
   }
@@ -67,7 +66,7 @@ class TestTLSSocket extends net.Socket {
     const shasum = crypto.createHash('sha256');
     shasum.update(Buffer.concat(this.handshake_list));
     const message_hash = shasum.digest();
-    const r = PRF12('sha256', this.master_secret,
+    const r = PRF12('sha256', this.primary_secret,
                     'client finished', message_hash, 12);
     const msg = addHandshakeHeader(0x14, r);
     this.emit('handshake', msg);
diff --git a/test/common/tmpdir.js b/test/common/tmpdir.js
index 94ee600724f0615600a10c15fe7df4249614a06a..0bafea1582b38d51c14169bd8e6c50915e2aebb3 100644
--- a/test/common/tmpdir.js
+++ b/test/common/tmpdir.js
@@ -1,11 +1,11 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
 const fs = require('fs');
 const path = require('path');
+const { isMainThread } = require('worker_threads');
 
-function rimrafSync(pathname) {
-  fs.rmdirSync(pathname, { maxRetries: 3, recursive: true });
+function rmSync(pathname) {
+  fs.rmSync(pathname, { maxRetries: 3, recursive: true, force: true });
 }
 
 const testRoot = process.env.NODE_TEST_DIR ?
@@ -13,12 +13,46 @@ const testRoot = process.env.NODE_TEST_DIR ?
 
 // Using a `.` prefixed name, which is the convention for "hidden" on POSIX,
 // gets tools to ignore it by default or by simple rules, especially eslint.
-const tmpdirName = '.tmp.' + (process.env.TEST_THREAD_ID || '0');
+const tmpdirName = '.tmp.' +
+  (process.env.TEST_SERIAL_ID || process.env.TEST_THREAD_ID || '0');
 const tmpPath = path.join(testRoot, tmpdirName);
 
+let firstRefresh = true;
 function refresh() {
-  rimrafSync(this.path);
+  rmSync(this.path);
   fs.mkdirSync(this.path);
+
+  if (firstRefresh) {
+    firstRefresh = false;
+    // Clean only when a test uses refresh. This allows for child processes to
+    // use the tmpdir and only the parent will clean on exit.
+    process.on('exit', onexit);
+  }
+}
+
+function onexit() {
+  // Change directory to avoid possible EBUSY
+  if (isMainThread)
+    process.chdir(testRoot);
+
+  try {
+    rmSync(tmpPath);
+  } catch (e) {
+    console.error('Can\'t clean tmpdir:', tmpPath);
+
+    const files = fs.readdirSync(tmpPath);
+    console.error('Files blocking:', files);
+
+    if (files.some((f) => f.startsWith('.nfs'))) {
+      // Warn about NFS "silly rename"
+      console.error('Note: ".nfs*" might be files that were open and ' +
+                    'unlinked but not closed.');
+      console.error('See http://nfs.sourceforge.net/#faq_d2 for details.');
+    }
+
+    console.error();
+    throw e;
+  }
 }
 
 module.exports = {
diff --git a/test/common/udppair.js b/test/common/udppair.js
index a7e532a99778e9f8b8585f53f4cb25c7a1b5c884..6213f4becfd6aa5edf6dd17bbdac7d14f2bcedd7 100644
--- a/test/common/udppair.js
+++ b/test/common/udppair.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 const { internalBinding } = require('internal/test/binding');
 const { JSUDPWrap } = internalBinding('js_udp_wrap');
diff --git a/test/common/wpt.js b/test/common/wpt.js
index 60891f1ca338fedc9e7d5c02b8e461a5222bfe0d..c394b67e926335203b2693eaeb1b52173e3ca309 100644
--- a/test/common/wpt.js
+++ b/test/common/wpt.js
@@ -1,4 +1,3 @@
-/* eslint-disable node-core/require-common-first, node-core/required-modules */
 'use strict';
 
 const assert = require('assert');
@@ -9,7 +8,7 @@ const path = require('path');
 const { inspect } = require('util');
 const { Worker } = require('worker_threads');
 
-// https://github.com/w3c/testharness.js/blob/master/testharness.js
+// https://github.com/web-platform-tests/wpt/blob/HEAD/resources/testharness.js
 // TODO: get rid of this half-baked harness in favor of the one
 // pulled from WPT
 const harnessMock = {
diff --git a/test/common/wpt/worker.js b/test/common/wpt/worker.js
index f0faeeba9e8062492f1ab2adc5c43adfff684f53..9039dada35b6999101377391ddb2d6643f636d91 100644
--- a/test/common/wpt/worker.js
+++ b/test/common/wpt/worker.js
@@ -1,5 +1,3 @@
-/* eslint-disable node-core/required-modules,node-core/require-common-first */
-
 'use strict';
 
 const { runInThisContext } = require('vm');
diff --git a/test/doctool/test-apilinks.js b/test/doctool/test-apilinks.mjs
similarity index 71%
rename from test/doctool/test-apilinks.js
rename to test/doctool/test-apilinks.mjs
index 91de4b79f865f40fed58cded2ad7acdea626388e..e3c334b19e7234c93e3b5cd7285ff19ec8ee70bb 100644
--- a/test/doctool/test-apilinks.js
+++ b/test/doctool/test-apilinks.mjs
@@ -1,14 +1,15 @@
-'use strict';
-
-require('../common');
-const fixtures = require('../common/fixtures');
-const tmpdir = require('../common/tmpdir');
-const fs = require('fs');
-const assert = require('assert');
-const path = require('path');
-const { execFileSync } = require('child_process');
-
-const script = path.join(__dirname, '..', '..', 'tools', 'doc', 'apilinks.js');
+import '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import tmpdir from '../common/tmpdir.js';
+
+import assert from 'assert';
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const script = fileURLToPath(
+  new URL('../../tools/doc/apilinks.mjs', import.meta.url));
 const apilinks = fixtures.path('apilinks');
 
 tmpdir.refresh();
diff --git a/test/doctool/test-doctool-html.js b/test/doctool/test-doctool-html.mjs
similarity index 67%
rename from test/doctool/test-doctool-html.js
rename to test/doctool/test-doctool-html.mjs
index 1608eb049702225f11d11752f65d8f93402cd302..bf3475c6a61d0f21ac295aa32ff40921bc35c0ce 100644
--- a/test/doctool/test-doctool-html.js
+++ b/test/doctool/test-doctool-html.mjs
@@ -1,22 +1,14 @@
-'use strict';
+import '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
 
-const common = require('../common');
-// The doctool currently uses js-yaml from the tool/node_modules/eslint/ tree.
-try {
-  require('../../tools/node_modules/eslint/node_modules/js-yaml');
-} catch {
-  common.skip('missing js-yaml (eslint not present)');
-}
+import assert from 'assert';
+import { readFileSync } from 'fs';
+import { createRequire } from 'module';
 
-const assert = require('assert');
-const { readFileSync } = require('fs');
-const fixtures = require('../common/fixtures');
-const { replaceLinks } = require('../../tools/doc/markdown.js');
-const html = require('../../tools/doc/html.js');
-const path = require('path');
+import * as html from '../../tools/doc/html.mjs';
+import { replaceLinks } from '../../tools/doc/markdown.mjs';
 
-module.paths.unshift(
-  path.join(__dirname, '..', '..', 'tools', 'doc', 'node_modules'));
+const require = createRequire(new URL('../../tools/doc/', import.meta.url));
 const unified = require('unified');
 const markdown = require('remark-parse');
 const remark2rehype = require('remark-rehype');
@@ -44,7 +36,7 @@ function toHTML({ input, filename, nodeVersion, versions }) {
     .use(html.preprocessText, { nodeVersion })
     .use(html.preprocessElements, { filename })
     .use(html.buildToc, { filename, apilinks: {} })
-    .use(remark2rehype, { allowDangerousHTML: true })
+    .use(remark2rehype, { allowDangerousHtml: true })
     .use(raw)
     .use(htmlStringify)
     .processSync(input);
@@ -60,24 +52,25 @@ function toHTML({ input, filename, nodeVersion, versions }) {
 const testData = [
   {
     file: fixtures.path('order_of_end_tags_5873.md'),
-    html: '<h3>Static method: Buffer.from(array) <span> ' +
+    html: '<h4>Static method: Buffer.from(array) <span> ' +
       '<a class="mark" href="#foo_static_method_buffer_from_array" ' +
-      'id="foo_static_method_buffer_from_array">#</a> </span> </h3>' +
+      'id="foo_static_method_buffer_from_array">#</a> </span> </h4>' +
       '<ul><li><code>array</code><a ' +
       'href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/' +
       'Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li></ul>'
   },
   {
     file: fixtures.path('doc_with_yaml.md'),
-    html: '<h1>Sample Markdown with YAML info' +
+    html: '<h2>Sample Markdown with YAML info' +
       '<span><a class="mark" href="#foo_sample_markdown_with_yaml_info" ' +
-      ' id="foo_sample_markdown_with_yaml_info">#</a></span></h1>' +
-      '<h2>Foobar<span><a class="mark" href="#foo_foobar" ' +
-      'id="foo_foobar">#</a></span></h2>' +
+      ' id="foo_sample_markdown_with_yaml_info">#</a></span></h2>' +
+      '<section><h3>Foobar<span><a class="mark" href="#foo_foobar" ' +
+      'id="foo_foobar">#</a></span></h3>' +
       '<div class="api_metadata"><span>Added in: v1.0.0</span></div> ' +
       '<p>Describe <code>Foobar</code> in more detail here.</p>' +
-      '<h2>Foobar II<span><a class="mark" href="#foo_foobar_ii" ' +
-      'id="foo_foobar_ii">#</a></span></h2><div class="api_metadata">' +
+      '</section><section>' +
+      '<h3>Foobar II<span><a class="mark" href="#foo_foobar_ii" ' +
+      'id="foo_foobar_ii">#</a></span></h3><div class="api_metadata">' +
       '<details class="changelog"><summary>History</summary>' +
       '<table><tbody><tr><th>Version</th><th>Changes</th></tr>' +
       '<tr><td>v5.3.0, v4.2.0</td>' +
@@ -86,16 +79,18 @@ const testData = [
       'an arrow function.</p></td></tr></tbody></table></details></div> ' +
       '<p>Describe <code>Foobar II</code> in more detail here.' +
       '<a href="http://man7.org/linux/man-pages/man1/fg.1.html"><code>fg(1)' +
-      '</code></a></p><h2>Deprecated thingy<span><a class="mark" ' +
+      '</code></a></p></section><section>' +
+      '<h3>Deprecated thingy<span><a class="mark" ' +
       'href="#foo_deprecated_thingy" id="foo_deprecated_thingy">#</a>' +
-      '</span></h2><div class="api_metadata"><span>Added in: v1.0.0</span>' +
+      '</span></h3><div class="api_metadata"><span>Added in: v1.0.0</span>' +
       '<span>Deprecated since: v2.0.0</span></div><p>Describe ' +
       '<code>Deprecated thingy</code> in more detail here.' +
       '<a href="http://man7.org/linux/man-pages/man1/fg.1p.html"><code>fg(1p)' +
-      '</code></a></p><h2>Something<span><a class="mark" href="#foo_something' +
-      '" id="foo_something">#</a></span></h2> ' +
+      '</code></a></p></section><section>' +
+      '<h3>Something<span><a class="mark" href="#foo_something' +
+      '" id="foo_something">#</a></span></h3> ' +
       '<!-- This is not a metadata comment --> ' +
-      '<p>Describe <code>Something</code> in more detail here. </p>'
+      '<p>Describe <code>Something</code> in more detail here. </p></section>'
   },
   {
     file: fixtures.path('sample_document.md'),
@@ -108,23 +103,33 @@ const testData = [
   },
   {
     file: fixtures.path('document_with_links.md'),
-    html: '<h1>Usage and Example<span><a class="mark"' +
+    html: '<h2>Usage and Example<span><a class="mark"' +
     'href="#foo_usage_and_example" id="foo_usage_and_example">#</a>' +
-    '</span></h1><h2>Usage<span><a class="mark" href="#foo_usage"' +
-    'id="foo_usage">#</a></span></h2><p><code>node \\[options\\] index.js' +
+    '</span></h2><section><h3>Usage<span><a class="mark" href="#foo_usage"' +
+    'id="foo_usage">#</a></span></h3><p><code>node \\[options\\] index.js' +
     '</code></p><p>Please see the<a href="cli.html#cli-options">' +
-    'Command Line Options</a>document for more information.</p><h2>' +
+    'Command Line Options</a>document for more information.</p>' +
+    '</section><section><h3>' +
     'Example<span><a class="mark" href="#foo_example" id="foo_example">' +
-    '#</a></span></h2><p>An example of a<a href="example.html">' +
+    '#</a></span></h3><p>An example of a<a href="example.html">' +
     'webserver</a>written with Node.js which responds with<code>' +
-    '\'Hello, World!\'</code>:</p><h2>See also<span><a class="mark"' +
-    'href="#foo_see_also" id="foo_see_also">#</a></span></h2><p>Check' +
-    'out also<a href="https://nodejs.org/">this guide</a></p>'
+    '\'Hello, World!\'</code>:</p></section><section>' +
+    '<h3>See also<span><a class="mark"' +
+    'href="#foo_see_also" id="foo_see_also">#</a></span></h3><p>Check' +
+    'out also<a href="https://nodejs.org/">this guide</a></p></section>'
   },
   {
     file: fixtures.path('document_with_special_heading.md'),
     html: '<title>Sample markdown with special heading |',
-  }
+  },
+  {
+    file: fixtures.path('document_with_esm_and_cjs_code_snippet.md'),
+    html: '<input class="js-flavor-selector" type="checkbox" checked',
+  },
+  {
+    file: fixtures.path('document_with_cjs_and_esm_code_snippet.md'),
+    html: '<input class="js-flavor-selector" type="checkbox" aria-label',
+  },
 ];
 
 const spaces = /\s/g;
diff --git a/test/doctool/test-doctool-json.js b/test/doctool/test-doctool-json.mjs
similarity index 85%
rename from test/doctool/test-doctool-json.js
rename to test/doctool/test-doctool-json.mjs
index 36d76cfec8236b1b307c8e3564e1afbda41eb9cf..d3badf84f553b2c1cfcc7fe8b8cd8e4e728f400f 100644
--- a/test/doctool/test-doctool-json.js
+++ b/test/doctool/test-doctool-json.mjs
@@ -1,21 +1,13 @@
-'use strict';
+import * as common from '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
 
-const common = require('../common');
-// The doctool currently uses js-yaml from the tool/node_modules/eslint/ tree.
-try {
-  require('../../tools/node_modules/eslint/node_modules/js-yaml');
-} catch {
-  common.skip('missing js-yaml (eslint not present)');
-}
+import assert from 'assert';
+import fs from 'fs';
+import { createRequire } from 'module';
 
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const fixtures = require('../common/fixtures');
-const json = require('../../tools/doc/json.js');
+import * as json from '../../tools/doc/json.mjs';
 
-module.paths.unshift(
-  path.join(__dirname, '..', '..', 'tools', 'doc', 'node_modules'));
+const require = createRequire(new URL('../../tools/doc/', import.meta.url));
 const unified = require('unified');
 const markdown = require('remark-parse');
 
@@ -79,7 +71,7 @@ const testData = [
                   name: 'array',
                   type: 'Array'
                 }]
-              }
+              },
             ]
           }],
           type: 'module',
@@ -121,8 +113,7 @@ const testData = [
                   { 'version': 'v4.2.0',
                     'pr-url': 'https://github.com/nodejs/node/pull/3276',
                     'description': 'The `error` parameter can now be ' +
-                      'an arrow function.'
-                  }
+                      'an arrow function.' },
                 ]
               },
               desc: '<p>Describe <code>Foobar II</code> in more detail ' +
@@ -150,11 +141,11 @@ const testData = [
                 'Describe <code>Something</code> in more detail here.</p>',
               type: 'module',
               displayName: 'Something'
-            }
+            },
           ],
           type: 'module',
           displayName: 'Sample Markdown with YAML info'
-        }
+        },
       ]
     }
   },
@@ -171,7 +162,7 @@ const testData = [
             {
               name: 'fullName',
               textRaw: '`Fqhqwhgads.fullName`'
-            }
+            },
           ],
           classMethods: [
             {
@@ -179,18 +170,18 @@ const testData = [
               signatures: [
                 {
                   params: []
-                }
+                },
               ],
               textRaw: 'Static method: `Fhqwhgads.again()`',
               type: 'classMethod'
-            }
+            },
           ],
           classes: [
             {
               textRaw: 'Class: `ComeOn`',
               type: 'class',
               name: 'ComeOn'
-            }
+            },
           ],
           ctors: [
             {
@@ -198,11 +189,11 @@ const testData = [
               signatures: [
                 {
                   params: []
-                }
+                },
               ],
               textRaw: 'Constructor: `new Fhqwhgads()`',
               type: 'ctor'
-            }
+            },
           ],
           methods: [
             {
@@ -210,7 +201,7 @@ const testData = [
               type: 'method',
               name: 'to',
               signatures: [{ params: [] }]
-            }
+            },
           ],
           events: [
             {
@@ -218,21 +209,19 @@ const testData = [
               type: 'event',
               name: 'FHQWHfest',
               params: []
-            }
+            },
           ],
           type: 'module',
           displayName: 'Fhqwhgads'
-        }
+        },
       ]
     }
-  }
+  },
 ];
 
 testData.forEach((item) => {
-  fs.readFile(item.file, 'utf8', common.mustCall((err, input) => {
-    assert.ifError(err);
-    toJSON(input, 'foo', common.mustCall((err, output) => {
-      assert.ifError(err);
+  fs.readFile(item.file, 'utf8', common.mustSucceed((input) => {
+    toJSON(input, 'foo', common.mustSucceed((output) => {
       assert.deepStrictEqual(output.json, item.json);
     }));
   }));
diff --git a/test/doctool/test-doctool-versions.js b/test/doctool/test-doctool-versions.mjs
similarity index 86%
rename from test/doctool/test-doctool-versions.js
rename to test/doctool/test-doctool-versions.mjs
index 5673cc79402df70b7d4511526c0219760d86841e..92dedab9cc49ea0e3cb261c4a88a6e6116d36acc 100644
--- a/test/doctool/test-doctool-versions.js
+++ b/test/doctool/test-doctool-versions.mjs
@@ -1,15 +1,16 @@
-'use strict';
+import '../common/index.mjs';
+import tmpdir from '../common/tmpdir.js';
 
-require('../common');
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const tmpdir = require('../common/tmpdir');
-const util = require('util');
+import assert from 'assert';
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import util from 'util';
 
 const debuglog = util.debuglog('test');
-const versionsTool = path.resolve(__dirname, '../../tools/doc/versions.js');
+const versionsTool = fileURLToPath(
+  new URL('../../tools/doc/versions.mjs', import.meta.url));
 
 // At the time of writing these are the minimum expected versions.
 // New versions of Node.js do not have to be explicitly added here.
diff --git a/test/doctool/test-local-md-file-reference-regex.mjs b/test/doctool/test-local-md-file-reference-regex.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..3cc312b84010221c54e25028f6142664fddd98d0
--- /dev/null
+++ b/test/doctool/test-local-md-file-reference-regex.mjs
@@ -0,0 +1,46 @@
+import '../common/index.mjs';
+
+import assert from 'assert';
+
+import { referenceToLocalMdFile } from '../../tools/doc/markdown.mjs';
+
+{
+  const shouldBeSpotted = [
+    'test.md',
+    'TEST.MD',
+    'test.js.md',
+    '.test.md',
+    './test.md',
+    'subfolder/test.md',
+    '../test.md',
+    'test.md#anchor',
+    'subfolder/test.md#anchor',
+    '/test.md',
+  ];
+
+  shouldBeSpotted.forEach((url) => {
+    assert.match(url, referenceToLocalMdFile);
+  });
+}
+
+{
+  const shouldNotBeSpotted = [
+    'https://example.com/test.md',
+    'HTTPS://EXAMPLE.COM/TEST.MD',
+    'git+https://example.com/test.md',
+    'ftp://1.1.1.1/test.md',
+    'urn:isbn:9780307476463.md',
+    'file://./test.md',
+    '/dev/null',
+    'test.html',
+    'test.html#anchor.md',
+    'test.html?anchor.md',
+    'test.md5',
+    'testmd',
+    '.md',
+  ];
+
+  shouldNotBeSpotted.forEach((url) => {
+    assert.doesNotMatch(url, referenceToLocalMdFile);
+  });
+}
diff --git a/test/doctool/test-make-doc.js b/test/doctool/test-make-doc.mjs
similarity index 75%
rename from test/doctool/test-make-doc.js
rename to test/doctool/test-make-doc.mjs
index 7f4f3ae6fbfdfaf5ab04f3fa04109e1c7d376122..06ec6e028bf4e8a0be583885a33df54f59e63dee 100644
--- a/test/doctool/test-make-doc.js
+++ b/test/doctool/test-make-doc.mjs
@@ -1,5 +1,9 @@
-'use strict';
-const common = require('../common');
+import * as common from '../common/index.mjs';
+
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+
 if (common.isWindows) {
   common.skip('`make doc` does not run on Windows');
 }
@@ -7,14 +11,10 @@ if (common.isWindows) {
 // This tests that `make doc` generates the documentation properly.
 // Note that for this test to pass, `make doc` must be run first.
 
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-
-const apiPath = path.resolve(__dirname, '..', '..', 'out', 'doc', 'api');
-const mdPath = path.resolve(__dirname, '..', '..', 'doc', 'api');
-const allMD = fs.readdirSync(mdPath);
-const allDocs = fs.readdirSync(apiPath);
+const apiURL = new URL('../../out/doc/api/', import.meta.url);
+const mdURL = new URL('../../doc/api/', import.meta.url);
+const allMD = fs.readdirSync(mdURL);
+const allDocs = fs.readdirSync(apiURL);
 assert.ok(allDocs.includes('index.html'));
 
 const actualDocs = allDocs.filter(
@@ -33,7 +33,7 @@ for (const name of actualDocs) {
   );
 }
 
-const toc = fs.readFileSync(path.resolve(apiPath, 'index.html'), 'utf8');
+const toc = fs.readFileSync(new URL('./index.html', apiURL), 'utf8');
 const re = /href="([^/]+\.html)"/;
 const globalRe = new RegExp(re, 'g');
 const links = toc.match(globalRe);
@@ -56,8 +56,9 @@ for (const actualDoc of actualDocs) {
   assert.ok(
     expectedDocs.includes(actualDoc), `${actualDoc} does not match TOC`);
 
-  assert.ok(
-    fs.statSync(path.join(apiPath, actualDoc)).size !== 0,
+  assert.notStrictEqual(
+    fs.statSync(new URL(`./${actualDoc}`, apiURL)).size,
+    0,
     `${actualDoc} is empty`
   );
 }
diff --git a/test/embedding/embedtest.cc b/test/embedding/embedtest.cc
index 23a3d25307d98a1a59e2746aeb939fcafe0ecff3..fece8924ad6471c8cc3da5ae1d0d8c5b50fcd6da 100644
--- a/test/embedding/embedtest.cc
+++ b/test/embedding/embedtest.cc
@@ -16,8 +16,8 @@ using v8::Local;
 using v8::Locker;
 using v8::MaybeLocal;
 using v8::SealHandleScope;
-using v8::Value;
 using v8::V8;
+using v8::Value;
 
 static int RunNodeInstance(MultiIsolatePlatform* platform,
                            const std::vector<std::string>& args,
@@ -63,7 +63,7 @@ int RunNodeInstance(MultiIsolatePlatform* platform,
   std::shared_ptr<ArrayBufferAllocator> allocator =
       ArrayBufferAllocator::Create();
 
-  Isolate* isolate = NewIsolate(allocator.get(), &loop, platform);
+  Isolate* isolate = NewIsolate(allocator, &loop, platform);
   if (isolate == nullptr) {
     fprintf(stderr, "%s: Failed to initialize V8 Isolate\n", args[0].c_str());
     return 1;
@@ -110,12 +110,14 @@ int RunNodeInstance(MultiIsolatePlatform* platform,
         more = uv_loop_alive(&loop);
         if (more) continue;
 
-        node::EmitBeforeExit(env.get());
+        if (node::EmitProcessBeforeExit(env.get()).IsNothing())
+          break;
+
         more = uv_loop_alive(&loop);
       } while (more == true);
     }
 
-    exit_code = node::EmitExit(env.get());
+    exit_code = node::EmitProcessExit(env.get()).FromMaybe(1);
 
     node::Stop(env.get());
   }
diff --git a/test/es-module/test-esm-cjs-load-error-note.mjs b/test/es-module/test-esm-cjs-load-error-note.mjs
index c0ac9393a8ddd5149c19fd2f04bf18433654a2d3..ae34131e85ef84937641f738dafc72873f68388f 100644
--- a/test/es-module/test-esm-cjs-load-error-note.mjs
+++ b/test/es-module/test-esm-cjs-load-error-note.mjs
@@ -10,6 +10,10 @@ const Import2 = fixtures.path('/es-modules/es-note-promiserej-import-2.cjs');
 const Import3 = fixtures.path('/es-modules/es-note-unexpected-import-3.cjs');
 const Import4 = fixtures.path('/es-modules/es-note-unexpected-import-4.cjs');
 const Import5 = fixtures.path('/es-modules/es-note-unexpected-import-5.cjs');
+const Error1 = fixtures.path('/es-modules/es-note-error-1.mjs');
+const Error2 = fixtures.path('/es-modules/es-note-error-2.mjs');
+const Error3 = fixtures.path('/es-modules/es-note-error-3.mjs');
+const Error4 = fixtures.path('/es-modules/es-note-error-4.mjs');
 
 // Expect note to be included in the error output
 const expectedNote = 'To load an ES module, ' +
@@ -106,3 +110,55 @@ pImport5.on('close', mustCall((code) => {
   assert.ok(!pImport5Stderr.includes(expectedNote),
             `${expectedNote} must not be included in ${pImport5Stderr}`);
 }));
+
+const pError1 = spawn(process.execPath, [Error1]);
+let pError1Stderr = '';
+pError1.stderr.setEncoding('utf8');
+pError1.stderr.on('data', (data) => {
+  pError1Stderr += data;
+});
+pError1.on('close', mustCall((code) => {
+  assert.strictEqual(code, expectedCode);
+  assert.ok(pError1Stderr.includes('Error: some error'));
+  assert.ok(!pError1Stderr.includes(expectedNote),
+            `${expectedNote} must not be included in ${pError1Stderr}`);
+}));
+
+const pError2 = spawn(process.execPath, [Error2]);
+let pError2Stderr = '';
+pError2.stderr.setEncoding('utf8');
+pError2.stderr.on('data', (data) => {
+  pError2Stderr += data;
+});
+pError2.on('close', mustCall((code) => {
+  assert.strictEqual(code, expectedCode);
+  assert.ok(pError2Stderr.includes('string'));
+  assert.ok(!pError2Stderr.includes(expectedNote),
+            `${expectedNote} must not be included in ${pError2Stderr}`);
+}));
+
+const pError3 = spawn(process.execPath, [Error3]);
+let pError3Stderr = '';
+pError3.stderr.setEncoding('utf8');
+pError3.stderr.on('data', (data) => {
+  pError3Stderr += data;
+});
+pError3.on('close', mustCall((code) => {
+  assert.strictEqual(code, expectedCode);
+  assert.ok(pError3Stderr.includes('null'));
+  assert.ok(!pError3Stderr.includes(expectedNote),
+            `${expectedNote} must not be included in ${pError3Stderr}`);
+}));
+
+const pError4 = spawn(process.execPath, [Error4]);
+let pError4Stderr = '';
+pError4.stderr.setEncoding('utf8');
+pError4.stderr.on('data', (data) => {
+  pError4Stderr += data;
+});
+pError4.on('close', mustCall((code) => {
+  assert.strictEqual(code, expectedCode);
+  assert.ok(pError4Stderr.includes('undefined'));
+  assert.ok(!pError4Stderr.includes(expectedNote),
+            `${expectedNote} must not be included in ${pError4Stderr}`);
+}));
diff --git a/test/es-module/test-esm-custom-exports.mjs b/test/es-module/test-esm-custom-exports.mjs
index cf0557fa44215e20f1a2d69ba9b0440efd5967e1..e6023387cf8afc43796e05c13da897cad6e40c8a 100644
--- a/test/es-module/test-esm-custom-exports.mjs
+++ b/test/es-module/test-esm-custom-exports.mjs
@@ -1,4 +1,4 @@
-// Flags: --conditions=custom-condition --conditions another
+// Flags: --conditions=custom-condition -C another
 import { mustCall } from '../common/index.mjs';
 import { strictEqual } from 'assert';
 import { requireFixture, importFixture } from '../fixtures/pkgexports.mjs';
diff --git a/test/es-module/test-esm-data-urls.js b/test/es-module/test-esm-data-urls.js
index 282aaf1857a0df8ab44bbd59eb39920932e0e7a7..ba8bd4c95746c051d4c30b7ab2f7a02d78235c68 100644
--- a/test/es-module/test-esm-data-urls.js
+++ b/test/es-module/test-esm-data-urls.js
@@ -99,7 +99,7 @@ function createBase64URL(mime, body) {
       await import(plainESMURL);
       common.mustNotCall()();
     } catch (e) {
-      assert.strictEqual(e.code, 'ERR_INVALID_RETURN_PROPERTY_VALUE');
+      assert.strictEqual(e.code, 'ERR_INVALID_MODULE_SPECIFIER');
     }
   }
   {
diff --git a/test/es-module/test-esm-dynamic-import.js b/test/es-module/test-esm-dynamic-import.js
index 6f8757da1b914e31e7718517335d67a32b290bf8..3df2191e3ba06b310870d4b7ff5d498f6ebb83f8 100644
--- a/test/es-module/test-esm-dynamic-import.js
+++ b/test/es-module/test-esm-dynamic-import.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
-const { URL } = require('url');
 
 const relativePath = '../fixtures/es-modules/test-esm-ok.mjs';
 const absolutePath = require.resolve('../fixtures/es-modules/test-esm-ok.mjs');
@@ -52,6 +51,8 @@ function expectFsNamespace(result) {
 
   expectModuleError(import('node:unknown'),
                     'ERR_UNKNOWN_BUILTIN_MODULE');
+  expectModuleError(import('node:internal/test/binding'),
+                    'ERR_UNKNOWN_BUILTIN_MODULE');
   expectModuleError(import('./not-an-existing-module.mjs'),
                     'ERR_MODULE_NOT_FOUND');
   expectModuleError(import('http://example.com/foo.js'),
diff --git a/test/es-module/test-esm-encoded-path.mjs b/test/es-module/test-esm-encoded-path.mjs
index 351cb7eab887b4c655ad5fc3b3c7e498084741cc..067ce6066697b6f1877f917003e3725147d5edbc 100644
--- a/test/es-module/test-esm-encoded-path.mjs
+++ b/test/es-module/test-esm-encoded-path.mjs
@@ -2,5 +2,8 @@ import '../common/index.mjs';
 import assert from 'assert';
 // ./test-esm-ok.mjs
 import ok from '../fixtures/es-modules/test-%65%73%6d-ok.mjs';
+// ./test-esm-comma,.mjs
+import comma from '../fixtures/es-modules/test-esm-comma%2c.mjs';
 
 assert(ok);
+assert(comma);
diff --git a/test/es-module/test-esm-error-cache.js b/test/es-module/test-esm-error-cache.js
index b13e793626876a377702adb04c1739d3f64b22bb..d780f1a22164d72e107203e720a167cf13423c8c 100644
--- a/test/es-module/test-esm-error-cache.js
+++ b/test/es-module/test-esm-error-cache.js
@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const file = '../fixtures/syntax/bad_syntax.mjs';
@@ -23,4 +23,4 @@ let error;
       return true;
     }
   );
-})();
+})().then(common.mustCall());
diff --git a/test/es-module/test-esm-exports.mjs b/test/es-module/test-esm-exports.mjs
index d234099732e3aace757ec929609210e218aa9cb7..73b6303df46cff78829be352d350e86a0ce3af66 100644
--- a/test/es-module/test-esm-exports.mjs
+++ b/test/es-module/test-esm-exports.mjs
@@ -35,7 +35,7 @@ import fromInside from '../fixtures/node_modules/pkgexports/lib/hole.js';
     ['pkgexports-sugar', { default: 'main' }],
     // Path patterns
     ['pkgexports/subpath/sub-dir1', { default: 'main' }],
-    ['pkgexports/features/dir1', { default: 'main' }]
+    ['pkgexports/features/dir1', { default: 'main' }],
   ]);
 
   if (isRequire) {
@@ -44,6 +44,11 @@ import fromInside from '../fixtures/node_modules/pkgexports/lib/hole.js';
     validSpecifiers.set('pkgexports/subpath/dir1/', { default: 'main' });
     validSpecifiers.set('pkgexports/subpath/dir2', { default: 'index' });
     validSpecifiers.set('pkgexports/subpath/dir2/', { default: 'index' });
+  } else {
+    // No exports or main field
+    validSpecifiers.set('no_exports', { default: 'index' });
+    // Main field without extension
+    validSpecifiers.set('default_index', { default: 'main' });
   }
 
   for (const [validSpecifier, expected] of validSpecifiers) {
@@ -162,10 +167,13 @@ import fromInside from '../fixtures/node_modules/pkgexports/lib/hole.js';
     }));
   }
 
-  // The use of %2F escapes in paths fails loading
+  // The use of %2F and %5C escapes in paths fails loading
   loadFixture('pkgexports/sub/..%2F..%2Fbar.js').catch(mustCall((err) => {
     strictEqual(err.code, 'ERR_INVALID_MODULE_SPECIFIER');
   }));
+  loadFixture('pkgexports/sub/..%5C..%5Cbar.js').catch(mustCall((err) => {
+    strictEqual(err.code, 'ERR_INVALID_MODULE_SPECIFIER');
+  }));
 
   // Package export with numeric index properties must throw a validation error
   loadFixture('pkgexports-numeric').catch(mustCall((err) => {
diff --git a/test/es-module/test-esm-fs-promises.mjs b/test/es-module/test-esm-fs-promises.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..76901f4fc168acb43ac810e546c01cbf16cbf8af
--- /dev/null
+++ b/test/es-module/test-esm-fs-promises.mjs
@@ -0,0 +1,5 @@
+import '../common/index.mjs';
+import { stat } from 'fs/promises';
+
+// Should not reject.
+stat(new URL(import.meta.url));
diff --git a/test/es-module/test-esm-import-meta-resolve.mjs b/test/es-module/test-esm-import-meta-resolve.mjs
index faf9320a82745adc9eba335c678ce90fe71a3bd8..1fac362172ae3401fe1e075729e76dff2497854f 100644
--- a/test/es-module/test-esm-import-meta-resolve.mjs
+++ b/test/es-module/test-esm-import-meta-resolve.mjs
@@ -1,5 +1,5 @@
 // Flags: --experimental-import-meta-resolve
-import '../common/index.mjs';
+import { mustCall } from '../common/index.mjs';
 import assert from 'assert';
 
 const dirname = import.meta.url.slice(0, import.meta.url.lastIndexOf('/') + 1);
@@ -19,6 +19,19 @@ const fixtures = dirname.slice(0, dirname.lastIndexOf('/', dirname.length - 2) +
     await import.meta.resolve('../fixtures/empty-with-bom.txt'),
     fixtures + 'empty-with-bom.txt');
   assert.strictEqual(await import.meta.resolve('../fixtures/'), fixtures);
+  assert.strictEqual(
+    await import.meta.resolve('../fixtures/', import.meta.url),
+    fixtures);
+  assert.strictEqual(
+    await import.meta.resolve('../fixtures/', new URL(import.meta.url)),
+    fixtures);
+  await Promise.all(
+    [[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
+      assert.rejects(import.meta.resolve('../fixtures/', arg), {
+        code: 'ERR_INVALID_ARG_TYPE',
+      })
+    )
+  );
   assert.strictEqual(await import.meta.resolve('baz/', fixtures),
                      fixtures + 'node_modules/baz/');
-})();
+})().then(mustCall());
diff --git a/test/es-module/test-esm-imports.mjs b/test/es-module/test-esm-imports.mjs
index 694496a2ff2c935ea25ed22b16013072080d94c8..97bdc618c70d23c74530e0f3103ef9ac47de02fe 100644
--- a/test/es-module/test-esm-imports.mjs
+++ b/test/es-module/test-esm-imports.mjs
@@ -53,13 +53,15 @@ const { requireImport, importImport } = importer;
     // Backtracking below the package base
     ['#subpath/sub/../../../belowbase', 'request is not a valid subpath'],
     // Percent-encoded slash errors
-    ['#external/subpath/x%2Fy', 'must not include encoded "/"'],
+    ['#external/subpath/x%2Fy', 'must not include encoded "/" or "\\"'],
+    ['#external/subpath/x%5Cy', 'must not include encoded "/" or "\\"'],
     // Target must have a name
     ['#', '#'],
     // Initial slash target must have a leading name
     ['#/initialslash', '#/initialslash'],
     // Percent-encoded target paths
-    ['#percent', 'must not include encoded "/"'],
+    ['#encodedslash', 'must not include encoded "/" or "\\"'],
+    ['#encodedbackslash', 'must not include encoded "/" or "\\"'],
   ]);
 
   for (const [specifier, expected] of invalidImportSpecifiers) {
diff --git a/test/es-module/test-esm-invalid-data-urls.js b/test/es-module/test-esm-invalid-data-urls.js
new file mode 100644
index 0000000000000000000000000000000000000000..67f0bfe4e25588496dc50bbc1ef8ff0ee70777bb
--- /dev/null
+++ b/test/es-module/test-esm-invalid-data-urls.js
@@ -0,0 +1,24 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+(async () => {
+  await assert.rejects(import('data:text/plain,export default0'), {
+    code: 'ERR_INVALID_MODULE_SPECIFIER',
+    message:
+      'Invalid module "data:text/plain,export default0" has an unsupported ' +
+      'MIME type "text/plain"',
+  });
+  await assert.rejects(import('data:text/plain;base64,'), {
+    code: 'ERR_INVALID_MODULE_SPECIFIER',
+    message:
+      'Invalid module "data:text/plain;base64," has an unsupported ' +
+      'MIME type "text/plain"',
+  });
+  await assert.rejects(import('data:application/json,[]'), {
+    code: 'ERR_INVALID_MODULE_SPECIFIER',
+    message:
+      'Invalid module "data:application/json,[]" has an unsupported ' +
+      'MIME type "application/json"',
+  });
+})().then(common.mustCall());
diff --git a/test/es-module/test-esm-json.mjs b/test/es-module/test-esm-json.mjs
index ddcc7cb33e709f73166a8d2f5a096828c5dc96c4..df4f75fbd6e067557938712d983259e06bc53c9c 100644
--- a/test/es-module/test-esm-json.mjs
+++ b/test/es-module/test-esm-json.mjs
@@ -11,7 +11,7 @@ strictEqual(secret.ofLife, 42);
 // Test warning message
 const child = spawn(process.execPath, [
   '--experimental-json-modules',
-  path('/es-modules/json-modules.mjs')
+  path('/es-modules/json-modules.mjs'),
 ]);
 
 let stderr = '';
diff --git a/test/es-module/test-esm-loader-custom-condition.mjs b/test/es-module/test-esm-loader-custom-condition.mjs
index 26d1db4842f621333431e4ed5e925d332a7c3955..075e4fe2b66029f9ee1a1ef827f5af05f59a2ffc 100644
--- a/test/es-module/test-esm-loader-custom-condition.mjs
+++ b/test/es-module/test-esm-loader-custom-condition.mjs
@@ -1,7 +1,21 @@
 // Flags: --experimental-loader ./test/fixtures/es-module-loaders/loader-with-custom-condition.mjs
 import '../common/index.mjs';
 import assert from 'assert';
+import util from 'util';
 
 import * as ns from '../fixtures/es-modules/conditional-exports.mjs';
 
 assert.deepStrictEqual({ ...ns }, { default: 'from custom condition' });
+
+assert.strictEqual(
+  util.inspect(ns, { showHidden: false }),
+  "[Module: null prototype] { default: 'from custom condition' }"
+);
+
+assert.strictEqual(
+  util.inspect(ns, { showHidden: true }),
+  '[Module: null prototype] {\n' +
+  "  default: 'from custom condition',\n" +
+  "  [Symbol(Symbol.toStringTag)]: 'Module'\n" +
+  '}'
+);
diff --git a/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs b/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs
deleted file mode 100644
index 62781c37d482402362fbf64e95df36047b52a996..0000000000000000000000000000000000000000
--- a/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Flags: --experimental-loader ./test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs
-import { expectsError } from '../common/index.mjs';
-
-import('test').catch(expectsError({
-  code: 'ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK',
-  message: 'The ES Module loader may not return a format of \'dynamic\' ' +
-    'when no dynamicInstantiate function was provided'
-}));
diff --git a/test/es-module/test-esm-loader-modulemap.js b/test/es-module/test-esm-loader-modulemap.js
index a4d56a2c2fda1ced38863e1aad856064010cece9..2d74cd385be52bedbc88d6420274abf2af744f2e 100644
--- a/test/es-module/test-esm-loader-modulemap.js
+++ b/test/es-module/test-esm-loader-modulemap.js
@@ -7,7 +7,6 @@
 require('../common');
 
 const assert = require('assert');
-const { URL } = require('url');
 const { Loader } = require('internal/modules/esm/loader');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
diff --git a/test/es-module/test-esm-loader-search.js b/test/es-module/test-esm-loader-search.js
index 82450fd00ee94178e1d7a17c9325fc03dec77697..3c451409b356db259e6a0502313e2ce5dcc9cd71 100644
--- a/test/es-module/test-esm-loader-search.js
+++ b/test/es-module/test-esm-loader-search.js
@@ -11,7 +11,7 @@ const {
 } = require('internal/modules/esm/resolve');
 
 assert.throws(
-  () => resolve('target', undefined),
+  () => resolve('target'),
   {
     code: 'ERR_MODULE_NOT_FOUND',
     name: 'Error',
diff --git a/test/es-module/test-esm-named-exports.mjs b/test/es-module/test-esm-named-exports.mjs
index 7d8d1080082401e81b34ea90810adc8502d5a605..ce8599e68b1bf575d2e3e2faeefa3e392be3781a 100644
--- a/test/es-module/test-esm-named-exports.mjs
+++ b/test/es-module/test-esm-named-exports.mjs
@@ -1,8 +1,9 @@
 // Flags: --experimental-loader ./test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
 import '../common/index.mjs';
-import { readFile } from 'fs';
+import { readFile, __fromLoader } from 'fs';
 import assert from 'assert';
 import ok from '../fixtures/es-modules/test-esm-ok.mjs';
 
 assert(ok);
 assert(readFile);
+assert(__fromLoader);
diff --git a/test/es-module/test-esm-nowarn-exports.mjs b/test/es-module/test-esm-nowarn-exports.mjs
index 5e0927f4674f8453fc5e25d5d411c2ea7e227c6e..57d5bc58c7235685530a05d54f068571ce244305 100644
--- a/test/es-module/test-esm-nowarn-exports.mjs
+++ b/test/es-module/test-esm-nowarn-exports.mjs
@@ -5,7 +5,7 @@ import { spawn } from 'child_process';
 
 const child = spawn(process.execPath, [
   '--experimental-import-meta-resolve',
-  path('/es-modules/import-resolve-exports.mjs')
+  path('/es-modules/import-resolve-exports.mjs'),
 ]);
 
 let stderr = '';
diff --git a/test/es-module/test-esm-pkgname.mjs b/test/es-module/test-esm-pkgname.mjs
index 06b5d2d104df6337e1c4318a94e207b78cc6680b..5090d6c22ce68964e8514e9116d80c49a4839dca 100644
--- a/test/es-module/test-esm-pkgname.mjs
+++ b/test/es-module/test-esm-pkgname.mjs
@@ -7,6 +7,10 @@ importFixture('as%2Ff').catch(mustCall((err) => {
   strictEqual(err.code, 'ERR_INVALID_MODULE_SPECIFIER');
 }));
 
+importFixture('as%5Cf').catch(mustCall((err) => {
+  strictEqual(err.code, 'ERR_INVALID_MODULE_SPECIFIER');
+}));
+
 importFixture('as\\df').catch(mustCall((err) => {
   strictEqual(err.code, 'ERR_INVALID_MODULE_SPECIFIER');
 }));
diff --git a/test/es-module/test-esm-preserve-symlinks-main.js b/test/es-module/test-esm-preserve-symlinks-main.js
index 877066a6a4548ed27c43fb2a1cd8abd11fdd4d6e..b8fb301e02d85bee50782b3aaf45e88b1c0349b0 100644
--- a/test/es-module/test-esm-preserve-symlinks-main.js
+++ b/test/es-module/test-esm-preserve-symlinks-main.js
@@ -42,7 +42,7 @@ function doTest(flags, done) {
   spawn(process.execPath,
         flags.concat([
           '--preserve-symlinks',
-          '--preserve-symlinks-main', entry_link_absolute_path
+          '--preserve-symlinks-main', entry_link_absolute_path,
         ]),
         { stdio: 'inherit' }).on('exit', (code) => {
     assert.strictEqual(code, 0);
diff --git a/test/es-module/test-esm-repl.js b/test/es-module/test-esm-repl.js
index 653927b241694eb9c2548c2311080392acbbb94c..872d2c1f6ef8f454f6f503f4d10b9289372a5026 100644
--- a/test/es-module/test-esm-repl.js
+++ b/test/es-module/test-esm-repl.js
@@ -4,7 +4,7 @@ const assert = require('assert');
 const { spawn } = require('child_process');
 
 const child = spawn(process.execPath, [
-  '--interactive'
+  '--interactive',
 ]);
 child.stdin.end(`
 import('fs').then(
diff --git a/test/es-module/test-esm-specifiers.mjs b/test/es-module/test-esm-specifiers.mjs
index 8451a6a703bb65e45d80ab0cc615b6eee46882c0..bc6125f5f94ad9d809daa2cd6029c9fc312a25fd 100644
--- a/test/es-module/test-esm-specifiers.mjs
+++ b/test/es-module/test-esm-specifiers.mjs
@@ -51,7 +51,7 @@ main().catch(mustNotCall);
   );
   [
     '--experimental-specifier-resolution',
-    '--es-module-specifier-resolution'
+    '--es-module-specifier-resolution',
   ].forEach((option) => {
     spawn(process.execPath,
           [`${option}=node`, modulePath],
diff --git a/test/es-module/test-esm-symlink-type.js b/test/es-module/test-esm-symlink-type.js
index 1f46dce17f2e463c85352b21e18fc3f2828c7bb6..2537881f46c0e28453c334d3b1f08ad12f32e9c0 100644
--- a/test/es-module/test-esm-symlink-type.js
+++ b/test/es-module/test-esm-symlink-type.js
@@ -40,7 +40,7 @@ const symlinks = [
     target: fixtures.path('es-modules/package-without-type/index.js'),
     prints: 'package-without-type',
     errorsWithPreserveSymlinksMain: false
-  }
+  },
 ];
 
 symlinks.forEach((symlink) => {
@@ -49,7 +49,7 @@ symlinks.forEach((symlink) => {
 
   const flags = [
     '',
-    '--preserve-symlinks-main'
+    '--preserve-symlinks-main',
   ];
   flags.forEach((nodeOptions) => {
     const opts = {
diff --git a/test/es-module/test-esm-tla-unfinished.mjs b/test/es-module/test-esm-tla-unfinished.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..7d35c86285ac81b3cf80179f0b07c64bb66cf21a
--- /dev/null
+++ b/test/es-module/test-esm-tla-unfinished.mjs
@@ -0,0 +1,82 @@
+import '../common/index.mjs';
+import assert from 'assert';
+import child_process from 'child_process';
+import fixtures from '../common/fixtures.js';
+
+{
+  // Unresolved TLA promise, --eval
+  const { status, stdout, stderr } = child_process.spawnSync(
+    process.execPath,
+    ['--input-type=module', '--eval', 'await new Promise(() => {})'],
+    { encoding: 'utf8' });
+  assert.deepStrictEqual([status, stdout, stderr], [13, '', '']);
+}
+
+{
+  // Rejected TLA promise, --eval
+  const { status, stdout, stderr } = child_process.spawnSync(
+    process.execPath,
+    ['--input-type=module', '-e', 'await Promise.reject(new Error("Xyz"))'],
+    { encoding: 'utf8' });
+  assert.deepStrictEqual([status, stdout], [1, '']);
+  assert.match(stderr, /Error: Xyz/);
+}
+
+{
+  // Unresolved TLA promise with explicit exit code, --eval
+  const { status, stdout, stderr } = child_process.spawnSync(
+    process.execPath,
+    ['--input-type=module', '--eval',
+     'process.exitCode = 42;await new Promise(() => {})'],
+    { encoding: 'utf8' });
+  assert.deepStrictEqual([status, stdout, stderr], [42, '', '']);
+}
+
+{
+  // Rejected TLA promise with explicit exit code, --eval
+  const { status, stdout, stderr } = child_process.spawnSync(
+    process.execPath,
+    ['--input-type=module', '-e',
+     'process.exitCode = 42;await Promise.reject(new Error("Xyz"))'],
+    { encoding: 'utf8' });
+  assert.deepStrictEqual([status, stdout], [1, '']);
+  assert.match(stderr, /Error: Xyz/);
+}
+
+{
+  // Unresolved TLA promise, module file
+  const { status, stdout, stderr } = child_process.spawnSync(
+    process.execPath,
+    [fixtures.path('es-modules/tla/unresolved.mjs')],
+    { encoding: 'utf8' });
+  assert.deepStrictEqual([status, stdout, stderr], [13, '', '']);
+}
+
+{
+  // Rejected TLA promise, module file
+  const { status, stdout, stderr } = child_process.spawnSync(
+    process.execPath,
+    [fixtures.path('es-modules/tla/rejected.mjs')],
+    { encoding: 'utf8' });
+  assert.deepStrictEqual([status, stdout], [1, '']);
+  assert.match(stderr, /Error: Xyz/);
+}
+
+{
+  // Unresolved TLA promise, module file
+  const { status, stdout, stderr } = child_process.spawnSync(
+    process.execPath,
+    [fixtures.path('es-modules/tla/unresolved-withexitcode.mjs')],
+    { encoding: 'utf8' });
+  assert.deepStrictEqual([status, stdout, stderr], [42, '', '']);
+}
+
+{
+  // Rejected TLA promise, module file
+  const { status, stdout, stderr } = child_process.spawnSync(
+    process.execPath,
+    [fixtures.path('es-modules/tla/rejected-withexitcode.mjs')],
+    { encoding: 'utf8' });
+  assert.deepStrictEqual([status, stdout], [1, '']);
+  assert.match(stderr, /Error: Xyz/);
+}
diff --git a/test/es-module/test-esm-tla.mjs b/test/es-module/test-esm-tla.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..68a9d8954c5e2e272a099344f2054e25804b17a4
--- /dev/null
+++ b/test/es-module/test-esm-tla.mjs
@@ -0,0 +1,9 @@
+import '../common/index.mjs';
+import fixtures from '../common/fixtures.js';
+import assert from 'assert';
+import { pathToFileURL } from 'url';
+
+import(pathToFileURL(fixtures.path('/es-modules/tla/parent.mjs')))
+  .then(({ default: order }) => {
+    assert.deepStrictEqual(order, ['order', 'b', 'c', 'd', 'a', 'parent']);
+  });
diff --git a/test/es-module/test-esm-undefined-cjs-global-like-variables.js b/test/es-module/test-esm-undefined-cjs-global-like-variables.js
new file mode 100644
index 0000000000000000000000000000000000000000..10867919f6f036868e257218201726b30a46b2e4
--- /dev/null
+++ b/test/es-module/test-esm-undefined-cjs-global-like-variables.js
@@ -0,0 +1,42 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { pathToFileURL } = require('url');
+
+assert.rejects(
+  import('data:text/javascript,require;'),
+  /require is not defined in ES module scope, you can use import instead$/
+).then(common.mustCall());
+assert.rejects(
+  import('data:text/javascript,exports={};'),
+  /exports is not defined in ES module scope$/
+).then(common.mustCall());
+
+assert.rejects(
+  import('data:text/javascript,require_custom;'),
+  /^(?!in ES module scope)(?!use import instead).*$/
+).then(common.mustCall());
+
+const pkgUrl = pathToFileURL(fixtures.path('/es-modules/package-type-module/'));
+assert.rejects(
+  import(new URL('./cjs.js', pkgUrl)),
+  /use the '\.cjs' file extension/
+).then(common.mustCall());
+assert.rejects(
+  import(new URL('./cjs.js#target', pkgUrl)),
+  /use the '\.cjs' file extension/
+).then(common.mustCall());
+assert.rejects(
+  import(new URL('./cjs.js?foo=bar', pkgUrl)),
+  /use the '\.cjs' file extension/
+).then(common.mustCall());
+assert.rejects(
+  import(new URL('./cjs.js?foo=bar#target', pkgUrl)),
+  /use the '\.cjs' file extension/
+).then(common.mustCall());
+
+assert.rejects(
+  import('data:text/javascript,require;//.js'),
+  /^(?!use the '\.cjs' file extension).*$/
+).then(common.mustCall());
diff --git a/test/es-module/test-esm-wasm.mjs b/test/es-module/test-esm-wasm.mjs
index b2218ce2f09893ca0228dbaa118b90d671e8b5b3..877a841850dc4fd7d969bc319288acf86a5af6fe 100644
--- a/test/es-module/test-esm-wasm.mjs
+++ b/test/es-module/test-esm-wasm.mjs
@@ -19,7 +19,7 @@ strictEqual(addImported(1), 43);
 // Test warning message
 const child = spawn(process.execPath, [
   '--experimental-wasm-modules',
-  path('/es-modules/wasm-modules.mjs')
+  path('/es-modules/wasm-modules.mjs'),
 ]);
 
 let stderr = '';
diff --git a/test/fixtures/0-dns/0-dns-cert.pem b/test/fixtures/0-dns/0-dns-cert.pem
deleted file mode 100644
index 03a4db3e2d8501822539656c040fa54b8d7998b8..0000000000000000000000000000000000000000
--- a/test/fixtures/0-dns/0-dns-cert.pem
+++ /dev/null
@@ -1,19 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDGDCCAgCgAwIBAgIBATANBgkqhkiG9w0BAQsFADAZMRcwFQYDVQQDEw5jYS5l
-eGFtcGxlLmNvbTAeFw0xNzAzMDIwMTMxMjJaFw0yNzAyMjgwMTMxMjJaMBsxGTAX
-BgNVBAMTEGV2aWwuZXhhbXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
-ggEKAoIBAQDFyJT0kv2P9L6iNY6TL7IZonAR8R9ev7iD1tR5ycMEpM/y6WTefIco
-civMcBGVZWtCgkoePHiveH9UIep7HFGB4gxCYDZFYB46yGS0YH2fB5GWXTLYObYa
-zxuEhgFRG0DLIwNDRLW0+0FG3disp7YdRHBtdbL58F/qNORqPEjIpoQxOJc2UqX2
-/gfomJRdFW/PSgN7uH2QwMzRQRIrKmyAFzeuEWVP+UAV4853Yg66PmYpAASyt069
-sE8QNTNE75KrerMmYzH7AmTEGvY8bukrDuVQZce2/lcK2rAE+G6at2eBNMZKOnzR
-y9kWIiJ3rR7+WK55EKelLz0doZFKteu1AgMBAAGjaTBnMGUGA1UdEQReMFyCImdv
-b2QuZXhhbXBsZS5vcmcALmV2aWwuZXhhbXBsZS5jb22CGGp1c3QtYW5vdGhlci5l
-eGFtcGxlLmNvbYcECAgICIcECAgEBIIQbGFzdC5leGFtcGxlLmNvbTANBgkqhkiG
-9w0BAQsFAAOCAQEAvreVoOZO2gpM4Dmzp70D30XZjsK9i0BCsRHBvPLPw3y8B2xg
-BRtOREOI69NU0WGpj5Lbqww5M8M1hjHshiGEu2aXfZ6qM3lENaIMCpKlF9jbm02/
-wmxNaAnS8bDSZyO5rbsGr2tJb4ds7DazmMEKWhOBEpJoOp9rG6SAey+a6MkZ7NEN
-0p3THCqNf3lL1KblPrMvdsyhHPEzv4uT7+YAnLKHwGzbihcWJRsRo5oipWL8ZDhn
-bd3SMWtfRTSWDmghJaHke2xIjDtTwSjHjjPTFsK+rl227W8r4/EQI/X6fTQV2j3T
-7zqrJLF9h9F/v3mo57k6sxsQNZ12XvhuTHC2dA==
------END CERTIFICATE-----
diff --git a/test/fixtures/0-dns/0-dns-key.pem b/test/fixtures/0-dns/0-dns-key.pem
deleted file mode 100644
index 4e2fdb5fc61e0e1b6cfd87ddc98ce0811d9f5bf4..0000000000000000000000000000000000000000
--- a/test/fixtures/0-dns/0-dns-key.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAxciU9JL9j/S+ojWOky+yGaJwEfEfXr+4g9bUecnDBKTP8ulk
-3nyHKHIrzHARlWVrQoJKHjx4r3h/VCHqexxRgeIMQmA2RWAeOshktGB9nweRll0y
-2Dm2Gs8bhIYBURtAyyMDQ0S1tPtBRt3YrKe2HURwbXWy+fBf6jTkajxIyKaEMTiX
-NlKl9v4H6JiUXRVvz0oDe7h9kMDM0UESKypsgBc3rhFlT/lAFePOd2IOuj5mKQAE
-srdOvbBPEDUzRO+Sq3qzJmMx+wJkxBr2PG7pKw7lUGXHtv5XCtqwBPhumrdngTTG
-Sjp80cvZFiIid60e/liueRCnpS89HaGRSrXrtQIDAQABAoIBABcGA3j5B3VTi0F8
-tI0jtzrOsvcTt5AjB0qpnnBS8VXADcj8LFbN7jniGIEi5pkahkLmwdQFPBNJFqFn
-lVEheceB1eWAJ7EpwDsdisOIm/cAPY1gagPLrAww4cYqh0q2vnMnL0EMZY6c1Pt3
-5borh8KebewAEIaR2ch8wb4wKFTbAM0DftYBFzHAF88OeCuIpdsk2Tz0sVQbA3/1
-XNLOVcJvDOVIRPEpo2l7RIN33KvDhzpMoV3qVzWxqdccPRZZFU5KmJ6DtouIPT3S
-3WauIL5oVpAyYNJETTyxjBQE4DgFeNX1Wyycgk27EoLcn6Trcs0kNVrmXXblNAtJ
-Nko6g10CgYEA+TjzNjyAXPrOpY88uiPVMAgepEQOnDYtMwasdDVaW3xK9KH1rrhU
-dx1IDTMmOUfyU2qsj5txmJtReQz//1bpd7e73VO8mHQDUubhs2TivgGs+fqzAdmT
-vJsjerfNsxf+4JENzzWmqT/Ybc976Tu55VH5mcRG9Q66fTxdAJ51+8MCgYEAyymF
-gntRMBd9e/KIiqlvcxelo0ahyKEzaJC7/FkZotuSB+kAwpdJ5Unb0FeVQZxNhDPg
-xgsrGOOOvHvfhv7DPU0TQ/vp6VDPdg+N6m/Ow2vr79A2v6s+7gZj3MLiLRFyEF6l
-bxQNGe3qavnm3owUQQCY2RLBKYCFfv/cykYlGycCgYB6etKMRQ+QonIMS2i80f9j
-q5njgM7tVnLAMPdv5QiTDXKI50+mnlBkea9/TTPr0r/03ugPa4VYSnyv0QO+qSfz
-/ggFrbFx+xHnHDCvyVTlrE0mTV7L+fHxLw0wskQVUCWil6cBvow5gXcMAHwVE5U4
-biEMwLlele5wvcm3FClHoQKBgACV/RGUQ3atCqqZ13T26iBd2Bdxc7P9awWJLVGb
-/CvxECm/rUXiY88qeFzQc9i9l6ei8qn/jD9FILtAbDOadnutxjly94i5t+9yOgmM
-Cv+bRxHo+s9wsfzDvfP8B+TzYO3VKAr69tK1UfC/CcBojQJm+wndOPtiqH/mQv++
-VgsPAoGBAJ0aNJe3zb+blvAQ3W4iPSjhyxdMC00x46pr6ds+Y8WygbN6lzCvNDw6
-FFTINBckOs5Z/UWUNbExWYjBHZhLlhhxTezCzvIrwNvgUB8Y4sPk3S4KDsnkyy6f
-/qMmEHlVyKjh2BCNs7PVnWDlfl3vECE7n8dBizFHgja76l1ia+0z
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/0-dns/0-dns-rsapub.der b/test/fixtures/0-dns/0-dns-rsapub.der
deleted file mode 100644
index 263a4b8293dd0ef752e74ae4b459bed5b0a88fca..0000000000000000000000000000000000000000
Binary files a/test/fixtures/0-dns/0-dns-rsapub.der and /dev/null differ
diff --git a/test/fixtures/child-process-stay-alive-forever.js b/test/fixtures/child-process-stay-alive-forever.js
new file mode 100644
index 0000000000000000000000000000000000000000..fda313eba074c1ee2fa9572742e54e390acd48a5
--- /dev/null
+++ b/test/fixtures/child-process-stay-alive-forever.js
@@ -0,0 +1,3 @@
+setInterval(() => {
+    // Starting an interval to stay alive.
+}, 1000);
diff --git a/test/fixtures/cycles/warning-a.js b/test/fixtures/cycles/warning-a.js
new file mode 100644
index 0000000000000000000000000000000000000000..dea4c53a267af6442dadccab11b2517165a3d31d
--- /dev/null
+++ b/test/fixtures/cycles/warning-a.js
@@ -0,0 +1 @@
+require('./warning-b.js');
diff --git a/test/fixtures/cycles/warning-b.js b/test/fixtures/cycles/warning-b.js
new file mode 100644
index 0000000000000000000000000000000000000000..3be73bfd0af264627e781bcb0a184cb291573476
--- /dev/null
+++ b/test/fixtures/cycles/warning-b.js
@@ -0,0 +1,3 @@
+const a = require('./warning-a.js');
+a.missingPropB;
+a[Symbol('someSymbol')];
diff --git a/test/fixtures/cycles/warning-esm-half-transpiled-a.js b/test/fixtures/cycles/warning-esm-half-transpiled-a.js
new file mode 100644
index 0000000000000000000000000000000000000000..f4c17f9e4adaaf9c2d5af899ba2ac1c77a03a587
--- /dev/null
+++ b/test/fixtures/cycles/warning-esm-half-transpiled-a.js
@@ -0,0 +1 @@
+require('./warning-esm-half-transpiled-b.js');
diff --git a/test/fixtures/cycles/warning-esm-half-transpiled-b.js b/test/fixtures/cycles/warning-esm-half-transpiled-b.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab31fdbffc1a07076e890608657eaabf1e8262f3
--- /dev/null
+++ b/test/fixtures/cycles/warning-esm-half-transpiled-b.js
@@ -0,0 +1,2 @@
+const a = require('./warning-esm-half-transpiled-a.js');
+a.__esModule;
diff --git a/test/fixtures/cycles/warning-esm-transpiled-a.js b/test/fixtures/cycles/warning-esm-transpiled-a.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe70e745d38e08847afdf92da3e6905163ae57e0
--- /dev/null
+++ b/test/fixtures/cycles/warning-esm-transpiled-a.js
@@ -0,0 +1,2 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+require('./warning-esm-transpiled-b.js');
diff --git a/test/fixtures/cycles/warning-esm-transpiled-b.js b/test/fixtures/cycles/warning-esm-transpiled-b.js
new file mode 100644
index 0000000000000000000000000000000000000000..a44a63ce2c95b32c4488a6a3db07021c4f3a9c42
--- /dev/null
+++ b/test/fixtures/cycles/warning-esm-transpiled-b.js
@@ -0,0 +1 @@
+require('./warning-esm-transpiled-a.js').missingPropESM;
diff --git a/test/fixtures/cycles/warning-moduleexports-a.js b/test/fixtures/cycles/warning-moduleexports-a.js
new file mode 100644
index 0000000000000000000000000000000000000000..b37504b1b8ad519a60b718f61dacd70a2712d212
--- /dev/null
+++ b/test/fixtures/cycles/warning-moduleexports-a.js
@@ -0,0 +1,2 @@
+module.exports = {};
+require('./warning-moduleexports-b.js');
diff --git a/test/fixtures/cycles/warning-moduleexports-b.js b/test/fixtures/cycles/warning-moduleexports-b.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d2292934d2d64c482541587dd0e5f7fde6f2da9
--- /dev/null
+++ b/test/fixtures/cycles/warning-moduleexports-b.js
@@ -0,0 +1 @@
+require('./warning-moduleexports-b.js').missingPropModuleExportsB;
diff --git a/test/fixtures/cycles/warning-moduleexports-class-a.js b/test/fixtures/cycles/warning-moduleexports-class-a.js
new file mode 100644
index 0000000000000000000000000000000000000000..e23654d7f36c649dec7aa9587192acb463497f1b
--- /dev/null
+++ b/test/fixtures/cycles/warning-moduleexports-class-a.js
@@ -0,0 +1,11 @@
+const assert = require('assert');
+
+class Parent {}
+class A extends Parent {}
+
+module.exports = A;
+require('./warning-moduleexports-class-b.js');
+process.nextTick(() => {
+  assert.strictEqual(module.exports, A);
+  assert.strictEqual(Object.getPrototypeOf(module.exports), Parent);
+});
diff --git a/test/fixtures/cycles/warning-moduleexports-class-b.js b/test/fixtures/cycles/warning-moduleexports-class-b.js
new file mode 100644
index 0000000000000000000000000000000000000000..3fe1763eb7256fc98fc0c57555d73c4e78df20fb
--- /dev/null
+++ b/test/fixtures/cycles/warning-moduleexports-class-b.js
@@ -0,0 +1 @@
+require('./warning-moduleexports-class-a.js').missingPropModuleExportsClassB;
diff --git a/test/fixtures/cycles/warning-skip-proxy-traps-a.js b/test/fixtures/cycles/warning-skip-proxy-traps-a.js
new file mode 100644
index 0000000000000000000000000000000000000000..b64f8e633ebfff5305e8b46f1dfdd9ebd5d90420
--- /dev/null
+++ b/test/fixtures/cycles/warning-skip-proxy-traps-a.js
@@ -0,0 +1,17 @@
+module.exports = new Proxy({}, {
+  get(_target, prop) { throw new Error(`get: ${String(prop)}`); },
+  getPrototypeOf() { throw new Error('getPrototypeOf'); },
+  setPrototypeOf() { throw new Error('setPrototypeOf'); },
+  isExtensible() { throw new Error('isExtensible'); },
+  preventExtensions() { throw new Error('preventExtensions'); },
+  getOwnPropertyDescriptor() { throw new Error('getOwnPropertyDescriptor'); },
+  defineProperty() { throw new Error('defineProperty'); },
+  has() { throw new Error('has'); },
+  set() { throw new Error('set'); },
+  deleteProperty() { throw new Error('deleteProperty'); },
+  ownKeys() { throw new Error('ownKeys'); },
+  apply() { throw new Error('apply'); },
+  construct() { throw new Error('construct'); }
+});
+
+require('./warning-skip-proxy-traps-b.js');
diff --git a/test/fixtures/cycles/warning-skip-proxy-traps-b.js b/test/fixtures/cycles/warning-skip-proxy-traps-b.js
new file mode 100644
index 0000000000000000000000000000000000000000..e686bd719c136f8042ecb91b3cd87b6f5394a6b0
--- /dev/null
+++ b/test/fixtures/cycles/warning-skip-proxy-traps-b.js
@@ -0,0 +1,10 @@
+const assert = require('assert');
+
+const object = require('./warning-skip-proxy-traps-a.js');
+
+assert.throws(() => {
+  object.missingPropProxyTrap;
+}, {
+  message: 'get: missingPropProxyTrap',
+  name: 'Error',
+});
diff --git a/deps/node-inspect/examples/alive.js b/test/fixtures/debugger/alive.js
similarity index 100%
rename from deps/node-inspect/examples/alive.js
rename to test/fixtures/debugger/alive.js
diff --git a/deps/node-inspect/examples/backtrace.js b/test/fixtures/debugger/backtrace.js
similarity index 100%
rename from deps/node-inspect/examples/backtrace.js
rename to test/fixtures/debugger/backtrace.js
diff --git a/deps/node-inspect/examples/break.js b/test/fixtures/debugger/break.js
similarity index 100%
rename from deps/node-inspect/examples/break.js
rename to test/fixtures/debugger/break.js
diff --git a/deps/node-inspect/examples/cjs/index.js b/test/fixtures/debugger/cjs/index.js
similarity index 55%
rename from deps/node-inspect/examples/cjs/index.js
rename to test/fixtures/debugger/cjs/index.js
index 0ace6d9b78591ca13532e347560606fce1264617..c9bf53d1b4e61b4d68b5d34c2a5f31bcd4644de4 100644
--- a/deps/node-inspect/examples/cjs/index.js
+++ b/test/fixtures/debugger/cjs/index.js
@@ -1,5 +1,5 @@
-const fourty = 40;
+const forty = 40;
 const { add } = require('./other');
 
-const sum = add(fourty, 2);
+const sum = add(forty, 2);
 module.exports = sum;
diff --git a/deps/node-inspect/examples/cjs/other.js b/test/fixtures/debugger/cjs/other.js
similarity index 100%
rename from deps/node-inspect/examples/cjs/other.js
rename to test/fixtures/debugger/cjs/other.js
diff --git a/deps/node-inspect/examples/empty.js b/test/fixtures/debugger/empty.js
similarity index 100%
rename from deps/node-inspect/examples/empty.js
rename to test/fixtures/debugger/empty.js
diff --git a/deps/node-inspect/examples/exceptions.js b/test/fixtures/debugger/exceptions.js
similarity index 100%
rename from deps/node-inspect/examples/exceptions.js
rename to test/fixtures/debugger/exceptions.js
diff --git a/deps/node-inspect/examples/three-lines.js b/test/fixtures/debugger/three-lines.js
similarity index 100%
rename from deps/node-inspect/examples/three-lines.js
rename to test/fixtures/debugger/three-lines.js
diff --git a/deps/node-inspect/examples/use-strict.js b/test/fixtures/debugger/use-strict.js
similarity index 100%
rename from deps/node-inspect/examples/use-strict.js
rename to test/fixtures/debugger/use-strict.js
diff --git a/test/fixtures/document_with_cjs_and_esm_code_snippet.md b/test/fixtures/document_with_cjs_and_esm_code_snippet.md
new file mode 100644
index 0000000000000000000000000000000000000000..aae5ea28353a7d333ce31955519e3650b5a2c293
--- /dev/null
+++ b/test/fixtures/document_with_cjs_and_esm_code_snippet.md
@@ -0,0 +1,11 @@
+# Usage and Example
+
+CJS snippet is first, it should be the one displayed by default.
+
+```cjs
+require('path');
+```
+
+```mjs
+import 'node:url';
+```
\ No newline at end of file
diff --git a/test/fixtures/document_with_esm_and_cjs_code_snippet.md b/test/fixtures/document_with_esm_and_cjs_code_snippet.md
new file mode 100644
index 0000000000000000000000000000000000000000..a7e1438376297999e3cadc8ece3c081884481fb5
--- /dev/null
+++ b/test/fixtures/document_with_esm_and_cjs_code_snippet.md
@@ -0,0 +1,11 @@
+# Usage and Example
+
+ESM snippet is first, it should be the one displayed by default.
+
+```mjs
+import 'node:url';
+```
+
+```cjs
+require('path');
+```
\ No newline at end of file
diff --git a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
index 9f1bc24560b87a05d5d1bf7f2a8e230c5eb2878d..f06e9e90ff97c310f962e27eb0c66b165d33c924 100644
--- a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
+++ b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
@@ -1,23 +1,62 @@
 import module from 'module';
 
-export function getFormat(url, context, defaultGetFormat) {
-  if (module.builtinModules.includes(url)) {
+const GET_BUILTIN = `$__get_builtin_hole_${Date.now()}`;
+
+export function getGlobalPreloadCode() {
+  return `Object.defineProperty(globalThis, ${JSON.stringify(GET_BUILTIN)}, {
+  value: (builtinName) => {
+    return getBuiltin(builtinName);
+  },
+  enumerable: false,
+  configurable: false,
+});
+`;
+}
+
+export function resolve(specifier, context, defaultResolve) {
+  const def = defaultResolve(specifier, context);
+  if (def.url.startsWith('node:')) {
+    return {
+      url: `custom-${def.url}`,
+    };
+  }
+  return def;
+}
+
+export function getSource(url, context, defaultGetSource) {
+  if (url.startsWith('custom-node:')) {
+    const urlObj = new URL(url);
     return {
-      format: 'dynamic'
+      source: generateBuiltinModule(urlObj.pathname),
+      format: 'module',
     };
   }
+  return defaultGetSource(url, context);
+}
+
+export function getFormat(url, context, defaultGetFormat) {
+  if (url.startsWith('custom-node:')) {
+    return { format: 'module' };
+  }
   return defaultGetFormat(url, context, defaultGetFormat);
 }
 
-export function dynamicInstantiate(url) {
-  const builtinInstance = module._load(url);
-  const builtinExports = ['default', ...Object.keys(builtinInstance)];
-  return {
-    exports: builtinExports,
-    execute: exports => {
-      for (let name of builtinExports)
-        exports[name].set(builtinInstance[name]);
-      exports.default.set(builtinInstance);
-    }
-  };
+function generateBuiltinModule(builtinName) {
+  const builtinInstance = module._load(builtinName);
+  const builtinExports = [
+    ...Object.keys(builtinInstance),
+  ];
+  return `\
+const $builtinInstance = ${GET_BUILTIN}(${JSON.stringify(builtinName)});
+
+export const __fromLoader = true;
+
+export default $builtinInstance;
+
+${
+  builtinExports
+    .map(name => `export const ${name} = $builtinInstance.${name};`)
+    .join('\n')
+}
+`;
 }
diff --git a/test/fixtures/es-modules/es-note-error-1.cjs b/test/fixtures/es-modules/es-note-error-1.cjs
new file mode 100644
index 0000000000000000000000000000000000000000..3db3728b2079d9f60e819857fbeec7dd4d7c1d46
--- /dev/null
+++ b/test/fixtures/es-modules/es-note-error-1.cjs
@@ -0,0 +1 @@
+throw new Error('some error');
diff --git a/test/fixtures/es-modules/es-note-error-1.mjs b/test/fixtures/es-modules/es-note-error-1.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..8968fa5f5732471451b954a56b73bfca0bd1dbfa
--- /dev/null
+++ b/test/fixtures/es-modules/es-note-error-1.mjs
@@ -0,0 +1 @@
+import './es-note-error-1.cjs';
diff --git a/test/fixtures/es-modules/es-note-error-2.cjs b/test/fixtures/es-modules/es-note-error-2.cjs
new file mode 100644
index 0000000000000000000000000000000000000000..fdd2e30969a85e53c911393f9e386ae28a494797
--- /dev/null
+++ b/test/fixtures/es-modules/es-note-error-2.cjs
@@ -0,0 +1 @@
+throw 'string';
diff --git a/test/fixtures/es-modules/es-note-error-2.mjs b/test/fixtures/es-modules/es-note-error-2.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..0a04bf0fb1bf775ecf1a7469fe329def31fa3529
--- /dev/null
+++ b/test/fixtures/es-modules/es-note-error-2.mjs
@@ -0,0 +1 @@
+import './es-note-error-2.cjs';
diff --git a/test/fixtures/es-modules/es-note-error-3.cjs b/test/fixtures/es-modules/es-note-error-3.cjs
new file mode 100644
index 0000000000000000000000000000000000000000..37d3d14b8bfe1b6058ec708550f4560544d76ca3
--- /dev/null
+++ b/test/fixtures/es-modules/es-note-error-3.cjs
@@ -0,0 +1 @@
+throw null;
diff --git a/test/fixtures/es-modules/es-note-error-3.mjs b/test/fixtures/es-modules/es-note-error-3.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..88840bb9d4d1a17f52b2972f71c5860c31635688
--- /dev/null
+++ b/test/fixtures/es-modules/es-note-error-3.mjs
@@ -0,0 +1 @@
+import './es-note-error-3.cjs';
diff --git a/test/fixtures/es-modules/es-note-error-4.cjs b/test/fixtures/es-modules/es-note-error-4.cjs
new file mode 100644
index 0000000000000000000000000000000000000000..38ecbdff9801f6fd77f2e8c26c6966eacc544cd0
--- /dev/null
+++ b/test/fixtures/es-modules/es-note-error-4.cjs
@@ -0,0 +1 @@
+throw undefined;
diff --git a/test/fixtures/es-modules/es-note-error-4.mjs b/test/fixtures/es-modules/es-note-error-4.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..a94e1b10ed12f6ea175ed35d8016ae1f7872f388
--- /dev/null
+++ b/test/fixtures/es-modules/es-note-error-4.mjs
@@ -0,0 +1 @@
+import './es-note-error-4.cjs';
diff --git a/test/fixtures/es-modules/pkgimports/package.json b/test/fixtures/es-modules/pkgimports/package.json
index a2224b39ddd2ac27c28a700c0fb86fb7451a6727..ca2c6c65e00a8f786f61ff89ce01737341a25b1d 100644
--- a/test/fixtures/es-modules/pkgimports/package.json
+++ b/test/fixtures/es-modules/pkgimports/package.json
@@ -25,6 +25,7 @@
     "#": "./test.js",
     "#/initialslash": "./test.js",
     "#notfound": "./notfound.js",
-    "#percent": "./..%2F/x.js"
+    "#encodedslash": "./..%2F/x.js",
+    "#encodedbackslash": "./..%5C/x.js"
   }
 }
diff --git a/test/fixtures/es-modules/simple.wasm b/test/fixtures/es-modules/simple.wasm
deleted file mode 100644
index 9e035904b2e4d0a30ce5a63bcf05cc3a2c8449db..0000000000000000000000000000000000000000
Binary files a/test/fixtures/es-modules/simple.wasm and /dev/null differ
diff --git a/test/fixtures/es-modules/test-esm-comma,.mjs b/test/fixtures/es-modules/test-esm-comma,.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..0a5f91dc35ef5cf56f3eceba6d1511b6f891a825
--- /dev/null
+++ b/test/fixtures/es-modules/test-esm-comma,.mjs
@@ -0,0 +1 @@
+export default ',';
diff --git a/test/fixtures/es-modules/tla/a.mjs b/test/fixtures/es-modules/tla/a.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..c899a1c658c38553f5e0793b0711c378e276dde1
--- /dev/null
+++ b/test/fixtures/es-modules/tla/a.mjs
@@ -0,0 +1,7 @@
+import order from './order.mjs';
+
+await new Promise((resolve) => {
+  setTimeout(resolve, 200);
+});
+
+order.push('a');
diff --git a/test/fixtures/es-modules/tla/b.mjs b/test/fixtures/es-modules/tla/b.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..5149f5fda9361ee3674e3c94550133f0e7ff3ce5
--- /dev/null
+++ b/test/fixtures/es-modules/tla/b.mjs
@@ -0,0 +1,3 @@
+import order from './order.mjs';
+
+order.push('b');
diff --git a/test/fixtures/es-modules/tla/c.mjs b/test/fixtures/es-modules/tla/c.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..ab0479f12b8eacf3654fa70b4d8812505015610b
--- /dev/null
+++ b/test/fixtures/es-modules/tla/c.mjs
@@ -0,0 +1,3 @@
+import order from './order.mjs';
+
+order.push('c');
diff --git a/test/fixtures/es-modules/tla/d.mjs b/test/fixtures/es-modules/tla/d.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..4d6e7d496fc88af9ee9d7562187dd9506defb0fe
--- /dev/null
+++ b/test/fixtures/es-modules/tla/d.mjs
@@ -0,0 +1,6 @@
+import order from './order.mjs';
+
+const end = Date.now() + 500;
+while (end < Date.now()) {}
+
+order.push('d');
diff --git a/test/fixtures/es-modules/tla/order.mjs b/test/fixtures/es-modules/tla/order.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..3258bf986eae36733c393f25e226fa614348f890
--- /dev/null
+++ b/test/fixtures/es-modules/tla/order.mjs
@@ -0,0 +1 @@
+export default ['order'];
diff --git a/test/fixtures/es-modules/tla/parent.mjs b/test/fixtures/es-modules/tla/parent.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..ed17e1022676966d3ba0640bb12f8f2752d6b83a
--- /dev/null
+++ b/test/fixtures/es-modules/tla/parent.mjs
@@ -0,0 +1,9 @@
+import order from './order.mjs';
+import './a.mjs';
+import './b.mjs';
+import './c.mjs';
+import './d.mjs';
+
+order.push('parent');
+
+export default order;
diff --git a/test/fixtures/es-modules/tla/rejected-withexitcode.mjs b/test/fixtures/es-modules/tla/rejected-withexitcode.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..34e98e0147f134f7d98be0efc285d892ba54b368
--- /dev/null
+++ b/test/fixtures/es-modules/tla/rejected-withexitcode.mjs
@@ -0,0 +1,2 @@
+process.exitCode = 42;
+await Promise.reject(new Error('Xyz'));
diff --git a/test/fixtures/es-modules/tla/rejected.mjs b/test/fixtures/es-modules/tla/rejected.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..752a3b91ff65340b3fd82d20ef0ee3e1d9c8d355
--- /dev/null
+++ b/test/fixtures/es-modules/tla/rejected.mjs
@@ -0,0 +1 @@
+await Promise.reject(new Error('Xyz'));
diff --git a/test/fixtures/es-modules/tla/unresolved-withexitcode.mjs b/test/fixtures/es-modules/tla/unresolved-withexitcode.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..1cb982311080b8f11ac1aaecdd60239d417fbc15
--- /dev/null
+++ b/test/fixtures/es-modules/tla/unresolved-withexitcode.mjs
@@ -0,0 +1,2 @@
+process.exitCode = 42;
+await new Promise(() => {});
diff --git a/test/fixtures/es-modules/tla/unresolved.mjs b/test/fixtures/es-modules/tla/unresolved.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..231a8cd634825c1ec7bdb6ead8833fe07b51d079
--- /dev/null
+++ b/test/fixtures/es-modules/tla/unresolved.mjs
@@ -0,0 +1 @@
+await new Promise(() => {});
diff --git a/test/fixtures/google_ssl_hello.bin b/test/fixtures/google_ssl_hello.bin
deleted file mode 100644
index 739be3580fc80f5c892f5798c811403b467fd840..0000000000000000000000000000000000000000
--- a/test/fixtures/google_ssl_hello.bin
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2cfff297965b5e823df7a49c5ff5fd3c62f336d00ee120c6c3025a7a7e0e0fe9
-size 517
diff --git a/test/fixtures/icu-punycode-toascii.json b/test/fixtures/icu-punycode-toascii.json
new file mode 100644
index 0000000000000000000000000000000000000000..814f06e794866d4d2a817418ad368bf4f5ff446a
--- /dev/null
+++ b/test/fixtures/icu-punycode-toascii.json
@@ -0,0 +1,149 @@
+[
+  "This resource is focused on highlighting issues with UTS #46 ToASCII",
+  {
+    "comment": "Label with hyphens in 3rd and 4th position",
+    "input": "aa--",
+    "output": "aa--"
+  },
+  {
+    "input": "a†--",
+    "output": "xn--a---kp0a"
+  },
+  {
+    "input": "ab--c",
+    "output": "ab--c"
+  },
+  {
+    "comment": "Label with leading hyphen",
+    "input": "-x",
+    "output": "-x"
+  },
+  {
+    "input": "-†",
+    "output": "xn----xhn"
+  },
+  {
+    "input": "-x.xn--nxa",
+    "output": "-x.xn--nxa"
+  },
+  {
+    "input": "-x.β",
+    "output": "-x.xn--nxa"
+  },
+  {
+    "comment": "Label with trailing hyphen",
+    "input": "x-.xn--nxa",
+    "output": "x-.xn--nxa"
+  },
+  {
+    "input": "x-.β",
+    "output": "x-.xn--nxa"
+  },
+  {
+    "comment": "Empty labels",
+    "input": "x..xn--nxa",
+    "output": "x..xn--nxa"
+  },
+  {
+    "input": "x..β",
+    "output": "x..xn--nxa"
+  },
+  {
+    "comment": "Invalid Punycode",
+    "input": "xn--a",
+    "output": null
+  },
+  {
+    "input": "xn--a.xn--nxa",
+    "output": null
+  },
+  {
+    "input": "xn--a.β",
+    "output": null
+  },
+  {
+    "comment": "Valid Punycode",
+    "input": "xn--nxa.xn--nxa",
+    "output": "xn--nxa.xn--nxa"
+  },
+  {
+    "comment": "Mixed",
+    "input": "xn--nxa.β",
+    "output": "xn--nxa.xn--nxa"
+  },
+  {
+    "input": "ab--c.xn--nxa",
+    "output": "ab--c.xn--nxa"
+  },
+  {
+    "input": "ab--c.β",
+    "output": "ab--c.xn--nxa"
+  },
+  {
+    "comment": "CheckJoiners is true",
+    "input": "\u200D.example",
+    "output": null
+  },
+  {
+    "input": "xn--1ug.example",
+    "output": null
+  },
+  {
+    "comment": "CheckBidi is true",
+    "input": "يa",
+    "output": null
+  },
+  {
+    "input": "xn--a-yoc",
+    "output": null
+  },
+  {
+    "comment": "processing_option is Nontransitional_Processing",
+    "input": "ශ්‍රී",
+    "output": "xn--10cl1a0b660p"
+  },
+  {
+    "input": "نامه‌ای",
+    "output": "xn--mgba3gch31f060k"
+  },
+  {
+    "comment": "U+FFFD",
+    "input": "\uFFFD.com",
+    "output": null
+  },
+  {
+    "comment": "U+FFFD character encoded in Punycode",
+    "input": "xn--zn7c.com",
+    "output": null
+  },
+  {
+    "comment": "Label longer than 63 code points",
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901†",
+    "output": "xn--x01234567890123456789012345678901234567890123456789012345678901-6963b"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x.β",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa"
+  },
+  {
+    "comment": "Domain excluding TLD longer than 253 code points",
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x"
+  },
+  {
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa"
+  },
+  {
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.β",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa"
+  }
+]
diff --git a/test/fixtures/ispreloading.js b/test/fixtures/ispreloading.js
new file mode 100644
index 0000000000000000000000000000000000000000..a936bbb6761cc54b8eb08a514975b0d20644cc93
--- /dev/null
+++ b/test/fixtures/ispreloading.js
@@ -0,0 +1,2 @@
+const assert = require('assert');
+assert(module.isPreloading);
diff --git a/test/fixtures/keys/I_AM_THE_WALRUS_sha256_signature_signedby_rsa_private_b.sha256 b/test/fixtures/keys/I_AM_THE_WALRUS_sha256_signature_signedby_rsa_private_b.sha256
deleted file mode 100644
index 59eb6c7c8831cc21f840333ef9b1fd375997969e..0000000000000000000000000000000000000000
Binary files a/test/fixtures/keys/I_AM_THE_WALRUS_sha256_signature_signedby_rsa_private_b.sha256 and /dev/null differ
diff --git a/test/fixtures/keys/Makefile b/test/fixtures/keys/Makefile
index 824704c7241b0ae58f5b4f2768b429f465aafb9b..95f4edbafffde16c78e3712e8cf6879f81527568 100644
--- a/test/fixtures/keys/Makefile
+++ b/test/fixtures/keys/Makefile
@@ -75,6 +75,10 @@ all: \
   ed448_public.pem \
   x448_private.pem \
   x448_public.pem \
+  incorrect_san_correct_subject-cert.pem \
+  incorrect_san_correct_subject-key.pem \
+  irrelevant_san_correct_subject-cert.pem \
+  irrelevant_san_correct_subject-key.pem \
 
 #
 # Create Certificate Authority: ca1
@@ -733,6 +737,30 @@ x448_private.pem:
 x448_public.pem: x448_private.pem
 	openssl pkey -in x448_private.pem -pubout -out x448_public.pem
 
+incorrect_san_correct_subject-cert.pem: incorrect_san_correct_subject-key.pem
+	openssl req -x509 \
+	            -key incorrect_san_correct_subject-key.pem \
+	            -out incorrect_san_correct_subject-cert.pem \
+	            -sha256 \
+	            -days 3650 \
+	            -subj "/CN=good.example.com" \
+	            -addext "subjectAltName = DNS:evil.example.com"
+
+incorrect_san_correct_subject-key.pem:
+	openssl ecparam -name prime256v1 -genkey -noout -out incorrect_san_correct_subject-key.pem
+
+irrelevant_san_correct_subject-cert.pem: irrelevant_san_correct_subject-key.pem
+	openssl req -x509 \
+	            -key irrelevant_san_correct_subject-key.pem \
+	            -out irrelevant_san_correct_subject-cert.pem \
+	            -sha256 \
+	            -days 3650 \
+	            -subj "/CN=good.example.com" \
+	            -addext "subjectAltName = IP:1.2.3.4"
+
+irrelevant_san_correct_subject-key.pem:
+	openssl ecparam -name prime256v1 -genkey -noout -out irrelevant_san_correct_subject-key.pem
+
 clean:
 	rm -f *.pfx *.pem *.srl ca2-database.txt ca2-serial fake-startcom-root-serial *.print *.old fake-startcom-root-issued-certs/*.pem
 	@> fake-startcom-root-database.txt
diff --git a/test/fixtures/keys/agent1-cert.pem b/test/fixtures/keys/agent1-cert.pem
deleted file mode 100644
index 664d00ca6d8f9c7396287c06d270ddf88734e89a..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent1-cert.pem
+++ /dev/null
@@ -1,18 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIC2DCCAkGgAwIBAgIJAOzJuFYnDamoMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2ExMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjFaGA8yMjkyMDgzMDE4
-NDIyMVowfTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEP
-MA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQ8wDQYDVQQDDAZhZ2Vu
-dDExIDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0GCSqGSIb3
-DQEBAQUAA4GNADCBiQKBgQDvVEBwFjfiirsDjlZB+CjYNMNCqdJe27hqK/b72AnL
-jgN6mLcXCOABJC5N61TGFkiF9Zndh6IyFXRZVb4gQX4zxNDRuAydo95BmiYHGV0v
-t1ZXsLv7XrfQu6USLRtpZMe1cNULjsAB7raN+1hEN1CPMSmSjWc7MKPgv09QYJ5j
-cQIDAQABo2EwXzBdBggrBgEFBQcBAQRRME8wIwYIKwYBBQUHMAGGF2h0dHA6Ly9v
-Y3NwLm5vZGVqcy5vcmcvMCgGCCsGAQUFBzAChhxodHRwOi8vY2Eubm9kZWpzLm9y
-Zy9jYS5jZXJ0MA0GCSqGSIb3DQEBCwUAA4GBAHrKvx2Z4fsF7b3VRgiIbdbFCfxY
-ICvoJ0+BObYPjqIZZm9+/5c36SpzKzGO9CN9qUEj3KxPmijnb+Zjsm1CSCrG1m04
-C73+AjAIPnQ+eWZnF1K4L2kuEDTpv8nQzYKYiGxsmW58PSMeAq1TmaFwtSW3TxHX
-7ROnqBX0uXQlOo1m
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent1-csr.pem b/test/fixtures/keys/agent1-csr.pem
deleted file mode 100644
index 6ed2fb3aff9ef7be0cd0f67e82fe5cab49311cd5..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent1-csr.pem
+++ /dev/null
@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB4jCCAUsCAQAwfTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjEPMA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQ8wDQYDVQQD
-DAZhZ2VudDExIDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0G
-CSqGSIb3DQEBAQUAA4GNADCBiQKBgQDvVEBwFjfiirsDjlZB+CjYNMNCqdJe27hq
-K/b72AnLjgN6mLcXCOABJC5N61TGFkiF9Zndh6IyFXRZVb4gQX4zxNDRuAydo95B
-miYHGV0vt1ZXsLv7XrfQu6USLRtpZMe1cNULjsAB7raN+1hEN1CPMSmSjWc7MKPg
-v09QYJ5jcQIDAQABoCUwIwYJKoZIhvcNAQkHMRYMFEEgY2hhbGxlbmdlIHBhc3N3
-b3JkMA0GCSqGSIb3DQEBCwUAA4GBAN3UIAdShj7eA91fH8m8UQBJndgigNwt88qk
-S2kS3XfZqkEawMu2HF/y5yWX7EyGs7OkRXZxJSR67GlgdrTi82qCBC3H2xF7fKXr
-s5b6ges5NZFjEA9JTvX5PFSAfo5APbXuuhRWBdxvagi00szTnYiaKgGU4C/dZWAz
-E0/tTFT4
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent1-key.pem b/test/fixtures/keys/agent1-key.pem
deleted file mode 100644
index fe750dee3f47f53f33ae8b492f42491108a87a13..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent1-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXQIBAAKBgQDvVEBwFjfiirsDjlZB+CjYNMNCqdJe27hqK/b72AnLjgN6mLcX
-COABJC5N61TGFkiF9Zndh6IyFXRZVb4gQX4zxNDRuAydo95BmiYHGV0vt1ZXsLv7
-XrfQu6USLRtpZMe1cNULjsAB7raN+1hEN1CPMSmSjWc7MKPgv09QYJ5jcQIDAQAB
-AoGAbqk3TlyHpKFfDarf6Yr0X9wtuQJK+n+ACt+fSR3AkbVtmF9KsUTyRrTTEEZT
-IXCmQgKpDYysi5nt/WyvB70gu6xGYbT6PzZaf1RmcpWd1pLcdyBOppY6y7nTMZA3
-BVFfmIPSmAvtCuzZwQFFnNoKH3d6cqna+ZQJ0zvCLCSLcw0CQQD6tswNlhCIfguh
-tvhw7hJB5vZPWWEzyTQl8nVdY6SbxAT8FTx0UjxsKgOiJFzAGAVoCi40oRKIHhrw
-pKwHsEqTAkEA9GABbi2xqAmhPn66e0AiU8t2uv69PISBSt2tXbUAburJFj+4rYZW
-71QIbSKEYceveb7wm0NP+adgZqJlxn7oawJBAOjfK4+fCIJPWWx+8Cqs5yZxae1w
-HrokNBzfJSZ2bCoGm36uFvYQgHETYUaUsdX3OeZWNm7KAdWO6QUGX4fQtqMCQGXv
-OgmEY+utAKZ55D2PFgKQB1me8r6wouHgr/U7kA+0Peba86TmOZMhIVaspD3JNqf4
-/pI1NMH1kF+fdAalXzsCQQCelwr9I3FWhx336CWrfAY20xbiMOWMyAhrjVrexgUD
-53Y6AhSaRC725pZTgO2PQ4AjkGLIP61sZKgTrXS85KmJ
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent1.pfx b/test/fixtures/keys/agent1.pfx
deleted file mode 100644
index f830eccead5284d4abe5be09830a64c4718287df..0000000000000000000000000000000000000000
Binary files a/test/fixtures/keys/agent1.pfx and /dev/null differ
diff --git a/test/fixtures/keys/agent10-cert.pem b/test/fixtures/keys/agent10-cert.pem
deleted file mode 100644
index 8aaabd3f938beaa8a1fbfacbe9c42e36feab2c25..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent10-cert.pem
+++ /dev/null
@@ -1,32 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICfzCCAeigAwIBAgIJAOyvM6GMZDW6MA0GCSqGSIb3DQEBCwUAMIGIMQswCQYD
-VQQGEwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMR8wHQYDVQQKDBZUaGUg
-Tm9kZS5qcyBGb3VuZGF0aW9uMRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANj
-YTQxHjAcBgkqhkiG9w0BCQEWD2NhNEBleGFtcGxlLm9yZzAgFw0xODExMTYxODQy
-MjFaGA8yMjkyMDgzMDE4NDIyMVoweDELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNB
-MQswCQYDVQQHDAJTRjEfMB0GA1UECgwWVGhlIE5vZGUuanMgRm91bmRhdGlvbjEQ
-MA4GA1UECwwHTm9kZS5qczEcMBoGA1UEAwwTYWdlbnQxMC5leGFtcGxlLmNvbTCB
-nzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEArV2diVumrKDS5k81MrcdECnYYVZ5
-feQ/FZDqwEHM/zlXvs6vphU3rGmZeASMQEdHg7vUjzzvE8PDqJuJXKrC5lEO1OUY
-eUDhaZ/QvYS9tDp7qTJzORxT9im65dQH0Xq5JQwTy30hidQHxOgAkILNive07/Jk
-N1vle6TnZX6K/dkCAwEAATANBgkqhkiG9w0BAQsFAAOBgQAAg+FpvhA6coalWxGR
-acWiUbc7CJ4RWjlSeA+fhd1G00x0Hl5hjt6IAqEHe4T9fV41U05X1eo5KaN3jXWU
-IS56SVX8BxOhU53lr0iID0MpxMqttA9LgjE3fc6uAjThnx1zX50VGR4P8LQqG+HL
-WJUW0+3oJrOgRbJ6wAEs0iCcTg==
------END CERTIFICATE-----
------BEGIN CERTIFICATE-----
-MIICkzCCAfygAwIBAgIJAJHwBmNgafKbMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2EyMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjFaGA8yMjkyMDgzMDE4
-NDIyMVowgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0Yx
-HzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAOBgNVBAsMB05vZGUu
-anMxDDAKBgNVBAMMA2NhNDEeMBwGCSqGSIb3DQEJARYPY2E0QGV4YW1wbGUub3Jn
-MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDC1M2aGVYsmrBiut1n0nfTU+9v
-TNVdAmKQBjnNsv3IIch/PPaEOIEm7dFhgdk86Z+wVCN3sAKu54Bz4JDKdPsFGvDy
-18JGuGH1vIVW5285IW7fMrzvAdZtETeBAiPM10Q69ddB4M6FbLiF273ZqCJ+vSsw
-kl5Dkas8YTZ0uwqKjQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEB
-CwUAA4GBAGDMGSbPg/B4OripSxT2scXFIwoej47PW1byJgWaGoMJ8zgKUoKE7Z7A
-aWQbD22In05F0kBllqpSJWEZpTuVFsyyLeb3R7cuGQWs/puaaPul7sx+PRGhwxYe
-nrNIGtsaBf8TO/kb5lMiXWbhM5gZbBtbMMv3xWA4FxqU0AgfO3jM
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent10-csr.pem b/test/fixtures/keys/agent10-csr.pem
deleted file mode 100644
index b96e682d5bd7da64484a08d4d1b42b45f0d3a894..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent10-csr.pem
+++ /dev/null
@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB3TCCAUYCAQAweDELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjEfMB0GA1UECgwWVGhlIE5vZGUuanMgRm91bmRhdGlvbjEQMA4GA1UECwwH
-Tm9kZS5qczEcMBoGA1UEAwwTYWdlbnQxMC5leGFtcGxlLmNvbTCBnzANBgkqhkiG
-9w0BAQEFAAOBjQAwgYkCgYEArV2diVumrKDS5k81MrcdECnYYVZ5feQ/FZDqwEHM
-/zlXvs6vphU3rGmZeASMQEdHg7vUjzzvE8PDqJuJXKrC5lEO1OUYeUDhaZ/QvYS9
-tDp7qTJzORxT9im65dQH0Xq5JQwTy30hidQHxOgAkILNive07/JkN1vle6TnZX6K
-/dkCAwEAAaAlMCMGCSqGSIb3DQEJBzEWDBRBIGNoYWxsZW5nZSBwYXNzd29yZDAN
-BgkqhkiG9w0BAQsFAAOBgQBeyxGhHnFF0ifHhWUbqqMM9zJ5OhLjGsQ0gvmK/LHL
-vmGJ43XgeYiN/U6xREQ7DZMss+C14mfQvp5oM0zQRWwQhLgV7YlIIIe09CYTKTfC
-xxc18OJewNQUje5cG5aSMZb2HfHmLDaavAJqK0Yaoj69e+iEnAkVFVZALqlhezS+
-xQ==
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent10-key.pem b/test/fixtures/keys/agent10-key.pem
deleted file mode 100644
index dd589cafdf6191a939e65c4db69285c4c3b51486..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent10-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQCtXZ2JW6asoNLmTzUytx0QKdhhVnl95D8VkOrAQcz/OVe+zq+m
-FTesaZl4BIxAR0eDu9SPPO8Tw8Oom4lcqsLmUQ7U5Rh5QOFpn9C9hL20OnupMnM5
-HFP2Kbrl1AfRerklDBPLfSGJ1AfE6ACQgs2K97Tv8mQ3W+V7pOdlfor92QIDAQAB
-AoGAIAjiaVVEMTXugpw0SlDH0ArLbwEZpgedGJEUr7348VhZPGrYzimxhexlbWX5
-vI7vSgpVNrqduts7tlY3RaZQKQzFkSqkUUb432bXkJLHNIspd0XHOO2Hy/ZbTg0n
-OIQes7C91Z/OLUi9esXoh4AMsAoxiHoVee0dkEJt8RoywNkCQQDk39QND1rQ2eJq
-Fcfj/v6fXgsHmQT16w2Ii9P5uPAeIGrGcrsCoVWrsh+wjSlYc7emGV8JINiltNhZ
-fSg6ux8/AkEAwemf5LryUDCoZ68MlAYMcH+G7gtm06d+FUFpBclT3hJeXnUAdlyU
-6kCvazcVTQQKDTWIS1oIBuleVmc/VWc05wJBAMVRZyq/QydtwTJ+hq+8pl5VIKMz
-PECbnjZLfrv7wh/nCMcAINRarVZyIbn/aVbVpM3xb6qaA82QxTkZmvZPXtcCQFqx
-pjMYrNSMrXcxDDT/Tzoeq0ES3BkKMZJHcZNfQnaPKMwM9RZm3s9hSapfrPrEdN8Q
-tppnlXGGHLVUvO54wukCQBKbjspQONRZFBh9Fdeyf/rX+inBLhuMSnsY3FeBp0c6
-TAPbyuiezn7axr9kILojdjZgXK1b+MTHSEjqCpHwIvg=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent10.pfx b/test/fixtures/keys/agent10.pfx
deleted file mode 100644
index c6a5dd0386e7cf68e2b9b2aa225b83b0aa6a8efb..0000000000000000000000000000000000000000
Binary files a/test/fixtures/keys/agent10.pfx and /dev/null differ
diff --git a/test/fixtures/keys/agent2-cert.pem b/test/fixtures/keys/agent2-cert.pem
deleted file mode 100644
index 12750543c327df604e1a6d6954af041cb965c22e..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent2-cert.pem
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICczCCAdwCCQCtrfdcbYDS0jANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJV
-UzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMQ8wDQYDVQQKDAZKb3llbnQxEDAO
-BgNVBAsMB05vZGUuanMxDzANBgNVBAMMBmFnZW50MjEgMB4GCSqGSIb3DQEJARYR
-cnlAdGlueWNsb3Vkcy5vcmcwIBcNMTgxMTE2MTg0MjIxWhgPMjI5MjA4MzAxODQy
-MjFaMH0xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzAN
-BgNVBAoMBkpveWVudDEQMA4GA1UECwwHTm9kZS5qczEPMA0GA1UEAwwGYWdlbnQy
-MSAwHgYJKoZIhvcNAQkBFhFyeUB0aW55Y2xvdWRzLm9yZzCBnzANBgkqhkiG9w0B
-AQEFAAOBjQAwgYkCgYEAq2BtovcwlIUNVAi3ukbyQveZNg3VkkxB6Ih+CL70VEX3
-0ji5EpQqGjwk5Ub6tRYfuGHwBWSO8+W2PwtdplDbuIOoK5MAp+wkDRCC8H1l4i8c
-dOA97Edw3nRU6MiPrUiirV1u2liHYp6YDLWix80UiNnH6EOLFd5Wy5s7CSt4rEkC
-AwEAATANBgkqhkiG9w0BAQsFAAOBgQCg75WmaDjpwBmMAl/+5oK8D7p2V98ChhyV
-bIwhpLPo9jf7iPW9VayxQKvV5HXuiT1vpIjuvhbRRH3wGj3by0TtI+sqECcPKu1v
-5bg2e+bX8s1OXFJh+x93KCnrcFNEwOVk9VjUX+ilJdTkdcGA75N4ZO7qEV5wKl9g
-658PRZl3KA==
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent2-csr.pem b/test/fixtures/keys/agent2-csr.pem
deleted file mode 100644
index 02217de52bd5e42e61aacd5bb5038bcf045c900a..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent2-csr.pem
+++ /dev/null
@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB4jCCAUsCAQAwfTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjEPMA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQ8wDQYDVQQD
-DAZhZ2VudDIxIDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0G
-CSqGSIb3DQEBAQUAA4GNADCBiQKBgQCrYG2i9zCUhQ1UCLe6RvJC95k2DdWSTEHo
-iH4IvvRURffSOLkSlCoaPCTlRvq1Fh+4YfAFZI7z5bY/C12mUNu4g6grkwCn7CQN
-EILwfWXiLxx04D3sR3DedFToyI+tSKKtXW7aWIdinpgMtaLHzRSI2cfoQ4sV3lbL
-mzsJK3isSQIDAQABoCUwIwYJKoZIhvcNAQkHMRYMFEEgY2hhbGxlbmdlIHBhc3N3
-b3JkMA0GCSqGSIb3DQEBCwUAA4GBAJqJXQdhuPxsJA6O/yWt9t9lQIgoYCQyCG2w
-Xl0n84f14WDi/N9rF0IfGMSVWoLDCc5gcoqKal0X/vQI4lpPiZ0hctU5cXru1Pvi
-yfDbIPB0td7POf3Q3Ge3a3RHf4I4cfRuzA6jfzMlorpgQmAKL+sstC94LZZnDiNp
-ihciaeK7
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent2-key.pem b/test/fixtures/keys/agent2-key.pem
deleted file mode 100644
index 6aca2ed78be7c3f449f7d20364ea6e96839d8353..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent2-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQCrYG2i9zCUhQ1UCLe6RvJC95k2DdWSTEHoiH4IvvRURffSOLkS
-lCoaPCTlRvq1Fh+4YfAFZI7z5bY/C12mUNu4g6grkwCn7CQNEILwfWXiLxx04D3s
-R3DedFToyI+tSKKtXW7aWIdinpgMtaLHzRSI2cfoQ4sV3lbLmzsJK3isSQIDAQAB
-AoGAbaqNPiXUjpX+C3Jwr+FKkhQDlRWRP8dQvc7qaApaK7uCdKIbvInXz2YBbj7X
-nB4GOmVhxPGukODEmN9bFFzV3NbQVcAO8iPI6ldkYCmpmwfeEA1UJnBfBC2IYVFr
-0TSuq7OdniiO+FLhZvSAJXN+5yDv66nZEnojMuu1oqpG/gECQQDdxzSeNbOY2ak8
-Db2ZYKSBWjxVbW+UC8mYA7jHVpcUxlNnamcJrhg6hEfJqax6c/vAefECFsngG7yy
-XVTYX6rpAkEAxdI83zQz4NqYkZmFlCElNDRF7S1Sa2eX1HzzJYlOEMx3P1iE/z4U
-HOQh9py2jlY1th3GdbChF1VWMIOqGCtaYQJAJwxS/GQyKgBw5qz4rA+zBz9vDg+F
-rMhih0xodViOo07EEppOaArqIyt1RFGGl8ziD6Kox5hhlP7tO25paOt3OQJBALSL
-6y60EF06ZWENwxKtJa19wAx1/vEz/SjcWXZ62JsQYg2Yltn2KJktxam04hEKsb7j
-cgxcBsqrAh0JLicc+kECQDmH1wTvulw3E59jqOaKEbYNQFi18zzFkIIoNRVqMhtt
-zTJx8NYT9NUS3YE4OcUX0dQtVO3W+NIVrniaY8i29UM=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent3-cert.pem b/test/fixtures/keys/agent3-cert.pem
deleted file mode 100644
index 9460b44bb6abe106f2746b1535877641500c9e0e..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent3-cert.pem
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICcDCCAdkCCQCR8AZjYGnynDANBgkqhkiG9w0BAQsFADB6MQswCQYDVQQGEwJV
-UzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMQ8wDQYDVQQKDAZKb3llbnQxEDAO
-BgNVBAsMB05vZGUuanMxDDAKBgNVBAMMA2NhMjEgMB4GCSqGSIb3DQEJARYRcnlA
-dGlueWNsb3Vkcy5vcmcwIBcNMTgxMTE2MTg0MjIxWhgPMjI5MjA4MzAxODQyMjFa
-MH0xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNV
-BAoMBkpveWVudDEQMA4GA1UECwwHTm9kZS5qczEPMA0GA1UEAwwGYWdlbnQzMSAw
-HgYJKoZIhvcNAQkBFhFyeUB0aW55Y2xvdWRzLm9yZzCBnzANBgkqhkiG9w0BAQEF
-AAOBjQAwgYkCgYEAv+hwfSVuJfHDQOXmF2D/HsI2JZkspfrPQE/ZL1tII2cXRnus
-IqWZvLg9v7IVY0gSvx5gWMHxmqqaK75McVJvO1XEzLYpa9Ddnj06xqNWl6hwLHnP
-bclRi2n63Cs6zSM80r1iQ16ovZ0hyWPjXaBlWmb71QeeBp6ynxhB+yA0eZsCAwEA
-ATANBgkqhkiG9w0BAQsFAAOBgQA/C2xJIYA3Vo8pr1cfmzN+os9uvbMQEAegg6W+
-6/t82tLGnrCEglMTFHFp7MJCNiKCY16Ixi5WCZoUrGCfbh+Obtd4bP/wAlR8AS67
-lYZDvjADGU4e7Aqu0o0AHeb4MiRUQbkD0EUioyD8091Qhzlrx43UtdojPvakwAXM
-N/LFEw==
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent3-csr.pem b/test/fixtures/keys/agent3-csr.pem
deleted file mode 100644
index 21bb06e2ea72f5f918cb376ceb75dee216619c65..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent3-csr.pem
+++ /dev/null
@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB4jCCAUsCAQAwfTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjEPMA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQ8wDQYDVQQD
-DAZhZ2VudDMxIDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0G
-CSqGSIb3DQEBAQUAA4GNADCBiQKBgQC/6HB9JW4l8cNA5eYXYP8ewjYlmSyl+s9A
-T9kvW0gjZxdGe6wipZm8uD2/shVjSBK/HmBYwfGaqporvkxxUm87VcTMtilr0N2e
-PTrGo1aXqHAsec9tyVGLafrcKzrNIzzSvWJDXqi9nSHJY+NdoGVaZvvVB54GnrKf
-GEH7IDR5mwIDAQABoCUwIwYJKoZIhvcNAQkHMRYMFEEgY2hhbGxlbmdlIHBhc3N3
-b3JkMA0GCSqGSIb3DQEBCwUAA4GBAFHJUONDqOhZpGN8ZCFkWkGyD4iDPGdJyR1f
-lh1N2vSf9vx663ni6lG9XQrQZXyPH8n7vvyyX1bJE5X6dAKuiD4GYlcGUUCnsvcA
-r+JzSBrbtwD57bPnn21YSUl2QEoG2b+/6uPKWxKr8e1sreMxHOLwsPgSavnQ84Bc
-GvSLlIcR
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent3-key.pem b/test/fixtures/keys/agent3-key.pem
deleted file mode 100644
index 3470fdf4b7bab46a4226b236ca385221b8a4e51f..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent3-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQC/6HB9JW4l8cNA5eYXYP8ewjYlmSyl+s9AT9kvW0gjZxdGe6wi
-pZm8uD2/shVjSBK/HmBYwfGaqporvkxxUm87VcTMtilr0N2ePTrGo1aXqHAsec9t
-yVGLafrcKzrNIzzSvWJDXqi9nSHJY+NdoGVaZvvVB54GnrKfGEH7IDR5mwIDAQAB
-AoGAa94V5HH2kMNskXznsPpnS/2z+7w2OXFZrvdyx0iSqruWfJqlLbBRUp9orehG
-V1C6oMxNMXaJ+/qqv62uQAAq3oCPHRrN5a1fLzYKk/ixUbk0F7saNvOsmWqbSIzv
-OEtsHBt3zJxEkgLFzuaFnfoBoFL7lvJYol+4QPVvxYj2exkCQQDqVRGFbhRmKBZ+
-ienF9JpUOruKEsW4lmSKP2fUAL4rH40cJEFD0OI80/WdN/34USPOEqSsFTZITvFH
-+y+45PD/AkEA0acinvAAb0FLlMlhcG0LGzIwcYUWcEpPxwkioGgwGaEPLR276gHv
-NvgtL7xgLi4QMKB0n48zz4W4Usww6QmbZQJBAOGIZoipXfDEfIHlcp4XwcF3lbBa
-SPpTpQh55hBhdqZCg6mmKzp9/IDW7/oVPdaVIYTg5KTK9ae6cvb4hwHJNzkCQE3p
-YclVAaRWzKK/b/Ga5Gy36x7UybDzPNCHyZF5Bp8PppcqnKHrFB4GfqxlwgyHW8bm
-alC9pBBz7jr+3RJNWq0CQFHxhrjdhQFhYJoW8b+pqE1ryNSSSf/1yBEug6Xsqsjn
-MSuyCTLXRpoS/LAdL95ENCX3ULsu/5nlpKZmy99yY2M=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent4-cert.pem b/test/fixtures/keys/agent4-cert.pem
deleted file mode 100644
index d39e9d2630b1ca6ebbcf5be6826e24df5fafa9ac..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent4-cert.pem
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICjjCCAfegAwIBAgIJAJHwBmNgafKaMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2EyMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjBaGA8yMjkyMDgzMDE4
-NDIyMFowfTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEP
-MA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQ8wDQYDVQQDDAZhZ2Vu
-dDQxIDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0GCSqGSIb3
-DQEBAQUAA4GNADCBiQKBgQCvcVH69FzdPGCUXgwowuBz4lLAV+COzishbuyNGF5l
-J6mw6eY8gizLmpxh0r6d/REnlzKRy3Uy9FdZEQZKKfeK63MxLU6BYaHX0fnqz2y1
-oCaA2eW4yeGOLaSBcjEKHIs964Ik9VKEDnioYtoObbFihRbcS6QLNajQR9ij+7hl
-pQIDAQABoxcwFTATBgNVHSUEDDAKBggrBgEFBQcDAjANBgkqhkiG9w0BAQsFAAOB
-gQAykzKtLG++xAfLoq2AZ3OKlEYGC4RuOCy9J75RYWNRuy18UnYl0HGSepeqQ/4c
-0r+dy/SLUVKxC7e87hs7gP8UX+f9UaVM7dvqvZbZMVH+A6w2nIAcO3zwtSJlfQ8H
-NJAdQl1lZ6qc97APtBlfeTMTdi/hTghqZLah21/hIE5lFw==
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent4-csr.pem b/test/fixtures/keys/agent4-csr.pem
deleted file mode 100644
index 3e803a6a3c0d443908e46aed6ba91a2bff2a37ab..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent4-csr.pem
+++ /dev/null
@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB4jCCAUsCAQAwfTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjEPMA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQ8wDQYDVQQD
-DAZhZ2VudDQxIDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0G
-CSqGSIb3DQEBAQUAA4GNADCBiQKBgQCvcVH69FzdPGCUXgwowuBz4lLAV+COzish
-buyNGF5lJ6mw6eY8gizLmpxh0r6d/REnlzKRy3Uy9FdZEQZKKfeK63MxLU6BYaHX
-0fnqz2y1oCaA2eW4yeGOLaSBcjEKHIs964Ik9VKEDnioYtoObbFihRbcS6QLNajQ
-R9ij+7hlpQIDAQABoCUwIwYJKoZIhvcNAQkHMRYMFEEgY2hhbGxlbmdlIHBhc3N3
-b3JkMA0GCSqGSIb3DQEBCwUAA4GBAJ4tZ0hFXYqGQ0BDpcI6QIjufzoFHXMHBmE0
-wHU1f8jVM2v9Df5eInArMvAVya4gXtuZnMpRZKNrcbnwPUK9spwIzHxPyw7qjeCP
-SG+TusJoFFIGgpZBo6zVdtpRCRbTxNfKteK+y34g+sYZolt88AmlzY8H2QYeQabI
-1SBuLdBH
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent4-key.pem b/test/fixtures/keys/agent4-key.pem
deleted file mode 100644
index 1e9a8b8d2ed9114afb23238a4bbe90f7863c28fb..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent4-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXQIBAAKBgQCvcVH69FzdPGCUXgwowuBz4lLAV+COzishbuyNGF5lJ6mw6eY8
-gizLmpxh0r6d/REnlzKRy3Uy9FdZEQZKKfeK63MxLU6BYaHX0fnqz2y1oCaA2eW4
-yeGOLaSBcjEKHIs964Ik9VKEDnioYtoObbFihRbcS6QLNajQR9ij+7hlpQIDAQAB
-AoGASgLVIbf6gP4ahByUppFnXJuqayfnPHcu7MC9m9we3i94P4C8tuP3f8Dunbno
-3f9HQFthYu3guCkpvBIZhCnmGgrge/Rm5IYN9Jktc8gTSQ0NlJbr3hjgHEkJXhca
-6zE/sFEgZVWF/yCIunyU3umbWBJE9R+suk+mpe1wZ9T+AXUCQQDU208b7AvW9Yoo
-8SomHE5B1FJOwnyEWHBJ9W0myGXOrJbf6zNJ4eOLQsn1UWSsI9tzgeh49f6smc7B
-bhWhHqoLAkEA0wCs6zyKs0pbzGfGYQFafDbjSUBbT+nn4tXR+3O7Z8K6x3gt7DBx
-VtlbJtfBBWCCrIgYsrU3TUwtweDV6umtDwJBAJN7tU+SeQ2jKex+VQb8+9gu5iy+
-IwqMQJluHQgPOENAYHWcAPiDNGdMiqSYldmUKrzY2RvezmwHUjPCM+hkV8sCQQCF
-MQL2RrQi8sg5ojQmXa1ZhWg5gAdjzXnTxTcUa/ybRd+TNDiAxB93PCL+xOiR1VcH
-Q62beSqcf37OyHcgHztfAkAEHZwjVSRXFELBQDPzespHXVC3rwpQlbd1tqOybmPd
-tpqmlWjvFxdvEDQZnemPUCtXNhMOaXcSOeeSYcUkIVX6
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent5-cert.pem b/test/fixtures/keys/agent5-cert.pem
deleted file mode 100644
index 31e95265ff04704930ab2b5056fb6319a7568305..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent5-cert.pem
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIChTCCAe6gAwIBAgIJAJHwBmNgafKdMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2EyMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjFaGA8yMjkyMDgzMDE4
-NDIyMVowdDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MREwDwYDVQQK
-DAhUcmVzb3JpdDEWMBQGA1UEAwwNw4Fkw6FtIExpcHBhaTEnMCUGCSqGSIb3DQEJ
-ARYYYWRhbS5saXBwYWlAdHJlc29yaXQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GN
-ADCBiQKBgQCksphKSkbE4aCa68r2o7j2xWbxbWP+bjAGwWWYQwnacQ6p5tlhaN10
-ebDAmPVakLo8xxPEXMqWFxCU2AWg0Wtd6TgqIQtIMNXQz6cif5Ufxo3lhus+dLhs
-flz+yTpFD5vREvn0kQ9ce+jVjVzh8bK5qfpaNlaIqQc64WpJKQe+8QIDAQABoxcw
-FTATBgNVHSUEDDAKBggrBgEFBQcDAjANBgkqhkiG9w0BAQsFAAOBgQAYcJ8LyVUB
-5GNqnVdJW4dndeUvllYW3txxuUXhcxgvT7b0glDXSp/cRq0yxZb1jRCLqESsHer0
-o064S5GCWCktZWwbDo75YFE2Vo1R8TChhmD1txFcAi2J161yn9QVoHVbOhyyIHXz
-Yw9zhrnJURZA+1lUpIarcRmkUsbSR25gyg==
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent5-csr.pem b/test/fixtures/keys/agent5-csr.pem
deleted file mode 100644
index 6d670ffd8c73022079a0acfef7c7b49e721749c1..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent5-csr.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB2TCCAUICAQAwdDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MREw
-DwYDVQQKDAhUcmVzb3JpdDEWMBQGA1UEAwwNw4Fkw6FtIExpcHBhaTEnMCUGCSqG
-SIb3DQEJARYYYWRhbS5saXBwYWlAdHJlc29yaXQuY29tMIGfMA0GCSqGSIb3DQEB
-AQUAA4GNADCBiQKBgQCksphKSkbE4aCa68r2o7j2xWbxbWP+bjAGwWWYQwnacQ6p
-5tlhaN10ebDAmPVakLo8xxPEXMqWFxCU2AWg0Wtd6TgqIQtIMNXQz6cif5Ufxo3l
-hus+dLhsflz+yTpFD5vREvn0kQ9ce+jVjVzh8bK5qfpaNlaIqQc64WpJKQe+8QID
-AQABoCUwIwYJKoZIhvcNAQkHMRYMFEEgY2hhbGxlbmdlIHBhc3N3b3JkMA0GCSqG
-SIb3DQEBCwUAA4GBABmDywVdbouxznVhI5cnTB2cZTGKMDYCnYx+0pFOZw6ux1eR
-oUF59E/QCIfibOI6b1+Dd7O3hK81aCQxd6oBiWWg8gyCjFcoCVqOkR/Ug176asZv
-72+l6pBLYoZlmPrQXkxtfL+FtLM3/xLdt6hDSZEWyznWcraanDqKx9M4NEgG
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent5-key.pem b/test/fixtures/keys/agent5-key.pem
deleted file mode 100644
index 5de95c20b980207e553f7f5682a50737c79a472d..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent5-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQCksphKSkbE4aCa68r2o7j2xWbxbWP+bjAGwWWYQwnacQ6p5tlh
-aN10ebDAmPVakLo8xxPEXMqWFxCU2AWg0Wtd6TgqIQtIMNXQz6cif5Ufxo3lhus+
-dLhsflz+yTpFD5vREvn0kQ9ce+jVjVzh8bK5qfpaNlaIqQc64WpJKQe+8QIDAQAB
-AoGASLj7ecI2YXTnP8DiC+nbIEul2vDceFobJsB6pbLkROoq+WaPke2F64pYO5LO
-s8C4G2IkHk6CvadNkQuZ4JrX9xgNdxWRHGAbDedEFnN8gi0inHQjHITj62Il9civ
-JB8cR5fJxzAKZS23elrocrzU6lU90V4gm4VUUJ6dQhZYO2ECQQDYoC6r+Qf9YCNU
-89/RnGdUzL26l1S/GmUw5VfIDorMNbwH1xfg6Z8MukF42Q9kZQdtoh+HVLG7Ljok
-2cLmmBA9AkEAwqIlSsiGSjfJlzQoDi13X2ZgVp6/nicKan1eKCPq+EnWhA5CP1u1
-5WaYBbLjlDl7A7VA7gMd19tSNGHzRQRAxQJBAJe4kRe3wsXOqNBeQnuf7Kty/suK
-JDv4s7jsWG/w53uhgwGGv92yIsiaRzLp7CLns60wqJ5zTkwIU4bt0dkJ1g0CQD9D
-YQe7whqho37oTxS8po51wl6lXvdTDUmr0k0Nz7RAm990mwfpEWitPkCr8tkdDeUY
-pzA2Bx9AhKnOJLqMNVkCQAwJYI4fS7Mec2f2Kv5SInxjMeasGivzDxe99EyLS8jz
-dWfNwtCGA+gmpqcWqpT/JNnJgG4ljseW7Xk6YogngVU=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent6-cert.pem b/test/fixtures/keys/agent6-cert.pem
deleted file mode 100644
index 18ded35c1f3f04f2f573ad55e38dd36011209a97..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent6-cert.pem
+++ /dev/null
@@ -1,31 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICbDCCAdWgAwIBAgIJANAIL0WLbvvoMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2EzMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjFaGA8yMjkyMDgzMDE4
-NDIyMVowdDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MREwDwYDVQQK
-DAhUcmVzb3JpdDEWMBQGA1UEAwwNw4Fkw6FtIExpcHBhaTEnMCUGCSqGSIb3DQEJ
-ARYYYWRhbS5saXBwYWlAdHJlc29yaXQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GN
-ADCBiQKBgQDBIF2kWViZb+GpjUKfQ2Jevk68mLWXib66z6vCi+mjpcvZeq6A5Z0M
-qNJYftEgSykluxL9EkpRqWr6qCDsSrpazMHG2HB+yip8/lfLWCv/xGAHh9+4XY3s
-UPGIGg+LmvhRCZvgxARxY2uG7AB+WZVMby4TCyAFAT7D/ri4L8iZZwIDAQABMA0G
-CSqGSIb3DQEBCwUAA4GBAFU3MAVxVCmsaoNxr0y+KK/n0iEAzsOH9r0L3PL2gJtl
-p62iOaOPw1/9x8c77RA6z/nXPX9IyAwASv0n8FEdxuIF2+KqFG6bXw5nyfgPIszr
-U7YSV2Pi/Heinr76RrI6aWGtvEuD56Qt3Ce5TYiMnzAWtqEcPLGjgsx0MAv+m48B
------END CERTIFICATE-----
------BEGIN CERTIFICATE-----
-MIIChDCCAe2gAwIBAgIJAOzJuFYnDamnMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2ExMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjFaGA8yMjkyMDgzMDE4
-NDIyMVowejELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEP
-MA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTMx
-IDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0GCSqGSIb3DQEB
-AQUAA4GNADCBiQKBgQCZ9fF/1UcYaurFIX0QIyAJdojn9+bfsTcjEIoGbsAnQLz2
-bsZ4pqRNhZbYJApxqc+oDzZOqJOaxe8mlB5jUZ/sUA9Sp+wfWly95tkEHBMSse4x
-UNJVM4vFPfOG4fv9fYGH3pcmAU1QnST4Fh+qZRzrh9wa99ltmB/U2mJEF6NriwID
-AQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GBAM3CFiDdGEcx
-07J6pm4zGX399VxPr50PID110jmX7BRAfqva+wBRhwweSxZ/QRcKe1v/FK3GE87y
-RbaXhFfnPRUHoUHQMtGwmZuZcdK65Pim9RPGb7qrEJ2wlPt/C1Q6VjL/fBGqjtJM
-Bq/2GR2GoBsE85jGM287hcvXV0eG5OwM
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent6-csr.pem b/test/fixtures/keys/agent6-csr.pem
deleted file mode 100644
index af864a617e9756653f13884fd78174fc213c4166..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent6-csr.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB2TCCAUICAQAwdDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MREw
-DwYDVQQKDAhUcmVzb3JpdDEWMBQGA1UEAwwNw4Fkw6FtIExpcHBhaTEnMCUGCSqG
-SIb3DQEJARYYYWRhbS5saXBwYWlAdHJlc29yaXQuY29tMIGfMA0GCSqGSIb3DQEB
-AQUAA4GNADCBiQKBgQDBIF2kWViZb+GpjUKfQ2Jevk68mLWXib66z6vCi+mjpcvZ
-eq6A5Z0MqNJYftEgSykluxL9EkpRqWr6qCDsSrpazMHG2HB+yip8/lfLWCv/xGAH
-h9+4XY3sUPGIGg+LmvhRCZvgxARxY2uG7AB+WZVMby4TCyAFAT7D/ri4L8iZZwID
-AQABoCUwIwYJKoZIhvcNAQkHMRYMFEEgY2hhbGxlbmdlIHBhc3N3b3JkMA0GCSqG
-SIb3DQEBCwUAA4GBAAX9mbfgDULEA541c1teuG+eW0KLghFaaotFb0+R6WD1ZQLO
-Url8y1iz6T/qqfuoAWu5OA8/7sKDdta/0mzV6UoGnDOcnWnH5FURmnQPUS/hBJ6A
-mJBslJx6y0z4Rl/fxJUy5K31YbeRHHLEneM211usTv8QguAD0y2BNAQ0Mno0
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent6-key.pem b/test/fixtures/keys/agent6-key.pem
deleted file mode 100644
index 0a2f2fae4f0c32d7e57ba96686ee532a559ececb..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent6-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQDBIF2kWViZb+GpjUKfQ2Jevk68mLWXib66z6vCi+mjpcvZeq6A
-5Z0MqNJYftEgSykluxL9EkpRqWr6qCDsSrpazMHG2HB+yip8/lfLWCv/xGAHh9+4
-XY3sUPGIGg+LmvhRCZvgxARxY2uG7AB+WZVMby4TCyAFAT7D/ri4L8iZZwIDAQAB
-AoGAIfEMRBwnxB+zq1bWRKNVII2VzPORxqZAzRg+eZyZXVeAMiKrlJ/GMDljboYr
-Pt+2xZjRR4T1ZtC9qnvt/VlM0uWTEIgyzo29ZO0Bd9yMnIF2EUlzVtW07UnN6+VW
-z1/RxOgBiAvkrSTgN4SOQJJIgOZYAt2Xhrkz/0CLwEOis1ECQQD+1hQkEYwvNH6Y
-qUVoWvlNg0Q4kozNQCrwUrkHCtIOxCmr/KxcwcPBaVmEypcCnwf78KbgUQ/5oIgZ
-OReuNcWjAkEAwgIk38VZRxSyBP1RThbKrK5h+GIwkEO7RW7lZ9yoVKhV6YDMWof0
-xCl23YwdpflaTUHuBVOYa3EPegkOGCfxbQJAdCTDpzCsMHN/Yzp6nLYhu3chJ5t7
-OqyNJVy+YXxIAlzbFTyind/dxQ+rsf7XVmV+sQ+cLs4jNsU4Yi6IIWj2ewJBAKRH
-OH4bF9vulEdRUTV0ay4Jg3/VdRXTpJHIs4xc9lSpLgZJP8Ew+nvYOISlDr3qBSMC
-PtBX1uqzk81cOYkO2YkCQBUVMew70XetUXgh/2KOWyG/87uYy/s/NZ/LGImvo+tq
-FUapBPapob9I7WA6gRYVseiE+mSGPAciGIFg/d6iyxI=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent6.pfx b/test/fixtures/keys/agent6.pfx
deleted file mode 100644
index 1f1d827dc9336527049a6d1722b27d2016ae4476..0000000000000000000000000000000000000000
Binary files a/test/fixtures/keys/agent6.pfx and /dev/null differ
diff --git a/test/fixtures/keys/agent7-cert.pem b/test/fixtures/keys/agent7-cert.pem
deleted file mode 100644
index 98d3f6210cdd51e33234d4f5cf680109909513b0..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent7-cert.pem
+++ /dev/null
@@ -1,19 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDEjCCAfqgAwIBAgIJAJ4TtCDh9ccYMA0GCSqGSIb3DQEBCwUAMDIxCzAJBgNV
-BAYTAkNOMQ4wDAYDVQQKDAVDTk5JQzETMBEGA1UEAwwKQ05OSUMgUk9PVDAgFw0x
-ODExMTYxODQyMjFaGA8yMjkyMDgzMDE4NDIyMVowXTELMAkGA1UEBhMCVVMxCzAJ
-BgNVBAgMAkNBMQswCQYDVQQHDAJTRjENMAsGA1UECgwESU9KUzERMA8GA1UECwwI
-aW9qcy5vcmcxEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQAD
-ggEPADCCAQoCggEBAM2+DkRxPeRGI4JK0YpuaqCJkNswMYMyZM4VQYyn99SL7xS8
-lB9P0vIm+K1P4198WXwUHSykWRcyy54nMNpq+9Dfy8BalHRaUa8BO/7UQgipRGi0
-HidDk/bAuNNHNIzJr2sGYGHsZuHkO9inEqDcqrSlTc0G0zyLry5LekRZRTgAlXpl
-C9PsAZl0J+gGA83rUhdD/RDjaT4ldqjLKycHvcMLCIS6Wq0TszYCUdbvMsageDcQ
-zQerIJkHzfJFGYCetQR5/fiIKyF1bICKD22AnpLlfhdthAhLVlYQn34IlYJwdptq
-2miktcqvBw4rnBhE1ONj8DqF61S9BKr9aCf5OoMCAwEAATANBgkqhkiG9w0BAQsF
-AAOCAQEAbek4GyLi+vVeUg3Od17lr8qT108iP3esUJ5cfPrXaexxcypRAmYPB7r4
-NA/vVeOTNkxbb07Ct8dmz+rTn+FflI9h5eKRC7hbH/rFTDEfnoS66eSlxr/jJgtv
-LWuKTMJhzXjgliHleaBDGzo3mR5hcJbQvj9qyK4pXjxlt2QvkPdx2H9H76+nBh1g
-TY5bW4+3NFaHfaR2p2T20bY3no25/vfV7K5endff6pgzcZR3/SptGTywC4EZzIcz
-9Q0JnALQtxAAxq1yrljQcvpjM/aAYY7BxwFHJuLmb/FpMulkzZ2vJALluF/3G5ne
-RT9QhxJdwUz+Juv5QKH2i+nnb2Ur6g==
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent7-csr.pem b/test/fixtures/keys/agent7-csr.pem
deleted file mode 100644
index a3634a637f8cc3c782490f4f008d00da918f3b39..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent7-csr.pem
+++ /dev/null
@@ -1,17 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIICxzCCAa8CAQAwXTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjENMAsGA1UECgwESU9KUzERMA8GA1UECwwIaW9qcy5vcmcxEjAQBgNVBAMM
-CWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM2+DkRx
-PeRGI4JK0YpuaqCJkNswMYMyZM4VQYyn99SL7xS8lB9P0vIm+K1P4198WXwUHSyk
-WRcyy54nMNpq+9Dfy8BalHRaUa8BO/7UQgipRGi0HidDk/bAuNNHNIzJr2sGYGHs
-ZuHkO9inEqDcqrSlTc0G0zyLry5LekRZRTgAlXplC9PsAZl0J+gGA83rUhdD/RDj
-aT4ldqjLKycHvcMLCIS6Wq0TszYCUdbvMsageDcQzQerIJkHzfJFGYCetQR5/fiI
-KyF1bICKD22AnpLlfhdthAhLVlYQn34IlYJwdptq2miktcqvBw4rnBhE1ONj8DqF
-61S9BKr9aCf5OoMCAwEAAaAlMCMGCSqGSIb3DQEJBzEWDBRBIGNoYWxsZW5nZSBw
-YXNzd29yZDANBgkqhkiG9w0BAQsFAAOCAQEAKcwglrFyAj+pc26WqHv5R9NToUKF
-1Yd5zkExZHWH5glrAprCdRhUY575KcY1Sz4KCCRADdYo7KGUFHi4B/N+iyIS9m3t
-TWpJQVq4o98hF0+FalhdYyIND2FdiTmdxzmi788JFcTKZT1ryKyoB7vAj0kvXdED
-3VU2mDoxPc17ZInR5x0A8hJHDHY9SlDL96n6QTEAByXfqNq/c8S7bkBPEJJUln7G
-L/8YWxQJ25971PEX/QLbWADMkSPGkHCHF0znZhtJ6wxTFRkdQJSa9FASKpVgDMMu
-wQVEnOa10z2aQ3PayZUHh43zq441FakE7LAseeOoJChPb00lFrN3ph+TnQ==
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent7-key.pem b/test/fixtures/keys/agent7-key.pem
deleted file mode 100644
index bc4cbe878af0436a71cf6ac75a43b152807c6b06..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent7-key.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAzb4ORHE95EYjgkrRim5qoImQ2zAxgzJkzhVBjKf31IvvFLyU
-H0/S8ib4rU/jX3xZfBQdLKRZFzLLnicw2mr70N/LwFqUdFpRrwE7/tRCCKlEaLQe
-J0OT9sC400c0jMmvawZgYexm4eQ72KcSoNyqtKVNzQbTPIuvLkt6RFlFOACVemUL
-0+wBmXQn6AYDzetSF0P9EONpPiV2qMsrJwe9wwsIhLparROzNgJR1u8yxqB4NxDN
-B6sgmQfN8kUZgJ61BHn9+IgrIXVsgIoPbYCekuV+F22ECEtWVhCffgiVgnB2m2ra
-aKS1yq8HDiucGETU42PwOoXrVL0Eqv1oJ/k6gwIDAQABAoIBAEvZcmcXHIsotHSX
-YrLXTCYNMUMtfENy86jqOzVAw2Qvhp+teiolAo7VgT5bwmZ0cIUG4U6Q9GtSBbEz
-n5YWdOmnZ/VtL2fJ2G1dViH3XLTWumqjZK5zAnyoxjrV+HCi9jHNswDG55MF0m5o
-Ab0ePSzF+G3Kw1uB376Agv3pr1QacVmMxsYxuUm8Ks0H3hB1E1rYByOcFgljq0EA
-E7GuYG1JyjFcGsoyNPykpJ8Ri6mko5sbE7ndaTPqiYkovl02nsqGdiXSyrlC1Q7O
-+XjfOO0gig6LFsWiKCWxQzJUOTD7RsqRaZTHnEHEf9iIcFmHh52i9Bt5r/lqNA/Q
-D7V7vsECgYEA9pYzzZR4+xSYKfQHEpIdUGQTh1kFIdxHp/W4HD+3NJc+DIeUWGVl
-7oUGcZvcEDfQojM3LUNAof/NuPuLinjKKzycRBU05ApuLIP9R1mq8ndxe98jxOIM
-sCd/UfKHKAtOlyWnLvLuJZLozVYack+9/ZnEDUuz9u1S3l+IPUNiSmMCgYEA1Ziy
-jFvchUecrXz1PFpW95psYMkCcgDYg26UwF8jrEcf26DblXs3O8mPGUqCwHOJHk+6
-fEXMGbF7ocr+b2HMKuq5EaCFUJqu5orZLDqFuxCDee2OS/pxfTXaXwrnCKVrYzJU
-9HNmuac4pryWnarnGbA56BlXp9mJsAbRcxiZOWECgYEAm1CKOn+9H/Cd0zb4SXMs
-8ZjHUCX6/JPhsmIr3+cl/wMQOxYekvrzFCRHpcFVAAYX7EI0C9djW2Zi7pPKFaL1
-O/yGNL/iu4vyTymnm4xYBzbCjRJEVltHQKDwKe6HwOo2Sy+VORYceCArcEI+kCe3
-9IconHNFXE+pNZWYm3XY8B8CgYBmEHUhBLQ3K6T+cXttv21XG382MFbuyuCqzShf
-VBbjt4jNlevXXe1isEmkuCoKdCrNRSPDRkbk8B43jZxO9NhumYKdnaqWfZOdrjNg
-IwbMAHQSyyT3wVCBmD4ktDz5sLHD0MUvmgU4KWO0qOD/ri6H4+GHurRcDGLyrg9f
-hB2TgQKBgH1WLbZEHvY07coCUdAywMCjcR2zmKrxo2rsmVrfjNNF0X0mh6Tsw8Af
-BpL/j2bb7bHIIVKEystD2lx+zmOyLZOmT7nvZ7nFKiRKe4HwHiZW5N3JJjpGfBWU
-vzPAbJHWnyctRihxgXbq6eGJEv5Dwgf6ERP83Cnn3JiDUNPuEIa4
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent8-cert.pem b/test/fixtures/keys/agent8-cert.pem
deleted file mode 100644
index 7b9304d7448c1559b9750b6b2d583d977153bd7d..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent8-cert.pem
+++ /dev/null
@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDUDCCAjgCAQEwDQYJKoZIhvcNAQELBQAwfTELMAkGA1UEBhMCSUwxFjAUBgNV
-BAoMDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsMIlNlY3VyZSBEaWdpdGFsIENlcnRp
-ZmljYXRlIFNpZ25pbmcxKTAnBgNVBAMMIFN0YXJ0Q29tIENlcnRpZmljYXRpb24g
-QXV0aG9yaXR5MCAXDTE2MTAyMDIzNTk1OVoYDzIyOTIwODMwMTg0MjIxWjBdMQsw
-CQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMQ8wDQYDVQQKDAZO
-T0RFSlMxDzANBgNVBAsMBmFnZW50ODESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjAN
-BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvCbXGqz553XQ+W9zsQEaBc1/mhd4
-TFjivwbK1hSdTuB8vWyOw6oZuqAJjctcIPmNXf01zV1+cAurpoU8k9SmtetwqaDV
-0K5ooKUuzgAefRoLJqU0XonW4VaK0ICQATkxSWdJzYET68NTukv5f9Fh0Jfi2Q6Y
-PKlgUIuoTPQJSErAMsdph4KWMP7zsaEZNJhmZ1Lprfm4DdVnwUfYvDhq5VmAHFLj
-Vor/z3DJS+pW9oORDta3CMvAY5oGcIYWWMxsoG9B9NtTTs58jjeFpJrw/RYJA/CM
-uRawLWKt/z1zPhzmvknTKfAIc6SjbBqu8Nx/Xvcd61c2V39U/nZDTs+H9QIDAQAB
-MA0GCSqGSIb3DQEBCwUAA4IBAQBfy91+ceZDfZ0DnHHAlm8e+26V5sdrdOXZJtkc
-AacDcCX6AD1iMK+0axBgG6ZJs6m87cmFdaq23pLpBLQ+KHSdG5YgRCEuWW+RaJGj
-/vVn9AS4eB3EmX0RhhJgYyVbN7ye8qjfAv0NtHzUsdMS8ay3HbdUCtrcsHonGDR3
-t/0BGsYny9Kt2f2PNN32UEkx/jhcssXwnNGxyxR/04heJUe6LI5ErdQoxxvaZtrd
-u9ZgjSxix4dFH4nTYEYe3oXM1U7PakbzOzJvRMmDh8vYyK7/ih0w8/DcsK0d1Oej
-mgtTF/IyJqy8T9goFf9U2uSshia+sKJBfrrzRaUHZMx+ZobA
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent8-csr.pem b/test/fixtures/keys/agent8-csr.pem
deleted file mode 100644
index 9b76b0f530b265f89e18658d2518a1cd8346bb9d..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent8-csr.pem
+++ /dev/null
@@ -1,17 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIICxzCCAa8CAQAwXTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjEPMA0GA1UECgwGTk9ERUpTMQ8wDQYDVQQLDAZhZ2VudDgxEjAQBgNVBAMM
-CWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALwm1xqs
-+ed10Plvc7EBGgXNf5oXeExY4r8GytYUnU7gfL1sjsOqGbqgCY3LXCD5jV39Nc1d
-fnALq6aFPJPUprXrcKmg1dCuaKClLs4AHn0aCyalNF6J1uFWitCAkAE5MUlnSc2B
-E+vDU7pL+X/RYdCX4tkOmDypYFCLqEz0CUhKwDLHaYeCljD+87GhGTSYZmdS6a35
-uA3VZ8FH2Lw4auVZgBxS41aK/89wyUvqVvaDkQ7WtwjLwGOaBnCGFljMbKBvQfTb
-U07OfI43haSa8P0WCQPwjLkWsC1irf89cz4c5r5J0ynwCHOko2warvDcf173HetX
-Nld/VP52Q07Ph/UCAwEAAaAlMCMGCSqGSIb3DQEJBzEWDBRBIGNoYWxsZW5nZSBw
-YXNzd29yZDANBgkqhkiG9w0BAQsFAAOCAQEAsLb6+50b2ck7DOop0M+EitLaY3H2
-PWZBS6A86RU+5y30pJsFKCtefN8Hb21DwSwqhkcFukHzZRcKuGA8IsMhlE2u7YAU
-Bx8pX5jOBhFWbUG+mAoe563XPCQNZ3GbKg3pGOCJ8b6gflmGvIxXlzQlR8lg1RG2
-dT5q/sWTOXOsDyu49bObDw0jEFM/HgHzpFyHdrnh3P2vEULx7qdRVUXQ9JIsuPjB
-bys9FhjDmV9yEabWfHRXqrFY318CPit25Q6Cl9G4EFMCYkUX2nVzjLojExkwJHdf
-y4wDaEzxtqJgEEaQwMu+j68v3wgYAGk0yKMFNDQ0gaSZkAQ6u8I5unTGYQ==
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent8-key.pem b/test/fixtures/keys/agent8-key.pem
deleted file mode 100644
index dac8716602122e1dfbb3222a74b1509b68eacf8e..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent8-key.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEAvCbXGqz553XQ+W9zsQEaBc1/mhd4TFjivwbK1hSdTuB8vWyO
-w6oZuqAJjctcIPmNXf01zV1+cAurpoU8k9SmtetwqaDV0K5ooKUuzgAefRoLJqU0
-XonW4VaK0ICQATkxSWdJzYET68NTukv5f9Fh0Jfi2Q6YPKlgUIuoTPQJSErAMsdp
-h4KWMP7zsaEZNJhmZ1Lprfm4DdVnwUfYvDhq5VmAHFLjVor/z3DJS+pW9oORDta3
-CMvAY5oGcIYWWMxsoG9B9NtTTs58jjeFpJrw/RYJA/CMuRawLWKt/z1zPhzmvknT
-KfAIc6SjbBqu8Nx/Xvcd61c2V39U/nZDTs+H9QIDAQABAoIBAQC0gx8EfMgWBLbF
-WORKAaCRyKKPl8zWksCYPVAFLCnwLvf+VFRz7JJatofz/hMZn9K9Rd2EdhqELO42
-CMYhnneDOasRUzlPyMSgu1m4UezuYTopjX485Um/T2RGvdFrGw/qOKpZ+2i9XNzL
-c3Cf7KZHljERxirQqD+7hwGlMsxlCYpIRYbe6orpT0aAiGr1iVioohyk8tT+7iXD
-mlPeF9qbWAChgfLzTmHcpxGpiFXS0w6KV1XG8sickm1tnoXbCV5ZJw6HscL5VBp9
-SBclRo8AXWBaqhcfj0mvLJWs5E5K3P6dM9X/RcxJwP4Q+kfABYoYjZrZ1/sOJkZr
-mHzoYznRAoGBAPeDWWG5RLSlYgs6Llw9ERF3917AiY+eWUCai7faWGP3SEigmPOm
-m7rHQcI650DN22aXm8DBSRM1QV0C/UWd1DoDpQAc76GexJhLYRA8/ZGAe24/q1nX
-V0aDHzTLC6m8fYGj5ATOotvzYYz6aK9dCuLxPYfWmyZsIXU6K+ypsZOrAoGBAMKa
-a+7es33C8aUf6kvBOtPPs9tJW8rhox9gMQxHXuibz+0ZUM7h0DUbsMkDpj4Ydwqr
-c7O5sIHUjJLSmw7Oaw6xByK51tZNZeA3bVB2ZUAPILNkF2UqldRYRT7DfLTHEbNV
-DMo5P4tR8HxWdrKuhcp+RdPfVmay7iIkFtcKWbLfAoGAR34nKTUMhWln4npRvc7d
-yT/vsezHTzab7S82wEpPUcCxnljVFTvAq7i2Y9YDyhIsF3wfPxQVeXjegnFEmwE1
-tfQritbQ2Mw1WRAc30XesFJ+VKALbI3o5bMmJmen3MVXM0UVrdXJ8OJiAQiriEvF
-wzuPXFc+xWBiYawF1/xEELUCgYAYBm6K2A262gVxSGZpodp8aekfiof9nSvBZOPJ
-S0ppV0stT3HNiM1msRt7RasRgX244H/xUVx8Otx8B+pCwrMu5iYmYGEopfeM3eru
-Ax/u768u1o2Y3NAQnjE2VXYg7269ACQLF1REBAK3pwkSeD9mR36hcLI/DZoetuvm
-8o0uawKBgQCGwazVcS1cOOODw8mP39KIlWNtbpeRI6T4Qz8Z4FO5B324uccRmxL6
-gCRTdO0990mYQ/BJQ0EQWyrcnpqSfw1YYQOYpYvPexhKpRV+sU5KqJJkqEBe3WLm
-oiaFpuz+NtKkQrCc9AlA3SHlJWPo7jTjIPCpGuVM+FipGTbLGHr7HA==
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/agent9-cert.pem b/test/fixtures/keys/agent9-cert.pem
deleted file mode 100644
index 7fdada43d59d7aa996d44965c603d252c447cd53..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent9-cert.pem
+++ /dev/null
@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDUjCCAjoCAQIwDQYJKoZIhvcNAQELBQAwfTELMAkGA1UEBhMCSUwxFjAUBgNV
-BAoMDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsMIlNlY3VyZSBEaWdpdGFsIENlcnRp
-ZmljYXRlIFNpZ25pbmcxKTAnBgNVBAMMIFN0YXJ0Q29tIENlcnRpZmljYXRpb24g
-QXV0aG9yaXR5MCIYDzIwMTYxMDIxMDAwMDAxWhgPMjI5MjA4MzAxODQyMjFaMF0x
-CzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoM
-Bk5PREVKUzEPMA0GA1UECwwGYWdlbnQ5MRIwEAYDVQQDDAlsb2NhbGhvc3QwggEi
-MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC2oEMk2EKwIZrx4IPNcGjHw5DO
-u8A8yJrcWG4pThUadrvwMI7bQ4QwNgHm4PVpbjAPbSUsRPX98PWL6GcpoH0lmJ9+
-j9CCEIEkW+j5wM7hYBXUSGuAZZfkdrpbZHsvwpYj2U39sfmUyGT1gBbGBmaAzODh
-ZaqYSm9VdaKS56SRMey3Pbsx+ikylgiEyPFoRKA141Zuxz1MKiwszLHuyz6pCZKY
-K7x1dlEGi3h3dvkRAdMyeSXJkYCZGbS5Fbl2OuW4pSWP4no/M960vBwEYvuJPDtx
-qxGezE51oXp4W4l9k+TYPOfGJDVW0PAg+JpfbepLetgFaO9/eNWes34AhF6FAgMB
-AAEwDQYJKoZIhvcNAQELBQADggEBAD8ojlI4FdXLCyHVYwwTP6BncF4tfeGP82/i
-Zcr8U9k28T2vlsLwdCGu8UVqGWfYrSY5oZqZmHPcDfZmv6Uc39eQ72aweoyLedk3
-UF1Ucwq+MxEM98doLlqL4lnPO1+TcpdhtoHAgT28WkddbR3alfsu+GRU3br3s4lS
-DHcm6UzdA/lkgZtC8wFUSW04WhzSHB78gm8VOl+1JGY0pp/T+ae5swkfj45Q3jOd
-H6jdZiUrU+LJQwLlXYniF4qzmH0SN8Gd3djVNzWJtNF+LFKXzCOYSK8AFaQ6Ta+s
-Pd6Rqa8Hl6cMmlsDu1NLumstvGna5wsc7ks1VZwtWt6WfIyIN2k=
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/agent9-csr.pem b/test/fixtures/keys/agent9-csr.pem
deleted file mode 100644
index b93b34ec9412cec12640000c584878ecef1395d3..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent9-csr.pem
+++ /dev/null
@@ -1,17 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIICxzCCAa8CAQAwXTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjEPMA0GA1UECgwGTk9ERUpTMQ8wDQYDVQQLDAZhZ2VudDkxEjAQBgNVBAMM
-CWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALagQyTY
-QrAhmvHgg81waMfDkM67wDzImtxYbilOFRp2u/AwjttDhDA2Aebg9WluMA9tJSxE
-9f3w9YvoZymgfSWYn36P0IIQgSRb6PnAzuFgFdRIa4Bll+R2ultkey/CliPZTf2x
-+ZTIZPWAFsYGZoDM4OFlqphKb1V1opLnpJEx7Lc9uzH6KTKWCITI8WhEoDXjVm7H
-PUwqLCzMse7LPqkJkpgrvHV2UQaLeHd2+REB0zJ5JcmRgJkZtLkVuXY65bilJY/i
-ej8z3rS8HARi+4k8O3GrEZ7MTnWhenhbiX2T5Ng858YkNVbQ8CD4ml9t6kt62AVo
-73941Z6zfgCEXoUCAwEAAaAlMCMGCSqGSIb3DQEJBzEWDBRBIGNoYWxsZW5nZSBw
-YXNzd29yZDANBgkqhkiG9w0BAQsFAAOCAQEAms/rMyW2wVfNtBHZ7HAUxUlWl8ow
-0dlZgVmAXF0WBnfOGn31CQcGPyj9btJ48tmaTXmhIw96KqQDIi8KmYXDrDm0JmEp
-d+6Q704A0Qjwq4OmMqSobNHRVZUM24niF+U/oGuI8J5nSbCp/6m6chwM+R015cfl
-1yNqqQXYYIogcHQZVdofeKvGmrQhBfsEt5cdk2riGqfWVBwY6rfXW+MSHIw6cHIn
-vVFYG32Gk8ZU+MoWPQ/DLAy8B7Azo7ePMnidfaOxPAox6IGzCcZOfnCu2tZ09S5t
-gqcpdnecBLuQdIybhKhCbM7GOmIricDeIJXkVhmwmjpcu1WdQWUIUsD18A==
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/agent9-key.pem b/test/fixtures/keys/agent9-key.pem
deleted file mode 100644
index 1dc2df9a064344575980fa98f24e8934d57d0538..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/agent9-key.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEpQIBAAKCAQEAtqBDJNhCsCGa8eCDzXBox8OQzrvAPMia3FhuKU4VGna78DCO
-20OEMDYB5uD1aW4wD20lLET1/fD1i+hnKaB9JZiffo/QghCBJFvo+cDO4WAV1Ehr
-gGWX5Ha6W2R7L8KWI9lN/bH5lMhk9YAWxgZmgMzg4WWqmEpvVXWikuekkTHstz27
-MfopMpYIhMjxaESgNeNWbsc9TCosLMyx7ss+qQmSmCu8dXZRBot4d3b5EQHTMnkl
-yZGAmRm0uRW5djrluKUlj+J6PzPetLwcBGL7iTw7casRnsxOdaF6eFuJfZPk2Dzn
-xiQ1VtDwIPiaX23qS3rYBWjvf3jVnrN+AIRehQIDAQABAoIBAQCxMp0TkfZa+bBi
-woqAenJgaeQGg2vKTobcB72TvFyDmfNO4X6rRz5qnOyJfXsBelWNkkSASMU6SWOn
-Ba+bV0o2gXk4DwisOqFjiv5p3uedDGMB3+bW5TxVA9JcPQm91JtjW0TuRJK7BxnW
-jxsJt0ob7S7B5Kh7LbYLAKHm0nX+HgFcfiaRsVCiCtuYkTOzpkUQsl7psX4VJJQ+
-SYr4URsPZI7SGdIeq6ofKH/yGJeoYyhxfNDzNZXqdIC1LEU4BrsrBR6mVRTj35+K
-0pHiOQ5Eezi5BnEFUgRR6ompTXQGfnDgEmNyuhzVhuP6nFJ/QPO2KUcIkU4cqViC
-7ZTeaLjdAoGBAPNfZbi515DhtwdwDx/Ol0Y6kzyK2NP2FpMlGXwUKXSYbmwbSxSo
-zXGyCjxmKtQfbwzVSd/aNdH1lPCHerNFmumhL52wsWi/9EIT+liaxN8Cw/IbUuOy
-QlA8BT3Pf1H4Fv/ePIx1DuiPk5jp/eyAK/iPVCyXu7d85ULdfhvwVS7XAoGBAMAZ
-/x7dP7qRAUgjvCw8JQVpJPxeVvraKHpzQnceIhd88oTAIYHONNomSBAlqoT00JzW
-uFkDbtMZydhorOCUR/d6oHWyg4qEt7F89mssvCFXkROs+ePCuvspYO4F9B7/A7HT
-dwErWsvEaRmEO/AWRvHMhjTV4F5ZMNvPj3E1YX4DAoGBAMM/y7oRzrG7hD2BV4Dr
-G04KfElcE2ypx56xauqyujeCe0Rb+TZP3tLSRYgDZ2Ta+xrOmv/ubrNNVPpLltLw
-isHYwPy/3vTs2yeQI46mTD+mVlGMPknSn4UDQik+qSS35qvMPcNpvlYxqfZJ85+j
-jKNTSfKkoMMqfjvQuvXrMEvtAoGAIjZ/EWgmKXwZ1ldG9Dnh/gyz4Z6LrzGbc/OD
-KuPa/oPqTWpKjWvETfXzb6zFqdhQLx6uxmuuGTrGkBxUbcr65kCYw11/v/PTI3E2
-EfBtsSJ/XBm6h63uzzyXXs0ApWSVq94Vm8e07AWXEkxSwHe3OulKHa7ZvvPzl7Jn
-wanYKzECgYEAun2EZ1ETQ10fkQ9RYxeJYd3HjazTfWXUJJeVhPlsLQQyVfZoRwy0
-9nzdOclgSvE2/+m3SQFh4UHTddlrU1C/V8pkgImnOyCmBFEv8SAfuvEnhQWA13kA
-bfreLGMiDnbK1+7MEq0CJeIUZ1LWeuHlFNJT8bYvyjLiZcJyipgQ3NA=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/ca1-cert.pem b/test/fixtures/keys/ca1-cert.pem
deleted file mode 100644
index c126543553d904838f9f30480ec4fd34213ec537..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca1-cert.pem
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIChDCCAe2gAwIBAgIJAMsVOuISYJ/GMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2ExMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjBaGA8yMjkyMDgzMDE4
-NDIyMFowejELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEP
-MA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTEx
-IDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0GCSqGSIb3DQEB
-AQUAA4GNADCBiQKBgQDrNdKjVKhbxKbrDRLdy45u9vsU3IH8C3qFcLF5wqf+g7OC
-vMOOrFDM6mL5iYwuYaLRvAtsC0mtGPzBGyFflxGhiBYaOhi7nCKEsUkFuNYlCzX+
-FflT04JYT3qWPLL7rT32GXpABND/8DEnj5D5liYYNR05PjV1fUnGg1gPqXVxbwID
-AQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GBAHhsWFy6m6VO
-AjK14n0XCSM66ltk9qMKpOryXneLhmmkOQbJd7oavueUWzMdszWLMKhrBoXjmvuW
-QceutP9IUq1Kzw7a/B+lLPD90xfLMr7tNLAxZoJmq/NAUI63M3nJGpX0HkjnYwoU
-ekzNkKt5TggwcqqzK+cCSG1wDvJ+wjiD
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/ca1-key.pem b/test/fixtures/keys/ca1-key.pem
deleted file mode 100644
index be4ad727f7020057558edfcb9c58151299afe9b3..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca1-key.pem
+++ /dev/null
@@ -1,18 +0,0 @@
------BEGIN ENCRYPTED PRIVATE KEY-----
-MIIC1DBOBgkqhkiG9w0BBQ0wQTApBgkqhkiG9w0BBQwwHAQIO9cMY0yHJGgCAggA
-MAwGCCqGSIb3DQIJBQAwFAYIKoZIhvcNAwcECAKYHSZXK7beBIICgHkIYlgRIfZt
-QZxMoahaz4Bu6t5F24ud9rdrpT8qKCnffj71z5mtwucE7sXMslcejgo4QEP5V3lS
-zFWQDY5B0p9al+M9DIsseSz8L9StqgQo3FfYLGVs8njO4PFyaWSdbPWWpaXRUmdm
-32CbOKwdvOMFhcR8G+jlezkm4uyQ9yCC5bERdrpsaaPJTlt8aMdrvxMytHw60OZo
-VVF88fRm9x4kUT+sKyiwG0JWTRDueeFoJR4oa5xlw1AVmEYBBQee9Tc73wqtOr2r
-4dnL/zwc6c9ZoTTDOGZNgBvxswVzg04K/qp9LIt3uOeHXqfnmzfmJ4eT5fG71pir
-pSfZPIYXJwgC1NjWvsWudI/kE1Wj0JnGYuPY/Vea9RSSrRqq9nL9kqTSa1jgo8l1
-zTR/uZHZH2wCMlH09tiz7uOiPihsO8qeYWIe+vkgC2xCm6O/B1vMuqQY36LOxeVt
-igi9hDLjWxNth9lEcC/0wsrft8Y1/CF5h3/j86h1IcgQKFrePu40kols/yBxp7/n
-MIzm4oUoClGe3q+a3aajEYL5Cos+7tu2jSM3MKVMiNZ5aTICQ9Sr/OOz+tYZOdJd
-hCDF/oncBALJ7nhe77mf1j+Qy/vZzCvDIl/ki3zK/S83U9InZW3oKFv4u3brh+77
-2zruIZ6l/zId8fFARdh6PvXz5avz2eC//EM1zNJiV6IC9DvB3xibvA05rmoK4g9V
-DIIIWJsTJUPPvEXszMAtb1zR+MhDs71RF6KvM67KCasI0k07hGY0rgDjlzeoWe/3
-SLgXPda5/WCkRcpgznzRu53HJwq27tUsh74hXPbqaQREDrX0bBBokAMCGBxCFrJi
-Btmo/ouOp4w=
------END ENCRYPTED PRIVATE KEY-----
diff --git a/test/fixtures/keys/ca2-cert.pem b/test/fixtures/keys/ca2-cert.pem
deleted file mode 100644
index 0c72d6c64756fe20dc00e12300b077a58136d331..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca2-cert.pem
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICbTCCAdYCCQDRrfgRk8tC1zANBgkqhkiG9w0BAQsFADB6MQswCQYDVQQGEwJV
-UzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMQ8wDQYDVQQKDAZKb3llbnQxEDAO
-BgNVBAsMB05vZGUuanMxDDAKBgNVBAMMA2NhMjEgMB4GCSqGSIb3DQEJARYRcnlA
-dGlueWNsb3Vkcy5vcmcwIBcNMTgxMTE2MTg0MjIwWhgPMjI5MjA4MzAxODQyMjBa
-MHoxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNV
-BAoMBkpveWVudDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2EyMSAwHgYJ
-KoZIhvcNAQkBFhFyeUB0aW55Y2xvdWRzLm9yZzCBnzANBgkqhkiG9w0BAQEFAAOB
-jQAwgYkCgYEAv61gNiLff+zxCdAwdzlVoucGu5L+LFFN9TXzcT3ZD8U1H6CiLp3Q
-02IlbK1JRHwpJBXgYOFvMWd9LD6JiJgJsp61kpZShl2qZSUIfhzeExWH7kkuPHWC
-IEkiP/aDp5wuqbFBkNUJu8opYr0E6/t9sIzl4IK7WNDXWgQvv8cqin8CAwEAATAN
-BgkqhkiG9w0BAQsFAAOBgQB80WTJ9neA5yVaDVV+hZtOasLiZlUT8m49ImQMnInA
-jdoAkxgySNOJP8IrsilleAGeHF+JPy042z8NZ5C+xL9REaB1/OaQ7+nwHP0O0f+l
-kXHgZATQ3YVf6db5euK3R1mdO1Vv++R4Nu4NYBu0cmfMpdl/uKdYpXMjPVn21iB7
-5w==
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/ca2-crl.pem b/test/fixtures/keys/ca2-crl.pem
deleted file mode 100644
index de416297dcd381672aa0fcd80d9810bdb63ef941..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca2-crl.pem
+++ /dev/null
@@ -1,10 +0,0 @@
------BEGIN X509 CRL-----
-MIIBXTCBxzANBgkqhkiG9w0BAQ0FADB6MQswCQYDVQQGEwJVUzELMAkGA1UECAwC
-Q0ExCzAJBgNVBAcMAlNGMQ8wDQYDVQQKDAZKb3llbnQxEDAOBgNVBAsMB05vZGUu
-anMxDDAKBgNVBAMMA2NhMjEgMB4GCSqGSIb3DQEJARYRcnlAdGlueWNsb3Vkcy5v
-cmcXDTE4MTExNjE4NDIyMFoXDTQ2MDQwMjE4NDIyMFowHDAaAgkAkfAGY2Bp8poX
-DTE4MTExNjE4NDIyMFowDQYJKoZIhvcNAQENBQADgYEAiZKSPllC/hi1S9jedRFt
-eah65RINSkGZt40AuxPIFfyu5qSeKU+9p8zdXELtPqywSr2k6JjBP40yRIc5/odZ
-CxFM5XR/AIoeNspplxb+Qg1v1KlbGxzfeBHRIn91QpKcvsMCEYF8nu3xKOJmYrTR
-3Kj0gniNHbiLe/HTpEY7YOA=
------END X509 CRL-----
diff --git a/test/fixtures/keys/ca2-key.pem b/test/fixtures/keys/ca2-key.pem
deleted file mode 100644
index 2efd44d78c3b6aea26223a6608dd9bdb2a63096f..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca2-key.pem
+++ /dev/null
@@ -1,18 +0,0 @@
------BEGIN ENCRYPTED PRIVATE KEY-----
-MIIC1DBOBgkqhkiG9w0BBQ0wQTApBgkqhkiG9w0BBQwwHAQI0/0Q5tLDQW0CAggA
-MAwGCCqGSIb3DQIJBQAwFAYIKoZIhvcNAwcECHCRfosVTaMUBIICgHq2VKpOxq8W
-+KZ7bVFuWx/gJvE1FAJokIZogK52LH3oEk9kMlEujwYAMovEew4lPMgAnyQh5Mbx
-BXIm8Arww9hUZlRPuHmeQQuikbz/Sy5LVFbrzRsM0xGZxeWkpq3iKj3Z4W1OneRd
-HAtBADAlID1a4r5f/BxiuNBGn5X54x66qbC94mJ2b02zHJJaRVd6OQM5iZURlcbi
-N1E/LtQ3/I9qWqGYfiVCZf39ItxbrBkIEk65BbCackpDpVxzOfEbvC8RdBZcHxZm
-8g4XZ6p1rCmzLi22l7usgEhd4QSMQyT9JTnMfM1QFzaqAVTqWr4ZFP108a2vH574
-T/HFKBkI+DEUsKQTLmYqZ05mg0wx80KGP/+1jOB1yx0tGnxCihGJVhqqGoFqgBSm
-aqC5arQIZSUt2eN4OamakgU4iLzrKFb6bWGwTNUoHZNh4TsYz4CvFkPcM5tOyX+l
-RoUyPAyfu348Z2IKBzUwYUfXJ5WFW2xq+RiOmlt4zF1Lym+aktEP6REQZYTGZZZx
-l1YsvIUDd0pj5AJ3/PSTZN+VzkKz5lJdKEDEqpoOkEZnE/FL5VJHnRLOANyNf1zl
-qZFgLGRZgZQwGkwj2hAF3auRJWJyvjuQW57v86F3U6XKKKejgBVb2ohMk7U6WW8B
-wPtYyEa2zW1hSCLWhMEaek5Y2/2NX/dPryHNZ5XJ1UD0SGrPumN4lbErKDWGmAoK
-jH6bpX/xVdmur2BwgGdqt6S1BW9B2F+cXz46UNiFKPYL49iBe13xM5EFKk9N9DL3
-HWPWrExlmi+p4PASL6cR5t9sDw8wUYp5cyC/M1RHDJPvjgBX987F17fI6GkNNToE
-ZIbM6M/EuKg=
------END ENCRYPTED PRIVATE KEY-----
diff --git a/test/fixtures/keys/ca3-cert.pem b/test/fixtures/keys/ca3-cert.pem
deleted file mode 100644
index 7cc283053da2beb73114b848b62d90496f86eb66..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca3-cert.pem
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIChDCCAe2gAwIBAgIJAOzJuFYnDamnMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2ExMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjFaGA8yMjkyMDgzMDE4
-NDIyMVowejELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEP
-MA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTMx
-IDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0GCSqGSIb3DQEB
-AQUAA4GNADCBiQKBgQCZ9fF/1UcYaurFIX0QIyAJdojn9+bfsTcjEIoGbsAnQLz2
-bsZ4pqRNhZbYJApxqc+oDzZOqJOaxe8mlB5jUZ/sUA9Sp+wfWly95tkEHBMSse4x
-UNJVM4vFPfOG4fv9fYGH3pcmAU1QnST4Fh+qZRzrh9wa99ltmB/U2mJEF6NriwID
-AQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GBAM3CFiDdGEcx
-07J6pm4zGX399VxPr50PID110jmX7BRAfqva+wBRhwweSxZ/QRcKe1v/FK3GE87y
-RbaXhFfnPRUHoUHQMtGwmZuZcdK65Pim9RPGb7qrEJ2wlPt/C1Q6VjL/fBGqjtJM
-Bq/2GR2GoBsE85jGM287hcvXV0eG5OwM
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/ca3-csr.pem b/test/fixtures/keys/ca3-csr.pem
deleted file mode 100644
index 2c0358727f46f7065115e05acc6ce33582798dcc..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca3-csr.pem
+++ /dev/null
@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB3zCCAUgCAQAwejELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQH
-DAJTRjEPMA0GA1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQD
-DANjYTMxIDAeBgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMIGfMA0GCSqG
-SIb3DQEBAQUAA4GNADCBiQKBgQCZ9fF/1UcYaurFIX0QIyAJdojn9+bfsTcjEIoG
-bsAnQLz2bsZ4pqRNhZbYJApxqc+oDzZOqJOaxe8mlB5jUZ/sUA9Sp+wfWly95tkE
-HBMSse4xUNJVM4vFPfOG4fv9fYGH3pcmAU1QnST4Fh+qZRzrh9wa99ltmB/U2mJE
-F6NriwIDAQABoCUwIwYJKoZIhvcNAQkHMRYMFEEgY2hhbGxlbmdlIHBhc3N3b3Jk
-MA0GCSqGSIb3DQEBCwUAA4GBACeDmANyVHX/zFlz0OhqXzFw2C76/AjoNsR7cY6b
-Mdl8R27MexPxkhD2IOzESxDkxFTzv+aVAz4gQIxDmdea307/P5LvRQXucAtNkAWi
-2j6hB0Oq1BNKyBnevRTv28X7rhUp5OGDhRPP5lt1+PPA0zTurw+zJIaInePM//sT
-7Ckh
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/ca3-key.pem b/test/fixtures/keys/ca3-key.pem
deleted file mode 100644
index b1fe69b712fc85472b3c9826d4b5ab181756aae9..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca3-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQCZ9fF/1UcYaurFIX0QIyAJdojn9+bfsTcjEIoGbsAnQLz2bsZ4
-pqRNhZbYJApxqc+oDzZOqJOaxe8mlB5jUZ/sUA9Sp+wfWly95tkEHBMSse4xUNJV
-M4vFPfOG4fv9fYGH3pcmAU1QnST4Fh+qZRzrh9wa99ltmB/U2mJEF6NriwIDAQAB
-AoGAOfsmdNb0TFzPh2fiOnaP9SBf1MRGfU23DwyGfn+s+9tkjoYPVpajX9KEiWeh
-S0cBPjBkamEQHYSXWPcFLrApwnaS8A3Tkp1Voas1dg9Bu3WmDzIIsmBseMgMW00C
-6yETeYFtZ8/2nnpK/G7+N8eeseA63LUqg6ANw+BMH3o3dcECQQDNKW6ZfhDtn94+
-PWeXmxJWU6bm30U4othIo3iZKIswDhxVnlZhZ0mrgs0mc9c4CzTmyogvLKN0/nJF
-gknvEcdrAkEAwByJR63E5Wg8OR/d0HgZAkrXVZGkGz33ZddGygrdUGvk4dfYYALB
-A6/aCDc99gn4cUkzcOGOUGGEn3m38BeUYQJAUfyytChK/4sZt2m2kkFoTJNVaYHk
-GcQKBs09DofDR8r7y8Ng5b/vEtlMvocghMcFtw1M6v09vS1J4Tk17pH+TQJBAJYZ
-dbU4cv+e6nbjjAam3ztoSEjGK0dRqiu7AMc5p+N++WzvnVKetDnyOtNyfgnvjlrN
-C9ElmnD5UIrdqjZ/5eECQHhcQsKgsWGRKPKxyf7f/sFHpkSeAEZSAPdh8ouzIdUS
-xSRbK9UF+ckIop5cYjnBbmFa/BjWr4m9NcEKE8rXYxk=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/ca4-cert.pem b/test/fixtures/keys/ca4-cert.pem
deleted file mode 100644
index 4a94c99f0c3a3b8e35e69ed51391e2cefedec1cb..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca4-cert.pem
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICkzCCAfygAwIBAgIJAJHwBmNgafKbMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoMBkpveWVu
-dDEQMA4GA1UECwwHTm9kZS5qczEMMAoGA1UEAwwDY2EyMSAwHgYJKoZIhvcNAQkB
-FhFyeUB0aW55Y2xvdWRzLm9yZzAgFw0xODExMTYxODQyMjFaGA8yMjkyMDgzMDE4
-NDIyMVowgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0Yx
-HzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAOBgNVBAsMB05vZGUu
-anMxDDAKBgNVBAMMA2NhNDEeMBwGCSqGSIb3DQEJARYPY2E0QGV4YW1wbGUub3Jn
-MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDC1M2aGVYsmrBiut1n0nfTU+9v
-TNVdAmKQBjnNsv3IIch/PPaEOIEm7dFhgdk86Z+wVCN3sAKu54Bz4JDKdPsFGvDy
-18JGuGH1vIVW5285IW7fMrzvAdZtETeBAiPM10Q69ddB4M6FbLiF273ZqCJ+vSsw
-kl5Dkas8YTZ0uwqKjQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEB
-CwUAA4GBAGDMGSbPg/B4OripSxT2scXFIwoej47PW1byJgWaGoMJ8zgKUoKE7Z7A
-aWQbD22In05F0kBllqpSJWEZpTuVFsyyLeb3R7cuGQWs/puaaPul7sx+PRGhwxYe
-nrNIGtsaBf8TO/kb5lMiXWbhM5gZbBtbMMv3xWA4FxqU0AgfO3jM
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/ca4-csr.pem b/test/fixtures/keys/ca4-csr.pem
deleted file mode 100644
index 0e6a0393843b27da710bcc90696dd10c6465634f..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca4-csr.pem
+++ /dev/null
@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIB7jCCAVcCAQAwgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UE
-BwwCU0YxHzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAOBgNVBAsM
-B05vZGUuanMxDDAKBgNVBAMMA2NhNDEeMBwGCSqGSIb3DQEJARYPY2E0QGV4YW1w
-bGUub3JnMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDC1M2aGVYsmrBiut1n
-0nfTU+9vTNVdAmKQBjnNsv3IIch/PPaEOIEm7dFhgdk86Z+wVCN3sAKu54Bz4JDK
-dPsFGvDy18JGuGH1vIVW5285IW7fMrzvAdZtETeBAiPM10Q69ddB4M6FbLiF273Z
-qCJ+vSswkl5Dkas8YTZ0uwqKjQIDAQABoCUwIwYJKoZIhvcNAQkHMRYMFEEgY2hh
-bGxlbmdlIHBhc3N3b3JkMA0GCSqGSIb3DQEBCwUAA4GBAJoKIMOK0sCoXAa/cCaJ
-oTYLHee1aJBWmt8XTUqREdFIIAjjrgY0/ZGEeA9OEczbFgSTMPXemir4Ks3ib3kr
-MeJkOWSUgKL2gdV4jPZIUEdeTYaMQ5utiTvL2oKN4R51mSNg5ZEFIf+vZpK6UTpR
-LCERUC79Hsj13NrHK2Lf8jhy
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/ca4-key.pem b/test/fixtures/keys/ca4-key.pem
deleted file mode 100644
index 90d595bce5b50ea48dccd21a20810b2b9848ee13..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca4-key.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQDC1M2aGVYsmrBiut1n0nfTU+9vTNVdAmKQBjnNsv3IIch/PPaE
-OIEm7dFhgdk86Z+wVCN3sAKu54Bz4JDKdPsFGvDy18JGuGH1vIVW5285IW7fMrzv
-AdZtETeBAiPM10Q69ddB4M6FbLiF273ZqCJ+vSswkl5Dkas8YTZ0uwqKjQIDAQAB
-AoGALnr8Tf4ra9q/p94ywfkZMyZ8Ic5vvI+8GeYSVjuUhfFhVtGhcivUzAfCgwOq
-YvjNaxC3oW8xRK7gG0UA5fwAgm24RkwazqYgcT2OTqoffRhd3lmyOUcR7fWB6FAN
-p7mx9ctW83HBPCwc7SIFaWxMULi3O38A7jXMMJrjIzhEsVUCQQDiKJF8sE6Ep7cr
-ARDcWxKP5INa7+UdsPdpR+wKxdrReQuhIF5V0hA6QbyCsNpqhqrO7e4El194qCMk
-NfYnz1nPAkEA3IoHlwMOquisd6/KcurFbUHguKH6CWzpxRU6QfLqUkNf+MPPozU1
-qYOm7nukWyJq+dDt5hrmaSuZny6I9zWY4wJBALcq8kJRrRZFm9VppJVD8bG2+ygw
-uZkllgyf4q4K9yHG7sNOKvlJDDmSujIDOLMkZLz5+VegngNj8ipGxhoSFwMCQGwv
-VdvRhx919izcUk6fNmwLVgachsCa6e5hJGv3ktT58hlhTPk9/+4BBCGXC6AdOScF
-Q76OUZsj5T8+H7hNVYsCQCahB/XNbok2MgfB8ABdqVPcAOMLtaGZH4gbE2M3p/Fh
-Y6BHQ25FT3LPKEzU89XJuyRoxea3CXqioJngt3JxN1I=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/ca5-cert.pem b/test/fixtures/keys/ca5-cert.pem
deleted file mode 100644
index ef42f5bf92f6683896123d5ad4469bfa06c90eee..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca5-cert.pem
+++ /dev/null
@@ -1,14 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICHDCCAcGgAwIBAgIJANUB/0ZUgBZhMAoGCCqGSM49BAMCMIGIMQswCQYDVQQG
-EwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMR8wHQYDVQQKDBZUaGUgTm9k
-ZS5qcyBGb3VuZGF0aW9uMRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTUx
-HjAcBgkqhkiG9w0BCQEWD2NhNUBleGFtcGxlLm9yZzAgFw0xODExMTYxODQyMjFa
-GA8yMjkyMDgzMDE4NDIyMVowgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEL
-MAkGA1UEBwwCU0YxHzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAO
-BgNVBAsMB05vZGUuanMxDDAKBgNVBAMMA2NhNTEeMBwGCSqGSIb3DQEJARYPY2E1
-QGV4YW1wbGUub3JnMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6qDnQ6qm6hN+
-zbym76EK+spOKstEmqj9WzdA/tRBHhzZijXq1l90yQmRfmgclAKZw843qzMfj8Vj
-RMRXdZyyYKMQMA4wDAYDVR0TBAUwAwEB/zAKBggqhkjOPQQDAgNJADBGAiEA4nCM
-yQUkViSEvBeL3cLzRnak68tXTIkdRMekRFgdsOMCIQDFnkeCyB4S9u2gz1u/syEq
-usBaxJpZkN5nyTLapTQGqA==
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/ca5-csr.pem b/test/fixtures/keys/ca5-csr.pem
deleted file mode 100644
index a1f77c72a4e1a0557564155b7db6b47ec6a57d1c..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca5-csr.pem
+++ /dev/null
@@ -1,10 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIBaTCCARACAQAwgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UE
-BwwCU0YxHzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAOBgNVBAsM
-B05vZGUuanMxDDAKBgNVBAMMA2NhNTEeMBwGCSqGSIb3DQEJARYPY2E1QGV4YW1w
-bGUub3JnMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6qDnQ6qm6hN+zbym76EK
-+spOKstEmqj9WzdA/tRBHhzZijXq1l90yQmRfmgclAKZw843qzMfj8VjRMRXdZyy
-YKAlMCMGCSqGSIb3DQEJBzEWDBRBIGNoYWxsZW5nZSBwYXNzd29yZDAKBggqhkjO
-PQQDAgNHADBEAiABtQaxoQqAdrK8rjMh4wPB14/+uxMtJ7mY+QwJ411XywIgERcz
-HrcyJDqk2CS8B9mHwzD+ERUZ1CgThc15bnBleN0=
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/ca5-key.pem b/test/fixtures/keys/ca5-key.pem
deleted file mode 100644
index c213e03beadcf49cba4566a79414d4f53ea9fb74..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca5-key.pem
+++ /dev/null
@@ -1,8 +0,0 @@
------BEGIN EC PARAMETERS-----
-BggqhkjOPQMBBw==
------END EC PARAMETERS-----
------BEGIN EC PRIVATE KEY-----
-MHcCAQEEINQRYMZO9+WwFZsKDa03DHkQfraKyJ3EcAfYkgtyYtX3oAoGCCqGSM49
-AwEHoUQDQgAE6qDnQ6qm6hN+zbym76EK+spOKstEmqj9WzdA/tRBHhzZijXq1l90
-yQmRfmgclAKZw843qzMfj8VjRMRXdZyyYA==
------END EC PRIVATE KEY-----
diff --git a/test/fixtures/keys/ca6-cert.pem b/test/fixtures/keys/ca6-cert.pem
deleted file mode 100644
index a6d2c1fbd2978b57689dada9f667aaae760dd7c8..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca6-cert.pem
+++ /dev/null
@@ -1,14 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICGzCCAcGgAwIBAgIJAMTCBUQ4OI4+MAoGCCqGSM49BAMCMIGIMQswCQYDVQQG
-EwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMR8wHQYDVQQKDBZUaGUgTm9k
-ZS5qcyBGb3VuZGF0aW9uMRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTUx
-HjAcBgkqhkiG9w0BCQEWD2NhNUBleGFtcGxlLm9yZzAgFw0xODExMTYxODQyMjFa
-GA8yMjkyMDgzMDE4NDIyMVowgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEL
-MAkGA1UEBwwCU0YxHzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAO
-BgNVBAsMB05vZGUuanMxDDAKBgNVBAMMA2NhNjEeMBwGCSqGSIb3DQEJARYPY2E2
-QGV4YW1wbGUub3JnMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa7HfEgyVTPWY
-ku9cWGRSym5OdB7zqFihL8+k93EfWViJph72fJH3sOZypUgDXS/sEyUaLhbxtLYz
-sMbECzEDwaMQMA4wDAYDVR0TBAUwAwEB/zAKBggqhkjOPQQDAgNIADBFAiEA+NIP
-zuqh2e3/59QndyPqRH2CZ4V4ipU6rf6ZZmwPApUCIBMABWesJfwdrETIjN6dT8gc
-STrYyR4ovD8Aofubqjd0
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/ca6-csr.pem b/test/fixtures/keys/ca6-csr.pem
deleted file mode 100644
index c12e008f533a8767faeb4e8f4ff54a1586db43ca..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca6-csr.pem
+++ /dev/null
@@ -1,10 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIBaTCCARACAQAwgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UE
-BwwCU0YxHzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAOBgNVBAsM
-B05vZGUuanMxDDAKBgNVBAMMA2NhNjEeMBwGCSqGSIb3DQEJARYPY2E2QGV4YW1w
-bGUub3JnMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa7HfEgyVTPWYku9cWGRS
-ym5OdB7zqFihL8+k93EfWViJph72fJH3sOZypUgDXS/sEyUaLhbxtLYzsMbECzED
-waAlMCMGCSqGSIb3DQEJBzEWDBRBIGNoYWxsZW5nZSBwYXNzd29yZDAKBggqhkjO
-PQQDAgNHADBEAiAH69eeaDguTPAqGhWJbhFPEw7zXyZl6TgxoMIeZOouRgIge+Ft
-kXO05md30kbq6s559B45rYoH4iHxFOJZqHso7Yc=
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/ca6-key.pem b/test/fixtures/keys/ca6-key.pem
deleted file mode 100644
index bb80dd3af4990b966647c533767a8a992df4e767..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ca6-key.pem
+++ /dev/null
@@ -1,8 +0,0 @@
------BEGIN EC PARAMETERS-----
-BggqhkjOPQMBBw==
------END EC PARAMETERS-----
------BEGIN EC PRIVATE KEY-----
-MHcCAQEEIFbxtF4Zc09n/2w7z5SMQLFNTdxg4QPSm1WgyffHtJFIoAoGCCqGSM49
-AwEHoUQDQgAEa7HfEgyVTPWYku9cWGRSym5OdB7zqFihL8+k93EfWViJph72fJH3
-sOZypUgDXS/sEyUaLhbxtLYzsMbECzEDwQ==
------END EC PRIVATE KEY-----
diff --git a/test/fixtures/keys/dh1024.pem b/test/fixtures/keys/dh1024.pem
deleted file mode 100644
index 67c8cbc9231718ccdbd34f7c31240ddc1107ac43..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dh1024.pem
+++ /dev/null
@@ -1,5 +0,0 @@
------BEGIN DH PARAMETERS-----
-MIGHAoGBAOJ2igPYPdXULPSXaeR40pdGRdQmiWchzxDbzExdaJ4Q/landa7K9jfj
-KNV2heMpFoXa6+GkCxXSli+99j0W/ARK1nnZ9YaB42sp3g2oTmMevWyk9hfZTTUC
-Pc3AyioJGTQV/5wqYPdSNAu5KdHFZkP26EhbGgnDZ2hg5vFQT6EjAgEC
------END DH PARAMETERS-----
diff --git a/test/fixtures/keys/dh2048.pem b/test/fixtures/keys/dh2048.pem
deleted file mode 100644
index cece692e241b2823eedc1cba0d8f6e127927bd41..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dh2048.pem
+++ /dev/null
@@ -1,8 +0,0 @@
------BEGIN DH PARAMETERS-----
-MIIBCAKCAQEA+/OlXG2eqOsd9oA6Rg9KDbU22adIXuuwSaVLiUFNIc4WYnzPuyd0
-WcLajZzhXoUpN6GCLqXE+jBphHTh+xx6Y0ztlMldx0mnrLzacd236LCrTX5smojO
-CQ3BFmbDn7naG2famOZXF3gLRkcAmUtHrn2hYRbEk+1+GD3yXUm/JgFcnAX2HUQa
-b4sDL5NHMJ61+qE65qIIht9jOVovl4b7yOoyDu+JrheV0XBrc8WU03AGKcJnjW6i
-YqKXQlpamVvL/QqWfhg3SztBxYADAURePTUmS1H1FTnxSdRoUK9ZwKoTeZFL6krT
-3HK76Y0HXhwtjk3aXKTJyEDDLdYaltOCOwIBAg==
------END DH PARAMETERS-----
diff --git a/test/fixtures/keys/dh512.pem b/test/fixtures/keys/dh512.pem
deleted file mode 100644
index 713076ee2ffba6a079b3ff59c31f054c07fbda88..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dh512.pem
+++ /dev/null
@@ -1,4 +0,0 @@
------BEGIN DH PARAMETERS-----
-MEYCQQDItkdipTrinQp7aKt0GtwY7QE6tMKpg+r1zeucMrq9uNp8uLhHkF1OtqnL
-StFTzxQIkjN2s8exIvoWZWiy/9DTAgEC
------END DH PARAMETERS-----
diff --git a/test/fixtures/keys/dherror.pem b/test/fixtures/keys/dherror.pem
deleted file mode 100644
index 4f56268d19a23ecaff8032798b1e52ab2cc74ba5..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dherror.pem
+++ /dev/null
@@ -1,4 +0,0 @@
------BEGIN DH PARAMETERS-----
-AAAAAAAAAA
-AAAAAAAAAA
------END DH PARAMETERS-----
diff --git a/test/fixtures/keys/dsa1025.pem b/test/fixtures/keys/dsa1025.pem
deleted file mode 100644
index bd83e734c688e88cc112cd9451c29ff89f1f3756..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa1025.pem
+++ /dev/null
@@ -1,9 +0,0 @@
------BEGIN DSA PARAMETERS-----
-MIIBLgKBiQDp3xGIsNcKZWSpur2Ab2f5rirhu5AsYGLI/XZvzueoO4kLPp3szKHX
-abBObdxU07kRFkfpV9lftdXT3a6E/Wxb+w2d7g0F7pWTdwpmmofcRtwgbynmJKvq
-Wt/OwfVFsdUvvpVci9AxY/5rdM/K54Srp6iSpfteBYKGqCpPnswikND0GxKM1Mbz
-AhUAqAPKCZ4hxromirUu33tn3Nhsq20CgYgf0tH2nwzWlPLoN4OJvC5dVLPvMRyJ
-TQekW8tR0oY6PeshmZOaoI0L3e/M4KeZ/4qiY7IRNksP2YGJxjfS6W+h+MNjPO5r
-0aYYFYCPQ8JbhBO7l0hdXmkTY3FcdyRHeh2gwe3bBX6Auev2MGgL616Cgd/KH8PA
-X9EHmrNPcQOWHem4KcfJXqou
------END DSA PARAMETERS-----
diff --git a/test/fixtures/keys/dsa_params.pem b/test/fixtures/keys/dsa_params.pem
deleted file mode 100644
index 9052393fd2ebbe20fe442f7653eb9defb74a5ce3..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa_params.pem
+++ /dev/null
@@ -1,14 +0,0 @@
------BEGIN DSA PARAMETERS-----
-MIICLQKCAQEAoSw3Ghf02sMSmd5k2rvSqf6eJPFO7fHDRyvDDbifjO6/BKSIkXM4
-3qyCqddC04arKg7wc1QDEQ8gb13pCmnC0RBiljE6ke4yK46Q5JjiEKH9U1eCbtTr
-hcGrLDgwbqvRM06EN6IfAL3OBF6YzS9wn3/EfSwW2Z8gAIkjZrTjEUTV+/gEAdfE
-gd/WAZxcc9zYKOwPy0/LjjldQw5fsPlIEkS1yJFlWMokSsZVYlJLR06h1S4kQoE3
-BqELirH/FQfJ36RMRFsaKZ6nQYS66Qc8rybQw2VlOJsqiRoTSDwREPz6j9oLYh1E
-e86j5Xt9jbiBrK33UbkTr/jBtO0J2PR0+wIhAIXIexS5LQJPSoi96k6OU4yrLLmA
-IY8gS9mdYTdbpwcdAoIBAQCCN3gTjFiPgBQ/bj/Edp9w90SA+dQ/VnnYDTMcz+Mi
-/8sgtlQ3O9CCFb0327YnOLwvxsmSadT9XrIq1/5jGD2VtjFDVlridjYASrjezR2k
-dr781G+bxtVNQuIOKZl9xqruCmHUSSRL/vuCR6pKsA81ZPfpdcLh3RYYxDIoTK6t
-VX4GrX5bcxGDIUCQiTaqKv9Nzpm1liBLRm6LHczBsFk2OVrRyMsT3gh0J6DSUw+d
-w/Vru1J6glkrr0CxBWoJ65btcqtFyQV/76btor9Qgc/z9suYBoJZ3Ua0yAfv3J2E
-rOs1CAbh4LWNULA9eJObY2R4sAV7Q8wOMT5jmjKo4unp
------END DSA PARAMETERS-----
diff --git a/test/fixtures/keys/dsa_private.pem b/test/fixtures/keys/dsa_private.pem
deleted file mode 100644
index 3f64ae4e85f0d436a42031f8af66d331fdf766cf..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa_private.pem
+++ /dev/null
@@ -1,20 +0,0 @@
------BEGIN DSA PRIVATE KEY-----
-MIIDVwIBAAKCAQEAoSw3Ghf02sMSmd5k2rvSqf6eJPFO7fHDRyvDDbifjO6/BKSI
-kXM43qyCqddC04arKg7wc1QDEQ8gb13pCmnC0RBiljE6ke4yK46Q5JjiEKH9U1eC
-btTrhcGrLDgwbqvRM06EN6IfAL3OBF6YzS9wn3/EfSwW2Z8gAIkjZrTjEUTV+/gE
-AdfEgd/WAZxcc9zYKOwPy0/LjjldQw5fsPlIEkS1yJFlWMokSsZVYlJLR06h1S4k
-QoE3BqELirH/FQfJ36RMRFsaKZ6nQYS66Qc8rybQw2VlOJsqiRoTSDwREPz6j9oL
-Yh1Ee86j5Xt9jbiBrK33UbkTr/jBtO0J2PR0+wIhAIXIexS5LQJPSoi96k6OU4yr
-LLmAIY8gS9mdYTdbpwcdAoIBAQCCN3gTjFiPgBQ/bj/Edp9w90SA+dQ/VnnYDTMc
-z+Mi/8sgtlQ3O9CCFb0327YnOLwvxsmSadT9XrIq1/5jGD2VtjFDVlridjYASrje
-zR2kdr781G+bxtVNQuIOKZl9xqruCmHUSSRL/vuCR6pKsA81ZPfpdcLh3RYYxDIo
-TK6tVX4GrX5bcxGDIUCQiTaqKv9Nzpm1liBLRm6LHczBsFk2OVrRyMsT3gh0J6DS
-Uw+dw/Vru1J6glkrr0CxBWoJ65btcqtFyQV/76btor9Qgc/z9suYBoJZ3Ua0yAfv
-3J2ErOs1CAbh4LWNULA9eJObY2R4sAV7Q8wOMT5jmjKo4unpAoIBAQCE1m+DUb9L
-T58u6XV/L1p6K9T2mc6jAmzD51fPiUwsRov9sDGJmSnQjQ5pt3hVp8inVfNkhqOI
-1rpdKmx5W00fPu6VCiPuximuHSNHzJpCAVUrIH8YasS+AurCOwGMdvODLF6dx7yR
-MdxbiszrBry8J0TdvqElHZ1YmQDwoHH7R4pUd31jsk4gnE6pkqLgWwVAy0LXXGsg
-2JfnDvdQY8fIHkuezLdhOyO9pRlXSYv4fLdMaSjHyEcwr2hnm5tm5RsBwM+u0sDc
-yBqUjwoN8NTuLLasfJzzmjeHWDcRGFbzKt/xlUkQ7pf+xdelnLOstuPDGglB1U85
-REhx4rQGKg7nAiA0FX4e4Ms3OXUnmtsTALk5YMiMF3jUp4pRDhHFKBgsYQ==
------END DSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/dsa_private_1025.pem b/test/fixtures/keys/dsa_private_1025.pem
deleted file mode 100644
index 038b0c36bb994757b5b3c7822800f473d66d98fd..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa_private_1025.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN DSA PRIVATE KEY-----
-MIIB0gIBAAKBiQDp3xGIsNcKZWSpur2Ab2f5rirhu5AsYGLI/XZvzueoO4kLPp3s
-zKHXabBObdxU07kRFkfpV9lftdXT3a6E/Wxb+w2d7g0F7pWTdwpmmofcRtwgbynm
-JKvqWt/OwfVFsdUvvpVci9AxY/5rdM/K54Srp6iSpfteBYKGqCpPnswikND0GxKM
-1MbzAhUAqAPKCZ4hxromirUu33tn3Nhsq20CgYgf0tH2nwzWlPLoN4OJvC5dVLPv
-MRyJTQekW8tR0oY6PeshmZOaoI0L3e/M4KeZ/4qiY7IRNksP2YGJxjfS6W+h+MNj
-PO5r0aYYFYCPQ8JbhBO7l0hdXmkTY3FcdyRHeh2gwe3bBX6Auev2MGgL616Cgd/K
-H8PAX9EHmrNPcQOWHem4KcfJXqouAoGIcZ/4bJurOAw5OL4+5BsE4jfSVFq4nmNl
-+m6Iy6ls3hOHOZ9sJlw0Fi+ZtdeddOTYnIngW/kH09XGoF5JJOaLQv2O4GmZfDfn
-la+vfHZPsOxmYqeEbSwA2pqlhOn/dCshBOymhwNLXp1FJ3JUEyh8i605X06XmWoj
-4ZIu/tr1xbnZDLHuFjBmXAIURbB5/IDf2h0sW+qL5gHFO8bgr+E=
------END DSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/dsa_private_encrypted.pem b/test/fixtures/keys/dsa_private_encrypted.pem
deleted file mode 100644
index 49b3375baf7194d294e738f30f7687b06cc38ec1..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa_private_encrypted.pem
+++ /dev/null
@@ -1,23 +0,0 @@
------BEGIN DSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: AES-256-CBC,FABA263DD471F214EF3E02699B837C20
-
-Tj2+4x9MEIaQGFQ4o7hk12MriVYyvLO5aCbqq7LG5uhVk546/+bJc6hewdSwb6oT
-MYPbuV+QTdtqshqFESA0McyGlj4w1tOg5TomP84NTKvwTO1EirVLMukfF3dqaguw
-C117AZJkGbqgbi6lZ2bG0Hta6HRbhI5+ODFtOp3rKQ2KwVmtL7zw6vt3PCISeMHN
-fLqikDc2+YoI9V1FJis9/FATyqV8yrJYYQQpP1RQN+gDY4SSs/eUr+Me7RNy6Lz7
-oH0tDaPGbiafwrZe1okksjxT2JQz1Q3hciBPikgdQIoE2NWTUlOeRYX0T0N2n37S
-6Odbcr522e+2XjcLj34Ozthp+Q5mIDcLuakazxkXhq0RyhJ7vo+xA2YiP7Q3vH7g
-oAnsJPFNVY6wJhprZi2VofKIUJUiajAXGDVX2yEIG/DOA9rnx0ZP+zopXMi4ptu0
-RzWyAL+P4jn0b8vgPf9CYJmn4VNfOcVmomZ1Bw6hzqTE2FnThJCXU3l2eaC/wcSR
-uMRp8c6IM8AR5DUzUBKIckkvXj1m5iSZoKuR8dB7s9BhrRtBAI7K3G254G06sByv
-0pnft8r+BkMqgdfG4rJQoQJw7tVYln+pL/gYPDuYsqyJ9kFuHDqtBvlozqXY5AL1
-XQaXoD6xMACEoJSIv5y+TzFzXwFQrDW+G1724YOSbiioUfGD0tRfjj2ei63PThQr
-Z50SryfKQQf4UgcJeokMhmRWT2vPXEFWEP1b2FMEQxBy6fyKcqwZBAbhqF6usGEB
-nwr/S1HXQAGEsWoc/Z4yynB7uhOwWu/Vpj+V6B98NmC7EUX15Why8zCsT9gzaIgC
-M6sZafHhcmjfwc+lL9xFlU/wnAOz0LeKZWry3D0sXZn1r2FRlOJdtLLx01Sve/MU
-ZRsgEDTkzv8E9dDltMeq8HQDCgLT1USTMWcY1kMELBj7y7ZdCWjH1QhTq2KlId+o
-1X28zJOsOL/XRseUSlpjmSSLRw1QQEypNCY2+tcvViAvn3AifipBbdzUNhvygLhc
-a2+5rYsd8BBEFnMJx7lDiyqXGnZkBbhbCSIudppNcjC+akFlFp6fBzkp4mKBuKpc
-hwBBdfqdEyzqu6SVHM8nGV/aDoRuu9shV6MX0y/KnIgLedudn8aN2eLgjR5k1+99
------END DSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/dsa_private_encrypted_1025.pem b/test/fixtures/keys/dsa_private_encrypted_1025.pem
deleted file mode 100644
index b75ffaf90df5eabe54198f7a09e8886ea29dfc2b..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa_private_encrypted_1025.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN ENCRYPTED PRIVATE KEY-----
-MIIBvTBXBgkqhkiG9w0BBQ0wSjApBgkqhkiG9w0BBQwwHAQIqTW00yecdxMCAggA
-MAwGCCqGSIb3DQIJBQAwHQYJYIZIAWUDBAEqBBBKgO4UF0LfCkPyS+iCvSrtBIIB
-YD3W6FyEZ97/crnoyRqjPUtr2Mm4KJMtaB5ZiGFzZEzd6AH7N/dbtAAMIibtsjmd
-RYdIptpET6xTpUhM8TvpULyYaZnhZJKTpVUrTVdvFTS3DYDutu7aWRLTrle6LzcY
-XpIppeP8ZmYFdRBQxhF+KoDsP4O0QA+vWl2W2VmRfr+sK9R+qV89w0YMjEWHsYY+
-VZsDbJBGKkj9gzIvxIsRyack/+RsbiSDrh6WTw+D0jrX/IMbgPjvYfBFhpxGC7zR
-hDn9r3JaO2KdHh9kMtvQfshA1n636kb0X6ewY57BhEs3J4hpMg46c6YFry94to24
-jxl5KutM0CFea7mYGtNf6WJXBsm7JSW03kjlqYoZGK43KNgZhzKAsXaNkoRkA5cw
-BzGfgmG6dHTpeAY9G4vM4inhCmGFA8Tx189g+xzRv16uFXRb8WFIllne1fEFaXRr
-1Rz2G6SPJkA3fsrl8zUIB0Y=
------END ENCRYPTED PRIVATE KEY-----
diff --git a/test/fixtures/keys/dsa_private_pkcs8.pem b/test/fixtures/keys/dsa_private_pkcs8.pem
deleted file mode 100644
index 8e4be9e7224fd19be87187bf6c5525af391e0e68..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa_private_pkcs8.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIICZQIBADCCAjoGByqGSM44BAEwggItAoIBAQChLDcaF/TawxKZ3mTau9Kp/p4k
-8U7t8cNHK8MNuJ+M7r8EpIiRczjerIKp10LThqsqDvBzVAMRDyBvXekKacLREGKW
-MTqR7jIrjpDkmOIQof1TV4Ju1OuFwassODBuq9EzToQ3oh8Avc4EXpjNL3Cff8R9
-LBbZnyAAiSNmtOMRRNX7+AQB18SB39YBnFxz3Ngo7A/LT8uOOV1DDl+w+UgSRLXI
-kWVYyiRKxlViUktHTqHVLiRCgTcGoQuKsf8VB8nfpExEWxopnqdBhLrpBzyvJtDD
-ZWU4myqJGhNIPBEQ/PqP2gtiHUR7zqPle32NuIGsrfdRuROv+MG07QnY9HT7AiEA
-hch7FLktAk9KiL3qTo5TjKssuYAhjyBL2Z1hN1unBx0CggEBAII3eBOMWI+AFD9u
-P8R2n3D3RID51D9WedgNMxzP4yL/yyC2VDc70IIVvTfbtic4vC/GyZJp1P1esirX
-/mMYPZW2MUNWWuJ2NgBKuN7NHaR2vvzUb5vG1U1C4g4pmX3Gqu4KYdRJJEv++4JH
-qkqwDzVk9+l1wuHdFhjEMihMrq1VfgatfltzEYMhQJCJNqoq/03OmbWWIEtGbosd
-zMGwWTY5WtHIyxPeCHQnoNJTD53D9Wu7UnqCWSuvQLEFagnrlu1yq0XJBX/vpu2i
-v1CBz/P2y5gGglndRrTIB+/cnYSs6zUIBuHgtY1QsD14k5tjZHiwBXtDzA4xPmOa
-Mqji6ekEIgIgNBV+HuDLNzl1J5rbEwC5OWDIjBd41KeKUQ4RxSgYLGE=
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/dsa_public.pem b/test/fixtures/keys/dsa_public.pem
deleted file mode 100644
index 7d2f2c63bc8e0e8c9dbb732721cd457d4c33b53d..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa_public.pem
+++ /dev/null
@@ -1,20 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIDSDCCAjoGByqGSM44BAEwggItAoIBAQChLDcaF/TawxKZ3mTau9Kp/p4k8U7t
-8cNHK8MNuJ+M7r8EpIiRczjerIKp10LThqsqDvBzVAMRDyBvXekKacLREGKWMTqR
-7jIrjpDkmOIQof1TV4Ju1OuFwassODBuq9EzToQ3oh8Avc4EXpjNL3Cff8R9LBbZ
-nyAAiSNmtOMRRNX7+AQB18SB39YBnFxz3Ngo7A/LT8uOOV1DDl+w+UgSRLXIkWVY
-yiRKxlViUktHTqHVLiRCgTcGoQuKsf8VB8nfpExEWxopnqdBhLrpBzyvJtDDZWU4
-myqJGhNIPBEQ/PqP2gtiHUR7zqPle32NuIGsrfdRuROv+MG07QnY9HT7AiEAhch7
-FLktAk9KiL3qTo5TjKssuYAhjyBL2Z1hN1unBx0CggEBAII3eBOMWI+AFD9uP8R2
-n3D3RID51D9WedgNMxzP4yL/yyC2VDc70IIVvTfbtic4vC/GyZJp1P1esirX/mMY
-PZW2MUNWWuJ2NgBKuN7NHaR2vvzUb5vG1U1C4g4pmX3Gqu4KYdRJJEv++4JHqkqw
-DzVk9+l1wuHdFhjEMihMrq1VfgatfltzEYMhQJCJNqoq/03OmbWWIEtGbosdzMGw
-WTY5WtHIyxPeCHQnoNJTD53D9Wu7UnqCWSuvQLEFagnrlu1yq0XJBX/vpu2iv1CB
-z/P2y5gGglndRrTIB+/cnYSs6zUIBuHgtY1QsD14k5tjZHiwBXtDzA4xPmOaMqji
-6ekDggEGAAKCAQEAhNZvg1G/S0+fLul1fy9aeivU9pnOowJsw+dXz4lMLEaL/bAx
-iZkp0I0Oabd4VafIp1XzZIajiNa6XSpseVtNHz7ulQoj7sYprh0jR8yaQgFVKyB/
-GGrEvgLqwjsBjHbzgyxence8kTHcW4rM6wa8vCdE3b6hJR2dWJkA8KBx+0eKVHd9
-Y7JOIJxOqZKi4FsFQMtC11xrINiX5w73UGPHyB5Lnsy3YTsjvaUZV0mL+Hy3TGko
-x8hHMK9oZ5ubZuUbAcDPrtLA3MgalI8KDfDU7iy2rHyc85o3h1g3ERhW8yrf8ZVJ
-EO6X/sXXpZyzrLbjwxoJQdVPOURIceK0BioO5w==
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/dsa_public_1025.pem b/test/fixtures/keys/dsa_public_1025.pem
deleted file mode 100644
index 1b4f083817eaa3eee1ff5fcd8d33f24db23cdaaa..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/dsa_public_1025.pem
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIBzjCCATsGByqGSM44BAEwggEuAoGJAOnfEYiw1wplZKm6vYBvZ/muKuG7kCxg
-Ysj9dm/O56g7iQs+nezModdpsE5t3FTTuREWR+lX2V+11dPdroT9bFv7DZ3uDQXu
-lZN3Cmaah9xG3CBvKeYkq+pa387B9UWx1S++lVyL0DFj/mt0z8rnhKunqJKl+14F
-goaoKk+ezCKQ0PQbEozUxvMCFQCoA8oJniHGuiaKtS7fe2fc2GyrbQKBiB/S0faf
-DNaU8ug3g4m8Ll1Us+8xHIlNB6Rby1HShjo96yGZk5qgjQvd78zgp5n/iqJjshE2
-Sw/ZgYnGN9Lpb6H4w2M87mvRphgVgI9DwluEE7uXSF1eaRNjcVx3JEd6HaDB7dsF
-foC56/YwaAvrXoKB38ofw8Bf0Qeas09xA5Yd6bgpx8leqi4DgYwAAoGIcZ/4bJur
-OAw5OL4+5BsE4jfSVFq4nmNl+m6Iy6ls3hOHOZ9sJlw0Fi+ZtdeddOTYnIngW/kH
-09XGoF5JJOaLQv2O4GmZfDfnla+vfHZPsOxmYqeEbSwA2pqlhOn/dCshBOymhwNL
-Xp1FJ3JUEyh8i605X06XmWoj4ZIu/tr1xbnZDLHuFjBmXA==
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/ec-cert.pem b/test/fixtures/keys/ec-cert.pem
deleted file mode 100644
index 1fd84b2fe88d5ed447171e2207fbaac8e9f50500..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ec-cert.pem
+++ /dev/null
@@ -1,13 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB6zCCAZICCQDB6nsD1ZVtUjAKBggqhkjOPQQDAjB9MQswCQYDVQQGEwJVUzEL
-MAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMQ8wDQYDVQQKDAZKb3llbnQxEDAOBgNV
-BAsMB05vZGUuanMxDzANBgNVBAMMBmFnZW50MjEgMB4GCSqGSIb3DQEJARYRcnlA
-dGlueWNsb3Vkcy5vcmcwIBcNMTgxMTE2MTg0MzE0WhgPMjI5MjA4MzAxODQzMTRa
-MH0xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNV
-BAoMBkpveWVudDEQMA4GA1UECwwHTm9kZS5qczEPMA0GA1UEAwwGYWdlbnQyMSAw
-HgYJKoZIhvcNAQkBFhFyeUB0aW55Y2xvdWRzLm9yZzBZMBMGByqGSM49AgEGCCqG
-SM49AwEHA0IABEppwUcxZQc2qbTxko8VEYAtKhMPbzzkhMlC3iqv+DJG9gXRJ3Kt
-8vz3/HuBV6gGDjuaTObou//p7sBjOdvcTXAwCgYIKoZIzj0EAwIDRwAwRAIgAmC2
-Xfpv1zjKePs3xAAWGP3Xp9+1lOdHpA3mTjlAFOoCIAJagVrpr8rWOf73fdN31xrs
-8IdbV8S1DDlqYzANVPnA
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/ec-csr.pem b/test/fixtures/keys/ec-csr.pem
deleted file mode 100644
index ab9e2085aef58ee22ed47cd958237fbeb0e87371..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ec-csr.pem
+++ /dev/null
@@ -1,9 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIBODCB3wIBADB9MQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcM
-AlNGMQ8wDQYDVQQKDAZKb3llbnQxEDAOBgNVBAsMB05vZGUuanMxDzANBgNVBAMM
-BmFnZW50MjEgMB4GCSqGSIb3DQEJARYRcnlAdGlueWNsb3Vkcy5vcmcwWTATBgcq
-hkjOPQIBBggqhkjOPQMBBwNCAARKacFHMWUHNqm08ZKPFRGALSoTD2885ITJQt4q
-r/gyRvYF0SdyrfL89/x7gVeoBg47mkzm6Lv/6e7AYznb3E1woAAwCgYIKoZIzj0E
-AwIDSAAwRQIhANc8OD4E9EhR8SBrvdgA6n0rg9x6cpWst4cMkR59wkSJAiAD+kOE
-X4RCKkmFxRysPaXrbwEQRCVYV/ynrCsYm5kbnA==
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/ec-key.pem b/test/fixtures/keys/ec-key.pem
deleted file mode 100644
index f9e40a8ce2fae61d7b38ff04e6de20619d63e0c5..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ec-key.pem
+++ /dev/null
@@ -1,8 +0,0 @@
------BEGIN EC PARAMETERS-----
-BggqhkjOPQMBBw==
------END EC PARAMETERS-----
------BEGIN EC PRIVATE KEY-----
-MHcCAQEEIBxOoTv4SYyESx2cM2ittkAS3z3YGQsPp38otS0PpkqhoAoGCCqGSM49
-AwEHoUQDQgAESmnBRzFlBzaptPGSjxURgC0qEw9vPOSEyULeKq/4Mkb2BdEncq3y
-/Pf8e4FXqAYOO5pM5ui7/+nuwGM529xNcA==
------END EC PRIVATE KEY-----
diff --git a/test/fixtures/keys/ec.pfx b/test/fixtures/keys/ec.pfx
deleted file mode 100644
index 2d2f502c77324bd9ecbb6370e5c91b14fba2dc4f..0000000000000000000000000000000000000000
Binary files a/test/fixtures/keys/ec.pfx and /dev/null differ
diff --git a/test/fixtures/keys/ec10-cert.pem b/test/fixtures/keys/ec10-cert.pem
deleted file mode 100644
index d6019ebce0cdeefd5137cb53ab21dc6fe5e2ff8a..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ec10-cert.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIB9zCCAZ6gAwIBAgIJAKl1NQOcXpYrMAoGCCqGSM49BAMCMIGIMQswCQYDVQQG
-EwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMR8wHQYDVQQKDBZUaGUgTm9k
-ZS5qcyBGb3VuZGF0aW9uMRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTYx
-HjAcBgkqhkiG9w0BCQEWD2NhNkBleGFtcGxlLm9yZzAgFw0xODExMTYxODQyMjFa
-GA8yMjkyMDgzMDE4NDIyMVoweDELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQsw
-CQYDVQQHDAJTRjEfMB0GA1UECgwWVGhlIE5vZGUuanMgRm91bmRhdGlvbjEQMA4G
-A1UECwwHTm9kZS5qczEcMBoGA1UEAwwTYWdlbnQxMC5leGFtcGxlLmNvbTBZMBMG
-ByqGSM49AgEGCCqGSM49AwEHA0IABDuWsQNVJ8wPZjqFqkkVeuYfYrfgstcPO7Ai
-cGrgfQKeFvz+oLd6+U+OGFMFh0+LkI6oTADserWMFyuaiqDIFzAwCgYIKoZIzj0E
-AwIDRwAwRAIgM0oqALjQXRlxmJlje71j0AX22Dq732dH0/oBEHiTDBcCIBbOfILG
-vtveS9DMkz5VVlqQJ2TsDcSerhXHcLowXt5i
------END CERTIFICATE-----
------BEGIN CERTIFICATE-----
-MIICGzCCAcGgAwIBAgIJAMTCBUQ4OI4+MAoGCCqGSM49BAMCMIGIMQswCQYDVQQG
-EwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMR8wHQYDVQQKDBZUaGUgTm9k
-ZS5qcyBGb3VuZGF0aW9uMRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTUx
-HjAcBgkqhkiG9w0BCQEWD2NhNUBleGFtcGxlLm9yZzAgFw0xODExMTYxODQyMjFa
-GA8yMjkyMDgzMDE4NDIyMVowgYgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEL
-MAkGA1UEBwwCU0YxHzAdBgNVBAoMFlRoZSBOb2RlLmpzIEZvdW5kYXRpb24xEDAO
-BgNVBAsMB05vZGUuanMxDDAKBgNVBAMMA2NhNjEeMBwGCSqGSIb3DQEJARYPY2E2
-QGV4YW1wbGUub3JnMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa7HfEgyVTPWY
-ku9cWGRSym5OdB7zqFihL8+k93EfWViJph72fJH3sOZypUgDXS/sEyUaLhbxtLYz
-sMbECzEDwaMQMA4wDAYDVR0TBAUwAwEB/zAKBggqhkjOPQQDAgNIADBFAiEA+NIP
-zuqh2e3/59QndyPqRH2CZ4V4ipU6rf6ZZmwPApUCIBMABWesJfwdrETIjN6dT8gc
-STrYyR4ovD8Aofubqjd0
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/ec10-csr.pem b/test/fixtures/keys/ec10-csr.pem
deleted file mode 100644
index da92a5eea92523dc1a3247766026df7b9598e60e..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ec10-csr.pem
+++ /dev/null
@@ -1,10 +0,0 @@
------BEGIN CERTIFICATE REQUEST-----
-MIIBWDCB/wIBADB4MQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcM
-AlNGMR8wHQYDVQQKDBZUaGUgTm9kZS5qcyBGb3VuZGF0aW9uMRAwDgYDVQQLDAdO
-b2RlLmpzMRwwGgYDVQQDDBNhZ2VudDEwLmV4YW1wbGUuY29tMFkwEwYHKoZIzj0C
-AQYIKoZIzj0DAQcDQgAEO5axA1UnzA9mOoWqSRV65h9it+Cy1w87sCJwauB9Ap4W
-/P6gt3r5T44YUwWHT4uQjqhMAOx6tYwXK5qKoMgXMKAlMCMGCSqGSIb3DQEJBzEW
-DBRBIGNoYWxsZW5nZSBwYXNzd29yZDAKBggqhkjOPQQDAgNIADBFAiEAgyYiDWmr
-Ks1RAQAsxR91PFzxJRa7dgclWPmuDTGTxhcCIFLtalcAOlD+4Wa06SvgGWN/R4V2
-u/JZjWD+lWFZjOC5
------END CERTIFICATE REQUEST-----
diff --git a/test/fixtures/keys/ec10-key.pem b/test/fixtures/keys/ec10-key.pem
deleted file mode 100644
index eca56fc2d9e13ebfd1fdc0e5298983c1fe92c512..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ec10-key.pem
+++ /dev/null
@@ -1,8 +0,0 @@
------BEGIN EC PARAMETERS-----
-BggqhkjOPQMBBw==
------END EC PARAMETERS-----
------BEGIN EC PRIVATE KEY-----
-MHcCAQEEIAAaqQ4/ivoch4lwve3fjDLeycYlB3q15IoxsA3fEBA7oAoGCCqGSM49
-AwEHoUQDQgAEO5axA1UnzA9mOoWqSRV65h9it+Cy1w87sCJwauB9Ap4W/P6gt3r5
-T44YUwWHT4uQjqhMAOx6tYwXK5qKoMgXMA==
------END EC PRIVATE KEY-----
diff --git a/test/fixtures/keys/ec10.pfx b/test/fixtures/keys/ec10.pfx
deleted file mode 100644
index 59448e550d4aed2e9692794ca5d762faa97a685d..0000000000000000000000000000000000000000
Binary files a/test/fixtures/keys/ec10.pfx and /dev/null differ
diff --git a/test/fixtures/keys/ed25519_private.pem b/test/fixtures/keys/ed25519_private.pem
deleted file mode 100644
index f837457cbd4f2377894b5627583a0c5cb9afaf34..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ed25519_private.pem
+++ /dev/null
@@ -1,3 +0,0 @@
------BEGIN PRIVATE KEY-----
-MC4CAQAwBQYDK2VwBCIEIMFSujN0jIUIdzSvuxka0lfgVVkMdRTuaVvIYUHrvzXQ
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/ed25519_public.pem b/test/fixtures/keys/ed25519_public.pem
deleted file mode 100644
index 4127a471bac9f5d32449687b1c9e52c6aa49ecf4..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ed25519_public.pem
+++ /dev/null
@@ -1,3 +0,0 @@
------BEGIN PUBLIC KEY-----
-MCowBQYDK2VwAyEAK1wIouqnuiA04b3WrMa+xKIKIpfHetNZRv3h9fBf768=
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/ed448_private.pem b/test/fixtures/keys/ed448_private.pem
deleted file mode 100644
index 9643665d67656df7fe458ce64585217328c8cfe9..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ed448_private.pem
+++ /dev/null
@@ -1,4 +0,0 @@
------BEGIN PRIVATE KEY-----
-MEcCAQAwBQYDK2VxBDsEOdOtCnu9bDdBqSHNNZ5xoDA5KdLBTUNPcKFaOADNX32s
-dfpo52pCtPqfku/l3/OfUHsF43EfZsaaWA==
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/ed448_public.pem b/test/fixtures/keys/ed448_public.pem
deleted file mode 100644
index b767109b187ee2dbe5fd18e1a5c7774e5e8ab5cf..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/ed448_public.pem
+++ /dev/null
@@ -1,4 +0,0 @@
------BEGIN PUBLIC KEY-----
-MEMwBQYDK2VxAzoAoX/ee5+jlcU53+BbGRsGIzly0V+SZtJ/oGXY0udf84q2hTW2
-RdstLktvwpkVJOoNb7oDgc2V5ZUA
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/fake-cnnic-root-cert.pem b/test/fixtures/keys/fake-cnnic-root-cert.pem
deleted file mode 100644
index da1b9d62a96db8fcf1889989de10bac83f888d2c..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/fake-cnnic-root-cert.pem
+++ /dev/null
@@ -1,18 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIC+TCCAeGgAwIBAgIJAJfD0pHVqYGkMA0GCSqGSIb3DQEBCwUAMDIxCzAJBgNV
-BAYTAkNOMQ4wDAYDVQQKDAVDTk5JQzETMBEGA1UEAwwKQ05OSUMgUk9PVDAgFw0x
-ODExMTYxODQyMjFaGA8yMjkyMDgzMDE4NDIyMVowMjELMAkGA1UEBhMCQ04xDjAM
-BgNVBAoMBUNOTklDMRMwEQYDVQQDDApDTk5JQyBST09UMIIBIjANBgkqhkiG9w0B
-AQEFAAOCAQ8AMIIBCgKCAQEA0nOFmJ4C0bUucql6YlXHPVyuxh5IxZ0heSjVCJXp
-Vk9JJRPxpU0Py1tSTW7GJSMRIsvFrrbVfb52YHOzaGwMiJ5OcR1cCVXWR5fci0lS
-0mTh8Rf+igHjKe/qrpOoqWzw7a0AHkFbcA5pGOZcB9qW2aMq3+mv4z+K8Jpw/b7G
-4QGeEfNx52xM/ygtW51GnmxFJp0eTrIQmJbPFKVrjjdAner+8v9fgmrYiFydFknf
-EqzFlsO1hcflw3caVD/usBpHq4VVvzy2fPqx6VJsloMYyNlCJIvrC0woHb/yj7Da
-JEnHu0MdEhrxzA+biw0/sgOH3au2FdtPoZlmloyReydiGQIDAQABoxAwDjAMBgNV
-HRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAMz67MddcgXRPkTEiRhVFrTIqr
-rny80Smrz9byJx7KhK0ciaDm+KvJavm7e6rrzuedOmbOdhZ3oN5wVo55v1fZqhL1
-dpt1/BlzyCBADE4FM2pDyvLKxbGGcpCzFCbi2K5WsKFJspm6Zr43R1y9UtyInNXB
-GLYwcbGqUrhbtLgnGMBccS/rEgasN3RGbADnZulfzkoGSCTAHJP6B+pFIW6T3kyr
-Sa+Wuvs0UeoaicOzMz8vTySpJPF+8kW/7MSuW26XZyc966Ht1dUuosv9Umg2VNcF
-SxRoUuaQKyHkyh/p4JmrDu2I9J25VE3FNvH7YoJCyaVrF213LvVA92FtDqzp
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/fake-cnnic-root-key.pem b/test/fixtures/keys/fake-cnnic-root-key.pem
deleted file mode 100644
index 918946953ae809ce4b608770ad2bdf2f183ea609..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/fake-cnnic-root-key.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEA0nOFmJ4C0bUucql6YlXHPVyuxh5IxZ0heSjVCJXpVk9JJRPx
-pU0Py1tSTW7GJSMRIsvFrrbVfb52YHOzaGwMiJ5OcR1cCVXWR5fci0lS0mTh8Rf+
-igHjKe/qrpOoqWzw7a0AHkFbcA5pGOZcB9qW2aMq3+mv4z+K8Jpw/b7G4QGeEfNx
-52xM/ygtW51GnmxFJp0eTrIQmJbPFKVrjjdAner+8v9fgmrYiFydFknfEqzFlsO1
-hcflw3caVD/usBpHq4VVvzy2fPqx6VJsloMYyNlCJIvrC0woHb/yj7DaJEnHu0Md
-EhrxzA+biw0/sgOH3au2FdtPoZlmloyReydiGQIDAQABAoIBAEDF04mcoIuA81HR
-PdzEP/Vv8E8EBSvlZ+cNnTvuQAoTjxS9ZbOV21Wgvt0cShomB+EozKgwl9cC5xZa
-pg5uqxDlgIkqGyi4ZaJVaEjqgXZGHJCC7RH28L74m8etpMy4vhK5G380aHs9xDUo
-uYylR6ampMyT9VHBPfc94acHr9iSguuPlZcO37aBc7BPRTa6MBFtLC8c2K7ybI+b
-yeGJypsd3N5aIzM3+JOVJQzD/3jNHODdAZKdCw5ZAfrUBIS4OaI/bC+3Ke/OvTrI
-tliXqHemlJNdVbGdOneaUu6Ysq/en4NK3d86b03dGrLnCsWeMa194TXYfLRQEVtn
-qbuXroECgYEA75KNQ7Fr7SX9r/TCp7Qro3cVoFxsgntypay3uqoiq2dJTvyBcgYh
-eawfY4vE2YVTGRmlwqits0SMr6VBa/BqFwm7D2IDqJDJ4blggmJ6m9qMQLADg2Mc
-CX5rRu24NsH8LEcikvXJy/qPUeFm8JDjEcRui66KLaM/IeVh5NZZn2kCgYEA4OHG
-84ExUNEXk7qoCd3CSlkFYj/7NgMcEiEeRI1gViaLp7XuI4i1my0JZbvmznyAUsxd
-NdDsYpqvETKuXA5G9doJwI5Y4FkMt9nfPniKsHESwvaIardeM42DuUOtnYApi74d
-GRd6RipJHFdfv6GNaftx5w2nyIVn1vfYaAsEBzECgYBOIh/MWgr29xL71fm+NDaf
-Q3FcMYh6LcTAX8o0KNTRzgfMqPGWvIUiZ459KtJyltb5MrIrAFRWSR8REfZ6O5h+
-FwBZDgBfc4lEAu+E1pViSy6+0ijzKtm0BvT51wHjafTShAi0oVDFI9ymObsW7koA
-O25KRAxwwfMPHP6GYZotMQKBgCJ5mmV0Ndo8489q+x3gGEwLj667PkjOezwwRZKe
-1dj/OcOxOVvLNoQeiGVHRB/9qDKJT/TTHZoUOqh5S4+jRK+mCH6zk9546GE7DmVm
-V2SrQQQQhWNOzys6E6qQPIp7vmLE93METWN6UhD9OBmJq8NGn/Sa/FDaWsvy3QM+
-RRTRAoGBAKQJMSfuiEB42TtVm0VnIbs+r9iDXgKi0ifDQSQyHjptYL2KF5GCNljY
-d9ZZJJsfMmj2pDeggLE9RB8yANQGQ87KfvZ45pZ6qL48Efw5ZknpeSjswHby87Qc
-24HmFjQKg6DhN+mRmxRjKe1rQpchRkaoO5kFmE2IUknuIybUkKMV
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/fake-startcom-root-cert.pem b/test/fixtures/keys/fake-startcom-root-cert.pem
deleted file mode 100644
index 48e5713ccb3b1c506d0a591cabade2892832c4bd..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/fake-startcom-root-cert.pem
+++ /dev/null
@@ -1,22 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDjzCCAnegAwIBAgIJAIIPb0xPNcgKMA0GCSqGSIb3DQEBCwUAMH0xCzAJBgNV
-BAYTAklMMRYwFAYDVQQKDA1TdGFydENvbSBMdGQuMSswKQYDVQQLDCJTZWN1cmUg
-RGlnaXRhbCBDZXJ0aWZpY2F0ZSBTaWduaW5nMSkwJwYDVQQDDCBTdGFydENvbSBD
-ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAgFw0xODExMTYxODQyMjFaGA8yMjkyMDgz
-MDE4NDIyMVowfTELMAkGA1UEBhMCSUwxFjAUBgNVBAoMDVN0YXJ0Q29tIEx0ZC4x
-KzApBgNVBAsMIlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNpZ25pbmcxKTAn
-BgNVBAMMIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkq
-hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1mZ/bufFVPGxKagC8W7hpBephIFIZw9K
-bX6ska2PXZkyqRToU5UFgTYhdBwkCNJMwaYfTqLpc9y/goRpVlLSAFk/t4W6Z0w1
-b80T149XvmelAUQTBJR49kkYspN+Jw627pf8tmmSkG5qcHykB9gr/nvoTpXtlk2t
-um/SL3BQSqXmqffBM/6VpFvGAB2FNWGQUIxj55e/7p9Opjo8yS4s2lnbovV6OSJ/
-CnqEYt6Ur4kdLwVOLKlMKRG3H4q65UXfoVpE+XhFgKADAiMZySSGjBsbjF6ADPnP
-/zNklvYwcM0phtQivmkKEcSOvJNsZodszYhoiwie5OknOo7Mqz9jqQIDAQABoxAw
-DjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBrsLtF6MEMCWQF6YXP
-DLw4friQhYzoB7w1W+fgksOOIyLyRmUEEA9X0FSfNW2a6KLmMtSoNYn3y5cLkmGr
-+JE4U3ovvXDU8C3r09dynuHywcib4oFRaG8NKNqldUryO3abk+kbdxMvxQlA/NHb
-33ABKPX7UTnTr6CexZ5Qr0ss62w0ELwxC3eVugJrVtDOmFt/yZF75lc0OgifK4Nj
-dii7g+sQvzymIgdWLAIbbrc3r/NfymFgmTEMPY/M17QEIdr9YS1qAHmqA6vGvmBz
-v2fCr+xrOQRzq+HO1atOmz8gOdtYJwDfUl2CWgJ2r8iMRsOTE7QgEl/+zpOM3fe+
-JU1b
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/fake-startcom-root-issued-certs/01.pem b/test/fixtures/keys/fake-startcom-root-issued-certs/01.pem
deleted file mode 100644
index 7b9304d7448c1559b9750b6b2d583d977153bd7d..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/fake-startcom-root-issued-certs/01.pem
+++ /dev/null
@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDUDCCAjgCAQEwDQYJKoZIhvcNAQELBQAwfTELMAkGA1UEBhMCSUwxFjAUBgNV
-BAoMDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsMIlNlY3VyZSBEaWdpdGFsIENlcnRp
-ZmljYXRlIFNpZ25pbmcxKTAnBgNVBAMMIFN0YXJ0Q29tIENlcnRpZmljYXRpb24g
-QXV0aG9yaXR5MCAXDTE2MTAyMDIzNTk1OVoYDzIyOTIwODMwMTg0MjIxWjBdMQsw
-CQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMQ8wDQYDVQQKDAZO
-T0RFSlMxDzANBgNVBAsMBmFnZW50ODESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjAN
-BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvCbXGqz553XQ+W9zsQEaBc1/mhd4
-TFjivwbK1hSdTuB8vWyOw6oZuqAJjctcIPmNXf01zV1+cAurpoU8k9SmtetwqaDV
-0K5ooKUuzgAefRoLJqU0XonW4VaK0ICQATkxSWdJzYET68NTukv5f9Fh0Jfi2Q6Y
-PKlgUIuoTPQJSErAMsdph4KWMP7zsaEZNJhmZ1Lprfm4DdVnwUfYvDhq5VmAHFLj
-Vor/z3DJS+pW9oORDta3CMvAY5oGcIYWWMxsoG9B9NtTTs58jjeFpJrw/RYJA/CM
-uRawLWKt/z1zPhzmvknTKfAIc6SjbBqu8Nx/Xvcd61c2V39U/nZDTs+H9QIDAQAB
-MA0GCSqGSIb3DQEBCwUAA4IBAQBfy91+ceZDfZ0DnHHAlm8e+26V5sdrdOXZJtkc
-AacDcCX6AD1iMK+0axBgG6ZJs6m87cmFdaq23pLpBLQ+KHSdG5YgRCEuWW+RaJGj
-/vVn9AS4eB3EmX0RhhJgYyVbN7ye8qjfAv0NtHzUsdMS8ay3HbdUCtrcsHonGDR3
-t/0BGsYny9Kt2f2PNN32UEkx/jhcssXwnNGxyxR/04heJUe6LI5ErdQoxxvaZtrd
-u9ZgjSxix4dFH4nTYEYe3oXM1U7PakbzOzJvRMmDh8vYyK7/ih0w8/DcsK0d1Oej
-mgtTF/IyJqy8T9goFf9U2uSshia+sKJBfrrzRaUHZMx+ZobA
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/fake-startcom-root-issued-certs/02.pem b/test/fixtures/keys/fake-startcom-root-issued-certs/02.pem
deleted file mode 100644
index 7fdada43d59d7aa996d44965c603d252c447cd53..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/fake-startcom-root-issued-certs/02.pem
+++ /dev/null
@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDUjCCAjoCAQIwDQYJKoZIhvcNAQELBQAwfTELMAkGA1UEBhMCSUwxFjAUBgNV
-BAoMDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsMIlNlY3VyZSBEaWdpdGFsIENlcnRp
-ZmljYXRlIFNpZ25pbmcxKTAnBgNVBAMMIFN0YXJ0Q29tIENlcnRpZmljYXRpb24g
-QXV0aG9yaXR5MCIYDzIwMTYxMDIxMDAwMDAxWhgPMjI5MjA4MzAxODQyMjFaMF0x
-CzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDzANBgNVBAoM
-Bk5PREVKUzEPMA0GA1UECwwGYWdlbnQ5MRIwEAYDVQQDDAlsb2NhbGhvc3QwggEi
-MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC2oEMk2EKwIZrx4IPNcGjHw5DO
-u8A8yJrcWG4pThUadrvwMI7bQ4QwNgHm4PVpbjAPbSUsRPX98PWL6GcpoH0lmJ9+
-j9CCEIEkW+j5wM7hYBXUSGuAZZfkdrpbZHsvwpYj2U39sfmUyGT1gBbGBmaAzODh
-ZaqYSm9VdaKS56SRMey3Pbsx+ikylgiEyPFoRKA141Zuxz1MKiwszLHuyz6pCZKY
-K7x1dlEGi3h3dvkRAdMyeSXJkYCZGbS5Fbl2OuW4pSWP4no/M960vBwEYvuJPDtx
-qxGezE51oXp4W4l9k+TYPOfGJDVW0PAg+JpfbepLetgFaO9/eNWes34AhF6FAgMB
-AAEwDQYJKoZIhvcNAQELBQADggEBAD8ojlI4FdXLCyHVYwwTP6BncF4tfeGP82/i
-Zcr8U9k28T2vlsLwdCGu8UVqGWfYrSY5oZqZmHPcDfZmv6Uc39eQ72aweoyLedk3
-UF1Ucwq+MxEM98doLlqL4lnPO1+TcpdhtoHAgT28WkddbR3alfsu+GRU3br3s4lS
-DHcm6UzdA/lkgZtC8wFUSW04WhzSHB78gm8VOl+1JGY0pp/T+ae5swkfj45Q3jOd
-H6jdZiUrU+LJQwLlXYniF4qzmH0SN8Gd3djVNzWJtNF+LFKXzCOYSK8AFaQ6Ta+s
-Pd6Rqa8Hl6cMmlsDu1NLumstvGna5wsc7ks1VZwtWt6WfIyIN2k=
------END CERTIFICATE-----
diff --git a/test/fixtures/keys/fake-startcom-root-key.pem b/test/fixtures/keys/fake-startcom-root-key.pem
deleted file mode 100644
index 748c3c10f7384282f531e61b3b0d89fe9bc2137f..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/fake-startcom-root-key.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEA1mZ/bufFVPGxKagC8W7hpBephIFIZw9KbX6ska2PXZkyqRTo
-U5UFgTYhdBwkCNJMwaYfTqLpc9y/goRpVlLSAFk/t4W6Z0w1b80T149XvmelAUQT
-BJR49kkYspN+Jw627pf8tmmSkG5qcHykB9gr/nvoTpXtlk2tum/SL3BQSqXmqffB
-M/6VpFvGAB2FNWGQUIxj55e/7p9Opjo8yS4s2lnbovV6OSJ/CnqEYt6Ur4kdLwVO
-LKlMKRG3H4q65UXfoVpE+XhFgKADAiMZySSGjBsbjF6ADPnP/zNklvYwcM0phtQi
-vmkKEcSOvJNsZodszYhoiwie5OknOo7Mqz9jqQIDAQABAoIBAAcdibcljAAAsW9/
-evGGS4jFnEOggsWg1UiC/rkq+GoTzoGcBwXXGUKriDqxQGTmjdOTbtCOSY8l0VlE
-ibZqszt9usadco1BEzjtpm3t/Ox9xhUfrD3nq4gI7v/mMzaan2mVs7ZeFJYkg/XN
-vSfhfbxJYnFROnxVgaGBWolmgdOoVE1gB/aRlHO9XTF08Rq1+gQFCUxPDKSEtwFQ
-L/7Bw4NrbnE7W3WAsSmPjd/tH3UfjCcVaRvMyqFNaeLbmt/6uCbaZbIJVgXhPfKS
-Z+ANYWRPi8WSf9bEbj2Xu7hdI/jvFSe44zHvBCnSfjw0RSgoNc5GTT+d37C/Him1
-AyAa3z0CgYEA7C+KsqSJM+0xiwyJlRDzlfW3kf/SdobYCQOkXx17w/RjmZsQNwWr
-EgHO/xqm+5YSrxeQEFbzHjCWLYw7k1bEBjC/tFAV16+1P275RDnOHzRm3xTWN74P
-Q6ECjy6ww9QwyPIdXwKuTp3MFeG4jfTH4glGKGTKC3n5SZ9JZLVu+DMCgYEA6GMU
-+gKBnsPH1wtWbpgezBlEApfPiE8E4sNInh5dwDYBVozr4+Es9eP7CQ0Dh2pSnc3U
-FgbsJ15J9ojkyL0MA9zS/z/rqVjyybeb86My7GGZJ7zTkBMXoH35H8hzDYAe5blQ
-X9N67UJ1dsWb+Vj83mUkw4NzCM958JO3trBAyLMCgYA12yFlWt9uV8fUTSeSNitV
-JpKVWCBFprncVFhG2BJAvJl5jUJFSaWYlZD92rX46F+aTWUsVKdbWvjjqfZrwn0w
-bC1KkHhqlkZeEJAGXqgBtZE/jSDL1Srl4PEUdTEZdmkpaQwJfjMA+jpvQukydX6e
-rD6zN0hbFZUilI/HxxdmwQKBgFyKaGYO7XM936zhFPBBn7IDNbQapEhRv05WGert
-iMPsPagrwhwjJXZd7S/zgL5CNtgkiRqkcxJSV/3XEdRmhAxduaBv4fa0Nyrg9TeW
-e8bqLsVGSrGLCNOelsBzYG214Zf1re4bF064MnKzyqMHLtuZR4ScKgkOJi8JhBU6
-JvJFAoGBAIEmjibErM1/gjh+8MfEZHSuziP0+8bcRSEsKWz1oqqI2gRIzw5ffVOF
-xU5FuiYPrY9OZ4Gtva88M9/JGfwQSc8S6gmIWx/eFFSTW/ys/XYH3j0hCUv08Te9
-lCTRX9ivVNvmUenLWe30V283TgdoQXlHVJnu2xQLxMrJeUuOKGMi
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_cert.pfx b/test/fixtures/keys/rsa_cert.pfx
deleted file mode 100644
index aef85e2e28055d26b05023460cdaca2eaad6355d..0000000000000000000000000000000000000000
Binary files a/test/fixtures/keys/rsa_cert.pfx and /dev/null differ
diff --git a/test/fixtures/keys/rsa_private.pem b/test/fixtures/keys/rsa_private.pem
deleted file mode 100644
index 215e5cc513125113d1faef977ea9857fb15f10f2..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_private.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEpQIBAAKCAQEAt9xYiIonscC3vz/A2ceR7KhZZlDu/5bye53nCVTcKnWd2seY
-6UAdKersX6njr83Dd5OVe1BW/wJvp5EjWTAGYbFswlNmeD44edEGM939B6Lq+/8i
-BkrTi8mGN4YCytivE24YI0D4XZMPfkLSpab2y/Hy4DjQKBq1ThZ0UBnK+9IhX37J
-u/ZoGYSlTIGIhzyaiYBh7wrZBoPczIEu6et/kN2VnnbRUtkYTF97ggcv5h+hDpUQ
-jQW0ZgOMcTc8n+RkGpIt0/iM/bTjI3Tz/gsFdi6hHcpZgbopPL630296iByyigQC
-PJVzdusFrQN5DeC+zT/nGypQkZanLb4ZspSx9QIDAQABAoIBAQCS2erYu8gyoGPi
-3E/zYgQ6ishFAZWzDWSFubwD5wSm4SSAzvViL/RbO6kqS25xR569DmLRiHzD17VI
-mJMsNECUnPrqR2TL256OJZaXrNHh3I1lUwVhEzjeKMsL4/ys+d70XPXoiocVblVs
-moDXEIGEqa48ywPvVE3Fngeuxrsq3/GCVBNiwtt0YjAOZxmKEh31UZdHO+YI+wNF
-/Z8KQCPscN5HGlR0SIQOlqMANz49aKStrevdvjS1UcpabzDEkuK84g3saJhcpAhb
-pGFmAf5GTjkkhE0rE1qDF15dSqrKGfCFtOjUeK17SIEN7E322ChmTReZ1hYGfoSV
-cdFntUINAoGBAPFKL5QeJ6wZu8R/ru11wTG6sQA0Jub2hGccPXpbnPrT+3CACOLI
-JTCLy/xTKW3dqRHj/wZEe+jUw88w7jwGb1BkWr4BI8tDvY9jQLP1jyuLWRfrxXbp
-4Z0oeBBwBeCI/ZG7FIvdDTqWxn1aj3Tmh6s4ByqEdtwrrrJPcBUNl01fAoGBAMMR
-3RGE/ca6X6xz6kgUD6TtHVhiiRJK1jm/u+q0n7i/MBkeDgTZkHYS7lPc0yIdtqaI
-Plz5yzwHnAvuMrv8LSdkjwioig2yQa3tAij8kXxqs7wN5418DMV2s1OJBrPthYPs
-bv4im2iI8V63JQS4ZMYQbckq8ABYccTpOnxXDy0rAoGBAKkvzHa+QjERhjB9GyoT
-1FhLQIsVBmYSWrp1+cGO9V6HPxoeHJzvm+wTSf/uS/FmaINL6+j4Ii4a6gWgmJts
-I6cqBtqNsAx5vjQJczf8KdxthBYa0sXTrsfktXNJKUXMqIgDtp9vazQ2vozs8AQX
-FPAAhD3SzgkJdCBBRSTt97ZfAoGAWAziKpxLKL7LnL4dzDcx8JIPIuwnTxh0plCD
-dCffyLaT8WJ9lXbXHFTjOvt8WfPrlDP/Ylxmfkw5BbGZOP1VLGjZn2DkH9aMiwNm
-bDXFPdG0G3hzQovx/9fajiRV4DWghLHeT9wzJfZabRRiI0VQR472300AVEeX4vgb
-rDBn600CgYEAk7czBCT9rHn/PNwCa17hlTy88C4vXkwbz83Oa+aX5L4e5gw5lhcR
-2ZuZHLb2r6oMt9rlD7EIDItSs+u21LOXWPTAlazdnpYUyw/CzogM/PN+qNwMRXn5
-uXFFhmlP2mVg2EdELTahXch8kWqHaCSX53yvqCtRKu/j76V31TfQZGM=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_private_1024.pem b/test/fixtures/keys/rsa_private_1024.pem
deleted file mode 100644
index a8a4830890cd9f026bc0adbab36ded92896cc910..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_private_1024.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXQIBAAKBgQDRMGk0Tp+sGoU4FbTF76l7g3uOdSpqLBnP4UDKSdhv3p+lfr6F
-piJh8KnXIPKMq5b4EX+X4Ghz7PKDMEs24ihiqwUMl89exvFtW2bXwqq0XpMqdF6R
-CxbbBYy3DFPTCTvoHaoAfmwHzwBfelHt2PaYl4ZNxhpD4UcP3/lrUB5KhwIDAQAB
-AoGAYK4gIUWpNDB5m4ckqkpuqSAGbbum47UIJPR1Lkjc2C8q16DxSvGSeHNy+3NF
-xk/TkUj9EGNtww4isxER4ga6JLH5WNkF3k92ET2wSn6G9/CtPZRe6wRP593ZO5vd
-KXLCXRNprlRVHQbE6VysIQToZKVH2sqoFhIH62RDdhXvQNECQQDq8PQsLd1szeKf
-iaJSlPxfuPG9yEZO7YY3QygpTmzRjLfN5560SejEvctMiO4hlwnWNbQzGbgQfhfA
-JbgK6Z0fAkEA4/CKKcR8JJe/8vukfTLDlgnp3DPMa1HOVFnKWF6QeCPk5aOehDcf
-CFm4E+A6NAbtG0oor6e4Bsr4ASOpLxE9mQJBAK4oAYiCU0JleFm1CAvZfx9iFGkP
-ffbiIfzzHmFITmgjvNi4mq+gnhjBbGOGmadytAsDclny9bvcDLUWANCuDhcCQCNE
-aFwmBn8y64QQ41ZrsE9aoVBsw0gnlCEA84nQt9Ge3B+bvT7/uFF2cEDDBL5gA/eg
-9cKX1KVYah7jAZ5CsKECQQCJFqYwEewb3G7aKjtAzVCsNfQSC64xT2EnMg47va9t
-GK5DXshigVNpMHJ52N4QxWIRtUs5LOCeGaZP/vTkTQ+z
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_private_2048.pem b/test/fixtures/keys/rsa_private_2048.pem
deleted file mode 100644
index 0e5bde2e02c55d4dd1aa4e07c728e5fc5a393a6d..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_private_2048.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEogIBAAKCAQEArk4OqxBqU5/k0FoUDU7CpZpjz6YJEXUpyqeJmFRVZPMUv/Rc
-7U4seLY+Qp6k26T/wlQ2WJWuyY+VJcbQNWLvjJWks5HWknwDuVs6sjuTM8CfHWn1
-960JkK5Ec2TjRhCQ1KJy+uc3GJLtWb4rWVgTbbaaC5fiR1/GeuJ8JH1Q50lB3mDs
-NGIk1U5jhNaYY82hYvlbErf6Ft5njHK0BOM5OTvQ6BBv7c363WNG7tYlNw1J40du
-p9OQPo5JmXN/h+sRbdgG8iUxrkRibuGv7loh52QQgq2snznuRMdKidRfUZjCDGgw
-bgK23Q7n8VZ9Y10j8PIvPTLJ83PX4lOEA37JlwIDAQABAoIBACoL2Ev5lLyBaI+9
-+vJO2nNaL9OKSMu2SJODIJTnWwYUASBg0P3Jir6/r3sgi8IUJkH5UHbD/LrQcPkA
-4X7PU9vEyUsr1efWFIvk7t7JsjOctoVA5z2Mty74arivUIe5PUadvUC6/7Zk0u6A
-CjLuJRmlH7nGNKZk+xrvgWTH+fkgc5ddbFxoGH129RcVC+ePbsi1EF60C9KbJvp1
-xjUJ5cDtNYnZ/g+ULo6ZJjRG5kUCVSI8H/Nc/DmStKsjN0isKpNGofU5ArEwywGC
-Cqxz/tr4hT2haAkVEto04ooYpqDUSqGEfPpLWL+CjFNPfCsWJ1tX5LQRvpu6eukd
-FO72oVECgYEA4+Ot7RQtGOtPeaxl3P7sbEzBZk0W/ZhCk+mzE2iYh0QXU44VtjtO
-/9CENajTklckiwlxjqBZ5NO1SiMQKBcmqkoA03x/DEujo2rMVuNPoc6ZYp1Gc4qA
-4ImkMQNsM7Swum42rKE960WoiWW7dsdEAq6vqgeApZlMU8lcKRAlOZkCgYEAw85H
-3bjF7gMatVibsWzj0zp2L4616m2v5Z3YkgohGRAvm1912DI5ku5Nmy9am57Z1EP2
-UtDOxahd/Vf6mK9lR4YEbNW1TenykViQJ6lmljOFUeZEZYYO3O+fthkyN/42l5yn
-MyUANTTb2rvt8amdRr0ARdRqWJmt5NfJzYBV+q8CgYB1ZjuZoQVCiybcRcYMPX/K
-oxgW/avUZPYXgRNx8jZxqNBjiRUCVjdybhdOFXU5NI9s2SaZFV56Fd6VHM8b+CFB
-JPKcAMzqpqTccQ5nzJ6fevFl7iP3LekKw53EakD5uiI5SMH92OsvIymZ7sDOhgUx
-ZJC2hTrvFLRPjbJerSSgMQKBgAv5iZuduT0dI30DtkHbjvNUF/ZAnA+CNcetJ5mG
-1Q9bVg4CgIqAR9UcjdJ3yurJhDjfDylxa7Pa4CSmRMUhtOfy4kJlr3jcXeFVsTs7
-uPJmpDimBHjRAgew/+t7Dv8tpNkQ04jlMmYOnYN7CspEvUGePW4H15kjjOb563WN
-67QxAoGAdhJPaHVtDBUrobn50ORVkVNJVZPBhEDbR6tNtHsgEevH7iYjxAdxEeUa
-c9S2iV9lir3hkrQceiYWAADcphWfO1HyP5Uld4sJzYiEGbSM7a0zRQjYlQgXFbZo
-SAc6Gok78kwECPwpmeH4lpGVeKNmzEteSBVYxGb9b6C/SSsu7l0=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_private_4096.pem b/test/fixtures/keys/rsa_private_4096.pem
deleted file mode 100644
index 4177b9ef956a376c7faf816fb6b65d24b914702e..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_private_4096.pem
+++ /dev/null
@@ -1,51 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIJKAIBAAKCAgEAxeStwofbjtZuol4lwKn1w08AzcSNLHfCqNFHa+W7er8is7LQ
-sPljtPT4yn4lsao83ngHFvSC3tbMiRNDpUHYqH2wBuUkuOmCtYkZLi0307H0CwcV
-V6W5P3tNEt80IJ+PqlRxtTknezUtbOasbIi/aornVWG+psgqDGrFZ4oTsWtiE0Sv
-i7sDqN5E2dijmH/YYnlnwqszgzHdtAnARp1bG34E64sqWCmLoGCfPdHtym/CSdxO
-LOsDV15jrwODZQ/TJZ5thkwKZRxu7g9fwlhA1PiI5WDP4reXNaqa2bSgrzpAljQE
-xYs4N0L7okSVOJQX9BEaoWtq8NLU8MpMdGoHNDU0Xr60Lfr58Z5qn8RGEvlTxoCb
-PJzPV2zgzD/lmEqft6NnfTclveA3sd8xSrOBUn4o3S8hS0b9Su7PBukHjM96/e0R
-eoIshSwXlQTLr2Ft8KwupyPm1ltNcTDtjqHcIWU6Bg+kPy9mxSVtGGZYAPtqGzNB
-A/m+oOja/OSPxAblPdln691DaDuZs5nuZCGwGcLaJWgiyoqvXAcyXDZFyH4OZZh8
-rsBLKbnFXHZ/ziG0cAozEygZEPJappw8Lx/ady7WL/SJjxooiKapc7Bnfy8eSLV3
-+XAKxhLW/MQ6ChJ+e/8ExAY02ca4MpCvqwIk9TfV6FM8pWGqHzQFj0v3NL0CAwEA
-AQKCAgBTb8eTbZS09NRQwUFJql9kqbq9B1I+nYAFjbd/Vq1lY5FOEubKt1vCwEbl
-mapq7kwbwJ+8nftP2WEDqouq8chXwialwZdqH4ps4BEt1wLizvUGcUYeXlFs4p/s
-hQ+FccExH8mRjzeGSzWL5PZuDHoogchnx36K83pHIf15Wk5TT+NaHGunjoJMgOqm
-ryDK+5xQaL/G5Egj2LKRZksbet0fClMovNRtt5aXWCXL+uc3o0dXvPt5FN2jyLhe
-4ixUQAfWpKWpKgZ3+zUKSpElb/Bl2yRdEiSUgrPOfNAtWmsldnok2mnooHpjUmqm
-UCRaZpZy4YNI6/F6+Gmv3Ju/ubSvHzoxQLlvgUqWAnVshivF1TJImHSIiLIvBKPp
-29SD6maWIT1DC9sKC4E1gq7VO4762l1//zEOAY7XK0Z7LrbZO4WXHnsgFOpGthQ3
-g9Qi/SeM6mb5xEJTBUBTmkhGs1x8jolzca30mqv8T63W4PXkXHmZdK7vyH5useiI
-s0eGUeaYK892WgfxCBo24JCNQiAcH/wTwV4l4yROqeH2V4ShbIYmCzla++7vsPYW
-hAwQR9eH0+4ogTkaMQrm16plZk0ezVX9BKK8KTnd4G9/T18VstQbiowF2/cKnGKC
-OqrmoR2vHOksQdUJVmnwCRqU1symBxhY0GSIps98v+lUYExKQQKCAQEA/uVYE2/H
-eNcV/uWAI9LspANXHJE33TFMZ8SuyOYtp3MYJizmQ1uT7Om2LEanDnNiz+fAQhrE
-vo1sDIF9xOAde2qjIH+iDzcLvFPgC3gkQspFjU31M9OO5xAjzBxfL3KDiG2MtmTR
-hNuKJX56eCOqkEp6WKaWOA35ccaKYHxNzMS49weCv95ZPpR9q0J1sgzD7HtVh4yu
-XI01/BC8F0RmYjtsuUo+PmB6sO2K94uqqo0GPUos7Mhgrbff3L36EkOPgmRiA1AV
-Zy1sKKxUKspGQ3m1fg+CA/+GZGckvYkVot1lFrwmrS2dok8EhT1HcVJde+++jx7z
-JsRLgFRvKHXklwKCAQEAxsAfxIQjjjKmuyJCzIvxG7lnuzovdy4OEdSuJL4yK5m3
-4BHJHn+yHeRIcrDnJKUTUYffcH/OjOnJS94BA6wH1tEuvGQz6LV6UpwApZ1M/2md
-nP0eC2L2JtSRL8mdxfyqXDloWMpD7rncBZ6ChLEZ6sWYa6WBQTARmPVePyUpNNG2
-qymxN3/vRBGGBunD3j6zX0M0szWK5iU+qsYDy3KzCKG8FU7XxwzRbP7iARRD5Hpt
-Zmy2W52EJg1uhmlVXJMm32SEBfrD2oDmlnjAqaZdqi5Mq2e4uB3dhM9RwJppSALG
-BY6k9DeanAFbOlawMJri2pk7B0phCn+DN2pg0+W3ywKCAQBeTwzfZCQxmaMRxGg8
-2PWlWXcJotFAjdTvL95bho6tve/ZcBNiKKf6qB43E40L07VjpyODUdQpjLnFhsO5
-7BH8b+AbTh3v8zXsYDwtAi6oZ56EQavPmR7ubxJPms+9BmmUOLQvZ+39ch0S8lDt
-0oRxDp1l330FEGaSqhrYyCUg9khZXfYKd4IdnWNB0j0pu39iJ9/lXy/EHpsywB5X
-nX8kKUh45fdRrPC4NauNG6fxomwEkUU99oWOwNGbIs87orOeUvXQs/i3TB8QjXI2
-wtBsdsOn+KTqRci7rU3ysp3GvJOCbesBeDcyrnnFsn6Udx0Plgyzd4gPd+FXgeX+
-2l/RAoIBAH81FKAY2xD2RlTb1tlIcGeIQWZKFXs4VPUApP0LZt0VI+UcPRdyL7SG
-GgCeTTLdHQI/7rj4dGEoeRg/3XJWNyY8+KbHk5nMHaCmDJvzlAaduK10LDipfFba
-Epr9dif0Ua15aNn7i4NOHg7Sp0L6f1YOZkHvykzI0VqPIWVVCYyu9TWUF8Mn9SIh
-/SCLmjuy8ed1AlP5Xw9yoyt2VZNvtDtAGTuiHOVfxOL4N/rs149y9HZr+kOlC6G3
-Uxhgbqwz2tt8YCvblmNRwURpwRZUTvrPa28Bke713oRUlUSrD9txOwDvjZBpzmEv
-VQ5/0YEqgSvcizVdW8L2XiunwJWfIAUCggEBALr4RF9TYa37CImZOs+vJ8FGRKMz
-h1EUwO2PvuITvkTtu/7E4IjyxAo5dkAokkWQCGABciiDJJEYUWqcUX45qQChOgtm
-NU2od6f9tgyDFxN5KS8cE32NXV3rJXs3bBZmIKLSPETf3uIPuEpFPjpdR5v5jlV+
-TDjH4RrItE3hDCvypTXhXXMmWp3VfYbgEfIP03uR2iIhL+/g3BUqbrywPEsTViSN
-NM/uBDQyamXLXB1bQ2I/Ob41I82PD1iNCqGi7ZvZ3eVYGgUTQyw6Q4O8glTPP9cC
-SFVXwE9gHbLe8TqfTZCWrM6crGX6Bb6hV2tqNsA+7J69U9NGuw5GNqXjafU=
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_private_b.pem b/test/fixtures/keys/rsa_private_b.pem
deleted file mode 100644
index 96d82ae2e24a3c120ca7236ec579a61a2837a826..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_private_b.pem
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEAyb1grrN+29fxeeEbTaSEja6TKDTpT/WXnqrFCS+h7IYcnDoA
-VwcsPU5FZeUPvLKMzi9NHSJ34LQCurqHgH8X+cw0YT3gdYS/7qoQiXs+zKv615Nc
-ttD3xlQLceY+NwznoPXyyZwOeZqyU5Hiqbrqu6hdr6gQYogMNLn2NxBW2pGegd6+
-ZGMCX3+/BtMP/6tXmttYjY+yhN2SrGz5cKhWpcHiC6X+B7uCKoKZy+t2jUxYVKUw
-Wr1ZuM8kpSnuVCcv1OoMGEimEHA7v/eaF/y+z/VdQ4Y88GhTnVN4KbtgZ+o9Pohj
-xLFU62VeTALixU5mPQKSgSICKfjev0FUUurF6wIDAQABAoIBAQCs11C/PM/iYNfl
-mSSAWAStMrWni/Wc6QhXC2422ZV8hMZ8XwEtjtqrR6UTkLXz8HHMsR/7Zy2X2gJA
-o1E2mS0ceoUiDxaA+RRL0W7Lq0j5qBsImZukkdLHG/iWRDJnjenhsParHsYUD6Lb
-ELFGw/safjyOI4quMGtsvSqisKAJL5ZCPD5JHLhnNP8HXT6icSZrsqGhunb2tsa+
-Ogcx1+bZzqdTsbvXdbw07Lnd/LRU0NDhjeEVl4J2yFNYY+OIj7/qrxSnZnGLLG0Y
-DFxiD+HCMvTBSooqvWI6FAipfyCGjUznGsVaRv7TuzHPuKE4LtbIC/Ac3Q10rKWq
-PmHALir5AoGBAOhGUCToWfYnj2zH0GIZQxnkrv9iRqmdGeCDX6ZM00Bs5tASnRo0
-o90UtLbhWjHe1PKRKFyD4I7a8iIWxcWWun2XHgOtItctPN+lbjpTHTyE2yA1iZhe
-dKCV3bAo4t+puKrPkZmaBqFD/fQx7DNxYdRERa1giiZGhlMUN3l7/S21AoGBAN5Y
-nZ68NkTgklk4YBzsxwsMpQbgbihyG79gtDFxWonxZUQ29EsL01yd30pJNhg1LxDN
-0fADfHVzkZ3qYz9knge9a75Yk8UBM3DM+xu+DRkjKhK5mPX5oLvj6061u3Scs6tj
-orpU/mV1amz5gqrkefMaelsdHRuGGZQVx9KTV2kfAoGBAN7EAL1E8nK4Qj/r6xkK
-bWZ6ArQABxFJELZYiPWvnLOfPka0c2PctIOmBiOXQa+urMDvIqyH9mhL6Al1mbwE
-8VreAfU4qb+BLW649FyPteyC5r2fWxV9EZGp6fG3ZM9psShw5o1QQaeM1BTNhGFa
-Dp9L0x+TBSvsW4t2SjYDCjA5AoGASzxxGWVWd7gFzWrmGuOD9pkwvkLzA3yZJwjx
-8EkK+eJVAeAWic5WluBUzi43v7k/U9BRWYXUd2nDvEuziZ/iWXwfGSmf1umxHlo+
-HgURKZBcjDmBKLpvSSS2WsvjwnHD2hq81ZAtBOfWO0myjWECYuByxqHzV3zo6tLz
-6q0wxsECgYA26twPrAoRqvfvPnNj6o0LrsE39Tj6jHIVijT7Lbcf2xVnaDiQ18PQ
-RC6Tgkz5KZf8GKfMRMA3WopGn9QE2luI4RLIbhLozEDrkk2L7wSYqI9DZ1Hd26wf
-v3+3jdpsXkzHwWYz1a2+FhCF5mJJRQl6kd/B0wu00vdfwviK9OVO7w==
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_private_encrypted.pem b/test/fixtures/keys/rsa_private_encrypted.pem
deleted file mode 100644
index f1914289ec4f7f12c1bc130a66ca057fc1322de9..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_private_encrypted.pem
+++ /dev/null
@@ -1,30 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: AES-256-CBC,DB3D20E60E8FDC3356BD79712FF8EF7E
-
-K+vu0U3IFTJBBi6zW5Zng80O1jXq/ZmlOFs/j/SQpPwfW1Do9i/Dwa7ntBlTwrCm
-sd3IIPgu2ikfLwxvbxsZN540oCaCqaZ/bmmyzH3MyVDA9MllUu+X8+Q3ATzcYa9R
-U5XfF5DAXsSRnstCbmKagWVQpO0oX8k3ratfny6Ixq86Y82tK8+o5YiBFq1kqa+9
-4yat7IWQbqV5ifUtUPCHZwEqBt+WKazX05BqERjkckHdpfaDrBvSSPXTwoLm6uRR
-ktkUVpO4tHMZ4VlcTfFtpz8gdYYod0nM6vz26hvbESHSwztSgMhmKdsE5eqmYfgu
-F4WkEN4bqAiPjKK3jnUKPt/vg2oKYFQlVYFl9QnBjiRqcQTi3e9lwn1hI7uoMb6g
-HuaCc57JJHPN/ZLP3ts4ZxFbwUjTGioh5Zh6WozG3L3+Ujwq/sDrAskRyzdcuP7I
-Rs3oLbHY03OHyg8IbxR5Iu89l6FLqnR45yvbxXtZ7ImGOPM5Z9pB1CzDhGDx2F6g
-J/Kf/7ZF2DmYUVbVKDfESEDhRfuMAVzhasDPTRqipSA5QvJVQY+J/6QDPrNNmHVB
-4e4ouHIDWERUf0t1Be7THvP3X8OJozj2HApzqa5ZCaJDo8eaL8TCD5uH75ID5URJ
-VscGHaUXT8/sxfHi1x8BibW5W5J/akFsnrnJU/1BZgGznIxjf5tKfHGppSIVdlKP
-3ghYNmEIFPNJ6cxuUA0D2IOV4uO3FTCU6seIzvJhYkmXnticcZYGtmGxXKrodtzS
-J1YuaNkkO/YRZah285lQ6QCIhCFo4Oa4ILjgoTQISuw7nQj5ESyncauzLUBXKX0c
-XDUej64KNTvVF9UXdG48fYvNmSZWCnTye4UmPu17FmwpVra38U+EdoLyWyMIAI5t
-rP6Hhgc9BxOo41Im9QpTcAPfKAknP8Rbm3ACJG5T9FKq/c29d1E//eFR6SL51e/a
-yWdCgJN/FJOAX60+erPwoVoRFEttAeDPkklgFGdc8F4LIYAig9gEZ92ykFFz3fWz
-jIcUVLrL+IokFbPVUBoMihqVyMQsWH+5Qq9wjxf6EDIf0BVtm9U4BJoOkPStFIfF
-Kof7OVv7izyL8R/GIil9VQs9ftwkIUPeXx2Hw0bE3HJ3C8K4+mbLg3tKhGnBDU5Z
-Xm5mLHoCRBa3ZRFWZtigX7POszdLAzftYo8o65Be4OtPS+tQAORk9gHsXATv7dDB
-OGw61x5KA55LHVHhWaRvu3J8E7nhxw0q/HskyZhDC+Y+Xs6vmQSb4nO4ET4NYX1P
-m3PMdgGoqRDJ2jZw4eoQdRKCM0EHSepSAYpO1tcAXhPZS4ITogoRgPpVgOebEQUL
-nKNeNu/BxMSH/IH15jjDLF3TiEoguF9xdTaCxIBzE1SFpVO0u9m9vXpWdPThVgsb
-VcEI487p7v9iImP3BYPT8ZYvytC26EH0hyOrwhahTvTb4vXghkLIyvPUg1lZHc6e
-aPHb2AzYAHLnp/ehDQGKWrCOJ1JE2vBv8ZkLa+XZo7YASXBRZitPOMlvykEyzxmR
-QAmNhKGvFmeM2mmHAp0aC03rgF3lxNsXQ1CyfEdq3UV9ReSnttq8gtrJfCwxV+wY
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_private_pkcs8.pem b/test/fixtures/keys/rsa_private_pkcs8.pem
deleted file mode 100644
index cd274ae6d9071d025cd9a05b86b55b7d5b299baa..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_private_pkcs8.pem
+++ /dev/null
@@ -1,28 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC33FiIiiexwLe/
-P8DZx5HsqFlmUO7/lvJ7necJVNwqdZ3ax5jpQB0p6uxfqeOvzcN3k5V7UFb/Am+n
-kSNZMAZhsWzCU2Z4Pjh50QYz3f0Hour7/yIGStOLyYY3hgLK2K8TbhgjQPhdkw9+
-QtKlpvbL8fLgONAoGrVOFnRQGcr70iFffsm79mgZhKVMgYiHPJqJgGHvCtkGg9zM
-gS7p63+Q3ZWedtFS2RhMX3uCBy/mH6EOlRCNBbRmA4xxNzyf5GQaki3T+Iz9tOMj
-dPP+CwV2LqEdylmBuik8vrfTb3qIHLKKBAI8lXN26wWtA3kN4L7NP+cbKlCRlqct
-vhmylLH1AgMBAAECggEBAJLZ6ti7yDKgY+LcT/NiBDqKyEUBlbMNZIW5vAPnBKbh
-JIDO9WIv9Fs7qSpLbnFHnr0OYtGIfMPXtUiYkyw0QJSc+upHZMvbno4llpes0eHc
-jWVTBWETON4oywvj/Kz53vRc9eiKhxVuVWyagNcQgYSprjzLA+9UTcWeB67Guyrf
-8YJUE2LC23RiMA5nGYoSHfVRl0c75gj7A0X9nwpAI+xw3kcaVHRIhA6WowA3Pj1o
-pK2t692+NLVRylpvMMSS4rziDexomFykCFukYWYB/kZOOSSETSsTWoMXXl1KqsoZ
-8IW06NR4rXtIgQ3sTfbYKGZNF5nWFgZ+hJVx0We1Qg0CgYEA8UovlB4nrBm7xH+u
-7XXBMbqxADQm5vaEZxw9eluc+tP7cIAI4sglMIvL/FMpbd2pEeP/BkR76NTDzzDu
-PAZvUGRavgEjy0O9j2NAs/WPK4tZF+vFdunhnSh4EHAF4Ij9kbsUi90NOpbGfVqP
-dOaHqzgHKoR23Cuusk9wFQ2XTV8CgYEAwxHdEYT9xrpfrHPqSBQPpO0dWGKJEkrW
-Ob+76rSfuL8wGR4OBNmQdhLuU9zTIh22pog+XPnLPAecC+4yu/wtJ2SPCKiKDbJB
-re0CKPyRfGqzvA3njXwMxXazU4kGs+2Fg+xu/iKbaIjxXrclBLhkxhBtySrwAFhx
-xOk6fFcPLSsCgYEAqS/Mdr5CMRGGMH0bKhPUWEtAixUGZhJaunX5wY71Xoc/Gh4c
-nO+b7BNJ/+5L8WZog0vr6PgiLhrqBaCYm2wjpyoG2o2wDHm+NAlzN/wp3G2EFhrS
-xdOux+S1c0kpRcyoiAO2n29rNDa+jOzwBBcU8ACEPdLOCQl0IEFFJO33tl8CgYBY
-DOIqnEsovsucvh3MNzHwkg8i7CdPGHSmUIN0J9/ItpPxYn2VdtccVOM6+3xZ8+uU
-M/9iXGZ+TDkFsZk4/VUsaNmfYOQf1oyLA2ZsNcU90bQbeHNCi/H/19qOJFXgNaCE
-sd5P3DMl9lptFGIjRVBHjvbfTQBUR5fi+BusMGfrTQKBgQCTtzMEJP2sef883AJr
-XuGVPLzwLi9eTBvPzc5r5pfkvh7mDDmWFxHZm5kctvavqgy32uUPsQgMi1Kz67bU
-s5dY9MCVrN2elhTLD8LOiAz8836o3AxFefm5cUWGaU/aZWDYR0QtNqFdyHyRaodo
-JJfnfK+oK1Eq7+PvpXfVN9BkYw==
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_private_pkcs8_bad.pem b/test/fixtures/keys/rsa_private_pkcs8_bad.pem
deleted file mode 100644
index ca36972e3a6503bc4a6e882c63ea84024c0f6549..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_private_pkcs8_bad.pem
+++ /dev/null
@@ -1,28 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC33FiIiiexwLe/
-P8DZx5HsqFlmUO7/lvJ7necJVNwqdZ3ax5jpQB0p6uxfqeOvzcN3k5V7UFb/Am+n
-kSNZMAZhsWzCU2Z4Pjh50QYz3f0Hour7/yIGStOLyYY3hgLK2K8TbhgjQPhdkw9+
-QtKlpvbL8fLgONAoGrVOFnRQGcr70iFffsm79mgZhKVMgYiHPJqJgGHvCtkGg9zM
-gS7p63+Q3ZWedtFS2RhMX3uCBy/mH6EOlRCNBbRmA4xxNzyf5GQaki3T+Iz9tOMj
-dPP+CwV2LqEdylmBuik8vrfTb3qIHLKKBAI8lXN26wWtA3kN4L7NP+cbKlCRlqct
-vhmylLH1AgMBAAECggEBAJLZ6ti7yDKgY+LcT/NiBDqKyEUBlbMNZIW5vAPnBKbh
-JIDO9WIv9Fs7qSpLbnFHnr0OYtGIfMPXtUiYkyw0QJSc+upHZMvbno4llpes0eHc
-jWVTBWETON4oywvj/Kz53vRc9eiKhxVuVWyagNcQgYSprjzLA+9UTcWeB67Guyrf
-8YJUE2LC23RiMA5nGYoSHfVRl0c75gj7A0X9nwpAI+xw3kcaVHRIhA6WowA3Pj1o
-pK2t692+NLVRylpvMMSS4rziDexomFykCFukYWYB/kZOOSSETSsTWoMXXl1KqsoZ
-8IW06NR4rXtIgQ3sTfbYKGZNF5nWFgZ+hJVx0We1Qg0CgYEA8UovlB4nrBm7xH+u
-7XXBMbqxADQm5vaEZxw9eluc+tP7cIAI4sglMIvL/FMpbd2pEeP/BkR76NTDzzDu
-PAZvUGRavgEjy0O9j2NAs/WPK4tZF+vFdunhnSh4EHAF4Ij9kbsUi90NOpbGfVqP
-dOaHqzgHKoR23Cuusk9wFQ2XTV8CgYEAwxHdEYT9xrpfrHPqSBQPpO0dWGKJEkrW
-Ob+76rSfuL8wGR4OBNmQdhLuU9zTIh22pog+XPnLPAecC+4yu/wtJ2SPCKiKDbJB
-re0CKPyRfGqzvA3njXwMxXazU4kGs+2Fg+xu/iKbaIjxXrclBLhkxhBtySrwAFhx
-xOk6fFcPLSsCgYEAqS/Mdr5CMRGGMH0bKhPUWEtAixUGZhJaunX5wY71Xoc/Gh4c
-nO+b7BNJ/+5L8WZog0vr6PgiLhrqBaCYm2wjpyoG2o2wDHm+NAlzN/wp3G2EFhrS
-xdOux+S1c0kpRcyoiAO2n29rNDa+jOzwBBcU8ACEPdLOCQl0IEFFJO33tl8CgYBY
-DOIqnEsovsucvh3MNzHwkg8i7CdPGHSmUIN0J9/ItpPxYn2VdtccVOM6+3xZ8+uU
-M/9iXGZ+TDkFsZk4/VUsaNmfYOQf1oyLA2ZsNcU90bQbeHNCi/H/19qOJFXgNaCE
-sd5P3DMl9lptFGIjRVBHjvbfTQBUR5fi+BusMGfrTQKBgQCTtzMEJP2sef883AJr
-XuGVPLzwLi9eTBvPzc5r5pfkvh7mDDmWFxHZm5kctvavqgy32uUPsQgMi1Kz67bU
-s5dY9MCVrN2elhTLD8LOiAz8836o3AxFefm5cUWGaU/aZWDYR0QtNqFdyHyRaodo
-JJfnfK+oK1Eq7+PvpXfVN9BkYw==
------END RSA PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_pss_private_2048.pem b/test/fixtures/keys/rsa_pss_private_2048.pem
deleted file mode 100644
index ffca137a71219fb6a801c7a905f6607672acb168..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_pss_private_2048.pem
+++ /dev/null
@@ -1,28 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvAIBADALBgkqhkiG9w0BAQoEggSoMIIEpAIBAAKCAQEAy4OMdS84PlgI5CRL
-bdbud9Ru7vprFr2YNNUmdT7D3YgApiv8CjzKXLiVDnbMET+lwmtag/EcZsxVCKov
-su30pYASBriHOiMVYui9+ZaJoQ9yI6lOjG1RbuUBJXNSjHBJxqBqmcgZOb1mdRr/
-eXzpAMWJ3hfuLojU2+zUSJ3/rvepepcLFG2q9nA0+PJskJ7Pnh3L0ydnv3U3hduM
-n5OVfm/Jx1FPyZpD184tJff+N+MY3s3hIcfuOnL9Pl4RPGeaTC4T1o460NaG6bG7
-c2Whg6NOaVgaFIaiNbrTTNCpVjeTyalsTXYlQQ3hiKjst0Q7pfFEkJDo8qiqLad1
-Msl59wIDAQABAoIBAQC6G8aqs0/f02nuGDLSc6cH9kCsUlz0ItW6GuJcfdVoFSNi
-0v5d7lGwkSveWk0ryOSw8rOHzUqHx3xLvDZ6jpkXcBMMClu/kq3QEb8JK90YaKOc
-cQvf52h83Pc7ZEatH1KYTcKudwp6fvXfSZ0vYEdD6WG2tHOgIollxSIsdjCHs1qi
-7baNHdK9T4DveuEZNcZ+LraZ1haHmFeqIPcy+KvpGuTaLCg5FPhH2jsIkw9apr7i
-iFLi+IJ7S5Bn/8XShmJWk4hPyx0jtIkC5r2iJnHf4x+XYWZfdo7oew3Dg6Pa7T6r
-I164Nnaw0u0LvO4gQdvYaJ/j9A602nHTp7Tsq8chAoGBAOtVHgIqpmdzwR5KjotW
-LuGXDdO9X6Xfge9ca2MlWH1jOj+zqEV7JtrjnZAzzOgP2kgqzpIR71Njs8wkaxTJ
-Tle0Ke6R/ghU9YOQgRByKjqJfQXHZnYFPsMg0diNYLroJ4SG8LO4+2SygTYZ4eKL
-qU0bda3QvQ7FL+rTNQBy01b9AoGBAN1jEQI80JxCT7AMvXE6nObIhbkASHte4yOE
-1CBwcOuBEGcuvMOvQVMzKITgea6+kgsu4ids4dM5PTPapQgpKqIIQ2/eSesaf56g
-73clGGSTPHJP0v+EfKg4+GYJf8o2swT0xDHkgWLgjjdsncB9hATc2j6DvHeau18d
-pgCLz9kDAoGAXl/SGvhTp2UqayVnKMW1I07agrGNLA4II5+iiS4u4InskCNSNhr/
-KATj6TJ82AuTdCGGmdmLapuvPQzVzI42VsGvlzcA8wJvOwW2XIwMF1GPy8N9eZL8
-6m+89+Uqh4oWXvVmjgx+9JEJdFLI3Xs4t+1tMfll+AhoAPoWZUmnK1kCgYAvEBxR
-iXQfg8lE97BeHcO1G/OxfGnsMCPBLT+bFcwrhGhkRv9B6kPM2BdJCB9WEpUhY3oY
-P4FSUdy85UIoFfhGMdOEOJEmNZ/jrPq7LVueJd63vlhwkU2exV2o82QDLNWpvA7p
-PFZ1Gp+hEKoIfaZPElQi7gZmtrIWaksb2pz42QKBgQCct9NP2qJfqeS4206RDnfv
-M238/O2lNhLWdSwY0g+tcN+I1sGs3+4vvrm95cxwAmXZyIM11wjdMcAPNxibodY7
-vufsebPHDBA0j0yuTjGkXefUKd1GdO88i5fppzxB7prDX9//DsWWrFhIMMRNYe0Q
-aeHd/NPuHcjZKcnaVBgukQ==
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_pss_private_2048_sha256_sha256_16.pem b/test/fixtures/keys/rsa_pss_private_2048_sha256_sha256_16.pem
deleted file mode 100644
index ea4597015401d52dcfdf23c73ee9403b1a0dbbaf..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_pss_private_2048_sha256_sha256_16.pem
+++ /dev/null
@@ -1,29 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIE7wIBADA9BgkqhkiG9w0BAQowMKANMAsGCWCGSAFlAwQCAaEaMBgGCSqGSIb3
-DQEBCDALBglghkgBZQMEAgGiAwIBEASCBKkwggSlAgEAAoIBAQDfqNM4C+QtD73i
-ILqOkqfV8ha3O19jpX8UujIk1Z72bbbuwEzh0+sBw0dD0N8CgkXnePOEEd6q7HNm
-byCNqRpDK6NDvaCMDWgEaD/PlHkRntvKh81IXSMC5imjRfOcZIE/Gnw7h8tanab0
-n75+ODvLJrmEWUG2q79Im1mWMx7Spod+Np6XEY+7I7nAUUWivr35Yx5DeyxY8rxF
-GpsLtGsi7JNQO4aHyeBpj8tz0Fhv23uPywE2nGmPHfnkXWbrTcHGbzYBgEbeSH9K
-UkRwczqDXNOPhtfaEHEFTm0MoeKCnJe1VOjSywev77dV1KZfpVh3Kh0ZRQIe9YOV
-Jhj4lMx3AgMBAAECggEBAIc+IgK5Bg/NfgeXvNdrjPuM+PlxeHvb3h1dfebSGd5v
-d3elZpgDug6F07kJO2Db/4M5mx7YY2m9swZU2j1u7MeDQqU6rDMkBCruEu/lmtPx
-2Hv+ZD6Gux4MqU7mhKmkCJds34Rr16aCwCsZ0WmnfViZoQKLqnXYIsG31pNBdDjx
-gke0HhX1LkA9yTVwlk8xOaHPqI4KfsFAyoiiHzyttGDexzb1PzmM0pybAPDMhpN/
-wXp2kLjyzmUmPe2Y2yva69WVWo7qS6joKjY75MQ1t20HYgEL69IApvCPu4CANfi9
-j3FAaV/+WrnhKCi6QyUi5PCI/+AJLsjNQmqTXIdBEoECgYEA+XsgFbeZ6+ZzEHa7
-HyFH6kiyBLd0q7w+ZLPsoOmEApDaP3yXSC7eJU7M/tPUPj8VQMMSK2D6fgmUDwhb
-3mEXFZxf67UlPFsFjweYcBihwy4r8QKBwury6dEbHPSUq4mXFJF5XRQdGqRGkr/F
-8OLZ0MwmHLUzczA67PxP/wF8TsECgYEA5YD4RxxJJYfAk1rFbqHRhNB8UeYVL+Wo
-wsRET1JeFg+S5grLGUga+KBB8Jn7Ahaip7MVE0Iud1cgaDi4WBEJsbJ6oJTlHJEg
-Jq7QAaBafwjeSCSnaEsVBVNvriy2WF7uAomLSKmW6uSUOBBFFt4+G+akG56EfOPc
-7YKBfsf5ITcCgYBvjVZzX307tfeNTQmuibsWTxsKcN2CTNG5RZpw+PlGDG8KJDOg
-2xQJqoqPBzjH/H0MUC03qE1ZPf8uGZa6gL9JsnpRctYLfselhMfsl5b9JxAO3AgZ
-l+S2GAH/mH1BlmwvjjyuGehJmVrVE1r2sviiHCaOf5dZ0h8HCGrco1VqAQKBgQCf
-fYkMofOTSUvjG2mpAHuCOQCsSaDfsFIfSBXQqgUIf7ouc8HAyAM2VOh+NAPj56cR
-s7opsAxqkvnKc+BoEy8Rdl8RyWeO+qvFNicHelBph9gxeod8SvFIyjsKZ7gwoYf1
-63AIBxMCGeeHLodU5Q10hkv1hau8vv2BcPhdCstu8QKBgQDgO4Rr36Pa5rjbNbGN
-PsJqALjthTeU0yaU8hdC7Hc7B/T6npEIhw3s1eNq7e0eeDltqz7tDnY8qysazbQZ
-p1cV5TJ8+gtwGmDoADBnU1NXqX4Squfml6OhNEucpTdjux7JdLVmmQFraOT2Eu5f
-9uuNtA+d8uhBEXhskuvEC552ug==
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_pss_private_2048_sha512_sha256_20.pem b/test/fixtures/keys/rsa_pss_private_2048_sha512_sha256_20.pem
deleted file mode 100644
index f8e898980ad25fd03dda0401fe4f18a148d7fb9f..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_pss_private_2048_sha512_sha256_20.pem
+++ /dev/null
@@ -1,29 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIE5wIBADA4BgkqhkiG9w0BAQowK6ANMAsGCWCGSAFlAwQCA6EaMBgGCSqGSIb3
-DQEBCDALBglghkgBZQMEAgEEggSmMIIEogIBAAKCAQEAvM9NgMCDqy5dqj5Ua2cZ
-cc4zVr+fCF34bZn63OBeYG8RTJKM3j36lO/yamtfDctDhb87b45CS6ipEr8J57I9
-WF55TNngsn6GNpXgwAe0eFXUnKonuqnGEC7x8r3vkAg99PBKhAtFc5oTaaZDAFKM
-zc5dIC/J0Y+kxhqjCPNI0ydQgZmKBrmYjM9cvbOYgRQL10GrWeJ+XHk2E33endaF
-+4dwjgyrzInt/l6OTkiCL8F59J/htk1GPru9BT6w5yOS/vH6q6FD6uizULVznytd
-lHjgnrVaHJmsqVjrYQa9OAZj9GBrTelBWvQ9b6+FBHUFHBp8HSp82lWCZThPrcZ/
-QwIDAQABAoIBADDzUfWic8CKuc/sbviVdzxRKHBCJ9oEeub3d9mR9gXsZcDDcfAg
-g3nfp6q9gZxS6YOga6llaXyyEnuAufGu/UaO38Xz6tR8BxHZ07YViU11ezTOzJQR
-df82HJZBdf2SlXWOYtNPFMd+16+ZYl+QB19INE6m9Rz2r9KIj2I/qM7NPPVhDRF0
-G4O0Yf2vaPhjoIaewn7xtQ6wmX7pAGcd8dmYEIGGkBi8aY3BVwrRK1X4AmD+oSmE
-wXqR6MQIzD4KdypL4UD1Cb4GoFeVRclXvegOG+EKl0iD+mjTodB4yjoJh98NYe3+
-GtpR/2u3Ltq8RqWpIg8ryShQk/MIqGJ5KpkCgYEA80uNEYWlBt6QGNvVIYrhnw+V
-2nLJWedioKV4H1sr9OLF/7WFOUfsaflpVybnmwfNV15lEyHb/m/sCM9jTrNk1t/q
-qhRnvtmy3kntxWBeoA2o0TRg/XZKWjabZsr/4UE/Ztws2opOvl9x05IYeZlU+PbZ
-B1lX2e+vtMOpllvRr28CgYEAxqtfrYv8brp/fAUqGu/MtdHxQdU1+vE+auN17gam
-ZM6ojIeasX4k2z0Rd/+8Dga9wPgO7hjtFZ2NWD5UwfBiw5U2PVZ6bp3iKSBPGHEh
-RsIR+nw8pFIgsQKoYnVK58tEnfQ31GSupKpYybHbaL5SdId+mfXU86SbKX/MefZX
-g20CgYBjn8hAKI2O5ovy4fHALnJ9A5DFRsOUgN8uERPDIz44pLOXJelLr1vreSnd
-ehzUqrk20Xxp/S9sXMA2S1XK4EKmikI5KungiJxp0bP/Yprcxzsdj2k34LxJfJrd
-2Lo2rtUbdYUYaBIeek7N58EF6feVit8L11XV9APq7UQAQdD3GQKBgBmxuGIdpLw9
-apeDo3pwYS1yxZ0aEi0uXkA8wtfSDFslTy89qogiJGomb8fxT0URIiF+849fseoF
-wm4TQasDiAJ7ndQ5BwSfbsya3R/wIbmhB+o5fy5RYOED0vtI6DMqWumC2GWjz+KE
-FY+gbRwS4V8o1vrajHwmYdrwKGXtskvRAoGADe/EdlCj98r6Zle9giF1C0GDIDTx
-8bR2m+Ogh9ZO218GpDMNaQ/WmbYVPDYMbRSOEA7y2gVkd1OeYhJMF6aYffp3aWhN
-t9g0uojLY0jfEpWBLBQdlYOTl7hOnLWRRcOAKTlHVg+OuD/O/GmdQ2Rg2H/hAWlI
-muuTQPuQTCV1aTc=
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/rsa_pss_public_2048.pem b/test/fixtures/keys/rsa_pss_public_2048.pem
deleted file mode 100644
index ade38f20a44353a88a28cee53fcdb3e13d25f5f7..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_pss_public_2048.pem
+++ /dev/null
@@ -1,9 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIBIDALBgkqhkiG9w0BAQoDggEPADCCAQoCggEBAMuDjHUvOD5YCOQkS23W7nfU
-bu76axa9mDTVJnU+w92IAKYr/Ao8yly4lQ52zBE/pcJrWoPxHGbMVQiqL7Lt9KWA
-Ega4hzojFWLovfmWiaEPciOpToxtUW7lASVzUoxwScagapnIGTm9ZnUa/3l86QDF
-id4X7i6I1Nvs1Eid/673qXqXCxRtqvZwNPjybJCez54dy9MnZ791N4XbjJ+TlX5v
-ycdRT8maQ9fOLSX3/jfjGN7N4SHH7jpy/T5eETxnmkwuE9aOOtDWhumxu3NloYOj
-TmlYGhSGojW600zQqVY3k8mpbE12JUEN4Yio7LdEO6XxRJCQ6PKoqi2ndTLJefcC
-AwEAAQ==
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/rsa_pss_public_2048_sha256_sha256_16.pem b/test/fixtures/keys/rsa_pss_public_2048_sha256_sha256_16.pem
deleted file mode 100644
index 9f8e15bbe0f8f1805c8cc62239a73d390df41b2a..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_pss_public_2048_sha256_sha256_16.pem
+++ /dev/null
@@ -1,10 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIBUjA9BgkqhkiG9w0BAQowMKANMAsGCWCGSAFlAwQCAaEaMBgGCSqGSIb3DQEB
-CDALBglghkgBZQMEAgGiAwIBEAOCAQ8AMIIBCgKCAQEA36jTOAvkLQ+94iC6jpKn
-1fIWtztfY6V/FLoyJNWe9m227sBM4dPrAcNHQ9DfAoJF53jzhBHequxzZm8gjaka
-QyujQ72gjA1oBGg/z5R5EZ7byofNSF0jAuYpo0XznGSBPxp8O4fLWp2m9J++fjg7
-yya5hFlBtqu/SJtZljMe0qaHfjaelxGPuyO5wFFFor69+WMeQ3ssWPK8RRqbC7Rr
-IuyTUDuGh8ngaY/Lc9BYb9t7j8sBNpxpjx355F1m603Bxm82AYBG3kh/SlJEcHM6
-g1zTj4bX2hBxBU5tDKHigpyXtVTo0ssHr++3VdSmX6VYdyodGUUCHvWDlSYY+JTM
-dwIDAQAB
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/rsa_pss_public_2048_sha512_sha256_20.pem b/test/fixtures/keys/rsa_pss_public_2048_sha512_sha256_20.pem
deleted file mode 100644
index 9ace7d6d2db7945fbe7ad78a059da0fdc7d9b365..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_pss_public_2048_sha512_sha256_20.pem
+++ /dev/null
@@ -1,10 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIBTTA4BgkqhkiG9w0BAQowK6ANMAsGCWCGSAFlAwQCA6EaMBgGCSqGSIb3DQEB
-CDALBglghkgBZQMEAgEDggEPADCCAQoCggEBALzPTYDAg6suXao+VGtnGXHOM1a/
-nwhd+G2Z+tzgXmBvEUySjN49+pTv8mprXw3LQ4W/O2+OQkuoqRK/CeeyPVheeUzZ
-4LJ+hjaV4MAHtHhV1JyqJ7qpxhAu8fK975AIPfTwSoQLRXOaE2mmQwBSjM3OXSAv
-ydGPpMYaowjzSNMnUIGZiga5mIzPXL2zmIEUC9dBq1niflx5NhN93p3WhfuHcI4M
-q8yJ7f5ejk5Igi/BefSf4bZNRj67vQU+sOcjkv7x+quhQ+ros1C1c58rXZR44J61
-WhyZrKlY62EGvTgGY/Rga03pQVr0PW+vhQR1BRwafB0qfNpVgmU4T63Gf0MCAwEA
-AQ==
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/rsa_public.pem b/test/fixtures/keys/rsa_public.pem
deleted file mode 100644
index 8c30cfa52d47afae5c925404ee06825a267a0ba1..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_public.pem
+++ /dev/null
@@ -1,9 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt9xYiIonscC3vz/A2ceR
-7KhZZlDu/5bye53nCVTcKnWd2seY6UAdKersX6njr83Dd5OVe1BW/wJvp5EjWTAG
-YbFswlNmeD44edEGM939B6Lq+/8iBkrTi8mGN4YCytivE24YI0D4XZMPfkLSpab2
-y/Hy4DjQKBq1ThZ0UBnK+9IhX37Ju/ZoGYSlTIGIhzyaiYBh7wrZBoPczIEu6et/
-kN2VnnbRUtkYTF97ggcv5h+hDpUQjQW0ZgOMcTc8n+RkGpIt0/iM/bTjI3Tz/gsF
-di6hHcpZgbopPL630296iByyigQCPJVzdusFrQN5DeC+zT/nGypQkZanLb4ZspSx
-9QIDAQAB
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/rsa_public_1024.pem b/test/fixtures/keys/rsa_public_1024.pem
deleted file mode 100644
index f5c71a8449ccf64d32dad34e02e123415614c49c..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_public_1024.pem
+++ /dev/null
@@ -1,6 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDRMGk0Tp+sGoU4FbTF76l7g3uO
-dSpqLBnP4UDKSdhv3p+lfr6FpiJh8KnXIPKMq5b4EX+X4Ghz7PKDMEs24ihiqwUM
-l89exvFtW2bXwqq0XpMqdF6RCxbbBYy3DFPTCTvoHaoAfmwHzwBfelHt2PaYl4ZN
-xhpD4UcP3/lrUB5KhwIDAQAB
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/rsa_public_2048.pem b/test/fixtures/keys/rsa_public_2048.pem
deleted file mode 100644
index 0c80ceb4d9a01b390bf2744e360f8871b95e835d..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_public_2048.pem
+++ /dev/null
@@ -1,9 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArk4OqxBqU5/k0FoUDU7C
-pZpjz6YJEXUpyqeJmFRVZPMUv/Rc7U4seLY+Qp6k26T/wlQ2WJWuyY+VJcbQNWLv
-jJWks5HWknwDuVs6sjuTM8CfHWn1960JkK5Ec2TjRhCQ1KJy+uc3GJLtWb4rWVgT
-bbaaC5fiR1/GeuJ8JH1Q50lB3mDsNGIk1U5jhNaYY82hYvlbErf6Ft5njHK0BOM5
-OTvQ6BBv7c363WNG7tYlNw1J40dup9OQPo5JmXN/h+sRbdgG8iUxrkRibuGv7loh
-52QQgq2snznuRMdKidRfUZjCDGgwbgK23Q7n8VZ9Y10j8PIvPTLJ83PX4lOEA37J
-lwIDAQAB
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/rsa_public_4096.pem b/test/fixtures/keys/rsa_public_4096.pem
deleted file mode 100644
index 4fd0bbc1c57b2271ccf28725360cfb9614a03325..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_public_4096.pem
+++ /dev/null
@@ -1,14 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxeStwofbjtZuol4lwKn1
-w08AzcSNLHfCqNFHa+W7er8is7LQsPljtPT4yn4lsao83ngHFvSC3tbMiRNDpUHY
-qH2wBuUkuOmCtYkZLi0307H0CwcVV6W5P3tNEt80IJ+PqlRxtTknezUtbOasbIi/
-aornVWG+psgqDGrFZ4oTsWtiE0Svi7sDqN5E2dijmH/YYnlnwqszgzHdtAnARp1b
-G34E64sqWCmLoGCfPdHtym/CSdxOLOsDV15jrwODZQ/TJZ5thkwKZRxu7g9fwlhA
-1PiI5WDP4reXNaqa2bSgrzpAljQExYs4N0L7okSVOJQX9BEaoWtq8NLU8MpMdGoH
-NDU0Xr60Lfr58Z5qn8RGEvlTxoCbPJzPV2zgzD/lmEqft6NnfTclveA3sd8xSrOB
-Un4o3S8hS0b9Su7PBukHjM96/e0ReoIshSwXlQTLr2Ft8KwupyPm1ltNcTDtjqHc
-IWU6Bg+kPy9mxSVtGGZYAPtqGzNBA/m+oOja/OSPxAblPdln691DaDuZs5nuZCGw
-GcLaJWgiyoqvXAcyXDZFyH4OZZh8rsBLKbnFXHZ/ziG0cAozEygZEPJappw8Lx/a
-dy7WL/SJjxooiKapc7Bnfy8eSLV3+XAKxhLW/MQ6ChJ+e/8ExAY02ca4MpCvqwIk
-9TfV6FM8pWGqHzQFj0v3NL0CAwEAAQ==
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/rsa_public_b.pem b/test/fixtures/keys/rsa_public_b.pem
deleted file mode 100644
index bce0804617fcb6f29bcf5062f0d6d25bf167fcb0..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_public_b.pem
+++ /dev/null
@@ -1,9 +0,0 @@
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyb1grrN+29fxeeEbTaSE
-ja6TKDTpT/WXnqrFCS+h7IYcnDoAVwcsPU5FZeUPvLKMzi9NHSJ34LQCurqHgH8X
-+cw0YT3gdYS/7qoQiXs+zKv615NcttD3xlQLceY+NwznoPXyyZwOeZqyU5Hiqbrq
-u6hdr6gQYogMNLn2NxBW2pGegd6+ZGMCX3+/BtMP/6tXmttYjY+yhN2SrGz5cKhW
-pcHiC6X+B7uCKoKZy+t2jUxYVKUwWr1ZuM8kpSnuVCcv1OoMGEimEHA7v/eaF/y+
-z/VdQ4Y88GhTnVN4KbtgZ+o9PohjxLFU62VeTALixU5mPQKSgSICKfjev0FUUurF
-6wIDAQAB
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/rsa_public_sha1_signature_signedby_rsa_private.sha1 b/test/fixtures/keys/rsa_public_sha1_signature_signedby_rsa_private.sha1
deleted file mode 100644
index 57435806d9623c73553da2d0a018d3ec7a54e2c9..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_public_sha1_signature_signedby_rsa_private.sha1
+++ /dev/null
@@ -1,2 +0,0 @@
-�yf�F���4}�x=�e	Z'`a%�Z>Yt�mxd4E�c(�9��ȴ��k��L�����2��+��q�Si��2:���[dfj/���5П�9�O<���8��'. O��eL�8���2�t�ӟ/��3�K����,��Њ�l��Zڅ�t�[��4�f��#�*	�Y�	��餡w/���2ߗfꢅ�X��h�a<T���ۦ��;Z���`F�#<wI�Gi6�fw�E<�4eΘv��b�.
-��
\ No newline at end of file
diff --git a/test/fixtures/keys/rsa_public_sha1_signature_signedby_rsa_private_pkcs8.sha1 b/test/fixtures/keys/rsa_public_sha1_signature_signedby_rsa_private_pkcs8.sha1
deleted file mode 100644
index 57435806d9623c73553da2d0a018d3ec7a54e2c9..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/rsa_public_sha1_signature_signedby_rsa_private_pkcs8.sha1
+++ /dev/null
@@ -1,2 +0,0 @@
-�yf�F���4}�x=�e	Z'`a%�Z>Yt�mxd4E�c(�9��ȴ��k��L�����2��+��q�Si��2:���[dfj/���5П�9�O<���8��'. O��eL�8���2�t�ӟ/��3�K����,��Њ�l��Zڅ�t�[��4�f��#�*	�Y�	��餡w/���2ߗfꢅ�X��h�a<T���ۦ��;Z���`F�#<wI�Gi6�fw�E<�4eΘv��b�.
-��
\ No newline at end of file
diff --git a/test/fixtures/keys/x25519_private.pem b/test/fixtures/keys/x25519_private.pem
deleted file mode 100644
index 926c4e3a2b669a4e0b5ad69c1cf1bee1d1846c2c..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/x25519_private.pem
+++ /dev/null
@@ -1,3 +0,0 @@
------BEGIN PRIVATE KEY-----
-MC4CAQAwBQYDK2VuBCIEIJi/yFpueUawC1BkXyWM8ONIBGFjL7UZHrD/Zo/KPDpn
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/x25519_public.pem b/test/fixtures/keys/x25519_public.pem
deleted file mode 100644
index e2d756bd17c83f9c1f24bc2ac92e458a4056a500..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/x25519_public.pem
+++ /dev/null
@@ -1,3 +0,0 @@
------BEGIN PUBLIC KEY-----
-MCowBQYDK2VuAyEAaSb8Q+RndwfNnPeOYGYPDUN3uhAPnMLzXyfi+mqfhig=
------END PUBLIC KEY-----
diff --git a/test/fixtures/keys/x448_private.pem b/test/fixtures/keys/x448_private.pem
deleted file mode 100644
index 61cd52c3989105340645cd7aaf189621f789bb1e..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/x448_private.pem
+++ /dev/null
@@ -1,4 +0,0 @@
------BEGIN PRIVATE KEY-----
-MEYCAQAwBQYDK2VvBDoEOLTDbazv6vHZWOmODQ3kk8TUOQgApB4j75rpInT5zSLl
-/xJHK8ixF7f+4uo+mGTCrK1sktI5UmCZ
------END PRIVATE KEY-----
diff --git a/test/fixtures/keys/x448_public.pem b/test/fixtures/keys/x448_public.pem
deleted file mode 100644
index 6475d0438042d54a5d63fe4adf5bc01858bfb6f8..0000000000000000000000000000000000000000
--- a/test/fixtures/keys/x448_public.pem
+++ /dev/null
@@ -1,4 +0,0 @@
------BEGIN PUBLIC KEY-----
-MEIwBQYDK2VvAzkAioHSHVpTs6hMvghosEJDIR7ceFiE3+Xccxati64oOVJ7NWjf
-ozE7ae31PXIUFq6cVYgvSKsDFPA=
------END PUBLIC KEY-----
diff --git a/test/fixtures/node_modules/default_index/index.js b/test/fixtures/node_modules/default_index/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..748e47637e97fa0ac805c9395399bf307093c673
--- /dev/null
+++ b/test/fixtures/node_modules/default_index/index.js
@@ -0,0 +1 @@
+export default 'main'
diff --git a/test/fixtures/node_modules/default_index/package.json b/test/fixtures/node_modules/default_index/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..7665d7a8037428bc75fda69269bdc43fd82f480d
--- /dev/null
+++ b/test/fixtures/node_modules/default_index/package.json
@@ -0,0 +1,4 @@
+{
+  "main": "index",
+  "type": "module"
+}
diff --git a/test/fixtures/node_modules/no_exports/index.js b/test/fixtures/node_modules/no_exports/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d97dd4b70ce59742348e6033451d4962bfdb864
--- /dev/null
+++ b/test/fixtures/node_modules/no_exports/index.js
@@ -0,0 +1 @@
+export default 'index'
diff --git a/test/fixtures/node_modules/no_exports/package.json b/test/fixtures/node_modules/no_exports/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..3dbc1ca591c0557e35b6004aeba250e6a70b56e3
--- /dev/null
+++ b/test/fixtures/node_modules/no_exports/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
diff --git a/test/fixtures/node_modules/no_index/lib/index.js b/test/fixtures/node_modules/no_index/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ba52ba2c8df6758685c8f65f490306b5c44eb76
--- /dev/null
+++ b/test/fixtures/node_modules/no_index/lib/index.js
@@ -0,0 +1 @@
+module.exports = {}
diff --git a/test/fixtures/node_modules/no_index/package.json b/test/fixtures/node_modules/no_index/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..0c6100eadad1847544f469298ad43f837cee8127
--- /dev/null
+++ b/test/fixtures/node_modules/no_index/package.json
@@ -0,0 +1,3 @@
+{
+  "main": "./lib/index.js"
+}
diff --git a/test/fixtures/person.jpg.br b/test/fixtures/person.jpg.br
deleted file mode 100644
index 7d35b1238fb7ec7324c3837dd41e7958d746480e..0000000000000000000000000000000000000000
Binary files a/test/fixtures/person.jpg.br and /dev/null differ
diff --git a/test/fixtures/person.jpg.gz b/test/fixtures/person.jpg.gz
deleted file mode 100644
index 0d3239a3c842298d4aa98f56e236bf91e1ddbb6c..0000000000000000000000000000000000000000
Binary files a/test/fixtures/person.jpg.gz and /dev/null differ
diff --git a/test/fixtures/policy/bad-main.mjs b/test/fixtures/policy/bad-main.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..db1938ad7c2e872d48d9390a18055b7050d465ac
--- /dev/null
+++ b/test/fixtures/policy/bad-main.mjs
@@ -0,0 +1 @@
+import {doesNotExist} from './dep.js';
diff --git a/test/fixtures/policy/canonicalize.mjs b/test/fixtures/policy/canonicalize.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..64e7cd117ad7c00652c911773792fd7a803feec0
--- /dev/null
+++ b/test/fixtures/policy/canonicalize.mjs
@@ -0,0 +1,5 @@
+import resolveAsFS from './dep.js';
+import fs from 'fs';
+
+let correct = resolveAsFS === fs && typeof resolveAsFS === 'object';
+process.exit(correct ? 0 : 1);
diff --git a/test/fixtures/policy/crypto-default-encoding/.gitattributes b/test/fixtures/policy/crypto-default-encoding/.gitattributes
new file mode 100644
index 0000000000000000000000000000000000000000..cbdcbbc258e6e757fe6f41a6e1827d407963b070
--- /dev/null
+++ b/test/fixtures/policy/crypto-default-encoding/.gitattributes
@@ -0,0 +1 @@
+*.js text eol=lf
diff --git a/test/fixtures/policy/crypto-default-encoding/dep.js b/test/fixtures/policy/crypto-default-encoding/dep.js
new file mode 100644
index 0000000000000000000000000000000000000000..d741da76db0076108b91ca284a807c7179bf522f
--- /dev/null
+++ b/test/fixtures/policy/crypto-default-encoding/dep.js
@@ -0,0 +1,3 @@
+'use strict';
+
+// No code.
diff --git a/test/fixtures/policy/crypto-default-encoding/parent.js b/test/fixtures/policy/crypto-default-encoding/parent.js
new file mode 100644
index 0000000000000000000000000000000000000000..90ebde7e6535c040307da24c8e9c3e2c6ed2ed51
--- /dev/null
+++ b/test/fixtures/policy/crypto-default-encoding/parent.js
@@ -0,0 +1,4 @@
+'use strict';
+
+require('crypto').DEFAULT_ENCODING = process.env.DEFAULT_ENCODING;
+require('./dep.js');
diff --git a/test/fixtures/policy/crypto-default-encoding/policy.json b/test/fixtures/policy/crypto-default-encoding/policy.json
new file mode 100644
index 0000000000000000000000000000000000000000..4cb485e1d9e2e4c3a9253acd53001c18b86ec176
--- /dev/null
+++ b/test/fixtures/policy/crypto-default-encoding/policy.json
@@ -0,0 +1,14 @@
+{
+  "resources": {
+    "./parent.js": {
+      "integrity": "sha384-j4pMdq83q5Bq9+idcHuGKzi89FrYm1PhZYrEw3irbNob6g4i3vKBjfYiRNYwmoGr",
+      "dependencies": {
+        "crypto": true,
+        "./dep.js": true
+      }
+    },
+    "./dep.js": {
+      "integrity": "sha384-VU7GIrTix/HFLhUb4yqsV4n1xXqjPcWw6kLvjuKXtR1+9nmufJu5vZLajBs8brIW"
+    }
+  }
+}
diff --git a/test/fixtures/policy/dependencies/dependencies-missing-export-policy.json b/test/fixtures/policy/dependencies/dependencies-missing-export-policy.json
new file mode 100644
index 0000000000000000000000000000000000000000..5da0de139209369895f532e9e2e59af2731089dc
--- /dev/null
+++ b/test/fixtures/policy/dependencies/dependencies-missing-export-policy.json
@@ -0,0 +1,11 @@
+{
+  "resources": {
+    "../bad-main.mjs": {
+      "integrity": true,
+      "dependencies": true
+    },
+    "../dep.js": {
+      "integrity": true
+    }
+  }
+}
diff --git a/test/fixtures/policy/dependencies/dependencies-missing-policy-default-true.json b/test/fixtures/policy/dependencies/dependencies-missing-policy-default-true.json
new file mode 100644
index 0000000000000000000000000000000000000000..10ab862d2b0cc00a9ae86de5702f3f2e61318374
--- /dev/null
+++ b/test/fixtures/policy/dependencies/dependencies-missing-policy-default-true.json
@@ -0,0 +1,13 @@
+{
+  "dependencies": true,
+  "resources": {
+    "../parent.js": {
+      "cascade": true,
+      "integrity": true
+    },
+    "../dep.js": {
+      "cascade": true,
+      "integrity": true
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/policy/dependencies/dependencies-redirect-builtin-policy.json b/test/fixtures/policy/dependencies/dependencies-redirect-builtin-policy.json
index 437228a2e502775602327a20df89cb283b430e51..7d2715f96a5092576f3410f838fbb06db823e15e 100644
--- a/test/fixtures/policy/dependencies/dependencies-redirect-builtin-policy.json
+++ b/test/fixtures/policy/dependencies/dependencies-redirect-builtin-policy.json
@@ -3,7 +3,7 @@
     "../parent.js": {
       "integrity": true,
       "dependencies": {
-        "./dep.js": "node:util"
+        "../dep.js": "node:util"
       }
     }
   }
diff --git a/test/fixtures/policy/dependencies/dependencies-redirect-policy.json b/test/fixtures/policy/dependencies/dependencies-redirect-policy.json
index 993a683f10a38fbc102cfbb044d78a1e4489298d..c5b73403d5f864a1b31edd02b1d16105c8c7e3e0 100644
--- a/test/fixtures/policy/dependencies/dependencies-redirect-policy.json
+++ b/test/fixtures/policy/dependencies/dependencies-redirect-policy.json
@@ -3,7 +3,7 @@
     "../parent.js": {
       "integrity": true,
       "dependencies": {
-        "./dep.js": "../dep.js"
+        "../dep.js": "../dep.js"
       }
     },
     "../dep.js": {
diff --git a/test/fixtures/policy/dependencies/dependencies-redirect-unknown-builtin-policy.json b/test/fixtures/policy/dependencies/dependencies-redirect-unknown-builtin-policy.json
index db2046c6d36f07d150f6d85cada4c99348f6dc3f..a2bcb2676223d3641176afec67a647e964d494df 100644
--- a/test/fixtures/policy/dependencies/dependencies-redirect-unknown-builtin-policy.json
+++ b/test/fixtures/policy/dependencies/dependencies-redirect-unknown-builtin-policy.json
@@ -3,7 +3,7 @@
     "../parent.js": {
       "integrity": true,
       "dependencies": {
-        "./dep.js": "node:404"
+        "../dep.js": "node:404"
       }
     }
   }
diff --git a/test/fixtures/policy/dependencies/dependencies-scopes-and-resources-policy.json b/test/fixtures/policy/dependencies/dependencies-scopes-and-resources-policy.json
new file mode 100644
index 0000000000000000000000000000000000000000..0cf33b16363352a90c23e39a275fea510d313337
--- /dev/null
+++ b/test/fixtures/policy/dependencies/dependencies-scopes-and-resources-policy.json
@@ -0,0 +1,14 @@
+{
+  "resources": {
+    "../multi-deps.js": {
+      "integrity": true,
+      "cascade": true
+    }
+  },
+  "scopes": {
+    "../": {
+      "integrity": true,
+      "dependencies": true
+    }
+  }
+}
diff --git a/test/fixtures/policy/dependencies/dependencies-scopes-policy.json b/test/fixtures/policy/dependencies/dependencies-scopes-policy.json
new file mode 100644
index 0000000000000000000000000000000000000000..2af78b0fa945bf0578b2a2b4e0e59fa051902168
--- /dev/null
+++ b/test/fixtures/policy/dependencies/dependencies-scopes-policy.json
@@ -0,0 +1,8 @@
+{
+  "scopes": {
+    "../": {
+      "integrity": true,
+      "dependencies": true
+    }
+  }
+}
diff --git a/test/fixtures/policy/dependencies/dependencies-scopes-relative-specifier.json b/test/fixtures/policy/dependencies/dependencies-scopes-relative-specifier.json
new file mode 100644
index 0000000000000000000000000000000000000000..7ce0b0262e48a83d6a8f09ef037298bac07b0770
--- /dev/null
+++ b/test/fixtures/policy/dependencies/dependencies-scopes-relative-specifier.json
@@ -0,0 +1,12 @@
+{
+  "scopes": {
+    "file:": {
+      "integrity": true,
+      "cascade": true,
+      "dependencies": {
+        "fs": "node:fs",
+        "../dep.js": "node:fs"
+      }
+    }
+  }
+}
diff --git a/test/fixtures/policy/main.mjs b/test/fixtures/policy/main.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..feac7e3b8c946ce356f64eec1ceeb2e26ff54e4d
--- /dev/null
+++ b/test/fixtures/policy/main.mjs
@@ -0,0 +1,2 @@
+'use strict';
+export default 'main.mjs';
diff --git a/test/fixtures/policy/multi-deps.js b/test/fixtures/policy/multi-deps.js
new file mode 100644
index 0000000000000000000000000000000000000000..51cdf61783989a1a901cedce03cfac3f1f1fc528
--- /dev/null
+++ b/test/fixtures/policy/multi-deps.js
@@ -0,0 +1,3 @@
+'use strict';
+require('fs');
+require('process');
diff --git a/test/fixtures/process-exit-code-cases.js b/test/fixtures/process-exit-code-cases.js
index c8c4a2ebe6c7ff6a2b179ae8ae9dde7f8b4e996b..05b01afd8f46305e1fc7ae816f0786b51d32068f 100644
--- a/test/fixtures/process-exit-code-cases.js
+++ b/test/fixtures/process-exit-code-cases.js
@@ -2,112 +2,135 @@
 
 const assert = require('assert');
 
-const cases = [];
-module.exports = cases;
+function getTestCases(isWorker = false) {
+  const cases = [];
+  function exitsOnExitCodeSet() {
+    process.exitCode = 42;
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 42);
+      assert.strictEqual(code, 42);
+    });
+  }
+  cases.push({ func: exitsOnExitCodeSet, result: 42 });
 
-function exitsOnExitCodeSet() {
-  process.exitCode = 42;
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 42);
-    assert.strictEqual(code, 42);
-  });
-}
-cases.push({ func: exitsOnExitCodeSet, result: 42 });
+  function changesCodeViaExit() {
+    process.exitCode = 99;
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 42);
+      assert.strictEqual(code, 42);
+    });
+    process.exit(42);
+  }
+  cases.push({ func: changesCodeViaExit, result: 42 });
 
-function changesCodeViaExit() {
-  process.exitCode = 99;
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 42);
-    assert.strictEqual(code, 42);
-  });
-  process.exit(42);
-}
-cases.push({ func: changesCodeViaExit, result: 42 });
+  function changesCodeZeroExit() {
+    process.exitCode = 99;
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 0);
+      assert.strictEqual(code, 0);
+    });
+    process.exit(0);
+  }
+  cases.push({ func: changesCodeZeroExit, result: 0 });
 
-function changesCodeZeroExit() {
-  process.exitCode = 99;
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 0);
-    assert.strictEqual(code, 0);
+  function exitWithOneOnUncaught() {
+    process.exitCode = 99;
+    process.on('exit', (code) => {
+      // cannot use assert because it will be uncaughtException -> 1 exit code
+      // that will render this test useless
+      if (code !== 1 || process.exitCode !== 1) {
+        console.log('wrong code! expected 1 for uncaughtException');
+        process.exit(99);
+      }
+    });
+    throw new Error('ok');
+  }
+  cases.push({
+    func: exitWithOneOnUncaught,
+    result: 1,
+    error: /^Error: ok$/,
   });
-  process.exit(0);
-}
-cases.push({ func: changesCodeZeroExit, result: 0 });
 
-function exitWithOneOnUncaught() {
-  process.exitCode = 99;
-  process.on('exit', (code) => {
-    // cannot use assert because it will be uncaughtException -> 1 exit code
-    // that will render this test useless
-    if (code !== 1 || process.exitCode !== 1) {
-      console.log('wrong code! expected 1 for uncaughtException');
-      process.exit(99);
-    }
-  });
-  throw new Error('ok');
-}
-cases.push({
-  func: exitWithOneOnUncaught,
-  result: 1,
-  error: /^Error: ok$/,
-});
+  function changeCodeInsideExit() {
+    process.exitCode = 95;
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 95);
+      assert.strictEqual(code, 95);
+      process.exitCode = 99;
+    });
+  }
+  cases.push({ func: changeCodeInsideExit, result: 99 });
 
-function changeCodeInsideExit() {
-  process.exitCode = 95;
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 95);
-    assert.strictEqual(code, 95);
-    process.exitCode = 99;
-  });
-}
-cases.push({ func: changeCodeInsideExit, result: 99 });
+  function zeroExitWithUncaughtHandler() {
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 0);
+      assert.strictEqual(code, 0);
+    });
+    process.on('uncaughtException', () => { });
+    throw new Error('ok');
+  }
+  cases.push({ func: zeroExitWithUncaughtHandler, result: 0 });
 
-function zeroExitWithUncaughtHandler() {
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 0);
-    assert.strictEqual(code, 0);
-  });
-  process.on('uncaughtException', () => {});
-  throw new Error('ok');
-}
-cases.push({ func: zeroExitWithUncaughtHandler, result: 0 });
+  function changeCodeInUncaughtHandler() {
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 97);
+      assert.strictEqual(code, 97);
+    });
+    process.on('uncaughtException', () => {
+      process.exitCode = 97;
+    });
+    throw new Error('ok');
+  }
+  cases.push({ func: changeCodeInUncaughtHandler, result: 97 });
 
-function changeCodeInUncaughtHandler() {
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 97);
-    assert.strictEqual(code, 97);
+  function changeCodeInExitWithUncaught() {
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 1);
+      assert.strictEqual(code, 1);
+      process.exitCode = 98;
+    });
+    throw new Error('ok');
+  }
+  cases.push({
+    func: changeCodeInExitWithUncaught,
+    result: 98,
+    error: /^Error: ok$/,
   });
-  process.on('uncaughtException', () => {
-    process.exitCode = 97;
+
+  function exitWithZeroInExitWithUncaught() {
+    process.on('exit', (code) => {
+      assert.strictEqual(process.exitCode, 1);
+      assert.strictEqual(code, 1);
+      process.exitCode = 0;
+    });
+    throw new Error('ok');
+  }
+  cases.push({
+    func: exitWithZeroInExitWithUncaught,
+    result: 0,
+    error: /^Error: ok$/,
   });
-  throw new Error('ok');
-}
-cases.push({ func: changeCodeInUncaughtHandler, result: 97 });
 
-function changeCodeInExitWithUncaught() {
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 1);
-    assert.strictEqual(code, 1);
-    process.exitCode = 98;
+  function exitWithThrowInUncaughtHandler() {
+    process.on('uncaughtException', () => {
+      throw new Error('ok')
+    });
+    throw new Error('bad');
+  }
+  cases.push({
+    func: exitWithThrowInUncaughtHandler,
+    result: isWorker ? 1 : 7,
+    error: /^Error: ok$/,
   });
-  throw new Error('ok');
-}
-cases.push({
-  func: changeCodeInExitWithUncaught,
-  result: 98,
-  error: /^Error: ok$/,
-});
 
-function exitWithZeroInExitWithUncaught() {
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 1);
-    assert.strictEqual(code, 1);
-    process.exitCode = 0;
+  function exitWithUndefinedFatalException() {
+    process._fatalException = undefined;
+    throw new Error('ok');
+  }
+  cases.push({
+    func: exitWithUndefinedFatalException,
+    result: 6,
   });
-  throw new Error('ok');
+  return cases;
 }
-cases.push({
-  func: exitWithZeroInExitWithUncaught,
-  result: 0,
-  error: /^Error: ok$/,
-});
+exports.getTestCases = getTestCases;
diff --git a/test/fixtures/pseudo-multimember-gzip.gz b/test/fixtures/pseudo-multimember-gzip.gz
deleted file mode 100644
index a019c484d854820da00e478ed3d8509b626523e9..0000000000000000000000000000000000000000
Binary files a/test/fixtures/pseudo-multimember-gzip.gz and /dev/null differ
diff --git a/test/fixtures/pseudo-multimember-gzip.z b/test/fixtures/pseudo-multimember-gzip.z
deleted file mode 100644
index e87b13ab534fbca0aed4ef958fef8bd67644969e..0000000000000000000000000000000000000000
Binary files a/test/fixtures/pseudo-multimember-gzip.z and /dev/null differ
diff --git a/test/fixtures/shared-memory.wasm b/test/fixtures/shared-memory.wasm
deleted file mode 100644
index 497b8440bd212e14fe51694b9c0e0fddf31f975f..0000000000000000000000000000000000000000
Binary files a/test/fixtures/shared-memory.wasm and /dev/null differ
diff --git a/test/fixtures/simple.wasm b/test/fixtures/simple.wasm
deleted file mode 100644
index 357f72da7a0db8add83699082fd51d46bf3352fb..0000000000000000000000000000000000000000
Binary files a/test/fixtures/simple.wasm and /dev/null differ
diff --git a/test/fixtures/source-map/enclosing-call-site-min.js b/test/fixtures/source-map/enclosing-call-site-min.js
new file mode 100644
index 0000000000000000000000000000000000000000..45b7ed2b219b867c0080b9527306be8c4ed70df0
--- /dev/null
+++ b/test/fixtures/source-map/enclosing-call-site-min.js
@@ -0,0 +1,3 @@
+var functionA=function(){functionB()};function functionB(){functionC()}var functionC=function(){functionD()},functionD=function(){if(0<Math.random())throw Error("an error!");},thrower=functionA;try{functionA()}catch(a){throw a;};
+//# sourceMappingURL=enclosing-call-site.js.map
+
diff --git a/test/fixtures/source-map/enclosing-call-site.js b/test/fixtures/source-map/enclosing-call-site.js
new file mode 100644
index 0000000000000000000000000000000000000000..d00041506fad48d460d2a0b1b82d4a03533c0fa2
--- /dev/null
+++ b/test/fixtures/source-map/enclosing-call-site.js
@@ -0,0 +1,27 @@
+const functionA = () => {
+  functionB()
+}
+
+function functionB() {
+  functionC()
+}
+
+const functionC = () => {
+  functionD()
+}
+
+const functionD = () => {
+  (function functionE () {
+    if (Math.random() > 0) {
+      throw new Error('an error!')
+    }
+  })()
+}
+
+const thrower = functionA
+
+try {
+  thrower()
+} catch (err) {
+  throw err
+}
diff --git a/test/fixtures/source-map/enclosing-call-site.js.map b/test/fixtures/source-map/enclosing-call-site.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..d0c785f26091ccf41fcd8df93db13ddb83808b51
--- /dev/null
+++ b/test/fixtures/source-map/enclosing-call-site.js.map
@@ -0,0 +1,8 @@
+{
+"version":3,
+"file":"enclosing-call-site-min.js",
+"lineCount":1,
+"mappings":"AAAA,IAAMA,UAAYA,QAAA,EAAM,CACtBC,SAAA,EADsB,CAIxBA,SAASA,UAAS,EAAG,CACnBC,SAAA,EADmB,CAIrB,IAAMA,UAAYA,QAAA,EAAM,CACtBC,SAAA,EADsB,CAAxB,CAIMA,UAAYA,QAAA,EAAM,CAEpB,GAAoB,CAApB,CAAIC,IAAA,CAAKC,MAAL,EAAJ,CACE,KAAUC,MAAJ,CAAU,WAAV,CAAN,CAHkB,CAJxB,CAYMC,QAAUP,SAEhB,IAAI,CACFO,SAAA,EADE,CAEF,MAAOC,CAAP,CAAY,CACZ,KAAMA,EAAN,CADY;",
+"sources":["enclosing-call-site.js"],
+"names":["functionA","functionB","functionC","functionD","Math","random","Error","thrower","err"]
+}
diff --git a/test/fixtures/source-map/esm-export-missing-module.mjs b/test/fixtures/source-map/esm-export-missing-module.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/test/fixtures/source-map/esm-export-missing-module.mjs.map b/test/fixtures/source-map/esm-export-missing-module.mjs.map
new file mode 100644
index 0000000000000000000000000000000000000000..17417c928dc04d2c6248b9ab95b90e06fe2434a8
--- /dev/null
+++ b/test/fixtures/source-map/esm-export-missing-module.mjs.map
@@ -0,0 +1 @@
+{"version":3,"file":"esm-export-missing-module.esm","sourceRoot":"","sources":["./exm-export-missing-module.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,SAAS;AAEzB,CAAC"}
\ No newline at end of file
diff --git a/test/fixtures/source-map/esm-export-missing.mjs b/test/fixtures/source-map/esm-export-missing.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..4bda755a86b38926865db7d645903cb728fdb37c
--- /dev/null
+++ b/test/fixtures/source-map/esm-export-missing.mjs
@@ -0,0 +1,2 @@
+import { Something } from './esm-export-missing-module.mjs';
+//# sourceMappingURL=esm-export-missing.mjs.map
diff --git a/test/fixtures/source-map/esm-export-missing.mjs.map b/test/fixtures/source-map/esm-export-missing.mjs.map
new file mode 100644
index 0000000000000000000000000000000000000000..2d1d482dc97083713b5876fc7bef5308004abb82
--- /dev/null
+++ b/test/fixtures/source-map/esm-export-missing.mjs.map
@@ -0,0 +1 @@
+{"version":3,"file":"esm-export-missing.ts","sourceRoot":"","sources":["./esm-export-missing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC"}
\ No newline at end of file
diff --git a/test/fixtures/source-map/esm-export-missing.ts b/test/fixtures/source-map/esm-export-missing.ts
new file mode 100644
index 0000000000000000000000000000000000000000..14797c69feaebcaad4c918a831ba3093cc874c68
--- /dev/null
+++ b/test/fixtures/source-map/esm-export-missing.ts
@@ -0,0 +1,3 @@
+
+import { Something } from './exm-export-missing-module.mjs';
+console.info(Something);
diff --git a/test/fixtures/source-map/icu.js b/test/fixtures/source-map/icu.js
new file mode 100644
index 0000000000000000000000000000000000000000..a29f188ae86189159d550c9c292d21d57de13a6b
--- /dev/null
+++ b/test/fixtures/source-map/icu.js
@@ -0,0 +1,13 @@
+const React = {
+  createElement: () => {
+    "あ 🐕 🐕", function (e) {
+      throw e;
+    }(Error("an error"));
+  }
+};
+const profile = /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("img", {
+  src: "avatar.png",
+  className: "profile"
+}), /*#__PURE__*/React.createElement("h3", null, ["hello"]));
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImljdS5qc3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxLQUFLLEdBQUc7QUFDWixFQUFBLGFBQWEsRUFBRSxNQUFNO0FBQ2xCO0FBQUE7QUFBQSxNQUFpQixLQUFLLENBQUMsVUFBRCxDQUF0QixDQUFEO0FBQ0Q7QUFIVyxDQUFkO0FBTUEsTUFBTSxPQUFPLGdCQUNYLDhDQUNFO0FBQUssRUFBQSxHQUFHLEVBQUMsWUFBVDtBQUFzQixFQUFBLFNBQVMsRUFBQztBQUFoQyxFQURGLGVBRUUsZ0NBQUssQ0FBQyxPQUFELENBQUwsQ0FGRixDQURGIiwiZmlsZSI6InN0ZG91dCIsInNvdXJjZXNDb250ZW50IjpbImNvbnN0IFJlYWN0ID0ge1xuICBjcmVhdGVFbGVtZW50OiAoKSA9PiB7XG4gICAgKFwi44GCIPCfkJUg8J+QlVwiLCB0aHJvdyBFcnJvcihcImFuIGVycm9yXCIpKTtcbiAgfVxufTtcblxuY29uc3QgcHJvZmlsZSA9IChcbiAgPGRpdj5cbiAgICA8aW1nIHNyYz1cImF2YXRhci5wbmdcIiBjbGFzc05hbWU9XCJwcm9maWxlXCIgLz5cbiAgICA8aDM+e1tcImhlbGxvXCJdfTwvaDM+XG4gIDwvZGl2PlxuKTtcbiJdfQ==
diff --git a/test/fixtures/source-map/icu.jsx b/test/fixtures/source-map/icu.jsx
new file mode 100644
index 0000000000000000000000000000000000000000..45325058b51222bf28a0bc82b4f3e15293ab66ee
--- /dev/null
+++ b/test/fixtures/source-map/icu.jsx
@@ -0,0 +1,12 @@
+const React = {
+  createElement: () => {
+    ("あ 🐕 🐕", throw Error("an error"));
+  }
+};
+
+const profile = (
+  <div>
+    <img src="avatar.png" className="profile" />
+    <h3>{["hello"]}</h3>
+  </div>
+);
diff --git a/test/fixtures/source-map/tabs.coffee b/test/fixtures/source-map/tabs.coffee
new file mode 100644
index 0000000000000000000000000000000000000000..abc5baab636e8af8e91d27d1ba7b08f3fceb5c38
--- /dev/null
+++ b/test/fixtures/source-map/tabs.coffee
@@ -0,0 +1,29 @@
+# Assignment:
+number   = 42
+opposite = true
+
+# Conditions:
+number = -42 if opposite
+
+# Functions:
+square = (x) -> x * x
+
+# Arrays:
+list = [1, 2, 3, 4, 5]
+
+# Objects:
+math =
+	root:   Math.sqrt
+	square: square
+	cube:   (x) -> x * square x
+
+# Splats:
+race = (winner, runners...) ->
+	print winner, runners
+
+# Existence:
+if true
+	alert "I knew it!"
+
+# Array comprehensions:
+cubes = (math.cube num for num in list)
diff --git a/test/fixtures/source-map/tabs.js b/test/fixtures/source-map/tabs.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e8ebf149dfd16c9aca507ee98487c45a26f061e
--- /dev/null
+++ b/test/fixtures/source-map/tabs.js
@@ -0,0 +1,56 @@
+// Generated by CoffeeScript 2.5.1
+(function() {
+  // Assignment:
+  var cubes, list, math, num, number, opposite, race, square;
+
+  number = 42;
+
+  opposite = true;
+
+  if (opposite) {
+    // Conditions:
+    number = -42;
+  }
+
+  // Functions:
+  square = function(x) {
+    return x * x;
+  };
+
+  // Arrays:
+  list = [1, 2, 3, 4, 5];
+
+  // Objects:
+  math = {
+    root: Math.sqrt,
+    square: square,
+    cube: function(x) {
+      return x * square(x);
+    }
+  };
+
+  // Splats:
+  race = function(winner, ...runners) {
+    return print(winner, runners);
+  };
+
+  // Existence:
+  if (true) {
+    alert("I knew it!");
+  }
+
+  // Array comprehensions:
+  cubes = (function() {
+    var i, len, results;
+    results = [];
+    for (i = 0, len = list.length; i < len; i++) {
+      num = list[i];
+      results.push(math.cube(num));
+    }
+    return results;
+  })();
+
+}).call(this);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFicy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRhYnMuY29mZmVlIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBYTtFQUFBO0FBQUEsTUFBQSxLQUFBLEVBQUEsSUFBQSxFQUFBLElBQUEsRUFBQSxHQUFBLEVBQUEsTUFBQSxFQUFBLFFBQUEsRUFBQSxJQUFBLEVBQUE7O0VBQ2IsTUFBQSxHQUFXOztFQUNYLFFBQUEsR0FBVzs7RUFHWCxJQUFnQixRQUFoQjs7SUFBQSxNQUFBLEdBQVMsQ0FBQyxHQUFWO0dBTGE7OztFQVFiLE1BQUEsR0FBUyxRQUFBLENBQUMsQ0FBRCxDQUFBO1dBQU8sQ0FBQSxHQUFJO0VBQVgsRUFSSTs7O0VBV2IsSUFBQSxHQUFPLENBQUMsQ0FBRCxFQUFJLENBQUosRUFBTyxDQUFQLEVBQVUsQ0FBVixFQUFhLENBQWIsRUFYTTs7O0VBY2IsSUFBQSxHQUNDO0lBQUEsSUFBQSxFQUFRLElBQUksQ0FBQyxJQUFiO0lBQ0EsTUFBQSxFQUFRLE1BRFI7SUFFQSxJQUFBLEVBQVEsUUFBQSxDQUFDLENBQUQsQ0FBQTthQUFPLENBQUEsR0FBSSxNQUFBLENBQU8sQ0FBUDtJQUFYO0VBRlIsRUFmWTs7O0VBb0JiLElBQUEsR0FBTyxRQUFBLENBQUMsTUFBRCxFQUFBLEdBQVMsT0FBVCxDQUFBO1dBQ04sS0FBQSxDQUFNLE1BQU4sRUFBYyxPQUFkO0VBRE0sRUFwQk07OztFQXdCYixJQUFHLElBQUg7SUFDQyxLQUFBLENBQU0sWUFBTixFQUREO0dBeEJhOzs7RUE0QmIsS0FBQTs7QUFBUztJQUFBLEtBQUEsc0NBQUE7O21CQUFBLElBQUksQ0FBQyxJQUFMLENBQVUsR0FBVjtJQUFBLENBQUE7OztBQTVCSSIsInNvdXJjZXNDb250ZW50IjpbIiMgQXNzaWdubWVudDpcbm51bWJlciAgID0gNDJcbm9wcG9zaXRlID0gdHJ1ZVxuXG4jIENvbmRpdGlvbnM6XG5udW1iZXIgPSAtNDIgaWYgb3Bwb3NpdGVcblxuIyBGdW5jdGlvbnM6XG5zcXVhcmUgPSAoeCkgLT4geCAqIHhcblxuIyBBcnJheXM6XG5saXN0ID0gWzEsIDIsIDMsIDQsIDVdXG5cbiMgT2JqZWN0czpcbm1hdGggPVxuXHRyb290OiAgIE1hdGguc3FydFxuXHRzcXVhcmU6IHNxdWFyZVxuXHRjdWJlOiAgICh4KSAtPiB4ICogc3F1YXJlIHhcblxuIyBTcGxhdHM6XG5yYWNlID0gKHdpbm5lciwgcnVubmVycy4uLikgLT5cblx0cHJpbnQgd2lubmVyLCBydW5uZXJzXG5cbiMgRXhpc3RlbmNlOlxuaWYgdHJ1ZVxuXHRhbGVydCBcIkkga25ldyBpdCFcIlxuXG4jIEFycmF5IGNvbXByZWhlbnNpb25zOlxuY3ViZXMgPSAobWF0aC5jdWJlIG51bSBmb3IgbnVtIGluIGxpc3QpXG4iXX0=
+//# sourceURL=/Users/bencoe/oss/coffee-script-test/tabs.coffee
diff --git a/test/fixtures/source-map/throw-on-require-entry.js b/test/fixtures/source-map/throw-on-require-entry.js
new file mode 100644
index 0000000000000000000000000000000000000000..94b14810a52ef1aeb511a2c13774762c2e168d6c
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require-entry.js
@@ -0,0 +1,4 @@
+"use strict";
+exports.__esModule = true;
+require("./throw-on-require");
+//# sourceMappingURL=throw-on-require-entry.js.map
diff --git a/test/fixtures/source-map/throw-on-require-entry.js.map b/test/fixtures/source-map/throw-on-require-entry.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..a5f0ca2253fe827ecab64e53e1101bc97a463e04
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require-entry.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"throw-on-require-entry.js","sourceRoot":"","sources":["throw-on-require-entry.ts"],"names":[],"mappings":";;AAAA,8BAA2B"}
\ No newline at end of file
diff --git a/test/fixtures/source-map/throw-on-require.js b/test/fixtures/source-map/throw-on-require.js
new file mode 100644
index 0000000000000000000000000000000000000000..5654f2bfb917ab80b20ebb9c1dfee2d8aac56329
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require.js
@@ -0,0 +1,15 @@
+var ATrue;
+(function (ATrue) {
+    ATrue[ATrue["IsTrue"] = 1] = "IsTrue";
+    ATrue[ATrue["IsFalse"] = 0] = "IsFalse";
+})(ATrue || (ATrue = {}));
+if (false) {
+    console.info('unreachable');
+}
+else if (true) {
+    throw Error('throw early');
+}
+else {
+    console.info('unreachable');
+}
+//# sourceMappingURL=throw-on-require.js.map
\ No newline at end of file
diff --git a/test/fixtures/source-map/throw-on-require.js.map b/test/fixtures/source-map/throw-on-require.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..94d0df9c03abbdbfb02484bf5be5ceba1efb2be1
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"throw-on-require.js","sourceRoot":"","sources":["throw-on-require.ts"],"names":[],"mappings":"AAAA,IAAK,KAGJ;AAHD,WAAK,KAAK;IACR,qCAAU,CAAA;IACV,uCAAW,CAAA;AACb,CAAC,EAHI,KAAK,KAAL,KAAK,QAGT;AAED,IAAI,KAAK,EAAE;IACT,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;CAC5B;KAAM,IAAI,IAAI,EAAE;IACf,MAAM,KAAK,CAAC,aAAa,CAAC,CAAA;CAC3B;KAAM;IACL,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;CAC5B"}
\ No newline at end of file
diff --git a/test/fixtures/source-map/throw-on-require.ts b/test/fixtures/source-map/throw-on-require.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4aa570302778f439ed0a52c6be4a69951de00484
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require.ts
@@ -0,0 +1,12 @@
+enum ATrue {
+  IsTrue = 1,
+  IsFalse = 0
+}
+ 
+if (false) {
+  console.info('unreachable')
+} else if (true) {
+  throw Error('throw early')
+} else {
+  console.info('unreachable')
+}
diff --git a/test/fixtures/source-map/throw-string-original.js b/test/fixtures/source-map/throw-string-original.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe177b669fdf7eca3de44f97e00053e1d4c6e13a
--- /dev/null
+++ b/test/fixtures/source-map/throw-string-original.js
@@ -0,0 +1,8 @@
+/*
+ * comments dropped by uglify.
+ */
+function Hello() {
+  throw 'goodbye';
+}
+
+Hello();
diff --git a/test/fixtures/source-map/throw-string.js b/test/fixtures/source-map/throw-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a810e12f5f5a9e4495ef20d867d32e98a89da67
--- /dev/null
+++ b/test/fixtures/source-map/throw-string.js
@@ -0,0 +1,2 @@
+function Hello(){throw"goodbye"}Hello();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRocm93LXN0cmluZy1vcmlnaW5hbC5qcyJdLCJuYW1lcyI6WyJIZWxsbyJdLCJtYXBwaW5ncyI6IkFBR0EsU0FBU0EsUUFDUCxLQUFNLFVBR1JBIn0=
diff --git a/test/fixtures/source-map/webpack.js b/test/fixtures/source-map/webpack.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8bf26ab6f6f59a1f9e2a9f0fc57e8c7941403ce
--- /dev/null
+++ b/test/fixtures/source-map/webpack.js
@@ -0,0 +1,2 @@
+!function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=0)}([function(e,t){const r=()=>{n()},n=()=>{o()},o=()=>{throw new Error("oh no!")};r()}]);
+//# sourceMappingURL=webpack.js.map
diff --git a/test/fixtures/source-map/webpack.js.map b/test/fixtures/source-map/webpack.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..c0849ff6f0a3baa964977c95ea9f569b2e6b5778
--- /dev/null
+++ b/test/fixtures/source-map/webpack.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./webpack.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","functionB","functionC","functionD","Error"],"mappings":"aACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QAKfF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,oBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,iBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,GAIjBlC,EAAoBA,EAAoBmC,EAAI,G,gBClFrD,MAIMC,EAAY,KAChBC,KAGIA,EAAY,KAChBC,KAGIA,EAAY,KAChB,MAAM,IAAIC,MAAM,WAZhBH","file":"webpack.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n","const functionA = () => {\n  functionB()\n}\n\nconst functionB = () => {\n  functionC()\n}\n\nconst functionC = () => {\n  functionD()\n}\n\nconst functionD = () => {\n  throw new Error('oh no!')\n}\n\nfunctionA()\n"],"sourceRoot":""}
\ No newline at end of file
diff --git a/test/fixtures/test-resolution-inspect-brk-resolver.js b/test/fixtures/test-resolution-inspect-brk-resolver.js
index fdfb5ca5b170c2624d8dc1976be129a9fed62a13..b5569e69fcf698f0256f1067d3d4594176c9efbc 100644
--- a/test/fixtures/test-resolution-inspect-brk-resolver.js
+++ b/test/fixtures/test-resolution-inspect-brk-resolver.js
@@ -1,5 +1,4 @@
 'use strict';
-// eslint-disable-next-line no-unused-vars
 const common = require('../common');
 
 require.extensions['.ext'] = require.extensions['.js'];
diff --git a/test/fixtures/utf8-bom-shebang.js b/test/fixtures/utf8-bom-shebang.js
deleted file mode 100644
index d0495f04552d4127d0a12b2075cc9d917262950b..0000000000000000000000000000000000000000
--- a/test/fixtures/utf8-bom-shebang.js
+++ /dev/null
@@ -1,2 +0,0 @@
-#!shebang
-module.exports = 42;
\ No newline at end of file
diff --git a/test/fixtures/worker-preload.js b/test/fixtures/worker-preload.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e5c4a31d2f20e71a944b67123087c8c836a1ab0
--- /dev/null
+++ b/test/fixtures/worker-preload.js
@@ -0,0 +1,9 @@
+const {
+  Worker,
+  workerData,
+  threadId
+} = require('worker_threads');
+
+if (threadId < 2) {
+  new Worker('1 + 1', { eval: true });
+}
diff --git a/test/fixtures/workload/bounded.js b/test/fixtures/workload/bounded.js
new file mode 100644
index 0000000000000000000000000000000000000000..ddf288d034bd1a04fa166cc325897b3e3788adfb
--- /dev/null
+++ b/test/fixtures/workload/bounded.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const total = parseInt(process.env.TEST_ALLOCATION) || 5000;
+const chunk = parseInt(process.env.TEST_CHUNK) || 1000;
+const cleanInterval = parseInt(process.env.TEST_CLEAN_INTERVAL) || 100;
+let count = 0;
+let arr = [];
+function runAllocation() {
+  count++;
+  if (count < total) {
+    if (count % cleanInterval === 0) {
+      arr.splice(0, arr.length);
+      setImmediate(runAllocation);
+    } else {
+      const str = JSON.stringify(process.config).slice(0, chunk);
+      arr.push(str);
+      setImmediate(runAllocation);
+    }
+  }
+}
+
+setImmediate(runAllocation);
diff --git a/test/fixtures/workload/grow-worker.js b/test/fixtures/workload/grow-worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..092d8f27751fc2fa75d925708a4564f2bc84caf3
--- /dev/null
+++ b/test/fixtures/workload/grow-worker.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const { Worker } = require('worker_threads');
+const path = require('path');
+const max_snapshots = parseInt(process.env.TEST_SNAPSHOTS) || 1;
+new Worker(path.join(__dirname, 'grow.js'), {
+  execArgv: [
+    `--heapsnapshot-near-heap-limit=${max_snapshots}`,
+  ],
+  resourceLimits: {
+    maxOldGenerationSizeMb:
+      parseInt(process.env.TEST_OLD_SPACE_SIZE) || 20
+  }
+});
diff --git a/test/fixtures/workload/grow.js b/test/fixtures/workload/grow.js
new file mode 100644
index 0000000000000000000000000000000000000000..9ac0139b332b52e71e5327da129375554e3a04d1
--- /dev/null
+++ b/test/fixtures/workload/grow.js
@@ -0,0 +1,12 @@
+'use strict';
+
+const chunk = parseInt(process.env.TEST_CHUNK) || 1000;
+
+let arr = [];
+function runAllocation() {
+  const str = JSON.stringify(process.config).slice(0, chunk);
+  arr.push(str);
+  setImmediate(runAllocation);
+}
+
+setImmediate(runAllocation);
diff --git a/test/fixtures/wpt/FileAPI/BlobURL/support/file_test2.txt b/test/fixtures/wpt/FileAPI/BlobURL/support/file_test2.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/test/fixtures/wpt/FileAPI/BlobURL/test2-manual.html b/test/fixtures/wpt/FileAPI/BlobURL/test2-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..07fb27ef8af10b130fdc52c3798e6ce2e999dcc0
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/BlobURL/test2-manual.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Blob and File reference URL Test(2)</title>
+    <link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#convenienceAPI">
+    <link rel=author title="Breezewish" href="mailto:me@breeswish.org">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+</head>
+<body>
+    <form name="upload">
+        <input type="file" id="fileChooser"><br><input type="button" id="start" value="start">
+    </form>
+
+    <div>
+        <p>Test steps:</p>
+        <ol>
+            <li>Download the <a href="support/file_test2.txt">file</a>.</li>
+            <li>Select the file in the file inputbox.</li>
+            <li>Delete the file.</li>
+            <li>Click the 'start' button.</li>
+        </ol>
+    </div>
+
+    <div id="log"></div>
+
+    <script>
+
+        var fileChooser = document.querySelector('#fileChooser');
+
+        setup({explicit_done: true});
+        setup({explicit_timeout: true});
+
+        on_event(document.querySelector('#start'), 'click', function() {
+
+            async_test(function(t) {
+
+                var url = URL.createObjectURL(fileChooser.files[0]);
+
+                var xhr = new XMLHttpRequest();
+                xhr.open('GET', url, true);
+                xhr.onreadystatechange = t.step_func(function() {
+                    switch (xhr.readyState) {
+                    case xhr.DONE:
+                        assert_equals(xhr.status, 500, 'status code should be 500.');
+                        t.done();
+                        return;
+                    }
+                });
+
+                xhr.send();
+
+            }, 'Check whether the browser response 500 in XHR if the selected file which File/Blob URL refered is not found');
+
+            done();
+
+        });
+
+    </script>
+</body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/FileReader/progress_event_bubbles_cancelable.html b/test/fixtures/wpt/FileAPI/FileReader/progress_event_bubbles_cancelable.html
new file mode 100644
index 0000000000000000000000000000000000000000..6a03243f934081b18cf456d741c3fc2d1660f9c3
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/FileReader/progress_event_bubbles_cancelable.html
@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>File API Test: Progress Event - bubbles, cancelable</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="help" href="http://www.w3.org/TR/FileAPI/#events">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="log"></div>
+<script>
+  async_test(function(){
+    var blob = new Blob(["TEST"]);
+    var reader = new FileReader();
+
+    reader.onloadstart = this.step_func(function(evt) {
+      assert_false(evt.bubbles, "The bubbles must be false when the event is dispatched");
+      assert_false(evt.cancelable, "The cancelable must be false when the event is dispatched");
+    });
+
+    reader.onload = this.step_func(function(evt) {
+      assert_false(evt.bubbles, "The bubbles must be false when the event is dispatched");
+      assert_false(evt.cancelable, "The cancelable must be false when the event is dispatched");
+    });
+
+    reader.onloadend = this.step_func(function(evt) {
+      assert_false(evt.bubbles, "The bubbles must be false when the event is dispatched");
+      assert_false(evt.cancelable, "The cancelable must be false when the event is dispatched");
+      this.done();
+    });
+
+    reader.readAsText(blob);
+  }, "Check the values of bubbles and cancelable are false when the progress event is dispatched");
+</script>
+
diff --git a/test/fixtures/wpt/FileAPI/FileReader/support/file_test1.txt b/test/fixtures/wpt/FileAPI/FileReader/support/file_test1.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/test/fixtures/wpt/FileAPI/FileReader/test_errors-manual.html b/test/fixtures/wpt/FileAPI/FileReader/test_errors-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..b8c3f84d2bf23ae675f20057021b0908cee23017
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/FileReader/test_errors-manual.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>FileReader Errors Test</title>
+    <link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#convenienceAPI">
+    <link rel=author title="Breezewish" href="mailto:me@breeswish.org">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+</head>
+<body>
+    <form name="upload">
+        <input type="file" id="fileChooser"><br><input type="button" id="start" value="start">
+    </form>
+
+    <div>
+        <p>Test steps:</p>
+        <ol>
+            <li>Download the <a href="support/file_test1.txt">file</a>.</li>
+            <li>Select the file in the file inputbox.</li>
+            <li>Delete the file.</li>
+            <li>Click the 'start' button.</li>
+        </ol>
+    </div>
+
+    <div id="log"></div>
+
+    <script>
+
+        var fileChooser = document.querySelector('#fileChooser');
+
+        setup({explicit_done: true});
+        setup({explicit_timeout: true});
+
+        on_event(fileChooser, 'change', function() {
+
+            async_test(function(t) {
+
+                var reader = new FileReader();
+                reader.readAsArrayBuffer(fileChooser.files[0]);
+
+                reader.onloadend = t.step_func_done(function(event) {
+                    assert_equals(event.target.readyState, FileReader.DONE);
+                    assert_equals(reader.error, null);
+                });
+
+            }, 'FileReader.error should be null if there are no errors when reading');
+
+        });
+
+        on_event(document.querySelector('#start'), 'click', function() {
+
+            async_test(function(t) {
+
+                var reader = new FileReader();
+                reader.readAsArrayBuffer(fileChooser.files[0]);
+
+                reader.onloadend = t.step_func_done(function(event) {
+                    assert_equals(event.target.readyState, FileReader.DONE);
+                    assert_equals(reader.error.code, 8);
+                    assert_true(reader.error instanceof DOMException);
+                });
+
+            }, 'FileReader.error should be NOT_FOUND_ERR if the file is not found when reading');
+
+            done();
+
+        });
+
+    </script>
+</body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/FileReader/test_notreadableerrors-manual.html b/test/fixtures/wpt/FileAPI/FileReader/test_notreadableerrors-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..46d73598a0f91a52e2faa364a665a5f3d871ab78
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/FileReader/test_notreadableerrors-manual.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>FileReader NotReadableError Test</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="help" href="https://w3c.github.io/FileAPI/#dfn-error-codes">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<form name="upload">
+  <input type="file" id="fileChooser"><br><input type="button" id="start" value="start">
+</form>
+
+<div>
+  <p>Test steps:</p>
+  <ol>
+    <li>Download the <a href="support/file_test1.txt">file</a>.</li>
+    <li>Select the file in the file inputbox.</li>
+    <li>Delete the file's readable permission.</li>
+    <li>Click the 'start' button.</li>
+  </ol>
+</div>
+
+<script>
+
+  const fileChooser = document.querySelector('#fileChooser');
+
+  setup({explicit_done: true});
+  setup({explicit_timeout: true});
+
+  on_event(document.querySelector('#start'), 'click', () => {
+    async_test(t => {
+      const reader = new FileReader();
+      reader.readAsArrayBuffer(fileChooser.files[0]);
+      reader.onloadend = t.step_func_done(event => {
+        assert_equals(event.target.readyState, FileReader.DONE);
+        assert_equals(reader.error.name, "NotReadableError");
+      });
+    }, 'FileReader.error should be NotReadableError if the file is unreadable');
+    done();
+  });
+
+</script>
+
diff --git a/test/fixtures/wpt/FileAPI/FileReader/test_securityerrors-manual.html b/test/fixtures/wpt/FileAPI/FileReader/test_securityerrors-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..add93ed69d139a5118e05ffd8ea38f1b2ca81356
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/FileReader/test_securityerrors-manual.html
@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>FileReader SecurityError Test</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="help" href="https://w3c.github.io/FileAPI/#dfn-error-codes">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<form name="upload">
+  <input type="file" id="fileChooser"><br><input type="button" id="start" value="start">
+</form>
+
+<div>
+  <p>Test steps:</p>
+  <ol>
+    <li>Select a system sensitive file (e.g. files in /usr/bin, password files,
+        and other native operating system executables) in the file inputbox.</li>
+    <li>Click the 'start' button.</li>
+    </ol>
+</div>
+
+<script>
+
+  const fileChooser = document.querySelector('#fileChooser');
+
+  setup({explicit_done: true});
+  setup({explicit_timeout: true});
+
+  on_event(document.querySelector('#start'), 'click', () => {
+    async_test(t => {
+      const reader = new FileReader();
+      reader.readAsArrayBuffer(fileChooser.files[0]);
+      reader.onloadend = t.step_func_done(event => {
+        assert_equals(event.target.readyState, FileReader.DONE);
+        assert_equals(reader.error.name, "SecurityError");
+      });
+    }, 'FileReader.error should be SECURITY_ERROR if the file is a system sensitive file');
+    done();
+  });
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/FileReader/workers.html b/test/fixtures/wpt/FileAPI/FileReader/workers.html
new file mode 100644
index 0000000000000000000000000000000000000000..8e114eeaf86ff55e6944bff0b17a099f6d8a02f8
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/FileReader/workers.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+
+async_test(t => {
+  function workerCode() {
+    close();
+    var blob = new Blob([123]);
+    var fr = new FileReader();
+    fr.readAsText(blob);
+    fr.abort()
+    fr.readAsArrayBuffer(blob);
+    postMessage(true);
+  }
+
+  var workerBlob = new Blob([workerCode.toString() + ";workerCode();"], {type:"application/javascript"});
+
+  var w = new Worker(URL.createObjectURL(workerBlob));
+  w.onmessage = function(e) {
+    assert_true(e.data, "FileReader created during worker shutdown.");
+    t.done();
+  }
+}, 'FileReader created after a worker self.close()');
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/FileReaderSync.worker.js b/test/fixtures/wpt/FileAPI/FileReaderSync.worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a0222f31266eaf65927efe0a5193cdbcb80a9
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/FileReaderSync.worker.js
@@ -0,0 +1,56 @@
+importScripts("/resources/testharness.js");
+
+var blob, empty_blob, readerSync;
+setup(() => {
+    readerSync = new FileReaderSync();
+    blob = new Blob(["test"]);
+    empty_blob = new Blob();
+});
+
+test(() => {
+    assert_true(readerSync instanceof FileReaderSync);
+}, "Interface");
+
+test(() => {
+    var text = readerSync.readAsText(blob);
+    assert_equals(text, "test");
+}, "readAsText");
+
+test(() => {
+    var text = readerSync.readAsText(empty_blob);
+    assert_equals(text, "");
+}, "readAsText with empty blob");
+
+test(() => {
+    var data = readerSync.readAsDataURL(blob);
+    assert_equals(data.indexOf("data:"), 0);
+}, "readAsDataURL");
+
+test(() => {
+    var data = readerSync.readAsDataURL(empty_blob);
+    assert_equals(data.indexOf("data:"), 0);
+}, "readAsDataURL with empty blob");
+
+test(() => {
+    var data = readerSync.readAsBinaryString(blob);
+    assert_equals(data, "test");
+}, "readAsBinaryString");
+
+test(() => {
+    var data = readerSync.readAsBinaryString(empty_blob);
+    assert_equals(data, "");
+}, "readAsBinaryString with empty blob");
+
+test(() => {
+    var data = readerSync.readAsArrayBuffer(blob);
+    assert_true(data instanceof ArrayBuffer);
+    assert_equals(data.byteLength, "test".length);
+}, "readAsArrayBuffer");
+
+test(() => {
+    var data = readerSync.readAsArrayBuffer(empty_blob);
+    assert_true(data instanceof ArrayBuffer);
+    assert_equals(data.byteLength, 0);
+}, "readAsArrayBuffer with empty blob");
+
+done();
diff --git a/test/fixtures/wpt/FileAPI/META.yml b/test/fixtures/wpt/FileAPI/META.yml
new file mode 100644
index 0000000000000000000000000000000000000000..506a59fec1eb33661658850254344e264c323c2e
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/META.yml
@@ -0,0 +1,6 @@
+spec: https://w3c.github.io/FileAPI/
+suggested_reviewers:
+  - inexorabletash
+  - zqzhang
+  - jdm
+  - mkruisselbrink
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-array-buffer.any.js b/test/fixtures/wpt/FileAPI/blob/Blob-array-buffer.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..2310646e5fdeab300bcea66e4035adbdf3651685
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-array-buffer.any.js
@@ -0,0 +1,45 @@
+// META: title=Blob Array Buffer
+// META: script=../support/Blob.js
+'use strict';
+
+promise_test(async () => {
+  const input_arr = new TextEncoder().encode("PASS");
+  const blob = new Blob([input_arr]);
+  const array_buffer = await blob.arrayBuffer();
+  assert_true(array_buffer instanceof ArrayBuffer);
+  assert_equals_typed_array(new Uint8Array(array_buffer), input_arr);
+}, "Blob.arrayBuffer()")
+
+promise_test(async () => {
+  const input_arr = new TextEncoder().encode("");
+  const blob = new Blob([input_arr]);
+  const array_buffer = await blob.arrayBuffer();
+  assert_true(array_buffer instanceof ArrayBuffer);
+  assert_equals_typed_array(new Uint8Array(array_buffer), input_arr);
+}, "Blob.arrayBuffer() empty Blob data")
+
+promise_test(async () => {
+  const input_arr = new TextEncoder().encode("\u08B8\u000a");
+  const blob = new Blob([input_arr]);
+  const array_buffer = await blob.arrayBuffer();
+  assert_equals_typed_array(new Uint8Array(array_buffer), input_arr);
+}, "Blob.arrayBuffer() non-ascii input")
+
+promise_test(async () => {
+  const input_arr = [8, 241, 48, 123, 151];
+  const typed_arr = new Uint8Array(input_arr);
+  const blob = new Blob([typed_arr]);
+  const array_buffer = await blob.arrayBuffer();
+  assert_equals_typed_array(new Uint8Array(array_buffer), typed_arr);
+}, "Blob.arrayBuffer() non-unicode input")
+
+promise_test(async () => {
+  const input_arr = new TextEncoder().encode("PASS");
+  const blob = new Blob([input_arr]);
+  const array_buffer_results = await Promise.all([blob.arrayBuffer(),
+      blob.arrayBuffer(), blob.arrayBuffer()]);
+  for (let array_buffer of array_buffer_results) {
+    assert_true(array_buffer instanceof ArrayBuffer);
+    assert_equals_typed_array(new Uint8Array(array_buffer), input_arr);
+  }
+}, "Blob.arrayBuffer() concurrent reads")
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-constructor-dom.window.js b/test/fixtures/wpt/FileAPI/blob/Blob-constructor-dom.window.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fd4a43ec4bea7ad12ce6a0c95b7ea52f56637f0
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-constructor-dom.window.js
@@ -0,0 +1,53 @@
+// META: title=Blob constructor
+// META: script=../support/Blob.js
+'use strict';
+
+var test_error = {
+  name: "test",
+  message: "test error",
+};
+
+test(function() {
+  var args = [
+    document.createElement("div"),
+    window,
+  ];
+  args.forEach(function(arg) {
+    assert_throws_js(TypeError, function() {
+      new Blob(arg);
+    }, "Should throw for argument " + format_value(arg) + ".");
+  });
+}, "Passing platform objects for blobParts should throw a TypeError.");
+
+test(function() {
+  var element = document.createElement("div");
+  element.appendChild(document.createElement("div"));
+  element.appendChild(document.createElement("p"));
+  var list = element.children;
+  Object.defineProperty(list, "length", {
+    get: function() { throw test_error; }
+  });
+  assert_throws_exactly(test_error, function() {
+    new Blob(list);
+  });
+}, "A platform object that supports indexed properties should be treated as a sequence for the blobParts argument (overwritten 'length'.)");
+
+test_blob(function() {
+  var select = document.createElement("select");
+  select.appendChild(document.createElement("option"));
+  return new Blob(select);
+}, {
+  expected: "[object HTMLOptionElement]",
+  type: "",
+  desc: "Passing an platform object that supports indexed properties as the blobParts array should work (select)."
+});
+
+test_blob(function() {
+  var elm = document.createElement("div");
+  elm.setAttribute("foo", "bar");
+  return new Blob(elm.attributes);
+}, {
+  expected: "[object Attr]",
+  type: "",
+  desc: "Passing an platform object that supports indexed properties as the blobParts array should work (attributes)."
+});
\ No newline at end of file
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-constructor-endings.html b/test/fixtures/wpt/FileAPI/blob/Blob-constructor-endings.html
new file mode 100644
index 0000000000000000000000000000000000000000..04edd2a303b1359d7f00c154c9b109df3610a1c6
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-constructor-endings.html
@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Blob constructor: endings option</title>
+<link rel=help href="https://w3c.github.io/FileAPI/#constructorBlob">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+
+// Windows platforms use CRLF as the native line ending. All others use LF.
+const crlf = navigator.platform.startsWith('Win');
+const native_ending = crlf ? '\r\n' : '\n';
+
+function readBlobAsPromise(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsText(blob);
+    reader.onload = e => resolve(reader.result);
+    reader.onerror = e => reject(reader.error);
+  });
+}
+
+[
+  'transparent',
+  'native'
+].forEach(value => test(t => {
+  assert_class_string(new Blob([], {endings: value}), 'Blob',
+                      `Constructor should allow "${value}" endings`);
+}, `Valid "endings" value: ${JSON.stringify(value)}`));
+
+[
+  null,
+  '',
+  'invalidEnumValue',
+  'Transparent',
+  'NATIVE',
+  0,
+  {}
+].forEach(value => test(t => {
+  assert_throws_js(TypeError, () => new Blob([], {endings: value}),
+                   'Blob constructor should throw');
+}, `Invalid "endings" value: ${JSON.stringify(value)}`));
+
+test(t => {
+  const test_error = {name: 'test'};
+  assert_throws_exactly(
+    test_error,
+    () => new Blob([], { get endings() { throw test_error; }}),
+    'Blob constructor should propagate exceptions from "endings" property');
+}, 'Exception propagation from options');
+
+test(t => {
+  let got = false;
+  new Blob([], { get endings() { got = true; } });
+  assert_true(got, 'The "endings" property was accessed during construction.');
+}, 'The "endings" options property is used');
+
+[
+  {name: 'LF', input: '\n', native: native_ending},
+  {name: 'CR', input: '\r', native: native_ending},
+
+  {name: 'CRLF', input: '\r\n', native: native_ending},
+  {name: 'CRCR', input: '\r\r', native: native_ending.repeat(2)},
+  {name: 'LFCR', input: '\n\r', native: native_ending.repeat(2)},
+  {name: 'LFLF', input: '\n\n', native: native_ending.repeat(2)},
+
+  {name: 'CRCRLF', input: '\r\r\n', native: native_ending.repeat(2)},
+  {name: 'CRLFLF', input: '\r\n\n', native: native_ending.repeat(2)},
+  {name: 'CRLFCR', input: '\r\n\r\n', native: native_ending.repeat(2)},
+
+  {name: 'CRLFCRLF', input: '\r\n\r\n', native: native_ending.repeat(2)},
+  {name: 'LFCRLFCR', input: '\n\r\n\r', native: native_ending.repeat(3)},
+
+].forEach(testCase => {
+  promise_test(async t => {
+    const blob = new Blob([testCase.input]);
+    assert_equals(
+      await readBlobAsPromise(blob), testCase.input,
+      'Newlines should not change with endings unspecified');
+  }, `Input ${testCase.name} with endings unspecified`);
+
+  promise_test(async t => {
+    const blob = new Blob([testCase.input], {endings: 'transparent'});
+    assert_equals(
+      await readBlobAsPromise(blob), testCase.input,
+      'Newlines should not change with endings "transparent"');
+  }, `Input ${testCase.name} with endings 'transparent'`);
+
+  promise_test(async t => {
+    const blob = new Blob([testCase.input], {endings: 'native'});
+    assert_equals(
+      await readBlobAsPromise(blob), testCase.native,
+      'Newlines should match the platform with endings "native"');
+  }, `Input ${testCase.name} with endings 'native'`);
+});
+
+promise_test(async t => {
+  const blob = new Blob(['\r', '\n'], {endings: 'native'});
+  const expected = native_ending.repeat(2);
+  assert_equals(
+    await readBlobAsPromise(blob), expected,
+    'CR/LF in adjacent strings should be converted to two platform newlines');
+}, `CR/LF in adjacent input strings`);
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-constructor.any.js b/test/fixtures/wpt/FileAPI/blob/Blob-constructor.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c34d7e34b93f91b48e01dae43002a3794f0dd37
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-constructor.any.js
@@ -0,0 +1,459 @@
+// META: title=Blob constructor
+// META: script=../support/Blob.js
+'use strict';
+
+test(function() {
+  assert_true("Blob" in globalThis, "globalThis should have a Blob property.");
+  assert_equals(Blob.length, 0, "Blob.length should be 0.");
+  assert_true(Blob instanceof Function, "Blob should be a function.");
+}, "Blob interface object");
+
+// Step 1.
+test(function() {
+  var blob = new Blob();
+  assert_true(blob instanceof Blob);
+  assert_equals(String(blob), '[object Blob]');
+  assert_equals(blob.size, 0);
+  assert_equals(blob.type, "");
+}, "Blob constructor with no arguments");
+test(function() {
+  assert_throws_js(TypeError, function() { var blob = Blob(); });
+}, "Blob constructor with no arguments, without 'new'");
+test(function() {
+  var blob = new Blob;
+  assert_true(blob instanceof Blob);
+  assert_equals(blob.size, 0);
+  assert_equals(blob.type, "");
+}, "Blob constructor without brackets");
+test(function() {
+  var blob = new Blob(undefined);
+  assert_true(blob instanceof Blob);
+  assert_equals(String(blob), '[object Blob]');
+  assert_equals(blob.size, 0);
+  assert_equals(blob.type, "");
+}, "Blob constructor with undefined as first argument");
+
+// blobParts argument (WebIDL).
+test(function() {
+  var args = [
+    null,
+    true,
+    false,
+    0,
+    1,
+    1.5,
+    "FAIL",
+    new Date(),
+    new RegExp(),
+    {},
+    { 0: "FAIL", length: 1 },
+  ];
+  args.forEach(function(arg) {
+    assert_throws_js(TypeError, function() {
+      new Blob(arg);
+    }, "Should throw for argument " + format_value(arg) + ".");
+  });
+}, "Passing non-objects, Dates and RegExps for blobParts should throw a TypeError.");
+
+test_blob(function() {
+  return new Blob({
+    [Symbol.iterator]: Array.prototype[Symbol.iterator],
+  });
+}, {
+  expected: "",
+  type: "",
+  desc: "A plain object with @@iterator should be treated as a sequence for the blobParts argument."
+});
+test(t => {
+  const blob = new Blob({
+    [Symbol.iterator]() {
+      var i = 0;
+      return {next: () => [
+        {done:false, value:'ab'},
+        {done:false, value:'cde'},
+        {done:true}
+      ][i++]
+      };
+    }
+  });
+  assert_equals(blob.size, 5, 'Custom @@iterator should be treated as a sequence');
+}, "A plain object with custom @@iterator should be treated as a sequence for the blobParts argument.");
+test_blob(function() {
+  return new Blob({
+    [Symbol.iterator]: Array.prototype[Symbol.iterator],
+    0: "PASS",
+    length: 1
+  });
+}, {
+  expected: "PASS",
+  type: "",
+  desc: "A plain object with @@iterator and a length property should be treated as a sequence for the blobParts argument."
+});
+test_blob(function() {
+  return new Blob(new String("xyz"));
+}, {
+  expected: "xyz",
+  type: "",
+  desc: "A String object should be treated as a sequence for the blobParts argument."
+});
+test_blob(function() {
+  return new Blob(new Uint8Array([1, 2, 3]));
+}, {
+  expected: "123",
+  type: "",
+  desc: "A Uint8Array object should be treated as a sequence for the blobParts argument."
+});
+
+var test_error = {
+  name: "test",
+  message: "test error",
+};
+
+test(function() {
+  var obj = {
+    [Symbol.iterator]: Array.prototype[Symbol.iterator],
+    get length() { throw test_error; }
+  };
+  assert_throws_exactly(test_error, function() {
+    new Blob(obj);
+  });
+}, "The length getter should be invoked and any exceptions should be propagated.");
+
+test(function() {
+  assert_throws_exactly(test_error, function() {
+    var obj = {
+      [Symbol.iterator]: Array.prototype[Symbol.iterator],
+      length: {
+        valueOf: null,
+        toString: function() { throw test_error; }
+      }
+    };
+    new Blob(obj);
+  });
+  assert_throws_exactly(test_error, function() {
+    var obj = {
+      [Symbol.iterator]: Array.prototype[Symbol.iterator],
+      length: { valueOf: function() { throw test_error; } }
+    };
+    new Blob(obj);
+  });
+}, "ToUint32 should be applied to the length and any exceptions should be propagated.");
+
+test(function() {
+  var received = [];
+  var obj = {
+    get [Symbol.iterator]() {
+      received.push("Symbol.iterator");
+      return Array.prototype[Symbol.iterator];
+    },
+    get length() {
+      received.push("length getter");
+      return {
+        valueOf: function() {
+          received.push("length valueOf");
+          return 3;
+        }
+      };
+    },
+    get 0() {
+      received.push("0 getter");
+      return {
+        toString: function() {
+          received.push("0 toString");
+          return "a";
+        }
+      };
+    },
+    get 1() {
+      received.push("1 getter");
+      throw test_error;
+    },
+    get 2() {
+      received.push("2 getter");
+      assert_unreached("Should not call the getter for 2 if the getter for 1 threw.");
+    }
+  };
+  assert_throws_exactly(test_error, function() {
+    new Blob(obj);
+  });
+  assert_array_equals(received, [
+    "Symbol.iterator",
+    "length getter",
+    "length valueOf",
+    "0 getter",
+    "0 toString",
+    "length getter",
+    "length valueOf",
+    "1 getter",
+  ]);
+}, "Getters and value conversions should happen in order until an exception is thrown.");
+
+// XXX should add tests edge cases of ToLength(length)
+
+test(function() {
+  assert_throws_exactly(test_error, function() {
+    new Blob([{ toString: function() { throw test_error; } }]);
+  }, "Throwing toString");
+  assert_throws_exactly(test_error, function() {
+    new Blob([{ toString: undefined, valueOf: function() { throw test_error; } }]);
+  }, "Throwing valueOf");
+  assert_throws_exactly(test_error, function() {
+    new Blob([{
+      toString: function() { throw test_error; },
+      valueOf: function() { assert_unreached("Should not call valueOf if toString is present."); }
+    }]);
+  }, "Throwing toString and valueOf");
+  assert_throws_js(TypeError, function() {
+    new Blob([{toString: null, valueOf: null}]);
+  }, "Null toString and valueOf");
+}, "ToString should be called on elements of the blobParts array and any exceptions should be propagated.");
+
+test_blob(function() {
+  var arr = [
+    { toString: function() { arr.pop(); return "PASS"; } },
+    { toString: function() { assert_unreached("Should have removed the second element of the array rather than called toString() on it."); } }
+  ];
+  return new Blob(arr);
+}, {
+  expected: "PASS",
+  type: "",
+  desc: "Changes to the blobParts array should be reflected in the returned Blob (pop)."
+});
+
+test_blob(function() {
+  var arr = [
+    {
+      toString: function() {
+        if (arr.length === 3) {
+          return "A";
+        }
+        arr.unshift({
+          toString: function() {
+            assert_unreached("Should only access index 0 once.");
+          }
+        });
+        return "P";
+      }
+    },
+    {
+      toString: function() {
+        return "SS";
+      }
+    }
+  ];
+  return new Blob(arr);
+}, {
+  expected: "PASS",
+  type: "",
+  desc: "Changes to the blobParts array should be reflected in the returned Blob (unshift)."
+});
+
+test_blob(function() {
+  // https://www.w3.org/Bugs/Public/show_bug.cgi?id=17652
+  return new Blob([
+    null,
+    undefined,
+    true,
+    false,
+    0,
+    1,
+    new String("stringobject"),
+    [],
+    ['x', 'y'],
+    {},
+    { 0: "FAIL", length: 1 },
+    { toString: function() { return "stringA"; } },
+    { toString: undefined, valueOf: function() { return "stringB"; } },
+    { valueOf: function() { assert_unreached("Should not call valueOf if toString is present on the prototype."); } }
+  ]);
+}, {
+  expected: "nullundefinedtruefalse01stringobjectx,y[object Object][object Object]stringAstringB[object Object]",
+  type: "",
+  desc: "ToString should be called on elements of the blobParts array."
+});
+
+test_blob(function() {
+  return new Blob([
+    new ArrayBuffer(8)
+  ]);
+}, {
+  expected: "\0\0\0\0\0\0\0\0",
+  type: "",
+  desc: "ArrayBuffer elements of the blobParts array should be supported."
+});
+
+test_blob(function() {
+  return new Blob([
+    new Uint8Array([0x50, 0x41, 0x53, 0x53]),
+    new Int8Array([0x50, 0x41, 0x53, 0x53]),
+    new Uint16Array([0x4150, 0x5353]),
+    new Int16Array([0x4150, 0x5353]),
+    new Uint32Array([0x53534150]),
+    new Int32Array([0x53534150]),
+    new Float32Array([0xD341500000])
+  ]);
+}, {
+  expected: "PASSPASSPASSPASSPASSPASSPASS",
+  type: "",
+  desc: "Passing typed arrays as elements of the blobParts array should work."
+});
+test_blob(function() {
+  return new Blob([
+    // 0x535 3415053534150
+    // 0x535 = 0b010100110101 -> Sign = +, Exponent = 1333 - 1023 = 310
+    // 0x13415053534150 * 2**(-52)
+    // ==> 0x13415053534150 * 2**258 = 2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680
+    new Float64Array([2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680])
+  ]);
+}, {
+  expected: "PASSPASS",
+  type: "",
+  desc: "Passing a Float64Array as element of the blobParts array should work."
+});
+
+
+
+var t_ports = async_test("Passing a FrozenArray as the blobParts array should work (FrozenArray<MessagePort>).");
+t_ports.step(function() {
+    var channel = new MessageChannel();
+    channel.port2.onmessage = this.step_func(function(e) {
+        var b_ports = new Blob(e.ports);
+        assert_equals(b_ports.size, "[object MessagePort]".length);
+        this.done();
+    });
+    var channel2 = new MessageChannel();
+    channel.port1.postMessage('', [channel2.port1]);
+});
+
+test_blob(function() {
+  var blob = new Blob(['foo']);
+  return new Blob([blob, blob]);
+}, {
+  expected: "foofoo",
+  type: "",
+  desc: "Array with two blobs"
+});
+
+test_blob_binary(function() {
+  var view = new Uint8Array([0, 255, 0]);
+  return new Blob([view.buffer, view.buffer]);
+}, {
+  expected: [0, 255, 0, 0, 255, 0],
+  type: "",
+  desc: "Array with two buffers"
+});
+
+test_blob_binary(function() {
+  var view = new Uint8Array([0, 255, 0, 4]);
+  var blob = new Blob([view, view]);
+  assert_equals(blob.size, 8);
+  var view1 = new Uint16Array(view.buffer, 2);
+  return new Blob([view1, view.buffer, view1]);
+}, {
+  expected: [0, 4, 0, 255, 0, 4, 0, 4],
+  type: "",
+  desc: "Array with two bufferviews"
+});
+
+test_blob(function() {
+  var view = new Uint8Array([0]);
+  var blob = new Blob(["fo"]);
+  return new Blob([view.buffer, blob, "foo"]);
+}, {
+  expected: "\0fofoo",
+  type: "",
+  desc: "Array with mixed types"
+});
+
+test(function() {
+  const accessed = [];
+  const stringified = [];
+
+  new Blob([], {
+    get type() { accessed.push('type'); },
+    get endings() { accessed.push('endings'); }
+  });
+  new Blob([], {
+    type: { toString: () => { stringified.push('type'); return ''; } },
+    endings: { toString: () => { stringified.push('endings'); return 'transparent'; } }
+  });
+  assert_array_equals(accessed, ['endings', 'type']);
+  assert_array_equals(stringified, ['endings', 'type']);
+}, "options properties should be accessed in lexicographic order.");
+
+test(function() {
+  assert_throws_exactly(test_error, function() {
+    new Blob(
+      [{ toString: function() { throw test_error } }],
+      {
+        get type() { assert_unreached("type getter should not be called."); }
+      }
+    );
+  });
+}, "Arguments should be evaluated from left to right.");
+
+[
+  null,
+  undefined,
+  {},
+  { unrecognized: true },
+  /regex/,
+  function() {}
+].forEach(function(arg, idx) {
+  test_blob(function() {
+    return new Blob([], arg);
+  }, {
+    expected: "",
+    type: "",
+    desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults."
+  });
+  test_blob(function() {
+    return new Blob(["\na\r\nb\n\rc\r"], arg);
+  }, {
+    expected: "\na\r\nb\n\rc\r",
+    type: "",
+    desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults (with newlines)."
+  });
+});
+
+[
+  123,
+  123.4,
+  true,
+  'abc'
+].forEach(arg => {
+  test(t => {
+    assert_throws_js(TypeError, () => new Blob([], arg),
+                     'Blob constructor should throw with invalid property bag');
+  }, `Passing ${JSON.stringify(arg)} for options should throw`);
+});
+
+var type_tests = [
+  // blobParts, type, expected type
+  [[], '', ''],
+  [[], 'a', 'a'],
+  [[], 'A', 'a'],
+  [[], 'text/html', 'text/html'],
+  [[], 'TEXT/HTML', 'text/html'],
+  [[], 'text/plain;charset=utf-8', 'text/plain;charset=utf-8'],
+  [[], '\u00E5', ''],
+  [[], '\uD801\uDC7E', ''], // U+1047E
+  [[], ' image/gif ', ' image/gif '],
+  [[], '\timage/gif\t', ''],
+  [[], 'image/gif;\u007f', ''],
+  [[], '\u0130mage/gif', ''], // uppercase i with dot
+  [[], '\u0131mage/gif', ''], // lowercase dotless i
+  [[], 'image/gif\u0000', ''],
+  // check that type isn't changed based on sniffing
+  [[0x3C, 0x48, 0x54, 0x4D, 0x4C, 0x3E], 'unknown/unknown', 'unknown/unknown'], // "<HTML>"
+  [[0x00, 0xFF], 'text/plain', 'text/plain'],
+  [[0x47, 0x49, 0x46, 0x38, 0x39, 0x61], 'image/png', 'image/png'], // "GIF89a"
+];
+
+type_tests.forEach(function(t) {
+  test(function() {
+    var arr = new Uint8Array([t[0]]).buffer;
+    var b = new Blob([arr], {type:t[1]});
+    assert_equals(b.type, t[2]);
+  }, "Blob with type " + format_value(t[1]));
+});
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-constructor.html b/test/fixtures/wpt/FileAPI/blob/Blob-constructor.html
new file mode 100644
index 0000000000000000000000000000000000000000..62a649aed66418494e9f06db833b25dcc477db1a
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-constructor.html
@@ -0,0 +1,501 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Blob constructor</title>
+<link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#constructorBlob">
+<link rel=help href="https://heycam.github.io/webidl/#es-union">
+<link rel=help href="https://heycam.github.io/webidl/#es-dictionary">
+<link rel=help href="https://heycam.github.io/webidl/#es-sequence">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/Blob.js"></script>
+<div id="log"></div>
+<script>
+test(function() {
+  assert_true("Blob" in window, "window should have a Blob property.");
+  assert_equals(Blob.length, 0, "Blob.length should be 0.");
+  assert_true(Blob instanceof Function, "Blob should be a function.");
+}, "Blob interface object");
+
+// Step 1.
+test(function() {
+  var blob = new Blob();
+  assert_true(blob instanceof Blob);
+  assert_equals(String(blob), '[object Blob]');
+  assert_equals(blob.size, 0);
+  assert_equals(blob.type, "");
+}, "Blob constructor with no arguments");
+test(function() {
+  assert_throws_js(TypeError, function() { var blob = Blob(); });
+}, "Blob constructor with no arguments, without 'new'");
+test(function() {
+  var blob = new Blob;
+  assert_true(blob instanceof Blob);
+  assert_equals(blob.size, 0);
+  assert_equals(blob.type, "");
+}, "Blob constructor without brackets");
+test(function() {
+  var blob = new Blob(undefined);
+  assert_true(blob instanceof Blob);
+  assert_equals(String(blob), '[object Blob]');
+  assert_equals(blob.size, 0);
+  assert_equals(blob.type, "");
+}, "Blob constructor with undefined as first argument");
+
+// blobParts argument (WebIDL).
+test(function() {
+  var args = [
+    null,
+    true,
+    false,
+    0,
+    1,
+    1.5,
+    "FAIL",
+    new Date(),
+    new RegExp(),
+    {},
+    { 0: "FAIL", length: 1 },
+    document.createElement("div"),
+    window,
+  ];
+  args.forEach(function(arg) {
+    assert_throws_js(TypeError, function() {
+      new Blob(arg);
+    }, "Should throw for argument " + format_value(arg) + ".");
+  });
+}, "Passing non-objects, Dates and RegExps for blobParts should throw a TypeError.");
+
+test_blob(function() {
+  return new Blob({
+    [Symbol.iterator]: Array.prototype[Symbol.iterator],
+  });
+}, {
+  expected: "",
+  type: "",
+  desc: "A plain object with @@iterator should be treated as a sequence for the blobParts argument."
+});
+test(t => {
+  const blob = new Blob({
+    [Symbol.iterator]() {
+      var i = 0;
+      return {next: () => [
+        {done:false, value:'ab'},
+        {done:false, value:'cde'},
+        {done:true}
+      ][i++]
+      };
+    }
+  });
+  assert_equals(blob.size, 5, 'Custom @@iterator should be treated as a sequence');
+}, "A plain object with custom @@iterator should be treated as a sequence for the blobParts argument.");
+test_blob(function() {
+  return new Blob({
+    [Symbol.iterator]: Array.prototype[Symbol.iterator],
+    0: "PASS",
+    length: 1
+  });
+}, {
+  expected: "PASS",
+  type: "",
+  desc: "A plain object with @@iterator and a length property should be treated as a sequence for the blobParts argument."
+});
+test_blob(function() {
+  return new Blob(new String("xyz"));
+}, {
+  expected: "xyz",
+  type: "",
+  desc: "A String object should be treated as a sequence for the blobParts argument."
+});
+test_blob(function() {
+  return new Blob(new Uint8Array([1, 2, 3]));
+}, {
+  expected: "123",
+  type: "",
+  desc: "A Uint8Array object should be treated as a sequence for the blobParts argument."
+});
+
+var test_error = {
+  name: "test",
+  message: "test error",
+};
+
+test(function() {
+  var obj = {
+    [Symbol.iterator]: Array.prototype[Symbol.iterator],
+    get length() { throw test_error; }
+  };
+  assert_throws_exactly(test_error, function() {
+    new Blob(obj);
+  });
+}, "The length getter should be invoked and any exceptions should be propagated.");
+
+test(function() {
+  var element = document.createElement("div");
+  element.appendChild(document.createElement("div"));
+  element.appendChild(document.createElement("p"));
+  var list = element.children;
+  Object.defineProperty(list, "length", {
+    get: function() { throw test_error; }
+  });
+  assert_throws_exactly(test_error, function() {
+    new Blob(list);
+  });
+}, "A platform object that supports indexed properties should be treated as a sequence for the blobParts argument (overwritten 'length'.)");
+
+test(function() {
+  assert_throws_exactly(test_error, function() {
+    var obj = {
+      [Symbol.iterator]: Array.prototype[Symbol.iterator],
+      length: {
+        valueOf: null,
+        toString: function() { throw test_error; }
+      }
+    };
+    new Blob(obj);
+  });
+  assert_throws_exactly(test_error, function() {
+    var obj = {
+      [Symbol.iterator]: Array.prototype[Symbol.iterator],
+      length: { valueOf: function() { throw test_error; } }
+    };
+    new Blob(obj);
+  });
+}, "ToUint32 should be applied to the length and any exceptions should be propagated.");
+
+test(function() {
+  var received = [];
+  var obj = {
+    get [Symbol.iterator]() {
+      received.push("Symbol.iterator");
+      return Array.prototype[Symbol.iterator];
+    },
+    get length() {
+      received.push("length getter");
+      return {
+        valueOf: function() {
+          received.push("length valueOf");
+          return 3;
+        }
+      };
+    },
+    get 0() {
+      received.push("0 getter");
+      return {
+        toString: function() {
+          received.push("0 toString");
+          return "a";
+        }
+      };
+    },
+    get 1() {
+      received.push("1 getter");
+      throw test_error;
+    },
+    get 2() {
+      received.push("2 getter");
+      assert_unreached("Should not call the getter for 2 if the getter for 1 threw.");
+    }
+  };
+  assert_throws_exactly(test_error, function() {
+    new Blob(obj);
+  });
+  assert_array_equals(received, [
+    "Symbol.iterator",
+    "length getter",
+    "length valueOf",
+    "0 getter",
+    "0 toString",
+    "length getter",
+    "length valueOf",
+    "1 getter",
+  ]);
+}, "Getters and value conversions should happen in order until an exception is thrown.");
+
+// XXX should add tests edge cases of ToLength(length)
+
+test(function() {
+  assert_throws_exactly(test_error, function() {
+    new Blob([{ toString: function() { throw test_error; } }]);
+  }, "Throwing toString");
+  assert_throws_exactly(test_error, function() {
+    new Blob([{ toString: undefined, valueOf: function() { throw test_error; } }]);
+  }, "Throwing valueOf");
+  assert_throws_exactly(test_error, function() {
+    new Blob([{
+      toString: function() { throw test_error; },
+      valueOf: function() { assert_unreached("Should not call valueOf if toString is present."); }
+    }]);
+  }, "Throwing toString and valueOf");
+  assert_throws_js(TypeError, function() {
+    new Blob([{toString: null, valueOf: null}]);
+  }, "Null toString and valueOf");
+}, "ToString should be called on elements of the blobParts array and any exceptions should be propagated.");
+
+test_blob(function() {
+  var arr = [
+    { toString: function() { arr.pop(); return "PASS"; } },
+    { toString: function() { assert_unreached("Should have removed the second element of the array rather than called toString() on it."); } }
+  ];
+  return new Blob(arr);
+}, {
+  expected: "PASS",
+  type: "",
+  desc: "Changes to the blobParts array should be reflected in the returned Blob (pop)."
+});
+
+test_blob(function() {
+  var arr = [
+    {
+      toString: function() {
+        if (arr.length === 3) {
+          return "A";
+        }
+        arr.unshift({
+          toString: function() {
+            assert_unreached("Should only access index 0 once.");
+          }
+        });
+        return "P";
+      }
+    },
+    {
+      toString: function() {
+        return "SS";
+      }
+    }
+  ];
+  return new Blob(arr);
+}, {
+  expected: "PASS",
+  type: "",
+  desc: "Changes to the blobParts array should be reflected in the returned Blob (unshift)."
+});
+
+test_blob(function() {
+  // https://www.w3.org/Bugs/Public/show_bug.cgi?id=17652
+  return new Blob([
+    null,
+    undefined,
+    true,
+    false,
+    0,
+    1,
+    new String("stringobject"),
+    [],
+    ['x', 'y'],
+    {},
+    { 0: "FAIL", length: 1 },
+    { toString: function() { return "stringA"; } },
+    { toString: undefined, valueOf: function() { return "stringB"; } },
+    { valueOf: function() { assert_unreached("Should not call valueOf if toString is present on the prototype."); } }
+  ]);
+}, {
+  expected: "nullundefinedtruefalse01stringobjectx,y[object Object][object Object]stringAstringB[object Object]",
+  type: "",
+  desc: "ToString should be called on elements of the blobParts array."
+});
+
+test_blob(function() {
+  return new Blob([
+    new ArrayBuffer(8)
+  ]);
+}, {
+  expected: "\0\0\0\0\0\0\0\0",
+  type: "",
+  desc: "ArrayBuffer elements of the blobParts array should be supported."
+});
+
+test_blob(function() {
+  return new Blob([
+    new Uint8Array([0x50, 0x41, 0x53, 0x53]),
+    new Int8Array([0x50, 0x41, 0x53, 0x53]),
+    new Uint16Array([0x4150, 0x5353]),
+    new Int16Array([0x4150, 0x5353]),
+    new Uint32Array([0x53534150]),
+    new Int32Array([0x53534150]),
+    new Float32Array([0xD341500000])
+  ]);
+}, {
+  expected: "PASSPASSPASSPASSPASSPASSPASS",
+  type: "",
+  desc: "Passing typed arrays as elements of the blobParts array should work."
+});
+test_blob(function() {
+  return new Blob([
+    // 0x535 3415053534150
+    // 0x535 = 0b010100110101 -> Sign = +, Exponent = 1333 - 1023 = 310
+    // 0x13415053534150 * 2**(-52)
+    // ==> 0x13415053534150 * 2**258 = 2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680
+    new Float64Array([2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680])
+  ]);
+}, {
+  expected: "PASSPASS",
+  type: "",
+  desc: "Passing a Float64Array as element of the blobParts array should work."
+});
+
+test_blob(function() {
+  var select = document.createElement("select");
+  select.appendChild(document.createElement("option"));
+  return new Blob(select);
+}, {
+  expected: "[object HTMLOptionElement]",
+  type: "",
+  desc: "Passing an platform object that supports indexed properties as the blobParts array should work (select)."
+});
+
+test_blob(function() {
+  var elm = document.createElement("div");
+  elm.setAttribute("foo", "bar");
+  return new Blob(elm.attributes);
+}, {
+  expected: "[object Attr]",
+  type: "",
+  desc: "Passing an platform object that supports indexed properties as the blobParts array should work (attributes)."
+});
+
+var t_ports = async_test("Passing a FrozenArray as the blobParts array should work (FrozenArray<MessagePort>).");
+t_ports.step(function() {
+    var channel = new MessageChannel();
+    channel.port2.onmessage = this.step_func(function(e) {
+        var b_ports = new Blob(e.ports);
+        assert_equals(b_ports.size, "[object MessagePort]".length);
+        this.done();
+    });
+    var channel2 = new MessageChannel();
+    channel.port1.postMessage('', [channel2.port1]);
+});
+
+test_blob(function() {
+  var blob = new Blob(['foo']);
+  return new Blob([blob, blob]);
+}, {
+  expected: "foofoo",
+  type: "",
+  desc: "Array with two blobs"
+});
+
+test_blob_binary(function() {
+  var view = new Uint8Array([0, 255, 0]);
+  return new Blob([view.buffer, view.buffer]);
+}, {
+  expected: [0, 255, 0, 0, 255, 0],
+  type: "",
+  desc: "Array with two buffers"
+});
+
+test_blob_binary(function() {
+  var view = new Uint8Array([0, 255, 0, 4]);
+  var blob = new Blob([view, view]);
+  assert_equals(blob.size, 8);
+  var view1 = new Uint16Array(view.buffer, 2);
+  return new Blob([view1, view.buffer, view1]);
+}, {
+  expected: [0, 4, 0, 255, 0, 4, 0, 4],
+  type: "",
+  desc: "Array with two bufferviews"
+});
+
+test_blob(function() {
+  var view = new Uint8Array([0]);
+  var blob = new Blob(["fo"]);
+  return new Blob([view.buffer, blob, "foo"]);
+}, {
+  expected: "\0fofoo",
+  type: "",
+  desc: "Array with mixed types"
+});
+
+test(function() {
+  const accessed = [];
+  const stringified = [];
+
+  new Blob([], {
+    get type() { accessed.push('type'); },
+    get endings() { accessed.push('endings'); }
+  });
+  new Blob([], {
+    type: { toString: () => { stringified.push('type'); return ''; } },
+    endings: { toString: () => { stringified.push('endings'); return 'transparent'; } }
+  });
+  assert_array_equals(accessed, ['endings', 'type']);
+  assert_array_equals(stringified, ['endings', 'type']);
+}, "options properties should be accessed in lexicographic order.");
+
+test(function() {
+  assert_throws_exactly(test_error, function() {
+    new Blob(
+      [{ toString: function() { throw test_error } }],
+      {
+        get type() { assert_unreached("type getter should not be called."); }
+      }
+    );
+  });
+}, "Arguments should be evaluated from left to right.");
+
+[
+  null,
+  undefined,
+  {},
+  { unrecognized: true },
+  /regex/,
+  function() {}
+].forEach(function(arg, idx) {
+  test_blob(function() {
+    return new Blob([], arg);
+  }, {
+    expected: "",
+    type: "",
+    desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults."
+  });
+  test_blob(function() {
+    return new Blob(["\na\r\nb\n\rc\r"], arg);
+  }, {
+    expected: "\na\r\nb\n\rc\r",
+    type: "",
+    desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults (with newlines)."
+  });
+});
+
+[
+  123,
+  123.4,
+  true,
+  'abc'
+].forEach(arg => {
+  test(t => {
+    assert_throws_js(TypeError, () => new Blob([], arg),
+                     'Blob constructor should throw with invalid property bag');
+  }, `Passing ${JSON.stringify(arg)} for options should throw`);
+});
+
+var type_tests = [
+  // blobParts, type, expected type
+  [[], '', ''],
+  [[], 'a', 'a'],
+  [[], 'A', 'a'],
+  [[], 'text/html', 'text/html'],
+  [[], 'TEXT/HTML', 'text/html'],
+  [[], 'text/plain;charset=utf-8', 'text/plain;charset=utf-8'],
+  [[], '\u00E5', ''],
+  [[], '\uD801\uDC7E', ''], // U+1047E
+  [[], ' image/gif ', ' image/gif '],
+  [[], '\timage/gif\t', ''],
+  [[], 'image/gif;\u007f', ''],
+  [[], '\u0130mage/gif', ''], // uppercase i with dot
+  [[], '\u0131mage/gif', ''], // lowercase dotless i
+  [[], 'image/gif\u0000', ''],
+  // check that type isn't changed based on sniffing
+  [[0x3C, 0x48, 0x54, 0x4D, 0x4C, 0x3E], 'unknown/unknown', 'unknown/unknown'], // "<HTML>"
+  [[0x00, 0xFF], 'text/plain', 'text/plain'],
+  [[0x47, 0x49, 0x46, 0x38, 0x39, 0x61], 'image/png', 'image/png'], // "GIF89a"
+];
+
+type_tests.forEach(function(t) {
+  test(function() {
+    var arr = new Uint8Array([t[0]]).buffer;
+    var b = new Blob([arr], {type:t[1]});
+    assert_equals(b.type, t[2]);
+  }, "Blob with type " + format_value(t[1]));
+});
+</script>
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-in-worker.worker.js b/test/fixtures/wpt/FileAPI/blob/Blob-in-worker.worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..a67060e7b85effa52a5b93856fcda3b62e572eaa
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-in-worker.worker.js
@@ -0,0 +1,14 @@
+importScripts("/resources/testharness.js");
+
+async_test(function() {
+  var data = "TEST";
+  var blob = new Blob([data], {type: "text/plain"});
+  var reader = new FileReader();
+  reader.onload = this.step_func_done(function() {
+    assert_equals(reader.result, data);
+  });
+  reader.onerror = this.unreached_func("Unexpected error event");
+  reader.readAsText(blob);
+}, "Create Blob in Worker");
+
+done();
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-slice-overflow.any.js b/test/fixtures/wpt/FileAPI/blob/Blob-slice-overflow.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..388fd9282c94abe8a296eee6dfe45dca4de400e2
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-slice-overflow.any.js
@@ -0,0 +1,32 @@
+// META: title=Blob slice overflow
+'use strict';
+
+var text = '';
+
+for (var i = 0; i < 2000; ++i) {
+  text += 'A';
+}
+
+test(function() {
+  var blob = new Blob([text]);
+  var sliceBlob = blob.slice(-1, blob.size);
+  assert_equals(sliceBlob.size, 1, "Blob slice size");
+}, "slice start is negative, relativeStart will be max((size + start), 0)");
+
+test(function() {
+  var blob = new Blob([text]);
+  var sliceBlob = blob.slice(blob.size + 1, blob.size);
+  assert_equals(sliceBlob.size, 0, "Blob slice size");
+}, "slice start is greater than blob size, relativeStart will be min(start, size)");
+
+test(function() {
+  var blob = new Blob([text]);
+  var sliceBlob = blob.slice(blob.size - 2, -1);
+  assert_equals(sliceBlob.size, 1, "Blob slice size");
+}, "slice end is negative, relativeEnd will be max((size + end), 0)");
+
+test(function() {
+  var blob = new Blob([text]);
+  var sliceBlob = blob.slice(blob.size - 2, blob.size + 999);
+  assert_equals(sliceBlob.size, 2, "Blob slice size");
+}, "slice end is greater than blob size, relativeEnd will be min(end, size)");
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-slice-overflow.html b/test/fixtures/wpt/FileAPI/blob/Blob-slice-overflow.html
new file mode 100644
index 0000000000000000000000000000000000000000..74cd83a34f7116d85b7cc2c8b9fcb12de0194926
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-slice-overflow.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Blob slice overflow</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="help" href="https://w3c.github.io/FileAPI/#dfn-slice">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="log"></div>
+<script>
+
+var text = '';
+
+for (var i = 0; i < 2000; ++i) {
+  text += 'A';
+}
+
+test(function() {
+  var blob = new Blob([text]);
+  var sliceBlob = blob.slice(-1, blob.size);
+  assert_equals(sliceBlob.size, 1, "Blob slice size");
+}, "slice start is negative, relativeStart will be max((size + start), 0)");
+
+test(function() {
+  var blob = new Blob([text]);
+  var sliceBlob = blob.slice(blob.size + 1, blob.size);
+  assert_equals(sliceBlob.size, 0, "Blob slice size");
+}, "slice start is greater than blob size, relativeStart will be min(start, size)");
+
+test(function() {
+  var blob = new Blob([text]);
+  var sliceBlob = blob.slice(blob.size - 2, -1);
+  assert_equals(sliceBlob.size, 1, "Blob slice size");
+}, "slice end is negative, relativeEnd will be max((size + end), 0)");
+
+test(function() {
+  var blob = new Blob([text]);
+  var sliceBlob = blob.slice(blob.size - 2, blob.size + 999);
+  assert_equals(sliceBlob.size, 2, "Blob slice size");
+}, "slice end is greater than blob size, relativeEnd will be min(end, size)");
+
+</script>
+
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-slice.any.js b/test/fixtures/wpt/FileAPI/blob/Blob-slice.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f85d44d269191d9b9338a3a9fe48cbc5200045f
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-slice.any.js
@@ -0,0 +1,231 @@
+// META: title=Blob slice
+// META: script=../support/Blob.js
+'use strict';
+
+test_blob(function() {
+  var blobTemp = new Blob(["PASS"]);
+  return blobTemp.slice();
+}, {
+  expected: "PASS",
+  type: "",
+  desc: "no-argument Blob slice"
+});
+
+test(function() {
+  var blob1, blob2;
+
+  test_blob(function() {
+    return blob1 = new Blob(["squiggle"]);
+  }, {
+    expected: "squiggle",
+    type: "",
+    desc: "blob1."
+  });
+
+  test_blob(function() {
+    return blob2 = new Blob(["steak"], {type: "content/type"});
+  }, {
+    expected: "steak",
+    type: "content/type",
+    desc: "blob2."
+  });
+
+  test_blob(function() {
+    return new Blob().slice(0,0,null);
+  }, {
+    expected: "",
+    type: "null",
+    desc: "null type Blob slice"
+  });
+
+  test_blob(function() {
+    return new Blob().slice(0,0,undefined);
+  }, {
+    expected: "",
+    type: "",
+    desc: "undefined type Blob slice"
+  });
+
+  test_blob(function() {
+    return new Blob().slice(0,0);
+  }, {
+    expected: "",
+    type: "",
+    desc: "no type Blob slice"
+  });
+
+  var arrayBuffer = new ArrayBuffer(16);
+  var int8View = new Int8Array(arrayBuffer);
+  for (var i = 0; i < 16; i++) {
+    int8View[i] = i + 65;
+  }
+
+  var testData = [
+    [
+      ["PASSSTRING"],
+      [{start:  -6, contents: "STRING"},
+       {start: -12, contents: "PASSSTRING"},
+       {start:   4, contents: "STRING"},
+       {start:  12, contents: ""},
+       {start: 0, end:  -6, contents: "PASS"},
+       {start: 0, end: -12, contents: ""},
+       {start: 0, end:   4, contents: "PASS"},
+       {start: 0, end:  12, contents: "PASSSTRING"},
+       {start: 7, end:   4, contents: ""}]
+    ],
+
+    // Test 3 strings
+    [
+      ["foo", "bar", "baz"],
+      [{start:  0, end:  9, contents: "foobarbaz"},
+       {start:  0, end:  3, contents: "foo"},
+       {start:  3, end:  9, contents: "barbaz"},
+       {start:  6, end:  9, contents: "baz"},
+       {start:  6, end: 12, contents: "baz"},
+       {start:  0, end:  9, contents: "foobarbaz"},
+       {start:  0, end: 11, contents: "foobarbaz"},
+       {start: 10, end: 15, contents: ""}]
+    ],
+
+    // Test string, Blob, string
+    [
+      ["foo", blob1, "baz"],
+      [{start:  0, end:  3, contents: "foo"},
+       {start:  3, end: 11, contents: "squiggle"},
+       {start:  2, end:  4, contents: "os"},
+       {start: 10, end: 12, contents: "eb"}]
+    ],
+
+    // Test blob, string, blob
+    [
+      [blob1, "foo", blob1],
+      [{start:  0, end:  8, contents: "squiggle"},
+       {start:  7, end:  9, contents: "ef"},
+       {start: 10, end: 12, contents: "os"},
+       {start:  1, end:  4, contents: "qui"},
+       {start: 12, end: 15, contents: "qui"},
+       {start: 40, end: 60, contents: ""}]
+    ],
+
+    // Test blobs all the way down
+    [
+      [blob2, blob1, blob2],
+      [{start: 0,  end:  5, contents: "steak"},
+       {start: 5,  end: 13, contents: "squiggle"},
+       {start: 13, end: 18, contents: "steak"},
+       {start:  1, end:  3, contents: "te"},
+       {start:  6, end: 10, contents: "quig"}]
+    ],
+
+    // Test an ArrayBufferView
+    [
+      [int8View, blob1, "foo"],
+      [{start:  0, end:  8, contents: "ABCDEFGH"},
+       {start:  8, end: 18, contents: "IJKLMNOPsq"},
+       {start: 17, end: 20, contents: "qui"},
+       {start:  4, end: 12, contents: "EFGHIJKL"}]
+    ],
+
+    // Test a partial ArrayBufferView
+    [
+      [new Uint8Array(arrayBuffer, 3, 5), blob1, "foo"],
+      [{start:  0, end:  8, contents: "DEFGHsqu"},
+       {start:  8, end: 18, contents: "igglefoo"},
+       {start:  4, end: 12, contents: "Hsquiggl"}]
+    ],
+
+    // Test type coercion of a number
+    [
+      [3, int8View, "foo"],
+      [{start:  0, end:  8, contents: "3ABCDEFG"},
+       {start:  8, end: 18, contents: "HIJKLMNOPf"},
+       {start: 17, end: 21, contents: "foo"},
+       {start:  4, end: 12, contents: "DEFGHIJK"}]
+    ],
+
+    [
+      [(new Uint8Array([0, 255, 0])).buffer,
+       new Blob(['abcd']),
+       'efgh',
+       'ijklmnopqrstuvwxyz'],
+      [{start:  1, end:  4, contents: "\uFFFD\u0000a"},
+       {start:  4, end:  8, contents: "bcde"},
+       {start:  8, end: 12, contents: "fghi"},
+       {start:  1, end: 12, contents: "\uFFFD\u0000abcdefghi"}]
+    ]
+  ];
+
+  testData.forEach(function(data, i) {
+    var blobs = data[0];
+    var tests = data[1];
+    tests.forEach(function(expectations, j) {
+      test(function() {
+        var blob = new Blob(blobs);
+        assert_true(blob instanceof Blob);
+        assert_false(blob instanceof File);
+
+        test_blob(function() {
+          return expectations.end === undefined
+                 ? blob.slice(expectations.start)
+                 : blob.slice(expectations.start, expectations.end);
+        }, {
+          expected: expectations.contents,
+          type: "",
+          desc: "Slicing test: slice (" + i + "," + j + ")."
+        });
+      }, "Slicing test (" + i + "," + j + ").");
+    });
+  });
+}, "Slices");
+
+var invalidTypes = [
+  "\xFF",
+  "te\x09xt/plain",
+  "te\x00xt/plain",
+  "te\x1Fxt/plain",
+  "te\x7Fxt/plain"
+];
+invalidTypes.forEach(function(type) {
+  test_blob(function() {
+    var blob = new Blob(["PASS"]);
+    return blob.slice(0, 4, type);
+  }, {
+    expected: "PASS",
+    type: "",
+    desc: "Invalid contentType (" + format_value(type) + ")"
+  });
+});
+
+var validTypes = [
+  "te(xt/plain",
+  "te)xt/plain",
+  "te<xt/plain",
+  "te>xt/plain",
+  "te@xt/plain",
+  "te,xt/plain",
+  "te;xt/plain",
+  "te:xt/plain",
+  "te\\xt/plain",
+  "te\"xt/plain",
+  "te/xt/plain",
+  "te[xt/plain",
+  "te]xt/plain",
+  "te?xt/plain",
+  "te=xt/plain",
+  "te{xt/plain",
+  "te}xt/plain",
+  "te\x20xt/plain",
+  "TEXT/PLAIN",
+  "text/plain;charset = UTF-8",
+  "text/plain;charset=UTF-8"
+];
+validTypes.forEach(function(type) {
+  test_blob(function() {
+    var blob = new Blob(["PASS"]);
+    return blob.slice(0, 4, type);
+  }, {
+    expected: "PASS",
+    type: type.toLowerCase(),
+    desc: "Valid contentType (" + format_value(type) + ")"
+  });
+});
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-slice.html b/test/fixtures/wpt/FileAPI/blob/Blob-slice.html
new file mode 100644
index 0000000000000000000000000000000000000000..03fe6ca5343bd1dbac65c2d885a7eb79f064d99e
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-slice.html
@@ -0,0 +1,238 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Blob slice</title>
+<link rel=help href="https://w3c.github.io/FileAPI/#slice-method-algo">
+<link rel=author title="Saurabh Anand" href="mailto:saurabhanandiit@gmail.com">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/Blob.js"></script>
+<div id="log"></div>
+<script>
+test_blob(function() {
+  var blobTemp = new Blob(["PASS"]);
+  return blobTemp.slice();
+}, {
+  expected: "PASS",
+  type: "",
+  desc: "no-argument Blob slice"
+});
+
+test(function() {
+  var blob1, blob2;
+
+  test_blob(function() {
+    return blob1 = new Blob(["squiggle"]);
+  }, {
+    expected: "squiggle",
+    type: "",
+    desc: "blob1."
+  });
+
+  test_blob(function() {
+    return blob2 = new Blob(["steak"], {type: "content/type"});
+  }, {
+    expected: "steak",
+    type: "content/type",
+    desc: "blob2."
+  });
+
+  test_blob(function() {
+    return new Blob().slice(0,0,null);
+  }, {
+    expected: "",
+    type: "null",
+    desc: "null type Blob slice"
+  });
+
+  test_blob(function() {
+    return new Blob().slice(0,0,undefined);
+  }, {
+    expected: "",
+    type: "",
+    desc: "undefined type Blob slice"
+  });
+
+  test_blob(function() {
+    return new Blob().slice(0,0);
+  }, {
+    expected: "",
+    type: "",
+    desc: "no type Blob slice"
+  });
+
+  var arrayBuffer = new ArrayBuffer(16);
+  var int8View = new Int8Array(arrayBuffer);
+  for (var i = 0; i < 16; i++) {
+    int8View[i] = i + 65;
+  }
+
+  var testData = [
+    [
+      ["PASSSTRING"],
+      [{start:  -6, contents: "STRING"},
+       {start: -12, contents: "PASSSTRING"},
+       {start:   4, contents: "STRING"},
+       {start:  12, contents: ""},
+       {start: 0, end:  -6, contents: "PASS"},
+       {start: 0, end: -12, contents: ""},
+       {start: 0, end:   4, contents: "PASS"},
+       {start: 0, end:  12, contents: "PASSSTRING"},
+       {start: 7, end:   4, contents: ""}]
+    ],
+
+    // Test 3 strings
+    [
+      ["foo", "bar", "baz"],
+      [{start:  0, end:  9, contents: "foobarbaz"},
+       {start:  0, end:  3, contents: "foo"},
+       {start:  3, end:  9, contents: "barbaz"},
+       {start:  6, end:  9, contents: "baz"},
+       {start:  6, end: 12, contents: "baz"},
+       {start:  0, end:  9, contents: "foobarbaz"},
+       {start:  0, end: 11, contents: "foobarbaz"},
+       {start: 10, end: 15, contents: ""}]
+    ],
+
+    // Test string, Blob, string
+    [
+      ["foo", blob1, "baz"],
+      [{start:  0, end:  3, contents: "foo"},
+       {start:  3, end: 11, contents: "squiggle"},
+       {start:  2, end:  4, contents: "os"},
+       {start: 10, end: 12, contents: "eb"}]
+    ],
+
+    // Test blob, string, blob
+    [
+      [blob1, "foo", blob1],
+      [{start:  0, end:  8, contents: "squiggle"},
+       {start:  7, end:  9, contents: "ef"},
+       {start: 10, end: 12, contents: "os"},
+       {start:  1, end:  4, contents: "qui"},
+       {start: 12, end: 15, contents: "qui"},
+       {start: 40, end: 60, contents: ""}]
+    ],
+
+    // Test blobs all the way down
+    [
+      [blob2, blob1, blob2],
+      [{start: 0,  end:  5, contents: "steak"},
+       {start: 5,  end: 13, contents: "squiggle"},
+       {start: 13, end: 18, contents: "steak"},
+       {start:  1, end:  3, contents: "te"},
+       {start:  6, end: 10, contents: "quig"}]
+    ],
+
+    // Test an ArrayBufferView
+    [
+      [int8View, blob1, "foo"],
+      [{start:  0, end:  8, contents: "ABCDEFGH"},
+       {start:  8, end: 18, contents: "IJKLMNOPsq"},
+       {start: 17, end: 20, contents: "qui"},
+       {start:  4, end: 12, contents: "EFGHIJKL"}]
+    ],
+
+    // Test a partial ArrayBufferView
+    [
+      [new Uint8Array(arrayBuffer, 3, 5), blob1, "foo"],
+      [{start:  0, end:  8, contents: "DEFGHsqu"},
+       {start:  8, end: 18, contents: "igglefoo"},
+       {start:  4, end: 12, contents: "Hsquiggl"}]
+    ],
+
+    // Test type coercion of a number
+    [
+      [3, int8View, "foo"],
+      [{start:  0, end:  8, contents: "3ABCDEFG"},
+       {start:  8, end: 18, contents: "HIJKLMNOPf"},
+       {start: 17, end: 21, contents: "foo"},
+       {start:  4, end: 12, contents: "DEFGHIJK"}]
+    ],
+
+    [
+      [(new Uint8Array([0, 255, 0])).buffer,
+       new Blob(['abcd']),
+       'efgh',
+       'ijklmnopqrstuvwxyz'],
+      [{start:  1, end:  4, contents: "\uFFFD\u0000a"},
+       {start:  4, end:  8, contents: "bcde"},
+       {start:  8, end: 12, contents: "fghi"},
+       {start:  1, end: 12, contents: "\uFFFD\u0000abcdefghi"}]
+    ]
+  ];
+
+  testData.forEach(function(data, i) {
+    var blobs = data[0];
+    var tests = data[1];
+    tests.forEach(function(expectations, j) {
+      test(function() {
+        var blob = new Blob(blobs);
+        assert_true(blob instanceof Blob);
+        assert_false(blob instanceof File);
+
+        test_blob(function() {
+          return expectations.end === undefined
+                 ? blob.slice(expectations.start)
+                 : blob.slice(expectations.start, expectations.end);
+        }, {
+          expected: expectations.contents,
+          type: "",
+          desc: "Slicing test: slice (" + i + "," + j + ")."
+        });
+      }, "Slicing test (" + i + "," + j + ").");
+    });
+  });
+}, "Slices");
+
+var invalidTypes = [
+  "\xFF",
+  "te\x09xt/plain",
+  "te\x00xt/plain",
+  "te\x1Fxt/plain",
+  "te\x7Fxt/plain"
+];
+invalidTypes.forEach(function(type) {
+  test_blob(function() {
+    var blob = new Blob(["PASS"]);
+    return blob.slice(0, 4, type);
+  }, {
+    expected: "PASS",
+    type: "",
+    desc: "Invalid contentType (" + format_value(type) + ")"
+  });
+});
+
+var validTypes = [
+  "te(xt/plain",
+  "te)xt/plain",
+  "te<xt/plain",
+  "te>xt/plain",
+  "te@xt/plain",
+  "te,xt/plain",
+  "te;xt/plain",
+  "te:xt/plain",
+  "te\\xt/plain",
+  "te\"xt/plain",
+  "te/xt/plain",
+  "te[xt/plain",
+  "te]xt/plain",
+  "te?xt/plain",
+  "te=xt/plain",
+  "te{xt/plain",
+  "te}xt/plain",
+  "te\x20xt/plain",
+  "TEXT/PLAIN",
+  "text/plain;charset = UTF-8",
+  "text/plain;charset=UTF-8"
+];
+validTypes.forEach(function(type) {
+  test_blob(function() {
+    var blob = new Blob(["PASS"]);
+    return blob.slice(0, 4, type);
+  }, {
+    expected: "PASS",
+    type: type.toLowerCase(),
+    desc: "Valid contentType (" + format_value(type) + ")"
+  });
+});
+</script>
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-stream.any.js b/test/fixtures/wpt/FileAPI/blob/Blob-stream.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..792b6639c35a265de4902af83ab5724a178ae8a9
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-stream.any.js
@@ -0,0 +1,72 @@
+// META: title=Blob Stream
+// META: script=../support/Blob.js
+// META: script=../../streams/resources/test-utils.js
+'use strict';
+
+// Helper function that triggers garbage collection while reading a chunk
+// if perform_gc is true.
+async function read_and_gc(reader, perform_gc) {
+  const read_promise = reader.read();
+  if (perform_gc)
+    garbageCollect();
+  return read_promise;
+}
+
+// Takes in a ReadableStream and reads from it until it is done, returning
+// an array that contains the results of each read operation. If perform_gc
+// is true, garbage collection is triggered while reading every chunk.
+async function read_all_chunks(stream, perform_gc = false) {
+  assert_true(stream instanceof ReadableStream);
+  assert_true('getReader' in stream);
+  const reader = stream.getReader();
+
+  assert_true('read' in reader);
+  let read_value = await read_and_gc(reader, perform_gc);
+
+  let out = [];
+  let i = 0;
+  while (!read_value.done) {
+    for (let val of read_value.value) {
+      out[i++] = val;
+    }
+    read_value = await read_and_gc(reader, perform_gc);
+  }
+  return out;
+}
+
+promise_test(async () => {
+  const blob = new Blob(["PASS"]);
+  const stream = blob.stream();
+  const chunks = await read_all_chunks(stream);
+  for (let [index, value] of chunks.entries()) {
+    assert_equals(value, "PASS".charCodeAt(index));
+  }
+}, "Blob.stream()")
+
+promise_test(async () => {
+  const blob = new Blob();
+  const stream = blob.stream();
+  const chunks = await read_all_chunks(stream);
+  assert_array_equals(chunks, []);
+}, "Blob.stream() empty Blob")
+
+promise_test(async () => {
+  const input_arr = [8, 241, 48, 123, 151];
+  const typed_arr = new Uint8Array(input_arr);
+  const blob = new Blob([typed_arr]);
+  const stream = blob.stream();
+  const chunks = await read_all_chunks(stream);
+  assert_array_equals(chunks, input_arr);
+}, "Blob.stream() non-unicode input")
+
+promise_test(async() => {
+  const input_arr = [8, 241, 48, 123, 151];
+  const typed_arr = new Uint8Array(input_arr);
+  let blob = new Blob([typed_arr]);
+  const stream = blob.stream();
+  blob = null;
+  garbageCollect();
+  const chunks = await read_all_chunks(stream, /*perform_gc=*/true);
+  assert_array_equals(chunks, input_arr);
+}, "Blob.stream() garbage collection of blob shouldn't break stream" +
+      "consumption")
diff --git a/test/fixtures/wpt/FileAPI/blob/Blob-text.any.js b/test/fixtures/wpt/FileAPI/blob/Blob-text.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..d04fa97cffe6a3d81f520f7ac92ac44e699fa004
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/blob/Blob-text.any.js
@@ -0,0 +1,64 @@
+// META: title=Blob Text
+// META: script=../support/Blob.js
+'use strict';
+
+promise_test(async () => {
+  const blob = new Blob(["PASS"]);
+  const text = await blob.text();
+  assert_equals(text, "PASS");
+}, "Blob.text()")
+
+promise_test(async () => {
+  const blob = new Blob();
+  const text = await blob.text();
+  assert_equals(text, "");
+}, "Blob.text() empty blob data")
+
+promise_test(async () => {
+  const blob = new Blob(["P", "A", "SS"]);
+  const text = await blob.text();
+  assert_equals(text, "PASS");
+}, "Blob.text() multi-element array in constructor")
+
+promise_test(async () => {
+  const non_unicode = "\u0061\u030A";
+  const input_arr = new TextEncoder().encode(non_unicode);
+  const blob = new Blob([input_arr]);
+  const text = await blob.text();
+  assert_equals(text, non_unicode);
+}, "Blob.text() non-unicode")
+
+promise_test(async () => {
+  const blob = new Blob(["PASS"], { type: "text/plain;charset=utf-16le" });
+  const text = await blob.text();
+  assert_equals(text, "PASS");
+}, "Blob.text() different charset param in type option")
+
+promise_test(async () => {
+  const non_unicode = "\u0061\u030A";
+  const input_arr = new TextEncoder().encode(non_unicode);
+  const blob = new Blob([input_arr], { type: "text/plain;charset=utf-16le" });
+  const text = await blob.text();
+  assert_equals(text, non_unicode);
+}, "Blob.text() different charset param with non-ascii input")
+
+promise_test(async () => {
+  const input_arr = new Uint8Array([192, 193, 245, 246, 247, 248, 249, 250, 251,
+      252, 253, 254, 255]);
+  const blob = new Blob([input_arr]);
+  const text = await blob.text();
+  assert_equals(text, "\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd" +
+      "\ufffd\ufffd\ufffd\ufffd");
+}, "Blob.text() invalid utf-8 input")
+
+promise_test(async () => {
+  const input_arr = new Uint8Array([192, 193, 245, 246, 247, 248, 249, 250, 251,
+      252, 253, 254, 255]);
+  const blob = new Blob([input_arr]);
+  const text_results = await Promise.all([blob.text(), blob.text(),
+      blob.text()]);
+  for (let text of text_results) {
+    assert_equals(text, "\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd" +
+        "\ufffd\ufffd\ufffd\ufffd");
+  }
+}, "Blob.text() concurrent reads")
diff --git a/test/fixtures/wpt/FileAPI/file/File-constructor-endings.html b/test/fixtures/wpt/FileAPI/file/File-constructor-endings.html
new file mode 100644
index 0000000000000000000000000000000000000000..1282b6c5ac2c790803eea11ad74183ae8d78bd07
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/File-constructor-endings.html
@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>File constructor: endings option</title>
+<link rel=help href="https://w3c.github.io/FileAPI/#file-constructor">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+
+// Windows platforms use CRLF as the native line ending. All others use LF.
+const crlf = navigator.platform.startsWith('Win');
+const native_ending = crlf ? '\r\n' : '\n';
+
+function readBlobAsPromise(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsText(blob);
+    reader.onload = e => resolve(reader.result);
+    reader.onerror = e => reject(reader.error);
+  });
+}
+
+[
+  'transparent',
+  'native'
+].forEach(value => test(t => {
+  assert_class_string(new File([], "name", {endings: value}), 'File',
+                      `Constructor should allow "${value}" endings`);
+}, `Valid "endings" value: ${JSON.stringify(value)}`));
+
+[
+  null,
+  '',
+  'invalidEnumValue',
+  'Transparent',
+  'NATIVE',
+  0,
+  {}
+].forEach(value => test(t => {
+  assert_throws_js(TypeError, () => new File([], "name", {endings: value}),
+                   'File constructor should throw');
+}, `Invalid "endings" value: ${JSON.stringify(value)}`));
+
+test(t => {
+  const test_error = {name: 'test'};
+  assert_throws_exactly(
+    test_error,
+    () => new File([], "name", { get endings() { throw test_error; }}),
+    'File constructor should propagate exceptions from "endings" property');
+}, 'Exception propagation from options');
+
+test(t => {
+  let got = false;
+  new File([], "name", { get endings() { got = true; } });
+  assert_true(got, 'The "endings" property was accessed during construction.');
+}, 'The "endings" options property is used');
+
+[
+  {name: 'LF', input: '\n', native: native_ending},
+  {name: 'CR', input: '\r', native: native_ending},
+
+  {name: 'CRLF', input: '\r\n', native: native_ending},
+  {name: 'CRCR', input: '\r\r', native: native_ending.repeat(2)},
+  {name: 'LFCR', input: '\n\r', native: native_ending.repeat(2)},
+  {name: 'LFLF', input: '\n\n', native: native_ending.repeat(2)},
+
+  {name: 'CRCRLF', input: '\r\r\n', native: native_ending.repeat(2)},
+  {name: 'CRLFLF', input: '\r\n\n', native: native_ending.repeat(2)},
+  {name: 'CRLFCR', input: '\r\n\r\n', native: native_ending.repeat(2)},
+
+  {name: 'CRLFCRLF', input: '\r\n\r\n', native: native_ending.repeat(2)},
+  {name: 'LFCRLFCR', input: '\n\r\n\r', native: native_ending.repeat(3)},
+
+].forEach(testCase => {
+  promise_test(async t => {
+    const file = new File([testCase.input], "name");
+    assert_equals(
+      await readBlobAsPromise(file), testCase.input,
+      'Newlines should not change with endings unspecified');
+  }, `Input ${testCase.name} with endings unspecified`);
+
+  promise_test(async t => {
+    const file = new File([testCase.input], "name", {endings: 'transparent'});
+    assert_equals(
+      await readBlobAsPromise(file), testCase.input,
+      'Newlines should not change with endings "transparent"');
+  }, `Input ${testCase.name} with endings 'transparent'`);
+
+  promise_test(async t => {
+    const file = new File([testCase.input], "name", {endings: 'native'});
+    assert_equals(
+      await readBlobAsPromise(file), testCase.native,
+      'Newlines should match the platform with endings "native"');
+  }, `Input ${testCase.name} with endings 'native'`);
+});
+
+promise_test(async t => {
+  const file = new File(['\r', '\n'], "name", {endings: 'native'});
+  const expected = native_ending.repeat(2);
+  assert_equals(
+    await readBlobAsPromise(file), expected,
+    'CR/LF in adjacent strings should be converted to two platform newlines');
+}, `CR/LF in adjacent input strings`);
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/File-constructor.html b/test/fixtures/wpt/FileAPI/file/File-constructor.html
new file mode 100644
index 0000000000000000000000000000000000000000..3477e4ada16e9297c2f2ee91da1d17f930a6a913
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/File-constructor.html
@@ -0,0 +1,159 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>File constructor</title>
+<link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-file">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="log"></div>
+<script>
+const to_string_obj = { toString: () => 'a string' };
+const to_string_throws = { toString: () => { throw new Error('expected'); } };
+
+test(function() {
+  assert_true("File" in window, "window should have a File property.");
+}, "File interface object exists");
+
+test(t => {
+  assert_throws_js(TypeError, () => new File(),
+                   'Bits argument is required');
+  assert_throws_js(TypeError, () => new File([]),
+                   'Name argument is required');
+}, 'Required arguments');
+
+function test_first_argument(arg1, expectedSize, testName) {
+  test(function() {
+    var file = new File(arg1, "dummy");
+    assert_true(file instanceof File);
+    assert_equals(file.name, "dummy");
+    assert_equals(file.size, expectedSize);
+    assert_equals(file.type, "");
+    // assert_false(file.isClosed); XXX: File.isClosed doesn't seem to be implemented
+    assert_not_equals(file.lastModified, "");
+  }, testName);
+}
+
+test_first_argument([], 0, "empty fileBits");
+test_first_argument(["bits"], 4, "DOMString fileBits");
+test_first_argument(["𝓽𝓮𝔁𝓽"], 16, "Unicode DOMString fileBits");
+test_first_argument([new String('string object')], 13, "String object fileBits");
+test_first_argument([new Blob()], 0, "Empty Blob fileBits");
+test_first_argument([new Blob(["bits"])], 4, "Blob fileBits");
+test_first_argument([new File([], 'world.txt')], 0, "Empty File fileBits");
+test_first_argument([new File(["bits"], 'world.txt')], 4, "File fileBits");
+test_first_argument([new ArrayBuffer(8)], 8, "ArrayBuffer fileBits");
+test_first_argument([new Uint8Array([0x50, 0x41, 0x53, 0x53])], 4, "Typed array fileBits");
+test_first_argument(["bits", new Blob(["bits"]), new Blob(), new Uint8Array([0x50, 0x41]),
+                     new Uint16Array([0x5353]), new Uint32Array([0x53534150])], 16, "Various fileBits");
+test_first_argument([12], 2, "Number in fileBits");
+test_first_argument([[1,2,3]], 5, "Array in fileBits");
+test_first_argument([{}], 15, "Object in fileBits"); // "[object Object]"
+test_first_argument([document.body], 24, "HTMLBodyElement in fileBits"); // "[object HTMLBodyElement]"
+test_first_argument([to_string_obj], 8, "Object with toString in fileBits");
+test_first_argument({[Symbol.iterator]() {
+  let i = 0;
+  return {next: () => [
+    {done:false, value:'ab'},
+    {done:false, value:'cde'},
+    {done:true}
+  ][i++]};
+}}, 5, 'Custom @@iterator');
+
+[
+  'hello',
+  0,
+  null
+].forEach(arg => {
+  test(t => {
+    assert_throws_js(TypeError, () => new File(arg, 'world.html'),
+                     'Constructor should throw for invalid bits argument');
+  }, `Invalid bits argument: ${JSON.stringify(arg)}`);
+});
+
+test(t => {
+  assert_throws_js(Error, () => new File([to_string_throws], 'name.txt'),
+                   'Constructor should propagate exceptions');
+}, 'Bits argument: object that throws');
+
+
+function test_second_argument(arg2, expectedFileName, testName) {
+  test(function() {
+    var file = new File(["bits"], arg2);
+    assert_true(file instanceof File);
+    assert_equals(file.name, expectedFileName);
+  }, testName);
+}
+
+test_second_argument("dummy", "dummy", "Using fileName");
+test_second_argument("dummy/foo", "dummy/foo",
+                     "No replacement when using special character in fileName");
+test_second_argument(null, "null", "Using null fileName");
+test_second_argument(1, "1", "Using number fileName");
+test_second_argument('', '', "Using empty string fileName");
+test_second_argument(document.body, '[object HTMLBodyElement]', "Using object fileName");
+
+// testing the third argument
+[
+  {type: 'text/plain', expected: 'text/plain'},
+  {type: 'text/plain;charset=UTF-8', expected: 'text/plain;charset=utf-8'},
+  {type: 'TEXT/PLAIN', expected: 'text/plain'},
+  {type: '𝓽𝓮𝔁𝓽/𝔭𝔩𝔞𝔦𝔫', expected: ''},
+  {type: 'ascii/nonprintable\u001F', expected: ''},
+  {type: 'ascii/nonprintable\u007F', expected: ''},
+  {type: 'nonascii\u00EE', expected: ''},
+  {type: 'nonascii\u1234', expected: ''},
+  {type: 'nonparsable', expected: 'nonparsable'}
+].forEach(testCase => {
+  test(t => {
+    var file = new File(["bits"], "dummy", { type: testCase.type});
+    assert_true(file instanceof File);
+    assert_equals(file.type, testCase.expected);
+  }, `Using type in File constructor: ${testCase.type}`);
+});
+test(function() {
+  var file = new File(["bits"], "dummy", { lastModified: 42 });
+  assert_true(file instanceof File);
+  assert_equals(file.lastModified, 42);
+}, "Using lastModified");
+test(function() {
+  var file = new File(["bits"], "dummy", { name: "foo" });
+  assert_true(file instanceof File);
+  assert_equals(file.name, "dummy");
+}, "Misusing name");
+test(function() {
+  var file = new File(["bits"], "dummy", { unknownKey: "value" });
+  assert_true(file instanceof File);
+  assert_equals(file.name, "dummy");
+}, "Unknown properties are ignored");
+
+[
+  123,
+  123.4,
+  true,
+  'abc'
+].forEach(arg => {
+  test(t => {
+    assert_throws_js(TypeError, () => new File(['bits'], 'name.txt', arg),
+                     'Constructor should throw for invalid property bag type');
+  }, `Invalid property bag: ${JSON.stringify(arg)}`);
+});
+
+[
+  null,
+  undefined,
+  [1,2,3],
+  /regex/,
+  function() {}
+].forEach(arg => {
+  test(t => {
+    assert_equals(new File(['bits'], 'name.txt', arg).size, 4,
+                  'Constructor should accept object-ish property bag type');
+  }, `Unusual but valid property bag: ${arg}`);
+});
+
+test(t => {
+  assert_throws_js(Error,
+                   () => new File(['bits'], 'name.txt', {type: to_string_throws}),
+                   'Constructor should propagate exceptions');
+}, 'Property bag propagates exceptions');
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/Worker-read-file-constructor.worker.js b/test/fixtures/wpt/FileAPI/file/Worker-read-file-constructor.worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e003b3c958a94da268f41edf9b7a3e0d5eeb97e
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/Worker-read-file-constructor.worker.js
@@ -0,0 +1,15 @@
+importScripts("/resources/testharness.js");
+
+async_test(function() {
+  var file = new File(["bits"], "dummy", { 'type': 'text/plain', lastModified: 42 });
+  var reader = new FileReader();
+  reader.onload = this.step_func_done(function() {
+    assert_equals(file.name, "dummy", "file name");
+    assert_equals(reader.result, "bits", "file content");
+    assert_equals(file.lastModified, 42, "file lastModified");
+  });
+  reader.onerror = this.unreached_func("Unexpected error event");
+  reader.readAsText(file);
+}, "FileReader in Worker");
+
+done();
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-controls.html b/test/fixtures/wpt/FileAPI/file/send-file-form-controls.html
new file mode 100644
index 0000000000000000000000000000000000000000..6347065bcae14b6e927a6918bfae61d58cb2b98e
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-controls.html
@@ -0,0 +1,113 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<title>Upload files named using controls</title>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data"
+/>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist"
+/>
+<link rel="help" href="https://w3c.github.io/FileAPI/#file-constructor" />
+<link
+  rel="author"
+  title="Benjamin C. Wiley Sittler"
+  href="mailto:bsittler@chromium.org"
+/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+  "use strict";
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-NUL-[\0].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-NUL-[\0].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-BS-[\b].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-BS-[\b].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-VT-[\v].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-VT-[\v].txt",
+  });
+
+  // These have characters that undergo processing in name=,
+  // filename=, and/or value; formPostFileUploadTest postprocesses
+  // expectedEncodedBaseName for these internally.
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LF-[\n].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-LF-[\n].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LF-CR-[\n\r].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-LF-CR-[\n\r].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CR-[\r].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-CR-[\r].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CR-LF-[\r\n].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-CR-LF-[\r\n].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-HT-[\t].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-HT-[\t].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-FF-[\f].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-FF-[\f].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-DEL-[\x7F].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-DEL-[\x7F].txt",
+  });
+
+  // The rest should be passed through unmodified:
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-ESC-[\x1B].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-ESC-[\x1B].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SPACE-[ ].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-SPACE-[ ].txt",
+  });
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-controls.tentative.html b/test/fixtures/wpt/FileAPI/file/send-file-form-controls.tentative.html
new file mode 100644
index 0000000000000000000000000000000000000000..d11f4a860931b4249f8c15d87143b8904cb61364
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-controls.tentative.html
@@ -0,0 +1,117 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<title>Upload files named using controls (tentative)</title>
+<!--
+    NOTE: This test is tentative because encoding for filename
+    control characters is not yet standardized.
+  -->
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data"
+/>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist"
+/>
+<link rel="help" href="https://w3c.github.io/FileAPI/#file-constructor" />
+<link
+  rel="author"
+  title="Benjamin C. Wiley Sittler"
+  href="mailto:bsittler@chromium.org"
+/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+  "use strict";
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-NUL-[\0].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-NUL-[\0].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-BS-[\b].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-BS-[\b].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-VT-[\v].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-VT-[\v].txt",
+  });
+
+  // These have characters that undergo processing in name=,
+  // filename=, and/or value; formPostFileUploadTest postprocesses
+  // expectedEncodedBaseName for these internally.
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LF-[\n].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-LF-[\n].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LF-CR-[\n\r].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-LF-CR-[\n\r].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CR-[\r].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-CR-[\r].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CR-LF-[\r\n].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-CR-LF-[\r\n].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-HT-[\t].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-HT-[\t].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-FF-[\f].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-FF-[\f].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-DEL-[\x7F].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-DEL-[\x7F].txt",
+  });
+
+  // The rest should be passed through unmodified:
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-ESC-[\x1B].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-ESC-[\x1B].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SPACE-[ ].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-SPACE-[ ].txt",
+  });
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-iso-2022-jp.html b/test/fixtures/wpt/FileAPI/file/send-file-form-iso-2022-jp.html
new file mode 100644
index 0000000000000000000000000000000000000000..c931c9be3aba8c6e81c7ef98c66852b939fba134
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-iso-2022-jp.html
@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<meta name=timeout content=long>
+<title>Upload files in ISO-2022-JP form</title>
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
+<link rel="help"
+      href="https://w3c.github.io/FileAPI/#file-constructor">
+<link rel="author" title="Benjamin C. Wiley Sittler"
+      href="mailto:bsittler@chromium.org">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+'use strict';
+
+formPostFileUploadTest({
+  fileNameSource: 'ASCII',
+  fileBaseName: 'file-for-upload-in-form.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'x-user-defined',
+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: (
+      'file-for-upload-in-form-&#63472;&#63379;&#63363;&#63392;.txt'),
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'windows-1252',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: (
+      'file-for-upload-in-form-&#226;&#732;&#186;&#240;&#376;&#732;&#8218;.txt'),
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'JIS X 0201 and JIS X 0208',
+  fileBaseName: 'file-for-upload-in-form-★星★.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: 'file-for-upload-in-form-\x1B$B!z@1!z\x1B(B.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: `file-for-upload-in-form-${
+      kTestFallbackIso2022jp
+  }.txt`,
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-iso-2022-jp.tentative.html b/test/fixtures/wpt/FileAPI/file/send-file-form-iso-2022-jp.tentative.html
new file mode 100644
index 0000000000000000000000000000000000000000..659af3bde85852d6f244cb51558a14c6ebef2830
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-iso-2022-jp.tentative.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<meta name=timeout content=long>
+<title>Upload files in ISO-2022-JP form (tentative)</title>
+<!--
+    NOTE: This test is tentative because encoding for filename
+    characters unrepresentable in the form charset is not yet
+    standardized.
+  -->
+<link rel="help"
+      href="https://github.com/whatwg/html/issues/3223">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
+<link rel="help"
+      href="https://w3c.github.io/FileAPI/#file-constructor">
+<link rel="author" title="Benjamin C. Wiley Sittler"
+      href="mailto:bsittler@chromium.org">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+'use strict';
+
+formPostFileUploadTest({
+  fileNameSource: 'ASCII',
+  fileBaseName: 'file-for-upload-in-form.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'x-user-defined',
+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: (
+      'file-for-upload-in-form-&#63472;&#63379;&#63363;&#63392;.txt'),
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'windows-1252',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: (
+      'file-for-upload-in-form-&#226;&#732;&#186;&#240;&#376;&#732;&#8218;.txt'),
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'JIS X 0201 and JIS X 0208',
+  fileBaseName: 'file-for-upload-in-form-★星★.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: 'file-for-upload-in-form-\x1B$B!z@1!z\x1B(B.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
+  formEncoding: 'ISO-2022-JP',
+  expectedEncodedBaseName: `file-for-upload-in-form-${
+      kTestFallbackIso2022jp
+  }.txt`,
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-punctuation.html b/test/fixtures/wpt/FileAPI/file/send-file-form-punctuation.html
new file mode 100644
index 0000000000000000000000000000000000000000..a6568e2e56e4d524a0cc439c7b75474ff5e1783c
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-punctuation.html
@@ -0,0 +1,226 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<title>Upload files named using punctuation</title>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data"
+/>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist"
+/>
+<link rel="help" href="https://w3c.github.io/FileAPI/#file-constructor" />
+<link
+  rel="author"
+  title="Benjamin C. Wiley Sittler"
+  href="mailto:bsittler@chromium.org"
+/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+  "use strict";
+
+  // These have characters that undergo processing in name=,
+  // filename=, and/or value; formPostFileUploadTest postprocesses
+  // expectedEncodedBaseName for these internally.
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-QUOTATION-MARK-[\x22].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-QUOTATION-MARK-[\x22].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: '"file-for-upload-in-form-double-quoted.txt"',
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: '"file-for-upload-in-form-double-quoted.txt"',
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-REVERSE-SOLIDUS-[\\].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-REVERSE-SOLIDUS-[\\].txt",
+  });
+
+  // The rest should be passed through unmodified:
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-EXCLAMATION-MARK-[!].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-EXCLAMATION-MARK-[!].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-DOLLAR-SIGN-[$].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-DOLLAR-SIGN-[$].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-PERCENT-SIGN-[%].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-PERCENT-SIGN-[%].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-AMPERSAND-[&].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-AMPERSAND-[&].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-APOSTROPHE-['].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-APOSTROPHE-['].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-PARENTHESIS-[(].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-LEFT-PARENTHESIS-[(].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-PARENTHESIS-[)].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-RIGHT-PARENTHESIS-[)].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-ASTERISK-[*].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-ASTERISK-[*].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-PLUS-SIGN-[+].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-PLUS-SIGN-[+].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-COMMA-[,].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-COMMA-[,].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-FULL-STOP-[.].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-FULL-STOP-[.].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SOLIDUS-[/].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-SOLIDUS-[/].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-COLON-[:].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-COLON-[:].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SEMICOLON-[;].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-SEMICOLON-[;].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-EQUALS-SIGN-[=].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-EQUALS-SIGN-[=].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-QUESTION-MARK-[?].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-QUESTION-MARK-[?].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CIRCUMFLEX-ACCENT-[^].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-CIRCUMFLEX-ACCENT-[^].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-SQUARE-BRACKET-[[].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-LEFT-SQUARE-BRACKET-[[].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-SQUARE-BRACKET-[]].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-RIGHT-SQUARE-BRACKET-[]].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-CURLY-BRACKET-[{].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-LEFT-CURLY-BRACKET-[{].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-VERTICAL-LINE-[|].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-VERTICAL-LINE-[|].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-CURLY-BRACKET-[}].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-RIGHT-CURLY-BRACKET-[}].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-TILDE-[~].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-TILDE-[~].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "'file-for-upload-in-form-single-quoted.txt'",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "'file-for-upload-in-form-single-quoted.txt'",
+  });
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-punctuation.tentative.html b/test/fixtures/wpt/FileAPI/file/send-file-form-punctuation.tentative.html
new file mode 100644
index 0000000000000000000000000000000000000000..5c2d6d0bf1fe0196932aa1cbddb3c6669db44698
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-punctuation.tentative.html
@@ -0,0 +1,230 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<title>Upload files named using punctuation (tentative)</title>
+<!--
+    NOTE: This test is tentative because encoding for filename
+    punctuation characters is not yet standardized.
+  -->
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data"
+/>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist"
+/>
+<link rel="help" href="https://w3c.github.io/FileAPI/#file-constructor" />
+<link
+  rel="author"
+  title="Benjamin C. Wiley Sittler"
+  href="mailto:bsittler@chromium.org"
+/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+  "use strict";
+
+  // These have characters that undergo processing in name=,
+  // filename=, and/or value; formPostFileUploadTest postprocesses
+  // expectedEncodedBaseName for these internally.
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-QUOTATION-MARK-[\x22].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-QUOTATION-MARK-[\x22].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: '"file-for-upload-in-form-double-quoted.txt"',
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: '"file-for-upload-in-form-double-quoted.txt"',
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-REVERSE-SOLIDUS-[\\].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-REVERSE-SOLIDUS-[\\].txt",
+  });
+
+  // The rest should be passed through unmodified:
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-EXCLAMATION-MARK-[!].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-EXCLAMATION-MARK-[!].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-DOLLAR-SIGN-[$].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-DOLLAR-SIGN-[$].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-PERCENT-SIGN-[%].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-PERCENT-SIGN-[%].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-AMPERSAND-[&].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-AMPERSAND-[&].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-APOSTROPHE-['].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-APOSTROPHE-['].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-PARENTHESIS-[(].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-LEFT-PARENTHESIS-[(].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-PARENTHESIS-[)].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-RIGHT-PARENTHESIS-[)].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-ASTERISK-[*].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-ASTERISK-[*].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-PLUS-SIGN-[+].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-PLUS-SIGN-[+].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-COMMA-[,].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-COMMA-[,].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-FULL-STOP-[.].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-FULL-STOP-[.].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SOLIDUS-[/].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-SOLIDUS-[/].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-COLON-[:].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-COLON-[:].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SEMICOLON-[;].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-SEMICOLON-[;].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-EQUALS-SIGN-[=].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-EQUALS-SIGN-[=].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-QUESTION-MARK-[?].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-QUESTION-MARK-[?].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CIRCUMFLEX-ACCENT-[^].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-CIRCUMFLEX-ACCENT-[^].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-SQUARE-BRACKET-[[].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-LEFT-SQUARE-BRACKET-[[].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-SQUARE-BRACKET-[]].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-RIGHT-SQUARE-BRACKET-[]].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-CURLY-BRACKET-[{].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-LEFT-CURLY-BRACKET-[{].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-VERTICAL-LINE-[|].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-VERTICAL-LINE-[|].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-CURLY-BRACKET-[}].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName:
+      "file-for-upload-in-form-RIGHT-CURLY-BRACKET-[}].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-TILDE-[~].txt",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "file-for-upload-in-form-TILDE-[~].txt",
+  });
+
+  formPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "'file-for-upload-in-form-single-quoted.txt'",
+    formEncoding: "UTF-8",
+    expectedEncodedBaseName: "'file-for-upload-in-form-single-quoted.txt'",
+  });
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-utf-8.html b/test/fixtures/wpt/FileAPI/file/send-file-form-utf-8.html
new file mode 100644
index 0000000000000000000000000000000000000000..1be44f4f4db09efdf155e5fe27bb18cacecf18e9
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-utf-8.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Upload files in UTF-8 form</title>
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
+<link rel="help"
+      href="https://w3c.github.io/FileAPI/#file-constructor">
+<link rel="author" title="Benjamin C. Wiley Sittler"
+      href="mailto:bsittler@chromium.org">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+'use strict';
+
+formPostFileUploadTest({
+  fileNameSource: 'ASCII',
+  fileBaseName: 'file-for-upload-in-form.txt',
+  formEncoding: 'UTF-8',
+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'x-user-defined',
+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
+  formEncoding: 'UTF-8',
+  expectedEncodedBaseName: (
+      'file-for-upload-in-form-\xEF\x9F\xB0\xEF\x9E\x93\xEF\x9E\x83\xEF\x9E\xA0.txt'),
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'windows-1252',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'UTF-8',
+  expectedEncodedBaseName: (
+      'file-for-upload-in-form-\xC3\xA2\xCB\x9C\xC2\xBA\xC3\xB0\xC5\xB8\xCB\x9C\xE2\x80\x9A.txt'),
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'JIS X 0201 and JIS X 0208',
+  fileBaseName: 'file-for-upload-in-form-★星★.txt',
+  formEncoding: 'UTF-8',
+  expectedEncodedBaseName: 'file-for-upload-in-form-\xE2\x98\x85\xE6\x98\x9F\xE2\x98\x85.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'UTF-8',
+  expectedEncodedBaseName: 'file-for-upload-in-form-\xE2\x98\xBA\xF0\x9F\x98\x82.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
+  formEncoding: 'UTF-8',
+  expectedEncodedBaseName: `file-for-upload-in-form-${kTestFallbackUtf8}.txt`,
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-windows-1252.html b/test/fixtures/wpt/FileAPI/file/send-file-form-windows-1252.html
new file mode 100644
index 0000000000000000000000000000000000000000..21b219ffd2d066092f8f2126b8cdce6f45063994
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-windows-1252.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Upload files in Windows-1252 form</title>
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
+<link rel="help"
+      href="https://w3c.github.io/FileAPI/#file-constructor">
+<link rel="author" title="Benjamin C. Wiley Sittler"
+      href="mailto:bsittler@chromium.org">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+'use strict';
+
+formPostFileUploadTest({
+  fileNameSource: 'ASCII',
+  fileBaseName: 'file-for-upload-in-form.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'x-user-defined',
+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#63472;&#63379;&#63363;&#63392;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'windows-1252',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form-\xE2\x98\xBA\xF0\x9F\x98\x82.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'JIS X 0201 and JIS X 0208',
+  fileBaseName: 'file-for-upload-in-form-★星★.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9733;&#26143;&#9733;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: `file-for-upload-in-form-${
+      kTestFallbackWindows1252
+  }.txt`,
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-windows-1252.tentative.html b/test/fixtures/wpt/FileAPI/file/send-file-form-windows-1252.tentative.html
new file mode 100644
index 0000000000000000000000000000000000000000..a2c37186b3e023d19ba3d731cd642f1f3fcdada8
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-windows-1252.tentative.html
@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Upload files in Windows-1252 form (tentative)</title>
+<!--
+    NOTE: This test is tentative because encoding for filename
+    characters unrepresentable in the form charset is not yet
+    standardized.
+  -->
+<link rel="help"
+      href="https://github.com/whatwg/html/issues/3223">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
+<link rel="help"
+      href="https://w3c.github.io/FileAPI/#file-constructor">
+<link rel="author" title="Benjamin C. Wiley Sittler"
+      href="mailto:bsittler@chromium.org">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+'use strict';
+
+formPostFileUploadTest({
+  fileNameSource: 'ASCII',
+  fileBaseName: 'file-for-upload-in-form.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'x-user-defined',
+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#63472;&#63379;&#63363;&#63392;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'windows-1252',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form-\xE2\x98\xBA\xF0\x9F\x98\x82.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'JIS X 0201 and JIS X 0208',
+  fileBaseName: 'file-for-upload-in-form-★星★.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9733;&#26143;&#9733;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
+  formEncoding: 'windows-1252',
+  expectedEncodedBaseName: `file-for-upload-in-form-${
+      kTestFallbackWindows1252
+  }.txt`,
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-x-user-defined.html b/test/fixtures/wpt/FileAPI/file/send-file-form-x-user-defined.html
new file mode 100644
index 0000000000000000000000000000000000000000..8d6605d86deb1c24e2385381c106fd57fc4a29ac
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-x-user-defined.html
@@ -0,0 +1,63 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Upload files in x-user-defined form</title>
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
+<link rel="help"
+      href="https://w3c.github.io/FileAPI/#file-constructor">
+<link rel="author" title="Benjamin C. Wiley Sittler"
+      href="mailto:bsittler@chromium.org">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+'use strict';
+
+formPostFileUploadTest({
+  fileNameSource: 'ASCII',
+  fileBaseName: 'file-for-upload-in-form.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'x-user-defined',
+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: 'file-for-upload-in-form-\xF0\x93\x83\xA0.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'windows-1252',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: ('file-for-upload-in-form-' +
+                            '&#226;&#732;&#186;&#240;&#376;&#732;&#8218;.txt'),
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'JIS X 0201 and JIS X 0208',
+  fileBaseName: 'file-for-upload-in-form-★星★.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9733;&#26143;&#9733;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: `file-for-upload-in-form-${
+      kTestFallbackXUserDefined
+  }.txt`,
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form-x-user-defined.tentative.html b/test/fixtures/wpt/FileAPI/file/send-file-form-x-user-defined.tentative.html
new file mode 100644
index 0000000000000000000000000000000000000000..503b08a51706f77eeda7ca066c18200ad6750699
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form-x-user-defined.tentative.html
@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Upload files in x-user-defined form (tentative)</title>
+<!--
+    NOTE: This test is tentative because encoding for filename
+    characters unrepresentable in the form charset is not yet
+    standardized.
+  -->
+<link rel="help"
+      href="https://github.com/whatwg/html/issues/3223">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
+<link rel="help"
+      href="https://w3c.github.io/FileAPI/#file-constructor">
+<link rel="author" title="Benjamin C. Wiley Sittler"
+      href="mailto:bsittler@chromium.org">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+'use strict';
+
+formPostFileUploadTest({
+  fileNameSource: 'ASCII',
+  fileBaseName: 'file-for-upload-in-form.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'x-user-defined',
+  fileBaseName: 'file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: 'file-for-upload-in-form-\xF0\x93\x83\xA0.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'windows-1252',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: ('file-for-upload-in-form-' +
+                            '&#226;&#732;&#186;&#240;&#376;&#732;&#8218;.txt'),
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'JIS X 0201 and JIS X 0208',
+  fileBaseName: 'file-for-upload-in-form-★星★.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9733;&#26143;&#9733;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: 'file-for-upload-in-form-☺😂.txt',
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: 'file-for-upload-in-form-&#9786;&#128514;.txt',
+});
+
+formPostFileUploadTest({
+  fileNameSource: 'Unicode',
+  fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
+  formEncoding: 'x-user-defined',
+  expectedEncodedBaseName: `file-for-upload-in-form-${
+      kTestFallbackXUserDefined
+  }.txt`,
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-form.html b/test/fixtures/wpt/FileAPI/file/send-file-form.html
new file mode 100644
index 0000000000000000000000000000000000000000..baa8d4286c5789c55168cebf5496982b20d06083
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-form.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Upload ASCII-named file in UTF-8 form</title>
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">
+<link rel="help"
+      href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist">
+<link rel="help"
+      href="https://w3c.github.io/FileAPI/#file-constructor">
+<link rel="author" title="Benjamin C. Wiley Sittler"
+      href="mailto:bsittler@chromium.org">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-form-helper.js"></script>
+<script>
+'use strict';
+
+formPostFileUploadTest({
+  fileNameSource: 'ASCII',
+  fileBaseName: 'file-for-upload-in-form.txt',
+  formEncoding: 'UTF-8',
+  expectedEncodedBaseName: 'file-for-upload-in-form.txt',
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-formdata-controls.tentative.html b/test/fixtures/wpt/FileAPI/file/send-file-formdata-controls.tentative.html
new file mode 100644
index 0000000000000000000000000000000000000000..4259741b63ef316613a2fbea4236bbcbe6cfb1df
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-formdata-controls.tentative.html
@@ -0,0 +1,93 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<title>FormData: Upload files named using controls (tentative)</title>
+<!--
+    NOTE: This test is tentative because encoding for filename
+    control characters is not yet standardized.
+  -->
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data"
+/>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist"
+/>
+<link rel="help" href="https://w3c.github.io/FileAPI/#file-constructor" />
+<link
+  rel="author"
+  title="Benjamin C. Wiley Sittler"
+  href="mailto:bsittler@chromium.org"
+/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-formdata-helper.js"></script>
+<script>
+  "use strict";
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-NUL-[\0].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-BS-[\b].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-VT-[\v].txt",
+  });
+
+  // These have characters that undergo processing in name=,
+  // filename=, and/or value; formDataPostFileUploadTest postprocesses
+  // expectedEncodedBaseName for these internally.
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LF-[\n].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LF-CR-[\n\r].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CR-[\r].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CR-LF-[\r\n].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-HT-[\t].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-FF-[\f].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-DEL-[\x7F].txt",
+  });
+
+  // The rest should be passed through unmodified:
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-ESC-[\x1B].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SPACE-[ ].txt",
+  });
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-formdata-punctuation.tentative.html b/test/fixtures/wpt/FileAPI/file/send-file-formdata-punctuation.tentative.html
new file mode 100644
index 0000000000000000000000000000000000000000..d8e84e9d978094f84c5c0fb06526fd0734f13efa
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-formdata-punctuation.tentative.html
@@ -0,0 +1,168 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<title>FormData: Upload files named using punctuation (tentative)</title>
+<!--
+    NOTE: This test is tentative because encoding for filename
+    punctuation characters is not yet standardized.
+  -->
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data"
+/>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist"
+/>
+<link rel="help" href="https://w3c.github.io/FileAPI/#file-constructor" />
+<link
+  rel="author"
+  title="Benjamin C. Wiley Sittler"
+  href="mailto:bsittler@chromium.org"
+/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-formdata-helper.js"></script>
+<script>
+  "use strict";
+
+  // These have characters that undergo processing in name=,
+  // filename=, and/or value; formDataPostFileUploadTest postprocesses
+  // expectedEncodedBaseName for these internally.
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-QUOTATION-MARK-[\x22].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: '"file-for-upload-in-form-double-quoted.txt"',
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-REVERSE-SOLIDUS-[\\].txt",
+  });
+
+  // The rest should be passed through unmodified:
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-EXCLAMATION-MARK-[!].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-DOLLAR-SIGN-[$].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-PERCENT-SIGN-[%].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-AMPERSAND-[&].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-APOSTROPHE-['].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-PARENTHESIS-[(].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-PARENTHESIS-[)].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-ASTERISK-[*].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-PLUS-SIGN-[+].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-COMMA-[,].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-FULL-STOP-[.].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SOLIDUS-[/].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-COLON-[:].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-SEMICOLON-[;].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-EQUALS-SIGN-[=].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-QUESTION-MARK-[?].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-CIRCUMFLEX-ACCENT-[^].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-SQUARE-BRACKET-[[].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-SQUARE-BRACKET-[]].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-LEFT-CURLY-BRACKET-[{].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-VERTICAL-LINE-[|].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-RIGHT-CURLY-BRACKET-[}].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form-TILDE-[~].txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "'file-for-upload-in-form-single-quoted.txt'",
+  });
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-formdata-utf-8.html b/test/fixtures/wpt/FileAPI/file/send-file-formdata-utf-8.html
new file mode 100644
index 0000000000000000000000000000000000000000..7a7f6cefe776b9d4c9ed29c6652a6978be5dbb4b
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-formdata-utf-8.html
@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<title>FormData: Upload files in UTF-8 fetch()</title>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data"
+/>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist"
+/>
+<link rel="help" href="https://w3c.github.io/FileAPI/#file-constructor" />
+<link
+  rel="author"
+  title="Benjamin C. Wiley Sittler"
+  href="mailto:bsittler@chromium.org"
+/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-formdata-helper.js"></script>
+<script>
+  "use strict";
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form.txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "x-user-defined",
+    fileBaseName: "file-for-upload-in-form-\uF7F0\uF793\uF783\uF7A0.txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "windows-1252",
+    fileBaseName: "file-for-upload-in-form-☺😂.txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "JIS X 0201 and JIS X 0208",
+    fileBaseName: "file-for-upload-in-form-★星★.txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "Unicode",
+    fileBaseName: "file-for-upload-in-form-☺😂.txt",
+  });
+
+  formDataPostFileUploadTest({
+    fileNameSource: "Unicode",
+    fileBaseName: `file-for-upload-in-form-${kTestChars}.txt`,
+  });
+</script>
diff --git a/test/fixtures/wpt/FileAPI/file/send-file-formdata.html b/test/fixtures/wpt/FileAPI/file/send-file-formdata.html
new file mode 100644
index 0000000000000000000000000000000000000000..77e048e54741c013ab5ce9395265de28e1de8771
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/file/send-file-formdata.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<title>FormData: Upload ASCII-named file in UTF-8 form</title>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data"
+/>
+<link
+  rel="help"
+  href="https://html.spec.whatwg.org/multipage/dnd.html#datatransferitemlist"
+/>
+<link rel="help" href="https://w3c.github.io/FileAPI/#file-constructor" />
+<link
+  rel="author"
+  title="Benjamin C. Wiley Sittler"
+  href="mailto:bsittler@chromium.org"
+/>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../support/send-file-formdata-helper.js"></script>
+<script>
+  "use strict";
+
+  formDataPostFileUploadTest({
+    fileNameSource: "ASCII",
+    fileBaseName: "file-for-upload-in-form.txt",
+  });
+</script>
diff --git a/test/fixtures/wpt/FileAPI/fileReader.html b/test/fixtures/wpt/FileAPI/fileReader.html
new file mode 100644
index 0000000000000000000000000000000000000000..b767e22d4a66eba06560617405952dfbefa2c084
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/fileReader.html
@@ -0,0 +1,67 @@
+<!doctype html>
+<html>
+  <head>
+      <title>FileReader States</title>
+      <link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-filereader">
+      <link rel=author title="Lenient" href="mailto:lenient315@gmail.com">
+      <script src="/resources/testharness.js"></script>
+      <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+    <script>
+        test(function() {
+             assert_true("FileReader" in window, "window should have a FileReader property.");
+        }, "FileReader interface object");
+
+        test(function(){
+            var fileReader = new FileReader();
+            assert_true(fileReader instanceof FileReader);
+        }, "no-argument FileReader constructor");
+
+        var t_abort = async_test("FileReader States -- abort");
+        t_abort.step(function(){
+            var fileReader = new FileReader();
+            assert_equals(fileReader.readyState, 0);
+            assert_equals(fileReader.readyState, FileReader.EMPTY);
+
+            var blob = new Blob();
+            fileReader.readAsArrayBuffer(blob);
+            assert_equals(fileReader.readyState, 1);
+            assert_equals(fileReader.readyState, FileReader.LOADING);
+
+            fileReader.onabort = this.step_func(function(e) {
+                assert_equals(fileReader.readyState, 2);
+                assert_equals(fileReader.readyState, FileReader.DONE);
+                t_abort.done();
+            });
+            fileReader.abort();
+            fileReader.onabort = this.unreached_func("abort event should fire sync")
+        });
+
+        var t_event = async_test("FileReader States -- events");
+        t_event.step(function(){
+            var fileReader = new FileReader();
+
+            var blob = new Blob();
+            fileReader.readAsArrayBuffer(blob);
+
+            fileReader.onloadstart = this.step_func(function(e) {
+                assert_equals(fileReader.readyState, 1);
+                assert_equals(fileReader.readyState, FileReader.LOADING);
+            });
+
+            fileReader.onprogress = this.step_func(function(e) {
+                assert_equals(fileReader.readyState, 1);
+                assert_equals(fileReader.readyState, FileReader.LOADING);
+            });
+
+            fileReader.onloadend = this.step_func(function(e) {
+                assert_equals(fileReader.readyState, 2);
+                assert_equals(fileReader.readyState, FileReader.DONE);
+                t_event.done();
+            });
+        });
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/filelist-section/filelist.html b/test/fixtures/wpt/FileAPI/filelist-section/filelist.html
new file mode 100644
index 0000000000000000000000000000000000000000..b97dcde19f647c80c2454483424b99ea0c512abf
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/filelist-section/filelist.html
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset='utf-8'>
+    <title>FileAPI Test: filelist</title>
+    <link rel='author' title='Intel' href='http://www.intel.com'>
+    <link rel='help' href='http://dev.w3.org/2006/webapi/FileAPI/#filelist-section'>
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-length">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-item">
+    <script src='/resources/testharness.js'></script>
+    <script src='/resources/testharnessreport.js'></script>
+  </head>
+
+  <body>
+    <form name='uploadData' style="display:none">
+      <input type='file' id='fileChooser'>
+    </form>
+    <div id='log'></div>
+
+    <script>
+      var fileList;
+
+      setup(function () {
+        fileList = document.querySelector('#fileChooser').files;
+      });
+
+      test(function () {
+        assert_true('FileList' in window, 'window has a FileList property');
+      }, 'Check if window has a FileList property');
+
+      test(function () {
+        assert_equals(FileList.length, 0, 'FileList.length is 0');
+      }, 'Check if FileList.length is 0');
+
+      test(function () {
+        assert_true(fileList.item instanceof Function, 'item is a instanceof Function');
+      }, 'Check if item is a instanceof Function');
+
+      test(function() {
+        assert_inherits(fileList, 'item', 'item is a method of fileList');
+      }, 'Check if item is a method of fileList');
+
+      test(function() {
+        assert_equals(fileList.item(0), null, 'item method returns null');
+      }, 'Check if the item method returns null when no file selected');
+
+      test(function() {
+        assert_inherits(fileList, 'length', 'length is fileList attribute');
+      }, 'Check if length is fileList\'s attribute');
+
+      test(function() {
+        assert_equals(fileList.length, 0, 'fileList length is 0');
+      }, 'Check if the fileList length is 0 when no file selected');
+    </script>
+
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/filelist-section/filelist_multiple_selected_files-manual.html b/test/fixtures/wpt/FileAPI/filelist-section/filelist_multiple_selected_files-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..2efaa059fa48978e999a2a23ef28669e45b00c54
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/filelist-section/filelist_multiple_selected_files-manual.html
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset='utf-8'>
+    <title>FileAPI Test: filelist_multiple_selected_files</title>
+    <link rel='author' title='Intel' href='http://www.intel.com'>
+    <link rel='help' href='http://dev.w3.org/2006/webapi/FileAPI/#filelist-section'>
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-length">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-item">
+    <script src='/resources/testharness.js'></script>
+    <script src='/resources/testharnessreport.js'></script>
+  </head>
+
+  <body>
+    <form name='uploadData'>
+      <input type='file' id='fileChooser' multiple>
+    </form>
+    <div>
+      <p>Test steps:</p>
+      <ol>
+        <li>Download <a href='support/upload.txt'>upload.txt</a>, <a href="support/upload.zip">upload.zip</a> to local.</li>
+        <li>Select the local two files (upload.txt, upload.zip) to run the test.</li>
+      </ol>
+    </div>
+
+    <div id='log'></div>
+
+    <script>
+      var fileInput = document.querySelector('#fileChooser');
+      var fileList;
+
+      setup({explicit_done: true, explicit_timeout: true});
+
+      on_event(fileInput, 'change', function(evt) {
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_equals(fileList.length, 2, 'fileList length is 2');
+        }, 'Check if the fileList length is 2 when selected two files');
+
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_true(fileList.item(0) instanceof File, 'item method is instanceof File');
+        }, 'Check if the item method returns the File interface when selected two files');
+
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_not_equals(fileList.item(1), null, 'item(1) is not null');
+        }, 'Check if item(1) is not null when selected two files. Index must be treated by user agents as value for the position of a File object in the FileList, with 0 representing the first file.');
+
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_equals(fileList.item(2), null, 'item(2) is null');
+        }, 'Check if item(2) is null when selected two files');
+
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_array_equals([fileList.item(0).name, fileList.item(1).name], ['upload.txt', 'upload.zip'], 'file name string is the name of selected files "upload.txt", "upload.zip"');
+        }, 'Check if the file name string is the name of selected files');
+
+        done();
+      });
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/filelist-section/filelist_selected_file-manual.html b/test/fixtures/wpt/FileAPI/filelist-section/filelist_selected_file-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..966aadda615589d52bc87df8b3dfcb0569e33693
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/filelist-section/filelist_selected_file-manual.html
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset='utf-8'>
+    <title>FileAPI Test: filelist_selected_file</title>
+    <link rel='author' title='Intel' href='http://www.intel.com'>
+    <link rel='help' href='http://dev.w3.org/2006/webapi/FileAPI/#filelist-section'>
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-length">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-item">
+    <script src='/resources/testharness.js'></script>
+    <script src='/resources/testharnessreport.js'></script>
+  </head>
+
+  <body>
+    <form name='uploadData'>
+      <input type='file' id='fileChooser'>
+    </form>
+    <div>
+      <p>Test steps:</p>
+      <ol>
+        <li>Download <a href='support/upload.txt'>upload.txt</a> to local.</li>
+        <li>Select the local upload.txt file to run the test.</li>
+      </ol>
+    </div>
+
+    <div id='log'></div>
+
+    <script>
+      var fileInput = document.querySelector('#fileChooser');
+      var fileList;
+
+      setup({explicit_done: true, explicit_timeout: true});
+
+      on_event(fileInput, 'change', function(evt) {
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_equals(fileList.length, 1, 'fileList length is 1');
+        }, 'Check if the fileList length is 1 when selected one file');
+
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_true(fileList.item(0) instanceof File, 'item method is instanceof File');
+        }, 'Check if the item method returns the File interface when selected one file');
+
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_not_equals(fileList.item(0), null, 'item(0) is not null');
+        }, 'Check if item(0) is not null when selected one file. Index must be treated by user agents as value for the position of a File object in the FileList, with 0 representing the first file.');
+
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_equals(fileList.item(1), null, 'item(1) is null');
+        }, 'Check if item(1) is null when selected one file only');
+
+        test(function() {
+          fileList = document.querySelector('#fileChooser').files;
+          assert_equals(fileList.item(0).name, 'upload.txt', 'file name string is "upload.txt"');
+        }, 'Check if the file name string is the selected "upload.txt"');
+
+        done();
+      });
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/filelist-section/support/upload.txt b/test/fixtures/wpt/FileAPI/filelist-section/support/upload.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f45965b711f127b6ae2060b00e0753fe08299019
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/filelist-section/support/upload.txt
@@ -0,0 +1 @@
+Hello, this is test file for file upload.
diff --git a/test/fixtures/wpt/FileAPI/historical.https.html b/test/fixtures/wpt/FileAPI/historical.https.html
new file mode 100644
index 0000000000000000000000000000000000000000..4f841f1763945946a4e2445a85a23b5d4326c386
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/historical.https.html
@@ -0,0 +1,65 @@
+<!doctype html>
+<html>
+ <head>
+  <meta charset="utf-8">
+  <title>Historical features</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
+ </head>
+ <body>
+  <div id="log"></div>
+  <script>
+    var removedFromWindow = [
+        'toNativeLineEndings',
+        'FileError',
+        'FileException',
+        'FileHandle',
+        'FileRequest',
+        'MutableFile',
+    ];
+
+    removedFromWindow.forEach(function(name) {
+        test(function() {
+            assert_false(name in window);
+        }, '"' + name + '" should not be supported');
+    });
+
+    test(function() {
+        var b = new Blob();
+        var prefixes = ['op', 'moz', 'webkit', 'ms'];
+        for (var i = 0; i < prefixes.length; ++i) {
+            assert_false(prefixes[i]+'Slice' in b, "'"+prefixes[i]+"Slice' in b");
+            assert_false(prefixes[i]+'Slice' in Blob.prototype, "'"+prefixes[i]+"Slice in Blob.prototype");
+        }
+    }, 'Blob should not support slice prefixed');
+
+    test(function() {
+        var prefixes = ['', 'O', 'Moz', 'WebKit', 'MS'];
+        for (var i = 0; i < prefixes.length; ++i) {
+            assert_false(prefixes[i]+'BlobBuilder' in window, prefixes[i]+'BlobBuilder');
+        }
+    }, 'BlobBuilder should not be supported.');
+
+    test(function() {
+        assert_false('createFor' in URL);
+    }, 'createFor method should not be supported');
+
+    test(function() {
+        var b = new Blob();
+        assert_false('close' in b, 'close in b');
+        assert_false('close' in Blob.prototype, 'close in Blob.prototype');
+        assert_false('isClosed' in b, 'isClosed in b');
+        assert_false('isClosed' in Blob.prototype, 'isClosed in Blob.prototype');
+    }, 'Blob.close() should not be supported');
+
+    test(() => {
+      const f = new File([], "");
+      assert_false("lastModifiedDate" in f);
+      assert_false("lastModifiedDate" in File.prototype);
+    }, "File's lastModifiedDate should not be supported");
+
+    service_worker_test('support/historical-serviceworker.js', 'Service worker test setup');
+  </script>
+ </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/idlharness-manual.html b/test/fixtures/wpt/FileAPI/idlharness-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..c1d8b0c7149d75ede72aa38a55a8d0db689c2b64
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/idlharness-manual.html
@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>File API manual IDL tests</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#conformance">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/resources/WebIDLParser.js"></script>
+    <script src="/resources/idlharness.js"></script>
+  </head>
+  <body>
+    <h1>File API manual IDL tests</h1>
+
+    <p>Either download <a href="support/upload.txt">upload.txt</a> and select it below or select an
+    arbitrary local file.</p>
+
+    <form name="uploadData">
+      <input type="file" id="fileChooser">
+    </form>
+
+    <div id="log"></div>
+
+    <script>
+      const fileInput = document.querySelector("#fileChooser");
+
+      setup({explicit_timeout: true});
+
+      idl_test(
+        ['FileAPI'],
+        ['dom', 'html', 'url'],
+        async idl_array => {
+          await new Promise(resolve => {
+            on_event(fileInput, "change", resolve);
+          });
+          idl_array.add_objects({
+            FileList: [fileInput.files],
+            File: [fileInput.files[0]],
+          });
+        }
+      );
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/idlharness.html b/test/fixtures/wpt/FileAPI/idlharness.html
new file mode 100644
index 0000000000000000000000000000000000000000..5e0a43f80df3f85e187e95d3437e617417b79de8
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/idlharness.html
@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>File API automated IDL tests</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#conformance">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/resources/WebIDLParser.js"></script>
+    <script src="/resources/idlharness.js"></script>
+  </head>
+  <body>
+    <h1>File API automated IDL tests</h1>
+
+    <div id="log"></div>
+
+    <form name="uploadData">
+      <input type="file" id="fileChooser">
+    </form>
+
+    <script>
+      'use strict';
+
+      idl_test(
+        ['FileAPI'],
+        ['dom', 'html', 'url'],
+        idl_array => {
+          idl_array.add_objects({
+            Blob: ['new Blob(["TEST"])'],
+            File: ['new File(["myFileBits"], "myFileName")'],
+            FileList: ['document.querySelector("#fileChooser").files'],
+            FileReader: ['new FileReader()']
+          });
+        }
+      );
+    </script>
+
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/idlharness.worker.js b/test/fixtures/wpt/FileAPI/idlharness.worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..786b7e4199fb45f3a8d0e113392a8239ddd4bc33
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/idlharness.worker.js
@@ -0,0 +1,20 @@
+importScripts("/resources/testharness.js");
+importScripts("/resources/WebIDLParser.js", "/resources/idlharness.js");
+
+'use strict';
+
+// https://w3c.github.io/FileAPI/
+
+idl_test(
+  ['FileAPI'],
+  ['dom', 'html', 'url'],
+  idl_array => {
+    idl_array.add_objects({
+      Blob: ['new Blob(["TEST"])'],
+      File: ['new File(["myFileBits"], "myFileName")'],
+      FileReader: ['new FileReader()'],
+      FileReaderSync: ['new FileReaderSync()']
+    });
+  }
+);
+done();
diff --git a/test/fixtures/wpt/FileAPI/progress-manual.html b/test/fixtures/wpt/FileAPI/progress-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..b2e03b3eb27387414391721fa09fd5ab283e1fda
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/progress-manual.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Process Events for FileReader</title>
+<link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#event-handler-attributes-section">
+<link rel=author title="Jinks Zhao" href="mailto:jinks@maxthon.com">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+Please choose one file through this input below.<br>
+<input type="file" id="filer">
+<div id="log"></div>
+<script>
+var input, reader, progressEventCounter, progressEventTimeList,
+    lastProgressEventTime;
+setup(function() {
+    input = document.getElementById('filer');
+    reader = new FileReader();
+    progressEventCounter = 0;
+    progressEventTimeList = [];
+    lastProgressEventTime;
+}, { explicit_timeout: true });
+
+var t = async_test("FileReader progress events.")
+
+reader.onprogress = t.step_func(function () {
+    var newTime = new Date;
+    var timeout = newTime - lastProgressEventTime;
+
+    progressEventTimeList.push(timeout);
+    lastProgressEventTime = newTime;
+    progressEventCounter++;
+
+    assert_less_than_equal(timeout, 50, "The progress event should be fired every 50ms.");
+});
+
+reader.onload = t.step_func_done(function () {
+    assert_greater_than_equal(progressEventCounter, 1,
+                              "When read completely, the progress event must be fired at least once.")
+});
+
+input.onchange = t.step_func(function () {
+    var files = input.files;
+
+    assert_greater_than(files.length, 0);
+    var file = files[0];
+
+    lastProgressEventTime = new Date;
+    reader.readAsArrayBuffer(file);
+});
+</script>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/Determining-Encoding.html b/test/fixtures/wpt/FileAPI/reading-data-section/Determining-Encoding.html
new file mode 100644
index 0000000000000000000000000000000000000000..d65ae9db18a1ff4dc87258505c3f966e81b4c542
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/Determining-Encoding.html
@@ -0,0 +1,91 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>FileAPI Test: Blob Determining Encoding</title>
+<link ref="author" title="march1993" href="mailto:march511@gmail.com">
+<link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#enctype">
+<link rel=help href="http://encoding.spec.whatwg.org/#decode">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="log"></div>
+<script>
+var t = async_test("Blob Determing Encoding with encoding argument");
+t.step(function() {
+    // string 'hello'
+    var data = [0xFE,0xFF,0x00,0x68,0x00,0x65,0x00,0x6C,0x00,0x6C,0x00,0x6F];
+    var blob = new Blob([new Uint8Array(data)]);
+    var reader = new FileReader();
+
+    reader.onloadend = t.step_func_done (function(event) {
+        assert_equals(this.result, "hello", "The FileReader should read the ArrayBuffer through UTF-16BE.")
+    }, reader);
+
+    reader.readAsText(blob, "UTF-16BE");
+});
+
+var t = async_test("Blob Determing Encoding with type attribute");
+t.step(function() {
+    var data = [0xFE,0xFF,0x00,0x68,0x00,0x65,0x00,0x6C,0x00,0x6C,0x00,0x6F];
+    var blob = new Blob([new Uint8Array(data)], {type:"text/plain;charset=UTF-16BE"});
+    var reader = new FileReader();
+
+    reader.onloadend = t.step_func_done (function(event) {
+        assert_equals(this.result, "hello", "The FileReader should read the ArrayBuffer through UTF-16BE.")
+    }, reader);
+
+    reader.readAsText(blob);
+});
+
+
+var t = async_test("Blob Determing Encoding with UTF-8 BOM");
+t.step(function() {
+    var data = [0xEF,0xBB,0xBF,0x68,0x65,0x6C,0x6C,0xC3,0xB6];
+    var blob = new Blob([new Uint8Array(data)]);
+    var reader = new FileReader();
+
+    reader.onloadend = t.step_func_done (function(event) {
+        assert_equals(this.result, "hellö", "The FileReader should read the blob with UTF-8.");
+    }, reader);
+
+    reader.readAsText(blob);
+});
+
+var t = async_test("Blob Determing Encoding without anything implying charset.");
+t.step(function() {
+    var data = [0x68,0x65,0x6C,0x6C,0xC3,0xB6];
+    var blob = new Blob([new Uint8Array(data)]);
+    var reader = new FileReader();
+
+    reader.onloadend = t.step_func_done (function(event) {
+        assert_equals(this.result, "hellö", "The FileReader should read the blob by default with UTF-8.");
+    }, reader);
+
+    reader.readAsText(blob);
+});
+
+var t = async_test("Blob Determing Encoding with UTF-16BE BOM");
+t.step(function() {
+    var data = [0xFE,0xFF,0x00,0x68,0x00,0x65,0x00,0x6C,0x00,0x6C,0x00,0x6F];
+    var blob = new Blob([new Uint8Array(data)]);
+    var reader = new FileReader();
+
+    reader.onloadend = t.step_func_done (function(event) {
+        assert_equals(this.result, "hello", "The FileReader should read the ArrayBuffer through UTF-16BE.");
+    }, reader);
+
+    reader.readAsText(blob);
+});
+
+var t = async_test("Blob Determing Encoding with UTF-16LE BOM");
+t.step(function() {
+    var data = [0xFF,0xFE,0x68,0x00,0x65,0x00,0x6C,0x00,0x6C,0x00,0x6F,0x00];
+    var blob = new Blob([new Uint8Array(data)]);
+    var reader = new FileReader();
+
+    reader.onloadend = t.step_func_done (function(event) {
+        assert_equals(this.result, "hello", "The FileReader should read the ArrayBuffer through UTF-16LE.");
+    }, reader);
+
+    reader.readAsText(blob);
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/FileReader-event-handler-attributes.html b/test/fixtures/wpt/FileAPI/reading-data-section/FileReader-event-handler-attributes.html
new file mode 100644
index 0000000000000000000000000000000000000000..86657b5711aff156a4bb60f6d1add3f301cc25cc
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/FileReader-event-handler-attributes.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>FileReader event handler attributes</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id=log></div>
+<script>
+var attributes = [
+  "onloadstart",
+  "onprogress",
+  "onload",
+  "onabort",
+  "onerror",
+  "onloadend",
+];
+attributes.forEach(function(a) {
+  test(function() {
+    var reader = new FileReader();
+    assert_equals(reader[a], null,
+                  "event handler attribute should initially be null");
+  }, "FileReader." + a + ": initial value");
+});
+</script>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/FileReader-multiple-reads.html b/test/fixtures/wpt/FileAPI/reading-data-section/FileReader-multiple-reads.html
new file mode 100644
index 0000000000000000000000000000000000000000..e7279fe4bd445e9fec2495b6682054dc91c97fe9
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/FileReader-multiple-reads.html
@@ -0,0 +1,89 @@
+<!DOCTYPE html>
+<title>FileReader: starting new reads while one is in progress</title>
+<link rel="author" title="Yinkan Li" href="mailto:liyinkan.biz@gmail.com">
+<link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#MultipleReads">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="log"></div>
+<script>
+test(function() {
+  var blob_1 = new Blob(['TEST000000001'])
+  var blob_2 = new Blob(['TEST000000002'])
+  var reader = new FileReader();
+  reader.readAsText(blob_1)
+  assert_equals(reader.readyState, FileReader.LOADING, "readyState Must be LOADING")
+  assert_throws_dom("InvalidStateError", function () {
+    reader.readAsText(blob_2)
+  })
+}, 'test FileReader InvalidStateError exception for readAsText');
+
+test(function() {
+  var blob_1 = new Blob(['TEST000000001'])
+  var blob_2 = new Blob(['TEST000000002'])
+  var reader = new FileReader();
+  reader.readAsDataURL(blob_1)
+  assert_equals(reader.readyState, FileReader.LOADING, "readyState Must be LOADING")
+  assert_throws_dom("InvalidStateError", function () {
+    reader.readAsDataURL(blob_2)
+  })
+}, 'test FileReader InvalidStateError exception for readAsDataURL');
+
+test(function() {
+  var blob_1 = new Blob(['TEST000000001'])
+  var blob_2 = new Blob(['TEST000000002'])
+  var reader = new FileReader();
+  reader.readAsArrayBuffer(blob_1)
+  assert_equals(reader.readyState, FileReader.LOADING, "readyState Must be LOADING")
+  assert_throws_dom("InvalidStateError", function () {
+    reader.readAsArrayBuffer(blob_2)
+  })
+}, 'test FileReader InvalidStateError exception for readAsArrayBuffer');
+
+async_test(function() {
+  var blob_1 = new Blob(['TEST000000001'])
+  var blob_2 = new Blob(['TEST000000002'])
+  var reader = new FileReader();
+  var triggered = false;
+  reader.onloadstart = this.step_func_done(function() {
+    assert_false(triggered, "Only one loadstart event should be dispatched");
+    triggered = true;
+    assert_equals(reader.readyState, FileReader.LOADING,
+                  "readyState must be LOADING")
+    assert_throws_dom("InvalidStateError", function () {
+      reader.readAsArrayBuffer(blob_2)
+    })
+  });
+  reader.readAsArrayBuffer(blob_1)
+  assert_equals(reader.readyState, FileReader.LOADING, "readyState Must be LOADING")
+}, 'test FileReader InvalidStateError exception in onloadstart event for readAsArrayBuffer');
+
+async_test(function() {
+  var blob_1 = new Blob(['TEST000000001'])
+  var blob_2 = new Blob(['TEST000000002'])
+  var reader = new FileReader();
+  reader.onloadend = this.step_func_done(function() {
+    assert_equals(reader.readyState, FileReader.DONE,
+                  "readyState must be DONE")
+    reader.readAsArrayBuffer(blob_2)
+    assert_equals(reader.readyState, FileReader.LOADING, "readyState Must be LOADING")
+  });
+  reader.readAsArrayBuffer(blob_1)
+  assert_equals(reader.readyState, FileReader.LOADING, "readyState Must be LOADING")
+}, 'test FileReader no InvalidStateError exception in loadend event handler for readAsArrayBuffer');
+
+async_test(function() {
+  var blob_1 = new Blob([new Uint8Array(0x414141)]);
+  var blob_2 = new Blob(['TEST000000002']);
+  var reader = new FileReader();
+  reader.onloadstart = this.step_func(function() {
+    reader.abort();
+    reader.onloadstart = null;
+    reader.onloadend = this.step_func_done(function() {
+      assert_equals('TEST000000002', reader.result);
+    });
+    reader.readAsText(blob_2);
+  });
+  reader.readAsText(blob_1);
+}, 'test abort and restart in onloadstart event for readAsText');
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_abort.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_abort.html
new file mode 100644
index 0000000000000000000000000000000000000000..940a775d35bf422db758623a278538f6ef8e7c48
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_abort.html
@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>FileAPI Test: filereader_abort</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#abort">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+
+    <script>
+    test(function() {
+      var readerNoRead = new FileReader();
+      readerNoRead.abort();
+      assert_equals(readerNoRead.readyState, readerNoRead.EMPTY);
+      assert_equals(readerNoRead.result, null);
+    }, "Aborting before read");
+
+    promise_test(t => {
+        var blob = new Blob(["TEST THE ABORT METHOD"]);
+        var readerAbort = new FileReader();
+
+        var eventWatcher = new EventWatcher(t, readerAbort,
+            ['abort', 'loadstart', 'loadend', 'error', 'load']);
+
+        // EventWatcher doesn't let us inspect the state after the abort event,
+        // so add an extra event handler for that.
+        readerAbort.addEventListener('abort', t.step_func(e => {
+              assert_equals(readerAbort.readyState, readerAbort.DONE);
+          }));
+
+        readerAbort.readAsText(blob);
+        return eventWatcher.wait_for('loadstart')
+          .then(() => {
+              assert_equals(readerAbort.readyState, readerAbort.LOADING);
+              // 'abort' and 'loadend' events are dispatched synchronously, so
+              // call wait_for before calling abort.
+              var nextEvent = eventWatcher.wait_for(['abort', 'loadend']);
+              readerAbort.abort();
+              return nextEvent;
+            })
+          .then(() => {
+              // https://www.w3.org/Bugs/Public/show_bug.cgi?id=24401
+              assert_equals(readerAbort.result, null);
+              assert_equals(readerAbort.readyState, readerAbort.DONE);
+            });
+      }, "Aborting after read");
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_error.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_error.html
new file mode 100644
index 0000000000000000000000000000000000000000..cf4524825b80cac569b63b71b4ace474a0e66c24
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_error.html
@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>FileAPI Test: filereader_error</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#dfn-domerror">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#abort">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+
+    <script>
+    async_test(function() {
+      var blob = new Blob(["TEST THE ERROR ATTRIBUTE AND ERROR EVENT"]);
+      var reader = new FileReader();
+      assert_equals(reader.error, null, "The error is null when no error occurred");
+
+      reader.onload = this.step_func(function(evt) {
+        assert_unreached("Should not dispatch the load event");
+      });
+
+      reader.onloadend = this.step_func(function(evt) {
+        assert_equals(reader.result, null, "The result is null");
+        this.done();
+      });
+
+      reader.readAsText(blob);
+      reader.abort();
+    });
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_events.any.js b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_events.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac692907d119f7c8cc9c6e028df4819f27a5112e
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_events.any.js
@@ -0,0 +1,19 @@
+promise_test(async t => {
+  var reader = new FileReader();
+  var eventWatcher = new EventWatcher(t, reader, ['loadstart', 'progress', 'abort', 'error', 'load', 'loadend']);
+  reader.readAsText(new Blob([]));
+  await eventWatcher.wait_for('loadstart');
+  // No progress event for an empty blob, as no data is loaded.
+  await eventWatcher.wait_for('load');
+  await eventWatcher.wait_for('loadend');
+}, 'events are dispatched in the correct order for an empty blob');
+
+promise_test(async t => {
+  var reader = new FileReader();
+  var eventWatcher = new EventWatcher(t, reader, ['loadstart', 'progress', 'abort', 'error', 'load', 'loadend']);
+  reader.readAsText(new Blob(['a']));
+  await eventWatcher.wait_for('loadstart');
+  await eventWatcher.wait_for('progress');
+  await eventWatcher.wait_for('load');
+  await eventWatcher.wait_for('loadend');
+}, 'events are dispatched in the correct order for a non-empty blob');
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_file-manual.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_file-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..702ca9afd7b06702564d89558676c6e1b80a6611
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_file-manual.html
@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>FileAPI Test: filereader_file</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#FileReader-interface">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#file">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div>
+      <p>Test step:</p>
+      <ol>
+        <li>Download <a href="support/blue-100x100.png">blue-100x100.png</a> to local.</li>
+        <li>Select the local file (blue-100x100.png) to run the test.</li>
+      </ol>
+    </div>
+
+    <form name="uploadData">
+      <input type="file" id="fileChooser">
+    </form>
+
+    <div id="log"></div>
+    <script>
+      var fileInput = document.querySelector('#fileChooser');
+      var reader = new FileReader();
+
+      //readType: 1-> ArrayBuffer, 2-> Text, 3-> DataURL
+      var readType = 1;
+
+      setup({
+        explicit_done: true,
+        explicit_timeout: true,
+      });
+
+      on_event(fileInput, "change", function(evt) {
+        reader.readAsArrayBuffer(fileInput.files[0]);
+      });
+
+      on_event(reader, "load", function(evt) {
+        if (readType == 1) {
+          test(function() {
+            assert_true(reader.result instanceof ArrayBuffer, "The result is instanceof ArrayBuffer");
+          }, "Check if the readAsArrayBuffer works");
+
+          readType++;
+          reader.readAsText(fileInput.files[0]);
+        } else if (readType == 2) {
+          test(function() {
+            assert_equals(typeof reader.result, "string", "The result is typeof string");
+          }, "Check if the readAsText works");
+
+          readType++;
+          reader.readAsDataURL(fileInput.files[0]);
+        } else if (readType == 3) {
+          test(function() {
+            assert_equals(typeof reader.result, "string", "The result is typeof string");
+            assert_equals(reader.result.indexOf("data"), 0, "The result starts with 'data'");
+            assert_true(reader.result.indexOf("base64") > 0, "The result contains 'base64'");
+          }, "Check if the readAsDataURL works");
+
+          done();
+        }
+      });
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_file_img-manual.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_file_img-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..fca42c7fceba48ae5fd7229a92a89eacff9e252f
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_file_img-manual.html
@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>FileAPI Test: filereader_file_img</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#FileReader-interface">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#file">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div>
+      <p>Test step:</p>
+      <ol>
+        <li>Download <a href="support/blue-100x100.png">blue-100x100.png</a> to local.</li>
+        <li>Select the local file (blue-100x100.png) to run the test.</li>
+      </ol>
+    </div>
+
+    <form name="uploadData">
+      <input type="file" id="fileChooser">
+    </form>
+
+    <div id="log"></div>
+    <script>
+      var fileInput = document.querySelector('#fileChooser');
+      var reader = new FileReader();
+
+      setup({
+        explicit_done: true,
+        explicit_timeout: true,
+      });
+
+      fileInput.addEventListener("change", function(evt) {
+        reader.readAsDataURL(fileInput.files[0]);
+      }, false);
+
+      reader.addEventListener("loadend", function(evt) {
+        test(function () {
+          assert_true(reader.result.indexOf("iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAYAAABw4pVUAAAAqklEQVR42u3RsREAMAgDMe+/M4E7ZkhBoeI9gJWkWpfaeToTECACAkRAgAgIEAEB4gQgAgJEQIAICBABASIgAgJEQIAICBABASIgAgJEQIAICBABASIgAgJEQIAICBABASIgAgJEQIAICBABASIgAgJEQIAICBABASIgAgJEQIAICBABASIgAgJEQIAICBABASIgAgJEQIAICBABASIgQJwARECACAgQ/W4AQauujc8IdAoAAAAASUVORK5CYII=") != -1, "Encoded image")
+        }, "Check if readAsDataURL returns correct image");
+        done();
+      }, false);
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsArrayBuffer.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsArrayBuffer.html
new file mode 100644
index 0000000000000000000000000000000000000000..31001a51a0727fbd4d1876f3aa4b6e6c860a6874
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsArrayBuffer.html
@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>FileAPI Test: filereader_readAsArrayBuffer</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#readAsArrayBuffer">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+
+    <script>
+    async_test(function() {
+      var blob = new Blob(["TEST"]);
+      var reader = new FileReader();
+
+      reader.onload = this.step_func(function(evt) {
+        assert_equals(reader.result.byteLength, 4, "The byteLength is 4");
+        assert_true(reader.result instanceof ArrayBuffer, "The result is instanceof ArrayBuffer");
+        assert_equals(reader.readyState, reader.DONE);
+        this.done();
+      });
+
+      reader.onloadstart = this.step_func(function(evt) {
+        assert_equals(reader.readyState, reader.LOADING);
+      });
+
+      reader.onprogress = this.step_func(function(evt) {
+        assert_equals(reader.readyState, reader.LOADING);
+      });
+
+      reader.readAsArrayBuffer(blob);
+    });
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsBinaryString.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsBinaryString.html
new file mode 100644
index 0000000000000000000000000000000000000000..b550e4d0a96dc7e407e960be1bf43b5115037907
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsBinaryString.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>FileAPI Test: filereader_readAsBinaryString</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="help" href="https://w3c.github.io/FileAPI/#readAsBinaryString">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+
+async_test(t => {
+  const blob = new Blob(["σ"]);
+  const reader = new FileReader();
+
+  reader.onload = t.step_func_done(() => {
+    assert_equals(typeof reader.result, "string", "The result is string");
+    assert_equals(reader.result.length, 2, "The result length is 2");
+    assert_equals(reader.result, "\xcf\x83", "The result is \xcf\x83");
+    assert_equals(reader.readyState, reader.DONE);
+  });
+
+  reader.onloadstart = t.step_func(() => {
+    assert_equals(reader.readyState, reader.LOADING);
+  });
+
+  reader.onprogress = t.step_func(() => {
+    assert_equals(reader.readyState, reader.LOADING);
+  });
+
+  reader.readAsBinaryString(blob);
+});
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsDataURL.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsDataURL.html
new file mode 100644
index 0000000000000000000000000000000000000000..5bc39499a229d182226aa099a843fa43d911ca04
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsDataURL.html
@@ -0,0 +1,51 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>FileAPI Test: FileReader.readAsDataURL</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="help" href="https://w3c.github.io/FileAPI/#readAsDataURL">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+
+<script>
+async_test(function(testCase) {
+  var blob = new Blob(["TEST"]);
+  var reader = new FileReader();
+
+  reader.onload = this.step_func(function(evt) {
+    assert_equals(reader.readyState, reader.DONE);
+    testCase.done();
+  });
+  reader.onloadstart = this.step_func(function(evt) {
+    assert_equals(reader.readyState, reader.LOADING);
+  });
+  reader.onprogress = this.step_func(function(evt) {
+    assert_equals(reader.readyState, reader.LOADING);
+  });
+
+  reader.readAsDataURL(blob);
+}, 'FileReader readyState during readAsDataURL');
+
+async_test(function(testCase) {
+  var blob = new Blob(["TEST"], { type: 'text/plain' });
+  var reader = new FileReader();
+
+  reader.onload = this.step_func(function() {
+    assert_equals(reader.result, "data:text/plain;base64,VEVTVA==");
+    testCase.done();
+  });
+  reader.readAsDataURL(blob);
+}, 'readAsDataURL result for Blob with specified MIME type');
+
+async_test(function(testCase) {
+  var blob = new Blob(["TEST"]);
+  var reader = new FileReader();
+
+  reader.onload = this.step_func(function() {
+    assert_equals(reader.result,
+                  "data:application/octet-stream;base64,VEVTVA==");
+    testCase.done();
+  });
+  reader.readAsDataURL(blob);
+}, 'readAsDataURL result for Blob with unspecified MIME type');
+
+</script>
\ No newline at end of file
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsText.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsText.html
new file mode 100644
index 0000000000000000000000000000000000000000..7d639d0111473b87973c121e2f98732a15ae0e28
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readAsText.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>FileAPI Test: filereader_readAsText</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#readAsDataText">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+
+    <script>
+    async_test(function() {
+      var blob = new Blob(["TEST"]);
+      var reader = new FileReader();
+
+      reader.onload = this.step_func(function(evt) {
+        assert_equals(typeof reader.result, "string", "The result is typeof string");
+        assert_equals(reader.result, "TEST", "The result is TEST");
+        this.done();
+      });
+
+      reader.onloadstart = this.step_func(function(evt) {
+        assert_equals(reader.readyState, reader.LOADING, "The readyState");
+      });
+
+      reader.onprogress = this.step_func(function(evt) {
+        assert_equals(reader.readyState, reader.LOADING);
+      });
+
+      reader.readAsText(blob);
+    }, "readAsText should correctly read UTF-8.");
+
+    async_test(function() {
+      var blob = new Blob(["TEST"]);
+      var reader = new FileReader();
+      var reader_UTF16 = new FileReader();
+      reader_UTF16.onload = this.step_func(function(evt) {
+        // "TEST" in UTF-8 is 0x54 0x45 0x53 0x54.
+        // Decoded as utf-16 (little-endian), we get 0x4554 0x5453.
+        assert_equals(reader_UTF16.readyState, reader.DONE, "The readyState");
+        assert_equals(reader_UTF16.result, "\u4554\u5453", "The result is not TEST");
+        this.done();
+      });
+      reader_UTF16.readAsText(blob, "UTF-16");
+    }, "readAsText should correctly read UTF-16.");
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readystate.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readystate.html
new file mode 100644
index 0000000000000000000000000000000000000000..1586b8995059f7f0ee86aeca0f303345bf861bdb
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_readystate.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>FileAPI Test: filereader_readystate</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#blobreader-state">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+
+    <script>
+    async_test(function() {
+      var blob = new Blob(["THIS TEST THE READYSTATE WHEN READ BLOB"]);
+      var reader = new FileReader();
+
+      assert_equals(reader.readyState, reader.EMPTY);
+
+      reader.onloadstart = this.step_func(function(evt) {
+        assert_equals(reader.readyState, reader.LOADING);
+      });
+
+      reader.onloadend = this.step_func(function(evt) {
+        assert_equals(reader.readyState, reader.DONE);
+        this.done();
+      });
+
+      reader.readAsDataURL(blob);
+    });
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/filereader_result.html b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_result.html
new file mode 100644
index 0000000000000000000000000000000000000000..b80322ed424f83edfe5470654a241844c0b12ed7
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/reading-data-section/filereader_result.html
@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>FileAPI Test: filereader_result</title>
+    <link rel="author" title="Intel" href="http://www.intel.com">
+    <link rel="help" href="http://dev.w3.org/2006/webapi/FileAPI/#filedata-attr">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <div id="log"></div>
+
+    <script>
+    var blob, blob2;
+    setup(function() {
+      blob = new Blob(["This test the result attribute"]);
+      blob2 = new Blob(["This is a second blob"]);
+    });
+
+    async_test(function() {
+      var readText = new FileReader();
+      assert_equals(readText.result, null);
+
+      readText.onloadend = this.step_func(function(evt) {
+        assert_equals(typeof readText.result, "string", "The result type is string");
+        assert_equals(readText.result, "This test the result attribute", "The result is correct");
+        this.done();
+      });
+
+      readText.readAsText(blob);
+    }, "readAsText");
+
+    async_test(function() {
+      var readDataURL = new FileReader();
+      assert_equals(readDataURL.result, null);
+
+      readDataURL.onloadend = this.step_func(function(evt) {
+        assert_equals(typeof readDataURL.result, "string", "The result type is string");
+        assert_true(readDataURL.result.indexOf("VGhpcyB0ZXN0IHRoZSByZXN1bHQgYXR0cmlidXRl") != -1, "return the right base64 string");
+        this.done();
+      });
+
+      readDataURL.readAsDataURL(blob);
+    }, "readAsDataURL");
+
+    async_test(function() {
+      var readArrayBuffer = new FileReader();
+      assert_equals(readArrayBuffer.result, null);
+
+      readArrayBuffer.onloadend = this.step_func(function(evt) {
+        assert_true(readArrayBuffer.result instanceof ArrayBuffer, "The result is instanceof ArrayBuffer");
+        this.done();
+      });
+
+      readArrayBuffer.readAsArrayBuffer(blob);
+    }, "readAsArrayBuffer");
+
+    async_test(function() {
+      var readBinaryString = new FileReader();
+      assert_equals(readBinaryString.result, null);
+
+      readBinaryString.onloadend = this.step_func(function(evt) {
+        assert_equals(typeof readBinaryString.result, "string", "The result type is string");
+        assert_equals(readBinaryString.result, "This test the result attribute", "The result is correct");
+        this.done();
+      });
+
+      readBinaryString.readAsBinaryString(blob);
+    }, "readAsBinaryString");
+
+
+    for (let event of ['loadstart', 'progress']) {
+      for (let method of ['readAsText', 'readAsDataURL', 'readAsArrayBuffer', 'readAsBinaryString']) {
+        promise_test(async function(t) {
+          var reader = new FileReader();
+          assert_equals(reader.result, null, 'result is null before read');
+
+          var eventWatcher = new EventWatcher(t, reader,
+              [event, 'loadend']);
+
+          reader[method](blob);
+          assert_equals(reader.result, null, 'result is null after first read call');
+          await eventWatcher.wait_for(event);
+          assert_equals(reader.result, null, 'result is null during event');
+          await eventWatcher.wait_for('loadend');
+          assert_not_equals(reader.result, null);
+          reader[method](blob);
+          assert_equals(reader.result, null, 'result is null after second read call');
+          await eventWatcher.wait_for(event);
+          assert_equals(reader.result, null, 'result is null during second read event');
+        }, 'result is null during "' + event + '" event for ' + method);
+      }
+    }
+    </script>
+  </body>
+</html>
diff --git a/test/fixtures/wpt/FileAPI/reading-data-section/support/blue-100x100.png b/test/fixtures/wpt/FileAPI/reading-data-section/support/blue-100x100.png
new file mode 100644
index 0000000000000000000000000000000000000000..b662fe18ec4797c21b91aeb6d3ccfe14d99f0e9a
Binary files /dev/null and b/test/fixtures/wpt/FileAPI/reading-data-section/support/blue-100x100.png differ
diff --git a/test/fixtures/wpt/FileAPI/support/Blob.js b/test/fixtures/wpt/FileAPI/support/Blob.js
new file mode 100644
index 0000000000000000000000000000000000000000..04069acd3ccbe713ad03f6e0a7d63f3e5a3c81b9
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/support/Blob.js
@@ -0,0 +1,70 @@
+'use strict'
+
+function test_blob(fn, expectations) {
+  var expected = expectations.expected,
+      type = expectations.type,
+      desc = expectations.desc;
+
+  var t = async_test(desc);
+  t.step(function() {
+    var blob = fn();
+    assert_true(blob instanceof Blob);
+    assert_false(blob instanceof File);
+    assert_equals(blob.type, type);
+    assert_equals(blob.size, expected.length);
+
+    var fr = new FileReader();
+    fr.onload = t.step_func_done(function(event) {
+      assert_equals(this.result, expected);
+    }, fr);
+    fr.onerror = t.step_func(function(e) {
+      assert_unreached("got error event on FileReader");
+    });
+    fr.readAsText(blob, "UTF-8");
+  });
+}
+
+function test_blob_binary(fn, expectations) {
+  var expected = expectations.expected,
+      type = expectations.type,
+      desc = expectations.desc;
+
+  var t = async_test(desc);
+  t.step(function() {
+    var blob = fn();
+    assert_true(blob instanceof Blob);
+    assert_false(blob instanceof File);
+    assert_equals(blob.type, type);
+    assert_equals(blob.size, expected.length);
+
+    var fr = new FileReader();
+    fr.onload = t.step_func_done(function(event) {
+      assert_true(this.result instanceof ArrayBuffer,
+                  "Result should be an ArrayBuffer");
+      assert_array_equals(new Uint8Array(this.result), expected);
+    }, fr);
+    fr.onerror = t.step_func(function(e) {
+      assert_unreached("got error event on FileReader");
+    });
+    fr.readAsArrayBuffer(blob);
+  });
+}
+
+// Assert that two TypedArray objects have the same byte values
+self.assert_equals_typed_array = (array1, array2) => {
+  const [view1, view2] = [array1, array2].map((array) => {
+    assert_true(array.buffer instanceof ArrayBuffer,
+      'Expect input ArrayBuffers to contain field `buffer`');
+    return new DataView(array.buffer, array.byteOffset, array.byteLength);
+  });
+
+  assert_equals(view1.byteLength, view2.byteLength,
+    'Expect both arrays to be of the same byte length');
+
+  const byteLength = view1.byteLength;
+
+  for (let i = 0; i < byteLength; ++i) {
+    assert_equals(view1.getUint8(i), view2.getUint8(i),
+      `Expect byte at buffer position ${i} to be equal`);
+  }
+}
diff --git a/test/fixtures/wpt/FileAPI/support/document-domain-setter.sub.html b/test/fixtures/wpt/FileAPI/support/document-domain-setter.sub.html
new file mode 100644
index 0000000000000000000000000000000000000000..61aebdf326679cdd7e4d9318e2fa1cf90283eb82
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/support/document-domain-setter.sub.html
@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<title>Relevant/current/blob source page used as a test helper</title>
+
+<script>
+"use strict";
+document.domain = "{{host}}";
+</script>
diff --git a/test/fixtures/wpt/FileAPI/support/historical-serviceworker.js b/test/fixtures/wpt/FileAPI/support/historical-serviceworker.js
new file mode 100644
index 0000000000000000000000000000000000000000..8bd89a23adb70fd0075131d29b6c4d36cb079d18
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/support/historical-serviceworker.js
@@ -0,0 +1,5 @@
+importScripts('/resources/testharness.js');
+
+test(() => {
+  assert_false('FileReaderSync' in self);
+}, '"FileReaderSync" should not be supported in service workers');
diff --git a/test/fixtures/wpt/FileAPI/support/incumbent.sub.html b/test/fixtures/wpt/FileAPI/support/incumbent.sub.html
new file mode 100644
index 0000000000000000000000000000000000000000..63a81cd3281c464d621f49f7660ab8edb0a4bb8b
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/support/incumbent.sub.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<title>Incumbent page used as a test helper</title>
+
+<iframe src="//{{domains[www1]}}:{{location[port]}}/FileAPI/support/document-domain-setter.sub.html" id="c"></iframe>
+<iframe src="//{{domains[www2]}}:{{location[port]}}/FileAPI/support/document-domain-setter.sub.html" id="r"></iframe>
+<iframe src="//{{domains[élève]}}:{{location[port]}}/FileAPI/support/document-domain-setter.sub.html" id="bs"></iframe>
+
+<script>
+"use strict";
+document.domain = "{{host}}";
+
+window.createBlobURL = () => {
+    const current = document.querySelector("#c").contentWindow;
+    const relevant = document.querySelector("#r").contentWindow;
+    const blobSource = document.querySelector("#bs").contentWindow;
+
+    const blob = new blobSource.Blob(["Test Blob"]);
+
+    return current.URL.createObjectURL.call(relevant, blob);
+};
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/support/send-file-form-helper.js b/test/fixtures/wpt/FileAPI/support/send-file-form-helper.js
new file mode 100644
index 0000000000000000000000000000000000000000..d6adf21ec337957e22876f601ba05d5711ee3d3b
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/support/send-file-form-helper.js
@@ -0,0 +1,282 @@
+'use strict';
+
+// See /FileAPI/file/resources/echo-content-escaped.py
+function escapeString(string) {
+  return string.replace(/\\/g, "\\\\").replace(
+    /[^\x20-\x7E]/g,
+    (x) => {
+      let hex = x.charCodeAt(0).toString(16);
+      if (hex.length < 2) hex = "0" + hex;
+      return `\\x${hex}`;
+    },
+  ).replace(/\\x0d\\x0a/g, "\r\n");
+}
+
+// Rationale for this particular test character sequence, which is
+// used in filenames and also in file contents:
+//
+// - ABC~ ensures the string starts with something we can read to
+//   ensure it is from the correct source; ~ is used because even
+//   some 1-byte otherwise-ASCII-like parts of ISO-2022-JP
+//   interpret it differently.
+// - ‾¥ are inside a single-byte range of ISO-2022-JP and help
+//   diagnose problems due to filesystem encoding or locale
+// - ≈ is inside IBM437 and helps diagnose problems due to filesystem
+//   encoding or locale
+// - ¤ is inside Latin-1 and helps diagnose problems due to
+//   filesystem encoding or locale; it is also the "simplest" case
+//   needing substitution in ISO-2022-JP
+// - ･ is inside a single-byte range of ISO-2022-JP in some variants
+//   and helps diagnose problems due to filesystem encoding or locale;
+//   on the web it is distinct when decoding but unified when encoding
+// - ・ is inside a double-byte range of ISO-2022-JP and helps
+//   diagnose problems due to filesystem encoding or locale
+// - • is inside Windows-1252 and helps diagnose problems due to
+//   filesystem encoding or locale and also ensures these aren't
+//   accidentally turned into e.g. control codes
+// - ∙ is inside IBM437 and helps diagnose problems due to filesystem
+//   encoding or locale
+// - · is inside Latin-1 and helps diagnose problems due to
+//   filesystem encoding or locale and also ensures HTML named
+//   character references (e.g. &middot;) are not used
+// - ☼ is inside IBM437 shadowing C0 and helps diagnose problems due to
+//   filesystem encoding or locale and also ensures these aren't
+//   accidentally turned into e.g. control codes
+// - ★ is inside ISO-2022-JP on a non-Kanji page and makes correct
+//   output easier to spot
+// - 星 is inside ISO-2022-JP on a Kanji page and makes correct
+//   output easier to spot
+// - 🌟 is outside the BMP and makes incorrect surrogate pair
+//   substitution detectable and ensures substitutions work
+//   correctly immediately after Kanji 2-byte ISO-2022-JP
+// - 星 repeated here ensures the correct codec state is used
+//   after a non-BMP substitution
+// - ★ repeated here also makes correct output easier to spot
+// - ☼ is inside IBM437 shadowing C0 and helps diagnose problems due to
+//   filesystem encoding or locale and also ensures these aren't
+//   accidentally turned into e.g. control codes and also ensures
+//   substitutions work correctly immediately after non-Kanji
+//   2-byte ISO-2022-JP
+// - · is inside Latin-1 and helps diagnose problems due to
+//   filesystem encoding or locale and also ensures HTML named
+//   character references (e.g. &middot;) are not used
+// - ∙ is inside IBM437 and helps diagnose problems due to filesystem
+//   encoding or locale
+// - • is inside Windows-1252 and again helps diagnose problems
+//   due to filesystem encoding or locale
+// - ・ is inside a double-byte range of ISO-2022-JP and helps
+//   diagnose problems due to filesystem encoding or locale
+// - ･ is inside a single-byte range of ISO-2022-JP in some variants
+//   and helps diagnose problems due to filesystem encoding or locale;
+//   on the web it is distinct when decoding but unified when encoding
+// - ¤ is inside Latin-1 and helps diagnose problems due to
+//   filesystem encoding or locale; again it is a "simple"
+//   substitution case
+// - ≈ is inside IBM437 and helps diagnose problems due to filesystem
+//   encoding or locale
+// - ¥‾ are inside a single-byte range of ISO-2022-JP and help
+//   diagnose problems due to filesystem encoding or locale
+// - ~XYZ ensures earlier errors don't lead to misencoding of
+//   simple ASCII
+//
+// Overall the near-symmetry makes common I18N mistakes like
+// off-by-1-after-non-BMP easier to spot. All the characters
+// are also allowed in Windows Unicode filenames.
+const kTestChars = 'ABC~‾¥≈¤･・•∙·☼★星🌟星★☼·∙•・･¤≈¥‾~XYZ';
+
+// The kTestFallback* strings represent the expected byte sequence from
+// encoding kTestChars with the given encoding with "html" replacement
+// mode, isomorphic-decoded. That means, characters that can't be
+// encoded in that encoding get HTML-escaped, but no further
+// `escapeString`-like escapes are needed.
+const kTestFallbackUtf8 = (
+  "ABC~\xE2\x80\xBE\xC2\xA5\xE2\x89\x88\xC2\xA4\xEF\xBD\xA5\xE3\x83\xBB\xE2" +
+    "\x80\xA2\xE2\x88\x99\xC2\xB7\xE2\x98\xBC\xE2\x98\x85\xE6\x98\x9F\xF0\x9F" +
+    "\x8C\x9F\xE6\x98\x9F\xE2\x98\x85\xE2\x98\xBC\xC2\xB7\xE2\x88\x99\xE2\x80" +
+    "\xA2\xE3\x83\xBB\xEF\xBD\xA5\xC2\xA4\xE2\x89\x88\xC2\xA5\xE2\x80\xBE~XYZ"
+);
+
+const kTestFallbackIso2022jp = (
+  ("ABC~\x1B(J~\\≈¤\x1B$B!&!&\x1B(B•∙·☼\x1B$B!z@1\x1B(B🌟" +
+    "\x1B$B@1!z\x1B(B☼·∙•\x1B$B!&!&\x1B(B¤≈\x1B(J\\~\x1B(B~XYZ")
+    .replace(/[^\0-\x7F]/gu, (x) => `&#${x.codePointAt(0)};`)
+);
+
+const kTestFallbackWindows1252 = (
+  "ABC~‾\xA5≈\xA4･・\x95∙\xB7☼★星🌟星★☼\xB7∙\x95・･\xA4≈\xA5‾~XYZ".replace(
+    /[^\0-\xFF]/gu,
+    (x) => `&#${x.codePointAt(0)};`,
+  )
+);
+
+const kTestFallbackXUserDefined = kTestChars.replace(
+  /[^\0-\x7F]/gu,
+  (x) => `&#${x.codePointAt(0)};`,
+);
+
+// formPostFileUploadTest - verifies multipart upload structure and
+// numeric character reference replacement for filenames, field names,
+// and field values using form submission.
+//
+// Uses /FileAPI/file/resources/echo-content-escaped.py to echo the
+// upload POST with controls and non-ASCII bytes escaped. This is done
+// because navigations whose response body contains [\0\b\v] may get
+// treated as a download, which is not what we want. Use the
+// `escapeString` function to replicate that kind of escape (note that
+// it takes an isomorphic-decoded string, not a byte sequence).
+//
+// Fields in the parameter object:
+//
+// - fileNameSource: purely explanatory and gives a clue about which
+//   character encoding is the source for the non-7-bit-ASCII parts of
+//   the fileBaseName, or Unicode if no smaller-than-Unicode source
+//   contains all the characters. Used in the test name.
+// - fileBaseName: the not-necessarily-just-7-bit-ASCII file basename
+//   used for the constructed test file. Used in the test name.
+// - formEncoding: the acceptCharset of the form used to submit the
+//   test file. Used in the test name.
+// - expectedEncodedBaseName: the expected formEncoding-encoded
+//   version of fileBaseName, isomorphic-decoded. That means, characters
+//   that can't be encoded in that encoding get HTML-escaped, but no
+//   further `escapeString`-like escapes are needed.
+const formPostFileUploadTest = ({
+  fileNameSource,
+  fileBaseName,
+  formEncoding,
+  expectedEncodedBaseName,
+}) => {
+  promise_test(async testCase => {
+
+    if (document.readyState !== 'complete') {
+      await new Promise(resolve => addEventListener('load', resolve));
+    }
+
+    const formTargetFrame = Object.assign(document.createElement('iframe'), {
+      name: 'formtargetframe',
+    });
+    document.body.append(formTargetFrame);
+    testCase.add_cleanup(() => {
+      document.body.removeChild(formTargetFrame);
+    });
+
+    const form = Object.assign(document.createElement('form'), {
+      acceptCharset: formEncoding,
+      action: '/FileAPI/file/resources/echo-content-escaped.py',
+      method: 'POST',
+      enctype: 'multipart/form-data',
+      target: formTargetFrame.name,
+    });
+    document.body.append(form);
+    testCase.add_cleanup(() => {
+      document.body.removeChild(form);
+    });
+
+    // Used to verify that the browser agrees with the test about
+    // which form charset is used.
+    form.append(Object.assign(document.createElement('input'), {
+      type: 'hidden',
+      name: '_charset_',
+    }));
+
+    // Used to verify that the browser agrees with the test about
+    // field value replacement and encoding independently of file system
+    // idiosyncracies.
+    form.append(Object.assign(document.createElement('input'), {
+      type: 'hidden',
+      name: 'filename',
+      value: fileBaseName,
+    }));
+
+    // Same, but with name and value reversed to ensure field names
+    // get the same treatment.
+    form.append(Object.assign(document.createElement('input'), {
+      type: 'hidden',
+      name: fileBaseName,
+      value: 'filename',
+    }));
+
+    const fileInput = Object.assign(document.createElement('input'), {
+      type: 'file',
+      name: 'file',
+    });
+    form.append(fileInput);
+
+    // Removes c:\fakepath\ or other pseudofolder and returns just the
+    // final component of filePath; allows both / and \ as segment
+    // delimiters.
+    const baseNameOfFilePath = filePath => filePath.split(/[\/\\]/).pop();
+    await new Promise(resolve => {
+      const dataTransfer = new DataTransfer;
+      dataTransfer.items.add(
+          new File([kTestChars], fileBaseName, {type: 'text/plain'}));
+      fileInput.files = dataTransfer.files;
+      // For historical reasons .value will be prefixed with
+      // c:\fakepath\, but the basename should match the file name
+      // exposed through the newer .files[0].name API. This check
+      // verifies that assumption.
+      assert_equals(
+          baseNameOfFilePath(fileInput.files[0].name),
+          baseNameOfFilePath(fileInput.value),
+          `The basename of the field's value should match its files[0].name`);
+      form.submit();
+      formTargetFrame.onload = resolve;
+    });
+
+    const formDataText = formTargetFrame.contentDocument.body.textContent;
+    const formDataLines = formDataText.split('\n');
+    if (formDataLines.length && !formDataLines[formDataLines.length - 1]) {
+      --formDataLines.length;
+    }
+    assert_greater_than(
+        formDataLines.length,
+        2,
+        `${fileBaseName}: multipart form data must have at least 3 lines: ${
+             JSON.stringify(formDataText)
+           }`);
+    const boundary = formDataLines[0];
+    assert_equals(
+        formDataLines[formDataLines.length - 1],
+        boundary + '--',
+        `${fileBaseName}: multipart form data must end with ${boundary}--: ${
+             JSON.stringify(formDataText)
+           }`);
+
+    const asValue = expectedEncodedBaseName.replace(/\r\n?|\n/g, "\r\n");
+    const asName = asValue.replace(/[\r\n"]/g, encodeURIComponent);
+    const asFilename = expectedEncodedBaseName.replace(/[\r\n"]/g, encodeURIComponent);
+
+    // The response body from echo-content-escaped.py has controls and non-ASCII
+    // bytes escaped, so any caller-provided field that might contain such bytes
+    // must be passed to `escapeString`, after any other expected
+    // transformations.
+    const expectedText = [
+      boundary,
+      'Content-Disposition: form-data; name="_charset_"',
+      '',
+      formEncoding,
+      boundary,
+      'Content-Disposition: form-data; name="filename"',
+      '',
+      // Unlike for names and filenames, multipart/form-data values don't escape
+      // \r\n linebreaks, and when they're read from an iframe they become \n.
+      escapeString(asValue).replace(/\r\n/g, "\n"),
+      boundary,
+      `Content-Disposition: form-data; name="${escapeString(asName)}"`,
+      '',
+      'filename',
+      boundary,
+      `Content-Disposition: form-data; name="file"; ` +
+          `filename="${escapeString(asFilename)}"`,
+      'Content-Type: text/plain',
+      '',
+      escapeString(kTestFallbackUtf8),
+      boundary + '--',
+    ].join('\n');
+
+    assert_true(
+        formDataText.startsWith(expectedText),
+        `Unexpected multipart-shaped form data received:\n${
+             formDataText
+           }\nExpected:\n${expectedText}`);
+  }, `Upload ${fileBaseName} (${fileNameSource}) in ${formEncoding} form`);
+};
diff --git a/test/fixtures/wpt/FileAPI/support/send-file-formdata-helper.js b/test/fixtures/wpt/FileAPI/support/send-file-formdata-helper.js
new file mode 100644
index 0000000000000000000000000000000000000000..53572ef36c8d1b17037117d988c64e8b4fbc2a73
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/support/send-file-formdata-helper.js
@@ -0,0 +1,97 @@
+"use strict";
+
+const kTestChars = "ABC~‾¥≈¤･・•∙·☼★星🌟星★☼·∙•・･¤≈¥‾~XYZ";
+
+// formDataPostFileUploadTest - verifies multipart upload structure and
+// numeric character reference replacement for filenames, field names,
+// and field values using FormData and fetch().
+//
+// Uses /fetch/api/resources/echo-content.py to echo the upload
+// POST (unlike in send-file-form-helper.js, here we expect all
+// multipart/form-data request bodies to be UTF-8, so we don't need to
+// escape controls and non-ASCII bytes).
+//
+// Fields in the parameter object:
+//
+// - fileNameSource: purely explanatory and gives a clue about which
+//   character encoding is the source for the non-7-bit-ASCII parts of
+//   the fileBaseName, or Unicode if no smaller-than-Unicode source
+//   contains all the characters. Used in the test name.
+// - fileBaseName: the not-necessarily-just-7-bit-ASCII file basename
+//   used for the constructed test file. Used in the test name.
+const formDataPostFileUploadTest = ({
+  fileNameSource,
+  fileBaseName,
+}) => {
+  promise_test(async (testCase) => {
+    const formData = new FormData();
+    let file = new Blob([kTestChars], { type: "text/plain" });
+    try {
+      // Switch to File in browsers that allow this
+      file = new File([file], fileBaseName, { type: file.type });
+    } catch (ignoredException) {
+    }
+
+    // Used to verify that the browser agrees with the test about
+    // field value replacement and encoding independently of file system
+    // idiosyncracies.
+    formData.append("filename", fileBaseName);
+
+    // Same, but with name and value reversed to ensure field names
+    // get the same treatment.
+    formData.append(fileBaseName, "filename");
+
+    formData.append("file", file, fileBaseName);
+
+    const formDataText = await (await fetch(
+      `/fetch/api/resources/echo-content.py`,
+      {
+        method: "POST",
+        body: formData,
+      },
+    )).text();
+    const formDataLines = formDataText.split("\r\n");
+    if (formDataLines.length && !formDataLines[formDataLines.length - 1]) {
+      --formDataLines.length;
+    }
+    assert_greater_than(
+      formDataLines.length,
+      2,
+      `${fileBaseName}: multipart form data must have at least 3 lines: ${
+        JSON.stringify(formDataText)
+      }`,
+    );
+    const boundary = formDataLines[0];
+    assert_equals(
+      formDataLines[formDataLines.length - 1],
+      boundary + "--",
+      `${fileBaseName}: multipart form data must end with ${boundary}--: ${
+        JSON.stringify(formDataText)
+      }`,
+    );
+
+    const asName = fileBaseName.replace(/[\r\n"]/g, encodeURIComponent);
+    const expectedText = [
+      boundary,
+      'Content-Disposition: form-data; name="filename"',
+      "",
+      fileBaseName,
+      boundary,
+      `Content-Disposition: form-data; name="${asName}"`,
+      "",
+      "filename",
+      boundary,
+      `Content-Disposition: form-data; name="file"; ` +
+      `filename="${asName}"`,
+      "Content-Type: text/plain",
+      "",
+      kTestChars,
+      boundary + "--",
+    ].join("\r\n");
+
+    assert_true(
+      formDataText.startsWith(expectedText),
+      `Unexpected multipart-shaped form data received:\n${formDataText}\nExpected:\n${expectedText}`,
+    );
+  }, `Upload ${fileBaseName} (${fileNameSource}) in fetch with FormData`);
+};
diff --git a/test/fixtures/wpt/FileAPI/support/upload.txt b/test/fixtures/wpt/FileAPI/support/upload.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5ab2f8a4323abafb10abb68657d9d39f1a775057
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/support/upload.txt
@@ -0,0 +1 @@
+Hello
\ No newline at end of file
diff --git a/test/fixtures/wpt/FileAPI/support/url-origin.html b/test/fixtures/wpt/FileAPI/support/url-origin.html
new file mode 100644
index 0000000000000000000000000000000000000000..63755113915f9f59eec9d292fc04422e7d219f90
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/support/url-origin.html
@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<script>
+const blob = new Blob(["Test Blob"]);
+const url = URL.createObjectURL(blob);
+window.parent.postMessage({url: url}, '*');
+</script>
diff --git a/test/fixtures/wpt/FileAPI/unicode.html b/test/fixtures/wpt/FileAPI/unicode.html
new file mode 100644
index 0000000000000000000000000000000000000000..ce3e3579d7c2c74c27d907ccd25c953588ef87f2
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/unicode.html
@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Blob/Unicode interaction: normalization and encoding</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+'use strict';
+
+const OMICRON_WITH_OXIA = '\u1F79'; // NFC normalized to U+3CC
+const CONTAINS_UNPAIRED_SURROGATES = 'abc\uDC00def\uD800ghi';
+const REPLACED = 'abc\uFFFDdef\uFFFDghi';
+
+function readBlobAsPromise(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsText(blob);
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error);
+  });
+}
+
+promise_test(async t => {
+  const blob = new Blob([OMICRON_WITH_OXIA]);
+  const result = await readBlobAsPromise(blob);
+  assert_equals(result, OMICRON_WITH_OXIA, 'String should not be normalized');
+}, 'Test that strings are not NFC normalized by Blob constructor');
+
+promise_test(async t => {
+  const file = new File([OMICRON_WITH_OXIA], 'name');
+  const result = await readBlobAsPromise(file);
+  assert_equals(result, OMICRON_WITH_OXIA, 'String should not be normalized');
+}, 'Test that strings are not NFC normalized by File constructor');
+
+promise_test(async t => {
+  const blob = new Blob([CONTAINS_UNPAIRED_SURROGATES]);
+  const result = await readBlobAsPromise(blob);
+  assert_equals(result, REPLACED, 'Unpaired surrogates should be replaced.');
+}, 'Test that unpaired surrogates are replaced by Blob constructor');
+
+promise_test(async t => {
+  const file = new File([CONTAINS_UNPAIRED_SURROGATES], 'name');
+  const result = await readBlobAsPromise(file);
+  assert_equals(result, REPLACED, 'Unpaired surrogates should be replaced.');
+}, 'Test that unpaired surrogates are replaced by File constructor');
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/url/cross-global-revoke.sub.html b/test/fixtures/wpt/FileAPI/url/cross-global-revoke.sub.html
new file mode 100644
index 0000000000000000000000000000000000000000..21b8c5bb1986d59e9a8ed85f0b9cfcd78358a92f
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/cross-global-revoke.sub.html
@@ -0,0 +1,61 @@
+<!doctype html>
+<meta charset="utf-8">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<body>
+<script>
+async_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+  const url = URL.createObjectURL(blob);
+  const frame = document.createElement('iframe');
+  frame.setAttribute('style', 'display:none;');
+  frame.src = 'resources/revoke-helper.html';
+  document.body.appendChild(frame);
+
+  frame.onload = t.step_func(e => {
+    frame.contentWindow.postMessage({url: url}, '*');
+  });
+
+  self.addEventListener('message', t.step_func(e => {
+    if (e.source !== frame.contentWindow) return;
+    assert_equals(e.data, 'revoked');
+    promise_rejects_js(t, TypeError, fetch(url)).then(t.step_func_done());
+  }));
+}, 'It is possible to revoke same-origin blob URLs from different frames.');
+
+async_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+  const url = URL.createObjectURL(blob);
+  const worker = new Worker('resources/revoke-helper.js');
+  worker.onmessage = t.step_func(e => {
+    assert_equals(e.data, 'revoked');
+    promise_rejects_js(t, TypeError, fetch(url)).then(t.step_func_done());
+  });
+  worker.postMessage({url: url});
+}, 'It is possible to revoke same-origin blob URLs from a different worker global.');
+
+async_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+  const url = URL.createObjectURL(blob);
+  const frame = document.createElement('iframe');
+  frame.setAttribute('style', 'display:none;');
+  frame.src = '//{{domains[www1]}}:{{location[port]}}/FileAPI/url/resources/revoke-helper.html';
+  document.body.appendChild(frame);
+
+  frame.onload = t.step_func(e => {
+    frame.contentWindow.postMessage({url: url}, '*');
+  });
+
+  self.addEventListener('message', t.step_func(e => {
+    if (e.source !== frame.contentWindow) return;
+    assert_equals(e.data, 'revoked');
+    fetch(url).then(response => response.text()).then(t.step_func_done(text => {
+      assert_equals(text, blob_contents);
+    }), t.unreached_func('Unexpected promise rejection'));
+  }));
+}, 'It is not possible to revoke cross-origin blob URLs.');
+
+</script>
\ No newline at end of file
diff --git a/test/fixtures/wpt/FileAPI/url/multi-global-origin-serialization.sub.html b/test/fixtures/wpt/FileAPI/url/multi-global-origin-serialization.sub.html
new file mode 100644
index 0000000000000000000000000000000000000000..0052b26fa62130fa953d27d2278aa350881f1059
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/multi-global-origin-serialization.sub.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Blob URL serialization (specifically the origin) in multi-global situations</title>
+<link rel="help" href="https://w3c.github.io/FileAPI/#unicodeBlobURL">
+<link rel="author" title="Domenic Denicola" href="mailto:d@domenic.me">
+
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+
+<!-- this page is the entry global -->
+
+<iframe src="//{{domains[www]}}:{{location[port]}}/FileAPI/support/incumbent.sub.html"></iframe>
+
+<script>
+"use strict";
+setup({ single_test: true });
+document.domain = "{{host}}";
+
+window.onload = () => {
+  const url = frames[0].createBlobURL();
+  const desired = "blob:{{location[scheme]}}://www1";
+  assert_equals(url.substring(0, desired.length), desired,
+    "Origin should contain www1, from the current settings object");
+  done();
+};
+</script>
diff --git a/test/fixtures/wpt/FileAPI/url/resources/create-helper.html b/test/fixtures/wpt/FileAPI/url/resources/create-helper.html
new file mode 100644
index 0000000000000000000000000000000000000000..fa6cf4e671e8356072e8400f53e3b918b1fc4608
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/resources/create-helper.html
@@ -0,0 +1,7 @@
+<!doctype html>
+<script>
+self.addEventListener('message', e => {
+  let url = URL.createObjectURL(e.data.blob);
+  e.source.postMessage({url: url}, '*');
+});
+</script>
\ No newline at end of file
diff --git a/test/fixtures/wpt/FileAPI/url/resources/create-helper.js b/test/fixtures/wpt/FileAPI/url/resources/create-helper.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6344f700ced602af361c9db0d6db2cf63f9f999
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/resources/create-helper.js
@@ -0,0 +1,4 @@
+self.addEventListener('message', e => {
+  let url = URL.createObjectURL(e.data.blob);
+  self.postMessage({url: url});
+});
diff --git a/test/fixtures/wpt/FileAPI/url/resources/fetch-tests.js b/test/fixtures/wpt/FileAPI/url/resources/fetch-tests.js
new file mode 100644
index 0000000000000000000000000000000000000000..a81ea1e7b1de350fbf8a29a47cdbe2bdb48d2cb3
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/resources/fetch-tests.js
@@ -0,0 +1,71 @@
+// This method generates a number of tests verifying fetching of blob URLs,
+// allowing the same tests to be used both with fetch() and XMLHttpRequest.
+//
+// |fetch_method| is only used in test names, and should describe the
+// (javascript) method being used by the other two arguments (i.e. 'fetch' or 'XHR').
+//
+// |fetch_should_succeed| is a callback that is called with the Test and a URL.
+// Fetching the URL is expected to succeed. The callback should return a promise
+// resolved with whatever contents were fetched.
+//
+// |fetch_should_fail| similarly is a callback that is called with the Test, a URL
+// to fetch, and optionally a method to use to do the fetch. If no method is
+// specified the callback should use the 'GET' method. Fetching of these URLs is
+// expected to fail, and the callback should return a promise that resolves iff
+// fetching did indeed fail.
+function fetch_tests(fetch_method, fetch_should_succeed, fetch_should_fail) {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+
+  promise_test(t => {
+    const url = URL.createObjectURL(blob);
+
+    return fetch_should_succeed(t, url).then(text => {
+      assert_equals(text, blob_contents);
+    });
+  }, 'Blob URLs can be used in ' + fetch_method);
+
+  promise_test(t => {
+    const url = URL.createObjectURL(blob);
+
+    return fetch_should_succeed(t, url + '#fragment').then(text => {
+      assert_equals(text, blob_contents);
+    });
+  }, fetch_method + ' with a fragment should succeed');
+
+  promise_test(t => {
+    const url = URL.createObjectURL(blob);
+    URL.revokeObjectURL(url);
+
+    return fetch_should_fail(t, url);
+  }, fetch_method + ' of a revoked URL should fail');
+
+  promise_test(t => {
+    const url = URL.createObjectURL(blob);
+    URL.revokeObjectURL(url + '#fragment');
+
+    return fetch_should_succeed(t, url).then(text => {
+      assert_equals(text, blob_contents);
+    });
+  }, 'Only exact matches should revoke URLs, using ' + fetch_method);
+
+  promise_test(t => {
+    const url = URL.createObjectURL(blob);
+
+    return fetch_should_fail(t, url + '?querystring');
+  }, 'Appending a query string should cause ' + fetch_method + ' to fail');
+
+  promise_test(t => {
+    const url = URL.createObjectURL(blob);
+
+    return fetch_should_fail(t, url + '/path');
+  }, 'Appending a path should cause ' + fetch_method + ' to fail');
+
+  for (const method of ['HEAD', 'POST', 'DELETE', 'OPTIONS', 'PUT', 'CUSTOM']) {
+    const url = URL.createObjectURL(blob);
+
+    promise_test(t => {
+      return fetch_should_fail(t, url, method);
+    }, fetch_method + ' with method "' + method + '" should fail');
+  }
+}
\ No newline at end of file
diff --git a/test/fixtures/wpt/FileAPI/url/resources/revoke-helper.html b/test/fixtures/wpt/FileAPI/url/resources/revoke-helper.html
new file mode 100644
index 0000000000000000000000000000000000000000..adf5a014a668d6dbf1922451dec2a682e8d8a610
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/resources/revoke-helper.html
@@ -0,0 +1,7 @@
+<!doctype html>
+<script>
+self.addEventListener('message', e => {
+  URL.revokeObjectURL(e.data.url);
+  e.source.postMessage('revoked', '*');
+});
+</script>
\ No newline at end of file
diff --git a/test/fixtures/wpt/FileAPI/url/resources/revoke-helper.js b/test/fixtures/wpt/FileAPI/url/resources/revoke-helper.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3e05b64b1a6c8e6dc1bb28c14055f13138ac73d
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/resources/revoke-helper.js
@@ -0,0 +1,9 @@
+self.addEventListener('message', e => {
+  URL.revokeObjectURL(e.data.url);
+  // Registering a new object URL will make absolutely sure that the revocation
+  // has propagated. Without this at least in chrome it is possible for the
+  // below postMessage to arrive at its destination before the revocation has
+  // been fully processed.
+  URL.createObjectURL(new Blob([]));
+  self.postMessage('revoked');
+});
diff --git a/test/fixtures/wpt/FileAPI/url/sandboxed-iframe.html b/test/fixtures/wpt/FileAPI/url/sandboxed-iframe.html
new file mode 100644
index 0000000000000000000000000000000000000000..a52939a3eb297c8c07e06479c2d2c1b7370075d3
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/sandboxed-iframe.html
@@ -0,0 +1,32 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>FileAPI Test: Verify behavior of Blob URL in unique origins</title>
+<meta name="timeout" content="long">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+
+<iframe id="sandboxed-iframe" sandbox="allow-scripts"></iframe>
+
+<script>
+
+const iframe_scripts = [
+  'resources/fetch-tests.js',
+  'url-format.any.js',
+  'url-in-tags.window.js',
+  'url-with-xhr.any.js',
+  'url-with-fetch.any.js',
+];
+
+let html = '<!doctype html>\n<meta charset="utf-8">\n<body>\n';
+html = html + '<script src="/resources/testharness.js"></' + 'script>\n';
+html = html + '<script>setup({"explicit_timeout": true});</' + 'script>\n';
+for (const script of iframe_scripts)
+  html = html + '<script src="' + script + '"></' + 'script>\n';
+
+const frame = document.querySelector('#sandboxed-iframe');
+frame.setAttribute('srcdoc', html);
+frame.setAttribute('style', 'display:none;');
+
+fetch_tests_from_window(frame.contentWindow);
+
+</script>
diff --git a/test/fixtures/wpt/FileAPI/url/unicode-origin.sub.html b/test/fixtures/wpt/FileAPI/url/unicode-origin.sub.html
new file mode 100644
index 0000000000000000000000000000000000000000..2c4921c03449986f4ae261155376f44b27f04977
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/unicode-origin.sub.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>FileAPI Test: Verify origin of Blob URL</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<body>
+<script>
+async_test(t => {
+  const frame = document.createElement('iframe');
+  self.addEventListener('message', t.step_func(e => {
+      if (e.source != frame.contentWindow) return;
+      const url = e.data.url;
+      assert_false(url.includes('天気の良い日'),
+          'Origin should be ascii rather than unicode');
+      assert_equals(new URL(url).origin, e.origin,
+          'Origin of URL should match origin of frame');
+      assert_true(url.startsWith('blob:{{location[scheme]}}://xn--'));
+      t.done();
+    }));
+  frame.src = '{{location[scheme]}}://{{domains[天気の良い日]}}:{{location[port]}}/FileAPI/support/url-origin.html';
+  document.body.appendChild(frame);
+}, 'Verify serialization of non-ascii origin in Blob URLs');
+</script>
diff --git a/test/fixtures/wpt/FileAPI/url/url-charset.window.js b/test/fixtures/wpt/FileAPI/url/url-charset.window.js
new file mode 100644
index 0000000000000000000000000000000000000000..777709b64a50e51b9ba37c5ce240073aa4b1f8ef
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url-charset.window.js
@@ -0,0 +1,34 @@
+async_test(t => {
+  // This could be detected as ISO-2022-JP, in which case there would be no
+  // <textarea>, and thus the script inside would be interpreted as actual
+  // script.
+  const blob = new Blob(
+      [
+        `aaa\u001B$@<textarea>\u001B(B<script>/* xss */<\/script></textarea>bbb`
+      ],
+      {type: 'text/html;charset=utf-8'});
+  const url = URL.createObjectURL(blob);
+  const win = window.open(url);
+  t.add_cleanup(() => {
+    win.close();
+  });
+
+  win.onload = t.step_func_done(() => {
+    assert_equals(win.document.charset, 'UTF-8');
+  });
+}, 'Blob charset should override any auto-detected charset.');
+
+async_test(t => {
+  const blob = new Blob(
+      [`<!doctype html>\n<meta charset="ISO-8859-1">`],
+      {type: 'text/html;charset=utf-8'});
+  const url = URL.createObjectURL(blob);
+  const win = window.open(url);
+  t.add_cleanup(() => {
+    win.close();
+  });
+
+  win.onload = t.step_func_done(() => {
+    assert_equals(win.document.charset, 'UTF-8');
+  });
+}, 'Blob charset should override <meta charset>.');
diff --git a/test/fixtures/wpt/FileAPI/url/url-format.any.js b/test/fixtures/wpt/FileAPI/url/url-format.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..33732fa61fc3ddd0f52b23fe83ea824cc6abae06
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url-format.any.js
@@ -0,0 +1,64 @@
+// META: timeout=long
+const blob = new Blob(['test']);
+const file = new File(['test'], 'name');
+
+test(() => {
+  const url_count = 5000;
+  let list = [];
+
+  for (let i = 0; i < url_count; ++i)
+    list.push(URL.createObjectURL(blob));
+
+  list.sort();
+
+  for (let i = 1; i < list.length; ++i)
+    assert_not_equals(list[i], list[i-1], 'generated Blob URLs should be unique');
+}, 'Generated Blob URLs are unique');
+
+test(() => {
+  const url = URL.createObjectURL(blob);
+  assert_equals(typeof url, 'string');
+  assert_true(url.startsWith('blob:'));
+}, 'Blob URL starts with "blob:"');
+
+test(() => {
+  const url = URL.createObjectURL(file);
+  assert_equals(typeof url, 'string');
+  assert_true(url.startsWith('blob:'));
+}, 'Blob URL starts with "blob:" for Files');
+
+test(() => {
+  const url = URL.createObjectURL(blob);
+  assert_equals(new URL(url).origin, location.origin);
+  if (location.origin !== 'null') {
+    assert_true(url.includes(location.origin));
+    assert_true(url.startsWith('blob:' + location.protocol));
+  }
+}, 'Origin of Blob URL matches our origin');
+
+test(() => {
+  const url = URL.createObjectURL(blob);
+  const url_record = new URL(url);
+  assert_equals(url_record.protocol, 'blob:');
+  assert_equals(url_record.origin, location.origin);
+  assert_equals(url_record.host, '', 'host should be an empty string');
+  assert_equals(url_record.port, '', 'port should be an empty string');
+  const uuid_path_re = /\/[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  assert_true(uuid_path_re.test(url_record.pathname), 'Path must end with a valid UUID');
+  if (location.origin !== 'null') {
+    const nested_url = new URL(url_record.pathname);
+    assert_equals(nested_url.origin, location.origin);
+    assert_equals(nested_url.pathname.search(uuid_path_re), 0, 'Path must be a valid UUID');
+    assert_true(url.includes(location.origin));
+    assert_true(url.startsWith('blob:' + location.protocol));
+  }
+}, 'Blob URL parses correctly');
+
+test(() => {
+  const url = URL.createObjectURL(file);
+  assert_equals(new URL(url).origin, location.origin);
+  if (location.origin !== 'null') {
+    assert_true(url.includes(location.origin));
+    assert_true(url.startsWith('blob:' + location.protocol));
+  }
+}, 'Origin of Blob URL matches our origin for Files');
diff --git a/test/fixtures/wpt/FileAPI/url/url-in-tags-revoke.window.js b/test/fixtures/wpt/FileAPI/url/url-in-tags-revoke.window.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cdad79f7e34e080c62ba639f2f363efd4ed26a9
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url-in-tags-revoke.window.js
@@ -0,0 +1,115 @@
+// META: timeout=long
+async_test(t => {
+  const run_result = 'test_frame_OK';
+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
+    '<script>window.test_result = "' + run_result + '";</script>';
+  const blob = new Blob([blob_contents], {type: 'text/html'});
+  const url = URL.createObjectURL(blob);
+
+  const frame = document.createElement('iframe');
+  frame.setAttribute('src', url);
+  frame.setAttribute('style', 'display:none;');
+  document.body.appendChild(frame);
+  URL.revokeObjectURL(url);
+
+  frame.onload = t.step_func_done(() => {
+    assert_equals(frame.contentWindow.test_result, run_result);
+  });
+}, 'Fetching a blob URL immediately before revoking it works in an iframe.');
+
+async_test(t => {
+  const run_result = 'test_frame_OK';
+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
+    '<script>window.test_result = "' + run_result + '";</script>';
+  const blob = new Blob([blob_contents], {type: 'text/html'});
+  const url = URL.createObjectURL(blob);
+
+  const frame = document.createElement('iframe');
+  frame.setAttribute('src', '/common/blank.html');
+  frame.setAttribute('style', 'display:none;');
+  document.body.appendChild(frame);
+
+  frame.onload = t.step_func(() => {
+    frame.contentWindow.location = url;
+    URL.revokeObjectURL(url);
+    frame.onload = t.step_func_done(() => {
+      assert_equals(frame.contentWindow.test_result, run_result);
+    });
+  });
+}, 'Fetching a blob URL immediately before revoking it works in an iframe navigation.');
+
+async_test(t => {
+  const run_result = 'test_frame_OK';
+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
+    '<script>window.test_result = "' + run_result + '";</script>';
+  const blob = new Blob([blob_contents], {type: 'text/html'});
+  const url = URL.createObjectURL(blob);
+  const win = window.open(url);
+  URL.revokeObjectURL(url);
+  add_completion_callback(() => { win.close(); });
+
+  win.onload = t.step_func_done(() => {
+    assert_equals(win.test_result, run_result);
+  });
+}, 'Opening a blob URL in a new window immediately before revoking it works.');
+
+function receive_message_on_channel(t, channel_name) {
+  const channel = new BroadcastChannel(channel_name);
+  return new Promise(resolve => {
+    channel.addEventListener('message', t.step_func(e => {
+      resolve(e.data);
+    }));
+  });
+}
+
+function window_contents_for_channel(channel_name) {
+  return '<!doctype html>\n' +
+    '<script>\n' +
+    'new BroadcastChannel("' + channel_name + '").postMessage("foobar");\n' +
+    'self.close();\n' +
+    '</script>';
+}
+
+async_test(t => {
+  const channel_name = 'noopener-window-test';
+  const blob = new Blob([window_contents_for_channel(channel_name)], {type: 'text/html'});
+  receive_message_on_channel(t, channel_name).then(t.step_func_done(t => {
+    assert_equals(t, 'foobar');
+  }));
+  const url = URL.createObjectURL(blob);
+  const win = window.open();
+  win.opener = null;
+  win.location = url;
+  URL.revokeObjectURL(url);
+}, 'Opening a blob URL in a noopener about:blank window immediately before revoking it works.');
+
+async_test(t => {
+  const run_result = 'test_script_OK';
+  const blob_contents = 'window.script_test_result = "' + run_result + '";';
+  const blob = new Blob([blob_contents]);
+  const url = URL.createObjectURL(blob);
+
+  const e = document.createElement('script');
+  e.setAttribute('src', url);
+  e.onload = t.step_func_done(() => {
+    assert_equals(window.script_test_result, run_result);
+  });
+
+  document.body.appendChild(e);
+  URL.revokeObjectURL(url);
+}, 'Fetching a blob URL immediately before revoking it works in <script> tags.');
+
+async_test(t => {
+  const channel_name = 'a-click-test';
+  const blob = new Blob([window_contents_for_channel(channel_name)], {type: 'text/html'});
+  receive_message_on_channel(t, channel_name).then(t.step_func_done(t => {
+    assert_equals(t, 'foobar');
+  }));
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.target = '_blank';
+  document.body.appendChild(anchor);
+  anchor.click();
+  URL.revokeObjectURL(url);
+}, 'Opening a blob URL in a new window by clicking an <a> tag works immediately before revoking the URL.');
diff --git a/test/fixtures/wpt/FileAPI/url/url-in-tags.window.js b/test/fixtures/wpt/FileAPI/url/url-in-tags.window.js
new file mode 100644
index 0000000000000000000000000000000000000000..f20b3599013bf5b4f305549f6dc85e5756a00908
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url-in-tags.window.js
@@ -0,0 +1,48 @@
+async_test(t => {
+  const run_result = 'test_script_OK';
+  const blob_contents = 'window.test_result = "' + run_result + '";';
+  const blob = new Blob([blob_contents]);
+  const url = URL.createObjectURL(blob);
+
+  const e = document.createElement('script');
+  e.setAttribute('src', url);
+  e.onload = t.step_func_done(() => {
+    assert_equals(window.test_result, run_result);
+  });
+
+  document.body.appendChild(e);
+}, 'Blob URLs can be used in <script> tags');
+
+async_test(t => {
+  const run_result = 'test_frame_OK';
+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
+    '<script>window.test_result = "' + run_result + '";</script>';
+  const blob = new Blob([blob_contents], {type: 'text/html'});
+  const url = URL.createObjectURL(blob);
+
+  const frame = document.createElement('iframe');
+  frame.setAttribute('src', url);
+  frame.setAttribute('style', 'display:none;');
+  document.body.appendChild(frame);
+
+  frame.onload = t.step_func_done(() => {
+    assert_equals(frame.contentWindow.test_result, run_result);
+  });
+}, 'Blob URLs can be used in iframes, and are treated same origin');
+
+async_test(t => {
+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
+    '<style>body { margin: 0; } .block { height: 5000px; }</style>\n' +
+    '<body>\n' +
+    '<a id="block1"></a><div class="block"></div>\n' +
+    '<a id="block2"></a><div class="block"></div>';
+  const blob = new Blob([blob_contents], {type: 'text/html'});
+  const url = URL.createObjectURL(blob);
+
+  const frame = document.createElement('iframe');
+  frame.setAttribute('src', url + '#block2');
+  document.body.appendChild(frame);
+  frame.contentWindow.onscroll = t.step_func_done(() => {
+    assert_equals(frame.contentWindow.scrollY, 5000);
+  });
+}, 'Blob URL fragment is implemented.');
diff --git a/test/fixtures/wpt/FileAPI/url/url-lifetime.html b/test/fixtures/wpt/FileAPI/url/url-lifetime.html
new file mode 100644
index 0000000000000000000000000000000000000000..ad5d667193a3d005d28c29fc8ca46364f614a7b1
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url-lifetime.html
@@ -0,0 +1,56 @@
+<!doctype html>
+<meta charset="utf-8">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<body>
+<script>
+promise_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+  const worker = new Worker('resources/create-helper.js');
+  let url;
+  return new Promise(resolve => {
+    worker.onmessage = e => resolve(e.data);
+    worker.postMessage({blob: blob});
+  }).then(data => {
+    url = data.url;
+    let result = fetch(url);
+    worker.terminate();
+    return result;
+  }).then(response => response.text()).then(text => {
+    assert_equals(text, blob_contents);
+    return new Promise(resolve => t.step_timeout(resolve, 100));
+  }).then(() => promise_rejects_js(t, TypeError, fetch(url)));
+}, 'Terminating worker revokes its URLs');
+
+promise_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+  const frame = document.createElement('iframe');
+  frame.setAttribute('style', 'display:none;');
+  frame.src = 'resources/create-helper.html';
+  document.body.appendChild(frame);
+
+  let url;
+  return new Promise(resolve => {
+    frame.onload = t.step_func(e => {
+      resolve(e);
+    });
+  }).then(e => {
+    frame.contentWindow.postMessage({blob: blob}, '*');
+    return new Promise(resolve => {
+      self.addEventListener('message', t.step_func(e => {
+        if (e.source === frame.contentWindow) resolve(e);
+      }));
+    });
+  }).then(e => {
+    url = e.data.url;
+    let fetch_result = fetch(url);
+    document.body.removeChild(frame);
+    return fetch_result;
+  }).then(response => response.text()).then(text => {
+    assert_equals(text, blob_contents);
+    return new Promise(resolve => t.step_timeout(resolve, 100));
+  }).then(() => promise_rejects_js(t, TypeError, fetch(url)));
+}, 'Removing an iframe revokes its URLs');
+</script>
\ No newline at end of file
diff --git a/test/fixtures/wpt/FileAPI/url/url-reload.window.js b/test/fixtures/wpt/FileAPI/url/url-reload.window.js
new file mode 100644
index 0000000000000000000000000000000000000000..d333b3a74aa82c58fafc5b3e5b0fab40730d13f1
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url-reload.window.js
@@ -0,0 +1,36 @@
+function blob_url_reload_test(t, revoke_before_reload) {
+  const run_result = 'test_frame_OK';
+  const blob_contents = '<!doctype html>\n<meta charset="utf-8">\n' +
+    '<script>window.test_result = "' + run_result + '";</script>';
+  const blob = new Blob([blob_contents], {type: 'text/html'});
+  const url = URL.createObjectURL(blob);
+
+  const frame = document.createElement('iframe');
+  frame.setAttribute('src', url);
+  frame.setAttribute('style', 'display:none;');
+  document.body.appendChild(frame);
+
+  frame.onload = t.step_func(() => {
+    if (revoke_before_reload)
+      URL.revokeObjectURL(url);
+    assert_equals(frame.contentWindow.test_result, run_result);
+    frame.contentWindow.test_result = null;
+    frame.onload = t.step_func_done(() => {
+      assert_equals(frame.contentWindow.test_result, run_result);
+    });
+    // Slight delay before reloading to ensure revoke actually has had a chance
+    // to be processed.
+    t.step_timeout(() => {
+      frame.contentWindow.location.reload();
+    }, 250);
+  });
+}
+
+async_test(t => {
+  blob_url_reload_test(t, false);
+}, 'Reloading a blob URL succeeds.');
+
+
+async_test(t => {
+  blob_url_reload_test(t, true);
+}, 'Reloading a blob URL succeeds even if the URL was revoked.');
diff --git a/test/fixtures/wpt/FileAPI/url/url-with-fetch.any.js b/test/fixtures/wpt/FileAPI/url/url-with-fetch.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..9bd8d383df4e1e1ea8ab3a59771a8b78e3a9b2c6
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url-with-fetch.any.js
@@ -0,0 +1,53 @@
+// META: script=resources/fetch-tests.js
+
+function fetch_should_succeed(test, request) {
+  return fetch(request).then(response => response.text());
+}
+
+function fetch_should_fail(test, url, method = 'GET') {
+  return promise_rejects_js(test, TypeError, fetch(url, {method: method}));
+}
+
+fetch_tests('fetch', fetch_should_succeed, fetch_should_fail);
+
+promise_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob_type = 'image/png';
+  const blob = new Blob([blob_contents], {type: blob_type});
+  const url = URL.createObjectURL(blob);
+
+  return fetch(url).then(response => {
+    assert_equals(response.headers.get('Content-Type'), blob_type);
+  });
+}, 'fetch should return Content-Type from Blob');
+
+promise_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+  const url = URL.createObjectURL(blob);
+  const request = new Request(url);
+
+  // Revoke the object URL.  Request should take a reference to the blob as
+  // soon as it receives it in open(), so the request succeeds even though we
+  // revoke the URL before calling fetch().
+  URL.revokeObjectURL(url);
+
+  return fetch_should_succeed(t, request).then(text => {
+    assert_equals(text, blob_contents);
+  });
+}, 'Revoke blob URL after creating Request, will fetch');
+
+promise_test(function(t) {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+  const url = URL.createObjectURL(blob);
+
+  const result = fetch_should_succeed(t, url).then(text => {
+    assert_equals(text, blob_contents);
+  });
+
+  // Revoke the object URL. fetch should have already resolved the blob URL.
+  URL.revokeObjectURL(url);
+
+  return result;
+}, 'Revoke blob URL after calling fetch, fetch should succeed');
diff --git a/test/fixtures/wpt/FileAPI/url/url-with-xhr.any.js b/test/fixtures/wpt/FileAPI/url/url-with-xhr.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..29d83080ab584564ab2f9c54bc1674f497f24eec
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url-with-xhr.any.js
@@ -0,0 +1,68 @@
+// META: script=resources/fetch-tests.js
+
+function xhr_should_succeed(test, url) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url);
+    xhr.onload = test.step_func(() => {
+      assert_equals(xhr.status, 200);
+      assert_equals(xhr.statusText, 'OK');
+      resolve(xhr.response);
+    });
+    xhr.onerror = () => reject('Got unexpected error event');
+    xhr.send();
+  });
+}
+
+function xhr_should_fail(test, url, method = 'GET') {
+  const xhr = new XMLHttpRequest();
+  xhr.open(method, url);
+  const result1 = new Promise((resolve, reject) => {
+    xhr.onload = () => reject('Got unexpected load event');
+    xhr.onerror = resolve;
+  });
+  const result2 = new Promise(resolve => {
+    xhr.onreadystatechange = test.step_func(() => {
+      if (xhr.readyState !== xhr.DONE) return;
+      assert_equals(xhr.status, 0);
+      resolve();
+    });
+  });
+  xhr.send();
+  return Promise.all([result1, result2]);
+}
+
+fetch_tests('XHR', xhr_should_succeed, xhr_should_fail);
+
+async_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob_type = 'image/png';
+  const blob = new Blob([blob_contents], {type: blob_type});
+  const url = URL.createObjectURL(blob);
+  const xhr = new XMLHttpRequest();
+  xhr.open('GET', url);
+  xhr.onloadend = t.step_func_done(() => {
+    assert_equals(xhr.getResponseHeader('Content-Type'), blob_type);
+  });
+  xhr.send();
+}, 'XHR should return Content-Type from Blob');
+
+async_test(t => {
+  const blob_contents = 'test blob contents';
+  const blob = new Blob([blob_contents]);
+  const url = URL.createObjectURL(blob);
+  const xhr = new XMLHttpRequest();
+  xhr.open('GET', url);
+
+  // Revoke the object URL.  XHR should take a reference to the blob as soon as
+  // it receives it in open(), so the request succeeds even though we revoke the
+  // URL before calling send().
+  URL.revokeObjectURL(url);
+
+  xhr.onload = t.step_func_done(() => {
+    assert_equals(xhr.response, blob_contents);
+  });
+  xhr.onerror = t.unreached_func('Got unexpected error event');
+
+  xhr.send();
+}, 'Revoke blob URL after open(), will fetch');
diff --git a/test/fixtures/wpt/FileAPI/url/url_createobjecturl_file-manual.html b/test/fixtures/wpt/FileAPI/url/url_createobjecturl_file-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..7ae32512e07c76a19bda89c106f63a8ceb94b4c4
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url_createobjecturl_file-manual.html
@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>FileAPI Test: Creating Blob URL with File</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="author" title="JunChen Xia" href="mailto:xjconlyme@gmail.com">
+<meta name="timeout" content="long">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+
+<div>
+  <p>Test steps:</p>
+  <ol>
+    <li>Download <a href="/images/blue96x96.png">blue96x96.png</a> to local.</li>
+    <li>Select the local file (blue96x96.png) to run the test.</li>
+  </ol>
+</div>
+
+<form name="uploadData">
+  <input type="file" id="fileChooser">
+</form>
+
+<div id="log"></div>
+
+<script>
+  async_test(function(t) {
+    var fileInput = document.querySelector('#fileChooser');
+
+    fileInput.onchange = t.step_func(function(e) {
+      var blobURL, file = fileInput.files[0];
+
+      test(function() {
+        assert_true(file instanceof File, "FileList contains File");
+      }, "Check if FileList contains File");
+
+      test(function() {
+        blobURL = window.URL.createObjectURL(file);
+        assert_equals(typeof blobURL, "string", "Blob URL is type of string");
+        assert_equals(blobURL.indexOf("blob"), 0, "Blob URL's scheme is blob");
+      }, "Check if URL.createObjectURL(File) returns a Blob URL");
+
+      t.done();
+    });
+  });
+</script>
+
diff --git a/test/fixtures/wpt/FileAPI/url/url_createobjecturl_file_img-manual.html b/test/fixtures/wpt/FileAPI/url/url_createobjecturl_file_img-manual.html
new file mode 100644
index 0000000000000000000000000000000000000000..534c1de9968da89036e57ff52a8ac6feb8d5b377
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url_createobjecturl_file_img-manual.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>FileAPI Test: Creating Blob URL with File as image source</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="author" title="JunChen Xia" href="mailto:xjconlyme@gmail.com">
+
+<div>
+  <p>Test steps:</p>
+  <ol>
+    <li>Download <a href="/images/blue96x96.png">blue96x96.png</a> to local.</li>
+    <li>Select the local file (blue96x96.png) to run the test.</li>
+  </ol>
+  <p>Pass/fail criteria:</p>
+  <p>Test passes if there is a filled blue square.</p>
+
+  <p><input type="file" accept="image/*" id="fileChooser"></p>
+  <p><img id="displayImage"></img></p>
+</div>
+
+<script>
+  var fileInput = document.querySelector("#fileChooser");
+  var img = document.querySelector("#displayImage");
+
+  fileInput.addEventListener("change", function(evt) {
+    img.src = window.URL.createObjectURL(fileInput.files[0]);
+  }, false);
+</script>
+
diff --git a/test/fixtures/wpt/FileAPI/url/url_xmlhttprequest_img-ref.html b/test/fixtures/wpt/FileAPI/url/url_xmlhttprequest_img-ref.html
new file mode 100644
index 0000000000000000000000000000000000000000..7d7390442d3631c9cdc190a1357497a4ef457345
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url_xmlhttprequest_img-ref.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>FileAPI Reference File</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="author" title="JunChen Xia" href="mailto:xjconlyme@gmail.com">
+
+<p>Test passes if there is a filled blue square.</p>
+
+<p>
+  <img id="fileDisplay" src="/images/blue96x96.png">
+</p>
+
diff --git a/test/fixtures/wpt/FileAPI/url/url_xmlhttprequest_img.html b/test/fixtures/wpt/FileAPI/url/url_xmlhttprequest_img.html
new file mode 100644
index 0000000000000000000000000000000000000000..468dcb086d770a5a9a5e385166539f674799fa9b
--- /dev/null
+++ b/test/fixtures/wpt/FileAPI/url/url_xmlhttprequest_img.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html class="reftest-wait">
+<meta charset="utf-8">
+<title>FileAPI Test: Creating Blob URL via XMLHttpRequest as image source</title>
+<link rel="author" title="Intel" href="http://www.intel.com">
+<link rel="author" title="JunChen Xia" href="mailto:xjconlyme@gmail.com">
+<link rel="match" href="url_xmlhttprequest_img-ref.html">
+
+<p>Test passes if there is a filled blue square.</p>
+
+<p>
+  <img id="fileDisplay">
+</p>
+
+<script src="/common/reftest-wait.js"></script>
+<script>
+  var http = new XMLHttpRequest();
+  http.open("GET", "/images/blue96x96.png", true);
+  http.responseType = "blob";
+  http.onloadend = function() {
+    var fileDisplay = document.querySelector("#fileDisplay");
+    fileDisplay.src = window.URL.createObjectURL(http.response);
+    fileDisplay.onload = takeScreenshot;
+  };
+  http.send();
+</script>
+</html>
diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index 041e8fe1f2eec3759904af58fd29e96c1ff82f9e..30dda41a52379bfb19697f140ef48f466c464009 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -11,13 +11,16 @@ See [test/wpt](../../wpt/README.md) for information on how these tests are run.
 Last update:
 
 - console: https://github.com/web-platform-tests/wpt/tree/9786a4b131/console
-- encoding: https://github.com/web-platform-tests/wpt/tree/5059d2c777/encoding
+- encoding: https://github.com/web-platform-tests/wpt/tree/1821fb5f77/encoding
 - url: https://github.com/web-platform-tests/wpt/tree/418f7fabeb/url
 - resources: https://github.com/web-platform-tests/wpt/tree/e1fddfbf80/resources
 - interfaces: https://github.com/web-platform-tests/wpt/tree/8ada332aea/interfaces
+- html/webappapis/atob: https://github.com/web-platform-tests/wpt/tree/f267e1dca6/html/webappapis/atob
 - html/webappapis/microtask-queuing: https://github.com/web-platform-tests/wpt/tree/0c3bed38df/html/webappapis/microtask-queuing
 - html/webappapis/timers: https://github.com/web-platform-tests/wpt/tree/ddfe9c089b/html/webappapis/timers
 - hr-time: https://github.com/web-platform-tests/wpt/tree/a5d1774ecf/hr-time
+- dom/abort: https://github.com/web-platform-tests/wpt/tree/1728d198c9/dom/abort
+- FileAPI: https://github.com/web-platform-tests/wpt/tree/3b279420d4/FileAPI
 
 [Web Platform Tests]: https://github.com/web-platform-tests/wpt
 [`git node wpt`]: https://github.com/nodejs/node-core-utils/blob/master/docs/git-node.md#git-node-wpt
diff --git a/test/fixtures/wpt/dom/abort/event.any.js b/test/fixtures/wpt/dom/abort/event.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..2589ba1ce45091c6e1b8ad030c6eeb3a4fed714b
--- /dev/null
+++ b/test/fixtures/wpt/dom/abort/event.any.js
@@ -0,0 +1,72 @@
+test(t => {
+  const c = new AbortController(),
+        s = c.signal;
+  let state = "begin";
+
+  assert_false(s.aborted);
+
+  s.addEventListener("abort",
+    t.step_func(e => {
+      assert_equals(state, "begin");
+      state = "aborted";
+    })
+  );
+  c.abort();
+
+  assert_equals(state, "aborted");
+  assert_true(s.aborted);
+
+  c.abort();
+}, "AbortController abort() should fire event synchronously");
+
+test(t => {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  assert_equals(controller.signal, signal,
+                "value of controller.signal should not have changed");
+  controller.abort();
+  assert_equals(controller.signal, signal,
+                "value of controller.signal should still not have changed");
+}, "controller.signal should always return the same object");
+
+test(t => {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  let eventCount = 0;
+  signal.onabort = () => {
+    ++eventCount;
+  };
+  controller.abort();
+  assert_true(signal.aborted);
+  assert_equals(eventCount, 1, "event handler should have been called once");
+  controller.abort();
+  assert_true(signal.aborted);
+  assert_equals(eventCount, 1,
+                "event handler should not have been called again");
+}, "controller.abort() should do nothing the second time it is called");
+
+test(t => {
+  const controller = new AbortController();
+  controller.abort();
+  controller.signal.onabort =
+      t.unreached_func("event handler should not be called");
+}, "event handler should not be called if added after controller.abort()");
+
+test(t => {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  signal.onabort = t.step_func(e => {
+    assert_equals(e.type, "abort", "event type should be abort");
+    assert_equals(e.target, signal, "event target should be signal");
+    assert_false(e.bubbles, "event should not bubble");
+    assert_true(e.isTrusted, "event should be trusted");
+  });
+  controller.abort();
+}, "the abort event should have the right properties");
+
+test(t => {
+  const signal = AbortSignal.abort();
+  assert_true(signal.aborted);
+}, "the AbortSignal.abort() static returns an already aborted signal");
+
+done();
diff --git a/test/fixtures/wpt/encoding/idlharness.any.js b/test/fixtures/wpt/encoding/idlharness.any.js
index 7a057f14e3a78c73b39a17f1debd3b8ad1e754d6..acd100c43b461c85399407087d20a51a57ce8352 100644
--- a/test/fixtures/wpt/encoding/idlharness.any.js
+++ b/test/fixtures/wpt/encoding/idlharness.any.js
@@ -4,7 +4,7 @@
 
 idl_test(
   ['encoding'],
-  [], // No deps
+  ['streams'],
   idl_array => {
     idl_array.add_objects({
       TextEncoder: ['new TextEncoder()'],
diff --git a/test/fixtures/wpt/encoding/iso-2022-jp-encoder.html b/test/fixtures/wpt/encoding/iso-2022-jp-encoder.html
index 81bd18039b23d320ac36ffbff21aefe130cfe0b0..fa08375d9e0e3811eaea9ed57f20a6afb1739cbb 100644
--- a/test/fixtures/wpt/encoding/iso-2022-jp-encoder.html
+++ b/test/fixtures/wpt/encoding/iso-2022-jp-encoder.html
@@ -12,8 +12,16 @@
    }, "iso-2022-jp encoder: " + desc)
  }
 
- encode("s", "s", "very basic")
- encode("\u00A5\u203Es\\\uFF90\u4F69", "%1B(J\\~s%1B(B\\%1B$B%_PP%1B(B", "basics")
- encode("\x0E\x0F\x1Bx", "%0E%0F%1Bx", "SO/SI ESC")
+ encode("s", "s", "very basic");
+ encode("\u00A5\u203Es\\\uFF90\u4F69", "%1B(J\\~s%1B(B\\%1B$B%_PP%1B(B", "basics");
+ encode("\uFF61", "%1B$B!%23%1B(B", "Katakana");
+ encode("\u0393", "%1B$B&%23%1B(B", "jis0208");
+ encode("\x0E\x0F\x1Bx", "%26%2365533%3B%26%2365533%3B%26%2365533%3Bx", "SO/SI ESC");
+ encode("\u203E\x0E\x0F\x1Bx", "%1B(J~%26%2365533%3B%26%2365533%3B%26%2365533%3Bx%1B(B", "Roman SO/SI ESC");
+ encode("\uFF61\x0E\x0F\x1Bx", "%1B$B!%23%1B(B%26%2365533%3B%26%2365533%3B%26%2365533%3Bx", "Katakana SO/SI ESC");
+ encode("\u0393\x0E\x0F\x1Bx", "%1B$B&%23%1B(B%26%2365533%3B%26%2365533%3B%26%2365533%3Bx", "jis0208 SO/SI ESC");
  encode("\uFFFD", "%26%2365533%3B", "U+FFFD");
+ encode("\u203E\uFFFD", "%1B(J~%26%2365533%3B%1B(B", "Roman U+FFFD");
+ encode("\uFF61\uFFFD", "%1B$B!%23%1B(B%26%2365533%3B", "Katakana U+FFFD");
+ encode("\u0393\uFFFD", "%1B$B&%23%1B(B%26%2365533%3B", "jis0208 U+FFFD");
 </script>
diff --git a/test/fixtures/wpt/encoding/streams/decode-non-utf8.any.js b/test/fixtures/wpt/encoding/streams/decode-non-utf8.any.js
index 7f39cdc04ca76b7071d3321ac068f9216b365002..35aa936647e7ad5d31e49be8f9893d23e1fd2765 100644
--- a/test/fixtures/wpt/encoding/streams/decode-non-utf8.any.js
+++ b/test/fixtures/wpt/encoding/streams/decode-non-utf8.any.js
@@ -25,6 +25,12 @@ const encodings = [
     expected: "\u{6c34}",
     invalid: [255]
   },
+  {
+    name: 'ISO-2022-JP',
+    value: [65, 66, 67, 0x1B, 65, 66, 67],
+    expected: "ABC\u{fffd}ABC",
+    invalid: [0x0E]
+  },
   {
     name: 'ISO-8859-14',
     value: [100, 240, 114],
diff --git a/test/fixtures/wpt/html/webappapis/atob/base64.any.js b/test/fixtures/wpt/html/webappapis/atob/base64.any.js
new file mode 100644
index 0000000000000000000000000000000000000000..7f433f4d8a9ee2e317def3327c5882938cbd6732
--- /dev/null
+++ b/test/fixtures/wpt/html/webappapis/atob/base64.any.js
@@ -0,0 +1,163 @@
+/**
+ * btoa() as defined by the HTML5 spec, which mostly just references RFC4648.
+ */
+function mybtoa(s) {
+    // String conversion as required by WebIDL.
+    s = String(s);
+
+    // "The btoa() method must throw an INVALID_CHARACTER_ERR exception if the
+    // method's first argument contains any character whose code point is
+    // greater than U+00FF."
+    for (var i = 0; i < s.length; i++) {
+        if (s.charCodeAt(i) > 255) {
+            return "INVALID_CHARACTER_ERR";
+        }
+    }
+
+    var out = "";
+    for (var i = 0; i < s.length; i += 3) {
+        var groupsOfSix = [undefined, undefined, undefined, undefined];
+        groupsOfSix[0] = s.charCodeAt(i) >> 2;
+        groupsOfSix[1] = (s.charCodeAt(i) & 0x03) << 4;
+        if (s.length > i + 1) {
+            groupsOfSix[1] |= s.charCodeAt(i + 1) >> 4;
+            groupsOfSix[2] = (s.charCodeAt(i + 1) & 0x0f) << 2;
+        }
+        if (s.length > i + 2) {
+            groupsOfSix[2] |= s.charCodeAt(i + 2) >> 6;
+            groupsOfSix[3] = s.charCodeAt(i + 2) & 0x3f;
+        }
+        for (var j = 0; j < groupsOfSix.length; j++) {
+            if (typeof groupsOfSix[j] == "undefined") {
+                out += "=";
+            } else {
+                out += btoaLookup(groupsOfSix[j]);
+            }
+        }
+    }
+    return out;
+}
+
+/**
+ * Lookup table for mybtoa(), which converts a six-bit number into the
+ * corresponding ASCII character.
+ */
+function btoaLookup(idx) {
+    if (idx < 26) {
+        return String.fromCharCode(idx + 'A'.charCodeAt(0));
+    }
+    if (idx < 52) {
+        return String.fromCharCode(idx - 26 + 'a'.charCodeAt(0));
+    }
+    if (idx < 62) {
+        return String.fromCharCode(idx - 52 + '0'.charCodeAt(0));
+    }
+    if (idx == 62) {
+        return '+';
+    }
+    if (idx == 63) {
+        return '/';
+    }
+    // Throw INVALID_CHARACTER_ERR exception here -- won't be hit in the tests.
+}
+
+function btoaException(input) {
+    input = String(input);
+    for (var i = 0; i < input.length; i++) {
+        if (input.charCodeAt(i) > 255) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function testBtoa(input) {
+    // "The btoa() method must throw an INVALID_CHARACTER_ERR exception if the
+    // method's first argument contains any character whose code point is
+    // greater than U+00FF."
+    var normalizedInput = String(input);
+    for (var i = 0; i < normalizedInput.length; i++) {
+        if (normalizedInput.charCodeAt(i) > 255) {
+            assert_throws_dom("InvalidCharacterError", function() { btoa(input); },
+                "Code unit " + i + " has value " + normalizedInput.charCodeAt(i) + ", which is greater than 255");
+            return;
+        }
+    }
+    assert_equals(btoa(input), mybtoa(input));
+    assert_equals(atob(btoa(input)), String(input), "atob(btoa(input)) must be the same as String(input)");
+}
+
+var tests = ["עברית", "", "ab", "abc", "abcd", "abcde",
+    // This one is thrown in because IE9 seems to fail atob(btoa()) on it.  Or
+    // possibly to fail btoa().  I actually can't tell what's happening here,
+    // but it doesn't hurt.
+    "\xff\xff\xc0",
+    // Is your DOM implementation binary-safe?
+    "\0a", "a\0b",
+    // WebIDL tests.
+    undefined, null, 7, 12, 1.5, true, false, NaN, +Infinity, -Infinity, 0, -0,
+    {toString: function() { return "foo" }},
+];
+for (var i = 0; i < 258; i++) {
+    tests.push(String.fromCharCode(i));
+}
+tests.push(String.fromCharCode(10000));
+tests.push(String.fromCharCode(65534));
+tests.push(String.fromCharCode(65535));
+
+// This is supposed to be U+10000.
+tests.push(String.fromCharCode(0xd800, 0xdc00));
+tests = tests.map(
+    function(elem) {
+        var expected = mybtoa(elem);
+        if (expected === "INVALID_CHARACTER_ERR") {
+            return ["btoa("  + format_value(elem) + ") must raise INVALID_CHARACTER_ERR", elem];
+        }
+        return ["btoa(" + format_value(elem) + ") == " + format_value(mybtoa(elem)), elem];
+    }
+);
+
+var everything = "";
+for (var i = 0; i < 256; i++) {
+    everything += String.fromCharCode(i);
+}
+tests.push(["btoa(first 256 code points concatenated)", everything]);
+
+generate_tests(testBtoa, tests);
+
+promise_test(() => fetch("../../../fetch/data-urls/resources/base64.json").then(res => res.json()).then(runAtobTests), "atob() setup.");
+
+const idlTests = [
+  [undefined, null],
+  [null, [158, 233, 101]],
+  [7, null],
+  [12, [215]],
+  [1.5, null],
+  [true, [182, 187]],
+  [false, null],
+  [NaN, [53, 163]],
+  [+Infinity, [34, 119, 226, 158, 43, 114]],
+  [-Infinity, null],
+  [0, null],
+  [-0, null],
+  [{toString: function() { return "foo" }}, [126, 138]],
+  [{toString: function() { return "abcd" }}, [105, 183, 29]]
+];
+
+function runAtobTests(tests) {
+  const allTests = tests.concat(idlTests);
+  for(let i = 0; i < allTests.length; i++) {
+    const input = allTests[i][0],
+          output = allTests[i][1];
+    test(() => {
+      if(output === null) {
+        assert_throws_dom("InvalidCharacterError", () => globalThis.atob(input));
+      } else {
+        const result = globalThis.atob(input);
+        for(let ii = 0; ii < output.length; ii++) {
+          assert_equals(result.charCodeAt(ii), output[ii]);
+        }
+      }
+    }, "atob(" + format_value(input) + ")");
+  }
+}
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index 566041b6362862baf55b0f0940435ee69bdb9921..77ace95841fab371bddd6c12297cdd618f8c7df6 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -4,7 +4,7 @@
     "path": "console"
   },
   "encoding": {
-    "commit": "5059d2c77703d67d2f76931b44e6d2437526b6e9",
+    "commit": "1821fb5f77723b5361058c6a8ed0b71f9d2d6b8d",
     "path": "encoding"
   },
   "url": {
@@ -19,6 +19,10 @@
     "commit": "8ada332aeac03764f73ec7ff66f682c5c0b454b4",
     "path": "interfaces"
   },
+  "html/webappapis/atob": {
+    "commit": "f267e1dca6f57a9f4d69f32a6920adfdb3268656",
+    "path": "html/webappapis/atob"
+  },
   "html/webappapis/microtask-queuing": {
     "commit": "0c3bed38df6d9dcd1441873728fb5c1bb59c92df",
     "path": "html/webappapis/microtask-queuing"
@@ -30,5 +34,13 @@
   "hr-time": {
     "commit": "a5d1774ecf41751d1c9357c27c709ee33bf3e279",
     "path": "hr-time"
+  },
+  "dom/abort": {
+    "commit": "1728d198c92834d92f7f399ef35e7823d5bfa0e4",
+    "path": "dom/abort"
+  },
+  "FileAPI": {
+    "commit": "3b279420d40afea32506e823f9ac005448f4f3d8",
+    "path": "FileAPI"
   }
-}
\ No newline at end of file
+}
diff --git a/deps/node-inspect/.gitignore b/test/fixtures/x509-escaping/.gitignore
similarity index 36%
rename from deps/node-inspect/.gitignore
rename to test/fixtures/x509-escaping/.gitignore
index 72e2c8c18012a891bed6eaab45f1dfa67679a113..504afef81fbadc8c0a072e1ac93f1376bca7f4a9 100644
--- a/deps/node-inspect/.gitignore
+++ b/test/fixtures/x509-escaping/.gitignore
@@ -1,4 +1,2 @@
 node_modules/
-npm-debug.log
-/tmp
-/.vs
+package-lock.json
diff --git a/test/fixtures/x509-escaping/create-certs.js b/test/fixtures/x509-escaping/create-certs.js
new file mode 100644
index 0000000000000000000000000000000000000000..abb01756be56c009cc089db26066b2e9dfcb62a4
--- /dev/null
+++ b/test/fixtures/x509-escaping/create-certs.js
@@ -0,0 +1,643 @@
+'use strict';
+
+const asn1 = require('asn1.js');
+const crypto = require('crypto');
+const { writeFileSync } = require('fs');
+const rfc5280 = require('asn1.js-rfc5280');
+const BN = asn1.bignum;
+
+const oid = {
+  commonName: [2, 5, 4, 3],
+  countryName: [2, 5, 4, 6],
+  localityName: [2, 5, 4, 7],
+  rsaEncryption: [1, 2, 840, 113549, 1, 1, 1],
+  sha256WithRSAEncryption: [1, 2, 840, 113549, 1, 1, 11],
+  xmppAddr: [1, 3, 6, 1, 5, 5, 7, 8, 5],
+  srvName: [1, 3, 6, 1, 5, 5, 7, 8, 7],
+  ocsp: [1, 3, 6, 1, 5, 5, 7, 48, 1],
+  caIssuers: [1, 3, 6, 1, 5, 5, 7, 48, 2],
+  privateUnrecognized: [1, 3, 9999, 12, 34]
+};
+
+const digest = 'SHA256';
+
+const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
+  modulusLength: 4096,
+  publicKeyEncoding: {
+    type: 'pkcs1',
+    format: 'der'
+  }
+});
+
+writeFileSync('server-key.pem', privateKey.export({
+  type: 'pkcs8',
+  format: 'pem'
+}));
+
+const now = Date.now();
+const days = 3650;
+
+function utilType(name, fn) {
+  return asn1.define(name, function() {
+    this[fn]();
+  });
+}
+
+const Null_ = utilType('Null_', 'null_');
+const null_ = Null_.encode('der');
+
+const IA5String = utilType('IA5String', 'ia5str');
+const PrintableString = utilType('PrintableString', 'printstr');
+const UTF8String = utilType('UTF8String', 'utf8str');
+
+const subjectCommonName = PrintableString.encode('evil.example.com', 'der');
+
+const sans = [
+  { type: 'dNSName', value: 'good.example.com, DNS:evil.example.com' },
+  { type: 'uniformResourceIdentifier', value: 'http://example.com/' },
+  { type: 'uniformResourceIdentifier', value: 'http://example.com/?a=b&c=d' },
+  { type: 'uniformResourceIdentifier', value: 'http://example.com/a,b' },
+  { type: 'uniformResourceIdentifier', value: 'http://example.com/a%2Cb' },
+  {
+    type: 'uniformResourceIdentifier',
+    value: 'http://example.com/a, DNS:good.example.com'
+  },
+  { type: 'dNSName', value: Buffer.from('exämple.com', 'latin1') },
+  { type: 'dNSName', value: '"evil.example.com"' },
+  { type: 'iPAddress', value: Buffer.from('08080808', 'hex') },
+  { type: 'iPAddress', value: Buffer.from('08080404', 'hex') },
+  { type: 'iPAddress', value: Buffer.from('0008080404', 'hex') },
+  { type: 'iPAddress', value: Buffer.from('000102030405', 'hex') },
+  {
+    type: 'iPAddress',
+    value: Buffer.from('0a0b0c0d0e0f0000000000007a7b7c7d', 'hex')
+  },
+  { type: 'rfc822Name', value: 'foo@example.com' },
+  { type: 'rfc822Name', value: 'foo@example.com, DNS:good.example.com' },
+  {
+    type: 'directoryName',
+    value: {
+      type: 'rdnSequence',
+      value: [
+        [
+          {
+            type: oid.countryName,
+            value: PrintableString.encode('DE', 'der')
+          }
+        ],
+        [
+          {
+            type: oid.localityName,
+            value: UTF8String.encode('Hannover', 'der')
+          }
+        ]
+      ]
+    }
+  },
+  {
+    type: 'directoryName',
+    value: {
+      type: 'rdnSequence',
+      value: [
+        [
+          {
+            type: oid.countryName,
+            value: PrintableString.encode('DE', 'der')
+          }
+        ],
+        [
+          {
+            type: oid.localityName,
+            value: UTF8String.encode('München', 'der')
+          }
+        ]
+      ]
+    }
+  },
+  {
+    type: 'directoryName',
+    value: {
+      type: 'rdnSequence',
+      value: [
+        [
+          {
+            type: oid.countryName,
+            value: PrintableString.encode('DE', 'der')
+          }
+        ],
+        [
+          {
+            type: oid.localityName,
+            value: UTF8String.encode('Berlin, DNS:good.example.com', 'der')
+          }
+        ]
+      ]
+    }
+  },
+  {
+    type: 'directoryName',
+    value: {
+      type: 'rdnSequence',
+      value: [
+        [
+          {
+            type: oid.countryName,
+            value: PrintableString.encode('DE', 'der')
+          }
+        ],
+        [
+          {
+            type: oid.localityName,
+            value: UTF8String.encode('Berlin, DNS:good.example.com\0evil.example.com', 'der')
+          }
+        ]
+      ]
+    }
+  },
+  {
+    type: 'directoryName',
+    value: {
+      type: 'rdnSequence',
+      value: [
+        [
+          {
+            type: oid.countryName,
+            value: PrintableString.encode('DE', 'der')
+          }
+        ],
+        [
+          {
+            type: oid.localityName,
+            value: UTF8String.encode(
+              'Berlin, DNS:good.example.com\\\0evil.example.com', 'der')
+          }
+        ]
+      ]
+    }
+  },
+  {
+    type: 'directoryName',
+    value: {
+      type: 'rdnSequence',
+      value: [
+        [
+          {
+            type: oid.countryName,
+            value: PrintableString.encode('DE', 'der')
+          }
+        ],
+        [
+          {
+            type: oid.localityName,
+            value: UTF8String.encode('Berlin\r\n', 'der')
+          }
+        ]
+      ]
+    }
+  },
+  {
+    type: 'directoryName',
+    value: {
+      type: 'rdnSequence',
+      value: [
+        [
+          {
+            type: oid.countryName,
+            value: PrintableString.encode('DE', 'der')
+          }
+        ],
+        [
+          {
+            type: oid.localityName,
+            value: UTF8String.encode('Berlin/CN=good.example.com', 'der')
+          }
+        ]
+      ]
+    }
+  },
+  {
+    type: 'registeredID',
+    value: oid.sha256WithRSAEncryption
+  },
+  {
+    type: 'registeredID',
+    value: oid.privateUnrecognized
+  },
+  {
+    type: 'otherName',
+    value: {
+      'type-id': oid.xmppAddr,
+      value: UTF8String.encode('abc123', 'der')
+    }
+  },
+  {
+    type: 'otherName',
+    value: {
+      'type-id': oid.xmppAddr,
+      value: UTF8String.encode('abc123, DNS:good.example.com', 'der')
+    }
+  },
+  {
+    type: 'otherName',
+    value: {
+      'type-id': oid.xmppAddr,
+      value: UTF8String.encode('good.example.com\0abc123', 'der')
+    }
+  },
+  {
+    type: 'otherName',
+    value: {
+      'type-id': oid.privateUnrecognized,
+      value: UTF8String.encode('abc123', 'der')
+    }
+  },
+  {
+    type: 'otherName',
+    value: {
+      'type-id': oid.srvName,
+      value: IA5String.encode('abc123', 'der')
+    }
+  },
+  {
+    type: 'otherName',
+    value: {
+      'type-id': oid.srvName,
+      value: UTF8String.encode('abc123', 'der')
+    }
+  },
+  {
+    type: 'otherName',
+    value: {
+      'type-id': oid.srvName,
+      value: IA5String.encode('abc\0def', 'der')
+    }
+  }
+];
+
+for (let i = 0; i < sans.length; i++) {
+  const san = sans[i];
+
+  const tbs = {
+    version: 'v3',
+    serialNumber: new BN('01', 16),
+    signature: {
+      algorithm: oid.sha256WithRSAEncryption,
+      parameters: null_
+    },
+    issuer: {
+      type: 'rdnSequence',
+      value: [
+        [
+          { type: oid.commonName, value: subjectCommonName }
+        ]
+      ]
+    },
+    validity: {
+      notBefore: { type: 'utcTime', value: now },
+      notAfter: { type: 'utcTime', value: now + days * 86400000 }
+    },
+    subject: {
+      type: 'rdnSequence',
+      value: [
+        [
+          { type: oid.commonName, value: subjectCommonName }
+        ]
+      ]
+    },
+    subjectPublicKeyInfo: {
+      algorithm: {
+        algorithm: oid.rsaEncryption,
+        parameters: null_
+      },
+      subjectPublicKey: {
+        unused: 0,
+        data: publicKey
+      }
+    },
+    extensions: [
+      {
+        extnID: 'subjectAlternativeName',
+        critical: false,
+        extnValue: [san]
+      }
+    ]
+  };
+
+  // Self-sign the certificate.
+  const tbsDer = rfc5280.TBSCertificate.encode(tbs, 'der');
+  const signature = crypto.createSign(digest).update(tbsDer).sign(privateKey);
+
+  // Construct the signed certificate.
+  const cert = {
+    tbsCertificate: tbs,
+    signatureAlgorithm: {
+      algorithm: oid.sha256WithRSAEncryption,
+      parameters: null_
+    },
+    signature: {
+      unused: 0,
+      data: signature
+    }
+  };
+
+  // Store the signed certificate.
+  const pem = rfc5280.Certificate.encode(cert, 'pem', {
+    label: 'CERTIFICATE'
+  });
+  writeFileSync(`./alt-${i}-cert.pem`, `${pem}\n`);
+}
+
+const infoAccessExtensions = [
+  [
+    {
+      accessMethod: oid.ocsp,
+      accessLocation: {
+        type: 'uniformResourceIdentifier',
+        value: 'http://good.example.com/\nOCSP - URI:http://evil.example.com/',
+      },
+    },
+  ],
+  [
+    {
+      accessMethod: oid.caIssuers,
+      accessLocation: {
+        type: 'uniformResourceIdentifier',
+        value: 'http://ca.example.com/\nOCSP - URI:http://evil.example.com',
+      },
+    },
+    {
+      accessMethod: oid.ocsp,
+      accessLocation: {
+        type: 'dNSName',
+        value: 'good.example.com\nOCSP - URI:http://ca.nodejs.org/ca.cert',
+      },
+    },
+  ],
+  [
+    {
+      accessMethod: oid.privateUnrecognized,
+      accessLocation: {
+        type: 'uniformResourceIdentifier',
+        value: 'http://ca.example.com/',
+      },
+    },
+  ],
+  [
+    {
+      accessMethod: oid.ocsp,
+      accessLocation: {
+        type: 'otherName',
+        value: {
+          'type-id': oid.xmppAddr,
+          value: UTF8String.encode('good.example.com', 'der'),
+        },
+      },
+    },
+    {
+      accessMethod: oid.ocsp,
+      accessLocation: {
+        type: 'otherName',
+        value: {
+          'type-id': oid.privateUnrecognized,
+          value: UTF8String.encode('abc123', 'der')
+        },
+      },
+    },
+    {
+      accessMethod: oid.ocsp,
+      accessLocation: {
+        type: 'otherName',
+        value: {
+          'type-id': oid.srvName,
+          value: IA5String.encode('abc123', 'der')
+        }
+      }
+    },
+  ],
+  [
+    {
+      accessMethod: oid.ocsp,
+      accessLocation: {
+        type: 'otherName',
+        value: {
+          'type-id': oid.xmppAddr,
+          value: UTF8String.encode('good.example.com\0abc123', 'der'),
+        },
+      },
+    },
+  ],
+];
+
+for (let i = 0; i < infoAccessExtensions.length; i++) {
+  const infoAccess = infoAccessExtensions[i];
+
+  const tbs = {
+    version: 'v3',
+    serialNumber: new BN('01', 16),
+    signature: {
+      algorithm: oid.sha256WithRSAEncryption,
+      parameters: null_
+    },
+    issuer: {
+      type: 'rdnSequence',
+      value: [
+        [
+          { type: oid.commonName, value: subjectCommonName }
+        ]
+      ]
+    },
+    validity: {
+      notBefore: { type: 'utcTime', value: now },
+      notAfter: { type: 'utcTime', value: now + days * 86400000 }
+    },
+    subject: {
+      type: 'rdnSequence',
+      value: [
+        [
+          { type: oid.commonName, value: subjectCommonName }
+        ]
+      ]
+    },
+    subjectPublicKeyInfo: {
+      algorithm: {
+        algorithm: oid.rsaEncryption,
+        parameters: null_
+      },
+      subjectPublicKey: {
+        unused: 0,
+        data: publicKey
+      }
+    },
+    extensions: [
+      {
+        extnID: 'authorityInformationAccess',
+        critical: false,
+        extnValue: infoAccess
+      }
+    ]
+  };
+
+  // Self-sign the certificate.
+  const tbsDer = rfc5280.TBSCertificate.encode(tbs, 'der');
+  const signature = crypto.createSign(digest).update(tbsDer).sign(privateKey);
+
+  // Construct the signed certificate.
+  const cert = {
+    tbsCertificate: tbs,
+    signatureAlgorithm: {
+      algorithm: oid.sha256WithRSAEncryption,
+      parameters: null_
+    },
+    signature: {
+      unused: 0,
+      data: signature
+    }
+  };
+
+  // Store the signed certificate.
+  const pem = rfc5280.Certificate.encode(cert, 'pem', {
+    label: 'CERTIFICATE'
+  });
+  writeFileSync(`./info-${i}-cert.pem`, `${pem}\n`);
+}
+
+const subjects = [
+  [
+    [
+      { type: oid.localityName, value: UTF8String.encode('Somewhere') }
+    ],
+    [
+      { type: oid.commonName, value: UTF8String.encode('evil.example.com') }
+    ]
+  ],
+  [
+    [
+      {
+        type: oid.localityName,
+        value: UTF8String.encode('Somewhere\0evil.example.com'),
+      }
+    ]
+  ],
+  [
+    [
+      {
+        type: oid.localityName,
+        value: UTF8String.encode('Somewhere\nCN=evil.example.com')
+      }
+    ]
+  ],
+  [
+    [
+      {
+        type: oid.localityName,
+        value: UTF8String.encode('Somewhere, CN = evil.example.com')
+      }
+    ]
+  ],
+  [
+    [
+      {
+        type: oid.localityName,
+        value: UTF8String.encode('Somewhere/CN=evil.example.com')
+      }
+    ]
+  ],
+  [
+    [
+      {
+        type: oid.localityName,
+        value: UTF8String.encode('M\u00fcnchen\\\nCN=evil.example.com')
+      }
+    ]
+  ],
+  [
+    [
+      { type: oid.localityName, value: UTF8String.encode('Somewhere') },
+      { type: oid.commonName, value: UTF8String.encode('evil.example.com') },
+    ]
+  ],
+  [
+    [
+      {
+        type: oid.localityName,
+        value: UTF8String.encode('Somewhere + CN=evil.example.com'),
+      }
+    ]
+  ],
+  [
+    [
+      { type: oid.localityName, value: UTF8String.encode('L1') },
+      { type: oid.localityName, value: UTF8String.encode('L2') },
+    ],
+    [
+      { type: oid.localityName, value: UTF8String.encode('L3') },
+    ]
+  ],
+  [
+    [
+      { type: oid.localityName, value: UTF8String.encode('L1') },
+    ],
+    [
+      { type: oid.localityName, value: UTF8String.encode('L2') },
+    ],
+    [
+      { type: oid.localityName, value: UTF8String.encode('L3') },
+    ],
+  ],
+];
+
+for (let i = 0; i < subjects.length; i++) {
+  const tbs = {
+    version: 'v3',
+    serialNumber: new BN('01', 16),
+    signature: {
+      algorithm: oid.sha256WithRSAEncryption,
+      parameters: null_
+    },
+    issuer: {
+      type: 'rdnSequence',
+      value: subjects[i]
+    },
+    validity: {
+      notBefore: { type: 'utcTime', value: now },
+      notAfter: { type: 'utcTime', value: now + days * 86400000 }
+    },
+    subject: {
+      type: 'rdnSequence',
+      value: subjects[i]
+    },
+    subjectPublicKeyInfo: {
+      algorithm: {
+        algorithm: oid.rsaEncryption,
+        parameters: null_
+      },
+      subjectPublicKey: {
+        unused: 0,
+        data: publicKey
+      }
+    }
+  };
+
+  // Self-sign the certificate.
+  const tbsDer = rfc5280.TBSCertificate.encode(tbs, 'der');
+  const signature = crypto.createSign(digest).update(tbsDer).sign(privateKey);
+
+  // Construct the signed certificate.
+  const cert = {
+    tbsCertificate: tbs,
+    signatureAlgorithm: {
+      algorithm: oid.sha256WithRSAEncryption,
+      parameters: null_
+    },
+    signature: {
+      unused: 0,
+      data: signature
+    }
+  };
+
+  // Store the signed certificate.
+  const pem = rfc5280.Certificate.encode(cert, 'pem', {
+    label: 'CERTIFICATE'
+  });
+  writeFileSync(`./subj-${i}-cert.pem`, `${pem}\n`);
+}
diff --git a/test/fixtures/x509-escaping/package.json b/test/fixtures/x509-escaping/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..37d9f2a9385c46e8b6a34eba5c0633e12e7b61b0
--- /dev/null
+++ b/test/fixtures/x509-escaping/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "x509-escaping",
+  "version": "1.0.0",
+  "description": "create certificates for x509-escaping test",
+  "main": "createCert.js",
+  "license": "SEE LICENSE IN ../../../LICENSE",
+  "private": true,
+  "dependencies": {
+    "asn1.js": "^5.4.1",
+    "asn1.js-rfc5280": "^3.0.0"
+  }
+}
diff --git a/test/internet/test-dgram-multicast-multi-process.js b/test/internet/test-dgram-multicast-multi-process.js
index 9d2e2c9f3ffd841b51d5350e3d7faebc411f39a6..e19f8dc05b747a9685b08747b3521eddded3a2ab 100644
--- a/test/internet/test-dgram-multicast-multi-process.js
+++ b/test/internet/test-dgram-multicast-multi-process.js
@@ -35,7 +35,7 @@ const messages = [
   Buffer.from('First message to send'),
   Buffer.from('Second message to send'),
   Buffer.from('Third message to send'),
-  Buffer.from('Fourth message to send')
+  Buffer.from('Fourth message to send'),
 ];
 const workers = {};
 const listeners = 3;
diff --git a/test/internet/test-dgram-multicast-set-interface-lo.js b/test/internet/test-dgram-multicast-set-interface-lo.js
index e06969b7b2367320392cc763e2950f339c99b3c5..11c3d47cff06375bb5eded387f228e5666525665 100644
--- a/test/internet/test-dgram-multicast-set-interface-lo.js
+++ b/test/internet/test-dgram-multicast-set-interface-lo.js
@@ -70,7 +70,7 @@ const messages = [
   { tail: 'Fourth message to send', mcast: MULTICASTS[FAM][2] },
   { tail: 'Fifth message to send', mcast: MULTICASTS[FAM][1], rcv: true },
   { tail: 'Sixth message to send', mcast: MULTICASTS[FAM][2], rcv: true,
-    newAddr: LOOPBACK[FAM] }
+    newAddr: LOOPBACK[FAM] },
 ];
 
 
diff --git a/test/internet/test-dgram-multicast-ssm-multi-process.js b/test/internet/test-dgram-multicast-ssm-multi-process.js
index 1771a4204c137b139808de2a8097d521eb27cbc6..5653559e243c7a2890366ac655c7d6c208ec5079 100644
--- a/test/internet/test-dgram-multicast-ssm-multi-process.js
+++ b/test/internet/test-dgram-multicast-ssm-multi-process.js
@@ -14,7 +14,7 @@ const messages = [
   Buffer.from('First message to send'),
   Buffer.from('Second message to send'),
   Buffer.from('Third message to send'),
-  Buffer.from('Fourth message to send')
+  Buffer.from('Fourth message to send'),
 ];
 const workers = {};
 const listeners = 3;
diff --git a/test/internet/test-dgram-multicast-ssmv6-multi-process.js b/test/internet/test-dgram-multicast-ssmv6-multi-process.js
index 88bb563364bfe39effaabf79e1aa02239bcb0c85..e139d93a971a28287a1e3dd386855cf79cf962e5 100644
--- a/test/internet/test-dgram-multicast-ssmv6-multi-process.js
+++ b/test/internet/test-dgram-multicast-ssmv6-multi-process.js
@@ -14,7 +14,7 @@ const messages = [
   Buffer.from('First message to send'),
   Buffer.from('Second message to send'),
   Buffer.from('Third message to send'),
-  Buffer.from('Fourth message to send')
+  Buffer.from('Fourth message to send'),
 ];
 const workers = {};
 const listeners = 3;
diff --git a/test/internet/test-dns-any.js b/test/internet/test-dns-any.js
index d60f00f09804a70e3e08cbc2e6358168dcf2ab00..e721d0f99dcfd7adf219055264746263d50bcc21 100644
--- a/test/internet/test-dns-any.js
+++ b/test/internet/test-dns-any.js
@@ -127,8 +127,7 @@ TEST(async function test_sip2sip_for_naptr(done) {
   const req = dns.resolve(
     'sip2sip.info',
     'ANY',
-    common.mustCall(function(err, ret) {
-      assert.ifError(err);
+    common.mustSucceed((ret) => {
       validateResult(ret);
       done();
     }));
@@ -147,8 +146,7 @@ TEST(async function test_google_for_cname_and_srv(done) {
   const req = dns.resolve(
     '_jabber._tcp.google.com',
     'ANY',
-    common.mustCall(function(err, ret) {
-      assert.ifError(err);
+    common.mustSucceed((ret) => {
       validateResult(ret);
       done();
     }));
@@ -167,8 +165,7 @@ TEST(async function test_ptr(done) {
   const req = dns.resolve(
     '8.8.8.8.in-addr.arpa',
     'ANY',
-    common.mustCall(function(err, ret) {
-      assert.ifError(err);
+    common.mustSucceed((ret) => {
       validateResult(ret);
       done();
     }));
diff --git a/test/internet/test-dns-cares-domains.js b/test/internet/test-dns-cares-domains.js
index 6609758a7daf17b54c4b83244746954c4c14d7e9..4a8e0eee71ba72d8d65a63f5ce497e5c60ee4ddc 100644
--- a/test/internet/test-dns-cares-domains.js
+++ b/test/internet/test-dns-cares-domains.js
@@ -15,7 +15,7 @@ const methods = [
   'resolveSrv',
   'resolvePtr',
   'resolveNaptr',
-  'resolveSoa'
+  'resolveSoa',
 ];
 
 methods.forEach(function(method) {
diff --git a/test/internet/test-dns-ipv4.js b/test/internet/test-dns-ipv4.js
index 1179cd6f5d6c7f8804e268bd3c8640137fc86508..a84f7e644fc9cf9cfe6dffee5f07e448aa304575 100644
--- a/test/internet/test-dns-ipv4.js
+++ b/test/internet/test-dns-ipv4.js
@@ -50,8 +50,7 @@ TEST(async function test_resolve4(done) {
 
   const req = dns.resolve4(
     addresses.INET4_HOST,
-    common.mustCall((err, ips) => {
-      assert.ifError(err);
+    common.mustSucceed((ips) => {
       validateResult(ips);
       done();
     }));
@@ -73,8 +72,7 @@ TEST(async function test_reverse_ipv4(done) {
 
   const req = dns.reverse(
     addresses.INET4_IP,
-    common.mustCall((err, domains) => {
-      assert.ifError(err);
+    common.mustSucceed((domains) => {
       validateResult(domains);
       done();
     }));
@@ -92,8 +90,7 @@ TEST(async function test_lookup_ipv4_explicit(done) {
 
   const req = dns.lookup(
     addresses.INET4_HOST, 4,
-    common.mustCall((err, ip, family) => {
-      assert.ifError(err);
+    common.mustSucceed((ip, family) => {
       validateResult({ address: ip, family });
       done();
     }));
@@ -111,8 +108,7 @@ TEST(async function test_lookup_ipv4_implicit(done) {
 
   const req = dns.lookup(
     addresses.INET4_HOST,
-    common.mustCall((err, ip, family) => {
-      assert.ifError(err);
+    common.mustSucceed((ip, family) => {
       validateResult({ address: ip, family });
       done();
     }));
@@ -130,8 +126,7 @@ TEST(async function test_lookup_ipv4_explicit_object(done) {
 
   const req = dns.lookup(addresses.INET4_HOST, {
     family: 4
-  }, common.mustCall((err, ip, family) => {
-    assert.ifError(err);
+  }, common.mustSucceed((ip, family) => {
     validateResult({ address: ip, family });
     done();
   }));
@@ -151,8 +146,7 @@ TEST(async function test_lookup_ipv4_hint_addrconfig(done) {
 
   const req = dns.lookup(addresses.INET4_HOST, {
     hints: dns.ADDRCONFIG
-  }, common.mustCall((err, ip, family) => {
-    assert.ifError(err);
+  }, common.mustSucceed((ip, family) => {
     validateResult({ address: ip, family });
     done();
   }));
@@ -169,8 +163,7 @@ TEST(async function test_lookup_ip_ipv4(done) {
   validateResult(await dnsPromises.lookup('127.0.0.1'));
 
   const req = dns.lookup('127.0.0.1',
-                         common.mustCall((err, ip, family) => {
-                           assert.ifError(err);
+                         common.mustSucceed((ip, family) => {
                            validateResult({ address: ip, family });
                            done();
                          }));
@@ -187,8 +180,7 @@ TEST(async function test_lookup_localhost_ipv4(done) {
   validateResult(await dnsPromises.lookup('localhost', 4));
 
   const req = dns.lookup('localhost', 4,
-                         common.mustCall((err, ip, family) => {
-                           assert.ifError(err);
+                         common.mustSucceed((ip, family) => {
                            validateResult({ address: ip, family });
                            done();
                          }));
@@ -215,8 +207,7 @@ TEST(async function test_lookup_all_ipv4(done) {
   const req = dns.lookup(
     addresses.INET4_HOST,
     { all: true, family: 4 },
-    common.mustCall((err, ips) => {
-      assert.ifError(err);
+    common.mustSucceed((ips) => {
       validateResult(ips);
       done();
     })
@@ -236,8 +227,7 @@ TEST(async function test_lookupservice_ip_ipv4(done) {
 
   const req = dns.lookupService(
     '127.0.0.1', 80,
-    common.mustCall((err, hostname, service) => {
-      assert.ifError(err);
+    common.mustSucceed((hostname, service) => {
       validateResult({ hostname, service });
       done();
     })
diff --git a/test/internet/test-dns-ipv6.js b/test/internet/test-dns-ipv6.js
index b2cd6163e8007c48f1b3b53449aa77fe42b63ffe..6f499b68947322f935913d67be51e43f2bb47918 100644
--- a/test/internet/test-dns-ipv6.js
+++ b/test/internet/test-dns-ipv6.js
@@ -52,8 +52,7 @@ TEST(async function test_resolve6(done) {
 
   const req = dns.resolve6(
     addresses.INET6_HOST,
-    common.mustCall((err, ips) => {
-      assert.ifError(err);
+    common.mustSucceed((ips) => {
       validateResult(ips);
       done();
     }));
@@ -74,8 +73,7 @@ TEST(async function test_reverse_ipv6(done) {
 
   const req = dns.reverse(
     addresses.INET6_IP,
-    common.mustCall((err, domains) => {
-      assert.ifError(err);
+    common.mustSucceed((domains) => {
       validateResult(domains);
       done();
     }));
@@ -94,8 +92,7 @@ TEST(async function test_lookup_ipv6_explicit(done) {
   const req = dns.lookup(
     addresses.INET6_HOST,
     6,
-    common.mustCall((err, ip, family) => {
-      assert.ifError(err);
+    common.mustSucceed((ip, family) => {
       validateResult({ address: ip, family });
       done();
     }));
@@ -103,19 +100,18 @@ TEST(async function test_lookup_ipv6_explicit(done) {
   checkWrap(req);
 });
 
-/* This ends up just being too problematic to test
-TEST(function test_lookup_ipv6_implicit(done) {
-  var req = dns.lookup(addresses.INET6_HOST, function(err, ip, family) {
-    assert.ifError(err);
-    assert.ok(net.isIPv6(ip));
-    assert.strictEqual(family, 6);
+// This ends up just being too problematic to test
+// TEST(function test_lookup_ipv6_implicit(done) {
+//   var req = dns.lookup(addresses.INET6_HOST, function(err, ip, family) {
+//     assert.ifError(err);
+//     assert.ok(net.isIPv6(ip));
+//     assert.strictEqual(family, 6);
 
-    done();
-  });
+//     done();
+//   });
 
-  checkWrap(req);
-});
-*/
+//   checkWrap(req);
+// });
 
 TEST(async function test_lookup_ipv6_explicit_object(done) {
   function validateResult(res) {
@@ -127,8 +123,7 @@ TEST(async function test_lookup_ipv6_explicit_object(done) {
 
   const req = dns.lookup(addresses.INET6_HOST, {
     family: 6
-  }, common.mustCall((err, ip, family) => {
-    assert.ifError(err);
+  }, common.mustSucceed((ip, family) => {
     validateResult({ address: ip, family });
     done();
   }));
@@ -174,8 +169,7 @@ TEST(async function test_lookup_ip_ipv6(done) {
 
   const req = dns.lookup(
     '::1',
-    common.mustCall((err, ip, family) => {
-      assert.ifError(err);
+    common.mustSucceed((ip, family) => {
       validateResult({ address: ip, family });
       done();
     }));
@@ -203,8 +197,7 @@ TEST(async function test_lookup_all_ipv6(done) {
   const req = dns.lookup(
     addresses.INET6_HOST,
     { all: true, family: 6 },
-    common.mustCall((err, ips) => {
-      assert.ifError(err);
+    common.mustSucceed((ips) => {
       validateResult(ips);
       done();
     })
@@ -233,15 +226,15 @@ TEST(function test_lookupservice_ip_ipv6(done) {
   checkWrap(req);
 });
 
-/* Disabled because it appears to be not working on linux. */
-/* TEST(function test_lookup_localhost_ipv6(done) {
-  var req = dns.lookup('localhost', 6, function(err, ip, family) {
-    assert.ifError(err);
-    assert.ok(net.isIPv6(ip));
-    assert.strictEqual(family, 6);
-
-    done();
-  });
-
-  checkWrap(req);
-}); */
+// Disabled because it appears to be not working on Linux.
+// TEST(function test_lookup_localhost_ipv6(done) {
+//   var req = dns.lookup('localhost', 6, function(err, ip, family) {
+//     assert.ifError(err);
+//     assert.ok(net.isIPv6(ip));
+//     assert.strictEqual(family, 6);
+//
+//     done();
+//   });
+//
+//   checkWrap(req);
+// });
diff --git a/test/internet/test-dns-lookup.js b/test/internet/test-dns-lookup.js
index df5ccf99a56fc3c307ae46e83946505da6089665..6939698d392317c83865216fb513a41b776047d3 100644
--- a/test/internet/test-dns-lookup.js
+++ b/test/internet/test-dns-lookup.js
@@ -8,30 +8,30 @@ const { addresses } = require('../common/internet');
 const assert = require('assert');
 
 assert.rejects(
-  dnsPromises.lookup(addresses.INVALID_HOST, {
+  dnsPromises.lookup(addresses.NOT_FOUND, {
     hints: 0,
     family: 0,
     all: false
   }),
   {
     code: 'ENOTFOUND',
-    message: `getaddrinfo ENOTFOUND ${addresses.INVALID_HOST}`
+    message: `getaddrinfo ENOTFOUND ${addresses.NOT_FOUND}`
   }
 );
 
 assert.rejects(
-  dnsPromises.lookup(addresses.INVALID_HOST, {
+  dnsPromises.lookup(addresses.NOT_FOUND, {
     hints: 0,
     family: 0,
     all: true
   }),
   {
     code: 'ENOTFOUND',
-    message: `getaddrinfo ENOTFOUND ${addresses.INVALID_HOST}`
+    message: `getaddrinfo ENOTFOUND ${addresses.NOT_FOUND}`
   }
 );
 
-dns.lookup(addresses.INVALID_HOST, {
+dns.lookup(addresses.NOT_FOUND, {
   hints: 0,
   family: 0,
   all: true
@@ -39,8 +39,8 @@ dns.lookup(addresses.INVALID_HOST, {
   assert.strictEqual(error.code, 'ENOTFOUND');
   assert.strictEqual(
     error.message,
-    `getaddrinfo ENOTFOUND ${addresses.INVALID_HOST}`
+    `getaddrinfo ENOTFOUND ${addresses.NOT_FOUND}`
   );
   assert.strictEqual(error.syscall, 'getaddrinfo');
-  assert.strictEqual(error.hostname, addresses.INVALID_HOST);
+  assert.strictEqual(error.hostname, addresses.NOT_FOUND);
 }));
diff --git a/test/internet/test-dns-promises-resolve.js b/test/internet/test-dns-promises-resolve.js
index a482cba60a2c1479d124f921f2fcbf31f0f2f7a1..ed9c95a010a36e609b45672b6b892f41a238aeca 100644
--- a/test/internet/test-dns-promises-resolve.js
+++ b/test/internet/test-dns-promises-resolve.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const dnsPromises = require('dns').promises;
@@ -38,5 +38,5 @@ const dnsPromises = require('dns').promises;
     const result = await dnsPromises.resolve('example.org', rrtype);
     assert.ok(result !== undefined);
     assert.ok(result.length > 0);
-  })();
+  })().then(common.mustCall());
 }
diff --git a/test/internet/test-dns-txt-sigsegv.js b/test/internet/test-dns-txt-sigsegv.js
index 9f65b6ec24ffc07cce6bc0afcfecd212d28af229..eeebf28fc7761cdae56c5ae974f5769da1d82d7f 100644
--- a/test/internet/test-dns-txt-sigsegv.js
+++ b/test/internet/test-dns-txt-sigsegv.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const dns = require('dns');
 const dnsPromises = dns.promises;
@@ -7,7 +7,7 @@ const dnsPromises = dns.promises;
 (async function() {
   const result = await dnsPromises.resolveTxt('www.microsoft.com');
   assert.strictEqual(result.length, 0);
-})();
+})().then(common.mustCall());
 
 dns.resolveTxt('www.microsoft.com', function(err, records) {
   assert.strictEqual(err, null);
diff --git a/test/internet/test-dns.js b/test/internet/test-dns.js
index 3d331fd196a722835f272415b2e46d4e2ee97aab..363dc92446a5efc18075375a132da9940f1138b3 100644
--- a/test/internet/test-dns.js
+++ b/test/internet/test-dns.js
@@ -24,6 +24,7 @@
 const common = require('../common');
 const { addresses } = require('../common/internet');
 const { internalBinding } = require('internal/test/binding');
+const { getSystemErrorName } = require('util');
 const assert = require('assert');
 const dns = require('dns');
 const net = require('net');
@@ -71,7 +72,10 @@ function checkWrap(req) {
 TEST(function test_reverse_bogus(done) {
   dnsPromises.reverse('bogus ip')
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'EINVAL' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'EINVAL');
+      assert.strictEqual(getSystemErrorName(err.errno), 'EINVAL');
+    }));
 
   assert.throws(() => {
     dns.reverse('bogus ip', common.mustNotCall());
@@ -87,7 +91,7 @@ TEST(async function test_resolve4_ttl(done) {
       assert.strictEqual(typeof item, 'object');
       assert.strictEqual(typeof item.ttl, 'number');
       assert.strictEqual(typeof item.address, 'string');
-      assert.ok(item.ttl > 0);
+      assert.ok(item.ttl >= 0);
       assert.ok(isIPv4(item.address));
     }
   }
@@ -115,7 +119,7 @@ TEST(async function test_resolve6_ttl(done) {
       assert.strictEqual(typeof item, 'object');
       assert.strictEqual(typeof item.ttl, 'number');
       assert.strictEqual(typeof item.address, 'string');
-      assert.ok(item.ttl > 0);
+      assert.ok(item.ttl >= 0);
       assert.ok(isIPv6(item.address));
     }
   }
@@ -159,13 +163,15 @@ TEST(async function test_resolveMx(done) {
 });
 
 TEST(function test_resolveMx_failure(done) {
-  dnsPromises.resolveMx(addresses.INVALID_HOST)
+  dnsPromises.resolveMx(addresses.NOT_FOUND)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
 
-  const req = dns.resolveMx(addresses.INVALID_HOST, function(err, result) {
+  const req = dns.resolveMx(addresses.NOT_FOUND, function(err, result) {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, 'ENOTFOUND');
 
     assert.strictEqual(result, undefined);
 
@@ -197,13 +203,15 @@ TEST(async function test_resolveNs(done) {
 });
 
 TEST(function test_resolveNs_failure(done) {
-  dnsPromises.resolveNs(addresses.INVALID_HOST)
+  dnsPromises.resolveNs(addresses.NOT_FOUND)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
 
-  const req = dns.resolveNs(addresses.INVALID_HOST, function(err, result) {
+  const req = dns.resolveNs(addresses.NOT_FOUND, function(err, result) {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, 'ENOTFOUND');
 
     assert.strictEqual(result, undefined);
 
@@ -239,13 +247,15 @@ TEST(async function test_resolveSrv(done) {
 });
 
 TEST(function test_resolveSrv_failure(done) {
-  dnsPromises.resolveSrv(addresses.INVALID_HOST)
+  dnsPromises.resolveSrv(addresses.NOT_FOUND)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
 
-  const req = dns.resolveSrv(addresses.INVALID_HOST, function(err, result) {
+  const req = dns.resolveSrv(addresses.NOT_FOUND, function(err, result) {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, 'ENOTFOUND');
 
     assert.strictEqual(result, undefined);
 
@@ -277,13 +287,15 @@ TEST(async function test_resolvePtr(done) {
 });
 
 TEST(function test_resolvePtr_failure(done) {
-  dnsPromises.resolvePtr(addresses.INVALID_HOST)
+  dnsPromises.resolvePtr(addresses.NOT_FOUND)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
 
-  const req = dns.resolvePtr(addresses.INVALID_HOST, function(err, result) {
+  const req = dns.resolvePtr(addresses.NOT_FOUND, function(err, result) {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, 'ENOTFOUND');
 
     assert.strictEqual(result, undefined);
 
@@ -320,13 +332,15 @@ TEST(async function test_resolveNaptr(done) {
 });
 
 TEST(function test_resolveNaptr_failure(done) {
-  dnsPromises.resolveNaptr(addresses.INVALID_HOST)
+  dnsPromises.resolveNaptr(addresses.NOT_FOUND)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
 
-  const req = dns.resolveNaptr(addresses.INVALID_HOST, function(err, result) {
+  const req = dns.resolveNaptr(addresses.NOT_FOUND, function(err, result) {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, 'ENOTFOUND');
 
     assert.strictEqual(result, undefined);
 
@@ -367,13 +381,55 @@ TEST(async function test_resolveSoa(done) {
 });
 
 TEST(function test_resolveSoa_failure(done) {
-  dnsPromises.resolveSoa(addresses.INVALID_HOST)
+  dnsPromises.resolveSoa(addresses.NOT_FOUND)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
 
-  const req = dns.resolveSoa(addresses.INVALID_HOST, function(err, result) {
+  const req = dns.resolveSoa(addresses.NOT_FOUND, function(err, result) {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, 'ENOTFOUND');
+
+    assert.strictEqual(result, undefined);
+
+    done();
+  });
+
+  checkWrap(req);
+});
+
+TEST(async function test_resolveCaa(done) {
+  function validateResult(result) {
+    assert.ok(Array.isArray(result),
+              `expected array, got ${util.inspect(result)}`);
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(typeof result[0].critical, 'number');
+    assert.strictEqual(result[0].critical, 0);
+    assert.strictEqual(result[0].issue, 'pki.goog');
+  }
+
+  validateResult(await dnsPromises.resolveCaa(addresses.CAA_HOST));
+
+  const req = dns.resolveCaa(addresses.CAA_HOST, function(err, records) {
+    assert.ifError(err);
+    validateResult(records);
+    done();
+  });
+
+  checkWrap(req);
+});
+
+TEST(function test_resolveCaa_failure(done) {
+  dnsPromises.resolveTxt(addresses.NOT_FOUND)
+    .then(common.mustNotCall())
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
+
+  const req = dns.resolveCaa(addresses.NOT_FOUND, function(err, result) {
+    assert.ok(err instanceof Error);
+    assert.strictEqual(err.code, 'ENOTFOUND');
 
     assert.strictEqual(result, undefined);
 
@@ -405,13 +461,15 @@ TEST(async function test_resolveCname(done) {
 });
 
 TEST(function test_resolveCname_failure(done) {
-  dnsPromises.resolveCname(addresses.INVALID_HOST)
+  dnsPromises.resolveCname(addresses.NOT_FOUND)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
 
-  const req = dns.resolveCname(addresses.INVALID_HOST, function(err, result) {
+  const req = dns.resolveCname(addresses.NOT_FOUND, function(err, result) {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, 'ENOTFOUND');
 
     assert.strictEqual(result, undefined);
 
@@ -441,13 +499,15 @@ TEST(async function test_resolveTxt(done) {
 });
 
 TEST(function test_resolveTxt_failure(done) {
-  dnsPromises.resolveTxt(addresses.INVALID_HOST)
+  dnsPromises.resolveTxt(addresses.NOT_FOUND)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+    .catch(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOTFOUND');
+    }));
 
-  const req = dns.resolveTxt(addresses.INVALID_HOST, function(err, result) {
+  const req = dns.resolveTxt(addresses.NOT_FOUND, function(err, result) {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, 'ENOTFOUND');
 
     assert.strictEqual(result, undefined);
 
@@ -459,16 +519,16 @@ TEST(function test_resolveTxt_failure(done) {
 
 
 TEST(function test_lookup_failure(done) {
-  dnsPromises.lookup(addresses.INVALID_HOST, 4)
+  dnsPromises.lookup(addresses.NOT_FOUND, 4)
     .then(common.mustNotCall())
-    .catch(common.expectsError({ errno: dns.NOTFOUND }));
+    .catch(common.expectsError({ code: dns.NOTFOUND }));
 
-  const req = dns.lookup(addresses.INVALID_HOST, 4, (err) => {
+  const req = dns.lookup(addresses.NOT_FOUND, 4, (err) => {
     assert.ok(err instanceof Error);
-    assert.strictEqual(err.errno, dns.NOTFOUND);
-    assert.strictEqual(err.errno, 'ENOTFOUND');
+    assert.strictEqual(err.code, dns.NOTFOUND);
+    assert.strictEqual(err.code, 'ENOTFOUND');
     assert.ok(!/ENOENT/.test(err.message));
-    assert.ok(err.message.includes(addresses.INVALID_HOST));
+    assert.ok(err.message.includes(addresses.NOT_FOUND));
 
     done();
   });
@@ -612,18 +672,18 @@ TEST(function test_reverse_failure(done) {
 
 
 TEST(function test_lookup_failure(done) {
-  dnsPromises.lookup(addresses.INVALID_HOST)
+  dnsPromises.lookup(addresses.NOT_FOUND)
     .then(common.mustNotCall())
     .catch(common.expectsError({
       code: 'ENOTFOUND',
-      hostname: addresses.INVALID_HOST
+      hostname: addresses.NOT_FOUND
     }));
 
-  const req = dns.lookup(addresses.INVALID_HOST, (err) => {
+  const req = dns.lookup(addresses.NOT_FOUND, (err) => {
     assert(err instanceof Error);
     assert.strictEqual(err.code, 'ENOTFOUND');  // Silly error code...
-    assert.strictEqual(err.hostname, addresses.INVALID_HOST);
-    assert.ok(err.message.includes(addresses.INVALID_HOST));
+    assert.strictEqual(err.hostname, addresses.NOT_FOUND);
+    assert.ok(err.message.includes(addresses.NOT_FOUND));
 
     done();
   });
@@ -633,7 +693,7 @@ TEST(function test_lookup_failure(done) {
 
 
 TEST(function test_resolve_failure(done) {
-  const req = dns.resolve4(addresses.INVALID_HOST, (err) => {
+  const req = dns.resolve4(addresses.NOT_FOUND, (err) => {
     assert(err instanceof Error);
 
     switch (err.code) {
@@ -645,8 +705,8 @@ TEST(function test_resolve_failure(done) {
         break;
     }
 
-    assert.strictEqual(err.hostname, addresses.INVALID_HOST);
-    assert.ok(err.message.includes(addresses.INVALID_HOST));
+    assert.strictEqual(err.hostname, addresses.NOT_FOUND);
+    assert.ok(err.message.includes(addresses.NOT_FOUND));
 
     done();
   });
@@ -688,4 +748,4 @@ dns.lookupService('0.0.0.0', 0, common.mustCall());
 (async function() {
   await dnsPromises.lookup(addresses.INET6_HOST, 6);
   await dnsPromises.lookup(addresses.INET_HOST, {});
-})();
+})().then(common.mustCall());
diff --git a/test/internet/test-http-dns-fail.js b/test/internet/test-http-dns-fail.js
index 82a7030465dbc9fb81c67c2e5109f0053a51ff49..00875a976335e6f1e334cc2b01b5565cf7b27a71 100644
--- a/test/internet/test-http-dns-fail.js
+++ b/test/internet/test-http-dns-fail.js
@@ -20,10 +20,9 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-/*
- * Repeated requests for a domain that fails to resolve
- * should trigger the error event after each attempt.
- */
+
+// Repeated requests for a domain that fails to resolve
+// should trigger the error event after each attempt.
 
 const common = require('../common');
 const assert = require('assert');
diff --git a/test/internet/test-http2-issue-32922.js b/test/internet/test-http2-issue-32922.js
index e11de0286eb7a47f0990d7f7f050e8b34c118361..d4efc27060dda09310d9f36a316c04e21fb42e86 100644
--- a/test/internet/test-http2-issue-32922.js
+++ b/test/internet/test-http2-issue-32922.js
@@ -1,6 +1,5 @@
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 
 if (!common.hasCrypto)
   common.skip('missing crypto');
@@ -29,9 +28,7 @@ function normalSession(cb) {
     });
   });
 }
-normalSession(common.mustCall(function(err) {
-  assert.ifError(err);
-}));
+normalSession(common.mustSucceed());
 
 // Create a session using a socket that has not yet finished connecting
 function socketNotFinished(done) {
@@ -52,9 +49,7 @@ function socketNotFinished(done) {
     });
   });
 }
-socketNotFinished(common.mustCall(function(err) {
-  assert.ifError(err);
-}));
+socketNotFinished(common.mustSucceed());
 
 // Create a session using a socket that has finished connecting
 function socketFinished(done) {
@@ -75,6 +70,4 @@ function socketFinished(done) {
     });
   });
 }
-socketFinished(common.mustCall(function(err) {
-  assert.ifError(err);
-}));
+socketFinished(common.mustSucceed());
diff --git a/test/internet/test-tls-connnect-melissadata.js b/test/internet/test-tls-connnect-melissadata.js
deleted file mode 100644
index ab5aa3950938b33bc70c35512f3ffe59186b1d27..0000000000000000000000000000000000000000
--- a/test/internet/test-tls-connnect-melissadata.js
+++ /dev/null
@@ -1,13 +0,0 @@
-'use strict';
-// Test for authorized access to the server which has a cross root
-// certification between Starfield Class 2 and ValiCert Class 2
-
-const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
-
-const tls = require('tls');
-const socket = tls.connect(443, 'address.melissadata.net', function() {
-  socket.resume();
-  socket.destroy();
-});
diff --git a/test/internet/test-trace-events-dns.js b/test/internet/test-trace-events-dns.js
index 9e5a0ccb026c1ac3b415fd721c1df9acabef0722..529665f907b0c9473413076fd75823a778db0450 100644
--- a/test/internet/test-trace-events-dns.js
+++ b/test/internet/test-trace-events-dns.js
@@ -29,6 +29,7 @@ const tests = {
   'resolveAny': 'dns.resolveAny("example.com", (err, res) => {});',
   'resolve4': 'dns.resolve4("example.com", (err, res) => {});',
   'resolve6': 'dns.resolve6("example.com", (err, res) => {});',
+  'resolveCaa': 'dns.resolveCaa("example.com", (err, res) => {});',
   'resolveCname': 'dns.resolveCname("example.com", (err, res) => {});',
   'resolveMx': 'dns.resolveMx("example.com", (err, res) => {});',
   'resolveNs': 'dns.resolveNs("example.com", (err, res) => {});',
@@ -44,7 +45,7 @@ for (const tr in tests) {
                             [ '--trace-event-categories',
                               'node.dns.native',
                               '-e',
-                              test_str + tests[tr]
+                              test_str + tests[tr],
                             ],
                             { encoding: 'utf8' });
 
diff --git a/test/js-native-api/2_function_arguments/binding.c b/test/js-native-api/2_function_arguments/2_function_arguments.c
similarity index 100%
rename from test/js-native-api/2_function_arguments/binding.c
rename to test/js-native-api/2_function_arguments/2_function_arguments.c
diff --git a/test/js-native-api/2_function_arguments/binding.gyp b/test/js-native-api/2_function_arguments/binding.gyp
index 2a144bab42827e558244cf6dead5e47a0a742d1b..7e35a4c9d6dc05429c880beb8a972f1536bac877 100644
--- a/test/js-native-api/2_function_arguments/binding.gyp
+++ b/test/js-native-api/2_function_arguments/binding.gyp
@@ -1,10 +1,10 @@
 {
   "targets": [
     {
-      "target_name": "binding",
+      "target_name": "2_function_arguments",
       "sources": [
         "../entry_point.c",
-        "binding.c"
+        "2_function_arguments.c"
       ]
     }
   ]
diff --git a/test/js-native-api/2_function_arguments/test.js b/test/js-native-api/2_function_arguments/test.js
index e70f76b718bd10e9515baddf6b328164ee18217a..bf0ecabac3b7a03cbb98da46ba9a7cf5c90256e0 100644
--- a/test/js-native-api/2_function_arguments/test.js
+++ b/test/js-native-api/2_function_arguments/test.js
@@ -1,6 +1,6 @@
 'use strict';
 const common = require('../../common');
 const assert = require('assert');
-const addon = require(`./build/${common.buildType}/binding`);
+const addon = require(`./build/${common.buildType}/2_function_arguments`);
 
 assert.strictEqual(addon.add(3, 5), 8);
diff --git a/test/js-native-api/3_callbacks/binding.c b/test/js-native-api/3_callbacks/3_callbacks.c
similarity index 100%
rename from test/js-native-api/3_callbacks/binding.c
rename to test/js-native-api/3_callbacks/3_callbacks.c
diff --git a/test/js-native-api/3_callbacks/binding.gyp b/test/js-native-api/3_callbacks/binding.gyp
index 2a144bab42827e558244cf6dead5e47a0a742d1b..3cc662c4076dc1ad2d830789800dae0154694a79 100644
--- a/test/js-native-api/3_callbacks/binding.gyp
+++ b/test/js-native-api/3_callbacks/binding.gyp
@@ -1,10 +1,10 @@
 {
   "targets": [
     {
-      "target_name": "binding",
+      "target_name": "3_callbacks",
       "sources": [
         "../entry_point.c",
-        "binding.c"
+        "3_callbacks.c"
       ]
     }
   ]
diff --git a/test/js-native-api/3_callbacks/test.js b/test/js-native-api/3_callbacks/test.js
index 25e070d97445297aa658823eac331ad8b8baf170..b84d3fbc9ddec0523958d2c9d014f30e55891c91 100644
--- a/test/js-native-api/3_callbacks/test.js
+++ b/test/js-native-api/3_callbacks/test.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../../common');
 const assert = require('assert');
-const addon = require(`./build/${common.buildType}/binding`);
+const addon = require(`./build/${common.buildType}/3_callbacks`);
 
 addon.RunCallback(function(msg) {
   assert.strictEqual(msg, 'hello world');
diff --git a/test/js-native-api/4_object_factory/binding.c b/test/js-native-api/4_object_factory/4_object_factory.c
similarity index 100%
rename from test/js-native-api/4_object_factory/binding.c
rename to test/js-native-api/4_object_factory/4_object_factory.c
diff --git a/test/js-native-api/4_object_factory/binding.gyp b/test/js-native-api/4_object_factory/binding.gyp
index 2a144bab42827e558244cf6dead5e47a0a742d1b..6cb3a9fa68b48a09aff1d5edc4fef200f739b4b8 100644
--- a/test/js-native-api/4_object_factory/binding.gyp
+++ b/test/js-native-api/4_object_factory/binding.gyp
@@ -1,10 +1,10 @@
 {
   "targets": [
     {
-      "target_name": "binding",
+      "target_name": "4_object_factory",
       "sources": [
         "../entry_point.c",
-        "binding.c"
+        "4_object_factory.c"
       ]
     }
   ]
diff --git a/test/js-native-api/4_object_factory/test.js b/test/js-native-api/4_object_factory/test.js
index 15313c1547f24b4158c921612cfb806a499d49f4..16cad91753d40e3905aa205b1ee8b2510941eb22 100644
--- a/test/js-native-api/4_object_factory/test.js
+++ b/test/js-native-api/4_object_factory/test.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../../common');
 const assert = require('assert');
-const addon = require(`./build/${common.buildType}/binding`);
+const addon = require(`./build/${common.buildType}/4_object_factory`);
 
 const obj1 = addon('hello');
 const obj2 = addon('world');
diff --git a/test/js-native-api/5_function_factory/binding.c b/test/js-native-api/5_function_factory/5_function_factory.c
similarity index 100%
rename from test/js-native-api/5_function_factory/binding.c
rename to test/js-native-api/5_function_factory/5_function_factory.c
diff --git a/test/js-native-api/5_function_factory/binding.gyp b/test/js-native-api/5_function_factory/binding.gyp
index 2a144bab42827e558244cf6dead5e47a0a742d1b..c621c29f185cab88ad03bbcd6cd8a815f936dbd3 100644
--- a/test/js-native-api/5_function_factory/binding.gyp
+++ b/test/js-native-api/5_function_factory/binding.gyp
@@ -1,10 +1,10 @@
 {
   "targets": [
     {
-      "target_name": "binding",
+      "target_name": "5_function_factory",
       "sources": [
         "../entry_point.c",
-        "binding.c"
+        "5_function_factory.c"
       ]
     }
   ]
diff --git a/test/js-native-api/5_function_factory/test.js b/test/js-native-api/5_function_factory/test.js
index 7521824e1e000a4cda21a2e5e51af7fe7157db76..9d4772985c2a40f1d53b49ab7ad7baecc1ae8f5d 100644
--- a/test/js-native-api/5_function_factory/test.js
+++ b/test/js-native-api/5_function_factory/test.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../../common');
 const assert = require('assert');
-const addon = require(`./build/${common.buildType}/binding`);
+const addon = require(`./build/${common.buildType}/5_function_factory`);
 
 const fn = addon();
 assert.strictEqual(fn(), 'hello world'); // 'hello world'
diff --git a/test/js-native-api/6_object_wrap/myobject.cc b/test/js-native-api/6_object_wrap/6_object_wrap.cc
similarity index 100%
rename from test/js-native-api/6_object_wrap/myobject.cc
rename to test/js-native-api/6_object_wrap/6_object_wrap.cc
diff --git a/test/js-native-api/6_object_wrap/binding.gyp b/test/js-native-api/6_object_wrap/binding.gyp
index 0456804aaff8b96dd9c348b54016dda9d9cec8f0..2807d6a1572529b4112c06d9fbef96c3180b6a73 100644
--- a/test/js-native-api/6_object_wrap/binding.gyp
+++ b/test/js-native-api/6_object_wrap/binding.gyp
@@ -1,10 +1,10 @@
 {
   "targets": [
     {
-      "target_name": "binding",
+      "target_name": "6_object_wrap",
       "sources": [
         "../entry_point.c",
-        "myobject.cc"
+        "6_object_wrap.cc"
       ]
     }
   ]
diff --git a/test/js-native-api/6_object_wrap/test.js b/test/js-native-api/6_object_wrap/test.js
index f3535969c60fea09b77ecfff061316036bf0f38c..c113a47299f95ca65c729983fca9cc8ce71b33c7 100644
--- a/test/js-native-api/6_object_wrap/test.js
+++ b/test/js-native-api/6_object_wrap/test.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../../common');
 const assert = require('assert');
-const addon = require(`./build/${common.buildType}/binding`);
+const addon = require(`./build/${common.buildType}/6_object_wrap`);
 
 const getterOnlyErrorRE =
   /^TypeError: Cannot set property .* of #<.*> which has only a getter$/;
diff --git a/test/js-native-api/7_factory_wrap/binding.cc b/test/js-native-api/7_factory_wrap/7_factory_wrap.cc
similarity index 100%
rename from test/js-native-api/7_factory_wrap/binding.cc
rename to test/js-native-api/7_factory_wrap/7_factory_wrap.cc
diff --git a/test/js-native-api/7_factory_wrap/binding.gyp b/test/js-native-api/7_factory_wrap/binding.gyp
index 4071c9fe8cf87afd5554108efd671356e4200bbd..f9096674a70b5c448dfb0a09f0a0cdfc9484c2d9 100644
--- a/test/js-native-api/7_factory_wrap/binding.gyp
+++ b/test/js-native-api/7_factory_wrap/binding.gyp
@@ -1,10 +1,10 @@
 {
   "targets": [
     {
-      "target_name": "binding",
+      "target_name": "7_factory_wrap",
       "sources": [
         "../entry_point.c",
-        "binding.cc",
+        "7_factory_wrap.cc",
         "myobject.cc"
       ]
     }
diff --git a/test/js-native-api/7_factory_wrap/test.js b/test/js-native-api/7_factory_wrap/test.js
index ff1516eaa5a09221e1cad3d566b1d79ea73558f7..fd9771d43bbed0490ddc27552a98f31dfed5efc5 100644
--- a/test/js-native-api/7_factory_wrap/test.js
+++ b/test/js-native-api/7_factory_wrap/test.js
@@ -3,7 +3,7 @@
 
 const common = require('../../common');
 const assert = require('assert');
-const test = require(`./build/${common.buildType}/binding`);
+const test = require(`./build/${common.buildType}/7_factory_wrap`);
 
 assert.strictEqual(test.finalizeCount, 0);
 async function runGCTests() {
diff --git a/test/js-native-api/8_passing_wrapped/binding.cc b/test/js-native-api/8_passing_wrapped/8_passing_wrapped.cc
similarity index 100%
rename from test/js-native-api/8_passing_wrapped/binding.cc
rename to test/js-native-api/8_passing_wrapped/8_passing_wrapped.cc
diff --git a/test/js-native-api/8_passing_wrapped/binding.gyp b/test/js-native-api/8_passing_wrapped/binding.gyp
index 4071c9fe8cf87afd5554108efd671356e4200bbd..f85cc4cc97ae45757c82030588fe16b491fcd103 100644
--- a/test/js-native-api/8_passing_wrapped/binding.gyp
+++ b/test/js-native-api/8_passing_wrapped/binding.gyp
@@ -1,10 +1,10 @@
 {
   "targets": [
     {
-      "target_name": "binding",
+      "target_name": "8_passing_wrapped",
       "sources": [
         "../entry_point.c",
-        "binding.cc",
+        "8_passing_wrapped.cc",
         "myobject.cc"
       ]
     }
diff --git a/test/js-native-api/8_passing_wrapped/test.js b/test/js-native-api/8_passing_wrapped/test.js
index 54c829d9c77dffb1a955207a8a409305c354b43f..d6da19fecd4de876d56c29d8933c57fe00eb2674 100644
--- a/test/js-native-api/8_passing_wrapped/test.js
+++ b/test/js-native-api/8_passing_wrapped/test.js
@@ -3,7 +3,7 @@
 
 const common = require('../../common');
 const assert = require('assert');
-const addon = require(`./build/${common.buildType}/binding`);
+const addon = require(`./build/${common.buildType}/8_passing_wrapped`);
 
 async function runTest() {
   let obj1 = addon.createObject(10);
diff --git a/test/js-native-api/test_array/test.js b/test/js-native-api/test_array/test.js
index 4ec05596cf63bc276655ed797271893963b53181..c2a6b11a6074d5f187f71227f220bfc193c339e4 100644
--- a/test/js-native-api/test_array/test.js
+++ b/test/js-native-api/test_array/test.js
@@ -15,8 +15,8 @@ const array = [
   [
     'world',
     'node',
-    'abi'
-  ]
+    'abi',
+  ],
 ];
 
 assert.throws(
diff --git a/test/js-native-api/test_bigint/test.js b/test/js-native-api/test_bigint/test.js
index bf9ce5066d6d2a30cadb6a6b509fe313675c16c0..509c263c733a53a0b02dd0c6d3d18ca3fedc550b 100644
--- a/test/js-native-api/test_bigint/test.js
+++ b/test/js-native-api/test_bigint/test.js
@@ -40,13 +40,13 @@ const {
   assert.strictEqual(num, TestWords(num));
 });
 
-assert.throws(CreateTooBigBigInt, {
+assert.throws(() => CreateTooBigBigInt(), {
   name: 'Error',
   message: 'Invalid argument',
 });
 
 // Test that we correctly forward exceptions from the engine.
-assert.throws(MakeBigIntWordsThrow, {
+assert.throws(() => MakeBigIntWordsThrow(), {
   name: 'RangeError',
   message: 'Maximum BigInt size exceeded'
 });
diff --git a/test/js-native-api/test_exception/test.js b/test/js-native-api/test_exception/test.js
index ff11b702198b888a650162c3f7ef492cfedc4438..38e8fd1d6b6bdc37528565e665f379f4b54dd888 100644
--- a/test/js-native-api/test_exception/test.js
+++ b/test/js-native-api/test_exception/test.js
@@ -48,6 +48,34 @@ const test_exception = (function() {
                      ` thrown, but ${returnedError} was passed`);
 }
 
+
+{
+  const throwTheError = class { constructor() { throw theError; } };
+
+  // Test that the native side successfully captures the exception
+  let returnedError = test_exception.constructReturnException(throwTheError);
+  assert.strictEqual(returnedError, theError);
+
+  // Test that the native side passes the exception through
+  assert.throws(
+    () => { test_exception.constructAllowException(throwTheError); },
+    (err) => err === theError
+  );
+
+  // Test that the exception thrown above was marked as pending
+  // before it was handled on the JS side
+  const exception_pending = test_exception.wasPending();
+  assert.strictEqual(exception_pending, true,
+                     'Exception not pending as expected,' +
+                     ` .wasPending() returned ${exception_pending}`);
+
+  // Test that the native side does not capture a non-existing exception
+  returnedError = test_exception.constructReturnException(common.mustCall());
+  assert.strictEqual(returnedError, undefined,
+                     'Returned error should be undefined when no exception is' +
+                     ` thrown, but ${returnedError} was passed`);
+}
+
 {
   // Test that no exception appears that was not thrown by us
   let caughtError;
@@ -66,3 +94,22 @@ const test_exception = (function() {
                      'Exception state did not remain clear as expected,' +
                      ` .wasPending() returned ${exception_pending}`);
 }
+
+{
+  // Test that no exception appears that was not thrown by us
+  let caughtError;
+  try {
+    test_exception.constructAllowException(common.mustCall());
+  } catch (anError) {
+    caughtError = anError;
+  }
+  assert.strictEqual(caughtError, undefined,
+                     'No exception originated on the native side, but' +
+                     ` ${caughtError} was passed`);
+
+  // Test that the exception state remains clear when no exception is thrown
+  const exception_pending = test_exception.wasPending();
+  assert.strictEqual(exception_pending, false,
+                     'Exception state did not remain clear as expected,' +
+                     ` .wasPending() returned ${exception_pending}`);
+}
diff --git a/test/js-native-api/test_exception/testFinalizerException.js b/test/js-native-api/test_exception/testFinalizerException.js
index 1ba74ba4802a0f8ad157c919eaf00779cb3489bf..16f8bd5fe762285030ea99c65be08dce98a8139d 100644
--- a/test/js-native-api/test_exception/testFinalizerException.js
+++ b/test/js-native-api/test_exception/testFinalizerException.js
@@ -26,7 +26,7 @@ if (process.argv[2] === 'child') {
 const assert = require('assert');
 const { spawnSync } = require('child_process');
 const child = spawnSync(process.execPath, [
-  '--expose-gc', __filename, 'child'
+  '--expose-gc', __filename, 'child',
 ]);
 assert.strictEqual(child.signal, null);
-assert.match(child.stderr.toString(), /Error during Finalize/m);
+assert.match(child.stderr.toString(), /Error during Finalize/);
diff --git a/test/js-native-api/test_exception/test_exception.c b/test/js-native-api/test_exception/test_exception.c
index 01adf42c942b8f0ec0ebae3078e0028a29b08696..9cd8ed36cd4bd5fd432267aea111950a3d294b58 100644
--- a/test/js-native-api/test_exception/test_exception.c
+++ b/test/js-native-api/test_exception/test_exception.c
@@ -22,6 +22,22 @@ static napi_value returnException(napi_env env, napi_callback_info info) {
   return NULL;
 }
 
+static napi_value constructReturnException(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  napi_value result;
+  napi_status status = napi_new_instance(env, args[0], 0, 0, &result);
+  if (status == napi_pending_exception) {
+    napi_value ex;
+    NAPI_CALL(env, napi_get_and_clear_last_exception(env, &ex));
+    return ex;
+  }
+
+  return NULL;
+}
+
 static napi_value allowException(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
@@ -38,6 +54,19 @@ static napi_value allowException(napi_env env, napi_callback_info info) {
   return NULL;
 }
 
+static napi_value constructAllowException(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  napi_value result;
+  napi_new_instance(env, args[0], 0, 0, &result);
+  // Ignore status and check napi_is_exception_pending() instead.
+
+  NAPI_CALL(env, napi_is_exception_pending(env, &exceptionWasPending));
+  return NULL;
+}
+
 static napi_value wasPending(napi_env env, napi_callback_info info) {
   napi_value result;
   NAPI_CALL(env, napi_get_boolean(env, exceptionWasPending, &result));
@@ -64,6 +93,8 @@ napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("returnException", returnException),
     DECLARE_NAPI_PROPERTY("allowException", allowException),
+    DECLARE_NAPI_PROPERTY("constructReturnException", constructReturnException),
+    DECLARE_NAPI_PROPERTY("constructAllowException", constructAllowException),
     DECLARE_NAPI_PROPERTY("wasPending", wasPending),
     DECLARE_NAPI_PROPERTY("createExternal", createExternal),
   };
diff --git a/test/js-native-api/test_function/test.js b/test/js-native-api/test_function/test.js
index 988f128404e429525417763c62439f15a296d003..972adcd79f54b259d42406e42e7e91ebff384e26 100644
--- a/test/js-native-api/test_function/test.js
+++ b/test/js-native-api/test_function/test.js
@@ -42,3 +42,11 @@ assert.deepStrictEqual(test_function.TestCreateFunctionParameters(), {
   cbIsNull: 'Invalid argument',
   resultIsNull: 'Invalid argument'
 });
+
+assert.throws(
+  () => test_function.TestBadReturnExceptionPending(),
+  {
+    code: 'throwing exception',
+    name: 'Error'
+  }
+);
diff --git a/test/js-native-api/test_function/test_function.c b/test/js-native-api/test_function/test_function.c
index 713e935e08c972948aecb0521d54c258fc55d6da..922d298136aa43bd98ae1c1bbb2944692aec188b 100644
--- a/test/js-native-api/test_function/test_function.c
+++ b/test/js-native-api/test_function/test_function.c
@@ -153,6 +153,19 @@ static napi_value MakeTrackedFunction(napi_env env, napi_callback_info info) {
   return result;
 }
 
+static napi_value TestBadReturnExceptionPending(napi_env env, napi_callback_info info) {
+  napi_throw_error(env, "throwing exception", "throwing exception");
+
+  // addons should only ever return a valid napi_value even if an
+  // exception occurs, but we have seen that the C++ wrapper
+  // with exceptions enabled sometimes returns an invalid value
+  // when an exception is thrown. Test that we ignore the return
+  // value then an exeption is pending. We use 0xFFFFFFFF as a value
+  // that should never be a valid napi_value and node seems to
+  // crash if it is not ignored indicating that it is indeed invalid.
+  return (napi_value)(0xFFFFFFFFF);
+}
+
 EXTERN_C_START
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn1;
@@ -183,6 +196,12 @@ napi_value Init(napi_env env, napi_value exports) {
                                       NULL,
                                       &fn5));
 
+  napi_value fn6;
+  NAPI_CALL(env,
+      napi_create_function(
+          env, "TestBadReturnExceptionPending", NAPI_AUTO_LENGTH,
+          TestBadReturnExceptionPending, NULL, &fn6));
+
   NAPI_CALL(env, napi_set_named_property(env, exports, "TestCall", fn1));
   NAPI_CALL(env, napi_set_named_property(env, exports, "TestName", fn2));
   NAPI_CALL(env, napi_set_named_property(env, exports, "TestNameShort", fn3));
@@ -196,6 +215,10 @@ napi_value Init(napi_env env, napi_value exports) {
                                          "TestCreateFunctionParameters",
                                          fn5));
 
+  NAPI_CALL(env,
+      napi_set_named_property(
+          env, exports, "TestBadReturnExceptionPending", fn6));
+
   return exports;
 }
 EXTERN_C_END
diff --git a/test/js-native-api/test_general/test.js b/test/js-native-api/test_general/test.js
index 76527bc81c7cd858daa240bb697c2f9091db141e..ec5c4fe0ddc86f42682d8cab8378d67ea23fe618 100644
--- a/test/js-native-api/test_general/test.js
+++ b/test/js-native-api/test_general/test.js
@@ -42,7 +42,7 @@ assert.strictEqual(test_general.testGetVersion(), 8);
   new Object(),
   true,
   undefined,
-  Symbol()
+  Symbol(),
 ].forEach((val) => {
   assert.strictEqual(test_general.testNapiTypeof(val), typeof val);
 });
diff --git a/test/js-native-api/test_general/testEnvCleanup.js b/test/js-native-api/test_general/testEnvCleanup.js
index 8d567bef4518ce00372e01c73a19177246b6672a..99b47a3e62560f42ab86b514a2481b54aaced835 100644
--- a/test/js-native-api/test_general/testEnvCleanup.js
+++ b/test/js-native-api/test_general/testEnvCleanup.js
@@ -30,7 +30,7 @@ if (process.argv[2] === 'child') {
   // Make sure that only the latest attached version of a re-wrapped item's
   // finalizer gets called at env cleanup.
   module.exports['first wrap'] =
-    test_general.envCleanupWrap({}, finalizerMessages['first wrap']),
+    test_general.envCleanupWrap({}, finalizerMessages['first wrap']);
   test_general.removeWrap(module.exports['first wrap']);
   test_general.envCleanupWrap(module.exports['first wrap'],
                               finalizerMessages['second wrap']);
diff --git a/test/js-native-api/test_instance_data/test.js b/test/js-native-api/test_instance_data/test.js
index 986f644fd226b915b0def49578f5ed1ec758f79e..23efb32678eb8756cb14581315b3b13214694052 100644
--- a/test/js-native-api/test_instance_data/test.js
+++ b/test/js-native-api/test_instance_data/test.js
@@ -4,7 +4,7 @@
 const common = require('../../common');
 const assert = require('assert');
 
-if (module.parent) {
+if (module !== require.main) {
   // When required as a module, run the tests.
   const test_instance_data =
     require(`./build/${common.buildType}/test_instance_data`);
diff --git a/test/js-native-api/test_new_target/binding.gyp b/test/js-native-api/test_new_target/binding.gyp
index dc050e6839b46503c97fb3f8aad0dfc5cdca7610..f9cc6e83758ced508f1f3450c300cd7f4f8ca464 100644
--- a/test/js-native-api/test_new_target/binding.gyp
+++ b/test/js-native-api/test_new_target/binding.gyp
@@ -1,11 +1,11 @@
 {
   'targets': [
     {
-      'target_name': 'binding',
+      'target_name': 'test_new_target',
       'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
       'sources': [
         '../entry_point.c',
-        'binding.c'
+        'test_new_target.c'
       ]
     }
   ]
diff --git a/test/js-native-api/test_new_target/test.js b/test/js-native-api/test_new_target/test.js
index 702e8ca8b4387db3ef9741c57ea9d0c02deef699..02d610e1e0973461362b8073345a2a44377581dd 100644
--- a/test/js-native-api/test_new_target/test.js
+++ b/test/js-native-api/test_new_target/test.js
@@ -2,7 +2,7 @@
 
 const common = require('../../common');
 const assert = require('assert');
-const binding = require(`./build/${common.buildType}/binding`);
+const binding = require(`./build/${common.buildType}/test_new_target`);
 
 class Class extends binding.BaseClass {
   constructor() {
diff --git a/test/js-native-api/test_new_target/binding.c b/test/js-native-api/test_new_target/test_new_target.c
similarity index 100%
rename from test/js-native-api/test_new_target/binding.c
rename to test/js-native-api/test_new_target/test_new_target.c
diff --git a/test/js-native-api/test_object/test.js b/test/js-native-api/test_object/test.js
index e5923ecd16c2cf2ff7148701d77fd52e4f0da16c..807c920bd46b54620d7404733afc7ecce999d1de 100644
--- a/test/js-native-api/test_object/test.js
+++ b/test/js-native-api/test_object/test.js
@@ -9,7 +9,7 @@ const test_object = require(`./build/${common.buildType}/test_object`);
 const object = {
   hello: 'world',
   array: [
-    1, 94, 'str', 12.321, { test: 'obj in arr' }
+    1, 94, 'str', 12.321, { test: 'obj in arr' },
   ],
   newObject: {
     test: 'obj in obj'
diff --git a/test/js-native-api/test_reference_double_free/binding.gyp b/test/js-native-api/test_reference_double_free/binding.gyp
new file mode 100644
index 0000000000000000000000000000000000000000..864846765d01325a1aefd3815b172cf3fb868bdb
--- /dev/null
+++ b/test/js-native-api/test_reference_double_free/binding.gyp
@@ -0,0 +1,11 @@
+{
+  "targets": [
+    {
+      "target_name": "test_reference_double_free",
+      "sources": [
+        "../entry_point.c",
+        "test_reference_double_free.c"
+      ]
+    }
+  ]
+}
diff --git a/test/js-native-api/test_reference_double_free/test.js b/test/js-native-api/test_reference_double_free/test.js
new file mode 100644
index 0000000000000000000000000000000000000000..242d850ba9f677b5147f6f2e2df74b46a607b91e
--- /dev/null
+++ b/test/js-native-api/test_reference_double_free/test.js
@@ -0,0 +1,11 @@
+'use strict';
+
+// This test makes no assertions. It tests a fix without which it will crash
+// with a double free.
+
+const { buildType } = require('../../common');
+
+const addon = require(`./build/${buildType}/test_reference_double_free`);
+
+{ new addon.MyObject(true); }
+{ new addon.MyObject(false); }
diff --git a/test/js-native-api/test_reference_double_free/test_reference_double_free.c b/test/js-native-api/test_reference_double_free/test_reference_double_free.c
new file mode 100644
index 0000000000000000000000000000000000000000..f38867d220ae688056e2840e84a641a08b9aab4b
--- /dev/null
+++ b/test/js-native-api/test_reference_double_free/test_reference_double_free.c
@@ -0,0 +1,55 @@
+#include <stdlib.h>
+#include <js_native_api.h>
+#include "../common.h"
+
+static size_t g_call_count = 0;
+
+static void Destructor(napi_env env, void* data, void* nothing) {
+  napi_ref* ref = data;
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, *ref));
+  free(ref);
+}
+
+static void NoDeleteDestructor(napi_env env, void* data, void* hint) {
+  napi_ref* ref = data;
+  size_t* call_count = hint;
+
+  // This destructor must be called exactly once.
+  if ((*call_count) > 0) abort();
+  *call_count = ((*call_count) + 1);
+  free(ref);
+}
+
+static napi_value New(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value js_this, js_delete;
+  bool delete;
+  napi_ref* ref = malloc(sizeof(*ref));
+
+  NAPI_CALL(env,
+      napi_get_cb_info(env, info, &argc, &js_delete, &js_this, NULL));
+  NAPI_CALL(env, napi_get_value_bool(env, js_delete, &delete));
+
+  if (delete) {
+    NAPI_CALL(env,
+        napi_wrap(env, js_this, ref, Destructor, NULL, ref));
+  } else {
+    NAPI_CALL(env,
+        napi_wrap(env, js_this, ref, NoDeleteDestructor, &g_call_count, ref));
+  }
+  NAPI_CALL(env, napi_reference_ref(env, *ref, NULL));
+
+  return js_this;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  napi_value myobj_ctor;
+  NAPI_CALL(env,
+      napi_define_class(
+          env, "MyObject", NAPI_AUTO_LENGTH, New, NULL, 0, NULL, &myobj_ctor));
+  NAPI_CALL(env,
+      napi_set_named_property(env, exports, "MyObject", myobj_ctor));
+  return exports;
+}
+EXTERN_C_END
diff --git a/test/js-native-api/test_typedarray/test.js b/test/js-native-api/test_typedarray/test.js
index 0d9594d92933c718a82de26fc7d3e3230f0dc938..3065ed30dd9984981a08ebe2dc0769745ffab88f 100644
--- a/test/js-native-api/test_typedarray/test.js
+++ b/test/js-native-api/test_typedarray/test.js
@@ -78,9 +78,11 @@ nonByteArrayTypes.forEach((currentType) => {
 // Test detaching
 arrayTypes.forEach((currentType) => {
   const buffer = Reflect.construct(currentType, [8]);
-  assert.throws(
-    () => test_typedarray.Detach(buffer),
-    /A detachable arraybuffer was expected/);
+  assert.strictEqual(buffer.length, 8);
+  assert.ok(!test_typedarray.IsDetached(buffer.buffer));
+  test_typedarray.Detach(buffer);
+  assert.ok(test_typedarray.IsDetached(buffer.buffer));
+  assert.strictEqual(buffer.length, 0);
 });
 {
   const buffer = test_typedarray.External();
diff --git a/test/js-native-api/test_typedarray/test_typedarray.c b/test/js-native-api/test_typedarray/test_typedarray.c
index 711e3daf7ffbb2b969b60c0d1c2db0375cc8eb4a..1714b5fe717f8798a6ea833baaaf07d5d157982a 100644
--- a/test/js-native-api/test_typedarray/test_typedarray.c
+++ b/test/js-native-api/test_typedarray/test_typedarray.c
@@ -1,5 +1,6 @@
 #include <js_native_api.h>
 #include <string.h>
+#include <stdlib.h>
 #include "../common.h"
 
 static napi_value Multiply(napi_env env, napi_callback_info info) {
@@ -73,22 +74,33 @@ static napi_value Multiply(napi_env env, napi_callback_info info) {
   return output_array;
 }
 
+static void FinalizeCallback(napi_env env,
+                             void* finalize_data,
+                             void* finalize_hint)
+{
+  free(finalize_data);
+}
+
 static napi_value External(napi_env env, napi_callback_info info) {
-  static int8_t externalData[] = {0, 1, 2};
+  const uint8_t nElem = 3;
+  int8_t* externalData = malloc(nElem*sizeof(int8_t));
+  externalData[0] = 0;
+  externalData[1] = 1;
+  externalData[2] = 2;
 
   napi_value output_buffer;
   NAPI_CALL(env, napi_create_external_arraybuffer(
       env,
       externalData,
-      sizeof(externalData),
-      NULL,  // finalize_callback
+      nElem*sizeof(int8_t),
+      FinalizeCallback,
       NULL,  // finalize_hint
       &output_buffer));
 
   napi_value output_array;
   NAPI_CALL(env, napi_create_typedarray(env,
       napi_int8_array,
-      sizeof(externalData) / sizeof(int8_t),
+      nElem,
       output_buffer,
       0,
       &output_array));
diff --git a/test/known_issues/known_issues.status b/test/known_issues/known_issues.status
index 9ca45bbd85420ac57c88de5a8c535330811414f6..690e6e9840b77c2740cdbe388cd9b3fa09a92c90 100644
--- a/test/known_issues/known_issues.status
+++ b/test/known_issues/known_issues.status
@@ -1,3 +1,4 @@
+
 prefix known_issues
 
 # If a known issue does not apply to a platform, list the test name in the
@@ -14,19 +15,32 @@ test-vm-timeout-escape-queuemicrotask: SKIP
 [$system==win32]
 
 [$system==linux]
-# https://github.com/nodejs/node/pull/23743
-# https://github.com/nodejs/node/issues/3020
-test-vm-timeout-escape-promise: PASS,FLAKY
+# Windows-specific test
+test-path-posix-relative-on-windows: SKIP
 
 [$system==macos]
+# Windows-specific test
+test-path-posix-relative-on-windows: SKIP
 
 [$system==solaris]
+# Windows-specific test
+test-path-posix-relative-on-windows: SKIP
 
 [$system==freebsd]
+# Windows-specific test
+test-path-posix-relative-on-windows: SKIP
 
 [$system==aix]
+# Windows-specific test
+test-path-posix-relative-on-windows: SKIP
 
 [$arch==arm]
 # The Raspberry Pis are too slow to run this test.
 # See https://github.com/nodejs/build/issues/2227#issuecomment-608334574
 test-crypto-authenticated-stream: SKIP
+# Windows-specific test
+test-path-posix-relative-on-windows: SKIP
+
+[$system==ibmi]
+# Windows-specific test
+test-path-posix-relative-on-windows: SKIP
diff --git a/test/known_issues/test-path-posix-relative-on-windows.js b/test/known_issues/test-path-posix-relative-on-windows.js
new file mode 100644
index 0000000000000000000000000000000000000000..bcaaca8b18a1ef653023a25430d266513a6fa0db
--- /dev/null
+++ b/test/known_issues/test-path-posix-relative-on-windows.js
@@ -0,0 +1,10 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const path = require('path');
+
+// Refs: https://github.com/nodejs/node/issues/13683
+
+const relativePath = path.posix.relative('a/b/c', '../../x');
+assert.match(relativePath, /^(\.\.\/){3,5}x$/);
diff --git a/test/known_issues/test-vm-timeout-escape-queuemicrotask.js b/test/known_issues/test-vm-timeout-escape-queuemicrotask.js
index 0d3a0b0c5c5814b8683142fd523e32d9b368a4aa..c8333bd044702b4b8c3c3cfee2b097f2c56b6450 100644
--- a/test/known_issues/test-vm-timeout-escape-queuemicrotask.js
+++ b/test/known_issues/test-vm-timeout-escape-queuemicrotask.js
@@ -35,7 +35,7 @@ assert.throws(() => {
       queueMicrotask,
       loop
     },
-    { timeout }
+    { timeout, microtaskMode: 'afterScriptRun' }
   );
 }, {
   code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
diff --git a/test/message/2100bytes.js b/test/message/2100bytes.js
index ff1b51f4653394b9e9921b83a24e27ba2ebde949..abd8c4b55246aec3348267841462233c7c7b8f10 100644
--- a/test/message/2100bytes.js
+++ b/test/message/2100bytes.js
@@ -64,5 +64,5 @@ console.log([
   '_____________________________________________1950',
   '_____________________________________________2000',
   '_____________________________________________2050',
-  '_____________________________________________2100'
+  '_____________________________________________2100',
 ].join('\n'));
diff --git a/test/message/async_error_eval_cjs.js b/test/message/async_error_eval_cjs.js
index a2caaa0937745e9ef7f664b48d23d078cb45dc12..820507beda993760811c593d2656ccca06af0a43 100644
--- a/test/message/async_error_eval_cjs.js
+++ b/test/message/async_error_eval_cjs.js
@@ -27,7 +27,7 @@ main();
 {
   const child = spawnSync(process.execPath, [
     '-e',
-    main
+    main,
   ], {
     env: { ...process.env }
   });
diff --git a/test/message/async_error_eval_esm.js b/test/message/async_error_eval_esm.js
index 0c9b7378d54729eae4920090a645d991a52aa39b..dfab2b8a8264e95a0efcc5379c37e64e4b6c3598 100644
--- a/test/message/async_error_eval_esm.js
+++ b/test/message/async_error_eval_esm.js
@@ -29,7 +29,7 @@ main();
     '--input-type',
     'module',
     '-e',
-    main
+    main,
   ], {
     env: { ...process.env }
   });
diff --git a/test/message/esm_display_syntax_error.mjs b/test/message/esm_display_syntax_error.mjs
index bda4a7e6ebe3a3a2f3c9ba0d57665ccd8da2b1a9..0b9a30c2d054f79bcf405e86ecac3a60649929f1 100644
--- a/test/message/esm_display_syntax_error.mjs
+++ b/test/message/esm_display_syntax_error.mjs
@@ -1,2 +1,4 @@
+// Flags: --no-harmony-top-level-await
+
 'use strict';
 await async () => 0;
diff --git a/test/message/esm_display_syntax_error.out b/test/message/esm_display_syntax_error.out
index b7d2008540adf3b502c124df2ee9bc5b46df74aa..775448d4b68afd2016e6cd28cc79926f1777e74b 100644
--- a/test/message/esm_display_syntax_error.out
+++ b/test/message/esm_display_syntax_error.out
@@ -1,4 +1,4 @@
-file:///*/test/message/esm_display_syntax_error.mjs:2
+file:///*/test/message/esm_display_syntax_error.mjs:4
 await async () => 0;
 ^^^^^
 
diff --git a/test/message/esm_display_syntax_error_module.out b/test/message/esm_display_syntax_error_module.out
index 708257fcaf5792ff37a49445e5d1d8aa1e9cadd1..c45a5008e691cad3710b58263b5b322fefae35ef 100644
--- a/test/message/esm_display_syntax_error_module.out
+++ b/test/message/esm_display_syntax_error_module.out
@@ -1,6 +1,6 @@
 file:///*/test/fixtures/es-module-loaders/syntax-error.mjs:2
 await async () => 0;
-^^^^^
+^^^^^^^^^^^^^
 
-SyntaxError: Unexpected reserved word
+SyntaxError: Malformed arrow function parameter list
     at Loader.moduleStrategy (internal/modules/esm/translators.js:*:*)
\ No newline at end of file
diff --git a/test/message/esm_loader_not_found.out b/test/message/esm_loader_not_found.out
index 97400699e644b7b129fca5f87d5427e8fa77be2d..61291a9bbc5ec13bf1f0cd4586df3b2bc34315db 100644
--- a/test/message/esm_loader_not_found.out
+++ b/test/message/esm_loader_not_found.out
@@ -1,8 +1,10 @@
 (node:*) ExperimentalWarning: --experimental-loader is an experimental feature. This feature could change at any time
+(Use `* --trace-warnings ...` to show where the warning was created)
 internal/process/esm_loader.js:*
     internalBinding('errors').triggerUncaughtException(
                               ^
 Error [ERR_MODULE_NOT_FOUND]: Cannot find package 'i-dont-exist' imported from *
+    at new NodeError (internal/errors.js:*:*)
     at packageResolve (internal/modules/esm/resolve.js:*:*)
     at moduleResolve (internal/modules/esm/resolve.js:*:*)
     at Loader.defaultResolve [as _resolve] (internal/modules/esm/resolve.js:*:*)
@@ -11,7 +13,6 @@ Error [ERR_MODULE_NOT_FOUND]: Cannot find package 'i-dont-exist' imported from *
     at Loader.import (internal/modules/esm/loader.js:*:*)
     at internal/process/esm_loader.js:*:*
     at initializeLoader (internal/process/esm_loader.js:*:*)
-    at Object.loadESM (internal/process/esm_loader.js:*:*)
-    at runMainESM (internal/modules/run_main.js:*:*) {
+    at Object.loadESM (internal/process/esm_loader.js:*:*) {
   code: 'ERR_MODULE_NOT_FOUND'
 }
diff --git a/test/message/esm_loader_not_found_cjs_hint_bare.js b/test/message/esm_loader_not_found_cjs_hint_bare.js
index b049fd203fef060a41ea902bea81108aa76f4fc3..437fa2d3d430a17410a8f4f78c0a95e9c6bd93c1 100644
--- a/test/message/esm_loader_not_found_cjs_hint_bare.js
+++ b/test/message/esm_loader_not_found_cjs_hint_bare.js
@@ -8,7 +8,7 @@ const { fixturesDir } = require('../common/fixtures');
 spawn(
   process.execPath,
   [
-    join(fixturesDir, 'esm_loader_not_found_cjs_hint_bare.mjs')
+    join(fixturesDir, 'esm_loader_not_found_cjs_hint_bare.mjs'),
   ],
   {
     cwd: fixturesDir,
diff --git a/test/message/esm_loader_not_found_cjs_hint_bare.out b/test/message/esm_loader_not_found_cjs_hint_bare.out
index c3f758577eb4d610ad69c49fe5305fea42c5cd03..c61640063000944662387cbbbbcdd6442d7f5e0c 100644
--- a/test/message/esm_loader_not_found_cjs_hint_bare.out
+++ b/test/message/esm_loader_not_found_cjs_hint_bare.out
@@ -4,6 +4,7 @@ internal/process/esm_loader.js:*
 
 Error [ERR_MODULE_NOT_FOUND]: Cannot find module '*test*fixtures*node_modules*some_module*obj' imported from *test*fixtures*esm_loader_not_found_cjs_hint_bare.mjs
 Did you mean to import some_module/obj.js?
+    at new NodeError (internal/errors.js:*:*)
     at finalizeResolution (internal/modules/esm/resolve.js:*:*)
     at moduleResolve (internal/modules/esm/resolve.js:*:*)
     at Loader.defaultResolve [as _resolve] (internal/modules/esm/resolve.js:*:*)
diff --git a/test/message/esm_loader_not_found_cjs_hint_relative.out b/test/message/esm_loader_not_found_cjs_hint_relative.out
index eeb4480ee19144ee7a29a4f2492f658a83a7e206..edfe27a1f3b461fc7a3e7f331d31fb6b2c3ce703 100644
--- a/test/message/esm_loader_not_found_cjs_hint_relative.out
+++ b/test/message/esm_loader_not_found_cjs_hint_relative.out
@@ -1,10 +1,12 @@
 (node:*) ExperimentalWarning: --experimental-loader is an experimental feature. This feature could change at any time
+(Use `* --trace-warnings ...` to show where the warning was created)
 internal/process/esm_loader.js:*
     internalBinding('errors').triggerUncaughtException(
                               ^
 
 Error [ERR_MODULE_NOT_FOUND]: Cannot find module '*test*common*fixtures' imported from *
 Did you mean to import ./test/common/fixtures.js?
+    at new NodeError (internal/errors.js:*:*)
     at finalizeResolution (internal/modules/esm/resolve.js:*:*)
     at moduleResolve (internal/modules/esm/resolve.js:*:*)
     at Loader.defaultResolve [as _resolve] (internal/modules/esm/resolve.js:*:*)
@@ -13,7 +15,6 @@ Did you mean to import ./test/common/fixtures.js?
     at Loader.import (internal/modules/esm/loader.js:*:*)
     at internal/process/esm_loader.js:*:*
     at initializeLoader (internal/process/esm_loader.js:*:*)
-    at Object.loadESM (internal/process/esm_loader.js:*:*)
-    at runMainESM (internal/modules/run_main.js:*:*) {
+    at Object.loadESM (internal/process/esm_loader.js:*:*) {
   code: 'ERR_MODULE_NOT_FOUND'
 }
diff --git a/test/message/esm_loader_syntax_error.out b/test/message/esm_loader_syntax_error.out
index 7dd1c01fbcc1bf95268d49ab3f1e436d81c9d5b4..d6c6df0a338c848127ba0cfa11a98d13b0326848 100644
--- a/test/message/esm_loader_syntax_error.out
+++ b/test/message/esm_loader_syntax_error.out
@@ -1,8 +1,9 @@
 (node:*) ExperimentalWarning: --experimental-loader is an experimental feature. This feature could change at any time
+(Use `* --trace-warnings ...` to show where the warning was created)
 file://*/test/fixtures/es-module-loaders/syntax-error.mjs:2
 await async () => 0;
-^^^^^
+^^^^^^^^^^^^^
 
-SyntaxError: Unexpected reserved word
+SyntaxError: Malformed arrow function parameter list
     at Loader.moduleStrategy (internal/modules/esm/translators.js:*:*)
     at async link (internal/modules/esm/module_job.js:*:*)
diff --git a/test/message/eval_messages.out b/test/message/eval_messages.out
index 64743d4ae67acf1f8cb28b832b1f7204ace48952..4ba0d35974fc2100812ba60b15f2cd3c8c48c865 100644
--- a/test/message/eval_messages.out
+++ b/test/message/eval_messages.out
@@ -6,8 +6,8 @@ SyntaxError: Strict mode code may not include a with statement
     at new Script (vm.js:*:*)
     at createScript (vm.js:*:*)
     at Object.runInThisContext (vm.js:*:*)
-    at Object.<anonymous> ([eval]-wrapper:*:*)
-    at Module._compile (internal/modules/cjs/loader.js:*:*)
+    at internal/process/execution.js:*:*
+    at [eval]-wrapper:*:*
     at evalScript (internal/process/execution.js:*:*)
     at internal/main/eval_string.js:*:*
 42
@@ -20,8 +20,8 @@ Error: hello
     at [eval]:1:7
     at Script.runInThisContext (vm.js:*:*)
     at Object.runInThisContext (vm.js:*:*)
-    at Object.<anonymous> ([eval]-wrapper:*:*)
-    at Module._compile (internal/modules/cjs/loader.js:*:*)
+    at internal/process/execution.js:*:*
+    at [eval]-wrapper:*:*
     at evalScript (internal/process/execution.js:*:*)
     at internal/main/eval_string.js:*:*
 
@@ -33,8 +33,8 @@ Error: hello
     at [eval]:1:7
     at Script.runInThisContext (vm.js:*:*)
     at Object.runInThisContext (vm.js:*:*)
-    at Object.<anonymous> ([eval]-wrapper:*:*)
-    at Module._compile (internal/modules/cjs/loader.js:*:*)
+    at internal/process/execution.js:*:*
+    at [eval]-wrapper:*:*
     at evalScript (internal/process/execution.js:*:*)
     at internal/main/eval_string.js:*:*
 100
@@ -46,8 +46,8 @@ ReferenceError: y is not defined
     at [eval]:1:16
     at Script.runInThisContext (vm.js:*:*)
     at Object.runInThisContext (vm.js:*:*)
-    at Object.<anonymous> ([eval]-wrapper:*:*)
-    at Module._compile (internal/modules/cjs/loader.js:*:*)
+    at internal/process/execution.js:*:*
+    at [eval]-wrapper:*:*
     at evalScript (internal/process/execution.js:*:*)
     at internal/main/eval_string.js:*:*
 
diff --git a/test/message/internal_assert.out b/test/message/internal_assert.out
index cf09fdcb605269322594a43be1ad7b5421a6c7e3..9ca8350756c9ad0daaaa1e35339bc81a2016443d 100644
--- a/test/message/internal_assert.out
+++ b/test/message/internal_assert.out
@@ -5,6 +5,7 @@ internal/assert.js:*
 Error [ERR_INTERNAL_ASSERTION]: This is caused by either a bug in Node.js or incorrect usage of Node.js internals.
 Please open an issue with this stack trace at https://github.com/nodejs/node/issues
 
+    at new NodeError (internal/errors.js:*:*)
     at assert (internal/assert.js:*:*)
     at * (*test*message*internal_assert.js:7:1)
     at *
diff --git a/test/message/internal_assert_fail.out b/test/message/internal_assert_fail.out
index 11b532b7b2af3c4ef5b51bde32c1eef08ad780e8..11e253703170d2d60fcaafa362da085870f6418e 100644
--- a/test/message/internal_assert_fail.out
+++ b/test/message/internal_assert_fail.out
@@ -6,6 +6,7 @@ Error [ERR_INTERNAL_ASSERTION]: Unreachable!
 This is caused by either a bug in Node.js or incorrect usage of Node.js internals.
 Please open an issue with this stack trace at https://github.com/nodejs/node/issues
 
+    at new NodeError (internal/errors.js:*:*)
     at Function.fail (internal/assert.js:*:*)
     at * (*test*message*internal_assert_fail.js:7:8)
     at *
diff --git a/test/message/nexttick_throw.js b/test/message/nexttick_throw.js
index a3369e0d102924dd25b5758ac6ed29460ab1bffe..d7e51b411eda64f406521a74c1419d2bbeaa6d7a 100644
--- a/test/message/nexttick_throw.js
+++ b/test/message/nexttick_throw.js
@@ -26,7 +26,7 @@ process.nextTick(function() {
   process.nextTick(function() {
     process.nextTick(function() {
       process.nextTick(function() {
-        // eslint-disable-next-line no-undef
+        // eslint-disable-next-line no-undef,no-unused-expressions
         undefined_reference_error_maker;
       });
     });
diff --git a/test/message/promise_unhandled_warn_with_error.js b/test/message/promise_unhandled_warn_with_error.js
new file mode 100644
index 0000000000000000000000000000000000000000..0f22e8deeba65390bb1e3b861d163d9047e9f9f8
--- /dev/null
+++ b/test/message/promise_unhandled_warn_with_error.js
@@ -0,0 +1,10 @@
+// Flags: --unhandled-rejections=warn-with-error-code
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+common.disableCrashOnUnhandledRejection();
+
+Promise.reject(new Error('alas'));
+process.on('exit', assert.strictEqual.bind(null, 1));
diff --git a/test/message/promise_unhandled_warn_with_error.out b/test/message/promise_unhandled_warn_with_error.out
new file mode 100644
index 0000000000000000000000000000000000000000..66c98c57f71717046d26e6672897030dfd770da6
--- /dev/null
+++ b/test/message/promise_unhandled_warn_with_error.out
@@ -0,0 +1,10 @@
+*UnhandledPromiseRejectionWarning: Error: alas
+    at *promise_unhandled_warn_with_error.js:*:*
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+(Use `* --trace-warnings ...` to show where the warning was created)
+*UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `--unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 1)
\ No newline at end of file
diff --git a/test/message/source_map_disabled_by_api.js b/test/message/source_map_disabled_by_api.js
new file mode 100644
index 0000000000000000000000000000000000000000..8405e4f3661cff0fcc68a102ece609c659825c71
--- /dev/null
+++ b/test/message/source_map_disabled_by_api.js
@@ -0,0 +1,20 @@
+// Flags: --enable-source-maps
+
+'use strict';
+require('../common');
+
+process.setSourceMapsEnabled(false);
+
+try {
+  require('../fixtures/source-map/enclosing-call-site-min.js');
+} catch (e) {
+  console.log(e);
+}
+
+delete require.cache[require
+  .resolve('../fixtures/source-map/enclosing-call-site-min.js')];
+
+// Re-enable.
+process.setSourceMapsEnabled(true);
+
+require('../fixtures/source-map/enclosing-call-site-min.js');
diff --git a/test/message/source_map_disabled_by_api.out b/test/message/source_map_disabled_by_api.out
new file mode 100644
index 0000000000000000000000000000000000000000..46762a0b476f10c31f458e385fa9799624067735
--- /dev/null
+++ b/test/message/source_map_disabled_by_api.out
@@ -0,0 +1,26 @@
+Error: an error!
+    at functionD (*enclosing-call-site-min.js:1:156)
+    at functionC (*enclosing-call-site-min.js:1:97)
+    at functionB (*enclosing-call-site-min.js:1:60)
+    at functionA (*enclosing-call-site-min.js:1:26)
+    at Object.<anonymous> (*enclosing-call-site-min.js:1:199)
+    at Module._compile (internal/modules/cjs/loader.js:*)
+    at Object.Module._extensions..js (internal/modules/cjs/loader.js:*)
+    at Module.load (internal/modules/cjs/loader.js:*)
+    at Function.Module._load (internal/modules/cjs/loader.js:*)
+    at Module.require (internal/modules/cjs/loader.js:*)
+*enclosing-call-site.js:16
+      throw new Error('an error!')
+                ^
+
+Error: an error!
+    at functionD (*enclosing-call-site.js:16:17)
+    at functionC (*enclosing-call-site.js:10:3)
+    at functionB (*enclosing-call-site.js:6:3)
+    at functionA (*enclosing-call-site.js:2:3)
+    at Object.<anonymous> (*enclosing-call-site.js:24:3)
+    at Module._compile (internal/modules/cjs/loader.js:*)
+    at Object.Module._extensions..js (internal/modules/cjs/loader.js:*)
+    at Module.load (internal/modules/cjs/loader.js:*)
+    at Function.Module._load (internal/modules/cjs/loader.js:*)
+    at Module.require (internal/modules/cjs/loader.js:*)
diff --git a/test/message/source_map_enabled_by_api.js b/test/message/source_map_enabled_by_api.js
new file mode 100644
index 0000000000000000000000000000000000000000..3133bd26399fd4e17b4d50cc691b65ccbdaf88eb
--- /dev/null
+++ b/test/message/source_map_enabled_by_api.js
@@ -0,0 +1,17 @@
+'use strict';
+require('../common');
+
+process.setSourceMapsEnabled(true);
+
+try {
+  require('../fixtures/source-map/enclosing-call-site-min.js');
+} catch (e) {
+  console.log(e);
+}
+
+delete require.cache[require
+  .resolve('../fixtures/source-map/enclosing-call-site-min.js')];
+
+process.setSourceMapsEnabled(false);
+
+require('../fixtures/source-map/enclosing-call-site-min.js');
diff --git a/test/message/source_map_enabled_by_api.out b/test/message/source_map_enabled_by_api.out
new file mode 100644
index 0000000000000000000000000000000000000000..3f111ee2f7dee88d7ec334403c724a4531c639b2
--- /dev/null
+++ b/test/message/source_map_enabled_by_api.out
@@ -0,0 +1,30 @@
+*enclosing-call-site.js:16
+      throw new Error('an error!')
+                ^
+
+Error: an error!
+    at functionD (*enclosing-call-site.js:16:17)
+    at functionC (*enclosing-call-site.js:10:3)
+    at functionB (*enclosing-call-site.js:6:3)
+    at functionA (*enclosing-call-site.js:2:3)
+    at Object.<anonymous> (*enclosing-call-site.js:24:3)
+    at Module._compile (internal/modules/cjs/loader.js:*)
+    at Object.Module._extensions..js (internal/modules/cjs/loader.js:*)
+    at Module.load (internal/modules/cjs/loader.js:*)
+    at Function.Module._load (internal/modules/cjs/loader.js:*)
+    at Module.require (internal/modules/cjs/loader.js:*)
+*enclosing-call-site-min.js:1
+var functionA=function(){functionB()};function functionB(){functionC()}var functionC=function(){functionD()},functionD=function(){if(0<Math.random())throw Error("an error!");},thrower=functionA;try{functionA()}catch(a){throw a;};
+                                                                                                                                                                                                                           ^
+
+Error: an error!
+    at functionD (*enclosing-call-site-min.js:1:156)
+    at functionC (*enclosing-call-site-min.js:1:97)
+    at functionB (*enclosing-call-site-min.js:1:60)
+    at functionA (*enclosing-call-site-min.js:1:26)
+    at Object.<anonymous> (*enclosing-call-site-min.js:1:199)
+    at Module._compile (internal/modules/cjs/loader.js:*)
+    at Object.Module._extensions..js (internal/modules/cjs/loader.js:*)
+    at Module.load (internal/modules/cjs/loader.js:*)
+    at Function.Module._load (internal/modules/cjs/loader.js:*)
+    at Module.require (internal/modules/cjs/loader.js:*)
diff --git a/test/message/source_map_enclosing_function.js b/test/message/source_map_enclosing_function.js
new file mode 100644
index 0000000000000000000000000000000000000000..43b6931bf1e19ee2b1c3b5a481c21c0713c80e7c
--- /dev/null
+++ b/test/message/source_map_enclosing_function.js
@@ -0,0 +1,5 @@
+// Flags:  --enable-source-maps
+
+'use strict';
+require('../common');
+require('../fixtures/source-map/enclosing-call-site-min.js');
diff --git a/test/message/source_map_enclosing_function.out b/test/message/source_map_enclosing_function.out
new file mode 100644
index 0000000000000000000000000000000000000000..057c1e762993c9c5bbdc4ee41b8d06ef25edad0f
--- /dev/null
+++ b/test/message/source_map_enclosing_function.out
@@ -0,0 +1,15 @@
+*enclosing-call-site.js:16
+      throw new Error('an error!')
+                ^
+
+Error: an error!
+    at functionD (*enclosing-call-site.js:16:17)
+    at functionC (*enclosing-call-site.js:10:3)
+    at functionB (*enclosing-call-site.js:6:3)
+    at functionA (*enclosing-call-site.js:2:3)
+    at Object.<anonymous> (*enclosing-call-site.js:24:3)
+    at Module._compile (internal/modules/cjs/loader.js:*)
+    at Object.Module._extensions..js (internal/modules/cjs/loader.js:*)
+    at Module.load (internal/modules/cjs/loader.js:*)
+    at Function.Module._load (internal/modules/cjs/loader.js:*)
+    at Module.require (internal/modules/cjs/loader.js:*)
diff --git a/test/message/source_map_reference_error_tabs.js b/test/message/source_map_reference_error_tabs.js
new file mode 100644
index 0000000000000000000000000000000000000000..f6a39d9d497449ea568efbf12395290c5d2502c1
--- /dev/null
+++ b/test/message/source_map_reference_error_tabs.js
@@ -0,0 +1,5 @@
+// Flags:  --enable-source-maps
+
+'use strict';
+require('../common');
+require('../fixtures/source-map/tabs.js');
diff --git a/test/message/source_map_reference_error_tabs.out b/test/message/source_map_reference_error_tabs.out
new file mode 100644
index 0000000000000000000000000000000000000000..275c703c661212da0b712cd40dde2d9690c2bf24
--- /dev/null
+++ b/test/message/source_map_reference_error_tabs.out
@@ -0,0 +1,15 @@
+*tabs.coffee:26
+	alert "I knew it!"
+	^
+
+ReferenceError: alert is not defined
+    at *tabs.coffee:26:2*
+    at *tabs.coffee:1:14*
+    at Module._compile (internal/modules/cjs/loader.js:*
+    at Object.Module._extensions..js (internal/modules/cjs/loader.js:*
+    at Module.load (internal/modules/cjs/loader.js:*
+    at Function.Module._load (internal/modules/cjs/loader.js:*
+    at Module.require (internal/modules/cjs/loader.js:*
+    at require (internal/modules/cjs/helpers.js:*
+    at Object.<anonymous> (*source_map_reference_error_tabs.js:*
+    at Module._compile (internal/modules/cjs/loader.js:*
diff --git a/test/message/source_map_throw_catch.out b/test/message/source_map_throw_catch.out
index 63e3eca3eff0ce8bd710f0ee479b6c281980bedc..b2123e6eebd1b4815ed855d47d80ccaddb3434dd 100644
--- a/test/message/source_map_throw_catch.out
+++ b/test/message/source_map_throw_catch.out
@@ -1,9 +1,10 @@
 reachable
+*typescript-throw.ts:18
+    throw Error('an exception');
+          ^
 Error: an exception
-    at branch (*typescript-throw.js:20:15)
-        -> *typescript-throw.ts:18:11
-    at Object.<anonymous> (*typescript-throw.js:26:1)
-        -> *typescript-throw.ts:24:1
+    at *typescript-throw.ts:18:11*
+    at *typescript-throw.ts:24:1*
     at Module._compile (internal/modules/cjs/loader.js:*)
     at Object.Module._extensions..js (internal/modules/cjs/loader.js:*)
     at Module.load (internal/modules/cjs/loader.js:*)
diff --git a/test/message/source_map_throw_first_tick.out b/test/message/source_map_throw_first_tick.out
index 7f11d9fbd969be85a49bcd0f5e7d5da01dd1ffc2..e4a8e9ff25bb3ec87d8c99504e6939ea0dba37f4 100644
--- a/test/message/source_map_throw_first_tick.out
+++ b/test/message/source_map_throw_first_tick.out
@@ -1,9 +1,10 @@
 reachable
+*typescript-throw.ts:18
+    throw Error('an exception');
+          ^
 Error: an exception
-    at branch (*typescript-throw.js:20:15)
-        -> *typescript-throw.ts:18:11
-    at Object.<anonymous> (*typescript-throw.js:26:1)
-        -> *typescript-throw.ts:24:1
+    at *typescript-throw.ts:18:11*
+    at *typescript-throw.ts:24:1*
     at Module._compile (internal/modules/cjs/loader.js:*)
     at Object.Module._extensions..js (internal/modules/cjs/loader.js:*)
     at Module.load (internal/modules/cjs/loader.js:*)
diff --git a/test/message/source_map_throw_icu.js b/test/message/source_map_throw_icu.js
new file mode 100644
index 0000000000000000000000000000000000000000..00298edc5ed81ae081cc62089e79bd34db99bdbf
--- /dev/null
+++ b/test/message/source_map_throw_icu.js
@@ -0,0 +1,5 @@
+// Flags: --enable-source-maps
+
+'use strict';
+require('../common');
+require('../fixtures/source-map/icu');
diff --git a/test/message/source_map_throw_icu.out b/test/message/source_map_throw_icu.out
new file mode 100644
index 0000000000000000000000000000000000000000..9ceb20125f7d9ae8ee1b5e43507529eda4927b44
--- /dev/null
+++ b/test/message/source_map_throw_icu.out
@@ -0,0 +1,15 @@
+*icu.jsx:3
+    ("********", throw Error("an error"));
+                       ^
+
+Error: an error
+    at *icu.jsx:3:23*
+    at *icu.jsx:9:5*
+    at Module._compile (internal/modules/cjs/loader.js:*
+    at Object.Module._extensions..js (internal/modules/cjs/loader.js:*
+    at Module.load (internal/modules/cjs/loader.js:*
+    at Function.Module._load (internal/modules/cjs/loader.js:*
+    at Module.require (internal/modules/cjs/loader.js:*
+    at require (internal/modules/cjs/helpers.js:*
+    at Object.<anonymous> (*source_map_throw_icu.js:*
+    at Module._compile (internal/modules/cjs/loader.js:*
diff --git a/test/message/source_map_throw_set_immediate.out b/test/message/source_map_throw_set_immediate.out
index 6b169d7e025f7e68d03053b0712677c181cb8e92..08d7f76fcfcc2ae31b1d7eeadf6bd0b09a740797 100644
--- a/test/message/source_map_throw_set_immediate.out
+++ b/test/message/source_map_throw_set_immediate.out
@@ -1,10 +1,8 @@
-*uglify-throw.js:1
-setImmediate(function(){!function(){throw Error("goodbye")}()});
-                                    ^
+*uglify-throw-original.js:5
+  throw Error('goodbye');
+        ^
 
 Error: goodbye
-    at *uglify-throw.js:1:43
-        -> *uglify-throw-original.js:5:9
-    at Immediate.<anonymous> (*uglify-throw.js:1:60)
-        -> *uglify-throw-original.js:9:3
+    at Hello *uglify-throw-original.js:5:9*
+    at *uglify-throw-original.js:9:3*
     at processImmediate (internal/timers.js:*)
diff --git a/test/message/stdin_messages.out b/test/message/stdin_messages.out
index 3c71c5683b7d949bc7b1a46e7cbd4473c40cf871..0994aaef3e2ca2f9174d5f8d262994ae3409a214 100644
--- a/test/message/stdin_messages.out
+++ b/test/message/stdin_messages.out
@@ -7,13 +7,13 @@ SyntaxError: Strict mode code may not include a with statement
     at new Script (vm.js:*)
     at createScript (vm.js:*)
     at Object.runInThisContext (vm.js:*)
-    at Object.<anonymous> ([stdin]-wrapper:*:*)
-    at Module._compile (internal/modules/cjs/loader.js:*:*)
+    at internal/process/execution.js:*:*
+    at [stdin]-wrapper:*:*
     at evalScript (internal/process/execution.js:*:*)
     at internal/main/eval_stdin.js:*:*
     at Socket.<anonymous> (internal/process/execution.js:*:*)
     at Socket.emit (events.js:*:*)
-    at endReadableNT (_stream_readable.js:*:*)
+    at endReadableNT (internal/streams/readable.js:*:*)
 42
 42
 [stdin]:1
@@ -24,13 +24,13 @@ Error: hello
     at [stdin]:1:7
     at Script.runInThisContext (vm.js:*)
     at Object.runInThisContext (vm.js:*)
-    at Object.<anonymous> ([stdin]-wrapper:*:*)
-    at Module._compile (internal/modules/cjs/loader.js:*:*)
+    at internal/process/execution.js:*:*
+    at [stdin]-wrapper:*:*
     at evalScript (internal/process/execution.js:*:*)
     at internal/main/eval_stdin.js:*:*
     at Socket.<anonymous> (internal/process/execution.js:*:*)
     at Socket.emit (events.js:*:*)
-    at endReadableNT (_stream_readable.js:*:*)
+    at endReadableNT (internal/streams/readable.js:*:*)
 [stdin]:1
 throw new Error("hello")
 ^
@@ -39,13 +39,13 @@ Error: hello
     at [stdin]:1:*
     at Script.runInThisContext (vm.js:*)
     at Object.runInThisContext (vm.js:*)
-    at Object.<anonymous> ([stdin]-wrapper:*:*)
-    at Module._compile (internal/modules/cjs/loader.js:*:*)
+    at internal/process/execution.js:*:*
+    at [stdin]-wrapper:*:*
     at evalScript (internal/process/execution.js:*:*)
     at internal/main/eval_stdin.js:*:*
     at Socket.<anonymous> (internal/process/execution.js:*:*)
     at Socket.emit (events.js:*:*)
-    at endReadableNT (_stream_readable.js:*:*)
+    at endReadableNT (internal/streams/readable.js:*:*)
 100
 [stdin]:1
 let x = 100; y = x;
@@ -55,13 +55,13 @@ ReferenceError: y is not defined
     at [stdin]:1:16
     at Script.runInThisContext (vm.js:*)
     at Object.runInThisContext (vm.js:*)
-    at Object.<anonymous> ([stdin]-wrapper:*:*)
-    at Module._compile (internal/modules/cjs/loader.js:*:*)
+    at internal/process/execution.js:*:*
+    at [stdin]-wrapper:*:*
     at evalScript (internal/process/execution.js:*:*)
     at internal/main/eval_stdin.js:*:*
     at Socket.<anonymous> (internal/process/execution.js:*:*)
     at Socket.emit (events.js:*:*)
-    at endReadableNT (_stream_readable.js:*:*)
+    at endReadableNT (internal/streams/readable.js:*:*)
 
 [stdin]:1
 let ______________________________________________; throw 10
diff --git a/test/message/testcfg.py b/test/message/testcfg.py
index bd56a8eba8c4cefce6f3e98eb8b62fe6d1372ec3..4be454b55c9053b1cdafd2f332c6b7454bceee08 100644
--- a/test/message/testcfg.py
+++ b/test/message/testcfg.py
@@ -43,6 +43,7 @@ class MessageTestCase(test.TestCase):
     self.config = config
     self.arch = arch
     self.mode = mode
+    self.parallel = True
 
   def IgnoreLine(self, str):
     """Ignore empty lines and valgrind output."""
diff --git a/test/message/timeout_throw.js b/test/message/timeout_throw.js
index 6ae705369786c480e1e453921ed8f82f66ea5688..9bcbd85b5036e20d3dd3f2745a7d39f9ef416822 100644
--- a/test/message/timeout_throw.js
+++ b/test/message/timeout_throw.js
@@ -23,6 +23,6 @@
 require('../common');
 
 setTimeout(function() {
-  // eslint-disable-next-line no-undef
+  // eslint-disable-next-line no-undef,no-unused-expressions
   undefined_reference_error_maker;
 }, 1);
diff --git a/test/message/v8_warning.out b/test/message/v8_warning.out
index 7943d0e9d64dfe9c880a9855745c131eddfbcb4c..6c419c83cddf28b139c6a8ed828d1fd7b173c395 100644
--- a/test/message/v8_warning.out
+++ b/test/message/v8_warning.out
@@ -1 +1,2 @@
 (node:*) V8: *v8_warning.js:* Invalid asm.js: Invalid return type
+(Use `* --trace-warnings ...` to show where the warning was created)
diff --git a/test/node-api/test_async/binding.gyp b/test/node-api/test_async/binding.gyp
index cf8beb70c68e78a0a3ecdf6bf0ad0aec20829daf..d8436e2b1d189fcd2ba96fe879a4b6c7e88ca7da 100644
--- a/test/node-api/test_async/binding.gyp
+++ b/test/node-api/test_async/binding.gyp
@@ -2,7 +2,7 @@
   "targets": [
     {
       "target_name": "test_async",
-      "sources": [ "test_async.cc" ]
+      "sources": [ "test_async.c" ]
     }
   ]
 }
diff --git a/test/node-api/test_async/test-async-hooks.js b/test/node-api/test_async/test-async-hooks.js
index db6e0cbd1679e60dadbed93d42e6c4180e01e1a7..e7879c5ad2b686b177dccf9768e1d0caf0d6013a 100644
--- a/test/node-api/test_async/test-async-hooks.js
+++ b/test/node-api/test_async/test-async-hooks.js
@@ -55,6 +55,6 @@ process.on('exit', () => {
     { type: 'before', id: testId },
     { type: 'complete' },
     { type: 'after', id: testId },
-    { type: 'destroy', id: testId }
+    { type: 'destroy', id: testId },
   ]);
 });
diff --git a/test/node-api/test_async/test_async.cc b/test/node-api/test_async/test_async.c
similarity index 78%
rename from test/node-api/test_async/test_async.cc
rename to test/node-api/test_async/test_async.c
index ff3d2749a9d1849f362c51b3a0d935b5bbaef3c3..44ad08366b190805b8ce0ec7df768a0b0fa23c61 100644
--- a/test/node-api/test_async/test_async.cc
+++ b/test/node-api/test_async/test_async.c
@@ -19,32 +19,32 @@ typedef struct {
   napi_async_work _request;
 } carrier;
 
-carrier the_carrier;
-carrier async_carrier[MAX_CANCEL_THREADS];
+static carrier the_carrier;
+static carrier async_carrier[MAX_CANCEL_THREADS];
 
-void Execute(napi_env env, void* data) {
+static void Execute(napi_env env, void* data) {
 #if defined _WIN32
   Sleep(1000);
 #else
   sleep(1);
 #endif
-  carrier* c = static_cast<carrier*>(data);
+  carrier* c = (carrier*)(data);
 
   assert(c == &the_carrier);
 
   c->_output = c->_input * 2;
 }
 
-void Complete(napi_env env, napi_status status, void* data) {
-  carrier* c = static_cast<carrier*>(data);
+static void Complete(napi_env env, napi_status status, void* data) {
+  carrier* c = (carrier*)(data);
 
   if (c != &the_carrier) {
-    napi_throw_type_error(env, nullptr, "Wrong data parameter to Complete.");
+    napi_throw_type_error(env, NULL, "Wrong data parameter to Complete.");
     return;
   }
 
   if (status != napi_ok) {
-    napi_throw_type_error(env, nullptr, "Execute callback failed.");
+    napi_throw_type_error(env, NULL, "Execute callback failed.");
     return;
   }
 
@@ -66,7 +66,7 @@ void Complete(napi_env env, napi_status status, void* data) {
   NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
 }
 
-napi_value Test(napi_env env, napi_callback_info info) {
+static napi_value Test(napi_env env, napi_callback_info info) {
   size_t argc = 3;
   napi_value argv[3];
   napi_value _this;
@@ -101,16 +101,16 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env,
       napi_queue_async_work(env, the_carrier._request));
 
-  return nullptr;
+  return NULL;
 }
 
-void BusyCancelComplete(napi_env env, napi_status status, void* data) {
-  carrier* c = static_cast<carrier*>(data);
+static void BusyCancelComplete(napi_env env, napi_status status, void* data) {
+  carrier* c = (carrier*)(data);
   NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
 }
 
-void CancelComplete(napi_env env, napi_status status, void* data) {
-  carrier* c = static_cast<carrier*>(data);
+static void CancelComplete(napi_env env, napi_status status, void* data) {
+  carrier* c = (carrier*)(data);
 
   if (status == napi_cancelled) {
     // ok we got the status we expected so make the callback to
@@ -122,14 +122,14 @@ void CancelComplete(napi_env env, napi_status status, void* data) {
     NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &global));
     napi_value result;
     NAPI_CALL_RETURN_VOID(env,
-      napi_call_function(env, global, callback, 0, nullptr, &result));
+      napi_call_function(env, global, callback, 0, NULL, &result));
   }
 
   NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
   NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, c->_callback));
 }
 
-void CancelExecute(napi_env env, void* data) {
+static void CancelExecute(napi_env env, void* data) {
 #if defined _WIN32
   Sleep(1000);
 #else
@@ -137,7 +137,7 @@ void CancelExecute(napi_env env, void* data) {
 #endif
 }
 
-napi_value TestCancel(napi_env env, napi_callback_info info) {
+static napi_value TestCancel(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value argv[1];
   napi_value _this;
@@ -150,7 +150,7 @@ napi_value TestCancel(napi_env env, napi_callback_info info) {
   // make sure the work we are going to cancel will not be
   // able to start by using all the threads in the pool
   for (int i = 1; i < MAX_CANCEL_THREADS; i++) {
-    NAPI_CALL(env, napi_create_async_work(env, nullptr, resource_name,
+    NAPI_CALL(env, napi_create_async_work(env, NULL, resource_name,
       CancelExecute, BusyCancelComplete,
       &async_carrier[i], &async_carrier[i]._request));
     NAPI_CALL(env, napi_queue_async_work(env, async_carrier[i]._request));
@@ -162,20 +162,20 @@ napi_value TestCancel(napi_env env, napi_callback_info info) {
   // workers above.
   NAPI_CALL(env,
     napi_get_cb_info(env, info, &argc, argv, &_this, &data));
-  NAPI_CALL(env, napi_create_async_work(env, nullptr, resource_name,
+  NAPI_CALL(env, napi_create_async_work(env, NULL, resource_name,
     CancelExecute, CancelComplete,
     &async_carrier[0], &async_carrier[0]._request));
   NAPI_CALL(env,
       napi_create_reference(env, argv[0], 1, &async_carrier[0]._callback));
   NAPI_CALL(env, napi_queue_async_work(env, async_carrier[0]._request));
   NAPI_CALL(env, napi_cancel_async_work(env, async_carrier[0]._request));
-  return nullptr;
+  return NULL;
 }
 
 struct {
   napi_ref ref;
   napi_async_work work;
-} repeated_work_info = { nullptr, nullptr };
+} repeated_work_info = { NULL, NULL };
 
 static void RepeatedWorkerThread(napi_env env, void* data) {}
 
@@ -187,33 +187,33 @@ static void RepeatedWorkComplete(napi_env env, napi_status status, void* data) {
       napi_delete_async_work(env, repeated_work_info.work));
   NAPI_CALL_RETURN_VOID(env,
       napi_delete_reference(env, repeated_work_info.ref));
-  repeated_work_info.work = nullptr;
-  repeated_work_info.ref = nullptr;
+  repeated_work_info.work = NULL;
+  repeated_work_info.ref = NULL;
   NAPI_CALL_RETURN_VOID(env,
       napi_create_uint32(env, (uint32_t)status, &js_status));
   NAPI_CALL_RETURN_VOID(env,
-      napi_call_function(env, cb, cb, 1, &js_status, nullptr));
+      napi_call_function(env, cb, cb, 1, &js_status, NULL));
 }
 
 static napi_value DoRepeatedWork(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value cb, name;
-  NAPI_ASSERT(env, repeated_work_info.ref == nullptr,
+  NAPI_ASSERT(env, repeated_work_info.ref == NULL,
       "Reference left over from previous work");
-  NAPI_ASSERT(env, repeated_work_info.work == nullptr,
+  NAPI_ASSERT(env, repeated_work_info.work == NULL,
       "Work pointer left over from previous work");
-  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &cb, nullptr, nullptr));
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &cb, NULL, NULL));
   NAPI_CALL(env, napi_create_reference(env, cb, 1, &repeated_work_info.ref));
   NAPI_CALL(env,
       napi_create_string_utf8(env, "Repeated Work", NAPI_AUTO_LENGTH, &name));
   NAPI_CALL(env,
-      napi_create_async_work(env, nullptr, name, RepeatedWorkerThread,
+      napi_create_async_work(env, NULL, name, RepeatedWorkerThread,
           RepeatedWorkComplete, &repeated_work_info, &repeated_work_info.work));
   NAPI_CALL(env, napi_queue_async_work(env, repeated_work_info.work));
-  return nullptr;
+  return NULL;
 }
 
-napi_value Init(napi_env env, napi_value exports) {
+static napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
     DECLARE_NAPI_PROPERTY("TestCancel", TestCancel),
diff --git a/test/node-api/test_async_context/binding.c b/test/node-api/test_async_context/binding.c
new file mode 100644
index 0000000000000000000000000000000000000000..3dab0fd0e818dd6f190297962908e6ffe1739d1c
--- /dev/null
+++ b/test/node-api/test_async_context/binding.c
@@ -0,0 +1,129 @@
+#include <node_api.h>
+#include <assert.h>
+#include "../../js-native-api/common.h"
+
+#define MAX_ARGUMENTS 10
+#define RESERVED_ARGS 3
+
+static napi_value MakeCallback(napi_env env, napi_callback_info info) {
+  size_t argc = MAX_ARGUMENTS;
+  size_t n;
+  napi_value args[MAX_ARGUMENTS];
+  // NOLINTNEXTLINE (readability/null_usage)
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
+
+  napi_value async_context_wrap = args[0];
+  napi_value recv = args[1];
+  napi_value func = args[2];
+
+  napi_value argv[MAX_ARGUMENTS - RESERVED_ARGS];
+  for (n = RESERVED_ARGS; n < argc; n += 1) {
+    argv[n - RESERVED_ARGS] = args[n];
+  }
+
+  napi_valuetype func_type;
+  NAPI_CALL(env, napi_typeof(env, func, &func_type));
+
+  napi_async_context context;
+  NAPI_CALL(env, napi_unwrap(env, async_context_wrap, (void**)&context));
+
+  napi_value result;
+  if (func_type == napi_function) {
+    NAPI_CALL(env, napi_make_callback(
+        env, context, recv, func, argc - RESERVED_ARGS, argv, &result));
+  } else {
+    NAPI_ASSERT(env, false, "Unexpected argument type");
+  }
+
+  return result;
+}
+
+static void AsyncDestroyCb(napi_env env, void* data, void* hint) {
+  napi_status status = napi_async_destroy(env, (napi_async_context)data);
+  // We cannot use NAPI_ASSERT_RETURN_VOID because we need to have a JS stack
+  // below in order to use exceptions.
+  assert(status == napi_ok);
+}
+
+#define CREATE_ASYNC_RESOURCE_ARGC 2
+
+static napi_value CreateAsyncResource(napi_env env, napi_callback_info info) {
+  napi_value async_context_wrap;
+  NAPI_CALL(env, napi_create_object(env, &async_context_wrap));
+
+  size_t argc = CREATE_ASYNC_RESOURCE_ARGC;
+  napi_value args[CREATE_ASYNC_RESOURCE_ARGC];
+  // NOLINTNEXTLINE (readability/null_usage)
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  napi_value resource = args[0];
+  napi_value js_destroy_on_finalizer = args[1];
+  napi_valuetype resource_type;
+  NAPI_CALL(env, napi_typeof(env, resource, &resource_type));
+  if (resource_type != napi_object) {
+    resource = NULL;
+  }
+
+  napi_value resource_name;
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "test_async", NAPI_AUTO_LENGTH, &resource_name));
+
+  napi_async_context context;
+  NAPI_CALL(env, napi_async_init(env, resource, resource_name, &context));
+
+  bool destroy_on_finalizer = true;
+  if (argc == 2) {
+    NAPI_CALL(env, napi_get_value_bool(env, js_destroy_on_finalizer, &destroy_on_finalizer));
+  }
+  if (resource_type == napi_object && destroy_on_finalizer) {
+    NAPI_CALL(env, napi_add_finalizer(
+        env, resource, (void*)context, AsyncDestroyCb, NULL, NULL));
+  }
+  NAPI_CALL(env, napi_wrap(env, async_context_wrap, context, NULL, NULL, NULL));
+  return async_context_wrap;
+}
+
+#define DESTROY_ASYNC_RESOURCE_ARGC 1
+
+static napi_value DestroyAsyncResource(napi_env env, napi_callback_info info) {
+  size_t argc = DESTROY_ASYNC_RESOURCE_ARGC;
+  napi_value args[DESTROY_ASYNC_RESOURCE_ARGC];
+  // NOLINTNEXTLINE (readability/null_usage)
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
+
+  napi_value async_context_wrap = args[0];
+
+  napi_async_context async_context;
+  NAPI_CALL(env,
+            napi_remove_wrap(env, async_context_wrap, (void**)&async_context));
+  NAPI_CALL(env, napi_async_destroy(env, async_context));
+
+  return async_context_wrap;
+}
+
+static
+napi_value Init(napi_env env, napi_value exports) {
+  napi_value fn;
+  NAPI_CALL(env, napi_create_function(
+      // NOLINTNEXTLINE (readability/null_usage)
+      env, NULL, NAPI_AUTO_LENGTH, MakeCallback, NULL, &fn));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
+  NAPI_CALL(env, napi_create_function(
+      // NOLINTNEXTLINE (readability/null_usage)
+      env, NULL, NAPI_AUTO_LENGTH, CreateAsyncResource, NULL, &fn));
+  NAPI_CALL(env, napi_set_named_property(
+      env, exports, "createAsyncResource", fn));
+
+  NAPI_CALL(env, napi_create_function(
+      // NOLINTNEXTLINE (readability/null_usage)
+      env, NULL, NAPI_AUTO_LENGTH, DestroyAsyncResource, NULL, &fn));
+  NAPI_CALL(env, napi_set_named_property(
+      env, exports, "destroyAsyncResource", fn));
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/node-api/test_async_context/binding.gyp b/test/node-api/test_async_context/binding.gyp
new file mode 100644
index 0000000000000000000000000000000000000000..23daf507916ff6649e5abfe4c082daa2dcc8010b
--- /dev/null
+++ b/test/node-api/test_async_context/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
+      'sources': [ 'binding.c' ]
+    }
+  ]
+}
diff --git a/test/node-api/test_async_context/test-gcable-callback.js b/test/node-api/test_async_context/test-gcable-callback.js
new file mode 100644
index 0000000000000000000000000000000000000000..e66080bb6a3a901408d8f39fe1fa51738ee8e27f
--- /dev/null
+++ b/test/node-api/test_async_context/test-gcable-callback.js
@@ -0,0 +1,65 @@
+'use strict';
+// Flags: --gc-interval=100 --gc-global
+
+const common = require('../../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+const {
+  createAsyncResource,
+  destroyAsyncResource,
+  makeCallback,
+} = require(`./build/${common.buildType}/binding`);
+
+// Test for https://github.com/nodejs/node/issues/27218:
+// napi_async_destroy() can be called during a regular garbage collection run.
+
+const hook_result = {
+  id: null,
+  init_called: false,
+  destroy_called: false,
+};
+
+const test_hook = async_hooks.createHook({
+  init: (id, type) => {
+    if (type === 'test_async') {
+      hook_result.id = id;
+      hook_result.init_called = true;
+    }
+  },
+  destroy: (id) => {
+    if (id === hook_result.id) hook_result.destroy_called = true;
+  },
+});
+
+test_hook.enable();
+const asyncResource = createAsyncResource(
+  { foo: 'bar' },
+  /* destroy_on_finalizer */false
+);
+
+// Trigger GC. This does *not* use global.gc(), because what we want to verify
+// is that `napi_async_destroy()` can be called when there is no JS context
+// on the stack at the time of GC.
+// Currently, using --gc-interval=100 + 1M elements seems to work fine for this.
+const arr = new Array(1024 * 1024);
+for (let i = 0; i < arr.length; i++)
+  arr[i] = {};
+
+assert.strictEqual(hook_result.destroy_called, false);
+setImmediate(() => {
+  assert.strictEqual(hook_result.destroy_called, false);
+  makeCallback(asyncResource, process, () => {
+    const executionAsyncResource = async_hooks.executionAsyncResource();
+    // Assuming the executionAsyncResource was created for the absence of the
+    // initial `{ foo: 'bar' }`.
+    // This is the worst path of `napi_async_context` related API of
+    // recovering from the condition and not break the executionAsyncResource
+    // shape, although the executionAsyncResource might not be correct.
+    assert.strictEqual(typeof executionAsyncResource, 'object');
+    assert.strictEqual(executionAsyncResource.foo, undefined);
+    destroyAsyncResource(asyncResource);
+    setImmediate(() => {
+      assert.strictEqual(hook_result.destroy_called, true);
+    });
+  });
+});
diff --git a/test/node-api/test_make_callback/test-async-hooks-gcable.js b/test/node-api/test_async_context/test-gcable.js
similarity index 95%
rename from test/node-api/test_make_callback/test-async-hooks-gcable.js
rename to test/node-api/test_async_context/test-gcable.js
index a9b4d3d75d604066e198a54e919e57c60546a4b3..288b7412267dccd81ce51d350b72db214d57cced 100644
--- a/test/node-api/test_make_callback/test-async-hooks-gcable.js
+++ b/test/node-api/test_async_context/test-gcable.js
@@ -17,7 +17,7 @@ const hook_result = {
 
 const test_hook = async_hooks.createHook({
   init: (id, type) => {
-    if (type === 'test_gcable') {
+    if (type === 'test_async') {
       hook_result.id = id;
       hook_result.init_called = true;
     }
@@ -28,7 +28,7 @@ const test_hook = async_hooks.createHook({
 });
 
 test_hook.enable();
-createAsyncResource();
+createAsyncResource({});
 
 // Trigger GC. This does *not* use global.gc(), because what we want to verify
 // is that `napi_async_destroy()` can be called when there is no JS context
diff --git a/test/node-api/test_async_context/test.js b/test/node-api/test_async_context/test.js
new file mode 100644
index 0000000000000000000000000000000000000000..2cf00b1ef7bb0eeb85ffeea1a36a519afe89217d
--- /dev/null
+++ b/test/node-api/test_async_context/test.js
@@ -0,0 +1,63 @@
+'use strict';
+// Flags: --gc-interval=100 --gc-global
+
+const common = require('../../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+const {
+  makeCallback,
+  createAsyncResource,
+  destroyAsyncResource,
+} = require(`./build/${common.buildType}/binding`);
+
+const hook_result = {
+  id: null,
+  resource: null,
+  init_called: false,
+  destroy_called: false,
+};
+
+const test_hook = async_hooks.createHook({
+  init: (id, type, triggerAsyncId, resource) => {
+    if (type === 'test_async') {
+      hook_result.id = id;
+      hook_result.init_called = true;
+      hook_result.resource = resource;
+    }
+  },
+  destroy: (id) => {
+    if (id === hook_result.id) hook_result.destroy_called = true;
+  },
+});
+
+test_hook.enable();
+const resourceWrap = createAsyncResource(
+  /**
+   * set resource to NULL to generate a managed resource object
+   */
+  undefined
+);
+
+assert.strictEqual(hook_result.destroy_called, false);
+const recv = {};
+makeCallback(resourceWrap, recv, function callback() {
+  assert.strictEqual(hook_result.destroy_called, false);
+  assert.strictEqual(
+    hook_result.resource,
+    async_hooks.executionAsyncResource()
+  );
+  assert.strictEqual(this, recv);
+
+  setImmediate(() => {
+    assert.strictEqual(hook_result.destroy_called, false);
+    assert.notStrictEqual(
+      hook_result.resource,
+      async_hooks.executionAsyncResource()
+    );
+
+    destroyAsyncResource(resourceWrap);
+    setImmediate(() => {
+      assert.strictEqual(hook_result.destroy_called, true);
+    });
+  });
+});
diff --git a/test/node-api/test_buffer/test.js b/test/node-api/test_buffer/test.js
index 6b6c2089afa76eb0a755ecf26d8a913f21a79bfa..fe668a3ef9a8790addee60a38b960a545f6de000 100644
--- a/test/node-api/test_buffer/test.js
+++ b/test/node-api/test_buffer/test.js
@@ -1,10 +1,10 @@
 'use strict';
-// Flags: --expose-gc
+// Flags: --expose-gc --no-concurrent-array-buffer-freeing --no-concurrent-array-buffer-sweeping
 
 const common = require('../../common');
 const binding = require(`./build/${common.buildType}/test_buffer`);
 const assert = require('assert');
-const setImmediatePromise = require('util').promisify(setImmediate);
+const tick = require('util').promisify(require('../../common/tick'));
 
 (async function() {
   assert.strictEqual(binding.newBuffer().toString(), binding.theText);
@@ -12,7 +12,7 @@ const setImmediatePromise = require('util').promisify(setImmediate);
   console.log('gc1');
   global.gc();
   assert.strictEqual(binding.getDeleterCallCount(), 0);
-  await setImmediatePromise();
+  await tick(10);
   assert.strictEqual(binding.getDeleterCallCount(), 1);
   assert.strictEqual(binding.copyBuffer().toString(), binding.theText);
 
@@ -22,7 +22,7 @@ const setImmediatePromise = require('util').promisify(setImmediate);
   buffer = null;
   global.gc();
   assert.strictEqual(binding.getDeleterCallCount(), 1);
-  await setImmediatePromise();
+  await tick(10);
   console.log('gc2');
   assert.strictEqual(binding.getDeleterCallCount(), 2);
 })().then(common.mustCall());
diff --git a/test/node-api/test_callback_scope/binding.cc b/test/node-api/test_callback_scope/binding.c
similarity index 76%
rename from test/node-api/test_callback_scope/binding.cc
rename to test/node-api/test_callback_scope/binding.c
index a8a755a016a7ee0a0501d317050fb00a52b144c7..d512219e7bfa58a18eceb621a1d5cbd924f52cc0 100644
--- a/test/node-api/test_callback_scope/binding.cc
+++ b/test/node-api/test_callback_scope/binding.c
@@ -1,17 +1,16 @@
+#include <stdlib.h>
 #include "node_api.h"
 #include "uv.h"
 #include "../../js-native-api/common.h"
 
-namespace {
-
-napi_value RunInCallbackScope(napi_env env, napi_callback_info info) {
+static napi_value RunInCallbackScope(napi_env env, napi_callback_info info) {
   size_t argc;
   napi_value args[3];
 
-  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr));
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, NULL, NULL, NULL));
   NAPI_ASSERT(env, argc == 3 , "Wrong number of arguments");
 
-  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_valuetype valuetype;
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
@@ -29,7 +28,7 @@ napi_value RunInCallbackScope(napi_env env, napi_callback_info info) {
   napi_async_context context;
   NAPI_CALL(env, napi_async_init(env, args[0], args[1], &context));
 
-  napi_callback_scope scope = nullptr;
+  napi_callback_scope scope = NULL;
   NAPI_CALL(
       env,
       napi_open_callback_scope(env,
@@ -39,9 +38,9 @@ napi_value RunInCallbackScope(napi_env env, napi_callback_info info) {
 
   // if the function has an exception pending after the call that is ok
   // so we don't use NAPI_CALL as we must close the callback scope regardless
-  napi_value result = nullptr;
+  napi_value result = NULL;
   napi_status function_call_result =
-      napi_call_function(env, args[0], args[2], 0, nullptr, &result);
+      napi_call_function(env, args[0], args[2], 0, NULL, &result);
   if (function_call_result != napi_ok) {
     GET_AND_THROW_LAST_ERROR((env));
   }
@@ -52,13 +51,13 @@ napi_value RunInCallbackScope(napi_env env, napi_callback_info info) {
   return result;
 }
 
-static napi_env shared_env = nullptr;
-static napi_deferred deferred = nullptr;
+static napi_env shared_env = NULL;
+static napi_deferred deferred = NULL;
 
 static void Callback(uv_work_t* req, int ignored) {
   napi_env env = shared_env;
 
-  napi_handle_scope handle_scope = nullptr;
+  napi_handle_scope handle_scope = NULL;
   NAPI_CALL_RETURN_VOID(env, napi_open_handle_scope(env, &handle_scope));
 
   napi_value resource_name;
@@ -66,7 +65,7 @@ static void Callback(uv_work_t* req, int ignored) {
       env, "test", NAPI_AUTO_LENGTH, &resource_name));
   napi_async_context context;
   NAPI_CALL_RETURN_VOID(env,
-                        napi_async_init(env, nullptr, resource_name, &context));
+                        napi_async_init(env, NULL, resource_name, &context));
 
   napi_value resource_object;
   NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &resource_object));
@@ -74,7 +73,7 @@ static void Callback(uv_work_t* req, int ignored) {
   napi_value undefined_value;
   NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined_value));
 
-  napi_callback_scope scope = nullptr;
+  napi_callback_scope scope = NULL;
   NAPI_CALL_RETURN_VOID(env, napi_open_callback_scope(env,
                                                       resource_object,
                                                       context,
@@ -87,28 +86,30 @@ static void Callback(uv_work_t* req, int ignored) {
 
   NAPI_CALL_RETURN_VOID(env, napi_close_handle_scope(env, handle_scope));
   NAPI_CALL_RETURN_VOID(env, napi_async_destroy(env, context));
-  delete req;
+  free(req);
 }
 
-napi_value TestResolveAsync(napi_env env, napi_callback_info info) {
-  napi_value promise = nullptr;
-  if (deferred == nullptr) {
+static void NoopWork(uv_work_t* work) { (void) work; }
+
+static napi_value TestResolveAsync(napi_env env, napi_callback_info info) {
+  napi_value promise = NULL;
+  if (deferred == NULL) {
     shared_env = env;
     NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
 
-    uv_loop_t* loop = nullptr;
+    uv_loop_t* loop = NULL;
     NAPI_CALL(env, napi_get_uv_event_loop(env, &loop));
 
-    uv_work_t* req = new uv_work_t();
+    uv_work_t* req = malloc(sizeof(*req));
     uv_queue_work(loop,
                   req,
-                  [](uv_work_t*) {},
+                  NoopWork,
                   Callback);
   }
   return promise;
 }
 
-napi_value Init(napi_env env, napi_value exports) {
+static napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("runInCallbackScope", RunInCallbackScope),
     DECLARE_NAPI_PROPERTY("testResolveAsync", TestResolveAsync)
@@ -120,6 +121,4 @@ napi_value Init(napi_env env, napi_value exports) {
   return exports;
 }
 
-}  // anonymous namespace
-
 NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/node-api/test_callback_scope/binding.gyp b/test/node-api/test_callback_scope/binding.gyp
index 7ede63d94a0d77635ff78b8ad2d0079216eefa1a..23daf507916ff6649e5abfe4c082daa2dcc8010b 100644
--- a/test/node-api/test_callback_scope/binding.gyp
+++ b/test/node-api/test_callback_scope/binding.gyp
@@ -3,7 +3,7 @@
     {
       'target_name': 'binding',
       'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
-      'sources': [ 'binding.cc' ]
+      'sources': [ 'binding.c' ]
     }
   ]
 }
diff --git a/test/node-api/test_cleanup_hook/binding.cc b/test/node-api/test_cleanup_hook/binding.c
similarity index 56%
rename from test/node-api/test_cleanup_hook/binding.cc
rename to test/node-api/test_cleanup_hook/binding.c
index 9426716e674d22f66fa71fac04067021e416b9f7..3e0ddfe9e3c59bede5e5e17fd6184d36fc1e8195 100644
--- a/test/node-api/test_cleanup_hook/binding.cc
+++ b/test/node-api/test_cleanup_hook/binding.c
@@ -2,23 +2,19 @@
 #include "uv.h"
 #include "../../js-native-api/common.h"
 
-namespace {
-
-void cleanup(void* arg) {
-  printf("cleanup(%d)\n", *static_cast<int*>(arg));
+static void cleanup(void* arg) {
+  printf("cleanup(%d)\n", *(int*)(arg));
 }
 
-int secret = 42;
-int wrong_secret = 17;
+static int secret = 42;
+static int wrong_secret = 17;
 
-napi_value Init(napi_env env, napi_value exports) {
+static napi_value Init(napi_env env, napi_value exports) {
   napi_add_env_cleanup_hook(env, cleanup, &wrong_secret);
   napi_add_env_cleanup_hook(env, cleanup, &secret);
   napi_remove_env_cleanup_hook(env, cleanup, &wrong_secret);
 
-  return nullptr;
+  return NULL;
 }
 
-}  // anonymous namespace
-
 NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/node-api/test_cleanup_hook/binding.gyp b/test/node-api/test_cleanup_hook/binding.gyp
index 7ede63d94a0d77635ff78b8ad2d0079216eefa1a..23daf507916ff6649e5abfe4c082daa2dcc8010b 100644
--- a/test/node-api/test_cleanup_hook/binding.gyp
+++ b/test/node-api/test_cleanup_hook/binding.gyp
@@ -3,7 +3,7 @@
     {
       'target_name': 'binding',
       'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
-      'sources': [ 'binding.cc' ]
+      'sources': [ 'binding.c' ]
     }
   ]
 }
diff --git a/test/node-api/test_env_teardown_gc/binding.c b/test/node-api/test_env_teardown_gc/binding.c
new file mode 100644
index 0000000000000000000000000000000000000000..f894690b2470b24ce118f288b53cc61969d3e1b0
--- /dev/null
+++ b/test/node-api/test_env_teardown_gc/binding.c
@@ -0,0 +1,37 @@
+#include <stdlib.h>
+#include <node_api.h>
+#include "../../js-native-api/common.h"
+
+static void MyObject_fini(napi_env env, void* data, void* hint) {
+  napi_ref* ref = data;
+  napi_value global;
+  napi_value cleanup;
+  NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &global));
+  NAPI_CALL_RETURN_VOID(
+      env, napi_get_named_property(env, global, "cleanup", &cleanup));
+  napi_status status = napi_call_function(env, global, cleanup, 0, NULL, NULL);
+  // We may not be allowed to call into JS, in which case a pending exception
+  // will be returned.
+  NAPI_ASSERT_RETURN_VOID(env,
+      status == napi_ok || status == napi_pending_exception,
+      "Unexpected status for napi_call_function");
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, *ref));
+  free(ref);
+}
+
+static napi_value MyObject(napi_env env, napi_callback_info info) {
+  napi_value js_this;
+  napi_ref* ref = malloc(sizeof(*ref));
+  NAPI_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &js_this, NULL));
+  NAPI_CALL(env, napi_wrap(env, js_this, ref, MyObject_fini, NULL, ref));
+  return NULL;
+}
+
+NAPI_MODULE_INIT() {
+  napi_value ctor;
+  NAPI_CALL(
+      env, napi_define_class(
+          env, "MyObject", NAPI_AUTO_LENGTH, MyObject, NULL, 0, NULL, &ctor));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "MyObject",  ctor));
+  return exports;
+}
diff --git a/test/node-api/test_env_teardown_gc/binding.gyp b/test/node-api/test_env_teardown_gc/binding.gyp
new file mode 100644
index 0000000000000000000000000000000000000000..413621ade335a18eb1e775033ce946dca0434452
--- /dev/null
+++ b/test/node-api/test_env_teardown_gc/binding.gyp
@@ -0,0 +1,8 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'sources': [ 'binding.c' ]
+    }
+  ]
+}
diff --git a/test/node-api/test_env_teardown_gc/test.js b/test/node-api/test_env_teardown_gc/test.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f1c4f4038fbaba634c6cf3af5aefdf80097036d
--- /dev/null
+++ b/test/node-api/test_env_teardown_gc/test.js
@@ -0,0 +1,14 @@
+'use strict';
+// Flags: --expose-gc
+
+process.env.NODE_TEST_KNOWN_GLOBALS = 0;
+
+const common = require('../../common');
+const binding = require(`./build/${common.buildType}/binding`);
+
+global.it = new binding.MyObject();
+
+global.cleanup = () => {
+  delete global.it;
+  global.gc();
+};
diff --git a/test/node-api/test_fatal/test.js b/test/node-api/test_fatal/test.js
index 7ff9a395635dceeff80875219d69ab7dc57a9b2c..c4af828ff154d131ef6fab173aed62b5f59182fa 100644
--- a/test/node-api/test_fatal/test.js
+++ b/test/node-api/test_fatal/test.js
@@ -16,3 +16,4 @@ const p = child_process.spawnSync(
 assert.ifError(p.error);
 assert.ok(p.stderr.toString().includes(
   'FATAL ERROR: test_fatal::Test fatal message'));
+assert.ok(p.status === 134 || p.signal === 'SIGABRT');
diff --git a/test/node-api/test_fatal/test2.js b/test/node-api/test_fatal/test2.js
index b9bde8f13016cce6f19020b2c8a6f2c310d11640..6449f098458d76f626e33b64a36cfe663d7d5e08 100644
--- a/test/node-api/test_fatal/test2.js
+++ b/test/node-api/test_fatal/test2.js
@@ -16,3 +16,4 @@ const p = child_process.spawnSync(
 assert.ifError(p.error);
 assert.ok(p.stderr.toString().includes(
   'FATAL ERROR: test_fatal::Test fatal message'));
+assert.ok(p.status === 134 || p.signal === 'SIGABRT');
diff --git a/test/node-api/test_fatal/test_fatal.c b/test/node-api/test_fatal/test_fatal.c
index 70bb458ef20e4eade7432e66c6be9a89c498a4ef..1b4bdd180e5dfae69a8110856aa231e077fd6dfc 100644
--- a/test/node-api/test_fatal/test_fatal.c
+++ b/test/node-api/test_fatal/test_fatal.c
@@ -1,12 +1,32 @@
+// For the purpose of this test we use libuv's threading library. When deciding
+// on a threading library for a new project it bears remembering that in the
+// future libuv may introduce API changes which may render it non-ABI-stable,
+// which, in turn, may affect the ABI stability of the project despite its use
+// of N-API.
+#include <uv.h>
 #include <node_api.h>
 #include "../../js-native-api/common.h"
 
+static uv_thread_t uv_thread;
+
+static void work_thread(void* data) {
+  napi_fatal_error("work_thread", NAPI_AUTO_LENGTH,
+      "foobar", NAPI_AUTO_LENGTH);
+}
+
 static napi_value Test(napi_env env, napi_callback_info info) {
   napi_fatal_error("test_fatal::Test", NAPI_AUTO_LENGTH,
                    "fatal message", NAPI_AUTO_LENGTH);
   return NULL;
 }
 
+static napi_value TestThread(napi_env env, napi_callback_info info) {
+  NAPI_ASSERT(env,
+      (uv_thread_create(&uv_thread, work_thread, NULL) == 0),
+      "Thread creation");
+  return NULL;
+}
+
 static napi_value TestStringLength(napi_env env, napi_callback_info info) {
   napi_fatal_error("test_fatal::TestStringLength", 16, "fatal message", 13);
   return NULL;
@@ -16,6 +36,7 @@ static napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
     DECLARE_NAPI_PROPERTY("TestStringLength", TestStringLength),
+    DECLARE_NAPI_PROPERTY("TestThread", TestThread),
   };
 
   NAPI_CALL(env, napi_define_properties(
diff --git a/test/node-api/test_fatal/test_threads.js b/test/node-api/test_fatal/test_threads.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd56f60cbe832f8547b504923fa3707834310a8b
--- /dev/null
+++ b/test/node-api/test_fatal/test_threads.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const child_process = require('child_process');
+const test_fatal = require(`./build/${common.buildType}/test_fatal`);
+
+// Test in a child process because the test code will trigger a fatal error
+// that crashes the process.
+if (process.argv[2] === 'child') {
+  test_fatal.TestThread();
+  // Busy loop to allow the work thread to abort.
+  while (true) {}
+}
+
+const p = child_process.spawnSync(
+  process.execPath, [ __filename, 'child' ]);
+assert.ifError(p.error);
+assert.ok(p.stderr.toString().includes(
+  'FATAL ERROR: work_thread foobar'));
+assert.ok(p.status === 134 || p.signal === 'SIGABRT');
diff --git a/test/node-api/test_fatal/test_threads_report.js b/test/node-api/test_fatal/test_threads_report.js
new file mode 100644
index 0000000000000000000000000000000000000000..83c6642bdc41ebf602452c92e55b69a6c7e71035
--- /dev/null
+++ b/test/node-api/test_fatal/test_threads_report.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../../common');
+const helper = require('../../common/report.js');
+const tmpdir = require('../../common/tmpdir');
+
+const assert = require('assert');
+const child_process = require('child_process');
+const test_fatal = require(`./build/${common.buildType}/test_fatal`);
+
+if (common.buildType === 'Debug')
+  common.skip('as this will currently fail with a Debug check ' +
+              'in v8::Isolate::GetCurrent()');
+
+// Test in a child process because the test code will trigger a fatal error
+// that crashes the process.
+if (process.argv[2] === 'child') {
+  test_fatal.TestThread();
+  // Busy loop to allow the work thread to abort.
+  while (true) {}
+}
+
+tmpdir.refresh();
+const p = child_process.spawnSync(
+  process.execPath,
+  [ '--report-on-fatalerror', __filename, 'child' ],
+  { cwd: tmpdir.path });
+assert.ifError(p.error);
+assert.ok(p.stderr.toString().includes(
+  'FATAL ERROR: work_thread foobar'));
+assert.ok(p.status === 134 || p.signal === 'SIGABRT');
+
+const reports = helper.findReports(p.pid, tmpdir.path);
+assert.strictEqual(reports.length, 1);
+
+const report = reports[0];
+helper.validate(report);
diff --git a/test/node-api/test_instance_data/test.js b/test/node-api/test_instance_data/test.js
index 7dc3f4b317687766cfe33921e9db78451e298ffc..7f8e785ac4354604beb79c8a0553576a453bec1f 100644
--- a/test/node-api/test_instance_data/test.js
+++ b/test/node-api/test_instance_data/test.js
@@ -3,7 +3,7 @@
 
 const common = require('../../common');
 
-if (module.parent) {
+if (module !== require.main) {
   // When required as a module, run the tests.
   const test_instance_data =
     require(`./build/${common.buildType}/test_instance_data`);
diff --git a/test/node-api/test_make_callback/binding.c b/test/node-api/test_make_callback/binding.c
index 782cf0f6fb8f5464d46cf3fe9b8fc5b9ad2bfdd8..214e0a4e18238505dbb94a98d7f62ad7b8767442 100644
--- a/test/node-api/test_make_callback/binding.c
+++ b/test/node-api/test_make_callback/binding.c
@@ -3,6 +3,7 @@
 #include "../../js-native-api/common.h"
 
 #define MAX_ARGUMENTS 10
+#define RESERVED_ARGS 3
 
 static napi_value MakeCallback(napi_env env, napi_callback_info info) {
   size_t argc = MAX_ARGUMENTS;
@@ -13,12 +14,13 @@ static napi_value MakeCallback(napi_env env, napi_callback_info info) {
 
   NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
 
-  napi_value recv = args[0];
-  napi_value func = args[1];
+  napi_value resource = args[0];
+  napi_value recv = args[1];
+  napi_value func = args[2];
 
-  napi_value argv[MAX_ARGUMENTS - 2];
-  for (n = 2; n < argc; n += 1) {
-    argv[n - 2] = args[n];
+  napi_value argv[MAX_ARGUMENTS - RESERVED_ARGS];
+  for (n = RESERVED_ARGS; n < argc; n += 1) {
+    argv[n - RESERVED_ARGS] = args[n];
   }
 
   napi_valuetype func_type;
@@ -30,12 +32,12 @@ static napi_value MakeCallback(napi_env env, napi_callback_info info) {
       env, "test", NAPI_AUTO_LENGTH, &resource_name));
 
   napi_async_context context;
-  NAPI_CALL(env, napi_async_init(env, func, resource_name, &context));
+  NAPI_CALL(env, napi_async_init(env, resource, resource_name, &context));
 
   napi_value result;
   if (func_type == napi_function) {
     NAPI_CALL(env, napi_make_callback(
-        env, context, recv, func, argc - 2, argv, &result));
+        env, context, recv, func, argc - RESERVED_ARGS, argv, &result));
   } else {
     NAPI_ASSERT(env, false, "Unexpected argument type");
   }
@@ -45,30 +47,6 @@ static napi_value MakeCallback(napi_env env, napi_callback_info info) {
   return result;
 }
 
-static void AsyncDestroyCb(napi_env env, void* data, void* hint) {
-  napi_status status = napi_async_destroy(env, (napi_async_context)data);
-  // We cannot use NAPI_ASSERT_RETURN_VOID because we need to have a JS stack
-  // below in order to use exceptions.
-  assert(status == napi_ok);
-}
-
-static napi_value CreateAsyncResource(napi_env env, napi_callback_info info) {
-  napi_value object;
-  NAPI_CALL(env, napi_create_object(env, &object));
-
-  napi_value resource_name;
-  NAPI_CALL(env, napi_create_string_utf8(
-      env, "test_gcable", NAPI_AUTO_LENGTH, &resource_name));
-
-  napi_async_context context;
-  NAPI_CALL(env, napi_async_init(env, object, resource_name, &context));
-
-  NAPI_CALL(env, napi_add_finalizer(
-      env, object, (void*)context, AsyncDestroyCb, NULL, NULL));
-
-  return object;
-}
-
 static
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
@@ -76,11 +54,6 @@ napi_value Init(napi_env env, napi_value exports) {
       // NOLINTNEXTLINE (readability/null_usage)
       env, NULL, NAPI_AUTO_LENGTH, MakeCallback, NULL, &fn));
   NAPI_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
-  NAPI_CALL(env, napi_create_function(
-      // NOLINTNEXTLINE (readability/null_usage)
-      env, NULL, NAPI_AUTO_LENGTH, CreateAsyncResource, NULL, &fn));
-  NAPI_CALL(env, napi_set_named_property(
-      env, exports, "createAsyncResource", fn));
   return exports;
 }
 
diff --git a/test/node-api/test_make_callback/test-async-hooks.js b/test/node-api/test_make_callback/test-async-hooks.js
index 755a2389c6859147dcbb604a475ffd25b9f70e15..ca31ac4995ae5babc0b84b47aafd6c4f4663d582 100644
--- a/test/node-api/test_make_callback/test-async-hooks.js
+++ b/test/node-api/test_make_callback/test-async-hooks.js
@@ -33,7 +33,16 @@ const test_hook = async_hooks.createHook({
 });
 
 test_hook.enable();
-makeCallback(process, function() {});
+
+/**
+ * Resource should be able to be arbitrary objects without special internal
+ * slots. Testing with plain object here.
+ */
+const resource = {};
+makeCallback(resource, process, function cb() {
+  assert.strictEqual(this, process);
+  assert.strictEqual(async_hooks.executionAsyncResource(), resource);
+});
 
 assert.strictEqual(hook_result.init_called, true);
 assert.strictEqual(hook_result.before_called, true);
diff --git a/test/node-api/test_make_callback/test.js b/test/node-api/test_make_callback/test.js
index f409bbc9d127d69564e286e81759b07f60d2bd82..d0b4b22500c9f698ecd694947a8d833e7af72254 100644
--- a/test/node-api/test_make_callback/test.js
+++ b/test/node-api/test_make_callback/test.js
@@ -13,46 +13,51 @@ function myMultiArgFunc(arg1, arg2, arg3) {
   return 42;
 }
 
-assert.strictEqual(makeCallback(process, common.mustCall(function() {
+/**
+ * Resource should be able to be arbitrary objects without special internal
+ * slots. Testing with plain object here.
+ */
+const resource = {};
+assert.strictEqual(makeCallback(resource, process, common.mustCall(function() {
   assert.strictEqual(arguments.length, 0);
   assert.strictEqual(this, process);
   return 42;
 })), 42);
 
-assert.strictEqual(makeCallback(process, common.mustCall(function(x) {
+assert.strictEqual(makeCallback(resource, process, common.mustCall(function(x) {
   assert.strictEqual(arguments.length, 1);
   assert.strictEqual(this, process);
   assert.strictEqual(x, 1337);
   return 42;
 }), 1337), 42);
 
-assert.strictEqual(makeCallback(this,
+assert.strictEqual(makeCallback(resource, this,
                                 common.mustCall(myMultiArgFunc), 1, 2, 3), 42);
 
 // TODO(node-api): napi_make_callback needs to support
 // strings passed for the func argument
-/*
-const recv = {
-  one: common.mustCall(function() {
-    assert.strictEqual(0, arguments.length);
-    assert.strictEqual(this, recv);
-    return 42;
-  }),
-  two: common.mustCall(function(x) {
-    assert.strictEqual(1, arguments.length);
-    assert.strictEqual(this, recv);
-    assert.strictEqual(x, 1337);
-    return 42;
-  }),
-};
+//
+// const recv = {
+//   one: common.mustCall(function() {
+//     assert.strictEqual(0, arguments.length);
+//     assert.strictEqual(this, recv);
+//     return 42;
+//   }),
+//   two: common.mustCall(function(x) {
+//     assert.strictEqual(1, arguments.length);
+//     assert.strictEqual(this, recv);
+//     assert.strictEqual(x, 1337);
+//     return 42;
+//   }),
+// };
+//
+// assert.strictEqual(makeCallback(recv, 'one'), 42);
+// assert.strictEqual(makeCallback(recv, 'two', 1337), 42);
+//
+// // Check that callbacks on a receiver from a different context works.
+// const foreignObject = vm.runInNewContext('({ fortytwo() { return 42; } })');
+// assert.strictEqual(makeCallback(foreignObject, 'fortytwo'), 42);
 
-assert.strictEqual(makeCallback(recv, 'one'), 42);
-assert.strictEqual(makeCallback(recv, 'two', 1337), 42);
-
-// Check that callbacks on a receiver from a different context works.
-const foreignObject = vm.runInNewContext('({ fortytwo() { return 42; } })');
-assert.strictEqual(makeCallback(foreignObject, 'fortytwo'), 42);
-*/
 
 // Check that the callback is made in the context of the receiver.
 const target = vm.runInNewContext(`
@@ -62,7 +67,7 @@ const target = vm.runInNewContext(`
       return Object;
     })
 `);
-assert.notStrictEqual(makeCallback(process, target, Object), Object);
+assert.notStrictEqual(makeCallback(resource, process, target, Object), Object);
 
 // Runs in inner context.
 const forward = vm.runInNewContext(`
@@ -78,4 +83,4 @@ function endpoint($Object) {
   return Object;
 }
 
-assert.strictEqual(makeCallback(process, forward, endpoint), Object);
+assert.strictEqual(makeCallback(resource, process, forward, endpoint), Object);
diff --git a/test/node-api/test_make_callback_recurse/binding.cc b/test/node-api/test_make_callback_recurse/binding.c
similarity index 75%
rename from test/node-api/test_make_callback_recurse/binding.cc
rename to test/node-api/test_make_callback_recurse/binding.c
index 93440ee4ce54c21724b12a7f18f54c6c4de0381e..78f27e370babdebfc342f35edc5d3e37d11b21d3 100644
--- a/test/node-api/test_make_callback_recurse/binding.cc
+++ b/test/node-api/test_make_callback_recurse/binding.c
@@ -1,10 +1,7 @@
 #include <node_api.h>
 #include "../../js-native-api/common.h"
-#include <vector>
 
-namespace {
-
-napi_value MakeCallback(napi_env env, napi_callback_info info) {
+static napi_value MakeCallback(napi_env env, napi_callback_info info) {
   size_t argc = 2;
   napi_value args[2];
   // NOLINTNEXTLINE (readability/null_usage)
@@ -13,8 +10,8 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   napi_value recv = args[0];
   napi_value func = args[1];
 
-  napi_status status = napi_make_callback(env, nullptr /* async_context */,
-    recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
+  napi_status status = napi_make_callback(env, NULL /* async_context */,
+    recv, func, 0 /* argc */, NULL /* argv */, NULL /* result */);
 
   bool isExceptionPending;
   NAPI_CALL(env, napi_is_exception_pending(env, &isExceptionPending));
@@ -25,14 +22,14 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
     status = napi_get_and_clear_last_exception(env, &pending_error);
     NAPI_CALL(env,
       napi_throw_error((env),
-                        nullptr,
+                        NULL,
                         "error when only pending exception expected"));
   }
 
   return recv;
 }
 
-napi_value Init(napi_env env, napi_value exports) {
+static napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
   NAPI_CALL(env, napi_create_function(
       // NOLINTNEXTLINE (readability/null_usage)
@@ -41,6 +38,4 @@ napi_value Init(napi_env env, napi_value exports) {
   return exports;
 }
 
-}  // anonymous namespace
-
 NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/node-api/test_make_callback_recurse/binding.gyp b/test/node-api/test_make_callback_recurse/binding.gyp
index 7ede63d94a0d77635ff78b8ad2d0079216eefa1a..23daf507916ff6649e5abfe4c082daa2dcc8010b 100644
--- a/test/node-api/test_make_callback_recurse/binding.gyp
+++ b/test/node-api/test_make_callback_recurse/binding.gyp
@@ -3,7 +3,7 @@
     {
       'target_name': 'binding',
       'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
-      'sources': [ 'binding.cc' ]
+      'sources': [ 'binding.c' ]
     }
   ]
 }
diff --git a/test/node-api/test_policy/test_policy.js b/test/node-api/test_policy/test_policy.js
index b3f477567e37bafd7918869034c515a4d40f3a2d..b69dbded585891a45b110797c1f70f1fbb27ee11 100644
--- a/test/node-api/test_policy/test_policy.js
+++ b/test/node-api/test_policy/test_policy.js
@@ -44,7 +44,7 @@ function test(shouldFail, resources) {
   const { status, stdout, stderr } = spawnSync(process.execPath, [
     '--experimental-policy',
     policyFilepath,
-    depFilepath
+    depFilepath,
   ]);
 
   console.log(stdout.toString(), stderr.toString());
diff --git a/test/node-api/test_threadsafe_function/binding.c b/test/node-api/test_threadsafe_function/binding.c
index c9c526153804c60b5bd5844d2c2aacac7f0fb514..339e772aa7e0e67b2448b7c23f5d87002e082305 100644
--- a/test/node-api/test_threadsafe_function/binding.c
+++ b/test/node-api/test_threadsafe_function/binding.c
@@ -7,7 +7,7 @@
 #include <node_api.h>
 #include "../../js-native-api/common.h"
 
-#define ARRAY_LENGTH 10
+#define ARRAY_LENGTH 10000
 #define MAX_QUEUE_SIZE 2
 
 static uv_thread_t uv_threads[2];
@@ -72,7 +72,7 @@ static void data_source_thread(void* data) {
   for (index = ARRAY_LENGTH - 1; index > -1 && !queue_was_closing; index--) {
     status = napi_call_threadsafe_function(ts_fn, &ints[index],
         ts_fn_info->block_on_full);
-    if (ts_fn_info->max_queue_size == 0) {
+    if (ts_fn_info->max_queue_size == 0 && (index % 1000 == 0)) {
       // Let's make this thread really busy for 200 ms to give the main thread a
       // chance to abort.
       uint64_t start = uv_hrtime();
@@ -130,7 +130,7 @@ static void call_js(napi_env env, napi_value cb, void* hint, void* data) {
 }
 
 static napi_ref alt_ref;
-// Getting the data into JS with the alternative referece
+// Getting the data into JS with the alternative reference
 static void call_ref(napi_env env, napi_value _, void* hint, void* data) {
   if (!(env == NULL || alt_ref == NULL)) {
     napi_value fn, argv, undefined;
diff --git a/test/node-api/test_threadsafe_function/test.js b/test/node-api/test_threadsafe_function/test.js
index 3603d79ee6b5d36590503989d8168368eaf12b03..ff8a7d808490799c32c3b93c879e987d32ece185 100644
--- a/test/node-api/test_threadsafe_function/test.js
+++ b/test/node-api/test_threadsafe_function/test.js
@@ -36,7 +36,8 @@ function testWithJSMarshaller({
   quitAfter,
   abort,
   maxQueueSize,
-  launchSecondary }) {
+  launchSecondary,
+}) {
   return new Promise((resolve) => {
     const array = [];
     binding[threadStarter](function testCallback(value) {
@@ -210,6 +211,15 @@ new Promise(function testWithoutJSMarshaller(resolve) {
 }))
 .then((result) => assert.strictEqual(result.indexOf(0), -1))
 
+// Make sure that threadsafe function isn't stalled when we hit
+// `kMaxIterationCount` in `src/node_api.cc`
+.then(() => testWithJSMarshaller({
+  threadStarter: 'StartThreadNonblocking',
+  maxQueueSize: binding.ARRAY_LENGTH >>> 1,
+  quitAfter: binding.ARRAY_LENGTH
+}))
+.then((result) => assert.deepStrictEqual(result, expectedArray))
+
 // Start a child process to test rapid teardown
 .then(() => testUnref(binding.MAX_QUEUE_SIZE))
 
diff --git a/test/node-api/test_worker_buffer_callback/test_worker_buffer_callback.c b/test/node-api/test_worker_buffer_callback/test_worker_buffer_callback.c
index b327feaeb28878c60be8a0c246bb39a7c0e7d2be..b4f2e288ece31bb03e1fbb574bbd4e30470e1598 100644
--- a/test/node-api/test_worker_buffer_callback/test_worker_buffer_callback.c
+++ b/test/node-api/test_worker_buffer_callback/test_worker_buffer_callback.c
@@ -1,10 +1,10 @@
 #include <stdio.h>
+#include <stdlib.h>
 #include <node_api.h>
 #include <assert.h>
 #include "../../js-native-api/common.h"
 
 uint32_t free_call_count = 0;
-char data[] = "hello";
 
 napi_value GetFreeCallCount(napi_env env, napi_callback_info info) {
   napi_value value;
@@ -13,7 +13,7 @@ napi_value GetFreeCallCount(napi_env env, napi_callback_info info) {
 }
 
 static void finalize_cb(napi_env env, void* finalize_data, void* hint) {
-  assert(finalize_data == data);
+  free(finalize_data);
   free_call_count++;
 }
 
@@ -29,6 +29,9 @@ NAPI_MODULE_INIT() {
   // rather than a Node.js Buffer, since testing the latter would only test
   // the same code paths and not the ones specific to N-API.
   napi_value buffer;
+
+  char* data = malloc(sizeof(char));
+
   NAPI_CALL(env, napi_create_external_arraybuffer(
       env,
       data,
diff --git a/test/node-api/test_worker_terminate_finalization/test.js b/test/node-api/test_worker_terminate_finalization/test.js
index 171a32b812334f1a726782b1825dd5c875d0bb71..937079968f722afced144f3e1735e254d566a5c0 100644
--- a/test/node-api/test_worker_terminate_finalization/test.js
+++ b/test/node-api/test_worker_terminate_finalization/test.js
@@ -1,11 +1,9 @@
 'use strict';
 const common = require('../../common');
 
-// TODO(addaleax): Run this test once it stops failing under ASAN/valgrind.
 // Refs: https://github.com/nodejs/node/issues/34731
 // Refs: https://github.com/nodejs/node/pull/35777
 // Refs: https://github.com/nodejs/node/issues/35778
-common.skip('Reference management in N-API leaks memory');
 
 const { Worker, isMainThread } = require('worker_threads');
 
diff --git a/test/overlapped-checker/main_unix.c b/test/overlapped-checker/main_unix.c
new file mode 100644
index 0000000000000000000000000000000000000000..9d3d83af0f1068a5e239eda14d23060a2dca2bab
--- /dev/null
+++ b/test/overlapped-checker/main_unix.c
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <errno.h>
+#include <unistd.h>
+
+static size_t r(char* buf, size_t buf_size) {
+  ssize_t read_count;
+  do
+    read_count = read(0, buf, buf_size);
+  while (read_count < 0 && errno == EINTR);
+  if (read_count <= 0)
+    abort();
+  return (size_t)read_count;
+}
+
+static void w(const char* buf, size_t count) {
+  const char* end = buf + count;
+
+  while (buf < end) {
+    ssize_t write_count;
+    do
+      write_count = write(1, buf, count);
+    while (write_count < 0 && errno == EINTR);
+    if (write_count <= 0)
+      abort();
+    buf += write_count;
+  }
+
+  fprintf(stderr, "%zu", count);
+  fflush(stderr);
+}
+
+int main(void) {
+  w("0", 1);
+
+  while (1) {
+    char buf[256];
+    size_t read_count = r(buf, sizeof(buf));
+    // The JS part (test-child-process-stdio-overlapped.js) only writes the
+    // "exit" string when the buffer is empty, so the read is guaranteed to be
+    // atomic due to it being less than PIPE_BUF.
+    if (!strncmp(buf, "exit", read_count)) {
+      break;
+    }
+    w(buf, read_count);
+  }
+
+  return 0;
+}
diff --git a/test/overlapped-checker/main_win.c b/test/overlapped-checker/main_win.c
new file mode 100644
index 0000000000000000000000000000000000000000..c38b7febe6ddc5f8d9b3716cee21cec202a1d2e5
--- /dev/null
+++ b/test/overlapped-checker/main_win.c
@@ -0,0 +1,85 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <windows.h>
+
+static char buf[256];
+static DWORD read_count;
+static DWORD write_count;
+static HANDLE stdin_h;
+static OVERLAPPED stdin_o;
+
+static void die(const char* buf) {
+  fprintf(stderr, "%s\n", buf);
+  fflush(stderr);
+  exit(100);
+}
+
+static void overlapped_read(void) {
+  if (ReadFile(stdin_h, buf, sizeof(buf), NULL, &stdin_o)) {
+    // Since we start the read operation immediately before requesting a write,
+    // it should never complete synchronously since no data would be available
+    die("read completed synchronously");
+  }
+  if (GetLastError() != ERROR_IO_PENDING) {
+    die("overlapped read failed");
+  }
+}
+
+static void write(const char* buf, size_t buf_size) {
+  overlapped_read();
+  DWORD write_count;
+  HANDLE stdout_h = GetStdHandle(STD_OUTPUT_HANDLE);
+  if (!WriteFile(stdout_h, buf, buf_size, &write_count, NULL)) {
+    die("overlapped write failed");
+  }
+  fprintf(stderr, "%d", write_count);
+  fflush(stderr);
+}
+
+int main(void) {
+  HANDLE event = CreateEvent(NULL, FALSE, FALSE, NULL);
+  if (event == NULL) {
+    die("failed to create event handle");
+  }
+
+  stdin_h = GetStdHandle(STD_INPUT_HANDLE);
+  stdin_o.hEvent = event;
+
+  write("0", 1);
+
+  while (1) {
+    DWORD result = WaitForSingleObject(event, INFINITE);
+    if (result == WAIT_OBJECT_0) {
+      if (!GetOverlappedResult(stdin_h, &stdin_o, &read_count, FALSE)) {
+        die("failed to get overlapped read result");
+      }
+      if (strncmp(buf, "exit", read_count) == 0) {
+        break;
+      }
+      write(buf, read_count);
+    } else {
+      char emsg[0xfff];
+      int ecode = GetLastError();
+      DWORD rv = FormatMessage(
+          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+          NULL,
+          ecode,
+          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+          (LPSTR)emsg,
+          sizeof(emsg),
+          NULL);
+      if (rv > 0) {
+        snprintf(emsg, sizeof(emsg),
+            "WaitForSingleObject failed. Error %d (%s)", ecode, emsg);
+      } else {
+        snprintf(emsg, sizeof(emsg),
+            "WaitForSingleObject failed. Error %d", ecode);
+      }
+      die(emsg);
+    }
+  }
+
+  return 0;
+}
diff --git a/test/parallel/parallel.status b/test/parallel/parallel.status
index 811fb9a9c6f985d9301499b2dcbc766468b750a9..6ccc9e625fdc845fd689a7f5212e1e735b9b3659 100644
--- a/test/parallel/parallel.status
+++ b/test/parallel/parallel.status
@@ -7,32 +7,18 @@ prefix parallel
 [true] # This section applies to all platforms
 
 [$system==win32]
-# https://github.com/nodejs/node/issues/20750
-test-http2-client-upload: PASS,FLAKY
-# https://github.com/nodejs/node/issues/20750
-test-http2-client-upload-reject: PASS,FLAKY
-# https://github.com/nodejs/node/issues/30847
-test-http2-compat-client-upload-reject: PASS,FLAKY
-# https://github.com/nodejs/node/issues/30845
-test-http2-multistream-destroy-on-read-tls: PASS,FLAKY
-# https://github.com/nodejs/node/issues/20750
-test-http2-pipe: PASS,FLAKY
-# https://github.com/nodejs/node/issues/20750
-test-stream-pipeline-http2: PASS,FLAKY
 # https://github.com/nodejs/node/issues/24497
 test-timers-immediate-queue: PASS,FLAKY
 # https://github.com/nodejs/node/issues/23277
 test-worker-memory: PASS,FLAKY
-# https://github.com/nodejs/node/issues/30846
-test-worker-message-port-transfer-terminate: PASS,FLAKY
 
 [$system==linux]
+# https://github.com/nodejs/node/issues/39368
+test-domain-error-types: PASS,FLAKY
 
 [$system==macos]
 
 [$arch==arm || $arch==arm64]
-# https://github.com/nodejs/node/issues/26610
-test-async-hooks-http-parser-destroy: PASS,FLAKY
 # https://github.com/nodejs/node/pull/31178
 test-crypto-dh-stateless: SKIP
 test-crypto-keygen: SKIP
@@ -71,3 +57,7 @@ test-net-write-after-end-nt: SKIP
 test-tls-env-extra-ca: SKIP
 # https://github.com/nodejs/node/pull/34209
 test-dgram-error-message-address: SKIP
+# https://github.com/nodejs/node/issues/36929
+test-crypto-secure-heap: SKIP
+# https://github.com/nodejs/node/issues/36925
+test-fs-read-type: SKIP
diff --git a/test/parallel/test-abortcontroller.js b/test/parallel/test-abortcontroller.js
new file mode 100644
index 0000000000000000000000000000000000000000..049dc72b93995a2c9a30ff2139d9ca45e5dc41c6
--- /dev/null
+++ b/test/parallel/test-abortcontroller.js
@@ -0,0 +1,144 @@
+// Flags: --no-warnings --expose-internals --experimental-abortcontroller
+'use strict';
+
+const common = require('../common');
+const { inspect } = require('util');
+
+const { ok, strictEqual, throws } = require('assert');
+const { Event } = require('internal/event_target');
+
+{
+  // Tests that abort is fired with the correct event type on AbortControllers
+  const ac = new AbortController();
+  ok(ac.signal);
+  ac.signal.onabort = common.mustCall((event) => {
+    ok(event);
+    strictEqual(event.type, 'abort');
+  });
+  ac.signal.addEventListener('abort', common.mustCall((event) => {
+    ok(event);
+    strictEqual(event.type, 'abort');
+  }), { once: true });
+  ac.abort();
+  ac.abort();
+  ok(ac.signal.aborted);
+}
+
+{
+  // Tests that abort events are trusted
+  const ac = new AbortController();
+  ac.signal.addEventListener('abort', common.mustCall((event) => {
+    ok(event.isTrusted);
+  }));
+  ac.abort();
+}
+
+{
+  // Tests that abort events have the same `isTrusted` reference
+  const first = new AbortController();
+  const second = new AbortController();
+  let ev1, ev2;
+  const ev3 = new Event('abort');
+  first.signal.addEventListener('abort', common.mustCall((event) => {
+    ev1 = event;
+  }));
+  second.signal.addEventListener('abort', common.mustCall((event) => {
+    ev2 = event;
+  }));
+  first.abort();
+  second.abort();
+  const firstTrusted = Reflect.getOwnPropertyDescriptor(ev1, 'isTrusted').get;
+  const secondTrusted = Reflect.getOwnPropertyDescriptor(ev2, 'isTrusted').get;
+  const untrusted = Reflect.getOwnPropertyDescriptor(ev3, 'isTrusted').get;
+  strictEqual(firstTrusted, secondTrusted);
+  strictEqual(untrusted, firstTrusted);
+}
+
+{
+  // Tests that AbortSignal is impossible to construct manually
+  const ac = new AbortController();
+  throws(
+    () => new ac.signal.constructor(),
+    /^TypeError: Illegal constructor$/
+  );
+}
+{
+  // Symbol.toStringTag
+  const toString = (o) => Object.prototype.toString.call(o);
+  const ac = new AbortController();
+  strictEqual(toString(ac), '[object AbortController]');
+  strictEqual(toString(ac.signal), '[object AbortSignal]');
+}
+
+{
+  const signal = AbortSignal.abort();
+  ok(signal.aborted);
+}
+
+{
+  // Test that AbortController properties and methods validate the receiver
+  const acSignalGet = Object.getOwnPropertyDescriptor(
+    AbortController.prototype,
+    'signal'
+  ).get;
+  const acAbort = AbortController.prototype.abort;
+
+  const goodController = new AbortController();
+  ok(acSignalGet.call(goodController));
+  acAbort.call(goodController);
+
+  const badAbortControllers = [
+    null,
+    undefined,
+    0,
+    NaN,
+    true,
+    'AbortController',
+    Object.create(AbortController.prototype),
+  ];
+  for (const badController of badAbortControllers) {
+    throws(
+      () => acSignalGet.call(badController),
+      { code: 'ERR_INVALID_THIS', name: 'TypeError' }
+    );
+    throws(
+      () => acAbort.call(badController),
+      { code: 'ERR_INVALID_THIS', name: 'TypeError' }
+    );
+  }
+}
+
+{
+  // Test that AbortSignal properties validate the receiver
+  const signalAbortedGet = Object.getOwnPropertyDescriptor(
+    AbortSignal.prototype,
+    'aborted'
+  ).get;
+
+  const goodSignal = new AbortController().signal;
+  strictEqual(signalAbortedGet.call(goodSignal), false);
+
+  const badAbortSignals = [
+    null,
+    undefined,
+    0,
+    NaN,
+    true,
+    'AbortSignal',
+    Object.create(AbortSignal.prototype),
+  ];
+  for (const badSignal of badAbortSignals) {
+    throws(
+      () => signalAbortedGet.call(badSignal),
+      { code: 'ERR_INVALID_THIS', name: 'TypeError' }
+    );
+  }
+}
+
+{
+  const ac = new AbortController();
+  strictEqual(inspect(ac, { depth: 1 }),
+              'AbortController { signal: [AbortSignal] }');
+  strictEqual(inspect(ac, { depth: null }),
+              'AbortController { signal: AbortSignal { aborted: false } }');
+}
diff --git a/test/parallel/test-accessor-properties.js b/test/parallel/test-accessor-properties.js
index a84889d617b4ad6cc863d9d9e2cc4e389bb43b1e..ae7919ea318c093b61f3bc9296a1a6eaf588d33f 100644
--- a/test/parallel/test-accessor-properties.js
+++ b/test/parallel/test-accessor-properties.js
@@ -17,7 +17,7 @@ const UDP = internalBinding('udp_wrap').UDP;
 {
   // Should throw instead of raise assertions
   assert.throws(() => {
-    UDP.prototype.fd;
+    UDP.prototype.fd; // eslint-disable-line no-unused-expressions
   }, TypeError);
 
   const StreamWrapProto = Object.getPrototypeOf(TTY.prototype);
@@ -26,7 +26,7 @@ const UDP = internalBinding('udp_wrap').UDP;
   properties.forEach((property) => {
     // Should throw instead of raise assertions
     assert.throws(() => {
-      TTY.prototype[property];
+      TTY.prototype[property]; // eslint-disable-line no-unused-expressions
     }, TypeError, `Missing expected TypeError for TTY.prototype.${property}`);
 
     // Should not throw for Object.getOwnPropertyDescriptor
@@ -42,6 +42,7 @@ const UDP = internalBinding('udp_wrap').UDP;
     const crypto = internalBinding('crypto');
 
     assert.throws(() => {
+      // eslint-disable-next-line no-unused-expressions
       crypto.SecureContext.prototype._external;
     }, TypeError);
 
diff --git a/test/parallel/test-arm-math-illegal-instruction.js b/test/parallel/test-arm-math-illegal-instruction.js
index 2c4cdd263018a06a880afcda3d51fa1507361601..4bf881d1b385a39500bc0920dcc469b2cc60c805 100644
--- a/test/parallel/test-arm-math-illegal-instruction.js
+++ b/test/parallel/test-arm-math-illegal-instruction.js
@@ -6,30 +6,10 @@ require('../common');
 // See https://github.com/nodejs/node/issues/1376
 // and https://code.google.com/p/v8/issues/detail?id=4019
 
-Math.abs(-0.5);
-Math.acos(-0.5);
-Math.acosh(-0.5);
-Math.asin(-0.5);
-Math.asinh(-0.5);
-Math.atan(-0.5);
-Math.atanh(-0.5);
-Math.cbrt(-0.5);
-Math.ceil(-0.5);
-Math.cos(-0.5);
-Math.cosh(-0.5);
-Math.exp(-0.5);
-Math.expm1(-0.5);
-Math.floor(-0.5);
-Math.fround(-0.5);
-Math.log(-0.5);
-Math.log10(-0.5);
-Math.log1p(-0.5);
-Math.log2(-0.5);
-Math.round(-0.5);
-Math.sign(-0.5);
-Math.sin(-0.5);
-Math.sinh(-0.5);
-Math.sqrt(-0.5);
-Math.tan(-0.5);
-Math.tanh(-0.5);
-Math.trunc(-0.5);
+// Iterate over all Math functions
+Object.getOwnPropertyNames(Math).forEach((functionName) => {
+  if (!/[A-Z]/.test(functionName)) {
+    // The function names don't have capital letters.
+    Math[functionName](-0.5);
+  }
+});
diff --git a/test/parallel/test-assert-async.js b/test/parallel/test-assert-async.js
index 0459145b31c6c232506145b8be69647b349d852e..dd98c0a23339ec9bd0d623a3c1191d672c460826 100644
--- a/test/parallel/test-assert-async.js
+++ b/test/parallel/test-assert-async.js
@@ -66,6 +66,22 @@ const invalidThenableFunc = () => {
       code: 'ERR_INVALID_RETURN_VALUE'
     })
   );
+
+  const err = new Error('foobar');
+  const validate = () => { return 'baz'; };
+  promises.push(assert.rejects(
+    () => assert.rejects(Promise.reject(err), validate),
+    {
+      message: 'The "validate" validation function is expected to ' +
+               "return \"true\". Received 'baz'\n\nCaught error:\n\n" +
+               'Error: foobar',
+      code: 'ERR_ASSERTION',
+      actual: err,
+      expected: validate,
+      name: 'AssertionError',
+      operator: 'rejects',
+    }
+  ));
 }
 
 {
diff --git a/test/parallel/test-assert-calltracker-calls.js b/test/parallel/test-assert-calltracker-calls.js
index 4de23d4658468a88b1e6c2b208f45dc2e2967a77..99db4ee284be81d120a6efb4a67a2514ec77e223 100644
--- a/test/parallel/test-assert-calltracker-calls.js
+++ b/test/parallel/test-assert-calltracker-calls.js
@@ -64,3 +64,17 @@ assert.throws(
   () => callsfunc(),
   { message: msg }
 );
+
+{
+  const tracker = new assert.CallTracker();
+  const callsNoop = tracker.calls(1);
+  callsNoop();
+  tracker.verify();
+}
+
+{
+  const tracker = new assert.CallTracker();
+  const callsNoop = tracker.calls(undefined, 1);
+  callsNoop();
+  tracker.verify();
+}
diff --git a/test/parallel/test-assert-calltracker-report.js b/test/parallel/test-assert-calltracker-report.js
index 79186c88fd058b37bdef7c1b3d15019896fd09ec..87ef0bff17fc0bf0c1847e30cdb02f0f77ee5396 100644
--- a/test/parallel/test-assert-calltracker-report.js
+++ b/test/parallel/test-assert-calltracker-report.js
@@ -11,22 +11,16 @@ function foo() {}
 const callsfoo = tracker.calls(foo, 1);
 
 // Ensures that foo was added to the callChecks array.
-if (tracker.report()[0].operator !== 'foo') {
-  process.exit(1);
-}
+assert.strictEqual(tracker.report()[0].operator, 'foo');
 
 callsfoo();
 
 // Ensures that foo was removed from the callChecks array after being called the
 // expected number of times.
-if (typeof tracker.report()[0] === undefined) {
-  process.exit(1);
-}
+assert.strictEqual(typeof tracker.report()[0], 'undefined');
 
 callsfoo();
 
 // Ensures that foo was added back to the callChecks array after being called
 // more than the expected number of times.
-if (tracker.report()[0].operator !== 'foo') {
-  process.exit(1);
-}
+assert.strictEqual(tracker.report()[0].operator, 'foo');
diff --git a/test/parallel/test-assert-deep.js b/test/parallel/test-assert-deep.js
index cc3132d55ecdb99f018071d867300359b64dec03..c74ca48d26cb74de3761159385202ba147eacd60 100644
--- a/test/parallel/test-assert-deep.js
+++ b/test/parallel/test-assert-deep.js
@@ -164,7 +164,7 @@ assert.throws(
     new Int32Array([1]), // Int32Array
     new Uint32Array([1]), // Uint32Array
     Buffer.from([1]), // Uint8Array
-    (function() { return arguments; })(1)
+    (function() { return arguments; })(1),
   ]);
 
   for (const a of similar) {
@@ -524,7 +524,7 @@ assertNotDeepOrStrict(
     {
       code: 'ERR_ASSERTION',
       message: `${defaultMsgStartFull}\n\n` +
-               "  Map {\n+   1 => 1\n-   1 => '1'\n  }"
+               "  Map(1) {\n+   1 => 1\n-   1 => '1'\n  }"
     }
   );
 }
@@ -590,10 +590,9 @@ assertNotDeepOrStrict(
 }
 
 // Handle NaN
-assert.notDeepEqual(NaN, NaN);
-assert.deepStrictEqual(NaN, NaN);
-assert.deepStrictEqual({ a: NaN }, { a: NaN });
-assert.deepStrictEqual([ 1, 2, NaN, 4 ], [ 1, 2, NaN, 4 ]);
+assertDeepAndStrictEqual(NaN, NaN);
+assertDeepAndStrictEqual({ a: NaN }, { a: NaN });
+assertDeepAndStrictEqual([ 1, 2, NaN, 4 ], [ 1, 2, NaN, 4 ]);
 
 // Handle boxed primitives
 {
@@ -1195,3 +1194,13 @@ assert.throws(
   Object.setPrototypeOf(b, null);
   assertNotDeepOrStrict(a, b, assert.AssertionError);
 }
+
+{
+  // Verify commutativity
+  // Regression test for https://github.com/nodejs/node/issues/37710
+  const a = { x: 1 };
+  const b = { y: 1 };
+  Object.defineProperty(b, 'x', { value: 1 });
+
+  assertNotDeepOrStrict(a, b);
+}
diff --git a/test/parallel/test-assert-typedarray-deepequal.js b/test/parallel/test-assert-typedarray-deepequal.js
index 6be4c10595ab4591defe1578981e622a553aad5a..a31da2739af93e54dd90c6934de30b39c7f2a725 100644
--- a/test/parallel/test-assert-typedarray-deepequal.js
+++ b/test/parallel/test-assert-typedarray-deepequal.js
@@ -25,12 +25,12 @@ const equalArrayPairs = [
   [new Uint16Array([1, 2, 3, 4]).subarray(1), new Uint16Array([2, 3, 4])],
   [new Uint32Array([1, 2, 3, 4]).subarray(1, 3), new Uint32Array([2, 3])],
   [new ArrayBuffer(3), new ArrayBuffer(3)],
-  [new SharedArrayBuffer(3), new SharedArrayBuffer(3)]
+  [new SharedArrayBuffer(3), new SharedArrayBuffer(3)],
 ];
 
 const looseEqualArrayPairs = [
   [new Float32Array([+0.0]), new Float32Array([-0.0])],
-  [new Float64Array([+0.0]), new Float64Array([-0.0])]
+  [new Float64Array([+0.0]), new Float64Array([-0.0])],
 ];
 
 const notEqualArrayPairs = [
@@ -52,15 +52,15 @@ const notEqualArrayPairs = [
   [new Uint8Array([1, 2, 3]).buffer, new Uint8Array([4, 5, 6]).buffer],
   [
     new Uint8Array(new SharedArrayBuffer(3)).fill(1).buffer,
-    new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer
+    new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer,
   ],
   [new ArrayBuffer(2), new ArrayBuffer(3)],
   [new SharedArrayBuffer(2), new SharedArrayBuffer(3)],
   [new ArrayBuffer(2), new SharedArrayBuffer(3)],
   [
     new Uint8Array(new ArrayBuffer(3)).fill(1).buffer,
-    new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer
-  ]
+    new Uint8Array(new SharedArrayBuffer(3)).fill(2).buffer,
+  ],
 ];
 
 equalArrayPairs.forEach((arrayPair) => {
diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js
index 95351a1c9304394567ab7f6a6c29a8f29b7bd818..80a55094b73ecff3225fb3a65bfabbd12b283dc6 100644
--- a/test/parallel/test-assert.js
+++ b/test/parallel/test-assert.js
@@ -25,6 +25,7 @@
 const common = require('../common');
 const assert = require('assert');
 const { inspect } = require('util');
+const vm = require('vm');
 const { internalBinding } = require('internal/test/binding');
 const a = assert;
 
@@ -123,16 +124,19 @@ assert.throws(() => thrower(a.AssertionError));
 assert.throws(() => thrower(TypeError));
 
 // When passing a type, only catch errors of the appropriate type.
-{
-  let threw = false;
-  try {
-    a.throws(() => thrower(TypeError), a.AssertionError);
-  } catch (e) {
-    threw = true;
-    assert.ok(e instanceof TypeError, 'type');
+assert.throws(
+  () => a.throws(() => thrower(TypeError), a.AssertionError),
+  {
+    generatedMessage: true,
+    actual: new TypeError({}),
+    expected: a.AssertionError,
+    code: 'ERR_ASSERTION',
+    name: 'AssertionError',
+    operator: 'throws',
+    message: 'The error is expected to be an instance of "AssertionError". ' +
+             'Received "TypeError"\n\nError message:\n\n[object Object]'
   }
-  assert.ok(threw, 'a.throws with an explicit error is eating extra errors');
-}
+);
 
 // doesNotThrow should pass through all errors.
 {
@@ -237,20 +241,27 @@ a.throws(() => thrower(TypeError), (err) => {
 
 // https://github.com/nodejs/node/issues/3188
 {
-  let threw = false;
-  let AnotherErrorType;
-  try {
-    const ES6Error = class extends Error {};
-    AnotherErrorType = class extends Error {};
-
-    assert.throws(() => { throw new AnotherErrorType('foo'); }, ES6Error);
-  } catch (e) {
-    threw = true;
-    assert(e instanceof AnotherErrorType,
-           `expected AnotherErrorType, received ${e}`);
-  }
+  let actual;
+  assert.throws(
+    () => {
+      const ES6Error = class extends Error {};
+      const AnotherErrorType = class extends Error {};
 
-  assert.ok(threw);
+      assert.throws(() => {
+        actual = new AnotherErrorType('foo');
+        throw actual;
+      }, ES6Error);
+    },
+    (err) => {
+      assert.strictEqual(
+        err.message,
+        'The error is expected to be an instance of "ES6Error". ' +
+          'Received "AnotherErrorType"\n\nError message:\n\nfoo'
+      );
+      assert.strictEqual(err.actual, actual);
+      return true;
+    }
+  );
 }
 
 // Check messages from assert.throws().
@@ -335,15 +346,15 @@ testShortAssertionMessage(0, '0');
 testShortAssertionMessage(Symbol(), 'Symbol()');
 testShortAssertionMessage(undefined, 'undefined');
 testShortAssertionMessage(-Infinity, '-Infinity');
-testShortAssertionMessage(function() {}, '[Function]');
 testAssertionMessage([], '[]');
 testAssertionMessage(/a/, '/a/');
 testAssertionMessage(/abc/gim, '/abc/gim');
 testAssertionMessage({}, '{}');
 testAssertionMessage([1, 2, 3], '[\n+   1,\n+   2,\n+   3\n+ ]');
 testAssertionMessage(function f() {}, '[Function: f]');
+testAssertionMessage(function() {}, '[Function (anonymous)]');
 testAssertionMessage(circular,
-                     '{\n+   x: [Circular],\n+   y: 1\n+ }');
+                     '<ref *1> {\n+   x: [Circular *1],\n+   y: 1\n+ }');
 testAssertionMessage({ a: undefined, b: null },
                      '{\n+   a: undefined,\n+   b: null\n+ }');
 testAssertionMessage({ a: NaN, b: Infinity, c: -Infinity },
@@ -490,6 +501,12 @@ assert.throws(
   }
 );
 
+a.equal(NaN, NaN);
+a.throws(
+  () => a.notEqual(NaN, NaN),
+  a.AssertionError
+);
+
 // Test strict assert.
 {
   const a = require('assert');
@@ -575,7 +592,7 @@ assert.throws(
     '...',
     '    1,',
     '    1',
-    '  ]'
+    '  ]',
   ].join('\n');
   assert.throws(
     () => assert.deepEqual(
@@ -596,7 +613,7 @@ assert.throws(
     '    1,',
     '    1,',
     '    1',
-    '  ]'
+    '  ]',
   ].join('\n');
   assert.throws(
     () => assert.deepEqual(
@@ -617,7 +634,7 @@ assert.throws(
     '    0,',
     '+   1,',
     '    1',
-    '  ]'
+    '  ]',
   ].join('\n');
   assert.throws(
     () => assert.deepEqual(
@@ -648,7 +665,7 @@ assert.throws(
     '+   1,',
     '    2,',
     '    1',
-    '  ]'
+    '  ]',
   ].join('\n');
   assert.throws(
     () => assert.deepEqual([1, 2, 1], [2, 1]),
@@ -676,7 +693,7 @@ assert.throws(
     '\n' +
     '+ {}\n' +
     '- {\n' +
-    '-   [Symbol(nodejs.util.inspect.custom)]: [Function],\n' +
+    '-   [Symbol(nodejs.util.inspect.custom)]: [Function (anonymous)],\n' +
     "-   loop: 'forever'\n" +
     '- }'
   });
@@ -929,7 +946,7 @@ assert.throws(
 [
   1,
   false,
-  Symbol()
+  Symbol(),
 ].forEach((input) => {
   assert.throws(
     () => assert.throws(() => {}, input),
@@ -1265,7 +1282,7 @@ assert.throws(
 );
 
 assert.throws(
-  () => a.notStrictEqual(5n),
+  () => a.notStrictEqual(5n), // eslint-disable-line no-restricted-syntax
   { code: 'ERR_MISSING_ARGS' }
 );
 
@@ -1302,6 +1319,55 @@ assert.throws(
   })();
 }
 
+assert.throws(
+  () => assert.throws(() => { throw Symbol('foo'); }, RangeError),
+  {
+    message: 'The error is expected to be an instance of "RangeError". ' +
+             'Received "Symbol(foo)"'
+  }
+);
+
+assert.throws(
+  // eslint-disable-next-line no-throw-literal
+  () => assert.throws(() => { throw [1, 2]; }, RangeError),
+  {
+    message: 'The error is expected to be an instance of "RangeError". ' +
+             'Received "[Array]"'
+  }
+);
+
+{
+  const err = new TypeError('foo');
+  const validate = (() => () => ({ a: true, b: [ 1, 2, 3 ] }))();
+  assert.throws(
+    () => assert.throws(() => { throw err; }, validate),
+    {
+      message: 'The validation function is expected to ' +
+              `return "true". Received ${inspect(validate())}\n\nCaught ` +
+              `error:\n\n${err}`,
+      code: 'ERR_ASSERTION',
+      actual: err,
+      expected: validate,
+      name: 'AssertionError',
+      operator: 'throws',
+    }
+  );
+}
+
+assert.throws(
+  () => {
+    const script = new vm.Script('new RangeError("foobar");');
+    const context = vm.createContext();
+    const err = script.runInContext(context);
+    assert.throws(() => { throw err; }, RangeError);
+  },
+  {
+    message: 'The error is expected to be an instance of "RangeError". ' +
+             'Received an error with identical name but a different ' +
+             'prototype.\n\nError message:\n\nfoobar'
+  }
+);
+
 // Multiple assert.match() tests.
 {
   assert.throws(
diff --git a/test/parallel/test-async-hooks-correctly-switch-promise-hook.js b/test/parallel/test-async-hooks-correctly-switch-promise-hook.js
new file mode 100644
index 0000000000000000000000000000000000000000..73127f1ebaf94cfed474604e0aca9be136568ac2
--- /dev/null
+++ b/test/parallel/test-async-hooks-correctly-switch-promise-hook.js
@@ -0,0 +1,77 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+
+// Regression test for:
+// - https://github.com/nodejs/node/issues/38814
+// - https://github.com/nodejs/node/issues/38815
+
+const layers = new Map();
+
+// Only init to start context-based promise hook
+async_hooks.createHook({
+  init(asyncId, type) {
+    layers.set(asyncId, {
+      type,
+      init: true,
+      before: false,
+      after: false,
+      promiseResolve: false
+    });
+  },
+  before(asyncId) {
+    if (layers.has(asyncId)) {
+      layers.get(asyncId).before = true;
+    }
+  },
+  after(asyncId) {
+    if (layers.has(asyncId)) {
+      layers.get(asyncId).after = true;
+    }
+  },
+  promiseResolve(asyncId) {
+    if (layers.has(asyncId)) {
+      layers.get(asyncId).promiseResolve = true;
+    }
+  }
+}).enable();
+
+// With destroy, this should switch to native
+// and disable context - based promise hook
+async_hooks.createHook({
+  init() { },
+  destroy() { }
+}).enable();
+
+async function main() {
+  return Promise.resolve();
+}
+
+main();
+
+process.on('exit', () => {
+  assert.deepStrictEqual(Array.from(layers.values()), [
+    {
+      type: 'PROMISE',
+      init: true,
+      before: true,
+      after: true,
+      promiseResolve: true
+    },
+    {
+      type: 'PROMISE',
+      init: true,
+      before: false,
+      after: false,
+      promiseResolve: true
+    },
+    {
+      type: 'PROMISE',
+      init: true,
+      before: true,
+      after: true,
+      promiseResolve: true
+    },
+  ]);
+});
diff --git a/test/parallel/test-async-hooks-enable-before-promise-resolve.js b/test/parallel/test-async-hooks-enable-before-promise-resolve.js
new file mode 100644
index 0000000000000000000000000000000000000000..c96c9e5dd966552634de26029d375a484ffb587f
--- /dev/null
+++ b/test/parallel/test-async-hooks-enable-before-promise-resolve.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+
+// This test ensures that fast-path PromiseHook assigns async ids
+// to already created promises when the native hook function is
+// triggered on before event.
+
+let initialAsyncId;
+const promise = new Promise((resolve) => {
+  setTimeout(() => {
+    initialAsyncId = async_hooks.executionAsyncId();
+    async_hooks.createHook({
+      after: common.mustCall(() => {}, 2)
+    }).enable();
+    resolve();
+  }, 0);
+});
+
+promise.then(common.mustCall(() => {
+  const id = async_hooks.executionAsyncId();
+  assert.notStrictEqual(id, initialAsyncId);
+  assert.ok(id > 0);
+}));
diff --git a/test/parallel/test-async-hooks-fatal-error.js b/test/parallel/test-async-hooks-fatal-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..40c2edf329df6e1031f22c6eec822d167255e670
--- /dev/null
+++ b/test/parallel/test-async-hooks-fatal-error.js
@@ -0,0 +1,53 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const childProcess = require('child_process');
+const os = require('os');
+
+if (process.argv[2] === 'child') {
+  child(process.argv[3], process.argv[4]);
+} else {
+  main();
+}
+
+function child(type, valueType) {
+  const { createHook } = require('async_hooks');
+  const fs = require('fs');
+
+  createHook({
+    [type]() {
+      if (valueType === 'symbol') {
+        throw Symbol('foo');
+      }
+      // eslint-disable-next-line no-throw-literal
+      throw null;
+    }
+  }).enable();
+
+  // Trigger `promiseResolve`.
+  new Promise((resolve) => resolve())
+  // Trigger `after`/`destroy`.
+    .then(() => fs.promises.readFile(__filename, 'utf8'))
+  // Make process exit with code 0 if no error caught.
+    .then(() => process.exit(0));
+}
+
+function main() {
+  const types = [ 'init', 'before', 'after', 'destroy', 'promiseResolve' ];
+  const valueTypes = [
+    [ 'null', 'Error: null' ],
+    [ 'symbol', 'Error: Symbol(foo)' ],
+  ];
+  for (const type of types) {
+    for (const [valueType, expect] of valueTypes) {
+      const cp = childProcess.spawnSync(
+        process.execPath,
+        [ __filename, 'child', type, valueType ],
+        {
+          encoding: 'utf8',
+        });
+      assert.strictEqual(cp.status, 1, type);
+      assert.strictEqual(cp.stderr.trim().split(os.EOL)[0], expect, type);
+    }
+  }
+}
diff --git a/test/parallel/test-async-hooks-promise.js b/test/parallel/test-async-hooks-promise.js
index 637d287b506ba965576302f67422555142123fe6..9db510e329ffadbfbcf29d434daed750fbbb0883 100644
--- a/test/parallel/test-async-hooks-promise.js
+++ b/test/parallel/test-async-hooks-promise.js
@@ -24,6 +24,4 @@ const a = Promise.resolve(42);
 a.then(common.mustCall());
 
 assert.strictEqual(initCalls[0].triggerId, 1);
-assert.strictEqual(initCalls[0].resource.isChainedPromise, false);
 assert.strictEqual(initCalls[1].triggerId, initCalls[0].id);
-assert.strictEqual(initCalls[1].resource.isChainedPromise, true);
diff --git a/test/parallel/test-async-hooks-run-in-async-scope-this-arg.js b/test/parallel/test-async-hooks-run-in-async-scope-this-arg.js
new file mode 100644
index 0000000000000000000000000000000000000000..a5016da9d5fcd3a5a9872fa528ed1ce09afb2683
--- /dev/null
+++ b/test/parallel/test-async-hooks-run-in-async-scope-this-arg.js
@@ -0,0 +1,17 @@
+'use strict';
+
+// Test that passing thisArg to runInAsyncScope() works.
+
+const common = require('../common');
+const assert = require('assert');
+const { AsyncResource } = require('async_hooks');
+
+const thisArg = {};
+
+const res = new AsyncResource('fhqwhgads');
+
+function callback() {
+  assert.strictEqual(this, thisArg);
+}
+
+res.runInAsyncScope(common.mustCall(callback), thisArg);
diff --git a/test/parallel/test-async-hooks-vm-gc.js b/test/parallel/test-async-hooks-vm-gc.js
new file mode 100644
index 0000000000000000000000000000000000000000..da95e3579dcca4db817c9d11f794f2f4309bdee5
--- /dev/null
+++ b/test/parallel/test-async-hooks-vm-gc.js
@@ -0,0 +1,15 @@
+// Flags: --expose-gc
+'use strict';
+
+require('../common');
+const asyncHooks = require('async_hooks');
+const vm = require('vm');
+
+// This is a regression test for https://github.com/nodejs/node/issues/39019
+//
+// It should not segfault.
+
+const hook = asyncHooks.createHook({ init() {} }).enable();
+vm.createContext();
+globalThis.gc();
+hook.disable();
diff --git a/test/parallel/test-async-local-storage-contexts.js b/test/parallel/test-async-local-storage-contexts.js
new file mode 100644
index 0000000000000000000000000000000000000000..9a6327133794f6a706207feae184f055105640fe
--- /dev/null
+++ b/test/parallel/test-async-local-storage-contexts.js
@@ -0,0 +1,35 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+const { AsyncLocalStorage } = require('async_hooks');
+
+// Regression test for https://github.com/nodejs/node/issues/38781
+
+const context = vm.createContext({
+  AsyncLocalStorage,
+  assert
+});
+
+vm.runInContext(`
+  const storage = new AsyncLocalStorage()
+  async function test() {
+    return storage.run({ test: 'vm' }, async () => {
+      assert.strictEqual(storage.getStore().test, 'vm');
+      await 42;
+      assert.strictEqual(storage.getStore().test, 'vm');
+    });
+  }
+  test()
+`, context);
+
+const storage = new AsyncLocalStorage();
+async function test() {
+  return storage.run({ test: 'main context' }, async () => {
+    assert.strictEqual(storage.getStore().test, 'main context');
+    await 42;
+    assert.strictEqual(storage.getStore().test, 'main context');
+  });
+}
+test();
diff --git a/test/parallel/test-binding-constants.js b/test/parallel/test-binding-constants.js
index e989e09b3cd7d627f5d06aaca26e0a2489f3a42f..4a96b7c7443fc6f03f477d4019f16cfe714a1247 100644
--- a/test/parallel/test-binding-constants.js
+++ b/test/parallel/test-binding-constants.js
@@ -29,5 +29,5 @@ function test(obj) {
 
 [
   constants, constants.crypto, constants.fs, constants.os, constants.trace,
-  constants.zlib, constants.os.dlopen, constants.os.errno, constants.os.signals
+  constants.zlib, constants.os.dlopen, constants.os.errno, constants.os.signals,
 ].forEach(test);
diff --git a/test/parallel/test-blob.js b/test/parallel/test-blob.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f9a8a93abd3f33b6ef2ff0d2e5f289ac0e21943
--- /dev/null
+++ b/test/parallel/test-blob.js
@@ -0,0 +1,201 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { Blob } = require('buffer');
+const { inspect } = require('util');
+const { MessageChannel } = require('worker_threads');
+
+{
+  const b = new Blob();
+  assert.strictEqual(b.size, 0);
+  assert.strictEqual(b.type, '');
+}
+
+assert.throws(() => new Blob(false), {
+  code: 'ERR_INVALID_ARG_TYPE'
+});
+
+assert.throws(() => new Blob('hello'), {
+  code: 'ERR_INVALID_ARG_TYPE'
+});
+
+assert.throws(() => new Blob({}), {
+  code: 'ERR_INVALID_ARG_TYPE'
+});
+
+{
+  const b = new Blob([]);
+  assert(b);
+  assert.strictEqual(b.size, 0);
+  assert.strictEqual(b.type, '');
+
+  b.arrayBuffer().then(common.mustCall((ab) => {
+    assert.deepStrictEqual(ab, new ArrayBuffer(0));
+  }));
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, '');
+  }));
+  const c = b.slice();
+  assert.strictEqual(c.size, 0);
+}
+
+{
+  assert.strictEqual(new Blob([], { type: 1 }).type, '1');
+  assert.strictEqual(new Blob([], { type: false }).type, 'false');
+  assert.strictEqual(new Blob([], { type: {} }).type, '[object object]');
+}
+
+{
+  const b = new Blob(['616263'], { encoding: 'hex', type: 'foo' });
+  assert.strictEqual(b.size, 3);
+  assert.strictEqual(b.type, 'foo');
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'abc');
+  }));
+}
+
+{
+  const b = new Blob([Buffer.from('abc')]);
+  assert.strictEqual(b.size, 3);
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'abc');
+  }));
+}
+
+{
+  const b = new Blob([new ArrayBuffer(3)]);
+  assert.strictEqual(b.size, 3);
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, '\0\0\0');
+  }));
+}
+
+{
+  const b = new Blob([new Uint8Array(3)]);
+  assert.strictEqual(b.size, 3);
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, '\0\0\0');
+  }));
+}
+
+{
+  const b = new Blob([new Blob(['abc'])]);
+  assert.strictEqual(b.size, 3);
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'abc');
+  }));
+}
+
+{
+  const b = new Blob(['hello', Buffer.from('world')]);
+  assert.strictEqual(b.size, 10);
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'helloworld');
+  }));
+}
+
+{
+  const b = new Blob(
+    [
+      'h',
+      'e',
+      'l',
+      'lo',
+      Buffer.from('world'),
+    ]);
+  assert.strictEqual(b.size, 10);
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'helloworld');
+  }));
+}
+
+{
+  const b = new Blob(['hello', Buffer.from('world')]);
+  assert.strictEqual(b.size, 10);
+  assert.strictEqual(b.type, '');
+
+  const c = b.slice(1, -1, 'foo');
+  assert.strictEqual(c.type, 'foo');
+  c.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'elloworl');
+  }));
+
+  const d = c.slice(1, -1);
+  d.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'llowor');
+  }));
+
+  const e = d.slice(1, -1);
+  e.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'lowo');
+  }));
+
+  const f = e.slice(1, -1);
+  f.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'ow');
+  }));
+
+  const g = f.slice(1, -1);
+  assert.strictEqual(g.type, '');
+  g.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, '');
+  }));
+
+  const h = b.slice(-1, 1);
+  assert.strictEqual(h.size, 0);
+
+  const i = b.slice(1, 100);
+  assert.strictEqual(i.size, 9);
+
+  const j = b.slice(1, 2, false);
+  assert.strictEqual(j.type, 'false');
+
+  assert.strictEqual(b.size, 10);
+  assert.strictEqual(b.type, '');
+}
+
+{
+  const b = new Blob([Buffer.from('hello'), Buffer.from('world')]);
+  const mc = new MessageChannel();
+  mc.port1.onmessage = common.mustCall(({ data }) => {
+    data.text().then(common.mustCall((text) => {
+      assert.strictEqual(text, 'helloworld');
+    }));
+    mc.port1.close();
+  });
+  mc.port2.postMessage(b);
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'helloworld');
+  }));
+}
+
+{
+  const b = new Blob(['hello'], { type: '\x01' });
+  assert.strictEqual(b.type, '');
+}
+
+{
+  const descriptor =
+      Object.getOwnPropertyDescriptor(Blob.prototype, Symbol.toStringTag);
+  assert.deepStrictEqual(descriptor, {
+    configurable: true,
+    enumerable: false,
+    value: 'Blob',
+    writable: false
+  });
+}
+
+{
+  const b = new Blob(['test', 42]);
+  b.text().then(common.mustCall((text) => {
+    assert.strictEqual(text, 'test42');
+  }));
+}
+
+{
+  const b = new Blob();
+  assert.strictEqual(inspect(b, { depth: null }),
+                     'Blob { size: 0, type: \'\' }');
+  assert.strictEqual(inspect(b, { depth: -1 }), '[Blob]');
+}
diff --git a/test/parallel/test-blocklist-clone.js b/test/parallel/test-blocklist-clone.js
new file mode 100644
index 0000000000000000000000000000000000000000..163592d47793263b0060c08e8af109d492ef3219
--- /dev/null
+++ b/test/parallel/test-blocklist-clone.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+
+const {
+  BlockList,
+} = require('net');
+const {
+  MessageChannel,
+} = require('worker_threads');
+
+const {
+  ok,
+  notStrictEqual,
+} = require('assert');
+
+const blocklist = new BlockList();
+blocklist.addAddress('123.123.123.123');
+
+const mc = new MessageChannel();
+
+mc.port1.onmessage = common.mustCall(({ data }) => {
+  notStrictEqual(data, blocklist);
+  ok(data.check('123.123.123.123'));
+  ok(!data.check('123.123.123.124'));
+
+  data.addAddress('123.123.123.124');
+  ok(blocklist.check('123.123.123.124'));
+  ok(data.check('123.123.123.124'));
+
+  mc.port1.close();
+});
+
+mc.port2.postMessage(blocklist);
diff --git a/test/parallel/test-blocklist.js b/test/parallel/test-blocklist.js
new file mode 100644
index 0000000000000000000000000000000000000000..51f19e07bc649cb90c88923996fd621102c8dbf7
--- /dev/null
+++ b/test/parallel/test-blocklist.js
@@ -0,0 +1,274 @@
+'use strict';
+
+require('../common');
+
+const {
+  BlockList,
+  SocketAddress,
+} = require('net');
+const assert = require('assert');
+const util = require('util');
+
+{
+  const blockList = new BlockList();
+
+  [1, [], {}, null, 1n, undefined, null].forEach((i) => {
+    assert.throws(() => blockList.addAddress(i), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  [1, [], {}, null, 1n, null].forEach((i) => {
+    assert.throws(() => blockList.addAddress('1.1.1.1', i), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  assert.throws(() => blockList.addAddress('1.1.1.1', 'foo'), {
+    code: 'ERR_INVALID_ARG_VALUE'
+  });
+
+  [1, [], {}, null, 1n, undefined, null].forEach((i) => {
+    assert.throws(() => blockList.addRange(i), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+    assert.throws(() => blockList.addRange('1.1.1.1', i), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  [1, [], {}, null, 1n, null].forEach((i) => {
+    assert.throws(() => blockList.addRange('1.1.1.1', '1.1.1.2', i), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  assert.throws(() => blockList.addRange('1.1.1.1', '1.1.1.2', 'foo'), {
+    code: 'ERR_INVALID_ARG_VALUE'
+  });
+}
+
+{
+  const blockList = new BlockList();
+  blockList.addAddress('1.1.1.1');
+  blockList.addAddress('8592:757c:efae:4e45:fb5d:d62a:0d00:8e17', 'ipv6');
+  blockList.addAddress('::ffff:1.1.1.2', 'ipv6');
+
+  assert(blockList.check('1.1.1.1'));
+  assert(!blockList.check('1.1.1.1', 'ipv6'));
+  assert(!blockList.check('8592:757c:efae:4e45:fb5d:d62a:0d00:8e17'));
+  assert(blockList.check('8592:757c:efae:4e45:fb5d:d62a:0d00:8e17', 'ipv6'));
+
+  assert(blockList.check('::ffff:1.1.1.1', 'ipv6'));
+  assert(blockList.check('::ffff:1.1.1.1', 'IPV6'));
+
+  assert(blockList.check('1.1.1.2'));
+
+  assert(!blockList.check('1.2.3.4'));
+  assert(!blockList.check('::1', 'ipv6'));
+}
+
+{
+  const blockList = new BlockList();
+  const sa1 = new SocketAddress({ address: '1.1.1.1' });
+  const sa2 = new SocketAddress({
+    address: '8592:757c:efae:4e45:fb5d:d62a:0d00:8e17',
+    family: 'ipv6'
+  });
+  const sa3 = new SocketAddress({ address: '1.1.1.2' });
+
+  blockList.addAddress(sa1);
+  blockList.addAddress(sa2);
+  blockList.addAddress('::ffff:1.1.1.2', 'ipv6');
+
+  assert(blockList.check('1.1.1.1'));
+  assert(blockList.check(sa1));
+  assert(!blockList.check('1.1.1.1', 'ipv6'));
+  assert(!blockList.check('8592:757c:efae:4e45:fb5d:d62a:0d00:8e17'));
+  assert(blockList.check('8592:757c:efae:4e45:fb5d:d62a:0d00:8e17', 'ipv6'));
+  assert(blockList.check(sa2));
+
+  assert(blockList.check('::ffff:1.1.1.1', 'ipv6'));
+  assert(blockList.check('::ffff:1.1.1.1', 'IPV6'));
+
+  assert(blockList.check('1.1.1.2'));
+  assert(blockList.check(sa3));
+
+  assert(!blockList.check('1.2.3.4'));
+  assert(!blockList.check('::1', 'ipv6'));
+}
+
+{
+  const blockList = new BlockList();
+  blockList.addRange('1.1.1.1', '1.1.1.10');
+  blockList.addRange('::1', '::f', 'ipv6');
+
+  assert(!blockList.check('1.1.1.0'));
+  for (let n = 1; n <= 10; n++)
+    assert(blockList.check(`1.1.1.${n}`));
+  assert(!blockList.check('1.1.1.11'));
+
+  assert(!blockList.check('::0', 'ipv6'));
+  for (let n = 0x1; n <= 0xf; n++) {
+    assert(blockList.check(`::${n.toString(16)}`, 'ipv6'),
+           `::${n.toString(16)} check failed`);
+  }
+  assert(!blockList.check('::10', 'ipv6'));
+}
+
+{
+  const blockList = new BlockList();
+  const sa1 = new SocketAddress({ address: '1.1.1.1' });
+  const sa2 = new SocketAddress({ address: '1.1.1.10' });
+  const sa3 = new SocketAddress({ address: '::1', family: 'ipv6' });
+  const sa4 = new SocketAddress({ address: '::f', family: 'ipv6' });
+
+  blockList.addRange(sa1, sa2);
+  blockList.addRange(sa3, sa4);
+
+  assert(!blockList.check('1.1.1.0'));
+  for (let n = 1; n <= 10; n++)
+    assert(blockList.check(`1.1.1.${n}`));
+  assert(!blockList.check('1.1.1.11'));
+
+  assert(!blockList.check('::0', 'ipv6'));
+  for (let n = 0x1; n <= 0xf; n++) {
+    assert(blockList.check(`::${n.toString(16)}`, 'ipv6'),
+           `::${n.toString(16)} check failed`);
+  }
+  assert(!blockList.check('::10', 'ipv6'));
+}
+
+{
+  const blockList = new BlockList();
+  blockList.addSubnet('1.1.1.0', 16);
+  blockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');
+
+  assert(blockList.check('1.1.0.1'));
+  assert(blockList.check('1.1.1.1'));
+  assert(!blockList.check('1.2.0.1'));
+  assert(blockList.check('::ffff:1.1.0.1', 'ipv6'));
+
+  assert(blockList.check('8592:757c:efae:4e45:f::', 'ipv6'));
+  assert(blockList.check('8592:757c:efae:4e45::f', 'ipv6'));
+  assert(!blockList.check('8592:757c:efae:4f45::f', 'ipv6'));
+}
+
+{
+  const blockList = new BlockList();
+  const sa1 = new SocketAddress({ address: '1.1.1.0' });
+  const sa2 = new SocketAddress({ address: '1.1.1.1' });
+  blockList.addSubnet(sa1, 16);
+  blockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');
+
+  assert(blockList.check('1.1.0.1'));
+  assert(blockList.check(sa2));
+  assert(!blockList.check('1.2.0.1'));
+  assert(blockList.check('::ffff:1.1.0.1', 'ipv6'));
+
+  assert(blockList.check('8592:757c:efae:4e45:f::', 'ipv6'));
+  assert(blockList.check('8592:757c:efae:4e45::f', 'ipv6'));
+  assert(!blockList.check('8592:757c:efae:4f45::f', 'ipv6'));
+}
+
+{
+  const blockList = new BlockList();
+  blockList.addAddress('1.1.1.1');
+  blockList.addRange('10.0.0.1', '10.0.0.10');
+  blockList.addSubnet('8592:757c:efae:4e45::', 64, 'IpV6'); // Case insensitive
+
+  const rulesCheck = [
+    'Subnet: IPv6 8592:757c:efae:4e45::/64',
+    'Range: IPv4 10.0.0.1-10.0.0.10',
+    'Address: IPv4 1.1.1.1',
+  ];
+  assert.deepStrictEqual(blockList.rules, rulesCheck);
+
+  assert(blockList.check('1.1.1.1'));
+  assert(blockList.check('10.0.0.5'));
+  assert(blockList.check('::ffff:10.0.0.5', 'ipv6'));
+  assert(blockList.check('8592:757c:efae:4e45::f', 'ipv6'));
+
+  assert(!blockList.check('123.123.123.123'));
+  assert(!blockList.check('8592:757c:efaf:4e45:fb5d:d62a:0d00:8e17', 'ipv6'));
+  assert(!blockList.check('::ffff:123.123.123.123', 'ipv6'));
+}
+
+{
+  // This test validates boundaries of non-aligned CIDR bit prefixes
+  const blockList = new BlockList();
+  blockList.addSubnet('10.0.0.0', 27);
+  blockList.addSubnet('8592:757c:efaf::', 51, 'ipv6');
+
+  for (let n = 0; n <= 31; n++)
+    assert(blockList.check(`10.0.0.${n}`));
+  assert(!blockList.check('10.0.0.32'));
+
+  assert(blockList.check('8592:757c:efaf:0:0:0:0:0', 'ipv6'));
+  assert(blockList.check('8592:757c:efaf:1fff:ffff:ffff:ffff:ffff', 'ipv6'));
+  assert(!blockList.check('8592:757c:efaf:2fff:ffff:ffff:ffff:ffff', 'ipv6'));
+}
+
+{
+  // Regression test for https://github.com/nodejs/node/issues/39074
+  const blockList = new BlockList();
+
+  blockList.addRange('10.0.0.2', '10.0.0.10');
+
+  // IPv4 checks against IPv4 range.
+  assert(blockList.check('10.0.0.2'));
+  assert(blockList.check('10.0.0.10'));
+  assert(!blockList.check('192.168.0.3'));
+  assert(!blockList.check('2.2.2.2'));
+  assert(!blockList.check('255.255.255.255'));
+
+  // IPv6 checks against IPv4 range.
+  assert(blockList.check('::ffff:0a00:0002', 'ipv6'));
+  assert(blockList.check('::ffff:0a00:000a', 'ipv6'));
+  assert(!blockList.check('::ffff:c0a8:0003', 'ipv6'));
+  assert(!blockList.check('::ffff:0202:0202', 'ipv6'));
+  assert(!blockList.check('::ffff:ffff:ffff', 'ipv6'));
+}
+
+{
+  const blockList = new BlockList();
+  assert.throws(() => blockList.addRange('1.1.1.2', '1.1.1.1'), /ERR_INVALID_ARG_VALUE/);
+}
+
+{
+  const blockList = new BlockList();
+  assert.throws(() => blockList.addSubnet(1), /ERR_INVALID_ARG_TYPE/);
+  assert.throws(() => blockList.addSubnet('1.1.1.1', ''),
+                /ERR_INVALID_ARG_TYPE/);
+  assert.throws(() => blockList.addSubnet('1.1.1.1', NaN), /ERR_OUT_OF_RANGE/);
+  assert.throws(() => blockList.addSubnet('', 1, 1), /ERR_INVALID_ARG_TYPE/);
+  assert.throws(() => blockList.addSubnet('', 1, ''), /ERR_INVALID_ARG_VALUE/);
+
+  assert.throws(() => blockList.addSubnet('1.1.1.1', -1, 'ipv4'),
+                /ERR_OUT_OF_RANGE/);
+  assert.throws(() => blockList.addSubnet('1.1.1.1', 33, 'ipv4'),
+                /ERR_OUT_OF_RANGE/);
+
+  assert.throws(() => blockList.addSubnet('::', -1, 'ipv6'),
+                /ERR_OUT_OF_RANGE/);
+  assert.throws(() => blockList.addSubnet('::', 129, 'ipv6'),
+                /ERR_OUT_OF_RANGE/);
+}
+
+{
+  const blockList = new BlockList();
+  assert.throws(() => blockList.check(1), /ERR_INVALID_ARG_TYPE/);
+  assert.throws(() => blockList.check('', 1), /ERR_INVALID_ARG_TYPE/);
+}
+
+{
+  const blockList = new BlockList();
+  const ret = util.inspect(blockList, { depth: -1 });
+  assert.strictEqual(ret, '[BlockList]');
+}
+
+{
+  const blockList = new BlockList();
+  const ret = util.inspect(blockList, { depth: null });
+  assert(ret.includes('rules: []'));
+}
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index e978edf04fc90c61d2e5546dc8786dfe826b76ed..683171fe3c7b20b357e16bd500edbf998bef51e3 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -17,7 +17,7 @@ const expectedModules = new Set([
   'Internal Binding credentials',
   'Internal Binding fs',
   'Internal Binding fs_dir',
-  'Internal Binding inspector',
+  'Internal Binding fs_event_wrap',
   'Internal Binding messaging',
   'Internal Binding module_wrap',
   'Internal Binding native_module',
@@ -32,6 +32,8 @@ const expectedModules = new Set([
   'Internal Binding types',
   'Internal Binding url',
   'Internal Binding util',
+  'Internal Binding uv',
+  'NativeModule async_hooks',
   'NativeModule buffer',
   'NativeModule events',
   'NativeModule fs',
@@ -47,6 +49,9 @@ const expectedModules = new Set([
   'NativeModule internal/fixed_queue',
   'NativeModule internal/fs/dir',
   'NativeModule internal/fs/utils',
+  'NativeModule internal/fs/promises',
+  'NativeModule internal/fs/rimraf',
+  'NativeModule internal/fs/watchers',
   'NativeModule internal/idna',
   'NativeModule internal/linkedlist',
   'NativeModule internal/modules/run_main',
@@ -74,15 +79,18 @@ const expectedModules = new Set([
   'NativeModule internal/process/warning',
   'NativeModule internal/querystring',
   'NativeModule internal/source_map/source_map_cache',
+  'NativeModule internal/streams/utils',
   'NativeModule internal/timers',
   'NativeModule internal/url',
   'NativeModule internal/util',
   'NativeModule internal/util/debuglog',
   'NativeModule internal/util/inspect',
+  'NativeModule internal/util/iterable_weak_map',
   'NativeModule internal/util/types',
   'NativeModule internal/validators',
   'NativeModule internal/vm/module',
   'NativeModule internal/worker/js_transferable',
+  'NativeModule internal/blob',
   'NativeModule path',
   'NativeModule timers',
   'NativeModule url',
@@ -90,27 +98,31 @@ const expectedModules = new Set([
 ]);
 
 if (!common.isMainThread) {
-  expectedModules.add('Internal Binding messaging');
-  expectedModules.add('Internal Binding symbols');
-  expectedModules.add('Internal Binding worker');
-  expectedModules.add('Internal Binding performance');
-  expectedModules.add('NativeModule _stream_duplex');
-  expectedModules.add('NativeModule _stream_passthrough');
-  expectedModules.add('NativeModule _stream_readable');
-  expectedModules.add('NativeModule _stream_transform');
-  expectedModules.add('NativeModule _stream_writable');
-  expectedModules.add('NativeModule internal/error_serdes');
-  expectedModules.add('NativeModule internal/process/worker_thread_only');
-  expectedModules.add('NativeModule internal/streams/buffer_list');
-  expectedModules.add('NativeModule internal/streams/destroy');
-  expectedModules.add('NativeModule internal/streams/end-of-stream');
-  expectedModules.add('NativeModule internal/streams/legacy');
-  expectedModules.add('NativeModule internal/streams/pipeline');
-  expectedModules.add('NativeModule internal/streams/state');
-  expectedModules.add('NativeModule internal/worker');
-  expectedModules.add('NativeModule internal/worker/io');
-  expectedModules.add('NativeModule stream');
-  expectedModules.add('NativeModule worker_threads');
+  [
+    'Internal Binding messaging',
+    'Internal Binding performance',
+    'Internal Binding symbols',
+    'Internal Binding worker',
+    'NativeModule internal/streams/duplex',
+    'NativeModule internal/streams/passthrough',
+    'NativeModule internal/streams/readable',
+    'NativeModule internal/streams/transform',
+    'NativeModule internal/streams/writable',
+    'NativeModule internal/error_serdes',
+    'NativeModule internal/event_target',
+    'NativeModule internal/process/worker_thread_only',
+    'NativeModule internal/streams/buffer_list',
+    'NativeModule internal/streams/destroy',
+    'NativeModule internal/streams/end-of-stream',
+    'NativeModule internal/streams/legacy',
+    'NativeModule internal/streams/pipeline',
+    'NativeModule internal/streams/state',
+    'NativeModule internal/worker',
+    'NativeModule internal/worker/io',
+    'NativeModule stream',
+    'NativeModule util',
+    'NativeModule worker_threads',
+  ].forEach(expectedModules.add.bind(expectedModules));
 }
 
 if (common.hasIntl) {
@@ -120,6 +132,7 @@ if (common.hasIntl) {
 }
 
 if (process.features.inspector) {
+  expectedModules.add('Internal Binding inspector');
   expectedModules.add('NativeModule internal/inspector_async_hook');
   expectedModules.add('NativeModule internal/util/inspector');
 }
diff --git a/test/parallel/test-buffer-alloc.js b/test/parallel/test-buffer-alloc.js
index 070a3803802e56ec7736791559ec7d7204625754..d07d15125bc546471edcdfe0901542c968505c2b 100644
--- a/test/parallel/test-buffer-alloc.js
+++ b/test/parallel/test-buffer-alloc.js
@@ -292,14 +292,40 @@ Buffer.alloc(1).write('', 1, 0);
 // Test toString('base64')
 //
 assert.strictEqual((Buffer.from('Man')).toString('base64'), 'TWFu');
+assert.strictEqual((Buffer.from('Woman')).toString('base64'), 'V29tYW4=');
+
+//
+// Test toString('base64url')
+//
+assert.strictEqual((Buffer.from('Man')).toString('base64url'), 'TWFu');
+assert.strictEqual((Buffer.from('Woman')).toString('base64url'), 'V29tYW4');
 
 {
-  // Test that regular and URL-safe base64 both work
+  // Test that regular and URL-safe base64 both work both ways
   const expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff];
   assert.deepStrictEqual(Buffer.from('//++/++/++//', 'base64'),
                          Buffer.from(expected));
   assert.deepStrictEqual(Buffer.from('__--_--_--__', 'base64'),
                          Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('//++/++/++//', 'base64url'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('__--_--_--__', 'base64url'),
+                         Buffer.from(expected));
+}
+
+const base64flavors = ['base64', 'base64url'];
+
+{
+  // Test that regular and URL-safe base64 both work both ways with padding
+  const expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff, 0xfb];
+  assert.deepStrictEqual(Buffer.from('//++/++/++//+w==', 'base64'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('//++/++/++//+w==', 'base64'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('//++/++/++//+w==', 'base64url'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('//++/++/++//+w==', 'base64url'),
+                         Buffer.from(expected));
 }
 
 {
@@ -316,137 +342,182 @@ assert.strictEqual((Buffer.from('Man')).toString('base64'), 'TWFu');
                    'dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZ' +
                    'GdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm' +
                    '5hbCBwbGVhc3VyZS4=';
-  assert.strictEqual((Buffer.from(quote)).toString('base64'), expected);
-
-  let b = Buffer.allocUnsafe(1024);
-  let bytesWritten = b.write(expected, 0, 'base64');
-  assert.strictEqual(quote.length, bytesWritten);
-  assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
-
-  // Check that the base64 decoder ignores whitespace
-  const expectedWhite = `${expected.slice(0, 60)} \n` +
-                        `${expected.slice(60, 120)} \n` +
-                        `${expected.slice(120, 180)} \n` +
-                        `${expected.slice(180, 240)} \n` +
-                        `${expected.slice(240, 300)}\n` +
-                        `${expected.slice(300, 360)}\n`;
-  b = Buffer.allocUnsafe(1024);
-  bytesWritten = b.write(expectedWhite, 0, 'base64');
-  assert.strictEqual(quote.length, bytesWritten);
-  assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
-
-  // Check that the base64 decoder on the constructor works
-  // even in the presence of whitespace.
-  b = Buffer.from(expectedWhite, 'base64');
-  assert.strictEqual(quote.length, b.length);
-  assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
-
-  // Check that the base64 decoder ignores illegal chars
-  const expectedIllegal = expected.slice(0, 60) + ' \x80' +
-                          expected.slice(60, 120) + ' \xff' +
-                          expected.slice(120, 180) + ' \x00' +
-                          expected.slice(180, 240) + ' \x98' +
-                          expected.slice(240, 300) + '\x03' +
-                          expected.slice(300, 360);
-  b = Buffer.from(expectedIllegal, 'base64');
-  assert.strictEqual(quote.length, b.length);
-  assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+  assert.strictEqual(Buffer.from(quote).toString('base64'), expected);
+  assert.strictEqual(
+    Buffer.from(quote).toString('base64url'),
+    expected.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+  );
+
+  base64flavors.forEach((encoding) => {
+    let b = Buffer.allocUnsafe(1024);
+    let bytesWritten = b.write(expected, 0, encoding);
+    assert.strictEqual(quote.length, bytesWritten);
+    assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+
+    // Check that the base64 decoder ignores whitespace
+    const expectedWhite = `${expected.slice(0, 60)} \n` +
+                          `${expected.slice(60, 120)} \n` +
+                          `${expected.slice(120, 180)} \n` +
+                          `${expected.slice(180, 240)} \n` +
+                          `${expected.slice(240, 300)}\n` +
+                          `${expected.slice(300, 360)}\n`;
+    b = Buffer.allocUnsafe(1024);
+    bytesWritten = b.write(expectedWhite, 0, encoding);
+    assert.strictEqual(quote.length, bytesWritten);
+    assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+
+    // Check that the base64 decoder on the constructor works
+    // even in the presence of whitespace.
+    b = Buffer.from(expectedWhite, encoding);
+    assert.strictEqual(quote.length, b.length);
+    assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+
+    // Check that the base64 decoder ignores illegal chars
+    const expectedIllegal = expected.slice(0, 60) + ' \x80' +
+                            expected.slice(60, 120) + ' \xff' +
+                            expected.slice(120, 180) + ' \x00' +
+                            expected.slice(180, 240) + ' \x98' +
+                            expected.slice(240, 300) + '\x03' +
+                            expected.slice(300, 360);
+    b = Buffer.from(expectedIllegal, encoding);
+    assert.strictEqual(quote.length, b.length);
+    assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+  });
 }
 
-assert.strictEqual(Buffer.from('', 'base64').toString(), '');
-assert.strictEqual(Buffer.from('K', 'base64').toString(), '');
-
-// multiple-of-4 with padding
-assert.strictEqual(Buffer.from('Kg==', 'base64').toString(), '*');
-assert.strictEqual(Buffer.from('Kio=', 'base64').toString(), '*'.repeat(2));
-assert.strictEqual(Buffer.from('Kioq', 'base64').toString(), '*'.repeat(3));
-assert.strictEqual(Buffer.from('KioqKg==', 'base64').toString(), '*'.repeat(4));
-assert.strictEqual(Buffer.from('KioqKio=', 'base64').toString(), '*'.repeat(5));
-assert.strictEqual(Buffer.from('KioqKioq', 'base64').toString(), '*'.repeat(6));
-assert.strictEqual(Buffer.from('KioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(7));
-assert.strictEqual(Buffer.from('KioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(8));
-assert.strictEqual(Buffer.from('KioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(9));
-assert.strictEqual(Buffer.from('KioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(10));
-assert.strictEqual(Buffer.from('KioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(11));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(12));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(13));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(14));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(15));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(16));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(17));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(18));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKg==',
-                               'base64').toString(),
-                   '*'.repeat(19));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKio=',
-                               'base64').toString(),
-                   '*'.repeat(20));
-
-// No padding, not a multiple of 4
-assert.strictEqual(Buffer.from('Kg', 'base64').toString(), '*');
-assert.strictEqual(Buffer.from('Kio', 'base64').toString(), '*'.repeat(2));
-assert.strictEqual(Buffer.from('KioqKg', 'base64').toString(), '*'.repeat(4));
-assert.strictEqual(Buffer.from('KioqKio', 'base64').toString(), '*'.repeat(5));
-assert.strictEqual(Buffer.from('KioqKioqKg', 'base64').toString(),
-                   '*'.repeat(7));
-assert.strictEqual(Buffer.from('KioqKioqKio', 'base64').toString(),
-                   '*'.repeat(8));
-assert.strictEqual(Buffer.from('KioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(10));
-assert.strictEqual(Buffer.from('KioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(11));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(13));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(14));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(16));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(17));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKg',
-                               'base64').toString(),
-                   '*'.repeat(19));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKio',
-                               'base64').toString(),
-                   '*'.repeat(20));
+base64flavors.forEach((encoding) => {
+  assert.strictEqual(Buffer.from('', encoding).toString(), '');
+  assert.strictEqual(Buffer.from('K', encoding).toString(), '');
+
+  // multiple-of-4 with padding
+  assert.strictEqual(Buffer.from('Kg==', encoding).toString(), '*');
+  assert.strictEqual(Buffer.from('Kio=', encoding).toString(), '*'.repeat(2));
+  assert.strictEqual(Buffer.from('Kioq', encoding).toString(), '*'.repeat(3));
+  assert.strictEqual(
+    Buffer.from('KioqKg==', encoding).toString(), '*'.repeat(4));
+  assert.strictEqual(
+    Buffer.from('KioqKio=', encoding).toString(), '*'.repeat(5));
+  assert.strictEqual(
+    Buffer.from('KioqKioq', encoding).toString(), '*'.repeat(6));
+  assert.strictEqual(Buffer.from('KioqKioqKg==', encoding).toString(),
+                     '*'.repeat(7));
+  assert.strictEqual(Buffer.from('KioqKioqKio=', encoding).toString(),
+                     '*'.repeat(8));
+  assert.strictEqual(Buffer.from('KioqKioqKioq', encoding).toString(),
+                     '*'.repeat(9));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKg==', encoding).toString(),
+                     '*'.repeat(10));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKio=', encoding).toString(),
+                     '*'.repeat(11));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioq', encoding).toString(),
+                     '*'.repeat(12));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg==', encoding).toString(),
+                     '*'.repeat(13));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio=', encoding).toString(),
+                     '*'.repeat(14));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioq', encoding).toString(),
+                     '*'.repeat(15));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKg==', encoding).toString(),
+    '*'.repeat(16));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKio=', encoding).toString(),
+    '*'.repeat(17));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKioq', encoding).toString(),
+    '*'.repeat(18));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKg==',
+                                 encoding).toString(),
+                     '*'.repeat(19));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKio=',
+                                 encoding).toString(),
+                     '*'.repeat(20));
+
+  // No padding, not a multiple of 4
+  assert.strictEqual(Buffer.from('Kg', encoding).toString(), '*');
+  assert.strictEqual(Buffer.from('Kio', encoding).toString(), '*'.repeat(2));
+  assert.strictEqual(Buffer.from('KioqKg', encoding).toString(), '*'.repeat(4));
+  assert.strictEqual(
+    Buffer.from('KioqKio', encoding).toString(), '*'.repeat(5));
+  assert.strictEqual(Buffer.from('KioqKioqKg', encoding).toString(),
+                     '*'.repeat(7));
+  assert.strictEqual(Buffer.from('KioqKioqKio', encoding).toString(),
+                     '*'.repeat(8));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKg', encoding).toString(),
+                     '*'.repeat(10));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKio', encoding).toString(),
+                     '*'.repeat(11));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg', encoding).toString(),
+                     '*'.repeat(13));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio', encoding).toString(),
+                     '*'.repeat(14));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKg', encoding).toString(),
+                     '*'.repeat(16));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKio', encoding).toString(),
+    '*'.repeat(17));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKioqKg', encoding).toString(),
+    '*'.repeat(19));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKioqKio', encoding).toString(),
+    '*'.repeat(20));
+});
 
 // Handle padding graciously, multiple-of-4 or not
 assert.strictEqual(
   Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', 'base64').length,
   32
 );
+assert.strictEqual(
+  Buffer.from('72INjkR5fchcxk9-VgdGPFJDxUBFR5_rMFsghgxADiw==', 'base64url')
+    .length,
+  32
+);
 assert.strictEqual(
   Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=', 'base64').length,
   32
 );
+assert.strictEqual(
+  Buffer.from('72INjkR5fchcxk9-VgdGPFJDxUBFR5_rMFsghgxADiw=', 'base64url')
+    .length,
+  32
+);
 assert.strictEqual(
   Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw', 'base64').length,
   32
 );
+assert.strictEqual(
+  Buffer.from('72INjkR5fchcxk9-VgdGPFJDxUBFR5_rMFsghgxADiw', 'base64url')
+    .length,
+  32
+);
 assert.strictEqual(
   Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', 'base64').length,
   31
 );
+assert.strictEqual(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', 'base64url')
+    .length,
+  31
+);
 assert.strictEqual(
   Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', 'base64').length,
   31
 );
+assert.strictEqual(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', 'base64url')
+    .length,
+  31
+);
 assert.strictEqual(
   Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', 'base64').length,
   31
 );
+assert.strictEqual(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', 'base64url').length,
+  31
+);
 
 {
 // This string encodes single '.' character in UTF-16
@@ -458,6 +529,16 @@ assert.strictEqual(
   assert.strictEqual(dot.toString('base64'), '//4uAA==');
 }
 
+{
+// This string encodes single '.' character in UTF-16
+  const dot = Buffer.from('//4uAA', 'base64url');
+  assert.strictEqual(dot[0], 0xff);
+  assert.strictEqual(dot[1], 0xfe);
+  assert.strictEqual(dot[2], 0x2e);
+  assert.strictEqual(dot[3], 0x00);
+  assert.strictEqual(dot.toString('base64url'), '__4uAA');
+}
+
 {
   // Writing base64 at a position > 0 should not mangle the result.
   //
@@ -473,6 +554,21 @@ assert.strictEqual(
                      'Madness?! This is node.js!');
 }
 
+{
+  // Writing base64url at a position > 0 should not mangle the result.
+  //
+  // https://github.com/joyent/node/issues/402
+  const segments = ['TWFkbmVzcz8h', 'IFRoaXM', 'IGlz', 'IG5vZGUuanMh'];
+  const b = Buffer.allocUnsafe(64);
+  let pos = 0;
+
+  for (let i = 0; i < segments.length; ++i) {
+    pos += b.write(segments[i], pos, 'base64url');
+  }
+  assert.strictEqual(b.toString('latin1', 0, pos),
+                     'Madness?! This is node.js!');
+}
+
 // Regression test for https://github.com/nodejs/node/issues/3496.
 assert.strictEqual(Buffer.from('=bad'.repeat(1e4), 'base64').length, 0);
 
diff --git a/test/parallel/test-buffer-backing-arraybuffer.js b/test/parallel/test-buffer-backing-arraybuffer.js
index e7e15c079e633203c4690c9fc52d834fb334e5d2..86fdf92181788fba8f7fda55366e3630e9940a56 100644
--- a/test/parallel/test-buffer-backing-arraybuffer.js
+++ b/test/parallel/test-buffer-backing-arraybuffer.js
@@ -20,7 +20,7 @@ for (const { length, expectOnHeap } of tests) {
     new Float32Array(length / 4),
     new Float64Array(length / 8),
     Buffer.alloc(length),
-    Buffer.allocUnsafeSlow(length)
+    Buffer.allocUnsafeSlow(length),
     // Buffer.allocUnsafe() is missing because it may use pooled allocations.
   ];
 
@@ -31,7 +31,7 @@ for (const { length, expectOnHeap } of tests) {
                        `for ${array.constructor.name}, length = ${length}`);
 
     // Consistency check: Accessing .buffer should create it.
-    array.buffer;
+    array.buffer; // eslint-disable-line no-unused-expressions
     assert(arrayBufferViewHasBuffer(array));
   }
 }
diff --git a/test/parallel/test-buffer-bytelength.js b/test/parallel/test-buffer-bytelength.js
index b5264ba092ce1e1279404f3c6f08b1d970aa54b9..33cbb3268440a10e168027beaea041d18da301d9 100644
--- a/test/parallel/test-buffer-bytelength.js
+++ b/test/parallel/test-buffer-bytelength.js
@@ -9,7 +9,7 @@ const vm = require('vm');
   [32, 'latin1'],
   [NaN, 'utf8'],
   [{}, 'latin1'],
-  []
+  [],
 ].forEach((args) => {
   assert.throws(
     () => Buffer.byteLength(...args),
@@ -91,9 +91,19 @@ assert.strictEqual(Buffer.byteLength('aGkk', 'base64'), 3);
 assert.strictEqual(
   Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==', 'base64'), 25
 );
+// base64url
+assert.strictEqual(Buffer.byteLength('aGVsbG8gd29ybGQ', 'base64url'), 11);
+assert.strictEqual(Buffer.byteLength('aGVsbG8gd29ybGQ', 'BASE64URL'), 11);
+assert.strictEqual(Buffer.byteLength('bm9kZS5qcyByb2NrcyE', 'base64url'), 14);
+assert.strictEqual(Buffer.byteLength('aGkk', 'base64url'), 3);
+assert.strictEqual(
+  Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw', 'base64url'), 25
+);
 // special padding
 assert.strictEqual(Buffer.byteLength('aaa=', 'base64'), 2);
 assert.strictEqual(Buffer.byteLength('aaaa==', 'base64'), 3);
+assert.strictEqual(Buffer.byteLength('aaa=', 'base64url'), 2);
+assert.strictEqual(Buffer.byteLength('aaaa==', 'base64url'), 3);
 
 assert.strictEqual(Buffer.byteLength('Il était tué'), 14);
 assert.strictEqual(Buffer.byteLength('Il était tué', 'utf8'), 14);
diff --git a/test/parallel/test-buffer-constructor-deprecation-error.js b/test/parallel/test-buffer-constructor-deprecation-error.js
index 46535e103b33eef4505e53ec5523a73c35e59eb1..6628bd490a2ff3c83db1d14fcae8267a419a1271 100644
--- a/test/parallel/test-buffer-constructor-deprecation-error.js
+++ b/test/parallel/test-buffer-constructor-deprecation-error.js
@@ -14,4 +14,4 @@ process.on('warning', common.mustCall());
 
 Error.prepareStackTrace = (err, trace) => new Buffer(10);
 
-new Error().stack;
+new Error().stack; // eslint-disable-line no-unused-expressions
diff --git a/test/parallel/test-buffer-copy.js b/test/parallel/test-buffer-copy.js
index d6f734614471e5a3f7676e9fae303ff46ceb25c6..f7ccfff9d0cbbeac13897880b21a970e55a19855 100644
--- a/test/parallel/test-buffer-copy.js
+++ b/test/parallel/test-buffer-copy.js
@@ -30,6 +30,17 @@ let cntr = 0;
   }
 }
 
+{
+  // Floats will be converted to integers via `Math.floor`
+  b.fill(++cntr);
+  c.fill(++cntr);
+  const copied = b.copy(c, 0, 0, 512.5);
+  assert.strictEqual(copied, 512);
+  for (let i = 0; i < c.length; i++) {
+    assert.strictEqual(c[i], b[i]);
+  }
+}
+
 {
   // Copy c into b, without specifying sourceEnd
   b.fill(++cntr);
@@ -52,6 +63,17 @@ let cntr = 0;
   }
 }
 
+{
+  // Copied source range greater than source length
+  b.fill(++cntr);
+  c.fill(++cntr);
+  const copied = c.copy(b, 0, 0, c.length + 1);
+  assert.strictEqual(copied, c.length);
+  for (let i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
 {
   // Copy longer buffer b to shorter c without targetStart
   b.fill(++cntr);
@@ -107,6 +129,26 @@ bb.fill('hello crazy world');
 // Try to copy from before the beginning of b. Should not throw.
 b.copy(c, 0, 100, 10);
 
+// Throw with invalid source type
+assert.throws(
+  () => Buffer.prototype.copy.call(0),
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+  }
+);
+
+// Copy throws at negative targetStart
+assert.throws(
+  () => Buffer.allocUnsafe(5).copy(Buffer.allocUnsafe(5), -1, 0),
+  {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: 'The value of "targetStart" is out of range. ' +
+             'It must be >= 0. Received -1'
+  }
+);
+
 // Copy throws at negative sourceStart
 assert.throws(
   () => Buffer.allocUnsafe(5).copy(Buffer.allocUnsafe(5), 0, -1),
diff --git a/test/parallel/test-buffer-failed-alloc-typed-arrays.js b/test/parallel/test-buffer-failed-alloc-typed-arrays.js
index 9e480a5c8d38533f06dd859169022186e6cb783d..3e91b31ccaf6f3a83e4e0793b9bb3bbcd86b32b9 100644
--- a/test/parallel/test-buffer-failed-alloc-typed-arrays.js
+++ b/test/parallel/test-buffer-failed-alloc-typed-arrays.js
@@ -18,7 +18,7 @@ const allocators = [
   SlowBuffer,
   Buffer.alloc,
   Buffer.allocUnsafe,
-  Buffer.allocUnsafeSlow
+  Buffer.allocUnsafeSlow,
 ];
 for (const allocator of allocators) {
   for (const size of sizes) {
diff --git a/test/parallel/test-buffer-fakes.js b/test/parallel/test-buffer-fakes.js
index d126d39aa95263e39bae748207507d4d6c133cad..da78fe0895e6bb1bf2a2a0e9d8ee518481f95d0b 100644
--- a/test/parallel/test-buffer-fakes.js
+++ b/test/parallel/test-buffer-fakes.js
@@ -14,7 +14,7 @@ assert.throws(function() {
 }, TypeError);
 
 assert.throws(function() {
-  +Buffer.prototype;
+  +Buffer.prototype; // eslint-disable-line no-unused-expressions
 }, TypeError);
 
 assert.throws(function() {
diff --git a/test/parallel/test-buffer-fill.js b/test/parallel/test-buffer-fill.js
index 6e24b3511e6e1af9808597371a0d97bd1918d7cc..00e65c82e91849abc580d8f1c050930f96151274 100644
--- a/test/parallel/test-buffer-fill.js
+++ b/test/parallel/test-buffer-fill.js
@@ -131,20 +131,36 @@ assert.throws(() => {
 });
 
 // BASE64
-testBufs('YWJj', 'ucs2');
-testBufs('yKJhYQ==', 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 'ucs2');
-testBufs('YWJj', 4, 'ucs2');
-testBufs('YWJj', SIZE, 'ucs2');
-testBufs('yKJhYQ==', 2, 'ucs2');
-testBufs('yKJhYQ==', 8, 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 4, 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 12, 'ucs2');
-testBufs('YWJj', 4, 1, 'ucs2');
-testBufs('YWJj', 5, 1, 'ucs2');
-testBufs('yKJhYQ==', 8, 1, 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 4, 1, 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 12, 1, 'ucs2');
+testBufs('YWJj', 'base64');
+testBufs('yKJhYQ==', 'base64');
+testBufs('Yci0Ysi1Y8i2', 'base64');
+testBufs('YWJj', 4, 'base64');
+testBufs('YWJj', SIZE, 'base64');
+testBufs('yKJhYQ==', 2, 'base64');
+testBufs('yKJhYQ==', 8, 'base64');
+testBufs('Yci0Ysi1Y8i2', 4, 'base64');
+testBufs('Yci0Ysi1Y8i2', 12, 'base64');
+testBufs('YWJj', 4, 1, 'base64');
+testBufs('YWJj', 5, 1, 'base64');
+testBufs('yKJhYQ==', 8, 1, 'base64');
+testBufs('Yci0Ysi1Y8i2', 4, 1, 'base64');
+testBufs('Yci0Ysi1Y8i2', 12, 1, 'base64');
+
+// BASE64URL
+testBufs('YWJj', 'base64url');
+testBufs('yKJhYQ', 'base64url');
+testBufs('Yci0Ysi1Y8i2', 'base64url');
+testBufs('YWJj', 4, 'base64url');
+testBufs('YWJj', SIZE, 'base64url');
+testBufs('yKJhYQ', 2, 'base64url');
+testBufs('yKJhYQ', 8, 'base64url');
+testBufs('Yci0Ysi1Y8i2', 4, 'base64url');
+testBufs('Yci0Ysi1Y8i2', 12, 'base64url');
+testBufs('YWJj', 4, 1, 'base64url');
+testBufs('YWJj', 5, 1, 'base64url');
+testBufs('yKJhYQ', 8, 1, 'base64url');
+testBufs('Yci0Ysi1Y8i2', 4, 1, 'base64url');
+testBufs('Yci0Ysi1Y8i2', 12, 1, 'base64url');
 
 // Buffer
 function deepStrictEqualValues(buf, arr) {
@@ -189,7 +205,7 @@ assert.throws(
 
 [
   ['a', 0, 0, NaN],
-  ['a', 0, 0, false]
+  ['a', 0, 0, false],
 ].forEach((args) => {
   assert.throws(
     () => buf1.fill(...args),
diff --git a/test/parallel/test-buffer-from.js b/test/parallel/test-buffer-from.js
index 165b38893f9e998341fb93872fb3f97acc0980c7..b513f4080a205477309ea1450c0037c4dfbbf398 100644
--- a/test/parallel/test-buffer-from.js
+++ b/test/parallel/test-buffer-from.js
@@ -47,7 +47,7 @@ deepStrictEqual(
   5n,
   (one, two, three) => {},
   undefined,
-  null
+  null,
 ].forEach((input) => {
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
diff --git a/test/parallel/test-buffer-includes.js b/test/parallel/test-buffer-includes.js
index 5d74303fad6350087dd6e231e2b5ef2d058f25e0..57b3a33aaa487f8c013858ccbad40c39253b70ef 100644
--- a/test/parallel/test-buffer-includes.js
+++ b/test/parallel/test-buffer-includes.js
@@ -275,7 +275,7 @@ for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
 [
   () => { },
   {},
-  []
+  [],
 ].forEach((val) => {
   assert.throws(
     () => b.includes(val),
diff --git a/test/parallel/test-buffer-indexof.js b/test/parallel/test-buffer-indexof.js
index b17520366e506a08593e50143ad4f5829fb71cea..68a5cbb45c624b429f6f9674c2b3eca5cc3ba86a 100644
--- a/test/parallel/test-buffer-indexof.js
+++ b/test/parallel/test-buffer-indexof.js
@@ -180,15 +180,18 @@ assert.strictEqual(Buffer.from('aaaa0').indexOf('30', 'hex'), 4);
 assert.strictEqual(Buffer.from('aaaa00a').indexOf('3030', 'hex'), 4);
 
 {
-  // test usc2 encoding
-  const twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
-
-  assert.strictEqual(twoByteString.indexOf('\u0395', 4, 'ucs2'), 8);
-  assert.strictEqual(twoByteString.indexOf('\u03a3', -4, 'ucs2'), 6);
-  assert.strictEqual(twoByteString.indexOf('\u03a3', -6, 'ucs2'), 4);
-  assert.strictEqual(twoByteString.indexOf(
-    Buffer.from('\u03a3', 'ucs2'), -6, 'ucs2'), 4);
-  assert.strictEqual(-1, twoByteString.indexOf('\u03a3', -2, 'ucs2'));
+  // Test usc2 and utf16le encoding
+  ['ucs2', 'utf16le'].forEach((encoding) => {
+    const twoByteString = Buffer.from(
+      '\u039a\u0391\u03a3\u03a3\u0395', encoding);
+
+    assert.strictEqual(twoByteString.indexOf('\u0395', 4, encoding), 8);
+    assert.strictEqual(twoByteString.indexOf('\u03a3', -4, encoding), 6);
+    assert.strictEqual(twoByteString.indexOf('\u03a3', -6, encoding), 4);
+    assert.strictEqual(twoByteString.indexOf(
+      Buffer.from('\u03a3', encoding), -6, encoding), 4);
+    assert.strictEqual(-1, twoByteString.indexOf('\u03a3', -2, encoding));
+  });
 }
 
 const mixedByteStringUcs2 =
@@ -350,7 +353,7 @@ assert.strictEqual(Buffer.from('aaaaa').indexOf('b', 'ucs2'), -1);
 [
   () => {},
   {},
-  []
+  [],
 ].forEach((val) => {
   assert.throws(
     () => b.indexOf(val),
diff --git a/test/parallel/test-buffer-isencoding.js b/test/parallel/test-buffer-isencoding.js
index e67d1c078397a3e2fb29423217aa14b09aa0090e..f9150055cc3a5c0e6209753ff1949d48941fbc62 100644
--- a/test/parallel/test-buffer-isencoding.js
+++ b/test/parallel/test-buffer-isencoding.js
@@ -11,10 +11,11 @@ const assert = require('assert');
   'latin1',
   'binary',
   'base64',
+  'base64url',
   'ucs2',
   'ucs-2',
   'utf16le',
-  'utf-16le'
+  'utf-16le',
 ].forEach((enc) => {
   assert.strictEqual(Buffer.isEncoding(enc), true);
 });
@@ -31,7 +32,7 @@ const assert = require('assert');
   [],
   1,
   0,
-  -1
+  -1,
 ].forEach((enc) => {
   assert.strictEqual(Buffer.isEncoding(enc), false);
 });
diff --git a/test/parallel/test-buffer-iterator.js b/test/parallel/test-buffer-iterator.js
index 0016b021c078bf93deff9895488203580bcca54a..6cf64712c0f4475ff72e281148115e3a79ec9996 100644
--- a/test/parallel/test-buffer-iterator.js
+++ b/test/parallel/test-buffer-iterator.js
@@ -58,5 +58,5 @@ assert.deepStrictEqual(arr, [
   [1, 2],
   [2, 3],
   [3, 4],
-  [4, 5]
+  [4, 5],
 ]);
diff --git a/test/parallel/test-buffer-parent-property.js b/test/parallel/test-buffer-parent-property.js
index 5dae996b87feff017436232ab54a3a48d74ffa39..24cdaade43fb1ecb0b5d778a1cda4d8820652757 100644
--- a/test/parallel/test-buffer-parent-property.js
+++ b/test/parallel/test-buffer-parent-property.js
@@ -1,11 +1,9 @@
 'use strict';
 
-/*
- * Fix for https://github.com/nodejs/node/issues/8266
- *
- * Zero length Buffer objects should expose the `buffer` property of the
- * TypedArrays, via the `parent` property.
- */
+// Fix for https://github.com/nodejs/node/issues/8266
+//
+// Zero length Buffer objects should expose the `buffer` property of the
+// TypedArrays, via the `parent` property.
 require('../common');
 const assert = require('assert');
 
diff --git a/test/parallel/test-buffer-pool-untransferable.js b/test/parallel/test-buffer-pool-untransferable.js
index 96e109c113fee811657b35602fc37adbe8434abf..d39b03435fa5b74f78326e3cd52d6a7ae95d3b81 100644
--- a/test/parallel/test-buffer-pool-untransferable.js
+++ b/test/parallel/test-buffer-pool-untransferable.js
@@ -15,6 +15,6 @@ const length = a.length;
 const { port1 } = new MessageChannel();
 port1.postMessage(a, [ a.buffer ]);
 
-// Verify that the pool ArrayBuffer has not actually been transfered:
+// Verify that the pool ArrayBuffer has not actually been transferred:
 assert.strictEqual(a.buffer, b.buffer);
 assert.strictEqual(a.length, length);
diff --git a/test/parallel/test-buffer-slice.js b/test/parallel/test-buffer-slice.js
index f40a495b2060793c66ba5efdc72de849a3bcc815..05cbfba4733829ee728d3e0e7fb10bb6ecabb671 100644
--- a/test/parallel/test-buffer-slice.js
+++ b/test/parallel/test-buffer-slice.js
@@ -59,7 +59,7 @@ const expectedSameBufs = [
   [buf.slice('-10', '-5'), Buffer.from('01234', 'utf8')],
   [buf.slice('-10', '-0'), Buffer.from('', 'utf8')],
   [buf.slice('111'), Buffer.from('', 'utf8')],
-  [buf.slice('0', '-111'), Buffer.from('', 'utf8')]
+  [buf.slice('0', '-111'), Buffer.from('', 'utf8')],
 ];
 
 for (let i = 0, s = buf.toString(); i < buf.length; ++i) {
@@ -114,13 +114,13 @@ assert.strictEqual(Buffer.from('hello', 'utf8').slice(0, 0).length, 0);
 {
   const buf = Buffer.from([
     1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0,
-    0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0
+    0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0,
   ]);
   const chunk1 = Buffer.from([
-    1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0
+    1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0,
   ]);
   const chunk2 = Buffer.from([
-    0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0
+    0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0,
   ]);
   const middle = buf.length / 2;
 
diff --git a/test/parallel/test-buffer-write.js b/test/parallel/test-buffer-write.js
index 842b12c04c04dbf5a0213d9722949d7076b7e2b1..128327c47e5d6f6e8868f85eafbe0b2346317484 100644
--- a/test/parallel/test-buffer-write.js
+++ b/test/parallel/test-buffer-write.js
@@ -23,7 +23,8 @@ const resultMap = new Map([
   ['binary', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])],
   ['utf16le', Buffer.from([102, 0, 111, 0, 111, 0, 0, 0, 0])],
   ['base64', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])],
-  ['hex', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])]
+  ['base64url', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])],
+  ['hex', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])],
 ]);
 
 // utf8, ucs2, ascii, latin1, utf16le
@@ -44,7 +45,7 @@ encodings
   });
 
 // base64
-['base64', 'BASE64'].forEach((encoding) => {
+['base64', 'BASE64', 'base64url', 'BASE64URL'].forEach((encoding) => {
   const buf = Buffer.alloc(9);
   const len = Buffer.byteLength('Zm9v', encoding);
 
diff --git a/test/parallel/test-buffer-writedouble.js b/test/parallel/test-buffer-writedouble.js
index 3f156d8297d40e88244ab9d9870df9d31eed7f9a..5026c8187430b3ae5aee74224aa378996cc6bd6d 100644
--- a/test/parallel/test-buffer-writedouble.js
+++ b/test/parallel/test-buffer-writedouble.js
@@ -11,35 +11,35 @@ buffer.writeDoubleBE(2.225073858507201e-308, 0);
 buffer.writeDoubleLE(2.225073858507201e-308, 8);
 assert.ok(buffer.equals(new Uint8Array([
   0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00,
 ])));
 
 buffer.writeDoubleBE(1.0000000000000004, 0);
 buffer.writeDoubleLE(1.0000000000000004, 8);
 assert.ok(buffer.equals(new Uint8Array([
   0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
-  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f
+  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f,
 ])));
 
 buffer.writeDoubleBE(-2, 0);
 buffer.writeDoubleLE(-2, 8);
 assert.ok(buffer.equals(new Uint8Array([
   0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
 ])));
 
 buffer.writeDoubleBE(1.7976931348623157e+308, 0);
 buffer.writeDoubleLE(1.7976931348623157e+308, 8);
 assert.ok(buffer.equals(new Uint8Array([
   0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0x7f
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0x7f,
 ])));
 
 buffer.writeDoubleBE(0 * -1, 0);
 buffer.writeDoubleLE(0 * -1, 8);
 assert.ok(buffer.equals(new Uint8Array([
   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
 ])));
 
 buffer.writeDoubleBE(Infinity, 0);
@@ -47,7 +47,7 @@ buffer.writeDoubleLE(Infinity, 8);
 
 assert.ok(buffer.equals(new Uint8Array([
   0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x7F
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x7F,
 ])));
 
 assert.strictEqual(buffer.readDoubleBE(0), Infinity);
@@ -58,7 +58,7 @@ buffer.writeDoubleLE(-Infinity, 8);
 
 assert.ok(buffer.equals(new Uint8Array([
   0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF,
 ])));
 
 assert.strictEqual(buffer.readDoubleBE(0), -Infinity);
@@ -72,12 +72,12 @@ buffer.writeDoubleLE(NaN, 8);
 if (buffer[1] === 0xF7) {
   assert.ok(buffer.equals(new Uint8Array([
     0x7F, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x7F
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x7F,
   ])));
 } else {
   assert.ok(buffer.equals(new Uint8Array([
     0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F,
   ])));
 }
 
diff --git a/test/parallel/test-buffer-writeint.js b/test/parallel/test-buffer-writeint.js
index 4799fb33d77b603f4adba7050a959de8db579cf7..e4b916b1cff27fae30e2936c2172bfca821552d0 100644
--- a/test/parallel/test-buffer-writeint.js
+++ b/test/parallel/test-buffer-writeint.js
@@ -107,32 +107,32 @@ const errorOutOfBounds = {
   buffer.writeInt32BE(0x23, 0);
   buffer.writeInt32LE(0x23, 4);
   assert.ok(buffer.equals(new Uint8Array([
-    0x00, 0x00, 0x00, 0x23, 0x23, 0x00, 0x00, 0x00
+    0x00, 0x00, 0x00, 0x23, 0x23, 0x00, 0x00, 0x00,
   ])));
 
   buffer.writeInt32BE(-5, 0);
   buffer.writeInt32LE(-5, 4);
   assert.ok(buffer.equals(new Uint8Array([
-    0xff, 0xff, 0xff, 0xfb, 0xfb, 0xff, 0xff, 0xff
+    0xff, 0xff, 0xff, 0xfb, 0xfb, 0xff, 0xff, 0xff,
   ])));
 
   buffer.writeInt32BE(-805306713, 0);
   buffer.writeInt32LE(-805306713, 4);
   assert.ok(buffer.equals(new Uint8Array([
-    0xcf, 0xff, 0xfe, 0xa7, 0xa7, 0xfe, 0xff, 0xcf
+    0xcf, 0xff, 0xfe, 0xa7, 0xa7, 0xfe, 0xff, 0xcf,
   ])));
 
   /* Make sure we handle min/max correctly */
   buffer.writeInt32BE(0x7fffffff, 0);
   buffer.writeInt32BE(-0x80000000, 4);
   assert.ok(buffer.equals(new Uint8Array([
-    0x7f, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00
+    0x7f, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00,
   ])));
 
   buffer.writeInt32LE(0x7fffffff, 0);
   buffer.writeInt32LE(-0x80000000, 4);
   assert.ok(buffer.equals(new Uint8Array([
-    0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x80
+    0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x80,
   ])));
 
   ['writeInt32BE', 'writeInt32LE'].forEach((fn) => {
@@ -168,12 +168,12 @@ const errorOutOfBounds = {
   const buffer = Buffer.allocUnsafe(6);
   buffer.writeIntBE(value, 0, 6);
   assert.ok(buffer.equals(new Uint8Array([
-    0x12, 0x34, 0x56, 0x78, 0x90, 0xab
+    0x12, 0x34, 0x56, 0x78, 0x90, 0xab,
   ])));
 
   buffer.writeIntLE(value, 0, 6);
   assert.ok(buffer.equals(new Uint8Array([
-    0xab, 0x90, 0x78, 0x56, 0x34, 0x12
+    0xab, 0x90, 0x78, 0x56, 0x34, 0x12,
   ])));
 }
 
diff --git a/test/parallel/test-buffer-writeuint.js b/test/parallel/test-buffer-writeuint.js
index 7667d9381900dd81cea8183d368beb31fa38dad1..efacdb7ab48c3bea6f555f5c623d979b0bb704d4 100644
--- a/test/parallel/test-buffer-writeuint.js
+++ b/test/parallel/test-buffer-writeuint.js
@@ -3,13 +3,11 @@
 require('../common');
 const assert = require('assert');
 
-/*
- * We need to check the following things:
- *  - We are correctly resolving big endian (doesn't mean anything for 8 bit)
- *  - Correctly resolving little endian (doesn't mean anything for 8 bit)
- *  - Correctly using the offsets
- *  - Correctly interpreting values that are beyond the signed range as unsigned
- */
+// We need to check the following things:
+//  - We are correctly resolving big endian (doesn't mean anything for 8 bit)
+//  - Correctly resolving little endian (doesn't mean anything for 8 bit)
+//  - Correctly using the offsets
+//  - Correctly interpreting values that are beyond the signed range as unsigned
 
 { // OOB
   const data = Buffer.alloc(8);
diff --git a/test/parallel/test-buffer-zero-fill-cli.js b/test/parallel/test-buffer-zero-fill-cli.js
index 2f3b243c470c3cf7543665436a655f974596f8a8..4299f81039b0b557e6d23f77635cffff930391b7 100644
--- a/test/parallel/test-buffer-zero-fill-cli.js
+++ b/test/parallel/test-buffer-zero-fill-cli.js
@@ -24,7 +24,7 @@ for (let i = 0; i < 50; i++) {
     Buffer.allocUnsafe(20),
     SlowBuffer(20),
     Buffer(20),
-    new SlowBuffer(20)
+    new SlowBuffer(20),
   ];
   for (const buf of bufs) {
     assert(isZeroFilled(buf));
diff --git a/test/parallel/test-c-ares.js b/test/parallel/test-c-ares.js
index 383edd6f887a0103e82a1ad1efe4ad19f46e027c..a6d27a1ebebcfc9c47f7387dbf0abe6756326017 100644
--- a/test/parallel/test-c-ares.js
+++ b/test/parallel/test-c-ares.js
@@ -40,23 +40,20 @@ const dnsPromises = dns.promises;
   res = await dnsPromises.lookup('::1');
   assert.strictEqual(res.address, '::1');
   assert.strictEqual(res.family, 6);
-})();
+})().then(common.mustCall());
 
 // Try resolution without hostname.
-dns.lookup(null, common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
+dns.lookup(null, common.mustSucceed((result, addressType) => {
   assert.strictEqual(result, null);
   assert.strictEqual(addressType, 4);
 }));
 
-dns.lookup('127.0.0.1', common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
+dns.lookup('127.0.0.1', common.mustSucceed((result, addressType) => {
   assert.strictEqual(result, '127.0.0.1');
   assert.strictEqual(addressType, 4);
 }));
 
-dns.lookup('::1', common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
+dns.lookup('::1', common.mustSucceed((result, addressType) => {
   assert.strictEqual(result, '::1');
   assert.strictEqual(addressType, 6);
 }));
@@ -65,7 +62,7 @@ dns.lookup('::1', common.mustCall((error, result, addressType) => {
   // Try calling resolve with an unsupported type.
   'HI',
   // Try calling resolve with an unsupported type that's an object key
-  'toString'
+  'toString',
 ].forEach((val) => {
   const err = {
     code: 'ERR_INVALID_OPT_VALUE',
@@ -86,12 +83,11 @@ dns.lookup('::1', common.mustCall((error, result, addressType) => {
 // so we disable this test on Windows.
 // IBMi reports `ENOTFOUND` when get hostname by address 127.0.0.1
 if (!common.isWindows && !common.isIBMi) {
-  dns.reverse('127.0.0.1', common.mustCall(function(error, domains) {
-    assert.ifError(error);
+  dns.reverse('127.0.0.1', common.mustSucceed((domains) => {
     assert.ok(Array.isArray(domains));
   }));
 
   (async function() {
     assert.ok(Array.isArray(await dnsPromises.reverse('127.0.0.1')));
-  })();
+  })().then(common.mustCall());
 }
diff --git a/test/parallel/test-child-process-advanced-serialization-largebuffer.js b/test/parallel/test-child-process-advanced-serialization-largebuffer.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e80bce40570f9f7c00e257017dd9dbe574fe396
--- /dev/null
+++ b/test/parallel/test-child-process-advanced-serialization-largebuffer.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const child_process = require('child_process');
+
+// Regression test for https://github.com/nodejs/node/issues/34797
+const eightMB = 8 * 1024 * 1024;
+
+if (process.argv[2] === 'child') {
+  for (let i = 0; i < 4; i++) {
+    process.send(new Uint8Array(eightMB).fill(i));
+  }
+} else {
+  const child = child_process.spawn(process.execPath, [__filename, 'child'], {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+    serialization: 'advanced'
+  });
+  const received = [];
+  child.on('message', common.mustCall((chunk) => {
+    assert.deepStrictEqual(chunk, new Uint8Array(eightMB).fill(chunk[0]));
+
+    received.push(chunk[0]);
+    if (received.length === 4) {
+      assert.deepStrictEqual(received, [0, 1, 2, 3]);
+    }
+  }, 4));
+}
diff --git a/test/parallel/test-child-process-advanced-serialization.js b/test/parallel/test-child-process-advanced-serialization.js
index 0303fc719d331c5e66cdbe6ea3a3fc23a240703c..d75f0b59989bc66e70dcf35163a0eeee14612f68 100644
--- a/test/parallel/test-child-process-advanced-serialization.js
+++ b/test/parallel/test-child-process-advanced-serialization.js
@@ -11,7 +11,8 @@ if (process.argv[2] !== 'child') {
     }, {
       code: 'ERR_INVALID_OPT_VALUE',
       message: `The value "${value}" is invalid ` +
-        'for option "options.serialization"'
+      'for option "options.serialization". ' +
+      "Must be one of: undefined, 'json', 'advanced'"
     });
   }
 
diff --git a/test/parallel/test-child-process-can-write-to-stdout.js b/test/parallel/test-child-process-can-write-to-stdout.js
index bb9ddb71c827bcd97ab697e69f315003fde6dd7d..069e07fb160282c1c72bfff17809b9c1f51c27c0 100644
--- a/test/parallel/test-child-process-can-write-to-stdout.js
+++ b/test/parallel/test-child-process-can-write-to-stdout.js
@@ -8,7 +8,7 @@ const assert = require('assert');
 const spawn = require('child_process').spawn;
 
 const child = spawn(process.argv[0], [
-  fixtures.path('GH-1899-output.js')
+  fixtures.path('GH-1899-output.js'),
 ]);
 let output = '';
 
diff --git a/test/parallel/test-child-process-cwd.js b/test/parallel/test-child-process-cwd.js
index af71edd8af3e3556e5624f37cd7f006d76c99427..869db83db3902e2bc69a7adb062937746752a8ee 100644
--- a/test/parallel/test-child-process-cwd.js
+++ b/test/parallel/test-child-process-cwd.js
@@ -20,21 +20,24 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
+
 const common = require('../common');
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
 const assert = require('assert');
 const { spawn } = require('child_process');
+const { pathToFileURL, URL } = require('url');
 
-/*
-  Spawns 'pwd' with given options, then test
-  - whether the exit code equals expectCode,
-  - optionally whether the trimmed stdout result matches expectData
-*/
-function testCwd(options, expectCode = 0, expectData) {
+// Spawns 'pwd' with given options, then test
+// - whether the child pid is undefined or number,
+// - whether the exit code equals expectCode,
+// - optionally whether the trimmed stdout result matches expectData
+function testCwd(options, expectPidType, expectCode = 0, expectData) {
   const child = spawn(...common.pwdCommand, options);
 
+  assert.strictEqual(typeof child.pid, expectPidType);
+
   child.stdout.setEncoding('utf8');
 
   // No need to assert callback since `data` is asserted.
@@ -59,18 +62,35 @@ function testCwd(options, expectCode = 0, expectData) {
 
 // Assume does-not-exist doesn't exist, expect exitCode=-1 and errno=ENOENT
 {
-  testCwd({ cwd: 'does-not-exist' }, -1)
+  testCwd({ cwd: 'does-not-exist' }, 'undefined', -1)
     .on('error', common.mustCall(function(e) {
       assert.strictEqual(e.code, 'ENOENT');
     }));
 }
 
+{
+  assert.throws(() => {
+    testCwd({
+      cwd: new URL('http://example.com/'),
+    }, 'number', 0, tmpdir.path);
+  }, /The URL must be of scheme file/);
+
+  if (process.platform !== 'win32') {
+    assert.throws(() => {
+      testCwd({
+        cwd: new URL('file://host/dev/null'),
+      }, 'number', 0, tmpdir.path);
+    }, /File URL host must be "localhost" or empty on/);
+  }
+}
+
 // Assume these exist, and 'pwd' gives us the right directory back
-testCwd({ cwd: tmpdir.path }, 0, tmpdir.path);
+testCwd({ cwd: tmpdir.path }, 'number', 0, tmpdir.path);
 const shouldExistDir = common.isWindows ? process.env.windir : '/dev';
-testCwd({ cwd: shouldExistDir }, 0, shouldExistDir);
+testCwd({ cwd: shouldExistDir }, 'number', 0, shouldExistDir);
+testCwd({ cwd: pathToFileURL(tmpdir.path) }, 'number', 0, tmpdir.path);
 
 // Spawn() shouldn't try to chdir() to invalid arg, so this should just work
-testCwd({ cwd: '' });
-testCwd({ cwd: undefined });
-testCwd({ cwd: null });
+testCwd({ cwd: '' }, 'number');
+testCwd({ cwd: undefined }, 'number');
+testCwd({ cwd: null }, 'number');
diff --git a/test/parallel/test-child-process-double-pipe.js b/test/parallel/test-child-process-double-pipe.js
index 11e9ce1cb532a696399387513b28cde1a54b064b..7a432d3892acfcdbbc5dfe03c74d0bbaaba49ca5 100644
--- a/test/parallel/test-child-process-double-pipe.js
+++ b/test/parallel/test-child-process-double-pipe.js
@@ -47,15 +47,13 @@ if (isWindows) {
   echo = spawn('echo', ['hello\nnode\nand\nworld\n']);
 }
 
-/*
- * grep and sed hang if the spawn function leaks file descriptors to child
- * processes.
- * This happens when calling pipe(2) and then forgetting to set the
- * FD_CLOEXEC flag on the resulting file descriptors.
- *
- * This test checks child processes exit, meaning they don't hang like
- * explained above.
- */
+// If the spawn function leaks file descriptors to subprocesses, grep and sed
+// hang.
+// This happens when calling pipe(2) and then forgetting to set the
+// FD_CLOEXEC flag on the resulting file descriptors.
+//
+// This test checks child processes exit, meaning they don't hang like
+// explained above.
 
 
 // pipe echo | grep
diff --git a/test/parallel/test-child-process-exec-abortcontroller-promisified.js b/test/parallel/test-child-process-exec-abortcontroller-promisified.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf3c1c92b5ec21e9c128bfff1ae95d29161bfda5
--- /dev/null
+++ b/test/parallel/test-child-process-exec-abortcontroller-promisified.js
@@ -0,0 +1,48 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const exec = require('child_process').exec;
+const { promisify } = require('util');
+
+const execPromisifed = promisify(exec);
+const invalidArgTypeError = {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError'
+};
+
+const waitCommand = common.isLinux ?
+  'sleep 2m' :
+  `${process.execPath} -e "setInterval(()=>{}, 99)"`;
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  const promise = execPromisifed(waitCommand, { signal });
+  assert.rejects(promise, /AbortError/, 'post aborted sync signal failed')
+        .then(common.mustCall());
+  ac.abort();
+}
+
+{
+  assert.throws(() => {
+    execPromisifed(waitCommand, { signal: {} });
+  }, invalidArgTypeError);
+}
+
+{
+  function signal() {}
+  assert.throws(() => {
+    execPromisifed(waitCommand, { signal });
+  }, invalidArgTypeError);
+}
+
+{
+  const ac = new AbortController();
+  const { signal } = ac;
+  ac.abort();
+  const promise = execPromisifed(waitCommand, { signal });
+
+  assert.rejects(promise, /AbortError/, 'pre aborted signal failed')
+        .then(common.mustCall());
+}
diff --git a/test/parallel/test-child-process-exec-any-shells-windows.js b/test/parallel/test-child-process-exec-any-shells-windows.js
index 0e78b6656897205b5f331bd58212d338580465d2..5c34bc77308cc397d3a32087a079bb28982be0a7 100644
--- a/test/parallel/test-child-process-exec-any-shells-windows.js
+++ b/test/parallel/test-child-process-exec-any-shells-windows.js
@@ -17,8 +17,8 @@ fs.mkdirSync(tmpPath);
 
 const test = (shell) => {
   cp.exec('echo foo bar', { shell: shell },
-          common.mustCall((error, stdout, stderror) => {
-            assert.ok(!error && !stderror);
+          common.mustSucceed((stdout, stderror) => {
+            assert.ok(!stderror);
             assert.ok(stdout.includes('foo') && stdout.includes('bar'));
           }));
 };
@@ -43,12 +43,11 @@ test('CMD');
 test('powershell');
 testCopy('powershell.exe',
          `${system32}\\WindowsPowerShell\\v1.0\\powershell.exe`);
-fs.writeFile(`${tmpPath}\\test file`, 'Test', common.mustCall((err) => {
-  assert.ifError(err);
+fs.writeFile(`${tmpPath}\\test file`, 'Test', common.mustSucceed(() => {
   cp.exec(`Get-ChildItem "${tmpPath}" | Select-Object -Property Name`,
           { shell: 'PowerShell' },
-          common.mustCall((error, stdout, stderror) => {
-            assert.ok(!error && !stderror);
+          common.mustSucceed((stdout, stderror) => {
+            assert.ok(!stderror);
             assert.ok(stdout.includes(
               'test file'));
           }));
diff --git a/test/parallel/test-child-process-exec-cwd.js b/test/parallel/test-child-process-exec-cwd.js
index c16f77f4c529062ecabf5c6fda86feb78bcfa963..2f86cf10fe5e0f886e962d6afeff73fbe51e1b36 100644
--- a/test/parallel/test-child-process-exec-cwd.js
+++ b/test/parallel/test-child-process-exec-cwd.js
@@ -34,7 +34,6 @@ if (common.isWindows) {
   dir = '/dev';
 }
 
-exec(pwdcommand, { cwd: dir }, common.mustCall(function(err, stdout, stderr) {
-  assert.ifError(err);
+exec(pwdcommand, { cwd: dir }, common.mustSucceed((stdout, stderr) => {
   assert(stdout.startsWith(dir));
 }));
diff --git a/test/parallel/test-child-process-exec-encoding.js b/test/parallel/test-child-process-exec-encoding.js
index d7c059a65ab4d81908db9813a20cec07056cf31f..0c3178e3f206073d0522bc91ac60e4f2cdce25d0 100644
--- a/test/parallel/test-child-process-exec-encoding.js
+++ b/test/parallel/test-child-process-exec-encoding.js
@@ -15,8 +15,7 @@ if (process.argv[2] === 'child') {
   function run(options, callback) {
     const cmd = `"${process.execPath}" "${__filename}" child`;
 
-    cp.exec(cmd, options, common.mustCall((err, stdout, stderr) => {
-      assert.ifError(err);
+    cp.exec(cmd, options, common.mustSucceed((stdout, stderr) => {
       callback(stdout, stderr);
     }));
   }
diff --git a/test/parallel/test-child-process-exec-error.js b/test/parallel/test-child-process-exec-error.js
index eaddeb6614e921e4a450e1514d14422ede40cd17..cd45f3071c2920dda406fac076517d2c92372441 100644
--- a/test/parallel/test-child-process-exec-error.js
+++ b/test/parallel/test-child-process-exec-error.js
@@ -24,17 +24,21 @@ const common = require('../common');
 const assert = require('assert');
 const child_process = require('child_process');
 
-function test(fn, code) {
-  fn('does-not-exist', common.mustCall(function(err) {
+function test(fn, code, expectPidType = 'number') {
+  const child = fn('does-not-exist', common.mustCall(function(err) {
     assert.strictEqual(err.code, code);
     assert(err.cmd.includes('does-not-exist'));
   }));
+
+  assert.strictEqual(typeof child.pid, expectPidType);
 }
 
+// With `shell: true`, expect pid (of the shell)
 if (common.isWindows) {
-  test(child_process.exec, 1); // Exit code of cmd.exe
+  test(child_process.exec, 1, 'number'); // Exit code of cmd.exe
 } else {
-  test(child_process.exec, 127); // Exit code of /bin/sh
+  test(child_process.exec, 127, 'number'); // Exit code of /bin/sh
 }
 
-test(child_process.execFile, 'ENOENT');
+// With `shell: false`, expect no pid
+test(child_process.execFile, 'ENOENT', 'undefined');
diff --git a/test/parallel/test-child-process-exec-maxbuf.js b/test/parallel/test-child-process-exec-maxbuf.js
index 0f639b5dd90e1d0677287b40ffbd409faece47d9..c434c8531d7ebfe0fd02053f50fcf70e0829e7f1 100644
--- a/test/parallel/test-child-process-exec-maxbuf.js
+++ b/test/parallel/test-child-process-exec-maxbuf.js
@@ -27,8 +27,7 @@ function runChecks(err, stdio, streamName, expected) {
   const cmd =
     `${process.execPath} -e "console.log('a'.repeat(1024 * 1024 - 1))"`;
 
-  cp.exec(cmd, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
+  cp.exec(cmd, common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout.trim(), 'a'.repeat(1024 * 1024 - 1));
     assert.strictEqual(stderr, '');
   }));
@@ -38,8 +37,7 @@ function runChecks(err, stdio, streamName, expected) {
   const cmd = `"${process.execPath}" -e "console.log('hello world');"`;
   const options = { maxBuffer: Infinity };
 
-  cp.exec(cmd, options, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
+  cp.exec(cmd, options, common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout.trim(), 'hello world');
     assert.strictEqual(stderr, '');
   }));
@@ -80,8 +78,7 @@ function runChecks(err, stdio, streamName, expected) {
   const cmd =
     `"${process.execPath}" -e "console.log('a'.repeat(1024 * 1024 - 1))"`;
 
-  cp.exec(cmd, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
+  cp.exec(cmd, common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout.trim(), 'a'.repeat(1024 * 1024 - 1));
     assert.strictEqual(stderr, '');
   }));
diff --git a/test/parallel/test-child-process-exec-std-encoding.js b/test/parallel/test-child-process-exec-std-encoding.js
index 11cb66cf42cc5b36662e27ee3d22d12d6345c760..08187316726e96c68584117fe1dafb741a311af6 100644
--- a/test/parallel/test-child-process-exec-std-encoding.js
+++ b/test/parallel/test-child-process-exec-std-encoding.js
@@ -13,8 +13,7 @@ if (process.argv[2] === 'child') {
   console.error(stderrData);
 } else {
   const cmd = `"${process.execPath}" "${__filename}" child`;
-  const child = cp.exec(cmd, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
+  const child = cp.exec(cmd, common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout, expectedStdout);
     assert.strictEqual(stderr, expectedStderr);
   }));
diff --git a/test/parallel/test-child-process-exec-timeout.js b/test/parallel/test-child-process-exec-timeout.js
index 343050e063c68049c91852178a575f6d5e723077..64648d62bb32847d8a0b8d38b96ebbf9aa8e0425 100644
--- a/test/parallel/test-child-process-exec-timeout.js
+++ b/test/parallel/test-child-process-exec-timeout.js
@@ -51,8 +51,7 @@ cp.exec(cmd, {
 }));
 
 // Test the case where a timeout is set, but not expired.
-cp.exec(cmd, { timeout: 2 ** 30 }, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
+cp.exec(cmd, { timeout: 2 ** 30 }, common.mustSucceed((stdout, stderr) => {
   assert.strictEqual(stdout.trim(), 'child stdout');
   assert.strictEqual(stderr.trim(), 'child stderr');
 }));
@@ -68,7 +67,7 @@ if (common.isWindows) {
       'where',
       `commandline like '%${basename}%child'`,
       'delete',
-      '/nointeractive'
+      '/nointeractive',
     ]);
   });
 }
diff --git a/test/parallel/test-child-process-execFile-promisified-abortController.js b/test/parallel/test-child-process-execFile-promisified-abortController.js
new file mode 100644
index 0000000000000000000000000000000000000000..b2724eeb01be7a43fe0705a2bcd47b40887ab9ac
--- /dev/null
+++ b/test/parallel/test-child-process-execFile-promisified-abortController.js
@@ -0,0 +1,59 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { promisify } = require('util');
+const execFile = require('child_process').execFile;
+const fixtures = require('../common/fixtures');
+
+const echoFixture = fixtures.path('echo.js');
+const promisified = promisify(execFile);
+const invalidArgTypeError = {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError'
+};
+
+{
+  // Verify that the signal option works properly
+  const ac = new AbortController();
+  const signal = ac.signal;
+  const promise = promisified(process.execPath, [echoFixture, 0], { signal });
+
+  ac.abort();
+
+  assert.rejects(
+    promise,
+    { name: 'AbortError' }
+  ).then(common.mustCall());
+}
+
+{
+  // Verify that the signal option works properly when already aborted
+  const ac = new AbortController();
+  const { signal } = ac;
+  ac.abort();
+
+  assert.rejects(
+    promisified(process.execPath, [echoFixture, 0], { signal }),
+    { name: 'AbortError' }
+  ).then(common.mustCall());
+}
+
+{
+  // Verify that if something different than Abortcontroller.signal
+  // is passed, ERR_INVALID_ARG_TYPE is thrown
+  const signal = {};
+  assert.throws(() => {
+    promisified(process.execPath, [echoFixture, 0], { signal });
+  }, invalidArgTypeError);
+}
+
+{
+  // Verify that if something different than Abortcontroller.signal
+  // is passed, ERR_INVALID_ARG_TYPE is thrown
+  const signal = 'world!';
+  assert.throws(() => {
+    promisified(process.execPath, [echoFixture, 0], { signal });
+  }, invalidArgTypeError);
+}
diff --git a/test/parallel/test-child-process-execfile-maxbuf.js b/test/parallel/test-child-process-execfile-maxbuf.js
index 8cc9b95d374367bfba69cea46ad3ccf110e4e858..22fb9264ea8c532d4546d1fda0cc5560b44602e6 100644
--- a/test/parallel/test-child-process-execfile-maxbuf.js
+++ b/test/parallel/test-child-process-execfile-maxbuf.js
@@ -25,8 +25,7 @@ function checkFactory(streamName) {
   execFile(
     process.execPath,
     ['-e', 'console.log("a".repeat(1024 * 1024 - 1))'],
-    common.mustCall((err, stdout, stderr) => {
-      assert.ifError(err);
+    common.mustSucceed((stdout, stderr) => {
       assert.strictEqual(stdout.trim(), 'a'.repeat(1024 * 1024 - 1));
       assert.strictEqual(stderr, '');
     })
@@ -40,8 +39,7 @@ function checkFactory(streamName) {
     process.execPath,
     ['-e', 'console.log("hello world");'],
     options,
-    common.mustCall((err, stdout, stderr) => {
-      assert.ifError(err);
+    common.mustSucceed((stdout, stderr) => {
       assert.strictEqual(stdout.trim(), 'hello world');
       assert.strictEqual(stderr, '');
     })
diff --git a/test/parallel/test-child-process-execfile.js b/test/parallel/test-child-process-execfile.js
index af69d685789d62db6b6d023bd817c875ab17f7cb..f75dd05f81a386658644bb9c31e4ccb68d010eed 100644
--- a/test/parallel/test-child-process-execfile.js
+++ b/test/parallel/test-child-process-execfile.js
@@ -1,12 +1,15 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
 const assert = require('assert');
 const execFile = require('child_process').execFile;
+const { getEventListeners } = require('events');
 const { getSystemErrorName } = require('util');
 const fixtures = require('../common/fixtures');
 
 const fixture = fixtures.path('exit.js');
+const echoFixture = fixtures.path('echo.js');
 const execOpts = { encoding: 'utf8', shell: true };
 
 {
@@ -43,7 +46,59 @@ const execOpts = { encoding: 'utf8', shell: true };
 
 {
   // Verify the shell option works properly
-  execFile(process.execPath, [fixture, 0], execOpts, common.mustCall((err) => {
-    assert.ifError(err);
-  }));
+  execFile(process.execPath, [fixture, 0], execOpts, common.mustSucceed());
+}
+
+{
+  // Verify that the signal option works properly
+  const ac = new AbortController();
+  const { signal } = ac;
+
+  const test = () => {
+    const check = common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ABORT_ERR');
+      assert.strictEqual(err.name, 'AbortError');
+      assert.strictEqual(err.signal, undefined);
+    });
+    execFile(process.execPath, [echoFixture, 0], { signal }, check);
+  };
+
+  // Verify that it still works the same way now that the signal is aborted.
+  test();
+  ac.abort();
+}
+
+{
+  // Verify that does not spawn a child if already aborted
+  const ac = new AbortController();
+  const { signal } = ac;
+  ac.abort();
+
+  const check = common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ABORT_ERR');
+    assert.strictEqual(err.name, 'AbortError');
+    assert.strictEqual(err.signal, undefined);
+  });
+  execFile(process.execPath, [echoFixture, 0], { signal }, check);
+}
+
+{
+  // Verify that if something different than Abortcontroller.signal
+  // is passed, ERR_INVALID_ARG_TYPE is thrown
+  assert.throws(() => {
+    const callback = common.mustNotCall(() => {});
+
+    execFile(process.execPath, [echoFixture, 0], { signal: 'hello' }, callback);
+  }, { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+}
+{
+  // Verify that the process completing removes the abort listener
+  const ac = new AbortController();
+  const { signal } = ac;
+
+  const callback = common.mustCall((err) => {
+    assert.strictEqual(getEventListeners(ac.signal).length, 0);
+    assert.strictEqual(err, null);
+  });
+  execFile(process.execPath, [fixture, 0], { signal }, callback);
 }
diff --git a/test/parallel/test-child-process-execfilesync-maxbuf.js b/test/parallel/test-child-process-execfilesync-maxbuf.js
index 6e89444f3dac72d7ea3ed1b4aaee6262459e8a42..63f8cc26ebb4d31bfeb5ea333c4111637ad2f5f5 100644
--- a/test/parallel/test-child-process-execfilesync-maxbuf.js
+++ b/test/parallel/test-child-process-execfilesync-maxbuf.js
@@ -5,13 +5,14 @@ require('../common');
 // works as expected.
 
 const assert = require('assert');
+const { getSystemErrorName } = require('util');
 const { execFileSync } = require('child_process');
 const msgOut = 'this is stdout';
 const msgOutBuf = Buffer.from(`${msgOut}\n`);
 
 const args = [
   '-e',
-  `console.log("${msgOut}");`
+  `console.log("${msgOut}");`,
 ];
 
 // Verify that an error is returned if maxBuffer is surpassed.
@@ -20,7 +21,8 @@ const args = [
     execFileSync(process.execPath, args, { maxBuffer: 1 });
   }, (e) => {
     assert.ok(e, 'maxBuffer should error');
-    assert.strictEqual(e.errno, 'ENOBUFS');
+    assert.strictEqual(e.code, 'ENOBUFS');
+    assert.strictEqual(getSystemErrorName(e.errno), 'ENOBUFS');
     // We can have buffers larger than maxBuffer because underneath we alloc 64k
     // that matches our read sizes.
     assert.deepStrictEqual(e.stdout, msgOutBuf);
@@ -44,7 +46,8 @@ const args = [
     );
   }, (e) => {
     assert.ok(e, 'maxBuffer should error');
-    assert.strictEqual(e.errno, 'ENOBUFS');
+    assert.strictEqual(e.code, 'ENOBUFS');
+    assert.strictEqual(getSystemErrorName(e.errno), 'ENOBUFS');
     return true;
   });
 }
diff --git a/test/parallel/test-child-process-execsync-maxbuf.js b/test/parallel/test-child-process-execsync-maxbuf.js
index 6400c49b028230f8e461f2259c842f18f63eb981..62b211cc3a3de1a7bd8002e6df619c42b2b4f721 100644
--- a/test/parallel/test-child-process-execsync-maxbuf.js
+++ b/test/parallel/test-child-process-execsync-maxbuf.js
@@ -5,13 +5,14 @@ require('../common');
 // works as expected.
 
 const assert = require('assert');
+const { getSystemErrorName } = require('util');
 const { execSync } = require('child_process');
 const msgOut = 'this is stdout';
 const msgOutBuf = Buffer.from(`${msgOut}\n`);
 
 const args = [
   '-e',
-  `"console.log('${msgOut}')";`
+  `"console.log('${msgOut}')";`,
 ];
 
 // Verify that an error is returned if maxBuffer is surpassed.
@@ -20,7 +21,8 @@ const args = [
     execSync(`"${process.execPath}" ${args.join(' ')}`, { maxBuffer: 1 });
   }, (e) => {
     assert.ok(e, 'maxBuffer should error');
-    assert.strictEqual(e.errno, 'ENOBUFS');
+    assert.strictEqual(e.code, 'ENOBUFS');
+    assert.strictEqual(getSystemErrorName(e.errno), 'ENOBUFS');
     // We can have buffers larger than maxBuffer because underneath we alloc 64k
     // that matches our read sizes.
     assert.deepStrictEqual(e.stdout, msgOutBuf);
@@ -46,7 +48,8 @@ const args = [
     );
   }, (e) => {
     assert.ok(e, 'maxBuffer should error');
-    assert.strictEqual(e.errno, 'ENOBUFS');
+    assert.strictEqual(e.code, 'ENOBUFS');
+    assert.strictEqual(getSystemErrorName(e.errno), 'ENOBUFS');
     return true;
   });
 }
diff --git a/test/parallel/test-child-process-fork-abort-signal.js b/test/parallel/test-child-process-fork-abort-signal.js
new file mode 100644
index 0000000000000000000000000000000000000000..817366a71f2bccefbfd5f0d27fc22bc36d8fb8a3
--- /dev/null
+++ b/test/parallel/test-child-process-fork-abort-signal.js
@@ -0,0 +1,73 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+
+const { mustCall, mustNotCall } = require('../common');
+const { strictEqual } = require('assert');
+const fixtures = require('../common/fixtures');
+const { fork } = require('child_process');
+
+{
+  // Test aborting a forked child_process after calling fork
+  const ac = new AbortController();
+  const { signal } = ac;
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall((code, killSignal) => {
+    strictEqual(code, null);
+    strictEqual(killSignal, 'SIGTERM');
+  }));
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+  }));
+  process.nextTick(() => ac.abort());
+}
+{
+  // Test passing an already aborted signal to a forked child_process
+  const ac = new AbortController();
+  const { signal } = ac;
+  ac.abort();
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall((code, killSignal) => {
+    strictEqual(code, null);
+    strictEqual(killSignal, 'SIGTERM');
+  }));
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+  }));
+}
+
+{
+  // Test passing a different kill signal
+  const ac = new AbortController();
+  const { signal } = ac;
+  ac.abort();
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal,
+    killSignal: 'SIGKILL',
+  });
+  cp.on('exit', mustCall((code, killSignal) => {
+    strictEqual(code, null);
+    strictEqual(killSignal, 'SIGKILL');
+  }));
+  cp.on('error', mustCall((err) => {
+    strictEqual(err.name, 'AbortError');
+  }));
+}
+
+{
+  // Test aborting a cp before close but after exit
+  const ac = new AbortController();
+  const { signal } = ac;
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    signal
+  });
+  cp.on('exit', mustCall(() => {
+    ac.abort();
+  }));
+  cp.on('error', mustNotCall());
+
+  setTimeout(() => cp.kill(), 1);
+}
diff --git a/test/parallel/test-child-process-fork-args.js b/test/parallel/test-child-process-fork-args.js
index 02a8db5fa60b61783e6d589b71a3f8d9a0956e61..68863ffb14b747dbf18a296d3b37d33893aa9c4b 100644
--- a/test/parallel/test-child-process-fork-args.js
+++ b/test/parallel/test-child-process-fork-args.js
@@ -19,7 +19,7 @@ const expectedEnv = { foo: 'bar' };
     [],
     {},
     () => {},
-    Symbol('t')
+    Symbol('t'),
   ];
   invalidModulePath.forEach((modulePath) => {
     assert.throws(() => fork(modulePath), {
@@ -46,7 +46,7 @@ const expectedEnv = { foo: 'bar' };
     0,
     true,
     () => {},
-    Symbol('t')
+    Symbol('t'),
   ];
   invalidSecondArgs.forEach((arg) => {
     assert.throws(
@@ -89,7 +89,7 @@ const expectedEnv = { foo: 'bar' };
     0,
     true,
     () => {},
-    Symbol('t')
+    Symbol('t'),
   ];
   invalidThirdArgs.forEach((arg) => {
     assert.throws(
diff --git a/test/parallel/test-child-process-fork-dgram.js b/test/parallel/test-child-process-fork-dgram.js
index 6552a162636aa855111df096878897ae99f1a170..4ea2edc60c29c1cc6044d5629cd28be521dd1955 100644
--- a/test/parallel/test-child-process-fork-dgram.js
+++ b/test/parallel/test-child-process-fork-dgram.js
@@ -20,12 +20,12 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-/*
- * The purpose of this test is to make sure that when forking a process,
- * sending a fd representing a UDP socket to the child and sending messages
- * to this endpoint, these messages are distributed to the parent and the
- * child process.
- */
+
+// The purpose of this test is to make sure that when forking a process,
+// sending a fd representing a UDP socket to the child and sending messages
+// to this endpoint, these messages are distributed to the parent and the
+// child process.
+
 
 const common = require('../common');
 if (common.isWindows)
@@ -80,10 +80,8 @@ if (process.argv[2] === 'child') {
     const serverPort = parentServer.address().port;
 
     const timer = setInterval(() => {
-      /*
-       * Both the parent and the child got at least one message,
-       * test passed, clean up everything.
-       */
+      // Both the parent and the child got at least one message,
+      // test passed, clean up everything.
       if (parentGotMessage && childGotMessage) {
         clearInterval(timer);
         client.close();
diff --git a/test/parallel/test-child-process-fork-getconnections.js b/test/parallel/test-child-process-fork-getconnections.js
index a6843ea64ba41f5d3e59437f03dad35b9f004e80..62376c489f77c8379afa46fb7f3815cbbd4719b7 100644
--- a/test/parallel/test-child-process-fork-getconnections.js
+++ b/test/parallel/test-child-process-fork-getconnections.js
@@ -97,8 +97,7 @@ if (process.argv[2] === 'child') {
 
     child.once('message', common.mustCall((m) => {
       assert.strictEqual(m.status, 'closed');
-      server.getConnections(common.mustCall((err, num) => {
-        assert.ifError(err);
+      server.getConnections(common.mustSucceed((num) => {
         assert.strictEqual(num, count - (i + 1));
         closeSockets(i + 1);
       }));
diff --git a/test/parallel/test-child-process-fork-timeout-kill-signal.js b/test/parallel/test-child-process-fork-timeout-kill-signal.js
new file mode 100644
index 0000000000000000000000000000000000000000..f5b9bd281f310ba103a2cdc9debb534ddf43fbd1
--- /dev/null
+++ b/test/parallel/test-child-process-fork-timeout-kill-signal.js
@@ -0,0 +1,54 @@
+// Flags: --expose-internals
+'use strict';
+
+const { mustCall } = require('../common');
+const { strictEqual, throws } = require('assert');
+const fixtures = require('../common/fixtures');
+const { fork } = require('child_process');
+const { getEventListeners } = require('events');
+const {
+  EventTarget,
+} = require('internal/event_target');
+
+{
+  // Verify default signal
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    timeout: 5,
+  });
+  cp.on('exit', mustCall((code, ks) => strictEqual(ks, 'SIGTERM')));
+}
+
+{
+  // Verify correct signal + closes after at least 4 ms.
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    timeout: 5,
+    killSignal: 'SIGKILL',
+  });
+  cp.on('exit', mustCall((code, ks) => strictEqual(ks, 'SIGKILL')));
+}
+
+{
+  // Verify timeout verification
+  throws(() => fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    timeout: 'badValue',
+  }), /ERR_OUT_OF_RANGE/);
+
+  throws(() => fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    timeout: {},
+  }), /ERR_OUT_OF_RANGE/);
+}
+
+{
+  // Verify abort signal gets unregistered
+  const signal = new EventTarget();
+  signal.aborted = false;
+
+  const cp = fork(fixtures.path('child-process-stay-alive-forever.js'), {
+    timeout: 6,
+    signal,
+  });
+  strictEqual(getEventListeners(signal, 'abort').length, 1);
+  cp.on('exit', mustCall(() => {
+    strictEqual(getEventListeners(signal, 'abort').length, 0);
+  }));
+}
diff --git a/test/parallel/test-child-process-http-socket-leak.js b/test/parallel/test-child-process-http-socket-leak.js
index 07cc0ebbf95e7664b6f9f58f8420f534eeab9bbf..cae4b051bc2b353213ea97e9ce69b2d7a4de9cf3 100644
--- a/test/parallel/test-child-process-http-socket-leak.js
+++ b/test/parallel/test-child-process-http-socket-leak.js
@@ -46,7 +46,7 @@ server.listen(0, common.mustCall(() => {
     }, common.mustCall((res) => {
       res.on('data', () => {});
       res.on('end', common.mustCall(() => {
-        assert.strictEqual(socket[kTimeout]._idleTimeout, -1);
+        assert.strictEqual(socket[kTimeout], null);
         assert.strictEqual(socket.parser, null);
         assert.strictEqual(socket._httpMessage, null);
       }));
diff --git a/test/parallel/test-child-process-kill.js b/test/parallel/test-child-process-kill.js
index 00aab44dd1318dd9982f94bbc67875220afa994c..1025c69ba1ac2859bfef7ebe1cc7e25fea5519d0 100644
--- a/test/parallel/test-child-process-kill.js
+++ b/test/parallel/test-child-process-kill.js
@@ -32,8 +32,10 @@ cat.stderr.on('end', common.mustCall());
 cat.on('exit', common.mustCall((code, signal) => {
   assert.strictEqual(code, null);
   assert.strictEqual(signal, 'SIGTERM');
+  assert.strictEqual(cat.signalCode, 'SIGTERM');
 }));
 
+assert.strictEqual(cat.signalCode, null);
 assert.strictEqual(cat.killed, false);
 cat.kill();
 assert.strictEqual(cat.killed, true);
diff --git a/test/parallel/test-child-process-pipe-dataflow.js b/test/parallel/test-child-process-pipe-dataflow.js
index 5f425a6f3d087ca8014503a363b58780074a2307..e989ff135c8047abcbbde994613a6ba5bccaf476 100644
--- a/test/parallel/test-child-process-pipe-dataflow.js
+++ b/test/parallel/test-child-process-pipe-dataflow.js
@@ -3,7 +3,6 @@ const common = require('../common');
 const assert = require('assert');
 const path = require('path');
 const fs = require('fs');
-const os = require('os');
 const spawn = require('child_process').spawn;
 const tmpdir = require('../common/tmpdir');
 
@@ -22,12 +21,13 @@ const MB = KB * KB;
   const file = path.resolve(tmpdir.path, 'data.txt');
   const buf = Buffer.alloc(MB).fill('x');
 
-  // Most OS commands that deal with data, attach special
-  // meanings to new line - for example, line buffering.
-  // So cut the buffer into lines at some points, forcing
-  // data flow to be split in the stream.
+  // Most OS commands that deal with data, attach special meanings to new line -
+  // for example, line buffering. So cut the buffer into lines at some points,
+  // forcing data flow to be split in the stream. Do not use os.EOL for \n as
+  // that is 2 characters on Windows and is sometimes converted to 1 character
+  // which causes the test to fail.
   for (let i = 1; i < KB; i++)
-    buf.write(os.EOL, i * KB);
+    buf.write('\n', i * KB);
   fs.writeFileSync(file, buf.toString());
 
   cat = spawn('cat', [file]);
@@ -61,8 +61,13 @@ const MB = KB * KB;
     }));
   });
 
+  let wcBuf = '';
   wc.stdout.on('data', common.mustCall((data) => {
-    // Grep always adds one extra byte at the end.
-    assert.strictEqual(data.toString().trim(), (MB + 1).toString());
+    wcBuf += data;
   }));
+
+  process.on('exit', () => {
+    // Grep always adds one extra byte at the end.
+    assert.strictEqual(wcBuf.trim(), (MB + 1).toString());
+  });
 }
diff --git a/test/parallel/test-child-process-recv-handle.js b/test/parallel/test-child-process-recv-handle.js
index 24c6b07037f2d04775e04e62f2a416fee837f227..a5d322ca7dc19c4963105186447b9c2e0a6c518e 100644
--- a/test/parallel/test-child-process-recv-handle.js
+++ b/test/parallel/test-child-process-recv-handle.js
@@ -36,7 +36,9 @@ else
 function master() {
   // spawn() can only create one IPC channel so we use stdin/stdout as an
   // ad-hoc command channel.
-  const proc = spawn(process.execPath, [__filename, 'worker'], {
+  const proc = spawn(process.execPath, [
+    '--expose-internals', __filename, 'worker',
+  ], {
     stdio: ['pipe', 'pipe', 'pipe', 'ipc']
   });
   let handle = null;
@@ -57,12 +59,13 @@ function master() {
 }
 
 function worker() {
-  process.channel.readStop();  // Make messages batch up.
+  const { kChannelHandle } = require('internal/child_process');
+  process[kChannelHandle].readStop();  // Make messages batch up.
   process.stdout.ref();
   process.stdout.write('ok\r\n');
   process.stdin.once('data', common.mustCall((data) => {
     assert.strictEqual(data.toString(), 'ok\r\n');
-    process.channel.readStart();
+    process[kChannelHandle].readStart();
   }));
   let n = 0;
   process.on('message', common.mustCall((msg, handle) => {
diff --git a/test/parallel/test-child-process-send-keep-open.js b/test/parallel/test-child-process-send-keep-open.js
index 2d8a28121ac1fb6240f981268979d972ded75f8e..54169dc1885f661f9af0f11404f7518bb251735a 100644
--- a/test/parallel/test-child-process-send-keep-open.js
+++ b/test/parallel/test-child-process-send-keep-open.js
@@ -32,9 +32,7 @@ if (process.argv[2] !== 'child') {
       });
     }));
 
-    child.send('socket', socket, { keepOpen: true }, common.mustCall((err) => {
-      assert.ifError(err);
-    }));
+    child.send('socket', socket, { keepOpen: true }, common.mustSucceed());
   });
 
   server.listen(0, () => {
diff --git a/test/parallel/test-child-process-server-close.js b/test/parallel/test-child-process-server-close.js
index d70926f2e8278e19162fd87ed50d9d68b2c34a6e..832cf970178afac7b6be3000a525e010eb6b13d9 100644
--- a/test/parallel/test-child-process-server-close.js
+++ b/test/parallel/test-child-process-server-close.js
@@ -1,12 +1,29 @@
 'use strict';
 
 const common = require('../common');
-const { spawn } = require('child_process');
+const assert = require('assert');
+const { fork, spawn } = require('child_process');
 const net = require('net');
 
 const tmpdir = require('../common/tmpdir');
-tmpdir.refresh();
 
+// Run in a child process because the PIPE file descriptor stays open until
+// Node.js completes, blocking the tmpdir and preventing cleanup.
+
+if (process.argv[2] !== 'child') {
+  // Parent
+  tmpdir.refresh();
+
+  // Run test
+  const child = fork(__filename, ['child'], { stdio: 'inherit' });
+  child.on('exit', common.mustCall(function(code) {
+    assert.strictEqual(code, 0);
+  }));
+
+  return;
+}
+
+// Child
 const server = net.createServer((conn) => {
   spawn(process.execPath, ['-v'], {
     stdio: ['ignore', conn, 'ignore']
@@ -15,7 +32,7 @@ const server = net.createServer((conn) => {
   }));
 }).listen(common.PIPE, () => {
   const client = net.connect(common.PIPE, common.mustCall());
-  client.on('data', () => {
+  client.once('data', () => {
     client.end(() => {
       server.close();
     });
diff --git a/test/parallel/test-child-process-silent.js b/test/parallel/test-child-process-silent.js
index a2ebb3ffeb9385c19181f87e08121f9251eff243..bedef1509cf9c7af1de443c08e357a8c5d483cf6 100644
--- a/test/parallel/test-child-process-silent.js
+++ b/test/parallel/test-child-process-silent.js
@@ -42,8 +42,7 @@ if (process.argv[2] === 'pipe') {
   const child = childProcess.fork(process.argv[1], ['pipe'], { silent: true });
 
   // Allow child process to self terminate
-  child.channel.close();
-  child.channel = null;
+  child.disconnect();
 
   child.on('exit', function() {
     process.exit(0);
diff --git a/test/parallel/test-child-process-spawn-args.js b/test/parallel/test-child-process-spawn-args.js
index ef70fe844f9c1284180ca6565ea828f703d31648..ec56f409faf2a976bddf19b61f25ab7413ef3fdc 100644
--- a/test/parallel/test-child-process-spawn-args.js
+++ b/test/parallel/test-child-process-spawn-args.js
@@ -52,4 +52,4 @@ const expectedResult = tmpdir.path.trim().toLowerCase();
   );
 
   assert.deepStrictEqual([...new Set(results)], [expectedResult]);
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-child-process-spawn-controller.js b/test/parallel/test-child-process-spawn-controller.js
new file mode 100644
index 0000000000000000000000000000000000000000..d76b4391870c26a56d303ebd162da691f96974b6
--- /dev/null
+++ b/test/parallel/test-child-process-spawn-controller.js
@@ -0,0 +1,110 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { spawn } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+const aliveScript = fixtures.path('child-process-stay-alive-forever.js');
+{
+  // Verify that passing an AbortSignal works
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+
+  controller.abort();
+}
+
+{
+  // Verify that passing an already-aborted signal works.
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  controller.abort();
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+}
+
+{
+  // Verify that waiting a bit and closing works
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGTERM');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+
+  setTimeout(() => controller.abort(), 1);
+}
+
+{
+  // Test passing a different killSignal
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+    killSignal: 'SIGKILL',
+  });
+
+  cp.on('exit', common.mustCall((code, killSignal) => {
+    assert.strictEqual(code, null);
+    assert.strictEqual(killSignal, 'SIGKILL');
+  }));
+
+  cp.on('error', common.mustCall((e) => {
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+
+  setTimeout(() => controller.abort(), 1);
+}
+
+{
+  // Test aborting a cp before close but after exit
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  const cp = spawn(process.execPath, [aliveScript], {
+    signal,
+  });
+
+  cp.on('exit', common.mustCall(() => {
+    controller.abort();
+  }));
+
+  cp.on('error', common.mustNotCall());
+
+  setTimeout(() => cp.kill(), 1);
+}
diff --git a/test/parallel/test-child-process-spawn-error.js b/test/parallel/test-child-process-spawn-error.js
index 33f66d0ba64ac4585dbddf140295b859050bc7bd..ed1c8fac9f97ed519da3b039c6f75445b59b87ad 100644
--- a/test/parallel/test-child-process-spawn-error.js
+++ b/test/parallel/test-child-process-spawn-error.js
@@ -21,6 +21,7 @@
 
 'use strict';
 const common = require('../common');
+const { getSystemErrorName } = require('util');
 const spawn = require('child_process').spawn;
 const assert = require('assert');
 const fs = require('fs');
@@ -40,9 +41,14 @@ assert.strictEqual(enoentChild.stdio[0], enoentChild.stdin);
 assert.strictEqual(enoentChild.stdio[1], enoentChild.stdout);
 assert.strictEqual(enoentChild.stdio[2], enoentChild.stderr);
 
+// Verify pid is not assigned.
+assert.strictEqual(enoentChild.pid, undefined);
+
+enoentChild.on('spawn', common.mustNotCall());
+
 enoentChild.on('error', common.mustCall(function(err) {
   assert.strictEqual(err.code, 'ENOENT');
-  assert.strictEqual(err.errno, 'ENOENT');
+  assert.strictEqual(getSystemErrorName(err.errno), 'ENOENT');
   assert.strictEqual(err.syscall, `spawn ${enoentPath}`);
   assert.strictEqual(err.path, enoentPath);
   assert.deepStrictEqual(err.spawnargs, spawnargs);
diff --git a/test/parallel/test-child-process-spawn-event.js b/test/parallel/test-child-process-spawn-event.js
new file mode 100644
index 0000000000000000000000000000000000000000..c025d8628681e880834459d16c3f089a76914d3c
--- /dev/null
+++ b/test/parallel/test-child-process-spawn-event.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const spawn = require('child_process').spawn;
+const assert = require('assert');
+
+const subprocess = spawn('echo', ['ok']);
+
+let didSpawn = false;
+subprocess.on('spawn', function() {
+  didSpawn = true;
+});
+function mustCallAfterSpawn() {
+  return common.mustCall(function() {
+    assert.ok(didSpawn);
+  });
+}
+
+subprocess.on('error', common.mustNotCall());
+subprocess.on('spawn', common.mustCall());
+subprocess.stdout.on('data', mustCallAfterSpawn());
+subprocess.stdout.on('end', mustCallAfterSpawn());
+subprocess.stdout.on('close', mustCallAfterSpawn());
+subprocess.stderr.on('data', common.mustNotCall());
+subprocess.stderr.on('end', mustCallAfterSpawn());
+subprocess.stderr.on('close', mustCallAfterSpawn());
+subprocess.on('exit', mustCallAfterSpawn());
+subprocess.on('close', mustCallAfterSpawn());
diff --git a/test/parallel/test-child-process-spawn-timeout-kill-signal.js b/test/parallel/test-child-process-spawn-timeout-kill-signal.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0bedebc597a1d17b70e0ae0a5434d045b463112
--- /dev/null
+++ b/test/parallel/test-child-process-spawn-timeout-kill-signal.js
@@ -0,0 +1,51 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+
+const { mustCall } = require('../common');
+const { strictEqual, throws } = require('assert');
+const fixtures = require('../common/fixtures');
+const { spawn } = require('child_process');
+const { getEventListeners } = require('events');
+
+const aliveForeverFile = 'child-process-stay-alive-forever.js';
+{
+  // Verify default signal + closes
+  const cp = spawn(process.execPath, [fixtures.path(aliveForeverFile)], {
+    timeout: 5,
+  });
+  cp.on('exit', mustCall((code, ks) => strictEqual(ks, 'SIGTERM')));
+}
+
+{
+  // Verify SIGKILL signal + closes
+  const cp = spawn(process.execPath, [fixtures.path(aliveForeverFile)], {
+    timeout: 6,
+    killSignal: 'SIGKILL',
+  });
+  cp.on('exit', mustCall((code, ks) => strictEqual(ks, 'SIGKILL')));
+}
+
+{
+  // Verify timeout verification
+  throws(() => spawn(process.execPath, [fixtures.path(aliveForeverFile)], {
+    timeout: 'badValue',
+  }), /ERR_OUT_OF_RANGE/);
+
+  throws(() => spawn(process.execPath, [fixtures.path(aliveForeverFile)], {
+    timeout: {},
+  }), /ERR_OUT_OF_RANGE/);
+}
+
+{
+  // Verify abort signal gets unregistered
+  const controller = new AbortController();
+  const { signal } = controller;
+  const cp = spawn(process.execPath, [fixtures.path(aliveForeverFile)], {
+    timeout: 6,
+    signal,
+  });
+  strictEqual(getEventListeners(signal, 'abort').length, 1);
+  cp.on('exit', mustCall(() => {
+    strictEqual(getEventListeners(signal, 'abort').length, 0);
+  }));
+}
diff --git a/test/parallel/test-child-process-spawnsync-input.js b/test/parallel/test-child-process-spawnsync-input.js
index 4dce110316b30e23afbcc298da68fa45b042a6e7..62ae476ae17caaae2e88d12e14b256a18a96bb4c 100644
--- a/test/parallel/test-child-process-spawnsync-input.js
+++ b/test/parallel/test-child-process-spawnsync-input.js
@@ -35,7 +35,7 @@ const msgErrBuf = Buffer.from(`${msgErr}\n`);
 
 const args = [
   '-e',
-  `console.log("${msgOut}"); console.error("${msgErr}");`
+  `console.log("${msgOut}"); console.error("${msgErr}");`,
 ];
 
 let ret;
diff --git a/test/parallel/test-child-process-spawnsync-kill-signal.js b/test/parallel/test-child-process-spawnsync-kill-signal.js
index d31d629c503e2244eeb09186c24816acb4bdc9ee..6d14f24724bb2b3c161a673ef273676bf6ba8f7e 100644
--- a/test/parallel/test-child-process-spawnsync-kill-signal.js
+++ b/test/parallel/test-child-process-spawnsync-kill-signal.js
@@ -36,7 +36,7 @@ if (process.argv[2] === 'child') {
   // Verify that the default kill signal is SIGTERM.
   {
     const child = spawn(undefined, (opts) => {
-      assert.strictEqual(opts.options.killSignal, undefined);
+      assert.strictEqual(opts.killSignal, undefined);
     });
 
     assert.strictEqual(child.signal, 'SIGTERM');
@@ -45,7 +45,7 @@ if (process.argv[2] === 'child') {
   // Verify that a string signal name is handled properly.
   {
     const child = spawn('SIGKILL', (opts) => {
-      assert.strictEqual(opts.options.killSignal, SIGKILL);
+      assert.strictEqual(opts.killSignal, SIGKILL);
     });
 
     assert.strictEqual(child.signal, 'SIGKILL');
@@ -56,7 +56,7 @@ if (process.argv[2] === 'child') {
     assert.strictEqual(typeof SIGKILL, 'number');
 
     const child = spawn(SIGKILL, (opts) => {
-      assert.strictEqual(opts.options.killSignal, SIGKILL);
+      assert.strictEqual(opts.killSignal, SIGKILL);
     });
 
     assert.strictEqual(child.signal, 'SIGKILL');
diff --git a/test/parallel/test-child-process-spawnsync-maxbuf.js b/test/parallel/test-child-process-spawnsync-maxbuf.js
index 5f4e959b880d4b9c8af8740840d6ba84527584c9..3f452a41e66c26f141cfc1b8a6e72c82416690ce 100644
--- a/test/parallel/test-child-process-spawnsync-maxbuf.js
+++ b/test/parallel/test-child-process-spawnsync-maxbuf.js
@@ -6,12 +6,13 @@ require('../common');
 
 const assert = require('assert');
 const spawnSync = require('child_process').spawnSync;
+const { getSystemErrorName } = require('util');
 const msgOut = 'this is stdout';
 const msgOutBuf = Buffer.from(`${msgOut}\n`);
 
 const args = [
   '-e',
-  `console.log("${msgOut}");`
+  `console.log("${msgOut}");`,
 ];
 
 // Verify that an error is returned if maxBuffer is surpassed.
@@ -19,7 +20,8 @@ const args = [
   const ret = spawnSync(process.execPath, args, { maxBuffer: 1 });
 
   assert.ok(ret.error, 'maxBuffer should error');
-  assert.strictEqual(ret.error.errno, 'ENOBUFS');
+  assert.strictEqual(ret.error.code, 'ENOBUFS');
+  assert.strictEqual(getSystemErrorName(ret.error.errno), 'ENOBUFS');
   // We can have buffers larger than maxBuffer because underneath we alloc 64k
   // that matches our read sizes.
   assert.deepStrictEqual(ret.stdout, msgOutBuf);
@@ -39,7 +41,8 @@ const args = [
   const ret = spawnSync(process.execPath, args);
 
   assert.ok(ret.error, 'maxBuffer should error');
-  assert.strictEqual(ret.error.errno, 'ENOBUFS');
+  assert.strictEqual(ret.error.code, 'ENOBUFS');
+  assert.strictEqual(getSystemErrorName(ret.error.errno), 'ENOBUFS');
 }
 
 // Default maxBuffer size is 1024 * 1024.
diff --git a/test/parallel/test-child-process-spawnsync-shell.js b/test/parallel/test-child-process-spawnsync-shell.js
index feb329e2ae6323780ee56efb568d57eb619dc061..0dd50cedd123b279cea518239d7c09aba62b71b0 100644
--- a/test/parallel/test-child-process-spawnsync-shell.js
+++ b/test/parallel/test-child-process-spawnsync-shell.js
@@ -64,12 +64,12 @@ assert.strictEqual(env.stdout.toString().trim(), 'buzz');
       assert.strictEqual(opts.file, shellOutput);
       assert.deepStrictEqual(opts.args,
                              [shellOutput, ...shellFlags, outputCmd]);
-      assert.strictEqual(opts.options.shell, shell);
-      assert.strictEqual(opts.options.file, opts.file);
-      assert.deepStrictEqual(opts.options.args, opts.args);
-      assert.strictEqual(opts.options.windowsHide, undefined);
-      assert.strictEqual(opts.options.windowsVerbatimArguments,
-                         windowsVerbatim);
+      assert.strictEqual(opts.shell, shell);
+      assert.strictEqual(opts.file, opts.file);
+      assert.deepStrictEqual(opts.args, opts.args);
+      assert.strictEqual(opts.windowsHide, false);
+      assert.strictEqual(opts.windowsVerbatimArguments,
+                         !!windowsVerbatim);
     });
     cp.spawnSync(cmd, { shell });
     internalCp.spawnSync = oldSpawnSync;
diff --git a/test/parallel/test-child-process-spawnsync-timeout.js b/test/parallel/test-child-process-spawnsync-timeout.js
index 5991f5d626411a60650cf980a6f4ef58c6ea4a84..2923d8c21cb01776fbaf7f0abeae9173d3ec9199 100644
--- a/test/parallel/test-child-process-spawnsync-timeout.js
+++ b/test/parallel/test-child-process-spawnsync-timeout.js
@@ -24,7 +24,7 @@ const common = require('../common');
 const assert = require('assert');
 
 const spawnSync = require('child_process').spawnSync;
-const { debuglog } = require('util');
+const { debuglog, getSystemErrorName } = require('util');
 const debug = debuglog('test');
 
 const TIMER = 200;
@@ -41,7 +41,8 @@ switch (process.argv[2]) {
     const start = Date.now();
     const ret = spawnSync(process.execPath, [__filename, 'child'],
                           { timeout: TIMER });
-    assert.strictEqual(ret.error.errno, 'ETIMEDOUT');
+    assert.strictEqual(ret.error.code, 'ETIMEDOUT');
+    assert.strictEqual(getSystemErrorName(ret.error.errno), 'ETIMEDOUT');
     const end = Date.now() - start;
     assert(end < SLEEP);
     assert(ret.status > 128 || ret.signal);
diff --git a/test/parallel/test-child-process-spawnsync.js b/test/parallel/test-child-process-spawnsync.js
index dac37a5aa862e9c0dfb29b2f957b0cee81054f2e..9ec125ea891689e861bfd76a8a76aec1d8c7dfdb 100644
--- a/test/parallel/test-child-process-spawnsync.js
+++ b/test/parallel/test-child-process-spawnsync.js
@@ -26,6 +26,7 @@ tmpdir.refresh();
 
 const assert = require('assert');
 const { spawnSync } = require('child_process');
+const { getSystemErrorName } = require('util');
 
 // `sleep` does different things on Windows and Unix, but in both cases, it does
 // more-or-less nothing if there are no parameters
@@ -36,7 +37,7 @@ assert.strictEqual(ret.status, 0);
 const ret_err = spawnSync('command_does_not_exist', ['bar']).error;
 
 assert.strictEqual(ret_err.code, 'ENOENT');
-assert.strictEqual(ret_err.errno, 'ENOENT');
+assert.strictEqual(getSystemErrorName(ret_err.errno), 'ENOENT');
 assert.strictEqual(ret_err.syscall, 'spawnSync command_does_not_exist');
 assert.strictEqual(ret_err.path, 'command_does_not_exist');
 assert.deepStrictEqual(ret_err.spawnargs, ['bar']);
@@ -60,7 +61,7 @@ assert.deepStrictEqual(ret_err.spawnargs, ['bar']);
   const stringifiedDefault = [
     null,
     retDefault.stdout.toString(),
-    retDefault.stderr.toString()
+    retDefault.stderr.toString(),
   ];
   assert.deepStrictEqual(retUTF8.output, stringifiedDefault);
 }
diff --git a/test/parallel/test-child-process-stdin-ipc.js b/test/parallel/test-child-process-stdin-ipc.js
index b162ced916096d2fb5e82d3ada2d62ba11fc7f02..945960b99b72cc05aa7b3a908f572c5330fed0be 100644
--- a/test/parallel/test-child-process-stdin-ipc.js
+++ b/test/parallel/test-child-process-stdin-ipc.js
@@ -27,7 +27,7 @@ const spawn = require('child_process').spawn;
 
 if (process.argv[2] === 'child') {
   // Just reference stdin, it should start it
-  process.stdin;
+  process.stdin; // eslint-disable-line no-unused-expressions
   return;
 }
 
diff --git a/test/parallel/test-child-process-stdio-overlapped.js b/test/parallel/test-child-process-stdio-overlapped.js
new file mode 100644
index 0000000000000000000000000000000000000000..70a6454ff8fc9ae476d5f9dd97b1ca19e9375c5b
--- /dev/null
+++ b/test/parallel/test-child-process-stdio-overlapped.js
@@ -0,0 +1,75 @@
+// Test for "overlapped" stdio option. This test uses the "overlapped-checker"
+// helper program which basically a specialized echo program.
+//
+// The test has two goals:
+//
+// - Verify that overlapped I/O works on windows. The test program will deadlock
+//   if stdin doesn't have the FILE_FLAG_OVERLAPPED flag set on startup (see
+//   test/overlapped-checker/main_win.c for more details).
+// - Verify that "overlapped" stdio option works transparently as a pipe (on
+//   unix/windows)
+//
+// This is how the test works:
+//
+// - This script assumes only numeric strings are written to the test program
+//   stdout.
+// - The test program will be spawned with "overlapped" set on stdin and "pipe"
+//   set on stdout/stderr and at startup writes a number to its stdout
+// - When this script receives some data, it will parse the number, add 50 and
+//   write to the test program's stdin.
+// - The test program will then echo the number back to us which will repeat the
+//   cycle until the number reaches 200, at which point we send the "exit"
+//   string, which causes the test program to exit.
+// - Extra assertion: Every time the test program writes a string to its stdout,
+//   it will write the number of bytes written to stderr.
+// - If overlapped I/O is not setup correctly, this test is going to hang.
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+const child_process = require('child_process');
+
+const exeExtension = process.platform === 'win32' ? '.exe' : '';
+const exe = 'overlapped-checker' + exeExtension;
+const exePath = path.join(path.dirname(process.execPath), exe);
+
+const child = child_process.spawn(exePath, [], {
+  stdio: ['overlapped', 'pipe', 'pipe']
+});
+
+child.stdin.setEncoding('utf8');
+child.stdout.setEncoding('utf8');
+child.stderr.setEncoding('utf8');
+
+function writeNext(n) {
+  child.stdin.write((n + 50).toString());
+}
+
+child.stdout.on('data', (s) => {
+  const n = Number(s);
+  if (n >= 200) {
+    child.stdin.write('exit');
+    return;
+  }
+  writeNext(n);
+});
+
+let stderr = '';
+child.stderr.on('data', (s) => {
+  stderr += s;
+});
+
+child.stderr.on('end', common.mustCall(() => {
+  // This is the sequence of numbers sent to us:
+  // - 0 (1 byte written)
+  // - 50 (2 bytes written)
+  // - 100 (3 bytes written)
+  // - 150 (3 bytes written)
+  // - 200 (3 bytes written)
+  assert.strictEqual(stderr, '12333');
+}));
+
+child.on('exit', common.mustCall((status) => {
+  // The test program will return the number of writes as status code.
+  assert.strictEqual(status, 0);
+}));
diff --git a/test/parallel/test-child-process-validate-stdio.js b/test/parallel/test-child-process-validate-stdio.js
index ff214ee2d782620043bff87dbf1868589f7065a6..7abcce4ca36a3c0c7d55a8f636a3012b62a40dea 100644
--- a/test/parallel/test-child-process-validate-stdio.js
+++ b/test/parallel/test-child-process-validate-stdio.js
@@ -50,7 +50,7 @@ if (common.isMainThread) {
     stdio: [
       { type: 'fd', fd: 0 },
       { type: 'fd', fd: 1 },
-      { type: 'fd', fd: 2 }
+      { type: 'fd', fd: 2 },
     ],
     ipc: undefined,
     ipcFd: undefined
diff --git a/test/parallel/test-child-process-windows-hide.js b/test/parallel/test-child-process-windows-hide.js
index ec00978408bb16a97ab873fe931a079ff8cd952a..ef4a8be8784ebc62e43341bc7df6c16b42afee35 100644
--- a/test/parallel/test-child-process-windows-hide.js
+++ b/test/parallel/test-child-process-windows-hide.js
@@ -19,7 +19,7 @@ internalCp.ChildProcess.prototype.spawn = common.mustCall(function(options) {
 }, 2);
 
 internalCp.spawnSync = common.mustCall(function(options) {
-  assert.strictEqual(options.options.windowsHide, true);
+  assert.strictEqual(options.windowsHide, true);
   return originalSpawnSync.apply(this, arguments);
 });
 
@@ -42,8 +42,7 @@ internalCp.spawnSync = common.mustCall(function(options) {
 }
 
 {
-  const callback = common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
+  const callback = common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout.trim(), '42');
     assert.strictEqual(stderr.trim(), '');
   });
diff --git a/test/parallel/test-cli-eval.js b/test/parallel/test-cli-eval.js
index be063b79fad320398161d026d727d720a98a9c82..e95fee008d6e3a759998b13385065c53e1d6123d 100644
--- a/test/parallel/test-cli-eval.js
+++ b/test/parallel/test-cli-eval.js
@@ -20,7 +20,7 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-if (module.parent) {
+if (module !== require.main) {
   // Signal we've been loaded as a module.
   // The following console.log() is part of the test.
   console.log('Loaded as a module, exiting with status code 42.');
@@ -40,16 +40,14 @@ if (process.argv.length > 2) {
 }
 
 // Assert that nothing is written to stdout.
-child.exec(`${nodejs} --eval 42`, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
+child.exec(`${nodejs} --eval 42`, common.mustSucceed((stdout, stderr) => {
   assert.strictEqual(stdout, '');
   assert.strictEqual(stderr, '');
 }));
 
 // Assert that "42\n" is written to stderr.
 child.exec(`${nodejs} --eval "console.error(42)"`,
-           common.mustCall((err, stdout, stderr) => {
-             assert.ifError(err);
+           common.mustSucceed((stdout, stderr) => {
              assert.strictEqual(stdout, '');
              assert.strictEqual(stderr, '42\n');
            }));
@@ -58,14 +56,12 @@ child.exec(`${nodejs} --eval "console.error(42)"`,
 ['--print', '-p -e', '-pe', '-p'].forEach((s) => {
   const cmd = `${nodejs} ${s} `;
 
-  child.exec(`${cmd}42`, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
+  child.exec(`${cmd}42`, common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout, '42\n');
     assert.strictEqual(stderr, '');
   }));
 
-  child.exec(`${cmd} '[]'`, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
+  child.exec(`${cmd} '[]'`, common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout, '[]\n');
     assert.strictEqual(stderr, '');
   }));
@@ -88,8 +84,7 @@ child.exec(`${nodejs} --eval "console.error(42)"`,
 
 // Check that builtin modules are pre-defined.
 child.exec(`${nodejs} --print "os.platform()"`,
-           common.mustCall((err, stdout, stderr) => {
-             assert.ifError(err);
+           common.mustSucceed((stdout, stderr) => {
              assert.strictEqual(stderr, '');
              assert.strictEqual(stdout.trim(), require('os').platform());
            }));
@@ -113,22 +108,19 @@ child.exec(`${nodejs} -e`, common.mustCall((err, stdout, stderr) => {
 }));
 
 // Empty program should do nothing.
-child.exec(`${nodejs} -e ""`, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
+child.exec(`${nodejs} -e ""`, common.mustSucceed((stdout, stderr) => {
   assert.strictEqual(stdout, '');
   assert.strictEqual(stderr, '');
 }));
 
 // "\\-42" should be interpreted as an escaped expression, not a switch.
-child.exec(`${nodejs} -p "\\-42"`, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
+child.exec(`${nodejs} -p "\\-42"`, common.mustSucceed((stdout, stderr) => {
   assert.strictEqual(stdout, '-42\n');
   assert.strictEqual(stderr, '');
 }));
 
 child.exec(`${nodejs} --use-strict -p process.execArgv`,
-           common.mustCall((err, stdout, stderr) => {
-             assert.ifError(err);
+           common.mustSucceed((stdout, stderr) => {
              assert.strictEqual(
                stdout, "[ '--use-strict', '-p', 'process.execArgv' ]\n"
              );
@@ -143,8 +135,7 @@ child.exec(`${nodejs} --use-strict -p process.execArgv`,
   }
 
   child.exec(`${nodejs} -e 'require("child_process").fork("${emptyFile}")'`,
-             common.mustCall((err, stdout, stderr) => {
-               assert.ifError(err);
+             common.mustSucceed((stdout, stderr) => {
                assert.strictEqual(stdout, '');
                assert.strictEqual(stderr, '');
              }));
@@ -154,8 +145,7 @@ child.exec(`${nodejs} --use-strict -p process.execArgv`,
   child.exec(
     `${nodejs} -e "process.execArgv = ['-e', 'console.log(42)', 'thirdArg'];` +
                   `require('child_process').fork('${emptyFile}')"`,
-    common.mustCall((err, stdout, stderr) => {
-      assert.ifError(err);
+    common.mustSucceed((stdout, stderr) => {
       assert.strictEqual(stdout, '42\n');
       assert.strictEqual(stderr, '');
     }));
@@ -237,17 +227,17 @@ child.exec(`${nodejs} --use-strict -p process.execArgv`,
 const execOptions = '--input-type module';
 child.exec(
   `${nodejs} ${execOptions} --eval "console.log(42)"`,
-  common.mustCall((err, stdout) => {
-    assert.ifError(err);
+  common.mustSucceed((stdout) => {
     assert.strictEqual(stdout, '42\n');
   }));
 
 // Assert that "42\n" is written to stdout with print option.
 child.exec(
   `${nodejs} ${execOptions} --print --eval "42"`,
-  common.mustCall((err, stdout) => {
-    assert.ifError(err);
-    assert.strictEqual(stdout, '42\n');
+  common.mustCall((err, stdout, stderr) => {
+    assert.ok(err);
+    assert.strictEqual(stdout, '');
+    assert.ok(stderr.includes('--print cannot be used with ESM input'));
   }));
 
 // Assert that error is written to stderr on invalid input.
@@ -262,16 +252,14 @@ child.exec(
 // Assert that require is undefined in ESM support
 child.exec(
   `${nodejs} ${execOptions} --eval "console.log(typeof require);"`,
-  common.mustCall((err, stdout) => {
-    assert.ifError(err);
+  common.mustSucceed((stdout) => {
     assert.strictEqual(stdout, 'undefined\n');
   }));
 
 // Assert that import.meta is defined in ESM
 child.exec(
   `${nodejs} ${execOptions} --eval "console.log(typeof import.meta);"`,
-  common.mustCall((err, stdout) => {
-    assert.ifError(err);
+  common.mustSucceed((stdout) => {
     assert.strictEqual(stdout, 'object\n');
   }));
 
@@ -279,8 +267,7 @@ child.exec(
 child.exec(
   `${nodejs} ${execOptions} ` +
   '--eval "import \'./test/fixtures/es-modules/mjs-file.mjs\'"',
-  common.mustCall((err, stdout) => {
-    assert.ifError(err);
+  common.mustSucceed((stdout) => {
     assert.strictEqual(stdout, '.mjs file\n');
   }));
 
@@ -290,16 +277,14 @@ child.exec(
   `${nodejs} ${execOptions} ` +
   '--eval "process.chdir(\'..\');' +
           'import(\'./test/fixtures/es-modules/mjs-file.mjs\')"',
-  common.mustCall((err, stdout) => {
-    assert.ifError(err);
+  common.mustSucceed((stdout) => {
     assert.strictEqual(stdout, '.mjs file\n');
   }));
 
 child.exec(
-  `${nodejs} ${execOptions} ` +
+  `${nodejs} ` +
   '--eval "process.chdir(\'..\');' +
           'import(\'./test/fixtures/es-modules/mjs-file.mjs\')"',
-  common.mustCall((err, stdout) => {
-    assert.ifError(err);
+  common.mustSucceed((stdout) => {
     assert.strictEqual(stdout, '.mjs file\n');
   }));
diff --git a/test/parallel/test-cli-node-options.js b/test/parallel/test-cli-node-options.js
index 2fc22ca477ce94153d2d3b29c2ab6ba99b725e59..8fb15d3ba505c142233a703163c384923e92f8af 100644
--- a/test/parallel/test-cli-node-options.js
+++ b/test/parallel/test-cli-node-options.js
@@ -78,6 +78,10 @@ expect('--stack-trace-limit=100',
 if (!['arm', 'arm64'].includes(process.arch))
   expect('--interpreted-frames-native-stack', 'B\n');
 
+// Workers can't eval as ES Modules. https://github.com/nodejs/node/issues/30682
+expectNoWorker('--input-type=module',
+               'B\n', 'console.log(await "B")');
+
 function expectNoWorker(opt, want, command, wantsError) {
   expect(opt, want, command, wantsError, false);
 }
diff --git a/test/parallel/test-cli-node-print-help.js b/test/parallel/test-cli-node-print-help.js
index e115124b0487fe6a22d6f3b35541d995de23cb59..ab8cd101350a81f8e4fbb93f59478b031cd6bd32 100644
--- a/test/parallel/test-cli-node-print-help.js
+++ b/test/parallel/test-cli-node-print-help.js
@@ -14,8 +14,7 @@ let stdOut;
 
 
 function startPrintHelpTest() {
-  exec(`${process.execPath} --help`, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
+  exec(`${process.execPath} --help`, common.mustSucceed((stdout, stderr) => {
     stdOut = stdout;
     validateNodePrintHelp();
   }));
diff --git a/test/parallel/test-cli-options-negation.js b/test/parallel/test-cli-options-negation.js
new file mode 100644
index 0000000000000000000000000000000000000000..bfbee635ab1a2e61ef382cc0b21547ec8b78405c
--- /dev/null
+++ b/test/parallel/test-cli-options-negation.js
@@ -0,0 +1,39 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+// --warnings is on by default.
+assertHasWarning(spawnWithFlags([]));
+
+// --warnings can be passed alone.
+assertHasWarning(spawnWithFlags(['--warnings']));
+
+// --no-warnings can be passed alone.
+assertHasNoWarning(spawnWithFlags(['--no-warnings']));
+
+// Last flag takes precedence.
+assertHasWarning(spawnWithFlags(['--no-warnings', '--warnings']));
+
+// Non-boolean flags cannot be negated.
+assert(spawnWithFlags(['--no-max-http-header-size']).stderr.toString().includes(
+  '--no-max-http-header-size is an invalid negation because it is not ' +
+  'a boolean option',
+));
+
+// Inexistant flags cannot be negated.
+assert(spawnWithFlags(['--no-i-dont-exist']).stderr.toString().includes(
+  'bad option: --no-i-dont-exist',
+));
+
+function spawnWithFlags(flags) {
+  return spawnSync(process.execPath, [...flags, '-e', 'new Buffer(0)']);
+}
+
+function assertHasWarning(proc) {
+  assert(proc.stderr.toString().includes('Buffer() is deprecated'));
+}
+
+function assertHasNoWarning(proc) {
+  assert(!proc.stderr.toString().includes('Buffer() is deprecated'));
+}
diff --git a/test/parallel/test-cli-options-precedence.js b/test/parallel/test-cli-options-precedence.js
index f76c12043e29cd85725235c562524572b35d865e..32804d187fccc34d3a8a25620d400af2318611a0 100644
--- a/test/parallel/test-cli-options-precedence.js
+++ b/test/parallel/test-cli-options-precedence.js
@@ -7,7 +7,7 @@ const { spawnSync } = require('child_process');
 assert.strictEqual(spawnSync(process.execPath, [
   '--max-http-header-size=1234',
   '--max-http-header-size=5678',
-  '-p', 'http.maxHeaderSize'
+  '-p', 'http.maxHeaderSize',
 ], {
   encoding: 'utf8'
 }).stdout.trim(), '5678');
@@ -15,7 +15,7 @@ assert.strictEqual(spawnSync(process.execPath, [
 // The command line takes precedence over NODE_OPTIONS:
 assert.strictEqual(spawnSync(process.execPath, [
   '--max-http-header-size=5678',
-  '-p', 'http.maxHeaderSize'
+  '-p', 'http.maxHeaderSize',
 ], {
   encoding: 'utf8',
   env: { ...process.env, NODE_OPTIONS: '--max-http-header-size=1234' }
diff --git a/test/parallel/test-cli-syntax-piped-bad.js b/test/parallel/test-cli-syntax-piped-bad.js
index abd924848fc417e342450eb8e0a1378a6264c516..d22c21cb7e160559ceec5cac2a03d2587561a700 100644
--- a/test/parallel/test-cli-syntax-piped-bad.js
+++ b/test/parallel/test-cli-syntax-piped-bad.js
@@ -9,7 +9,7 @@ const node = process.execPath;
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
   '-c',
-  '--check'
+  '--check',
 ];
 
 // Match on the name of the `Error` but not the message as it is different
diff --git a/test/parallel/test-cli-syntax-piped-good.js b/test/parallel/test-cli-syntax-piped-good.js
index 43de5d32f40d402e6d84d48bb096962ce7392aff..db2e0f875d2ac7bc6d579d1437dcdcac84af99d9 100644
--- a/test/parallel/test-cli-syntax-piped-good.js
+++ b/test/parallel/test-cli-syntax-piped-good.js
@@ -9,7 +9,7 @@ const node = process.execPath;
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
   '-c',
-  '--check'
+  '--check',
 ];
 
 // Should not execute code piped from stdin with --check.
diff --git a/test/parallel/test-client-request-destroy.js b/test/parallel/test-client-request-destroy.js
new file mode 100644
index 0000000000000000000000000000000000000000..2f3efcf81204b3c1d6c874c149c475a511a0fa94
--- /dev/null
+++ b/test/parallel/test-client-request-destroy.js
@@ -0,0 +1,13 @@
+'use strict';
+
+// Test that http.ClientRequest,prototype.destroy() returns `this`.
+require('../common');
+
+const assert = require('assert');
+const http = require('http');
+const clientRequest = new http.ClientRequest({ createConnection: () => {} });
+
+assert.strictEqual(clientRequest.destroyed, false);
+assert.strictEqual(clientRequest.destroy(), clientRequest);
+assert.strictEqual(clientRequest.destroyed, true);
+assert.strictEqual(clientRequest.destroy(), clientRequest);
diff --git a/test/parallel/test-cluster-fork-windowsHide.js b/test/parallel/test-cluster-fork-windowsHide.js
index b9ee701beb65ff3256d366dbc7a4253896b2d002..b788c2263e5246e8c1acab02c13e559f45665ffb 100644
--- a/test/parallel/test-cluster-fork-windowsHide.js
+++ b/test/parallel/test-cluster-fork-windowsHide.js
@@ -5,16 +5,15 @@ const child_process = require('child_process');
 const cluster = require('cluster');
 
 if (!process.argv[2]) {
-  /* It seems Windows only allocate new console window for
-   * attaching processes spawned by detached processes. i.e.
-   * - If process D is spawned by process C with `detached: true`,
-   *   and process W is spawned by process D with `detached: false`,
-   *   W will get a new black console window popped up.
-   * - If D is spawned by C with `detached: false` or W is spawned
-   *   by D with `detached: true`, no console window will pop up for W.
-   *
-   * So, we have to spawn a detached process first to run the actual test.
-   */
+  // It seems Windows only allocate new console window for
+  // attaching processes spawned by detached processes. i.e.
+  // - If process D is spawned by process C with `detached: true`,
+  //   and process W is spawned by process D with `detached: false`,
+  //   W will get a new black console window popped up.
+  // - If D is spawned by C with `detached: false` or W is spawned
+  //   by D with `detached: true`, no console window will pop up for W.
+  //
+  // So, we have to spawn a detached process first to run the actual test.
   const master = child_process.spawn(
     process.argv[0],
     [process.argv[1], '--cluster'],
diff --git a/test/parallel/test-cluster-http-pipe.js b/test/parallel/test-cluster-http-pipe.js
index 9e039541cd26f1104f334534ad335405082693c2..173ddd04f4f26d17ff898fe8d46b29d31b2e91c9 100644
--- a/test/parallel/test-cluster-http-pipe.js
+++ b/test/parallel/test-cluster-http-pipe.js
@@ -51,8 +51,7 @@ http.createServer(common.mustCall((req, res) => {
 })).listen(common.PIPE, common.mustCall(() => {
   http.get({ socketPath: common.PIPE, path: '/' }, common.mustCall((res) => {
     res.resume();
-    res.on('end', common.mustCall((err) => {
-      assert.ifError(err);
+    res.on('end', common.mustSucceed(() => {
       process.send('DONE');
       process.exit();
     }));
diff --git a/test/parallel/test-cluster-worker-destroy.js b/test/parallel/test-cluster-worker-destroy.js
index 65b41381f569bb2d03893dbad77ed5fa2cfbe1b2..b08919c052593ef0304b4384c1d1bf571ac2f673 100644
--- a/test/parallel/test-cluster-worker-destroy.js
+++ b/test/parallel/test-cluster-worker-destroy.js
@@ -20,13 +20,12 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-/*
- * The goal of this test is to cover the Workers' implementation of
- * Worker.prototype.destroy. Worker.prototype.destroy is called within
- * the worker's context: once when the worker is still connected to the
- * master, and another time when it's not connected to it, so that we cover
- * both code paths.
- */
+
+// The goal of this test is to cover the Workers' implementation of
+// Worker.prototype.destroy. Worker.prototype.destroy is called within
+// the worker's context: once when the worker is still connected to the
+// master, and another time when it's not connected to it, so that we cover
+// both code paths.
 
 const common = require('../common');
 const assert = require('assert');
diff --git a/test/parallel/test-cluster-worker-disconnect-on-error.js b/test/parallel/test-cluster-worker-disconnect-on-error.js
index c55e69e256950f9c37cd5557e8648e6a5d3665d9..3b03b21ee7a21a5133596c33471c286e37d99b53 100644
--- a/test/parallel/test-cluster-worker-disconnect-on-error.js
+++ b/test/parallel/test-cluster-worker-disconnect-on-error.js
@@ -10,8 +10,7 @@ const server = http.createServer();
 if (cluster.isMaster) {
   let worker;
 
-  server.listen(0, common.mustCall((error) => {
-    assert.ifError(error);
+  server.listen(0, common.mustSucceed(() => {
     assert(worker);
 
     worker.send({ port: server.address().port });
diff --git a/test/parallel/test-cluster-worker-exit.js b/test/parallel/test-cluster-worker-exit.js
index f93a3f587096abd20288f167997940460eb21fd3..4c1f9c8d65978ad9a11f7380c26cad9094d2585d 100644
--- a/test/parallel/test-cluster-worker-exit.js
+++ b/test/parallel/test-cluster-worker-exit.js
@@ -53,7 +53,7 @@ if (cluster.isWorker) {
     worker_emitExit: [1, "the worker did not emit 'exit'"],
     worker_state: ['disconnected', 'the worker state is incorrect'],
     worker_exitedAfterDisconnect: [
-      false, 'the .exitedAfterDisconnect flag is incorrect'
+      false, 'the .exitedAfterDisconnect flag is incorrect',
     ],
     worker_died: [true, 'the worker is still running'],
     worker_exitCode: [EXIT_CODE, 'the worker exited w/ incorrect exitCode'],
diff --git a/test/parallel/test-common-countdown.js b/test/parallel/test-common-countdown.js
index 6a1a2f1bbce98a87341bbb7c0703ca016eed2a84..d3c0daf599670c38e2a4e378c5ba23279ae197f8 100644
--- a/test/parallel/test-common-countdown.js
+++ b/test/parallel/test-common-countdown.js
@@ -19,7 +19,7 @@ const failFixtures = [
   [
     fixtures.path('failcounter.js'),
     'Mismatched <anonymous> function calls. Expected exactly 1, actual 0.',
-  ]
+  ],
 ];
 
 for (const p of failFixtures) {
diff --git a/test/parallel/test-common.js b/test/parallel/test-common.js
index 3087cc035eb4e28bfbafdb5dc4e6e343190d2d91..24c4f8462eb767cb82921acd19e00e40860464f5 100644
--- a/test/parallel/test-common.js
+++ b/test/parallel/test-common.js
@@ -91,11 +91,11 @@ fnAtLeast2Called3();
 const failFixtures = [
   [
     fixtures.path('failmustcall1.js'),
-    'Mismatched <anonymous> function calls. Expected exactly 2, actual 1.'
+    'Mismatched <anonymous> function calls. Expected exactly 2, actual 1.',
   ], [
     fixtures.path('failmustcall2.js'),
-    'Mismatched <anonymous> function calls. Expected at least 2, actual 1.'
-  ]
+    'Mismatched <anonymous> function calls. Expected at least 2, actual 1.',
+  ],
 ];
 for (const p of failFixtures) {
   const [file, expected] = p;
diff --git a/test/parallel/test-console-formatTime.js b/test/parallel/test-console-formatTime.js
new file mode 100644
index 0000000000000000000000000000000000000000..0420013c50e77c2eeeaed5d0a46ceec0eb581ab4
--- /dev/null
+++ b/test/parallel/test-console-formatTime.js
@@ -0,0 +1,14 @@
+'use strict';
+// Flags: --expose-internals
+require('../common');
+const { formatTime } = require('internal/console/constructor');
+const assert = require('assert');
+
+assert.strictEqual(formatTime(100.0096), '100.01ms');
+assert.strictEqual(formatTime(100.0115), '100.011ms');
+assert.strictEqual(formatTime(1500.04), '1.500s');
+assert.strictEqual(formatTime(1000.056), '1.000s');
+assert.strictEqual(formatTime(60300.3), '1:00.300 (m:ss.mmm)');
+assert.strictEqual(formatTime(4000457.4), '1:06:40.457 (h:mm:ss.mmm)');
+assert.strictEqual(formatTime(3601310.4), '1:00:01.310 (h:mm:ss.mmm)');
+assert.strictEqual(formatTime(3213601017.6), '892:40:01.018 (h:mm:ss.mmm)');
diff --git a/test/parallel/test-console-table.js b/test/parallel/test-console-table.js
index e2b3b71b6287187801ecc9b2e89a27026daee02b..fb1de08323e325e0cb4f411b68b6d6c43cc7b8d4 100644
--- a/test/parallel/test-console-table.js
+++ b/test/parallel/test-console-table.js
@@ -32,7 +32,7 @@ test(undefined, 'undefined\n');
 test(false, 'false\n');
 test('hi', 'hi\n');
 test(Symbol(), 'Symbol()\n');
-test(function() {}, '[Function]\n');
+test(function() {}, '[Function (anonymous)]\n');
 
 test([1, 2, 3], `
 ┌─────────┬────────┐
@@ -276,3 +276,18 @@ test({ foo: '你好', bar: 'hello' }, `
 │   bar   │ 'hello' │
 └─────────┴─────────┘
 `);
+
+// Regression test for prototype pollution via console.table. Earlier versions
+// of Node.js created an object with a non-null prototype within console.table
+// and then wrote to object[column][index], which lead to an error as well as
+// modifications to Object.prototype.
+test([{ foo: 10 }, { foo: 20 }], ['__proto__'], `
+┌─────────┬───────────┐
+│ (index) │ __proto__ │
+├─────────┼───────────┤
+│    0    │           │
+│    1    │           │
+└─────────┴───────────┘
+`);
+assert.strictEqual('0' in Object.prototype, false);
+assert.strictEqual('1' in Object.prototype, false);
diff --git a/test/parallel/test-console-tty-colors.js b/test/parallel/test-console-tty-colors.js
index e906c71c1861771bbacb05d1411e6a4ca50720fc..0eb51c72898f7c28321c5f395b42ca17444cae08 100644
--- a/test/parallel/test-console-tty-colors.js
+++ b/test/parallel/test-console-tty-colors.js
@@ -10,7 +10,7 @@ function check(isTTY, colorMode, expectedColorMode, inspectOptions) {
     1,
     { a: 2 },
     [ 'foo' ],
-    { '\\a': '\\bar' }
+    { '\\a': '\\bar' },
   ];
 
   let i = 0;
diff --git a/test/parallel/test-console.js b/test/parallel/test-console.js
index e2c5291d915c1deeeb28d218923554efec92fb15..ee2c7c82a6f8e062501a9b3a05717f0440ed10fe 100644
--- a/test/parallel/test-console.js
+++ b/test/parallel/test-console.js
@@ -49,7 +49,7 @@ common.expectWarning(
     ['No such label \'default\' for console.timeLog()'],
     ['No such label \'default\' for console.timeEnd()'],
     ['Label \'default\' already exists for console.time()'],
-    ['Label \'test\' already exists for console.time()']
+    ['Label \'test\' already exists for console.time()'],
   ]
 );
 
@@ -216,7 +216,7 @@ console.timeEnd('label3');
 assert.strictEqual(console._times.size, timesMapSize);
 
 const expectedStrings = [
-  'foo', 'foo bar', 'foo bar hop', "{ slashes: '\\\\\\\\' }", 'inspect'
+  'foo', 'foo bar', 'foo bar hop', "{ slashes: '\\\\\\\\' }", 'inspect',
 ];
 
 for (const expected of expectedStrings) {
@@ -246,24 +246,24 @@ assert.ok(strings[0].includes('foo: { bar: { baz:'));
 assert.ok(strings[0].includes('quux'));
 assert.ok(strings.shift().includes('quux: true'));
 
-assert.ok(/^label: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^__proto__: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^constructor: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^hasOwnProperty: \d+\.\d{3}ms$/.test(strings.shift().trim()));
+assert.ok(/^label: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^__proto__: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^constructor: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^hasOwnProperty: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
 
 // Verify that console.time() coerces label values to strings as expected
-assert.ok(/^: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^\[object Object\]: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^\[object Object\]: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^null: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^default: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^default: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^NaN: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-
-assert.ok(/^log1: \d+\.\d{3}ms$/.test(strings.shift().trim()));
-assert.ok(/^log1: \d+\.\d{3}ms test$/.test(strings.shift().trim()));
-assert.ok(/^log1: \d+\.\d{3}ms {} \[ 1, 2, 3 ]$/.test(strings.shift().trim()));
-assert.ok(/^log1: \d+\.\d{3}ms$/.test(strings.shift().trim()));
+assert.ok(/^: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^\[object Object\]: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^\[object Object\]: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^null: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^default: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^default: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^NaN: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+
+assert.ok(/^log1: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
+assert.ok(/^log1: \d+(\.\d{1,3})?(ms|s) test$/.test(strings.shift().trim()));
+assert.ok(/^log1: \d+(\.\d{1,3})?(ms|s) {} \[ 1, 2, 3 ]$/.test(strings.shift().trim()));
+assert.ok(/^log1: \d+(\.\d{1,3})?(ms|s)$/.test(strings.shift().trim()));
 
 // Make sure that we checked all strings
 assert.strictEqual(strings.length, 0);
diff --git a/test/known_issues/test-crypto-authenticated-stream.js b/test/parallel/test-crypto-authenticated-stream.js
similarity index 98%
rename from test/known_issues/test-crypto-authenticated-stream.js
rename to test/parallel/test-crypto-authenticated-stream.js
index 1e2a9edd7b0a6eff99b5de322f6c83437d1bcc1e..f29ee8932af8049835c55655cba414b28e54ed72 100644
--- a/test/known_issues/test-crypto-authenticated-stream.js
+++ b/test/parallel/test-crypto-authenticated-stream.js
@@ -1,7 +1,9 @@
-/* eslint-disable node-core/crypto-check */
 'use strict';
 // Refs: https://github.com/nodejs/node/issues/31733
 const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
 const assert = require('assert');
 const crypto = require('crypto');
 const fs = require('fs');
@@ -121,7 +123,6 @@ function test(config) {
 
 tmpdir.refresh();
 
-// OK
 test({
   cipher: 'aes-128-ccm',
   aad: Buffer.alloc(1),
@@ -131,7 +132,6 @@ test({
   plaintextLength: 32768,
 });
 
-// Fails the fstream test.
 test({
   cipher: 'aes-128-ccm',
   aad: Buffer.alloc(1),
diff --git a/test/parallel/test-crypto-authenticated.js b/test/parallel/test-crypto-authenticated.js
index 863907bafd81920c40bccaf89299a2bcdb1be79e..1375095d1ce9bb14e178ec11c6f4f62e83404e3b 100644
--- a/test/parallel/test-crypto-authenticated.js
+++ b/test/parallel/test-crypto-authenticated.js
@@ -68,12 +68,12 @@ const expectedWarnings = common.hasFipsCrypto ?
     ['Use Cipheriv for counter mode of aes-256-ccm'],
     ['Use Cipheriv for counter mode of aes-256-ccm'],
     ['Use Cipheriv for counter mode of aes-256-ccm'],
-    ['Use Cipheriv for counter mode of aes-256-ccm']
+    ['Use Cipheriv for counter mode of aes-256-ccm'],
   ];
 
 const expectedDeprecationWarnings = [
   ['crypto.DEFAULT_ENCODING is deprecated.', 'DEP0091'],
-  ['crypto.createCipher is deprecated.', 'DEP0106']
+  ['crypto.createCipher is deprecated.', 'DEP0106'],
 ];
 
 common.expectWarning({
@@ -310,7 +310,7 @@ for (const test of TEST_CASES) {
   decipher.setAuthTag(Buffer.from('445352d3ff85cf94', 'hex'));
   const text = Buffer.concat([
     decipher.update('3a2a3647', 'hex'),
-    decipher.final()
+    decipher.final(),
   ]);
   assert.strictEqual(text.toString('utf8'), 'node');
 }
@@ -611,7 +611,7 @@ for (const test of TEST_CASES) {
     // Decryption should still work.
     const plaintext = Buffer.concat([
       decipher.update(ciphertext),
-      decipher.final()
+      decipher.final(),
     ]);
     assert(plain.equals(plaintext));
   }
diff --git a/test/parallel/test-crypto-binary-default.js b/test/parallel/test-crypto-binary-default.js
index a2fb2e82670567f3867936a6f0999a80acf4061e..3fcd3f66161fdb0953bcfc5e7dce758854f8d6f5 100644
--- a/test/parallel/test-crypto-binary-default.js
+++ b/test/parallel/test-crypto-binary-default.js
@@ -214,7 +214,7 @@ assert.throws(function() {
             '20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de04460' +
             '65c97440fa8c6a58'
       }
-    }
+    },
   ];
 
   for (const testCase of rfc4231) {
@@ -286,7 +286,7 @@ assert.throws(function() {
           'Test Using Larger Than Block-Size Key and Larger Than One ' +
           'Block-Size Data',
       hmac: '6f630fad67cda0ee1fb1f562db3aa53e'
-    }
+    },
   ];
   const rfc2202_sha1 = [
     {
@@ -340,7 +340,7 @@ assert.throws(function() {
           'Test Using Larger Than Block-Size Key and Larger Than One ' +
           'Block-Size Data',
       hmac: 'e8e99d0f45237d786d6bbaa7965c7808bbff1a91'
-    }
+    },
   ];
 
   if (!common.hasFipsCrypto) {
diff --git a/test/parallel/test-crypto-cipher-decipher.js b/test/parallel/test-crypto-cipher-decipher.js
index 4bb765d9ca408b656937bc6ee59d58a0f3518a39..b60c7f95d15cb3730850dd48568bef87b0f5c77e 100644
--- a/test/parallel/test-crypto-cipher-decipher.js
+++ b/test/parallel/test-crypto-cipher-decipher.js
@@ -12,10 +12,10 @@ const assert = require('assert');
 
 common.expectWarning({
   Warning: [
-    ['Use Cipheriv for counter mode of aes-256-gcm']
+    ['Use Cipheriv for counter mode of aes-256-gcm'],
   ],
   DeprecationWarning: [
-    ['crypto.createCipher is deprecated.', 'DEP0106']
+    ['crypto.createCipher is deprecated.', 'DEP0106'],
   ]
 });
 
diff --git a/test/parallel/test-crypto-dh-leak.js b/test/parallel/test-crypto-dh-leak.js
index 65486dbd80cb6447d5e4dc6564001ea518554ffd..5c4c0c61d4f41c532c74e067e6a3bfa990f753d3 100644
--- a/test/parallel/test-crypto-dh-leak.js
+++ b/test/parallel/test-crypto-dh-leak.js
@@ -10,7 +10,7 @@ if (process.config.variables.asan)
 const assert = require('assert');
 const crypto = require('crypto');
 
-const before = process.memoryUsage().rss;
+const before = process.memoryUsage.rss();
 {
   const dh = crypto.createDiffieHellman(common.hasFipsCrypto ? 1024 : 256);
   const publicKey = dh.generateKeys();
@@ -21,7 +21,7 @@ const before = process.memoryUsage().rss;
   }
 }
 global.gc();
-const after = process.memoryUsage().rss;
+const after = process.memoryUsage.rss();
 
 // RSS should stay the same, ceteris paribus, but allow for
 // some slop because V8 mallocs memory during execution.
diff --git a/test/parallel/test-crypto-dh-padding.js b/test/parallel/test-crypto-dh-padding.js
index 311b9d156ff174b3ed5088325e0ca2e3d2ab450d..088ea827ec9c5839044ef71628c50c159d71a7b0 100644
--- a/test/parallel/test-crypto-dh-padding.js
+++ b/test/parallel/test-crypto-dh-padding.js
@@ -28,41 +28,40 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const crypto = require('crypto');
 
-/* This test verifies padding with leading zeroes for shared
- * secrets that are strictly smaller than the modulus (prime).
- * See:
- *  RFC 4346: https://www.ietf.org/rfc/rfc4346.txt
- *  https://github.com/nodejs/node-v0.x-archive/issues/7906
- *  https://github.com/nodejs/node-v0.x-archive/issues/5239
- *
- * In FIPS mode OPENSSL_DH_FIPS_MIN_MODULUS_BITS = 1024, meaning we need
- * a FIPS-friendly >= 1024 bit prime, we can use MODP 14 from RFC 3526:
- * https://www.ietf.org/rfc/rfc3526.txt
- *
- * We can generate appropriate values with this code:
- *
- * crypto = require('crypto');
- *
- * for (;;) {
- *   var a = crypto.getDiffieHellman('modp14'),
- *   var b = crypto.getDiffieHellman('modp14');
- *
- *   a.generateKeys();
- *   b.generateKeys();
- *
- *   var aSecret = a.computeSecret(b.getPublicKey()).toString('hex');
- *   console.log("A public: " + a.getPublicKey().toString('hex'));
- *   console.log("A private: " + a.getPrivateKey().toString('hex'));
- *   console.log("B public: " + b.getPublicKey().toString('hex'));
- *   console.log("B private: " + b.getPrivateKey().toString('hex'));
- *   console.log("A secret: " + aSecret);
- *   console.log('-------------------------------------------------');
- *   if(aSecret.substring(0,2) === "00") {
- *     console.log("found short key!");
- *     return;
- *   }
- * }
- */
+// This test verifies padding with leading zeroes for shared
+// secrets that are strictly smaller than the modulus (prime).
+// See:
+//  RFC 4346: https://www.ietf.org/rfc/rfc4346.txt
+//  https://github.com/nodejs/node-v0.x-archive/issues/7906
+//  https://github.com/nodejs/node-v0.x-archive/issues/5239
+//
+// In FIPS mode OPENSSL_DH_FIPS_MIN_MODULUS_BITS = 1024, meaning we need
+// a FIPS-friendly >= 1024 bit prime, we can use MODP 14 from RFC 3526:
+// https://www.ietf.org/rfc/rfc3526.txt
+//
+// We can generate appropriate values with this code:
+//
+// crypto = require('crypto');
+//
+// for (;;) {
+//   var a = crypto.getDiffieHellman('modp14'),
+//   var b = crypto.getDiffieHellman('modp14');
+//
+//   a.generateKeys();
+//   b.generateKeys();
+//
+//   var aSecret = a.computeSecret(b.getPublicKey()).toString('hex');
+//   console.log("A public: " + a.getPublicKey().toString('hex'));
+//   console.log("A private: " + a.getPrivateKey().toString('hex'));
+//   console.log("B public: " + b.getPublicKey().toString('hex'));
+//   console.log("B private: " + b.getPrivateKey().toString('hex'));
+//   console.log("A secret: " + aSecret);
+//   console.log('-------------------------------------------------');
+//   if(aSecret.substring(0,2) === "00") {
+//     console.log("found short key!");
+//     return;
+//   }
+// }
 
 const apub =
 '5484455905d3eff34c70980e871f27f05448e66f5a6efbb97cbcba4e927196c2bd9ea272cded91\
diff --git a/test/parallel/test-crypto-dh-stateless.js b/test/parallel/test-crypto-dh-stateless.js
index b01cea76b221c164e0046a4a8014f22683c74d1d..e1b02b5c51fbd887e1bfdfb62d033d921f671e59 100644
--- a/test/parallel/test-crypto-dh-stateless.js
+++ b/test/parallel/test-crypto-dh-stateless.js
@@ -138,7 +138,7 @@ for (const [params1, params2] of [
   // Same primes, but different generator.
   [{ group: 'modp5' }, { prime: group.getPrime(), generator: 5 }],
   // Same generator, but different primes.
-  [{ primeLength: 1024 }, { primeLength: 1024 }]
+  [{ primeLength: 1024 }, { primeLength: 1024 }],
 ]) {
   assert.throws(() => {
     test(crypto.generateKeyPairSync('dh', params1),
diff --git a/test/parallel/test-crypto-dh.js b/test/parallel/test-crypto-dh.js
index 6db0d9543f057b7542b1ff480feb6f5bde89294b..cb82bde516169749f933f97068f5e72bb28771b5 100644
--- a/test/parallel/test-crypto-dh.js
+++ b/test/parallel/test-crypto-dh.js
@@ -102,7 +102,7 @@ for (const g of [Buffer.from([]),
   [0x1, 0x2],
   () => { },
   /abc/,
-  {}
+  {},
 ].forEach((input) => {
   assert.throws(
     () => crypto.createDiffieHellman(input),
@@ -182,9 +182,9 @@ const aSecret = alice.computeSecret(bob.getPublicKey()).toString('hex');
 const bSecret = bob.computeSecret(alice.getPublicKey()).toString('hex');
 assert.strictEqual(aSecret, bSecret);
 
-/* Ensure specific generator (buffer) works as expected.
- * The values below (modp2/modp2buf) are for a 1024 bits long prime from
- * RFC 2412 E.2, see https://tools.ietf.org/html/rfc2412. */
+// Ensure specific generator (buffer) works as expected.
+// The values below (modp2/modp2buf) are for a 1024 bits long prime from
+// RFC 2412 E.2, see https://tools.ietf.org/html/rfc2412. */
 const modp2 = crypto.createDiffieHellmanGroup('modp2');
 const modp2buf = Buffer.from([
   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f,
@@ -199,7 +199,7 @@ const modp2buf = Buffer.from([
   0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, 0xee, 0x38, 0x6b, 0xfb,
   0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b,
   0x1f, 0xe6, 0x49, 0x28, 0x66, 0x51, 0xec, 0xe6, 0x53, 0x81,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 ]);
 
 {
@@ -448,7 +448,7 @@ assert.throws(
   {
     name: 'Error',
     code: 'ERR_CRYPTO_UNKNOWN_DH_GROUP',
-    message: 'Unknown group'
+    message: 'Unknown DH group'
   },
   'crypto.getDiffieHellman(\'unknown-group\') ' +
   'failed to throw the expected error.'
@@ -471,3 +471,9 @@ assert.throws(
   'crypto.getDiffieHellman(\'modp1\').setPublicKey(\'\') ' +
   'failed to throw the expected error.'
 );
+assert.throws(
+  () => crypto.createDiffieHellman('', true),
+  {
+    code: 'ERR_INVALID_ARG_TYPE'
+  }
+);
diff --git a/test/parallel/test-crypto-hmac.js b/test/parallel/test-crypto-hmac.js
index 160d09036dbe7fa41223479324f907fb263047e3..13285f2fbbf855bf8278d02e45b513d296f6d05f 100644
--- a/test/parallel/test-crypto-hmac.js
+++ b/test/parallel/test-crypto-hmac.js
@@ -51,7 +51,7 @@ function testHmac(algo, key, data, expected) {
   // If the key is a Buffer, test Hmac with a key object as well.
   const keyWrappers = [
     (key) => key,
-    ...(typeof key === 'string' ? [] : [crypto.createSecretKey])
+    ...(typeof key === 'string' ? [] : [crypto.createSecretKey]),
   ];
 
   for (const keyWrapper of keyWrappers) {
@@ -262,7 +262,7 @@ const rfc4231 = [
           '20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de04460' +
           '65c97440fa8c6a58'
     }
-  }
+  },
 ];
 
 for (let i = 0, l = rfc4231.length; i < l; i++) {
@@ -344,7 +344,7 @@ const rfc2202_md5 = [
         'Test Using Larger Than Block-Size Key and Larger Than One ' +
         'Block-Size Data',
     hmac: '6f630fad67cda0ee1fb1f562db3aa53e'
-  }
+  },
 ];
 
 for (const { key, data, hmac } of rfc2202_md5)
@@ -402,7 +402,7 @@ const rfc2202_sha1 = [
         'Test Using Larger Than Block-Size Key and Larger Than One ' +
         'Block-Size Data',
     hmac: 'e8e99d0f45237d786d6bbaa7965c7808bbff1a91'
-  }
+  },
 ];
 
 for (const { key, data, hmac } of rfc2202_sha1)
diff --git a/test/parallel/test-crypto-key-objects-messageport.js b/test/parallel/test-crypto-key-objects-messageport.js
index 1b910b571f77fc7c9d0ac323a4b718247c5ae60a..f38e20da420aaeb745a49696a5cd4506280c2fe0 100644
--- a/test/parallel/test-crypto-key-objects-messageport.js
+++ b/test/parallel/test-crypto-key-objects-messageport.js
@@ -75,9 +75,9 @@ for (const [key, repr] of keys) {
 
     // TODO(addaleax): Switch this to a 'messageerror' event once MessagePort
     // implements EventTarget fully and in a cross-context manner.
-    port2moved.emit = common.mustCall((name, err) => {
-      assert.strictEqual(name, 'messageerror');
-      assert.strictEqual(err.code, 'ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE');
+    port2moved.onmessageerror = common.mustCall((event) => {
+      assert.strictEqual(event.data.code,
+                         'ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE');
     });
 
     port2moved.start();
diff --git a/test/parallel/test-crypto-key-objects.js b/test/parallel/test-crypto-key-objects.js
index d3011db79d65b4e80d8a546e122e462951acef9f..5d1e2619a66bc32f304527268536f6b9d0a0a83f 100644
--- a/test/parallel/test-crypto-key-objects.js
+++ b/test/parallel/test-crypto-key-objects.js
@@ -78,12 +78,12 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
 
   const cipher = createCipheriv('aes-256-ecb', key, null);
   const ciphertext = Buffer.concat([
-    cipher.update(plaintext), cipher.final()
+    cipher.update(plaintext), cipher.final(),
   ]);
 
   const decipher = createDecipheriv('aes-256-ecb', key, null);
   const deciphered = Buffer.concat([
-    decipher.update(ciphertext), decipher.final()
+    decipher.update(ciphertext), decipher.final(),
   ]);
 
   assert(plaintext.equals(deciphered));
@@ -185,15 +185,15 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
     // Test distinguishing PKCS#1 public and private keys based on the
     // DER-encoded data only.
     publicEncrypt({ format: 'der', type: 'pkcs1', key: publicDER }, plaintext),
-    publicEncrypt({ format: 'der', type: 'pkcs1', key: privateDER }, plaintext)
+    publicEncrypt({ format: 'der', type: 'pkcs1', key: privateDER }, plaintext),
   ], [
     privateKey,
     { format: 'pem', key: privatePem },
-    { format: 'der', type: 'pkcs1', key: privateDER }
+    { format: 'der', type: 'pkcs1', key: privateDER },
   ]);
 
   testDecryption(publicDecrypt, [
-    privateEncrypt(privateKey, plaintext)
+    privateEncrypt(privateKey, plaintext),
   ], [
     // Decrypt using the public key.
     publicKey,
@@ -203,7 +203,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
     // Decrypt using the private key.
     privateKey,
     { format: 'pem', key: privatePem },
-    { format: 'der', type: 'pkcs1', key: privateDER }
+    { format: 'der', type: 'pkcs1', key: privateDER },
   ]);
 }
 
diff --git a/test/parallel/test-crypto-keygen.js b/test/parallel/test-crypto-keygen.js
index 384f4fa68a2d02616d269e7d6ea84068243cb246..dd106004fad5acacb74b1c06ba5cb117ef0dad02 100644
--- a/test/parallel/test-crypto-keygen.js
+++ b/test/parallel/test-crypto-keygen.js
@@ -143,9 +143,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       type: 'pkcs1',
       format: 'pem'
     }
-  }, common.mustCall((err, publicKeyDER, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKeyDER, privateKey) => {
     assert(Buffer.isBuffer(publicKeyDER));
     assertApproximateSize(publicKeyDER, 74);
 
@@ -169,9 +167,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       cipher: 'aes-256-cbc',
       passphrase: 'secret'
     }
-  }, common.mustCall((err, publicKeyDER, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKeyDER, privateKey) => {
     assert(Buffer.isBuffer(publicKeyDER));
     assertApproximateSize(publicKeyDER, 74);
 
@@ -202,9 +198,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       cipher: 'aes-256-cbc',
       passphrase: 'secret'
     }
-  }, common.mustCall((err, publicKeyDER, privateKeyDER) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKeyDER, privateKeyDER) => {
     assert(Buffer.isBuffer(publicKeyDER));
     assertApproximateSize(publicKeyDER, 74);
 
@@ -245,9 +239,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       type: 'pkcs8',
       format: 'der'
     }
-  }, common.mustCall((err, publicKeyDER, privateKeyDER) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKeyDER, privateKeyDER) => {
     assert(Buffer.isBuffer(publicKeyDER));
     assertApproximateSize(publicKeyDER, 74);
 
@@ -272,9 +264,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
     saltLength: 16,
     hash: 'sha256',
     mgf1Hash: 'sha256'
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(publicKey.type, 'public');
     assert.strictEqual(publicKey.asymmetricKeyType, 'rsa-pss');
 
@@ -321,9 +311,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       passphrase: 'secret',
       ...privateKeyEncoding
     }
-  }, common.mustCall((err, publicKey, privateKeyDER) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKeyDER) => {
     assert.strictEqual(typeof publicKey, 'string');
     assert(spkiExp.test(publicKey));
     // The private key is DER-encoded.
@@ -367,9 +355,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       type: 'sec1',
       format: 'pem'
     }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(typeof publicKey, 'string');
     assert(spkiExp.test(publicKey));
     assert.strictEqual(typeof privateKey, 'string');
@@ -391,9 +377,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       type: 'sec1',
       format: 'pem'
     }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(typeof publicKey, 'string');
     assert(spkiExp.test(publicKey));
     assert.strictEqual(typeof privateKey, 'string');
@@ -416,9 +400,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       cipher: 'aes-128-cbc',
       passphrase: 'secret'
     }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(typeof publicKey, 'string');
     assert(spkiExp.test(publicKey));
     assert.strictEqual(typeof privateKey, 'string');
@@ -448,9 +430,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       cipher: 'aes-128-cbc',
       passphrase: 'secret'
     }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(typeof publicKey, 'string');
     assert(spkiExp.test(publicKey));
     assert.strictEqual(typeof privateKey, 'string');
@@ -483,9 +463,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       cipher: 'aes-128-cbc',
       passphrase: 'top secret'
     }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(typeof publicKey, 'string');
     assert(spkiExp.test(publicKey));
     assert.strictEqual(typeof privateKey, 'string');
@@ -519,9 +497,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       cipher: 'aes-128-cbc',
       passphrase: 'top secret'
     }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(typeof publicKey, 'string');
     assert(spkiExp.test(publicKey));
     assert.strictEqual(typeof privateKey, 'string');
@@ -637,9 +613,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       type: 'pkcs1',
       format: 'pem'
     }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(typeof publicKey, 'object');
     assert.strictEqual(publicKey.type, 'public');
     assert.strictEqual(publicKey.asymmetricKeyType, 'rsa');
@@ -658,9 +632,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
       type: 'pkcs1',
       format: 'pem'
     }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     // The public key should still be a string.
     assert.strictEqual(typeof publicKey, 'string');
 
@@ -962,16 +934,14 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
     namedCurve: 'P-256',
     publicKeyEncoding: { type: 'spki', format: 'pem' },
     privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
+  }, common.mustSucceed((publicKey, privateKey) => {
   }));
 
   generateKeyPair('ec', {
     namedCurve: 'secp256k1',
     publicKeyEncoding: { type: 'spki', format: 'pem' },
     privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
+  }, common.mustSucceed((publicKey, privateKey) => {
   }));
 }
 
@@ -979,9 +949,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
 {
   if (!/^1\.1\.0/.test(process.versions.openssl)) {
     ['ed25519', 'ed448', 'x25519', 'x448'].forEach((keyType) => {
-      generateKeyPair(keyType, common.mustCall((err, publicKey, privateKey) => {
-        assert.ifError(err);
-
+      generateKeyPair(keyType, common.mustSucceed((publicKey, privateKey) => {
         assert.strictEqual(publicKey.type, 'public');
         assert.strictEqual(publicKey.asymmetricKeyType, keyType);
 
@@ -996,9 +964,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
 {
   generateKeyPair('dh', {
     primeLength: 1024
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
+  }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(publicKey.type, 'public');
     assert.strictEqual(publicKey.asymmetricKeyType, 'dh');
 
@@ -1044,7 +1010,7 @@ const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
     ['group', 'prime'],
     ['group', 'primeLength'],
     ['group', 'generator'],
-    ['prime', 'primeLength']
+    ['prime', 'primeLength'],
   ];
   for (const [opt1, opt2] of incompatible) {
     assert.throws(() => {
diff --git a/test/parallel/test-crypto-pbkdf2.js b/test/parallel/test-crypto-pbkdf2.js
index 5ab37aceb6505a971c3baac0c10cdf1aade7a26b..f68dbaf2028da0a4cddf27aab7a800e0f3261bc4 100644
--- a/test/parallel/test-crypto-pbkdf2.js
+++ b/test/parallel/test-crypto-pbkdf2.js
@@ -6,11 +6,6 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const crypto = require('crypto');
 
-common.expectWarning(
-  'DeprecationWarning',
-  'Calling pbkdf2 or pbkdf2Sync with "digest" set to null is deprecated.',
-  'DEP0009');
-
 //
 // Test PBKDF2 with RFC 6070 test vectors (except #4)
 //
@@ -19,9 +14,10 @@ function testPBKDF2(password, salt, iterations, keylen, expected) {
     crypto.pbkdf2Sync(password, salt, iterations, keylen, 'sha256');
   assert.strictEqual(actual.toString('latin1'), expected);
 
-  crypto.pbkdf2(password, salt, iterations, keylen, 'sha256', (err, actual) => {
-    assert.strictEqual(actual.toString('latin1'), expected);
-  });
+  crypto.pbkdf2(password, salt, iterations, keylen, 'sha256',
+                (err, actual) => {
+                  assert.strictEqual(actual.toString('latin1'), expected);
+                });
 }
 
 
@@ -53,30 +49,33 @@ const expected =
 const key = crypto.pbkdf2Sync('password', 'salt', 32, 32, 'sha256');
 assert.strictEqual(key.toString('hex'), expected);
 
-crypto.pbkdf2('password', 'salt', 32, 32, 'sha256', common.mustCall(ondone));
-function ondone(err, key) {
-  assert.ifError(err);
+crypto.pbkdf2('password', 'salt', 32, 32, 'sha256',
+              common.mustSucceed(ondone));
+
+function ondone(key) {
   assert.strictEqual(key.toString('hex'), expected);
 }
 
 // Error path should not leak memory (check with valgrind).
 assert.throws(
-  () => crypto.pbkdf2('password', 'salt', 1, 20, null),
+  () => crypto.pbkdf2('password', 'salt', 1, 20, 'sha1'),
   {
     code: 'ERR_INVALID_CALLBACK',
     name: 'TypeError'
   }
 );
 
-assert.throws(
-  () => crypto.pbkdf2Sync('password', 'salt', -1, 20, 'sha1'),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    name: 'RangeError',
-    message: 'The value of "iterations" is out of range. ' +
-             'It must be >= 0 && < 4294967296. Received -1'
-  }
-);
+for (const iterations of [-1, 0]) {
+  assert.throws(
+    () => crypto.pbkdf2Sync('password', 'salt', iterations, 20, 'sha1'),
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "iterations" is out of range. ' +
+               `It must be >= 1 && < 4294967296. Received ${iterations}`
+    }
+  );
+}
 
 ['str', null, undefined, [], {}].forEach((notNumber) => {
   assert.throws(
@@ -118,14 +117,14 @@ assert.throws(
 
 // Should not get FATAL ERROR with empty password and salt
 // https://github.com/nodejs/node/issues/8571
-crypto.pbkdf2('', '', 1, 32, 'sha256', common.mustCall(assert.ifError));
+crypto.pbkdf2('', '', 1, 32, 'sha256', common.mustSucceed());
 
 assert.throws(
   () => crypto.pbkdf2('password', 'salt', 8, 8, common.mustNotCall()),
   {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError',
-    message: 'The "digest" argument must be of type string or null. ' +
+    message: 'The "digest" argument must be of type string. ' +
              'Received undefined'
   });
 
@@ -134,10 +133,18 @@ assert.throws(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError',
-    message: 'The "digest" argument must be of type string or null. ' +
+    message: 'The "digest" argument must be of type string. ' +
              'Received undefined'
   });
 
+assert.throws(
+  () => crypto.pbkdf2Sync('password', 'salt', 8, 8, null),
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+    message: 'The "digest" argument must be of type string. ' +
+             'Received null'
+  });
 [1, {}, [], true, undefined, null].forEach((input) => {
   const msgPart2 = 'an instance of Buffer, TypedArray, or DataView.' +
                    common.invalidArgTypeHelper(input);
@@ -200,16 +207,26 @@ assert.throws(
 });
 
 // Any TypedArray should work for password and salt
-crypto.pbkdf2(new Uint8Array(10), 'salt', 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2('pass', new Uint8Array(10), 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2(new Uint16Array(10), 'salt', 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2('pass', new Uint16Array(10), 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2(new Uint32Array(10), 'salt', 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2('pass', new Uint32Array(10), 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2(new Float32Array(10), 'salt', 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2('pass', new Float32Array(10), 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2(new Float64Array(10), 'salt', 8, 8, 'sha256', common.mustCall());
-crypto.pbkdf2('pass', new Float64Array(10), 8, 8, 'sha256', common.mustCall());
+crypto.pbkdf2(new Uint8Array(10), 'salt', 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2('pass', new Uint8Array(10), 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2(new Uint16Array(10), 'salt', 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2('pass', new Uint16Array(10), 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2(new Uint32Array(10), 'salt', 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2('pass', new Uint32Array(10), 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2(new Float32Array(10), 'salt', 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2('pass', new Float32Array(10), 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2(new Float64Array(10), 'salt', 8, 8, 'sha256',
+              common.mustSucceed());
+crypto.pbkdf2('pass', new Float64Array(10), 8, 8, 'sha256',
+              common.mustSucceed());
 
 crypto.pbkdf2Sync(new Uint8Array(10), 'salt', 8, 8, 'sha256');
 crypto.pbkdf2Sync('pass', new Uint8Array(10), 8, 8, 'sha256');
diff --git a/test/parallel/test-crypto-random.js b/test/parallel/test-crypto-random.js
index e175550c4b4c1241745a68f84221c547368026aa..e09eae69dd9a2e5f4cecaff25c692b76dea6d4bb 100644
--- a/test/parallel/test-crypto-random.js
+++ b/test/parallel/test-crypto-random.js
@@ -31,8 +31,8 @@ const crypto = require('crypto');
 const { kMaxLength } = require('buffer');
 const { inspect } = require('util');
 
-const kMaxUint32 = Math.pow(2, 32) - 1;
-const kMaxPossibleLength = Math.min(kMaxLength, kMaxUint32);
+const kMaxInt32 = 2 ** 31 - 1;
+const kMaxPossibleLength = Math.min(kMaxLength, kMaxInt32);
 
 common.expectWarning('DeprecationWarning',
                      'crypto.pseudoRandomBytes is deprecated.', 'DEP0115');
@@ -50,7 +50,7 @@ common.expectWarning('DeprecationWarning',
       assert.throws(() => f(value, common.mustNotCall()), errObj);
     });
 
-    [-1, NaN, 2 ** 32].forEach((value) => {
+    [-1, NaN, 2 ** 32, 2 ** 31].forEach((value) => {
       const errObj = {
         code: 'ERR_OUT_OF_RANGE',
         name: 'RangeError',
@@ -92,7 +92,7 @@ common.expectWarning('DeprecationWarning',
     new Uint32Array(10),
     new Float32Array(10),
     new Float64Array(10),
-    new DataView(new ArrayBuffer(10))
+    new DataView(new ArrayBuffer(10)),
   ].forEach((buf) => {
     const before = Buffer.from(buf.buffer).toString('hex');
     crypto.randomFillSync(buf);
@@ -104,8 +104,7 @@ common.expectWarning('DeprecationWarning',
 {
   const buf = Buffer.alloc(10);
   const before = buf.toString('hex');
-  crypto.randomFill(buf, common.mustCall((err, buf) => {
-    assert.ifError(err);
+  crypto.randomFill(buf, common.mustSucceed((buf) => {
     const after = buf.toString('hex');
     assert.notStrictEqual(before, after);
   }));
@@ -114,8 +113,7 @@ common.expectWarning('DeprecationWarning',
 {
   const buf = new Uint8Array(new Array(10).fill(0));
   const before = Buffer.from(buf).toString('hex');
-  crypto.randomFill(buf, common.mustCall((err, buf) => {
-    assert.ifError(err);
+  crypto.randomFill(buf, common.mustSucceed((buf) => {
     const after = Buffer.from(buf).toString('hex');
     assert.notStrictEqual(before, after);
   }));
@@ -127,11 +125,10 @@ common.expectWarning('DeprecationWarning',
     new Uint32Array(10),
     new Float32Array(10),
     new Float64Array(10),
-    new DataView(new ArrayBuffer(10))
+    new DataView(new ArrayBuffer(10)),
   ].forEach((buf) => {
     const before = Buffer.from(buf.buffer).toString('hex');
-    crypto.randomFill(buf, common.mustCall((err, buf) => {
-      assert.ifError(err);
+    crypto.randomFill(buf, common.mustSucceed((buf) => {
       const after = Buffer.from(buf.buffer).toString('hex');
       assert.notStrictEqual(before, after);
     }));
@@ -168,8 +165,7 @@ common.expectWarning('DeprecationWarning',
 {
   const buf = Buffer.alloc(10);
   const before = buf.toString('hex');
-  crypto.randomFill(buf, 5, 5, common.mustCall((err, buf) => {
-    assert.ifError(err);
+  crypto.randomFill(buf, 5, 5, common.mustSucceed((buf) => {
     const after = buf.toString('hex');
     assert.notStrictEqual(before, after);
     assert.deepStrictEqual(before.slice(0, 5), after.slice(0, 5));
@@ -179,8 +175,7 @@ common.expectWarning('DeprecationWarning',
 {
   const buf = new Uint8Array(new Array(10).fill(0));
   const before = Buffer.from(buf).toString('hex');
-  crypto.randomFill(buf, 5, 5, common.mustCall((err, buf) => {
-    assert.ifError(err);
+  crypto.randomFill(buf, 5, 5, common.mustSucceed((buf) => {
     const after = Buffer.from(buf).toString('hex');
     assert.notStrictEqual(before, after);
     assert.deepStrictEqual(before.slice(0, 5), after.slice(0, 5));
@@ -190,7 +185,7 @@ common.expectWarning('DeprecationWarning',
 {
   [
     Buffer.alloc(10),
-    new Uint8Array(new Array(10).fill(0))
+    new Uint8Array(new Array(10).fill(0)),
   ].forEach((buf) => {
     const len = Buffer.byteLength(buf);
     assert.strictEqual(len, 10, `Expected byteLength of 10, got ${len}`);
@@ -318,8 +313,7 @@ assert.throws(
   // Asynchronous API
   const randomInts = [];
   for (let i = 0; i < 100; i++) {
-    crypto.randomInt(3, common.mustCall((err, n) => {
-      assert.ifError(err);
+    crypto.randomInt(3, common.mustSucceed((n) => {
       assert.ok(n >= 0);
       assert.ok(n < 3);
       randomInts.push(n);
@@ -353,8 +347,7 @@ assert.throws(
   // Positive range
   const randomInts = [];
   for (let i = 0; i < 100; i++) {
-    crypto.randomInt(1, 3, common.mustCall((err, n) => {
-      assert.ifError(err);
+    crypto.randomInt(1, 3, common.mustSucceed((n) => {
       assert.ok(n >= 1);
       assert.ok(n < 3);
       randomInts.push(n);
@@ -371,8 +364,7 @@ assert.throws(
   // Negative range
   const randomInts = [];
   for (let i = 0; i < 100; i++) {
-    crypto.randomInt(-10, -8, common.mustCall((err, n) => {
-      assert.ifError(err);
+    crypto.randomInt(-10, -8, common.mustSucceed((n) => {
       assert.ok(n >= -10);
       assert.ok(n < -8);
       randomInts.push(n);
@@ -430,8 +422,8 @@ assert.throws(
   const maxInt = Number.MAX_SAFE_INTEGER;
   const minInt = Number.MIN_SAFE_INTEGER;
 
-  crypto.randomInt(minInt, minInt + 5, common.mustCall());
-  crypto.randomInt(maxInt - 5, maxInt, common.mustCall());
+  crypto.randomInt(minInt, minInt + 5, common.mustSucceed());
+  crypto.randomInt(maxInt - 5, maxInt, common.mustSucceed());
 
   assert.throws(
     () => crypto.randomInt(minInt - 1, minInt + 5, common.mustNotCall()),
@@ -453,8 +445,8 @@ assert.throws(
     }
   );
 
-  crypto.randomInt(1, common.mustCall());
-  crypto.randomInt(0, 1, common.mustCall());
+  crypto.randomInt(1, common.mustSucceed());
+  crypto.randomInt(0, 1, common.mustSucceed());
   for (const arg of [[0], [1, 1], [3, 2], [-5, -5], [11, -10]]) {
     assert.throws(() => crypto.randomInt(...arg, common.mustNotCall()), {
       code: 'ERR_OUT_OF_RANGE',
@@ -466,8 +458,8 @@ assert.throws(
   }
 
   const MAX_RANGE = 0xFFFF_FFFF_FFFF;
-  crypto.randomInt(MAX_RANGE, common.mustCall());
-  crypto.randomInt(1, MAX_RANGE + 1, common.mustCall());
+  crypto.randomInt(MAX_RANGE, common.mustSucceed());
+  crypto.randomInt(1, MAX_RANGE + 1, common.mustSucceed());
   assert.throws(
     () => crypto.randomInt(1, MAX_RANGE + 2, common.mustNotCall()),
     {
diff --git a/test/parallel/test-crypto-randomuuid.js b/test/parallel/test-crypto-randomuuid.js
new file mode 100644
index 0000000000000000000000000000000000000000..23e97fb8cf49a1c13022838e4bf8aaeaf990dd87
--- /dev/null
+++ b/test/parallel/test-crypto-randomuuid.js
@@ -0,0 +1,58 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const {
+  randomUUID,
+} = require('crypto');
+
+const last = new Set([
+  '00000000-0000-0000-0000-000000000000',
+]);
+
+function testMatch(uuid) {
+  assert.match(
+    uuid,
+    /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+}
+
+// Generate a number of UUID's to make sure we're
+// not just generating the same value over and over
+// and to make sure the batching changes the random
+// bytes.
+for (let n = 0; n < 130; n++) {
+  const uuid = randomUUID();
+  assert(!last.has(uuid));
+  last.add(uuid);
+  assert.strictEqual(typeof uuid, 'string');
+  assert.strictEqual(uuid.length, 36);
+  testMatch(uuid);
+
+  // Check that version 4 identifier was populated.
+  assert.strictEqual(
+    Buffer.from(uuid.substr(14, 2), 'hex')[0] & 0x40, 0x40);
+
+  // Check that clock_seq_hi_and_reserved was populated with reserved bits.
+  assert.strictEqual(
+    Buffer.from(uuid.substr(19, 2), 'hex')[0] & 0b1100_0000, 0b1000_0000);
+}
+
+// Test non-buffered UUID's
+{
+  testMatch(randomUUID({ disableEntropyCache: true }));
+  testMatch(randomUUID({ disableEntropyCache: true }));
+  testMatch(randomUUID({ disableEntropyCache: true }));
+  testMatch(randomUUID({ disableEntropyCache: true }));
+
+  assert.throws(() => randomUUID(1), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+
+  assert.throws(() => randomUUID({ disableEntropyCache: '' }), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+}
diff --git a/test/parallel/test-crypto-scrypt.js b/test/parallel/test-crypto-scrypt.js
index ff074bba06d324cdda851389ec805a88fd4c1258..7c013a28715cafb80e3098ac50df78c446e56317 100644
--- a/test/parallel/test-crypto-scrypt.js
+++ b/test/parallel/test-crypto-scrypt.js
@@ -99,7 +99,7 @@ const bad = [
   { N: 3, p: 1, r: 1 },         // Not power of 2.
   { N: 1, cost: 1 },            // Both N and cost
   { p: 1, parallelization: 1 }, // Both p and parallelization
-  { r: 1, blockSize: 1 }        // Both r and blocksize
+  { r: 1, blockSize: 1 },        // Both r and blocksize
 ];
 
 // Test vectors where 128*N*r exceeds maxmem.
@@ -149,8 +149,7 @@ for (const options of good) {
   const { pass, salt, keylen, expected } = options;
   const actual = crypto.scryptSync(pass, salt, keylen, options);
   assert.strictEqual(actual.toString('hex'), expected);
-  crypto.scrypt(pass, salt, keylen, options, common.mustCall((err, actual) => {
-    assert.ifError(err);
+  crypto.scrypt(pass, salt, keylen, options, common.mustSucceed((actual) => {
     assert.strictEqual(actual.toString('hex'), expected);
   }));
 }
@@ -184,8 +183,7 @@ for (const options of toobig) {
   const expected = crypto.scryptSync('pass', 'salt', 1, defaults);
   const actual = crypto.scryptSync('pass', 'salt', 1);
   assert.deepStrictEqual(actual.toString('hex'), expected.toString('hex'));
-  crypto.scrypt('pass', 'salt', 1, common.mustCall((err, actual) => {
-    assert.ifError(err);
+  crypto.scrypt('pass', 'salt', 1, common.mustSucceed((actual) => {
     assert.deepStrictEqual(actual.toString('hex'), expected.toString('hex'));
   }));
 }
@@ -200,8 +198,7 @@ for (const options of toobig) {
   const actual = crypto.scryptSync('pass', 'salt', 1);
   assert.deepStrictEqual(actual, expected.toString(testEncoding));
 
-  crypto.scrypt('pass', 'salt', 1, common.mustCall((err, actual) => {
-    assert.ifError(err);
+  crypto.scrypt('pass', 'salt', 1, common.mustSucceed((actual) => {
     assert.deepStrictEqual(actual, expected.toString(testEncoding));
   }));
 
@@ -225,8 +222,7 @@ for (const { args, expected } of badargs) {
   // Values for maxmem that do not fit in 32 bits but that are still safe
   // integers should be allowed.
   crypto.scrypt('', '', 4, { maxmem: 2 ** 52 },
-                common.mustCall((err, actual) => {
-                  assert.ifError(err);
+                common.mustSucceed((actual) => {
                   assert.strictEqual(actual.toString('hex'), 'd72c87d0');
                 }));
 
@@ -267,6 +263,6 @@ for (const { args, expected } of badargs) {
   [
     ['N', 16384], ['cost', 16384],
     ['r', 8], ['blockSize', 8],
-    ['p', 1], ['parallelization', 1]
+    ['p', 1], ['parallelization', 1],
   ].forEach((arg) => testParameter(...arg));
 }
diff --git a/test/parallel/test-crypto-sign-verify.js b/test/parallel/test-crypto-sign-verify.js
index ff410dcf00fa6a8d27733422161fe7a99d0b296b..02bb169a4ddf2780702d382f365d4bd95c96815d 100644
--- a/test/parallel/test-crypto-sign-verify.js
+++ b/test/parallel/test-crypto-sign-verify.js
@@ -170,14 +170,14 @@ assert.throws(
       getEffectiveSaltLength(crypto.constants.RSA_PSS_SALTLEN_DIGEST),
       crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN,
       getEffectiveSaltLength(crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN),
-      0, 16, 32, 64, 128
+      0, 16, 32, 64, 128,
     ];
 
     const verifySaltLengths = [
       crypto.constants.RSA_PSS_SALTLEN_DIGEST,
       getEffectiveSaltLength(crypto.constants.RSA_PSS_SALTLEN_DIGEST),
       getEffectiveSaltLength(crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN),
-      0, 16, 32, 64, 128
+      0, 16, 32, 64, 128,
     ];
     const errMessage = /^Error:.*data too large for key size$/;
 
@@ -383,7 +383,7 @@ assert.throws(
   });
 
   [
-    Uint8Array, Uint16Array, Uint32Array, Float32Array, Float64Array
+    Uint8Array, Uint16Array, Uint32Array, Float32Array, Float64Array,
   ].forEach((clazz) => {
     // These should all just work
     sign.update(new clazz());
@@ -436,7 +436,7 @@ assert.throws(
   { private: fixtures.readKey('rsa_private_2048.pem', 'ascii'),
     public: fixtures.readKey('rsa_public_2048.pem', 'ascii'),
     algo: 'sha1',
-    sigLen: 256 }
+    sigLen: 256 },
 ].forEach((pair) => {
   const algo = pair.algo;
 
@@ -472,7 +472,7 @@ assert.throws(
   }
 
   [
-    Uint8Array, Uint16Array, Uint32Array, Float32Array, Float64Array
+    Uint8Array, Uint16Array, Uint32Array, Float32Array, Float64Array,
   ].forEach((clazz) => {
     const data = new clazz();
     const sig = crypto.sign(algo, data, pair.private);
@@ -523,7 +523,7 @@ assert.throws(
     [
       crypto.createSign('sha1').update(data).sign(privKey),
       crypto.sign('sha1', data, privKey),
-      crypto.sign('sha1', data, { key: privKey, dsaEncoding: 'der' })
+      crypto.sign('sha1', data, { key: privKey, dsaEncoding: 'der' }),
     ].forEach((sig) => {
       // Signature length variability due to DER encoding
       assert(sig.length >= length + 4 && sig.length <= length + 8);
diff --git a/test/parallel/test-crypto-update-encoding.js b/test/parallel/test-crypto-update-encoding.js
new file mode 100644
index 0000000000000000000000000000000000000000..e1e6d029aa5e30e42dd4b8b056cf1ce9d08914ea
--- /dev/null
+++ b/test/parallel/test-crypto-update-encoding.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const crypto = require('crypto');
+
+const zeros = Buffer.alloc;
+const key = zeros(16);
+const iv = zeros(16);
+
+const cipher = () => crypto.createCipheriv('aes-128-cbc', key, iv);
+const decipher = () => crypto.createDecipheriv('aes-128-cbc', key, iv);
+const hash = () => crypto.createSign('sha256');
+const hmac = () => crypto.createHmac('sha256', key);
+const sign = () => crypto.createSign('sha256');
+const verify = () => crypto.createVerify('sha256');
+
+for (const f of [cipher, decipher, hash, hmac, sign, verify])
+  for (const n of [15, 16])
+    f().update(zeros(n), 'hex');  // Should ignore inputEncoding.
diff --git a/test/parallel/test-crypto-worker-thread.js b/test/parallel/test-crypto-worker-thread.js
index c3b978ceb3d37c862650d9a4f065bc22ff5b9e9f..fb20eaaffbc28d5f01da28461d382fc0636a4eca 100644
--- a/test/parallel/test-crypto-worker-thread.js
+++ b/test/parallel/test-crypto-worker-thread.js
@@ -4,8 +4,7 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 
 // Issue https://github.com/nodejs/node/issues/35263
-/* Description: test for checking keyobject passed to worker thread
- does not crash */
+// Description: Test that passing keyobject to worker thread does not crash.
 const { createSecretKey } = require('crypto');
 
 const { Worker, isMainThread, workerData } = require('worker_threads');
diff --git a/test/parallel/test-crypto.js b/test/parallel/test-crypto.js
index 7216523819364cd00ebd23cd0999cd5fc194f51c..6b65af5a39aaea23c7bd92e1f59dabb296f1b4fb 100644
--- a/test/parallel/test-crypto.js
+++ b/test/parallel/test-crypto.js
@@ -27,7 +27,7 @@ if (!common.hasCrypto)
 
 common.expectWarning({
   DeprecationWarning: [
-    ['crypto.createCipher is deprecated.', 'DEP0106']
+    ['crypto.createCipher is deprecated.', 'DEP0106'],
   ]
 });
 
@@ -161,6 +161,13 @@ testImmutability(tls.getCiphers);
 testImmutability(crypto.getHashes);
 testImmutability(crypto.getCurves);
 
+const encodingError = {
+  code: 'ERR_INVALID_ARG_VALUE',
+  name: 'TypeError',
+  message: "The argument 'encoding' is invalid for data of length 1." +
+           " Received 'hex'",
+};
+
 // Regression tests for https://github.com/nodejs/node-v0.x-archive/pull/5725:
 // hex input that's not a power of two should throw, not assert in C++ land.
 ['createCipher', 'createDecipher'].forEach((funcName) => {
@@ -173,17 +180,26 @@ testImmutability(crypto.getCurves);
                error.name === 'Error' &&
                /^Error: not supported in FIPS mode$/.test(error);
       }
-      assert.throws(() => { throw error; }, /^TypeError: Bad input string$/);
+      assert.throws(() => { throw error; }, encodingError);
       return true;
     }
   );
 });
 
+assert.throws(
+  () => crypto.createHash('sha1').update('0', 'hex'),
+  (error) => {
+    assert.ok(!('opensslErrorStack' in error));
+    assert.throws(() => { throw error; }, encodingError);
+    return true;
+  }
+);
+
 assert.throws(
   () => crypto.createHmac('sha256', 'a secret').update('0', 'hex'),
   (error) => {
     assert.ok(!('opensslErrorStack' in error));
-    assert.throws(() => { throw error; }, /^TypeError: Bad input string$/);
+    assert.throws(() => { throw error; }, encodingError);
     return true;
   }
 );
@@ -196,7 +212,7 @@ assert.throws(() => {
     'eKN7LggbF3Dk5wIQN6SL+fQ5H/+7NgARsVBp0QIRANxYRukavs4QvuyNhMx+vrkCEQCbf6j/',
     'Ig6/HueCK/0Jkmp+',
     '-----END RSA PRIVATE KEY-----',
-    ''
+    '',
   ].join('\n');
   crypto.createSign('SHA256').update('test').sign(priv);
 }, (err) => {
diff --git a/test/parallel/test-debug-usage.js b/test/parallel/test-debug-usage.js
index eb9594f236b35c1870d8c964682dd3f66addf2b0..fcf2d8edb944e052840bc9ac0ae55d6f51f59fa6 100644
--- a/test/parallel/test-debug-usage.js
+++ b/test/parallel/test-debug-usage.js
@@ -11,7 +11,7 @@ child.stderr.setEncoding('utf8');
 
 const expectedLines = [
   /^\(node:\d+\) \[DEP0068\] DeprecationWarning:/,
-  /Usage: .*node.* debug script\.js\r?\n       .*node.* debug <host>:<port>\r?\n       .*node.* debug -p <pid>\r?\n$/,
+  /Usage: .*node.* debug script\.js\r?\n       .*node.* debug <host>:<port>\r?\n       .*node.* debug --port=<port>\r?\n       .*node.* debug -p <pid>\r?\n$/,
 ];
 
 let actualUsageMessage = '';
diff --git a/deps/node-inspect/test/cli/address.test.js b/test/parallel/test-debugger-address.js
similarity index 68%
rename from deps/node-inspect/test/cli/address.test.js
rename to test/parallel/test-debugger-address.js
index 1dbe4f37b421754fe9edc6603c25bb408d222aef..95dd1c6e3f82835d5ccaf65544d654b71efaa392 100644
--- a/deps/node-inspect/test/cli/address.test.js
+++ b/test/parallel/test-debugger-address.js
@@ -1,9 +1,13 @@
 'use strict';
-const { spawn } = require('child_process');
-const Path = require('path');
-const { test } = require('tap');
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-const startCLI = require('./start-cli');
+const assert = require('assert');
+const { spawn } = require('child_process');
 
 // NOTE(oyyd): We might want to import this regexp from "lib/_inspect.js"?
 const kDebuggerMsgReg = /Debugger listening on ws:\/\/\[?(.+?)\]?:(\d+)\//;
@@ -12,11 +16,13 @@ function launchTarget(...args) {
   const childProc = spawn(process.execPath, args);
   return new Promise((resolve, reject) => {
     const onExit = () => {
-      reject(new Error('Child process exits unexpectly'));
+      reject(new Error('Child process exits unexpectedly'));
     };
     childProc.on('exit', onExit);
     childProc.stderr.setEncoding('utf8');
-    childProc.stderr.on('data', (data) => {
+    let data = '';
+    childProc.stderr.on('data', (chunk) => {
+      data += chunk;
       const ret = kDebuggerMsgReg.exec(data);
       childProc.removeListener('exit', onExit);
       if (ret) {
@@ -30,12 +36,8 @@ function launchTarget(...args) {
   });
 }
 
-// process.debugPort is our proxy for "the version of node used to run this
-// test suite doesn't support SIGUSR1 for enabling --inspect for a process".
-const defaultsToOldProtocol = process.debugPort === 5858;
-
-test('examples/alive.js', { skip: defaultsToOldProtocol }, (t) => {
-  const script = Path.join('examples', 'alive.js');
+{
+  const script = fixtures.path('debugger/alive.js');
   let cli = null;
   let target = null;
 
@@ -48,7 +50,7 @@ test('examples/alive.js', { skip: defaultsToOldProtocol }, (t) => {
       target.kill();
       target = null;
     }
-    if (error) throw error;
+    assert.ifError(error);
   }
 
   return launchTarget('--inspect=0', script)
@@ -61,11 +63,11 @@ test('examples/alive.js', { skip: defaultsToOldProtocol }, (t) => {
     .then(() => cli.waitFor(/break/))
     .then(() => cli.waitForPrompt())
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
-        '> 3   ++x;',
+        /> 3   \+\+x;/,
         'marks the 3rd line');
     })
     .then(() => cleanup())
     .then(null, cleanup);
-});
+}
diff --git a/test/parallel/test-debugger-pid.js b/test/parallel/test-debugger-pid.js
index f269ff310b145c0add03e1ae40ba08969e4bf315..00f14b2cf5bb61511efc08d7366694cf1034b38c 100644
--- a/test/parallel/test-debugger-pid.js
+++ b/test/parallel/test-debugger-pid.js
@@ -29,9 +29,12 @@ interfacer.on('line', function(line) {
     case 1:
       expected =
         new RegExp(`^\\(node:${pid}\\) \\[DEP0068\\] DeprecationWarning: `);
-      assert.ok(expected.test(line), `expected regexp match for ${line}`);
+      assert.match(line, expected);
       break;
     case 2:
+      assert.match(line, /Use `node --trace-deprecation \.\.\.` to show where /);
+      break;
+    case 3:
       // Doesn't currently work on Windows.
       if (!common.isWindows) {
         expected = "Target process: 655555 doesn't exist.";
@@ -48,6 +51,6 @@ interfacer.on('line', function(line) {
 interfacer.on('exit', function(code, signal) {
   assert.strictEqual(code, 1, `Got unexpected code: ${code}`);
   if (!common.isWindows) {
-    assert.strictEqual(lineCount, 2);
+    assert.strictEqual(lineCount, 3);
   }
 });
diff --git a/deps/node-inspect/test/cli/invalid-args.test.js b/test/parallel/test-debugger-unavailable-port.js
similarity index 36%
rename from deps/node-inspect/test/cli/invalid-args.test.js
rename to test/parallel/test-debugger-unavailable-port.js
index 86428a3ec270302fdf1be3c2a4c9058217bbefba..e2920312ffc21c8dc4b49f3feb826c090e6f9de2 100644
--- a/deps/node-inspect/test/cli/invalid-args.test.js
+++ b/test/parallel/test-debugger-unavailable-port.js
@@ -1,33 +1,16 @@
 'use strict';
-const Path = require('path');
-const { createServer } = require('net');
-
-const { test } = require('tap');
+const common = require('../common');
 
-const startCLI = require('./start-cli');
+common.skipIfInspectorDisabled();
 
-test('launch CLI w/o args', (t) => {
-  const cli = startCLI([]);
-  return cli.quit()
-    .then((code) => {
-      t.equal(code, 1, 'exits with non-zero exit code');
-      t.match(cli.output, /^Usage:/, 'Prints usage info');
-    });
-});
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-test('launch w/ invalid host:port', (t) => {
-  const cli = startCLI(['localhost:914']);
-  return cli.quit()
-    .then((code) => {
-      t.match(
-        cli.output,
-        'failed to connect',
-        'Tells the user that the connection failed');
-      t.equal(code, 1, 'exits with non-zero exit code');
-    });
-});
+const assert = require('assert');
+const { createServer } = require('net');
 
-test('launch w/ unavailable port', async(t) => {
+// Launch w/ unavailable port.
+(async () => {
   const blocker = createServer((socket) => socket.end());
   const port = await new Promise((resolve, reject) => {
     blocker.on('error', reject);
@@ -35,20 +18,19 @@ test('launch w/ unavailable port', async(t) => {
   });
 
   try {
-    const script = Path.join('examples', 'three-lines.js');
+    const script = fixtures.path('debugger', 'three-lines.js');
     const cli = startCLI([`--port=${port}`, script]);
     const code = await cli.quit();
 
-    t.notMatch(
+    assert.doesNotMatch(
       cli.output,
-      'report this bug',
+      /report this bug/,
       'Omits message about reporting this as a bug');
-    t.match(
-      cli.output,
-      `waiting for 127.0.0.1:${port} to be free`,
+    assert.ok(
+      cli.output.includes(`waiting for 127.0.0.1:${port} to be free`),
       'Tells the user that the port wasn\'t available');
-    t.equal(code, 1, 'exits with non-zero exit code');
+    assert.strictEqual(code, 1);
   } finally {
     blocker.close();
   }
-});
+})().then(common.mustCall());
diff --git a/test/parallel/test-debugger-websocket-secret-mismatch.js b/test/parallel/test-debugger-websocket-secret-mismatch.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b7b50c518f186cbb49d018c65afb93d428efae7
--- /dev/null
+++ b/test/parallel/test-debugger-websocket-secret-mismatch.js
@@ -0,0 +1,54 @@
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const childProcess = require('child_process');
+const http = require('http');
+
+let port;
+
+const server = http.createServer(common.mustCall((req, res) => {
+  if (req.url.startsWith('/json')) {
+    res.writeHead(200);
+    res.end(`[ {
+      "description": "",
+      "devtoolsFrontendUrl": "/devtools/inspector.html?ws=localhost:${port}/devtools/page/DAB7FB6187B554E10B0BD18821265734",
+      "cid": "DAB7FB6187B554E10B0BD18821265734",
+      "title": "Fhqwhgads",
+      "type": "page",
+      "url": "https://www.example.com/",
+      "webSocketDebuggerUrl": "ws://localhost:${port}/devtools/page/DAB7FB6187B554E10B0BD18821265734"
+    } ]`);
+  } else {
+    res.setHeader('Upgrade', 'websocket');
+    res.setHeader('Connection', 'Upgrade');
+    res.setHeader('Sec-WebSocket-Accept', 'fhqwhgads');
+    res.setHeader('Sec-WebSocket-Protocol', 'chat');
+    res.writeHead(101);
+    res.end();
+  }
+}, 2)).listen(0, common.mustCall(() => {
+  port = server.address().port;
+  const proc =
+    childProcess.spawn(process.execPath, ['inspect', `localhost:${port}`]);
+
+  let stdout = '';
+  proc.stdout.on('data', (data) => {
+    stdout += data.toString();
+    assert.doesNotMatch(stdout, /\bok\b/);
+  });
+
+  let stderr = '';
+  proc.stderr.on('data', (data) => {
+    stderr += data.toString();
+  });
+
+  proc.on('exit', common.mustCall((code, signal) => {
+    assert.match(stderr, /\bWebSocket secret mismatch\b/);
+    assert.notStrictEqual(code, 0);
+    assert.strictEqual(signal, null);
+    server.close();
+  }));
+}));
diff --git a/test/parallel/test-dgram-close-signal.js b/test/parallel/test-dgram-close-signal.js
new file mode 100644
index 0000000000000000000000000000000000000000..680d795a22e22d0038eae5ec0bd31bd72a6cfbb0
--- /dev/null
+++ b/test/parallel/test-dgram-close-signal.js
@@ -0,0 +1,34 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+{
+  // Test bad signal.
+  assert.throws(
+    () => dgram.createSocket({ type: 'udp4', signal: {} }),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
+}
+
+{
+  // Test close.
+  const controller = new AbortController();
+  const { signal } = controller;
+  const server = dgram.createSocket({ type: 'udp4', signal });
+  server.on('close', common.mustCall());
+  controller.abort();
+}
+
+{
+  // Test close with pre-aborted signal.
+  const controller = new AbortController();
+  controller.abort();
+  const { signal } = controller;
+  const server = dgram.createSocket({ type: 'udp4', signal });
+  server.on('close', common.mustCall());
+}
diff --git a/test/parallel/test-dgram-connect-send-callback-buffer-length.js b/test/parallel/test-dgram-connect-send-callback-buffer-length.js
index 08c220682e79afd3e826cebb82ee9c3e738de5d1..723b2738e2ef1d5c47d92cca8b7a33041054fff3 100644
--- a/test/parallel/test-dgram-connect-send-callback-buffer-length.js
+++ b/test/parallel/test-dgram-connect-send-callback-buffer-length.js
@@ -10,8 +10,7 @@ const buf = Buffer.allocUnsafe(256);
 const offset = 20;
 const len = buf.length - offset;
 
-const messageSent = common.mustCall(function messageSent(err, bytes) {
-  assert.ifError(err);
+const messageSent = common.mustSucceed(function messageSent(bytes) {
   assert.notStrictEqual(bytes, buf.length);
   assert.strictEqual(bytes, buf.length - offset);
   client.close();
diff --git a/test/parallel/test-dgram-connect-send-callback-buffer.js b/test/parallel/test-dgram-connect-send-callback-buffer.js
index ad756b03effa6f2a170cefcdad033dc72ddc0099..d6ef1f510cce217539cf1610aa55e8f461658f08 100644
--- a/test/parallel/test-dgram-connect-send-callback-buffer.js
+++ b/test/parallel/test-dgram-connect-send-callback-buffer.js
@@ -8,8 +8,7 @@ const client = dgram.createSocket('udp4');
 
 const buf = Buffer.allocUnsafe(256);
 
-const onMessage = common.mustCall(function(err, bytes) {
-  assert.ifError(err);
+const onMessage = common.mustSucceed((bytes) => {
   assert.strictEqual(bytes, buf.length);
   client.close();
 });
diff --git a/test/parallel/test-dgram-connect-send-empty-buffer.js b/test/parallel/test-dgram-connect-send-empty-buffer.js
index c41ce8309f59bdd71b2a75340edb07c68c5aa120..bce4c82e5c876eb8c4d27b20f15fb29b1c651988 100644
--- a/test/parallel/test-dgram-connect-send-empty-buffer.js
+++ b/test/parallel/test-dgram-connect-send-empty-buffer.js
@@ -10,7 +10,7 @@ client.bind(0, common.mustCall(function() {
   const port = this.address().port;
   client.connect(port, common.mustCall(() => {
     const buf = Buffer.alloc(0);
-    client.send(buf, 0, 0, common.mustCall());
+    client.send(buf, 0, 0, common.mustSucceed());
   }));
 
   client.on('message', common.mustCall((buffer) => {
diff --git a/test/parallel/test-dgram-connect-send-multi-buffer-copy.js b/test/parallel/test-dgram-connect-send-multi-buffer-copy.js
index ae8de70a6b47990cd0fe9bc347dd4728517e3a8b..0859a0cf86f465f5edd0e9b1e8c06d0d2e4554d7 100644
--- a/test/parallel/test-dgram-connect-send-multi-buffer-copy.js
+++ b/test/parallel/test-dgram-connect-send-multi-buffer-copy.js
@@ -6,8 +6,7 @@ const dgram = require('dgram');
 
 const client = dgram.createSocket('udp4');
 
-const onMessage = common.mustCall(common.mustCall((err, bytes) => {
-  assert.ifError(err);
+const onMessage = common.mustCall(common.mustSucceed((bytes) => {
   assert.strictEqual(bytes, buf1.length + buf2.length);
 }));
 
diff --git a/test/parallel/test-dgram-createSocket-type.js b/test/parallel/test-dgram-createSocket-type.js
index ae141d3c38323637bdeaa2718e345cdcf62fbb60..19bbd6c1b2b088c15d8e1ee4ff80bffdf706440e 100644
--- a/test/parallel/test-dgram-createSocket-type.js
+++ b/test/parallel/test-dgram-createSocket-type.js
@@ -11,13 +11,13 @@ const invalidTypes = [
   true,
   false,
   null,
-  undefined
+  undefined,
 ];
 const validTypes = [
   'udp4',
   'udp6',
   { type: 'udp4' },
-  { type: 'udp6' }
+  { type: 'udp6' },
 ];
 const errMessage = /^Bad socket type specified\. Valid types are: udp4, udp6$/;
 
diff --git a/test/parallel/test-dgram-deprecation-error.js b/test/parallel/test-dgram-deprecation-error.js
index d244940b64d79349e97c103d45572a2fbf52ccaa..c544a917b02b8341f38b491a825d30f91eea8386 100644
--- a/test/parallel/test-dgram-deprecation-error.js
+++ b/test/parallel/test-dgram-deprecation-error.js
@@ -14,12 +14,12 @@ const propertiesToTest = [
   '_receiving',
   '_bindState',
   '_queue',
-  '_reuseAddr'
+  '_reuseAddr',
 ];
 
 const methodsToTest = [
   '_healthCheck',
-  '_stopReceiving'
+  '_stopReceiving',
 ];
 
 const propertyCases = propertiesToTest.map((propName) => {
@@ -31,7 +31,7 @@ const propertyCases = propertiesToTest.map((propName) => {
         `Socket.prototype.${propName} is deprecated`,
         'DEP0112'
       );
-      sock[propName];
+      sock[propName]; // eslint-disable-line no-unused-expressions
     },
     () => {
       // Test property setter
@@ -41,7 +41,7 @@ const propertyCases = propertiesToTest.map((propName) => {
         'DEP0112'
       );
       sock[propName] = null;
-    }
+    },
   ];
 });
 
diff --git a/test/parallel/test-dgram-send-address-types.js b/test/parallel/test-dgram-send-address-types.js
index d64558bac4424e3aa89177120cf39146a25c835f..a88ef088dcf8a96af6bb3f9b42b61df6f940977d 100644
--- a/test/parallel/test-dgram-send-address-types.js
+++ b/test/parallel/test-dgram-send-address-types.js
@@ -5,8 +5,7 @@ const dgram = require('dgram');
 
 const buf = Buffer.from('test');
 
-const onMessage = common.mustCall((err, bytes) => {
-  assert.ifError(err);
+const onMessage = common.mustSucceed((bytes) => {
   assert.strictEqual(bytes, buf.length);
 }, 6);
 
diff --git a/test/parallel/test-dgram-send-callback-buffer-empty-address.js b/test/parallel/test-dgram-send-callback-buffer-empty-address.js
index 5b3b1c41a1917c2d259a00d70e2ca17676d0734b..f6254ec43e90d640742af22d69083a89cc6b90b2 100644
--- a/test/parallel/test-dgram-send-callback-buffer-empty-address.js
+++ b/test/parallel/test-dgram-send-callback-buffer-empty-address.js
@@ -8,8 +8,7 @@ const client = dgram.createSocket('udp4');
 
 const buf = Buffer.alloc(256, 'x');
 
-const onMessage = common.mustCall(function(err, bytes) {
-  assert.ifError(err);
+const onMessage = common.mustSucceed((bytes) => {
   assert.strictEqual(bytes, buf.length);
   client.close();
 });
diff --git a/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js b/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js
index 544f66702494daaa047f121853f9bc5790505aed..a95018d14b220a066c6b9e03fd255e65766dcc63 100644
--- a/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js
+++ b/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js
@@ -10,8 +10,7 @@ const buf = Buffer.alloc(256, 'x');
 const offset = 20;
 const len = buf.length - offset;
 
-const onMessage = common.mustCall(function messageSent(err, bytes) {
-  assert.ifError(err);
+const onMessage = common.mustSucceed(function messageSent(bytes) {
   assert.notStrictEqual(bytes, buf.length);
   assert.strictEqual(bytes, buf.length - offset);
   client.close();
diff --git a/test/parallel/test-dgram-send-callback-buffer-length.js b/test/parallel/test-dgram-send-callback-buffer-length.js
index bf1b351df33e7bbb489979d77baf2132f4a52d03..f570ecb20db71027412f684b38c5d011f1c09956 100644
--- a/test/parallel/test-dgram-send-callback-buffer-length.js
+++ b/test/parallel/test-dgram-send-callback-buffer-length.js
@@ -31,8 +31,7 @@ const buf = Buffer.allocUnsafe(256);
 const offset = 20;
 const len = buf.length - offset;
 
-const messageSent = common.mustCall(function messageSent(err, bytes) {
-  assert.ifError(err);
+const messageSent = common.mustSucceed(function messageSent(bytes) {
   assert.notStrictEqual(bytes, buf.length);
   assert.strictEqual(bytes, buf.length - offset);
   client.close();
diff --git a/test/parallel/test-dgram-send-callback-buffer.js b/test/parallel/test-dgram-send-callback-buffer.js
index c174e585d6128283b1b8f80c34cff070ac2a601f..11f8208de912bba43c14b3d41bf1f3483110dd09 100644
--- a/test/parallel/test-dgram-send-callback-buffer.js
+++ b/test/parallel/test-dgram-send-callback-buffer.js
@@ -8,8 +8,7 @@ const client = dgram.createSocket('udp4');
 
 const buf = Buffer.allocUnsafe(256);
 
-const onMessage = common.mustCall(function(err, bytes) {
-  assert.ifError(err);
+const onMessage = common.mustSucceed((bytes) => {
   assert.strictEqual(bytes, buf.length);
   client.close();
 });
diff --git a/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js b/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js
index cef71083c71a369280ad5497624f3a1866bd7388..37e9e04c4462cfe43f72efeb0167f73cb31029d5 100644
--- a/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js
+++ b/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js
@@ -6,8 +6,7 @@ const dgram = require('dgram');
 
 const client = dgram.createSocket('udp4');
 
-const messageSent = common.mustCall(function messageSent(err, bytes) {
-  assert.ifError(err);
+const messageSent = common.mustSucceed(function messageSent(bytes) {
   assert.strictEqual(bytes, buf1.length + buf2.length);
 });
 
diff --git a/test/parallel/test-dgram-send-error.js b/test/parallel/test-dgram-send-error.js
index f6d37f2c8181124626b074064c89b12ddb4ef333..6aa326c8ec55ead64fd8425c87adde2ebad8ecce 100644
--- a/test/parallel/test-dgram-send-error.js
+++ b/test/parallel/test-dgram-send-error.js
@@ -5,6 +5,7 @@ const assert = require('assert');
 const dgram = require('dgram');
 const { internalBinding } = require('internal/test/binding');
 const { UV_UNKNOWN } = internalBinding('uv');
+const { getSystemErrorName } = require('util');
 const { kStateSymbol } = require('internal/dgram');
 const mockError = new Error('mock DNS error');
 
@@ -50,7 +51,7 @@ getSocket((socket) => {
     const callback = common.mustCall((err) => {
       socket.close();
       assert.strictEqual(err.code, 'UNKNOWN');
-      assert.strictEqual(err.errno, 'UNKNOWN');
+      assert.strictEqual(getSystemErrorName(err.errno), 'UNKNOWN');
       assert.strictEqual(err.syscall, 'send');
       assert.strictEqual(err.address, common.localhostIPv4);
       assert.strictEqual(err.port, port);
diff --git a/test/parallel/test-diagnostics-channel-has-subscribers.js b/test/parallel/test-diagnostics-channel-has-subscribers.js
new file mode 100644
index 0000000000000000000000000000000000000000..de37267555089e9a268759a889324af49496ca8b
--- /dev/null
+++ b/test/parallel/test-diagnostics-channel-has-subscribers.js
@@ -0,0 +1,10 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { channel, hasSubscribers } = require('diagnostics_channel');
+
+const dc = channel('test');
+assert.ok(!hasSubscribers('test'));
+
+dc.subscribe(() => {});
+assert.ok(hasSubscribers('test'));
diff --git a/test/parallel/test-diagnostics-channel-http-server-start.js b/test/parallel/test-diagnostics-channel-http-server-start.js
new file mode 100644
index 0000000000000000000000000000000000000000..9a8136d4cc5839c79a2467c338d311791fd40eb1
--- /dev/null
+++ b/test/parallel/test-diagnostics-channel-http-server-start.js
@@ -0,0 +1,65 @@
+'use strict';
+
+const common = require('../common');
+const { AsyncLocalStorage } = require('async_hooks');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+const http = require('http');
+
+const incomingStartChannel = dc.channel('http.server.request.start');
+const outgoingFinishChannel = dc.channel('http.server.response.finish');
+
+const als = new AsyncLocalStorage();
+let context;
+
+// Bind requests to an AsyncLocalStorage context
+incomingStartChannel.subscribe(common.mustCall((message) => {
+  als.enterWith(message);
+  context = message;
+}));
+
+// When the request ends, verify the context has been maintained
+// and that the messages contain the expected data
+outgoingFinishChannel.subscribe(common.mustCall((message) => {
+  const data = {
+    request,
+    response,
+    server,
+    socket: request.socket
+  };
+
+  // Context is maintained
+  compare(als.getStore(), context);
+
+  compare(context, data);
+  compare(message, data);
+}));
+
+let request;
+let response;
+
+const server = http.createServer(common.mustCall((req, res) => {
+  request = req;
+  response = res;
+
+  setTimeout(() => {
+    res.end('done');
+  }, 1);
+}));
+
+server.listen(() => {
+  const { port } = server.address();
+  http.get(`http://localhost:${port}`, (res) => {
+    res.resume();
+    res.on('end', () => {
+      server.close();
+    });
+  });
+});
+
+function compare(a, b) {
+  assert.strictEqual(a.request, b.request);
+  assert.strictEqual(a.response, b.response);
+  assert.strictEqual(a.socket, b.socket);
+  assert.strictEqual(a.server, b.server);
+}
diff --git a/test/parallel/test-diagnostics-channel-object-channel-pub-sub.js b/test/parallel/test-diagnostics-channel-object-channel-pub-sub.js
new file mode 100644
index 0000000000000000000000000000000000000000..cbc5b4d2e9a9535f29b9c5f604bce86026e8c940
--- /dev/null
+++ b/test/parallel/test-diagnostics-channel-object-channel-pub-sub.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+const { Channel } = dc;
+
+const input = {
+  foo: 'bar'
+};
+
+// Should not have named channel
+assert.ok(!dc.hasSubscribers('test'));
+
+// Individual channel objects can be created to avoid future lookups
+const channel = dc.channel('test');
+assert.ok(channel instanceof Channel);
+
+// No subscribers yet, should not publish
+assert.ok(!channel.hasSubscribers);
+
+const subscriber = common.mustCall((message, name) => {
+  assert.strictEqual(name, channel.name);
+  assert.deepStrictEqual(message, input);
+});
+
+// Now there's a subscriber, should publish
+channel.subscribe(subscriber);
+assert.ok(channel.hasSubscribers);
+
+// The ActiveChannel prototype swap should not fail instanceof
+assert.ok(channel instanceof Channel);
+
+// Should trigger the subscriber once
+channel.publish(input);
+
+// Should not publish after subscriber is unsubscribed
+channel.unsubscribe(subscriber);
+assert.ok(!channel.hasSubscribers);
+
+assert.throws(() => {
+  channel.subscribe(null);
+}, { code: 'ERR_INVALID_ARG_TYPE' });
diff --git a/test/parallel/test-diagnostics-channel-safe-subscriber-errors.js b/test/parallel/test-diagnostics-channel-safe-subscriber-errors.js
new file mode 100644
index 0000000000000000000000000000000000000000..b0c5ab2480e374ca6ecc4473839978c1deb53a78
--- /dev/null
+++ b/test/parallel/test-diagnostics-channel-safe-subscriber-errors.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const input = {
+  foo: 'bar'
+};
+
+const channel = dc.channel('fail');
+
+const error = new Error('nope');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err, error);
+}));
+
+channel.subscribe(common.mustCall((message, name) => {
+  throw error;
+}));
+
+// The failing subscriber should not stop subsequent subscribers from running
+channel.subscribe(common.mustCall());
+
+// Publish should continue without throwing
+const fn = common.mustCall();
+channel.publish(input);
+fn();
diff --git a/test/parallel/test-diagnostics-channel-symbol-named.js b/test/parallel/test-diagnostics-channel-symbol-named.js
new file mode 100644
index 0000000000000000000000000000000000000000..96fe0fa53596e2fa00084196fc102f1f4da48bb7
--- /dev/null
+++ b/test/parallel/test-diagnostics-channel-symbol-named.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const input = {
+  foo: 'bar'
+};
+
+const symbol = Symbol('test');
+
+// Individual channel objects can be created to avoid future lookups
+const channel = dc.channel(symbol);
+
+// Expect two successful publishes later
+channel.subscribe(common.mustCall((message, name) => {
+  assert.strictEqual(name, symbol);
+  assert.deepStrictEqual(message, input);
+}));
+
+channel.publish(input);
+
+{
+  assert.throws(() => {
+    dc.channel(null);
+  }, /ERR_INVALID_ARG_TYPE/);
+}
diff --git a/test/parallel/test-disable-proto-throw.js b/test/parallel/test-disable-proto-throw.js
index e7a1f679765235fac2d0b2265ca1b24e37f04e11..a39cfef0d8bd43ed0f988d442373965f8fe7126b 100644
--- a/test/parallel/test-disable-proto-throw.js
+++ b/test/parallel/test-disable-proto-throw.js
@@ -10,7 +10,7 @@ const { Worker, isMainThread } = require('worker_threads');
 assert(Object.prototype.hasOwnProperty('__proto__'));
 
 assert.throws(() => {
-  // eslint-disable-next-line no-proto
+  // eslint-disable-next-line no-proto,no-unused-expressions
   ({}).__proto__;
 }, {
   code: 'ERR_PROTO_ACCESS'
diff --git a/test/parallel/test-dns-cancel-reverse-lookup.js b/test/parallel/test-dns-cancel-reverse-lookup.js
index 0918178e1257ba2cbc2c1b40da8aa45514119792..e0cb4d1854b4ab6ec7c3e8c3e552dc86acb6057c 100644
--- a/test/parallel/test-dns-cancel-reverse-lookup.js
+++ b/test/parallel/test-dns-cancel-reverse-lookup.js
@@ -12,7 +12,6 @@ server.bind(0, common.mustCall(() => {
   resolver.setServers([`127.0.0.1:${server.address().port}`]);
   resolver.reverse('123.45.67.89', common.mustCall((err, res) => {
     assert.strictEqual(err.code, 'ECANCELLED');
-    assert.strictEqual(err.errno, 'ECANCELLED');
     assert.strictEqual(err.syscall, 'getHostByAddr');
     assert.strictEqual(err.hostname, '123.45.67.89');
     server.close();
diff --git a/test/parallel/test-dns-channel-cancel-promise.js b/test/parallel/test-dns-channel-cancel-promise.js
new file mode 100644
index 0000000000000000000000000000000000000000..382ac3dd508d68862186ae751a6636dc497a88d0
--- /dev/null
+++ b/test/parallel/test-dns-channel-cancel-promise.js
@@ -0,0 +1,65 @@
+'use strict';
+const common = require('../common');
+const { promises: dnsPromises } = require('dns');
+const assert = require('assert');
+const dgram = require('dgram');
+
+const server = dgram.createSocket('udp4');
+const resolver = new dnsPromises.Resolver();
+
+const addMessageListener = () => {
+  server.removeAllListeners('message');
+
+  server.once('message', () => {
+    server.once('message', common.mustNotCall);
+
+    resolver.cancel();
+  });
+};
+
+server.bind(0, common.mustCall(async () => {
+  resolver.setServers([`127.0.0.1:${server.address().port}`]);
+
+  addMessageListener();
+
+  // Single promise
+  {
+    const hostname = 'example0.org';
+
+    await assert.rejects(
+      resolver.resolve4(hostname),
+      {
+        code: 'ECANCELLED',
+        syscall: 'queryA',
+        hostname
+      }
+    );
+  }
+
+  addMessageListener();
+
+  // Multiple promises
+  {
+    const assertions = [];
+    const assertionCount = 10;
+
+    for (let i = 1; i <= assertionCount; i++) {
+      const hostname = `example${i}.org`;
+
+      assertions.push(
+        assert.rejects(
+          resolver.resolve4(hostname),
+          {
+            code: 'ECANCELLED',
+            syscall: 'queryA',
+            hostname: hostname
+          }
+        )
+      );
+    }
+
+    await Promise.all(assertions);
+  }
+
+  server.close();
+}));
diff --git a/test/parallel/test-dns-channel-cancel.js b/test/parallel/test-dns-channel-cancel.js
index 797d61efb4065355b9078e4b0cd742e9796bb88e..f92fb2e30a4d12fbb3b920a58a52d5662b494acd 100644
--- a/test/parallel/test-dns-channel-cancel.js
+++ b/test/parallel/test-dns-channel-cancel.js
@@ -1,6 +1,5 @@
 'use strict';
 const common = require('../common');
-const dnstools = require('../common/dns');
 const { Resolver } = require('dns');
 const assert = require('assert');
 const dgram = require('dgram');
@@ -8,22 +7,45 @@ const dgram = require('dgram');
 const server = dgram.createSocket('udp4');
 const resolver = new Resolver();
 
-server.bind(0, common.mustCall(() => {
+const desiredQueries = 11;
+let finishedQueries = 0;
+
+const addMessageListener = () => {
+  server.removeAllListeners('message');
+
+  server.once('message', () => {
+    server.once('message', common.mustNotCall);
+
+    resolver.cancel();
+  });
+};
+
+server.bind(0, common.mustCall(async () => {
   resolver.setServers([`127.0.0.1:${server.address().port}`]);
-  resolver.resolve4('example.org', common.mustCall((err, res) => {
+
+  const callback = common.mustCall((err, res) => {
     assert.strictEqual(err.code, 'ECANCELLED');
-    assert.strictEqual(err.errno, 'ECANCELLED');
     assert.strictEqual(err.syscall, 'queryA');
-    assert.strictEqual(err.hostname, 'example.org');
-    server.close();
-  }));
-}));
+    assert.strictEqual(err.hostname, `example${finishedQueries}.org`);
+
+    finishedQueries++;
+    if (finishedQueries === desiredQueries) {
+      server.close();
+    }
+  }, desiredQueries);
+
+  const next = (...args) => {
+    callback(...args);
+
+    addMessageListener();
 
-server.on('message', common.mustCall((msg, { address, port }) => {
-  const parsed = dnstools.parseDNSPacket(msg);
-  const domain = parsed.questions[0].domain;
-  assert.strictEqual(domain, 'example.org');
+    // Multiple queries
+    for (let i = 1; i < desiredQueries; i++) {
+      resolver.resolve4(`example${i}.org`, callback);
+    }
+  };
 
-  // Do not send a reply.
-  resolver.cancel();
+  // Single query
+  addMessageListener();
+  resolver.resolve4('example0.org', next);
 }));
diff --git a/test/parallel/test-dns-default-verbatim-false.js b/test/parallel/test-dns-default-verbatim-false.js
new file mode 100644
index 0000000000000000000000000000000000000000..06b8f66a610998860511e8fa350bf144ef4e960a
--- /dev/null
+++ b/test/parallel/test-dns-default-verbatim-false.js
@@ -0,0 +1,51 @@
+// Flags: --expose-internals --dns-result-order=ipv4first
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+const cares = internalBinding('cares_wrap');
+const { promisify } = require('util');
+
+// Test that --dns-result-order=ipv4first works as expected.
+
+const originalGetaddrinfo = cares.getaddrinfo;
+const calls = [];
+cares.getaddrinfo = common.mustCallAtLeast((...args) => {
+  calls.push(args);
+  originalGetaddrinfo(...args);
+}, 1);
+
+const dns = require('dns');
+const dnsPromises = dns.promises;
+
+let verbatim;
+
+// We want to test the parameter of verbatim only so that we
+// ignore possible errors here.
+function allowFailed(fn) {
+  return fn.catch((_err) => {
+    //
+  });
+}
+
+(async () => {
+  let callsLength = 0;
+  const checkParameter = (expected) => {
+    assert.strictEqual(calls.length, callsLength + 1);
+    verbatim = calls[callsLength][4];
+    assert.strictEqual(verbatim, expected);
+    callsLength += 1;
+  };
+
+  await allowFailed(promisify(dns.lookup)('example.org'));
+  checkParameter(false);
+
+  await allowFailed(dnsPromises.lookup('example.org'));
+  checkParameter(false);
+
+  await allowFailed(promisify(dns.lookup)('example.org', {}));
+  checkParameter(false);
+
+  await allowFailed(dnsPromises.lookup('example.org', {}));
+  checkParameter(false);
+})().then(common.mustCall());
diff --git a/test/parallel/test-dns-default-verbatim-true.js b/test/parallel/test-dns-default-verbatim-true.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cdaa44a2dcb717eaeef6ab783e0b772a8c170da
--- /dev/null
+++ b/test/parallel/test-dns-default-verbatim-true.js
@@ -0,0 +1,51 @@
+// Flags: --expose-internals --dns-result-order=verbatim
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+const cares = internalBinding('cares_wrap');
+const { promisify } = require('util');
+
+// Test that --dns-result-order=verbatim works as expected.
+
+const originalGetaddrinfo = cares.getaddrinfo;
+const calls = [];
+cares.getaddrinfo = common.mustCallAtLeast((...args) => {
+  calls.push(args);
+  originalGetaddrinfo(...args);
+}, 1);
+
+const dns = require('dns');
+const dnsPromises = dns.promises;
+
+let verbatim;
+
+// We want to test the parameter of verbatim only so that we
+// ignore possible errors here.
+function allowFailed(fn) {
+  return fn.catch((_err) => {
+    //
+  });
+}
+
+(async () => {
+  let callsLength = 0;
+  const checkParameter = (expected) => {
+    assert.strictEqual(calls.length, callsLength + 1);
+    verbatim = calls[callsLength][4];
+    assert.strictEqual(verbatim, expected);
+    callsLength += 1;
+  };
+
+  await allowFailed(promisify(dns.lookup)('example.org'));
+  checkParameter(true);
+
+  await allowFailed(dnsPromises.lookup('example.org'));
+  checkParameter(true);
+
+  await allowFailed(promisify(dns.lookup)('example.org', {}));
+  checkParameter(true);
+
+  await allowFailed(dnsPromises.lookup('example.org', {}));
+  checkParameter(true);
+})().then(common.mustCall());
diff --git a/test/parallel/test-dns-lookup-promises.js b/test/parallel/test-dns-lookup-promises.js
index 3e8e202c94c112f25bc76b9f74be0af665f2ba14..31c7dbd2458fe6168af7fc013d9cce9b8ac87621 100644
--- a/test/parallel/test-dns-lookup-promises.js
+++ b/test/parallel/test-dns-lookup-promises.js
@@ -56,7 +56,7 @@ async function lookupPositive() {
       stub: getaddrinfoPositive(['some-address2']),
       factory: () => dnsPromises.lookup('example.com', { family: 6 }),
       expectation: { address: 'some-address2', family: 6 }
-    }
+    },
   ].forEach(async ({ stub, factory, expectation }) => {
     getaddrinfoStub = stub;
     assert.deepStrictEqual(await factory(), expectation);
@@ -80,7 +80,7 @@ async function lookupallPositive() {
       factory: () => dnsPromises.lookup('example', { all: true }),
       expectation: [
         { address: '::1', family: 6 },
-        { address: '::2', family: 6 }
+        { address: '::2', family: 6 },
       ]
     },
     {
@@ -88,7 +88,7 @@ async function lookupallPositive() {
       factory: () => dnsPromises.lookup('example', { all: true, family: 4 }),
       expectation: [
         { address: '::1', family: 4 },
-        { address: '::2', family: 4 }
+        { address: '::2', family: 4 },
       ]
     },
     {
@@ -96,7 +96,7 @@ async function lookupallPositive() {
       factory: () => dnsPromises.lookup('example', { all: true }),
       expectation: [
         { address: '127.0.0.1', family: 4 },
-        { address: 'some-address', family: 0 }
+        { address: 'some-address', family: 0 },
       ]
     },
     {
@@ -104,14 +104,14 @@ async function lookupallPositive() {
       factory: () => dnsPromises.lookup('example', { all: true, family: 6 }),
       expectation: [
         { address: '127.0.0.1', family: 6 },
-        { address: 'some-address', family: 6 }
+        { address: 'some-address', family: 6 },
       ]
     },
     {
       stub: getaddrinfoPositive([]),
       factory: () => dnsPromises.lookup('example', { all: true }),
       expectation: []
-    }
+    },
   ].forEach(async ({ stub, factory, expectation }) => {
     getaddrinfoStub = stub;
     assert.deepStrictEqual(await factory(), expectation);
@@ -134,6 +134,6 @@ async function lookupallNegative() {
     lookupPositive(),
     lookupNegative(),
     lookupallPositive(),
-    lookupallNegative()
-  ]).then(common.mustCall());
-})();
+    lookupallNegative(),
+  ]);
+})().then(common.mustCall());
diff --git a/test/parallel/test-dns-lookup.js b/test/parallel/test-dns-lookup.js
index 80e13d308d3217fd7fdae80d469b8e55a7f184dd..220153ac380cc983641b4574f06483081014c902 100644
--- a/test/parallel/test-dns-lookup.js
+++ b/test/parallel/test-dns-lookup.js
@@ -27,7 +27,7 @@ const dnsPromises = dns.promises;
 common.expectWarning({
   // For 'internal/test/binding' module.
   'internal/test/binding': [
-    'These APIs are for internal testing only. Do not use them.'
+    'These APIs are for internal testing only. Do not use them.',
   ],
   // For calling `dns.lookup` with falsy `hostname`.
   'DeprecationWarning': {
@@ -72,7 +72,8 @@ assert.throws(() => {
   const err = {
     code: 'ERR_INVALID_OPT_VALUE',
     name: 'TypeError',
-    message: 'The value "20" is invalid for option "family"'
+    message: 'The value "20" is invalid for option "family". ' +
+    'Must be one of: 0, 4, 6'
   };
   const options = {
     hints: 0,
@@ -109,14 +110,13 @@ assert.throws(() => {
     all: false
   });
   assert.deepStrictEqual(res, { address: '127.0.0.1', family: 4 });
-})();
+})().then(common.mustCall());
 
 dns.lookup(false, {
   hints: 0,
   family: 0,
   all: true
-}, common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
+}, common.mustSucceed((result, addressType) => {
   assert.deepStrictEqual(result, []);
   assert.strictEqual(addressType, undefined);
 }));
@@ -125,8 +125,7 @@ dns.lookup('127.0.0.1', {
   hints: 0,
   family: 4,
   all: true
-}, common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
+}, common.mustSucceed((result, addressType) => {
   assert.deepStrictEqual(result, [{
     address: '127.0.0.1',
     family: 4
@@ -138,8 +137,7 @@ dns.lookup('127.0.0.1', {
   hints: 0,
   family: 4,
   all: false
-}, common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
+}, common.mustSucceed((result, addressType) => {
   assert.deepStrictEqual(result, '127.0.0.1');
   assert.strictEqual(addressType, 4);
 }));
diff --git a/test/parallel/test-dns-multi-channel.js b/test/parallel/test-dns-multi-channel.js
index bd88fe0b24fc75b0b4505cda7fbca776f80238e3..026ef44e339e8576c18b2ed279ec503e8e06f371 100644
--- a/test/parallel/test-dns-multi-channel.js
+++ b/test/parallel/test-dns-multi-channel.js
@@ -13,7 +13,7 @@ const servers = [
   {
     socket: dgram.createSocket('udp4'),
     reply: { type: 'A', address: '5.6.7.8', ttl: 123, domain: 'example.org' }
-  }
+  },
 ];
 
 let waiting = servers.length;
@@ -44,8 +44,7 @@ function ready() {
 
   for (const { server: { socket, reply }, resolver } of resolvers) {
     resolver.setServers([`127.0.0.1:${socket.address().port}`]);
-    resolver.resolve4('example.org', common.mustCall((err, res) => {
-      assert.ifError(err);
+    resolver.resolve4('example.org', common.mustSucceed((res) => {
       assert.deepStrictEqual(res, [reply.address]);
       socket.close();
     }));
diff --git a/test/parallel/test-dns-resolveany.js b/test/parallel/test-dns-resolveany.js
index 33beee847fd52cf6456a38ea8d137f086100bc9b..0bbfe8f9f18432a4fe0561d2bec4f5680366a535 100644
--- a/test/parallel/test-dns-resolveany.js
+++ b/test/parallel/test-dns-resolveany.js
@@ -23,6 +23,11 @@ const answers = [
     expire: 1800,
     minttl: 60
   },
+  {
+    type: 'CAA',
+    critical: 128,
+    issue: 'platynum.ch'
+  },
 ];
 
 const server = dgram.createSocket('udp4');
@@ -45,8 +50,7 @@ server.bind(0, common.mustCall(async () => {
 
   validateResults(await dnsPromises.resolveAny('example.org'));
 
-  dns.resolveAny('example.org', common.mustCall((err, res) => {
-    assert.ifError(err);
+  dns.resolveAny('example.org', common.mustSucceed((res) => {
     validateResults(res);
     server.close();
   }));
diff --git a/test/parallel/test-dns-set-default-order.js b/test/parallel/test-dns-set-default-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..43980c5dd8716c05ee6f1c8344e331c7b7290c13
--- /dev/null
+++ b/test/parallel/test-dns-set-default-order.js
@@ -0,0 +1,93 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+const cares = internalBinding('cares_wrap');
+const { promisify } = require('util');
+
+// Test that `dns.setDefaultResultOrder()` and
+// `dns.promises.setDefaultResultOrder()` works as expected.
+
+const originalGetaddrinfo = cares.getaddrinfo;
+const calls = [];
+cares.getaddrinfo = common.mustCallAtLeast((...args) => {
+  calls.push(args);
+  originalGetaddrinfo(...args);
+}, 1);
+
+const dns = require('dns');
+const dnsPromises = dns.promises;
+
+let verbatim;
+
+// We want to test the parameter of verbatim only so that we
+// ignore possible errors here.
+function allowFailed(fn) {
+  return fn.catch((_err) => {
+    //
+  });
+}
+
+assert.throws(() => dns.setDefaultResultOrder('my_order'), {
+  code: 'ERR_INVALID_ARG_VALUE',
+});
+assert.throws(() => dns.promises.setDefaultResultOrder('my_order'), {
+  code: 'ERR_INVALID_ARG_VALUE',
+});
+assert.throws(() => dns.setDefaultResultOrder(4), {
+  code: 'ERR_INVALID_ARG_VALUE',
+});
+assert.throws(() => dns.promises.setDefaultResultOrder(4), {
+  code: 'ERR_INVALID_ARG_VALUE',
+});
+
+(async () => {
+  let callsLength = 0;
+  const checkParameter = (expected) => {
+    assert.strictEqual(calls.length, callsLength + 1);
+    verbatim = calls[callsLength][4];
+    assert.strictEqual(verbatim, expected);
+    callsLength += 1;
+  };
+
+  dns.setDefaultResultOrder('verbatim');
+  await allowFailed(promisify(dns.lookup)('example.org'));
+  checkParameter(true);
+  await allowFailed(dnsPromises.lookup('example.org'));
+  checkParameter(true);
+  await allowFailed(promisify(dns.lookup)('example.org', {}));
+  checkParameter(true);
+  await allowFailed(dnsPromises.lookup('example.org', {}));
+  checkParameter(true);
+
+  dns.setDefaultResultOrder('ipv4first');
+  await allowFailed(promisify(dns.lookup)('example.org'));
+  checkParameter(false);
+  await allowFailed(dnsPromises.lookup('example.org'));
+  checkParameter(false);
+  await allowFailed(promisify(dns.lookup)('example.org', {}));
+  checkParameter(false);
+  await allowFailed(dnsPromises.lookup('example.org', {}));
+  checkParameter(false);
+
+  dns.promises.setDefaultResultOrder('verbatim');
+  await allowFailed(promisify(dns.lookup)('example.org'));
+  checkParameter(true);
+  await allowFailed(dnsPromises.lookup('example.org'));
+  checkParameter(true);
+  await allowFailed(promisify(dns.lookup)('example.org', {}));
+  checkParameter(true);
+  await allowFailed(dnsPromises.lookup('example.org', {}));
+  checkParameter(true);
+
+  dns.promises.setDefaultResultOrder('ipv4first');
+  await allowFailed(promisify(dns.lookup)('example.org'));
+  checkParameter(false);
+  await allowFailed(dnsPromises.lookup('example.org'));
+  checkParameter(false);
+  await allowFailed(promisify(dns.lookup)('example.org', {}));
+  checkParameter(false);
+  await allowFailed(dnsPromises.lookup('example.org', {}));
+  checkParameter(false);
+})().then(common.mustCall());
diff --git a/test/parallel/test-dns-setlocaladdress.js b/test/parallel/test-dns-setlocaladdress.js
new file mode 100644
index 0000000000000000000000000000000000000000..25bece328f4a7477b0bddb424f51dfab6fda196b
--- /dev/null
+++ b/test/parallel/test-dns-setlocaladdress.js
@@ -0,0 +1,40 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const dns = require('dns');
+const resolver = new dns.Resolver();
+const promiseResolver = new dns.promises.Resolver();
+
+// Verifies that setLocalAddress succeeds with IPv4 and IPv6 addresses
+{
+  resolver.setLocalAddress('127.0.0.1');
+  resolver.setLocalAddress('::1');
+  resolver.setLocalAddress('127.0.0.1', '::1');
+  promiseResolver.setLocalAddress('127.0.0.1', '::1');
+}
+
+// Verify that setLocalAddress throws if called with an invalid address
+{
+  assert.throws(() => {
+    resolver.setLocalAddress('127.0.0.1', '127.0.0.1');
+  }, Error);
+  assert.throws(() => {
+    resolver.setLocalAddress('::1', '::1');
+  }, Error);
+  assert.throws(() => {
+    resolver.setLocalAddress('bad');
+  }, Error);
+  assert.throws(() => {
+    resolver.setLocalAddress(123);
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+  assert.throws(() => {
+    resolver.setLocalAddress('127.0.0.1', 42);
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+  assert.throws(() => {
+    resolver.setLocalAddress();
+  }, Error);
+  assert.throws(() => {
+    promiseResolver.setLocalAddress();
+  }, Error);
+}
diff --git a/test/parallel/test-dns-setservers-type-check.js b/test/parallel/test-dns-setservers-type-check.js
index 9f09ee4ebf65191a13e82b7e9d9111dd13edb4ca..cc819cae74b7fd630f54427552f33cd8d4d40305 100644
--- a/test/parallel/test-dns-setservers-type-check.js
+++ b/test/parallel/test-dns-setservers-type-check.js
@@ -15,7 +15,7 @@ const promiseResolver = new dns.promises.Resolver();
     addresses.DNS4_SERVER,
     {
       address: addresses.DNS4_SERVER
-    }
+    },
   ].forEach((val) => {
     const errObj = {
       code: 'ERR_INVALID_ARG_TYPE',
@@ -54,8 +54,8 @@ const promiseResolver = new dns.promises.Resolver();
     [
       {
         address: addresses.DNS4_SERVER
-      }
-    ]
+      },
+    ],
   ].forEach((val) => {
     const errObj = {
       code: 'ERR_INVALID_ARG_TYPE',
diff --git a/test/parallel/test-dns.js b/test/parallel/test-dns.js
index bf49b66370dc93910319d7ad4695ecb5dba1d3c6..fb6600430acb9e6463180560e82438f7e9d15a9b 100644
--- a/test/parallel/test-dns.js
+++ b/test/parallel/test-dns.js
@@ -61,7 +61,7 @@ assert(existing.length > 0);
   assert.deepStrictEqual(dns.getServers(), [
     '127.0.0.1',
     '192.168.1.1',
-    '0.0.0.0'
+    '0.0.0.0',
   ]);
 }
 
@@ -75,7 +75,7 @@ assert(existing.length > 0);
     // Check for REDOS issues.
     ':'.repeat(100000),
     '['.repeat(100000),
-    '['.repeat(100000) + ']'.repeat(100000) + 'a'
+    '['.repeat(100000) + ']'.repeat(100000) + 'a',
   ];
   invalidServers.forEach((serv) => {
     assert.throws(
@@ -207,15 +207,13 @@ assert.deepStrictEqual(dns.getServers(), []);
 }
 
 {
-  /*
-  * Make sure that dns.lookup throws if hints does not represent a valid flag.
-  * (dns.V4MAPPED | dns.ADDRCONFIG | dns.ALL) + 1 is invalid because:
-  * - it's different from dns.V4MAPPED and dns.ADDRCONFIG and dns.ALL.
-  * - it's different from any subset of them bitwise ored.
-  * - it's different from 0.
-  * - it's an odd number different than 1, and thus is invalid, because
-  * flags are either === 1 or even.
-  */
+  // Make sure that dns.lookup throws if hints does not represent a valid flag.
+  // (dns.V4MAPPED | dns.ADDRCONFIG | dns.ALL) + 1 is invalid because:
+  // - it's different from dns.V4MAPPED and dns.ADDRCONFIG and dns.ALL.
+  // - it's different from any subset of them bitwise ored.
+  // - it's different from 0.
+  // - it's an odd number different than 1, and thus is invalid, because
+  // flags are either === 1 or even.
   const hints = (dns.V4MAPPED | dns.ADDRCONFIG | dns.ALL) + 1;
   const err = {
     code: 'ERR_INVALID_OPT_VALUE',
@@ -276,7 +274,7 @@ dns.lookup('', {
   await dnsPromises.lookup('', {
     hints: dns.ADDRCONFIG | dns.V4MAPPED | dns.ALL
   });
-})();
+})().then(common.mustCall());
 
 {
   const err = {
@@ -338,7 +336,6 @@ assert.throws(() => {
 
 {
   dns.resolveMx('foo.onion', function(err) {
-    assert.deepStrictEqual(err.errno, 'ENOTFOUND');
     assert.deepStrictEqual(err.code, 'ENOTFOUND');
     assert.deepStrictEqual(err.syscall, 'queryMx');
     assert.deepStrictEqual(err.hostname, 'foo.onion');
@@ -365,18 +362,15 @@ assert.throws(() => {
           expire: 1800,
           minttl: 3333333333
         },
-      ]
-    },
+      ] },
 
     { method: 'resolve4',
       options: { ttl: true },
-      answers: [ { type: 'A', address: '1.2.3.4', ttl: 3333333333 } ]
-    },
+      answers: [ { type: 'A', address: '1.2.3.4', ttl: 3333333333 } ] },
 
     { method: 'resolve6',
       options: { ttl: true },
-      answers: [ { type: 'AAAA', address: '::42', ttl: 3333333333 } ]
-    },
+      answers: [ { type: 'AAAA', address: '::42', ttl: 3333333333 } ] },
 
     { method: 'resolveSoa',
       answers: [
@@ -389,9 +383,8 @@ assert.throws(() => {
           retry: 900,
           expire: 1800,
           minttl: 3333333333
-        }
-      ]
-    },
+        },
+      ] },
   ];
 
   const server = dgram.createSocket('udp4');
@@ -445,13 +438,12 @@ assert.throws(() => {
 
       validateResults(await dnsPromises[method]('example.org', options));
 
-      dns[method]('example.org', options, common.mustCall((err, res) => {
-        assert.ifError(err);
+      dns[method]('example.org', options, common.mustSucceed((res) => {
         validateResults(res);
         cases.shift();
         nextCase();
       }));
-    })();
+    })().then(common.mustCall());
 
   }));
 }
diff --git a/test/parallel/test-domain-abort-on-uncaught.js b/test/parallel/test-domain-abort-on-uncaught.js
index e74fb436bf18e06ca7901ba0897e178b65bbe536..08551721c1d39b9de4e880174f26bda6f423641c 100644
--- a/test/parallel/test-domain-abort-on-uncaught.js
+++ b/test/parallel/test-domain-abort-on-uncaught.js
@@ -191,7 +191,7 @@ const tests = [
         });
       });
     });
-  }
+  },
 ];
 
 if (process.argv[2] === 'child') {
diff --git a/test/parallel/test-domain-crypto.js b/test/parallel/test-domain-crypto.js
index cb397c2fe33eb6c53d2e2a7047a9f278a6a93940..e0a470bd9db5151636443b0aa4ff44addf71b21e 100644
--- a/test/parallel/test-domain-crypto.js
+++ b/test/parallel/test-domain-crypto.js
@@ -35,9 +35,9 @@ global.domain = require('domain');
 
 // Should not throw a 'TypeError: undefined is not a function' exception
 crypto.randomBytes(8);
-crypto.randomBytes(8, common.mustCall());
+crypto.randomBytes(8, common.mustSucceed());
 const buf = Buffer.alloc(8);
 crypto.randomFillSync(buf);
 crypto.pseudoRandomBytes(8);
-crypto.pseudoRandomBytes(8, common.mustCall());
-crypto.pbkdf2('password', 'salt', 8, 8, 'sha1', common.mustCall());
+crypto.pseudoRandomBytes(8, common.mustSucceed());
+crypto.pbkdf2('password', 'salt', 8, 8, 'sha1', common.mustSucceed());
diff --git a/test/parallel/test-domain-dep0097.js b/test/parallel/test-domain-dep0097.js
new file mode 100644
index 0000000000000000000000000000000000000000..05b5c74b30d98e2a7d72d4eeb5c6a42547f8ff40
--- /dev/null
+++ b/test/parallel/test-domain-dep0097.js
@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const domain = require('domain');
+const inspector = require('inspector');
+
+process.on('warning', common.mustCall((warning) => {
+  assert.strictEqual(warning.code, 'DEP0097');
+  assert.match(warning.message, /Triggered by calling emit on process/);
+}));
+
+domain.create().run(() => {
+  inspector.open();
+});
diff --git a/test/parallel/test-domain-emit-error-handler-stack.js b/test/parallel/test-domain-emit-error-handler-stack.js
new file mode 100644
index 0000000000000000000000000000000000000000..da00b92826aa89afe6bdf8e53db50b7d5aea741f
--- /dev/null
+++ b/test/parallel/test-domain-emit-error-handler-stack.js
@@ -0,0 +1,159 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+const EventEmitter = require('events');
+
+// Make sure that the domains stack and the active domain is setup properly when
+// a domain's error handler is called due to an error event being emitted.
+// More specifically, we want to test that:
+// - the active domain in the domain's error handler is//not* that domain,//but*
+//   the active domain is a any direct parent domain at the time the error was
+//   emitted.
+// - the domains stack in the domain's error handler does//not* include that
+//   domain, *but* it includes all parents of that domain when the error was
+//   emitted.
+const d1 = domain.create();
+const d2 = domain.create();
+const d3 = domain.create();
+
+function checkExpectedDomains(err) {
+  // First, check that domains stack and active domain is as expected when the
+  // event handler is called synchronously via ee.emit('error').
+  if (domain._stack.length !== err.expectedStackLength) {
+    console.error('expected domains stack length of %d, but instead is %d',
+                  err.expectedStackLength, domain._stack.length);
+    process.exit(1);
+  }
+
+  if (process.domain !== err.expectedActiveDomain) {
+    console.error('expected active domain to be %j, but instead is %j',
+                  err.expectedActiveDomain, process.domain);
+    process.exit(1);
+  }
+
+  // Then make sure that the domains stack and active domain is setup as
+  // expected when executing a callback scheduled via nextTick from the error
+  // handler.
+  process.nextTick(() => {
+    const expectedStackLengthInNextTickCb =
+            err.expectedStackLength > 0 ? 1 : 0;
+    if (domain._stack.length !== expectedStackLengthInNextTickCb) {
+      console.error('expected stack length in nextTick cb to be %d, ' +
+                'but instead is %d', expectedStackLengthInNextTickCb,
+                    domain._stack.length);
+      process.exit(1);
+    }
+
+    const expectedActiveDomainInNextTickCb =
+            expectedStackLengthInNextTickCb === 0 ? undefined :
+              err.expectedActiveDomain;
+    if (process.domain !== expectedActiveDomainInNextTickCb) {
+      console.error('expected active domain in nextTick cb to be %j, ' +
+                'but instead is %j', expectedActiveDomainInNextTickCb,
+                    process.domain);
+      process.exit(1);
+    }
+  });
+}
+
+d1.on('error', common.mustCall((err) => {
+  checkExpectedDomains(err);
+}, 2));
+
+d2.on('error', common.mustCall((err) => {
+  checkExpectedDomains(err);
+}, 2));
+
+d3.on('error', common.mustCall((err) => {
+  checkExpectedDomains(err);
+}, 1));
+
+d1.run(() => {
+  const ee = new EventEmitter();
+  assert.strictEqual(process.domain, d1);
+  assert.strictEqual(domain._stack.length, 1);
+
+  const err = new Error('oops');
+  err.expectedStackLength = 0;
+  err.expectedActiveDomain = null;
+  ee.emit('error', err);
+
+  assert.strictEqual(process.domain, d1);
+  assert.strictEqual(domain._stack.length, 1);
+});
+
+d1.run(() => {
+  d1.run(() => {
+    const ee = new EventEmitter();
+
+    assert.strictEqual(process.domain, d1);
+    assert.strictEqual(domain._stack.length, 2);
+
+    const err = new Error('oops');
+    err.expectedStackLength = 0;
+    err.expectedActiveDomain = null;
+    ee.emit('error', err);
+
+    assert.strictEqual(process.domain, d1);
+    assert.strictEqual(domain._stack.length, 2);
+  });
+});
+
+d1.run(() => {
+  d2.run(() => {
+    const ee = new EventEmitter();
+
+    assert.strictEqual(process.domain, d2);
+    assert.strictEqual(domain._stack.length, 2);
+
+    const err = new Error('oops');
+    err.expectedStackLength = 1;
+    err.expectedActiveDomain = d1;
+    ee.emit('error', err);
+
+    assert.strictEqual(process.domain, d2);
+    assert.strictEqual(domain._stack.length, 2);
+  });
+});
+
+d1.run(() => {
+  d2.run(() => {
+    d2.run(() => {
+      const ee = new EventEmitter();
+
+      assert.strictEqual(process.domain, d2);
+      assert.strictEqual(domain._stack.length, 3);
+
+      const err = new Error('oops');
+      err.expectedStackLength = 1;
+      err.expectedActiveDomain = d1;
+      ee.emit('error', err);
+
+      assert.strictEqual(process.domain, d2);
+      assert.strictEqual(domain._stack.length, 3);
+    });
+  });
+});
+
+d3.run(() => {
+  d1.run(() => {
+    d3.run(() => {
+      d3.run(() => {
+        const ee = new EventEmitter();
+
+        assert.strictEqual(process.domain, d3);
+        assert.strictEqual(domain._stack.length, 4);
+
+        const err = new Error('oops');
+        err.expectedStackLength = 2;
+        err.expectedActiveDomain = d1;
+        ee.emit('error', err);
+
+        assert.strictEqual(process.domain, d3);
+        assert.strictEqual(domain._stack.length, 4);
+      });
+    });
+  });
+});
diff --git a/test/parallel/test-domain-error-types.js b/test/parallel/test-domain-error-types.js
index b7c2d6ba9b748eb6c4eb7346c53e8d2520ce41da..cfd4fa801e3d95e7d716d3d99fd80bf81758f0d7 100644
--- a/test/parallel/test-domain-error-types.js
+++ b/test/parallel/test-domain-error-types.js
@@ -11,7 +11,7 @@ const domain = require('domain');
 // https://github.com/nodejs/node/issues/28275 is fixed in debug mode.
 
 for (const something of [
-  42, null, undefined, false, () => {}, 'string', Symbol('foo')
+  42, null, undefined, false, () => {}, 'string', Symbol('foo'),
 ]) {
   const d = new domain.Domain();
   d.run(common.mustCall(() => {
diff --git a/test/parallel/test-domain-multiple-errors.js b/test/parallel/test-domain-multiple-errors.js
index 5b031eb1b44bc458d28dccd42de5ced60bf1db13..fc4ccc47d3270849bb160a27f5fa18089087d57c 100644
--- a/test/parallel/test-domain-multiple-errors.js
+++ b/test/parallel/test-domain-multiple-errors.js
@@ -10,7 +10,7 @@ const domain = require('domain');
 const d = new domain.Domain();
 
 const values = [
-  42, null, undefined, false, () => {}, 'string', Symbol('foo')
+  42, null, undefined, false, () => {}, 'string', Symbol('foo'),
 ];
 
 d.on('error', common.mustCall((err) => {
diff --git a/test/parallel/test-domain-thrown-error-handler-stack.js b/test/parallel/test-domain-thrown-error-handler-stack.js
new file mode 100644
index 0000000000000000000000000000000000000000..da5f6318c0fb15ea09e7a9cade989e381311719b
--- /dev/null
+++ b/test/parallel/test-domain-thrown-error-handler-stack.js
@@ -0,0 +1,44 @@
+'use strict';
+
+const common = require('../common');
+const domain = require('domain');
+
+// Make sure that when an erorr is thrown from a nested domain, its error
+// handler runs outside of that domain, but within the context of any parent
+// domain.
+
+const d = domain.create();
+const d2 = domain.create();
+
+d2.on('error', common.mustCall((err) => {
+  if (domain._stack.length !== 1) {
+    console.error('domains stack length should be 1 but is %d',
+                  domain._stack.length);
+    process.exit(1);
+  }
+
+  if (process.domain !== d) {
+    console.error('active domain should be %j but is %j', d, process.domain);
+    process.exit(1);
+  }
+
+  process.nextTick(() => {
+    if (domain._stack.length !== 1) {
+      console.error('domains stack length should be 1 but is %d',
+                    domain._stack.length);
+      process.exit(1);
+    }
+
+    if (process.domain !== d) {
+      console.error('active domain should be %j but is %j', d,
+                    process.domain);
+      process.exit(1);
+    }
+  });
+}));
+
+d.run(() => {
+  d2.run(() => {
+    throw new Error('oops');
+  });
+});
diff --git a/test/parallel/test-domain-top-level-error-handler-clears-stack.js b/test/parallel/test-domain-top-level-error-handler-clears-stack.js
index 05d5fca46718260f5e9698131d2720926c6240ce..2f67a73290cbfa6d14bffd55a2077333be9aa03e 100644
--- a/test/parallel/test-domain-top-level-error-handler-clears-stack.js
+++ b/test/parallel/test-domain-top-level-error-handler-clears-stack.js
@@ -3,26 +3,23 @@
 const common = require('../common');
 const domain = require('domain');
 
-/*
- * Make sure that the domains stack is cleared after a top-level domain
- * error handler exited gracefully.
- */
+// Make sure that the domains stack is cleared after a top-level domain
+// error handler exited gracefully.
 const d = domain.create();
 
 d.on('error', common.mustCall(() => {
+  // Scheduling a callback with process.nextTick _could_ enter a _new_ domain,
+  // but domain's error handlers are called outside of their domain's context.
+  // So there should _no_ domain on the domains stack if the domains stack was
+  // cleared properly when the domain error handler was called.
   process.nextTick(() => {
-    // Scheduling a callback with process.nextTick will enter a _new_ domain,
-    // and the callback will be called after the domain that handled the error
-    // was exited. So there should be only one domain on the domains stack if
-    // the domains stack was cleared properly when the domain error handler
-    // returned.
-    if (domain._stack.length !== 1) {
+    if (domain._stack.length !== 0) {
       // Do not use assert to perform this test: this callback runs in a
       // different callstack as the original process._fatalException that
       // handled the original error, thus throwing here would trigger another
       // call to process._fatalException, and so on recursively and
       // indefinitely.
-      console.error('domains stack length should be 1, but instead is:',
+      console.error('domains stack length should be 0, but instead is:',
                     domain._stack.length);
       process.exit(1);
     }
diff --git a/test/parallel/test-domain-top-level-error-handler-throw.js b/test/parallel/test-domain-top-level-error-handler-throw.js
index 3a0768327383dacf11b73be7f225405e885bae6f..ed839749bbbd34db77b165c1a3af0602aede4621 100644
--- a/test/parallel/test-domain-top-level-error-handler-throw.js
+++ b/test/parallel/test-domain-top-level-error-handler-throw.js
@@ -1,11 +1,9 @@
 'use strict';
 
-/*
- * The goal of this test is to make sure that when a top-level error
- * handler throws an error following the handling of a previous error,
- * the process reports the error message from the error thrown in the
- * top-level error handler, not the one from the previous error.
- */
+// The goal of this test is to make sure that when a top-level error
+// handler throws an error following the handling of a previous error,
+// the process reports the error message from the error thrown in the
+// top-level error handler, not the one from the previous error.
 
 require('../common');
 
diff --git a/test/parallel/test-domain-uncaught-exception.js b/test/parallel/test-domain-uncaught-exception.js
index 0d6465fbf3f42ffd569a3a75236e1385642960f1..a9a28c35ec26a70e0a5ca8d19a2f89a1264fa17d 100644
--- a/test/parallel/test-domain-uncaught-exception.js
+++ b/test/parallel/test-domain-uncaught-exception.js
@@ -1,12 +1,10 @@
 'use strict';
 
-/*
- * The goal of this test is to make sure that errors thrown within domains
- * are handled correctly. It checks that the process' 'uncaughtException' event
- * is emitted when appropriate, and not emitted when it shouldn't. It also
- * checks that the proper domain error handlers are called when they should
- * be called, and not called when they shouldn't.
- */
+// The goal of this test is to make sure that errors thrown within domains
+// are handled correctly. It checks that the process' 'uncaughtException' event
+// is emitted when appropriate, and not emitted when it shouldn't. It also
+// checks that the proper domain error handlers are called when they should
+// be called, and not called when they shouldn't.
 
 const common = require('../common');
 const assert = require('assert');
@@ -16,11 +14,9 @@ const child_process = require('child_process');
 const tests = [];
 
 function test1() {
-  /*
-   * Throwing from an async callback from within a domain that doesn't have
-   * an error handler must result in emitting the process' uncaughtException
-   * event.
-   */
+  // Throwing from an async callback from within a domain that doesn't have
+  // an error handler must result in emitting the process' uncaughtException
+  // event.
   const d = domain.create();
   d.run(function() {
     setTimeout(function onTimeout() {
@@ -35,10 +31,8 @@ tests.push({
 });
 
 function test2() {
-  /*
-   * Throwing from from within a domain that doesn't have an error handler must
-   * result in emitting the process' uncaughtException event.
-   */
+  // Throwing from from within a domain that doesn't have an error handler must
+  // result in emitting the process' uncaughtException event.
   const d2 = domain.create();
   d2.run(function() {
     throw new Error('boom!');
@@ -51,11 +45,9 @@ tests.push({
 });
 
 function test3() {
-  /*
-   * This test creates two nested domains: d3 and d4. d4 doesn't register an
-   * error handler, but d3 does. The error is handled by the d3 domain and thus
-   * an 'uncaughtException' event should _not_ be emitted.
-   */
+  // This test creates two nested domains: d3 and d4. d4 doesn't register an
+  // error handler, but d3 does. The error is handled by the d3 domain and thus
+  // an 'uncaughtException' event should _not_ be emitted.
   const d3 = domain.create();
   const d4 = domain.create();
 
@@ -76,15 +68,13 @@ tests.push({
 });
 
 function test4() {
-  /*
-   * This test creates two nested domains: d5 and d6. d6 doesn't register an
-   * error handler. When the timer's callback is called, because async
-   * operations like timer callbacks are bound to the domain that was active
-   * at the time of their creation, and because both d5 and d6 domains have
-   * exited by the time the timer's callback is called, its callback runs with
-   * only d6 on the domains stack. Since d6 doesn't register an error handler,
-   * the process' uncaughtException event should be emitted.
-   */
+  // This test creates two nested domains: d5 and d6. d6 doesn't register an
+  // error handler. When the timer's callback is called, because async
+  // operations like timer callbacks are bound to the domain that was active
+  // at the time of their creation, and because both d5 and d6 domains have
+  // exited by the time the timer's callback is called, its callback runs with
+  // only d6 on the domains stack. Since d6 doesn't register an error handler,
+  // the process' uncaughtException event should be emitted.
   const d5 = domain.create();
   const d6 = domain.create();
 
@@ -107,11 +97,9 @@ tests.push({
 });
 
 function test5() {
-  /*
-   * This test creates two nested domains: d7 and d8. d8 _does_ register an
-   * error handler, so throwing within that domain should not emit an uncaught
-   * exception.
-   */
+  // This test creates two nested domains: d7 and d8. d8 _does_ register an
+  // error handler, so throwing within that domain should not emit an uncaught
+  // exception.
   const d7 = domain.create();
   const d8 = domain.create();
 
@@ -131,11 +119,10 @@ tests.push({
 });
 
 function test6() {
-  /*
-   * This test creates two nested domains: d9 and d10. d10 _does_ register an
-   * error handler, so throwing within that domain in an async callback should
-   * _not_ emit an uncaught exception.
-   */
+  // This test creates two nested domains: d9 and d10. d10 _does_ register an
+  // error handler, so throwing within that domain in an async callback should
+  // _not_ emit an uncaught exception.
+  //
   const d9 = domain.create();
   const d10 = domain.create();
 
diff --git a/test/parallel/test-domain-with-abort-on-uncaught-exception.js b/test/parallel/test-domain-with-abort-on-uncaught-exception.js
index 0707f123b8c3a1255bfc83c21898ef0d00025e92..5eed67d28ffa584f06b6a662ff5a67ba3aa2f638 100644
--- a/test/parallel/test-domain-with-abort-on-uncaught-exception.js
+++ b/test/parallel/test-domain-with-abort-on-uncaught-exception.js
@@ -4,27 +4,25 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
-/*
- * The goal of this test is to make sure that:
- *
- * - Even if --abort_on_uncaught_exception is passed on the command line,
- * setting up a top-level domain error handler and throwing an error
- * within this domain does *not* make the process abort. The process exits
- * gracefully.
- *
- * - When passing --abort_on_uncaught_exception on the command line and
- * setting up a top-level domain error handler, an error thrown
- * within this domain's error handler *does* make the process abort.
- *
- * - When *not* passing --abort_on_uncaught_exception on the command line and
- * setting up a top-level domain error handler, an error thrown within this
- * domain's error handler does *not* make the process abort, but makes it exit
- * with the proper failure exit code.
- *
- * - When throwing an error within the top-level domain's error handler
- * within a try/catch block, the process should exit gracefully, whether or
- * not --abort_on_uncaught_exception is passed on the command line.
- */
+// The goal of this test is to make sure that:
+//
+// - Even if --abort_on_uncaught_exception is passed on the command line,
+// setting up a top-level domain error handler and throwing an error
+// within this domain does *not* make the process abort. The process exits
+// gracefully.
+//
+// - When passing --abort_on_uncaught_exception on the command line and
+// setting up a top-level domain error handler, an error thrown
+// within this domain's error handler *does* make the process abort.
+//
+// - When *not* passing --abort_on_uncaught_exception on the command line and
+// setting up a top-level domain error handler, an error thrown within this
+// domain's error handler does *not* make the process abort, but makes it exit
+// with the proper failure exit code.
+//
+// - When throwing an error within the top-level domain's error handler
+// within a try/catch block, the process should exit gracefully, whether or
+// not --abort_on_uncaught_exception is passed on the command line.
 
 const domainErrHandlerExMessage = 'exception from domain error handler';
 
diff --git a/test/parallel/test-env-newprotomethod-remove-unnecessary-prototypes.js b/test/parallel/test-env-newprotomethod-remove-unnecessary-prototypes.js
index a2e2dabab0ffb2ed8828933cadcea95e3a87a38e..deb7993a14582513b5a934a912832a92d1f5987f 100644
--- a/test/parallel/test-env-newprotomethod-remove-unnecessary-prototypes.js
+++ b/test/parallel/test-env-newprotomethod-remove-unnecessary-prototypes.js
@@ -13,7 +13,7 @@ const { internalBinding } = require('internal/test/binding');
   internalBinding('udp_wrap').UDP.prototype.send6,
   internalBinding('tcp_wrap').TCP.prototype.bind,
   internalBinding('udp_wrap').UDP.prototype.close,
-  internalBinding('tcp_wrap').TCP.prototype.open
+  internalBinding('tcp_wrap').TCP.prototype.open,
 ].forEach((binding, i) => {
   assert.strictEqual('prototype' in binding, false, `Test ${i} failed`);
 });
diff --git a/test/parallel/test-env-var-no-warnings.js b/test/parallel/test-env-var-no-warnings.js
index cf90c2759d9ad70102637444711a25878caf4682..b6164da1039a555d065c8950ff938477a0092067 100644
--- a/test/parallel/test-env-var-no-warnings.js
+++ b/test/parallel/test-env-var-no-warnings.js
@@ -17,7 +17,7 @@ if (process.argv[2] === 'child') {
       if (env.NODE_NO_WARNINGS === '1')
         assert.strictEqual(stderr, '');
       else
-        assert(/Warning: foo$/.test(stderr.trim()));
+        assert.match(stderr.trim(), /Warning: foo\n/);
     }));
   }
 
diff --git a/test/parallel/test-err-name-deprecation.js b/test/parallel/test-err-name-deprecation.js
index 58dff38364c81846d20bdbf9c0501f94e577fd4f..5f3fb28f1006633fc7da8d353ce9e892c1b130d8 100644
--- a/test/parallel/test-err-name-deprecation.js
+++ b/test/parallel/test-err-name-deprecation.js
@@ -9,7 +9,7 @@ common.expectWarning({
      'DEP0111'],
     ['Directly calling process.binding(\'uv\').errname(<val>) is being ' +
      'deprecated. Please make sure to use util.getSystemErrorName() instead.',
-     'DEP0119']
+     'DEP0119'],
   ]
 });
 
diff --git a/test/parallel/test-error-prepare-stack-trace.js b/test/parallel/test-error-prepare-stack-trace.js
index 2ace9c8d71491dda2821ca8e16e332a2376739f3..28ecdd25f50135390937e10cc16c7d416dc0b99b 100644
--- a/test/parallel/test-error-prepare-stack-trace.js
+++ b/test/parallel/test-error-prepare-stack-trace.js
@@ -13,7 +13,7 @@ const assert = require('assert');
   try {
     throw new Error('foo');
   } catch (err) {
-    err.stack;
+    err.stack; // eslint-disable-line no-unused-expressions
   }
   assert(prepareCalled);
 }
diff --git a/test/parallel/test-error-serdes.js b/test/parallel/test-error-serdes.js
index f01dc0d6a8a81d3a143261c7154d2d259eccd673..a65781c25eb261bb2715f5073a2e5d788c101434 100644
--- a/test/parallel/test-error-serdes.js
+++ b/test/parallel/test-error-serdes.js
@@ -49,3 +49,20 @@ assert.strictEqual(cycle(Function), '[Function: Function]');
   assert.strictEqual(err.name, 'TypeError');
   assert.strictEqual(err.code, 'ERR_INVALID_ARG_TYPE');
 }
+
+{
+  let called = false;
+  class DynamicError extends Error {
+    get type() {
+      called = true;
+      return 'dynamic';
+    }
+
+    get shouldIgnoreError() {
+      throw new Error();
+    }
+  }
+
+  serializeError(new DynamicError());
+  assert.deepStrictEqual(called, true);
+}
diff --git a/test/parallel/test-errors-systemerror.js b/test/parallel/test-errors-systemerror.js
index e801871f40af2c2f09215e78ad8196cf4e6b070c..2a20588e75b386e199f4c42d133273a50d29785d 100644
--- a/test/parallel/test-errors-systemerror.js
+++ b/test/parallel/test-errors-systemerror.js
@@ -9,7 +9,7 @@ assert.throws(
   () => { new SystemError(); },
   {
     name: 'TypeError',
-    message: 'Cannot read property \'match\' of undefined'
+    message: 'String.prototype.match called on null or undefined'
   }
 );
 
diff --git a/test/parallel/test-eslint-alphabetize-errors.js b/test/parallel/test-eslint-alphabetize-errors.js
index a9bc26d7f0540a36ff923d5cdf214a9a97a17ce5..df822f274095200e2a6661e80ae628ebe379b54e 100644
--- a/test/parallel/test-eslint-alphabetize-errors.js
+++ b/test/parallel/test-eslint-alphabetize-errors.js
@@ -14,7 +14,7 @@ new RuleTester().run('alphabetize-errors', rule, {
       E('AAA', 'foo');
       E('BBB', 'bar');
       E('CCC', 'baz');
-    `
+    `,
   ],
   invalid: [
     {
@@ -24,6 +24,6 @@ new RuleTester().run('alphabetize-errors', rule, {
         E('CCC', 'baz');
       `,
       errors: [{ message: 'Out of ASCIIbetical order - BBB >= AAA', line: 3 }]
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-async-iife-no-unused-result.js b/test/parallel/test-eslint-async-iife-no-unused-result.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e7f60c183b830a8bd682258a62fa621ecb0c919
--- /dev/null
+++ b/test/parallel/test-eslint-async-iife-no-unused-result.js
@@ -0,0 +1,49 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/async-iife-no-unused-result');
+
+const message = 'The result of an immediately-invoked async function needs ' +
+  'to be used (e.g. with `.then(common.mustCall())`)';
+
+const tester = new RuleTester({ parserOptions: { ecmaVersion: 8 } });
+tester.run('async-iife-no-unused-result', rule, {
+  valid: [
+    '(() => {})()',
+    '(async () => {})',
+    '(async () => {})().then()',
+    '(async () => {})().catch()',
+    '(function () {})()',
+    '(async function () {})',
+    '(async function () {})().then()',
+    '(async function () {})().catch()',
+  ],
+  invalid: [
+    {
+      code: '(async () => {})()',
+      errors: [{ message }],
+      output: '(async () => {})()',
+    },
+    {
+      code: '(async function() {})()',
+      errors: [{ message }],
+      output: '(async function() {})()',
+    },
+    {
+      code: "const common = require('../common');(async () => {})()",
+      errors: [{ message }],
+      output: "const common = require('../common');(async () => {})()" +
+        '.then(common.mustCall())',
+    },
+    {
+      code: "const common = require('../common');(async function() {})()",
+      errors: [{ message }],
+      output: "const common = require('../common');(async function() {})()" +
+        '.then(common.mustCall())',
+    },
+  ]
+});
diff --git a/test/parallel/test-eslint-crypto-check.js b/test/parallel/test-eslint-crypto-check.js
index 0a973f4c9c951da9036d87c249aa1ba23c1a4b1e..164149131a9758a426212c39b68c64bda11bc9a6 100644
--- a/test/parallel/test-eslint-crypto-check.js
+++ b/test/parallel/test-eslint-crypto-check.js
@@ -27,7 +27,7 @@ new RuleTester().run('crypto-check', rule, {
       common.skip("missing crypto");
     }
     internalBinding("crypto");
-    `
+    `,
   ],
   invalid: [
     {
@@ -71,6 +71,6 @@ new RuleTester().run('crypto-check', rule, {
               '}\n' +
               'if (common.foo) {}\n' +
               'internalBinding("crypto")'
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-documented-errors.js b/test/parallel/test-eslint-documented-errors.js
index a047ecd35847e023ba0fa9024c256b9aafb4aa29..e8abd38a983e5bda6ab469a92ec8c7dc39e98d4a 100644
--- a/test/parallel/test-eslint-documented-errors.js
+++ b/test/parallel/test-eslint-documented-errors.js
@@ -14,7 +14,7 @@ new RuleTester().run('documented-errors', rule, {
   valid: [
     `
       E('ERR_ASSERTION', 'foo');
-    `
+    `,
   ],
   invalid: [
     {
@@ -30,8 +30,8 @@ new RuleTester().run('documented-errors', rule, {
           message:
             `doc/api/errors.md does not have an anchor for "${invalidCode}"`,
           line: 2
-        }
+        },
       ]
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-eslint-check.js b/test/parallel/test-eslint-eslint-check.js
index c1ee3d501f0eec6f19ea8cadcc46c922ce485b64..28ec2e1f10fdb3249d313edb5da8051f6fffef17 100644
--- a/test/parallel/test-eslint-eslint-check.js
+++ b/test/parallel/test-eslint-eslint-check.js
@@ -18,7 +18,7 @@ new RuleTester().run('eslint-check', rule, {
     'foo;',
     'require("common")\n' +
       'common.skipIfEslintMissing();\n' +
-      'require("../../tools/node_modules/eslint")'
+      'require("../../tools/node_modules/eslint")',
   ],
   invalid: [
     {
@@ -28,6 +28,6 @@ new RuleTester().run('eslint-check', rule, {
       output: 'require("common")\n' +
               'common.skipIfEslintMissing();\n' +
               'require("../../tools/node_modules/eslint").RuleTester'
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-inspector-check.js b/test/parallel/test-eslint-inspector-check.js
index cf9f60e94505b8ff21eed98ff0f3bf22936b7d7c..2d945c3da331881807f465534a09d8858694df68 100644
--- a/test/parallel/test-eslint-inspector-check.js
+++ b/test/parallel/test-eslint-inspector-check.js
@@ -17,7 +17,7 @@ new RuleTester().run('inspector-check', rule, {
     'foo;',
     'require("common")\n' +
       'common.skipIfInspectorDisabled();\n' +
-      'require("inspector")'
+      'require("inspector")',
   ],
   invalid: [
     {
@@ -27,6 +27,6 @@ new RuleTester().run('inspector-check', rule, {
       output: 'require("common")\n' +
               'common.skipIfInspectorDisabled();\n' +
               'require("inspector")'
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-no-array-destructuring.js b/test/parallel/test-eslint-no-array-destructuring.js
new file mode 100644
index 0000000000000000000000000000000000000000..be59ee69309755df35e2569e0b5f1b5826b06a2a
--- /dev/null
+++ b/test/parallel/test-eslint-no-array-destructuring.js
@@ -0,0 +1,141 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+common.skipIfEslintMissing();
+
+const { RuleTester } = require('../../tools/node_modules/eslint');
+const rule = require('../../tools/eslint-rules/no-array-destructuring');
+
+const USE_OBJ_DESTRUCTURING =
+  'Use object destructuring instead of array destructuring.';
+const USE_ARRAY_METHODS =
+  'Use primordials.ArrayPrototypeSlice to avoid unsafe array iteration.';
+
+new RuleTester({
+  parserOptions: { ecmaVersion: 2021 },
+  env: { es6: true }
+})
+  .run('no-array-destructuring', rule, {
+    valid: [
+      'const first = [1, 2, 3][0];',
+      'const {0:first} = [1, 2, 3];',
+      '({1:elem} = array);',
+      'function name(param, { 0: key, 1: value },) {}',
+    ],
+    invalid: [
+      {
+        code: 'const [Array] = args;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'const {0:Array} = args;'
+      },
+      {
+        code: 'const [ , res] = args;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'const {  1:res} = args;',
+      },
+      {
+        code: '[, elem] = options;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: '({ 1:elem} = options);',
+      },
+      {
+        code: 'const {values:[elem]} = options;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'const {values:{0:elem}} = options;',
+      },
+      {
+        code: '[[[elem]]] = options;',
+        errors: [
+          { message: USE_OBJ_DESTRUCTURING },
+          { message: USE_OBJ_DESTRUCTURING },
+          { message: USE_OBJ_DESTRUCTURING },
+        ],
+        output: '({0:[[elem]]} = options);',
+      },
+      {
+        code: '[, ...rest] = options;',
+        errors: [{ message: USE_ARRAY_METHODS }],
+      },
+      {
+        code: 'for(const [key, value] of new Map);',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'for(const {0:key, 1:value} of new Map);',
+      },
+      {
+        code: 'let [first,,,fourth] = array;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'let {0:first,3:fourth} = array;',
+      },
+      {
+        code: 'let [,second,,fourth] = array;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'let {1:second,3:fourth} = array;',
+      },
+      {
+        code: 'let [ ,,,fourth ] = array;',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'let { 3:fourth } = array;',
+      },
+      {
+        code: 'let [,,,fourth, fifth,, minorFall, majorLift,...music] = arr;',
+        errors: [{ message: USE_ARRAY_METHODS }],
+      },
+      {
+        code: 'function map([key, value]) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'function map({0:key, 1:value}) {}',
+      },
+      {
+        code: 'function map([key, value],) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'function map({0:key, 1:value},) {}',
+      },
+      {
+        code: '(function([key, value]) {})',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: '(function({0:key, 1:value}) {})',
+      },
+      {
+        code: '(function([key, value] = [null, 0]) {})',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: '(function({0:key, 1:value} = [null, 0]) {})',
+      },
+      {
+        code: 'function map([key, ...values]) {}',
+        errors: [{ message: USE_ARRAY_METHODS }],
+      },
+      {
+        code: 'function map([key, value], ...args) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'function map({0:key, 1:value}, ...args) {}',
+      },
+      {
+        code: 'async function map([key, value], ...args) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'async function map({0:key, 1:value}, ...args) {}',
+      },
+      {
+        code: 'async function* generator([key, value], ...args) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'async function* generator({0:key, 1:value}, ...args) {}',
+      },
+      {
+        code: 'function* generator([key, value], ...args) {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'function* generator({0:key, 1:value}, ...args) {}',
+      },
+      {
+        code: 'const cb = ([key, value], ...args) => {}',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'const cb = ({0:key, 1:value}, ...args) => {}',
+      },
+      {
+        code: 'class name{ method([key], ...args){} }',
+        errors: [{ message: USE_OBJ_DESTRUCTURING }],
+        output: 'class name{ method({0:key}, ...args){} }',
+      },
+    ]
+  });
diff --git a/test/parallel/test-eslint-no-unescaped-regexp-dot.js b/test/parallel/test-eslint-no-unescaped-regexp-dot.js
index 69600d80731302fd829744c93b4e37f67035418f..7cf69877ca12ed3d73ef7f51eb917b0e24284ea6 100644
--- a/test/parallel/test-eslint-no-unescaped-regexp-dot.js
+++ b/test/parallel/test-eslint-no-unescaped-regexp-dot.js
@@ -17,7 +17,7 @@ new RuleTester().run('no-unescaped-regexp-dot', rule, {
     '/.*/',
     '/.?/',
     '/.{5}/',
-    String.raw`/\\\./`
+    String.raw`/\\\./`,
   ],
   invalid: [
     {
@@ -27,6 +27,6 @@ new RuleTester().run('no-unescaped-regexp-dot', rule, {
     {
       code: String.raw`/\\./`,
       errors: [{ message: 'Unescaped dot character in regular expression' }]
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-non-ascii-character.js b/test/parallel/test-eslint-non-ascii-character.js
new file mode 100644
index 0000000000000000000000000000000000000000..0b4a09f813431b7b0249487ce3d7c9d30e134d8a
--- /dev/null
+++ b/test/parallel/test-eslint-non-ascii-character.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/non-ascii-character');
+
+new RuleTester().run('non-ascii-characters', rule, {
+  valid: [
+    {
+      code: 'console.log("fhqwhgads")',
+      options: []
+    },
+  ],
+  invalid: [
+    {
+      code: 'console.log("μ")',
+      options: [],
+      errors: [{ message: "Non-ASCII character 'μ' detected." }],
+    },
+  ]
+});
diff --git a/test/parallel/test-eslint-prefer-assert-iferror.js b/test/parallel/test-eslint-prefer-assert-iferror.js
index 342459f0b77ce4f995f0f60e89aadbf645b1dd34..5ccb7883393f46bd7f879741a85d15090999dda0 100644
--- a/test/parallel/test-eslint-prefer-assert-iferror.js
+++ b/test/parallel/test-eslint-prefer-assert-iferror.js
@@ -14,7 +14,7 @@ new RuleTester().run('prefer-assert-iferror', rule, {
     'assert.ifError(err);',
     'if (err) throw somethingElse;',
     'throw err;',
-    'if (err) { throw somethingElse; }'
+    'if (err) { throw somethingElse; }',
   ],
   invalid: [
     {
@@ -30,6 +30,6 @@ new RuleTester().run('prefer-assert-iferror', rule, {
       errors: [{ message: 'Use assert.ifError(error) instead.' }],
       output: 'require("assert");\n' +
               'assert.ifError(error);'
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-prefer-assert-methods.js b/test/parallel/test-eslint-prefer-assert-methods.js
index a5829cdce3054f5b57e96fc1bee03b9eadaaead7..3271f6ab1856b0927b2cae5efb47c8c73eb59a27 100644
--- a/test/parallel/test-eslint-prefer-assert-methods.js
+++ b/test/parallel/test-eslint-prefer-assert-methods.js
@@ -21,7 +21,7 @@ new RuleTester().run('prefer-assert-methods', rule, {
     'assert(foo != bar && baz);',
     'assert.ok(foo);',
     'assert.ok(foo != bar);',
-    'assert.ok(foo === bar && baz);'
+    'assert.ok(foo === bar && baz);',
   ],
   invalid: [
     {
@@ -51,6 +51,6 @@ new RuleTester().run('prefer-assert-methods', rule, {
         message: "'assert.notStrictEqual' should be used instead of '!=='"
       }],
       output: 'assert.notStrictEqual(foo, bar);'
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-prefer-common-mustnotcall.js b/test/parallel/test-eslint-prefer-common-mustnotcall.js
index dba244a2a9fa8917177c8c4dd42d16d510d86eb9..5c360bb1ecbec60e775d9e0389443d6168b60ef6 100644
--- a/test/parallel/test-eslint-prefer-common-mustnotcall.js
+++ b/test/parallel/test-eslint-prefer-common-mustnotcall.js
@@ -16,7 +16,7 @@ new RuleTester().run('prefer-common-mustnotcall', rule, {
   valid: [
     'common.mustNotCall(fn)',
     'common.mustCall(fn)',
-    'common.mustCall(fn, 1)'
+    'common.mustCall(fn, 1)',
   ],
   invalid: [
     {
@@ -26,6 +26,6 @@ new RuleTester().run('prefer-common-mustnotcall', rule, {
     {
       code: 'common.mustCall(0)',
       errors: [{ message }]
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-prefer-common-mustsucceed.js b/test/parallel/test-eslint-prefer-common-mustsucceed.js
new file mode 100644
index 0000000000000000000000000000000000000000..302b6a0bee4f3857dbe02592fe6e8aa7ad5b2e07
--- /dev/null
+++ b/test/parallel/test-eslint-prefer-common-mustsucceed.js
@@ -0,0 +1,52 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-common-mustsucceed');
+
+const msg1 = 'Please use common.mustSucceed instead of ' +
+             'common.mustCall(assert.ifError).';
+const msg2 = 'Please use common.mustSucceed instead of ' +
+             'common.mustCall with assert.ifError.';
+
+new RuleTester({
+  parserOptions: { ecmaVersion: 2015 }
+}).run('prefer-common-mustsucceed', rule, {
+  valid: [
+    'foo((err) => assert.ifError(err))',
+    'foo(function(err) { assert.ifError(err) })',
+    'foo(assert.ifError)',
+    'common.mustCall((err) => err)',
+  ],
+  invalid: [
+    {
+      code: 'common.mustCall(assert.ifError)',
+      errors: [{ message: msg1 }]
+    },
+    {
+      code: 'common.mustCall((err) => assert.ifError(err))',
+      errors: [{ message: msg2 }]
+    },
+    {
+      code: 'common.mustCall((e) => assert.ifError(e))',
+      errors: [{ message: msg2 }]
+    },
+    {
+      code: 'common.mustCall(function(e) { assert.ifError(e); })',
+      errors: [{ message: msg2 }]
+    },
+    {
+      code: 'common.mustCall(function(e) { return assert.ifError(e); })',
+      errors: [{ message: msg2 }]
+    },
+    {
+      code: 'common.mustCall(function(e) {{ assert.ifError(e); }})',
+      errors: [{ message: msg2 }]
+    },
+  ]
+});
diff --git a/test/parallel/test-eslint-prefer-primordials.js b/test/parallel/test-eslint-prefer-primordials.js
new file mode 100644
index 0000000000000000000000000000000000000000..143ddd2b0d118ff71d5e0c43f88d1402abd4dc4f
--- /dev/null
+++ b/test/parallel/test-eslint-prefer-primordials.js
@@ -0,0 +1,175 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-primordials');
+
+new RuleTester({
+  parserOptions: { ecmaVersion: 6 },
+  env: { es6: true }
+})
+  .run('prefer-primordials', rule, {
+    valid: [
+      'new Array()',
+      'JSON.stringify({})',
+      'class A { *[Symbol.iterator] () { yield "a"; } }',
+      'const a = { *[Symbol.iterator] () { yield "a"; } }',
+      'Object.defineProperty(o, Symbol.toStringTag, { value: "o" })',
+      'parseInt("10")',
+      `
+        const { Reflect } = primordials;
+        module.exports = function() {
+          const { ownKeys } = Reflect;
+        }
+      `,
+      {
+        code: 'const { Array } = primordials; new Array()',
+        options: [{ name: 'Array' }]
+      },
+      {
+        code: 'const { JSONStringify } = primordials; JSONStringify({})',
+        options: [{ name: 'JSON' }]
+      },
+      {
+        code: 'const { SymbolFor } = primordials; SymbolFor("xxx")',
+        options: [{ name: 'Symbol' }]
+      },
+      {
+        code: `
+          const { SymbolIterator } = primordials;
+          class A { *[SymbolIterator] () { yield "a"; } }
+        `,
+        options: [{ name: 'Symbol' }]
+      },
+      {
+        code: `
+          const { Symbol } = primordials;
+          const a = { *[Symbol.iterator] () { yield "a"; } }
+        `,
+        options: [{ name: 'Symbol', ignore: ['iterator'] }]
+      },
+      {
+        code: `
+          const { ObjectDefineProperty, Symbol } = primordials;
+          ObjectDefineProperty(o, Symbol.toStringTag, { value: "o" })
+        `,
+        options: [{ name: 'Symbol', ignore: ['toStringTag'] }]
+      },
+      {
+        code: 'const { Symbol } = primordials; Symbol.for("xxx")',
+        options: [{ name: 'Symbol', ignore: ['for'] }]
+      },
+      {
+        code: 'const { NumberParseInt } = primordials; NumberParseInt("xxx")',
+        options: [{ name: 'parseInt', into: 'Number' }]
+      },
+      {
+        code: `
+          const { ReflectOwnKeys } = primordials;
+          module.exports = function() {
+            ReflectOwnKeys({})
+          }
+        `,
+        options: [{ name: 'Reflect' }],
+      },
+      {
+        code: 'const { Map } = primordials; new Map()',
+        options: [{ name: 'Map', into: 'Safe' }],
+      },
+    ],
+    invalid: [
+      {
+        code: 'new Array()',
+        options: [{ name: 'Array' }],
+        errors: [{ message: /const { Array } = primordials/ }]
+      },
+      {
+        code: 'JSON.parse("{}")',
+        options: [{ name: 'JSON' }],
+        errors: [
+          { message: /const { JSONParse } = primordials/ },
+        ]
+      },
+      {
+        code: 'const { JSON } = primordials; JSON.parse("{}")',
+        options: [{ name: 'JSON' }],
+        errors: [{ message: /const { JSONParse } = primordials/ }]
+      },
+      {
+        code: 'Symbol.for("xxx")',
+        options: [{ name: 'Symbol' }],
+        errors: [
+          { message: /const { SymbolFor } = primordials/ },
+        ]
+      },
+      {
+        code: 'const { Symbol } = primordials; Symbol.for("xxx")',
+        options: [{ name: 'Symbol' }],
+        errors: [{ message: /const { SymbolFor } = primordials/ }]
+      },
+      {
+        code: `
+          const { Symbol } = primordials;
+          class A { *[Symbol.iterator] () { yield "a"; } }
+        `,
+        options: [{ name: 'Symbol' }],
+        errors: [{ message: /const { SymbolIterator } = primordials/ }]
+      },
+      {
+        code: `
+          const { Symbol } = primordials;
+          const a = { *[Symbol.iterator] () { yield "a"; } }
+        `,
+        options: [{ name: 'Symbol' }],
+        errors: [{ message: /const { SymbolIterator } = primordials/ }]
+      },
+      {
+        code: `
+          const { ObjectDefineProperty, Symbol } = primordials;
+          ObjectDefineProperty(o, Symbol.toStringTag, { value: "o" })
+        `,
+        options: [{ name: 'Symbol' }],
+        errors: [{ message: /const { SymbolToStringTag } = primordials/ }]
+      },
+      {
+        code: `
+          const { Number } = primordials;
+          Number.parseInt('10')
+        `,
+        options: [{ name: 'Number' }],
+        errors: [{ message: /const { NumberParseInt } = primordials/ }]
+      },
+      {
+        code: 'parseInt("10")',
+        options: [{ name: 'parseInt', into: 'Number' }],
+        errors: [{ message: /const { NumberParseInt } = primordials/ }]
+      },
+      {
+        code: `
+          module.exports = function() {
+            const { ownKeys } = Reflect;
+          }
+        `,
+        options: [{ name: 'Reflect' }],
+        errors: [{ message: /const { ReflectOwnKeys } = primordials/ }]
+      },
+      {
+        code: 'new Map()',
+        options: [{ name: 'Map', into: 'Safe' }],
+        errors: [{ message: /const { SafeMap } = primordials/ }]
+      },
+      {
+        code: `
+          const { Function } = primordials;
+          const noop = Function.prototype;
+        `,
+        options: [{ name: 'Function' }],
+        errors: [{ message: /const { FunctionPrototype } = primordials/ }]
+      },
+    ]
+  });
diff --git a/test/parallel/test-eslint-prefer-util-format-errors.js b/test/parallel/test-eslint-prefer-util-format-errors.js
index 762fec28b1f1d8a6cae1d79d665c99fdb568a2e9..a6c2662a382418bc9428b09594fc07290fa4a115 100644
--- a/test/parallel/test-eslint-prefer-util-format-errors.js
+++ b/test/parallel/test-eslint-prefer-util-format-errors.js
@@ -17,7 +17,7 @@ new RuleTester({ parserOptions: { ecmaVersion: 6 } })
       'E(\'ABC\', \'abc\');',
       'E(\'ABC\', (arg1, arg2) => `${arg2}${arg1}`);',
       'E(\'ABC\', (arg1, arg2) => `${arg1}{arg2.something}`);',
-      'E(\'ABC\', (arg1, arg2) => fn(arg1, arg2));'
+      'E(\'ABC\', (arg1, arg2) => fn(arg1, arg2));',
     ],
     invalid: [
       {
@@ -26,6 +26,6 @@ new RuleTester({ parserOptions: { ecmaVersion: 6 } })
           message: 'Please use a printf-like formatted string that ' +
                    'util.format can consume.'
         }]
-      }
+      },
     ]
   });
diff --git a/test/parallel/test-eslint-require-common-first.js b/test/parallel/test-eslint-require-common-first.js
index 018d4185d527e5fa0c6f1197f603ebc45c73c49f..b3d132e11fdc3f693544f4f5f1b75482f910a258 100644
--- a/test/parallel/test-eslint-require-common-first.js
+++ b/test/parallel/test-eslint-require-common-first.js
@@ -14,7 +14,7 @@ new RuleTester().run('require-common-first', rule, {
     {
       code: 'require("common")\n' +
             'require("assert")'
-    }
+    },
   ],
   invalid: [
     {
@@ -22,6 +22,6 @@ new RuleTester().run('require-common-first', rule, {
             'require("common")',
       errors: [{ message: 'Mandatory module "common" must be loaded ' +
                           'before any other modules.' }]
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eslint-required-modules.js b/test/parallel/test-eslint-required-modules.js
index e81a7d4b241353a48f4747d39dbb2e92a98e90fb..c891e2350711a42c1177b629c8e384edf1cc5b51 100644
--- a/test/parallel/test-eslint-required-modules.js
+++ b/test/parallel/test-eslint-required-modules.js
@@ -46,6 +46,6 @@ new RuleTester().run('required-modules', rule, {
       code: 'require("somethingElse")',
       options: [{ common: 'common' }],
       errors: [{ message: 'Mandatory module "common" must be loaded.' }]
-    }
+    },
   ]
 });
diff --git a/test/parallel/test-eval-strict-referenceerror.js b/test/parallel/test-eval-strict-referenceerror.js
index a96478a1bedaae708b3df2671c5085e7c3c5c8a7..97f2b15ba0ed3d2456252546cb68614d5dba7f9e 100644
--- a/test/parallel/test-eval-strict-referenceerror.js
+++ b/test/parallel/test-eval-strict-referenceerror.js
@@ -15,7 +15,7 @@ function test() {
     'function bar() {',
     '\'use strict\';',
     'return foo; // foo isn\'t captured in 0.10',
-    '};'
+    '};',
   ].join('\n');
 
   eval(code);
diff --git a/test/parallel/test-event-emitter-emit-context.js b/test/parallel/test-event-emitter-emit-context.js
new file mode 100644
index 0000000000000000000000000000000000000000..82e4b595185a591778cdd61891b7802bdcda44ab
--- /dev/null
+++ b/test/parallel/test-event-emitter-emit-context.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+
+// Test emit called by other context
+const EE = new EventEmitter();
+
+// Works as expected if the context has no `constructor.name`
+{
+  const ctx = Object.create(null);
+  assert.throws(
+    () => EE.emit.call(ctx, 'error', new Error('foo')),
+    common.expectsError({ name: 'Error', message: 'foo' })
+  );
+}
+
+assert.strictEqual(EE.emit.call({}, 'foo'), false);
diff --git a/test/parallel/test-event-emitter-special-event-names.js b/test/parallel/test-event-emitter-special-event-names.js
index 7ff781f0f90c5a436c316a0a6fc30abed9977947..f34faba9468cc2bfa646c3eabf1365178c64edf9 100644
--- a/test/parallel/test-event-emitter-special-event-names.js
+++ b/test/parallel/test-event-emitter-special-event-names.js
@@ -19,7 +19,7 @@ ee.on('toString', handler);
 assert.deepStrictEqual(ee.eventNames(), [
   '__proto__',
   '__defineGetter__',
-  'toString'
+  'toString',
 ]);
 
 assert.deepStrictEqual(ee.listeners('__proto__'), [handler]);
diff --git a/test/parallel/test-event-on-async-iterator.js b/test/parallel/test-events-on-async-iterator.js
similarity index 51%
rename from test/parallel/test-event-on-async-iterator.js
rename to test/parallel/test-events-on-async-iterator.js
index ff5d8cdaf2aea0562bb30b23bf3eade51252ebc7..0b7e0a07e939e3e46cfac4ddb8946283290b7393 100644
--- a/test/parallel/test-event-on-async-iterator.js
+++ b/test/parallel/test-events-on-async-iterator.js
@@ -1,8 +1,14 @@
+// Flags: --expose-internals --no-warnings --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
 const assert = require('assert');
 const { on, EventEmitter } = require('events');
+const {
+  EventTarget,
+  NodeEventTarget,
+  Event
+} = require('internal/event_target');
 
 async function basic() {
   const ee = new EventEmitter();
@@ -31,6 +37,13 @@ async function basic() {
   assert.strictEqual(ee.listenerCount('error'), 0);
 }
 
+async function invalidArgType() {
+  assert.throws(() => on({}, 'foo'), common.expectsError({
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+  }));
+}
+
 async function error() {
   const ee = new EventEmitter();
   const _err = new Error('kaboom');
@@ -115,7 +128,7 @@ async function next() {
   const results = await Promise.all([
     iterable.next(),
     iterable.next(),
-    iterable.next()
+    iterable.next(),
   ]);
 
   assert.deepStrictEqual(results, [{
@@ -145,7 +158,7 @@ async function nextError() {
   const results = await Promise.allSettled([
     iterable.next(),
     iterable.next(),
-    iterable.next()
+    iterable.next(),
   ]);
   assert.deepStrictEqual(results, [{
     status: 'rejected',
@@ -204,15 +217,175 @@ async function iterableThrow() {
   assert.strictEqual(ee.listenerCount('error'), 0);
 }
 
+async function eventTarget() {
+  const et = new EventTarget();
+  const tick = () => et.dispatchEvent(new Event('tick'));
+  const interval = setInterval(tick, 0);
+  let count = 0;
+  for await (const [ event ] of on(et, 'tick')) {
+    count++;
+    assert.strictEqual(event.type, 'tick');
+    if (count >= 5) {
+      break;
+    }
+  }
+  assert.strictEqual(count, 5);
+  clearInterval(interval);
+}
+
+async function errorListenerCount() {
+  const et = new EventEmitter();
+  on(et, 'foo');
+  assert.strictEqual(et.listenerCount('error'), 1);
+}
+
+async function nodeEventTarget() {
+  const et = new NodeEventTarget();
+  const tick = () => et.dispatchEvent(new Event('tick'));
+  const interval = setInterval(tick, 0);
+  let count = 0;
+  for await (const [ event] of on(et, 'tick')) {
+    count++;
+    assert.strictEqual(event.type, 'tick');
+    if (count >= 5) {
+      break;
+    }
+  }
+  assert.strictEqual(count, 5);
+  clearInterval(interval);
+}
+
+async function abortableOnBefore() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+  ac.abort();
+  [1, {}, null, false, 'hi'].forEach((signal) => {
+    assert.throws(() => on(ee, 'foo', { signal }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+  assert.throws(() => on(ee, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+}
+
+async function eventTargetAbortableOnBefore() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+  ac.abort();
+  [1, {}, null, false, 'hi'].forEach((signal) => {
+    assert.throws(() => on(et, 'foo', { signal }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+  assert.throws(() => on(et, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+}
+
+async function abortableOnAfter() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+
+  const i = setInterval(() => ee.emit('foo', 'foo'), 10);
+
+  async function foo() {
+    for await (const f of on(ee, 'foo', { signal: ac.signal })) {
+      assert.strictEqual(f, 'foo');
+    }
+  }
+
+  foo().catch(common.mustCall((error) => {
+    assert.strictEqual(error.name, 'AbortError');
+  })).finally(() => {
+    clearInterval(i);
+  });
+
+  process.nextTick(() => ac.abort());
+}
+
+async function eventTargetAbortableOnAfter() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+
+  const i = setInterval(() => et.dispatchEvent(new Event('foo')), 10);
+
+  async function foo() {
+    for await (const f of on(et, 'foo', { signal: ac.signal })) {
+      assert(f);
+    }
+  }
+
+  foo().catch(common.mustCall((error) => {
+    assert.strictEqual(error.name, 'AbortError');
+  })).finally(() => {
+    clearInterval(i);
+  });
+
+  process.nextTick(() => ac.abort());
+}
+
+async function eventTargetAbortableOnAfter2() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+
+  const i = setInterval(() => et.dispatchEvent(new Event('foo')), 10);
+
+  async function foo() {
+    for await (const f of on(et, 'foo', { signal: ac.signal })) {
+      assert(f);
+      // Cancel after a single event has been triggered.
+      ac.abort();
+    }
+  }
+
+  foo().catch(common.mustCall((error) => {
+    assert.strictEqual(error.name, 'AbortError');
+  })).finally(() => {
+    clearInterval(i);
+  });
+}
+
+async function abortableOnAfterDone() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+
+  const i = setInterval(() => ee.emit('foo', 'foo'), 1);
+  let count = 0;
+
+  async function foo() {
+    for await (const f of on(ee, 'foo', { signal: ac.signal })) {
+      assert.strictEqual(f[0], 'foo');
+      if (++count === 5)
+        break;
+    }
+    ac.abort();  // No error will occur
+  }
+
+  foo().finally(() => {
+    clearInterval(i);
+  });
+}
+
 async function run() {
   const funcs = [
     basic,
+    invalidArgType,
     error,
     errorDelayed,
     throwInLoop,
     next,
     nextError,
-    iterableThrow
+    iterableThrow,
+    eventTarget,
+    errorListenerCount,
+    nodeEventTarget,
+    abortableOnBefore,
+    abortableOnAfter,
+    eventTargetAbortableOnBefore,
+    eventTargetAbortableOnAfter,
+    eventTargetAbortableOnAfter2,
+    abortableOnAfterDone,
   ];
 
   for (const fn of funcs) {
diff --git a/test/parallel/test-events-once.js b/test/parallel/test-events-once.js
index d07492ea63fa8e0d7852489a6421219b8a13f5d8..867987da9ef38694b916b7eb6ac413d936caae15 100644
--- a/test/parallel/test-events-once.js
+++ b/test/parallel/test-events-once.js
@@ -1,55 +1,15 @@
 'use strict';
+// Flags: --expose-internals --no-warnings --experimental-abortcontroller
 
 const common = require('../common');
 const { once, EventEmitter } = require('events');
-const { strictEqual, deepStrictEqual } = require('assert');
-
-class EventTargetMock {
-  constructor() {
-    this.events = {};
-  }
-
-  addEventListener = common.mustCall(function(name, listener, options) {
-    if (!(name in this.events)) {
-      this.events[name] = { listeners: [], options };
-    }
-    this.events[name].listeners.push(listener);
-  });
-
-  removeEventListener = common.mustCall(function(name, callback) {
-    if (!(name in this.events)) {
-      return;
-    }
-    const event = this.events[name];
-    const stack = event.listeners;
-
-    for (let i = 0, l = stack.length; i < l; i++) {
-      if (stack[i] === callback) {
-        stack.splice(i, 1);
-        if (stack.length === 0) {
-          Reflect.deleteProperty(this.events, name);
-        }
-        return;
-      }
-    }
-  });
-
-  dispatchEvent = function(name, ...arg) {
-    if (!(name in this.events)) {
-      return true;
-    }
-    const event = this.events[name];
-    const stack = event.listeners.slice();
-
-    for (let i = 0, l = stack.length; i < l; i++) {
-      stack[i].apply(this, arg);
-      if (event.options.once) {
-        this.removeEventListener(name, stack[i]);
-      }
-    }
-    return !name.defaultPrevented;
-  };
-}
+const {
+  strictEqual,
+  deepStrictEqual,
+  fail,
+  rejects,
+} = require('assert');
+const { EventTarget, Event } = require('internal/event_target');
 
 async function onceAnEvent() {
   const ee = new EventEmitter();
@@ -104,8 +64,6 @@ async function stopListeningAfterCatchingError() {
     ee.emit('myevent', 42, 24);
   });
 
-  process.on('multipleResolves', common.mustNotCall());
-
   try {
     await once(ee, 'myevent');
   } catch (_e) {
@@ -125,66 +83,115 @@ async function onceError() {
     ee.emit('error', expected);
   });
 
-  const [err] = await once(ee, 'error');
+  const promise = once(ee, 'error');
+  strictEqual(ee.listenerCount('error'), 1);
+  const [ err ] = await promise;
   strictEqual(err, expected);
   strictEqual(ee.listenerCount('error'), 0);
   strictEqual(ee.listenerCount('myevent'), 0);
 }
 
 async function onceWithEventTarget() {
-  const et = new EventTargetMock();
-
+  const et = new EventTarget();
+  const event = new Event('myevent');
   process.nextTick(() => {
-    et.dispatchEvent('myevent', 42);
+    et.dispatchEvent(event);
   });
   const [ value ] = await once(et, 'myevent');
-  strictEqual(value, 42);
-  strictEqual(Reflect.has(et.events, 'myevent'), false);
+  strictEqual(value, event);
 }
 
-async function onceWithEventTargetTwoArgs() {
-  const et = new EventTargetMock();
-
+async function onceWithEventTargetError() {
+  const et = new EventTarget();
+  const error = new Event('error');
   process.nextTick(() => {
-    et.dispatchEvent('myevent', 42, 24);
+    et.dispatchEvent(error);
   });
 
-  const value = await once(et, 'myevent');
-  deepStrictEqual(value, [42, 24]);
+  const [ err ] = await once(et, 'error');
+  strictEqual(err, error);
 }
 
-async function onceWithEventTargetError() {
-  const et = new EventTargetMock();
+async function prioritizesEventEmitter() {
+  const ee = new EventEmitter();
+  ee.addEventListener = fail;
+  ee.removeAllListeners = fail;
+  process.nextTick(() => ee.emit('foo'));
+  await once(ee, 'foo');
+}
 
-  const expected = new Error('kaboom');
-  process.nextTick(() => {
-    et.dispatchEvent('error', expected);
+async function abortSignalBefore() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+  ee.on('error', common.mustNotCall());
+  ac.abort();
+
+  await Promise.all([1, {}, 'hi', null, false].map((signal) => {
+    return rejects(once(ee, 'foo', { signal }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  }));
+
+  return rejects(once(ee, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
   });
-
-  const [err] = await once(et, 'error');
-  strictEqual(err, expected);
-  strictEqual(Reflect.has(et.events, 'error'), false);
 }
 
-async function assumesEventEmitterIfOnIsAFunction() {
+async function abortSignalAfter() {
   const ee = new EventEmitter();
-  ee.addEventListener = () => {};
+  const ac = new AbortController();
+  ee.on('error', common.mustNotCall());
+  const r = rejects(once(ee, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+  process.nextTick(() => ac.abort());
+  return r;
+}
 
-  const expected = new Error('kaboom');
-  let err;
+async function abortSignalAfterEvent() {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
   process.nextTick(() => {
-    ee.emit('error', expected);
+    ee.emit('foo');
+    ac.abort();
   });
+  await once(ee, 'foo', { signal: ac.signal });
+}
 
-  try {
-    await once(ee, 'myevent');
-  } catch (_e) {
-    err = _e;
-  }
+async function eventTargetAbortSignalBefore() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+  ac.abort();
 
-  strictEqual(err, expected);
-  strictEqual(ee.listenerCount('error'), 0);
-  strictEqual(ee.listenerCount('myevent'), 0);
+  await Promise.all([1, {}, 'hi', null, false].map((signal) => {
+    return rejects(once(et, 'foo', { signal }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  }));
+
+  return rejects(once(et, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+}
+
+async function eventTargetAbortSignalAfter() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+  const r = rejects(once(et, 'foo', { signal: ac.signal }), {
+    name: 'AbortError'
+  });
+  process.nextTick(() => ac.abort());
+  return r;
+}
+
+async function eventTargetAbortSignalAfterEvent() {
+  const et = new EventTarget();
+  const ac = new AbortController();
+  process.nextTick(() => {
+    et.dispatchEvent(new Event('foo'));
+    ac.abort();
+  });
+  await once(et, 'foo', { signal: ac.signal });
 }
 
 Promise.all([
@@ -194,7 +201,12 @@ Promise.all([
   stopListeningAfterCatchingError(),
   onceError(),
   onceWithEventTarget(),
-  onceWithEventTargetTwoArgs(),
   onceWithEventTargetError(),
-  assumesEventEmitterIfOnIsAFunction(),
+  prioritizesEventEmitter(),
+  abortSignalBefore(),
+  abortSignalAfter(),
+  abortSignalAfterEvent(),
+  eventTargetAbortSignalBefore(),
+  eventTargetAbortSignalAfter(),
+  eventTargetAbortSignalAfterEvent(),
 ]).then(common.mustCall());
diff --git a/test/parallel/test-events-static-geteventlisteners.js b/test/parallel/test-events-static-geteventlisteners.js
new file mode 100644
index 0000000000000000000000000000000000000000..d5e8c457f5d57f01af0b92998640bd3273482fb0
--- /dev/null
+++ b/test/parallel/test-events-static-geteventlisteners.js
@@ -0,0 +1,38 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+
+const {
+  deepStrictEqual,
+} = require('assert');
+
+const { getEventListeners, EventEmitter } = require('events');
+const { EventTarget } = require('internal/event_target');
+
+// Test getEventListeners on EventEmitter
+{
+  const fn1 = common.mustNotCall();
+  const fn2 = common.mustNotCall();
+  const emitter = new EventEmitter();
+  emitter.on('foo', fn1);
+  emitter.on('foo', fn2);
+  emitter.on('baz', fn1);
+  emitter.on('baz', fn1);
+  deepStrictEqual(getEventListeners(emitter, 'foo'), [fn1, fn2]);
+  deepStrictEqual(getEventListeners(emitter, 'bar'), []);
+  deepStrictEqual(getEventListeners(emitter, 'baz'), [fn1, fn1]);
+}
+// Test getEventListeners on EventTarget
+{
+  const fn1 = common.mustNotCall();
+  const fn2 = common.mustNotCall();
+  const target = new EventTarget();
+  target.addEventListener('foo', fn1);
+  target.addEventListener('foo', fn2);
+  target.addEventListener('baz', fn1);
+  target.addEventListener('baz', fn1);
+  deepStrictEqual(getEventListeners(target, 'foo'), [fn1, fn2]);
+  deepStrictEqual(getEventListeners(target, 'bar'), []);
+  deepStrictEqual(getEventListeners(target, 'baz'), [fn1]);
+}
diff --git a/test/parallel/test-eventtarget-memoryleakwarning.js b/test/parallel/test-eventtarget-memoryleakwarning.js
new file mode 100644
index 0000000000000000000000000000000000000000..060dd7472868a3fedf40cb7fc0f98fecd84ae447
--- /dev/null
+++ b/test/parallel/test-eventtarget-memoryleakwarning.js
@@ -0,0 +1,81 @@
+// Flags: --no-warnings --expose-internals --experimental-abortcontroller
+'use strict';
+const common = require('../common');
+const {
+  setMaxListeners,
+  EventEmitter
+} = require('events');
+const assert = require('assert');
+const { MessageChannel } = require('worker_threads');
+const { EventTarget } = require('internal/event_target');
+
+common.expectWarning({
+  MaxListenersExceededWarning: [
+    ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
+     'EventTarget. Use events.setMaxListeners() ' +
+     'to increase limit'],
+    ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
+     '[MessagePort [EventTarget]]. ' +
+     'Use events.setMaxListeners() to increase ' +
+     'limit'],
+    ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
+     '[MessagePort [EventTarget]]. ' +
+     'Use events.setMaxListeners() to increase ' +
+     'limit'],
+    ['Possible EventTarget memory leak detected. 3 foo listeners added to ' +
+     '[AbortSignal]. ' +
+     'Use events.setMaxListeners() to increase ' +
+     'limit'],
+  ],
+  ExperimentalWarning: [[
+    'AbortController is an experimental feature. This feature could change ' +
+    'at any time',
+  ]]
+});
+
+
+{
+  const et = new EventTarget();
+  setMaxListeners(2, et);
+  et.addEventListener('foo', () => {});
+  et.addEventListener('foo', () => {});
+  et.addEventListener('foo', () => {});
+}
+
+{
+  // No warning emitted because prior limit was only for that
+  // one EventTarget.
+  const et = new EventTarget();
+  et.addEventListener('foo', () => {});
+  et.addEventListener('foo', () => {});
+  et.addEventListener('foo', () => {});
+}
+
+{
+  const mc = new MessageChannel();
+  setMaxListeners(2, mc.port1);
+  mc.port1.addEventListener('foo', () => {});
+  mc.port1.addEventListener('foo', () => {});
+  mc.port1.addEventListener('foo', () => {});
+}
+
+{
+  // Set the default for newly created EventTargets
+  setMaxListeners(2);
+  const mc = new MessageChannel();
+  mc.port1.addEventListener('foo', () => {});
+  mc.port1.addEventListener('foo', () => {});
+  mc.port1.addEventListener('foo', () => {});
+
+  const ac = new AbortController();
+  ac.signal.addEventListener('foo', () => {});
+  ac.signal.addEventListener('foo', () => {});
+  ac.signal.addEventListener('foo', () => {});
+}
+
+{
+  // It works for EventEmitters also
+  const ee = new EventEmitter();
+  setMaxListeners(2, ee);
+  assert.strictEqual(ee.getMaxListeners(), 2);
+}
diff --git a/test/parallel/test-eventtarget-once-twice.js b/test/parallel/test-eventtarget-once-twice.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a38b80e2db75a9ecf560d5db37b211e4e63b2bc
--- /dev/null
+++ b/test/parallel/test-eventtarget-once-twice.js
@@ -0,0 +1,19 @@
+// Flags: --expose-internals --no-warnings
+'use strict';
+const common = require('../common');
+const {
+  Event,
+  EventTarget,
+} = require('internal/event_target');
+const { once } = require('events');
+
+const et = new EventTarget();
+(async function() {
+  await once(et, 'foo');
+  await once(et, 'foo');
+})().then(common.mustCall());
+
+et.dispatchEvent(new Event('foo'));
+setImmediate(() => {
+  et.dispatchEvent(new Event('foo'));
+});
diff --git a/test/parallel/test-eventtarget-whatwg-once.js b/test/parallel/test-eventtarget-whatwg-once.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba43c10916cfb74a3c2405320729305143f79063
--- /dev/null
+++ b/test/parallel/test-eventtarget-whatwg-once.js
@@ -0,0 +1,91 @@
+// Flags: --expose-internals --no-warnings
+'use strict';
+
+const common = require('../common');
+
+const {
+  Event,
+  EventTarget,
+} = require('internal/event_target');
+
+const {
+  strictEqual,
+} = require('assert');
+
+// Manually ported from: wpt@dom/events/AddEventListenerOptions-once.html
+{
+  const document = new EventTarget();
+  let invoked_once = false;
+  let invoked_normal = false;
+  function handler_once() {
+    invoked_once = true;
+  }
+
+  function handler_normal() {
+    invoked_normal = true;
+  }
+
+  document.addEventListener('test', handler_once, { once: true });
+  document.addEventListener('test', handler_normal);
+  document.dispatchEvent(new Event('test'));
+  strictEqual(invoked_once, true, 'Once handler should be invoked');
+  strictEqual(invoked_normal, true, 'Normal handler should be invoked');
+
+  invoked_once = false;
+  invoked_normal = false;
+  document.dispatchEvent(new Event('test'));
+  strictEqual(invoked_once, false, 'Once handler shouldn\'t be invoked again');
+  strictEqual(invoked_normal, true, 'Normal handler should be invoked again');
+  document.removeEventListener('test', handler_normal);
+}
+
+
+{
+  // Manually ported from AddEventListenerOptions-once.html
+  const document = new EventTarget();
+  let invoked_count = 0;
+  function handler() {
+    invoked_count++;
+  }
+  document.addEventListener('test', handler, { once: true });
+  document.addEventListener('test', handler);
+  document.dispatchEvent(new Event('test'));
+  strictEqual(invoked_count, 1, 'The handler should only be added once');
+
+  invoked_count = 0;
+  document.dispatchEvent(new Event('test'));
+  strictEqual(invoked_count, 0, 'The handler was added as a once listener');
+
+  invoked_count = 0;
+  document.addEventListener('test', handler, { once: true });
+  document.removeEventListener('test', handler);
+  document.dispatchEvent(new Event('test'));
+  strictEqual(invoked_count, 0, 'The handler should have been removed');
+}
+
+{
+  // TODO(benjamingr) fix EventTarget recursion
+  common.skip('EventTarget recursion is currently broken');
+  const document = new EventTarget();
+  let invoked_count = 0;
+  function handler() {
+    invoked_count++;
+    if (invoked_count === 1)
+      document.dispatchEvent(new Event('test'));
+  }
+  document.addEventListener('test', handler, { once: true });
+  document.dispatchEvent(new Event('test'));
+  strictEqual(invoked_count, 1, 'Once handler should only be invoked once');
+
+  invoked_count = 0;
+  function handler2() {
+    invoked_count++;
+    if (invoked_count === 1)
+      document.addEventListener('test', handler2, { once: true });
+    if (invoked_count <= 2)
+      document.dispatchEvent(new Event('test'));
+  }
+  document.addEventListener('test', handler2, { once: true });
+  document.dispatchEvent(new Event('test'));
+  strictEqual(invoked_count, 2, 'Once handler should only be invoked once');
+}
diff --git a/test/parallel/test-eventtarget-whatwg-passive.js b/test/parallel/test-eventtarget-whatwg-passive.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e33ec5c6c2e47150a3bc4ca15b8e73b9cc310a0
--- /dev/null
+++ b/test/parallel/test-eventtarget-whatwg-passive.js
@@ -0,0 +1,69 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+
+const {
+  Event,
+  EventTarget,
+} = require('internal/event_target');
+
+const {
+  fail,
+  ok,
+  strictEqual
+} = require('assert');
+
+// Manually ported from WPT AddEventListenerOptions-passive.html
+{
+  const document = new EventTarget();
+  let supportsPassive = false;
+  const query_options = {
+    get passive() {
+      supportsPassive = true;
+      return false;
+    },
+    get dummy() {
+      fail('dummy value getter invoked');
+      return false;
+    }
+  };
+
+  document.addEventListener('test_event', null, query_options);
+  ok(supportsPassive);
+
+  supportsPassive = false;
+  document.removeEventListener('test_event', null, query_options);
+  strictEqual(supportsPassive, false);
+}
+{
+  function testPassiveValue(optionsValue, expectedDefaultPrevented) {
+    const document = new EventTarget();
+    let defaultPrevented;
+    function handler(e) {
+      if (e.defaultPrevented) {
+        fail('Event prematurely marked defaultPrevented');
+      }
+      e.preventDefault();
+      defaultPrevented = e.defaultPrevented;
+    }
+    document.addEventListener('test', handler, optionsValue);
+    // TODO the WHATWG test is more extensive here and tests dispatching on
+    // document.body, if we ever support getParent we should amend this
+    const ev = new Event('test', { bubbles: true, cancelable: true });
+    const uncanceled = document.dispatchEvent(ev);
+
+    strictEqual(defaultPrevented, expectedDefaultPrevented);
+    strictEqual(uncanceled, !expectedDefaultPrevented);
+
+    document.removeEventListener('test', handler, optionsValue);
+  }
+  testPassiveValue(undefined, true);
+  testPassiveValue({}, true);
+  testPassiveValue({ passive: false }, true);
+
+  common.skip('TODO: passive listeners is still broken');
+  testPassiveValue({ passive: 1 }, false);
+  testPassiveValue({ passive: true }, false);
+  testPassiveValue({ passive: 0 }, true);
+}
diff --git a/test/parallel/test-eventtarget.js b/test/parallel/test-eventtarget.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a013875dc32257bce8911edadb0f52b1d78acef
--- /dev/null
+++ b/test/parallel/test-eventtarget.js
@@ -0,0 +1,539 @@
+// Flags: --expose-internals --no-warnings
+'use strict';
+
+const common = require('../common');
+const {
+  Event,
+  EventTarget,
+  defineEventHandler
+} = require('internal/event_target');
+
+const {
+  ok,
+  deepStrictEqual,
+  strictEqual,
+  throws,
+} = require('assert');
+
+const { once } = require('events');
+
+const { promisify } = require('util');
+const delay = promisify(setTimeout);
+
+// The globals are defined.
+ok(Event);
+ok(EventTarget);
+
+// The warning event has special behavior regarding attaching listeners
+let lastWarning;
+process.on('warning', (e) => {
+  lastWarning = e;
+});
+
+// Utility promise for parts of the test that need to wait for eachother -
+// Namely tests for warning events
+/* eslint-disable no-unused-vars */
+let asyncTest = Promise.resolve();
+
+// First, test Event
+{
+  const ev = new Event('foo');
+  strictEqual(ev.type, 'foo');
+  strictEqual(ev.cancelable, false);
+  strictEqual(ev.defaultPrevented, false);
+  strictEqual(typeof ev.timeStamp, 'number');
+
+  // Compatibility properties with the DOM
+  deepStrictEqual(ev.composedPath(), []);
+  strictEqual(ev.returnValue, true);
+  strictEqual(ev.bubbles, false);
+  strictEqual(ev.composed, false);
+  strictEqual(ev.isTrusted, false);
+  strictEqual(ev.eventPhase, 0);
+  strictEqual(ev.cancelBubble, false);
+
+  // Not cancelable
+  ev.preventDefault();
+  strictEqual(ev.defaultPrevented, false);
+}
+{
+  [
+    'foo',
+    1,
+    false,
+  ].forEach((i) => (
+    throws(() => new Event('foo', i), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: 'The "options" argument must be of type object.' +
+               common.invalidArgTypeHelper(i)
+    })
+  ));
+}
+{
+  const ev = new Event('foo');
+  strictEqual(ev.cancelBubble, false);
+  ev.cancelBubble = true;
+  strictEqual(ev.cancelBubble, true);
+}
+{
+  const ev = new Event('foo');
+  strictEqual(ev.cancelBubble, false);
+  ev.stopPropagation();
+  strictEqual(ev.cancelBubble, true);
+}
+{
+  const ev = new Event('foo');
+  strictEqual(ev.cancelBubble, false);
+  ev.cancelBubble = 'some-truthy-value';
+  strictEqual(ev.cancelBubble, true);
+}
+{
+  // No argument behavior - throw TypeError
+  throws(() => {
+    new Event();
+  }, TypeError);
+  // Too many arguments passed behavior - ignore additional arguments
+  const ev = new Event('foo', {}, {});
+  strictEqual(ev.type, 'foo');
+}
+{
+  const ev = new Event('foo');
+  strictEqual(ev.cancelBubble, false);
+  ev.cancelBubble = true;
+  strictEqual(ev.cancelBubble, true);
+}
+{
+  const ev = new Event('foo');
+  strictEqual(ev.cancelBubble, false);
+  ev.stopPropagation();
+  strictEqual(ev.cancelBubble, true);
+}
+{
+  const ev = new Event('foo');
+  strictEqual(ev.cancelBubble, false);
+  ev.cancelBubble = 'some-truthy-value';
+  strictEqual(ev.cancelBubble, true);
+}
+{
+  const ev = new Event('foo', { cancelable: true });
+  strictEqual(ev.type, 'foo');
+  strictEqual(ev.cancelable, true);
+  strictEqual(ev.defaultPrevented, false);
+
+  ev.preventDefault();
+  strictEqual(ev.defaultPrevented, true);
+  throws(() => new Event(Symbol()), TypeError);
+}
+{
+  const ev = new Event('foo');
+  deepStrictEqual(Object.keys(ev), ['isTrusted']);
+}
+{
+  const eventTarget = new EventTarget();
+
+  const ev1 = common.mustCall(function(event) {
+    strictEqual(event.type, 'foo');
+    strictEqual(this, eventTarget);
+    strictEqual(event.eventPhase, 2);
+  }, 2);
+
+  const ev2 = {
+    handleEvent: common.mustCall(function(event) {
+      strictEqual(event.type, 'foo');
+      strictEqual(this, ev2);
+    })
+  };
+
+  eventTarget.addEventListener('foo', ev1);
+  eventTarget.addEventListener('foo', ev2, { once: true });
+  ok(eventTarget.dispatchEvent(new Event('foo')));
+  eventTarget.dispatchEvent(new Event('foo'));
+
+  eventTarget.removeEventListener('foo', ev1);
+  eventTarget.dispatchEvent(new Event('foo'));
+}
+{
+  // event subclassing
+  const SubEvent = class extends Event {};
+  const ev = new SubEvent('foo');
+  const eventTarget = new EventTarget();
+  const fn = common.mustCall((event) => strictEqual(event, ev));
+  eventTarget.addEventListener('foo', fn, { once: true });
+  eventTarget.dispatchEvent(ev);
+}
+
+{
+  const eventTarget = new EventTarget();
+  const event = new Event('foo', { cancelable: true });
+  eventTarget.addEventListener('foo', (event) => event.preventDefault());
+  ok(!eventTarget.dispatchEvent(event));
+}
+{
+  // Adding event listeners with a boolean useCapture
+  const eventTarget = new EventTarget();
+  const event = new Event('foo');
+  const fn = common.mustCall((event) => strictEqual(event.type, 'foo'));
+  eventTarget.addEventListener('foo', fn, false);
+  eventTarget.dispatchEvent(event);
+}
+
+{
+  // The `options` argument can be `null`.
+  const eventTarget = new EventTarget();
+  const event = new Event('foo');
+  const fn = common.mustCall((event) => strictEqual(event.type, 'foo'));
+  eventTarget.addEventListener('foo', fn, null);
+  eventTarget.dispatchEvent(event);
+}
+
+{
+  const uncaughtException = common.mustCall((err, event) => {
+    strictEqual(err.message, 'boom');
+    strictEqual(event.type, 'foo');
+  }, 4);
+
+  // Whether or not the handler function is async or not, errors
+  // are routed to uncaughtException
+  process.on('error', uncaughtException);
+
+  const eventTarget = new EventTarget();
+
+  const ev1 = async () => { throw new Error('boom'); };
+  const ev2 = () => { throw new Error('boom'); };
+  const ev3 = { handleEvent() { throw new Error('boom'); } };
+  const ev4 = { async handleEvent() { throw new Error('boom'); } };
+
+  // Errors in a handler won't stop calling the others.
+  eventTarget.addEventListener('foo', ev1, { once: true });
+  eventTarget.addEventListener('foo', ev2, { once: true });
+  eventTarget.addEventListener('foo', ev3, { once: true });
+  eventTarget.addEventListener('foo', ev4, { once: true });
+
+  eventTarget.dispatchEvent(new Event('foo'));
+}
+
+{
+  const eventTarget = new EventTarget();
+
+  // Once handler only invoked once
+  const ev = common.mustCall((event) => {
+    // Can invoke the same event name recursively
+    eventTarget.dispatchEvent(new Event('foo'));
+  });
+
+  // Errors in a handler won't stop calling the others.
+  eventTarget.addEventListener('foo', ev, { once: true });
+
+  eventTarget.dispatchEvent(new Event('foo'));
+}
+
+{
+  // Coercion to string works
+  strictEqual((new Event(1)).type, '1');
+  strictEqual((new Event(false)).type, 'false');
+  strictEqual((new Event({})).type, String({}));
+
+  const target = new EventTarget();
+
+  [
+    'foo',
+    {},  // No type event
+    undefined,
+    1,
+    false,
+  ].forEach((i) => {
+    throws(() => target.dispatchEvent(i), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: 'The "event" argument must be an instance of Event.' +
+               common.invalidArgTypeHelper(i)
+    });
+  });
+
+  const err = (arg) => ({
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+    message: 'The "listener" argument must be an instance of EventListener.' +
+             common.invalidArgTypeHelper(arg)
+  });
+
+  [
+    'foo',
+    1,
+    {},  // No handleEvent function
+    false,
+  ].forEach((i) => throws(() => target.addEventListener('foo', i), err(i)));
+}
+
+{
+  const target = new EventTarget();
+  once(target, 'foo').then(common.mustCall());
+  target.dispatchEvent(new Event('foo'));
+}
+
+{
+  const target = new EventTarget();
+  const event = new Event('foo');
+  event.stopImmediatePropagation();
+  target.addEventListener('foo', common.mustNotCall());
+  target.dispatchEvent(event);
+}
+
+{
+  const target = new EventTarget();
+  const event = new Event('foo');
+  target.addEventListener('foo', common.mustCall((event) => {
+    event.stopImmediatePropagation();
+  }));
+  target.addEventListener('foo', common.mustNotCall());
+  target.dispatchEvent(event);
+}
+
+{
+  const target = new EventTarget();
+  const event = new Event('foo');
+  target.addEventListener('foo', common.mustCall((event) => {
+    event.stopImmediatePropagation();
+  }));
+  target.addEventListener('foo', common.mustNotCall());
+  target.dispatchEvent(event);
+}
+
+{
+  const target = new EventTarget();
+  const event = new Event('foo');
+  strictEqual(event.target, null);
+  target.addEventListener('foo', common.mustCall((event) => {
+    strictEqual(event.target, target);
+    strictEqual(event.currentTarget, target);
+    strictEqual(event.srcElement, target);
+  }));
+  target.dispatchEvent(event);
+}
+
+{
+  const target1 = new EventTarget();
+  const target2 = new EventTarget();
+  const event = new Event('foo');
+  target1.addEventListener('foo', common.mustCall((event) => {
+    throws(() => target2.dispatchEvent(event), {
+      code: 'ERR_EVENT_RECURSION'
+    });
+  }));
+  target1.dispatchEvent(event);
+}
+
+{
+  const target = new EventTarget();
+  const a = common.mustCall(() => target.removeEventListener('foo', a));
+  const b = common.mustCall(2);
+
+  target.addEventListener('foo', a);
+  target.addEventListener('foo', b);
+
+  target.dispatchEvent(new Event('foo'));
+  target.dispatchEvent(new Event('foo'));
+}
+
+{
+  const target = new EventTarget();
+  const a = common.mustCall(3);
+
+  target.addEventListener('foo', a, { capture: true });
+  target.addEventListener('foo', a, { capture: false });
+
+  target.dispatchEvent(new Event('foo'));
+  target.removeEventListener('foo', a, { capture: true });
+  target.dispatchEvent(new Event('foo'));
+  target.removeEventListener('foo', a, { capture: false });
+  target.dispatchEvent(new Event('foo'));
+}
+{
+  const target = new EventTarget();
+  strictEqual(target.toString(), '[object EventTarget]');
+  const event = new Event('');
+  strictEqual(event.toString(), '[object Event]');
+}
+{
+  const target = new EventTarget();
+  defineEventHandler(target, 'foo');
+  target.onfoo = common.mustCall();
+  target.dispatchEvent(new Event('foo'));
+}
+{
+  const target = new EventTarget();
+  defineEventHandler(target, 'foo');
+  let count = 0;
+  target.onfoo = () => count++;
+  target.onfoo = common.mustCall(() => count++);
+  target.dispatchEvent(new Event('foo'));
+  strictEqual(count, 1);
+}
+{
+  const target = new EventTarget();
+  defineEventHandler(target, 'foo');
+  let count = 0;
+  target.addEventListener('foo', () => count++);
+  target.onfoo = common.mustCall(() => count++);
+  target.dispatchEvent(new Event('foo'));
+  strictEqual(count, 2);
+}
+{
+  const target = new EventTarget();
+  defineEventHandler(target, 'foo');
+  const fn = common.mustNotCall();
+  target.onfoo = fn;
+  strictEqual(target.onfoo, fn);
+  target.onfoo = null;
+  target.dispatchEvent(new Event('foo'));
+}
+
+{
+  // `this` value of dispatchEvent
+  const target = new EventTarget();
+  const target2 = new EventTarget();
+  const event = new Event('foo');
+
+  ok(target.dispatchEvent.call(target2, event));
+
+  [
+    'foo',
+    {},
+    [],
+    1,
+    null,
+    undefined,
+    false,
+    Symbol(),
+    /a/,
+  ].forEach((i) => {
+    throws(() => target.dispatchEvent.call(i, event), {
+      code: 'ERR_INVALID_THIS'
+    });
+  });
+}
+
+{
+  // Event Statics
+  strictEqual(Event.NONE, 0);
+  strictEqual(Event.CAPTURING_PHASE, 1);
+  strictEqual(Event.AT_TARGET, 2);
+  strictEqual(Event.BUBBLING_PHASE, 3);
+  strictEqual(new Event('foo').eventPhase, Event.NONE);
+  const target = new EventTarget();
+  target.addEventListener('foo', common.mustCall((e) => {
+    strictEqual(e.eventPhase, Event.AT_TARGET);
+  }), { once: true });
+  target.dispatchEvent(new Event('foo'));
+  // Event is a function
+  strictEqual(Event.length, 1);
+}
+
+{
+  const target = new EventTarget();
+  const ev = new Event('toString');
+  const fn = common.mustCall((event) => strictEqual(event.type, 'toString'));
+  target.addEventListener('toString', fn);
+  target.dispatchEvent(ev);
+}
+{
+  const target = new EventTarget();
+  const ev = new Event('__proto__');
+  const fn = common.mustCall((event) => strictEqual(event.type, '__proto__'));
+  target.addEventListener('__proto__', fn);
+  target.dispatchEvent(ev);
+}
+
+{
+  const eventTarget = new EventTarget();
+  // Single argument throws
+  throws(() => eventTarget.addEventListener('foo'), TypeError);
+  // Null events - does not throw
+  eventTarget.addEventListener('foo', null);
+  eventTarget.removeEventListener('foo', null);
+  eventTarget.addEventListener('foo', undefined);
+  eventTarget.removeEventListener('foo', undefined);
+  // Strings, booleans
+  throws(() => eventTarget.addEventListener('foo', 'hello'), TypeError);
+  throws(() => eventTarget.addEventListener('foo', false), TypeError);
+  throws(() => eventTarget.addEventListener('foo', Symbol()), TypeError);
+  asyncTest = asyncTest.then(async () => {
+    const eventTarget = new EventTarget();
+    // Single argument throws
+    throws(() => eventTarget.addEventListener('foo'), TypeError);
+    // Null events - does not throw
+
+    eventTarget.addEventListener('foo', null);
+    eventTarget.removeEventListener('foo', null);
+
+    // Warnings always happen after nextTick, so wait for a timer of 0
+    await delay(0);
+    strictEqual(lastWarning.name, 'AddEventListenerArgumentTypeWarning');
+    strictEqual(lastWarning.target, eventTarget);
+    lastWarning = null;
+    eventTarget.addEventListener('foo', undefined);
+    await delay(0);
+    strictEqual(lastWarning.name, 'AddEventListenerArgumentTypeWarning');
+    strictEqual(lastWarning.target, eventTarget);
+    eventTarget.removeEventListener('foo', undefined);
+    // Strings, booleans
+    throws(() => eventTarget.addEventListener('foo', 'hello'), TypeError);
+    throws(() => eventTarget.addEventListener('foo', false), TypeError);
+    throws(() => eventTarget.addEventListener('foo', Symbol()), TypeError);
+  });
+}
+{
+  const eventTarget = new EventTarget();
+  const event = new Event('foo');
+  eventTarget.dispatchEvent(event);
+  strictEqual(event.target, eventTarget);
+}
+{
+  // Event target exported keys
+  const eventTarget = new EventTarget();
+  deepStrictEqual(Object.keys(eventTarget), []);
+  deepStrictEqual(Object.getOwnPropertyNames(eventTarget), []);
+  const parentKeys = Object.keys(Object.getPrototypeOf(eventTarget)).sort();
+  const keys = ['addEventListener', 'dispatchEvent', 'removeEventListener'];
+  deepStrictEqual(parentKeys, keys);
+}
+{
+  // Subclassing
+  class SubTarget extends EventTarget {}
+  const target = new SubTarget();
+  target.addEventListener('foo', common.mustCall());
+  target.dispatchEvent(new Event('foo'));
+}
+{
+  // Test event order
+  const target = new EventTarget();
+  let state = 0;
+  target.addEventListener('foo', common.mustCall(() => {
+    strictEqual(state, 0);
+    state++;
+  }));
+  target.addEventListener('foo', common.mustCall(() => {
+    strictEqual(state, 1);
+  }));
+  target.dispatchEvent(new Event('foo'));
+}
+{
+  const target = new EventTarget();
+  defineEventHandler(target, 'foo');
+  const descriptor = Object.getOwnPropertyDescriptor(target, 'onfoo');
+  strictEqual(descriptor.configurable, true);
+  strictEqual(descriptor.enumerable, true);
+}
+{
+  const target = new EventTarget();
+  defineEventHandler(target, 'foo');
+  const output = [];
+  target.addEventListener('foo', () => output.push(1));
+  target.onfoo = common.mustNotCall();
+  target.addEventListener('foo', () => output.push(3));
+  target.onfoo = () => output.push(2);
+  target.addEventListener('foo', () => output.push(4));
+  target.dispatchEvent(new Event('foo'));
+  deepStrictEqual(output, [1, 2, 3, 4]);
+}
diff --git a/test/parallel/test-file-write-stream.js b/test/parallel/test-file-write-stream.js
index 05a2d5432b5fb762eacce376b30ee205a9ce810d..6cab71a4353ff2825f71ec98edc9c523f95c3462 100644
--- a/test/parallel/test-file-write-stream.js
+++ b/test/parallel/test-file-write-stream.js
@@ -20,7 +20,7 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const path = require('path');
@@ -46,9 +46,6 @@ file
     callbacks.open++;
     assert.strictEqual(typeof fd, 'number');
   })
-  .on('error', function(err) {
-    throw err;
-  })
   .on('drain', function() {
     console.error('drain!', callbacks.drain);
     callbacks.drain++;
@@ -65,17 +62,12 @@ file
     assert.strictEqual(file.bytesWritten, EXPECTED.length * 2);
 
     callbacks.close++;
-    assert.throws(
-      () => {
-        console.error('write after end should not be allowed');
-        file.write('should not work anymore');
-      },
-      {
-        code: 'ERR_STREAM_WRITE_AFTER_END',
-        name: 'Error',
-        message: 'write after end'
-      }
-    );
+    console.error('write after end should not be allowed');
+    file.write('should not work anymore', common.expectsError({
+      code: 'ERR_STREAM_WRITE_AFTER_END',
+      name: 'Error',
+      message: 'write after end'
+    }));
 
     fs.unlinkSync(fn);
   });
diff --git a/test/parallel/test-file-write-stream2.js b/test/parallel/test-file-write-stream2.js
index 2654c8bca20712d82ccf01469b1424d13323e959..487b5d44054373c2dea8b3f3513adbcc6e359794 100644
--- a/test/parallel/test-file-write-stream2.js
+++ b/test/parallel/test-file-write-stream2.js
@@ -33,7 +33,7 @@ const filepath = path.join(tmpdir.path, 'write.txt');
 
 const EXPECTED = '012345678910';
 
-const cb_expected = 'write open drain write drain close error ';
+const cb_expected = 'write open drain write drain close ';
 let cb_occurred = '';
 
 let countDrains = 0;
@@ -92,16 +92,11 @@ file.on('drain', function() {
 file.on('close', function() {
   cb_occurred += 'close ';
   assert.strictEqual(file.bytesWritten, EXPECTED.length * 2);
-  file.write('should not work anymore');
+  file.write('should not work anymore', (err) => {
+    assert.ok(err.message.includes('write after end'));
+  });
 });
 
-
-file.on('error', function(err) {
-  cb_occurred += 'error ';
-  assert.ok(err.message.includes('write after end'));
-});
-
-
 for (let i = 0; i < 11; i++) {
   const ret = file.write(String(i));
   console.error(`${i} ${ret}`);
diff --git a/test/parallel/test-finalization-group-error.js b/test/parallel/test-finalization-group-error.js
deleted file mode 100644
index 0685811f55b7f8efc88e04ffd5e173ed7d415258..0000000000000000000000000000000000000000
--- a/test/parallel/test-finalization-group-error.js
+++ /dev/null
@@ -1,27 +0,0 @@
-'use strict';
-
-// Flags: --expose-gc --harmony-weak-refs
-
-const common = require('../common');
-const assert = require('assert');
-
-const g = new globalThis.FinalizationGroup(common.mustCallAtLeast(() => {
-  throw new Error('test');
-}, 1));
-g.register({}, 42);
-
-setTimeout(() => {
-  globalThis.gc();
-  assert.throws(() => {
-    g.cleanupSome();
-  }, {
-    name: 'Error',
-    message: 'test',
-  });
-
-  // Give the callbacks scheduled by global.gc() time to run, as the underlying
-  // uv_async_t is unref’ed.
-  setTimeout(() => {}, 200);
-}, 200);
-
-process.on('uncaughtException', common.mustCall());
diff --git a/test/parallel/test-finalization-group-regular-gc.js b/test/parallel/test-finalization-group-regular-gc.js
deleted file mode 100644
index 7a4a4797eadcf02867ad30c20b37060fa7abb5fb..0000000000000000000000000000000000000000
--- a/test/parallel/test-finalization-group-regular-gc.js
+++ /dev/null
@@ -1,25 +0,0 @@
-// Flags: --harmony-weak-refs
-'use strict';
-require('../common');
-const assert = require('assert');
-
-// Test that finalization callbacks do not crash when caused through a regular
-// GC (not global.gc()).
-
-const start = Date.now();
-const g = new globalThis.FinalizationGroup(() => {
-  const diff = Date.now() - start;
-  assert(diff < 10000, `${diff} >= 10000`);
-});
-g.register({}, 42);
-
-setImmediate(() => {
-  const arr = [];
-  // Build up enough memory usage to hopefully trigger a platform task but not
-  // enough to trigger GC as an interrupt.
-  while (arr.length < 1000000) arr.push([]);
-
-  setTimeout(() => {
-    g;  // Keep reference alive.
-  }, 200000).unref();
-});
diff --git a/test/parallel/test-finalization-group.js b/test/parallel/test-finalization-group.js
deleted file mode 100644
index 3e6b9d72e356480e2b78f0b336f252d0eec641d4..0000000000000000000000000000000000000000
--- a/test/parallel/test-finalization-group.js
+++ /dev/null
@@ -1,13 +0,0 @@
-'use strict';
-
-// Flags: --expose-gc --harmony-weak-refs
-
-const common = require('../common');
-
-const g = new globalThis.FinalizationGroup(common.mustCallAtLeast(1));
-g.register({}, 42);
-
-setTimeout(() => {
-  globalThis.gc();
-  g.cleanupSome();
-}, 200);
diff --git a/test/parallel/test-freelist.js b/test/parallel/test-freelist.js
index d0ec3d1e8e7f9bb69592726bfdc3458d2fa6f660..eb43308dbe59cc685eaaa430c062eb7457ecbf99 100644
--- a/test/parallel/test-freelist.js
+++ b/test/parallel/test-freelist.js
@@ -28,13 +28,3 @@ assert.strictEqual(flist1.free({ id: 'test5' }), false);
 assert.strictEqual(flist1.alloc().id, 'test3');
 assert.strictEqual(flist1.alloc().id, 'test2');
 assert.strictEqual(flist1.alloc().id, 'test1');
-
-// Check list has elements
-const flist2 = new FreeList('flist2', 2, Object);
-assert.strictEqual(flist2.hasItems(), false);
-
-flist2.free({ id: 'test1' });
-assert.strictEqual(flist2.hasItems(), true);
-
-flist2.alloc();
-assert.strictEqual(flist2.hasItems(), false);
diff --git a/test/parallel/test-fs-access.js b/test/parallel/test-fs-access.js
index 2a431134af322ed300ec7fc21b16dd6b28690b3b..9fa4dfcf1fe4d8f6acbb2e0db6d378544a9fa20c 100644
--- a/test/parallel/test-fs-access.js
+++ b/test/parallel/test-fs-access.js
@@ -32,29 +32,27 @@ tmpdir.refresh();
 createFileWithPerms(readOnlyFile, 0o444);
 createFileWithPerms(readWriteFile, 0o666);
 
-/*
- * On non-Windows supported platforms, fs.access(readOnlyFile, W_OK, ...)
- * always succeeds if node runs as the super user, which is sometimes the
- * case for tests running on our continuous testing platform agents.
- *
- * In this case, this test tries to change its process user id to a
- * non-superuser user so that the test that checks for write access to a
- * read-only file can be more meaningful.
- *
- * The change of user id is done after creating the fixtures files for the same
- * reason: the test may be run as the superuser within a directory in which
- * only the superuser can create files, and thus it may need superuser
- * privileges to create them.
- *
- * There's not really any point in resetting the process' user id to 0 after
- * changing it to 'nobody', since in the case that the test runs without
- * superuser privilege, it is not possible to change its process user id to
- * superuser.
- *
- * It can prevent the test from removing files created before the change of user
- * id, but that's fine. In this case, it is the responsibility of the
- * continuous integration platform to take care of that.
- */
+// On non-Windows supported platforms, fs.access(readOnlyFile, W_OK, ...)
+// always succeeds if node runs as the super user, which is sometimes the
+// case for tests running on our continuous testing platform agents.
+//
+// In this case, this test tries to change its process user id to a
+// non-superuser user so that the test that checks for write access to a
+// read-only file can be more meaningful.
+//
+// The change of user id is done after creating the fixtures files for the same
+// reason: the test may be run as the superuser within a directory in which
+// only the superuser can create files, and thus it may need superuser
+// privileges to create them.
+//
+// There's not really any point in resetting the process' user id to 0 after
+// changing it to 'nobody', since in the case that the test runs without
+// superuser privilege, it is not possible to change its process user id to
+// superuser.
+//
+// It can prevent the test from removing files created before the change of user
+// id, but that's fine. In this case, it is the responsibility of the
+// continuous integration platform to take care of that.
 let hasWriteAccessForReadonlyFile = false;
 if (!common.isWindows && process.getuid() === 0) {
   hasWriteAccessForReadonlyFile = true;
@@ -158,6 +156,55 @@ fs.accessSync(__filename);
 const mode = fs.F_OK | fs.R_OK | fs.W_OK;
 fs.accessSync(readWriteFile, mode);
 
+// Invalid modes should throw.
+[
+  false,
+  1n,
+  { [Symbol.toPrimitive]() { return fs.R_OK; } },
+  [1],
+  'r',
+].forEach((mode, i) => {
+  console.log(mode, i);
+  assert.throws(
+    () => fs.access(readWriteFile, mode, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /"mode" argument.+integer/
+    }
+  );
+  assert.throws(
+    () => fs.accessSync(readWriteFile, mode),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /"mode" argument.+integer/
+    }
+  );
+});
+
+// Out of range modes should throw
+[
+  -1,
+  8,
+  Infinity,
+  NaN,
+].forEach((mode, i) => {
+  console.log(mode, i);
+  assert.throws(
+    () => fs.access(readWriteFile, mode, common.mustNotCall()),
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      message: /"mode".+It must be an integer >= 0 && <= 7/
+    }
+  );
+  assert.throws(
+    () => fs.accessSync(readWriteFile, mode),
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      message: /"mode".+It must be an integer >= 0 && <= 7/
+    }
+  );
+});
+
 assert.throws(
   () => { fs.accessSync(doesNotExist); },
   (err) => {
diff --git a/test/parallel/test-fs-append-file-sync.js b/test/parallel/test-fs-append-file-sync.js
index 190381234aa5ad489efd9c7588e701d635cea81b..0070b8f6486d75b8c387f5b9abc4492614128a39 100644
--- a/test/parallel/test-fs-append-file-sync.js
+++ b/test/parallel/test-fs-append-file-sync.js
@@ -70,11 +70,18 @@ const fileData3 = fs.readFileSync(filename3);
 
 assert.strictEqual(buf.length + currentFileData.length, fileData3.length);
 
-// Test that appendFile accepts numbers.
 const filename4 = join(tmpdir.path, 'append-sync4.txt');
 fs.writeFileSync(filename4, currentFileData, { mode: m });
 
-fs.appendFileSync(filename4, num, { mode: m });
+[
+  true, false, 0, 1, Infinity, () => {}, {}, [], undefined, null,
+].forEach((value) => {
+  assert.throws(
+    () => fs.appendFileSync(filename4, value, { mode: m }),
+    { message: /data/, code: 'ERR_INVALID_ARG_TYPE' }
+  );
+});
+fs.appendFileSync(filename4, `${num}`, { mode: m });
 
 // Windows permissions aren't Unix.
 if (!common.isWindows) {
@@ -99,13 +106,3 @@ const fileData5 = fs.readFileSync(filename5);
 
 assert.strictEqual(Buffer.byteLength(data) + currentFileData.length,
                    fileData5.length);
-
-// Exit logic for cleanup.
-
-process.on('exit', function() {
-  fs.unlinkSync(filename);
-  fs.unlinkSync(filename2);
-  fs.unlinkSync(filename3);
-  fs.unlinkSync(filename4);
-  fs.unlinkSync(filename5);
-});
diff --git a/test/parallel/test-fs-append-file.js b/test/parallel/test-fs-append-file.js
index 90fe8d9277a23e4c987938258d089075f92db585..70919830f6cb0b03168296b87288d56aae8ac326 100644
--- a/test/parallel/test-fs-append-file.js
+++ b/test/parallel/test-fs-append-file.js
@@ -29,7 +29,6 @@ const tmpdir = require('../common/tmpdir');
 
 const currentFileData = 'ABCD';
 
-const n = 220;
 const s = '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
           '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
           '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
@@ -46,11 +45,8 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
 {
   const filename = join(tmpdir.path, 'append.txt');
 
-  fs.appendFile(filename, s, common.mustCall(function(e) {
-    assert.ifError(e);
-
-    fs.readFile(filename, common.mustCall(function(e, buffer) {
-      assert.ifError(e);
+  fs.appendFile(filename, s, common.mustSucceed(() => {
+    fs.readFile(filename, common.mustSucceed((buffer) => {
       assert.strictEqual(Buffer.byteLength(s), buffer.length);
     }));
   }));
@@ -73,11 +69,8 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
   const filename = join(tmpdir.path, 'append-non-empty.txt');
   fs.writeFileSync(filename, currentFileData);
 
-  fs.appendFile(filename, s, common.mustCall(function(e) {
-    assert.ifError(e);
-
-    fs.readFile(filename, common.mustCall(function(e, buffer) {
-      assert.ifError(e);
+  fs.appendFile(filename, s, common.mustSucceed(() => {
+    fs.readFile(filename, common.mustSucceed((buffer) => {
       assert.strictEqual(Buffer.byteLength(s) + currentFileData.length,
                          buffer.length);
     }));
@@ -105,11 +98,8 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
 
   const buf = Buffer.from(s, 'utf8');
 
-  fs.appendFile(filename, buf, common.mustCall((e) => {
-    assert.ifError(e);
-
-    fs.readFile(filename, common.mustCall((e, buffer) => {
-      assert.ifError(e);
+  fs.appendFile(filename, buf, common.mustSucceed(() => {
+    fs.readFile(filename, common.mustSucceed((buffer) => {
       assert.strictEqual(buf.length + currentFileData.length, buffer.length);
     }));
   }));
@@ -130,68 +120,47 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
     .catch(throwNextTick);
 }
 
-// Test that appendFile accepts numbers (callback API).
-{
-  const filename = join(tmpdir.path, 'append-numbers.txt');
-  fs.writeFileSync(filename, currentFileData);
-
-  const m = 0o600;
-  fs.appendFile(filename, n, { mode: m }, common.mustCall((e) => {
-    assert.ifError(e);
-
-    // Windows permissions aren't Unix.
-    if (!common.isWindows) {
-      const st = fs.statSync(filename);
-      assert.strictEqual(st.mode & 0o700, m);
+// Test that appendFile does not accept invalid data type (callback API).
+[false, 5, {}, null, undefined].forEach(async (data) => {
+  const errObj = {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: /"data"|"buffer"/
+  };
+  const filename = join(tmpdir.path, 'append-invalid-data.txt');
+
+  assert.throws(
+    () => fs.appendFile(filename, data, common.mustNotCall()),
+    errObj
+  );
+
+  assert.throws(
+    () => fs.appendFileSync(filename, data),
+    errObj
+  );
+
+  await assert.rejects(
+    fs.promises.appendFile(filename, data),
+    errObj
+  );
+  // The filename shouldn't exist if throwing error.
+  assert.throws(
+    () => fs.statSync(filename),
+    {
+      code: 'ENOENT',
+      message: /no such file or directory/
     }
-
-    fs.readFile(filename, common.mustCall((e, buffer) => {
-      assert.ifError(e);
-      assert.strictEqual(Buffer.byteLength(String(n)) + currentFileData.length,
-                         buffer.length);
-    }));
-  }));
-}
-
-// Test that appendFile accepts numbers (promises API).
-{
-  const filename = join(tmpdir.path, 'append-numbers-promises.txt');
-  fs.writeFileSync(filename, currentFileData);
-
-  const m = 0o600;
-  fs.promises.appendFile(filename, n, { mode: m })
-    .then(common.mustCall(() => {
-      // Windows permissions aren't Unix.
-      if (!common.isWindows) {
-        const st = fs.statSync(filename);
-        assert.strictEqual(st.mode & 0o700, m);
-      }
-
-      return fs.promises.readFile(filename);
-    }))
-    .then((buffer) => {
-      assert.strictEqual(Buffer.byteLength(String(n)) + currentFileData.length,
-                         buffer.length);
-    })
-    .catch(throwNextTick);
-}
+  );
+});
 
 // Test that appendFile accepts file descriptors (callback API).
 {
   const filename = join(tmpdir.path, 'append-descriptors.txt');
   fs.writeFileSync(filename, currentFileData);
 
-  fs.open(filename, 'a+', common.mustCall((e, fd) => {
-    assert.ifError(e);
-
-    fs.appendFile(fd, s, common.mustCall((e) => {
-      assert.ifError(e);
-
-      fs.close(fd, common.mustCall((e) => {
-        assert.ifError(e);
-
-        fs.readFile(filename, common.mustCall((e, buffer) => {
-          assert.ifError(e);
+  fs.open(filename, 'a+', common.mustSucceed((fd) => {
+    fs.appendFile(fd, s, common.mustSucceed(() => {
+      fs.close(fd, common.mustSucceed(() => {
+        fs.readFile(filename, common.mustSucceed((buffer) => {
           assert.strictEqual(Buffer.byteLength(s) + currentFileData.length,
                              buffer.length);
         }));
diff --git a/test/parallel/test-fs-buffer.js b/test/parallel/test-fs-buffer.js
index d9afbaf7fa08ecdc57a69718861005c6043ac96e..4c81c13e26977f46ec81bdb95cc2dc4433987f8e 100644
--- a/test/parallel/test-fs-buffer.js
+++ b/test/parallel/test-fs-buffer.js
@@ -9,13 +9,12 @@ const path = require('path');
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-fs.access(Buffer.from(tmpdir.path), common.mustCall(assert.ifError));
+fs.access(Buffer.from(tmpdir.path), common.mustSucceed());
 
 const buf = Buffer.from(path.join(tmpdir.path, 'a.txt'));
-fs.open(buf, 'w+', common.mustCall((err, fd) => {
-  assert.ifError(err);
+fs.open(buf, 'w+', common.mustSucceed((fd) => {
   assert(fd);
-  fs.close(fd, common.mustCall(assert.ifError));
+  fs.close(fd, common.mustSucceed());
 }));
 
 assert.throws(
@@ -31,10 +30,8 @@ assert.throws(
 );
 
 const dir = Buffer.from(fixtures.fixturesDir);
-fs.readdir(dir, 'hex', common.mustCall((err, hexList) => {
-  assert.ifError(err);
-  fs.readdir(dir, common.mustCall((err, stringList) => {
-    assert.ifError(err);
+fs.readdir(dir, 'hex', common.mustSucceed((hexList) => {
+  fs.readdir(dir, common.mustSucceed((stringList) => {
     stringList.forEach((val, idx) => {
       const fromHexList = Buffer.from(hexList[idx], 'hex').toString();
       assert.strictEqual(
diff --git a/test/parallel/test-fs-buffertype-writesync.js b/test/parallel/test-fs-buffertype-writesync.js
index d5257d214bdb8125f90400f08f81ea16ba962583..5649a00569a2faef6f465585d8feca3e06c420dd 100644
--- a/test/parallel/test-fs-buffertype-writesync.js
+++ b/test/parallel/test-fs-buffertype-writesync.js
@@ -1,22 +1,16 @@
 'use strict';
 require('../common');
 
-// This test ensures that writeSync does support inputs which
-// are then correctly converted into string buffers.
+// This test ensures that writeSync throws for invalid data input.
 
 const assert = require('assert');
 const fs = require('fs');
-const path = require('path');
 
-const tmpdir = require('../common/tmpdir');
-
-const filePath = path.join(tmpdir.path, 'test_buffer_type');
-const v = [true, false, 0, 1, Infinity, () => {}, {}, [], undefined, null];
-
-tmpdir.refresh();
-
-v.forEach((value) => {
-  const fd = fs.openSync(filePath, 'w');
-  fs.writeSync(fd, value);
-  assert.strictEqual(fs.readFileSync(filePath).toString(), String(value));
+[
+  true, false, 0, 1, Infinity, () => {}, {}, [], undefined, null,
+].forEach((value) => {
+  assert.throws(
+    () => fs.writeSync(1, value),
+    { message: /"buffer"/, code: 'ERR_INVALID_ARG_TYPE' }
+  );
 });
diff --git a/test/parallel/test-fs-chmod-mask.js b/test/parallel/test-fs-chmod-mask.js
index 9564ca142bd6430f32cf0094b9c2cc3ea316d6bb..bd967f5fb625787ab8256931e3f44cb7b8a3af35 100644
--- a/test/parallel/test-fs-chmod-mask.js
+++ b/test/parallel/test-fs-chmod-mask.js
@@ -29,8 +29,7 @@ function test(mode, asString) {
     const file = path.join(tmpdir.path, `chmod-async-${suffix}.txt`);
     fs.writeFileSync(file, 'test', 'utf-8');
 
-    fs.chmod(file, input, common.mustCall((err) => {
-      assert.ifError(err);
+    fs.chmod(file, input, common.mustSucceed(() => {
       assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
     }));
   }
@@ -46,11 +45,8 @@ function test(mode, asString) {
   {
     const file = path.join(tmpdir.path, `fchmod-async-${suffix}.txt`);
     fs.writeFileSync(file, 'test', 'utf-8');
-    fs.open(file, 'w', common.mustCall((err, fd) => {
-      assert.ifError(err);
-
-      fs.fchmod(fd, input, common.mustCall((err) => {
-        assert.ifError(err);
+    fs.open(file, 'w', common.mustSucceed((fd) => {
+      fs.fchmod(fd, input, common.mustSucceed(() => {
         assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
         fs.close(fd, assert.ifError);
       }));
@@ -74,8 +70,7 @@ function test(mode, asString) {
     fs.writeFileSync(file, 'test', 'utf-8');
     fs.symlinkSync(file, link);
 
-    fs.lchmod(link, input, common.mustCall((err) => {
-      assert.ifError(err);
+    fs.lchmod(link, input, common.mustSucceed(() => {
       assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode);
     }));
   }
diff --git a/test/parallel/test-fs-chmod.js b/test/parallel/test-fs-chmod.js
index 36e417c6c4b5e32acc29a182c69b0b41227df12f..4056c9fc0fc092b8e81e95350530c6d5f58b8bab 100644
--- a/test/parallel/test-fs-chmod.js
+++ b/test/parallel/test-fs-chmod.js
@@ -80,9 +80,7 @@ const file2 = path.join(tmpdir.path, 'a1.js');
 // Create file1.
 fs.closeSync(fs.openSync(file1, 'w'));
 
-fs.chmod(file1, mode_async.toString(8), common.mustCall((err) => {
-  assert.ifError(err);
-
+fs.chmod(file1, mode_async.toString(8), common.mustSucceed(() => {
   if (common.isWindows) {
     assert.ok((fs.statSync(file1).mode & 0o777) & mode_async);
   } else {
@@ -97,12 +95,8 @@ fs.chmod(file1, mode_async.toString(8), common.mustCall((err) => {
   }
 }));
 
-fs.open(file2, 'w', common.mustCall((err, fd) => {
-  assert.ifError(err);
-
-  fs.fchmod(fd, mode_async.toString(8), common.mustCall((err) => {
-    assert.ifError(err);
-
+fs.open(file2, 'w', common.mustSucceed((fd) => {
+  fs.fchmod(fd, mode_async.toString(8), common.mustSucceed(() => {
     if (common.isWindows) {
       assert.ok((fs.fstatSync(fd).mode & 0o777) & mode_async);
     } else {
@@ -136,9 +130,7 @@ if (fs.lchmod) {
 
   fs.symlinkSync(file2, link);
 
-  fs.lchmod(link, mode_async, common.mustCall((err) => {
-    assert.ifError(err);
-
+  fs.lchmod(link, mode_async, common.mustSucceed(() => {
     assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode_async);
 
     fs.lchmodSync(link, mode_sync);
diff --git a/test/parallel/test-fs-copyfile-respect-permissions.js b/test/parallel/test-fs-copyfile-respect-permissions.js
index cb6774ef2abaee4863687d9113552669b981b174..cba99ed89984f4af46cbe37c8d60db059b37b1c2 100644
--- a/test/parallel/test-fs-copyfile-respect-permissions.js
+++ b/test/parallel/test-fs-copyfile-respect-permissions.js
@@ -49,7 +49,7 @@ function beforeEach() {
   const { source, dest, check } = beforeEach();
   (async () => {
     await assert.rejects(fs.promises.copyFile(source, dest), check);
-  })();
+  })().then(common.mustCall());
 }
 
 // Test callback API.
diff --git a/test/parallel/test-fs-copyfile.js b/test/parallel/test-fs-copyfile.js
index ab27ed66848c6ba0a5cfa6dc15634665c160e38c..51250d7b83145cb349f205547607369d29c8e5ae 100644
--- a/test/parallel/test-fs-copyfile.js
+++ b/test/parallel/test-fs-copyfile.js
@@ -76,8 +76,7 @@ try {
 
 // Copies asynchronously.
 tmpdir.refresh(); // Don't use unlinkSync() since the last test may fail.
-fs.copyFile(src, dest, common.mustCall((err) => {
-  assert.ifError(err);
+fs.copyFile(src, dest, common.mustSucceed(() => {
   verify(src, dest);
 
   // Copy asynchronously with flags.
@@ -114,28 +113,57 @@ assert.throws(() => {
     () => fs.copyFile(i, dest, common.mustNotCall()),
     {
       code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError'
+      name: 'TypeError',
+      message: /src/
     }
   );
   assert.throws(
     () => fs.copyFile(src, i, common.mustNotCall()),
     {
       code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError'
+      name: 'TypeError',
+      message: /dest/
     }
   );
   assert.throws(
     () => fs.copyFileSync(i, dest),
     {
       code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError'
+      name: 'TypeError',
+      message: /src/
     }
   );
   assert.throws(
     () => fs.copyFileSync(src, i),
     {
       code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError'
+      name: 'TypeError',
+      message: /dest/
     }
   );
 });
+
+assert.throws(() => {
+  fs.copyFileSync(src, dest, 'r');
+}, {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError',
+  message: /mode/
+});
+
+assert.throws(() => {
+  fs.copyFileSync(src, dest, 8);
+}, {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError',
+  message: 'The value of "mode" is out of range. It must be an integer ' +
+           '>= 0 && <= 7. Received 8'
+});
+
+assert.throws(() => {
+  fs.copyFile(src, dest, 'r', common.mustNotCall());
+}, {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError',
+  message: /mode/
+});
diff --git a/test/parallel/test-fs-empty-readStream.js b/test/parallel/test-fs-empty-readStream.js
index a5de2ab80bcf10524e42fb7f92b4a53d1ed2c7bd..7cbe4d50055ad4ccc917661fa8fae5df96b545a7 100644
--- a/test/parallel/test-fs-empty-readStream.js
+++ b/test/parallel/test-fs-empty-readStream.js
@@ -27,10 +27,7 @@ const fixtures = require('../common/fixtures');
 
 const emptyFile = fixtures.path('empty.txt');
 
-fs.open(emptyFile, 'r', common.mustCall((error, fd) => {
-
-  assert.ifError(error);
-
+fs.open(emptyFile, 'r', common.mustSucceed((fd) => {
   const read = fs.createReadStream(emptyFile, { fd });
 
   read.once('data', common.mustNotCall('data event should not emit'));
@@ -38,10 +35,7 @@ fs.open(emptyFile, 'r', common.mustCall((error, fd) => {
   read.once('end', common.mustCall());
 }));
 
-fs.open(emptyFile, 'r', common.mustCall((error, fd) => {
-
-  assert.ifError(error);
-
+fs.open(emptyFile, 'r', common.mustSucceed((fd) => {
   const read = fs.createReadStream(emptyFile, { fd });
 
   read.pause();
diff --git a/test/parallel/test-fs-error-messages.js b/test/parallel/test-fs-error-messages.js
index 05e4515ad40abdbd17607a8b9853c1f3e6c9c602..dd9639d99657b689a6f552532ba5d317a90dc39f 100644
--- a/test/parallel/test-fs-error-messages.js
+++ b/test/parallel/test-fs-error-messages.js
@@ -663,21 +663,17 @@ if (!common.isAIX) {
   );
 }
 
-// Check copyFile with invalid flags.
+// Check copyFile with invalid modes.
 {
   const validateError = {
-    // TODO: Make sure the error message always also contains the src.
-    message: `EINVAL: invalid argument, copyfile -> '${nonexistentFile}'`,
-    errno: UV_EINVAL,
-    code: 'EINVAL',
-    syscall: 'copyfile'
+    message: /"mode".+must be an integer >= 0 && <= 7\. Received -1/,
+    code: 'ERR_OUT_OF_RANGE'
   };
 
-  fs.copyFile(existingFile, nonexistentFile, -1,
-              common.expectsError(validateError));
-
-  validateError.message = 'EINVAL: invalid argument, copyfile ' +
-                          `'${existingFile}' -> '${nonexistentFile}'`;
+  assert.throws(
+    () => fs.copyFile(existingFile, nonexistentFile, -1, () => {}),
+    validateError
+  );
   assert.throws(
     () => fs.copyFileSync(existingFile, nonexistentFile, -1),
     validateError
diff --git a/test/parallel/test-fs-exists.js b/test/parallel/test-fs-exists.js
index cd2d9a712f3f58e74fc50632d736df5b28d56059..75b7adfc3ee3d04be8cba0eb2e6d6041f9ea26f4 100644
--- a/test/parallel/test-fs-exists.js
+++ b/test/parallel/test-fs-exists.js
@@ -23,7 +23,6 @@
 const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
-const { URL } = require('url');
 const f = __filename;
 
 assert.throws(() => fs.exists(f), { code: 'ERR_INVALID_CALLBACK' });
diff --git a/test/parallel/test-fs-existssync-false.js b/test/parallel/test-fs-existssync-false.js
index 3808750d7f304a4ffa4f05072e5330cab3cb873a..e81e6c7a3116684d4f7cb6243ca85f4a8abf403f 100644
--- a/test/parallel/test-fs-existssync-false.js
+++ b/test/parallel/test-fs-existssync-false.js
@@ -31,6 +31,4 @@ for (let i = 0; i < 50; i++) {
 assert(fs.existsSync(dir), 'Directory is not accessible');
 
 // Test if file exists asynchronously
-fs.access(dir, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.access(dir, common.mustSucceed());
diff --git a/test/parallel/test-fs-filehandle.js b/test/parallel/test-fs-filehandle.js
index 30f42a60f044b3fd623ea924b12314bfaf3a0bd1..818a38249044316b6a84d59a7dfd51de6668b7b2 100644
--- a/test/parallel/test-fs-filehandle.js
+++ b/test/parallel/test-fs-filehandle.js
@@ -19,13 +19,20 @@ let fdnum;
   assert.strictEqual(ctx.errno, undefined);
 }
 
+const deprecationWarning =
+  'Closing a FileHandle object on garbage collection is deprecated. ' +
+  'Please close FileHandle objects explicitly using ' +
+  'FileHandle.prototype.close(). In the future, an error will be ' +
+  'thrown if a file descriptor is closed during garbage collection.';
+
 common.expectWarning({
   'internal/test/binding': [
-    'These APIs are for internal testing only. Do not use them.'
+    'These APIs are for internal testing only. Do not use them.',
   ],
   'Warning': [
-    `Closing file descriptor ${fdnum} on garbage collection`
-  ]
+    `Closing file descriptor ${fdnum} on garbage collection`,
+  ],
+  'DeprecationWarning': [[deprecationWarning, 'DEP0137']]
 });
 
 global.gc();
diff --git a/test/parallel/test-fs-fsync.js b/test/parallel/test-fs-fsync.js
index 11eb321f86bfc65da7720a8fbffc2d09f06fb89c..c60fe0af728e396a8d0ffbc31ac2914e8704973c 100644
--- a/test/parallel/test-fs-fsync.js
+++ b/test/parallel/test-fs-fsync.js
@@ -35,17 +35,14 @@ const fileTemp = path.join(tmpdir.path, 'a.js');
 tmpdir.refresh();
 fs.copyFileSync(fileFixture, fileTemp);
 
-fs.open(fileTemp, 'a', 0o777, common.mustCall(function(err, fd) {
-  assert.ifError(err);
-
+fs.open(fileTemp, 'a', 0o777, common.mustSucceed((fd) => {
   fs.fdatasyncSync(fd);
 
   fs.fsyncSync(fd);
 
-  fs.fdatasync(fd, common.mustCall(function(err) {
-    assert.ifError(err);
-    fs.fsync(fd, common.mustCall(function(err) {
-      assert.ifError(err);
+  fs.fdatasync(fd, common.mustSucceed(() => {
+    fs.fsync(fd, common.mustSucceed(() => {
+      fs.closeSync(fd);
     }));
   }));
 }));
diff --git a/test/parallel/test-fs-lchown.js b/test/parallel/test-fs-lchown.js
index a554c8914b6f567cbbd4403a2a98e6502abb8d27..ba2b4b85fb9c9047248f378955b2be802d542a0a 100644
--- a/test/parallel/test-fs-lchown.js
+++ b/test/parallel/test-fs-lchown.js
@@ -58,8 +58,7 @@ if (!common.isWindows) {
   tmpdir.refresh();
   fs.copyFileSync(__filename, testFile);
   fs.lchownSync(testFile, uid, gid);
-  fs.lchown(testFile, uid, gid, common.mustCall(async (err) => {
-    assert.ifError(err);
+  fs.lchown(testFile, uid, gid, common.mustSucceed(async (err) => {
     await promises.lchown(testFile, uid, gid);
   }));
 }
diff --git a/test/parallel/test-fs-long-path.js b/test/parallel/test-fs-long-path.js
index 11ec4d56fcea3f7990195e21f952b677e4671f74..1cb66fa60461524793b3306ec649466b4c3fec95 100644
--- a/test/parallel/test-fs-long-path.js
+++ b/test/parallel/test-fs-long-path.js
@@ -26,7 +26,6 @@ if (!common.isWindows)
 
 const fs = require('fs');
 const path = require('path');
-const assert = require('assert');
 
 const tmpdir = require('../common/tmpdir');
 
@@ -42,14 +41,6 @@ console.log({
   fullPathLength: fullPath.length
 });
 
-fs.writeFile(fullPath, 'ok', common.mustCall(function(err) {
-  assert.ifError(err);
-
-  fs.stat(fullPath, common.mustCall(function(err, stats) {
-    assert.ifError(err);
-  }));
+fs.writeFile(fullPath, 'ok', common.mustSucceed(() => {
+  fs.stat(fullPath, common.mustSucceed());
 }));
-
-process.on('exit', function() {
-  fs.unlinkSync(fullPath);
-});
diff --git a/test/parallel/test-fs-mkdir-mode-mask.js b/test/parallel/test-fs-mkdir-mode-mask.js
index 40bd7bec441373cc91b6378dc01b491b1f774028..6e11d0fb2e36eb0e61e01fc101240712ebad875a 100644
--- a/test/parallel/test-fs-mkdir-mode-mask.js
+++ b/test/parallel/test-fs-mkdir-mode-mask.js
@@ -31,8 +31,7 @@ function test(mode, asString) {
 
   {
     const dir = path.join(tmpdir.path, `mkdir-${suffix}`);
-    fs.mkdir(dir, input, common.mustCall((err) => {
-      assert.ifError(err);
+    fs.mkdir(dir, input, common.mustSucceed(() => {
       assert.strictEqual(fs.statSync(dir).mode & 0o777, mode);
     }));
   }
diff --git a/test/parallel/test-fs-mkdir-rmdir.js b/test/parallel/test-fs-mkdir-rmdir.js
index 5e4982ba8576bf0eb79dc2a3c0b29d5d1e264602..80162934d1f3996111f4a0f123640b37651918c7 100644
--- a/test/parallel/test-fs-mkdir-rmdir.js
+++ b/test/parallel/test-fs-mkdir-rmdir.js
@@ -25,9 +25,7 @@ fs.rmdirSync(d);
 assert(!fs.existsSync(d));
 
 // Similarly test the Async version
-fs.mkdir(d, 0o666, common.mustCall(function(err) {
-  assert.ifError(err);
-
+fs.mkdir(d, 0o666, common.mustSucceed(() => {
   fs.mkdir(d, 0o666, common.mustCall(function(err) {
     assert.strictEqual(this, undefined);
     assert.ok(err, 'got no error');
diff --git a/test/parallel/test-fs-mkdir.js b/test/parallel/test-fs-mkdir.js
index 5e28d6b944b6e0e72b4bb37af9853b52b3699ffe..4124a638a202343c006e938593b992417c1bde7a 100644
--- a/test/parallel/test-fs-mkdir.js
+++ b/test/parallel/test-fs-mkdir.js
@@ -53,6 +53,25 @@ function nextdir() {
   }));
 }
 
+// fs.mkdir creates directory with mode passed as an options object
+{
+  const pathname = path.join(tmpdir.path, nextdir());
+
+  fs.mkdir(pathname, { mode: 0o777 }, common.mustCall(function(err) {
+    assert.strictEqual(err, null);
+    assert.strictEqual(fs.existsSync(pathname), true);
+  }));
+}
+
+// fs.mkdirSync creates directory with mode passed as an options object
+{
+  const pathname = path.join(tmpdir.path, nextdir());
+
+  fs.mkdirSync(pathname, { mode: 0o777 });
+
+  assert.strictEqual(fs.existsSync(pathname), true);
+}
+
 // mkdirSync successfully creates directory from given path
 {
   const pathname = path.join(tmpdir.path, nextdir());
diff --git a/test/parallel/test-fs-mkdtemp-prefix-check.js b/test/parallel/test-fs-mkdtemp-prefix-check.js
index 1d9d88232a067e53197178068c57a1c6f99aef0a..33a06914a46e10f0b6c1a9c9a30228e4b54743da 100644
--- a/test/parallel/test-fs-mkdtemp-prefix-check.js
+++ b/test/parallel/test-fs-mkdtemp-prefix-check.js
@@ -3,7 +3,7 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
-const prefixValues = [undefined, null, 0, true, false, 1, ''];
+const prefixValues = [undefined, null, 0, true, false, 1];
 
 function fail(value) {
   assert.throws(
diff --git a/test/parallel/test-fs-null-bytes.js b/test/parallel/test-fs-null-bytes.js
index beaea00969b6303ea78c2ea65a9e018eb09a5352..d4548c02c07009eb7544794f21106598a7083d1f 100644
--- a/test/parallel/test-fs-null-bytes.js
+++ b/test/parallel/test-fs-null-bytes.js
@@ -23,7 +23,6 @@
 const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
-const URL = require('url').URL;
 
 function check(async, sync) {
   const argsSync = Array.prototype.slice.call(arguments, 2);
diff --git a/test/parallel/test-fs-open-flags.js b/test/parallel/test-fs-open-flags.js
index bb5b7c6020c06262f9dbd5919403bee2a1cef860..8b2eddffbe0a92d7430c98d9cd34953f7d422127 100644
--- a/test/parallel/test-fs-open-flags.js
+++ b/test/parallel/test-fs-open-flags.js
@@ -38,8 +38,7 @@ const { O_APPEND = 0,
         O_SYNC = 0,
         O_DSYNC = 0,
         O_TRUNC = 0,
-        O_WRONLY = 0
-} = fs.constants;
+        O_WRONLY = 0 } = fs.constants;
 
 const { stringToFlags } = require('internal/fs/utils');
 
@@ -84,15 +83,12 @@ assert.throws(
   { code: 'ERR_INVALID_OPT_VALUE', name: 'TypeError' }
 );
 
-assert.throws(
-  () => stringToFlags(null),
-  { code: 'ERR_INVALID_OPT_VALUE', name: 'TypeError' }
-);
-
 if (common.isLinux || common.isOSX) {
   const tmpdir = require('../common/tmpdir');
   tmpdir.refresh();
   const file = path.join(tmpdir.path, 'a.js');
   fs.copyFileSync(fixtures.path('a.js'), file);
-  fs.open(file, O_DSYNC, common.mustCall(assert.ifError));
+  fs.open(file, O_DSYNC, common.mustSucceed((fd) => {
+    fs.closeSync(fd);
+  }));
 }
diff --git a/test/parallel/test-fs-open-mode-mask.js b/test/parallel/test-fs-open-mode-mask.js
index 4100fbb32c2046236fceff770296cea2336c60b1..bab89f98f0d1a72c005675b171297461eb751a71 100644
--- a/test/parallel/test-fs-open-mode-mask.js
+++ b/test/parallel/test-fs-open-mode-mask.js
@@ -29,8 +29,7 @@ function test(mode, asString) {
 
   {
     const file = path.join(tmpdir.path, `open-${suffix}.txt`);
-    fs.open(file, 'w+', input, common.mustCall((err, fd) => {
-      assert.ifError(err);
+    fs.open(file, 'w+', input, common.mustSucceed((fd) => {
       assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
       fs.closeSync(fd);
       assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
diff --git a/test/parallel/test-fs-open-no-close.js b/test/parallel/test-fs-open-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e432dd11d8084cde1b5a2fb40ce1afc3db81a4c
--- /dev/null
+++ b/test/parallel/test-fs-open-no-close.js
@@ -0,0 +1,24 @@
+'use strict';
+
+// Refs: https://github.com/nodejs/node/issues/34266
+// Failing to close a file should not keep the event loop open.
+
+const common = require('../common');
+const assert = require('assert');
+
+const fs = require('fs');
+
+const debuglog = (arg) => {
+  console.log(new Date().toLocaleString(), arg);
+};
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+{
+  fs.open(`${tmpdir.path}/dummy`, 'wx+', common.mustCall((err, fd) => {
+    debuglog('fs open() callback');
+    assert.ifError(err);
+  }));
+  debuglog('waiting for callback');
+}
diff --git a/test/parallel/test-fs-open.js b/test/parallel/test-fs-open.js
index c96c435c6c33b404702dbc5706c4d49866edc4fb..bf64089bf73dfbd170fd09b02a252324aa2a685a 100644
--- a/test/parallel/test-fs-open.js
+++ b/test/parallel/test-fs-open.js
@@ -38,25 +38,15 @@ assert.strictEqual(caughtException, true);
 
 fs.openSync(__filename);
 
-fs.open(__filename, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(__filename, common.mustSucceed());
 
-fs.open(__filename, 'r', common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(__filename, 'r', common.mustSucceed());
 
-fs.open(__filename, 'rs', common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(__filename, 'rs', common.mustSucceed());
 
-fs.open(__filename, 'r', 0, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(__filename, 'r', 0, common.mustSucceed());
 
-fs.open(__filename, 'r', null, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(__filename, 'r', null, common.mustSucceed());
 
 async function promise() {
   await fs.promises.open(__filename);
diff --git a/test/parallel/test-fs-opendir.js b/test/parallel/test-fs-opendir.js
index e5233e3a10914ada15453f758266eb8871887f85..4c4681ef48e2ff832283738e4449254a194fb901 100644
--- a/test/parallel/test-fs-opendir.js
+++ b/test/parallel/test-fs-opendir.js
@@ -65,8 +65,7 @@ const invalidCallbackObj = {
 }
 
 // Check the opendir async version
-fs.opendir(testDir, common.mustCall(function(err, dir) {
-  assert.ifError(err);
+fs.opendir(testDir, common.mustSucceed((dir) => {
   let sync = true;
   dir.read(common.mustCall((err, dirent) => {
     assert(!sync);
@@ -81,9 +80,7 @@ fs.opendir(testDir, common.mustCall(function(err, dir) {
       assert(!syncInner);
       assert.ifError(err);
 
-      dir.close(common.mustCall(function(err) {
-        assert.ifError(err);
-      }));
+      dir.close(common.mustSucceed());
     }));
     syncInner = false;
   }));
@@ -226,12 +223,11 @@ async function doAsyncIterInvalidCallbackTest() {
 }
 doAsyncIterInvalidCallbackTest().then(common.mustCall());
 
-// Check if directory already closed - throw an exception
+// Check first call to close() - should not report an error.
 async function doAsyncIterDirClosedTest() {
   const dir = await fs.promises.opendir(testDir);
   await dir.close();
-
-  assert.throws(() => dir.close(), dirclosedError);
+  await assert.rejects(() => dir.close(), dirclosedError);
 }
 doAsyncIterDirClosedTest().then(common.mustCall());
 
@@ -248,6 +244,12 @@ async function doConcurrentAsyncAndSyncOps() {
 }
 doConcurrentAsyncAndSyncOps().then(common.mustCall());
 
+// Check read throw exceptions on invalid callback
+{
+  const dir = fs.opendirSync(testDir);
+  assert.throws(() => dir.read('INVALID_CALLBACK'), /ERR_INVALID_CALLBACK/);
+}
+
 // Check that concurrent read() operations don't do weird things.
 async function doConcurrentAsyncOps() {
   const dir = await fs.promises.opendir(testDir);
@@ -270,3 +272,19 @@ async function doConcurrentAsyncMixedOps() {
   await promise2;
 }
 doConcurrentAsyncMixedOps().then(common.mustCall());
+
+// Check if directory already closed - the callback should pass an error.
+{
+  const dir = fs.opendirSync(testDir);
+  dir.closeSync();
+  dir.close(common.mustCall((error) => {
+    assert.strictEqual(error.code, dirclosedError.code);
+  }));
+}
+
+// Check if directory already closed - throw an promise exception.
+{
+  const dir = fs.opendirSync(testDir);
+  dir.closeSync();
+  assert.rejects(dir.close(), dirclosedError).then(common.mustCall());
+}
diff --git a/test/parallel/test-fs-options-immutable.js b/test/parallel/test-fs-options-immutable.js
index 85e016f8347828105321f83b1c42da97a4ed4ed3..b993d776e6e460f65d0a71b73cc8767002122c3a 100644
--- a/test/parallel/test-fs-options-immutable.js
+++ b/test/parallel/test-fs-options-immutable.js
@@ -1,12 +1,10 @@
 'use strict';
 const common = require('../common');
 
-/*
- * These tests make sure that the `options` object passed to these functions are
- * never altered.
- *
- * Refer: https://github.com/nodejs/node/issues/7655
- */
+// These tests make sure that the `options` object passed to these functions are
+// never altered.
+//
+// Refer: https://github.com/nodejs/node/issues/7655
 
 const assert = require('assert');
 const fs = require('fs');
@@ -46,7 +44,7 @@ if (common.canCreateSymLink()) {
   fs.appendFile(fileName, 'ABCD', options, common.mustCall(errHandler));
 }
 
-if (!common.isIBMi) { // IBMi does not suppport fs.watch()
+if (!common.isIBMi) { // IBMi does not support fs.watch()
   const watch = fs.watch(__filename, options, common.mustNotCall());
   watch.close();
 }
@@ -70,6 +68,6 @@ if (!common.isIBMi) { // IBMi does not suppport fs.watch()
 {
   const fileName = path.resolve(tmpdir.path, 'streams');
   fs.WriteStream(fileName, options).once('open', common.mustCall(() => {
-    fs.ReadStream(fileName, options);
-  }));
+    fs.ReadStream(fileName, options).destroy();
+  })).end();
 }
diff --git a/test/parallel/test-fs-promises-exists.js b/test/parallel/test-fs-promises-exists.js
new file mode 100644
index 0000000000000000000000000000000000000000..d56308257e6b1718af5b66edbb071f03d1bde5bd
--- /dev/null
+++ b/test/parallel/test-fs-promises-exists.js
@@ -0,0 +1,6 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.strictEqual(require('fs/promises'), require('fs').promises);
diff --git a/test/parallel/test-fs-promises-file-handle-append-file.js b/test/parallel/test-fs-promises-file-handle-append-file.js
index f9abef359e006438b2e5439253360b49f84cecca..90bb6e392516f4cb3128645404c60862cb5a41bf 100644
--- a/test/parallel/test-fs-promises-file-handle-append-file.js
+++ b/test/parallel/test-fs-promises-file-handle-append-file.js
@@ -22,6 +22,8 @@ async function validateAppendBuffer() {
   await fileHandle.appendFile(buffer);
   const appendedFileData = fs.readFileSync(filePath);
   assert.deepStrictEqual(appendedFileData, buffer);
+
+  await fileHandle.close();
 }
 
 async function validateAppendString() {
@@ -33,6 +35,8 @@ async function validateAppendString() {
   const stringAsBuffer = Buffer.from(string, 'utf8');
   const appendedFileData = fs.readFileSync(filePath);
   assert.deepStrictEqual(appendedFileData, stringAsBuffer);
+
+  await fileHandle.close();
 }
 
 validateAppendBuffer()
diff --git a/test/parallel/test-fs-promises-file-handle-chmod.js b/test/parallel/test-fs-promises-file-handle-chmod.js
index 2a05218969ee0a822d5c6560f6c0437ee9b6c10e..5a5f84be80ffd9398899470acd59305904436281 100644
--- a/test/parallel/test-fs-promises-file-handle-chmod.js
+++ b/test/parallel/test-fs-promises-file-handle-chmod.js
@@ -38,6 +38,8 @@ async function validateFilePermission() {
   await fileHandle.chmod(newPermissions);
   const statsAfterMod = fs.statSync(filePath);
   assert.deepStrictEqual(statsAfterMod.mode & expectedAccess, expectedAccess);
+
+  await fileHandle.close();
 }
 
 validateFilePermission().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-file-handle-close.js b/test/parallel/test-fs-promises-file-handle-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..d6417964746720d9354938d7028b963e326fa265
--- /dev/null
+++ b/test/parallel/test-fs-promises-file-handle-close.js
@@ -0,0 +1,41 @@
+// Flags: --expose-gc --no-warnings
+'use strict';
+
+// Test that a runtime warning is emitted when a FileHandle object
+// is allowed to close on garbage collection. In the future, this
+// test should verify that closing on garbage collection throws a
+// process fatal exception.
+
+const common = require('../common');
+const assert = require('assert');
+const { promises: fs } = require('fs');
+
+const warning =
+  'Closing a FileHandle object on garbage collection is deprecated. ' +
+  'Please close FileHandle objects explicitly using ' +
+  'FileHandle.prototype.close(). In the future, an error will be ' +
+  'thrown if a file descriptor is closed during garbage collection.';
+
+async function doOpen() {
+  const fh = await fs.open(__filename);
+
+  common.expectWarning({
+    Warning: [[`Closing file descriptor ${fh.fd} on garbage collection`]],
+    DeprecationWarning: [[warning, 'DEP0137']]
+  });
+
+  return fh;
+}
+
+doOpen().then(common.mustCall((fd) => {
+  assert.strictEqual(typeof fd, 'object');
+})).then(common.mustCall(() => {
+  setImmediate(() => {
+    // The FileHandle should be out-of-scope and no longer accessed now.
+    global.gc();
+
+    // Wait an extra event loop turn, as the warning is emitted from the
+    // native layer in an unref()'ed setImmediate() callback.
+    setImmediate(common.mustCall());
+  });
+}));
diff --git a/test/parallel/test-fs-promises-file-handle-read.js b/test/parallel/test-fs-promises-file-handle-read.js
index 13f8c277780d0747cda29c33e5e512d85b085949..74383a02e42fd94e63fc6d7e0c02ed75966d2e1b 100644
--- a/test/parallel/test-fs-promises-file-handle-read.js
+++ b/test/parallel/test-fs-promises-file-handle-read.js
@@ -13,7 +13,11 @@ const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
 const tmpDir = tmpdir.path;
 
-tmpdir.refresh();
+async function read(fileHandle, buffer, offset, length, position) {
+  return useConf ?
+    fileHandle.read({ buffer, offset, length, position }) :
+    fileHandle.read(buffer, offset, length, position);
+}
 
 async function validateRead() {
   const filePath = path.resolve(tmpDir, 'tmp-read-file.txt');
@@ -23,9 +27,11 @@ async function validateRead() {
   const fd = fs.openSync(filePath, 'w+');
   fs.writeSync(fd, buffer, 0, buffer.length);
   fs.closeSync(fd);
-  const readAsyncHandle = await fileHandle.read(Buffer.alloc(11), 0, 11, 0);
+  const readAsyncHandle = await read(fileHandle, Buffer.alloc(11), 0, 11, 0);
   assert.deepStrictEqual(buffer.length, readAsyncHandle.bytesRead);
   assert.deepStrictEqual(buffer, readAsyncHandle.buffer);
+
+  await fileHandle.close();
 }
 
 async function validateEmptyRead() {
@@ -36,8 +42,10 @@ async function validateEmptyRead() {
   const fd = fs.openSync(filePath, 'w+');
   fs.writeSync(fd, buffer, 0, buffer.length);
   fs.closeSync(fd);
-  const readAsyncHandle = await fileHandle.read(Buffer.alloc(11), 0, 11, 0);
+  const readAsyncHandle = await read(fileHandle, Buffer.alloc(11), 0, 11, 0);
   assert.deepStrictEqual(buffer.length, readAsyncHandle.bytesRead);
+
+  await fileHandle.close();
 }
 
 async function validateLargeRead() {
@@ -47,12 +55,29 @@ async function validateLargeRead() {
   const filePath = fixtures.path('x.txt');
   const fileHandle = await open(filePath, 'r');
   const pos = 0xffffffff + 1; // max-uint32 + 1
-  const readHandle = await fileHandle.read(Buffer.alloc(1), 0, 1, pos);
+  const readHandle = await read(fileHandle, Buffer.alloc(1), 0, 1, pos);
 
   assert.strictEqual(readHandle.bytesRead, 0);
 }
 
-validateRead()
-  .then(validateEmptyRead)
-  .then(validateLargeRead)
-  .then(common.mustCall());
+async function validateReadNoParams() {
+  const filePath = fixtures.path('x.txt');
+  const fileHandle = await open(filePath, 'r');
+  // Should not throw
+  await fileHandle.read();
+}
+
+let useConf = false;
+
+(async function() {
+  for (const value of [false, true]) {
+    tmpdir.refresh();
+    useConf = value;
+
+    await validateRead()
+          .then(validateEmptyRead)
+          .then(validateLargeRead)
+          .then(common.mustCall());
+  }
+  await validateReadNoParams();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-file-handle-readFile.js b/test/parallel/test-fs-promises-file-handle-readFile.js
index c31e175019a3fbdd71eec7295f281136c776d1ea..3a178f7f37ff258c77ba9341a3da730c45f060dc 100644
--- a/test/parallel/test-fs-promises-file-handle-readFile.js
+++ b/test/parallel/test-fs-promises-file-handle-readFile.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
@@ -6,9 +7,15 @@ const common = require('../common');
 // FileHandle.readFile method.
 
 const fs = require('fs');
-const { open } = fs.promises;
+const {
+  open,
+  readFile,
+  writeFile,
+  truncate,
+} = fs.promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
+const tick = require('../common/tick');
 const assert = require('assert');
 const tmpDir = tmpdir.path;
 
@@ -25,6 +32,8 @@ async function validateReadFile() {
 
   const readFileData = await fileHandle.readFile();
   assert.deepStrictEqual(buffer, readFileData);
+
+  await fileHandle.close();
 }
 
 async function validateReadFileProc() {
@@ -43,6 +52,75 @@ async function validateReadFileProc() {
   assert.ok(hostname.length > 0);
 }
 
+async function doReadAndCancel() {
+  // Signal aborted from the start
+  {
+    const filePathForHandle = path.resolve(tmpDir, 'dogs-running.txt');
+    const fileHandle = await open(filePathForHandle, 'w+');
+    const buffer = Buffer.from('Dogs running'.repeat(10000), 'utf8');
+    fs.writeFileSync(filePathForHandle, buffer);
+    const controller = new AbortController();
+    const { signal } = controller;
+    controller.abort();
+    await assert.rejects(readFile(fileHandle, { signal }), {
+      name: 'AbortError'
+    });
+    await fileHandle.close();
+  }
+
+  // Signal aborted on first tick
+  {
+    const filePathForHandle = path.resolve(tmpDir, 'dogs-running1.txt');
+    const fileHandle = await open(filePathForHandle, 'w+');
+    const buffer = Buffer.from('Dogs running'.repeat(10000), 'utf8');
+    fs.writeFileSync(filePathForHandle, buffer);
+    const controller = new AbortController();
+    const { signal } = controller;
+    process.nextTick(() => controller.abort());
+    await assert.rejects(readFile(fileHandle, { signal }), {
+      name: 'AbortError'
+    }, 'tick-0');
+    await fileHandle.close();
+  }
+
+  // Signal aborted right before buffer read
+  {
+    const newFile = path.resolve(tmpDir, 'dogs-running2.txt');
+    const buffer = Buffer.from('Dogs running'.repeat(1000), 'utf8');
+    fs.writeFileSync(newFile, buffer);
+
+    const fileHandle = await open(newFile, 'r');
+
+    const controller = new AbortController();
+    const { signal } = controller;
+    tick(1, () => controller.abort());
+    await assert.rejects(fileHandle.readFile({ signal, encoding: 'utf8' }), {
+      name: 'AbortError'
+    }, 'tick-1');
+
+    await fileHandle.close();
+  }
+
+  // Validate file size is within range for reading
+  {
+    // Variable taken from https://github.com/nodejs/node/blob/master/lib/internal/fs/promises.js#L5
+    const kIoMaxLength = 2 ** 31 - 1;
+
+    const newFile = path.resolve(tmpDir, 'dogs-running3.txt');
+    await writeFile(newFile, Buffer.from('0'));
+    await truncate(newFile, kIoMaxLength + 1);
+
+    const fileHandle = await open(newFile, 'r');
+
+    await assert.rejects(fileHandle.readFile(), {
+      name: 'RangeError',
+      code: 'ERR_FS_FILE_TOO_LARGE'
+    });
+    await fileHandle.close();
+  }
+}
+
 validateReadFile()
-  .then(() => validateReadFileProc())
+  .then(validateReadFileProc)
+  .then(doReadAndCancel)
   .then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-file-handle-stat.js b/test/parallel/test-fs-promises-file-handle-stat.js
index 19ee365213d302f550bb42ab07c93c08a533f25c..278d3700edc02888f681d183a3807dc6d0b2bf32 100644
--- a/test/parallel/test-fs-promises-file-handle-stat.js
+++ b/test/parallel/test-fs-promises-file-handle-stat.js
@@ -17,6 +17,7 @@ async function validateStat() {
   const fileHandle = await open(filePath, 'w+');
   const stats = await fileHandle.stat();
   assert.ok(stats.mtime instanceof Date);
+  await fileHandle.close();
 }
 
 validateStat()
diff --git a/test/parallel/test-fs-promises-file-handle-sync.js b/test/parallel/test-fs-promises-file-handle-sync.js
index fc6d00c0b8fc138bb9d2aaa7f0f8c5e7b30c6d70..53eb2424549f93f0c6b9402b514e7f8c4042c6cd 100644
--- a/test/parallel/test-fs-promises-file-handle-sync.js
+++ b/test/parallel/test-fs-promises-file-handle-sync.js
@@ -7,11 +7,22 @@ const tmpdir = require('../common/tmpdir');
 const { access, copyFile, open } = require('fs').promises;
 const path = require('path');
 
-async function validateSync() {
+async function validate() {
   tmpdir.refresh();
   const dest = path.resolve(tmpdir.path, 'baz.js');
+  await assert.rejects(
+    copyFile(fixtures.path('baz.js'), dest, 'r'),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /mode.*integer.*string/
+    }
+  );
   await copyFile(fixtures.path('baz.js'), dest);
-  await access(dest, 'r');
+  await assert.rejects(
+    access(dest, 'r'),
+    { code: 'ERR_INVALID_ARG_TYPE', message: /mode/ }
+  );
+  await access(dest);
   const handle = await open(dest, 'r+');
   await handle.datasync();
   await handle.sync();
@@ -20,6 +31,7 @@ async function validateSync() {
   const ret = await handle.read(Buffer.alloc(11), 0, 11, 0);
   assert.strictEqual(ret.bytesRead, 11);
   assert.deepStrictEqual(ret.buffer, buf);
+  await handle.close();
 }
 
-validateSync();
+validate();
diff --git a/test/parallel/test-fs-promises-file-handle-truncate.js b/test/parallel/test-fs-promises-file-handle-truncate.js
index 65f998db7485676191fe0c8adcefe512ab1bf491..ca83755f19e111b114b4d1fd3e0609b4639a3db9 100644
--- a/test/parallel/test-fs-promises-file-handle-truncate.js
+++ b/test/parallel/test-fs-promises-file-handle-truncate.js
@@ -20,6 +20,8 @@ async function validateTruncate() {
 
   await fileHandle.truncate(5);
   assert.deepStrictEqual((await readFile(filename)).toString(), 'Hello');
+
+  await fileHandle.close();
 }
 
 validateTruncate().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-file-handle-write.js b/test/parallel/test-fs-promises-file-handle-write.js
index da8cfc0a4bf96bbe8c62b1ee73573d41ce79664f..3c25842d8bf9cc0d3659240fe6178a9708737c37 100644
--- a/test/parallel/test-fs-promises-file-handle-write.js
+++ b/test/parallel/test-fs-promises-file-handle-write.js
@@ -22,6 +22,8 @@ async function validateWrite() {
   await fileHandle.write(buffer, 0, buffer.length);
   const readFileData = fs.readFileSync(filePathForHandle);
   assert.deepStrictEqual(buffer, readFileData);
+
+  await fileHandle.close();
 }
 
 async function validateEmptyWrite() {
@@ -32,6 +34,8 @@ async function validateEmptyWrite() {
   await fileHandle.write(buffer, 0, buffer.length);
   const readFileData = fs.readFileSync(filePathForHandle);
   assert.deepStrictEqual(buffer, readFileData);
+
+  await fileHandle.close();
 }
 
 async function validateNonUint8ArrayWrite() {
@@ -42,6 +46,8 @@ async function validateNonUint8ArrayWrite() {
   await fileHandle.write(buffer, 0, buffer.length);
   const readFileData = fs.readFileSync(filePathForHandle);
   assert.deepStrictEqual(Buffer.from(buffer, 'utf8'), readFileData);
+
+  await fileHandle.close();
 }
 
 async function validateNonStringValuesWrite() {
@@ -49,17 +55,18 @@ async function validateNonStringValuesWrite() {
   const fileHandle = await open(filePathForHandle, 'w+');
   const nonStringValues = [123, {}, new Map()];
   for (const nonStringValue of nonStringValues) {
-    await fileHandle.write(nonStringValue);
+    await assert.rejects(
+      fileHandle.write(nonStringValue),
+      { message: /"buffer"/, code: 'ERR_INVALID_ARG_TYPE' }
+    );
   }
 
-  const readFileData = fs.readFileSync(filePathForHandle);
-  const expected = ['123', '[object Object]', '[object Map]'].join('');
-  assert.deepStrictEqual(Buffer.from(expected, 'utf8'), readFileData);
+  await fileHandle.close();
 }
 
 Promise.all([
   validateWrite(),
   validateEmptyWrite(),
   validateNonUint8ArrayWrite(),
-  validateNonStringValuesWrite()
+  validateNonStringValuesWrite(),
 ]).then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-file-handle-writeFile.js b/test/parallel/test-fs-promises-file-handle-writeFile.js
index e39c59f5cae80cd55ffbed147f43325585dbbe25..6458144657dae94c9f7794ff6a446ca321e66642 100644
--- a/test/parallel/test-fs-promises-file-handle-writeFile.js
+++ b/test/parallel/test-fs-promises-file-handle-writeFile.js
@@ -1,13 +1,15 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
 
 // The following tests validate base functionality for the fs.promises
-// FileHandle.readFile method.
+// FileHandle.writeFile method.
 
 const fs = require('fs');
-const { open } = fs.promises;
+const { open, writeFile } = fs.promises;
 const path = require('path');
+const { Readable } = require('stream');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
 const tmpDir = tmpdir.path;
@@ -17,12 +19,183 @@ tmpdir.refresh();
 async function validateWriteFile() {
   const filePathForHandle = path.resolve(tmpDir, 'tmp-write-file2.txt');
   const fileHandle = await open(filePathForHandle, 'w+');
-  const buffer = Buffer.from('Hello world'.repeat(100), 'utf8');
+  try {
+    const buffer = Buffer.from('Hello world'.repeat(100), 'utf8');
 
-  await fileHandle.writeFile(buffer);
-  const readFileData = fs.readFileSync(filePathForHandle);
-  assert.deepStrictEqual(buffer, readFileData);
+    await fileHandle.writeFile(buffer);
+    const readFileData = fs.readFileSync(filePathForHandle);
+    assert.deepStrictEqual(buffer, readFileData);
+  } finally {
+    await fileHandle.close();
+  }
 }
 
-validateWriteFile()
-  .then(common.mustCall());
+// Signal aborted while writing file
+async function doWriteAndCancel() {
+  const filePathForHandle = path.resolve(tmpDir, 'dogs-running.txt');
+  const fileHandle = await open(filePathForHandle, 'w+');
+  try {
+    const buffer = Buffer.from('dogs running'.repeat(512 * 1024), 'utf8');
+    const controller = new AbortController();
+    const { signal } = controller;
+    process.nextTick(() => controller.abort());
+    await assert.rejects(writeFile(fileHandle, buffer, { signal }), {
+      name: 'AbortError'
+    });
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+const dest = path.resolve(tmpDir, 'tmp.txt');
+const otherDest = path.resolve(tmpDir, 'tmp-2.txt');
+const stream = Readable.from(['a', 'b', 'c']);
+const stream2 = Readable.from(['ümlaut', ' ', 'sechzig']);
+const iterable = {
+  expected: 'abc',
+  *[Symbol.iterator]() {
+    yield 'a';
+    yield 'b';
+    yield 'c';
+  }
+};
+function iterableWith(value) {
+  return {
+    *[Symbol.iterator]() {
+      yield value;
+    }
+  };
+}
+const bufferIterable = {
+  expected: 'abc',
+  *[Symbol.iterator]() {
+    yield Buffer.from('a');
+    yield Buffer.from('b');
+    yield Buffer.from('c');
+  }
+};
+const asyncIterable = {
+  expected: 'abc',
+  async* [Symbol.asyncIterator]() {
+    yield 'a';
+    yield 'b';
+    yield 'c';
+  }
+};
+
+async function doWriteStream() {
+  const fileHandle = await open(dest, 'w+');
+  try {
+    await fileHandle.writeFile(stream);
+    const expected = 'abc';
+    const data = fs.readFileSync(dest, 'utf-8');
+    assert.deepStrictEqual(data, expected);
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+async function doWriteStreamWithCancel() {
+  const controller = new AbortController();
+  const { signal } = controller;
+  process.nextTick(() => controller.abort());
+  const fileHandle = await open(otherDest, 'w+');
+  try {
+    await assert.rejects(
+      fileHandle.writeFile(stream, { signal }),
+      { name: 'AbortError' }
+    );
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+async function doWriteIterable() {
+  const fileHandle = await open(dest, 'w+');
+  try {
+    await fileHandle.writeFile(iterable);
+    const data = fs.readFileSync(dest, 'utf-8');
+    assert.deepStrictEqual(data, iterable.expected);
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+async function doWriteInvalidIterable() {
+  const fileHandle = await open(dest, 'w+');
+  try {
+    await Promise.all(
+      [42, 42n, {}, Symbol('42'), true, undefined, null, NaN].map((value) =>
+        assert.rejects(
+          fileHandle.writeFile(iterableWith(value)),
+          { code: 'ERR_INVALID_ARG_TYPE' }
+        )
+      )
+    );
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+async function doWriteIterableWithEncoding() {
+  const fileHandle = await open(dest, 'w+');
+  try {
+    await fileHandle.writeFile(stream2, 'latin1');
+    const expected = 'ümlaut sechzig';
+    const data = fs.readFileSync(dest, 'latin1');
+    assert.deepStrictEqual(data, expected);
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+async function doWriteBufferIterable() {
+  const fileHandle = await open(dest, 'w+');
+  try {
+    await fileHandle.writeFile(bufferIterable);
+    const data = fs.readFileSync(dest, 'utf-8');
+    assert.deepStrictEqual(data, bufferIterable.expected);
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+async function doWriteAsyncIterable() {
+  const fileHandle = await open(dest, 'w+');
+  try {
+    await fileHandle.writeFile(asyncIterable);
+    const data = fs.readFileSync(dest, 'utf-8');
+    assert.deepStrictEqual(data, asyncIterable.expected);
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+async function doWriteInvalidValues() {
+  const fileHandle = await open(dest, 'w+');
+  try {
+    await Promise.all(
+      [42, 42n, {}, Symbol('42'), true, undefined, null, NaN].map((value) =>
+        assert.rejects(
+          fileHandle.writeFile(value),
+          { code: 'ERR_INVALID_ARG_TYPE' }
+        )
+      )
+    );
+  } finally {
+    await fileHandle.close();
+  }
+}
+
+(async () => {
+  await validateWriteFile();
+  await doWriteAndCancel();
+  await doWriteStream();
+  await doWriteStreamWithCancel();
+  await doWriteIterable();
+  await doWriteInvalidIterable();
+  await doWriteIterableWithEncoding();
+  await doWriteBufferIterable();
+  await doWriteAsyncIterable();
+  await doWriteInvalidValues();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-readfile-with-fd.js b/test/parallel/test-fs-promises-readfile-with-fd.js
index 9bf4c18536494977e4f8c25983e1a0c3a96822ca..3d4b1dc168fe3086726c283ca8b576248666df9b 100644
--- a/test/parallel/test-fs-promises-readfile-with-fd.js
+++ b/test/parallel/test-fs-promises-readfile-with-fd.js
@@ -1,9 +1,7 @@
 'use strict';
 
-/*
- * This test makes sure that `readFile()` always reads from the current
- * position of the file, instead of reading from the beginning of the file.
- */
+// This test makes sure that `readFile()` always reads from the current
+// position of the file, instead of reading from the beginning of the file.
 
 const common = require('../common');
 const assert = require('assert');
@@ -28,6 +26,8 @@ async function readFileTest() {
 
   /* readFile() should read from position five, instead of zero. */
   assert.deepStrictEqual((await handle.readFile()).toString(), ' World');
+
+  await handle.close();
 }
 
 
diff --git a/test/parallel/test-fs-promises-readfile.js b/test/parallel/test-fs-promises-readfile.js
index ff25be75b84ff0375ecef487b6ee5e7044205842..28a191d41442eb0990ab405ba0b0db28189c1e68 100644
--- a/test/parallel/test-fs-promises-readfile.js
+++ b/test/parallel/test-fs-promises-readfile.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
@@ -10,18 +11,21 @@ tmpdir.refresh();
 
 const fn = path.join(tmpdir.path, 'large-file');
 
-async function validateReadFile() {
-  // Creating large buffer with random content
-  const buffer = Buffer.from(
-    Array.apply(null, { length: 16834 * 2 })
-      .map(Math.random)
-      .map((number) => (number * (1 << 8)))
-  );
+// Creating large buffer with random content
+const largeBuffer = Buffer.from(
+  Array.apply(null, { length: 16834 * 2 })
+    .map(Math.random)
+    .map((number) => (number * (1 << 8)))
+);
 
+async function createLargeFile() {
   // Writing buffer to a file then try to read it
-  await writeFile(fn, buffer);
+  await writeFile(fn, largeBuffer);
+}
+
+async function validateReadFile() {
   const readBuffer = await readFile(fn);
-  assert.strictEqual(readBuffer.equals(buffer), true);
+  assert.strictEqual(readBuffer.equals(largeBuffer), true);
 }
 
 async function validateReadFileProc() {
@@ -39,6 +43,40 @@ async function validateReadFileProc() {
   assert.ok(hostname.length > 0);
 }
 
-validateReadFile()
-  .then(() => validateReadFileProc())
-  .then(common.mustCall());
+function validateReadFileAbortLogicBefore() {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  controller.abort();
+  assert.rejects(readFile(fn, { signal }), {
+    name: 'AbortError'
+  });
+}
+
+function validateReadFileAbortLogicDuring() {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  process.nextTick(() => controller.abort());
+  assert.rejects(readFile(fn, { signal }), {
+    name: 'AbortError'
+  });
+}
+
+async function validateWrongSignalParam() {
+  // Verify that if something different than Abortcontroller.signal
+  // is passed, ERR_INVALID_ARG_TYPE is thrown
+
+  await assert.rejects(async () => {
+    const callback = common.mustNotCall(() => {});
+    await readFile(fn, { signal: 'hello' }, callback);
+  }, { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+
+}
+
+(async () => {
+  await createLargeFile();
+  await validateReadFile();
+  await validateReadFileProc();
+  await validateReadFileAbortLogicBefore();
+  await validateReadFileAbortLogicDuring();
+  await validateWrongSignalParam();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-watch.js b/test/parallel/test-fs-promises-watch.js
new file mode 100644
index 0000000000000000000000000000000000000000..af964252aaf9b6d5497b737cb8210f7ce867ef6e
--- /dev/null
+++ b/test/parallel/test-fs-promises-watch.js
@@ -0,0 +1,116 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+const { watch } = require('fs/promises');
+const fs = require('fs');
+const assert = require('assert');
+const { join } = require('path');
+const tmpdir = require('../common/tmpdir');
+
+class WatchTestCase {
+  constructor(shouldInclude, dirName, fileName, field) {
+    this.dirName = dirName;
+    this.fileName = fileName;
+    this.field = field;
+    this.shouldSkip = !shouldInclude;
+  }
+  get dirPath() { return join(tmpdir.path, this.dirName); }
+  get filePath() { return join(this.dirPath, this.fileName); }
+}
+
+const kCases = [
+  // Watch on a directory should callback with a filename on supported systems
+  new WatchTestCase(
+    common.isLinux || common.isOSX || common.isWindows || common.isAIX,
+    'watch1',
+    'foo',
+    'filePath'
+  ),
+  // Watch on a file should callback with a filename on supported systems
+  new WatchTestCase(
+    common.isLinux || common.isOSX || common.isWindows,
+    'watch2',
+    'bar',
+    'dirPath'
+  ),
+];
+
+tmpdir.refresh();
+
+for (const testCase of kCases) {
+  if (testCase.shouldSkip) continue;
+  fs.mkdirSync(testCase.dirPath);
+  // Long content so it's actually flushed.
+  const content1 = Date.now() + testCase.fileName.toLowerCase().repeat(1e4);
+  fs.writeFileSync(testCase.filePath, content1);
+
+  async function test() {
+    const watcher = watch(testCase[testCase.field]);
+    for await (const { eventType, filename } of watcher) {
+      assert.strictEqual(['rename', 'change'].includes(eventType), true);
+      assert.strictEqual(filename, testCase.fileName);
+      break;
+    }
+
+    // Waiting on it again is a non-op
+    // eslint-disable-next-line no-unused-vars
+    for await (const p of watcher) {
+      assert.fail('should not run');
+    }
+  }
+
+  // Long content so it's actually flushed. toUpperCase so there's real change.
+  const content2 = Date.now() + testCase.fileName.toUpperCase().repeat(1e4);
+  setImmediate(() => {
+    fs.writeFileSync(testCase.filePath, '');
+    fs.writeFileSync(testCase.filePath, content2);
+  });
+
+  test().then(common.mustCall());
+}
+
+assert.rejects(
+  // eslint-disable-next-line no-unused-vars
+  async () => { for await (const _ of watch(1)) {} },
+  { code: 'ERR_INVALID_ARG_TYPE' });
+
+assert.rejects(
+  // eslint-disable-next-line no-unused-vars
+  async () => { for await (const _ of watch(__filename, 1)) {} },
+  { code: 'ERR_INVALID_ARG_TYPE' });
+
+assert.rejects(
+  // eslint-disable-next-line no-unused-vars
+  async () => { for await (const _ of watch('', { persistent: 1 })) {} },
+  { code: 'ERR_INVALID_ARG_TYPE' });
+
+assert.rejects(
+  // eslint-disable-next-line no-unused-vars
+  async () => { for await (const _ of watch('', { recursive: 1 })) {} },
+  { code: 'ERR_INVALID_ARG_TYPE' });
+
+assert.rejects(
+  // eslint-disable-next-line no-unused-vars
+  async () => { for await (const _ of watch('', { encoding: 1 })) {} },
+  { code: 'ERR_INVALID_ARG_VALUE' });
+
+assert.rejects(
+  // eslint-disable-next-line no-unused-vars
+  async () => { for await (const _ of watch('', { signal: 1 })) {} },
+  { code: 'ERR_INVALID_ARG_TYPE' });
+
+(async () => {
+  const ac = new AbortController();
+  const { signal } = ac;
+  setImmediate(() => ac.abort());
+  try {
+    // eslint-disable-next-line no-unused-vars
+    for await (const _ of watch(__filename, { signal })) {}
+  } catch (err) {
+    assert.strictEqual(err.name, 'AbortError');
+  }
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-writefile-typedarray.js b/test/parallel/test-fs-promises-writefile-typedarray.js
new file mode 100644
index 0000000000000000000000000000000000000000..32d9cffa236e571d067b34bb020f2cc781cd439a
--- /dev/null
+++ b/test/parallel/test-fs-promises-writefile-typedarray.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const fsPromises = fs.promises;
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const tmpDir = tmpdir.path;
+
+tmpdir.refresh();
+
+const dest = path.resolve(tmpDir, 'tmp.txt');
+// Use a file size larger than `kReadFileMaxChunkSize`.
+const buffer = Buffer.from('012'.repeat(2 ** 14));
+
+(async () => {
+  for (const Constructor of [Uint8Array, Uint16Array, Uint32Array]) {
+    const array = new Constructor(buffer.buffer);
+    await fsPromises.writeFile(dest, array);
+    const data = await fsPromises.readFile(dest);
+    assert.deepStrictEqual(data, buffer);
+  }
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-writefile-with-fd.js b/test/parallel/test-fs-promises-writefile-with-fd.js
index a4cc31df7f4d5f58228eb9b62b9535852b75ec0f..35a493f8cdd25c654d10eb60440b6fc24f2087fe 100644
--- a/test/parallel/test-fs-promises-writefile-with-fd.js
+++ b/test/parallel/test-fs-promises-writefile-with-fd.js
@@ -1,9 +1,7 @@
 'use strict';
 
-/*
- * This test makes sure that `writeFile()` always writes from the current
- * position of the file, instead of truncating the file.
- */
+// This test makes sure that `writeFile()` always writes from the current
+// position of the file, instead of truncating the file.
 
 const common = require('../common');
 const assert = require('assert');
@@ -29,6 +27,8 @@ async function writeFileTest() {
 
   /* New content should be written at position five, instead of zero. */
   assert.deepStrictEqual(readFileSync(fn).toString(), 'HelloWorld');
+
+  await handle.close();
 }
 
 
diff --git a/test/parallel/test-fs-promises-writefile.js b/test/parallel/test-fs-promises-writefile.js
index 858e90bc6291de5f0a5109cd9de7cbab24f0daaf..2be52ccbaa875f56701eef0722fa184fceebf923 100644
--- a/test/parallel/test-fs-promises-writefile.js
+++ b/test/parallel/test-fs-promises-writefile.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 
 const common = require('../common');
@@ -7,12 +8,47 @@ const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
 const tmpDir = tmpdir.path;
+const { Readable } = require('stream');
 
 tmpdir.refresh();
 
 const dest = path.resolve(tmpDir, 'tmp.txt');
+const otherDest = path.resolve(tmpDir, 'tmp-2.txt');
 const buffer = Buffer.from('abc'.repeat(1000));
 const buffer2 = Buffer.from('xyz'.repeat(1000));
+const stream = Readable.from(['a', 'b', 'c']);
+const stream2 = Readable.from(['ümlaut', ' ', 'sechzig']);
+const iterable = {
+  expected: 'abc',
+  *[Symbol.iterator]() {
+    yield 'a';
+    yield 'b';
+    yield 'c';
+  }
+};
+function iterableWith(value) {
+  return {
+    *[Symbol.iterator]() {
+      yield value;
+    }
+  };
+}
+const bufferIterable = {
+  expected: 'abc',
+  *[Symbol.iterator]() {
+    yield Buffer.from('a');
+    yield Buffer.from('b');
+    yield Buffer.from('c');
+  }
+};
+const asyncIterable = {
+  expected: 'abc',
+  async* [Symbol.asyncIterator]() {
+    yield 'a';
+    yield 'b';
+    yield 'c';
+  }
+};
 
 async function doWrite() {
   await fsPromises.writeFile(dest, buffer);
@@ -20,8 +56,80 @@ async function doWrite() {
   assert.deepStrictEqual(data, buffer);
 }
 
+async function doWriteStream() {
+  await fsPromises.writeFile(dest, stream);
+  const expected = 'abc';
+  const data = fs.readFileSync(dest, 'utf-8');
+  assert.deepStrictEqual(data, expected);
+}
+
+async function doWriteStreamWithCancel() {
+  const controller = new AbortController();
+  const { signal } = controller;
+  process.nextTick(() => controller.abort());
+  await assert.rejects(
+    fsPromises.writeFile(otherDest, stream, { signal }),
+    { name: 'AbortError' }
+  );
+}
+
+async function doWriteIterable() {
+  await fsPromises.writeFile(dest, iterable);
+  const data = fs.readFileSync(dest, 'utf-8');
+  assert.deepStrictEqual(data, iterable.expected);
+}
+
+async function doWriteInvalidIterable() {
+  await Promise.all(
+    [42, 42n, {}, Symbol('42'), true, undefined, null, NaN].map((value) =>
+      assert.rejects(fsPromises.writeFile(dest, iterableWith(value)), {
+        code: 'ERR_INVALID_ARG_TYPE',
+      })
+    )
+  );
+}
+
+async function doWriteIterableWithEncoding() {
+  await fsPromises.writeFile(dest, stream2, 'latin1');
+  const expected = 'ümlaut sechzig';
+  const data = fs.readFileSync(dest, 'latin1');
+  assert.deepStrictEqual(data, expected);
+}
+
+async function doWriteBufferIterable() {
+  await fsPromises.writeFile(dest, bufferIterable);
+  const data = fs.readFileSync(dest, 'utf-8');
+  assert.deepStrictEqual(data, bufferIterable.expected);
+}
+
+async function doWriteAsyncIterable() {
+  await fsPromises.writeFile(dest, asyncIterable);
+  const data = fs.readFileSync(dest, 'utf-8');
+  assert.deepStrictEqual(data, asyncIterable.expected);
+}
+
+async function doWriteInvalidValues() {
+  await Promise.all(
+    [42, 42n, {}, Symbol('42'), true, undefined, null, NaN].map((value) =>
+      assert.rejects(fsPromises.writeFile(dest, value), {
+        code: 'ERR_INVALID_ARG_TYPE',
+      })
+    )
+  );
+}
+
+async function doWriteWithCancel() {
+  const controller = new AbortController();
+  const { signal } = controller;
+  process.nextTick(() => controller.abort());
+  await assert.rejects(
+    fsPromises.writeFile(otherDest, buffer, { signal }),
+    { name: 'AbortError' }
+  );
+}
+
 async function doAppend() {
-  await fsPromises.appendFile(dest, buffer2);
+  await fsPromises.appendFile(dest, buffer2, { flag: null });
   const data = fs.readFileSync(dest);
   const buf = Buffer.concat([buffer, buffer2]);
   assert.deepStrictEqual(buf, data);
@@ -40,8 +148,18 @@ async function doReadWithEncoding() {
   assert.deepStrictEqual(data, syncData);
 }
 
-doWrite()
-  .then(doAppend)
-  .then(doRead)
-  .then(doReadWithEncoding)
-  .then(common.mustCall());
+(async () => {
+  await doWrite();
+  await doWriteWithCancel();
+  await doAppend();
+  await doRead();
+  await doReadWithEncoding();
+  await doWriteStream();
+  await doWriteStreamWithCancel();
+  await doWriteIterable();
+  await doWriteInvalidIterable();
+  await doWriteIterableWithEncoding();
+  await doWriteBufferIterable();
+  await doWriteAsyncIterable();
+  await doWriteInvalidValues();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises.js b/test/parallel/test-fs-promises.js
index 34f41d0b580fd3ced036636c15657ae9e8dd7cac..35d2deff8b814815d9f93ed3d4a458dbb80ecd45 100644
--- a/test/parallel/test-fs-promises.js
+++ b/test/parallel/test-fs-promises.js
@@ -16,6 +16,7 @@ const {
   link,
   lchmod,
   lstat,
+  lutimes,
   mkdir,
   mkdtemp,
   open,
@@ -47,17 +48,33 @@ assert.strictEqual(
 );
 
 {
-  access(__filename, 'r')
+  access(__filename, 0)
     .then(common.mustCall());
 
-  access('this file does not exist', 'r')
-    .then(common.mustNotCall())
-    .catch(common.expectsError({
+  assert.rejects(
+    access('this file does not exist', 0),
+    {
       code: 'ENOENT',
       name: 'Error',
-      message:
-        /^ENOENT: no such file or directory, access/
-    }));
+      message: /^ENOENT: no such file or directory, access/
+    }
+  );
+
+  assert.rejects(
+    access(__filename, 8),
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      message: /"mode".*must be an integer >= 0 && <= 7\. Received 8$/
+    }
+  );
+
+  assert.rejects(
+    access(__filename, { [Symbol.toPrimitive]() { return 5; } }),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /"mode" argument.+integer\. Received an instance of Object$/
+    }
+  );
 }
 
 function verifyStatObject(stat) {
@@ -68,7 +85,7 @@ function verifyStatObject(stat) {
 
 async function getHandle(dest) {
   await copyFile(fixtures.path('baz.js'), dest);
-  await access(dest, 'r');
+  await access(dest);
 
   return open(dest, 'r+');
 }
@@ -83,6 +100,7 @@ async function getHandle(dest) {
     {
       const handle = await getHandle(dest);
       assert.strictEqual(typeof handle, 'object');
+      await handle.close();
     }
 
     // file stats
@@ -106,6 +124,7 @@ async function getHandle(dest) {
 
       await handle.datasync();
       await handle.sync();
+      await handle.close();
     }
 
     // Test fs.read promises when length to read is zero bytes
@@ -119,6 +138,14 @@ async function getHandle(dest) {
       assert.strictEqual(ret.bytesRead, 0);
 
       await unlink(dest);
+      await handle.close();
+    }
+
+    // Use fallback buffer allocation when input not buffer
+    {
+      const handle = await getHandle(dest);
+      const ret = await handle.read(0, 0, 0, 0);
+      assert.strictEqual(ret.buffer.length, 16384);
     }
 
     // Bytes written to file match buffer
@@ -130,6 +157,7 @@ async function getHandle(dest) {
       const ret = await handle.read(Buffer.alloc(bufLen), 0, bufLen, 0);
       assert.strictEqual(ret.bytesRead, bufLen);
       assert.deepStrictEqual(ret.buffer, buf);
+      await handle.close();
     }
 
     // Truncate file to specified length
@@ -143,6 +171,7 @@ async function getHandle(dest) {
       assert.deepStrictEqual(ret.buffer, buf);
       await truncate(dest, 5);
       assert.deepStrictEqual((await readFile(dest)).toString(), 'hello');
+      await handle.close();
     }
 
     // Invalid change of ownership
@@ -162,25 +191,27 @@ async function getHandle(dest) {
 
       assert.rejects(
         async () => {
-          await chown(dest, 1, -1);
+          await chown(dest, 1, -2);
         },
         {
           code: 'ERR_OUT_OF_RANGE',
           name: 'RangeError',
           message: 'The value of "gid" is out of range. ' +
-                  'It must be >= 0 && < 4294967296. Received -1'
+                  'It must be >= -1 && <= 4294967295. Received -2'
         });
 
       assert.rejects(
         async () => {
-          await handle.chown(1, -1);
+          await handle.chown(1, -2);
         },
         {
           code: 'ERR_OUT_OF_RANGE',
           name: 'RangeError',
           message: 'The value of "gid" is out of range. ' +
-                    'It must be >= 0 && < 4294967296. Received -1'
+                    'It must be >= -1 && <= 4294967295. Received -2'
         });
+
+      await handle.close();
     }
 
     // Set modification times
@@ -203,6 +234,19 @@ async function getHandle(dest) {
       await handle.close();
     }
 
+    // Set modification times with lutimes
+    {
+      const a_time = new Date();
+      a_time.setMinutes(a_time.getMinutes() - 1);
+      const m_time = new Date();
+      m_time.setHours(m_time.getHours() - 1);
+      await lutimes(dest, a_time, m_time);
+      const stats = await stat(dest);
+
+      assert.strictEqual(a_time.toString(), stats.atime.toString());
+      assert.strictEqual(m_time.toString(), stats.mtime.toString());
+    }
+
     // create symlink
     {
       const newPath = path.resolve(tmpDir, 'baz2.js');
@@ -239,7 +283,7 @@ async function getHandle(dest) {
                 name: 'Error',
                 message: 'The lchmod() method is not implemented'
               })
-            )
+            ),
           ]);
         }
 
@@ -247,6 +291,15 @@ async function getHandle(dest) {
       }
     }
 
+    // specify symlink type
+    {
+      const dir = path.join(tmpDir, nextdir());
+      await symlink(tmpDir, dir, 'dir');
+      const stats = await lstat(dir);
+      assert.strictEqual(stats.isSymbolicLink(), true);
+      await unlink(dir);
+    }
+
     // create hard link
     {
       const newPath = path.resolve(tmpDir, 'baz2.js');
@@ -273,6 +326,14 @@ async function getHandle(dest) {
       await unlink(newFile);
     }
 
+    // Use fallback encoding when input is null
+    {
+      const newFile = path.resolve(tmpDir, 'dogs_running.js');
+      await writeFile(newFile, 'dogs running', { encoding: null });
+      const fileExists = fs.existsSync(newFile);
+      assert.strictEqual(fileExists, true);
+    }
+
     // `mkdir` when options is number.
     {
       const dir = path.join(tmpDir, nextdir());
@@ -301,7 +362,7 @@ async function getHandle(dest) {
     {
       const dir = path.join(tmpDir, nextdir(), nextdir());
       await mkdir(path.dirname(dir));
-      await writeFile(dir);
+      await writeFile(dir, '');
       assert.rejects(
         mkdir(dir, { recursive: true }),
         {
@@ -318,7 +379,7 @@ async function getHandle(dest) {
       const file = path.join(tmpDir, nextdir(), nextdir());
       const dir = path.join(file, nextdir(), nextdir());
       await mkdir(path.dirname(file));
-      await writeFile(file);
+      await writeFile(file, '');
       assert.rejects(
         mkdir(dir, { recursive: true }),
         {
diff --git a/test/parallel/test-fs-read-empty-buffer.js b/test/parallel/test-fs-read-empty-buffer.js
index 8ca08448182d4a20757036e7254bef70afd42c95..7ec5e5c186f5ebbe7ed7889cd049fd9e91d16c6f 100644
--- a/test/parallel/test-fs-read-empty-buffer.js
+++ b/test/parallel/test-fs-read-empty-buffer.js
@@ -38,4 +38,4 @@ assert.throws(
                'Received Uint8Array(0) []'
     }
   );
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-read-offset-null.js b/test/parallel/test-fs-read-offset-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..27e893f781b2ff126f1b0aaa44929218101f2e6b
--- /dev/null
+++ b/test/parallel/test-fs-read-offset-null.js
@@ -0,0 +1,42 @@
+'use strict';
+
+
+// Test to assert the desired functioning of fs.read
+// when {offset:null} is passed as options parameter
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const fsPromises = fs.promises;
+const fixtures = require('../common/fixtures');
+const filepath = fixtures.path('x.txt');
+
+const buf = Buffer.alloc(1);
+// Reading only one character, hence buffer of one byte is enough.
+
+// Test for callback API.
+fs.open(filepath, 'r', common.mustSucceed((fd) => {
+  fs.read(fd, { offset: null, buffer: buf },
+          common.mustSucceed((bytesRead, buffer) => {
+            // Test is done by making sure the first letter in buffer is
+            // same as first letter in file.
+            // 120 is the hex for ascii code of letter x.
+            assert.strictEqual(buffer[0], 120);
+            fs.close(fd, common.mustSucceed(() => {}));
+          }));
+}));
+
+let filehandle = null;
+
+// Test for promise api
+(async () => {
+  filehandle = await fsPromises.open(filepath, 'r');
+  const readObject = await filehandle.read(buf, null, buf.length);
+  assert.strictEqual(readObject.buffer[0], 120);
+})()
+.then(common.mustCall())
+.finally(async () => {
+// Close the file handle if it is opened
+  if (filehandle)
+    await filehandle.close();
+});
diff --git a/test/parallel/test-fs-read-optional-params.js b/test/parallel/test-fs-read-optional-params.js
index bae99da3c0ebd0de79b5faf01239af9a1662d654..aac5f51d0bb2db1f62ef464b6a90d8c6f2d25019 100644
--- a/test/parallel/test-fs-read-optional-params.js
+++ b/test/parallel/test-fs-read-optional-params.js
@@ -11,14 +11,14 @@ const expected = Buffer.from('xyz\n');
 const defaultBufferAsync = Buffer.alloc(16384);
 const bufferAsOption = Buffer.allocUnsafe(expected.length);
 
-// Test passing in an empty options object
-fs.read(fd, { position: 0 }, common.mustCall((err, bytesRead, buffer) => {
+// Test not passing in any options object
+fs.read(fd, common.mustCall((err, bytesRead, buffer) => {
   assert.strictEqual(bytesRead, expected.length);
   assert.deepStrictEqual(defaultBufferAsync.length, buffer.length);
 }));
 
-// Test not passing in any options object
-fs.read(fd, common.mustCall((err, bytesRead, buffer) => {
+// Test passing in an empty options object
+fs.read(fd, { position: 0 }, common.mustCall((err, bytesRead, buffer) => {
   assert.strictEqual(bytesRead, expected.length);
   assert.deepStrictEqual(defaultBufferAsync.length, buffer.length);
 }));
diff --git a/test/parallel/test-fs-read-stream-autoClose.js b/test/parallel/test-fs-read-stream-autoClose.js
new file mode 100644
index 0000000000000000000000000000000000000000..e7989ee7911264ab55f7aa76c9006fc9199457b0
--- /dev/null
+++ b/test/parallel/test-fs-read-stream-autoClose.js
@@ -0,0 +1,16 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const writeFile = path.join(tmpdir.path, 'write-autoClose.txt');
+tmpdir.refresh();
+
+const file = fs.createWriteStream(writeFile, { autoClose: true });
+
+file.on('finish', common.mustCall(() => {
+  assert.strictEqual(file.destroyed, false);
+}));
+file.end('asd');
diff --git a/test/parallel/test-fs-read-stream-patch-open.js b/test/parallel/test-fs-read-stream-patch-open.js
new file mode 100644
index 0000000000000000000000000000000000000000..c658105132b155b1c702bc7cc044a3f5ac1dc366
--- /dev/null
+++ b/test/parallel/test-fs-read-stream-patch-open.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+
+common.expectWarning(
+  'DeprecationWarning',
+  'ReadStream.prototype.open() is deprecated', 'DEP0135');
+const s = fs.createReadStream('asd')
+  // We don't care about errors in this test.
+  .on('error', () => {});
+s.open();
+
+// Allow overriding open().
+fs.ReadStream.prototype.open = common.mustCall();
+fs.createReadStream('asd');
diff --git a/test/parallel/test-fs-read-stream-pos.js b/test/parallel/test-fs-read-stream-pos.js
new file mode 100644
index 0000000000000000000000000000000000000000..c9470cb23ddeb6eaf51e4528b693ea2d8e77184d
--- /dev/null
+++ b/test/parallel/test-fs-read-stream-pos.js
@@ -0,0 +1,69 @@
+'use strict';
+
+// Refs: https://github.com/nodejs/node/issues/33940
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+const assert = require('assert');
+const path = require('path');
+
+tmpdir.refresh();
+
+const file = path.join(tmpdir.path, '/read_stream_pos_test.txt');
+
+fs.writeFileSync(file, '');
+
+let counter = 0;
+
+setInterval(() => {
+  counter = counter + 1;
+  const line = `hello at ${counter}\n`;
+  fs.writeFileSync(file, line, { flag: 'a' });
+}, 1);
+
+const hwm = 10;
+let bufs = [];
+let isLow = false;
+let cur = 0;
+let stream;
+
+setInterval(() => {
+  if (stream) return;
+
+  stream = fs.createReadStream(file, {
+    highWaterMark: hwm,
+    start: cur
+  });
+  stream.on('data', common.mustCallAtLeast((chunk) => {
+    cur += chunk.length;
+    bufs.push(chunk);
+    if (isLow) {
+      const brokenLines = Buffer.concat(bufs).toString()
+        .split('\n')
+        .filter((line) => {
+          const s = 'hello at'.slice(0, line.length);
+          if (line && !line.startsWith(s)) {
+            return true;
+          }
+          return false;
+        });
+      assert.strictEqual(brokenLines.length, 0);
+      process.exit();
+      return;
+    }
+    if (chunk.length !== hwm) {
+      isLow = true;
+    }
+  }));
+  stream.on('end', () => {
+    stream = null;
+    isLow = false;
+    bufs = [];
+  });
+}, 10);
+
+// Time longer than 90 seconds to exit safely
+setTimeout(() => {
+  process.exit();
+}, 90000);
diff --git a/test/parallel/test-fs-read-stream-throw-type-error.js b/test/parallel/test-fs-read-stream-throw-type-error.js
index 83b9387cc38da9f2fb9afad26f5409614d34baca..a01d23d5abdd102672c4c5fca40314ba6bfaaad6 100644
--- a/test/parallel/test-fs-read-stream-throw-type-error.js
+++ b/test/parallel/test-fs-read-stream-throw-type-error.js
@@ -43,7 +43,7 @@ const rangeError = {
 [
   { start: 'invalid' },
   { end: 'invalid' },
-  { start: 'invalid', end: 'invalid' }
+  { start: 'invalid', end: 'invalid' },
 ].forEach((opts) => createReadStreamErr(example, opts, typeError));
 
 // Case 2: Should throw RangeError if either start or end is NaN
@@ -71,7 +71,7 @@ createReadStreamErr(example, { start: 5, end: 1 }, rangeError);
 const NOT_SAFE_INTEGER = 2 ** 53;
 [
   { start: NOT_SAFE_INTEGER, end: Infinity },
-  { start: 0, end: NOT_SAFE_INTEGER }
+  { start: 0, end: NOT_SAFE_INTEGER },
 ].forEach((opts) =>
   createReadStreamErr(example, opts, rangeError)
 );
diff --git a/test/parallel/test-fs-read-type.js b/test/parallel/test-fs-read-type.js
index d95c88c47e7c26d0c0a6705c37bb597dd618519d..79d6c32be1ffa630b0c866ebff20a267e6c85da6 100644
--- a/test/parallel/test-fs-read-type.js
+++ b/test/parallel/test-fs-read-type.js
@@ -44,8 +44,20 @@ assert.throws(() => {
 }, {
   code: 'ERR_OUT_OF_RANGE',
   name: 'RangeError',
-  message: 'The value of "offset" is out of range. It must be >= 0. ' +
-           'Received -1'
+});
+
+assert.throws(() => {
+  fs.read(fd,
+          Buffer.allocUnsafe(expected.length),
+          NaN,
+          expected.length,
+          0,
+          common.mustNotCall());
+}, {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError',
+  message: 'The value of "offset" is out of range. It must be an integer. ' +
+           'Received NaN'
 });
 
 assert.throws(() => {
@@ -62,6 +74,51 @@ assert.throws(() => {
            'It must be >= 0. Received -1'
 });
 
+[true, () => {}, {}, ''].forEach((value) => {
+  assert.throws(() => {
+    fs.read(fd,
+            Buffer.allocUnsafe(expected.length),
+            0,
+            expected.length,
+            value,
+            common.mustNotCall());
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  });
+});
+
+[0.5, 2 ** 53, 2n ** 63n].forEach((value) => {
+  assert.throws(() => {
+    fs.read(fd,
+            Buffer.allocUnsafe(expected.length),
+            0,
+            expected.length,
+            value,
+            common.mustNotCall());
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError'
+  });
+});
+
+fs.read(fd,
+        Buffer.allocUnsafe(expected.length),
+        0,
+        expected.length,
+        0n,
+        common.mustSucceed());
+
+fs.read(fd,
+        Buffer.allocUnsafe(expected.length),
+        0,
+        expected.length,
+        2n ** 53n - 1n,
+        common.mustCall((err) => {
+          if (err) {
+            assert.strictEqual(err.code, 'EFBIG');
+          }
+        }));
 
 assert.throws(
   () => fs.readSync(fd, expected.length, 0, 'utf-8'),
@@ -95,8 +152,19 @@ assert.throws(() => {
 }, {
   code: 'ERR_OUT_OF_RANGE',
   name: 'RangeError',
-  message: 'The value of "offset" is out of range. ' +
-           'It must be >= 0. Received -1'
+});
+
+assert.throws(() => {
+  fs.readSync(fd,
+              Buffer.allocUnsafe(expected.length),
+              NaN,
+              expected.length,
+              0);
+}, {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError',
+  message: 'The value of "offset" is out of range. It must be an integer. ' +
+           'Received NaN'
 });
 
 assert.throws(() => {
@@ -124,3 +192,48 @@ assert.throws(() => {
   message: 'The value of "length" is out of range. ' +
            'It must be <= 4. Received 5'
 });
+
+[true, () => {}, {}, ''].forEach((value) => {
+  assert.throws(() => {
+    fs.readSync(fd,
+                Buffer.allocUnsafe(expected.length),
+                0,
+                expected.length,
+                value);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  });
+});
+
+[0.5, 2 ** 53, 2n ** 63n].forEach((value) => {
+  assert.throws(() => {
+    fs.readSync(fd,
+                Buffer.allocUnsafe(expected.length),
+                0,
+                expected.length,
+                value);
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError'
+  });
+});
+
+fs.readSync(fd,
+            Buffer.allocUnsafe(expected.length),
+            0,
+            expected.length,
+            0n);
+
+try {
+  fs.readSync(fd,
+              Buffer.allocUnsafe(expected.length),
+              0,
+              expected.length,
+              2n ** 53n - 1n);
+} catch (err) {
+  // On systems where max file size is below 2^53-1, we'd expect a EFBIG error.
+  // This is not using `assert.throws` because the above call should not raise
+  // any error on systems that allows file of that size.
+  if (err.code !== 'EFBIG') throw err;
+}
diff --git a/test/parallel/test-fs-read.js b/test/parallel/test-fs-read.js
index 2b665d8eb96ebb0016529245ded1e9101daa68ae..531eba00d2847d5fda22208b34f8f8b3c52cb725 100644
--- a/test/parallel/test-fs-read.js
+++ b/test/parallel/test-fs-read.js
@@ -35,8 +35,7 @@ function test(bufferAsync, bufferSync, expected) {
           0,
           expected.length,
           0,
-          common.mustCall((err, bytesRead) => {
-            assert.ifError(err);
+          common.mustSucceed((bytesRead) => {
             assert.strictEqual(bytesRead, expected.length);
             assert.deepStrictEqual(bufferAsync, expected);
           }));
@@ -62,8 +61,7 @@ test(new Uint8Array(expected.length),
   const nRead = fs.readSync(fd, Buffer.alloc(1), 0, 1, pos);
   assert.strictEqual(nRead, 0);
 
-  fs.read(fd, Buffer.alloc(1), 0, 1, pos, common.mustCall((err, nRead) => {
-    assert.ifError(err);
+  fs.read(fd, Buffer.alloc(1), 0, 1, pos, common.mustSucceed((nRead) => {
     assert.strictEqual(nRead, 0);
   }));
 }
diff --git a/test/parallel/test-fs-readdir-types.js b/test/parallel/test-fs-readdir-types.js
index 78f1b0d4e1b627cce7a135e892e7bb855cbad317..9116a04f44ed70b1f722f2260a43b7162c349cce 100644
--- a/test/parallel/test-fs-readdir-types.js
+++ b/test/parallel/test-fs-readdir-types.js
@@ -67,8 +67,7 @@ fs.readdir(__filename, {
 // Check the readdir async version
 fs.readdir(readdirDir, {
   withFileTypes: true
-}, common.mustCall((err, dirents) => {
-  assert.ifError(err);
+}, common.mustSucceed((dirents) => {
   assertDirents(dirents);
 }));
 
@@ -77,11 +76,12 @@ fs.readdir(readdirDir, {
     withFileTypes: true
   });
   assertDirents(dirents);
-})();
+})().then(common.mustCall());
 
 // Check for correct types when the binding returns unknowns
 const UNKNOWN = constants.UV_DIRENT_UNKNOWN;
 const oldReaddir = binding.readdir;
+process.on('beforeExit', () => { binding.readdir = oldReaddir; });
 binding.readdir = common.mustCall((path, encoding, types, req, ctx) => {
   if (req) {
     const oldCb = req.oncomplete;
@@ -103,8 +103,7 @@ binding.readdir = common.mustCall((path, encoding, types, req, ctx) => {
 assertDirents(fs.readdirSync(readdirDir, { withFileTypes: true }));
 fs.readdir(readdirDir, {
   withFileTypes: true
-}, common.mustCall((err, dirents) => {
-  assert.ifError(err);
+}, common.mustSucceed((dirents) => {
   assertDirents(dirents);
 }));
 
diff --git a/test/parallel/test-fs-readdir-ucs2.js b/test/parallel/test-fs-readdir-ucs2.js
index e5b85665932a7c8b688960d150ba22fed6ecb632..264858ec6ae8daabf886ca0f41d6dcb2b9ea7f13 100644
--- a/test/parallel/test-fs-readdir-ucs2.js
+++ b/test/parallel/test-fs-readdir-ucs2.js
@@ -23,8 +23,7 @@ try {
   throw e;
 }
 
-fs.readdir(tmpdir.path, 'ucs2', common.mustCall((err, list) => {
-  assert.ifError(err);
+fs.readdir(tmpdir.path, 'ucs2', common.mustSucceed((list) => {
   assert.strictEqual(list.length, 1);
   const fn = list[0];
   assert.deepStrictEqual(Buffer.from(fn, 'ucs2'), filebuff);
diff --git a/test/parallel/test-fs-readdir.js b/test/parallel/test-fs-readdir.js
index bfb88ed93fb4b31ee72827deee1ce8a3fe0bce1e..6ae29045cdd7a38c1c9804e05bf237eb8e74cb6d 100644
--- a/test/parallel/test-fs-readdir.js
+++ b/test/parallel/test-fs-readdir.js
@@ -21,8 +21,7 @@ files.forEach(function(currentFile) {
 assert.deepStrictEqual(files, fs.readdirSync(readdirDir).sort());
 
 // Check the readdir async version
-fs.readdir(readdirDir, common.mustCall(function(err, f) {
-  assert.ifError(err);
+fs.readdir(readdirDir, common.mustSucceed((f) => {
   assert.deepStrictEqual(files, f.sort());
 }));
 
diff --git a/test/parallel/test-fs-readfile-error.js b/test/parallel/test-fs-readfile-error.js
index 4b9017de060023003f958fb260c9cd0586130ad9..9d92638ed48dbe3c417a850798a73a96be86ba71 100644
--- a/test/parallel/test-fs-readfile-error.js
+++ b/test/parallel/test-fs-readfile-error.js
@@ -61,7 +61,7 @@ assert.throws(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     message: 'The "path" argument must be of type string or an instance of ' +
-             'Buffer or URL. Received type function ([Function])',
+             'Buffer or URL. Received type function ([Function (anonymous)])',
     name: 'TypeError'
   }
 );
diff --git a/test/parallel/test-fs-readfile-fd.js b/test/parallel/test-fs-readfile-fd.js
index df0f428bf153c0739b3d3591992a7432d58fb0e4..d7bf11c2d8d67174c61ae262d5c297058b03be5a 100644
--- a/test/parallel/test-fs-readfile-fd.js
+++ b/test/parallel/test-fs-readfile-fd.js
@@ -51,44 +51,43 @@ function tempFdSync(callback) {
 }
 
 {
-  /*
-   * This test makes sure that `readFile()` always reads from the current
-   * position of the file, instead of reading from the beginning of the file,
-   * when used with file descriptors.
-   */
+  // This test makes sure that `readFile()` always reads from the current
+  // position of the file, instead of reading from the beginning of the file,
+  // when used with file descriptors.
 
   const filename = join(tmpdir.path, 'test.txt');
   fs.writeFileSync(filename, 'Hello World');
 
   {
-    /* Tests the fs.readFileSync(). */
+    // Tests the fs.readFileSync().
     const fd = fs.openSync(filename, 'r');
 
-    /* Read only five bytes, so that the position moves to five. */
+    // Read only five bytes, so that the position moves to five.
     const buf = Buffer.alloc(5);
     assert.deepStrictEqual(fs.readSync(fd, buf, 0, 5), 5);
     assert.deepStrictEqual(buf.toString(), 'Hello');
 
-    /* readFileSync() should read from position five, instead of zero. */
+    // readFileSync() should read from position five, instead of zero.
     assert.deepStrictEqual(fs.readFileSync(fd).toString(), ' World');
+
+    fs.closeSync(fd);
   }
 
   {
-    /* Tests the fs.readFile(). */
-    fs.open(filename, 'r', common.mustCall((err, fd) => {
-      assert.ifError(err);
+    // Tests the fs.readFile().
+    fs.open(filename, 'r', common.mustSucceed((fd) => {
       const buf = Buffer.alloc(5);
 
-      /* Read only five bytes, so that the position moves to five. */
-      fs.read(fd, buf, 0, 5, null, common.mustCall((err, bytes) => {
-        assert.ifError(err);
+      // Read only five bytes, so that the position moves to five.
+      fs.read(fd, buf, 0, 5, null, common.mustSucceed((bytes) => {
         assert.strictEqual(bytes, 5);
         assert.deepStrictEqual(buf.toString(), 'Hello');
 
-        fs.readFile(fd, common.mustCall((err, data) => {
-          assert.ifError(err);
-          /* readFile() should read from position five, instead of zero. */
+        fs.readFile(fd, common.mustSucceed((data) => {
+          // readFile() should read from position five, instead of zero.
           assert.deepStrictEqual(data.toString(), ' World');
+
+          fs.closeSync(fd);
         }));
       }));
     }));
diff --git a/test/parallel/test-fs-readfile-flags.js b/test/parallel/test-fs-readfile-flags.js
new file mode 100644
index 0000000000000000000000000000000000000000..2aceee25506419b407eefd2a897883ffe184920a
--- /dev/null
+++ b/test/parallel/test-fs-readfile-flags.js
@@ -0,0 +1,51 @@
+'use strict';
+
+// Test of fs.readFile with different flags.
+const common = require('../common');
+const fs = require('fs');
+const assert = require('assert');
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+{
+  const emptyFile = path.join(tmpdir.path, 'empty.txt');
+  fs.closeSync(fs.openSync(emptyFile, 'w'));
+
+  fs.readFile(
+    emptyFile,
+    // With `a+` the file is created if it does not exist
+    { encoding: 'utf8', flag: 'a+' },
+    common.mustCall((err, data) => { assert.strictEqual(data, ''); })
+  );
+
+  fs.readFile(
+    emptyFile,
+    // Like `a+` but fails if the path exists.
+    { encoding: 'utf8', flag: 'ax+' },
+    common.mustCall((err, data) => { assert.strictEqual(err.code, 'EEXIST'); })
+  );
+}
+
+{
+  const willBeCreated = path.join(tmpdir.path, 'will-be-created');
+
+  fs.readFile(
+    willBeCreated,
+    // With `a+` the file is created if it does not exist
+    { encoding: 'utf8', flag: 'a+' },
+    common.mustCall((err, data) => { assert.strictEqual(data, ''); })
+  );
+}
+
+{
+  const willNotBeCreated = path.join(tmpdir.path, 'will-not-be-created');
+
+  fs.readFile(
+    willNotBeCreated,
+    // Default flag is `r`. An exception occurs if the file does not exist.
+    { encoding: 'utf8' },
+    common.mustCall((err, data) => { assert.strictEqual(err.code, 'ENOENT'); })
+  );
+}
diff --git a/test/parallel/test-fs-readfile-pipe-large.js b/test/parallel/test-fs-readfile-pipe-large.js
index 78c5feedb7210c98791919b127202e891e994660..14a0793620b7b9bfdea94867f69662a8cd2e826e 100644
--- a/test/parallel/test-fs-readfile-pipe-large.js
+++ b/test/parallel/test-fs-readfile-pipe-large.js
@@ -29,8 +29,7 @@ const exec = require('child_process').exec;
 const f = JSON.stringify(__filename);
 const node = JSON.stringify(process.execPath);
 const cmd = `cat ${filename} | ${node} ${f} child`;
-exec(cmd, { maxBuffer: 1000000 }, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
+exec(cmd, { maxBuffer: 1000000 }, common.mustSucceed((stdout, stderr) => {
   assert.strictEqual(
     stdout,
     dataExpected,
@@ -43,7 +42,3 @@ exec(cmd, { maxBuffer: 1000000 }, common.mustCall((err, stdout, stderr) => {
   );
   console.log('ok');
 }));
-
-process.on('exit', function() {
-  fs.unlinkSync(filename);
-});
diff --git a/test/parallel/test-fs-readfile-pipe.js b/test/parallel/test-fs-readfile-pipe.js
index a21801e3890894a8faaf8e014c2d480649d2157d..0cffbd0f5aa162d2f71b1df7d86a3b3bbefd6aab 100644
--- a/test/parallel/test-fs-readfile-pipe.js
+++ b/test/parallel/test-fs-readfile-pipe.js
@@ -31,8 +31,7 @@ const assert = require('assert');
 const fs = require('fs');
 
 if (process.argv[2] === 'child') {
-  fs.readFile('/dev/stdin', common.mustCall(function(er, data) {
-    assert.ifError(er);
+  fs.readFile('/dev/stdin', common.mustSucceed((data) => {
     process.stdout.write(data);
   }));
   return;
@@ -47,8 +46,7 @@ const exec = require('child_process').exec;
 const f = JSON.stringify(__filename);
 const node = JSON.stringify(process.execPath);
 const cmd = `cat ${filename} | ${node} ${f} child`;
-exec(cmd, common.mustCall(function(err, stdout, stderr) {
-  assert.ifError(err);
+exec(cmd, common.mustSucceed((stdout, stderr) => {
   assert.strictEqual(
     stdout,
     dataExpected,
diff --git a/test/parallel/test-fs-readfile-unlink.js b/test/parallel/test-fs-readfile-unlink.js
index 3ff9b6ac9029fea6f522a95478c952dcfeac1cfc..c3e70a7c4db5973475eecfba36de5505ddac76a1 100644
--- a/test/parallel/test-fs-readfile-unlink.js
+++ b/test/parallel/test-fs-readfile-unlink.js
@@ -37,8 +37,7 @@ tmpdir.refresh();
 
 fs.writeFileSync(fileName, buf);
 
-fs.readFile(fileName, common.mustCall((err, data) => {
-  assert.ifError(err);
+fs.readFile(fileName, common.mustSucceed((data) => {
   assert.strictEqual(data.length, buf.length);
   assert.strictEqual(buf[0], 42);
 
diff --git a/test/parallel/test-fs-readfile.js b/test/parallel/test-fs-readfile.js
index 648bf692d1dcc821f64d5f0ccded7af0122098f5..f31d356291fa4cae9493f9459b0296ab600b48c8 100644
--- a/test/parallel/test-fs-readfile.js
+++ b/test/parallel/test-fs-readfile.js
@@ -1,3 +1,4 @@
+// Flags: --experimental-abortcontroller
 'use strict';
 const common = require('../common');
 
@@ -15,20 +16,15 @@ tmpdir.refresh();
 
 const fileInfo = [
   { name: path.join(tmpdir.path, `${prefix}-1K.txt`),
-    len: 1024,
-  },
+    len: 1024 },
   { name: path.join(tmpdir.path, `${prefix}-64K.txt`),
-    len: 64 * 1024,
-  },
+    len: 64 * 1024 },
   { name: path.join(tmpdir.path, `${prefix}-64KLessOne.txt`),
-    len: (64 * 1024) - 1,
-  },
+    len: (64 * 1024) - 1 },
   { name: path.join(tmpdir.path, `${prefix}-1M.txt`),
-    len: 1 * 1024 * 1024,
-  },
+    len: 1 * 1024 * 1024 },
   { name: path.join(tmpdir.path, `${prefix}-1MPlusOne.txt`),
-    len: (1 * 1024 * 1024) + 1,
-  },
+    len: (1 * 1024 * 1024) + 1 },
 ];
 
 // Populate each fileInfo (and file) with unique fill.
@@ -57,3 +53,29 @@ for (const e of fileInfo) {
     assert.deepStrictEqual(buf, e.contents);
   }));
 }
+{
+  // Test cancellation, before
+  const controller = new AbortController();
+  const signal = controller.signal;
+  controller.abort();
+  fs.readFile(fileInfo[0].name, { signal }, common.mustCall((err, buf) => {
+    assert.strictEqual(err.name, 'AbortError');
+  }));
+}
+{
+  // Test cancellation, during read
+  const controller = new AbortController();
+  const signal = controller.signal;
+  fs.readFile(fileInfo[0].name, { signal }, common.mustCall((err, buf) => {
+    assert.strictEqual(err.name, 'AbortError');
+  }));
+  process.nextTick(() => controller.abort());
+}
+{
+  // Verify that if something different than Abortcontroller.signal
+  // is passed, ERR_INVALID_ARG_TYPE is thrown
+  assert.throws(() => {
+    const callback = common.mustNotCall(() => {});
+    fs.readFile(fileInfo[0].name, { signal: 'hello' }, callback);
+  }, { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+}
diff --git a/test/parallel/test-fs-readfilesync-enoent.js b/test/parallel/test-fs-readfilesync-enoent.js
index 0369f3587703833ab7862cf02ac345529f2227c7..baf87ff990bc73961c00f8046240dabab703b2ca 100644
--- a/test/parallel/test-fs-readfilesync-enoent.js
+++ b/test/parallel/test-fs-readfilesync-enoent.js
@@ -18,8 +18,7 @@ function test(p) {
   const result = fs.realpathSync(p);
   assert.strictEqual(result.toLowerCase(), path.resolve(p).toLowerCase());
 
-  fs.realpath(p, common.mustCall(function(err, result) {
-    assert.ok(!err);
+  fs.realpath(p, common.mustSucceed((result) => {
     assert.strictEqual(result.toLowerCase(), path.resolve(p).toLowerCase());
   }));
 }
diff --git a/test/parallel/test-fs-readfilesync-pipe-large.js b/test/parallel/test-fs-readfilesync-pipe-large.js
index 0f180f0f86005c0ba67acac71a0de337eabee4b5..7c2a5e7fd01ae3c1ceb2e1aae88488491fab1012 100644
--- a/test/parallel/test-fs-readfilesync-pipe-large.js
+++ b/test/parallel/test-fs-readfilesync-pipe-large.js
@@ -29,14 +29,9 @@ const cmd = `cat ${filename} | ${node} ${f} child`;
 exec(
   cmd,
   { maxBuffer: 1000000 },
-  common.mustCall(function(err, stdout, stderr) {
-    assert.ifError(err);
+  common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout, dataExpected);
     assert.strictEqual(stderr, '');
     console.log('ok');
   })
 );
-
-process.on('exit', function() {
-  fs.unlinkSync(filename);
-});
diff --git a/test/parallel/test-fs-readv-promises.js b/test/parallel/test-fs-readv-promises.js
index e0536505c91291dc21f4968fc4080c2680889a85..1d12126e557683ceacee085ec865a12552b0b1d3 100644
--- a/test/parallel/test-fs-readv-promises.js
+++ b/test/parallel/test-fs-readv-promises.js
@@ -1,6 +1,5 @@
 'use strict';
-
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const path = require('path');
 const fs = require('fs').promises;
@@ -19,7 +18,7 @@ function getFileName() {
 const allocateEmptyBuffers = (combinedLength) => {
   const bufferArr = [];
   // Allocate two buffers, each half the size of exptectedBuff
-  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2)),
+  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
   bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
 
   return bufferArr;
@@ -64,4 +63,4 @@ const allocateEmptyBuffers = (combinedLength) => {
     assert(Buffer.concat(bufferArr).equals(await fs.readFile(filename)));
     handle.close();
   }
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-readv-sync.js b/test/parallel/test-fs-readv-sync.js
index 92aa2fb6816752257f11204f1b837b72ddbfedef..9da39824d7f583123e6788eec9628a7849ecadfb 100644
--- a/test/parallel/test-fs-readv-sync.js
+++ b/test/parallel/test-fs-readv-sync.js
@@ -19,7 +19,7 @@ fs.writeFileSync(filename, exptectedBuff);
 const allocateEmptyBuffers = (combinedLength) => {
   const bufferArr = [];
   // Allocate two buffers, each half the size of exptectedBuff
-  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2)),
+  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
   bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
 
   return bufferArr;
diff --git a/test/parallel/test-fs-readv.js b/test/parallel/test-fs-readv.js
index 1fa9d80f9f2328a69eb0fe29c53dbe2187f91037..2ca79b302c636f0aadf3995960b74726213d5591 100644
--- a/test/parallel/test-fs-readv.js
+++ b/test/parallel/test-fs-readv.js
@@ -17,16 +17,14 @@ const exptectedBuff = Buffer.from(expected);
 const allocateEmptyBuffers = (combinedLength) => {
   const bufferArr = [];
   // Allocate two buffers, each half the size of exptectedBuff
-  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2)),
+  bufferArr[0] = Buffer.alloc(Math.floor(combinedLength / 2));
   bufferArr[1] = Buffer.alloc(combinedLength - bufferArr[0].length);
 
   return bufferArr;
 };
 
 const getCallback = (fd, bufferArr) => {
-  return common.mustCall((err, bytesRead, buffers) => {
-    assert.ifError(err);
-
+  return common.mustSucceed((bytesRead, buffers) => {
     assert.deepStrictEqual(bufferArr, buffers);
     const expectedLength = exptectedBuff.length;
     assert.deepStrictEqual(bytesRead, expectedLength);
diff --git a/test/parallel/test-fs-ready-event-stream.js b/test/parallel/test-fs-ready-event-stream.js
index f6b380cf26d42c0f4ce386c5b24782ee81ee096e..68e8fb76b771f4057223fa3f6771dc9fe2060e3a 100644
--- a/test/parallel/test-fs-ready-event-stream.js
+++ b/test/parallel/test-fs-ready-event-stream.js
@@ -17,4 +17,5 @@ const writeStream = fs.createWriteStream(writeFile, { autoClose: true });
 assert.strictEqual(writeStream.pending, true);
 writeStream.on('ready', common.mustCall(() => {
   assert.strictEqual(writeStream.pending, false);
+  writeStream.end();
 }));
diff --git a/test/parallel/test-fs-realpath-buffer-encoding.js b/test/parallel/test-fs-realpath-buffer-encoding.js
index 6952e0c46c689efcdc651a22a7c90e69e40658ac..481e1b0df67f04d9b1486588838cd48ee13baaf0 100644
--- a/test/parallel/test-fs-realpath-buffer-encoding.js
+++ b/test/parallel/test-fs-realpath-buffer-encoding.js
@@ -54,45 +54,37 @@ for (encoding in expected) {
   fs.realpath(
     string_dir,
     { encoding },
-    common.mustCall((err, res) => {
-      assert.ifError(err);
+    common.mustSucceed((res) => {
       assert.strictEqual(res, expected_value);
     })
   );
-  fs.realpath(string_dir, encoding, common.mustCall((err, res) => {
-    assert.ifError(err);
+  fs.realpath(string_dir, encoding, common.mustSucceed((res) => {
     assert.strictEqual(res, expected_value);
   }));
   fs.realpath(
     buffer_dir,
     { encoding },
-    common.mustCall((err, res) => {
-      assert.ifError(err);
+    common.mustSucceed((res) => {
       assert.strictEqual(res, expected_value);
     })
   );
-  fs.realpath(buffer_dir, encoding, common.mustCall((err, res) => {
-    assert.ifError(err);
+  fs.realpath(buffer_dir, encoding, common.mustSucceed((res) => {
     assert.strictEqual(res, expected_value);
   }));
 }
 
-fs.realpath(string_dir, { encoding: 'buffer' }, common.mustCall((err, res) => {
-  assert.ifError(err);
+fs.realpath(string_dir, { encoding: 'buffer' }, common.mustSucceed((res) => {
   assert.deepStrictEqual(res, buffer_dir);
 }));
 
-fs.realpath(string_dir, 'buffer', common.mustCall((err, res) => {
-  assert.ifError(err);
+fs.realpath(string_dir, 'buffer', common.mustSucceed((res) => {
   assert.deepStrictEqual(res, buffer_dir);
 }));
 
-fs.realpath(buffer_dir, { encoding: 'buffer' }, common.mustCall((err, res) => {
-  assert.ifError(err);
+fs.realpath(buffer_dir, { encoding: 'buffer' }, common.mustSucceed((res) => {
   assert.deepStrictEqual(res, buffer_dir);
 }));
 
-fs.realpath(buffer_dir, 'buffer', common.mustCall((err, res) => {
-  assert.ifError(err);
+fs.realpath(buffer_dir, 'buffer', common.mustSucceed((res) => {
   assert.deepStrictEqual(res, buffer_dir);
 }));
diff --git a/test/parallel/test-fs-realpath-native.js b/test/parallel/test-fs-realpath-native.js
index 089572442d62f54ccaf063e0f2582f61fcdc95f1..d6f319a015aeafca785e2dccdb1d77f5ccad0c46 100644
--- a/test/parallel/test-fs-realpath-native.js
+++ b/test/parallel/test-fs-realpath-native.js
@@ -12,8 +12,7 @@ assert.strictEqual(
 
 fs.realpath.native(
   './test/parallel/test-fs-realpath-native.js',
-  common.mustCall(function(err, res) {
-    assert.ifError(err);
+  common.mustSucceed(function(res) {
     assert.strictEqual(res.toLowerCase(), filename);
     assert.strictEqual(this, undefined);
   }));
diff --git a/test/parallel/test-fs-realpath-on-substed-drive.js b/test/parallel/test-fs-realpath-on-substed-drive.js
index d5c684f33c073fc00f954703a05056dfb4ff77b6..aea53f642f3eef4fb375b2cf1aaa77404faaa72f 100644
--- a/test/parallel/test-fs-realpath-on-substed-drive.js
+++ b/test/parallel/test-fs-realpath-on-substed-drive.js
@@ -41,13 +41,11 @@ result = fs.realpathSync(filename, 'buffer');
 assert(Buffer.isBuffer(result));
 assert(result.equals(filenameBuffer));
 
-fs.realpath(filename, common.mustCall(function(err, result) {
-  assert.ifError(err);
+fs.realpath(filename, common.mustSucceed((result) => {
   assert.strictEqual(result, filename);
 }));
 
-fs.realpath(filename, 'buffer', common.mustCall(function(err, result) {
-  assert.ifError(err);
+fs.realpath(filename, 'buffer', common.mustSucceed((result) => {
   assert(Buffer.isBuffer(result));
   assert(result.equals(filenameBuffer));
 }));
diff --git a/test/parallel/test-fs-realpath-pipe.js b/test/parallel/test-fs-realpath-pipe.js
index 7104e93ff123ede93e2f4de86f65ecfcb1205147..29fe1d3b7d28e1ce44a23c49a6f358bd0c2e30d1 100644
--- a/test/parallel/test-fs-realpath-pipe.js
+++ b/test/parallel/test-fs-realpath-pipe.js
@@ -12,6 +12,7 @@ const { spawnSync } = require('child_process');
 for (const code of [
   `require('fs').realpath('/dev/stdin', (err, resolvedPath) => {
     if (err) {
+      console.error(err);
       process.exit(1);
     }
     if (resolvedPath) {
@@ -22,11 +23,17 @@ for (const code of [
     if (require('fs').realpathSync('/dev/stdin')) {
       process.exit(2);
     }
-  } catch {
+  } catch (e) {
+    console.error(e);
     process.exit(1);
-  }`
+  }`,
 ]) {
-  assert.strictEqual(spawnSync(process.execPath, ['-e', code], {
+  const child = spawnSync(process.execPath, ['-e', code], {
     stdio: 'pipe'
-  }).status, 2);
+  });
+  if (child.status !== 2) {
+    console.log(code);
+    console.log(child.stderr.toString());
+  }
+  assert.strictEqual(child.status, 2);
 }
diff --git a/test/parallel/test-fs-realpath.js b/test/parallel/test-fs-realpath.js
index 83b629ef0b983680fe07363803f7e92cbc6bd866..488e4b4ceaada329ea8ec7b8e0e37abcb292732e 100644
--- a/test/parallel/test-fs-realpath.js
+++ b/test/parallel/test-fs-realpath.js
@@ -106,7 +106,7 @@ function test_simple_relative_symlink(realpath, realpathSync, callback) {
   const entry = `${tmpDir}/symlink`;
   const expected = `${tmpDir}/cycles/root.js`;
   [
-    [entry, `../${path.basename(tmpDir)}/cycles/root.js`]
+    [entry, `../${path.basename(tmpDir)}/cycles/root.js`],
   ].forEach(function(t) {
     try { fs.unlinkSync(t[0]); } catch {}
     console.log('fs.symlinkSync(%j, %j, %j)', t[1], t[0], 'file');
@@ -132,7 +132,7 @@ function test_simple_absolute_symlink(realpath, realpathSync, callback) {
   const entry = `${tmpAbsDir}/symlink`;
   const expected = fixtures.path('nested-index', 'one');
   [
-    [entry, expected]
+    [entry, expected],
   ].forEach(function(t) {
     try { fs.unlinkSync(t[0]); } catch {}
     console.error('fs.symlinkSync(%j, %j, %j)', t[1], t[0], type);
@@ -214,7 +214,7 @@ function test_cyclic_link_protection(realpath, realpathSync, callback) {
   [
     [entry, '../cycles/realpath-3b'],
     [path.join(tmpDir, '/cycles/realpath-3b'), '../cycles/realpath-3c'],
-    [path.join(tmpDir, '/cycles/realpath-3c'), '../cycles/realpath-3a']
+    [path.join(tmpDir, '/cycles/realpath-3c'), '../cycles/realpath-3a'],
   ].forEach(function(t) {
     try { fs.unlinkSync(t[0]); } catch {}
     fs.symlinkSync(t[1], t[0], 'dir');
@@ -267,7 +267,7 @@ function test_relative_input_cwd(realpath, realpathSync, callback) {
   [
     [entry, '../cycles/realpath-3b'],
     [`${tmpDir}/cycles/realpath-3b`, '../cycles/realpath-3c'],
-    [`${tmpDir}/cycles/realpath-3c`, 'root.js']
+    [`${tmpDir}/cycles/realpath-3c`, 'root.js'],
   ].forEach(function(t) {
     const fn = t[0];
     console.error('fn=%j', fn);
@@ -298,17 +298,16 @@ function test_deep_symlink_mix(realpath, realpathSync, callback) {
     return callback();
   }
 
-  /*
-  /tmp/node-test-realpath-f1 -> $tmpDir/node-test-realpath-d1/foo
-  /tmp/node-test-realpath-d1 -> $tmpDir/node-test-realpath-d2
-  /tmp/node-test-realpath-d2/foo -> $tmpDir/node-test-realpath-f2
-  /tmp/node-test-realpath-f2
-    -> $tmpDir/targets/nested-index/one/realpath-c
-  $tmpDir/targets/nested-index/one/realpath-c
-    -> $tmpDir/targets/nested-index/two/realpath-c
-  $tmpDir/targets/nested-index/two/realpath-c -> $tmpDir/cycles/root.js
-  $tmpDir/targets/cycles/root.js (hard)
-  */
+  // /tmp/node-test-realpath-f1 -> $tmpDir/node-test-realpath-d1/foo
+  // /tmp/node-test-realpath-d1 -> $tmpDir/node-test-realpath-d2
+  // /tmp/node-test-realpath-d2/foo -> $tmpDir/node-test-realpath-f2
+  // /tmp/node-test-realpath-f2
+  //   -> $tmpDir/targets/nested-index/one/realpath-c
+  // $tmpDir/targets/nested-index/one/realpath-c
+  //   -> $tmpDir/targets/nested-index/two/realpath-c
+  // $tmpDir/targets/nested-index/two/realpath-c -> $tmpDir/cycles/root.js
+  // $tmpDir/targets/cycles/root.js (hard)
+
   const entry = tmp('node-test-realpath-f1');
   try { fs.unlinkSync(tmp('node-test-realpath-d2/foo')); } catch {}
   try { fs.rmdirSync(tmp('node-test-realpath-d2')); } catch {}
@@ -324,7 +323,7 @@ function test_deep_symlink_mix(realpath, realpathSync, callback) {
       [`${targetsAbsDir}/nested-index/one/realpath-c`,
        `${targetsAbsDir}/nested-index/two/realpath-c`],
       [`${targetsAbsDir}/nested-index/two/realpath-c`,
-       `${tmpDir}/cycles/root.js`]
+       `${tmpDir}/cycles/root.js`],
     ].forEach(function(t) {
       try { fs.unlinkSync(t[0]); } catch {}
       fs.symlinkSync(t[1], t[0]);
@@ -478,14 +477,14 @@ function test_abs_with_kids(realpath, realpathSync, cb) {
   const root = `${tmpAbsDir}/node-test-realpath-abs-kids`;
   function cleanup() {
     ['/a/b/c/x.txt',
-     '/a/link'
+     '/a/link',
     ].forEach(function(file) {
       try { fs.unlinkSync(root + file); } catch {}
     });
     ['/a/b/c',
      '/a/b',
      '/a',
-     ''
+     '',
     ].forEach(function(folder) {
       try { fs.rmdirSync(root + folder); } catch {}
     });
@@ -496,7 +495,7 @@ function test_abs_with_kids(realpath, realpathSync, cb) {
     ['',
      '/a',
      '/a/b',
-     '/a/b/c'
+     '/a/b/c',
     ].forEach(function(folder) {
       console.log(`mkdir ${root}${folder}`);
       fs.mkdirSync(root + folder, 0o700);
@@ -554,7 +553,7 @@ const tests = [
   test_up_multiple,
   test_up_multiple_with_null_options,
   test_root,
-  test_root_with_null_options
+  test_root_with_null_options,
 ];
 const numtests = tests.length;
 let testsRun = 0;
@@ -565,8 +564,7 @@ function runNextTest(err) {
     return console.log(`${numtests} subtests completed OK for fs.realpath`);
   }
   testsRun++;
-  test(fs.realpath, fs.realpathSync, common.mustCall((err) => {
-    assert.ifError(err);
+  test(fs.realpath, fs.realpathSync, common.mustSucceed(() => {
     testsRun++;
     test(fs.realpath.native,
          fs.realpathSync.native,
diff --git a/test/parallel/test-fs-rm.js b/test/parallel/test-fs-rm.js
new file mode 100644
index 0000000000000000000000000000000000000000..5bb5d2de553eee052f49ca43f1b770d95a02369b
--- /dev/null
+++ b/test/parallel/test-fs-rm.js
@@ -0,0 +1,282 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { validateRmOptionsSync } = require('internal/fs/utils');
+
+tmpdir.refresh();
+
+let count = 0;
+const nextDirPath = (name = 'rm') =>
+  path.join(tmpdir.path, `${name}-${count++}`);
+
+function makeNonEmptyDirectory(depth, files, folders, dirname, createSymLinks) {
+  fs.mkdirSync(dirname, { recursive: true });
+  fs.writeFileSync(path.join(dirname, 'text.txt'), 'hello', 'utf8');
+
+  const options = { flag: 'wx' };
+
+  for (let f = files; f > 0; f--) {
+    fs.writeFileSync(path.join(dirname, `f-${depth}-${f}`), '', options);
+  }
+
+  if (createSymLinks) {
+    // Valid symlink
+    fs.symlinkSync(
+      `f-${depth}-1`,
+      path.join(dirname, `link-${depth}-good`),
+      'file'
+    );
+
+    // Invalid symlink
+    fs.symlinkSync(
+      'does-not-exist',
+      path.join(dirname, `link-${depth}-bad`),
+      'file'
+    );
+  }
+
+  // File with a name that looks like a glob
+  fs.writeFileSync(path.join(dirname, '[a-z0-9].txt'), '', options);
+
+  depth--;
+  if (depth <= 0) {
+    return;
+  }
+
+  for (let f = folders; f > 0; f--) {
+    fs.mkdirSync(
+      path.join(dirname, `folder-${depth}-${f}`),
+      { recursive: true }
+    );
+    makeNonEmptyDirectory(
+      depth,
+      files,
+      folders,
+      path.join(dirname, `d-${depth}-${f}`),
+      createSymLinks
+    );
+  }
+}
+
+function removeAsync(dir) {
+  // Removal should fail without the recursive option.
+  fs.rm(dir, common.mustCall((err) => {
+    assert.strictEqual(err.syscall, 'rm');
+
+    // Removal should fail without the recursive option set to true.
+    fs.rm(dir, { recursive: false }, common.mustCall((err) => {
+      assert.strictEqual(err.syscall, 'rm');
+
+      // Recursive removal should succeed.
+      fs.rm(dir, { recursive: true }, common.mustSucceed(() => {
+
+        // Attempted removal should fail now because the directory is gone.
+        fs.rm(dir, common.mustCall((err) => {
+          assert.strictEqual(err.syscall, 'stat');
+        }));
+      }));
+    }));
+  }));
+}
+
+// Test the asynchronous version
+{
+  // Create a 4-level folder hierarchy including symlinks
+  let dir = nextDirPath();
+  makeNonEmptyDirectory(4, 10, 2, dir, true);
+  removeAsync(dir);
+
+  // Create a 2-level folder hierarchy without symlinks
+  dir = nextDirPath();
+  makeNonEmptyDirectory(2, 10, 2, dir, false);
+  removeAsync(dir);
+
+  // Create a flat folder including symlinks
+  dir = nextDirPath();
+  makeNonEmptyDirectory(1, 10, 2, dir, true);
+  removeAsync(dir);
+
+  // Should fail if target does not exist
+  fs.rm(
+    path.join(tmpdir.path, 'noexist.txt'),
+    { recursive: true },
+    common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOENT');
+    })
+  );
+
+  // Should delete a file
+  const filePath = path.join(tmpdir.path, 'rm-async-file.txt');
+  fs.writeFileSync(filePath, '');
+  fs.rm(filePath, { recursive: true }, common.mustCall((err) => {
+    try {
+      assert.strictEqual(err, null);
+      assert.strictEqual(fs.existsSync(filePath), false);
+    } finally {
+      fs.rmSync(filePath, { force: true });
+    }
+  }));
+}
+
+// Test the synchronous version.
+{
+  const dir = nextDirPath();
+  makeNonEmptyDirectory(4, 10, 2, dir, true);
+
+  // Removal should fail without the recursive option set to true.
+  assert.throws(() => {
+    fs.rmSync(dir);
+  }, { syscall: 'rm' });
+  assert.throws(() => {
+    fs.rmSync(dir, { recursive: false });
+  }, { syscall: 'rm' });
+
+  // Should fail if target does not exist
+  assert.throws(() => {
+    fs.rmSync(path.join(tmpdir.path, 'noexist.txt'), { recursive: true });
+  }, {
+    code: 'ENOENT',
+    name: 'Error',
+    message: /^ENOENT: no such file or directory, stat/
+  });
+
+  // Should delete a file
+  const filePath = path.join(tmpdir.path, 'rm-file.txt');
+  fs.writeFileSync(filePath, '');
+
+  try {
+    fs.rmSync(filePath, { recursive: true });
+  } finally {
+    fs.rmSync(filePath, { force: true });
+  }
+
+  // Recursive removal should succeed.
+  fs.rmSync(dir, { recursive: true });
+
+  // Attempted removal should fail now because the directory is gone.
+  assert.throws(() => fs.rmSync(dir), { syscall: 'stat' });
+}
+
+// Test the Promises based version.
+(async () => {
+  const dir = nextDirPath();
+  makeNonEmptyDirectory(4, 10, 2, dir, true);
+
+  // Removal should fail without the recursive option set to true.
+  assert.rejects(fs.promises.rm(dir), { syscall: 'rm' });
+  assert.rejects(fs.promises.rm(dir, { recursive: false }), {
+    syscall: 'rm'
+  });
+
+  // Recursive removal should succeed.
+  await fs.promises.rm(dir, { recursive: true });
+
+  // Attempted removal should fail now because the directory is gone.
+  assert.rejects(fs.promises.rm(dir), { syscall: 'stat' });
+
+  // Should fail if target does not exist
+  assert.rejects(fs.promises.rm(
+    path.join(tmpdir.path, 'noexist.txt'),
+    { recursive: true }
+  ), {
+    code: 'ENOENT',
+    name: 'Error',
+    message: /^ENOENT: no such file or directory, stat/
+  });
+
+  // Should not fail if target does not exist and force option is true
+  fs.promises.rm(path.join(tmpdir.path, 'noexist.txt'), { force: true });
+
+  // Should delete file
+  const filePath = path.join(tmpdir.path, 'rm-promises-file.txt');
+  fs.writeFileSync(filePath, '');
+
+  try {
+    await fs.promises.rm(filePath, { recursive: true });
+  } finally {
+    fs.rmSync(filePath, { force: true });
+  }
+})().then(common.mustCall());
+
+// Test input validation.
+{
+  const dir = nextDirPath();
+  makeNonEmptyDirectory(4, 10, 2, dir, true);
+  const filePath = (path.join(tmpdir.path, 'rm-args-file.txt'));
+  fs.writeFileSync(filePath, '');
+
+  const defaults = {
+    retryDelay: 100,
+    maxRetries: 0,
+    recursive: false,
+    force: false
+  };
+  const modified = {
+    retryDelay: 953,
+    maxRetries: 5,
+    recursive: true,
+    force: false
+  };
+
+  assert.deepStrictEqual(validateRmOptionsSync(filePath), defaults);
+  assert.deepStrictEqual(validateRmOptionsSync(filePath, {}), defaults);
+  assert.deepStrictEqual(validateRmOptionsSync(filePath, modified), modified);
+  assert.deepStrictEqual(validateRmOptionsSync(filePath, {
+    maxRetries: 99
+  }), {
+    retryDelay: 100,
+    maxRetries: 99,
+    recursive: false,
+    force: false
+  });
+
+  [null, 'foo', 5, NaN].forEach((bad) => {
+    assert.throws(() => {
+      validateRmOptionsSync(filePath, bad);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: /^The "options" argument must be of type object\./
+    });
+  });
+
+  [undefined, null, 'foo', Infinity, function() {}].forEach((bad) => {
+    assert.throws(() => {
+      validateRmOptionsSync(filePath, { recursive: bad });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: /^The "options\.recursive" property must be of type boolean\./
+    });
+  });
+
+  [undefined, null, 'foo', Infinity, function() {}].forEach((bad) => {
+    assert.throws(() => {
+      validateRmOptionsSync(filePath, { force: bad });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: /^The "options\.force" property must be of type boolean\./
+    });
+  });
+
+  assert.throws(() => {
+    validateRmOptionsSync(filePath, { retryDelay: -1 });
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: /^The value of "options\.retryDelay" is out of range\./
+  });
+
+  assert.throws(() => {
+    validateRmOptionsSync(filePath, { maxRetries: -1 });
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: /^The value of "options\.maxRetries" is out of range\./
+  });
+}
diff --git a/test/parallel/test-fs-rmdir-recursive.js b/test/parallel/test-fs-rmdir-recursive.js
index db8d4b14dac7cfd316f8fdfe951dcacf3fc594b6..7375eeacb07177eb66c7b5524d6af215f101426d 100644
--- a/test/parallel/test-fs-rmdir-recursive.js
+++ b/test/parallel/test-fs-rmdir-recursive.js
@@ -72,13 +72,9 @@ function removeAsync(dir) {
       assert.strictEqual(err.syscall, 'rmdir');
 
       // Recursive removal should succeed.
-      fs.rmdir(dir, { recursive: true }, common.mustCall((err) => {
-        assert.ifError(err);
-
+      fs.rmdir(dir, { recursive: true }, common.mustSucceed(() => {
         // No error should occur if recursive and the directory does not exist.
-        fs.rmdir(dir, { recursive: true }, common.mustCall((err) => {
-          assert.ifError(err);
-
+        fs.rmdir(dir, { recursive: true }, common.mustSucceed(() => {
           // Attempted removal should fail now because the directory is gone.
           fs.rmdir(dir, common.mustCall((err) => {
             assert.strictEqual(err.syscall, 'rmdir');
@@ -149,7 +145,7 @@ function removeAsync(dir) {
 
   // Attempted removal should fail now because the directory is gone.
   assert.rejects(fs.promises.rmdir(dir), { syscall: 'rmdir' });
-})();
+})().then(common.mustCall());
 
 // Test input validation.
 {
@@ -191,7 +187,7 @@ function removeAsync(dir) {
     }, {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError',
-      message: /^The "recursive" argument must be of type boolean\./
+      message: /^The "options\.recursive" property must be of type boolean\./
     });
   });
 
@@ -200,7 +196,7 @@ function removeAsync(dir) {
   }, {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError',
-    message: /^The value of "retryDelay" is out of range\./
+    message: /^The value of "options\.retryDelay" is out of range\./
   });
 
   assert.throws(() => {
@@ -208,6 +204,31 @@ function removeAsync(dir) {
   }, {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError',
-    message: /^The value of "maxRetries" is out of range\./
+    message: /^The value of "options\.maxRetries" is out of range\./
   });
 }
+
+// It should not pass recursive option to rmdirSync, when called from
+// rimraf (see: #35566)
+{
+  // Make a non-empty directory:
+  const original = fs.rmdirSync;
+  const dir = `${nextDirPath()}/foo/bar`;
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(`${dir}/foo.txt`, 'hello world', 'utf8');
+
+  // When called the second time from rimraf, the recursive option should
+  // not be set for rmdirSync:
+  let callCount = 0;
+  let rmdirSyncOptionsFromRimraf;
+  fs.rmdirSync = (path, options) => {
+    if (callCount > 0) {
+      rmdirSyncOptionsFromRimraf = { ...options };
+    }
+    callCount++;
+    return original(path, options);
+  };
+  fs.rmdirSync(dir, { recursive: true });
+  fs.rmdirSync = original;
+  assert.strictEqual(rmdirSyncOptionsFromRimraf.recursive, undefined);
+}
diff --git a/test/parallel/test-fs-stat-bigint.js b/test/parallel/test-fs-stat-bigint.js
index f96bef192f07ab8038b7843152ce91333c78ba76..cffec39288de4a1c2ff8255a770534fe9f592113 100644
--- a/test/parallel/test-fs-stat-bigint.js
+++ b/test/parallel/test-fs-stat-bigint.js
@@ -122,6 +122,33 @@ if (!common.isWindows) {
   fs.closeSync(fd);
 }
 
+{
+  assert.throws(
+    () => fs.statSync('does_not_exist'),
+    { code: 'ENOENT' });
+  assert.strictEqual(
+    fs.statSync('does_not_exist', { throwIfNoEntry: false }),
+    undefined);
+}
+
+{
+  assert.throws(
+    () => fs.lstatSync('does_not_exist'),
+    { code: 'ENOENT' });
+  assert.strictEqual(
+    fs.lstatSync('does_not_exist', { throwIfNoEntry: false }),
+    undefined);
+}
+
+{
+  assert.throws(
+    () => fs.fstatSync(9999),
+    { code: 'EBADF' });
+  assert.throws(
+    () => fs.fstatSync(9999, { throwIfNoEntry: false }),
+    { code: 'EBADF' });
+}
+
 const runCallbackTest = (func, arg, done) => {
   const startTime = process.hrtime.bigint();
   func(arg, { bigint: true }, common.mustCall((err, bigintStats) => {
@@ -185,4 +212,4 @@ if (!common.isWindows) {
   const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
   verifyStats(bigintStats, numStats, allowableDelta);
   await handle.close();
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-stat.js b/test/parallel/test-fs-stat.js
index 32acf65b7b96a3a738147d2148bac0a256fbfc01..31aec8fab00450c8f73aedd5a0caf2a4d5faaaf8 100644
--- a/test/parallel/test-fs-stat.js
+++ b/test/parallel/test-fs-stat.js
@@ -25,8 +25,7 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
-fs.stat('.', common.mustCall(function(err, stats) {
-  assert.ifError(err);
+fs.stat('.', common.mustSucceed(function(stats) {
   assert.ok(stats.mtime instanceof Date);
   assert.ok(stats.hasOwnProperty('blksize'));
   assert.ok(stats.hasOwnProperty('blocks'));
@@ -36,8 +35,7 @@ fs.stat('.', common.mustCall(function(err, stats) {
   assert.strictEqual(this, undefined);
 }));
 
-fs.lstat('.', common.mustCall(function(err, stats) {
-  assert.ifError(err);
+fs.lstat('.', common.mustSucceed(function(stats) {
   assert.ok(stats.mtime instanceof Date);
   // Confirm that we are not running in the context of the internal binding
   // layer.
@@ -46,12 +44,10 @@ fs.lstat('.', common.mustCall(function(err, stats) {
 }));
 
 // fstat
-fs.open('.', 'r', undefined, common.mustCall(function(err, fd) {
-  assert.ifError(err);
+fs.open('.', 'r', undefined, common.mustSucceed(function(fd) {
   assert.ok(fd);
 
-  fs.fstat(fd, common.mustCall(function(err, stats) {
-    assert.ifError(err);
+  fs.fstat(fd, common.mustSucceed(function(stats) {
     assert.ok(stats.mtime instanceof Date);
     fs.close(fd, assert.ifError);
     // Confirm that we are not running in the context of the internal binding
@@ -70,11 +66,10 @@ fs.open('.', 'r', undefined, common.mustCall(function(err, fd) {
 fs.open('.', 'r', undefined, common.mustCall(function(err, fd) {
   const stats = fs.fstatSync(fd);
   assert.ok(stats.mtime instanceof Date);
-  fs.close(fd, common.mustCall(assert.ifError));
+  fs.close(fd, common.mustSucceed());
 }));
 
-fs.stat(__filename, common.mustCall(function(err, s) {
-  assert.ifError(err);
+fs.stat(__filename, common.mustSucceed((s) => {
   assert.strictEqual(s.isDirectory(), false);
   assert.strictEqual(s.isFile(), true);
   assert.strictEqual(s.isSocket(), false);
diff --git a/test/parallel/test-fs-stream-destroy-emit-error.js b/test/parallel/test-fs-stream-destroy-emit-error.js
index c1db9547a8a158b38f2d9ec6d9f84ab2aee440cf..347fbfd97fa0c4d7edde3228131f4ae7fed221f7 100644
--- a/test/parallel/test-fs-stream-destroy-emit-error.js
+++ b/test/parallel/test-fs-stream-destroy-emit-error.js
@@ -8,13 +8,13 @@ tmpdir.refresh();
 
 {
   const stream = fs.createReadStream(__filename);
-  stream.on('close', common.mustNotCall());
+  stream.on('close', common.mustCall());
   test(stream);
 }
 
 {
   const stream = fs.createWriteStream(`${tmpdir.path}/dummy`);
-  stream.on('close', common.mustNotCall());
+  stream.on('close', common.mustCall());
   test(stream);
 }
 
diff --git a/test/pummel/test-regress-GH-814.js b/test/parallel/test-fs-symlink-buffer-path.js
similarity index 47%
rename from test/pummel/test-regress-GH-814.js
rename to test/parallel/test-fs-symlink-buffer-path.js
index d926890ce2678697b64e9e6f967aece8d5dc9e7f..8cc9571258ed14bd922391c8f26eb846044b081a 100644
--- a/test/pummel/test-regress-GH-814.js
+++ b/test/parallel/test-fs-symlink-buffer-path.js
@@ -19,70 +19,42 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-// Refs: https://github.com/nodejs/node-v0.x-archive/issues/814
-
 'use strict';
-// Flags: --expose_gc
-
-require('../common');
-const assert = require('assert');
+const common = require('../common');
+if (!common.canCreateSymLink())
+  common.skip('insufficient privileges');
 
-const tmpdir = require('../common/tmpdir');
-
-function newBuffer(size, value) {
-  const buffer = Buffer.allocUnsafe(size);
-  while (size--) {
-    buffer[size] = value;
-  }
-  buffer[buffer.length - 1] = 0x0a;
-  return buffer;
-}
+const fixtures = require('../common/fixtures');
 
+const assert = require('assert');
+const path = require('path');
 const fs = require('fs');
-const testFileName = require('path').join(tmpdir.path, 'GH-814_testFile.txt');
-const testFileFD = fs.openSync(testFileName, 'w');
-console.log(testFileName);
 
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
 
-const kBufSize = 128 * 1024;
-let PASS = true;
-const neverWrittenBuffer = newBuffer(kBufSize, 0x2e); // 0x2e === '.'
-const bufPool = [];
-
-
-const tail = require('child_process').spawn('tail', ['-f', testFileName]);
-tail.stdout.on('data', tailCB);
-
-function tailCB(data) {
-  PASS = !data.toString().includes('.');
-}
-
+// Test creating and reading symbolic link
+const linkData = fixtures.path('/cycles/root.js');
+const linkPath = path.join(tmpdir.path, 'symlink1.js');
 
-const timeToQuit = Date.now() + 8e3; // Test during no more than this seconds.
-(function main() {
+let linkTime;
+let fileTime;
 
-  if (PASS) {
-    fs.write(testFileFD, newBuffer(kBufSize, 0x61), 0, kBufSize, -1, cb);
-    global.gc();
-    const nuBuf = Buffer.allocUnsafe(kBufSize);
-    neverWrittenBuffer.copy(nuBuf);
-    if (bufPool.push(nuBuf) > 100) {
-      bufPool.length = 0;
-    }
-  } else {
-    throw new Error("Buffer GC'ed test -> FAIL");
-  }
+// Refs: https://github.com/nodejs/node/issues/34514
+fs.symlinkSync(Buffer.from(linkData), linkPath);
 
-  if (Date.now() < timeToQuit) {
-    process.nextTick(main);
-  } else {
-    tail.kill();
-    console.log("Buffer GC'ed test -> PASS (OK)");
-  }
+fs.lstat(linkPath, common.mustSucceed((stats) => {
+  linkTime = stats.mtime.getTime();
+}));
 
-})();
+fs.stat(linkPath, common.mustSucceed((stats) => {
+  fileTime = stats.mtime.getTime();
+}));
 
+fs.readlink(linkPath, common.mustSucceed((destination) => {
+  assert.strictEqual(destination, linkData);
+}));
 
-function cb(err, written) {
-  assert.ifError(err);
-}
+process.on('exit', () => {
+  assert.notStrictEqual(linkTime, fileTime);
+});
diff --git a/test/parallel/test-fs-symlink-dir-junction-relative.js b/test/parallel/test-fs-symlink-dir-junction-relative.js
index 308ab04048847142b78a8ac6a7196821ef17afbd..ec86f84b666e67eb55eb3a31259d9a079a96e181 100644
--- a/test/parallel/test-fs-symlink-dir-junction-relative.js
+++ b/test/parallel/test-fs-symlink-dir-junction-relative.js
@@ -38,8 +38,7 @@ const linkData = fixtures.fixturesDir;
 tmpdir.refresh();
 
 // Test fs.symlink()
-fs.symlink(linkData, linkPath1, 'junction', common.mustCall(function(err) {
-  assert.ifError(err);
+fs.symlink(linkData, linkPath1, 'junction', common.mustSucceed(() => {
   verifyLink(linkPath1);
 }));
 
diff --git a/test/parallel/test-fs-symlink-dir-junction.js b/test/parallel/test-fs-symlink-dir-junction.js
index 42d6bc1214132b95195d21c9dc990b9fb7336ebd..f705f0e43acfcc8b444ce95011f1737138614d94 100644
--- a/test/parallel/test-fs-symlink-dir-junction.js
+++ b/test/parallel/test-fs-symlink-dir-junction.js
@@ -34,19 +34,14 @@ const linkPath = path.join(tmpdir.path, 'cycles_link');
 
 tmpdir.refresh();
 
-fs.symlink(linkData, linkPath, 'junction', common.mustCall(function(err) {
-  assert.ifError(err);
-
-  fs.lstat(linkPath, common.mustCall(function(err, stats) {
-    assert.ifError(err);
+fs.symlink(linkData, linkPath, 'junction', common.mustSucceed(() => {
+  fs.lstat(linkPath, common.mustSucceed((stats) => {
     assert.ok(stats.isSymbolicLink());
 
-    fs.readlink(linkPath, common.mustCall(function(err, destination) {
-      assert.ifError(err);
+    fs.readlink(linkPath, common.mustSucceed((destination) => {
       assert.strictEqual(destination, linkData);
 
-      fs.unlink(linkPath, common.mustCall(function(err) {
-        assert.ifError(err);
+      fs.unlink(linkPath, common.mustSucceed(() => {
         assert(!fs.existsSync(linkPath));
         assert(fs.existsSync(linkData));
       }));
@@ -59,13 +54,10 @@ fs.symlink(linkData, linkPath, 'junction', common.mustCall(function(err) {
   const linkData = fixtures.path('/not/exists/dir');
   const linkPath = path.join(tmpdir.path, 'invalid_junction_link');
 
-  fs.symlink(linkData, linkPath, 'junction', common.mustCall(function(err) {
-    assert.ifError(err);
-
+  fs.symlink(linkData, linkPath, 'junction', common.mustSucceed(() => {
     assert(!fs.existsSync(linkPath));
 
-    fs.unlink(linkPath, common.mustCall(function(err) {
-      assert.ifError(err);
+    fs.unlink(linkPath, common.mustSucceed(() => {
       assert(!fs.existsSync(linkPath));
     }));
   }));
diff --git a/test/parallel/test-fs-symlink-dir.js b/test/parallel/test-fs-symlink-dir.js
index 707bc5b486d723cdf358e26a838ee4d09f5cccd5..012d34c301e83564a9b47d9b711f9668ee674808 100644
--- a/test/parallel/test-fs-symlink-dir.js
+++ b/test/parallel/test-fs-symlink-dir.js
@@ -18,11 +18,11 @@ tmpdir.refresh();
 
 const linkTargets = [
   'relative-target',
-  path.join(tmpdir.path, 'absolute-target')
+  path.join(tmpdir.path, 'absolute-target'),
 ];
 const linkPaths = [
   path.relative(process.cwd(), path.join(tmpdir.path, 'relative-path')),
-  path.join(tmpdir.path, 'absolute-path')
+  path.join(tmpdir.path, 'absolute-path'),
 ];
 
 function testSync(target, path) {
@@ -31,8 +31,7 @@ function testSync(target, path) {
 }
 
 function testAsync(target, path) {
-  fs.symlink(target, path, common.mustCall((err) => {
-    assert.ifError(err);
+  fs.symlink(target, path, common.mustSucceed(() => {
     fs.readdirSync(path);
   }));
 }
@@ -53,8 +52,7 @@ for (const linkTarget of linkTargets) {
   }
 
   function testAsync(target, path) {
-    fs.symlink(target, path, common.mustCall((err) => {
-      assert.ifError(err);
+    fs.symlink(target, path, common.mustSucceed(() => {
       assert(!fs.existsSync(path));
     }));
   }
diff --git a/test/parallel/test-fs-symlink-longpath.js b/test/parallel/test-fs-symlink-longpath.js
index f6824218137bf29fbb0732826a143abbab1bbc88..ac15b841df9c3a13be5a8955ea2872fb6f29d246 100644
--- a/test/parallel/test-fs-symlink-longpath.js
+++ b/test/parallel/test-fs-symlink-longpath.js
@@ -15,15 +15,13 @@ fs.mkdirSync(longPath, { recursive: true });
 const targetDirtectory = path.join(longPath, 'target-directory');
 fs.mkdirSync(targetDirtectory);
 const pathDirectory = path.join(tmpDir, 'new-directory');
-fs.symlink(targetDirtectory, pathDirectory, 'dir', common.mustCall((err) => {
-  assert.ifError(err);
+fs.symlink(targetDirtectory, pathDirectory, 'dir', common.mustSucceed(() => {
   assert(fs.existsSync(pathDirectory));
 }));
 
 const targetFile = path.join(longPath, 'target-file');
 fs.writeFileSync(targetFile, 'data');
 const pathFile = path.join(tmpDir, 'new-file');
-fs.symlink(targetFile, pathFile, common.mustCall((err) => {
-  assert.ifError(err);
+fs.symlink(targetFile, pathFile, common.mustSucceed(() => {
   assert(fs.existsSync(pathFile));
 }));
diff --git a/test/parallel/test-fs-symlink.js b/test/parallel/test-fs-symlink.js
index d1784fdd3a07f428202792513405a2e0098b2a15..836dfeae17016ced0e0abd1c4ef77c2351b69789 100644
--- a/test/parallel/test-fs-symlink.js
+++ b/test/parallel/test-fs-symlink.js
@@ -39,21 +39,16 @@ tmpdir.refresh();
 const linkData = fixtures.path('/cycles/root.js');
 const linkPath = path.join(tmpdir.path, 'symlink1.js');
 
-fs.symlink(linkData, linkPath, common.mustCall(function(err) {
-  assert.ifError(err);
-
-  fs.lstat(linkPath, common.mustCall(function(err, stats) {
-    assert.ifError(err);
+fs.symlink(linkData, linkPath, common.mustSucceed(() => {
+  fs.lstat(linkPath, common.mustSucceed((stats) => {
     linkTime = stats.mtime.getTime();
   }));
 
-  fs.stat(linkPath, common.mustCall(function(err, stats) {
-    assert.ifError(err);
+  fs.stat(linkPath, common.mustSucceed((stats) => {
     fileTime = stats.mtime.getTime();
   }));
 
-  fs.readlink(linkPath, common.mustCall(function(err, destination) {
-    assert.ifError(err);
+  fs.readlink(linkPath, common.mustSucceed((destination) => {
     assert.strictEqual(destination, linkData);
   }));
 }));
@@ -63,9 +58,7 @@ fs.symlink(linkData, linkPath, common.mustCall(function(err) {
   const linkData = fixtures.path('/not/exists/file');
   const linkPath = path.join(tmpdir.path, 'symlink2.js');
 
-  fs.symlink(linkData, linkPath, common.mustCall(function(err) {
-    assert.ifError(err);
-
+  fs.symlink(linkData, linkPath, common.mustSucceed(() => {
     assert(!fs.existsSync(linkPath));
   }));
 }
@@ -92,6 +85,6 @@ const errObj = {
 assert.throws(() => fs.symlink('', '', '🍏', common.mustNotCall()), errObj);
 assert.throws(() => fs.symlinkSync('', '', '🍏'), errObj);
 
-process.on('exit', function() {
+process.on('exit', () => {
   assert.notStrictEqual(linkTime, fileTime);
 });
diff --git a/test/parallel/test-fs-syncwritestream.js b/test/parallel/test-fs-syncwritestream.js
index 8fbe665a4047d07c503d96df48c37063be965b0f..35591876e849d4cb2723e5ca589da30b7f20fdfe 100644
--- a/test/parallel/test-fs-syncwritestream.js
+++ b/test/parallel/test-fs-syncwritestream.js
@@ -36,6 +36,6 @@ proc.on('close', common.mustCall(() => {
 
   assert.deepStrictEqual(JSON.parse(fs.readFileSync(filename, 'utf8')), [
     { instance: true, readable: false, writable: true },
-    { instance: true, readable: false, writable: true }
+    { instance: true, readable: false, writable: true },
   ]);
 }));
diff --git a/test/parallel/test-fs-truncate-clear-file-zero.js b/test/parallel/test-fs-truncate-clear-file-zero.js
index 4f3dce90995d06c5fee634336ac00384194a6060..234e65e5803793a3d6ab3039c95e2c62b8a30ceb 100644
--- a/test/parallel/test-fs-truncate-clear-file-zero.js
+++ b/test/parallel/test-fs-truncate-clear-file-zero.js
@@ -49,8 +49,7 @@ tmpdir.refresh();
   fs.truncate(
     filename,
     5,
-    common.mustCall(function(err) {
-      assert.ifError(err);
+    common.mustSucceed(() => {
       assert.strictEqual(fs.readFileSync(filename).toString(), '01234');
     })
   );
diff --git a/test/parallel/test-fs-truncate-fd.js b/test/parallel/test-fs-truncate-fd.js
index f71d511f5da057f88af516c833a3249310d3ef4f..51de2e5b91d3e8b568b3529e1b112c500576b738 100644
--- a/test/parallel/test-fs-truncate-fd.js
+++ b/test/parallel/test-fs-truncate-fd.js
@@ -16,12 +16,11 @@ const msg = 'Using fs.truncate with a file descriptor is deprecated.' +
 
 
 common.expectWarning('DeprecationWarning', msg, 'DEP0081');
-fs.truncate(fd, 5, common.mustCall((err) => {
-  assert.ok(!err);
+fs.truncate(fd, 5, common.mustSucceed(() => {
   assert.strictEqual(fs.readFileSync(filename, 'utf8'), 'hello');
 }));
 
-process.on('exit', () => {
+process.once('beforeExit', () => {
   fs.closeSync(fd);
   fs.unlinkSync(filename);
   console.log('ok');
diff --git a/test/parallel/test-fs-truncate.js b/test/parallel/test-fs-truncate.js
index 70de779e04a0bcb1d90afe79191c091666d1e17c..de9687ebb27f0cb264ae0e3de8293681c0c29216 100644
--- a/test/parallel/test-fs-truncate.js
+++ b/test/parallel/test-fs-truncate.js
@@ -71,9 +71,8 @@ fs.truncateSync(fd);
 fs.closeSync(fd);
 
 // Async tests
-testTruncate(common.mustCall(function(er) {
-  assert.ifError(er);
-  testFtruncate(common.mustCall(assert.ifError));
+testTruncate(common.mustSucceed(() => {
+  testFtruncate(common.mustSucceed());
 }));
 
 function testTruncate(cb) {
@@ -147,7 +146,7 @@ function testFtruncate(cb) {
   const file2 = path.resolve(tmp, 'truncate-file-2.txt');
   fs.writeFileSync(file2, 'Hi');
   const fd = fs.openSync(file2, 'r+');
-  process.on('exit', () => fs.closeSync(fd));
+  process.on('beforeExit', () => fs.closeSync(fd));
   fs.ftruncateSync(fd, 4);
   assert(fs.readFileSync(file2).equals(Buffer.from('Hi\u0000\u0000')));
 }
@@ -155,8 +154,7 @@ function testFtruncate(cb) {
 {
   const file3 = path.resolve(tmp, 'truncate-file-3.txt');
   fs.writeFileSync(file3, 'Hi');
-  fs.truncate(file3, 4, common.mustCall(function(err) {
-    assert.ifError(err);
+  fs.truncate(file3, 4, common.mustSucceed(() => {
     assert(fs.readFileSync(file3).equals(Buffer.from('Hi\u0000\u0000')));
   }));
 }
@@ -165,9 +163,8 @@ function testFtruncate(cb) {
   const file4 = path.resolve(tmp, 'truncate-file-4.txt');
   fs.writeFileSync(file4, 'Hi');
   const fd = fs.openSync(file4, 'r+');
-  process.on('exit', () => fs.closeSync(fd));
-  fs.ftruncate(fd, 4, common.mustCall(function(err) {
-    assert.ifError(err);
+  process.on('beforeExit', () => fs.closeSync(fd));
+  fs.ftruncate(fd, 4, common.mustSucceed(() => {
     assert(fs.readFileSync(file4).equals(Buffer.from('Hi\u0000\u0000')));
   }));
 }
@@ -176,7 +173,7 @@ function testFtruncate(cb) {
   const file5 = path.resolve(tmp, 'truncate-file-5.txt');
   fs.writeFileSync(file5, 'Hi');
   const fd = fs.openSync(file5, 'r+');
-  process.on('exit', () => fs.closeSync(fd));
+  process.on('beforeExit', () => fs.closeSync(fd));
 
   ['', false, null, {}, []].forEach((input) => {
     const received = common.invalidArgTypeHelper(input);
@@ -221,8 +218,7 @@ function testFtruncate(cb) {
     );
   });
 
-  fs.ftruncate(fd, undefined, common.mustCall(function(err) {
-    assert.ifError(err);
+  fs.ftruncate(fd, undefined, common.mustSucceed(() => {
     assert(fs.readFileSync(file5).equals(Buffer.from('')));
   }));
 }
@@ -231,9 +227,8 @@ function testFtruncate(cb) {
   const file6 = path.resolve(tmp, 'truncate-file-6.txt');
   fs.writeFileSync(file6, 'Hi');
   const fd = fs.openSync(file6, 'r+');
-  process.on('exit', () => fs.closeSync(fd));
-  fs.ftruncate(fd, -1, common.mustCall(function(err) {
-    assert.ifError(err);
+  process.on('beforeExit', () => fs.closeSync(fd));
+  fs.ftruncate(fd, -1, common.mustSucceed(() => {
     assert(fs.readFileSync(file6).equals(Buffer.from('')));
   }));
 }
@@ -241,8 +236,7 @@ function testFtruncate(cb) {
 {
   const file7 = path.resolve(tmp, 'truncate-file-7.txt');
   fs.writeFileSync(file7, 'Hi');
-  fs.truncate(file7, undefined, common.mustCall(function(err) {
-    assert.ifError(err);
+  fs.truncate(file7, undefined, common.mustSucceed(() => {
     assert(fs.readFileSync(file7).equals(Buffer.from('')));
   }));
 }
@@ -286,3 +280,19 @@ function testFtruncate(cb) {
     );
   });
 });
+
+{
+  const file1 = path.resolve(tmp, 'truncate-file-1.txt');
+  fs.writeFileSync(file1, 'Hi');
+  fs.truncateSync(file1, -1);  // Negative coerced to 0, No error.
+  assert(fs.readFileSync(file1).equals(Buffer.alloc(0)));
+}
+
+{
+  const file1 = path.resolve(tmp, 'truncate-file-2.txt');
+  fs.writeFileSync(file1, 'Hi');
+  // Negative coerced to 0, No error.
+  fs.truncate(file1, -1, common.mustSucceed(() => {
+    assert(fs.readFileSync(file1).equals(Buffer.alloc(0)));
+  }));
+}
diff --git a/test/parallel/test-fs-util-validateoffsetlengthwrite.js b/test/parallel/test-fs-util-validateoffsetlength.js
similarity index 40%
rename from test/parallel/test-fs-util-validateoffsetlengthwrite.js
rename to test/parallel/test-fs-util-validateoffsetlength.js
index be6d8acea77efa5adc82a6bcaaa192167b510fb0..28e087d33aec7b199e8eb7ed603eafdd47cd64e2 100644
--- a/test/parallel/test-fs-util-validateoffsetlengthwrite.js
+++ b/test/parallel/test-fs-util-validateoffsetlength.js
@@ -1,55 +1,87 @@
 // Flags: --expose-internals
 'use strict';
 
-require('../common');
+const common = require('../common');
+
 const assert = require('assert');
-const { validateOffsetLengthWrite } = require('internal/fs/utils');
-const { kMaxLength } = require('buffer');
+const {
+  validateOffsetLengthRead,
+  validateOffsetLengthWrite,
+} = require('internal/fs/utils');
 
-// RangeError when offset > byteLength
 {
-  const offset = 100;
-  const length = 100;
-  const byteLength = 50;
+  const offset = -1;
   assert.throws(
-    () => validateOffsetLengthWrite(offset, length, byteLength),
-    {
+    () => validateOffsetLengthRead(offset, 0, 0),
+    common.expectsError({
       code: 'ERR_OUT_OF_RANGE',
       name: 'RangeError',
       message: 'The value of "offset" is out of range. ' +
-               `It must be <= ${byteLength}. Received ${offset}`
-    }
+                 `It must be >= 0. Received ${offset}`
+    })
+  );
+}
+
+{
+  const length = -1;
+  assert.throws(
+    () => validateOffsetLengthRead(0, length, 0),
+    common.expectsError({
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "length" is out of range. ' +
+                 `It must be >= 0. Received ${length}`
+    })
   );
 }
 
-// RangeError when byteLength > kMaxLength, and length > kMaxLength - offset .
 {
-  const offset = kMaxLength;
+  const offset = 1;
+  const length = 1;
+  const byteLength = offset + length - 1;
+  assert.throws(
+    () => validateOffsetLengthRead(offset, length, byteLength),
+    common.expectsError({
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "length" is out of range. ' +
+                 `It must be <= ${byteLength - offset}. Received ${length}`
+    })
+  );
+}
+
+// Most platforms don't allow reads or writes >= 2 GB.
+// See https://github.com/libuv/libuv/pull/1501.
+const kIoMaxLength = 2 ** 31 - 1;
+
+// RangeError when offset > byteLength
+{
+  const offset = 100;
   const length = 100;
-  const byteLength = kMaxLength + 1;
+  const byteLength = 50;
   assert.throws(
     () => validateOffsetLengthWrite(offset, length, byteLength),
-    {
+    common.expectsError({
       code: 'ERR_OUT_OF_RANGE',
       name: 'RangeError',
-      message: 'The value of "length" is out of range. ' +
-               `It must be <= ${kMaxLength - offset}. Received ${length}`
-    }
+      message: 'The value of "offset" is out of range. ' +
+               `It must be <= ${byteLength}. Received ${offset}`
+    })
   );
 }
 
-// RangeError when byteLength < kMaxLength, and length > byteLength - offset .
+// RangeError when byteLength < kIoMaxLength, and length > byteLength - offset.
 {
-  const offset = kMaxLength - 150;
+  const offset = kIoMaxLength - 150;
   const length = 200;
-  const byteLength = kMaxLength - 100;
+  const byteLength = kIoMaxLength - 100;
   assert.throws(
     () => validateOffsetLengthWrite(offset, length, byteLength),
-    {
+    common.expectsError({
       code: 'ERR_OUT_OF_RANGE',
       name: 'RangeError',
       message: 'The value of "length" is out of range. ' +
                `It must be <= ${byteLength - offset}. Received ${length}`
-    }
+    })
   );
 }
diff --git a/test/parallel/test-fs-utils-get-dirents.js b/test/parallel/test-fs-utils-get-dirents.js
index 6afe6dbca3e52933fc9e63d75318eb4a7ec0cc1a..0cc6cd40243f19ae98586ed0c0f60a9bd32e2a90 100644
--- a/test/parallel/test-fs-utils-get-dirents.js
+++ b/test/parallel/test-fs-utils-get-dirents.js
@@ -61,7 +61,7 @@ const filename = 'foo';
         err.message,
         [
           'The "path" argument must be of type string or an ' +
-          'instance of Buffer. Received type number (42)'
+          'instance of Buffer. Received type number (42)',
         ].join(''));
     },
     ));
@@ -116,7 +116,7 @@ const filename = 'foo';
         err.message,
         [
           'The "path" argument must be of type string or an ' +
-          'instance of Buffer. Received type number (42)'
+          'instance of Buffer. Received type number (42)',
         ].join(''));
     },
     ));
diff --git a/test/parallel/test-fs-utimes-y2K38.js b/test/parallel/test-fs-utimes-y2K38.js
new file mode 100644
index 0000000000000000000000000000000000000000..9e42e90feb1fd699ac27f7377171780899f89b45
--- /dev/null
+++ b/test/parallel/test-fs-utimes-y2K38.js
@@ -0,0 +1,66 @@
+'use strict';
+const common = require('../common');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const assert = require('assert');
+const fs = require('fs');
+
+// Check for Y2K38 support. For Windows, assume it's there. Windows
+// doesn't have `touch` and `date -r` which are used in the check for support.
+if (!common.isWindows) {
+  const testFilePath = `${tmpdir.path}/y2k38-test`;
+  const testFileDate = '204001020304';
+  const { spawnSync } = require('child_process');
+  const touchResult = spawnSync('touch',
+                                ['-t', testFileDate, testFilePath],
+                                { encoding: 'utf8' });
+  if (touchResult.status !== 0) {
+    common.skip('File system appears to lack Y2K38 support (touch failed)');
+  }
+
+  // On some file systems that lack Y2K38 support, `touch` will succeed but
+  // the time will be incorrect.
+  const dateResult = spawnSync('date',
+                               ['-r', testFilePath, '+%Y%m%d%H%M'],
+                               { encoding: 'utf8' });
+  if (dateResult.status === 0) {
+    if (dateResult.stdout.trim() !== testFileDate) {
+      common.skip('File system appears to lack Y2k38 support (date failed)');
+    }
+  } else {
+    // On some platforms `date` may not support the `-r` option. Usually
+    // this will result in a non-zero status and usage information printed.
+    // In this case optimistically proceed -- the earlier `touch` succeeded
+    // but validation that the file has the correct time is not easily possible.
+    assert.match(dateResult.stderr, /[Uu]sage:/);
+  }
+}
+
+// Ref: https://github.com/nodejs/node/issues/13255
+const path = `${tmpdir.path}/test-utimes-precision`;
+fs.writeFileSync(path, '');
+
+const Y2K38_mtime = 2 ** 31;
+fs.utimesSync(path, Y2K38_mtime, Y2K38_mtime);
+const Y2K38_stats = fs.statSync(path);
+assert.strictEqual(Y2K38_stats.mtime.getTime() / 1000, Y2K38_mtime);
+
+if (common.isWindows) {
+  // This value would get converted to (double)1713037251359.9998
+  const truncate_mtime = 1713037251360;
+  fs.utimesSync(path, truncate_mtime / 1000, truncate_mtime / 1000);
+  const truncate_stats = fs.statSync(path);
+  assert.strictEqual(truncate_stats.mtime.getTime(), truncate_mtime);
+
+  // test Y2K38 for windows
+  // This value if treaded as a `signed long` gets converted to -2135622133469.
+  // POSIX systems stores timestamps in {long t_sec, long t_usec}.
+  // NTFS stores times in nanoseconds in a single `uint64_t`, so when libuv
+  // calculates (long)`uv_timespec_t.tv_sec` we get 2's complement.
+  const overflow_mtime = 2159345162531;
+  fs.utimesSync(path, overflow_mtime / 1000, overflow_mtime / 1000);
+  const overflow_stats = fs.statSync(path);
+  assert.strictEqual(overflow_stats.mtime.getTime(), overflow_mtime);
+}
diff --git a/test/parallel/test-fs-utimes.js b/test/parallel/test-fs-utimes.js
index b81c5b6bf62940ba93df19b4421e5436929a6a85..8f8286f8a3343f437b7ba966125ff8e8eb8982e4 100644
--- a/test/parallel/test-fs-utimes.js
+++ b/test/parallel/test-fs-utimes.js
@@ -156,37 +156,6 @@ function runTests(iter) {
   }
 }
 
-// Ref: https://github.com/nodejs/node/issues/13255
-const path = `${tmpdir.path}/test-utimes-precision`;
-fs.writeFileSync(path, '');
-
-// Test Y2K38 for all platforms [except 'arm', 'OpenBSD', 'SunOS' and 'IBMi']
-if (!process.arch.includes('arm') &&
-  !common.isOpenBSD && !common.isSunOS && !common.isIBMi) {
-  const Y2K38_mtime = 2 ** 31;
-  fs.utimesSync(path, Y2K38_mtime, Y2K38_mtime);
-  const Y2K38_stats = fs.statSync(path);
-  assert.strictEqual(Y2K38_stats.mtime.getTime() / 1000, Y2K38_mtime);
-}
-
-if (common.isWindows) {
-  // This value would get converted to (double)1713037251359.9998
-  const truncate_mtime = 1713037251360;
-  fs.utimesSync(path, truncate_mtime / 1000, truncate_mtime / 1000);
-  const truncate_stats = fs.statSync(path);
-  assert.strictEqual(truncate_stats.mtime.getTime(), truncate_mtime);
-
-  // test Y2K38 for windows
-  // This value if treaded as a `signed long` gets converted to -2135622133469.
-  // POSIX systems stores timestamps in {long t_sec, long t_usec}.
-  // NTFS stores times in nanoseconds in a single `uint64_t`, so when libuv
-  // calculates (long)`uv_timespec_t.tv_sec` we get 2's complement.
-  const overflow_mtime = 2159345162531;
-  fs.utimesSync(path, overflow_mtime / 1000, overflow_mtime / 1000);
-  const overflow_stats = fs.statSync(path);
-  assert.strictEqual(overflow_stats.mtime.getTime(), overflow_mtime);
-}
-
 const expectTypeError = {
   code: 'ERR_INVALID_ARG_TYPE',
   name: 'TypeError'
diff --git a/test/parallel/test-fs-watch-abort-signal.js b/test/parallel/test-fs-watch-abort-signal.js
new file mode 100644
index 0000000000000000000000000000000000000000..e5589bc1140f8b37ea0edd2f9b9436b2b6789376
--- /dev/null
+++ b/test/parallel/test-fs-watch-abort-signal.js
@@ -0,0 +1,32 @@
+// Flags: --expose-internals --experimental-abortcontroller
+'use strict';
+
+// Verify that AbortSignal integration works for fs.watch
+
+const common = require('../common');
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+
+
+{
+  // Signal aborted after creating the watcher
+  const file = fixtures.path('empty.js');
+  const ac = new AbortController();
+  const { signal } = ac;
+  const watcher = fs.watch(file, { signal });
+  watcher.once('close', common.mustCall());
+  setImmediate(() => ac.abort());
+}
+{
+  // Signal aborted before creating the watcher
+  const file = fixtures.path('empty.js');
+  const ac = new AbortController();
+  const { signal } = ac;
+  ac.abort();
+  const watcher = fs.watch(file, { signal });
+  watcher.once('close', common.mustCall());
+}
diff --git a/test/parallel/test-fs-watch-recursive.js b/test/parallel/test-fs-watch-recursive.js
index 4985ece0e0ec15c5869b4aa1dce54d3f50c81fc1..70b413814e78f4b10de4e6e71060e5fba0d76caf 100644
--- a/test/parallel/test-fs-watch-recursive.js
+++ b/test/parallel/test-fs-watch-recursive.js
@@ -2,8 +2,6 @@
 
 const common = require('../common');
 
-if (!(common.isOSX || common.isWindows))
-  common.skip('recursive option is darwin/windows specific');
 
 const assert = require('assert');
 const path = require('path');
@@ -20,6 +18,11 @@ const testsubdir = fs.mkdtempSync(testDir + path.sep);
 const relativePathOne = path.join(path.basename(testsubdir), filenameOne);
 const filepathOne = path.join(testsubdir, filenameOne);
 
+if (!common.isOSX && !common.isWindows) {
+  assert.throws(() => { fs.watch(testDir, { recursive: true }); },
+                { code: 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM' });
+  return;
+}
 const watcher = fs.watch(testDir, { recursive: true });
 
 let watcherClosed = false;
diff --git a/test/parallel/test-fs-watch.js b/test/parallel/test-fs-watch.js
index 3777589e5b5335b3a13666b223c937710903bef8..6fcf6c4df63fdcbfc568fd17bed83449e4633b65 100644
--- a/test/parallel/test-fs-watch.js
+++ b/test/parallel/test-fs-watch.js
@@ -35,7 +35,7 @@ const cases = [
     'watch2',
     'bar',
     'dirPath'
-  )
+  ),
 ];
 
 const tmpdir = require('../common/tmpdir');
@@ -60,8 +60,6 @@ for (const testCase of cases) {
   });
   watcher.on('close', common.mustCall(() => {
     watcher.close(); // Closing a closed watcher should be a noop
-    // Starting a closed watcher should be a noop
-    watcher.start();
   }));
   watcher.on('change', common.mustCall(function(eventType, argFilename) {
     if (interval) {
@@ -74,16 +72,11 @@ for (const testCase of cases) {
       assert.strictEqual(eventType, 'change');
     assert.strictEqual(argFilename, testCase.fileName);
 
-    // Starting a started watcher should be a noop
-    watcher.start();
-    watcher.start(pathToWatch);
-
     watcher.close();
 
     // We document that watchers cannot be used anymore when it's closed,
     // here we turn the methods into noops instead of throwing
     watcher.close(); // Closing a closed watcher should be a noop
-    watcher.start();  // Starting a closed watcher should be a noop
   }));
 
   // Long content so it's actually flushed. toUpperCase so there's real change.
diff --git a/test/parallel/test-fs-watchfile-bigint.js b/test/parallel/test-fs-watchfile-bigint.js
index 500a0ef1f64b1b4bd21e68fadfb3bb2064d1c2fa..569c7ad6f57fe426207264429679c1dfbfc48967 100644
--- a/test/parallel/test-fs-watchfile-bigint.js
+++ b/test/parallel/test-fs-watchfile-bigint.js
@@ -67,5 +67,3 @@ const watcher =
 // 'stop' should only be emitted once - stopping a stopped watcher should
 // not trigger a 'stop' event.
 watcher.on('stop', common.mustCall(function onStop() {}));
-
-watcher.start();  // Starting a started watcher should be a noop
diff --git a/test/parallel/test-fs-watchfile.js b/test/parallel/test-fs-watchfile.js
index 5f39f85ac88e97a42756bd4248e71e1c87151fd1..4e5af9d77bb15a7a4ed653157b10a782f7cb910d 100644
--- a/test/parallel/test-fs-watchfile.js
+++ b/test/parallel/test-fs-watchfile.js
@@ -82,8 +82,6 @@ const watcher =
 // not trigger a 'stop' event.
 watcher.on('stop', common.mustCall(function onStop() {}));
 
-watcher.start();  // Starting a started watcher should be a noop
-
 // Watch events should callback with a filename on supported systems.
 // Omitting AIX. It works but not reliably.
 if (common.isLinux || common.isOSX || common.isWindows) {
diff --git a/test/parallel/test-fs-whatwg-url.js b/test/parallel/test-fs-whatwg-url.js
index 73c6c03e188eb732822534191b62469c56dd7447..829cfa92fafebd94995272d85bbb544aca4e1c27 100644
--- a/test/parallel/test-fs-whatwg-url.js
+++ b/test/parallel/test-fs-whatwg-url.js
@@ -6,7 +6,6 @@ const assert = require('assert');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-const URL = require('url').URL;
 
 function pathToFileURL(p) {
   if (!path.isAbsolute(p))
@@ -22,8 +21,7 @@ const url = pathToFileURL(p);
 assert(url instanceof URL);
 
 // Check that we can pass in a URL object successfully
-fs.readFile(url, common.mustCall((err, data) => {
-  assert.ifError(err);
+fs.readFile(url, common.mustSucceed((data) => {
   assert(Buffer.isBuffer(data));
 }));
 
@@ -63,7 +61,7 @@ if (common.isWindows) {
       code: 'ERR_INVALID_ARG_VALUE',
       name: 'TypeError',
       message: 'The argument \'path\' must be a string or Uint8Array without ' +
-               'null bytes. Received \'c:\\\\tmp\\\\\\u0000test\''
+               "null bytes. Received 'c:\\\\tmp\\\\\\x00test'"
     }
   );
 } else {
@@ -97,7 +95,7 @@ if (common.isWindows) {
       code: 'ERR_INVALID_ARG_VALUE',
       name: 'TypeError',
       message: "The argument 'path' must be a string or Uint8Array without " +
-               "null bytes. Received '/tmp/\\u0000test'"
+               "null bytes. Received '/tmp/\\x00test'"
     }
   );
 }
diff --git a/test/parallel/test-fs-write-buffer-large.js b/test/parallel/test-fs-write-buffer-large.js
new file mode 100644
index 0000000000000000000000000000000000000000..a80072354eaa0feeb5e89615439ae4892acb01ad
--- /dev/null
+++ b/test/parallel/test-fs-write-buffer-large.js
@@ -0,0 +1,40 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// fs.write with length > INT32_MAX
+
+common.skipIf32Bits();
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(0x7FFFFFFF + 1);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip('skipped due to memory requirements');
+}
+
+const filename = path.join(tmpdir.path, 'write9.txt');
+fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+  assert.throws(() => {
+    fs.write(fd,
+             buf,
+             0,
+             0x7FFFFFFF + 1,
+             0,
+             common.mustNotCall());
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: 'The value of "length" is out of range. ' +
+      'It must be >= 0 && <= 2147483647. Received 2147483648'
+  });
+
+  fs.closeSync(fd);
+}));
diff --git a/test/parallel/test-fs-write-buffer.js b/test/parallel/test-fs-write-buffer.js
index 362571f2479c84a459169ba0f208f26f08bb1120..a70c44eaceffe50dca2e9c7beab4ae0338010485 100644
--- a/test/parallel/test-fs-write-buffer.js
+++ b/test/parallel/test-fs-write-buffer.js
@@ -32,12 +32,8 @@ tmpdir.refresh();
 // fs.write with all parameters provided:
 {
   const filename = path.join(tmpdir.path, 'write1.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall((err, fd) => {
-    assert.ifError(err);
-
-    const cb = common.mustCall((err, written) => {
-      assert.ifError(err);
-
+  fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+    const cb = common.mustSucceed((written) => {
       assert.strictEqual(written, expected.length);
       fs.closeSync(fd);
 
@@ -52,12 +48,8 @@ tmpdir.refresh();
 // fs.write with a buffer, without the length parameter:
 {
   const filename = path.join(tmpdir.path, 'write2.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall((err, fd) => {
-    assert.ifError(err);
-
-    const cb = common.mustCall((err, written) => {
-      assert.ifError(err);
-
+  fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+    const cb = common.mustSucceed((written) => {
       assert.strictEqual(written, 2);
       fs.closeSync(fd);
 
@@ -72,12 +64,8 @@ tmpdir.refresh();
 // fs.write with a buffer, without the offset and length parameters:
 {
   const filename = path.join(tmpdir.path, 'write3.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall(function(err, fd) {
-    assert.ifError(err);
-
-    const cb = common.mustCall(function(err, written) {
-      assert.ifError(err);
-
+  fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+    const cb = common.mustSucceed((written) => {
       assert.strictEqual(written, expected.length);
       fs.closeSync(fd);
 
@@ -92,12 +80,8 @@ tmpdir.refresh();
 // fs.write with the offset passed as undefined followed by the callback:
 {
   const filename = path.join(tmpdir.path, 'write4.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall(function(err, fd) {
-    assert.ifError(err);
-
-    const cb = common.mustCall(function(err, written) {
-      assert.ifError(err);
-
+  fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+    const cb = common.mustSucceed((written) => {
       assert.strictEqual(written, expected.length);
       fs.closeSync(fd);
 
@@ -112,12 +96,8 @@ tmpdir.refresh();
 // fs.write with offset and length passed as undefined followed by the callback:
 {
   const filename = path.join(tmpdir.path, 'write5.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall((err, fd) => {
-    assert.ifError(err);
-
-    const cb = common.mustCall((err, written) => {
-      assert.ifError(err);
-
+  fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+    const cb = common.mustSucceed((written) => {
       assert.strictEqual(written, expected.length);
       fs.closeSync(fd);
 
@@ -132,12 +112,46 @@ tmpdir.refresh();
 // fs.write with a Uint8Array, without the offset and length parameters:
 {
   const filename = path.join(tmpdir.path, 'write6.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall((err, fd) => {
-    assert.ifError(err);
+  fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+    const cb = common.mustSucceed((written) => {
+      assert.strictEqual(written, expected.length);
+      fs.closeSync(fd);
 
-    const cb = common.mustCall((err, written) => {
-      assert.ifError(err);
+      const found = fs.readFileSync(filename, 'utf8');
+      assert.strictEqual(found, expected.toString());
+    });
 
+    fs.write(fd, Uint8Array.from(expected), cb);
+  }));
+}
+
+// fs.write with invalid offset type
+{
+  const filename = path.join(tmpdir.path, 'write7.txt');
+  fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+    assert.throws(() => {
+      fs.write(fd,
+               Buffer.from('abcd'),
+               NaN,
+               expected.length,
+               0,
+               common.mustNotCall());
+    }, {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "offset" is out of range. ' +
+               'It must be an integer. Received NaN'
+    });
+
+    fs.closeSync(fd);
+  }));
+}
+
+// fs.write with a DataView, without the offset and length parameters:
+{
+  const filename = path.join(tmpdir.path, 'write8.txt');
+  fs.open(filename, 'w', 0o644, common.mustSucceed((fd) => {
+    const cb = common.mustSucceed((written) => {
       assert.strictEqual(written, expected.length);
       fs.closeSync(fd);
 
@@ -145,6 +159,7 @@ tmpdir.refresh();
       assert.strictEqual(found, expected.toString());
     });
 
-    fs.write(fd, Uint8Array.from(expected), cb);
+    const uint8 = Uint8Array.from(expected);
+    fs.write(fd, new DataView(uint8.buffer), cb);
   }));
 }
diff --git a/test/parallel/test-fs-write-file-sync.js b/test/parallel/test-fs-write-file-sync.js
index 013322ed15ba46d2232c0f333ef857114351f399..2ef7d14365b7814696a9ec36d41e57f6fd745dcb 100644
--- a/test/parallel/test-fs-write-file-sync.js
+++ b/test/parallel/test-fs-write-file-sync.js
@@ -101,3 +101,17 @@ tmpdir.refresh();
   const content = fs.readFileSync(file, { encoding: 'utf8' });
   assert.strictEqual(content, 'hello world!');
 }
+
+// Test writeFileSync with an object with an own toString function
+{
+  const file = path.join(tmpdir.path, 'testWriteFileSyncStringify.txt');
+  const data = {
+    toString() {
+      return 'hello world!';
+    }
+  };
+
+  fs.writeFileSync(file, data, { encoding: 'utf8', flag: 'a' });
+  const content = fs.readFileSync(file, { encoding: 'utf8' });
+  assert.strictEqual(content, String(data));
+}
diff --git a/test/parallel/test-fs-write-file-typedarrays.js b/test/parallel/test-fs-write-file-typedarrays.js
index eca22750f6f903e399372eb721355157bfdb1879..9b48bf9dbbafa13bda80949f976832b7e0983dc1 100644
--- a/test/parallel/test-fs-write-file-typedarrays.js
+++ b/test/parallel/test-fs-write-file-typedarrays.js
@@ -33,11 +33,8 @@ for (const expectView of common.getArrayBufferViews(inputBuffer)) {
 for (const expectView of common.getArrayBufferViews(inputBuffer)) {
   console.log('Async test for ', expectView[Symbol.toStringTag]);
   const file = `${filename}-${expectView[Symbol.toStringTag]}`;
-  fs.writeFile(file, expectView, common.mustCall((e) => {
-    assert.ifError(e);
-
-    fs.readFile(file, 'utf8', common.mustCall((err, data) => {
-      assert.ifError(err);
+  fs.writeFile(file, expectView, common.mustSucceed(() => {
+    fs.readFile(file, 'utf8', common.mustSucceed((data) => {
       assert.strictEqual(data, inputBuffer.toString('utf8'));
     }));
   }));
diff --git a/test/parallel/test-fs-write-file.js b/test/parallel/test-fs-write-file.js
index b9536bea4ca1310431e5b6fad429cb8c8469381f..129560e63601fa95b3aec6554327c6540bf08407 100644
--- a/test/parallel/test-fs-write-file.js
+++ b/test/parallel/test-fs-write-file.js
@@ -19,6 +19,7 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+// Flags: --experimental-abortcontroller
 'use strict';
 const common = require('../common');
 const assert = require('assert');
@@ -30,7 +31,6 @@ tmpdir.refresh();
 
 const filename = join(tmpdir.path, 'test.txt');
 
-const n = 220;
 const s = '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
           '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
           '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
@@ -39,11 +39,8 @@ const s = '南越国是前203年至前111年存在于岭南地区的一个国家
           '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
           '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
 
-fs.writeFile(filename, s, common.mustCall(function(e) {
-  assert.ifError(e);
-
-  fs.readFile(filename, common.mustCall(function(e, buffer) {
-    assert.ifError(e);
+fs.writeFile(filename, s, common.mustSucceed(() => {
+  fs.readFile(filename, common.mustSucceed((buffer) => {
     assert.strictEqual(Buffer.byteLength(s), buffer.length);
   }));
 }));
@@ -52,60 +49,50 @@ fs.writeFile(filename, s, common.mustCall(function(e) {
 const filename2 = join(tmpdir.path, 'test2.txt');
 const buf = Buffer.from(s, 'utf8');
 
-fs.writeFile(filename2, buf, common.mustCall(function(e) {
-  assert.ifError(e);
-
-  fs.readFile(filename2, common.mustCall(function(e, buffer) {
-    assert.ifError(e);
-
+fs.writeFile(filename2, buf, common.mustSucceed(() => {
+  fs.readFile(filename2, common.mustSucceed((buffer) => {
     assert.strictEqual(buf.length, buffer.length);
   }));
 }));
 
-// Test that writeFile accepts numbers.
-const filename3 = join(tmpdir.path, 'test3.txt');
-
-const m = 0o600;
-fs.writeFile(filename3, n, { mode: m }, common.mustCall(function(e) {
-  assert.ifError(e);
-
-  // Windows permissions aren't Unix.
-  if (!common.isWindows) {
-    const st = fs.statSync(filename3);
-    assert.strictEqual(st.mode & 0o700, m);
-  }
-
-  fs.readFile(filename3, common.mustCall(function(e, buffer) {
-    assert.ifError(e);
+// Test that writeFile accepts file descriptors.
+const filename4 = join(tmpdir.path, 'test4.txt');
 
-    assert.strictEqual(Buffer.byteLength(String(n)), buffer.length);
+fs.open(filename4, 'w+', common.mustSucceed((fd) => {
+  fs.writeFile(fd, s, common.mustSucceed(() => {
+    fs.close(fd, common.mustSucceed(() => {
+      fs.readFile(filename4, common.mustSucceed((buffer) => {
+        assert.strictEqual(Buffer.byteLength(s), buffer.length);
+      }));
+    }));
   }));
 }));
 
-// Test that writeFile accepts file descriptors.
-const filename4 = join(tmpdir.path, 'test4.txt');
 
-fs.open(filename4, 'w+', common.mustCall(function(e, fd) {
-  assert.ifError(e);
+{
+  // Test that writeFile is cancellable with an AbortSignal.
+  // Before the operation has started
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const filename3 = join(tmpdir.path, 'test3.txt');
 
-  fs.writeFile(fd, s, common.mustCall(function(e) {
-    assert.ifError(e);
+  fs.writeFile(filename3, s, { signal }, common.mustCall((err) => {
+    assert.strictEqual(err.name, 'AbortError');
+  }));
 
-    fs.close(fd, common.mustCall(function(e) {
-      assert.ifError(e);
+  controller.abort();
+}
 
-      fs.readFile(filename4, common.mustCall(function(e, buffer) {
-        assert.ifError(e);
+{
+  // Test that writeFile is cancellable with an AbortSignal.
+  // After the operation has started
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const filename4 = join(tmpdir.path, 'test5.txt');
 
-        assert.strictEqual(Buffer.byteLength(s), buffer.length);
-      }));
-    }));
+  fs.writeFile(filename4, s, { signal }, common.mustCall((err) => {
+    assert.strictEqual(err.name, 'AbortError');
   }));
-}));
 
-process.on('exit', function() {
-  fs.unlinkSync(filename);
-  fs.unlinkSync(filename2);
-  fs.unlinkSync(filename3);
-  fs.unlinkSync(filename4);
-});
+  process.nextTick(() => controller.abort());
+}
diff --git a/test/parallel/test-fs-write-negativeoffset.js b/test/parallel/test-fs-write-negativeoffset.js
new file mode 100644
index 0000000000000000000000000000000000000000..b1c6ed9039b7d799d7a2782da837fd402cbf67c6
--- /dev/null
+++ b/test/parallel/test-fs-write-negativeoffset.js
@@ -0,0 +1,55 @@
+'use strict';
+
+// Tests that passing a negative offset does not crash the process
+
+const common = require('../common');
+
+const {
+  join,
+} = require('path');
+
+const {
+  closeSync,
+  open,
+  write,
+  writeSync,
+} = require('fs');
+
+const assert = require('assert');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const filename = join(tmpdir.path, 'test.txt');
+
+open(filename, 'w+', common.mustSucceed((fd) => {
+  assert.throws(() => {
+    write(fd, Buffer.alloc(0), -1, common.mustNotCall());
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+  assert.throws(() => {
+    writeSync(fd, Buffer.alloc(0), -1);
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+  closeSync(fd);
+}));
+
+const filename2 = join(tmpdir.path, 'test2.txt');
+
+// Make sure negative length's don't cause aborts either
+
+open(filename2, 'w+', common.mustSucceed((fd) => {
+  assert.throws(() => {
+    write(fd, Buffer.alloc(0), 0, -1, common.mustNotCall());
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+  assert.throws(() => {
+    writeSync(fd, Buffer.alloc(0), 0, -1);
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+  });
+  closeSync(fd);
+}));
diff --git a/test/parallel/test-fs-write-reuse-callback.js b/test/parallel/test-fs-write-reuse-callback.js
new file mode 100644
index 0000000000000000000000000000000000000000..790d719b67c46b3bfdea03ee404c13134d56609d
--- /dev/null
+++ b/test/parallel/test-fs-write-reuse-callback.js
@@ -0,0 +1,38 @@
+// Flags: --expose-gc
+'use strict';
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const path = require('path');
+
+// Regression test for https://github.com/nodejs/node-v0.x-archive/issues/814:
+// Make sure that Buffers passed to fs.write() are not garbage-collected
+// even when the callback is being reused.
+
+const fs = require('fs');
+
+tmpdir.refresh();
+const filename = path.join(tmpdir.path, 'test.txt');
+const fd = fs.openSync(filename, 'w');
+
+const size = 16 * 1024;
+const writes = 1000;
+let done = 0;
+
+const ondone = common.mustSucceed(() => {
+  if (++done < writes) {
+    if (done % 25 === 0) global.gc();
+    setImmediate(write);
+  } else {
+    assert.strictEqual(
+      fs.readFileSync(filename, 'utf8'),
+      'x'.repeat(writes * size));
+    fs.closeSync(fd);
+  }
+}, writes);
+
+write();
+function write() {
+  const buf = Buffer.alloc(size, 'x');
+  fs.write(fd, buf, 0, buf.length, -1, ondone);
+}
diff --git a/test/parallel/test-fs-write-stream-autoclose-option.js b/test/parallel/test-fs-write-stream-autoclose-option.js
index e39f4d615ab7e030a991eb741f985c76d44b0aed..8d205fbc69fb39057aeff7171929ccecfac86be9 100644
--- a/test/parallel/test-fs-write-stream-autoclose-option.js
+++ b/test/parallel/test-fs-write-stream-autoclose-option.js
@@ -27,8 +27,8 @@ function next() {
   stream.end();
   stream.on('finish', common.mustCall(function() {
     assert.strictEqual(stream.closed, false);
-    assert.strictEqual(stream.fd, null);
     stream.on('close', common.mustCall(function() {
+      assert.strictEqual(stream.fd, null);
       assert.strictEqual(stream.closed, true);
       process.nextTick(next2);
     }));
@@ -51,8 +51,8 @@ function next3() {
   stream.end();
   stream.on('finish', common.mustCall(function() {
     assert.strictEqual(stream.closed, false);
-    assert.strictEqual(stream.fd, null);
     stream.on('close', common.mustCall(function() {
+      assert.strictEqual(stream.fd, null);
       assert.strictEqual(stream.closed, true);
     }));
   }));
diff --git a/test/parallel/test-fs-write-stream-change-open.js b/test/parallel/test-fs-write-stream-change-open.js
index 56dbafd656431b5e86ac15a70941c71e79acdcb3..2fc06cf901615b63cfc5552a97b66806762317e3 100644
--- a/test/parallel/test-fs-write-stream-change-open.js
+++ b/test/parallel/test-fs-write-stream-change-open.js
@@ -46,6 +46,7 @@ fs.close = function(fd) {
   assert.ok(fd, 'fs.close must not be called with an undefined fd.');
   fs.close = _fs_close;
   fs.open = _fs_open;
+  fs.closeSync(fd);
 };
 
 stream.write('foo');
diff --git a/test/parallel/test-fs-write-stream-err.js b/test/parallel/test-fs-write-stream-err.js
index 0db517da2a58d9bee4e968c993e5c727cfa65ba1..6d6f25b21f0e273801a689d923bf0fb102425fb8 100644
--- a/test/parallel/test-fs-write-stream-err.js
+++ b/test/parallel/test-fs-write-stream-err.js
@@ -56,6 +56,7 @@ fs.write = function() {
 fs.close = common.mustCall(function(fd_, cb) {
   console.error('fs.close', fd_, stream.fd);
   assert.strictEqual(fd_, stream.fd);
+  fs.closeSync(fd_);
   process.nextTick(cb);
 });
 
diff --git a/test/parallel/test-fs-write-stream-patch-open.js b/test/parallel/test-fs-write-stream-patch-open.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac683785cbfec739f064308605b9655a75e99602
--- /dev/null
+++ b/test/parallel/test-fs-write-stream-patch-open.js
@@ -0,0 +1,34 @@
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+
+// Run in a child process because 'out' is opened twice, blocking the tmpdir
+// and preventing cleanup.
+if (process.argv[2] !== 'child') {
+  // Parent
+  const assert = require('assert');
+  const { fork } = require('child_process');
+  tmpdir.refresh();
+
+  // Run test
+  const child = fork(__filename, ['child'], { stdio: 'inherit' });
+  child.on('exit', common.mustCall(function(code) {
+    assert.strictEqual(code, 0);
+  }));
+
+  return;
+}
+
+// Child
+
+common.expectWarning(
+  'DeprecationWarning',
+  'WriteStream.prototype.open() is deprecated', 'DEP0135');
+const s = fs.createWriteStream(`${tmpdir.path}/out`);
+s.open();
+
+// Allow overriding open().
+fs.WriteStream.prototype.open = common.mustCall();
+fs.createWriteStream('asd');
diff --git a/test/parallel/test-fs-write-stream-throw-type-error.js b/test/parallel/test-fs-write-stream-throw-type-error.js
index 1c1da2d6079af2897aea09a2a7f048260e5dcfa7..77d546a61ace3de01dbddc437c9d3b5c43fc56a0 100644
--- a/test/parallel/test-fs-write-stream-throw-type-error.js
+++ b/test/parallel/test-fs-write-stream-throw-type-error.js
@@ -10,10 +10,10 @@ const example = path.join(tmpdir.path, 'dummy');
 
 tmpdir.refresh();
 // Should not throw.
-fs.createWriteStream(example, undefined);
-fs.createWriteStream(example, null);
-fs.createWriteStream(example, 'utf8');
-fs.createWriteStream(example, { encoding: 'utf8' });
+fs.createWriteStream(example, undefined).end();
+fs.createWriteStream(example, null).end();
+fs.createWriteStream(example, 'utf8').end();
+fs.createWriteStream(example, { encoding: 'utf8' }).end();
 
 const createWriteStreamErr = (path, opt) => {
   assert.throws(
diff --git a/test/parallel/test-fs-write-stream.js b/test/parallel/test-fs-write-stream.js
index dba577a2be97c42d780ab54e589e904e967fec73..9f422a644379e8fa9f223e6fb2b1d8f0af54dff9 100644
--- a/test/parallel/test-fs-write-stream.js
+++ b/test/parallel/test-fs-write-stream.js
@@ -38,6 +38,7 @@ tmpdir.refresh();
   fs.close = function(fd) {
     assert.ok(fd, 'fs.close must not be called without an undefined fd.');
     fs.close = _fs_close;
+    fs.closeSync(fd);
   };
   stream.destroy();
 }
@@ -55,13 +56,12 @@ tmpdir.refresh();
 // Throws if data is not of type Buffer.
 {
   const stream = fs.createWriteStream(file);
-  stream.on('error', common.expectsError({
+  stream.on('error', common.mustNotCall());
+  assert.throws(() => {
+    stream.write(42);
+  }, {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError'
-  }));
-  stream.write(42, null, common.expectsError({
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError'
-  }));
+  });
   stream.destroy();
 }
diff --git a/test/parallel/test-fs-write-string-coerce.js b/test/parallel/test-fs-write-string-coerce.js
deleted file mode 100644
index b9ac82aec026c504af095f62233c04f75d442aa2..0000000000000000000000000000000000000000
--- a/test/parallel/test-fs-write-string-coerce.js
+++ /dev/null
@@ -1,28 +0,0 @@
-'use strict';
-const common = require('../common');
-const assert = require('assert');
-const path = require('path');
-const fs = require('fs');
-
-const tmpdir = require('../common/tmpdir');
-tmpdir.refresh();
-
-const fn = path.join(tmpdir.path, 'write-string-coerce.txt');
-const data = true;
-const expected = String(data);
-
-fs.open(fn, 'w', 0o644, common.mustCall(function(err, fd) {
-  assert.ifError(err);
-  console.log('open done');
-  fs.write(fd, data, 0, 'utf8', common.mustCall(function(err, written) {
-    console.log('write done');
-    assert.ifError(err);
-    assert.strictEqual(written, Buffer.byteLength(expected));
-    fs.closeSync(fd);
-    const found = fs.readFileSync(fn, 'utf8');
-    console.log(`expected: "${expected}"`);
-    console.log(`found: "${found}"`);
-    fs.unlinkSync(fn);
-    assert.strictEqual(found, expected);
-  }));
-}));
diff --git a/test/parallel/test-fs-write.js b/test/parallel/test-fs-write.js
index 39a0f3720ee76a6b4e475a8bc666679a37d449b0..63f0245663c435b141819847fc222a5ab574c0bd 100644
--- a/test/parallel/test-fs-write.js
+++ b/test/parallel/test-fs-write.js
@@ -32,14 +32,17 @@ tmpdir.refresh();
 const fn = path.join(tmpdir.path, 'write.txt');
 const fn2 = path.join(tmpdir.path, 'write2.txt');
 const fn3 = path.join(tmpdir.path, 'write3.txt');
+const fn4 = path.join(tmpdir.path, 'write4.txt');
 const expected = 'ümlaut.';
 const constants = fs.constants;
 
-/* eslint-disable no-undef */
-common.allowGlobals(externalizeString, isOneByteString, x);
+const { externalizeString, isOneByteString } = global;
+
+// Account for extra globals exposed by --expose_externalize_string.
+common.allowGlobals(externalizeString, isOneByteString, global.x);
 
 {
-  const expected = 'ümlaut eins';  // Must be a unique string.
+  const expected = 'ümlaut sechzig';  // Must be a unique string.
   externalizeString(expected);
   assert.strictEqual(isOneByteString(expected), true);
   const fd = fs.openSync(fn, 'w');
@@ -49,7 +52,7 @@ common.allowGlobals(externalizeString, isOneByteString, x);
 }
 
 {
-  const expected = 'ümlaut zwei';  // Must be a unique string.
+  const expected = 'ümlaut neunzig';  // Must be a unique string.
   externalizeString(expected);
   assert.strictEqual(isOneByteString(expected), true);
   const fd = fs.openSync(fn, 'w');
@@ -59,7 +62,7 @@ common.allowGlobals(externalizeString, isOneByteString, x);
 }
 
 {
-  const expected = '中文 1';  // Must be a unique string.
+  const expected = 'Zhōngwén 1';  // Must be a unique string.
   externalizeString(expected);
   assert.strictEqual(isOneByteString(expected), false);
   const fd = fs.openSync(fn, 'w');
@@ -69,7 +72,7 @@ common.allowGlobals(externalizeString, isOneByteString, x);
 }
 
 {
-  const expected = '中文 2';  // Must be a unique string.
+  const expected = 'Zhōngwén 2';  // Must be a unique string.
   externalizeString(expected);
   assert.strictEqual(isOneByteString(expected), false);
   const fd = fs.openSync(fn, 'w');
@@ -77,13 +80,9 @@ common.allowGlobals(externalizeString, isOneByteString, x);
   fs.closeSync(fd);
   assert.strictEqual(fs.readFileSync(fn, 'utf8'), expected);
 }
-/* eslint-enable no-undef */
-
-fs.open(fn, 'w', 0o644, common.mustCall((err, fd) => {
-  assert.ifError(err);
 
-  const done = common.mustCall((err, written) => {
-    assert.ifError(err);
+fs.open(fn, 'w', 0o644, common.mustSucceed((fd) => {
+  const done = common.mustSucceed((written) => {
     assert.strictEqual(written, Buffer.byteLength(expected));
     fs.closeSync(fd);
     const found = fs.readFileSync(fn, 'utf8');
@@ -91,8 +90,7 @@ fs.open(fn, 'w', 0o644, common.mustCall((err, fd) => {
     assert.strictEqual(found, expected);
   });
 
-  const written = common.mustCall((err, written) => {
-    assert.ifError(err);
+  const written = common.mustSucceed((written) => {
     assert.strictEqual(written, 0);
     fs.write(fd, expected, 0, 'utf8', done);
   });
@@ -101,11 +99,8 @@ fs.open(fn, 'w', 0o644, common.mustCall((err, fd) => {
 }));
 
 const args = constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC;
-fs.open(fn2, args, 0o644, common.mustCall((err, fd) => {
-  assert.ifError(err);
-
-  const done = common.mustCall((err, written) => {
-    assert.ifError(err);
+fs.open(fn2, args, 0o644, common.mustSucceed((fd) => {
+  const done = common.mustSucceed((written) => {
     assert.strictEqual(written, Buffer.byteLength(expected));
     fs.closeSync(fd);
     const found = fs.readFileSync(fn2, 'utf8');
@@ -113,8 +108,7 @@ fs.open(fn2, args, 0o644, common.mustCall((err, fd) => {
     assert.strictEqual(found, expected);
   });
 
-  const written = common.mustCall((err, written) => {
-    assert.ifError(err);
+  const written = common.mustSucceed((written) => {
     assert.strictEqual(written, 0);
     fs.write(fd, expected, 0, 'utf8', done);
   });
@@ -122,11 +116,8 @@ fs.open(fn2, args, 0o644, common.mustCall((err, fd) => {
   fs.write(fd, '', 0, 'utf8', written);
 }));
 
-fs.open(fn3, 'w', 0o644, common.mustCall((err, fd) => {
-  assert.ifError(err);
-
-  const done = common.mustCall((err, written) => {
-    assert.ifError(err);
+fs.open(fn3, 'w', 0o644, common.mustSucceed((fd) => {
+  const done = common.mustSucceed((written) => {
     assert.strictEqual(written, Buffer.byteLength(expected));
     fs.closeSync(fd);
   });
@@ -134,6 +125,18 @@ fs.open(fn3, 'w', 0o644, common.mustCall((err, fd) => {
   fs.write(fd, expected, done);
 }));
 
+fs.open(fn4, 'w', 0o644, common.mustSucceed((fd) => {
+  const done = common.mustSucceed((written) => {
+    assert.strictEqual(written, Buffer.byteLength(expected));
+    fs.closeSync(fd);
+  });
+
+  const data = {
+    toString() { return expected; }
+  };
+  fs.write(fd, data, done);
+}));
+
 [false, 'test', {}, [], null, undefined].forEach((i) => {
   assert.throws(
     () => fs.write(i, common.mustNotCall()),
@@ -150,3 +153,20 @@ fs.open(fn3, 'w', 0o644, common.mustCall((err, fd) => {
     }
   );
 });
+
+[false, 5, {}, [], null, undefined].forEach((data) => {
+  assert.throws(
+    () => fs.write(1, data, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /"buffer"/
+    }
+  );
+  assert.throws(
+    () => fs.writeSync(1, data),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /"buffer"/
+    }
+  );
+});
diff --git a/test/parallel/test-fs-writefile-with-fd.js b/test/parallel/test-fs-writefile-with-fd.js
index 6851518d4dcc9a86cd426f7d7ced6a132e7a1c82..209a041c54a48ff12ae891f5a689641a34d5275a 100644
--- a/test/parallel/test-fs-writefile-with-fd.js
+++ b/test/parallel/test-fs-writefile-with-fd.js
@@ -1,10 +1,8 @@
 'use strict';
 
-/*
- * This test makes sure that `writeFile()` always writes from the current
- * position of the file, instead of truncating the file, when used with file
- * descriptors.
- */
+// This test makes sure that `writeFile()` always writes from the current
+// position of the file, instead of truncating the file, when used with file
+// descriptors.
 
 const common = require('../common');
 const assert = require('assert');
@@ -20,36 +18,46 @@ tmpdir.refresh();
 
   /* Open the file descriptor. */
   const fd = fs.openSync(filename, 'w');
+  try {
+    /* Write only five characters, so that the position moves to five. */
+    assert.deepStrictEqual(fs.writeSync(fd, 'Hello'), 5);
+    assert.deepStrictEqual(fs.readFileSync(filename).toString(), 'Hello');
 
-  /* Write only five characters, so that the position moves to five. */
-  assert.deepStrictEqual(fs.writeSync(fd, 'Hello'), 5);
-  assert.deepStrictEqual(fs.readFileSync(filename).toString(), 'Hello');
-
-  /* Write some more with writeFileSync(). */
-  fs.writeFileSync(fd, 'World');
+    /* Write some more with writeFileSync(). */
+    fs.writeFileSync(fd, 'World');
 
-  /* New content should be written at position five, instead of zero. */
-  assert.deepStrictEqual(fs.readFileSync(filename).toString(), 'HelloWorld');
+    /* New content should be written at position five, instead of zero. */
+    assert.deepStrictEqual(fs.readFileSync(filename).toString(), 'HelloWorld');
+  } finally {
+    fs.closeSync(fd);
+  }
 }
 
+const fdsToCloseOnExit = [];
+process.on('beforeExit', common.mustCall(() => {
+  for (const fd of fdsToCloseOnExit) {
+    try {
+      fs.closeSync(fd);
+    } catch {
+      // Failed to close, ignore
+    }
+  }
+}));
+
 {
   /* writeFile() test. */
   const file = join(tmpdir.path, 'test1.txt');
 
   /* Open the file descriptor. */
-  fs.open(file, 'w', common.mustCall((err, fd) => {
-    assert.ifError(err);
-
+  fs.open(file, 'w', common.mustSucceed((fd) => {
+    fdsToCloseOnExit.push(fd);
     /* Write only five characters, so that the position moves to five. */
-    fs.write(fd, 'Hello', common.mustCall((err, bytes) => {
-      assert.ifError(err);
+    fs.write(fd, 'Hello', common.mustSucceed((bytes) => {
       assert.strictEqual(bytes, 5);
       assert.deepStrictEqual(fs.readFileSync(file).toString(), 'Hello');
 
       /* Write some more with writeFile(). */
-      fs.writeFile(fd, 'World', common.mustCall((err) => {
-        assert.ifError(err);
-
+      fs.writeFile(fd, 'World', common.mustSucceed(() => {
         /* New content should be written at position five, instead of zero. */
         assert.deepStrictEqual(fs.readFileSync(file).toString(), 'HelloWorld');
       }));
diff --git a/test/parallel/test-fs-writev-promises.js b/test/parallel/test-fs-writev-promises.js
index ea349796cc61581f6ceee6da4667ef7f9387ab0b..02da6799699946be1597b69c3e366422b138190f 100644
--- a/test/parallel/test-fs-writev-promises.js
+++ b/test/parallel/test-fs-writev-promises.js
@@ -1,6 +1,5 @@
 'use strict';
-
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const path = require('path');
 const fs = require('fs').promises;
@@ -48,4 +47,4 @@ tmpdir.refresh();
     assert(Buffer.concat(bufferArr).equals(await fs.readFile(filename)));
     handle.close();
   }
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-fs-writev.js b/test/parallel/test-fs-writev.js
index 5a32bb7ac96081394087da5e0ecf8275e9c397cc..a516f9c328f1b2bf544a3966af0122eca3b05f5d 100644
--- a/test/parallel/test-fs-writev.js
+++ b/test/parallel/test-fs-writev.js
@@ -24,9 +24,7 @@ const getFileName = (i) => path.join(tmpdir.path, `writev_${i}.txt`);
   const buffer = Buffer.from(expected);
   const bufferArr = [buffer, buffer];
 
-  const done = common.mustCall((err, written, buffers) => {
-    assert.ifError(err);
-
+  const done = common.mustSucceed((written, buffers) => {
     assert.deepStrictEqual(bufferArr, buffers);
     const expectedLength = bufferArr.length * buffer.byteLength;
     assert.deepStrictEqual(written, expectedLength);
@@ -46,9 +44,7 @@ const getFileName = (i) => path.join(tmpdir.path, `writev_${i}.txt`);
   const buffer = Buffer.from(expected);
   const bufferArr = [buffer, buffer];
 
-  const done = common.mustCall((err, written, buffers) => {
-    assert.ifError(err);
-
+  const done = common.mustSucceed((written, buffers) => {
     assert.deepStrictEqual(bufferArr, buffers);
 
     const expectedLength = bufferArr.length * buffer.byteLength;
diff --git a/test/parallel/test-global.js b/test/parallel/test-global.js
index ff34a812c592dab117a0a407dfa8d1e554208dac..5ad2bb01173291a27997d4d78f91e4508f08660b 100644
--- a/test/parallel/test-global.js
+++ b/test/parallel/test-global.js
@@ -49,7 +49,7 @@ builtinModules.forEach((moduleName) => {
     'clearTimeout',
     'setImmediate',
     'setInterval',
-    'setTimeout'
+    'setTimeout',
   ];
   assert.deepStrictEqual(new Set(Object.keys(global)), new Set(expected));
 }
diff --git a/test/parallel/test-heapsnapshot-near-heap-limit-bounded.js b/test/parallel/test-heapsnapshot-near-heap-limit-bounded.js
new file mode 100644
index 0000000000000000000000000000000000000000..a57b9a8fc4b5e550627433f5e0a5399658f4d5ad
--- /dev/null
+++ b/test/parallel/test-heapsnapshot-near-heap-limit-bounded.js
@@ -0,0 +1,36 @@
+'use strict';
+
+require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const env = {
+  ...process.env,
+  TEST_ALLOCATION: 50000,
+  TEST_CHUNK: 1000,
+  TEST_CLEAN_INTERVAL: 500,
+  NODE_DEBUG_NATIVE: 'diagnostics'
+};
+
+{
+  console.log('\nTesting limit = 1');
+  tmpdir.refresh();
+  const child = spawnSync(process.execPath, [
+    '--trace-gc',
+    '--heapsnapshot-near-heap-limit=1',
+    '--max-old-space-size=50',
+    fixtures.path('workload', 'bounded.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  console.log(child.stdout.toString());
+  console.log(child.stderr.toString());
+  assert.strictEqual(child.signal, null);
+  assert.strictEqual(child.status, 0);
+  const list = fs.readdirSync(tmpdir.path)
+    .filter((file) => file.endsWith('.heapsnapshot'));
+  assert.strictEqual(list.length, 0);
+}
diff --git a/test/parallel/test-heapsnapshot-near-heap-limit-worker.js b/test/parallel/test-heapsnapshot-near-heap-limit-worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..46744cbd44d82c27c361ce77f191f84111f60385
--- /dev/null
+++ b/test/parallel/test-heapsnapshot-near-heap-limit-worker.js
@@ -0,0 +1,39 @@
+'use strict';
+
+require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const env = {
+  ...process.env,
+  NODE_DEBUG_NATIVE: 'diagnostics'
+};
+
+{
+  tmpdir.refresh();
+  const child = spawnSync(process.execPath, [
+    fixtures.path('workload', 'grow-worker.js'),
+  ], {
+    cwd: tmpdir.path,
+    env: {
+      TEST_SNAPSHOTS: 1,
+      TEST_OLD_SPACE_SIZE: 50,
+      ...env
+    }
+  });
+  console.log(child.stdout.toString());
+  const stderr = child.stderr.toString();
+  console.log(stderr);
+  const risky = /Not generating snapshots because it's too risky/.test(stderr);
+  if (!risky) {
+    // There should be one snapshot taken and then after the
+    // snapshot heap limit callback is popped, the OOM callback
+    // becomes effective.
+    assert(stderr.includes('ERR_WORKER_OUT_OF_MEMORY'));
+    const list = fs.readdirSync(tmpdir.path)
+      .filter((file) => file.endsWith('.heapsnapshot'));
+    assert.strictEqual(list.length, 1);
+  }
+}
diff --git a/test/parallel/test-heapsnapshot-near-heap-limit.js b/test/parallel/test-heapsnapshot-near-heap-limit.js
new file mode 100644
index 0000000000000000000000000000000000000000..5743f71a3f568c3286d0c8f1310d9717abde86e4
--- /dev/null
+++ b/test/parallel/test-heapsnapshot-near-heap-limit.js
@@ -0,0 +1,98 @@
+'use strict';
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const env = {
+  ...process.env,
+  NODE_DEBUG_NATIVE: 'diagnostics'
+};
+
+{
+  tmpdir.refresh();
+  const child = spawnSync(process.execPath, [
+    '--heapsnapshot-near-heap-limit=-15',
+    '--max-old-space-size=50',
+    fixtures.path('workload', 'grow.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  assert.strictEqual(child.status, 9);
+}
+
+{
+  console.log('\nTesting limit = 0');
+  tmpdir.refresh();
+  const child = spawnSync(process.execPath, [
+    '--trace-gc',
+    '--heapsnapshot-near-heap-limit=0',
+    '--max-old-space-size=50',
+    fixtures.path('workload', 'grow.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  console.log(child.stdout.toString());
+  console.log(child.stderr.toString());
+  assert(common.nodeProcessAborted(child.status, child.signal),
+         'process should have aborted, but did not');
+  const list = fs.readdirSync(tmpdir.path)
+    .filter((file) => file.endsWith('.heapsnapshot'));
+  assert.strictEqual(list.length, 0);
+}
+
+{
+  console.log('\nTesting limit = 1');
+  tmpdir.refresh();
+  const child = spawnSync(process.execPath, [
+    '--trace-gc',
+    '--heapsnapshot-near-heap-limit=1',
+    '--max-old-space-size=50',
+    fixtures.path('workload', 'grow.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  console.log(child.stdout.toString());
+  const stderr = child.stderr.toString();
+  console.log(stderr);
+  assert(common.nodeProcessAborted(child.status, child.signal),
+         'process should have aborted, but did not');
+  const list = fs.readdirSync(tmpdir.path)
+    .filter((file) => file.endsWith('.heapsnapshot'));
+  const risky = [...stderr.matchAll(
+    /Not generating snapshots because it's too risky/g)].length;
+  assert(list.length + risky > 0 && list.length <= 3,
+         `Generated ${list.length} snapshots ` +
+                     `and ${risky} was too risky`);
+}
+
+{
+  console.log('\nTesting limit = 3');
+  tmpdir.refresh();
+  const child = spawnSync(process.execPath, [
+    '--trace-gc',
+    '--heapsnapshot-near-heap-limit=3',
+    '--max-old-space-size=50',
+    fixtures.path('workload', 'grow.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  console.log(child.stdout.toString());
+  const stderr = child.stderr.toString();
+  console.log(stderr);
+  assert(common.nodeProcessAborted(child.status, child.signal),
+         'process should have aborted, but did not');
+  const list = fs.readdirSync(tmpdir.path)
+    .filter((file) => file.endsWith('.heapsnapshot'));
+  const risky = [...stderr.matchAll(
+    /Not generating snapshots because it's too risky/g)].length;
+  assert(list.length + risky > 0 && list.length <= 3,
+         `Generated ${list.length} snapshots ` +
+        `and ${risky} was too risky`);
+}
diff --git a/test/parallel/test-http-abort-client.js b/test/parallel/test-http-abort-client.js
index 80492b9d22734d555d3afdb2a45366a5e085a6fa..608d4dc76078533d417574109fcf856ccb822f62 100644
--- a/test/parallel/test-http-abort-client.js
+++ b/test/parallel/test-http-abort-client.js
@@ -39,7 +39,7 @@ server.listen(0, common.mustCall(() => {
     serverRes.destroy();
 
     res.resume();
-    res.on('end', common.mustCall());
+    res.on('end', common.mustNotCall());
     res.on('aborted', common.mustCall());
     res.on('close', common.mustCall());
     res.socket.on('close', common.mustCall());
diff --git a/test/parallel/test-http-agent-close.js b/test/parallel/test-http-agent-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..84ed5e57c5fb86d6719c6d6c1e0f2c00a7785dbe
--- /dev/null
+++ b/test/parallel/test-http-agent-close.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const agent = new http.Agent();
+const _err = new Error('kaboom');
+agent.createSocket = function(req, options, cb) {
+  cb(_err);
+};
+
+const req = http
+  .request({
+    agent
+  })
+  .on('error', common.mustCall((err) => {
+    assert.strictEqual(err, _err);
+  }))
+  .on('close', common.mustCall(() => {
+    assert.strictEqual(req.destroyed, true);
+  }));
diff --git a/test/parallel/test-http-agent-destroyed-socket.js b/test/parallel/test-http-agent-destroyed-socket.js
index 5b58ef0f52a50bfaac8321bd43996850ef9a6c57..47123ed6c364b24471ab81cc2c8d72453574b3a4 100644
--- a/test/parallel/test-http-agent-destroyed-socket.js
+++ b/test/parallel/test-http-agent-destroyed-socket.js
@@ -48,7 +48,7 @@ const server = http.createServer(common.mustCall((req, res) => {
     response.on('end', common.mustCall(() => {
       request1.socket.destroy();
 
-      response.socket.once('close', common.mustCall(() => {
+      request1.socket.once('close', common.mustCall(() => {
         // Assert request2 was removed from the queue
         assert(!agent.requests[key]);
         process.nextTick(() => {
diff --git a/test/parallel/test-http-agent-scheduling.js b/test/parallel/test-http-agent-scheduling.js
index bcf07863b0fb61c7c84b7a6855a1b50cf469d7c4..737f535a0f0a928d1a0c96b5e040fb7f8cf13183 100644
--- a/test/parallel/test-http-agent-scheduling.js
+++ b/test/parallel/test-http-agent-scheduling.js
@@ -56,11 +56,11 @@ function defaultTest() {
 
     bulkRequest(url, agent, (ports) => {
       makeRequest(url, agent, (port) => {
-        assert.strictEqual(ports[0], port);
+        assert.strictEqual(ports[ports.length - 1], port);
         makeRequest(url, agent, (port) => {
-          assert.strictEqual(ports[1], port);
+          assert.strictEqual(ports[ports.length - 1], port);
           makeRequest(url, agent, (port) => {
-            assert.strictEqual(ports[2], port);
+            assert.strictEqual(ports[ports.length - 1], port);
             server.close();
             agent.destroy();
           });
@@ -137,7 +137,8 @@ function badSchedulingOptionTest() {
     assert.strictEqual(err.code, 'ERR_INVALID_OPT_VALUE');
     assert.strictEqual(
       err.message,
-      'The value "filo" is invalid for option "scheduling"'
+      'The value "filo" is invalid for option "scheduling". ' +
+      "Must be one of: 'fifo', 'lifo'"
     );
   }
 }
diff --git a/test/parallel/test-http-agent-timeout.js b/test/parallel/test-http-agent-timeout.js
index d8d34414d991a1c52a6b9399f6d85401b9b4b418..07c189e974533057a2d0558b95fa8c0ba65877dc 100644
--- a/test/parallel/test-http-agent-timeout.js
+++ b/test/parallel/test-http-agent-timeout.js
@@ -92,3 +92,43 @@ const http = require('http');
       }));
   }));
 }
+
+{
+  // Ensure custom keepSocketAlive timeout is respected
+
+  const CUSTOM_TIMEOUT = 60;
+  const AGENT_TIMEOUT = 50;
+
+  class CustomAgent extends http.Agent {
+    keepSocketAlive(socket) {
+      if (!super.keepSocketAlive(socket)) {
+        return false;
+      }
+
+      socket.setTimeout(CUSTOM_TIMEOUT);
+      return true;
+    }
+  }
+
+  const agent = new CustomAgent({ keepAlive: true, timeout: AGENT_TIMEOUT });
+
+  const server = http.createServer((req, res) => {
+    res.end();
+  });
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port, agent })
+      .on('response', common.mustCall((res) => {
+        const socket = res.socket;
+        assert(socket);
+        res.resume();
+        socket.on('free', common.mustCall(() => {
+          socket.on('timeout', common.mustCall(() => {
+            assert.strictEqual(socket.timeout, CUSTOM_TIMEOUT);
+            agent.destroy();
+            server.close();
+          }));
+        }));
+      }));
+  }));
+}
diff --git a/test/parallel/test-http-allow-content-length-304.js b/test/parallel/test-http-allow-content-length-304.js
new file mode 100644
index 0000000000000000000000000000000000000000..172733e73570d15c620c285c9e24dfe967124177
--- /dev/null
+++ b/test/parallel/test-http-allow-content-length-304.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+
+// This test ensures that the http-parser doesn't expect a body when
+// a 304 Not Modified response has a non-zero Content-Length header
+
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.setHeader('Content-Length', 11);
+  res.statusCode = 304;
+  res.end(null);
+}));
+
+server.listen(0, () => {
+  const request = http.request({
+    port: server.address().port,
+  });
+
+  request.on('response', common.mustCall((response) => {
+    response.on('data', common.mustNotCall());
+    response.on('aborted', common.mustNotCall());
+    response.on('end', common.mustCall(() => {
+      assert.strictEqual(response.headers['content-length'], '11');
+      assert.strictEqual(response.statusCode, 304);
+      server.close();
+    }));
+  }));
+
+  request.end(null);
+});
diff --git a/test/parallel/test-http-client-abort-destroy.js b/test/parallel/test-http-client-abort-destroy.js
new file mode 100644
index 0000000000000000000000000000000000000000..f46d10d367106e7216a94a198354ff23af38fb54
--- /dev/null
+++ b/test/parallel/test-http-client-abort-destroy.js
@@ -0,0 +1,94 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+
+{
+  // abort
+
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.end('Hello');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const options = { port: server.address().port };
+    const req = http.get(options, common.mustCall((res) => {
+      res.on('data', (data) => {
+        req.abort();
+        assert.strictEqual(req.aborted, true);
+        assert.strictEqual(req.destroyed, true);
+        server.close();
+      });
+    }));
+    req.on('error', common.mustNotCall());
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, false);
+  }));
+}
+
+{
+  // destroy + res
+
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.end('Hello');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const options = { port: server.address().port };
+    const req = http.get(options, common.mustCall((res) => {
+      res.on('data', (data) => {
+        req.destroy();
+        assert.strictEqual(req.aborted, false);
+        assert.strictEqual(req.destroyed, true);
+        server.close();
+      });
+    }));
+    req.on('error', common.mustNotCall());
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, false);
+  }));
+}
+
+{
+  // destroy
+
+  const server = http.createServer(common.mustNotCall());
+
+  server.listen(0, common.mustCall(() => {
+    const options = { port: server.address().port };
+    const req = http.get(options, common.mustNotCall());
+    req.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ECONNRESET');
+      server.close();
+    }));
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, false);
+    req.destroy();
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, true);
+  }));
+}
+
+
+{
+  // Destroy with AbortSignal
+
+  const server = http.createServer(common.mustNotCall());
+  const controller = new AbortController();
+
+  server.listen(0, common.mustCall(() => {
+    const options = { port: server.address().port, signal: controller.signal };
+    const req = http.get(options, common.mustNotCall());
+    req.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ABORT_ERR');
+      assert.strictEqual(err.name, 'AbortError');
+      server.close();
+    }));
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, false);
+    controller.abort();
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, true);
+  }));
+}
diff --git a/test/parallel/test-http-client-abort-keep-alive-destroy-res.js b/test/parallel/test-http-client-abort-keep-alive-destroy-res.js
new file mode 100644
index 0000000000000000000000000000000000000000..238430a83d31fd96eb121e1eaa606e7f4f77611f
--- /dev/null
+++ b/test/parallel/test-http-client-abort-keep-alive-destroy-res.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+let socketsCreated = 0;
+
+class Agent extends http.Agent {
+  createConnection(options, oncreate) {
+    const socket = super.createConnection(options, oncreate);
+    socketsCreated++;
+    return socket;
+  }
+}
+
+const server = http.createServer((req, res) => res.end());
+
+server.listen(0, common.mustCall(() => {
+  const port = server.address().port;
+  const agent = new Agent({
+    keepAlive: true,
+    maxSockets: 1
+  });
+
+  const req = http.get({ agent, port }, common.mustCall((res) => {
+    res.resume();
+    res.on('end', () => {
+      res.destroy();
+
+      http.get({ agent, port }, common.mustCall((res) => {
+        res.resume();
+        assert.strictEqual(socketsCreated, 1);
+        agent.destroy();
+        server.close();
+      }));
+    });
+  }));
+  req.end();
+}));
diff --git a/test/parallel/test-http-client-abort-keep-alive-queued-tcp-socket.js b/test/parallel/test-http-client-abort-keep-alive-queued-tcp-socket.js
index 6282aa3da7caf2742522f4625b66f7aa4a71604f..c9614f01c3db3fdad14233514334846c3b330380 100644
--- a/test/parallel/test-http-client-abort-keep-alive-queued-tcp-socket.js
+++ b/test/parallel/test-http-client-abort-keep-alive-queued-tcp-socket.js
@@ -3,34 +3,45 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-let socketsCreated = 0;
 
-class Agent extends http.Agent {
-  createConnection(options, oncreate) {
-    const socket = super.createConnection(options, oncreate);
-    socketsCreated++;
-    return socket;
+for (const destroyer of ['destroy', 'abort']) {
+  let socketsCreated = 0;
+
+  class Agent extends http.Agent {
+    createConnection(options, oncreate) {
+      const socket = super.createConnection(options, oncreate);
+      socketsCreated++;
+      return socket;
+    }
   }
-}
 
-const server = http.createServer((req, res) => res.end());
+  const server = http.createServer((req, res) => res.end());
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const agent = new Agent({
-    keepAlive: true,
-    maxSockets: 1
-  });
+  server.listen(0, common.mustCall(() => {
+    const port = server.address().port;
+    const agent = new Agent({
+      keepAlive: true,
+      maxSockets: 1
+    });
 
-  http.get({ agent, port }, (res) => res.resume());
+    http.get({ agent, port }, (res) => res.resume());
 
-  const req = http.get({ agent, port }, common.mustNotCall());
-  req.abort();
+    const req = http.get({ agent, port }, common.mustNotCall());
+    req[destroyer]();
 
-  http.get({ agent, port }, common.mustCall((res) => {
-    res.resume();
-    assert.strictEqual(socketsCreated, 1);
-    agent.destroy();
-    server.close();
+    if (destroyer === 'destroy') {
+      req.on('error', common.mustCall((err) => {
+        assert.strictEqual(err.code, 'ECONNRESET');
+      }));
+    } else {
+      req.on('error', common.mustNotCall());
+    }
+
+    http.get({ agent, port }, common.mustCall((res) => {
+      res.resume();
+      assert.strictEqual(socketsCreated, 1);
+      agent.destroy();
+      server.close();
+    }));
   }));
-}));
+}
diff --git a/test/parallel/test-http-client-agent-abort-close-event.js b/test/parallel/test-http-client-agent-abort-close-event.js
new file mode 100644
index 0000000000000000000000000000000000000000..69a48da232c369b52fd685a745708e8a717b8d45
--- /dev/null
+++ b/test/parallel/test-http-client-agent-abort-close-event.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(common.mustNotCall());
+
+const keepAliveAgent = new http.Agent({ keepAlive: true });
+
+server.listen(0, common.mustCall(() => {
+  const req = http.get({
+    port: server.address().port,
+    agent: keepAliveAgent
+  });
+
+  req
+    .on('socket', common.mustNotCall())
+    .on('response', common.mustNotCall())
+    .on('close', common.mustCall(() => {
+      assert.strictEqual(req.destroyed, true);
+      server.close();
+      keepAliveAgent.destroy();
+    }))
+    .abort();
+}));
diff --git a/test/parallel/test-http-client-agent-end-close-event.js b/test/parallel/test-http-client-agent-end-close-event.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce202f4d2f283c2209d4897dff1e541bb23448e9
--- /dev/null
+++ b/test/parallel/test-http-client-agent-end-close-event.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(common.mustCall((req, res) => {
+  res.end('hello');
+}));
+
+const keepAliveAgent = new http.Agent({ keepAlive: true });
+
+server.listen(0, common.mustCall(() => {
+  const req = http.get({
+    port: server.address().port,
+    agent: keepAliveAgent
+  });
+
+  req
+    .on('response', common.mustCall((res) => {
+      res
+        .on('close', common.mustCall(() => {
+          assert.strictEqual(req.destroyed, true);
+          server.close();
+          keepAliveAgent.destroy();
+        }))
+        .on('data', common.mustCall());
+    }))
+    .end();
+}));
diff --git a/test/parallel/test-http-client-close-event.js b/test/parallel/test-http-client-close-event.js
index 7573931ac48ef69758705d578cc7a9b80af899f1..7097a247859f5e804ee36ade6556ee28abde8c92 100644
--- a/test/parallel/test-http-client-close-event.js
+++ b/test/parallel/test-http-client-close-event.js
@@ -14,14 +14,15 @@ server.listen(0, common.mustCall(() => {
   const req = http.get({ port: server.address().port }, common.mustNotCall());
   let errorEmitted = false;
 
-  req.on('error', (err) => {
+  req.on('error', common.mustCall((err) => {
     errorEmitted = true;
     assert.strictEqual(err.constructor, Error);
     assert.strictEqual(err.message, 'socket hang up');
     assert.strictEqual(err.code, 'ECONNRESET');
-  });
+  }));
 
   req.on('close', common.mustCall(() => {
+    assert.strictEqual(req.destroyed, true);
     assert.strictEqual(errorEmitted, true);
     server.close();
   }));
diff --git a/test/parallel/test-http-client-get-url.js b/test/parallel/test-http-client-get-url.js
index a72eea56538c4d56021b55382312b94072304822..3b091a72eda493f1b65ab5fbc4a91ca41b6520f7 100644
--- a/test/parallel/test-http-client-get-url.js
+++ b/test/parallel/test-http-client-get-url.js
@@ -24,7 +24,6 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 const url = require('url');
-const URL = url.URL;
 const testPath = '/foo?bar';
 
 const server = http.createServer(common.mustCall((req, res) => {
diff --git a/test/parallel/test-http-client-headers-array.js b/test/parallel/test-http-client-headers-array.js
index 31ee35a123ccb9a972409ed38703a5772ae8d18f..2665c3a97bcf77f96c78abc467ad12b88b21e108 100644
--- a/test/parallel/test-http-client-headers-array.js
+++ b/test/parallel/test-http-client-headers-array.js
@@ -44,11 +44,11 @@ execute({ headers: { 'x-foo': 'boom', 'cookie': 'a=1; b=2; c=3' } });
 execute({ headers: { 'x-foo': 'boom', 'cookie': [ 'a=1', 'b=2', 'c=3' ] } });
 execute({ headers: [[ 'x-foo', 'boom' ], [ 'cookie', 'a=1; b=2; c=3' ]] });
 execute({ headers: [
-  [ 'x-foo', 'boom' ], [ 'cookie', [ 'a=1', 'b=2', 'c=3' ]]
+  [ 'x-foo', 'boom' ], [ 'cookie', [ 'a=1', 'b=2', 'c=3' ]],
 ] });
 execute({ headers: [
   [ 'x-foo', 'boom' ], [ 'cookie', 'a=1' ],
-  [ 'cookie', 'b=2' ], [ 'cookie', 'c=3']
+  [ 'cookie', 'b=2' ], [ 'cookie', 'c=3'],
 ] });
 
 // Authorization and Host header both missing from the second
@@ -56,5 +56,5 @@ execute({ auth: 'foo:bar', headers:
   { 'x-foo': 'boom', 'cookie': 'a=1; b=2; c=3' } });
 execute({ auth: 'foo:bar', headers: [
   [ 'x-foo', 'boom' ], [ 'cookie', 'a=1' ],
-  [ 'cookie', 'b=2' ], [ 'cookie', 'c=3']
+  [ 'cookie', 'b=2' ], [ 'cookie', 'c=3'],
 ] });
diff --git a/test/parallel/test-http-client-headers-host-array.js b/test/parallel/test-http-client-headers-host-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..53b259514133025db44b47f4c2d1d0183e5df91c
--- /dev/null
+++ b/test/parallel/test-http-client-headers-host-array.js
@@ -0,0 +1,23 @@
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+const http = require('http');
+
+{
+
+  const options = {
+    port: '80',
+    path: '/',
+    headers: {
+      host: []
+    }
+  };
+
+  assert.throws(() => {
+    http.request(options);
+  }, {
+    code: /ERR_INVALID_ARG_TYPE/
+  }, 'http request should throw when passing array as header host');
+}
diff --git a/test/parallel/test-http-client-keep-alive-release-before-finish.js b/test/parallel/test-http-client-keep-alive-release-before-finish.js
index 0efedc91e2613dea52ca3cd385b62220f8a9808f..e6e0bac1bbac37ea1de4c9482631e30cfa0e22a4 100644
--- a/test/parallel/test-http-client-keep-alive-release-before-finish.js
+++ b/test/parallel/test-http-client-keep-alive-release-before-finish.js
@@ -20,10 +20,9 @@ const server = http.createServer((req, res) => {
     res.resume();
   }));
 
-  /* What happens here is that the server `end`s the response before we send
-   * `something`, and the client thought that this is a green light for sending
-   * next GET request
-   */
+  // What happens here is that the server `end`s the response before we send
+  // `something`, and the client thought that this is a green light for sending
+  // next GET request
   post.write(Buffer.alloc(16 * 1024, 'X'));
   setTimeout(() => {
     post.end('something');
diff --git a/test/parallel/test-http-client-override-global-agent.js b/test/parallel/test-http-client-override-global-agent.js
index f046abaa74e45dfae49000c708571f005ae9bcae..0efaded5e419b0059df62539231f332726dafc8d 100644
--- a/test/parallel/test-http-client-override-global-agent.js
+++ b/test/parallel/test-http-client-override-global-agent.js
@@ -21,6 +21,8 @@ function makeRequest() {
   const req = http.get({
     port: server.address().port
   });
-  req.on('close', () =>
-    server.close());
+  req.on('close', () => {
+    assert.strictEqual(req.destroyed, true);
+    server.close();
+  });
 }
diff --git a/test/parallel/test-http-client-parse-error.js b/test/parallel/test-http-client-parse-error.js
index 305a7bc170b69387becac35596c5c638eadcc9d4..2c18bdbede0139377e05b844702dbd163f521779 100644
--- a/test/parallel/test-http-client-parse-error.js
+++ b/test/parallel/test-http-client-parse-error.js
@@ -29,7 +29,7 @@ const countdown = new Countdown(2, () => server.close());
 
 const payloads = [
   'HTTP/1.1 302 Object Moved\r\nContent-Length: 0\r\n\r\nhi world',
-  'bad http = should trigger parse error'
+  'bad http = should trigger parse error',
 ];
 
 // Create a TCP server
diff --git a/test/parallel/test-http-client-read-in-error.js b/test/parallel/test-http-client-read-in-error.js
index 73b86b0d7edd625042ce6a6f11256d21522efdea..5e38e49c1f6fdefd489adf500834f806a026a1d6 100644
--- a/test/parallel/test-http-client-read-in-error.js
+++ b/test/parallel/test-http-client-read-in-error.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const net = require('net');
 const http = require('http');
 
@@ -37,4 +37,5 @@ http.request({
   agent
 }).once('error', function() {
   console.log('ignore');
+  this.on('data', common.mustNotCall());
 });
diff --git a/test/parallel/test-http-client-response-timeout.js b/test/parallel/test-http-client-response-timeout.js
new file mode 100644
index 0000000000000000000000000000000000000000..7e44d83a83114320bcf54d55c7237170cdb483cd
--- /dev/null
+++ b/test/parallel/test-http-client-response-timeout.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+
+const server = http.createServer((req, res) => res.flushHeaders());
+
+server.listen(common.mustCall(() => {
+  const req =
+    http.get({ port: server.address().port }, common.mustCall((res) => {
+      res.on('timeout', common.mustCall(() => req.destroy()));
+      res.setTimeout(1);
+      server.close();
+    }));
+}));
diff --git a/test/parallel/test-http-client-set-timeout.js b/test/parallel/test-http-client-set-timeout.js
index 51b6622a6b71ccc108d8060de8c02627a0c61da9..8cb83e3f1869d0fb5c3fc3202f3690d72711d981 100644
--- a/test/parallel/test-http-client-set-timeout.js
+++ b/test/parallel/test-http-client-set-timeout.js
@@ -38,6 +38,7 @@ server.listen(0, mustCall(() => {
   }));
 
   req.on('close', mustCall(() => {
+    strictEqual(req.destroyed, true);
     server.close();
   }));
 
diff --git a/test/parallel/test-http-client-spurious-aborted.js b/test/parallel/test-http-client-spurious-aborted.js
index 296b4bd256c929709e56f5b0b52961557eada06c..0cb2f471c2b7920811c8e095584f526ec67d1961 100644
--- a/test/parallel/test-http-client-spurious-aborted.js
+++ b/test/parallel/test-http-client-spurious-aborted.js
@@ -56,12 +56,18 @@ function download() {
       if (res.complete) res.readable = true;
       callback();
     };
-    res.on('end', common.mustCall(() => {
-      reqCountdown.dec();
-    }));
-    res.on('aborted', () => {
-      aborted = true;
-    });
+    if (!abortRequest) {
+      res.on('end', common.mustCall(() => {
+        reqCountdown.dec();
+      }));
+    } else {
+      res.on('aborted', common.mustCall(() => {
+        aborted = true;
+        reqCountdown.dec();
+        writable.end();
+      }));
+    }
+
     res.on('error', common.mustNotCall());
     writable.on('finish', () => {
       assert.strictEqual(aborted, abortRequest);
diff --git a/test/parallel/test-http-client-timeout-event.js b/test/parallel/test-http-client-timeout-event.js
index 71767bef8f1641adf9ae5b2d4983f9650b57b1d7..d5a63622bad03b6e2cb6fe167955d28bfe84e286 100644
--- a/test/parallel/test-http-client-timeout-event.js
+++ b/test/parallel/test-http-client-timeout-event.js
@@ -21,6 +21,7 @@
 
 'use strict';
 const common = require('../common');
+const assert = require('assert');
 const http = require('http');
 
 const options = {
@@ -38,7 +39,10 @@ server.listen(0, options.host, function() {
   req.on('error', function() {
     // This space is intentionally left blank
   });
-  req.on('close', common.mustCall(() => server.close()));
+  req.on('close', common.mustCall(() => {
+    assert.strictEqual(req.destroyed, true);
+    server.close();
+  }));
 
   req.setTimeout(1);
   req.on('timeout', common.mustCall(() => {
diff --git a/test/parallel/test-http-client-timeout-option-listeners.js b/test/parallel/test-http-client-timeout-option-listeners.js
index dac89b5fd1a2bb611b1b5c795fc4ff041fbffd97..1122eaf79e46f803ca2a738536487def20ba8cb3 100644
--- a/test/parallel/test-http-client-timeout-option-listeners.js
+++ b/test/parallel/test-http-client-timeout-option-listeners.js
@@ -24,9 +24,9 @@ const options = {
 server.listen(0, options.host, common.mustCall(() => {
   options.port = server.address().port;
   doRequest(common.mustCall((numListeners) => {
-    assert.strictEqual(numListeners, 2);
+    assert.strictEqual(numListeners, 3);
     doRequest(common.mustCall((numListeners) => {
-      assert.strictEqual(numListeners, 2);
+      assert.strictEqual(numListeners, 3);
       server.close();
       agent.destroy();
     }));
diff --git a/test/parallel/test-http-client-timeout-option.js b/test/parallel/test-http-client-timeout-option.js
index c21ec88e855208c01bbbc98bcc64e0f276ed7d5d..1003c28b5def56462b1b9a7326cbd3a5dbd2456d 100644
--- a/test/parallel/test-http-client-timeout-option.js
+++ b/test/parallel/test-http-client-timeout-option.js
@@ -23,7 +23,10 @@ server.listen(0, options.host, function() {
   req.on('error', function() {
     // This space is intentionally left blank
   });
-  req.on('close', common.mustCall(() => server.close()));
+  req.on('close', common.mustCall(() => {
+    assert.strictEqual(req.destroyed, true);
+    server.close();
+  }));
 
   let timeout_events = 0;
   req.on('timeout', common.mustCall(() => timeout_events += 1));
diff --git a/test/parallel/test-http-client-timeout.js b/test/parallel/test-http-client-timeout.js
index 90a3bebebc9e13b8f7dc077c39748765ca4d4b01..b83bd1ddf010fe5d320c5918ccd9b803318dd9bc 100644
--- a/test/parallel/test-http-client-timeout.js
+++ b/test/parallel/test-http-client-timeout.js
@@ -41,6 +41,7 @@ server.listen(0, options.host, function() {
     // This space intentionally left blank
   });
   req.on('close', function() {
+    assert.strictEqual(req.destroyed, true);
     server.close();
   });
   function destroy() {
diff --git a/test/parallel/test-http-connect.js b/test/parallel/test-http-connect.js
index 6483c93dd702049e7efdf2ff1aed552d60903236..be853de347e0cb2f0c1a33c4f0941b0e0fa7c42d 100644
--- a/test/parallel/test-http-connect.js
+++ b/test/parallel/test-http-connect.js
@@ -36,6 +36,7 @@ server.on('connect', common.mustCall((req, socket, firstBodyChunk) => {
   assert.strictEqual(socket.listenerCount('data'), 0);
   assert.strictEqual(socket.listenerCount('end'), 1);
   assert.strictEqual(socket.listenerCount('error'), 0);
+  assert.strictEqual(socket.listenerCount('timeout'), 0);
 
   socket.write('HTTP/1.1 200 Connection established\r\n\r\n');
 
@@ -53,7 +54,8 @@ server.listen(0, common.mustCall(() => {
   const req = http.request({
     port: server.address().port,
     method: 'CONNECT',
-    path: 'google.com:443'
+    path: 'google.com:443',
+    timeout: 20000
   }, common.mustNotCall());
 
   req.on('socket', common.mustCall((socket) => {
@@ -80,6 +82,7 @@ server.listen(0, common.mustCall(() => {
     assert.strictEqual(socket.listenerCount('close'), 0);
     assert.strictEqual(socket.listenerCount('error'), 0);
     assert.strictEqual(socket.listenerCount('agentRemove'), 0);
+    assert.strictEqual(socket.listenerCount('timeout'), 0);
 
     let data = firstBodyChunk.toString();
     socket.on('data', (buf) => {
diff --git a/test/parallel/test-http-createConnection.js b/test/parallel/test-http-createConnection.js
index a65b9a158c679dd7049192829cfd2626f0b961a3..1425b964a75aa3d620295948c9f77202f7e52680 100644
--- a/test/parallel/test-http-createConnection.js
+++ b/test/parallel/test-http-createConnection.js
@@ -25,32 +25,36 @@ const http = require('http');
 const net = require('net');
 const assert = require('assert');
 
+function commonHttpGet(fn) {
+  if (typeof fn === 'function') {
+    fn = common.mustCall(fn);
+  }
+  return new Promise((resolve, reject) => {
+    http.get({ createConnection: fn }, (res) => {
+      resolve(res);
+    }).on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
 const server = http.createServer(common.mustCall(function(req, res) {
   res.end();
-}, 4)).listen(0, '127.0.0.1', function() {
-  let fn = common.mustCall(createConnection);
-  http.get({ createConnection: fn }, function(res) {
-    res.resume();
-    fn = common.mustCall(createConnectionAsync);
-    http.get({ createConnection: fn }, function(res) {
-      res.resume();
-      fn = common.mustCall(createConnectionBoth1);
-      http.get({ createConnection: fn }, function(res) {
-        res.resume();
-        fn = common.mustCall(createConnectionBoth2);
-        http.get({ createConnection: fn }, function(res) {
-          res.resume();
-          fn = common.mustCall(createConnectionError);
-          http.get({ createConnection: fn }, function(res) {
-            assert.fail('Unexpected response callback');
-          }).on('error', common.mustCall(function(err) {
-            assert.strictEqual(err.message, 'Could not create socket');
-            server.close();
-          }));
-        });
-      });
-    });
+}, 4)).listen(0, '127.0.0.1', async () => {
+  await commonHttpGet(createConnection);
+  await commonHttpGet(createConnectionAsync);
+  await commonHttpGet(createConnectionBoth1);
+  await commonHttpGet(createConnectionBoth2);
+
+  // Errors
+  await assert.rejects(() => commonHttpGet(createConnectionError), {
+    message: 'sync'
+  });
+  await assert.rejects(() => commonHttpGet(createConnectionAsyncError), {
+    message: 'async'
   });
+
+  server.close();
 });
 
 function createConnection() {
@@ -78,5 +82,9 @@ function createConnectionBoth2(options, cb) {
 }
 
 function createConnectionError(options, cb) {
-  process.nextTick(cb, new Error('Could not create socket'));
+  throw new Error('sync');
+}
+
+function createConnectionAsyncError(options, cb) {
+  process.nextTick(cb, new Error('async'));
 }
diff --git a/test/parallel/test-http-debug.js b/test/parallel/test-http-debug.js
index 4b1c093c66397436a5590cdf5acc48cc23a940e4..3907412203d3b00de5ad2fbccb112c465ee213d1 100644
--- a/test/parallel/test-http-debug.js
+++ b/test/parallel/test-http-debug.js
@@ -7,7 +7,7 @@ const path = require('path');
 
 process.env.NODE_DEBUG = 'http';
 const { stderr } = child_process.spawnSync(process.execPath, [
-  path.resolve(__dirname, 'test-http-conn-reset.js')
+  path.resolve(__dirname, 'test-http-conn-reset.js'),
 ], { encoding: 'utf8' });
 
 assert(stderr.match(/Setting the NODE_DEBUG environment variable to 'http' can expose sensitive data \(such as passwords, tokens and authentication headers\) in the resulting log\./),
diff --git a/test/parallel/test-http-decoded-auth.js b/test/parallel/test-http-decoded-auth.js
new file mode 100644
index 0000000000000000000000000000000000000000..7b09f47cc7267cbfaa4c2898e81800a6aad7fb67
--- /dev/null
+++ b/test/parallel/test-http-decoded-auth.js
@@ -0,0 +1,48 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const testCases = [
+  {
+    username: 'test@test"',
+    password: '123456^',
+    expected: 'dGVzdEB0ZXN0IjoxMjM0NTZe'
+  },
+  {
+    username: 'test%40test',
+    password: '123456',
+    expected: 'dGVzdEB0ZXN0OjEyMzQ1Ng=='
+  },
+  {
+    username: 'not%3Agood',
+    password: 'god',
+    expected: 'bm90Omdvb2Q6Z29k'
+  },
+  {
+    username: 'not%22good',
+    password: 'g%5Eod',
+    expected: 'bm90Imdvb2Q6Z15vZA=='
+  },
+  {
+    username: 'test1234::::',
+    password: 'mypass',
+    expected: 'dGVzdDEyMzQ6Ojo6Om15cGFzcw=='
+  },
+];
+
+for (const testCase of testCases) {
+  const server = http.createServer(function(request, response) {
+    // The correct authorization header is be passed
+    assert.strictEqual(request.headers.authorization, `Basic ${testCase.expected}`);
+    response.writeHead(200, {});
+    response.end('ok');
+    server.close();
+  });
+
+  server.listen(0, function() {
+    // make the request
+    const url = new URL(`http://${testCase.username}:${testCase.password}@localhost:${this.address().port}`);
+    http.request(url).end();
+  });
+}
diff --git a/test/parallel/test-http-default-port.js b/test/parallel/test-http-default-port.js
index a5af439a8ec6c366e71cabc2d6040508f0a6b888..2005487502fe4fde2e9e641d4dbdaeed42796057 100644
--- a/test/parallel/test-http-default-port.js
+++ b/test/parallel/test-http-default-port.js
@@ -37,7 +37,7 @@ const options = {
 
 for (const { mod, createServer } of [
   { mod: http, createServer: http.createServer },
-  { mod: https, createServer: https.createServer.bind(null, options) }
+  { mod: https, createServer: https.createServer.bind(null, options) },
 ]) {
   const server = createServer(common.mustCall((req, res) => {
     assert.strictEqual(req.headers.host, hostExpect);
diff --git a/test/parallel/test-http-destroyed-socket-write2.js b/test/parallel/test-http-destroyed-socket-write2.js
index 49594bde6daf1d2271de9effca9d49aff6aa97b6..8511c43dddf155a7460402589cf871b829b60a0f 100644
--- a/test/parallel/test-http-destroyed-socket-write2.js
+++ b/test/parallel/test-http-destroyed-socket-write2.js
@@ -21,16 +21,20 @@
 
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 
 // Verify that ECONNRESET is raised when writing to a http request
 // where the server has ended the socket.
 
+const assert = require('assert');
 const http = require('http');
+
+const kResponseDestroyed = Symbol('kResponseDestroyed');
+
 const server = http.createServer(function(req, res) {
-  setImmediate(function() {
+  req.on('data', common.mustCall(function() {
     res.destroy();
-  });
+    server.emit(kResponseDestroyed);
+  }));
 });
 
 server.listen(0, function() {
@@ -40,11 +44,9 @@ server.listen(0, function() {
     method: 'POST'
   });
 
-  function write() {
-    req.write('hello', function() {
-      setImmediate(write);
-    });
-  }
+  server.once(kResponseDestroyed, common.mustCall(function() {
+    req.write('hello');
+  }));
 
   req.on('error', common.mustCall(function(er) {
     assert.strictEqual(req.res, null);
@@ -73,6 +75,5 @@ server.listen(0, function() {
   }));
 
   req.on('response', common.mustNotCall());
-
-  write();
+  req.write('hello', common.mustSucceed());
 });
diff --git a/test/parallel/test-http-header-overflow.js b/test/parallel/test-http-header-overflow.js
index 2dd1f9cb9a9875a09c3a3f592c8bea758b10ef2c..e53f5f05f81c31a50289bf95dfec9ddbe0065010 100644
--- a/test/parallel/test-http-header-overflow.js
+++ b/test/parallel/test-http-header-overflow.js
@@ -1,9 +1,13 @@
+// Flags: --expose-internals
+
 'use strict';
 const { expectsError, mustCall } = require('../common');
 const assert = require('assert');
 const { createServer, maxHeaderSize } = require('http');
 const { createConnection } = require('net');
 
+const { getOptionValue } = require('internal/options');
+
 const CRLF = '\r\n';
 const DUMMY_HEADER_NAME = 'Cookie: ';
 const DUMMY_HEADER_VALUE = 'a'.repeat(
@@ -17,11 +21,14 @@ const PAYLOAD = PAYLOAD_GET + CRLF +
 const server = createServer();
 
 server.on('connection', mustCall((socket) => {
+  // Legacy parser gives sligthly different response.
+  // This discripancy is not fixed on purpose.
+  const legacy = getOptionValue('--http-parser') === 'legacy';
   socket.on('error', expectsError({
     name: 'Error',
     message: 'Parse Error: Header overflow',
     code: 'HPE_HEADER_OVERFLOW',
-    bytesParsed: maxHeaderSize + PAYLOAD_GET.length,
+    bytesParsed: maxHeaderSize + PAYLOAD_GET.length - (legacy ? -1 : 0),
     rawPacket: Buffer.from(PAYLOAD)
   }));
 }));
diff --git a/test/parallel/test-http-header-validators.js b/test/parallel/test-http-header-validators.js
new file mode 100644
index 0000000000000000000000000000000000000000..89cf974da0224776e3598032477cd7b7134ae1df
--- /dev/null
+++ b/test/parallel/test-http-header-validators.js
@@ -0,0 +1,62 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { validateHeaderName, validateHeaderValue } = require('http');
+
+// Expected static methods
+isFunc(validateHeaderName, 'validateHeaderName');
+isFunc(validateHeaderValue, 'validateHeaderValue');
+
+// Expected to be useful as static methods
+console.log('validateHeaderName');
+// - when used with valid header names - should not throw
+[
+  'user-agent',
+  'USER-AGENT',
+  'User-Agent',
+  'x-forwarded-for',
+].forEach((name) => {
+  console.log('does not throw for "%s"', name);
+  validateHeaderName(name);
+});
+
+// - when used with invalid header names:
+[
+  'איקס-פורוורד-פור',
+  'x-forwarded-fםr',
+].forEach((name) => {
+  console.log('throws for: "%s"', name.slice(0, 50));
+  assert.throws(
+    () => validateHeaderName(name),
+    { code: 'ERR_INVALID_HTTP_TOKEN' }
+  );
+});
+
+console.log('validateHeaderValue');
+// - when used with valid header values - should not throw
+[
+  ['x-valid', 1],
+  ['x-valid', '1'],
+  ['x-valid', 'string'],
+].forEach(([name, value]) => {
+  console.log('does not throw for "%s"', name);
+  validateHeaderValue(name, value);
+});
+
+// - when used with invalid header values:
+[
+  // [header, value, expectedCode]
+  ['x-undefined', undefined, 'ERR_HTTP_INVALID_HEADER_VALUE'],
+  ['x-bad-char', 'לא תקין', 'ERR_INVALID_CHAR'],
+].forEach(([name, value, code]) => {
+  console.log('throws %s for: "%s: %s"', code, name, value);
+  assert.throws(
+    () => validateHeaderValue(name, value),
+    { code }
+  );
+});
+
+// Misc.
+function isFunc(v, ttl) {
+  assert.ok(v.constructor === Function, `${ttl} is expected to be a function`);
+}
diff --git a/test/parallel/test-http-host-header-ipv6-fail.js b/test/parallel/test-http-host-header-ipv6-fail.js
index 0c56afad7f28e54b72176f61a9f9b3695f8fd9a0..e84e9ab05b2196ae83ef0cc0c41134fb5a7d258f 100644
--- a/test/parallel/test-http-host-header-ipv6-fail.js
+++ b/test/parallel/test-http-host-header-ipv6-fail.js
@@ -1,13 +1,12 @@
 'use strict';
-/*
- * When using the object form of http.request and using an IPv6 address
- * as a hostname, and using a non-standard port, the Host header
- * is improperly formatted.
- * Issue: https://github.com/nodejs/node/issues/5308
- * As per https://tools.ietf.org/html/rfc7230#section-5.4 and
- * https://tools.ietf.org/html/rfc3986#section-3.2.2
- * the IPv6 address should be enclosed in square brackets
- */
+
+// When using the object form of http.request and using an IPv6 address
+// as a hostname, and using a non-standard port, the Host header
+// is improperly formatted.
+// Issue: https://github.com/nodejs/node/issues/5308
+// As per https://tools.ietf.org/html/rfc7230#section-5.4 and
+// https://tools.ietf.org/html/rfc3986#section-3.2.2
+// the IPv6 address should be enclosed in square brackets
 
 const common = require('../common');
 const assert = require('assert');
@@ -16,7 +15,7 @@ const net = require('net');
 
 const requests = [
   { host: 'foo:1234', headers: { expectedhost: 'foo:1234:80' } },
-  { host: '::1', headers: { expectedhost: '[::1]:80' } }
+  { host: '::1', headers: { expectedhost: '[::1]:80' } },
 ];
 
 function createLocalConnection(options) {
diff --git a/test/parallel/test-http-incoming-message-connection-setter.js b/test/parallel/test-http-incoming-message-connection-setter.js
new file mode 100644
index 0000000000000000000000000000000000000000..82093e1a7939f05b1c1f34619bc2dd96149caf20
--- /dev/null
+++ b/test/parallel/test-http-incoming-message-connection-setter.js
@@ -0,0 +1,18 @@
+'use strict';
+
+// Test that the setter for http.IncomingMessage,prototype.connection sets the
+// socket property too.
+require('../common');
+
+const assert = require('assert');
+const http = require('http');
+
+const incomingMessage = new http.IncomingMessage();
+
+assert.strictEqual(incomingMessage.connection, undefined);
+assert.strictEqual(incomingMessage.socket, undefined);
+
+incomingMessage.connection = 'fhqwhgads';
+
+assert.strictEqual(incomingMessage.connection, 'fhqwhgads');
+assert.strictEqual(incomingMessage.socket, 'fhqwhgads');
diff --git a/test/parallel/test-http-information-headers.js b/test/parallel/test-http-information-headers.js
index f5cfa5078b85ac275c78998a03da4b58ff47610a..fc860b321f03e9a2c38b6834853b16dd537838c3 100644
--- a/test/parallel/test-http-information-headers.js
+++ b/test/parallel/test-http-information-headers.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 const Countdown = require('../common/countdown');
@@ -13,7 +13,7 @@ const server = http.createServer((req, res) => {
   // to call res.writeHead instead
   res._writeRaw('HTTP/1.1 102 Processing\r\n');
   res._writeRaw('Foo: Bar\r\n');
-  res._writeRaw('\r\n');
+  res._writeRaw('\r\n', common.mustCall());
   console.error('Server sending full response...');
   res.writeHead(200, {
     'Content-Type': 'text/plain',
diff --git a/test/parallel/test-http-insecure-parser-legacy.js b/test/parallel/test-http-insecure-parser-legacy.js
deleted file mode 100644
index a337333ed0915ff4ea4d7a4f8d882d8fa054fec3..0000000000000000000000000000000000000000
--- a/test/parallel/test-http-insecure-parser-legacy.js
+++ /dev/null
@@ -1,35 +0,0 @@
-// Flags: --insecure-http-parser --http-parser=legacy
-
-'use strict';
-const common = require('../common');
-const assert = require('assert');
-const http = require('http');
-const net = require('net');
-
-const server = http.createServer(function(req, res) {
-  assert.strictEqual(req.headers['content-type'], 'text/te\bt');
-  req.pipe(res);
-});
-
-server.listen(0, common.mustCall(function() {
-  const bufs = [];
-  const client = net.connect(
-    this.address().port,
-    function() {
-      client.write(
-        'GET / HTTP/1.1\r\n' +
-        'Content-Type: text/te\x08t\r\n' +
-        'Connection: close\r\n\r\n');
-    }
-  );
-  client.on('data', function(chunk) {
-    bufs.push(chunk);
-  });
-  client.on('end', common.mustCall(function() {
-    const head = Buffer.concat(bufs)
-      .toString('latin1')
-      .split('\r\n')[0];
-    assert.strictEqual(head, 'HTTP/1.1 200 OK');
-    server.close();
-  }));
-}));
diff --git a/test/parallel/test-http-insecure-parser-per-stream.js b/test/parallel/test-http-insecure-parser-per-stream.js
index d2b8ffe708770c6265cea138e1bff94e4cd3ec8e..2ba245c8f419b1a8281e70fe695f6797cbc91d4d 100644
--- a/test/parallel/test-http-insecure-parser-per-stream.js
+++ b/test/parallel/test-http-insecure-parser-per-stream.js
@@ -80,3 +80,15 @@ const MakeDuplexPair = require('../common/duplexpair');
                    'Hello: foo\x08foo\r\n' +
                    '\r\n\r\n');
 }
+
+// Test 5: Invalid argument type
+{
+  assert.throws(
+    () => http.request({ insecureHTTPParser: 0 }, common.mustNotCall()),
+    common.expectsError({
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: 'The "options.insecureHTTPParser" property must be of' +
+      ' type boolean. Received type number (0)'
+    })
+  );
+}
diff --git a/test/parallel/test-http-invalid-te-legacy.js b/test/parallel/test-http-invalid-te-legacy.js
deleted file mode 100644
index cbb3c00fc42d3ebb48b3c0a100af18f6abd26855..0000000000000000000000000000000000000000
--- a/test/parallel/test-http-invalid-te-legacy.js
+++ /dev/null
@@ -1,10 +0,0 @@
-// Flags: --http-parser=legacy
-
-'use strict';
-
-// Test https://hackerone.com/reports/735748 is fixed.
-// Test should pass with legacy parser, not just the default.
-
-require('../common');
-
-require('./test-http-invalid-te-legacy.js');
diff --git a/test/parallel/test-http-invalidheaderfield2.js b/test/parallel/test-http-invalidheaderfield2.js
index 40415d9c368891c6d889fd462f5565d90e0ab6e6..1b4e9e6edb01f38cce3c8ef75cfc9d110e3b26c9 100644
--- a/test/parallel/test-http-invalidheaderfield2.js
+++ b/test/parallel/test-http-invalidheaderfield2.js
@@ -25,7 +25,7 @@ const { _checkIsHttpToken, _checkInvalidHeaderChar } = require('_http_common');
   'It\'s_fun',
   '2*3',
   '4+2',
-  '3.14159265359'
+  '3.14159265359',
 ].forEach(function(str) {
   assert.strictEqual(
     _checkIsHttpToken(str), true,
@@ -51,7 +51,7 @@ const { _checkIsHttpToken, _checkInvalidHeaderChar } = require('_http_common');
   'End)',
   'End]',
   '"Quote"',
-  'This,That'
+  'This,That',
 ].forEach(function(str) {
   assert.strictEqual(
     _checkIsHttpToken(str), false,
@@ -64,7 +64,7 @@ const { _checkIsHttpToken, _checkInvalidHeaderChar } = require('_http_common');
   'foo bar',
   'foo\tbar',
   '0123456789ABCdef',
-  '!@#$%^&*()-_=+\\;\':"[]{}<>,./?|~`'
+  '!@#$%^&*()-_=+\\;\':"[]{}<>,./?|~`',
 ].forEach(function(str) {
   assert.strictEqual(
     _checkInvalidHeaderChar(str), false,
@@ -80,7 +80,7 @@ const { _checkIsHttpToken, _checkInvalidHeaderChar } = require('_http_common');
   '\x7FMe!',
   'Testing 123\x00',
   'foo\vbar',
-  'Ding!\x07'
+  'Ding!\x07',
 ].forEach(function(str) {
   assert.strictEqual(
     _checkInvalidHeaderChar(str), true,
diff --git a/test/parallel/test-http-keepalive-free.js b/test/parallel/test-http-keepalive-free.js
new file mode 100644
index 0000000000000000000000000000000000000000..0252c284962b390eec5c1dafc95c79e684ab87ee
--- /dev/null
+++ b/test/parallel/test-http-keepalive-free.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+const http = require('http');
+
+for (const method of ['abort', 'destroy']) {
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.end(req.url);
+  }));
+  server.listen(0, common.mustCall(() => {
+    const agent = http.Agent({ keepAlive: true });
+
+    const req = http
+      .request({
+        port: server.address().port,
+        agent
+      })
+      .on('socket', common.mustCall((socket) => {
+        socket.on('free', common.mustCall());
+      }))
+      .on('response', common.mustCall((res) => {
+        assert.strictEqual(req.destroyed, false);
+        res.on('end', () => {
+          assert.strictEqual(req.destroyed, true);
+          req[method]();
+          assert.strictEqual(req.socket.destroyed, false);
+          agent.destroy();
+          server.close();
+        }).resume();
+      }))
+      .end();
+    assert.strictEqual(req.destroyed, false);
+  }));
+}
diff --git a/test/parallel/test-http-max-header-size-per-stream.js b/test/parallel/test-http-max-header-size-per-stream.js
new file mode 100644
index 0000000000000000000000000000000000000000..5edb8d3a954cefb41e065fdd359bcd54520722b8
--- /dev/null
+++ b/test/parallel/test-http-max-header-size-per-stream.js
@@ -0,0 +1,82 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+const MakeDuplexPair = require('../common/duplexpair');
+
+// Test that setting the `maxHeaderSize` option works on a per-stream-basis.
+
+// Test 1: The server sends larger headers than what would otherwise be allowed.
+{
+  const { clientSide, serverSide } = MakeDuplexPair();
+
+  const req = http.request({
+    createConnection: common.mustCall(() => clientSide),
+    maxHeaderSize: http.maxHeaderSize * 4
+  }, common.mustCall((res) => {
+    assert.strictEqual(res.headers.hello, 'A'.repeat(http.maxHeaderSize * 3));
+    res.resume();  // We don’t actually care about contents.
+    res.on('end', common.mustCall());
+  }));
+  req.end();
+
+  serverSide.resume();  // Dump the request
+  serverSide.end('HTTP/1.1 200 OK\r\n' +
+                 'Hello: ' + 'A'.repeat(http.maxHeaderSize * 3) + '\r\n' +
+                 'Content-Length: 0\r\n' +
+                 '\r\n\r\n');
+}
+
+// Test 2: The same as Test 1 except without the option, to make sure it fails.
+{
+  const { clientSide, serverSide } = MakeDuplexPair();
+
+  const req = http.request({
+    createConnection: common.mustCall(() => clientSide)
+  }, common.mustNotCall());
+  req.end();
+  req.on('error', common.mustCall());
+
+  serverSide.resume();  // Dump the request
+  serverSide.end('HTTP/1.1 200 OK\r\n' +
+                 'Hello: ' + 'A'.repeat(http.maxHeaderSize * 3) + '\r\n' +
+                 'Content-Length: 0\r\n' +
+                 '\r\n\r\n');
+}
+
+// Test 3: The client sends larger headers than what would otherwise be allowed.
+{
+  const testData = 'Hello, World!\n';
+  const server = http.createServer(
+    { maxHeaderSize: http.maxHeaderSize * 4 },
+    common.mustCall((req, res) => {
+      res.statusCode = 200;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end(testData);
+    }));
+
+  server.on('clientError', common.mustNotCall());
+
+  const { clientSide, serverSide } = MakeDuplexPair();
+  serverSide.server = server;
+  server.emit('connection', serverSide);
+
+  clientSide.write('GET / HTTP/1.1\r\n' +
+                   'Hello: ' + 'A'.repeat(http.maxHeaderSize * 3) + '\r\n' +
+                   '\r\n\r\n');
+}
+
+// Test 4: The same as Test 3 except without the option, to make sure it fails.
+{
+  const server = http.createServer(common.mustNotCall());
+
+  server.on('clientError', common.mustCall());
+
+  const { clientSide, serverSide } = MakeDuplexPair();
+  serverSide.server = server;
+  server.emit('connection', serverSide);
+
+  clientSide.write('GET / HTTP/1.1\r\n' +
+                   'Hello: ' + 'A'.repeat(http.maxHeaderSize * 3) + '\r\n' +
+                   '\r\n\r\n');
+}
diff --git a/test/parallel/test-http-max-header-size.js b/test/parallel/test-http-max-header-size.js
index 07fbe902963525a3ef678c291f4e00c300ee87ef..53bd58c4f179b6404fbb93416c3e4234b7ae6303 100644
--- a/test/parallel/test-http-max-header-size.js
+++ b/test/parallel/test-http-max-header-size.js
@@ -5,7 +5,7 @@ const assert = require('assert');
 const { spawnSync } = require('child_process');
 const http = require('http');
 
-assert.strictEqual(http.maxHeaderSize, 8 * 1024);
+assert.strictEqual(http.maxHeaderSize, 16 * 1024);
 const child = spawnSync(process.execPath, ['--max-http-header-size=10', '-p',
                                            'http.maxHeaderSize']);
 assert.strictEqual(+child.stdout.toString().trim(), 10);
diff --git a/test/parallel/test-http-max-headers-count.js b/test/parallel/test-http-max-headers-count.js
index 9fcfe316e392ff50cf38edd5bce1d4f31e0d842c..b707c62bfba8c7c4118852294e86855870dda041 100644
--- a/test/parallel/test-http-max-headers-count.js
+++ b/test/parallel/test-http-max-headers-count.js
@@ -36,7 +36,7 @@ for (let i = 0; i < N; ++i) {
 const maxAndExpected = [ // for server
   [50, 50],
   [1500, 102],
-  [0, N + 2] // Host and Connection
+  [0, N + 2], // Host and Connection
 ];
 let max = maxAndExpected[requests][0];
 let expected = maxAndExpected[requests][1];
@@ -57,7 +57,7 @@ server.listen(0, function() {
   const maxAndExpected = [ // for client
     [20, 20],
     [1200, 103],
-    [0, N + 3] // Connection, Date and Transfer-Encoding
+    [0, N + 3], // Connection, Date and Transfer-Encoding
   ];
   doRequest();
 
diff --git a/test/sequential/test-http-max-http-headers.js b/test/parallel/test-http-max-http-headers.js
similarity index 88%
rename from test/sequential/test-http-max-http-headers.js
rename to test/parallel/test-http-max-http-headers.js
index c8bfd07f9ffd8ca57b32a94da1da3f0fc8a715d8..67ecc8c4654b40028cc1977fe40c8888c760cd05 100644
--- a/test/sequential/test-http-max-http-headers.js
+++ b/test/parallel/test-http-max-http-headers.js
@@ -4,15 +4,14 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 const net = require('net');
-const MAX = +(process.argv[2] || 8 * 1024); // Command line option, or 8KB.
+const MAX = +(process.argv[2] || 16 * 1024); // Command line option, or 16KB.
 
 const { getOptionValue } = require('internal/options');
 
 console.log('pid is', process.pid);
 console.log('max header size is', getOptionValue('--max-http-header-size'));
-console.log('current http parser is', getOptionValue('--http-parser'));
 
-// Verify that we cannot receive more than 8KB of headers.
+// Verify that we cannot receive more than 16KB of headers.
 
 function once(cb) {
   let called = false;
@@ -33,17 +32,12 @@ function finished(client, callback) {
 function fillHeaders(headers, currentSize, valid = false) {
   // `llhttp` counts actual header name/value sizes, excluding the whitespace
   // and stripped chars.
-  if (getOptionValue('--http-parser') === 'llhttp') {
-    // OK, Content-Length, 0, X-CRASH, aaa...
-    headers += 'a'.repeat(MAX - currentSize);
-  } else {
-    headers += 'a'.repeat(MAX - headers.length - 3);
-  }
+  // OK, Content-Length, 0, X-CRASH, aaa...
+  headers += 'a'.repeat(MAX - currentSize);
 
   // Generate valid headers
   if (valid) {
-    // TODO(mcollina): understand why -32 is needed instead of -1
-    headers = headers.slice(0, -32);
+    headers = headers.slice(0, -1);
   }
   return headers + '\r\n\r\n';
 }
diff --git a/test/parallel/test-http-mutable-headers.js b/test/parallel/test-http-mutable-headers.js
index c9f63acf4433f48f4e05cb3d702ed79d4a416955..2210750e6c359b0decea0277a6ca46b78e092e01 100644
--- a/test/parallel/test-http-mutable-headers.js
+++ b/test/parallel/test-http-mutable-headers.js
@@ -36,7 +36,7 @@ let test = 'headers';
 const content = 'hello world\n';
 const cookies = [
   'session_token=; path=/; expires=Sun, 15-Sep-2030 13:48:52 GMT',
-  'prefers_open_id=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT'
+  'prefers_open_id=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT',
 ];
 
 const s = http.createServer(common.mustCall((req, res) => {
@@ -47,6 +47,7 @@ const s = http.createServer(common.mustCall((req, res) => {
       const exoticObj = Object.create(null);
       assert.deepStrictEqual(headers, exoticObj);
       assert.deepStrictEqual(res.getHeaderNames(), []);
+      assert.deepStrictEqual(res.getRawHeaderNames(), []);
       assert.deepStrictEqual(res.hasHeader('Connection'), false);
       assert.deepStrictEqual(res.getHeader('Connection'), undefined);
 
@@ -108,6 +109,10 @@ const s = http.createServer(common.mustCall((req, res) => {
                              ['x-test-header', 'x-test-header2',
                               'set-cookie', 'x-test-array-header']);
 
+      assert.deepStrictEqual(res.getRawHeaderNames(),
+                             ['x-test-header', 'X-TEST-HEADER2',
+                              'set-cookie', 'x-test-array-header']);
+
       assert.strictEqual(res.hasHeader('x-test-header2'), true);
       assert.strictEqual(res.hasHeader('X-TEST-HEADER2'), true);
       assert.strictEqual(res.hasHeader('X-Test-Header2'), true);
@@ -117,7 +122,7 @@ const s = http.createServer(common.mustCall((req, res) => {
         true,
         {},
         { toString: () => 'X-TEST-HEADER2' },
-        () => { }
+        () => { },
       ].forEach((val) => {
         assert.throws(
           () => res.hasHeader(val),
@@ -171,7 +176,10 @@ function nextTest() {
 
   let bufferedResponse = '';
 
-  http.get({ port: s.address().port }, common.mustCall((response) => {
+  const req = http.get({
+    port: s.address().port,
+    headers: { 'X-foo': 'bar' }
+  }, common.mustCall((response) => {
     switch (test) {
       case 'headers':
         assert.strictEqual(response.statusCode, 201);
@@ -214,4 +222,10 @@ function nextTest() {
       common.mustCall(nextTest)();
     }));
   }));
+
+  assert.deepStrictEqual(req.getHeaderNames(),
+                         ['x-foo', 'host']);
+
+  assert.deepStrictEqual(req.getRawHeaderNames(),
+                         ['X-foo', 'Host']);
 }
diff --git a/test/parallel/test-http-no-read-no-dump.js b/test/parallel/test-http-no-read-no-dump.js
index c6ce19845d80abee9f6b411a4e45feae59267dc2..3f976bb087290c17f99cc6031e913c26e17a290a 100644
--- a/test/parallel/test-http-no-read-no-dump.js
+++ b/test/parallel/test-http-no-read-no-dump.js
@@ -40,10 +40,9 @@ const server = http.createServer((req, res) => {
     };
   }));
 
-  /* What happens here is that the server `end`s the response before we send
-   * `something`, and the client thought that this is a green light for sending
-   * next GET request
-   */
+  // What happens here is that the server `end`s the response before we send
+  // `something`, and the client thought that this is a green light for sending
+  // next GET request
   post.write('initial');
 
   http.request({
diff --git a/test/parallel/test-http-outgoing-end-cork.js b/test/parallel/test-http-outgoing-end-cork.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a217238c447c4f2f0fd747f1e366bc8f9f4a213
--- /dev/null
+++ b/test/parallel/test-http-outgoing-end-cork.js
@@ -0,0 +1,95 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const REQ_TIMEOUT = 500; // Set max ms of request time before abort
+
+// Set total allowed test timeout to avoid infinite loop
+// that will hang test suite
+const TOTAL_TEST_TIMEOUT = 1000;
+
+// Placeholder for sockets handled, to make sure that we
+// will reach a socket re-use case.
+const handledSockets = new Set();
+
+let metReusedSocket = false; // Flag for request loop termination.
+
+const doubleEndResponse = (res) => {
+  // First end the request while sending some normal data
+  res.end('regular end of request', 'utf8', common.mustCall());
+  // Make sure the response socket is uncorked after first call of end
+  assert.strictEqual(res.writableCorked, 0);
+  res.end(); // Double end the response to prep for next socket re-use.
+};
+
+const sendDrainNeedingData = (res) => {
+  // Send data to socket more than the high watermark so that
+  // it definitely needs drain
+  const highWaterMark = res.socket.writableHighWaterMark;
+  const bufferToSend = Buffer.alloc(highWaterMark + 100);
+  const ret = res.write(bufferToSend); // Write the request data.
+  // Make sure that we had back pressure on response stream.
+  assert.strictEqual(ret, false);
+  res.once('drain', () => res.end()); // End on drain.
+};
+
+const server = http.createServer((req, res) => {
+  const { socket: responseSocket } = res;
+  if (handledSockets.has(responseSocket)) { // re-used socket, send big data!
+    metReusedSocket = true; // stop request loop
+    console.debug('FOUND REUSED SOCKET!');
+    sendDrainNeedingData(res);
+  } else { // not used again
+    // add to make sure we recognise it when we meet socket again
+    handledSockets.add(responseSocket);
+    doubleEndResponse(res);
+  }
+});
+
+server.listen(0); // Start the server on a random port.
+
+const sendRequest = (agent) => new Promise((resolve, reject) => {
+  const timeout = setTimeout(common.mustNotCall(() => {
+    reject(new Error('Request timed out'));
+  }), REQ_TIMEOUT);
+  http.get({
+    port: server.address().port,
+    path: '/',
+    agent
+  }, common.mustCall((res) => {
+    const resData = [];
+    res.on('data', (data) => resData.push(data));
+    res.on('end', common.mustCall(() => {
+      const totalData = resData.reduce((total, elem) => total + elem.length, 0);
+      clearTimeout(timeout); // Cancel rejection timeout.
+      resolve(totalData); // fulfill promise
+    }));
+  }));
+});
+
+server.once('listening', async () => {
+  const testTimeout = setTimeout(common.mustNotCall(() => {
+    console.error('Test running for a while but could not met re-used socket');
+    process.exit(1);
+  }), TOTAL_TEST_TIMEOUT);
+  // Explicitly start agent to force socket reuse.
+  const agent = new http.Agent({ keepAlive: true });
+  // Start the request loop
+  let reqNo = 0;
+  while (!metReusedSocket) {
+    try {
+      console.log(`Sending req no ${++reqNo}`);
+      const totalData = await sendRequest(agent);
+      console.log(`${totalData} bytes were received for request ${reqNo}`);
+    } catch (err) {
+      console.error(err);
+      process.exit(1);
+    }
+  }
+  // Successfully tested conditions and ended loop
+  clearTimeout(testTimeout);
+  console.log('Closing server');
+  agent.destroy();
+  server.close();
+});
diff --git a/test/parallel/test-http-outgoing-end-multiple.js b/test/parallel/test-http-outgoing-end-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..2297f68cfec4c09b80297eb4661e3d8d199a4647
--- /dev/null
+++ b/test/parallel/test-http-outgoing-end-multiple.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+const server = http.createServer(common.mustCall(function(req, res) {
+  res.end('testing ended state', common.mustCall());
+  assert.strictEqual(res.writableCorked, 0);
+  res.end(common.mustCall());
+  assert.strictEqual(res.writableCorked, 0);
+  res.on('finish', common.mustCall(() => {
+    res.end(common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ERR_STREAM_ALREADY_FINISHED');
+      server.close();
+    }));
+    assert.strictEqual(res.writableCorked, 0);
+  }));
+}));
+
+server.listen(0);
+
+server.on('listening', common.mustCall(function() {
+  http
+    .request({
+      port: server.address().port,
+      method: 'GET',
+      path: '/'
+    })
+    .end();
+}));
diff --git a/test/parallel/test-http-outgoing-internal-headernames-getter.js b/test/parallel/test-http-outgoing-internal-headernames-getter.js
index c3caffff1f8a42c0a3eb75ebcce71a764d31adbf..4a56a1301050b522d0f9060f72493cc22ac2d3a1 100644
--- a/test/parallel/test-http-outgoing-internal-headernames-getter.js
+++ b/test/parallel/test-http-outgoing-internal-headernames-getter.js
@@ -9,5 +9,5 @@ common.expectWarning('DeprecationWarning', warn, 'DEP0066');
 {
   // Tests for _headerNames get method
   const outgoingMessage = new OutgoingMessage();
-  outgoingMessage._headerNames;
+  outgoingMessage._headerNames; // eslint-disable-line no-unused-expressions
 }
diff --git a/test/parallel/test-http-outgoing-internal-headers.js b/test/parallel/test-http-outgoing-internal-headers.js
index b9e7aed165b68d1d5c979bff340a2c7c881d1384..17de5e7d075ce528787d43fa3cad83ed1f19a9e0 100644
--- a/test/parallel/test-http-outgoing-internal-headers.js
+++ b/test/parallel/test-http-outgoing-internal-headers.js
@@ -13,7 +13,7 @@ common.expectWarning('DeprecationWarning', warn, 'DEP0066');
   // Tests for _headers get method
   const outgoingMessage = new OutgoingMessage();
   outgoingMessage.getHeaders = common.mustCall();
-  outgoingMessage._headers;
+  outgoingMessage._headers; // eslint-disable-line no-unused-expressions
 }
 
 {
@@ -31,3 +31,14 @@ common.expectWarning('DeprecationWarning', warn, 'DEP0066');
       origin: ['Origin', 'localhost']
     }));
 }
+
+{
+  // Tests for _headers set method `null`
+  const outgoingMessage = new OutgoingMessage();
+  outgoingMessage._headers = null;
+
+  assert.strictEqual(
+    outgoingMessage[kOutHeaders],
+    null
+  );
+}
diff --git a/test/parallel/test-http-outgoing-proto.js b/test/parallel/test-http-outgoing-proto.js
index 638e860f62b538625227a3a8d29bff8b6d3e2b7c..6968b7b04501681b5606df8e6d903546248b91e1 100644
--- a/test/parallel/test-http-outgoing-proto.js
+++ b/test/parallel/test-http-outgoing-proto.js
@@ -1,5 +1,5 @@
 'use strict';
-const common = require('../common');
+require('../common');
 const assert = require('assert');
 
 const http = require('http');
@@ -62,13 +62,16 @@ assert.throws(() => {
 {
   const outgoingMessage = new OutgoingMessage();
 
-  outgoingMessage.on('error', common.expectsError({
-    code: 'ERR_METHOD_NOT_IMPLEMENTED',
-    name: 'Error',
-    message: 'The _implicitHeader() method is not implemented'
-  }));
-
-  outgoingMessage.write('');
+  assert.throws(
+    () => {
+      outgoingMessage.write('');
+    },
+    {
+      code: 'ERR_METHOD_NOT_IMPLEMENTED',
+      name: 'Error',
+      message: 'The _implicitHeader() method is not implemented'
+    }
+  );
 }
 
 assert(OutgoingMessage.prototype.write.call({ _header: 'test' }));
@@ -119,3 +122,10 @@ assert.throws(() => {
   name: 'TypeError',
   message: 'Invalid character in trailer content ["404"]'
 });
+
+{
+  const outgoingMessage = new OutgoingMessage();
+  assert.strictEqual(outgoingMessage.destroyed, false);
+  outgoingMessage.destroy();
+  assert.strictEqual(outgoingMessage.destroyed, true);
+}
diff --git a/test/parallel/test-http-parser-freed-before-upgrade.js b/test/parallel/test-http-parser-freed-before-upgrade.js
index 4ba1de9501681ca8f2e89f5c7676fbc9e01193a2..d0f1409f1d2b435d4299d1a0746144ed6af2df89 100644
--- a/test/parallel/test-http-parser-freed-before-upgrade.js
+++ b/test/parallel/test-http-parser-freed-before-upgrade.js
@@ -12,7 +12,7 @@ server.on('upgrade', common.mustCall((request, socket) => {
     'HTTP/1.1 101 Switching Protocols',
     'Connection: Upgrade',
     'Upgrade: WebSocket',
-    '\r\n'
+    '\r\n',
   ].join('\r\n'));
 }));
 
diff --git a/test/parallel/test-http-parser-lazy-loaded.js b/test/parallel/test-http-parser-lazy-loaded.js
index 5fc376951027ab37c2c149752f1c9b219af77825..44bb59f052e6ce2ca389e13360e29b25fb050653 100644
--- a/test/parallel/test-http-parser-lazy-loaded.js
+++ b/test/parallel/test-http-parser-lazy-loaded.js
@@ -2,7 +2,7 @@
 
 'use strict';
 const common = require('../common');
-const { getOptionValue } = require('internal/options');
+const { internalBinding } = require('internal/test/binding');
 
 // Monkey patch before requiring anything
 class DummyParser {
@@ -15,12 +15,7 @@ class DummyParser {
 }
 DummyParser.REQUEST = Symbol();
 
-// Note: using process.binding instead of internalBinding because this test is
-// verifying that user applications are still able to monkey-patch the
-// http_parser module.
-const binding =
-  getOptionValue('--http-parser') === 'legacy' ?
-    process.binding('http_parser') : process.binding('http_parser_llhttp');
+const binding = internalBinding('http_parser');
 binding.HTTPParser = DummyParser;
 
 const assert = require('assert');
@@ -36,9 +31,7 @@ assert.strictEqual(parser.test_type, DummyParser.REQUEST);
 if (process.argv[2] !== 'child') {
   // Also test in a child process with IPC (specific case of https://github.com/nodejs/node/issues/23716)
   const child = spawn(process.execPath, [
-    '--expose-internals',
-    `--http-parser=${getOptionValue('--http-parser')}`,
-    __filename, 'child'
+    '--expose-internals', __filename, 'child',
   ], {
     stdio: ['inherit', 'inherit', 'inherit', 'ipc']
   });
diff --git a/test/parallel/test-http-parser-legacy-deprecation.js b/test/parallel/test-http-parser-legacy-deprecation.js
deleted file mode 100644
index 6c4c690a9b916948b72df4762dd029cf2ebe4cf4..0000000000000000000000000000000000000000
--- a/test/parallel/test-http-parser-legacy-deprecation.js
+++ /dev/null
@@ -1,11 +0,0 @@
-'use strict';
-const common = require('../common');
-
-// Flags: --http-parser=legacy
-require('http');
-
-common.expectWarning({
-  DeprecationWarning:
-    ['The legacy HTTP parser is deprecated.',
-     'DEP0131']
-});
diff --git a/test/parallel/test-http-parser-timeout-reset.js b/test/parallel/test-http-parser-timeout-reset.js
index e395c1c45730305a237c16c470da302ae650b793..1ba72d865f73fb9038fd8a99666aee5633573a76 100644
--- a/test/parallel/test-http-parser-timeout-reset.js
+++ b/test/parallel/test-http-parser-timeout-reset.js
@@ -25,6 +25,8 @@ const server = net.createServer((socket) => {
   parser.initialize(
     HTTPParser.RESPONSE,
     {},
+    0,
+    false,
     1e3
   );
 
diff --git a/test/parallel/test-http-pause.js b/test/parallel/test-http-pause.js
index 0294cf5625b5e8555271a7884ad6e4186829bfff..555eece2e3f13b55f12a2e10eea7e6364c1fd553 100644
--- a/test/parallel/test-http-pause.js
+++ b/test/parallel/test-http-pause.js
@@ -48,6 +48,8 @@ const server = http.createServer((req, res) => {
 });
 
 server.listen(0, function() {
+  // Anonymous function rather than arrow function to test `this` value.
+  assert.strictEqual(this, server);
   const req = http.request({
     port: this.address().port,
     path: '/',
diff --git a/test/parallel/test-http-perf_hooks.js b/test/parallel/test-http-perf_hooks.js
index f28885e4367853255cb376fee4c766d3fc626f1e..bc92fd1b3c0fe89f989b8764ecde923f80c4fd34 100644
--- a/test/parallel/test-http-perf_hooks.js
+++ b/test/parallel/test-http-perf_hooks.js
@@ -52,7 +52,7 @@ server.listen(0, common.mustCall(async () => {
       path: '/',
       method: 'POST',
       data: expected
-    })
+    }),
   ]);
   server.close();
 }));
diff --git a/test/parallel/test-http-proxy.js b/test/parallel/test-http-proxy.js
index 6a986024af29bec30b509d6859ce6960ee87d6e7..af3497630b7f79367411fb69fd22c2af5a18f83b 100644
--- a/test/parallel/test-http-proxy.js
+++ b/test/parallel/test-http-proxy.js
@@ -27,7 +27,7 @@ const url = require('url');
 
 const cookies = [
   'session_token=; path=/; expires=Sun, 15-Sep-2030 13:48:52 GMT',
-  'prefers_open_id=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT'
+  'prefers_open_id=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT',
 ];
 
 const headers = { 'content-type': 'text/plain',
diff --git a/test/parallel/test-http-raw-headers.js b/test/parallel/test-http-raw-headers.js
index 8ce20db351302c77aeacc438a7ad1b1085d199a9..d77a7cacc64c292cd0d4477d42ebe669f35263f9 100644
--- a/test/parallel/test-http-raw-headers.js
+++ b/test/parallel/test-http-raw-headers.js
@@ -34,7 +34,7 @@ http.createServer(function(req, res) {
     'x-BaR',
     'yoyoyo',
     'Connection',
-    'close'
+    'close',
   ];
   const expectHeaders = {
     'host': `localhost:${this.address().port}`,
@@ -50,7 +50,7 @@ http.createServer(function(req, res) {
     'X-bAr',
     'yOyOyOy',
     'X-baR',
-    'OyOyOyO'
+    'OyOyOyO',
   ];
   const expectTrailers = { 'x-bar': 'yOyOyOy, OyOyOyO, yOyOyOy, OyOyOyO' };
 
@@ -70,7 +70,7 @@ http.createServer(function(req, res) {
     ['x-fOo', 'xOxOxOx'],
     ['x-foO', 'OxOxOxO'],
     ['X-fOo', 'xOxOxOx'],
-    ['X-foO', 'OxOxOxO']
+    ['X-foO', 'OxOxOxO'],
   ]);
   res.end('x f o o');
 }).listen(0, function() {
@@ -79,7 +79,7 @@ http.createServer(function(req, res) {
     ['x-bAr', 'yOyOyOy'],
     ['x-baR', 'OyOyOyO'],
     ['X-bAr', 'yOyOyOy'],
-    ['X-baR', 'OyOyOyO']
+    ['X-baR', 'OyOyOyO'],
   ]);
   req.setHeader('transfer-ENCODING', 'CHUNKED');
   req.setHeader('x-BaR', 'yoyoyo');
@@ -93,7 +93,7 @@ http.createServer(function(req, res) {
       'Connection',
       'close',
       'Transfer-Encoding',
-      'chunked'
+      'chunked',
     ];
     const expectHeaders = {
       'trailer': 'x-foo',
@@ -114,7 +114,7 @@ http.createServer(function(req, res) {
         'X-fOo',
         'xOxOxOx',
         'X-foO',
-        'OxOxOxO'
+        'OxOxOxO',
       ];
       const expectTrailers = { 'x-foo': 'xOxOxOx, OxOxOxO, xOxOxOx, OxOxOxO' };
 
diff --git a/test/parallel/test-http-req-close-robust-from-tampering.js b/test/parallel/test-http-req-close-robust-from-tampering.js
new file mode 100644
index 0000000000000000000000000000000000000000..46ae0c0e2971586a432897bb169315ad9f9a5884
--- /dev/null
+++ b/test/parallel/test-http-req-close-robust-from-tampering.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../common');
+const { createServer } = require('http');
+const { connect } = require('net');
+
+// Make sure that calling the semi-private close() handlers manually doesn't
+// cause an error.
+
+const server = createServer(common.mustCall((req, res) => {
+  req.client._events.close.forEach((fn) => { fn.bind(req)(); });
+}));
+
+server.unref();
+
+server.listen(0, common.mustCall(() => {
+  const client = connect(server.address().port);
+
+  const req = [
+    'POST / HTTP/1.1',
+    'Content-Length: 11',
+    '',
+    'hello world',
+  ].join('\r\n');
+
+  client.end(req);
+}));
diff --git a/test/parallel/test-http-response-multiheaders.js b/test/parallel/test-http-response-multiheaders.js
index 31cb59546c698cc823a8708e64f416df8ae1e1bf..39840ce06957ec1a8a9900c9363901aacbccefb8 100644
--- a/test/parallel/test-http-response-multiheaders.js
+++ b/test/parallel/test-http-response-multiheaders.js
@@ -26,7 +26,7 @@ const norepeat = [
   'last-modified',
   'server',
   'age',
-  'expires'
+  'expires',
 ];
 const runCount = 2;
 
diff --git a/test/parallel/test-http-response-no-headers.js b/test/parallel/test-http-response-no-headers.js
index 87b0f8e67faf7c4d0ec72f1bb8cabf93422578f4..22705936e0825408b819248906431a35fa4eaf9d 100644
--- a/test/parallel/test-http-response-no-headers.js
+++ b/test/parallel/test-http-response-no-headers.js
@@ -51,6 +51,7 @@ function test(httpVersion, callback) {
         body += data;
       });
 
+      res.on('aborted', common.mustNotCall());
       res.on('end', common.mustCall(function() {
         assert.strictEqual(body, expected[httpVersion]);
         server.close();
diff --git a/test/parallel/test-http-response-status-message.js b/test/parallel/test-http-response-status-message.js
index 0f9bce8fa87d675b9aeeea783868371cf411de53..3c22e40b43bf026b228e89b968781cffe6859d34 100644
--- a/test/parallel/test-http-response-status-message.js
+++ b/test/parallel/test-http-response-status-message.js
@@ -20,7 +20,7 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 const net = require('net');
@@ -36,7 +36,7 @@ const testCases = [
   { path: '/missing', statusMessage: '',
     response: 'HTTP/1.1 200 \r\n\r\n' },
   { path: '/missing-no-space', statusMessage: '',
-    response: 'HTTP/1.1 200\r\n\r\n' }
+    response: 'HTTP/1.1 200\r\n\r\n' },
 ];
 testCases.findByPath = function(path) {
   const matching = this.filter(function(testCase) {
@@ -71,6 +71,7 @@ function runTest(testCaseIndex) {
     console.log(`client: actual status message: ${response.statusMessage}`);
     assert.strictEqual(testCase.statusMessage, response.statusMessage);
 
+    response.on('aborted', common.mustNotCall());
     response.on('end', function() {
       countdown.dec();
       if (testCaseIndex + 1 < testCases.length) {
diff --git a/test/parallel/test-http-same-map.js b/test/parallel/test-http-same-map.js
index 0adb73222de184018d573850423cee17b42cdcdd..3d8d325ad7b0d1d91ba17e674b16d6475d1913a5 100644
--- a/test/parallel/test-http-same-map.js
+++ b/test/parallel/test-http-same-map.js
@@ -39,9 +39,10 @@ onresponse.responses = [];
 
 function allSame(list) {
   assert(list.length >= 2);
-  // Use |elt| in no-op position to pacify eslint.
-  for (const elt of list) elt, eval('%DebugPrint(elt)');
-  for (const elt of list) elt, assert(eval('%HaveSameMap(list[0], elt)'));
+  // eslint-disable-next-line no-unused-vars
+  for (const elt of list) eval('%DebugPrint(elt)');
+  // eslint-disable-next-line no-unused-vars
+  for (const elt of list) assert(eval('%HaveSameMap(list[0], elt)'));
 }
 
 process.on('exit', () => {
diff --git a/test/parallel/test-http-server-disabled-headers-timeout.js b/test/parallel/test-http-server-disabled-headers-timeout.js
deleted file mode 100644
index 905e589cbe71ebdc0dbb2b731b2e735c6018e995..0000000000000000000000000000000000000000
--- a/test/parallel/test-http-server-disabled-headers-timeout.js
+++ /dev/null
@@ -1,49 +0,0 @@
-'use strict';
-
-const common = require('../common');
-const assert = require('assert');
-const { createServer } = require('http');
-const { connect } = require('net');
-
-// This test verifies that it is possible to disable
-// headersTimeout by setting it to zero.
-
-const server = createServer(common.mustCall((req, res) => {
-  res.writeHead(200);
-  res.end('OK');
-}));
-
-server.headersTimeout = 0;
-
-server.once('timeout', common.mustNotCall((socket) => {
-  socket.destroy();
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = connect(server.address().port);
-  let response = '';
-
-  client.resume();
-  client.write('GET / HTTP/1.1\r\nConnection: close\r\n');
-
-  // All the timeouts below must be greater than a second, otherwise
-  // headersTimeout won't be triggered anyway as the current date is cached
-  // for a second in HTTP internals.
-  setTimeout(() => {
-    client.write('X-Crash: Ab: 456\r\n');
-  }, common.platformTimeout(1100)).unref();
-
-  setTimeout(() => {
-    client.write('\r\n');
-  }, common.platformTimeout(1200)).unref();
-
-  client.on('data', (chunk) => {
-    response += chunk.toString('utf-8');
-  });
-
-  client.on('end', common.mustCall(() => {
-    assert.strictEqual(response.split('\r\n').shift(), 'HTTP/1.1 200 OK');
-    client.end();
-    server.close();
-  }));
-}));
diff --git a/test/parallel/test-http-server-keepalive-end.js b/test/parallel/test-http-server-keepalive-end.js
index 8ebdecb97c3d8ca01e6c8797343a54866141f7a2..9d1bc0bfc0d1161100829dcc9798d25eb0c1db75 100644
--- a/test/parallel/test-http-server-keepalive-end.js
+++ b/test/parallel/test-http-server-keepalive-end.js
@@ -31,7 +31,7 @@ server.listen(0, common.mustCall(() => {
     'Content-Length: 11',
     '',
     'hello world',
-    ''
+    '',
   ].join('\r\n');
 
   client.end(req);
diff --git a/test/parallel/test-http-server-keepalive-req-gc.js b/test/parallel/test-http-server-keepalive-req-gc.js
index e94845d38df0986a6fea03f61729854c369f9981..0c68ebab763223e50ed0bb558b3f5f340093d2fe 100644
--- a/test/parallel/test-http-server-keepalive-req-gc.js
+++ b/test/parallel/test-http-server-keepalive-req-gc.js
@@ -32,7 +32,7 @@ server.listen(0, common.mustCall(() => {
     'Content-Length: 11',
     '',
     'hello world',
-    ''
+    '',
   ].join('\r\n');
 
   client.write(req);
diff --git a/test/parallel/test-http-server-request-timeout-delayed-body.js b/test/parallel/test-http-server-request-timeout-delayed-body.js
new file mode 100644
index 0000000000000000000000000000000000000000..ec8ebbb5cd18eb368993ddc542f75bb17f0ac78f
--- /dev/null
+++ b/test/parallel/test-http-server-request-timeout-delayed-body.js
@@ -0,0 +1,68 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { createServer } = require('http');
+const { connect } = require('net');
+
+// This test validates that the server returns 408
+// after server.requestTimeout if the client
+// pauses before start sending the body.
+
+let sendDelayedRequestBody;
+const server = createServer(common.mustCall((req, res) => {
+  let body = '';
+  req.setEncoding('utf-8');
+
+  req.on('data', (chunk) => {
+    body += chunk;
+  });
+
+  req.on('end', () => {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write(body);
+    res.end();
+  });
+
+  assert.strictEqual(typeof sendDelayedRequestBody, 'function');
+  sendDelayedRequestBody();
+}));
+
+// 0 seconds is the default
+assert.strictEqual(server.requestTimeout, 0);
+const requestTimeout = common.platformTimeout(1000);
+server.requestTimeout = requestTimeout;
+assert.strictEqual(server.requestTimeout, requestTimeout);
+
+server.listen(0, common.mustCall(() => {
+  const client = connect(server.address().port);
+  let response = '';
+
+  client.on('data', common.mustCall((chunk) => {
+    response += chunk.toString('utf-8');
+  }));
+
+  client.resume();
+  client.write('POST / HTTP/1.1\r\n');
+  client.write('Content-Length: 20\r\n');
+  client.write('Connection: close\r\n');
+  client.write('\r\n');
+
+  sendDelayedRequestBody = common.mustCall(() => {
+    setTimeout(() => {
+      client.write('12345678901234567890\r\n\r\n');
+    }, common.platformTimeout(2000)).unref();
+  });
+
+  const errOrEnd = common.mustCall(function(err) {
+    console.log(err);
+    assert.strictEqual(
+      response,
+      'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
+    );
+    server.close();
+  });
+
+  client.on('end', errOrEnd);
+  client.on('error', errOrEnd);
+}));
diff --git a/test/parallel/test-http-server-request-timeout-delayed-headers.js b/test/parallel/test-http-server-request-timeout-delayed-headers.js
new file mode 100644
index 0000000000000000000000000000000000000000..f5d85b705149504ec53f7c63adf9cc1144270e3e
--- /dev/null
+++ b/test/parallel/test-http-server-request-timeout-delayed-headers.js
@@ -0,0 +1,53 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { createServer } = require('http');
+const { connect } = require('net');
+
+// This test validates that the server returns 408
+// after server.requestTimeout if the client
+// pauses before start sending the request.
+let sendDelayedRequestHeaders;
+const server = createServer(common.mustNotCall());
+server.on('connection', common.mustCall(() => {
+  assert.strictEqual(typeof sendDelayedRequestHeaders, 'function');
+  sendDelayedRequestHeaders();
+}));
+// 0 seconds is the default
+assert.strictEqual(server.requestTimeout, 0);
+const requestTimeout = common.platformTimeout(1000);
+server.requestTimeout = requestTimeout;
+assert.strictEqual(server.requestTimeout, requestTimeout);
+
+server.listen(0, common.mustCall(() => {
+  const client = connect(server.address().port);
+  let response = '';
+
+  client.on('data', common.mustCall((chunk) => {
+    response += chunk.toString('utf-8');
+  }));
+
+  const errOrEnd = common.mustCall(function(err) {
+    console.log(err);
+    assert.strictEqual(
+      response,
+      'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
+    );
+    server.close();
+  });
+
+  client.on('end', errOrEnd);
+  client.on('error', errOrEnd);
+
+  client.resume();
+
+  sendDelayedRequestHeaders = common.mustCall(() => {
+    setTimeout(() => {
+      client.write('POST / HTTP/1.1\r\n');
+      client.write('Content-Length: 20\r\n');
+      client.write('Connection: close\r\n\r\n');
+      client.write('12345678901234567890\r\n\r\n');
+    }, common.platformTimeout(2000)).unref();
+  });
+}));
diff --git a/test/parallel/test-http-server-request-timeout-interrupted-body.js b/test/parallel/test-http-server-request-timeout-interrupted-body.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d70351fdc0833bd9dd32ad818f820ccf46f98d2
--- /dev/null
+++ b/test/parallel/test-http-server-request-timeout-interrupted-body.js
@@ -0,0 +1,68 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { createServer } = require('http');
+const { connect } = require('net');
+
+// This test validates that the server returns 408
+// after server.requestTimeout if the client
+// pauses sending in the middle of the body.
+let sendDelayedRequestBody;
+const server = createServer(common.mustCall((req, res) => {
+  let body = '';
+  req.setEncoding('utf-8');
+
+  req.on('data', (chunk) => {
+    body += chunk;
+  });
+
+  req.on('end', () => {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write(body);
+    res.end();
+  });
+
+  assert.strictEqual(typeof sendDelayedRequestBody, 'function');
+  sendDelayedRequestBody();
+}));
+
+// 0 seconds is the default
+assert.strictEqual(server.requestTimeout, 0);
+const requestTimeout = common.platformTimeout(1000);
+server.requestTimeout = requestTimeout;
+assert.strictEqual(server.requestTimeout, requestTimeout);
+
+server.listen(0, common.mustCall(() => {
+  const client = connect(server.address().port);
+  let response = '';
+
+  client.on('data', common.mustCall((chunk) => {
+    response += chunk.toString('utf-8');
+  }));
+
+  const errOrEnd = common.mustCall(function(err) {
+    console.log(err);
+    assert.strictEqual(
+      response,
+      'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
+    );
+    server.close();
+  });
+
+  client.on('error', errOrEnd);
+  client.on('end', errOrEnd);
+
+  client.resume();
+  client.write('POST / HTTP/1.1\r\n');
+  client.write('Content-Length: 20\r\n');
+  client.write('Connection: close\r\n');
+  client.write('\r\n');
+  client.write('1234567890');
+
+  sendDelayedRequestBody = common.mustCall(() => {
+    setTimeout(() => {
+      client.write('1234567890\r\n\r\n');
+    }, common.platformTimeout(2000)).unref();
+  });
+}));
diff --git a/test/parallel/test-http-server-request-timeout-interrupted-headers.js b/test/parallel/test-http-server-request-timeout-interrupted-headers.js
new file mode 100644
index 0000000000000000000000000000000000000000..1fa8946ffae70f128dcca220ce096b2860108e57
--- /dev/null
+++ b/test/parallel/test-http-server-request-timeout-interrupted-headers.js
@@ -0,0 +1,54 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { createServer } = require('http');
+const { connect } = require('net');
+
+// This test validates that the server returns 408
+// after server.requestTimeout if the client
+// pauses sending in the middle of a header.
+let sendDelayedRequestHeaders;
+const server = createServer(common.mustNotCall());
+server.on('connection', common.mustCall(() => {
+  assert.strictEqual(typeof sendDelayedRequestHeaders, 'function');
+  sendDelayedRequestHeaders();
+}));
+
+// 120 seconds is the default
+assert.strictEqual(server.requestTimeout, 0);
+const requestTimeout = common.platformTimeout(1000);
+server.requestTimeout = requestTimeout;
+assert.strictEqual(server.requestTimeout, requestTimeout);
+
+server.listen(0, common.mustCall(() => {
+  const client = connect(server.address().port);
+  let response = '';
+
+  client.on('data', common.mustCall((chunk) => {
+    response += chunk.toString('utf-8');
+  }));
+
+  const errOrEnd = common.mustCall(function(err) {
+    console.log(err);
+    assert.strictEqual(
+      response,
+      'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
+    );
+    server.close();
+  });
+
+  client.on('end', errOrEnd);
+  client.on('error', errOrEnd);
+
+  client.resume();
+  client.write('GET / HTTP/1.1\r\n');
+  client.write('Connection: close\r\n');
+  client.write('X-CRASH: ');
+
+  sendDelayedRequestHeaders = common.mustCall(() => {
+    setTimeout(() => {
+      client.write('1234567890\r\n\r\n');
+    }, common.platformTimeout(2000)).unref();
+  });
+}));
diff --git a/test/parallel/test-http-server-request-timeout-keepalive.js b/test/parallel/test-http-server-request-timeout-keepalive.js
new file mode 100644
index 0000000000000000000000000000000000000000..77fde867e9b5403b3fd761b41810fab0e709a085
--- /dev/null
+++ b/test/parallel/test-http-server-request-timeout-keepalive.js
@@ -0,0 +1,94 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { createServer } = require('http');
+const { connect } = require('net');
+
+// This test validates that the server returns 408
+// after server.requestTimeout if the client
+// does not complete a request, and that keep alive
+// works properly
+
+function performRequestWithDelay(client, firstDelay, secondDelay) {
+  client.resume();
+  client.write('GET / HTTP/1.1\r\n');
+
+  firstDelay = common.platformTimeout(firstDelay);
+  secondDelay = common.platformTimeout(secondDelay);
+
+  console.log('performRequestWithDelay', firstDelay, secondDelay);
+
+  setTimeout(() => {
+    client.write('Connection: ');
+  }, firstDelay).unref();
+
+  // Complete the request
+  setTimeout(() => {
+    client.write('keep-alive\r\n\r\n');
+  }, firstDelay + secondDelay).unref();
+}
+
+const server = createServer(common.mustCallAtLeast((req, res) => {
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end();
+}));
+
+// 0 seconds is the default
+assert.strictEqual(server.requestTimeout, 0);
+const requestTimeout = common.platformTimeout(1000);
+server.requestTimeout = requestTimeout;
+assert.strictEqual(server.requestTimeout, requestTimeout);
+
+// Make sure keepAliveTimeout is big enough for the requestTimeout.
+server.keepAliveTimeout = 0;
+
+server.listen(0, common.mustCall(() => {
+  const client = connect(server.address().port);
+  let second = false;
+  let response = '';
+
+  client.on('data', common.mustCallAtLeast((chunk) => {
+    response += chunk.toString('utf-8');
+
+    // First response has ended
+    if (!second && response.endsWith('\r\n\r\n')) {
+      assert.strictEqual(
+        response.split('\r\n')[0],
+        'HTTP/1.1 200 OK'
+      );
+
+      const defer = common.platformTimeout(server.requestTimeout * 1.5);
+
+      console.log('defer by', defer);
+
+      // Wait some time to make sure requestTimeout
+      // does not interfere with keep alive
+      setTimeout(() => {
+        response = '';
+        second = true;
+
+        // Perform a second request expected to finish after requestTimeout
+        performRequestWithDelay(client, 1000, 3000);
+      }, defer).unref();
+    }
+  }, 1));
+
+  const errOrEnd = common.mustCall(function(err) {
+    console.log(err);
+    assert.strictEqual(second, true);
+    assert.strictEqual(
+      response,
+      // Empty because of https://github.com/nodejs/node/commit/e8d7fedf7cad6e612e4f2e0456e359af57608ac7
+      // 'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
+      ''
+    );
+    server.close();
+  });
+
+  client.on('error', errOrEnd);
+  client.on('end', errOrEnd);
+
+  // Perform a second request expected to finish before requestTimeout
+  performRequestWithDelay(client, 50, 500);
+}));
diff --git a/test/parallel/test-http-server-request-timeout-upgrade.js b/test/parallel/test-http-server-request-timeout-upgrade.js
new file mode 100644
index 0000000000000000000000000000000000000000..87e8dbab131631bbaf1a840f3ddd5338b47d6c22
--- /dev/null
+++ b/test/parallel/test-http-server-request-timeout-upgrade.js
@@ -0,0 +1,61 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { createServer } = require('http');
+const { connect } = require('net');
+
+// This test validates that the requestTimeoout
+// is disabled after the connection is upgraded.
+let sendDelayedRequestHeaders;
+const server = createServer(common.mustNotCall());
+server.on('connection', common.mustCall(() => {
+  assert.strictEqual(typeof sendDelayedRequestHeaders, 'function');
+  sendDelayedRequestHeaders();
+}));
+
+// 0 seconds is the default
+assert.strictEqual(server.requestTimeout, 0);
+const requestTimeout = common.platformTimeout(1000);
+server.requestTimeout = requestTimeout;
+assert.strictEqual(server.requestTimeout, requestTimeout);
+
+server.on('upgrade', common.mustCall((req, socket, head) => {
+  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n');
+  socket.write('Upgrade: WebSocket\r\n');
+  socket.write('Connection: Upgrade\r\n\r\n');
+  socket.pipe(socket);
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = connect(server.address().port);
+  let response = '';
+
+  client.on('data', common.mustCallAtLeast((chunk) => {
+    response += chunk.toString('utf-8');
+  }, 1));
+
+  client.on('end', common.mustCall(() => {
+    assert.strictEqual(
+      response,
+      'HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
+      'Upgrade: WebSocket\r\n' +
+      'Connection: Upgrade\r\n\r\n' +
+      '12345678901234567890'
+    );
+
+    server.close();
+  }));
+
+  client.resume();
+  client.write('GET / HTTP/1.1\r\n');
+  client.write('Upgrade: WebSocket\r\n');
+  client.write('Connection: Upgrade\r\n\r\n');
+
+  sendDelayedRequestHeaders = common.mustCall(() => {
+    setTimeout(() => {
+      client.write('12345678901234567890');
+      client.end();
+    }, common.platformTimeout(2000)).unref();
+  });
+}));
diff --git a/test/parallel/test-http-server-write-end-after-end.js b/test/parallel/test-http-server-write-end-after-end.js
new file mode 100644
index 0000000000000000000000000000000000000000..37fbe062f12b690e340d1c6de6c35cb1fb8d8524
--- /dev/null
+++ b/test/parallel/test-http-server-write-end-after-end.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+
+const server = http.createServer(handle);
+
+function handle(req, res) {
+  res.on('error', common.mustCall((err) => {
+    common.expectsError({
+      code: 'ERR_STREAM_WRITE_AFTER_END',
+      name: 'Error'
+    })(err);
+    server.close();
+  }));
+
+  res.write('hello');
+  res.end();
+
+  setImmediate(common.mustCall(() => {
+    res.end('world');
+  }));
+}
+
+server.listen(0, common.mustCall(() => {
+  http.get(`http://localhost:${server.address().port}`);
+}));
diff --git a/test/parallel/test-http-set-header-chain.js b/test/parallel/test-http-set-header-chain.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa9519129a912353a5630c979c63945708cd7994
--- /dev/null
+++ b/test/parallel/test-http-set-header-chain.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+const expected = {
+  '__proto__': null,
+  'testheader1': 'foo',
+  'testheader2': 'bar',
+  'testheader3': 'xyz'
+};
+const server = http.createServer(common.mustCall((req, res) => {
+  let retval = res.setHeader('testheader1', 'foo');
+
+  // Test that the setHeader returns the same response object.
+  assert.strictEqual(retval, res);
+
+  retval = res.setHeader('testheader2', 'bar').setHeader('testheader3', 'xyz');
+  // Test that chaining works for setHeader.
+  assert.deepStrictEqual(res.getHeaders(), expected);
+  res.end('ok');
+}));
+server.listen(0, () => {
+  http.get({ port: server.address().port }, common.mustCall((res) => {
+    res.on('data', () => {});
+    res.on('end', common.mustCall(() => {
+      server.close();
+    }));
+  }));
+});
diff --git a/test/parallel/test-http-should-keep-alive.js b/test/parallel/test-http-should-keep-alive.js
index 038af47ee4db97646d0f75e57ff9f48bae0322bc..dfc99cf4f3b3a123077cff0536c428f725a79add 100644
--- a/test/parallel/test-http-should-keep-alive.js
+++ b/test/parallel/test-http-should-keep-alive.js
@@ -32,7 +32,7 @@ const SERVER_RESPONSES = [
   'HTTP/1.0 200 ok\r\nContent-Length: 0\r\nConnection: close\r\n\r\n',
   'HTTP/1.1 200 ok\r\nContent-Length: 0\r\n\r\n',
   'HTTP/1.1 200 ok\r\nContent-Length: 0\r\nConnection: keep-alive\r\n\r\n',
-  'HTTP/1.1 200 ok\r\nContent-Length: 0\r\nConnection: close\r\n\r\n'
+  'HTTP/1.1 200 ok\r\nContent-Length: 0\r\nConnection: close\r\n\r\n',
 ];
 const SHOULD_KEEP_ALIVE = [
   false, // HTTP/1.0, default
@@ -40,7 +40,7 @@ const SHOULD_KEEP_ALIVE = [
   false, // HTTP/1.0, Connection: close
   true,  // HTTP/1.1, default
   true,  // HTTP/1.1, Connection: keep-alive
-  false  // HTTP/1.1, Connection: close
+  false,  // HTTP/1.1, Connection: close
 ];
 http.globalAgent.maxSockets = 5;
 
diff --git a/test/parallel/test-http-timeout-flag.js b/test/parallel/test-http-timeout-flag.js
deleted file mode 100644
index f816ce2f0a4f4bdb9bf49967598f8f087dfc5b03..0000000000000000000000000000000000000000
--- a/test/parallel/test-http-timeout-flag.js
+++ /dev/null
@@ -1,41 +0,0 @@
-'use strict';
-const common = require('../common');
-
-if (!common.hasCrypto)
-  common.skip('missing crypto');
-
-const fixtures = require('../common/fixtures');
-const http = require('http');
-const https = require('https');
-const http2 = require('http2');
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-
-// Make sure the defaults are correct.
-const servers = [
-  http.createServer(),
-  https.createServer({
-    key: fixtures.readKey('agent1-key.pem'),
-    cert: fixtures.readKey('agent1-cert.pem')
-  }),
-  http2.createServer()
-];
-
-for (const server of servers) {
-  assert.strictEqual(server.timeout, 120000);
-  server.close();
-}
-
-// Ensure that command line flag overrides the default timeout.
-const child1 = spawnSync(process.execPath, ['--http-server-default-timeout=10',
-                                            '-p', 'http.createServer().timeout'
-]);
-assert.strictEqual(+child1.stdout.toString().trim(), 10);
-
-// Ensure that the flag is whitelisted for NODE_OPTIONS.
-const env = Object.assign({}, process.env, {
-  NODE_OPTIONS: '--http-server-default-timeout=10'
-});
-const child2 = spawnSync(process.execPath,
-                         [ '-p', 'http.createServer().timeout'], { env });
-assert.strictEqual(+child2.stdout.toString().trim(), 10);
diff --git a/test/parallel/test-http-transfer-encoding-smuggling-legacy.js b/test/parallel/test-http-transfer-encoding-smuggling-legacy.js
deleted file mode 100644
index db618340df74a97999d3597cbd8d35bf7c60acc5..0000000000000000000000000000000000000000
--- a/test/parallel/test-http-transfer-encoding-smuggling-legacy.js
+++ /dev/null
@@ -1,47 +0,0 @@
-// Flags: --http-parser=legacy
-'use strict';
-
-const common = require('../common');
-
-const assert = require('assert');
-const http = require('http');
-const net = require('net');
-
-const msg = [
-  'POST / HTTP/1.1',
-  'Host: 127.0.0.1',
-  'Transfer-Encoding: chunked',
-  'Transfer-Encoding: chunked-false',
-  'Connection: upgrade',
-  '',
-  '1',
-  'A',
-  '0',
-  '',
-  'GET /flag HTTP/1.1',
-  'Host: 127.0.0.1',
-  '',
-  '',
-].join('\r\n');
-
-// Verify that the server is called only once even with a smuggled request.
-
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end();
-}, 1));
-
-function send(next) {
-  const client = net.connect(server.address().port, 'localhost');
-  client.setEncoding('utf8');
-  client.on('error', common.mustNotCall());
-  client.on('end', next);
-  client.write(msg);
-  client.resume();
-}
-
-server.listen(0, common.mustCall((err) => {
-  assert.ifError(err);
-  send(common.mustCall(() => {
-    server.close();
-  }));
-}));
diff --git a/test/parallel/test-http-transfer-encoding-smuggling.js b/test/parallel/test-http-transfer-encoding-smuggling.js
index 9d97db4c0a2ca1a336b2c54edaa2d5d3bb50aae8..77e719d37e143e51b353379fd68ad4e66cf21060 100644
--- a/test/parallel/test-http-transfer-encoding-smuggling.js
+++ b/test/parallel/test-http-transfer-encoding-smuggling.js
@@ -2,7 +2,6 @@
 
 const common = require('../common');
 
-const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
@@ -38,8 +37,7 @@ function send(next) {
   client.resume();
 }
 
-server.listen(0, common.mustCall((err) => {
-  assert.ifError(err);
+server.listen(0, common.mustSucceed(() => {
   send(common.mustCall(() => {
     server.close();
   }));
diff --git a/test/parallel/test-http-unix-socket-keep-alive.js b/test/parallel/test-http-unix-socket-keep-alive.js
index fd3c6a7b1608ff60c545dab5f3b3cadd3a99c11e..e1a2267e5c96894315e2d42c8a4b530ef03e7f6d 100644
--- a/test/parallel/test-http-unix-socket-keep-alive.js
+++ b/test/parallel/test-http-unix-socket-keep-alive.js
@@ -10,8 +10,7 @@ tmpdir.refresh();
 
 server.listen(common.PIPE, common.mustCall(() =>
   asyncLoop(makeKeepAliveRequest, 10, common.mustCall(() =>
-    server.getConnections(common.mustCall((err, conns) => {
-      assert.ifError(err);
+    server.getConnections(common.mustSucceed((conns) => {
       assert.strictEqual(conns, 1);
       server.close();
     }))
diff --git a/test/parallel/test-http-upgrade-client.js b/test/parallel/test-http-upgrade-client.js
index 8fe756f469f09a30ff178c422a8713dadce2f5fa..ea6972a18c7d49275dcb116ca45eca874ed622d6 100644
--- a/test/parallel/test-http-upgrade-client.js
+++ b/test/parallel/test-http-upgrade-client.js
@@ -60,8 +60,8 @@ server.listen(0, '127.0.0.1', common.mustCall(function() {
       ['Host', 'echo.websocket.org'],
       ['Connection', 'Upgrade'],
       ['Upgrade', 'websocket'],
-      ['Origin', 'http://www.websocket.org']
-    ]
+      ['Origin', 'http://www.websocket.org'],
+    ],
   ];
   const countdown = new Countdown(headers.length, () => server.close());
 
diff --git a/test/parallel/test-http-upgrade-server.js b/test/parallel/test-http-upgrade-server.js
index dc971690412baaa0413c8bd547588adf30770e15..5a660c4072a9a3adaeeeaaef2f8d608df30e3142 100644
--- a/test/parallel/test-http-upgrade-server.js
+++ b/test/parallel/test-http-upgrade-server.js
@@ -78,9 +78,7 @@ function writeReq(socket, data, encoding) {
 }
 
 
-/*-----------------------------------------------
-  connection: Upgrade with listener
------------------------------------------------*/
+// connection: Upgrade with listener
 function test_upgrade_with_listener() {
   const conn = net.createConnection(server.address().port);
   conn.setEncoding('utf8');
@@ -118,9 +116,7 @@ function test_upgrade_with_listener() {
   });
 }
 
-/*-----------------------------------------------
-  connection: Upgrade, no listener
------------------------------------------------*/
+// connection: Upgrade, no listener
 function test_upgrade_no_listener() {
   const conn = net.createConnection(server.address().port);
   conn.setEncoding('utf8');
@@ -144,9 +140,7 @@ function test_upgrade_no_listener() {
   });
 }
 
-/*-----------------------------------------------
-  connection: normal
------------------------------------------------*/
+// connection: normal
 function test_standard_http() {
   const conn = net.createConnection(server.address().port);
   conn.setEncoding('utf8');
@@ -175,9 +169,7 @@ server.listen(0, function() {
 });
 
 
-/*-----------------------------------------------
-  Fin.
------------------------------------------------*/
+// Fin.
 process.on('exit', function() {
   assert.strictEqual(requests_recv, 3);
   assert.strictEqual(requests_sent, 3);
diff --git a/test/parallel/test-http-url.parse-only-support-http-https-protocol.js b/test/parallel/test-http-url.parse-only-support-http-https-protocol.js
index 6dcb2a852e7199b4477cff9952a8c829c3157329..9b2a575ba7b1d73a7a5b1e3445f5daa6289e0e6d 100644
--- a/test/parallel/test-http-url.parse-only-support-http-https-protocol.js
+++ b/test/parallel/test-http-url.parse-only-support-http-https-protocol.js
@@ -31,7 +31,7 @@ const invalidUrls = [
   'ftp://www.example.com',
   'javascript:alert(\'hello\');',
   'xmpp:foo@bar.com',
-  'f://some.host/path'
+  'f://some.host/path',
 ];
 
 invalidUrls.forEach((invalid) => {
diff --git a/test/parallel/test-http-write-head-2.js b/test/parallel/test-http-write-head-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..a47d0d72e3be5699346b497c1164e66d7a3bf2ce
--- /dev/null
+++ b/test/parallel/test-http-write-head-2.js
@@ -0,0 +1,61 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+// Verify that ServerResponse.writeHead() works with arrays.
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.setHeader('test', '1');
+    res.writeHead(200, [ 'test', '2', 'test2', '2' ]);
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, common.mustCall((res) => {
+      assert.strictEqual(res.headers.test, '2');
+      assert.strictEqual(res.headers.test2, '2');
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+}
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.writeHead(200, [ 'test', '1', 'test2', '2' ]);
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, common.mustCall((res) => {
+      assert.strictEqual(res.headers.test, '1');
+      assert.strictEqual(res.headers.test2, '2');
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+}
+
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    try {
+      res.writeHead(200, [ 'test', '1', 'test2', '2', 'asd' ]);
+    } catch (err) {
+      assert.strictEqual(err.code, 'ERR_INVALID_ARG_VALUE');
+    }
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, common.mustCall((res) => {
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+}
diff --git a/test/parallel/test-http2-altsvc.js b/test/parallel/test-http2-altsvc.js
index 3a1a1cf62991b7f9f6ff6990682660567089a38a..c5abfc332653309c583789cc185d870963e14a62 100644
--- a/test/parallel/test-http2-altsvc.js
+++ b/test/parallel/test-http2-altsvc.js
@@ -6,7 +6,6 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const http2 = require('http2');
-const { URL } = require('url');
 const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
@@ -76,7 +75,7 @@ server.on('session', common.mustCall((session) => {
     'abc:',
     new URL('abc:'),
     { origin: 'null' },
-    { origin: '' }
+    { origin: '' },
   ].forEach((input) => {
     assert.throws(
       () => session.altsvc('h2=":8000', input),
diff --git a/test/parallel/test-http2-binding.js b/test/parallel/test-http2-binding.js
index bc86000f5941fdb9ff1bb82a7a4849da9add4432..e81a58dfe8a5c1552c9be89c1860341b88d45f9a 100644
--- a/test/parallel/test-http2-binding.js
+++ b/test/parallel/test-http2-binding.js
@@ -74,7 +74,7 @@ const expectedStatusCodes = {
   HTTP_STATUS_UNPROCESSABLE_ENTITY: 422,
   HTTP_STATUS_LOCKED: 423,
   HTTP_STATUS_FAILED_DEPENDENCY: 424,
-  HTTP_STATUS_UNORDERED_COLLECTION: 425,
+  HTTP_STATUS_TOO_EARLY: 425,
   HTTP_STATUS_UPGRADE_REQUIRED: 426,
   HTTP_STATUS_PRECONDITION_REQUIRED: 428,
   HTTP_STATUS_TOO_MANY_REQUESTS: 429,
@@ -170,7 +170,16 @@ const expectedHeaderNames = {
   HTTP2_HEADER_CONTENT_MD5: 'content-md5',
   HTTP2_HEADER_TE: 'te',
   HTTP2_HEADER_UPGRADE: 'upgrade',
-  HTTP2_HEADER_HTTP2_SETTINGS: 'http2-settings'
+  HTTP2_HEADER_HTTP2_SETTINGS: 'http2-settings',
+  HTTP2_HEADER_X_XSS_PROTECTION: 'x-xss-protection',
+  HTTP2_HEADER_ALT_SVC: 'alt-svc',
+  HTTP2_HEADER_CONTENT_SECURITY_POLICY: 'content-security-policy',
+  HTTP2_HEADER_EARLY_DATA: 'early-data',
+  HTTP2_HEADER_EXPECT_CT: 'expect-ct',
+  HTTP2_HEADER_ORIGIN: 'origin',
+  HTTP2_HEADER_PURPOSE: 'purpose',
+  HTTP2_HEADER_TIMING_ALLOW_ORIGIN: 'timing-allow-origin',
+  HTTP2_HEADER_X_FORWARDED_FOR: 'x-forwarded-for',
 };
 
 const expectedNGConstants = {
diff --git a/test/parallel/test-http2-buffersize.js b/test/parallel/test-http2-buffersize.js
index 2a21833f1cae3a461ff13aa47eb30255c0087c88..68bb4315fd068bbbf39ff6d97ed2c0b3f5721626 100644
--- a/test/parallel/test-http2-buffersize.js
+++ b/test/parallel/test-http2-buffersize.js
@@ -1,11 +1,11 @@
 'use strict';
 
-const { mustCall, hasCrypto, skip } = require('../common');
+const { mustCall, mustSucceed, hasCrypto, skip } = require('../common');
 if (!hasCrypto)
   skip('missing crypto');
 const assert = require('assert');
 const { createServer, connect } = require('http2');
-const { once } = require('events');
+const Countdown = require('../common/countdown');
 
 // This test ensures that `bufferSize` of Http2Session and Http2Stream work
 // as expected.
@@ -16,20 +16,18 @@ const { once } = require('events');
   const server = createServer();
 
   let client;
+  const countdown = new Countdown(kSockets, () => {
+    client.close();
+    server.close();
+  });
 
-  const getStream = async () => {
-    const [ stream ] = await once(server, 'stream');
+  server.on('stream', mustCall((stream) => {
     stream.on('data', mustCall());
     stream.on('end', mustCall());
-    stream.on('close', mustCall());
-    return once(stream, 'close');
-  };
-
-  const promises = [...new Array(kSockets)].map(getStream);
-  Promise.all(promises).then(mustCall(() => {
-    client.close();
-    server.close();
-  }));
+    stream.on('close', mustCall(() => {
+      countdown.dec();
+    }));
+  }, kSockets));
 
   server.listen(0, mustCall(() => {
     const authority = `http://localhost:${server.address().port}`;
@@ -42,7 +40,7 @@ const { once } = require('events');
       stream.on('data', () => {});
 
       for (let i = 0; i < kTimes; i += 1) {
-        stream.write(Buffer.allocUnsafe(kBufferSize), mustCall());
+        stream.write(Buffer.allocUnsafe(kBufferSize), mustSucceed());
         const expectedSocketBufferSize = kBufferSize * (i + 1);
         assert.strictEqual(stream.bufferSize, expectedSocketBufferSize);
       }
diff --git a/test/parallel/test-http2-clean-output.js b/test/parallel/test-http2-clean-output.js
new file mode 100644
index 0000000000000000000000000000000000000000..27b7c338c9a79444f61f737cab3838d31ba0421e
--- /dev/null
+++ b/test/parallel/test-http2-clean-output.js
@@ -0,0 +1,40 @@
+'use strict';
+
+const {
+  hasCrypto,
+  mustCall,
+  skip
+} = require('../common');
+if (!hasCrypto)
+  skip('missing crypto');
+
+const {
+  strictEqual
+} = require('assert');
+const {
+  createServer,
+  connect
+} = require('http2');
+const {
+  spawnSync
+} = require('child_process');
+
+// Validate that there is no unexpected output when
+// using http2
+if (process.argv[2] !== 'child') {
+  const {
+    stdout, stderr, status
+  } = spawnSync(process.execPath, [__filename, 'child'], { encoding: 'utf8' });
+  strictEqual(stderr, '');
+  strictEqual(stdout, '');
+  strictEqual(status, 0);
+} else {
+  const server = createServer();
+  server.listen(0, mustCall(() => {
+    const client = connect(`http://localhost:${server.address().port}`);
+    client.on('connect', mustCall(() => {
+      client.close();
+      server.close();
+    }));
+  }));
+}
diff --git a/test/parallel/test-http2-client-destroy.js b/test/parallel/test-http2-client-destroy.js
index 88850b9db51ccc8452bc13de2d362f53efdb3098..e226082245da954c33c937471d57804ddce6d906 100644
--- a/test/parallel/test-http2-client-destroy.js
+++ b/test/parallel/test-http2-client-destroy.js
@@ -1,4 +1,4 @@
-// Flags: --expose-internals
+// Flags: --expose-internals --experimental-abortcontroller
 
 'use strict';
 
@@ -8,6 +8,7 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const h2 = require('http2');
 const { kSocket } = require('internal/http2/util');
+const { kEvents } = require('internal/event_target');
 const Countdown = require('../common/countdown');
 
 {
@@ -15,7 +16,7 @@ const Countdown = require('../common/countdown');
   server.listen(0, common.mustCall(() => {
     const destroyCallbacks = [
       (client) => client.destroy(),
-      (client) => client[kSocket].destroy()
+      (client) => client[kSocket].destroy(),
     ];
 
     const countdown = new Countdown(destroyCallbacks.length, () => {
@@ -77,6 +78,7 @@ const Countdown = require('../common/countdown');
     };
 
     assert.throws(() => client.setNextStreamID(), sessionError);
+    assert.throws(() => client.setLocalWindowSize(), sessionError);
     assert.throws(() => client.ping(), sessionError);
     assert.throws(() => client.settings({}), sessionError);
     assert.throws(() => client.goaway(), sessionError);
@@ -87,6 +89,7 @@ const Countdown = require('../common/countdown');
     // so that state.destroyed is set to true
     setImmediate(() => {
       assert.throws(() => client.setNextStreamID(), sessionError);
+      assert.throws(() => client.setLocalWindowSize(), sessionError);
       assert.throws(() => client.ping(), sessionError);
       assert.throws(() => client.settings({}), sessionError);
       assert.throws(() => client.goaway(), sessionError);
@@ -95,7 +98,7 @@ const Countdown = require('../common/countdown');
     });
 
     req.resume();
-    req.on('end', common.mustCall());
+    req.on('end', common.mustNotCall());
     req.on('close', common.mustCall(() => server.close()));
   }));
 }
@@ -165,3 +168,76 @@ const Countdown = require('../common/countdown');
     req.on('close', common.mustCall(() => server.close()));
   }));
 }
+
+// Destroy with AbortSignal
+{
+  const server = h2.createServer();
+  const controller = new AbortController();
+
+  server.on('stream', common.mustNotCall());
+  server.listen(0, common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    client.on('close', common.mustCall());
+
+    const { signal } = controller;
+    assert.strictEqual(signal[kEvents].get('abort'), undefined);
+
+    client.on('error', common.mustCall(() => {
+      // After underlying stream dies, signal listener detached
+      assert.strictEqual(signal[kEvents].get('abort'), undefined);
+    }));
+
+    const req = client.request({}, { signal });
+
+    req.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ABORT_ERR');
+      assert.strictEqual(err.name, 'AbortError');
+    }));
+    req.on('close', common.mustCall(() => server.close()));
+
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, false);
+    // Signal listener attached
+    assert.strictEqual(signal[kEvents].get('abort').size, 1);
+
+    controller.abort();
+
+    assert.strictEqual(req.aborted, false);
+    assert.strictEqual(req.destroyed, true);
+  }));
+}
+// Pass an already destroyed signal to abort immediately.
+{
+  const server = h2.createServer();
+  const controller = new AbortController();
+
+  server.on('stream', common.mustNotCall());
+  server.listen(0, common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    client.on('close', common.mustCall());
+
+    const { signal } = controller;
+    controller.abort();
+
+    assert.strictEqual(signal[kEvents].get('abort'), undefined);
+
+    client.on('error', common.mustCall(() => {
+      // After underlying stream dies, signal listener detached
+      assert.strictEqual(signal[kEvents].get('abort'), undefined);
+    }));
+
+    const req = client.request({}, { signal });
+    // Signal already aborted, so no event listener attached.
+    assert.strictEqual(signal[kEvents].get('abort'), undefined);
+
+    assert.strictEqual(req.aborted, false);
+    // Destroyed on same tick as request made
+    assert.strictEqual(req.destroyed, true);
+
+    req.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ABORT_ERR');
+      assert.strictEqual(err.name, 'AbortError');
+    }));
+    req.on('close', common.mustCall(() => server.close()));
+  }));
+}
diff --git a/test/parallel/test-http2-client-jsstream-destroy.js b/test/parallel/test-http2-client-jsstream-destroy.js
new file mode 100644
index 0000000000000000000000000000000000000000..7e44241e985a64c174c4e916fd350f22cd4becd5
--- /dev/null
+++ b/test/parallel/test-http2-client-jsstream-destroy.js
@@ -0,0 +1,58 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const h2 = require('http2');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+const { Duplex } = require('stream');
+
+const server = h2.createSecureServer({
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+});
+
+class JSSocket extends Duplex {
+  constructor(socket) {
+    super({ emitClose: true });
+    socket.on('close', () => this.destroy());
+    socket.on('data', (data) => this.push(data));
+    this.socket = socket;
+  }
+
+  _write(data, encoding, callback) {
+    this.socket.write(data, encoding, callback);
+  }
+
+  _read(size) {
+  }
+
+  _final(cb) {
+    cb();
+  }
+}
+
+server.listen(0, common.mustCall(function() {
+  const socket = tls.connect({
+    rejectUnauthorized: false,
+    host: 'localhost',
+    port: this.address().port,
+    ALPNProtocols: ['h2']
+  }, () => {
+    const proxy = new JSSocket(socket);
+    const client = h2.connect(`https://localhost:${this.address().port}`, {
+      createConnection: () => proxy
+    });
+    const req = client.request();
+
+    server.on('request', () => {
+      socket.destroy();
+    });
+
+    req.on('close', common.mustCall(() => {
+      client.close();
+      server.close();
+    }));
+  });
+}));
diff --git a/test/parallel/test-http2-client-onconnect-errors.js b/test/parallel/test-http2-client-onconnect-errors.js
index 788386ae864e169c1224141f30572b4f46a7081c..04cbfe5befaeec4ca2a9a2a6253d93e52c9d27af 100644
--- a/test/parallel/test-http2-client-onconnect-errors.js
+++ b/test/parallel/test-http2-client-onconnect-errors.js
@@ -21,7 +21,7 @@ const { NghttpError } = require('internal/http2/util');
 
 const specificTestKeys = [
   'NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE',
-  'NGHTTP2_ERR_INVALID_ARGUMENT'
+  'NGHTTP2_ERR_INVALID_ARGUMENT',
 ];
 
 const specificTests = [
diff --git a/test/parallel/test-http2-client-setLocalWindowSize.js b/test/parallel/test-http2-client-setLocalWindowSize.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e3b57ed0c1a6bea1d02ad346dac94f7a2bb0c00
--- /dev/null
+++ b/test/parallel/test-http2-client-setLocalWindowSize.js
@@ -0,0 +1,121 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const http2 = require('http2');
+
+{
+  const server = http2.createServer();
+  server.on('stream', common.mustNotCall((stream) => {
+    stream.respond();
+    stream.end('ok');
+  }));
+
+  const types = {
+    boolean: true,
+    function: () => {},
+    number: 1,
+    object: {},
+    array: [],
+    null: null,
+  };
+
+  server.listen(0, common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    client.on('connect', common.mustCall(() => {
+      const outOfRangeNum = 2 ** 32;
+      assert.throws(
+        () => client.setLocalWindowSize(outOfRangeNum),
+        {
+          name: 'RangeError',
+          code: 'ERR_OUT_OF_RANGE',
+          message: 'The value of "windowSize" is out of range.' +
+            ' It must be >= 0 && <= 2147483647. Received ' + outOfRangeNum
+        }
+      );
+
+      // Throw if something other than number is passed to setLocalWindowSize
+      Object.entries(types).forEach(([type, value]) => {
+        if (type === 'number') {
+          return;
+        }
+
+        assert.throws(
+          () => client.setLocalWindowSize(value),
+          {
+            name: 'TypeError',
+            code: 'ERR_INVALID_ARG_TYPE',
+            message: 'The "windowSize" argument must be of type number.' +
+                    common.invalidArgTypeHelper(value)
+          }
+        );
+      });
+
+      server.close();
+      client.close();
+    }));
+  }));
+}
+
+{
+  const server = http2.createServer();
+  server.on('stream', common.mustNotCall((stream) => {
+    stream.respond();
+    stream.end('ok');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    client.on('connect', common.mustCall(() => {
+      const windowSize = 2 ** 20;
+      const defaultSetting = http2.getDefaultSettings();
+      client.setLocalWindowSize(windowSize);
+
+      assert.strictEqual(client.state.effectiveLocalWindowSize, windowSize);
+      assert.strictEqual(client.state.localWindowSize, windowSize);
+      assert.strictEqual(
+        client.state.remoteWindowSize,
+        defaultSetting.initialWindowSize
+      );
+
+      server.close();
+      client.close();
+    }));
+  }));
+}
+
+{
+  const server = http2.createServer();
+  server.on('stream', common.mustNotCall((stream) => {
+    stream.respond();
+    stream.end('ok');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    client.on('connect', common.mustCall(() => {
+      const windowSize = 20;
+      const defaultSetting = http2.getDefaultSettings();
+      client.setLocalWindowSize(windowSize);
+
+      assert.strictEqual(client.state.effectiveLocalWindowSize, windowSize);
+      assert.strictEqual(
+        client.state.localWindowSize,
+        defaultSetting.initialWindowSize
+      );
+      assert.strictEqual(
+        client.state.remoteWindowSize,
+        defaultSetting.initialWindowSize
+      );
+
+      server.close();
+      client.close();
+    }));
+  }));
+}
diff --git a/test/parallel/test-http2-client-settings-before-connect.js b/test/parallel/test-http2-client-settings-before-connect.js
index a02a26446995aca38d1c35a9ec118c7065b54412..406ddd86ab5e9b7b6644fe5d8dcde6741913e787 100644
--- a/test/parallel/test-http2-client-settings-before-connect.js
+++ b/test/parallel/test-http2-client-settings-before-connect.js
@@ -38,7 +38,7 @@ server.listen(0, common.mustCall(() => {
     ['enablePush', 1, TypeError],
     ['enablePush', 0, TypeError],
     ['enablePush', null, TypeError],
-    ['enablePush', {}, TypeError]
+    ['enablePush', {}, TypeError],
   ].forEach(([name, value, errorType]) =>
     assert.throws(
       () => client.settings({ [name]: value }),
diff --git a/test/parallel/test-http2-client-stream-destroy-before-connect.js b/test/parallel/test-http2-client-stream-destroy-before-connect.js
index 09667750ae16fd091b9e102be9736cee9b0e73c3..087b06d01bd837a7fd2614b113486a3d781bd896 100644
--- a/test/parallel/test-http2-client-stream-destroy-before-connect.js
+++ b/test/parallel/test-http2-client-stream-destroy-before-connect.js
@@ -50,5 +50,5 @@ server.listen(0, common.mustCall(() => {
 
   req.on('response', common.mustNotCall());
   req.resume();
-  req.on('end', common.mustCall());
+  req.on('end', common.mustNotCall());
 }));
diff --git a/test/parallel/test-http2-client-upload-reject.js b/test/parallel/test-http2-client-upload-reject.js
index 678114130e3dba8980a0c92dab65e655e5793525..723449303129fcc815a234fdcf58ff7248ff4564 100644
--- a/test/parallel/test-http2-client-upload-reject.js
+++ b/test/parallel/test-http2-client-upload-reject.js
@@ -14,9 +14,7 @@ const loc = fixtures.path('person-large.jpg');
 
 assert(fs.existsSync(loc));
 
-fs.readFile(loc, common.mustCall((err, data) => {
-  assert.ifError(err);
-
+fs.readFile(loc, common.mustSucceed((data) => {
   const server = http2.createServer();
 
   server.on('stream', common.mustCall((stream) => {
diff --git a/test/parallel/test-http2-client-upload.js b/test/parallel/test-http2-client-upload.js
index c5b052d2fec70257d7d6157b9cbecec8163f1400..f7f170126c1557a8de7e0c268ff2996be5fc123a 100644
--- a/test/parallel/test-http2-client-upload.js
+++ b/test/parallel/test-http2-client-upload.js
@@ -16,8 +16,7 @@ let fileData;
 
 assert(fs.existsSync(loc));
 
-fs.readFile(loc, common.mustCall((err, data) => {
-  assert.ifError(err);
+fs.readFile(loc, common.mustSucceed((data) => {
   fileData = data;
 
   const server = http2.createServer();
diff --git a/test/parallel/test-http2-client-write-empty-string.js b/test/parallel/test-http2-client-write-empty-string.js
index 087a498a37b46291415bf2e8da419d5d3733fa05..f0f0b8f012496485a5982216afcfdcd730452033 100644
--- a/test/parallel/test-http2-client-write-empty-string.js
+++ b/test/parallel/test-http2-client-write-empty-string.js
@@ -9,7 +9,7 @@ const http2 = require('http2');
 
 for (const chunkSequence of [
   [ '' ],
-  [ '', '' ]
+  [ '', '' ],
 ]) {
   const server = http2.createServer();
   server.on('stream', common.mustCall((stream, headers, flags) => {
diff --git a/test/parallel/test-http2-compat-client-upload-reject.js b/test/parallel/test-http2-compat-client-upload-reject.js
index 6e3fee2e7c2ce354f6b0a13a119fc81be0f2edb5..2378ef27dfa6249c21ddce688e0c754ebe1755e2 100644
--- a/test/parallel/test-http2-compat-client-upload-reject.js
+++ b/test/parallel/test-http2-compat-client-upload-reject.js
@@ -14,9 +14,7 @@ const loc = fixtures.path('person-large.jpg');
 
 assert(fs.existsSync(loc));
 
-fs.readFile(loc, common.mustCall((err, data) => {
-  assert.ifError(err);
-
+fs.readFile(loc, common.mustSucceed((data) => {
   const server = http2.createServer(common.mustCall((req, res) => {
     setImmediate(() => {
       res.writeHead(400);
diff --git a/test/parallel/test-http2-compat-serverrequest-trailers.js b/test/parallel/test-http2-compat-serverrequest-trailers.js
index 735ff1345e1a39e5cf0bd44694925d9377aaeab0..620ae69029a375ec312a7b74459c486d0ab463d1 100644
--- a/test/parallel/test-http2-compat-serverrequest-trailers.js
+++ b/test/parallel/test-http2-compat-serverrequest-trailers.js
@@ -35,7 +35,7 @@ server.listen(0, common.mustCall(function() {
         'x-foo',
         'OxOxOxO',
         'x-foo-test',
-        'test, test'
+        'test, test',
       ], request.rawTrailers);
       assert.strictEqual(data, 'test\ntest');
       response.end();
diff --git a/test/parallel/test-http2-compat-serverresponse-createpushresponse.js b/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
index 731c2f8709a432b97f11b9012189a22359f1d794..f25eab444f2dfd4fae9fcaa32c9374b951de3e87 100644
--- a/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
+++ b/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
@@ -40,8 +40,7 @@ const server = h2.createServer((request, response) => {
   response.createPushResponse({
     ':path': '/pushed',
     ':method': 'GET'
-  }, common.mustCall((error, push) => {
-    assert.ifError(error);
+  }, common.mustSucceed((push) => {
     assert.strictEqual(push.stream.id % 2, 0);
     push.end(pushExpect);
     response.end();
diff --git a/test/parallel/test-http2-compat-serverresponse-destroy.js b/test/parallel/test-http2-compat-serverresponse-destroy.js
index 0d73c82c2d862f27b81e1c83cefa086e305ac0cc..94d67330e86061e80783e1a79ae5ebf7c5a26fc7 100644
--- a/test/parallel/test-http2-compat-serverresponse-destroy.js
+++ b/test/parallel/test-http2-compat-serverresponse-destroy.js
@@ -11,7 +11,7 @@ const Countdown = require('../common/countdown');
 
 const errors = [
   'test-error',
-  Error('test')
+  Error('test'),
 ];
 let nextError;
 
diff --git a/test/parallel/test-http2-compat-serverresponse-headers.js b/test/parallel/test-http2-compat-serverresponse-headers.js
index 19720b1e41f2bda8b5bc4def62914ad6f70aa7c1..8b9b6d69278c601b1340f17f7bd8ab9fe1564aa8 100644
--- a/test/parallel/test-http2-compat-serverresponse-headers.js
+++ b/test/parallel/test-http2-compat-serverresponse-headers.js
@@ -58,7 +58,7 @@ server.listen(0, common.mustCall(function() {
       ':method',
       ':path',
       ':authority',
-      ':scheme'
+      ':scheme',
     ].forEach((header) => assert.throws(
       () => response.setHeader(header, 'foobar'),
       {
diff --git a/test/parallel/test-http2-compat-serverresponse-writehead-array.js b/test/parallel/test-http2-compat-serverresponse-writehead-array.js
index d856165d090f46572334711947d5184e64c2105e..c28f7329c1d0a1aa442067ec4fc49c93686b3fd7 100644
--- a/test/parallel/test-http2-compat-serverresponse-writehead-array.js
+++ b/test/parallel/test-http2-compat-serverresponse-writehead-array.js
@@ -14,7 +14,7 @@ server.listen(0, common.mustCall(() => {
   server.once('request', common.mustCall((request, response) => {
     const returnVal = response.writeHead(200, [
       ['foo', 'bar'],
-      ['ABC', 123]
+      ['ABC', 123],
     ]);
     assert.strictEqual(returnVal, response);
     response.end(common.mustCall(() => { server.close(); }));
diff --git a/test/parallel/test-http2-connect-method.js b/test/parallel/test-http2-connect-method.js
index d5b4c4bd2749502b74262981ceba9876ca6338e2..4ada9f475535284c753d9af2e2f4421b1c901507 100644
--- a/test/parallel/test-http2-connect-method.js
+++ b/test/parallel/test-http2-connect-method.js
@@ -6,7 +6,6 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const net = require('net');
 const http2 = require('http2');
-const { URL } = require('url');
 
 const {
   HTTP2_HEADER_METHOD,
diff --git a/test/parallel/test-http2-connect-tls-with-delay.js b/test/parallel/test-http2-connect-tls-with-delay.js
new file mode 100644
index 0000000000000000000000000000000000000000..0b3753ae38364206c2b4b6e4e12351d1d8db5010
--- /dev/null
+++ b/test/parallel/test-http2-connect-tls-with-delay.js
@@ -0,0 +1,50 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const http2 = require('http2');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const serverOptions = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const server = http2.createSecureServer(serverOptions, (req, res) => {
+  res.end();
+});
+
+server.listen(0, '127.0.0.1', common.mustCall(() => {
+  const options = {
+    ALPNProtocols: ['h2'],
+    host: '127.0.0.1',
+    servername: 'localhost',
+    port: server.address().port,
+    rejectUnauthorized: false
+  };
+
+  const socket = tls.connect(options, async () => {
+    socket.once('readable', () => {
+      const client = http2.connect(
+        'https://localhost:' + server.address().port,
+        { ...options, createConnection: () => socket }
+      );
+
+      client.once('remoteSettings', common.mustCall(() => {
+        const req = client.request({
+          ':path': '/'
+        });
+        req.on('data', () => req.resume());
+        req.on('end', common.mustCall(() => {
+          client.close();
+          req.close();
+          server.close();
+        }));
+        req.end();
+      }));
+    });
+  });
+}));
diff --git a/test/parallel/test-http2-cookies.js b/test/parallel/test-http2-cookies.js
index fcd6b847587470a791d037ac48e07280b5d43914..a270c1d73b1ba114113cb983fad545d9e09c1f9d 100644
--- a/test/parallel/test-http2-cookies.js
+++ b/test/parallel/test-http2-cookies.js
@@ -11,7 +11,7 @@ const server = h2.createServer();
 const setCookie = [
   'a=b',
   'c=d; Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly',
-  'e=f'
+  'e=f',
 ];
 
 // We use the lower-level API here
diff --git a/test/parallel/test-http2-create-client-connect.js b/test/parallel/test-http2-create-client-connect.js
index 8a4fc9a1d0e075cbaa226251a59b192106e6f9af..9859fe106771556706ee73ef66bffc45e25d8078 100644
--- a/test/parallel/test-http2-create-client-connect.js
+++ b/test/parallel/test-http2-create-client-connect.js
@@ -9,7 +9,6 @@ if (!common.hasCrypto)
 const fixtures = require('../common/fixtures');
 const h2 = require('http2');
 const url = require('url');
-const URL = url.URL;
 
 {
   const server = h2.createServer();
@@ -23,7 +22,7 @@ const URL = url.URL;
       [new URL(`http://localhost:${port}`)],
       [url.parse(`http://localhost:${port}`)],
       [{ port }, { protocol: 'http:' }],
-      [{ port, hostname: '127.0.0.1' }, { protocol: 'http:' }]
+      [{ port, hostname: '127.0.0.1' }, { protocol: 'http:' }],
     ];
 
     const serverClose = new Countdown(items.length + 1,
@@ -67,7 +66,7 @@ const URL = url.URL;
       [new URL(`https://localhost:${port}`), opts],
       [url.parse(`https://localhost:${port}`), opts],
       [{ port: port, protocol: 'https:' }, opts],
-      [{ port: port, hostname: '127.0.0.1', protocol: 'https:' }, opts]
+      [{ port: port, hostname: '127.0.0.1', protocol: 'https:' }, opts],
     ];
 
     const serverClose = new Countdown(items.length,
diff --git a/test/parallel/test-http2-create-client-secure-session.js b/test/parallel/test-http2-create-client-secure-session.js
index 8b2aa1c168cb5eefe21980878abdf60fb093819c..4303786b3e435d3d85dd932a3cd2e4ae46ec9f4b 100644
--- a/test/parallel/test-http2-create-client-secure-session.js
+++ b/test/parallel/test-http2-create-client-secure-session.js
@@ -73,7 +73,7 @@ function verifySecureSession(key, cert, ca, opts) {
       assert.strictEqual(jsonData.servername,
                          opts.servername || 'localhost');
       assert.strictEqual(jsonData.alpnProtocol, 'h2');
-      server.close(common.mustCall());
+      server.close(common.mustSucceed());
       client[kSocket].destroy();
     }));
   }));
diff --git a/test/parallel/test-http2-debug.js b/test/parallel/test-http2-debug.js
index 0d6b5f677c234bcd1aa8037b12f2144640e3ba63..a465f74af24698d1a9bf64cb98adf0984894c155 100644
--- a/test/parallel/test-http2-debug.js
+++ b/test/parallel/test-http2-debug.js
@@ -9,7 +9,7 @@ const path = require('path');
 process.env.NODE_DEBUG_NATIVE = 'http2';
 process.env.NODE_DEBUG = 'http2';
 const { stdout, stderr } = child_process.spawnSync(process.execPath, [
-  path.resolve(__dirname, 'test-http2-ping.js')
+  path.resolve(__dirname, 'test-http2-ping.js'),
 ], { encoding: 'utf8' });
 
 assert(stderr.match(/Setting the NODE_DEBUG environment variable to 'http2' can expose sensitive data \(such as passwords, tokens and authentication headers\) in the resulting log\.\r?\n/),
diff --git a/test/parallel/test-http2-destroy-after-write.js b/test/parallel/test-http2-destroy-after-write.js
new file mode 100644
index 0000000000000000000000000000000000000000..399df015b8879eadaf196bba5c5caf153a652e39
--- /dev/null
+++ b/test/parallel/test-http2-destroy-after-write.js
@@ -0,0 +1,37 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+
+const http2 = require('http2');
+const assert = require('assert');
+
+const server = http2.createServer();
+
+server.on('session', common.mustCall(function(session) {
+  session.on('stream', common.mustCall(function(stream) {
+    stream.on('end', common.mustCall(function() {
+      this.respond({
+        ':status': 200
+      });
+      this.write('foo');
+      this.destroy();
+    }));
+    stream.resume();
+  }));
+}));
+
+server.listen(0, function() {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const stream = client.request({ ':method': 'POST' });
+  stream.on('response', common.mustCall(function(headers) {
+    assert.strictEqual(headers[':status'], 200);
+  }));
+  stream.on('close', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+  stream.resume();
+  stream.end();
+});
diff --git a/test/parallel/test-http2-dont-lose-data.js b/test/parallel/test-http2-dont-lose-data.js
index c73208f955504421611261cda54584c58c9c795a..17cb610767785b47d572a13d0e5e632fc0fb8483 100644
--- a/test/parallel/test-http2-dont-lose-data.js
+++ b/test/parallel/test-http2-dont-lose-data.js
@@ -11,8 +11,7 @@ const server = http2.createServer();
 server.on('stream', (s) => {
   assert(s.pushAllowed);
 
-  s.pushStream({ ':path': '/file' }, common.mustCall((err, pushStream) => {
-    assert.ifError(err);
+  s.pushStream({ ':path': '/file' }, common.mustSucceed((pushStream) => {
     pushStream.respond();
     pushStream.end('a push stream');
   }));
diff --git a/test/parallel/test-http2-empty-frame-without-eof.js b/test/parallel/test-http2-empty-frame-without-eof.js
new file mode 100644
index 0000000000000000000000000000000000000000..02da78d940a92d63e6efa9b1195a5862af0f54e3
--- /dev/null
+++ b/test/parallel/test-http2-empty-frame-without-eof.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const { readSync } = require('../common/fixtures');
+const net = require('net');
+const http2 = require('http2');
+const { once } = require('events');
+
+async function main() {
+  const blobWithEmptyFrame = readSync('emptyframe.http2');
+  const server = net.createServer((socket) => {
+    socket.end(blobWithEmptyFrame);
+  }).listen(0);
+  await once(server, 'listening');
+
+  for (const maxSessionInvalidFrames of [0, 2]) {
+    const client = http2.connect(`http://localhost:${server.address().port}`, {
+      maxSessionInvalidFrames
+    });
+    const stream = client.request({
+      ':method': 'GET',
+      ':path': '/'
+    });
+    if (maxSessionInvalidFrames) {
+      stream.on('error', common.mustNotCall());
+      client.on('error', common.mustNotCall());
+    } else {
+      stream.on('error', common.mustCall());
+      client.on('error', common.mustCall());
+    }
+    stream.resume();
+    await once(stream, 'end');
+    client.close();
+  }
+  server.close();
+}
+
+main().then(common.mustCall());
diff --git a/test/parallel/test-http2-error-order.js b/test/parallel/test-http2-error-order.js
index 8bf0f03dba8ea34310bf5cbe718c2ccac2830b41..4ea71cf1d00ca4303d2cd952f481135861aaa80f 100644
--- a/test/parallel/test-http2-error-order.js
+++ b/test/parallel/test-http2-error-order.js
@@ -12,7 +12,7 @@ const expected = [
   'Stream:created',
   'Stream:error',
   'Stream:close',
-  'Request:error'
+  'Request:error',
 ];
 
 const server = createServer();
diff --git a/test/parallel/test-http2-getpackedsettings.js b/test/parallel/test-http2-getpackedsettings.js
index 851888771b6bd5314410d9e82d1cbabe329ff14b..4f5970522f13b384923a3cc8afeeac7895e7e94b 100644
--- a/test/parallel/test-http2-getpackedsettings.js
+++ b/test/parallel/test-http2-getpackedsettings.js
@@ -7,11 +7,11 @@ const assert = require('assert');
 const http2 = require('http2');
 
 const check = Buffer.from([0x00, 0x01, 0x00, 0x00, 0x10, 0x00,
+                           0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
                            0x00, 0x03, 0xff, 0xff, 0xff, 0xff,
-                           0x00, 0x05, 0x00, 0x00, 0x40, 0x00,
                            0x00, 0x04, 0x00, 0x00, 0xff, 0xff,
+                           0x00, 0x05, 0x00, 0x00, 0x40, 0x00,
                            0x00, 0x06, 0x00, 0x00, 0xff, 0xff,
-                           0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
                            0x00, 0x08, 0x00, 0x00, 0x00, 0x00]);
 const val = http2.getPackedSettings(http2.getDefaultSettings());
 assert.deepStrictEqual(val, check);
@@ -28,7 +28,7 @@ assert.deepStrictEqual(val, check);
   ['maxHeaderListSize', 0],
   ['maxHeaderListSize', 2 ** 32 - 1],
   ['maxHeaderSize', 0],
-  ['maxHeaderSize', 2 ** 32 - 1]
+  ['maxHeaderSize', 2 ** 32 - 1],
 ].forEach((i) => {
   // Valid options should not throw.
   http2.getPackedSettings({ [i[0]]: i[1] });
@@ -49,7 +49,7 @@ http2.getPackedSettings({ enablePush: false });
   ['maxHeaderListSize', -1],
   ['maxHeaderListSize', 2 ** 32],
   ['maxHeaderSize', -1],
-  ['maxHeaderSize', 2 ** 32]
+  ['maxHeaderSize', 2 ** 32],
 ].forEach((i) => {
   assert.throws(() => {
     http2.getPackedSettings({ [i[0]]: i[1] });
@@ -61,7 +61,7 @@ http2.getPackedSettings({ enablePush: false });
 });
 
 [
-  1, null, '', Infinity, new Date(), {}, NaN, [false]
+  1, null, '', Infinity, new Date(), {}, NaN, [false],
 ].forEach((i) => {
   assert.throws(() => {
     http2.getPackedSettings({ enablePush: i });
@@ -73,7 +73,7 @@ http2.getPackedSettings({ enablePush: false });
 });
 
 [
-  1, null, '', Infinity, new Date(), {}, NaN, [false]
+  1, null, '', Infinity, new Date(), {}, NaN, [false],
 ].forEach((i) => {
   assert.throws(() => {
     http2.getPackedSettings({ enableConnectProtocol: i });
@@ -87,12 +87,13 @@ http2.getPackedSettings({ enablePush: false });
 {
   const check = Buffer.from([
     0x00, 0x01, 0x00, 0x00, 0x00, 0x64,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
     0x00, 0x03, 0x00, 0x00, 0x00, 0xc8,
-    0x00, 0x05, 0x00, 0x00, 0x4e, 0x20,
     0x00, 0x04, 0x00, 0x00, 0x00, 0x64,
+    0x00, 0x05, 0x00, 0x00, 0x4e, 0x20,
     0x00, 0x06, 0x00, 0x00, 0x00, 0x64,
-    0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
-    0x00, 0x08, 0x00, 0x00, 0x00, 0x00]);
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+  ]);
 
   const packed = http2.getPackedSettings({
     headerTableSize: 100,
@@ -132,8 +133,8 @@ http2.getPackedSettings({ enablePush: false });
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError',
       message:
-        'The "buf" argument must be an instance of Buffer, TypedArray, or ' +
-        `DataView.${common.invalidArgTypeHelper(input)}`
+        'The "buf" argument must be an instance of Buffer or TypedArray.' +
+        common.invalidArgTypeHelper(input)
     });
   });
 
@@ -158,6 +159,58 @@ http2.getPackedSettings({ enablePush: false });
   assert.strictEqual(settings.enableConnectProtocol, false);
 }
 
+{
+  const packed = new Uint16Array([
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x64,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0xc8,
+    0x00, 0x05, 0x00, 0x00, 0x4e, 0x20,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x64,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x64,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x00]);
+
+  assert.throws(() => {
+    http2.getUnpackedSettings(packed.slice(5));
+  }, {
+    code: 'ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH',
+    name: 'RangeError',
+    message: 'Packed settings length must be a multiple of six'
+  });
+
+  const settings = http2.getUnpackedSettings(packed);
+
+  assert(settings);
+  assert.strictEqual(settings.headerTableSize, 100);
+  assert.strictEqual(settings.initialWindowSize, 100);
+  assert.strictEqual(settings.maxFrameSize, 20000);
+  assert.strictEqual(settings.maxConcurrentStreams, 200);
+  assert.strictEqual(settings.maxHeaderListSize, 100);
+  assert.strictEqual(settings.maxHeaderSize, 100);
+  assert.strictEqual(settings.enablePush, true);
+  assert.strictEqual(settings.enableConnectProtocol, false);
+}
+
+{
+  const packed = new DataView(Buffer.from([
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x64,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0xc8,
+    0x00, 0x05, 0x00, 0x00, 0x4e, 0x20,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x64,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x64,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x00]).buffer);
+
+  assert.throws(() => {
+    http2.getUnpackedSettings(packed);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+    message:
+        'The "buf" argument must be an instance of Buffer or TypedArray.' +
+        common.invalidArgTypeHelper(packed)
+  });
+}
+
 {
   const packed = Buffer.from([
     0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
diff --git a/test/parallel/test-http2-head-request.js b/test/parallel/test-http2-head-request.js
index 9eaa737503b377091b5edf954f5047433dd91357..6cf0a4d81cd41c933b35e02b0d919b6c656f7a5e 100644
--- a/test/parallel/test-http2-head-request.js
+++ b/test/parallel/test-http2-head-request.js
@@ -10,7 +10,7 @@ const errCheck = common.expectsError({
   name: 'Error',
   code: 'ERR_STREAM_WRITE_AFTER_END',
   message: 'write after end'
-}, 2);
+}, 1);
 
 const {
   HTTP2_HEADER_PATH,
@@ -41,12 +41,6 @@ server.listen(0, () => {
     [HTTP2_HEADER_PATH]: '/'
   });
 
-  // Because it is a HEAD request, the payload is meaningless. The
-  // option.endStream flag is set automatically making the stream
-  // non-writable.
-  req.on('error', errCheck);
-  req.write('data');
-
   req.on('response', common.mustCall((headers, flags) => {
     assert.strictEqual(headers[HTTP2_HEADER_STATUS], 200);
     assert.strictEqual(flags, 5); // The end of stream flag is set
diff --git a/test/parallel/test-http2-max-settings.js b/test/parallel/test-http2-max-settings.js
index 2eae223d21bcc7388cb15969b6a3934acc6b3a7f..0ae792855ae3d566503ba40f9fafd6b3f5a117dd 100644
--- a/test/parallel/test-http2-max-settings.js
+++ b/test/parallel/test-http2-max-settings.js
@@ -27,7 +27,8 @@ server.listen(0, common.mustCall(() => {
         // The actual settings values do not matter.
         headerTableSize: 1000,
         enablePush: false,
-      } });
+      },
+    });
 
   client.on('error', common.mustCall(() => {
     server.close();
diff --git a/test/parallel/test-http2-misbehaving-flow-control-paused.js b/test/parallel/test-http2-misbehaving-flow-control-paused.js
index d8f37c4394aa94c80b6d056c7b248aa73166ab0b..e54bb83238e7faa1dc855dae21829cd8ac8cae0e 100644
--- a/test/parallel/test-http2-misbehaving-flow-control-paused.js
+++ b/test/parallel/test-http2-misbehaving-flow-control-paused.js
@@ -25,13 +25,13 @@ const preamble = Buffer.from([
   0xa0, 0xe4, 0x1d, 0x13, 0x9d, 0x09, 0xb8, 0xf0, 0x1e, 0x07, 0x53,
   0x03, 0x2a, 0x2f, 0x2a, 0x90, 0x7a, 0x8a, 0xaa, 0x69, 0xd2, 0x9a,
   0xc4, 0xc0, 0x57, 0x0b, 0xcb, 0x87, 0x0f, 0x0d, 0x83, 0x08, 0x00,
-  0x0f
+  0x0f,
 ]);
 
 const data = Buffer.from([
   0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
   0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a
+  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
 ]);
 
 // This is testing the case of a misbehaving client that is not paying
diff --git a/test/parallel/test-http2-misbehaving-flow-control.js b/test/parallel/test-http2-misbehaving-flow-control.js
index 97f8c17f4ff85d94b7a6e6f4eadb59a4373f9533..6774be2237b109932dfb24b945804919ac58ef21 100644
--- a/test/parallel/test-http2-misbehaving-flow-control.js
+++ b/test/parallel/test-http2-misbehaving-flow-control.js
@@ -25,7 +25,7 @@ const preamble = Buffer.from([
   0xa0, 0xe4, 0x1d, 0x13, 0x9d, 0x09, 0xb8, 0xf0, 0x1e, 0x07, 0x53,
   0x03, 0x2a, 0x2f, 0x2a, 0x90, 0x7a, 0x8a, 0xaa, 0x69, 0xd2, 0x9a,
   0xc4, 0xc0, 0x57, 0x0b, 0xcb, 0x87, 0x0f, 0x0d, 0x83, 0x08, 0x00,
-  0x0f
+  0x0f,
 ]);
 
 const data = Buffer.from([
@@ -46,7 +46,7 @@ const data = Buffer.from([
   0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
   0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
   0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a
+  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
 ]);
 
 // This is testing the case of a misbehaving client that is not paying
diff --git a/test/parallel/test-http2-misused-pseudoheaders.js b/test/parallel/test-http2-misused-pseudoheaders.js
index 2ae3a1ddbfaf3f1238958a968f66a84570ffaf9b..230843c619ce7c4028d02a5801197d001bf18b6b 100644
--- a/test/parallel/test-http2-misused-pseudoheaders.js
+++ b/test/parallel/test-http2-misused-pseudoheaders.js
@@ -13,7 +13,7 @@ server.on('stream', common.mustCall((stream) => {
     ':path',
     ':authority',
     ':method',
-    ':scheme'
+    ':scheme',
   ].forEach((i) => {
     assert.throws(() => stream.respond({ [i]: '/' }),
                   {
diff --git a/test/parallel/test-http2-multiheaders-raw.js b/test/parallel/test-http2-multiheaders-raw.js
index 32bf9d05433d42d95d9df272c8d9adac69dd40bc..8e80a1c6312a911a8a69687666dae3b1629d9eba 100644
--- a/test/parallel/test-http2-multiheaders-raw.js
+++ b/test/parallel/test-http2-multiheaders-raw.js
@@ -31,7 +31,7 @@ server.on('stream', common.mustCall((stream, headers, flags, rawHeaders) => {
     'www-authenticate',
     'baz',
     'test',
-    'foo, bar, baz'
+    'foo, bar, baz',
   ];
 
   assert.deepStrictEqual(rawHeaders, expected);
diff --git a/test/parallel/test-http2-options-max-reserved-streams.js b/test/parallel/test-http2-options-max-reserved-streams.js
index 44c495b83304809fa804469d89079d01660fb02b..993bb1b7b3dfed3c7b0bdee887b5dec67fdbd557 100644
--- a/test/parallel/test-http2-options-max-reserved-streams.js
+++ b/test/parallel/test-http2-options-max-reserved-streams.js
@@ -20,8 +20,7 @@ server.on('stream', common.mustCall((stream) => {
   // The first pushStream will complete as normal
   stream.pushStream({
     ':path': '/foobar',
-  }, common.mustCall((err, pushedStream) => {
-    assert.ifError(err);
+  }, common.mustSucceed((pushedStream) => {
     pushedStream.respond();
     pushedStream.end();
     pushedStream.on('aborted', common.mustNotCall());
@@ -32,8 +31,7 @@ server.on('stream', common.mustCall((stream) => {
   // being set to only 1
   stream.pushStream({
     ':path': '/foobar',
-  }, common.mustCall((err, pushedStream) => {
-    assert.ifError(err);
+  }, common.mustSucceed((pushedStream) => {
     pushedStream.respond();
     pushedStream.on('aborted', common.mustCall());
     pushedStream.on('error', common.mustNotCall());
diff --git a/test/parallel/test-http2-origin.js b/test/parallel/test-http2-origin.js
index 519e8cb1a3dedd16580194741cc97fa5f8428188..5193af6d99ef7e3daf6dc9c23473fdcbeb2645f4 100644
--- a/test/parallel/test-http2-origin.js
+++ b/test/parallel/test-http2-origin.js
@@ -85,7 +85,7 @@ const ca = readKey('fake-startcom-root-cert.pem', 'binary');
     const client = connect(originSet[0], { ca });
     const checks = [
       ['https://foo.org', 'https://bar.org'],
-      ['https://example.org', 'https://example.com']
+      ['https://example.org', 'https://example.com'],
     ];
 
     const countdown = new Countdown(3, () => {
diff --git a/test/parallel/test-http2-padding-aligned.js b/test/parallel/test-http2-padding-aligned.js
index 88b321b55d1da522d4dac7d2e3cf20fe14859ef2..f687c02a98dc6ebcbc58ba3819313439de31746b 100644
--- a/test/parallel/test-http2-padding-aligned.js
+++ b/test/parallel/test-http2-padding-aligned.js
@@ -5,7 +5,7 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
-const { PADDING_STRATEGY_ALIGNED } = http2.constants;
+const { PADDING_STRATEGY_ALIGNED, PADDING_STRATEGY_CALLBACK } = http2.constants;
 const makeDuplexPair = require('../common/duplexpair');
 
 {
@@ -66,3 +66,6 @@ const makeDuplexPair = require('../common/duplexpair');
   }));
   req.end();
 }
+
+// PADDING_STRATEGY_CALLBACK has been aliased to mean aligned padding.
+assert.strictEqual(PADDING_STRATEGY_ALIGNED, PADDING_STRATEGY_CALLBACK);
diff --git a/test/parallel/test-http2-padding-callback.js b/test/parallel/test-http2-padding-callback.js
deleted file mode 100644
index 6d6a6b27221b07e0e3cce2d43c9ea5ede5bb0c24..0000000000000000000000000000000000000000
--- a/test/parallel/test-http2-padding-callback.js
+++ /dev/null
@@ -1,51 +0,0 @@
-'use strict';
-
-const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
-const assert = require('assert');
-const h2 = require('http2');
-const { PADDING_STRATEGY_CALLBACK } = h2.constants;
-
-function selectPadding(frameLen, max) {
-  assert.strictEqual(typeof frameLen, 'number');
-  assert.strictEqual(typeof max, 'number');
-  assert(max >= frameLen);
-  return max;
-}
-
-// selectPadding will be called three times:
-// 1. For the client request headers frame
-// 2. For the server response headers frame
-// 3. For the server response data frame
-const options = {
-  paddingStrategy: PADDING_STRATEGY_CALLBACK,
-  selectPadding: common.mustCall(selectPadding, 3)
-};
-
-const server = h2.createServer(options);
-server.on('stream', common.mustCall(onStream));
-
-function onStream(stream, headers, flags) {
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
-  stream.end('hello world');
-}
-
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`,
-                            options);
-
-  const req = client.request({ ':path': '/' });
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-  req.end();
-}));
diff --git a/test/parallel/test-http2-reset-flood.js b/test/parallel/test-http2-reset-flood.js
index db61b7d9292ce6c8af4f03767f5d20591e3a3632..a20970862091caec3516cdc62aa3aa672bc2cc37 100644
--- a/test/parallel/test-http2-reset-flood.js
+++ b/test/parallel/test-http2-reset-flood.js
@@ -69,10 +69,11 @@ const worker = new Worker(__filename).on('message', common.mustCall((port) => {
       h2header.writeIntBE(streamId, 5, 4);  // Stream ID
       streamId += 2;
       // 0x88 = :status: 200
-      if (conn.writable)
-        conn.write(Buffer.concat([h2header, Buffer.from([0x88])]));
+      if (!conn.write(Buffer.concat([h2header, Buffer.from([0x88])]))) {
+        break;
+      }
     }
-    if (conn.writable && !gotError)
+    if (!gotError)
       setImmediate(writeRequests);
   }
 
diff --git a/test/parallel/test-http2-respond-file-error-pipe-offset.js b/test/parallel/test-http2-respond-file-error-pipe-offset.js
index 8ee7c532332837cd2775847da8138cd3527efc04..39876baaf51dab8d6d93a8fe8fcfa5c51367831a 100644
--- a/test/parallel/test-http2-respond-file-error-pipe-offset.js
+++ b/test/parallel/test-http2-respond-file-error-pipe-offset.js
@@ -21,8 +21,6 @@ if (mkfifo.error && mkfifo.error.code === 'ENOENT') {
   common.skip('missing mkfifo');
 }
 
-process.on('exit', () => fs.unlinkSync(pipeName));
-
 const server = http2.createServer();
 server.on('stream', (stream) => {
   stream.respondWithFile(pipeName, {
@@ -58,4 +56,11 @@ server.listen(0, () => {
   req.end();
 });
 
-fs.writeFile(pipeName, 'Hello, world!\n', common.mustCall());
+fs.writeFile(pipeName, 'Hello, world!\n', common.mustCall((err) => {
+  // It's possible for the reading end of the pipe to get the expected error
+  // and break everything down before we're finished, so allow `EPIPE` but
+  // no other errors.
+  if (err?.code !== 'EPIPE') {
+    assert.ifError(err);
+  }
+}));
diff --git a/test/parallel/test-http2-respond-file-with-pipe.js b/test/parallel/test-http2-respond-file-with-pipe.js
index 2b7ca3fc9a51ee69f3895c7709db7d87af924852..30bcce46b9d23252bfde27bf27e24e74bba935e1 100644
--- a/test/parallel/test-http2-respond-file-with-pipe.js
+++ b/test/parallel/test-http2-respond-file-with-pipe.js
@@ -21,8 +21,6 @@ if (mkfifo.error && mkfifo.error.code === 'ENOENT') {
   common.skip('missing mkfifo');
 }
 
-process.on('exit', () => fs.unlinkSync(pipeName));
-
 const server = http2.createServer();
 server.on('stream', (stream) => {
   stream.respondWithFile(pipeName, {
@@ -51,8 +49,7 @@ server.listen(0, () => {
   req.end();
 });
 
-fs.open(pipeName, 'w', common.mustCall((err, fd) => {
-  assert.ifError(err);
+fs.open(pipeName, 'w', common.mustSucceed((fd) => {
   fs.writeSync(fd, 'Hello, world!\n');
   fs.closeSync(fd);
 }));
diff --git a/test/parallel/test-http2-response-splitting.js b/test/parallel/test-http2-response-splitting.js
index 9613eca9636ae4a7df24e7ae7fc8743fb9f9d1fc..a94b9ca4f72b355f7793895df4e414eaed620f7a 100644
--- a/test/parallel/test-http2-response-splitting.js
+++ b/test/parallel/test-http2-response-splitting.js
@@ -9,7 +9,6 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
-const { URL } = require('url');
 
 // Response splitting example, credit: Amit Klein, Safebreach
 const str = '/welcome?lang=bar%c4%8d%c4%8aContent­Length:%200%c4%8d%c4%8a%c' +
diff --git a/test/parallel/test-http2-sensitive-headers.js b/test/parallel/test-http2-sensitive-headers.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d4d775a55d4c29352fd77d2db7914f9b5900232
--- /dev/null
+++ b/test/parallel/test-http2-sensitive-headers.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const http2 = require('http2');
+const makeDuplexPair = require('../common/duplexpair');
+
+{
+  const testData = '<h1>Hello World</h1>';
+  const server = http2.createServer();
+  server.on('stream', common.mustCall((stream, headers) => {
+    stream.respond({
+      'content-type': 'text/html',
+      ':status': 200,
+      'cookie': 'donotindex',
+      'not-sensitive': 'foo',
+      'sensitive': 'bar',
+      // sensitiveHeaders entries are case-insensitive
+      [http2.sensitiveHeaders]: ['Sensitive']
+    });
+    stream.end(testData);
+  }));
+
+  const { clientSide, serverSide } = makeDuplexPair();
+  server.emit('connection', serverSide);
+
+  const client = http2.connect('http://localhost:80', {
+    createConnection: common.mustCall(() => clientSide)
+  });
+
+  const req = client.request({ ':path': '/' });
+
+  req.on('response', common.mustCall((headers) => {
+    assert.strictEqual(headers[':status'], 200);
+    assert.strictEqual(headers.cookie, 'donotindex');
+    assert.deepStrictEqual(headers[http2.sensitiveHeaders],
+                           ['cookie', 'sensitive']);
+  }));
+
+  req.on('end', common.mustCall(() => {
+    clientSide.destroy();
+    clientSide.end();
+  }));
+  req.resume();
+  req.end();
+}
diff --git a/test/parallel/test-http2-server-close-callback.js b/test/parallel/test-http2-server-close-callback.js
index f822d8a4a92d7816b409c24ef0936e64729769e3..5b0b8116a147fdcf6b0d2a8cbed449475b42b841 100644
--- a/test/parallel/test-http2-server-close-callback.js
+++ b/test/parallel/test-http2-server-close-callback.js
@@ -12,7 +12,7 @@ const server = http2.createServer();
 let session;
 
 const countdown = new Countdown(2, () => {
-  server.close(common.mustCall());
+  server.close(common.mustSucceed());
   session.destroy();
 });
 
diff --git a/test/parallel/test-http2-server-push-stream-errors.js b/test/parallel/test-http2-server-push-stream-errors.js
index 8e4ca37b280fe8c1a68c24836093aee245540e98..dae037c04f28c9b653f577bd613064a3b2fa03c4 100644
--- a/test/parallel/test-http2-server-push-stream-errors.js
+++ b/test/parallel/test-http2-server-push-stream-errors.js
@@ -20,7 +20,7 @@ const { NghttpError } = require('internal/http2/util');
 
 const specificTestKeys = [
   'NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE',
-  'NGHTTP2_ERR_STREAM_CLOSED'
+  'NGHTTP2_ERR_STREAM_CLOSED',
 ];
 
 const specificTests = [
diff --git a/test/parallel/test-http2-server-push-stream.js b/test/parallel/test-http2-server-push-stream.js
index 43e0e8d9320928e62e21af686d771535227d279e..7c75f66aef5e7d1d3f2f407a22cddbfb15ce4e09 100644
--- a/test/parallel/test-http2-server-push-stream.js
+++ b/test/parallel/test-http2-server-push-stream.js
@@ -14,8 +14,7 @@ server.on('stream', common.mustCall((stream, headers) => {
       ':scheme': 'http',
       ':path': '/foobar',
       ':authority': `localhost:${port}`,
-    }, common.mustCall((err, push, headers) => {
-      assert.ifError(err);
+    }, common.mustSucceed((push, headers) => {
       push.respond({
         'content-type': 'text/html',
         ':status': 200,
diff --git a/test/parallel/test-http2-server-rst-stream.js b/test/parallel/test-http2-server-rst-stream.js
index e76db1bf1ab2438d5981eeaaef3b2a35ce910068..9f37ce7147235320da3cdbbdd67194d7b46bbf78 100644
--- a/test/parallel/test-http2-server-rst-stream.js
+++ b/test/parallel/test-http2-server-rst-stream.js
@@ -21,7 +21,7 @@ const tests = [
   [NGHTTP2_PROTOCOL_ERROR, true, 'NGHTTP2_PROTOCOL_ERROR'],
   [NGHTTP2_CANCEL, false],
   [NGHTTP2_REFUSED_STREAM, true, 'NGHTTP2_REFUSED_STREAM'],
-  [NGHTTP2_INTERNAL_ERROR, true, 'NGHTTP2_INTERNAL_ERROR']
+  [NGHTTP2_INTERNAL_ERROR, true, 'NGHTTP2_INTERNAL_ERROR'],
 ];
 
 const server = http2.createServer();
diff --git a/test/parallel/test-http2-server-setLocalWindowSize.js b/test/parallel/test-http2-server-setLocalWindowSize.js
new file mode 100644
index 0000000000000000000000000000000000000000..8fcb9b9d0d81b0633119b656093109d86974d658
--- /dev/null
+++ b/test/parallel/test-http2-server-setLocalWindowSize.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const http2 = require('http2');
+
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream) => {
+  stream.respond();
+  stream.end('ok');
+}));
+server.on('session', common.mustCall((session) => {
+  const windowSize = 2 ** 20;
+  const defaultSetting = http2.getDefaultSettings();
+  session.setLocalWindowSize(windowSize);
+
+  assert.strictEqual(session.state.effectiveLocalWindowSize, windowSize);
+  assert.strictEqual(session.state.localWindowSize, windowSize);
+  assert.strictEqual(
+    session.state.remoteWindowSize,
+    defaultSetting.initialWindowSize
+  );
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request();
+  req.resume();
+  req.on('close', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+}));
diff --git a/test/parallel/test-http2-server-shutdown-options-errors.js b/test/parallel/test-http2-server-shutdown-options-errors.js
index 643d173f78bc43928e7fd6ea9b9b6f9d8d57c4d2..e6a69b54627e00722054b6e6347087d29d47697c 100644
--- a/test/parallel/test-http2-server-shutdown-options-errors.js
+++ b/test/parallel/test-http2-server-shutdown-options-errors.js
@@ -13,7 +13,7 @@ const types = [
   {},
   [],
   null,
-  new Date()
+  new Date(),
 ];
 
 server.on('stream', common.mustCall((stream) => {
diff --git a/test/parallel/test-http2-server-stream-session-destroy.js b/test/parallel/test-http2-server-stream-session-destroy.js
index b25dfbb347d9bf681895c33ef0314563cea50b79..a03569cdee7825688868503c7a0281cf3e10d700 100644
--- a/test/parallel/test-http2-server-stream-session-destroy.js
+++ b/test/parallel/test-http2-server-stream-session-destroy.js
@@ -34,11 +34,9 @@ server.on('stream', common.mustCall((stream) => {
       name: 'Error'
     }
   );
-  stream.on('error', common.expectsError({
-    name: 'Error',
-    code: 'ERR_STREAM_WRITE_AFTER_END',
-    message: 'write after end'
-  }));
+  // When session is detroyed all streams are destroyed and no further
+  // error should be emitted.
+  stream.on('error', common.mustNotCall());
   assert.strictEqual(stream.write('data', common.expectsError({
     name: 'Error',
     code: 'ERR_STREAM_WRITE_AFTER_END',
diff --git a/test/parallel/test-http2-server-timeout.js b/test/parallel/test-http2-server-timeout.js
index 88fc4eab2e08c07ed10d1c17e10a7a5f00ec3e7f..b1515e718ae5194597c834e8053be52334792573 100755
--- a/test/parallel/test-http2-server-timeout.js
+++ b/test/parallel/test-http2-server-timeout.js
@@ -5,21 +5,27 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const http2 = require('http2');
 
-const server = http2.createServer();
-server.setTimeout(common.platformTimeout(50));
+function testServerTimeout(setTimeoutFn) {
+  const server = http2.createServer();
+  setTimeoutFn(server);
 
-const onServerTimeout = common.mustCall((session) => {
-  session.close();
-});
+  const onServerTimeout = common.mustCall((session) => {
+    session.close();
+  });
 
-server.on('stream', common.mustNotCall());
-server.once('timeout', onServerTimeout);
+  server.on('stream', common.mustNotCall());
+  server.once('timeout', onServerTimeout);
 
-server.listen(0, common.mustCall(() => {
-  const url = `http://localhost:${server.address().port}`;
-  const client = http2.connect(url);
-  client.on('close', common.mustCall(() => {
-    const client2 = http2.connect(url);
-    client2.on('close', common.mustCall(() => server.close()));
+  server.listen(0, common.mustCall(() => {
+    const url = `http://localhost:${server.address().port}`;
+    const client = http2.connect(url);
+    client.on('close', common.mustCall(() => {
+      const client2 = http2.connect(url);
+      client2.on('close', common.mustCall(() => server.close()));
+    }));
   }));
-}));
+}
+
+const timeout = common.platformTimeout(50);
+testServerTimeout((server) => server.setTimeout(timeout));
+testServerTimeout((server) => server.timeout = timeout);
diff --git a/test/parallel/test-http2-session-settings.js b/test/parallel/test-http2-session-settings.js
index a31682f291479fe0c65901e598ce42210c650a3b..571ee87d93768c41a1189735674819c823a4700b 100644
--- a/test/parallel/test-http2-session-settings.js
+++ b/test/parallel/test-http2-session-settings.js
@@ -103,7 +103,7 @@ server.listen(
         ['maxHeaderListSize', -1],
         ['maxHeaderListSize', 2 ** 32],
         ['maxHeaderSize', -1],
-        ['maxHeaderSize', 2 ** 32]
+        ['maxHeaderSize', 2 ** 32],
       ].forEach((i) => {
         const settings = {};
         settings[i[0]] = i[1];
diff --git a/test/parallel/test-http2-single-headers.js b/test/parallel/test-http2-single-headers.js
index 6f20c1b35658d71cf964ffa8885ebd6ff2601354..c10623b9be7bf0d9c8910d0dd1d92f046798f64b 100644
--- a/test/parallel/test-http2-single-headers.js
+++ b/test/parallel/test-http2-single-headers.js
@@ -19,7 +19,7 @@ const singles = [
   'if-unmodified-since',
   'from',
   'location',
-  'max-forwards'
+  'max-forwards',
 ];
 
 server.on('stream', common.mustNotCall());
diff --git a/test/parallel/test-http2-socket-proxy-handler-for-has.js b/test/parallel/test-http2-socket-proxy-handler-for-has.js
new file mode 100644
index 0000000000000000000000000000000000000000..ccc63149ff1b125139e2e0104fdcfd3ca2f7d18d
--- /dev/null
+++ b/test/parallel/test-http2-socket-proxy-handler-for-has.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http2 = require('http2');
+
+const serverOptions = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+const server = http2.createSecureServer(serverOptions, common.mustCall(
+  (req, res) => {
+    const request = req;
+    assert.strictEqual(request.socket.encrypted, true);
+    assert.ok('encrypted' in request.socket);
+    res.end();
+  }
+));
+server.listen(common.mustCall(() => {
+  const port = server.address().port;
+  const client = http2.connect('https://localhost:' + port, {
+    ca: fixtures.readKey('agent1-cert.pem'),
+    rejectUnauthorized: false
+  });
+  const req = client.request({});
+  req.on('response', common.mustCall((headers, flags) => {
+    console.log(headers);
+    server.close(common.mustCall(() => {
+    }));
+  }));
+  req.on('end', common.mustCall(() => {
+    client.close();
+  }));
+  req.end();
+}));
diff --git a/test/parallel/test-http2-socket-proxy.js b/test/parallel/test-http2-socket-proxy.js
index 067909069e9d8664d5bb7120ed3ec080d6f734a8..3294cf7ccb901167ad2924b9b4419e6e40257ef1 100644
--- a/test/parallel/test-http2-socket-proxy.js
+++ b/test/parallel/test-http2-socket-proxy.js
@@ -85,10 +85,14 @@ server.on('stream', common.mustCall(function(stream, headers) {
 
   stream.respond();
 
-  socket.writable = 0;
-  socket.readable = 0;
-  assert.strictEqual(socket.writable, 0);
-  assert.strictEqual(socket.readable, 0);
+  socket.writable = true;
+  socket.readable = true;
+  assert.strictEqual(socket.writable, true);
+  assert.strictEqual(socket.readable, true);
+  socket.writable = false;
+  socket.readable = false;
+  assert.strictEqual(socket.writable, false);
+  assert.strictEqual(socket.readable, false);
 
   stream.end();
 
diff --git a/test/parallel/test-http2-tls-disconnect.js b/test/parallel/test-http2-tls-disconnect.js
index 2e635fe1376a5135dd54e7dbfe70c1ab41a19040..42c58c8a4e0975e0f39f2c3497029d7a05d8e446 100644
--- a/test/parallel/test-http2-tls-disconnect.js
+++ b/test/parallel/test-http2-tls-disconnect.js
@@ -21,7 +21,7 @@ const server = http2.createSecureServer({ key, cert }, (request, response) => {
 server.listen(0, () => {
   const proc = child_process.spawn('h2load', [
     '-n', '1000',
-    `https://localhost:${server.address().port}/`
+    `https://localhost:${server.address().port}/`,
   ]);
   proc.on('error', (err) => {
     if (err.code === 'ENOENT')
diff --git a/test/parallel/test-http2-unbound-socket-proxy.js b/test/parallel/test-http2-unbound-socket-proxy.js
index a5505c8509dca325d4f9e250827f739881833a1b..74ca0169446afb1f551b625c6bd51fb9f32d56f7 100644
--- a/test/parallel/test-http2-unbound-socket-proxy.js
+++ b/test/parallel/test-http2-unbound-socket-proxy.js
@@ -26,7 +26,7 @@ server.listen(0, common.mustCall(() => {
     // informative error.
     setImmediate(common.mustCall(() => {
       assert.throws(() => {
-        socket.example;
+        socket.example; // eslint-disable-line no-unused-expressions
       }, {
         code: 'ERR_HTTP2_SOCKET_UNBOUND'
       });
@@ -36,6 +36,7 @@ server.listen(0, common.mustCall(() => {
         code: 'ERR_HTTP2_SOCKET_UNBOUND'
       });
       assert.throws(() => {
+        // eslint-disable-next-line no-unused-expressions
         socket instanceof net.Socket;
       }, {
         code: 'ERR_HTTP2_SOCKET_UNBOUND'
diff --git a/test/parallel/test-http2-update-settings.js b/test/parallel/test-http2-update-settings.js
new file mode 100644
index 0000000000000000000000000000000000000000..e99ee2bcf150d819ee4d069dce83665f29c2c91b
--- /dev/null
+++ b/test/parallel/test-http2-update-settings.js
@@ -0,0 +1,59 @@
+'use strict';
+
+// This test ensures that the Http2SecureServer and Http2Server
+// settings are updated when the setting object is valid.
+// When the setting object is invalid, this test ensures that
+// updateSettings throws an exception.
+
+const common = require('../common');
+if (!common.hasCrypto) { common.skip('missing crypto'); }
+const assert = require('assert');
+const http2 = require('http2');
+
+testUpdateSettingsWith({
+  server: http2.createSecureServer(),
+  newServerSettings: {
+    'headerTableSize': 1,
+    'initialWindowSize': 1,
+    'maxConcurrentStreams': 1,
+    'maxHeaderListSize': 1,
+    'maxFrameSize': 16385,
+    'enablePush': false,
+    'enableConnectProtocol': true
+  }
+});
+testUpdateSettingsWith({
+  server: http2.createServer(),
+  newServerSettings: {
+    'enablePush': false
+  }
+});
+
+function testUpdateSettingsWith({ server, newServerSettings }) {
+  const oldServerSettings = getServerSettings(server);
+  assert.notDeepStrictEqual(oldServerSettings, newServerSettings);
+  server.updateSettings(newServerSettings);
+  const updatedServerSettings = getServerSettings(server);
+  assert.deepStrictEqual(updatedServerSettings, { ...oldServerSettings,
+                                                  ...newServerSettings });
+  assert.throws(() => server.updateSettings(''), {
+    message: 'The "settings" argument must be of type object. ' +
+    'Received type string (\'\')',
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  });
+  assert.throws(() => server.updateSettings({
+    'maxHeaderListSize': 'foo'
+  }), {
+    message: 'Invalid value for setting "maxHeaderListSize": foo',
+    code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+    name: 'RangeError'
+  });
+}
+
+function getServerSettings(server) {
+  const options = Object
+                  .getOwnPropertySymbols(server)
+                  .find((s) => s.toString() === 'Symbol(options)');
+  return server[options].settings;
+}
diff --git a/test/parallel/test-http2-util-asserts.js b/test/parallel/test-http2-util-asserts.js
index 5bbc1cde43f790c8d17e3d0cd1749835267f4d3e..29ba8180494a3cb7088909b0c7cbebf0a00c78da 100644
--- a/test/parallel/test-http2-util-asserts.js
+++ b/test/parallel/test-http2-util-asserts.js
@@ -13,7 +13,7 @@ const {
   {},
   Object.create(null),
   new Date(),
-  new (class Foo {})()
+  new (class Foo {})(),
 ].forEach((input) => {
   assertIsObject(input, 'foo', 'Object');
 });
@@ -25,7 +25,7 @@ const {
   NaN,
   Infinity,
   [],
-  [{}]
+  [{}],
 ].forEach((input) => {
   assert.throws(
     () => assertIsObject(input, 'foo', 'Object'),
diff --git a/test/parallel/test-http2-util-headers-list.js b/test/parallel/test-http2-util-headers-list.js
index a964c361b78815a544b7424bdd70a7c73e111d3b..1f6fb6557c05c19e438822ce118dc7b4e2774c8e 100644
--- a/test/parallel/test-http2-util-headers-list.js
+++ b/test/parallel/test-http2-util-headers-list.js
@@ -9,6 +9,7 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
 const { mapToHeaders, toHeaderObject } = require('internal/http2/util');
+const { sensitiveHeaders } = require('http2');
 const { internalBinding } = require('internal/test/binding');
 const {
   HTTP2_HEADER_STATUS,
@@ -102,8 +103,9 @@ const {
 
   assert.deepStrictEqual(
     mapToHeaders(headers),
-    [ [ ':path', 'abc', ':status', '200', 'abc', '1', 'xyz', '1', 'xyz', '2',
-        'xyz', '3', 'xyz', '4', 'bar', '1', '' ].join('\0'), 8 ]
+    [ [ ':path', 'abc\0', ':status', '200\0', 'abc', '1\0', 'xyz', '1\0',
+        'xyz', '2\0', 'xyz', '3\0', 'xyz', '4\0', 'bar', '1\0', '' ].join('\0'),
+      8 ]
   );
 }
 
@@ -118,8 +120,8 @@ const {
 
   assert.deepStrictEqual(
     mapToHeaders(headers),
-    [ [ ':status', '200', ':path', 'abc', 'abc', '1', 'xyz', '1', 'xyz', '2',
-        'xyz', '3', 'xyz', '4', '' ].join('\0'), 7 ]
+    [ [ ':status', '200\0', ':path', 'abc\0', 'abc', '1\0', 'xyz', '1\0',
+        'xyz', '2\0', 'xyz', '3\0', 'xyz', '4\0', '' ].join('\0'), 7 ]
   );
 }
 
@@ -135,8 +137,8 @@ const {
 
   assert.deepStrictEqual(
     mapToHeaders(headers),
-    [ [ ':status', '200', ':path', 'abc', 'abc', '1', 'xyz', '1', 'xyz', '2',
-        'xyz', '3', 'xyz', '4', '' ].join('\0'), 7 ]
+    [ [ ':status', '200\0', ':path', 'abc\0', 'abc', '1\0', 'xyz', '1\0',
+        'xyz', '2\0', 'xyz', '3\0', 'xyz', '4\0', '' ].join('\0'), 7 ]
   );
 }
 
@@ -151,8 +153,8 @@ const {
 
   assert.deepStrictEqual(
     mapToHeaders(headers),
-    [ [ ':status', '200', ':path', 'abc', 'xyz', '1', 'xyz', '2', 'xyz', '3',
-        'xyz', '4', '' ].join('\0'), 6 ]
+    [ [ ':status', '200\0', ':path', 'abc\0', 'xyz', '1\0', 'xyz', '2\0',
+        'xyz', '3\0', 'xyz', '4\0', '' ].join('\0'), 6 ]
   );
 }
 
@@ -164,7 +166,7 @@ const {
   };
   assert.deepStrictEqual(
     mapToHeaders(headers),
-    [ [ 'set-cookie', 'foo=bar', '' ].join('\0'), 1 ]
+    [ [ 'set-cookie', 'foo=bar\0', '' ].join('\0'), 1 ]
   );
 }
 
@@ -182,6 +184,23 @@ const {
   });
 }
 
+{
+  const headers = {
+    'abc': 1,
+    ':path': 'abc',
+    ':status': [200],
+    ':authority': [],
+    'xyz': [1, 2, 3, 4],
+    [sensitiveHeaders]: ['xyz']
+  };
+
+  assert.deepStrictEqual(
+    mapToHeaders(headers),
+    [ ':status\x00200\x00\x00:path\x00abc\x00\x00abc\x001\x00\x00' +
+      'xyz\x001\x00\x01xyz\x002\x00\x01xyz\x003\x00\x01xyz\x004\x00\x01', 7 ]
+  );
+}
+
 // The following are not allowed to have multiple values
 [
   HTTP2_HEADER_STATUS,
@@ -221,7 +240,7 @@ const {
   HTTP2_HEADER_TK,
   HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS,
   HTTP2_HEADER_USER_AGENT,
-  HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS
+  HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS,
 ].forEach((name) => {
   const msg = `Header field "${name}" must only have a single value`;
   assert.throws(() => mapToHeaders({ [name]: [1, 2, 3] }), {
@@ -259,7 +278,7 @@ const {
   HTTP2_HEADER_VIA,
   HTTP2_HEADER_WARNING,
   HTTP2_HEADER_WWW_AUTHENTICATE,
-  HTTP2_HEADER_X_FRAME_OPTIONS
+  HTTP2_HEADER_X_FRAME_OPTIONS,
 ].forEach((name) => {
   assert(!(mapToHeaders({ [name]: [1, 2, 3] }) instanceof Error), name);
 });
@@ -279,7 +298,7 @@ const {
   'TE',
   'Transfer-Encoding',
   'Proxy-Connection',
-  'Keep-Alive'
+  'Keep-Alive',
 ].forEach((name) => {
   assert.throws(() => mapToHeaders({ [name]: 'abc' }), {
     code: 'ERR_HTTP2_INVALID_CONNECTION_HEADERS',
@@ -315,7 +334,7 @@ mapToHeaders({ te: ['trailers'] });
     'cookie', 'foo',
     'set-cookie', 'sc1',
     'age', '10',
-    'x-multi', 'first'
+    'x-multi', 'first',
   ];
   const headers = toHeaderObject(rawHeaders);
   assert.strictEqual(headers[':status'], 200);
@@ -336,7 +355,7 @@ mapToHeaders({ te: ['trailers'] });
     'age', '10',
     'age', '20',
     'x-multi', 'first',
-    'x-multi', 'second'
+    'x-multi', 'second',
   ];
   const headers = toHeaderObject(rawHeaders);
   assert.strictEqual(headers[':status'], 200);
diff --git a/test/parallel/test-http2-window-size.js b/test/parallel/test-http2-window-size.js
index adf4534d5bc92bf22b15ca76b32f182da557e434..b5940f29583a7764a08de9610e3680c60055afc2 100644
--- a/test/parallel/test-http2-window-size.js
+++ b/test/parallel/test-http2-window-size.js
@@ -89,7 +89,7 @@ const initialWindowSizeList = [
   (1 << 8) - 1,
   1 << 8,
   1 << 17,
-  undefined // Use default window size which is (1 << 16) - 1
+  undefined, // Use default window size which is (1 << 16) - 1
 ];
 
 // Call `run` on each element in the cartesian product of buffersList and
diff --git a/test/parallel/test-http2-zero-length-header.js b/test/parallel/test-http2-zero-length-header.js
index 7b142d75f003b6f0200c4983fab267e7214714ee..2e7876858aaace02fb2709a633aafe7a8399f8c6 100644
--- a/test/parallel/test-http2-zero-length-header.js
+++ b/test/parallel/test-http2-zero-length-header.js
@@ -14,7 +14,8 @@ server.on('stream', (stream, headers) => {
     ':method': 'GET',
     ':path': '/',
     'bar': '',
-    '__proto__': null
+    '__proto__': null,
+    [http2.sensitiveHeaders]: []
   });
   stream.session.destroy();
   server.close();
diff --git a/test/parallel/test-https-abortcontroller.js b/test/parallel/test-https-abortcontroller.js
new file mode 100644
index 0000000000000000000000000000000000000000..3da2ab9ce25c288825189335184fbe837cdce6ed
--- /dev/null
+++ b/test/parallel/test-https-abortcontroller.js
@@ -0,0 +1,40 @@
+// Flags: --experimental-abortcontroller
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const fixtures = require('../common/fixtures');
+const https = require('https');
+const assert = require('assert');
+const { once } = require('events');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+(async () => {
+  const { port, server } = await new Promise((resolve) => {
+    const server = https.createServer(options, () => {});
+    server.listen(0, () => resolve({ port: server.address().port, server }));
+  });
+  try {
+    const ac = new AbortController();
+    const req = https.request({
+      host: 'localhost',
+      port,
+      path: '/',
+      method: 'GET',
+      rejectUnauthorized: false,
+      signal: ac.signal,
+    });
+    process.nextTick(() => ac.abort());
+    const [ err ] = await once(req, 'error');
+    assert.strictEqual(err.name, 'AbortError');
+    assert.strictEqual(err.code, 'ABORT_ERR');
+  } finally {
+    server.close();
+  }
+})().then(common.mustCall());
diff --git a/test/parallel/test-https-agent-additional-options.js b/test/parallel/test-https-agent-additional-options.js
index 2b5446b9e3d1944134125ac9c1a0a0b0366be43b..70c3dee103b2c929016ac7344fd56ef0402e170a 100644
--- a/test/parallel/test-https-agent-additional-options.js
+++ b/test/parallel/test-https-agent-additional-options.js
@@ -34,6 +34,8 @@ const updatedValues = new Map([
   ['dhparam', fixtures.readKey('dh2048.pem')],
   ['ecdhCurve', 'secp384r1'],
   ['honorCipherOrder', true],
+  ['minVersion', 'TLSv1.1'],
+  ['maxVersion', 'TLSv1.3'],
   ['secureOptions', crypto.constants.SSL_OP_CIPHER_SERVER_PREFERENCE],
   ['secureProtocol', 'TLSv1_1_method'],
   ['sessionIdContext', 'sessionIdContext'],
@@ -61,8 +63,8 @@ function variations(iter, port, cb) {
         server.close();
       } else {
         // Save `value` for check the next time.
-        value = next.value.val;
         const [key, val] = next.value;
+        value = val;
         https.get({ ...getBaseOptions(port), [key]: val },
                   variations(iter, port, cb));
       }
diff --git a/test/parallel/test-https-agent-getname.js b/test/parallel/test-https-agent-getname.js
index dabb08f074af9ae0e88a23e748c3ab1c6094716c..6f8c32b299a669bedf583931186f63f04aed4acb 100644
--- a/test/parallel/test-https-agent-getname.js
+++ b/test/parallel/test-https-agent-getname.js
@@ -12,7 +12,7 @@ const agent = new https.Agent();
 // empty options
 assert.strictEqual(
   agent.getName({}),
-  'localhost:::::::::::::::::::'
+  'localhost::::::::::::::::::::::'
 );
 
 // Pass all options arguments
@@ -34,11 +34,15 @@ const options = {
   secureOptions: 0,
   secureProtocol: 'secureProtocol',
   servername: 'localhost',
-  sessionIdContext: 'sessionIdContext'
+  sessionIdContext: 'sessionIdContext',
+  sigalgs: 'sigalgs',
+  privateKeyIdentifier: 'privateKeyIdentifier',
+  privateKeyEngine: 'privateKeyEngine',
 };
 
 assert.strictEqual(
   agent.getName(options),
   '0.0.0.0:443:192.168.1.1:ca:cert:dynamic:ciphers:key:pfx:false:localhost:' +
-    '::secureProtocol:c,r,l:false:ecdhCurve:dhparam:0:sessionIdContext'
+    '::secureProtocol:c,r,l:false:ecdhCurve:dhparam:0:sessionIdContext:' +
+    '"sigalgs":privateKeyIdentifier:privateKeyEngine'
 );
diff --git a/test/parallel/test-https-agent-session-reuse.js b/test/parallel/test-https-agent-session-reuse.js
index 0717a3f8165d67a85fc883617569bc85bb773ee7..485f4b1ca308c98429ff3f439d4a8a5cb2b1dd93 100644
--- a/test/parallel/test-https-agent-session-reuse.js
+++ b/test/parallel/test-https-agent-session-reuse.js
@@ -90,7 +90,7 @@ const server = https.createServer(options, function(req, res) {
       servername: 'agent1',
       ca: ca,
       port: this.address().port
-    }
+    },
   ];
 
   function request() {
diff --git a/test/parallel/test-https-agent-unref-socket.js b/test/parallel/test-https-agent-unref-socket.js
new file mode 100644
index 0000000000000000000000000000000000000000..49169b523e10424a61cb354d5e6e4e5fe36746c7
--- /dev/null
+++ b/test/parallel/test-https-agent-unref-socket.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const https = require('https');
+
+if (process.argv[2] === 'localhost') {
+  const request = https.get('https://localhost:' + process.argv[3]);
+
+  request.on('socket', (socket) => {
+    socket.unref();
+  });
+} else {
+  const assert = require('assert');
+  const net = require('net');
+  const server = net.createServer();
+  server.listen(0);
+  server.on('listening', () => {
+    const port = server.address().port;
+    const { fork } = require('child_process');
+    const child = fork(__filename, ['localhost', port], {});
+    child.on('close', (exit_code) => {
+      server.close();
+      assert.strictEqual(exit_code, 0);
+    });
+  });
+}
diff --git a/test/parallel/test-https-agent.js b/test/parallel/test-https-agent.js
index 4b2f9e73a1cd7927d2d1170ba4869c4faa3756cd..ce4bc6e5bdb86b078b50f61eb339a0e30120257e 100644
--- a/test/parallel/test-https-agent.js
+++ b/test/parallel/test-https-agent.js
@@ -35,7 +35,7 @@ const options = {
 };
 
 
-const server = https.Server(options, function(req, res) {
+const server = https.Server(options, (req, res) => {
   res.writeHead(200);
   res.end('hello world\n');
 });
@@ -46,9 +46,9 @@ const N = 4;
 const M = 4;
 
 
-server.listen(0, function() {
+server.listen(0, () => {
   for (let i = 0; i < N; i++) {
-    setTimeout(function() {
+    setTimeout(() => {
       for (let j = 0; j < M; j++) {
         https.get({
           path: '/',
@@ -58,7 +58,7 @@ server.listen(0, function() {
           res.resume();
           assert.strictEqual(res.statusCode, 200);
           if (++responses === N * M) server.close();
-        }).on('error', function(e) {
+        }).on('error', (e) => {
           throw e;
         });
       }
@@ -67,6 +67,6 @@ server.listen(0, function() {
 });
 
 
-process.on('exit', function() {
+process.on('exit', () => {
   assert.strictEqual(responses, N * M);
 });
diff --git a/test/parallel/test-https-client-get-url.js b/test/parallel/test-https-client-get-url.js
index 76328775e80187d10f887c2129911a1946035075..fb91a4f1e7cb8a2e968e3f1ef61b5a7c392d7a48 100644
--- a/test/parallel/test-https-client-get-url.js
+++ b/test/parallel/test-https-client-get-url.js
@@ -32,8 +32,6 @@ const assert = require('assert');
 const https = require('https');
 const url = require('url');
 
-const URL = url.URL;
-
 const options = {
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
diff --git a/test/parallel/test-https-close.js b/test/parallel/test-https-close.js
index d9ed2ba1de90a6d85ac81af28670ba3294b71fb1..29104bf2f92bd670268923959c87d27b32e838ed 100644
--- a/test/parallel/test-https-close.js
+++ b/test/parallel/test-https-close.js
@@ -29,7 +29,7 @@ server.on('connection', (connection) => {
 });
 
 function shutdown() {
-  server.close(common.mustCall());
+  server.close(common.mustSucceed());
 
   for (const key in connections) {
     connections[key].destroy();
diff --git a/test/parallel/test-https-host-headers.js b/test/parallel/test-https-host-headers.js
index 996b37a63385fb8b5c04f41c55707c98c8e35e9f..b8dcda320fddc5511b306483d724517ce871a495 100644
--- a/test/parallel/test-https-host-headers.js
+++ b/test/parallel/test-https-host-headers.js
@@ -7,15 +7,15 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const https = require('https');
+const debug = require('util').debuglog('test');
 
-const options = {
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem')
-};
-const httpsServer = https.createServer(options, reqHandler);
+let counter = 0;
 
-function reqHandler(req, res) {
-  console.log(`Got request: ${req.headers.host} ${req.url}`);
+const httpsServer = https.createServer({
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem'),
+}, common.mustCall(function(req, res) {
+  debug(`Got request: ${req.headers.host} ${req.url}`);
   if (req.url.startsWith('/setHostFalse')) {
     assert.strictEqual(req.headers.host, undefined);
   } else {
@@ -25,106 +25,93 @@ function reqHandler(req, res) {
   }
   res.writeHead(200, {});
   res.end('ok');
-}
-
-function thrower(er) {
-  throw er;
-}
-
-testHttps();
-
-function testHttps() {
-
-  let counter = 0;
-
-  function cb(res) {
-    counter--;
-    console.log(`back from https request. counter = ${counter}`);
-    if (counter === 0) {
-      httpsServer.close();
-      console.log('ok');
-    }
-    res.resume();
+}, 9)).listen(0, common.mustCall(function(err) {
+  debug(`test https server listening on port ${this.address().port}`);
+  assert.ifError(err);
+  https.get({
+    method: 'GET',
+    path: `/${counter++}`,
+    host: 'localhost',
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall());
+
+  https.request({
+    method: 'GET',
+    path: `/${counter++}`,
+    host: 'localhost',
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall()).end();
+
+  https.request({
+    method: 'POST',
+    path: `/${counter++}`,
+    host: 'localhost',
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall()).end();
+
+  https.request({
+    method: 'PUT',
+    path: `/${counter++}`,
+    host: 'localhost',
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall()).end();
+
+  https.request({
+    method: 'DELETE',
+    path: `/${counter++}`,
+    host: 'localhost',
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall()).end();
+
+  https.get({
+    method: 'GET',
+    path: `/setHostFalse${counter++}`,
+    host: 'localhost',
+    setHost: false,
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall());
+
+  https.request({
+    method: 'GET',
+    path: `/${counter++}`,
+    host: 'localhost',
+    setHost: true,
+    // agent: false,
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall()).end();
+
+  https.get({
+    method: 'GET',
+    path: `/setHostFalse${counter++}`,
+    host: 'localhost',
+    setHost: 0,
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall());
+
+  https.get({
+    method: 'GET',
+    path: `/setHostFalse${counter++}`,
+    host: 'localhost',
+    setHost: null,
+    port: this.address().port,
+    rejectUnauthorized: false,
+  }, cb).on('error', common.mustNotCall());
+}));
+
+const cb = common.mustCall(function(res) {
+  counter--;
+  debug(`back from https request. counter = ${counter}`);
+  if (counter === 0) {
+    httpsServer.close();
+    debug('ok');
   }
-
-  httpsServer.listen(0, function(er) {
-    console.log(`test https server listening on port ${this.address().port}`);
-    assert.ifError(er);
-    https.get({
-      method: 'GET',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower);
-
-    https.request({
-      method: 'GET',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.request({
-      method: 'POST',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.request({
-      method: 'PUT',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.request({
-      method: 'DELETE',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.get({
-      method: 'GET',
-      path: `/setHostFalse${counter++}`,
-      host: 'localhost',
-      setHost: false,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower);
-
-    https.request({
-      method: 'GET',
-      path: `/${counter++}`,
-      host: 'localhost',
-      setHost: true,
-      // agent: false,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.get({
-      method: 'GET',
-      path: `/setHostFalse${counter++}`,
-      host: 'localhost',
-      setHost: 0,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower);
-
-    https.get({
-      method: 'GET',
-      path: `/setHostFalse${counter++}`,
-      host: 'localhost',
-      setHost: null,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower);
-  });
-}
+  res.resume();
+}, 9);
diff --git a/test/parallel/test-https-hwm.js b/test/parallel/test-https-hwm.js
new file mode 100644
index 0000000000000000000000000000000000000000..71ee33b70868615f6eabb89f0f03415362ed5aaa
--- /dev/null
+++ b/test/parallel/test-https-hwm.js
@@ -0,0 +1,66 @@
+'use strict';
+
+// Test https highWaterMark
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const https = require('https');
+const fixtures = require('../common/fixtures');
+
+let counter = 0;
+
+function loadCallback(highWaterMark) {
+  return common.mustCall(function(res) {
+    assert.strictEqual(highWaterMark, res.readableHighWaterMark);
+    counter--;
+    console.log('back from https request. ',
+                `highWaterMark = ${res.readableHighWaterMark}`);
+    if (counter === 0) {
+      httpsServer.close();
+      console.log('ok');
+    }
+    res.resume();
+  });
+}
+
+// create server
+const httpsServer = https.createServer({
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+}, common.mustCall(function(req, res) {
+  res.writeHead(200, {});
+  res.end('ok');
+}, 3)).listen(0, common.mustCall(function(err) {
+  console.log(`test https server listening on port ${this.address().port}`);
+  assert.ifError(err);
+
+  https.request({
+    method: 'GET',
+    path: `/${counter++}`,
+    host: 'localhost',
+    port: this.address().port,
+    rejectUnauthorized: false,
+    highWaterMark: 128000,
+  }, loadCallback(128000)).on('error', common.mustNotCall()).end();
+
+  https.request({
+    method: 'GET',
+    path: `/${counter++}`,
+    host: 'localhost',
+    port: this.address().port,
+    rejectUnauthorized: false,
+    highWaterMark: 0,
+  }, loadCallback(0)).on('error', common.mustNotCall()).end();
+
+  https.request({
+    method: 'GET',
+    path: `/${counter++}`,
+    host: 'localhost',
+    port: this.address().port,
+    rejectUnauthorized: false,
+    highWaterMark: undefined,
+  }, loadCallback(16 * 1024)).on('error', common.mustNotCall()).end();
+}));
diff --git a/test/parallel/test-https-insecure-parse-per-stream.js b/test/parallel/test-https-insecure-parse-per-stream.js
new file mode 100644
index 0000000000000000000000000000000000000000..645fbcf2637654e6701758b69d60a7f3423b98d0
--- /dev/null
+++ b/test/parallel/test-https-insecure-parse-per-stream.js
@@ -0,0 +1,131 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const https = require('https');
+const MakeDuplexPair = require('../common/duplexpair');
+const tls = require('tls');
+const { finished } = require('stream');
+
+const certFixture = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem'),
+  ca: fixtures.readKey('ca1-cert.pem'),
+};
+
+
+// Test that setting the `insecureHTTPParse` option works on a per-stream-basis.
+
+// Test 1: The server sends an invalid header.
+{
+  const { clientSide, serverSide } = MakeDuplexPair();
+
+  const req = https.request({
+    rejectUnauthorized: false,
+    createConnection: common.mustCall(() => clientSide),
+    insecureHTTPParser: true
+  }, common.mustCall((res) => {
+    assert.strictEqual(res.headers.hello, 'foo\x08foo');
+    res.resume();  // We don’t actually care about contents.
+    res.on('end', common.mustCall());
+  }));
+  req.end();
+
+  serverSide.resume();  // Dump the request
+  serverSide.end('HTTP/1.1 200 OK\r\n' +
+                 'Hello: foo\x08foo\r\n' +
+                 'Content-Length: 0\r\n' +
+                 '\r\n\r\n');
+}
+
+// Test 2: The same as Test 1 except without the option, to make sure it fails.
+{
+  const { clientSide, serverSide } = MakeDuplexPair();
+
+  const req = https.request({
+    rejectUnauthorized: false,
+    createConnection: common.mustCall(() => clientSide)
+  }, common.mustNotCall());
+  req.end();
+  req.on('error', common.mustCall());
+
+  serverSide.resume();  // Dump the request
+  serverSide.end('HTTP/1.1 200 OK\r\n' +
+                 'Hello: foo\x08foo\r\n' +
+                 'Content-Length: 0\r\n' +
+                 '\r\n\r\n');
+}
+
+// Test 3: The client sends an invalid header.
+{
+  const testData = 'Hello, World!\n';
+  const server = https.createServer(
+    { insecureHTTPParser: true,
+      ...certFixture },
+    common.mustCall((req, res) => {
+      res.statusCode = 200;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end(testData);
+    }));
+
+  server.on('clientError', common.mustNotCall());
+
+  server.listen(0, common.mustCall(() => {
+    const client = tls.connect({
+      port: server.address().port,
+      rejectUnauthorized: false
+    });
+    client.write(
+      'GET / HTTP/1.1\r\n' +
+      'Hello: foo\x08foo\r\n' +
+      '\r\n\r\n');
+    client.end();
+
+    client.on('data', () => {});
+    finished(client, common.mustCall(() => {
+      server.close();
+    }));
+  }));
+}
+
+// Test 4: The same as Test 3 except without the option, to make sure it fails.
+{
+  const server = https.createServer(
+    { ...certFixture },
+    common.mustNotCall());
+
+  server.on('clientError', common.mustCall());
+
+  server.listen(0, common.mustCall(() => {
+    const client = tls.connect({
+      port: server.address().port,
+      rejectUnauthorized: false
+    });
+    client.write(
+      'GET / HTTP/1.1\r\n' +
+      'Hello: foo\x08foo\r\n' +
+      '\r\n\r\n');
+    client.end();
+
+    client.on('data', () => {});
+    finished(client, common.mustCall(() => {
+      server.close();
+    }));
+  }));
+}
+
+// Test 5: Invalid argument type
+{
+  assert.throws(
+    () => https.request({ insecureHTTPParser: 0 }, common.mustNotCall()),
+    common.expectsError({
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: 'The "options.insecureHTTPParser" property must be of' +
+      ' type boolean. Received type number (0)'
+    })
+  );
+}
diff --git a/test/parallel/test-https-max-header-size-per-stream.js b/test/parallel/test-https-max-header-size-per-stream.js
new file mode 100644
index 0000000000000000000000000000000000000000..f7117e16fb43f69acce348ad91c3807a592ede8f
--- /dev/null
+++ b/test/parallel/test-https-max-header-size-per-stream.js
@@ -0,0 +1,119 @@
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const https = require('https');
+const http = require('http');
+const tls = require('tls');
+const MakeDuplexPair = require('../common/duplexpair');
+const { finished } = require('stream');
+
+const certFixture = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem'),
+  ca: fixtures.readKey('ca1-cert.pem'),
+};
+
+
+// Test that setting the `maxHeaderSize` option works on a per-stream-basis.
+
+// Test 1: The server sends larger headers than what would otherwise be allowed.
+{
+  const { clientSide, serverSide } = MakeDuplexPair();
+
+  const req = https.request({
+    createConnection: common.mustCall(() => clientSide),
+    maxHeaderSize: http.maxHeaderSize * 4
+  }, common.mustCall((res) => {
+    assert.strictEqual(res.headers.hello, 'A'.repeat(http.maxHeaderSize * 3));
+    res.resume();  // We don’t actually care about contents.
+    res.on('end', common.mustCall());
+  }));
+  req.end();
+
+  serverSide.resume();  // Dump the request
+  serverSide.end('HTTP/1.1 200 OK\r\n' +
+                 'Hello: ' + 'A'.repeat(http.maxHeaderSize * 3) + '\r\n' +
+                 'Content-Length: 0\r\n' +
+                 '\r\n\r\n');
+}
+
+// Test 2: The same as Test 1 except without the option, to make sure it fails.
+{
+  const { clientSide, serverSide } = MakeDuplexPair();
+
+  const req = https.request({
+    createConnection: common.mustCall(() => clientSide)
+  }, common.mustNotCall());
+  req.end();
+  req.on('error', common.mustCall());
+
+  serverSide.resume();  // Dump the request
+  serverSide.end('HTTP/1.1 200 OK\r\n' +
+                 'Hello: ' + 'A'.repeat(http.maxHeaderSize * 3) + '\r\n' +
+                 'Content-Length: 0\r\n' +
+                 '\r\n\r\n');
+}
+
+// Test 3: The client sends larger headers than what would otherwise be allowed.
+{
+  const testData = 'Hello, World!\n';
+  const server = https.createServer(
+    { maxHeaderSize: http.maxHeaderSize * 4,
+      ...certFixture },
+    common.mustCall((req, res) => {
+      res.statusCode = 200;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end(testData);
+    }));
+
+  server.on('clientError', common.mustNotCall());
+
+  server.listen(0, common.mustCall(() => {
+    const client = tls.connect({
+      port: server.address().port,
+      rejectUnauthorized: false
+    });
+    client.write(
+      'GET / HTTP/1.1\r\n' +
+      'Hello: ' + 'A'.repeat(http.maxHeaderSize * 3) + '\r\n' +
+      '\r\n\r\n');
+    client.end();
+
+    client.on('data', () => {});
+    finished(client, common.mustCall(() => {
+      server.close();
+    }));
+  }));
+}
+
+// Test 4: The same as Test 3 except without the option, to make sure it fails.
+{
+  const server = https.createServer({ ...certFixture }, common.mustNotCall());
+
+  // clientError may be emitted multiple times when header is larger than
+  // maxHeaderSize.
+  server.on('clientError', common.mustCallAtLeast(() => {}, 1));
+
+  server.listen(0, common.mustCall(() => {
+    const client = tls.connect({
+      port: server.address().port,
+      rejectUnauthorized: false
+    });
+    client.write(
+      'GET / HTTP/1.1\r\n' +
+      'Hello: ' + 'A'.repeat(http.maxHeaderSize * 3) + '\r\n' +
+      '\r\n\r\n');
+    client.end();
+
+    client.on('data', () => {});
+    finished(client, common.mustCall(() => {
+      server.close();
+    }));
+  }));
+}
diff --git a/test/parallel/test-https-max-headers-count.js b/test/parallel/test-https-max-headers-count.js
index 12aaaa9cd3ad84d887aac9e394c82026b8a090f4..f8e4e64bfb94dd0302e0fdc66184c3bc9c5707c8 100644
--- a/test/parallel/test-https-max-headers-count.js
+++ b/test/parallel/test-https-max-headers-count.js
@@ -25,7 +25,7 @@ for (let i = 0; i < N; ++i) {
 const maxAndExpected = [ // for server
   [50, 50],
   [1500, 102],
-  [0, N + 2] // Host and Connection
+  [0, N + 2], // Host and Connection
 ];
 let max = maxAndExpected[requests][0];
 let expected = maxAndExpected[requests][1];
@@ -46,7 +46,7 @@ server.listen(0, common.mustCall(() => {
   const maxAndExpected = [ // for client
     [20, 20],
     [1200, 103],
-    [0, N + 3] // Connection, Date and Transfer-Encoding
+    [0, N + 3], // Connection, Date and Transfer-Encoding
   ];
   const doRequest = common.mustCall(() => {
     const max = maxAndExpected[responses][0];
diff --git a/test/parallel/test-https-options-boolean-check.js b/test/parallel/test-https-options-boolean-check.js
index 65a17f9f7605b09cee13f3df87294e4dfe1c351a..9740704e169f1e6d6c0324323e4cf08b1a27845a 100644
--- a/test/parallel/test-https-options-boolean-check.js
+++ b/test/parallel/test-https-options-boolean-check.js
@@ -61,7 +61,7 @@ const caArrDataView = toDataView(caCert);
   [[keyStr, keyStr2], false],
   [false, [certStr, certStr2]],
   [[{ pem: keyBuff }], false],
-  [[{ pem: keyBuff }, { pem: keyBuff }], false]
+  [[{ pem: keyBuff }, { pem: keyBuff }], false],
 ].forEach(([key, cert]) => {
   https.createServer({ key, cert });
 });
@@ -80,7 +80,7 @@ const caArrDataView = toDataView(caCert);
   [[keyBuff, true], [certBuff, certBuff2], 1],
   [[true, keyStr2], [certStr, certStr2], 0],
   [[true, false], [certBuff, certBuff2], 0],
-  [true, [certBuff, certBuff2]]
+  [true, [certBuff, certBuff2]],
 ].forEach(([key, cert, index]) => {
   const val = index === undefined ? key : key[index];
   assert.throws(() => {
@@ -141,7 +141,7 @@ const caArrDataView = toDataView(caCert);
   [keyBuff, certBuff, {}],
   [keyBuff, certBuff, 1],
   [keyBuff, certBuff, true],
-  [keyBuff, certBuff, [caCert, true], 1]
+  [keyBuff, certBuff, [caCert, true], 1],
 ].forEach(([key, cert, ca, index]) => {
   const val = index === undefined ? ca : ca[index];
   assert.throws(() => {
diff --git a/test/parallel/test-https-server-request-timeout.js b/test/parallel/test-https-server-request-timeout.js
new file mode 100644
index 0000000000000000000000000000000000000000..66a1cb9f25f82ec9343345cde1e471ef01ef54ba
--- /dev/null
+++ b/test/parallel/test-https-server-request-timeout.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const { createServer } = require('https');
+const fixtures = require('../common/fixtures');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+const server = createServer(options);
+
+// 0 seconds is the default
+assert.strictEqual(server.requestTimeout, 0);
+const requestTimeout = common.platformTimeout(1000);
+server.requestTimeout = requestTimeout;
+assert.strictEqual(server.requestTimeout, requestTimeout);
diff --git a/test/parallel/test-icu-punycode.js b/test/parallel/test-icu-punycode.js
index 7595ffc4937c46dd835a0db4ec993e49d5a11a02..29e88f9b9a62625a8598f01236d7d8e2da937f23 100644
--- a/test/parallel/test-icu-punycode.js
+++ b/test/parallel/test-icu-punycode.js
@@ -16,10 +16,7 @@ assert(!icu.hasConverter('x'),
        'hasConverter should report converter does not exist for x');
 
 const tests = require('../fixtures/url-idna.js');
-const fixtures = require('../common/fixtures');
-const wptToASCIITests = require(
-  fixtures.path('wpt', 'url', 'resources', 'toascii.json')
-);
+const fixtures = require('../fixtures/icu-punycode-toascii.json');
 
 {
   for (const [i, { ascii, unicode }] of tests.entries()) {
@@ -33,7 +30,7 @@ const wptToASCIITests = require(
 }
 
 {
-  for (const [i, test] of wptToASCIITests.entries()) {
+  for (const [i, test] of fixtures.entries()) {
     if (typeof test === 'string')
       continue; // skip comments
     const { comment, input, output } = test;
diff --git a/test/parallel/test-icu-transcode.js b/test/parallel/test-icu-transcode.js
index 20ecab7213b2920ec1e6b603da547a842c033f9a..e9aced128eec21e2a289043b21cf613627588aad 100644
--- a/test/parallel/test-icu-transcode.js
+++ b/test/parallel/test-icu-transcode.js
@@ -83,3 +83,8 @@ assert.deepStrictEqual(
   const dest = buffer.transcode(new Uint8Array(), 'utf8', 'latin1');
   assert.strictEqual(dest.length, 0);
 }
+
+// Test that it doesn't crash
+{
+  buffer.transcode(new buffer.SlowBuffer(1), 'utf16le', 'ucs2');
+}
diff --git a/test/parallel/test-inspect-async-hook-setup-at-inspect.js b/test/parallel/test-inspect-async-hook-setup-at-inspect.js
index b68617b5d522762b8306831a6280389e23ef1fe1..2c755582852a01d72889e5c0f5675b41bb3ad51a 100644
--- a/test/parallel/test-inspect-async-hook-setup-at-inspect.js
+++ b/test/parallel/test-inspect-async-hook-setup-at-inspect.js
@@ -30,7 +30,7 @@ async function setupTimeoutForStackTrace(session) {
   await session.send([
     { 'method': 'Runtime.evaluate',
       'params': { expression: 'setupTimeoutWithBreak()' } },
-    { 'method': 'Debugger.resume' }
+    { 'method': 'Debugger.resume' },
   ]);
 }
 
@@ -54,7 +54,7 @@ async function runTests() {
       'params': { 'maxDepth': 10 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ]);
 
   await waitForInitialSetup(session);
diff --git a/test/parallel/test-inspect-publish-uid.js b/test/parallel/test-inspect-publish-uid.js
index 58d651e97dc64eecc58a75a5d6da90ce53e92c58..32550ddb66983a7f13b6042412bb1fb58b4ab044 100644
--- a/test/parallel/test-inspect-publish-uid.js
+++ b/test/parallel/test-inspect-publish-uid.js
@@ -10,7 +10,7 @@ const { spawnSync } = require('child_process');
   await testArg('stderr');
   await testArg('http');
   await testArg('http,stderr');
-})();
+})().then(common.mustCall());
 
 async function testArg(argValue) {
   console.log('Checks ' + argValue + '..');
@@ -20,7 +20,7 @@ async function testArg(argValue) {
   const nodeProcess = spawnSync(process.execPath, [
     '--inspect=0',
     `--inspect-publish-uid=${argValue}`,
-    '-e', `(${scriptMain.toString()})(${hasHttp ? 200 : 404})`
+    '-e', `(${scriptMain.toString()})(${hasHttp ? 200 : 404})`,
   ]);
   const hasWebSocketInStderr = checkStdError(
     nodeProcess.stderr.toString('utf8'));
diff --git a/test/parallel/test-inspector-connect-main-thread.js b/test/parallel/test-inspector-connect-main-thread.js
index be34981cd0c5be7ad1bc330527be40275d0d1f07..86ff6866bc064e5f616e65be2acd37bfef2cc9e2 100644
--- a/test/parallel/test-inspector-connect-main-thread.js
+++ b/test/parallel/test-inspector-connect-main-thread.js
@@ -111,7 +111,7 @@ async function main() {
     'Runtime.enable',
     'Debugger.setBreakpointByUrl',
     'Debugger.evaluateOnCallFrame',
-    'Debugger.resume'
+    'Debugger.resume',
   ]);
 }
 
diff --git a/test/parallel/test-inspector-esm.js b/test/parallel/test-inspector-esm.js
index b9813e50c29ded58e848f5096ac02e840d9ac159..590432ad9ac31d15bd770edcc2d767546bb3cd3c 100644
--- a/test/parallel/test-inspector-esm.js
+++ b/test/parallel/test-inspector-esm.js
@@ -33,7 +33,7 @@ async function testBreakpointOnStart(session) {
       'params': { 'interval': 100 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ];
 
   await session.send(commands);
@@ -48,15 +48,14 @@ async function testBreakpoint(session) {
       'params': { 'lineNumber': 7,
                   'url': session.scriptURL(),
                   'columnNumber': 0,
-                  'condition': ''
-      }
-    },
+                  'condition': '' } },
     { 'method': 'Debugger.resume' },
   ];
   await session.send(commands);
   const { scriptSource } = await session.send({
     'method': 'Debugger.getScriptSource',
-    'params': { 'scriptId': session.mainScriptId } });
+    'params': { 'scriptId': session.mainScriptId },
+  });
   assert(scriptSource && (scriptSource.includes(session.script())),
          `Script source is wrong: ${scriptSource}`);
 
diff --git a/test/parallel/test-inspector-has-idle.js b/test/parallel/test-inspector-has-idle.js
new file mode 100644
index 0000000000000000000000000000000000000000..c14590353e678050198e20d37ee4decd83f4754f
--- /dev/null
+++ b/test/parallel/test-inspector-has-idle.js
@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { Session } = require('inspector');
+const { promisify } = require('util');
+
+const sleep = promisify(setTimeout);
+
+async function test() {
+  const inspector = new Session();
+  inspector.connect();
+
+  inspector.post('Profiler.enable');
+  inspector.post('Profiler.start');
+
+  await sleep(1000);
+
+  const { profile } = await new Promise((resolve, reject) => {
+    inspector.post('Profiler.stop', (err, params) => {
+      if (err) return reject(err);
+      resolve(params);
+    });
+  });
+
+  let hasIdle = false;
+  for (const node of profile.nodes) {
+    if (node.callFrame.functionName === '(idle)') {
+      hasIdle = true;
+      break;
+    }
+  }
+  assert(hasIdle);
+
+  inspector.post('Profiler.disable');
+  inspector.disconnect();
+}
+
+test().then(common.mustCall(() => {
+  console.log('Done!');
+}));
diff --git a/test/parallel/test-inspector-heapdump.js b/test/parallel/test-inspector-heapdump.js
index 4520de731fa57d92343d6fbb25dd5cbddac23422..33b6020ce26c1bae0b4f67ffe721fa36a1b70451 100644
--- a/test/parallel/test-inspector-heapdump.js
+++ b/test/parallel/test-inspector-heapdump.js
@@ -18,8 +18,7 @@ session.on('HeapProfiler.addHeapSnapshotChunk', (m) => {
   chunks.push(m.params.chunk);
 });
 
-session.post('HeapProfiler.takeHeapSnapshot', null, common.mustCall((e, r) => {
-  assert.ifError(e);
+session.post('HeapProfiler.takeHeapSnapshot', null, common.mustSucceed((r) => {
   assert.deepStrictEqual(r, {});
   session.disconnect();
 
diff --git a/test/parallel/test-inspector-multisession-ws.js b/test/parallel/test-inspector-multisession-ws.js
index 7981eef0d301493bb47b6bc7bf028216311efdd0..1caae767ec55c39694734cf18addf50270fa0cc1 100644
--- a/test/parallel/test-inspector-multisession-ws.js
+++ b/test/parallel/test-inspector-multisession-ws.js
@@ -37,7 +37,7 @@ async function setupSession(node) {
       'params': { 'interval': 100 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ]);
   return session;
 }
@@ -56,7 +56,7 @@ async function testSuspend(sessionA, sessionB) {
   sessionA.send({ 'method': 'Debugger.pause' });
   return Promise.all([
     sessionA.waitForNotification('Debugger.paused', 'SessionA paused'),
-    sessionB.waitForNotification('Debugger.paused', 'SessionB paused')
+    sessionB.waitForNotification('Debugger.paused', 'SessionB paused'),
   ]);
 }
 
diff --git a/test/parallel/test-inspector-tracing-domain.js b/test/parallel/test-inspector-tracing-domain.js
index 152df1491553f1a7367439c609e15d7d7d78a759..164fbe1cd86b67ce36a41f085acd392c0537ea5f 100644
--- a/test/parallel/test-inspector-tracing-domain.js
+++ b/test/parallel/test-inspector-tracing-domain.js
@@ -30,7 +30,7 @@ function post(message, data) {
 function generateTrace() {
   return new Promise((resolve) => setTimeout(() => {
     for (let i = 0; i < 1000000; i++) {
-      'test' + i;
+      'test' + i; // eslint-disable-line no-unused-expressions
     }
     resolve();
   }, 1));
diff --git a/test/parallel/test-inspector-vm-global-accessors-sideeffects.js b/test/parallel/test-inspector-vm-global-accessors-sideeffects.js
index 33545e14c7ae2be7ef1169f1d63fa65326b6eeab..b07ce182232fba4c37ed5ec30c003d1093be3bab 100644
--- a/test/parallel/test-inspector-vm-global-accessors-sideeffects.js
+++ b/test/parallel/test-inspector-vm-global-accessors-sideeffects.js
@@ -19,8 +19,7 @@ session.post('Runtime.evaluate', {
   expression: 'a',
   throwOnSideEffect: true,
   contextId: 2 // context's id
-}, common.mustCall((error, res) => {
-  assert.ifError(error),
+}, common.mustSucceed((res) => {
   assert.deepStrictEqual(res, {
     result: {
       type: 'number',
diff --git a/test/parallel/test-internal-errors.js b/test/parallel/test-internal-errors.js
index fbb8a0a86a3852cd34b2cf586663a8c3f3e7f714..7bcc7dcc330c2cca310cd8a240a8e2e009a243f8 100644
--- a/test/parallel/test-internal-errors.js
+++ b/test/parallel/test-internal-errors.js
@@ -1,6 +1,6 @@
 // Flags: --expose-internals
 'use strict';
-const common = require('../common');
+require('../common');
 const {
   hijackStdout,
   restoreStdout,
@@ -50,10 +50,13 @@ errors.E('TEST_ERROR_2', (a, b) => `${a} ${b}`, Error);
 }
 
 {
-  common.expectsInternalAssertion(
+  assert.throws(
     () => new errors.codes.TEST_ERROR_1(),
-    'Code: TEST_ERROR_1; The provided arguments ' +
-    'length (0) does not match the required ones (1).'
+    {
+      message: /^Code: TEST_ERROR_1; The provided arguments length \(0\) does not match the required ones \(1\)\./,
+      name: 'Error',
+      code: 'ERR_INTERNAL_ASSERTION'
+    }
   );
 }
 
diff --git a/test/parallel/test-internal-fs-syncwritestream.js b/test/parallel/test-internal-fs-syncwritestream.js
index bf4776550b6edf7ad41c3dbbd3648c97f0d7a956..bafa5fd8f4624fed8d190a8d10238f7c19a9fa02 100644
--- a/test/parallel/test-internal-fs-syncwritestream.js
+++ b/test/parallel/test-internal-fs-syncwritestream.js
@@ -38,6 +38,8 @@ const filename = path.join(tmpdir.path, 'sync-write-stream.txt');
 
   assert.strictEqual(stream._write(chunk, null, common.mustCall(1)), true);
   assert.strictEqual(fs.readFileSync(filename).equals(chunk), true);
+
+  fs.closeSync(fd);
 }
 
 // Verify that the stream will unset the fd after destroy().
@@ -68,5 +70,7 @@ const filename = path.join(tmpdir.path, 'sync-write-stream.txt');
   assert.strictEqual(stream.fd, fd);
 
   stream.end();
-  assert.strictEqual(stream.fd, null);
+  stream.on('close', common.mustCall(() => {
+    assert.strictEqual(stream.fd, null);
+  }));
 }
diff --git a/test/parallel/test-internal-iterable-weak-map.js b/test/parallel/test-internal-iterable-weak-map.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2befe13da87f3744e376a7ded88b28f7d4942f8
--- /dev/null
+++ b/test/parallel/test-internal-iterable-weak-map.js
@@ -0,0 +1,101 @@
+// Flags: --expose-gc --expose-internals
+'use strict';
+
+const common = require('../common');
+const { deepStrictEqual, strictEqual } = require('assert');
+const { IterableWeakMap } = require('internal/util/iterable_weak_map');
+
+// Ensures iterating over the map does not rely on methods which can be
+// mutated by users.
+Reflect.getPrototypeOf(function*() {}).prototype.next = common.mustNotCall();
+Reflect.getPrototypeOf(new Set()[Symbol.iterator]()).next =
+  common.mustNotCall();
+
+// It drops entry if a reference is no longer held.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+    moduleC: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleB, 'discard');
+  wm.set(_cache.moduleC, 'goodbye');
+  delete _cache.moduleB;
+  setImmediate(() => {
+    _cache; // eslint-disable-line no-unused-expressions
+    globalThis.gc();
+    const values = [...wm];
+    deepStrictEqual(values, ['hello', 'goodbye']);
+  });
+}
+
+// It updates an existing entry, if the same key is provided twice.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleB, 'goodbye');
+  wm.set(_cache.moduleB, 'goodnight');
+  const values = [...wm];
+  deepStrictEqual(values, ['hello', 'goodnight']);
+}
+
+// It allows entry to be deleted by key.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+    moduleC: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleB, 'discard');
+  wm.set(_cache.moduleC, 'goodbye');
+  wm.delete(_cache.moduleB);
+  const values = [...wm];
+  deepStrictEqual(values, ['hello', 'goodbye']);
+}
+
+// It handles delete for key that does not exist.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+    moduleC: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleC, 'goodbye');
+  wm.delete(_cache.moduleB);
+  const values = [...wm];
+  deepStrictEqual(values, ['hello', 'goodbye']);
+}
+
+// It allows an entry to be fetched by key.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+    moduleC: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleB, 'discard');
+  wm.set(_cache.moduleC, 'goodbye');
+  strictEqual(wm.get(_cache.moduleB), 'discard');
+}
+
+// It returns true for has() if key exists.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  strictEqual(wm.has(_cache.moduleA), true);
+}
diff --git a/test/parallel/test-internal-module-require.js b/test/parallel/test-internal-module-require.js
index 5b20a83393669fa3618a80425e407ce5fd500117..c6e2057d3da1eee0c0b9268d34750c4d75d1e8e6 100644
--- a/test/parallel/test-internal-module-require.js
+++ b/test/parallel/test-internal-module-require.js
@@ -70,7 +70,7 @@ const expectedPublicModules = new Set([
   'v8',
   'vm',
   'worker_threads',
-  'zlib'
+  'zlib',
 ]);
 
 if (process.argv[2] === 'child') {
diff --git a/test/parallel/test-internal-module-wrap.js b/test/parallel/test-internal-module-wrap.js
index b0cc3a1cf02d8a86e3922a993686cd0759956f9c..520a83a3a47c0e46280eafc829a032c573c37df8 100644
--- a/test/parallel/test-internal-module-wrap.js
+++ b/test/parallel/test-internal-module-wrap.js
@@ -1,8 +1,6 @@
-'use strict';
-
 // Flags: --expose-internals
-
-require('../common');
+'use strict';
+const common = require('../common');
 const assert = require('assert');
 
 const { internalBinding } = require('internal/test/binding');
@@ -10,7 +8,7 @@ const { ModuleWrap } = internalBinding('module_wrap');
 const { getPromiseDetails, isPromise } = internalBinding('util');
 const setTimeoutAsync = require('util').promisify(setTimeout);
 
-const foo = new ModuleWrap('foo', undefined, 'export * from "bar"; 6;', 0, 0);
+const foo = new ModuleWrap('foo', undefined, 'export * from "bar";', 0, 0);
 const bar = new ModuleWrap('bar', undefined, 'export const five = 5', 0, 0);
 
 (async () => {
@@ -24,6 +22,6 @@ const bar = new ModuleWrap('bar', undefined, 'export const five = 5', 0, 0);
 
   foo.instantiate();
 
-  assert.strictEqual(await foo.evaluate(-1, false), 6);
+  assert.strictEqual(await foo.evaluate(-1, false), undefined);
   assert.strictEqual(foo.getNamespace().five, 5);
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-internal-util-decorate-error-stack.js b/test/parallel/test-internal-util-decorate-error-stack.js
index b12d50bee79abcb4363e0d0db79d1fe48db1fa94..b125a29741cb73d98dd9b3afd7cacbe547579341 100644
--- a/test/parallel/test-internal-util-decorate-error-stack.js
+++ b/test/parallel/test-internal-util-decorate-error-stack.js
@@ -56,7 +56,7 @@ checkStack(err.stack);
 // Verify that the stack is only decorated once for uncaught exceptions.
 const args = [
   '-e',
-  `require('${badSyntaxPath}')`
+  `require('${badSyntaxPath}')`,
 ];
 const result = spawnSync(process.argv[0], args, { encoding: 'utf8' });
 checkStack(result.stderr);
diff --git a/test/parallel/test-internal-util-normalizeencoding.js b/test/parallel/test-internal-util-normalizeencoding.js
index d7a0259ac9c9fd54ac61a4fc42e2b432cd8aef6a..167880d661ff4cff39a33fea449388124fc8c072 100644
--- a/test/parallel/test-internal-util-normalizeencoding.js
+++ b/test/parallel/test-internal-util-normalizeencoding.js
@@ -33,6 +33,9 @@ const tests = [
   ['base64', 'base64'],
   ['BASE64', 'base64'],
   ['Base64', 'base64'],
+  ['base64url', 'base64url'],
+  ['BASE64url', 'base64url'],
+  ['Base64url', 'base64url'],
   ['hex', 'hex'],
   ['HEX', 'hex'],
   ['ASCII', 'ascii'],
@@ -43,7 +46,7 @@ const tests = [
   [NaN, undefined],
   [0, undefined],
   [[], undefined],
-  [{}, undefined]
+  [{}, undefined],
 ];
 
 tests.forEach((e, i) => {
diff --git a/test/parallel/test-internal-validators-validateoneof.js b/test/parallel/test-internal-validators-validateoneof.js
new file mode 100644
index 0000000000000000000000000000000000000000..38a79a051512410280aeeb7339b6d995f466a147
--- /dev/null
+++ b/test/parallel/test-internal-validators-validateoneof.js
@@ -0,0 +1,69 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { validateOneOf } = require('internal/validators');
+
+{
+  // validateOneOf number incorrect.
+  const allowed = [2, 3];
+  assert.throws(() => validateOneOf(1, 'name', allowed), {
+    code: 'ERR_INVALID_ARG_VALUE',
+    // eslint-disable-next-line quotes
+    message: `The argument 'name' must be one of: 2, 3. Received 1`
+  });
+  assert.throws(() => validateOneOf(1, 'name', allowed, true), {
+    code: 'ERR_INVALID_OPT_VALUE',
+    message: 'The value "1" is invalid for option "name". ' +
+      'Must be one of: 2, 3'
+  });
+}
+
+{
+  // validateOneOf number correct.
+  validateOneOf(2, 'name', [1, 2]);
+}
+
+{
+  // validateOneOf string incorrect.
+  const allowed = ['b', 'c'];
+  assert.throws(() => validateOneOf('a', 'name', allowed), {
+    code: 'ERR_INVALID_ARG_VALUE',
+    // eslint-disable-next-line quotes
+    message: `The argument 'name' must be one of: 'b', 'c'. Received 'a'`
+  });
+  assert.throws(() => validateOneOf('a', 'name', allowed, true), {
+    code: 'ERR_INVALID_OPT_VALUE',
+    // eslint-disable-next-line quotes
+    message: `The value "a" is invalid for option "name". ` +
+    "Must be one of: 'b', 'c'",
+  });
+}
+
+{
+  // validateOneOf string correct.
+  validateOneOf('two', 'name', ['one', 'two']);
+}
+
+{
+  // validateOneOf Symbol incorrect.
+  const allowed = [Symbol.for('b'), Symbol.for('c')];
+  assert.throws(() => validateOneOf(Symbol.for('a'), 'name', allowed), {
+    code: 'ERR_INVALID_ARG_VALUE',
+    // eslint-disable-next-line quotes
+    message: `The argument 'name' must be one of: Symbol(b), Symbol(c). ` +
+      'Received Symbol(a)'
+  });
+  assert.throws(() => validateOneOf(Symbol.for('a'), 'name', allowed, true), {
+    code: 'ERR_INVALID_OPT_VALUE',
+    message: 'The value "Symbol(a)" is invalid for option "name". ' +
+      'Must be one of: Symbol(b), Symbol(c)',
+  });
+}
+
+{
+  // validateOneOf Symbol correct.
+  const allowed = [Symbol.for('b'), Symbol.for('c')];
+  validateOneOf(Symbol.for('b'), 'name', allowed);
+}
diff --git a/test/parallel/test-internal-validators-validateport.js b/test/parallel/test-internal-validators-validateport.js
index ea9c3a7b58b6922ec31199df0eb57b13692c95a4..a4c92b8dbca929dad85deedf1df57f959f86a6d8 100644
--- a/test/parallel/test-internal-validators-validateport.js
+++ b/test/parallel/test-internal-validators-validateport.js
@@ -17,7 +17,7 @@ for (let n = 0; n <= 0xFFFF; n++) {
   -1, 'a', {}, [], false, true,
   0xFFFF + 1, Infinity, -Infinity, NaN,
   undefined, null, '', ' ', 1.1, '0x',
-  '-0x1', '-0o1', '-0b1', '0o', '0b'
+  '-0x1', '-0o1', '-0b1', '0o', '0b',
 ].forEach((i) => assert.throws(() => validatePort(i), {
   code: 'ERR_SOCKET_BAD_PORT'
 }));
diff --git a/test/parallel/test-intl.js b/test/parallel/test-intl.js
index 4daccac79d51c320bee6f566cc2ab42b019a11a6..956383c5281389cfcd3e86588547b2a5ab33afed 100644
--- a/test/parallel/test-intl.js
+++ b/test/parallel/test-intl.js
@@ -104,6 +104,13 @@ if (!common.hasIntl) {
     const numberFormat = new Intl.NumberFormat(['en']).format(12345.67890);
     assert.strictEqual(numberFormat, '12,345.679');
   }
+  // Number format resolved options
+  {
+    const numberFormat = new Intl.NumberFormat('en-US', { style: 'percent' });
+    const resolvedOptions = numberFormat.resolvedOptions();
+    assert.strictEqual(resolvedOptions.locale, 'en-US');
+    assert.strictEqual(resolvedOptions.style, 'percent');
+  }
   // Significant Digits
   {
     const loc = ['en-US'];
@@ -133,7 +140,7 @@ if (!common.hasIntl) {
     execFile(
       process.execPath, ['-p', 'new Date().toLocaleString()'],
       { env },
-      common.mustCall((e) => assert.ifError(e))
+      common.mustSucceed()
     );
   }
 
@@ -144,7 +151,7 @@ if (!common.hasIntl) {
       process.execPath,
       ['-p', 'new Intl.NumberFormat().resolvedOptions().locale'],
       { env },
-      common.mustCall((e) => assert.ifError(e))
+      common.mustSucceed()
     );
   }
 }
diff --git a/test/parallel/test-kill-segfault-freebsd.js b/test/parallel/test-kill-segfault-freebsd.js
index 8532f11c86b804497c20b85ff4ad77824eef1ebc..e17b00741bd9aa79bb39d7cac96263c1a44b36ad 100644
--- a/test/parallel/test-kill-segfault-freebsd.js
+++ b/test/parallel/test-kill-segfault-freebsd.js
@@ -11,7 +11,7 @@ const child_process = require('child_process');
 // NOTE: Was crashing on FreeBSD
 const cp = child_process.spawn(process.execPath, [
   '-e',
-  'process.kill(process.pid, "SIGINT")'
+  'process.kill(process.pid, "SIGINT")',
 ]);
 
 cp.on('exit', function(code) {
diff --git a/test/parallel/test-macos-app-sandbox.js b/test/parallel/test-macos-app-sandbox.js
index 53484834a36758a31f9656216f504547dd4946bc..b6743e8ba50da443d45aaac91e16ccdaa766da87 100644
--- a/test/parallel/test-macos-app-sandbox.js
+++ b/test/parallel/test-macos-app-sandbox.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../common');
 if (process.platform !== 'darwin')
-  common.skip('App Sandbox is only avaliable on Darwin');
+  common.skip('App Sandbox is only available on Darwin');
 
 const fixtures = require('../common/fixtures');
 const tmpdir = require('../common/tmpdir');
@@ -43,14 +43,14 @@ assert.strictEqual(
     '--entitlements', fixtures.path(
       'macos-app-sandbox', 'node_sandboxed.entitlements'),
     '--force', '-s', '-',
-    appBundlePath
+    appBundlePath,
   ]).status,
   0);
 
 // Sandboxed app shouldn't be able to read the home dir
 assert.notStrictEqual(
   child_process.spawnSync(appExecutablePath, [
-    '-e', 'fs.readdirSync(process.argv[1])', os.homedir()
+    '-e', 'fs.readdirSync(process.argv[1])', os.homedir(),
   ]).status,
   0);
 
diff --git a/test/parallel/test-memory-usage-emfile.js b/test/parallel/test-memory-usage-emfile.js
index 8dc1360d985bde2d56d7e8baaf3fd10365b3015d..05b112e91803d13db03fcfbb114a89654bd5eded 100644
--- a/test/parallel/test-memory-usage-emfile.js
+++ b/test/parallel/test-memory-usage-emfile.js
@@ -14,5 +14,5 @@ const files = [];
 while (files.length < 256)
   files.push(fs.openSync(__filename, 'r'));
 
-const r = process.memoryUsage();
-assert.strictEqual(r.rss > 0, true);
+const r = process.memoryUsage.rss();
+assert.strictEqual(r > 0, true);
diff --git a/test/parallel/test-memory-usage.js b/test/parallel/test-memory-usage.js
index e8743c47d235c0cd75b45327d52b67a51c3d6773..8e5ea4de5bf587530feb04ea10f02417cd87c9b9 100644
--- a/test/parallel/test-memory-usage.js
+++ b/test/parallel/test-memory-usage.js
@@ -26,8 +26,11 @@ const assert = require('assert');
 
 const r = process.memoryUsage();
 // On IBMi, the rss memory always returns zero
-if (!common.isIBMi)
+if (!common.isIBMi) {
   assert.ok(r.rss > 0);
+  assert.ok(process.memoryUsage.rss() > 0);
+}
+
 assert.ok(r.heapTotal > 0);
 assert.ok(r.heapUsed > 0);
 assert.ok(r.external > 0);
@@ -39,8 +42,8 @@ if (r.arrayBuffers > 0) {
   const ab = new ArrayBuffer(size);
 
   const after = process.memoryUsage();
-  assert(after.external - r.external >= size,
-         `${after.external} - ${r.external} >= ${size}`);
+  assert.ok(after.external - r.external >= size,
+            `${after.external} - ${r.external} >= ${size}`);
   assert.strictEqual(after.arrayBuffers - r.arrayBuffers, size,
                      `${after.arrayBuffers} - ${r.arrayBuffers} === ${size}`);
 }
diff --git a/test/parallel/test-microtask-queue-integration.js b/test/parallel/test-microtask-queue-integration.js
index 57c384f8ba817712b7b487be154948be055230e3..69d55253a25295427281f36c46c556be611cb4df 100644
--- a/test/parallel/test-microtask-queue-integration.js
+++ b/test/parallel/test-microtask-queue-integration.js
@@ -26,7 +26,7 @@ const assert = require('assert');
 const implementations = [
   function(fn) {
     Promise.resolve().then(fn);
-  }
+  },
 ];
 
 let expected = 0;
diff --git a/test/parallel/test-module-circular-dependency-warning.js b/test/parallel/test-module-circular-dependency-warning.js
new file mode 100644
index 0000000000000000000000000000000000000000..35ec16762b89e4a16252ebd0f6b9e624d81d7cf7
--- /dev/null
+++ b/test/parallel/test-module-circular-dependency-warning.js
@@ -0,0 +1,45 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+common.expectWarning({
+  Warning: [
+    ["Accessing non-existent property 'missingPropB' " +
+     'of module exports inside circular dependency'],
+    ["Accessing non-existent property 'Symbol(someSymbol)' " +
+     'of module exports inside circular dependency'],
+    ["Accessing non-existent property 'missingPropModuleExportsB' " +
+     'of module exports inside circular dependency'],
+  ]
+});
+const required = require(fixtures.path('cycles', 'warning-a.js'));
+assert.strictEqual(Object.getPrototypeOf(required), Object.prototype);
+
+const requiredWithModuleExportsOverridden =
+  require(fixtures.path('cycles', 'warning-moduleexports-a.js'));
+assert.strictEqual(Object.getPrototypeOf(requiredWithModuleExportsOverridden),
+                   Object.prototype);
+
+// If module.exports is not a regular object, no warning should be emitted.
+const classExport =
+  require(fixtures.path('cycles', 'warning-moduleexports-class-a.js'));
+assert.strictEqual(Object.getPrototypeOf(classExport).name, 'Parent');
+
+// If module.exports.__esModule is set, no warning should be emitted.
+const esmTranspiledExport =
+  require(fixtures.path('cycles', 'warning-esm-transpiled-a.js'));
+assert.strictEqual(esmTranspiledExport.__esModule, true);
+
+// If module.exports.__esModule is being accessed but is not present, e.g.
+// because only the one of the files is a transpiled ES module, no warning
+// should be emitted.
+const halfTranspiledExport =
+  require(fixtures.path('cycles', 'warning-esm-half-transpiled-a.js'));
+assert.strictEqual(halfTranspiledExport.__esModule, undefined);
+
+// No circular check is done to prevent triggering proxy traps, if
+// module.exports is set to a proxy that contains a `getPrototypeOf` or
+// `setPrototypeOf` trap.
+require(fixtures.path('cycles', 'warning-skip-proxy-traps-a.js'));
diff --git a/test/parallel/test-module-cjs-helpers.js b/test/parallel/test-module-cjs-helpers.js
deleted file mode 100644
index 12de65598e54e1d33662a20787c9424bb7318aa4..0000000000000000000000000000000000000000
--- a/test/parallel/test-module-cjs-helpers.js
+++ /dev/null
@@ -1,9 +0,0 @@
-'use strict';
-// Flags: --expose-internals
-
-require('../common');
-const assert = require('assert');
-const { builtinLibs } = require('internal/modules/cjs/helpers');
-
-const expectedLibs = process.features.inspector ? 34 : 33;
-assert.strictEqual(builtinLibs.length, expectedLibs);
diff --git a/test/parallel/test-module-loading-error.js b/test/parallel/test-module-loading-error.js
index 5bc01ce52d7279e0ec83caeedb4764c255261c36..8cbe8b2c67566336110788d057a8d58866631785 100644
--- a/test/parallel/test-module-loading-error.js
+++ b/test/parallel/test-module-loading-error.js
@@ -28,7 +28,7 @@ const errorMessagesByPlatform = {
   win32: ['is not a valid Win32 application'],
   linux: ['file too short', 'Exec format error'],
   sunos: ['unknown file type', 'not an ELF file'],
-  darwin: ['file too short'],
+  darwin: ['file too short', 'not a mach-o file'],
   aix: ['Cannot load module',
         'Cannot run a file that does not have a valid format.',
         'Exec format error'],
diff --git a/test/parallel/test-module-nodemodulepaths.js b/test/parallel/test-module-nodemodulepaths.js
index c79d2e6e72c64c6c0d1d995429dde0f2acc0bd3d..1e355882e0f3d76537573b54391c16af9fb02ec3 100644
--- a/test/parallel/test-module-nodemodulepaths.js
+++ b/test/parallel/test-module-nodemodulepaths.js
@@ -39,7 +39,7 @@ const cases = {
       'C:\\Users\\hefangshi\\AppData\\node_modules',
       'C:\\Users\\hefangshi\\node_modules',
       'C:\\Users\\node_modules',
-      'C:\\node_modules'
+      'C:\\node_modules',
     ]
   }, {
     file: 'C:\\Users\\Rocko Artischocko\\node_stuff\\foo',
@@ -48,7 +48,7 @@ const cases = {
       'C:\\Users\\Rocko Artischocko\\node_stuff\\node_modules',
       'C:\\Users\\Rocko Artischocko\\node_modules',
       'C:\\Users\\node_modules',
-      'C:\\node_modules'
+      'C:\\node_modules',
     ]
   }, {
     file: 'C:\\Users\\Rocko Artischocko\\node_stuff\\foo_node_modules',
@@ -58,17 +58,17 @@ Artischocko\\node_stuff\\foo_node_modules\\node_modules',
       'C:\\Users\\Rocko Artischocko\\node_stuff\\node_modules',
       'C:\\Users\\Rocko Artischocko\\node_modules',
       'C:\\Users\\node_modules',
-      'C:\\node_modules'
+      'C:\\node_modules',
     ]
   }, {
     file: 'C:\\node_modules',
     expect: [
-      'C:\\node_modules'
+      'C:\\node_modules',
     ]
   }, {
     file: 'C:\\',
     expect: [
-      'C:\\node_modules'
+      'C:\\node_modules',
     ]
   }],
   'POSIX': [{
@@ -83,7 +83,7 @@ node-gyp/node_modules/glob/node_modules',
       '/usr/lib/node_modules/npm/node_modules',
       '/usr/lib/node_modules',
       '/usr/node_modules',
-      '/node_modules'
+      '/node_modules',
     ]
   }, {
     file: '/usr/test/lib/node_modules/npm/foo',
@@ -93,7 +93,7 @@ node-gyp/node_modules/glob/node_modules',
       '/usr/test/lib/node_modules',
       '/usr/test/node_modules',
       '/usr/node_modules',
-      '/node_modules'
+      '/node_modules',
     ]
   }, {
     file: '/usr/test/lib/node_modules/npm/foo_node_modules',
@@ -103,17 +103,17 @@ node-gyp/node_modules/glob/node_modules',
       '/usr/test/lib/node_modules',
       '/usr/test/node_modules',
       '/usr/node_modules',
-      '/node_modules'
+      '/node_modules',
     ]
   }, {
     file: '/node_modules',
     expect: [
-      '/node_modules'
+      '/node_modules',
     ]
   }, {
     file: '/',
     expect: [
-      '/node_modules'
+      '/node_modules',
     ]
   }]
 };
diff --git a/test/parallel/test-net-after-close.js b/test/parallel/test-net-after-close.js
index 7d49780d001d6e5f1c8792dd3af2ae8814f1b6cf..413e8f75992de9227e50d2fdded9c5e7433394f7 100644
--- a/test/parallel/test-net-after-close.js
+++ b/test/parallel/test-net-after-close.js
@@ -32,6 +32,7 @@ const server = net.createServer(common.mustCall((s) => {
 server.listen(0, common.mustCall(() => {
   const c = net.createConnection(server.address().port);
   c.on('close', common.mustCall(() => {
+    /* eslint-disable no-unused-expressions */
     console.error('connection closed');
     assert.strictEqual(c._handle, null);
     // Calling functions / accessing properties of a closed socket should not
@@ -45,5 +46,6 @@ server.listen(0, common.mustCall(() => {
     c.remoteAddress;
     c.remotePort;
     server.close();
+    /* eslint-enable no-unused-expressions */
   }));
 }));
diff --git a/test/parallel/test-net-connect-buffer.js b/test/parallel/test-net-connect-buffer.js
index efdba4b5d8dd47dc9ffb05790224d55b85803010..749eee519904f5d74acb2aae125926323124ec43 100644
--- a/test/parallel/test-net-connect-buffer.js
+++ b/test/parallel/test-net-connect-buffer.js
@@ -51,29 +51,6 @@ tcp.listen(0, common.mustCall(function() {
   assert.strictEqual(socket.connecting, true);
   assert.strictEqual(socket.readyState, 'opening');
 
-  // Make sure that anything besides a buffer or a string throws.
-  assert.throws(() => socket.write(null),
-                {
-                  code: 'ERR_STREAM_NULL_VALUES',
-                  name: 'TypeError',
-                  message: 'May not write null values to stream'
-                });
-  [
-    true,
-    false,
-    1,
-    1.0,
-    +Infinity,
-    -Infinity
-  ].forEach((value) => {
-    assert.throws(() => socket.write(value), {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError',
-      message: 'The "chunk" argument must be of type string or an instance ' +
-               `of Buffer. Received type ${typeof value} (${value})`
-    });
-  });
-
   // Write a string that contains a multi-byte character sequence to test that
   // `bytesWritten` is incremented with the # of bytes, not # of characters.
   const a = "L'État, c'est ";
diff --git a/test/parallel/test-net-connect-options-fd.js b/test/parallel/test-net-connect-options-fd.js
index 62e1414421404a894ac8338ced584c3db82ed846..e9b35c0bfeadf44d7c494fa01c68f4f0e5639847 100644
--- a/test/parallel/test-net-connect-options-fd.js
+++ b/test/parallel/test-net-connect-options-fd.js
@@ -25,7 +25,7 @@ function testClients(getSocketOpt, getConnectOpt, getConnectCb) {
       .on('connect', getConnectCb(3)),
     new net.Socket(getSocketOpt(4)).connect(getConnectOpt(4), getConnectCb(4)),
     new net.Socket(getSocketOpt(5)).connect(getConnectOpt(5))
-      .on('connect', getConnectCb(5))
+      .on('connect', getConnectCb(5)),
   ];
 }
 
diff --git a/test/parallel/test-net-connect-options-port.js b/test/parallel/test-net-connect-options-port.js
index 91598f5f15af2f3f9f2c8a7018a20892e50ab075..8c78b957133bc4be0dcdcede6c93d6a53cc13a1c 100644
--- a/test/parallel/test-net-connect-options-port.js
+++ b/test/parallel/test-net-connect-options-port.js
@@ -129,7 +129,7 @@ function doConnect(args, getCb) {
       return socket.connect.apply(socket, args)
         .on('connect', getCb())
         .resume();
-    }
+    },
   ];
 }
 
diff --git a/test/parallel/test-net-during-close.js b/test/parallel/test-net-during-close.js
index 7bceb64041f2cc046f3087cbf62577037bd4d28a..3670ed9c273920b5ec6f6aa92292fd225c4067a3 100644
--- a/test/parallel/test-net-during-close.js
+++ b/test/parallel/test-net-during-close.js
@@ -28,6 +28,7 @@ const server = net.createServer(function(socket) {
 });
 
 server.listen(0, common.mustCall(function() {
+  /* eslint-disable no-unused-expressions */
   const client = net.createConnection(this.address().port);
   server.close();
   // Server connection event has not yet fired client is still attempting to
@@ -37,4 +38,5 @@ server.listen(0, common.mustCall(function() {
   client.remotePort;
   // Exit now, do not wait for the client error event.
   process.exit(0);
+  /* eslint-enable no-unused-expressions */
 }));
diff --git a/test/parallel/test-net-isipv4.js b/test/parallel/test-net-isipv4.js
index ec04505cedb27f29fdb17f05a959683c8908501f..8f5c30569ce988eb485015c96391f6674fb3d205 100644
--- a/test/parallel/test-net-isipv4.js
+++ b/test/parallel/test-net-isipv4.js
@@ -19,7 +19,7 @@ const v4 = [
   '192.0.2.235',
   '99.198.122.146',
   '46.51.197.88',
-  '173.194.34.134'
+  '173.194.34.134',
 ];
 
 const v4not = [
@@ -34,7 +34,7 @@ const v4not = [
   '1000.2.3.4',
   '999.2.3.4',
   '0000000192.168.0.200',
-  '192.168.0.2000000000'
+  '192.168.0.2000000000',
 ];
 
 v4.forEach((ip) => {
diff --git a/test/parallel/test-net-isipv6.js b/test/parallel/test-net-isipv6.js
index 7ba379c3bdd27e42af6146adfec7518127583ec5..855f17a076c6977f43a9f2313e0d74133cce15b6 100644
--- a/test/parallel/test-net-isipv6.js
+++ b/test/parallel/test-net-isipv6.js
@@ -131,7 +131,7 @@ const v6 = [
   'a:0:0:0:a:0:0:0',
   'a:0:0:0:0:0:0:0',
   'fe80::7:8%eth0',
-  'fe80::7:8%1'
+  'fe80::7:8%1',
 ];
 
 const v6not = [
@@ -232,7 +232,7 @@ const v6not = [
   '::ffff:257.1.2.3',
   '::ffff:12345678901234567890.1.26',
   '2001:0000:1234:0000:0000:C1C0:ABCD:0876 0',
-  '02001:0000:1234:0000:0000:C1C0:ABCD:0876'
+  '02001:0000:1234:0000:0000:C1C0:ABCD:0876',
 ];
 
 v6.forEach((ip) => {
diff --git a/test/parallel/test-net-normalize-args.js b/test/parallel/test-net-normalize-args.js
index 4677b396e258902ab01ab1f1140f1b13d8d5f47f..347c18d638f5f642190ca52ffc87048cc4b8032f 100644
--- a/test/parallel/test-net-normalize-args.js
+++ b/test/parallel/test-net-normalize-args.js
@@ -4,6 +4,7 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 const { normalizedArgsSymbol } = require('internal/net');
+const { getSystemErrorName } = require('util');
 
 function validateNormalizedArgs(input, output) {
   const args = net._normalizeArgs(input);
@@ -32,7 +33,7 @@ validateNormalizedArgs([{ port: 1234 }, assert.fail], res);
 
     socket.on('error', common.mustCall((err) => {
       assert(possibleErrors.includes(err.code));
-      assert(possibleErrors.includes(err.errno));
+      assert(possibleErrors.includes(getSystemErrorName(err.errno)));
       assert.strictEqual(err.syscall, 'connect');
       server.close();
     }));
diff --git a/test/parallel/test-net-pingpong.js b/test/parallel/test-net-pingpong.js
index e87ee10e43df84642726d696c6a580c3337c8321..7fb6678fe1a897bbceee94b5537302ed0bb60a9d 100644
--- a/test/parallel/test-net-pingpong.js
+++ b/test/parallel/test-net-pingpong.js
@@ -39,8 +39,7 @@ function pingPongTest(port, host) {
     assert.strictEqual(socket.server, server);
     assert.strictEqual(
       server,
-      server.getConnections(common.mustCall(function(err, connections) {
-        assert.ifError(err);
+      server.getConnections(common.mustSucceed((connections) => {
         assert.strictEqual(connections, 1);
       }))
     );
diff --git a/test/parallel/test-net-server-listen-options.js b/test/parallel/test-net-server-listen-options.js
index 035630468b7b195ed6fd2561fedae85aeccf7fb1..8753da6cc8d1dd5b2fa38b14fd5cf05041894a6f 100644
--- a/test/parallel/test-net-server-listen-options.js
+++ b/test/parallel/test-net-server-listen-options.js
@@ -20,7 +20,7 @@ function close() { this.close(); }
 // Test listen(port, cb) and listen({ port }, cb) combinations
 const listenOnPort = [
   (port, cb) => net.createServer().listen({ port }, cb),
-  (port, cb) => net.createServer().listen(port, cb)
+  (port, cb) => net.createServer().listen(port, cb),
 ];
 
 {
diff --git a/test/parallel/test-net-socket-constructor.js b/test/parallel/test-net-socket-constructor.js
index d1ac8b35121826a1b6c397fe26133e5d5774649e..0454a6fbe1233e338f4232c7adc244d8c1c7680c 100644
--- a/test/parallel/test-net-socket-constructor.js
+++ b/test/parallel/test-net-socket-constructor.js
@@ -27,12 +27,12 @@ function test(sock, readable, writable) {
 }
 
 if (cluster.isMaster) {
-  test(undefined, false, false);
+  test(undefined, true, true);
 
   const server = net.createServer(common.mustCall((socket) => {
     socket.unref();
     test(socket, true, true);
-    test({ handle: socket._handle }, false, false);
+    test({ handle: socket._handle }, true, true);
     test({ handle: socket._handle, readable: true, writable: true },
          true, true);
     server.close();
@@ -45,7 +45,7 @@ if (cluster.isMaster) {
       socket.end();
     }));
 
-    test(socket, false, true);
+    test(socket, true, true);
   }));
 
   cluster.setupMaster({
@@ -58,8 +58,8 @@ if (cluster.isMaster) {
     assert.strictEqual(signal, null);
   }));
 } else {
-  test(4, false, false);
-  test({ fd: 5 }, false, false);
+  test(4, true, true);
+  test({ fd: 5 }, true, true);
   test({ fd: 6, readable: true, writable: true }, true, true);
   process.disconnect();
 }
diff --git a/test/parallel/test-net-socket-destroy-send.js b/test/parallel/test-net-socket-destroy-send.js
index 54dadd94861ddf4695c4facccc89be41779f2caa..db792ad6d3b92111c140c702adc068fa32d60d89 100644
--- a/test/parallel/test-net-socket-destroy-send.js
+++ b/test/parallel/test-net-socket-destroy-send.js
@@ -12,11 +12,7 @@ server.listen(0, common.mustCall(function() {
   conn.on('connect', common.mustCall(function() {
     // Test destroy returns this, even on multiple calls when it short-circuits.
     assert.strictEqual(conn, conn.destroy().destroy());
-    conn.on('error', common.expectsError({
-      code: 'ERR_STREAM_DESTROYED',
-      message: 'Cannot call write after a stream was destroyed',
-      name: 'Error'
-    }));
+    conn.on('error', common.mustNotCall());
 
     conn.write(Buffer.from('kaboom'), common.expectsError({
       code: 'ERR_STREAM_DESTROYED',
diff --git a/test/parallel/test-net-socket-setnodelay.js b/test/parallel/test-net-socket-setnodelay.js
index e11d89daec58dee04b209a05f9b42ebdf7e669c5..da1d9a4a3148825d756ad0687083615f55867bf0 100644
--- a/test/parallel/test-net-socket-setnodelay.js
+++ b/test/parallel/test-net-socket-setnodelay.js
@@ -13,28 +13,32 @@ const genSetNoDelay = (desiredArg) => (enable) => {
 // setNoDelay should default to true
 let socket = new net.Socket({
   handle: {
-    setNoDelay: common.mustCall(genSetNoDelay(true))
+    setNoDelay: common.mustCall(genSetNoDelay(true)),
+    readStart() {}
   }
 });
 socket.setNoDelay();
 
 socket = new net.Socket({
   handle: {
-    setNoDelay: common.mustCall(genSetNoDelay(true), 1)
+    setNoDelay: common.mustCall(genSetNoDelay(true), 1),
+    readStart() {}
   }
 });
 truthyValues.forEach((testVal) => socket.setNoDelay(testVal));
 
 socket = new net.Socket({
   handle: {
-    setNoDelay: common.mustNotCall()
+    setNoDelay: common.mustNotCall(),
+    readStart() {}
   }
 });
 falseyValues.forEach((testVal) => socket.setNoDelay(testVal));
 
 socket = new net.Socket({
   handle: {
-    setNoDelay: common.mustCall(() => {}, 3)
+    setNoDelay: common.mustCall(() => {}, 3),
+    readStart() {}
   }
 });
 truthyValues.concat(falseyValues).concat(truthyValues)
@@ -44,7 +48,8 @@ truthyValues.concat(falseyValues).concat(truthyValues)
 // In the case below, if it is called an exception will be thrown
 socket = new net.Socket({
   handle: {
-    setNoDelay: null
+    setNoDelay: null,
+    readStart() {}
   }
 });
 const returned = socket.setNoDelay(true);
diff --git a/test/parallel/test-net-socket-timeout.js b/test/parallel/test-net-socket-timeout.js
index e01304afe53f0101473a34efff3448937f16d468..209359fda608109508c839e18580e6a1f3845015 100644
--- a/test/parallel/test-net-socket-timeout.js
+++ b/test/parallel/test-net-socket-timeout.js
@@ -28,12 +28,12 @@ const { inspect } = require('util');
 // Verify that invalid delays throw
 const s = new net.Socket();
 const nonNumericDelays = [
-  '100', true, false, undefined, null, '', {}, () => {}, []
+  '100', true, false, undefined, null, '', {}, () => {}, [],
 ];
 const badRangeDelays = [-0.001, -1, -Infinity, Infinity, NaN];
 const validDelays = [0, 0.001, 1, 1e6];
 const invalidCallbacks = [
-  1, '100', true, false, null, {}, [], Symbol('test')
+  1, '100', true, false, null, {}, [], Symbol('test'),
 ];
 
 
diff --git a/test/parallel/test-net-socket-write-error.js b/test/parallel/test-net-socket-write-error.js
index a4f5d6e2f41dfbba4e1b019fb813997b4749473f..e68db68c0d4939c0024e5a392b00bd91844e9219 100644
--- a/test/parallel/test-net-socket-write-error.js
+++ b/test/parallel/test-net-socket-write-error.js
@@ -1,20 +1,22 @@
 'use strict';
 
-require('../common');
-const assert = require('assert');
+const common = require('../common');
 const net = require('net');
+const assert = require('assert');
 
 const server = net.createServer().listen(0, connectToServer);
 
 function connectToServer() {
   const client = net.createConnection(this.address().port, () => {
-    assert.throws(() => client.write(1337),
-                  {
-                    code: 'ERR_INVALID_ARG_TYPE',
-                    name: 'TypeError'
-                  });
+    client.on('error', common.mustNotCall());
+    assert.throws(() => {
+      client.write(1337);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError'
+    });
 
-    client.end();
+    client.destroy();
   })
-  .on('end', () => server.close());
+  .on('close', () => server.close());
 }
diff --git a/test/parallel/test-net-write-arguments.js b/test/parallel/test-net-write-arguments.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab2f517de754610bdd10032b612dfb4abd36581c
--- /dev/null
+++ b/test/parallel/test-net-write-arguments.js
@@ -0,0 +1,38 @@
+'use strict';
+const common = require('../common');
+const net = require('net');
+const assert = require('assert');
+const socket = net.Stream({ highWaterMark: 0 });
+
+// Make sure that anything besides a buffer or a string throws.
+socket.on('error', common.mustNotCall());
+assert.throws(() => {
+  socket.write(null);
+}, {
+  code: 'ERR_STREAM_NULL_VALUES',
+  name: 'TypeError',
+  message: 'May not write null values to stream'
+});
+
+[
+  true,
+  false,
+  undefined,
+  1,
+  1.0,
+  +Infinity,
+  -Infinity,
+  [],
+  {},
+].forEach((value) => {
+  // We need to check the callback since 'error' will only
+  // be emitted once per instance.
+  assert.throws(() => {
+    socket.write(value);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+    message: 'The "chunk" argument must be of type string or an instance of ' +
+              `Buffer or Uint8Array.${common.invalidArgTypeHelper(value)}`
+  });
+});
diff --git a/test/parallel/test-next-tick-doesnt-hang.js b/test/parallel/test-next-tick-doesnt-hang.js
index f6af22263014991a297c02df1dd8bf2da2798cfd..36c1740bbf0f7583f3fef786ab8e1cc70166e6aa 100644
--- a/test/parallel/test-next-tick-doesnt-hang.js
+++ b/test/parallel/test-next-tick-doesnt-hang.js
@@ -20,10 +20,9 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-/*
- * This test verifies that having a single nextTick statement and nothing else
- * does not hang the event loop. If this test times out it has failed.
- */
+
+// This test verifies that having a single nextTick statement and nothing else
+// does not hang the event loop. If this test times out it has failed.
 
 require('../common');
 process.nextTick(function() {
diff --git a/test/parallel/test-next-tick-ordering.js b/test/parallel/test-next-tick-ordering.js
index 9ae212cb7f3fbe76d0498683034a199127e37e3a..8d3ee6488c09b12b1f75a64b314b11c06764edd0 100644
--- a/test/parallel/test-next-tick-ordering.js
+++ b/test/parallel/test-next-tick-ordering.js
@@ -48,9 +48,8 @@ console.log('Running from main.');
 
 process.on('exit', function() {
   assert.strictEqual(done[0], 'nextTick');
-  /* Disabling this test. I don't think we can ensure the order
-  for (i = 0; i < N; i += 1) {
-    assert.strictEqual(i, done[i + 1]);
-  }
-  */
+  // Disabling this test. I don't think we can ensure the order
+  // for (i = 0; i < N; i += 1) {
+  //  assert.strictEqual(i, done[i + 1]);
+  // }
 });
diff --git a/test/parallel/test-no-harmony-top-level-await.mjs b/test/parallel/test-no-harmony-top-level-await.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..d48fbbe7f45246792d84edf6214f1df6e269bf65
--- /dev/null
+++ b/test/parallel/test-no-harmony-top-level-await.mjs
@@ -0,0 +1,11 @@
+// Flags: --no-harmony-top-level-await
+
+import {
+  mustCall,
+  disableCrashOnUnhandledRejection
+} from '../common/index.mjs';
+
+disableCrashOnUnhandledRejection();
+
+process.on('unhandledRejection', mustCall());
+Promise.reject(new Error('should not be fatal error'));
diff --git a/test/parallel/test-nodeeventtarget.js b/test/parallel/test-nodeeventtarget.js
new file mode 100644
index 0000000000000000000000000000000000000000..276bd9feb4da7c147c1d8d4c3ab8d859b35fe8b7
--- /dev/null
+++ b/test/parallel/test-nodeeventtarget.js
@@ -0,0 +1,186 @@
+// Flags: --expose-internals --no-warnings
+'use strict';
+
+const common = require('../common');
+const {
+  Event,
+  NodeEventTarget,
+} = require('internal/event_target');
+
+const {
+  deepStrictEqual,
+  ok,
+  strictEqual,
+  throws,
+} = require('assert');
+
+const { on } = require('events');
+
+{
+  const eventTarget = new NodeEventTarget();
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  deepStrictEqual(eventTarget.eventNames(), []);
+
+  const ev1 = common.mustCall(function(event) {
+    strictEqual(event.type, 'foo');
+    strictEqual(this, eventTarget);
+  }, 2);
+
+  const ev2 = {
+    handleEvent: common.mustCall(function(event) {
+      strictEqual(event.type, 'foo');
+      strictEqual(this, ev2);
+    })
+  };
+
+  eventTarget.addEventListener('foo', ev1);
+  eventTarget.addEventListener('foo', ev2, { once: true });
+  strictEqual(eventTarget.listenerCount('foo'), 2);
+  ok(eventTarget.dispatchEvent(new Event('foo')));
+  strictEqual(eventTarget.listenerCount('foo'), 1);
+  eventTarget.dispatchEvent(new Event('foo'));
+
+  eventTarget.removeEventListener('foo', ev1);
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  eventTarget.dispatchEvent(new Event('foo'));
+}
+
+{
+  const eventTarget = new NodeEventTarget();
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  deepStrictEqual(eventTarget.eventNames(), []);
+
+  const ev1 = common.mustCall((event) => {
+    strictEqual(event.type, 'foo');
+  }, 2);
+
+  const ev2 = {
+    handleEvent: common.mustCall((event) => {
+      strictEqual(event.type, 'foo');
+    })
+  };
+
+  strictEqual(eventTarget.on('foo', ev1), eventTarget);
+  strictEqual(eventTarget.once('foo', ev2, { once: true }), eventTarget);
+  strictEqual(eventTarget.listenerCount('foo'), 2);
+  eventTarget.dispatchEvent(new Event('foo'));
+  strictEqual(eventTarget.listenerCount('foo'), 1);
+  eventTarget.dispatchEvent(new Event('foo'));
+
+  strictEqual(eventTarget.off('foo', ev1), eventTarget);
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  eventTarget.dispatchEvent(new Event('foo'));
+}
+
+{
+  const eventTarget = new NodeEventTarget();
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  deepStrictEqual(eventTarget.eventNames(), []);
+
+  const ev1 = common.mustCall((event) => {
+    strictEqual(event.type, 'foo');
+  }, 2);
+
+  const ev2 = {
+    handleEvent: common.mustCall((event) => {
+      strictEqual(event.type, 'foo');
+    })
+  };
+
+  eventTarget.addListener('foo', ev1);
+  eventTarget.once('foo', ev2, { once: true });
+  strictEqual(eventTarget.listenerCount('foo'), 2);
+  eventTarget.dispatchEvent(new Event('foo'));
+  strictEqual(eventTarget.listenerCount('foo'), 1);
+  eventTarget.dispatchEvent(new Event('foo'));
+
+  eventTarget.removeListener('foo', ev1);
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  eventTarget.dispatchEvent(new Event('foo'));
+}
+
+{
+  const eventTarget = new NodeEventTarget();
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  deepStrictEqual(eventTarget.eventNames(), []);
+
+  // Won't actually be called.
+  const ev1 = () => {};
+
+  // Won't actually be called.
+  const ev2 = { handleEvent() {} };
+
+  eventTarget.addListener('foo', ev1);
+  eventTarget.addEventListener('foo', ev1);
+  eventTarget.once('foo', ev2, { once: true });
+  eventTarget.once('foo', ev2, { once: false });
+  eventTarget.on('bar', ev1);
+  strictEqual(eventTarget.listenerCount('foo'), 2);
+  strictEqual(eventTarget.listenerCount('bar'), 1);
+  deepStrictEqual(eventTarget.eventNames(), ['foo', 'bar']);
+  strictEqual(eventTarget.removeAllListeners('foo'), eventTarget);
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  strictEqual(eventTarget.listenerCount('bar'), 1);
+  deepStrictEqual(eventTarget.eventNames(), ['bar']);
+  strictEqual(eventTarget.removeAllListeners(), eventTarget);
+  strictEqual(eventTarget.listenerCount('foo'), 0);
+  strictEqual(eventTarget.listenerCount('bar'), 0);
+  deepStrictEqual(eventTarget.eventNames(), []);
+}
+
+{
+  const target = new NodeEventTarget();
+
+  process.on('warning', common.mustCall((warning) => {
+    ok(warning instanceof Error);
+    strictEqual(warning.name, 'MaxListenersExceededWarning');
+    strictEqual(warning.target, target);
+    strictEqual(warning.count, 2);
+    strictEqual(warning.type, 'foo');
+    ok(warning.message.includes(
+      '2 foo listeners added to NodeEventTarget'));
+  }));
+
+  strictEqual(target.getMaxListeners(), NodeEventTarget.defaultMaxListeners);
+  target.setMaxListeners(1);
+  target.on('foo', () => {});
+  target.on('foo', () => {});
+}
+{
+  // Test NodeEventTarget emit
+  const emitter = new NodeEventTarget();
+  emitter.addEventListener('foo', common.mustCall((e) => {
+    strictEqual(e.type, 'foo');
+    strictEqual(e.detail, 'bar');
+    ok(e instanceof Event);
+  }), { once: true });
+  emitter.once('foo', common.mustCall((e, droppedAdditionalArgument) => {
+    strictEqual(e, 'bar');
+    strictEqual(droppedAdditionalArgument, undefined);
+  }));
+  emitter.emit('foo', 'bar', 'baz');
+}
+{
+  // Test NodeEventTarget emit unsupported usage
+  const emitter = new NodeEventTarget();
+  throws(() => {
+    emitter.emit();
+  }, /ERR_INVALID_ARG_TYPE/);
+}
+
+(async () => {
+  // test NodeEventTarget async-iterability
+  const emitter = new NodeEventTarget();
+  const interval = setInterval(() => {
+    emitter.dispatchEvent(new Event('foo'));
+  }, 0);
+  let count = 0;
+  for await (const [ item ] of on(emitter, 'foo')) {
+    count++;
+    strictEqual(item.type, 'foo');
+    if (count > 5) {
+      break;
+    }
+  }
+  clearInterval(interval);
+})().then(common.mustCall());
diff --git a/test/parallel/test-npm-install.js b/test/parallel/test-npm-install.js
index 1eec5f57ad6db9895dca8c0655f4dd99ae4ca833..d3ba8ab8b55561be918a5413817278b05801b187 100644
--- a/test/parallel/test-npm-install.js
+++ b/test/parallel/test-npm-install.js
@@ -42,8 +42,9 @@ const env = { ...process.env,
               PATH: path.dirname(process.execPath),
               NPM_CONFIG_PREFIX: path.join(npmSandbox, 'npm-prefix'),
               NPM_CONFIG_TMP: path.join(npmSandbox, 'npm-tmp'),
-              HOME: homeDir,
-};
+              NPM_CONFIG_AUDIT: false,
+              NPM_CONFIG_UPDATE_NOTIFIER: false,
+              HOME: homeDir };
 
 exec(`${process.execPath} ${npmPath} install`, {
   cwd: installDir,
diff --git a/test/parallel/test-options-binding.js b/test/parallel/test-options-binding.js
new file mode 100644
index 0000000000000000000000000000000000000000..b113a1ff66bcc974389e9ded2e2a317e3e5ff13b
--- /dev/null
+++ b/test/parallel/test-options-binding.js
@@ -0,0 +1,18 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const { primordials: { SafeMap } } = require('internal/test/binding');
+
+const { options, aliases, getOptionValue } = require('internal/options');
+const assert = require('assert');
+
+assert(options instanceof SafeMap,
+       "require('internal/options').options is a SafeMap");
+
+assert(aliases instanceof SafeMap,
+       "require('internal/options').aliases is a SafeMap");
+
+Map.prototype.get =
+  common.mustNotCall('`getOptionValue` must not call user-mutable method');
+assert.strictEqual(getOptionValue('--expose-internals'), true);
diff --git a/test/parallel/test-os-process-priority.js b/test/parallel/test-os-process-priority.js
index d9adac58bf981e060784e71a2c5b17930a3fe1ac..c6fdbff9e554d9c2123e8b3af447455f9f4c54ac 100644
--- a/test/parallel/test-os-process-priority.js
+++ b/test/parallel/test-os-process-priority.js
@@ -73,7 +73,7 @@ assert.strictEqual(typeof PRIORITY_HIGHEST, 'number');
   3.14,
   2 ** 32,
   PRIORITY_HIGHEST - 1,
-  PRIORITY_LOW + 1
+  PRIORITY_LOW + 1,
 ].forEach((priority) => {
   assert.throws(() => {
     os.setPriority(0, priority);
diff --git a/test/parallel/test-os.js b/test/parallel/test-os.js
index 5ee0fb9ca8dadb1e6d745e9bbdc617946d240c8a..da61a0a235ee0fed5e947aabb83b8aa0896efded 100644
--- a/test/parallel/test-os.js
+++ b/test/parallel/test-os.js
@@ -39,10 +39,6 @@ const is = {
   }
 };
 
-const flatten = (arr) =>
-  arr.reduce((acc, c) =>
-    acc.concat(Array.isArray(c) ? flatten(c) : c), []);
-
 process.env.TMPDIR = '/tmpdir';
 process.env.TMP = '/tmp';
 process.env.TEMP = '/temp';
@@ -174,7 +170,8 @@ const netmaskToCIDRSuffixMap = new Map(Object.entries({
   'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff': 128
 }));
 
-flatten(Object.values(interfaces))
+Object.values(interfaces)
+  .flat(Infinity)
   .map((v) => ({ v, mask: netmaskToCIDRSuffixMap.get(v.netmask) }))
   .forEach(({ v, mask }) => {
     assert.ok('cidr' in v, `"cidr" prop not found in ${inspect(v)}`);
@@ -247,6 +244,7 @@ assert.strictEqual(`${os.endianness}`, os.endianness());
 assert.strictEqual(`${os.tmpdir}`, os.tmpdir());
 assert.strictEqual(`${os.arch}`, os.arch());
 assert.strictEqual(`${os.platform}`, os.platform());
+assert.strictEqual(`${os.version}`, os.version());
 
 assert.strictEqual(+os.totalmem, os.totalmem());
 
@@ -259,3 +257,10 @@ if (!common.isIBMi) {
 
 is.number(+os.freemem, 'freemem');
 is.number(os.freemem(), 'freemem');
+
+const devNull = os.devNull;
+if (common.isWindows) {
+  assert.strictEqual(devNull, '\\\\.\\nul');
+} else {
+  assert.strictEqual(devNull, '/dev/null');
+}
diff --git a/test/parallel/test-outgoing-message-destroy.js b/test/parallel/test-outgoing-message-destroy.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ee7b5f40ef9fa791890f8541df17ebc0107eac5
--- /dev/null
+++ b/test/parallel/test-outgoing-message-destroy.js
@@ -0,0 +1,13 @@
+'use strict';
+
+// Test that http.OutgoingMessage,prototype.destroy() returns `this`.
+require('../common');
+
+const assert = require('assert');
+const http = require('http');
+const outgoingMessage = new http.OutgoingMessage();
+
+assert.strictEqual(outgoingMessage.destroyed, false);
+assert.strictEqual(outgoingMessage.destroy(), outgoingMessage);
+assert.strictEqual(outgoingMessage.destroyed, true);
+assert.strictEqual(outgoingMessage.destroy(), outgoingMessage);
diff --git a/test/parallel/test-path-join.js b/test/parallel/test-path-join.js
index 6243d97ce8a8bcd42db5e166a7eb827af7664a8d..d6d18399960d0b5308a4fe6900df40f4b90e07e4 100644
--- a/test/parallel/test-path-join.js
+++ b/test/parallel/test-path-join.js
@@ -55,9 +55,9 @@ const joinTests = [
      [['/', '//foo'], '/foo'],
      [['/', '', '/foo'], '/foo'],
      [['', '/', 'foo'], '/foo'],
-     [['', '/', '/foo'], '/foo']
-    ]
-  ]
+     [['', '/', '/foo'], '/foo'],
+    ],
+  ],
 ];
 
 // Windows-specific join tests
@@ -109,9 +109,9 @@ joinTests.push([
       [['c:.', '/'], 'c:.\\'],
       [['c:.', 'file'], 'c:file'],
       [['c:', '/'], 'c:\\'],
-      [['c:', 'file'], 'c:\\file']
+      [['c:', 'file'], 'c:\\file'],
     ]
-  )
+  ),
 ]);
 joinTests.forEach((test) => {
   if (!Array.isArray(test[0]))
diff --git a/test/parallel/test-path-parse-format.js b/test/parallel/test-path-parse-format.js
index 97c7227ac7e0eb91008c708ab403a29e2bbf7602..e60a0cedae4259192180063da1673322e9a36a43 100644
--- a/test/parallel/test-path-parse-format.js
+++ b/test/parallel/test-path-parse-format.js
@@ -47,7 +47,7 @@ const winPaths = [
   ['\\\\server two\\shared folder\\file path.zip',
    '\\\\server two\\shared folder\\'],
   ['\\\\teela\\admin$\\system32', '\\\\teela\\admin$\\'],
-  ['\\\\?\\UNC\\server\\share', '\\\\?\\UNC\\']
+  ['\\\\?\\UNC\\server\\share', '\\\\?\\UNC\\'],
 ];
 
 const winSpecialCaseParseTests = [
@@ -62,7 +62,7 @@ const winSpecialCaseFormatTests = [
   [{ name: 'index', ext: '.html' }, 'index.html'],
   [{ dir: 'some\\dir', name: 'index', ext: '.html' }, 'some\\dir\\index.html'],
   [{ root: 'C:\\', name: 'index', ext: '.html' }, 'C:\\index.html'],
-  [{}, '']
+  [{}, ''],
 ];
 
 const unixPaths = [
@@ -86,7 +86,7 @@ const unixPaths = [
   ['/.', '/'],
   ['/.foo', '/'],
   ['/.foo.bar', '/'],
-  ['/foo/bar.baz', '/']
+  ['/foo/bar.baz', '/'],
 ];
 
 const unixSpecialCaseFormatTests = [
@@ -96,7 +96,7 @@ const unixSpecialCaseFormatTests = [
   [{ name: 'index', ext: '.html' }, 'index.html'],
   [{ dir: 'some/dir', name: 'index', ext: '.html' }, 'some/dir/index.html'],
   [{ root: '/', name: 'index', ext: '.html' }, '/index.html'],
-  [{}, '']
+  [{}, ''],
 ];
 
 const errors = [
@@ -132,10 +132,9 @@ const trailingTests = [
         dir: 'D:\\foo\\\\',
         base: 'bar.baz',
         ext: '.baz',
-        name: 'bar'
-      }
-     ]
-    ]
+        name: 'bar' },
+     ],
+    ],
   ],
   [ path.posix.parse,
     [['./', { root: '', dir: '', base: '.', ext: '', name: '.' }],
@@ -143,10 +142,10 @@ const trailingTests = [
      ['///', { root: '/', dir: '/', base: '', ext: '', name: '' }],
      ['/foo///', { root: '/', dir: '/', base: 'foo', ext: '', name: 'foo' }],
      ['/foo///bar.baz',
-      { root: '/', dir: '/foo//', base: 'bar.baz', ext: '.baz', name: 'bar' }
-     ]
-    ]
-  ]
+      { root: '/', dir: '/foo//', base: 'bar.baz', ext: '.baz', name: 'bar' },
+     ],
+    ],
+  ],
 ];
 const failures = [];
 trailingTests.forEach((test) => {
diff --git a/test/parallel/test-path-relative.js b/test/parallel/test-path-relative.js
index 72f862b6df764ea6974fe52cdd4e75f25c2592be..f6a9f5662a6c248d13e92db70405f492a1b2d1b1 100644
--- a/test/parallel/test-path-relative.js
+++ b/test/parallel/test-path-relative.js
@@ -31,8 +31,8 @@ const relativeTests = [
      ['\\\\foo\\baz-quux', '\\\\foo\\baz', '..\\baz'],
      ['\\\\foo\\baz', '\\\\foo\\baz-quux', '..\\baz-quux'],
      ['C:\\baz', '\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz'],
-     ['\\\\foo\\bar\\baz', 'C:\\baz', 'C:\\baz']
-    ]
+     ['\\\\foo\\bar\\baz', 'C:\\baz', 'C:\\baz'],
+    ],
   ],
   [ path.posix.relative,
     // Arguments          result
@@ -48,9 +48,9 @@ const relativeTests = [
      ['/foo/bar/baz', '/foo/bar/baz-quux', '../baz-quux'],
      ['/baz-quux', '/baz', '../baz'],
      ['/baz', '/baz-quux', '../baz-quux'],
-     ['/page1/page2/foo', '/', '../../..']
-    ]
-  ]
+     ['/page1/page2/foo', '/', '../../..'],
+    ],
+  ],
 ];
 relativeTests.forEach((test) => {
   const relative = test[0];
diff --git a/test/parallel/test-path-resolve.js b/test/parallel/test-path-resolve.js
index ed3c7c4c5a0113795638db7647bae6966ffd1320..d901917f3b0892d133d7134662e32a628f9b30de 100644
--- a/test/parallel/test-path-resolve.js
+++ b/test/parallel/test-path-resolve.js
@@ -24,8 +24,8 @@ const resolveTests = [
      [['c:/', '//server//share'], '\\\\server\\share\\'],
      [['c:/', '///some//dir'], 'c:\\some\\dir'],
      [['C:\\foo\\tmp.3\\', '..\\tmp.3\\cycles\\root.js'],
-      'C:\\foo\\tmp.3\\cycles\\root.js']
-    ]
+      'C:\\foo\\tmp.3\\cycles\\root.js'],
+    ],
   ],
   [ path.posix.resolve,
     // Arguments                    result
@@ -34,14 +34,13 @@ const resolveTests = [
      [['a/b/c/', '../../..'], process.cwd()],
      [['.'], process.cwd()],
      [['/some/dir', '.', '/absolute/'], '/absolute'],
-     [['/foo/tmp.3/', '../tmp.3/cycles/root.js'], '/foo/tmp.3/cycles/root.js']
-    ]
-  ]
+     [['/foo/tmp.3/', '../tmp.3/cycles/root.js'], '/foo/tmp.3/cycles/root.js'],
+    ],
+  ],
 ];
-resolveTests.forEach((test) => {
-  const resolve = test[0];
-  test[1].forEach((test) => {
-    const actual = resolve.apply(null, test[0]);
+resolveTests.forEach(([resolve, tests]) => {
+  tests.forEach(([test, expected]) => {
+    const actual = resolve.apply(null, test);
     let actualAlt;
     const os = resolve === path.win32.resolve ? 'win32' : 'posix';
     if (resolve === path.win32.resolve && !common.isWindows)
@@ -49,15 +48,14 @@ resolveTests.forEach((test) => {
     else if (resolve !== path.win32.resolve && common.isWindows)
       actualAlt = actual.replace(slashRE, '\\');
 
-    const expected = test[1];
     const message =
-      `path.${os}.resolve(${test[0].map(JSON.stringify).join(',')})\n  expect=${
+      `path.${os}.resolve(${test.map(JSON.stringify).join(',')})\n  expect=${
         JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
     if (actual !== expected && actualAlt !== expected)
-      failures.push(`\n${message}`);
+      failures.push(message);
   });
 });
-assert.strictEqual(failures.length, 0, failures.join(''));
+assert.strictEqual(failures.length, 0, failures.join('\n'));
 
 if (common.isWindows) {
   // Test resolving the current Windows drive letter from a spawned process.
diff --git a/test/parallel/test-perf-hooks-histogram.js b/test/parallel/test-perf-hooks-histogram.js
new file mode 100644
index 0000000000000000000000000000000000000000..c9ae957bb424111371da420366026c4b77f2a0a7
--- /dev/null
+++ b/test/parallel/test-perf-hooks-histogram.js
@@ -0,0 +1,70 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const {
+  createHistogram,
+  monitorEventLoopDelay,
+} = require('perf_hooks');
+const { MessageChannel } = require('worker_threads');
+
+{
+  const h = createHistogram();
+
+  assert.strictEqual(h.min, 9223372036854776000);
+  assert.strictEqual(h.max, 0);
+  assert.strictEqual(h.exceeds, 0);
+  assert(Number.isNaN(h.mean));
+  assert(Number.isNaN(h.stddev));
+
+  h.record(1);
+
+  [false, '', {}, undefined, null].forEach((i) => {
+    assert.throws(() => h.record(i), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+  assert.throws(() => h.record(0, Number.MAX_SAFE_INTEGER + 1), {
+    code: 'ERR_OUT_OF_RANGE'
+  });
+
+  assert.strictEqual(h.min, 1);
+  assert.strictEqual(h.max, 1);
+  assert.strictEqual(h.exceeds, 0);
+  assert.strictEqual(h.mean, 1);
+  assert.strictEqual(h.stddev, 0);
+
+  assert.strictEqual(h.percentile(1), 1);
+  assert.strictEqual(h.percentile(100), 1);
+
+  const mc = new MessageChannel();
+  mc.port1.onmessage = common.mustCall(({ data }) => {
+    assert.strictEqual(h.min, 1);
+    assert.strictEqual(h.max, 1);
+    assert.strictEqual(h.exceeds, 0);
+    assert.strictEqual(h.mean, 1);
+    assert.strictEqual(h.stddev, 0);
+
+    data.record(2n);
+    data.recordDelta();
+
+    assert.strictEqual(h.max, 2);
+
+    mc.port1.close();
+  });
+  mc.port2.postMessage(h);
+}
+
+{
+  const e = monitorEventLoopDelay();
+  e.enable();
+  const mc = new MessageChannel();
+  mc.port1.onmessage = common.mustCall(({ data }) => {
+    assert(typeof data.min, 'number');
+    assert(data.min > 0);
+    assert.strictEqual(data.disable, undefined);
+    assert.strictEqual(data.enable, undefined);
+    mc.port1.close();
+  });
+  setTimeout(() => mc.port2.postMessage(e), 100);
+}
diff --git a/test/parallel/test-performance-eventlooputil.js b/test/parallel/test-performance-eventlooputil.js
index 6e62a6664432897174f86e7c9f64d18cffcae2cb..9ce7212729d574a199a348fbeefd0e20b652dc6f 100644
--- a/test/parallel/test-performance-eventlooputil.js
+++ b/test/parallel/test-performance-eventlooputil.js
@@ -22,6 +22,13 @@ if (nodeTiming.loopStart === -1) {
                          { idle: 0, active: 0, utilization: 0 });
 }
 
+const nodeTimingProps = ['name', 'entryType', 'startTime', 'duration',
+                         'nodeStart', 'v8Start', 'environment', 'loopStart',
+                         'loopExit', 'bootstrapComplete', 'idleTime'];
+for (const p of nodeTimingProps)
+  assert.ok(typeof JSON.parse(JSON.stringify(nodeTiming))[p] ===
+    typeof nodeTiming[p]);
+
 setTimeout(mustCall(function r() {
   const elu1 = eventLoopUtilization();
 
diff --git a/test/parallel/test-performance-gc.js b/test/parallel/test-performance-gc.js
index aef0ee14254146f43097e896ae2caeffb25fa1f0..97fd4212c1bb6ff0d4b68c26988d9cb69965b2f5 100644
--- a/test/parallel/test-performance-gc.js
+++ b/test/parallel/test-performance-gc.js
@@ -20,7 +20,7 @@ const kinds = [
   NODE_PERFORMANCE_GC_MAJOR,
   NODE_PERFORMANCE_GC_MINOR,
   NODE_PERFORMANCE_GC_INCREMENTAL,
-  NODE_PERFORMANCE_GC_WEAKCB
+  NODE_PERFORMANCE_GC_WEAKCB,
 ];
 
 // Adding an observer should force at least one gc to appear
diff --git a/test/parallel/test-pipe-file-to-http.js b/test/parallel/test-pipe-file-to-http.js
index 9b99ddb675de410692270217284d065238121282..99f18e74d318f81d27eca9d415b358b8d8dcab47 100644
--- a/test/parallel/test-pipe-file-to-http.js
+++ b/test/parallel/test-pipe-file-to-http.js
@@ -69,9 +69,7 @@ function makeRequest() {
 
   const s = fs.ReadStream(filename);
   s.pipe(req);
-  s.on('close', common.mustCall((err) => {
-    assert.ifError(err);
-  }));
+  s.on('close', common.mustSucceed());
 
   req.on('response', (res) => {
     res.resume();
diff --git a/test/parallel/test-pipe-head.js b/test/parallel/test-pipe-head.js
index cb3d183fcdff206083ef0b6ce100fbcbf2ea12fe..1e79249c290500f80e2655ddcea4282165ce94b1 100644
--- a/test/parallel/test-pipe-head.js
+++ b/test/parallel/test-pipe-head.js
@@ -10,8 +10,7 @@ const script = fixtures.path('print-10-lines.js');
 
 const cmd = `"${nodePath}" "${script}" | head -2`;
 
-exec(cmd, common.mustCall(function(err, stdout, stderr) {
-  assert.ifError(err);
+exec(cmd, common.mustSucceed((stdout, stderr) => {
   const lines = stdout.split('\n');
   assert.strictEqual(lines.length, 3);
 }));
diff --git a/test/parallel/test-pipe-unref.js b/test/parallel/test-pipe-unref.js
index 1e0245b5444f6266f6c6a8117715315425829972..78419a1d77076eda6c9a7d61ea7bda76628d4516 100644
--- a/test/parallel/test-pipe-unref.js
+++ b/test/parallel/test-pipe-unref.js
@@ -1,12 +1,29 @@
 'use strict';
 const common = require('../common');
 const net = require('net');
+const assert = require('assert');
+const { fork } = require('child_process');
 
 // This test should end immediately after `unref` is called
+// The pipe will stay open as Node.js completes, thus run in a child process
+// so that tmpdir can be cleaned up.
 
 const tmpdir = require('../common/tmpdir');
-tmpdir.refresh();
 
+if (process.argv[2] !== 'child') {
+  // Parent
+  tmpdir.refresh();
+
+  // Run test
+  const child = fork(__filename, ['child'], { stdio: 'inherit' });
+  child.on('exit', common.mustCall(function(code) {
+    assert.strictEqual(code, 0);
+  }));
+
+  return;
+}
+
+// Child
 const s = net.Server();
 s.listen(common.PIPE);
 s.unref();
diff --git a/test/parallel/test-policy-crypto-default-encoding.js b/test/parallel/test-policy-crypto-default-encoding.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f62b4d85a3c4fa8de3dfb78b6024a00a07e8749
--- /dev/null
+++ b/test/parallel/test-policy-crypto-default-encoding.js
@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+common.requireNoPackageJSONAbove();
+
+const fixtures = require('../common/fixtures');
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const encodings = ['buffer', 'utf8', 'utf16le', 'latin1', 'base64', 'hex'];
+
+for (const encoding of encodings) {
+  const dep = fixtures.path('policy', 'crypto-default-encoding', 'parent.js');
+  const depPolicy = fixtures.path(
+    'policy',
+    'crypto-default-encoding',
+    'policy.json');
+  const { status } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-policy', depPolicy, dep,
+    ],
+    {
+      env: {
+        ...process.env,
+        DEFAULT_ENCODING: encoding
+      }
+    }
+  );
+  assert.strictEqual(status, 0);
+}
diff --git a/test/parallel/test-policy-dependencies.js b/test/parallel/test-policy-dependencies.js
index e7b2289714dff426942adc12d030be06be7dd169..decc164dadd253d2b0441e49fdf0d14f7301f59d 100644
--- a/test/parallel/test-policy-dependencies.js
+++ b/test/parallel/test-policy-dependencies.js
@@ -3,6 +3,7 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
+common.requireNoPackageJSONAbove();
 
 const fixtures = require('../common/fixtures');
 
@@ -15,12 +16,13 @@ const dep = fixtures.path('policy', 'parent.js');
     'policy',
     'dependencies',
     'dependencies-redirect-policy.json');
-  const { status } = spawnSync(
+  const { status, stderr, stdout } = spawnSync(
     process.execPath,
     [
       '--experimental-policy', depPolicy, dep,
     ]
   );
+  console.log('%s\n%s', stderr, stdout);
   assert.strictEqual(status, 0);
 }
 {
@@ -54,12 +56,13 @@ const dep = fixtures.path('policy', 'parent.js');
     'policy',
     'dependencies',
     'dependencies-wildcard-policy.json');
-  const { status } = spawnSync(
+  const { status, stderr, stdout } = spawnSync(
     process.execPath,
     [
       '--experimental-policy', depPolicy, dep,
     ]
   );
+  console.log('%s\n%s', stderr, stdout);
   assert.strictEqual(status, 0);
 }
 {
@@ -75,6 +78,19 @@ const dep = fixtures.path('policy', 'parent.js');
   );
   assert.strictEqual(status, 1);
 }
+{
+  const depPolicy = fixtures.path(
+    'policy',
+    'dependencies',
+    'dependencies-missing-policy-default-true.json');
+  const { status } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-policy', depPolicy, dep,
+    ]
+  );
+  assert.strictEqual(status, 0);
+}
 {
   const depPolicy = fixtures.path(
     'policy',
@@ -88,3 +104,43 @@ const dep = fixtures.path('policy', 'parent.js');
   );
   assert.strictEqual(status, 1);
 }
+{
+  // Regression test for https://github.com/nodejs/node/issues/37812
+  const depPolicy = fixtures.path(
+    'policy',
+    'dependencies',
+    'dependencies-missing-export-policy.json');
+  const { status, stderr } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-policy',
+      depPolicy,
+      fixtures.path('policy', 'bad-main.mjs'),
+    ]
+  );
+  assert.strictEqual(status, 1);
+  assert.match(
+    `${stderr}`,
+    /SyntaxError: Named export 'doesNotExist' not found\./,
+    new Error('Should give the real SyntaxError and position'));
+}
+{
+  const depPolicy = fixtures.path(
+    'policy',
+    'dependencies',
+    'dependencies-scopes-relative-specifier.json');
+  const { status } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-policy',
+      depPolicy,
+      fixtures.path('policy', 'canonicalize.mjs'),
+    ]
+  );
+  assert.strictEqual(
+    status,
+    0,
+    new Error(
+      'policies should canonicalize specifiers by default prior to matching')
+  );
+}
diff --git a/test/parallel/test-policy-dependency-conditions.js b/test/parallel/test-policy-dependency-conditions.js
new file mode 100644
index 0000000000000000000000000000000000000000..dec17aa22984b0202e111cc0c360dfadb7779acf
--- /dev/null
+++ b/test/parallel/test-policy-dependency-conditions.js
@@ -0,0 +1,123 @@
+'use strict';
+// Flags: --expose-internals
+
+const common = require('../common');
+
+if (!common.hasCrypto) common.skip('missing crypto');
+common.requireNoPackageJSONAbove();
+
+const Manifest = require('internal/policy/manifest').Manifest;
+
+
+const assert = require('assert');
+
+const { debuglog } = require('util');
+const debug = debuglog('test');
+
+const conditionTreePermutations = [
+  ['default'],
+  ['import'],
+  ['node'],
+  ['require'],
+  ['require', 'import'],
+  ['import', 'require'],
+  ['default', 'require'],
+  ['require', 'default'],
+  ['node', 'require'],
+  ['require', 'node'],
+];
+for (const totalDepth of [1, 2, 3]) {
+  const conditionTrees = [];
+  function calc(depthLeft = 0, path = []) {
+    if (depthLeft) {
+      for (const conditions of conditionTreePermutations) {
+        calc(depthLeft - 1, [...path, conditions]);
+      }
+    } else {
+      conditionTrees.push(path);
+    }
+  }
+  calc(totalDepth, []);
+  let nextURLId = 1;
+  function getUniqueHREF() {
+    const id = nextURLId++;
+    return `test:${id}`;
+  }
+  for (const tree of conditionTrees) {
+    const root = {};
+    const targets = [root];
+    const offsets = [-1];
+    const order = [];
+    while (offsets.length) {
+      const depth = offsets.length - 1;
+      offsets[depth]++;
+      const conditionOffset = offsets[depth];
+      const conditionsForDepth = tree[depth];
+      if (conditionOffset >= conditionsForDepth.length) {
+        offsets.pop();
+        continue;
+      }
+      let target;
+      if (depth === tree.length - 1) {
+        target = getUniqueHREF();
+        order.push({
+          target,
+          conditions: new Set(
+            offsets.map(
+              (conditionOffset, depth) => tree[depth][conditionOffset]
+            )
+          )
+        });
+      } else {
+        target = {};
+        targets[depth + 1] = target;
+        offsets.push(-1);
+      }
+      const condition = tree[depth][conditionOffset];
+      targets[depth][condition] = target;
+    }
+    const manifest = new Manifest({
+      resources: {
+        'test:_': {
+          dependencies: {
+            _: root
+          }
+        }
+      }
+    });
+    const redirector = manifest.getDependencyMapper('test:_');
+    for (const { target, conditions } of order) {
+      const result = redirector.resolve('_', conditions).href;
+      if (result !== target) {
+        // If we didn't hit the target, make sure a target prior to this one
+        // matched, including conditions
+        searchPriorTargets:
+        for (const { target: preTarget, conditions: preConditions } of order) {
+          if (result === preTarget) {
+            // Ensure that the current conditions are a super set of the
+            // prior target
+            for (const preCondition of preConditions) {
+              if (conditions.has(preCondition) !== true) {
+                continue searchPriorTargets;
+              }
+            }
+            break searchPriorTargets;
+          }
+          if (preTarget === target) {
+            debug(
+              'dependencies %O expected ordering %O and trying for %j ' +
+              'no prior targets matched',
+              root,
+              order,
+              target
+            );
+            // THIS WILL ALWAYS FAIL, but we want that error message
+            assert.strictEqual(
+              result, target
+            );
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/test/parallel/test-policy-integrity-flag.js b/test/parallel/test-policy-integrity-flag.js
index d97ef86cbe9d0f0c4da8f57bc5166fc829412a53..ddcd02236d27c0d95b8f3e37b3fe13f159768452 100644
--- a/test/parallel/test-policy-integrity-flag.js
+++ b/test/parallel/test-policy-integrity-flag.js
@@ -3,6 +3,7 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
+common.requireNoPackageJSONAbove();
 
 const fixtures = require('../common/fixtures');
 
diff --git a/test/parallel/test-policy-parse-integrity.js b/test/parallel/test-policy-parse-integrity.js
index 2443d9691c2a512abf2f7205ddcc33dd90f4e1fe..7c48eeb01426c8afc964a20b8d8cfedfe0b4371f 100644
--- a/test/parallel/test-policy-parse-integrity.js
+++ b/test/parallel/test-policy-parse-integrity.js
@@ -2,6 +2,7 @@
 
 const common = require('../common');
 if (!common.hasCrypto) common.skip('missing crypto');
+common.requireNoPackageJSONAbove();
 
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
@@ -20,7 +21,7 @@ function hash(algo, body) {
 }
 
 const tmpdirPath = path.join(tmpdir.path, 'test-policy-parse-integrity');
-fs.rmdirSync(tmpdirPath, { maxRetries: 3, recursive: true });
+fs.rmSync(tmpdirPath, { maxRetries: 3, recursive: true, force: true });
 fs.mkdirSync(tmpdirPath, { recursive: true });
 
 const policyFilepath = path.join(tmpdirPath, 'policy');
@@ -44,7 +45,8 @@ const packageFilepath = path.join(tmpdirPath, 'package.json');
 const packageURL = pathToFileURL(packageFilepath);
 const packageBody = '{"main": "dep.js"}';
 
-function test({ shouldFail, integrity }) {
+function test({ shouldFail, integrity, manifest = {} }) {
+  manifest.resources = {};
   const resources = {
     [packageURL]: {
       body: packageBody,
@@ -55,9 +57,6 @@ function test({ shouldFail, integrity }) {
       integrity
     }
   };
-  const manifest = {
-    resources: {},
-  };
   for (const [url, { body, integrity }] of Object.entries(resources)) {
     manifest.resources[url] = {
       integrity,
@@ -68,7 +67,7 @@ function test({ shouldFail, integrity }) {
   const { status } = spawnSync(process.execPath, [
     '--experimental-policy',
     policyFilepath,
-    depFilepath
+    depFilepath,
   ]);
   if (shouldFail) {
     assert.notStrictEqual(status, 0);
@@ -96,3 +95,17 @@ test({
     depBody
   )}`,
 });
+test({
+  shouldFail: true,
+  integrity: `sha256-${hash('sha256', 'file:///')}`,
+  manifest: {
+    onerror: 'exit'
+  }
+});
+test({
+  shouldFail: false,
+  integrity: `sha256-${hash('sha256', 'file:///')}`,
+  manifest: {
+    onerror: 'log'
+  }
+});
diff --git a/test/parallel/test-policy-scopes-dependencies.js b/test/parallel/test-policy-scopes-dependencies.js
new file mode 100644
index 0000000000000000000000000000000000000000..f4b93a08e58c474868e7943523f7134a307927fb
--- /dev/null
+++ b/test/parallel/test-policy-scopes-dependencies.js
@@ -0,0 +1,342 @@
+'use strict';
+// Flags: --expose-internals
+
+const common = require('../common');
+
+if (!common.hasCrypto) common.skip('missing crypto');
+common.requireNoPackageJSONAbove();
+
+const Manifest = require('internal/policy/manifest').Manifest;
+const assert = require('assert');
+
+// #region files
+{
+  const baseURLs = [
+    // Localhost is special cased in spec
+    'file://localhost/root',
+    'file:///root',
+    'file:///',
+    'file:///root/dir1',
+    'file:///root/dir1/',
+    'file:///root/dir1/dir2',
+    'file:///root/dir1/dir2/',
+  ];
+
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'file:///': {
+          dependencies: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.getDependencyMapper(href).resolve('fs'),
+        true
+      );
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        '': {
+          dependencies: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.getDependencyMapper(href).resolve('fs'),
+        true
+      );
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        '': {
+          dependencies: true
+        },
+        'file:': {
+          cascade: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.getDependencyMapper(href).resolve('fs'),
+        true
+      );
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'file:': {
+          dependencies: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest
+          .getDependencyMapper(href)
+          .resolve('fs'),
+        true);
+    }
+
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('file://host/')
+        .resolve('fs'),
+      true);
+  }
+  {
+    const manifest = new Manifest({
+      resources: {
+        'file:///root/dir1': {
+          dependencies: {
+            fs: 'test:fs1'
+          }
+        },
+        'file:///root/dir1/isolated': {},
+        'file:///root/dir1/cascade': {
+          cascade: true
+        }
+      },
+      scopes: {
+        'file:///root/dir1/': {
+          dependencies: {
+            fs: 'test:fs2'
+          }
+        },
+        'file:///root/dir1/censor/': {
+        },
+      }
+    });
+
+    for (const href of baseURLs) {
+      const redirector = manifest.getDependencyMapper(href);
+      if (href.startsWith('file:///root/dir1/')) {
+        assert.strictEqual(
+          redirector.resolve('fs').href,
+          'test:fs2'
+        );
+      } else if (href === 'file:///root/dir1') {
+        assert.strictEqual(
+          redirector.resolve('fs').href,
+          'test:fs1'
+        );
+      } else {
+        assert.strictEqual(redirector.resolve('fs'), null);
+      }
+    }
+
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('file:///root/dir1/isolated')
+        .resolve('fs'),
+      null
+    );
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('file:///root/dir1/cascade')
+        .resolve('fs').href,
+      'test:fs2'
+    );
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('file:///root/dir1/censor/foo')
+        .resolve('fs'),
+      null
+    );
+  }
+}
+// #endregion
+// #region data
+{
+  const baseURLs = [
+    'data:text/javascript,0',
+    'data:text/javascript,0/1',
+  ];
+
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'data:text/': {
+          dependencies: {
+            fs: true
+          }
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.getDependencyMapper(href).resolve('fs'),
+        null);
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'data:/': {
+          dependencies: {
+            fs: true
+          }
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.getDependencyMapper(href).resolve('fs'),
+        null);
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'data:': {
+          dependencies: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.getDependencyMapper(href).resolve('fs'),
+        true
+      );
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'data:text/javascript,0/': {
+          dependencies: {
+            fs: 'test:fs1'
+          }
+        },
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.getDependencyMapper(href).resolve('fs'),
+        null);
+    }
+  }
+}
+// #endregion
+// #region blob
+{
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'https://example.com/': {
+          dependencies: true
+        }
+      }
+    });
+
+    assert.strictEqual(
+      manifest
+          .getDependencyMapper('blob:https://example.com/has-origin')
+          .resolve('fs'),
+      true
+    );
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'https://example.com': {
+          dependencies: true
+        }
+      }
+    });
+
+    assert.strictEqual(
+      manifest
+          .getDependencyMapper('blob:https://example.com/has-origin')
+          .resolve('fs'),
+      true
+    );
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+      }
+    });
+
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('blob:https://example.com/has-origin')
+        .resolve('fs'),
+      null);
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'blob:https://example.com/has-origin': {
+          cascade: true
+        }
+      }
+    });
+
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('blob:https://example.com/has-origin')
+        .resolve('fs'),
+      null);
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        // FIXME
+        'https://example.com/': {
+          dependencies: true
+        },
+        'blob:https://example.com/has-origin': {
+          cascade: true
+        }
+      }
+    });
+
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('blob:https://example.com/has-origin')
+        .resolve('fs'),
+      true
+    );
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'blob:': {
+          dependencies: true
+        },
+        'blob:https://example.com/has-origin': {
+          cascade: true
+        }
+      }
+    });
+
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('blob:https://example.com/has-origin')
+        .resolve('fs'),
+      null);
+    assert.strictEqual(
+      manifest
+        .getDependencyMapper('blob:foo').resolve('fs'),
+      true
+    );
+  }
+}
+// #endregion
diff --git a/test/parallel/test-policy-scopes-integrity.js b/test/parallel/test-policy-scopes-integrity.js
new file mode 100644
index 0000000000000000000000000000000000000000..16d9eb04eb734756adc1e27084eb03010f4d1838
--- /dev/null
+++ b/test/parallel/test-policy-scopes-integrity.js
@@ -0,0 +1,316 @@
+'use strict';
+// Flags: --expose-internals
+
+const common = require('../common');
+
+if (!common.hasCrypto) common.skip('missing crypto');
+common.requireNoPackageJSONAbove();
+
+const Manifest = require('internal/policy/manifest').Manifest;
+const assert = require('assert');
+
+// #region files
+{
+  const baseURLs = [
+    // Localhost is special cased in spec
+    'file://localhost/root',
+    'file:///root',
+    'file:///',
+    'file:///root/dir1',
+    'file:///root/dir1/',
+    'file:///root/dir1/dir2',
+    'file:///root/dir1/dir2/',
+  ];
+
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'file:///': {
+          integrity: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.assertIntegrity(href),
+        true
+      );
+      assert.strictEqual(
+        manifest.assertIntegrity(href, null),
+        true
+      );
+      assert.strictEqual(
+        manifest.assertIntegrity(href, ''),
+        true
+      );
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'file:': {
+          integrity: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(
+        manifest.assertIntegrity(href),
+        true
+      );
+      assert.strictEqual(
+        manifest.assertIntegrity(href, null),
+        true
+      );
+      assert.strictEqual(
+        manifest.assertIntegrity(href, ''),
+        true
+      );
+    }
+  }
+  {
+    const manifest = new Manifest({
+      resources: {
+        'file:///root/dir1/isolated': {},
+        'file:///root/dir1/cascade': {
+          cascade: true
+        }
+      },
+      scopes: {
+        'file:///root/dir1/': {
+          integrity: true,
+        },
+        'file:///root/dir1/dir2/': {
+          cascade: true,
+        },
+        'file:///root/dir1/censor/': {
+        },
+      }
+    });
+    assert.throws(
+      () => {
+        manifest.assertIntegrity('file:///root/dir1/isolated');
+      },
+      /ERR_MANIFEST_ASSERT_INTEGRITY/
+    );
+    assert.strictEqual(
+      manifest.assertIntegrity('file:///root/dir1/cascade'),
+      true
+    );
+    assert.strictEqual(
+      manifest.assertIntegrity('file:///root/dir1/enoent'),
+      true
+    );
+    assert.strictEqual(
+      manifest.assertIntegrity('file:///root/dir1/dir2/enoent'),
+      true
+    );
+    assert.throws(
+      () => {
+        manifest.assertIntegrity('file:///root/dir1/censor/enoent');
+      },
+      /ERR_MANIFEST_ASSERT_INTEGRITY/
+    );
+  }
+}
+// #endregion
+// #region data
+{
+  const baseURLs = [
+    'data:text/javascript,0',
+    'data:text/javascript,0/1',
+  ];
+
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'data:text/': {
+          integrity: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.throws(
+        () => {
+          manifest.assertIntegrity(href);
+        },
+        /ERR_MANIFEST_ASSERT_INTEGRITY/
+      );
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'data:/': {
+          integrity: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.throws(
+        () => {
+          manifest.assertIntegrity(href);
+        },
+        /ERR_MANIFEST_ASSERT_INTEGRITY/
+      );
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'data:': {
+          integrity: true
+        }
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.strictEqual(manifest.assertIntegrity(href), true);
+    }
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'data:text/javascript,0/': {
+          integrity: true
+        },
+      }
+    });
+
+    for (const href of baseURLs) {
+      assert.throws(
+        () => {
+          manifest.assertIntegrity(href);
+        },
+        /ERR_MANIFEST_ASSERT_INTEGRITY/
+      );
+    }
+  }
+}
+// #endregion
+// #region blob
+{
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'https://example.com/': {
+          integrity: true
+        }
+      }
+    });
+
+    assert.strictEqual(
+      manifest.assertIntegrity('blob:https://example.com/has-origin'),
+      true
+    );
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+      }
+    });
+
+    assert.throws(
+      () => {
+        manifest.assertIntegrity('blob:https://example.com/has-origin');
+      },
+      /ERR_MANIFEST_ASSERT_INTEGRITY/
+    );
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'blob:https://example.com/has-origin': {
+          cascade: true
+        }
+      }
+    });
+
+    assert.throws(
+      () => {
+        manifest.assertIntegrity('blob:https://example.com/has-origin');
+      },
+      /ERR_MANIFEST_ASSERT_INTEGRITY/
+    );
+  }
+  {
+    const manifest = new Manifest({
+      resources: {
+        'blob:https://example.com/has-origin': {
+          cascade: true
+        }
+      },
+      scopes: {
+        'https://example.com': {
+          integrity: true
+        }
+      }
+    });
+
+    assert.strictEqual(
+      manifest.assertIntegrity('blob:https://example.com/has-origin'),
+      true
+    );
+  }
+  {
+    const manifest = new Manifest({
+      scopes: {
+        'blob:': {
+          integrity: true
+        },
+        'https://example.com': {
+          cascade: true
+        }
+      }
+    });
+
+    assert.throws(
+      () => {
+        manifest.assertIntegrity('blob:https://example.com/has-origin');
+      },
+      /ERR_MANIFEST_ASSERT_INTEGRITY/
+    );
+    assert.strictEqual(
+      manifest.assertIntegrity('blob:foo'),
+      true
+    );
+  }
+}
+// #endregion
+// #startonerror
+{
+  const manifest = new Manifest({
+    scopes: {
+      'file:///': {
+        integrity: true
+      }
+    },
+    onerror: 'throw'
+  });
+  assert.throws(
+    () => {
+      manifest.assertIntegrity('http://example.com');
+    },
+    /ERR_MANIFEST_ASSERT_INTEGRITY/
+  );
+}
+{
+  assert.throws(
+    () => {
+      new Manifest({
+        scopes: {
+          'file:///': {
+            integrity: true
+          }
+        },
+        onerror: 'unknown'
+      });
+    },
+    /ERR_MANIFEST_UNKNOWN_ONERROR/
+  );
+}
+// #endonerror
diff --git a/test/parallel/test-policy-scopes.js b/test/parallel/test-policy-scopes.js
new file mode 100644
index 0000000000000000000000000000000000000000..43789713cc979a3b56155b83644552b58791a6ea
--- /dev/null
+++ b/test/parallel/test-policy-scopes.js
@@ -0,0 +1,40 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+common.requireNoPackageJSONAbove();
+
+const fixtures = require('../common/fixtures');
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+{
+  const dep = fixtures.path('policy', 'main.mjs');
+  const depPolicy = fixtures.path(
+    'policy',
+    'dependencies',
+    'dependencies-scopes-policy.json');
+  const { status } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-policy', depPolicy, dep,
+    ]
+  );
+  assert.strictEqual(status, 0);
+}
+{
+  const dep = fixtures.path('policy', 'multi-deps.js');
+  const depPolicy = fixtures.path(
+    'policy',
+    'dependencies',
+    'dependencies-scopes-and-resources-policy.json');
+  const { status } = spawnSync(
+    process.execPath,
+    [
+      '--experimental-policy', depPolicy, dep,
+    ]
+  );
+  assert.strictEqual(status, 0);
+}
diff --git a/test/parallel/test-preload-worker.js b/test/parallel/test-preload-worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e9134b470cf378a07d29cee3cfaee49d5c59b0b
--- /dev/null
+++ b/test/parallel/test-preload-worker.js
@@ -0,0 +1,10 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const worker = fixtures.path('worker-preload.js');
+const { exec } = require('child_process');
+const kNodeBinary = process.argv[0];
+
+
+exec(`"${kNodeBinary}" -r "${worker}" -pe "1+1"`, common.mustSucceed());
diff --git a/test/parallel/test-preload.js b/test/parallel/test-preload.js
index 25414d2d0a62ce3382a06c59e3b746a1ce67e3d2..4636a46007001c4c8dc7709d8ce6b6e8b65939c2 100644
--- a/test/parallel/test-preload.js
+++ b/test/parallel/test-preload.js
@@ -27,6 +27,19 @@ const fixtureE = fixtures.path('intrinsic-mutation.js');
 const fixtureF = fixtures.path('print-intrinsic-mutation-name.js');
 const fixtureG = fixtures.path('worker-from-argv.js');
 const fixtureThrows = fixtures.path('throws_error4.js');
+const fixtureIsPreloading = fixtures.path('ispreloading.js');
+
+// Assert that module.isPreloading is false here
+assert(!module.isPreloading);
+
+// Test that module.isPreloading is set in preloaded module
+// Test preloading a single module works
+childProcess.exec(
+  `"${nodeBinary}" ${preloadOption([fixtureIsPreloading])} "${fixtureB}"`,
+  function(err, stdout, stderr) {
+    assert.ifError(err);
+    assert.strictEqual(stdout, 'B\n');
+  });
 
 // Test preloading a single module works
 childProcess.exec(`"${nodeBinary}" ${preloadOption([fixtureA])} "${fixtureB}"`,
@@ -122,7 +135,7 @@ replProc.on('close', function(code) {
   assert.strictEqual(code, 0);
   const output = [
     'A',
-    '> '
+    '> ',
   ];
   assert.ok(replStdout.startsWith(output[0]));
   assert.ok(replStdout.endsWith(output[1]));
@@ -142,8 +155,7 @@ childProcess.exec(
 // Test that preload works with -i
 const interactive = childProcess.exec(
   `"${nodeBinary}" ${preloadOption([fixtureD])}-i`,
-  common.mustCall(function(err, stdout, stderr) {
-    assert.ifError(err);
+  common.mustSucceed((stdout, stderr) => {
     assert.ok(stdout.endsWith("> 'test'\n> "));
   })
 );
@@ -164,8 +176,7 @@ childProcess.exec(
 childProcess.exec(
   `"${nodeBinary}" ${preloadOption(['./printA.js'])} "${fixtureB}"`,
   { cwd: fixtures.fixturesDir },
-  common.mustCall(function(err, stdout, stderr) {
-    assert.ifError(err);
+  common.mustSucceed((stdout, stderr) => {
     assert.strictEqual(stdout, 'A\nB\n');
   })
 );
@@ -174,8 +185,7 @@ if (common.isWindows) {
   childProcess.exec(
     `"${nodeBinary}" ${preloadOption(['.\\printA.js'])} "${fixtureB}"`,
     { cwd: fixtures.fixturesDir },
-    common.mustCall(function(err, stdout, stderr) {
-      assert.ifError(err);
+    common.mustSucceed((stdout, stderr) => {
       assert.strictEqual(stdout, 'A\nB\n');
     })
   );
diff --git a/test/parallel/test-primordials-apply.js b/test/parallel/test-primordials-apply.js
new file mode 100644
index 0000000000000000000000000000000000000000..0901a87ba187778434cef6abe0b77d999da39176
--- /dev/null
+++ b/test/parallel/test-primordials-apply.js
@@ -0,0 +1,74 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+const {
+  ArrayOfApply,
+  ArrayPrototypePushApply,
+  ArrayPrototypeUnshiftApply,
+  MathMaxApply,
+  MathMinApply,
+  StringPrototypeConcatApply,
+  TypedArrayOfApply,
+} = require('internal/test/binding').primordials;
+
+{
+  const arr1 = [1, 2, 3];
+  const arr2 = ArrayOfApply(arr1);
+
+  assert.deepStrictEqual(arr2, arr1);
+  assert.notStrictEqual(arr2, arr1);
+}
+
+{
+  const array = [1, 2, 3];
+  const i32Array = TypedArrayOfApply(Int32Array, array);
+
+  assert(i32Array instanceof Int32Array);
+  assert.strictEqual(i32Array.length, array.length);
+  for (let i = 0, { length } = array; i < length; i++) {
+    assert.strictEqual(i32Array[i], array[i], `i32Array[${i}] === array[${i}]`);
+  }
+}
+
+{
+  const arr1 = [1, 2, 3];
+  const arr2 = [4, 5, 6];
+
+  const expected = [...arr1, ...arr2];
+
+  assert.strictEqual(ArrayPrototypePushApply(arr1, arr2), expected.length);
+  assert.deepStrictEqual(arr1, expected);
+}
+
+{
+  const arr1 = [1, 2, 3];
+  const arr2 = [4, 5, 6];
+
+  const expected = [...arr2, ...arr1];
+
+  assert.strictEqual(ArrayPrototypeUnshiftApply(arr1, arr2), expected.length);
+  assert.deepStrictEqual(arr1, expected);
+}
+
+{
+  const array = [1, 2, 3];
+  assert.strictEqual(MathMaxApply(array), 3);
+  assert.strictEqual(MathMinApply(array), 1);
+}
+
+{
+  let hint;
+  const obj = { [Symbol.toPrimitive](h) {
+    hint = h;
+    return '[object Object]';
+  } };
+
+  const args = ['foo ', obj, ' bar'];
+  const result = StringPrototypeConcatApply('', args);
+
+  assert.strictEqual(hint, 'string');
+  assert.strictEqual(result, 'foo [object Object] bar');
+}
diff --git a/test/parallel/test-priority-queue.js b/test/parallel/test-priority-queue.js
index f6318ede7ffbca2fb055f7ac03b3d1ea61598299..b98d228b08763b16bbcf8abb52c27bf0029cc05f 100644
--- a/test/parallel/test-priority-queue.js
+++ b/test/parallel/test-priority-queue.js
@@ -43,27 +43,6 @@ const PriorityQueue = require('internal/priority_queue');
   assert.strictEqual(queue.shift(), undefined);
 }
 
-{
-  // Checks that remove works as expected.
-  const queue = new PriorityQueue();
-  for (let i = 16; i > 0; i--)
-    queue.insert(i);
-
-  const removed = [5, 10, 15];
-  for (const id of removed)
-    assert(queue.remove(id));
-
-  assert(!queue.remove(100));
-  assert(!queue.remove(-100));
-
-  for (let i = 1; i < 17; i++) {
-    if (removed.indexOf(i) < 0)
-      assert.strictEqual(queue.shift(), i);
-  }
-
-  assert.strictEqual(queue.shift(), undefined);
-}
-
 {
   // Make a max heap with a custom sort function.
   const queue = new PriorityQueue((a, b) => b - a);
diff --git a/test/parallel/test-process-beforeexit-throw-exit.js b/test/parallel/test-process-beforeexit-throw-exit.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e9d764be90baa9d9ba2e0b3af50c28418c294cc
--- /dev/null
+++ b/test/parallel/test-process-beforeexit-throw-exit.js
@@ -0,0 +1,12 @@
+'use strict';
+const common = require('../common');
+common.skipIfWorker();
+
+// Test that 'exit' is emitted if 'beforeExit' throws.
+
+process.on('exit', common.mustCall(() => {
+  process.exitCode = 0;
+}));
+process.on('beforeExit', common.mustCall(() => {
+  throw new Error();
+}));
diff --git a/test/parallel/test-process-beforeexit.js b/test/parallel/test-process-beforeexit.js
index 215e73dc0650f3f55305ef1d5d187f4650225a55..7b7ba48f7d8cb48777a6f4e7bca349d6c2d1b767 100644
--- a/test/parallel/test-process-beforeexit.js
+++ b/test/parallel/test-process-beforeexit.js
@@ -49,12 +49,24 @@ function tryListen() {
 // Test that a function invoked from the beforeExit handler can use a timer
 // to keep the event loop open, which can use another timer to keep the event
 // loop open, etc.
+//
+// After N times, call function `tryNextTick` to test behaviors of the
+// `process.nextTick`.
 function tryRepeatedTimer() {
   const N = 5;
   let n = 0;
   const repeatedTimer = common.mustCall(function() {
     if (++n < N)
       setTimeout(repeatedTimer, 1);
+    else // n == N
+      process.once('beforeExit', common.mustCall(tryNextTick));
   }, N);
   setTimeout(repeatedTimer, 1);
 }
+
+// Test if the callback of `process.nextTick` can be invoked.
+function tryNextTick() {
+  process.nextTick(common.mustCall(function() {
+    process.once('beforeExit', common.mustNotCall());
+  }));
+}
diff --git a/test/parallel/test-process-binding-internalbinding-whitelist.js b/test/parallel/test-process-binding-internalbinding-allowlist.js
similarity index 94%
rename from test/parallel/test-process-binding-internalbinding-whitelist.js
rename to test/parallel/test-process-binding-internalbinding-allowlist.js
index 9768ef66741aa32b6923757d79e37b8c55f675fd..10667b843cde8895c4283aa724574aaba6c11d7f 100644
--- a/test/parallel/test-process-binding-internalbinding-whitelist.js
+++ b/test/parallel/test-process-binding-internalbinding-allowlist.js
@@ -4,7 +4,7 @@
 const common = require('../common');
 const assert = require('assert');
 
-// Assert that whitelisted internalBinding modules are accessible via
+// Assert that allowed internalBinding modules are accessible via
 // process.binding().
 assert(process.binding('async_wrap'));
 assert(process.binding('buffer'));
diff --git a/test/parallel/test-process-cpuUsage.js b/test/parallel/test-process-cpuUsage.js
index ecd782f86a52a959eec259d99555e591998ed1d3..3493ce90fafd370e39b0e7706976fb66c2c72385 100644
--- a/test/parallel/test-process-cpuUsage.js
+++ b/test/parallel/test-process-cpuUsage.js
@@ -62,7 +62,7 @@ assert.throws(
 
 [
   { user: 3, system: 'b' },
-  { user: 3, system: null }
+  { user: 3, system: null },
 ].forEach((value) => {
   assert.throws(
     () => process.cpuUsage(value),
@@ -78,7 +78,7 @@ assert.throws(
 // Check invalid values.
 [
   { user: -1, system: 2 },
-  { user: Number.POSITIVE_INFINITY, system: 4 }
+  { user: Number.POSITIVE_INFINITY, system: 4 },
 ].forEach((value) => {
   assert.throws(
     () => process.cpuUsage(value),
@@ -93,7 +93,7 @@ assert.throws(
 
 [
   { user: 3, system: -2 },
-  { user: 5, system: Number.NEGATIVE_INFINITY }
+  { user: 5, system: Number.NEGATIVE_INFINITY },
 ].forEach((value) => {
   assert.throws(
     () => process.cpuUsage(value),
diff --git a/test/parallel/test-process-emit-warning-from-native.js b/test/parallel/test-process-emit-warning-from-native.js
index ee7e731935dc9d3541edc72071e424814ad06855..80b1e71a08c58e0329fc700d17b7c5a8fec70194 100644
--- a/test/parallel/test-process-emit-warning-from-native.js
+++ b/test/parallel/test-process-emit-warning-from-native.js
@@ -13,10 +13,10 @@ const key = '0123456789';
 {
   common.expectWarning({
     DeprecationWarning: [
-      ['crypto.createCipher is deprecated.', 'DEP0106']
+      ['crypto.createCipher is deprecated.', 'DEP0106'],
     ],
     Warning: [
-      ['Use Cipheriv for counter mode of aes-256-gcm']
+      ['Use Cipheriv for counter mode of aes-256-gcm'],
     ]
   });
 
diff --git a/test/parallel/test-process-emitwarning.js b/test/parallel/test-process-emitwarning.js
index de0861140d6135610e67981c07037d25fb40fa76..1bfac40ecbce30d04d5b697d31a70407a535fc50 100644
--- a/test/parallel/test-process-emitwarning.js
+++ b/test/parallel/test-process-emitwarning.js
@@ -42,7 +42,7 @@ class CustomWarning extends Error {
   [testMsg, { type: testType, code: testCode, detail: true }],
   [testMsg, { type: testType, code: testCode, detail: [] }],
   [testMsg, { type: testType, code: testCode, detail: null }],
-  [testMsg, { type: testType, code: testCode, detail: 1 }]
+  [testMsg, { type: testType, code: testCode, detail: 1 }],
 ].forEach((args) => {
   process.emitWarning(...args);
 });
@@ -72,7 +72,7 @@ process.emitWarning(warningThrowToString);
   ['', '', []],
   [],
   [undefined, 'foo', 'bar'],
-  [undefined]
+  [undefined],
 ].forEach((args) => {
   assert.throws(
     () => process.emitWarning(...args),
diff --git a/test/parallel/test-process-env-allowed-flags-are-documented.js b/test/parallel/test-process-env-allowed-flags-are-documented.js
index 0e0af9471ce84ed28bdc1c51070052f50ce3eab4..6e5a9678f81e9e7c1243cad192a3363a241449b9 100644
--- a/test/parallel/test-process-env-allowed-flags-are-documented.js
+++ b/test/parallel/test-process-env-allowed-flags-are-documented.js
@@ -31,7 +31,8 @@ assert.deepStrictEqual(v8OptionsLines, [...v8OptionsLines].sort());
 const documented = new Set();
 for (const line of [...nodeOptionsLines, ...v8OptionsLines]) {
   for (const match of line.matchAll(/`(-[^`]+)`/g)) {
-    const option = match[1];
+    // Remove negation from the option's name.
+    const option = match[1].replace('--no-', '--');
     assert(!documented.has(option),
            `Option '${option}' was documented more than once as an ` +
            `allowed option for NODE_OPTIONS in ${cliMd}.`);
@@ -41,12 +42,13 @@ for (const line of [...nodeOptionsLines, ...v8OptionsLines]) {
 
 // Filter out options that are conditionally present.
 const conditionalOpts = [
-  { include: common.hasCrypto,
+  {
+    include: common.hasCrypto,
     filter: (opt) => {
       return ['--openssl-config', '--tls-cipher-list', '--use-bundled-ca',
               '--use-openssl-ca' ].includes(opt);
-    } },
-  {
+    }
+  }, {
     // We are using openssl_is_fips from the configuration because it could be
     // the case that OpenSSL is FIPS compatible but fips has not been enabled
     // (starting node with --enable-fips). If we use common.hasFipsCrypto
@@ -54,11 +56,14 @@ const conditionalOpts = [
     // want to check options which will be available regardless of whether fips
     // is enabled at runtime or not.
     include: process.config.variables.openssl_is_fips,
-    filter: (opt) => opt.includes('-fips') },
-  { include: common.hasIntl,
-    filter: (opt) => opt === '--icu-data-dir' },
-  { include: process.features.inspector,
-    filter: (opt) => opt.startsWith('--inspect') || opt === '--debug-port' },
+    filter: (opt) => opt.includes('-fips')
+  }, {
+    include: common.hasIntl,
+    filter: (opt) => opt === '--icu-data-dir'
+  }, {
+    include: process.features.inspector,
+    filter: (opt) => opt.startsWith('--inspect') || opt === '--debug-port'
+  },
 ];
 documented.forEach((opt) => {
   conditionalOpts.forEach(({ include, filter }) => {
@@ -83,11 +88,23 @@ const undocumented = difference(process.allowedNodeEnvironmentFlags,
                                 documented);
 // Remove intentionally undocumented options.
 assert(undocumented.delete('--debug-arraybuffer-allocations'));
+assert(undocumented.delete('--no-debug-arraybuffer-allocations'));
 assert(undocumented.delete('--es-module-specifier-resolution'));
 assert(undocumented.delete('--experimental-report'));
 assert(undocumented.delete('--experimental-worker'));
+assert(undocumented.delete('--node-snapshot'));
 assert(undocumented.delete('--no-node-snapshot'));
 assert(undocumented.delete('--loader'));
+assert(undocumented.delete('--verify-base-objects'));
+assert(undocumented.delete('--no-verify-base-objects'));
+
+// Remove negated versions of the flags.
+for (const flag of undocumented) {
+  if (flag.startsWith('--no-')) {
+    assert(documented.has(`--${flag.slice(5)}`), flag);
+    undocumented.delete(flag);
+  }
+}
 
 assert.strictEqual(undocumented.size, 0,
                    'The following options are not documented as allowed in ' +
diff --git a/test/parallel/test-process-env-allowed-flags.js b/test/parallel/test-process-env-allowed-flags.js
index 21beb5357a5f656d8e078409dbac5e091eda2292..275e210619ec719254bd53ef248787a2fa3c460a 100644
--- a/test/parallel/test-process-env-allowed-flags.js
+++ b/test/parallel/test-process-env-allowed-flags.js
@@ -28,7 +28,7 @@ const assert = require('assert');
     '--r',
     '-R',
     '---inspect-brk',
-    '--cheeseburgers'
+    '--cheeseburgers',
   ];
 
   goodFlags.forEach((flag) => {
@@ -51,7 +51,7 @@ const assert = require('assert');
 // Assert all "canonical" flags begin with dash(es)
 {
   process.allowedNodeEnvironmentFlags.forEach((flag) => {
-    assert(/^--?[a-z0-9._-]+$/.test(flag),
+    assert(/^--?[a-zA-Z0-9._-]+$/.test(flag),
            `Unexpected format for flag ${flag}`);
   });
 }
diff --git a/test/parallel/test-process-env-tz.js b/test/parallel/test-process-env-tz.js
new file mode 100644
index 0000000000000000000000000000000000000000..da716299c9f6221c4445b22a0862201177a87667
--- /dev/null
+++ b/test/parallel/test-process-env-tz.js
@@ -0,0 +1,52 @@
+'use strict';
+
+// Set the locale to a known good value because it affects ICU's date string
+// formatting. Setting LC_ALL needs to happen before the first call to
+// `icu::Locale::getDefault()` because ICU caches the result.
+process.env.LC_ALL = 'C';
+
+const common = require('../common');
+const assert = require('assert');
+
+if (!common.isMainThread)
+  common.skip('process.env.TZ is not intercepted in Workers');
+
+if (common.isWindows)  // Using a different TZ format.
+  common.skip('todo: test on Windows');
+
+const date = new Date('2018-04-14T12:34:56.789Z');
+
+process.env.TZ = 'Europe/Amsterdam';
+
+if (date.toString().includes('(Europe)'))
+  common.skip('not using bundled ICU');  // Shared library or --with-intl=none.
+
+if ('Sat Apr 14 2018 12:34:56 GMT+0000 (GMT)' === date.toString())
+  common.skip('missing tzdata');  // Alpine buildbots lack Europe/Amsterdam.
+
+if (date.toString().includes('(Central European Time)') ||
+    date.toString().includes('(CET)')) {
+  // The AIX and SmartOS buildbots report 2018 CEST as CET
+  // because apparently for them that's still the deep future.
+  common.skip('tzdata too old');
+}
+
+assert.strictEqual(
+  date.toString().replace('Central European Summer Time', 'CEST'),
+  'Sat Apr 14 2018 14:34:56 GMT+0200 (CEST)');
+
+process.env.TZ = 'Europe/London';
+assert.strictEqual(
+  date.toString().replace('British Summer Time', 'BST'),
+  'Sat Apr 14 2018 13:34:56 GMT+0100 (BST)');
+
+process.env.TZ = 'Etc/UTC';
+assert.strictEqual(
+  date.toString().replace('Coordinated Universal Time', 'UTC'),
+  'Sat Apr 14 2018 12:34:56 GMT+0000 (UTC)');
+
+// Just check that deleting the environment variable doesn't crash the process.
+// We can't really check the result of date.toString() because we don't know
+// the default time zone.
+delete process.env.TZ;
+date.toString();
diff --git a/test/parallel/test-process-env-windows-error-reset.js b/test/parallel/test-process-env-windows-error-reset.js
index 59e5f287d823460e2cdaf76bde36e932f71ed994..881da06d2926d330815aed17ba9fb2473dc64895 100644
--- a/test/parallel/test-process-env-windows-error-reset.js
+++ b/test/parallel/test-process-env-windows-error-reset.js
@@ -7,7 +7,7 @@ const assert = require('assert');
 
 {
   process.env.FOO = '';
-  process.env.NONEXISTENT_ENV_VAR;
+  process.env.NONEXISTENT_ENV_VAR; // eslint-disable-line no-unused-expressions
   const foo = process.env.FOO;
 
   assert.strictEqual(foo, '');
@@ -15,7 +15,7 @@ const assert = require('assert');
 
 {
   process.env.FOO = '';
-  process.env.NONEXISTENT_ENV_VAR;
+  process.env.NONEXISTENT_ENV_VAR; // eslint-disable-line no-unused-expressions
   const hasFoo = 'FOO' in process.env;
 
   assert.strictEqual(hasFoo, true);
diff --git a/test/parallel/test-process-env.js b/test/parallel/test-process-env.js
index 4ece826e8b938ffbdbd2f7903937baf98d0f218b..2252ddea71675ac88e1fa408f8b6ec3231b19780 100644
--- a/test/parallel/test-process-env.js
+++ b/test/parallel/test-process-env.js
@@ -70,22 +70,21 @@ if (process.argv[2] === 'you-are-the-child') {
 delete process.env.NON_EXISTING_VARIABLE;
 assert(delete process.env.NON_EXISTING_VARIABLE);
 
-/* For the moment we are not going to support setting the timezone via the
- * environment variables. The problem is that various V8 platform backends
- * deal with timezone in different ways. The windows platform backend caches
- * the timezone value while the Linux one hits libc for every query.
-
-https://github.com/joyent/node/blob/08782931205bc4f6d28102ebc29fd806e8ccdf1f/deps/v8/src/platform-linux.cc#L339-345
-https://github.com/joyent/node/blob/08782931205bc4f6d28102ebc29fd806e8ccdf1f/deps/v8/src/platform-win32.cc#L590-596
-
-// set the timezone; see tzset(3)
-process.env.TZ = 'Europe/Amsterdam';
-
-// time difference between Greenwich and Amsterdam is +2 hours in the summer
-date = new Date('Fri, 10 Sep 1982 03:15:00 GMT');
-assert.strictEqual(3, date.getUTCHours());
-assert.strictEqual(5, date.getHours());
-*/
+// For the moment we are not going to support setting the timezone via the
+// environment variables. The problem is that various V8 platform backends
+// deal with timezone in different ways. The Windows platform backend caches
+// the timezone value while the Linux one hits libc for every query.
+//
+// https://github.com/joyent/node/blob/08782931205bc4f6d28102ebc29fd806e8ccdf1f/deps/v8/src/platform-linux.cc#L339-345
+// https://github.com/joyent/node/blob/08782931205bc4f6d28102ebc29fd806e8ccdf1f/deps/v8/src/platform-win32.cc#L590-596
+//
+// // set the timezone; see tzset(3)
+// process.env.TZ = 'Europe/Amsterdam';
+//
+// // time difference between Greenwich and Amsterdam is +2 hours in the summer
+// date = new Date('Fri, 10 Sep 1982 03:15:00 GMT');
+// assert.strictEqual(3, date.getUTCHours());
+// assert.strictEqual(5, date.getHours());
 
 // Environment variables should be case-insensitive on Windows, and
 // case-sensitive on other platforms.
diff --git a/test/parallel/test-process-exit-code.js b/test/parallel/test-process-exit-code.js
index 2f658a172cdc5a47af19101ef761ca7696c52d39..51d23c35c5665e27ef32790edcf1f19012c3ba0f 100644
--- a/test/parallel/test-process-exit-code.js
+++ b/test/parallel/test-process-exit-code.js
@@ -24,7 +24,8 @@ require('../common');
 const assert = require('assert');
 const debug = require('util').debuglog('test');
 
-const testCases = require('../fixtures/process-exit-code-cases');
+const { getTestCases } = require('../fixtures/process-exit-code-cases');
+const testCases = getTestCases(false);
 
 if (!process.argv[2]) {
   parent();
diff --git a/test/parallel/test-process-redirect-warnings-env.js b/test/parallel/test-process-redirect-warnings-env.js
index 5afc5dbb302edb4dae5b250016c18c7a79ecbe54..678f4b0868fafcaa092b89157fa782057d7e117c 100644
--- a/test/parallel/test-process-redirect-warnings-env.js
+++ b/test/parallel/test-process-redirect-warnings-env.js
@@ -20,8 +20,7 @@ const warnpath = path.join(tmpdir.path, 'warnings.txt');
 
 fork(warnmod, { env: { ...process.env, NODE_REDIRECT_WARNINGS: warnpath } })
   .on('exit', common.mustCall(() => {
-    fs.readFile(warnpath, 'utf8', common.mustCall((err, data) => {
-      assert.ifError(err);
+    fs.readFile(warnpath, 'utf8', common.mustSucceed((data) => {
       assert(/\(node:\d+\) Warning: a bad practice warning/.test(data));
     }));
   }));
diff --git a/test/parallel/test-process-redirect-warnings.js b/test/parallel/test-process-redirect-warnings.js
index b4f55fa8345409e17eae7d3fe699830380f8c1bd..dd66c87e633224d9d81dd8093079a030e3557121 100644
--- a/test/parallel/test-process-redirect-warnings.js
+++ b/test/parallel/test-process-redirect-warnings.js
@@ -20,8 +20,7 @@ const warnpath = path.join(tmpdir.path, 'warnings.txt');
 
 fork(warnmod, { execArgv: [`--redirect-warnings=${warnpath}`] })
   .on('exit', common.mustCall(() => {
-    fs.readFile(warnpath, 'utf8', common.mustCall((err, data) => {
-      assert.ifError(err);
+    fs.readFile(warnpath, 'utf8', common.mustSucceed((data) => {
       assert(/\(node:\d+\) Warning: a bad practice warning/.test(data));
     }));
   }));
diff --git a/test/parallel/test-process-release.js b/test/parallel/test-process-release.js
index 13263894919407641f85d4cd8cbb4d0569b94366..ebb259f774a62cc2f1a299bda824d9689aa43d67 100644
--- a/test/parallel/test-process-release.js
+++ b/test/parallel/test-process-release.js
@@ -19,6 +19,8 @@ if (versionParts[0] === '4' && versionParts[1] >= 2) {
   assert.strictEqual(process.release.lts, 'Dubnium');
 } else if (versionParts[0] === '12' && versionParts[1] >= 13) {
   assert.strictEqual(process.release.lts, 'Erbium');
+} else if (versionParts[0] === '14' && versionParts[1] >= 15) {
+  assert.strictEqual(process.release.lts, 'Fermium');
 } else {
   assert.strictEqual(process.release.lts, undefined);
 }
diff --git a/test/parallel/test-process-setsourcemapsenabled.js b/test/parallel/test-process-setsourcemapsenabled.js
new file mode 100644
index 0000000000000000000000000000000000000000..7211cfb3b88cf2dc114c73acad7509d9a24d6355
--- /dev/null
+++ b/test/parallel/test-process-setsourcemapsenabled.js
@@ -0,0 +1,16 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const unexpectedValues = [
+  undefined,
+  null,
+  1,
+  {},
+  () => {},
+];
+for (const it of unexpectedValues) {
+  assert.throws(() => {
+    process.setSourceMapsEnabled(it);
+  }, /ERR_INVALID_ARG_TYPE/);
+}
diff --git a/test/parallel/test-process-uid-gid.js b/test/parallel/test-process-uid-gid.js
index 6ca2e009571ef012a77a481fa21d1ce0cdef18c7..0e170620b7f237fb1bdcb798ffe6d0f851f50265 100644
--- a/test/parallel/test-process-uid-gid.js
+++ b/test/parallel/test-process-uid-gid.js
@@ -51,6 +51,13 @@ assert.throws(() => {
   message: 'User identifier does not exist: fhqwhgadshgnsdhjsdbkhsdabkfabkveyb'
 });
 
+// Passing -0 shouldn't crash the process
+// Refs: https://github.com/nodejs/node/issues/32750
+try { process.setuid(-0); } catch {}
+try { process.seteuid(-0); } catch {}
+try { process.setgid(-0); } catch {}
+try { process.setegid(-0); } catch {}
+
 // If we're not running as super user...
 if (process.getuid() !== 0) {
   // Should not throw.
@@ -79,6 +86,7 @@ try {
   }
   process.setgid('nogroup');
 }
+
 const newgid = process.getgid();
 assert.notStrictEqual(newgid, oldgid);
 
diff --git a/test/parallel/test-process-versions.js b/test/parallel/test-process-versions.js
index 83568a30d8074a4763d772765041f3fbb058db9d..5d2371f44272cf5a4e297568e276078d44964175 100644
--- a/test/parallel/test-process-versions.js
+++ b/test/parallel/test-process-versions.js
@@ -2,9 +2,18 @@
 const common = require('../common');
 const assert = require('assert');
 
-const expected_keys = ['ares', 'brotli', 'modules', 'node',
-                       'uv', 'v8', 'zlib', 'nghttp2', 'napi',
-                       'http_parser', 'llhttp'];
+const expected_keys = [
+  'ares',
+  'brotli',
+  'modules',
+  'node',
+  'uv',
+  'v8',
+  'zlib',
+  'nghttp2',
+  'napi',
+  'llhttp',
+];
 
 if (common.hasCrypto) {
   expected_keys.push('openssl');
@@ -27,7 +36,6 @@ const commonTemplate = /^\d+\.\d+\.\d+(?:-.*)?$/;
 assert(commonTemplate.test(process.versions.ares));
 assert(commonTemplate.test(process.versions.brotli));
 assert(commonTemplate.test(process.versions.llhttp));
-assert(commonTemplate.test(process.versions.http_parser));
 assert(commonTemplate.test(process.versions.node));
 assert(commonTemplate.test(process.versions.uv));
 assert(commonTemplate.test(process.versions.zlib));
diff --git a/test/parallel/test-process-wrap.js b/test/parallel/test-process-wrap.js
index ef9075e9158229d7467941d99d77c6829ec33649..997e3e439080108cc4b5d12331c56d79353099c1 100644
--- a/test/parallel/test-process-wrap.js
+++ b/test/parallel/test-process-wrap.js
@@ -60,7 +60,7 @@ p.spawn({
   stdio: [
     { type: 'ignore' },
     { type: 'pipe', handle: pipe },
-    { type: 'ignore' }
+    { type: 'ignore' },
   ]
 });
 
@@ -74,7 +74,7 @@ assert.throws(function() {
     stdio: [
       { type: 'ignore' },
       { type: 'pipe', handle: pipe },
-      { type: 'ignore' }
+      { type: 'ignore' },
     ]
   });
 }, TypeError);
diff --git a/test/parallel/test-promise-swallowed-event.js b/test/parallel/test-promise-swallowed-event.js
index 144d732c20668b1994e15f3f65e685e5a27c08d2..e9b97ab19d329df1d98b5bdcbc3e104bc1ed1339 100644
--- a/test/parallel/test-promise-swallowed-event.js
+++ b/test/parallel/test-promise-swallowed-event.js
@@ -38,7 +38,7 @@ const expected = [
   swallowedResolve2,
   'reject',
   p2,
-  rejection2
+  rejection2,
 ];
 
 let count = 0;
diff --git a/test/parallel/test-promise-unhandled-throw-handler.js b/test/parallel/test-promise-unhandled-throw-handler.js
new file mode 100644
index 0000000000000000000000000000000000000000..be441c2d34c6bdef0ac537bdb1a8492a0f32ded0
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-throw-handler.js
@@ -0,0 +1,38 @@
+// Flags: --unhandled-rejections=throw
+'use strict';
+
+const common = require('../common');
+const Countdown = require('../common/countdown');
+const assert = require('assert');
+
+common.disableCrashOnUnhandledRejection();
+
+// Verify that the unhandledRejection handler prevents triggering
+// uncaught exceptions
+
+const err1 = new Error('One');
+
+const errors = [err1, null];
+
+const ref = new Promise(() => {
+  throw err1;
+});
+// Explicitly reject `null`.
+Promise.reject(null);
+
+process.on('warning', common.mustNotCall('warning'));
+process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+process.on('exit', assert.strictEqual.bind(null, 0));
+process.on('uncaughtException', common.mustNotCall('uncaughtException'));
+
+const timer = setTimeout(() => console.log(ref), 1000);
+
+const counter = new Countdown(2, () => {
+  clearTimeout(timer);
+});
+
+process.on('unhandledRejection', common.mustCall((err) => {
+  counter.dec();
+  const knownError = errors.shift();
+  assert.deepStrictEqual(err, knownError);
+}, 2));
diff --git a/test/parallel/test-promise-unhandled-throw.js b/test/parallel/test-promise-unhandled-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..30c6b87135b49b80007dfcc118e3bfb8efb23ff3
--- /dev/null
+++ b/test/parallel/test-promise-unhandled-throw.js
@@ -0,0 +1,55 @@
+// Flags: --unhandled-rejections=throw
+'use strict';
+
+const common = require('../common');
+const Countdown = require('../common/countdown');
+const assert = require('assert');
+
+common.disableCrashOnUnhandledRejection();
+
+// Verify that unhandled rejections always trigger uncaught exceptions instead
+// of triggering unhandled rejections.
+
+const err1 = new Error('One');
+const err2 = new Error(
+  'This error originated either by throwing ' +
+  'inside of an async function without a catch block, or by rejecting a ' +
+  'promise which was not handled with .catch(). The promise rejected with the' +
+  ' reason "null".'
+);
+err2.code = 'ERR_UNHANDLED_REJECTION';
+Object.defineProperty(err2, 'name', {
+  value: 'UnhandledPromiseRejection',
+  writable: true,
+  configurable: true
+});
+
+const errors = [err1, err2];
+const identical = [true, false];
+
+const ref = new Promise(() => {
+  throw err1;
+});
+// Explicitly reject `null`.
+Promise.reject(null);
+
+process.on('warning', common.mustNotCall('warning'));
+// If we add an unhandledRejection handler, the exception won't be thrown
+// process.on('unhandledRejection', common.mustCall(2));
+process.on('rejectionHandled', common.mustNotCall('rejectionHandled'));
+process.on('exit', assert.strictEqual.bind(null, 0));
+
+const timer = setTimeout(() => console.log(ref), 1000);
+
+const counter = new Countdown(2, () => {
+  clearTimeout(timer);
+});
+
+process.on('uncaughtException', common.mustCall((err, origin) => {
+  counter.dec();
+  assert.strictEqual(origin, 'unhandledRejection', err);
+  const knownError = errors.shift();
+  assert.deepStrictEqual(err, knownError);
+  // Check if the errors are reference equal.
+  assert(identical.shift() ? err === knownError : err !== knownError);
+}, 2));
diff --git a/test/parallel/test-promises-unhandled-symbol-rejections.js b/test/parallel/test-promises-unhandled-symbol-rejections.js
index 2851ce977fc4d036fa159c132a162011d3f57a23..ab112d3b9979520fcdb302abdb3195f6b18e584f 100644
--- a/test/parallel/test-promises-unhandled-symbol-rejections.js
+++ b/test/parallel/test-promises-unhandled-symbol-rejections.js
@@ -23,7 +23,7 @@ common.expectWarning({
   DeprecationWarning: expectedDeprecationWarning,
   UnhandledPromiseRejectionWarning: [
     expectedValueWarning,
-    expectedPromiseWarning
+    expectedPromiseWarning,
   ],
 });
 
diff --git a/test/parallel/test-punycode.js b/test/parallel/test-punycode.js
index d7ad2ec21faa57750012eb1deb0c014523f6c032..190c0b22b313dc387bc1923b03e6abaf7e182fd0 100644
--- a/test/parallel/test-punycode.js
+++ b/test/parallel/test-punycode.js
@@ -194,7 +194,7 @@ const tests = [
     encoded: '-> $1.00 <--',
     decoded: '\u002D\u003E\u0020\u0024\u0031\u002E\u0030\u0030\u0020\u003C' +
       '\u002D'
-  }
+  },
 ];
 
 let errors = 0;
diff --git a/test/parallel/test-querystring-maxKeys-non-finite.js b/test/parallel/test-querystring-maxKeys-non-finite.js
index 4c752fd26948d58c7dfbe4b4edc51af2eb9fa18f..610c30c7a363a4a67074805645014514446e7503 100644
--- a/test/parallel/test-querystring-maxKeys-non-finite.js
+++ b/test/parallel/test-querystring-maxKeys-non-finite.js
@@ -7,11 +7,8 @@ require('../common');
 const assert = require('assert');
 const parse = require('querystring').parse;
 
-/*
-taken from express-js/body-parser
-https://github.com/expressjs/body-parser/
-blob/ed25264fb494cf0c8bc992b8257092cd4f694d5e/test/urlencoded.js#L636-L651
-*/
+// Taken from express-js/body-parser
+// https://github.com/expressjs/body-parser/blob/ed25264fb494cf0c8bc992b8257092cd4f694d5e/test/urlencoded.js#L636-L651
 function createManyParams(count) {
   let str = '';
 
diff --git a/test/parallel/test-querystring.js b/test/parallel/test-querystring.js
index 58554f0d85c4386046980b2889c8d49d6d918e6e..eda94bf8df91642eddcc6ce0607c83d0a4c42751 100644
--- a/test/parallel/test-querystring.js
+++ b/test/parallel/test-querystring.js
@@ -107,7 +107,7 @@ const qsTestCases = [
   ['%20+&', '%20%20=', { '  ': '' }],
   ['=%20+&', '=%20%20', { '': '  ' }],
   [null, '', {}],
-  [undefined, '', {}]
+  [undefined, '', {}],
 ];
 
 // [ wonkyQS, canonicalQS, obj ]
@@ -118,7 +118,7 @@ const qsColonTestCases = [
    'foo:1%26bar%3A2;baz:quux',
    { 'foo': '1&bar:2', 'baz': 'quux' }],
   ['foo%3Abaz:bar', 'foo%3Abaz:bar', { 'foo:baz': 'bar' }],
-  ['foo:baz:bar', 'foo:baz%3Abar', { 'foo': 'baz:bar' }]
+  ['foo:baz:bar', 'foo:baz%3Abar', { 'foo': 'baz:bar' }],
 ];
 
 // [wonkyObj, qs, canonicalObj]
@@ -138,14 +138,14 @@ const qsWeirdObjects = [
   [
     { f: new Boolean(false), t: new Boolean(true) },
     'f=&t=',
-    { 'f': '', 't': '' }
+    { 'f': '', 't': '' },
   ],
   [{ f: false, t: true }, 'f=false&t=true', { 'f': 'false', 't': 'true' }],
   [{ n: null }, 'n=', { 'n': '' }],
   [{ nan: NaN }, 'nan=', { 'nan': '' }],
   [{ inf: Infinity }, 'inf=', { 'inf': '' }],
   [{ a: [], b: [] }, '', {}],
-  [{ a: 1, b: [] }, 'a=1', { 'a': '1' }]
+  [{ a: 1, b: [] }, 'a=1', { 'a': '1' }],
 ];
 // }}}
 
@@ -164,7 +164,7 @@ const qsNoMungeTestCases = [
   ['gragh=1&gragh=3&goo=2', { 'gragh': ['1', '3'], 'goo': '2' }],
   ['frappucino=muffin&goat%5B%5D=scone&pond=moose',
    { 'frappucino': 'muffin', 'goat[]': 'scone', 'pond': 'moose' }],
-  ['trololol=yes&lololo=no', { 'trololol': 'yes', 'lololo': 'no' }]
+  ['trololol=yes&lololo=no', { 'trololol': 'yes', 'lololo': 'no' }],
 ];
 
 const qsUnescapeTestCases = [
@@ -178,7 +178,7 @@ const qsUnescapeTestCases = [
    ' !"#$%&\'()*+,-./01234567'],
   ['%%2a', '%*'],
   ['%2sf%2a', '%2sf*'],
-  ['%2%2af%2a', '%2*f*']
+  ['%2%2af%2a', '%2*f*'],
 ];
 
 assert.strictEqual(qs.parse('id=918854443121279438895193').id,
@@ -232,13 +232,13 @@ qsNoMungeTestCases.forEach((testCase) => {
   const f = qs.parse('a=b&q=x%3Dy%26y%3Dz');
   check(f, createWithNoPrototype([
     { key: 'a', value: 'b' },
-    { key: 'q', value: 'x=y&y=z' }
+    { key: 'q', value: 'x=y&y=z' },
   ]));
 
   f.q = qs.parse(f.q);
   const expectedInternal = createWithNoPrototype([
     { key: 'x', value: 'y' },
-    { key: 'y', value: 'z' }
+    { key: 'y', value: 'z' },
   ]);
   check(f.q, expectedInternal);
 }
@@ -248,12 +248,12 @@ qsNoMungeTestCases.forEach((testCase) => {
   const f = qs.parse('a:b;q:x%3Ay%3By%3Az', ';', ':');
   check(f, createWithNoPrototype([
     { key: 'a', value: 'b' },
-    { key: 'q', value: 'x:y;y:z' }
+    { key: 'q', value: 'x:y;y:z' },
   ]));
   f.q = qs.parse(f.q, ';', ':');
   const expectedInternal = createWithNoPrototype([
     { key: 'x', value: 'y' },
-    { key: 'y', value: 'z' }
+    { key: 'y', value: 'z' },
   ]);
   check(f.q, expectedInternal);
 }
@@ -273,6 +273,24 @@ qsWeirdObjects.forEach((testCase) => {
   assert.strictEqual(qs.stringify(testCase[0]), testCase[1]);
 });
 
+// BigInt values
+
+assert.strictEqual(qs.stringify({ foo: 2n ** 1023n }),
+                   'foo=' + 2n ** 1023n);
+assert.strictEqual(qs.stringify([0n, 1n, 2n]),
+                   '0=0&1=1&2=2');
+
+assert.strictEqual(qs.stringify({ foo: 2n ** 1023n },
+                                null,
+                                null,
+                                { encodeURIComponent: (c) => c }),
+                   'foo=' + 2n ** 1023n);
+assert.strictEqual(qs.stringify([0n, 1n, 2n],
+                                null,
+                                null,
+                                { encodeURIComponent: (c) => c }),
+                   '0=0&1=1&2=2');
+
 // Invalid surrogate pair throws URIError
 assert.throws(
   () => qs.stringify({ foo: '\udc00' }),
@@ -289,6 +307,7 @@ assert.strictEqual(qs.stringify({ foo: -0 }), 'foo=0');
 assert.strictEqual(qs.stringify({ foo: 3 }), 'foo=3');
 assert.strictEqual(qs.stringify({ foo: -72.42 }), 'foo=-72.42');
 assert.strictEqual(qs.stringify({ foo: NaN }), 'foo=');
+assert.strictEqual(qs.stringify({ foo: 1e21 }), 'foo=1e%2B21');
 assert.strictEqual(qs.stringify({ foo: Infinity }), 'foo=');
 
 // nested
@@ -432,6 +451,14 @@ check(qs.parse('%\u0100=%\u0101'), { '%Ā': '%ā' });
     'a=a&b=b&c=c');
 }
 
+// Test custom encode for different types
+{
+  const obj = { number: 1, bigint: 2n, true: true, false: false, object: {} };
+  assert.strictEqual(
+    qs.stringify(obj, null, null, { encodeURIComponent: (v) => v }),
+    'number=1&bigint=2&true=true&false=false&object=');
+}
+
 // Test QueryString.unescapeBuffer
 qsUnescapeTestCases.forEach((testCase) => {
   assert.strictEqual(qs.unescape(testCase[0]), testCase[1]);
diff --git a/test/parallel/test-readable-from.js b/test/parallel/test-readable-from.js
index 94bc2c1ae4b9263a5a33aa4c881c344f57108b9b..f196d0b971f9b978d275e972ad44579752a17e75 100644
--- a/test/parallel/test-readable-from.js
+++ b/test/parallel/test-readable-from.js
@@ -41,7 +41,7 @@ async function toReadablePromises() {
   const promises = [
     Promise.resolve('a'),
     Promise.resolve('b'),
-    Promise.resolve('c')
+    Promise.resolve('c'),
   ];
 
   const stream = Readable.from(promises);
@@ -192,5 +192,5 @@ Promise.all([
   toReadableOnDataNonObject(),
   destroysTheStreamWhenThrowing(),
   asTransformStream(),
-  endWithError()
+  endWithError(),
 ]).then(mustCall());
diff --git a/test/parallel/test-readline-async-iterators-destroy.js b/test/parallel/test-readline-async-iterators-destroy.js
index e96f831432b1eb5abeab348956e585d4141f35c2..dc0ef3e1631d0aea164caa7bfef0f340b2efd8bc 100644
--- a/test/parallel/test-readline-async-iterators-destroy.js
+++ b/test/parallel/test-readline-async-iterators-destroy.js
@@ -17,7 +17,7 @@ const testContents = [
   '\n',
   'line 1',
   'line 1\nline 2 南越国是前203年至前111年存在于岭南地区的一个国家\nline 3\ntrailing',
-  'line 1\nline 2\nline 3 ends with newline\n'
+  'line 1\nline 2\nline 3 ends with newline\n',
 ];
 
 async function testSimpleDestroy() {
diff --git a/test/parallel/test-readline-async-iterators.js b/test/parallel/test-readline-async-iterators.js
index c3883e4f369fdec7559017a97c793b2fd05d0874..2aa557a33634862b6dfdb336ce025f4aef3b81b1 100644
--- a/test/parallel/test-readline-async-iterators.js
+++ b/test/parallel/test-readline-async-iterators.js
@@ -16,7 +16,7 @@ const testContents = [
   '\n',
   'line 1',
   'line 1\nline 2 南越国是前203年至前111年存在于岭南地区的一个国家\nline 3\ntrailing',
-  'line 1\nline 2\nline 3 ends with newline\n'
+  'line 1\nline 2\nline 3 ends with newline\n',
 ];
 
 async function testSimple() {
@@ -39,7 +39,7 @@ async function testSimple() {
       expectedLines.pop();
     }
     assert.deepStrictEqual(iteratedLines, expectedLines);
-    assert.strictEqual(iteratedLines.join(''), fileContent.replace(/\n/gm, ''));
+    assert.strictEqual(iteratedLines.join(''), fileContent.replace(/\n/g, ''));
   }
 }
 
diff --git a/test/parallel/test-readline-emit-keypress-events.js b/test/parallel/test-readline-emit-keypress-events.js
index 3b9aece4654ac12a25621e059fd3056690ada8fc..8bb10d905cae2a3e25eb596d0750f32ccc29729e 100644
--- a/test/parallel/test-readline-emit-keypress-events.js
+++ b/test/parallel/test-readline-emit-keypress-events.js
@@ -24,5 +24,5 @@ assert.deepStrictEqual(sequence, ['f', 'o', 'o']);
 assert.deepStrictEqual(keys, [
   { sequence: 'f', name: 'f', ctrl: false, meta: false, shift: false },
   { sequence: 'o', name: 'o', ctrl: false, meta: false, shift: false },
-  { sequence: 'o', name: 'o', ctrl: false, meta: false, shift: false }
+  { sequence: 'o', name: 'o', ctrl: false, meta: false, shift: false },
 ]);
diff --git a/test/parallel/test-readline-interface-escapecodetimeout.js b/test/parallel/test-readline-interface-escapecodetimeout.js
index 58f5fcb3cde42fd0a31492f48dfac28dcc980601..db78458be710643e8f39826a2df0f31f2f4fba09 100644
--- a/test/parallel/test-readline-interface-escapecodetimeout.js
+++ b/test/parallel/test-readline-interface-escapecodetimeout.js
@@ -29,7 +29,7 @@ class FakeInput extends EventEmitter {
   null,
   {},
   NaN,
-  '50'
+  '50',
 ].forEach((invalidInput) => {
   assert.throws(() => {
     const fi = new FakeInput();
diff --git a/test/parallel/test-readline-interface.js b/test/parallel/test-readline-interface.js
index 13765e6c4664fa1d47086269f5ec36b70f8cf6cb..3f8909914a313c36097893ff10286c388f80469f 100644
--- a/test/parallel/test-readline-interface.js
+++ b/test/parallel/test-readline-interface.js
@@ -19,18 +19,19 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-// Flags: --expose-internals
+// Flags: --expose-internals --experimental-abortcontroller
 'use strict';
 const common = require('../common');
 common.skipIfDumbTerminal();
 
 const assert = require('assert');
 const readline = require('readline');
+const util = require('util');
 const {
   getStringWidth,
   stripVTControlCharacters
 } = require('internal/util/inspect');
-const EventEmitter = require('events').EventEmitter;
+const { EventEmitter, getEventListeners } = require('events');
 const { Writable, Readable } = require('stream');
 
 class FakeInput extends EventEmitter {
@@ -48,1170 +49,972 @@ function isWarned(emitter) {
   return false;
 }
 
-{
-  // Default crlfDelay is 100ms
+function getInterface(options) {
   const fi = new FakeInput();
-  const rli = new readline.Interface({ input: fi, output: fi });
-  assert.strictEqual(rli.crlfDelay, 100);
+  const rli = new readline.Interface({
+    input: fi,
+    output: fi,
+    ...options,
+  });
+  return [rli, fi];
+}
+
+function assertCursorRowsAndCols(rli, rows, cols) {
+  const cursorPos = rli.getCursorPos();
+  assert.strictEqual(cursorPos.rows, rows);
+  assert.strictEqual(cursorPos.cols, cols);
+}
+
+{
+  const input = new FakeInput();
+  const rl = readline.Interface({ input });
+  assert(rl instanceof readline.Interface);
+}
+
+[
+  undefined,
+  50,
+  0,
+  100.5,
+  5000,
+].forEach((crlfDelay) => {
+  const [rli] = getInterface({ crlfDelay });
+  assert.strictEqual(rli.crlfDelay, Math.max(crlfDelay || 100, 100));
   rli.close();
+});
+
+{
+  const input = new FakeInput();
+
+  // Constructor throws if completer is not a function or undefined
+  assert.throws(() => {
+    readline.createInterface({
+      input,
+      completer: 'string is not valid'
+    });
+  }, {
+    name: 'TypeError',
+    code: 'ERR_INVALID_OPT_VALUE'
+  });
+
+  assert.throws(() => {
+    readline.createInterface({
+      input,
+      completer: ''
+    });
+  }, {
+    name: 'TypeError',
+    code: 'ERR_INVALID_OPT_VALUE'
+  });
+
+  assert.throws(() => {
+    readline.createInterface({
+      input,
+      completer: false
+    });
+  }, {
+    name: 'TypeError',
+    code: 'ERR_INVALID_OPT_VALUE'
+  });
+
+  // Constructor throws if history is not an array
+  ['not an array', 123, 123n, {}, true, Symbol(), null].forEach((history) => {
+    assert.throws(() => {
+      readline.createInterface({
+        input,
+        history,
+      });
+    }, {
+      name: 'TypeError',
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  // Constructor throws if historySize is not a positive number
+  ['not a number', -1, NaN, {}, true, Symbol(), null].forEach((historySize) => {
+    assert.throws(() => {
+      readline.createInterface({
+        input,
+        historySize,
+      });
+    }, {
+      name: 'RangeError',
+      code: 'ERR_INVALID_OPT_VALUE'
+    });
+  });
+
+  // Check for invalid tab sizes.
+  assert.throws(
+    () => new readline.Interface({
+      input,
+      tabSize: 0
+    }),
+    {
+      message: 'The value of "tabSize" is out of range. ' +
+                'It must be >= 1 && < 4294967296. Received 0',
+      code: 'ERR_OUT_OF_RANGE'
+    }
+  );
+
+  assert.throws(
+    () => new readline.Interface({
+      input,
+      tabSize: '4'
+    }),
+    { code: 'ERR_INVALID_ARG_TYPE' }
+  );
+
+  assert.throws(
+    () => new readline.Interface({
+      input,
+      tabSize: 4.5
+    }),
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      message: 'The value of "tabSize" is out of range. ' +
+                'It must be an integer. Received 4.5'
+    }
+  );
 }
 
+// Sending a single character with no newline
 {
-  // Minimum crlfDelay is 100ms
   const fi = new FakeInput();
-  const rli = new readline.Interface({ input: fi, output: fi, crlfDelay: 0 });
-  assert.strictEqual(rli.crlfDelay, 100);
+  const rli = new readline.Interface(fi, {});
+  rli.on('line', common.mustNotCall());
+  fi.emit('data', 'a');
   rli.close();
 }
 
+// Sending multiple newlines at once that does not end with a new line and a
+// `end` event(last line is). \r should behave like \n when alone.
 {
-  // Set crlfDelay to float 100.5ms
-  const fi = new FakeInput();
-  const rli = new readline.Interface({
-    input: fi,
-    output: fi,
-    crlfDelay: 100.5
+  const [rli, fi] = getInterface({ terminal: true });
+  const expectedLines = ['foo', 'bar', 'baz', 'bat'];
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, expectedLines.shift());
+  }, expectedLines.length - 1));
+  fi.emit('data', expectedLines.join('\r'));
+  rli.close();
+}
+
+// \r at start of input should output blank line
+{
+  const [rli, fi] = getInterface({ terminal: true });
+  const expectedLines = ['', 'foo' ];
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, expectedLines.shift());
+  }, expectedLines.length));
+  fi.emit('data', '\rfoo\r');
+  rli.close();
+}
+
+// \t does not become part of the input when there is a completer function
+{
+  const completer = (line) => [[], line];
+  const [rli, fi] = getInterface({ terminal: true, completer });
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, 'foo');
+  }));
+  for (const character of '\tfo\to\t') {
+    fi.emit('data', character);
+  }
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// \t when there is no completer function should behave like an ordinary
+// character
+{
+  const [rli, fi] = getInterface({ terminal: true });
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '\t');
+  }));
+  fi.emit('data', '\t');
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// Adding history lines should emit the history event with
+// the history array
+{
+  const [rli, fi] = getInterface({ terminal: true });
+  const expectedLines = ['foo', 'bar', 'baz', 'bat'];
+  rli.on('history', common.mustCall((history) => {
+    const expectedHistory = expectedLines.slice(0, history.length).reverse();
+    assert.deepStrictEqual(history, expectedHistory);
+  }, expectedLines.length));
+  for (const line of expectedLines) {
+    fi.emit('data', `${line}\n`);
+  }
+  rli.close();
+}
+
+// Altering the history array in the listener should not alter
+// the line being processed
+{
+  const [rli, fi] = getInterface({ terminal: true });
+  const expectedLine = 'foo';
+  rli.on('history', common.mustCall((history) => {
+    assert.strictEqual(history[0], expectedLine);
+    history.shift();
+  }));
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, expectedLine);
+    assert.strictEqual(rli.history.length, 0);
+  }));
+  fi.emit('data', `${expectedLine}\n`);
+  rli.close();
+}
+
+// Duplicate lines are removed from history when
+// `options.removeHistoryDuplicates` is `true`
+{
+  const [rli, fi] = getInterface({
+    terminal: true,
+    removeHistoryDuplicates: true
+  });
+  const expectedLines = ['foo', 'bar', 'baz', 'bar', 'bat', 'bat'];
+  // ['foo', 'baz', 'bar', bat'];
+  let callCount = 0;
+  rli.on('line', (line) => {
+    assert.strictEqual(line, expectedLines[callCount]);
+    callCount++;
   });
-  assert.strictEqual(rli.crlfDelay, 100.5);
+  fi.emit('data', `${expectedLines.join('\n')}\n`);
+  assert.strictEqual(callCount, expectedLines.length);
+  fi.emit('keypress', '.', { name: 'up' }); // 'bat'
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  fi.emit('keypress', '.', { name: 'up' }); // 'bar'
+  assert.notStrictEqual(rli.line, expectedLines[--callCount]);
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  fi.emit('keypress', '.', { name: 'up' }); // 'baz'
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  fi.emit('keypress', '.', { name: 'up' }); // 'foo'
+  assert.notStrictEqual(rli.line, expectedLines[--callCount]);
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  assert.strictEqual(callCount, 0);
+  fi.emit('keypress', '.', { name: 'down' }); // 'baz'
+  assert.strictEqual(rli.line, 'baz');
+  assert.strictEqual(rli.historyIndex, 2);
+  fi.emit('keypress', '.', { name: 'n', ctrl: true }); // 'bar'
+  assert.strictEqual(rli.line, 'bar');
+  assert.strictEqual(rli.historyIndex, 1);
+  fi.emit('keypress', '.', { name: 'n', ctrl: true });
+  assert.strictEqual(rli.line, 'bat');
+  assert.strictEqual(rli.historyIndex, 0);
+  // Activate the substring history search.
+  fi.emit('keypress', '.', { name: 'down' }); // 'bat'
+  assert.strictEqual(rli.line, 'bat');
+  assert.strictEqual(rli.historyIndex, -1);
+  // Deactivate substring history search.
+  fi.emit('keypress', '.', { name: 'backspace' }); // 'ba'
+  assert.strictEqual(rli.historyIndex, -1);
+  assert.strictEqual(rli.line, 'ba');
+  // Activate the substring history search.
+  fi.emit('keypress', '.', { name: 'down' }); // 'ba'
+  assert.strictEqual(rli.historyIndex, -1);
+  assert.strictEqual(rli.line, 'ba');
+  fi.emit('keypress', '.', { name: 'down' }); // 'ba'
+  assert.strictEqual(rli.historyIndex, -1);
+  assert.strictEqual(rli.line, 'ba');
+  fi.emit('keypress', '.', { name: 'up' }); // 'bat'
+  assert.strictEqual(rli.historyIndex, 0);
+  assert.strictEqual(rli.line, 'bat');
+  fi.emit('keypress', '.', { name: 'up' }); // 'bar'
+  assert.strictEqual(rli.historyIndex, 1);
+  assert.strictEqual(rli.line, 'bar');
+  fi.emit('keypress', '.', { name: 'up' }); // 'baz'
+  assert.strictEqual(rli.historyIndex, 2);
+  assert.strictEqual(rli.line, 'baz');
+  fi.emit('keypress', '.', { name: 'up' }); // 'ba'
+  assert.strictEqual(rli.historyIndex, 4);
+  assert.strictEqual(rli.line, 'ba');
+  fi.emit('keypress', '.', { name: 'up' }); // 'ba'
+  assert.strictEqual(rli.historyIndex, 4);
+  assert.strictEqual(rli.line, 'ba');
+  // Deactivate substring history search and reset history index.
+  fi.emit('keypress', '.', { name: 'right' }); // 'ba'
+  assert.strictEqual(rli.historyIndex, -1);
+  assert.strictEqual(rli.line, 'ba');
+  // Substring history search activated.
+  fi.emit('keypress', '.', { name: 'up' }); // 'ba'
+  assert.strictEqual(rli.historyIndex, 0);
+  assert.strictEqual(rli.line, 'bat');
   rli.close();
 }
 
+// Duplicate lines are not removed from history when
+// `options.removeHistoryDuplicates` is `false`
 {
-  // Set crlfDelay to 5000ms
-  const fi = new FakeInput();
-  const rli = new readline.Interface({
-    input: fi,
-    output: fi,
-    crlfDelay: 5000
+  const [rli, fi] = getInterface({
+    terminal: true,
+    removeHistoryDuplicates: false
+  });
+  const expectedLines = ['foo', 'bar', 'baz', 'bar', 'bat', 'bat'];
+  let callCount = 0;
+  rli.on('line', (line) => {
+    assert.strictEqual(line, expectedLines[callCount]);
+    callCount++;
   });
-  assert.strictEqual(rli.crlfDelay, 5000);
+  fi.emit('data', `${expectedLines.join('\n')}\n`);
+  assert.strictEqual(callCount, expectedLines.length);
+  fi.emit('keypress', '.', { name: 'up' }); // 'bat'
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  fi.emit('keypress', '.', { name: 'up' }); // 'bar'
+  assert.notStrictEqual(rli.line, expectedLines[--callCount]);
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  fi.emit('keypress', '.', { name: 'up' }); // 'baz'
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  fi.emit('keypress', '.', { name: 'up' }); // 'bar'
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  fi.emit('keypress', '.', { name: 'up' }); // 'foo'
+  assert.strictEqual(rli.line, expectedLines[--callCount]);
+  assert.strictEqual(callCount, 0);
   rli.close();
 }
 
-[ true, false ].forEach(function(terminal) {
-  // disable history
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal, historySize: 0 }
-    );
-    assert.strictEqual(rli.historySize, 0);
+// Regression test for repl freeze, #1968:
+// check that nothing fails if 'keypress' event throws.
+{
+  const [rli, fi] = getInterface({ terminal: true });
+  const keys = [];
+  const err = new Error('bad thing happened');
+  fi.on('keypress', (key) => {
+    keys.push(key);
+    if (key === 'X') {
+      throw err;
+    }
+  });
+  assert.throws(
+    () => fi.emit('data', 'fooX'),
+    (e) => {
+      assert.strictEqual(e, err);
+      return true;
+    }
+  );
+  fi.emit('data', 'bar');
+  assert.strictEqual(keys.join(''), 'fooXbar');
+  rli.close();
+}
 
-    fi.emit('data', 'asdf\n');
-    assert.deepStrictEqual(rli.history, terminal ? [] : undefined);
-    rli.close();
-  }
+// History is bound
+{
+  const [rli, fi] = getInterface({ terminal: true, historySize: 2 });
+  const lines = ['line 1', 'line 2', 'line 3'];
+  fi.emit('data', lines.join('\n') + '\n');
+  assert.strictEqual(rli.history.length, 2);
+  assert.strictEqual(rli.history[0], 'line 3');
+  assert.strictEqual(rli.history[1], 'line 2');
+}
 
-  // Default history size 30
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    assert.strictEqual(rli.historySize, 30);
+// Question
+{
+  const [rli] = getInterface({ terminal: true });
+  const expectedLines = ['foo'];
+  rli.question(expectedLines[0], () => rli.close());
+  assertCursorRowsAndCols(rli, 0, expectedLines[0].length);
+  rli.close();
+}
 
-    fi.emit('data', 'asdf\n');
-    assert.deepStrictEqual(rli.history, terminal ? ['asdf'] : undefined);
-    rli.close();
-  }
+// Sending a multi-line question
+{
+  const [rli] = getInterface({ terminal: true });
+  const expectedLines = ['foo', 'bar'];
+  rli.question(expectedLines.join('\n'), () => rli.close());
+  assertCursorRowsAndCols(
+    rli, expectedLines.length - 1, expectedLines.slice(-1)[0].length);
+  rli.close();
+}
 
-  // sending a full line
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    let called = false;
-    rli.on('line', function(line) {
-      called = true;
-      assert.strictEqual(line, 'asdf');
-    });
-    fi.emit('data', 'asdf\n');
-    assert.ok(called);
-  }
+{
+  // Beginning and end of line
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  fi.emit('keypress', '.', { ctrl: true, name: 'a' });
+  assertCursorRowsAndCols(rli, 0, 0);
+  fi.emit('keypress', '.', { ctrl: true, name: 'e' });
+  assertCursorRowsAndCols(rli, 0, 19);
+  rli.close();
+}
 
-  // Sending a blank line
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    let called = false;
-    rli.on('line', function(line) {
-      called = true;
-      assert.strictEqual(line, '');
-    });
-    fi.emit('data', '\n');
-    assert.ok(called);
-  }
+{
+  // Back and Forward one character
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  assertCursorRowsAndCols(rli, 0, 19);
+
+  // Back one character
+  fi.emit('keypress', '.', { ctrl: true, name: 'b' });
+  assertCursorRowsAndCols(rli, 0, 18);
+  // Back one character
+  fi.emit('keypress', '.', { ctrl: true, name: 'b' });
+  assertCursorRowsAndCols(rli, 0, 17);
+  // Forward one character
+  fi.emit('keypress', '.', { ctrl: true, name: 'f' });
+  assertCursorRowsAndCols(rli, 0, 18);
+  // Forward one character
+  fi.emit('keypress', '.', { ctrl: true, name: 'f' });
+  assertCursorRowsAndCols(rli, 0, 19);
+  rli.close();
+}
 
-  // Sending a single character with no newline
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(fi, {});
-    let called = false;
-    rli.on('line', function(line) {
-      called = true;
-    });
-    fi.emit('data', 'a');
-    assert.ok(!called);
-    rli.close();
-  }
+// Back and Forward one astral character
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', '💻');
 
-  // Sending a single character with no newline and then a newline
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    let called = false;
-    rli.on('line', function(line) {
-      called = true;
-      assert.strictEqual(line, 'a');
-    });
-    fi.emit('data', 'a');
-    assert.ok(!called);
-    fi.emit('data', '\n');
-    assert.ok(called);
-    rli.close();
-  }
+  // Move left one character/code point
+  fi.emit('keypress', '.', { name: 'left' });
+  assertCursorRowsAndCols(rli, 0, 0);
 
-  // Sending multiple newlines at once
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    const expectedLines = ['foo', 'bar', 'baz'];
-    let callCount = 0;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, expectedLines[callCount]);
-      callCount++;
-    });
-    fi.emit('data', `${expectedLines.join('\n')}\n`);
-    assert.strictEqual(callCount, expectedLines.length);
-    rli.close();
-  }
+  // Move right one character/code point
+  fi.emit('keypress', '.', { name: 'right' });
+  assertCursorRowsAndCols(rli, 0, 2);
 
-  // Sending multiple newlines at once that does not end with a new line
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    const expectedLines = ['foo', 'bar', 'baz', 'bat'];
-    let callCount = 0;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, expectedLines[callCount]);
-      callCount++;
-    });
-    fi.emit('data', expectedLines.join('\n'));
-    assert.strictEqual(callCount, expectedLines.length - 1);
-    rli.close();
-  }
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '💻');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
 
-  // Sending multiple newlines at once that does not end with a new(empty)
-  // line and a `end` event
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    const expectedLines = ['foo', 'bar', 'baz', ''];
-    let callCount = 0;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, expectedLines[callCount]);
-      callCount++;
-    });
-    rli.on('close', function() {
-      callCount++;
-    });
-    fi.emit('data', expectedLines.join('\n'));
-    fi.emit('end');
-    assert.strictEqual(callCount, expectedLines.length);
-    rli.close();
-  }
+// Two astral characters left
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', '💻');
 
-  // Sending multiple newlines at once that does not end with a new line
-  // and a `end` event(last line is)
+  // Move left one character/code point
+  fi.emit('keypress', '.', { name: 'left' });
+  assertCursorRowsAndCols(rli, 0, 0);
 
-  // \r should behave like \n when alone
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: true }
-    );
-    const expectedLines = ['foo', 'bar', 'baz', 'bat'];
-    let callCount = 0;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, expectedLines[callCount]);
-      callCount++;
-    });
-    fi.emit('data', expectedLines.join('\r'));
-    assert.strictEqual(callCount, expectedLines.length - 1);
-    rli.close();
-  }
+  fi.emit('data', '🐕');
+  assertCursorRowsAndCols(rli, 0, 2);
+
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '🐕💻');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// Two astral characters right
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', '💻');
+
+  // Move left one character/code point
+  fi.emit('keypress', '.', { name: 'right' });
+  assertCursorRowsAndCols(rli, 0, 2);
+
+  fi.emit('data', '🐕');
+  assertCursorRowsAndCols(rli, 0, 4);
+
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '💻🐕');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+{
+  // `wordLeft` and `wordRight`
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  fi.emit('keypress', '.', { ctrl: true, name: 'left' });
+  assertCursorRowsAndCols(rli, 0, 16);
+  fi.emit('keypress', '.', { meta: true, name: 'b' });
+  assertCursorRowsAndCols(rli, 0, 10);
+  fi.emit('keypress', '.', { ctrl: true, name: 'right' });
+  assertCursorRowsAndCols(rli, 0, 16);
+  fi.emit('keypress', '.', { meta: true, name: 'f' });
+  assertCursorRowsAndCols(rli, 0, 19);
+  rli.close();
+}
+
+// `deleteWordLeft`
+[
+  { ctrl: true, name: 'w' },
+  { ctrl: true, name: 'backspace' },
+  { meta: true, name: 'backspace' },
+].forEach((deleteWordLeftKey) => {
+  let [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  fi.emit('keypress', '.', { ctrl: true, name: 'left' });
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, 'the quick fox');
+  }));
+  fi.emit('keypress', '.', deleteWordLeftKey);
+  fi.emit('data', '\n');
+  rli.close();
+
+  // No effect if pressed at beginning of line
+  [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  fi.emit('keypress', '.', { ctrl: true, name: 'a' });
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, 'the quick brown fox');
+  }));
+  fi.emit('keypress', '.', deleteWordLeftKey);
+  fi.emit('data', '\n');
+  rli.close();
+});
+
+// `deleteWordRight`
+[
+  { ctrl: true, name: 'delete' },
+  { meta: true, name: 'delete' },
+  { meta: true, name: 'd' },
+].forEach((deleteWordRightKey) => {
+  let [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  fi.emit('keypress', '.', { ctrl: true, name: 'left' });
+  fi.emit('keypress', '.', { ctrl: true, name: 'left' });
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, 'the quick fox');
+  }));
+  fi.emit('keypress', '.', deleteWordRightKey);
+  fi.emit('data', '\n');
+  rli.close();
+
+  // No effect if pressed at end of line
+  [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, 'the quick brown fox');
+  }));
+  fi.emit('keypress', '.', deleteWordRightKey);
+  fi.emit('data', '\n');
+  rli.close();
+});
+
+// deleteLeft
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  assertCursorRowsAndCols(rli, 0, 19);
+
+  // Delete left character
+  fi.emit('keypress', '.', { ctrl: true, name: 'h' });
+  assertCursorRowsAndCols(rli, 0, 18);
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, 'the quick brown fo');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// deleteLeft astral character
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', '💻');
+  assertCursorRowsAndCols(rli, 0, 2);
+  // Delete left character
+  fi.emit('keypress', '.', { ctrl: true, name: 'h' });
+  assertCursorRowsAndCols(rli, 0, 0);
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// deleteRight
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+
+  // Go to the start of the line
+  fi.emit('keypress', '.', { ctrl: true, name: 'a' });
+  assertCursorRowsAndCols(rli, 0, 0);
+
+  // Delete right character
+  fi.emit('keypress', '.', { ctrl: true, name: 'd' });
+  assertCursorRowsAndCols(rli, 0, 0);
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, 'he quick brown fox');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// deleteRight astral character
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', '💻');
+
+  // Go to the start of the line
+  fi.emit('keypress', '.', { ctrl: true, name: 'a' });
+  assertCursorRowsAndCols(rli, 0, 0);
+
+  // Delete right character
+  fi.emit('keypress', '.', { ctrl: true, name: 'd' });
+  assertCursorRowsAndCols(rli, 0, 0);
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// deleteLineLeft
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+  assertCursorRowsAndCols(rli, 0, 19);
+
+  // Delete from current to start of line
+  fi.emit('keypress', '.', { ctrl: true, shift: true, name: 'backspace' });
+  assertCursorRowsAndCols(rli, 0, 0);
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// deleteLineRight
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick brown fox');
+
+  // Go to the start of the line
+  fi.emit('keypress', '.', { ctrl: true, name: 'a' });
+  assertCursorRowsAndCols(rli, 0, 0);
+
+  // Delete from current to end of line
+  fi.emit('keypress', '.', { ctrl: true, shift: true, name: 'delete' });
+  assertCursorRowsAndCols(rli, 0, 0);
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, '');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// Close readline interface
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('keypress', '.', { ctrl: true, name: 'c' });
+  assert(rli.closed);
+}
+
+// Multi-line input cursor position
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.columns = 10;
+  fi.emit('data', 'multi-line text');
+  assertCursorRowsAndCols(rli, 1, 5);
+  rli.close();
+}
+
+// Multi-line input cursor position and long tabs
+{
+  const [rli, fi] = getInterface({ tabSize: 16, terminal: true, prompt: '' });
+  fi.columns = 10;
+  fi.emit('data', 'multi-line\ttext \t');
+  assert.strictEqual(rli.cursor, 17);
+  assertCursorRowsAndCols(rli, 3, 2);
+  rli.close();
+}
+
+// Check for the default tab size.
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  fi.emit('data', 'the quick\tbrown\tfox');
+  assert.strictEqual(rli.cursor, 19);
+  // The first tab is 7 spaces long, the second one 3 spaces.
+  assertCursorRowsAndCols(rli, 0, 27);
+}
+
+// Multi-line prompt cursor position
+{
+  const [rli, fi] = getInterface({
+    terminal: true,
+    prompt: '\nfilledline\nwraping text\n> '
+  });
+  fi.columns = 10;
+  fi.emit('data', 't');
+  assertCursorRowsAndCols(rli, 4, 3);
+  rli.close();
+}
+
+// Clear the whole screen
+{
+  const [rli, fi] = getInterface({ terminal: true, prompt: '' });
+  const lines = ['line 1', 'line 2', 'line 3'];
+  fi.emit('data', lines.join('\n'));
+  fi.emit('keypress', '.', { ctrl: true, name: 'l' });
+  assertCursorRowsAndCols(rli, 0, 6);
+  rli.on('line', common.mustCall((line) => {
+    assert.strictEqual(line, 'line 3');
+  }));
+  fi.emit('data', '\n');
+  rli.close();
+}
+
+// Wide characters should be treated as two columns.
+assert.strictEqual(getStringWidth('a'), 1);
+assert.strictEqual(getStringWidth('あ'), 2);
+assert.strictEqual(getStringWidth('谢'), 2);
+assert.strictEqual(getStringWidth('고'), 2);
+assert.strictEqual(getStringWidth(String.fromCodePoint(0x1f251)), 2);
+assert.strictEqual(getStringWidth('abcde'), 5);
+assert.strictEqual(getStringWidth('古池や'), 6);
+assert.strictEqual(getStringWidth('ノード.js'), 9);
+assert.strictEqual(getStringWidth('你好'), 4);
+assert.strictEqual(getStringWidth('안녕하세요'), 10);
+assert.strictEqual(getStringWidth('A\ud83c\ude00BC'), 5);
+assert.strictEqual(getStringWidth('👨‍👩‍👦‍👦'), 8);
+assert.strictEqual(getStringWidth('🐕𐐷あ💻😀'), 9);
+// TODO(BridgeAR): This should have a width of 4.
+assert.strictEqual(getStringWidth('⓬⓪'), 2);
+assert.strictEqual(getStringWidth('\u0301\u200D\u200E'), 0);
+
+// Check if vt control chars are stripped
+assert.strictEqual(stripVTControlCharacters('\u001b[31m> \u001b[39m'), '> ');
+assert.strictEqual(
+  stripVTControlCharacters('\u001b[31m> \u001b[39m> '),
+  '> > '
+);
+assert.strictEqual(stripVTControlCharacters('\u001b[31m\u001b[39m'), '');
+assert.strictEqual(stripVTControlCharacters('> '), '> ');
+assert.strictEqual(getStringWidth('\u001b[31m> \u001b[39m'), 2);
+assert.strictEqual(getStringWidth('\u001b[31m> \u001b[39m> '), 4);
+assert.strictEqual(getStringWidth('\u001b[31m\u001b[39m'), 0);
+assert.strictEqual(getStringWidth('> '), 2);
+
+// Check EventEmitter memory leak
+for (let i = 0; i < 12; i++) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  rl.close();
+  assert.strictEqual(isWarned(process.stdin._events), false);
+  assert.strictEqual(isWarned(process.stdout._events), false);
+}
 
-  // \r at start of input should output blank line
+[true, false].forEach((terminal) => {
+  // Disable history
   {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: true }
-    );
-    const expectedLines = ['', 'foo' ];
-    let callCount = 0;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, expectedLines[callCount]);
-      callCount++;
-    });
-    fi.emit('data', '\rfoo\r');
-    assert.strictEqual(callCount, expectedLines.length);
+    const [rli, fi] = getInterface({ terminal, historySize: 0 });
+    assert.strictEqual(rli.historySize, 0);
+
+    fi.emit('data', 'asdf\n');
+    assert.deepStrictEqual(rli.history, []);
     rli.close();
   }
 
-  // Emit two line events when the delay
-  // between \r and \n exceeds crlfDelay
+  // Default history size 30
   {
-    const fi = new FakeInput();
-    const delay = 200;
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      terminal: terminal,
-      crlfDelay: delay
-    });
-    let callCount = 0;
-    rli.on('line', function(line) {
-      callCount++;
-    });
-    fi.emit('data', '\r');
-    setTimeout(common.mustCall(() => {
-      fi.emit('data', '\n');
-      assert.strictEqual(callCount, 2);
-      rli.close();
-    }), delay * 2);
+    const [rli, fi] = getInterface({ terminal });
+    assert.strictEqual(rli.historySize, 30);
+
+    fi.emit('data', 'asdf\n');
+    assert.deepStrictEqual(rli.history, terminal ? ['asdf'] : []);
+    rli.close();
   }
 
-  // Set crlfDelay to `Infinity` is allowed
+  // Sending a full line
   {
-    const fi = new FakeInput();
-    const delay = 200;
-    const crlfDelay = Infinity;
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      terminal: terminal,
-      crlfDelay
-    });
-    let callCount = 0;
-    rli.on('line', function(line) {
-      callCount++;
-    });
-    fi.emit('data', '\r');
-    setTimeout(common.mustCall(() => {
-      fi.emit('data', '\n');
-      assert.strictEqual(callCount, 1);
-      rli.close();
-    }), delay);
+    const [rli, fi] = getInterface({ terminal });
+    rli.on('line', common.mustCall((line) => {
+      assert.strictEqual(line, 'asdf');
+    }));
+    fi.emit('data', 'asdf\n');
   }
 
-  // \t when there is no completer function should behave like an ordinary
-  // character
+  // Sending a blank line
   {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: true }
-    );
-    let called = false;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, '\t');
-      assert.strictEqual(called, false);
-      called = true;
-    });
-    fi.emit('data', '\t');
+    const [rli, fi] = getInterface({ terminal });
+    rli.on('line', common.mustCall((line) => {
+      assert.strictEqual(line, '');
+    }));
     fi.emit('data', '\n');
-    assert.ok(called);
-    rli.close();
   }
 
-  // \t does not become part of the input when there is a completer function
+  // Sending a single character with no newline and then a newline
   {
-    const fi = new FakeInput();
-    const completer = (line) => [[], line];
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      terminal: true,
-      completer: completer
-    });
+    const [rli, fi] = getInterface({ terminal });
     let called = false;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, 'foo');
-      assert.strictEqual(called, false);
+    rli.on('line', (line) => {
       called = true;
+      assert.strictEqual(line, 'a');
     });
-    for (const character of '\tfo\to\t') {
-      fi.emit('data', character);
-    }
-    fi.emit('data', '\n');
-    assert.ok(called);
-    rli.close();
-  }
-
-  // Constructor throws if completer is not a function or undefined
-  {
-    const fi = new FakeInput();
-    assert.throws(() => {
-      readline.createInterface({
-        input: fi,
-        completer: 'string is not valid'
-      });
-    }, {
-      name: 'TypeError',
-      code: 'ERR_INVALID_OPT_VALUE'
-    });
-  }
-
-  // Constructor throws if historySize is not a positive number
-  {
-    const fi = new FakeInput();
-    assert.throws(() => {
-      readline.createInterface({
-        input: fi, historySize: 'not a number'
-      });
-    }, {
-      name: 'RangeError',
-      code: 'ERR_INVALID_OPT_VALUE'
-    });
-
-    assert.throws(() => {
-      readline.createInterface({
-        input: fi, historySize: -1
-      });
-    }, {
-      name: 'RangeError',
-      code: 'ERR_INVALID_OPT_VALUE'
-    });
-
-    assert.throws(() => {
-      readline.createInterface({
-        input: fi, historySize: NaN
-      });
-    }, {
-      name: 'RangeError',
-      code: 'ERR_INVALID_OPT_VALUE'
-    });
+    fi.emit('data', 'a');
+    assert.ok(!called);
+    fi.emit('data', '\n');
+    assert.ok(called);
+    rli.close();
   }
 
-  // Duplicate lines are removed from history when
-  // `options.removeHistoryDuplicates` is `true`
+  // Sending multiple newlines at once
   {
-    const fi = new FakeInput();
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      terminal: true,
-      removeHistoryDuplicates: true
-    });
-    const expectedLines = ['foo', 'bar', 'baz', 'bar', 'bat', 'bat'];
-    // ['foo', 'baz', 'bar', bat'];
-    let callCount = 0;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, expectedLines[callCount]);
-      callCount++;
-    });
+    const [rli, fi] = getInterface({ terminal });
+    const expectedLines = ['foo', 'bar', 'baz'];
+    rli.on('line', common.mustCall((line) => {
+      assert.strictEqual(line, expectedLines.shift());
+    }, expectedLines.length));
     fi.emit('data', `${expectedLines.join('\n')}\n`);
-    assert.strictEqual(callCount, expectedLines.length);
-    fi.emit('keypress', '.', { name: 'up' }); // 'bat'
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    fi.emit('keypress', '.', { name: 'up' }); // 'bar'
-    assert.notStrictEqual(rli.line, expectedLines[--callCount]);
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    fi.emit('keypress', '.', { name: 'up' }); // 'baz'
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    fi.emit('keypress', '.', { name: 'up' }); // 'foo'
-    assert.notStrictEqual(rli.line, expectedLines[--callCount]);
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    assert.strictEqual(callCount, 0);
-    fi.emit('keypress', '.', { name: 'down' }); // 'baz'
-    assert.strictEqual(rli.line, 'baz');
-    assert.strictEqual(rli.historyIndex, 2);
-    fi.emit('keypress', '.', { name: 'n', ctrl: true }); // 'bar'
-    assert.strictEqual(rli.line, 'bar');
-    assert.strictEqual(rli.historyIndex, 1);
-    fi.emit('keypress', '.', { name: 'n', ctrl: true });
-    assert.strictEqual(rli.line, 'bat');
-    assert.strictEqual(rli.historyIndex, 0);
-    // Activate the substring history search.
-    fi.emit('keypress', '.', { name: 'down' }); // 'bat'
-    assert.strictEqual(rli.line, 'bat');
-    assert.strictEqual(rli.historyIndex, -1);
-    // Deactivate substring history search.
-    fi.emit('keypress', '.', { name: 'backspace' }); // 'ba'
-    assert.strictEqual(rli.historyIndex, -1);
-    assert.strictEqual(rli.line, 'ba');
-    // Activate the substring history search.
-    fi.emit('keypress', '.', { name: 'down' }); // 'ba'
-    assert.strictEqual(rli.historyIndex, -1);
-    assert.strictEqual(rli.line, 'ba');
-    fi.emit('keypress', '.', { name: 'down' }); // 'ba'
-    assert.strictEqual(rli.historyIndex, -1);
-    assert.strictEqual(rli.line, 'ba');
-    fi.emit('keypress', '.', { name: 'up' }); // 'bat'
-    assert.strictEqual(rli.historyIndex, 0);
-    assert.strictEqual(rli.line, 'bat');
-    fi.emit('keypress', '.', { name: 'up' }); // 'bar'
-    assert.strictEqual(rli.historyIndex, 1);
-    assert.strictEqual(rli.line, 'bar');
-    fi.emit('keypress', '.', { name: 'up' }); // 'baz'
-    assert.strictEqual(rli.historyIndex, 2);
-    assert.strictEqual(rli.line, 'baz');
-    fi.emit('keypress', '.', { name: 'up' }); // 'ba'
-    assert.strictEqual(rli.historyIndex, 4);
-    assert.strictEqual(rli.line, 'ba');
-    fi.emit('keypress', '.', { name: 'up' }); // 'ba'
-    assert.strictEqual(rli.historyIndex, 4);
-    assert.strictEqual(rli.line, 'ba');
-    // Deactivate substring history search and reset history index.
-    fi.emit('keypress', '.', { name: 'right' }); // 'ba'
-    assert.strictEqual(rli.historyIndex, -1);
-    assert.strictEqual(rli.line, 'ba');
-    // Substring history search activated.
-    fi.emit('keypress', '.', { name: 'up' }); // 'ba'
-    assert.strictEqual(rli.historyIndex, 0);
-    assert.strictEqual(rli.line, 'bat');
     rli.close();
   }
 
-  // Duplicate lines are not removed from history when
-  // `options.removeHistoryDuplicates` is `false`
+  // Sending multiple newlines at once that does not end with a new line
+  {
+    const [rli, fi] = getInterface({ terminal });
+    const expectedLines = ['foo', 'bar', 'baz', 'bat'];
+    rli.on('line', common.mustCall((line) => {
+      assert.strictEqual(line, expectedLines.shift());
+    }, expectedLines.length - 1));
+    fi.emit('data', expectedLines.join('\n'));
+    rli.close();
+  }
+
+  // Sending multiple newlines at once that does not end with a new(empty)
+  // line and a `end` event
   {
-    const fi = new FakeInput();
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      terminal: true,
-      removeHistoryDuplicates: false
-    });
-    const expectedLines = ['foo', 'bar', 'baz', 'bar', 'bat', 'bat'];
-    let callCount = 0;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, expectedLines[callCount]);
-      callCount++;
-    });
-    fi.emit('data', `${expectedLines.join('\n')}\n`);
-    assert.strictEqual(callCount, expectedLines.length);
-    fi.emit('keypress', '.', { name: 'up' }); // 'bat'
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    fi.emit('keypress', '.', { name: 'up' }); // 'bar'
-    assert.notStrictEqual(rli.line, expectedLines[--callCount]);
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    fi.emit('keypress', '.', { name: 'up' }); // 'baz'
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    fi.emit('keypress', '.', { name: 'up' }); // 'bar'
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    fi.emit('keypress', '.', { name: 'up' }); // 'foo'
-    assert.strictEqual(rli.line, expectedLines[--callCount]);
-    assert.strictEqual(callCount, 0);
+    const [rli, fi] = getInterface({ terminal });
+    const expectedLines = ['foo', 'bar', 'baz', ''];
+    rli.on('line', common.mustCall((line) => {
+      assert.strictEqual(line, expectedLines.shift());
+    }, expectedLines.length - 1));
+    rli.on('close', common.mustCall());
+    fi.emit('data', expectedLines.join('\n'));
+    fi.emit('end');
     rli.close();
   }
 
   // Sending a multi-byte utf8 char over multiple writes
   {
     const buf = Buffer.from('☮', 'utf8');
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const [rli, fi] = getInterface({ terminal });
     let callCount = 0;
-    rli.on('line', function(line) {
+    rli.on('line', (line) => {
       callCount++;
       assert.strictEqual(line, buf.toString('utf8'));
     });
-    [].forEach.call(buf, function(i) {
+    for (const i of buf) {
       fi.emit('data', Buffer.from([i]));
-    });
+    }
     assert.strictEqual(callCount, 0);
     fi.emit('data', '\n');
     assert.strictEqual(callCount, 1);
     rli.close();
   }
 
-  // Regression test for repl freeze, #1968:
-  // check that nothing fails if 'keypress' event throws.
-  {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: true }
-    );
-    const keys = [];
-    const err = new Error('bad thing happened');
-    fi.on('keypress', function(key) {
-      keys.push(key);
-      if (key === 'X') {
-        throw err;
-      }
-    });
-    assert.throws(
-      () => fi.emit('data', 'fooX'),
-      (e) => {
-        assert.strictEqual(e, err);
-        return true;
-      }
-    );
-    fi.emit('data', 'bar');
-    assert.strictEqual(keys.join(''), 'fooXbar');
-    rli.close();
-  }
-
   // Calling readline without `new`
   {
-    const fi = new FakeInput();
-    const rli = readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    let called = false;
-    rli.on('line', function(line) {
-      called = true;
+    const [rli, fi] = getInterface({ terminal });
+    rli.on('line', common.mustCall((line) => {
       assert.strictEqual(line, 'asdf');
-    });
+    }));
     fi.emit('data', 'asdf\n');
-    assert.ok(called);
     rli.close();
   }
 
   // Calling the question callback
   {
-    let called = false;
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
-    rli.question('foo?', function(answer) {
-      called = true;
+    const [rli] = getInterface({ terminal });
+    rli.question('foo?', common.mustCall((answer) => {
       assert.strictEqual(answer, 'bar');
-    });
+    }));
     rli.write('bar\n');
-    assert.ok(called);
     rli.close();
   }
 
-  if (terminal) {
-    // history is bound
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface(
-        { input: fi, output: fi, terminal, historySize: 2 }
-      );
-      const lines = ['line 1', 'line 2', 'line 3'];
-      fi.emit('data', lines.join('\n') + '\n');
-      assert.strictEqual(rli.history.length, 2);
-      assert.strictEqual(rli.history[0], 'line 3');
-      assert.strictEqual(rli.history[1], 'line 2');
-    }
-    // question
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface(
-        { input: fi, output: fi, terminal: terminal }
-      );
-      const expectedLines = ['foo'];
-      rli.question(expectedLines[0], function() {
-        rli.close();
-      });
-      const cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, expectedLines[0].length);
-      rli.close();
-    }
-
-    // Sending a multi-line question
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface(
-        { input: fi, output: fi, terminal: terminal }
-      );
-      const expectedLines = ['foo', 'bar'];
-      rli.question(expectedLines.join('\n'), function() {
-        rli.close();
-      });
-      const cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, expectedLines.length - 1);
-      assert.strictEqual(cursorPos.cols, expectedLines.slice(-1)[0].length);
-      rli.close();
-    }
-
-    {
-      // Beginning and end of line
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', 'the quick brown fox');
-      fi.emit('keypress', '.', { ctrl: true, name: 'a' });
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-      fi.emit('keypress', '.', { ctrl: true, name: 'e' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 19);
-      rli.close();
-    }
-
-    {
-      // Back and Forward one character
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', 'the quick brown fox');
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 19);
-
-      // Back one character
-      fi.emit('keypress', '.', { ctrl: true, name: 'b' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 18);
-      // Back one character
-      fi.emit('keypress', '.', { ctrl: true, name: 'b' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 17);
-      // Forward one character
-      fi.emit('keypress', '.', { ctrl: true, name: 'f' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 18);
-      // Forward one character
-      fi.emit('keypress', '.', { ctrl: true, name: 'f' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 19);
-      rli.close();
-    }
-
-    // Back and Forward one astral character
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', '💻');
-
-      // Move left one character/code point
-      fi.emit('keypress', '.', { name: 'left' });
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-
-      // Move right one character/code point
-      fi.emit('keypress', '.', { name: 'right' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 2);
-
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '💻');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    // Two astral characters left
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', '💻');
-
-      // Move left one character/code point
-      fi.emit('keypress', '.', { name: 'left' });
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-
-      fi.emit('data', '🐕');
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 2);
-
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '🐕💻');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    // Two astral characters right
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', '💻');
-
-      // Move left one character/code point
-      fi.emit('keypress', '.', { name: 'right' });
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 2);
-
-      fi.emit('data', '🐕');
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 4);
-
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '💻🐕');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    {
-      // `wordLeft` and `wordRight`
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', 'the quick brown fox');
-      fi.emit('keypress', '.', { ctrl: true, name: 'left' });
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 16);
-      fi.emit('keypress', '.', { meta: true, name: 'b' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 10);
-      fi.emit('keypress', '.', { ctrl: true, name: 'right' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 16);
-      fi.emit('keypress', '.', { meta: true, name: 'f' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 19);
-      rli.close();
-    }
-
-    {
-      // `deleteWordLeft`
-      [
-        { ctrl: true, name: 'w' },
-        { ctrl: true, name: 'backspace' },
-        { meta: true, name: 'backspace' }
-      ]
-        .forEach((deleteWordLeftKey) => {
-          let fi = new FakeInput();
-          let rli = new readline.Interface({
-            input: fi,
-            output: fi,
-            prompt: '',
-            terminal: terminal
-          });
-          fi.emit('data', 'the quick brown fox');
-          fi.emit('keypress', '.', { ctrl: true, name: 'left' });
-          rli.on('line', common.mustCall((line) => {
-            assert.strictEqual(line, 'the quick fox');
-          }));
-          fi.emit('keypress', '.', deleteWordLeftKey);
-          fi.emit('data', '\n');
-          rli.close();
-
-          // No effect if pressed at beginning of line
-          fi = new FakeInput();
-          rli = new readline.Interface({
-            input: fi,
-            output: fi,
-            prompt: '',
-            terminal: terminal
-          });
-          fi.emit('data', 'the quick brown fox');
-          fi.emit('keypress', '.', { ctrl: true, name: 'a' });
-          rli.on('line', common.mustCall((line) => {
-            assert.strictEqual(line, 'the quick brown fox');
-          }));
-          fi.emit('keypress', '.', deleteWordLeftKey);
-          fi.emit('data', '\n');
-          rli.close();
-        });
-    }
-
-    {
-      // `deleteWordRight`
-      [
-        { ctrl: true, name: 'delete' },
-        { meta: true, name: 'delete' },
-        { meta: true, name: 'd' }
-      ]
-        .forEach((deleteWordRightKey) => {
-          let fi = new FakeInput();
-          let rli = new readline.Interface({
-            input: fi,
-            output: fi,
-            prompt: '',
-            terminal: terminal
-          });
-          fi.emit('data', 'the quick brown fox');
-          fi.emit('keypress', '.', { ctrl: true, name: 'left' });
-          fi.emit('keypress', '.', { ctrl: true, name: 'left' });
-          rli.on('line', common.mustCall((line) => {
-            assert.strictEqual(line, 'the quick fox');
-          }));
-          fi.emit('keypress', '.', deleteWordRightKey);
-          fi.emit('data', '\n');
-          rli.close();
-
-          // No effect if pressed at end of line
-          fi = new FakeInput();
-          rli = new readline.Interface({
-            input: fi,
-            output: fi,
-            prompt: '',
-            terminal: terminal
-          });
-          fi.emit('data', 'the quick brown fox');
-          rli.on('line', common.mustCall((line) => {
-            assert.strictEqual(line, 'the quick brown fox');
-          }));
-          fi.emit('keypress', '.', deleteWordRightKey);
-          fi.emit('data', '\n');
-          rli.close();
-        });
-    }
-
-    // deleteLeft
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', 'the quick brown fox');
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 19);
-
-      // Delete left character
-      fi.emit('keypress', '.', { ctrl: true, name: 'h' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 18);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, 'the quick brown fo');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    // deleteLeft astral character
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', '💻');
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 2);
-      // Delete left character
-      fi.emit('keypress', '.', { ctrl: true, name: 'h' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    // deleteRight
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', 'the quick brown fox');
-
-      // Go to the start of the line
-      fi.emit('keypress', '.', { ctrl: true, name: 'a' });
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-
-      // Delete right character
-      fi.emit('keypress', '.', { ctrl: true, name: 'd' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, 'he quick brown fox');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    // deleteRight astral character
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', '💻');
-
-      // Go to the start of the line
-      fi.emit('keypress', '.', { ctrl: true, name: 'a' });
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-
-      // Delete right character
-      fi.emit('keypress', '.', { ctrl: true, name: 'd' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    // deleteLineLeft
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', 'the quick brown fox');
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 19);
-
-      // Delete from current to start of line
-      fi.emit('keypress', '.', { ctrl: true, shift: true, name: 'backspace' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    // deleteLineRight
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.emit('data', 'the quick brown fox');
-
-      // Go to the start of the line
-      fi.emit('keypress', '.', { ctrl: true, name: 'a' });
-      let cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-
-      // Delete from current to end of line
-      fi.emit('keypress', '.', { ctrl: true, shift: true, name: 'delete' });
-      cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 0);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
-
-    // Multi-line input cursor position
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      fi.columns = 10;
-      fi.emit('data', 'multi-line text');
-      const cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 1);
-      assert.strictEqual(cursorPos.cols, 5);
-      rli.close();
-    }
-
-    // Multi-line prompt cursor position
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '\nfilledline\nwraping text\n> ',
-        terminal: terminal
-      });
-      fi.columns = 10;
-      fi.emit('data', 't');
-      const cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 4);
-      assert.strictEqual(cursorPos.cols, 3);
-      rli.close();
-    }
-
-    // Clear the whole screen
-    {
-      const fi = new FakeInput();
-      const rli = new readline.Interface({
-        input: fi,
-        output: fi,
-        prompt: '',
-        terminal: terminal
-      });
-      const lines = ['line 1', 'line 2', 'line 3'];
-      fi.emit('data', lines.join('\n'));
-      fi.emit('keypress', '.', { ctrl: true, name: 'l' });
-      const cursorPos = rli.getCursorPos();
-      assert.strictEqual(cursorPos.rows, 0);
-      assert.strictEqual(cursorPos.cols, 6);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, 'line 3');
-      }));
-      fi.emit('data', '\n');
-      rli.close();
-    }
+  // Calling the question multiple times
+  {
+    const [rli] = getInterface({ terminal });
+    rli.question('foo?', common.mustCall((answer) => {
+      assert.strictEqual(answer, 'baz');
+    }));
+    rli.question('bar?', common.mustNotCall(() => {
+    }));
+    rli.write('baz\n');
+    rli.close();
   }
 
-  // Wide characters should be treated as two columns.
-  assert.strictEqual(getStringWidth('a'), 1);
-  assert.strictEqual(getStringWidth('あ'), 2);
-  assert.strictEqual(getStringWidth('谢'), 2);
-  assert.strictEqual(getStringWidth('고'), 2);
-  assert.strictEqual(getStringWidth(String.fromCodePoint(0x1f251)), 2);
-  assert.strictEqual(getStringWidth('abcde'), 5);
-  assert.strictEqual(getStringWidth('古池や'), 6);
-  assert.strictEqual(getStringWidth('ノード.js'), 9);
-  assert.strictEqual(getStringWidth('你好'), 4);
-  assert.strictEqual(getStringWidth('안녕하세요'), 10);
-  assert.strictEqual(getStringWidth('A\ud83c\ude00BC'), 5);
-  assert.strictEqual(getStringWidth('👨‍👩‍👦‍👦'), 8);
-  assert.strictEqual(getStringWidth('🐕𐐷あ💻😀'), 9);
-  // TODO(BridgeAR): This should have a width of 4.
-  assert.strictEqual(getStringWidth('⓬⓪'), 2);
-  assert.strictEqual(getStringWidth('\u0301\u200D\u200E'), 0);
-
-  // Check if vt control chars are stripped
-  assert.strictEqual(
-    stripVTControlCharacters('\u001b[31m> \u001b[39m'),
-    '> '
-  );
-  assert.strictEqual(
-    stripVTControlCharacters('\u001b[31m> \u001b[39m> '),
-    '> > '
-  );
-  assert.strictEqual(
-    stripVTControlCharacters('\u001b[31m\u001b[39m'),
-    ''
-  );
-  assert.strictEqual(
-    stripVTControlCharacters('> '),
-    '> '
-  );
-  assert.strictEqual(getStringWidth('\u001b[31m> \u001b[39m'), 2);
-  assert.strictEqual(getStringWidth('\u001b[31m> \u001b[39m> '), 4);
-  assert.strictEqual(getStringWidth('\u001b[31m\u001b[39m'), 0);
-  assert.strictEqual(getStringWidth('> '), 2);
+  // Calling the promisified question
+  {
+    const [rli] = getInterface({ terminal });
+    const question = util.promisify(rli.question).bind(rli);
+    question('foo?')
+    .then(common.mustCall((answer) => {
+      assert.strictEqual(answer, 'bar');
+    }));
+    rli.write('bar\n');
+    rli.close();
+  }
 
+  // Aborting a question
   {
-    const fi = new FakeInput();
-    assert.deepStrictEqual(fi.listeners(terminal ? 'keypress' : 'data'), []);
+    const ac = new AbortController();
+    const signal = ac.signal;
+    const [rli] = getInterface({ terminal });
+    rli.on('line', common.mustCall((line) => {
+      assert.strictEqual(line, 'bar');
+    }));
+    rli.question('hello?', { signal }, common.mustNotCall());
+    ac.abort();
+    rli.write('bar\n');
+    rli.close();
   }
 
-  // check EventEmitter memory leak
-  for (let i = 0; i < 12; i++) {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    rl.close();
-    assert.strictEqual(isWarned(process.stdin._events), false);
-    assert.strictEqual(isWarned(process.stdout._events), false);
+  // Aborting a promisified question
+  {
+    const ac = new AbortController();
+    const signal = ac.signal;
+    const [rli] = getInterface({ terminal });
+    const question = util.promisify(rli.question).bind(rli);
+    rli.on('line', common.mustCall((line) => {
+      assert.strictEqual(line, 'bar');
+    }));
+    question('hello?', { signal })
+    .then(common.mustNotCall())
+    .catch(common.mustCall((error) => {
+      assert.strictEqual(error.name, 'AbortError');
+    }));
+    ac.abort();
+    rli.write('bar\n');
+    rli.close();
   }
 
   // Can create a new readline Interface with a null output argument
   {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: null, terminal: terminal }
-    );
-
-    let called = false;
-    rli.on('line', function(line) {
-      called = true;
+    const [rli, fi] = getInterface({ output: null, terminal });
+    rli.on('line', common.mustCall((line) => {
       assert.strictEqual(line, 'asdf');
-    });
+    }));
     fi.emit('data', 'asdf\n');
-    assert.ok(called);
 
     rli.setPrompt('ddd> ');
     rli.prompt();
-    rli.write('really shouldnt be seeing this');
-    rli.question('What do you think of node.js? ', function(answer) {
+    rli.write("really shouldn't be seeing this");
+    rli.question('What do you think of node.js? ', (answer) => {
       console.log('Thank you for your valuable feedback:', answer);
       rli.close();
     });
   }
 
+  // Calling the getPrompt method
+  {
+    const expectedPrompts = ['$ ', '> '];
+    const [rli] = getInterface({ terminal });
+    for (const prompt of expectedPrompts) {
+      rli.setPrompt(prompt);
+      assert.strictEqual(rli.getPrompt(), prompt);
+    }
+  }
+
   {
     const expected = terminal ?
       ['\u001b[1G', '\u001b[0J', '$ ', '\u001b[3G'] :
       ['$ '];
 
-    let counter = 0;
     const output = new Writable({
       write: common.mustCall((chunk, enc, cb) => {
-        assert.strictEqual(chunk.toString(), expected[counter++]);
+        assert.strictEqual(chunk.toString(), expected.shift());
         cb();
         rl.close();
       }, expected.length)
@@ -1219,83 +1022,95 @@ function isWarned(emitter) {
 
     const rl = readline.createInterface({
       input: new Readable({ read: common.mustCall() }),
-      output: output,
+      output,
       prompt: '$ ',
-      terminal: terminal
+      terminal
     });
 
     rl.prompt();
 
-    assert.strictEqual(rl._prompt, '$ ');
+    assert.strictEqual(rl.getPrompt(), '$ ');
+  }
+
+  {
+    const fi = new FakeInput();
+    assert.deepStrictEqual(fi.listeners(terminal ? 'keypress' : 'data'), []);
   }
-});
 
-// For the purposes of the following tests, we do not care about the exact
-// value of crlfDelay, only that the behaviour conforms to what's expected.
-// Setting it to Infinity allows the test to succeed even under extreme
-// CPU stress.
-const crlfDelay = Infinity;
+  // Emit two line events when the delay
+  // between \r and \n exceeds crlfDelay
+  {
+    const crlfDelay = 200;
+    const [rli, fi] = getInterface({ terminal, crlfDelay });
+    let callCount = 0;
+    rli.on('line', () => {
+      callCount++;
+    });
+    fi.emit('data', '\r');
+    setTimeout(common.mustCall(() => {
+      fi.emit('data', '\n');
+      assert.strictEqual(callCount, 2);
+      rli.close();
+    }), crlfDelay + 10);
+  }
+
+  // For the purposes of the following tests, we do not care about the exact
+  // value of crlfDelay, only that the behaviour conforms to what's expected.
+  // Setting it to Infinity allows the test to succeed even under extreme
+  // CPU stress.
+  const crlfDelay = Infinity;
+
+  // Set crlfDelay to `Infinity` is allowed
+  {
+    const delay = 200;
+    const [rli, fi] = getInterface({ terminal, crlfDelay });
+    let callCount = 0;
+    rli.on('line', () => {
+      callCount++;
+    });
+    fi.emit('data', '\r');
+    setTimeout(common.mustCall(() => {
+      fi.emit('data', '\n');
+      assert.strictEqual(callCount, 1);
+      rli.close();
+    }), delay);
+  }
 
-[ true, false ].forEach(function(terminal) {
   // Sending multiple newlines at once that does not end with a new line
   // and a `end` event(last line is)
 
   // \r\n should emit one line event, not two
   {
-    const fi = new FakeInput();
-    const rli = new readline.Interface(
-      {
-        input: fi,
-        output: fi,
-        terminal: terminal,
-        crlfDelay
-      }
-    );
+    const [rli, fi] = getInterface({ terminal, crlfDelay });
     const expectedLines = ['foo', 'bar', 'baz', 'bat'];
-    let callCount = 0;
-    rli.on('line', function(line) {
-      assert.strictEqual(line, expectedLines[callCount]);
-      callCount++;
-    });
+    rli.on('line', common.mustCall((line) => {
+      assert.strictEqual(line, expectedLines.shift());
+    }, expectedLines.length - 1));
     fi.emit('data', expectedLines.join('\r\n'));
-    assert.strictEqual(callCount, expectedLines.length - 1);
     rli.close();
   }
 
   // \r\n should emit one line event when split across multiple writes.
   {
-    const fi = new FakeInput();
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      terminal: terminal,
-      crlfDelay
-    });
+    const [rli, fi] = getInterface({ terminal, crlfDelay });
     const expectedLines = ['foo', 'bar', 'baz', 'bat'];
     let callCount = 0;
-    rli.on('line', function(line) {
+    rli.on('line', common.mustCall((line) => {
       assert.strictEqual(line, expectedLines[callCount]);
       callCount++;
-    });
-    expectedLines.forEach(function(line) {
+    }, expectedLines.length));
+    expectedLines.forEach((line) => {
       fi.emit('data', `${line}\r`);
       fi.emit('data', '\n');
     });
-    assert.strictEqual(callCount, expectedLines.length);
     rli.close();
   }
 
   // Emit one line event when the delay between \r and \n is
   // over the default crlfDelay but within the setting value.
   {
-    const fi = new FakeInput();
     const delay = 125;
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      terminal: terminal,
-      crlfDelay
-    });
+    const [rli, fi] = getInterface({ terminal, crlfDelay });
     let callCount = 0;
     rli.on('line', () => callCount++);
     fi.emit('data', '\r');
@@ -1322,10 +1137,65 @@ const crlfDelay = Infinity;
     }),
   });
   const rl = new readline.createInterface({
-    input: input,
-    output: output,
+    input,
+    output,
     terminal: true,
   });
   rl.line = `a${' '.repeat(1e6)}a`;
   rl.cursor = rl.line.length;
 }
+
+{
+  const fi = new FakeInput();
+  const signal = AbortSignal.abort();
+
+  const rl = readline.createInterface({
+    input: fi,
+    output: fi,
+    signal,
+  });
+  rl.on('close', common.mustCall());
+  assert.strictEqual(getEventListeners(signal, 'abort').length, 0);
+}
+
+{
+  const fi = new FakeInput();
+  const ac = new AbortController();
+  const { signal } = ac;
+  const rl = readline.createInterface({
+    input: fi,
+    output: fi,
+    signal,
+  });
+  assert.strictEqual(getEventListeners(signal, 'abort').length, 1);
+  rl.on('close', common.mustCall());
+  ac.abort();
+  assert.strictEqual(getEventListeners(signal, 'abort').length, 0);
+}
+
+{
+  const fi = new FakeInput();
+  const ac = new AbortController();
+  const { signal } = ac;
+  const rl = readline.createInterface({
+    input: fi,
+    output: fi,
+    signal,
+  });
+  assert.strictEqual(getEventListeners(signal, 'abort').length, 1);
+  rl.close();
+  assert.strictEqual(getEventListeners(signal, 'abort').length, 0);
+}
+
+{
+  // Constructor throws if signal is not an abort signal
+  assert.throws(() => {
+    readline.createInterface({
+      input: new FakeInput(),
+      signal: {},
+    });
+  }, {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+}
diff --git a/test/parallel/test-readline-keys.js b/test/parallel/test-readline-keys.js
index f0162ab06b8f386eb83bb04e935e138184049769..8ae0d680d5f039de1fce3049c497fbcb69b94e13 100644
--- a/test/parallel/test-readline-keys.js
+++ b/test/parallel/test-readline-keys.js
@@ -92,10 +92,13 @@ addTest('io.JS', [
 ]);
 
 // Named characters
-addTest('\n\r\t', [
+addTest('\n\r\t\x1b\n\x1b\r\x1b\t', [
   { name: 'enter', sequence: '\n' },
   { name: 'return', sequence: '\r' },
   { name: 'tab', sequence: '\t' },
+  { name: 'enter', sequence: '\x1b\n', meta: true },
+  { name: 'return', sequence: '\x1b\r', meta: true },
+  { name: 'tab', sequence: '\x1b\t', meta: true },
 ]);
 
 // Space and backspace
@@ -132,6 +135,25 @@ addTest('a\x1baA\x1bA', [
   { name: 'a', sequence: '\x1bA', meta: true, shift: true },
 ]);
 
+// xterm/gnome ESC [ letter (with modifiers)
+/* eslint-disable max-len */
+addTest('\x1b[2P\x1b[3P\x1b[4P\x1b[5P\x1b[6P\x1b[7P\x1b[8P\x1b[3Q\x1b[8Q\x1b[3R\x1b[8R\x1b[3S\x1b[8S', [
+  { name: 'f1', sequence: '\x1b[2P', code: '[P', shift: true, meta: false, ctrl: false },
+  { name: 'f1', sequence: '\x1b[3P', code: '[P', shift: false, meta: true, ctrl: false },
+  { name: 'f1', sequence: '\x1b[4P', code: '[P', shift: true, meta: true, ctrl: false },
+  { name: 'f1', sequence: '\x1b[5P', code: '[P', shift: false, meta: false, ctrl: true },
+  { name: 'f1', sequence: '\x1b[6P', code: '[P', shift: true, meta: false, ctrl: true },
+  { name: 'f1', sequence: '\x1b[7P', code: '[P', shift: false, meta: true, ctrl: true },
+  { name: 'f1', sequence: '\x1b[8P', code: '[P', shift: true, meta: true, ctrl: true },
+  { name: 'f2', sequence: '\x1b[3Q', code: '[Q', meta: true },
+  { name: 'f2', sequence: '\x1b[8Q', code: '[Q', shift: true, meta: true, ctrl: true },
+  { name: 'f3', sequence: '\x1b[3R', code: '[R', meta: true },
+  { name: 'f3', sequence: '\x1b[8R', code: '[R', shift: true, meta: true, ctrl: true },
+  { name: 'f4', sequence: '\x1b[3S', code: '[S', meta: true },
+  { name: 'f4', sequence: '\x1b[8S', code: '[S', shift: true, meta: true, ctrl: true },
+]);
+/* eslint-enable max-len */
+
 // xterm/gnome ESC O letter
 addTest('\x1bOP\x1bOQ\x1bOR\x1bOS', [
   { name: 'f1', sequence: '\x1bOP', code: 'OP' },
@@ -310,15 +332,15 @@ addTest('\x1bOa\x1bOb\x1bOc\x1bOd\x1bOe', [
 const runKeyIntervalTests = [
   // Escape character
   addKeyIntervalTest('\x1b', [
-    { name: 'escape', sequence: '\x1b', meta: true }
+    { name: 'escape', sequence: '\x1b', meta: true },
   ]),
   // Chain of escape characters.
   addKeyIntervalTest('\x1b\x1b\x1b\x1b'.split(''), [
     { name: 'escape', sequence: '\x1b', meta: true },
     { name: 'escape', sequence: '\x1b', meta: true },
     { name: 'escape', sequence: '\x1b', meta: true },
-    { name: 'escape', sequence: '\x1b', meta: true }
-  ])
+    { name: 'escape', sequence: '\x1b', meta: true },
+  ]),
 ].reverse().reduce((acc, fn) => fn(acc), () => {});
 
 // Run key interval tests one after another.
diff --git a/test/parallel/test-readline-reopen.js b/test/parallel/test-readline-reopen.js
index dead22d81ac961c04dd3b89c50103a47c407f528..fd305fee3e88c704aeac3c1d95551b4fc65b46b9 100644
--- a/test/parallel/test-readline-reopen.js
+++ b/test/parallel/test-readline-reopen.js
@@ -23,7 +23,7 @@ rl1.on('line', common.mustCall(rl1OnLine));
 // that it doesn’t get lost when closing the readline instance.
 input.write(Buffer.concat([
   Buffer.from('foo\n'),
-  Buffer.from([ 0xe2 ])  // Exactly one third of a ☃ snowman.
+  Buffer.from([ 0xe2 ]),  // Exactly one third of a ☃ snowman.
 ]));
 
 function rl1OnLine(line) {
diff --git a/test/parallel/test-readline-tab-complete.js b/test/parallel/test-readline-tab-complete.js
index e8871863402cb1374d18da2ddad3c92d41f055be..be993911c6fe1605798f34e4ef7328d46afc98f3 100644
--- a/test/parallel/test-readline-tab-complete.js
+++ b/test/parallel/test-readline-tab-complete.js
@@ -15,7 +15,7 @@ common.skipIfDumbTerminal();
 [
   'あ',
   '𐐷',
-  '🐕'
+  '🐕',
 ].forEach((char) => {
   [true, false].forEach((lineBreak) => {
     const completer = (line) => [
@@ -24,22 +24,22 @@ common.skipIfDumbTerminal();
         '',
         `${char}${'a'.repeat(10)}`, `${char}${'b'.repeat(10)}`, char.repeat(11),
       ],
-      line
+      line,
     ];
 
     let output = '';
     const width = getStringWidth(char) - 1;
 
     class FakeInput extends EventEmitter {
-    columns = ((width + 1) * 10 + (lineBreak ? 0 : 10)) * 3
+      columns = ((width + 1) * 10 + (lineBreak ? 0 : 10)) * 3
 
-    write = common.mustCall((data) => {
-      output += data;
-    }, 6)
+      write = common.mustCall((data) => {
+        output += data;
+      }, 6)
 
-    resume() {}
-    pause() {}
-    end() {}
+      resume() {}
+      pause() {}
+      end() {}
     }
 
     const fi = new FakeInput();
@@ -47,7 +47,7 @@ common.skipIfDumbTerminal();
       input: fi,
       output: fi,
       terminal: true,
-      completer: completer
+      completer: common.mustCallAtLeast(completer),
     });
 
     const last = '\r\nFirst group\r\n\r\n' +
@@ -68,3 +68,71 @@ common.skipIfDumbTerminal();
     rli.close();
   });
 });
+
+{
+  let output = '';
+  class FakeInput extends EventEmitter {
+    columns = 80
+
+    write = common.mustCall((data) => {
+      output += data;
+    }, 1)
+
+    resume() {}
+    pause() {}
+    end() {}
+  }
+
+  const fi = new FakeInput();
+  const rli = new readline.Interface({
+    input: fi,
+    output: fi,
+    terminal: true,
+    completer:
+        common.mustCallAtLeast((_, cb) => cb(new Error('message'))),
+  });
+
+  rli.on('line', common.mustNotCall());
+  fi.emit('data', '\t');
+  queueMicrotask(() => {
+    assert.match(output, /^Tab completion error: Error: message/);
+    output = '';
+  });
+  rli.close();
+}
+
+{
+  let output = '';
+  class FakeInput extends EventEmitter {
+    columns = 80
+
+    write = common.mustCall((data) => {
+      output += data;
+    }, 9)
+
+    resume() {}
+    pause() {}
+    end() {}
+  }
+
+  const fi = new FakeInput();
+  const rli = new readline.Interface({
+    input: fi,
+    output: fi,
+    terminal: true,
+    completer: common.mustCall((input, cb) => {
+      cb(null, [[input[0].toUpperCase() + input.slice(1)], input]);
+    }),
+  });
+
+  rli.on('line', common.mustNotCall());
+  fi.emit('data', 'input');
+  queueMicrotask(() => {
+    fi.emit('data', '\t');
+    queueMicrotask(() => {
+      assert.match(output, /> Input/);
+      output = '';
+      rli.close();
+    });
+  });
+}
diff --git a/test/parallel/test-readline.js b/test/parallel/test-readline.js
index b336996cd2e53ec71a5c07675b82d6e2b79fb4be..77799fc14cf75f4ed7e3087467863cfa40b3b860 100644
--- a/test/parallel/test-readline.js
+++ b/test/parallel/test-readline.js
@@ -142,7 +142,7 @@ common.skipIfDumbTerminal();
     'hop/zoo',
     '/zoo',
     'zoo',
-    ''
+    '',
   ].forEach(function(expectedLine) {
     rl.write.apply(rl, key.xterm.metad);
     assert.strictEqual(rl.cursor, 0);
diff --git a/test/parallel/test-repl-array-prototype-tempering.js b/test/parallel/test-repl-array-prototype-tempering.js
new file mode 100644
index 0000000000000000000000000000000000000000..907a6396ebeaef4f2389ada58ec5fb3c6839b950
--- /dev/null
+++ b/test/parallel/test-repl-array-prototype-tempering.js
@@ -0,0 +1,66 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { spawn } = require('child_process');
+
+const replProcess = spawn(process.argv0, ['--interactive'], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  windowsHide: true,
+});
+
+replProcess.on('error', common.mustNotCall());
+
+const replReadyState = (async function* () {
+  let ready;
+  const SPACE = ' '.charCodeAt();
+  const BRACKET = '>'.charCodeAt();
+  const DOT = '.'.charCodeAt();
+  replProcess.stdout.on('data', (data) => {
+    ready = data[data.length - 1] === SPACE && (
+      data[data.length - 2] === BRACKET || (
+        data[data.length - 2] === DOT &&
+        data[data.length - 3] === DOT &&
+        data[data.length - 4] === DOT
+      ));
+  });
+
+  const processCrashed = new Promise((resolve, reject) =>
+    replProcess.on('exit', reject)
+  );
+  while (true) {
+    await Promise.race([new Promise(setImmediate), processCrashed]);
+    if (ready) {
+      ready = false;
+      yield;
+    }
+  }
+})();
+async function writeLn(data, expectedOutput) {
+  await replReadyState.next();
+  if (expectedOutput) {
+    replProcess.stdout.once('data', common.mustCall((data) =>
+      assert.match(data.toString('utf8'), expectedOutput)
+    ));
+  }
+  await new Promise((resolve, reject) => replProcess.stdin.write(
+    `${data}\n`,
+    (err) => (err ? reject(err) : resolve())
+  ));
+}
+
+async function main() {
+  await writeLn(
+    'Object.defineProperty(Array.prototype, "-1", ' +
+        '{ get() { return this[this.length - 1]; } });'
+  );
+
+  await writeLn(
+    '[3, 2, 1][-1];',
+    /^1\n(>\s)?$/
+  );
+  await writeLn('.exit');
+
+  assert(!replProcess.connected);
+}
+
+main().then(common.mustCall());
diff --git a/test/parallel/test-repl-autocomplete.js b/test/parallel/test-repl-autocomplete.js
new file mode 100644
index 0000000000000000000000000000000000000000..b107053183080a10cd0aadf6241af1001120be3c
--- /dev/null
+++ b/test/parallel/test-repl-autocomplete.js
@@ -0,0 +1,218 @@
+'use strict';
+
+// Flags: --expose-internals
+
+const common = require('../common');
+const stream = require('stream');
+const REPL = require('internal/repl');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { inspect } = require('util');
+
+common.skipIfDumbTerminal();
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+process.throwDeprecation = true;
+
+const defaultHistoryPath = path.join(tmpdir.path, '.node_repl_history');
+
+// Create an input stream specialized for testing an array of actions
+class ActionStream extends stream.Stream {
+  run(data) {
+    const _iter = data[Symbol.iterator]();
+    const doAction = () => {
+      const next = _iter.next();
+      if (next.done) {
+        // Close the repl. Note that it must have a clean prompt to do so.
+        this.emit('keypress', '', { ctrl: true, name: 'd' });
+        return;
+      }
+      const action = next.value;
+
+      if (typeof action === 'object') {
+        this.emit('keypress', '', action);
+      } else {
+        this.emit('data', `${action}`);
+      }
+      setImmediate(doAction);
+    };
+    doAction();
+  }
+  resume() {}
+  pause() {}
+}
+ActionStream.prototype.readable = true;
+
+// Mock keys
+const ENTER = { name: 'enter' };
+const UP = { name: 'up' };
+const DOWN = { name: 'down' };
+const LEFT = { name: 'left' };
+const RIGHT = { name: 'right' };
+const BACKSPACE = { name: 'backspace' };
+const TABULATION = { name: 'tab' };
+const WORD_LEFT = { name: 'left', ctrl: true };
+const WORD_RIGHT = { name: 'right', ctrl: true };
+const GO_TO_END = { name: 'end' };
+const SIGINT = { name: 'c', ctrl: true };
+const ESCAPE = { name: 'escape', meta: true };
+
+const prompt = '> ';
+
+const tests = [
+  {
+    env: { NODE_REPL_HISTORY: defaultHistoryPath },
+    test: (function*() {
+      // Deleting Array iterator should not break history feature.
+      //
+      // Using a generator function instead of an object to allow the test to
+      // keep iterating even when Array.prototype[Symbol.iterator] has been
+      // deleted.
+      yield 'const ArrayIteratorPrototype =';
+      yield '  Object.getPrototypeOf(Array.prototype[Symbol.iterator]());';
+      yield ENTER;
+      yield 'const {next} = ArrayIteratorPrototype;';
+      yield ENTER;
+      yield 'const realArrayIterator = Array.prototype[Symbol.iterator];';
+      yield ENTER;
+      yield 'delete Array.prototype[Symbol.iterator];';
+      yield ENTER;
+      yield 'delete ArrayIteratorPrototype.next;';
+      yield ENTER;
+      yield UP;
+      yield UP;
+      yield DOWN;
+      yield DOWN;
+      yield 'fu';
+      yield 'n';
+      yield RIGHT;
+      yield BACKSPACE;
+      yield LEFT;
+      yield LEFT;
+      yield 'A';
+      yield BACKSPACE;
+      yield GO_TO_END;
+      yield BACKSPACE;
+      yield WORD_LEFT;
+      yield WORD_RIGHT;
+      yield ESCAPE;
+      yield ENTER;
+      yield 'require("./';
+      yield TABULATION;
+      yield SIGINT;
+      yield 'import("./';
+      yield TABULATION;
+      yield SIGINT;
+      yield 'Array.proto';
+      yield RIGHT;
+      yield '.pu';
+      yield ENTER;
+      yield 'ArrayIteratorPrototype.next = next;';
+      yield ENTER;
+      yield 'Array.prototype[Symbol.iterator] = realArrayIterator;';
+      yield ENTER;
+    })(),
+    expected: [],
+    clean: false
+  },
+];
+const numtests = tests.length;
+
+const runTestWrap = common.mustCall(runTest, numtests);
+
+function cleanupTmpFile() {
+  try {
+    // Write over the file, clearing any history
+    fs.writeFileSync(defaultHistoryPath, '');
+  } catch (err) {
+    if (err.code === 'ENOENT') return true;
+    throw err;
+  }
+  return true;
+}
+
+function runTest() {
+  const opts = tests.shift();
+  if (!opts) return; // All done
+
+  const { expected, skip } = opts;
+
+  // Test unsupported on platform.
+  if (skip) {
+    setImmediate(runTestWrap, true);
+    return;
+  }
+  const lastChunks = [];
+  let i = 0;
+
+  REPL.createInternalRepl(opts.env, {
+    input: new ActionStream(),
+    output: new stream.Writable({
+      write(chunk, _, next) {
+        const output = chunk.toString();
+
+        if (!opts.showEscapeCodes &&
+            (output[0] === '\x1B' || /^[\r\n]+$/.test(output))) {
+          return next();
+        }
+
+        lastChunks.push(output);
+
+        if (expected.length && !opts.checkTotal) {
+          try {
+            assert.strictEqual(output, expected[i]);
+          } catch (e) {
+            console.error(`Failed test # ${numtests - tests.length}`);
+            console.error('Last outputs: ' + inspect(lastChunks, {
+              breakLength: 5, colors: true
+            }));
+            throw e;
+          }
+          // TODO(BridgeAR): Auto close on last chunk!
+          i++;
+        }
+
+        next();
+      }
+    }),
+    allowBlockingCompletions: true,
+    completer: opts.completer,
+    prompt,
+    useColors: false,
+    preview: opts.preview,
+    terminal: true
+  }, function(err, repl) {
+    if (err) {
+      console.error(`Failed test # ${numtests - tests.length}`);
+      throw err;
+    }
+
+    repl.once('close', () => {
+      if (opts.clean)
+        cleanupTmpFile();
+
+      if (opts.checkTotal) {
+        assert.deepStrictEqual(lastChunks, expected);
+      } else if (expected.length !== i) {
+        console.error(tests[numtests - tests.length - 1]);
+        throw new Error(`Failed test # ${numtests - tests.length}`);
+      }
+
+      setImmediate(runTestWrap, true);
+    });
+
+    if (opts.columns) {
+      Object.defineProperty(repl, 'columns', {
+        value: opts.columns,
+        enumerable: true
+      });
+    }
+    repl.input.run(opts.test);
+  });
+}
+
+// run the tests
+runTest();
diff --git a/test/parallel/test-repl-clear-immediate-crash.js b/test/parallel/test-repl-clear-immediate-crash.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce8aaf48e7fa0e9711d8204ea26b125bce5f64ec
--- /dev/null
+++ b/test/parallel/test-repl-clear-immediate-crash.js
@@ -0,0 +1,12 @@
+'use strict';
+const common = require('../common');
+const child_process = require('child_process');
+const assert = require('assert');
+
+// Regression test for https://github.com/nodejs/node/issues/37806:
+const proc = child_process.spawn(process.execPath, ['-i']);
+proc.on('error', common.mustNotCall());
+proc.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 0);
+}));
+proc.stdin.write('clearImmediate({});\n.exit\n');
diff --git a/test/parallel/test-repl-domain.js b/test/parallel/test-repl-domain.js
index ce6da4bedb9e2806942f924884e440ee15f26d57..462677d114c13b9ce2b9cf49192022464022288e 100644
--- a/test/parallel/test-repl-domain.js
+++ b/test/parallel/test-repl-domain.js
@@ -41,5 +41,5 @@ putIn.write = function(data) {
 
 putIn.run([
   'require("domain").create().on("error", function() { console.log("OK") })' +
-  '.run(function() { throw new Error("threw") })'
+  '.run(function() { throw new Error("threw") })',
 ]);
diff --git a/test/parallel/test-repl-dynamic-import.js b/test/parallel/test-repl-dynamic-import.js
index 1f7a01575aa89bb08d0f903657dd4cc0f2786300..a043e31bf5b2d00fb2532d6ab19ebc4d2fa93f0e 100644
--- a/test/parallel/test-repl-dynamic-import.js
+++ b/test/parallel/test-repl-dynamic-import.js
@@ -4,7 +4,7 @@ const assert = require('assert');
 const child_process = require('child_process');
 const child = child_process.spawn(process.execPath, [
   '--interactive',
-  '--expose-gc'
+  '--expose-gc',
 ], {
   stdio: 'pipe'
 });
diff --git a/test/parallel/test-repl-editor.js b/test/parallel/test-repl-editor.js
index 41685f06e72c061e6b160a060ee11398d861209d..e260f5e89174a84aedaf35792582250696772562 100644
--- a/test/parallel/test-repl-editor.js
+++ b/test/parallel/test-repl-editor.js
@@ -19,9 +19,10 @@ function run({ input, output, event, checkTerminalCodes = true }) {
 
   stream.write = (msg) => found += msg.replace('\r', '');
 
-  let expected = `${terminalCode}.editor\n` +
-                 '// Entering editor mode (^D to finish, ^C to cancel)\n' +
-                 `${input}${output}\n${terminalCode}`;
+  let expected =
+    `${terminalCode}.editor\n` +
+    '// Entering editor mode (Ctrl+D to finish, Ctrl+C to cancel)\n' +
+    `${input}${output}\n${terminalCode}`;
 
   const replServer = repl.start({
     prompt: '> ',
@@ -47,7 +48,7 @@ function run({ input, output, event, checkTerminalCodes = true }) {
 const tests = [
   {
     input: '',
-    output: '\n(To exit, press ^C again or ^D or type .exit)',
+    output: '\n(To exit, press Ctrl+C again or Ctrl+D or type .exit)',
     event: { ctrl: true, name: 'c' }
   },
   {
@@ -70,7 +71,7 @@ const tests = [
     output: '',
     checkTerminalCodes: false,
     event: null,
-  }
+  },
 ];
 
 tests.forEach(run);
@@ -120,7 +121,7 @@ const codeAlignmentTests = [
     input: ' let i = 1;\n let j = 2\n',
     cursor: 2,
     line: '  '
-  }
+  },
 ];
 
 codeAlignmentTests.forEach(testCodeAlignment);
diff --git a/test/parallel/test-repl-envvars.js b/test/parallel/test-repl-envvars.js
index 4fab77b7c09980205acbdad6acb1f67c5c7aab63..96cc47dd1674f34b427d0364a3b08879d090fc2e 100644
--- a/test/parallel/test-repl-envvars.js
+++ b/test/parallel/test-repl-envvars.js
@@ -32,7 +32,7 @@ const tests = [
   {
     env: { NODE_NO_READLINE: '0' },
     expected: { terminal: true, useColors: true }
-  }
+  },
 ];
 
 function run(test) {
diff --git a/test/parallel/test-repl-history-navigation.js b/test/parallel/test-repl-history-navigation.js
index 032e1ba2fe7fc6ca2b97599d999e5d98d7bb557f..044c788a16af3f898468905273e720c303948e23 100644
--- a/test/parallel/test-repl-history-navigation.js
+++ b/test/parallel/test-repl-history-navigation.js
@@ -15,6 +15,8 @@ common.skipIfDumbTerminal();
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
+process.throwDeprecation = true;
+
 const defaultHistoryPath = path.join(tmpdir.path, '.node_repl_history');
 
 // Create an input stream specialized for testing an array of actions
@@ -57,6 +59,7 @@ const WORD_RIGHT = { name: 'right', ctrl: true };
 const GO_TO_END = { name: 'end' };
 const DELETE_WORD_LEFT = { name: 'backspace', ctrl: true };
 const SIGINT = { name: 'c', ctrl: true };
+const ESCAPE = { name: 'escape', meta: true };
 
 const prompt = '> ';
 const WAIT = '€';
@@ -113,7 +116,7 @@ const tests = [
       'const foo = true', ENTER,
       '555n + 111n', ENTER,
       '5 + 5', ENTER,
-      '55 - 13 === 42', ENTER
+      '55 - 13 === 42', ENTER,
     ],
     expected: [],
     clean: false
@@ -124,7 +127,7 @@ const tests = [
     preview: false,
     showEscapeCodes: true,
     test: [
-      '55', UP, UP, UP, UP, UP, UP, ENTER
+      '55', UP, UP, UP, UP, UP, UP, ENTER,
     ],
     expected: [
       '\x1B[1G', '\x1B[0J', prompt, '\x1B[3G',
@@ -147,7 +150,7 @@ const tests = [
       '\r\n', '55\n',
       '\x1B[1G', '\x1B[0J',
       '> ', '\x1B[3G',
-      '\r\n'
+      '\r\n',
     ],
     clean: true
   },
@@ -182,9 +185,11 @@ const tests = [
       'veryLongName'.repeat(30),
       ENTER,
       `${'\x1B[90m \x1B[39m'.repeat(235)} fun`,
+      ESCAPE,
       ENTER,
       `${' '.repeat(236)} fun`,
-      ENTER
+      ESCAPE,
+      ENTER,
     ],
     expected: [],
     clean: false
@@ -215,7 +220,7 @@ const tests = [
       '2',
       BACKSPACE,
       '3',
-      SIGINT
+      SIGINT,
     ],
     // A = Cursor n up
     // B = Cursor n down
@@ -310,7 +315,7 @@ const tests = [
       '\r\n',
       '\x1B[1G', '\x1B[0J',
       '> ', '\x1B[3G',
-      '\r\n'
+      '\r\n',
     ],
     clean: true
   },
@@ -318,6 +323,7 @@ const tests = [
     env: { NODE_REPL_HISTORY: defaultHistoryPath },
     showEscapeCodes: true,
     skip: !process.features.inspector,
+    checkTotal: true,
     test: [
       'fu',
       'n',
@@ -331,7 +337,13 @@ const tests = [
       BACKSPACE,
       WORD_LEFT,
       WORD_RIGHT,
-      ENTER
+      ESCAPE,
+      ENTER,
+      UP,
+      LEFT,
+      ENTER,
+      UP,
+      ENTER,
     ],
     // C = Cursor n forward
     // D = Cursor n back
@@ -379,12 +391,36 @@ const tests = [
       '\x1B[0K', '\x1B[7D', '\x1B[10G', ' // n', '\x1B[3G', '\x1B[10G',
       // 10. Word right. Cleanup
       '\x1B[0K', '\x1B[3G', '\x1B[7C', ' // n', '\x1B[10G',
-      '\x1B[0K',
-      // 11. ENTER
+      // 11. ESCAPE
+      '\x1B[0K', ' // n', '\x1B[10G', '\x1B[0K',
+      // 12. ENTER
+      '\r\n',
+      'Uncaught ReferenceError: functio is not defined\n',
+      '\x1B[1G', '\x1B[0J',
+      // 13. UP
+      prompt, '\x1B[3G', '\x1B[1G', '\x1B[0J',
+      `${prompt}functio`, '\x1B[10G',
+      ' // n', '\x1B[10G',
+      ' // n', '\x1B[10G',
+      // 14. LEFT
+      '\x1B[0K', '\x1B[1D',
+      '\x1B[10G', ' // n', '\x1B[9G', '\x1B[10G',
+      // 15. ENTER
+      '\x1B[0K', '\x1B[9G', '\x1B[1C',
       '\r\n',
       'Uncaught ReferenceError: functio is not defined\n',
       '\x1B[1G', '\x1B[0J',
-      prompt, '\x1B[3G', '\r\n'
+      '> ', '\x1B[3G',
+      // 16. UP
+      '\x1B[1G', '\x1B[0J',
+      '> functio', '\x1B[10G',
+      ' // n', '\x1B[10G',
+      ' // n', '\x1B[10G', '\x1B[0K',
+      // 17. ENTER
+      'n', '\r\n',
+      '\x1B[1G', '\x1B[0J',
+      '... ', '\x1B[5G',
+      '\r\n',
     ],
     clean: true
   },
@@ -394,7 +430,7 @@ const tests = [
     skip: !process.features.inspector,
     test: [
       'util.inspect.replDefaults.showHidden',
-      ENTER
+      ENTER,
     ],
     expected: [],
     clean: false
@@ -411,7 +447,7 @@ const tests = [
       ' = true',
       ENTER,
       '[ ]',
-      ENTER
+      ENTER,
     ],
     expected: [
       prompt,
@@ -451,7 +487,7 @@ const tests = [
       WAIT, // The second call is not awaited. It won't trigger the preview.
       BACKSPACE,
       's',
-      BACKSPACE
+      BACKSPACE,
     ],
     expected: [
       prompt,
@@ -468,7 +504,56 @@ const tests = [
       prompt,
     ],
     clean: true
-  }
+  },
+  {
+    env: { NODE_REPL_HISTORY: defaultHistoryPath },
+    test: (function*() {
+      // Deleting Array iterator should not break history feature.
+      //
+      // Using a generator function instead of an object to allow the test to
+      // keep iterating even when Array.prototype[Symbol.iterator] has been
+      // deleted.
+      yield 'const ArrayIteratorPrototype =';
+      yield '  Object.getPrototypeOf(Array.prototype[Symbol.iterator]());';
+      yield ENTER;
+      yield 'const {next} = ArrayIteratorPrototype;';
+      yield ENTER;
+      yield 'const realArrayIterator = Array.prototype[Symbol.iterator];';
+      yield ENTER;
+      yield 'delete Array.prototype[Symbol.iterator];';
+      yield ENTER;
+      yield 'delete ArrayIteratorPrototype.next;';
+      yield ENTER;
+      yield UP;
+      yield UP;
+      yield DOWN;
+      yield DOWN;
+      yield 'fu';
+      yield 'n';
+      yield RIGHT;
+      yield BACKSPACE;
+      yield LEFT;
+      yield LEFT;
+      yield 'A';
+      yield BACKSPACE;
+      yield GO_TO_END;
+      yield BACKSPACE;
+      yield WORD_LEFT;
+      yield WORD_RIGHT;
+      yield ESCAPE;
+      yield ENTER;
+      yield 'Array.proto';
+      yield RIGHT;
+      yield '.pu';
+      yield ENTER;
+      yield 'ArrayIteratorPrototype.next = next;';
+      yield ENTER;
+      yield 'Array.prototype[Symbol.iterator] = realArrayIterator;';
+      yield ENTER;
+    })(),
+    expected: [],
+    clean: false
+  },
 ];
 const numtests = tests.length;
 
diff --git a/test/parallel/test-repl-history-perm.js b/test/parallel/test-repl-history-perm.js
index a6317d7c02181b2b7c7cd5940de64852f576e10d..aeca832d4309789e61832cad5830aef5b3446f54 100644
--- a/test/parallel/test-repl-history-perm.js
+++ b/test/parallel/test-repl-history-perm.js
@@ -35,15 +35,16 @@ const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 const replHistoryPath = path.join(tmpdir.path, '.node_repl_history');
 
-const checkResults = common.mustCall(function(err, r) {
-  assert.ifError(err);
-
-  r.input.end();
+const checkResults = common.mustSucceed((r) => {
   const stat = fs.statSync(replHistoryPath);
   const fileMode = stat.mode & 0o777;
   assert.strictEqual(
     fileMode, 0o600,
     `REPL history file should be mode 0600 but was 0${fileMode.toString(8)}`);
+
+  // Close the REPL
+  r.input.emit('keypress', '', { ctrl: true, name: 'd' });
+  r.input.end();
 });
 
 repl.createInternalRepl(
diff --git a/test/parallel/test-repl-import-referrer.js b/test/parallel/test-repl-import-referrer.js
index 19b3fe721b5c43860dedd40f7a8455b929ec2b03..d77d70a031a14a1ad96fba7a48e783401b40c5b7 100644
--- a/test/parallel/test-repl-import-referrer.js
+++ b/test/parallel/test-repl-import-referrer.js
@@ -5,7 +5,6 @@ const cp = require('child_process');
 const fixtures = require('../common/fixtures');
 
 const args = ['--interactive', '--experimental-repl-await'];
-
 const opts = { cwd: fixtures.path('es-modules') };
 const child = cp.spawn(process.execPath, args, opts);
 
@@ -17,7 +16,10 @@ child.stdout.on('data', (data) => {
 
 child.on('exit', common.mustCall(() => {
   const results = output.replace(/^> /mg, '').split('\n').slice(2);
-  assert.deepStrictEqual(results, ['[Module] { message: \'A message\' }', '']);
+  assert.deepStrictEqual(
+    results,
+    ['[Module: null prototype] { message: \'A message\' }', '']
+  );
 }));
 
 child.stdin.write('await import(\'./message.mjs\');\n');
diff --git a/test/parallel/test-repl-inspect-defaults.js b/test/parallel/test-repl-inspect-defaults.js
index 9a033ce1f3dc13906844ddb6d75aa235f004ab00..84536eb773223bf0095d85fea792f349ce998bf4 100644
--- a/test/parallel/test-repl-inspect-defaults.js
+++ b/test/parallel/test-repl-inspect-defaults.js
@@ -18,7 +18,7 @@ child.on('exit', common.mustCall(() => {
       '[ 42, 23 ]',
       '1',
       '[ 42, ... 1 more item ]',
-      ''
+      '',
     ]
   );
 }));
diff --git a/test/parallel/test-repl-inspector.js b/test/parallel/test-repl-inspector.js
index acec99208bcf028d2e62b5993ac82ba396ee090c..1fff9031d500fd10f4d740f4cba84b6c634b3c08 100644
--- a/test/parallel/test-repl-inspector.js
+++ b/test/parallel/test-repl-inspector.js
@@ -28,7 +28,7 @@ putIn.run([
   'const session = new inspector.Session()',
   'session.connect()',
   'session.post("Runtime.evaluate", { expression: "1 + 1" }, console.log)',
-  'session.disconnect()'
+  'session.disconnect()',
 ]);
 
 assert(output.includes(
diff --git a/test/parallel/test-repl-mode.js b/test/parallel/test-repl-mode.js
index df84d86a3c8dc3f5fb9fe6cd3eef09833c3ab12a..d8131d34f93b44e73f30a32b449c813ebcc67e87 100644
--- a/test/parallel/test-repl-mode.js
+++ b/test/parallel/test-repl-mode.js
@@ -7,7 +7,8 @@ const repl = require('repl');
 const tests = [
   testSloppyMode,
   testStrictMode,
-  testAutoMode
+  testAutoMode,
+  testStrictModeTerminal,
 ];
 
 tests.forEach(function(test) {
@@ -37,6 +38,22 @@ function testStrictMode() {
   assert.strictEqual(cli.output.accumulator.join(''), 'undefined\n> ');
 }
 
+function testStrictModeTerminal() {
+  if (!process.features.inspector) {
+    console.warn('Test skipped: V8 inspector is disabled');
+    return;
+  }
+  // Verify that ReferenceErrors are reported in strict mode previews.
+  const cli = initRepl(repl.REPL_MODE_STRICT, {
+    terminal: true
+  });
+
+  cli.input.emit('data', 'xyz ');
+  assert.ok(
+    cli.output.accumulator.includes('\n// ReferenceError: xyz is not defined')
+  );
+}
+
 function testAutoMode() {
   const cli = initRepl(repl.REPL_MODE_MAGIC);
 
@@ -48,7 +65,7 @@ function testAutoMode() {
   assert.strictEqual(cli.output.accumulator.join(''), 'undefined\n> ');
 }
 
-function initRepl(mode) {
+function initRepl(mode, options) {
   const input = new Stream();
   input.write = input.pause = input.resume = () => {};
   input.readable = true;
@@ -65,6 +82,7 @@ function initRepl(mode) {
     output: output,
     useColors: false,
     terminal: false,
-    replMode: mode
+    replMode: mode,
+    ...options
   });
 }
diff --git a/test/parallel/test-repl-no-terminal.js b/test/parallel/test-repl-no-terminal.js
new file mode 100644
index 0000000000000000000000000000000000000000..60f97b52e26942d9fe5e9765637761ab68d34560
--- /dev/null
+++ b/test/parallel/test-repl-no-terminal.js
@@ -0,0 +1,7 @@
+'use strict';
+const common = require('../common');
+
+const repl = require('repl');
+const r = repl.start({ terminal: false });
+r.setupHistory('/nonexistent/file', common.mustSucceed());
+process.stdin.unref?.();
diff --git a/test/parallel/test-repl-options.js b/test/parallel/test-repl-options.js
index 43270e7412d3a2feea904d273e17dde274a4a94b..a5c01ccfcb08385c373aef8ff74b3317585829bd 100644
--- a/test/parallel/test-repl-options.js
+++ b/test/parallel/test-repl-options.js
@@ -19,15 +19,25 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+// Flags: --pending-deprecation
+
 'use strict';
 const common = require('../common');
 const ArrayStream = require('../common/arraystream');
 const assert = require('assert');
 const repl = require('repl');
+const cp = require('child_process');
+
+assert.strictEqual(repl.repl, undefined);
+repl._builtinLibs; // eslint-disable-line no-unused-expressions
 
 common.expectWarning({
   DeprecationWarning: {
-    DEP0124: 'REPLServer.rli is deprecated'
+    DEP0142:
+      'repl._builtinLibs is deprecated. Check module.builtinModules instead',
+    DEP0141: 'repl.inputStream and repl.outputStream are deprecated. ' +
+             'Use repl.input and repl.output instead',
+    DEP0124: 'REPLServer.rli is deprecated',
   }
 });
 
@@ -110,7 +120,7 @@ assert.throws(r3, {
 // 4, Verify that defaults are used when no arguments are provided
 const r4 = repl.start();
 
-assert.strictEqual(r4._prompt, '> ');
+assert.strictEqual(r4.getPrompt(), '> ');
 assert.strictEqual(r4.input, process.stdin);
 assert.strictEqual(r4.output, process.stdout);
 assert.strictEqual(r4.terminal, !!r4.output.isTTY);
@@ -120,3 +130,25 @@ assert.strictEqual(r4.ignoreUndefined, false);
 assert.strictEqual(r4.replMode, repl.REPL_MODE_SLOPPY);
 assert.strictEqual(r4.historySize, 30);
 r4.close();
+
+// Check the standalone REPL
+{
+  const child = cp.spawn(process.execPath, ['--interactive']);
+  let output = '';
+
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', (data) => {
+    output += data;
+  });
+
+  child.on('exit', common.mustCall(() => {
+    const results = output.replace(/^> /mg, '').split('\n').slice(2);
+    assert.deepStrictEqual(results, ['undefined', '']);
+  }));
+
+  child.stdin.write(
+    'assert.ok(util.inspect(repl.repl, {depth: -1}).includes("REPLServer"));\n'
+  );
+  child.stdin.write('.exit');
+  child.stdin.end();
+}
diff --git a/test/parallel/test-repl-persistent-history.js b/test/parallel/test-repl-persistent-history.js
index 705a7c7c236fb00431b6cbb929bd616d865c3681..b0cddf0a2bd020b9b722fd84fdeea815b30435ad 100644
--- a/test/parallel/test-repl-persistent-history.js
+++ b/test/parallel/test-repl-persistent-history.js
@@ -98,7 +98,7 @@ const tests = [
     expected: [
       prompt,
       '2', '1', '21\n', prompt, prompt,
-      "'", '4', '2', "'", "'42'\n", prompt, prompt
+      "'", '4', '2', "'", "'42'\n", prompt, prompt,
     ],
     clean: false
   },
@@ -128,7 +128,7 @@ const tests = [
       `${prompt}'you look fabulous today'`,
       prompt,
       `${prompt}'you look fabulous today'`,
-      prompt
+      prompt,
     ]
   },
   {
@@ -169,7 +169,7 @@ const tests = [
     env: {},
     test: [UP],
     expected: [prompt, homedirErr, prompt, replDisabled, prompt]
-  }
+  },
 ];
 const numtests = tests.length;
 
diff --git a/test/parallel/test-repl-preprocess-top-level-await.js b/test/parallel/test-repl-preprocess-top-level-await.js
index 2a173b7339b8c719e788a87f1c7feb11c32b5853..93d3d79a87bb088b8f51cf349880f9767166c78b 100644
--- a/test/parallel/test-repl-preprocess-top-level-await.js
+++ b/test/parallel/test-repl-preprocess-top-level-await.js
@@ -29,38 +29,97 @@ const testCases = [
   [ 'await 0; return 0;',
     null ],
   [ 'var a = await 1',
-    '(async () => { void (a = await 1) })()' ],
+    'var a; (async () => { void (a = await 1) })()' ],
   [ 'let a = await 1',
-    '(async () => { void (a = await 1) })()' ],
+    'let a; (async () => { void (a = await 1) })()' ],
   [ 'const a = await 1',
-    '(async () => { void (a = await 1) })()' ],
+    'let a; (async () => { void (a = await 1) })()' ],
   [ 'for (var i = 0; i < 1; ++i) { await i }',
-    '(async () => { for (void (i = 0); i < 1; ++i) { await i } })()' ],
+    'var i; (async () => { for (void (i = 0); i < 1; ++i) { await i } })()' ],
   [ 'for (let i = 0; i < 1; ++i) { await i }',
     '(async () => { for (let i = 0; i < 1; ++i) { await i } })()' ],
   [ 'var {a} = {a:1}, [b] = [1], {c:{d}} = {c:{d: await 1}}',
-    '(async () => { void ( ({a} = {a:1}), ([b] = [1]), ' +
+    'var a, b, d; (async () => { void ( ({a} = {a:1}), ([b] = [1]), ' +
         '({c:{d}} = {c:{d: await 1}})) })()' ],
+  [ 'let [a, b, c] = await ([1, 2, 3])',
+    'let a, b, c; (async () => { void ([a, b, c] = await ([1, 2, 3])) })()'],
+  [ 'let {a,b,c} = await ({a: 1, b: 2, c: 3})',
+    'let a, b, c; (async () => { void ({a,b,c} = ' +
+        'await ({a: 1, b: 2, c: 3})) })()'],
+  [ 'let {a: [b]} = {a: [await 1]}, [{d}] = [{d: 3}]',
+    'let b, d; (async () => { void ( ({a: [b]} = {a: [await 1]}),' +
+        ' ([{d}] = [{d: 3}])) })()'],
   /* eslint-disable no-template-curly-in-string */
   [ 'console.log(`${(await { a: 1 }).a}`)',
     '(async () => { return (console.log(`${(await { a: 1 }).a}`)) })()' ],
   /* eslint-enable no-template-curly-in-string */
   [ 'await 0; function foo() {}',
-    '(async () => { await 0; foo=function foo() {} })()' ],
+    'var foo; (async () => { await 0; this.foo = foo; function foo() {} })()' ],
   [ 'await 0; class Foo {}',
-    '(async () => { await 0; Foo=class Foo {} })()' ],
+    'let Foo; (async () => { await 0; Foo=class Foo {} })()' ],
   [ 'if (await true) { function foo() {} }',
-    '(async () => { if (await true) { foo=function foo() {} } })()' ],
+    'var foo; (async () => { ' +
+      'if (await true) { this.foo = foo; function foo() {} } })()' ],
   [ 'if (await true) { class Foo{} }',
     '(async () => { if (await true) { class Foo{} } })()' ],
   [ 'if (await true) { var a = 1; }',
-    '(async () => { if (await true) { void (a = 1); } })()' ],
+    'var a; (async () => { if (await true) { void (a = 1); } })()' ],
   [ 'if (await true) { let a = 1; }',
     '(async () => { if (await true) { let a = 1; } })()' ],
   [ 'var a = await 1; let b = 2; const c = 3;',
-    '(async () => { void (a = await 1); void (b = 2); void (c = 3); })()' ],
+    'var a; let b; let c; (async () => { void (a = await 1); void (b = 2);' +
+        ' void (c = 3); })()' ],
   [ 'let o = await 1, p',
-    '(async () => { void ( (o = await 1), (p=undefined)) })()' ]
+    'let o, p; (async () => { void ( (o = await 1), (p=undefined)) })()' ],
+  [ 'await (async () => { let p = await 1; return p; })()',
+    '(async () => { return (await (async () => ' +
+      '{ let p = await 1; return p; })()) })()' ],
+  [ '{ let p = await 1; }',
+    '(async () => { { let p = await 1; } })()' ],
+  [ 'var p = await 1',
+    'var p; (async () => { void (p = await 1) })()' ],
+  [ 'await (async () => { var p = await 1; return p; })()',
+    '(async () => { return (await (async () => ' +
+      '{ var p = await 1; return p; })()) })()' ],
+  [ '{ var p = await 1; }',
+    'var p; (async () => { { void (p = await 1); } })()' ],
+  [ 'for await (var i of asyncIterable) { i; }',
+    'var i; (async () => { for await (i of asyncIterable) { i; } })()'],
+  [ 'for await (var [i] of asyncIterable) { i; }',
+    'var i; (async () => { for await ([i] of asyncIterable) { i; } })()'],
+  [ 'for await (var {i} of asyncIterable) { i; }',
+    'var i; (async () => { for await ({i} of asyncIterable) { i; } })()'],
+  [ 'for await (var [{i}, [j]] of asyncIterable) { i; }',
+    'var i, j; (async () => { for await ([{i}, [j]] of asyncIterable)' +
+      ' { i; } })()'],
+  [ 'for await (let i of asyncIterable) { i; }',
+    '(async () => { for await (let i of asyncIterable) { i; } })()'],
+  [ 'for await (const i of asyncIterable) { i; }',
+    '(async () => { for await (const i of asyncIterable) { i; } })()'],
+  [ 'for (var i of [1,2,3]) { await 1; }',
+    'var i; (async () => { for (i of [1,2,3]) { await 1; } })()'],
+  [ 'for (var [i] of [[1], [2]]) { await 1; }',
+    'var i; (async () => { for ([i] of [[1], [2]]) { await 1; } })()'],
+  [ 'for (var {i} of [{i: 1}, {i: 2}]) { await 1; }',
+    'var i; (async () => { for ({i} of [{i: 1}, {i: 2}]) { await 1; } })()'],
+  [ 'for (var [{i}, [j]] of [[{i: 1}, [2]]]) { await 1; }',
+    'var i, j; (async () => { for ([{i}, [j]] of [[{i: 1}, [2]]])' +
+      ' { await 1; } })()'],
+  [ 'for (let i of [1,2,3]) { await 1; }',
+    '(async () => { for (let i of [1,2,3]) { await 1; } })()'],
+  [ 'for (const i of [1,2,3]) { await 1; }',
+    '(async () => { for (const i of [1,2,3]) { await 1; } })()'],
+  [ 'for (var i in {x:1}) { await 1 }',
+    'var i; (async () => { for (i in {x:1}) { await 1 } })()'],
+  [ 'for (var [a,b] in {xy:1}) { await 1 }',
+    'var a, b; (async () => { for ([a,b] in {xy:1}) { await 1 } })()'],
+  [ 'for (let i in {x:1}) { await 1 }',
+    '(async () => { for (let i in {x:1}) { await 1 } })()'],
+  [ 'for (const i in {x:1}) { await 1 }',
+    '(async () => { for (const i in {x:1}) { await 1 } })()'],
+  [ 'var x = await foo(); async function foo() { return Promise.resolve(1);}',
+    'var x; var foo; (async () => { void (x = await foo()); this.foo = foo; ' +
+      'async function foo() { return Promise.resolve(1);} })()'],
 ];
 
 for (const [input, expected] of testCases) {
diff --git a/test/parallel/test-repl-pretty-custom-stack.js b/test/parallel/test-repl-pretty-custom-stack.js
index d04a394a2e249e5a1ade9abbefc2aa3cb8fb5093..aef34f1b4f6329cb4e63d048419faf5764e07f80 100644
--- a/test/parallel/test-repl-pretty-custom-stack.js
+++ b/test/parallel/test-repl-pretty-custom-stack.js
@@ -68,7 +68,7 @@ const tests = [
   {
     command: '(function() { throw new Error(\'Whoops!\'); })()',
     expected: 'Uncaught Error: Whoops!--->\nREPL5:*:*\n'
-  }
+  },
 ];
 
 tests.forEach(run);
diff --git a/test/parallel/test-repl-pretty-stack-custom-writer.js b/test/parallel/test-repl-pretty-stack-custom-writer.js
new file mode 100644
index 0000000000000000000000000000000000000000..877f8cb807759763b1a2f72afa894d9ae5e392f0
--- /dev/null
+++ b/test/parallel/test-repl-pretty-stack-custom-writer.js
@@ -0,0 +1,23 @@
+'use strict';
+require('../common');
+const { PassThrough } = require('stream');
+const assert = require('assert');
+const repl = require('repl');
+
+{
+  const input = new PassThrough();
+  const output = new PassThrough();
+
+  const r = repl.start({
+    prompt: '',
+    input,
+    output,
+    writer: String,
+    terminal: false,
+    useColors: false
+  });
+
+  r.write('throw new Error("foo[a]")\n');
+  r.close();
+  assert.strictEqual(output.read().toString(), 'Uncaught Error: foo[a]\n');
+}
diff --git a/test/parallel/test-repl-pretty-stack.js b/test/parallel/test-repl-pretty-stack.js
index 8ab3fef2aaa033a089dc417dc5eef5f0211fb709..c785bf75a15ba65439a44d698afe497416497d32 100644
--- a/test/parallel/test-repl-pretty-stack.js
+++ b/test/parallel/test-repl-pretty-stack.js
@@ -70,7 +70,7 @@ const tests = [
   {
     command: '(function() { throw new Error(\'Whoops!\'); })()',
     expected: 'Uncaught Error: Whoops!\n    at REPL7:*:*\n'
-  }
+  },
 ];
 
 tests.forEach(run);
diff --git a/test/parallel/test-repl-preview.js b/test/parallel/test-repl-preview.js
index 34ac7e70d4f46838f2e54b90aaee3154d3708f8b..620f41296e91f08a1c693f2c04c579f523124821 100644
--- a/test/parallel/test-repl-preview.js
+++ b/test/parallel/test-repl-preview.js
@@ -77,7 +77,7 @@ async function tests(options) {
   repl.inputStream.run([
     'function foo(x) { return x; }',
     'function koo() { console.log("abc"); }',
-    'a = undefined;'
+    'a = undefined;',
   ]);
 
   const testCases = [{
@@ -86,15 +86,19 @@ async function tests(options) {
     preview: [
       'foo',
       '\x1B[90m[Function: foo]\x1B[39m\x1B[11G\x1B[1A\x1B[1B\x1B[2K\x1B[1A\r',
-      '\x1B[36m[Function: foo]\x1B[39m'
+      '\x1B[36m[Function: foo]\x1B[39m',
     ]
   }, {
     input: 'koo',
     noPreview: '[Function: koo]',
     preview: [
-      'k\x1B[90moo\x1B[39m\x1B[9G\x1B[0Ko\x1B[90mo\x1B[39m\x1B[10G\x1B[0Ko',
+      'k\x1B[90moo\x1B[39m\x1B[9G',
+      '\x1B[90m[Function: koo]\x1B[39m\x1B[9G\x1B[1A\x1B[1B\x1B[2K\x1B[1A' +
+        '\x1B[0Ko\x1B[90mo\x1B[39m\x1B[10G',
+      '\x1B[90m[Function: koo]\x1B[39m\x1B[10G\x1B[1A\x1B[1B\x1B[2K\x1B[1A' +
+        '\x1B[0Ko',
       '\x1B[90m[Function: koo]\x1B[39m\x1B[11G\x1B[1A\x1B[1B\x1B[2K\x1B[1A\r',
-      '\x1B[36m[Function: koo]\x1B[39m'
+      '\x1B[36m[Function: koo]\x1B[39m',
     ]
   }, {
     input: 'a',
@@ -108,7 +112,7 @@ async function tests(options) {
       '\x1B[90m1\x1B[39m\x1B[22G\x1B[1A\x1B[1B\x1B[2K\x1B[1A ',
       '\x1B[90m1\x1B[39m\x1B[23G\x1B[1A\x1B[1B\x1B[2K\x1B[1A=== 1',
       '\x1B[90mtrue\x1B[39m\x1B[28G\x1B[1A\x1B[1B\x1B[2K\x1B[1A\r',
-      '\x1B[33mtrue\x1B[39m'
+      '\x1B[33mtrue\x1B[39m',
     ]
   }, {
     input: "{ b: 1 }['b'] === 1;",
@@ -119,14 +123,14 @@ async function tests(options) {
       '\x1B[90m1\x1B[39m\x1B[22G\x1B[1A\x1B[1B\x1B[2K\x1B[1A=== 1',
       '\x1B[90mtrue\x1B[39m\x1B[27G\x1B[1A\x1B[1B\x1B[2K\x1B[1A;',
       '\x1B[90mfalse\x1B[39m\x1B[28G\x1B[1A\x1B[1B\x1B[2K\x1B[1A\r',
-      '\x1B[33mfalse\x1B[39m'
+      '\x1B[33mfalse\x1B[39m',
     ]
   }, {
     input: '{ a: true }',
     noPreview: '{ a: \x1B[33mtrue\x1B[39m }',
     preview: [
       '{ a: tru\x1B[90me\x1B[39m\x1B[16G\x1B[0Ke }\r',
-      '{ a: \x1B[33mtrue\x1B[39m }'
+      '{ a: \x1B[33mtrue\x1B[39m }',
     ]
   }, {
     input: '{ a: true };',
@@ -134,7 +138,7 @@ async function tests(options) {
     preview: [
       '{ a: tru\x1B[90me\x1B[39m\x1B[16G\x1B[0Ke };',
       '\x1B[90mtrue\x1B[39m\x1B[20G\x1B[1A\x1B[1B\x1B[2K\x1B[1A\r',
-      '\x1B[33mtrue\x1B[39m'
+      '\x1B[33mtrue\x1B[39m',
     ]
   }, {
     input: ' \t { a: true};',
@@ -143,7 +147,7 @@ async function tests(options) {
       '  { a: tru\x1B[90me\x1B[39m\x1B[18G\x1B[0Ke}',
       '\x1B[90m{ a: true }\x1B[39m\x1B[20G\x1B[1A\x1B[1B\x1B[2K\x1B[1A;',
       '\x1B[90mtrue\x1B[39m\x1B[21G\x1B[1A\x1B[1B\x1B[2K\x1B[1A\r',
-      '\x1B[33mtrue\x1B[39m'
+      '\x1B[33mtrue\x1B[39m',
     ]
   }, {
     input: '1n + 2n',
@@ -152,7 +156,7 @@ async function tests(options) {
       '1n + 2',
       '\x1B[90mType[39m\x1B[14G\x1B[1A\x1B[1B\x1B[2K\x1B[1An',
       '\x1B[90m3n\x1B[39m\x1B[15G\x1B[1A\x1B[1B\x1B[2K\x1B[1A\r',
-      '\x1B[33m3n\x1B[39m'
+      '\x1B[33m3n\x1B[39m',
     ]
   }, {
     input: '{};1',
@@ -160,7 +164,7 @@ async function tests(options) {
     preview: [
       '{};1',
       '\x1B[90m1\x1B[39m\x1B[12G\x1B[1A\x1B[1B\x1B[2K\x1B[1A\r',
-      '\x1B[33m1\x1B[39m'
+      '\x1B[33m1\x1B[39m',
     ]
   }];
 
diff --git a/test/parallel/test-repl-programmatic-history.js b/test/parallel/test-repl-programmatic-history.js
index 0eccea655263cdc08c08bf09498d5dee410e97bf..e2ad2cc66fd44d0df34f7d1074bb6d836fbc9aec 100644
--- a/test/parallel/test-repl-programmatic-history.js
+++ b/test/parallel/test-repl-programmatic-history.js
@@ -98,7 +98,7 @@ const tests = [
       // TODO(BridgeAR): The line is refreshed too many times. The double prompt
       // is redundant and can be optimized away.
       '2', '1', '21\n', prompt, prompt,
-      "'", '4', '2', "'", "'42'\n", prompt, prompt
+      "'", '4', '2', "'", "'42'\n", prompt, prompt,
     ],
     clean: false
   },
@@ -112,7 +112,7 @@ const tests = [
       prompt,
       `${prompt}21`,
       '21\n',
-      prompt
+      prompt,
     ]
   },
   {
@@ -124,7 +124,7 @@ const tests = [
       `${prompt}'you look fabulous today'`,
       prompt,
       `${prompt}'you look fabulous today'`,
-      prompt
+      prompt,
     ]
   },
   {
@@ -165,7 +165,7 @@ const tests = [
     env: {},
     test: [UP],
     expected: [prompt, homedirErr, prompt, replDisabled, prompt]
-  }
+  },
 ];
 const numtests = tests.length;
 
diff --git a/test/parallel/test-repl-reverse-search.js b/test/parallel/test-repl-reverse-search.js
index 0c6b29da36db5865f188f17c2714f3dafec98b6b..5165dc2820d2d631004e5943a5040ce96ea7b881 100644
--- a/test/parallel/test-repl-reverse-search.js
+++ b/test/parallel/test-repl-reverse-search.js
@@ -71,7 +71,7 @@ const tests = [
       'ab = "aaaa"', ENTER,
       '555 - 909', ENTER,
       '{key : {key2 :[] }}', ENTER,
-      'Array(100).fill(1)', ENTER
+      'Array(100).fill(1)', ENTER,
     ],
     expected: [],
     clean: false
@@ -99,7 +99,7 @@ const tests = [
       SEARCH_BACKWARDS, // 15
       SEARCH_FORWARDS,
       ESCAPE,           // 17
-      ENTER
+      ENTER,
     ],
     // A = Cursor n up
     // B = Cursor n down
@@ -179,7 +179,7 @@ const tests = [
       '\x1B[1G', '\x1B[0J',
       prompt,
       '\x1B[3G',
-      '\r\n'
+      '\r\n',
     ],
     clean: false
   },
@@ -207,7 +207,7 @@ const tests = [
       UP,                // 15
       DOWN,
       SEARCH_FORWARDS,   // 17
-      '\n'
+      '\n',
     ],
     expected: [
       '\x1B[1G', '\x1B[0J',
@@ -252,7 +252,7 @@ const tests = [
       '\x1B[1G', '\x1B[0J',
       `${prompt}ab = "aaaa"`, '\x1B[14G',
       '\x1B[1G', '\x1B[0J',
-      `${prompt}repl.repl.historyIndex`, '\x1B[25G', '\n// -1',
+      `${prompt}repl.repl.historyIndex`, '\x1B[25G', '\n// 8',
       '\x1B[25G', '\x1B[1A',
       '\x1B[1B', '\x1B[2K', '\x1B[1A',
       '\nfwd-i-search: _', '\x1B[1A', '\x1B[25G',
@@ -262,10 +262,10 @@ const tests = [
       '-1\n',
       '\x1B[1G', '\x1B[0J',
       prompt, '\x1B[3G',
-      '\r\n'
+      '\r\n',
     ],
     clean: false
-  }
+  },
 ];
 const numtests = tests.length;
 
diff --git a/test/parallel/test-repl-save-load.js b/test/parallel/test-repl-save-load.js
index f6ecc8d4ab67e9a9c91ff0e905ff237c516bdcbf..7fe535f6431adf7afa9eb45d1756abf1995383e2 100644
--- a/test/parallel/test-repl-save-load.js
+++ b/test/parallel/test-repl-save-load.js
@@ -46,7 +46,7 @@ testMe._domain.on('error', function(reason) {
 const testFile = [
   'let inner = (function() {',
   '  return {one:1};',
-  '})()'
+  '})()',
 ];
 const saveFileName = join(tmpdir.path, 'test.save.js');
 
@@ -61,8 +61,7 @@ assert.strictEqual(fs.readFileSync(saveFileName, 'utf8'),
                    testFile.join('\n'));
 
 // Make sure that the REPL data is "correct".
-testMe.complete('inner.o', common.mustCall(function(error, data) {
-  assert.ifError(error);
+testMe.complete('inner.o', common.mustSucceed((data) => {
   assert.deepStrictEqual(data, works);
 }));
 
@@ -73,8 +72,7 @@ putIn.run(['.clear']);
 putIn.run([`.load ${saveFileName}`]);
 
 // Make sure that the REPL data is "correct".
-testMe.complete('inner.o', common.mustCall(function(error, data) {
-  assert.ifError(error);
+testMe.complete('inner.o', common.mustSucceed((data) => {
   assert.deepStrictEqual(data, works);
 }));
 
@@ -123,7 +121,7 @@ putIn.run([`.save ${invalidFileName}`]);
   const cmds = [
     'function testSave() {',
     'return "saved";',
-    '}'
+    '}',
   ];
   const putIn = new ArrayStream();
   const replServer = repl.start({ terminal: true, stream: putIn });
diff --git a/test/parallel/test-repl-strict-mode-previews.js b/test/parallel/test-repl-strict-mode-previews.js
new file mode 100644
index 0000000000000000000000000000000000000000..8da4029e186b3c473388194dd4f8706a485aab59
--- /dev/null
+++ b/test/parallel/test-repl-strict-mode-previews.js
@@ -0,0 +1,46 @@
+// Previews in strict mode should indicate ReferenceErrors.
+
+'use strict';
+
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+if (process.argv[2] === 'child') {
+  const stream = require('stream');
+  const repl = require('repl');
+  class ActionStream extends stream.Stream {
+    readable = true;
+    run(data) {
+      this.emit('data', `${data}`);
+      this.emit('keypress', '', { ctrl: true, name: 'd' });
+    }
+    resume() {}
+    pause() {}
+  }
+
+  repl.start({
+    input: new ActionStream(),
+    output: new stream.Writable({
+      write(chunk, _, next) {
+        console.log(chunk.toString());
+        next();
+      }
+    }),
+    useColors: false,
+    terminal: true
+  }).inputStream.run('xyz');
+} else {
+  const assert = require('assert');
+  const { spawnSync } = require('child_process');
+
+  const result = spawnSync(
+    process.execPath,
+    ['--use-strict', `${__filename}`, 'child']
+  );
+
+  assert.match(
+    result.stdout.toString(),
+    /\/\/ ReferenceError: xyz is not defined/
+  );
+}
diff --git a/test/parallel/test-repl-tab-complete-import.js b/test/parallel/test-repl-tab-complete-import.js
new file mode 100644
index 0000000000000000000000000000000000000000..414b5cc4eac10374356f64e1cc8dc2a715a07ac8
--- /dev/null
+++ b/test/parallel/test-repl-tab-complete-import.js
@@ -0,0 +1,158 @@
+'use strict';
+
+const common = require('../common');
+const ArrayStream = require('../common/arraystream');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const { builtinModules } = require('module');
+const publicModules = builtinModules.filter(
+  (lib) => !lib.startsWith('_') && !lib.includes('/'),
+);
+
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
+// We have to change the directory to ../fixtures before requiring repl
+// in order to make the tests for completion of node_modules work properly
+// since repl modifies module.paths.
+process.chdir(fixtures.fixturesDir);
+
+const repl = require('repl');
+
+const putIn = new ArrayStream();
+const testMe = repl.start({
+  prompt: '',
+  input: putIn,
+  output: process.stdout,
+  allowBlockingCompletions: true
+});
+
+// Some errors are passed to the domain, but do not callback
+testMe._domain.on('error', assert.ifError);
+
+// Tab complete provides built in libs for import()
+testMe.complete('import(\'', common.mustCall((error, data) => {
+  assert.strictEqual(error, null);
+  publicModules.forEach((lib) => {
+    assert(
+      data[0].includes(lib) && data[0].includes(`node:${lib}`),
+      `${lib} not found`,
+    );
+  });
+  const newModule = 'foobar';
+  assert(!builtinModules.includes(newModule));
+  repl.builtinModules.push(newModule);
+  testMe.complete('import(\'', common.mustCall((_, [modules]) => {
+    assert.strictEqual(data[0].length + 1, modules.length);
+    assert(modules.includes(newModule) &&
+      !modules.includes(`node:${newModule}`));
+  }));
+}));
+
+testMe.complete("import\t( 'n", common.mustCall((error, data) => {
+  assert.strictEqual(error, null);
+  assert.strictEqual(data.length, 2);
+  assert.strictEqual(data[1], 'n');
+  const completions = data[0];
+  // import(...) completions include `node:` URL modules:
+  publicModules.forEach((lib, index) =>
+    assert.strictEqual(completions[index], `node:${lib}`));
+  assert.strictEqual(completions[publicModules.length], '');
+  // There is only one Node.js module that starts with n:
+  assert.strictEqual(completions[publicModules.length + 1], 'net');
+  assert.strictEqual(completions[publicModules.length + 2], '');
+  // It's possible to pick up non-core modules too
+  completions.slice(publicModules.length + 3).forEach((completion) => {
+    assert.match(completion, /^n/);
+  });
+}));
+
+{
+  const expected = ['@nodejsscope', '@nodejsscope/'];
+  // Import calls should handle all types of quotation marks.
+  for (const quotationMark of ["'", '"', '`']) {
+    putIn.run(['.clear']);
+    testMe.complete('import(`@nodejs', common.mustCall((err, data) => {
+      assert.strictEqual(err, null);
+      assert.deepStrictEqual(data, [expected, '@nodejs']);
+    }));
+
+    putIn.run(['.clear']);
+    // Completions should not be greedy in case the quotation ends.
+    const input = `import(${quotationMark}@nodejsscope${quotationMark}`;
+    testMe.complete(input, common.mustCall((err, data) => {
+      assert.strictEqual(err, null);
+      assert.deepStrictEqual(data, [[], undefined]);
+    }));
+  }
+}
+
+{
+  putIn.run(['.clear']);
+  // Completions should find modules and handle whitespace after the opening
+  // bracket.
+  testMe.complete('import \t("no_ind', common.mustCall((err, data) => {
+    assert.strictEqual(err, null);
+    assert.deepStrictEqual(data, [['no_index', 'no_index/'], 'no_ind']);
+  }));
+}
+
+// Test tab completion for import() relative to the current directory
+{
+  putIn.run(['.clear']);
+
+  const cwd = process.cwd();
+  process.chdir(__dirname);
+
+  ['import(\'.', 'import(".'].forEach((input) => {
+    testMe.complete(input, common.mustCall((err, data) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(data.length, 2);
+      assert.strictEqual(data[1], '.');
+      assert.strictEqual(data[0].length, 2);
+      assert.ok(data[0].includes('./'));
+      assert.ok(data[0].includes('../'));
+    }));
+  });
+
+  ['import(\'..', 'import("..'].forEach((input) => {
+    testMe.complete(input, common.mustCall((err, data) => {
+      assert.strictEqual(err, null);
+      assert.deepStrictEqual(data, [['../'], '..']);
+    }));
+  });
+
+  ['./', './test-'].forEach((path) => {
+    [`import('${path}`, `import("${path}`].forEach((input) => {
+      testMe.complete(input, common.mustCall((err, data) => {
+        assert.strictEqual(err, null);
+        assert.strictEqual(data.length, 2);
+        assert.strictEqual(data[1], path);
+        assert.ok(data[0].includes('./test-repl-tab-complete.js'));
+      }));
+    });
+  });
+
+  ['../parallel/', '../parallel/test-'].forEach((path) => {
+    [`import('${path}`, `import("${path}`].forEach((input) => {
+      testMe.complete(input, common.mustCall((err, data) => {
+        assert.strictEqual(err, null);
+        assert.strictEqual(data.length, 2);
+        assert.strictEqual(data[1], path);
+        assert.ok(data[0].includes('../parallel/test-repl-tab-complete.js'));
+      }));
+    });
+  });
+
+  {
+    const path = '../fixtures/repl-folder-extensions/f';
+    testMe.complete(`import('${path}`, common.mustSucceed((data) => {
+      assert.strictEqual(data.length, 2);
+      assert.strictEqual(data[1], path);
+      assert.ok(data[0].includes(
+        '../fixtures/repl-folder-extensions/foo.js/'));
+    }));
+  }
+
+  process.chdir(cwd);
+}
diff --git a/test/parallel/test-repl-tab-complete.js b/test/parallel/test-repl-tab-complete.js
index 6cf689c4b110741b89ba5535360e64ef023a94b6..9597c2a3480f3396b0f635694bdc86e0111f7817 100644
--- a/test/parallel/test-repl-tab-complete.js
+++ b/test/parallel/test-repl-tab-complete.js
@@ -30,6 +30,11 @@ const {
 const assert = require('assert');
 const path = require('path');
 const fixtures = require('../common/fixtures');
+const { builtinModules } = require('module');
+const publicModules = builtinModules.filter(
+  (lib) => !lib.startsWith('_') && !lib.includes('/'),
+);
+
 const hasInspector = process.features.inspector;
 
 if (!common.isMainThread)
@@ -43,15 +48,19 @@ process.chdir(fixtures.fixturesDir);
 const repl = require('repl');
 
 function getNoResultsFunction() {
-  return common.mustCall((err, data) => {
-    assert.ifError(err);
+  return common.mustSucceed((data) => {
     assert.deepStrictEqual(data[0], []);
   });
 }
 
 const works = [['inner.one'], 'inner.o'];
 const putIn = new ArrayStream();
-const testMe = repl.start('', putIn);
+const testMe = repl.start({
+  prompt: '',
+  input: putIn,
+  output: process.stdout,
+  allowBlockingCompletions: true
+});
 
 // Some errors are passed to the domain, but do not callback
 testMe._domain.on('error', assert.ifError);
@@ -59,7 +68,7 @@ testMe._domain.on('error', assert.ifError);
 // Tab Complete will not break in an object literal
 putIn.run([
   'var inner = {',
-  'one:1'
+  'one:1',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -67,6 +76,19 @@ testMe.complete('console.lo', common.mustCall(function(error, data) {
   assert.deepStrictEqual(data, [['console.log'], 'console.lo']);
 }));
 
+testMe.complete('console?.lo', common.mustCall((error, data) => {
+  assert.deepStrictEqual(data, [['console?.log'], 'console?.lo']);
+}));
+
+testMe.complete('console?.zzz', common.mustCall((error, data) => {
+  assert.deepStrictEqual(data, [[], 'console?.zzz']);
+}));
+
+testMe.complete('console?.', common.mustCall((error, data) => {
+  assert(data[0].includes('console?.log'));
+  assert.strictEqual(data[1], 'console?.');
+}));
+
 // Tab Complete will return globally scoped variables
 putIn.run(['};']);
 testMe.complete('inner.o', common.mustCall(function(error, data) {
@@ -79,7 +101,7 @@ putIn.run(['.clear']);
 putIn.run([
   'var inner = ( true ',
   '?',
-  '{one: 1} : '
+  '{one: 1} : ',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -88,7 +110,7 @@ putIn.run(['.clear']);
 // Tab Complete will return a simple local variable
 putIn.run([
   'var top = function() {',
-  'var inner = {one:1};'
+  'var inner = {one:1};',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -104,7 +126,7 @@ putIn.run([
   'var top = function() {',
   'var inner = {',
   ' one:1',
-  '};'
+  '};',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -116,7 +138,7 @@ putIn.run([
   'var top = function(one, two) {',
   'var inner = {',
   ' one:1',
-  '};'
+  '};',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -129,7 +151,7 @@ putIn.run([
   '(function test () {',
   'var inner = {',
   ' one:1',
-  '};'
+  '};',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -142,7 +164,7 @@ putIn.run([
   ' one, two) {',
   'var inner = {',
   ' one:1',
-  '};'
+  '};',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -155,7 +177,7 @@ putIn.run([
   '{',
   'var inner = {',
   ' one:1',
-  '};'
+  '};',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -169,7 +191,7 @@ putIn.run([
   '{',
   'var inner = {',
   ' one:1',
-  '};'
+  '};',
 ]);
 testMe.complete('inner.o', getNoResultsFunction());
 
@@ -177,7 +199,7 @@ putIn.run(['.clear']);
 
 // Make sure tab completion works on non-Objects
 putIn.run([
-  'var str = "test";'
+  'var str = "test";',
 ]);
 testMe.complete('str.len', common.mustCall(function(error, data) {
   assert.deepStrictEqual(data, [['str.length'], 'str.len']);
@@ -190,8 +212,7 @@ const spaceTimeout = setTimeout(function() {
   throw new Error('timeout');
 }, 1000);
 
-testMe.complete(' ', common.mustCall(function(error, data) {
-  assert.ifError(error);
+testMe.complete(' ', common.mustSucceed((data) => {
   assert.strictEqual(data[1], '');
   assert.ok(data[0].includes('globalThis'));
   clearTimeout(spaceTimeout);
@@ -211,7 +232,7 @@ putIn.run([
   'x.b = 2;',
   'var y = Object.create(x);',
   'y.a = 3;',
-  'y.c = 4;'
+  'y.c = 4;',
 ]);
 testMe.complete('y.', common.mustCall(function(error, data) {
   assert.deepStrictEqual(data, [['y.b', '', 'y.a', 'y.c'], 'y.']);
@@ -222,29 +243,65 @@ putIn.run(['.clear']);
 
 testMe.complete('require(\'', common.mustCall(function(error, data) {
   assert.strictEqual(error, null);
-  repl._builtinLibs.forEach(function(lib) {
-    assert(data[0].includes(lib), `${lib} not found`);
+  publicModules.forEach((lib) => {
+    assert(
+      data[0].includes(lib) && data[0].includes(`node:${lib}`),
+      `${lib} not found`
+    );
   });
+  const newModule = 'foobar';
+  assert(!builtinModules.includes(newModule));
+  repl.builtinModules.push(newModule);
+  testMe.complete('require(\'', common.mustCall((_, [modules]) => {
+    assert.strictEqual(data[0].length + 1, modules.length);
+    assert(modules.includes(newModule));
+  }));
 }));
 
-testMe.complete('require(\'n', common.mustCall(function(error, data) {
+testMe.complete("require\t( 'n", common.mustCall(function(error, data) {
   assert.strictEqual(error, null);
   assert.strictEqual(data.length, 2);
   assert.strictEqual(data[1], 'n');
-  assert(data[0].includes('net'));
+  // require(...) completions include `node:`-prefixed modules:
+  publicModules.forEach((lib, index) =>
+    assert.strictEqual(data[0][index], `node:${lib}`));
+  assert.strictEqual(data[0][publicModules.length], '');
+  // There is only one Node.js module that starts with n:
+  assert.strictEqual(data[0][publicModules.length + 1], 'net');
+  assert.strictEqual(data[0][publicModules.length + 2], '');
   // It's possible to pick up non-core modules too
-  data[0].forEach(function(completion) {
-    if (completion)
-      assert(/^n/.test(completion));
+  data[0].slice(publicModules.length + 3).forEach((completion) => {
+    assert.match(completion, /^n/);
   });
 }));
 
 {
   const expected = ['@nodejsscope', '@nodejsscope/'];
+  // Require calls should handle all types of quotation marks.
+  for (const quotationMark of ["'", '"', '`']) {
+    putIn.run(['.clear']);
+    testMe.complete('require(`@nodejs', common.mustCall((err, data) => {
+      assert.strictEqual(err, null);
+      assert.deepStrictEqual(data, [expected, '@nodejs']);
+    }));
+
+    putIn.run(['.clear']);
+    // Completions should not be greedy in case the quotation ends.
+    const input = `require(${quotationMark}@nodejsscope${quotationMark}`;
+    testMe.complete(input, common.mustCall((err, data) => {
+      assert.strictEqual(err, null);
+      assert.deepStrictEqual(data, [[], undefined]);
+    }));
+  }
+}
+
+{
   putIn.run(['.clear']);
-  testMe.complete('require(\'@nodejs', common.mustCall((err, data) => {
+  // Completions should find modules and handle whitespace after the opening
+  // bracket.
+  testMe.complete('require \t("no_ind', common.mustCall((err, data) => {
     assert.strictEqual(err, null);
-    assert.deepStrictEqual(data, [expected, '@nodejs']);
+    assert.deepStrictEqual(data, [['no_index', 'no_index/'], 'no_ind']);
   }));
 }
 
@@ -297,8 +354,7 @@ testMe.complete('require(\'n', common.mustCall(function(error, data) {
 
   {
     const path = '../fixtures/repl-folder-extensions/f';
-    testMe.complete(`require('${path}`, common.mustCall((err, data) => {
-      assert.ifError(err);
+    testMe.complete(`require('${path}`, common.mustSucceed((data) => {
       assert.strictEqual(data.length, 2);
       assert.strictEqual(data[1], path);
       assert.ok(data[0].includes('../fixtures/repl-folder-extensions/foo.js'));
@@ -312,7 +368,7 @@ testMe.complete('require(\'n', common.mustCall(function(error, data) {
 putIn.run(['.clear']);
 
 putIn.run([
-  'var custom = "test";'
+  'var custom = "test";',
 ]);
 testMe.complete('cus', common.mustCall(function(error, data) {
   assert.deepStrictEqual(data, [['custom'], 'cus']);
@@ -323,7 +379,7 @@ testMe.complete('cus', common.mustCall(function(error, data) {
 putIn.run(['.clear']);
 
 putIn.run([
-  'var proxy = new Proxy({}, {ownKeys: () => { throw new Error(); }});'
+  'var proxy = new Proxy({}, {ownKeys: () => { throw new Error(); }});',
 ]);
 
 testMe.complete('proxy.', common.mustCall(function(error, data) {
@@ -387,6 +443,18 @@ testMe.complete('obj.', common.mustCall((error, data) => {
   assert(data[0].includes('obj.key'));
 }));
 
+// Make sure tab completion does not include __defineSetter__ and friends.
+putIn.run(['.clear']);
+
+putIn.run(['var obj = {};']);
+testMe.complete('obj.', common.mustCall(function(error, data) {
+  assert.strictEqual(data[0].includes('obj.__defineGetter__'), false);
+  assert.strictEqual(data[0].includes('obj.__defineSetter__'), false);
+  assert.strictEqual(data[0].includes('obj.__lookupGetter__'), false);
+  assert.strictEqual(data[0].includes('obj.__lookupSetter__'), false);
+  assert.strictEqual(data[0].includes('obj.__proto__'), true);
+}));
+
 // Tab completion for files/directories
 {
   putIn.run(['.clear']);
@@ -459,7 +527,7 @@ testMe.complete('obj.', common.mustCall((error, data) => {
     putIn.run([
       'var ele = [];',
       'for (let i = 0; i < 1e6 + 1; i++) ele[i] = 0;',
-      'ele.biu = 1;'
+      'ele.biu = 1;',
     ]);
   } else if (type === Buffer) {
     putIn.run(['var ele = Buffer.alloc(1e6 + 1); ele.biu = 1;']);
@@ -489,7 +557,7 @@ testMe.complete('obj.', common.mustCall((error, data) => {
 
 // check Buffer.prototype.length not crashing.
 // Refs: https://github.com/nodejs/node/pull/11961
-putIn.run['.clear'];
+putIn.run(['.clear']);
 testMe.complete('Buffer.prototype.', common.mustCall());
 
 const testNonGlobal = repl.start({
@@ -527,7 +595,7 @@ const testCustomCompleterSyncMode = repl.start({
 testCustomCompleterSyncMode.complete('', common.mustCall((error, data) => {
   assert.deepStrictEqual(data, [
     customCompletions,
-    ''
+    '',
   ]);
 }));
 
@@ -535,7 +603,7 @@ testCustomCompleterSyncMode.complete('', common.mustCall((error, data) => {
 testCustomCompleterSyncMode.complete('a', common.mustCall((error, data) => {
   assert.deepStrictEqual(data, [
     'aaa aa1 aa2'.split(' '),
-    'a'
+    'a',
   ]);
 }));
 
@@ -557,7 +625,7 @@ const testCustomCompleterAsyncMode = repl.start({
 testCustomCompleterAsyncMode.complete('', common.mustCall((error, data) => {
   assert.deepStrictEqual(data, [
     customCompletions,
-    ''
+    '',
   ]);
 }));
 
@@ -565,7 +633,7 @@ testCustomCompleterAsyncMode.complete('', common.mustCall((error, data) => {
 testCustomCompleterAsyncMode.complete('a', common.mustCall((error, data) => {
   assert.deepStrictEqual(data, [
     'aaa aa1 aa2'.split(' '),
-    'a'
+    'a',
   ]);
 }));
 
diff --git a/test/parallel/test-repl-top-level-await.js b/test/parallel/test-repl-top-level-await.js
index 018d8707009ad9d6cf07c2505c5d0fff7b2aa8df..c3f016bf7030368c9858d4b9e127b033de382e9f 100644
--- a/test/parallel/test-repl-top-level-await.js
+++ b/test/parallel/test-repl-top-level-await.js
@@ -81,7 +81,7 @@ async function ordinaryTests() {
   // https://cs.chromium.org/chromium/src/third_party/WebKit/LayoutTests/http/tests/devtools/console/console-top-level-await.js?rcl=5d0ea979f0ba87655b7ef0e03b58fa3c04986ba6
   putIn.run([
     'function foo(x) { return x; }',
-    'function koo() { return Promise.resolve(4); }'
+    'function koo() { return Promise.resolve(4); }',
   ]);
   const testCases = [
     ['await Promise.resolve(0)', '0'],
@@ -139,9 +139,49 @@ async function ordinaryTests() {
        '1',
        '2',
        '3',
-       'undefined'
-     ]
-    ]
+       'undefined',
+     ],
+    ],
+    ['await Promise..resolve()',
+     [
+       'await Promise..resolve()\r',
+       'Uncaught SyntaxError: ',
+       'await Promise..resolve()',
+       '              ^',
+       '',
+       'Unexpected token \'.\'',
+     ],
+    ],
+    ['for (const x of [1,2,3]) {\nawait x\n}', [
+      'for (const x of [1,2,3]) {\r',
+      '... await x\r',
+      '... }\r',
+      'undefined',
+    ]],
+    ['for (const x of [1,2,3]) {\nawait x;\n}', [
+      'for (const x of [1,2,3]) {\r',
+      '... await x;\r',
+      '... }\r',
+      'undefined',
+    ]],
+    ['for await (const x of [1,2,3]) {\nconsole.log(x)\n}', [
+      'for await (const x of [1,2,3]) {\r',
+      '... console.log(x)\r',
+      '... }\r',
+      '1',
+      '2',
+      '3',
+      'undefined',
+    ]],
+    ['for await (const x of [1,2,3]) {\nconsole.log(x);\n}', [
+      'for await (const x of [1,2,3]) {\r',
+      '... console.log(x);\r',
+      '... }\r',
+      '1',
+      '2',
+      '3',
+      'undefined',
+    ]],
   ];
 
   for (const [input, expected = [`${input}\r`], options = {}] of testCases) {
@@ -164,24 +204,18 @@ async function ordinaryTests() {
 }
 
 async function ctrlCTest() {
-  putIn.run([
-    `const timeout = (msecs) => new Promise((resolve) => {
-       setTimeout(resolve, msecs).unref();
-     });`
-  ]);
-
   console.log('Testing Ctrl+C');
   assert.deepStrictEqual(await runAndWait([
-    'await timeout(100000)',
-    { ctrl: true, name: 'c' }
+    'await new Promise(() => {})',
+    { ctrl: true, name: 'c' },
   ]), [
-    'await timeout(100000)\r',
+    'await new Promise(() => {})\r',
     'Uncaught:',
     '[Error [ERR_SCRIPT_EXECUTION_INTERRUPTED]: ' +
       'Script execution was interrupted by `SIGINT`] {',
     "  code: 'ERR_SCRIPT_EXECUTION_INTERRUPTED'",
     '}',
-    PROMPT
+    PROMPT,
   ]);
 }
 
@@ -190,4 +224,4 @@ async function main() {
   await ctrlCTest();
 }
 
-main();
+main().then(common.mustCall());
diff --git a/test/parallel/test-repl-uncaught-exception-evalcallback.js b/test/parallel/test-repl-uncaught-exception-evalcallback.js
new file mode 100644
index 0000000000000000000000000000000000000000..a6f6e341049d6cbcf36db1ac5de7bb9e1592afee
--- /dev/null
+++ b/test/parallel/test-repl-uncaught-exception-evalcallback.js
@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const repl = require('repl');
+const { PassThrough } = require('stream');
+const input = new PassThrough();
+const output = new PassThrough();
+
+const r = repl.start({
+  input, output,
+  eval: common.mustCall((code, context, filename, cb) => {
+    r.setPrompt('prompt! ');
+    cb(new Error('err'));
+  })
+});
+
+input.end('foo\n');
+
+// The output includes exactly one post-error prompt.
+const out = output.read().toString();
+assert.match(out, /prompt!/);
+assert.doesNotMatch(out, /prompt![\S\s]*prompt!/);
+output.on('data', common.mustNotCall());
diff --git a/test/parallel/test-repl-uncaught-exception-standalone.js b/test/parallel/test-repl-uncaught-exception-standalone.js
index e7371f9f7c617ff64507f64b38c600e6a35dd420..8edf47b243689505903cbe1a35268581c0a8f0f7 100644
--- a/test/parallel/test-repl-uncaught-exception-standalone.js
+++ b/test/parallel/test-repl-uncaught-exception-standalone.js
@@ -24,7 +24,7 @@ child.on('exit', common.mustCall(() => {
       'undefined',
       // x\n
       '> Foobar',
-      '> '
+      '> ',
     ]
   );
 }));
diff --git a/test/parallel/test-repl-uncaught-exception.js b/test/parallel/test-repl-uncaught-exception.js
index 28e62dff22bf3a8b4713383d21351fbe835c4f8e..9d443b4e2ca553940c17da950896aa9ceadd6be5 100644
--- a/test/parallel/test-repl-uncaught-exception.js
+++ b/test/parallel/test-repl-uncaught-exception.js
@@ -64,7 +64,7 @@ const tests = [
     command: 'console.log("Baz");' +
              'process.on("uncaughtException", () => console.log("Foobar"));\n',
     expected: /^Baz\nUncaught:\nTypeError \[ERR_INVALID_REPL_INPUT]:.*uncaughtException/
-  }
+  },
 ];
 
 process.on('exit', () => {
diff --git a/test/parallel/test-repl-underscore.js b/test/parallel/test-repl-underscore.js
index c05c387471b59fdc8d98ec87feef8a7609e7e7b0..1802f8b8ff1e862234b0d4fa66691e79399d27d7 100644
--- a/test/parallel/test-repl-underscore.js
+++ b/test/parallel/test-repl-underscore.js
@@ -41,7 +41,7 @@ function testSloppyMode() {
     '30',
     '30',
     '40',
-    '30'
+    '30',
   ]);
 }
 
@@ -74,7 +74,7 @@ function testStrictMode() {
     '30',
     'undefined',
     'undefined',
-    '30'
+    '30',
   ]);
 }
 
@@ -107,7 +107,7 @@ function testMagicMode() {
     '30',
     'undefined',
     '50',
-    '30'
+    '30',
   ]);
 }
 
@@ -129,7 +129,7 @@ function testResetContext() {
     'Clearing context...',
     '10',
     '20',
-    '20'
+    '20',
   ]);
 }
 
@@ -216,7 +216,7 @@ function testError() {
       'Expression assignment to _error now disabled.',
       '0',
       'Uncaught Error: quux',
-      '0'
+      '0',
     ]);
   });
 }
diff --git a/test/parallel/test-repl-unexpected-token-recoverable.js b/test/parallel/test-repl-unexpected-token-recoverable.js
index 2461d8f62bd2c8b2b99e9f3460fc604ac31e8aea..242b86479ab1952c370be4a443544db290af396e 100644
--- a/test/parallel/test-repl-unexpected-token-recoverable.js
+++ b/test/parallel/test-repl-unexpected-token-recoverable.js
@@ -1,7 +1,7 @@
 'use strict';
-/*
- * This is a regression test for https://github.com/joyent/node/issues/8874.
- */
+
+// This is a regression test for https://github.com/joyent/node/issues/8874.
+
 require('../common');
 const assert = require('assert');
 
diff --git a/test/parallel/test-repl-unsafe-array-iteration.js b/test/parallel/test-repl-unsafe-array-iteration.js
new file mode 100644
index 0000000000000000000000000000000000000000..3fc65f54cf1f3714ff15fd500d9f2530abf02e64
--- /dev/null
+++ b/test/parallel/test-repl-unsafe-array-iteration.js
@@ -0,0 +1,68 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { spawn } = require('child_process');
+
+const replProcess = spawn(process.argv0, ['--interactive'], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  windowsHide: true,
+});
+
+replProcess.on('error', common.mustNotCall());
+
+const replReadyState = (async function* () {
+  let ready;
+  const SPACE = ' '.charCodeAt();
+  const BRACKET = '>'.charCodeAt();
+  const DOT = '.'.charCodeAt();
+  replProcess.stdout.on('data', (data) => {
+    ready = data[data.length - 1] === SPACE && (
+      data[data.length - 2] === BRACKET || (
+        data[data.length - 2] === DOT &&
+        data[data.length - 3] === DOT &&
+        data[data.length - 4] === DOT
+      ));
+  });
+
+  const processCrashed = new Promise((resolve, reject) =>
+    replProcess.on('exit', reject)
+  );
+  while (true) {
+    await Promise.race([new Promise(setImmediate), processCrashed]);
+    if (ready) {
+      ready = false;
+      yield;
+    }
+  }
+})();
+async function writeLn(data, expectedOutput) {
+  await replReadyState.next();
+  if (expectedOutput) {
+    replProcess.stdout.once('data', common.mustCall((data) =>
+      assert.match(data.toString('utf8'), expectedOutput)
+    ));
+  }
+  await new Promise((resolve, reject) => replProcess.stdin.write(
+    `${data}\n`,
+    (err) => (err ? reject(err) : resolve())
+  ));
+}
+
+async function main() {
+  await writeLn(
+    'const ArrayIteratorPrototype =' +
+      '  Object.getPrototypeOf(Array.prototype[Symbol.iterator]());'
+  );
+  await writeLn('delete Array.prototype[Symbol.iterator];');
+  await writeLn('delete ArrayIteratorPrototype.next;');
+
+  await writeLn(
+    'for(const x of [3, 2, 1]);',
+    /Uncaught TypeError: \[3,2,1\] is not iterable/
+  );
+  await writeLn('.exit');
+
+  assert(!replProcess.connected);
+}
+
+main().then(common.mustCall());
diff --git a/test/parallel/test-repl-use-global.js b/test/parallel/test-repl-use-global.js
index 00222608deca6f6ee1bd360b922dab2642b61ae1..3457d0c5ba721080a08b7c51af78d8d71b1761e4 100644
--- a/test/parallel/test-repl-use-global.js
+++ b/test/parallel/test-repl-use-global.js
@@ -11,7 +11,7 @@ const assert = require('assert');
 const globalTestCases = [
   [false, 'undefined'],
   [true, '\'tacos\''],
-  [undefined, 'undefined']
+  [undefined, 'undefined'],
 ];
 
 const globalTest = (useGlobal, cb, output) => (err, repl) => {
@@ -29,8 +29,7 @@ const globalTest = (useGlobal, cb, output) => (err, repl) => {
 
 // Test how the global object behaves in each state for useGlobal
 for (const [option, expected] of globalTestCases) {
-  runRepl(option, globalTest, common.mustCall((err, output) => {
-    assert.ifError(err);
+  runRepl(option, globalTest, common.mustSucceed((output) => {
     assert.strictEqual(output, expected);
   }));
 }
@@ -58,8 +57,7 @@ const processTest = (useGlobal, cb, output) => (err, repl) => {
 };
 
 for (const option of processTestCases) {
-  runRepl(option, processTest, common.mustCall((err, output) => {
-    assert.ifError(err);
+  runRepl(option, processTest, common.mustSucceed((output) => {
     assert.strictEqual(output, 'undefined\n42');
   }));
 }
diff --git a/test/parallel/test-repl.js b/test/parallel/test-repl.js
index ee1650be1c914044f189b7d132b325cbf00a3695..bbb95f3fa39f68321ced539642f51f63da6a11e1 100644
--- a/test/parallel/test-repl.js
+++ b/test/parallel/test-repl.js
@@ -120,14 +120,14 @@ const unixTests = [
   {
     send: '{a:1}',
     expect: '{ a: 1 }'
-  }
+  },
 ];
 
 const strictModeTests = [
   {
     send: 'ref = 1',
     expect: [/^Uncaught ReferenceError:\s/]
-  }
+  },
 ];
 
 const errorTests = [
@@ -242,7 +242,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -251,7 +251,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -260,7 +260,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -269,7 +269,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -278,7 +278,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -288,7 +288,7 @@ const errorTests = [
       kArrow,
       '',
       'Uncaught:',
-      /^SyntaxError: /
+      /^SyntaxError: /,
     ]
   },
   // Named functions can be used:
@@ -303,7 +303,7 @@ const errorTests = [
   // Functions should not evaluate twice (#2773)
   {
     send: 'var I = [1,2,3,function() {}]; I.pop()',
-    expect: '[Function]'
+    expect: '[Function (anonymous)]'
   },
   // Multiline object
   {
@@ -372,8 +372,8 @@ const errorTests = [
   {
     send: 'npm install foobar',
     expect: [
-      'npm should be run outside of the node repl, in your normal shell.',
-      '(Press Control-D to exit.)'
+      'npm should be run outside of the Node.js REPL, in your normal shell.',
+      '(Press Ctrl+D to exit.)',
     ]
   },
   {
@@ -411,7 +411,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   // Do not fail when a String is created with line continuation
@@ -453,8 +453,8 @@ const errorTests = [
       /\.load/,
       /\.save/,
       '',
-      'Press ^C to abort current expression, ^D to exit the repl',
-      /'thefourtheye'/
+      'Press Ctrl+C to abort current expression, Ctrl+D to exit the REPL',
+      /'thefourtheye'/,
     ]
   },
   // Check for wrapped objects.
@@ -468,7 +468,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -573,7 +573,7 @@ const errorTests = [
       /^    at .*/,
       "  code: 'MODULE_NOT_FOUND',",
       "  requireStack: [ '<repl>' ]",
-      '}'
+      '}',
     ]
   },
   // REPL should handle quotes within regexp literal in multiline mode
@@ -605,7 +605,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   // Mitigate https://github.com/nodejs/node/issues/548
@@ -624,7 +624,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   // Avoid emitting stack trace
@@ -634,7 +634,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
 
@@ -702,7 +702,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   // Bring back the repl to prompt
@@ -716,7 +716,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -725,7 +725,7 @@ const errorTests = [
       '... ... {',
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -734,7 +734,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -751,7 +751,7 @@ const errorTests = [
       kSource,
       kArrow,
       '',
-      /^Uncaught SyntaxError: /
+      /^Uncaught SyntaxError: /,
     ]
   },
   {
@@ -813,9 +813,9 @@ const tcpTests = [
       kArrow,
       '',
       'Uncaught:',
-      /^SyntaxError: .* dynamic import/
+      /^SyntaxError: .* dynamic import/,
     ]
-  }
+  },
 ];
 
 (async function() {
@@ -837,7 +837,7 @@ const tcpTests = [
     socket.end();
   }
   common.allowGlobals(...Object.values(global));
-})();
+})().then(common.mustCall());
 
 function startTCPRepl() {
   let resolveSocket, resolveReplServer;
@@ -871,7 +871,7 @@ function startTCPRepl() {
 
   return Promise.all([
     new Promise((resolve) => resolveSocket = resolve),
-    new Promise((resolve) => resolveReplServer = resolve)
+    new Promise((resolve) => resolveReplServer = resolve),
   ]);
 }
 
@@ -916,7 +916,7 @@ function startUnixRepl() {
 
   return Promise.all([
     new Promise((resolve) => resolveSocket = resolve),
-    new Promise((resolve) => resolveReplServer = resolve)
+    new Promise((resolve) => resolveReplServer = resolve),
   ]);
 }
 
@@ -926,7 +926,7 @@ function event(ee, expected) {
       const data = inspect(expected, { compact: false });
       const msg = `The REPL did not reply as expected for:\n\n${data}`;
       reject(new Error(msg));
-    }, common.platformTimeout(1000));
+    }, common.platformTimeout(9999));
     ee.once('data', common.mustCall((...args) => {
       clearTimeout(timeout);
       resolve(...args);
diff --git a/test/parallel/test-require-extension-over-directory.js b/test/parallel/test-require-extension-over-directory.js
index 922587615139196a625859967bd4d6088a3741c8..d1f7407e3d0ebe7e1951d741a5666bc46ca81c67 100644
--- a/test/parallel/test-require-extension-over-directory.js
+++ b/test/parallel/test-require-extension-over-directory.js
@@ -18,7 +18,7 @@ assert.strictEqual(
 const fakePath = [
   fixtures.path('module-extension-over-directory', 'inner'),
   'fake',
-  '..'
+  '..',
 ].join(path.sep);
 const fixturesRequireDir = require(fakePath);
 
diff --git a/test/parallel/test-require-node-prefix.js b/test/parallel/test-require-node-prefix.js
new file mode 100644
index 0000000000000000000000000000000000000000..957cabf13aeb114a1e74bd5438ab397a91a36d93
--- /dev/null
+++ b/test/parallel/test-require-node-prefix.js
@@ -0,0 +1,42 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const errUnknownBuiltinModuleRE = /^No such built-in module: /u;
+
+// For direct use of require expressions inside of CJS modules,
+// all kinds of specifiers should work without issue.
+{
+  assert.strictEqual(require('fs'), fs);
+  assert.strictEqual(require('node:fs'), fs);
+
+  assert.throws(
+    () => require('node:unknown'),
+    {
+      code: 'ERR_UNKNOWN_BUILTIN_MODULE',
+      message: errUnknownBuiltinModuleRE,
+    },
+  );
+
+  assert.throws(
+    () => require('node:internal/test/binding'),
+    {
+      code: 'ERR_UNKNOWN_BUILTIN_MODULE',
+      message: errUnknownBuiltinModuleRE,
+    },
+  );
+}
+
+// `node:`-prefixed `require(...)` calls bypass the require cache:
+{
+  const fakeModule = {};
+
+  require.cache.fs = { exports: fakeModule };
+
+  assert.strictEqual(require('fs'), fakeModule);
+  assert.strictEqual(require('node:fs'), fs);
+
+  delete require.cache.fs;
+}
diff --git a/test/parallel/test-resource-usage.js b/test/parallel/test-resource-usage.js
index ff41452f4a7f3b68f2d09c39b033ff2b6de4220a..d46fe4aeb7acc169fafe7723da522f9c1dfddfaf 100644
--- a/test/parallel/test-resource-usage.js
+++ b/test/parallel/test-resource-usage.js
@@ -19,7 +19,7 @@ const fields = [
   'ipcReceived',
   'signalsCount',
   'voluntaryContextSwitches',
-  'involuntaryContextSwitches'
+  'involuntaryContextSwitches',
 ];
 
 assert.deepStrictEqual(Object.keys(rusage).sort(), fields.sort());
diff --git a/test/parallel/test-revert-CVE-2021-44531.js b/test/parallel/test-revert-CVE-2021-44531.js
new file mode 100644
index 0000000000000000000000000000000000000000..56571730d4a14e3676239fbd258a7ab0c5c1c6e6
--- /dev/null
+++ b/test/parallel/test-revert-CVE-2021-44531.js
@@ -0,0 +1,64 @@
+// Flags: --security-revert=CVE-2021-44531
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const util = require('util');
+
+const tls = require('tls');
+
+common.expectWarning('DeprecationWarning', [
+  ['The URI http://[a.b.a.com]/ found in cert.subjectaltname ' +
+  'is not a valid URI, and is supported in the tls module ' +
+  'solely for compatibility.',
+   'DEP0109'],
+]);
+
+const tests = [
+  // Likewise for "URI:" Subject Alternative Names.
+  // See also https://github.com/nodejs/node/issues/8108.
+  {
+    host: '8.8.8.8',
+    cert: { subject: { CN: '8.8.8.8' }, subjectaltname: 'URI:http://8.8.8.8/' },
+    error: 'IP: 8.8.8.8 is not in the cert\'s list: '
+  },
+  // Empty Subject w/URI name
+  {
+    host: 'a.b.a.com', cert: {
+      subjectaltname: 'URI:http://a.b.a.com/',
+    }
+  },
+  // URI names
+  {
+    host: 'a.b.a.com', cert: {
+      subjectaltname: 'URI:http://a.b.a.com/',
+      subject: {}
+    }
+  },
+  {
+    host: 'a.b.a.com', cert: {
+      subjectaltname: 'URI:http://*.b.a.com/',
+      subject: {}
+    },
+    error: 'Host: a.b.a.com. is not in the cert\'s altnames: ' +
+           'URI:http://*.b.a.com/'
+  },
+  // Invalid URI
+  {
+    host: 'a.b.a.com', cert: {
+      subjectaltname: 'URI:http://[a.b.a.com]/',
+      subject: {}
+    }
+  },
+];
+
+tests.forEach(function(test, i) {
+  const err = tls.checkServerIdentity(test.host, test.cert);
+  assert.strictEqual(err && err.reason,
+                     test.error,
+                     `Test# ${i} failed: ${util.inspect(test)} \n` +
+                     `${test.error} != ${(err && err.reason)}`);
+});
diff --git a/test/sequential/test-set-http-max-http-headers.js b/test/parallel/test-set-http-max-http-headers.js
similarity index 33%
rename from test/sequential/test-set-http-max-http-headers.js
rename to test/parallel/test-set-http-max-http-headers.js
index 81d9d308b9b79d72414a3e7abe35bfba50c41a69..c4df779d2bd4fa601f0947ef49492e9c19b75f59 100644
--- a/test/sequential/test-set-http-max-http-headers.js
+++ b/test/parallel/test-set-http-max-http-headers.js
@@ -5,7 +5,6 @@ const assert = require('assert');
 const { spawn } = require('child_process');
 const path = require('path');
 const testName = path.join(__dirname, 'test-http-max-http-headers.js');
-const parsers = ['legacy', 'llhttp'];
 
 const timeout = common.platformTimeout(100);
 
@@ -15,16 +14,58 @@ function test(fn) {
   tests.push(fn);
 }
 
-parsers.forEach((parser) => {
+test(function(cb) {
+  console.log('running subtest expecting failure');
+
+  // Validate that the test fails if the max header size is too small.
+  const args = ['--expose-internals',
+                '--max-http-header-size=1024',
+                testName];
+  const cp = spawn(process.execPath, args, { stdio: 'inherit' });
+
+  cp.on('close', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 1);
+    assert.strictEqual(signal, null);
+    cb();
+  }));
+});
+
+test(function(cb) {
+  console.log('running subtest expecting success');
+
+  const env = Object.assign({}, process.env, {
+    NODE_DEBUG: 'http'
+  });
+
+  // Validate that the test now passes if the same limit is large enough.
+  const args = ['--expose-internals',
+                '--max-http-header-size=1024',
+                testName,
+                '1024'];
+  const cp = spawn(process.execPath, args, {
+    env,
+    stdio: 'inherit'
+  });
+
+  cp.on('close', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+    cb();
+  }));
+});
+
+// Next, repeat the same checks using NODE_OPTIONS if it is supported.
+if (!process.config.variables.node_without_node_options) {
+  const env = Object.assign({}, process.env, {
+    NODE_OPTIONS: '--max-http-header-size=1024'
+  });
+
   test(function(cb) {
     console.log('running subtest expecting failure');
 
     // Validate that the test fails if the max header size is too small.
-    const args = ['--expose-internals',
-                  `--http-parser=${parser}`,
-                  '--max-http-header-size=1024',
-                  testName];
-    const cp = spawn(process.execPath, args, { stdio: 'inherit' });
+    const args = ['--expose-internals', testName];
+    const cp = spawn(process.execPath, args, { env, stdio: 'inherit' });
 
     cp.on('close', common.mustCall((code, signal) => {
       assert.strictEqual(code, 1);
@@ -34,23 +75,9 @@ parsers.forEach((parser) => {
   });
 
   test(function(cb) {
-    console.log('running subtest expecting success');
-
-    const env = Object.assign({}, process.env, {
-      NODE_DEBUG: 'http'
-    });
-
-    // Validate that the test fails if the max header size is too small.
-    // Validate that the test now passes if the same limit becomes large enough.
-    const args = ['--expose-internals',
-                  `--http-parser=${parser}`,
-                  '--max-http-header-size=1024',
-                  testName,
-                  '1024'];
-    const cp = spawn(process.execPath, args, {
-      env,
-      stdio: 'inherit'
-    });
+    // Validate that the test now passes if the same limit is large enough.
+    const args = ['--expose-internals', testName, '1024'];
+    const cp = spawn(process.execPath, args, { env, stdio: 'inherit' });
 
     cp.on('close', common.mustCall((code, signal) => {
       assert.strictEqual(code, 0);
@@ -58,41 +85,7 @@ parsers.forEach((parser) => {
       cb();
     }));
   });
-
-  // Next, repeat the same checks using NODE_OPTIONS if it is supported.
-  if (!process.config.variables.node_without_node_options) {
-    const env = Object.assign({}, process.env, {
-      NODE_OPTIONS: `--http-parser=${parser} --max-http-header-size=1024`
-    });
-
-    test(function(cb) {
-      console.log('running subtest expecting failure');
-
-      // Validate that the test fails if the max header size is too small.
-      const args = ['--expose-internals', testName];
-      const cp = spawn(process.execPath, args, { env, stdio: 'inherit' });
-
-      cp.on('close', common.mustCall((code, signal) => {
-        assert.strictEqual(code, 1);
-        assert.strictEqual(signal, null);
-        cb();
-      }));
-    });
-
-    test(function(cb) {
-      // Validate that the test now passes if the same limit
-      // becomes large enough.
-      const args = ['--expose-internals', testName, '1024'];
-      const cp = spawn(process.execPath, args, { env, stdio: 'inherit' });
-
-      cp.on('close', common.mustCall((code, signal) => {
-        assert.strictEqual(code, 0);
-        assert.strictEqual(signal, null);
-        cb();
-      }));
-    });
-  }
-});
+}
 
 function runTest() {
   const fn = tests.shift();
diff --git a/test/parallel/test-setproctitle.js b/test/parallel/test-setproctitle.js
index ee146428a98f46ef7931973866c386e2e42ef11a..46288e8156edde9a016ecdcc8d08e758d08938ee 100644
--- a/test/parallel/test-setproctitle.js
+++ b/test/parallel/test-setproctitle.js
@@ -34,8 +34,7 @@ const cmd = common.isLinux ?
   `ps -o pid,args | grep '${process.pid} ${title}' | grep -v grep` :
   `ps -p ${process.pid} -o args=`;
 
-exec(cmd, common.mustCall((error, stdout, stderr) => {
-  assert.ifError(error);
+exec(cmd, common.mustSucceed((stdout, stderr) => {
   assert.strictEqual(stderr, '');
 
   // Freebsd always add ' (procname)' to the process title
diff --git a/test/parallel/test-socketaddress.js b/test/parallel/test-socketaddress.js
new file mode 100644
index 0000000000000000000000000000000000000000..877f70793b1f87e9079faa80a227f370a0f4dcbf
--- /dev/null
+++ b/test/parallel/test-socketaddress.js
@@ -0,0 +1,113 @@
+'use strict';
+
+const common = require('../common');
+const {
+  ok,
+  strictEqual,
+  throws,
+} = require('assert');
+const {
+  SocketAddress,
+} = require('net');
+const {
+  MessageChannel,
+} = require('worker_threads');
+
+{
+  const sa = new SocketAddress();
+  strictEqual(sa.address, '127.0.0.1');
+  strictEqual(sa.port, 0);
+  strictEqual(sa.family, 'ipv4');
+  strictEqual(sa.flowlabel, 0);
+
+  const mc = new MessageChannel();
+  mc.port1.onmessage = common.mustCall(({ data }) => {
+    ok(SocketAddress.isSocketAddress(data));
+
+    strictEqual(data.address, '127.0.0.1');
+    strictEqual(data.port, 0);
+    strictEqual(data.family, 'ipv4');
+    strictEqual(data.flowlabel, 0);
+
+    mc.port1.close();
+  });
+  mc.port2.postMessage(sa);
+}
+
+{
+  const sa = new SocketAddress({});
+  strictEqual(sa.address, '127.0.0.1');
+  strictEqual(sa.port, 0);
+  strictEqual(sa.family, 'ipv4');
+  strictEqual(sa.flowlabel, 0);
+}
+
+{
+  const sa = new SocketAddress({
+    address: '123.123.123.123',
+  });
+  strictEqual(sa.address, '123.123.123.123');
+  strictEqual(sa.port, 0);
+  strictEqual(sa.family, 'ipv4');
+  strictEqual(sa.flowlabel, 0);
+}
+
+{
+  const sa = new SocketAddress({
+    address: '123.123.123.123',
+    port: 80
+  });
+  strictEqual(sa.address, '123.123.123.123');
+  strictEqual(sa.port, 80);
+  strictEqual(sa.family, 'ipv4');
+  strictEqual(sa.flowlabel, 0);
+}
+
+{
+  const sa = new SocketAddress({
+    family: 'ipv6'
+  });
+  strictEqual(sa.address, '::');
+  strictEqual(sa.port, 0);
+  strictEqual(sa.family, 'ipv6');
+  strictEqual(sa.flowlabel, 0);
+}
+
+{
+  const sa = new SocketAddress({
+    family: 'ipv6',
+    flowlabel: 1,
+  });
+  strictEqual(sa.address, '::');
+  strictEqual(sa.port, 0);
+  strictEqual(sa.family, 'ipv6');
+  strictEqual(sa.flowlabel, 1);
+}
+
+[1, false, 'hello'].forEach((i) => {
+  throws(() => new SocketAddress(i), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+});
+
+[1, false, {}, [], 'test'].forEach((family) => {
+  throws(() => new SocketAddress({ family }), {
+    code: 'ERR_INVALID_ARG_VALUE'
+  });
+});
+
+[1, false, {}, []].forEach((address) => {
+  throws(() => new SocketAddress({ address }), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+});
+
+[-1, false, {}, []].forEach((port) => {
+  throws(() => new SocketAddress({ port }), {
+    code: 'ERR_SOCKET_BAD_PORT'
+  });
+});
+
+throws(() => new SocketAddress({ flowlabel: -1 }), {
+  code: 'ERR_OUT_OF_RANGE'
+});
diff --git a/test/parallel/test-source-map-api.js b/test/parallel/test-source-map-api.js
index 60bbb661e1c801e401531b66dd24994819c3400f..b8ff59e365e2e9afcc423e295d0a6322c3149925 100644
--- a/test/parallel/test-source-map-api.js
+++ b/test/parallel/test-source-map-api.js
@@ -1,11 +1,26 @@
 // Flags: --enable-source-maps
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const { findSourceMap, SourceMap } = require('module');
 const { readFileSync } = require('fs');
 
+// It should throw with invalid args.
+{
+  [1, true, 'foo'].forEach((invalidArg) =>
+    assert.throws(
+      () => new SourceMap(invalidArg),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError',
+        message: 'The "payload" argument must be of type object.' +
+               common.invalidArgTypeHelper(invalidArg)
+      }
+    )
+  );
+}
+
 // findSourceMap() can lookup source-maps based on URIs, in the
 // non-exceptional case.
 {
@@ -31,7 +46,7 @@ const { readFileSync } = require('fs');
   Error.prepareStackTrace = (error, trace) => {
     const throwingRequireCallSite = trace[0];
     if (throwingRequireCallSite.getFileName().endsWith('typescript-throw.js')) {
-      sourceMap = findSourceMap(throwingRequireCallSite.getFileName(), error);
+      sourceMap = findSourceMap(throwingRequireCallSite.getFileName());
       callSite = throwingRequireCallSite;
     }
   };
@@ -39,6 +54,7 @@ const { readFileSync } = require('fs');
     // Require a file that throws an exception, and has a source map.
     require('../fixtures/source-map/typescript-throw.js');
   } catch (err) {
+    // eslint-disable-next-line no-unused-expressions
     err.stack; // Force prepareStackTrace() to be called.
   }
   assert(callSite);
diff --git a/test/parallel/test-source-map-enable.js b/test/parallel/test-source-map-enable.js
index 71130441438dcc6285d0ef454632cf4033108ef8..eab718813fc37935d07f20516bbf1cbabf062d46 100644
--- a/test/parallel/test-source-map-enable.js
+++ b/test/parallel/test-source-map-enable.js
@@ -8,6 +8,7 @@ const { dirname } = require('path');
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { pathToFileURL } = require('url');
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
@@ -22,7 +23,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/basic')
+    require.resolve('../fixtures/source-map/basic'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (output.status !== 0) {
     console.log(output.stderr.toString());
@@ -37,7 +38,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/sigint')
+    require.resolve('../fixtures/source-map/sigint'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (!common.isWindows) {
     if (output.signal !== 'SIGINT') {
@@ -54,7 +55,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/exit-1')
+    require.resolve('../fixtures/source-map/exit-1'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   assert.strictEqual(output.stderr.toString(), '');
   const sourceMap = getSourceMapFromCache('exit-1.js', coverageDirectory);
@@ -66,7 +67,7 @@ function nextdir() {
   const coverageDirectory = nextdir();
   const output = spawnSync(process.execPath, [
     '--no-warnings',
-    require.resolve('../fixtures/source-map/esm-basic.mjs')
+    require.resolve('../fixtures/source-map/esm-basic.mjs'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   assert.strictEqual(output.stderr.toString(), '');
   const sourceMap = getSourceMapFromCache('esm-basic.mjs', coverageDirectory);
@@ -77,7 +78,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/disk-relative-path')
+    require.resolve('../fixtures/source-map/disk-relative-path'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   assert.strictEqual(output.status, 0);
   assert.strictEqual(output.stderr.toString(), '');
@@ -88,8 +89,8 @@ function nextdir() {
   // Source-map should have been loaded from disk and sources should have been
   // rewritten, such that they're absolute paths.
   assert.strictEqual(
-    dirname(
-      `file://${require.resolve('../fixtures/source-map/disk-relative-path')}`),
+    dirname(pathToFileURL(
+      require.resolve('../fixtures/source-map/disk-relative-path')).href),
     dirname(sourceMap.data.sources[0])
   );
 }
@@ -98,7 +99,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/inline-base64.js')
+    require.resolve('../fixtures/source-map/inline-base64.js'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   assert.strictEqual(output.status, 0);
   assert.strictEqual(output.stderr.toString(), '');
@@ -109,8 +110,8 @@ function nextdir() {
   // base64 JSON should have been decoded, and paths to sources should have
   // been rewritten such that they're absolute:
   assert.strictEqual(
-    dirname(
-      `file://${require.resolve('../fixtures/source-map/inline-base64')}`),
+    dirname(pathToFileURL(
+      require.resolve('../fixtures/source-map/inline-base64')).href),
     dirname(sourceMap.data.sources[0])
   );
 }
@@ -119,7 +120,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/inline-base64-type-error.js')
+    require.resolve('../fixtures/source-map/inline-base64-type-error.js'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   assert.strictEqual(output.status, 0);
   assert.strictEqual(output.stderr.toString(), '');
@@ -135,7 +136,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/inline-base64-json-error.js')
+    require.resolve('../fixtures/source-map/inline-base64-json-error.js'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   assert.strictEqual(output.status, 0);
   assert.strictEqual(output.stderr.toString(), '');
@@ -151,14 +152,14 @@ function nextdir() {
 // is not set.
 {
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/uglify-throw.js')
+    require.resolve('../fixtures/source-map/uglify-throw.js'),
   ]);
   assert.strictEqual(
-    output.stderr.toString().match(/->.*uglify-throw-original\.js:5:9/),
+    output.stderr.toString().match(/.*uglify-throw-original\.js:5:9/),
     null
   );
   assert.strictEqual(
-    output.stderr.toString().match(/->.*uglify-throw-original\.js:9:3/),
+    output.stderr.toString().match(/.*uglify-throw-original\.js:9:3/),
     null
   );
 }
@@ -167,34 +168,37 @@ function nextdir() {
 {
   const output = spawnSync(process.execPath, [
     '--enable-source-maps',
-    require.resolve('../fixtures/source-map/uglify-throw.js')
+    require.resolve('../fixtures/source-map/uglify-throw.js'),
   ]);
-  assert.ok(
-    output.stderr.toString().match(/->.*uglify-throw-original\.js:5:9/)
+  assert.match(
+    output.stderr.toString(),
+    /.*uglify-throw-original\.js:5:9/
   );
-  assert.ok(
-    output.stderr.toString().match(/->.*uglify-throw-original\.js:9:3/)
+  assert.match(
+    output.stderr.toString(),
+    /.*uglify-throw-original\.js:9:3/
   );
+  assert.match(output.stderr.toString(), /at Hello/);
 }
 
 // Applies source-maps generated by tsc to stack trace.
 {
   const output = spawnSync(process.execPath, [
     '--enable-source-maps',
-    require.resolve('../fixtures/source-map/typescript-throw.js')
+    require.resolve('../fixtures/source-map/typescript-throw.js'),
   ]);
-  assert.ok(output.stderr.toString().match(/->.*typescript-throw\.ts:18:11/));
-  assert.ok(output.stderr.toString().match(/->.*typescript-throw\.ts:24:1/));
+  assert.ok(output.stderr.toString().match(/.*typescript-throw\.ts:18:11/));
+  assert.ok(output.stderr.toString().match(/.*typescript-throw\.ts:24:1/));
 }
 
 // Applies source-maps generated by babel to stack trace.
 {
   const output = spawnSync(process.execPath, [
     '--enable-source-maps',
-    require.resolve('../fixtures/source-map/babel-throw.js')
+    require.resolve('../fixtures/source-map/babel-throw.js'),
   ]);
   assert.ok(
-    output.stderr.toString().match(/->.*babel-throw-original\.js:18:31/)
+    output.stderr.toString().match(/.*babel-throw-original\.js:18:31/)
   );
 }
 
@@ -202,13 +206,13 @@ function nextdir() {
 {
   const output = spawnSync(process.execPath, [
     '--enable-source-maps',
-    require.resolve('../fixtures/source-map/istanbul-throw.js')
+    require.resolve('../fixtures/source-map/istanbul-throw.js'),
   ]);
   assert.ok(
-    output.stderr.toString().match(/->.*istanbul-throw-original\.js:5:9/)
+    output.stderr.toString().match(/.*istanbul-throw-original\.js:5:9/)
   );
   assert.ok(
-    output.stderr.toString().match(/->.*istanbul-throw-original\.js:9:3/)
+    output.stderr.toString().match(/.*istanbul-throw-original\.js:9:3/)
   );
 }
 
@@ -216,10 +220,10 @@ function nextdir() {
 {
   const output = spawnSync(process.execPath, [
     '--enable-source-maps',
-    require.resolve('../fixtures/source-map/babel-esm.mjs')
+    require.resolve('../fixtures/source-map/babel-esm.mjs'),
   ]);
   assert.ok(
-    output.stderr.toString().match(/->.*babel-esm-original\.mjs:9:29/)
+    output.stderr.toString().match(/.*babel-esm-original\.mjs:9:29/)
   );
 }
 
@@ -227,7 +231,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/inline-base64.js')
+    require.resolve('../fixtures/source-map/inline-base64.js'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   const sourceMap = getSourceMapFromCache(
     'inline-base64.js',
@@ -240,7 +244,7 @@ function nextdir() {
 {
   const coverageDirectory = nextdir();
   spawnSync(process.execPath, [
-    require.resolve('../fixtures/source-map/istanbul-throw.js')
+    require.resolve('../fixtures/source-map/istanbul-throw.js'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   const sourceMap = getSourceMapFromCache(
     'istanbul-throw.js',
@@ -257,7 +261,7 @@ function nextdir() {
 {
   const output = spawnSync(process.execPath, [
     '--enable-source-maps',
-    require.resolve('../fixtures/source-map/emptyStackError.js')
+    require.resolve('../fixtures/source-map/emptyStackError.js'),
   ]);
 
   assert.ok(
@@ -265,6 +269,80 @@ function nextdir() {
   );
 }
 
+// Does not attempt to apply path resolution logic to absolute URLs
+// with schemes.
+// Refs: https://github.com/webpack/webpack/issues/9601
+// Refs: https://sourcemaps.info/spec.html#h.75yo6yoyk7x5
+{
+  const output = spawnSync(process.execPath, [
+    '--enable-source-maps',
+    require.resolve('../fixtures/source-map/webpack.js'),
+  ]);
+  // Error in original context of source content:
+  assert.match(
+    output.stderr.toString(),
+    /throw new Error\('oh no!'\)\r?\n.*\^/
+  );
+  // Rewritten stack trace:
+  assert.match(output.stderr.toString(), /webpack:\/\/\/webpack\.js:14:9/);
+  assert.match(output.stderr.toString(), /at functionD.*14:9/);
+  assert.match(output.stderr.toString(), /at functionC.*10:3/);
+}
+
+// Stores and applies source map associated with file that throws while
+// being required.
+{
+  const coverageDirectory = nextdir();
+  const output = spawnSync(process.execPath, [
+    '--enable-source-maps',
+    require.resolve('../fixtures/source-map/throw-on-require-entry.js'),
+  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const sourceMap = getSourceMapFromCache(
+    'throw-on-require.js',
+    coverageDirectory
+  );
+  // Rewritten stack trace.
+  assert.match(output.stderr.toString(), /throw-on-require\.ts:9:9/);
+  // Source map should have been serialized.
+  assert.ok(sourceMap);
+}
+
+// Does not throw TypeError when primitive value is thrown.
+{
+  const coverageDirectory = nextdir();
+  const output = spawnSync(process.execPath, [
+    '--enable-source-maps',
+    require.resolve('../fixtures/source-map/throw-string.js'),
+  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const sourceMap = getSourceMapFromCache(
+    'throw-string.js',
+    coverageDirectory
+  );
+  // Original stack trace.
+  assert.match(output.stderr.toString(), /goodbye/);
+  // Source map should have been serialized.
+  assert.ok(sourceMap);
+}
+
+// Does not throw TypeError when exception occurs as result of missing named
+// export.
+{
+  const coverageDirectory = nextdir();
+  const output = spawnSync(process.execPath, [
+    '--enable-source-maps',
+    require.resolve('../fixtures/source-map/esm-export-missing.mjs'),
+  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const sourceMap = getSourceMapFromCache(
+    'esm-export-missing.mjs',
+    coverageDirectory
+  );
+  // Module loader error displayed.
+  assert.match(output.stderr.toString(),
+               /does not provide an export named 'Something'/);
+  // Source map should have been serialized.
+  assert.ok(sourceMap);
+}
+
 function getSourceMapFromCache(fixtureFile, coverageDirectory) {
   const jsonFiles = fs.readdirSync(coverageDirectory);
   for (const jsonFile of jsonFiles) {
diff --git a/test/parallel/test-stdin-hang.js b/test/parallel/test-stdin-hang.js
index 23c686320d32990d6ed2941e63ad3e0de3e176c5..887f31fdb75adf611e5e8119349951aeab09c71d 100644
--- a/test/parallel/test-stdin-hang.js
+++ b/test/parallel/test-stdin-hang.js
@@ -27,6 +27,6 @@ require('../common');
 // If it does, then the test-runner will nuke it.
 
 // invoke the getter.
-process.stdin;
+process.stdin; // eslint-disable-line no-unused-expressions
 
 console.error('Should exit normally now.');
diff --git a/test/parallel/test-stdin-script-child.js b/test/parallel/test-stdin-script-child.js
index 7e73d82bfb5ab932416e5f2cdc33296fd5463979..cf83b278acd6d3795acce52007ae50b3db1e3d2c 100644
--- a/test/parallel/test-stdin-script-child.js
+++ b/test/parallel/test-stdin-script-child.js
@@ -6,8 +6,7 @@ const { spawn } = require('child_process');
 for (const args of [[], ['-']]) {
   const child = spawn(process.execPath, args, {
     env: { ...process.env,
-           NODE_DEBUG: process.argv[2]
-    }
+           NODE_DEBUG: process.argv[2] }
   });
   const wanted = `${child.pid}\n`;
   let found = '';
diff --git a/test/parallel/test-stdio-closed.js b/test/parallel/test-stdio-closed.js
index c21bbc2eac12b783b9ef7405cacf61fc66cb1977..cc9f1e86ccbf6ce8b791bd71562b82b60026d963 100644
--- a/test/parallel/test-stdio-closed.js
+++ b/test/parallel/test-stdio-closed.js
@@ -7,10 +7,12 @@ const fixtures = require('../common/fixtures');
 
 if (common.isWindows) {
   if (process.argv[2] === 'child') {
+    /* eslint-disable no-unused-expressions */
     process.stdin;
     process.stdout;
     process.stderr;
     return;
+    /* eslint-enable no-unused-expressions */
   }
   const python = process.env.PYTHON || 'python';
   const script = fixtures.path('spawn_closed_stdio.py');
diff --git a/test/parallel/test-stdio-pipe-access.js b/test/parallel/test-stdio-pipe-access.js
index e8f8131d1f19e84027208c45334d8fdea0b8f66e..6093e60b8b10a5adfd319f4b80bdca1bf19f7c02 100644
--- a/test/parallel/test-stdio-pipe-access.js
+++ b/test/parallel/test-stdio-pipe-access.js
@@ -32,6 +32,6 @@ switch (who) {
                        process.stderr ] });
     break;
   case 'bottom':
-    process.stdin;
+    process.stdin; // eslint-disable-line no-unused-expressions
     break;
 }
diff --git a/test/parallel/test-stdout-close-catch.js b/test/parallel/test-stdout-close-catch.js
index 6c0db3ea904a7d0cbf69defd8117ebb7ec893a8a..924b52715a54f3518f96a7b280ce8b1492f97071 100644
--- a/test/parallel/test-stdout-close-catch.js
+++ b/test/parallel/test-stdout-close-catch.js
@@ -3,6 +3,7 @@ const common = require('../common');
 const assert = require('assert');
 const child_process = require('child_process');
 const fixtures = require('../common/fixtures');
+const { getSystemErrorName } = require('util');
 
 const testScript = fixtures.path('catch-stdout-error.js');
 
@@ -13,11 +14,6 @@ const cmd = `${JSON.stringify(process.execPath)} ` +
 
 const child = child_process.exec(cmd);
 let output = '';
-const outputExpect = {
-  code: 'EPIPE',
-  errno: 'EPIPE',
-  syscall: 'write'
-};
 
 child.stderr.on('data', function(c) {
   output += c;
@@ -32,6 +28,8 @@ child.on('close', common.mustCall(function(code) {
     process.exit(1);
   }
 
-  assert.deepStrictEqual(output, outputExpect);
+  assert.strictEqual(output.code, 'EPIPE');
+  assert.strictEqual(getSystemErrorName(output.errno), 'EPIPE');
+  assert.strictEqual(output.syscall, 'write');
   console.log('ok');
 }));
diff --git a/test/parallel/test-stdout-to-file.js b/test/parallel/test-stdout-to-file.js
index f23bbea279d324224b36e5eee77cbeff87d5147e..014a304d3f0263f50e774af0d41eeb2e2325d44c 100644
--- a/test/parallel/test-stdout-to-file.js
+++ b/test/parallel/test-stdout-to-file.js
@@ -23,8 +23,7 @@ function test(size, useBuffer, cb) {
 
   console.log(`${size} chars to ${tmpFile}...`);
 
-  childProcess.exec(cmd, common.mustCall(function(err) {
-    assert.ifError(err);
+  childProcess.exec(cmd, common.mustSucceed(() => {
     console.log('done!');
 
     const stat = fs.statSync(tmpFile);
diff --git a/test/parallel/test-stream-big-packet.js b/test/parallel/test-stream-big-packet.js
index 0dca3391961a9314519f2368752d4cc43799727a..fdbe3cd21145ee03624ba9490ba9302c5359db3a 100644
--- a/test/parallel/test-stream-big-packet.js
+++ b/test/parallel/test-stream-big-packet.js
@@ -36,7 +36,11 @@ class TestStream extends stream.Transform {
   }
 }
 
-const s1 = new stream.PassThrough();
+const s1 = new stream.Transform({
+  transform(chunk, encoding, cb) {
+    process.nextTick(cb, null, chunk);
+  }
+});
 const s2 = new stream.PassThrough();
 const s3 = new TestStream();
 s1.pipe(s3);
diff --git a/test/parallel/test-stream-buffer-list.js b/test/parallel/test-stream-buffer-list.js
index 5b495a41e0854593883fd08261424af10747ade5..d9d0405f4d5a45354422b228dea278a39b9e6574 100644
--- a/test/parallel/test-stream-buffer-list.js
+++ b/test/parallel/test-stream-buffer-list.js
@@ -48,3 +48,37 @@ const shifted = list.shift();
 testIterator(list, 0);
 assert.strictEqual(shifted, buf);
 assert.deepStrictEqual(list, new BufferList());
+
+{
+  const list = new BufferList();
+  list.push('foo');
+  list.push('bar');
+  list.push('foo');
+  list.push('bar');
+  assert.strictEqual(list.consume(6, true), 'foobar');
+  assert.strictEqual(list.consume(6, true), 'foobar');
+}
+
+{
+  const list = new BufferList();
+  list.push('foo');
+  list.push('bar');
+  assert.strictEqual(list.consume(5, true), 'fooba');
+}
+
+{
+  const list = new BufferList();
+  list.push(buf);
+  list.push(buf);
+  list.push(buf);
+  list.push(buf);
+  assert.strictEqual(list.consume(6).toString(), 'foofoo');
+  assert.strictEqual(list.consume(6).toString(), 'foofoo');
+}
+
+{
+  const list = new BufferList();
+  list.push(buf);
+  list.push(buf);
+  assert.strictEqual(list.consume(5).toString(), 'foofo');
+}
diff --git a/test/parallel/test-stream-catch-rejections.js b/test/parallel/test-stream-catch-rejections.js
index fb5f1fccc18bd232e67db50940d307aa93b8240b..81427c35757ca8b8b7f7347e497489e0391ee405 100644
--- a/test/parallel/test-stream-catch-rejections.js
+++ b/test/parallel/test-stream-catch-rejections.js
@@ -8,11 +8,10 @@ const assert = require('assert');
   const r = new stream.Readable({
     captureRejections: true,
     read() {
-      this.push('hello');
-      this.push('world');
-      this.push(null);
     }
   });
+  r.push('hello');
+  r.push('world');
 
   const err = new Error('kaboom');
 
@@ -31,7 +30,7 @@ const assert = require('assert');
     captureRejections: true,
     highWaterMark: 1,
     write(chunk, enc, cb) {
-      cb();
+      process.nextTick(cb);
     }
   });
 
diff --git a/test/parallel/test-stream-duplex-destroy.js b/test/parallel/test-stream-duplex-destroy.js
index 3c38d2c364051c5c0c79241f2cd4b742231acaa9..c7d294e144bb5eee58dd792feaa331a0384ab85d 100644
--- a/test/parallel/test-stream-duplex-destroy.js
+++ b/test/parallel/test-stream-duplex-destroy.js
@@ -124,7 +124,7 @@ const assert = require('assert');
 
   duplex.removeListener('end', fail);
   duplex.removeListener('finish', fail);
-  duplex.on('end', common.mustCall());
+  duplex.on('end', common.mustNotCall());
   duplex.on('finish', common.mustCall());
   assert.strictEqual(duplex.destroyed, true);
 }
@@ -194,3 +194,47 @@ const assert = require('assert');
 
   new MyDuplex();
 }
+
+{
+  const duplex = new Duplex({
+    writable: false,
+    autoDestroy: true,
+    write(chunk, enc, cb) { cb(); },
+    read() {},
+  });
+  duplex.push(null);
+  duplex.resume();
+  duplex.on('close', common.mustCall());
+}
+
+{
+  const duplex = new Duplex({
+    readable: false,
+    autoDestroy: true,
+    write(chunk, enc, cb) { cb(); },
+    read() {},
+  });
+  duplex.end();
+  duplex.on('close', common.mustCall());
+}
+
+{
+  const duplex = new Duplex({
+    allowHalfOpen: false,
+    autoDestroy: true,
+    write(chunk, enc, cb) { cb(); },
+    read() {},
+  });
+  duplex.push(null);
+  duplex.resume();
+  const orgEnd = duplex.end;
+  duplex.end = common.mustNotCall();
+  duplex.on('end', () => {
+    // Ensure end() is called in next tick to allow
+    // any pending writes to be invoked first.
+    process.nextTick(() => {
+      duplex.end = common.mustCall(orgEnd);
+    });
+  });
+  duplex.on('close', common.mustCall());
+}
diff --git a/test/parallel/test-stream-duplex-end.js b/test/parallel/test-stream-duplex-end.js
index 8ee19346d3abe5e8e6eaf297588855a1aab2ed2f..2c7706146eb882cd050c52895e0a546a429a0ba1 100644
--- a/test/parallel/test-stream-duplex-end.js
+++ b/test/parallel/test-stream-duplex-end.js
@@ -22,7 +22,7 @@ const Duplex = require('stream').Duplex;
   });
   assert.strictEqual(stream.allowHalfOpen, false);
   stream.on('finish', common.mustCall());
-  assert.strictEqual(stream.listenerCount('end'), 1);
+  assert.strictEqual(stream.listenerCount('end'), 0);
   stream.resume();
   stream.push(null);
 }
@@ -35,7 +35,7 @@ const Duplex = require('stream').Duplex;
   assert.strictEqual(stream.allowHalfOpen, false);
   stream._writableState.ended = true;
   stream.on('finish', common.mustNotCall());
-  assert.strictEqual(stream.listenerCount('end'), 1);
+  assert.strictEqual(stream.listenerCount('end'), 0);
   stream.resume();
   stream.push(null);
 }
diff --git a/test/parallel/test-stream-duplex-props.js b/test/parallel/test-stream-duplex-props.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa6b23125a9d9d2de6008b74e4eba59ccc59ba49
--- /dev/null
+++ b/test/parallel/test-stream-duplex-props.js
@@ -0,0 +1,31 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { Duplex } = require('stream');
+
+{
+  const d = new Duplex({
+    objectMode: true,
+    highWaterMark: 100
+  });
+
+  assert.strictEqual(d.writableObjectMode, true);
+  assert.strictEqual(d.writableHighWaterMark, 100);
+  assert.strictEqual(d.readableObjectMode, true);
+  assert.strictEqual(d.readableHighWaterMark, 100);
+}
+
+{
+  const d = new Duplex({
+    readableObjectMode: false,
+    readableHighWaterMark: 10,
+    writableObjectMode: true,
+    writableHighWaterMark: 100
+  });
+
+  assert.strictEqual(d.writableObjectMode, true);
+  assert.strictEqual(d.writableHighWaterMark, 100);
+  assert.strictEqual(d.readableObjectMode, false);
+  assert.strictEqual(d.readableHighWaterMark, 10);
+}
diff --git a/test/parallel/test-stream-duplex-readable-end.js b/test/parallel/test-stream-duplex-readable-end.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e3e62aacb14bc49faf6ee4860cba509bc8bda92
--- /dev/null
+++ b/test/parallel/test-stream-duplex-readable-end.js
@@ -0,0 +1,29 @@
+'use strict';
+// https://github.com/nodejs/node/issues/35926
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+let loops = 5;
+
+const src = new stream.Readable({
+  read() {
+    if (loops--)
+      this.push(Buffer.alloc(20000));
+  }
+});
+
+const dst = new stream.Transform({
+  transform(chunk, output, fn) {
+    this.push(null);
+    fn();
+  }
+});
+
+src.pipe(dst);
+
+dst.on('data', () => { });
+dst.on('end', common.mustCall(() => {
+  assert.strictEqual(loops, 3);
+  assert.ok(src.isPaused());
+}));
diff --git a/test/parallel/test-stream-error-once.js b/test/parallel/test-stream-error-once.js
new file mode 100644
index 0000000000000000000000000000000000000000..71f268cfa476a18c9b8d7e703548d69636965f64
--- /dev/null
+++ b/test/parallel/test-stream-error-once.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../common');
+const { Writable, Readable } = require('stream');
+
+{
+  const writable = new Writable();
+  writable.on('error', common.mustCall());
+  writable.end();
+  writable.write('h');
+  writable.write('h');
+}
+
+{
+  const readable = new Readable();
+  readable.on('error', common.mustCall());
+  readable.push(null);
+  readable.push('h');
+  readable.push('h');
+}
diff --git a/test/parallel/test-stream-finished.js b/test/parallel/test-stream-finished.js
index 89fbd6e3bb21ba1c5a8d5082b772d3fbee03fb43..5d357454790e81d7d605dd04010890a91d1062ca 100644
--- a/test/parallel/test-stream-finished.js
+++ b/test/parallel/test-stream-finished.js
@@ -1,7 +1,14 @@
 'use strict';
 
 const common = require('../common');
-const { Writable, Readable, Transform, finished } = require('stream');
+const {
+  Writable,
+  Readable,
+  Transform,
+  finished,
+  Duplex,
+  PassThrough
+} = require('stream');
 const assert = require('assert');
 const EE = require('events');
 const fs = require('fs');
@@ -12,9 +19,7 @@ const { promisify } = require('util');
     read() {}
   });
 
-  finished(rs, common.mustCall((err) => {
-    assert(!err, 'no error');
-  }));
+  finished(rs, common.mustSucceed());
 
   rs.push(null);
   rs.resume();
@@ -27,9 +32,7 @@ const { promisify } = require('util');
     }
   });
 
-  finished(ws, common.mustCall((err) => {
-    assert(!err, 'no error');
-  }));
+  finished(ws, common.mustSucceed());
 
   ws.end();
 }
@@ -52,8 +55,7 @@ const { promisify } = require('util');
     finish = true;
   });
 
-  finished(tr, common.mustCall((err) => {
-    assert(!err, 'no error');
+  finished(tr, common.mustSucceed(() => {
     assert(finish);
     assert(ended);
   }));
@@ -100,9 +102,7 @@ const { promisify } = require('util');
 {
   const rs = new Readable();
 
-  finished(rs, common.mustCall((err) => {
-    assert(!err, 'no error');
-  }));
+  finished(rs, common.mustSucceed());
 
   rs.push(null);
   rs.emit('close'); // Should not trigger an error
@@ -138,7 +138,7 @@ const { promisify } = require('util');
     () => finished(rs, 'foo', () => {}),
     {
       code: 'ERR_INVALID_ARG_TYPE',
-      message: /opts/
+      message: /options/
     }
   );
   assert.throws(
@@ -181,55 +181,317 @@ const { promisify } = require('util');
   const streamLike = new EE();
   streamLike.readableEnded = true;
   streamLike.readable = true;
-  finished(streamLike, common.mustCall);
+  finished(streamLike, common.mustCall());
   streamLike.emit('close');
 }
 
+{
+  const writable = new Writable({ write() {} });
+  writable.writable = false;
+  writable.destroy();
+  finished(writable, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+  }));
+}
 
 {
-  // Test is readable check through readable
-  const streamLike = new EE();
-  streamLike.readable = false;
-  finished(streamLike, common.mustCall());
-  streamLike.emit('end');
+  const readable = new Readable();
+  readable.readable = false;
+  readable.destroy();
+  finished(readable, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+  }));
 }
 
 {
-  // Test is readable check through readableEnded
-  const streamLike = new EE();
-  streamLike.readableEnded = true;
-  finished(streamLike, common.mustCall());
-  streamLike.emit('end');
+  const w = new Writable({
+    write(chunk, encoding, callback) {
+      setImmediate(callback);
+    }
+  });
+  finished(w, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+  }));
+  w.end('asd');
+  w.destroy();
 }
 
+function testClosed(factory) {
+  {
+    // If already destroyed but finished is cancelled in same tick
+    // don't invoke the callback,
+
+    const s = factory();
+    s.destroy();
+    const dispose = finished(s, common.mustNotCall());
+    dispose();
+  }
+
+  {
+    // If already destroyed invoked callback.
+
+    const s = factory();
+    s.destroy();
+    finished(s, common.mustCall());
+  }
+
+  {
+    // Don't invoke until destroy has completed.
+
+    let destroyed = false;
+    const s = factory({
+      destroy(err, cb) {
+        setImmediate(() => {
+          destroyed = true;
+          cb();
+        });
+      }
+    });
+    s.destroy();
+    finished(s, common.mustCall(() => {
+      assert.strictEqual(destroyed, true);
+    }));
+  }
+
+  {
+    // Invoke callback even if close is inhibited.
+
+    const s = factory({
+      emitClose: false,
+      destroy(err, cb) {
+        cb();
+        finished(s, common.mustCall());
+      }
+    });
+    s.destroy();
+  }
+
+  {
+    // Invoke with deep async.
+
+    const s = factory({
+      destroy(err, cb) {
+        setImmediate(() => {
+          cb();
+          setImmediate(() => {
+            finished(s, common.mustCall());
+          });
+        });
+      }
+    });
+    s.destroy();
+  }
+}
+
+testClosed((opts) => new Readable({ ...opts }));
+testClosed((opts) => new Writable({ write() {}, ...opts }));
+
 {
-  // Test is readable check through _readableState
-  const streamLike = new EE();
-  streamLike._readableState = {};
-  finished(streamLike, common.mustCall());
-  streamLike.emit('end');
+  const w = new Writable({
+    write(chunk, encoding, cb) {
+      cb();
+    },
+    autoDestroy: false
+  });
+  w.end('asd');
+  process.nextTick(() => {
+    finished(w, common.mustCall());
+  });
 }
 
 {
-  // Test is writable check through writable
-  const streamLike = new EE();
-  streamLike.writable = false;
-  finished(streamLike, common.mustCall());
-  streamLike.emit('finish');
+  const w = new Writable({
+    write(chunk, encoding, cb) {
+      cb(new Error());
+    },
+    autoDestroy: false
+  });
+  w.write('asd');
+  w.on('error', common.mustCall(() => {
+    finished(w, common.mustCall());
+  }));
 }
 
 {
-  // Test is writable check through writableEnded
-  const streamLike = new EE();
-  streamLike.writableEnded = true;
-  finished(streamLike, common.mustCall());
-  streamLike.emit('finish');
+  const r = new Readable({
+    autoDestroy: false
+  });
+  r.push(null);
+  r.resume();
+  r.on('end', common.mustCall(() => {
+    finished(r, common.mustCall());
+  }));
 }
 
 {
-  // Test is writable check through _writableState
-  const streamLike = new EE();
-  streamLike._writableState = {};
-  finished(streamLike, common.mustCall());
-  streamLike.emit('finish');
+  const rs = fs.createReadStream(__filename, { autoClose: false });
+  rs.resume();
+  rs.on('close', common.mustNotCall());
+  rs.on('end', common.mustCall(() => {
+    finished(rs, common.mustCall());
+  }));
+}
+
+{
+  const d = new EE();
+  d._writableState = {};
+  d._writableState.finished = true;
+  finished(d, { readable: false, writable: true }, common.mustCall((err) => {
+    assert.strictEqual(err, undefined);
+  }));
+  d._writableState.errored = true;
+  d.emit('close');
+}
+
+{
+  const r = new Readable();
+  finished(r, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+  }));
+  r.push('asd');
+  r.push(null);
+  r.destroy();
+}
+
+{
+  const d = new Duplex({
+    final(cb) { }, // Never close writable side for test purpose
+    read() {
+      this.push(null);
+    }
+  });
+
+  d.on('end', common.mustCall());
+
+  finished(d, { readable: true, writable: false }, common.mustCall());
+
+  d.end();
+  d.resume();
+}
+
+{
+  const d = new Duplex({
+    final(cb) { }, // Never close writable side for test purpose
+    read() {
+      this.push(null);
+    }
+  });
+
+  d.on('end', common.mustCall());
+
+  d.end();
+  finished(d, { readable: true, writable: false }, common.mustCall());
+
+  d.resume();
+}
+
+{
+  // Test for compat for e.g. fd-slicer which implements
+  // non standard destroy behavior which might not emit
+  // 'close'.
+  const r = new Readable();
+  finished(r, common.mustCall());
+  r.resume();
+  r.push('asd');
+  r.destroyed = true;
+  r.push(null);
+}
+
+{
+  // Regression https://github.com/nodejs/node/issues/33130
+  const response = new PassThrough();
+
+  class HelloWorld extends Duplex {
+    constructor(response) {
+      super({
+        autoDestroy: false
+      });
+
+      this.response = response;
+      this.readMore = false;
+
+      response.once('end', () => {
+        this.push(null);
+      });
+
+      response.on('readable', () => {
+        if (this.readMore) {
+          this._read();
+        }
+      });
+    }
+
+    _read() {
+      const { response } = this;
+
+      this.readMore = true;
+
+      if (response.readableLength) {
+        this.readMore = false;
+      }
+
+      let data;
+      while ((data = response.read()) !== null) {
+        this.push(data);
+      }
+    }
+  }
+
+  const instance = new HelloWorld(response);
+  instance.setEncoding('utf8');
+  instance.end();
+
+  (async () => {
+    await EE.once(instance, 'finish');
+
+    setImmediate(() => {
+      response.write('chunk 1');
+      response.write('chunk 2');
+      response.write('chunk 3');
+      response.end();
+    });
+
+    let res = '';
+    for await (const data of instance) {
+      res += data;
+    }
+
+    assert.strictEqual(res, 'chunk 1chunk 2chunk 3');
+  })().then(common.mustCall());
+}
+
+{
+  const p = new PassThrough();
+  p.end();
+  finished(p, common.mustNotCall());
+}
+
+{
+  const p = new PassThrough();
+  p.end();
+  p.on('finish', common.mustCall(() => {
+    finished(p, common.mustNotCall());
+  }));
+}
+
+{
+  const w = new Writable({
+    write(chunk, encoding, callback) {
+      process.nextTick(callback);
+    }
+  });
+  w.aborted = false;
+  w.end();
+  let closed = false;
+  w.on('finish', () => {
+    assert.strictEqual(closed, false);
+    w.emit('aborted');
+  });
+  w.on('close', common.mustCall(() => {
+    closed = true;
+  }));
+
+  finished(w, common.mustCall(() => {
+    assert.strictEqual(closed, true);
+  }));
 }
diff --git a/test/parallel/test-stream-pipe-await-drain-push-while-write.js b/test/parallel/test-stream-pipe-await-drain-push-while-write.js
index 6dbf3c669bc177d702c6c8d1d1d6f35c3e0166e7..a717291cda2b03fd5731a3f26a80039f7d7a430b 100644
--- a/test/parallel/test-stream-pipe-await-drain-push-while-write.js
+++ b/test/parallel/test-stream-pipe-await-drain-push-while-write.js
@@ -19,7 +19,7 @@ const writable = new stream.Writable({
       });
     }
 
-    cb();
+    process.nextTick(cb);
   }, 3)
 });
 
diff --git a/test/parallel/test-stream-pipe-await-drain.js b/test/parallel/test-stream-pipe-await-drain.js
index 3ae248e08b854f9beb0914ccd132e22146887ff4..35b86f67f99676a6b858032c0c9e1bff8cf78f3b 100644
--- a/test/parallel/test-stream-pipe-await-drain.js
+++ b/test/parallel/test-stream-pipe-await-drain.js
@@ -19,7 +19,7 @@ reader._read = () => {};
 
 writer1._write = common.mustCall(function(chunk, encoding, cb) {
   this.emit('chunk-received');
-  cb();
+  process.nextTick(cb);
 }, 1);
 
 writer1.once('chunk-received', () => {
@@ -27,7 +27,7 @@ writer1.once('chunk-received', () => {
     reader._readableState.awaitDrainWriters.size,
     0,
     'awaitDrain initial value should be 0, actual is ' +
-    reader._readableState.awaitDrainWriters
+    reader._readableState.awaitDrainWriters.size
   );
   setImmediate(() => {
     // This one should *not* get through to writer1 because writer2 is not
@@ -42,7 +42,7 @@ writer2._write = common.mustCall((chunk, encoding, cb) => {
     reader._readableState.awaitDrainWriters.size,
     1,
     'awaitDrain should be 1 after first push, actual is ' +
-    reader._readableState.awaitDrainWriters
+    reader._readableState.awaitDrainWriters.size
   );
   // Not calling cb here to "simulate" slow stream.
   // This should be called exactly once, since the first .write() call
@@ -54,7 +54,7 @@ writer3._write = common.mustCall((chunk, encoding, cb) => {
     reader._readableState.awaitDrainWriters.size,
     2,
     'awaitDrain should be 2 after second push, actual is ' +
-    reader._readableState.awaitDrainWriters
+    reader._readableState.awaitDrainWriters.size
   );
   // Not calling cb here to "simulate" slow stream.
   // This should be called exactly once, since the first .write() call
diff --git a/test/parallel/test-stream-pipe-error-handling.js b/test/parallel/test-stream-pipe-error-handling.js
index e725465e07968285cc0b4461166c4ad75175ecf9..cf3a3699d0975d67d7915bf7c5d369dd47622d71 100644
--- a/test/parallel/test-stream-pipe-error-handling.js
+++ b/test/parallel/test-stream-pipe-error-handling.js
@@ -22,7 +22,7 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
-const Stream = require('stream').Stream;
+const { Stream, PassThrough } = require('stream');
 
 {
   const source = new Stream();
@@ -62,8 +62,8 @@ const Stream = require('stream').Stream;
   const R = Stream.Readable;
   const W = Stream.Writable;
 
-  const r = new R();
-  const w = new W();
+  const r = new R({ autoDestroy: false });
+  const w = new W({ autoDestroy: false });
   let removed = false;
 
   r._read = common.mustCall(function() {
@@ -108,3 +108,17 @@ const Stream = require('stream').Stream;
   w.removeListener('error', () => {});
   removed = true;
 }
+
+{
+  const _err = new Error('this should be handled');
+  const destination = new PassThrough();
+  destination.once('error', common.mustCall((err) => {
+    assert.strictEqual(err, _err);
+  }));
+
+  const stream = new Stream();
+  stream
+    .pipe(destination);
+
+  destination.destroy(_err);
+}
diff --git a/test/parallel/test-stream-pipe-error-unhandled.js b/test/parallel/test-stream-pipe-error-unhandled.js
new file mode 100644
index 0000000000000000000000000000000000000000..42c1ce77fe48786f250f47ae0a3076d452da2c0a
--- /dev/null
+++ b/test/parallel/test-stream-pipe-error-unhandled.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Readable, Writable } = require('stream');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'asd');
+}));
+
+const r = new Readable({
+  read() {
+    this.push('asd');
+  }
+});
+const w = new Writable({
+  autoDestroy: true,
+  write() {}
+});
+
+r.pipe(w);
+w.destroy(new Error('asd'));
diff --git a/test/parallel/test-stream-pipe-needDrain.js b/test/parallel/test-stream-pipe-needDrain.js
new file mode 100644
index 0000000000000000000000000000000000000000..0836c81da22438cca55b8415416354ee2badfe2b
--- /dev/null
+++ b/test/parallel/test-stream-pipe-needDrain.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const Readable = require('_stream_readable');
+const Writable = require('_stream_writable');
+
+// Pipe should pause temporarily if writable needs drain.
+{
+  const w = new Writable({
+    write(buf, encoding, callback) {
+      process.nextTick(callback);
+    },
+    highWaterMark: 1
+  });
+
+  while (w.write('asd'));
+
+  assert.strictEqual(w.writableNeedDrain, true);
+
+  const r = new Readable({
+    read() {
+      this.push('asd');
+      this.push(null);
+    }
+  });
+
+  r.on('pause', common.mustCall(2));
+  r.on('end', common.mustCall());
+
+  r.pipe(w);
+}
diff --git a/test/parallel/test-stream-pipe-same-destination-twice.js b/test/parallel/test-stream-pipe-same-destination-twice.js
index 1824c0606451a2a5aa7134a82b9cb0687de25c35..ff71639588ea49ef400965417e4712ead1a174db 100644
--- a/test/parallel/test-stream-pipe-same-destination-twice.js
+++ b/test/parallel/test-stream-pipe-same-destination-twice.js
@@ -20,15 +20,15 @@ const { PassThrough, Writable } = require('stream');
   passThrough.pipe(dest);
 
   assert.strictEqual(passThrough._events.data.length, 2);
-  assert.strictEqual(passThrough._readableState.pipesCount, 2);
+  assert.strictEqual(passThrough._readableState.pipes.length, 2);
   assert.strictEqual(passThrough._readableState.pipes[0], dest);
   assert.strictEqual(passThrough._readableState.pipes[1], dest);
 
   passThrough.unpipe(dest);
 
   assert.strictEqual(passThrough._events.data.length, 1);
-  assert.strictEqual(passThrough._readableState.pipesCount, 1);
-  assert.strictEqual(passThrough._readableState.pipes, dest);
+  assert.strictEqual(passThrough._readableState.pipes.length, 1);
+  assert.deepStrictEqual(passThrough._readableState.pipes, [dest]);
 
   passThrough.write('foobar');
   passThrough.pipe(dest);
@@ -47,7 +47,7 @@ const { PassThrough, Writable } = require('stream');
   passThrough.pipe(dest);
 
   assert.strictEqual(passThrough._events.data.length, 2);
-  assert.strictEqual(passThrough._readableState.pipesCount, 2);
+  assert.strictEqual(passThrough._readableState.pipes.length, 2);
   assert.strictEqual(passThrough._readableState.pipes[0], dest);
   assert.strictEqual(passThrough._readableState.pipes[1], dest);
 
@@ -64,7 +64,7 @@ const { PassThrough, Writable } = require('stream');
   passThrough.pipe(dest);
 
   assert.strictEqual(passThrough._events.data.length, 2);
-  assert.strictEqual(passThrough._readableState.pipesCount, 2);
+  assert.strictEqual(passThrough._readableState.pipes.length, 2);
   assert.strictEqual(passThrough._readableState.pipes[0], dest);
   assert.strictEqual(passThrough._readableState.pipes[1], dest);
 
@@ -72,7 +72,7 @@ const { PassThrough, Writable } = require('stream');
   passThrough.unpipe(dest);
 
   assert.strictEqual(passThrough._events.data, undefined);
-  assert.strictEqual(passThrough._readableState.pipesCount, 0);
+  assert.strictEqual(passThrough._readableState.pipes.length, 0);
 
   passThrough.write('foobar');
 }
diff --git a/test/parallel/test-stream-pipe-unpipe-streams.js b/test/parallel/test-stream-pipe-unpipe-streams.js
index c8a383bc61a24b7cc457b44874df580a0bb04c03..b1a673d9450ce8c1dc6237dc91664fe2161b6ffc 100644
--- a/test/parallel/test-stream-pipe-unpipe-streams.js
+++ b/test/parallel/test-stream-pipe-unpipe-streams.js
@@ -22,7 +22,7 @@ assert.strictEqual(source._readableState.pipes.length, 2);
 
 source.unpipe(dest2);
 
-assert.strictEqual(source._readableState.pipes, dest1);
+assert.deepStrictEqual(source._readableState.pipes, [dest1]);
 assert.notStrictEqual(source._readableState.pipes, dest2);
 
 dest2.on('unpipe', common.mustNotCall());
@@ -30,7 +30,7 @@ source.unpipe(dest2);
 
 source.unpipe(dest1);
 
-assert.strictEqual(source._readableState.pipes, null);
+assert.strictEqual(source._readableState.pipes.length, 0);
 
 {
   // Test `cleanup()` if we unpipe all streams.
@@ -43,8 +43,7 @@ assert.strictEqual(source._readableState.pipes, null);
   const destCheckEventNames = ['close', 'finish', 'drain', 'error', 'unpipe'];
 
   const checkSrcCleanup = common.mustCall(() => {
-    assert.strictEqual(source._readableState.pipes, null);
-    assert.strictEqual(source._readableState.pipesCount, 0);
+    assert.strictEqual(source._readableState.pipes.length, 0);
     assert.strictEqual(source._readableState.flowing, false);
 
     srcCheckEventNames.forEach((eventName) => {
@@ -85,3 +84,13 @@ assert.strictEqual(source._readableState.pipes, null);
   checkDestCleanup(dest2);
   source.unpipe();
 }
+
+{
+  const src = Readable({ read: () => {} });
+  const dst = Writable({ write: () => {} });
+  src.pipe(dst);
+  src.on('resume', common.mustCall(() => {
+    src.on('pause', common.mustCall());
+    src.unpipe(dst);
+  }));
+}
diff --git a/test/parallel/test-stream-pipeline-process.js b/test/parallel/test-stream-pipeline-process.js
new file mode 100644
index 0000000000000000000000000000000000000000..a535e7263ebf6499ac7f46df22d9e6a8a33cf0ea
--- /dev/null
+++ b/test/parallel/test-stream-pipeline-process.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const os = require('os');
+
+if (process.argv[2] === 'child') {
+  const { pipeline } = require('stream');
+  pipeline(
+    process.stdin,
+    process.stdout,
+    common.mustSucceed()
+  );
+} else {
+  const cp = require('child_process');
+  cp.exec([
+    'echo',
+    'hello',
+    '|',
+    `"${process.execPath}"`,
+    `"${__filename}"`,
+    'child',
+  ].join(' '), common.mustSucceed((stdout) => {
+    assert.strictEqual(stdout.split(os.EOL).shift().trim(), 'hello');
+  }));
+}
diff --git a/test/parallel/test-stream-pipeline-uncaught.js b/test/parallel/test-stream-pipeline-uncaught.js
new file mode 100644
index 0000000000000000000000000000000000000000..bfac4f1fee8d0b454c4fc0a4cf4f08ab0feb8491
--- /dev/null
+++ b/test/parallel/test-stream-pipeline-uncaught.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+const {
+  pipeline,
+  PassThrough
+} = require('stream');
+const assert = require('assert');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'error');
+}));
+
+// Ensure that pipeline that ends with Promise
+// still propagates error to uncaughtException.
+const s = new PassThrough();
+s.end('data');
+pipeline(s, async function(source) {
+  for await (const chunk of source) {} // eslint-disable-line no-unused-vars
+}, common.mustSucceed(() => {
+  throw new Error('error');
+}));
diff --git a/test/parallel/test-stream-pipeline.js b/test/parallel/test-stream-pipeline.js
index be96891a18b0cc964de2e5b600ffdea9d118607d..073a2993a78bacc6d19b383d501752b259063c96 100644
--- a/test/parallel/test-stream-pipeline.js
+++ b/test/parallel/test-stream-pipeline.js
@@ -7,11 +7,13 @@ const {
   Readable,
   Transform,
   pipeline,
-  PassThrough
+  PassThrough,
+  Duplex
 } = require('stream');
 const assert = require('assert');
 const http = require('http');
 const { promisify } = require('util');
+const net = require('net');
 
 {
   let finished = false;
@@ -19,7 +21,7 @@ const { promisify } = require('util');
   const expected = [
     Buffer.from('a'),
     Buffer.from('b'),
-    Buffer.from('c')
+    Buffer.from('c'),
   ];
 
   const read = new Readable({
@@ -42,8 +44,7 @@ const { promisify } = require('util');
   }
   read.push(null);
 
-  pipeline(read, write, common.mustCall((err) => {
-    assert.ok(!err, 'no error');
+  pipeline(read, write, common.mustSucceed(() => {
     assert.ok(finished);
     assert.deepStrictEqual(processed, expected);
   }));
@@ -253,7 +254,7 @@ const { promisify } = require('util');
 
 {
   const server = http.createServer((req, res) => {
-    pipeline(req, res, common.mustCall());
+    pipeline(req, res, common.mustSucceed());
   });
 
   server.listen(0, () => {
@@ -345,7 +346,7 @@ const { promisify } = require('util');
 
   const expected = [
     Buffer.from('hello'),
-    Buffer.from('world')
+    Buffer.from('world'),
   ];
 
   const rs = new Readable({
@@ -374,8 +375,7 @@ const { promisify } = require('util');
     rs,
     oldStream,
     ws,
-    common.mustCall((err) => {
-      assert(!err, 'no error');
+    common.mustSucceed(() => {
       assert(finished, 'last stream finished');
     })
   );
@@ -499,17 +499,13 @@ const { promisify } = require('util');
     http.get({ port: this.address().port }, (res) => {
       const stream = new PassThrough();
 
-      // NOTE: 2 because Node 12 streams can emit 'error'
-      // multiple times.
-      stream.on('error', common.mustCall(2));
+      stream.on('error', common.mustCall());
 
       pipeline(
         res,
         stream,
         common.mustCall((err) => {
-          assert.ok(err);
-          // TODO(ronag):
-          // assert.strictEqual(err.message, 'oh no');
+          assert.strictEqual(err.message, 'oh no');
           server.close();
         })
       );
@@ -519,6 +515,683 @@ const { promisify } = require('util');
   });
 }
 
+{
+  let res = '';
+  const w = new Writable({
+    write(chunk, encoding, callback) {
+      res += chunk;
+      callback();
+    }
+  });
+  pipeline(function*() {
+    yield 'hello';
+    yield 'world';
+  }(), w, common.mustSucceed(() => {
+    assert.strictEqual(res, 'helloworld');
+  }));
+}
+
+{
+  let res = '';
+  const w = new Writable({
+    write(chunk, encoding, callback) {
+      res += chunk;
+      callback();
+    }
+  });
+  pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+    yield 'world';
+  }(), w, common.mustSucceed(() => {
+    assert.strictEqual(res, 'helloworld');
+  }));
+}
+
+{
+  let res = '';
+  const w = new Writable({
+    write(chunk, encoding, callback) {
+      res += chunk;
+      callback();
+    }
+  });
+  pipeline(function*() {
+    yield 'hello';
+    yield 'world';
+  }, w, common.mustSucceed(() => {
+    assert.strictEqual(res, 'helloworld');
+  }));
+}
+
+{
+  let res = '';
+  const w = new Writable({
+    write(chunk, encoding, callback) {
+      res += chunk;
+      callback();
+    }
+  });
+  pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+    yield 'world';
+  }, w, common.mustSucceed(() => {
+    assert.strictEqual(res, 'helloworld');
+  }));
+}
+
+{
+  let res = '';
+  pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+    yield 'world';
+  }, async function*(source) {
+    for await (const chunk of source) {
+      yield chunk.toUpperCase();
+    }
+  }, async function(source) {
+    for await (const chunk of source) {
+      res += chunk;
+    }
+  }, common.mustSucceed(() => {
+    assert.strictEqual(res, 'HELLOWORLD');
+  }));
+}
+
+{
+  pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+    yield 'world';
+  }, async function*(source) {
+    for await (const chunk of source) {
+      yield chunk.toUpperCase();
+    }
+  }, async function(source) {
+    let ret = '';
+    for await (const chunk of source) {
+      ret += chunk;
+    }
+    return ret;
+  }, common.mustSucceed((val) => {
+    assert.strictEqual(val, 'HELLOWORLD');
+  }));
+}
+
+{
+  // AsyncIterable destination is returned and finalizes.
+
+  const ret = pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+  }, async function*(source) {
+    for await (const chunk of source) {}
+  }, common.mustCall((err) => {
+    assert.strictEqual(err, undefined);
+  }));
+  ret.resume();
+  assert.strictEqual(typeof ret.pipe, 'function');
+}
+
+{
+  // AsyncFunction destination is not returned and error is
+  // propagated.
+
+  const ret = pipeline(async function*() {
+    await Promise.resolve();
+    throw new Error('kaboom');
+  }, async function*(source) {
+    for await (const chunk of source) {}
+  }, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+  }));
+  ret.resume();
+  assert.strictEqual(typeof ret.pipe, 'function');
+}
+
+{
+  const s = new PassThrough();
+  pipeline(async function*() {
+    throw new Error('kaboom');
+  }, s, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(s.destroyed, true);
+  }));
+}
+
+{
+  const s = new PassThrough();
+  pipeline(async function*() {
+    throw new Error('kaboom');
+  }(), s, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(s.destroyed, true);
+  }));
+}
+
+{
+  const s = new PassThrough();
+  pipeline(function*() {
+    throw new Error('kaboom');
+  }, s, common.mustCall((err, val) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(s.destroyed, true);
+  }));
+}
+
+{
+  const s = new PassThrough();
+  pipeline(function*() {
+    throw new Error('kaboom');
+  }(), s, common.mustCall((err, val) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(s.destroyed, true);
+  }));
+}
+
+{
+  const s = new PassThrough();
+  pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+    yield 'world';
+  }, s, async function(source) {
+    for await (const chunk of source) {
+      throw new Error('kaboom');
+    }
+  }, common.mustCall((err, val) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(s.destroyed, true);
+  }));
+}
+
+{
+  const s = new PassThrough();
+  const ret = pipeline(function() {
+    return ['hello', 'world'];
+  }, s, async function*(source) {
+    for await (const chunk of source) {
+      throw new Error('kaboom');
+    }
+  }, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(s.destroyed, true);
+  }));
+  ret.resume();
+  assert.strictEqual(typeof ret.pipe, 'function');
+}
+
+{
+  // Legacy streams without async iterator.
+
+  const s = new PassThrough();
+  s.push('asd');
+  s.push(null);
+  s[Symbol.asyncIterator] = null;
+  let ret = '';
+  pipeline(s, async function(source) {
+    for await (const chunk of source) {
+      ret += chunk;
+    }
+  }, common.mustCall((err) => {
+    assert.strictEqual(err, undefined);
+    assert.strictEqual(ret, 'asd');
+  }));
+}
+
+{
+  // v1 streams without read().
+
+  const s = new Stream();
+  process.nextTick(() => {
+    s.emit('data', 'asd');
+    s.emit('end');
+  });
+  // 'destroyer' can be called multiple times,
+  // once from stream wrapper and
+  // once from iterator wrapper.
+  s.close = common.mustCallAtLeast(1);
+  let ret = '';
+  pipeline(s, async function(source) {
+    for await (const chunk of source) {
+      ret += chunk;
+    }
+  }, common.mustCall((err) => {
+    assert.strictEqual(err, undefined);
+    assert.strictEqual(ret, 'asd');
+  }));
+}
+
+{
+  // v1 error streams without read().
+
+  const s = new Stream();
+  process.nextTick(() => {
+    s.emit('error', new Error('kaboom'));
+  });
+  s.destroy = common.mustCall();
+  pipeline(s, async function(source) {
+  }, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+  }));
+}
+
+{
+  const s = new PassThrough();
+  assert.throws(() => {
+    pipeline(function(source) {
+    }, s, () => {});
+  }, (err) => {
+    assert.strictEqual(err.code, 'ERR_INVALID_RETURN_VALUE');
+    assert.strictEqual(s.destroyed, false);
+    return true;
+  });
+}
+
+{
+  const s = new PassThrough();
+  assert.throws(() => {
+    pipeline(s, function(source) {
+    }, s, () => {});
+  }, (err) => {
+    assert.strictEqual(err.code, 'ERR_INVALID_RETURN_VALUE');
+    assert.strictEqual(s.destroyed, false);
+    return true;
+  });
+}
+
+{
+  const s = new PassThrough();
+  assert.throws(() => {
+    pipeline(s, function(source) {
+    }, () => {});
+  }, (err) => {
+    assert.strictEqual(err.code, 'ERR_INVALID_RETURN_VALUE');
+    assert.strictEqual(s.destroyed, false);
+    return true;
+  });
+}
+
+{
+  const s = new PassThrough();
+  assert.throws(() => {
+    pipeline(s, function*(source) {
+    }, () => {});
+  }, (err) => {
+    assert.strictEqual(err.code, 'ERR_INVALID_RETURN_VALUE');
+    assert.strictEqual(s.destroyed, false);
+    return true;
+  });
+}
+
+{
+  let res = '';
+  pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+    yield 'world';
+  }, new Transform({
+    transform(chunk, encoding, cb) {
+      cb(new Error('kaboom'));
+    }
+  }), async function(source) {
+    for await (const chunk of source) {
+      res += chunk;
+    }
+  }, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(res, '');
+  }));
+}
+
+{
+  let res = '';
+  pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+    yield 'world';
+  }, new Transform({
+    transform(chunk, encoding, cb) {
+      process.nextTick(cb, new Error('kaboom'));
+    }
+  }), async function(source) {
+    for await (const chunk of source) {
+      res += chunk;
+    }
+  }, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(res, '');
+  }));
+}
+
+{
+  let res = '';
+  pipeline(async function*() {
+    await Promise.resolve();
+    yield 'hello';
+    yield 'world';
+  }, new Transform({
+    decodeStrings: false,
+    transform(chunk, encoding, cb) {
+      cb(null, chunk.toUpperCase());
+    }
+  }), async function(source) {
+    for await (const chunk of source) {
+      res += chunk;
+    }
+  }, common.mustSucceed(() => {
+    assert.strictEqual(res, 'HELLOWORLD');
+  }));
+}
+
+{
+  // Ensure no unhandled rejection from async function.
+
+  pipeline(async function*() {
+    yield 'hello';
+  }, async function(source) {
+    throw new Error('kaboom');
+  }, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+  }));
+}
+
+{
+  const src = new PassThrough({ autoDestroy: false });
+  const dst = new PassThrough({ autoDestroy: false });
+  pipeline(src, dst, common.mustCall(() => {
+    assert.strictEqual(src.destroyed, false);
+    assert.strictEqual(dst.destroyed, false);
+  }));
+  src.end();
+}
+
+{
+  // Make sure 'close' before 'end' finishes without error
+  // if readable has received eof.
+  // Ref: https://github.com/nodejs/node/issues/29699
+  const r = new Readable();
+  const w = new Writable({
+    write(chunk, encoding, cb) {
+      cb();
+    }
+  });
+  pipeline(r, w, (err) => {
+    assert.strictEqual(err, undefined);
+  });
+  r.push('asd');
+  r.push(null);
+  r.emit('close');
+}
+
+{
+  const server = http.createServer((req, res) => {
+  });
+
+  server.listen(0, () => {
+    const req = http.request({
+      port: server.address().port
+    });
+
+    const body = new PassThrough();
+    pipeline(
+      body,
+      req,
+      common.mustSucceed(() => {
+        assert(!req.res);
+        assert(!req.aborted);
+        req.abort();
+        server.close();
+      })
+    );
+    body.end();
+  });
+}
+
+{
+  const src = new PassThrough();
+  const dst = new PassThrough();
+  pipeline(src, dst, common.mustSucceed(() => {
+    assert.strictEqual(dst.destroyed, false);
+  }));
+  src.end();
+}
+
+{
+  const src = new PassThrough();
+  const dst = new PassThrough();
+  dst.readable = false;
+  pipeline(src, dst, common.mustSucceed(() => {
+    assert.strictEqual(dst.destroyed, false);
+  }));
+  src.end();
+}
+
+{
+  let res = '';
+  const rs = new Readable({
+    read() {
+      setImmediate(() => {
+        rs.push('hello');
+      });
+    }
+  });
+  const ws = new Writable({
+    write: common.mustNotCall()
+  });
+  pipeline(rs, async function*(stream) {
+    /* eslint no-unused-vars: off */
+    for await (const chunk of stream) {
+      throw new Error('kaboom');
+    }
+  }, async function *(source) {
+    for await (const chunk of source) {
+      res += chunk;
+    }
+  }, ws, common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+    assert.strictEqual(res, '');
+  }));
+}
+
+{
+  const server = http.createServer((req, res) => {
+    req.socket.on('error', common.mustNotCall());
+    pipeline(req, new PassThrough(), (err) => {
+      assert.ifError(err);
+      res.end();
+      server.close();
+    });
+  });
+
+  server.listen(0, () => {
+    const req = http.request({
+      method: 'PUT',
+      port: server.address().port
+    });
+    req.end('asd123');
+    req.on('response', common.mustCall());
+    req.on('error', common.mustNotCall());
+  });
+}
+
+{
+  // Might still want to be able to use the writable side
+  // of src. This is in the case where e.g. the Duplex input
+  // is not directly connected to its output. Such a case could
+  // happen when the Duplex is reading from a socket and then echos
+  // the data back on the same socket.
+  const src = new PassThrough();
+  assert.strictEqual(src.writable, true);
+  const dst = new PassThrough();
+  pipeline(src, dst, common.mustCall((err) => {
+    assert.strictEqual(src.writable, true);
+    assert.strictEqual(src.destroyed, false);
+  }));
+  src.push(null);
+}
+
+{
+  const src = new PassThrough();
+  const dst = pipeline(
+    src,
+    async function * (source) {
+      for await (const chunk of source) {
+        yield chunk;
+      }
+    },
+    common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+    })
+  );
+  src.push('asd');
+  dst.destroy();
+}
+
+{
+  pipeline(async function * () {
+    yield 'asd';
+  }, async function * (source) {
+    for await (const chunk of source) {
+      yield { chunk };
+    }
+  }, common.mustSucceed());
+}
+
+{
+  let closed = false;
+  const src = new Readable({
+    read() {},
+    destroy(err, cb) {
+      process.nextTick(cb);
+    }
+  });
+  const dst = new Writable({
+    write(chunk, encoding, callback) {
+      callback();
+    }
+  });
+  src.on('close', () => {
+    closed = true;
+  });
+  src.push(null);
+  pipeline(src, dst, common.mustCall((err) => {
+    assert.strictEqual(closed, true);
+  }));
+}
+
+{
+  let closed = false;
+  const src = new Readable({
+    read() {},
+    destroy(err, cb) {
+      process.nextTick(cb);
+    }
+  });
+  const dst = new Duplex({});
+  src.on('close', common.mustCall(() => {
+    closed = true;
+  }));
+  src.push(null);
+  pipeline(src, dst, common.mustCall((err) => {
+    assert.strictEqual(closed, true);
+  }));
+}
+
+{
+  const server = net.createServer(common.mustCall((socket) => {
+    // echo server
+    pipeline(socket, socket, common.mustSucceed());
+    // 13 force destroys the socket before it has a chance to emit finish
+    socket.on('finish', common.mustCall(() => {
+      server.close();
+    }));
+  })).listen(0, common.mustCall(() => {
+    const socket = net.connect(server.address().port);
+    socket.end();
+  }));
+}
+
+{
+  const d = new Duplex({
+    autoDestroy: false,
+    write: common.mustCall((data, enc, cb) => {
+      d.push(data);
+      cb();
+    }),
+    read: common.mustCall(() => {
+      d.push(null);
+    }),
+    final: common.mustCall((cb) => {
+      setTimeout(() => {
+        assert.strictEqual(d.destroyed, false);
+        cb();
+      }, 1000);
+    }),
+    destroy: common.mustNotCall()
+  });
+
+  const sink = new Writable({
+    write: common.mustCall((data, enc, cb) => {
+      cb();
+    })
+  });
+
+  pipeline(d, sink, common.mustSucceed());
+
+  d.write('test');
+  d.end();
+}
+
+{
+  const server = net.createServer(common.mustCall((socket) => {
+    // echo server
+    pipeline(socket, socket, common.mustSucceed());
+    socket.on('finish', common.mustCall(() => {
+      server.close();
+    }));
+  })).listen(0, common.mustCall(() => {
+    const socket = net.connect(server.address().port);
+    socket.end();
+  }));
+}
+
+{
+  const d = new Duplex({
+    autoDestroy: false,
+    write: common.mustCall((data, enc, cb) => {
+      d.push(data);
+      cb();
+    }),
+    read: common.mustCall(() => {
+      d.push(null);
+    }),
+    final: common.mustCall((cb) => {
+      setTimeout(() => {
+        assert.strictEqual(d.destroyed, false);
+        cb();
+      }, 1000);
+    }),
+    // `destroy()` won't be invoked by pipeline since
+    // the writable side has not completed when
+    // the pipeline has completed.
+    destroy: common.mustNotCall()
+  });
+
+  const sink = new Writable({
+    write: common.mustCall((data, enc, cb) => {
+      cb();
+    })
+  });
+
+  pipeline(d, sink, common.mustSucceed());
+
+  d.write('test');
+  d.end();
+}
+
 {
   const r = new Readable({
     read() {}
@@ -533,8 +1206,60 @@ const { promisify } = require('util');
       callback();
     }
   });
-  pipeline([r, w], common.mustCall((err) => {
-    assert.ok(!err);
+  pipeline([r, w], common.mustSucceed(() => {
     assert.strictEqual(res, 'helloworld');
   }));
 }
+
+{
+  pipeline([1, 2, 3], PassThrough({ objectMode: true }),
+           common.mustSucceed(() => {}));
+
+  let res = '';
+  const w = new Writable({
+    write(chunk, encoding, callback) {
+      res += chunk;
+      callback();
+    },
+  });
+  pipeline(['1', '2', '3'], w, common.mustSucceed(() => {
+    assert.strictEqual(res, '123');
+  }));
+}
+{
+  function createThenable() {
+    let counter = 0;
+    return {
+      get then() {
+        if (counter++) {
+          throw new Error('Cannot access `then` more than once');
+        }
+        return Function.prototype;
+      },
+    };
+  }
+
+  pipeline(
+    function* () {
+      yield 0;
+    },
+    createThenable,
+    () => common.mustNotCall(),
+  );
+}
+
+{
+  const content = 'abc';
+  pipeline(Buffer.from(content), PassThrough({ objectMode: true }),
+           common.mustSucceed(() => {}));
+
+  let res = '';
+  pipeline(Buffer.from(content), async function*(previous) {
+    for await (const val of previous) {
+      res += String.fromCharCode(val);
+      yield val;
+    }
+  }, common.mustSucceed(() => {
+    assert.strictEqual(res, content);
+  }));
+}
diff --git a/test/parallel/test-stream-readable-async-iterators.js b/test/parallel/test-stream-readable-async-iterators.js
index c8b0e5151af0aa7f2b77d14f06d91d23d5ffcc3a..a8dc0fa854b36019a7c3c69eda9e6344f53c4477 100644
--- a/test/parallel/test-stream-readable-async-iterators.js
+++ b/test/parallel/test-stream-readable-async-iterators.js
@@ -1,17 +1,71 @@
 'use strict';
 
 const common = require('../common');
-const { Readable, Transform, PassThrough, pipeline } = require('stream');
+const {
+  Stream,
+  Readable,
+  Transform,
+  PassThrough,
+  pipeline
+} = require('stream');
 const assert = require('assert');
+const http = require('http');
 
 async function tests() {
   {
-    const AsyncIteratorPrototype = Object.getPrototypeOf(
-      Object.getPrototypeOf(async function* () {}).prototype);
-    const rs = new Readable({});
-    assert.strictEqual(
-      Object.getPrototypeOf(Object.getPrototypeOf(rs[Symbol.asyncIterator]())),
-      AsyncIteratorPrototype);
+    // v1 stream
+
+    const stream = new Stream();
+    stream.destroy = common.mustCall();
+    process.nextTick(() => {
+      stream.emit('data', 'hello');
+      stream.emit('data', 'world');
+      stream.emit('end');
+    });
+
+    let res = '';
+    stream[Symbol.asyncIterator] = Readable.prototype[Symbol.asyncIterator];
+    for await (const d of stream) {
+      res += d;
+    }
+    assert.strictEqual(res, 'helloworld');
+  }
+
+  {
+    // v1 stream error
+
+    const stream = new Stream();
+    stream.close = common.mustCall();
+    process.nextTick(() => {
+      stream.emit('data', 0);
+      stream.emit('data', 1);
+      stream.emit('error', new Error('asd'));
+    });
+
+    const iter = Readable.prototype[Symbol.asyncIterator].call(stream);
+    await iter.next()
+      .then(common.mustNotCall())
+      .catch(common.mustCall((err) => {
+        assert.strictEqual(err.message, 'asd');
+      }));
+  }
+
+  {
+    // Non standard stream cleanup
+
+    const readable = new Readable({ autoDestroy: false, read() {} });
+    readable.push('asd');
+    readable.push('asd');
+    readable.destroy = null;
+    readable.close = common.mustCall(() => {
+      readable.emit('close');
+    });
+
+    await (async () => {
+      for await (const d of readable) { // eslint-disable-line no-unused-vars
+        return;
+      }
+    })();
   }
 
   {
@@ -126,12 +180,19 @@ async function tests() {
     resolved.forEach(common.mustCall(
       (item, i) => assert.strictEqual(item.value, 'hello-' + i), max));
 
-    errors.forEach((promise) => {
+    errors.slice(0, 1).forEach((promise) => {
       promise.catch(common.mustCall((err) => {
         assert.strictEqual(err.message, 'kaboom');
       }));
     });
 
+    errors.slice(1).forEach((promise) => {
+      promise.then(common.mustCall(({ done, value }) => {
+        assert.strictEqual(done, true);
+        assert.strictEqual(value, undefined);
+      }));
+    });
+
     readable.destroy(new Error('kaboom'));
   }
 
@@ -270,6 +331,22 @@ async function tests() {
     assert.strictEqual(received, 1);
   }
 
+  {
+    console.log('destroyed will not deadlock');
+    const readable = new Readable();
+    readable.destroy();
+    process.nextTick(async () => {
+      readable.on('close', common.mustNotCall());
+      let received = 0;
+      for await (const k of readable) {
+        // Just make linting pass. This should never run.
+        assert.strictEqual(k, 'hello');
+        received++;
+      }
+      assert.strictEqual(received, 0);
+    });
+  }
+
   {
     console.log('push async');
     const max = 42;
@@ -476,14 +553,84 @@ async function tests() {
       assert.strictEqual(e, err);
     })(), (async () => {
       let e;
+      let x;
       try {
-        await d;
+        x = await d;
       } catch (_e) {
         e = _e;
       }
-      assert.strictEqual(e, err);
+      assert.strictEqual(e, undefined);
+      assert.strictEqual(x.done, true);
+      assert.strictEqual(x.value, undefined);
     })()]);
   }
+
+  {
+    const _err = new Error('asd');
+    const r = new Readable({
+      read() {
+      },
+      destroy(err, callback) {
+        setTimeout(() => callback(_err), 1);
+      }
+    });
+
+    r.destroy();
+    const it = r[Symbol.asyncIterator]();
+    it.next().catch(common.mustCall((err) => {
+      assert.strictEqual(err, _err);
+    }));
+  }
+
+  {
+    // Don't destroy if no auto destroy.
+    // https://github.com/nodejs/node/issues/35116
+
+    const r = new Readable({
+      autoDestroy: false,
+      read() {
+        this.push('asd');
+        this.push(null);
+      }
+    });
+
+    for await (const chunk of r) {} // eslint-disable-line no-unused-vars
+    assert.strictEqual(r.destroyed, false);
+  }
+
+  {
+    // Destroy if no auto destroy and premature break.
+    // https://github.com/nodejs/node/pull/35122/files#r485678318
+
+    const r = new Readable({
+      autoDestroy: false,
+      read() {
+        this.push('asd');
+      }
+    });
+
+    for await (const chunk of r) { // eslint-disable-line no-unused-vars
+      break;
+    }
+    assert.strictEqual(r.destroyed, true);
+  }
+
+  {
+    // Don't destroy before 'end'.
+
+    const r = new Readable({
+      read() {
+        this.push('asd');
+        this.push(null);
+      }
+    }).on('end', () => {
+      assert.strictEqual(r.destroyed, false);
+    });
+
+    for await (const chunk of r) {} // eslint-disable-line no-unused-vars
+
+    assert.strictEqual(r.destroyed, true);
+  }
 }
 
 {
@@ -546,5 +693,83 @@ async function tests() {
   });
 }
 
+{
+  let _req;
+  const server = http.createServer((request, response) => {
+    response.statusCode = 404;
+    response.write('never ends');
+  });
+
+  server.listen(() => {
+    _req = http.request(`http://localhost:${server.address().port}`)
+      .on('response', common.mustCall(async (res) => {
+        setTimeout(() => {
+          _req.destroy(new Error('something happened'));
+        }, 100);
+
+        res.on('aborted', () => {
+          const err = new Error();
+          err.code = 'ECONNRESET';
+          res.emit('error', err);
+        });
+
+        res.on('error', common.mustCall());
+
+        let _err;
+        try {
+          // eslint-disable-next-line no-unused-vars
+          for await (const chunk of res) {}
+        } catch (err) {
+          _err = err;
+        }
+
+        assert.strictEqual(_err.code, 'ECONNRESET');
+        server.close();
+      }))
+      .on('error', common.mustCall())
+      .end();
+  });
+}
+
+{
+  async function getParsedBody(request) {
+    let body = '';
+
+    for await (const data of request) {
+      body += data;
+    }
+
+    try {
+      return JSON.parse(body);
+    } catch {
+      return {};
+    }
+  }
+
+  const str = JSON.stringify({ asd: true });
+  const server = http.createServer(async (request, response) => {
+    const body = await getParsedBody(request);
+    response.statusCode = 200;
+    assert.strictEqual(JSON.stringify(body), str);
+    response.end(JSON.stringify(body));
+  }).listen(() => {
+    http
+      .request({
+        method: 'POST',
+        hostname: 'localhost',
+        port: server.address().port,
+      })
+      .end(str)
+      .on('response', async (res) => {
+        let body = '';
+        for await (const chunk of res) {
+          body += chunk;
+        }
+        assert.strictEqual(body, str);
+        server.close();
+      });
+  });
+}
+
 // To avoid missing some tests if a promise does not resolve
 tests().then(common.mustCall());
diff --git a/test/parallel/test-stream-readable-destroy.js b/test/parallel/test-stream-readable-destroy.js
index 7687ea90cc82d806bb2d9428ed3fb237c16263f1..8ab78ec8ccec352a092789e3dd0d7000d9c17e33 100644
--- a/test/parallel/test-stream-readable-destroy.js
+++ b/test/parallel/test-stream-readable-destroy.js
@@ -113,7 +113,7 @@ const assert = require('assert');
   read.destroy();
 
   read.removeListener('end', fail);
-  read.on('end', common.mustCall());
+  read.on('end', common.mustNotCall());
   assert.strictEqual(read.destroyed, true);
 }
 
@@ -129,13 +129,20 @@ const assert = require('assert');
     cb(expected);
   });
 
+  let ticked = false;
   read.on('end', common.mustNotCall('no end event'));
   read.on('error', common.mustCall((err) => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(read._readableState.errorEmitted, true);
+    assert.strictEqual(read._readableState.errored, expected);
     assert.strictEqual(err, expected);
   }));
 
   read.destroy();
+  assert.strictEqual(read._readableState.errorEmitted, false);
+  assert.strictEqual(read._readableState.errored, expected);
   assert.strictEqual(read.destroyed, true);
+  ticked = true;
 }
 
 {
@@ -174,10 +181,58 @@ const assert = require('assert');
 
   const expected = new Error('kaboom');
 
-  read.on('close', common.mustCall());
+  let ticked = false;
+  read.on('close', common.mustCall(() => {
+    assert.strictEqual(read._readableState.errorEmitted, true);
+    assert.strictEqual(ticked, true);
+  }));
+  read.on('error', common.mustCall((err) => {
+    assert.strictEqual(err, expected);
+  }));
+
+  assert.strictEqual(read._readableState.errored, null);
+  assert.strictEqual(read._readableState.errorEmitted, false);
+
   read.destroy(expected, common.mustCall(function(err) {
+    assert.strictEqual(read._readableState.errored, expected);
     assert.strictEqual(err, expected);
   }));
+  assert.strictEqual(read._readableState.errorEmitted, false);
+  assert.strictEqual(read._readableState.errored, expected);
+  ticked = true;
+}
+
+{
+  const readable = new Readable({
+    destroy: common.mustCall(function(err, cb) {
+      process.nextTick(cb, new Error('kaboom 1'));
+    }),
+    read() {}
+  });
+
+  let ticked = false;
+  readable.on('close', common.mustCall(() => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(readable._readableState.errorEmitted, true);
+  }));
+  readable.on('error', common.mustCall((err) => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(err.message, 'kaboom 1');
+    assert.strictEqual(readable._readableState.errorEmitted, true);
+  }));
+
+  readable.destroy();
+  assert.strictEqual(readable.destroyed, true);
+  assert.strictEqual(readable._readableState.errored, null);
+  assert.strictEqual(readable._readableState.errorEmitted, false);
+
+  // Test case where `readable.destroy()` is called again with an error before
+  // the `_destroy()` callback is called.
+  readable.destroy(new Error('kaboom 2'));
+  assert.strictEqual(readable._readableState.errorEmitted, false);
+  assert.strictEqual(readable._readableState.errored, null);
+
+  ticked = true;
 }
 
 {
@@ -198,3 +253,18 @@ const assert = require('assert');
   assert.strictEqual(read.destroyed, true);
   read.read();
 }
+
+{
+  const read = new Readable({
+    autoDestroy: false,
+    read() {
+      this.push(null);
+      this.push('asd');
+    }
+  });
+
+  read.on('error', common.mustCall(() => {
+    assert(read._readableState.errored);
+  }));
+  read.resume();
+}
diff --git a/test/parallel/test-stream-readable-didRead.js b/test/parallel/test-stream-readable-didRead.js
new file mode 100644
index 0000000000000000000000000000000000000000..7508dd76899013cb0cc5f1860bee234e41097922
--- /dev/null
+++ b/test/parallel/test-stream-readable-didRead.js
@@ -0,0 +1,104 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const Readable = require('stream').Readable;
+
+function noop() {}
+
+function check(readable, data, fn) {
+  assert.strictEqual(readable.readableDidRead, false);
+  if (data === -1) {
+    readable.on('error', common.mustCall());
+    readable.on('data', common.mustNotCall());
+    readable.on('end', common.mustNotCall());
+  } else {
+    readable.on('error', common.mustNotCall());
+    if (data === -2) {
+      readable.on('end', common.mustNotCall());
+    } else {
+      readable.on('end', common.mustCall());
+    }
+    if (data > 0) {
+      readable.on('data', common.mustCallAtLeast(data));
+    } else {
+      readable.on('data', common.mustNotCall());
+    }
+  }
+  readable.on('close', common.mustCall());
+  fn();
+  setImmediate(() => {
+    assert.strictEqual(readable.readableDidRead, true);
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, 0, () => {
+    readable.read();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, 0, () => {
+    readable.resume();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, -2, () => {
+    readable.destroy();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+
+  check(readable, -1, () => {
+    readable.destroy(new Error());
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push('data');
+      this.push(null);
+    }
+  });
+
+  check(readable, 1, () => {
+    readable.on('data', noop);
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push('data');
+      this.push(null);
+    }
+  });
+
+  check(readable, 1, () => {
+    readable.on('data', noop);
+    readable.off('data', noop);
+  });
+}
diff --git a/test/parallel/test-stream-readable-end-destroyed.js b/test/parallel/test-stream-readable-end-destroyed.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b60bf4614770ab4bec9df44d5491a0750a31013
--- /dev/null
+++ b/test/parallel/test-stream-readable-end-destroyed.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common');
+const { Readable } = require('stream');
+
+{
+  // Don't emit 'end' after 'close'.
+
+  const r = new Readable();
+
+  r.on('end', common.mustNotCall());
+  r.resume();
+  r.destroy();
+  r.on('close', common.mustCall(() => {
+    r.push(null);
+  }));
+}
diff --git a/test/parallel/test-stream-readable-error-end.js b/test/parallel/test-stream-readable-error-end.js
new file mode 100644
index 0000000000000000000000000000000000000000..b46fd7f32c6bd99808bf266214e21796c720dd3c
--- /dev/null
+++ b/test/parallel/test-stream-readable-error-end.js
@@ -0,0 +1,15 @@
+'use strict';
+
+const common = require('../common');
+const { Readable } = require('stream');
+
+{
+  const r = new Readable({ read() {} });
+
+  r.on('end', common.mustNotCall());
+  r.on('data', common.mustCall());
+  r.on('error', common.mustCall());
+  r.push('asd');
+  r.push(null);
+  r.destroy(new Error('kaboom'));
+}
diff --git a/test/parallel/test-stream-readable-invalid-chunk.js b/test/parallel/test-stream-readable-invalid-chunk.js
index ce830bab41b01ff5341001a069be7359f690d40a..0fcc76ae73fae318d91b76f39862503e0d0de4b9 100644
--- a/test/parallel/test-stream-readable-invalid-chunk.js
+++ b/test/parallel/test-stream-readable-invalid-chunk.js
@@ -17,3 +17,18 @@ function testPushArg(val) {
 testPushArg([]);
 testPushArg({});
 testPushArg(0);
+
+function testUnshiftArg(val) {
+  const readable = new stream.Readable({
+    read: () => {}
+  });
+  readable.on('error', common.expectsError({
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError'
+  }));
+  readable.unshift(val);
+}
+
+testUnshiftArg([]);
+testUnshiftArg({});
+testUnshiftArg(0);
diff --git a/test/parallel/test-stream-readable-readable.js b/test/parallel/test-stream-readable-readable.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e1a7fb32e30806da608eb9594cb9f2b03b29c62
--- /dev/null
+++ b/test/parallel/test-stream-readable-readable.js
@@ -0,0 +1,45 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { Readable } = require('stream');
+
+{
+  const r = new Readable({
+    read() {}
+  });
+  assert.strictEqual(r.readable, true);
+  r.destroy();
+  assert.strictEqual(r.readable, false);
+}
+
+{
+  const mustNotCall = common.mustNotCall();
+  const r = new Readable({
+    read() {}
+  });
+  assert.strictEqual(r.readable, true);
+  r.on('end', mustNotCall);
+  r.resume();
+  r.push(null);
+  assert.strictEqual(r.readable, true);
+  r.off('end', mustNotCall);
+  r.on('end', common.mustCall(() => {
+    assert.strictEqual(r.readable, false);
+  }));
+}
+
+{
+  const r = new Readable({
+    read: common.mustCall(() => {
+      process.nextTick(() => {
+        r.destroy(new Error());
+        assert.strictEqual(r.readable, false);
+      });
+    })
+  });
+  r.resume();
+  r.on('error', common.mustCall(() => {
+    assert.strictEqual(r.readable, false);
+  }));
+}
diff --git a/test/parallel/test-stream-readable-unshift.js b/test/parallel/test-stream-readable-unshift.js
index 4b3bfab19f9c24da7f6d7a4ae849c000bdb27c31..6eefb55d73bc88d9b229fa44c18a61b2012ed764 100644
--- a/test/parallel/test-stream-readable-unshift.js
+++ b/test/parallel/test-stream-readable-unshift.js
@@ -112,23 +112,6 @@ const { Readable } = require('stream');
 
 }
 
-{
-  // Check that error is thrown for invalid chunks
-
-  const readable = new Readable({ read() {} });
-  function checkError(fn) {
-    assert.throws(fn, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError'
-    });
-  }
-
-  checkError(() => readable.unshift([]));
-  checkError(() => readable.unshift({}));
-  checkError(() => readable.unshift(0));
-
-}
-
 {
   // Check that ObjectMode works
   const readable = new Readable({ objectMode: true, read() {} });
diff --git a/test/parallel/test-stream-readable-with-unimplemented-_read.js b/test/parallel/test-stream-readable-with-unimplemented-_read.js
index 7d48c422535152c22e1ceba60bb0eb423d72a5dd..16ec2ac8cd88523a0e755fc4126e88221a96ad0f 100644
--- a/test/parallel/test-stream-readable-with-unimplemented-_read.js
+++ b/test/parallel/test-stream-readable-with-unimplemented-_read.js
@@ -1,14 +1,18 @@
 'use strict';
-const common = require('../common');
+require('../common');
 
+const assert = require('assert');
 const { Readable } = require('stream');
 
 const readable = new Readable();
 
-readable.on('error', common.expectsError({
-  code: 'ERR_METHOD_NOT_IMPLEMENTED',
-  name: 'Error',
-  message: 'The _read() method is not implemented'
-}));
-
-readable.read();
+assert.throws(
+  () => {
+    readable.read();
+  },
+  {
+    code: 'ERR_METHOD_NOT_IMPLEMENTED',
+    name: 'Error',
+    message: 'The _read() method is not implemented'
+  }
+);
diff --git a/test/parallel/test-stream-transform-constructor-set-methods.js b/test/parallel/test-stream-transform-constructor-set-methods.js
index 8a4abd6860671a309919e4d740e5da378e90c959..a20a1a07cffee87ac59c3d63f1075d3f1863905b 100644
--- a/test/parallel/test-stream-transform-constructor-set-methods.js
+++ b/test/parallel/test-stream-transform-constructor-set-methods.js
@@ -1,18 +1,21 @@
 'use strict';
 const common = require('../common');
 
-const { strictEqual } = require('assert');
+const assert = require('assert');
 const { Transform } = require('stream');
 
 const t = new Transform();
 
-t.on('error', common.expectsError({
-  name: 'Error',
-  code: 'ERR_METHOD_NOT_IMPLEMENTED',
-  message: 'The _transform() method is not implemented'
-}));
-
-t.end(Buffer.from('blerg'));
+assert.throws(
+  () => {
+    t.end(Buffer.from('blerg'));
+  },
+  {
+    name: 'Error',
+    code: 'ERR_METHOD_NOT_IMPLEMENTED',
+    message: 'The _transform() method is not implemented'
+  }
+);
 
 const _transform = common.mustCall((chunk, _, next) => {
   next();
@@ -32,9 +35,9 @@ const t2 = new Transform({
   final: _final
 });
 
-strictEqual(t2._transform, _transform);
-strictEqual(t2._flush, _flush);
-strictEqual(t2._final, _final);
+assert.strictEqual(t2._transform, _transform);
+assert.strictEqual(t2._flush, _flush);
+assert.strictEqual(t2._final, _final);
 
 t2.end(Buffer.from('blerg'));
 t2.resume();
diff --git a/test/parallel/test-stream-transform-final-sync.js b/test/parallel/test-stream-transform-final-sync.js
index 1942bee1a01e8a422fcef241f28cd010c5d76837..739421382dce53c3e352773ca2dc6b6013425c5b 100644
--- a/test/parallel/test-stream-transform-final-sync.js
+++ b/test/parallel/test-stream-transform-final-sync.js
@@ -5,56 +5,56 @@ const assert = require('assert');
 const stream = require('stream');
 let state = 0;
 
-/*
-What you do
-const stream = new stream.Transform({
-  transform: function transformCallback(chunk, _, next) {
-    // part 1
-    this.push(chunk);
-    //part 2
-    next();
-  },
-  final: function endCallback(done) {
-    // part 1
-    process.nextTick(function () {
-      // part 2
-      done();
-    });
-  },
-  flush: function flushCallback(done) {
-    // part 1
-    process.nextTick(function () {
-      // part 2
-      done();
-    });
-  }
-});
-t.on('data', dataListener);
-t.on('end', endListener);
-t.on('finish', finishListener);
-t.write(1);
-t.write(4);
-t.end(7, endMethodCallback);
-
-The order things are called
 
-1. transformCallback part 1
-2. dataListener
-3. transformCallback part 2
-4. transformCallback part 1
-5. dataListener
-6. transformCallback part 2
-7. transformCallback part 1
-8. dataListener
-9. transformCallback part 2
-10. finalCallback part 1
-11. finalCallback part 2
-12. flushCallback part 1
-13. finishListener
-14. endMethodCallback
-15. flushCallback part 2
-16. endListener
-*/
+// What you do
+//
+// const stream = new stream.Transform({
+//   transform: function transformCallback(chunk, _, next) {
+//     // part 1
+//     this.push(chunk);
+//     //part 2
+//     next();
+//   },
+//   final: function endCallback(done) {
+//     // part 1
+//     process.nextTick(function () {
+//       // part 2
+//       done();
+//     });
+//   },
+//   flush: function flushCallback(done) {
+//     // part 1
+//     process.nextTick(function () {
+//       // part 2
+//       done();
+//     });
+//   }
+// });
+// t.on('data', dataListener);
+// t.on('end', endListener);
+// t.on('finish', finishListener);
+// t.write(1);
+// t.write(4);
+// t.end(7, endMethodCallback);
+//
+// The order things are called
+//
+// 1. transformCallback part 1
+// 2. dataListener
+// 3. transformCallback part 2
+// 4. transformCallback part 1
+// 5. dataListener
+// 6. transformCallback part 2
+// 7. transformCallback part 1
+// 8. dataListener
+// 9. transformCallback part 2
+// 10. finalCallback part 1
+// 11. finalCallback part 2
+// 12. flushCallback part 1
+// 13. finishListener
+// 14. endMethodCallback
+// 15. flushCallback part 2
+// 16. endListener
 
 const t = new stream.Transform({
   objectMode: true,
diff --git a/test/parallel/test-stream-transform-final.js b/test/parallel/test-stream-transform-final.js
index 53b81cfea224e496ed2cd668e5d46ff9d707db64..6ac6013d6cca7b2aeb5f9068115bfcf4f0c54157 100644
--- a/test/parallel/test-stream-transform-final.js
+++ b/test/parallel/test-stream-transform-final.js
@@ -5,56 +5,56 @@ const assert = require('assert');
 const stream = require('stream');
 let state = 0;
 
-/*
-What you do
-const stream = new stream.Transform({
-  transform: function transformCallback(chunk, _, next) {
-    // part 1
-    this.push(chunk);
-    //part 2
-    next();
-  },
-  final: function endCallback(done) {
-    // part 1
-    process.nextTick(function () {
-      // part 2
-      done();
-    });
-  },
-  flush: function flushCallback(done) {
-    // part 1
-    process.nextTick(function () {
-      // part 2
-      done();
-    });
-  }
-});
-t.on('data', dataListener);
-t.on('end', endListener);
-t.on('finish', finishListener);
-t.write(1);
-t.write(4);
-t.end(7, endMethodCallback);
 
-The order things are called
+// What you do:
+//
+// const stream = new stream.Transform({
+//   transform: function transformCallback(chunk, _, next) {
+//     // part 1
+//     this.push(chunk);
+//     //part 2
+//     next();
+//   },
+//   final: function endCallback(done) {
+//     // part 1
+//     process.nextTick(function () {
+//       // part 2
+//       done();
+//     });
+//   },
+//   flush: function flushCallback(done) {
+//     // part 1
+//     process.nextTick(function () {
+//       // part 2
+//       done();
+//     });
+//   }
+// });
+// t.on('data', dataListener);
+// t.on('end', endListener);
+// t.on('finish', finishListener);
+// t.write(1);
+// t.write(4);
+// t.end(7, endMethodCallback);
+//
+// The order things are called
 
-1. transformCallback part 1
-2. dataListener
-3. transformCallback part 2
-4. transformCallback part 1
-5. dataListener
-6. transformCallback part 2
-7. transformCallback part 1
-8. dataListener
-9. transformCallback part 2
-10. finalCallback part 1
-11. finalCallback part 2
-12. flushCallback part 1
-13. finishListener
-14. endMethodCallback
-15. flushCallback part 2
-16. endListener
-*/
+// 1. transformCallback part 1
+// 2. dataListener
+// 3. transformCallback part 2
+// 4. transformCallback part 1
+// 5. dataListener
+// 6. transformCallback part 2
+// 7. transformCallback part 1
+// 8. dataListener
+// 9. transformCallback part 2
+// 10. finalCallback part 1
+// 11. finalCallback part 2
+// 12. flushCallback part 1
+// 13. finishListener
+// 14. endMethodCallback
+// 15. flushCallback part 2
+// 16. endListener
 
 const t = new stream.Transform({
   objectMode: true,
diff --git a/test/parallel/test-stream-unpipe-event.js b/test/parallel/test-stream-unpipe-event.js
index 340502d1a98b7c69ceeb5029e2579ddcb440e4b3..46cc8e8cb0ae9e20596017940141fd4be8c5e368 100644
--- a/test/parallel/test-stream-unpipe-event.js
+++ b/test/parallel/test-stream-unpipe-event.js
@@ -23,7 +23,7 @@ class NeverEndReadable extends Readable {
   dest.on('unpipe', common.mustCall());
   src.pipe(dest);
   setImmediate(() => {
-    assert.strictEqual(src._readableState.pipesCount, 0);
+    assert.strictEqual(src._readableState.pipes.length, 0);
   });
 }
 
@@ -34,7 +34,7 @@ class NeverEndReadable extends Readable {
   dest.on('unpipe', common.mustNotCall('unpipe should not have been emitted'));
   src.pipe(dest);
   setImmediate(() => {
-    assert.strictEqual(src._readableState.pipesCount, 1);
+    assert.strictEqual(src._readableState.pipes.length, 1);
   });
 }
 
@@ -46,7 +46,7 @@ class NeverEndReadable extends Readable {
   src.pipe(dest);
   src.unpipe(dest);
   setImmediate(() => {
-    assert.strictEqual(src._readableState.pipesCount, 0);
+    assert.strictEqual(src._readableState.pipes.length, 0);
   });
 }
 
@@ -57,7 +57,7 @@ class NeverEndReadable extends Readable {
   dest.on('unpipe', common.mustCall());
   src.pipe(dest, { end: false });
   setImmediate(() => {
-    assert.strictEqual(src._readableState.pipesCount, 0);
+    assert.strictEqual(src._readableState.pipes.length, 0);
   });
 }
 
@@ -68,7 +68,7 @@ class NeverEndReadable extends Readable {
   dest.on('unpipe', common.mustNotCall('unpipe should not have been emitted'));
   src.pipe(dest, { end: false });
   setImmediate(() => {
-    assert.strictEqual(src._readableState.pipesCount, 1);
+    assert.strictEqual(src._readableState.pipes.length, 1);
   });
 }
 
@@ -80,6 +80,6 @@ class NeverEndReadable extends Readable {
   src.pipe(dest, { end: false });
   src.unpipe(dest);
   setImmediate(() => {
-    assert.strictEqual(src._readableState.pipesCount, 0);
+    assert.strictEqual(src._readableState.pipes.length, 0);
   });
 }
diff --git a/test/parallel/test-stream-unshift-read-race.js b/test/parallel/test-stream-unshift-read-race.js
index ecf55382f9c2c7fb05969c54c5e73b0e147ec3a0..fe110ea285521eda68a53b71d30543a44d38803f 100644
--- a/test/parallel/test-stream-unshift-read-race.js
+++ b/test/parallel/test-stream-unshift-read-race.js
@@ -32,7 +32,7 @@ const assert = require('assert');
 
 const stream = require('stream');
 const hwm = 10;
-const r = stream.Readable({ highWaterMark: hwm });
+const r = stream.Readable({ highWaterMark: hwm, autoDestroy: false });
 const chunks = 10;
 
 const data = Buffer.allocUnsafe(chunks * hwm + Math.ceil(hwm / 2));
@@ -68,6 +68,9 @@ r._read = function(n) {
 };
 
 function pushError() {
+  r.unshift(Buffer.allocUnsafe(1));
+  w.end();
+
   assert.throws(() => {
     r.push(Buffer.allocUnsafe(1));
   }, {
@@ -77,6 +80,7 @@ function pushError() {
   });
 }
 
+
 const w = stream.Writable();
 const written = [];
 w._write = function(chunk, encoding, cb) {
@@ -84,16 +88,7 @@ w._write = function(chunk, encoding, cb) {
   cb();
 };
 
-r.on('end', common.mustCall(function() {
-  assert.throws(function() {
-    r.unshift(Buffer.allocUnsafe(1));
-  }, {
-    code: 'ERR_STREAM_UNSHIFT_AFTER_END_EVENT',
-    name: 'Error',
-    message: 'stream.unshift() after end event'
-  });
-  w.end();
-}));
+r.on('end', common.mustNotCall());
 
 r.on('readable', function() {
   let chunk;
diff --git a/test/parallel/test-stream-writable-callback-twice.js b/test/parallel/test-stream-writable-callback-twice.js
new file mode 100644
index 0000000000000000000000000000000000000000..25e7579a2d4737d05378a537de725a1bf90e8cb2
--- /dev/null
+++ b/test/parallel/test-stream-writable-callback-twice.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+const { Writable } = require('stream');
+const stream = new Writable({
+  write(chunk, enc, cb) { cb(); cb(); }
+});
+
+stream.on('error', common.expectsError({
+  name: 'Error',
+  message: 'Callback called multiple times',
+  code: 'ERR_MULTIPLE_CALLBACK'
+}));
+
+stream.write('foo');
diff --git a/test/parallel/test-stream-writable-constructor-set-methods.js b/test/parallel/test-stream-writable-constructor-set-methods.js
index c326428210c16b6c494c0fd23348b6bbba6acd55..34fda8edda9fc1cca432f356819f01ef641a3ef8 100644
--- a/test/parallel/test-stream-writable-constructor-set-methods.js
+++ b/test/parallel/test-stream-writable-constructor-set-methods.js
@@ -1,34 +1,36 @@
 'use strict';
 const common = require('../common');
 
-const { strictEqual } = require('assert');
+const assert = require('assert');
 const { Writable } = require('stream');
 
-const w = new Writable();
-
-w.on('error', common.expectsError({
-  name: 'Error',
-  code: 'ERR_METHOD_NOT_IMPLEMENTED',
-  message: 'The _write() method is not implemented'
-}));
-
 const bufferBlerg = Buffer.from('blerg');
+const w = new Writable();
 
-w.end(bufferBlerg);
+assert.throws(
+  () => {
+    w.end(bufferBlerg);
+  },
+  {
+    name: 'Error',
+    code: 'ERR_METHOD_NOT_IMPLEMENTED',
+    message: 'The _write() method is not implemented'
+  }
+);
 
 const _write = common.mustCall((chunk, _, next) => {
   next();
 });
 
 const _writev = common.mustCall((chunks, next) => {
-  strictEqual(chunks.length, 2);
+  assert.strictEqual(chunks.length, 2);
   next();
 });
 
 const w2 = new Writable({ write: _write, writev: _writev });
 
-strictEqual(w2._write, _write);
-strictEqual(w2._writev, _writev);
+assert.strictEqual(w2._write, _write);
+assert.strictEqual(w2._writev, _writev);
 
 w2.write(bufferBlerg);
 
diff --git a/test/parallel/test-stream-writable-destroy.js b/test/parallel/test-stream-writable-destroy.js
index 4302c5abc83389735c1d22ee64fa43e9625e59a8..f3ca402d5b3f94108ef290914bf7bfbca8755c90 100644
--- a/test/parallel/test-stream-writable-destroy.js
+++ b/test/parallel/test-stream-writable-destroy.js
@@ -16,6 +16,20 @@ const assert = require('assert');
   assert.strictEqual(write.destroyed, true);
 }
 
+{
+  const write = new Writable({
+    write(chunk, enc, cb) {
+      this.destroy(new Error('asd'));
+      cb();
+    }
+  });
+
+  write.on('error', common.mustCall());
+  write.on('finish', common.mustNotCall());
+  write.end('asd');
+  assert.strictEqual(write.destroyed, true);
+}
+
 {
   const write = new Writable({
     write(chunk, enc, cb) { cb(); }
@@ -143,13 +157,23 @@ const assert = require('assert');
     write(chunk, enc, cb) { cb(); }
   });
 
-  write.on('close', common.mustCall());
-  write.on('error', common.mustCall());
+  let ticked = false;
+  write.on('close', common.mustCall(() => {
+    assert.strictEqual(ticked, true);
+  }));
+  write.on('error', common.mustCall((err) => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(err.message, 'kaboom 1');
+    assert.strictEqual(write._writableState.errorEmitted, true);
+  }));
 
-  write.destroy(new Error('kaboom 1'));
+  const expected = new Error('kaboom 1');
+  write.destroy(expected);
   write.destroy(new Error('kaboom 2'));
-  assert.strictEqual(write._writableState.errorEmitted, true);
+  assert.strictEqual(write._writableState.errored, expected);
+  assert.strictEqual(write._writableState.errorEmitted, false);
   assert.strictEqual(write.destroyed, true);
+  ticked = true;
 }
 
 {
@@ -162,20 +186,31 @@ const assert = require('assert');
     }
   });
 
-  writable.on('close', common.mustCall());
-  writable.on('error', common.expectsError({
-    name: 'Error',
-    message: 'kaboom 2'
+  let ticked = false;
+  writable.on('close', common.mustCall(() => {
+    writable.on('error', common.mustNotCall());
+    writable.destroy(new Error('hello'));
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(writable._writableState.errorEmitted, true);
+  }));
+  writable.on('error', common.mustCall((err) => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(err.message, 'kaboom 1');
+    assert.strictEqual(writable._writableState.errorEmitted, true);
   }));
 
   writable.destroy();
   assert.strictEqual(writable.destroyed, true);
+  assert.strictEqual(writable._writableState.errored, null);
   assert.strictEqual(writable._writableState.errorEmitted, false);
 
   // Test case where `writable.destroy()` is called again with an error before
   // the `_destroy()` callback is called.
   writable.destroy(new Error('kaboom 2'));
-  assert.strictEqual(writable._writableState.errorEmitted, true);
+  assert.strictEqual(writable._writableState.errorEmitted, false);
+  assert.strictEqual(writable._writableState.errored, null);
+
+  ticked = true;
 }
 
 {
@@ -214,8 +249,8 @@ const assert = require('assert');
 
   const expected = new Error('kaboom');
 
-  write.destroy(expected, common.mustCall(function(err) {
-    assert.strictEqual(err, expected);
+  write.destroy(expected, common.mustCall((err) => {
+    assert.strictEqual(err, undefined);
   }));
 }
 
@@ -224,11 +259,172 @@ const assert = require('assert');
   // called again.
   const write = new Writable({
     write: common.mustNotCall(),
-    final: common.mustCall((cb) => cb(), 2)
+    final: common.mustCall((cb) => cb(), 2),
+    autoDestroy: true
   });
 
   write.end();
+  write.once('close', common.mustCall(() => {
+    write._undestroy();
+    write.end();
+  }));
+}
+
+{
+  const write = new Writable();
+
   write.destroy();
-  write._undestroy();
+  write.on('error', common.mustNotCall());
+  write.write('asd', common.expectsError({
+    name: 'Error',
+    code: 'ERR_STREAM_DESTROYED',
+    message: 'Cannot call write after a stream was destroyed'
+  }));
+}
+
+{
+  const write = new Writable({
+    write(chunk, enc, cb) { cb(); }
+  });
+
+  write.on('error', common.mustNotCall());
+
+  write.cork();
+  write.write('asd', common.mustCall());
+  write.uncork();
+
+  write.cork();
+  write.write('asd', common.expectsError({
+    name: 'Error',
+    code: 'ERR_STREAM_DESTROYED',
+    message: 'Cannot call write after a stream was destroyed'
+  }));
+  write.destroy();
+  write.write('asd', common.expectsError({
+    name: 'Error',
+    code: 'ERR_STREAM_DESTROYED',
+    message: 'Cannot call write after a stream was destroyed'
+  }));
+  write.uncork();
+}
+
+{
+  // Call end(cb) after error & destroy
+
+  const write = new Writable({
+    write(chunk, enc, cb) { cb(new Error('asd')); }
+  });
+  write.on('error', common.mustCall(() => {
+    write.destroy();
+    let ticked = false;
+    write.end(common.mustCall((err) => {
+      assert.strictEqual(ticked, true);
+      assert.strictEqual(err.code, 'ERR_STREAM_DESTROYED');
+    }));
+    ticked = true;
+  }));
+  write.write('asd');
+}
+
+{
+  // Call end(cb) after finish & destroy
+
+  const write = new Writable({
+    write(chunk, enc, cb) { cb(); }
+  });
+  write.on('finish', common.mustCall(() => {
+    write.destroy();
+    let ticked = false;
+    write.end(common.mustCall((err) => {
+      assert.strictEqual(ticked, true);
+      assert.strictEqual(err.code, 'ERR_STREAM_ALREADY_FINISHED');
+    }));
+    ticked = true;
+  }));
   write.end();
 }
+
+{
+  // Call end(cb) after error & destroy and don't trigger
+  // unhandled exception.
+
+  const write = new Writable({
+    write(chunk, enc, cb) { process.nextTick(cb); }
+  });
+  write.once('error', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'asd');
+  }));
+  write.end('asd', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'asd');
+  }));
+  write.destroy(new Error('asd'));
+}
+
+{
+  // Call buffered write callback with error
+
+  const write = new Writable({
+    write(chunk, enc, cb) {
+      process.nextTick(cb, new Error('asd'));
+    },
+    autoDestroy: false
+  });
+  write.cork();
+  write.write('asd', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'asd');
+  }));
+  write.write('asd', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_DESTROYED');
+  }));
+  write.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'asd');
+  }));
+  write.uncork();
+}
+
+{
+  // Ensure callback order.
+
+  let state = 0;
+  const write = new Writable({
+    write(chunk, enc, cb) {
+      // `setImmediate()` is used on purpose to ensure the callback is called
+      // after `process.nextTick()` callbacks.
+      setImmediate(cb);
+    }
+  });
+  write.write('asd', common.mustCall(() => {
+    assert.strictEqual(state++, 0);
+  }));
+  write.write('asd', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_STREAM_DESTROYED');
+    assert.strictEqual(state++, 1);
+  }));
+  write.destroy();
+}
+
+{
+  const write = new Writable({
+    autoDestroy: false,
+    write(chunk, enc, cb) {
+      cb();
+      cb();
+    }
+  });
+
+  write.on('error', common.mustCall(() => {
+    assert(write._writableState.errored);
+  }));
+  write.write('asd');
+}
+
+{
+  // Destroy twice
+  const write = new Writable({
+    write(chunk, enc, cb) { cb(); }
+  });
+
+  write.end(common.mustCall());
+  write.destroy();
+  write.destroy();
+}
diff --git a/test/parallel/test-stream-writable-end-cb-error.js b/test/parallel/test-stream-writable-end-cb-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..24989a6d06a1113e036a89af049677c866e62835
--- /dev/null
+++ b/test/parallel/test-stream-writable-end-cb-error.js
@@ -0,0 +1,48 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+{
+  // Invoke end callback on failure.
+  const writable = new stream.Writable();
+
+  writable._write = (chunk, encoding, cb) => {
+    process.nextTick(cb, new Error('kaboom'));
+  };
+
+  writable.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+  }));
+  writable.write('asd');
+  writable.end(common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+  }));
+  writable.end(common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+  }));
+}
+
+{
+  // Don't invoke end callback twice
+  const writable = new stream.Writable();
+
+  writable._write = (chunk, encoding, cb) => {
+    process.nextTick(cb);
+  };
+
+  let called = false;
+  writable.end('asd', common.mustCall((err) => {
+    called = true;
+    assert.strictEqual(err, undefined);
+  }));
+
+  writable.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'kaboom');
+  }));
+  writable.on('finish', common.mustCall(() => {
+    assert.strictEqual(called, true);
+    writable.emit('error', new Error('kaboom'));
+  }));
+}
diff --git a/test/parallel/test-stream-writable-end-cb-uncaught.js b/test/parallel/test-stream-writable-end-cb-uncaught.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab25cac81b0bee21f794a8f30404165b7776066e
--- /dev/null
+++ b/test/parallel/test-stream-writable-end-cb-uncaught.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const stream = require('stream');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'kaboom');
+}));
+
+const writable = new stream.Writable();
+
+writable._write = (chunk, encoding, cb) => {
+  cb();
+};
+writable._final = (cb) => {
+  cb(new Error('kaboom'));
+};
+
+writable.write('asd');
+writable.end(common.mustCall((err) => {
+  assert.strictEqual(err.message, 'kaboom');
+}));
diff --git a/test/parallel/test-stream-writable-end-multiple.js b/test/parallel/test-stream-writable-end-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..000f5b07f594f6eac3da880119b743c14b53746c
--- /dev/null
+++ b/test/parallel/test-stream-writable-end-multiple.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const stream = require('stream');
+
+const writable = new stream.Writable();
+writable._write = (chunk, encoding, cb) => {
+  setTimeout(() => cb(), 10);
+};
+
+writable.end('testing ended state', common.mustCall());
+writable.end(common.mustCall());
+writable.on('finish', common.mustCall(() => {
+  let ticked = false;
+  writable.end(common.mustCall((err) => {
+    assert.strictEqual(ticked, true);
+    assert.strictEqual(err.code, 'ERR_STREAM_ALREADY_FINISHED');
+  }));
+  ticked = true;
+}));
diff --git a/test/parallel/test-stream-writable-ended-state.js b/test/parallel/test-stream-writable-ended-state.js
index e5fa624c12aed7d286cffaff814e3c7ee7d41420..2c40c62a9ee9a567c48652cc40abbe1e4536920a 100644
--- a/test/parallel/test-stream-writable-ended-state.js
+++ b/test/parallel/test-stream-writable-ended-state.js
@@ -9,17 +9,24 @@ const writable = new stream.Writable();
 
 writable._write = (chunk, encoding, cb) => {
   assert.strictEqual(writable._writableState.ended, false);
+  assert.strictEqual(writable._writableState.writable, undefined);
   assert.strictEqual(writable.writableEnded, false);
   cb();
 };
 
 assert.strictEqual(writable._writableState.ended, false);
+assert.strictEqual(writable._writableState.writable, undefined);
+assert.strictEqual(writable.writable, true);
 assert.strictEqual(writable.writableEnded, false);
 
 writable.end('testing ended state', common.mustCall(() => {
   assert.strictEqual(writable._writableState.ended, true);
+  assert.strictEqual(writable._writableState.writable, undefined);
+  assert.strictEqual(writable.writable, false);
   assert.strictEqual(writable.writableEnded, true);
 }));
 
 assert.strictEqual(writable._writableState.ended, true);
+assert.strictEqual(writable._writableState.writable, undefined);
+assert.strictEqual(writable.writable, false);
 assert.strictEqual(writable.writableEnded, true);
diff --git a/test/parallel/test-stream-writable-finished.js b/test/parallel/test-stream-writable-finished.js
index a5dfc060256a028a16ad614d9d64474c8b44b436..dfe87a9005db8c655cd493c1e0440830fa2b392a 100644
--- a/test/parallel/test-stream-writable-finished.js
+++ b/test/parallel/test-stream-writable-finished.js
@@ -28,3 +28,16 @@ const assert = require('assert');
     assert.strictEqual(writable.writableFinished, true);
   }));
 }
+
+{
+  // Emit finish asynchronously
+
+  const w = new Writable({
+    write(chunk, encoding, cb) {
+      cb();
+    }
+  });
+
+  w.end();
+  w.on('finish', common.mustCall());
+}
diff --git a/test/parallel/test-stream-writable-invalid-chunk.js b/test/parallel/test-stream-writable-invalid-chunk.js
index 09ee5877c8d00c653e1d10eec4d8d37cd3cf57d4..09032c07c5925551a3d78116a0def9bb831b4142 100644
--- a/test/parallel/test-stream-writable-invalid-chunk.js
+++ b/test/parallel/test-stream-writable-invalid-chunk.js
@@ -2,20 +2,21 @@
 
 const common = require('../common');
 const stream = require('stream');
+const assert = require('assert');
 
 function testWriteType(val, objectMode, code) {
   const writable = new stream.Writable({
     objectMode,
     write: () => {}
   });
-  if (!code) {
-    writable.on('error', common.mustNotCall());
+  writable.on('error', common.mustNotCall());
+  if (code) {
+    assert.throws(() => {
+      writable.write(val);
+    }, { code });
   } else {
-    writable.on('error', common.expectsError({
-      code: code,
-    }));
+    writable.write(val);
   }
-  writable.write(val);
 }
 
 testWriteType([], false, 'ERR_INVALID_ARG_TYPE');
diff --git a/test/parallel/test-stream-writable-needdrain-state.js b/test/parallel/test-stream-writable-needdrain-state.js
index ea5617d997d5eddfa3df4753d953da07c35e52da..0e72d832bc3ff063e2f5eca7f80f88df5906a7b1 100644
--- a/test/parallel/test-stream-writable-needdrain-state.js
+++ b/test/parallel/test-stream-writable-needdrain-state.js
@@ -10,8 +10,10 @@ const transform = new stream.Transform({
 });
 
 function _transform(chunk, encoding, cb) {
-  assert.strictEqual(transform._writableState.needDrain, true);
-  cb();
+  process.nextTick(() => {
+    assert.strictEqual(transform._writableState.needDrain, true);
+    cb();
+  });
 }
 
 assert.strictEqual(transform._writableState.needDrain, false);
diff --git a/test/parallel/test-stream-writable-null.js b/test/parallel/test-stream-writable-null.js
index 506b1df3d08cd9f1fd2640e54a62fb6fb7dcd94b..99419f1cf9a066bea67d0b641b4876be466b0d9f 100644
--- a/test/parallel/test-stream-writable-null.js
+++ b/test/parallel/test-stream-writable-null.js
@@ -1,47 +1,37 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const stream = require('stream');
 
 class MyWritable extends stream.Writable {
+  constructor(options) {
+    super({ autoDestroy: false, ...options });
+  }
   _write(chunk, encoding, callback) {
     assert.notStrictEqual(chunk, null);
     callback();
   }
 }
 
-assert.throws(
-  () => {
-    const m = new MyWritable({ objectMode: true });
-    m.write(null, (err) => assert.ok(err));
-  },
-  {
-    code: 'ERR_STREAM_NULL_VALUES',
-    name: 'TypeError',
-    message: 'May not write null values to stream'
-  }
-);
-
-{ // Should not throw.
-  const m = new MyWritable({ objectMode: true }).on('error', assert);
-  m.write(null, assert);
+{
+  const m = new MyWritable({ objectMode: true });
+  m.on('error', common.mustNotCall());
+  assert.throws(() => {
+    m.write(null);
+  }, {
+    code: 'ERR_STREAM_NULL_VALUES'
+  });
 }
 
-assert.throws(
-  () => {
-    const m = new MyWritable();
-    m.write(false, (err) => assert.ok(err));
-  },
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError'
-  }
-);
-
-{ // Should not throw.
-  const m = new MyWritable().on('error', assert);
-  m.write(false, assert);
+{
+  const m = new MyWritable();
+  m.on('error', common.mustNotCall());
+  assert.throws(() => {
+    m.write(false);
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
 }
 
 { // Should not throw.
diff --git a/test/parallel/test-stream-writable-writable.js b/test/parallel/test-stream-writable-writable.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef5454dc52ef352704aa9cd3ea05ae518ff1781b
--- /dev/null
+++ b/test/parallel/test-stream-writable-writable.js
@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { Writable } = require('stream');
+
+{
+  const w = new Writable({
+    write() {}
+  });
+  assert.strictEqual(w.writable, true);
+  w.destroy();
+  assert.strictEqual(w.writable, false);
+}
+
+{
+  const w = new Writable({
+    write: common.mustCall((chunk, encoding, callback) => {
+      callback(new Error());
+    })
+  });
+  assert.strictEqual(w.writable, true);
+  w.write('asd');
+  assert.strictEqual(w.writable, false);
+  w.on('error', common.mustCall());
+}
+
+{
+  const w = new Writable({
+    write: common.mustCall((chunk, encoding, callback) => {
+      process.nextTick(() => {
+        callback(new Error());
+        assert.strictEqual(w.writable, false);
+      });
+    })
+  });
+  w.write('asd');
+  w.on('error', common.mustCall());
+}
+
+{
+  const w = new Writable({
+    write: common.mustNotCall()
+  });
+  assert.strictEqual(w.writable, true);
+  w.end();
+  assert.strictEqual(w.writable, false);
+}
diff --git a/test/parallel/test-stream-writable-write-cb-error.js b/test/parallel/test-stream-writable-write-cb-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..72db1b7e3ffe7044b42dc59b754b73417401112e
--- /dev/null
+++ b/test/parallel/test-stream-writable-write-cb-error.js
@@ -0,0 +1,58 @@
+'use strict';
+const common = require('../common');
+const { Writable } = require('stream');
+const assert = require('assert');
+
+// Ensure callback is always invoked before
+// error is emitted. Regardless if error was
+// sync or async.
+
+{
+  let callbackCalled = false;
+  // Sync Error
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      cb(new Error());
+    })
+  });
+  writable.on('error', common.mustCall(() => {
+    assert.strictEqual(callbackCalled, true);
+  }));
+  writable.write('hi', common.mustCall(() => {
+    callbackCalled = true;
+  }));
+}
+
+{
+  let callbackCalled = false;
+  // Async Error
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      process.nextTick(cb, new Error());
+    })
+  });
+  writable.on('error', common.mustCall(() => {
+    assert.strictEqual(callbackCalled, true);
+  }));
+  writable.write('hi', common.mustCall(() => {
+    callbackCalled = true;
+  }));
+}
+
+{
+  // Sync Error
+  const writable = new Writable({
+    write: common.mustCall((buf, enc, cb) => {
+      cb(new Error());
+    })
+  });
+
+  writable.on('error', common.mustCall());
+
+  let cnt = 0;
+  // Ensure we don't live lock on sync error
+  while (writable.write('a'))
+    cnt++;
+
+  assert.strictEqual(cnt, 0);
+}
diff --git a/test/parallel/test-stream-writable-write-cb-twice.js b/test/parallel/test-stream-writable-write-cb-twice.js
index 469712142d8b6409d01d315f5900371b6371078d..244698c52253f78ce31e0e5615ed91f1f68d22bc 100644
--- a/test/parallel/test-stream-writable-write-cb-twice.js
+++ b/test/parallel/test-stream-writable-write-cb-twice.js
@@ -1,20 +1,20 @@
 'use strict';
 const common = require('../common');
 const { Writable } = require('stream');
-const assert = require('assert');
 
 {
   // Sync + Sync
   const writable = new Writable({
     write: common.mustCall((buf, enc, cb) => {
       cb();
-      assert.throws(cb, {
-        code: 'ERR_MULTIPLE_CALLBACK',
-        name: 'Error'
-      });
+      cb();
     })
   });
   writable.write('hi');
+  writable.on('error', common.expectsError({
+    code: 'ERR_MULTIPLE_CALLBACK',
+    name: 'Error'
+  }));
 }
 
 {
@@ -23,14 +23,15 @@ const assert = require('assert');
     write: common.mustCall((buf, enc, cb) => {
       cb();
       process.nextTick(() => {
-        assert.throws(cb, {
-          code: 'ERR_MULTIPLE_CALLBACK',
-          name: 'Error'
-        });
+        cb();
       });
     })
   });
   writable.write('hi');
+  writable.on('error', common.expectsError({
+    code: 'ERR_MULTIPLE_CALLBACK',
+    name: 'Error'
+  }));
 }
 
 {
@@ -39,12 +40,13 @@ const assert = require('assert');
     write: common.mustCall((buf, enc, cb) => {
       process.nextTick(cb);
       process.nextTick(() => {
-        assert.throws(cb, {
-          code: 'ERR_MULTIPLE_CALLBACK',
-          name: 'Error'
-        });
+        cb();
       });
     })
   });
   writable.write('hi');
+  writable.on('error', common.expectsError({
+    code: 'ERR_MULTIPLE_CALLBACK',
+    name: 'Error'
+  }));
 }
diff --git a/test/parallel/test-stream-writable-write-error.js b/test/parallel/test-stream-writable-write-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb9b1db06b772b27e11a8527037d57a89e71ff60
--- /dev/null
+++ b/test/parallel/test-stream-writable-write-error.js
@@ -0,0 +1,66 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { Writable } = require('stream');
+
+function expectError(w, arg, code, sync) {
+  if (sync) {
+    if (code) {
+      assert.throws(() => w.write(arg), { code });
+    } else {
+      w.write(arg);
+    }
+  } else {
+    let errorCalled = false;
+    let ticked = false;
+    w.write(arg, common.mustCall((err) => {
+      assert.strictEqual(ticked, true);
+      assert.strictEqual(errorCalled, false);
+      assert.strictEqual(err.code, code);
+    }));
+    ticked = true;
+    w.on('error', common.mustCall((err) => {
+      errorCalled = true;
+      assert.strictEqual(err.code, code);
+    }));
+  }
+}
+
+function test(autoDestroy) {
+  {
+    const w = new Writable({
+      autoDestroy,
+      _write() {}
+    });
+    w.end();
+    expectError(w, 'asd', 'ERR_STREAM_WRITE_AFTER_END');
+  }
+
+  {
+    const w = new Writable({
+      autoDestroy,
+      _write() {}
+    });
+    w.destroy();
+  }
+
+  {
+    const w = new Writable({
+      autoDestroy,
+      _write() {}
+    });
+    expectError(w, null, 'ERR_STREAM_NULL_VALUES', true);
+  }
+
+  {
+    const w = new Writable({
+      autoDestroy,
+      _write() {}
+    });
+    expectError(w, {}, 'ERR_INVALID_ARG_TYPE', true);
+  }
+}
+
+test(false);
+test(true);
diff --git a/test/parallel/test-stream-writable-write-writev-finish.js b/test/parallel/test-stream-writable-write-writev-finish.js
index 4399f1ca503b3718d88a74adfaa1deb3ba6b213e..9fce315f8b2e1a8d0af6a9baccd579ac3821da58 100644
--- a/test/parallel/test-stream-writable-write-writev-finish.js
+++ b/test/parallel/test-stream-writable-write-writev-finish.js
@@ -14,16 +14,10 @@ const stream = require('stream');
     cb(new Error('write test error'));
   };
 
-  let firstError = false;
-  writable.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
-
-  writable.on('prefinish', common.mustCall());
-
+  writable.on('finish', common.mustNotCall());
+  writable.on('prefinish', common.mustNotCall());
   writable.on('error', common.mustCall((er) => {
     assert.strictEqual(er.message, 'write test error');
-    firstError = true;
   }));
 
   writable.end('test');
@@ -36,16 +30,10 @@ const stream = require('stream');
     setImmediate(cb, new Error('write test error'));
   };
 
-  let firstError = false;
-  writable.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
-
-  writable.on('prefinish', common.mustCall());
-
+  writable.on('finish', common.mustNotCall());
+  writable.on('prefinish', common.mustNotCall());
   writable.on('error', common.mustCall((er) => {
     assert.strictEqual(er.message, 'write test error');
-    firstError = true;
   }));
 
   writable.end('test');
@@ -62,16 +50,10 @@ const stream = require('stream');
     cb(new Error('writev test error'));
   };
 
-  let firstError = false;
-  writable.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
-
-  writable.on('prefinish', common.mustCall());
-
+  writable.on('finish', common.mustNotCall());
+  writable.on('prefinish', common.mustNotCall());
   writable.on('error', common.mustCall((er) => {
     assert.strictEqual(er.message, 'writev test error');
-    firstError = true;
   }));
 
   writable.cork();
@@ -93,16 +75,10 @@ const stream = require('stream');
     setImmediate(cb, new Error('writev test error'));
   };
 
-  let firstError = false;
-  writable.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
-
-  writable.on('prefinish', common.mustCall());
-
+  writable.on('finish', common.mustNotCall());
+  writable.on('prefinish', common.mustNotCall());
   writable.on('error', common.mustCall((er) => {
     assert.strictEqual(er.message, 'writev test error');
-    firstError = true;
   }));
 
   writable.cork();
@@ -123,14 +99,9 @@ const stream = require('stream');
   rs._read = () => {};
 
   const ws = new stream.Writable();
-  let firstError = false;
 
-  ws.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
-  ws.on('error', common.mustCall(function() {
-    firstError = true;
-  }));
+  ws.on('finish', common.mustNotCall());
+  ws.on('error', common.mustCall());
 
   ws._write = (chunk, encoding, done) => {
     setImmediate(done, new Error());
@@ -161,6 +132,7 @@ const stream = require('stream');
     process.nextTick(cb);
   };
   w.on('error', common.mustCall());
+  w.on('finish', common.mustNotCall());
   w.on('prefinish', () => {
     w.write("shouldn't write in prefinish listener");
   });
diff --git a/test/parallel/test-stream-write-destroy.js b/test/parallel/test-stream-write-destroy.js
index 83b329a6a8a7b3dcd57287b9bb748d5bf97077c7..297217eb4accc6b221ce301b9291da70272e7e36 100644
--- a/test/parallel/test-stream-write-destroy.js
+++ b/test/parallel/test-stream-write-destroy.js
@@ -24,7 +24,16 @@ for (const withPendingData of [ false, true ]) {
     w.on('drain', () => drains++);
     w.on('finish', () => finished = true);
 
-    w.write('abc', () => chunksWritten++);
+    function onWrite(err) {
+      if (err) {
+        assert.strictEqual(w.destroyed, true);
+        assert.strictEqual(err.code, 'ERR_STREAM_DESTROYED');
+      } else {
+        chunksWritten++;
+      }
+    }
+
+    w.write('abc', onWrite);
     assert.strictEqual(chunksWritten, 0);
     assert.strictEqual(drains, 0);
     callbacks.shift()();
@@ -34,14 +43,14 @@ for (const withPendingData of [ false, true ]) {
     if (withPendingData) {
       // Test 2 cases: There either is or is not data still in the write queue.
       // (The second write will never actually get executed either way.)
-      w.write('def', () => chunksWritten++);
+      w.write('def', onWrite);
     }
     if (useEnd) {
       // Again, test 2 cases: Either we indicate that we want to end the
       // writable or not.
-      w.end('ghi', () => chunksWritten++);
+      w.end('ghi', onWrite);
     } else {
-      w.write('ghi', () => chunksWritten++);
+      w.write('ghi', onWrite);
     }
 
     assert.strictEqual(chunksWritten, 1);
diff --git a/test/parallel/test-stream-writev.js b/test/parallel/test-stream-writev.js
index 7aba543f0732f648e6aeb51dc0fe1f21f350e9e4..5a42411c6f3a93b4688042c0690ec54063bec5c2 100644
--- a/test/parallel/test-stream-writev.js
+++ b/test/parallel/test-stream-writev.js
@@ -71,13 +71,13 @@ function test(decode, uncork, multi, next) {
     { encoding: 'buffer',
       chunk: [10, 97, 110, 100, 32, 116, 104, 101, 110, 46, 46, 46] },
     { encoding: 'buffer',
-      chunk: [250, 206, 190, 167, 222, 173, 190, 239, 222, 202, 251, 173] }
+      chunk: [250, 206, 190, 167, 222, 173, 190, 239, 222, 202, 251, 173] },
   ] : [
     { encoding: 'ascii', chunk: 'hello, ' },
     { encoding: 'utf8', chunk: 'world' },
     { encoding: 'buffer', chunk: [33] },
     { encoding: 'latin1', chunk: '\nand then...' },
-    { encoding: 'hex', chunk: 'facebea7deadbeefdecafbad' }
+    { encoding: 'hex', chunk: 'facebea7deadbeefdecafbad' },
   ];
 
   let actualChunks;
diff --git a/test/parallel/test-stream2-basic.js b/test/parallel/test-stream2-basic.js
index 08e3b29d532660d76a7236f4574cc633af2920b5..7121f7bda75b029b0f3287d42d6faa9ab8ba89b0 100644
--- a/test/parallel/test-stream2-basic.js
+++ b/test/parallel/test-stream2-basic.js
@@ -171,10 +171,10 @@ class TestWriter extends EE {
   w[0].on('write', function() {
     if (--writes === 0) {
       r.unpipe();
-      assert.strictEqual(r._readableState.pipes, null);
+      assert.deepStrictEqual(r._readableState.pipes, []);
       w[0].end();
       r.pipe(w[1]);
-      assert.strictEqual(r._readableState.pipes, w[1]);
+      assert.deepStrictEqual(r._readableState.pipes, [w[1]]);
     }
   });
 
diff --git a/test/parallel/test-stream2-finish-pipe-error.js b/test/parallel/test-stream2-finish-pipe-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..a603e154b989614fc80b7a240218f0c984303733
--- /dev/null
+++ b/test/parallel/test-stream2-finish-pipe-error.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+const stream = require('stream');
+
+process.on('uncaughtException', common.mustCall());
+
+const r = new stream.Readable();
+r._read = function(size) {
+  r.push(Buffer.allocUnsafe(size));
+};
+
+const w = new stream.Writable();
+w._write = function(data, encoding, cb) {
+  cb(null);
+};
+
+r.pipe(w);
+
+// end() after pipe should cause unhandled exception
+w.end();
diff --git a/test/parallel/test-stream2-finish-pipe.js b/test/parallel/test-stream2-finish-pipe.js
index 4744093e18f9fae7ab9e295635919a27c9cfe90e..5e2969aad4f2599639314c258fc71a2686cc3e33 100644
--- a/test/parallel/test-stream2-finish-pipe.js
+++ b/test/parallel/test-stream2-finish-pipe.js
@@ -30,12 +30,15 @@ r._read = function(size) {
 
 const w = new stream.Writable();
 w._write = function(data, encoding, cb) {
-  cb(null);
+  process.nextTick(cb, null);
 };
 
 r.pipe(w);
 
-// This might sound unrealistic, but it happens in net.js. When
-// `socket.allowHalfOpen === false`, EOF will cause `.destroySoon()` call which
-// ends the writable side of net.Socket.
-w.end();
+// end() must be called in nextTick or a WRITE_AFTER_END error occurs.
+process.nextTick(() => {
+  // This might sound unrealistic, but it happens in net.js. When
+  // socket.allowHalfOpen === false, EOF will cause .destroySoon() call which
+  // ends the writable side of net.Socket.
+  w.end();
+});
diff --git a/test/parallel/test-stream2-objects.js b/test/parallel/test-stream2-objects.js
index f58ea4a32a1e7dd96d039909f518a43f2347db5c..0958c8ec566c27a8d71f8678a57b3ce86d45477b 100644
--- a/test/parallel/test-stream2-objects.js
+++ b/test/parallel/test-stream2-objects.js
@@ -71,7 +71,7 @@ function fromArray(list) {
   r.pipe(toArray(common.mustCall(function(list) {
     assert.deepStrictEqual(list, [
       { one: '1' },
-      { two: '2' }
+      { two: '2' },
     ]);
   })));
 }
@@ -96,7 +96,7 @@ function fromArray(list) {
   r.pipe(toArray(common.mustCall(function(list) {
     assert.deepStrictEqual(list, [
       { one: '1' },
-      { two: '2' }
+      { two: '2' },
     ]);
   })));
 }
@@ -115,7 +115,7 @@ function fromArray(list) {
   r.pipe(toArray(common.mustCall(function(list) {
     assert.deepStrictEqual(list, [
       { one: '1' },
-      { two: '2' }
+      { two: '2' },
     ]);
   })));
 }
diff --git a/test/parallel/test-stream2-pipe-error-handling.js b/test/parallel/test-stream2-pipe-error-handling.js
index d5d266db8773e054bfcd42e70b3dffcbaf2924cb..d3f483810532bcf98997f49cdf016262ccd93dec 100644
--- a/test/parallel/test-stream2-pipe-error-handling.js
+++ b/test/parallel/test-stream2-pipe-error-handling.js
@@ -80,7 +80,7 @@ const stream = require('stream');
     stream.Readable.prototype.unpipe.call(this, dest);
   };
 
-  const dest = new stream.Writable();
+  const dest = new stream.Writable({ autoDestroy: false });
   dest._write = function(chunk, encoding, cb) {
     cb();
   };
diff --git a/test/parallel/test-stream2-readable-wrap-error.js b/test/parallel/test-stream2-readable-wrap-error.js
index a257530e4d1e3a04f099212eaa5caa4e8d0b3944..a05ae8179b06efe96fd5451fe5ce62ec8032f6db 100644
--- a/test/parallel/test-stream2-readable-wrap-error.js
+++ b/test/parallel/test-stream2-readable-wrap-error.js
@@ -11,21 +11,27 @@ class LegacyStream extends EE {
 }
 
 {
+  const err = new Error();
   const oldStream = new LegacyStream();
   const r = new Readable({ autoDestroy: true })
     .wrap(oldStream)
     .on('error', common.mustCall(() => {
+      assert.strictEqual(r._readableState.errorEmitted, true);
+      assert.strictEqual(r._readableState.errored, err);
       assert.strictEqual(r.destroyed, true);
     }));
-  oldStream.emit('error', new Error());
+  oldStream.emit('error', err);
 }
 
 {
+  const err = new Error();
   const oldStream = new LegacyStream();
   const r = new Readable({ autoDestroy: false })
     .wrap(oldStream)
     .on('error', common.mustCall(() => {
+      assert.strictEqual(r._readableState.errorEmitted, true);
+      assert.strictEqual(r._readableState.errored, err);
       assert.strictEqual(r.destroyed, false);
     }));
-  oldStream.emit('error', new Error());
+  oldStream.emit('error', err);
 }
diff --git a/test/parallel/test-stream2-transform.js b/test/parallel/test-stream2-transform.js
index fa24ce152d71ed6b96f68d50398eaa3d0b98f566..d7ad2ed4e570ea1a331d3335d107313fe6cdad35 100644
--- a/test/parallel/test-stream2-transform.js
+++ b/test/parallel/test-stream2-transform.js
@@ -407,7 +407,7 @@ const Transform = require('_stream_transform');
     { foo: 'bar' },
     100,
     'string',
-    { nested: { things: [ { foo: 'bar' }, 100, 'string' ] } }
+    { nested: { things: [ { foo: 'bar' }, 100, 'string' ] } },
   ];
 
   let ended = false;
@@ -448,7 +448,7 @@ const Transform = require('_stream_transform');
     { foo: 'bar' },
     100,
     'string',
-    { nested: { things: [ { foo: 'bar' }, 100, 'string' ] } }
+    { nested: { things: [ { foo: 'bar' }, 100, 'string' ] } },
   ];
 
   let ended = false;
diff --git a/test/parallel/test-stream2-writable.js b/test/parallel/test-stream2-writable.js
index 262606d9062a10a742db0fb24e8a7765890d0aaf..03835bb1bd046513b35cff59dd115dc316e2d2ff 100644
--- a/test/parallel/test-stream2-writable.js
+++ b/test/parallel/test-stream2-writable.js
@@ -275,7 +275,7 @@ const helloWorldBuffer = Buffer.from('hello world');
 
 {
   // Verify writables cannot be piped
-  const w = new W();
+  const w = new W({ autoDestroy: false });
   w._write = common.mustNotCall();
   let gotError = false;
   w.on('error', function() {
@@ -402,3 +402,59 @@ const helloWorldBuffer = Buffer.from('hello world');
   w.write(Buffer.allocUnsafe(1));
   w.end(Buffer.allocUnsafe(0));
 }
+
+{
+  // Verify that error is only emitted once when failing in _finish.
+  const w = new W();
+
+  w._final = common.mustCall(function(cb) {
+    cb(new Error('test'));
+  });
+  w.on('error', common.mustCall((err) => {
+    assert.strictEqual(w._writableState.errorEmitted, true);
+    assert.strictEqual(err.message, 'test');
+    w.on('error', common.mustNotCall());
+    w.destroy(new Error());
+  }));
+  w.end();
+}
+
+{
+  // Verify that error is only emitted once when failing in write.
+  const w = new W();
+  w.on('error', common.mustNotCall());
+  assert.throws(() => {
+    w.write(null);
+  }, {
+    code: 'ERR_STREAM_NULL_VALUES'
+  });
+}
+
+{
+  // Verify that error is only emitted once when failing in write after end.
+  const w = new W();
+  w.on('error', common.mustCall((err) => {
+    assert.strictEqual(w._writableState.errorEmitted, true);
+    assert.strictEqual(err.code, 'ERR_STREAM_WRITE_AFTER_END');
+  }));
+  w.end();
+  w.write('hello');
+  w.destroy(new Error());
+}
+
+{
+  // Verify that finish is not emitted after error
+  const w = new W();
+
+  w._final = common.mustCall(function(cb) {
+    cb(new Error());
+  });
+  w._write = function(chunk, e, cb) {
+    process.nextTick(cb);
+  };
+  w.on('error', common.mustCall());
+  w.on('prefinish', common.mustNotCall());
+  w.on('finish', common.mustNotCall());
+  w.write(Buffer.allocUnsafe(1));
+  w.end(Buffer.allocUnsafe(0));
+}
diff --git a/test/parallel/test-streams-highwatermark.js b/test/parallel/test-streams-highwatermark.js
index 2228c12f1421f56874fb8530cf733cff0472c42b..5e27a7613508104c512db4415657fb44103f988c 100644
--- a/test/parallel/test-streams-highwatermark.js
+++ b/test/parallel/test-streams-highwatermark.js
@@ -59,3 +59,16 @@ const { inspect } = require('util');
   readable._read = common.mustCall();
   readable.read(0);
 }
+
+{
+  // Parse size as decimal integer
+  ['1', '1.0', 1].forEach((size) => {
+    const readable = new stream.Readable({
+      read: common.mustCall(),
+      highWaterMark: 0,
+    });
+    readable.read(size);
+
+    assert.strictEqual(readable._readableState.highWaterMark, Number(size));
+  });
+}
diff --git a/test/parallel/test-string-decoder-end.js b/test/parallel/test-string-decoder-end.js
index ee0a47e3572f6d0bf6d5093c42591125e4ce2379..5a3c5cc720789d1ee85b5498e45673c2f2c048b8 100644
--- a/test/parallel/test-string-decoder-end.js
+++ b/test/parallel/test-string-decoder-end.js
@@ -27,7 +27,7 @@
 require('../common');
 const assert = require('assert');
 const SD = require('string_decoder').StringDecoder;
-const encodings = ['base64', 'hex', 'utf8', 'utf16le', 'ucs2'];
+const encodings = ['base64', 'base64url', 'hex', 'utf8', 'utf16le', 'ucs2'];
 
 const bufs = [ '☃💩', 'asdf' ].map((b) => Buffer.from(b));
 
@@ -79,6 +79,13 @@ testEnd('base64', Buffer.of(0x61, 0x61), Buffer.of(0x61), 'YWE=YQ==');
 testEnd('base64', Buffer.of(0x61, 0x61, 0x61), Buffer.of(), 'YWFh');
 testEnd('base64', Buffer.of(0x61, 0x61, 0x61), Buffer.of(0x61), 'YWFhYQ==');
 
+testEnd('base64url', Buffer.of(0x61), Buffer.of(), 'YQ');
+testEnd('base64url', Buffer.of(0x61), Buffer.of(0x61), 'YQYQ');
+testEnd('base64url', Buffer.of(0x61, 0x61), Buffer.of(), 'YWE');
+testEnd('base64url', Buffer.of(0x61, 0x61), Buffer.of(0x61), 'YWEYQ');
+testEnd('base64url', Buffer.of(0x61, 0x61, 0x61), Buffer.of(), 'YWFh');
+testEnd('base64url', Buffer.of(0x61, 0x61, 0x61), Buffer.of(0x61), 'YWFhYQ');
+
 function testEncoding(encoding) {
   bufs.forEach((buf) => {
     testBuf(encoding, buf);
diff --git a/test/parallel/test-string-decoder-fuzz.js b/test/parallel/test-string-decoder-fuzz.js
index d8d018815911612bee5698f958644d963899a4c8..3a6108e8fc993d831fa281acffc2b5741b94cd6b 100644
--- a/test/parallel/test-string-decoder-fuzz.js
+++ b/test/parallel/test-string-decoder-fuzz.js
@@ -20,7 +20,7 @@ function randBuf(maxLen) {
 }
 
 const encodings = [
-  'utf16le', 'utf8', 'ascii', 'hex', 'base64', 'latin1'
+  'utf16le', 'utf8', 'ascii', 'hex', 'base64', 'latin1', 'base64url',
 ];
 
 function runSingleFuzzTest() {
diff --git a/test/parallel/test-string-decoder.js b/test/parallel/test-string-decoder.js
index 1fbf9b572cc2f83f2974e43db215d3e0e8565c81..be876f46e5af02f5f02c1cb5d9b6618abec075e7 100644
--- a/test/parallel/test-string-decoder.js
+++ b/test/parallel/test-string-decoder.js
@@ -201,6 +201,15 @@ assert.throws(
   }
 );
 
+if (common.enoughTestMem) {
+  assert.throws(
+    () => new StringDecoder().write(Buffer.alloc(0x1fffffe8 + 1).fill('a')),
+    {
+      code: 'ERR_STRING_TOO_LONG',
+    }
+  );
+}
+
 // Test verifies that StringDecoder will correctly decode the given input
 // buffer with the given encoding to the expected output. It will attempt all
 // possible ways to write() the input buffer, see writeSequences(). The
diff --git a/test/parallel/test-timers-active.js b/test/parallel/test-timers-active.js
index a98d32c0b042d133c4a15c4cf1b7a93b106ff5d7..ac79c6fc1e1ca080ba99a9c90fb912748b7b9ba6 100644
--- a/test/parallel/test-timers-active.js
+++ b/test/parallel/test-timers-active.js
@@ -6,7 +6,7 @@ const active = require('timers').active;
 // active() should create timers for these
 const legitTimers = [
   { _idleTimeout: 0 },
-  { _idleTimeout: 1 }
+  { _idleTimeout: 1 },
 ];
 
 legitTimers.forEach(function(legit) {
diff --git a/test/parallel/test-timers-clear-object-does-not-throw-error.js b/test/parallel/test-timers-clear-object-does-not-throw-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..9752f53abd075570ef352b69810548e12531c7a6
--- /dev/null
+++ b/test/parallel/test-timers-clear-object-does-not-throw-error.js
@@ -0,0 +1,8 @@
+'use strict';
+require('../common');
+
+// This test makes sure clearing timers with
+// objects doesn't throw
+clearImmediate({});
+clearTimeout({});
+clearInterval({});
diff --git a/test/parallel/test-timers-enroll-invalid-msecs.js b/test/parallel/test-timers-enroll-invalid-msecs.js
index f82bf29d74d973dbd7e0d2ab61b2f56939b35a8e..466f1a2c4a8872f8d33f651a9cf0e9f6dc59f069 100644
--- a/test/parallel/test-timers-enroll-invalid-msecs.js
+++ b/test/parallel/test-timers-enroll-invalid-msecs.js
@@ -9,7 +9,7 @@ const timers = require('timers');
   [],
   'foo',
   () => { },
-  Symbol('foo')
+  Symbol('foo'),
 ].forEach((val) => {
   assert.throws(
     () => timers.enroll({}, val),
@@ -23,7 +23,7 @@ const timers = require('timers');
 [
   -1,
   Infinity,
-  NaN
+  NaN,
 ].forEach((val) => {
   assert.throws(
     () => timers.enroll({}, val),
diff --git a/test/parallel/test-timers-non-integer-delay.js b/test/parallel/test-timers-non-integer-delay.js
index eabfc560264cde73c4b8f595f4ffed4ce3fb088a..089c1fee8b94c0d77127bb7389e99a1e40d98590 100644
--- a/test/parallel/test-timers-non-integer-delay.js
+++ b/test/parallel/test-timers-non-integer-delay.js
@@ -23,21 +23,19 @@
 const common = require('../common');
 const assert = require('assert');
 
-/*
- * This test makes sure that non-integer timer delays do not make the process
- * hang. See https://github.com/joyent/node/issues/8065 and
- * https://github.com/joyent/node/issues/8068 which have been fixed by
- * https://github.com/joyent/node/pull/8073.
- *
- * If the process hangs, this test will make the tests suite timeout,
- * otherwise it will exit very quickly (after 50 timers with a short delay
- * fire).
- *
- * We have to set at least several timers with a non-integer delay to
- * reproduce the issue. Sometimes, a timer with a non-integer delay will
- * expire correctly. 50 timers has always been more than enough to reproduce
- * it 100%.
- */
+// This test makes sure that non-integer timer delays do not make the process
+// hang. See https://github.com/joyent/node/issues/8065 and
+// https://github.com/joyent/node/issues/8068 which have been fixed by
+// https://github.com/joyent/node/pull/8073.
+//
+// If the process hangs, this test will make the tests suite timeout,
+// otherwise it will exit very quickly (after 50 timers with a short delay
+// fire).
+//
+// We have to set at least several timers with a non-integer delay to
+// reproduce the issue. Sometimes, a timer with a non-integer delay will
+// expire correctly. 50 timers has always been more than enough to reproduce
+// it 100%.
 
 const TIMEOUT_DELAY = 1.1;
 let N = 50;
diff --git a/test/parallel/test-timers-promisified.js b/test/parallel/test-timers-promisified.js
index 85e7093cfa185fefdfa127659f9e38a6c739f2f2..cc399746fbe77b1f29001ce52cda21ed47582249 100644
--- a/test/parallel/test-timers-promisified.js
+++ b/test/parallel/test-timers-promisified.js
@@ -1,14 +1,20 @@
+// Flags: --no-warnings --expose-internals --experimental-abortcontroller
 'use strict';
 const common = require('../common');
 const assert = require('assert');
 const timers = require('timers');
 const { promisify } = require('util');
 
+// TODO(benjamingr) - refactor to use getEventListeners when #35991 lands
+const { NodeEventTarget } = require('internal/event_target');
+
 /* eslint-disable no-restricted-syntax */
 
 const setTimeout = promisify(timers.setTimeout);
 const setImmediate = promisify(timers.setImmediate);
 
+process.on('multipleResolves', common.mustNotCall());
+
 {
   const promise = setTimeout(1);
   promise.then(common.mustCall((value) => {
@@ -36,3 +42,97 @@ const setImmediate = promisify(timers.setImmediate);
     assert.strictEqual(value, 'foobar');
   }));
 }
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  assert.rejects(setTimeout(10, undefined, { signal }), /AbortError/);
+  ac.abort();
+}
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  ac.abort(); // Abort in advance
+  assert.rejects(setTimeout(10, undefined, { signal }), /AbortError/);
+}
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  assert.rejects(setImmediate(10, { signal }), /AbortError/);
+  ac.abort();
+}
+
+{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  ac.abort(); // Abort in advance
+  assert.rejects(setImmediate(10, { signal }), /AbortError/);
+}
+
+{
+  // Check that aborting after resolve will not reject.
+  const ac = new AbortController();
+  const signal = ac.signal;
+  setTimeout(10, undefined, { signal }).then(() => {
+    ac.abort();
+  });
+}
+{
+  // Check that aborting after resolve will not reject.
+  const ac = new AbortController();
+  const signal = ac.signal;
+  setImmediate(10, { signal }).then(() => {
+    ac.abort();
+  });
+}
+
+{
+  // Check that timer adding signals does not leak handlers
+  const signal = new NodeEventTarget();
+  signal.aborted = false;
+  setTimeout(0, null, { signal }).finally(common.mustCall(() => {
+    assert.strictEqual(signal.listenerCount('abort'), 0);
+  }));
+}
+
+{
+  // Check that timer adding signals does not leak handlers
+  const signal = new NodeEventTarget();
+  signal.aborted = false;
+  setImmediate(0, { signal }).finally(common.mustCall(() => {
+    assert.strictEqual(signal.listenerCount('abort'), 0);
+  }));
+}
+
+{
+  Promise.all(
+    [1, '', false, Infinity].map((i) => assert.rejects(setImmediate(10, i)), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    })).then(common.mustCall());
+
+  Promise.all(
+    [1, '', false, Infinity, null, {}].map(
+      (signal) => assert.rejects(setImmediate(10, { signal })), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      })).then(common.mustCall());
+
+  Promise.all(
+    [1, '', false, Infinity].map(
+      (i) => assert.rejects(setTimeout(10, null, i)), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      })).then(common.mustCall());
+
+  Promise.all(
+    [1, '', false, Infinity, null, {}].map(
+      (signal) => assert.rejects(setTimeout(10, null, { signal })), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      })).then(common.mustCall());
+
+  Promise.all(
+    [1, '', Infinity, null, {}].map(
+      (ref) => assert.rejects(setTimeout(10, null, { ref })), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      })).then(common.mustCall());
+}
diff --git a/test/parallel/test-timers-reset-process-domain-on-throw.js b/test/parallel/test-timers-reset-process-domain-on-throw.js
index 55fd43feb81523f73f7be6e036c9a4341e2a22ea..a0de01f09229641c3490227532599c9e4817dde9 100644
--- a/test/parallel/test-timers-reset-process-domain-on-throw.js
+++ b/test/parallel/test-timers-reset-process-domain-on-throw.js
@@ -26,9 +26,10 @@ function err() {
   }
 
   function handleDomainError(e) {
-    // In the domain's error handler, the current active domain should be the
-    // domain within which the error was thrown.
-    assert.strictEqual(process.domain, d);
+    assert.strictEqual(e.domain, d);
+    // Domains' error handlers are called outside of their domain's context, so
+    // we're not expecting any active domain here.
+    assert.strictEqual(process.domain, undefined);
   }
 }
 
diff --git a/test/parallel/test-timers-same-timeout-wrong-list-deleted.js b/test/parallel/test-timers-same-timeout-wrong-list-deleted.js
index 3e04cb6c4cbc42743acf02f02ff45d5b6a208697..f02603ad88c406143ae9d90366de58b0e52d6226 100644
--- a/test/parallel/test-timers-same-timeout-wrong-list-deleted.js
+++ b/test/parallel/test-timers-same-timeout-wrong-list-deleted.js
@@ -1,15 +1,13 @@
 'use strict';
 
-/*
- * This is a regression test for https://github.com/nodejs/node/issues/7722.
- *
- * When nested timers have the same timeout, calling clearTimeout on the
- * older timer after it has fired causes the list the newer timer is in
- * to be deleted. Since the newer timer was not cleared, it still blocks
- * the event loop completing for the duration of its timeout, however, since
- * no reference exists to it in its list, it cannot be canceled and its
- * callback is not called when the timeout elapses.
- */
+// This is a regression test for https://github.com/nodejs/node/issues/7722.
+//
+// When nested timers have the same timeout, calling clearTimeout on the
+// older timer after it has fired causes the list the newer timer is in
+// to be deleted. Since the newer timer was not cleared, it still blocks
+// the event loop completing for the duration of its timeout, however, since
+// no reference exists to it in its list, it cannot be canceled and its
+// callback is not called when the timeout elapses.
 
 const common = require('../common');
 
diff --git a/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js b/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
index 5dceb386fdbdf4486e4fc9664995ae2171c3606a..ccecfe4c63a6a19c5ee17c22b917063edd94511b 100644
--- a/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
+++ b/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
@@ -1,8 +1,6 @@
 'use strict';
 
-/*
- * This test is a regression test for joyent/node#8897.
- */
+// Regression test for https://github.com/nodejs/node-v0.x-archive/issues/8897.
 
 const common = require('../common');
 const net = require('net');
@@ -14,12 +12,10 @@ const server = net.createServer(function onClient(client) {
   clients.push(client);
 
   if (clients.length === 2) {
-    /*
-     * Enroll two timers, and make the one supposed to fire first
-     * unenroll the other one supposed to fire later. This mutates
-     * the list of unref timers when traversing it, and exposes the
-     * original issue in joyent/node#8897.
-     */
+    // Enroll two timers, and make the one supposed to fire first
+    // unenroll the other one supposed to fire later. This mutates
+    // the list of unref timers when traversing it, and exposes the
+    // original issue in joyent/node#8897.
     clients[0].setTimeout(1, () => {
       clients[1].setTimeout(0);
       clients[0].end();
diff --git a/test/parallel/test-timers-unref-active.js b/test/parallel/test-timers-unref-active.js
index 69f6d4e9f1bce4ccc4705e48828c4d9853b06fa3..a620304089e50006b6de1e107ff2e615139802f5 100644
--- a/test/parallel/test-timers-unref-active.js
+++ b/test/parallel/test-timers-unref-active.js
@@ -1,19 +1,17 @@
 'use strict';
 
-/*
- * This test is aimed at making sure that unref timers queued with
- * timers._unrefActive work correctly.
- *
- * Basically, it queues one timer in the unref queue, and then queues
- * it again each time its timeout callback is fired until the callback
- * has been called ten times.
- *
- * At that point, it unenrolls the unref timer so that its timeout callback
- * is not fired ever again.
- *
- * Finally, a ref timeout is used with a delay large enough to make sure that
- * all 10 timeouts had the time to expire.
- */
+// This test is aimed at making sure that unref timers queued with
+// timers._unrefActive work correctly.
+//
+// Basically, it queues one timer in the unref queue, and then queues
+// it again each time its timeout callback is fired until the callback
+// has been called ten times.
+//
+// At that point, it unenrolls the unref timer so that its timeout callback
+// is not fired ever again.
+//
+// Finally, a ref timeout is used with a delay large enough to make sure that
+// all 10 timeouts had the time to expire.
 
 require('../common');
 const timers = require('timers');
@@ -22,14 +20,12 @@ const assert = require('assert');
 const someObject = {};
 let nbTimeouts = 0;
 
-/*
- * libuv 0.10.x uses GetTickCount on Windows to implement timers, which uses
- * system's timers whose resolution is between 10 and 16ms. See
- * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724408.aspx
- * for more information. That's the lowest resolution for timers across all
- * supported platforms. We're using it as the lowest common denominator,
- * and thus expect 5 timers to be able to fire in under 100 ms.
- */
+// libuv 0.10.x uses GetTickCount on Windows to implement timers, which uses
+// system's timers whose resolution is between 10 and 16ms. See
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms724408.aspx
+// for more information. That's the lowest resolution for timers across all
+// supported platforms. We're using it as the lowest common denominator,
+// and thus expect 5 timers to be able to fire in under 100 ms.
 const N = 5;
 const TEST_DURATION = 1000;
 
diff --git a/test/parallel/test-timers-unref-remove-other-unref-timers-only-one-fires.js b/test/parallel/test-timers-unref-remove-other-unref-timers-only-one-fires.js
index ce63ad8d2968e72a95169387ad8e6daa3c20936d..07c2f4398278b7a6cd6846a49aa8b6e93bb70f24 100644
--- a/test/parallel/test-timers-unref-remove-other-unref-timers-only-one-fires.js
+++ b/test/parallel/test-timers-unref-remove-other-unref-timers-only-one-fires.js
@@ -1,15 +1,15 @@
 'use strict';
 
-/*
- * The goal of this test is to make sure that, after the regression introduced
- * by 934bfe23a16556d05bfb1844ef4d53e8c9887c3d, the fix preserves the following
- * behavior of unref timers: if two timers are scheduled to fire at the same
- * time, if one unenrolls the other one in its _onTimeout callback, the other
- * one will *not* fire.
- *
- * This behavior is a private implementation detail and should not be
- * considered public interface.
- */
+
+// The goal of this test is to make sure that, after the regression introduced
+// by 934bfe23a16556d05bfb1844ef4d53e8c9887c3d, the fix preserves the following
+// behavior of unref timers: if two timers are scheduled to fire at the same
+// time, if one unenrolls the other one in its _onTimeout callback, the other
+// one will *not* fire.
+
+// This behavior is a private implementation detail and should not be
+// considered public interface.
+
 require('../common');
 const timers = require('timers');
 const assert = require('assert');
diff --git a/test/parallel/test-timers-unref-remove-other-unref-timers.js b/test/parallel/test-timers-unref-remove-other-unref-timers.js
index 84dd75025d6c0d6c1b715ebd3e603ac605519cab..0926bd308c1efa6b8ddc532be5b5f6c7bbfbce43 100644
--- a/test/parallel/test-timers-unref-remove-other-unref-timers.js
+++ b/test/parallel/test-timers-unref-remove-other-unref-timers.js
@@ -1,11 +1,9 @@
 'use strict';
 
-/*
- * This test is a regression test for joyent/node#8897.
- *
- * It tests some private implementation details that should not be
- * considered public interface.
- */
+// Regression test for https://github.com/nodejs/node-v0.x-archive/issues/8897.
+
+// Test some private implementation details that should not be
+// considered public interface.
 const common = require('../common');
 const timers = require('timers');
 
diff --git a/test/parallel/test-timers-unrefd-interval-still-fires.js b/test/parallel/test-timers-unrefd-interval-still-fires.js
index 45c59c01082777d1f66955a711aa06fce0179f2d..98172d18bcac407a3f8947bbeec3e6ea89b06cc3 100644
--- a/test/parallel/test-timers-unrefd-interval-still-fires.js
+++ b/test/parallel/test-timers-unrefd-interval-still-fires.js
@@ -1,7 +1,5 @@
 'use strict';
-/*
- * This test is a regression test for joyent/node#8900.
- */
+// Regression test for https://github.com/nodejs/node-v0.x-archive/issues/8900.
 const common = require('../common');
 
 const TEST_DURATION = common.platformTimeout(1000);
diff --git a/test/parallel/test-timers.js b/test/parallel/test-timers.js
index b8733f79f54639437c782ea4d9b632f8930e9390..e04c1f3f184946cc25aa73f269f2fee07d0bf22d 100644
--- a/test/parallel/test-timers.js
+++ b/test/parallel/test-timers.js
@@ -48,7 +48,7 @@ const inputs = [
   1,
   1.0,
   2147483648,     // Browser behavior: timeouts > 2^31-1 run on next tick
-  12345678901234  // ditto
+  12345678901234,  // ditto
 ];
 
 const timeouts = [];
diff --git a/test/pummel/test-regress-GH-814_2.js b/test/parallel/test-tls-0-dns-altname-revert-CVE-2021-44532.js
similarity index 39%
rename from test/pummel/test-regress-GH-814_2.js
rename to test/parallel/test-tls-0-dns-altname-revert-CVE-2021-44532.js
index 450b306a47b4ca3d0d41a0f9bb00cba18871944f..8624c46f8272e47b3860ff699e0a1047d11b5cd9 100644
--- a/test/pummel/test-regress-GH-814_2.js
+++ b/test/parallel/test-tls-0-dns-altname-revert-CVE-2021-44532.js
@@ -18,86 +18,37 @@
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// Refs: https://github.com/nodejs/node-v0.x-archive/issues/814
-
+// Flags: --security-revert=CVE-2021-44532
 'use strict';
-// Flags: --expose_gc
-
-require('../common');
-const assert = require('assert');
-
-const fs = require('fs');
-const tmpdir = require('../common/tmpdir');
-const testFileName = require('path').join(tmpdir.path, 'GH-814_test.txt');
-const testFD = fs.openSync(testFileName, 'w');
-console.error(`${testFileName}\n`);
-
-
-const tailProc = require('child_process').spawn('tail', ['-f', testFileName]);
-tailProc.stdout.on('data', tailCB);
-
-function tailCB(data) {
-  PASS = !data.toString().includes('.');
-
-  if (!PASS) {
-    console.error('[FAIL]\n DATA -> ');
-    console.error(data);
-    console.error('\n');
-    throw new Error('Buffers GC test -> FAIL');
-  }
-}
-
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
 
-let PASS = true;
-const bufPool = [];
-const kBufSize = 16 * 1024 * 1024;
-const neverWrittenBuffer = newBuffer(kBufSize, 0x2e); // 0x2e === '.'
+// Check getPeerCertificate can properly handle '\0' for fix CVE-2009-2408.
 
-const timeToQuit = Date.now() + 5e3; // Test should last no more than this.
-writer();
-
-function writer() {
-
-  if (PASS) {
-    if (Date.now() > timeToQuit) {
-      setTimeout(function() {
-        process.kill(tailProc.pid);
-        console.error('\nBuffers GC test -> PASS (OK)\n');
-      }, 555);
-    } else {
-      fs.write(testFD, newBuffer(kBufSize, 0x61), 0, kBufSize, -1, writerCB);
-      global.gc();
-      global.gc();
-      global.gc();
-      global.gc();
-      global.gc();
-      global.gc();
-      const nuBuf = Buffer.allocUnsafe(kBufSize);
-      neverWrittenBuffer.copy(nuBuf);
-      if (bufPool.push(nuBuf) > 100) {
-        bufPool.length = 0;
-      }
-      process.nextTick(writer);
-    }
-  }
-
-}
-
-function writerCB(err, written) {
-  assert.ifError(err);
-}
-
-
-// ******************* UTILITIES
-
-
-function newBuffer(size, value) {
-  const buffer = Buffer.allocUnsafe(size);
-  while (size--) {
-    buffer[size] = value;
-  }
-  buffer[buffer.length - 1] = 0x0d;
-  buffer[buffer.length - 1] = 0x0a;
-  return buffer;
-}
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const server = tls.createServer({
+  key: fixtures.readSync(['0-dns', '0-dns-key.pem']),
+  cert: fixtures.readSync(['0-dns', '0-dns-cert.pem'])
+}, common.mustCall((c) => {
+  c.once('data', common.mustCall(() => {
+    c.destroy();
+    server.close();
+  }));
+})).listen(0, common.mustCall(() => {
+  const c = tls.connect(server.address().port, {
+    rejectUnauthorized: false
+  }, common.mustCall(() => {
+    const cert = c.getPeerCertificate();
+    assert.strictEqual(cert.subjectaltname,
+                       'DNS:good.example.org\0.evil.example.com, ' +
+                           'DNS:just-another.example.com, ' +
+                           'IP Address:8.8.8.8, ' +
+                           'IP Address:8.8.4.4, ' +
+                           'DNS:last.example.com');
+    c.write('ok');
+  }));
+}));
diff --git a/test/parallel/test-tls-0-dns-altname.js b/test/parallel/test-tls-0-dns-altname.js
index 4bc87e44cb60c1a6fae9abaef07686b80e92533b..e5cb8e3d487af11110c2a598c636524d4286b93b 100644
--- a/test/parallel/test-tls-0-dns-altname.js
+++ b/test/parallel/test-tls-0-dns-altname.js
@@ -44,7 +44,7 @@ const server = tls.createServer({
   }, common.mustCall(() => {
     const cert = c.getPeerCertificate();
     assert.strictEqual(cert.subjectaltname,
-                       'DNS:good.example.org\0.evil.example.com, ' +
+                       'DNS:"good.example.org\\u0000.evil.example.com", ' +
                            'DNS:just-another.example.com, ' +
                            'IP Address:8.8.8.8, ' +
                            'IP Address:8.8.4.4, ' +
diff --git a/test/parallel/test-tls-addca.js b/test/parallel/test-tls-addca.js
index 8eb88db6291457535a6e758b10fd2cbc0c5f988b..5ca44f7a26e7db44b6f9d151b7b21bc63085a378 100644
--- a/test/parallel/test-tls-addca.js
+++ b/test/parallel/test-tls-addca.js
@@ -43,8 +43,7 @@ connect({
   connect({
     client: clientOptions,
     server: serverOptions,
-  }, common.mustCall((err, pair, cleanup) => {
-    assert.ifError(err);
+  }, common.mustSucceed((pair, cleanup) => {
     cleanup();
   }));
 }));
diff --git a/test/parallel/test-tls-ca-concat.js b/test/parallel/test-tls-ca-concat.js
index efec4e649c950629f2f07df37183155147241035..38a6a4dfec378fb07af773d4620ff226de30770c 100644
--- a/test/parallel/test-tls-ca-concat.js
+++ b/test/parallel/test-tls-ca-concat.js
@@ -6,7 +6,7 @@ const fixtures = require('../common/fixtures');
 // non-CA cert and showing that agent6's CA root is still found.
 
 const {
-  assert, connect, keys
+  connect, keys
 } = require(fixtures.path('tls-connect'));
 
 connect({
@@ -18,7 +18,6 @@ connect({
     cert: keys.agent6.cert,
     key: keys.agent6.key,
   },
-}, common.mustCall((err, pair, cleanup) => {
-  assert.ifError(err);
+}, common.mustSucceed((pair, cleanup) => {
   return cleanup();
 }));
diff --git a/test/parallel/test-tls-cert-chains-concat.js b/test/parallel/test-tls-cert-chains-concat.js
index a099f9ce332cb0257bcaa2e47d98c312656f0cb3..c186f0f6c4e4b1e93f4949afb192a79d5e0094ff 100644
--- a/test/parallel/test-tls-cert-chains-concat.js
+++ b/test/parallel/test-tls-cert-chains-concat.js
@@ -19,9 +19,7 @@ connect({
     cert: keys.agent6.cert,
     key: keys.agent6.key,
   },
-}, common.mustCall((err, pair, cleanup) => {
-  assert.ifError(err);
-
+}, common.mustSucceed((pair, cleanup) => {
   const peer = pair.client.conn.getPeerCertificate();
   debug('peer:\n', peer);
   assert.strictEqual(peer.subject.emailAddress, 'adam.lippai@tresorit.com');
diff --git a/test/parallel/test-tls-check-server-identity.js b/test/parallel/test-tls-check-server-identity.js
index 04c77305eb3b89c4be6cea8c99a390b38c2c751d..fe81fc5285a3ce2f83a680c3ed097496a3027fb0 100644
--- a/test/parallel/test-tls-check-server-identity.js
+++ b/test/parallel/test-tls-check-server-identity.js
@@ -30,13 +30,6 @@ const util = require('util');
 
 const tls = require('tls');
 
-common.expectWarning('DeprecationWarning', [
-  ['The URI http://[a.b.a.com]/ found in cert.subjectaltname ' +
-  'is not a valid URI, and is supported in the tls module ' +
-  'solely for compatibility.',
-   'DEP0109'],
-]);
-
 const tests = [
   // False-y values.
   {
@@ -124,12 +117,13 @@ const tests = [
     cert: { subject: { CN: '*n.b.com' } },
     error: 'Host: \n.b.com. is not cert\'s CN: *n.b.com'
   },
-  { host: 'b.a.com', cert: {
-    subjectaltname: 'DNS:omg.com',
-    subject: { CN: '*.a.com' } },
+  { host: 'b.a.com',
+    cert: {
+      subjectaltname: 'DNS:omg.com',
+      subject: { CN: '*.a.com' },
+    },
     error: 'Host: b.a.com. is not in the cert\'s altnames: ' +
-           'DNS:omg.com'
-  },
+           'DNS:omg.com' },
   {
     host: 'b.a.com',
     cert: { subject: { CN: 'b*b.a.com' } },
@@ -140,7 +134,7 @@ const tests = [
   {
     host: 'a.com',
     cert: { },
-    error: 'Cert is empty'
+    error: 'Cert does not contain a DNS name'
   },
 
   // Empty Subject w/DNS name
@@ -154,7 +148,8 @@ const tests = [
   {
     host: 'a.b.a.com', cert: {
       subjectaltname: 'URI:http://a.b.a.com/',
-    }
+    },
+    error: 'Cert does not contain a DNS name'
   },
 
   // Multiple CN fields
@@ -271,22 +266,15 @@ const tests = [
     host: 'a.b.a.com', cert: {
       subjectaltname: 'URI:http://a.b.a.com/',
       subject: {}
-    }
+    },
+    error: 'Cert does not contain a DNS name'
   },
   {
     host: 'a.b.a.com', cert: {
       subjectaltname: 'URI:http://*.b.a.com/',
       subject: {}
     },
-    error: 'Host: a.b.a.com. is not in the cert\'s altnames: ' +
-           'URI:http://*.b.a.com/'
-  },
-  // Invalid URI
-  {
-    host: 'a.b.a.com', cert: {
-      subjectaltname: 'URI:http://[a.b.a.com]/',
-      subject: {}
-    }
+    error: 'Cert does not contain a DNS name'
   },
   // IP addresses
   {
@@ -294,8 +282,7 @@ const tests = [
       subjectaltname: 'IP Address:127.0.0.1',
       subject: {}
     },
-    error: 'Host: a.b.a.com. is not in the cert\'s altnames: ' +
-           'IP Address:127.0.0.1'
+    error: 'Cert does not contain a DNS name'
   },
   {
     host: '127.0.0.1', cert: {
diff --git a/test/parallel/test-tls-cipher-list.js b/test/parallel/test-tls-cipher-list.js
index b3c34a74bf4ee04ef4e34b41662f50b18ee97a15..b1a61405898a9a9ea995410634925e909807da89 100644
--- a/test/parallel/test-tls-cipher-list.js
+++ b/test/parallel/test-tls-cipher-list.js
@@ -12,7 +12,7 @@ function doCheck(arg, expression, check) {
   let out = '';
   arg = arg.concat([
     '-pe',
-    expression
+    expression,
   ]);
   spawn(process.execPath, arg, {})
     .on('error', common.mustNotCall())
diff --git a/test/parallel/test-tls-client-getephemeralkeyinfo.js b/test/parallel/test-tls-client-getephemeralkeyinfo.js
index 599306993e1252bd9243167eee2aadc108bded10..73ac215102ddbba155e1a2a1a792cb7a8d013245 100644
--- a/test/parallel/test-tls-client-getephemeralkeyinfo.js
+++ b/test/parallel/test-tls-client-getephemeralkeyinfo.js
@@ -35,9 +35,7 @@ function test(size, type, name, cipher) {
     conn.end();
   }));
 
-  server.on('close', common.mustCall((err) => {
-    assert.ifError(err);
-  }));
+  server.on('close', common.mustSucceed());
 
   server.listen(0, '127.0.0.1', common.mustCall(() => {
     const client = tls.connect({
diff --git a/test/parallel/test-tls-client-verify.js b/test/parallel/test-tls-client-verify.js
index 12d2514eed3a897d1454cdba98a49537aeb0a6ca..a8de1078bf2e9a599573cf1232722b04a706b9f8 100644
--- a/test/parallel/test-tls-client-verify.js
+++ b/test/parallel/test-tls-client-verify.js
@@ -35,9 +35,8 @@ const testCases = [
     servers: [
       { ok: true, key: 'agent1-key', cert: 'agent1-cert' },
       { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
-      { ok: false, key: 'agent3-key', cert: 'agent3-cert' }
-    ]
-  },
+      { ok: false, key: 'agent3-key', cert: 'agent3-cert' },
+    ] },
 
   { ca: [],
     key: 'agent2-key',
@@ -45,9 +44,8 @@ const testCases = [
     servers: [
       { ok: false, key: 'agent1-key', cert: 'agent1-cert' },
       { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
-      { ok: false, key: 'agent3-key', cert: 'agent3-cert' }
-    ]
-  },
+      { ok: false, key: 'agent3-key', cert: 'agent3-cert' },
+    ] },
 
   { ca: ['ca1-cert', 'ca2-cert'],
     key: 'agent2-key',
@@ -55,9 +53,8 @@ const testCases = [
     servers: [
       { ok: true, key: 'agent1-key', cert: 'agent1-cert' },
       { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
-      { ok: true, key: 'agent3-key', cert: 'agent3-cert' }
-    ]
-  }
+      { ok: true, key: 'agent3-key', cert: 'agent3-cert' },
+    ] },
 ];
 
 
diff --git a/test/parallel/test-tls-cnnic-whitelist.js b/test/parallel/test-tls-cnnic-whitelist.js
index e08e93013f6acaa3772c462c149f920924fff020..99ad02ee1c66bee050b27842264b22bd5b5b61e4 100644
--- a/test/parallel/test-tls-cnnic-whitelist.js
+++ b/test/parallel/test-tls-cnnic-whitelist.js
@@ -31,7 +31,7 @@ const testCases = [
       rejectUnauthorized: true
     },
     errorCode: 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY'
-  }
+  },
 ];
 
 function runTest(tindex) {
diff --git a/test/parallel/test-tls-connect-hwm-option.js b/test/parallel/test-tls-connect-hwm-option.js
new file mode 100644
index 0000000000000000000000000000000000000000..e016ccc6cba0dcf37f2e6af3a5e5712b9d87bb0b
--- /dev/null
+++ b/test/parallel/test-tls-connect-hwm-option.js
@@ -0,0 +1,53 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const pem = (n) => fixtures.readKey(`${n}.pem`);
+
+let clients = 0;
+
+const server = tls.createServer({
+  key: pem('agent1-key'),
+  cert: pem('agent1-cert')
+}, common.mustCall(() => {
+  if (--clients === 0)
+    server.close();
+}, 3));
+
+server.listen(0, common.mustCall(() => {
+  clients++;
+  const highBob = tls.connect({
+    port: server.address().port,
+    rejectUnauthorized: false,
+    highWaterMark: 128000,
+  }, common.mustCall(() => {
+    assert.strictEqual(highBob.readableHighWaterMark, 128000);
+    highBob.end();
+  }));
+
+  clients++;
+  const defaultHighBob = tls.connect({
+    port: server.address().port,
+    rejectUnauthorized: false,
+    highWaterMark: undefined,
+  }, common.mustCall(() => {
+    assert.strictEqual(defaultHighBob.readableHighWaterMark, 16 * 1024);
+    defaultHighBob.end();
+  }));
+
+  clients++;
+  const zeroHighBob = tls.connect({
+    port: server.address().port,
+    rejectUnauthorized: false,
+    highWaterMark: 0,
+  }, common.mustCall(() => {
+    assert.strictEqual(zeroHighBob.readableHighWaterMark, 0);
+    zeroHighBob.end();
+  }));
+}));
diff --git a/test/parallel/test-tls-disable-renegotiation.js b/test/parallel/test-tls-disable-renegotiation.js
index 926e2b8a03e49ea7c4a1cb571ed463e7074327f7..f720eec6c6448aebf3f70373988655179468c2ab 100644
--- a/test/parallel/test-tls-disable-renegotiation.js
+++ b/test/parallel/test-tls-disable-renegotiation.js
@@ -73,8 +73,7 @@ server.listen(0, common.mustCall(() => {
 
     // Negotiation is still permitted for this first
     // attempt. This should succeed.
-    let ok = client.renegotiate(options, common.mustCall((err) => {
-      assert.ifError(err);
+    let ok = client.renegotiate(options, common.mustSucceed(() => {
       // Once renegotiation completes, we write some
       // data to the socket, which triggers the on
       // data event on the server. After that data
diff --git a/test/parallel/test-tls-ecdh-multiple.js b/test/parallel/test-tls-ecdh-multiple.js
index 1fcfc041bd405052ec99dabf64b89b88fc61c67f..25e6314a54a58dd3db3ee1916ee0dd84a75c7522 100644
--- a/test/parallel/test-tls-ecdh-multiple.js
+++ b/test/parallel/test-tls-ecdh-multiple.js
@@ -62,7 +62,7 @@ process.on('exit', function() {
   const unsupportedCurves = [
     'wap-wsg-idm-ecid-wtls1',
     'c2pnb163v1',
-    'prime192v3'
+    'prime192v3',
   ];
 
   // Brainpool is not supported in FIPS mode
diff --git a/test/parallel/test-tls-ecdh.js b/test/parallel/test-tls-ecdh.js
index 23767be92cf00c5abca31b90a0ec25558fd79cb1..c0d2625a9a6168dc1921bb2dd2cf981f6f9183ba 100644
--- a/test/parallel/test-tls-ecdh.js
+++ b/test/parallel/test-tls-ecdh.js
@@ -51,8 +51,7 @@ server.listen(0, '127.0.0.1', common.mustCall(function() {
   const cmd = `"${common.opensslCli}" s_client -cipher ${
     options.ciphers} -connect 127.0.0.1:${this.address().port}`;
 
-  exec(cmd, common.mustCall(function(err, stdout, stderr) {
-    assert.ifError(err);
+  exec(cmd, common.mustSucceed((stdout, stderr) => {
     assert(stdout.includes(reply));
     server.close();
   }));
diff --git a/test/parallel/test-tls-external-accessor.js b/test/parallel/test-tls-external-accessor.js
index 33d371923a600c670424d95b2507e177d6d69073..07d79ef64a516793da34b5ad07dbfc5effdfb3b4 100644
--- a/test/parallel/test-tls-external-accessor.js
+++ b/test/parallel/test-tls-external-accessor.js
@@ -12,11 +12,11 @@ const tls = require('tls');
   const pctx = tls.createSecureContext().context;
   const cctx = Object.create(pctx);
   assert.throws(() => cctx._external, TypeError);
-  pctx._external;
+  pctx._external; // eslint-disable-line no-unused-expressions
 }
 {
   const pctx = tls.createSecurePair().credentials.context;
   const cctx = Object.create(pctx);
   assert.throws(() => cctx._external, TypeError);
-  pctx._external;
+  pctx._external; // eslint-disable-line no-unused-expressions
 }
diff --git a/test/parallel/test-tls-getprotocol.js b/test/parallel/test-tls-getprotocol.js
index ec3642cbf74614801732f5f730c0ee1fc1667177..46dacbee23bebab85638f57a898d9010d92fb28e 100644
--- a/test/parallel/test-tls-getprotocol.js
+++ b/test/parallel/test-tls-getprotocol.js
@@ -13,7 +13,7 @@ const fixtures = require('../common/fixtures');
 const clientConfigs = [
   { secureProtocol: 'TLSv1_method', version: 'TLSv1' },
   { secureProtocol: 'TLSv1_1_method', version: 'TLSv1.1' },
-  { secureProtocol: 'TLSv1_2_method', version: 'TLSv1.2' }
+  { secureProtocol: 'TLSv1_2_method', version: 'TLSv1.2' },
 ];
 
 const serverConfig = {
diff --git a/test/parallel/test-tls-multi-pfx.js b/test/parallel/test-tls-multi-pfx.js
index c20376a82ad8a81b6c66b6baf7de09b4ea28a340..f353183ce2fa0cc4e858f532d3ee922312065445 100644
--- a/test/parallel/test-tls-multi-pfx.js
+++ b/test/parallel/test-tls-multi-pfx.js
@@ -13,7 +13,7 @@ const options = {
       buf: fixtures.readKey('agent1.pfx'),
       passphrase: 'sample'
     },
-    fixtures.readKey('ec.pfx')
+    fixtures.readKey('ec.pfx'),
   ]
 };
 
diff --git a/test/parallel/test-tls-onread-static-buffer.js b/test/parallel/test-tls-onread-static-buffer.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e19184e887d2adb868da3cf0f03623d9959bd4e
--- /dev/null
+++ b/test/parallel/test-tls-onread-static-buffer.js
@@ -0,0 +1,206 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const options = {
+  key: fixtures.readKey('agent2-key.pem'),
+  cert: fixtures.readKey('agent2-cert.pem')
+};
+
+const smallMessage = Buffer.from('hello world');
+// Used to test .pause(), so needs to be larger than the internal buffer
+const largeMessage = Buffer.alloc(64 * 1024).fill('hello world');
+
+// Test typical usage
+tls.createServer(options, common.mustCall(function(socket) {
+  this.close();
+  socket.end(smallMessage);
+})).listen(0, function() {
+  let received = 0;
+  const buffers = [];
+  const sockBuf = Buffer.alloc(8);
+  tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false,
+    onread: {
+      buffer: sockBuf,
+      callback: function(nread, buf) {
+        assert.strictEqual(buf, sockBuf);
+        received += nread;
+        buffers.push(Buffer.from(buf.slice(0, nread)));
+      }
+    }
+  }).on('data', common.mustNotCall()).on('end', common.mustCall(() => {
+    assert.strictEqual(received, smallMessage.length);
+    assert.deepStrictEqual(Buffer.concat(buffers), smallMessage);
+  }));
+});
+
+// Test Uint8Array support
+tls.createServer(options, common.mustCall(function(socket) {
+  this.close();
+  socket.end(smallMessage);
+})).listen(0, function() {
+  let received = 0;
+  let incoming = new Uint8Array(0);
+  const sockBuf = new Uint8Array(8);
+  tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false,
+    onread: {
+      buffer: sockBuf,
+      callback: function(nread, buf) {
+        assert.strictEqual(buf, sockBuf);
+        received += nread;
+        const newIncoming = new Uint8Array(incoming.length + nread);
+        newIncoming.set(incoming);
+        newIncoming.set(buf.slice(0, nread), incoming.length);
+        incoming = newIncoming;
+      }
+    }
+  }).on('data', common.mustNotCall()).on('end', common.mustCall(() => {
+    assert.strictEqual(received, smallMessage.length);
+    assert.deepStrictEqual(incoming, new Uint8Array(smallMessage));
+  }));
+});
+
+// Test Buffer callback usage
+tls.createServer(options, common.mustCall(function(socket) {
+  this.close();
+  socket.end(smallMessage);
+})).listen(0, function() {
+  let received = 0;
+  const incoming = [];
+  const bufPool = [ Buffer.alloc(2), Buffer.alloc(2), Buffer.alloc(2) ];
+  let bufPoolIdx = -1;
+  let bufPoolUsage = 0;
+  tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false,
+    onread: {
+      buffer: () => {
+        ++bufPoolUsage;
+        bufPoolIdx = (bufPoolIdx + 1) % bufPool.length;
+        return bufPool[bufPoolIdx];
+      },
+      callback: function(nread, buf) {
+        assert.strictEqual(buf, bufPool[bufPoolIdx]);
+        received += nread;
+        incoming.push(Buffer.from(buf.slice(0, nread)));
+      }
+    }
+  }).on('data', common.mustNotCall()).on('end', common.mustCall(() => {
+    assert.strictEqual(received, smallMessage.length);
+    assert.deepStrictEqual(Buffer.concat(incoming), smallMessage);
+    assert.strictEqual(bufPoolUsage, 7);
+  }));
+});
+
+// Test Uint8Array callback support
+tls.createServer(options, common.mustCall(function(socket) {
+  this.close();
+  socket.end(smallMessage);
+})).listen(0, function() {
+  let received = 0;
+  let incoming = new Uint8Array(0);
+  const bufPool = [ new Uint8Array(2), new Uint8Array(2), new Uint8Array(2) ];
+  let bufPoolIdx = -1;
+  let bufPoolUsage = 0;
+  tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false,
+    onread: {
+      buffer: () => {
+        ++bufPoolUsage;
+        bufPoolIdx = (bufPoolIdx + 1) % bufPool.length;
+        return bufPool[bufPoolIdx];
+      },
+      callback: function(nread, buf) {
+        assert.strictEqual(buf, bufPool[bufPoolIdx]);
+        received += nread;
+        const newIncoming = new Uint8Array(incoming.length + nread);
+        newIncoming.set(incoming);
+        newIncoming.set(buf.slice(0, nread), incoming.length);
+        incoming = newIncoming;
+      }
+    }
+  }).on('data', common.mustNotCall()).on('end', common.mustCall(() => {
+    assert.strictEqual(received, smallMessage.length);
+    assert.deepStrictEqual(incoming, new Uint8Array(smallMessage));
+    assert.strictEqual(bufPoolUsage, 7);
+  }));
+});
+
+// Test explicit socket pause
+tls.createServer(options, common.mustCall(function(socket) {
+  this.close();
+  // Need larger message here to observe the pause
+  socket.end(largeMessage);
+})).listen(0, function() {
+  let received = 0;
+  const buffers = [];
+  const sockBuf = Buffer.alloc(64);
+  let pauseScheduled = false;
+  const client = tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false,
+    onread: {
+      buffer: sockBuf,
+      callback: function(nread, buf) {
+        assert.strictEqual(buf, sockBuf);
+        received += nread;
+        buffers.push(Buffer.from(buf.slice(0, nread)));
+        if (!pauseScheduled) {
+          pauseScheduled = true;
+          client.pause();
+          setTimeout(() => {
+            client.resume();
+          }, 100);
+        }
+      }
+    }
+  }).on('data', common.mustNotCall()).on('end', common.mustCall(() => {
+    assert.strictEqual(received, largeMessage.length);
+    assert.deepStrictEqual(Buffer.concat(buffers), largeMessage);
+  }));
+});
+
+// Test implicit socket pause
+tls.createServer(options, common.mustCall(function(socket) {
+  this.close();
+  // Need larger message here to observe the pause
+  socket.end(largeMessage);
+})).listen(0, function() {
+  let received = 0;
+  const buffers = [];
+  const sockBuf = Buffer.alloc(64);
+  let pauseScheduled = false;
+  const client = tls.connect({
+    port: this.address().port,
+    rejectUnauthorized: false,
+    onread: {
+      buffer: sockBuf,
+      callback: function(nread, buf) {
+        assert.strictEqual(buf, sockBuf);
+        received += nread;
+        buffers.push(Buffer.from(buf.slice(0, nread)));
+        if (!pauseScheduled) {
+          pauseScheduled = true;
+          setTimeout(() => {
+            client.resume();
+          }, 100);
+          return false;
+        }
+        return true;
+      }
+    }
+  }).on('data', common.mustNotCall()).on('end', common.mustCall(() => {
+    assert.strictEqual(received, largeMessage.length);
+    assert.deepStrictEqual(Buffer.concat(buffers), largeMessage);
+  }));
+});
diff --git a/test/parallel/test-tls-options-boolean-check.js b/test/parallel/test-tls-options-boolean-check.js
index 4dae8e47c8ea7010e9bbbf229a6f63650fdb4e28..900a39f0c1cd4249134fc42c8bf7046cdf8b6a60 100644
--- a/test/parallel/test-tls-options-boolean-check.js
+++ b/test/parallel/test-tls-options-boolean-check.js
@@ -61,7 +61,7 @@ const caArrDataView = toDataView(caCert);
   [[keyStr, keyStr2], false],
   [false, [certStr, certStr2]],
   [[{ pem: keyBuff }], false],
-  [[{ pem: keyBuff }, { pem: keyBuff }], false]
+  [[{ pem: keyBuff }, { pem: keyBuff }], false],
 ].forEach(([key, cert]) => {
   tls.createServer({ key, cert });
 });
@@ -79,7 +79,7 @@ const caArrDataView = toDataView(caCert);
   [[keyBuff, true], [certBuff, certBuff2], 1],
   [[true, keyStr2], [certStr, certStr2], 0],
   [[true, false], [certBuff, certBuff2], 0],
-  [true, [certBuff, certBuff2]]
+  [true, [certBuff, certBuff2]],
 ].forEach(([key, cert, index]) => {
   const val = index === undefined ? key : key[index];
   assert.throws(() => {
@@ -105,7 +105,7 @@ const caArrDataView = toDataView(caCert);
   [[keyBuff, keyBuff2], [true, certBuff2], 0],
   [[keyStr, keyStr2], [certStr, true], 1],
   [[keyStr, keyStr2], [true, false], 0],
-  [[keyStr, keyStr2], true]
+  [[keyStr, keyStr2], true],
 ].forEach(([key, cert, index]) => {
   const val = index === undefined ? cert : cert[index];
   assert.throws(() => {
@@ -140,7 +140,7 @@ const caArrDataView = toDataView(caCert);
   [keyBuff, certBuff, {}],
   [keyBuff, certBuff, 1],
   [keyBuff, certBuff, true],
-  [keyBuff, certBuff, [caCert, true], 1]
+  [keyBuff, certBuff, [caCert, true], 1],
 ].forEach(([key, cert, ca, index]) => {
   const val = index === undefined ? ca : ca[index];
   assert.throws(() => {
@@ -161,7 +161,7 @@ const caArrDataView = toDataView(caCert);
   [false, false, false],
   [undefined, undefined, undefined],
   ['', '', ''],
-  [0, 0, 0]
+  [0, 0, 0],
 ].forEach(([key, cert, ca]) => {
   tls.createSecureContext({ key, cert, ca });
 });
diff --git a/test/parallel/test-tls-psk-server.js b/test/parallel/test-tls-psk-server.js
index 434d31380fe2adf180a7f9d39fa96acfb523c658..b92609584015220d89b7df42728805bc87786f5d 100644
--- a/test/parallel/test-tls-psk-server.js
+++ b/test/parallel/test-tls-psk-server.js
@@ -46,7 +46,7 @@ server.listen(0, () => {
     '-connect', `127.0.0.1:${server.address().port}`,
     '-cipher', CIPHERS,
     '-psk', KEY,
-    '-psk_identity', IDENTITY
+    '-psk_identity', IDENTITY,
   ]);
 
   let out = '';
diff --git a/test/parallel/test-tls-server-verify.js b/test/parallel/test-tls-server-verify.js
index 347dfd985ab97d167886380893be0c7ee325d1e1..51ccd0d747fdf59a10d06bf239259f52b3aeb1e9 100644
--- a/test/parallel/test-tls-server-verify.js
+++ b/test/parallel/test-tls-server-verify.js
@@ -53,9 +53,8 @@ const testCases =
      [{ name: 'agent1', shouldReject: false, shouldAuth: false },
       { name: 'agent2', shouldReject: false, shouldAuth: false },
       { name: 'agent3', shouldReject: false, shouldAuth: false },
-      { name: 'nocert', shouldReject: false, shouldAuth: false }
-     ]
-  },
+      { name: 'nocert', shouldReject: false, shouldAuth: false },
+     ] },
 
    { title: 'Allow both authed and unauthed connections with CA1',
      requestCert: true,
@@ -66,9 +65,8 @@ const testCases =
     [{ name: 'agent1', shouldReject: false, shouldAuth: true },
      { name: 'agent2', shouldReject: false, shouldAuth: false },
      { name: 'agent3', shouldReject: false, shouldAuth: false },
-     { name: 'nocert', shouldReject: false, shouldAuth: false }
-    ]
-   },
+     { name: 'nocert', shouldReject: false, shouldAuth: false },
+    ] },
 
    { title: 'Do not request certs at connection. Do that later',
      requestCert: false,
@@ -79,9 +77,8 @@ const testCases =
     [{ name: 'agent1', shouldReject: false, shouldAuth: true },
      { name: 'agent2', shouldReject: false, shouldAuth: false },
      { name: 'agent3', shouldReject: false, shouldAuth: false },
-     { name: 'nocert', shouldReject: false, shouldAuth: false }
-    ]
-   },
+     { name: 'nocert', shouldReject: false, shouldAuth: false },
+    ] },
 
    { title: 'Allow only authed connections with CA1',
      requestCert: true,
@@ -92,9 +89,8 @@ const testCases =
     [{ name: 'agent1', shouldReject: false, shouldAuth: true },
      { name: 'agent2', shouldReject: true },
      { name: 'agent3', shouldReject: true },
-     { name: 'nocert', shouldReject: true }
-    ]
-   },
+     { name: 'nocert', shouldReject: true },
+    ] },
 
    { title: 'Allow only authed connections with CA1 and CA2',
      requestCert: true,
@@ -105,9 +101,8 @@ const testCases =
     [{ name: 'agent1', shouldReject: false, shouldAuth: true },
      { name: 'agent2', shouldReject: true },
      { name: 'agent3', shouldReject: false, shouldAuth: true },
-     { name: 'nocert', shouldReject: true }
-    ]
-   },
+     { name: 'nocert', shouldReject: true },
+    ] },
 
 
    { title: 'Allow only certs signed by CA2 but not in the CRL',
@@ -122,9 +117,8 @@ const testCases =
        { name: 'agent3', shouldReject: false, shouldAuth: true },
        // Agent4 has a cert in the CRL.
        { name: 'agent4', shouldReject: true, shouldAuth: false },
-       { name: 'nocert', shouldReject: true }
-     ]
-   }
+       { name: 'nocert', shouldReject: true },
+     ] },
   ];
 
 function filenamePEM(n) {
@@ -265,10 +259,8 @@ function runTest(port, testIndex) {
     rejectUnauthorized: tcase.rejectUnauthorized
   };
 
-  /*
-   * If renegotiating - session might be resumed and openssl won't request
-   * client's certificate (probably because of bug in the openssl)
-   */
+  // If renegotiating - session might be resumed and openssl won't request
+  // client's certificate (probably because of bug in the openssl)
   if (tcase.renegotiate) {
     serverOptions.secureOptions =
         SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
diff --git a/test/parallel/test-tls-session-cache.js b/test/parallel/test-tls-session-cache.js
index 2be093a4f596fc727c16bfd31bff6ccf1cfdb617..46903583b224ccb9071cb4861c98d9eb0bf48c99 100644
--- a/test/parallel/test-tls-session-cache.js
+++ b/test/parallel/test-tls-session-cache.js
@@ -103,7 +103,7 @@ function doTest(testOptions, callback) {
       '-servername', 'ohgod',
       '-key', fixtures.path('keys/rsa_private.pem'),
       '-cert', fixtures.path('keys/rsa_cert.crt'),
-      '-reconnect'
+      '-reconnect',
     ].concat(testOptions.tickets ? [] : '-no_ticket');
 
     function spawnClient() {
diff --git a/test/parallel/test-tls-set-secure-context.js b/test/parallel/test-tls-set-secure-context.js
index f72daff6ef14fb33f8ff69b417ecb2abe798d556..ed409f4f80203440d4864f9af4b3393f6daaf471 100644
--- a/test/parallel/test-tls-set-secure-context.js
+++ b/test/parallel/test-tls-set-secure-context.js
@@ -21,7 +21,7 @@ const credentialOptions = [
     key: fixtures.readKey('agent2-key.pem'),
     cert: fixtures.readKey('agent2-cert.pem'),
     ca: fixtures.readKey('ca2-cert.pem')
-  }
+  },
 ];
 let firstResponse;
 
diff --git a/test/parallel/test-tls-socket-allow-half-open-option.js b/test/parallel/test-tls-socket-allow-half-open-option.js
index 36449a6130c6d16ae226d9124f2e99ac3b4a2acc..6b94c39747a31c8405f202653573e941eea98ef2 100644
--- a/test/parallel/test-tls-socket-allow-half-open-option.js
+++ b/test/parallel/test-tls-socket-allow-half-open-option.js
@@ -21,7 +21,10 @@ const tls = require('tls');
 {
   // The option is ignored when the `socket` argument is a generic
   // `stream.Duplex`.
-  const duplex = new stream.Duplex({ allowHalfOpen: false });
+  const duplex = new stream.Duplex({
+    allowHalfOpen: false,
+    read() {}
+  });
   const socket = new tls.TLSSocket(duplex, { allowHalfOpen: true });
   assert.strictEqual(socket.allowHalfOpen, false);
 }
diff --git a/test/parallel/test-tls-startcom-wosign-whitelist.js b/test/parallel/test-tls-startcom-wosign-whitelist.js
index 33da14884836bfa6c6c181b07366f7b134f2e3bd..56ffd73aac0e54d57c3eafa4d1fbbe88b61bb1a8 100644
--- a/test/parallel/test-tls-startcom-wosign-whitelist.js
+++ b/test/parallel/test-tls-startcom-wosign-whitelist.js
@@ -39,7 +39,7 @@ const testCases = [
       rejectUnauthorized: true
     },
     errorCode: 'CERT_REVOKED'
-  }
+  },
 ];
 
 
diff --git a/test/parallel/test-tls-ticket-invalid-arg.js b/test/parallel/test-tls-ticket-invalid-arg.js
new file mode 100644
index 0000000000000000000000000000000000000000..55143cdca31e77ee8eb62122d837075171316afa
--- /dev/null
+++ b/test/parallel/test-tls-ticket-invalid-arg.js
@@ -0,0 +1,24 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+
+const assert = require('assert');
+const tls = require('tls');
+
+const server = new tls.Server();
+
+[null, undefined, 0, 1, 1n, Symbol(), {}, [], true, false, '', () => {}]
+  .forEach((arg) =>
+    assert.throws(
+      () => server.setTicketKeys(arg),
+      { code: 'ERR_INVALID_ARG_TYPE' }
+    ));
+
+[new Uint8Array(1), Buffer.from([1]), new DataView(new ArrayBuffer(2))].forEach(
+  (arg) =>
+    assert.throws(() => {
+      server.setTicketKeys(arg);
+    }, /Session ticket keys must be a 48-byte buffer/)
+);
diff --git a/test/parallel/test-tls-tlswrap-segfault-2.js b/test/parallel/test-tls-tlswrap-segfault-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..d4f3b12b99fdd516a0c42cbda7b2b8189a7f21be
--- /dev/null
+++ b/test/parallel/test-tls-tlswrap-segfault-2.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+// This test ensures that Node.js doesn't incur a segfault while
+// adding session or keylog listeners after destroy.
+// https://github.com/nodejs/node/issues/38133
+// https://github.com/nodejs/node/issues/38135
+
+const tls = require('tls');
+const tlsSocketKeyLog = tls.connect('cause-error');
+tlsSocketKeyLog.on('error', common.mustCall());
+tlsSocketKeyLog.on('close', common.mustCall(() => {
+  tlsSocketKeyLog.on('keylog', common.mustNotCall());
+}));
+
+const tlsSocketSession = tls.connect('cause-error-2');
+tlsSocketSession.on('error', common.mustCall());
+tlsSocketSession.on('close', common.mustCall(() => {
+  tlsSocketSession.on('session', common.mustNotCall());
+}));
diff --git a/test/parallel/test-tls-transport-destroy-after-own-gc.js b/test/parallel/test-tls-transport-destroy-after-own-gc.js
index 9b9c8353077dfe11ca9de7b8333583141837fa7a..819aa0a03d6cb4ca56333ce42475e369926aa744 100644
--- a/test/parallel/test-tls-transport-destroy-after-own-gc.js
+++ b/test/parallel/test-tls-transport-destroy-after-own-gc.js
@@ -15,12 +15,12 @@ const makeDuplexPair = require('../common/duplexpair');
 let { clientSide } = makeDuplexPair();
 
 let clientTLS = new TLSSocket(clientSide, { isServer: false });
-let clientTLSHandle = clientTLS._handle;
+let clientTLSHandle = clientTLS._handle;  // eslint-disable-line no-unused-vars
 
 setImmediate(() => {
   clientTLS = null;
   global.gc();
-  clientTLSHandle = null; // eslint-disable-line no-unused-vars
+  clientTLSHandle = null;
   global.gc();
   setImmediate(() => {
     clientSide = null;
diff --git a/test/parallel/test-tls-wrap-econnreset-localaddress.js b/test/parallel/test-tls-wrap-econnreset-localaddress.js
index 9df145ac374ab73d97aa05698edb2b91e23c3e9c..30d3a8873fa8f05c1d53e702c9ddf4f07d301baa 100644
--- a/test/parallel/test-tls-wrap-econnreset-localaddress.js
+++ b/test/parallel/test-tls-wrap-econnreset-localaddress.js
@@ -13,6 +13,7 @@ const server = net.createServer((c) => {
 }).listen(common.mustCall(() => {
   const port = server.address().port;
 
+  let errored = false;
   tls.connect({
     port: port,
     localAddress: common.localhostIPv4
@@ -24,5 +25,9 @@ const server = net.createServer((c) => {
       assert.strictEqual(e.port, port);
       assert.strictEqual(e.localAddress, common.localhostIPv4);
       server.close();
+      errored = true;
+    }))
+    .on('close', common.mustCall(() => {
+      assert.strictEqual(errored, true);
     }));
 }));
diff --git a/test/parallel/test-tls-wrap-econnreset-pipe.js b/test/parallel/test-tls-wrap-econnreset-pipe.js
index b400e35d412392e5ac620c3d47306da3cf6d11d3..f294f23f1d00c974b706ae5d113da05308ab1cbc 100644
--- a/test/parallel/test-tls-wrap-econnreset-pipe.js
+++ b/test/parallel/test-tls-wrap-econnreset-pipe.js
@@ -7,13 +7,31 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const tls = require('tls');
 const net = require('net');
+const { fork } = require('child_process');
 
 const tmpdir = require('../common/tmpdir');
-tmpdir.refresh();
 
+// Run in a child process because the PIPE file descriptor stays open until
+// Node.js completes, blocking the tmpdir and preventing cleanup.
+
+if (process.argv[2] !== 'child') {
+  // Parent
+  tmpdir.refresh();
+
+  // Run test
+  const child = fork(__filename, ['child'], { stdio: 'inherit' });
+  child.on('exit', common.mustCall(function(code) {
+    assert.strictEqual(code, 0);
+  }));
+
+  return;
+}
+
+// Child
 const server = net.createServer((c) => {
   c.end();
 }).listen(common.PIPE, common.mustCall(() => {
+  let errored = false;
   tls.connect({ path: common.PIPE })
     .once('error', common.mustCall((e) => {
       assert.strictEqual(e.code, 'ECONNRESET');
@@ -22,5 +40,9 @@ const server = net.createServer((c) => {
       assert.strictEqual(e.host, undefined);
       assert.strictEqual(e.localAddress, undefined);
       server.close();
+      errored = true;
+    }))
+    .on('close', common.mustCall(() => {
+      assert.strictEqual(errored, true);
     }));
 }));
diff --git a/test/parallel/test-tls-wrap-econnreset-socket.js b/test/parallel/test-tls-wrap-econnreset-socket.js
index 672da9876fd0059906557c496020a2b3536c9df0..ec305b785e05459637763b324c084d3828ee7283 100644
--- a/test/parallel/test-tls-wrap-econnreset-socket.js
+++ b/test/parallel/test-tls-wrap-econnreset-socket.js
@@ -15,6 +15,7 @@ const server = net.createServer((c) => {
 
   const socket = new net.Socket();
 
+  let errored = false;
   tls.connect({ socket })
     .once('error', common.mustCall((e) => {
       assert.strictEqual(e.code, 'ECONNRESET');
@@ -22,7 +23,11 @@ const server = net.createServer((c) => {
       assert.strictEqual(e.host, undefined);
       assert.strictEqual(e.port, undefined);
       assert.strictEqual(e.localAddress, undefined);
+      errored = true;
       server.close();
+    }))
+    .on('close', common.mustCall(() => {
+      assert.strictEqual(errored, true);
     }));
 
   socket.connect(port);
diff --git a/test/parallel/test-tls-wrap-econnreset.js b/test/parallel/test-tls-wrap-econnreset.js
index 5c6db86b75e06a958b2b3de268b5c508c4e30053..6ed268e766f704e1409e82aeab0382ffb4b89483 100644
--- a/test/parallel/test-tls-wrap-econnreset.js
+++ b/test/parallel/test-tls-wrap-econnreset.js
@@ -13,6 +13,7 @@ const server = net.createServer((c) => {
 }).listen(common.mustCall(() => {
   const port = server.address().port;
 
+  let errored = false;
   tls.connect(port, common.localhostIPv4)
     .once('error', common.mustCall((e) => {
       assert.strictEqual(e.code, 'ECONNRESET');
@@ -21,5 +22,9 @@ const server = net.createServer((c) => {
       assert.strictEqual(e.port, port);
       assert.strictEqual(e.localAddress, undefined);
       server.close();
+      errored = true;
+    }))
+    .on('close', common.mustCall(() => {
+      assert.strictEqual(errored, true);
     }));
 }));
diff --git a/test/parallel/test-tls-wrap-event-emmiter.js b/test/parallel/test-tls-wrap-event-emmiter.js
index 871e6c9ae6834c7a35434bd58c4612e849f012ae..47933da674bc93d6699b63c82afbb988bbda1c4d 100644
--- a/test/parallel/test-tls-wrap-event-emmiter.js
+++ b/test/parallel/test-tls-wrap-event-emmiter.js
@@ -1,9 +1,7 @@
 'use strict';
 
-/*
- * Issue: https://github.com/nodejs/node/issues/3655
- * Test checks if we get exception instead of runtime error
- */
+// Issue: https://github.com/nodejs/node/issues/3655
+// Test checks if we get exception instead of runtime error
 
 const common = require('../common');
 if (!common.hasCrypto)
diff --git a/test/parallel/test-tls-write-error.js b/test/parallel/test-tls-write-error.js
index 2783e62d063a28ee2227bb6d828bf6687f5fc5ef..77f003139f99c6d3870be7b57069cc4e88672562 100644
--- a/test/parallel/test-tls-write-error.js
+++ b/test/parallel/test-tls-write-error.js
@@ -45,7 +45,7 @@ const server = https.createServer(opts, (req, res) => {
       cke,
       ccs,
       client.encrypt(finished),
-      client.encrypt(ill)
+      client.encrypt(ill),
     ]);
     client.write(frames, common.mustCall(() => {
       client.end();
diff --git a/test/parallel/test-trace-atomics-wait.js b/test/parallel/test-trace-atomics-wait.js
new file mode 100644
index 0000000000000000000000000000000000000000..03b76791586d9810c2ef5af4d11e3c7e33c3bec1
--- /dev/null
+++ b/test/parallel/test-trace-atomics-wait.js
@@ -0,0 +1,95 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const child_process = require('child_process');
+const { Worker } = require('worker_threads');
+
+if (process.argv[2] === 'child') {
+  const i32arr = new Int32Array(new SharedArrayBuffer(8));
+  assert.strictEqual(Atomics.wait(i32arr, 0, 1), 'not-equal');
+  assert.strictEqual(Atomics.wait(i32arr, 0, 0, 10), 'timed-out');
+
+  new Worker(`
+  const i32arr = require('worker_threads').workerData;
+  Atomics.store(i32arr, 1, -1);
+  Atomics.notify(i32arr, 1);
+  Atomics.wait(i32arr, 1, -1);
+  `, { eval: true, workerData: i32arr });
+
+  Atomics.wait(i32arr, 1, 0);
+  assert.strictEqual(Atomics.load(i32arr, 1), -1);
+  Atomics.store(i32arr, 1, 0);
+  Atomics.notify(i32arr, 1);
+  return;
+}
+
+const proc = child_process.spawnSync(
+  process.execPath,
+  [ '--trace-atomics-wait', __filename, 'child' ],
+  { encoding: 'utf8', stdio: [ 'inherit', 'inherit', 'pipe' ] });
+
+if (proc.status !== 0) console.log(proc);
+assert.strictEqual(proc.status, 0);
+
+const SABAddress = proc.stderr.match(/Atomics\.wait\((?<SAB>.+) \+/).groups.SAB;
+const actualTimeline = proc.stderr
+  .replace(new RegExp(SABAddress, 'g'), '<address>')
+  .replace(new RegExp(`\\(node:${proc.pid}\\) `, 'g'), '')
+  .replace(/\binf(inity)?\b/gi, 'inf')
+  .replace(/\r/g, '')
+  .trim();
+console.log('+++ normalized stdout +++');
+console.log(actualTimeline);
+console.log('--- normalized stdout ---');
+
+const begin =
+`[Thread 0] Atomics.wait(<address> + 0, 1, inf) started
+[Thread 0] Atomics.wait(<address> + 0, 1, inf) did not wait because the \
+values mismatched
+[Thread 0] Atomics.wait(<address> + 0, 0, 10) started
+[Thread 0] Atomics.wait(<address> + 0, 0, 10) timed out`;
+
+const expectedTimelines = [
+  `${begin}
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) started
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) started
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) was woken up by another thread
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) was woken up by another thread`,
+  `${begin}
+[Thread 1] Atomics.wait(<address> + 4, 0, inf) started
+[Thread 0] Atomics.wait(<address> + 4, -1, inf) started
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) was woken up by another thread
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) was woken up by another thread`,
+  `${begin}
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) started
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) was woken up by another thread
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) started
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) was woken up by another thread`,
+  `${begin}
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) started
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) was woken up by another thread
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) started
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) did not wait because the \
+values mismatched`,
+  `${begin}
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) started
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) started
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) was woken up by another thread
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) did not wait because the \
+values mismatched`,
+  `${begin}
+[Thread 1] Atomics.wait(<address> + 4, 0, inf) started
+[Thread 0] Atomics.wait(<address> + 4, -1, inf) started
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) was woken up by another thread
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) did not wait because the \
+values mismatched`,
+  `${begin}
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) started
+[Thread 0] Atomics.wait(<address> + 4, 0, inf) did not wait because the \
+values mismatched
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) started
+[Thread 1] Atomics.wait(<address> + 4, -1, inf) did not wait because the \
+values mismatched`,
+];
+
+assert(expectedTimelines.includes(actualTimeline));
diff --git a/test/parallel/test-trace-events-api.js b/test/parallel/test-trace-events-api.js
index e45f374bab642c3775f7fd3fa87e64cc7f3cef7b..759075e74f1d6ebf8026a8a312ee292f3a31674b 100644
--- a/test/parallel/test-trace-events-api.js
+++ b/test/parallel/test-trace-events-api.js
@@ -64,7 +64,7 @@ assert.strictEqual(tracing.enabled, true);
 
 assert.strictEqual(getEnabledCategories(),
                    [
-                     ...[enabledCategories].filter((_) => !!_), 'node.perf'
+                     ...[enabledCategories].filter((_) => !!_), 'node.perf',
                    ].join(','));
 
 tracing.disable();
@@ -134,23 +134,27 @@ function testApiInChildProcess(execArgs, cb) {
   const expectedMarks = ['A', 'B'];
   const expectedBegins = [
     { cat: 'node,node.perf,node.perf.timerify', name: 'f' },
-    { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' }
+    { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' },
   ];
   const expectedEnds = [
     { cat: 'node,node.perf,node.perf.timerify', name: 'f' },
-    { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' }
+    { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' },
   ];
 
   const proc = cp.fork(__filename,
                        ['child'],
-                       { execArgv: [ '--expose-gc', ...execArgs ] });
+                       {
+                         execArgv: [
+                           '--expose-gc',
+                           ...execArgs,
+                         ]
+                       });
 
   proc.once('exit', common.mustCall(() => {
     const file = path.join(tmpdir.path, 'node_trace.1.log');
 
     assert(fs.existsSync(file));
-    fs.readFile(file, common.mustCall((err, data) => {
-      assert.ifError(err);
+    fs.readFile(file, common.mustSucceed((data) => {
       const traces = JSON.parse(data.toString()).traceEvents
         .filter((trace) => trace.cat !== '__metadata');
       assert.strictEqual(traces.length,
diff --git a/test/parallel/test-trace-events-async-hooks-dynamic.js b/test/parallel/test-trace-events-async-hooks-dynamic.js
index b660f7f8d49ee81057c406837df849f07e16d516..a1b59d48c0387569e93716f9d06c3edd685d7bc4 100644
--- a/test/parallel/test-trace-events-async-hooks-dynamic.js
+++ b/test/parallel/test-trace-events-async-hooks-dynamic.js
@@ -31,8 +31,7 @@ const proc = cp.spawnSync(
     cwd: tmpdir.path,
     env: { ...process.env,
            'NODE_DEBUG_NATIVE': 'tracing',
-           'NODE_DEBUG': 'tracing'
-    }
+           'NODE_DEBUG': 'tracing' }
   });
 
 console.log('process exit with signal:', proc.signal);
diff --git a/test/parallel/test-trace-events-async-hooks-worker.js b/test/parallel/test-trace-events-async-hooks-worker.js
index 185f310f89e13a183b99cc0e86b444b72c0bfb2e..7807a29925ca11c16787cd70e7425af2829846c3 100644
--- a/test/parallel/test-trace-events-async-hooks-worker.js
+++ b/test/parallel/test-trace-events-async-hooks-worker.js
@@ -38,8 +38,7 @@ const proc = cp.spawnSync(
     cwd: tmpdir.path,
     env: { ...process.env,
            'NODE_DEBUG_NATIVE': 'tracing',
-           'NODE_DEBUG': 'tracing'
-    }
+           'NODE_DEBUG': 'tracing' }
   });
 
 console.log('process exit with signal:', proc.signal);
diff --git a/test/parallel/test-trace-events-bootstrap.js b/test/parallel/test-trace-events-bootstrap.js
index 7251a9824dc951e0b07fb8ad6e19ddf66bae5614..3b9cb95a69f7b6554a84b18de8b0aa080754224b 100644
--- a/test/parallel/test-trace-events-bootstrap.js
+++ b/test/parallel/test-trace-events-bootstrap.js
@@ -12,11 +12,11 @@ const names = [
   'v8Start',
   'loopStart',
   'loopExit',
-  'bootstrapComplete'
+  'bootstrapComplete',
 ];
 
 if (process.argv[2] === 'child') {
-  1 + 1;
+  1 + 1; // eslint-disable-line no-unused-expressions
 } else {
   tmpdir.refresh();
 
@@ -25,7 +25,7 @@ if (process.argv[2] === 'child') {
                          cwd: tmpdir.path,
                          execArgv: [
                            '--trace-event-categories',
-                           'node.bootstrap'
+                           'node.bootstrap',
                          ]
                        });
 
diff --git a/test/parallel/test-trace-events-console.js b/test/parallel/test-trace-events-console.js
index a4860b5da008b4a2135c6756c698ffc61fa0e5ca..01a532d69e704ac3194877d5df86547262936bf3 100644
--- a/test/parallel/test-trace-events-console.js
+++ b/test/parallel/test-trace-events-console.js
@@ -11,7 +11,7 @@ const tmpdir = require('../common/tmpdir');
 
 const names = [
   'time::foo',
-  'count::bar'
+  'count::bar',
 ];
 const expectedCounts = [ 1, 2, 0 ];
 const expectedTimeTypes = [ 'b', 'n', 'e' ];
@@ -37,7 +37,7 @@ if (process.argv[2] === 'child') {
                          cwd: tmpdir.path,
                          execArgv: [
                            '--trace-event-categories',
-                           'node.console'
+                           'node.console',
                          ]
                        });
 
diff --git a/test/parallel/test-trace-events-environment.js b/test/parallel/test-trace-events-environment.js
index 14900dfc96ff4662c5d11d457ff12dd0d6fa5df9..8105b8394b0d71fee3fd21ed61974090082658db 100644
--- a/test/parallel/test-trace-events-environment.js
+++ b/test/parallel/test-trace-events-environment.js
@@ -17,16 +17,18 @@ const names = new Set([
   'RunTimers',
   'BeforeExit',
   'RunCleanup',
-  'AtExit'
+  'AtExit',
 ]);
 
 if (process.argv[2] === 'child') {
+  /* eslint-disable no-unused-expressions */
   // This is just so that the child has something to do.
   1 + 1;
   // These ensure that the RunTimers, CheckImmediate, and
   // RunAndClearNativeImmediates appear in the list.
   setImmediate(() => { 1 + 1; });
   setTimeout(() => { 1 + 1; }, 1);
+  /* eslint-enable no-unused-expressions */
 } else {
   tmpdir.refresh();
 
@@ -35,7 +37,7 @@ if (process.argv[2] === 'child') {
                          cwd: tmpdir.path,
                          execArgv: [
                            '--trace-event-categories',
-                           'node.environment'
+                           'node.environment',
                          ]
                        });
 
diff --git a/test/parallel/test-trace-events-file-pattern.js b/test/parallel/test-trace-events-file-pattern.js
index d9cd8e66d2364607481c74f99059b5c89cd741c1..0c5097b2e174fd9a53e9918531ade0a972bd3eec 100644
--- a/test/parallel/test-trace-events-file-pattern.js
+++ b/test/parallel/test-trace-events-file-pattern.js
@@ -16,7 +16,7 @@ const proc = cp.spawn(process.execPath, [
   '--trace-event-file-pattern',
   // eslint-disable-next-line no-template-curly-in-string
   '${pid}-${rotation}-${pid}-${rotation}.tracing.log',
-  '-e', CODE
+  '-e', CODE,
 ], { cwd: tmpdir.path });
 
 proc.once('exit', common.mustCall(() => {
diff --git a/test/parallel/test-trace-events-fs-sync.js b/test/parallel/test-trace-events-fs-sync.js
index d8e9ca30a8ebd3429c093dafff63a255fe137a71..41a0d2926f4fa1f06d50fe77ca5a98c4d917caaf 100644
--- a/test/parallel/test-trace-events-fs-sync.js
+++ b/test/parallel/test-trace-events-fs-sync.js
@@ -23,7 +23,7 @@ tests['fs.sync.chmod'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
                          'fs.chmodSync("fs.txt",100);' +
                          'fs.unlinkSync("fs.txt")';
 tests['fs.sync.chown'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                         'fs.chownSync("fs.txt",' + uid + ',' + gid + ');' +
+                         `fs.chownSync("fs.txt", ${uid}, ${gid});` +
                          'fs.unlinkSync("fs.txt")';
 tests['fs.sync.close'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
                          'fs.unlinkSync("fs.txt")';
@@ -36,7 +36,7 @@ tests['fs.sync.fchmod'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
                           'fs.unlinkSync("fs.txt")';
 tests['fs.sync.fchown'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
                           'const fd = fs.openSync("fs.txt", "r+");' +
-                          'fs.fchownSync(fd,' + uid + ',' + gid + ');' +
+                          `fs.fchownSync(fd, ${uid}, ${gid});` +
                           'fs.unlinkSync("fs.txt")';
 tests['fs.sync.fdatasync'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
                              'const fd = fs.openSync("fs.txt", "r+");' +
@@ -58,7 +58,7 @@ tests['fs.sync.futimes'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
                            'fs.futimesSync(fd,1,1);' +
                            'fs.unlinkSync("fs.txt")';
 tests['fs.sync.lchown'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                          'fs.lchownSync("fs.txt",' + uid + ',' + gid + ');' +
+                          `fs.lchownSync("fs.txt", ${uid}, ${gid});` +
                           'fs.unlinkSync("fs.txt")';
 tests['fs.sync.link'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
                         'fs.linkSync("fs.txt", "linkx");' +
diff --git a/test/parallel/test-trace-events-perf.js b/test/parallel/test-trace-events-perf.js
index 2403a8078a47fdf2be9f78b6911b119d1c124f5e..e9701be7a343c774b628c7c14c592d2b23ab0054 100644
--- a/test/parallel/test-trace-events-perf.js
+++ b/test/parallel/test-trace-events-perf.js
@@ -26,21 +26,21 @@ if (process.argv[2] === 'child') {
   const expectedMarks = ['A', 'B'];
   const expectedBegins = [
     { cat: 'node,node.perf,node.perf.timerify', name: 'f' },
-    { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' }
+    { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' },
   ];
   const expectedEnds = [
     { cat: 'node,node.perf,node.perf.timerify', name: 'f' },
-    { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' }
+    { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' },
   ];
 
   const proc = cp.fork(__filename,
                        [
-                         'child'
+                         'child',
                        ], {
                          cwd: tmpdir.path,
                          execArgv: [
                            '--trace-event-categories',
-                           'node.perf'
+                           'node.perf',
                          ]
                        });
 
diff --git a/test/parallel/test-trace-events-promises.js b/test/parallel/test-trace-events-promises.js
index 0dd4fddc6d75ba92e3153ea83600ccfb977e4fec..eec463369c119e15b7781309e2b8c9f998cc5f15 100644
--- a/test/parallel/test-trace-events-promises.js
+++ b/test/parallel/test-trace-events-promises.js
@@ -23,7 +23,7 @@ if (process.argv[2] === 'child') {
                          execArgv: [
                            '--no-warnings',
                            '--trace-event-categories',
-                           'node.promises.rejections'
+                           'node.promises.rejections',
                          ]
                        });
 
diff --git a/test/parallel/test-trace-events-vm.js b/test/parallel/test-trace-events-vm.js
index 3e5d32b6c3f82c3097f4f499acb2462f22a9e85d..b3d3a403bec7119ef3f63c805fadfc63baab6a92 100644
--- a/test/parallel/test-trace-events-vm.js
+++ b/test/parallel/test-trace-events-vm.js
@@ -9,7 +9,7 @@ const tmpdir = require('../common/tmpdir');
 const names = [
   'ContextifyScript::New',
   'RunInThisContext',
-  'RunInContext'
+  'RunInContext',
 ];
 
 if (process.argv[2] === 'child') {
@@ -23,7 +23,7 @@ if (process.argv[2] === 'child') {
                          cwd: tmpdir.path,
                          execArgv: [
                            '--trace-event-categories',
-                           'node.vm.script'
+                           'node.vm.script',
                          ]
                        });
 
diff --git a/test/parallel/test-tracing-no-crash.js b/test/parallel/test-tracing-no-crash.js
index 0ae402f5288cca5870fec18cc531eb16560781c8..2e5d42b6067bb769f6d02d39a6030c07a954266e 100644
--- a/test/parallel/test-tracing-no-crash.js
+++ b/test/parallel/test-tracing-no-crash.js
@@ -9,7 +9,7 @@ function CheckNoSignalAndErrorCodeOne(code, signal) {
 }
 
 const child = spawn(process.execPath, [
-  '--trace-event-categories', 'madeup', '-e', 'throw new Error()'
+  '--trace-event-categories', 'madeup', '-e', 'throw new Error()',
 ], { stdio: [ 'inherit', 'inherit', 'pipe' ] });
 child.on('exit', common.mustCall(CheckNoSignalAndErrorCodeOne));
 
diff --git a/test/parallel/test-tty-backwards-api.js b/test/parallel/test-tty-backwards-api.js
index b4005bad61a3b194ea071e019d8ed837e88034fe..16e71aab9e187c273ac28a309f48aecfa4ea42bc 100644
--- a/test/parallel/test-tty-backwards-api.js
+++ b/test/parallel/test-tty-backwards-api.js
@@ -19,7 +19,7 @@ const { WriteStream } = require('tty');
   'cursorTo',
   'moveCursor',
   'clearLine',
-  'clearScreenDown'
+  'clearScreenDown',
 ].forEach((method) => {
   readline[method] = common.mustCall(function() {
     const lastArg = arguments[arguments.length - 1];
diff --git a/test/parallel/test-url-domain-ascii-unicode.js b/test/parallel/test-url-domain-ascii-unicode.js
index 49259a7ab0f4c427d9c2215ac24e8dba7c208fb4..737294c241fbfe621e5bd15ace51c9b42b803245 100644
--- a/test/parallel/test-url-domain-ascii-unicode.js
+++ b/test/parallel/test-url-domain-ascii-unicode.js
@@ -18,7 +18,7 @@ const domainWithASCII = [
   ['名がドメイン.com', 'xn--v8jxj3d1dzdz08w.com'],
   ['افغانستا.icom.museum', 'xn--mgbaal8b0b9b2b.icom.museum'],
   ['الجزائر.icom.fake', 'xn--lgbbat1ad8j.icom.fake'],
-  ['भारत.org', 'xn--h2brj9c.org']
+  ['भारत.org', 'xn--h2brj9c.org'],
 ];
 
 domainWithASCII.forEach((pair) => {
diff --git a/test/parallel/test-url-format-invalid-input.js b/test/parallel/test-url-format-invalid-input.js
index 99a35b76f08e722bbad791dac84ea74f2079cb53..efa1a9ba1df6bf911571ebf8c00dd18ea7790756 100644
--- a/test/parallel/test-url-format-invalid-input.js
+++ b/test/parallel/test-url-format-invalid-input.js
@@ -10,7 +10,7 @@ const throwsObjsAndReportTypes = [
   false,
   0,
   function() {},
-  Symbol('foo')
+  Symbol('foo'),
 ];
 
 for (const urlObject of throwsObjsAndReportTypes) {
diff --git a/test/parallel/test-url-format-whatwg.js b/test/parallel/test-url-format-whatwg.js
index ab3d18bdc3aa25e4cdb5b81267dfea7c6eccd0b2..9c86a7ae2c6910def5c6392ce3f18bb119240d4e 100644
--- a/test/parallel/test-url-format-whatwg.js
+++ b/test/parallel/test-url-format-whatwg.js
@@ -6,7 +6,6 @@ if (!common.hasIntl)
 
 const assert = require('assert');
 const url = require('url');
-const URL = url.URL;
 
 const myURL = new URL('http://xn--lck1c3crb1723bpq4a.com/a?a=b#c');
 
diff --git a/test/parallel/test-url-format.js b/test/parallel/test-url-format.js
index 2d0132eb38a0bb97e8124c04ac6b2e35f951a057..720a10a97a979b87b3a80c1463dd6827fc7f43c9 100644
--- a/test/parallel/test-url-format.js
+++ b/test/parallel/test-url-format.js
@@ -148,6 +148,12 @@ const formatTests = {
     host: '[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:61616',
     pathname: '/s/stopButton'
   },
+  'http://[::]/': {
+    href: 'http://[::]/',
+    protocol: 'http:',
+    hostname: '[::]',
+    pathname: '/'
+  },
 
   // Encode context-specific delimiters in path and query, but do not touch
   // other non-delimiter chars like `%`.
diff --git a/test/parallel/test-url-parse-invalid-input.js b/test/parallel/test-url-parse-invalid-input.js
index ff63e91ecda2ab1880a4ca877848bfb9041488d3..55db598e04f808d8375df2e5e270e53320da8ebe 100644
--- a/test/parallel/test-url-parse-invalid-input.js
+++ b/test/parallel/test-url-parse-invalid-input.js
@@ -14,7 +14,7 @@ const url = require('url');
   [[], 'object'],
   [{}, 'object'],
   [() => {}, 'function'],
-  [Symbol('foo'), 'symbol']
+  [Symbol('foo'), 'symbol'],
 ].forEach(([val, type]) => {
   assert.throws(() => {
     url.parse(val);
diff --git a/test/parallel/test-url-pathtofileurl.js b/test/parallel/test-url-pathtofileurl.js
index 79adb58b77d754978d681c967c9b45f5252e2660..068a04e6613b282efbfa57aa2ef0e279bf466c8a 100644
--- a/test/parallel/test-url-pathtofileurl.js
+++ b/test/parallel/test-url-pathtofileurl.js
@@ -90,7 +90,7 @@ const url = require('url');
       // Rocket emoji (non-BMP code point)
       { path: 'C:\\🚀', expected: 'file:///C:/%F0%9F%9A%80' },
       // UNC path (see https://docs.microsoft.com/en-us/archive/blogs/ie/file-uris-in-windows)
-      { path: '\\\\nas\\My Docs\\File.doc', expected: 'file://nas/My%20Docs/File.doc' }
+      { path: '\\\\nas\\My Docs\\File.doc', expected: 'file://nas/My%20Docs/File.doc' },
     ];
   } else {
     testCases = [
diff --git a/test/parallel/test-url-relative.js b/test/parallel/test-url-relative.js
index d0c4b5f42c3e0cae73cfe11ca2582cc4565afff7..1eb2bdc58fc3a6eb5d7a129f3f0c3d880eb8e598 100644
--- a/test/parallel/test-url-relative.js
+++ b/test/parallel/test-url-relative.js
@@ -7,9 +7,7 @@ const url = require('url');
 // When source is false
 assert.strictEqual(url.resolveObject('', 'foo'), 'foo');
 
-/*
- [from, path, expected]
-*/
+// [from, path, expected]
 const relativeTests = [
   ['/foo/bar/baz', 'quux', '/foo/bar/quux'],
   ['/foo/bar/baz', 'quux/asdf', '/foo/bar/quux/asdf'],
@@ -54,7 +52,7 @@ const relativeTests = [
    'http://example.com/a/b/c/d'],
   ['/foo/bar/baz', '/../etc/passwd', '/etc/passwd'],
   ['http://localhost', 'file:///Users/foo', 'file:///Users/foo'],
-  ['http://localhost', 'file://foo/Users', 'file://foo/Users']
+  ['http://localhost', 'file://foo/Users', 'file://foo/Users'],
 ];
 relativeTests.forEach(function(relativeTest) {
   const a = url.resolve(relativeTest[0], relativeTest[1]);
@@ -78,7 +76,7 @@ const bases = [
   'http://a/b/c/d;p?q=1/2',
   'http://a/b/c/d;p=1/2?q',
   'fred:///s//a/b/c',
-  'http:///s//a/b/c'
+  'http:///s//a/b/c',
 ];
 
 // [to, from, result]
@@ -373,7 +371,7 @@ const relativeTests2 = [
    'https://user:password@example.com/foo'],
 
   // No path at all
-  ['#hash1', '#hash2', '#hash1']
+  ['#hash1', '#hash2', '#hash1'],
 ];
 relativeTests2.forEach(function(relativeTest) {
   const a = url.resolve(relativeTest[1], relativeTest[0]);
diff --git a/test/parallel/test-url-urltooptions.js b/test/parallel/test-url-urltooptions.js
new file mode 100644
index 0000000000000000000000000000000000000000..cc4838eeecb00f6a61c7587c3b55dac90dd6f7fd
--- /dev/null
+++ b/test/parallel/test-url-urltooptions.js
@@ -0,0 +1,37 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { urlToHttpOptions } = require('url');
+
+// Test urlToHttpOptions
+const urlObj = new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test');
+const opts = urlToHttpOptions(urlObj);
+assert.strictEqual(opts instanceof URL, false);
+assert.strictEqual(opts.protocol, 'http:');
+assert.strictEqual(opts.auth, 'user:pass');
+assert.strictEqual(opts.hostname, 'foo.bar.com');
+assert.strictEqual(opts.port, 21);
+assert.strictEqual(opts.path, '/aaa/zzz?l=24');
+assert.strictEqual(opts.pathname, '/aaa/zzz');
+assert.strictEqual(opts.search, '?l=24');
+assert.strictEqual(opts.hash, '#test');
+
+const { hostname } = urlToHttpOptions(new URL('http://[::1]:21'));
+assert.strictEqual(hostname, '::1');
+
+// If a WHATWG URL object is copied, it is possible that the resulting copy
+// contains the Symbols that Node uses for brand checking, but not the data
+// properties, which are getters. Verify that urlToHttpOptions() can handle
+// such a case.
+const copiedUrlObj = { ...urlObj };
+const copiedOpts = urlToHttpOptions(copiedUrlObj);
+assert.strictEqual(copiedOpts instanceof URL, false);
+assert.strictEqual(copiedOpts.protocol, undefined);
+assert.strictEqual(copiedOpts.auth, undefined);
+assert.strictEqual(copiedOpts.hostname, undefined);
+assert.strictEqual(copiedOpts.port, NaN);
+assert.strictEqual(copiedOpts.path, '');
+assert.strictEqual(copiedOpts.pathname, undefined);
+assert.strictEqual(copiedOpts.search, undefined);
+assert.strictEqual(copiedOpts.hash, undefined);
+assert.strictEqual(copiedOpts.href, undefined);
diff --git a/test/parallel/test-util-callbackify.js b/test/parallel/test-util-callbackify.js
index eb2b3a383b9a53309054378f2dcd9a7096b80933..444e10b16bf85af0d2b5777556c88b1d45fe0b9c 100644
--- a/test/parallel/test-util-callbackify.js
+++ b/test/parallel/test-util-callbackify.js
@@ -20,7 +20,7 @@ const values = [
   Symbol('I am a symbol'),
   function ok() {},
   ['array', 'with', 4, 'values'],
-  new Error('boo')
+  new Error('boo'),
 ];
 
 {
@@ -32,8 +32,7 @@ const values = [
     }
 
     const cbAsyncFn = callbackify(asyncFn);
-    cbAsyncFn(common.mustCall((err, ret) => {
-      assert.ifError(err);
+    cbAsyncFn(common.mustSucceed((ret) => {
       assert.strictEqual(ret, value);
     }));
 
@@ -43,8 +42,7 @@ const values = [
     }
 
     const cbPromiseFn = callbackify(promiseFn);
-    cbPromiseFn(common.mustCall((err, ret) => {
-      assert.ifError(err);
+    cbPromiseFn(common.mustSucceed((ret) => {
       assert.strictEqual(ret, value);
     }));
 
@@ -58,8 +56,7 @@ const values = [
     }
 
     const cbThenableFn = callbackify(thenableFn);
-    cbThenableFn(common.mustCall((err, ret) => {
-      assert.ifError(err);
+    cbThenableFn(common.mustSucceed((ret) => {
       assert.strictEqual(ret, value);
     }));
   }
@@ -162,8 +159,7 @@ const values = [
       Object.getPrototypeOf(asyncFn)
     );
     assert.strictEqual(Object.getPrototypeOf(cbAsyncFn), Function.prototype);
-    cbAsyncFn(value, common.mustCall((err, ret) => {
-      assert.ifError(err);
+    cbAsyncFn(value, common.mustSucceed((ret) => {
       assert.strictEqual(ret, value);
     }));
 
@@ -181,8 +177,7 @@ const values = [
 
     const cbPromiseFn = callbackify(promiseFn);
     assert.strictEqual(promiseFn.length, obj);
-    cbPromiseFn(value, common.mustCall((err, ret) => {
-      assert.ifError(err);
+    cbPromiseFn(value, common.mustSucceed((ret) => {
       assert.strictEqual(ret, value);
     }));
   }
@@ -198,8 +193,7 @@ const values = [
       },
     };
     iAmThis.cbFn = callbackify(iAmThis.fn);
-    iAmThis.cbFn(value, common.mustCall(function(err, ret) {
-      assert.ifError(err);
+    iAmThis.cbFn(value, common.mustSucceed(function(ret) {
       assert.strictEqual(ret, value);
       assert.strictEqual(this, iAmThis);
     }));
@@ -211,8 +205,7 @@ const values = [
       },
     };
     iAmThat.cbFn = callbackify(iAmThat.fn);
-    iAmThat.cbFn(value, common.mustCall(function(err, ret) {
-      assert.ifError(err);
+    iAmThat.cbFn(value, common.mustSucceed(function(ret) {
       assert.strictEqual(ret, value);
       assert.strictEqual(this, iAmThat);
     }));
@@ -242,8 +235,7 @@ const values = [
   execFile(
     process.execPath,
     [fixture],
-    common.mustCall((err, stdout, stderr) => {
-      assert.ifError(err);
+    common.mustSucceed((stdout, stderr) => {
       assert.strictEqual(
         stdout.trim(),
         `ifError got unwanted exception: ${fixture}`);
diff --git a/test/parallel/test-util-format.js b/test/parallel/test-util-format.js
index d1cb83b51d19864a6285e30866426aec4048a18f..3d6404076471dd4bb47a2dfcbecc04540f54e14b 100644
--- a/test/parallel/test-util-format.js
+++ b/test/parallel/test-util-format.js
@@ -263,10 +263,10 @@ assert.strictEqual(
   '{\n' +
   '  foo: \'bar\',\n' +
   '  foobar: 1,\n' +
-  '  func: [Function: func] {\n' +
+  '  func: <ref *1> [Function: func] {\n' +
   '    [length]: 0,\n' +
   '    [name]: \'func\',\n' +
-  '    [prototype]: func { [constructor]: [Circular] }\n' +
+  '    [prototype]: { [constructor]: [Circular *1] }\n' +
   '  }\n' +
   '}');
 assert.strictEqual(
@@ -276,10 +276,10 @@ assert.strictEqual(
   '  foobar: 1,\n' +
   '  func: [\n' +
   '    {\n' +
-  '      a: [Function: a] {\n' +
+  '      a: <ref *1> [Function: a] {\n' +
   '        [length]: 0,\n' +
   '        [name]: \'a\',\n' +
-  '        [prototype]: a { [constructor]: [Circular] }\n' +
+  '        [prototype]: { [constructor]: [Circular *1] }\n' +
   '      }\n' +
   '    },\n' +
   '    [length]: 1\n' +
@@ -291,10 +291,10 @@ assert.strictEqual(
   '  foo: \'bar\',\n' +
   '  foobar: {\n' +
   '    foo: \'bar\',\n' +
-  '    func: [Function: func] {\n' +
+  '    func: <ref *1> [Function: func] {\n' +
   '      [length]: 0,\n' +
   '      [name]: \'func\',\n' +
-  '      [prototype]: func { [constructor]: [Circular] }\n' +
+  '      [prototype]: { [constructor]: [Circular *1] }\n' +
   '    }\n' +
   '  }\n' +
   '}');
@@ -303,18 +303,18 @@ assert.strictEqual(
   '{\n' +
   '  foo: \'bar\',\n' +
   '  foobar: 1,\n' +
-  '  func: [Function: func] {\n' +
+  '  func: <ref *1> [Function: func] {\n' +
   '    [length]: 0,\n' +
   '    [name]: \'func\',\n' +
-  '    [prototype]: func { [constructor]: [Circular] }\n' +
+  '    [prototype]: { [constructor]: [Circular *1] }\n' +
   '  }\n' +
   '} {\n' +
   '  foo: \'bar\',\n' +
   '  foobar: 1,\n' +
-  '  func: [Function: func] {\n' +
+  '  func: <ref *1> [Function: func] {\n' +
   '    [length]: 0,\n' +
   '    [name]: \'func\',\n' +
-  '    [prototype]: func { [constructor]: [Circular] }\n' +
+  '    [prototype]: { [constructor]: [Circular *1] }\n' +
   '  }\n' +
   '}');
 assert.strictEqual(
@@ -322,10 +322,10 @@ assert.strictEqual(
   '{\n' +
   '  foo: \'bar\',\n' +
   '  foobar: 1,\n' +
-  '  func: [Function: func] {\n' +
+  '  func: <ref *1> [Function: func] {\n' +
   '    [length]: 0,\n' +
   '    [name]: \'func\',\n' +
-  '    [prototype]: func { [constructor]: [Circular] }\n' +
+  '    [prototype]: { [constructor]: [Circular *1] }\n' +
   '  }\n' +
   '} %o');
 
@@ -383,7 +383,7 @@ assert.strictEqual(util.format('abc%', 1), 'abc% 1');
 
 // Additional arguments after format specifiers
 assert.strictEqual(util.format('%i', 1, 'number'), '1 number');
-assert.strictEqual(util.format('%i', 1, () => {}), '1 [Function]');
+assert.strictEqual(util.format('%i', 1, () => {}), '1 [Function (anonymous)]');
 
 // %c from https://console.spec.whatwg.org/
 assert.strictEqual(util.format('%c'), '%c');
@@ -440,8 +440,8 @@ assert.strictEqual(util.format('1', '1'), '1 1');
 assert.strictEqual(util.format(1, '1'), '1 1');
 assert.strictEqual(util.format('1', 1), '1 1');
 assert.strictEqual(util.format(1, -0), '1 -0');
-assert.strictEqual(util.format('1', () => {}), '1 [Function]');
-assert.strictEqual(util.format(1, () => {}), '1 [Function]');
+assert.strictEqual(util.format('1', () => {}), '1 [Function (anonymous)]');
+assert.strictEqual(util.format(1, () => {}), '1 [Function (anonymous)]');
 assert.strictEqual(util.format('1', "'"), "1 '");
 assert.strictEqual(util.format(1, "'"), "1 '");
 assert.strictEqual(util.format('1', 'number'), '1 number');
@@ -476,3 +476,20 @@ assert.strictEqual(
   ),
   '[ 1, [Object] ]'
 );
+
+[
+  undefined,
+  null,
+  false,
+  5n,
+  5,
+  'test',
+  Symbol(),
+].forEach((invalidOptions) => {
+  assert.throws(() => {
+    util.formatWithOptions(invalidOptions, { a: true });
+  }, {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: /"inspectOptions".+object/
+  });
+});
diff --git a/test/parallel/test-util-inspect-getters-accessing-this.js b/test/parallel/test-util-inspect-getters-accessing-this.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d185b134e852d03311f57a9565c96eda1160383
--- /dev/null
+++ b/test/parallel/test-util-inspect-getters-accessing-this.js
@@ -0,0 +1,30 @@
+'use strict';
+
+require('../common');
+
+// This test ensures that util.inspect logs getters
+// which access this.
+
+const assert = require('assert');
+
+const util = require('util');
+
+class X {
+  constructor() {
+    this._y = 123;
+  }
+
+  get y() {
+    return this._y;
+  }
+}
+
+const result = util.inspect(new X(), {
+  getters: true,
+  showHidden: true
+});
+
+assert.strictEqual(
+  result,
+  'X { _y: 123, [y]: [Getter: 123] }'
+);
diff --git a/test/parallel/test-util-inspect-namespace.js b/test/parallel/test-util-inspect-namespace.js
index 89b26fcdbcf1b2340c987918c1544b089a14086f..951955fb7791e14b82cca1c709a91e087e201418 100644
--- a/test/parallel/test-util-inspect-namespace.js
+++ b/test/parallel/test-util-inspect-namespace.js
@@ -1,8 +1,6 @@
-'use strict';
-
 // Flags: --experimental-vm-modules
-
-require('../common');
+'use strict';
+const common = require('../common');
 const assert = require('assert');
 
 const { SourceTextModule } = require('vm');
@@ -13,7 +11,11 @@ const { inspect } = require('util');
   await m.link(() => 0);
   assert.strictEqual(
     inspect(m.namespace),
-    '[Module] { a: <uninitialized>, b: undefined }');
+    '[Module: null prototype] { a: <uninitialized>, b: undefined }'
+  );
   await m.evaluate();
-  assert.strictEqual(inspect(m.namespace), '[Module] { a: 1, b: 2 }');
-})();
+  assert.strictEqual(
+    inspect(m.namespace),
+    '[Module: null prototype] { a: 1, b: 2 }'
+  );
+})().then(common.mustCall());
diff --git a/test/parallel/test-util-inspect-proxy.js b/test/parallel/test-util-inspect-proxy.js
index f87ebecb8e7e7cd2f228406ba373b19c30b5aa91..3e1341fadfc9f9d1d7f3aa017da778e7f2ddf428 100644
--- a/test/parallel/test-util-inspect-proxy.js
+++ b/test/parallel/test-util-inspect-proxy.js
@@ -154,7 +154,7 @@ const proxy11 = new Proxy(() => {}, {
     return proxy11;
   }
 });
-const expected10 = '[Function]';
-const expected11 = '[Function]';
+const expected10 = '[Function (anonymous)]';
+const expected11 = '[Function (anonymous)]';
 assert.strictEqual(util.inspect(proxy10), expected10);
 assert.strictEqual(util.inspect(proxy11), expected11);
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index d63ad3a1440b11a5f437acbdc4671e7797bbba31..dbec153cf945e5513ddd05b8a7e947afd7a0bbae 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -36,19 +36,19 @@ assert.strictEqual(util.inspect(false), 'false');
 assert.strictEqual(util.inspect(''), "''");
 assert.strictEqual(util.inspect('hello'), "'hello'");
 assert.strictEqual(util.inspect(function abc() {}), '[Function: abc]');
-assert.strictEqual(util.inspect(() => {}), '[Function]');
+assert.strictEqual(util.inspect(() => {}), '[Function (anonymous)]');
 assert.strictEqual(
   util.inspect(async function() {}),
-  '[AsyncFunction]'
+  '[AsyncFunction (anonymous)]'
 );
-assert.strictEqual(util.inspect(async () => {}), '[AsyncFunction]');
+assert.strictEqual(util.inspect(async () => {}), '[AsyncFunction (anonymous)]');
 
 // Special function inspection.
 {
   const fn = (() => function*() {})();
   assert.strictEqual(
     util.inspect(fn),
-    '[GeneratorFunction]'
+    '[GeneratorFunction (anonymous)]'
   );
   assert.strictEqual(
     util.inspect(async function* abc() {}),
@@ -57,7 +57,7 @@ assert.strictEqual(util.inspect(async () => {}), '[AsyncFunction]');
   Object.setPrototypeOf(fn, Object.getPrototypeOf(async () => {}));
   assert.strictEqual(
     util.inspect(fn),
-    '[GeneratorFunction] AsyncFunction'
+    '[GeneratorFunction (anonymous)] AsyncFunction'
   );
   Object.defineProperty(fn, 'name', { value: 5, configurable: true });
   assert.strictEqual(
@@ -92,10 +92,11 @@ assert.strictEqual(
   new Date('2010-02-14T12:48:40+01:00').toISOString()
 );
 assert.strictEqual(util.inspect(new Date('')), (new Date('')).toString());
-assert.strictEqual(util.inspect('\n\u0001'), "'\\n\\u0001'");
+assert.strictEqual(util.inspect('\n\x01'), "'\\n\\x01'");
 assert.strictEqual(
-  util.inspect(`${Array(75).fill(1)}'\n\u001d\n\u0003`),
-  `"${Array(75).fill(1)}'\\n" +\n  '\\u001d\\n' +\n  '\\u0003'`
+  util.inspect(`${Array(75).fill(1)}'\n\x1d\n\x03\x85\x7f\x7e\x9f\xa0`),
+  // eslint-disable-next-line no-irregular-whitespace
+  `"${Array(75).fill(1)}'\\n" +\n  '\\x1D\\n' +\n  '\\x03\\x85\\x7F~\\x9F '`
 );
 assert.strictEqual(util.inspect([]), '[]');
 assert.strictEqual(util.inspect(Object.create([])), 'Array {}');
@@ -209,6 +210,17 @@ assert(!/Object/.test(
                      'ArrayBuffer { (detached), byteLength: 0 }');
 }
 
+// Truncate output for ArrayBuffers using plural or singular bytes
+{
+  const ab = new ArrayBuffer(3);
+  assert.strictEqual(util.inspect(ab, { showHidden: true, maxArrayLength: 2 }),
+                     'ArrayBuffer { [Uint8Contents]' +
+                      ': <00 00 ... 1 more byte>, byteLength: 3 }');
+  assert.strictEqual(util.inspect(ab, { showHidden: true, maxArrayLength: 1 }),
+                     'ArrayBuffer { [Uint8Contents]' +
+                      ': <00 ... 2 more bytes>, byteLength: 3 }');
+}
+
 // Now do the same checks but from a different context.
 {
   const showHidden = false;
@@ -359,7 +371,7 @@ assert.strictEqual(
 
   const value = {};
   value.a = value;
-  assert.strictEqual(util.inspect(value), '{ a: [Circular] }');
+  assert.strictEqual(util.inspect(value), '<ref *1> { a: [Circular *1] }');
   const getterFn = {
     get one() {
       return null;
@@ -483,7 +495,7 @@ assert.strictEqual(
                       'true,',
                       "'4294967296': true,",
                       "'4294967295': true,",
-                      "'4294967297': true\n]"
+                      "'4294967297': true\n]",
                      ].join('\n  '));
 }
 
@@ -500,7 +512,7 @@ assert.strictEqual(
   value.aprop = 42;
   assert.strictEqual(
     util.inspect(value),
-    '[Function] { aprop: 42 }'
+    '[Function (anonymous)] { aprop: 42 }'
   );
 }
 
@@ -582,10 +594,10 @@ assert.strictEqual(util.inspect(-5e-324), '-5e-324');
 {
   let obj = vm.runInNewContext('(function(){return {}})()', {});
   assert.strictEqual(util.inspect(obj), '{}');
-  obj = vm.runInNewContext('var m=new Map();m.set(1,2);m', {});
-  assert.strictEqual(util.inspect(obj), 'Map { 1 => 2 }');
-  obj = vm.runInNewContext('var s=new Set();s.add(1);s.add(2);s', {});
-  assert.strictEqual(util.inspect(obj), 'Set { 1, 2 }');
+  obj = vm.runInNewContext('const m=new Map();m.set(1,2);m', {});
+  assert.strictEqual(util.inspect(obj), 'Map(1) { 1 => 2 }');
+  obj = vm.runInNewContext('const s=new Set();s.add(1);s.add(2);s', {});
+  assert.strictEqual(util.inspect(obj), 'Set(2) { 1, 2 }');
   obj = vm.runInNewContext('fn=function(){};new Promise(fn,fn)', {});
   assert.strictEqual(util.inspect(obj), 'Promise { <pending> }');
 }
@@ -628,7 +640,7 @@ assert.strictEqual(util.inspect(-5e-324), '-5e-324');
     new Error(),
     new Error('FAIL'),
     new TypeError('FAIL'),
-    new SyntaxError('FAIL')
+    new SyntaxError('FAIL'),
   ].forEach((err) => {
     assert.strictEqual(util.inspect(err), err.stack);
   });
@@ -1096,13 +1108,13 @@ if (typeof Symbol !== 'undefined') {
 
 // Test Set.
 {
-  assert.strictEqual(util.inspect(new Set()), 'Set {}');
-  assert.strictEqual(util.inspect(new Set([1, 2, 3])), 'Set { 1, 2, 3 }');
+  assert.strictEqual(util.inspect(new Set()), 'Set(0) {}');
+  assert.strictEqual(util.inspect(new Set([1, 2, 3])), 'Set(3) { 1, 2, 3 }');
   const set = new Set(['foo']);
   set.bar = 42;
   assert.strictEqual(
     util.inspect(set, { showHidden: true }),
-    "Set { 'foo', [size]: 1, bar: 42 }"
+    "Set(1) { 'foo', bar: 42 }"
   );
 }
 
@@ -1110,33 +1122,39 @@ if (typeof Symbol !== 'undefined') {
 {
   const set = new Set();
   set.add(set);
-  assert.strictEqual(util.inspect(set), 'Set { [Circular] }');
+  assert.strictEqual(util.inspect(set), '<ref *1> Set(1) { [Circular *1] }');
 }
 
 // Test Map.
 {
-  assert.strictEqual(util.inspect(new Map()), 'Map {}');
+  assert.strictEqual(util.inspect(new Map()), 'Map(0) {}');
   assert.strictEqual(util.inspect(new Map([[1, 'a'], [2, 'b'], [3, 'c']])),
-                     "Map { 1 => 'a', 2 => 'b', 3 => 'c' }");
+                     "Map(3) { 1 => 'a', 2 => 'b', 3 => 'c' }");
   const map = new Map([['foo', null]]);
   map.bar = 42;
   assert.strictEqual(util.inspect(map, true),
-                     "Map { 'foo' => null, [size]: 1, bar: 42 }");
+                     "Map(1) { 'foo' => null, bar: 42 }");
 }
 
 // Test circular Map.
 {
   const map = new Map();
   map.set(map, 'map');
-  assert.strictEqual(inspect(map), "Map { [Circular] => 'map' }");
+  assert.strictEqual(
+    inspect(map),
+    "<ref *1> Map(1) { [Circular *1] => 'map' }"
+  );
   map.set(map, map);
   assert.strictEqual(
     inspect(map),
-    'Map { [Circular] => [Circular] }'
+    '<ref *1> Map(1) { [Circular *1] => [Circular *1] }'
   );
   map.delete(map);
   map.set('map', map);
-  assert.strictEqual(inspect(map), "Map { 'map' => [Circular] }");
+  assert.strictEqual(
+    inspect(map),
+    "<ref *1> Map(1) { 'map' => [Circular *1] }"
+  );
 }
 
 // Test multiple circular references.
@@ -1149,7 +1167,10 @@ if (typeof Symbol !== 'undefined') {
 
   assert.strictEqual(
     inspect(obj),
-    '{ a: [ [Circular] ], b: { inner: [Circular], obj: [Circular] } }'
+    '<ref *1> {\n' +
+    '  a: [ [Circular *1] ],\n' +
+    '  b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }\n' +
+    '}'
   );
 }
 
@@ -1299,10 +1320,10 @@ if (typeof Symbol !== 'undefined') {
   });
 
   checkAlignment(obj, '{', "  'X': null", '}');
-  checkAlignment(new Set(bigArray), 'Set {', '  X', '}');
+  checkAlignment(new Set(bigArray), 'Set(100) {', '  X', '}');
   checkAlignment(
     new Map(bigArray.map((number) => [number, null])),
-    'Map {', '  X => null', '}'
+    'Map(100) {', '  X => null', '}'
   );
 }
 
@@ -1322,9 +1343,9 @@ if (typeof Symbol !== 'undefined') {
   assert.strictEqual(util.inspect(new ArraySubclass(1, 2, 3)),
                      'ArraySubclass(3) [ 1, 2, 3 ]');
   assert.strictEqual(util.inspect(new SetSubclass([1, 2, 3])),
-                     'SetSubclass [Set] { 1, 2, 3 }');
+                     'SetSubclass(3) [Set] { 1, 2, 3 }');
   assert.strictEqual(util.inspect(new MapSubclass([['foo', 42]])),
-                     "MapSubclass [Map] { 'foo' => 42 }");
+                     "MapSubclass(1) [Map] { 'foo' => 42 }");
   assert.strictEqual(util.inspect(new PromiseSubclass(() => {})),
                      'PromiseSubclass [Promise] { <pending> }');
   assert.strictEqual(
@@ -1348,9 +1369,9 @@ if (typeof Symbol !== 'undefined') {
   arr[0][0][0] = { a: 2 };
   assert.strictEqual(util.inspect(arr), '[ [ [ [Object] ] ] ]');
   arr[0][0][0] = arr;
-  assert.strictEqual(util.inspect(arr), '[ [ [ [Circular] ] ] ]');
+  assert.strictEqual(util.inspect(arr), '<ref *1> [ [ [ [Circular *1] ] ] ]');
   arr[0][0][0] = arr[0][0];
-  assert.strictEqual(util.inspect(arr), '[ [ [ [Circular] ] ] ]');
+  assert.strictEqual(util.inspect(arr), '[ [ <ref *1> [ [Circular *1] ] ] ]');
 }
 
 // Corner cases.
@@ -1583,7 +1604,7 @@ util.inspect(process);
     "         'test',",
     "         'foo' ] ],",
     '     4 ],',
-    "  b: Map { 'za' => 1, 'zb' => 'test' } }",
+    "  b: Map(2) { 'za' => 1, 'zb' => 'test' } }",
   ].join('\n');
   assert.strictEqual(out, expect);
 
@@ -1604,11 +1625,11 @@ util.inspect(process);
     '    ],',
     '    4',
     '  ],',
-    '  b: Map {',
+    '  b: Map(2) {',
     "    'za' => 1,",
     "    'zb' => 'test'",
     '  }',
-    '}'
+    '}',
   ].join('\n');
   assert.strictEqual(out, expect);
 
@@ -1616,7 +1637,7 @@ util.inspect(process);
   expect = [
     "'Lorem ipsum dolor\\n' +",
     "  'sit amet,\\tconsectetur adipiscing elit, sed do eiusmod tempor " +
-      "incididunt ut labore et dolore magna aliqua.'"
+      "incididunt ut labore et dolore magna aliqua.'",
   ].join('\n');
   assert.strictEqual(out, expect);
 
@@ -1630,7 +1651,7 @@ util.inspect(process);
     '12 45 78 01 34 67 90 23 56 89 123456789012345678901234567890',
     { compact: false, breakLength: 3 });
   expect = [
-    "'12 45 78 01 34 67 90 23 56 89 123456789012345678901234567890'"
+    "'12 45 78 01 34 67 90 23 56 89 123456789012345678901234567890'",
   ].join('\n');
   assert.strictEqual(out, expect);
 
@@ -1639,21 +1660,21 @@ util.inspect(process);
   out = util.inspect(o, { compact: false, breakLength: 3 });
   expect = [
     '{',
-    '  a: [Function],',
+    '  a: [Function (anonymous)],',
     '  b: [Number: 3]',
-    '}'
+    '}',
   ].join('\n');
   assert.strictEqual(out, expect);
 
   out = util.inspect(o, { compact: false, breakLength: 3, showHidden: true });
   expect = [
     '{',
-    '  a: [Function] {',
+    '  a: [Function (anonymous)] {',
     '    [length]: 0,',
     "    [name]: ''",
     '  },',
     '  b: [Number: 3]',
-    '}'
+    '}',
   ].join('\n');
   assert.strictEqual(out, expect);
 
@@ -1684,18 +1705,17 @@ util.inspect(process);
 
   let out = util.inspect(map, { compact: false, showHidden: true, depth: 9 });
   let expected = [
-    'Map {',
+    'Map(2) {',
     '  Promise {',
     '    [',
     '      [',
     '        1,',
-    '        Set {',
+    '        Set(1) {',
     '          [',
     '            1,',
     '            2,',
     '            [length]: 2',
-    '          ],',
-    '          [size]: 1',
+    '          ]',
     '        },',
     '        [length]: 2',
     '      ],',
@@ -1718,7 +1738,7 @@ util.inspect(process);
     '      [length]: 2',
     '    ],',
     "    [Symbol(Symbol.toStringTag)]: 'Set Iterator'",
-    '  } => [Map Iterator] {',
+    '  } => <ref *1> [Map Iterator] {',
     '    Uint8Array(0) [',
     '      [BYTES_PER_ELEMENT]: 1,',
     '      [length]: 0,',
@@ -1729,11 +1749,10 @@ util.inspect(process);
     '        foo: true',
     '      }',
     '    ],',
-    '    [Circular],',
+    '    [Circular *1],',
     "    [Symbol(Symbol.toStringTag)]: 'Map Iterator'",
-    '  },',
-    '  [size]: 2',
-    '}'
+    '  }',
+    '}',
   ].join('\n');
 
   assert.strict.equal(out, expected);
@@ -1741,12 +1760,12 @@ util.inspect(process);
   out = util.inspect(map, { compact: 2, showHidden: true, depth: 9 });
 
   expected = [
-    'Map {',
+    'Map(2) {',
     '  Promise {',
     '    [',
     '      [',
     '        1,',
-    '        Set { [ 1, 2, [length]: 2 ], [size]: 1 },',
+    '        Set(1) { [ 1, 2, [length]: 2 ] },',
     '        [length]: 2',
     '      ],',
     '      [length]: 1',
@@ -1761,7 +1780,7 @@ util.inspect(process);
     '  [Set Iterator] {',
     '    [ 1, 2, [length]: 2 ],',
     "    [Symbol(Symbol.toStringTag)]: 'Set Iterator'",
-    '  } => [Map Iterator] {',
+    '  } => <ref *1> [Map Iterator] {',
     '    Uint8Array(0) [',
     '      [BYTES_PER_ELEMENT]: 1,',
     '      [length]: 0,',
@@ -1769,11 +1788,10 @@ util.inspect(process);
     '      [byteOffset]: 0,',
     '      [buffer]: ArrayBuffer { byteLength: 0, foo: true }',
     '    ],',
-    '    [Circular],',
+    '    [Circular *1],',
     "    [Symbol(Symbol.toStringTag)]: 'Map Iterator'",
-    '  },',
-    '  [size]: 2',
-    '}'
+    '  }',
+    '}',
   ].join('\n');
 
   assert.strict.equal(out, expected);
@@ -1782,14 +1800,13 @@ util.inspect(process);
     showHidden: true, depth: 9, breakLength: 4, compact: true
   });
   expected = [
-    'Map {',
+    'Map(2) {',
     '  Promise {',
     '    [ [ 1,',
-    '        Set {',
+    '        Set(1) {',
     '          [ 1,',
     '            2,',
-    '            [length]: 2 ],',
-    '          [size]: 1 },',
+    '            [length]: 2 ] },',
     '        [length]: 2 ],',
     '      [length]: 1 ] } => Uint8Array(0) [',
     '    [BYTES_PER_ELEMENT]: 1,',
@@ -1804,7 +1821,7 @@ util.inspect(process);
     '      2,',
     '      [length]: 2 ],',
     '    [Symbol(Symbol.toStringTag)]:',
-    "     'Set Iterator' } => [Map Iterator] {",
+    "     'Set Iterator' } => <ref *1> [Map Iterator] {",
     '    Uint8Array(0) [',
     '      [BYTES_PER_ELEMENT]: 1,',
     '      [length]: 0,',
@@ -1813,10 +1830,9 @@ util.inspect(process);
     '      [buffer]: ArrayBuffer {',
     '        byteLength: 0,',
     '        foo: true } ],',
-    '    [Circular],',
+    '    [Circular *1],',
     '    [Symbol(Symbol.toStringTag)]:',
-    "     'Map Iterator' },",
-    '  [size]: 2 }'
+    "     'Map Iterator' } }",
   ].join('\n');
 
   assert.strict.equal(out, expected);
@@ -1914,7 +1930,7 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
     get name() {
       return 'BazError';
     }
-  }, undefined]
+  }, undefined],
 ].forEach(([Class, message], i) => {
   console.log('Test %i', i);
   const foo = new Class(message);
@@ -1984,7 +2000,7 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
   // Foobar !!!
   [class X   extends /****/ Error
   // More comments
-  {}, '[class X extends Error]']
+  {}, '[class X extends Error]'],
   /* eslint-enable spaced-comment, no-multi-spaces, brace-style */
 ].forEach(([clazz, string]) => {
   const inspected = util.inspect(clazz);
@@ -2006,6 +2022,11 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
     rest[rest.length - 1] = rest[rest.length - 1].slice(0, -1);
     rest.length = 1;
   }
+  Object.setPrototypeOf(clazz, Map.prototype);
+  assert.strictEqual(
+    util.inspect(clazz),
+    ['[class', name, '[Map]', ...rest].join(' ') + ']'
+  );
   Object.setPrototypeOf(clazz, null);
   assert.strictEqual(
     util.inspect(clazz),
@@ -2057,13 +2078,13 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
   [new Number(55), '[Number: 55]'],
   [Object(BigInt(55)), '[BigInt: 55n]'],
   [Object(Symbol('foo')), '[Symbol: Symbol(foo)]'],
-  [function() {}, '[Function]'],
-  [() => {}, '[Function]'],
+  [function() {}, '[Function (anonymous)]'],
+  [() => {}, '[Function (anonymous)]'],
   [[1, 2], '[ 1, 2 ]'],
   [[, , 5, , , , ], '[ <2 empty items>, 5, <3 empty items> ]'],
   [{ a: 5 }, '{ a: 5 }'],
-  [new Set([1, 2]), 'Set { 1, 2 }'],
-  [new Map([[1, 2]]), 'Map { 1 => 2 }'],
+  [new Set([1, 2]), 'Set(2) { 1, 2 }'],
+  [new Map([[1, 2]]), 'Map(1) { 1 => 2 }'],
   [new Set([1, 2]).entries(), '[Set Entries] { [ 1, 1 ], [ 2, 2 ] }'],
   [new Map([[1, 2]]).keys(), '[Map Iterator] { 1 }'],
   [new Date(2000), '1970-01-01T00:00:02.000Z'],
@@ -2071,7 +2092,7 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
   [new Promise((resolve) => setTimeout(resolve, 10)), 'Promise { <pending> }'],
   [new WeakSet(), 'WeakSet { <items unknown> }'],
   [new WeakMap(), 'WeakMap { <items unknown> }'],
-  [/foobar/g, '/foobar/g']
+  [/foobar/g, '/foobar/g'],
 ].forEach(([value, expected]) => {
   Object.defineProperty(value, 'valueOf', {
     get() {
@@ -2094,8 +2115,8 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
 // Verify that having no prototype still produces nice results.
 [
   [[1, 3, 4], '[Array(3): null prototype] [ 1, 3, 4 ]'],
-  [new Set([1, 2]), '[Set: null prototype] { 1, 2 }'],
-  [new Map([[1, 2]]), '[Map: null prototype] { 1 => 2 }'],
+  [new Set([1, 2]), '[Set(2): null prototype] { 1, 2 }'],
+  [new Map([[1, 2]]), '[Map(1): null prototype] { 1 => 2 }'],
   [new Promise((resolve) => setTimeout(resolve, 10)),
    '[Promise: null prototype] { <pending> }'],
   [new WeakSet(), '[WeakSet: null prototype] { <items unknown> }'],
@@ -2120,7 +2141,7 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
      '{\n  [Uint8Contents]: <00 00>,\n  byteLength: undefined\n}'],
   [/foobar/, '[RegExp: null prototype] /foobar/'],
   [new Date('Sun, 14 Feb 2010 11:48:40 GMT'),
-   '[Date: null prototype] 2010-02-14T11:48:40.000Z']
+   '[Date: null prototype] 2010-02-14T11:48:40.000Z'],
 ].forEach(([value, expected]) => {
   assert.strictEqual(
     util.inspect(Object.setPrototypeOf(value, null)),
@@ -2142,7 +2163,7 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
    [10],
    '[\n  0n, 0n, 0n, 0n, 0n,\n  0n, 0n, 0n, 0n, 0n\n]'],
   [Date, ['Sun, 14 Feb 2010 11:48:40 GMT'], '2010-02-14T11:48:40.000Z'],
-  [Date, ['invalid_date'], 'Invalid Date']
+  [Date, ['invalid_date'], 'Invalid Date'],
 ].forEach(([base, input, rawExpected]) => {
   class Foo extends base {}
   const value = new Foo(...input);
@@ -2232,7 +2253,7 @@ assert.strictEqual(
     'blue',
     'magenta',
     'cyan',
-    'white'
+    'white',
   ].forEach((color, i) => {
     assert.deepStrictEqual(inspect.colors[color], [30 + i, 39]);
     assert.deepStrictEqual(inspect.colors[`${color}Bright`], [90 + i, 39]);
@@ -2286,11 +2307,11 @@ assert.strictEqual(
   Object.setPrototypeOf(obj, value);
   assert.strictEqual(
     util.inspect(obj),
-    'Object <[Function (null prototype)]> { a: true }'
+    'Object <[Function (null prototype) (anonymous)]> { a: true }'
   );
   assert.strictEqual(
     util.inspect(obj, { colors: true }),
-    'Object <\u001b[36m[Function (null prototype)]\u001b[39m> ' +
+    'Object <\u001b[36m[Function (null prototype) (anonymous)]\u001b[39m> ' +
       '{ a: \u001b[33mtrue\u001b[39m }'
   );
 
@@ -2345,7 +2366,7 @@ assert.strictEqual(
     value: iterator,
     configurable: true
   });
-  assert.strictEqual(util.inspect(obj), '[Set: null prototype] { 1, 2 }');
+  assert.strictEqual(util.inspect(obj), '[Set(2): null prototype] { 1, 2 }');
   Object.defineProperty(obj, Symbol.iterator, {
     value: true,
     configurable: true
@@ -2357,7 +2378,7 @@ assert.strictEqual(
   });
   assert.strictEqual(
     util.inspect(obj),
-    '[Set: null prototype] { 1, 2, size: NaN }'
+    '[Set(2): null prototype] { 1, 2, size: NaN }'
   );
 }
 
@@ -2390,7 +2411,7 @@ assert.strictEqual(
   getset.foo = new Set([[{ a: true }, 2, {}], 'foobar', { x: 1 }]);
   assert.strictEqual(
     inspect(getset, { getters: true }),
-    '{\n  foo: [Getter/Setter] Set { [ [Object], 2, {} ], ' +
+    '{\n  foo: [Getter/Setter] Set(3) { [ [Object], 2, {} ], ' +
       "'foobar', { x: 1 } },\n  inc: [Getter: NaN]\n}");
 }
 
@@ -2410,7 +2431,7 @@ assert.strictEqual(
     b: [
       1,
       2,
-      [ 1, 2, { a: 1, b: 2, c: 3 } ]
+      [ 1, 2, { a: 1, b: 2, c: 3 } ],
     ],
     c: ['foo', 4, 444444],
     d: Array.from({ length: 101 }).map((e, i) => {
@@ -2502,7 +2523,7 @@ assert.strictEqual(
     "    'This text is too long for grouping!',",
     "    'This text is too long for grouping!'",
     '  ]',
-    '}'
+    '}',
   ].join('\n');
 
   assert.strictEqual(out, expected);
@@ -2510,7 +2531,7 @@ assert.strictEqual(
   obj = [
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 123456789
+    1, 1, 1, 1, 1, 1, 123456789,
   ];
 
   out = util.inspect(obj, { compact: 3 });
@@ -2524,7 +2545,7 @@ assert.strictEqual(
     '  1, 1,         1, 1,',
     '  1, 1,         1, 1,',
     '  1, 1, 123456789',
-    ']'
+    ']',
   ].join('\n');
 
   assert.strictEqual(out, expected);
@@ -2532,7 +2553,7 @@ assert.strictEqual(
   // Unicode support. あ has a length of one and a width of two.
   obj = [
     '123', '123', '123', '123', 'あああ',
-    '123', '123', '123', '123', 'あああ'
+    '123', '123', '123', '123', 'あああ',
   ];
 
   out = util.inspect(obj, { compact: 3 });
@@ -2606,7 +2627,7 @@ assert.strictEqual(
     '  \u001b[33m52\u001b[39m, \u001b[33m53\u001b[39m, \u001b[33m54\u001b[39m, \u001b[33m55\u001b[39m,',
     '  \u001b[33m56\u001b[39m, \u001b[33m57\u001b[39m, \u001b[33m58\u001b[39m, \u001b[33m59\u001b[39m',
     /* eslint-enable max-len */
-    ']'
+    ']',
   ].join('\n');
 
   assert.strictEqual(out, expected);
@@ -2638,24 +2659,23 @@ assert.strictEqual(
     'unescape', 'eval', 'isFinite',
     'isNaN', 'SharedArrayBuffer', 'Atomics',
     'globalThis', 'WebAssembly', 'global',
-    'process', 'GLOBAL', 'root',
-    'Buffer', 'URL', 'URLSearchParams',
-    'TextEncoder', 'TextDecoder', 'clearInterval',
-    'clearTimeout', 'setInterval', 'setTimeout',
-    'queueMicrotask', 'clearImmediate', 'setImmediate',
-    'module', 'require', 'assert',
-    'async_hooks', 'buffer', 'child_process',
-    'cluster', 'crypto', 'dgram',
-    'dns', 'domain', 'events',
-    'fs', 'http', 'http2',
-    'https', 'inspector', 'net',
-    'os', 'path', 'perf_hooks',
-    'punycode', 'querystring', 'readline',
-    'repl', 'stream', 'string_decoder',
-    'tls', 'trace_events', 'tty',
-    'url', 'v8', 'vm',
-    'worker_threads', 'zlib', '_',
-    '_error', 'util'
+    'process', 'Buffer', 'URL',
+    'URLSearchParams', 'TextEncoder', 'TextDecoder',
+    'clearInterval', 'clearTimeout', 'setInterval',
+    'setTimeout', 'queueMicrotask', 'clearImmediate',
+    'setImmediate', 'module', 'require',
+    'assert', 'async_hooks', 'buffer',
+    'child_process', 'cluster', 'crypto',
+    'dgram', 'dns', 'domain',
+    'events', 'fs', 'http',
+    'http2', 'https', 'inspector',
+    'net', 'os', 'path',
+    'perf_hooks', 'punycode', 'querystring',
+    'readline', 'repl', 'stream',
+    'string_decoder', 'tls', 'trace_events',
+    'tty', 'url', 'v8',
+    'vm', 'worker_threads', 'zlib',
+    '_', '_error', 'util',
   ];
 
   out = util.inspect(
@@ -2664,45 +2684,44 @@ assert.strictEqual(
   );
   expected = [
     '[',
-    "  'Object',         'Function',           'Array',",
-    "  'Number',         'parseFloat',         'parseInt',",
-    "  'Infinity',       'NaN',                'undefined',",
-    "  'Boolean',        'String',             'Symbol',",
-    "  'Date',           'Promise',            'RegExp',",
-    "  'Error',          'EvalError',          'RangeError',",
-    "  'ReferenceError', 'SyntaxError',        'TypeError',",
-    "  'URIError',       'JSON',               'Math',",
-    "  'console',        'Intl',               'ArrayBuffer',",
-    "  'Uint8Array',     'Int8Array',          'Uint16Array',",
-    "  'Int16Array',     'Uint32Array',        'Int32Array',",
-    "  'Float32Array',   'Float64Array',       'Uint8ClampedArray',",
-    "  'BigUint64Array', 'BigInt64Array',      'DataView',",
-    "  'Map',            'BigInt',             'Set',",
-    "  'WeakMap',        'WeakSet',            'Proxy',",
-    "  'Reflect',        'decodeURI',          'decodeURIComponent',",
-    "  'encodeURI',      'encodeURIComponent', 'escape',",
-    "  'unescape',       'eval',               'isFinite',",
-    "  'isNaN',          'SharedArrayBuffer',  'Atomics',",
-    "  'globalThis',     'WebAssembly',        'global',",
-    "  'process',        'GLOBAL',             'root',",
-    "  'Buffer',         'URL',                'URLSearchParams',",
-    "  'TextEncoder',    'TextDecoder',        'clearInterval',",
-    "  'clearTimeout',   'setInterval',        'setTimeout',",
-    "  'queueMicrotask', 'clearImmediate',     'setImmediate',",
-    "  'module',         'require',            'assert',",
-    "  'async_hooks',    'buffer',             'child_process',",
-    "  'cluster',        'crypto',             'dgram',",
-    "  'dns',            'domain',             'events',",
-    "  'fs',             'http',               'http2',",
-    "  'https',          'inspector',          'net',",
-    "  'os',             'path',               'perf_hooks',",
-    "  'punycode',       'querystring',        'readline',",
-    "  'repl',           'stream',             'string_decoder',",
-    "  'tls',            'trace_events',       'tty',",
-    "  'url',            'v8',                 'vm',",
-    "  'worker_threads', 'zlib',               '_',",
-    "  '_error',         'util'",
-    ']'
+    "  'Object',          'Function',           'Array',",
+    "  'Number',          'parseFloat',         'parseInt',",
+    "  'Infinity',        'NaN',                'undefined',",
+    "  'Boolean',         'String',             'Symbol',",
+    "  'Date',            'Promise',            'RegExp',",
+    "  'Error',           'EvalError',          'RangeError',",
+    "  'ReferenceError',  'SyntaxError',        'TypeError',",
+    "  'URIError',        'JSON',               'Math',",
+    "  'console',         'Intl',               'ArrayBuffer',",
+    "  'Uint8Array',      'Int8Array',          'Uint16Array',",
+    "  'Int16Array',      'Uint32Array',        'Int32Array',",
+    "  'Float32Array',    'Float64Array',       'Uint8ClampedArray',",
+    "  'BigUint64Array',  'BigInt64Array',      'DataView',",
+    "  'Map',             'BigInt',             'Set',",
+    "  'WeakMap',         'WeakSet',            'Proxy',",
+    "  'Reflect',         'decodeURI',          'decodeURIComponent',",
+    "  'encodeURI',       'encodeURIComponent', 'escape',",
+    "  'unescape',        'eval',               'isFinite',",
+    "  'isNaN',           'SharedArrayBuffer',  'Atomics',",
+    "  'globalThis',      'WebAssembly',        'global',",
+    "  'process',         'Buffer',             'URL',",
+    "  'URLSearchParams', 'TextEncoder',        'TextDecoder',",
+    "  'clearInterval',   'clearTimeout',       'setInterval',",
+    "  'setTimeout',      'queueMicrotask',     'clearImmediate',",
+    "  'setImmediate',    'module',             'require',",
+    "  'assert',          'async_hooks',        'buffer',",
+    "  'child_process',   'cluster',            'crypto',",
+    "  'dgram',           'dns',                'domain',",
+    "  'events',          'fs',                 'http',",
+    "  'http2',           'https',              'inspector',",
+    "  'net',             'os',                 'path',",
+    "  'perf_hooks',      'punycode',           'querystring',",
+    "  'readline',        'repl',               'stream',",
+    "  'string_decoder',  'tls',                'trace_events',",
+    "  'tty',             'url',                'v8',",
+    "  'vm',              'worker_threads',     'zlib',",
+    "  '_',               '_error',             'util'",
+    ']',
   ].join('\n');
 
   assert.strictEqual(out, expected);
@@ -2722,10 +2741,10 @@ assert.strictEqual(
     '    at Module.require [as weird/name] (internal/aaaaaa/loader.js:735:19)',
     '    at require (internal/modules/cjs/helpers.js:14:16)',
     '    at /test/test-util-inspect.js:2239:9',
-    '    at getActual (assert.js:592:5)'
+    '    at getActual (assert.js:592:5)',
   ];
   const isNodeCoreFile = [
-    false, false, true, true, false, true, false, true, false, true
+    false, false, true, true, false, true, false, true, false, true,
   ];
   const err = new TypeError('Wonderful message!');
   err.stack = stack.join('\n');
@@ -2801,12 +2820,11 @@ assert.strictEqual(
 
   assert.strictEqual(
     inspect(bar),
-    'Bar [Map] { prop: true, prop2: true, abc: true }'
+    'Bar(0) [Map] { prop: true, prop2: true, abc: true }'
   );
   assert.strictEqual(
     inspect(bar, { showHidden: true, getters: true, colors: false }),
-    'Bar [Map] {\n' +
-    '  [size]: 0,\n' +
+    'Bar(0) [Map] {\n' +
     '  prop: true,\n' +
     '  prop2: true,\n' +
     '  abc: true,\n' +
@@ -2816,8 +2834,7 @@ assert.strictEqual(
   );
   assert.strictEqual(
     inspect(bar, { showHidden: true, getters: false, colors: true }),
-    'Bar [Map] {\n' +
-    '  [size]: \x1B[33m0\x1B[39m,\n' +
+    'Bar(0) [Map] {\n' +
     '  prop: \x1B[33mtrue\x1B[39m,\n' +
     '  prop2: \x1B[33mtrue\x1B[39m,\n' +
     '  abc: \x1B[33mtrue\x1B[39m,\n' +
@@ -2832,6 +2849,48 @@ assert.strictEqual(
     '{ \x1B[2mabc: \x1B[33mtrue\x1B[39m\x1B[22m, ' +
       '\x1B[2mdef: \x1B[33m5\x1B[39m\x1B[22m }'
   );
+
+  assert.strictEqual(
+    inspect(Object.getPrototypeOf(bar), { showHidden: true, getters: true }),
+    '<ref *1> Foo [Map] {\n' +
+    '    [constructor]: [class Bar extends Foo] {\n' +
+    '      [length]: 0,\n' +
+    '      [prototype]: [Circular *1],\n' +
+    "      [name]: 'Bar',\n" +
+    '      [Symbol(Symbol.species)]: [Getter: <Inspection threw ' +
+      "(Symbol.prototype.toString requires that 'this' be a Symbol)>]\n" +
+    '    },\n' +
+    "    [xyz]: [Getter: 'YES!'],\n" +
+    '    [Symbol(nodejs.util.inspect.custom)]: ' +
+      '[Function: [nodejs.util.inspect.custom]] {\n' +
+    '      [length]: 0,\n' +
+    "      [name]: '[nodejs.util.inspect.custom]'\n" +
+    '    },\n' +
+    '    [abc]: [Getter: true],\n' +
+    '    [def]: [Getter/Setter: false]\n' +
+    '  }'
+  );
+
+  assert.strictEqual(
+    inspect(Object.getPrototypeOf(bar)),
+    'Foo [Map] {}'
+  );
+
+  assert.strictEqual(
+    inspect(Object.getPrototypeOf(new Foo())),
+    'Map {}'
+  );
+}
+
+// Check that prototypes with a null prototype are inspectable.
+// Regression test for https://github.com/nodejs/node/issues/35730
+{
+  function Func() {}
+  Func.prototype = null;
+  const object = {};
+  object.constructor = Func;
+
+  assert.strictEqual(util.inspect(object), '{ constructor: [Function: Func] }');
 }
 
 // Test changing util.inspect.colors colors and aliases.
@@ -2867,12 +2926,19 @@ assert.strictEqual(
   assert.strictEqual(inspect(undetectable), '{}');
 }
 
+// Truncate output for Primitives with 1 character left
+{
+  assert.strictEqual(util.inspect('bl', { maxStringLength: 1 }),
+                     "'b'... 1 more character");
+}
+
 {
   const x = 'a'.repeat(1e6);
   assert.strictEqual(
     util.inspect(x, { maxStringLength: 4 }),
     "'aaaa'... 999996 more characters"
   );
+  assert.match(util.inspect(x, { maxStringLength: null }), /a'$/);
 }
 
 {
@@ -2957,3 +3023,81 @@ assert.strictEqual(
   // Consistency check.
   assert(fullObjectGraph(global).has(Function.prototype));
 }
+
+{
+  // Confirm that own constructor value displays correctly.
+
+  function Fhqwhgads() {}
+
+  const sterrance = new Fhqwhgads();
+  sterrance.constructor = Fhqwhgads;
+
+  assert.strictEqual(
+    util.inspect(sterrance, { showHidden: true }),
+    'Fhqwhgads {\n' +
+      '  constructor: <ref *1> [Function: Fhqwhgads] {\n' +
+      '    [length]: 0,\n' +
+      "    [name]: 'Fhqwhgads',\n" +
+      '    [prototype]: { [constructor]: [Circular *1] }\n' +
+      '  }\n' +
+      '}'
+  );
+}
+
+{
+  // Confirm null prototype of generator prototype displays as expected.
+
+  function getProtoOfProto() {
+    return Object.getPrototypeOf(Object.getPrototypeOf(function* () {}));
+  }
+
+  function* generator() {}
+
+  const generatorPrototype = Object.getPrototypeOf(generator);
+  const originalProtoOfProto = Object.getPrototypeOf(generatorPrototype);
+  assert.strictEqual(getProtoOfProto(), originalProtoOfProto);
+  Object.setPrototypeOf(generatorPrototype, null);
+  assert.notStrictEqual(getProtoOfProto, originalProtoOfProto);
+
+  // This is the actual test. The other assertions in this block are about
+  // making sure the test is set up correctly and isn't polluting other tests.
+  assert.strictEqual(
+    util.inspect(generator, { showHidden: true }),
+    '[GeneratorFunction: generator] {\n' +
+    '  [length]: 0,\n' +
+    "  [name]: 'generator',\n" +
+    "  [prototype]: Object [Generator] { [Symbol(Symbol.toStringTag)]: 'Generator' },\n" + // eslint-disable-line max-len
+    "  [Symbol(Symbol.toStringTag)]: 'GeneratorFunction'\n" +
+    '}'
+  );
+
+  // Reset so we don't pollute other tests
+  Object.setPrototypeOf(generatorPrototype, originalProtoOfProto);
+  assert.strictEqual(getProtoOfProto(), originalProtoOfProto);
+}
+
+{
+  // Test for when breakLength results in a single column.
+  const obj = Array(9).fill('fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf');
+  assert.strictEqual(
+    util.inspect(obj, { breakLength: 256 }),
+    '[\n' +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf',\n" +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf',\n" +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf',\n" +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf',\n" +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf',\n" +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf',\n" +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf',\n" +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf',\n" +
+    "  'fhqwhgadshgnsdhjsdbkhsdabkfabkveybvf'\n" +
+    ']'
+  );
+}
+
+{
+  assert.strictEqual(
+    util.inspect({ ['__proto__']: { a: 1 } }),
+    "{ ['__proto__']: { a: 1 } }"
+  );
+}
diff --git a/test/parallel/test-util-log.js b/test/parallel/test-util-log.js
index 3de79b835d85a33d8971e3ecb24596df1e3db609..854746290ec79639098b9c809739a751e936140f 100644
--- a/test/parallel/test-util-log.js
+++ b/test/parallel/test-util-log.js
@@ -48,7 +48,7 @@ const tests = [
   { input: function() {}, output: '[Function: input]' },
   { input: parseInt('not a number', 10), output: 'NaN' },
   { input: { answer: 42 }, output: '{ answer: 42 }' },
-  { input: [1, 2, 3], output: '[ 1, 2, 3 ]' }
+  { input: [1, 2, 3], output: '[ 1, 2, 3 ]' },
 ];
 
 // test util.log()
diff --git a/test/parallel/test-util-promisify.js b/test/parallel/test-util-promisify.js
index cbbe8983fdf105c5fa33bb5c07987ea378dea507..7edeb6e493993e966f71d3251f745fe773c8181a 100644
--- a/test/parallel/test-util-promisify.js
+++ b/test/parallel/test-util-promisify.js
@@ -131,7 +131,7 @@ const stat = promisify(fs.stat);
   (async () => {
     const value = await promisify(fn)(null, 42);
     assert.strictEqual(value, 42);
-  })();
+  })().then(common.mustCall());
 }
 
 {
@@ -159,7 +159,7 @@ const stat = promisify(fs.stat);
     await fn();
     await Promise.resolve();
     return assert.strictEqual(stack, err.stack);
-  })();
+  })().then(common.mustCall());
 }
 
 {
@@ -193,7 +193,7 @@ const stat = promisify(fs.stat);
     }),
     b.then(assert.fail, function(e) {
       assert.strictEqual(err, e);
-    })
+    }),
   ]);
 }
 
diff --git a/test/parallel/test-util-types.js b/test/parallel/test-util-types.js
index 6a9bad016993339dccf8b90e1c0cf4e9d09adcc2..189d084ee34ff17d9bac529402daa77e8c763bb6 100644
--- a/test/parallel/test-util-types.js
+++ b/test/parallel/test-util-types.js
@@ -1,7 +1,6 @@
 // Flags: --experimental-vm-modules --expose-internals
 'use strict';
-require('../common');
-const fixtures = require('../common/fixtures');
+const common = require('../common');
 const assert = require('assert');
 const { types, inspect } = require('util');
 const vm = require('vm');
@@ -9,7 +8,6 @@ const { internalBinding } = require('internal/test/binding');
 const { JSStream } = internalBinding('js_stream');
 
 const external = (new JSStream())._externalStream;
-const wasmBuffer = fixtures.readSync('simple.wasm');
 
 for (const [ value, _method ] of [
   [ external, 'isExternal' ],
@@ -50,7 +48,6 @@ for (const [ value, _method ] of [
   [ new DataView(new ArrayBuffer()) ],
   [ new SharedArrayBuffer() ],
   [ new Proxy({}, {}), 'isProxy' ],
-  [ new WebAssembly.Module(wasmBuffer), 'isWebAssemblyCompiledModule' ],
 ]) {
   const method = _method || `is${value.constructor.name}`;
   assert(method in types, `Missing ${method} for ${inspect(value)}`);
@@ -76,7 +73,7 @@ for (const [ value, _method ] of [
   new Number(),
   new String(),
   Object(Symbol()),
-  Object(BigInt(0))
+  Object(BigInt(0)),
 ].forEach((entry) => assert(types.isBoxedPrimitive(entry)));
 
 {
@@ -197,7 +194,7 @@ for (const [ value, _method ] of [
     float32Array, fakeFloat32Array, stealthyFloat32Array,
     float64Array, fakeFloat64Array, stealthyFloat64Array,
     bigInt64Array, fakeBigInt64Array, stealthyBigInt64Array,
-    bigUint64Array, fakeBigUint64Array, stealthyBigUint64Array
+    bigUint64Array, fakeBigUint64Array, stealthyBigUint64Array,
   ];
 
   const expected = {
@@ -214,7 +211,7 @@ for (const [ value, _method ] of [
       float32Array, stealthyFloat32Array,
       float64Array, stealthyFloat64Array,
       bigInt64Array, stealthyBigInt64Array,
-      bigUint64Array, stealthyBigUint64Array
+      bigUint64Array, stealthyBigUint64Array,
     ],
     isTypedArray: [
       buffer,
@@ -228,40 +225,40 @@ for (const [ value, _method ] of [
       float32Array, stealthyFloat32Array,
       float64Array, stealthyFloat64Array,
       bigInt64Array, stealthyBigInt64Array,
-      bigUint64Array, stealthyBigUint64Array
+      bigUint64Array, stealthyBigUint64Array,
     ],
     isUint8Array: [
-      buffer, uint8Array, stealthyUint8Array
+      buffer, uint8Array, stealthyUint8Array,
     ],
     isUint8ClampedArray: [
-      uint8ClampedArray, stealthyUint8ClampedArray
+      uint8ClampedArray, stealthyUint8ClampedArray,
     ],
     isUint16Array: [
-      uint16Array, stealthyUint16Array
+      uint16Array, stealthyUint16Array,
     ],
     isUint32Array: [
-      uint32Array, stealthyUint32Array
+      uint32Array, stealthyUint32Array,
     ],
     isInt8Array: [
-      int8Array, stealthyInt8Array
+      int8Array, stealthyInt8Array,
     ],
     isInt16Array: [
-      int16Array, stealthyInt16Array
+      int16Array, stealthyInt16Array,
     ],
     isInt32Array: [
-      int32Array, stealthyInt32Array
+      int32Array, stealthyInt32Array,
     ],
     isFloat32Array: [
-      float32Array, stealthyFloat32Array
+      float32Array, stealthyFloat32Array,
     ],
     isFloat64Array: [
-      float64Array, stealthyFloat64Array
+      float64Array, stealthyFloat64Array,
     ],
     isBigInt64Array: [
-      bigInt64Array, stealthyBigInt64Array
+      bigInt64Array, stealthyBigInt64Array,
     ],
     isBigUint64Array: [
-      bigUint64Array, stealthyBigUint64Array
+      bigUint64Array, stealthyBigUint64Array,
     ]
   };
 
@@ -283,4 +280,4 @@ for (const [ value, _method ] of [
   await m.link(() => 0);
   await m.evaluate();
   assert.ok(types.isModuleNamespaceObject(m.namespace));
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-util.js b/test/parallel/test-util.js
index 204b2bca5b9f3bbdbcfa0d803208709bbe5bb3b4..42218be858157997a639ad696b309236ffe24138 100644
--- a/test/parallel/test-util.js
+++ b/test/parallel/test-util.js
@@ -148,6 +148,8 @@ assert.strictEqual(util.isFunction(function() {}), true);
 assert.strictEqual(util.isFunction(), false);
 assert.strictEqual(util.isFunction('string'), false);
 
+assert.strictEqual(util.toUSVString('string\ud801'), 'string\ufffd');
+
 {
   assert.strictEqual(util.types.isNativeError(new Error()), true);
   assert.strictEqual(util.types.isNativeError(new TypeError()), true);
diff --git a/test/parallel/test-uv-errmap.js b/test/parallel/test-uv-errmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a077551b63d7790473435aa06fac47430bd295c
--- /dev/null
+++ b/test/parallel/test-uv-errmap.js
@@ -0,0 +1,24 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const {
+  getSystemErrorMap,
+  _errnoException
+} = require('util');
+
+const { internalBinding } = require('internal/test/binding');
+const uv = internalBinding('uv');
+const uvKeys = Object.keys(uv);
+
+const errMap = getSystemErrorMap();
+
+uvKeys.forEach((key) => {
+  if (!key.startsWith('UV_'))
+    return;
+
+  const err = _errnoException(uv[key]);
+  const name = uv.errname(uv[key]);
+  assert.strictEqual(errMap.get(err.errno)[0], name);
+});
diff --git a/test/parallel/test-uv-errno.js b/test/parallel/test-uv-errno.js
index d1615e87c5661521e57308eb99036728c850741c..e46b365e4b69e484e84743ed6662519ce898ebc6 100644
--- a/test/parallel/test-uv-errno.js
+++ b/test/parallel/test-uv-errno.js
@@ -20,7 +20,7 @@ keys.forEach((key) => {
   const name = uv.errname(uv[key]);
   assert.strictEqual(getSystemErrorName(uv[key]), name);
   assert.strictEqual(err.code, name);
-  assert.strictEqual(err.code, err.errno);
+  assert.strictEqual(err.code, getSystemErrorName(err.errno));
   assert.strictEqual(err.message, `test ${name}`);
 });
 
diff --git a/test/parallel/test-uv-unmapped-exception.js b/test/parallel/test-uv-unmapped-exception.js
index 26a38b01cfbfe20fafcca59c53c88f573bdf97fc..0b63461dd25dee6005a364f159078656d61d8a2a 100644
--- a/test/parallel/test-uv-unmapped-exception.js
+++ b/test/parallel/test-uv-unmapped-exception.js
@@ -19,6 +19,7 @@ const { uvException, uvExceptionWithHostPort } = require('internal/errors');
   assert.strictEqual(exception.message,
                      'listen UNKNOWN: unknown error 127.0.0.1:80');
   assert.strictEqual(exception.code, 'UNKNOWN');
+  assert.strictEqual(exception.errno, 100);
   assert.strictEqual(exception.syscall, 'listen');
   assert.strictEqual(exception.address, '127.0.0.1');
   assert.strictEqual(exception.port, 80);
diff --git a/test/parallel/test-v8-coverage.js b/test/parallel/test-v8-coverage.js
index 2e70ce91fead6da47056481d987c7b92d63084a9..ca5301b8bd08e0c3219663d457315aa1f9c2152e 100644
--- a/test/parallel/test-v8-coverage.js
+++ b/test/parallel/test-v8-coverage.js
@@ -20,7 +20,7 @@ function nextdir() {
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/basic')
+    require.resolve('../fixtures/v8-coverage/basic'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (output.status !== 0) {
     console.log(output.stderr.toString());
@@ -39,7 +39,7 @@ function nextdir() {
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/throw')
+    require.resolve('../fixtures/v8-coverage/throw'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (output.status !== 1) {
     console.log(output.stderr.toString());
@@ -57,7 +57,7 @@ function nextdir() {
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/exit-1')
+    require.resolve('../fixtures/v8-coverage/exit-1'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (output.status !== 1) {
     console.log(output.stderr.toString());
@@ -76,7 +76,7 @@ function nextdir() {
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/sigint')
+    require.resolve('../fixtures/v8-coverage/sigint'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (!common.isWindows) {
     if (output.signal !== 'SIGINT') {
@@ -97,7 +97,7 @@ function nextdir() {
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/spawn-subprocess')
+    require.resolve('../fixtures/v8-coverage/spawn-subprocess'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (output.status !== 0) {
     console.log(output.stderr.toString());
@@ -117,7 +117,7 @@ function nextdir() {
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/worker')
+    require.resolve('../fixtures/v8-coverage/worker'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (output.status !== 0) {
     console.log(output.stderr.toString());
@@ -137,7 +137,7 @@ function nextdir() {
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/spawn-subprocess-no-cov')
+    require.resolve('../fixtures/v8-coverage/spawn-subprocess-no-cov'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (output.status !== 0) {
     console.log(output.stderr.toString());
@@ -153,7 +153,7 @@ function nextdir() {
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/async-hooks')
+    require.resolve('../fixtures/v8-coverage/async-hooks'),
   ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
   if (output.status !== 0) {
     console.log(output.stderr.toString());
@@ -172,7 +172,7 @@ function nextdir() {
   const coverageDirectory = nextdir();
   const absoluteCoverageDirectory = path.join(tmpdir.path, coverageDirectory);
   const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/basic')
+    require.resolve('../fixtures/v8-coverage/basic'),
   ], {
     cwd: tmpdir.path,
     env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory }
diff --git a/test/parallel/test-v8-getheapsnapshot-twice.js b/test/parallel/test-v8-getheapsnapshot-twice.js
new file mode 100644
index 0000000000000000000000000000000000000000..feffd97aa001a37c79b6107fc95f3613c5f9dd70
--- /dev/null
+++ b/test/parallel/test-v8-getheapsnapshot-twice.js
@@ -0,0 +1,9 @@
+'use strict';
+require('../common');
+const v8 = require('v8');
+
+// Regression test for https://github.com/nodejs/node/issues/35559
+// It is important that the return value of the first call is not used, i.e.
+// that the first snapshot is GC-able while the second one is being created.
+v8.getHeapSnapshot();
+v8.getHeapSnapshot();
diff --git a/test/parallel/test-v8-serdes.js b/test/parallel/test-v8-serdes.js
index a992ba42ce46bfcdccdca997ee13718086d3256d..1d3b6ff81168e704aa67e7abe1556c460e06ffa9 100644
--- a/test/parallel/test-v8-serdes.js
+++ b/test/parallel/test-v8-serdes.js
@@ -3,7 +3,6 @@
 'use strict';
 
 const common = require('../common');
-const fixtures = require('../common/fixtures');
 const { internalBinding } = require('internal/test/binding');
 const assert = require('assert');
 const v8 = require('v8');
@@ -12,28 +11,21 @@ const os = require('os');
 const circular = {};
 circular.circular = circular;
 
-const wasmModule = new WebAssembly.Module(fixtures.readSync('simple.wasm'));
-
 const objects = [
   { foo: 'bar' },
   { bar: 'baz' },
   new Uint8Array([1, 2, 3, 4]),
   new Uint32Array([1, 2, 3, 4]),
+  new DataView(new ArrayBuffer(42)),
   Buffer.from([1, 2, 3, 4]),
   undefined,
   null,
   42,
   circular,
-  wasmModule
 ];
 
 const hostObject = new (internalBinding('js_stream').JSStream)();
 
-const serializerTypeError =
-  /^TypeError: Class constructor Serializer cannot be invoked without 'new'$/;
-const deserializerTypeError =
-  /^TypeError: Class constructor Deserializer cannot be invoked without 'new'$/;
-
 {
   const ser = new v8.DefaultSerializer();
   ser.writeHeader();
@@ -190,8 +182,16 @@ const deserializerTypeError =
 }
 
 {
-  assert.throws(v8.Serializer, serializerTypeError);
-  assert.throws(v8.Deserializer, deserializerTypeError);
+  assert.throws(() => v8.Serializer(), {
+    constructor: TypeError,
+    message: "Class constructor Serializer cannot be invoked without 'new'",
+    code: 'ERR_CONSTRUCT_CALL_REQUIRED'
+  });
+  assert.throws(() => v8.Deserializer(), {
+    constructor: TypeError,
+    message: "Class constructor Deserializer cannot be invoked without 'new'",
+    code: 'ERR_CONSTRUCT_CALL_REQUIRED'
+  });
 }
 
 
@@ -238,7 +238,8 @@ const deserializerTypeError =
 }
 
 {
-  const deserializedWasmModule = v8.deserialize(v8.serialize(wasmModule));
-  const instance = new WebAssembly.Instance(deserializedWasmModule);
-  assert.strictEqual(instance.exports.add(10, 20), 30);
+  // Regression test for https://github.com/nodejs/node/issues/37978
+  assert.throws(() => {
+    new v8.Deserializer(new v8.Serializer().releaseBuffer()).readDouble();
+  }, /ReadDouble\(\) failed/);
 }
diff --git a/test/parallel/test-v8-stats.js b/test/parallel/test-v8-stats.js
index d79ab84956edf99623ab745638085ff73aca5d0f..2093343859f2afe77e51e294c126f8bf07f2543d 100644
--- a/test/parallel/test-v8-stats.js
+++ b/test/parallel/test-v8-stats.js
@@ -42,7 +42,7 @@ const expectedHeapSpaces = [
   'new_large_object_space',
   'new_space',
   'old_space',
-  'read_only_space'
+  'read_only_space',
 ];
 const heapSpaceStatistics = v8.getHeapSpaceStatistics();
 const actualHeapSpaceNames = heapSpaceStatistics.map((s) => s.space_name);
diff --git a/test/parallel/test-v8-version-tag.js b/test/parallel/test-v8-version-tag.js
index 22b0db0cd4888532a3eb628cfe2a20a51b4bd45d..ec57b82fac6d5045b1c9b981dee3bb4b34c44b9e 100644
--- a/test/parallel/test-v8-version-tag.js
+++ b/test/parallel/test-v8-version-tag.js
@@ -7,9 +7,9 @@ const versionTag1 = v8.cachedDataVersionTag();
 assert.strictEqual(typeof versionTag1, 'number');
 assert.strictEqual(v8.cachedDataVersionTag(), versionTag1);
 
-// The value of cachedDataVersionTag is derived from the command line flags and
-// detected CPU features. Test that the value does indeed update when flags
-// are toggled.
+// The value returned by v8.cachedDataVersionTag() is derived from the V8
+// version, command-line flags, and detected CPU features. Test that the value
+// does indeed update when flags are toggled.
 v8.setFlagsFromString('--allow_natives_syntax');
 
 const versionTag2 = v8.cachedDataVersionTag();
diff --git a/test/parallel/test-validators.js b/test/parallel/test-validators.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b0d49c6997a6565ce15f93a86018a8e0af66f45
--- /dev/null
+++ b/test/parallel/test-validators.js
@@ -0,0 +1,113 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const {
+  validateArray,
+  validateBoolean,
+  validateInteger,
+  validateNumber,
+  validateObject,
+  validateString,
+} = require('internal/validators');
+const { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } = Number;
+const outOfRangeError = {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError',
+};
+const invalidArgTypeError = {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError',
+};
+const invalidArgValueError = {
+  code: 'ERR_INVALID_ARG_VALUE',
+  name: 'TypeError',
+};
+
+{
+  // validateInteger tests.
+
+  // validateInteger() defaults to validating safe integers.
+  validateInteger(MAX_SAFE_INTEGER, 'foo');
+  validateInteger(MIN_SAFE_INTEGER, 'foo');
+  assert.throws(() => {
+    validateInteger(MAX_SAFE_INTEGER + 1, 'foo');
+  }, outOfRangeError);
+  assert.throws(() => {
+    validateInteger(MIN_SAFE_INTEGER - 1, 'foo');
+  }, outOfRangeError);
+
+  // validateInteger() works with unsafe integers.
+  validateInteger(MAX_SAFE_INTEGER + 1, 'foo', 0, MAX_SAFE_INTEGER + 1);
+  validateInteger(MIN_SAFE_INTEGER - 1, 'foo', MIN_SAFE_INTEGER - 1);
+}
+
+{
+  // validateArray tests.
+  validateArray([], 'foo');
+  validateArray([1, 2, 3], 'foo');
+
+  [undefined, null, true, false, 0, 0.0, 42, '', 'string', {}]
+    .forEach((val) => {
+      assert.throws(() => {
+        validateArray(val, 'foo');
+      }, invalidArgTypeError);
+    });
+
+  validateArray([1], 'foo', 1);
+  assert.throws(() => {
+    validateArray([], 'foo', 1);
+  }, invalidArgValueError);
+}
+
+{
+  // validateBoolean tests.
+  validateBoolean(true, 'foo');
+  validateBoolean(false, 'foo');
+
+  [undefined, null, 0, 0.0, 42, '', 'string', {}, []].forEach((val) => {
+    assert.throws(() => {
+      validateBoolean(val, 'foo');
+    }, invalidArgTypeError);
+  });
+}
+
+{
+  // validateObject tests.
+  validateObject({}, 'foo');
+  validateObject({ a: 42, b: 'foo' }, 'foo');
+
+  [undefined, null, true, false, 0, 0.0, 42, '', 'string', [], () => {}]
+    .forEach((val) => {
+      assert.throws(() => {
+        validateObject(val, 'foo');
+      }, invalidArgTypeError);
+    });
+
+  // validateObject options tests:
+  validateObject(null, 'foo', { nullable: true });
+  validateObject([], 'foo', { allowArray: true });
+  validateObject(() => {}, 'foo', { allowFunction: true });
+}
+
+{
+  // validateString type validation.
+  [
+    -1, {}, [], false, true,
+    1, Infinity, -Infinity, NaN,
+    undefined, null, 1.1,
+  ].forEach((i) => assert.throws(() => validateString(i, 'name'), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  }));
+}
+{
+  // validateNumber type validation.
+  [
+    'a', {}, [], false, true,
+    undefined, null, '', ' ', '0x',
+    '-0x1', '-0o1', '-0b1', '0o', '0b',
+  ].forEach((i) => assert.throws(() => validateNumber(i, 'name'), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  }));
+}
diff --git a/test/parallel/test-vm-context.js b/test/parallel/test-vm-context.js
index 5226f0e6ac0ea22349e4950c51d50f92c4e0f868..bcfbb327bf72e869b304d7eb73aa2e012e77d59c 100644
--- a/test/parallel/test-vm-context.js
+++ b/test/parallel/test-vm-context.js
@@ -82,7 +82,7 @@ const contextifiedObjectError = {
   [0.0, nonContextualObjectError],
   ['', nonContextualObjectError],
   [{}, contextifiedObjectError],
-  [[], contextifiedObjectError]
+  [[], contextifiedObjectError],
 ].forEach((e) => {
   assert.throws(() => { script.runInContext(e[0]); }, e[1]);
   assert.throws(() => { vm.runInContext('', e[0]); }, e[1]);
diff --git a/test/parallel/test-vm-is-context.js b/test/parallel/test-vm-is-context.js
index a47bee7c599c6b751df35c662bbf4d3b3275115a..02dc7a596db463db61f65e80b0143c4782046b57 100644
--- a/test/parallel/test-vm-is-context.js
+++ b/test/parallel/test-vm-is-context.js
@@ -25,7 +25,7 @@ const assert = require('assert');
 const vm = require('vm');
 
 for (const valToTest of [
-  'string', null, undefined, 8.9, Symbol('sym'), true
+  'string', null, undefined, 8.9, Symbol('sym'), true,
 ]) {
   assert.throws(() => {
     vm.isContext(valToTest);
diff --git a/test/parallel/test-vm-measure-memory-lazy.js b/test/parallel/test-vm-measure-memory-lazy.js
new file mode 100644
index 0000000000000000000000000000000000000000..513cfbc367245175eb5caa5337e47728661ea3cf
--- /dev/null
+++ b/test/parallel/test-vm-measure-memory-lazy.js
@@ -0,0 +1,37 @@
+// Flags: --expose-gc
+
+'use strict';
+const common = require('../common');
+const {
+  assertSummaryShape,
+  expectExperimentalWarning
+} = require('../common/measure-memory');
+const vm = require('vm');
+
+expectExperimentalWarning();
+
+// Test lazy memory measurement - we will need to global.gc()
+// or otherwise these may not resolve.
+{
+  vm.measureMemory()
+    .then(common.mustCall(assertSummaryShape));
+  global.gc();
+}
+
+{
+  vm.measureMemory({})
+    .then(common.mustCall(assertSummaryShape));
+  global.gc();
+}
+
+{
+  vm.measureMemory({ mode: 'summary' })
+    .then(common.mustCall(assertSummaryShape));
+  global.gc();
+}
+
+{
+  vm.measureMemory({ mode: 'detailed' })
+    .then(common.mustCall(assertSummaryShape));
+  global.gc();
+}
diff --git a/test/parallel/test-vm-measure-memory-multi-context.js b/test/parallel/test-vm-measure-memory-multi-context.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a3065a8edb6315f460cfe6ad214dbc7cf1e1313
--- /dev/null
+++ b/test/parallel/test-vm-measure-memory-multi-context.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+const {
+  assertDetailedShape,
+  expectExperimentalWarning
+} = require('../common/measure-memory');
+const vm = require('vm');
+const assert = require('assert');
+
+expectExperimentalWarning();
+{
+  const arr = [];
+  const count = 10;
+  for (let i = 0; i < count; ++i) {
+    const context = vm.createContext({
+      test: new Array(100).fill('foo')
+    });
+    arr.push(context);
+  }
+  // Check that one more context shows up in the result
+  vm.measureMemory({ mode: 'detailed', execution: 'eager' })
+    .then(common.mustCall((result) => {
+      // We must hold on to the contexts here so that they
+      // don't get GC'ed until the measurement is complete
+      assert.strictEqual(arr.length, count);
+      assertDetailedShape(result, count);
+    }));
+}
diff --git a/test/parallel/test-vm-measure-memory.js b/test/parallel/test-vm-measure-memory.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b18db9be7a71486985aca526a596aa9e8ba1c6d
--- /dev/null
+++ b/test/parallel/test-vm-measure-memory.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+const {
+  assertSummaryShape,
+  assertSingleDetailedShape,
+  expectExperimentalWarning
+} = require('../common/measure-memory');
+const assert = require('assert');
+const vm = require('vm');
+
+expectExperimentalWarning();
+
+// Test eager memory measurement
+{
+  vm.measureMemory({ execution: 'eager' })
+    .then(common.mustCall(assertSummaryShape));
+
+  vm.measureMemory({ mode: 'detailed', execution: 'eager' })
+    .then(common.mustCall(assertSingleDetailedShape));
+
+  vm.measureMemory({ mode: 'summary', execution: 'eager' })
+    .then(common.mustCall(assertSummaryShape));
+
+  assert.throws(() => vm.measureMemory(null), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+  assert.throws(() => vm.measureMemory('summary'), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
+  assert.throws(() => vm.measureMemory({ mode: 'random' }), {
+    code: 'ERR_INVALID_ARG_VALUE'
+  });
+  assert.throws(() => vm.measureMemory({ execution: 'random' }), {
+    code: 'ERR_INVALID_ARG_VALUE'
+  });
+}
diff --git a/test/parallel/test-vm-module-basic.js b/test/parallel/test-vm-module-basic.js
index 27b7f0476d502dae129029a1f60fc93a7772f543..dbb88e2a87741d1d75bf163f77e44531db787582 100644
--- a/test/parallel/test-vm-module-basic.js
+++ b/test/parallel/test-vm-module-basic.js
@@ -25,34 +25,34 @@ const util = require('util');
   assert.strictEqual(m.status, 'unlinked');
   await m.link(common.mustNotCall());
   assert.strictEqual(m.status, 'linked');
-  const result = await m.evaluate();
+  assert.strictEqual(await m.evaluate(), undefined);
   assert.strictEqual(m.status, 'evaluated');
-  assert.strictEqual(Object.getPrototypeOf(result), null);
   assert.deepStrictEqual(context, {
     foo: 'bar',
     baz: 'bar',
     typeofProcess: 'undefined'
   });
-  assert.strictEqual(result.result, 'function');
-}());
+}().then(common.mustCall()));
 
 (async () => {
-  const m = new SourceTextModule(
-    'global.vmResult = "foo"; Object.prototype.toString.call(process);'
-  );
+  const m = new SourceTextModule(`
+    global.vmResultFoo = "foo";
+    global.vmResultTypeofProcess = Object.prototype.toString.call(process);
+  `);
   await m.link(common.mustNotCall());
-  const { result } = await m.evaluate();
-  assert.strictEqual(global.vmResult, 'foo');
-  assert.strictEqual(result, '[object process]');
-  delete global.vmResult;
-})();
+  await m.evaluate();
+  assert.strictEqual(global.vmResultFoo, 'foo');
+  assert.strictEqual(global.vmResultTypeofProcess, '[object process]');
+  delete global.vmResultFoo;
+  delete global.vmResultTypeofProcess;
+})().then(common.mustCall());
 
 (async () => {
   const m = new SourceTextModule('while (true) {}');
   await m.link(common.mustNotCall());
   await m.evaluate({ timeout: 500 })
     .then(() => assert(false), () => {});
-})();
+})().then(common.mustCall());
 
 // Check the generated identifier for each module
 (async () => {
@@ -65,7 +65,7 @@ const util = require('util');
   assert.strictEqual(m2.identifier, 'vm:module(1)');
   const m3 = new SourceTextModule('3', { context: context2 });
   assert.strictEqual(m3.identifier, 'vm:module(0)');
-})();
+})().then(common.mustCall());
 
 // Check inspection of the instance
 {
@@ -83,9 +83,12 @@ const util = require('util');
 
   assert.strictEqual(util.inspect(m, { depth: -1 }), '[SourceTextModule]');
 
-  assert.strictEqual(
-    m[util.inspect.custom].call(Object.create(null)),
-    'Module { status: undefined, identifier: undefined, context: undefined }',
+  assert.throws(
+    () => m[util.inspect.custom].call(Object.create(null)),
+    {
+      code: 'ERR_VM_MODULE_NOT_MODULE',
+      message: 'Provided module is not an instance of Module'
+    },
   );
 }
 
diff --git a/test/parallel/test-vm-module-dynamic-import.js b/test/parallel/test-vm-module-dynamic-import.js
index 70229b3897874bd3eaeb4f9ba65733b5baffe1d1..9d04cf96e6f97969939a94b310f6fdd5d396f1f1 100644
--- a/test/parallel/test-vm-module-dynamic-import.js
+++ b/test/parallel/test-vm-module-dynamic-import.js
@@ -5,19 +5,23 @@
 const common = require('../common');
 
 const assert = require('assert');
-const { Script, SourceTextModule, createContext } = require('vm');
+const { Script, SourceTextModule } = require('vm');
 
 async function testNoCallback() {
-  const m = new SourceTextModule('import("foo")', { context: createContext() });
+  const m = new SourceTextModule(`
+    globalThis.importResult = import("foo");
+    globalThis.importResult.catch(() => {});
+  `);
   await m.link(common.mustNotCall());
-  const { result } = await m.evaluate();
+  await m.evaluate();
   let threw = false;
   try {
-    await result;
+    await globalThis.importResult;
   } catch (err) {
     threw = true;
     assert.strictEqual(err.code, 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING');
   }
+  delete globalThis.importResult;
   assert(threw);
 }
 
@@ -40,7 +44,7 @@ async function test() {
   }
 
   {
-    const m = new SourceTextModule('import("foo")', {
+    const m = new SourceTextModule('globalThis.fooResult = import("foo")', {
       importModuleDynamically: common.mustCall((specifier, wrap) => {
         assert.strictEqual(specifier, 'foo');
         assert.strictEqual(wrap, m);
@@ -48,24 +52,26 @@ async function test() {
       }),
     });
     await m.link(common.mustNotCall());
-    const { result } = await m.evaluate();
-    assert.strictEqual(foo.namespace, await result);
+    await m.evaluate();
+    assert.strictEqual(foo.namespace, await globalThis.fooResult);
+    delete globalThis.fooResult;
   }
 }
 
 async function testInvalid() {
-  const m = new SourceTextModule('import("foo")', {
+  const m = new SourceTextModule('globalThis.fooResult = import("foo")', {
     importModuleDynamically: common.mustCall((specifier, wrap) => {
       return 5;
     }),
   });
   await m.link(common.mustNotCall());
-  const { result } = await m.evaluate();
-  await result.catch(common.mustCall((e) => {
+  await m.evaluate();
+  await globalThis.fooResult.catch(common.mustCall((e) => {
     assert.strictEqual(e.code, 'ERR_VM_MODULE_NOT_MODULE');
   }));
+  delete globalThis.fooResult;
 
-  const s = new Script('import("foo")', {
+  const s = new Script('import("bar")', {
     importModuleDynamically: common.mustCall((specifier, wrap) => {
       return undefined;
     }),
diff --git a/test/parallel/test-vm-module-dynamic-namespace.js b/test/parallel/test-vm-module-dynamic-namespace.js
index 987b21f2ec11512c077a5aea6c3b6e7a59c500a1..84937cd78de4af8976fe93e6bc2f9386773d1873 100644
--- a/test/parallel/test-vm-module-dynamic-namespace.js
+++ b/test/parallel/test-vm-module-dynamic-namespace.js
@@ -9,22 +9,18 @@ const assert = require('assert');
 const { types } = require('util');
 const { SourceTextModule } = require('vm');
 
-async function getNamespace() {
-  const m = new SourceTextModule('');
-  await m.link(() => 0);
-  await m.evaluate();
-  return m.namespace;
-}
-
 (async () => {
-  const namespace = await getNamespace();
-  const m = new SourceTextModule('export const A = "A"; import("");', {
-    importModuleDynamically: common.mustCall((specifier, wrap) => {
-      return namespace;
-    })
+  const m = new SourceTextModule('globalThis.importResult = import("");', {
+    importModuleDynamically: common.mustCall(async (specifier, wrap) => {
+      const m = new SourceTextModule('');
+      await m.link(() => 0);
+      await m.evaluate();
+      return m.namespace;
+    }),
   });
   await m.link(() => 0);
-  const { result } = await m.evaluate();
-  const ns = await result;
+  await m.evaluate();
+  const ns = await globalThis.importResult;
+  delete globalThis.importResult;
   assert.ok(types.isModuleNamespaceObject(ns));
 })().then(common.mustCall());
diff --git a/test/parallel/test-vm-module-errors.js b/test/parallel/test-vm-module-errors.js
index d14296b1e9ebde9467577ca74f59af66dd5fb3ff..888250cef84f6f8397a88870cd048b00a03f223f 100644
--- a/test/parallel/test-vm-module-errors.js
+++ b/test/parallel/test-vm-module-errors.js
@@ -6,7 +6,7 @@ const common = require('../common');
 
 const assert = require('assert');
 
-const { SourceTextModule, createContext } = require('vm');
+const { SourceTextModule, createContext, Module } = require('vm');
 
 async function createEmptyLinkedModule() {
   const m = new SourceTextModule('');
@@ -24,7 +24,7 @@ async function checkArgType() {
 
   for (const invalidOptions of [
     0, 1, null, true, 'str', () => {}, { identifier: 0 }, Symbol.iterator,
-    { context: null }, { context: 'hucairz' }, { context: {} }
+    { context: null }, { context: 'hucairz' }, { context: {} },
   ]) {
     assert.throws(() => {
       new SourceTextModule('', invalidOptions);
@@ -35,7 +35,7 @@ async function checkArgType() {
   }
 
   for (const invalidLinker of [
-    0, 1, undefined, null, true, 'str', {}, Symbol.iterator
+    0, 1, undefined, null, true, 'str', {}, Symbol.iterator,
   ]) {
     await assert.rejects(async () => {
       const m = new SourceTextModule('');
@@ -86,7 +86,7 @@ async function checkModuleState() {
 
   assert.throws(() => {
     const m = new SourceTextModule('');
-    m.error;
+    m.error; // eslint-disable-line no-unused-expressions
   }, {
     code: 'ERR_VM_MODULE_STATUS',
     message: 'Module status must be errored'
@@ -95,7 +95,7 @@ async function checkModuleState() {
   await assert.rejects(async () => {
     const m = await createEmptyLinkedModule();
     await m.evaluate();
-    m.error;
+    m.error; // eslint-disable-line no-unused-expressions
   }, {
     code: 'ERR_VM_MODULE_STATUS',
     message: 'Module status must be errored'
@@ -103,7 +103,7 @@ async function checkModuleState() {
 
   assert.throws(() => {
     const m = new SourceTextModule('');
-    m.namespace;
+    m.namespace; // eslint-disable-line no-unused-expressions
   }, {
     code: 'ERR_VM_MODULE_STATUS',
     message: 'Module status must not be unlinked or linking'
@@ -182,13 +182,11 @@ async function checkExecution() {
   await (async () => {
     const m = new SourceTextModule('throw new Error();');
     await m.link(common.mustNotCall());
-    const evaluatePromise = m.evaluate();
-    await evaluatePromise.catch(() => {});
-    assert.strictEqual(m.status, 'errored');
     try {
-      await evaluatePromise;
+      await m.evaluate();
     } catch (err) {
       assert.strictEqual(m.error, err);
+      assert.strictEqual(m.status, 'errored');
       return;
     }
     assert.fail('Missing expected exception');
@@ -207,6 +205,17 @@ async function checkInvalidOptionForEvaluate() {
       "Received type string ('a-string')",
     code: 'ERR_INVALID_ARG_TYPE'
   });
+
+  {
+    ['link', 'evaluate'].forEach(async (method) => {
+      await assert.rejects(async () => {
+        await Module.prototype[method]();
+      }, {
+        code: 'ERR_VM_MODULE_NOT_MODULE',
+        message: /Provided module is not an instance of Module/
+      });
+    });
+  }
 }
 
 function checkInvalidCachedData() {
@@ -225,6 +234,29 @@ function checkInvalidCachedData() {
   });
 }
 
+function checkGettersErrors() {
+  const expectedError = {
+    code: 'ERR_VM_MODULE_NOT_MODULE',
+    message: /Provided module is not an instance of Module/
+  };
+  const getters = ['identifier', 'context', 'namespace', 'status', 'error'];
+  getters.forEach((getter) => {
+    assert.throws(() => {
+      // eslint-disable-next-line no-unused-expressions
+      Module.prototype[getter];
+    }, expectedError);
+    assert.throws(() => {
+      // eslint-disable-next-line no-unused-expressions
+      SourceTextModule.prototype[getter];
+    }, expectedError);
+  });
+  // `dependencySpecifiers` getter is just part of SourceTextModule
+  assert.throws(() => {
+    // eslint-disable-next-line no-unused-expressions
+    SourceTextModule.prototype.dependencySpecifiers;
+  }, expectedError);
+}
+
 const finished = common.mustCall();
 
 (async function main() {
@@ -234,5 +266,6 @@ const finished = common.mustCall();
   await checkExecution();
   await checkInvalidOptionForEvaluate();
   checkInvalidCachedData();
+  checkGettersErrors();
   finished();
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-vm-module-import-meta.js b/test/parallel/test-vm-module-import-meta.js
index 0f86f2fa646914ac7606fc99ef05167d09c5695c..4fa285a906086db672cc8035318c5b3dc4844b61 100644
--- a/test/parallel/test-vm-module-import-meta.js
+++ b/test/parallel/test-vm-module-import-meta.js
@@ -7,14 +7,16 @@ const assert = require('assert');
 const { SourceTextModule } = require('vm');
 
 async function testBasic() {
-  const m = new SourceTextModule('import.meta;', {
+  const m = new SourceTextModule('globalThis.importMeta = import.meta;', {
     initializeImportMeta: common.mustCall((meta, module) => {
       assert.strictEqual(module, m);
       meta.prop = 42;
     })
   });
   await m.link(common.mustNotCall());
-  const { result } = await m.evaluate();
+  await m.evaluate();
+  const result = globalThis.importMeta;
+  delete globalThis.importMeta;
   assert.strictEqual(typeof result, 'object');
   assert.strictEqual(Object.getPrototypeOf(result), null);
   assert.strictEqual(result.prop, 42);
@@ -23,7 +25,7 @@ async function testBasic() {
 
 async function testInvalid() {
   for (const invalidValue of [
-    null, {}, 0, Symbol.iterator, [], 'string', false
+    null, {}, 0, Symbol.iterator, [], 'string', false,
   ]) {
     assert.throws(() => {
       new SourceTextModule('', {
@@ -39,4 +41,4 @@ async function testInvalid() {
 (async () => {
   await testBasic();
   await testInvalid();
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-vm-module-link.js b/test/parallel/test-vm-module-link.js
index 56443e3e1a73bc78b4b41c37b0bbb0b54ac5fc0a..39520bcf8e68916707b9f38233bad4c37312cac4 100644
--- a/test/parallel/test-vm-module-link.js
+++ b/test/parallel/test-vm-module-link.js
@@ -5,7 +5,6 @@
 const common = require('../common');
 
 const assert = require('assert');
-const { URL } = require('url');
 
 const { SourceTextModule } = require('vm');
 
@@ -13,7 +12,8 @@ async function simple() {
   const foo = new SourceTextModule('export default 5;');
   await foo.link(common.mustNotCall());
 
-  const bar = new SourceTextModule('import five from "foo"; five');
+  globalThis.fiveResult = undefined;
+  const bar = new SourceTextModule('import five from "foo"; fiveResult = five');
 
   assert.deepStrictEqual(bar.dependencySpecifiers, ['foo']);
 
@@ -23,7 +23,9 @@ async function simple() {
     return foo;
   }));
 
-  assert.strictEqual((await bar.evaluate()).result, 5);
+  await bar.evaluate();
+  assert.strictEqual(globalThis.fiveResult, 5);
+  delete globalThis.fiveResult;
 }
 
 async function depth() {
@@ -130,4 +132,4 @@ const finished = common.mustCall();
   await circular();
   await circular2();
   finished();
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-vm-module-reevaluate.js b/test/parallel/test-vm-module-reevaluate.js
index 4767541dd24c376d71921561ff3f098dfee48d9b..e547390e0cf84f9a46d513740120da1f8ade028b 100644
--- a/test/parallel/test-vm-module-reevaluate.js
+++ b/test/parallel/test-vm-module-reevaluate.js
@@ -12,11 +12,16 @@ const finished = common.mustCall();
 
 (async function main() {
   {
-    const m = new SourceTextModule('1');
+    globalThis.count = 0;
+    const m = new SourceTextModule('count += 1;');
     await m.link(common.mustNotCall());
-    assert.strictEqual((await m.evaluate()).result, 1);
-    assert.strictEqual((await m.evaluate()).result, undefined);
-    assert.strictEqual((await m.evaluate()).result, undefined);
+    assert.strictEqual(await m.evaluate(), undefined);
+    assert.strictEqual(globalThis.count, 1);
+    assert.strictEqual(await m.evaluate(), undefined);
+    assert.strictEqual(globalThis.count, 1);
+    assert.strictEqual(await m.evaluate(), undefined);
+    assert.strictEqual(globalThis.count, 1);
+    delete globalThis.count;
   }
 
   {
@@ -43,4 +48,4 @@ const finished = common.mustCall();
   }
 
   finished();
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-vm-module-synthetic.js b/test/parallel/test-vm-module-synthetic.js
index 83a78f2f3f5ba2345664212421012da0fb9fa394..9d1c07ead5c4cd55a2589fad202e9cbd20b2abf8 100644
--- a/test/parallel/test-vm-module-synthetic.js
+++ b/test/parallel/test-vm-module-synthetic.js
@@ -2,7 +2,7 @@
 
 // Flags: --experimental-vm-modules
 
-require('../common');
+const common = require('../common');
 const { SyntheticModule, SourceTextModule } = require('vm');
 const assert = require('assert');
 
@@ -26,6 +26,17 @@ const assert = require('assert');
     assert.strictEqual(m.namespace.getX(), 42);
   }
 
+  {
+    const s = new SyntheticModule([], () => {
+      const p = Promise.reject();
+      p.catch(() => {});
+      return p;
+    });
+
+    await s.link(common.mustNotCall());
+    assert.strictEqual(await s.evaluate(), undefined);
+  }
+
   for (const invalidName of [1, Symbol.iterator, {}, [], null, true, 0]) {
     const s = new SyntheticModule([], () => {});
     await s.link(() => {});
@@ -54,4 +65,14 @@ const assert = require('assert');
       code: 'ERR_VM_MODULE_STATUS',
     });
   }
-})();
+
+  {
+    assert.throws(() => {
+      SyntheticModule.prototype.setExport.call({}, 'foo');
+    }, {
+      code: 'ERR_VM_MODULE_NOT_MODULE',
+      message: /Provided module is not an instance of Module/
+    });
+  }
+
+})().then(common.mustCall());
diff --git a/test/parallel/test-vm-sigint-existing-handler.js b/test/parallel/test-vm-sigint-existing-handler.js
index c6072d29d854ccbf684eae3e41f53f7db13bc24b..47e5e80c7430235cee8c5377bcd385402ac3549d 100644
--- a/test/parallel/test-vm-sigint-existing-handler.js
+++ b/test/parallel/test-vm-sigint-existing-handler.js
@@ -11,7 +11,7 @@ const spawn = require('child_process').spawn;
 
 const methods = [
   'runInThisContext',
-  'runInContext'
+  'runInContext',
 ];
 
 if (process.argv[2] === 'child') {
diff --git a/test/parallel/test-vm-syntax-error-message.js b/test/parallel/test-vm-syntax-error-message.js
index 5a16239f5653e9e38066ba63d444ad0387b1a49f..c49ff6aeb1925eddbf1b4933c99b0e22511f361f 100644
--- a/test/parallel/test-vm-syntax-error-message.js
+++ b/test/parallel/test-vm-syntax-error-message.js
@@ -8,7 +8,7 @@ const p = child_process.spawn(process.execPath, [
   'vm = require("vm");' +
       'context = vm.createContext({});' +
       'try { vm.runInContext("throw new Error(\'boo\')", context); } ' +
-      'catch (e) { console.log(e.message); }'
+      'catch (e) { console.log(e.message); }',
 ]);
 
 p.stderr.on('data', common.mustNotCall());
diff --git a/test/parallel/test-vm-syntax-error-stderr.js b/test/parallel/test-vm-syntax-error-stderr.js
index e8d48235cf3edeb8e04c7190ed63a97c287143e2..dd0667c65302aeffd90926f7552914da5ef28e10 100644
--- a/test/parallel/test-vm-syntax-error-stderr.js
+++ b/test/parallel/test-vm-syntax-error-stderr.js
@@ -9,7 +9,7 @@ const wrong_script = fixtures.path('keys/rsa_cert.crt');
 const p = child_process.spawn(process.execPath, [
   '-e',
   'require(process.argv[1]);',
-  wrong_script
+  wrong_script,
 ]);
 
 p.stdout.on('data', common.mustNotCall());
diff --git a/test/parallel/test-vm-timeout-escape-promise-2.js b/test/parallel/test-vm-timeout-escape-promise-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..a3cb3dbc7fd442062ccb3eb8157a89c05f86fa7d
--- /dev/null
+++ b/test/parallel/test-vm-timeout-escape-promise-2.js
@@ -0,0 +1,38 @@
+'use strict';
+// https://github.com/nodejs/node/issues/3020
+// Promises used to allow code to escape the timeout
+// set for runInContext, runInNewContext, and runInThisContext.
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const NS_PER_MS = 1000000n;
+
+const hrtime = process.hrtime.bigint;
+
+function loop() {
+  const start = hrtime();
+  while (1) {
+    const current = hrtime();
+    const span = (current - start) / NS_PER_MS;
+    if (span >= 100n) {
+      throw new Error(
+        `escaped timeout at ${span} milliseconds!`);
+    }
+  }
+}
+
+assert.throws(() => {
+  vm.runInNewContext(
+    'Promise.resolve().then(() => loop());',
+    {
+      hrtime,
+      loop
+    },
+    { timeout: 10, microtaskMode: 'afterEvaluate' }
+  );
+}, {
+  code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
+  message: 'Script execution timed out after 10ms'
+});
diff --git a/test/parallel/test-vm-timeout-escape-promise-module.js b/test/parallel/test-vm-timeout-escape-promise-module.js
new file mode 100644
index 0000000000000000000000000000000000000000..3451c0af71c16fc5f1908ef1d548aba21bec8c6f
--- /dev/null
+++ b/test/parallel/test-vm-timeout-escape-promise-module.js
@@ -0,0 +1,42 @@
+// Flags: --experimental-vm-modules
+'use strict';
+
+// https://github.com/nodejs/node/issues/3020
+// Promises used to allow code to escape the timeout
+// set for runInContext, runInNewContext, and runInThisContext.
+
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const NS_PER_MS = 1000000n;
+
+const hrtime = process.hrtime.bigint;
+
+function loop() {
+  const start = hrtime();
+  while (1) {
+    const current = hrtime();
+    const span = (current - start) / NS_PER_MS;
+    if (span >= 100n) {
+      throw new Error(
+        `escaped timeout at ${span} milliseconds!`);
+    }
+  }
+}
+
+assert.rejects(async () => {
+  const module = new vm.SourceTextModule(
+    'Promise.resolve().then(() => loop()); loop();',
+    {
+      context: vm.createContext({
+        hrtime,
+        loop
+      }, { microtaskMode: 'afterEvaluate' })
+    });
+  await module.link(common.mustNotCall());
+  await module.evaluate({ timeout: 5 });
+}, {
+  code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
+  message: 'Script execution timed out after 5ms'
+});
diff --git a/test/known_issues/test-vm-timeout-escape-promise.js b/test/parallel/test-vm-timeout-escape-promise.js
similarity index 74%
rename from test/known_issues/test-vm-timeout-escape-promise.js
rename to test/parallel/test-vm-timeout-escape-promise.js
index 4452c83cd182e3dbcad962e47485ad631709ce99..0e82ab8c86a935533333418b67d5d8a462f056c0 100644
--- a/test/known_issues/test-vm-timeout-escape-promise.js
+++ b/test/parallel/test-vm-timeout-escape-promise.js
@@ -1,8 +1,8 @@
 'use strict';
 
 // https://github.com/nodejs/node/issues/3020
-// Promises, nextTick, and queueMicrotask allow code to escape the timeout
-// set for runInContext, runInNewContext, and runInThisContext
+// Promises used to allow code to escape the timeout
+// set for runInContext, runInNewContext, and runInThisContext.
 
 require('../common');
 const assert = require('assert');
@@ -26,12 +26,12 @@ function loop() {
 
 assert.throws(() => {
   vm.runInNewContext(
-    'Promise.resolve().then(loop); loop();',
+    'Promise.resolve().then(() => loop()); loop();',
     {
       hrtime,
       loop
     },
-    { timeout: 5 }
+    { timeout: 5, microtaskMode: 'afterEvaluate' }
   );
 }, {
   code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
diff --git a/test/parallel/test-weakref.js b/test/parallel/test-weakref.js
index 9dac8463760dac6ee9270fe6805699c6bffd7299..ca7485aaa6a40c916fd3fec80960e9c6f6f3eda6 100644
--- a/test/parallel/test-weakref.js
+++ b/test/parallel/test-weakref.js
@@ -1,6 +1,6 @@
 'use strict';
 
-// Flags: --expose-gc --harmony-weak-refs
+// Flags: --expose-gc
 
 require('../common');
 const assert = require('assert');
diff --git a/test/parallel/test-whatwg-encoding-custom-api-basics.js b/test/parallel/test-whatwg-encoding-custom-api-basics.js
index c39bce5d74ee99611d6ef8cc7e7755b98f0c0622..71b573a8df962ec4ea2d603ccca259b6ae59df5e 100644
--- a/test/parallel/test-whatwg-encoding-custom-api-basics.js
+++ b/test/parallel/test-whatwg-encoding-custom-api-basics.js
@@ -28,7 +28,7 @@ const sample = 'z\xA2\u6C34\uD834\uDD1E\uF8FF\uDBFF\uDFFD\uFFFE';
     0x7A, 0xC2, 0xA2, 0xE6, 0xB0, 0xB4,
     0xF0, 0x9D, 0x84, 0x9E, 0xEF, 0xA3,
     0xBF, 0xF4, 0x8F, 0xBF, 0xBD, 0xEF,
-    0xBF, 0xBE
+    0xBF, 0xBE,
   ];
   const encoded = new TextEncoder().encode(string);
   assert.deepStrictEqual([].slice.call(encoded), bytes);
@@ -46,7 +46,7 @@ testDecodeSample(
   [
     0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
     0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
-    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF
+    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF,
   ]
 );
 
@@ -56,6 +56,6 @@ testDecodeSample(
   [
     0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
     0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
-    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF
+    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF,
   ]
 );
diff --git a/test/parallel/test-whatwg-encoding-custom-fatal-streaming.js b/test/parallel/test-whatwg-encoding-custom-fatal-streaming.js
index aed0f14ef7fcaeb0567f684f77481e1af1876473..164088270c3e905445dfac4f78f1f1c434633531 100644
--- a/test/parallel/test-whatwg-encoding-custom-fatal-streaming.js
+++ b/test/parallel/test-whatwg-encoding-custom-fatal-streaming.js
@@ -13,7 +13,7 @@ if (!common.hasIntl)
   [
     { encoding: 'utf-8', sequence: [0xC0] },
     { encoding: 'utf-16le', sequence: [0x00] },
-    { encoding: 'utf-16be', sequence: [0x00] }
+    { encoding: 'utf-16be', sequence: [0x00] },
   ].forEach((testCase) => {
     const data = new Uint8Array([testCase.sequence]);
     assert.throws(
diff --git a/test/parallel/test-whatwg-encoding-custom-internals.js b/test/parallel/test-whatwg-encoding-custom-internals.js
index 64bf6abe0d97bea69da50c8159d06e72ddc957ad..c810b43b1ae44755d758692ef355c6f9d7af0b36 100644
--- a/test/parallel/test-whatwg-encoding-custom-internals.js
+++ b/test/parallel/test-whatwg-encoding-custom-internals.js
@@ -13,16 +13,16 @@ const { getEncodingFromLabel } = require('internal/encoding');
   const mappings = {
     'utf-8': [
       'unicode-1-1-utf-8',
-      'utf8'
+      'utf8',
     ],
     'utf-16be': [],
     'utf-16le': [
-      'utf-16'
+      'utf-16',
     ],
     'ibm866': [
       '866',
       'cp866',
-      'csibm866'
+      'csibm866',
     ],
     'iso-8859-2': [
       'csisolatin2',
@@ -32,7 +32,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso_8859-2',
       'iso_8859-2:1987',
       'l2',
-      'latin2'
+      'latin2',
     ],
     'iso-8859-3': [
       'csisolatin3',
@@ -42,7 +42,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso_8859-3',
       'iso_8859-3:1988',
       'l3',
-      'latin3'
+      'latin3',
     ],
     'iso-8859-4': [
       'csisolatin4',
@@ -52,7 +52,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso_8859-4',
       'iso_8859-4:1988',
       'l4',
-      'latin4'
+      'latin4',
     ],
     'iso-8859-5': [
       'csisolatincyrillic',
@@ -61,7 +61,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso8859-5',
       'iso88595',
       'iso_8859-5',
-      'iso_8859-5:1988'
+      'iso_8859-5:1988',
     ],
     'iso-8859-6': [
       'arabic',
@@ -76,7 +76,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso8859-6',
       'iso88596',
       'iso_8859-6',
-      'iso_8859-6:1987'
+      'iso_8859-6:1987',
     ],
     'iso-8859-7': [
       'csisolatingreek',
@@ -89,7 +89,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso88597',
       'iso_8859-7',
       'iso_8859-7:1987',
-      'sun_eu_greek'
+      'sun_eu_greek',
     ],
     'iso-8859-8': [
       'csiso88598e',
@@ -101,11 +101,11 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso88598',
       'iso_8859-8',
       'iso_8859-8:1988',
-      'visual'
+      'visual',
     ],
     'iso-8859-8-i': [
       'csiso88598i',
-      'logical'
+      'logical',
     ],
     'iso-8859-10': [
       'csisolatin6',
@@ -113,51 +113,51 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso8859-10',
       'iso885910',
       'l6',
-      'latin6'
+      'latin6',
     ],
     'iso-8859-13': [
       'iso8859-13',
-      'iso885913'
+      'iso885913',
     ],
     'iso-8859-14': [
       'iso8859-14',
-      'iso885914'
+      'iso885914',
     ],
     'iso-8859-15': [
       'csisolatin9',
       'iso8859-15',
       'iso885915',
       'iso_8859-15',
-      'l9'
+      'l9',
     ],
     'koi8-r': [
       'cskoi8r',
       'koi',
       'koi8',
-      'koi8_r'
+      'koi8_r',
     ],
     'koi8-u': [
-      'koi8-ru'
+      'koi8-ru',
     ],
     'macintosh': [
       'csmacintosh',
       'mac',
-      'x-mac-roman'
+      'x-mac-roman',
     ],
     'windows-874': [
       'dos-874',
       'iso-8859-11',
       'iso8859-11',
       'iso885911',
-      'tis-620'
+      'tis-620',
     ],
     'windows-1250': [
       'cp1250',
-      'x-cp1250'
+      'x-cp1250',
     ],
     'windows-1251': [
       'cp1251',
-      'x-cp1251'
+      'x-cp1251',
     ],
     'windows-1252': [
       'ansi_x3.4-1968',
@@ -175,11 +175,11 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'l1',
       'latin1',
       'us-ascii',
-      'x-cp1252'
+      'x-cp1252',
     ],
     'windows-1253': [
       'cp1253',
-      'x-cp1253'
+      'x-cp1253',
     ],
     'windows-1254': [
       'cp1254',
@@ -192,26 +192,26 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso_8859-9:1989',
       'l5',
       'latin5',
-      'x-cp1254'
+      'x-cp1254',
     ],
     'windows-1255': [
       'cp1255',
-      'x-cp1255'
+      'x-cp1255',
     ],
     'windows-1256': [
       'cp1256',
-      'x-cp1256'
+      'x-cp1256',
     ],
     'windows-1257': [
       'cp1257',
-      'x-cp1257'
+      'x-cp1257',
     ],
     'windows-1258': [
       'cp1258',
-      'x-cp1258'
+      'x-cp1258',
     ],
     'x-mac-cyrillic': [
-      'x-mac-ukrainian'
+      'x-mac-ukrainian',
     ],
     'gbk': [
       'chinese',
@@ -221,21 +221,21 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'gb_2312',
       'gb_2312-80',
       'iso-ir-58',
-      'x-gbk'
+      'x-gbk',
     ],
     'gb18030': [ ],
     'big5': [
       'big5-hkscs',
       'cn-big5',
       'csbig5',
-      'x-x-big5'
+      'x-x-big5',
     ],
     'euc-jp': [
       'cseucpkdfmtjapanese',
-      'x-euc-jp'
+      'x-euc-jp',
     ],
     'iso-2022-jp': [
-      'csiso2022jp'
+      'csiso2022jp',
     ],
     'shift_jis': [
       'csshiftjis',
@@ -244,7 +244,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'shift-jis',
       'sjis',
       'windows-31j',
-      'x-sjis'
+      'x-sjis',
     ],
     'euc-kr': [
       '  euc-kr  \t',
@@ -257,7 +257,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'ks_c_5601-1989',
       'ksc5601',
       'ksc_5601',
-      'windows-949'
+      'windows-949',
     ]
   };
   Object.entries(mappings).forEach((i) => {
diff --git a/test/parallel/test-whatwg-encoding-custom-textdecoder-api-invalid-label.js b/test/parallel/test-whatwg-encoding-custom-textdecoder-api-invalid-label.js
index 3323f5b3d126f4aaa291838f3053e907f764910b..a701d79a285a16eac476dcd702a03bc008824056 100644
--- a/test/parallel/test-whatwg-encoding-custom-textdecoder-api-invalid-label.js
+++ b/test/parallel/test-whatwg-encoding-custom-textdecoder-api-invalid-label.js
@@ -11,7 +11,7 @@ const assert = require('assert');
   'utf8',
   'utf-16be',
   'utf-16le',
-  'utf-16'
+  'utf-16',
 ].forEach((i) => {
   ['\u0000', '\u000b', '\u00a0', '\u2028', '\u2029'].forEach((ws) => {
     assert.throws(
diff --git a/test/parallel/test-whatwg-encoding-custom-textdecoder-ignorebom.js b/test/parallel/test-whatwg-encoding-custom-textdecoder-ignorebom.js
index 9f6368dcd5e93f8e17a43c0a736bea2aee78c9b0..94fc3318d1f15e6cc4c72a19cf10daffb2f60ede 100644
--- a/test/parallel/test-whatwg-encoding-custom-textdecoder-ignorebom.js
+++ b/test/parallel/test-whatwg-encoding-custom-textdecoder-ignorebom.js
@@ -15,7 +15,7 @@ const cases = [
   {
     encoding: 'utf-16le',
     bytes: [0xFF, 0xFE, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00]
-  }
+  },
 ];
 
 cases.forEach((testCase) => {
diff --git a/test/parallel/test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js b/test/parallel/test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js
index f4d9ef8d42dced7896126cf16490c6d25d9dd909..2a8eac5f1874061bf52fa2726ff2c2d55a5217e1 100644
--- a/test/parallel/test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js
+++ b/test/parallel/test-whatwg-encoding-custom-textdecoder-utf16-surrogates.js
@@ -40,7 +40,7 @@ const bad = [
     input: [0x00, 0xdc, 0x00, 0xd8],
     expected: '\uFFFD\uFFFD',
     name: 'swapped surrogate pair'
-  }
+  },
 ];
 
 bad.forEach((t) => {
diff --git a/test/parallel/test-whatwg-encoding-custom-textdecoder.js b/test/parallel/test-whatwg-encoding-custom-textdecoder.js
index d16fd24bcd373998e08e888eb99c9a3d3bf6cf4f..877cd43734451b4b4ca8093ddad069c3218aeb3d 100644
--- a/test/parallel/test-whatwg-encoding-custom-textdecoder.js
+++ b/test/parallel/test-whatwg-encoding-custom-textdecoder.js
@@ -85,6 +85,7 @@ if (common.hasIntl) {
   assert.strictEqual(dec.encoding, 'utf-8');
   assert.strictEqual(dec.fatal, false);
   assert.strictEqual(dec.ignoreBOM, false);
+  assert.strictEqual(dec[Symbol.toStringTag], 'TextDecoder');
 }
 
 // Test TextDecoder, UTF-16le
@@ -125,10 +126,7 @@ if (common.hasIntl) {
       '  [Symbol(flags)]: 4,\n' +
       '  [Symbol(handle)]: StringDecoder {\n' +
       "    encoding: 'utf8',\n" +
-      '    [Symbol(kNativeDecoder)]: <Buffer 00 00 00 00 00 00 01>,\n' +
-      '    lastChar: [Getter],\n' +
-      '    lastNeed: [Getter],\n' +
-      '    lastTotal: [Getter]\n' +
+      '    [Symbol(kNativeDecoder)]: <Buffer 00 00 00 00 00 00 01>\n' +
       '  }\n' +
       '}'
     );
diff --git a/test/parallel/test-whatwg-url-constructor.js b/test/parallel/test-whatwg-url-constructor.js
index 282679d7797f2a01e1dd1135bcfb5a829c406ffb..3dc1c5986027e7427fe73415f48028bb955e7f1a 100644
--- a/test/parallel/test-whatwg-url-constructor.js
+++ b/test/parallel/test-whatwg-url-constructor.js
@@ -6,7 +6,6 @@ if (!common.hasIntl) {
 }
 
 const fixtures = require('../common/fixtures');
-const { URL, URLSearchParams } = require('url');
 const { test, assert_equals, assert_true, assert_throws } =
   require('../common/wpt').harness;
 
@@ -16,11 +15,11 @@ const request = {
   )
 };
 
-/* The following tests are copied from WPT. Modifications to them should be
-   upstreamed first. Refs:
-   https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-constructor.html
-   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
-*/
+// The following tests are copied from WPT. Modifications to them should be
+// upstreamed first.
+// Refs: https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-constructor.html
+// License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+
 /* eslint-disable */
 function runURLConstructorTests() {
   // var setup = async_test("Loading data…")
diff --git a/test/parallel/test-whatwg-url-custom-global.js b/test/parallel/test-whatwg-url-custom-global.js
index c79723f0490e07fcd8c465b97fb317e9f6dd0e0a..b99dfd8f3e7d94c3545a90d7595c8c5fa1a9d8f0 100644
--- a/test/parallel/test-whatwg-url-custom-global.js
+++ b/test/parallel/test-whatwg-url-custom-global.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const { URL, URLSearchParams } = require('url');
 
 assert.deepStrictEqual(
   Object.getOwnPropertyDescriptor(global, 'URL'),
diff --git a/test/parallel/test-whatwg-url-custom-inspect.js b/test/parallel/test-whatwg-url-custom-inspect.js
index 318b8b66d5672a1cbd90b087f59902cc7e588169..ad77f5725d30ed6b5c1eb0f3f14c912f7d248143 100644
--- a/test/parallel/test-whatwg-url-custom-inspect.js
+++ b/test/parallel/test-whatwg-url-custom-inspect.js
@@ -9,7 +9,6 @@ if (!common.hasIntl) {
 }
 
 const util = require('util');
-const URL = require('url').URL;
 const assert = require('assert');
 
 const url = new URL('https://username:password@host.name:8080/path/name/?que=ry#hash');
diff --git a/test/parallel/test-whatwg-url-custom-parsing.js b/test/parallel/test-whatwg-url-custom-parsing.js
index 2799a9caef3efe360dfc605bb2ae84dedcd9e30d..a07d776d0a25cccc9b42f438de2eaa59217ea382 100644
--- a/test/parallel/test-whatwg-url-custom-parsing.js
+++ b/test/parallel/test-whatwg-url-custom-parsing.js
@@ -8,7 +8,6 @@ if (!common.hasIntl) {
   common.skip('missing Intl');
 }
 
-const URL = require('url').URL;
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 
@@ -30,7 +29,7 @@ const typeFailures = [
   { input: new RegExp() },
   { input: 'test', base: null },
   { input: 'http://nodejs.org', base: null },
-  { input: () => {} }
+  { input: () => {} },
 ];
 
 // See https://github.com/w3c/web-platform-tests/pull/10955
diff --git a/test/parallel/test-whatwg-url-custom-properties.js b/test/parallel/test-whatwg-url-custom-properties.js
index 23742a8e7493e22ed2c6cd73e5f6ef156aecf7ff..82f07544148a206e979a42b7ee746ef8681a4526 100644
--- a/test/parallel/test-whatwg-url-custom-properties.js
+++ b/test/parallel/test-whatwg-url-custom-properties.js
@@ -4,9 +4,7 @@
 // Tests below are not from WPT.
 
 require('../common');
-const URL = require('url').URL;
 const assert = require('assert');
-const urlToOptions = require('internal/url').urlToOptions;
 
 const url = new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test');
 const oldParams = url.searchParams;  // For test of [SameObject]
@@ -131,41 +129,6 @@ assert.strictEqual(url.toString(),
 assert.strictEqual((delete url.searchParams), true);
 assert.strictEqual(url.searchParams, oldParams);
 
-// Test urlToOptions
-{
-  const urlObj = new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test');
-  const opts = urlToOptions(urlObj);
-  assert.strictEqual(opts instanceof URL, false);
-  assert.strictEqual(opts.protocol, 'http:');
-  assert.strictEqual(opts.auth, 'user:pass');
-  assert.strictEqual(opts.hostname, 'foo.bar.com');
-  assert.strictEqual(opts.port, 21);
-  assert.strictEqual(opts.path, '/aaa/zzz?l=24');
-  assert.strictEqual(opts.pathname, '/aaa/zzz');
-  assert.strictEqual(opts.search, '?l=24');
-  assert.strictEqual(opts.hash, '#test');
-
-  const { hostname } = urlToOptions(new URL('http://[::1]:21'));
-  assert.strictEqual(hostname, '::1');
-
-  // If a WHATWG URL object is copied, it is possible that the resulting copy
-  // contains the Symbols that Node uses for brand checking, but not the data
-  // properties, which are getters. Verify that urlToOptions() can handle such
-  // a case.
-  const copiedUrlObj = { ...urlObj };
-  const copiedOpts = urlToOptions(copiedUrlObj);
-  assert.strictEqual(copiedOpts instanceof URL, false);
-  assert.strictEqual(copiedOpts.protocol, undefined);
-  assert.strictEqual(copiedOpts.auth, undefined);
-  assert.strictEqual(copiedOpts.hostname, undefined);
-  assert.strictEqual(copiedOpts.port, NaN);
-  assert.strictEqual(copiedOpts.path, '');
-  assert.strictEqual(copiedOpts.pathname, undefined);
-  assert.strictEqual(copiedOpts.search, undefined);
-  assert.strictEqual(copiedOpts.hash, undefined);
-  assert.strictEqual(copiedOpts.href, undefined);
-}
-
 // Test special origins
 [
   { expected: 'https://whatwg.org',
@@ -177,7 +140,7 @@ assert.strictEqual(url.searchParams, oldParams);
   { expected: 'ws://example.org', url: 'ws://example.org/foo' },
   { expected: 'wss://example.org', url: 'wss://example.org/foo' },
   { expected: 'null', url: 'file:///tmp/mock/path' },
-  { expected: 'null', url: 'npm://nodejs/rules' }
+  { expected: 'null', url: 'npm://nodejs/rules' },
 ].forEach((test) => {
   assert.strictEqual(new URL(test.url).origin, test.expected);
 });
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-append.js b/test/parallel/test-whatwg-url-custom-searchparams-append.js
index cf93950ebd514c817df4dce33ac93d47971e1e72..5d2976a23cad53710e29f554f30e121705aab833 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-append.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-append.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-constructor.js b/test/parallel/test-whatwg-url-custom-searchparams-constructor.js
index ab065814179d3f5fe0261c1b2d71d3c441d46afd..878caed43ff0ab6661eaccd219b8978a1e4cca8b 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-constructor.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-constructor.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 function makeIterableFunc(array) {
   return Object.assign(() => {}, {
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-delete.js b/test/parallel/test-whatwg-url-custom-searchparams-delete.js
index 5c3088b0363ff1df05a10d12c143533237df1158..e84f10e3f93df88bae98a5d782605628f50e69bf 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-delete.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-delete.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const { URL, URLSearchParams } = require('url');
 
 {
   const params = new URLSearchParams();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-entries.js b/test/parallel/test-whatwg-url-custom-searchparams-entries.js
index b70717ff2b78c1183d66d591626db90ebf3a2222..6e5dabb1a768c4d64ae135d983140daa016751fc 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-entries.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-entries.js
@@ -2,7 +2,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 // Tests below are not from WPT.
 const params = new URLSearchParams('a=b&c=d');
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-foreach.js b/test/parallel/test-whatwg-url-custom-searchparams-foreach.js
index b796cff9bc1b5cb3700cf74139267dc00cd27139..0c035161dbea9708a734e6b56b7e8a2c5c7a9635 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-foreach.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-foreach.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const { URLSearchParams } = require('url');
 
 {
   const params = new URLSearchParams();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-get.js b/test/parallel/test-whatwg-url-custom-searchparams-get.js
index 1088fcc43d439a918826cd947bc90c4f296f815a..4ce16805ceceb956a8ce5694638968833ae215ad 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-get.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-get.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-getall.js b/test/parallel/test-whatwg-url-custom-searchparams-getall.js
index 8d229a25979d6c4d122907d362fff7f828c8d16c..d3f271fcc5dc7b831a2df0b7d62b4368a6860eb0 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-getall.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-getall.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-has.js b/test/parallel/test-whatwg-url-custom-searchparams-has.js
index 4a76dda6d3dc483d33edd4b606fd5479445491f7..1963e40057ef722eda3197ce8b3870adce7aa2a0 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-has.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-has.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-inspect.js b/test/parallel/test-whatwg-url-custom-searchparams-inspect.js
index 6cc22caea624369a114a67ec45e053a7e52013a4..c03890938d9cfe4402f0cd43027bbb1fc24f6599 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-inspect.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-inspect.js
@@ -5,7 +5,6 @@
 require('../common');
 const assert = require('assert');
 const util = require('util');
-const URLSearchParams = require('url').URLSearchParams;
 
 const sp = new URLSearchParams('?a=a&b=b&b=c');
 assert.strictEqual(util.inspect(sp),
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-keys.js b/test/parallel/test-whatwg-url-custom-searchparams-keys.js
index 5a222c7428eac720ea5f3f9e12857745693a08ba..b65e71c9a24153dbba7179c3322c4203063f758e 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-keys.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-keys.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 const params = new URLSearchParams('a=b&c=d');
 const keys = params.keys();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-set.js b/test/parallel/test-whatwg-url-custom-searchparams-set.js
index 39462bf488006508c2e9a6012438c368040e5b78..106e94d6a249a9a4e92e9876aa2b9b300e993785 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-set.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-set.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-sort.js b/test/parallel/test-whatwg-url-custom-searchparams-sort.js
index 49c3b065f957c6001e2db0230196271ee363ec28..e0b0c5c1ed12f615d6502df54c85e783890ad7dc 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-sort.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-sort.js
@@ -3,7 +3,6 @@
 // Tests below are not from WPT.
 
 require('../common');
-const { URL, URLSearchParams } = require('url');
 const { test, assert_array_equals } = require('../common/wpt').harness;
 
 // TODO(joyeecheung): upstream this to WPT, if possible - even
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-stringifier.js b/test/parallel/test-whatwg-url-custom-searchparams-stringifier.js
index 35307fa914975a729a2a03cf5562bbcb64a11f29..e46865e8b014eb0cf3d8e02faafb8c3475ef80f5 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-stringifier.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-stringifier.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-values.js b/test/parallel/test-whatwg-url-custom-searchparams-values.js
index eedad691fa351c7f37813b44720795a7e71f8da7..9c4bb05d0e587da299691b84a6ca29dcbc76eb95 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-values.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-values.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URLSearchParams = require('url').URLSearchParams;
 
 const params = new URLSearchParams('a=b&c=d');
 const values = params.values();
diff --git a/test/parallel/test-whatwg-url-custom-searchparams.js b/test/parallel/test-whatwg-url-custom-searchparams.js
index 39c8d87b6a60bfed59ea9a8fc86fbd356e7b52db..272435b001a36683e1e471a308c635f6796dcbe0 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const { URL, URLSearchParams } = require('url');
 const fixtures = require('../common/fixtures');
 
 const serialized = 'a=a&a=1&a=true&a=undefined&a=null&a=%EF%BF%BD' +
diff --git a/test/parallel/test-whatwg-url-custom-setters.js b/test/parallel/test-whatwg-url-custom-setters.js
index e10ebb9fe669689cd5745f8bc903aa66a7c5bc47..b98bf5d8d3b3939d54a489e884f9b01b62acb10d 100644
--- a/test/parallel/test-whatwg-url-custom-setters.js
+++ b/test/parallel/test-whatwg-url-custom-setters.js
@@ -9,7 +9,6 @@ if (!common.hasIntl) {
 }
 
 const assert = require('assert');
-const URL = require('url').URL;
 const { test, assert_equals } = require('../common/wpt').harness;
 const fixtures = require('../common/fixtures');
 
diff --git a/test/parallel/test-whatwg-url-custom-tostringtag.js b/test/parallel/test-whatwg-url-custom-tostringtag.js
index 784a3ebc7728e5bf91d39f15bc414290b1274c5c..54e5850a8f07b9b03df417aaa4a04880d887526d 100644
--- a/test/parallel/test-whatwg-url-custom-tostringtag.js
+++ b/test/parallel/test-whatwg-url-custom-tostringtag.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const URL = require('url').URL;
 
 const toString = Object.prototype.toString;
 
diff --git a/test/parallel/test-whatwg-url-origin.js b/test/parallel/test-whatwg-url-origin.js
index 5b1aa14cd07642dcbe5f1c18c93734862d0be3ed..532ff06bb1152f58dfb331ef3587af6642f3ee1b 100644
--- a/test/parallel/test-whatwg-url-origin.js
+++ b/test/parallel/test-whatwg-url-origin.js
@@ -6,7 +6,6 @@ if (!common.hasIntl) {
 }
 
 const fixtures = require('../common/fixtures');
-const URL = require('url').URL;
 const { test, assert_equals } = require('../common/wpt').harness;
 
 const request = {
@@ -15,11 +14,11 @@ const request = {
   )
 };
 
-/* The following tests are copied from WPT. Modifications to them should be
-   upstreamed first. Refs:
-   https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-origin.html
-   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
-*/
+// The following tests are copied from WPT. Modifications to them should be
+// upstreamed first.
+// Refs: https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-origin.html
+// License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+
 /* eslint-disable */
 function runURLOriginTests() {
   // var setup = async_test("Loading data…")
diff --git a/test/parallel/test-whatwg-url-override-hostname.js b/test/parallel/test-whatwg-url-override-hostname.js
new file mode 100644
index 0000000000000000000000000000000000000000..61e3412c6b7b53c662297431a491621650043677
--- /dev/null
+++ b/test/parallel/test-whatwg-url-override-hostname.js
@@ -0,0 +1,20 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+{
+  const url = new (class extends URL { get hostname() { return 'bar.com'; } })('http://foo.com/');
+  assert.strictEqual(url.href, 'http://foo.com/');
+  assert.strictEqual(url.toString(), 'http://foo.com/');
+  assert.strictEqual(url.toJSON(), 'http://foo.com/');
+  assert.strictEqual(url.hash, '');
+  assert.strictEqual(url.host, 'foo.com');
+  assert.strictEqual(url.hostname, 'bar.com');
+  assert.strictEqual(url.origin, 'http://foo.com');
+  assert.strictEqual(url.password, '');
+  assert.strictEqual(url.protocol, 'http:');
+  assert.strictEqual(url.username, '');
+  assert.strictEqual(url.search, '');
+  assert.strictEqual(url.searchParams.toString(), '');
+}
diff --git a/test/parallel/test-whatwg-url-setters.js b/test/parallel/test-whatwg-url-setters.js
index 13422bd77690ed478ab60696b962de94bcd51ec9..8742ab8ed372de58f5fcdb66bbab22dc9c748f8a 100644
--- a/test/parallel/test-whatwg-url-setters.js
+++ b/test/parallel/test-whatwg-url-setters.js
@@ -6,7 +6,6 @@ if (!common.hasIntl) {
   common.skip('missing Intl');
 }
 
-const URL = require('url').URL;
 const { test, assert_equals } = require('../common/wpt').harness;
 const fixtures = require('../common/fixtures');
 
@@ -16,11 +15,11 @@ const request = {
   ))
 };
 
-/* The following tests are copied from WPT. Modifications to them should be
-   upstreamed first. Refs:
-   https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-setters.html
-   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
-*/
+// The following tests are copied from WPT. Modifications to them should be
+// upstreamed first.
+// Refs: https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-setters.html
+// License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+
 /* eslint-disable */
 function startURLSettersTests() {
 //   var setup = async_test("Loading data…")
diff --git a/test/parallel/test-whatwg-url-toascii.js b/test/parallel/test-whatwg-url-toascii.js
index 4869ab3f1d3bd1075d4de3bcefd6bba903614178..e5180bfb3441279f848683bbe5a3ef42c57b65ac 100644
--- a/test/parallel/test-whatwg-url-toascii.js
+++ b/test/parallel/test-whatwg-url-toascii.js
@@ -6,7 +6,6 @@ if (!common.hasIntl) {
 }
 
 const fixtures = require('../common/fixtures');
-const { URL } = require('url');
 const { test, assert_equals, assert_throws } = require('../common/wpt').harness;
 
 const request = {
@@ -15,11 +14,11 @@ const request = {
   )
 };
 
-/* The following tests are copied from WPT. Modifications to them should be
-   upstreamed first. Refs:
-   https://github.com/w3c/web-platform-tests/blob/4839a0a804/url/toascii.window.js
-   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
-*/
+// The following tests are copied from WPT. Modifications to them should be
+// upstreamed first.
+// Refs: https://github.com/w3c/web-platform-tests/blob/4839a0a804/url/toascii.window.js
+// License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+
 /* eslint-disable */
 // async_test(t => {
 //   const request = new XMLHttpRequest()
diff --git a/test/parallel/test-worker-beforeexit-throw-exit.js b/test/parallel/test-worker-beforeexit-throw-exit.js
new file mode 100644
index 0000000000000000000000000000000000000000..2aa255ee82af8a90f2f0bbf811ffc3dba287a93a
--- /dev/null
+++ b/test/parallel/test-worker-beforeexit-throw-exit.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Test that 'exit' is emitted if 'beforeExit' throws, both inside the Worker.
+
+const workerData = new Uint8Array(new SharedArrayBuffer(2));
+const w = new Worker(`
+  const { workerData } = require('worker_threads');
+  process.on('exit', () => {
+    workerData[0] = 100;
+  });
+  process.on('beforeExit', () => {
+    workerData[1] = 200;
+    throw new Error('banana');
+  });
+`, { eval: true, workerData });
+
+w.on('error', common.mustCall((err) => {
+  assert.strictEqual(err.message, 'banana');
+}));
+
+w.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 1);
+  assert.strictEqual(workerData[0], 100);
+  assert.strictEqual(workerData[1], 200);
+}));
diff --git a/test/parallel/test-worker-cleanexit-with-moduleload.js b/test/parallel/test-worker-cleanexit-with-moduleload.js
index 0de9ad71d3dc7b2a51c258121ddd54a0d48d79c3..f2e8ad786f1a88d089b1ff131509505f21ed2b1c 100644
--- a/test/parallel/test-worker-cleanexit-with-moduleload.js
+++ b/test/parallel/test-worker-cleanexit-with-moduleload.js
@@ -10,7 +10,7 @@ const common = require('../common');
 
 const { Worker } = require('worker_threads');
 const modules = [ 'fs', 'assert', 'async_hooks', 'buffer', 'child_process',
-                  'net', 'http', 'os', 'path', 'v8', 'vm'
+                  'net', 'http', 'os', 'path', 'v8', 'vm',
 ];
 if (common.hasCrypto) {
   modules.push('https');
diff --git a/test/parallel/test-worker-data-url.js b/test/parallel/test-worker-data-url.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe73ba8824ba07d8f38ca4b9ac20358448edbe91
--- /dev/null
+++ b/test/parallel/test-worker-data-url.js
@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common');
+const { Worker } = require('worker_threads');
+const assert = require('assert');
+
+new Worker(new URL('data:text/javascript,'))
+  .on('error', common.mustNotCall(() => {}));
+new Worker(new URL('data:text/javascript,export{}'))
+  .on('error', common.mustNotCall(() => {}));
+
+new Worker(new URL('data:text/plain,'))
+  .on('error', common.mustCall(() => {}));
+new Worker(new URL('data:text/javascript,module.exports={}'))
+  .on('error', common.mustCall(() => {}));
+
+new Worker(new URL('data:text/javascript,await Promise.resolve()'))
+  .on('error', common.mustNotCall(() => {}));
+new Worker(new URL('data:text/javascript,await Promise.reject()'))
+  .on('error', common.mustCall(() => {}));
+new Worker(new URL('data:text/javascript,await new Promise(()=>{})'))
+  .on(
+    'exit',
+    common.mustCall((exitCode) => { assert.strictEqual(exitCode, 13); })
+  );
diff --git a/test/parallel/test-worker-debug.js b/test/parallel/test-worker-debug.js
index 1d7bb9bb185e66cd7f23545c4d8475c7fdc10b24..758d7acfc3a99f74a5b471f20273768eaae6e0b0 100644
--- a/test/parallel/test-worker-debug.js
+++ b/test/parallel/test-worker-debug.js
@@ -128,14 +128,12 @@ class WorkerSession extends EventEmitter {
 }
 
 async function testBasicWorkerDebug(session, post) {
-  /*
-    1. Do 'enable' with waitForDebuggerOnStart = true
-    2. Run worker. It should break on start.
-    3. Enable Runtime (to get console message) and Debugger. Resume.
-    4. Breaks on the 'debugger' statement. Resume.
-    5. Console message received, worker runs to a completion.
-    6. contextCreated/contextDestroyed had been properly dispatched
-  */
+  // 1. Do 'enable' with waitForDebuggerOnStart = true
+  // 2. Run worker. It should break on start.
+  // 3. Enable Runtime (to get console message) and Debugger. Resume.
+  // 4. Breaks on the 'debugger' statement. Resume.
+  // 5. Console message received, worker runs to a completion.
+  // 6. contextCreated/contextDestroyed had been properly dispatched
   console.log('Test basic debug scenario');
   await post('NodeWorker.enable', { waitForDebuggerOnStart: true });
   const attached = waitForWorkerAttach(session);
@@ -146,7 +144,7 @@ async function testBasicWorkerDebug(session, post) {
   const workerSession = new WorkerSession(session, sessionId);
   const contextEventPromises = Promise.all([
     waitForEvent(workerSession, 'Runtime.executionContextCreated'),
-    waitForEvent(workerSession, 'Runtime.executionContextDestroyed')
+    waitForEvent(workerSession, 'Runtime.executionContextDestroyed'),
   ]);
   const consolePromise = waitForEvent(workerSession, 'Runtime.consoleAPICalled')
       .then((notification) => notification.params.args[0].value);
@@ -221,7 +219,7 @@ async function testWaitForDisconnectInWorker(session, post) {
 
   const attached = [
     waitForWorkerAttach(session),
-    waitForWorkerAttach(sessionWithoutWaiting)
+    waitForWorkerAttach(sessionWithoutWaiting),
   ];
 
   let worker = null;
diff --git a/test/parallel/test-worker-environmentdata.js b/test/parallel/test-worker-environmentdata.js
new file mode 100644
index 0000000000000000000000000000000000000000..cac97b746acef8d02f7516e18cc0532aa01ad298
--- /dev/null
+++ b/test/parallel/test-worker-environmentdata.js
@@ -0,0 +1,33 @@
+'use strict';
+
+require('../common');
+const {
+  Worker,
+  getEnvironmentData,
+  setEnvironmentData,
+  threadId,
+} = require('worker_threads');
+
+const {
+  deepStrictEqual,
+  strictEqual,
+} = require('assert');
+
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  setEnvironmentData('foo', 'bar');
+  setEnvironmentData('hello', { value: 'world' });
+  setEnvironmentData(1, 2);
+  strictEqual(getEnvironmentData(1), 2);
+  setEnvironmentData(1); // Delete it, key won't show up in the worker.
+  new Worker(__filename);
+  setEnvironmentData('hello');  // Delete it. Has no impact on the worker.
+} else {
+  strictEqual(getEnvironmentData('foo'), 'bar');
+  deepStrictEqual(getEnvironmentData('hello'), { value: 'world' });
+  strictEqual(getEnvironmentData(1), undefined);
+
+  // Recurse to make sure the environment data is inherited
+  if (threadId <= 2)
+    new Worker(__filename);
+}
diff --git a/test/parallel/test-worker-event.js b/test/parallel/test-worker-event.js
new file mode 100644
index 0000000000000000000000000000000000000000..01e95ead8316cb8107d15e846e9b95aee9ec7db3
--- /dev/null
+++ b/test/parallel/test-worker-event.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const {
+  Worker,
+  threadId: parentThreadId,
+} = require('worker_threads');
+
+process.on('worker', common.mustCall(({ threadId }) => {
+  assert.strictEqual(threadId, parentThreadId + 1);
+}));
+
+new Worker('', { eval: true });
diff --git a/test/parallel/test-worker-execargv-invalid.js b/test/parallel/test-worker-execargv-invalid.js
index bbad565c4f0c5fb9a2eb2b6d2981b2d96e3496df..be8ab0b8c423b7dad80f35c42150fc2b7c3ee740 100644
--- a/test/parallel/test-worker-execargv-invalid.js
+++ b/test/parallel/test-worker-execargv-invalid.js
@@ -33,3 +33,17 @@ const { Worker } = require('worker_threads');
     new Worker(__filename, { execArgv: ['--redirect-warnings'] });
   }, expectedErr);
 }
+
+{
+  const expectedErr = {
+    code: 'ERR_WORKER_INVALID_EXEC_ARGV',
+    name: 'Error'
+  };
+  assert.throws(() => {
+    new Worker(__filename, {
+      env: {
+        NODE_OPTIONS: '--nonexistent-options'
+      }
+    });
+  }, expectedErr);
+}
diff --git a/test/parallel/test-worker-exit-code.js b/test/parallel/test-worker-exit-code.js
index 6107cd0316b250e27217b8e75f65b28f67f4cf18..db8986f9ef6c92084ee0b791350b9ae84ea487c3 100644
--- a/test/parallel/test-worker-exit-code.js
+++ b/test/parallel/test-worker-exit-code.js
@@ -8,7 +8,8 @@ const assert = require('assert');
 const worker = require('worker_threads');
 const { Worker, parentPort } = worker;
 
-const testCases = require('../fixtures/process-exit-code-cases');
+const { getTestCases } = require('../fixtures/process-exit-code-cases');
+const testCases = getTestCases(true);
 
 // Do not use isMainThread so that this test itself can be run inside a Worker.
 if (!process.env.HAS_STARTED_WORKER) {
diff --git a/test/parallel/test-worker-message-port-close.js b/test/parallel/test-worker-message-port-close.js
index 17a10559e4e61dcc8319085d106226db1c27072d..6abc01d1b7b56885d5b9e803a089d12615c15eb5 100644
--- a/test/parallel/test-worker-message-port-close.js
+++ b/test/parallel/test-worker-message-port-close.js
@@ -1,6 +1,7 @@
 'use strict';
 const common = require('../common');
-const { MessageChannel } = require('worker_threads');
+const assert = require('assert');
+const { MessageChannel, moveMessagePortToContext } = require('worker_threads');
 
 // Make sure that .start() and .stop() do not throw on closing/closed
 // MessagePorts.
@@ -29,3 +30,12 @@ function dummy() {}
     port1.off('message', dummy);
   }));
 }
+
+{
+  const { port2 } = new MessageChannel();
+  port2.close();
+  assert.throws(() => moveMessagePortToContext(port2, {}), {
+    code: 'ERR_CLOSED_MESSAGE_PORT',
+    message: 'Cannot send data on closed MessagePort'
+  });
+}
diff --git a/test/parallel/test-worker-message-port-inspect-during-init-hook.js b/test/parallel/test-worker-message-port-inspect-during-init-hook.js
index 30b90710a604f144844c6ba02447e60d90c5ba8b..8f9678de1e970e7cb03df9d65da08628be670a2a 100644
--- a/test/parallel/test-worker-message-port-inspect-during-init-hook.js
+++ b/test/parallel/test-worker-message-port-inspect-during-init-hook.js
@@ -10,8 +10,9 @@ const { MessageChannel } = require('worker_threads');
 
 async_hooks.createHook({
   init: common.mustCall((id, type, triggerId, resource) => {
-    assert.strictEqual(util.inspect(resource),
-                       'MessagePort { active: true, refed: false }');
+    assert.strictEqual(
+      util.inspect(resource),
+      'MessagePort [EventTarget] { active: true, refed: false }');
   }, 2)
 }).enable();
 
diff --git a/test/parallel/test-worker-message-port-multiple-sharedarraybuffers.js b/test/parallel/test-worker-message-port-multiple-sharedarraybuffers.js
index eb68236e4d6788e40d7131e618452ddc546123e0..efec7f0190d2e5d4cb282b0d5bc2537085a38b00 100644
--- a/test/parallel/test-worker-message-port-multiple-sharedarraybuffers.js
+++ b/test/parallel/test-worker-message-port-multiple-sharedarraybuffers.js
@@ -7,7 +7,7 @@ const { MessageChannel } = require('worker_threads');
 
 const obj = [
   [ new SharedArrayBuffer(0), new SharedArrayBuffer(1) ],
-  [ new SharedArrayBuffer(2), new SharedArrayBuffer(3) ]
+  [ new SharedArrayBuffer(2), new SharedArrayBuffer(3) ],
 ];
 
 const { port1, port2 } = new MessageChannel();
diff --git a/test/parallel/test-worker-message-port-receive-message.js b/test/parallel/test-worker-message-port-receive-message.js
index e7078ea1e67ee5bab1f295a7684bd371d7131858..8e5dc91a0790ae521c111206f328e8a8c3318bc1 100644
--- a/test/parallel/test-worker-message-port-receive-message.js
+++ b/test/parallel/test-worker-message-port-receive-message.js
@@ -28,6 +28,6 @@ for (const value of [null, 0, -1, {}, []]) {
   assert.throws(() => receiveMessageOnPort(value), {
     name: 'TypeError',
     code: 'ERR_INVALID_ARG_TYPE',
-    message: 'First argument needs to be a MessagePort instance'
+    message: 'The "port" argument must be a MessagePort instance'
   });
 }
diff --git a/test/parallel/test-worker-message-port-transfer-filehandle.js b/test/parallel/test-worker-message-port-transfer-filehandle.js
index 157acb22e8ad55bde07b6c8457e8291ba4efe824..32f086a7f5d32c6f96a86786caa8764435ce5d40 100644
--- a/test/parallel/test-worker-message-port-transfer-filehandle.js
+++ b/test/parallel/test-worker-message-port-transfer-filehandle.js
@@ -57,9 +57,9 @@ const { once } = require('events');
   });
   // TODO(addaleax): Switch this to a 'messageerror' event once MessagePort
   // implements EventTarget fully and in a cross-context manner.
-  port2moved.emit = common.mustCall((name, err) => {
-    assert.strictEqual(name, 'messageerror');
-    assert.strictEqual(err.code, 'ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE');
+  port2moved.onmessageerror = common.mustCall((event) => {
+    assert.strictEqual(event.data.code,
+                       'ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE');
   });
   port2moved.start();
 
@@ -69,3 +69,36 @@ const { once } = require('events');
 
   port1.postMessage('second message');
 })().then(common.mustCall());
+
+(async function() {
+  // Check that a FileHandle with a read in progress cannot be transferred.
+  const fh = await fs.open(__filename);
+
+  const { port1 } = new MessageChannel();
+
+  const readPromise = fh.readFile();
+  assert.throws(() => {
+    port1.postMessage(fh, [fh]);
+  }, {
+    message: 'Cannot transfer FileHandle while in use',
+    name: 'DataCloneError'
+  });
+
+  assert.deepStrictEqual(await readPromise, await fs.readFile(__filename));
+})().then(common.mustCall());
+
+(async function() {
+  // Check that filehandles with a close in progress cannot be transferred.
+  const fh = await fs.open(__filename);
+
+  const { port1 } = new MessageChannel();
+
+  const closePromise = fh.close();
+  assert.throws(() => {
+    port1.postMessage(fh, [fh]);
+  }, {
+    message: 'Cannot transfer FileHandle while in use',
+    name: 'DataCloneError'
+  });
+  await closePromise;
+})().then(common.mustCall());
diff --git a/test/parallel/test-worker-message-port.js b/test/parallel/test-worker-message-port.js
index d128dc7edb25fd2ec9e2807734300de1da040bcb..1b51aea701c0b2a77cc334154a0c1c86cea28a3b 100644
--- a/test/parallel/test-worker-message-port.js
+++ b/test/parallel/test-worker-message-port.js
@@ -16,7 +16,18 @@ const { MessageChannel, MessagePort } = require('worker_threads');
     port2.close(common.mustCall());
   }));
 }
-
+{
+  // Test emitting non-message events on a port
+  const { port2 } = new MessageChannel();
+  port2.addEventListener('foo', common.mustCall((received) => {
+    assert.strictEqual(received.type, 'foo');
+    assert.strictEqual(received.detail, 'bar');
+  }));
+  port2.on('foo', common.mustCall((received) => {
+    assert.strictEqual(received, 'bar');
+  }));
+  port2.emit('foo', 'bar');
+}
 {
   const { port1, port2 } = new MessageChannel();
 
@@ -154,7 +165,7 @@ const { MessageChannel, MessagePort } = require('worker_threads');
   assert.deepStrictEqual(
     Object.getOwnPropertyNames(MessagePort.prototype).sort(),
     [
-      'close', 'constructor', 'onmessage', 'postMessage', 'ref', 'start',
-      'unref'
+      'close', 'constructor', 'onmessage', 'onmessageerror', 'postMessage',
+      'ref', 'start', 'unref',
     ]);
 }
diff --git a/test/parallel/test-worker-nearheaplimit-deadlock.js b/test/parallel/test-worker-nearheaplimit-deadlock.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f38bc074da048a69195574b46d528a5dca39c6d
--- /dev/null
+++ b/test/parallel/test-worker-nearheaplimit-deadlock.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  const opts = {
+    resourceLimits: {
+      maxYoungGenerationSizeMb: 0,
+      maxOldGenerationSizeMb: 0
+    }
+  };
+
+  const worker = new Worker(__filename, opts);
+  worker.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_WORKER_OUT_OF_MEMORY');
+  }));
+} else {
+  setInterval(() => {}, 1);
+}
diff --git a/test/parallel/test-worker-no-stdin-stdout-interaction.js b/test/parallel/test-worker-no-stdin-stdout-interaction.js
index 6febbd07b566fa5de5969c29b7a2eb0cecb8a553..77c0feecdaca08e2698cd2c4f73e813d17f202ca 100644
--- a/test/parallel/test-worker-no-stdin-stdout-interaction.js
+++ b/test/parallel/test-worker-no-stdin-stdout-interaction.js
@@ -15,6 +15,6 @@ if (isMainThread) {
   process.stdin.on('data', () => {});
 
   for (let i = 0; i < 10; ++i) {
-    process.stdout.write(`processing(${i})\n`, common.mustCall());
+    process.stdout.write(`processing(${i})\n`, common.mustSucceed());
   }
 }
diff --git a/test/parallel/test-worker-process-argv.js b/test/parallel/test-worker-process-argv.js
index ebdebe02ab855c189b299cf8fbf9827a1a137cc7..0e541c453e2419e4bcc398c8f0d187886afe7f8c 100644
--- a/test/parallel/test-worker-process-argv.js
+++ b/test/parallel/test-worker-process-argv.js
@@ -35,7 +35,7 @@ if (isMainThread) {
     `, {
       argv: [null, 'foo', 123, Symbol('bar')],
       eval: true
-    })
+    }),
   ].forEach((worker) => {
     worker.on('exit', common.mustCall((code) => {
       assert.strictEqual(code, 0);
diff --git a/test/parallel/test-worker-process-cwd.js b/test/parallel/test-worker-process-cwd.js
index 3d6d1707f18c0f3c16b75fd466058a4bf79c68c0..e24515cce777a33b992e43543ade82f6b8f6bd1d 100644
--- a/test/parallel/test-worker-process-cwd.js
+++ b/test/parallel/test-worker-process-cwd.js
@@ -32,7 +32,7 @@ if (!process.env.HAS_STARTED_WORKER) {
   // 2. Save the current cwd and verify that `process.cwd` includes the
   //    Atomics.load call and spawn a new worker.
   const cwd = process.cwd();
-  assert(!process.cwd.toString().includes('Atomics.load'));
+  assert(process.cwd.toString().includes('Atomics.load'));
 
   const w = new Worker(__filename);
   w.once('message', common.mustCall((message) => {
@@ -56,7 +56,7 @@ if (!process.env.HAS_STARTED_WORKER) {
   const cwd = process.cwd();
   // Send the current cwd to the parent.
   parentPort.postMessage(cwd);
-  assert(!process.cwd.toString().includes('Atomics.load'));
+  assert(process.cwd.toString().includes('Atomics.load'));
 
   parentPort.once('message', common.mustCall((message) => {
     // 7. Verify that the current cwd is identical to the received one but
diff --git a/test/parallel/test-worker-resource-limits.js b/test/parallel/test-worker-resource-limits.js
index 0c168bbea1a4881de1b73d2e8dd9a1591fd8e9ad..ffda452f6c6335c33c85d9c98e36a569728d8a1c 100644
--- a/test/parallel/test-worker-resource-limits.js
+++ b/test/parallel/test-worker-resource-limits.js
@@ -35,9 +35,10 @@ if (!process.env.HAS_STARTED_WORKER) {
 assert.deepStrictEqual(resourceLimits, testResourceLimits);
 const array = [];
 while (true) {
-  // Leave 10 % wiggle room here.
+  // Leave 10% wiggle room here, and 20% on debug builds.
+  const wiggleRoom = common.buildType === 'Release' ? 1.1 : 1.2;
   const usedMB = v8.getHeapStatistics().used_heap_size / 1024 / 1024;
-  assert(usedMB < resourceLimits.maxOldGenerationSizeMb * 1.1);
+  assert(usedMB < resourceLimits.maxOldGenerationSizeMb * wiggleRoom);
 
   let seenSpaces = 0;
   for (const { space_name, space_size } of v8.getHeapSpaceStatistics()) {
diff --git a/test/parallel/test-worker-terminate-source-map.js b/test/parallel/test-worker-terminate-source-map.js
index 8cd40a6607422c38fb9dd20f303e41a8356c33cc..c855dab975be016d0eaf823eab780cd2d8d66654 100644
--- a/test/parallel/test-worker-terminate-source-map.js
+++ b/test/parallel/test-worker-terminate-source-map.js
@@ -27,16 +27,19 @@ const { callCount } = workerData;
 function increaseCallCount() { callCount[0]++; }
 
 // Increase the call count when a forbidden method is called.
-Object.getPrototypeOf((new Map()).entries()).next = increaseCallCount;
-Map.prototype.entries = increaseCallCount;
-Object.keys = increaseCallCount;
-Object.create = increaseCallCount;
-Object.hasOwnProperty = increaseCallCount;
 for (const property of ['_cache', 'lineLengths', 'url']) {
   Object.defineProperty(Object.prototype, property, {
     get: increaseCallCount,
     set: increaseCallCount
   });
 }
+Object.getPrototypeOf([][Symbol.iterator]()).next = increaseCallCount;
+Object.getPrototypeOf((new Map()).entries()).next = increaseCallCount;
+Array.prototype[Symbol.iterator] = increaseCallCount;
+Map.prototype[Symbol.iterator] = increaseCallCount;
+Map.prototype.entries = increaseCallCount;
+Object.keys = increaseCallCount;
+Object.create = increaseCallCount;
+Object.hasOwnProperty = increaseCallCount;
 
 parentPort.postMessage('done');
diff --git a/test/parallel/test-worker-type-check.js b/test/parallel/test-worker-type-check.js
index 88965f4be4c62d500713bb493708fb9e6b5b0f8f..9a718dfad055b44c33e069aaab255260e2dbdee8 100644
--- a/test/parallel/test-worker-type-check.js
+++ b/test/parallel/test-worker-type-check.js
@@ -13,7 +13,7 @@ const { Worker } = require('worker_threads');
     Symbol('test'),
     {},
     [],
-    () => {}
+    () => {},
   ].forEach((val) => {
     assert.throws(
       () => new Worker(val),
diff --git a/test/parallel/test-worker-unsupported-path.js b/test/parallel/test-worker-unsupported-path.js
index 1a5f53c821ee6c39121bcbde69b8a732dbd27708..227b759dcfe753a2b31b90d1362a757dc12a4a79 100644
--- a/test/parallel/test-worker-unsupported-path.js
+++ b/test/parallel/test-worker-unsupported-path.js
@@ -33,6 +33,10 @@ const { Worker } = require('worker_threads');
     () => { new Worker('file:///file_url'); },
     /Wrap file:\/\/ URLs with `new URL`/
   );
+  assert.throws(
+    () => { new Worker('data:text/javascript,'); },
+    /Wrap data: URLs with `new URL`/
+  );
   assert.throws(
     () => { new Worker('relative_no_dot'); },
     // eslint-disable-next-line node-core/no-unescaped-regexp-dot
@@ -47,6 +51,4 @@ const { Worker } = require('worker_threads');
   };
   assert.throws(() => { new Worker(new URL('https://www.url.com')); },
                 expectedErr);
-  assert.throws(() => { new Worker(new URL('data:application/javascript,')); },
-                expectedErr);
 }
diff --git a/test/parallel/test-worker-unsupported-things.js b/test/parallel/test-worker-unsupported-things.js
index cc9eec4af677602708ee5a35da60198a3fa5cc6f..18c1617c3cde5ef12f9c97828840c39e0be3dc2c 100644
--- a/test/parallel/test-worker-unsupported-things.js
+++ b/test/parallel/test-worker-unsupported-things.js
@@ -24,6 +24,14 @@ if (!process.env.HAS_STARTED_WORKER) {
     assert.strictEqual(process.debugPort, before);
   }
 
+  {
+    const mask = 0o600;
+    assert.throws(() => { process.umask(mask); }, {
+      code: 'ERR_WORKER_UNSUPPORTED_OPERATION',
+      message: 'Setting process.umask() is not supported in workers'
+    });
+  }
+
   const stubs = ['abort', 'chdir', 'send', 'disconnect'];
 
   if (!common.isWindows) {
@@ -35,13 +43,19 @@ if (!process.env.HAS_STARTED_WORKER) {
     assert.strictEqual(process[fn].disabled, true);
     assert.throws(() => {
       process[fn]();
-    }, { code: 'ERR_WORKER_UNSUPPORTED_OPERATION' });
+    }, {
+      code: 'ERR_WORKER_UNSUPPORTED_OPERATION',
+      message: `process.${fn}() is not supported in workers`
+    });
   });
 
   ['channel', 'connected'].forEach((fn) => {
     assert.throws(() => {
-      process[fn];
-    }, { code: 'ERR_WORKER_UNSUPPORTED_OPERATION' });
+      process[fn]; // eslint-disable-line no-unused-expressions
+    }, {
+      code: 'ERR_WORKER_UNSUPPORTED_OPERATION',
+      message: `process.${fn} is not supported in workers`
+    });
   });
 
   assert.strictEqual('_startProfilerIdleNotifier' in process, false);
diff --git a/test/parallel/test-wrap-js-stream-exceptions.js b/test/parallel/test-wrap-js-stream-exceptions.js
index eeab26f525ae5082b2e00a09226bbf3cba046292..b90e46002ccae71f80d395d45754a30f01568ef8 100644
--- a/test/parallel/test-wrap-js-stream-exceptions.js
+++ b/test/parallel/test-wrap-js-stream-exceptions.js
@@ -16,4 +16,8 @@ const socket = new JSStreamWrap(new Duplex({
   })
 }));
 
-assert.throws(() => socket.end('foo'), /Error: write EPROTO/);
+socket.end('foo');
+socket.on('error', common.expectsError({
+  name: 'Error',
+  message: 'write EPROTO'
+}));
diff --git a/test/parallel/test-x509-escaping-revert-CVE-2021-44532.js b/test/parallel/test-x509-escaping-revert-CVE-2021-44532.js
new file mode 100644
index 0000000000000000000000000000000000000000..c07edca86d82edccd870bca2c26002688e715b1b
--- /dev/null
+++ b/test/parallel/test-x509-escaping-revert-CVE-2021-44532.js
@@ -0,0 +1,360 @@
+// Flags: --security-revert=CVE-2021-44532
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const { hasOpenSSL3 } = common;
+
+// Test escaping rules for subject alternative names.
+{
+  const expectedSANs = [
+    'DNS:good.example.com, DNS:evil.example.com',
+    // URIs should not require escaping.
+    'URI:http://example.com/',
+    'URI:http://example.com/?a=b&c=d',
+    // Unless they contain commas.
+    'URI:http://example.com/a,b',
+    // Percent encoding should not require escaping.
+    'URI:http://example.com/a%2Cb',
+    // Malicious attempts should be escaped.
+    'URI:http://example.com/a, DNS:good.example.com',
+    // Non-ASCII characters in DNS names should be treated as Latin-1.
+    'DNS:ex�mple.com',
+    // It should not be possible to cause unescaping without escaping.
+    'DNS:"evil.example.com"',
+    // IPv4 addresses should be represented as usual.
+    'IP Address:8.8.8.8',
+    'IP Address:8.8.4.4',
+    // For backward-compatibility, include invalid IP address lengths.
+    hasOpenSSL3 ? 'IP Address:<invalid length=5>' : 'IP Address:<invalid>',
+    hasOpenSSL3 ? 'IP Address:<invalid length=6>' : 'IP Address:<invalid>',
+    // IPv6 addresses are represented as OpenSSL does.
+    'IP Address:A0B:C0D:E0F:0:0:0:7A7B:7C7D',
+    // Regular email addresses don't require escaping.
+    'email:foo@example.com',
+    // ... but should be escaped if they contain commas.
+    'email:foo@example.com, DNS:good.example.com',
+    'DirName:/C=DE/L=Hannover',
+    // TODO(tniessen): support UTF8 in DirName
+    'DirName:/C=DE/L=M\\xC3\\xBCnchen',
+    'DirName:/C=DE/L=Berlin, DNS:good.example.com',
+    'DirName:/C=DE/L=Berlin, DNS:good.example.com\\x00' +
+      'evil.example.com',
+    'DirName:/C=DE/L=Berlin, DNS:good.example.com\\\\x00' +
+      'evil.example.com',
+    // These next two tests might be surprising. OpenSSL applies its own rules
+    // first, which introduce backslashes, which activate node's escaping.
+    // Unfortunately, there are also differences between OpenSSL 1.1.1 and 3.0.
+    'DirName:/C=DE/L=Berlin\\x0D\\x0A',
+    hasOpenSSL3 ?
+      'DirName:/C=DE/L=Berlin\\/CN=good.example.com' :
+      'DirName:/C=DE/L=Berlin/CN=good.example.com',
+    // TODO(tniessen): even OIDs that are well-known (such as the following,
+    // which is sha256WithRSAEncryption) should be represented numerically only.
+    'Registered ID:sha256WithRSAEncryption',
+    // This is an OID that will likely never be assigned to anything, thus
+    // OpenSSL hould not know it.
+    'Registered ID:1.3.9999.12.34',
+    hasOpenSSL3 ?
+      'othername: XmppAddr::abc123' :
+      'othername:<unsupported>',
+    hasOpenSSL3 ?
+      'othername: XmppAddr::abc123, DNS:good.example.com' :
+      'othername:<unsupported>',
+    hasOpenSSL3 ?
+      null :
+      'othername:<unsupported>',
+    // This is unsupported because the OID is not recognized.
+    hasOpenSSL3 ?
+      'othername: 1.3.9999.12.34::abc123' :
+      'othername:<unsupported>',
+    hasOpenSSL3 ? 'othername: SRVName::abc123' : 'othername:<unsupported>',
+    // This is unsupported because it is an SRVName with a UTF8String value,
+    // which is not allowed for SRVName.
+    hasOpenSSL3 ?
+      null : 'othername:<unsupported>',
+    hasOpenSSL3 ?
+      null :
+      'othername:<unsupported>',
+  ];
+
+  const serverKey = fixtures.readSync('x509-escaping/server-key.pem', 'utf8');
+
+  for (let i = 0; i < expectedSANs.length; i++) {
+    const pem = fixtures.readSync(`x509-escaping/alt-${i}-cert.pem`, 'utf8');
+
+    // X509Certificate interface is not supported in v12.x & v14.x. Disable
+    // checks for subjectAltName with expectedSANs. The testcase is ported
+    // from v17.x
+    //
+    // Test the subjectAltName property of the X509Certificate API.
+    // const cert = new X509Certificate(pem);
+    // assert.strictEqual(cert.subjectAltName, expectedSANs[i]);
+
+    // Test that the certificate obtained by checkServerIdentity has the correct
+    // subjectaltname property.
+    const server = tls.createServer({
+      key: serverKey,
+      cert: pem,
+    }, common.mustCall((conn) => {
+      conn.destroy();
+      server.close();
+    })).listen(common.mustCall(() => {
+      const { port } = server.address();
+      tls.connect(port, {
+        ca: pem,
+        servername: 'example.com',
+        checkServerIdentity: (hostname, peerCert) => {
+          assert.strictEqual(hostname, 'example.com');
+          assert.strictEqual(peerCert.subjectaltname, expectedSANs[i]);
+        },
+      }, common.mustCall());
+    }));
+  }
+}
+
+// Test escaping rules for authority info access.
+{
+  const expectedInfoAccess = [
+    {
+      text: 'OCSP - URI:http://good.example.com/\n' +
+            'OCSP - URI:http://evil.example.com/',
+      legacy: {
+        'OCSP - URI': [
+          'http://good.example.com/',
+          'http://evil.example.com/',
+        ],
+      },
+    },
+    {
+      text: 'CA Issuers - URI:http://ca.example.com/\n' +
+            'OCSP - URI:http://evil.example.com\n' +
+            'OCSP - DNS:good.example.com\n' +
+            'OCSP - URI:http://ca.nodejs.org/ca.cert',
+      legacy: {
+        'CA Issuers - URI': [
+          'http://ca.example.com/',
+        ],
+        'OCSP - DNS': [
+          'good.example.com',
+        ],
+        'OCSP - URI': [
+          'http://evil.example.com',
+          'http://ca.nodejs.org/ca.cert',
+        ],
+      },
+    },
+    {
+      text: '1.3.9999.12.34 - URI:http://ca.example.com/',
+      legacy: {
+        '1.3.9999.12.34 - URI': [
+          'http://ca.example.com/',
+        ],
+      },
+    },
+    hasOpenSSL3 ? {
+      text: 'OCSP - othername: XmppAddr::good.example.com\n' +
+            'OCSP - othername: 1.3.9999.12.34::abc123\n' +
+            'OCSP - othername: SRVName::abc123',
+      legacy: {
+        'OCSP - othername': [
+          ' XmppAddr::good.example.com',
+          ' 1.3.9999.12.34::abc123',
+          ' SRVName::abc123',
+        ],
+      },
+    } : {
+      text: 'OCSP - othername:<unsupported>\n' +
+            'OCSP - othername:<unsupported>\n' +
+            'OCSP - othername:<unsupported>',
+      legacy: {
+        'OCSP - othername': [
+          '<unsupported>',
+          '<unsupported>',
+          '<unsupported>',
+        ],
+      },
+    },
+    hasOpenSSL3 ? {
+      text: null,
+      legacy: null,
+    } : {
+      text: 'OCSP - othername:<unsupported>',
+      legacy: {
+        'OCSP - othername': [
+          '<unsupported>',
+        ]
+      },
+    },
+  ];
+
+  const serverKey = fixtures.readSync('x509-escaping/server-key.pem', 'utf8');
+
+  for (let i = 0; i < expectedInfoAccess.length; i++) {
+    const pem = fixtures.readSync(`x509-escaping/info-${i}-cert.pem`, 'utf8');
+    const expected = expectedInfoAccess[i];
+
+    // X509Certificate interface is not supported in v12.x & v14.x. Disable
+    // checks for cert.infoAccess with expected text. The testcase is ported
+    // from v17.x
+    //
+    // Test the subjectAltName property of the X509Certificate API.
+    // const cert = new X509Certificate(pem);
+    // assert.strictEqual(cert.infoAccess, expected.text ?
+    //  `${expected.text}${hasOpenSSL3 ? '' : '\n'}` :
+    //  expected.text);
+
+    // Test that the certificate obtained by checkServerIdentity has the correct
+    // subjectaltname property.
+    const server = tls.createServer({
+      key: serverKey,
+      cert: pem,
+    }, common.mustCall((conn) => {
+      conn.destroy();
+      server.close();
+    })).listen(common.mustCall(() => {
+      const { port } = server.address();
+      tls.connect(port, {
+        ca: pem,
+        servername: 'example.com',
+        checkServerIdentity: (hostname, peerCert) => {
+          assert.strictEqual(hostname, 'example.com');
+          assert.deepStrictEqual(peerCert.infoAccess,
+                                 expected.legacy ?
+                                   Object.assign(Object.create(null),
+                                                 expected.legacy) :
+                                   expected.legacy);
+        },
+      }, common.mustCall());
+    }));
+  }
+}
+
+// The internal parsing logic must match the JSON specification exactly.
+{
+  // This list is partially based on V8's own JSON tests.
+  const invalidJSON = [
+    '"\\a invalid escape"',
+    '"\\v invalid escape"',
+    '"\\\' invalid escape"',
+    '"\\x42 invalid escape"',
+    '"\\u202 invalid escape"',
+    '"\\012 invalid escape"',
+    '"Unterminated string',
+    '"Unterminated string\\"',
+    '"Unterminated string\\\\\\"',
+    '"\u0000 control character"',
+    '"\u001e control character"',
+    '"\u001f control character"',
+  ];
+
+  for (const invalidStringLiteral of invalidJSON) {
+    // Usually, checkServerIdentity returns an error upon verification failure.
+    // In this case, however, it should throw an error since this is not a
+    // verification error. Node.js itself will never produce invalid JSON string
+    // literals, so this can only happen when users construct invalid subject
+    // alternative name strings (that do not follow escaping rules).
+    assert.throws(() => {
+      tls.checkServerIdentity('example.com', {
+        subjectaltname: `DNS:${invalidStringLiteral}`,
+      });
+    }, {
+      code: 'ERR_TLS_CERT_ALTNAME_FORMAT',
+      message: 'Invalid subject alternative name string'
+    });
+  }
+}
+
+// While node does not produce commas within SAN entries, it should parse them
+// correctly (i.e., not simply split at commas).
+{
+  // Regardless of the quotes, splitting this SAN string at commas would
+  // cause checkServerIdentity to see 'DNS:b.example.com' and thus to accept
+  // the certificate for b.example.com.
+  const san = 'DNS:"a.example.com, DNS:b.example.com, DNS:c.example.com"';
+
+  // This is what node used to do, and which is not correct!
+  const hostname = 'b.example.com';
+  assert.strictEqual(san.split(', ')[1], `DNS:${hostname}`);
+
+  // The new implementation should parse the string correctly.
+  const err = tls.checkServerIdentity(hostname, { subjectaltname: san });
+  assert(err);
+  assert.strictEqual(err.code, 'ERR_TLS_CERT_ALTNAME_INVALID');
+  assert.strictEqual(err.message, 'Hostname/IP does not match certificate\'s ' +
+                                  'altnames: Host: b.example.com. is not in ' +
+                                  'the cert\'s altnames: DNS:"a.example.com, ' +
+                                  'DNS:b.example.com, DNS:c.example.com"');
+}
+
+// The subject MUST be ignored if a dNSName subject alternative name exists.
+{
+  const key = fixtures.readKey('incorrect_san_correct_subject-key.pem');
+  const cert = fixtures.readKey('incorrect_san_correct_subject-cert.pem');
+
+  // The hostname is the CN, but not a SAN entry.
+  const servername = 'good.example.com';
+
+  // X509Certificate interface is not supported in v12.x & v14.x. Disable
+  // checks for certX509.subject and certX509.subjectAltName with expected
+  // value. The testcase is ported from v17.x
+  //
+  // const certX509 = new X509Certificate(cert);
+  // assert.strictEqual(certX509.subject, `CN=${servername}`);
+  // assert.strictEqual(certX509.subjectAltName, 'DNS:evil.example.com');
+
+  // Try connecting to a server that uses the self-signed certificate.
+  const server = tls.createServer({ key, cert }, common.mustNotCall());
+  server.listen(common.mustCall(() => {
+    const { port } = server.address();
+    const socket = tls.connect(port, {
+      ca: cert,
+      servername,
+    }, common.mustNotCall());
+    socket.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ERR_TLS_CERT_ALTNAME_INVALID');
+      assert.strictEqual(err.message, 'Hostname/IP does not match ' +
+                                      "certificate's altnames: Host: " +
+                                      "good.example.com. is not in the cert's" +
+                                      ' altnames: DNS:evil.example.com');
+    }));
+  })).unref();
+}
+
+// The subject MUST NOT be ignored if no dNSName subject alternative name
+// exists, even if other subject alternative names exist.
+{
+  const key = fixtures.readKey('irrelevant_san_correct_subject-key.pem');
+  const cert = fixtures.readKey('irrelevant_san_correct_subject-cert.pem');
+
+  // The hostname is the CN, but there is no dNSName SAN entry.
+  const servername = 'good.example.com';
+
+  // X509Certificate interface is not supported in v12.x & v14.x. Disable
+  // checks for certX509.subject and certX509.subjectAltName with expected
+  // value. The testcase is ported from v17.x
+  //
+  // const certX509 = new X509Certificate(cert);
+  // assert.strictEqual(certX509.subject, `CN=${servername}`);
+  // assert.strictEqual(certX509.subjectAltName, 'IP Address:1.2.3.4');
+
+  // Connect to a server that uses the self-signed certificate.
+  const server = tls.createServer({ key, cert }, common.mustCall((socket) => {
+    socket.destroy();
+    server.close();
+  })).listen(common.mustCall(() => {
+    const { port } = server.address();
+    tls.connect(port, {
+      ca: cert,
+      servername,
+    }, common.mustCall(() => {
+      // Do nothing, the server will close the connection.
+    }));
+  }));
+}
diff --git a/test/parallel/test-x509-escaping.js b/test/parallel/test-x509-escaping.js
new file mode 100644
index 0000000000000000000000000000000000000000..0635606dcc906169e6971273443dac1006f4fce8
--- /dev/null
+++ b/test/parallel/test-x509-escaping.js
@@ -0,0 +1,490 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const { hasOpenSSL3 } = common;
+
+// Test that all certificate chains provided by the reporter are rejected.
+{
+  const rootPEM = fixtures.readSync('x509-escaping/google/root.pem');
+  const intermPEM = fixtures.readSync('x509-escaping/google/intermediate.pem');
+  const keyPEM = fixtures.readSync('x509-escaping/google/key.pem');
+
+  const numLeaves = 5;
+
+  for (let i = 0; i < numLeaves; i++) {
+    const name = `x509-escaping/google/leaf${i}.pem`;
+    const leafPEM = fixtures.readSync(name, 'utf8');
+
+    const server = tls.createServer({
+      key: keyPEM,
+      cert: leafPEM + intermPEM,
+    }, common.mustNotCall()).listen(common.mustCall(() => {
+      const { port } = server.address();
+      const socket = tls.connect(port, {
+        ca: rootPEM,
+        servername: 'nodejs.org',
+      }, common.mustNotCall());
+      socket.on('error', common.mustCall());
+    })).unref();
+  }
+}
+
+// Test escaping rules for subject alternative names.
+{
+  const expectedSANs = [
+    'DNS:"good.example.com\\u002c DNS:evil.example.com"',
+    // URIs should not require escaping.
+    'URI:http://example.com/',
+    'URI:http://example.com/?a=b&c=d',
+    // Unless they contain commas.
+    'URI:"http://example.com/a\\u002cb"',
+    // Percent encoding should not require escaping.
+    'URI:http://example.com/a%2Cb',
+    // Malicious attempts should be escaped.
+    'URI:"http://example.com/a\\u002c DNS:good.example.com"',
+    // Non-ASCII characters in DNS names should be treated as Latin-1.
+    'DNS:"ex\\u00e4mple.com"',
+    // It should not be possible to cause unescaping without escaping.
+    'DNS:"\\"evil.example.com\\""',
+    // IPv4 addresses should be represented as usual.
+    'IP Address:8.8.8.8',
+    'IP Address:8.8.4.4',
+    // For backward-compatibility, include invalid IP address lengths.
+    hasOpenSSL3 ? 'IP Address:<invalid length=5>' : 'IP Address:<invalid>',
+    hasOpenSSL3 ? 'IP Address:<invalid length=6>' : 'IP Address:<invalid>',
+    // IPv6 addresses are represented as OpenSSL does.
+    'IP Address:A0B:C0D:E0F:0:0:0:7A7B:7C7D',
+    // Regular email addresses don't require escaping.
+    'email:foo@example.com',
+    // ... but should be escaped if they contain commas.
+    'email:"foo@example.com\\u002c DNS:good.example.com"',
+    'DirName:/C=DE/L=Hannover',
+    // TODO(tniessen): support UTF8 in DirName
+    'DirName:"/C=DE/L=M\\\\xC3\\\\xBCnchen"',
+    'DirName:"/C=DE/L=Berlin\\u002c DNS:good.example.com"',
+    'DirName:"/C=DE/L=Berlin\\u002c DNS:good.example.com\\\\x00' +
+      'evil.example.com"',
+    'DirName:"/C=DE/L=Berlin\\u002c DNS:good.example.com\\\\\\\\x00' +
+      'evil.example.com"',
+    // These next two tests might be surprising. OpenSSL applies its own rules
+    // first, which introduce backslashes, which activate node's escaping.
+    // Unfortunately, there are also differences between OpenSSL 1.1.1 and 3.0.
+    'DirName:"/C=DE/L=Berlin\\\\x0D\\\\x0A"',
+    hasOpenSSL3 ?
+      'DirName:"/C=DE/L=Berlin\\\\/CN=good.example.com"' :
+      'DirName:/C=DE/L=Berlin/CN=good.example.com',
+    // TODO(tniessen): even OIDs that are well-known (such as the following,
+    // which is sha256WithRSAEncryption) should be represented numerically only.
+    'Registered ID:sha256WithRSAEncryption',
+    // This is an OID that will likely never be assigned to anything, thus
+    // OpenSSL should not know it.
+    'Registered ID:1.3.9999.12.34',
+    hasOpenSSL3 ?
+      'othername: XmppAddr::abc123' :
+      'othername:<unsupported>',
+    hasOpenSSL3 ?
+      'othername:" XmppAddr::abc123\\u002c DNS:good.example.com"' :
+      'othername:<unsupported>',
+    hasOpenSSL3 ?
+      'othername:" XmppAddr::good.example.com\\u0000abc123"' :
+      'othername:<unsupported>',
+    // This is unsupported because the OID is not recognized.
+    'othername:<unsupported>',
+    hasOpenSSL3 ? 'othername: SRVName::abc123' : 'othername:<unsupported>',
+    // This is unsupported because it is an SRVName with a UTF8String value,
+    // which is not allowed for SRVName.
+    'othername:<unsupported>',
+    hasOpenSSL3 ?
+      'othername:" SRVName::abc\\u0000def"' :
+      'othername:<unsupported>',
+  ];
+
+  const serverKey = fixtures.readSync('x509-escaping/server-key.pem', 'utf8');
+
+  for (let i = 0; i < expectedSANs.length; i++) {
+    const pem = fixtures.readSync(`x509-escaping/alt-${i}-cert.pem`, 'utf8');
+
+    // X509Certificate interface is not supported in v12.x & v14.x. Disable
+    // checks for subjectAltName with expectedSANs. The testcase is ported
+    // from v17.x
+    //
+    // Test the subjectAltName property of the X509Certificate API.
+    // const cert = new X509Certificate(pem);
+    // assert.strictEqual(cert.subjectAltName, expectedSANs[i]);
+
+    // Test that the certificate obtained by checkServerIdentity has the correct
+    // subjectaltname property.
+    const server = tls.createServer({
+      key: serverKey,
+      cert: pem,
+    }, common.mustCall((conn) => {
+      conn.destroy();
+      server.close();
+    })).listen(common.mustCall(() => {
+      const { port } = server.address();
+      tls.connect(port, {
+        ca: pem,
+        servername: 'example.com',
+        checkServerIdentity: (hostname, peerCert) => {
+          assert.strictEqual(hostname, 'example.com');
+          assert.strictEqual(peerCert.subjectaltname, expectedSANs[i]);
+        },
+      }, common.mustCall());
+    }));
+  }
+}
+
+// Test escaping rules for authority info access.
+{
+  const expectedInfoAccess = [
+    {
+      text: 'OCSP - URI:"http://good.example.com/\\u000a' +
+            'OCSP - URI:http://evil.example.com/"',
+      legacy: {
+        'OCSP - URI': [
+          'http://good.example.com/\nOCSP - URI:http://evil.example.com/',
+        ],
+      },
+    },
+    {
+      text: 'CA Issuers - URI:"http://ca.example.com/\\u000a' +
+            'OCSP - URI:http://evil.example.com"\n' +
+            'OCSP - DNS:"good.example.com\\u000a' +
+            'OCSP - URI:http://ca.nodejs.org/ca.cert"',
+      legacy: {
+        'CA Issuers - URI': [
+          'http://ca.example.com/\nOCSP - URI:http://evil.example.com',
+        ],
+        'OCSP - DNS': [
+          'good.example.com\nOCSP - URI:http://ca.nodejs.org/ca.cert',
+        ],
+      },
+    },
+    {
+      text: '1.3.9999.12.34 - URI:http://ca.example.com/',
+      legacy: {
+        '1.3.9999.12.34 - URI': [
+          'http://ca.example.com/',
+        ],
+      },
+    },
+    hasOpenSSL3 ? {
+      text: 'OCSP - othername: XmppAddr::good.example.com\n' +
+            'OCSP - othername:<unsupported>\n' +
+            'OCSP - othername: SRVName::abc123',
+      legacy: {
+        'OCSP - othername': [
+          ' XmppAddr::good.example.com',
+          '<unsupported>',
+          ' SRVName::abc123',
+        ],
+      },
+    } : {
+      text: 'OCSP - othername:<unsupported>\n' +
+            'OCSP - othername:<unsupported>\n' +
+            'OCSP - othername:<unsupported>',
+      legacy: {
+        'OCSP - othername': [
+          '<unsupported>',
+          '<unsupported>',
+          '<unsupported>',
+        ],
+      },
+    },
+    hasOpenSSL3 ? {
+      text: 'OCSP - othername:" XmppAddr::good.example.com\\u0000abc123"',
+      legacy: {
+        'OCSP - othername': [
+          ' XmppAddr::good.example.com\0abc123',
+        ],
+      },
+    } : {
+      text: 'OCSP - othername:<unsupported>',
+      legacy: {
+        'OCSP - othername': [
+          '<unsupported>',
+        ],
+      },
+    },
+  ];
+
+  const serverKey = fixtures.readSync('x509-escaping/server-key.pem', 'utf8');
+
+  for (let i = 0; i < expectedInfoAccess.length; i++) {
+    const pem = fixtures.readSync(`x509-escaping/info-${i}-cert.pem`, 'utf8');
+    const expected = expectedInfoAccess[i];
+
+    // X509Certificate interface is not supported in v12.x & v14.x. Disable
+    // checks for cert.infoAccess with expected text. The testcase is ported
+    // from v17.x
+    // Test the subjectAltName property of the X509Certificate API.
+    // const cert = new X509Certificate(pem);
+    // assert.strictEqual(cert.infoAccess,
+    //                   `${expected.text}${hasOpenSSL3 ? '' : '\n'}`);
+
+    // Test that the certificate obtained by checkServerIdentity has the correct
+    // subjectaltname property.
+    const server = tls.createServer({
+      key: serverKey,
+      cert: pem,
+    }, common.mustCall((conn) => {
+      conn.destroy();
+      server.close();
+    })).listen(common.mustCall(() => {
+      const { port } = server.address();
+      tls.connect(port, {
+        ca: pem,
+        servername: 'example.com',
+        checkServerIdentity: (hostname, peerCert) => {
+          assert.strictEqual(hostname, 'example.com');
+          assert.deepStrictEqual(peerCert.infoAccess,
+                                 Object.assign(Object.create(null),
+                                               expected.legacy));
+        },
+      }, common.mustCall());
+    }));
+  }
+}
+
+// Test escaping rules for the subject field.
+{
+  const expectedSubjects = [
+    {
+      text: 'L=Somewhere\nCN=evil.example.com',
+      legacy: {
+        L: 'Somewhere',
+        CN: 'evil.example.com',
+      },
+    },
+    {
+      text: 'L=Somewhere\\00evil.example.com',
+      legacy: {
+        L: 'Somewhere\0evil.example.com',
+      },
+    },
+    {
+      text: 'L=Somewhere\\0ACN=evil.example.com',
+      legacy: {
+        L: 'Somewhere\nCN=evil.example.com'
+      },
+    },
+    {
+      text: 'L=Somewhere\\, CN = evil.example.com',
+      legacy: {
+        L: 'Somewhere, CN = evil.example.com'
+      },
+    },
+    {
+      text: 'L=Somewhere/CN=evil.example.com',
+      legacy: {
+        L: 'Somewhere/CN=evil.example.com'
+      },
+    },
+    {
+      text: 'L=München\\\\\\0ACN=evil.example.com',
+      legacy: {
+        L: 'München\\\nCN=evil.example.com'
+      }
+    },
+    {
+      text: 'L=Somewhere + CN=evil.example.com',
+      legacy: {
+        L: 'Somewhere',
+        CN: 'evil.example.com',
+      }
+    },
+    {
+      text: 'L=Somewhere \\+ CN=evil.example.com',
+      legacy: {
+        L: 'Somewhere + CN=evil.example.com'
+      }
+    },
+    // Observe that the legacy representation cannot properly distinguish
+    // between multi-value RDNs and multiple single-value RDNs.
+    {
+      text: 'L=L1 + L=L2\nL=L3',
+      legacy: {
+        L: ['L1', 'L2', 'L3']
+      },
+    },
+    {
+      text: 'L=L1\nL=L2\nL=L3',
+      legacy: {
+        L: ['L1', 'L2', 'L3']
+      },
+    },
+  ];
+
+  const serverKey = fixtures.readSync('x509-escaping/server-key.pem', 'utf8');
+
+  for (let i = 0; i < expectedSubjects.length; i++) {
+    const pem = fixtures.readSync(`x509-escaping/subj-${i}-cert.pem`, 'utf8');
+    const expected = expectedSubjects[i];
+
+    // X509Certificate interface is not supported in v12.x & v14.x. Disable
+    // checks for certX509.subject and certX509.issuer with expected
+    // text. The testcase is ported from v17.x
+    //
+    // Test the subject property of the X509Certificate API.
+    // const cert = new X509Certificate(pem);
+    // assert.strictEqual(cert.subject, expected.text);
+    // The issuer MUST be the same as the subject since the cert is self-signed.
+    // assert.strictEqual(cert.issuer, expected.text);
+
+    // Test that the certificate obtained by checkServerIdentity has the correct
+    // subject property.
+    const server = tls.createServer({
+      key: serverKey,
+      cert: pem,
+    }, common.mustCall((conn) => {
+      conn.destroy();
+      server.close();
+    })).listen(common.mustCall(() => {
+      const { port } = server.address();
+      tls.connect(port, {
+        ca: pem,
+        servername: 'example.com',
+        checkServerIdentity: (hostname, peerCert) => {
+          assert.strictEqual(hostname, 'example.com');
+          const expectedObject = Object.assign(Object.create(null),
+                                               expected.legacy);
+          assert.deepStrictEqual(peerCert.subject, expectedObject);
+          // The issuer MUST be the same as the subject since the cert is
+          // self-signed. Otherwise, OpenSSL would have already rejected the
+          // certificate while connecting to the TLS server.
+          assert.deepStrictEqual(peerCert.issuer, expectedObject);
+        },
+      }, common.mustCall());
+    }));
+  }
+}
+
+// The internal parsing logic must match the JSON specification exactly.
+{
+  // This list is partially based on V8's own JSON tests.
+  const invalidJSON = [
+    '"\\a invalid escape"',
+    '"\\v invalid escape"',
+    '"\\\' invalid escape"',
+    '"\\x42 invalid escape"',
+    '"\\u202 invalid escape"',
+    '"\\012 invalid escape"',
+    '"Unterminated string',
+    '"Unterminated string\\"',
+    '"Unterminated string\\\\\\"',
+    '"\u0000 control character"',
+    '"\u001e control character"',
+    '"\u001f control character"',
+  ];
+
+  for (const invalidStringLiteral of invalidJSON) {
+    // Usually, checkServerIdentity returns an error upon verification failure.
+    // In this case, however, it should throw an error since this is not a
+    // verification error. Node.js itself will never produce invalid JSON string
+    // literals, so this can only happen when users construct invalid subject
+    // alternative name strings (that do not follow escaping rules).
+    assert.throws(() => {
+      tls.checkServerIdentity('example.com', {
+        subjectaltname: `DNS:${invalidStringLiteral}`,
+      });
+    }, {
+      code: 'ERR_TLS_CERT_ALTNAME_FORMAT',
+      message: 'Invalid subject alternative name string'
+    });
+  }
+}
+
+// While node does not produce commas within SAN entries, it should parse them
+// correctly (i.e., not simply split at commas).
+{
+  // Regardless of the quotes, splitting this SAN string at commas would
+  // cause checkServerIdentity to see 'DNS:b.example.com' and thus to accept
+  // the certificate for b.example.com.
+  const san = 'DNS:"a.example.com, DNS:b.example.com, DNS:c.example.com"';
+
+  // This is what node used to do, and which is not correct!
+  const hostname = 'b.example.com';
+  assert.strictEqual(san.split(', ')[1], `DNS:${hostname}`);
+
+  // The new implementation should parse the string correctly.
+  const err = tls.checkServerIdentity(hostname, { subjectaltname: san });
+  assert(err);
+  assert.strictEqual(err.code, 'ERR_TLS_CERT_ALTNAME_INVALID');
+  assert.strictEqual(err.message, 'Hostname/IP does not match certificate\'s ' +
+                                  'altnames: Host: b.example.com. is not in ' +
+                                  'the cert\'s altnames: DNS:"a.example.com, ' +
+                                  'DNS:b.example.com, DNS:c.example.com"');
+}
+
+// The subject MUST be ignored if a dNSName subject alternative name exists.
+{
+  const key = fixtures.readKey('incorrect_san_correct_subject-key.pem');
+  const cert = fixtures.readKey('incorrect_san_correct_subject-cert.pem');
+
+  // The hostname is the CN, but not a SAN entry.
+  const servername = 'good.example.com';
+
+  // X509Certificate interface is not supported in v12.x & v14.x. Disable
+  // checks for certX509.subject and certX509.subjectAltName with expected
+  // value. The testcase is ported from v17.x
+  //
+  // const certX509 = new X509Certificate(cert);
+  // assert.strictEqual(certX509.subject, `CN=${servername}`);
+  // assert.strictEqual(certX509.subjectAltName, 'DNS:evil.example.com');
+
+  // Try connecting to a server that uses the self-signed certificate.
+  const server = tls.createServer({ key, cert }, common.mustNotCall());
+  server.listen(common.mustCall(() => {
+    const { port } = server.address();
+    const socket = tls.connect(port, {
+      ca: cert,
+      servername,
+    }, common.mustNotCall());
+    socket.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ERR_TLS_CERT_ALTNAME_INVALID');
+      assert.strictEqual(err.message, 'Hostname/IP does not match ' +
+                                      "certificate's altnames: Host: " +
+                                      "good.example.com. is not in the cert's" +
+                                      ' altnames: DNS:evil.example.com');
+    }));
+  })).unref();
+}
+
+// The subject MUST NOT be ignored if no dNSName subject alternative name
+// exists, even if other subject alternative names exist.
+{
+  const key = fixtures.readKey('irrelevant_san_correct_subject-key.pem');
+  const cert = fixtures.readKey('irrelevant_san_correct_subject-cert.pem');
+
+  // The hostname is the CN, but there is no dNSName SAN entry.
+  const servername = 'good.example.com';
+
+  // X509Certificate interface is not supported in v12.x & v14.x. Disable
+  // checks for certX509.subject and certX509.subjectAltName with expected
+  // value. The testcase is ported from v17.x
+  //
+  // const certX509 = new X509Certificate(cert);
+  // assert.strictEqual(certX509.subject, `CN=${servername}`);
+  // assert.strictEqual(certX509.subjectAltName, 'IP Address:1.2.3.4');
+
+  // Connect to a server that uses the self-signed certificate.
+  const server = tls.createServer({ key, cert }, common.mustCall((socket) => {
+    socket.destroy();
+    server.close();
+  })).listen(common.mustCall(() => {
+    const { port } = server.address();
+    tls.connect(port, {
+      ca: cert,
+      servername,
+    }, common.mustCall(() => {
+      // Do nothing, the server will close the connection.
+    }));
+  }));
+}
diff --git a/test/parallel/test-zlib-brotli.js b/test/parallel/test-zlib-brotli.js
index 772b655177aa18b1466438422a7b1b597d541e6a..ef31db3dd64ac4d59562060a347c4309d58f01e4 100644
--- a/test/parallel/test-zlib-brotli.js
+++ b/test/parallel/test-zlib-brotli.js
@@ -71,3 +71,24 @@ const sampleBuffer = fixtures.readSync('/pss-vectors.json');
     message: 'Initialization failed'
   });
 }
+
+{
+  // Test options.flush range
+  assert.throws(() => {
+    zlib.brotliCompressSync('', { flush: zlib.constants.Z_FINISH });
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: 'The value of "options.flush" is out of range. It must be >= 0 ' +
+      'and <= 3. Received 4',
+  });
+
+  assert.throws(() => {
+    zlib.brotliCompressSync('', { finishFlush: zlib.constants.Z_FINISH });
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: 'The value of "options.finishFlush" is out of range. It must be ' +
+      '>= 0 and <= 3. Received 4',
+  });
+}
diff --git a/test/parallel/test-zlib-bytes-read.js b/test/parallel/test-zlib-bytes-read.js
index a7a4e523f7060b7303a25346345f6cbcd1e07b2e..605281cd3bd7e676b04ffe1c1591a91d06c9e5c3 100644
--- a/test/parallel/test-zlib-bytes-read.js
+++ b/test/parallel/test-zlib-bytes-read.js
@@ -32,7 +32,7 @@ for (const method of [
   ['createGzip', 'createUnzip', false],
   ['createDeflate', 'createInflate', true],
   ['createDeflateRaw', 'createInflateRaw', true],
-  ['createBrotliCompress', 'createBrotliDecompress', true]
+  ['createBrotliCompress', 'createBrotliDecompress', true],
 ]) {
   let compWriter;
   let compData = Buffer.alloc(0);
diff --git a/test/parallel/test-zlib-const.js b/test/parallel/test-zlib-const.js
index d25a1ca6be033ae0012d11a4536da74afd19a3dd..342c8c712a475b2434a69ed0d8ade2e8312507ed 100644
--- a/test/parallel/test-zlib-const.js
+++ b/test/parallel/test-zlib-const.js
@@ -7,13 +7,13 @@ const zlib = require('zlib');
 assert.strictEqual(zlib.constants.Z_OK, 0,
                    [
                      'Expected Z_OK to be 0;',
-                     `got ${zlib.constants.Z_OK}`
+                     `got ${zlib.constants.Z_OK}`,
                    ].join(' '));
 zlib.constants.Z_OK = 1;
 assert.strictEqual(zlib.constants.Z_OK, 0,
                    [
                      'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.constants.Z_OK}`
+                     `Expected to get 0, got ${zlib.constants.Z_OK}`,
                    ].join(' '));
 
 assert.strictEqual(zlib.codes.Z_OK, 0,
@@ -22,17 +22,17 @@ zlib.codes.Z_OK = 1;
 assert.strictEqual(zlib.codes.Z_OK, 0,
                    [
                      'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.codes.Z_OK}`
+                     `Expected to get 0, got ${zlib.codes.Z_OK}`,
                    ].join(' '));
 zlib.codes = { Z_OK: 1 };
 assert.strictEqual(zlib.codes.Z_OK, 0,
                    [
                      'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.codes.Z_OK}`
+                     `Expected to get 0, got ${zlib.codes.Z_OK}`,
                    ].join(' '));
 
 assert.ok(Object.isFrozen(zlib.codes),
           [
             'Expected zlib.codes to be frozen, but Object.isFrozen',
-            `returned ${Object.isFrozen(zlib.codes)}`
+            `returned ${Object.isFrozen(zlib.codes)}`,
           ].join(' '));
diff --git a/test/parallel/test-zlib-convenience-methods.js b/test/parallel/test-zlib-convenience-methods.js
index 4757eef42c236b2fc011db9dc68a48ef23147e23..01ec7e211bd5aaf88a3eec59ede6d7ba527729c4 100644
--- a/test/parallel/test-zlib-convenience-methods.js
+++ b/test/parallel/test-zlib-convenience-methods.js
@@ -45,7 +45,7 @@ for (const [type, expect] of [
   ['Buffer', expectBuf],
   ...common.getBufferSources(expectBuf).map((obj) =>
     [obj[Symbol.toStringTag], obj]
-  )
+  ),
 ]) {
   for (const method of [
     ['gzip', 'gunzip', 'Gzip', 'Gunzip'],
diff --git a/test/parallel/test-zlib-destroy.js b/test/parallel/test-zlib-destroy.js
index bbfce22ee2cf8a1925330da3aa5563e8f97a73c4..775b7020b4ecfda463813213b93e40ac91516333 100644
--- a/test/parallel/test-zlib-destroy.js
+++ b/test/parallel/test-zlib-destroy.js
@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 
 const assert = require('assert');
 const zlib = require('zlib');
@@ -8,6 +8,24 @@ const zlib = require('zlib');
 // Verify that the zlib transform does clean up
 // the handle when calling destroy.
 
-const ts = zlib.createGzip();
-ts.destroy();
-assert.strictEqual(ts._handle, null);
+{
+  const ts = zlib.createGzip();
+  ts.destroy();
+  assert.strictEqual(ts._handle, null);
+
+  ts.on('close', common.mustCall(() => {
+    ts.close(common.mustCall());
+  }));
+}
+
+{
+  // Ensure 'error' is only emitted once.
+  const decompress = zlib.createGunzip(15);
+
+  decompress.on('error', common.mustCall((err) => {
+    decompress.close();
+  }));
+
+  decompress.write('something invalid');
+  decompress.destroy(new Error('asd'));
+}
diff --git a/test/parallel/test-zlib-dictionary.js b/test/parallel/test-zlib-dictionary.js
index 11c8959cc68505e896b65f601bfb7f424bdf188a..49a01d5a03ee4bf0c6a21d78d1ddc3933c2982ae 100644
--- a/test/parallel/test-zlib-dictionary.js
+++ b/test/parallel/test-zlib-dictionary.js
@@ -39,14 +39,14 @@ const spdyDict = Buffer.from([
   'ndayTuesdayWednesdayThursdayFridaySaturdaySundayJanFebMarAprMayJunJulAugSe',
   'pOctNovDecchunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplic',
   'ation/xhtmltext/plainpublicmax-agecharset=iso-8859-1utf-8gzipdeflateHTTP/1',
-  '.1statusversionurl\0'
+  '.1statusversionurl\0',
 ].join(''));
 
 const input = [
   'HTTP/1.1 200 Ok',
   'Server: node.js',
   'Content-Length: 0',
-  ''
+  '',
 ].join('\r\n');
 
 function basicDictionaryTest(spdyDict) {
diff --git a/test/parallel/test-zlib-empty-buffer.js b/test/parallel/test-zlib-empty-buffer.js
index 3b52896d29965e72260378ed5bf7fbb8ce56f709..27fd1340fd1eb4525b9fdbd25fdc830d82406f64 100644
--- a/test/parallel/test-zlib-empty-buffer.js
+++ b/test/parallel/test-zlib-empty-buffer.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const zlib = require('zlib');
 const { inspect, promisify } = require('util');
 const assert = require('assert');
@@ -14,7 +14,7 @@ const emptyBuffer = Buffer.alloc(0);
     [ promisify(zlib.deflateRaw), promisify(zlib.inflateRaw), 'raw' ],
     [ promisify(zlib.deflate), promisify(zlib.inflate), 'deflate' ],
     [ promisify(zlib.gzip), promisify(zlib.gunzip), 'gzip' ],
-    [ promisify(zlib.brotliCompress), promisify(zlib.brotliDecompress), 'br' ]
+    [ promisify(zlib.brotliCompress), promisify(zlib.brotliDecompress), 'br' ],
   ]) {
     const compressed = await compress(emptyBuffer);
     const decompressed = await decompress(compressed);
@@ -23,4 +23,4 @@ const emptyBuffer = Buffer.alloc(0);
       `Expected ${inspect(compressed)} to match ${inspect(decompressed)} ` +
       `to match for ${method}`);
   }
-})();
+})().then(common.mustCall());
diff --git a/test/parallel/test-zlib-flush-write-sync-interleaved.js b/test/parallel/test-zlib-flush-write-sync-interleaved.js
index 9fed592a34bb1b5cdc0d881324db0b74c71ab0bb..f8387f40069b5f5ccc0a5dc20673e64c7a610c58 100644
--- a/test/parallel/test-zlib-flush-write-sync-interleaved.js
+++ b/test/parallel/test-zlib-flush-write-sync-interleaved.js
@@ -52,6 +52,6 @@ process.on('exit', () => {
     'compress end',
     { read: 'abc' },
     { read: 'def' },
-    { read: 'ghi' }
+    { read: 'ghi' },
   ]);
 });
diff --git a/test/parallel/test-zlib-from-concatenated-gzip.js b/test/parallel/test-zlib-from-concatenated-gzip.js
index 7bb31c0f9ddd9f5994f26dbc7ee3280a16137531..1de36dacf95f3dd512c45c0f957a94a1732e6dbd 100644
--- a/test/parallel/test-zlib-from-concatenated-gzip.js
+++ b/test/parallel/test-zlib-from-concatenated-gzip.js
@@ -15,27 +15,24 @@ const defEncoded = zlib.gzipSync(def);
 
 const data = Buffer.concat([
   abcEncoded,
-  defEncoded
+  defEncoded,
 ]);
 
 assert.strictEqual(zlib.gunzipSync(data).toString(), (abc + def));
 
-zlib.gunzip(data, common.mustCall((err, result) => {
-  assert.ifError(err);
+zlib.gunzip(data, common.mustSucceed((result) => {
   assert.strictEqual(result.toString(), (abc + def));
 }));
 
-zlib.unzip(data, common.mustCall((err, result) => {
-  assert.ifError(err);
+zlib.unzip(data, common.mustSucceed((result) => {
   assert.strictEqual(result.toString(), (abc + def));
 }));
 
 // Multi-member support does not apply to zlib inflate/deflate.
 zlib.unzip(Buffer.concat([
   zlib.deflateSync('abc'),
-  zlib.deflateSync('def')
-]), common.mustCall((err, result) => {
-  assert.ifError(err);
+  zlib.deflateSync('def'),
+]), common.mustSucceed((result) => {
   assert.strictEqual(result.toString(), abc);
 }));
 
@@ -78,7 +75,7 @@ fs.createReadStream(pmmFileGz)
 
   // First write: write "abc" + the first bytes of "def"
   unzip.write(Buffer.concat([
-    abcEncoded, defEncoded.slice(0, offset)
+    abcEncoded, defEncoded.slice(0, offset),
   ]));
 
   // Write remaining bytes of "def"
diff --git a/test/parallel/test-zlib-from-gzip-with-trailing-garbage.js b/test/parallel/test-zlib-from-gzip-with-trailing-garbage.js
index 06fc2258a0395ccd671ddb586a28c992909cecc8..477a6c544f2c078cefb2c7b64aa43e123fef9474 100644
--- a/test/parallel/test-zlib-from-gzip-with-trailing-garbage.js
+++ b/test/parallel/test-zlib-from-gzip-with-trailing-garbage.js
@@ -9,13 +9,12 @@ const zlib = require('zlib');
 let data = Buffer.concat([
   zlib.gzipSync('abc'),
   zlib.gzipSync('def'),
-  Buffer.alloc(10)
+  Buffer.alloc(10),
 ]);
 
 assert.strictEqual(zlib.gunzipSync(data).toString(), 'abcdef');
 
-zlib.gunzip(data, common.mustCall((err, result) => {
-  assert.ifError(err);
+zlib.gunzip(data, common.mustSucceed((result) => {
   assert.strictEqual(
     result.toString(),
     'abcdef',
@@ -29,7 +28,7 @@ data = Buffer.concat([
   zlib.gzipSync('abc'),
   zlib.gzipSync('def'),
   Buffer.from([0x1f, 0x8b, 0xff, 0xff]),
-  Buffer.alloc(10)
+  Buffer.alloc(10),
 ]);
 
 assert.throws(
@@ -51,7 +50,7 @@ zlib.gunzip(data, common.mustCall((err, result) => {
 data = Buffer.concat([
   zlib.gzipSync('abc'),
   zlib.gzipSync('def'),
-  Buffer.from([0x1f, 0x8b, 0xff, 0xff])
+  Buffer.from([0x1f, 0x8b, 0xff, 0xff]),
 ]);
 
 assert.throws(
diff --git a/test/parallel/test-zlib-invalid-arg-value-brotli-compress.js b/test/parallel/test-zlib-invalid-arg-value-brotli-compress.js
new file mode 100644
index 0000000000000000000000000000000000000000..688acddd16a1368a38fd24d1c6e2fa5b5221cf45
--- /dev/null
+++ b/test/parallel/test-zlib-invalid-arg-value-brotli-compress.js
@@ -0,0 +1,20 @@
+'use strict';
+
+require('../common');
+
+// This test ensures that the BrotliCompress function throws
+// ERR_INVALID_ARG_TYPE when the values of the `params` key-value object are
+// neither numbers nor booleans.
+
+const assert = require('assert');
+const { BrotliCompress, constants } = require('zlib');
+
+const opts = {
+  params: {
+    [constants.BROTLI_PARAM_MODE]: 'lol'
+  }
+};
+
+assert.throws(() => BrotliCompress(opts), {
+  code: 'ERR_INVALID_ARG_TYPE'
+});
diff --git a/test/parallel/test-zlib-invalid-input.js b/test/parallel/test-zlib-invalid-input.js
index 68fa3825b91ced1bed54d9efbf300b6fabca6a1c..67793984a991c5afb8ed65c90bf9ddd2f5cc2c7a 100644
--- a/test/parallel/test-zlib-invalid-input.js
+++ b/test/parallel/test-zlib-invalid-input.js
@@ -30,7 +30,7 @@ const nonStringInputs = [
   1,
   true,
   { a: 1 },
-  ['a']
+  ['a'],
 ];
 
 // zlib.Unzip classes need to get valid data, or else they'll throw.
@@ -39,14 +39,15 @@ const unzips = [
   zlib.Gunzip(),
   zlib.Inflate(),
   zlib.InflateRaw(),
-  zlib.BrotliDecompress()
+  zlib.BrotliDecompress(),
 ];
 
 nonStringInputs.forEach(common.mustCall((input) => {
-  // zlib.gunzip should not throw an error when called with bad input.
-  zlib.gunzip(input, (err, buffer) => {
-    // zlib.gunzip should pass the error to the callback.
-    assert.ok(err);
+  assert.throws(() => {
+    zlib.gunzip(input);
+  }, {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE'
   });
 }, nonStringInputs.length));
 
diff --git a/test/parallel/test-zlib-no-stream.js b/test/parallel/test-zlib-no-stream.js
new file mode 100644
index 0000000000000000000000000000000000000000..68da269ab8f57e383972a25edf68c017972c7987
--- /dev/null
+++ b/test/parallel/test-zlib-no-stream.js
@@ -0,0 +1,14 @@
+/* eslint-disable node-core/required-modules */
+/* eslint-disable node-core/require-common-first */
+
+'use strict';
+
+// We are not loading common because it will load the stream module,
+// defeating the purpose of this test.
+
+const { gzipSync } = require('zlib');
+
+// Avoid regressions such as https://github.com/nodejs/node/issues/36615
+
+// This must not throw
+gzipSync('fooobar');
diff --git a/test/parallel/test-zlib-not-string-or-buffer.js b/test/parallel/test-zlib-not-string-or-buffer.js
index b7b9a465cb89e18488342122053cf76dcc2b34b5..a0954a0e1eaef7b1e35312535dc28d32ebef3ce8 100644
--- a/test/parallel/test-zlib-not-string-or-buffer.js
+++ b/test/parallel/test-zlib-not-string-or-buffer.js
@@ -15,7 +15,7 @@ const zlib = require('zlib');
   0,
   1,
   [1, 2, 3],
-  { foo: 'bar' }
+  { foo: 'bar' },
 ].forEach((input) => {
   assert.throws(
     () => zlib.deflateSync(input),
diff --git a/test/parallel/test-zlib-object-write.js b/test/parallel/test-zlib-object-write.js
index 98f34b38bed850938c75bbc3d51b6f33556c5972..2be5edab897510e8b9a0a5fc30874d35dfbfff7c 100644
--- a/test/parallel/test-zlib-object-write.js
+++ b/test/parallel/test-zlib-object-write.js
@@ -1,11 +1,14 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const { Gunzip } = require('zlib');
 
 const gunzip = new Gunzip({ objectMode: true });
-assert.throws(
-  () => gunzip.write({}),
-  TypeError
-);
+gunzip.on('error', common.mustNotCall());
+assert.throws(() => {
+  gunzip.write({});
+}, {
+  name: 'TypeError',
+  code: 'ERR_INVALID_ARG_TYPE'
+});
diff --git a/test/parallel/test-zlib-premature-end.js b/test/parallel/test-zlib-premature-end.js
index 9e191c4c88282c2efe2e7b8d16fa92f2204148c8..17446c907ddc13852d1c1032fd1cf0a5e8463900 100644
--- a/test/parallel/test-zlib-premature-end.js
+++ b/test/parallel/test-zlib-premature-end.js
@@ -8,7 +8,7 @@ const input = '0123456789'.repeat(4);
 for (const [ compress, decompressor ] of [
   [ zlib.deflateRawSync, zlib.createInflateRaw ],
   [ zlib.deflateSync, zlib.createInflate ],
-  [ zlib.brotliCompressSync, zlib.createBrotliDecompress ]
+  [ zlib.brotliCompressSync, zlib.createBrotliDecompress ],
 ]) {
   const compressed = compress(input);
   const trailingData = Buffer.from('not valid compressed data');
@@ -18,7 +18,7 @@ for (const [ compress, decompressor ] of [
     (stream) => { stream.write(compressed); stream.write(trailingData); },
     (stream) => { stream.write(compressed); stream.end(trailingData); },
     (stream) => { stream.write(Buffer.concat([compressed, trailingData])); },
-    (stream) => { stream.end(Buffer.concat([compressed, trailingData])); }
+    (stream) => { stream.end(Buffer.concat([compressed, trailingData])); },
   ]) {
     let output = '';
     const stream = decompressor();
diff --git a/test/parallel/test-zlib-reset-before-write.js b/test/parallel/test-zlib-reset-before-write.js
index 6b2b107d25d313358967c0517e65b0a09d475763..57bd708380381097b2f22ed90a0669458fad3a88 100644
--- a/test/parallel/test-zlib-reset-before-write.js
+++ b/test/parallel/test-zlib-reset-before-write.js
@@ -12,7 +12,7 @@ for (const fn of [
     z.reset();
     cb();
   },
-  (z, cb) => z.params(0, zlib.constants.Z_DEFAULT_STRATEGY, cb)
+  (z, cb) => z.params(0, zlib.constants.Z_DEFAULT_STRATEGY, cb),
 ]) {
   const deflate = zlib.createDeflate();
   const inflate = zlib.createInflate();
diff --git a/test/parallel/test-zlib-truncated.js b/test/parallel/test-zlib-truncated.js
index 304f76b9da8651e48aa7617c83c060f0876daaf6..bcd55923c9999c0175608c5e5564c38464bb6bf5 100644
--- a/test/parallel/test-zlib-truncated.js
+++ b/test/parallel/test-zlib-truncated.js
@@ -21,7 +21,7 @@ const errMessage = /unexpected end of file/;
   { comp: 'gzip', decomp: 'gunzip', decompSync: 'gunzipSync' },
   { comp: 'gzip', decomp: 'unzip', decompSync: 'unzipSync' },
   { comp: 'deflate', decomp: 'inflate', decompSync: 'inflateSync' },
-  { comp: 'deflateRaw', decomp: 'inflateRaw', decompSync: 'inflateRawSync' }
+  { comp: 'deflateRaw', decomp: 'inflateRaw', decompSync: 'inflateRawSync' },
 ].forEach(function(methods) {
   zlib[methods.comp](inputString, function(err, compressed) {
     assert.ifError(err);
diff --git a/test/parallel/test-zlib-unused-weak.js b/test/parallel/test-zlib-unused-weak.js
index 7a5a6728533e18ffd1b509bb000f48aeaed91620..2c1e2d729030dded0b01e49d6f70ba5123690eb6 100644
--- a/test/parallel/test-zlib-unused-weak.js
+++ b/test/parallel/test-zlib-unused-weak.js
@@ -1,11 +1,12 @@
 'use strict';
-// Flags: --expose-gc
+// Flags: --expose-gc --no-concurrent-array-buffer-sweeping
 require('../common');
 const assert = require('assert');
 const zlib = require('zlib');
 
 // Tests that native zlib handles start out their life as weak handles.
 
+global.gc();
 const before = process.memoryUsage().external;
 for (let i = 0; i < 100; ++i)
   zlib.createGzip();
diff --git a/test/parallel/test-zlib-unzip-one-byte-chunks.js b/test/parallel/test-zlib-unzip-one-byte-chunks.js
index be3b5dda818cf6e599c72e5b889820f70115ea90..3d3d9c37ff019818c8949acb4b94ece7d002d85f 100644
--- a/test/parallel/test-zlib-unzip-one-byte-chunks.js
+++ b/test/parallel/test-zlib-unzip-one-byte-chunks.js
@@ -5,7 +5,7 @@ const zlib = require('zlib');
 
 const data = Buffer.concat([
   zlib.gzipSync('abc'),
-  zlib.gzipSync('def')
+  zlib.gzipSync('def'),
 ]);
 
 const resultBuffers = [];
diff --git a/test/parallel/test-zlib-write-after-close.js b/test/parallel/test-zlib-write-after-close.js
index 06a7d3f19175435a2eb52d373563b9ea31831b3f..eb8ff4353963d446e23c909ca040326eabf50917 100644
--- a/test/parallel/test-zlib-write-after-close.js
+++ b/test/parallel/test-zlib-write-after-close.js
@@ -21,18 +21,14 @@
 
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 const zlib = require('zlib');
 
 zlib.gzip('hello', common.mustCall(function(err, out) {
   const unzip = zlib.createGunzip();
   unzip.close(common.mustCall());
-  assert.throws(
-    () => unzip.write(out),
-    {
-      code: 'ERR_STREAM_DESTROYED',
-      name: 'Error',
-      message: 'Cannot call write after a stream was destroyed'
-    }
-  );
+  unzip.write('asd', common.expectsError({
+    code: 'ERR_STREAM_DESTROYED',
+    name: 'Error',
+    message: 'Cannot call write after a stream was destroyed'
+  }));
 }));
diff --git a/test/parallel/test-zlib.js b/test/parallel/test-zlib.js
index 02e66167d11b4f8b668f6e35777bcd81b693cc10..65050b85a036cfad05d9e840b52bc42b10e78c99 100644
--- a/test/parallel/test-zlib.js
+++ b/test/parallel/test-zlib.js
@@ -179,7 +179,8 @@ zlib.createDeflateRaw({ windowBits: 8 });
       .pipe(zlib.createInflateRaw({ windowBits: 8 }))
       .on('data', (chunk) => reinflated.push(chunk))
       .on('end', common.mustCall(
-        () => assert(Buffer.concat(raw).equals(Buffer.concat(reinflated)))));
+        () => assert(Buffer.concat(raw).equals(Buffer.concat(reinflated)))))
+      .on('close', common.mustCall(1));
 }
 
 // For each of the files, make sure that compressing and
diff --git a/test/pseudo-tty/test-set-raw-mode-reset-process-exit.js b/test/pseudo-tty/test-set-raw-mode-reset-process-exit.js
index b6857eaebbdf60a33cc79754e1b00ff3ac334f2f..1f80ab304d540d2e6fee06a5fa43e76d483da0fd 100644
--- a/test/pseudo-tty/test-set-raw-mode-reset-process-exit.js
+++ b/test/pseudo-tty/test-set-raw-mode-reset-process-exit.js
@@ -5,7 +5,7 @@ const child_process = require('child_process');
 // Tests that exiting through process.exit() resets the TTY mode.
 
 child_process.spawnSync(process.execPath, [
-  '-e', 'process.stdin.setRawMode(true); process.exit(0)'
+  '-e', 'process.stdin.setRawMode(true); process.exit(0)',
 ], { stdio: 'inherit' });
 
 const { stdout } = child_process.spawnSync('stty', {
diff --git a/test/pseudo-tty/test-set-raw-mode-reset-signal.js b/test/pseudo-tty/test-set-raw-mode-reset-signal.js
index f953a01331c050c34965dbe9b565cfd719200a0f..8b666f3ee0a8c3e390693722d5960247c808f145 100644
--- a/test/pseudo-tty/test-set-raw-mode-reset-signal.js
+++ b/test/pseudo-tty/test-set-raw-mode-reset-signal.js
@@ -5,7 +5,7 @@ const child_process = require('child_process');
 // Tests that exiting through a catchable signal resets the TTY mode.
 
 const proc = child_process.spawn(process.execPath, [
-  '-e', 'process.stdin.setRawMode(true); console.log("Y"); while(true) {}'
+  '-e', 'process.stdin.setRawMode(true); console.log("Y"); while(true) {}',
 ], { stdio: ['inherit', 'pipe', 'inherit'] });
 
 proc.stdout.on('data', common.mustCall(() => {
diff --git a/test/pseudo-tty/test-set-raw-mode-reset.js b/test/pseudo-tty/test-set-raw-mode-reset.js
index ab8f1125bfc6024d4441362f0c802e5daf475695..7cd9bba80672fe5418abbca002d22c58270f446b 100644
--- a/test/pseudo-tty/test-set-raw-mode-reset.js
+++ b/test/pseudo-tty/test-set-raw-mode-reset.js
@@ -6,7 +6,7 @@ const child_process = require('child_process');
 // Refs: https://github.com/nodejs/node/issues/21020
 
 child_process.spawnSync(process.execPath, [
-  '-e', 'process.stdin.setRawMode(true)'
+  '-e', 'process.stdin.setRawMode(true)',
 ], { stdio: 'inherit' });
 
 const { stdout } = child_process.spawnSync('stty', {
diff --git a/test/pseudo-tty/test-tty-color-support-warning-2.out b/test/pseudo-tty/test-tty-color-support-warning-2.out
index cd57b3f9f6967224192e4a9d43d705b1960eb742..37b470a5f108f9cffc8a08cfb15bf04bbea4d9d5 100644
--- a/test/pseudo-tty/test-tty-color-support-warning-2.out
+++ b/test/pseudo-tty/test-tty-color-support-warning-2.out
@@ -1,2 +1,3 @@
 
 (node:*) Warning: The 'NODE_DISABLE_COLORS' env is ignored due to the 'FORCE_COLOR' env being set.
+(Use `* --trace-warnings ...` to show where the warning was created)
diff --git a/test/pseudo-tty/test-tty-color-support-warning.out b/test/pseudo-tty/test-tty-color-support-warning.out
index 9360ae1328b2cde2560de67c0cce38b0519fa176..b25d2e42cf7244a6513de2f29c2f647d91983782 100644
--- a/test/pseudo-tty/test-tty-color-support-warning.out
+++ b/test/pseudo-tty/test-tty-color-support-warning.out
@@ -1,2 +1,3 @@
 
 (node:*) Warning: The 'NODE_DISABLE_COLORS' and 'NO_COLOR' env is ignored due to the 'FORCE_COLOR' env being set.
+(Use `* --trace-warnings ...` to show where the warning was created)
diff --git a/test/pseudo-tty/test-tty-color-support.out b/test/pseudo-tty/test-tty-color-support.out
index e6904d10b8a7b8b2430465d48e7e7df9a51b961e..df5831c555be1914e28986df62bbb4421a29d68a 100644
--- a/test/pseudo-tty/test-tty-color-support.out
+++ b/test/pseudo-tty/test-tty-color-support.out
@@ -1 +1,2 @@
 (node:*) Warning: The 'NO_COLOR' env is ignored due to the 'FORCE_COLOR' env being set.
+(Use `* --trace-warnings ...` to show where the warning was created)
diff --git a/test/pseudo-tty/test-tty-isatty.js b/test/pseudo-tty/test-tty-isatty.js
index 3a7b2940311221d5e8529d8ca0c4b394740a2f78..ad81a4c6eff92b8ab35647db1b9d432c48b6a1d7 100644
--- a/test/pseudo-tty/test-tty-isatty.js
+++ b/test/pseudo-tty/test-tty-isatty.js
@@ -10,6 +10,7 @@ strictEqual(isatty(2), true, 'stderr reported to not be a tty, but it is');
 
 strictEqual(isatty(-1), false, '-1 reported to be a tty, but it is not');
 strictEqual(isatty(55555), false, '55555 reported to be a tty, but it is not');
+strictEqual(isatty(2 ** 31), false, '2^31 reported to be a tty, but it is not');
 strictEqual(isatty(1.1), false, '1.1 reported to be a tty, but it is not');
 strictEqual(isatty('1'), false, '\'1\' reported to be a tty, but it is not');
 strictEqual(isatty({}), false, '{} reported to be a tty, but it is not');
diff --git a/test/pseudo-tty/testcfg.py b/test/pseudo-tty/testcfg.py
index 8f09bef2e95599261ac52bbba64033165404b66b..df380ad31eff1e1b6e243acfce3b21d44e93b2f8 100644
--- a/test/pseudo-tty/testcfg.py
+++ b/test/pseudo-tty/testcfg.py
@@ -48,6 +48,7 @@ class TTYTestCase(test.TestCase):
     self.config = config
     self.arch = arch
     self.mode = mode
+    self.parallel = True
 
   def IgnoreLine(self, str_arg):
     """Ignore empty lines and valgrind output."""
@@ -70,7 +71,7 @@ class TTYTestCase(test.TestCase):
     raw_lines = (output.stdout + output.stderr).split('\n')
     outlines = [ s.rstrip() for s in raw_lines if not self.IgnoreLine(s) ]
     if len(outlines) != len(patterns):
-      print("length differs.")
+      print(" length differs.")
       print("expect=%d" % len(patterns))
       print("actual=%d" % len(outlines))
       print("patterns:")
@@ -82,7 +83,7 @@ class TTYTestCase(test.TestCase):
       return True
     for i in range(len(patterns)):
       if not re.match(patterns[i], outlines[i]):
-        print("match failed")
+        print(" match failed")
         print("line=%d" % i)
         print("expect=%s" % patterns[i])
         print("actual=%s" % outlines[i])
diff --git a/test/pummel/test-crypto-dh-hash-modp18.js b/test/pummel/test-crypto-dh-hash-modp18.js
index 288a647bdd321d47fef7227dcc6c38cd7de3c1f1..06121d1f6dc9567ace91ed7cf160ea3798983e2c 100644
--- a/test/pummel/test-crypto-dh-hash-modp18.js
+++ b/test/pummel/test-crypto-dh-hash-modp18.js
@@ -21,8 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+
+if (!common.hasCrypto) {
   common.skip('node compiled without OpenSSL.');
+}
+
+if ((process.config.variables.arm_version === '6') ||
+  (process.config.variables.arm_version === '7')) {
+  common.skip('Too slow for armv6 and armv7 bots');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
diff --git a/test/pummel/test-crypto-dh-hash.js b/test/pummel/test-crypto-dh-hash.js
index 7188fbb32b9197817287377b8812b8ada578ed6b..5b7002ce7fe16b0fad08eb77e1a9235118b3e314 100644
--- a/test/pummel/test-crypto-dh-hash.js
+++ b/test/pummel/test-crypto-dh-hash.js
@@ -21,8 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+
+if (!common.hasCrypto) {
   common.skip('node compiled without OpenSSL.');
+}
+
+if ((process.config.variables.arm_version === '6') ||
+  (process.config.variables.arm_version === '7')) {
+  common.skip('Too slow for armv6 and armv7 bots');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
diff --git a/test/pummel/test-crypto-dh-keys.js b/test/pummel/test-crypto-dh-keys.js
index f8f990b5c5ee4a06e0c18e332e35487fe7b23ef0..33c2ed8607304530e75b5c41b858cdf13c8412fd 100644
--- a/test/pummel/test-crypto-dh-keys.js
+++ b/test/pummel/test-crypto-dh-keys.js
@@ -21,8 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+
+if (!common.hasCrypto) {
   common.skip('node compiled without OpenSSL.');
+}
+
+if ((process.config.variables.arm_version === '6') ||
+  (process.config.variables.arm_version === '7')) {
+  common.skip('Too slow for armv6 and armv7 bots');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
diff --git a/test/pummel/test-dh-regr.js b/test/pummel/test-dh-regr.js
index f2da464bbbfbd71c8ddb606125724a48d86e1e49..dcdaa69385335236724a65553fd9283daebf1607 100644
--- a/test/pummel/test-dh-regr.js
+++ b/test/pummel/test-dh-regr.js
@@ -21,8 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+if ((process.config.variables.arm_version === '6') ||
+  (process.config.variables.arm_version === '7')) {
+  common.skip('Too slow for armv6 and armv7 bots');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
diff --git a/test/pummel/test-fs-largefile.js b/test/pummel/test-fs-largefile.js
index 8200543b9a13e7504f5ffcf5f374ad9ccfd141dd..9c2b26782d9c961366aa1e38aadb205e00f89151 100644
--- a/test/pummel/test-fs-largefile.js
+++ b/test/pummel/test-fs-largefile.js
@@ -34,7 +34,7 @@ const fd = fs.openSync(filepath, 'w+');
 const offset = 5 * 1024 * 1024 * 1024; // 5GB
 const message = 'Large File';
 
-fs.truncateSync(fd, offset);
+fs.ftruncateSync(fd, offset);
 assert.strictEqual(fs.statSync(filepath).size, offset);
 const writeBuf = Buffer.from(message);
 fs.writeSync(fd, writeBuf, 0, writeBuf.length, offset);
@@ -47,9 +47,3 @@ assert.strictEqual(readBuf[0], 0);
 // Verify that floating point positions do not throw.
 fs.writeSync(fd, writeBuf, 0, writeBuf.length, 42.000001);
 fs.close(fd, common.mustCall());
-
-// Normally, we don't clean up tmp files at the end of a test, but we'll make an
-// exception for a 5 GB file.
-process.on('exit', function() {
-  fs.unlinkSync(filepath);
-});
diff --git a/test/pummel/test-fs-watch-file-slow.js b/test/pummel/test-fs-watch-file-slow.js
index 94f2a263881427717a9d30b8151f596d49964382..c7513a18e6fa3ec6b274174fc9093561824f7d52 100644
--- a/test/pummel/test-fs-watch-file-slow.js
+++ b/test/pummel/test-fs-watch-file-slow.js
@@ -27,6 +27,7 @@ const fs = require('fs');
 
 const tmpdir = require('../common/tmpdir');
 
+tmpdir.refresh();
 const FILENAME = path.join(tmpdir.path, 'watch-me');
 const TIMEOUT = 1300;
 
diff --git a/test/pummel/test-fs-watch-file.js b/test/pummel/test-fs-watch-file.js
index 4573c9a1b12204ac190638321208d8cd9ae4c537..ca8aecc8721dc848f9f774c139a4a5c778c27eb5 100644
--- a/test/pummel/test-fs-watch-file.js
+++ b/test/pummel/test-fs-watch-file.js
@@ -46,10 +46,6 @@ const filenameThree = 'charm'; // Because the third time is
 const filenameFour = 'get';
 
 process.on('exit', function() {
-  fs.unlinkSync(filepathOne);
-  fs.unlinkSync(filepathTwoAbs);
-  fs.unlinkSync(filenameThree);
-  fs.unlinkSync(filenameFour);
   assert.strictEqual(watchSeenOne, 1);
   assert.strictEqual(watchSeenTwo, 2);
   assert.strictEqual(watchSeenThree, 1);
@@ -57,6 +53,7 @@ process.on('exit', function() {
 });
 
 
+tmpdir.refresh();
 fs.writeFileSync(filepathOne, 'hello');
 
 assert.throws(
diff --git a/test/pummel/test-fs-watch-non-recursive.js b/test/pummel/test-fs-watch-non-recursive.js
index b9a6cd6dcfb1d00eeb9b6d9c5a8a9e2e9da468e8..49071a965f1737cffcc9109d90a76cd8f9d9312c 100644
--- a/test/pummel/test-fs-watch-non-recursive.js
+++ b/test/pummel/test-fs-watch-non-recursive.js
@@ -21,6 +21,11 @@
 
 'use strict';
 const common = require('../common');
+
+if (common.isIBMi) {
+  common.skip('IBMi does not support fs.watch()');
+}
+
 const path = require('path');
 const fs = require('fs');
 
diff --git a/test/pummel/test-fs-watch-system-limit.js b/test/pummel/test-fs-watch-system-limit.js
index 8b9cb62ad0a0078b68318b350810cc3db1be4ca5..ce390dd3d0bb835cc8f8be2e0c5dac68808ae202 100644
--- a/test/pummel/test-fs-watch-system-limit.js
+++ b/test/pummel/test-fs-watch-system-limit.js
@@ -37,7 +37,7 @@ function spawnProcesses() {
       [ '-e',
         `process.chdir(${JSON.stringify(__dirname)});
         for (const file of fs.readdirSync('.'))
-          fs.watch(file, () => {});`
+          fs.watch(file, () => {});`,
       ], { stdio: ['inherit', 'inherit', 'pipe'] });
     proc.stderr.pipe(gatherStderr);
     processes.push(proc);
diff --git a/test/pummel/test-hash-seed.js b/test/pummel/test-hash-seed.js
index 30edca32f6f852a0fb8aef720078a9c4d0cbee55..d63754cb56ed020b9b3127652117ec12951491d4 100644
--- a/test/pummel/test-hash-seed.js
+++ b/test/pummel/test-hash-seed.js
@@ -2,6 +2,11 @@
 
 // Check that spawn child doesn't create duplicated entries
 const common = require('../common');
+
+if ((process.config.variables.arm_version === '6') ||
+    (process.config.variables.arm_version === '7'))
+  common.skip('Too slow for armv6 and armv7 bots');
+
 const kRepetitions = 2;
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
diff --git a/test/pummel/test-heapdump-dns.js b/test/pummel/test-heapdump-dns.js
index 6fe79f7dd4ec5a9a5b2661a027daceaf4e89318b..675ddc09aca61abc99f8c69062c1259a337303f3 100644
--- a/test/pummel/test-heapdump-dns.js
+++ b/test/pummel/test-heapdump-dns.js
@@ -10,9 +10,9 @@ dns.resolve('localhost', () => {});
 validateSnapshotNodes('Node / ChannelWrap', [
   {
     children: [
-      { node_name: 'Node / node_ares_task_list', edge_name: 'task_list' },
+      { node_name: 'Node / NodeAresTask::List', edge_name: 'task_list' },
       // `Node / ChannelWrap` (C++) -> `ChannelWrap` (JS)
-      { node_name: 'ChannelWrap', edge_name: 'wrapped' }
+      { node_name: 'ChannelWrap', edge_name: 'wrapped' },
     ]
-  }
+  },
 ]);
diff --git a/test/pummel/test-heapdump-fs-promise.js b/test/pummel/test-heapdump-fs-promise.js
index ca170e13a6177049d53ad64f9fef14d563889d44..181029dd69c11fe80fb191ffbc751be9892a21a0 100644
--- a/test/pummel/test-heapdump-fs-promise.js
+++ b/test/pummel/test-heapdump-fs-promise.js
@@ -10,7 +10,7 @@ validateSnapshotNodes('Node / FSReqPromise', [
   {
     children: [
       { node_name: 'FSReqPromise', edge_name: 'wrapped' },
-      { node_name: 'Float64Array', edge_name: 'stats_field_array' }
+      { node_name: 'Float64Array', edge_name: 'stats_field_array' },
     ]
-  }
+  },
 ]);
diff --git a/test/pummel/test-heapdump-http2.js b/test/pummel/test-heapdump-http2.js
index fe11dcfb2f44bbac62b936882eb5d7207f781b4a..2fa854a91f117d64b21ae40318d0d7f3912a9d84 100644
--- a/test/pummel/test-heapdump-http2.js
+++ b/test/pummel/test-heapdump-http2.js
@@ -28,7 +28,7 @@ server.listen(0, () => {
       {
         children: [
           // current_headers and/or queue could be empty
-          { node_name: 'Http2Stream', edge_name: 'wrapped' }
+          { node_name: 'Http2Stream', edge_name: 'wrapped' },
         ]
       },
     ], { loose: true });
@@ -37,32 +37,32 @@ server.listen(0, () => {
     state.validateSnapshotNodes('Node / FileHandle', [
       {
         children: [
-          { node_name: 'FileHandle', edge_name: 'wrapped' }
+          { node_name: 'FileHandle', edge_name: 'wrapped' },
           // current_headers could be empty
         ]
-      }
+      },
     ], { loose: true });
     state.validateSnapshotNodes('Node / TCPSocketWrap', [
       {
         children: [
-          { node_name: 'TCP', edge_name: 'wrapped' }
+          { node_name: 'TCP', edge_name: 'wrapped' },
         ]
-      }
+      },
     ], { loose: true });
     state.validateSnapshotNodes('Node / TCPServerWrap', [
       {
         children: [
-          { node_name: 'TCP', edge_name: 'wrapped' }
+          { node_name: 'TCP', edge_name: 'wrapped' },
         ]
-      }
+      },
     ], { loose: true });
     // `Node / StreamPipe` (C++) -> StreamPipe (JS)
     state.validateSnapshotNodes('Node / StreamPipe', [
       {
         children: [
-          { node_name: 'StreamPipe', edge_name: 'wrapped' }
+          { node_name: 'StreamPipe', edge_name: 'wrapped' },
         ]
-      }
+      },
     ]);
     // `Node / Http2Session` (C++) -> Http2Session (JS)
     state.validateSnapshotNodes('Node / Http2Session', [
@@ -72,11 +72,11 @@ server.listen(0, () => {
           { node_name: 'Node / nghttp2_memory', edge_name: 'nghttp2_memory' },
           {
             node_name: 'Node / streams', edge_name: 'streams'
-          }
+          },
           // outstanding_pings, outgoing_buffers, outgoing_storage,
           // pending_rst_streams could be empty
         ]
-      }
+      },
     ], { loose: true });
   }));
 
diff --git a/test/pummel/test-heapdump-inspector.js b/test/pummel/test-heapdump-inspector.js
index d46be57c914a061bacb29eb2f8ba5ea27bf3691f..9b08e33fdb2bce2a1e6173391911ff04b8759764 100644
--- a/test/pummel/test-heapdump-inspector.js
+++ b/test/pummel/test-heapdump-inspector.js
@@ -9,7 +9,7 @@ const inspector = require('inspector');
 
 const snapshotNode = {
   children: [
-    { node_name: 'Node / InspectorSession', edge_name: 'session' }
+    { node_name: 'Node / InspectorSession', edge_name: 'session' },
   ]
 };
 
@@ -33,9 +33,9 @@ const snapshotNode = {
         { node_name: 'Connection', edge_name: 'wrapped' },
         (edge) => edge.name === 'callback' &&
           (edge.to.type === undefined || // embedded graph
-           edge.to.type === 'closure') // snapshot
+           edge.to.type === 'closure'), // snapshot
       ]
-    }
+    },
   ];
   if (process.env.NODE_V8_COVERAGE) {
     expected.push(snapshotNode);
diff --git a/test/pummel/test-heapdump-tls.js b/test/pummel/test-heapdump-tls.js
index fee19bf67625b2e76adfd42ba63fdd1dae3a6650..a58a543a28d65d2bdfe9e87a13a60865bf8899fd 100644
--- a/test/pummel/test-heapdump-tls.js
+++ b/test/pummel/test-heapdump-tls.js
@@ -27,9 +27,9 @@ const server = net.createServer(common.mustCall((c) => {
         { node_name: 'Node / NodeBIO', edge_name: 'enc_out' },
         { node_name: 'Node / NodeBIO', edge_name: 'enc_in' },
         // `Node / TLSWrap` (C++) -> `TLSWrap` (JS)
-        { node_name: 'TLSWrap', edge_name: 'wrapped' }
+        { node_name: 'TLSWrap', edge_name: 'wrapped' },
         // pending_cleartext_input could be empty
       ]
-    }
+    },
   ]);
 }));
diff --git a/test/pummel/test-heapdump-worker.js b/test/pummel/test-heapdump-worker.js
index 6e91bee4d3d378d7630fc787c0c9b5ea7b327fa6..0e8322affb5d64160d04cd804317a42c9b88a6d8 100644
--- a/test/pummel/test-heapdump-worker.js
+++ b/test/pummel/test-heapdump-worker.js
@@ -10,15 +10,15 @@ validateSnapshotNodes('Node / Worker', [
   {
     children: [
       { node_name: 'Node / MessagePort', edge_name: 'parent_port' },
-      { node_name: 'Worker', edge_name: 'wrapped' }
+      { node_name: 'Worker', edge_name: 'wrapped' },
     ]
-  }
+  },
 ]);
 validateSnapshotNodes('Node / MessagePort', [
   {
     children: [
-      { node_name: 'Node / MessagePortData', edge_name: 'data' }
+      { node_name: 'Node / MessagePortData', edge_name: 'data' },
     ]
-  }
+  },
 ], { loose: true });
 worker.terminate();
diff --git a/test/pummel/test-heapdump-zlib.js b/test/pummel/test-heapdump-zlib.js
index ef906c9935274e7b77057ad47b41da2f4232f383..16e4ede4f916a27072935a60ed84f0d3266dc47d 100644
--- a/test/pummel/test-heapdump-zlib.js
+++ b/test/pummel/test-heapdump-zlib.js
@@ -10,10 +10,10 @@ const gzip = zlib.createGzip();
 validateSnapshotNodes('Node / ZlibStream', [
   {
     children: [
-      { node_name: 'Zlib', edge_name: 'wrapped' }
+      { node_name: 'Zlib', edge_name: 'wrapped' },
       // No entry for memory because zlib memory is initialized lazily.
     ]
-  }
+  },
 ]);
 
 gzip.write('hello world', common.mustCall(() => {
@@ -21,8 +21,8 @@ gzip.write('hello world', common.mustCall(() => {
     {
       children: [
         { node_name: 'Zlib', edge_name: 'wrapped' },
-        { node_name: 'Node / zlib_memory', edge_name: 'zlib_memory' }
+        { node_name: 'Node / zlib_memory', edge_name: 'zlib_memory' },
       ]
-    }
+    },
   ]);
 }));
diff --git a/test/pummel/test-heapsnapshot-near-heap-limit-big.js b/test/pummel/test-heapsnapshot-near-heap-limit-big.js
new file mode 100644
index 0000000000000000000000000000000000000000..14f62e3cbc40697f0df97c1d32eedbb943a4a427
--- /dev/null
+++ b/test/pummel/test-heapsnapshot-near-heap-limit-big.js
@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const fixtures = require('../common/fixtures');
+const fs = require('fs');
+const env = {
+  ...process.env,
+  NODE_DEBUG_NATIVE: 'diagnostics'
+};
+
+if (!common.enoughTestMem)
+  common.skip('Insufficient memory for snapshot test');
+
+{
+  console.log('\nTesting limit = 3');
+  tmpdir.refresh();
+  const child = spawnSync(process.execPath, [
+    '--heapsnapshot-near-heap-limit=3',
+    '--max-old-space-size=512',
+    fixtures.path('workload', 'grow.js'),
+  ], {
+    cwd: tmpdir.path,
+    env: {
+      ...env,
+      TEST_CHUNK: 2000,
+    }
+  });
+  const stderr = child.stderr.toString();
+  console.log(stderr);
+  assert(common.nodeProcessAborted(child.status, child.signal),
+         'process should have aborted, but did not');
+  const list = fs.readdirSync(tmpdir.path)
+    .filter((file) => file.endsWith('.heapsnapshot'));
+  const risky = [...stderr.matchAll(
+    /Not generating snapshots because it's too risky/g)].length;
+  assert(list.length + risky > 0 && list.length <= 3,
+         `Generated ${list.length} snapshots ` +
+    `and ${risky} was too risky`);
+}
diff --git a/test/pummel/test-net-timeout.js b/test/pummel/test-net-timeout.js
index 5b9f2a01b3823eccbe3182b3e5ac136b4bd2663f..f110254a50499d8a511c238958cae8ea36560422 100644
--- a/test/pummel/test-net-timeout.js
+++ b/test/pummel/test-net-timeout.js
@@ -45,7 +45,6 @@ const echo_server = net.createServer((socket) => {
   });
 
   socket.on('data', (d) => {
-    console.log(d);
     socket.write(d);
   });
 
@@ -105,7 +104,4 @@ process.on('exit', () => {
   console.log(`diff = ${diff}`);
 
   assert.ok(timeout < diff);
-
-  // Allow for 800 milliseconds more
-  assert.ok(diff < timeout + 800);
 });
diff --git a/test/pummel/test-next-tick-infinite-calls.js b/test/pummel/test-next-tick-infinite-calls.js
index 5ee44076dcc2f3e680011a89996bcb527b3e72a2..7ae3b2261358af9a1eb70254e58f7dac13b7b683 100644
--- a/test/pummel/test-next-tick-infinite-calls.js
+++ b/test/pummel/test-next-tick-infinite-calls.js
@@ -20,7 +20,12 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
+
+if ((process.config.variables.arm_version === '6') ||
+  (process.config.variables.arm_version === '7')) {
+  common.skip('Too slow for armv6 and armv7 bots');
+}
 
 let complete = 0;
 
diff --git a/test/pummel/test-policy-integrity.js b/test/pummel/test-policy-integrity.js
index db1589c5ffe834ee4daa672e7fef6bfc49cd1d54..9383f881fbe514253699f8d04998f72c847262f9 100644
--- a/test/pummel/test-policy-integrity.js
+++ b/test/pummel/test-policy-integrity.js
@@ -1,7 +1,17 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto) common.skip('missing crypto');
+
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+
+if ((process.config.variables.arm_version === '6') ||
+  (process.config.variables.arm_version === '7')) {
+  common.skip('Too slow for armv6 and armv7 bots');
+}
+
+common.requireNoPackageJSONAbove();
 
 const { debuglog } = require('util');
 const debug = debuglog('test');
@@ -75,6 +85,7 @@ function newTestId() {
   return nextTestId++;
 }
 tmpdir.refresh();
+common.requireNoPackageJSONAbove(tmpdir.path);
 
 let spawned = 0;
 const toSpawn = [];
@@ -109,7 +120,7 @@ function drainQueue() {
       `deletable-policy-${testId}.json`
     );
     const cliPolicy = willDeletePolicy ? tmpPolicyPath : policyPath;
-    fs.rmdirSync(configDirPath, { maxRetries: 3, recursive: true });
+    fs.rmSync(configDirPath, { maxRetries: 3, recursive: true, force: true });
     fs.mkdirSync(configDirPath, { recursive: true });
     const manifest = {
       onerror: onError,
@@ -185,7 +196,7 @@ function drainQueue() {
         console.log(`stderr: ${Buffer.concat(stderr)}`);
         throw e;
       }
-      fs.rmdirSync(configDirPath, { maxRetries: 3, recursive: true });
+      fs.rmSync(configDirPath, { maxRetries: 3, recursive: true, force: true });
       drainQueue();
     });
   }
diff --git a/test/pummel/test-vm-memleak.js b/test/pummel/test-vm-memleak.js
index a433ab6565e1470a0d6f58a5f4251bf38594612a..419b4171d226e9219b4330c02f65d44e2386097b 100644
--- a/test/pummel/test-vm-memleak.js
+++ b/test/pummel/test-vm-memleak.js
@@ -20,12 +20,19 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-// Flags: --max_old_space_size=32
+// Flags: --max_old_space_size=32 --expose_gc
+
+const common = require('../common');
+
+if (process.config.variables.asan) {
+  common.skip('ASAN messes with memory measurements');
+}
 
-require('../common');
 const assert = require('assert');
 const vm = require('vm');
 
+const baselineRss = process.memoryUsage.rss();
+
 const start = Date.now();
 
 const interval = setInterval(function() {
@@ -34,9 +41,10 @@ const interval = setInterval(function() {
   } catch {
   }
 
-  const rss = process.memoryUsage().rss;
-  assert.ok(rss < 64 * 1024 * 1024,
-            `memory usage: ${Math.round(rss / (1024 * 1024))}Mb`);
+  global.gc();
+  const rss = process.memoryUsage.rss();
+  assert.ok(rss < baselineRss + 32 * 1024 * 1024,
+            `memory usage: ${rss} baseline: ${baselineRss}`);
 
   // Stop after 5 seconds.
   if (Date.now() - start > 5 * 1000) {
diff --git a/test/pummel/test-worker-take-heapsnapshot.js b/test/pummel/test-worker-take-heapsnapshot.js
index b369759d0613e5f08dd31251130adc44de20afed..71f1782fe58d1d196e44f95515bb1ae2e8ca63a3 100644
--- a/test/pummel/test-worker-take-heapsnapshot.js
+++ b/test/pummel/test-worker-take-heapsnapshot.js
@@ -14,9 +14,9 @@ const { once } = require('events');
   snapshot.validateSnapshot('Node / MessagePort', [
     {
       children: [
-        { node_name: 'Node / MessagePortData', edge_name: 'data' }
+        { node_name: 'Node / MessagePortData', edge_name: 'data' },
       ]
-    }
+    },
   ], { loose: true });
   await w.terminate();
 })().then(common.mustCall());
diff --git a/test/report/test-report-fatal-error.js b/test/report/test-report-fatal-error.js
index c166c4b86c384f00ef004d6120bf03bd58b90236..c913240c4bc7ee92a7f541461e85ff21599213bf 100644
--- a/test/report/test-report-fatal-error.js
+++ b/test/report/test-report-fatal-error.js
@@ -28,7 +28,7 @@ if (process.argv[2] === 'child') {
 const ARGS = [
   '--max-old-space-size=20',
   __filename,
-  'child'
+  'child',
 ];
 
 {
@@ -104,7 +104,7 @@ const ARGS = [
     '--report-on-fatalerror',
     '--report-compact',
     '--report-filename=stderr',
-    ...ARGS
+    ...ARGS,
   ];
   const child = spawnSync(process.execPath, args, { encoding: 'utf8' });
   assert.notStrictEqual(child.status, 0, 'Process exited unexpectedly');
diff --git a/test/report/test-report-uncaught-exception-override.js b/test/report/test-report-uncaught-exception-override.js
new file mode 100644
index 0000000000000000000000000000000000000000..df4f8a1958114b3c55c104b00bc2ef07cdf9b771
--- /dev/null
+++ b/test/report/test-report-uncaught-exception-override.js
@@ -0,0 +1,26 @@
+// Flags: --report-uncaught-exception
+'use strict';
+// Test report is suppressed on uncaught exception hook.
+const common = require('../common');
+const assert = require('assert');
+const helper = require('../common/report');
+const tmpdir = require('../common/tmpdir');
+const error = new Error('test error');
+
+tmpdir.refresh();
+process.report.directory = tmpdir.path;
+
+// First, install an uncaught exception hook.
+process.setUncaughtExceptionCaptureCallback(common.mustCall());
+
+// Make sure this is ignored due to the above override.
+process.on('uncaughtException', common.mustNotCall());
+
+process.on('exit', (code) => {
+  assert.strictEqual(code, 0);
+  // Make sure no reports are generated.
+  const reports = helper.findReports(process.pid, tmpdir.path);
+  assert.strictEqual(reports.length, 0);
+});
+
+throw error;
diff --git a/test/report/test-report-uv-handles.js b/test/report/test-report-uv-handles.js
index 3a6a34a8573fe7a963365424f0c87c63e4908d40..4486f2d9d152d63e7cf480cfb562f0d9093a57cb 100644
--- a/test/report/test-report-uv-handles.js
+++ b/test/report/test-report-uv-handles.js
@@ -2,18 +2,22 @@
 
 // Testcase to check reporting of uv handles.
 const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const path = require('path');
 if (common.isIBMi)
   common.skip('IBMi does not support fs.watch()');
 
-if (process.argv[2] === 'child') {
-  // Exit on loss of parent process
-  const exit = () => process.exit(2);
-  process.on('disconnect', exit);
+// This is quite similar to common.PIPE except that it uses an extended prefix
+// of "\\?\pipe" on windows.
+const PIPE = (() => {
+  const localRelative = path.relative(process.cwd(), `${tmpdir.path}/`);
+  const pipePrefix = common.isWindows ? '\\\\?\\pipe\\' : localRelative;
+  const pipeName = `node-test.${process.pid}.sock`;
+  return path.join(pipePrefix, pipeName);
+})();
 
+function createFsHandle(childData) {
   const fs = require('fs');
-  const http = require('http');
-  const spawn = require('child_process').spawn;
-
   // Watching files should result in fs_event/fs_poll uv handles.
   let watcher;
   try {
@@ -22,59 +26,129 @@ if (process.argv[2] === 'child') {
     // fs.watch() unavailable
   }
   fs.watchFile(__filename, () => {});
+  childData.skip_fs_watch = watcher === undefined;
+
+  return () => {
+    if (watcher) watcher.close();
+    fs.unwatchFile(__filename);
+  };
+}
 
+function createChildProcessHandle(childData) {
+  const spawn = require('child_process').spawn;
   // Child should exist when this returns as child_process.pid must be set.
-  const child_process = spawn(process.execPath,
-                              ['-e', "process.stdin.on('data', (x) => " +
-                                     'console.log(x.toString()));']);
+  const cp = spawn(process.execPath,
+                   ['-e', "process.stdin.on('data', (x) => " +
+          'console.log(x.toString()));']);
+  childData.pid = cp.pid;
+
+  return () => {
+    cp.kill();
+  };
+}
 
+function createTimerHandle() {
   const timeout = setInterval(() => {}, 1000);
   // Make sure the timer doesn't keep the test alive and let
   // us check we detect unref'd handles correctly.
   timeout.unref();
+  return () => {
+    clearInterval(timeout);
+  };
+}
+
+function createTcpHandle(childData) {
+  const http = require('http');
 
+  return new Promise((resolve) => {
+    // Simple server/connection to create tcp uv handles.
+    const server = http.createServer((req, res) => {
+      req.on('end', () => {
+        resolve(() => {
+          res.writeHead(200, { 'Content-Type': 'text/plain' });
+          res.end();
+          server.close();
+        });
+      });
+      req.resume();
+    });
+    server.listen(() => {
+      childData.tcp_address = server.address();
+      http.get({ port: server.address().port });
+    });
+  });
+}
+
+function createUdpHandle(childData) {
   // Datagram socket for udp uv handles.
   const dgram = require('dgram');
-  const udp_socket = dgram.createSocket('udp4');
-  const connected_udp_socket = dgram.createSocket('udp4');
-  udp_socket.bind({}, common.mustCall(() => {
-    connected_udp_socket.connect(udp_socket.address().port);
-  }));
+  const udpSocket = dgram.createSocket('udp4');
+  const connectedUdpSocket = dgram.createSocket('udp4');
+
+  return new Promise((resolve) => {
+    udpSocket.bind({}, common.mustCall(() => {
+      connectedUdpSocket.connect(udpSocket.address().port);
 
-  // Simple server/connection to create tcp uv handles.
-  const server = http.createServer((req, res) => {
-    req.on('end', () => {
-      // Generate the report while the connection is active.
-      console.log(JSON.stringify(process.report.getReport(), null, 2));
-      child_process.kill();
-
-      res.writeHead(200, { 'Content-Type': 'text/plain' });
-      res.end();
-
-      // Tidy up to allow process to exit cleanly.
-      server.close(() => {
-        if (watcher) watcher.close();
-        fs.unwatchFile(__filename);
-        connected_udp_socket.close();
-        udp_socket.close();
-        process.removeListener('disconnect', exit);
+      childData.udp_address = udpSocket.address();
+      resolve(() => {
+        connectedUdpSocket.close();
+        udpSocket.close();
+      });
+    }));
+  });
+}
+
+function createNamedPipeHandle(childData) {
+  const net = require('net');
+  const sockPath = PIPE;
+  return new Promise((resolve) => {
+    const server = net.createServer((socket) => {
+      childData.pipe_sock_path = server.address();
+      resolve(() => {
+        socket.end();
+        server.close();
       });
     });
-    req.resume();
+    server.listen(
+      sockPath,
+      () => {
+        net.connect(sockPath, (socket) => {});
+      });
   });
-  server.listen(() => {
-    const data = { pid: child_process.pid,
-                   tcp_address: server.address(),
-                   udp_address: udp_socket.address(),
-                   skip_fs_watch: (watcher === undefined) };
-    process.send(data);
-    http.get({ port: server.address().port });
+}
+
+async function child() {
+  // Exit on loss of parent process
+  const exit = () => process.exit(2);
+  process.on('disconnect', exit);
+
+  const childData = {};
+  const disposes = await Promise.all([
+    createFsHandle(childData),
+    createChildProcessHandle(childData),
+    createTimerHandle(childData),
+    createTcpHandle(childData),
+    createUdpHandle(childData),
+    createNamedPipeHandle(childData),
+  ]);
+  process.send(childData);
+
+  // Generate the report while the connection is active.
+  console.log(JSON.stringify(process.report.getReport(), null, 2));
+
+  // Tidy up to allow process to exit cleanly.
+  disposes.forEach((it) => {
+    it();
   });
+  process.removeListener('disconnect', exit);
+}
+
+if (process.argv[2] === 'child') {
+  child();
 } else {
   const helper = require('../common/report.js');
   const fork = require('child_process').fork;
   const assert = require('assert');
-  const tmpdir = require('../common/tmpdir');
   tmpdir.refresh();
   const options = { encoding: 'utf8', silent: true, cwd: tmpdir.path };
   const child = fork(__filename, ['child'], options);
@@ -86,25 +160,25 @@ if (process.argv[2] === 'child') {
   const report_msg = 'Report files were written: unexpectedly';
   child.stdout.on('data', (chunk) => { stdout += chunk; });
   child.on('exit', common.mustCall((code, signal) => {
+    assert.strictEqual(stderr.trim(), '');
     assert.deepStrictEqual(code, 0, 'Process exited unexpectedly with code: ' +
                            `${code}`);
     assert.deepStrictEqual(signal, null, 'Process should have exited cleanly,' +
                             ` but did not: ${signal}`);
-    assert.strictEqual(stderr.trim(), '');
 
     const reports = helper.findReports(child.pid, tmpdir.path);
     assert.deepStrictEqual(reports, [], report_msg, reports);
 
     // Test libuv handle key order
     {
-      const get_libuv = /"libuv":\s\[([\s\S]*?)\]/gm;
-      const get_handle_inner = /{([\s\S]*?),*?}/gm;
+      const get_libuv = /"libuv":\s\[([\s\S]*?)\]/g;
+      const get_handle_inner = /{([\s\S]*?),*?}/g;
       const libuv_handles_str = get_libuv.exec(stdout)[1];
       const libuv_handles_array = libuv_handles_str.match(get_handle_inner);
       for (const i of libuv_handles_array) {
         // Exclude nested structure
         if (i.includes('type')) {
-          const handle_keys = i.match(/(".*"):/gm);
+          const handle_keys = i.match(/(".*"):/g);
           assert(handle_keys[0], 'type');
           assert(handle_keys[1], 'is_active');
         }
@@ -116,6 +190,7 @@ if (process.argv[2] === 'child') {
     const expected_filename = `${prefix}${__filename}`;
     const found_tcp = [];
     const found_udp = [];
+    const found_named_pipe = [];
     // Functions are named to aid debugging when they are not called.
     const validators = {
       fs_event: common.mustCall(function fs_event_validator(handle) {
@@ -128,8 +203,26 @@ if (process.argv[2] === 'child') {
         assert.strictEqual(handle.filename, expected_filename);
         assert(handle.is_referenced);
       }),
+      loop: common.mustCall(function loop_validator(handle) {
+        assert.strictEqual(typeof handle.loopIdleTimeSeconds, 'number');
+      }),
       pipe: common.mustCallAtLeast(function pipe_validator(handle) {
         assert(handle.is_referenced);
+        // Pipe handles. The report should contain three pipes:
+        // 1. The server's listening pipe.
+        // 2. The inbound pipe making the request.
+        // 3. The outbound pipe sending the response.
+        //
+        // There is no way to distinguish inbound and outbound in a cross
+        // platform manner, so we just check inbound here.
+        const sockPath = child_data.pipe_sock_path;
+        if (handle.localEndpoint === sockPath) {
+          if (handle.writable === false) {
+            found_named_pipe.push('listening');
+          }
+        } else if (handle.remoteEndpoint === sockPath) {
+          found_named_pipe.push('inbound');
+        }
       }),
       process: common.mustCall(function process_validator(handle) {
         assert.strictEqual(handle.pid, child_data.pid);
@@ -169,7 +262,7 @@ if (process.argv[2] === 'child') {
         assert(handle.is_referenced);
       }, 2),
     };
-    console.log(report.libuv);
+
     for (const entry of report.libuv) {
       if (validators[entry.type]) validators[entry.type](entry);
     }
@@ -179,6 +272,10 @@ if (process.argv[2] === 'child') {
     for (const socket of ['connected', 'unconnected']) {
       assert(found_udp.includes(socket), `${socket} UDP socket was not found`);
     }
+    for (const socket of ['listening', 'inbound']) {
+      assert(found_named_pipe.includes(socket),
+             `${socket} named pipe socket was not found`);
+    }
 
     // Common report tests.
     helper.validateContent(stdout);
diff --git a/test/sequential/sequential.status b/test/sequential/sequential.status
index fce8bd959f0326597270a1addaad57e77bf3af12..a025cb0002655d88d72c384748bafaa2fcba0075 100644
--- a/test/sequential/sequential.status
+++ b/test/sequential/sequential.status
@@ -9,8 +9,6 @@ prefix sequential
 test-cpu-prof-dir-worker: PASS, FLAKY
 
 [$system==win32]
-# https://github.com/nodejs/node/issues/22327
-test-http2-large-file: PASS, FLAKY
 # https://github.com/nodejs/node/issues/26401
 test-worker-prof: PASS, FLAKY
 
@@ -32,6 +30,6 @@ test-buffer-creation-regression: SKIP
 # https://github.com/nodejs/node/pull/30819
 test-perf-hooks: SKIP
 
-[$arch==arm]
+[$arch==arm || $arch==arm64]
 # https://github.com/nodejs/node/issues/26401#issuecomment-613095719
 test-worker-prof: PASS, FLAKY
diff --git a/test/sequential/test-async-wrap-getasyncid.js b/test/sequential/test-async-wrap-getasyncid.js
index 957c7f7440a4bc17e89b2a305de5f6a78fc85283..921fe8fc4bdc86db1f081db1658a5fdd0c2df490 100644
--- a/test/sequential/test-async-wrap-getasyncid.js
+++ b/test/sequential/test-async-wrap-getasyncid.js
@@ -54,6 +54,7 @@ const { getSystemErrorName } = require('util');
     delete providers.ELDHISTOGRAM;
     delete providers.SIGINTWATCHDOG;
     delete providers.WORKERHEAPSNAPSHOT;
+    delete providers.FIXEDSIZEBLOBCOPY;
 
     const objKeys = Object.keys(providers);
     if (objKeys.length > 0)
diff --git a/test/sequential/test-buffer-creation-regression.js b/test/sequential/test-buffer-creation-regression.js
index 07deb1db0fe377c8cb2da2095373151f0adc7911..4122cd0c78a620315369afd139eea498242fbf61 100644
--- a/test/sequential/test-buffer-creation-regression.js
+++ b/test/sequential/test-buffer-creation-regression.js
@@ -17,7 +17,7 @@ function test(arrayBuffer, offset, length) {
 
 const acceptableOOMErrors = [
   'Array buffer allocation failed',
-  'Invalid array buffer length'
+  'Invalid array buffer length',
 ];
 
 const length = 1000;
diff --git a/test/sequential/test-child-process-execsync.js b/test/sequential/test-child-process-execsync.js
index 8c8e36f2a22385aa29c89bca7bef0f6a3dca98ad..bc589efb8b5b6400e14c2dc07831bb4cdf158ed3 100644
--- a/test/sequential/test-child-process-execsync.js
+++ b/test/sequential/test-child-process-execsync.js
@@ -27,6 +27,7 @@ tmpdir.refresh();
 const assert = require('assert');
 
 const { execFileSync, execSync, spawnSync } = require('child_process');
+const { getSystemErrorName } = require('util');
 
 const TIMER = 200;
 const SLEEP = 2000;
@@ -51,7 +52,7 @@ try {
   ret = execSync(cmd, { timeout: TIMER });
 } catch (e) {
   caught = true;
-  assert.strictEqual(e.errno, 'ETIMEDOUT');
+  assert.strictEqual(getSystemErrorName(e.errno), 'ETIMEDOUT');
   err = e;
 } finally {
   assert.strictEqual(ret, undefined,
@@ -86,7 +87,7 @@ const cmd = `"${process.execPath}" -e "console.log('${msg}');"`;
 
 const args = [
   '-e',
-  `console.log("${msg}");`
+  `console.log("${msg}");`,
 ];
 {
   const ret = execFileSync(process.execPath, args);
@@ -127,7 +128,7 @@ const args = [
     'signal',
     'status',
     'stderr',
-    'stdout'
+    'stdout',
   ]);
 
   assert.throws(() => {
diff --git a/test/sequential/test-child-process-exit.js b/test/sequential/test-child-process-exit.js
index 64e188fbf87efcd1f7f397eba8dd1a016c940354..318b6451dd4e30d70eb4ffe308eb1e6eac5b30a5 100644
--- a/test/sequential/test-child-process-exit.js
+++ b/test/sequential/test-child-process-exit.js
@@ -48,12 +48,6 @@ assert.ok(!child.stderr);
 
 console.error('gen=%d, pid=%d', gen, process.pid);
 
-/*
-var timer = setTimeout(function() {
-  throw new Error('timeout! gen='+gen);
-}, 1000);
-*/
-
 child.on('exit', function(code) {
   console.error('exit %d from gen %d', code, gen + 1);
 });
diff --git a/test/sequential/test-cli-syntax-bad.js b/test/sequential/test-cli-syntax-bad.js
index 8298157a57e16e5396087a6cd00abdf1e330b8ab..319746adfb670ee08e9184a6f333fce4ae5f2f93 100644
--- a/test/sequential/test-cli-syntax-bad.js
+++ b/test/sequential/test-cli-syntax-bad.js
@@ -10,7 +10,7 @@ const node = process.execPath;
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
   ['-c'],
-  ['--check']
+  ['--check'],
 ];
 
 // Match on the name of the `Error` but not the message as it is different
@@ -22,7 +22,7 @@ const syntaxErrorRE = /^SyntaxError: \b/m;
   'syntax/bad_syntax.js',
   'syntax/bad_syntax',
   'syntax/bad_syntax_shebang.js',
-  'syntax/bad_syntax_shebang'
+  'syntax/bad_syntax_shebang',
 ].forEach(function(file) {
   file = fixtures.path(file);
 
diff --git a/test/sequential/test-cli-syntax-file-not-found.js b/test/sequential/test-cli-syntax-file-not-found.js
index 3e1f3ec56118b3590376382ddf5f496d9aceecc8..6a4c6338311d58523c691da68188a2dff04a45c9 100644
--- a/test/sequential/test-cli-syntax-file-not-found.js
+++ b/test/sequential/test-cli-syntax-file-not-found.js
@@ -10,7 +10,7 @@ const node = process.execPath;
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
   ['-c'],
-  ['--check']
+  ['--check'],
 ];
 
 const notFoundRE = /^Error: Cannot find module/m;
@@ -18,7 +18,7 @@ const notFoundRE = /^Error: Cannot find module/m;
 // test file not found
 [
   'syntax/file_not_found.js',
-  'syntax/file_not_found'
+  'syntax/file_not_found',
 ].forEach(function(file) {
   file = fixtures.path(file);
 
diff --git a/test/sequential/test-cli-syntax-good.js b/test/sequential/test-cli-syntax-good.js
index 48581e7733da445f793995880e6c4fa3ed33177d..262c30ccad6bce6bb8812af71be78b093d3d817d 100644
--- a/test/sequential/test-cli-syntax-good.js
+++ b/test/sequential/test-cli-syntax-good.js
@@ -10,7 +10,7 @@ const node = process.execPath;
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
   ['-c'],
-  ['--check']
+  ['--check'],
 ];
 
 // Test good syntax with and without shebang
@@ -19,7 +19,7 @@ const syntaxArgs = [
   'syntax/good_syntax',
   'syntax/good_syntax_shebang.js',
   'syntax/good_syntax_shebang',
-  'syntax/illegal_if_not_wrapped.js'
+  'syntax/illegal_if_not_wrapped.js',
 ].forEach(function(file) {
   file = fixtures.path(file);
 
diff --git a/test/sequential/test-debugger-auto-resume.js b/test/sequential/test-debugger-auto-resume.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a25f5fc804e1a94290218b3e8718f30620fbb54
--- /dev/null
+++ b/test/sequential/test-debugger-auto-resume.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+const { addLibraryPath } = require('../common/shared-lib-util');
+
+const assert = require('assert');
+const path = require('path');
+
+addLibraryPath(process.env);
+
+// Auto-resume on start if the environment variable is defined.
+{
+  const scriptFullPath = fixtures.path('debugger', 'break.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
+
+  const env = { ...process.env };
+  env.NODE_INSPECT_RESUME_ON_START = '1';
+
+  const cli = startCLI([script], [], { env });
+
+  cli.waitForInitialBreak()
+    .then(() => {
+      assert.deepStrictEqual(
+        cli.breakInfo,
+        { filename: script, line: 10 },
+      );
+    })
+    .then(() => cli.quit())
+    .then((code) => {
+      assert.strictEqual(code, 0);
+    });
+}
diff --git a/deps/node-inspect/test/cli/backtrace.test.js b/test/sequential/test-debugger-backtrace.js
similarity index 43%
rename from deps/node-inspect/test/cli/backtrace.test.js
rename to test/sequential/test-debugger-backtrace.js
index 127ea56bf853029ab46652214b7beb0f62da4348..f362e98068f15e3805f8e717cc25cf8f679b51a6 100644
--- a/deps/node-inspect/test/cli/backtrace.test.js
+++ b/test/sequential/test-debugger-backtrace.js
@@ -1,12 +1,18 @@
 'use strict';
-const Path = require('path');
+const common = require('../common');
 
-const { test } = require('tap');
+common.skipIfInspectorDisabled();
 
-const startCLI = require('./start-cli');
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-test('display and navigate backtrace', (t) => {
-  const script = Path.join('examples', 'backtrace.js');
+const assert = require('assert');
+const path = require('path');
+
+// Display and navigate backtrace.
+{
+  const scriptFullPath = fixtures.path('debugger', 'backtrace.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
   const cli = startCLI([script]);
 
   function onFatal(error) {
@@ -19,12 +25,12 @@ test('display and navigate backtrace', (t) => {
     .then(() => cli.stepCommand('c'))
     .then(() => cli.command('bt'))
     .then(() => {
-      t.match(cli.output, `#0 topFn ${script}:7:2`);
+      assert.ok(cli.output.includes(`#0 topFn ${script}:7:2`));
     })
     .then(() => cli.command('backtrace'))
     .then(() => {
-      t.match(cli.output, `#0 topFn ${script}:7:2`);
+      assert.ok(cli.output.includes(`#0 topFn ${script}:7:2`));
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/deps/node-inspect/test/cli/break.test.js b/test/sequential/test-debugger-break.js
similarity index 36%
rename from deps/node-inspect/test/cli/break.test.js
rename to test/sequential/test-debugger-break.js
index ff71a36481571725a16eb2ad41de36807407165f..7c92aedc435eab9b6fa866096edbf4e8249242e5 100644
--- a/deps/node-inspect/test/cli/break.test.js
+++ b/test/sequential/test-debugger-break.js
@@ -1,12 +1,18 @@
 'use strict';
-const Path = require('path');
+const common = require('../common');
 
-const { test } = require('tap');
+common.skipIfInspectorDisabled();
 
-const startCLI = require('./start-cli');
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-test('stepping through breakpoints', (t) => {
-  const script = Path.join('examples', 'break.js');
+const assert = require('assert');
+const path = require('path');
+
+// Stepping through breakpoints.
+{
+  const scriptFullPath = fixtures.path('debugger', 'break.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
   const cli = startCLI([script]);
 
   function onFatal(error) {
@@ -14,182 +20,112 @@ test('stepping through breakpoints', (t) => {
     throw error;
   }
 
-  return cli.waitForInitialBreak()
+  cli.waitForInitialBreak()
     .then(() => cli.waitForPrompt())
     .then(() => {
-      t.match(
+      assert.deepStrictEqual(
         cli.breakInfo,
         { filename: script, line: 1 },
-        'pauses in the first line of the script');
-      t.match(
+      );
+      assert.match(
         cli.output,
         /> 1 (?:\(function \([^)]+\) \{ )?const x = 10;/,
         'shows the source and marks the current line');
     })
     .then(() => cli.stepCommand('n'))
     .then(() => {
-      t.match(
-        cli.output,
-        `break in ${script}:2`,
+      assert.ok(
+        cli.output.includes(`break in ${script}:2`),
         'pauses in next line of the script');
-      t.match(
+      assert.match(
         cli.output,
-        '> 2 let name = \'World\';',
+        /> 2 let name = 'World';/,
         'marks the 2nd line');
     })
     .then(() => cli.stepCommand('next'))
     .then(() => {
-      t.match(
-        cli.output,
-        `break in ${script}:3`,
+      assert.ok(
+        cli.output.includes(`break in ${script}:3`),
         'pauses in next line of the script');
-      t.match(
+      assert.match(
         cli.output,
-        '> 3 name = \'Robin\';',
+        /> 3 name = 'Robin';/,
         'marks the 3nd line');
     })
     .then(() => cli.stepCommand('cont'))
     .then(() => {
-      t.match(
-        cli.output,
-        `break in ${script}:10`,
+      assert.ok(
+        cli.output.includes(`break in ${script}:10`),
         'pauses on the next breakpoint');
-      t.match(
+      assert.match(
         cli.output,
-        '>10 debugger;',
+        />10 debugger;/,
         'marks the debugger line');
     })
 
     // Prepare additional breakpoints
     .then(() => cli.command('sb("break.js", 6)'))
-    .then(() => t.notMatch(cli.output, 'Could not resolve breakpoint'))
+    .then(() => assert.doesNotMatch(cli.output, /Could not resolve breakpoint/))
     .then(() => cli.command('sb("otherFunction()")'))
     .then(() => cli.command('sb(16)'))
-    .then(() => t.notMatch(cli.output, 'Could not resolve breakpoint'))
+    .then(() => assert.doesNotMatch(cli.output, /Could not resolve breakpoint/))
     .then(() => cli.command('breakpoints'))
     .then(() => {
-      t.match(cli.output, `#0 ${script}:6`);
-      t.match(cli.output, `#1 ${script}:16`);
+      assert.ok(cli.output.includes(`#0 ${script}:6`));
+      assert.ok(cli.output.includes(`#1 ${script}:16`));
     })
 
     .then(() => cli.command('list()'))
     .then(() => {
-      t.match(cli.output, '>10 debugger;', 'prints and marks current line');
-      t.strictDeepEqual(
+      assert.match(
+        cli.output,
+        />10 debugger;/,
+        'prints and marks current line'
+      );
+      assert.deepStrictEqual(
         cli.parseSourceLines(),
         [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
-        'prints 5 lines before and after');
+      );
     })
     .then(() => cli.command('list(2)'))
     .then(() => {
-      t.match(cli.output, '>10 debugger;', 'prints and marks current line');
-      t.strictDeepEqual(
+      assert.match(
+        cli.output,
+        />10 debugger;/,
+        'prints and marks current line'
+      );
+      assert.deepStrictEqual(
         cli.parseSourceLines(),
         [8, 9, 10, 11, 12],
-        'prints 2 lines before and after');
+      );
     })
 
     .then(() => cli.stepCommand('s'))
     .then(() => cli.stepCommand(''))
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
-        'break in timers.js',
+        /break in timers/,
         'entered timers.js');
     })
     .then(() => cli.stepCommand('cont'))
     .then(() => {
-      t.match(
-        cli.output,
-        `break in ${script}:16`,
+      assert.ok(
+        cli.output.includes(`break in ${script}:16`),
         'found breakpoint we set above w/ line number only');
     })
     .then(() => cli.stepCommand('cont'))
     .then(() => {
-      t.match(
-        cli.output,
-        `break in ${script}:6`,
+      assert.ok(
+        cli.output.includes(`break in ${script}:6`),
         'found breakpoint we set above w/ line number & script');
     })
     .then(() => cli.stepCommand(''))
     .then(() => {
-      t.match(
-        cli.output,
-        `debugCommand in ${script}:14`,
+      assert.ok(
+        cli.output.includes(`debugCommand in ${script}:14`),
         'found function breakpoint we set above');
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
-
-test('sb before loading file', (t) => {
-  const script = Path.join('examples', 'cjs', 'index.js');
-  const otherScript = Path.join('examples', 'cjs', 'other.js');
-  const cli = startCLI([script]);
-
-  function onFatal(error) {
-    cli.quit();
-    throw error;
-  }
-
-  return cli.waitForInitialBreak()
-    .then(() => cli.waitForPrompt())
-    .then(() => cli.command('sb("other.js", 2)'))
-    .then(() => {
-      t.match(
-        cli.output,
-        'not loaded yet',
-        'warns that the script was not loaded yet');
-    })
-    .then(() => cli.stepCommand('cont'))
-    .then(() => {
-      t.match(
-        cli.output,
-        `break in ${otherScript}:2`,
-        'found breakpoint in file that was not loaded yet');
-    })
-    .then(() => cli.quit())
-    .then(null, onFatal);
-});
-
-test('clearBreakpoint', (t) => {
-  const script = Path.join('examples', 'break.js');
-  const cli = startCLI([script]);
-
-  function onFatal(error) {
-    cli.quit();
-    throw error;
-  }
-
-  return cli.waitForInitialBreak()
-    .then(() => cli.waitForPrompt())
-    .then(() => cli.command('sb("break.js", 3)'))
-    .then(() => cli.command('sb("break.js", 9)'))
-    .then(() => cli.command('breakpoints'))
-    .then(() => {
-      t.match(cli.output, `#0 ${script}:3`);
-      t.match(cli.output, `#1 ${script}:9`);
-    })
-    .then(() => cli.command('clearBreakpoint("break.js", 4)'))
-    .then(() => {
-      t.match(cli.output, 'Could not find breakpoint');
-    })
-    .then(() => cli.command('clearBreakpoint("not-such-script.js", 3)'))
-    .then(() => {
-      t.match(cli.output, 'Could not find breakpoint');
-    })
-    .then(() => cli.command('clearBreakpoint("break.js", 3)'))
-    .then(() => cli.command('breakpoints'))
-    .then(() => {
-      t.match(cli.output, `#0 ${script}:9`);
-    })
-    .then(() => cli.stepCommand('cont'))
-    .then(() => {
-      t.match(
-        cli.output,
-        `break in ${script}:9`,
-        'hits the 2nd breakpoint because the 1st was cleared');
-    })
-    .then(() => cli.quit())
-    .then(null, onFatal);
-});
+}
diff --git a/test/sequential/test-debugger-breakpoint-exists.js b/test/sequential/test-debugger-breakpoint-exists.js
new file mode 100644
index 0000000000000000000000000000000000000000..7be0ba657fa9814c60e6a69842df60b8246b623a
--- /dev/null
+++ b/test/sequential/test-debugger-breakpoint-exists.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+// Test for "Breakpoint at specified location already exists" error.
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('setBreakpoint(1)'))
+    .then(() => cli.command('setBreakpoint(1)'))
+    .then(() => cli.waitFor(/Breakpoint at specified location already exists/))
+    .then(() => cli.quit())
+    .then(null, onFatal);
+}
diff --git a/test/sequential/test-debugger-clear-breakpoints.js b/test/sequential/test-debugger-clear-breakpoints.js
new file mode 100644
index 0000000000000000000000000000000000000000..91349e105a11601968e3f94dbf1cc54a7d953f16
--- /dev/null
+++ b/test/sequential/test-debugger-clear-breakpoints.js
@@ -0,0 +1,53 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const path = require('path');
+
+// clearBreakpoint
+{
+  const scriptFullPath = fixtures.path('debugger', 'break.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('sb("break.js", 3)'))
+    .then(() => cli.command('sb("break.js", 9)'))
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      assert.ok(cli.output.includes(`#0 ${script}:3`));
+      assert.ok(cli.output.includes(`#1 ${script}:9`));
+    })
+    .then(() => cli.command('clearBreakpoint("break.js", 4)'))
+    .then(() => {
+      assert.match(cli.output, /Could not find breakpoint/);
+    })
+    .then(() => cli.command('clearBreakpoint("not-such-script.js", 3)'))
+    .then(() => {
+      assert.match(cli.output, /Could not find breakpoint/);
+    })
+    .then(() => cli.command('clearBreakpoint("break.js", 3)'))
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      assert.ok(cli.output.includes(`#0 ${script}:9`));
+    })
+    .then(() => cli.stepCommand('cont'))
+    .then(() => {
+      assert.ok(
+        cli.output.includes(`break in ${script}:9`),
+        'hits the 2nd breakpoint because the 1st was cleared');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+}
diff --git a/test/sequential/test-debugger-custom-port.js b/test/sequential/test-debugger-custom-port.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6cee10ffa53b5de49e9d684b38a8266f9797158
--- /dev/null
+++ b/test/sequential/test-debugger-custom-port.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Custom port.
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
+
+  const cli = startCLI([`--port=${common.PORT}`, script]);
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      assert.match(cli.output, /debug>/, 'prints a prompt');
+      assert.match(
+        cli.output,
+        new RegExp(`< Debugger listening on [^\n]*${common.PORT}`),
+        'forwards child output');
+    })
+    .then(() => cli.quit())
+    .then((code) => {
+      assert.strictEqual(code, 0);
+    });
+}
diff --git a/deps/node-inspect/test/cli/exceptions.test.js b/test/sequential/test-debugger-exceptions.js
similarity index 55%
rename from deps/node-inspect/test/cli/exceptions.test.js
rename to test/sequential/test-debugger-exceptions.js
index 69d42d0a25bb1a1826af455c50c8c73db60d99ae..9b1163316268c70b6f24d70826b266597b20d8df 100644
--- a/deps/node-inspect/test/cli/exceptions.test.js
+++ b/test/sequential/test-debugger-exceptions.js
@@ -1,12 +1,18 @@
 'use strict';
-const Path = require('path');
+const common = require('../common');
 
-const { test } = require('tap');
+common.skipIfInspectorDisabled();
 
-const startCLI = require('./start-cli');
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-test('break on (uncaught) exceptions', (t) => {
-  const script = Path.join('examples', 'exceptions.js');
+const assert = require('assert');
+const path = require('path');
+
+// Break on (uncaught) exceptions.
+{
+  const scriptFullPath = fixtures.path('debugger', 'exceptions.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
   const cli = startCLI([script]);
 
   function onFatal(error) {
@@ -14,42 +20,42 @@ test('break on (uncaught) exceptions', (t) => {
     throw error;
   }
 
-  return cli.waitForInitialBreak()
+  cli.waitForInitialBreak()
     .then(() => cli.waitForPrompt())
     .then(() => {
-      t.match(cli.breakInfo, { filename: script, line: 1 });
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
     })
-    // making sure it will die by default:
+    // Making sure it will die by default:
     .then(() => cli.command('c'))
-    // TODO: Remove FATAL ERROR once node doesn't show a FATAL ERROR anymore
+    // TODO: Remove FATAL ERROR once node doesn't show a FATAL ERROR anymore.
     .then(() => cli.waitFor(/disconnect|FATAL ERROR/))
 
-    // Next run: With `breakOnException` it pauses in both places
+    // Next run: With `breakOnException` it pauses in both places.
     .then(() => cli.stepCommand('r'))
     .then(() => cli.waitForInitialBreak())
     .then(() => {
-      t.match(cli.breakInfo, { filename: script, line: 1 });
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
     })
     .then(() => cli.command('breakOnException'))
     .then(() => cli.stepCommand('c'))
     .then(() => {
-      t.match(cli.output, `exception in ${script}:3`);
+      assert.ok(cli.output.includes(`exception in ${script}:3`));
     })
     .then(() => cli.stepCommand('c'))
     .then(() => {
-      t.match(cli.output, `exception in ${script}:9`);
+      assert.ok(cli.output.includes(`exception in ${script}:9`));
     })
 
-    // Next run: With `breakOnUncaught` it only pauses on the 2nd exception
+    // Next run: With `breakOnUncaught` it only pauses on the 2nd exception.
     .then(() => cli.command('breakOnUncaught'))
-    .then(() => cli.stepCommand('r')) // also, the setting survives the restart
+    .then(() => cli.stepCommand('r')) // Also, the setting survives the restart.
     .then(() => cli.waitForInitialBreak())
     .then(() => {
-      t.match(cli.breakInfo, { filename: script, line: 1 });
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
     })
     .then(() => cli.stepCommand('c'))
     .then(() => {
-      t.match(cli.output, `exception in ${script}:9`);
+      assert.ok(cli.output.includes(`exception in ${script}:9`));
     })
 
     // Next run: Back to the initial state! It should die again.
@@ -57,7 +63,7 @@ test('break on (uncaught) exceptions', (t) => {
     .then(() => cli.stepCommand('r'))
     .then(() => cli.waitForInitialBreak())
     .then(() => {
-      t.match(cli.breakInfo, { filename: script, line: 1 });
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
     })
     .then(() => cli.command('c'))
     // TODO: Remove FATAL ERROR once node doesn't show a FATAL ERROR anymore
@@ -65,4 +71,4 @@ test('break on (uncaught) exceptions', (t) => {
 
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/test/sequential/test-debugger-exec-scope.js b/test/sequential/test-debugger-exec-scope.js
new file mode 100644
index 0000000000000000000000000000000000000000..9e5d2ac7ebaeebfb87a01a4d3bfa974acf0efd4d
--- /dev/null
+++ b/test/sequential/test-debugger-exec-scope.js
@@ -0,0 +1,38 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// exec .scope
+{
+  const cli = startCLI([fixtures.path('debugger/backtrace.js')]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.stepCommand('c'))
+    .then(() => cli.command('exec .scope'))
+    .then(() => {
+      assert.match(
+        cli.output,
+        /'moduleScoped'/, 'displays closure from module body');
+      assert.match(cli.output, /'a'/, 'displays local / function arg');
+      assert.match(cli.output, /'l1'/, 'displays local scope');
+      assert.doesNotMatch(
+        cli.output,
+        /'encodeURIComponent'/,
+        'omits global scope'
+      );
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+}
diff --git a/deps/node-inspect/test/cli/exec.test.js b/test/sequential/test-debugger-exec.js
similarity index 43%
rename from deps/node-inspect/test/cli/exec.test.js
rename to test/sequential/test-debugger-exec.js
index acfd6e34abb279b52bebac1e12825e922036aab4..68a9b37d09d6aa623cb5f9a0202a11b5291aae7f 100644
--- a/deps/node-inspect/test/cli/exec.test.js
+++ b/test/sequential/test-debugger-exec.js
@@ -1,77 +1,67 @@
 'use strict';
-const { test } = require('tap');
+const common = require('../common');
 
-const startCLI = require('./start-cli');
+common.skipIfInspectorDisabled();
 
-test('examples/alive.js', (t) => {
-  const cli = startCLI(['examples/alive.js']);
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+{
+
+  const cli = startCLI([fixtures.path('debugger/alive.js')]);
 
   function onFatal(error) {
     cli.quit();
     throw error;
   }
 
-  return cli.waitForInitialBreak()
+  cli.waitForInitialBreak()
     .then(() => cli.waitForPrompt())
     .then(() => cli.command('exec [typeof heartbeat, typeof process.exit]'))
     .then(() => {
-      t.match(cli.output, '[ \'function\', \'function\' ]', 'works w/o paren');
+      assert.match(
+        cli.output,
+        /\[ 'function', 'function' \]/,
+        'works w/o paren'
+      );
     })
     .then(() => cli.command('repl'))
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
-        'Press Ctrl + C to leave debug repl\n> ',
+        /Press Ctrl\+C to leave debug repl\n+> /,
         'shows hint for how to leave repl');
-      t.notMatch(cli.output, 'debug>', 'changes the repl style');
+      assert.doesNotMatch(cli.output, /debug>/, 'changes the repl style');
     })
     .then(() => cli.command('[typeof heartbeat, typeof process.exit]'))
     .then(() => cli.waitFor(/function/))
     .then(() => cli.waitForPrompt())
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
-        '[ \'function\', \'function\' ]', 'can evaluate in the repl');
-      t.match(cli.output, /> $/);
+        /\[ 'function', 'function' \]/, 'can evaluate in the repl');
+      assert.match(cli.output, /> $/);
     })
     .then(() => cli.ctrlC())
     .then(() => cli.waitFor(/debug> $/))
     .then(() => cli.command('exec("[typeof heartbeat, typeof process.exit]")'))
     .then(() => {
-      t.match(cli.output, '[ \'function\', \'function\' ]', 'works w/ paren');
+      assert.match(
+        cli.output,
+        /\[ 'function', 'function' \]/,
+        'works w/ paren'
+      );
     })
     .then(() => cli.command('cont'))
     .then(() => cli.command('exec [typeof heartbeat, typeof process.exit]'))
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
-        '[ \'undefined\', \'function\' ]',
+        /\[ 'undefined', 'function' \]/,
         'non-paused exec can see global but not module-scope values');
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
-
-test('exec .scope', (t) => {
-  const cli = startCLI(['examples/backtrace.js']);
-
-  function onFatal(error) {
-    cli.quit();
-    throw error;
-  }
-
-  return cli.waitForInitialBreak()
-    .then(() => cli.waitForPrompt())
-    .then(() => cli.stepCommand('c'))
-    .then(() => cli.command('exec .scope'))
-    .then(() => {
-      t.match(
-        cli.output,
-        '\'moduleScoped\'', 'displays closure from module body');
-      t.match(cli.output, '\'a\'', 'displays local / function arg');
-      t.match(cli.output, '\'l1\'', 'displays local scope');
-      t.notMatch(cli.output, '\'encodeURIComponent\'', 'omits global scope');
-    })
-    .then(() => cli.quit())
-    .then(null, onFatal);
-});
+}
diff --git a/deps/node-inspect/test/cli/heap-profiler.test.js b/test/sequential/test-debugger-heap-profiler.js
similarity index 32%
rename from deps/node-inspect/test/cli/heap-profiler.test.js
rename to test/sequential/test-debugger-heap-profiler.js
index ebd734e03cb06d1a0bebd40d2c58801c6f0c10bc..86eb9d9d0d232fb563f3cea20eb9de4c53c34b78 100644
--- a/deps/node-inspect/test/cli/heap-profiler.test.js
+++ b/test/sequential/test-debugger-heap-profiler.js
@@ -1,22 +1,23 @@
 'use strict';
-const { test } = require('tap');
-const { readFileSync, unlinkSync } = require('fs');
+const common = require('../common');
 
-const startCLI = require('./start-cli');
-const filename = 'node.heapsnapshot';
+common.skipIfInspectorDisabled();
 
-function cleanup() {
-  try {
-    unlinkSync(filename);
-  } catch (_) {
-    // Ignore.
-  }
-}
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+const tmpdir = require('../common/tmpdir');
+const path = require('path');
+
+tmpdir.refresh();
 
-cleanup();
+const { readFileSync } = require('fs');
 
-test('Heap profiler take snapshot', (t) => {
-  const cli = startCLI(['examples/empty.js']);
+const filename = path.join(tmpdir.path, 'node.heapsnapshot');
+
+// Heap profiler take snapshot.
+{
+  const opts = { cwd: tmpdir.path };
+  const cli = startCLI([fixtures.path('debugger/empty.js')], [], opts);
 
   function onFatal(error) {
     cli.quit();
@@ -28,7 +29,10 @@ test('Heap profiler take snapshot', (t) => {
     .then(() => cli.waitForPrompt())
     .then(() => cli.command('takeHeapSnapshot()'))
     .then(() => JSON.parse(readFileSync(filename, 'utf8')))
-    .then(() => cleanup())
+    // Check that two simultaneous snapshots don't step all over each other.
+    // Refs: https://github.com/nodejs/node/issues/39555
+    .then(() => cli.command('takeHeapSnapshot(); takeHeapSnapshot()'))
+    .then(() => JSON.parse(readFileSync(filename, 'utf8')))
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/deps/node-inspect/test/cli/help.test.js b/test/sequential/test-debugger-help.js
similarity index 45%
rename from deps/node-inspect/test/cli/help.test.js
rename to test/sequential/test-debugger-help.js
index 9f0c081bdee39a59eb9ba7261cfa08166ac9fdee..e24f873212b58950cecb1702d4e9813dd3ed48a1 100644
--- a/deps/node-inspect/test/cli/help.test.js
+++ b/test/sequential/test-debugger-help.js
@@ -1,10 +1,15 @@
 'use strict';
-const { test } = require('tap');
+const common = require('../common');
 
-const startCLI = require('./start-cli');
+common.skipIfInspectorDisabled();
 
-test('examples/empty.js', (t) => {
-  const cli = startCLI(['examples/empty.js']);
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+{
+  const cli = startCLI([fixtures.path('debugger/empty.js')]);
 
   function onFatal(error) {
     cli.quit();
@@ -15,8 +20,8 @@ test('examples/empty.js', (t) => {
     .then(() => cli.waitForPrompt())
     .then(() => cli.command('help'))
     .then(() => {
-      t.match(cli.output, /run, restart, r\s+/m);
+      assert.match(cli.output, /run, restart, r\s+/m);
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/test/sequential/test-debugger-invalid-args.js b/test/sequential/test-debugger-invalid-args.js
new file mode 100644
index 0000000000000000000000000000000000000000..36f8e588b04a6e46cfeba6b9a0413e8985a1e389
--- /dev/null
+++ b/test/sequential/test-debugger-invalid-args.js
@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Launch CLI w/o args.
+{
+  const cli = startCLI([]);
+  cli.quit()
+    .then((code) => {
+      assert.strictEqual(code, 1);
+      assert.match(cli.output, /^Usage:/, 'Prints usage info');
+    });
+}
+
+// Launch w/ invalid host:port.
+{
+  const cli = startCLI([`localhost:${common.PORT}`]);
+  cli.quit()
+    .then((code) => {
+      assert.match(
+        cli.output,
+        /failed to connect/,
+        'Tells the user that the connection failed');
+      assert.strictEqual(code, 1);
+    });
+}
diff --git a/test/sequential/test-debugger-launch.js b/test/sequential/test-debugger-launch.js
new file mode 100644
index 0000000000000000000000000000000000000000..3bfe541ecca05c2b886079ef7148656b0aec662c
--- /dev/null
+++ b/test/sequential/test-debugger-launch.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
+  const cli = startCLI([script]);
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      assert.match(cli.output, /debug>/, 'prints a prompt');
+      assert.match(
+        cli.output,
+        /< Debugger listening on [^\n]*9229/,
+        'forwards child output');
+    })
+    .then(() => cli.command('["hello", "world"].join(" ")'))
+    .then(() => {
+      assert.match(cli.output, /hello world/, 'prints the result');
+    })
+    .then(() => cli.command(''))
+    .then(() => {
+      assert.match(
+        cli.output,
+        /hello world/,
+        'repeats the last command on <enter>'
+      );
+    })
+    .then(() => cli.command('version'))
+    .then(() => {
+      assert.ok(
+        cli.output.includes(process.versions.v8),
+        'version prints the v8 version'
+      );
+    })
+    .then(() => cli.quit())
+    .then((code) => {
+      assert.strictEqual(code, 0);
+    });
+}
diff --git a/deps/node-inspect/test/cli/low-level.test.js b/test/sequential/test-debugger-low-level.js
similarity index 57%
rename from deps/node-inspect/test/cli/low-level.test.js
rename to test/sequential/test-debugger-low-level.js
index 2a41359825612fa47c1f7d955231783b3dff6905..f6d97f2dfe153d5ea371aaab5615e940aeac155e 100644
--- a/deps/node-inspect/test/cli/low-level.test.js
+++ b/test/sequential/test-debugger-low-level.js
@@ -1,11 +1,16 @@
 'use strict';
-const { test } = require('tap');
+const common = require('../common');
 
-const startCLI = require('./start-cli');
+common.skipIfInspectorDisabled();
 
-test('Debugger agent direct access', (t) => {
-  const cli = startCLI(['examples/three-lines.js']);
-  const scriptPattern = /^\* (\d+): examples(?:\/|\\)three-lines.js/;
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+const assert = require('assert');
+
+// Debugger agent direct access.
+{
+  const cli = startCLI([fixtures.path('debugger/three-lines.js')]);
+  const scriptPattern = /^\* (\d+): \S+debugger(?:\/|\\)three-lines\.js/m;
 
   function onFatal(error) {
     cli.quit();
@@ -22,13 +27,13 @@ test('Debugger agent direct access', (t) => {
       );
     })
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
         /scriptSource:[ \n]*'(?:\(function \(|let x = 1)/);
-      t.match(
+      assert.match(
         cli.output,
         /let x = 1;/);
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/deps/node-inspect/test/cli/pid.test.js b/test/sequential/test-debugger-pid.js
similarity index 61%
rename from deps/node-inspect/test/cli/pid.test.js
rename to test/sequential/test-debugger-pid.js
index 15d7fdeaa5f49b63eb8c0dbdaedfe308895309fb..402c1f86dd4ed99b413eca5fce8a2db47797b11a 100644
--- a/deps/node-inspect/test/cli/pid.test.js
+++ b/test/sequential/test-debugger-pid.js
@@ -1,22 +1,22 @@
 'use strict';
-const { spawn } = require('child_process');
-const Path = require('path');
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-const { test } = require('tap');
+const assert = require('assert');
+const { spawn } = require('child_process');
 
-const startCLI = require('./start-cli');
 
 function launchTarget(...args) {
   const childProc = spawn(process.execPath, args);
   return Promise.resolve(childProc);
 }
 
-// process.debugPort is our proxy for "the version of node used to run this
-// test suite doesn't support SIGUSR1 for enabling --inspect for a process".
-const defaultsToOldProtocol = process.debugPort === 5858;
-
-test('examples/alive.js', { skip: defaultsToOldProtocol }, (t) => {
-  const script = Path.join('examples', 'alive.js');
+{
+  const script = fixtures.path('debugger', 'alive.js');
   let cli = null;
   let target = null;
 
@@ -29,7 +29,7 @@ test('examples/alive.js', { skip: defaultsToOldProtocol }, (t) => {
       target.kill();
       target = null;
     }
-    if (error) throw error;
+    assert.ifError(error);
   }
 
   return launchTarget(script)
@@ -42,11 +42,11 @@ test('examples/alive.js', { skip: defaultsToOldProtocol }, (t) => {
     .then(() => cli.waitFor(/break/))
     .then(() => cli.waitForPrompt())
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
-        '> 3   ++x;',
+        /> 3   \+\+x;/,
         'marks the 3rd line');
     })
     .then(() => cleanup())
     .then(null, cleanup);
-});
+}
diff --git a/deps/node-inspect/test/cli/preserve-breaks.test.js b/test/sequential/test-debugger-preserve-breaks.js
similarity index 44%
rename from deps/node-inspect/test/cli/preserve-breaks.test.js
rename to test/sequential/test-debugger-preserve-breaks.js
index affa3ad975c915e5b78861449603eaa5c20c2663..fbc463af96a1e64f7bab6e803d696475c470be67 100644
--- a/deps/node-inspect/test/cli/preserve-breaks.test.js
+++ b/test/sequential/test-debugger-preserve-breaks.js
@@ -1,12 +1,18 @@
 'use strict';
-const Path = require('path');
+const common = require('../common');
 
-const { test } = require('tap');
+common.skipIfInspectorDisabled();
 
-const startCLI = require('./start-cli');
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-test('run after quit / restart', (t) => {
-  const script = Path.join('examples', 'three-lines.js');
+const assert = require('assert');
+const path = require('path');
+
+// Run after quit.
+{
+  const scriptFullPath = fixtures.path('debugger', 'three-lines.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
   const cli = startCLI([script]);
 
   function onFatal(error) {
@@ -18,47 +24,39 @@ test('run after quit / restart', (t) => {
     .then(() => cli.waitForPrompt())
     .then(() => cli.command('breakpoints'))
     .then(() => {
-      t.match(cli.output, 'No breakpoints yet');
+      assert.match(cli.output, /No breakpoints yet/);
     })
     .then(() => cli.command('sb(2)'))
     .then(() => cli.command('sb(3)'))
     .then(() => cli.command('breakpoints'))
     .then(() => {
-      t.match(cli.output, `#0 ${script}:2`);
-      t.match(cli.output, `#1 ${script}:3`);
+      assert.ok(cli.output.includes(`#0 ${script}:2`));
+      assert.ok(cli.output.includes(`#1 ${script}:3`));
     })
     .then(() => cli.stepCommand('c')) // hit line 2
     .then(() => cli.stepCommand('c')) // hit line 3
     .then(() => {
-      t.match(cli.breakInfo, { filename: script, line: 3 });
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 3 });
     })
     .then(() => cli.command('restart'))
     .then(() => cli.waitForInitialBreak())
     .then(() => {
-      t.match(cli.breakInfo, { filename: script, line: 1 });
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
     })
     .then(() => cli.stepCommand('c'))
     .then(() => {
-      t.match(cli.breakInfo, { filename: script, line: 2 });
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 2 });
     })
     .then(() => cli.stepCommand('c'))
     .then(() => {
-      t.match(cli.breakInfo, { filename: script, line: 3 });
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 3 });
     })
     .then(() => cli.command('breakpoints'))
     .then(() => {
-      if (process.platform === 'aix') {
-        // TODO: There is a known issue on AIX where the breakpoints aren't
-        // properly resolved yet when we reach this point.
-        // Eventually that should be figured out but for now we don't want
-        // to fail builds because of it.
-        t.match(cli.output, /#0 [^\n]+three-lines\.js\$?:2/);
-        t.match(cli.output, /#1 [^\n]+three-lines\.js\$?:3/);
-      } else {
-        t.match(cli.output, `#0 ${script}:2`);
-        t.match(cli.output, `#1 ${script}:3`);
-      }
+      const msg = `SCRIPT: ${script}, OUTPUT: ${cli.output}`;
+      assert.ok(cli.output.includes(`#0 ${script}:2`), msg);
+      assert.ok(cli.output.includes(`#1 ${script}:3`), msg);
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/deps/node-inspect/test/cli/profile.test.js b/test/sequential/test-debugger-profile.js
similarity index 52%
rename from deps/node-inspect/test/cli/profile.test.js
rename to test/sequential/test-debugger-profile.js
index 0f900c5a2b06f8b452298888a4cca93a75e087cd..992c6f71c00775848fe43fd00a278d5f8c2fa93d 100644
--- a/deps/node-inspect/test/cli/profile.test.js
+++ b/test/sequential/test-debugger-profile.js
@@ -1,14 +1,20 @@
 'use strict';
-const { test } = require('tap');
+const common = require('../common');
 
-const startCLI = require('./start-cli');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
 
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-test('profiles', (t) => {
-  const cli = startCLI(['examples/empty.js']);
+// Profiles.
+{
+  const cli = startCLI([fixtures.path('debugger/empty.js')]);
 
   function onFatal(error) {
     cli.quit();
@@ -19,14 +25,14 @@ test('profiles', (t) => {
     .then(() => cli.waitForPrompt())
     .then(() => cli.command('exec console.profile()'))
     .then(() => {
-      t.match(cli.output, 'undefined');
+      assert.match(cli.output, /undefined/);
     })
     .then(() => cli.command('exec console.profileEnd()'))
     .then(() => delay(250))
     .then(() => {
-      t.match(cli.output, 'undefined');
-      t.match(cli.output, 'Captured new CPU profile.');
+      assert.match(cli.output, /undefined/);
+      assert.match(cli.output, /Captured new CPU profile\./);
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/test/sequential/test-debugger-random-port-with-inspect-port.js b/test/sequential/test-debugger-random-port-with-inspect-port.js
new file mode 100644
index 0000000000000000000000000000000000000000..5617e130f02585b588465268ce57e5525509f357
--- /dev/null
+++ b/test/sequential/test-debugger-random-port-with-inspect-port.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Random port with --inspect-port=0.
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
+
+  const cli = startCLI(['--inspect-port=0', script]);
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      assert.match(cli.output, /debug>/, 'prints a prompt');
+      assert.match(
+        cli.output,
+        /< Debugger listening on /,
+        'forwards child output');
+    })
+    .then(() => cli.quit())
+    .then((code) => {
+      assert.strictEqual(code, 0);
+    });
+}
diff --git a/test/sequential/test-debugger-random-port.js b/test/sequential/test-debugger-random-port.js
new file mode 100644
index 0000000000000000000000000000000000000000..da8656cf1c7115727c4d7ed28d02450f87a5b628
--- /dev/null
+++ b/test/sequential/test-debugger-random-port.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Random port.
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
+
+  const cli = startCLI(['--port=0', script]);
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      assert.match(cli.output, /debug>/, 'prints a prompt');
+      assert.match(
+        cli.output,
+        /< Debugger listening on /,
+        'forwards child output');
+    })
+    .then(() => cli.quit())
+    .then((code) => {
+      assert.strictEqual(code, 0);
+    });
+}
diff --git a/test/sequential/test-debugger-repeat-last.js b/test/sequential/test-debugger-repeat-last.js
index 42638e5d2ebf12aae02fe51b0d0ec7a31253a3e2..5bdcc7dc8c86429451e916dfa254f242e3524435 100644
--- a/test/sequential/test-debugger-repeat-last.js
+++ b/test/sequential/test-debugger-repeat-last.js
@@ -9,7 +9,7 @@ const fixture = path('debugger-repeat-last.js');
 const args = [
   'inspect',
   `--port=${common.PORT}`,
-  fixture
+  fixture,
 ];
 
 const proc = spawn(process.execPath, args, { stdio: 'pipe' });
diff --git a/test/sequential/test-debugger-restart-message.js b/test/sequential/test-debugger-restart-message.js
new file mode 100644
index 0000000000000000000000000000000000000000..bcd06b4e230131450a07c31c9afbaf33277d977b
--- /dev/null
+++ b/test/sequential/test-debugger-restart-message.js
@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+
+const RESTARTS = 10;
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+// Using `restart` should result in only one "Connect/For help" message.
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  const listeningRegExp = /Debugger listening on/g;
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      assert.strictEqual(cli.output.match(listeningRegExp).length, 1);
+    })
+    .then(async () => {
+      for (let i = 0; i < RESTARTS; i++) {
+        await cli.stepCommand('restart');
+        assert.strictEqual(cli.output.match(listeningRegExp).length, 1);
+      }
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+}
diff --git a/test/sequential/test-debugger-run-after-quit-restart.js b/test/sequential/test-debugger-run-after-quit-restart.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9da07dcdff8bd0b8cc69ccff8f29a67ff553592
--- /dev/null
+++ b/test/sequential/test-debugger-run-after-quit-restart.js
@@ -0,0 +1,90 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const path = require('path');
+
+// Run after quit/restart.
+{
+  const scriptFullPath = fixtures.path('debugger', 'three-lines.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.stepCommand('n'))
+    .then(() => {
+      assert.ok(
+        cli.output.includes(`break in ${script}:2`),
+        'steps to the 2nd line'
+      );
+    })
+    .then(() => cli.command('cont'))
+    .then(() => cli.waitFor(/disconnect/))
+    .then(() => {
+      assert.match(
+        cli.output,
+        /Waiting for the debugger to disconnect/,
+        'the child was done');
+    })
+    .then(() => {
+      // On windows the socket won't close by itself
+      return cli.command('kill');
+    })
+    .then(() => cli.command('cont'))
+    .then(() => cli.waitFor(/start the app/))
+    .then(() => {
+      assert.match(cli.output, /Use `run` to start the app again/);
+    })
+    .then(() => cli.stepCommand('run'))
+    .then(() => cli.waitForInitialBreak())
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      assert.deepStrictEqual(
+        cli.breakInfo,
+        { filename: script, line: 1 },
+      );
+    })
+    .then(() => cli.stepCommand('n'))
+    .then(() => {
+      assert.deepStrictEqual(
+        cli.breakInfo,
+        { filename: script, line: 2 },
+      );
+    })
+    .then(() => cli.stepCommand('restart'))
+    .then(() => cli.waitForInitialBreak())
+    .then(() => {
+      assert.deepStrictEqual(
+        cli.breakInfo,
+        { filename: script, line: 1 },
+      );
+    })
+    .then(() => cli.command('kill'))
+    .then(() => cli.command('cont'))
+    .then(() => cli.waitFor(/start the app/))
+    .then(() => {
+      assert.match(cli.output, /Use `run` to start the app again/);
+    })
+    .then(() => cli.stepCommand('run'))
+    .then(() => cli.waitForInitialBreak())
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      assert.deepStrictEqual(
+        cli.breakInfo,
+        { filename: script, line: 1 },
+      );
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+}
diff --git a/test/sequential/test-debugger-sb-before-load.js b/test/sequential/test-debugger-sb-before-load.js
new file mode 100644
index 0000000000000000000000000000000000000000..586687800e8e90aadba9e8fce0bb19b4d0391ab0
--- /dev/null
+++ b/test/sequential/test-debugger-sb-before-load.js
@@ -0,0 +1,44 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const path = require('path');
+
+// Using sb before loading file.
+{
+  const scriptFullPath = fixtures.path('debugger', 'cjs', 'index.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
+
+  const otherScriptFullPath = fixtures.path('debugger', 'cjs', 'other.js');
+  const otherScript = path.relative(process.cwd(), otherScriptFullPath);
+
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('sb("other.js", 2)'))
+    .then(() => {
+      assert.match(
+        cli.output,
+        /not loaded yet/,
+        'warns that the script was not loaded yet');
+    })
+    .then(() => cli.stepCommand('cont'))
+    .then(() => {
+      assert.ok(
+        cli.output.includes(`break in ${otherScript}:2`),
+        'found breakpoint in file that was not loaded yet');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+}
diff --git a/deps/node-inspect/test/cli/scripts.test.js b/test/sequential/test-debugger-scripts.js
similarity index 52%
rename from deps/node-inspect/test/cli/scripts.test.js
rename to test/sequential/test-debugger-scripts.js
index f6e3f30dcafce0a7c19d21dba2f745d803d9fada..8a4491814427c0524af15285f7e4cf438e63f2e0 100644
--- a/deps/node-inspect/test/cli/scripts.test.js
+++ b/test/sequential/test-debugger-scripts.js
@@ -1,12 +1,16 @@
 'use strict';
-const Path = require('path');
+const common = require('../common');
 
-const { test } = require('tap');
+common.skipIfInspectorDisabled();
 
-const startCLI = require('./start-cli');
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-test('list scripts', (t) => {
-  const script = Path.join('examples', 'three-lines.js');
+const assert = require('assert');
+
+// List scripts.
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
   const cli = startCLI([script]);
 
   function onFatal(error) {
@@ -18,26 +22,26 @@ test('list scripts', (t) => {
     .then(() => cli.waitForPrompt())
     .then(() => cli.command('scripts'))
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
-        /^\* \d+: examples(?:\/|\\)three-lines\.js/,
+        /^\* \d+: \S+debugger(?:\/|\\)three-lines\.js/m,
         'lists the user script');
-      t.notMatch(
+      assert.doesNotMatch(
         cli.output,
-        /\d+: buffer\.js <native>/,
+        /\d+: node:internal\/buffer/,
         'omits node-internal scripts');
     })
     .then(() => cli.command('scripts(true)'))
     .then(() => {
-      t.match(
+      assert.match(
         cli.output,
-        /\* \d+: examples(?:\/|\\)three-lines\.js/,
+        /\* \d+: \S+debugger(?:\/|\\)three-lines\.js/,
         'lists the user script');
-      t.match(
+      assert.match(
         cli.output,
-        /\d+: buffer\.js <native>/,
+        /\d+: internal\/buffer/,
         'includes node-internal scripts');
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/deps/node-inspect/test/cli/use-strict.test.js b/test/sequential/test-debugger-use-strict.js
similarity index 54%
rename from deps/node-inspect/test/cli/use-strict.test.js
rename to test/sequential/test-debugger-use-strict.js
index c6dc8f31cd82b549bb3f6229dcc871f2e3be04b9..ae82a9fc82352b419468ca035539ff50eb31ae41 100644
--- a/deps/node-inspect/test/cli/use-strict.test.js
+++ b/test/sequential/test-debugger-use-strict.js
@@ -1,12 +1,16 @@
 'use strict';
-const Path = require('path');
+const common = require('../common');
 
-const { test } = require('tap');
+common.skipIfInspectorDisabled();
 
-const startCLI = require('./start-cli');
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
 
-test('for whiles that starts with strict directive', (t) => {
-  const script = Path.join('examples', 'use-strict.js');
+const assert = require('assert');
+
+// Test for files that start with strict directive.
+{
+  const script = fixtures.path('debugger', 'use-strict.js');
   const cli = startCLI([script]);
 
   function onFatal(error) {
@@ -18,11 +22,11 @@ test('for whiles that starts with strict directive', (t) => {
     .then(() => cli.waitForPrompt())
     .then(() => {
       const brk = cli.breakInfo;
-      t.match(
+      assert.match(
         `${brk.line}`,
         /^(1|2)$/,
         'pauses either on strict directive or first "real" line');
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/deps/node-inspect/test/cli/watchers.test.js b/test/sequential/test-debugger-watchers.js
similarity index 56%
rename from deps/node-inspect/test/cli/watchers.test.js
rename to test/sequential/test-debugger-watchers.js
index 46bcde19a2a4cfaee1599aabe9087deb6181af85..e856132b74e28a9395179a1594b6bef715a41243 100644
--- a/deps/node-inspect/test/cli/watchers.test.js
+++ b/test/sequential/test-debugger-watchers.js
@@ -1,10 +1,16 @@
 'use strict';
-const { test } = require('tap');
+const common = require('../common');
 
-const startCLI = require('./start-cli');
+common.skipIfInspectorDisabled();
 
-test('stepping through breakpoints', (t) => {
-  const cli = startCLI(['examples/break.js']);
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Stepping through breakpoints.
+{
+  const cli = startCLI([fixtures.path('debugger/break.js')]);
 
   function onFatal(error) {
     cli.quit();
@@ -22,21 +28,21 @@ test('stepping through breakpoints', (t) => {
     .then(() => cli.command('watch("process.env")'))
     .then(() => cli.command('watchers'))
     .then(() => {
-      t.match(cli.output, 'x is not defined');
+      assert.match(cli.output, /x is not defined/);
     })
     .then(() => cli.command('unwatch("42")'))
     .then(() => cli.stepCommand('n'))
     .then(() => {
-      t.match(cli.output, '0: x = 10');
-      t.match(cli.output, '1: "Hello" = \'Hello\'');
-      t.match(cli.output, '2: NaN = NaN');
-      t.match(cli.output, '3: true = true');
-      t.match(cli.output, '4: [1, 2] = [ 1, 2 ]');
-      t.match(
+      assert.match(cli.output, /0: x = 10/);
+      assert.match(cli.output, /1: "Hello" = 'Hello'/);
+      assert.match(cli.output, /2: NaN = NaN/);
+      assert.match(cli.output, /3: true = true/);
+      assert.match(cli.output, /4: \[1, 2\] = \[ 1, 2 \]/);
+      assert.match(
         cli.output,
         /5: process\.env =\n\s+\{[\s\S]+,\n\s+\.\.\. \}/,
         'shows "..." for process.env');
     })
     .then(() => cli.quit())
     .then(null, onFatal);
-});
+}
diff --git a/test/sequential/test-dgram-implicit-bind-failure.js b/test/sequential/test-dgram-implicit-bind-failure.js
index d77db12618f3bcca08203c97350e85a9e749bc20..89da00d5766fb33eab8d717d64466c45a9e75907 100644
--- a/test/sequential/test-dgram-implicit-bind-failure.js
+++ b/test/sequential/test-dgram-implicit-bind-failure.js
@@ -2,48 +2,31 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
+const EventEmitter = require('events');
 const dgram = require('dgram');
 const dns = require('dns');
 const { kStateSymbol } = require('internal/dgram');
+const mockError = new Error('fake DNS');
 
 // Monkey patch dns.lookup() so that it always fails.
 dns.lookup = function(address, family, callback) {
-  process.nextTick(() => { callback(new Error('fake DNS')); });
+  process.nextTick(() => { callback(mockError); });
 };
 
 const socket = dgram.createSocket('udp4');
-let dnsFailures = 0;
-let sendFailures = 0;
 
-process.on('exit', () => {
-  assert.strictEqual(dnsFailures, 3);
-  assert.strictEqual(sendFailures, 3);
-});
-
-socket.on('error', (err) => {
-  if (/^Error: fake DNS$/.test(err)) {
-    // The DNS lookup should fail since it is monkey patched. At that point in
-    // time, the send queue should be populated with the send() operation. There
-    // should also be two listeners - this function and the dgram internal one
-    // time error handler.
-    dnsFailures++;
-    assert(Array.isArray(socket[kStateSymbol].queue));
-    assert.strictEqual(socket[kStateSymbol].queue.length, 1);
-    assert.strictEqual(socket.listenerCount('error'), 2);
-    return;
-  }
-
-  if (err.code === 'ERR_SOCKET_CANNOT_SEND') {
-    // On error, the queue should be destroyed and this function should be
-    // the only listener.
-    sendFailures++;
-    assert.strictEqual(socket[kStateSymbol].queue, undefined);
-    assert.strictEqual(socket.listenerCount('error'), 1);
-    return;
-  }
-
-  assert.fail(`Unexpected error: ${err}`);
-});
+socket.on(EventEmitter.errorMonitor, common.mustCall((err) => {
+  // The DNS lookup should fail since it is monkey patched. At that point in
+  // time, the send queue should be populated with the send() operation.
+  assert.strictEqual(err, mockError);
+  assert(Array.isArray(socket[kStateSymbol].queue));
+  assert.strictEqual(socket[kStateSymbol].queue.length, 1);
+}, 3));
+
+socket.on('error', common.mustCall((err) => {
+  assert.strictEqual(err, mockError);
+  assert.strictEqual(socket[kStateSymbol].queue, undefined);
+}, 3));
 
 // Initiate a few send() operations, which will fail.
 socket.send('foobar', common.PORT, 'localhost');
diff --git a/test/sequential/test-fs-watch.js b/test/sequential/test-fs-watch.js
index 031e92c61c0b3c27e1b3808fe74292781d0a63ed..c5db585f3f4a59f5aed7c15937ce0aabd6e05966 100644
--- a/test/sequential/test-fs-watch.js
+++ b/test/sequential/test-fs-watch.js
@@ -42,6 +42,15 @@ const testDir = tmpdir.path;
 
 tmpdir.refresh();
 
+// Because macOS (and possibly other operating systems) can return a watcher
+// before it is actually watching, we need to repeat the operation to avoid
+// a race condition.
+function repeat(fn) {
+  setImmediate(fn);
+  const interval = setInterval(fn, 5000);
+  return interval;
+}
+
 {
   const filepath = path.join(testDir, 'watch.txt');
 
@@ -54,12 +63,11 @@ tmpdir.refresh();
     if (expectFilePath) {
       assert.strictEqual(filename, 'watch.txt');
     }
+    clearInterval(interval);
     watcher.close();
   }));
 
-  setImmediate(function() {
-    fs.writeFileSync(filepath, 'world');
-  });
+  const interval = repeat(() => { fs.writeFileSync(filepath, 'world'); });
 }
 
 {
@@ -76,12 +84,11 @@ tmpdir.refresh();
       if (expectFilePath) {
         assert.strictEqual(filename, 'hasOwnProperty');
       }
+      clearInterval(interval);
       watcher.close();
     }));
 
-  setImmediate(function() {
-    fs.writeFileSync(filepathAbs, 'pardner');
-  });
+  const interval = repeat(() => { fs.writeFileSync(filepathAbs, 'pardner'); });
 }
 
 {
@@ -97,14 +104,15 @@ tmpdir.refresh();
       } else {
         assert.strictEqual(filename, null);
       }
+      clearInterval(interval);
       watcher.close();
     }));
 
-  setImmediate(function() {
+  const interval = repeat(() => {
+    fs.rmSync(filepath, { force: true });
     const fd = fs.openSync(filepath, 'w');
     fs.closeSync(fd);
   });
-
 }
 
 // https://github.com/joyent/node/issues/2293 - non-persistent watcher should
@@ -117,14 +125,40 @@ tmpdir.refresh();
 // https://github.com/joyent/node/issues/6690
 {
   let oldhandle;
-  common.expectsInternalAssertion(
+  assert.throws(
     () => {
       const w = fs.watch(__filename, common.mustNotCall());
       oldhandle = w._handle;
       w._handle = { close: w._handle.close };
       w.close();
     },
-    'handle must be a FSEvent'
+    {
+      name: 'Error',
+      code: 'ERR_INTERNAL_ASSERTION',
+      message: /^handle must be a FSEvent/,
+    }
+  );
+  oldhandle.close(); // clean up
+}
+
+{
+  let oldhandle;
+  assert.throws(
+    () => {
+      const w = fs.watch(__filename, common.mustNotCall());
+      oldhandle = w._handle;
+      const protoSymbols =
+        Object.getOwnPropertySymbols(Object.getPrototypeOf(w));
+      const kFSWatchStart =
+        protoSymbols.find((val) => val.toString() === 'Symbol(kFSWatchStart)');
+      w._handle = {};
+      w[kFSWatchStart]();
+    },
+    {
+      name: 'Error',
+      code: 'ERR_INTERNAL_ASSERTION',
+      message: /^handle must be a FSEvent/,
+    }
   );
   oldhandle.close(); // clean up
 }
diff --git a/test/sequential/test-http2-timeout-large-write-file.js b/test/sequential/test-http2-timeout-large-write-file.js
index bb366cfff04091835e87c1956d9939f074b0d4e6..520958bd57f6d412bfb4932fc1b39a0640c6b8be 100644
--- a/test/sequential/test-http2-timeout-large-write-file.js
+++ b/test/sequential/test-http2-timeout-large-write-file.js
@@ -33,6 +33,7 @@ const content = Buffer.alloc(writeSize, 0x44);
 const filepath = path.join(tmpdir.path, 'http2-large-write.tmp');
 fs.writeFileSync(filepath, content, 'binary');
 const fd = fs.openSync(filepath, 'r');
+process.on('beforeExit', () => fs.closeSync(fd));
 
 const server = http2.createSecureServer({
   key: fixtures.readKey('agent1-key.pem'),
diff --git a/test/sequential/test-init.js b/test/sequential/test-init.js
index a86a1fd045f48c0c4760ac69c0abc8dc490dd4ad..b64fb23daeabc7e937f6c11edc1285a6e16f4a07 100644
--- a/test/sequential/test-init.js
+++ b/test/sequential/test-init.js
@@ -36,8 +36,7 @@ process.env.TEST_INIT = 1;
 
 function test(file, expected) {
   const path = `"${process.execPath}" ${file}`;
-  child.exec(path, { env: process.env }, common.mustCall((err, out) => {
-    assert.ifError(err);
+  child.exec(path, { env: process.env }, common.mustSucceed((out) => {
     assert.strictEqual(out, expected, `'node ${file}' failed!`);
   }));
 }
diff --git a/test/sequential/test-inspector-async-call-stack-abort.js b/test/sequential/test-inspector-async-call-stack-abort.js
index ce2b43cdf02e826ed47361784ca010d586c8ad6c..a3d0944ce5ecbba00acd36437d46dfd378e546c3 100644
--- a/test/sequential/test-inspector-async-call-stack-abort.js
+++ b/test/sequential/test-inspector-async-call-stack-abort.js
@@ -25,7 +25,7 @@ if (process.argv[2] === 'child') {
     await session.post('Debugger.setAsyncCallStackDepth', { maxDepth: 42 });
     strictEqual(enabled, 1);
     throw new Error(eyecatcher);
-  })();
+  })().finally(common.mustCall());
 } else {
   const { spawnSync } = require('child_process');
   const options = { encoding: 'utf8' };
diff --git a/test/sequential/test-inspector-async-hook-setup-at-inspect-brk.js b/test/sequential/test-inspector-async-hook-setup-at-inspect-brk.js
index f4f45a1aa8f4cea977b17339c1220d72e3141013..2a9a2030552e6e7c3ea7aee45036e3da9298ba65 100644
--- a/test/sequential/test-inspector-async-hook-setup-at-inspect-brk.js
+++ b/test/sequential/test-inspector-async-hook-setup-at-inspect-brk.js
@@ -24,7 +24,7 @@ async function checkAsyncStackTrace(session) {
          `${Object.keys(paused.params)} contains "asyncStackTrace" property`);
   assert(paused.params.asyncStackTrace.description, 'Timeout');
   assert(paused.params.asyncStackTrace.callFrames
-           .some((frame) => frame.functionName === 'Module._compile'));
+           .some((frame) => frame.url === 'internal/process/execution.js'));
 }
 
 async function runTests() {
@@ -37,7 +37,7 @@ async function runTests() {
       'params': { 'maxDepth': 10 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ]);
   await skipBreakpointAtStart(session);
   await checkAsyncStackTrace(session);
diff --git a/test/sequential/test-inspector-async-hook-setup-at-signal.js b/test/sequential/test-inspector-async-hook-setup-at-signal.js
index 259a40db976e466899507e7f271263d267122724..1de7a3ed20acf6aa73a1b5dd895d99a9a2478358 100644
--- a/test/sequential/test-inspector-async-hook-setup-at-signal.js
+++ b/test/sequential/test-inspector-async-hook-setup-at-signal.js
@@ -45,7 +45,7 @@ async function setupTimeoutForStackTrace(session) {
   await session.send([
     { 'method': 'Runtime.evaluate',
       'params': { expression: 'setupTimeoutWithBreak()' } },
-    { 'method': 'Debugger.resume' }
+    { 'method': 'Debugger.resume' },
   ]);
 }
 
@@ -69,7 +69,7 @@ async function runTests() {
       'params': { 'maxDepth': 10 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ]);
 
   await waitForInitialSetup(session);
diff --git a/test/sequential/test-inspector-async-stack-traces-promise-then.js b/test/sequential/test-inspector-async-stack-traces-promise-then.js
index 40b05c9aacf375615770aace9aff0d4063d48f71..f50d8994a24c95fdf102992e89a69f66f9db8c34 100644
--- a/test/sequential/test-inspector-async-stack-traces-promise-then.js
+++ b/test/sequential/test-inspector-async-stack-traces-promise-then.js
@@ -27,7 +27,7 @@ async function runTests() {
       'params': { 'maxDepth': 10 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ]);
 
   await session.waitForBreakOnLine(0, '[eval]');
diff --git a/test/sequential/test-inspector-async-stack-traces-set-interval.js b/test/sequential/test-inspector-async-stack-traces-set-interval.js
index 97b2917b70092c94afae2bd60633e02feb3dda5e..4369f6f9cc99a20c70bc2a5b51265c89aaeec1f0 100644
--- a/test/sequential/test-inspector-async-stack-traces-set-interval.js
+++ b/test/sequential/test-inspector-async-stack-traces-set-interval.js
@@ -20,7 +20,7 @@ async function checkAsyncStackTrace(session) {
          `${Object.keys(paused.params)} contains "asyncStackTrace" property`);
   assert(paused.params.asyncStackTrace.description, 'Timeout');
   assert(paused.params.asyncStackTrace.callFrames
-           .some((frame) => frame.functionName === 'Module._compile'));
+           .some((frame) => frame.url === 'internal/process/execution.js'));
 }
 
 async function runTests() {
@@ -33,7 +33,7 @@ async function runTests() {
       'params': { 'maxDepth': 10 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ]);
 
   await skipFirstBreakpoint(session);
diff --git a/test/sequential/test-inspector-break-e.js b/test/sequential/test-inspector-break-e.js
index f2a52fcae835fd6ff7c02716dcb032c0c8d335d6..274422cf59b19045fcc52a811806d91cade6c880 100644
--- a/test/sequential/test-inspector-break-e.js
+++ b/test/sequential/test-inspector-break-e.js
@@ -11,7 +11,7 @@ async function runTests() {
   await session.send([
     { 'method': 'Runtime.enable' },
     { 'method': 'Debugger.enable' },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ]);
   await session.waitForBreakOnLine(0, '[eval]');
   await session.runToCompletion();
diff --git a/test/sequential/test-inspector-break-when-eval.js b/test/sequential/test-inspector-break-when-eval.js
index 7a834e9934b1abde6d0b2f4cfa8f6b3b90f4d8a7..1e7ab513dadbbb69c9ee22770fd1e8d44ef015d4 100644
--- a/test/sequential/test-inspector-break-when-eval.js
+++ b/test/sequential/test-inspector-break-when-eval.js
@@ -36,9 +36,7 @@ async function breakOnLine(session) {
       'params': { 'lineNumber': 9,
                   'url': pathToFileURL(script).toString(),
                   'columnNumber': 0,
-                  'condition': ''
-      }
-    },
+                  'condition': '' } },
     { 'method': 'Runtime.evaluate',
       'params': { 'expression': 'sum()',
                   'objectGroup': 'console',
@@ -48,9 +46,7 @@ async function breakOnLine(session) {
                   'returnByValue': false,
                   'generatePreview': true,
                   'userGesture': true,
-                  'awaitPromise': false
-      }
-    }
+                  'awaitPromise': false } },
   ];
   session.send(commands);
   await session.waitForBreakOnLine(9, pathToFileURL(script).toString());
diff --git a/test/sequential/test-inspector-console.js b/test/sequential/test-inspector-console.js
index bb0f0ce42a3d03bafc8b86a384e776edc22d9e03..33cd913efb2cec1334f1ca8280a4dd205315df6b 100644
--- a/test/sequential/test-inspector-console.js
+++ b/test/sequential/test-inspector-console.js
@@ -17,7 +17,7 @@ async function runTest() {
 
   const commands = [
     { 'method': 'Runtime.enable' },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ];
 
   session.send(commands);
diff --git a/test/sequential/test-inspector-debug-brk-flag.js b/test/sequential/test-inspector-debug-brk-flag.js
index f1312b47ad8d8b483342c5165a7fe078a80324be..db235326e96ff9895f1c3d838e2443f75cb6e055 100644
--- a/test/sequential/test-inspector-debug-brk-flag.js
+++ b/test/sequential/test-inspector-debug-brk-flag.js
@@ -19,7 +19,7 @@ async function testBreakpointOnStart(session) {
       'params': { 'interval': 100 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ];
 
   session.send(commands);
diff --git a/test/sequential/test-inspector-exception.js b/test/sequential/test-inspector-exception.js
index f1cd2eca3f30f30565e90512a7d7fbe08aea76b2..fc41de97e97841ccf033a1080e4917ca5ab05823 100644
--- a/test/sequential/test-inspector-exception.js
+++ b/test/sequential/test-inspector-exception.js
@@ -25,7 +25,7 @@ async function testBreakpointOnStart(session) {
       'params': { 'interval': 100 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ];
 
   await session.send(commands);
diff --git a/test/sequential/test-inspector-not-blocked-on-idle.js b/test/sequential/test-inspector-not-blocked-on-idle.js
index fbf26d15c91f1245a8c4510387e06cab2c55dab2..0a38540c3e8a0d0854e280e716f4747e9c5c395c 100644
--- a/test/sequential/test-inspector-not-blocked-on-idle.js
+++ b/test/sequential/test-inspector-not-blocked-on-idle.js
@@ -11,7 +11,7 @@ async function runTests() {
   const session = await node.connectInspectorSession();
   await session.send([
     { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.pause' }
+    { 'method': 'Debugger.pause' },
   ]);
   session.disconnect();
   node.kill();
diff --git a/test/sequential/test-inspector-port-cluster.js b/test/sequential/test-inspector-port-cluster.js
index a6c961084352d4824d200385eb1387f673a06623..bb63b1fa437fc11fe85d897f81ecaa155aae3bd7 100644
--- a/test/sequential/test-inspector-port-cluster.js
+++ b/test/sequential/test-inspector-port-cluster.js
@@ -14,10 +14,8 @@ const childProcess = require('child_process');
 
 let offset = 0;
 
-/*
- * This test suite checks that inspector port in cluster is incremented
- * for different execArgv combinations
- */
+// This test suite checks that inspector port in cluster is incremented
+// for different execArgv combinations
 
 function testRunnerMain() {
   let defaultPortCase = spawnMaster({
@@ -31,7 +29,7 @@ function testRunnerMain() {
       { expectedPort: 65535 },
       { expectedPort: 1024 },
       { expectedPort: 1025 },
-      { expectedPort: 1026 }
+      { expectedPort: 1026 },
     ]
   });
 
@@ -42,7 +40,7 @@ function testRunnerMain() {
     workers: [
       { expectedPort: port + 1 },
       { expectedPort: port + 2 },
-      { expectedPort: port + 3 }
+      { expectedPort: port + 3 },
     ]
   });
 
@@ -108,7 +106,7 @@ function testRunnerMain() {
     clusterSettings: { inspectPort: 'addTwo' },
     workers: [
       { expectedPort: port + 2 },
-      { expectedPort: port + 4 }
+      { expectedPort: port + 4 },
     ]
   });
 
@@ -166,7 +164,7 @@ function testRunnerMain() {
     execArgv: [],
     clusterSettings: { inspectPort: port, execArgv: ['--inspect'] },
     workers: [
-      { expectedPort: port }
+      { expectedPort: port },
     ]
   });
 
@@ -178,7 +176,7 @@ function testRunnerMain() {
     workers: [
       { expectedInitialPort: 0 },
       { expectedInitialPort: 0 },
-      { expectedInitialPort: 0 }
+      { expectedInitialPort: 0 },
     ]
   });
 
@@ -190,7 +188,7 @@ function testRunnerMain() {
     workers: [
       { expectedInitialPort: 0 },
       { expectedInitialPort: 0 },
-      { expectedInitialPort: 0 }
+      { expectedInitialPort: 0 },
     ]
   });
 
@@ -200,7 +198,7 @@ function testRunnerMain() {
       execArgv: ['--inspect'],
       clusterSettings: { inspectPort: port + 2 },
       workers: [
-        { expectedInitialPort: port + 2 }
+        { expectedInitialPort: port + 2 },
       ]
     });
   });
@@ -332,8 +330,7 @@ function spawnMaster({ execArgv, workers, clusterSettings = {} }) {
       env: { ...process.env,
              workers: JSON.stringify(workers),
              clusterSettings: JSON.stringify(clusterSettings),
-             testProcess: true
-      },
+             testProcess: true },
       execArgv: execArgv.concat(['--expose-internals'])
     }).on('exit', common.mustCall((code, signal) => {
       checkExitCode(code, signal);
diff --git a/test/sequential/test-inspector-port-zero.js b/test/sequential/test-inspector-port-zero.js
index 59027b5e30769d8ee44f7f8331804dcf915270fe..1683394a1dd4a3c30cfaa19791eba937b242aef7 100644
--- a/test/sequential/test-inspector-port-zero.js
+++ b/test/sequential/test-inspector-port-zero.js
@@ -4,7 +4,6 @@ const { mustCall, skipIfInspectorDisabled } = require('../common');
 skipIfInspectorDisabled();
 
 const assert = require('assert');
-const { URL } = require('url');
 const { spawn } = require('child_process');
 
 function test(arg, port = '') {
diff --git a/test/sequential/test-inspector-scriptparsed-context.js b/test/sequential/test-inspector-scriptparsed-context.js
index e656436879ce63b988f63d3556ab7da4fc7deb3f..3c5c07a53a78c0f33519bc1abdef606fcab751a1 100644
--- a/test/sequential/test-inspector-scriptparsed-context.js
+++ b/test/sequential/test-inspector-scriptparsed-context.js
@@ -48,7 +48,7 @@ async function runTests() {
   const session = await instance.connectInspectorSession();
   await session.send([
     { 'method': 'Debugger.enable' },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ]);
   await session.waitForBreakOnLine(2, '[eval]');
 
diff --git a/test/sequential/test-inspector.js b/test/sequential/test-inspector.js
index b58d70c864263ae4b19ff077756b10d76c856ac3..84e0bb1c5e0c440f4144bc9046d0bc7c8ca3f4d3 100644
--- a/test/sequential/test-inspector.js
+++ b/test/sequential/test-inspector.js
@@ -72,7 +72,7 @@ async function testBreakpointOnStart(session) {
       'params': { 'interval': 100 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
   ];
 
   await session.send(commands);
@@ -86,15 +86,14 @@ async function testBreakpoint(session) {
       'params': { 'lineNumber': 5,
                   'url': session.scriptURL(),
                   'columnNumber': 0,
-                  'condition': ''
-      }
-    },
+                  'condition': '' } },
     { 'method': 'Debugger.resume' },
   ];
   await session.send(commands);
   const { scriptSource } = await session.send({
     'method': 'Debugger.getScriptSource',
-    'params': { 'scriptId': session.mainScriptId } });
+    'params': { 'scriptId': session.mainScriptId },
+  });
   assert(scriptSource && (scriptSource.includes(session.script())),
          `Script source is wrong: ${scriptSource}`);
 
@@ -188,7 +187,7 @@ async function testCommandLineAPI(session) {
         'expression': [
           'typeof require.resolve === "function"',
           'typeof require.extensions === "object"',
-          'typeof require.cache === "object"'
+          'typeof require.cache === "object"',
         ].join(' && '),
         'includeCommandLineAPI': true
       }
diff --git a/test/sequential/test-net-bytes-per-incoming-chunk-overhead.js b/test/sequential/test-net-bytes-per-incoming-chunk-overhead.js
index 6eec8cc3c6d6c8d28f5acf8a5247a6dd726f9f3a..7bcdfaa9f6f6aab8d3c19efe1b37d9e41abcb20e 100644
--- a/test/sequential/test-net-bytes-per-incoming-chunk-overhead.js
+++ b/test/sequential/test-net-bytes-per-incoming-chunk-overhead.js
@@ -17,7 +17,7 @@ const receivedChunks = [];
 const N = 250000;
 
 const server = net.createServer(common.mustCall((socket) => {
-  baseRSS = process.memoryUsage().rss;
+  baseRSS = process.memoryUsage.rss();
 
   socket.setNoDelay(true);
   socket.on('data', (chunk) => {
@@ -38,7 +38,7 @@ const server = net.createServer(common.mustCall((socket) => {
 process.on('exit', () => {
   global.gc();
   const bytesPerChunk =
-    (process.memoryUsage().rss - baseRSS) / receivedChunks.length;
+    (process.memoryUsage.rss() - baseRSS) / receivedChunks.length;
   // We should always have less than one page (usually ~ 4 kB) per chunk.
-  assert(bytesPerChunk < 600, `measured ${bytesPerChunk} bytes per chunk`);
+  assert(bytesPerChunk < 650, `measured ${bytesPerChunk} bytes per chunk`);
 });
diff --git a/test/pummel/test-net-connect-econnrefused.js b/test/sequential/test-net-connect-econnrefused.js
similarity index 100%
rename from test/pummel/test-net-connect-econnrefused.js
rename to test/sequential/test-net-connect-econnrefused.js
diff --git a/test/sequential/test-performance-eventloopdelay.js b/test/sequential/test-performance-eventloopdelay.js
index 47c54a2543fd54fb32077af40bc6e4771f0742bd..765691f3fcb14f5744eb24800bf5dfaa9ba54ceb 100644
--- a/test/sequential/test-performance-eventloopdelay.js
+++ b/test/sequential/test-performance-eventloopdelay.js
@@ -86,7 +86,7 @@ const { sleep } = require('internal/util');
           }
         );
       });
-      [-1, 0, 101].forEach((i) => {
+      [-1, 0, 101, NaN].forEach((i) => {
         assert.throws(
           () => histogram.percentile(i),
           {
diff --git a/test/sequential/test-pipe.js b/test/sequential/test-pipe.js
index c5bff3563be1e6a138ef9424c5ef9960227e3814..c3e0ddef9fe57d92d0f47d6814737ed8dcdb4897 100644
--- a/test/sequential/test-pipe.js
+++ b/test/sequential/test-pipe.js
@@ -34,9 +34,7 @@ let gotThanks = false;
 let tcpLengthSeen = 0;
 
 
-/*
- * 5MB of random buffer.
- */
+// 5MB of random buffer.
 const buffer = Buffer.allocUnsafe(bufferSize);
 for (let i = 0; i < buffer.length; i++) {
   buffer[i] = parseInt(Math.random() * 10000) % 256;
diff --git a/test/sequential/test-stream2-stderr-sync.js b/test/sequential/test-stream2-stderr-sync.js
index 7384cf6e74f502d10ca3911a4daa650fc22a6663..db0ed180edc51b9e7703fe858baa0a4c0c8bcc7d 100644
--- a/test/sequential/test-stream2-stderr-sync.js
+++ b/test/sequential/test-stream2-stderr-sync.js
@@ -67,7 +67,8 @@ function child2() {
   const socket = new net.Socket({
     fd: 2,
     readable: false,
-    writable: true });
+    writable: true,
+  });
   socket.write('child 2\n');
   socket.write('foo\n');
   socket.write('bar\n');
diff --git a/test/sequential/test-util-debug.js b/test/sequential/test-util-debug.js
index 8bf5ae5e5abbb0dcbe5bdb5688e6f59be3d6c343..f8be25f6f880b85ce14ed41e1c5bd52821b77acf 100644
--- a/test/sequential/test-util-debug.js
+++ b/test/sequential/test-util-debug.js
@@ -57,7 +57,7 @@ function parent() {
 
 function test(environ, shouldWrite, section, forceColors = false) {
   let expectErr = '';
-  const expectOut = 'ok\n';
+  const expectOut = shouldWrite ? 'enabled\n' : 'disabled\n';
 
   const spawn = require('child_process').spawn;
   const child = spawn(process.execPath, [__filename, 'child', section], {
@@ -123,5 +123,5 @@ function child(section) {
   }));
   debug('this', { is: 'a' }, /debugging/);
   debug('num=%d str=%s obj=%j', 1, 'a', { foo: 'bar' });
-  console.log('ok');
+  console.log(debug.enabled ? 'enabled' : 'disabled');
 }
diff --git a/test/sequential/test-vm-timeout-escape-promise-module-2.js b/test/sequential/test-vm-timeout-escape-promise-module-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a9d09890ddef0f08bb46a5f245d1ea425345d3d
--- /dev/null
+++ b/test/sequential/test-vm-timeout-escape-promise-module-2.js
@@ -0,0 +1,42 @@
+// Flags: --experimental-vm-modules
+'use strict';
+
+// https://github.com/nodejs/node/issues/3020
+// Promises used to allow code to escape the timeout
+// set for runInContext, runInNewContext, and runInThisContext.
+
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const NS_PER_MS = 1000000n;
+
+const hrtime = process.hrtime.bigint;
+
+function loop() {
+  const start = hrtime();
+  while (1) {
+    const current = hrtime();
+    const span = (current - start) / NS_PER_MS;
+    if (span >= 100n) {
+      throw new Error(
+        `escaped timeout at ${span} milliseconds!`);
+    }
+  }
+}
+
+assert.rejects(async () => {
+  const module = new vm.SourceTextModule(
+    'Promise.resolve().then(() => loop());',
+    {
+      context: vm.createContext({
+        hrtime,
+        loop
+      }, { microtaskMode: 'afterEvaluate' })
+    });
+  await module.link(common.mustNotCall());
+  await module.evaluate({ timeout: 10 });
+}, {
+  code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
+  message: 'Script execution timed out after 10ms'
+});
diff --git a/test/parallel/test-worker-eventlooputil.js b/test/sequential/test-worker-eventlooputil.js
similarity index 100%
rename from test/parallel/test-worker-eventlooputil.js
rename to test/sequential/test-worker-eventlooputil.js
diff --git a/test/tick-processor/test-tick-processor-polyfill-brokenfile.js b/test/tick-processor/test-tick-processor-polyfill-brokenfile.js
index f61bdbe9a12510dec324249fd5cf006b94d4c783..98cbf5bb414789e97a5a6279d56812e931f63c28 100644
--- a/test/tick-processor/test-tick-processor-polyfill-brokenfile.js
+++ b/test/tick-processor/test-tick-processor-polyfill-brokenfile.js
@@ -37,7 +37,7 @@ const proc = spawn(process.execPath, [
   '--no_logfile_per_isolate',
   '--logfile=-',
   '--prof',
-  '-pe', code
+  '-pe', code,
 ], {
   stdio: ['ignore', 'pipe', 'inherit']
 });
@@ -53,7 +53,7 @@ function runPolyfill(content) {
   const child = spawnSync(
     `${process.execPath}`,
     [
-      '--prof-process', LOG_FILE
+      '--prof-process', LOG_FILE,
     ]);
   assert(WARN_REG_EXP.test(child.stderr.toString()));
   assert(WARN_DETAIL_REG_EXP.test(child.stderr.toString()));
diff --git a/test/tick-processor/tick-processor-base.js b/test/tick-processor/tick-processor-base.js
index 33944655258bef872663a288e1f9d73cb853331d..d9f23ae7d768f55141f1fe44e81b48f6ea23c3fe 100644
--- a/test/tick-processor/tick-processor-base.js
+++ b/test/tick-processor/tick-processor-base.js
@@ -15,7 +15,7 @@ function runTest(test) {
     '--no_logfile_per_isolate',
     '--logfile=-',
     '--prof',
-    '-pe', test.code
+    '-pe', test.code,
   ], {
     stdio: [ 'ignore', 'pipe', 'inherit' ]
   });
@@ -37,7 +37,7 @@ function match(pattern, parent, ticks, flags = []) {
     '--prof-process',
     '--call-graph-size=10',
     ...flags,
-    LOG_FILE
+    LOG_FILE,
   ], {
     stdio: [ 'ignore', 'pipe', 'inherit' ]
   });
diff --git a/test/v8-updates/test-linux-perf.js b/test/v8-updates/test-linux-perf.js
index 01ebce0ae5af9a084c43560e574844a80cb77906..9a8097b071a2b5ce9e1ca8780659dab190c505a2 100644
--- a/test/v8-updates/test-linux-perf.js
+++ b/test/v8-updates/test-linux-perf.js
@@ -68,7 +68,7 @@ const perfCompiledFramesArgs = [
 ];
 
 const perfArgsList = [
-  perfInterpretedFramesArgs, perfCompiledFramesArgs
+  perfInterpretedFramesArgs, perfCompiledFramesArgs,
 ];
 
 const perfScriptArgs = [
diff --git a/test/v8-updates/test-postmortem-metadata.js b/test/v8-updates/test-postmortem-metadata.js
deleted file mode 100644
index b7b830daf458d46ba2397a4f19d14d68e06f9b58..0000000000000000000000000000000000000000
--- a/test/v8-updates/test-postmortem-metadata.js
+++ /dev/null
@@ -1,202 +0,0 @@
-'use strict';
-
-// This test verifies that expected postmortem debugging metadata is present
-// in the Node.js binary. These constants are used by tools such as llnode and
-// mdb_v8, so this test ensures that they don't vanish between V8 updates.
-
-const common = require('../common');
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const { getSharedLibPath } = require('../common/shared-lib-util.js');
-
-// For shared lib case, check shared lib instead
-const args = [
-  process.config.variables.node_shared ?
-    getSharedLibPath() : process.execPath
-];
-
-if (common.isAIX)
-  args.unshift('-Xany', '-B');
-
-if (common.isOpenBSD)
-  common.skip('no v8 debug symbols on OpenBSD');
-
-const nm = spawnSync('nm', args, { maxBuffer: Infinity });
-
-if (nm.error && nm.error.errno === 'ENOENT')
-  common.skip('nm not found on system');
-
-const stderr = nm.stderr.toString();
-if (stderr.length > 0) {
-  common.skip(`Failed to execute nm: ${stderr}`);
-}
-
-const symbolRe = /\s_?(v8dbg_.+)$/;
-const symbols = nm.stdout.toString().split('\n').reduce((filtered, line) => {
-  const match = line.match(symbolRe);
-  const symbol = match && match[1];
-
-  if (symbol)
-    filtered.push(symbol);
-
-  return filtered;
-}, []);
-
-assert.notStrictEqual(symbols.length, 0, 'No postmortem metadata detected');
-
-const missing = getExpectedSymbols().filter((symbol) => {
-  return !symbols.includes(symbol);
-});
-
-assert.strictEqual(missing.length, 0,
-                   `Missing constants: \n${missing.join('\n')}`);
-
-// This is only a function so that the long list of expected symbols can be
-// pushed to the bottom of the file for improved readability.
-function getExpectedSymbols() {
-  return [
-    // Disable the maximum line length for the remainder of the file since it
-    // should only consist of postmortem constants, and some of them can be
-    // relatively long.
-    /* eslint-disable max-len */
-    'v8dbg_class_DescriptorArray__header_size__uintptr_t',
-    'v8dbg_bit_field3_is_dictionary_map_shift',
-    'v8dbg_bit_field3_number_of_own_descriptors_shift',
-    'v8dbg_class_Code__instruction_size__int',
-    'v8dbg_class_Code__instruction_start__uintptr_t',
-    'v8dbg_class_ConsString__first__String',
-    'v8dbg_class_ConsString__second__String',
-    'v8dbg_class_FixedArray__data__uintptr_t',
-    'v8dbg_class_FixedArrayBase__length__SMI',
-    'v8dbg_class_JSTypedArray__base_pointer__Object',
-    'v8dbg_class_JSTypedArray__external_pointer__uintptr_t',
-    'v8dbg_class_HeapNumber__value__double',
-    'v8dbg_class_HeapObject__map__Map',
-    'v8dbg_class_JSArray__length__Object',
-    'v8dbg_class_JSArrayBuffer__backing_store__uintptr_t',
-    'v8dbg_class_JSArrayBuffer__byte_length__size_t',
-    'v8dbg_class_JSArrayBufferView__buffer__Object',
-    'v8dbg_class_JSArrayBufferView__byte_length__size_t',
-    'v8dbg_class_JSArrayBufferView__byte_offset__size_t',
-    'v8dbg_class_JSDate__value__Object',
-    'v8dbg_class_JSFunction__context__Context',
-    'v8dbg_class_JSFunction__shared__SharedFunctionInfo',
-    'v8dbg_class_JSObject__elements__Object',
-    'v8dbg_class_JSObject__internal_fields__uintptr_t',
-    'v8dbg_class_JSReceiver__raw_properties_or_hash__Object',
-    'v8dbg_class_JSRegExp__source__Object',
-    'v8dbg_class_Map__bit_field3__int',
-    'v8dbg_class_Map__constructor_or_backpointer__Object',
-    'v8dbg_class_Map__inobject_properties_start_or_constructor_function_index__char',
-    'v8dbg_class_Map__instance_type__uint16_t',
-    'v8dbg_class_Map__instance_descriptors_offset',
-    'v8dbg_class_Map__instance_size_in_words__char',
-    'v8dbg_class_Oddball__kind_offset__int',
-    'v8dbg_class_Script__line_ends__Object',
-    'v8dbg_class_Script__line_offset__SMI',
-    'v8dbg_class_Script__name__Object',
-    'v8dbg_class_Script__source__Object',
-    'v8dbg_class_SeqOneByteString__chars__char',
-    'v8dbg_class_SeqTwoByteString__chars__char',
-    'v8dbg_class_SharedFunctionInfo__function_data__Object',
-    'v8dbg_class_SharedFunctionInfo__flags__int',
-    'v8dbg_class_UncompiledData__end_position__int32_t',
-    'v8dbg_class_UncompiledData__inferred_name__String',
-    'v8dbg_class_SharedFunctionInfo__internal_formal_parameter_count__uint16_t',
-    'v8dbg_class_SharedFunctionInfo__name_or_scope_info__Object',
-    'v8dbg_class_SharedFunctionInfo__script_or_debug_info__Object',
-    'v8dbg_class_UncompiledData__start_position__int32_t',
-    'v8dbg_class_SlicedString__offset__SMI',
-    'v8dbg_class_SlicedString__parent__String',
-    'v8dbg_class_String__length__int32_t',
-    'v8dbg_class_ThinString__actual__String',
-    'v8dbg_context_idx_scope_info',
-    'v8dbg_context_idx_prev',
-    'v8dbg_context_min_slots',
-    'v8dbg_frametype_ArgumentsAdaptorFrame',
-    'v8dbg_frametype_ConstructEntryFrame',
-    'v8dbg_frametype_ConstructFrame',
-    'v8dbg_frametype_EntryFrame',
-    'v8dbg_frametype_ExitFrame',
-    'v8dbg_frametype_InternalFrame',
-    'v8dbg_frametype_OptimizedFrame',
-    'v8dbg_frametype_StubFrame',
-    'v8dbg_jsarray_buffer_was_detached_mask',
-    'v8dbg_jsarray_buffer_was_detached_shift',
-    'v8dbg_namedictionary_prefix_start_index',
-    'v8dbg_namedictionaryshape_entry_size',
-    'v8dbg_namedictionaryshape_prefix_size',
-    'v8dbg_off_fp_args',
-    'v8dbg_off_fp_context',
-    'v8dbg_off_fp_function',
-    'v8dbg_prop_attributes_mask',
-    'v8dbg_prop_attributes_shift',
-    'v8dbg_prop_attributes_DONT_ENUM',
-    'v8dbg_prop_attributes_DONT_ENUM',
-    'v8dbg_prop_attributes_NONE',
-    'v8dbg_prop_attributes_READ_ONLY',
-    'v8dbg_prop_desc_details',
-    'v8dbg_prop_desc_key',
-    'v8dbg_prop_desc_size',
-    'v8dbg_prop_desc_value',
-    'v8dbg_prop_index_mask',
-    'v8dbg_prop_index_shift',
-    'v8dbg_prop_kind_mask',
-    'v8dbg_prop_kind_Accessor',
-    'v8dbg_prop_kind_Data',
-    'v8dbg_prop_location_mask',
-    'v8dbg_prop_location_shift',
-    'v8dbg_prop_location_Descriptor',
-    'v8dbg_prop_location_Field',
-    'v8dbg_prop_representation_double',
-    'v8dbg_prop_representation_mask',
-    'v8dbg_prop_representation_shift',
-    'v8dbg_scopeinfo_idx_first_vars',
-    'v8dbg_scopeinfo_idx_ncontextlocals',
-    'v8dbg_scopeinfo_idx_nparams',
-    'v8dbg_type_Code__CODE_TYPE',
-    'v8dbg_type_FixedArray__FIXED_ARRAY_TYPE',
-    'v8dbg_type_HeapNumber__HEAP_NUMBER_TYPE',
-    'v8dbg_type_JSArray__JS_ARRAY_TYPE',
-    'v8dbg_type_JSArrayBuffer__JS_ARRAY_BUFFER_TYPE',
-    'v8dbg_type_JSDate__JS_DATE_TYPE',
-    'v8dbg_type_JSFunction__JS_FUNCTION_TYPE',
-    'v8dbg_type_JSGlobalObject__JS_GLOBAL_OBJECT_TYPE',
-    'v8dbg_type_JSGlobalProxy__JS_GLOBAL_PROXY_TYPE',
-    'v8dbg_type_JSObject__JS_OBJECT_TYPE',
-    'v8dbg_type_JSRegExp__JS_REGEXP_TYPE',
-    'v8dbg_type_JSTypedArray__JS_TYPED_ARRAY_TYPE',
-    'v8dbg_type_Map__MAP_TYPE',
-    'v8dbg_type_Oddball__ODDBALL_TYPE',
-    'v8dbg_type_Script__SCRIPT_TYPE',
-    'v8dbg_type_SharedFunctionInfo__SHARED_FUNCTION_INFO_TYPE',
-    'v8dbg_APIObjectType',
-    'v8dbg_ConsStringTag',
-    'v8dbg_ExternalStringTag',
-    'v8dbg_FirstNonstringType',
-    'v8dbg_HeapObjectTag',
-    'v8dbg_HeapObjectTagMask',
-    'v8dbg_OddballException',
-    'v8dbg_OddballFalse',
-    'v8dbg_OddballNull',
-    'v8dbg_OddballTheHole',
-    'v8dbg_OddballTrue',
-    'v8dbg_OddballUndefined',
-    'v8dbg_OddballUninitialized',
-    'v8dbg_OneByteStringTag',
-    'v8dbg_SystemPointerSize',
-    'v8dbg_SystemPointerSizeLog2',
-    'v8dbg_TaggedSize',
-    'v8dbg_TaggedSizeLog2',
-    'v8dbg_SeqStringTag',
-    'v8dbg_SlicedStringTag',
-    'v8dbg_SmiShiftSize',
-    'v8dbg_SmiTag',
-    'v8dbg_SmiTagMask',
-    'v8dbg_SpecialAPIObjectType',
-    'v8dbg_StringEncodingMask',
-    'v8dbg_StringRepresentationMask',
-    'v8dbg_ThinStringTag',
-    'v8dbg_TwoByteStringTag',
-  ];
-}
diff --git a/test/wasi/test-return-on-exit.js b/test/wasi/test-return-on-exit.js
index 3f5d40c9ba7fb864767e9ac6c4b9a9f466d687e7..eef97996fbf7442a6bdd808fe1b5b6eab148f322 100644
--- a/test/wasi/test-return-on-exit.js
+++ b/test/wasi/test-return-on-exit.js
@@ -21,7 +21,8 @@ const buffer = fs.readFileSync(modulePath);
   // Verify that if a WASI application throws an exception, Node rethrows it
   // properly.
   const wasi = new WASI({ returnOnExit: true });
-  wasi.wasiImport.proc_exit = () => { throw new Error('test error'); };
+  const patchedExit = () => { throw new Error('test error'); };
+  wasi.wasiImport.proc_exit = patchedExit.bind(wasi.wasiImport);
   const importObject = { wasi_snapshot_preview1: wasi.wasiImport };
   const { instance } = await WebAssembly.instantiate(buffer, importObject);
 
diff --git a/test/wasi/test-wasi-not-started.js b/test/wasi/test-wasi-not-started.js
index ad13e6d711802b029c4b536f2ed8944484d821cf..93ceba3c06c7410695045a387898903cce0f63bb 100644
--- a/test/wasi/test-wasi-not-started.js
+++ b/test/wasi/test-wasi-not-started.js
@@ -31,7 +31,7 @@ if (process.argv[2] === 'wasi-child') {
     '--experimental-wasi-unstable-preview1',
     '--experimental-wasm-bigint',
     __filename,
-    'wasi-child'
+    'wasi-child',
   ], {
     env: { ...process.env, NODE_DEBUG_NATIVE: 'wasi' }
   });
diff --git a/test/wasi/test-wasi-stdio.js b/test/wasi/test-wasi-stdio.js
index 4abe3c1ad8ae0d7af7b57040fdc4b146931a2b15..d49fa67ce75a6a97c6956ec1a86a561435be5f54 100644
--- a/test/wasi/test-wasi-stdio.js
+++ b/test/wasi/test-wasi-stdio.js
@@ -1,6 +1,6 @@
 // Flags: --experimental-wasi-unstable-preview1 --experimental-wasm-bigint
 'use strict';
-require('../common');
+const common = require('../common');
 const tmpdir = require('../common/tmpdir');
 const { strictEqual } = require('assert');
 const { closeSync, openSync, readFileSync, writeFileSync } = require('fs');
@@ -31,4 +31,4 @@ const importObject = { wasi_snapshot_preview1: wasi.wasiImport };
   closeSync(stderr);
   strictEqual(readFileSync(stdoutFile, 'utf8').trim(), 'x'.repeat(31));
   strictEqual(readFileSync(stderrFile, 'utf8').trim(), '');
-})();
+})().then(common.mustCall());
diff --git a/test/wasi/test-wasi-symlinks.js b/test/wasi/test-wasi-symlinks.js
index d1ec796125cb532e95e27562620312fdae40fac3..16acca16f38564c02ee4c0e2fcb8640fe0b4c07a 100644
--- a/test/wasi/test-wasi-symlinks.js
+++ b/test/wasi/test-wasi-symlinks.js
@@ -14,7 +14,8 @@ if (process.argv[2] === 'wasi-child') {
     args: [],
     env: process.env,
     preopens: {
-      '/sandbox': process.argv[4]
+      '/sandbox': process.argv[4],
+      '/tmp': process.argv[5]
     }
   });
   const importObject = { wasi_snapshot_preview1: wasi.wasiImport };
@@ -25,7 +26,7 @@ if (process.argv[2] === 'wasi-child') {
     const { instance } = await WebAssembly.instantiate(buffer, importObject);
 
     wasi.start(instance);
-  })();
+  })().then(common.mustCall());
 } else {
   if (!common.canCreateSymLink()) {
     common.skip('insufficient privileges');
@@ -45,9 +46,11 @@ if (process.argv[2] === 'wasi-child') {
   const escapingSymlink = path.join(sandboxedDir, 'outside.txt');
   const loopSymlink1 = path.join(sandboxedDir, 'loop1');
   const loopSymlink2 = path.join(sandboxedDir, 'loop2');
+  const sandboxedTmp = path.join(tmpdir.path, 'tmp');
 
   fs.mkdirSync(sandbox);
   fs.mkdirSync(sandboxedDir);
+  fs.mkdirSync(sandboxedTmp);
   fs.writeFileSync(sandboxedFile, 'hello from input.txt', 'utf8');
   fs.writeFileSync(externalFile, 'this should be inaccessible', 'utf8');
   fs.symlinkSync(path.join('.', 'input.txt'), sandboxedSymlink, 'file');
@@ -66,7 +69,8 @@ if (process.argv[2] === 'wasi-child') {
       __filename,
       'wasi-child',
       options.test,
-      sandbox
+      sandbox,
+      sandboxedTmp,
     ], opts);
     console.log(child.stderr.toString());
     assert.strictEqual(child.status, 0);
@@ -76,6 +80,7 @@ if (process.argv[2] === 'wasi-child') {
 
   runWASI({ test: 'create_symlink', stdout: 'hello from input.txt' });
   runWASI({ test: 'follow_symlink', stdout: 'hello from input.txt' });
+  runWASI({ test: 'link' });
   runWASI({ test: 'symlink_escape' });
   runWASI({ test: 'symlink_loop' });
 }
diff --git a/test/wasi/test-wasi-worker-terminate.js b/test/wasi/test-wasi-worker-terminate.js
index 118c2a9d47e411bb7e1dd6152f35c5c0b3b106ef..a0851e14ad6b62cc2d5595af06151034d20ab9be 100644
--- a/test/wasi/test-wasi-worker-terminate.js
+++ b/test/wasi/test-wasi-worker-terminate.js
@@ -19,7 +19,7 @@ const bytecode = new Uint8Array([
   0x64, 0x75, 0x63, 0x65, 0x72, 0x73, 0x01, 0x0c, 0x70, 0x72, 0x6f, 0x63,
   0x65, 0x73, 0x73, 0x65, 0x64, 0x2d, 0x62, 0x79, 0x01, 0x05, 0x63, 0x6c,
   0x61, 0x6e, 0x67, 0x0f, 0x31, 0x30, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x34,
-  0x75, 0x62, 0x75, 0x6e, 0x74, 0x75, 0x31
+  0x75, 0x62, 0x75, 0x6e, 0x74, 0x75, 0x31,
 ]);
 
 // Do not use isMainThread so that this test itself can be run inside a Worker.
diff --git a/test/wasi/test-wasi.js b/test/wasi/test-wasi.js
index b4c404e515cbb2a54eac4fd52eb92d8535b577d9..bb89c51441a851bb7d5b1d637bde6c72f16d3197 100644
--- a/test/wasi/test-wasi.js
+++ b/test/wasi/test-wasi.js
@@ -30,7 +30,7 @@ if (process.argv[2] === 'wasi-child') {
     const { instance } = await WebAssembly.instantiate(buffer, importObject);
 
     wasi.start(instance);
-  })();
+  })().then(common.mustCall());
 } else {
   const assert = require('assert');
   const cp = require('child_process');
@@ -54,7 +54,7 @@ if (process.argv[2] === 'wasi-child') {
       '--experimental-wasm-bigint',
       __filename,
       'wasi-child',
-      options.test
+      options.test,
     ], opts);
     console.log(child.stderr.toString());
     assert.strictEqual(child.status, options.exitCode || 0);
@@ -79,7 +79,6 @@ if (process.argv[2] === 'wasi-child') {
     runWASI({ test: 'getrusage' });
   }
   runWASI({ test: 'gettimeofday' });
-  runWASI({ test: 'link' });
   runWASI({ test: 'main_args' });
   runWASI({ test: 'notdir' });
   runWASI({ test: 'poll' });
diff --git a/test/wasi/wasm/cant_dotdot.wasm b/test/wasi/wasm/cant_dotdot.wasm
deleted file mode 100755
index 1ffbe23c6afdb2fcb784db4d1c7d08ce3897e1c8..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/cant_dotdot.wasm and /dev/null differ
diff --git a/test/wasi/wasm/clock_getres.wasm b/test/wasi/wasm/clock_getres.wasm
deleted file mode 100755
index 510049dca4a0099b587983afeffe9f3ec4be71be..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/clock_getres.wasm and /dev/null differ
diff --git a/test/wasi/wasm/create_symlink.wasm b/test/wasi/wasm/create_symlink.wasm
deleted file mode 100755
index 1612e975d87e5d3a3e0182bad86f171037c3c5f5..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/create_symlink.wasm and /dev/null differ
diff --git a/test/wasi/wasm/exitcode.wasm b/test/wasi/wasm/exitcode.wasm
deleted file mode 100755
index ceb797f8b31ddf45a3f2313a4ee54d20d1e6131d..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/exitcode.wasm and /dev/null differ
diff --git a/test/wasi/wasm/fd_prestat_get_refresh.wasm b/test/wasi/wasm/fd_prestat_get_refresh.wasm
deleted file mode 100755
index 159cfa9e4c8159aaeb166c6bdbe20fdb4679513f..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/fd_prestat_get_refresh.wasm and /dev/null differ
diff --git a/test/wasi/wasm/follow_symlink.wasm b/test/wasi/wasm/follow_symlink.wasm
deleted file mode 100755
index f5f236c53f2440a5212de439577a959028b8dc65..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/follow_symlink.wasm and /dev/null differ
diff --git a/test/wasi/wasm/freopen.wasm b/test/wasi/wasm/freopen.wasm
deleted file mode 100755
index fb417fbe21fa69299a9892d8d4bf41047429eecc..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/freopen.wasm and /dev/null differ
diff --git a/test/wasi/wasm/ftruncate.wasm b/test/wasi/wasm/ftruncate.wasm
deleted file mode 100755
index a16e90d98ddb289bc87399df25e44c9f1b71519a..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/ftruncate.wasm and /dev/null differ
diff --git a/test/wasi/wasm/getentropy.wasm b/test/wasi/wasm/getentropy.wasm
deleted file mode 100755
index 527ac6a17d3008cbaf82e73138782babf5a66379..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/getentropy.wasm and /dev/null differ
diff --git a/test/wasi/wasm/getrusage.wasm b/test/wasi/wasm/getrusage.wasm
deleted file mode 100755
index c9546e232c795648eeb2966cc0b40c424bb2e4f2..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/getrusage.wasm and /dev/null differ
diff --git a/test/wasi/wasm/gettimeofday.wasm b/test/wasi/wasm/gettimeofday.wasm
deleted file mode 100755
index 7629b119d8895d3a74b4cf26ad304889a220bf29..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/gettimeofday.wasm and /dev/null differ
diff --git a/test/wasi/wasm/link.wasm b/test/wasi/wasm/link.wasm
deleted file mode 100755
index 60f5c07601a2af4e1e79c455b814c4834f976fc2..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/link.wasm and /dev/null differ
diff --git a/test/wasi/wasm/main_args.wasm b/test/wasi/wasm/main_args.wasm
deleted file mode 100755
index 60cb69defe2d32422dbe354325a27f499fc8cf78..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/main_args.wasm and /dev/null differ
diff --git a/test/wasi/wasm/notdir.wasm b/test/wasi/wasm/notdir.wasm
deleted file mode 100755
index 6b592fc17b032f64721eca09d6895d740e74c89d..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/notdir.wasm and /dev/null differ
diff --git a/test/wasi/wasm/poll.wasm b/test/wasi/wasm/poll.wasm
deleted file mode 100755
index 37e17b8d880ad220cbb89732bd9e67ff31a21ec7..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/poll.wasm and /dev/null differ
diff --git a/test/wasi/wasm/preopen_populates.wasm b/test/wasi/wasm/preopen_populates.wasm
deleted file mode 100755
index 618050b3b4c210a00509a1976662076f7c661a91..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/preopen_populates.wasm and /dev/null differ
diff --git a/test/wasi/wasm/read_file.wasm b/test/wasi/wasm/read_file.wasm
deleted file mode 100755
index 1c5e8107e0a9f754ceae521d64e12d09766ef36c..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/read_file.wasm and /dev/null differ
diff --git a/test/wasi/wasm/read_file_twice.wasm b/test/wasi/wasm/read_file_twice.wasm
deleted file mode 100755
index 6917a105eb4c08fca2ad381322ee64e738790343..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/read_file_twice.wasm and /dev/null differ
diff --git a/test/wasi/wasm/readdir.wasm b/test/wasi/wasm/readdir.wasm
deleted file mode 100755
index ce6cb4999524db243ef569120258fff2a8c23a9f..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/readdir.wasm and /dev/null differ
diff --git a/test/wasi/wasm/stat.wasm b/test/wasi/wasm/stat.wasm
deleted file mode 100755
index 4a50c0282bb60a43d9bb04291a01ec1461213c16..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/stat.wasm and /dev/null differ
diff --git a/test/wasi/wasm/stdin.wasm b/test/wasi/wasm/stdin.wasm
deleted file mode 100755
index 3cc548607af2e08ac762fd1a547d714eaad7dc99..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/stdin.wasm and /dev/null differ
diff --git a/test/wasi/wasm/symlink_escape.wasm b/test/wasi/wasm/symlink_escape.wasm
deleted file mode 100755
index fcb8cfd579078277554d2a239afc353872d52748..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/symlink_escape.wasm and /dev/null differ
diff --git a/test/wasi/wasm/symlink_loop.wasm b/test/wasi/wasm/symlink_loop.wasm
deleted file mode 100755
index 98e5c62f4b8355718bbd2f2ef396c23acd918f04..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/symlink_loop.wasm and /dev/null differ
diff --git a/test/wasi/wasm/write_file.wasm b/test/wasi/wasm/write_file.wasm
deleted file mode 100755
index c21d0c2bfef5c7a1198288c982f0f8f763d27b80..0000000000000000000000000000000000000000
Binary files a/test/wasi/wasm/write_file.wasm and /dev/null differ
diff --git a/test/wpt/status/FileAPI/blob.json b/test/wpt/status/FileAPI/blob.json
new file mode 100644
index 0000000000000000000000000000000000000000..23505105eafa4d4a1ed5142f3a6b9118a16d8738
--- /dev/null
+++ b/test/wpt/status/FileAPI/blob.json
@@ -0,0 +1,17 @@
+{
+  "Blob-constructor.any.js": {
+    "skip": "https://github.com/nodejs/node/issues/37358"
+  },
+  "Blob-constructor-dom.window.js": {
+    "skip": "Depends on DOM API"
+  },
+  "Blob-slice.any.js": {
+    "skip": "Depends on File API"
+  },
+  "Blob-stream.any.js": {
+    "skip": "Depends on Web Streams API"
+  },
+  "Blob-in-worker.worker.js": {
+    "skip": "Depends on Web Workers API"
+  }
+}
diff --git a/test/wpt/status/dom/abort.json b/test/wpt/status/dom/abort.json
new file mode 100644
index 0000000000000000000000000000000000000000..0967ef424bce6791893e9a57bb952f80fd536e93
--- /dev/null
+++ b/test/wpt/status/dom/abort.json
@@ -0,0 +1 @@
+{}
diff --git a/test/wpt/status/html/webappapis/atob.json b/test/wpt/status/html/webappapis/atob.json
new file mode 100644
index 0000000000000000000000000000000000000000..65deda7312d4266ad37b0a2c4b1c40d156b16839
--- /dev/null
+++ b/test/wpt/status/html/webappapis/atob.json
@@ -0,0 +1,5 @@
+{
+  "base64.any.js": {
+    "fail": "promise_test: Unhandled rejection with value: object \"Error: ENOENT: no such file or directory, open '/root/node/node/fetch/data-urls/resources/base64.json'\""
+  }
+}
diff --git a/test/wpt/test-abort.js b/test/wpt/test-abort.js
new file mode 100644
index 0000000000000000000000000000000000000000..36946d721e9dc9d5f17616e0d4ca86fedf393795
--- /dev/null
+++ b/test/wpt/test-abort.js
@@ -0,0 +1,9 @@
+'use strict';
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('dom/abort');
+
+runner.setFlags(['--experimental-abortcontroller']);
+
+runner.runJsTests();
diff --git a/test/wpt/test-atob.js b/test/wpt/test-atob.js
new file mode 100644
index 0000000000000000000000000000000000000000..51fa27e36d3f2f0ead5a323c9675422a8143993f
--- /dev/null
+++ b/test/wpt/test-atob.js
@@ -0,0 +1,19 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('html/webappapis/atob');
+
+// Needed to access to DOMException.
+runner.setFlags(['--expose-internals']);
+
+// Set a script that will be executed in the worker before running the tests.
+runner.setInitScript(`
+  const { internalBinding } = require('internal/test/binding');
+  const { atob, btoa } = require('buffer');
+  const { DOMException } = internalBinding('messaging');
+  global.DOMException = DOMException;
+`);
+
+runner.runJsTests();
diff --git a/test/wpt/test-blob.js b/test/wpt/test-blob.js
new file mode 100644
index 0000000000000000000000000000000000000000..92e18bc0ef2f220d3f2719afaec8bbc9c505695c
--- /dev/null
+++ b/test/wpt/test-blob.js
@@ -0,0 +1,13 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('FileAPI/blob');
+
+runner.setInitScript(`
+  const { Blob } = require('buffer');
+  global.Blob = Blob;
+`);
+
+runner.runJsTests();
diff --git a/tools/actions/commit-queue.sh b/tools/actions/commit-queue.sh
index 028297217469a032f597de73b8169f4ded20fb49..22f306cc36b684d2c0d3a0c52bd9484ae87dab19 100755
--- a/tools/actions/commit-queue.sh
+++ b/tools/actions/commit-queue.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 
 set -xe
 
@@ -7,23 +7,26 @@ REPOSITORY=$2
 GITHUB_TOKEN=$3
 shift 3
 
+UPSTREAM=origin
+DEFAULT_BRANCH=master
+
 API_URL=https://api.github.com
 COMMIT_QUEUE_LABEL='commit-queue'
 COMMIT_QUEUE_FAILED_LABEL='commit-queue-failed'
 
-function issueUrl() {
+issueUrl() {
   echo "$API_URL/repos/${OWNER}/${REPOSITORY}/issues/${1}"
 }
 
-function labelsUrl() {
+labelsUrl() {
   echo "$(issueUrl "${1}")/labels"
 }
 
-function commentsUrl() {
+commentsUrl() {
   echo "$(issueUrl "${1}")/comments"
 }
 
-function gitHubCurl() {
+gitHubCurl() {
   url=$1
   method=$2
   shift 2
@@ -34,6 +37,18 @@ function gitHubCurl() {
        --header 'content-type: application/json' "$@"
 }
 
+commit_queue_failed() {
+  gitHubCurl "$(labelsUrl "${1}")" POST --data '{"labels": ["'"${COMMIT_QUEUE_FAILED_LABEL}"'"]}'
+
+  # shellcheck disable=SC2154
+  cqurl="${GITHUB_SERVER_URL}/${OWNER}/${REPOSITORY}/actions/runs/${GITHUB_RUN_ID}"
+  jq -n --arg content "<details><summary>Commit Queue failed</summary><pre>$(cat output)</pre><a href='$cqurl'>$cqurl</a></details>" '{body: $content}' > output.json
+  cat output.json
+
+  gitHubCurl "$(commentsUrl "${1}")" POST --data @output.json
+
+  rm output output.json
+}
 
 # TODO(mmarchini): should this be set with whoever added the label for each PR?
 git config --local user.email "github-bot@iojs.org"
@@ -61,25 +76,25 @@ for pr in "$@"; do
 
   # TODO(mmarchini): workaround for ncu not returning the expected status code,
   # if the "Landed in..." message was not on the output we assume land failed
-  if ! tail -n 10 output | grep '. Post "Landed in .*/pull/'"${pr}"; then
-    gitHubCurl "$(labelsUrl "$pr")" POST --data '{"labels": ["'"${COMMIT_QUEUE_FAILED_LABEL}"'"]}'
-
-    jq -n --arg content "<details><summary>Commit Queue failed</summary><pre>$(cat output)</pre></details>" '{body: $content}' > output.json
-    cat output.json
-
-    gitHubCurl "$(commentsUrl "$pr")" POST --data @output.json
-
-    rm output output.json
+  if ! grep -q '. Post "Landed in .*/pull/'"${pr}" output; then
+    commit_queue_failed "$pr"
     # If `git node land --abort` fails, we're in unknown state. Better to stop
     # the script here, current PR was removed from the queue so it shouldn't
-    # interfer again in the future
+    # interfere again in the future.
     git node land --abort --yes
-  else
-    rm output
-    git push origin master
-
-    gitHubCurl "$(commentsUrl "$pr")" POST --data '{"body": "Landed in '"$(git rev-parse HEAD)"'"}'
+    continue
+  fi
+  
+  commits="$(git rev-parse $UPSTREAM/$DEFAULT_BRANCH)...$(git rev-parse HEAD)"
 
-    gitHubCurl "$(issueUrl "$pr")" PATCH --data '{"state": "closed"}'
+  if ! git push $UPSTREAM $DEFAULT_BRANCH >> output 2>&1; then
+    commit_queue_failed "$pr"
+    continue
   fi
+
+  rm output
+
+  gitHubCurl "$(commentsUrl "$pr")" POST --data '{"body": "Landed in '"$commits"'"}'
+
+  gitHubCurl "$(issueUrl "$pr")" PATCH --data '{"state": "closed"}'
 done
diff --git a/tools/actions/start-ci.sh b/tools/actions/start-ci.sh
index 8eb3dae3c5bdf0b0c4e7e7ccb3e1ef8d27dc2c66..72a04b6b321b1fa18789c259dacb1dad70cf16d0 100755
--- a/tools/actions/start-ci.sh
+++ b/tools/actions/start-ci.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 
 set -xe
 
@@ -10,15 +10,15 @@ REQUEST_CI_LABEL='request-ci'
 REQUEST_CI_FAILED_LABEL='request-ci-failed'
 shift 3
 
-function issueUrl() {
+issueUrl() {
   echo "$API_URL/repos/${OWNER}/${REPOSITORY}/issues/${1}"
 }
 
-function labelsUrl() {
+labelsUrl() {
   echo "$(issueUrl "${1}")/labels"
 }
 
-function commentsUrl() {
+commentsUrl() {
   echo "$(issueUrl "${1}")/comments"
 }
 
@@ -33,7 +33,7 @@ for pr in "$@"; do
   ncu-ci run "$pr" >output 2>&1 || ci_started=no
   cat output
 
-  if [ "$ci_started" == "no" ]; then
+  if [ "$ci_started" = "no" ]; then
     # Do we need to reset?
     curl -sL --request PUT \
        --url "$(labelsUrl "$pr")" \
diff --git a/tools/bootstrap/windows_boxstarter b/tools/bootstrap/windows_boxstarter
index dd6dd25ba03a2f877cb139175d9cca7a6d4bfca7..eb0b2d72e98381ea8bebf7957bb639c845bd9ac5 100644
--- a/tools/bootstrap/windows_boxstarter
+++ b/tools/bootstrap/windows_boxstarter
@@ -1,15 +1,15 @@
 # Boxstarter (http://boxstarter.org/) script for Node.js prerequisites
 #
 # To install either open this link in IE or Edge:
-#  http://boxstarter.org/package/nr/url?https://raw.githubusercontent.com/nodejs/node/master/tools/bootstrap/windows_boxstarter
+#  http://boxstarter.org/package/nr/url?https://raw.githubusercontent.com/nodejs/node/HEAD/tools/bootstrap/windows_boxstarter
 #
 # Or run those commands in an elevated Powershell terminal:
 #  iex ((New-Object System.Net.WebClient).DownloadString('http://boxstarter.org/bootstrapper.ps1'))
 #  get-boxstarter -Force
-#  Install-BoxstarterPackage https://raw.githubusercontent.com/nodejs/node/master/tools/bootstrap/windows_boxstarter -DisableReboots
+#  Install-BoxstarterPackage https://raw.githubusercontent.com/nodejs/node/HEAD/tools/bootstrap/windows_boxstarter -DisableReboots
 #
 # For more detail see
-# https://github.com/nodejs/node/blob/master/tools/bootstrap/README.md
+# https://github.com/nodejs/node/blob/HEAD/tools/bootstrap/README.md
 #
 
 # Git and Unix tools will be added to the PATH
diff --git a/tools/checkimports.py b/tools/checkimports.py
index 609a75f542748f6d41ed57d7b5b7ccc6ea40e52e..b94919e3cc47e4b2452c19175c7627cc070ef2e2 100755
--- a/tools/checkimports.py
+++ b/tools/checkimports.py
@@ -5,7 +5,7 @@ import glob
 import io
 import re
 import sys
-
+import itertools
 
 def do_exist(file_name, lines, imported):
   if not any(not re.match('using \w+::{0};'.format(imported), line) and
@@ -41,5 +41,10 @@ def is_valid(file_name):
     return valid
 
 if __name__ == '__main__':
-  files = glob.iglob(sys.argv[1] if len(sys.argv) > 1 else 'src/*.cc')
-  sys.exit(0 if all(map(is_valid, files)) else 1)
+  if len(sys.argv) > 1:
+    files = []
+    for pattern in sys.argv[1:]:
+      files = itertools.chain(files, glob.iglob(pattern))
+  else:
+    files = glob.iglob('src/*.cc')
+  sys.exit(0 if all(list(map(is_valid, files))) else 1)
diff --git a/tools/clang-format/package-lock.json b/tools/clang-format/package-lock.json
index af57b9891ff8302254162ef93729d683e407c32e..61f17967f0e4a5c519d049e162546e03d5584415 100644
--- a/tools/clang-format/package-lock.json
+++ b/tools/clang-format/package-lock.json
@@ -92,9 +92,9 @@
       "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
     },
     "path-parse": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
-      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw=="
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="
     },
     "resolve": {
       "version": "1.8.1",
diff --git a/tools/code_cache/mkcodecache.cc b/tools/code_cache/mkcodecache.cc
index 3d2473ec87fd096f7b1de575ff32ec112842785d..c314e07fd78b224033c05de90ed56bc07a8aa41f 100644
--- a/tools/code_cache/mkcodecache.cc
+++ b/tools/code_cache/mkcodecache.cc
@@ -24,10 +24,10 @@ using v8::Local;
 int wmain(int argc, wchar_t* argv[]) {
 #else   // UNIX
 int main(int argc, char* argv[]) {
-  argv = uv_setup_args(argc, argv);
 #endif  // _WIN32
 
   v8::V8::SetFlagsFromString("--random_seed=42");
+  v8::V8::SetFlagsFromString("--harmony-top-level-await");
 
   if (argc < 2) {
     std::cerr << "Usage: " << argv[0] << " <path/to/output.cc>\n";
@@ -49,9 +49,8 @@ int main(int argc, char* argv[]) {
 
   // Create a new Isolate and make it the current one.
   Isolate::CreateParams create_params;
-  std::unique_ptr<ArrayBuffer::Allocator> array_buffer_allocator {
-      ArrayBuffer::Allocator::NewDefaultAllocator() };
-  create_params.array_buffer_allocator = array_buffer_allocator.get();
+  create_params.array_buffer_allocator_shared.reset(
+      ArrayBuffer::Allocator::NewDefaultAllocator());
   Isolate* isolate = Isolate::New(create_params);
   {
     Isolate::Scope isolate_scope(isolate);
diff --git a/tools/configure.d/nodedownload.py b/tools/configure.d/nodedownload.py
index 515704e3de4763d7ce6c1ed3d76cb10907f7836c..4f144e0e4b406c7f7590455d096d96e2ad4d91a2 100644
--- a/tools/configure.d/nodedownload.py
+++ b/tools/configure.d/nodedownload.py
@@ -63,7 +63,7 @@ def checkHash(targetfile, hashAlgo):
     digest = hashlib.new(hashAlgo)
     with open(targetfile, 'rb') as f:
       chunk = f.read(1024)
-      while chunk !=  "":
+      while len(chunk) > 0:
         digest.update(chunk)
         chunk = f.read(1024)
     return digest.hexdigest()
diff --git a/tools/create_expfile.sh b/tools/create_expfile.sh
index 1daed4b1984068c0b99a08c1cf854efdd557e3ef..cac20da721b06a1da6d292490d08a622ddd53778 100755
--- a/tools/create_expfile.sh
+++ b/tools/create_expfile.sh
@@ -37,15 +37,15 @@
 echo "Searching $1 to write out expfile to $2"
 
 # This special sequence must be at the start of the exp file.
-echo "#!." > $2.tmp
+echo "#!." > "$2.tmp"
 
 # Pull the symbols from the .a files.
-find $1 -name "*.a" | grep -v gtest \
+find "$1" -name "*.a" | grep -v gtest \
   | xargs nm -Xany -BCpg \
   | awk '{
       if ((($2 == "T") || ($2 == "D") || ($2 == "B")) &&
           (substr($3,1,1) != ".")) { print $3 }
     }' \
-  | sort -u >> $2.tmp
+  | sort -u >> "$2.tmp"
 
-mv -f $2.tmp $2
+mv -f "$2.tmp" "$2"
diff --git a/tools/doc/README.md b/tools/doc/README.md
index f2f37faa653d4ded145b73962a9d2c95d2a392a6..e2aedfb1b5662251d3738c3831b64d780fc8409a 100644
--- a/tools/doc/README.md
+++ b/tools/doc/README.md
@@ -78,7 +78,7 @@ added: v0.10.0
 
 * Returns: {SomeClass | null} The next `SomeClass` in line.
 
-`SomeClass` must be registered in `tools/doc/type-parser.js`
+`SomeClass` must be registered in `tools/doc/type-parser.mjs`
 to be properly parsed in `{type}` fields.
 
 ### SomeClass.someProperty
diff --git a/tools/doc/addon-verify.js b/tools/doc/addon-verify.mjs
similarity index 62%
rename from tools/doc/addon-verify.js
rename to tools/doc/addon-verify.mjs
index c4dfdba9c4d3adb76383b15581bd122b91cb4edd..ee4d597693b8b3bf04bac385ebd7ad56fcc29e8d 100644
--- a/tools/doc/addon-verify.js
+++ b/tools/doc/addon-verify.mjs
@@ -1,23 +1,22 @@
-'use strict';
-
 // doc/api/addons.md has a bunch of code.  Extract it for verification
 // that the C++ code compiles and the js code runs.
 // Add .gyp files which will be used to compile the C++ code.
 // Modify the require paths in the js code to pull from the build tree.
 // Triggered from the build-addons target in the Makefile and vcbuild.bat.
 
-const { mkdir, writeFile } = require('fs');
-const { resolve } = require('path');
-const vfile = require('to-vfile');
-const unified = require('unified');
-const remarkParse = require('remark-parse');
+import { mkdir, writeFile } from 'fs/promises';
+
+import gfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { toVFile } from 'to-vfile';
+import unified from 'unified';
 
-const rootDir = resolve(__dirname, '..', '..');
-const doc = resolve(rootDir, 'doc', 'api', 'addons.md');
-const verifyDir = resolve(rootDir, 'test', 'addons');
+const rootDir = new URL('../../', import.meta.url);
+const doc = new URL('./doc/api/addons.md', rootDir);
+const verifyDir = new URL('./test/addons/', rootDir);
 
-const file = vfile.readSync(doc, 'utf8');
-const tree = unified().use(remarkParse).parse(file);
+const file = toVFile.readSync(doc, 'utf8');
+const tree = unified().use(remarkParse).use(gfm).parse(file);
 const addons = {};
 let id = 0;
 let currentHeader;
@@ -25,7 +24,7 @@ let currentHeader;
 const validNames = /^\/\/\s+(.*\.(?:cc|h|js))[\r\n]/;
 tree.children.forEach((node) => {
   if (node.type === 'heading') {
-    currentHeader = file.contents.slice(
+    currentHeader = file.value.slice(
       node.children[0].position.start.offset,
       node.position.end.offset);
     addons[currentHeader] = { files: {} };
@@ -37,9 +36,10 @@ tree.children.forEach((node) => {
   }
 });
 
-Object.keys(addons).forEach((header) => {
-  verifyFiles(addons[header].files, header);
-});
+await Promise.all(
+  Object.keys(addons).flatMap(
+    (header) => verifyFiles(addons[header].files, header)
+  ));
 
 function verifyFiles(files, blockName) {
   const fileNames = Object.keys(files);
@@ -47,13 +47,13 @@ function verifyFiles(files, blockName) {
   // Must have a .cc and a .js to be a valid test.
   if (!fileNames.some((name) => name.endsWith('.cc')) ||
       !fileNames.some((name) => name.endsWith('.js'))) {
-    return;
+    return [];
   }
 
   blockName = blockName.toLowerCase().replace(/\s/g, '_').replace(/\W/g, '');
-  const dir = resolve(
+  const dir = new URL(
+    `./${String(++id).padStart(2, '0')}_${blockName}/`,
     verifyDir,
-    `${String(++id).padStart(2, '0')}_${blockName}`
   );
 
   files = fileNames.map((name) => {
@@ -67,14 +67,14 @@ ${files[name].replace(
 `;
     }
     return {
-      path: resolve(dir, name),
-      name: name,
-      content: files[name]
+      content: files[name],
+      name,
+      url: new URL(`./${name}`, dir),
     };
   });
 
   files.push({
-    path: resolve(dir, 'binding.gyp'),
+    url: new URL('./binding.gyp', dir),
     content: JSON.stringify({
       targets: [
         {
@@ -86,16 +86,8 @@ ${files[name].replace(
     })
   });
 
-  mkdir(dir, () => {
-    // Ignore errors.
+  const dirCreation = mkdir(dir);
 
-    files.forEach(({ path, content }) => {
-      writeFile(path, content, (err) => {
-        if (err)
-          throw err;
-
-        console.log(`Wrote ${path}`);
-      });
-    });
-  });
+  return files.map(({ url, content }) =>
+    dirCreation.then(() => writeFile(url, content)));
 }
diff --git a/tools/doc/allhtml.js b/tools/doc/allhtml.mjs
similarity index 72%
rename from tools/doc/allhtml.js
rename to tools/doc/allhtml.mjs
index c038b1f57a9bb8cec2caff35588cf3bbf938ae1b..905ea5d3dd6c6fc7aaca6c1a7066e39767c2f919 100644
--- a/tools/doc/allhtml.js
+++ b/tools/doc/allhtml.mjs
@@ -1,18 +1,16 @@
-'use strict';
-
 // Build all.html by combining the generated toc and apicontent from each
 // of the generated html files.
 
-const fs = require('fs');
+import fs from 'fs';
 
-const source = `${__dirname}/../../out/doc/api`;
+const source = new URL('../../out/doc/api/', import.meta.url);
 
 // Get a list of generated API documents.
 const htmlFiles = fs.readdirSync(source, 'utf8')
   .filter((name) => name.includes('.html') && name !== 'all.html');
 
 // Read the table of contents.
-const toc = fs.readFileSync(source + '/index.html', 'utf8');
+const toc = fs.readFileSync(new URL('./index.html', source), 'utf8');
 
 // Extract (and concatenate) the toc and apicontent from each document.
 let contents = '';
@@ -28,16 +26,16 @@ const seen = {
 for (const link of toc.match(/<a.*?>/g)) {
   const href = /href="(.*?)"/.exec(link)[1];
   if (!htmlFiles.includes(href) || seen[href]) continue;
-  const data = fs.readFileSync(source + '/' + href, 'utf8');
+  const data = fs.readFileSync(new URL(`./${href}`, source), 'utf8');
 
   // Split the doc.
-  const match = /(<\/ul>\s*)?<\/div>\s*<div id="apicontent">/.exec(data);
+  const match = /(<\/ul>\s*)?<\/\w+>\s*<\w+ id="apicontent">/.exec(data);
 
   contents += data.slice(0, match.index)
-    .replace(/[\s\S]*?<div id="toc">\s*<h2>.*?<\/h2>\s*(<ul>\s*)?/, '');
+    .replace(/[\s\S]*?id="toc"[^>]*>\s*<\w+>.*?<\/\w+>\s*(<ul>\s*)?/, '');
 
-  apicontent += data.slice(match.index + match[0].length)
-    .replace(/<!-- API END -->[\s\S]*/, '')
+  apicontent += '<section>' + data.slice(match.index + match[0].length)
+    .replace(/<!-- API END -->[\s\S]*/, '</section>')
     .replace(/<a href="(\w[^#"]*)#/g, (match, href) => {
       return htmlFiles.includes(href) ? '<a href="#' : match;
     })
@@ -59,30 +57,32 @@ let all = toc.replace(/index\.html/g, 'all.html')
 all = all.replace(/<title>.*?\| /, '<title>');
 
 // Insert the combined table of contents.
-const tocStart = /<div id="toc">\s*<h2>.*?<\/h2>\s*/.exec(all);
+const tocStart = /<!-- TOC -->/.exec(all);
 all = all.slice(0, tocStart.index + tocStart[0].length) +
+  '<details id="toc" open><summary>Table of contents</summary>\n' +
   '<ul>\n' + contents + '</ul>\n' +
+  '</details>\n' +
   all.slice(tocStart.index + tocStart[0].length);
 
 // Replace apicontent with the concatenated set of apicontents from each source.
-const apiStart = /<div id="apicontent">\s*/.exec(all);
+const apiStart = /<\w+ id="apicontent">\s*/.exec(all);
 const apiEnd = all.lastIndexOf('<!-- API END -->');
 all = all.slice(0, apiStart.index + apiStart[0].length) +
   apicontent +
   all.slice(apiEnd);
 
 // Write results.
-fs.writeFileSync(source + '/all.html', all, 'utf8');
+fs.writeFileSync(new URL('./all.html', source), all, 'utf8');
 
 // Validate all hrefs have a target.
 const ids = new Set();
-const idRe = / id="(\w+)"/g;
+const idRe = / id="([^"]+)"/g;
 let match;
 while (match = idRe.exec(all)) {
   ids.add(match[1]);
 }
 
-const hrefRe = / href="#(\w+)"/g;
+const hrefRe = / href="#([^"]+)"/g;
 while (match = hrefRe.exec(all)) {
   if (!ids.has(match[1])) throw new Error(`link not found: ${match[1]}`);
 }
diff --git a/tools/doc/alljson.js b/tools/doc/alljson.mjs
similarity index 79%
rename from tools/doc/alljson.js
rename to tools/doc/alljson.mjs
index 7e027f764e7efd486a1519cfff85c91b90e71da1..18afc29e7e93665e6715b2612c6faea6a55a61a6 100644
--- a/tools/doc/alljson.js
+++ b/tools/doc/alljson.mjs
@@ -1,18 +1,16 @@
-'use strict';
-
 // Build all.json by combining the miscs, modules, classes, globals, and methods
 // from the generated json files.
 
-const fs = require('fs');
+import fs from 'fs';
 
-const source = `${__dirname}/../../out/doc/api`;
+const source = new URL('../../out/doc/api/', import.meta.url);
 
 // Get a list of generated API documents.
 const jsonFiles = fs.readdirSync(source, 'utf8')
   .filter((name) => name.includes('.json') && name !== 'all.json');
 
 // Read the table of contents.
-const toc = fs.readFileSync(source + '/index.html', 'utf8');
+const toc = fs.readFileSync(new URL('./index.html', source), 'utf8');
 
 // Initialize results. Only these four data values will be collected.
 const results = {
@@ -37,12 +35,15 @@ for (const link of toc.match(/<a.*?>/g)) {
   const json = href.replace('.html', '.json');
   if (!jsonFiles.includes(json) || seen[json]) continue;
   const data = JSON.parse(
-    fs.readFileSync(source + '/' + json, 'utf8')
+    fs.readFileSync(new URL(`./${json}`, source), 'utf8')
       .replace(/<a href=\\"#/g, `<a href=\\"${href}#`)
   );
 
   for (const property in data) {
     if (results.hasOwnProperty(property)) {
+      data[property].forEach((mod) => {
+        mod.source = data.source;
+      });
       results[property].push(...data[property]);
     }
   }
@@ -52,5 +53,5 @@ for (const link of toc.match(/<a.*?>/g)) {
 }
 
 // Write results.
-fs.writeFileSync(source + '/all.json',
+fs.writeFileSync(new URL('./all.json', source),
                  `${JSON.stringify(results, null, 2)}\n`, 'utf8');
diff --git a/tools/doc/apilinks.js b/tools/doc/apilinks.mjs
similarity index 94%
rename from tools/doc/apilinks.js
rename to tools/doc/apilinks.mjs
index 461805dac3a811ca90030e29a77ebcba71ab19ef..a1b660f1cfaf54ca3b3da891d1144188ec593525 100644
--- a/tools/doc/apilinks.js
+++ b/tools/doc/apilinks.mjs
@@ -1,5 +1,3 @@
-'use strict';
-
 // Scan API sources for definitions.
 //
 // Note the output is produced based on a world class parser, adherence to
@@ -18,10 +16,11 @@
 //    `function X(...) {...}`). Over time, we expect to handle more
 //    cases (example: ES2015 class definitions).
 
-const acorn = require('../../deps/acorn/acorn');
-const fs = require('fs');
-const path = require('path');
-const child_process = require('child_process');
+import child_process from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+import * as acorn from '../../deps/acorn/acorn/dist/acorn.mjs';
 
 // Run a command, capturing stdout, ignoring errors.
 function execSync(command) {
@@ -54,14 +53,16 @@ inputs.forEach((file) => {
 
   // Parse source.
   const source = fs.readFileSync(file, 'utf8');
-  const ast = acorn.parse(
-    source,
-    { allowReturnOutsideFunction: true, ecmaVersion: 10, locations: true });
+  const ast = acorn.parse(source, {
+    allowReturnOutsideFunction: true,
+    ecmaVersion: 'latest',
+    locations: true,
+  });
   const program = ast.body;
 
   // Build link
-  const link = `https://github.com/${repo}/blob/${tag}/` +
-    path.relative('.', file).replace(/\\/g, '/');
+  const link =
+    `https://github.com/${repo}/blob/${tag}/${path.relative('.', file).replace(/\\/g, '/')}`;
 
   // Scan for exports.
   const exported = { constructors: [], identifiers: [] };
diff --git a/tools/doc/checkLinks.js b/tools/doc/checkLinks.js
deleted file mode 100644
index aeb0fe5d03f2325e1fc1f9e6156e98218292964a..0000000000000000000000000000000000000000
--- a/tools/doc/checkLinks.js
+++ /dev/null
@@ -1,76 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const { extname, join, resolve } = require('path');
-const unified = require('unified');
-const { pathToFileURL } = require('url');
-const DIR = resolve(process.argv[2]);
-
-console.log('Running Markdown link checker...');
-findMarkdownFilesRecursively(DIR);
-
-function* getLinksRecursively(node) {
-  if (node.url && !node.url.startsWith('#')) {
-    yield node;
-  }
-  for (const child of node.children || []) {
-    yield* getLinksRecursively(child);
-  }
-}
-
-function findMarkdownFilesRecursively(dirPath) {
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const path = join(dirPath, entry.name);
-
-    if (
-      entry.isDirectory() &&
-      entry.name !== 'api' &&
-      entry.name !== 'build' &&
-      entry.name !== 'changelogs' &&
-      entry.name !== 'deps' &&
-      entry.name !== 'fixtures' &&
-      entry.name !== 'gyp' &&
-      entry.name !== 'node_modules' &&
-      entry.name !== 'out' &&
-      entry.name !== 'tmp'
-    ) {
-      findMarkdownFilesRecursively(path);
-    } else if (entry.isFile() && extname(entry.name) === '.md') {
-      checkFile(path);
-    }
-  }
-}
-
-function checkFile(path) {
-  const tree = unified()
-    .use(require('remark-parse'))
-    .parse(fs.readFileSync(path));
-
-  const base = pathToFileURL(path);
-  let previousDefinitionLabel;
-  for (const node of getLinksRecursively(tree)) {
-    const targetURL = new URL(node.url, base);
-    if (targetURL.protocol === 'file:' && !fs.existsSync(targetURL)) {
-      const { line, column } = node.position.start;
-      console.error((process.env.GITHUB_ACTIONS ?
-        `::error file=${path},line=${line},col=${column}::` : '') +
-        `Broken link at ${path}:${line}:${column} (${node.url})`);
-      process.exitCode = 1;
-    }
-    if (node.type === 'definition') {
-      if (previousDefinitionLabel &&
-          previousDefinitionLabel > node.label) {
-        const { line, column } = node.position.start;
-        console.error((process.env.GITHUB_ACTIONS ?
-          `::error file=${path},line=${line},col=${column}::` : '') +
-          `Unordered reference at ${path}:${line}:${column} (` +
-          `"${node.label}" should be before "${previousDefinitionLabel})"`
-        );
-        process.exitCode = 1;
-      }
-      previousDefinitionLabel = node.label;
-    }
-  }
-}
diff --git a/tools/doc/common.js b/tools/doc/common.mjs
similarity index 67%
rename from tools/doc/common.js
rename to tools/doc/common.mjs
index 11e4ad6e2c99aa8f6a79bb2f4772488208f18e7d..2f838e3b15016abe0d9b8542558b4a5d91c536cd 100644
--- a/tools/doc/common.js
+++ b/tools/doc/common.mjs
@@ -1,27 +1,24 @@
-'use strict';
+import yaml from 'js-yaml';
 
-const yaml =
-  require(`${__dirname}/../node_modules/eslint/node_modules/js-yaml`);
-
-function isYAMLBlock(text) {
+export function isYAMLBlock(text) {
   return /^<!-- YAML/.test(text);
 }
 
-function isSourceLink(text) {
+export function isSourceLink(text) {
   return /^<!-- source_link=([^\s/]+\/)+\w+\.\w+ -->/.test(text);
 }
 
-function arrify(value) {
+export function arrify(value) {
   return Array.isArray(value) ? value : [value];
 }
 
-function extractAndParseYAML(text) {
+export function extractAndParseYAML(text) {
   text = text.trim()
              .replace(/^<!-- YAML/, '')
              .replace(/-->$/, '');
 
-  // js-yaml.safeLoad() throws on error.
-  const meta = yaml.safeLoad(text);
+  // js-yaml.load() throws on error.
+  const meta = yaml.load(text);
 
   if (meta.added) {
     // Since semver-minors can trickle down to previous major versions,
@@ -46,5 +43,3 @@ function extractAndParseYAML(text) {
 
   return meta;
 }
-
-module.exports = { arrify, isYAMLBlock, isSourceLink, extractAndParseYAML };
diff --git a/tools/doc/generate.js b/tools/doc/generate.mjs
similarity index 85%
rename from tools/doc/generate.js
rename to tools/doc/generate.mjs
index 007a0d48eed3473a245f88eea2d2b77f61496f2f..95f5528e31152e8d2c5c957e25f486cba314b705 100644
--- a/tools/doc/generate.js
+++ b/tools/doc/generate.mjs
@@ -19,20 +19,23 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-'use strict';
+import { readFileSync, promises as fs } from 'fs';
+import path from 'path';
 
-const { promises: fs } = require('fs');
-const path = require('path');
-const unified = require('unified');
-const markdown = require('remark-parse');
-const remark2rehype = require('remark-rehype');
-const raw = require('rehype-raw');
-const htmlStringify = require('rehype-stringify');
+import raw from 'rehype-raw';
+import htmlStringify from 'rehype-stringify';
+import gfm from 'remark-gfm';
+import markdown from 'remark-parse';
+import remark2rehype from 'remark-rehype';
+import frontmatter from 'remark-frontmatter';
+import unified from 'unified';
 
-const { replaceLinks } = require('./markdown');
-const linksMapper = require('./links-mapper');
-const html = require('./html');
-const json = require('./json');
+import * as html from './html.mjs';
+import * as json from './json.mjs';
+import { replaceLinks } from './markdown.mjs';
+
+const linksMapperFile = new URL('links-mapper.json', import.meta.url);
+const linksMapper = JSON.parse(readFileSync(linksMapperFile, 'utf8'));
 
 // Parse the args.
 // Don't use nopt or whatever for this. It's simple enough.
@@ -42,7 +45,7 @@ let filename = null;
 let nodeVersion = null;
 let outputDir = null;
 let apilinks = {};
-let versions = {};
+let versions = [];
 
 async function main() {
   for (const arg of args) {
@@ -80,8 +83,10 @@ async function main() {
   const input = await fs.readFile(filename, 'utf8');
 
   const content = await unified()
+    .use(frontmatter)
     .use(replaceLinks, { filename, linksMapper })
     .use(markdown)
+    .use(gfm)
     .use(html.preprocessText, { nodeVersion })
     .use(json.jsonAPI, { filename })
     .use(html.firstHeader)
diff --git a/tools/doc/html.js b/tools/doc/html.mjs
similarity index 69%
rename from tools/doc/html.js
rename to tools/doc/html.mjs
index e84c7526f01844c528be0953eb0e406428386af6..c2c3a7a1836e88b35b5cf1191f9b75c6256fef80 100644
--- a/tools/doc/html.js
+++ b/tools/doc/html.mjs
@@ -19,26 +19,24 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-'use strict';
-
-const common = require('./common.js');
-const fs = require('fs');
-const unified = require('unified');
-const find = require('unist-util-find');
-const visit = require('unist-util-visit');
-const markdown = require('remark-parse');
-const remark2rehype = require('remark-rehype');
-const raw = require('rehype-raw');
-const htmlStringify = require('rehype-stringify');
-const path = require('path');
-const typeParser = require('./type-parser.js');
-const { highlight, getLanguage } = require('highlight.js');
-
-module.exports = {
-  toHTML, firstHeader, preprocessText, preprocessElements, buildToc
-};
-
-const docPath = path.resolve(__dirname, '..', '..', 'doc');
+import fs from 'fs';
+import path from 'path';
+
+import highlightJs from 'highlight.js';
+import raw from 'rehype-raw';
+import htmlStringify from 'rehype-stringify';
+import gfm from 'remark-gfm';
+import markdown from 'remark-parse';
+import remark2rehype from 'remark-rehype';
+import unified from 'unified';
+import { visit } from 'unist-util-visit';
+
+import * as common from './common.mjs';
+import * as typeParser from './type-parser.mjs';
+
+const { highlight, getLanguage } = highlightJs;
+
+const docPath = new URL('../../doc/', import.meta.url);
 
 // Add class attributes to index navigation links.
 function navClasses() {
@@ -50,20 +48,44 @@ function navClasses() {
   };
 }
 
-const gtocPath = path.join(docPath, 'api', 'index.md');
-const gtocMD = fs.readFileSync(gtocPath, 'utf8').replace(/^<!--.*?-->/gms, '');
+const gtocPath = new URL('./api/index.md', docPath);
+const gtocMD = fs.readFileSync(gtocPath, 'utf8')
+  .replace(/\(([^#?]+?)\.md\)/ig, (_, filename) => `(${filename}.html)`)
+  .replace(/^<!--.*?-->/gms, '');
 const gtocHTML = unified()
   .use(markdown)
+  .use(gfm)
   .use(remark2rehype, { allowDangerousHtml: true })
   .use(raw)
   .use(navClasses)
   .use(htmlStringify)
   .processSync(gtocMD).toString();
 
-const templatePath = path.join(docPath, 'template.html');
+const templatePath = new URL('./template.html', docPath);
 const template = fs.readFileSync(templatePath, 'utf8');
 
-function toHTML({ input, content, filename, nodeVersion, versions }) {
+function processContent(content) {
+  content = content.toString();
+  // Increment header tag levels to avoid multiple h1 tags in a doc.
+  // This means we can't already have an <h6>.
+  if (content.includes('<h6>')) {
+    throw new Error('Cannot increment a level 6 header');
+  }
+  // `++level` to convert the string to a number and increment it.
+  content = content.replace(/(?<=<\/?h)[1-5](?=[^<>]*>)/g, (level) => ++level);
+  // Wrap h3 tags in section tags.
+  let firstTime = true;
+  return content
+    .replace(/<h3/g, (heading) => {
+      if (firstTime) {
+        firstTime = false;
+        return '<section>' + heading;
+      }
+      return '</section><section>' + heading;
+    }) + (firstTime ? '' : '</section>');
+}
+
+export function toHTML({ input, content, filename, nodeVersion, versions }) {
   filename = path.basename(filename, '.md');
 
   const id = filename.replace(/\W+/g, '-');
@@ -76,7 +98,7 @@ function toHTML({ input, content, filename, nodeVersion, versions }) {
                      .replace('__GTOC__', gtocHTML.replace(
                        `class="nav-${id}"`, `class="nav-${id} active"`))
                      .replace('__EDIT_ON_GITHUB__', editOnGitHub(filename))
-                     .replace('__CONTENT__', content.toString());
+                     .replace('__CONTENT__', processContent(content));
 
   const docCreated = input.match(
     /<!--\s*introduced_in\s*=\s*v([0-9]+)\.([0-9]+)\.[0-9]+\s*-->/);
@@ -91,9 +113,15 @@ function toHTML({ input, content, filename, nodeVersion, versions }) {
 }
 
 // Set the section name based on the first header.  Default to 'Index'.
-function firstHeader() {
+export function firstHeader() {
   return (tree, file) => {
-    const heading = find(tree, { type: 'heading' });
+    let heading;
+    visit(tree, (node) => {
+      if (node.type === 'heading') {
+        heading = node;
+        return false;
+      }
+    });
 
     if (heading && heading.children.length) {
       const recursiveTextContent = (node) =>
@@ -107,7 +135,7 @@ function firstHeader() {
 
 // Handle general body-text replacements.
 // For example, link man page references to the actual page.
-function preprocessText({ nodeVersion }) {
+export function preprocessText({ nodeVersion }) {
   return (tree) => {
     visit(tree, null, (node) => {
       if (common.isSourceLink(node.value)) {
@@ -139,12 +167,10 @@ function linkManPages(text) {
       const displayAs = `<code>${name}(${number}${optionalCharacter})</code>`;
 
       if (BSD_ONLY_SYSCALLS.has(name)) {
-        return `${beginning}<a href="https://www.freebsd.org/cgi/man.cgi` +
-          `?query=${name}&sektion=${number}">${displayAs}</a>`;
+        return `${beginning}<a href="https://www.freebsd.org/cgi/man.cgi?query=${name}&sektion=${number}">${displayAs}</a>`;
       }
 
-      return `${beginning}<a href="http://man7.org/linux/man-pages/man${number}` +
-        `/${name}.${number}${optionalCharacter}.html">${displayAs}</a>`;
+      return `${beginning}<a href="http://man7.org/linux/man-pages/man${number}/${name}.${number}${optionalCharacter}.html">${displayAs}</a>`;
     });
 }
 
@@ -166,32 +192,60 @@ function linkJsTypeDocs(text) {
   return parts.join('`');
 }
 
+const isJSFlavorSnippet = (node) => node.lang === 'cjs' || node.lang === 'mjs';
+
 // Preprocess headers, stability blockquotes, and YAML blocks.
-function preprocessElements({ filename }) {
+export function preprocessElements({ filename }) {
   return (tree) => {
     const STABILITY_RE = /(.*:)\s*(\d)([\s\S]*)/;
     let headingIndex = -1;
     let heading = null;
 
-    visit(tree, null, (node, index) => {
+    visit(tree, null, (node, index, parent) => {
       if (node.type === 'heading') {
         headingIndex = index;
         heading = node;
       } else if (node.type === 'code') {
         if (!node.lang) {
           console.warn(
-            `No language set in ${filename}, ` +
-            `line ${node.position.start.line}`);
+            `No language set in ${filename}, line ${node.position.start.line}`
+          );
         }
-        const language = (node.lang || '').split(' ')[0];
-        const highlighted = getLanguage(language) ?
-          highlight(language, node.value).value :
-          node.value;
+        const className = isJSFlavorSnippet(node) ?
+          `language-js ${node.lang}` :
+          `language-${node.lang}`;
+        const highlighted =
+          `<code class='${className}'>${(getLanguage(node.lang || '') ? highlight(node.value, { language: node.lang }) : node).value}</code>`;
         node.type = 'html';
-        node.value = '<pre>' +
-          `<code class = 'language-${node.lang}'>` +
-          highlighted +
-          '</code></pre>';
+
+        if (isJSFlavorSnippet(node)) {
+          const previousNode = parent.children[index - 1] || {};
+          const nextNode = parent.children[index + 1] || {};
+
+          if (!isJSFlavorSnippet(previousNode) &&
+              isJSFlavorSnippet(nextNode) &&
+              nextNode.lang !== node.lang) {
+            // Saving the highlight code as value to be added in the next node.
+            node.value = highlighted;
+          } else if (isJSFlavorSnippet(previousNode)) {
+            node.value = '<pre>' +
+              '<input class="js-flavor-selector" type="checkbox"' +
+              // If CJS comes in second, ESM should display by default.
+              (node.lang === 'cjs' ? ' checked' : '') +
+              ' aria-label="Show modern ES modules syntax">' +
+              previousNode.value +
+              highlighted +
+              '</pre>';
+            node.lang = null;
+            previousNode.value = '';
+            previousNode.lang = null;
+          } else {
+            // Isolated JS snippet, no need to add the checkbox.
+            node.value = `<pre>${highlighted}</pre>`;
+          }
+        } else {
+          node.value = `<pre>${highlighted}</pre>`;
+        }
       } else if (node.type === 'html' && common.isYAMLBlock(node.value)) {
         node.value = parseYAML(node.value);
 
@@ -204,9 +258,9 @@ function preprocessElements({ filename }) {
           const [, prefix, number, explication] =
             text.value.match(STABILITY_RE);
 
-          const isStabilityIndex =
-            index - 2 === headingIndex || // General.
-            index - 3 === headingIndex;   // With api_metadata block.
+          // Stability indices are never more than 3 nodes away from their
+          // heading.
+          const isStabilityIndex = index - headingIndex <= 3;
 
           if (heading && isStabilityIndex) {
             heading.stability = number;
@@ -216,7 +270,7 @@ function preprocessElements({ filename }) {
 
           // Do not link to the section we are already in.
           const noLinking = filename.includes('documentation') &&
-            heading !== null && heading.children[0].value === 'Stability Index';
+            heading !== null && heading.children[0].value === 'Stability index';
 
           // Collapse blockquote and paragraph into a single node
           node.type = 'paragraph';
@@ -281,6 +335,7 @@ function parseYAML(text) {
     meta.changes.forEach((change) => {
       const description = unified()
         .use(markdown)
+        .use(gfm)
         .use(remark2rehype, { allowDangerousHtml: true })
         .use(raw)
         .use(htmlStringify)
@@ -294,8 +349,7 @@ function parseYAML(text) {
 
     result += '</table>\n</details>\n';
   } else {
-    result += `${added.description}${deprecated.description}` +
-              `${removed.description}\n`;
+    result += `${added.description}${deprecated.description}${removed.description}\n`;
   }
 
   if (meta.napiVersion) {
@@ -323,7 +377,8 @@ function versionSort(a, b) {
   return +b.match(numberRe)[0] - +a.match(numberRe)[0];
 }
 
-function buildToc({ filename, apilinks }) {
+const DEPRECATION_HEADING_PATTERN = /^DEP\d+:/;
+export function buildToc({ filename, apilinks }) {
   return (tree, file) => {
     const idCounters = Object.create(null);
     let toc = '';
@@ -345,17 +400,26 @@ function buildToc({ filename, apilinks }) {
         node.position.end.offset).trim();
       const id = getId(`${realFilename}_${headingText}`, idCounters);
 
+      const isDeprecationHeading =
+        DEPRECATION_HEADING_PATTERN.test(headingText);
+      if (isDeprecationHeading) {
+        if (!node.data) node.data = {};
+        if (!node.data.hProperties) node.data.hProperties = {};
+        node.data.hProperties.id =
+          headingText.substring(0, headingText.indexOf(':'));
+      }
+
       const hasStability = node.stability !== undefined;
       toc += ' '.repeat((depth - 1) * 2) +
         (hasStability ? `* <span class="stability_${node.stability}">` : '* ') +
-        `<a href="#${id}">${headingText}</a>${hasStability ? '</span>' : ''}\n`;
+        `<a href="#${isDeprecationHeading ? node.data.hProperties.id : id}">${headingText}</a>${hasStability ? '</span>' : ''}\n`;
 
       let anchor =
          `<span><a class="mark" href="#${id}" id="${id}">#</a></span>`;
 
       if (realFilename === 'errors' && headingText.startsWith('ERR_')) {
-        anchor += `<span><a class="mark" href="#${headingText}" ` +
-                  `id="${headingText}">#</a></span>`;
+        anchor +=
+          `<span><a class="mark" href="#${headingText}" id="${headingText}">#</a></span>`;
       }
 
       const api = headingText.replace(/^.*:\s+/, '').replace(/\(.*/, '');
@@ -366,12 +430,19 @@ function buildToc({ filename, apilinks }) {
       node.children.push({ type: 'html', value: anchor });
     });
 
-    file.toc = unified()
-      .use(markdown)
-      .use(remark2rehype, { allowDangerousHtml: true })
-      .use(raw)
-      .use(htmlStringify)
-      .processSync(toc).toString();
+    if (toc !== '') {
+      file.toc = '<details id="toc" open><summary>Table of contents</summary>' +
+        unified()
+          .use(markdown)
+          .use(gfm)
+          .use(remark2rehype, { allowDangerousHtml: true })
+          .use(raw)
+          .use(htmlStringify)
+          .processSync(toc).toString() +
+        '</details>';
+    } else {
+      file.toc = '<!-- TOC -->';
+    }
   };
 }
 
@@ -398,8 +469,7 @@ function altDocs(filename, docCreated, versions) {
     `${host}/docs/latest-v${versionNum}/api/${filename}.html`;
 
   const wrapInListItem = (version) =>
-    `<li><a href="${getHref(version.num)}">${version.num}` +
-    `${version.lts ? ' <b>LTS</b>' : ''}</a></li>`;
+    `<li><a href="${getHref(version.num)}">${version.num}${version.lts ? ' <b>LTS</b>' : ''}</a></li>`;
 
   function isDocInVersion(version) {
     const [versionMajor, versionMinor] = version.num.split('.').map(Number);
@@ -419,8 +489,6 @@ function altDocs(filename, docCreated, versions) {
   ` : '';
 }
 
-// eslint-disable-next-line max-len
-const githubLogo = '<span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>';
 function editOnGitHub(filename) {
-  return `<li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/${filename}.md">${githubLogo}Edit on GitHub</a></li>`;
+  return `<li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/${filename}.md">Edit on GitHub</a></li>`;
 }
diff --git a/tools/doc/json.js b/tools/doc/json.mjs
similarity index 98%
rename from tools/doc/json.js
rename to tools/doc/json.mjs
index 5677fd1ce8b664c71eae7771b6b032c58f891439..318be8fd2ffb4efa63def84dc1506407a549165f 100644
--- a/tools/doc/json.js
+++ b/tools/doc/json.mjs
@@ -19,18 +19,15 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-'use strict';
+import html from 'remark-html';
+import unified from 'unified';
+import { selectAll } from 'unist-util-select';
 
-const unified = require('unified');
-const common = require('./common.js');
-const html = require('remark-html');
-const { selectAll } = require('unist-util-select');
-
-module.exports = { jsonAPI };
+import * as common from './common.mjs';
 
 // Unified processor: input is https://github.com/syntax-tree/mdast,
 // output is: https://gist.github.com/1777387.
-function jsonAPI({ filename }) {
+export function jsonAPI({ filename }) {
   return (tree, file) => {
 
     const exampleHeading = /^example/i;
@@ -458,7 +455,6 @@ const callWithParams = r`\([^)]*\)`;
 
 const maybeExtends = `(?: +extends +${maybeAncestors}${classId})?`;
 
-/* eslint-disable max-len */
 const headingExpressions = [
   { type: 'event', re: RegExp(
     `${eventPrefix}${maybeBacktick}${maybeQuote}(${notQuotes})${maybeQuote}${maybeBacktick}$`, 'i') },
@@ -478,7 +474,6 @@ const headingExpressions = [
   { type: 'property', re: RegExp(
     `^${maybeClassPropertyPrefix}${maybeBacktick}${ancestors}(${id})${maybeBacktick}$`, 'i') },
 ];
-/* eslint-enable max-len */
 
 function newSection(header, file) {
   const text = textJoin(header.children, file);
diff --git a/tools/doc/markdown.js b/tools/doc/markdown.mjs
similarity index 42%
rename from tools/doc/markdown.js
rename to tools/doc/markdown.mjs
index 97feadbf9990bb92484c201b9274885b096025c4..7c9ebfbf7471e4bcb9474f65f0e10a20e731c2e6 100644
--- a/tools/doc/markdown.js
+++ b/tools/doc/markdown.mjs
@@ -1,15 +1,19 @@
-'use strict';
+import { visit } from 'unist-util-visit';
 
-const visit = require('unist-util-visit');
+export const referenceToLocalMdFile = /^(?![+a-z]+:)([^#?]+)\.md(#.+)?$/i;
 
-module.exports = {
-  replaceLinks
-};
-
-function replaceLinks({ filename, linksMapper }) {
+export function replaceLinks({ filename, linksMapper }) {
   return (tree) => {
     const fileHtmlUrls = linksMapper[filename];
 
+    visit(tree, (node) => {
+      if (node.url) {
+        node.url = node.url.replace(
+          referenceToLocalMdFile,
+          (_, filename, hash) => `${filename}.html${hash || ''}`
+        );
+      }
+    });
     visit(tree, 'definition', (node) => {
       const htmlUrl = fileHtmlUrls && fileHtmlUrls[node.identifier];
 
diff --git a/tools/doc/package-lock.json b/tools/doc/package-lock.json
index 36514e5989c7b7fd5eee4479bb84247b402e64d2..7d60e99f088c6cc8e74fb4f2dfa6c4c19e78886d 100644
--- a/tools/doc/package-lock.json
+++ b/tools/doc/package-lock.json
@@ -1,9 +1,1346 @@
 {
   "name": "node-doc-generator",
   "version": "0.0.0",
-  "lockfileVersion": 1,
+  "lockfileVersion": 2,
   "requires": true,
+  "packages": {
+    "": {
+      "name": "node-doc-generator",
+      "version": "0.0.0",
+      "bin": {
+        "node-doc-generator": "generate.js"
+      },
+      "devDependencies": {
+        "highlight.js": "11.0.1",
+        "js-yaml": "4.1.0",
+        "rehype-raw": "5.1.0",
+        "rehype-stringify": "8.0.0",
+        "remark-frontmatter": "^3.0.0",
+        "remark-gfm": "^1.0.0",
+        "remark-html": "13.0.1",
+        "remark-parse": "^9.0.0",
+        "remark-rehype": "8.1.0",
+        "to-vfile": "7.1.0",
+        "unified": "9.2.1",
+        "unist-util-select": "4.0.0",
+        "unist-util-visit": "3.1.0"
+      },
+      "engines": {
+        "node": ">=14.8.0"
+      }
+    },
+    "node_modules/@types/hast": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.1.tgz",
+      "integrity": "sha512-viwwrB+6xGzw+G1eWpF9geV3fnsDgXqHG+cqgiHrvQfDUW5hzhCyV7Sy3UJxhfRFBsgky2SSW33qi/YrIkjX5Q==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/mdast": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.3.tgz",
+      "integrity": "sha512-SXPBMnFVQg1s00dlMCc/jCdvPqdE4mXaMMCeRlxLDmTAEoegHT53xKtkDnzDTOcmMHUfcjyf36/YYZ6SxRdnsw==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/parse5": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/@types/parse5/-/parse5-5.0.3.tgz",
+      "integrity": "sha512-kUNnecmtkunAoQ3CnjmMkzNU/gtxG8guhi+Fk2U/kOpIKjIMKnXGp4IJCgQJrXSgMsWYimYG4TGjz/UzbGEBTw==",
+      "dev": true
+    },
+    "node_modules/@types/unist": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.3.tgz",
+      "integrity": "sha512-FvUupuM3rlRsRtCN+fDudtmytGO6iHJuuRKS1Ss0pG5z8oX0diNEw94UEL7hgDbpN94rgaK5R7sWm6RrSkZuAQ==",
+      "dev": true
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true
+    },
+    "node_modules/bail": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-1.0.5.tgz",
+      "integrity": "sha512-xFbRxM1tahm08yHBP16MMjVUAvDaBMD38zsM9EMAUN61omwLmKlOpB/Zku5QkjZ8TZ4vn53pj+t518cH0S03RQ==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/boolbase": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
+      "integrity": "sha1-aN/1++YMUes3cl6p4+0xDcwed24=",
+      "dev": true
+    },
+    "node_modules/ccount": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-1.1.0.tgz",
+      "integrity": "sha512-vlNK021QdI7PNeiUh/lKkC/mNHHfV0m/Ad5JoI0TYtlBnJAslM/JIkm/tGC88bkLIwO6OQ5uV6ztS6kVAtCDlg==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-1.2.4.tgz",
+      "integrity": "sha512-iBMyeEHxfVnIakwOuDXpVkc54HijNgCyQB2w0VfGQThle6NXn50zU6V/u+LDhxHcDUPojn6Kpga3PTAD8W1bQw==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-html4": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-1.1.4.tgz",
+      "integrity": "sha512-HRcDxZuZqMx3/a+qrzxdBKBPUpxWEq9xw2OPZ3a/174ihfrQKVsFhqtthBInFy1zZ9GgZyFXOatNujm8M+El3g==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-1.1.4.tgz",
+      "integrity": "sha512-3Xnr+7ZFS1uxeiUDvV02wQ+QDbc55o97tIV5zHScSPJpcLm/r0DFPcoY3tYRp+VZukxuMeKgXYmsXQHO05zQeA==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-reference-invalid": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-1.1.4.tgz",
+      "integrity": "sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/comma-separated-tokens": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz",
+      "integrity": "sha512-GHuDRO12Sypu2cV70d1dkA2EUmXHgntrzbpvOB+Qy+49ypNfGgFQIC2fhhXbnyrJRynDCAARsT7Ou0M6hirpfw==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/css-selector-parser": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/css-selector-parser/-/css-selector-parser-1.4.1.tgz",
+      "integrity": "sha512-HYPSb7y/Z7BNDCOrakL4raGO2zltZkbeXyAd6Tg9obzix6QhzxCotdBl6VT0Dv4vZfJGVz3WL/xaEI9Ly3ul0g==",
+      "dev": true
+    },
+    "node_modules/debug": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+      "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+      "dev": true,
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "dev": true
+    },
+    "node_modules/fault": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/fault/-/fault-1.0.4.tgz",
+      "integrity": "sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==",
+      "dev": true,
+      "dependencies": {
+        "format": "^0.2.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/format": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz",
+      "integrity": "sha1-1hcBB+nv3E7TDJ3DkBbflCtctYs=",
+      "dev": true,
+      "engines": {
+        "node": ">=0.4.x"
+      }
+    },
+    "node_modules/hast-to-hyperscript": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/hast-to-hyperscript/-/hast-to-hyperscript-9.0.1.tgz",
+      "integrity": "sha512-zQgLKqF+O2F72S1aa4y2ivxzSlko3MAvxkwG8ehGmNiqd98BIN3JM1rAJPmplEyLmGLO2QZYJtIneOSZ2YbJuA==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.3",
+        "comma-separated-tokens": "^1.0.0",
+        "property-information": "^5.3.0",
+        "space-separated-tokens": "^1.0.0",
+        "style-to-object": "^0.3.0",
+        "unist-util-is": "^4.0.0",
+        "web-namespaces": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-from-parse5": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-6.0.1.tgz",
+      "integrity": "sha512-jeJUWiN5pSxW12Rh01smtVkZgZr33wBokLzKLwinYOUfSzm1Nl/c3GUGebDyOKjdsRgMvoVbV0VpAcpjF4NrJA==",
+      "dev": true,
+      "dependencies": {
+        "@types/parse5": "^5.0.0",
+        "hastscript": "^6.0.0",
+        "property-information": "^5.0.0",
+        "vfile": "^4.0.0",
+        "vfile-location": "^3.2.0",
+        "web-namespaces": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-is-element": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-1.1.0.tgz",
+      "integrity": "sha512-oUmNua0bFbdrD/ELDSSEadRVtWZOf3iF6Lbv81naqsIV99RnSCieTbWuWCY8BAeEfKJTKl0gRdokv+dELutHGQ==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-parse-selector": {
+      "version": "2.2.5",
+      "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-2.2.5.tgz",
+      "integrity": "sha512-7j6mrk/qqkSehsM92wQjdIgWM2/BW61u/53G6xmC8i1OmEdKLHbk419QKQUjz6LglWsfqoiHmyMRkP1BGjecNQ==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-raw": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-6.1.0.tgz",
+      "integrity": "sha512-5FoZLDHBpka20OlZZ4I/+RBw5piVQ8iI1doEvffQhx5CbCyTtP8UCq8Tw6NmTAMtXgsQxmhW7Ly8OdFre5/YMQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "hast-util-from-parse5": "^6.0.0",
+        "hast-util-to-parse5": "^6.0.0",
+        "html-void-elements": "^1.0.0",
+        "parse5": "^6.0.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^2.0.0",
+        "vfile": "^4.0.0",
+        "web-namespaces": "^1.0.0",
+        "xtend": "^4.0.0",
+        "zwitch": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-raw/node_modules/unist-util-visit": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
+      "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^4.0.0",
+        "unist-util-visit-parents": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-sanitize": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-3.0.2.tgz",
+      "integrity": "sha512-+2I0x2ZCAyiZOO/sb4yNLFmdwPBnyJ4PBkVTUMKMqBwYNA+lXSgOmoRXlJFazoyid9QPogRRKgKhVEodv181sA==",
+      "dev": true,
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-to-html": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-7.1.3.tgz",
+      "integrity": "sha512-yk2+1p3EJTEE9ZEUkgHsUSVhIpCsL/bvT8E5GzmWc+N1Po5gBw+0F8bo7dpxXR0nu0bQVxVZGX2lBGF21CmeDw==",
+      "dev": true,
+      "dependencies": {
+        "ccount": "^1.0.0",
+        "comma-separated-tokens": "^1.0.0",
+        "hast-util-is-element": "^1.0.0",
+        "hast-util-whitespace": "^1.0.0",
+        "html-void-elements": "^1.0.0",
+        "property-information": "^5.0.0",
+        "space-separated-tokens": "^1.0.0",
+        "stringify-entities": "^3.0.1",
+        "unist-util-is": "^4.0.0",
+        "xtend": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-to-parse5": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-6.0.0.tgz",
+      "integrity": "sha512-Lu5m6Lgm/fWuz8eWnrKezHtVY83JeRGaNQ2kn9aJgqaxvVkFCZQBEhgodZUDUvoodgyROHDb3r5IxAEdl6suJQ==",
+      "dev": true,
+      "dependencies": {
+        "hast-to-hyperscript": "^9.0.0",
+        "property-information": "^5.0.0",
+        "web-namespaces": "^1.0.0",
+        "xtend": "^4.0.0",
+        "zwitch": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-1.0.4.tgz",
+      "integrity": "sha512-I5GTdSfhYfAPNztx2xJRQpG8cuDSNt599/7YUn7Gx/WxNMsG+a835k97TDkFgk123cwjfwINaZknkKkphx/f2A==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hastscript": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-6.0.0.tgz",
+      "integrity": "sha512-nDM6bvd7lIqDUiYEiu5Sl/+6ReP0BMk/2f4U/Rooccxkj0P5nm+acM5PrGJ/t5I8qPGiqZSE6hVAwZEdZIvP4w==",
+      "dev": true,
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "comma-separated-tokens": "^1.0.0",
+        "hast-util-parse-selector": "^2.0.0",
+        "property-information": "^5.0.0",
+        "space-separated-tokens": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/highlight.js": {
+      "version": "11.0.1",
+      "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-11.0.1.tgz",
+      "integrity": "sha512-EqYpWyTF2s8nMfttfBA2yLKPNoZCO33pLS4MnbXQ4hECf1TKujCt1Kq7QAdrio7roL4+CqsfjqwYj4tYgq0pJQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/html-void-elements": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-1.0.5.tgz",
+      "integrity": "sha512-uE/TxKuyNIcx44cIWnjr/rfIATDH7ZaOMmstu0CwhFG1Dunhlp4OC6/NMbhiwoq5BpW0ubi303qnEk/PZj614w==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/inline-style-parser": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.1.1.tgz",
+      "integrity": "sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==",
+      "dev": true
+    },
+    "node_modules/is-alphabetical": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-1.0.4.tgz",
+      "integrity": "sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-alphanumerical": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz",
+      "integrity": "sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A==",
+      "dev": true,
+      "dependencies": {
+        "is-alphabetical": "^1.0.0",
+        "is-decimal": "^1.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-buffer": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz",
+      "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/is-decimal": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.4.tgz",
+      "integrity": "sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-hexadecimal": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz",
+      "integrity": "sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-plain-obj": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
+      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dev": true,
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/longest-streak": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-2.0.4.tgz",
+      "integrity": "sha512-vM6rUVCVUJJt33bnmHiZEvr7wPT78ztX7rojL+LW51bHtLh6HTjx84LA5W4+oa6aKEJA7jJu5LR6vQRBpA5DVg==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/markdown-table": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz",
+      "integrity": "sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==",
+      "dev": true,
+      "dependencies": {
+        "repeat-string": "^1.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/mdast-util-definitions": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-4.0.0.tgz",
+      "integrity": "sha512-k8AJ6aNnUkB7IE+5azR9h81O5EQ/cTDXtWdMq9Kk5KcEW/8ritU5CeLg/9HhOC++nALHBlaogJ5jz0Ybk3kPMQ==",
+      "dev": true,
+      "dependencies": {
+        "unist-util-visit": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-definitions/node_modules/unist-util-visit": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
+      "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^4.0.0",
+        "unist-util-visit-parents": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-find-and-replace": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-1.1.1.tgz",
+      "integrity": "sha512-9cKl33Y21lyckGzpSmEQnIDjEfeeWelN5s1kUW1LwdB0Fkuq2u+4GdqcGEygYxJE8GVqCl0741bYXHgamfWAZA==",
+      "dev": true,
+      "dependencies": {
+        "escape-string-regexp": "^4.0.0",
+        "unist-util-is": "^4.0.0",
+        "unist-util-visit-parents": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-from-markdown": {
+      "version": "0.8.5",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-0.8.5.tgz",
+      "integrity": "sha512-2hkTXtYYnr+NubD/g6KGBS/0mFmBcifAsI0yIWRiRo0PjVs6SSOSOdtzbp6kSGnShDN6G5aWZpKQ2lWRy27mWQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-string": "^2.0.0",
+        "micromark": "~2.11.0",
+        "parse-entities": "^2.0.0",
+        "unist-util-stringify-position": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-frontmatter": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-frontmatter/-/mdast-util-frontmatter-0.2.0.tgz",
+      "integrity": "sha512-FHKL4w4S5fdt1KjJCwB0178WJ0evnyyQr5kXTM3wrOVpytD0hrkvd+AOOjU9Td8onOejCkmZ+HQRT3CZ3coHHQ==",
+      "dev": true,
+      "dependencies": {
+        "micromark-extension-frontmatter": "^0.2.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-0.1.2.tgz",
+      "integrity": "sha512-NNkhDx/qYcuOWB7xHUGWZYVXvjPFFd6afg6/e2g+SV4r9q5XUcCbV4Wfa3DLYIiD+xAEZc6K4MGaE/m0KDcPwQ==",
+      "dev": true,
+      "dependencies": {
+        "mdast-util-gfm-autolink-literal": "^0.1.0",
+        "mdast-util-gfm-strikethrough": "^0.2.0",
+        "mdast-util-gfm-table": "^0.1.0",
+        "mdast-util-gfm-task-list-item": "^0.1.0",
+        "mdast-util-to-markdown": "^0.6.1"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-autolink-literal": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-0.1.3.tgz",
+      "integrity": "sha512-GjmLjWrXg1wqMIO9+ZsRik/s7PLwTaeCHVB7vRxUwLntZc8mzmTsLVr6HW1yLokcnhfURsn5zmSVdi3/xWWu1A==",
+      "dev": true,
+      "dependencies": {
+        "ccount": "^1.0.0",
+        "mdast-util-find-and-replace": "^1.1.0",
+        "micromark": "^2.11.3"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-strikethrough": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-0.2.3.tgz",
+      "integrity": "sha512-5OQLXpt6qdbttcDG/UxYY7Yjj3e8P7X16LzvpX8pIQPYJ/C2Z1qFGMmcw+1PZMUM3Z8wt8NRfYTvCni93mgsgA==",
+      "dev": true,
+      "dependencies": {
+        "mdast-util-to-markdown": "^0.6.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-table": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-0.1.6.tgz",
+      "integrity": "sha512-j4yDxQ66AJSBwGkbpFEp9uG/LS1tZV3P33fN1gkyRB2LoRL+RR3f76m0HPHaby6F4Z5xr9Fv1URmATlRRUIpRQ==",
+      "dev": true,
+      "dependencies": {
+        "markdown-table": "^2.0.0",
+        "mdast-util-to-markdown": "~0.6.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-task-list-item": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-0.1.6.tgz",
+      "integrity": "sha512-/d51FFIfPsSmCIRNp7E6pozM9z1GYPIkSy1urQ8s/o4TC22BZ7DqfHFWiqBD23bc7J3vV1Fc9O4QIHBlfuit8A==",
+      "dev": true,
+      "dependencies": {
+        "mdast-util-to-markdown": "~0.6.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-10.2.0.tgz",
+      "integrity": "sha512-JoPBfJ3gBnHZ18icCwHR50orC9kNH81tiR1gs01D8Q5YpV6adHNO9nKNuFBCJQ941/32PT1a63UF/DitmS3amQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "mdast-util-definitions": "^4.0.0",
+        "mdurl": "^1.0.0",
+        "unist-builder": "^2.0.0",
+        "unist-util-generated": "^1.0.0",
+        "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-hast/node_modules/unist-util-visit": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
+      "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^4.0.0",
+        "unist-util-visit-parents": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-markdown": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-0.6.5.tgz",
+      "integrity": "sha512-XeV9sDE7ZlOQvs45C9UKMtfTcctcaj/pGwH8YLbMHoMOXNNCn2LsqVQOqrF1+/NU8lKDAqozme9SCXWyo9oAcQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "longest-streak": "^2.0.0",
+        "mdast-util-to-string": "^2.0.0",
+        "parse-entities": "^2.0.0",
+        "repeat-string": "^1.0.0",
+        "zwitch": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-string": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-2.0.0.tgz",
+      "integrity": "sha512-AW4DRS3QbBayY/jJmD8437V1Gombjf8RSOUCMFBuo5iHi58AGEgVCKQ+ezHkZZDpAQS75hcBMpLqjpJTjtUL7w==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdurl": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz",
+      "integrity": "sha1-/oWy7HWlkDfyrf7BAP1sYBdhFS4=",
+      "dev": true
+    },
+    "node_modules/micromark": {
+      "version": "2.11.4",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-2.11.4.tgz",
+      "integrity": "sha512-+WoovN/ppKolQOFIAajxi7Lu9kInbPxFuTBVEavFcL8eAfVstoc5MocPmqBeAdBOJV00uaVjegzH4+MA0DN/uA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "debug": "^4.0.0",
+        "parse-entities": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-extension-frontmatter": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/micromark-extension-frontmatter/-/micromark-extension-frontmatter-0.2.2.tgz",
+      "integrity": "sha512-q6nPLFCMTLtfsctAuS0Xh4vaolxSFUWUWR6PZSrXXiRy+SANGllpcqdXFv2z07l0Xz/6Hl40hK0ffNCJPH2n1A==",
+      "dev": true,
+      "dependencies": {
+        "fault": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm": {
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-0.3.3.tgz",
+      "integrity": "sha512-oVN4zv5/tAIA+l3GbMi7lWeYpJ14oQyJ3uEim20ktYFAcfX1x3LNlFGGlmrZHt7u9YlKExmyJdDGaTt6cMSR/A==",
+      "dev": true,
+      "dependencies": {
+        "micromark": "~2.11.0",
+        "micromark-extension-gfm-autolink-literal": "~0.5.0",
+        "micromark-extension-gfm-strikethrough": "~0.6.5",
+        "micromark-extension-gfm-table": "~0.4.0",
+        "micromark-extension-gfm-tagfilter": "~0.3.0",
+        "micromark-extension-gfm-task-list-item": "~0.3.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-autolink-literal": {
+      "version": "0.5.7",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-0.5.7.tgz",
+      "integrity": "sha512-ePiDGH0/lhcngCe8FtH4ARFoxKTUelMp4L7Gg2pujYD5CSMb9PbblnyL+AAMud/SNMyusbS2XDSiPIRcQoNFAw==",
+      "dev": true,
+      "dependencies": {
+        "micromark": "~2.11.3"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-strikethrough": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-0.6.5.tgz",
+      "integrity": "sha512-PpOKlgokpQRwUesRwWEp+fHjGGkZEejj83k9gU5iXCbDG+XBA92BqnRKYJdfqfkrRcZRgGuPuXb7DaK/DmxOhw==",
+      "dev": true,
+      "dependencies": {
+        "micromark": "~2.11.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-table": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-0.4.3.tgz",
+      "integrity": "sha512-hVGvESPq0fk6ALWtomcwmgLvH8ZSVpcPjzi0AjPclB9FsVRgMtGZkUcpE0zgjOCFAznKepF4z3hX8z6e3HODdA==",
+      "dev": true,
+      "dependencies": {
+        "micromark": "~2.11.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-tagfilter": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-0.3.0.tgz",
+      "integrity": "sha512-9GU0xBatryXifL//FJH+tAZ6i240xQuFrSL7mYi8f4oZSbc+NvXjkrHemeYP0+L4ZUT+Ptz3b95zhUZnMtoi/Q==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-task-list-item": {
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-0.3.3.tgz",
+      "integrity": "sha512-0zvM5iSLKrc/NQl84pZSjGo66aTGd57C1idmlWmE87lkMcXrTxg1uXa/nXomxJytoje9trP0NDLvw4bZ/Z/XCQ==",
+      "dev": true,
+      "dependencies": {
+        "micromark": "~2.11.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "dev": true
+    },
+    "node_modules/nth-check": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.0.tgz",
+      "integrity": "sha512-i4sc/Kj8htBrAiH1viZ0TgU8Y5XqCaV/FziYK6TBczxmeKm3AEFWqqF3195yKudrarqy7Zu80Ra5dobFjn9X/Q==",
+      "dev": true,
+      "dependencies": {
+        "boolbase": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/nth-check?sponsor=1"
+      }
+    },
+    "node_modules/parse-entities": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-2.0.0.tgz",
+      "integrity": "sha512-kkywGpCcRYhqQIchaWqZ875wzpS/bMKhz5HnN3p7wveJTkTtyAB/AlnS0f8DFSqYW1T82t6yEAkEcB+A1I3MbQ==",
+      "dev": true,
+      "dependencies": {
+        "character-entities": "^1.0.0",
+        "character-entities-legacy": "^1.0.0",
+        "character-reference-invalid": "^1.0.0",
+        "is-alphanumerical": "^1.0.0",
+        "is-decimal": "^1.0.0",
+        "is-hexadecimal": "^1.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/parse5": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz",
+      "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==",
+      "dev": true
+    },
+    "node_modules/property-information": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-5.6.0.tgz",
+      "integrity": "sha512-YUHSPk+A30YPv+0Qf8i9Mbfe/C0hdPXk1s1jPVToV8pk8BQtpw10ct89Eo7OWkutrwqvT0eicAxlOg3dOAu8JA==",
+      "dev": true,
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/rehype-raw": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/rehype-raw/-/rehype-raw-5.1.0.tgz",
+      "integrity": "sha512-MDvHAb/5mUnif2R+0IPCYJU8WjHa9UzGtM/F4AVy5GixPlDZ1z3HacYy4xojDU+uBa+0X/3PIfyQI26/2ljJNA==",
+      "dev": true,
+      "dependencies": {
+        "hast-util-raw": "^6.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/rehype-stringify": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-8.0.0.tgz",
+      "integrity": "sha512-VkIs18G0pj2xklyllrPSvdShAV36Ff3yE5PUO9u36f6+2qJFnn22Z5gKwBOwgXviux4UC7K+/j13AnZfPICi/g==",
+      "dev": true,
+      "dependencies": {
+        "hast-util-to-html": "^7.1.1"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-frontmatter": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-frontmatter/-/remark-frontmatter-3.0.0.tgz",
+      "integrity": "sha512-mSuDd3svCHs+2PyO29h7iijIZx4plX0fheacJcAoYAASfgzgVIcXGYSq9GFyYocFLftQs8IOmmkgtOovs6d4oA==",
+      "dev": true,
+      "dependencies": {
+        "mdast-util-frontmatter": "^0.2.0",
+        "micromark-extension-frontmatter": "^0.2.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-gfm": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-1.0.0.tgz",
+      "integrity": "sha512-KfexHJCiqvrdBZVbQ6RopMZGwaXz6wFJEfByIuEwGf0arvITHjiKKZ1dpXujjH9KZdm1//XJQwgfnJ3lmXaDPA==",
+      "dev": true,
+      "dependencies": {
+        "mdast-util-gfm": "^0.1.0",
+        "micromark-extension-gfm": "^0.3.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-html": {
+      "version": "13.0.1",
+      "resolved": "https://registry.npmjs.org/remark-html/-/remark-html-13.0.1.tgz",
+      "integrity": "sha512-K5KQCXWVz+harnyC+UVM/J9eJWCgjYRqFeZoZf2NgP0iFbuuw/RgMZv3MA34b/OEpGnstl3oiOUtZzD3tJ+CBw==",
+      "dev": true,
+      "dependencies": {
+        "hast-util-sanitize": "^3.0.0",
+        "hast-util-to-html": "^7.0.0",
+        "mdast-util-to-hast": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-parse": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-9.0.0.tgz",
+      "integrity": "sha512-geKatMwSzEXKHuzBNU1z676sGcDcFoChMK38TgdHJNAYfFtsfHDQG7MoJAjs6sgYMqyLduCYWDIWZIxiPeafEw==",
+      "dev": true,
+      "dependencies": {
+        "mdast-util-from-markdown": "^0.8.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-rehype": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-8.1.0.tgz",
+      "integrity": "sha512-EbCu9kHgAxKmW1yEYjx3QafMyGY3q8noUbNUI5xyKbaFP89wbhDrKxyIQNukNYthzjNHZu6J7hwFg7hRm1svYA==",
+      "dev": true,
+      "dependencies": {
+        "mdast-util-to-hast": "^10.2.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/repeat-string": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
+      "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/space-separated-tokens": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-1.1.5.tgz",
+      "integrity": "sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/stringify-entities": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-3.1.0.tgz",
+      "integrity": "sha512-3FP+jGMmMV/ffZs86MoghGqAoqXAdxLrJP4GUdrDN1aIScYih5tuIO3eF4To5AJZ79KDZ8Fpdy7QJnK8SsL1Vg==",
+      "dev": true,
+      "dependencies": {
+        "character-entities-html4": "^1.0.0",
+        "character-entities-legacy": "^1.0.0",
+        "xtend": "^4.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/style-to-object": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-0.3.0.tgz",
+      "integrity": "sha512-CzFnRRXhzWIdItT3OmF8SQfWyahHhjq3HwcMNCNLn+N7klOOqPjMeG/4JSu77D7ypZdGvSzvkrbyeTMizz2VrA==",
+      "dev": true,
+      "dependencies": {
+        "inline-style-parser": "0.1.1"
+      }
+    },
+    "node_modules/to-vfile": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/to-vfile/-/to-vfile-7.1.0.tgz",
+      "integrity": "sha512-t1c42ASuWo39ddjh2R+hX5+kbDcc2CmbhaTSJkVavDYMjnFkpq0L4LeF+rcPoDdieGUsFaivSSkmwuFpYzhBZw==",
+      "dev": true,
+      "dependencies": {
+        "is-buffer": "^2.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/to-vfile/node_modules/unist-util-stringify-position": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.0.tgz",
+      "integrity": "sha512-SdfAl8fsDclywZpfMDTVDxA2V7LjtRDTOFd44wUJamgl6OlVngsqWjxvermMYf60elWHbxhuRCZml7AnuXCaSA==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/to-vfile/node_modules/vfile": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.0.1.tgz",
+      "integrity": "sha512-lbcf0k66x96Syy36HG+nIBFaSD/fAk589q4nETZTr0JW7eRRmrVo1vHwbD8NlHszUM5ICtFSWQ5xHC292hYZ/w==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "is-buffer": "^2.0.0",
+        "unist-util-stringify-position": "^3.0.0",
+        "vfile-message": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/to-vfile/node_modules/vfile-message": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.0.1.tgz",
+      "integrity": "sha512-gYmSHcZZUEtYpTmaWaFJwsuUD70/rTY4v09COp8TGtOkix6gGxb/a8iTQByIY9ciTk9GwAwIXd/J9OPfM4Bvaw==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-stringify-position": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/trough": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-1.0.5.tgz",
+      "integrity": "sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/unified": {
+      "version": "9.2.1",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-9.2.1.tgz",
+      "integrity": "sha512-juWjuI8Z4xFg8pJbnEZ41b5xjGUWGHqXALmBZ3FC3WX0PIx1CZBIIJ6mXbYMcf6Yw4Fi0rFUTA1cdz/BglbOhA==",
+      "dev": true,
+      "dependencies": {
+        "bail": "^1.0.0",
+        "extend": "^3.0.0",
+        "is-buffer": "^2.0.0",
+        "is-plain-obj": "^2.0.0",
+        "trough": "^1.0.0",
+        "vfile": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-builder": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/unist-builder/-/unist-builder-2.0.3.tgz",
+      "integrity": "sha512-f98yt5pnlMWlzP539tPc4grGMsFaQQlP/vM396b00jngsiINumNmsY8rkXjfoi1c6QaM8nQ3vaGDuoKWbe/1Uw==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-generated": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-1.1.6.tgz",
+      "integrity": "sha512-cln2Mm1/CZzN5ttGK7vkoGw+RZ8VcUH6BtGbq98DDtRGquAAOXig1mrBQYelOwMXYS8rK+vZDyyojSjp7JX+Lg==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.1.0.tgz",
+      "integrity": "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-3.1.0.tgz",
+      "integrity": "sha512-w+PkwCbYSFw8vpgWD0v7zRCl1FpY3fjDSQ3/N/wNd9Ffa4gPi8+4keqt99N3XW6F99t/mUzp2xAhNmfKWp95QA==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-select": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-select/-/unist-util-select-4.0.0.tgz",
+      "integrity": "sha512-UJsER0ubbBy8KR+5zZpcF/9/aApWOzjNqfseMjcw1h0wAUqbxAf56mMewspAqXtGKiwBylnYB+PbD/XqwcYrWg==",
+      "dev": true,
+      "dependencies": {
+        "css-selector-parser": "^1.0.0",
+        "nth-check": "^2.0.0",
+        "unist-util-is": "^5.0.0",
+        "zwitch": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-select/node_modules/unist-util-is": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.0.tgz",
+      "integrity": "sha512-pWspZ+AvTqYbC+xWeRmzGqbcY8Na08Eowlfs2xchWTYot8vBBAq+syrE/LWS0bw1D/JOu4lwzDbEb6Mz13tK+g==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-select/node_modules/zwitch": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.2.tgz",
+      "integrity": "sha512-JZxotl7SxAJH0j7dN4pxsTV6ZLXoLdGME+PsjkL/DaBrVryK9kTGq06GfKrwcSOqypP+fdXGoCHE36b99fWVoA==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.3.tgz",
+      "integrity": "sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.2"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-3.1.0.tgz",
+      "integrity": "sha512-Szoh+R/Ll68QWAyQyZZpQzZQm2UPbxibDvaY8Xc9SUtYgPsDzx5AWSk++UUt2hJuow8mvwR+rG+LQLw+KsuAKA==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.1.1.tgz",
+      "integrity": "sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit/node_modules/unist-util-is": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.0.tgz",
+      "integrity": "sha512-pWspZ+AvTqYbC+xWeRmzGqbcY8Na08Eowlfs2xchWTYot8vBBAq+syrE/LWS0bw1D/JOu4lwzDbEb6Mz13tK+g==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit/node_modules/unist-util-visit-parents": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz",
+      "integrity": "sha512-1xAFJXAKpnnJl8G7K5KgU7FY55y3GcLIXqkzUj5QF/QVP7biUm0K0O2oqVkYsdjzJKifYeWn9+o6piAK2hGSHw==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-4.2.1.tgz",
+      "integrity": "sha512-O6AE4OskCG5S1emQ/4gl8zK586RqA3srz3nfK/Viy0UPToBc5Trp9BVFb1u0CjsKrAWwnpr4ifM/KBXPWwJbCA==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "is-buffer": "^2.0.0",
+        "unist-util-stringify-position": "^2.0.0",
+        "vfile-message": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-location": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.2.0.tgz",
+      "integrity": "sha512-aLEIZKv/oxuCDZ8lkJGhuhztf/BW4M+iHdCwglA/eWc+vtuRFJj8EtgceYFX4LRjOhCAAiNHsKGssC6onJ+jbA==",
+      "dev": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-2.0.4.tgz",
+      "integrity": "sha512-DjssxRGkMvifUOJre00juHoP9DPWuzjxKuMDrhNbk2TdaYYBNMStsNhEOt3idrtI12VQYM/1+iM0KOzXi4pxwQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-stringify-position": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/web-namespaces": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-1.1.4.tgz",
+      "integrity": "sha512-wYxSGajtmoP4WxfejAPIr4l0fVh+jeMXZb08wNc0tMg6xsfZXj3cECqIK0G7ZAqUq0PP8WlMDtaOGVBTAWztNw==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/zwitch": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-1.0.5.tgz",
+      "integrity": "sha512-V50KMwwzqJV0NpZIZFwfOD5/lyny3WlSzRiXgA0G7VUnRlqttta1L6UQIHzd6EuBY/cHGfwTIck7w1yH6Q5zUw==",
+      "dev": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    }
+  },
   "dependencies": {
+    "@types/hast": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.1.tgz",
+      "integrity": "sha512-viwwrB+6xGzw+G1eWpF9geV3fnsDgXqHG+cqgiHrvQfDUW5hzhCyV7Sy3UJxhfRFBsgky2SSW33qi/YrIkjX5Q==",
+      "dev": true,
+      "requires": {
+        "@types/unist": "*"
+      }
+    },
     "@types/mdast": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.3.tgz",
@@ -13,6 +1350,12 @@
         "@types/unist": "*"
       }
     },
+    "@types/parse5": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/@types/parse5/-/parse5-5.0.3.tgz",
+      "integrity": "sha512-kUNnecmtkunAoQ3CnjmMkzNU/gtxG8guhi+Fk2U/kOpIKjIMKnXGp4IJCgQJrXSgMsWYimYG4TGjz/UzbGEBTw==",
+      "dev": true
+    },
     "@types/unist": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.3.tgz",
@@ -20,13 +1363,10 @@
       "dev": true
     },
     "argparse": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
-      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
-      "dev": true,
-      "requires": {
-        "sprintf-js": "~1.0.2"
-      }
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true
     },
     "bail": {
       "version": "1.0.5",
@@ -41,9 +1381,9 @@
       "dev": true
     },
     "ccount": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/ccount/-/ccount-1.0.5.tgz",
-      "integrity": "sha512-MOli1W+nfbPLlKEhInaxhRdp7KVLFxLN5ykwzHgLsLI3H3gs5jjFAK4Eoj3OzzcxCtumDaI8onoVDeQyWaNTkw==",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-1.1.0.tgz",
+      "integrity": "sha512-vlNK021QdI7PNeiUh/lKkC/mNHHfV0m/Ad5JoI0TYtlBnJAslM/JIkm/tGC88bkLIwO6OQ5uV6ztS6kVAtCDlg==",
       "dev": true
     },
     "character-entities": {
@@ -70,12 +1410,6 @@
       "integrity": "sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg==",
       "dev": true
     },
-    "collapse-white-space": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-1.0.6.tgz",
-      "integrity": "sha512-jEovNnrhMuqyCcjfEJA56v0Xq8SkIoPKDyaHahwo3POf4qcSXqMYuwNcOTzp74vTsR9Tn08z4MxWqAhcekogkQ==",
-      "dev": true
-    },
     "comma-separated-tokens": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz",
@@ -88,10 +1422,19 @@
       "integrity": "sha512-HYPSb7y/Z7BNDCOrakL4raGO2zltZkbeXyAd6Tg9obzix6QhzxCotdBl6VT0Dv4vZfJGVz3WL/xaEI9Ly3ul0g==",
       "dev": true
     },
-    "esprima": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
-      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+    "debug": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+      "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+      "dev": true,
+      "requires": {
+        "ms": "2.1.2"
+      }
+    },
+    "escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
       "dev": true
     },
     "extend": {
@@ -100,46 +1443,48 @@
       "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
       "dev": true
     },
-    "function-bind": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
-      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
-      "dev": true
-    },
-    "has": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
-      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+    "fault": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/fault/-/fault-1.0.4.tgz",
+      "integrity": "sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==",
       "dev": true,
       "requires": {
-        "function-bind": "^1.1.1"
+        "format": "^0.2.0"
       }
     },
+    "format": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz",
+      "integrity": "sha1-1hcBB+nv3E7TDJ3DkBbflCtctYs=",
+      "dev": true
+    },
     "hast-to-hyperscript": {
-      "version": "7.0.4",
-      "resolved": "https://registry.npmjs.org/hast-to-hyperscript/-/hast-to-hyperscript-7.0.4.tgz",
-      "integrity": "sha512-vmwriQ2H0RPS9ho4Kkbf3n3lY436QKLq6VaGA1pzBh36hBi3tm1DO9bR+kaJIbpT10UqaANDkMjxvjVfr+cnOA==",
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/hast-to-hyperscript/-/hast-to-hyperscript-9.0.1.tgz",
+      "integrity": "sha512-zQgLKqF+O2F72S1aa4y2ivxzSlko3MAvxkwG8ehGmNiqd98BIN3JM1rAJPmplEyLmGLO2QZYJtIneOSZ2YbJuA==",
       "dev": true,
       "requires": {
+        "@types/unist": "^2.0.3",
         "comma-separated-tokens": "^1.0.0",
         "property-information": "^5.3.0",
         "space-separated-tokens": "^1.0.0",
-        "style-to-object": "^0.2.1",
-        "unist-util-is": "^3.0.0",
-        "web-namespaces": "^1.1.2"
+        "style-to-object": "^0.3.0",
+        "unist-util-is": "^4.0.0",
+        "web-namespaces": "^1.0.0"
       }
     },
     "hast-util-from-parse5": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-5.0.3.tgz",
-      "integrity": "sha512-gOc8UB99F6eWVWFtM9jUikjN7QkWxB3nY0df5Z0Zq1/Nkwl5V4hAAsl0tmwlgWl/1shlTF8DnNYLO8X6wRV9pA==",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-6.0.1.tgz",
+      "integrity": "sha512-jeJUWiN5pSxW12Rh01smtVkZgZr33wBokLzKLwinYOUfSzm1Nl/c3GUGebDyOKjdsRgMvoVbV0VpAcpjF4NrJA==",
       "dev": true,
       "requires": {
-        "ccount": "^1.0.3",
-        "hastscript": "^5.0.0",
+        "@types/parse5": "^5.0.0",
+        "hastscript": "^6.0.0",
         "property-information": "^5.0.0",
-        "web-namespaces": "^1.1.2",
-        "xtend": "^4.0.1"
+        "vfile": "^4.0.0",
+        "vfile-location": "^3.2.0",
+        "web-namespaces": "^1.0.0"
       }
     },
     "hast-util-is-element": {
@@ -149,40 +1494,56 @@
       "dev": true
     },
     "hast-util-parse-selector": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-2.2.4.tgz",
-      "integrity": "sha512-gW3sxfynIvZApL4L07wryYF4+C9VvH3AUi7LAnVXV4MneGEgwOByXvFo18BgmTWnm7oHAe874jKbIB1YhHSIzA==",
+      "version": "2.2.5",
+      "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-2.2.5.tgz",
+      "integrity": "sha512-7j6mrk/qqkSehsM92wQjdIgWM2/BW61u/53G6xmC8i1OmEdKLHbk419QKQUjz6LglWsfqoiHmyMRkP1BGjecNQ==",
       "dev": true
     },
     "hast-util-raw": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-5.0.2.tgz",
-      "integrity": "sha512-3ReYQcIHmzSgMq8UrDZHFL0oGlbuVGdLKs8s/Fe8BfHFAyZDrdv1fy/AGn+Fim8ZuvAHcJ61NQhVMtyfHviT/g==",
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-6.1.0.tgz",
+      "integrity": "sha512-5FoZLDHBpka20OlZZ4I/+RBw5piVQ8iI1doEvffQhx5CbCyTtP8UCq8Tw6NmTAMtXgsQxmhW7Ly8OdFre5/YMQ==",
       "dev": true,
       "requires": {
-        "hast-util-from-parse5": "^5.0.0",
-        "hast-util-to-parse5": "^5.0.0",
+        "@types/hast": "^2.0.0",
+        "hast-util-from-parse5": "^6.0.0",
+        "hast-util-to-parse5": "^6.0.0",
         "html-void-elements": "^1.0.0",
-        "parse5": "^5.0.0",
+        "parse5": "^6.0.0",
         "unist-util-position": "^3.0.0",
+        "unist-util-visit": "^2.0.0",
+        "vfile": "^4.0.0",
         "web-namespaces": "^1.0.0",
         "xtend": "^4.0.0",
         "zwitch": "^1.0.0"
+      },
+      "dependencies": {
+        "unist-util-visit": {
+          "version": "2.0.3",
+          "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
+          "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+          "dev": true,
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-is": "^4.0.0",
+            "unist-util-visit-parents": "^3.0.0"
+          }
+        }
       }
     },
     "hast-util-sanitize": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-3.0.0.tgz",
-      "integrity": "sha512-gxsM24ARtuulsrWEj8QtVM6FNeAEHklF/t7TEIWvX1wuQcoAQtJtEUcT8t0os4uxCUqh1epX/gTi8fp8gNKvCA==",
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-3.0.2.tgz",
+      "integrity": "sha512-+2I0x2ZCAyiZOO/sb4yNLFmdwPBnyJ4PBkVTUMKMqBwYNA+lXSgOmoRXlJFazoyid9QPogRRKgKhVEodv181sA==",
       "dev": true,
       "requires": {
         "xtend": "^4.0.0"
       }
     },
     "hast-util-to-html": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-7.1.1.tgz",
-      "integrity": "sha512-Ujqj0hGuo3dIQKilkbauAv5teOqPvhaSLEgs1lgApFT0812e114KiffV8XfE4ttR8dRPqxNOIJOMu6SKOVOGlg==",
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-7.1.3.tgz",
+      "integrity": "sha512-yk2+1p3EJTEE9ZEUkgHsUSVhIpCsL/bvT8E5GzmWc+N1Po5gBw+0F8bo7dpxXR0nu0bQVxVZGX2lBGF21CmeDw==",
       "dev": true,
       "requires": {
         "ccount": "^1.0.0",
@@ -195,23 +1556,15 @@
         "stringify-entities": "^3.0.1",
         "unist-util-is": "^4.0.0",
         "xtend": "^4.0.0"
-      },
-      "dependencies": {
-        "unist-util-is": {
-          "version": "4.0.2",
-          "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.0.2.tgz",
-          "integrity": "sha512-Ofx8uf6haexJwI1gxWMGg6I/dLnF2yE+KibhD3/diOqY2TinLcqHXCV6OI5gFVn3xQqDH+u0M625pfKwIwgBKQ==",
-          "dev": true
-        }
       }
     },
     "hast-util-to-parse5": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-5.1.2.tgz",
-      "integrity": "sha512-ZgYLJu9lYknMfsBY0rBV4TJn2xiwF1fXFFjbP6EE7S0s5mS8LIKBVWzhA1MeIs1SWW6GnnE4In6c3kPb+CWhog==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-6.0.0.tgz",
+      "integrity": "sha512-Lu5m6Lgm/fWuz8eWnrKezHtVY83JeRGaNQ2kn9aJgqaxvVkFCZQBEhgodZUDUvoodgyROHDb3r5IxAEdl6suJQ==",
       "dev": true,
       "requires": {
-        "hast-to-hyperscript": "^7.0.0",
+        "hast-to-hyperscript": "^9.0.0",
         "property-information": "^5.0.0",
         "web-namespaces": "^1.0.0",
         "xtend": "^4.0.0",
@@ -225,11 +1578,12 @@
       "dev": true
     },
     "hastscript": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-5.1.2.tgz",
-      "integrity": "sha512-WlztFuK+Lrvi3EggsqOkQ52rKbxkXL3RwB6t5lwoa8QLMemoWfBuL43eDrwOamJyR7uKQKdmKYaBH1NZBiIRrQ==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-6.0.0.tgz",
+      "integrity": "sha512-nDM6bvd7lIqDUiYEiu5Sl/+6ReP0BMk/2f4U/Rooccxkj0P5nm+acM5PrGJ/t5I8qPGiqZSE6hVAwZEdZIvP4w==",
       "dev": true,
       "requires": {
+        "@types/hast": "^2.0.0",
         "comma-separated-tokens": "^1.0.0",
         "hast-util-parse-selector": "^2.0.0",
         "property-information": "^5.0.0",
@@ -237,9 +1591,9 @@
       }
     },
     "highlight.js": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-10.1.0.tgz",
-      "integrity": "sha512-e8aO/LUHDoxW4ntyKQf0/T3OtIZPhsfTr8XRuOq+FW5VdWEg/UDAeArzKF/22BaNZp6hPi/Zu/XQlTLOGLix3Q==",
+      "version": "11.0.1",
+      "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-11.0.1.tgz",
+      "integrity": "sha512-EqYpWyTF2s8nMfttfBA2yLKPNoZCO33pLS4MnbXQ4hECf1TKujCt1Kq7QAdrio7roL4+CqsfjqwYj4tYgq0pJQ==",
       "dev": true
     },
     "html-void-elements": {
@@ -248,12 +1602,6 @@
       "integrity": "sha512-uE/TxKuyNIcx44cIWnjr/rfIATDH7ZaOMmstu0CwhFG1Dunhlp4OC6/NMbhiwoq5BpW0ubi303qnEk/PZj614w==",
       "dev": true
     },
-    "inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "dev": true
-    },
     "inline-style-parser": {
       "version": "0.1.1",
       "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.1.1.tgz",
@@ -266,139 +1614,314 @@
       "integrity": "sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg==",
       "dev": true
     },
-    "is-alphanumerical": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz",
-      "integrity": "sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A==",
+    "is-alphanumerical": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz",
+      "integrity": "sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A==",
+      "dev": true,
+      "requires": {
+        "is-alphabetical": "^1.0.0",
+        "is-decimal": "^1.0.0"
+      }
+    },
+    "is-buffer": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz",
+      "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==",
+      "dev": true
+    },
+    "is-decimal": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.4.tgz",
+      "integrity": "sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw==",
+      "dev": true
+    },
+    "is-hexadecimal": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz",
+      "integrity": "sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw==",
+      "dev": true
+    },
+    "is-plain-obj": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
+      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
+      "dev": true
+    },
+    "js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dev": true,
+      "requires": {
+        "argparse": "^2.0.1"
+      }
+    },
+    "longest-streak": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-2.0.4.tgz",
+      "integrity": "sha512-vM6rUVCVUJJt33bnmHiZEvr7wPT78ztX7rojL+LW51bHtLh6HTjx84LA5W4+oa6aKEJA7jJu5LR6vQRBpA5DVg==",
+      "dev": true
+    },
+    "markdown-table": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz",
+      "integrity": "sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==",
+      "dev": true,
+      "requires": {
+        "repeat-string": "^1.0.0"
+      }
+    },
+    "mdast-util-definitions": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-4.0.0.tgz",
+      "integrity": "sha512-k8AJ6aNnUkB7IE+5azR9h81O5EQ/cTDXtWdMq9Kk5KcEW/8ritU5CeLg/9HhOC++nALHBlaogJ5jz0Ybk3kPMQ==",
+      "dev": true,
+      "requires": {
+        "unist-util-visit": "^2.0.0"
+      },
+      "dependencies": {
+        "unist-util-visit": {
+          "version": "2.0.3",
+          "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
+          "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+          "dev": true,
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-is": "^4.0.0",
+            "unist-util-visit-parents": "^3.0.0"
+          }
+        }
+      }
+    },
+    "mdast-util-find-and-replace": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-1.1.1.tgz",
+      "integrity": "sha512-9cKl33Y21lyckGzpSmEQnIDjEfeeWelN5s1kUW1LwdB0Fkuq2u+4GdqcGEygYxJE8GVqCl0741bYXHgamfWAZA==",
+      "dev": true,
+      "requires": {
+        "escape-string-regexp": "^4.0.0",
+        "unist-util-is": "^4.0.0",
+        "unist-util-visit-parents": "^3.0.0"
+      }
+    },
+    "mdast-util-from-markdown": {
+      "version": "0.8.5",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-0.8.5.tgz",
+      "integrity": "sha512-2hkTXtYYnr+NubD/g6KGBS/0mFmBcifAsI0yIWRiRo0PjVs6SSOSOdtzbp6kSGnShDN6G5aWZpKQ2lWRy27mWQ==",
+      "dev": true,
+      "requires": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-string": "^2.0.0",
+        "micromark": "~2.11.0",
+        "parse-entities": "^2.0.0",
+        "unist-util-stringify-position": "^2.0.0"
+      }
+    },
+    "mdast-util-frontmatter": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-frontmatter/-/mdast-util-frontmatter-0.2.0.tgz",
+      "integrity": "sha512-FHKL4w4S5fdt1KjJCwB0178WJ0evnyyQr5kXTM3wrOVpytD0hrkvd+AOOjU9Td8onOejCkmZ+HQRT3CZ3coHHQ==",
       "dev": true,
       "requires": {
-        "is-alphabetical": "^1.0.0",
-        "is-decimal": "^1.0.0"
+        "micromark-extension-frontmatter": "^0.2.0"
       }
     },
-    "is-buffer": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.4.tgz",
-      "integrity": "sha512-Kq1rokWXOPXWuaMAqZiJW4XxsmD9zGx9q4aePabbn3qCRGedtH7Cm+zV8WETitMfu1wdh+Rvd6w5egwSngUX2A==",
-      "dev": true
-    },
-    "is-decimal": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.4.tgz",
-      "integrity": "sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw==",
-      "dev": true
-    },
-    "is-hexadecimal": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz",
-      "integrity": "sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw==",
-      "dev": true
-    },
-    "is-plain-obj": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
-      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
-      "dev": true
-    },
-    "is-whitespace-character": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-whitespace-character/-/is-whitespace-character-1.0.4.tgz",
-      "integrity": "sha512-SDweEzfIZM0SJV0EUga669UTKlmL0Pq8Lno0QDQsPnvECB3IM2aP0gdx5TrU0A01MAPfViaZiI2V1QMZLaKK5w==",
-      "dev": true
-    },
-    "is-word-character": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-word-character/-/is-word-character-1.0.4.tgz",
-      "integrity": "sha512-5SMO8RVennx3nZrqtKwCGyyetPE9VDba5ugvKLaD4KopPG5kR4mQ7tNt/r7feL5yt5h3lpuBbIUmCOG2eSzXHA==",
-      "dev": true
-    },
-    "js-yaml": {
-      "version": "3.14.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.0.tgz",
-      "integrity": "sha512-/4IbIeHcD9VMHFqDR/gQ7EdZdLimOvW2DdcxFjdyyZ9NsbS+ccrXqVWDtab/lRl5AlUqmpBx8EhPaWR+OtY17A==",
+    "mdast-util-gfm": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-0.1.2.tgz",
+      "integrity": "sha512-NNkhDx/qYcuOWB7xHUGWZYVXvjPFFd6afg6/e2g+SV4r9q5XUcCbV4Wfa3DLYIiD+xAEZc6K4MGaE/m0KDcPwQ==",
       "dev": true,
       "requires": {
-        "argparse": "^1.0.7",
-        "esprima": "^4.0.0"
+        "mdast-util-gfm-autolink-literal": "^0.1.0",
+        "mdast-util-gfm-strikethrough": "^0.2.0",
+        "mdast-util-gfm-table": "^0.1.0",
+        "mdast-util-gfm-task-list-item": "^0.1.0",
+        "mdast-util-to-markdown": "^0.6.1"
       }
     },
-    "lodash.iteratee": {
-      "version": "4.7.0",
-      "resolved": "https://registry.npmjs.org/lodash.iteratee/-/lodash.iteratee-4.7.0.tgz",
-      "integrity": "sha1-vkF32yiajMw8CZDx2ya1si/BVUw=",
-      "dev": true
-    },
-    "longest-streak": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-1.0.0.tgz",
-      "integrity": "sha1-0GWXxNTDG1LMsfXY+P5xSOr9aWU=",
-      "dev": true
+    "mdast-util-gfm-autolink-literal": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-0.1.3.tgz",
+      "integrity": "sha512-GjmLjWrXg1wqMIO9+ZsRik/s7PLwTaeCHVB7vRxUwLntZc8mzmTsLVr6HW1yLokcnhfURsn5zmSVdi3/xWWu1A==",
+      "dev": true,
+      "requires": {
+        "ccount": "^1.0.0",
+        "mdast-util-find-and-replace": "^1.1.0",
+        "micromark": "^2.11.3"
+      }
     },
-    "markdown-escapes": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/markdown-escapes/-/markdown-escapes-1.0.4.tgz",
-      "integrity": "sha512-8z4efJYk43E0upd0NbVXwgSTQs6cT3T06etieCMEg7dRbzCbxUCK/GHlX8mhHRDcp+OLlHkPKsvqQTCvsRl2cg==",
-      "dev": true
+    "mdast-util-gfm-strikethrough": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-0.2.3.tgz",
+      "integrity": "sha512-5OQLXpt6qdbttcDG/UxYY7Yjj3e8P7X16LzvpX8pIQPYJ/C2Z1qFGMmcw+1PZMUM3Z8wt8NRfYTvCni93mgsgA==",
+      "dev": true,
+      "requires": {
+        "mdast-util-to-markdown": "^0.6.0"
+      }
     },
-    "markdown-table": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-0.4.0.tgz",
-      "integrity": "sha1-iQwsGzv+g/sA5BKbjkz+ZFJw+dE=",
-      "dev": true
+    "mdast-util-gfm-table": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-0.1.6.tgz",
+      "integrity": "sha512-j4yDxQ66AJSBwGkbpFEp9uG/LS1tZV3P33fN1gkyRB2LoRL+RR3f76m0HPHaby6F4Z5xr9Fv1URmATlRRUIpRQ==",
+      "dev": true,
+      "requires": {
+        "markdown-table": "^2.0.0",
+        "mdast-util-to-markdown": "~0.6.0"
+      }
     },
-    "mdast-util-definitions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-3.0.1.tgz",
-      "integrity": "sha512-BAv2iUm/e6IK/b2/t+Fx69EL/AGcq/IG2S+HxHjDJGfLJtd6i9SZUS76aC9cig+IEucsqxKTR0ot3m933R3iuA==",
+    "mdast-util-gfm-task-list-item": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-0.1.6.tgz",
+      "integrity": "sha512-/d51FFIfPsSmCIRNp7E6pozM9z1GYPIkSy1urQ8s/o4TC22BZ7DqfHFWiqBD23bc7J3vV1Fc9O4QIHBlfuit8A==",
       "dev": true,
       "requires": {
-        "unist-util-visit": "^2.0.0"
+        "mdast-util-to-markdown": "~0.6.0"
       }
     },
     "mdast-util-to-hast": {
-      "version": "9.1.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-9.1.1.tgz",
-      "integrity": "sha512-vpMWKFKM2mnle+YbNgDXxx95vv0CoLU0v/l3F5oFAG5DV7qwkZVWA206LsAdOnEVyf5vQcLnb3cWJywu7mUxsQ==",
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-10.2.0.tgz",
+      "integrity": "sha512-JoPBfJ3gBnHZ18icCwHR50orC9kNH81tiR1gs01D8Q5YpV6adHNO9nKNuFBCJQ941/32PT1a63UF/DitmS3amQ==",
       "dev": true,
       "requires": {
         "@types/mdast": "^3.0.0",
-        "@types/unist": "^2.0.3",
-        "mdast-util-definitions": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "mdast-util-definitions": "^4.0.0",
         "mdurl": "^1.0.0",
         "unist-builder": "^2.0.0",
         "unist-util-generated": "^1.0.0",
         "unist-util-position": "^3.0.0",
         "unist-util-visit": "^2.0.0"
+      },
+      "dependencies": {
+        "unist-util-visit": {
+          "version": "2.0.3",
+          "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
+          "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+          "dev": true,
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-is": "^4.0.0",
+            "unist-util-visit-parents": "^3.0.0"
+          }
+        }
+      }
+    },
+    "mdast-util-to-markdown": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-0.6.5.tgz",
+      "integrity": "sha512-XeV9sDE7ZlOQvs45C9UKMtfTcctcaj/pGwH8YLbMHoMOXNNCn2LsqVQOqrF1+/NU8lKDAqozme9SCXWyo9oAcQ==",
+      "dev": true,
+      "requires": {
+        "@types/unist": "^2.0.0",
+        "longest-streak": "^2.0.0",
+        "mdast-util-to-string": "^2.0.0",
+        "parse-entities": "^2.0.0",
+        "repeat-string": "^1.0.0",
+        "zwitch": "^1.0.0"
       }
     },
+    "mdast-util-to-string": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-2.0.0.tgz",
+      "integrity": "sha512-AW4DRS3QbBayY/jJmD8437V1Gombjf8RSOUCMFBuo5iHi58AGEgVCKQ+ezHkZZDpAQS75hcBMpLqjpJTjtUL7w==",
+      "dev": true
+    },
     "mdurl": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz",
       "integrity": "sha1-/oWy7HWlkDfyrf7BAP1sYBdhFS4=",
       "dev": true
     },
-    "not": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/not/-/not-0.1.0.tgz",
-      "integrity": "sha1-yWkcF0bFXc++VMvYvU/wQbwrUZ0=",
+    "micromark": {
+      "version": "2.11.4",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-2.11.4.tgz",
+      "integrity": "sha512-+WoovN/ppKolQOFIAajxi7Lu9kInbPxFuTBVEavFcL8eAfVstoc5MocPmqBeAdBOJV00uaVjegzH4+MA0DN/uA==",
+      "dev": true,
+      "requires": {
+        "debug": "^4.0.0",
+        "parse-entities": "^2.0.0"
+      }
+    },
+    "micromark-extension-frontmatter": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/micromark-extension-frontmatter/-/micromark-extension-frontmatter-0.2.2.tgz",
+      "integrity": "sha512-q6nPLFCMTLtfsctAuS0Xh4vaolxSFUWUWR6PZSrXXiRy+SANGllpcqdXFv2z07l0Xz/6Hl40hK0ffNCJPH2n1A==",
+      "dev": true,
+      "requires": {
+        "fault": "^1.0.0"
+      }
+    },
+    "micromark-extension-gfm": {
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-0.3.3.tgz",
+      "integrity": "sha512-oVN4zv5/tAIA+l3GbMi7lWeYpJ14oQyJ3uEim20ktYFAcfX1x3LNlFGGlmrZHt7u9YlKExmyJdDGaTt6cMSR/A==",
+      "dev": true,
+      "requires": {
+        "micromark": "~2.11.0",
+        "micromark-extension-gfm-autolink-literal": "~0.5.0",
+        "micromark-extension-gfm-strikethrough": "~0.6.5",
+        "micromark-extension-gfm-table": "~0.4.0",
+        "micromark-extension-gfm-tagfilter": "~0.3.0",
+        "micromark-extension-gfm-task-list-item": "~0.3.0"
+      }
+    },
+    "micromark-extension-gfm-autolink-literal": {
+      "version": "0.5.7",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-0.5.7.tgz",
+      "integrity": "sha512-ePiDGH0/lhcngCe8FtH4ARFoxKTUelMp4L7Gg2pujYD5CSMb9PbblnyL+AAMud/SNMyusbS2XDSiPIRcQoNFAw==",
+      "dev": true,
+      "requires": {
+        "micromark": "~2.11.3"
+      }
+    },
+    "micromark-extension-gfm-strikethrough": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-0.6.5.tgz",
+      "integrity": "sha512-PpOKlgokpQRwUesRwWEp+fHjGGkZEejj83k9gU5iXCbDG+XBA92BqnRKYJdfqfkrRcZRgGuPuXb7DaK/DmxOhw==",
+      "dev": true,
+      "requires": {
+        "micromark": "~2.11.0"
+      }
+    },
+    "micromark-extension-gfm-table": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-0.4.3.tgz",
+      "integrity": "sha512-hVGvESPq0fk6ALWtomcwmgLvH8ZSVpcPjzi0AjPclB9FsVRgMtGZkUcpE0zgjOCFAznKepF4z3hX8z6e3HODdA==",
+      "dev": true,
+      "requires": {
+        "micromark": "~2.11.0"
+      }
+    },
+    "micromark-extension-gfm-tagfilter": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-0.3.0.tgz",
+      "integrity": "sha512-9GU0xBatryXifL//FJH+tAZ6i240xQuFrSL7mYi8f4oZSbc+NvXjkrHemeYP0+L4ZUT+Ptz3b95zhUZnMtoi/Q==",
       "dev": true
     },
-    "nth-check": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-1.0.2.tgz",
-      "integrity": "sha512-WeBOdju8SnzPN5vTUJYxYUxLeXpCaVP5i5e0LF8fg7WORF2Wd7wFX/pk0tYZk7s8T+J7VLy0Da6J1+wCT0AtHg==",
+    "micromark-extension-gfm-task-list-item": {
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-0.3.3.tgz",
+      "integrity": "sha512-0zvM5iSLKrc/NQl84pZSjGo66aTGd57C1idmlWmE87lkMcXrTxg1uXa/nXomxJytoje9trP0NDLvw4bZ/Z/XCQ==",
       "dev": true,
       "requires": {
-        "boolbase": "~1.0.0"
+        "micromark": "~2.11.0"
       }
     },
-    "once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+    "ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "dev": true
+    },
+    "nth-check": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.0.tgz",
+      "integrity": "sha512-i4sc/Kj8htBrAiH1viZ0TgU8Y5XqCaV/FziYK6TBczxmeKm3AEFWqqF3195yKudrarqy7Zu80Ra5dobFjn9X/Q==",
       "dev": true,
       "requires": {
-        "wrappy": "1"
+        "boolbase": "^1.0.0"
       }
     },
     "parse-entities": {
@@ -416,27 +1939,27 @@
       }
     },
     "parse5": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-5.1.1.tgz",
-      "integrity": "sha512-ugq4DFI0Ptb+WWjAdOK16+u/nHfiIrcE+sh8kZMaM0WllQKLI9rOUq6c2b7cwPkXdzfQESqvoqK6ug7U/Yyzug==",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz",
+      "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==",
       "dev": true
     },
     "property-information": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/property-information/-/property-information-5.5.0.tgz",
-      "integrity": "sha512-RgEbCx2HLa1chNgvChcx+rrCWD0ctBmGSE0M7lVm1yyv4UbvbrWoXp/BkVLZefzjrRBGW8/Js6uh/BnlHXFyjA==",
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-5.6.0.tgz",
+      "integrity": "sha512-YUHSPk+A30YPv+0Qf8i9Mbfe/C0hdPXk1s1jPVToV8pk8BQtpw10ct89Eo7OWkutrwqvT0eicAxlOg3dOAu8JA==",
       "dev": true,
       "requires": {
         "xtend": "^4.0.0"
       }
     },
     "rehype-raw": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/rehype-raw/-/rehype-raw-4.0.2.tgz",
-      "integrity": "sha512-xQt94oXfDaO7sK9mJBtsZXkjW/jm6kArCoYN+HqKZ51O19AFHlp3Xa5UfZZ2tJkbpAZzKtgVUYvnconk9IsFuA==",
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/rehype-raw/-/rehype-raw-5.1.0.tgz",
+      "integrity": "sha512-MDvHAb/5mUnif2R+0IPCYJU8WjHa9UzGtM/F4AVy5GixPlDZ1z3HacYy4xojDU+uBa+0X/3PIfyQI26/2ljJNA==",
       "dev": true,
       "requires": {
-        "hast-util-raw": "^5.0.0"
+        "hast-util-raw": "^6.1.0"
       }
     },
     "rehype-stringify": {
@@ -448,190 +1971,53 @@
         "hast-util-to-html": "^7.1.1"
       }
     },
-    "remark": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/remark/-/remark-5.1.0.tgz",
-      "integrity": "sha1-y0Y709vLS5l5STXu4c9x16jjBow=",
+    "remark-frontmatter": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-frontmatter/-/remark-frontmatter-3.0.0.tgz",
+      "integrity": "sha512-mSuDd3svCHs+2PyO29h7iijIZx4plX0fheacJcAoYAASfgzgVIcXGYSq9GFyYocFLftQs8IOmmkgtOovs6d4oA==",
       "dev": true,
       "requires": {
-        "remark-parse": "^1.1.0",
-        "remark-stringify": "^1.1.0",
-        "unified": "^4.1.1"
-      },
-      "dependencies": {
-        "parse-entities": {
-          "version": "1.2.2",
-          "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-1.2.2.tgz",
-          "integrity": "sha512-NzfpbxW/NPrzZ/yYSoQxyqUZMZXIdCfE0OIN4ESsnptHJECoUk3FZktxNuzQf4tjt5UEopnxpYJbvYuxIFDdsg==",
-          "dev": true,
-          "requires": {
-            "character-entities": "^1.0.0",
-            "character-entities-legacy": "^1.0.0",
-            "character-reference-invalid": "^1.0.0",
-            "is-alphanumerical": "^1.0.0",
-            "is-decimal": "^1.0.0",
-            "is-hexadecimal": "^1.0.0"
-          }
-        },
-        "remark-parse": {
-          "version": "1.1.0",
-          "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-1.1.0.tgz",
-          "integrity": "sha1-w8oQ+ajaBGFcKPCapOMEUQUm7CE=",
-          "dev": true,
-          "requires": {
-            "collapse-white-space": "^1.0.0",
-            "extend": "^3.0.0",
-            "parse-entities": "^1.0.2",
-            "repeat-string": "^1.5.4",
-            "trim": "0.0.1",
-            "trim-trailing-lines": "^1.0.0",
-            "unherit": "^1.0.4",
-            "unist-util-remove-position": "^1.0.0",
-            "vfile-location": "^2.0.0"
-          }
-        },
-        "unified": {
-          "version": "4.2.1",
-          "resolved": "https://registry.npmjs.org/unified/-/unified-4.2.1.tgz",
-          "integrity": "sha1-dv9Dqo2kMPbn5KVchOusKtLPzS4=",
-          "dev": true,
-          "requires": {
-            "bail": "^1.0.0",
-            "extend": "^3.0.0",
-            "has": "^1.0.1",
-            "once": "^1.3.3",
-            "trough": "^1.0.0",
-            "vfile": "^1.0.0"
-          }
-        },
-        "unist-util-remove-position": {
-          "version": "1.1.4",
-          "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-1.1.4.tgz",
-          "integrity": "sha512-tLqd653ArxJIPnKII6LMZwH+mb5q+n/GtXQZo6S6csPRs5zB0u79Yw8ouR3wTw8wxvdJFhpP6Y7jorWdCgLO0A==",
-          "dev": true,
-          "requires": {
-            "unist-util-visit": "^1.1.0"
-          }
-        },
-        "unist-util-visit": {
-          "version": "1.4.1",
-          "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-1.4.1.tgz",
-          "integrity": "sha512-AvGNk7Bb//EmJZyhtRUnNMEpId/AZ5Ph/KUpTI09WHQuDZHKovQ1oEv3mfmKpWKtoMzyMC4GLBm1Zy5k12fjIw==",
-          "dev": true,
-          "requires": {
-            "unist-util-visit-parents": "^2.0.0"
-          }
-        },
-        "unist-util-visit-parents": {
-          "version": "2.1.2",
-          "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-2.1.2.tgz",
-          "integrity": "sha512-DyN5vD4NE3aSeB+PXYNKxzGsfocxp6asDc2XXE3b0ekO2BaRUpBicbbUygfSvYfUz1IkmjFR1YF7dPklraMZ2g==",
-          "dev": true,
-          "requires": {
-            "unist-util-is": "^3.0.0"
-          }
-        },
-        "vfile": {
-          "version": "1.4.0",
-          "resolved": "https://registry.npmjs.org/vfile/-/vfile-1.4.0.tgz",
-          "integrity": "sha1-wP1vpIT43r23cfaMMe112I2pf+c=",
-          "dev": true
-        },
-        "vfile-location": {
-          "version": "2.0.6",
-          "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-2.0.6.tgz",
-          "integrity": "sha512-sSFdyCP3G6Ka0CEmN83A2YCMKIieHx0EDaj5IDP4g1pa5ZJ4FJDvpO0WODLxo4LUX4oe52gmSCK7Jw4SBghqxA==",
-          "dev": true
-        }
+        "mdast-util-frontmatter": "^0.2.0",
+        "micromark-extension-frontmatter": "^0.2.0"
+      }
+    },
+    "remark-gfm": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-1.0.0.tgz",
+      "integrity": "sha512-KfexHJCiqvrdBZVbQ6RopMZGwaXz6wFJEfByIuEwGf0arvITHjiKKZ1dpXujjH9KZdm1//XJQwgfnJ3lmXaDPA==",
+      "dev": true,
+      "requires": {
+        "mdast-util-gfm": "^0.1.0",
+        "micromark-extension-gfm": "^0.3.0"
       }
     },
     "remark-html": {
-      "version": "12.0.0",
-      "resolved": "https://registry.npmjs.org/remark-html/-/remark-html-12.0.0.tgz",
-      "integrity": "sha512-M104NMHs48+uswChJkCDXCdabzxAinpHikpt6kS3gmGMyIvPZ5kn53tB9shFsL2O4HUJ9DIEsah1SX1Ve5FXHA==",
+      "version": "13.0.1",
+      "resolved": "https://registry.npmjs.org/remark-html/-/remark-html-13.0.1.tgz",
+      "integrity": "sha512-K5KQCXWVz+harnyC+UVM/J9eJWCgjYRqFeZoZf2NgP0iFbuuw/RgMZv3MA34b/OEpGnstl3oiOUtZzD3tJ+CBw==",
       "dev": true,
       "requires": {
         "hast-util-sanitize": "^3.0.0",
         "hast-util-to-html": "^7.0.0",
-        "mdast-util-to-hast": "^9.0.0",
-        "xtend": "^4.0.1"
+        "mdast-util-to-hast": "^10.0.0"
       }
     },
     "remark-parse": {
-      "version": "8.0.3",
-      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-8.0.3.tgz",
-      "integrity": "sha512-E1K9+QLGgggHxCQtLt++uXltxEprmWzNfg+MxpfHsZlrddKzZ/hZyWHDbK3/Ap8HJQqYJRXP+jHczdL6q6i85Q==",
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-9.0.0.tgz",
+      "integrity": "sha512-geKatMwSzEXKHuzBNU1z676sGcDcFoChMK38TgdHJNAYfFtsfHDQG7MoJAjs6sgYMqyLduCYWDIWZIxiPeafEw==",
       "dev": true,
       "requires": {
-        "ccount": "^1.0.0",
-        "collapse-white-space": "^1.0.2",
-        "is-alphabetical": "^1.0.0",
-        "is-decimal": "^1.0.0",
-        "is-whitespace-character": "^1.0.0",
-        "is-word-character": "^1.0.0",
-        "markdown-escapes": "^1.0.0",
-        "parse-entities": "^2.0.0",
-        "repeat-string": "^1.5.4",
-        "state-toggle": "^1.0.0",
-        "trim": "0.0.1",
-        "trim-trailing-lines": "^1.0.0",
-        "unherit": "^1.0.4",
-        "unist-util-remove-position": "^2.0.0",
-        "vfile-location": "^3.0.0",
-        "xtend": "^4.0.1"
+        "mdast-util-from-markdown": "^0.8.0"
       }
     },
     "remark-rehype": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-7.0.0.tgz",
-      "integrity": "sha512-uqQ/VbaTdxyu/da6npHAso6hA00cMqhA3a59RziQdOLN2KEIkPykAVy52IcmZEVTuauXO0VtpxkyCey4phtHzQ==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-8.1.0.tgz",
+      "integrity": "sha512-EbCu9kHgAxKmW1yEYjx3QafMyGY3q8noUbNUI5xyKbaFP89wbhDrKxyIQNukNYthzjNHZu6J7hwFg7hRm1svYA==",
       "dev": true,
       "requires": {
-        "mdast-util-to-hast": "^9.1.0"
-      }
-    },
-    "remark-stringify": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-1.1.0.tgz",
-      "integrity": "sha1-pxBeJbnuK/mkm3XSxCPxGwauIJI=",
-      "dev": true,
-      "requires": {
-        "ccount": "^1.0.0",
-        "extend": "^3.0.0",
-        "longest-streak": "^1.0.0",
-        "markdown-table": "^0.4.0",
-        "parse-entities": "^1.0.2",
-        "repeat-string": "^1.5.4",
-        "stringify-entities": "^1.0.1",
-        "unherit": "^1.0.4"
-      },
-      "dependencies": {
-        "parse-entities": {
-          "version": "1.2.2",
-          "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-1.2.2.tgz",
-          "integrity": "sha512-NzfpbxW/NPrzZ/yYSoQxyqUZMZXIdCfE0OIN4ESsnptHJECoUk3FZktxNuzQf4tjt5UEopnxpYJbvYuxIFDdsg==",
-          "dev": true,
-          "requires": {
-            "character-entities": "^1.0.0",
-            "character-entities-legacy": "^1.0.0",
-            "character-reference-invalid": "^1.0.0",
-            "is-alphanumerical": "^1.0.0",
-            "is-decimal": "^1.0.0",
-            "is-hexadecimal": "^1.0.0"
-          }
-        },
-        "stringify-entities": {
-          "version": "1.3.2",
-          "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-1.3.2.tgz",
-          "integrity": "sha512-nrBAQClJAPN2p+uGCVJRPIPakKeKWZ9GtBCmormE7pWOSlHat7+x5A8gx85M7HM5Dt0BP3pP5RhVW77WdbJJ3A==",
-          "dev": true,
-          "requires": {
-            "character-entities-html4": "^1.0.0",
-            "character-entities-legacy": "^1.0.0",
-            "is-alphanumerical": "^1.0.0",
-            "is-hexadecimal": "^1.0.0"
-          }
-        }
+        "mdast-util-to-hast": "^10.2.0"
       }
     },
     "repeat-string": {
@@ -640,94 +2026,85 @@
       "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=",
       "dev": true
     },
-    "replace-ext": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.0.tgz",
-      "integrity": "sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=",
-      "dev": true
-    },
     "space-separated-tokens": {
       "version": "1.1.5",
       "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-1.1.5.tgz",
       "integrity": "sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA==",
       "dev": true
     },
-    "sprintf-js": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
-      "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",
-      "dev": true
-    },
-    "state-toggle": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/state-toggle/-/state-toggle-1.0.3.tgz",
-      "integrity": "sha512-d/5Z4/2iiCnHw6Xzghyhb+GcmF89bxwgXG60wjIiZaxnymbyOmI8Hk4VqHXiVVp6u2ysaskFfXg3ekCj4WNftQ==",
-      "dev": true
-    },
     "stringify-entities": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-3.0.1.tgz",
-      "integrity": "sha512-Lsk3ISA2++eJYqBMPKcr/8eby1I6L0gP0NlxF8Zja6c05yr/yCYyb2c9PwXjd08Ib3If1vn1rbs1H5ZtVuOfvQ==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-3.1.0.tgz",
+      "integrity": "sha512-3FP+jGMmMV/ffZs86MoghGqAoqXAdxLrJP4GUdrDN1aIScYih5tuIO3eF4To5AJZ79KDZ8Fpdy7QJnK8SsL1Vg==",
       "dev": true,
       "requires": {
         "character-entities-html4": "^1.0.0",
         "character-entities-legacy": "^1.0.0",
-        "is-alphanumerical": "^1.0.0",
-        "is-decimal": "^1.0.2",
-        "is-hexadecimal": "^1.0.0"
+        "xtend": "^4.0.0"
       }
     },
     "style-to-object": {
-      "version": "0.2.3",
-      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-0.2.3.tgz",
-      "integrity": "sha512-1d/k4EY2N7jVLOqf2j04dTc37TPOv/hHxZmvpg8Pdh8UYydxeu/C1W1U4vD8alzf5V2Gt7rLsmkr4dxAlDm9ng==",
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-0.3.0.tgz",
+      "integrity": "sha512-CzFnRRXhzWIdItT3OmF8SQfWyahHhjq3HwcMNCNLn+N7klOOqPjMeG/4JSu77D7ypZdGvSzvkrbyeTMizz2VrA==",
       "dev": true,
       "requires": {
         "inline-style-parser": "0.1.1"
       }
     },
     "to-vfile": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/to-vfile/-/to-vfile-6.1.0.tgz",
-      "integrity": "sha512-BxX8EkCxOAZe+D/ToHdDsJcVI4HqQfmw0tCkp31zf3dNP/XWIAjU4CmeuSwsSoOzOTqHPOL0KUzyZqJplkD0Qw==",
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/to-vfile/-/to-vfile-7.1.0.tgz",
+      "integrity": "sha512-t1c42ASuWo39ddjh2R+hX5+kbDcc2CmbhaTSJkVavDYMjnFkpq0L4LeF+rcPoDdieGUsFaivSSkmwuFpYzhBZw==",
       "dev": true,
       "requires": {
         "is-buffer": "^2.0.0",
-        "vfile": "^4.0.0"
+        "vfile": "^5.0.0"
+      },
+      "dependencies": {
+        "unist-util-stringify-position": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.0.tgz",
+          "integrity": "sha512-SdfAl8fsDclywZpfMDTVDxA2V7LjtRDTOFd44wUJamgl6OlVngsqWjxvermMYf60elWHbxhuRCZml7AnuXCaSA==",
+          "dev": true,
+          "requires": {
+            "@types/unist": "^2.0.0"
+          }
+        },
+        "vfile": {
+          "version": "5.0.1",
+          "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.0.1.tgz",
+          "integrity": "sha512-lbcf0k66x96Syy36HG+nIBFaSD/fAk589q4nETZTr0JW7eRRmrVo1vHwbD8NlHszUM5ICtFSWQ5xHC292hYZ/w==",
+          "dev": true,
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "is-buffer": "^2.0.0",
+            "unist-util-stringify-position": "^3.0.0",
+            "vfile-message": "^3.0.0"
+          }
+        },
+        "vfile-message": {
+          "version": "3.0.1",
+          "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.0.1.tgz",
+          "integrity": "sha512-gYmSHcZZUEtYpTmaWaFJwsuUD70/rTY4v09COp8TGtOkix6gGxb/a8iTQByIY9ciTk9GwAwIXd/J9OPfM4Bvaw==",
+          "dev": true,
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-stringify-position": "^3.0.0"
+          }
+        }
       }
     },
-    "trim": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/trim/-/trim-0.0.1.tgz",
-      "integrity": "sha1-WFhUf2spB1fulczMZm+1AITEYN0=",
-      "dev": true
-    },
-    "trim-trailing-lines": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/trim-trailing-lines/-/trim-trailing-lines-1.1.3.tgz",
-      "integrity": "sha512-4ku0mmjXifQcTVfYDfR5lpgV7zVqPg6zV9rdZmwOPqq0+Zq19xDqEgagqVbc4pOOShbncuAOIs59R3+3gcF3ZA==",
-      "dev": true
-    },
     "trough": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/trough/-/trough-1.0.5.tgz",
       "integrity": "sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA==",
       "dev": true
     },
-    "unherit": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/unherit/-/unherit-1.1.3.tgz",
-      "integrity": "sha512-Ft16BJcnapDKp0+J/rqFC3Rrk6Y/Ng4nzsC028k2jdDII/rdZ7Wd3pPT/6+vIIxRagwRc9K0IUX0Ra4fKvw+WQ==",
-      "dev": true,
-      "requires": {
-        "inherits": "^2.0.0",
-        "xtend": "^4.0.0"
-      }
-    },
     "unified": {
-      "version": "9.2.0",
-      "resolved": "https://registry.npmjs.org/unified/-/unified-9.2.0.tgz",
-      "integrity": "sha512-vx2Z0vY+a3YoTj8+pttM3tiJHCwY5UFbYdiWrwBEbHmK8pvsPj2rtAX2BFfgXen8T39CJWblWRDT4L5WGXtDdg==",
+      "version": "9.2.1",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-9.2.1.tgz",
+      "integrity": "sha512-juWjuI8Z4xFg8pJbnEZ41b5xjGUWGHqXALmBZ3FC3WX0PIx1CZBIIJ6mXbYMcf6Yw4Fi0rFUTA1cdz/BglbOhA==",
       "dev": true,
       "requires": {
         "bail": "^1.0.0",
@@ -744,47 +2121,16 @@
       "integrity": "sha512-f98yt5pnlMWlzP539tPc4grGMsFaQQlP/vM396b00jngsiINumNmsY8rkXjfoi1c6QaM8nQ3vaGDuoKWbe/1Uw==",
       "dev": true
     },
-    "unist-util-find": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/unist-util-find/-/unist-util-find-1.0.1.tgz",
-      "integrity": "sha1-EGK7tpKMepfGrcibU3RdTEbCIqI=",
-      "dev": true,
-      "requires": {
-        "lodash.iteratee": "^4.5.0",
-        "remark": "^5.0.1",
-        "unist-util-visit": "^1.1.0"
-      },
-      "dependencies": {
-        "unist-util-visit": {
-          "version": "1.4.1",
-          "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-1.4.1.tgz",
-          "integrity": "sha512-AvGNk7Bb//EmJZyhtRUnNMEpId/AZ5Ph/KUpTI09WHQuDZHKovQ1oEv3mfmKpWKtoMzyMC4GLBm1Zy5k12fjIw==",
-          "dev": true,
-          "requires": {
-            "unist-util-visit-parents": "^2.0.0"
-          }
-        },
-        "unist-util-visit-parents": {
-          "version": "2.1.2",
-          "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-2.1.2.tgz",
-          "integrity": "sha512-DyN5vD4NE3aSeB+PXYNKxzGsfocxp6asDc2XXE3b0ekO2BaRUpBicbbUygfSvYfUz1IkmjFR1YF7dPklraMZ2g==",
-          "dev": true,
-          "requires": {
-            "unist-util-is": "^3.0.0"
-          }
-        }
-      }
-    },
     "unist-util-generated": {
-      "version": "1.1.5",
-      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-1.1.5.tgz",
-      "integrity": "sha512-1TC+NxQa4N9pNdayCYA1EGUOCAO0Le3fVp7Jzns6lnua/mYgwHo0tz5WUAfrdpNch1RZLHc61VZ1SDgrtNXLSw==",
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-1.1.6.tgz",
+      "integrity": "sha512-cln2Mm1/CZzN5ttGK7vkoGw+RZ8VcUH6BtGbq98DDtRGquAAOXig1mrBQYelOwMXYS8rK+vZDyyojSjp7JX+Lg==",
       "dev": true
     },
     "unist-util-is": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-3.0.0.tgz",
-      "integrity": "sha512-sVZZX3+kspVNmLWBPAB6r+7D9ZgAFPNWm66f7YNb420RlQSbn+n8rG8dGZSkrER7ZIXGQYNm5pqC3v3HopH24A==",
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.1.0.tgz",
+      "integrity": "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg==",
       "dev": true
     },
     "unist-util-position": {
@@ -793,32 +2139,28 @@
       "integrity": "sha512-w+PkwCbYSFw8vpgWD0v7zRCl1FpY3fjDSQ3/N/wNd9Ffa4gPi8+4keqt99N3XW6F99t/mUzp2xAhNmfKWp95QA==",
       "dev": true
     },
-    "unist-util-remove-position": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-2.0.1.tgz",
-      "integrity": "sha512-fDZsLYIe2uT+oGFnuZmy73K6ZxOPG/Qcm+w7jbEjaFcJgbQ6cqjs/eSPzXhsmGpAsWPkqZM9pYjww5QTn3LHMA==",
-      "dev": true,
-      "requires": {
-        "unist-util-visit": "^2.0.0"
-      }
-    },
     "unist-util-select": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/unist-util-select/-/unist-util-select-3.0.1.tgz",
-      "integrity": "sha512-VQpTuqZVJlRbosQdnLdTPIIqwZeU70YZ5aMBOqtFNGeeCdYn6ORZt/9RiaVlbl06ocuf58SVMoFa7a13CSGPMA==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-select/-/unist-util-select-4.0.0.tgz",
+      "integrity": "sha512-UJsER0ubbBy8KR+5zZpcF/9/aApWOzjNqfseMjcw1h0wAUqbxAf56mMewspAqXtGKiwBylnYB+PbD/XqwcYrWg==",
       "dev": true,
       "requires": {
         "css-selector-parser": "^1.0.0",
-        "not": "^0.1.0",
-        "nth-check": "^1.0.0",
-        "unist-util-is": "^4.0.0",
-        "zwitch": "^1.0.0"
+        "nth-check": "^2.0.0",
+        "unist-util-is": "^5.0.0",
+        "zwitch": "^2.0.0"
       },
       "dependencies": {
         "unist-util-is": {
-          "version": "4.0.2",
-          "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.0.2.tgz",
-          "integrity": "sha512-Ofx8uf6haexJwI1gxWMGg6I/dLnF2yE+KibhD3/diOqY2TinLcqHXCV6OI5gFVn3xQqDH+u0M625pfKwIwgBKQ==",
+          "version": "5.1.0",
+          "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.0.tgz",
+          "integrity": "sha512-pWspZ+AvTqYbC+xWeRmzGqbcY8Na08Eowlfs2xchWTYot8vBBAq+syrE/LWS0bw1D/JOu4lwzDbEb6Mz13tK+g==",
+          "dev": true
+        },
+        "zwitch": {
+          "version": "2.0.2",
+          "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.2.tgz",
+          "integrity": "sha512-JZxotl7SxAJH0j7dN4pxsTV6ZLXoLdGME+PsjkL/DaBrVryK9kTGq06GfKrwcSOqypP+fdXGoCHE36b99fWVoA==",
           "dev": true
         }
       }
@@ -833,59 +2175,60 @@
       }
     },
     "unist-util-visit": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
-      "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-3.1.0.tgz",
+      "integrity": "sha512-Szoh+R/Ll68QWAyQyZZpQzZQm2UPbxibDvaY8Xc9SUtYgPsDzx5AWSk++UUt2hJuow8mvwR+rG+LQLw+KsuAKA==",
       "dev": true,
       "requires": {
         "@types/unist": "^2.0.0",
-        "unist-util-is": "^4.0.0",
-        "unist-util-visit-parents": "^3.0.0"
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^4.0.0"
       },
       "dependencies": {
         "unist-util-is": {
-          "version": "4.0.2",
-          "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.0.2.tgz",
-          "integrity": "sha512-Ofx8uf6haexJwI1gxWMGg6I/dLnF2yE+KibhD3/diOqY2TinLcqHXCV6OI5gFVn3xQqDH+u0M625pfKwIwgBKQ==",
+          "version": "5.1.0",
+          "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.0.tgz",
+          "integrity": "sha512-pWspZ+AvTqYbC+xWeRmzGqbcY8Na08Eowlfs2xchWTYot8vBBAq+syrE/LWS0bw1D/JOu4lwzDbEb6Mz13tK+g==",
           "dev": true
+        },
+        "unist-util-visit-parents": {
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz",
+          "integrity": "sha512-1xAFJXAKpnnJl8G7K5KgU7FY55y3GcLIXqkzUj5QF/QVP7biUm0K0O2oqVkYsdjzJKifYeWn9+o6piAK2hGSHw==",
+          "dev": true,
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-is": "^5.0.0"
+          }
         }
       }
     },
     "unist-util-visit-parents": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.1.0.tgz",
-      "integrity": "sha512-0g4wbluTF93npyPrp/ymd3tCDTMnP0yo2akFD2FIBAYXq/Sga3lwaU1D8OYKbtpioaI6CkDcQ6fsMnmtzt7htw==",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.1.1.tgz",
+      "integrity": "sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg==",
       "dev": true,
       "requires": {
         "@types/unist": "^2.0.0",
         "unist-util-is": "^4.0.0"
-      },
-      "dependencies": {
-        "unist-util-is": {
-          "version": "4.0.2",
-          "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.0.2.tgz",
-          "integrity": "sha512-Ofx8uf6haexJwI1gxWMGg6I/dLnF2yE+KibhD3/diOqY2TinLcqHXCV6OI5gFVn3xQqDH+u0M625pfKwIwgBKQ==",
-          "dev": true
-        }
       }
     },
     "vfile": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/vfile/-/vfile-4.2.0.tgz",
-      "integrity": "sha512-a/alcwCvtuc8OX92rqqo7PflxiCgXRFjdyoGVuYV+qbgCb0GgZJRvIgCD4+U/Kl1yhaRsaTwksF88xbPyGsgpw==",
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-4.2.1.tgz",
+      "integrity": "sha512-O6AE4OskCG5S1emQ/4gl8zK586RqA3srz3nfK/Viy0UPToBc5Trp9BVFb1u0CjsKrAWwnpr4ifM/KBXPWwJbCA==",
       "dev": true,
       "requires": {
         "@types/unist": "^2.0.0",
         "is-buffer": "^2.0.0",
-        "replace-ext": "1.0.0",
         "unist-util-stringify-position": "^2.0.0",
         "vfile-message": "^2.0.0"
       }
     },
     "vfile-location": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.1.0.tgz",
-      "integrity": "sha512-FCZ4AN9xMcjFIG1oGmZKo61PjwJHRVA+0/tPUP2ul4uIwjGGndIxavEMRpWn5p4xwm/ZsdXp9YNygf1ZyE4x8g==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.2.0.tgz",
+      "integrity": "sha512-aLEIZKv/oxuCDZ8lkJGhuhztf/BW4M+iHdCwglA/eWc+vtuRFJj8EtgceYFX4LRjOhCAAiNHsKGssC6onJ+jbA==",
       "dev": true
     },
     "vfile-message": {
@@ -904,12 +2247,6 @@
       "integrity": "sha512-wYxSGajtmoP4WxfejAPIr4l0fVh+jeMXZb08wNc0tMg6xsfZXj3cECqIK0G7ZAqUq0PP8WlMDtaOGVBTAWztNw==",
       "dev": true
     },
-    "wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
-      "dev": true
-    },
     "xtend": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
diff --git a/tools/doc/package.json b/tools/doc/package.json
index e3e60831a85e572a2e8a7750b506abc1fa393876..92ac19660d5b421ebf36c1d140c96516777d2ebf 100644
--- a/tools/doc/package.json
+++ b/tools/doc/package.json
@@ -4,22 +4,24 @@
   "description": "Internal tool for generating Node.js API docs",
   "version": "0.0.0",
   "engines": {
-    "node": ">=12.10.0"
+    "node": ">=14.8.0"
   },
   "devDependencies": {
-    "highlight.js": "10.1.0",
-    "js-yaml": "3.14.0",
-    "rehype-raw": "4.0.2",
+    "highlight.js": "11.0.1",
+    "js-yaml": "4.1.0",
+    "rehype-raw": "5.1.0",
     "rehype-stringify": "8.0.0",
-    "remark-html": "12.0.0",
-    "remark-parse": "8.0.3",
-    "remark-rehype": "7.0.0",
-    "to-vfile": "6.1.0",
-    "unified": "9.2.0",
-    "unist-util-find": "1.0.1",
-    "unist-util-select": "3.0.1",
-    "unist-util-visit": "2.0.3"
+    "remark-frontmatter": "^3.0.0",
+    "remark-gfm": "^1.0.0",
+    "remark-html": "13.0.1",
+    "remark-parse": "^9.0.0",
+    "remark-rehype": "8.1.0",
+    "to-vfile": "7.1.0",
+    "unified": "9.2.1",
+    "unist-util-select": "4.0.0",
+    "unist-util-visit": "3.1.0"
   },
-  "optionalDependencies": {},
-  "bin": "./generate.js"
+  "bin": {
+    "node-doc-generator": "generate.js"
+  }
 }
diff --git a/tools/doc/stability.mjs b/tools/doc/stability.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..6b5f182a76e7e0de0765455c2280889cd0057de5
--- /dev/null
+++ b/tools/doc/stability.mjs
@@ -0,0 +1,112 @@
+// Build stability table to documentation.html/json/md by generated all.json
+
+import fs from 'fs';
+
+import raw from 'rehype-raw';
+import htmlStringify from 'rehype-stringify';
+import gfm from 'remark-gfm';
+import markdown from 'remark-parse';
+import remark2rehype from 'remark-rehype';
+import unified from 'unified';
+import { visit } from 'unist-util-visit';
+
+const source = new URL('../../out/doc/api/', import.meta.url);
+const data = JSON.parse(fs.readFileSync(new URL('./all.json', source), 'utf8'));
+const markBegin = '<!-- STABILITY_OVERVIEW_SLOT_BEGIN -->';
+const markEnd = '<!-- STABILITY_OVERVIEW_SLOT_END -->';
+const mark = `${markBegin}(.*)${markEnd}`;
+
+const output = {
+  json: new URL('./stability.json', source),
+  docHTML: new URL('./documentation.html', source),
+  docJSON: new URL('./documentation.json', source),
+  docMarkdown: new URL('./documentation.md', source),
+};
+
+function collectStability(data) {
+  const stability = [];
+
+  for (const mod of data.modules) {
+    if (mod.displayName && mod.stability >= 0) {
+      const link = mod.source.replace('doc/api/', '').replace('.md', '.html');
+
+      stability.push({
+        api: mod.name,
+        link: link,
+        stability: mod.stability,
+        stabilityText: `(${mod.stability}) ${mod.stabilityText}`,
+      });
+    }
+  }
+
+  stability.sort((a, b) => a.api.localeCompare(b.api));
+  return stability;
+}
+
+function createMarkdownTable(data) {
+  const md = ['| API | Stability |', '| --- | --------- |'];
+
+  for (const mod of data) {
+    md.push(`| [${mod.api}](${mod.link}) | ${mod.stabilityText} |`);
+  }
+
+  return md.join('\n');
+}
+
+function createHTML(md) {
+  const file = unified()
+    .use(markdown)
+    .use(gfm)
+    .use(remark2rehype, { allowDangerousHtml: true })
+    .use(raw)
+    .use(htmlStringify)
+    .use(processStability)
+    .processSync(md);
+
+  return file.contents.trim();
+}
+
+function processStability() {
+  return (tree) => {
+    visit(tree, { type: 'element', tagName: 'tr' }, (node) => {
+      const [api, stability] = node.children;
+      if (api.tagName !== 'td') {
+        return;
+      }
+
+      api.properties.class = 'module_stability';
+
+      const level = stability.children[0].value[1];
+      stability.properties.class = `api_stability api_stability_${level}`;
+    });
+  };
+}
+
+function updateStabilityMark(file, value, mark) {
+  const fd = fs.openSync(file, 'r+');
+  const content = fs.readFileSync(fd, { encoding: 'utf8' });
+
+  const replaced = content.replace(mark, value);
+  if (replaced !== content) {
+    fs.writeSync(fd, replaced, 0, 'utf8');
+  }
+  fs.closeSync(fd);
+}
+
+const stability = collectStability(data);
+
+// add markdown
+const markdownTable = createMarkdownTable(stability);
+updateStabilityMark(output.docMarkdown,
+                    `${markBegin}\n${markdownTable}\n${markEnd}`,
+                    new RegExp(mark, 's'));
+
+// add html table
+const html = createHTML(markdownTable);
+updateStabilityMark(output.docHTML, `${markBegin}${html}${markEnd}`,
+                    new RegExp(mark, 's'));
+
+// add json output
+updateStabilityMark(output.docJSON,
+                    JSON.stringify(`${markBegin}${html}${markEnd}`),
+                    new RegExp(JSON.stringify(mark), 's'));
diff --git a/tools/doc/type-parser.js b/tools/doc/type-parser.mjs
similarity index 85%
rename from tools/doc/type-parser.js
rename to tools/doc/type-parser.mjs
index 256b262b280b4c683c9e48bdf84b488b5de7e8ad..ca937453543049dd4855c060f0a2f05164ca63b7 100644
--- a/tools/doc/type-parser.js
+++ b/tools/doc/type-parser.mjs
@@ -1,5 +1,3 @@
-'use strict';
-
 const jsDocPrefix = 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/';
 
 const jsDataStructuresUrl = `${jsDocPrefix}Data_structures`;
@@ -26,15 +24,22 @@ const customTypesMap = {
 
   'this': `${jsDocPrefix}Reference/Operators/this`,
 
+  'AbortController': 'globals.html#globals_class_abortcontroller',
+  'AbortSignal': 'globals.html#globals_class_abortsignal',
+
   'ArrayBufferView':
     'https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView',
 
   'AsyncIterator': 'https://tc39.github.io/ecma262/#sec-asynciterator-interface',
 
+  'AsyncIterable': 'https://tc39.github.io/ecma262/#sec-asynciterable-interface',
+
   'bigint': `${jsDocPrefix}Reference/Global_Objects/BigInt`,
   'WebAssembly.Instance':
     `${jsDocPrefix}Reference/Global_Objects/WebAssembly/Instance`,
 
+  'Blob': 'buffer.html#buffer_class_blob',
+
   'Iterable':
     `${jsDocPrefix}Reference/Iteration_protocols#The_iterable_protocol`,
   'Iterator':
@@ -68,6 +73,8 @@ const customTypesMap = {
 
   'dgram.Socket': 'dgram.html#dgram_class_dgram_socket',
 
+  'Channel': 'diagnostics_channel.html#diagnostics_channel_class_channel',
+
   'Domain': 'domain.html#domain_class_domain',
 
   'errors.Error': 'errors.html#errors_class_error',
@@ -75,6 +82,9 @@ const customTypesMap = {
   'import.meta': 'esm.html#esm_import_meta',
 
   'EventEmitter': 'events.html#events_class_eventemitter',
+  'EventTarget': 'events.html#events_class_eventtarget',
+  'Event': 'events.html#events_class_event',
+  'EventListener': 'events.html#events_event_listener',
 
   'FileHandle': 'fs.html#fs_class_filehandle',
   'fs.Dir': 'fs.html#fs_class_fs_dir',
@@ -109,20 +119,29 @@ const customTypesMap = {
   'module': 'modules.html#modules_the_module_object',
 
   'module.SourceMap':
-    'modules_module.html#modules_module_class_module_sourcemap',
+    'module.html#module_class_module_sourcemap',
 
   'require': 'modules.html#modules_require_id',
 
   'Handle': 'net.html#net_server_listen_handle_backlog_callback',
+  'net.BlockList': 'net.html#net_class_net_blocklist',
   'net.Server': 'net.html#net_class_net_server',
   'net.Socket': 'net.html#net_class_net_socket',
+  'net.SocketAddress': 'net.html#net_class_net_socketaddress',
+
+  'NodeEventTarget':
+    'events.html#events_class_nodeeventtarget',
 
   'os.constants.dlopen': 'os.html#os_dlopen_constants',
 
   'Histogram': 'perf_hooks.html#perf_hooks_class_histogram',
+  'IntervalHistogram':
+     'perf_hooks.html#perf_hooks_class_intervalhistogram_extends_histogram',
+  'RecordableHistogram':
+     'perf_hooks.html#perf_hooks_class_recordablehistogram_extends_histogram',
   'PerformanceEntry': 'perf_hooks.html#perf_hooks_class_performanceentry',
   'PerformanceNodeTiming':
-    'perf_hooks.html#perf_hooks_class_performancenodetiming_extends_performanceentry', // eslint-disable-line max-len
+    'perf_hooks.html#perf_hooks_class_performancenodetiming',
   'PerformanceObserver':
     'perf_hooks.html#perf_hooks_class_perf_hooks_performanceobserver',
   'PerformanceObserverEntryList':
@@ -152,16 +171,18 @@ const customTypesMap = {
   'URLSearchParams': 'url.html#url_class_urlsearchparams',
 
   'vm.Module': 'vm.html#vm_class_vm_module',
+  'vm.Script': 'vm.html#vm_class_vm_script',
   'vm.SourceTextModule': 'vm.html#vm_class_vm_sourcetextmodule',
 
   'MessagePort': 'worker_threads.html#worker_threads_class_messageport',
+  'Worker': 'worker_threads.html#worker_threads_class_worker',
 
   'zlib options': 'zlib.html#zlib_class_options',
 };
 
 const arrayPart = /(?:\[])+$/;
 
-function toLink(typeInput) {
+export function toLink(typeInput) {
   const typeLinks = [];
   typeInput = typeInput.replace('{', '').replace('}', '');
   const typeTexts = typeInput.split('|');
@@ -192,7 +213,7 @@ function toLink(typeInput) {
       } else {
         throw new Error(
           `Unrecognized type: '${typeTextFull}'.\n` +
-          "Please, edit the type or update the 'tools/doc/type-parser.js'."
+          `Please, edit the type or update '${import.meta.url}'.`
         );
       }
     } else {
@@ -202,5 +223,3 @@ function toLink(typeInput) {
 
   return typeLinks.length ? typeLinks.join(' | ') : typeInput;
 }
-
-module.exports = { toLink };
diff --git a/tools/doc/versions.js b/tools/doc/versions.mjs
similarity index 85%
rename from tools/doc/versions.js
rename to tools/doc/versions.mjs
index 52f5648ecae92fe4b70cbfbb09a16c0f76280159..ec623a2dbd206eeef8069204cca2582a39559bf0 100644
--- a/tools/doc/versions.js
+++ b/tools/doc/versions.mjs
@@ -1,18 +1,16 @@
-'use strict';
+import { readFileSync, writeFileSync } from 'fs';
+import https from 'https';
 
-const { readFileSync, writeFileSync } = require('fs');
-const path = require('path');
-const srcRoot = path.join(__dirname, '..', '..');
+const srcRoot = new URL('../../', import.meta.url);
 
 const isRelease = () => {
   const re = /#define NODE_VERSION_IS_RELEASE 0/;
-  const file = path.join(srcRoot, 'src', 'node_version.h');
+  const file = new URL('./src/node_version.h', srcRoot);
   return !re.test(readFileSync(file, { encoding: 'utf8' }));
 };
 
 const getUrl = (url) => {
   return new Promise((resolve, reject) => {
-    const https = require('https');
     const request = https.get(url, { timeout: 30000 }, (response) => {
       if (response.statusCode !== 200) {
         reject(new Error(
@@ -36,9 +34,9 @@ async function versions() {
   // The CHANGELOG.md on release branches may not reference newer semver
   // majors of Node.js so fetch and parse the version from the master branch.
   const url =
-    'https://raw.githubusercontent.com/nodejs/node/master/CHANGELOG.md';
+    'https://raw.githubusercontent.com/nodejs/node/HEAD/CHANGELOG.md';
   let changelog;
-  const file = path.join(srcRoot, 'CHANGELOG.md');
+  const file = new URL('./CHANGELOG.md', srcRoot);
   if (kNoInternet) {
     changelog = readFileSync(file, { encoding: 'utf8' });
   } else {
diff --git a/tools/find-inactive-collaborators.mjs b/tools/find-inactive-collaborators.mjs
new file mode 100755
index 0000000000000000000000000000000000000000..9f7ac239d2df01aa9b4e04ccaddd943a7e9aacfa
--- /dev/null
+++ b/tools/find-inactive-collaborators.mjs
@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+// Identify inactive collaborators. "Inactive" is not quite right, as the things
+// this checks for are not the entirety of collaborator activities. Still, it is
+// a pretty good proxy. Feel free to suggest or implement further metrics.
+
+import cp from 'node:child_process';
+import fs from 'node:fs';
+import readline from 'node:readline';
+
+const SINCE = +process.argv[2] || 5000;
+
+async function runGitCommand(cmd, mapFn) {
+  const childProcess = cp.spawn('/bin/sh', ['-c', cmd], {
+    cwd: new URL('..', import.meta.url),
+    encoding: 'utf8',
+    stdio: ['inherit', 'pipe', 'inherit'],
+  });
+  const lines = readline.createInterface({
+    input: childProcess.stdout,
+  });
+  const errorHandler = new Promise(
+    (_, reject) => childProcess.on('error', reject)
+  );
+  let returnValue = mapFn ? new Set() : '';
+  await Promise.race([errorHandler, Promise.resolve()]);
+  // If no mapFn, return the value. If there is a mapFn, use it to make a Set to
+  // return.
+  for await (const line of lines) {
+    await Promise.race([errorHandler, Promise.resolve()]);
+    if (mapFn) {
+      const val = mapFn(line);
+      if (val) {
+        returnValue.add(val);
+      }
+    } else {
+      returnValue += line;
+    }
+  }
+  return Promise.race([errorHandler, Promise.resolve(returnValue)]);
+}
+
+// Get all commit authors during the time period.
+const authors = await runGitCommand(
+  `git shortlog -n -s --email --max-count="${SINCE}" HEAD`,
+  (line) => line.trim().split('\t', 2)[1]
+);
+
+// Get all commit landers during the time period.
+const landers = await runGitCommand(
+  `git shortlog -n -s -c --email --max-count="${SINCE}" HEAD`,
+  (line) => line.trim().split('\t', 2)[1]
+);
+
+// Get all approving reviewers of landed commits during the time period.
+const approvingReviewers = await runGitCommand(
+  `git log --max-count="${SINCE}" | egrep "^    Reviewed-By: "`,
+  (line) => /^    Reviewed-By: ([^<]+)/.exec(line)[1].trim()
+);
+
+async function getCollaboratorsFromReadme() {
+  const readmeText = readline.createInterface({
+    input: fs.createReadStream(new URL('../README.md', import.meta.url)),
+    crlfDelay: Infinity,
+  });
+  const returnedArray = [];
+  let foundCollaboratorHeading = false;
+  for await (const line of readmeText) {
+    // If we've found the collaborator heading already, stop processing at the
+    // next heading.
+    if (foundCollaboratorHeading && line.startsWith('#')) {
+      break;
+    }
+
+    const isCollaborator = foundCollaboratorHeading && line.length;
+
+    if (line === '### Collaborators') {
+      foundCollaboratorHeading = true;
+    }
+    if (line.startsWith('**') && isCollaborator) {
+      const [, name, email] = /^\*\*([^*]+)\*\* &lt;(.+)&gt;/.exec(line);
+      const mailmap = await runGitCommand(
+        `git check-mailmap '${name} <${email}>'`
+      );
+      if (mailmap !== `${name} <${email}>`) {
+        console.log(`README entry for Collaborator does not match mailmap:\n  ${name} <${email}> => ${mailmap}`);
+      }
+      returnedArray.push({
+        name,
+        email,
+        mailmap,
+      });
+    }
+  }
+
+  if (!foundCollaboratorHeading) {
+    throw new Error('Could not find Collaborator section of README');
+  }
+
+  return returnedArray;
+}
+
+async function moveCollaboratorToEmeritus(peopleToMove) {
+  const readmeText = readline.createInterface({
+    input: fs.createReadStream(new URL('../README.md', import.meta.url)),
+    crlfDelay: Infinity,
+  });
+  let fileContents = '';
+  let inCollaboratorsSection = false;
+  let inCollaboratorEmeritusSection = false;
+  let collaboratorFirstLine = '';
+  const textToMove = [];
+  for await (const line of readmeText) {
+    // If we've been processing collaborator emeriti and we reach the end of
+    // the list, print out the remaining entries to be moved because they come
+    // alphabetically after the last item.
+    if (inCollaboratorEmeritusSection && line === '' &&
+        fileContents.endsWith('&gt;\n')) {
+      while (textToMove.length) {
+        fileContents += textToMove.pop();
+      }
+    }
+
+    // If we've found the collaborator heading already, stop processing at the
+    // next heading.
+    if (line.startsWith('#')) {
+      inCollaboratorsSection = false;
+      inCollaboratorEmeritusSection = false;
+    }
+
+    const isCollaborator = inCollaboratorsSection && line.length;
+    const isCollaboratorEmeritus = inCollaboratorEmeritusSection && line.length;
+
+    if (line === '### Collaborators') {
+      inCollaboratorsSection = true;
+    }
+    if (line === '### Collaborator emeriti') {
+      inCollaboratorEmeritusSection = true;
+    }
+
+    if (isCollaborator) {
+      if (line.startsWith('* ')) {
+        collaboratorFirstLine = line;
+      } else if (line.startsWith('**')) {
+        const [, name, email] = /^\*\*([^*]+)\*\* &lt;(.+)&gt;/.exec(line);
+        if (peopleToMove.some((entry) => {
+          return entry.name === name && entry.email === email;
+        })) {
+          textToMove.push(`${collaboratorFirstLine}\n${line}\n`);
+        } else {
+          fileContents += `${collaboratorFirstLine}\n${line}\n`;
+        }
+      } else {
+        fileContents += `${line}\n`;
+      }
+    }
+
+    if (isCollaboratorEmeritus) {
+      if (line.startsWith('* ')) {
+        collaboratorFirstLine = line;
+      } else if (line.startsWith('**')) {
+        const currentLine = `${collaboratorFirstLine}\n${line}\n`;
+        // If textToMove is empty, this still works because when undefined is
+        // used in a comparison with <, the result is always false.
+        while (textToMove[0] < currentLine) {
+          fileContents += textToMove.shift();
+        }
+        fileContents += currentLine;
+      } else {
+        fileContents += `${line}\n`;
+      }
+    }
+
+    if (!isCollaborator && !isCollaboratorEmeritus) {
+      fileContents += `${line}\n`;
+    }
+  }
+
+  return fileContents;
+}
+
+// Get list of current collaborators from README.md.
+const collaborators = await getCollaboratorsFromReadme();
+
+console.log(`In the last ${SINCE} commits:\n`);
+console.log(`* ${authors.size.toLocaleString()} authors have made commits.`);
+console.log(`* ${landers.size.toLocaleString()} landers have landed commits.`);
+console.log(`* ${approvingReviewers.size.toLocaleString()} reviewers have approved landed commits.`);
+console.log(`* ${collaborators.length.toLocaleString()} collaborators currently in the project.`);
+
+const inactive = collaborators.filter((collaborator) =>
+  !authors.has(collaborator.mailmap) &&
+  !landers.has(collaborator.mailmap) &&
+  !approvingReviewers.has(collaborator.name)
+);
+
+if (inactive.length) {
+  console.log('\nInactive collaborators:\n');
+  console.log(inactive.map((entry) => `* ${entry.name}`).join('\n'));
+  console.log('\nGenerating new README.md file...');
+  const newReadmeText = await moveCollaboratorToEmeritus(inactive);
+  fs.writeFileSync(new URL('../README.md', import.meta.url), newReadmeText);
+  console.log('Updated README.md generated. Please commit these changes.');
+}
diff --git a/tools/genv8constants.py b/tools/genv8constants.py
index 8ab2ed8bae50c02cc7db77470325d000ca34d0bc..01aa37cc715de0452941ceb14ff067d6e58972dd 100755
--- a/tools/genv8constants.py
+++ b/tools/genv8constants.py
@@ -14,7 +14,7 @@ import sys
 import errno
 
 if len(sys.argv) != 3:
-  print("usage: objsym.py outfile libv8_base.a")
+  print("Usage: genv8constants.py outfile libv8_base.a")
   sys.exit(2)
 
 outfile = open(sys.argv[1], 'w')
@@ -73,6 +73,7 @@ def out_define():
   out_reset()
 
 for line in pipe:
+  line = line.decode('utf-8')
   if curr_sym != None:
     #
     # This bit of code has nasty knowledge of the objdump text output
@@ -95,7 +96,7 @@ for line in pipe:
       curr_octet += 1
 
   match = pattern.match(line)
-  if match == None:
+  if match is None:
     continue
 
   # Print previous symbol
@@ -113,3 +114,5 @@ outfile.write("""
 
 #endif /* V8_CONSTANTS_H */
 """)
+
+outfile.close()
diff --git a/tools/gyp/.flake8 b/tools/gyp/.flake8
new file mode 100644
index 0000000000000000000000000000000000000000..ea0c7680ef87b24641f43389d183879ab9de0cb7
--- /dev/null
+++ b/tools/gyp/.flake8
@@ -0,0 +1,4 @@
+[flake8]
+max-complexity = 101
+max-line-length = 88
+extend-ignore = E203  # whitespace before ':' to agree with psf/black
diff --git a/tools/gyp/.github/workflows/Python_tests.yml b/tools/gyp/.github/workflows/Python_tests.yml
new file mode 100644
index 0000000000000000000000000000000000000000..128654f3121d76f76f24163490a0125ce174bdee
--- /dev/null
+++ b/tools/gyp/.github/workflows/Python_tests.yml
@@ -0,0 +1,31 @@
+# TODO: Enable os: windows-latest
+# TODO: Enable python-version: 3.5
+# TODO: Enable pytest --doctest-modules
+
+name: Python_tests
+on: [push, pull_request]
+jobs:
+  Python_tests:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      max-parallel: 15
+      matrix:
+        os: [macos-latest, ubuntu-latest] # , windows-latest]
+        python-version: [2.7, 3.6, 3.7, 3.8, 3.9]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements_dev.txt
+      - name: Lint with flake8
+        run: flake8 . --count --show-source --statistics
+      - name: Test with pytest
+        run: pytest
+      # - name: Run doctests with pytest
+      #   run: pytest --doctest-modules
diff --git a/tools/gyp/.github/workflows/node-gyp.yml b/tools/gyp/.github/workflows/node-gyp.yml
new file mode 100644
index 0000000000000000000000000000000000000000..78fe502bda062fc34cc15eae81ddac02080353c2
--- /dev/null
+++ b/tools/gyp/.github/workflows/node-gyp.yml
@@ -0,0 +1,40 @@
+name: node-gyp integration
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Clone gyp-next
+        uses: actions/checkout@v2
+        with:
+          path: gyp-next
+      - name: Clone nodejs/node-gyp
+        uses: actions/checkout@v2
+        with:
+          repository: nodejs/node-gyp
+          path: node-gyp
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 14.x
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.9
+      - name: Install dependencies
+        run: |
+          cd node-gyp
+          npm install --no-progress
+      - name: Replace gyp in node-gyp
+        shell: bash
+        run: |
+          rm -rf node-gyp/gyp
+          cp -r gyp-next node-gyp/gyp
+      - name: Run tests
+        run: |
+          cd node-gyp
+          npm test
diff --git a/tools/gyp/.github/workflows/nodejs-windows.yml b/tools/gyp/.github/workflows/nodejs-windows.yml
new file mode 100644
index 0000000000000000000000000000000000000000..fffe96e33b815e0c380778980d6496b1650eefa2
--- /dev/null
+++ b/tools/gyp/.github/workflows/nodejs-windows.yml
@@ -0,0 +1,27 @@
+name: Node.js Windows integration
+
+on: [push, pull_request]
+
+jobs:
+  build-windows:
+    runs-on: windows-latest
+    steps:
+      - name: Clone gyp-next
+        uses: actions/checkout@v2
+        with:
+          path: gyp-next
+      - name: Clone nodejs/node
+        uses: actions/checkout@v2
+        with:
+          repository: nodejs/node
+          path: node
+      - name: Install deps
+        run: choco install nasm
+      - name: Replace gyp in Node.js
+        run: |
+          rm -Recurse node/tools/gyp
+          cp -Recurse gyp-next node/tools/gyp
+      - name: Build Node.js
+        run: |
+          cd node
+          ./vcbuild.bat
diff --git a/tools/gyp/.github/workflows/release-please.yml b/tools/gyp/.github/workflows/release-please.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a414c10e1563606bc9119b3fa9941190a02b2973
--- /dev/null
+++ b/tools/gyp/.github/workflows/release-please.yml
@@ -0,0 +1,16 @@
+on:
+  push:
+    branches:
+      - master
+
+name: release-please
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: GoogleCloudPlatform/release-please-action@v2.5.6
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          release-type: python
+          package-name: gyp-next
+          bump-minor-pre-major: Yes
diff --git a/tools/gyp/.gitignore b/tools/gyp/.gitignore
index 0d20b6487c61e7d1bde93acf4a14b7a89083a16d..d82fa7a96c90159c0dba3052f3a09284f027a1a7 100644
--- a/tools/gyp/.gitignore
+++ b/tools/gyp/.gitignore
@@ -1 +1,143 @@
-*.pyc
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# static files generated from Django application using `collectstatic`
+media
+static
diff --git a/tools/gyp/AUTHORS b/tools/gyp/AUTHORS
index 130c81605893641ff5232bec953d157dc32a1e67..f49a357b9ed10465d5abe5288ca9dc7dabb04c61 100644
--- a/tools/gyp/AUTHORS
+++ b/tools/gyp/AUTHORS
@@ -13,3 +13,4 @@ Eric N. Vander Weele <ericvw@gmail.com>
 Tom Freudenberg <th.freudenberg@gmail.com>
 Julien Brianceau <jbriance@cisco.com>
 Refael Ackermann <refack@gmail.com>
+Ujjwal Sharma <ryzokuken@disroot.org>
diff --git a/tools/gyp/CHANGELOG.md b/tools/gyp/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..794036769506715a5307a04573e95821f1d687d5
--- /dev/null
+++ b/tools/gyp/CHANGELOG.md
@@ -0,0 +1,89 @@
+# Changelog
+
+## [0.7.0](https://www.github.com/nodejs/gyp-next/compare/v0.6.2...v0.7.0) (2020-12-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* **msvs:** On Windows, arguments passed to the "action" commands are no longer transformed to replace slashes with backslashes.
+
+### Features
+
+* **xcode:** --cross-compiling overrides arch-specific settings ([973bae0](https://www.github.com/nodejs/gyp-next/commit/973bae0b7b08be7b680ecae9565fbd04b3e0787d))
+
+
+### Bug Fixes
+
+* **msvs:** do not fix paths in action command arguments ([fc22f83](https://www.github.com/nodejs/gyp-next/commit/fc22f8335e2016da4aae4f4233074bd651d2faea))
+* cmake on python 3 ([fd61f5f](https://www.github.com/nodejs/gyp-next/commit/fd61f5faa5275ec8fc98e3c7868c0dd46f109540))
+* ValueError: invalid mode: 'rU' while trying to load binding.gyp ([d0504e6](https://www.github.com/nodejs/gyp-next/commit/d0504e6700ce48f44957a4d5891b142a60be946f))
+* xcode cmake parsing ([eefe8d1](https://www.github.com/nodejs/gyp-next/commit/eefe8d10e99863bc4ac7e2ed32facd608d400d4b))
+
+### [0.6.2](https://www.github.com/nodejs/gyp-next/compare/v0.6.1...v0.6.2) (2020-10-16)
+
+
+### Bug Fixes
+
+* do not rewrite absolute paths to avoid long paths ([#74](https://www.github.com/nodejs/gyp-next/issues/74)) ([c2ccc1a](https://www.github.com/nodejs/gyp-next/commit/c2ccc1a81f7f94433a94f4d01a2e820db4c4331a))
+* only include MARMASM when toolset is target ([5a2794a](https://www.github.com/nodejs/gyp-next/commit/5a2794aefb58f0c00404ff042b61740bc8b8d5cd))
+
+### [0.6.1](https://github.com/nodejs/gyp-next/compare/v0.6.0...v0.6.1) (2020-10-14)
+
+
+### Bug Fixes
+
+* Correctly rename object files for absolute paths in MSVS generator.
+
+## [0.6.0](https://github.com/nodejs/gyp-next/compare/v0.5.0...v0.6.0) (2020-10-13)
+
+
+### Features
+
+* The Makefile generator will now output shared libraries directly to the product directory on all platforms (previously only macOS).
+
+## [0.5.0](https://github.com/nodejs/gyp-next/compare/v0.4.0...v0.5.0) (2020-09-30)
+
+
+### Features
+
+* Extended compile_commands_json generator to consider more file extensions than just `c` and `cc`. `cpp` and `cxx` are now supported.
+* Source files with duplicate basenames are now supported.
+
+### Removed
+
+* The `--no-duplicate-basename-check` option was removed.
+* The `msvs_enable_marmasm` configuration option was removed in favor of auto-inclusion of the "marmasm" sections for Windows on ARM.
+
+## [0.4.0](https://github.com/nodejs/gyp-next/compare/v0.3.0...v0.4.0) (2020-07-14)
+
+
+### Features
+
+* Added support for passing arbitrary architectures to Xcode builds, enables `arm64` builds.
+
+### Bug Fixes
+
+* Fixed a bug on Solaris where copying archives failed.
+
+## [0.3.0](https://github.com/nodejs/gyp-next/compare/v0.2.1...v0.3.0) (2020-06-06)
+
+
+### Features
+
+* Added support for MSVC cross-compilation. This allows compilation on x64 for a Windows ARM target.
+
+### Bug Fixes
+
+* Fixed XCode CLT version detection on macOS Catalina.
+
+### [0.2.1](https://github.com/nodejs/gyp-next/compare/v0.2.0...v0.2.1) (2020-05-05)
+
+
+### Bug Fixes
+
+* Relicensed to Node.js contributors.
+* Fixed Windows bug introduced in v0.2.0.
+
+## [0.2.0](https://github.com/nodejs/gyp-next/releases/tag/v0.2.0) (2020-04-06)
+
+This is the first release of this project, based on https://chromium.googlesource.com/external/gyp with changes made over the years in Node.js and node-gyp.
diff --git a/tools/gyp/CODE_OF_CONDUCT.md b/tools/gyp/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000000000000000000000000000000000..4c211405596cb42eac87cbf2c90c2764766fbb18
--- /dev/null
+++ b/tools/gyp/CODE_OF_CONDUCT.md
@@ -0,0 +1,4 @@
+# Code of Conduct
+
+* [Node.js Code of Conduct](https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md)
+* [Node.js Moderation Policy](https://github.com/nodejs/admin/blob/master/Moderation-Policy.md)
diff --git a/tools/gyp/CONTRIBUTING.md b/tools/gyp/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..f9dd574a47cd9dfc092d10d4ec22593d936c777a
--- /dev/null
+++ b/tools/gyp/CONTRIBUTING.md
@@ -0,0 +1,32 @@
+# Contributing to gyp-next
+
+## Code of Conduct
+
+This project is bound to the [Node.js Code of Conduct](https://github.com/nodejs/admin/blob/master/CODE_OF_CONDUCT.md).
+
+<a id="developers-certificate-of-origin"></a>
+## Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+* (a) The contribution was created in whole or in part by me and I
+  have the right to submit it under the open source license
+  indicated in the file; or
+
+* (b) The contribution is based upon previous work that, to the best
+  of my knowledge, is covered under an appropriate open source
+  license and I have the right under that license to submit that
+  work with modifications, whether created in whole or in part
+  by me, under the same open source license (unless I am
+  permitted to submit under a different license), as indicated
+  in the file; or
+
+* (c) The contribution was provided directly to me by some other
+  person who certified (a), (b) or (c) and I have not modified
+  it.
+
+* (d) I understand and agree that this project and the contribution
+  are public and that a record of the contribution (including all
+  personal information I submit with it, including my sign-off) is
+  maintained indefinitely and may be redistributed consistent with
+  this project or the open source license(s) involved.
diff --git a/tools/gyp/LICENSE b/tools/gyp/LICENSE
index ab6b011a109335d7bb8604d49be0d185f34d1744..c6944c5e4ed488c54e2a8f4963ab8492d0cfa7dd 100644
--- a/tools/gyp/LICENSE
+++ b/tools/gyp/LICENSE
@@ -1,3 +1,4 @@
+Copyright (c) 2020 Node.js contributors. All rights reserved.
 Copyright (c) 2009 Google Inc. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/tools/gyp/OWNERS b/tools/gyp/OWNERS
deleted file mode 100644
index 72e8ffc0db8aad71a934dd11e5968bd5109e54b4..0000000000000000000000000000000000000000
--- a/tools/gyp/OWNERS
+++ /dev/null
@@ -1 +0,0 @@
-*
diff --git a/tools/gyp/PRESUBMIT.py b/tools/gyp/PRESUBMIT.py
deleted file mode 100644
index e52f9d2d22d6079e2ef6ec1d0dcedbde5fb9aa8e..0000000000000000000000000000000000000000
--- a/tools/gyp/PRESUBMIT.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# Copyright (c) 2012 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-
-"""Top-level presubmit script for GYP.
-
-See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
-for more details about the presubmit API built into gcl.
-"""
-
-
-PYLINT_BLACKLIST = [
-    # TODO: fix me.
-    # From SCons, not done in google style.
-    'test/lib/TestCmd.py',
-    'test/lib/TestCommon.py',
-    'test/lib/TestGyp.py',
-]
-
-
-PYLINT_DISABLED_WARNINGS = [
-    # TODO: fix me.
-    # Many tests include modules they don't use.
-    'W0611',
-    # Possible unbalanced tuple unpacking with sequence.
-    'W0632',
-    # Attempting to unpack a non-sequence.
-    'W0633',
-    # Include order doesn't properly include local files?
-    'F0401',
-    # Some use of built-in names.
-    'W0622',
-    # Some unused variables.
-    'W0612',
-    # Operator not preceded/followed by space.
-    'C0323',
-    'C0322',
-    # Unnecessary semicolon.
-    'W0301',
-    # Unused argument.
-    'W0613',
-    # String has no effect (docstring in wrong place).
-    'W0105',
-    # map/filter on lambda could be replaced by comprehension.
-    'W0110',
-    # Use of eval.
-    'W0123',
-    # Comma not followed by space.
-    'C0324',
-    # Access to a protected member.
-    'W0212',
-    # Bad indent.
-    'W0311',
-    # Line too long.
-    'C0301',
-    # Undefined variable.
-    'E0602',
-    # Not exception type specified.
-    'W0702',
-    # No member of that name.
-    'E1101',
-    # Dangerous default {}.
-    'W0102',
-    # Cyclic import.
-    'R0401',
-    # Others, too many to sort.
-    'W0201', 'W0232', 'E1103', 'W0621', 'W0108', 'W0223', 'W0231',
-    'R0201', 'E0101', 'C0321',
-    # ************* Module copy
-    # W0104:427,12:_test.odict.__setitem__: Statement seems to have no effect
-    'W0104',
-]
-
-
-def _LicenseHeader(input_api):
-  # Accept any year number from 2009 to the current year.
-  current_year = int(input_api.time.strftime('%Y'))
-  allowed_years = (str(s) for s in reversed(range(2009, current_year + 1)))
-  years_re = '(' + '|'.join(allowed_years) + ')'
-
-  # The (c) is deprecated, but tolerate it until it's removed from all files.
-  return (
-      r'.*? Copyright (\(c\) )?%(year)s Google Inc\. All rights reserved\.\n'
-      r'.*? Use of this source code is governed by a BSD-style license that '
-        r'can be\n'
-      r'.*? found in the LICENSE file\.\n'
-  ) % {
-      'year': years_re,
-  }
-
-def CheckChangeOnUpload(input_api, output_api):
-  report = []
-  report.extend(input_api.canned_checks.PanProjectChecks(
-      input_api, output_api, license_header=_LicenseHeader(input_api)))
-  return report
-
-
-def CheckChangeOnCommit(input_api, output_api):
-  report = []
-
-  report.extend(input_api.canned_checks.PanProjectChecks(
-      input_api, output_api, license_header=_LicenseHeader(input_api)))
-  report.extend(input_api.canned_checks.CheckTreeIsOpen(
-      input_api, output_api,
-      'http://gyp-status.appspot.com/status',
-      'http://gyp-status.appspot.com/current'))
-
-  import os
-  import sys
-  old_sys_path = sys.path
-  try:
-    sys.path = ['pylib', 'test/lib'] + sys.path
-    blacklist = PYLINT_BLACKLIST
-    if sys.platform == 'win32':
-      blacklist = [os.path.normpath(x).replace('\\', '\\\\')
-                   for x in PYLINT_BLACKLIST]
-    report.extend(input_api.canned_checks.RunPylint(
-        input_api,
-        output_api,
-        black_list=blacklist,
-        disabled_warnings=PYLINT_DISABLED_WARNINGS))
-  finally:
-    sys.path = old_sys_path
-  return report
-
-
-TRYBOTS = [
-    'linux_try',
-    'mac_try',
-    'win_try',
-]
-
-
-def GetPreferredTryMasters(_, change):
-  return {
-      'client.gyp': { t: set(['defaulttests']) for t in TRYBOTS },
-  }
diff --git a/tools/gyp/README.md b/tools/gyp/README.md
index c0d73ac9587af3d9af6b36f4cf9124dee45c10b4..9ffc2b21e81b8b8b5008246fe0d59e4b9c6c6eee 100644
--- a/tools/gyp/README.md
+++ b/tools/gyp/README.md
@@ -2,3 +2,6 @@ GYP can Generate Your Projects.
 ===================================
 
 Documents are available at [gyp.gsrc.io](https://gyp.gsrc.io), or you can check out ```md-pages``` branch to read those documents offline.
+
+__gyp-next__ is [released](https://github.com/nodejs/gyp-next/releases) to the [__Python Packaging Index__](https://pypi.org/project/gyp-next) (PyPI) and can be installed with the command:
+* `python3 -m pip install gyp-next`
diff --git a/tools/gyp/gyp_main.py b/tools/gyp/gyp_main.py
index f738e8009f71e7b6b6f5602de347597c0a56c06c..da696cfc4b1c3fff05e9190a3f4cb76ecc637a67 100755
--- a/tools/gyp/gyp_main.py
+++ b/tools/gyp/gyp_main.py
@@ -10,41 +10,42 @@ import subprocess
 
 PY3 = bytes != str
 
-# Below IsCygwin() function copied from pylib/gyp/common.py
+
 def IsCygwin():
-  try:
-    out = subprocess.Popen("uname",
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT)
-    stdout, stderr = out.communicate()
-    if PY3:
-      stdout = stdout.decode("utf-8")
-    return "CYGWIN" in str(stdout)
-  except Exception:
-    return False
+    # Function copied from pylib/gyp/common.py
+    try:
+        out = subprocess.Popen(
+            "uname", stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        stdout, stderr = out.communicate()
+        if PY3:
+            stdout = stdout.decode("utf-8")
+        return "CYGWIN" in str(stdout)
+    except Exception:
+        return False
 
 
 def UnixifyPath(path):
-  try:
-    if not IsCygwin():
-      return path
-    out = subprocess.Popen(["cygpath", "-u", path],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT)
-    stdout, _ = out.communicate()
-    if PY3:
-      stdout = stdout.decode("utf-8")
-    return str(stdout)
-  except Exception:
-    return path
+    try:
+        if not IsCygwin():
+            return path
+        out = subprocess.Popen(
+            ["cygpath", "-u", path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        stdout, _ = out.communicate()
+        if PY3:
+            stdout = stdout.decode("utf-8")
+        return str(stdout)
+    except Exception:
+        return path
 
 
 # Make sure we're using the version of pylib in this repo, not one installed
 # elsewhere on the system. Also convert to Unix style path on Cygwin systems,
 # else the 'gyp' library will not be found
 path = UnixifyPath(sys.argv[0])
-sys.path.insert(0, os.path.join(os.path.dirname(path), 'pylib'))
-import gyp
+sys.path.insert(0, os.path.join(os.path.dirname(path), "pylib"))
+import gyp  # noqa: E402
 
-if __name__ == '__main__':
-  sys.exit(gyp.script_main())
+if __name__ == "__main__":
+    sys.exit(gyp.script_main())
diff --git a/tools/gyp/pylib/gyp/MSVSNew.py b/tools/gyp/pylib/gyp/MSVSNew.py
index 740ef2c73fa71b5fcff61e9309e834a7813be52b..04bbb3df718727cf172ec78fc36ba01b48944999 100644
--- a/tools/gyp/pylib/gyp/MSVSNew.py
+++ b/tools/gyp/pylib/gyp/MSVSNew.py
@@ -12,26 +12,28 @@ from operator import attrgetter
 import gyp.common
 
 try:
-  cmp
+    cmp
 except NameError:
-  def cmp(x, y):
-    return (x > y) - (x < y)
+
+    def cmp(x, y):
+        return (x > y) - (x < y)
+
 
 # Initialize random number generator
 random.seed()
 
 # GUIDs for project types
 ENTRY_TYPE_GUIDS = {
-    'project': '{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}',
-    'folder': '{2150E333-8FDC-42A3-9474-1A3956D46DE8}',
+    "project": "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}",
+    "folder": "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
 }
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # Helper functions
 
 
-def MakeGuid(name, seed='msvs_new'):
-  """Returns a GUID for the specified target name.
+def MakeGuid(name, seed="msvs_new"):
+    """Returns a GUID for the specified target name.
 
   Args:
     name: Target name.
@@ -45,28 +47,39 @@ def MakeGuid(name, seed='msvs_new'):
   determine the GUID to refer to explicitly.  It also means that the GUID will
   not change when the project for a target is rebuilt.
   """
-  # Calculate a MD5 signature for the seed and name.
-  d = hashlib.md5((str(seed) + str(name)).encode('utf-8')).hexdigest().upper()
-  # Convert most of the signature to GUID form (discard the rest)
-  guid = ('{' + d[:8] + '-' + d[8:12] + '-' + d[12:16] + '-' + d[16:20]
-          + '-' + d[20:32] + '}')
-  return guid
-
-#------------------------------------------------------------------------------
+    # Calculate a MD5 signature for the seed and name.
+    d = hashlib.md5((str(seed) + str(name)).encode("utf-8")).hexdigest().upper()
+    # Convert most of the signature to GUID form (discard the rest)
+    guid = (
+        "{"
+        + d[:8]
+        + "-"
+        + d[8:12]
+        + "-"
+        + d[12:16]
+        + "-"
+        + d[16:20]
+        + "-"
+        + d[20:32]
+        + "}"
+    )
+    return guid
+
+
+# ------------------------------------------------------------------------------
 
 
 class MSVSSolutionEntry(object):
-  def __cmp__(self, other):
-    # Sort by name then guid (so things are in order on vs2008).
-    return cmp((self.name, self.get_guid()), (other.name, other.get_guid()))
+    def __cmp__(self, other):
+        # Sort by name then guid (so things are in order on vs2008).
+        return cmp((self.name, self.get_guid()), (other.name, other.get_guid()))
 
 
 class MSVSFolder(MSVSSolutionEntry):
-  """Folder in a Visual Studio project or solution."""
+    """Folder in a Visual Studio project or solution."""
 
-  def __init__(self, path, name = None, entries = None,
-               guid = None, items = None):
-    """Initializes the folder.
+    def __init__(self, path, name=None, entries=None, guid=None, items=None):
+        """Initializes the folder.
 
     Args:
       path: Full path to the folder.
@@ -77,38 +90,46 @@ class MSVSFolder(MSVSSolutionEntry):
       items: List of solution items to include in the folder project.  May be
           None, if the folder does not directly contain items.
     """
-    if name:
-      self.name = name
-    else:
-      # Use last layer.
-      self.name = os.path.basename(path)
+        if name:
+            self.name = name
+        else:
+            # Use last layer.
+            self.name = os.path.basename(path)
 
-    self.path = path
-    self.guid = guid
+        self.path = path
+        self.guid = guid
 
-    # Copy passed lists (or set to empty lists)
-    self.entries = sorted(entries or [], key=attrgetter('path'))
-    self.items = list(items or [])
+        # Copy passed lists (or set to empty lists)
+        self.entries = sorted(entries or [], key=attrgetter("path"))
+        self.items = list(items or [])
 
-    self.entry_type_guid = ENTRY_TYPE_GUIDS['folder']
+        self.entry_type_guid = ENTRY_TYPE_GUIDS["folder"]
 
-  def get_guid(self):
-    if self.guid is None:
-      # Use consistent guids for folders (so things don't regenerate).
-      self.guid = MakeGuid(self.path, seed='msvs_folder')
-    return self.guid
+    def get_guid(self):
+        if self.guid is None:
+            # Use consistent guids for folders (so things don't regenerate).
+            self.guid = MakeGuid(self.path, seed="msvs_folder")
+        return self.guid
 
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 
 
 class MSVSProject(MSVSSolutionEntry):
-  """Visual Studio project."""
-
-  def __init__(self, path, name = None, dependencies = None, guid = None,
-               spec = None, build_file = None, config_platform_overrides = None,
-               fixpath_prefix = None):
-    """Initializes the project.
+    """Visual Studio project."""
+
+    def __init__(
+        self,
+        path,
+        name=None,
+        dependencies=None,
+        guid=None,
+        spec=None,
+        build_file=None,
+        config_platform_overrides=None,
+        fixpath_prefix=None,
+    ):
+        """Initializes the project.
 
     Args:
       path: Absolute path to the project file.
@@ -123,57 +144,59 @@ class MSVSProject(MSVSSolutionEntry):
           used in place of the default for this target.
       fixpath_prefix: the path used to adjust the behavior of _fixpath
     """
-    self.path = path
-    self.guid = guid
-    self.spec = spec
-    self.build_file = build_file
-    # Use project filename if name not specified
-    self.name = name or os.path.splitext(os.path.basename(path))[0]
-
-    # Copy passed lists (or set to empty lists)
-    self.dependencies = list(dependencies or [])
-
-    self.entry_type_guid = ENTRY_TYPE_GUIDS['project']
-
-    if config_platform_overrides:
-      self.config_platform_overrides = config_platform_overrides
-    else:
-      self.config_platform_overrides = {}
-    self.fixpath_prefix = fixpath_prefix
-    self.msbuild_toolset = None
-
-  def set_dependencies(self, dependencies):
-    self.dependencies = list(dependencies or [])
-
-  def get_guid(self):
-    if self.guid is None:
-      # Set GUID from path
-      # TODO(rspangler): This is fragile.
-      # 1. We can't just use the project filename sans path, since there could
-      #    be multiple projects with the same base name (for example,
-      #    foo/unittest.vcproj and bar/unittest.vcproj).
-      # 2. The path needs to be relative to $SOURCE_ROOT, so that the project
-      #    GUID is the same whether it's included from base/base.sln or
-      #    foo/bar/baz/baz.sln.
-      # 3. The GUID needs to be the same each time this builder is invoked, so
-      #    that we don't need to rebuild the solution when the project changes.
-      # 4. We should be able to handle pre-built project files by reading the
-      #    GUID from the files.
-      self.guid = MakeGuid(self.name)
-    return self.guid
-
-  def set_msbuild_toolset(self, msbuild_toolset):
-    self.msbuild_toolset = msbuild_toolset
-
-#------------------------------------------------------------------------------
+        self.path = path
+        self.guid = guid
+        self.spec = spec
+        self.build_file = build_file
+        # Use project filename if name not specified
+        self.name = name or os.path.splitext(os.path.basename(path))[0]
+
+        # Copy passed lists (or set to empty lists)
+        self.dependencies = list(dependencies or [])
+
+        self.entry_type_guid = ENTRY_TYPE_GUIDS["project"]
+
+        if config_platform_overrides:
+            self.config_platform_overrides = config_platform_overrides
+        else:
+            self.config_platform_overrides = {}
+        self.fixpath_prefix = fixpath_prefix
+        self.msbuild_toolset = None
+
+    def set_dependencies(self, dependencies):
+        self.dependencies = list(dependencies or [])
+
+    def get_guid(self):
+        if self.guid is None:
+            # Set GUID from path
+            # TODO(rspangler): This is fragile.
+            # 1. We can't just use the project filename sans path, since there could
+            #    be multiple projects with the same base name (for example,
+            #    foo/unittest.vcproj and bar/unittest.vcproj).
+            # 2. The path needs to be relative to $SOURCE_ROOT, so that the project
+            #    GUID is the same whether it's included from base/base.sln or
+            #    foo/bar/baz/baz.sln.
+            # 3. The GUID needs to be the same each time this builder is invoked, so
+            #    that we don't need to rebuild the solution when the project changes.
+            # 4. We should be able to handle pre-built project files by reading the
+            #    GUID from the files.
+            self.guid = MakeGuid(self.name)
+        return self.guid
+
+    def set_msbuild_toolset(self, msbuild_toolset):
+        self.msbuild_toolset = msbuild_toolset
+
+
+# ------------------------------------------------------------------------------
 
 
 class MSVSSolution(object):
-  """Visual Studio solution."""
+    """Visual Studio solution."""
 
-  def __init__(self, path, version, entries=None, variants=None,
-               websiteProperties=True):
-    """Initializes the solution.
+    def __init__(
+        self, path, version, entries=None, variants=None, websiteProperties=True
+    ):
+        """Initializes the solution.
 
     Args:
       path: Path to solution file.
@@ -185,152 +208,163 @@ class MSVSSolution(object):
       websiteProperties: Flag to decide if the website properties section
           is generated.
     """
-    self.path = path
-    self.websiteProperties = websiteProperties
-    self.version = version
-
-    # Copy passed lists (or set to empty lists)
-    self.entries = list(entries or [])
-
-    if variants:
-      # Copy passed list
-      self.variants = variants[:]
-    else:
-      # Use default
-      self.variants = ['Debug|Win32', 'Release|Win32']
-    # TODO(rspangler): Need to be able to handle a mapping of solution config
-    # to project config.  Should we be able to handle variants being a dict,
-    # or add a separate variant_map variable?  If it's a dict, we can't
-    # guarantee the order of variants since dict keys aren't ordered.
-
-
-    # TODO(rspangler): Automatically write to disk for now; should delay until
-    # node-evaluation time.
-    self.Write()
-
-
-  def Write(self, writer=gyp.common.WriteOnDiff):
-    """Writes the solution file to disk.
+        self.path = path
+        self.websiteProperties = websiteProperties
+        self.version = version
+
+        # Copy passed lists (or set to empty lists)
+        self.entries = list(entries or [])
+
+        if variants:
+            # Copy passed list
+            self.variants = variants[:]
+        else:
+            # Use default
+            self.variants = ["Debug|Win32", "Release|Win32"]
+        # TODO(rspangler): Need to be able to handle a mapping of solution config
+        # to project config.  Should we be able to handle variants being a dict,
+        # or add a separate variant_map variable?  If it's a dict, we can't
+        # guarantee the order of variants since dict keys aren't ordered.
+
+        # TODO(rspangler): Automatically write to disk for now; should delay until
+        # node-evaluation time.
+        self.Write()
+
+    def Write(self, writer=gyp.common.WriteOnDiff):
+        """Writes the solution file to disk.
 
     Raises:
       IndexError: An entry appears multiple times.
     """
-    # Walk the entry tree and collect all the folders and projects.
-    all_entries = set()
-    entries_to_check = self.entries[:]
-    while entries_to_check:
-      e = entries_to_check.pop(0)
-
-      # If this entry has been visited, nothing to do.
-      if e in all_entries:
-        continue
-
-      all_entries.add(e)
-
-      # If this is a folder, check its entries too.
-      if isinstance(e, MSVSFolder):
-        entries_to_check += e.entries
-
-    all_entries = sorted(all_entries, key=attrgetter('path'))
-
-    # Open file and print header
-    f = writer(self.path)
-    f.write('Microsoft Visual Studio Solution File, '
-            'Format Version %s\r\n' % self.version.SolutionVersion())
-    f.write('# %s\r\n' % self.version.Description())
-
-    # Project entries
-    sln_root = os.path.split(self.path)[0]
-    for e in all_entries:
-      relative_path = gyp.common.RelativePath(e.path, sln_root)
-      # msbuild does not accept an empty folder_name.
-      # use '.' in case relative_path is empty.
-      folder_name = relative_path.replace('/', '\\') or '.'
-      f.write('Project("%s") = "%s", "%s", "%s"\r\n' % (
-          e.entry_type_guid,          # Entry type GUID
-          e.name,                     # Folder name
-          folder_name,                # Folder name (again)
-          e.get_guid(),               # Entry GUID
-      ))
-
-      # TODO(rspangler): Need a way to configure this stuff
-      if self.websiteProperties:
-        f.write('\tProjectSection(WebsiteProperties) = preProject\r\n'
-                '\t\tDebug.AspNetCompiler.Debug = "True"\r\n'
-                '\t\tRelease.AspNetCompiler.Debug = "False"\r\n'
-                '\tEndProjectSection\r\n')
-
-      if isinstance(e, MSVSFolder):
-        if e.items:
-          f.write('\tProjectSection(SolutionItems) = preProject\r\n')
-          for i in e.items:
-            f.write('\t\t%s = %s\r\n' % (i, i))
-          f.write('\tEndProjectSection\r\n')
-
-      if isinstance(e, MSVSProject):
-        if e.dependencies:
-          f.write('\tProjectSection(ProjectDependencies) = postProject\r\n')
-          for d in e.dependencies:
-            f.write('\t\t%s = %s\r\n' % (d.get_guid(), d.get_guid()))
-          f.write('\tEndProjectSection\r\n')
-
-      f.write('EndProject\r\n')
-
-    # Global section
-    f.write('Global\r\n')
-
-    # Configurations (variants)
-    f.write('\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n')
-    for v in self.variants:
-      f.write('\t\t%s = %s\r\n' % (v, v))
-    f.write('\tEndGlobalSection\r\n')
-
-    # Sort config guids for easier diffing of solution changes.
-    config_guids = []
-    config_guids_overrides = {}
-    for e in all_entries:
-      if isinstance(e, MSVSProject):
-        config_guids.append(e.get_guid())
-        config_guids_overrides[e.get_guid()] = e.config_platform_overrides
-    config_guids.sort()
-
-    f.write('\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n')
-    for g in config_guids:
-      for v in self.variants:
-        nv = config_guids_overrides[g].get(v, v)
-        # Pick which project configuration to build for this solution
-        # configuration.
-        f.write('\t\t%s.%s.ActiveCfg = %s\r\n' % (
-            g,              # Project GUID
-            v,              # Solution build configuration
-            nv,             # Project build config for that solution config
-        ))
-
-        # Enable project in this solution configuration.
-        f.write('\t\t%s.%s.Build.0 = %s\r\n' % (
-            g,              # Project GUID
-            v,              # Solution build configuration
-            nv,             # Project build config for that solution config
-        ))
-    f.write('\tEndGlobalSection\r\n')
-
-    # TODO(rspangler): Should be able to configure this stuff too (though I've
-    # never seen this be any different)
-    f.write('\tGlobalSection(SolutionProperties) = preSolution\r\n')
-    f.write('\t\tHideSolutionNode = FALSE\r\n')
-    f.write('\tEndGlobalSection\r\n')
-
-    # Folder mappings
-    # Omit this section if there are no folders
-    if any([e.entries for e in all_entries if isinstance(e, MSVSFolder)]):
-      f.write('\tGlobalSection(NestedProjects) = preSolution\r\n')
-      for e in all_entries:
-        if not isinstance(e, MSVSFolder):
-          continue        # Does not apply to projects, only folders
-        for subentry in e.entries:
-          f.write('\t\t%s = %s\r\n' % (subentry.get_guid(), e.get_guid()))
-      f.write('\tEndGlobalSection\r\n')
-
-    f.write('EndGlobal\r\n')
-
-    f.close()
+        # Walk the entry tree and collect all the folders and projects.
+        all_entries = set()
+        entries_to_check = self.entries[:]
+        while entries_to_check:
+            e = entries_to_check.pop(0)
+
+            # If this entry has been visited, nothing to do.
+            if e in all_entries:
+                continue
+
+            all_entries.add(e)
+
+            # If this is a folder, check its entries too.
+            if isinstance(e, MSVSFolder):
+                entries_to_check += e.entries
+
+        all_entries = sorted(all_entries, key=attrgetter("path"))
+
+        # Open file and print header
+        f = writer(self.path)
+        f.write(
+            "Microsoft Visual Studio Solution File, "
+            "Format Version %s\r\n" % self.version.SolutionVersion()
+        )
+        f.write("# %s\r\n" % self.version.Description())
+
+        # Project entries
+        sln_root = os.path.split(self.path)[0]
+        for e in all_entries:
+            relative_path = gyp.common.RelativePath(e.path, sln_root)
+            # msbuild does not accept an empty folder_name.
+            # use '.' in case relative_path is empty.
+            folder_name = relative_path.replace("/", "\\") or "."
+            f.write(
+                'Project("%s") = "%s", "%s", "%s"\r\n'
+                % (
+                    e.entry_type_guid,  # Entry type GUID
+                    e.name,  # Folder name
+                    folder_name,  # Folder name (again)
+                    e.get_guid(),  # Entry GUID
+                )
+            )
+
+            # TODO(rspangler): Need a way to configure this stuff
+            if self.websiteProperties:
+                f.write(
+                    "\tProjectSection(WebsiteProperties) = preProject\r\n"
+                    '\t\tDebug.AspNetCompiler.Debug = "True"\r\n'
+                    '\t\tRelease.AspNetCompiler.Debug = "False"\r\n'
+                    "\tEndProjectSection\r\n"
+                )
+
+            if isinstance(e, MSVSFolder):
+                if e.items:
+                    f.write("\tProjectSection(SolutionItems) = preProject\r\n")
+                    for i in e.items:
+                        f.write("\t\t%s = %s\r\n" % (i, i))
+                    f.write("\tEndProjectSection\r\n")
+
+            if isinstance(e, MSVSProject):
+                if e.dependencies:
+                    f.write("\tProjectSection(ProjectDependencies) = postProject\r\n")
+                    for d in e.dependencies:
+                        f.write("\t\t%s = %s\r\n" % (d.get_guid(), d.get_guid()))
+                    f.write("\tEndProjectSection\r\n")
+
+            f.write("EndProject\r\n")
+
+        # Global section
+        f.write("Global\r\n")
+
+        # Configurations (variants)
+        f.write("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n")
+        for v in self.variants:
+            f.write("\t\t%s = %s\r\n" % (v, v))
+        f.write("\tEndGlobalSection\r\n")
+
+        # Sort config guids for easier diffing of solution changes.
+        config_guids = []
+        config_guids_overrides = {}
+        for e in all_entries:
+            if isinstance(e, MSVSProject):
+                config_guids.append(e.get_guid())
+                config_guids_overrides[e.get_guid()] = e.config_platform_overrides
+        config_guids.sort()
+
+        f.write("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n")
+        for g in config_guids:
+            for v in self.variants:
+                nv = config_guids_overrides[g].get(v, v)
+                # Pick which project configuration to build for this solution
+                # configuration.
+                f.write(
+                    "\t\t%s.%s.ActiveCfg = %s\r\n"
+                    % (
+                        g,  # Project GUID
+                        v,  # Solution build configuration
+                        nv,  # Project build config for that solution config
+                    )
+                )
+
+                # Enable project in this solution configuration.
+                f.write(
+                    "\t\t%s.%s.Build.0 = %s\r\n"
+                    % (
+                        g,  # Project GUID
+                        v,  # Solution build configuration
+                        nv,  # Project build config for that solution config
+                    )
+                )
+        f.write("\tEndGlobalSection\r\n")
+
+        # TODO(rspangler): Should be able to configure this stuff too (though I've
+        # never seen this be any different)
+        f.write("\tGlobalSection(SolutionProperties) = preSolution\r\n")
+        f.write("\t\tHideSolutionNode = FALSE\r\n")
+        f.write("\tEndGlobalSection\r\n")
+
+        # Folder mappings
+        # Omit this section if there are no folders
+        if any([e.entries for e in all_entries if isinstance(e, MSVSFolder)]):
+            f.write("\tGlobalSection(NestedProjects) = preSolution\r\n")
+            for e in all_entries:
+                if not isinstance(e, MSVSFolder):
+                    continue  # Does not apply to projects, only folders
+                for subentry in e.entries:
+                    f.write("\t\t%s = %s\r\n" % (subentry.get_guid(), e.get_guid()))
+            f.write("\tEndGlobalSection\r\n")
+
+        f.write("EndGlobal\r\n")
+
+        f.close()
diff --git a/tools/gyp/pylib/gyp/MSVSProject.py b/tools/gyp/pylib/gyp/MSVSProject.py
index db1ceede344c60cf223b235138e94642ef3448e8..f953d52cd03d3646eb47e145addb96dbedc5c507 100644
--- a/tools/gyp/pylib/gyp/MSVSProject.py
+++ b/tools/gyp/pylib/gyp/MSVSProject.py
@@ -4,55 +4,55 @@
 
 """Visual Studio project reader/writer."""
 
-import gyp.common
 import gyp.easy_xml as easy_xml
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 
 
 class Tool(object):
-  """Visual Studio tool."""
+    """Visual Studio tool."""
 
-  def __init__(self, name, attrs=None):
-    """Initializes the tool.
+    def __init__(self, name, attrs=None):
+        """Initializes the tool.
 
     Args:
       name: Tool name.
       attrs: Dict of tool attributes; may be None.
     """
-    self._attrs = attrs or {}
-    self._attrs['Name'] = name
+        self._attrs = attrs or {}
+        self._attrs["Name"] = name
 
-  def _GetSpecification(self):
-    """Creates an element for the tool.
+    def _GetSpecification(self):
+        """Creates an element for the tool.
 
     Returns:
       A new xml.dom.Element for the tool.
     """
-    return ['Tool', self._attrs]
+        return ["Tool", self._attrs]
+
 
 class Filter(object):
-  """Visual Studio filter - that is, a virtual folder."""
+    """Visual Studio filter - that is, a virtual folder."""
 
-  def __init__(self, name, contents=None):
-    """Initializes the folder.
+    def __init__(self, name, contents=None):
+        """Initializes the folder.
 
     Args:
       name: Filter (folder) name.
       contents: List of filenames and/or Filter objects contained.
     """
-    self.name = name
-    self.contents = list(contents or [])
+        self.name = name
+        self.contents = list(contents or [])
 
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 
 
 class Writer(object):
-  """Visual Studio XML project writer."""
+    """Visual Studio XML project writer."""
 
-  def __init__(self, project_path, version, name, guid=None, platforms=None):
-    """Initializes the project.
+    def __init__(self, project_path, version, name, guid=None, platforms=None):
+        """Initializes the project.
 
     Args:
       project_path: Path to the project file.
@@ -61,36 +61,36 @@ class Writer(object):
       guid: GUID to use for project, if not None.
       platforms: Array of string, the supported platforms.  If null, ['Win32']
     """
-    self.project_path = project_path
-    self.version = version
-    self.name = name
-    self.guid = guid
+        self.project_path = project_path
+        self.version = version
+        self.name = name
+        self.guid = guid
 
-    # Default to Win32 for platforms.
-    if not platforms:
-      platforms = ['Win32']
+        # Default to Win32 for platforms.
+        if not platforms:
+            platforms = ["Win32"]
 
-    # Initialize the specifications of the various sections.
-    self.platform_section = ['Platforms']
-    for platform in platforms:
-      self.platform_section.append(['Platform', {'Name': platform}])
-    self.tool_files_section = ['ToolFiles']
-    self.configurations_section = ['Configurations']
-    self.files_section = ['Files']
+        # Initialize the specifications of the various sections.
+        self.platform_section = ["Platforms"]
+        for platform in platforms:
+            self.platform_section.append(["Platform", {"Name": platform}])
+        self.tool_files_section = ["ToolFiles"]
+        self.configurations_section = ["Configurations"]
+        self.files_section = ["Files"]
 
-    # Keep a dict keyed on filename to speed up access.
-    self.files_dict = dict()
+        # Keep a dict keyed on filename to speed up access.
+        self.files_dict = dict()
 
-  def AddToolFile(self, path):
-    """Adds a tool file to the project.
+    def AddToolFile(self, path):
+        """Adds a tool file to the project.
 
     Args:
       path: Relative path from project to tool file.
     """
-    self.tool_files_section.append(['ToolFile', {'RelativePath': path}])
+        self.tool_files_section.append(["ToolFile", {"RelativePath": path}])
 
-  def _GetSpecForConfiguration(self, config_type, config_name, attrs, tools):
-    """Returns the specification for a configuration.
+    def _GetSpecForConfiguration(self, config_type, config_name, attrs, tools):
+        """Returns the specification for a configuration.
 
     Args:
       config_type: Type of configuration node.
@@ -99,40 +99,39 @@ class Writer(object):
       tools: List of tools (strings or Tool objects); may be None.
     Returns:
     """
-    # Handle defaults
-    if not attrs:
-      attrs = {}
-    if not tools:
-      tools = []
-
-    # Add configuration node and its attributes
-    node_attrs = attrs.copy()
-    node_attrs['Name'] = config_name
-    specification = [config_type, node_attrs]
-
-    # Add tool nodes and their attributes
-    if tools:
-      for t in tools:
-        if isinstance(t, Tool):
-          specification.append(t._GetSpecification())
-        else:
-          specification.append(Tool(t)._GetSpecification())
-    return specification
-
-
-  def AddConfig(self, name, attrs=None, tools=None):
-    """Adds a configuration to the project.
+        # Handle defaults
+        if not attrs:
+            attrs = {}
+        if not tools:
+            tools = []
+
+        # Add configuration node and its attributes
+        node_attrs = attrs.copy()
+        node_attrs["Name"] = config_name
+        specification = [config_type, node_attrs]
+
+        # Add tool nodes and their attributes
+        if tools:
+            for t in tools:
+                if isinstance(t, Tool):
+                    specification.append(t._GetSpecification())
+                else:
+                    specification.append(Tool(t)._GetSpecification())
+        return specification
+
+    def AddConfig(self, name, attrs=None, tools=None):
+        """Adds a configuration to the project.
 
     Args:
       name: Configuration name.
       attrs: Dict of configuration attributes; may be None.
       tools: List of tools (strings or Tool objects); may be None.
     """
-    spec = self._GetSpecForConfiguration('Configuration', name, attrs, tools)
-    self.configurations_section.append(spec)
+        spec = self._GetSpecForConfiguration("Configuration", name, attrs, tools)
+        self.configurations_section.append(spec)
 
-  def _AddFilesToNode(self, parent, files):
-    """Adds files and/or filters to the parent node.
+    def _AddFilesToNode(self, parent, files):
+        """Adds files and/or filters to the parent node.
 
     Args:
       parent: Destination node
@@ -140,17 +139,17 @@ class Writer(object):
 
     Will call itself recursively, if the files list contains Filter objects.
     """
-    for f in files:
-      if isinstance(f, Filter):
-        node = ['Filter', {'Name': f.name}]
-        self._AddFilesToNode(node, f.contents)
-      else:
-        node = ['File', {'RelativePath': f}]
-        self.files_dict[f] = node
-      parent.append(node)
-
-  def AddFiles(self, files):
-    """Adds files to the project.
+        for f in files:
+            if isinstance(f, Filter):
+                node = ["Filter", {"Name": f.name}]
+                self._AddFilesToNode(node, f.contents)
+            else:
+                node = ["File", {"RelativePath": f}]
+                self.files_dict[f] = node
+            parent.append(node)
+
+    def AddFiles(self, files):
+        """Adds files to the project.
 
     Args:
       files: A list of Filter objects and/or relative paths to files.
@@ -159,12 +158,12 @@ class Writer(object):
     later add files to a Filter object which was passed into a previous call
     to AddFiles(), it will not be reflected in this project.
     """
-    self._AddFilesToNode(self.files_section, files)
-    # TODO(rspangler) This also doesn't handle adding files to an existing
-    # filter.  That is, it doesn't merge the trees.
+        self._AddFilesToNode(self.files_section, files)
+        # TODO(rspangler) This also doesn't handle adding files to an existing
+        # filter.  That is, it doesn't merge the trees.
 
-  def AddFileConfig(self, path, config, attrs=None, tools=None):
-    """Adds a configuration to a file.
+    def AddFileConfig(self, path, config, attrs=None, tools=None):
+        """Adds a configuration to a file.
 
     Args:
       path: Relative path to the file.
@@ -175,34 +174,33 @@ class Writer(object):
     Raises:
       ValueError: Relative path does not match any file added via AddFiles().
     """
-    # Find the file node with the right relative path
-    parent = self.files_dict.get(path)
-    if not parent:
-      raise ValueError('AddFileConfig: file "%s" not in project.' % path)
-
-    # Add the config to the file node
-    spec = self._GetSpecForConfiguration('FileConfiguration', config, attrs,
-                                         tools)
-    parent.append(spec)
-
-  def WriteIfChanged(self):
-    """Writes the project file."""
-    # First create XML content definition
-    content = [
-        'VisualStudioProject',
-        {'ProjectType': 'Visual C++',
-         'Version': self.version.ProjectVersion(),
-         'Name': self.name,
-         'ProjectGUID': self.guid,
-         'RootNamespace': self.name,
-         'Keyword': 'Win32Proj'
-        },
-        self.platform_section,
-        self.tool_files_section,
-        self.configurations_section,
-        ['References'],  # empty section
-        self.files_section,
-        ['Globals']  # empty section
-    ]
-    easy_xml.WriteXmlIfChanged(content, self.project_path,
-                               encoding="Windows-1252")
+        # Find the file node with the right relative path
+        parent = self.files_dict.get(path)
+        if not parent:
+            raise ValueError('AddFileConfig: file "%s" not in project.' % path)
+
+        # Add the config to the file node
+        spec = self._GetSpecForConfiguration("FileConfiguration", config, attrs, tools)
+        parent.append(spec)
+
+    def WriteIfChanged(self):
+        """Writes the project file."""
+        # First create XML content definition
+        content = [
+            "VisualStudioProject",
+            {
+                "ProjectType": "Visual C++",
+                "Version": self.version.ProjectVersion(),
+                "Name": self.name,
+                "ProjectGUID": self.guid,
+                "RootNamespace": self.name,
+                "Keyword": "Win32Proj",
+            },
+            self.platform_section,
+            self.tool_files_section,
+            self.configurations_section,
+            ["References"],  # empty section
+            self.files_section,
+            ["Globals"],  # empty section
+        ]
+        easy_xml.WriteXmlIfChanged(content, self.project_path, encoding="Windows-1252")
diff --git a/tools/gyp/pylib/gyp/MSVSSettings.py b/tools/gyp/pylib/gyp/MSVSSettings.py
index 5dd8f8c1e6e24279e68f7651e69e5979673d05f6..6ef16f2a0b23e2cea5ff38fbf1d6d98db0f47293 100644
--- a/tools/gyp/pylib/gyp/MSVSSettings.py
+++ b/tools/gyp/pylib/gyp/MSVSSettings.py
@@ -37,42 +37,42 @@ _msbuild_name_of_tool = {}
 
 
 class _Tool(object):
-  """Represents a tool used by MSVS or MSBuild.
+    """Represents a tool used by MSVS or MSBuild.
 
   Attributes:
       msvs_name: The name of the tool in MSVS.
       msbuild_name: The name of the tool in MSBuild.
   """
 
-  def __init__(self, msvs_name, msbuild_name):
-    self.msvs_name = msvs_name
-    self.msbuild_name = msbuild_name
+    def __init__(self, msvs_name, msbuild_name):
+        self.msvs_name = msvs_name
+        self.msbuild_name = msbuild_name
 
 
 def _AddTool(tool):
-  """Adds a tool to the four dictionaries used to process settings.
+    """Adds a tool to the four dictionaries used to process settings.
 
   This only defines the tool.  Each setting also needs to be added.
 
   Args:
     tool: The _Tool object to be added.
   """
-  _msvs_validators[tool.msvs_name] = {}
-  _msbuild_validators[tool.msbuild_name] = {}
-  _msvs_to_msbuild_converters[tool.msvs_name] = {}
-  _msbuild_name_of_tool[tool.msvs_name] = tool.msbuild_name
+    _msvs_validators[tool.msvs_name] = {}
+    _msbuild_validators[tool.msbuild_name] = {}
+    _msvs_to_msbuild_converters[tool.msvs_name] = {}
+    _msbuild_name_of_tool[tool.msvs_name] = tool.msbuild_name
 
 
 def _GetMSBuildToolSettings(msbuild_settings, tool):
-  """Returns an MSBuild tool dictionary.  Creates it if needed."""
-  return msbuild_settings.setdefault(tool.msbuild_name, {})
+    """Returns an MSBuild tool dictionary.  Creates it if needed."""
+    return msbuild_settings.setdefault(tool.msbuild_name, {})
 
 
 class _Type(object):
-  """Type of settings (Base class)."""
+    """Type of settings (Base class)."""
 
-  def ValidateMSVS(self, value):
-    """Verifies that the value is legal for MSVS.
+    def ValidateMSVS(self, value):
+        """Verifies that the value is legal for MSVS.
 
     Args:
       value: the value to check for this type.
@@ -81,8 +81,8 @@ class _Type(object):
       ValueError if value is not valid for MSVS.
     """
 
-  def ValidateMSBuild(self, value):
-    """Verifies that the value is legal for MSBuild.
+    def ValidateMSBuild(self, value):
+        """Verifies that the value is legal for MSBuild.
 
     Args:
       value: the value to check for this type.
@@ -91,8 +91,8 @@ class _Type(object):
       ValueError if value is not valid for MSBuild.
     """
 
-  def ConvertToMSBuild(self, value):
-    """Returns the MSBuild equivalent of the MSVS value given.
+    def ConvertToMSBuild(self, value):
+        """Returns the MSBuild equivalent of the MSVS value given.
 
     Args:
       value: the MSVS value to convert.
@@ -103,84 +103,84 @@ class _Type(object):
     Raises:
       ValueError if value is not valid.
     """
-    return value
+        return value
 
 
 class _String(_Type):
-  """A setting that's just a string."""
+    """A setting that's just a string."""
 
-  def ValidateMSVS(self, value):
-    if not isinstance(value, string_types):
-      raise ValueError('expected string; got %r' % value)
+    def ValidateMSVS(self, value):
+        if not isinstance(value, string_types):
+            raise ValueError("expected string; got %r" % value)
 
-  def ValidateMSBuild(self, value):
-    if not isinstance(value, string_types):
-      raise ValueError('expected string; got %r' % value)
+    def ValidateMSBuild(self, value):
+        if not isinstance(value, string_types):
+            raise ValueError("expected string; got %r" % value)
 
-  def ConvertToMSBuild(self, value):
-    # Convert the macros
-    return ConvertVCMacrosToMSBuild(value)
+    def ConvertToMSBuild(self, value):
+        # Convert the macros
+        return ConvertVCMacrosToMSBuild(value)
 
 
 class _StringList(_Type):
-  """A settings that's a list of strings."""
+    """A settings that's a list of strings."""
 
-  def ValidateMSVS(self, value):
-    if not isinstance(value, string_types) and not isinstance(value, list):
-      raise ValueError('expected string list; got %r' % value)
+    def ValidateMSVS(self, value):
+        if not isinstance(value, string_types) and not isinstance(value, list):
+            raise ValueError("expected string list; got %r" % value)
 
-  def ValidateMSBuild(self, value):
-    if not isinstance(value, string_types) and not isinstance(value, list):
-      raise ValueError('expected string list; got %r' % value)
+    def ValidateMSBuild(self, value):
+        if not isinstance(value, string_types) and not isinstance(value, list):
+            raise ValueError("expected string list; got %r" % value)
 
-  def ConvertToMSBuild(self, value):
-    # Convert the macros
-    if isinstance(value, list):
-      return [ConvertVCMacrosToMSBuild(i) for i in value]
-    else:
-      return ConvertVCMacrosToMSBuild(value)
+    def ConvertToMSBuild(self, value):
+        # Convert the macros
+        if isinstance(value, list):
+            return [ConvertVCMacrosToMSBuild(i) for i in value]
+        else:
+            return ConvertVCMacrosToMSBuild(value)
 
 
 class _Boolean(_Type):
-  """Boolean settings, can have the values 'false' or 'true'."""
+    """Boolean settings, can have the values 'false' or 'true'."""
 
-  def _Validate(self, value):
-    if value != 'true' and value != 'false':
-      raise ValueError('expected bool; got %r' % value)
+    def _Validate(self, value):
+        if value != "true" and value != "false":
+            raise ValueError("expected bool; got %r" % value)
 
-  def ValidateMSVS(self, value):
-    self._Validate(value)
+    def ValidateMSVS(self, value):
+        self._Validate(value)
 
-  def ValidateMSBuild(self, value):
-    self._Validate(value)
+    def ValidateMSBuild(self, value):
+        self._Validate(value)
 
-  def ConvertToMSBuild(self, value):
-    self._Validate(value)
-    return value
+    def ConvertToMSBuild(self, value):
+        self._Validate(value)
+        return value
 
 
 class _Integer(_Type):
-  """Integer settings."""
+    """Integer settings."""
 
-  def __init__(self, msbuild_base=10):
-    _Type.__init__(self)
-    self._msbuild_base = msbuild_base
+    def __init__(self, msbuild_base=10):
+        _Type.__init__(self)
+        self._msbuild_base = msbuild_base
 
-  def ValidateMSVS(self, value):
-    # Try to convert, this will raise ValueError if invalid.
-    self.ConvertToMSBuild(value)
+    def ValidateMSVS(self, value):
+        # Try to convert, this will raise ValueError if invalid.
+        self.ConvertToMSBuild(value)
 
-  def ValidateMSBuild(self, value):
-    # Try to convert, this will raise ValueError if invalid.
-    int(value, self._msbuild_base)
+    def ValidateMSBuild(self, value):
+        # Try to convert, this will raise ValueError if invalid.
+        int(value, self._msbuild_base)
 
-  def ConvertToMSBuild(self, value):
-    msbuild_format = (self._msbuild_base == 10) and '%d' or '0x%04x'
-    return msbuild_format % int(value)
+    def ConvertToMSBuild(self, value):
+        msbuild_format = (self._msbuild_base == 10) and "%d" or "0x%04x"
+        return msbuild_format % int(value)
 
 
 class _Enumeration(_Type):
-  """Type of settings that is an enumeration.
+    """Type of settings that is an enumeration.
 
   In MSVS, the values are indexes like '0', '1', and '2'.
   MSBuild uses text labels that are more representative, like 'Win32'.
@@ -192,31 +192,32 @@ class _Enumeration(_Type):
     new: an array of labels that are new to MSBuild.
   """
 
-  def __init__(self, label_list, new=None):
-    _Type.__init__(self)
-    self._label_list = label_list
-    self._msbuild_values = set(value for value in label_list
-                               if value is not None)
-    if new is not None:
-      self._msbuild_values.update(new)
-
-  def ValidateMSVS(self, value):
-    # Try to convert.  It will raise an exception if not valid.
-    self.ConvertToMSBuild(value)
-
-  def ValidateMSBuild(self, value):
-    if value not in self._msbuild_values:
-      raise ValueError('unrecognized enumerated value %s' % value)
-
-  def ConvertToMSBuild(self, value):
-    index = int(value)
-    if index < 0 or index >= len(self._label_list):
-      raise ValueError('index value (%d) not in expected range [0, %d)' %
-                       (index, len(self._label_list)))
-    label = self._label_list[index]
-    if label is None:
-      raise ValueError('converted value for %s not specified.' % value)
-    return label
+    def __init__(self, label_list, new=None):
+        _Type.__init__(self)
+        self._label_list = label_list
+        self._msbuild_values = set(value for value in label_list if value is not None)
+        if new is not None:
+            self._msbuild_values.update(new)
+
+    def ValidateMSVS(self, value):
+        # Try to convert.  It will raise an exception if not valid.
+        self.ConvertToMSBuild(value)
+
+    def ValidateMSBuild(self, value):
+        if value not in self._msbuild_values:
+            raise ValueError("unrecognized enumerated value %s" % value)
+
+    def ConvertToMSBuild(self, value):
+        index = int(value)
+        if index < 0 or index >= len(self._label_list):
+            raise ValueError(
+                "index value (%d) not in expected range [0, %d)"
+                % (index, len(self._label_list))
+            )
+        label = self._label_list[index]
+        if label is None:
+            raise ValueError("converted value for %s not specified." % value)
+        return label
 
 
 # Instantiate the various generic types.
@@ -231,22 +232,22 @@ _folder_list = _StringList()
 _string_list = _StringList()
 # Some boolean settings went from numerical values to boolean.  The
 # mapping is 0: default, 1: false, 2: true.
-_newly_boolean = _Enumeration(['', 'false', 'true'])
+_newly_boolean = _Enumeration(["", "false", "true"])
 
 
 def _Same(tool, name, setting_type):
-  """Defines a setting that has the same name in MSVS and MSBuild.
+    """Defines a setting that has the same name in MSVS and MSBuild.
 
   Args:
     tool: a dictionary that gives the names of the tool for MSVS and MSBuild.
     name: the name of the setting.
     setting_type: the type of this setting.
   """
-  _Renamed(tool, name, name, setting_type)
+    _Renamed(tool, name, name, setting_type)
 
 
 def _Renamed(tool, msvs_name, msbuild_name, setting_type):
-  """Defines a setting for which the name has changed.
+    """Defines a setting for which the name has changed.
 
   Args:
     tool: a dictionary that gives the names of the tool for MSVS and MSBuild.
@@ -255,24 +256,25 @@ def _Renamed(tool, msvs_name, msbuild_name, setting_type):
     setting_type: the type of this setting.
   """
 
-  def _Translate(value, msbuild_settings):
-    msbuild_tool_settings = _GetMSBuildToolSettings(msbuild_settings, tool)
-    msbuild_tool_settings[msbuild_name] = setting_type.ConvertToMSBuild(value)
+    def _Translate(value, msbuild_settings):
+        msbuild_tool_settings = _GetMSBuildToolSettings(msbuild_settings, tool)
+        msbuild_tool_settings[msbuild_name] = setting_type.ConvertToMSBuild(value)
 
-  _msvs_validators[tool.msvs_name][msvs_name] = setting_type.ValidateMSVS
-  _msbuild_validators[tool.msbuild_name][msbuild_name] = (
-      setting_type.ValidateMSBuild)
-  _msvs_to_msbuild_converters[tool.msvs_name][msvs_name] = _Translate
+    _msvs_validators[tool.msvs_name][msvs_name] = setting_type.ValidateMSVS
+    _msbuild_validators[tool.msbuild_name][msbuild_name] = setting_type.ValidateMSBuild
+    _msvs_to_msbuild_converters[tool.msvs_name][msvs_name] = _Translate
 
 
 def _Moved(tool, settings_name, msbuild_tool_name, setting_type):
-  _MovedAndRenamed(tool, settings_name, msbuild_tool_name, settings_name,
-                   setting_type)
+    _MovedAndRenamed(
+        tool, settings_name, msbuild_tool_name, settings_name, setting_type
+    )
 
 
-def _MovedAndRenamed(tool, msvs_settings_name, msbuild_tool_name,
-                     msbuild_settings_name, setting_type):
-  """Defines a setting that may have moved to a new section.
+def _MovedAndRenamed(
+    tool, msvs_settings_name, msbuild_tool_name, msbuild_settings_name, setting_type
+):
+    """Defines a setting that may have moved to a new section.
 
   Args:
     tool: a dictionary that gives the names of the tool for MSVS and MSBuild.
@@ -282,19 +284,18 @@ def _MovedAndRenamed(tool, msvs_settings_name, msbuild_tool_name,
     setting_type: the type of this setting.
   """
 
-  def _Translate(value, msbuild_settings):
-    tool_settings = msbuild_settings.setdefault(msbuild_tool_name, {})
-    tool_settings[msbuild_settings_name] = setting_type.ConvertToMSBuild(value)
+    def _Translate(value, msbuild_settings):
+        tool_settings = msbuild_settings.setdefault(msbuild_tool_name, {})
+        tool_settings[msbuild_settings_name] = setting_type.ConvertToMSBuild(value)
 
-  _msvs_validators[tool.msvs_name][msvs_settings_name] = (
-      setting_type.ValidateMSVS)
-  validator = setting_type.ValidateMSBuild
-  _msbuild_validators[msbuild_tool_name][msbuild_settings_name] = validator
-  _msvs_to_msbuild_converters[tool.msvs_name][msvs_settings_name] = _Translate
+    _msvs_validators[tool.msvs_name][msvs_settings_name] = setting_type.ValidateMSVS
+    validator = setting_type.ValidateMSBuild
+    _msbuild_validators[msbuild_tool_name][msbuild_settings_name] = validator
+    _msvs_to_msbuild_converters[tool.msvs_name][msvs_settings_name] = _Translate
 
 
 def _MSVSOnly(tool, name, setting_type):
-  """Defines a setting that is only found in MSVS.
+    """Defines a setting that is only found in MSVS.
 
   Args:
     tool: a dictionary that gives the names of the tool for MSVS and MSBuild.
@@ -302,16 +303,16 @@ def _MSVSOnly(tool, name, setting_type):
     setting_type: the type of this setting.
   """
 
-  def _Translate(unused_value, unused_msbuild_settings):
-    # Since this is for MSVS only settings, no translation will happen.
-    pass
+    def _Translate(unused_value, unused_msbuild_settings):
+        # Since this is for MSVS only settings, no translation will happen.
+        pass
 
-  _msvs_validators[tool.msvs_name][name] = setting_type.ValidateMSVS
-  _msvs_to_msbuild_converters[tool.msvs_name][name] = _Translate
+    _msvs_validators[tool.msvs_name][name] = setting_type.ValidateMSVS
+    _msvs_to_msbuild_converters[tool.msvs_name][name] = _Translate
 
 
 def _MSBuildOnly(tool, name, setting_type):
-  """Defines a setting that is only found in MSBuild.
+    """Defines a setting that is only found in MSBuild.
 
   Args:
     tool: a dictionary that gives the names of the tool for MSVS and MSBuild.
@@ -319,17 +320,17 @@ def _MSBuildOnly(tool, name, setting_type):
     setting_type: the type of this setting.
   """
 
-  def _Translate(value, msbuild_settings):
-    # Let msbuild-only properties get translated as-is from msvs_settings.
-    tool_settings = msbuild_settings.setdefault(tool.msbuild_name, {})
-    tool_settings[name] = value
+    def _Translate(value, msbuild_settings):
+        # Let msbuild-only properties get translated as-is from msvs_settings.
+        tool_settings = msbuild_settings.setdefault(tool.msbuild_name, {})
+        tool_settings[name] = value
 
-  _msbuild_validators[tool.msbuild_name][name] = setting_type.ValidateMSBuild
-  _msvs_to_msbuild_converters[tool.msvs_name][name] = _Translate
+    _msbuild_validators[tool.msbuild_name][name] = setting_type.ValidateMSBuild
+    _msvs_to_msbuild_converters[tool.msvs_name][name] = _Translate
 
 
 def _ConvertedToAdditionalOption(tool, msvs_name, flag):
-  """Defines a setting that's handled via a command line option in MSBuild.
+    """Defines a setting that's handled via a command line option in MSBuild.
 
   Args:
     tool: a dictionary that gives the names of the tool for MSVS and MSBuild.
@@ -337,53 +338,55 @@ def _ConvertedToAdditionalOption(tool, msvs_name, flag):
     flag: the flag to insert at the end of the AdditionalOptions
   """
 
-  def _Translate(value, msbuild_settings):
-    if value == 'true':
-      tool_settings = _GetMSBuildToolSettings(msbuild_settings, tool)
-      if 'AdditionalOptions' in tool_settings:
-        new_flags = '%s %s' % (tool_settings['AdditionalOptions'], flag)
-      else:
-        new_flags = flag
-      tool_settings['AdditionalOptions'] = new_flags
-  _msvs_validators[tool.msvs_name][msvs_name] = _boolean.ValidateMSVS
-  _msvs_to_msbuild_converters[tool.msvs_name][msvs_name] = _Translate
+    def _Translate(value, msbuild_settings):
+        if value == "true":
+            tool_settings = _GetMSBuildToolSettings(msbuild_settings, tool)
+            if "AdditionalOptions" in tool_settings:
+                new_flags = "%s %s" % (tool_settings["AdditionalOptions"], flag)
+            else:
+                new_flags = flag
+            tool_settings["AdditionalOptions"] = new_flags
+
+    _msvs_validators[tool.msvs_name][msvs_name] = _boolean.ValidateMSVS
+    _msvs_to_msbuild_converters[tool.msvs_name][msvs_name] = _Translate
 
 
 def _CustomGeneratePreprocessedFile(tool, msvs_name):
-  def _Translate(value, msbuild_settings):
-    tool_settings = _GetMSBuildToolSettings(msbuild_settings, tool)
-    if value == '0':
-      tool_settings['PreprocessToFile'] = 'false'
-      tool_settings['PreprocessSuppressLineNumbers'] = 'false'
-    elif value == '1':  # /P
-      tool_settings['PreprocessToFile'] = 'true'
-      tool_settings['PreprocessSuppressLineNumbers'] = 'false'
-    elif value == '2':  # /EP /P
-      tool_settings['PreprocessToFile'] = 'true'
-      tool_settings['PreprocessSuppressLineNumbers'] = 'true'
-    else:
-      raise ValueError('value must be one of [0, 1, 2]; got %s' % value)
-  # Create a bogus validator that looks for '0', '1', or '2'
-  msvs_validator = _Enumeration(['a', 'b', 'c']).ValidateMSVS
-  _msvs_validators[tool.msvs_name][msvs_name] = msvs_validator
-  msbuild_validator = _boolean.ValidateMSBuild
-  msbuild_tool_validators = _msbuild_validators[tool.msbuild_name]
-  msbuild_tool_validators['PreprocessToFile'] = msbuild_validator
-  msbuild_tool_validators['PreprocessSuppressLineNumbers'] = msbuild_validator
-  _msvs_to_msbuild_converters[tool.msvs_name][msvs_name] = _Translate
-
-
-fix_vc_macro_slashes_regex_list = ('IntDir', 'OutDir')
+    def _Translate(value, msbuild_settings):
+        tool_settings = _GetMSBuildToolSettings(msbuild_settings, tool)
+        if value == "0":
+            tool_settings["PreprocessToFile"] = "false"
+            tool_settings["PreprocessSuppressLineNumbers"] = "false"
+        elif value == "1":  # /P
+            tool_settings["PreprocessToFile"] = "true"
+            tool_settings["PreprocessSuppressLineNumbers"] = "false"
+        elif value == "2":  # /EP /P
+            tool_settings["PreprocessToFile"] = "true"
+            tool_settings["PreprocessSuppressLineNumbers"] = "true"
+        else:
+            raise ValueError("value must be one of [0, 1, 2]; got %s" % value)
+
+    # Create a bogus validator that looks for '0', '1', or '2'
+    msvs_validator = _Enumeration(["a", "b", "c"]).ValidateMSVS
+    _msvs_validators[tool.msvs_name][msvs_name] = msvs_validator
+    msbuild_validator = _boolean.ValidateMSBuild
+    msbuild_tool_validators = _msbuild_validators[tool.msbuild_name]
+    msbuild_tool_validators["PreprocessToFile"] = msbuild_validator
+    msbuild_tool_validators["PreprocessSuppressLineNumbers"] = msbuild_validator
+    _msvs_to_msbuild_converters[tool.msvs_name][msvs_name] = _Translate
+
+
+fix_vc_macro_slashes_regex_list = ("IntDir", "OutDir")
 fix_vc_macro_slashes_regex = re.compile(
-  r'(\$\((?:%s)\))(?:[\\/]+)' % "|".join(fix_vc_macro_slashes_regex_list)
+    r"(\$\((?:%s)\))(?:[\\/]+)" % "|".join(fix_vc_macro_slashes_regex_list)
 )
 
 # Regular expression to detect keys that were generated by exclusion lists
-_EXCLUDED_SUFFIX_RE = re.compile('^(.*)_excluded$')
+_EXCLUDED_SUFFIX_RE = re.compile("^(.*)_excluded$")
 
 
 def _ValidateExclusionSetting(setting, settings, error_msg, stderr=sys.stderr):
-  """Verify that 'setting' is valid if it is generated from an exclusion list.
+    """Verify that 'setting' is valid if it is generated from an exclusion list.
 
   If the setting appears to be generated from an exclusion list, the root name
   is checked.
@@ -394,57 +397,57 @@ def _ValidateExclusionSetting(setting, settings, error_msg, stderr=sys.stderr):
       error_msg: The message to emit in the event of error
       stderr:    The stream receiving the error messages.
   """
-  # This may be unrecognized because it's an exclusion list. If the
-  # setting name has the _excluded suffix, then check the root name.
-  unrecognized = True
-  m = re.match(_EXCLUDED_SUFFIX_RE, setting)
-  if m:
-    root_setting = m.group(1)
-    unrecognized = root_setting not in settings
+    # This may be unrecognized because it's an exclusion list. If the
+    # setting name has the _excluded suffix, then check the root name.
+    unrecognized = True
+    m = re.match(_EXCLUDED_SUFFIX_RE, setting)
+    if m:
+        root_setting = m.group(1)
+        unrecognized = root_setting not in settings
 
-  if unrecognized:
-    # We don't know this setting. Give a warning.
-    print(error_msg, file=stderr)
+    if unrecognized:
+        # We don't know this setting. Give a warning.
+        print(error_msg, file=stderr)
 
 
 def FixVCMacroSlashes(s):
-  """Replace macros which have excessive following slashes.
+    """Replace macros which have excessive following slashes.
 
   These macros are known to have a built-in trailing slash. Furthermore, many
   scripts hiccup on processing paths with extra slashes in the middle.
 
   This list is probably not exhaustive.  Add as needed.
   """
-  if '$' in s:
-    s = fix_vc_macro_slashes_regex.sub(r'\1', s)
-  return s
+    if "$" in s:
+        s = fix_vc_macro_slashes_regex.sub(r"\1", s)
+    return s
 
 
 def ConvertVCMacrosToMSBuild(s):
-  """Convert the MSVS macros found in the string to the MSBuild equivalent.
+    """Convert the MSVS macros found in the string to the MSBuild equivalent.
 
   This list is probably not exhaustive.  Add as needed.
   """
-  if '$' in s:
-    replace_map = {
-        '$(ConfigurationName)': '$(Configuration)',
-        '$(InputDir)': '%(RelativeDir)',
-        '$(InputExt)': '%(Extension)',
-        '$(InputFileName)': '%(Filename)%(Extension)',
-        '$(InputName)': '%(Filename)',
-        '$(InputPath)': '%(Identity)',
-        '$(ParentName)': '$(ProjectFileName)',
-        '$(PlatformName)': '$(Platform)',
-        '$(SafeInputName)': '%(Filename)',
-    }
-    for old, new in replace_map.items():
-      s = s.replace(old, new)
-    s = FixVCMacroSlashes(s)
-  return s
+    if "$" in s:
+        replace_map = {
+            "$(ConfigurationName)": "$(Configuration)",
+            "$(InputDir)": "%(RelativeDir)",
+            "$(InputExt)": "%(Extension)",
+            "$(InputFileName)": "%(Filename)%(Extension)",
+            "$(InputName)": "%(Filename)",
+            "$(InputPath)": "%(Identity)",
+            "$(ParentName)": "$(ProjectFileName)",
+            "$(PlatformName)": "$(Platform)",
+            "$(SafeInputName)": "%(Filename)",
+        }
+        for old, new in replace_map.items():
+            s = s.replace(old, new)
+        s = FixVCMacroSlashes(s)
+    return s
 
 
 def ConvertToMSBuildSettings(msvs_settings, stderr=sys.stderr):
-  """Converts MSVS settings (VS2008 and earlier) to MSBuild settings (VS2010+).
+    """Converts MSVS settings (VS2008 and earlier) to MSBuild settings (VS2010+).
 
   Args:
       msvs_settings: A dictionary.  The key is the tool name.  The values are
@@ -456,55 +459,65 @@ def ConvertToMSBuildSettings(msvs_settings, stderr=sys.stderr):
       or the empty string (for the global settings).  The values are themselves
       dictionaries of settings and their values.
   """
-  msbuild_settings = {}
-  for msvs_tool_name, msvs_tool_settings in msvs_settings.items():
-    if msvs_tool_name in _msvs_to_msbuild_converters:
-      msvs_tool = _msvs_to_msbuild_converters[msvs_tool_name]
-      for msvs_setting, msvs_value in msvs_tool_settings.items():
-        if msvs_setting in msvs_tool:
-          # Invoke the translation function.
-          try:
-            msvs_tool[msvs_setting](msvs_value, msbuild_settings)
-          except ValueError as e:
-            print('Warning: while converting %s/%s to MSBuild, '
-                  '%s' % (msvs_tool_name, msvs_setting, e), file=stderr)
+    msbuild_settings = {}
+    for msvs_tool_name, msvs_tool_settings in msvs_settings.items():
+        if msvs_tool_name in _msvs_to_msbuild_converters:
+            msvs_tool = _msvs_to_msbuild_converters[msvs_tool_name]
+            for msvs_setting, msvs_value in msvs_tool_settings.items():
+                if msvs_setting in msvs_tool:
+                    # Invoke the translation function.
+                    try:
+                        msvs_tool[msvs_setting](msvs_value, msbuild_settings)
+                    except ValueError as e:
+                        print(
+                            "Warning: while converting %s/%s to MSBuild, "
+                            "%s" % (msvs_tool_name, msvs_setting, e),
+                            file=stderr,
+                        )
+                else:
+                    _ValidateExclusionSetting(
+                        msvs_setting,
+                        msvs_tool,
+                        (
+                            "Warning: unrecognized setting %s/%s "
+                            "while converting to MSBuild."
+                            % (msvs_tool_name, msvs_setting)
+                        ),
+                        stderr,
+                    )
         else:
-          _ValidateExclusionSetting(msvs_setting,
-                                    msvs_tool,
-                                    ('Warning: unrecognized setting %s/%s '
-                                     'while converting to MSBuild.' %
-                                     (msvs_tool_name, msvs_setting)),
-                                    stderr)
-    else:
-      print('Warning: unrecognized tool %s while converting to '
-            'MSBuild.' % msvs_tool_name, file=stderr)
-  return msbuild_settings
+            print(
+                "Warning: unrecognized tool %s while converting to "
+                "MSBuild." % msvs_tool_name,
+                file=stderr,
+            )
+    return msbuild_settings
 
 
 def ValidateMSVSSettings(settings, stderr=sys.stderr):
-  """Validates that the names of the settings are valid for MSVS.
+    """Validates that the names of the settings are valid for MSVS.
 
   Args:
       settings: A dictionary.  The key is the tool name.  The values are
           themselves dictionaries of settings and their values.
       stderr: The stream receiving the error messages.
   """
-  _ValidateSettings(_msvs_validators, settings, stderr)
+    _ValidateSettings(_msvs_validators, settings, stderr)
 
 
 def ValidateMSBuildSettings(settings, stderr=sys.stderr):
-  """Validates that the names of the settings are valid for MSBuild.
+    """Validates that the names of the settings are valid for MSBuild.
 
   Args:
       settings: A dictionary.  The key is the tool name.  The values are
           themselves dictionaries of settings and their values.
       stderr: The stream receiving the error messages.
   """
-  _ValidateSettings(_msbuild_validators, settings, stderr)
+    _ValidateSettings(_msbuild_validators, settings, stderr)
 
 
 def _ValidateSettings(validators, settings, stderr):
-  """Validates that the settings are valid for MSBuild or MSVS.
+    """Validates that the settings are valid for MSBuild or MSVS.
 
   We currently only validate the names of the settings, not their values.
 
@@ -514,36 +527,39 @@ def _ValidateSettings(validators, settings, stderr):
           themselves dictionaries of settings and their values.
       stderr: The stream receiving the error messages.
   """
-  for tool_name in settings:
-    if tool_name in validators:
-      tool_validators = validators[tool_name]
-      for setting, value in settings[tool_name].items():
-        if setting in tool_validators:
-          try:
-            tool_validators[setting](value)
-          except ValueError as e:
-            print('Warning: for %s/%s, %s' %
-                              (tool_name, setting, e), file=stderr)
-        else:
-          _ValidateExclusionSetting(setting,
-                                    tool_validators,
-                                    ('Warning: unrecognized setting %s/%s' %
-                                     (tool_name, setting)),
-                                    stderr)
+    for tool_name in settings:
+        if tool_name in validators:
+            tool_validators = validators[tool_name]
+            for setting, value in settings[tool_name].items():
+                if setting in tool_validators:
+                    try:
+                        tool_validators[setting](value)
+                    except ValueError as e:
+                        print(
+                            "Warning: for %s/%s, %s" % (tool_name, setting, e),
+                            file=stderr,
+                        )
+                else:
+                    _ValidateExclusionSetting(
+                        setting,
+                        tool_validators,
+                        ("Warning: unrecognized setting %s/%s" % (tool_name, setting)),
+                        stderr,
+                    )
 
-    else:
-      print('Warning: unrecognized tool %s' % (tool_name), file=stderr)
+        else:
+            print("Warning: unrecognized tool %s" % (tool_name), file=stderr)
 
 
 # MSVS and MBuild names of the tools.
-_compile = _Tool('VCCLCompilerTool', 'ClCompile')
-_link = _Tool('VCLinkerTool', 'Link')
-_midl = _Tool('VCMIDLTool', 'Midl')
-_rc = _Tool('VCResourceCompilerTool', 'ResourceCompile')
-_lib = _Tool('VCLibrarianTool', 'Lib')
-_manifest = _Tool('VCManifestTool', 'Manifest')
-_masm = _Tool('MASM', 'MASM')
-_armasm = _Tool('ARMASM', 'ARMASM')
+_compile = _Tool("VCCLCompilerTool", "ClCompile")
+_link = _Tool("VCLinkerTool", "Link")
+_midl = _Tool("VCMIDLTool", "Midl")
+_rc = _Tool("VCResourceCompilerTool", "ResourceCompile")
+_lib = _Tool("VCLibrarianTool", "Lib")
+_manifest = _Tool("VCManifestTool", "Manifest")
+_masm = _Tool("MASM", "MASM")
+_armasm = _Tool("ARMASM", "ARMASM")
 
 
 _AddTool(_compile)
@@ -555,9 +571,9 @@ _AddTool(_manifest)
 _AddTool(_masm)
 _AddTool(_armasm)
 # Add sections only found in the MSBuild settings.
-_msbuild_validators[''] = {}
-_msbuild_validators['ProjectReference'] = {}
-_msbuild_validators['ManifestResourceCompile'] = {}
+_msbuild_validators[""] = {}
+_msbuild_validators["ProjectReference"] = {}
+_msbuild_validators["ManifestResourceCompile"] = {}
 
 # Descriptions of the compiler options, i.e. VCCLCompilerTool in MSVS and
 # ClCompile in MSBuild.
@@ -565,167 +581,231 @@ _msbuild_validators['ManifestResourceCompile'] = {}
 # the schema of the MSBuild ClCompile settings.
 
 # Options that have the same name in MSVS and MSBuild
-_Same(_compile, 'AdditionalIncludeDirectories', _folder_list)  # /I
-_Same(_compile, 'AdditionalOptions', _string_list)
-_Same(_compile, 'AdditionalUsingDirectories', _folder_list)  # /AI
-_Same(_compile, 'AssemblerListingLocation', _file_name)  # /Fa
-_Same(_compile, 'BrowseInformationFile', _file_name)
-_Same(_compile, 'BufferSecurityCheck', _boolean)  # /GS
-_Same(_compile, 'DisableLanguageExtensions', _boolean)  # /Za
-_Same(_compile, 'DisableSpecificWarnings', _string_list)  # /wd
-_Same(_compile, 'EnableFiberSafeOptimizations', _boolean)  # /GT
-_Same(_compile, 'EnablePREfast', _boolean)  # /analyze Visible='false'
-_Same(_compile, 'ExpandAttributedSource', _boolean)  # /Fx
-_Same(_compile, 'FloatingPointExceptions', _boolean)  # /fp:except
-_Same(_compile, 'ForceConformanceInForLoopScope', _boolean)  # /Zc:forScope
-_Same(_compile, 'ForcedIncludeFiles', _file_list)  # /FI
-_Same(_compile, 'ForcedUsingFiles', _file_list)  # /FU
-_Same(_compile, 'GenerateXMLDocumentationFiles', _boolean)  # /doc
-_Same(_compile, 'IgnoreStandardIncludePath', _boolean)  # /X
-_Same(_compile, 'MinimalRebuild', _boolean)  # /Gm
-_Same(_compile, 'OmitDefaultLibName', _boolean)  # /Zl
-_Same(_compile, 'OmitFramePointers', _boolean)  # /Oy
-_Same(_compile, 'PreprocessorDefinitions', _string_list)  # /D
-_Same(_compile, 'ProgramDataBaseFileName', _file_name)  # /Fd
-_Same(_compile, 'RuntimeTypeInfo', _boolean)  # /GR
-_Same(_compile, 'ShowIncludes', _boolean)  # /showIncludes
-_Same(_compile, 'SmallerTypeCheck', _boolean)  # /RTCc
-_Same(_compile, 'StringPooling', _boolean)  # /GF
-_Same(_compile, 'SuppressStartupBanner', _boolean)  # /nologo
-_Same(_compile, 'TreatWChar_tAsBuiltInType', _boolean)  # /Zc:wchar_t
-_Same(_compile, 'UndefineAllPreprocessorDefinitions', _boolean)  # /u
-_Same(_compile, 'UndefinePreprocessorDefinitions', _string_list)  # /U
-_Same(_compile, 'UseFullPaths', _boolean)  # /FC
-_Same(_compile, 'WholeProgramOptimization', _boolean)  # /GL
-_Same(_compile, 'XMLDocumentationFileName', _file_name)
-_Same(_compile, 'CompileAsWinRT', _boolean)  # /ZW
-
-_Same(_compile, 'AssemblerOutput',
-      _Enumeration(['NoListing',
-                    'AssemblyCode',  # /FA
-                    'All',  # /FAcs
-                    'AssemblyAndMachineCode',  # /FAc
-                    'AssemblyAndSourceCode']))  # /FAs
-_Same(_compile, 'BasicRuntimeChecks',
-      _Enumeration(['Default',
-                    'StackFrameRuntimeCheck',  # /RTCs
-                    'UninitializedLocalUsageCheck',  # /RTCu
-                    'EnableFastChecks']))  # /RTC1
-_Same(_compile, 'BrowseInformation',
-      _Enumeration(['false',
-                    'true',  # /FR
-                    'true']))  # /Fr
-_Same(_compile, 'CallingConvention',
-      _Enumeration(['Cdecl',  # /Gd
-                    'FastCall',  # /Gr
-                    'StdCall',  # /Gz
-                    'VectorCall']))  # /Gv
-_Same(_compile, 'CompileAs',
-      _Enumeration(['Default',
-                    'CompileAsC',  # /TC
-                    'CompileAsCpp']))  # /TP
-_Same(_compile, 'DebugInformationFormat',
-      _Enumeration(['',  # Disabled
-                    'OldStyle',  # /Z7
-                    None,
-                    'ProgramDatabase',  # /Zi
-                    'EditAndContinue']))  # /ZI
-_Same(_compile, 'EnableEnhancedInstructionSet',
-      _Enumeration(['NotSet',
-                    'StreamingSIMDExtensions',  # /arch:SSE
-                    'StreamingSIMDExtensions2',  # /arch:SSE2
-                    'AdvancedVectorExtensions',  # /arch:AVX (vs2012+)
-                    'NoExtensions',  # /arch:IA32 (vs2012+)
-                    # This one only exists in the new msbuild format.
-                    'AdvancedVectorExtensions2',  # /arch:AVX2 (vs2013r2+)
-                    ]))
-_Same(_compile, 'ErrorReporting',
-      _Enumeration(['None',  # /errorReport:none
-                    'Prompt',  # /errorReport:prompt
-                    'Queue'],  # /errorReport:queue
-                   new=['Send']))  # /errorReport:send"
-_Same(_compile, 'ExceptionHandling',
-      _Enumeration(['false',
-                    'Sync',  # /EHsc
-                    'Async'],  # /EHa
-                   new=['SyncCThrow']))  # /EHs
-_Same(_compile, 'FavorSizeOrSpeed',
-      _Enumeration(['Neither',
-                    'Speed',  # /Ot
-                    'Size']))  # /Os
-_Same(_compile, 'FloatingPointModel',
-      _Enumeration(['Precise',  # /fp:precise
-                    'Strict',  # /fp:strict
-                    'Fast']))  # /fp:fast
-_Same(_compile, 'InlineFunctionExpansion',
-      _Enumeration(['Default',
-                    'OnlyExplicitInline',  # /Ob1
-                    'AnySuitable'],  # /Ob2
-                   new=['Disabled']))  # /Ob0
-_Same(_compile, 'Optimization',
-      _Enumeration(['Disabled',  # /Od
-                    'MinSpace',  # /O1
-                    'MaxSpeed',  # /O2
-                    'Full']))  # /Ox
-_Same(_compile, 'RuntimeLibrary',
-      _Enumeration(['MultiThreaded',  # /MT
-                    'MultiThreadedDebug',  # /MTd
-                    'MultiThreadedDLL',  # /MD
-                    'MultiThreadedDebugDLL']))  # /MDd
-_Same(_compile, 'StructMemberAlignment',
-      _Enumeration(['Default',
-                    '1Byte',  # /Zp1
-                    '2Bytes',  # /Zp2
-                    '4Bytes',  # /Zp4
-                    '8Bytes',  # /Zp8
-                    '16Bytes']))  # /Zp16
-_Same(_compile, 'WarningLevel',
-      _Enumeration(['TurnOffAllWarnings',  # /W0
-                    'Level1',  # /W1
-                    'Level2',  # /W2
-                    'Level3',  # /W3
-                    'Level4'],  # /W4
-                   new=['EnableAllWarnings']))  # /Wall
+_Same(_compile, "AdditionalIncludeDirectories", _folder_list)  # /I
+_Same(_compile, "AdditionalOptions", _string_list)
+_Same(_compile, "AdditionalUsingDirectories", _folder_list)  # /AI
+_Same(_compile, "AssemblerListingLocation", _file_name)  # /Fa
+_Same(_compile, "BrowseInformationFile", _file_name)
+_Same(_compile, "BufferSecurityCheck", _boolean)  # /GS
+_Same(_compile, "DisableLanguageExtensions", _boolean)  # /Za
+_Same(_compile, "DisableSpecificWarnings", _string_list)  # /wd
+_Same(_compile, "EnableFiberSafeOptimizations", _boolean)  # /GT
+_Same(_compile, "EnablePREfast", _boolean)  # /analyze Visible='false'
+_Same(_compile, "ExpandAttributedSource", _boolean)  # /Fx
+_Same(_compile, "FloatingPointExceptions", _boolean)  # /fp:except
+_Same(_compile, "ForceConformanceInForLoopScope", _boolean)  # /Zc:forScope
+_Same(_compile, "ForcedIncludeFiles", _file_list)  # /FI
+_Same(_compile, "ForcedUsingFiles", _file_list)  # /FU
+_Same(_compile, "GenerateXMLDocumentationFiles", _boolean)  # /doc
+_Same(_compile, "IgnoreStandardIncludePath", _boolean)  # /X
+_Same(_compile, "MinimalRebuild", _boolean)  # /Gm
+_Same(_compile, "OmitDefaultLibName", _boolean)  # /Zl
+_Same(_compile, "OmitFramePointers", _boolean)  # /Oy
+_Same(_compile, "PreprocessorDefinitions", _string_list)  # /D
+_Same(_compile, "ProgramDataBaseFileName", _file_name)  # /Fd
+_Same(_compile, "RuntimeTypeInfo", _boolean)  # /GR
+_Same(_compile, "ShowIncludes", _boolean)  # /showIncludes
+_Same(_compile, "SmallerTypeCheck", _boolean)  # /RTCc
+_Same(_compile, "StringPooling", _boolean)  # /GF
+_Same(_compile, "SuppressStartupBanner", _boolean)  # /nologo
+_Same(_compile, "TreatWChar_tAsBuiltInType", _boolean)  # /Zc:wchar_t
+_Same(_compile, "UndefineAllPreprocessorDefinitions", _boolean)  # /u
+_Same(_compile, "UndefinePreprocessorDefinitions", _string_list)  # /U
+_Same(_compile, "UseFullPaths", _boolean)  # /FC
+_Same(_compile, "WholeProgramOptimization", _boolean)  # /GL
+_Same(_compile, "XMLDocumentationFileName", _file_name)
+_Same(_compile, "CompileAsWinRT", _boolean)  # /ZW
+
+_Same(
+    _compile,
+    "AssemblerOutput",
+    _Enumeration(
+        [
+            "NoListing",
+            "AssemblyCode",  # /FA
+            "All",  # /FAcs
+            "AssemblyAndMachineCode",  # /FAc
+            "AssemblyAndSourceCode",
+        ]
+    ),
+)  # /FAs
+_Same(
+    _compile,
+    "BasicRuntimeChecks",
+    _Enumeration(
+        [
+            "Default",
+            "StackFrameRuntimeCheck",  # /RTCs
+            "UninitializedLocalUsageCheck",  # /RTCu
+            "EnableFastChecks",
+        ]
+    ),
+)  # /RTC1
+_Same(
+    _compile, "BrowseInformation", _Enumeration(["false", "true", "true"])  # /FR
+)  # /Fr
+_Same(
+    _compile,
+    "CallingConvention",
+    _Enumeration(["Cdecl", "FastCall", "StdCall", "VectorCall"]),  # /Gd  # /Gr  # /Gz
+)  # /Gv
+_Same(
+    _compile,
+    "CompileAs",
+    _Enumeration(["Default", "CompileAsC", "CompileAsCpp"]),  # /TC
+)  # /TP
+_Same(
+    _compile,
+    "DebugInformationFormat",
+    _Enumeration(
+        [
+            "",  # Disabled
+            "OldStyle",  # /Z7
+            None,
+            "ProgramDatabase",  # /Zi
+            "EditAndContinue",
+        ]
+    ),
+)  # /ZI
+_Same(
+    _compile,
+    "EnableEnhancedInstructionSet",
+    _Enumeration(
+        [
+            "NotSet",
+            "StreamingSIMDExtensions",  # /arch:SSE
+            "StreamingSIMDExtensions2",  # /arch:SSE2
+            "AdvancedVectorExtensions",  # /arch:AVX (vs2012+)
+            "NoExtensions",  # /arch:IA32 (vs2012+)
+            # This one only exists in the new msbuild format.
+            "AdvancedVectorExtensions2",  # /arch:AVX2 (vs2013r2+)
+        ]
+    ),
+)
+_Same(
+    _compile,
+    "ErrorReporting",
+    _Enumeration(
+        [
+            "None",  # /errorReport:none
+            "Prompt",  # /errorReport:prompt
+            "Queue",
+        ],  # /errorReport:queue
+        new=["Send"],
+    ),
+)  # /errorReport:send"
+_Same(
+    _compile,
+    "ExceptionHandling",
+    _Enumeration(["false", "Sync", "Async"], new=["SyncCThrow"]),  # /EHsc  # /EHa
+)  # /EHs
+_Same(
+    _compile, "FavorSizeOrSpeed", _Enumeration(["Neither", "Speed", "Size"])  # /Ot
+)  # /Os
+_Same(
+    _compile,
+    "FloatingPointModel",
+    _Enumeration(["Precise", "Strict", "Fast"]),  # /fp:precise  # /fp:strict
+)  # /fp:fast
+_Same(
+    _compile,
+    "InlineFunctionExpansion",
+    _Enumeration(
+        ["Default", "OnlyExplicitInline", "AnySuitable"],  # /Ob1  # /Ob2
+        new=["Disabled"],
+    ),
+)  # /Ob0
+_Same(
+    _compile,
+    "Optimization",
+    _Enumeration(["Disabled", "MinSpace", "MaxSpeed", "Full"]),  # /Od  # /O1  # /O2
+)  # /Ox
+_Same(
+    _compile,
+    "RuntimeLibrary",
+    _Enumeration(
+        [
+            "MultiThreaded",  # /MT
+            "MultiThreadedDebug",  # /MTd
+            "MultiThreadedDLL",  # /MD
+            "MultiThreadedDebugDLL",
+        ]
+    ),
+)  # /MDd
+_Same(
+    _compile,
+    "StructMemberAlignment",
+    _Enumeration(
+        [
+            "Default",
+            "1Byte",  # /Zp1
+            "2Bytes",  # /Zp2
+            "4Bytes",  # /Zp4
+            "8Bytes",  # /Zp8
+            "16Bytes",
+        ]
+    ),
+)  # /Zp16
+_Same(
+    _compile,
+    "WarningLevel",
+    _Enumeration(
+        [
+            "TurnOffAllWarnings",  # /W0
+            "Level1",  # /W1
+            "Level2",  # /W2
+            "Level3",  # /W3
+            "Level4",
+        ],  # /W4
+        new=["EnableAllWarnings"],
+    ),
+)  # /Wall
 
 # Options found in MSVS that have been renamed in MSBuild.
-_Renamed(_compile, 'EnableFunctionLevelLinking', 'FunctionLevelLinking',
-         _boolean)  # /Gy
-_Renamed(_compile, 'EnableIntrinsicFunctions', 'IntrinsicFunctions',
-         _boolean)  # /Oi
-_Renamed(_compile, 'KeepComments', 'PreprocessKeepComments', _boolean)  # /C
-_Renamed(_compile, 'ObjectFile', 'ObjectFileName', _file_name)  # /Fo
-_Renamed(_compile, 'OpenMP', 'OpenMPSupport', _boolean)  # /openmp
-_Renamed(_compile, 'PrecompiledHeaderThrough', 'PrecompiledHeaderFile',
-         _file_name)  # Used with /Yc and /Yu
-_Renamed(_compile, 'PrecompiledHeaderFile', 'PrecompiledHeaderOutputFile',
-         _file_name)  # /Fp
-_Renamed(_compile, 'UsePrecompiledHeader', 'PrecompiledHeader',
-         _Enumeration(['NotUsing',  # VS recognized '' for this value too.
-                       'Create',   # /Yc
-                       'Use']))  # /Yu
-_Renamed(_compile, 'WarnAsError', 'TreatWarningAsError', _boolean)  # /WX
-
-_ConvertedToAdditionalOption(_compile, 'DefaultCharIsUnsigned', '/J')
+_Renamed(
+    _compile, "EnableFunctionLevelLinking", "FunctionLevelLinking", _boolean
+)  # /Gy
+_Renamed(_compile, "EnableIntrinsicFunctions", "IntrinsicFunctions", _boolean)  # /Oi
+_Renamed(_compile, "KeepComments", "PreprocessKeepComments", _boolean)  # /C
+_Renamed(_compile, "ObjectFile", "ObjectFileName", _file_name)  # /Fo
+_Renamed(_compile, "OpenMP", "OpenMPSupport", _boolean)  # /openmp
+_Renamed(
+    _compile, "PrecompiledHeaderThrough", "PrecompiledHeaderFile", _file_name
+)  # Used with /Yc and /Yu
+_Renamed(
+    _compile, "PrecompiledHeaderFile", "PrecompiledHeaderOutputFile", _file_name
+)  # /Fp
+_Renamed(
+    _compile,
+    "UsePrecompiledHeader",
+    "PrecompiledHeader",
+    _Enumeration(
+        ["NotUsing", "Create", "Use"]  # VS recognized '' for this value too.  # /Yc
+    ),
+)  # /Yu
+_Renamed(_compile, "WarnAsError", "TreatWarningAsError", _boolean)  # /WX
+
+_ConvertedToAdditionalOption(_compile, "DefaultCharIsUnsigned", "/J")
 
 # MSVS options not found in MSBuild.
-_MSVSOnly(_compile, 'Detect64BitPortabilityProblems', _boolean)
-_MSVSOnly(_compile, 'UseUnicodeResponseFiles', _boolean)
+_MSVSOnly(_compile, "Detect64BitPortabilityProblems", _boolean)
+_MSVSOnly(_compile, "UseUnicodeResponseFiles", _boolean)
 
 # MSBuild options not found in MSVS.
-_MSBuildOnly(_compile, 'BuildingInIDE', _boolean)
-_MSBuildOnly(_compile, 'CompileAsManaged',
-             _Enumeration([], new=['false',
-                                   'true']))  # /clr
-_MSBuildOnly(_compile, 'CreateHotpatchableImage', _boolean)  # /hotpatch
-_MSBuildOnly(_compile, 'MultiProcessorCompilation', _boolean)  # /MP
-_MSBuildOnly(_compile, 'PreprocessOutputPath', _string)  # /Fi
-_MSBuildOnly(_compile, 'ProcessorNumber', _integer)  # the number of processors
-_MSBuildOnly(_compile, 'TrackerLogDirectory', _folder_name)
-_MSBuildOnly(_compile, 'TreatSpecificWarningsAsErrors', _string_list)  # /we
-_MSBuildOnly(_compile, 'UseUnicodeForAssemblerListing', _boolean)  # /FAu
+_MSBuildOnly(_compile, "BuildingInIDE", _boolean)
+_MSBuildOnly(
+    _compile, "CompileAsManaged", _Enumeration([], new=["false", "true"])
+)  # /clr
+_MSBuildOnly(_compile, "CreateHotpatchableImage", _boolean)  # /hotpatch
+_MSBuildOnly(_compile, "MultiProcessorCompilation", _boolean)  # /MP
+_MSBuildOnly(_compile, "PreprocessOutputPath", _string)  # /Fi
+_MSBuildOnly(_compile, "ProcessorNumber", _integer)  # the number of processors
+_MSBuildOnly(_compile, "TrackerLogDirectory", _folder_name)
+_MSBuildOnly(_compile, "TreatSpecificWarningsAsErrors", _string_list)  # /we
+_MSBuildOnly(_compile, "UseUnicodeForAssemblerListing", _boolean)  # /FAu
 
 # Defines a setting that needs very customized processing
-_CustomGeneratePreprocessedFile(_compile, 'GeneratePreprocessedFile')
+_CustomGeneratePreprocessedFile(_compile, "GeneratePreprocessedFile")
 
 
 # Directives for converting MSVS VCLinkerTool to MSBuild Link.
@@ -733,326 +813,411 @@ _CustomGeneratePreprocessedFile(_compile, 'GeneratePreprocessedFile')
 # the schema of the MSBuild Link settings.
 
 # Options that have the same name in MSVS and MSBuild
-_Same(_link, 'AdditionalDependencies', _file_list)
-_Same(_link, 'AdditionalLibraryDirectories', _folder_list)  # /LIBPATH
+_Same(_link, "AdditionalDependencies", _file_list)
+_Same(_link, "AdditionalLibraryDirectories", _folder_list)  # /LIBPATH
 #  /MANIFESTDEPENDENCY:
-_Same(_link, 'AdditionalManifestDependencies', _file_list)
-_Same(_link, 'AdditionalOptions', _string_list)
-_Same(_link, 'AddModuleNamesToAssembly', _file_list)  # /ASSEMBLYMODULE
-_Same(_link, 'AllowIsolation', _boolean)  # /ALLOWISOLATION
-_Same(_link, 'AssemblyLinkResource', _file_list)  # /ASSEMBLYLINKRESOURCE
-_Same(_link, 'BaseAddress', _string)  # /BASE
-_Same(_link, 'CLRUnmanagedCodeCheck', _boolean)  # /CLRUNMANAGEDCODECHECK
-_Same(_link, 'DelayLoadDLLs', _file_list)  # /DELAYLOAD
-_Same(_link, 'DelaySign', _boolean)  # /DELAYSIGN
-_Same(_link, 'EmbedManagedResourceFile', _file_list)  # /ASSEMBLYRESOURCE
-_Same(_link, 'EnableUAC', _boolean)  # /MANIFESTUAC
-_Same(_link, 'EntryPointSymbol', _string)  # /ENTRY
-_Same(_link, 'ForceSymbolReferences', _file_list)  # /INCLUDE
-_Same(_link, 'FunctionOrder', _file_name)  # /ORDER
-_Same(_link, 'GenerateDebugInformation', _boolean)  # /DEBUG
-_Same(_link, 'GenerateMapFile', _boolean)  # /MAP
-_Same(_link, 'HeapCommitSize', _string)
-_Same(_link, 'HeapReserveSize', _string)  # /HEAP
-_Same(_link, 'IgnoreAllDefaultLibraries', _boolean)  # /NODEFAULTLIB
-_Same(_link, 'IgnoreEmbeddedIDL', _boolean)  # /IGNOREIDL
-_Same(_link, 'ImportLibrary', _file_name)  # /IMPLIB
-_Same(_link, 'KeyContainer', _file_name)  # /KEYCONTAINER
-_Same(_link, 'KeyFile', _file_name)  # /KEYFILE
-_Same(_link, 'ManifestFile', _file_name)  # /ManifestFile
-_Same(_link, 'MapExports', _boolean)  # /MAPINFO:EXPORTS
-_Same(_link, 'MapFileName', _file_name)
-_Same(_link, 'MergedIDLBaseFileName', _file_name)  # /IDLOUT
-_Same(_link, 'MergeSections', _string)  # /MERGE
-_Same(_link, 'MidlCommandFile', _file_name)  # /MIDL
-_Same(_link, 'ModuleDefinitionFile', _file_name)  # /DEF
-_Same(_link, 'OutputFile', _file_name)  # /OUT
-_Same(_link, 'PerUserRedirection', _boolean)
-_Same(_link, 'Profile', _boolean)  # /PROFILE
-_Same(_link, 'ProfileGuidedDatabase', _file_name)  # /PGD
-_Same(_link, 'ProgramDatabaseFile', _file_name)  # /PDB
-_Same(_link, 'RegisterOutput', _boolean)
-_Same(_link, 'SetChecksum', _boolean)  # /RELEASE
-_Same(_link, 'StackCommitSize', _string)
-_Same(_link, 'StackReserveSize', _string)  # /STACK
-_Same(_link, 'StripPrivateSymbols', _file_name)  # /PDBSTRIPPED
-_Same(_link, 'SupportUnloadOfDelayLoadedDLL', _boolean)  # /DELAY:UNLOAD
-_Same(_link, 'SuppressStartupBanner', _boolean)  # /NOLOGO
-_Same(_link, 'SwapRunFromCD', _boolean)  # /SWAPRUN:CD
-_Same(_link, 'TurnOffAssemblyGeneration', _boolean)  # /NOASSEMBLY
-_Same(_link, 'TypeLibraryFile', _file_name)  # /TLBOUT
-_Same(_link, 'TypeLibraryResourceID', _integer)  # /TLBID
-_Same(_link, 'UACUIAccess', _boolean)  # /uiAccess='true'
-_Same(_link, 'Version', _string)  # /VERSION
-
-_Same(_link, 'EnableCOMDATFolding', _newly_boolean)  # /OPT:ICF
-_Same(_link, 'FixedBaseAddress', _newly_boolean)  # /FIXED
-_Same(_link, 'LargeAddressAware', _newly_boolean)  # /LARGEADDRESSAWARE
-_Same(_link, 'OptimizeReferences', _newly_boolean)  # /OPT:REF
-_Same(_link, 'RandomizedBaseAddress', _newly_boolean)  # /DYNAMICBASE
-_Same(_link, 'TerminalServerAware', _newly_boolean)  # /TSAWARE
+_Same(_link, "AdditionalManifestDependencies", _file_list)
+_Same(_link, "AdditionalOptions", _string_list)
+_Same(_link, "AddModuleNamesToAssembly", _file_list)  # /ASSEMBLYMODULE
+_Same(_link, "AllowIsolation", _boolean)  # /ALLOWISOLATION
+_Same(_link, "AssemblyLinkResource", _file_list)  # /ASSEMBLYLINKRESOURCE
+_Same(_link, "BaseAddress", _string)  # /BASE
+_Same(_link, "CLRUnmanagedCodeCheck", _boolean)  # /CLRUNMANAGEDCODECHECK
+_Same(_link, "DelayLoadDLLs", _file_list)  # /DELAYLOAD
+_Same(_link, "DelaySign", _boolean)  # /DELAYSIGN
+_Same(_link, "EmbedManagedResourceFile", _file_list)  # /ASSEMBLYRESOURCE
+_Same(_link, "EnableUAC", _boolean)  # /MANIFESTUAC
+_Same(_link, "EntryPointSymbol", _string)  # /ENTRY
+_Same(_link, "ForceSymbolReferences", _file_list)  # /INCLUDE
+_Same(_link, "FunctionOrder", _file_name)  # /ORDER
+_Same(_link, "GenerateDebugInformation", _boolean)  # /DEBUG
+_Same(_link, "GenerateMapFile", _boolean)  # /MAP
+_Same(_link, "HeapCommitSize", _string)
+_Same(_link, "HeapReserveSize", _string)  # /HEAP
+_Same(_link, "IgnoreAllDefaultLibraries", _boolean)  # /NODEFAULTLIB
+_Same(_link, "IgnoreEmbeddedIDL", _boolean)  # /IGNOREIDL
+_Same(_link, "ImportLibrary", _file_name)  # /IMPLIB
+_Same(_link, "KeyContainer", _file_name)  # /KEYCONTAINER
+_Same(_link, "KeyFile", _file_name)  # /KEYFILE
+_Same(_link, "ManifestFile", _file_name)  # /ManifestFile
+_Same(_link, "MapExports", _boolean)  # /MAPINFO:EXPORTS
+_Same(_link, "MapFileName", _file_name)
+_Same(_link, "MergedIDLBaseFileName", _file_name)  # /IDLOUT
+_Same(_link, "MergeSections", _string)  # /MERGE
+_Same(_link, "MidlCommandFile", _file_name)  # /MIDL
+_Same(_link, "ModuleDefinitionFile", _file_name)  # /DEF
+_Same(_link, "OutputFile", _file_name)  # /OUT
+_Same(_link, "PerUserRedirection", _boolean)
+_Same(_link, "Profile", _boolean)  # /PROFILE
+_Same(_link, "ProfileGuidedDatabase", _file_name)  # /PGD
+_Same(_link, "ProgramDatabaseFile", _file_name)  # /PDB
+_Same(_link, "RegisterOutput", _boolean)
+_Same(_link, "SetChecksum", _boolean)  # /RELEASE
+_Same(_link, "StackCommitSize", _string)
+_Same(_link, "StackReserveSize", _string)  # /STACK
+_Same(_link, "StripPrivateSymbols", _file_name)  # /PDBSTRIPPED
+_Same(_link, "SupportUnloadOfDelayLoadedDLL", _boolean)  # /DELAY:UNLOAD
+_Same(_link, "SuppressStartupBanner", _boolean)  # /NOLOGO
+_Same(_link, "SwapRunFromCD", _boolean)  # /SWAPRUN:CD
+_Same(_link, "TurnOffAssemblyGeneration", _boolean)  # /NOASSEMBLY
+_Same(_link, "TypeLibraryFile", _file_name)  # /TLBOUT
+_Same(_link, "TypeLibraryResourceID", _integer)  # /TLBID
+_Same(_link, "UACUIAccess", _boolean)  # /uiAccess='true'
+_Same(_link, "Version", _string)  # /VERSION
+
+_Same(_link, "EnableCOMDATFolding", _newly_boolean)  # /OPT:ICF
+_Same(_link, "FixedBaseAddress", _newly_boolean)  # /FIXED
+_Same(_link, "LargeAddressAware", _newly_boolean)  # /LARGEADDRESSAWARE
+_Same(_link, "OptimizeReferences", _newly_boolean)  # /OPT:REF
+_Same(_link, "RandomizedBaseAddress", _newly_boolean)  # /DYNAMICBASE
+_Same(_link, "TerminalServerAware", _newly_boolean)  # /TSAWARE
 
 _subsystem_enumeration = _Enumeration(
-    ['NotSet',
-     'Console',  # /SUBSYSTEM:CONSOLE
-     'Windows',  # /SUBSYSTEM:WINDOWS
-     'Native',  # /SUBSYSTEM:NATIVE
-     'EFI Application',  # /SUBSYSTEM:EFI_APPLICATION
-     'EFI Boot Service Driver',  # /SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER
-     'EFI ROM',  # /SUBSYSTEM:EFI_ROM
-     'EFI Runtime',  # /SUBSYSTEM:EFI_RUNTIME_DRIVER
-     'WindowsCE'],  # /SUBSYSTEM:WINDOWSCE
-    new=['POSIX'])  # /SUBSYSTEM:POSIX
+    [
+        "NotSet",
+        "Console",  # /SUBSYSTEM:CONSOLE
+        "Windows",  # /SUBSYSTEM:WINDOWS
+        "Native",  # /SUBSYSTEM:NATIVE
+        "EFI Application",  # /SUBSYSTEM:EFI_APPLICATION
+        "EFI Boot Service Driver",  # /SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER
+        "EFI ROM",  # /SUBSYSTEM:EFI_ROM
+        "EFI Runtime",  # /SUBSYSTEM:EFI_RUNTIME_DRIVER
+        "WindowsCE",
+    ],  # /SUBSYSTEM:WINDOWSCE
+    new=["POSIX"],
+)  # /SUBSYSTEM:POSIX
 
 _target_machine_enumeration = _Enumeration(
-    ['NotSet',
-     'MachineX86',  # /MACHINE:X86
-     None,
-     'MachineARM',  # /MACHINE:ARM
-     'MachineEBC',  # /MACHINE:EBC
-     'MachineIA64',  # /MACHINE:IA64
-     None,
-     'MachineMIPS',  # /MACHINE:MIPS
-     'MachineMIPS16',  # /MACHINE:MIPS16
-     'MachineMIPSFPU',  # /MACHINE:MIPSFPU
-     'MachineMIPSFPU16',  # /MACHINE:MIPSFPU16
-     None,
-     None,
-     None,
-     'MachineSH4',  # /MACHINE:SH4
-     None,
-     'MachineTHUMB',  # /MACHINE:THUMB
-     'MachineX64'])  # /MACHINE:X64
-
-_Same(_link, 'AssemblyDebug',
-      _Enumeration(['',
-                    'true',  # /ASSEMBLYDEBUG
-                    'false']))  # /ASSEMBLYDEBUG:DISABLE
-_Same(_link, 'CLRImageType',
-      _Enumeration(['Default',
-                    'ForceIJWImage',  # /CLRIMAGETYPE:IJW
-                    'ForcePureILImage',  # /Switch="CLRIMAGETYPE:PURE
-                    'ForceSafeILImage']))  # /Switch="CLRIMAGETYPE:SAFE
-_Same(_link, 'CLRThreadAttribute',
-      _Enumeration(['DefaultThreadingAttribute',  # /CLRTHREADATTRIBUTE:NONE
-                    'MTAThreadingAttribute',  # /CLRTHREADATTRIBUTE:MTA
-                    'STAThreadingAttribute']))  # /CLRTHREADATTRIBUTE:STA
-_Same(_link, 'DataExecutionPrevention',
-      _Enumeration(['',
-                    'false',  # /NXCOMPAT:NO
-                    'true']))  # /NXCOMPAT
-_Same(_link, 'Driver',
-      _Enumeration(['NotSet',
-                    'Driver',  # /Driver
-                    'UpOnly',  # /DRIVER:UPONLY
-                    'WDM']))  # /DRIVER:WDM
-_Same(_link, 'LinkTimeCodeGeneration',
-      _Enumeration(['Default',
-                    'UseLinkTimeCodeGeneration',  # /LTCG
-                    'PGInstrument',  # /LTCG:PGInstrument
-                    'PGOptimization',  # /LTCG:PGOptimize
-                    'PGUpdate']))  # /LTCG:PGUpdate
-_Same(_link, 'ShowProgress',
-      _Enumeration(['NotSet',
-                    'LinkVerbose',  # /VERBOSE
-                    'LinkVerboseLib'],  # /VERBOSE:Lib
-                   new=['LinkVerboseICF',  # /VERBOSE:ICF
-                        'LinkVerboseREF',  # /VERBOSE:REF
-                        'LinkVerboseSAFESEH',  # /VERBOSE:SAFESEH
-                        'LinkVerboseCLR']))  # /VERBOSE:CLR
-_Same(_link, 'SubSystem', _subsystem_enumeration)
-_Same(_link, 'TargetMachine', _target_machine_enumeration)
-_Same(_link, 'UACExecutionLevel',
-      _Enumeration(['AsInvoker',  # /level='asInvoker'
-                    'HighestAvailable',  # /level='highestAvailable'
-                    'RequireAdministrator']))  # /level='requireAdministrator'
-_Same(_link, 'MinimumRequiredVersion', _string)
-_Same(_link, 'TreatLinkerWarningAsErrors', _boolean)  # /WX
+    [
+        "NotSet",
+        "MachineX86",  # /MACHINE:X86
+        None,
+        "MachineARM",  # /MACHINE:ARM
+        "MachineEBC",  # /MACHINE:EBC
+        "MachineIA64",  # /MACHINE:IA64
+        None,
+        "MachineMIPS",  # /MACHINE:MIPS
+        "MachineMIPS16",  # /MACHINE:MIPS16
+        "MachineMIPSFPU",  # /MACHINE:MIPSFPU
+        "MachineMIPSFPU16",  # /MACHINE:MIPSFPU16
+        None,
+        None,
+        None,
+        "MachineSH4",  # /MACHINE:SH4
+        None,
+        "MachineTHUMB",  # /MACHINE:THUMB
+        "MachineX64",
+    ]
+)  # /MACHINE:X64
+
+_Same(
+    _link, "AssemblyDebug", _Enumeration(["", "true", "false"])  # /ASSEMBLYDEBUG
+)  # /ASSEMBLYDEBUG:DISABLE
+_Same(
+    _link,
+    "CLRImageType",
+    _Enumeration(
+        [
+            "Default",
+            "ForceIJWImage",  # /CLRIMAGETYPE:IJW
+            "ForcePureILImage",  # /Switch="CLRIMAGETYPE:PURE
+            "ForceSafeILImage",
+        ]
+    ),
+)  # /Switch="CLRIMAGETYPE:SAFE
+_Same(
+    _link,
+    "CLRThreadAttribute",
+    _Enumeration(
+        [
+            "DefaultThreadingAttribute",  # /CLRTHREADATTRIBUTE:NONE
+            "MTAThreadingAttribute",  # /CLRTHREADATTRIBUTE:MTA
+            "STAThreadingAttribute",
+        ]
+    ),
+)  # /CLRTHREADATTRIBUTE:STA
+_Same(
+    _link,
+    "DataExecutionPrevention",
+    _Enumeration(["", "false", "true"]),  # /NXCOMPAT:NO
+)  # /NXCOMPAT
+_Same(
+    _link,
+    "Driver",
+    _Enumeration(["NotSet", "Driver", "UpOnly", "WDM"]),  # /Driver  # /DRIVER:UPONLY
+)  # /DRIVER:WDM
+_Same(
+    _link,
+    "LinkTimeCodeGeneration",
+    _Enumeration(
+        [
+            "Default",
+            "UseLinkTimeCodeGeneration",  # /LTCG
+            "PGInstrument",  # /LTCG:PGInstrument
+            "PGOptimization",  # /LTCG:PGOptimize
+            "PGUpdate",
+        ]
+    ),
+)  # /LTCG:PGUpdate
+_Same(
+    _link,
+    "ShowProgress",
+    _Enumeration(
+        ["NotSet", "LinkVerbose", "LinkVerboseLib"],  # /VERBOSE  # /VERBOSE:Lib
+        new=[
+            "LinkVerboseICF",  # /VERBOSE:ICF
+            "LinkVerboseREF",  # /VERBOSE:REF
+            "LinkVerboseSAFESEH",  # /VERBOSE:SAFESEH
+            "LinkVerboseCLR",
+        ],
+    ),
+)  # /VERBOSE:CLR
+_Same(_link, "SubSystem", _subsystem_enumeration)
+_Same(_link, "TargetMachine", _target_machine_enumeration)
+_Same(
+    _link,
+    "UACExecutionLevel",
+    _Enumeration(
+        [
+            "AsInvoker",  # /level='asInvoker'
+            "HighestAvailable",  # /level='highestAvailable'
+            "RequireAdministrator",
+        ]
+    ),
+)  # /level='requireAdministrator'
+_Same(_link, "MinimumRequiredVersion", _string)
+_Same(_link, "TreatLinkerWarningAsErrors", _boolean)  # /WX
 
 
 # Options found in MSVS that have been renamed in MSBuild.
-_Renamed(_link, 'ErrorReporting', 'LinkErrorReporting',
-         _Enumeration(['NoErrorReport',  # /ERRORREPORT:NONE
-                       'PromptImmediately',  # /ERRORREPORT:PROMPT
-                       'QueueForNextLogin'],  # /ERRORREPORT:QUEUE
-                      new=['SendErrorReport']))  # /ERRORREPORT:SEND
-_Renamed(_link, 'IgnoreDefaultLibraryNames', 'IgnoreSpecificDefaultLibraries',
-         _file_list)  # /NODEFAULTLIB
-_Renamed(_link, 'ResourceOnlyDLL', 'NoEntryPoint', _boolean)  # /NOENTRY
-_Renamed(_link, 'SwapRunFromNet', 'SwapRunFromNET', _boolean)  # /SWAPRUN:NET
-
-_Moved(_link, 'GenerateManifest', '', _boolean)
-_Moved(_link, 'IgnoreImportLibrary', '', _boolean)
-_Moved(_link, 'LinkIncremental', '', _newly_boolean)
-_Moved(_link, 'LinkLibraryDependencies', 'ProjectReference', _boolean)
-_Moved(_link, 'UseLibraryDependencyInputs', 'ProjectReference', _boolean)
+_Renamed(
+    _link,
+    "ErrorReporting",
+    "LinkErrorReporting",
+    _Enumeration(
+        [
+            "NoErrorReport",  # /ERRORREPORT:NONE
+            "PromptImmediately",  # /ERRORREPORT:PROMPT
+            "QueueForNextLogin",
+        ],  # /ERRORREPORT:QUEUE
+        new=["SendErrorReport"],
+    ),
+)  # /ERRORREPORT:SEND
+_Renamed(
+    _link, "IgnoreDefaultLibraryNames", "IgnoreSpecificDefaultLibraries", _file_list
+)  # /NODEFAULTLIB
+_Renamed(_link, "ResourceOnlyDLL", "NoEntryPoint", _boolean)  # /NOENTRY
+_Renamed(_link, "SwapRunFromNet", "SwapRunFromNET", _boolean)  # /SWAPRUN:NET
+
+_Moved(_link, "GenerateManifest", "", _boolean)
+_Moved(_link, "IgnoreImportLibrary", "", _boolean)
+_Moved(_link, "LinkIncremental", "", _newly_boolean)
+_Moved(_link, "LinkLibraryDependencies", "ProjectReference", _boolean)
+_Moved(_link, "UseLibraryDependencyInputs", "ProjectReference", _boolean)
 
 # MSVS options not found in MSBuild.
-_MSVSOnly(_link, 'OptimizeForWindows98', _newly_boolean)
-_MSVSOnly(_link, 'UseUnicodeResponseFiles', _boolean)
+_MSVSOnly(_link, "OptimizeForWindows98", _newly_boolean)
+_MSVSOnly(_link, "UseUnicodeResponseFiles", _boolean)
 
 # MSBuild options not found in MSVS.
-_MSBuildOnly(_link, 'BuildingInIDE', _boolean)
-_MSBuildOnly(_link, 'ImageHasSafeExceptionHandlers', _boolean)  # /SAFESEH
-_MSBuildOnly(_link, 'LinkDLL', _boolean)  # /DLL Visible='false'
-_MSBuildOnly(_link, 'LinkStatus', _boolean)  # /LTCG:STATUS
-_MSBuildOnly(_link, 'PreventDllBinding', _boolean)  # /ALLOWBIND
-_MSBuildOnly(_link, 'SupportNobindOfDelayLoadedDLL', _boolean)  # /DELAY:NOBIND
-_MSBuildOnly(_link, 'TrackerLogDirectory', _folder_name)
-_MSBuildOnly(_link, 'MSDOSStubFileName', _file_name)  # /STUB Visible='false'
-_MSBuildOnly(_link, 'SectionAlignment', _integer)  # /ALIGN
-_MSBuildOnly(_link, 'SpecifySectionAttributes', _string)  # /SECTION
-_MSBuildOnly(_link, 'ForceFileOutput',
-             _Enumeration([], new=['Enabled',  # /FORCE
-                                   # /FORCE:MULTIPLE
-                                   'MultiplyDefinedSymbolOnly',
-                                   'UndefinedSymbolOnly']))  # /FORCE:UNRESOLVED
-_MSBuildOnly(_link, 'CreateHotPatchableImage',
-             _Enumeration([], new=['Enabled',  # /FUNCTIONPADMIN
-                                   'X86Image',  # /FUNCTIONPADMIN:5
-                                   'X64Image',  # /FUNCTIONPADMIN:6
-                                   'ItaniumImage']))  # /FUNCTIONPADMIN:16
-_MSBuildOnly(_link, 'CLRSupportLastError',
-             _Enumeration([], new=['Enabled',  # /CLRSupportLastError
-                                   'Disabled',  # /CLRSupportLastError:NO
-                                   # /CLRSupportLastError:SYSTEMDLL
-                                   'SystemDlls']))
+_MSBuildOnly(_link, "BuildingInIDE", _boolean)
+_MSBuildOnly(_link, "ImageHasSafeExceptionHandlers", _boolean)  # /SAFESEH
+_MSBuildOnly(_link, "LinkDLL", _boolean)  # /DLL Visible='false'
+_MSBuildOnly(_link, "LinkStatus", _boolean)  # /LTCG:STATUS
+_MSBuildOnly(_link, "PreventDllBinding", _boolean)  # /ALLOWBIND
+_MSBuildOnly(_link, "SupportNobindOfDelayLoadedDLL", _boolean)  # /DELAY:NOBIND
+_MSBuildOnly(_link, "TrackerLogDirectory", _folder_name)
+_MSBuildOnly(_link, "MSDOSStubFileName", _file_name)  # /STUB Visible='false'
+_MSBuildOnly(_link, "SectionAlignment", _integer)  # /ALIGN
+_MSBuildOnly(_link, "SpecifySectionAttributes", _string)  # /SECTION
+_MSBuildOnly(
+    _link,
+    "ForceFileOutput",
+    _Enumeration(
+        [],
+        new=[
+            "Enabled",  # /FORCE
+            # /FORCE:MULTIPLE
+            "MultiplyDefinedSymbolOnly",
+            "UndefinedSymbolOnly",
+        ],
+    ),
+)  # /FORCE:UNRESOLVED
+_MSBuildOnly(
+    _link,
+    "CreateHotPatchableImage",
+    _Enumeration(
+        [],
+        new=[
+            "Enabled",  # /FUNCTIONPADMIN
+            "X86Image",  # /FUNCTIONPADMIN:5
+            "X64Image",  # /FUNCTIONPADMIN:6
+            "ItaniumImage",
+        ],
+    ),
+)  # /FUNCTIONPADMIN:16
+_MSBuildOnly(
+    _link,
+    "CLRSupportLastError",
+    _Enumeration(
+        [],
+        new=[
+            "Enabled",  # /CLRSupportLastError
+            "Disabled",  # /CLRSupportLastError:NO
+            # /CLRSupportLastError:SYSTEMDLL
+            "SystemDlls",
+        ],
+    ),
+)
 
 
 # Directives for converting VCResourceCompilerTool to ResourceCompile.
 # See "c:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\1033\rc.xml" for
 # the schema of the MSBuild ResourceCompile settings.
 
-_Same(_rc, 'AdditionalOptions', _string_list)
-_Same(_rc, 'AdditionalIncludeDirectories', _folder_list)  # /I
-_Same(_rc, 'Culture', _Integer(msbuild_base=16))
-_Same(_rc, 'IgnoreStandardIncludePath', _boolean)  # /X
-_Same(_rc, 'PreprocessorDefinitions', _string_list)  # /D
-_Same(_rc, 'ResourceOutputFileName', _string)  # /fo
-_Same(_rc, 'ShowProgress', _boolean)  # /v
+_Same(_rc, "AdditionalOptions", _string_list)
+_Same(_rc, "AdditionalIncludeDirectories", _folder_list)  # /I
+_Same(_rc, "Culture", _Integer(msbuild_base=16))
+_Same(_rc, "IgnoreStandardIncludePath", _boolean)  # /X
+_Same(_rc, "PreprocessorDefinitions", _string_list)  # /D
+_Same(_rc, "ResourceOutputFileName", _string)  # /fo
+_Same(_rc, "ShowProgress", _boolean)  # /v
 # There is no UI in VisualStudio 2008 to set the following properties.
 # However they are found in CL and other tools.  Include them here for
 # completeness, as they are very likely to have the same usage pattern.
-_Same(_rc, 'SuppressStartupBanner', _boolean)  # /nologo
-_Same(_rc, 'UndefinePreprocessorDefinitions', _string_list)  # /u
+_Same(_rc, "SuppressStartupBanner", _boolean)  # /nologo
+_Same(_rc, "UndefinePreprocessorDefinitions", _string_list)  # /u
 
 # MSBuild options not found in MSVS.
-_MSBuildOnly(_rc, 'NullTerminateStrings', _boolean)  # /n
-_MSBuildOnly(_rc, 'TrackerLogDirectory', _folder_name)
+_MSBuildOnly(_rc, "NullTerminateStrings", _boolean)  # /n
+_MSBuildOnly(_rc, "TrackerLogDirectory", _folder_name)
 
 
 # Directives for converting VCMIDLTool to Midl.
 # See "c:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\1033\midl.xml" for
 # the schema of the MSBuild Midl settings.
 
-_Same(_midl, 'AdditionalIncludeDirectories', _folder_list)  # /I
-_Same(_midl, 'AdditionalOptions', _string_list)
-_Same(_midl, 'CPreprocessOptions', _string)  # /cpp_opt
-_Same(_midl, 'ErrorCheckAllocations', _boolean)  # /error allocation
-_Same(_midl, 'ErrorCheckBounds', _boolean)  # /error bounds_check
-_Same(_midl, 'ErrorCheckEnumRange', _boolean)  # /error enum
-_Same(_midl, 'ErrorCheckRefPointers', _boolean)  # /error ref
-_Same(_midl, 'ErrorCheckStubData', _boolean)  # /error stub_data
-_Same(_midl, 'GenerateStublessProxies', _boolean)  # /Oicf
-_Same(_midl, 'GenerateTypeLibrary', _boolean)
-_Same(_midl, 'HeaderFileName', _file_name)  # /h
-_Same(_midl, 'IgnoreStandardIncludePath', _boolean)  # /no_def_idir
-_Same(_midl, 'InterfaceIdentifierFileName', _file_name)  # /iid
-_Same(_midl, 'MkTypLibCompatible', _boolean)  # /mktyplib203
-_Same(_midl, 'OutputDirectory', _string)  # /out
-_Same(_midl, 'PreprocessorDefinitions', _string_list)  # /D
-_Same(_midl, 'ProxyFileName', _file_name)  # /proxy
-_Same(_midl, 'RedirectOutputAndErrors', _file_name)  # /o
-_Same(_midl, 'SuppressStartupBanner', _boolean)  # /nologo
-_Same(_midl, 'TypeLibraryName', _file_name)  # /tlb
-_Same(_midl, 'UndefinePreprocessorDefinitions', _string_list)  # /U
-_Same(_midl, 'WarnAsError', _boolean)  # /WX
-
-_Same(_midl, 'DefaultCharType',
-      _Enumeration(['Unsigned',  # /char unsigned
-                    'Signed',  # /char signed
-                    'Ascii']))  # /char ascii7
-_Same(_midl, 'TargetEnvironment',
-      _Enumeration(['NotSet',
-                    'Win32',  # /env win32
-                    'Itanium',  # /env ia64
-                    'X64',  # /env x64
-                    'ARM64',  # /env arm64
-                    ]))
-_Same(_midl, 'EnableErrorChecks',
-      _Enumeration(['EnableCustom',
-                    'None',  # /error none
-                    'All']))  # /error all
-_Same(_midl, 'StructMemberAlignment',
-      _Enumeration(['NotSet',
-                    '1',  # Zp1
-                    '2',  # Zp2
-                    '4',  # Zp4
-                    '8']))  # Zp8
-_Same(_midl, 'WarningLevel',
-      _Enumeration(['0',  # /W0
-                    '1',  # /W1
-                    '2',  # /W2
-                    '3',  # /W3
-                    '4']))  # /W4
-
-_Renamed(_midl, 'DLLDataFileName', 'DllDataFileName', _file_name)  # /dlldata
-_Renamed(_midl, 'ValidateParameters', 'ValidateAllParameters',
-         _boolean)  # /robust
+_Same(_midl, "AdditionalIncludeDirectories", _folder_list)  # /I
+_Same(_midl, "AdditionalOptions", _string_list)
+_Same(_midl, "CPreprocessOptions", _string)  # /cpp_opt
+_Same(_midl, "ErrorCheckAllocations", _boolean)  # /error allocation
+_Same(_midl, "ErrorCheckBounds", _boolean)  # /error bounds_check
+_Same(_midl, "ErrorCheckEnumRange", _boolean)  # /error enum
+_Same(_midl, "ErrorCheckRefPointers", _boolean)  # /error ref
+_Same(_midl, "ErrorCheckStubData", _boolean)  # /error stub_data
+_Same(_midl, "GenerateStublessProxies", _boolean)  # /Oicf
+_Same(_midl, "GenerateTypeLibrary", _boolean)
+_Same(_midl, "HeaderFileName", _file_name)  # /h
+_Same(_midl, "IgnoreStandardIncludePath", _boolean)  # /no_def_idir
+_Same(_midl, "InterfaceIdentifierFileName", _file_name)  # /iid
+_Same(_midl, "MkTypLibCompatible", _boolean)  # /mktyplib203
+_Same(_midl, "OutputDirectory", _string)  # /out
+_Same(_midl, "PreprocessorDefinitions", _string_list)  # /D
+_Same(_midl, "ProxyFileName", _file_name)  # /proxy
+_Same(_midl, "RedirectOutputAndErrors", _file_name)  # /o
+_Same(_midl, "SuppressStartupBanner", _boolean)  # /nologo
+_Same(_midl, "TypeLibraryName", _file_name)  # /tlb
+_Same(_midl, "UndefinePreprocessorDefinitions", _string_list)  # /U
+_Same(_midl, "WarnAsError", _boolean)  # /WX
+
+_Same(
+    _midl,
+    "DefaultCharType",
+    _Enumeration(["Unsigned", "Signed", "Ascii"]),  # /char unsigned  # /char signed
+)  # /char ascii7
+_Same(
+    _midl,
+    "TargetEnvironment",
+    _Enumeration(
+        [
+            "NotSet",
+            "Win32",  # /env win32
+            "Itanium",  # /env ia64
+            "X64",  # /env x64
+            "ARM64",  # /env arm64
+        ]
+    ),
+)
+_Same(
+    _midl,
+    "EnableErrorChecks",
+    _Enumeration(["EnableCustom", "None", "All"]),  # /error none
+)  # /error all
+_Same(
+    _midl,
+    "StructMemberAlignment",
+    _Enumeration(["NotSet", "1", "2", "4", "8"]),  # Zp1  # Zp2  # Zp4
+)  # Zp8
+_Same(
+    _midl,
+    "WarningLevel",
+    _Enumeration(["0", "1", "2", "3", "4"]),  # /W0  # /W1  # /W2  # /W3
+)  # /W4
+
+_Renamed(_midl, "DLLDataFileName", "DllDataFileName", _file_name)  # /dlldata
+_Renamed(_midl, "ValidateParameters", "ValidateAllParameters", _boolean)  # /robust
 
 # MSBuild options not found in MSVS.
-_MSBuildOnly(_midl, 'ApplicationConfigurationMode', _boolean)  # /app_config
-_MSBuildOnly(_midl, 'ClientStubFile', _file_name)  # /cstub
-_MSBuildOnly(_midl, 'GenerateClientFiles',
-             _Enumeration([], new=['Stub',  # /client stub
-                                   'None']))  # /client none
-_MSBuildOnly(_midl, 'GenerateServerFiles',
-             _Enumeration([], new=['Stub',  # /client stub
-                                   'None']))  # /client none
-_MSBuildOnly(_midl, 'LocaleID', _integer)  # /lcid DECIMAL
-_MSBuildOnly(_midl, 'ServerStubFile', _file_name)  # /sstub
-_MSBuildOnly(_midl, 'SuppressCompilerWarnings', _boolean)  # /no_warn
-_MSBuildOnly(_midl, 'TrackerLogDirectory', _folder_name)
-_MSBuildOnly(_midl, 'TypeLibFormat',
-             _Enumeration([], new=['NewFormat',  # /newtlb
-                                   'OldFormat']))  # /oldtlb
+_MSBuildOnly(_midl, "ApplicationConfigurationMode", _boolean)  # /app_config
+_MSBuildOnly(_midl, "ClientStubFile", _file_name)  # /cstub
+_MSBuildOnly(
+    _midl, "GenerateClientFiles", _Enumeration([], new=["Stub", "None"])  # /client stub
+)  # /client none
+_MSBuildOnly(
+    _midl, "GenerateServerFiles", _Enumeration([], new=["Stub", "None"])  # /client stub
+)  # /client none
+_MSBuildOnly(_midl, "LocaleID", _integer)  # /lcid DECIMAL
+_MSBuildOnly(_midl, "ServerStubFile", _file_name)  # /sstub
+_MSBuildOnly(_midl, "SuppressCompilerWarnings", _boolean)  # /no_warn
+_MSBuildOnly(_midl, "TrackerLogDirectory", _folder_name)
+_MSBuildOnly(
+    _midl, "TypeLibFormat", _Enumeration([], new=["NewFormat", "OldFormat"])  # /newtlb
+)  # /oldtlb
 
 
 # Directives for converting VCLibrarianTool to Lib.
 # See "c:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\1033\lib.xml" for
 # the schema of the MSBuild Lib settings.
 
-_Same(_lib, 'AdditionalDependencies', _file_list)
-_Same(_lib, 'AdditionalLibraryDirectories', _folder_list)  # /LIBPATH
-_Same(_lib, 'AdditionalOptions', _string_list)
-_Same(_lib, 'ExportNamedFunctions', _string_list)  # /EXPORT
-_Same(_lib, 'ForceSymbolReferences', _string)  # /INCLUDE
-_Same(_lib, 'IgnoreAllDefaultLibraries', _boolean)  # /NODEFAULTLIB
-_Same(_lib, 'IgnoreSpecificDefaultLibraries', _file_list)  # /NODEFAULTLIB
-_Same(_lib, 'ModuleDefinitionFile', _file_name)  # /DEF
-_Same(_lib, 'OutputFile', _file_name)  # /OUT
-_Same(_lib, 'SuppressStartupBanner', _boolean)  # /NOLOGO
-_Same(_lib, 'UseUnicodeResponseFiles', _boolean)
-_Same(_lib, 'LinkTimeCodeGeneration', _boolean)  # /LTCG
-_Same(_lib, 'TargetMachine', _target_machine_enumeration)
+_Same(_lib, "AdditionalDependencies", _file_list)
+_Same(_lib, "AdditionalLibraryDirectories", _folder_list)  # /LIBPATH
+_Same(_lib, "AdditionalOptions", _string_list)
+_Same(_lib, "ExportNamedFunctions", _string_list)  # /EXPORT
+_Same(_lib, "ForceSymbolReferences", _string)  # /INCLUDE
+_Same(_lib, "IgnoreAllDefaultLibraries", _boolean)  # /NODEFAULTLIB
+_Same(_lib, "IgnoreSpecificDefaultLibraries", _file_list)  # /NODEFAULTLIB
+_Same(_lib, "ModuleDefinitionFile", _file_name)  # /DEF
+_Same(_lib, "OutputFile", _file_name)  # /OUT
+_Same(_lib, "SuppressStartupBanner", _boolean)  # /NOLOGO
+_Same(_lib, "UseUnicodeResponseFiles", _boolean)
+_Same(_lib, "LinkTimeCodeGeneration", _boolean)  # /LTCG
+_Same(_lib, "TargetMachine", _target_machine_enumeration)
 
 # TODO(jeanluc) _link defines the same value that gets moved to
 # ProjectReference.  We may want to validate that they are consistent.
-_Moved(_lib, 'LinkLibraryDependencies', 'ProjectReference', _boolean)
-
-_MSBuildOnly(_lib, 'DisplayLibrary', _string)  # /LIST Visible='false'
-_MSBuildOnly(_lib, 'ErrorReporting',
-             _Enumeration([], new=['PromptImmediately',  # /ERRORREPORT:PROMPT
-                                   'QueueForNextLogin',  # /ERRORREPORT:QUEUE
-                                   'SendErrorReport',  # /ERRORREPORT:SEND
-                                   'NoErrorReport']))  # /ERRORREPORT:NONE
-_MSBuildOnly(_lib, 'MinimumRequiredVersion', _string)
-_MSBuildOnly(_lib, 'Name', _file_name)  # /NAME
-_MSBuildOnly(_lib, 'RemoveObjects', _file_list)  # /REMOVE
-_MSBuildOnly(_lib, 'SubSystem', _subsystem_enumeration)
-_MSBuildOnly(_lib, 'TrackerLogDirectory', _folder_name)
-_MSBuildOnly(_lib, 'TreatLibWarningAsErrors', _boolean)  # /WX
-_MSBuildOnly(_lib, 'Verbose', _boolean)
+_Moved(_lib, "LinkLibraryDependencies", "ProjectReference", _boolean)
+
+_MSBuildOnly(_lib, "DisplayLibrary", _string)  # /LIST Visible='false'
+_MSBuildOnly(
+    _lib,
+    "ErrorReporting",
+    _Enumeration(
+        [],
+        new=[
+            "PromptImmediately",  # /ERRORREPORT:PROMPT
+            "QueueForNextLogin",  # /ERRORREPORT:QUEUE
+            "SendErrorReport",  # /ERRORREPORT:SEND
+            "NoErrorReport",
+        ],
+    ),
+)  # /ERRORREPORT:NONE
+_MSBuildOnly(_lib, "MinimumRequiredVersion", _string)
+_MSBuildOnly(_lib, "Name", _file_name)  # /NAME
+_MSBuildOnly(_lib, "RemoveObjects", _file_list)  # /REMOVE
+_MSBuildOnly(_lib, "SubSystem", _subsystem_enumeration)
+_MSBuildOnly(_lib, "TrackerLogDirectory", _folder_name)
+_MSBuildOnly(_lib, "TreatLibWarningAsErrors", _boolean)  # /WX
+_MSBuildOnly(_lib, "Verbose", _boolean)
 
 
 # Directives for converting VCManifestTool to Mt.
@@ -1060,41 +1225,45 @@ _MSBuildOnly(_lib, 'Verbose', _boolean)
 # the schema of the MSBuild Lib settings.
 
 # Options that have the same name in MSVS and MSBuild
-_Same(_manifest, 'AdditionalManifestFiles', _file_list)  # /manifest
-_Same(_manifest, 'AdditionalOptions', _string_list)
-_Same(_manifest, 'AssemblyIdentity', _string)  # /identity:
-_Same(_manifest, 'ComponentFileName', _file_name)  # /dll
-_Same(_manifest, 'GenerateCatalogFiles', _boolean)  # /makecdfs
-_Same(_manifest, 'InputResourceManifests', _string)  # /inputresource
-_Same(_manifest, 'OutputManifestFile', _file_name)  # /out
-_Same(_manifest, 'RegistrarScriptFile', _file_name)  # /rgs
-_Same(_manifest, 'ReplacementsFile', _file_name)  # /replacements
-_Same(_manifest, 'SuppressStartupBanner', _boolean)  # /nologo
-_Same(_manifest, 'TypeLibraryFile', _file_name)  # /tlb:
-_Same(_manifest, 'UpdateFileHashes', _boolean)  # /hashupdate
-_Same(_manifest, 'UpdateFileHashesSearchPath', _file_name)
-_Same(_manifest, 'VerboseOutput', _boolean)  # /verbose
+_Same(_manifest, "AdditionalManifestFiles", _file_list)  # /manifest
+_Same(_manifest, "AdditionalOptions", _string_list)
+_Same(_manifest, "AssemblyIdentity", _string)  # /identity:
+_Same(_manifest, "ComponentFileName", _file_name)  # /dll
+_Same(_manifest, "GenerateCatalogFiles", _boolean)  # /makecdfs
+_Same(_manifest, "InputResourceManifests", _string)  # /inputresource
+_Same(_manifest, "OutputManifestFile", _file_name)  # /out
+_Same(_manifest, "RegistrarScriptFile", _file_name)  # /rgs
+_Same(_manifest, "ReplacementsFile", _file_name)  # /replacements
+_Same(_manifest, "SuppressStartupBanner", _boolean)  # /nologo
+_Same(_manifest, "TypeLibraryFile", _file_name)  # /tlb:
+_Same(_manifest, "UpdateFileHashes", _boolean)  # /hashupdate
+_Same(_manifest, "UpdateFileHashesSearchPath", _file_name)
+_Same(_manifest, "VerboseOutput", _boolean)  # /verbose
 
 # Options that have moved location.
-_MovedAndRenamed(_manifest, 'ManifestResourceFile',
-                 'ManifestResourceCompile',
-                 'ResourceOutputFileName',
-                 _file_name)
-_Moved(_manifest, 'EmbedManifest', '', _boolean)
+_MovedAndRenamed(
+    _manifest,
+    "ManifestResourceFile",
+    "ManifestResourceCompile",
+    "ResourceOutputFileName",
+    _file_name,
+)
+_Moved(_manifest, "EmbedManifest", "", _boolean)
 
 # MSVS options not found in MSBuild.
-_MSVSOnly(_manifest, 'DependencyInformationFile', _file_name)
-_MSVSOnly(_manifest, 'UseFAT32Workaround', _boolean)
-_MSVSOnly(_manifest, 'UseUnicodeResponseFiles', _boolean)
+_MSVSOnly(_manifest, "DependencyInformationFile", _file_name)
+_MSVSOnly(_manifest, "UseFAT32Workaround", _boolean)
+_MSVSOnly(_manifest, "UseUnicodeResponseFiles", _boolean)
 
 # MSBuild options not found in MSVS.
-_MSBuildOnly(_manifest, 'EnableDPIAwareness', _boolean)
-_MSBuildOnly(_manifest, 'GenerateCategoryTags', _boolean)  # /category
-_MSBuildOnly(_manifest, 'ManifestFromManagedAssembly',
-             _file_name)  # /managedassemblyname
-_MSBuildOnly(_manifest, 'OutputResourceManifests', _string)  # /outputresource
-_MSBuildOnly(_manifest, 'SuppressDependencyElement', _boolean)  # /nodependency
-_MSBuildOnly(_manifest, 'TrackerLogDirectory', _folder_name)
+_MSBuildOnly(_manifest, "EnableDPIAwareness", _boolean)
+_MSBuildOnly(_manifest, "GenerateCategoryTags", _boolean)  # /category
+_MSBuildOnly(
+    _manifest, "ManifestFromManagedAssembly", _file_name
+)  # /managedassemblyname
+_MSBuildOnly(_manifest, "OutputResourceManifests", _string)  # /outputresource
+_MSBuildOnly(_manifest, "SuppressDependencyElement", _boolean)  # /nodependency
+_MSBuildOnly(_manifest, "TrackerLogDirectory", _folder_name)
 
 
 # Directives for MASM.
@@ -1102,4 +1271,4 @@ _MSBuildOnly(_manifest, 'TrackerLogDirectory', _folder_name)
 # MSBuild MASM settings.
 
 # Options that have the same name in MSVS and MSBuild.
-_Same(_masm, 'UseSafeExceptionHandlers', _boolean)  # /safeseh
+_Same(_masm, "UseSafeExceptionHandlers", _boolean)  # /safeseh
diff --git a/tools/gyp/pylib/gyp/MSVSSettings_test.py b/tools/gyp/pylib/gyp/MSVSSettings_test.py
index 77b79e650d8b4e4afccef21b19922c5873a40224..99860c880ec5d084f7669b8c8c5465ffddd82cfd 100755
--- a/tools/gyp/pylib/gyp/MSVSSettings_test.py
+++ b/tools/gyp/pylib/gyp/MSVSSettings_test.py
@@ -10,1090 +10,1141 @@ import unittest
 import gyp.MSVSSettings as MSVSSettings
 
 try:
-  from StringIO import StringIO  # Python 2
+    from StringIO import StringIO  # Python 2
 except ImportError:
-  from io import StringIO  # Python 3
+    from io import StringIO  # Python 3
 
 
 class TestSequenceFunctions(unittest.TestCase):
+    def setUp(self):
+        self.stderr = StringIO()
 
-  def setUp(self):
-    self.stderr = StringIO()
+    def _ExpectedWarnings(self, expected):
+        """Compares recorded lines to expected warnings."""
+        self.stderr.seek(0)
+        actual = self.stderr.read().split("\n")
+        actual = [line for line in actual if line]
+        self.assertEqual(sorted(expected), sorted(actual))
 
-  def _ExpectedWarnings(self, expected):
-    """Compares recorded lines to expected warnings."""
-    self.stderr.seek(0)
-    actual = self.stderr.read().split('\n')
-    actual = [line for line in actual if line]
-    self.assertEqual(sorted(expected), sorted(actual))
-
-  def testValidateMSVSSettings_tool_names(self):
-    """Tests that only MSVS tool names are allowed."""
-    MSVSSettings.ValidateMSVSSettings(
-        {'VCCLCompilerTool': {},
-         'VCLinkerTool': {},
-         'VCMIDLTool': {},
-         'foo': {},
-         'VCResourceCompilerTool': {},
-         'VCLibrarianTool': {},
-         'VCManifestTool': {},
-         'ClCompile': {}},
-        self.stderr)
-    self._ExpectedWarnings([
-        'Warning: unrecognized tool foo',
-        'Warning: unrecognized tool ClCompile'])
+    def testValidateMSVSSettings_tool_names(self):
+        """Tests that only MSVS tool names are allowed."""
+        MSVSSettings.ValidateMSVSSettings(
+            {
+                "VCCLCompilerTool": {},
+                "VCLinkerTool": {},
+                "VCMIDLTool": {},
+                "foo": {},
+                "VCResourceCompilerTool": {},
+                "VCLibrarianTool": {},
+                "VCManifestTool": {},
+                "ClCompile": {},
+            },
+            self.stderr,
+        )
+        self._ExpectedWarnings(
+            ["Warning: unrecognized tool foo", "Warning: unrecognized tool ClCompile"]
+        )
 
-  def testValidateMSVSSettings_settings(self):
-    """Tests that for invalid MSVS settings."""
-    MSVSSettings.ValidateMSVSSettings(
-        {'VCCLCompilerTool': {
-            'AdditionalIncludeDirectories': 'folder1;folder2',
-            'AdditionalOptions': ['string1', 'string2'],
-            'AdditionalUsingDirectories': 'folder1;folder2',
-            'AssemblerListingLocation': 'a_file_name',
-            'AssemblerOutput': '0',
-            'BasicRuntimeChecks': '5',
-            'BrowseInformation': 'fdkslj',
-            'BrowseInformationFile': 'a_file_name',
-            'BufferSecurityCheck': 'true',
-            'CallingConvention': '-1',
-            'CompileAs': '1',
-            'DebugInformationFormat': '2',
-            'DefaultCharIsUnsigned': 'true',
-            'Detect64BitPortabilityProblems': 'true',
-            'DisableLanguageExtensions': 'true',
-            'DisableSpecificWarnings': 'string1;string2',
-            'EnableEnhancedInstructionSet': '1',
-            'EnableFiberSafeOptimizations': 'true',
-            'EnableFunctionLevelLinking': 'true',
-            'EnableIntrinsicFunctions': 'true',
-            'EnablePREfast': 'true',
-            'Enableprefast': 'bogus',
-            'ErrorReporting': '1',
-            'ExceptionHandling': '1',
-            'ExpandAttributedSource': 'true',
-            'FavorSizeOrSpeed': '1',
-            'FloatingPointExceptions': 'true',
-            'FloatingPointModel': '1',
-            'ForceConformanceInForLoopScope': 'true',
-            'ForcedIncludeFiles': 'file1;file2',
-            'ForcedUsingFiles': 'file1;file2',
-            'GeneratePreprocessedFile': '1',
-            'GenerateXMLDocumentationFiles': 'true',
-            'IgnoreStandardIncludePath': 'true',
-            'InlineFunctionExpansion': '1',
-            'KeepComments': 'true',
-            'MinimalRebuild': 'true',
-            'ObjectFile': 'a_file_name',
-            'OmitDefaultLibName': 'true',
-            'OmitFramePointers': 'true',
-            'OpenMP': 'true',
-            'Optimization': '1',
-            'PrecompiledHeaderFile': 'a_file_name',
-            'PrecompiledHeaderThrough': 'a_file_name',
-            'PreprocessorDefinitions': 'string1;string2',
-            'ProgramDataBaseFileName': 'a_file_name',
-            'RuntimeLibrary': '1',
-            'RuntimeTypeInfo': 'true',
-            'ShowIncludes': 'true',
-            'SmallerTypeCheck': 'true',
-            'StringPooling': 'true',
-            'StructMemberAlignment': '1',
-            'SuppressStartupBanner': 'true',
-            'TreatWChar_tAsBuiltInType': 'true',
-            'UndefineAllPreprocessorDefinitions': 'true',
-            'UndefinePreprocessorDefinitions': 'string1;string2',
-            'UseFullPaths': 'true',
-            'UsePrecompiledHeader': '1',
-            'UseUnicodeResponseFiles': 'true',
-            'WarnAsError': 'true',
-            'WarningLevel': '1',
-            'WholeProgramOptimization': 'true',
-            'XMLDocumentationFileName': 'a_file_name',
-            'ZZXYZ': 'bogus'},
-         'VCLinkerTool': {
-             'AdditionalDependencies': 'file1;file2',
-             'AdditionalDependencies_excluded': 'file3',
-             'AdditionalLibraryDirectories': 'folder1;folder2',
-             'AdditionalManifestDependencies': 'file1;file2',
-             'AdditionalOptions': 'a string1',
-             'AddModuleNamesToAssembly': 'file1;file2',
-             'AllowIsolation': 'true',
-             'AssemblyDebug': '2',
-             'AssemblyLinkResource': 'file1;file2',
-             'BaseAddress': 'a string1',
-             'CLRImageType': '2',
-             'CLRThreadAttribute': '2',
-             'CLRUnmanagedCodeCheck': 'true',
-             'DataExecutionPrevention': '2',
-             'DelayLoadDLLs': 'file1;file2',
-             'DelaySign': 'true',
-             'Driver': '2',
-             'EmbedManagedResourceFile': 'file1;file2',
-             'EnableCOMDATFolding': '2',
-             'EnableUAC': 'true',
-             'EntryPointSymbol': 'a string1',
-             'ErrorReporting': '2',
-             'FixedBaseAddress': '2',
-             'ForceSymbolReferences': 'file1;file2',
-             'FunctionOrder': 'a_file_name',
-             'GenerateDebugInformation': 'true',
-             'GenerateManifest': 'true',
-             'GenerateMapFile': 'true',
-             'HeapCommitSize': 'a string1',
-             'HeapReserveSize': 'a string1',
-             'IgnoreAllDefaultLibraries': 'true',
-             'IgnoreDefaultLibraryNames': 'file1;file2',
-             'IgnoreEmbeddedIDL': 'true',
-             'IgnoreImportLibrary': 'true',
-             'ImportLibrary': 'a_file_name',
-             'KeyContainer': 'a_file_name',
-             'KeyFile': 'a_file_name',
-             'LargeAddressAware': '2',
-             'LinkIncremental': '2',
-             'LinkLibraryDependencies': 'true',
-             'LinkTimeCodeGeneration': '2',
-             'ManifestFile': 'a_file_name',
-             'MapExports': 'true',
-             'MapFileName': 'a_file_name',
-             'MergedIDLBaseFileName': 'a_file_name',
-             'MergeSections': 'a string1',
-             'MidlCommandFile': 'a_file_name',
-             'ModuleDefinitionFile': 'a_file_name',
-             'OptimizeForWindows98': '1',
-             'OptimizeReferences': '2',
-             'OutputFile': 'a_file_name',
-             'PerUserRedirection': 'true',
-             'Profile': 'true',
-             'ProfileGuidedDatabase': 'a_file_name',
-             'ProgramDatabaseFile': 'a_file_name',
-             'RandomizedBaseAddress': '2',
-             'RegisterOutput': 'true',
-             'ResourceOnlyDLL': 'true',
-             'SetChecksum': 'true',
-             'ShowProgress': '2',
-             'StackCommitSize': 'a string1',
-             'StackReserveSize': 'a string1',
-             'StripPrivateSymbols': 'a_file_name',
-             'SubSystem': '2',
-             'SupportUnloadOfDelayLoadedDLL': 'true',
-             'SuppressStartupBanner': 'true',
-             'SwapRunFromCD': 'true',
-             'SwapRunFromNet': 'true',
-             'TargetMachine': '2',
-             'TerminalServerAware': '2',
-             'TurnOffAssemblyGeneration': 'true',
-             'TypeLibraryFile': 'a_file_name',
-             'TypeLibraryResourceID': '33',
-             'UACExecutionLevel': '2',
-             'UACUIAccess': 'true',
-             'UseLibraryDependencyInputs': 'true',
-             'UseUnicodeResponseFiles': 'true',
-             'Version': 'a string1'},
-         'VCMIDLTool': {
-             'AdditionalIncludeDirectories': 'folder1;folder2',
-             'AdditionalOptions': 'a string1',
-             'CPreprocessOptions': 'a string1',
-             'DefaultCharType': '1',
-             'DLLDataFileName': 'a_file_name',
-             'EnableErrorChecks': '1',
-             'ErrorCheckAllocations': 'true',
-             'ErrorCheckBounds': 'true',
-             'ErrorCheckEnumRange': 'true',
-             'ErrorCheckRefPointers': 'true',
-             'ErrorCheckStubData': 'true',
-             'GenerateStublessProxies': 'true',
-             'GenerateTypeLibrary': 'true',
-             'HeaderFileName': 'a_file_name',
-             'IgnoreStandardIncludePath': 'true',
-             'InterfaceIdentifierFileName': 'a_file_name',
-             'MkTypLibCompatible': 'true',
-             'notgood': 'bogus',
-             'OutputDirectory': 'a string1',
-             'PreprocessorDefinitions': 'string1;string2',
-             'ProxyFileName': 'a_file_name',
-             'RedirectOutputAndErrors': 'a_file_name',
-             'StructMemberAlignment': '1',
-             'SuppressStartupBanner': 'true',
-             'TargetEnvironment': '1',
-             'TypeLibraryName': 'a_file_name',
-             'UndefinePreprocessorDefinitions': 'string1;string2',
-             'ValidateParameters': 'true',
-             'WarnAsError': 'true',
-             'WarningLevel': '1'},
-         'VCResourceCompilerTool': {
-             'AdditionalOptions': 'a string1',
-             'AdditionalIncludeDirectories': 'folder1;folder2',
-             'Culture': '1003',
-             'IgnoreStandardIncludePath': 'true',
-             'notgood2': 'bogus',
-             'PreprocessorDefinitions': 'string1;string2',
-             'ResourceOutputFileName': 'a string1',
-             'ShowProgress': 'true',
-             'SuppressStartupBanner': 'true',
-             'UndefinePreprocessorDefinitions': 'string1;string2'},
-         'VCLibrarianTool': {
-             'AdditionalDependencies': 'file1;file2',
-             'AdditionalLibraryDirectories': 'folder1;folder2',
-             'AdditionalOptions': 'a string1',
-             'ExportNamedFunctions': 'string1;string2',
-             'ForceSymbolReferences': 'a string1',
-             'IgnoreAllDefaultLibraries': 'true',
-             'IgnoreSpecificDefaultLibraries': 'file1;file2',
-             'LinkLibraryDependencies': 'true',
-             'ModuleDefinitionFile': 'a_file_name',
-             'OutputFile': 'a_file_name',
-             'SuppressStartupBanner': 'true',
-             'UseUnicodeResponseFiles': 'true'},
-         'VCManifestTool': {
-             'AdditionalManifestFiles': 'file1;file2',
-             'AdditionalOptions': 'a string1',
-             'AssemblyIdentity': 'a string1',
-             'ComponentFileName': 'a_file_name',
-             'DependencyInformationFile': 'a_file_name',
-             'GenerateCatalogFiles': 'true',
-             'InputResourceManifests': 'a string1',
-             'ManifestResourceFile': 'a_file_name',
-             'OutputManifestFile': 'a_file_name',
-             'RegistrarScriptFile': 'a_file_name',
-             'ReplacementsFile': 'a_file_name',
-             'SuppressStartupBanner': 'true',
-             'TypeLibraryFile': 'a_file_name',
-             'UpdateFileHashes': 'truel',
-             'UpdateFileHashesSearchPath': 'a_file_name',
-             'UseFAT32Workaround': 'true',
-             'UseUnicodeResponseFiles': 'true',
-             'VerboseOutput': 'true'}},
-        self.stderr)
-    self._ExpectedWarnings([
-        'Warning: for VCCLCompilerTool/BasicRuntimeChecks, '
-        'index value (5) not in expected range [0, 4)',
-        'Warning: for VCCLCompilerTool/BrowseInformation, '
-        "invalid literal for int() with base 10: 'fdkslj'",
-        'Warning: for VCCLCompilerTool/CallingConvention, '
-        'index value (-1) not in expected range [0, 4)',
-        'Warning: for VCCLCompilerTool/DebugInformationFormat, '
-        'converted value for 2 not specified.',
-        'Warning: unrecognized setting VCCLCompilerTool/Enableprefast',
-        'Warning: unrecognized setting VCCLCompilerTool/ZZXYZ',
-        'Warning: for VCLinkerTool/TargetMachine, '
-        'converted value for 2 not specified.',
-        'Warning: unrecognized setting VCMIDLTool/notgood',
-        'Warning: unrecognized setting VCResourceCompilerTool/notgood2',
-        'Warning: for VCManifestTool/UpdateFileHashes, '
-        "expected bool; got 'truel'"
-        ''])
+    def testValidateMSVSSettings_settings(self):
+        """Tests that for invalid MSVS settings."""
+        MSVSSettings.ValidateMSVSSettings(
+            {
+                "VCCLCompilerTool": {
+                    "AdditionalIncludeDirectories": "folder1;folder2",
+                    "AdditionalOptions": ["string1", "string2"],
+                    "AdditionalUsingDirectories": "folder1;folder2",
+                    "AssemblerListingLocation": "a_file_name",
+                    "AssemblerOutput": "0",
+                    "BasicRuntimeChecks": "5",
+                    "BrowseInformation": "fdkslj",
+                    "BrowseInformationFile": "a_file_name",
+                    "BufferSecurityCheck": "true",
+                    "CallingConvention": "-1",
+                    "CompileAs": "1",
+                    "DebugInformationFormat": "2",
+                    "DefaultCharIsUnsigned": "true",
+                    "Detect64BitPortabilityProblems": "true",
+                    "DisableLanguageExtensions": "true",
+                    "DisableSpecificWarnings": "string1;string2",
+                    "EnableEnhancedInstructionSet": "1",
+                    "EnableFiberSafeOptimizations": "true",
+                    "EnableFunctionLevelLinking": "true",
+                    "EnableIntrinsicFunctions": "true",
+                    "EnablePREfast": "true",
+                    "Enableprefast": "bogus",
+                    "ErrorReporting": "1",
+                    "ExceptionHandling": "1",
+                    "ExpandAttributedSource": "true",
+                    "FavorSizeOrSpeed": "1",
+                    "FloatingPointExceptions": "true",
+                    "FloatingPointModel": "1",
+                    "ForceConformanceInForLoopScope": "true",
+                    "ForcedIncludeFiles": "file1;file2",
+                    "ForcedUsingFiles": "file1;file2",
+                    "GeneratePreprocessedFile": "1",
+                    "GenerateXMLDocumentationFiles": "true",
+                    "IgnoreStandardIncludePath": "true",
+                    "InlineFunctionExpansion": "1",
+                    "KeepComments": "true",
+                    "MinimalRebuild": "true",
+                    "ObjectFile": "a_file_name",
+                    "OmitDefaultLibName": "true",
+                    "OmitFramePointers": "true",
+                    "OpenMP": "true",
+                    "Optimization": "1",
+                    "PrecompiledHeaderFile": "a_file_name",
+                    "PrecompiledHeaderThrough": "a_file_name",
+                    "PreprocessorDefinitions": "string1;string2",
+                    "ProgramDataBaseFileName": "a_file_name",
+                    "RuntimeLibrary": "1",
+                    "RuntimeTypeInfo": "true",
+                    "ShowIncludes": "true",
+                    "SmallerTypeCheck": "true",
+                    "StringPooling": "true",
+                    "StructMemberAlignment": "1",
+                    "SuppressStartupBanner": "true",
+                    "TreatWChar_tAsBuiltInType": "true",
+                    "UndefineAllPreprocessorDefinitions": "true",
+                    "UndefinePreprocessorDefinitions": "string1;string2",
+                    "UseFullPaths": "true",
+                    "UsePrecompiledHeader": "1",
+                    "UseUnicodeResponseFiles": "true",
+                    "WarnAsError": "true",
+                    "WarningLevel": "1",
+                    "WholeProgramOptimization": "true",
+                    "XMLDocumentationFileName": "a_file_name",
+                    "ZZXYZ": "bogus",
+                },
+                "VCLinkerTool": {
+                    "AdditionalDependencies": "file1;file2",
+                    "AdditionalDependencies_excluded": "file3",
+                    "AdditionalLibraryDirectories": "folder1;folder2",
+                    "AdditionalManifestDependencies": "file1;file2",
+                    "AdditionalOptions": "a string1",
+                    "AddModuleNamesToAssembly": "file1;file2",
+                    "AllowIsolation": "true",
+                    "AssemblyDebug": "2",
+                    "AssemblyLinkResource": "file1;file2",
+                    "BaseAddress": "a string1",
+                    "CLRImageType": "2",
+                    "CLRThreadAttribute": "2",
+                    "CLRUnmanagedCodeCheck": "true",
+                    "DataExecutionPrevention": "2",
+                    "DelayLoadDLLs": "file1;file2",
+                    "DelaySign": "true",
+                    "Driver": "2",
+                    "EmbedManagedResourceFile": "file1;file2",
+                    "EnableCOMDATFolding": "2",
+                    "EnableUAC": "true",
+                    "EntryPointSymbol": "a string1",
+                    "ErrorReporting": "2",
+                    "FixedBaseAddress": "2",
+                    "ForceSymbolReferences": "file1;file2",
+                    "FunctionOrder": "a_file_name",
+                    "GenerateDebugInformation": "true",
+                    "GenerateManifest": "true",
+                    "GenerateMapFile": "true",
+                    "HeapCommitSize": "a string1",
+                    "HeapReserveSize": "a string1",
+                    "IgnoreAllDefaultLibraries": "true",
+                    "IgnoreDefaultLibraryNames": "file1;file2",
+                    "IgnoreEmbeddedIDL": "true",
+                    "IgnoreImportLibrary": "true",
+                    "ImportLibrary": "a_file_name",
+                    "KeyContainer": "a_file_name",
+                    "KeyFile": "a_file_name",
+                    "LargeAddressAware": "2",
+                    "LinkIncremental": "2",
+                    "LinkLibraryDependencies": "true",
+                    "LinkTimeCodeGeneration": "2",
+                    "ManifestFile": "a_file_name",
+                    "MapExports": "true",
+                    "MapFileName": "a_file_name",
+                    "MergedIDLBaseFileName": "a_file_name",
+                    "MergeSections": "a string1",
+                    "MidlCommandFile": "a_file_name",
+                    "ModuleDefinitionFile": "a_file_name",
+                    "OptimizeForWindows98": "1",
+                    "OptimizeReferences": "2",
+                    "OutputFile": "a_file_name",
+                    "PerUserRedirection": "true",
+                    "Profile": "true",
+                    "ProfileGuidedDatabase": "a_file_name",
+                    "ProgramDatabaseFile": "a_file_name",
+                    "RandomizedBaseAddress": "2",
+                    "RegisterOutput": "true",
+                    "ResourceOnlyDLL": "true",
+                    "SetChecksum": "true",
+                    "ShowProgress": "2",
+                    "StackCommitSize": "a string1",
+                    "StackReserveSize": "a string1",
+                    "StripPrivateSymbols": "a_file_name",
+                    "SubSystem": "2",
+                    "SupportUnloadOfDelayLoadedDLL": "true",
+                    "SuppressStartupBanner": "true",
+                    "SwapRunFromCD": "true",
+                    "SwapRunFromNet": "true",
+                    "TargetMachine": "2",
+                    "TerminalServerAware": "2",
+                    "TurnOffAssemblyGeneration": "true",
+                    "TypeLibraryFile": "a_file_name",
+                    "TypeLibraryResourceID": "33",
+                    "UACExecutionLevel": "2",
+                    "UACUIAccess": "true",
+                    "UseLibraryDependencyInputs": "true",
+                    "UseUnicodeResponseFiles": "true",
+                    "Version": "a string1",
+                },
+                "VCMIDLTool": {
+                    "AdditionalIncludeDirectories": "folder1;folder2",
+                    "AdditionalOptions": "a string1",
+                    "CPreprocessOptions": "a string1",
+                    "DefaultCharType": "1",
+                    "DLLDataFileName": "a_file_name",
+                    "EnableErrorChecks": "1",
+                    "ErrorCheckAllocations": "true",
+                    "ErrorCheckBounds": "true",
+                    "ErrorCheckEnumRange": "true",
+                    "ErrorCheckRefPointers": "true",
+                    "ErrorCheckStubData": "true",
+                    "GenerateStublessProxies": "true",
+                    "GenerateTypeLibrary": "true",
+                    "HeaderFileName": "a_file_name",
+                    "IgnoreStandardIncludePath": "true",
+                    "InterfaceIdentifierFileName": "a_file_name",
+                    "MkTypLibCompatible": "true",
+                    "notgood": "bogus",
+                    "OutputDirectory": "a string1",
+                    "PreprocessorDefinitions": "string1;string2",
+                    "ProxyFileName": "a_file_name",
+                    "RedirectOutputAndErrors": "a_file_name",
+                    "StructMemberAlignment": "1",
+                    "SuppressStartupBanner": "true",
+                    "TargetEnvironment": "1",
+                    "TypeLibraryName": "a_file_name",
+                    "UndefinePreprocessorDefinitions": "string1;string2",
+                    "ValidateParameters": "true",
+                    "WarnAsError": "true",
+                    "WarningLevel": "1",
+                },
+                "VCResourceCompilerTool": {
+                    "AdditionalOptions": "a string1",
+                    "AdditionalIncludeDirectories": "folder1;folder2",
+                    "Culture": "1003",
+                    "IgnoreStandardIncludePath": "true",
+                    "notgood2": "bogus",
+                    "PreprocessorDefinitions": "string1;string2",
+                    "ResourceOutputFileName": "a string1",
+                    "ShowProgress": "true",
+                    "SuppressStartupBanner": "true",
+                    "UndefinePreprocessorDefinitions": "string1;string2",
+                },
+                "VCLibrarianTool": {
+                    "AdditionalDependencies": "file1;file2",
+                    "AdditionalLibraryDirectories": "folder1;folder2",
+                    "AdditionalOptions": "a string1",
+                    "ExportNamedFunctions": "string1;string2",
+                    "ForceSymbolReferences": "a string1",
+                    "IgnoreAllDefaultLibraries": "true",
+                    "IgnoreSpecificDefaultLibraries": "file1;file2",
+                    "LinkLibraryDependencies": "true",
+                    "ModuleDefinitionFile": "a_file_name",
+                    "OutputFile": "a_file_name",
+                    "SuppressStartupBanner": "true",
+                    "UseUnicodeResponseFiles": "true",
+                },
+                "VCManifestTool": {
+                    "AdditionalManifestFiles": "file1;file2",
+                    "AdditionalOptions": "a string1",
+                    "AssemblyIdentity": "a string1",
+                    "ComponentFileName": "a_file_name",
+                    "DependencyInformationFile": "a_file_name",
+                    "GenerateCatalogFiles": "true",
+                    "InputResourceManifests": "a string1",
+                    "ManifestResourceFile": "a_file_name",
+                    "OutputManifestFile": "a_file_name",
+                    "RegistrarScriptFile": "a_file_name",
+                    "ReplacementsFile": "a_file_name",
+                    "SuppressStartupBanner": "true",
+                    "TypeLibraryFile": "a_file_name",
+                    "UpdateFileHashes": "truel",
+                    "UpdateFileHashesSearchPath": "a_file_name",
+                    "UseFAT32Workaround": "true",
+                    "UseUnicodeResponseFiles": "true",
+                    "VerboseOutput": "true",
+                },
+            },
+            self.stderr,
+        )
+        self._ExpectedWarnings(
+            [
+                "Warning: for VCCLCompilerTool/BasicRuntimeChecks, "
+                "index value (5) not in expected range [0, 4)",
+                "Warning: for VCCLCompilerTool/BrowseInformation, "
+                "invalid literal for int() with base 10: 'fdkslj'",
+                "Warning: for VCCLCompilerTool/CallingConvention, "
+                "index value (-1) not in expected range [0, 4)",
+                "Warning: for VCCLCompilerTool/DebugInformationFormat, "
+                "converted value for 2 not specified.",
+                "Warning: unrecognized setting VCCLCompilerTool/Enableprefast",
+                "Warning: unrecognized setting VCCLCompilerTool/ZZXYZ",
+                "Warning: for VCLinkerTool/TargetMachine, "
+                "converted value for 2 not specified.",
+                "Warning: unrecognized setting VCMIDLTool/notgood",
+                "Warning: unrecognized setting VCResourceCompilerTool/notgood2",
+                "Warning: for VCManifestTool/UpdateFileHashes, "
+                "expected bool; got 'truel'"
+                "",
+            ]
+        )
 
-  def testValidateMSBuildSettings_settings(self):
-    """Tests that for invalid MSBuild settings."""
-    MSVSSettings.ValidateMSBuildSettings(
-        {'ClCompile': {
-            'AdditionalIncludeDirectories': 'folder1;folder2',
-            'AdditionalOptions': ['string1', 'string2'],
-            'AdditionalUsingDirectories': 'folder1;folder2',
-            'AssemblerListingLocation': 'a_file_name',
-            'AssemblerOutput': 'NoListing',
-            'BasicRuntimeChecks': 'StackFrameRuntimeCheck',
-            'BrowseInformation': 'false',
-            'BrowseInformationFile': 'a_file_name',
-            'BufferSecurityCheck': 'true',
-            'BuildingInIDE': 'true',
-            'CallingConvention': 'Cdecl',
-            'CompileAs': 'CompileAsC',
-            'CompileAsManaged': 'true',
-            'CreateHotpatchableImage': 'true',
-            'DebugInformationFormat': 'ProgramDatabase',
-            'DisableLanguageExtensions': 'true',
-            'DisableSpecificWarnings': 'string1;string2',
-            'EnableEnhancedInstructionSet': 'StreamingSIMDExtensions',
-            'EnableFiberSafeOptimizations': 'true',
-            'EnablePREfast': 'true',
-            'Enableprefast': 'bogus',
-            'ErrorReporting': 'Prompt',
-            'ExceptionHandling': 'SyncCThrow',
-            'ExpandAttributedSource': 'true',
-            'FavorSizeOrSpeed': 'Neither',
-            'FloatingPointExceptions': 'true',
-            'FloatingPointModel': 'Precise',
-            'ForceConformanceInForLoopScope': 'true',
-            'ForcedIncludeFiles': 'file1;file2',
-            'ForcedUsingFiles': 'file1;file2',
-            'FunctionLevelLinking': 'false',
-            'GenerateXMLDocumentationFiles': 'true',
-            'IgnoreStandardIncludePath': 'true',
-            'InlineFunctionExpansion': 'OnlyExplicitInline',
-            'IntrinsicFunctions': 'false',
-            'MinimalRebuild': 'true',
-            'MultiProcessorCompilation': 'true',
-            'ObjectFileName': 'a_file_name',
-            'OmitDefaultLibName': 'true',
-            'OmitFramePointers': 'true',
-            'OpenMPSupport': 'true',
-            'Optimization': 'Disabled',
-            'PrecompiledHeader': 'NotUsing',
-            'PrecompiledHeaderFile': 'a_file_name',
-            'PrecompiledHeaderOutputFile': 'a_file_name',
-            'PreprocessKeepComments': 'true',
-            'PreprocessorDefinitions': 'string1;string2',
-            'PreprocessOutputPath': 'a string1',
-            'PreprocessSuppressLineNumbers': 'false',
-            'PreprocessToFile': 'false',
-            'ProcessorNumber': '33',
-            'ProgramDataBaseFileName': 'a_file_name',
-            'RuntimeLibrary': 'MultiThreaded',
-            'RuntimeTypeInfo': 'true',
-            'ShowIncludes': 'true',
-            'SmallerTypeCheck': 'true',
-            'StringPooling': 'true',
-            'StructMemberAlignment': '1Byte',
-            'SuppressStartupBanner': 'true',
-            'TrackerLogDirectory': 'a_folder',
-            'TreatSpecificWarningsAsErrors': 'string1;string2',
-            'TreatWarningAsError': 'true',
-            'TreatWChar_tAsBuiltInType': 'true',
-            'UndefineAllPreprocessorDefinitions': 'true',
-            'UndefinePreprocessorDefinitions': 'string1;string2',
-            'UseFullPaths': 'true',
-            'UseUnicodeForAssemblerListing': 'true',
-            'WarningLevel': 'TurnOffAllWarnings',
-            'WholeProgramOptimization': 'true',
-            'XMLDocumentationFileName': 'a_file_name',
-            'ZZXYZ': 'bogus'},
-         'Link': {
-             'AdditionalDependencies': 'file1;file2',
-             'AdditionalLibraryDirectories': 'folder1;folder2',
-             'AdditionalManifestDependencies': 'file1;file2',
-             'AdditionalOptions': 'a string1',
-             'AddModuleNamesToAssembly': 'file1;file2',
-             'AllowIsolation': 'true',
-             'AssemblyDebug': '',
-             'AssemblyLinkResource': 'file1;file2',
-             'BaseAddress': 'a string1',
-             'BuildingInIDE': 'true',
-             'CLRImageType': 'ForceIJWImage',
-             'CLRSupportLastError': 'Enabled',
-             'CLRThreadAttribute': 'MTAThreadingAttribute',
-             'CLRUnmanagedCodeCheck': 'true',
-             'CreateHotPatchableImage': 'X86Image',
-             'DataExecutionPrevention': 'false',
-             'DelayLoadDLLs': 'file1;file2',
-             'DelaySign': 'true',
-             'Driver': 'NotSet',
-             'EmbedManagedResourceFile': 'file1;file2',
-             'EnableCOMDATFolding': 'false',
-             'EnableUAC': 'true',
-             'EntryPointSymbol': 'a string1',
-             'FixedBaseAddress': 'false',
-             'ForceFileOutput': 'Enabled',
-             'ForceSymbolReferences': 'file1;file2',
-             'FunctionOrder': 'a_file_name',
-             'GenerateDebugInformation': 'true',
-             'GenerateMapFile': 'true',
-             'HeapCommitSize': 'a string1',
-             'HeapReserveSize': 'a string1',
-             'IgnoreAllDefaultLibraries': 'true',
-             'IgnoreEmbeddedIDL': 'true',
-             'IgnoreSpecificDefaultLibraries': 'a_file_list',
-             'ImageHasSafeExceptionHandlers': 'true',
-             'ImportLibrary': 'a_file_name',
-             'KeyContainer': 'a_file_name',
-             'KeyFile': 'a_file_name',
-             'LargeAddressAware': 'false',
-             'LinkDLL': 'true',
-             'LinkErrorReporting': 'SendErrorReport',
-             'LinkStatus': 'true',
-             'LinkTimeCodeGeneration': 'UseLinkTimeCodeGeneration',
-             'ManifestFile': 'a_file_name',
-             'MapExports': 'true',
-             'MapFileName': 'a_file_name',
-             'MergedIDLBaseFileName': 'a_file_name',
-             'MergeSections': 'a string1',
-             'MidlCommandFile': 'a_file_name',
-             'MinimumRequiredVersion': 'a string1',
-             'ModuleDefinitionFile': 'a_file_name',
-             'MSDOSStubFileName': 'a_file_name',
-             'NoEntryPoint': 'true',
-             'OptimizeReferences': 'false',
-             'OutputFile': 'a_file_name',
-             'PerUserRedirection': 'true',
-             'PreventDllBinding': 'true',
-             'Profile': 'true',
-             'ProfileGuidedDatabase': 'a_file_name',
-             'ProgramDatabaseFile': 'a_file_name',
-             'RandomizedBaseAddress': 'false',
-             'RegisterOutput': 'true',
-             'SectionAlignment': '33',
-             'SetChecksum': 'true',
-             'ShowProgress': 'LinkVerboseREF',
-             'SpecifySectionAttributes': 'a string1',
-             'StackCommitSize': 'a string1',
-             'StackReserveSize': 'a string1',
-             'StripPrivateSymbols': 'a_file_name',
-             'SubSystem': 'Console',
-             'SupportNobindOfDelayLoadedDLL': 'true',
-             'SupportUnloadOfDelayLoadedDLL': 'true',
-             'SuppressStartupBanner': 'true',
-             'SwapRunFromCD': 'true',
-             'SwapRunFromNET': 'true',
-             'TargetMachine': 'MachineX86',
-             'TerminalServerAware': 'false',
-             'TrackerLogDirectory': 'a_folder',
-             'TreatLinkerWarningAsErrors': 'true',
-             'TurnOffAssemblyGeneration': 'true',
-             'TypeLibraryFile': 'a_file_name',
-             'TypeLibraryResourceID': '33',
-             'UACExecutionLevel': 'AsInvoker',
-             'UACUIAccess': 'true',
-             'Version': 'a string1'},
-         'ResourceCompile': {
-             'AdditionalIncludeDirectories': 'folder1;folder2',
-             'AdditionalOptions': 'a string1',
-             'Culture': '0x236',
-             'IgnoreStandardIncludePath': 'true',
-             'NullTerminateStrings': 'true',
-             'PreprocessorDefinitions': 'string1;string2',
-             'ResourceOutputFileName': 'a string1',
-             'ShowProgress': 'true',
-             'SuppressStartupBanner': 'true',
-             'TrackerLogDirectory': 'a_folder',
-             'UndefinePreprocessorDefinitions': 'string1;string2'},
-         'Midl': {
-             'AdditionalIncludeDirectories': 'folder1;folder2',
-             'AdditionalOptions': 'a string1',
-             'ApplicationConfigurationMode': 'true',
-             'ClientStubFile': 'a_file_name',
-             'CPreprocessOptions': 'a string1',
-             'DefaultCharType': 'Signed',
-             'DllDataFileName': 'a_file_name',
-             'EnableErrorChecks': 'EnableCustom',
-             'ErrorCheckAllocations': 'true',
-             'ErrorCheckBounds': 'true',
-             'ErrorCheckEnumRange': 'true',
-             'ErrorCheckRefPointers': 'true',
-             'ErrorCheckStubData': 'true',
-             'GenerateClientFiles': 'Stub',
-             'GenerateServerFiles': 'None',
-             'GenerateStublessProxies': 'true',
-             'GenerateTypeLibrary': 'true',
-             'HeaderFileName': 'a_file_name',
-             'IgnoreStandardIncludePath': 'true',
-             'InterfaceIdentifierFileName': 'a_file_name',
-             'LocaleID': '33',
-             'MkTypLibCompatible': 'true',
-             'OutputDirectory': 'a string1',
-             'PreprocessorDefinitions': 'string1;string2',
-             'ProxyFileName': 'a_file_name',
-             'RedirectOutputAndErrors': 'a_file_name',
-             'ServerStubFile': 'a_file_name',
-             'StructMemberAlignment': 'NotSet',
-             'SuppressCompilerWarnings': 'true',
-             'SuppressStartupBanner': 'true',
-             'TargetEnvironment': 'Itanium',
-             'TrackerLogDirectory': 'a_folder',
-             'TypeLibFormat': 'NewFormat',
-             'TypeLibraryName': 'a_file_name',
-             'UndefinePreprocessorDefinitions': 'string1;string2',
-             'ValidateAllParameters': 'true',
-             'WarnAsError': 'true',
-             'WarningLevel': '1'},
-         'Lib': {
-             'AdditionalDependencies': 'file1;file2',
-             'AdditionalLibraryDirectories': 'folder1;folder2',
-             'AdditionalOptions': 'a string1',
-             'DisplayLibrary': 'a string1',
-             'ErrorReporting': 'PromptImmediately',
-             'ExportNamedFunctions': 'string1;string2',
-             'ForceSymbolReferences': 'a string1',
-             'IgnoreAllDefaultLibraries': 'true',
-             'IgnoreSpecificDefaultLibraries': 'file1;file2',
-             'LinkTimeCodeGeneration': 'true',
-             'MinimumRequiredVersion': 'a string1',
-             'ModuleDefinitionFile': 'a_file_name',
-             'Name': 'a_file_name',
-             'OutputFile': 'a_file_name',
-             'RemoveObjects': 'file1;file2',
-             'SubSystem': 'Console',
-             'SuppressStartupBanner': 'true',
-             'TargetMachine': 'MachineX86i',
-             'TrackerLogDirectory': 'a_folder',
-             'TreatLibWarningAsErrors': 'true',
-             'UseUnicodeResponseFiles': 'true',
-             'Verbose': 'true'},
-         'Manifest': {
-             'AdditionalManifestFiles': 'file1;file2',
-             'AdditionalOptions': 'a string1',
-             'AssemblyIdentity': 'a string1',
-             'ComponentFileName': 'a_file_name',
-             'EnableDPIAwareness': 'fal',
-             'GenerateCatalogFiles': 'truel',
-             'GenerateCategoryTags': 'true',
-             'InputResourceManifests': 'a string1',
-             'ManifestFromManagedAssembly': 'a_file_name',
-             'notgood3': 'bogus',
-             'OutputManifestFile': 'a_file_name',
-             'OutputResourceManifests': 'a string1',
-             'RegistrarScriptFile': 'a_file_name',
-             'ReplacementsFile': 'a_file_name',
-             'SuppressDependencyElement': 'true',
-             'SuppressStartupBanner': 'true',
-             'TrackerLogDirectory': 'a_folder',
-             'TypeLibraryFile': 'a_file_name',
-             'UpdateFileHashes': 'true',
-             'UpdateFileHashesSearchPath': 'a_file_name',
-             'VerboseOutput': 'true'},
-         'ProjectReference': {
-             'LinkLibraryDependencies': 'true',
-             'UseLibraryDependencyInputs': 'true'},
-         'ManifestResourceCompile': {
-             'ResourceOutputFileName': 'a_file_name'},
-         '': {
-             'EmbedManifest': 'true',
-             'GenerateManifest': 'true',
-             'IgnoreImportLibrary': 'true',
-             'LinkIncremental': 'false'}},
-        self.stderr)
-    self._ExpectedWarnings([
-        'Warning: unrecognized setting ClCompile/Enableprefast',
-        'Warning: unrecognized setting ClCompile/ZZXYZ',
-        'Warning: unrecognized setting Manifest/notgood3',
-        'Warning: for Manifest/GenerateCatalogFiles, '
-        "expected bool; got 'truel'",
-        'Warning: for Lib/TargetMachine, unrecognized enumerated value '
-        'MachineX86i',
-        "Warning: for Manifest/EnableDPIAwareness, expected bool; got 'fal'"])
+    def testValidateMSBuildSettings_settings(self):
+        """Tests that for invalid MSBuild settings."""
+        MSVSSettings.ValidateMSBuildSettings(
+            {
+                "ClCompile": {
+                    "AdditionalIncludeDirectories": "folder1;folder2",
+                    "AdditionalOptions": ["string1", "string2"],
+                    "AdditionalUsingDirectories": "folder1;folder2",
+                    "AssemblerListingLocation": "a_file_name",
+                    "AssemblerOutput": "NoListing",
+                    "BasicRuntimeChecks": "StackFrameRuntimeCheck",
+                    "BrowseInformation": "false",
+                    "BrowseInformationFile": "a_file_name",
+                    "BufferSecurityCheck": "true",
+                    "BuildingInIDE": "true",
+                    "CallingConvention": "Cdecl",
+                    "CompileAs": "CompileAsC",
+                    "CompileAsManaged": "true",
+                    "CreateHotpatchableImage": "true",
+                    "DebugInformationFormat": "ProgramDatabase",
+                    "DisableLanguageExtensions": "true",
+                    "DisableSpecificWarnings": "string1;string2",
+                    "EnableEnhancedInstructionSet": "StreamingSIMDExtensions",
+                    "EnableFiberSafeOptimizations": "true",
+                    "EnablePREfast": "true",
+                    "Enableprefast": "bogus",
+                    "ErrorReporting": "Prompt",
+                    "ExceptionHandling": "SyncCThrow",
+                    "ExpandAttributedSource": "true",
+                    "FavorSizeOrSpeed": "Neither",
+                    "FloatingPointExceptions": "true",
+                    "FloatingPointModel": "Precise",
+                    "ForceConformanceInForLoopScope": "true",
+                    "ForcedIncludeFiles": "file1;file2",
+                    "ForcedUsingFiles": "file1;file2",
+                    "FunctionLevelLinking": "false",
+                    "GenerateXMLDocumentationFiles": "true",
+                    "IgnoreStandardIncludePath": "true",
+                    "InlineFunctionExpansion": "OnlyExplicitInline",
+                    "IntrinsicFunctions": "false",
+                    "MinimalRebuild": "true",
+                    "MultiProcessorCompilation": "true",
+                    "ObjectFileName": "a_file_name",
+                    "OmitDefaultLibName": "true",
+                    "OmitFramePointers": "true",
+                    "OpenMPSupport": "true",
+                    "Optimization": "Disabled",
+                    "PrecompiledHeader": "NotUsing",
+                    "PrecompiledHeaderFile": "a_file_name",
+                    "PrecompiledHeaderOutputFile": "a_file_name",
+                    "PreprocessKeepComments": "true",
+                    "PreprocessorDefinitions": "string1;string2",
+                    "PreprocessOutputPath": "a string1",
+                    "PreprocessSuppressLineNumbers": "false",
+                    "PreprocessToFile": "false",
+                    "ProcessorNumber": "33",
+                    "ProgramDataBaseFileName": "a_file_name",
+                    "RuntimeLibrary": "MultiThreaded",
+                    "RuntimeTypeInfo": "true",
+                    "ShowIncludes": "true",
+                    "SmallerTypeCheck": "true",
+                    "StringPooling": "true",
+                    "StructMemberAlignment": "1Byte",
+                    "SuppressStartupBanner": "true",
+                    "TrackerLogDirectory": "a_folder",
+                    "TreatSpecificWarningsAsErrors": "string1;string2",
+                    "TreatWarningAsError": "true",
+                    "TreatWChar_tAsBuiltInType": "true",
+                    "UndefineAllPreprocessorDefinitions": "true",
+                    "UndefinePreprocessorDefinitions": "string1;string2",
+                    "UseFullPaths": "true",
+                    "UseUnicodeForAssemblerListing": "true",
+                    "WarningLevel": "TurnOffAllWarnings",
+                    "WholeProgramOptimization": "true",
+                    "XMLDocumentationFileName": "a_file_name",
+                    "ZZXYZ": "bogus",
+                },
+                "Link": {
+                    "AdditionalDependencies": "file1;file2",
+                    "AdditionalLibraryDirectories": "folder1;folder2",
+                    "AdditionalManifestDependencies": "file1;file2",
+                    "AdditionalOptions": "a string1",
+                    "AddModuleNamesToAssembly": "file1;file2",
+                    "AllowIsolation": "true",
+                    "AssemblyDebug": "",
+                    "AssemblyLinkResource": "file1;file2",
+                    "BaseAddress": "a string1",
+                    "BuildingInIDE": "true",
+                    "CLRImageType": "ForceIJWImage",
+                    "CLRSupportLastError": "Enabled",
+                    "CLRThreadAttribute": "MTAThreadingAttribute",
+                    "CLRUnmanagedCodeCheck": "true",
+                    "CreateHotPatchableImage": "X86Image",
+                    "DataExecutionPrevention": "false",
+                    "DelayLoadDLLs": "file1;file2",
+                    "DelaySign": "true",
+                    "Driver": "NotSet",
+                    "EmbedManagedResourceFile": "file1;file2",
+                    "EnableCOMDATFolding": "false",
+                    "EnableUAC": "true",
+                    "EntryPointSymbol": "a string1",
+                    "FixedBaseAddress": "false",
+                    "ForceFileOutput": "Enabled",
+                    "ForceSymbolReferences": "file1;file2",
+                    "FunctionOrder": "a_file_name",
+                    "GenerateDebugInformation": "true",
+                    "GenerateMapFile": "true",
+                    "HeapCommitSize": "a string1",
+                    "HeapReserveSize": "a string1",
+                    "IgnoreAllDefaultLibraries": "true",
+                    "IgnoreEmbeddedIDL": "true",
+                    "IgnoreSpecificDefaultLibraries": "a_file_list",
+                    "ImageHasSafeExceptionHandlers": "true",
+                    "ImportLibrary": "a_file_name",
+                    "KeyContainer": "a_file_name",
+                    "KeyFile": "a_file_name",
+                    "LargeAddressAware": "false",
+                    "LinkDLL": "true",
+                    "LinkErrorReporting": "SendErrorReport",
+                    "LinkStatus": "true",
+                    "LinkTimeCodeGeneration": "UseLinkTimeCodeGeneration",
+                    "ManifestFile": "a_file_name",
+                    "MapExports": "true",
+                    "MapFileName": "a_file_name",
+                    "MergedIDLBaseFileName": "a_file_name",
+                    "MergeSections": "a string1",
+                    "MidlCommandFile": "a_file_name",
+                    "MinimumRequiredVersion": "a string1",
+                    "ModuleDefinitionFile": "a_file_name",
+                    "MSDOSStubFileName": "a_file_name",
+                    "NoEntryPoint": "true",
+                    "OptimizeReferences": "false",
+                    "OutputFile": "a_file_name",
+                    "PerUserRedirection": "true",
+                    "PreventDllBinding": "true",
+                    "Profile": "true",
+                    "ProfileGuidedDatabase": "a_file_name",
+                    "ProgramDatabaseFile": "a_file_name",
+                    "RandomizedBaseAddress": "false",
+                    "RegisterOutput": "true",
+                    "SectionAlignment": "33",
+                    "SetChecksum": "true",
+                    "ShowProgress": "LinkVerboseREF",
+                    "SpecifySectionAttributes": "a string1",
+                    "StackCommitSize": "a string1",
+                    "StackReserveSize": "a string1",
+                    "StripPrivateSymbols": "a_file_name",
+                    "SubSystem": "Console",
+                    "SupportNobindOfDelayLoadedDLL": "true",
+                    "SupportUnloadOfDelayLoadedDLL": "true",
+                    "SuppressStartupBanner": "true",
+                    "SwapRunFromCD": "true",
+                    "SwapRunFromNET": "true",
+                    "TargetMachine": "MachineX86",
+                    "TerminalServerAware": "false",
+                    "TrackerLogDirectory": "a_folder",
+                    "TreatLinkerWarningAsErrors": "true",
+                    "TurnOffAssemblyGeneration": "true",
+                    "TypeLibraryFile": "a_file_name",
+                    "TypeLibraryResourceID": "33",
+                    "UACExecutionLevel": "AsInvoker",
+                    "UACUIAccess": "true",
+                    "Version": "a string1",
+                },
+                "ResourceCompile": {
+                    "AdditionalIncludeDirectories": "folder1;folder2",
+                    "AdditionalOptions": "a string1",
+                    "Culture": "0x236",
+                    "IgnoreStandardIncludePath": "true",
+                    "NullTerminateStrings": "true",
+                    "PreprocessorDefinitions": "string1;string2",
+                    "ResourceOutputFileName": "a string1",
+                    "ShowProgress": "true",
+                    "SuppressStartupBanner": "true",
+                    "TrackerLogDirectory": "a_folder",
+                    "UndefinePreprocessorDefinitions": "string1;string2",
+                },
+                "Midl": {
+                    "AdditionalIncludeDirectories": "folder1;folder2",
+                    "AdditionalOptions": "a string1",
+                    "ApplicationConfigurationMode": "true",
+                    "ClientStubFile": "a_file_name",
+                    "CPreprocessOptions": "a string1",
+                    "DefaultCharType": "Signed",
+                    "DllDataFileName": "a_file_name",
+                    "EnableErrorChecks": "EnableCustom",
+                    "ErrorCheckAllocations": "true",
+                    "ErrorCheckBounds": "true",
+                    "ErrorCheckEnumRange": "true",
+                    "ErrorCheckRefPointers": "true",
+                    "ErrorCheckStubData": "true",
+                    "GenerateClientFiles": "Stub",
+                    "GenerateServerFiles": "None",
+                    "GenerateStublessProxies": "true",
+                    "GenerateTypeLibrary": "true",
+                    "HeaderFileName": "a_file_name",
+                    "IgnoreStandardIncludePath": "true",
+                    "InterfaceIdentifierFileName": "a_file_name",
+                    "LocaleID": "33",
+                    "MkTypLibCompatible": "true",
+                    "OutputDirectory": "a string1",
+                    "PreprocessorDefinitions": "string1;string2",
+                    "ProxyFileName": "a_file_name",
+                    "RedirectOutputAndErrors": "a_file_name",
+                    "ServerStubFile": "a_file_name",
+                    "StructMemberAlignment": "NotSet",
+                    "SuppressCompilerWarnings": "true",
+                    "SuppressStartupBanner": "true",
+                    "TargetEnvironment": "Itanium",
+                    "TrackerLogDirectory": "a_folder",
+                    "TypeLibFormat": "NewFormat",
+                    "TypeLibraryName": "a_file_name",
+                    "UndefinePreprocessorDefinitions": "string1;string2",
+                    "ValidateAllParameters": "true",
+                    "WarnAsError": "true",
+                    "WarningLevel": "1",
+                },
+                "Lib": {
+                    "AdditionalDependencies": "file1;file2",
+                    "AdditionalLibraryDirectories": "folder1;folder2",
+                    "AdditionalOptions": "a string1",
+                    "DisplayLibrary": "a string1",
+                    "ErrorReporting": "PromptImmediately",
+                    "ExportNamedFunctions": "string1;string2",
+                    "ForceSymbolReferences": "a string1",
+                    "IgnoreAllDefaultLibraries": "true",
+                    "IgnoreSpecificDefaultLibraries": "file1;file2",
+                    "LinkTimeCodeGeneration": "true",
+                    "MinimumRequiredVersion": "a string1",
+                    "ModuleDefinitionFile": "a_file_name",
+                    "Name": "a_file_name",
+                    "OutputFile": "a_file_name",
+                    "RemoveObjects": "file1;file2",
+                    "SubSystem": "Console",
+                    "SuppressStartupBanner": "true",
+                    "TargetMachine": "MachineX86i",
+                    "TrackerLogDirectory": "a_folder",
+                    "TreatLibWarningAsErrors": "true",
+                    "UseUnicodeResponseFiles": "true",
+                    "Verbose": "true",
+                },
+                "Manifest": {
+                    "AdditionalManifestFiles": "file1;file2",
+                    "AdditionalOptions": "a string1",
+                    "AssemblyIdentity": "a string1",
+                    "ComponentFileName": "a_file_name",
+                    "EnableDPIAwareness": "fal",
+                    "GenerateCatalogFiles": "truel",
+                    "GenerateCategoryTags": "true",
+                    "InputResourceManifests": "a string1",
+                    "ManifestFromManagedAssembly": "a_file_name",
+                    "notgood3": "bogus",
+                    "OutputManifestFile": "a_file_name",
+                    "OutputResourceManifests": "a string1",
+                    "RegistrarScriptFile": "a_file_name",
+                    "ReplacementsFile": "a_file_name",
+                    "SuppressDependencyElement": "true",
+                    "SuppressStartupBanner": "true",
+                    "TrackerLogDirectory": "a_folder",
+                    "TypeLibraryFile": "a_file_name",
+                    "UpdateFileHashes": "true",
+                    "UpdateFileHashesSearchPath": "a_file_name",
+                    "VerboseOutput": "true",
+                },
+                "ProjectReference": {
+                    "LinkLibraryDependencies": "true",
+                    "UseLibraryDependencyInputs": "true",
+                },
+                "ManifestResourceCompile": {"ResourceOutputFileName": "a_file_name"},
+                "": {
+                    "EmbedManifest": "true",
+                    "GenerateManifest": "true",
+                    "IgnoreImportLibrary": "true",
+                    "LinkIncremental": "false",
+                },
+            },
+            self.stderr,
+        )
+        self._ExpectedWarnings(
+            [
+                "Warning: unrecognized setting ClCompile/Enableprefast",
+                "Warning: unrecognized setting ClCompile/ZZXYZ",
+                "Warning: unrecognized setting Manifest/notgood3",
+                "Warning: for Manifest/GenerateCatalogFiles, "
+                "expected bool; got 'truel'",
+                "Warning: for Lib/TargetMachine, unrecognized enumerated value "
+                "MachineX86i",
+                "Warning: for Manifest/EnableDPIAwareness, expected bool; got 'fal'",
+            ]
+        )
 
-  def testConvertToMSBuildSettings_empty(self):
-    """Tests an empty conversion."""
-    msvs_settings = {}
-    expected_msbuild_settings = {}
-    actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
-        msvs_settings,
-        self.stderr)
-    self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
-    self._ExpectedWarnings([])
+    def testConvertToMSBuildSettings_empty(self):
+        """Tests an empty conversion."""
+        msvs_settings = {}
+        expected_msbuild_settings = {}
+        actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
+            msvs_settings, self.stderr
+        )
+        self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
+        self._ExpectedWarnings([])
 
-  def testConvertToMSBuildSettings_minimal(self):
-    """Tests a minimal conversion."""
-    msvs_settings = {
-        'VCCLCompilerTool': {
-            'AdditionalIncludeDirectories': 'dir1',
-            'AdditionalOptions': '/foo',
-            'BasicRuntimeChecks': '0',
+    def testConvertToMSBuildSettings_minimal(self):
+        """Tests a minimal conversion."""
+        msvs_settings = {
+            "VCCLCompilerTool": {
+                "AdditionalIncludeDirectories": "dir1",
+                "AdditionalOptions": "/foo",
+                "BasicRuntimeChecks": "0",
             },
-        'VCLinkerTool': {
-            'LinkTimeCodeGeneration': '1',
-            'ErrorReporting': '1',
-            'DataExecutionPrevention': '2',
+            "VCLinkerTool": {
+                "LinkTimeCodeGeneration": "1",
+                "ErrorReporting": "1",
+                "DataExecutionPrevention": "2",
             },
         }
-    expected_msbuild_settings = {
-        'ClCompile': {
-            'AdditionalIncludeDirectories': 'dir1',
-            'AdditionalOptions': '/foo',
-            'BasicRuntimeChecks': 'Default',
+        expected_msbuild_settings = {
+            "ClCompile": {
+                "AdditionalIncludeDirectories": "dir1",
+                "AdditionalOptions": "/foo",
+                "BasicRuntimeChecks": "Default",
             },
-        'Link': {
-            'LinkTimeCodeGeneration': 'UseLinkTimeCodeGeneration',
-            'LinkErrorReporting': 'PromptImmediately',
-            'DataExecutionPrevention': 'true',
+            "Link": {
+                "LinkTimeCodeGeneration": "UseLinkTimeCodeGeneration",
+                "LinkErrorReporting": "PromptImmediately",
+                "DataExecutionPrevention": "true",
             },
         }
-    actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
-        msvs_settings,
-        self.stderr)
-    self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
-    self._ExpectedWarnings([])
-
-  def testConvertToMSBuildSettings_warnings(self):
-    """Tests conversion that generates warnings."""
-    msvs_settings = {
-        'VCCLCompilerTool': {
-            'AdditionalIncludeDirectories': '1',
-            'AdditionalOptions': '2',
-            # These are incorrect values:
-            'BasicRuntimeChecks': '12',
-            'BrowseInformation': '21',
-            'UsePrecompiledHeader': '13',
-            'GeneratePreprocessedFile': '14'},
-        'VCLinkerTool': {
-            # These are incorrect values:
-            'Driver': '10',
-            'LinkTimeCodeGeneration': '31',
-            'ErrorReporting': '21',
-            'FixedBaseAddress': '6'},
-        'VCResourceCompilerTool': {
-            # Custom
-            'Culture': '1003'}}
-    expected_msbuild_settings = {
-        'ClCompile': {
-            'AdditionalIncludeDirectories': '1',
-            'AdditionalOptions': '2'},
-        'Link': {},
-        'ResourceCompile': {
-            # Custom
-            'Culture': '0x03eb'}}
-    actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
-        msvs_settings,
-        self.stderr)
-    self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
-    self._ExpectedWarnings([
-        'Warning: while converting VCCLCompilerTool/BasicRuntimeChecks to '
-        'MSBuild, index value (12) not in expected range [0, 4)',
-        'Warning: while converting VCCLCompilerTool/BrowseInformation to '
-        'MSBuild, index value (21) not in expected range [0, 3)',
-        'Warning: while converting VCCLCompilerTool/UsePrecompiledHeader to '
-        'MSBuild, index value (13) not in expected range [0, 3)',
-        'Warning: while converting VCCLCompilerTool/GeneratePreprocessedFile to '
-        'MSBuild, value must be one of [0, 1, 2]; got 14',
+        actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
+            msvs_settings, self.stderr
+        )
+        self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
+        self._ExpectedWarnings([])
 
-        'Warning: while converting VCLinkerTool/Driver to '
-        'MSBuild, index value (10) not in expected range [0, 4)',
-        'Warning: while converting VCLinkerTool/LinkTimeCodeGeneration to '
-        'MSBuild, index value (31) not in expected range [0, 5)',
-        'Warning: while converting VCLinkerTool/ErrorReporting to '
-        'MSBuild, index value (21) not in expected range [0, 3)',
-        'Warning: while converting VCLinkerTool/FixedBaseAddress to '
-        'MSBuild, index value (6) not in expected range [0, 3)',
-        ])
+    def testConvertToMSBuildSettings_warnings(self):
+        """Tests conversion that generates warnings."""
+        msvs_settings = {
+            "VCCLCompilerTool": {
+                "AdditionalIncludeDirectories": "1",
+                "AdditionalOptions": "2",
+                # These are incorrect values:
+                "BasicRuntimeChecks": "12",
+                "BrowseInformation": "21",
+                "UsePrecompiledHeader": "13",
+                "GeneratePreprocessedFile": "14",
+            },
+            "VCLinkerTool": {
+                # These are incorrect values:
+                "Driver": "10",
+                "LinkTimeCodeGeneration": "31",
+                "ErrorReporting": "21",
+                "FixedBaseAddress": "6",
+            },
+            "VCResourceCompilerTool": {
+                # Custom
+                "Culture": "1003"
+            },
+        }
+        expected_msbuild_settings = {
+            "ClCompile": {
+                "AdditionalIncludeDirectories": "1",
+                "AdditionalOptions": "2",
+            },
+            "Link": {},
+            "ResourceCompile": {
+                # Custom
+                "Culture": "0x03eb"
+            },
+        }
+        actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
+            msvs_settings, self.stderr
+        )
+        self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
+        self._ExpectedWarnings(
+            [
+                "Warning: while converting VCCLCompilerTool/BasicRuntimeChecks to "
+                "MSBuild, index value (12) not in expected range [0, 4)",
+                "Warning: while converting VCCLCompilerTool/BrowseInformation to "
+                "MSBuild, index value (21) not in expected range [0, 3)",
+                "Warning: while converting VCCLCompilerTool/UsePrecompiledHeader to "
+                "MSBuild, index value (13) not in expected range [0, 3)",
+                "Warning: while converting "
+                "VCCLCompilerTool/GeneratePreprocessedFile to "
+                "MSBuild, value must be one of [0, 1, 2]; got 14",
+                "Warning: while converting VCLinkerTool/Driver to "
+                "MSBuild, index value (10) not in expected range [0, 4)",
+                "Warning: while converting VCLinkerTool/LinkTimeCodeGeneration to "
+                "MSBuild, index value (31) not in expected range [0, 5)",
+                "Warning: while converting VCLinkerTool/ErrorReporting to "
+                "MSBuild, index value (21) not in expected range [0, 3)",
+                "Warning: while converting VCLinkerTool/FixedBaseAddress to "
+                "MSBuild, index value (6) not in expected range [0, 3)",
+            ]
+        )
 
-  def testConvertToMSBuildSettings_full_synthetic(self):
-    """Tests conversion of all the MSBuild settings."""
-    msvs_settings = {
-        'VCCLCompilerTool': {
-            'AdditionalIncludeDirectories': 'folder1;folder2;folder3',
-            'AdditionalOptions': 'a_string',
-            'AdditionalUsingDirectories': 'folder1;folder2;folder3',
-            'AssemblerListingLocation': 'a_file_name',
-            'AssemblerOutput': '0',
-            'BasicRuntimeChecks': '1',
-            'BrowseInformation': '2',
-            'BrowseInformationFile': 'a_file_name',
-            'BufferSecurityCheck': 'true',
-            'CallingConvention': '0',
-            'CompileAs': '1',
-            'DebugInformationFormat': '4',
-            'DefaultCharIsUnsigned': 'true',
-            'Detect64BitPortabilityProblems': 'true',
-            'DisableLanguageExtensions': 'true',
-            'DisableSpecificWarnings': 'd1;d2;d3',
-            'EnableEnhancedInstructionSet': '0',
-            'EnableFiberSafeOptimizations': 'true',
-            'EnableFunctionLevelLinking': 'true',
-            'EnableIntrinsicFunctions': 'true',
-            'EnablePREfast': 'true',
-            'ErrorReporting': '1',
-            'ExceptionHandling': '2',
-            'ExpandAttributedSource': 'true',
-            'FavorSizeOrSpeed': '0',
-            'FloatingPointExceptions': 'true',
-            'FloatingPointModel': '1',
-            'ForceConformanceInForLoopScope': 'true',
-            'ForcedIncludeFiles': 'file1;file2;file3',
-            'ForcedUsingFiles': 'file1;file2;file3',
-            'GeneratePreprocessedFile': '1',
-            'GenerateXMLDocumentationFiles': 'true',
-            'IgnoreStandardIncludePath': 'true',
-            'InlineFunctionExpansion': '2',
-            'KeepComments': 'true',
-            'MinimalRebuild': 'true',
-            'ObjectFile': 'a_file_name',
-            'OmitDefaultLibName': 'true',
-            'OmitFramePointers': 'true',
-            'OpenMP': 'true',
-            'Optimization': '3',
-            'PrecompiledHeaderFile': 'a_file_name',
-            'PrecompiledHeaderThrough': 'a_file_name',
-            'PreprocessorDefinitions': 'd1;d2;d3',
-            'ProgramDataBaseFileName': 'a_file_name',
-            'RuntimeLibrary': '0',
-            'RuntimeTypeInfo': 'true',
-            'ShowIncludes': 'true',
-            'SmallerTypeCheck': 'true',
-            'StringPooling': 'true',
-            'StructMemberAlignment': '1',
-            'SuppressStartupBanner': 'true',
-            'TreatWChar_tAsBuiltInType': 'true',
-            'UndefineAllPreprocessorDefinitions': 'true',
-            'UndefinePreprocessorDefinitions': 'd1;d2;d3',
-            'UseFullPaths': 'true',
-            'UsePrecompiledHeader': '1',
-            'UseUnicodeResponseFiles': 'true',
-            'WarnAsError': 'true',
-            'WarningLevel': '2',
-            'WholeProgramOptimization': 'true',
-            'XMLDocumentationFileName': 'a_file_name'},
-        'VCLinkerTool': {
-            'AdditionalDependencies': 'file1;file2;file3',
-            'AdditionalLibraryDirectories': 'folder1;folder2;folder3',
-            'AdditionalLibraryDirectories_excluded': 'folder1;folder2;folder3',
-            'AdditionalManifestDependencies': 'file1;file2;file3',
-            'AdditionalOptions': 'a_string',
-            'AddModuleNamesToAssembly': 'file1;file2;file3',
-            'AllowIsolation': 'true',
-            'AssemblyDebug': '0',
-            'AssemblyLinkResource': 'file1;file2;file3',
-            'BaseAddress': 'a_string',
-            'CLRImageType': '1',
-            'CLRThreadAttribute': '2',
-            'CLRUnmanagedCodeCheck': 'true',
-            'DataExecutionPrevention': '0',
-            'DelayLoadDLLs': 'file1;file2;file3',
-            'DelaySign': 'true',
-            'Driver': '1',
-            'EmbedManagedResourceFile': 'file1;file2;file3',
-            'EnableCOMDATFolding': '0',
-            'EnableUAC': 'true',
-            'EntryPointSymbol': 'a_string',
-            'ErrorReporting': '0',
-            'FixedBaseAddress': '1',
-            'ForceSymbolReferences': 'file1;file2;file3',
-            'FunctionOrder': 'a_file_name',
-            'GenerateDebugInformation': 'true',
-            'GenerateManifest': 'true',
-            'GenerateMapFile': 'true',
-            'HeapCommitSize': 'a_string',
-            'HeapReserveSize': 'a_string',
-            'IgnoreAllDefaultLibraries': 'true',
-            'IgnoreDefaultLibraryNames': 'file1;file2;file3',
-            'IgnoreEmbeddedIDL': 'true',
-            'IgnoreImportLibrary': 'true',
-            'ImportLibrary': 'a_file_name',
-            'KeyContainer': 'a_file_name',
-            'KeyFile': 'a_file_name',
-            'LargeAddressAware': '2',
-            'LinkIncremental': '1',
-            'LinkLibraryDependencies': 'true',
-            'LinkTimeCodeGeneration': '2',
-            'ManifestFile': 'a_file_name',
-            'MapExports': 'true',
-            'MapFileName': 'a_file_name',
-            'MergedIDLBaseFileName': 'a_file_name',
-            'MergeSections': 'a_string',
-            'MidlCommandFile': 'a_file_name',
-            'ModuleDefinitionFile': 'a_file_name',
-            'OptimizeForWindows98': '1',
-            'OptimizeReferences': '0',
-            'OutputFile': 'a_file_name',
-            'PerUserRedirection': 'true',
-            'Profile': 'true',
-            'ProfileGuidedDatabase': 'a_file_name',
-            'ProgramDatabaseFile': 'a_file_name',
-            'RandomizedBaseAddress': '1',
-            'RegisterOutput': 'true',
-            'ResourceOnlyDLL': 'true',
-            'SetChecksum': 'true',
-            'ShowProgress': '0',
-            'StackCommitSize': 'a_string',
-            'StackReserveSize': 'a_string',
-            'StripPrivateSymbols': 'a_file_name',
-            'SubSystem': '2',
-            'SupportUnloadOfDelayLoadedDLL': 'true',
-            'SuppressStartupBanner': 'true',
-            'SwapRunFromCD': 'true',
-            'SwapRunFromNet': 'true',
-            'TargetMachine': '3',
-            'TerminalServerAware': '2',
-            'TurnOffAssemblyGeneration': 'true',
-            'TypeLibraryFile': 'a_file_name',
-            'TypeLibraryResourceID': '33',
-            'UACExecutionLevel': '1',
-            'UACUIAccess': 'true',
-            'UseLibraryDependencyInputs': 'false',
-            'UseUnicodeResponseFiles': 'true',
-            'Version': 'a_string'},
-        'VCResourceCompilerTool': {
-            'AdditionalIncludeDirectories': 'folder1;folder2;folder3',
-            'AdditionalOptions': 'a_string',
-            'Culture': '1003',
-            'IgnoreStandardIncludePath': 'true',
-            'PreprocessorDefinitions': 'd1;d2;d3',
-            'ResourceOutputFileName': 'a_string',
-            'ShowProgress': 'true',
-            'SuppressStartupBanner': 'true',
-            'UndefinePreprocessorDefinitions': 'd1;d2;d3'},
-        'VCMIDLTool': {
-            'AdditionalIncludeDirectories': 'folder1;folder2;folder3',
-            'AdditionalOptions': 'a_string',
-            'CPreprocessOptions': 'a_string',
-            'DefaultCharType': '0',
-            'DLLDataFileName': 'a_file_name',
-            'EnableErrorChecks': '2',
-            'ErrorCheckAllocations': 'true',
-            'ErrorCheckBounds': 'true',
-            'ErrorCheckEnumRange': 'true',
-            'ErrorCheckRefPointers': 'true',
-            'ErrorCheckStubData': 'true',
-            'GenerateStublessProxies': 'true',
-            'GenerateTypeLibrary': 'true',
-            'HeaderFileName': 'a_file_name',
-            'IgnoreStandardIncludePath': 'true',
-            'InterfaceIdentifierFileName': 'a_file_name',
-            'MkTypLibCompatible': 'true',
-            'OutputDirectory': 'a_string',
-            'PreprocessorDefinitions': 'd1;d2;d3',
-            'ProxyFileName': 'a_file_name',
-            'RedirectOutputAndErrors': 'a_file_name',
-            'StructMemberAlignment': '3',
-            'SuppressStartupBanner': 'true',
-            'TargetEnvironment': '1',
-            'TypeLibraryName': 'a_file_name',
-            'UndefinePreprocessorDefinitions': 'd1;d2;d3',
-            'ValidateParameters': 'true',
-            'WarnAsError': 'true',
-            'WarningLevel': '4'},
-        'VCLibrarianTool': {
-            'AdditionalDependencies': 'file1;file2;file3',
-            'AdditionalLibraryDirectories': 'folder1;folder2;folder3',
-            'AdditionalLibraryDirectories_excluded': 'folder1;folder2;folder3',
-            'AdditionalOptions': 'a_string',
-            'ExportNamedFunctions': 'd1;d2;d3',
-            'ForceSymbolReferences': 'a_string',
-            'IgnoreAllDefaultLibraries': 'true',
-            'IgnoreSpecificDefaultLibraries': 'file1;file2;file3',
-            'LinkLibraryDependencies': 'true',
-            'ModuleDefinitionFile': 'a_file_name',
-            'OutputFile': 'a_file_name',
-            'SuppressStartupBanner': 'true',
-            'UseUnicodeResponseFiles': 'true'},
-        'VCManifestTool': {
-            'AdditionalManifestFiles': 'file1;file2;file3',
-            'AdditionalOptions': 'a_string',
-            'AssemblyIdentity': 'a_string',
-            'ComponentFileName': 'a_file_name',
-            'DependencyInformationFile': 'a_file_name',
-            'EmbedManifest': 'true',
-            'GenerateCatalogFiles': 'true',
-            'InputResourceManifests': 'a_string',
-            'ManifestResourceFile': 'my_name',
-            'OutputManifestFile': 'a_file_name',
-            'RegistrarScriptFile': 'a_file_name',
-            'ReplacementsFile': 'a_file_name',
-            'SuppressStartupBanner': 'true',
-            'TypeLibraryFile': 'a_file_name',
-            'UpdateFileHashes': 'true',
-            'UpdateFileHashesSearchPath': 'a_file_name',
-            'UseFAT32Workaround': 'true',
-            'UseUnicodeResponseFiles': 'true',
-            'VerboseOutput': 'true'}}
-    expected_msbuild_settings = {
-        'ClCompile': {
-            'AdditionalIncludeDirectories': 'folder1;folder2;folder3',
-            'AdditionalOptions': 'a_string /J',
-            'AdditionalUsingDirectories': 'folder1;folder2;folder3',
-            'AssemblerListingLocation': 'a_file_name',
-            'AssemblerOutput': 'NoListing',
-            'BasicRuntimeChecks': 'StackFrameRuntimeCheck',
-            'BrowseInformation': 'true',
-            'BrowseInformationFile': 'a_file_name',
-            'BufferSecurityCheck': 'true',
-            'CallingConvention': 'Cdecl',
-            'CompileAs': 'CompileAsC',
-            'DebugInformationFormat': 'EditAndContinue',
-            'DisableLanguageExtensions': 'true',
-            'DisableSpecificWarnings': 'd1;d2;d3',
-            'EnableEnhancedInstructionSet': 'NotSet',
-            'EnableFiberSafeOptimizations': 'true',
-            'EnablePREfast': 'true',
-            'ErrorReporting': 'Prompt',
-            'ExceptionHandling': 'Async',
-            'ExpandAttributedSource': 'true',
-            'FavorSizeOrSpeed': 'Neither',
-            'FloatingPointExceptions': 'true',
-            'FloatingPointModel': 'Strict',
-            'ForceConformanceInForLoopScope': 'true',
-            'ForcedIncludeFiles': 'file1;file2;file3',
-            'ForcedUsingFiles': 'file1;file2;file3',
-            'FunctionLevelLinking': 'true',
-            'GenerateXMLDocumentationFiles': 'true',
-            'IgnoreStandardIncludePath': 'true',
-            'InlineFunctionExpansion': 'AnySuitable',
-            'IntrinsicFunctions': 'true',
-            'MinimalRebuild': 'true',
-            'ObjectFileName': 'a_file_name',
-            'OmitDefaultLibName': 'true',
-            'OmitFramePointers': 'true',
-            'OpenMPSupport': 'true',
-            'Optimization': 'Full',
-            'PrecompiledHeader': 'Create',
-            'PrecompiledHeaderFile': 'a_file_name',
-            'PrecompiledHeaderOutputFile': 'a_file_name',
-            'PreprocessKeepComments': 'true',
-            'PreprocessorDefinitions': 'd1;d2;d3',
-            'PreprocessSuppressLineNumbers': 'false',
-            'PreprocessToFile': 'true',
-            'ProgramDataBaseFileName': 'a_file_name',
-            'RuntimeLibrary': 'MultiThreaded',
-            'RuntimeTypeInfo': 'true',
-            'ShowIncludes': 'true',
-            'SmallerTypeCheck': 'true',
-            'StringPooling': 'true',
-            'StructMemberAlignment': '1Byte',
-            'SuppressStartupBanner': 'true',
-            'TreatWarningAsError': 'true',
-            'TreatWChar_tAsBuiltInType': 'true',
-            'UndefineAllPreprocessorDefinitions': 'true',
-            'UndefinePreprocessorDefinitions': 'd1;d2;d3',
-            'UseFullPaths': 'true',
-            'WarningLevel': 'Level2',
-            'WholeProgramOptimization': 'true',
-            'XMLDocumentationFileName': 'a_file_name'},
-        'Link': {
-            'AdditionalDependencies': 'file1;file2;file3',
-            'AdditionalLibraryDirectories': 'folder1;folder2;folder3',
-            'AdditionalManifestDependencies': 'file1;file2;file3',
-            'AdditionalOptions': 'a_string',
-            'AddModuleNamesToAssembly': 'file1;file2;file3',
-            'AllowIsolation': 'true',
-            'AssemblyDebug': '',
-            'AssemblyLinkResource': 'file1;file2;file3',
-            'BaseAddress': 'a_string',
-            'CLRImageType': 'ForceIJWImage',
-            'CLRThreadAttribute': 'STAThreadingAttribute',
-            'CLRUnmanagedCodeCheck': 'true',
-            'DataExecutionPrevention': '',
-            'DelayLoadDLLs': 'file1;file2;file3',
-            'DelaySign': 'true',
-            'Driver': 'Driver',
-            'EmbedManagedResourceFile': 'file1;file2;file3',
-            'EnableCOMDATFolding': '',
-            'EnableUAC': 'true',
-            'EntryPointSymbol': 'a_string',
-            'FixedBaseAddress': 'false',
-            'ForceSymbolReferences': 'file1;file2;file3',
-            'FunctionOrder': 'a_file_name',
-            'GenerateDebugInformation': 'true',
-            'GenerateMapFile': 'true',
-            'HeapCommitSize': 'a_string',
-            'HeapReserveSize': 'a_string',
-            'IgnoreAllDefaultLibraries': 'true',
-            'IgnoreEmbeddedIDL': 'true',
-            'IgnoreSpecificDefaultLibraries': 'file1;file2;file3',
-            'ImportLibrary': 'a_file_name',
-            'KeyContainer': 'a_file_name',
-            'KeyFile': 'a_file_name',
-            'LargeAddressAware': 'true',
-            'LinkErrorReporting': 'NoErrorReport',
-            'LinkTimeCodeGeneration': 'PGInstrument',
-            'ManifestFile': 'a_file_name',
-            'MapExports': 'true',
-            'MapFileName': 'a_file_name',
-            'MergedIDLBaseFileName': 'a_file_name',
-            'MergeSections': 'a_string',
-            'MidlCommandFile': 'a_file_name',
-            'ModuleDefinitionFile': 'a_file_name',
-            'NoEntryPoint': 'true',
-            'OptimizeReferences': '',
-            'OutputFile': 'a_file_name',
-            'PerUserRedirection': 'true',
-            'Profile': 'true',
-            'ProfileGuidedDatabase': 'a_file_name',
-            'ProgramDatabaseFile': 'a_file_name',
-            'RandomizedBaseAddress': 'false',
-            'RegisterOutput': 'true',
-            'SetChecksum': 'true',
-            'ShowProgress': 'NotSet',
-            'StackCommitSize': 'a_string',
-            'StackReserveSize': 'a_string',
-            'StripPrivateSymbols': 'a_file_name',
-            'SubSystem': 'Windows',
-            'SupportUnloadOfDelayLoadedDLL': 'true',
-            'SuppressStartupBanner': 'true',
-            'SwapRunFromCD': 'true',
-            'SwapRunFromNET': 'true',
-            'TargetMachine': 'MachineARM',
-            'TerminalServerAware': 'true',
-            'TurnOffAssemblyGeneration': 'true',
-            'TypeLibraryFile': 'a_file_name',
-            'TypeLibraryResourceID': '33',
-            'UACExecutionLevel': 'HighestAvailable',
-            'UACUIAccess': 'true',
-            'Version': 'a_string'},
-        'ResourceCompile': {
-            'AdditionalIncludeDirectories': 'folder1;folder2;folder3',
-            'AdditionalOptions': 'a_string',
-            'Culture': '0x03eb',
-            'IgnoreStandardIncludePath': 'true',
-            'PreprocessorDefinitions': 'd1;d2;d3',
-            'ResourceOutputFileName': 'a_string',
-            'ShowProgress': 'true',
-            'SuppressStartupBanner': 'true',
-            'UndefinePreprocessorDefinitions': 'd1;d2;d3'},
-        'Midl': {
-            'AdditionalIncludeDirectories': 'folder1;folder2;folder3',
-            'AdditionalOptions': 'a_string',
-            'CPreprocessOptions': 'a_string',
-            'DefaultCharType': 'Unsigned',
-            'DllDataFileName': 'a_file_name',
-            'EnableErrorChecks': 'All',
-            'ErrorCheckAllocations': 'true',
-            'ErrorCheckBounds': 'true',
-            'ErrorCheckEnumRange': 'true',
-            'ErrorCheckRefPointers': 'true',
-            'ErrorCheckStubData': 'true',
-            'GenerateStublessProxies': 'true',
-            'GenerateTypeLibrary': 'true',
-            'HeaderFileName': 'a_file_name',
-            'IgnoreStandardIncludePath': 'true',
-            'InterfaceIdentifierFileName': 'a_file_name',
-            'MkTypLibCompatible': 'true',
-            'OutputDirectory': 'a_string',
-            'PreprocessorDefinitions': 'd1;d2;d3',
-            'ProxyFileName': 'a_file_name',
-            'RedirectOutputAndErrors': 'a_file_name',
-            'StructMemberAlignment': '4',
-            'SuppressStartupBanner': 'true',
-            'TargetEnvironment': 'Win32',
-            'TypeLibraryName': 'a_file_name',
-            'UndefinePreprocessorDefinitions': 'd1;d2;d3',
-            'ValidateAllParameters': 'true',
-            'WarnAsError': 'true',
-            'WarningLevel': '4'},
-        'Lib': {
-            'AdditionalDependencies': 'file1;file2;file3',
-            'AdditionalLibraryDirectories': 'folder1;folder2;folder3',
-            'AdditionalOptions': 'a_string',
-            'ExportNamedFunctions': 'd1;d2;d3',
-            'ForceSymbolReferences': 'a_string',
-            'IgnoreAllDefaultLibraries': 'true',
-            'IgnoreSpecificDefaultLibraries': 'file1;file2;file3',
-            'ModuleDefinitionFile': 'a_file_name',
-            'OutputFile': 'a_file_name',
-            'SuppressStartupBanner': 'true',
-            'UseUnicodeResponseFiles': 'true'},
-        'Manifest': {
-            'AdditionalManifestFiles': 'file1;file2;file3',
-            'AdditionalOptions': 'a_string',
-            'AssemblyIdentity': 'a_string',
-            'ComponentFileName': 'a_file_name',
-            'GenerateCatalogFiles': 'true',
-            'InputResourceManifests': 'a_string',
-            'OutputManifestFile': 'a_file_name',
-            'RegistrarScriptFile': 'a_file_name',
-            'ReplacementsFile': 'a_file_name',
-            'SuppressStartupBanner': 'true',
-            'TypeLibraryFile': 'a_file_name',
-            'UpdateFileHashes': 'true',
-            'UpdateFileHashesSearchPath': 'a_file_name',
-            'VerboseOutput': 'true'},
-        'ManifestResourceCompile': {
-            'ResourceOutputFileName': 'my_name'},
-        'ProjectReference': {
-            'LinkLibraryDependencies': 'true',
-            'UseLibraryDependencyInputs': 'false'},
-        '': {
-            'EmbedManifest': 'true',
-            'GenerateManifest': 'true',
-            'IgnoreImportLibrary': 'true',
-            'LinkIncremental': 'false'}}
-    self.maxDiff = 9999  # on failure display a long diff
-    actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
-        msvs_settings,
-        self.stderr)
-    self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
-    self._ExpectedWarnings([])
+    def testConvertToMSBuildSettings_full_synthetic(self):
+        """Tests conversion of all the MSBuild settings."""
+        msvs_settings = {
+            "VCCLCompilerTool": {
+                "AdditionalIncludeDirectories": "folder1;folder2;folder3",
+                "AdditionalOptions": "a_string",
+                "AdditionalUsingDirectories": "folder1;folder2;folder3",
+                "AssemblerListingLocation": "a_file_name",
+                "AssemblerOutput": "0",
+                "BasicRuntimeChecks": "1",
+                "BrowseInformation": "2",
+                "BrowseInformationFile": "a_file_name",
+                "BufferSecurityCheck": "true",
+                "CallingConvention": "0",
+                "CompileAs": "1",
+                "DebugInformationFormat": "4",
+                "DefaultCharIsUnsigned": "true",
+                "Detect64BitPortabilityProblems": "true",
+                "DisableLanguageExtensions": "true",
+                "DisableSpecificWarnings": "d1;d2;d3",
+                "EnableEnhancedInstructionSet": "0",
+                "EnableFiberSafeOptimizations": "true",
+                "EnableFunctionLevelLinking": "true",
+                "EnableIntrinsicFunctions": "true",
+                "EnablePREfast": "true",
+                "ErrorReporting": "1",
+                "ExceptionHandling": "2",
+                "ExpandAttributedSource": "true",
+                "FavorSizeOrSpeed": "0",
+                "FloatingPointExceptions": "true",
+                "FloatingPointModel": "1",
+                "ForceConformanceInForLoopScope": "true",
+                "ForcedIncludeFiles": "file1;file2;file3",
+                "ForcedUsingFiles": "file1;file2;file3",
+                "GeneratePreprocessedFile": "1",
+                "GenerateXMLDocumentationFiles": "true",
+                "IgnoreStandardIncludePath": "true",
+                "InlineFunctionExpansion": "2",
+                "KeepComments": "true",
+                "MinimalRebuild": "true",
+                "ObjectFile": "a_file_name",
+                "OmitDefaultLibName": "true",
+                "OmitFramePointers": "true",
+                "OpenMP": "true",
+                "Optimization": "3",
+                "PrecompiledHeaderFile": "a_file_name",
+                "PrecompiledHeaderThrough": "a_file_name",
+                "PreprocessorDefinitions": "d1;d2;d3",
+                "ProgramDataBaseFileName": "a_file_name",
+                "RuntimeLibrary": "0",
+                "RuntimeTypeInfo": "true",
+                "ShowIncludes": "true",
+                "SmallerTypeCheck": "true",
+                "StringPooling": "true",
+                "StructMemberAlignment": "1",
+                "SuppressStartupBanner": "true",
+                "TreatWChar_tAsBuiltInType": "true",
+                "UndefineAllPreprocessorDefinitions": "true",
+                "UndefinePreprocessorDefinitions": "d1;d2;d3",
+                "UseFullPaths": "true",
+                "UsePrecompiledHeader": "1",
+                "UseUnicodeResponseFiles": "true",
+                "WarnAsError": "true",
+                "WarningLevel": "2",
+                "WholeProgramOptimization": "true",
+                "XMLDocumentationFileName": "a_file_name",
+            },
+            "VCLinkerTool": {
+                "AdditionalDependencies": "file1;file2;file3",
+                "AdditionalLibraryDirectories": "folder1;folder2;folder3",
+                "AdditionalLibraryDirectories_excluded": "folder1;folder2;folder3",
+                "AdditionalManifestDependencies": "file1;file2;file3",
+                "AdditionalOptions": "a_string",
+                "AddModuleNamesToAssembly": "file1;file2;file3",
+                "AllowIsolation": "true",
+                "AssemblyDebug": "0",
+                "AssemblyLinkResource": "file1;file2;file3",
+                "BaseAddress": "a_string",
+                "CLRImageType": "1",
+                "CLRThreadAttribute": "2",
+                "CLRUnmanagedCodeCheck": "true",
+                "DataExecutionPrevention": "0",
+                "DelayLoadDLLs": "file1;file2;file3",
+                "DelaySign": "true",
+                "Driver": "1",
+                "EmbedManagedResourceFile": "file1;file2;file3",
+                "EnableCOMDATFolding": "0",
+                "EnableUAC": "true",
+                "EntryPointSymbol": "a_string",
+                "ErrorReporting": "0",
+                "FixedBaseAddress": "1",
+                "ForceSymbolReferences": "file1;file2;file3",
+                "FunctionOrder": "a_file_name",
+                "GenerateDebugInformation": "true",
+                "GenerateManifest": "true",
+                "GenerateMapFile": "true",
+                "HeapCommitSize": "a_string",
+                "HeapReserveSize": "a_string",
+                "IgnoreAllDefaultLibraries": "true",
+                "IgnoreDefaultLibraryNames": "file1;file2;file3",
+                "IgnoreEmbeddedIDL": "true",
+                "IgnoreImportLibrary": "true",
+                "ImportLibrary": "a_file_name",
+                "KeyContainer": "a_file_name",
+                "KeyFile": "a_file_name",
+                "LargeAddressAware": "2",
+                "LinkIncremental": "1",
+                "LinkLibraryDependencies": "true",
+                "LinkTimeCodeGeneration": "2",
+                "ManifestFile": "a_file_name",
+                "MapExports": "true",
+                "MapFileName": "a_file_name",
+                "MergedIDLBaseFileName": "a_file_name",
+                "MergeSections": "a_string",
+                "MidlCommandFile": "a_file_name",
+                "ModuleDefinitionFile": "a_file_name",
+                "OptimizeForWindows98": "1",
+                "OptimizeReferences": "0",
+                "OutputFile": "a_file_name",
+                "PerUserRedirection": "true",
+                "Profile": "true",
+                "ProfileGuidedDatabase": "a_file_name",
+                "ProgramDatabaseFile": "a_file_name",
+                "RandomizedBaseAddress": "1",
+                "RegisterOutput": "true",
+                "ResourceOnlyDLL": "true",
+                "SetChecksum": "true",
+                "ShowProgress": "0",
+                "StackCommitSize": "a_string",
+                "StackReserveSize": "a_string",
+                "StripPrivateSymbols": "a_file_name",
+                "SubSystem": "2",
+                "SupportUnloadOfDelayLoadedDLL": "true",
+                "SuppressStartupBanner": "true",
+                "SwapRunFromCD": "true",
+                "SwapRunFromNet": "true",
+                "TargetMachine": "3",
+                "TerminalServerAware": "2",
+                "TurnOffAssemblyGeneration": "true",
+                "TypeLibraryFile": "a_file_name",
+                "TypeLibraryResourceID": "33",
+                "UACExecutionLevel": "1",
+                "UACUIAccess": "true",
+                "UseLibraryDependencyInputs": "false",
+                "UseUnicodeResponseFiles": "true",
+                "Version": "a_string",
+            },
+            "VCResourceCompilerTool": {
+                "AdditionalIncludeDirectories": "folder1;folder2;folder3",
+                "AdditionalOptions": "a_string",
+                "Culture": "1003",
+                "IgnoreStandardIncludePath": "true",
+                "PreprocessorDefinitions": "d1;d2;d3",
+                "ResourceOutputFileName": "a_string",
+                "ShowProgress": "true",
+                "SuppressStartupBanner": "true",
+                "UndefinePreprocessorDefinitions": "d1;d2;d3",
+            },
+            "VCMIDLTool": {
+                "AdditionalIncludeDirectories": "folder1;folder2;folder3",
+                "AdditionalOptions": "a_string",
+                "CPreprocessOptions": "a_string",
+                "DefaultCharType": "0",
+                "DLLDataFileName": "a_file_name",
+                "EnableErrorChecks": "2",
+                "ErrorCheckAllocations": "true",
+                "ErrorCheckBounds": "true",
+                "ErrorCheckEnumRange": "true",
+                "ErrorCheckRefPointers": "true",
+                "ErrorCheckStubData": "true",
+                "GenerateStublessProxies": "true",
+                "GenerateTypeLibrary": "true",
+                "HeaderFileName": "a_file_name",
+                "IgnoreStandardIncludePath": "true",
+                "InterfaceIdentifierFileName": "a_file_name",
+                "MkTypLibCompatible": "true",
+                "OutputDirectory": "a_string",
+                "PreprocessorDefinitions": "d1;d2;d3",
+                "ProxyFileName": "a_file_name",
+                "RedirectOutputAndErrors": "a_file_name",
+                "StructMemberAlignment": "3",
+                "SuppressStartupBanner": "true",
+                "TargetEnvironment": "1",
+                "TypeLibraryName": "a_file_name",
+                "UndefinePreprocessorDefinitions": "d1;d2;d3",
+                "ValidateParameters": "true",
+                "WarnAsError": "true",
+                "WarningLevel": "4",
+            },
+            "VCLibrarianTool": {
+                "AdditionalDependencies": "file1;file2;file3",
+                "AdditionalLibraryDirectories": "folder1;folder2;folder3",
+                "AdditionalLibraryDirectories_excluded": "folder1;folder2;folder3",
+                "AdditionalOptions": "a_string",
+                "ExportNamedFunctions": "d1;d2;d3",
+                "ForceSymbolReferences": "a_string",
+                "IgnoreAllDefaultLibraries": "true",
+                "IgnoreSpecificDefaultLibraries": "file1;file2;file3",
+                "LinkLibraryDependencies": "true",
+                "ModuleDefinitionFile": "a_file_name",
+                "OutputFile": "a_file_name",
+                "SuppressStartupBanner": "true",
+                "UseUnicodeResponseFiles": "true",
+            },
+            "VCManifestTool": {
+                "AdditionalManifestFiles": "file1;file2;file3",
+                "AdditionalOptions": "a_string",
+                "AssemblyIdentity": "a_string",
+                "ComponentFileName": "a_file_name",
+                "DependencyInformationFile": "a_file_name",
+                "EmbedManifest": "true",
+                "GenerateCatalogFiles": "true",
+                "InputResourceManifests": "a_string",
+                "ManifestResourceFile": "my_name",
+                "OutputManifestFile": "a_file_name",
+                "RegistrarScriptFile": "a_file_name",
+                "ReplacementsFile": "a_file_name",
+                "SuppressStartupBanner": "true",
+                "TypeLibraryFile": "a_file_name",
+                "UpdateFileHashes": "true",
+                "UpdateFileHashesSearchPath": "a_file_name",
+                "UseFAT32Workaround": "true",
+                "UseUnicodeResponseFiles": "true",
+                "VerboseOutput": "true",
+            },
+        }
+        expected_msbuild_settings = {
+            "ClCompile": {
+                "AdditionalIncludeDirectories": "folder1;folder2;folder3",
+                "AdditionalOptions": "a_string /J",
+                "AdditionalUsingDirectories": "folder1;folder2;folder3",
+                "AssemblerListingLocation": "a_file_name",
+                "AssemblerOutput": "NoListing",
+                "BasicRuntimeChecks": "StackFrameRuntimeCheck",
+                "BrowseInformation": "true",
+                "BrowseInformationFile": "a_file_name",
+                "BufferSecurityCheck": "true",
+                "CallingConvention": "Cdecl",
+                "CompileAs": "CompileAsC",
+                "DebugInformationFormat": "EditAndContinue",
+                "DisableLanguageExtensions": "true",
+                "DisableSpecificWarnings": "d1;d2;d3",
+                "EnableEnhancedInstructionSet": "NotSet",
+                "EnableFiberSafeOptimizations": "true",
+                "EnablePREfast": "true",
+                "ErrorReporting": "Prompt",
+                "ExceptionHandling": "Async",
+                "ExpandAttributedSource": "true",
+                "FavorSizeOrSpeed": "Neither",
+                "FloatingPointExceptions": "true",
+                "FloatingPointModel": "Strict",
+                "ForceConformanceInForLoopScope": "true",
+                "ForcedIncludeFiles": "file1;file2;file3",
+                "ForcedUsingFiles": "file1;file2;file3",
+                "FunctionLevelLinking": "true",
+                "GenerateXMLDocumentationFiles": "true",
+                "IgnoreStandardIncludePath": "true",
+                "InlineFunctionExpansion": "AnySuitable",
+                "IntrinsicFunctions": "true",
+                "MinimalRebuild": "true",
+                "ObjectFileName": "a_file_name",
+                "OmitDefaultLibName": "true",
+                "OmitFramePointers": "true",
+                "OpenMPSupport": "true",
+                "Optimization": "Full",
+                "PrecompiledHeader": "Create",
+                "PrecompiledHeaderFile": "a_file_name",
+                "PrecompiledHeaderOutputFile": "a_file_name",
+                "PreprocessKeepComments": "true",
+                "PreprocessorDefinitions": "d1;d2;d3",
+                "PreprocessSuppressLineNumbers": "false",
+                "PreprocessToFile": "true",
+                "ProgramDataBaseFileName": "a_file_name",
+                "RuntimeLibrary": "MultiThreaded",
+                "RuntimeTypeInfo": "true",
+                "ShowIncludes": "true",
+                "SmallerTypeCheck": "true",
+                "StringPooling": "true",
+                "StructMemberAlignment": "1Byte",
+                "SuppressStartupBanner": "true",
+                "TreatWarningAsError": "true",
+                "TreatWChar_tAsBuiltInType": "true",
+                "UndefineAllPreprocessorDefinitions": "true",
+                "UndefinePreprocessorDefinitions": "d1;d2;d3",
+                "UseFullPaths": "true",
+                "WarningLevel": "Level2",
+                "WholeProgramOptimization": "true",
+                "XMLDocumentationFileName": "a_file_name",
+            },
+            "Link": {
+                "AdditionalDependencies": "file1;file2;file3",
+                "AdditionalLibraryDirectories": "folder1;folder2;folder3",
+                "AdditionalManifestDependencies": "file1;file2;file3",
+                "AdditionalOptions": "a_string",
+                "AddModuleNamesToAssembly": "file1;file2;file3",
+                "AllowIsolation": "true",
+                "AssemblyDebug": "",
+                "AssemblyLinkResource": "file1;file2;file3",
+                "BaseAddress": "a_string",
+                "CLRImageType": "ForceIJWImage",
+                "CLRThreadAttribute": "STAThreadingAttribute",
+                "CLRUnmanagedCodeCheck": "true",
+                "DataExecutionPrevention": "",
+                "DelayLoadDLLs": "file1;file2;file3",
+                "DelaySign": "true",
+                "Driver": "Driver",
+                "EmbedManagedResourceFile": "file1;file2;file3",
+                "EnableCOMDATFolding": "",
+                "EnableUAC": "true",
+                "EntryPointSymbol": "a_string",
+                "FixedBaseAddress": "false",
+                "ForceSymbolReferences": "file1;file2;file3",
+                "FunctionOrder": "a_file_name",
+                "GenerateDebugInformation": "true",
+                "GenerateMapFile": "true",
+                "HeapCommitSize": "a_string",
+                "HeapReserveSize": "a_string",
+                "IgnoreAllDefaultLibraries": "true",
+                "IgnoreEmbeddedIDL": "true",
+                "IgnoreSpecificDefaultLibraries": "file1;file2;file3",
+                "ImportLibrary": "a_file_name",
+                "KeyContainer": "a_file_name",
+                "KeyFile": "a_file_name",
+                "LargeAddressAware": "true",
+                "LinkErrorReporting": "NoErrorReport",
+                "LinkTimeCodeGeneration": "PGInstrument",
+                "ManifestFile": "a_file_name",
+                "MapExports": "true",
+                "MapFileName": "a_file_name",
+                "MergedIDLBaseFileName": "a_file_name",
+                "MergeSections": "a_string",
+                "MidlCommandFile": "a_file_name",
+                "ModuleDefinitionFile": "a_file_name",
+                "NoEntryPoint": "true",
+                "OptimizeReferences": "",
+                "OutputFile": "a_file_name",
+                "PerUserRedirection": "true",
+                "Profile": "true",
+                "ProfileGuidedDatabase": "a_file_name",
+                "ProgramDatabaseFile": "a_file_name",
+                "RandomizedBaseAddress": "false",
+                "RegisterOutput": "true",
+                "SetChecksum": "true",
+                "ShowProgress": "NotSet",
+                "StackCommitSize": "a_string",
+                "StackReserveSize": "a_string",
+                "StripPrivateSymbols": "a_file_name",
+                "SubSystem": "Windows",
+                "SupportUnloadOfDelayLoadedDLL": "true",
+                "SuppressStartupBanner": "true",
+                "SwapRunFromCD": "true",
+                "SwapRunFromNET": "true",
+                "TargetMachine": "MachineARM",
+                "TerminalServerAware": "true",
+                "TurnOffAssemblyGeneration": "true",
+                "TypeLibraryFile": "a_file_name",
+                "TypeLibraryResourceID": "33",
+                "UACExecutionLevel": "HighestAvailable",
+                "UACUIAccess": "true",
+                "Version": "a_string",
+            },
+            "ResourceCompile": {
+                "AdditionalIncludeDirectories": "folder1;folder2;folder3",
+                "AdditionalOptions": "a_string",
+                "Culture": "0x03eb",
+                "IgnoreStandardIncludePath": "true",
+                "PreprocessorDefinitions": "d1;d2;d3",
+                "ResourceOutputFileName": "a_string",
+                "ShowProgress": "true",
+                "SuppressStartupBanner": "true",
+                "UndefinePreprocessorDefinitions": "d1;d2;d3",
+            },
+            "Midl": {
+                "AdditionalIncludeDirectories": "folder1;folder2;folder3",
+                "AdditionalOptions": "a_string",
+                "CPreprocessOptions": "a_string",
+                "DefaultCharType": "Unsigned",
+                "DllDataFileName": "a_file_name",
+                "EnableErrorChecks": "All",
+                "ErrorCheckAllocations": "true",
+                "ErrorCheckBounds": "true",
+                "ErrorCheckEnumRange": "true",
+                "ErrorCheckRefPointers": "true",
+                "ErrorCheckStubData": "true",
+                "GenerateStublessProxies": "true",
+                "GenerateTypeLibrary": "true",
+                "HeaderFileName": "a_file_name",
+                "IgnoreStandardIncludePath": "true",
+                "InterfaceIdentifierFileName": "a_file_name",
+                "MkTypLibCompatible": "true",
+                "OutputDirectory": "a_string",
+                "PreprocessorDefinitions": "d1;d2;d3",
+                "ProxyFileName": "a_file_name",
+                "RedirectOutputAndErrors": "a_file_name",
+                "StructMemberAlignment": "4",
+                "SuppressStartupBanner": "true",
+                "TargetEnvironment": "Win32",
+                "TypeLibraryName": "a_file_name",
+                "UndefinePreprocessorDefinitions": "d1;d2;d3",
+                "ValidateAllParameters": "true",
+                "WarnAsError": "true",
+                "WarningLevel": "4",
+            },
+            "Lib": {
+                "AdditionalDependencies": "file1;file2;file3",
+                "AdditionalLibraryDirectories": "folder1;folder2;folder3",
+                "AdditionalOptions": "a_string",
+                "ExportNamedFunctions": "d1;d2;d3",
+                "ForceSymbolReferences": "a_string",
+                "IgnoreAllDefaultLibraries": "true",
+                "IgnoreSpecificDefaultLibraries": "file1;file2;file3",
+                "ModuleDefinitionFile": "a_file_name",
+                "OutputFile": "a_file_name",
+                "SuppressStartupBanner": "true",
+                "UseUnicodeResponseFiles": "true",
+            },
+            "Manifest": {
+                "AdditionalManifestFiles": "file1;file2;file3",
+                "AdditionalOptions": "a_string",
+                "AssemblyIdentity": "a_string",
+                "ComponentFileName": "a_file_name",
+                "GenerateCatalogFiles": "true",
+                "InputResourceManifests": "a_string",
+                "OutputManifestFile": "a_file_name",
+                "RegistrarScriptFile": "a_file_name",
+                "ReplacementsFile": "a_file_name",
+                "SuppressStartupBanner": "true",
+                "TypeLibraryFile": "a_file_name",
+                "UpdateFileHashes": "true",
+                "UpdateFileHashesSearchPath": "a_file_name",
+                "VerboseOutput": "true",
+            },
+            "ManifestResourceCompile": {"ResourceOutputFileName": "my_name"},
+            "ProjectReference": {
+                "LinkLibraryDependencies": "true",
+                "UseLibraryDependencyInputs": "false",
+            },
+            "": {
+                "EmbedManifest": "true",
+                "GenerateManifest": "true",
+                "IgnoreImportLibrary": "true",
+                "LinkIncremental": "false",
+            },
+        }
+        self.maxDiff = 9999  # on failure display a long diff
+        actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
+            msvs_settings, self.stderr
+        )
+        self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
+        self._ExpectedWarnings([])
 
-  def testConvertToMSBuildSettings_actual(self):
-    """Tests the conversion of an actual project.
+    def testConvertToMSBuildSettings_actual(self):
+        """Tests the conversion of an actual project.
 
     A VS2008 project with most of the options defined was created through the
     VS2008 IDE.  It was then converted to VS2010.  The tool settings found in
@@ -1136,354 +1187,364 @@ class TestSequenceFunctions(unittest.TestCase):
             AdditionalOptions:  ' %(AdditionalOptions)',
             InputResourceManifests:  ';%(InputResourceManifests)',
     """
-    msvs_settings = {
-        'VCCLCompilerTool': {
-            'AdditionalIncludeDirectories': 'dir1',
-            'AdditionalOptions': '/more',
-            'AdditionalUsingDirectories': 'test',
-            'AssemblerListingLocation': '$(IntDir)\\a',
-            'AssemblerOutput': '1',
-            'BasicRuntimeChecks': '3',
-            'BrowseInformation': '1',
-            'BrowseInformationFile': '$(IntDir)\\e',
-            'BufferSecurityCheck': 'false',
-            'CallingConvention': '1',
-            'CompileAs': '1',
-            'DebugInformationFormat': '4',
-            'DefaultCharIsUnsigned': 'true',
-            'Detect64BitPortabilityProblems': 'true',
-            'DisableLanguageExtensions': 'true',
-            'DisableSpecificWarnings': 'abc',
-            'EnableEnhancedInstructionSet': '1',
-            'EnableFiberSafeOptimizations': 'true',
-            'EnableFunctionLevelLinking': 'true',
-            'EnableIntrinsicFunctions': 'true',
-            'EnablePREfast': 'true',
-            'ErrorReporting': '2',
-            'ExceptionHandling': '2',
-            'ExpandAttributedSource': 'true',
-            'FavorSizeOrSpeed': '2',
-            'FloatingPointExceptions': 'true',
-            'FloatingPointModel': '1',
-            'ForceConformanceInForLoopScope': 'false',
-            'ForcedIncludeFiles': 'def',
-            'ForcedUsingFiles': 'ge',
-            'GeneratePreprocessedFile': '2',
-            'GenerateXMLDocumentationFiles': 'true',
-            'IgnoreStandardIncludePath': 'true',
-            'InlineFunctionExpansion': '1',
-            'KeepComments': 'true',
-            'MinimalRebuild': 'true',
-            'ObjectFile': '$(IntDir)\\b',
-            'OmitDefaultLibName': 'true',
-            'OmitFramePointers': 'true',
-            'OpenMP': 'true',
-            'Optimization': '3',
-            'PrecompiledHeaderFile': '$(IntDir)\\$(TargetName).pche',
-            'PrecompiledHeaderThrough': 'StdAfx.hd',
-            'PreprocessorDefinitions': 'WIN32;_DEBUG;_CONSOLE',
-            'ProgramDataBaseFileName': '$(IntDir)\\vc90b.pdb',
-            'RuntimeLibrary': '3',
-            'RuntimeTypeInfo': 'false',
-            'ShowIncludes': 'true',
-            'SmallerTypeCheck': 'true',
-            'StringPooling': 'true',
-            'StructMemberAlignment': '3',
-            'SuppressStartupBanner': 'false',
-            'TreatWChar_tAsBuiltInType': 'false',
-            'UndefineAllPreprocessorDefinitions': 'true',
-            'UndefinePreprocessorDefinitions': 'wer',
-            'UseFullPaths': 'true',
-            'UsePrecompiledHeader': '0',
-            'UseUnicodeResponseFiles': 'false',
-            'WarnAsError': 'true',
-            'WarningLevel': '3',
-            'WholeProgramOptimization': 'true',
-            'XMLDocumentationFileName': '$(IntDir)\\c'},
-        'VCLinkerTool': {
-            'AdditionalDependencies': 'zx',
-            'AdditionalLibraryDirectories': 'asd',
-            'AdditionalManifestDependencies': 's2',
-            'AdditionalOptions': '/mor2',
-            'AddModuleNamesToAssembly': 'd1',
-            'AllowIsolation': 'false',
-            'AssemblyDebug': '1',
-            'AssemblyLinkResource': 'd5',
-            'BaseAddress': '23423',
-            'CLRImageType': '3',
-            'CLRThreadAttribute': '1',
-            'CLRUnmanagedCodeCheck': 'true',
-            'DataExecutionPrevention': '0',
-            'DelayLoadDLLs': 'd4',
-            'DelaySign': 'true',
-            'Driver': '2',
-            'EmbedManagedResourceFile': 'd2',
-            'EnableCOMDATFolding': '1',
-            'EnableUAC': 'false',
-            'EntryPointSymbol': 'f5',
-            'ErrorReporting': '2',
-            'FixedBaseAddress': '1',
-            'ForceSymbolReferences': 'd3',
-            'FunctionOrder': 'fssdfsd',
-            'GenerateDebugInformation': 'true',
-            'GenerateManifest': 'false',
-            'GenerateMapFile': 'true',
-            'HeapCommitSize': '13',
-            'HeapReserveSize': '12',
-            'IgnoreAllDefaultLibraries': 'true',
-            'IgnoreDefaultLibraryNames': 'flob;flok',
-            'IgnoreEmbeddedIDL': 'true',
-            'IgnoreImportLibrary': 'true',
-            'ImportLibrary': 'f4',
-            'KeyContainer': 'f7',
-            'KeyFile': 'f6',
-            'LargeAddressAware': '2',
-            'LinkIncremental': '0',
-            'LinkLibraryDependencies': 'false',
-            'LinkTimeCodeGeneration': '1',
-            'ManifestFile':
-            '$(IntDir)\\$(TargetFileName).2intermediate.manifest',
-            'MapExports': 'true',
-            'MapFileName': 'd5',
-            'MergedIDLBaseFileName': 'f2',
-            'MergeSections': 'f5',
-            'MidlCommandFile': 'f1',
-            'ModuleDefinitionFile': 'sdsd',
-            'OptimizeForWindows98': '2',
-            'OptimizeReferences': '2',
-            'OutputFile': '$(OutDir)\\$(ProjectName)2.exe',
-            'PerUserRedirection': 'true',
-            'Profile': 'true',
-            'ProfileGuidedDatabase': '$(TargetDir)$(TargetName).pgdd',
-            'ProgramDatabaseFile': 'Flob.pdb',
-            'RandomizedBaseAddress': '1',
-            'RegisterOutput': 'true',
-            'ResourceOnlyDLL': 'true',
-            'SetChecksum': 'false',
-            'ShowProgress': '1',
-            'StackCommitSize': '15',
-            'StackReserveSize': '14',
-            'StripPrivateSymbols': 'd3',
-            'SubSystem': '1',
-            'SupportUnloadOfDelayLoadedDLL': 'true',
-            'SuppressStartupBanner': 'false',
-            'SwapRunFromCD': 'true',
-            'SwapRunFromNet': 'true',
-            'TargetMachine': '1',
-            'TerminalServerAware': '1',
-            'TurnOffAssemblyGeneration': 'true',
-            'TypeLibraryFile': 'f3',
-            'TypeLibraryResourceID': '12',
-            'UACExecutionLevel': '2',
-            'UACUIAccess': 'true',
-            'UseLibraryDependencyInputs': 'true',
-            'UseUnicodeResponseFiles': 'false',
-            'Version': '333'},
-        'VCResourceCompilerTool': {
-            'AdditionalIncludeDirectories': 'f3',
-            'AdditionalOptions': '/more3',
-            'Culture': '3084',
-            'IgnoreStandardIncludePath': 'true',
-            'PreprocessorDefinitions': '_UNICODE;UNICODE2',
-            'ResourceOutputFileName': '$(IntDir)/$(InputName)3.res',
-            'ShowProgress': 'true'},
-        'VCManifestTool': {
-            'AdditionalManifestFiles': 'sfsdfsd',
-            'AdditionalOptions': 'afdsdafsd',
-            'AssemblyIdentity': 'sddfdsadfsa',
-            'ComponentFileName': 'fsdfds',
-            'DependencyInformationFile': '$(IntDir)\\mt.depdfd',
-            'EmbedManifest': 'false',
-            'GenerateCatalogFiles': 'true',
-            'InputResourceManifests': 'asfsfdafs',
-            'ManifestResourceFile':
-            '$(IntDir)\\$(TargetFileName).embed.manifest.resfdsf',
-            'OutputManifestFile': '$(TargetPath).manifestdfs',
-            'RegistrarScriptFile': 'sdfsfd',
-            'ReplacementsFile': 'sdffsd',
-            'SuppressStartupBanner': 'false',
-            'TypeLibraryFile': 'sfsd',
-            'UpdateFileHashes': 'true',
-            'UpdateFileHashesSearchPath': 'sfsd',
-            'UseFAT32Workaround': 'true',
-            'UseUnicodeResponseFiles': 'false',
-            'VerboseOutput': 'true'}}
-    expected_msbuild_settings = {
-        'ClCompile': {
-            'AdditionalIncludeDirectories': 'dir1',
-            'AdditionalOptions': '/more /J',
-            'AdditionalUsingDirectories': 'test',
-            'AssemblerListingLocation': '$(IntDir)a',
-            'AssemblerOutput': 'AssemblyCode',
-            'BasicRuntimeChecks': 'EnableFastChecks',
-            'BrowseInformation': 'true',
-            'BrowseInformationFile': '$(IntDir)e',
-            'BufferSecurityCheck': 'false',
-            'CallingConvention': 'FastCall',
-            'CompileAs': 'CompileAsC',
-            'DebugInformationFormat': 'EditAndContinue',
-            'DisableLanguageExtensions': 'true',
-            'DisableSpecificWarnings': 'abc',
-            'EnableEnhancedInstructionSet': 'StreamingSIMDExtensions',
-            'EnableFiberSafeOptimizations': 'true',
-            'EnablePREfast': 'true',
-            'ErrorReporting': 'Queue',
-            'ExceptionHandling': 'Async',
-            'ExpandAttributedSource': 'true',
-            'FavorSizeOrSpeed': 'Size',
-            'FloatingPointExceptions': 'true',
-            'FloatingPointModel': 'Strict',
-            'ForceConformanceInForLoopScope': 'false',
-            'ForcedIncludeFiles': 'def',
-            'ForcedUsingFiles': 'ge',
-            'FunctionLevelLinking': 'true',
-            'GenerateXMLDocumentationFiles': 'true',
-            'IgnoreStandardIncludePath': 'true',
-            'InlineFunctionExpansion': 'OnlyExplicitInline',
-            'IntrinsicFunctions': 'true',
-            'MinimalRebuild': 'true',
-            'ObjectFileName': '$(IntDir)b',
-            'OmitDefaultLibName': 'true',
-            'OmitFramePointers': 'true',
-            'OpenMPSupport': 'true',
-            'Optimization': 'Full',
-            'PrecompiledHeader': 'NotUsing',  # Actual conversion gives ''
-            'PrecompiledHeaderFile': 'StdAfx.hd',
-            'PrecompiledHeaderOutputFile': '$(IntDir)$(TargetName).pche',
-            'PreprocessKeepComments': 'true',
-            'PreprocessorDefinitions': 'WIN32;_DEBUG;_CONSOLE',
-            'PreprocessSuppressLineNumbers': 'true',
-            'PreprocessToFile': 'true',
-            'ProgramDataBaseFileName': '$(IntDir)vc90b.pdb',
-            'RuntimeLibrary': 'MultiThreadedDebugDLL',
-            'RuntimeTypeInfo': 'false',
-            'ShowIncludes': 'true',
-            'SmallerTypeCheck': 'true',
-            'StringPooling': 'true',
-            'StructMemberAlignment': '4Bytes',
-            'SuppressStartupBanner': 'false',
-            'TreatWarningAsError': 'true',
-            'TreatWChar_tAsBuiltInType': 'false',
-            'UndefineAllPreprocessorDefinitions': 'true',
-            'UndefinePreprocessorDefinitions': 'wer',
-            'UseFullPaths': 'true',
-            'WarningLevel': 'Level3',
-            'WholeProgramOptimization': 'true',
-            'XMLDocumentationFileName': '$(IntDir)c'},
-        'Link': {
-            'AdditionalDependencies': 'zx',
-            'AdditionalLibraryDirectories': 'asd',
-            'AdditionalManifestDependencies': 's2',
-            'AdditionalOptions': '/mor2',
-            'AddModuleNamesToAssembly': 'd1',
-            'AllowIsolation': 'false',
-            'AssemblyDebug': 'true',
-            'AssemblyLinkResource': 'd5',
-            'BaseAddress': '23423',
-            'CLRImageType': 'ForceSafeILImage',
-            'CLRThreadAttribute': 'MTAThreadingAttribute',
-            'CLRUnmanagedCodeCheck': 'true',
-            'DataExecutionPrevention': '',
-            'DelayLoadDLLs': 'd4',
-            'DelaySign': 'true',
-            'Driver': 'UpOnly',
-            'EmbedManagedResourceFile': 'd2',
-            'EnableCOMDATFolding': 'false',
-            'EnableUAC': 'false',
-            'EntryPointSymbol': 'f5',
-            'FixedBaseAddress': 'false',
-            'ForceSymbolReferences': 'd3',
-            'FunctionOrder': 'fssdfsd',
-            'GenerateDebugInformation': 'true',
-            'GenerateMapFile': 'true',
-            'HeapCommitSize': '13',
-            'HeapReserveSize': '12',
-            'IgnoreAllDefaultLibraries': 'true',
-            'IgnoreEmbeddedIDL': 'true',
-            'IgnoreSpecificDefaultLibraries': 'flob;flok',
-            'ImportLibrary': 'f4',
-            'KeyContainer': 'f7',
-            'KeyFile': 'f6',
-            'LargeAddressAware': 'true',
-            'LinkErrorReporting': 'QueueForNextLogin',
-            'LinkTimeCodeGeneration': 'UseLinkTimeCodeGeneration',
-            'ManifestFile': '$(IntDir)$(TargetFileName).2intermediate.manifest',
-            'MapExports': 'true',
-            'MapFileName': 'd5',
-            'MergedIDLBaseFileName': 'f2',
-            'MergeSections': 'f5',
-            'MidlCommandFile': 'f1',
-            'ModuleDefinitionFile': 'sdsd',
-            'NoEntryPoint': 'true',
-            'OptimizeReferences': 'true',
-            'OutputFile': '$(OutDir)$(ProjectName)2.exe',
-            'PerUserRedirection': 'true',
-            'Profile': 'true',
-            'ProfileGuidedDatabase': '$(TargetDir)$(TargetName).pgdd',
-            'ProgramDatabaseFile': 'Flob.pdb',
-            'RandomizedBaseAddress': 'false',
-            'RegisterOutput': 'true',
-            'SetChecksum': 'false',
-            'ShowProgress': 'LinkVerbose',
-            'StackCommitSize': '15',
-            'StackReserveSize': '14',
-            'StripPrivateSymbols': 'd3',
-            'SubSystem': 'Console',
-            'SupportUnloadOfDelayLoadedDLL': 'true',
-            'SuppressStartupBanner': 'false',
-            'SwapRunFromCD': 'true',
-            'SwapRunFromNET': 'true',
-            'TargetMachine': 'MachineX86',
-            'TerminalServerAware': 'false',
-            'TurnOffAssemblyGeneration': 'true',
-            'TypeLibraryFile': 'f3',
-            'TypeLibraryResourceID': '12',
-            'UACExecutionLevel': 'RequireAdministrator',
-            'UACUIAccess': 'true',
-            'Version': '333'},
-        'ResourceCompile': {
-            'AdditionalIncludeDirectories': 'f3',
-            'AdditionalOptions': '/more3',
-            'Culture': '0x0c0c',
-            'IgnoreStandardIncludePath': 'true',
-            'PreprocessorDefinitions': '_UNICODE;UNICODE2',
-            'ResourceOutputFileName': '$(IntDir)%(Filename)3.res',
-            'ShowProgress': 'true'},
-        'Manifest': {
-            'AdditionalManifestFiles': 'sfsdfsd',
-            'AdditionalOptions': 'afdsdafsd',
-            'AssemblyIdentity': 'sddfdsadfsa',
-            'ComponentFileName': 'fsdfds',
-            'GenerateCatalogFiles': 'true',
-            'InputResourceManifests': 'asfsfdafs',
-            'OutputManifestFile': '$(TargetPath).manifestdfs',
-            'RegistrarScriptFile': 'sdfsfd',
-            'ReplacementsFile': 'sdffsd',
-            'SuppressStartupBanner': 'false',
-            'TypeLibraryFile': 'sfsd',
-            'UpdateFileHashes': 'true',
-            'UpdateFileHashesSearchPath': 'sfsd',
-            'VerboseOutput': 'true'},
-        'ProjectReference': {
-            'LinkLibraryDependencies': 'false',
-            'UseLibraryDependencyInputs': 'true'},
-        '': {
-            'EmbedManifest': 'false',
-            'GenerateManifest': 'false',
-            'IgnoreImportLibrary': 'true',
-            'LinkIncremental': ''
+        msvs_settings = {
+            "VCCLCompilerTool": {
+                "AdditionalIncludeDirectories": "dir1",
+                "AdditionalOptions": "/more",
+                "AdditionalUsingDirectories": "test",
+                "AssemblerListingLocation": "$(IntDir)\\a",
+                "AssemblerOutput": "1",
+                "BasicRuntimeChecks": "3",
+                "BrowseInformation": "1",
+                "BrowseInformationFile": "$(IntDir)\\e",
+                "BufferSecurityCheck": "false",
+                "CallingConvention": "1",
+                "CompileAs": "1",
+                "DebugInformationFormat": "4",
+                "DefaultCharIsUnsigned": "true",
+                "Detect64BitPortabilityProblems": "true",
+                "DisableLanguageExtensions": "true",
+                "DisableSpecificWarnings": "abc",
+                "EnableEnhancedInstructionSet": "1",
+                "EnableFiberSafeOptimizations": "true",
+                "EnableFunctionLevelLinking": "true",
+                "EnableIntrinsicFunctions": "true",
+                "EnablePREfast": "true",
+                "ErrorReporting": "2",
+                "ExceptionHandling": "2",
+                "ExpandAttributedSource": "true",
+                "FavorSizeOrSpeed": "2",
+                "FloatingPointExceptions": "true",
+                "FloatingPointModel": "1",
+                "ForceConformanceInForLoopScope": "false",
+                "ForcedIncludeFiles": "def",
+                "ForcedUsingFiles": "ge",
+                "GeneratePreprocessedFile": "2",
+                "GenerateXMLDocumentationFiles": "true",
+                "IgnoreStandardIncludePath": "true",
+                "InlineFunctionExpansion": "1",
+                "KeepComments": "true",
+                "MinimalRebuild": "true",
+                "ObjectFile": "$(IntDir)\\b",
+                "OmitDefaultLibName": "true",
+                "OmitFramePointers": "true",
+                "OpenMP": "true",
+                "Optimization": "3",
+                "PrecompiledHeaderFile": "$(IntDir)\\$(TargetName).pche",
+                "PrecompiledHeaderThrough": "StdAfx.hd",
+                "PreprocessorDefinitions": "WIN32;_DEBUG;_CONSOLE",
+                "ProgramDataBaseFileName": "$(IntDir)\\vc90b.pdb",
+                "RuntimeLibrary": "3",
+                "RuntimeTypeInfo": "false",
+                "ShowIncludes": "true",
+                "SmallerTypeCheck": "true",
+                "StringPooling": "true",
+                "StructMemberAlignment": "3",
+                "SuppressStartupBanner": "false",
+                "TreatWChar_tAsBuiltInType": "false",
+                "UndefineAllPreprocessorDefinitions": "true",
+                "UndefinePreprocessorDefinitions": "wer",
+                "UseFullPaths": "true",
+                "UsePrecompiledHeader": "0",
+                "UseUnicodeResponseFiles": "false",
+                "WarnAsError": "true",
+                "WarningLevel": "3",
+                "WholeProgramOptimization": "true",
+                "XMLDocumentationFileName": "$(IntDir)\\c",
+            },
+            "VCLinkerTool": {
+                "AdditionalDependencies": "zx",
+                "AdditionalLibraryDirectories": "asd",
+                "AdditionalManifestDependencies": "s2",
+                "AdditionalOptions": "/mor2",
+                "AddModuleNamesToAssembly": "d1",
+                "AllowIsolation": "false",
+                "AssemblyDebug": "1",
+                "AssemblyLinkResource": "d5",
+                "BaseAddress": "23423",
+                "CLRImageType": "3",
+                "CLRThreadAttribute": "1",
+                "CLRUnmanagedCodeCheck": "true",
+                "DataExecutionPrevention": "0",
+                "DelayLoadDLLs": "d4",
+                "DelaySign": "true",
+                "Driver": "2",
+                "EmbedManagedResourceFile": "d2",
+                "EnableCOMDATFolding": "1",
+                "EnableUAC": "false",
+                "EntryPointSymbol": "f5",
+                "ErrorReporting": "2",
+                "FixedBaseAddress": "1",
+                "ForceSymbolReferences": "d3",
+                "FunctionOrder": "fssdfsd",
+                "GenerateDebugInformation": "true",
+                "GenerateManifest": "false",
+                "GenerateMapFile": "true",
+                "HeapCommitSize": "13",
+                "HeapReserveSize": "12",
+                "IgnoreAllDefaultLibraries": "true",
+                "IgnoreDefaultLibraryNames": "flob;flok",
+                "IgnoreEmbeddedIDL": "true",
+                "IgnoreImportLibrary": "true",
+                "ImportLibrary": "f4",
+                "KeyContainer": "f7",
+                "KeyFile": "f6",
+                "LargeAddressAware": "2",
+                "LinkIncremental": "0",
+                "LinkLibraryDependencies": "false",
+                "LinkTimeCodeGeneration": "1",
+                "ManifestFile": "$(IntDir)\\$(TargetFileName).2intermediate.manifest",
+                "MapExports": "true",
+                "MapFileName": "d5",
+                "MergedIDLBaseFileName": "f2",
+                "MergeSections": "f5",
+                "MidlCommandFile": "f1",
+                "ModuleDefinitionFile": "sdsd",
+                "OptimizeForWindows98": "2",
+                "OptimizeReferences": "2",
+                "OutputFile": "$(OutDir)\\$(ProjectName)2.exe",
+                "PerUserRedirection": "true",
+                "Profile": "true",
+                "ProfileGuidedDatabase": "$(TargetDir)$(TargetName).pgdd",
+                "ProgramDatabaseFile": "Flob.pdb",
+                "RandomizedBaseAddress": "1",
+                "RegisterOutput": "true",
+                "ResourceOnlyDLL": "true",
+                "SetChecksum": "false",
+                "ShowProgress": "1",
+                "StackCommitSize": "15",
+                "StackReserveSize": "14",
+                "StripPrivateSymbols": "d3",
+                "SubSystem": "1",
+                "SupportUnloadOfDelayLoadedDLL": "true",
+                "SuppressStartupBanner": "false",
+                "SwapRunFromCD": "true",
+                "SwapRunFromNet": "true",
+                "TargetMachine": "1",
+                "TerminalServerAware": "1",
+                "TurnOffAssemblyGeneration": "true",
+                "TypeLibraryFile": "f3",
+                "TypeLibraryResourceID": "12",
+                "UACExecutionLevel": "2",
+                "UACUIAccess": "true",
+                "UseLibraryDependencyInputs": "true",
+                "UseUnicodeResponseFiles": "false",
+                "Version": "333",
+            },
+            "VCResourceCompilerTool": {
+                "AdditionalIncludeDirectories": "f3",
+                "AdditionalOptions": "/more3",
+                "Culture": "3084",
+                "IgnoreStandardIncludePath": "true",
+                "PreprocessorDefinitions": "_UNICODE;UNICODE2",
+                "ResourceOutputFileName": "$(IntDir)/$(InputName)3.res",
+                "ShowProgress": "true",
+            },
+            "VCManifestTool": {
+                "AdditionalManifestFiles": "sfsdfsd",
+                "AdditionalOptions": "afdsdafsd",
+                "AssemblyIdentity": "sddfdsadfsa",
+                "ComponentFileName": "fsdfds",
+                "DependencyInformationFile": "$(IntDir)\\mt.depdfd",
+                "EmbedManifest": "false",
+                "GenerateCatalogFiles": "true",
+                "InputResourceManifests": "asfsfdafs",
+                "ManifestResourceFile":
+                    "$(IntDir)\\$(TargetFileName).embed.manifest.resfdsf",
+                "OutputManifestFile": "$(TargetPath).manifestdfs",
+                "RegistrarScriptFile": "sdfsfd",
+                "ReplacementsFile": "sdffsd",
+                "SuppressStartupBanner": "false",
+                "TypeLibraryFile": "sfsd",
+                "UpdateFileHashes": "true",
+                "UpdateFileHashesSearchPath": "sfsd",
+                "UseFAT32Workaround": "true",
+                "UseUnicodeResponseFiles": "false",
+                "VerboseOutput": "true",
+            },
+        }
+        expected_msbuild_settings = {
+            "ClCompile": {
+                "AdditionalIncludeDirectories": "dir1",
+                "AdditionalOptions": "/more /J",
+                "AdditionalUsingDirectories": "test",
+                "AssemblerListingLocation": "$(IntDir)a",
+                "AssemblerOutput": "AssemblyCode",
+                "BasicRuntimeChecks": "EnableFastChecks",
+                "BrowseInformation": "true",
+                "BrowseInformationFile": "$(IntDir)e",
+                "BufferSecurityCheck": "false",
+                "CallingConvention": "FastCall",
+                "CompileAs": "CompileAsC",
+                "DebugInformationFormat": "EditAndContinue",
+                "DisableLanguageExtensions": "true",
+                "DisableSpecificWarnings": "abc",
+                "EnableEnhancedInstructionSet": "StreamingSIMDExtensions",
+                "EnableFiberSafeOptimizations": "true",
+                "EnablePREfast": "true",
+                "ErrorReporting": "Queue",
+                "ExceptionHandling": "Async",
+                "ExpandAttributedSource": "true",
+                "FavorSizeOrSpeed": "Size",
+                "FloatingPointExceptions": "true",
+                "FloatingPointModel": "Strict",
+                "ForceConformanceInForLoopScope": "false",
+                "ForcedIncludeFiles": "def",
+                "ForcedUsingFiles": "ge",
+                "FunctionLevelLinking": "true",
+                "GenerateXMLDocumentationFiles": "true",
+                "IgnoreStandardIncludePath": "true",
+                "InlineFunctionExpansion": "OnlyExplicitInline",
+                "IntrinsicFunctions": "true",
+                "MinimalRebuild": "true",
+                "ObjectFileName": "$(IntDir)b",
+                "OmitDefaultLibName": "true",
+                "OmitFramePointers": "true",
+                "OpenMPSupport": "true",
+                "Optimization": "Full",
+                "PrecompiledHeader": "NotUsing",  # Actual conversion gives ''
+                "PrecompiledHeaderFile": "StdAfx.hd",
+                "PrecompiledHeaderOutputFile": "$(IntDir)$(TargetName).pche",
+                "PreprocessKeepComments": "true",
+                "PreprocessorDefinitions": "WIN32;_DEBUG;_CONSOLE",
+                "PreprocessSuppressLineNumbers": "true",
+                "PreprocessToFile": "true",
+                "ProgramDataBaseFileName": "$(IntDir)vc90b.pdb",
+                "RuntimeLibrary": "MultiThreadedDebugDLL",
+                "RuntimeTypeInfo": "false",
+                "ShowIncludes": "true",
+                "SmallerTypeCheck": "true",
+                "StringPooling": "true",
+                "StructMemberAlignment": "4Bytes",
+                "SuppressStartupBanner": "false",
+                "TreatWarningAsError": "true",
+                "TreatWChar_tAsBuiltInType": "false",
+                "UndefineAllPreprocessorDefinitions": "true",
+                "UndefinePreprocessorDefinitions": "wer",
+                "UseFullPaths": "true",
+                "WarningLevel": "Level3",
+                "WholeProgramOptimization": "true",
+                "XMLDocumentationFileName": "$(IntDir)c",
+            },
+            "Link": {
+                "AdditionalDependencies": "zx",
+                "AdditionalLibraryDirectories": "asd",
+                "AdditionalManifestDependencies": "s2",
+                "AdditionalOptions": "/mor2",
+                "AddModuleNamesToAssembly": "d1",
+                "AllowIsolation": "false",
+                "AssemblyDebug": "true",
+                "AssemblyLinkResource": "d5",
+                "BaseAddress": "23423",
+                "CLRImageType": "ForceSafeILImage",
+                "CLRThreadAttribute": "MTAThreadingAttribute",
+                "CLRUnmanagedCodeCheck": "true",
+                "DataExecutionPrevention": "",
+                "DelayLoadDLLs": "d4",
+                "DelaySign": "true",
+                "Driver": "UpOnly",
+                "EmbedManagedResourceFile": "d2",
+                "EnableCOMDATFolding": "false",
+                "EnableUAC": "false",
+                "EntryPointSymbol": "f5",
+                "FixedBaseAddress": "false",
+                "ForceSymbolReferences": "d3",
+                "FunctionOrder": "fssdfsd",
+                "GenerateDebugInformation": "true",
+                "GenerateMapFile": "true",
+                "HeapCommitSize": "13",
+                "HeapReserveSize": "12",
+                "IgnoreAllDefaultLibraries": "true",
+                "IgnoreEmbeddedIDL": "true",
+                "IgnoreSpecificDefaultLibraries": "flob;flok",
+                "ImportLibrary": "f4",
+                "KeyContainer": "f7",
+                "KeyFile": "f6",
+                "LargeAddressAware": "true",
+                "LinkErrorReporting": "QueueForNextLogin",
+                "LinkTimeCodeGeneration": "UseLinkTimeCodeGeneration",
+                "ManifestFile": "$(IntDir)$(TargetFileName).2intermediate.manifest",
+                "MapExports": "true",
+                "MapFileName": "d5",
+                "MergedIDLBaseFileName": "f2",
+                "MergeSections": "f5",
+                "MidlCommandFile": "f1",
+                "ModuleDefinitionFile": "sdsd",
+                "NoEntryPoint": "true",
+                "OptimizeReferences": "true",
+                "OutputFile": "$(OutDir)$(ProjectName)2.exe",
+                "PerUserRedirection": "true",
+                "Profile": "true",
+                "ProfileGuidedDatabase": "$(TargetDir)$(TargetName).pgdd",
+                "ProgramDatabaseFile": "Flob.pdb",
+                "RandomizedBaseAddress": "false",
+                "RegisterOutput": "true",
+                "SetChecksum": "false",
+                "ShowProgress": "LinkVerbose",
+                "StackCommitSize": "15",
+                "StackReserveSize": "14",
+                "StripPrivateSymbols": "d3",
+                "SubSystem": "Console",
+                "SupportUnloadOfDelayLoadedDLL": "true",
+                "SuppressStartupBanner": "false",
+                "SwapRunFromCD": "true",
+                "SwapRunFromNET": "true",
+                "TargetMachine": "MachineX86",
+                "TerminalServerAware": "false",
+                "TurnOffAssemblyGeneration": "true",
+                "TypeLibraryFile": "f3",
+                "TypeLibraryResourceID": "12",
+                "UACExecutionLevel": "RequireAdministrator",
+                "UACUIAccess": "true",
+                "Version": "333",
+            },
+            "ResourceCompile": {
+                "AdditionalIncludeDirectories": "f3",
+                "AdditionalOptions": "/more3",
+                "Culture": "0x0c0c",
+                "IgnoreStandardIncludePath": "true",
+                "PreprocessorDefinitions": "_UNICODE;UNICODE2",
+                "ResourceOutputFileName": "$(IntDir)%(Filename)3.res",
+                "ShowProgress": "true",
+            },
+            "Manifest": {
+                "AdditionalManifestFiles": "sfsdfsd",
+                "AdditionalOptions": "afdsdafsd",
+                "AssemblyIdentity": "sddfdsadfsa",
+                "ComponentFileName": "fsdfds",
+                "GenerateCatalogFiles": "true",
+                "InputResourceManifests": "asfsfdafs",
+                "OutputManifestFile": "$(TargetPath).manifestdfs",
+                "RegistrarScriptFile": "sdfsfd",
+                "ReplacementsFile": "sdffsd",
+                "SuppressStartupBanner": "false",
+                "TypeLibraryFile": "sfsd",
+                "UpdateFileHashes": "true",
+                "UpdateFileHashesSearchPath": "sfsd",
+                "VerboseOutput": "true",
+            },
+            "ProjectReference": {
+                "LinkLibraryDependencies": "false",
+                "UseLibraryDependencyInputs": "true",
+            },
+            "": {
+                "EmbedManifest": "false",
+                "GenerateManifest": "false",
+                "IgnoreImportLibrary": "true",
+                "LinkIncremental": "",
+            },
+            "ManifestResourceCompile": {
+                "ResourceOutputFileName":
+                    "$(IntDir)$(TargetFileName).embed.manifest.resfdsf"
             },
-        'ManifestResourceCompile': {
-            'ResourceOutputFileName':
-            '$(IntDir)$(TargetFileName).embed.manifest.resfdsf'}
         }
-    self.maxDiff = 9999  # on failure display a long diff
-    actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
-        msvs_settings,
-        self.stderr)
-    self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
-    self._ExpectedWarnings([])
+        self.maxDiff = 9999  # on failure display a long diff
+        actual_msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(
+            msvs_settings, self.stderr
+        )
+        self.assertEqual(expected_msbuild_settings, actual_msbuild_settings)
+        self._ExpectedWarnings([])
 
 
-if __name__ == '__main__':
-  unittest.main()
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/gyp/pylib/gyp/MSVSToolFile.py b/tools/gyp/pylib/gyp/MSVSToolFile.py
index 74e529a17f1dcad3b0b1cf7138d118cd6db16eca..2c08589e06dc6d024cde5f05f43b6c4842ef208d 100644
--- a/tools/gyp/pylib/gyp/MSVSToolFile.py
+++ b/tools/gyp/pylib/gyp/MSVSToolFile.py
@@ -4,28 +4,27 @@
 
 """Visual Studio project reader/writer."""
 
-import gyp.common
 import gyp.easy_xml as easy_xml
 
 
 class Writer(object):
-  """Visual Studio XML tool file writer."""
+    """Visual Studio XML tool file writer."""
 
-  def __init__(self, tool_file_path, name):
-    """Initializes the tool file.
+    def __init__(self, tool_file_path, name):
+        """Initializes the tool file.
 
     Args:
       tool_file_path: Path to the tool file.
       name: Name of the tool file.
     """
-    self.tool_file_path = tool_file_path
-    self.name = name
-    self.rules_section = ['Rules']
+        self.tool_file_path = tool_file_path
+        self.name = name
+        self.rules_section = ["Rules"]
 
-  def AddCustomBuildRule(self, name, cmd, description,
-                         additional_dependencies,
-                         outputs, extensions):
-    """Adds a rule to the tool file.
+    def AddCustomBuildRule(
+        self, name, cmd, description, additional_dependencies, outputs, extensions
+    ):
+        """Adds a rule to the tool file.
 
     Args:
       name: Name of the rule.
@@ -35,24 +34,26 @@ class Writer(object):
       outputs: outputs of the rule.
       extensions: extensions handled by the rule.
     """
-    rule = ['CustomBuildRule',
-            {'Name': name,
-             'ExecutionDescription': description,
-             'CommandLine': cmd,
-             'Outputs': ';'.join(outputs),
-             'FileExtensions': ';'.join(extensions),
-             'AdditionalDependencies':
-                 ';'.join(additional_dependencies)
-            }]
-    self.rules_section.append(rule)
-
-  def WriteIfChanged(self):
-    """Writes the tool file."""
-    content = ['VisualStudioToolFile',
-               {'Version': '8.00',
-                'Name': self.name
-               },
-               self.rules_section
-               ]
-    easy_xml.WriteXmlIfChanged(content, self.tool_file_path,
-                               encoding="Windows-1252")
+        rule = [
+            "CustomBuildRule",
+            {
+                "Name": name,
+                "ExecutionDescription": description,
+                "CommandLine": cmd,
+                "Outputs": ";".join(outputs),
+                "FileExtensions": ";".join(extensions),
+                "AdditionalDependencies": ";".join(additional_dependencies),
+            },
+        ]
+        self.rules_section.append(rule)
+
+    def WriteIfChanged(self):
+        """Writes the tool file."""
+        content = [
+            "VisualStudioToolFile",
+            {"Version": "8.00", "Name": self.name},
+            self.rules_section,
+        ]
+        easy_xml.WriteXmlIfChanged(
+            content, self.tool_file_path, encoding="Windows-1252"
+        )
diff --git a/tools/gyp/pylib/gyp/MSVSUserFile.py b/tools/gyp/pylib/gyp/MSVSUserFile.py
index 2264d640152a290814c7abaccc5d47cbf5e9079b..de0896e69318164a7e1d2a10151c45065996d10f 100644
--- a/tools/gyp/pylib/gyp/MSVSUserFile.py
+++ b/tools/gyp/pylib/gyp/MSVSUserFile.py
@@ -6,78 +6,81 @@
 
 import os
 import re
-import socket # for gethostname
+import socket  # for gethostname
 
-import gyp.common
 import gyp.easy_xml as easy_xml
 
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
 
 def _FindCommandInPath(command):
-  """If there are no slashes in the command given, this function
+    """If there are no slashes in the command given, this function
      searches the PATH env to find the given command, and converts it
      to an absolute path.  We have to do this because MSVS is looking
      for an actual file to launch a debugger on, not just a command
      line.  Note that this happens at GYP time, so anything needing to
      be built needs to have a full path."""
-  if '/' in command or '\\' in command:
-    # If the command already has path elements (either relative or
-    # absolute), then assume it is constructed properly.
+    if "/" in command or "\\" in command:
+        # If the command already has path elements (either relative or
+        # absolute), then assume it is constructed properly.
+        return command
+    else:
+        # Search through the path list and find an existing file that
+        # we can access.
+        paths = os.environ.get("PATH", "").split(os.pathsep)
+        for path in paths:
+            item = os.path.join(path, command)
+            if os.path.isfile(item) and os.access(item, os.X_OK):
+                return item
     return command
-  else:
-    # Search through the path list and find an existing file that
-    # we can access.
-    paths = os.environ.get('PATH','').split(os.pathsep)
-    for path in paths:
-      item = os.path.join(path, command)
-      if os.path.isfile(item) and os.access(item, os.X_OK):
-        return item
-  return command
+
 
 def _QuoteWin32CommandLineArgs(args):
-  new_args = []
-  for arg in args:
-    # Replace all double-quotes with double-double-quotes to escape
-    # them for cmd shell, and then quote the whole thing if there
-    # are any.
-    if arg.find('"') != -1:
-      arg = '""'.join(arg.split('"'))
-      arg = '"%s"' % arg
-
-    # Otherwise, if there are any spaces, quote the whole arg.
-    elif re.search(r'[ \t\n]', arg):
-      arg = '"%s"' % arg
-    new_args.append(arg)
-  return new_args
+    new_args = []
+    for arg in args:
+        # Replace all double-quotes with double-double-quotes to escape
+        # them for cmd shell, and then quote the whole thing if there
+        # are any.
+        if arg.find('"') != -1:
+            arg = '""'.join(arg.split('"'))
+            arg = '"%s"' % arg
+
+        # Otherwise, if there are any spaces, quote the whole arg.
+        elif re.search(r"[ \t\n]", arg):
+            arg = '"%s"' % arg
+        new_args.append(arg)
+    return new_args
+
 
 class Writer(object):
-  """Visual Studio XML user user file writer."""
+    """Visual Studio XML user user file writer."""
 
-  def __init__(self, user_file_path, version, name):
-    """Initializes the user file.
+    def __init__(self, user_file_path, version, name):
+        """Initializes the user file.
 
     Args:
       user_file_path: Path to the user file.
       version: Version info.
       name: Name of the user file.
     """
-    self.user_file_path = user_file_path
-    self.version = version
-    self.name = name
-    self.configurations = {}
+        self.user_file_path = user_file_path
+        self.version = version
+        self.name = name
+        self.configurations = {}
 
-  def AddConfig(self, name):
-    """Adds a configuration to the project.
+    def AddConfig(self, name):
+        """Adds a configuration to the project.
 
     Args:
       name: Configuration name.
     """
-    self.configurations[name] = ['Configuration', {'Name': name}]
+        self.configurations[name] = ["Configuration", {"Name": name}]
 
-  def AddDebugSettings(self, config_name, command, environment = {},
-                       working_directory=""):
-    """Adds a DebugSettings node to the user file for a particular config.
+    def AddDebugSettings(
+        self, config_name, command, environment={}, working_directory=""
+    ):
+        """Adds a DebugSettings node to the user file for a particular config.
 
     Args:
       command: command line to run.  First element in the list is the
@@ -85,63 +88,66 @@ class Writer(object):
         necessary.
       working_directory: other files which may trigger the rule. (optional)
     """
-    command = _QuoteWin32CommandLineArgs(command)
-
-    abs_command = _FindCommandInPath(command[0])
-
-    if environment and isinstance(environment, dict):
-      env_list = ['%s="%s"' % (key, val)
-                  for (key,val) in environment.items()]
-      environment = ' '.join(env_list)
-    else:
-      environment = ''
-
-    n_cmd = ['DebugSettings',
-             {'Command': abs_command,
-              'WorkingDirectory': working_directory,
-              'CommandArguments': " ".join(command[1:]),
-              'RemoteMachine': socket.gethostname(),
-              'Environment': environment,
-              'EnvironmentMerge': 'true',
-              # Currently these are all "dummy" values that we're just setting
-              # in the default manner that MSVS does it.  We could use some of
-              # these to add additional capabilities, I suppose, but they might
-              # not have parity with other platforms then.
-              'Attach': 'false',
-              'DebuggerType': '3',  # 'auto' debugger
-              'Remote': '1',
-              'RemoteCommand': '',
-              'HttpUrl': '',
-              'PDBPath': '',
-              'SQLDebugging': '',
-              'DebuggerFlavor': '0',
-              'MPIRunCommand': '',
-              'MPIRunArguments': '',
-              'MPIRunWorkingDirectory': '',
-              'ApplicationCommand': '',
-              'ApplicationArguments': '',
-              'ShimCommand': '',
-              'MPIAcceptMode': '',
-              'MPIAcceptFilter': ''
-             }]
-
-    # Find the config, and add it if it doesn't exist.
-    if config_name not in self.configurations:
-      self.AddConfig(config_name)
-
-    # Add the DebugSettings onto the appropriate config.
-    self.configurations[config_name].append(n_cmd)
-
-  def WriteIfChanged(self):
-    """Writes the user file."""
-    configs = ['Configurations']
-    for config, spec in sorted(self.configurations.items()):
-      configs.append(spec)
-
-    content = ['VisualStudioUserFile',
-               {'Version': self.version.ProjectVersion(),
-                'Name': self.name
-               },
-               configs]
-    easy_xml.WriteXmlIfChanged(content, self.user_file_path,
-                               encoding="Windows-1252")
+        command = _QuoteWin32CommandLineArgs(command)
+
+        abs_command = _FindCommandInPath(command[0])
+
+        if environment and isinstance(environment, dict):
+            env_list = ['%s="%s"' % (key, val) for (key, val) in environment.items()]
+            environment = " ".join(env_list)
+        else:
+            environment = ""
+
+        n_cmd = [
+            "DebugSettings",
+            {
+                "Command": abs_command,
+                "WorkingDirectory": working_directory,
+                "CommandArguments": " ".join(command[1:]),
+                "RemoteMachine": socket.gethostname(),
+                "Environment": environment,
+                "EnvironmentMerge": "true",
+                # Currently these are all "dummy" values that we're just setting
+                # in the default manner that MSVS does it.  We could use some of
+                # these to add additional capabilities, I suppose, but they might
+                # not have parity with other platforms then.
+                "Attach": "false",
+                "DebuggerType": "3",  # 'auto' debugger
+                "Remote": "1",
+                "RemoteCommand": "",
+                "HttpUrl": "",
+                "PDBPath": "",
+                "SQLDebugging": "",
+                "DebuggerFlavor": "0",
+                "MPIRunCommand": "",
+                "MPIRunArguments": "",
+                "MPIRunWorkingDirectory": "",
+                "ApplicationCommand": "",
+                "ApplicationArguments": "",
+                "ShimCommand": "",
+                "MPIAcceptMode": "",
+                "MPIAcceptFilter": "",
+            },
+        ]
+
+        # Find the config, and add it if it doesn't exist.
+        if config_name not in self.configurations:
+            self.AddConfig(config_name)
+
+        # Add the DebugSettings onto the appropriate config.
+        self.configurations[config_name].append(n_cmd)
+
+    def WriteIfChanged(self):
+        """Writes the user file."""
+        configs = ["Configurations"]
+        for config, spec in sorted(self.configurations.items()):
+            configs.append(spec)
+
+        content = [
+            "VisualStudioUserFile",
+            {"Version": self.version.ProjectVersion(), "Name": self.name},
+            configs,
+        ]
+        easy_xml.WriteXmlIfChanged(
+            content, self.user_file_path, encoding="Windows-1252"
+        )
diff --git a/tools/gyp/pylib/gyp/MSVSUtil.py b/tools/gyp/pylib/gyp/MSVSUtil.py
index f24530b275f7cd38629867c4734bc9a9649e49df..83a9c297ed6e14b560f26fca8319b9c9d66963c8 100644
--- a/tools/gyp/pylib/gyp/MSVSUtil.py
+++ b/tools/gyp/pylib/gyp/MSVSUtil.py
@@ -10,25 +10,25 @@ import os
 
 # A dictionary mapping supported target types to extensions.
 TARGET_TYPE_EXT = {
-  'executable': 'exe',
-  'loadable_module': 'dll',
-  'shared_library': 'dll',
-  'static_library': 'lib',
-  'windows_driver': 'sys',
+    "executable": "exe",
+    "loadable_module": "dll",
+    "shared_library": "dll",
+    "static_library": "lib",
+    "windows_driver": "sys",
 }
 
 
 def _GetLargePdbShimCcPath():
-  """Returns the path of the large_pdb_shim.cc file."""
-  this_dir = os.path.abspath(os.path.dirname(__file__))
-  src_dir = os.path.abspath(os.path.join(this_dir, '..', '..'))
-  win_data_dir = os.path.join(src_dir, 'data', 'win')
-  large_pdb_shim_cc = os.path.join(win_data_dir, 'large-pdb-shim.cc')
-  return large_pdb_shim_cc
+    """Returns the path of the large_pdb_shim.cc file."""
+    this_dir = os.path.abspath(os.path.dirname(__file__))
+    src_dir = os.path.abspath(os.path.join(this_dir, "..", ".."))
+    win_data_dir = os.path.join(src_dir, "data", "win")
+    large_pdb_shim_cc = os.path.join(win_data_dir, "large-pdb-shim.cc")
+    return large_pdb_shim_cc
 
 
 def _DeepCopySomeKeys(in_dict, keys):
-  """Performs a partial deep-copy on |in_dict|, only copying the keys in |keys|.
+    """Performs a partial deep-copy on |in_dict|, only copying the keys in |keys|.
 
   Arguments:
     in_dict: The dictionary to copy.
@@ -37,16 +37,16 @@ def _DeepCopySomeKeys(in_dict, keys):
   Returns:
     The partially deep-copied dictionary.
   """
-  d = {}
-  for key in keys:
-    if key not in in_dict:
-      continue
-    d[key] = copy.deepcopy(in_dict[key])
-  return d
+    d = {}
+    for key in keys:
+        if key not in in_dict:
+            continue
+        d[key] = copy.deepcopy(in_dict[key])
+    return d
 
 
 def _SuffixName(name, suffix):
-  """Add a suffix to the end of a target.
+    """Add a suffix to the end of a target.
 
   Arguments:
     name: name of the target (foo#target)
@@ -54,13 +54,13 @@ def _SuffixName(name, suffix):
   Returns:
     Target name with suffix added (foo_suffix#target)
   """
-  parts = name.rsplit('#', 1)
-  parts[0] = '%s_%s' % (parts[0], suffix)
-  return '#'.join(parts)
+    parts = name.rsplit("#", 1)
+    parts[0] = "%s_%s" % (parts[0], suffix)
+    return "#".join(parts)
 
 
 def _ShardName(name, number):
-  """Add a shard number to the end of a target.
+    """Add a shard number to the end of a target.
 
   Arguments:
     name: name of the target (foo#target)
@@ -68,11 +68,11 @@ def _ShardName(name, number):
   Returns:
     Target name with shard added (foo_1#target)
   """
-  return _SuffixName(name, str(number))
+    return _SuffixName(name, str(number))
 
 
 def ShardTargets(target_list, target_dicts):
-  """Shard some targets apart to work around the linkers limits.
+    """Shard some targets apart to work around the linkers limits.
 
   Arguments:
     target_list: List of target pairs: 'base/base.gyp:base'.
@@ -80,54 +80,55 @@ def ShardTargets(target_list, target_dicts):
   Returns:
     Tuple of the new sharded versions of the inputs.
   """
-  # Gather the targets to shard, and how many pieces.
-  targets_to_shard = {}
-  for t in target_dicts:
-    shards = int(target_dicts[t].get('msvs_shard', 0))
-    if shards:
-      targets_to_shard[t] = shards
-  # Shard target_list.
-  new_target_list = []
-  for t in target_list:
-    if t in targets_to_shard:
-      for i in range(targets_to_shard[t]):
-        new_target_list.append(_ShardName(t, i))
-    else:
-      new_target_list.append(t)
-  # Shard target_dict.
-  new_target_dicts = {}
-  for t in target_dicts:
-    if t in targets_to_shard:
-      for i in range(targets_to_shard[t]):
-        name = _ShardName(t, i)
-        new_target_dicts[name] = copy.copy(target_dicts[t])
-        new_target_dicts[name]['target_name'] = _ShardName(
-             new_target_dicts[name]['target_name'], i)
-        sources = new_target_dicts[name].get('sources', [])
-        new_sources = []
-        for pos in range(i, len(sources), targets_to_shard[t]):
-          new_sources.append(sources[pos])
-        new_target_dicts[name]['sources'] = new_sources
-    else:
-      new_target_dicts[t] = target_dicts[t]
-  # Shard dependencies.
-  for t in sorted(new_target_dicts):
-    for deptype in ('dependencies', 'dependencies_original'):
-      dependencies = copy.copy(new_target_dicts[t].get(deptype, []))
-      new_dependencies = []
-      for d in dependencies:
-        if d in targets_to_shard:
-          for i in range(targets_to_shard[d]):
-            new_dependencies.append(_ShardName(d, i))
+    # Gather the targets to shard, and how many pieces.
+    targets_to_shard = {}
+    for t in target_dicts:
+        shards = int(target_dicts[t].get("msvs_shard", 0))
+        if shards:
+            targets_to_shard[t] = shards
+    # Shard target_list.
+    new_target_list = []
+    for t in target_list:
+        if t in targets_to_shard:
+            for i in range(targets_to_shard[t]):
+                new_target_list.append(_ShardName(t, i))
         else:
-          new_dependencies.append(d)
-      new_target_dicts[t][deptype] = new_dependencies
-
-  return (new_target_list, new_target_dicts)
+            new_target_list.append(t)
+    # Shard target_dict.
+    new_target_dicts = {}
+    for t in target_dicts:
+        if t in targets_to_shard:
+            for i in range(targets_to_shard[t]):
+                name = _ShardName(t, i)
+                new_target_dicts[name] = copy.copy(target_dicts[t])
+                new_target_dicts[name]["target_name"] = _ShardName(
+                    new_target_dicts[name]["target_name"], i
+                )
+                sources = new_target_dicts[name].get("sources", [])
+                new_sources = []
+                for pos in range(i, len(sources), targets_to_shard[t]):
+                    new_sources.append(sources[pos])
+                new_target_dicts[name]["sources"] = new_sources
+        else:
+            new_target_dicts[t] = target_dicts[t]
+    # Shard dependencies.
+    for t in sorted(new_target_dicts):
+        for deptype in ("dependencies", "dependencies_original"):
+            dependencies = copy.copy(new_target_dicts[t].get(deptype, []))
+            new_dependencies = []
+            for d in dependencies:
+                if d in targets_to_shard:
+                    for i in range(targets_to_shard[d]):
+                        new_dependencies.append(_ShardName(d, i))
+                else:
+                    new_dependencies.append(d)
+            new_target_dicts[t][deptype] = new_dependencies
+
+    return (new_target_list, new_target_dicts)
 
 
 def _GetPdbPath(target_dict, config_name, vars):
-  """Returns the path to the PDB file that will be generated by a given
+    """Returns the path to the PDB file that will be generated by a given
   configuration.
 
   The lookup proceeds as follows:
@@ -144,30 +145,29 @@ def _GetPdbPath(target_dict, config_name, vars):
   Returns:
     The path of the corresponding PDB file.
   """
-  config = target_dict['configurations'][config_name]
-  msvs = config.setdefault('msvs_settings', {})
-
-  linker = msvs.get('VCLinkerTool', {})
+    config = target_dict["configurations"][config_name]
+    msvs = config.setdefault("msvs_settings", {})
 
-  pdb_path = linker.get('ProgramDatabaseFile')
-  if pdb_path:
-    return pdb_path
+    linker = msvs.get("VCLinkerTool", {})
 
-  variables = target_dict.get('variables', {})
-  pdb_path = variables.get('msvs_large_pdb_path', None)
-  if pdb_path:
-    return pdb_path
+    pdb_path = linker.get("ProgramDatabaseFile")
+    if pdb_path:
+        return pdb_path
 
+    variables = target_dict.get("variables", {})
+    pdb_path = variables.get("msvs_large_pdb_path", None)
+    if pdb_path:
+        return pdb_path
 
-  pdb_base = target_dict.get('product_name', target_dict['target_name'])
-  pdb_base = '%s.%s.pdb' % (pdb_base, TARGET_TYPE_EXT[target_dict['type']])
-  pdb_path = vars['PRODUCT_DIR'] + '/' + pdb_base
+    pdb_base = target_dict.get("product_name", target_dict["target_name"])
+    pdb_base = "%s.%s.pdb" % (pdb_base, TARGET_TYPE_EXT[target_dict["type"]])
+    pdb_path = vars["PRODUCT_DIR"] + "/" + pdb_base
 
-  return pdb_path
+    return pdb_path
 
 
 def InsertLargePdbShims(target_list, target_dicts, vars):
-  """Insert a shim target that forces the linker to use 4KB pagesize PDBs.
+    """Insert a shim target that forces the linker to use 4KB pagesize PDBs.
 
   This is a workaround for targets with PDBs greater than 1GB in size, the
   limit for the 1KB pagesize PDBs created by the linker by default.
@@ -179,93 +179,93 @@ def InsertLargePdbShims(target_list, target_dicts, vars):
   Returns:
     Tuple of the shimmed version of the inputs.
   """
-  # Determine which targets need shimming.
-  targets_to_shim = []
-  for t in target_dicts:
-    target_dict = target_dicts[t]
-
-    # We only want to shim targets that have msvs_large_pdb enabled.
-    if not int(target_dict.get('msvs_large_pdb', 0)):
-      continue
-    # This is intended for executable, shared_library and loadable_module
-    # targets where every configuration is set up to produce a PDB output.
-    # If any of these conditions is not true then the shim logic will fail
-    # below.
-    targets_to_shim.append(t)
-
-  large_pdb_shim_cc = _GetLargePdbShimCcPath()
-
-  for t in targets_to_shim:
-    target_dict = target_dicts[t]
-    target_name = target_dict.get('target_name')
-
-    base_dict = _DeepCopySomeKeys(target_dict,
-          ['configurations', 'default_configuration', 'toolset'])
-
-    # This is the dict for copying the source file (part of the GYP tree)
-    # to the intermediate directory of the project. This is necessary because
-    # we can't always build a relative path to the shim source file (on Windows
-    # GYP and the project may be on different drives), and Ninja hates absolute
-    # paths (it ends up generating the .obj and .obj.d alongside the source
-    # file, polluting GYPs tree).
-    copy_suffix = 'large_pdb_copy'
-    copy_target_name = target_name + '_' + copy_suffix
-    full_copy_target_name = _SuffixName(t, copy_suffix)
-    shim_cc_basename = os.path.basename(large_pdb_shim_cc)
-    shim_cc_dir = vars['SHARED_INTERMEDIATE_DIR'] + '/' + copy_target_name
-    shim_cc_path = shim_cc_dir + '/' + shim_cc_basename
-    copy_dict = copy.deepcopy(base_dict)
-    copy_dict['target_name'] = copy_target_name
-    copy_dict['type'] = 'none'
-    copy_dict['sources'] = [ large_pdb_shim_cc ]
-    copy_dict['copies'] = [{
-      'destination': shim_cc_dir,
-      'files': [ large_pdb_shim_cc ]
-    }]
-
-    # This is the dict for the PDB generating shim target. It depends on the
-    # copy target.
-    shim_suffix = 'large_pdb_shim'
-    shim_target_name = target_name + '_' + shim_suffix
-    full_shim_target_name = _SuffixName(t, shim_suffix)
-    shim_dict = copy.deepcopy(base_dict)
-    shim_dict['target_name'] = shim_target_name
-    shim_dict['type'] = 'static_library'
-    shim_dict['sources'] = [ shim_cc_path ]
-    shim_dict['dependencies'] = [ full_copy_target_name ]
-
-    # Set up the shim to output its PDB to the same location as the final linker
-    # target.
-    for config_name, config in shim_dict.get('configurations').items():
-      pdb_path = _GetPdbPath(target_dict, config_name, vars)
-
-      # A few keys that we don't want to propagate.
-      for key in ['msvs_precompiled_header', 'msvs_precompiled_source', 'test']:
-        config.pop(key, None)
-
-      msvs = config.setdefault('msvs_settings', {})
-
-      # Update the compiler directives in the shim target.
-      compiler = msvs.setdefault('VCCLCompilerTool', {})
-      compiler['DebugInformationFormat'] = '3'
-      compiler['ProgramDataBaseFileName'] = pdb_path
-
-      # Set the explicit PDB path in the appropriate configuration of the
-      # original target.
-      config = target_dict['configurations'][config_name]
-      msvs = config.setdefault('msvs_settings', {})
-      linker = msvs.setdefault('VCLinkerTool', {})
-      linker['GenerateDebugInformation'] = 'true'
-      linker['ProgramDatabaseFile'] = pdb_path
-
-    # Add the new targets. They must go to the beginning of the list so that
-    # the dependency generation works as expected in ninja.
-    target_list.insert(0, full_copy_target_name)
-    target_list.insert(0, full_shim_target_name)
-    target_dicts[full_copy_target_name] = copy_dict
-    target_dicts[full_shim_target_name] = shim_dict
-
-    # Update the original target to depend on the shim target.
-    target_dict.setdefault('dependencies', []).append(full_shim_target_name)
-
-  return (target_list, target_dicts)
+    # Determine which targets need shimming.
+    targets_to_shim = []
+    for t in target_dicts:
+        target_dict = target_dicts[t]
+
+        # We only want to shim targets that have msvs_large_pdb enabled.
+        if not int(target_dict.get("msvs_large_pdb", 0)):
+            continue
+        # This is intended for executable, shared_library and loadable_module
+        # targets where every configuration is set up to produce a PDB output.
+        # If any of these conditions is not true then the shim logic will fail
+        # below.
+        targets_to_shim.append(t)
+
+    large_pdb_shim_cc = _GetLargePdbShimCcPath()
+
+    for t in targets_to_shim:
+        target_dict = target_dicts[t]
+        target_name = target_dict.get("target_name")
+
+        base_dict = _DeepCopySomeKeys(
+            target_dict, ["configurations", "default_configuration", "toolset"]
+        )
+
+        # This is the dict for copying the source file (part of the GYP tree)
+        # to the intermediate directory of the project. This is necessary because
+        # we can't always build a relative path to the shim source file (on Windows
+        # GYP and the project may be on different drives), and Ninja hates absolute
+        # paths (it ends up generating the .obj and .obj.d alongside the source
+        # file, polluting GYPs tree).
+        copy_suffix = "large_pdb_copy"
+        copy_target_name = target_name + "_" + copy_suffix
+        full_copy_target_name = _SuffixName(t, copy_suffix)
+        shim_cc_basename = os.path.basename(large_pdb_shim_cc)
+        shim_cc_dir = vars["SHARED_INTERMEDIATE_DIR"] + "/" + copy_target_name
+        shim_cc_path = shim_cc_dir + "/" + shim_cc_basename
+        copy_dict = copy.deepcopy(base_dict)
+        copy_dict["target_name"] = copy_target_name
+        copy_dict["type"] = "none"
+        copy_dict["sources"] = [large_pdb_shim_cc]
+        copy_dict["copies"] = [
+            {"destination": shim_cc_dir, "files": [large_pdb_shim_cc]}
+        ]
+
+        # This is the dict for the PDB generating shim target. It depends on the
+        # copy target.
+        shim_suffix = "large_pdb_shim"
+        shim_target_name = target_name + "_" + shim_suffix
+        full_shim_target_name = _SuffixName(t, shim_suffix)
+        shim_dict = copy.deepcopy(base_dict)
+        shim_dict["target_name"] = shim_target_name
+        shim_dict["type"] = "static_library"
+        shim_dict["sources"] = [shim_cc_path]
+        shim_dict["dependencies"] = [full_copy_target_name]
+
+        # Set up the shim to output its PDB to the same location as the final linker
+        # target.
+        for config_name, config in shim_dict.get("configurations").items():
+            pdb_path = _GetPdbPath(target_dict, config_name, vars)
+
+            # A few keys that we don't want to propagate.
+            for key in ["msvs_precompiled_header", "msvs_precompiled_source", "test"]:
+                config.pop(key, None)
+
+            msvs = config.setdefault("msvs_settings", {})
+
+            # Update the compiler directives in the shim target.
+            compiler = msvs.setdefault("VCCLCompilerTool", {})
+            compiler["DebugInformationFormat"] = "3"
+            compiler["ProgramDataBaseFileName"] = pdb_path
+
+            # Set the explicit PDB path in the appropriate configuration of the
+            # original target.
+            config = target_dict["configurations"][config_name]
+            msvs = config.setdefault("msvs_settings", {})
+            linker = msvs.setdefault("VCLinkerTool", {})
+            linker["GenerateDebugInformation"] = "true"
+            linker["ProgramDatabaseFile"] = pdb_path
+
+        # Add the new targets. They must go to the beginning of the list so that
+        # the dependency generation works as expected in ninja.
+        target_list.insert(0, full_copy_target_name)
+        target_list.insert(0, full_shim_target_name)
+        target_dicts[full_copy_target_name] = copy_dict
+        target_dicts[full_shim_target_name] = shim_dict
+
+        # Update the original target to depend on the shim target.
+        target_dict.setdefault("dependencies", []).append(full_shim_target_name)
+
+    return (target_list, target_dicts)
diff --git a/tools/gyp/pylib/gyp/MSVSVersion.py b/tools/gyp/pylib/gyp/MSVSVersion.py
index ce9b349834c947d9fe22b6e0a86a9969dd8321d2..36b006aaa937594a845b911869d67524686cf613 100644
--- a/tools/gyp/pylib/gyp/MSVSVersion.py
+++ b/tools/gyp/pylib/gyp/MSVSVersion.py
@@ -9,139 +9,152 @@ import os
 import re
 import subprocess
 import sys
-import gyp
 import glob
 
 PY3 = bytes != str
 
 
 def JoinPath(*args):
-  return os.path.normpath(os.path.join(*args))
+    return os.path.normpath(os.path.join(*args))
 
 
 class VisualStudioVersion(object):
-  """Information regarding a version of Visual Studio."""
-
-  def __init__(self, short_name, description,
-               solution_version, project_version, flat_sln, uses_vcxproj,
-               path, sdk_based, default_toolset=None, compatible_sdks=None):
-    self.short_name = short_name
-    self.description = description
-    self.solution_version = solution_version
-    self.project_version = project_version
-    self.flat_sln = flat_sln
-    self.uses_vcxproj = uses_vcxproj
-    self.path = path
-    self.sdk_based = sdk_based
-    self.default_toolset = default_toolset
-    compatible_sdks = compatible_sdks or []
-    compatible_sdks.sort(key=lambda v: float(v.replace('v', '')), reverse=True)
-    self.compatible_sdks = compatible_sdks
-
-  def ShortName(self):
-    return self.short_name
-
-  def Description(self):
-    """Get the full description of the version."""
-    return self.description
-
-  def SolutionVersion(self):
-    """Get the version number of the sln files."""
-    return self.solution_version
-
-  def ProjectVersion(self):
-    """Get the version number of the vcproj or vcxproj files."""
-    return self.project_version
-
-  def FlatSolution(self):
-    return self.flat_sln
-
-  def UsesVcxproj(self):
-    """Returns true if this version uses a vcxproj file."""
-    return self.uses_vcxproj
-
-  def ProjectExtension(self):
-    """Returns the file extension for the project."""
-    return self.uses_vcxproj and '.vcxproj' or '.vcproj'
-
-  def Path(self):
-    """Returns the path to Visual Studio installation."""
-    return self.path
-
-  def ToolPath(self, tool):
-    """Returns the path to a given compiler tool. """
-    return os.path.normpath(os.path.join(self.path, "VC/bin", tool))
-
-  def DefaultToolset(self):
-    """Returns the msbuild toolset version that will be used in the absence
+    """Information regarding a version of Visual Studio."""
+
+    def __init__(
+        self,
+        short_name,
+        description,
+        solution_version,
+        project_version,
+        flat_sln,
+        uses_vcxproj,
+        path,
+        sdk_based,
+        default_toolset=None,
+        compatible_sdks=None,
+    ):
+        self.short_name = short_name
+        self.description = description
+        self.solution_version = solution_version
+        self.project_version = project_version
+        self.flat_sln = flat_sln
+        self.uses_vcxproj = uses_vcxproj
+        self.path = path
+        self.sdk_based = sdk_based
+        self.default_toolset = default_toolset
+        compatible_sdks = compatible_sdks or []
+        compatible_sdks.sort(key=lambda v: float(v.replace("v", "")), reverse=True)
+        self.compatible_sdks = compatible_sdks
+
+    def ShortName(self):
+        return self.short_name
+
+    def Description(self):
+        """Get the full description of the version."""
+        return self.description
+
+    def SolutionVersion(self):
+        """Get the version number of the sln files."""
+        return self.solution_version
+
+    def ProjectVersion(self):
+        """Get the version number of the vcproj or vcxproj files."""
+        return self.project_version
+
+    def FlatSolution(self):
+        return self.flat_sln
+
+    def UsesVcxproj(self):
+        """Returns true if this version uses a vcxproj file."""
+        return self.uses_vcxproj
+
+    def ProjectExtension(self):
+        """Returns the file extension for the project."""
+        return self.uses_vcxproj and ".vcxproj" or ".vcproj"
+
+    def Path(self):
+        """Returns the path to Visual Studio installation."""
+        return self.path
+
+    def ToolPath(self, tool):
+        """Returns the path to a given compiler tool. """
+        return os.path.normpath(os.path.join(self.path, "VC/bin", tool))
+
+    def DefaultToolset(self):
+        """Returns the msbuild toolset version that will be used in the absence
     of a user override."""
-    return self.default_toolset
+        return self.default_toolset
 
-
-  def _SetupScriptInternal(self, target_arch):
-    """Returns a command (with arguments) to be used to set up the
+    def _SetupScriptInternal(self, target_arch):
+        """Returns a command (with arguments) to be used to set up the
     environment."""
-    assert target_arch in ('x86', 'x64'), "target_arch not supported"
-    # If WindowsSDKDir is set and SetEnv.Cmd exists then we are using the
-    # depot_tools build tools and should run SetEnv.Cmd to set up the
-    # environment. The check for WindowsSDKDir alone is not sufficient because
-    # this is set by running vcvarsall.bat.
-    sdk_dir = os.environ.get('WindowsSDKDir', '')
-    setup_path = JoinPath(sdk_dir, 'Bin', 'SetEnv.Cmd')
-    if self.sdk_based and sdk_dir and os.path.exists(setup_path):
-      return [setup_path, '/' + target_arch]
-
-    is_host_arch_x64 = (
-      os.environ.get('PROCESSOR_ARCHITECTURE') == 'AMD64' or
-      os.environ.get('PROCESSOR_ARCHITEW6432') == 'AMD64'
-    )
-
-    # For VS2017 (and newer) it's fairly easy
-    if self.short_name >= '2017':
-      script_path = JoinPath(self.path,
-                             'VC', 'Auxiliary', 'Build', 'vcvarsall.bat')
-
-      # Always use a native executable, cross-compiling if necessary.
-      host_arch = 'amd64' if is_host_arch_x64 else 'x86'
-      msvc_target_arch = 'amd64' if target_arch == 'x64' else 'x86'
-      arg = host_arch
-      if host_arch != msvc_target_arch:
-        arg += '_' + msvc_target_arch
-
-      return [script_path, arg]
-
-    # We try to find the best version of the env setup batch.
-    vcvarsall = JoinPath(self.path, 'VC', 'vcvarsall.bat')
-    if target_arch == 'x86':
-      if self.short_name >= '2013' and self.short_name[-1] != 'e' and \
-         is_host_arch_x64:
-        # VS2013 and later, non-Express have a x64-x86 cross that we want
-        # to prefer.
-        return [vcvarsall, 'amd64_x86']
-      else:
-        # Otherwise, the standard x86 compiler. We don't use VC/vcvarsall.bat
-        # for x86 because vcvarsall calls vcvars32, which it can only find if
-        # VS??COMNTOOLS is set, which isn't guaranteed.
-        return [JoinPath(self.path, 'Common7', 'Tools', 'vsvars32.bat')]
-    elif target_arch == 'x64':
-      arg = 'x86_amd64'
-      # Use the 64-on-64 compiler if we're not using an express edition and
-      # we're running on a 64bit OS.
-      if self.short_name[-1] != 'e' and is_host_arch_x64:
-        arg = 'amd64'
-      return [vcvarsall, arg]
-
-  def SetupScript(self, target_arch):
-    script_data = self._SetupScriptInternal(target_arch)
-    script_path = script_data[0]
-    if not os.path.exists(script_path):
-      raise Exception('%s is missing - make sure VC++ tools are installed.' %
-                      script_path)
-    return script_data
+        assert target_arch in ("x86", "x64"), "target_arch not supported"
+        # If WindowsSDKDir is set and SetEnv.Cmd exists then we are using the
+        # depot_tools build tools and should run SetEnv.Cmd to set up the
+        # environment. The check for WindowsSDKDir alone is not sufficient because
+        # this is set by running vcvarsall.bat.
+        sdk_dir = os.environ.get("WindowsSDKDir", "")
+        setup_path = JoinPath(sdk_dir, "Bin", "SetEnv.Cmd")
+        if self.sdk_based and sdk_dir and os.path.exists(setup_path):
+            return [setup_path, "/" + target_arch]
+
+        is_host_arch_x64 = (
+            os.environ.get("PROCESSOR_ARCHITECTURE") == "AMD64"
+            or os.environ.get("PROCESSOR_ARCHITEW6432") == "AMD64"
+        )
+
+        # For VS2017 (and newer) it's fairly easy
+        if self.short_name >= "2017":
+            script_path = JoinPath(
+                self.path, "VC", "Auxiliary", "Build", "vcvarsall.bat"
+            )
+
+            # Always use a native executable, cross-compiling if necessary.
+            host_arch = "amd64" if is_host_arch_x64 else "x86"
+            msvc_target_arch = "amd64" if target_arch == "x64" else "x86"
+            arg = host_arch
+            if host_arch != msvc_target_arch:
+                arg += "_" + msvc_target_arch
+
+            return [script_path, arg]
+
+        # We try to find the best version of the env setup batch.
+        vcvarsall = JoinPath(self.path, "VC", "vcvarsall.bat")
+        if target_arch == "x86":
+            if (
+                self.short_name >= "2013"
+                and self.short_name[-1] != "e"
+                and is_host_arch_x64
+            ):
+                # VS2013 and later, non-Express have a x64-x86 cross that we want
+                # to prefer.
+                return [vcvarsall, "amd64_x86"]
+            else:
+                # Otherwise, the standard x86 compiler. We don't use VC/vcvarsall.bat
+                # for x86 because vcvarsall calls vcvars32, which it can only find if
+                # VS??COMNTOOLS is set, which isn't guaranteed.
+                return [JoinPath(self.path, "Common7", "Tools", "vsvars32.bat")]
+        elif target_arch == "x64":
+            arg = "x86_amd64"
+            # Use the 64-on-64 compiler if we're not using an express edition and
+            # we're running on a 64bit OS.
+            if self.short_name[-1] != "e" and is_host_arch_x64:
+                arg = "amd64"
+            return [vcvarsall, arg]
+
+    def SetupScript(self, target_arch):
+        script_data = self._SetupScriptInternal(target_arch)
+        script_path = script_data[0]
+        if not os.path.exists(script_path):
+            raise Exception(
+                "%s is missing - make sure VC++ tools are installed." % script_path
+            )
+        return script_data
 
 
 def _RegistryQueryBase(sysdir, key, value):
-  """Use reg.exe to read a particular key.
+    """Use reg.exe to read a particular key.
 
   While ideally we might use the win32 module, we would like gyp to be
   python neutral, so for instance cygwin python lacks this module.
@@ -153,28 +166,27 @@ def _RegistryQueryBase(sysdir, key, value):
   Return:
     stdout from reg.exe, or None for failure.
   """
-  # Skip if not on Windows or Python Win32 setup issue
-  if sys.platform not in ('win32', 'cygwin'):
-    return None
-  # Setup params to pass to and attempt to launch reg.exe
-  cmd = [os.path.join(os.environ.get('WINDIR', ''), sysdir, 'reg.exe'),
-         'query', key]
-  if value:
-    cmd.extend(['/v', value])
-  p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-  # Obtain the stdout from reg.exe, reading to the end so p.returncode is valid
-  # Note that the error text may be in [1] in some cases
-  text = p.communicate()[0]
-  if PY3:
-    text = text.decode('utf-8')
-  # Check return code from reg.exe; officially 0==success and 1==error
-  if p.returncode:
-    return None
-  return text
+    # Skip if not on Windows or Python Win32 setup issue
+    if sys.platform not in ("win32", "cygwin"):
+        return None
+    # Setup params to pass to and attempt to launch reg.exe
+    cmd = [os.path.join(os.environ.get("WINDIR", ""), sysdir, "reg.exe"), "query", key]
+    if value:
+        cmd.extend(["/v", value])
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    # Obtain the stdout from reg.exe, reading to the end so p.returncode is valid
+    # Note that the error text may be in [1] in some cases
+    text = p.communicate()[0]
+    if PY3:
+        text = text.decode("utf-8")
+    # Check return code from reg.exe; officially 0==success and 1==error
+    if p.returncode:
+        return None
+    return text
 
 
 def _RegistryQuery(key, value=None):
-  r"""Use reg.exe to read a particular key through _RegistryQueryBase.
+    r"""Use reg.exe to read a particular key through _RegistryQueryBase.
 
   First tries to launch from %WinDir%\Sysnative to avoid WoW64 redirection. If
   that fails, it falls back to System32.  Sysnative is available on Vista and
@@ -190,19 +202,19 @@ def _RegistryQuery(key, value=None):
   Return:
     stdout from reg.exe, or None for failure.
   """
-  text = None
-  try:
-    text = _RegistryQueryBase('Sysnative', key, value)
-  except OSError as e:
-    if e.errno == errno.ENOENT:
-      text = _RegistryQueryBase('System32', key, value)
-    else:
-      raise
-  return text
+    text = None
+    try:
+        text = _RegistryQueryBase("Sysnative", key, value)
+    except OSError as e:
+        if e.errno == errno.ENOENT:
+            text = _RegistryQueryBase("System32", key, value)
+        else:
+            raise
+    return text
 
 
 def _RegistryGetValueUsingWinReg(key, value):
-  """Use the _winreg module to obtain the value of a registry key.
+    """Use the _winreg module to obtain the value of a registry key.
 
   Args:
     key: The registry key.
@@ -211,24 +223,24 @@ def _RegistryGetValueUsingWinReg(key, value):
     contents of the registry key's value, or None on failure.  Throws
     ImportError if _winreg is unavailable.
   """
-  try:
-    # Python 2
-    from _winreg import HKEY_LOCAL_MACHINE, OpenKey, QueryValueEx
-  except ImportError:
-    # Python 3
-    from winreg import HKEY_LOCAL_MACHINE, OpenKey, QueryValueEx
-
-  try:
-    root, subkey = key.split('\\', 1)
-    assert root == 'HKLM'  # Only need HKLM for now.
-    with OpenKey(HKEY_LOCAL_MACHINE, subkey) as hkey:
-      return QueryValueEx(hkey, value)[0]
-  except WindowsError:
-    return None
+    try:
+        # Python 2
+        from _winreg import HKEY_LOCAL_MACHINE, OpenKey, QueryValueEx
+    except ImportError:
+        # Python 3
+        from winreg import HKEY_LOCAL_MACHINE, OpenKey, QueryValueEx
+
+    try:
+        root, subkey = key.split("\\", 1)
+        assert root == "HKLM"  # Only need HKLM for now.
+        with OpenKey(HKEY_LOCAL_MACHINE, subkey) as hkey:
+            return QueryValueEx(hkey, value)[0]
+    except WindowsError:
+        return None
 
 
 def _RegistryGetValue(key, value):
-  """Use _winreg or reg.exe to obtain the value of a registry key.
+    """Use _winreg or reg.exe to obtain the value of a registry key.
 
   Using _winreg is preferable because it solves an issue on some corporate
   environments where access to reg.exe is locked down. However, we still need
@@ -241,161 +253,187 @@ def _RegistryGetValue(key, value):
   Return:
     contents of the registry key's value, or None on failure.
   """
-  try:
-    return _RegistryGetValueUsingWinReg(key, value)
-  except ImportError:
-    pass
-
-  # Fallback to reg.exe if we fail to import _winreg.
-  text = _RegistryQuery(key, value)
-  if not text:
-    return None
-  # Extract value.
-  match = re.search(r'REG_\w+\s+([^\r]+)\r\n', text)
-  if not match:
-    return None
-  return match.group(1)
+    try:
+        return _RegistryGetValueUsingWinReg(key, value)
+    except ImportError:
+        pass
+
+    # Fallback to reg.exe if we fail to import _winreg.
+    text = _RegistryQuery(key, value)
+    if not text:
+        return None
+    # Extract value.
+    match = re.search(r"REG_\w+\s+([^\r]+)\r\n", text)
+    if not match:
+        return None
+    return match.group(1)
 
 
 def _CreateVersion(name, path, sdk_based=False):
-  """Sets up MSVS project generation.
+    """Sets up MSVS project generation.
 
   Setup is based off the GYP_MSVS_VERSION environment variable or whatever is
   autodetected if GYP_MSVS_VERSION is not explicitly specified. If a version is
   passed in that doesn't match a value in versions python will throw a error.
   """
-  if path:
-    path = os.path.normpath(path)
-  versions = {
-      '2019': VisualStudioVersion('2019',
-                                  'Visual Studio 2019',
-                                  solution_version='12.00',
-                                  project_version='16.0',
-                                  flat_sln=False,
-                                  uses_vcxproj=True,
-                                  path=path,
-                                  sdk_based=sdk_based,
-                                  default_toolset='v142',
-                                  compatible_sdks=['v8.1', 'v10.0']),
-      '2017': VisualStudioVersion('2017',
-                                  'Visual Studio 2017',
-                                  solution_version='12.00',
-                                  project_version='15.0',
-                                  flat_sln=False,
-                                  uses_vcxproj=True,
-                                  path=path,
-                                  sdk_based=sdk_based,
-                                  default_toolset='v141',
-                                  compatible_sdks=['v8.1', 'v10.0']),
-      '2015': VisualStudioVersion('2015',
-                                  'Visual Studio 2015',
-                                  solution_version='12.00',
-                                  project_version='14.0',
-                                  flat_sln=False,
-                                  uses_vcxproj=True,
-                                  path=path,
-                                  sdk_based=sdk_based,
-                                  default_toolset='v140'),
-      '2013': VisualStudioVersion('2013',
-                                  'Visual Studio 2013',
-                                  solution_version='13.00',
-                                  project_version='12.0',
-                                  flat_sln=False,
-                                  uses_vcxproj=True,
-                                  path=path,
-                                  sdk_based=sdk_based,
-                                  default_toolset='v120'),
-      '2013e': VisualStudioVersion('2013e',
-                                   'Visual Studio 2013',
-                                   solution_version='13.00',
-                                   project_version='12.0',
-                                   flat_sln=True,
-                                   uses_vcxproj=True,
-                                   path=path,
-                                   sdk_based=sdk_based,
-                                   default_toolset='v120'),
-      '2012': VisualStudioVersion('2012',
-                                  'Visual Studio 2012',
-                                  solution_version='12.00',
-                                  project_version='4.0',
-                                  flat_sln=False,
-                                  uses_vcxproj=True,
-                                  path=path,
-                                  sdk_based=sdk_based,
-                                  default_toolset='v110'),
-      '2012e': VisualStudioVersion('2012e',
-                                   'Visual Studio 2012',
-                                   solution_version='12.00',
-                                   project_version='4.0',
-                                   flat_sln=True,
-                                   uses_vcxproj=True,
-                                   path=path,
-                                   sdk_based=sdk_based,
-                                   default_toolset='v110'),
-      '2010': VisualStudioVersion('2010',
-                                  'Visual Studio 2010',
-                                  solution_version='11.00',
-                                  project_version='4.0',
-                                  flat_sln=False,
-                                  uses_vcxproj=True,
-                                  path=path,
-                                  sdk_based=sdk_based),
-      '2010e': VisualStudioVersion('2010e',
-                                   'Visual C++ Express 2010',
-                                   solution_version='11.00',
-                                   project_version='4.0',
-                                   flat_sln=True,
-                                   uses_vcxproj=True,
-                                   path=path,
-                                   sdk_based=sdk_based),
-      '2008': VisualStudioVersion('2008',
-                                  'Visual Studio 2008',
-                                  solution_version='10.00',
-                                  project_version='9.00',
-                                  flat_sln=False,
-                                  uses_vcxproj=False,
-                                  path=path,
-                                  sdk_based=sdk_based),
-      '2008e': VisualStudioVersion('2008e',
-                                   'Visual Studio 2008',
-                                   solution_version='10.00',
-                                   project_version='9.00',
-                                   flat_sln=True,
-                                   uses_vcxproj=False,
-                                   path=path,
-                                   sdk_based=sdk_based),
-      '2005': VisualStudioVersion('2005',
-                                  'Visual Studio 2005',
-                                  solution_version='9.00',
-                                  project_version='8.00',
-                                  flat_sln=False,
-                                  uses_vcxproj=False,
-                                  path=path,
-                                  sdk_based=sdk_based),
-      '2005e': VisualStudioVersion('2005e',
-                                   'Visual Studio 2005',
-                                   solution_version='9.00',
-                                   project_version='8.00',
-                                   flat_sln=True,
-                                   uses_vcxproj=False,
-                                   path=path,
-                                   sdk_based=sdk_based),
-  }
-  return versions[str(name)]
+    if path:
+        path = os.path.normpath(path)
+    versions = {
+        "2019": VisualStudioVersion(
+            "2019",
+            "Visual Studio 2019",
+            solution_version="12.00",
+            project_version="16.0",
+            flat_sln=False,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+            default_toolset="v142",
+            compatible_sdks=["v8.1", "v10.0"],
+        ),
+        "2017": VisualStudioVersion(
+            "2017",
+            "Visual Studio 2017",
+            solution_version="12.00",
+            project_version="15.0",
+            flat_sln=False,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+            default_toolset="v141",
+            compatible_sdks=["v8.1", "v10.0"],
+        ),
+        "2015": VisualStudioVersion(
+            "2015",
+            "Visual Studio 2015",
+            solution_version="12.00",
+            project_version="14.0",
+            flat_sln=False,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+            default_toolset="v140",
+        ),
+        "2013": VisualStudioVersion(
+            "2013",
+            "Visual Studio 2013",
+            solution_version="13.00",
+            project_version="12.0",
+            flat_sln=False,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+            default_toolset="v120",
+        ),
+        "2013e": VisualStudioVersion(
+            "2013e",
+            "Visual Studio 2013",
+            solution_version="13.00",
+            project_version="12.0",
+            flat_sln=True,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+            default_toolset="v120",
+        ),
+        "2012": VisualStudioVersion(
+            "2012",
+            "Visual Studio 2012",
+            solution_version="12.00",
+            project_version="4.0",
+            flat_sln=False,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+            default_toolset="v110",
+        ),
+        "2012e": VisualStudioVersion(
+            "2012e",
+            "Visual Studio 2012",
+            solution_version="12.00",
+            project_version="4.0",
+            flat_sln=True,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+            default_toolset="v110",
+        ),
+        "2010": VisualStudioVersion(
+            "2010",
+            "Visual Studio 2010",
+            solution_version="11.00",
+            project_version="4.0",
+            flat_sln=False,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+        ),
+        "2010e": VisualStudioVersion(
+            "2010e",
+            "Visual C++ Express 2010",
+            solution_version="11.00",
+            project_version="4.0",
+            flat_sln=True,
+            uses_vcxproj=True,
+            path=path,
+            sdk_based=sdk_based,
+        ),
+        "2008": VisualStudioVersion(
+            "2008",
+            "Visual Studio 2008",
+            solution_version="10.00",
+            project_version="9.00",
+            flat_sln=False,
+            uses_vcxproj=False,
+            path=path,
+            sdk_based=sdk_based,
+        ),
+        "2008e": VisualStudioVersion(
+            "2008e",
+            "Visual Studio 2008",
+            solution_version="10.00",
+            project_version="9.00",
+            flat_sln=True,
+            uses_vcxproj=False,
+            path=path,
+            sdk_based=sdk_based,
+        ),
+        "2005": VisualStudioVersion(
+            "2005",
+            "Visual Studio 2005",
+            solution_version="9.00",
+            project_version="8.00",
+            flat_sln=False,
+            uses_vcxproj=False,
+            path=path,
+            sdk_based=sdk_based,
+        ),
+        "2005e": VisualStudioVersion(
+            "2005e",
+            "Visual Studio 2005",
+            solution_version="9.00",
+            project_version="8.00",
+            flat_sln=True,
+            uses_vcxproj=False,
+            path=path,
+            sdk_based=sdk_based,
+        ),
+    }
+    return versions[str(name)]
 
 
 def _ConvertToCygpath(path):
-  """Convert to cygwin path if we are using cygwin."""
-  if sys.platform == 'cygwin':
-    p = subprocess.Popen(['cygpath', path], stdout=subprocess.PIPE)
-    path = p.communicate()[0].strip()
-    if PY3:
-      path = path.decode('utf-8')
-  return path
+    """Convert to cygwin path if we are using cygwin."""
+    if sys.platform == "cygwin":
+        p = subprocess.Popen(["cygpath", path], stdout=subprocess.PIPE)
+        path = p.communicate()[0].strip()
+        if PY3:
+            path = path.decode("utf-8")
+    return path
 
 
 def _DetectVisualStudioVersions(versions_to_check, force_express):
-  """Collect the list of installed visual studio versions.
+    """Collect the list of installed visual studio versions.
 
   Returns:
     A list of visual studio versions installed in descending order of
@@ -412,105 +450,122 @@ def _DetectVisualStudioVersions(versions_to_check, force_express):
       2019    - Visual Studio 2019 (16)
     Where (e) is e for express editions of MSVS and blank otherwise.
   """
-  version_to_year = {
-      '8.0': '2005',
-      '9.0': '2008',
-      '10.0': '2010',
-      '11.0': '2012',
-      '12.0': '2013',
-      '14.0': '2015',
-      '15.0': '2017',
-      '16.0': '2019',
-  }
-  versions = []
-  for version in versions_to_check:
-    # Old method of searching for which VS version is installed
-    # We don't use the 2010-encouraged-way because we also want to get the
-    # path to the binaries, which it doesn't offer.
-    keys = [r'HKLM\Software\Microsoft\VisualStudio\%s' % version,
-            r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\%s' % version,
-            r'HKLM\Software\Microsoft\VCExpress\%s' % version,
-            r'HKLM\Software\Wow6432Node\Microsoft\VCExpress\%s' % version]
-    for index in range(len(keys)):
-      path = _RegistryGetValue(keys[index], 'InstallDir')
-      if not path:
-        continue
-      path = _ConvertToCygpath(path)
-      # Check for full.
-      full_path = os.path.join(path, 'devenv.exe')
-      express_path = os.path.join(path, '*express.exe')
-      if not force_express and os.path.exists(full_path):
-        # Add this one.
-        versions.append(_CreateVersion(version_to_year[version],
-            os.path.join(path, '..', '..')))
-      # Check for express.
-      elif glob.glob(express_path):
-        # Add this one.
-        versions.append(_CreateVersion(version_to_year[version] + 'e',
-            os.path.join(path, '..', '..')))
-
-    # The old method above does not work when only SDK is installed.
-    keys = [r'HKLM\Software\Microsoft\VisualStudio\SxS\VC7',
-            r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\SxS\VC7',
-            r'HKLM\Software\Microsoft\VisualStudio\SxS\VS7',
-            r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\SxS\VS7']
-    for index in range(len(keys)):
-      path = _RegistryGetValue(keys[index], version)
-      if not path:
-        continue
-      path = _ConvertToCygpath(path)
-      if version == '15.0':
-          if os.path.exists(path):
-              versions.append(_CreateVersion('2017', path))
-      elif version != '14.0':  # There is no Express edition for 2015.
-        versions.append(_CreateVersion(version_to_year[version] + 'e',
-            os.path.join(path, '..'), sdk_based=True))
-
-  return versions
-
-
-def SelectVisualStudioVersion(version='auto', allow_fallback=True):
-  """Select which version of Visual Studio projects to generate.
+    version_to_year = {
+        "8.0": "2005",
+        "9.0": "2008",
+        "10.0": "2010",
+        "11.0": "2012",
+        "12.0": "2013",
+        "14.0": "2015",
+        "15.0": "2017",
+        "16.0": "2019",
+    }
+    versions = []
+    for version in versions_to_check:
+        # Old method of searching for which VS version is installed
+        # We don't use the 2010-encouraged-way because we also want to get the
+        # path to the binaries, which it doesn't offer.
+        keys = [
+            r"HKLM\Software\Microsoft\VisualStudio\%s" % version,
+            r"HKLM\Software\Wow6432Node\Microsoft\VisualStudio\%s" % version,
+            r"HKLM\Software\Microsoft\VCExpress\%s" % version,
+            r"HKLM\Software\Wow6432Node\Microsoft\VCExpress\%s" % version,
+        ]
+        for index in range(len(keys)):
+            path = _RegistryGetValue(keys[index], "InstallDir")
+            if not path:
+                continue
+            path = _ConvertToCygpath(path)
+            # Check for full.
+            full_path = os.path.join(path, "devenv.exe")
+            express_path = os.path.join(path, "*express.exe")
+            if not force_express and os.path.exists(full_path):
+                # Add this one.
+                versions.append(
+                    _CreateVersion(
+                        version_to_year[version], os.path.join(path, "..", "..")
+                    )
+                )
+            # Check for express.
+            elif glob.glob(express_path):
+                # Add this one.
+                versions.append(
+                    _CreateVersion(
+                        version_to_year[version] + "e", os.path.join(path, "..", "..")
+                    )
+                )
+
+        # The old method above does not work when only SDK is installed.
+        keys = [
+            r"HKLM\Software\Microsoft\VisualStudio\SxS\VC7",
+            r"HKLM\Software\Wow6432Node\Microsoft\VisualStudio\SxS\VC7",
+            r"HKLM\Software\Microsoft\VisualStudio\SxS\VS7",
+            r"HKLM\Software\Wow6432Node\Microsoft\VisualStudio\SxS\VS7",
+        ]
+        for index in range(len(keys)):
+            path = _RegistryGetValue(keys[index], version)
+            if not path:
+                continue
+            path = _ConvertToCygpath(path)
+            if version == "15.0":
+                if os.path.exists(path):
+                    versions.append(_CreateVersion("2017", path))
+            elif version != "14.0":  # There is no Express edition for 2015.
+                versions.append(
+                    _CreateVersion(
+                        version_to_year[version] + "e",
+                        os.path.join(path, ".."),
+                        sdk_based=True,
+                    )
+                )
+
+    return versions
+
+
+def SelectVisualStudioVersion(version="auto", allow_fallback=True):
+    """Select which version of Visual Studio projects to generate.
 
   Arguments:
     version: Hook to allow caller to force a particular version (vs auto).
   Returns:
     An object representing a visual studio project format version.
   """
-  # In auto mode, check environment variable for override.
-  if version == 'auto':
-    version = os.environ.get('GYP_MSVS_VERSION', 'auto')
-  version_map = {
-    'auto': ('16.0', '15.0', '14.0', '12.0', '10.0', '9.0', '8.0', '11.0'),
-    '2005': ('8.0',),
-    '2005e': ('8.0',),
-    '2008': ('9.0',),
-    '2008e': ('9.0',),
-    '2010': ('10.0',),
-    '2010e': ('10.0',),
-    '2012': ('11.0',),
-    '2012e': ('11.0',),
-    '2013': ('12.0',),
-    '2013e': ('12.0',),
-    '2015': ('14.0',),
-    '2017': ('15.0',),
-    '2019': ('16.0',),
-  }
-  override_path = os.environ.get('GYP_MSVS_OVERRIDE_PATH')
-  if override_path:
-    msvs_version = os.environ.get('GYP_MSVS_VERSION')
-    if not msvs_version:
-      raise ValueError('GYP_MSVS_OVERRIDE_PATH requires GYP_MSVS_VERSION to be '
-                       'set to a particular version (e.g. 2010e).')
-    return _CreateVersion(msvs_version, override_path, sdk_based=True)
-  version = str(version)
-  versions = _DetectVisualStudioVersions(version_map[version], 'e' in version)
-  if not versions:
-    if not allow_fallback:
-      raise ValueError('Could not locate Visual Studio installation.')
-    if version == 'auto':
-      # Default to 2005 if we couldn't find anything
-      return _CreateVersion('2005', None)
-    else:
-      return _CreateVersion(version, None)
-  return versions[0]
+    # In auto mode, check environment variable for override.
+    if version == "auto":
+        version = os.environ.get("GYP_MSVS_VERSION", "auto")
+    version_map = {
+        "auto": ("16.0", "15.0", "14.0", "12.0", "10.0", "9.0", "8.0", "11.0"),
+        "2005": ("8.0",),
+        "2005e": ("8.0",),
+        "2008": ("9.0",),
+        "2008e": ("9.0",),
+        "2010": ("10.0",),
+        "2010e": ("10.0",),
+        "2012": ("11.0",),
+        "2012e": ("11.0",),
+        "2013": ("12.0",),
+        "2013e": ("12.0",),
+        "2015": ("14.0",),
+        "2017": ("15.0",),
+        "2019": ("16.0",),
+    }
+    override_path = os.environ.get("GYP_MSVS_OVERRIDE_PATH")
+    if override_path:
+        msvs_version = os.environ.get("GYP_MSVS_VERSION")
+        if not msvs_version:
+            raise ValueError(
+                "GYP_MSVS_OVERRIDE_PATH requires GYP_MSVS_VERSION to be "
+                "set to a particular version (e.g. 2010e)."
+            )
+        return _CreateVersion(msvs_version, override_path, sdk_based=True)
+    version = str(version)
+    versions = _DetectVisualStudioVersions(version_map[version], "e" in version)
+    if not versions:
+        if not allow_fallback:
+            raise ValueError("Could not locate Visual Studio installation.")
+        if version == "auto":
+            # Default to 2005 if we couldn't find anything
+            return _CreateVersion("2005", None)
+        else:
+            return _CreateVersion(version, None)
+    return versions[0]
diff --git a/tools/gyp/pylib/gyp/__init__.py b/tools/gyp/pylib/gyp/__init__.py
index dee834013f4144075ad63bd23214559b53c082ee..f6ea625d40a3c78cb8676c3076d9b9e0a794b9cf 100755
--- a/tools/gyp/pylib/gyp/__init__.py
+++ b/tools/gyp/pylib/gyp/__init__.py
@@ -27,153 +27,178 @@ except NameError:
 debug = {}
 
 # List of "official" debug modes, but you can use anything you like.
-DEBUG_GENERAL = 'general'
-DEBUG_VARIABLES = 'variables'
-DEBUG_INCLUDES = 'includes'
+DEBUG_GENERAL = "general"
+DEBUG_VARIABLES = "variables"
+DEBUG_INCLUDES = "includes"
 
 
 def DebugOutput(mode, message, *args):
-  if 'all' in gyp.debug or mode in gyp.debug:
-    ctx = ('unknown', 0, 'unknown')
-    try:
-      f = traceback.extract_stack(limit=2)
-      if f:
-        ctx = f[0][:3]
-    except:
-      pass
-    if args:
-      message %= args
-    print('%s:%s:%d:%s %s' % (mode.upper(), os.path.basename(ctx[0]),
-                              ctx[1], ctx[2], message))
+    if "all" in gyp.debug or mode in gyp.debug:
+        ctx = ("unknown", 0, "unknown")
+        try:
+            f = traceback.extract_stack(limit=2)
+            if f:
+                ctx = f[0][:3]
+        except Exception:
+            pass
+        if args:
+            message %= args
+        print(
+            "%s:%s:%d:%s %s"
+            % (mode.upper(), os.path.basename(ctx[0]), ctx[1], ctx[2], message)
+        )
+
 
 def FindBuildFiles():
-  extension = '.gyp'
-  files = os.listdir(os.getcwd())
-  build_files = []
-  for file in files:
-    if file.endswith(extension):
-      build_files.append(file)
-  return build_files
-
-
-def Load(build_files, format, default_variables={},
-         includes=[], depth='.', params=None, check=False,
-         circular_check=True, duplicate_basename_check=True):
-  """
+    extension = ".gyp"
+    files = os.listdir(os.getcwd())
+    build_files = []
+    for file in files:
+        if file.endswith(extension):
+            build_files.append(file)
+    return build_files
+
+
+def Load(
+    build_files,
+    format,
+    default_variables={},
+    includes=[],
+    depth=".",
+    params=None,
+    check=False,
+    circular_check=True,
+):
+    """
   Loads one or more specified build files.
   default_variables and includes will be copied before use.
   Returns the generator for the specified format and the
   data returned by loading the specified build files.
   """
-  if params is None:
-    params = {}
-
-  if '-' in format:
-    format, params['flavor'] = format.split('-', 1)
-
-  default_variables = copy.copy(default_variables)
-
-  # Default variables provided by this program and its modules should be
-  # named WITH_CAPITAL_LETTERS to provide a distinct "best practice" namespace,
-  # avoiding collisions with user and automatic variables.
-  default_variables['GENERATOR'] = format
-  default_variables['GENERATOR_FLAVOR'] = params.get('flavor', '')
-
-  # Format can be a custom python file, or by default the name of a module
-  # within gyp.generator.
-  if format.endswith('.py'):
-    generator_name = os.path.splitext(format)[0]
-    path, generator_name = os.path.split(generator_name)
-
-    # Make sure the path to the custom generator is in sys.path
-    # Don't worry about removing it once we are done.  Keeping the path
-    # to each generator that is used in sys.path is likely harmless and
-    # arguably a good idea.
-    path = os.path.abspath(path)
-    if path not in sys.path:
-      sys.path.insert(0, path)
-  else:
-    generator_name = 'gyp.generator.' + format
-
-  # These parameters are passed in order (as opposed to by key)
-  # because ActivePython cannot handle key parameters to __import__.
-  generator = __import__(generator_name, globals(), locals(), generator_name)
-  for (key, val) in generator.generator_default_variables.items():
-    default_variables.setdefault(key, val)
-
-  # Give the generator the opportunity to set additional variables based on
-  # the params it will receive in the output phase.
-  if getattr(generator, 'CalculateVariables', None):
-    generator.CalculateVariables(default_variables, params)
-
-  # Give the generator the opportunity to set generator_input_info based on
-  # the params it will receive in the output phase.
-  if getattr(generator, 'CalculateGeneratorInputInfo', None):
-    generator.CalculateGeneratorInputInfo(params)
-
-  # Fetch the generator specific info that gets fed to input, we use getattr
-  # so we can default things and the generators only have to provide what
-  # they need.
-  generator_input_info = {
-    'non_configuration_keys':
-        getattr(generator, 'generator_additional_non_configuration_keys', []),
-    'path_sections':
-        getattr(generator, 'generator_additional_path_sections', []),
-    'extra_sources_for_rules':
-        getattr(generator, 'generator_extra_sources_for_rules', []),
-    'generator_supports_multiple_toolsets':
-        getattr(generator, 'generator_supports_multiple_toolsets', False),
-    'generator_wants_static_library_dependencies_adjusted':
-        getattr(generator,
-                'generator_wants_static_library_dependencies_adjusted', True),
-    'generator_wants_sorted_dependencies':
-        getattr(generator, 'generator_wants_sorted_dependencies', False),
-    'generator_filelist_paths':
-        getattr(generator, 'generator_filelist_paths', None),
-  }
-
-  # Process the input specific to this generator.
-  result = gyp.input.Load(build_files, default_variables, includes[:],
-                          depth, generator_input_info, check, circular_check,
-                          duplicate_basename_check,
-                          params['parallel'], params['root_targets'])
-  return [generator] + result
+    if params is None:
+        params = {}
+
+    if "-" in format:
+        format, params["flavor"] = format.split("-", 1)
+
+    default_variables = copy.copy(default_variables)
+
+    # Default variables provided by this program and its modules should be
+    # named WITH_CAPITAL_LETTERS to provide a distinct "best practice" namespace,
+    # avoiding collisions with user and automatic variables.
+    default_variables["GENERATOR"] = format
+    default_variables["GENERATOR_FLAVOR"] = params.get("flavor", "")
+
+    # Format can be a custom python file, or by default the name of a module
+    # within gyp.generator.
+    if format.endswith(".py"):
+        generator_name = os.path.splitext(format)[0]
+        path, generator_name = os.path.split(generator_name)
+
+        # Make sure the path to the custom generator is in sys.path
+        # Don't worry about removing it once we are done.  Keeping the path
+        # to each generator that is used in sys.path is likely harmless and
+        # arguably a good idea.
+        path = os.path.abspath(path)
+        if path not in sys.path:
+            sys.path.insert(0, path)
+    else:
+        generator_name = "gyp.generator." + format
+
+    # These parameters are passed in order (as opposed to by key)
+    # because ActivePython cannot handle key parameters to __import__.
+    generator = __import__(generator_name, globals(), locals(), generator_name)
+    for (key, val) in generator.generator_default_variables.items():
+        default_variables.setdefault(key, val)
+
+    # Give the generator the opportunity to set additional variables based on
+    # the params it will receive in the output phase.
+    if getattr(generator, "CalculateVariables", None):
+        generator.CalculateVariables(default_variables, params)
+
+    # Give the generator the opportunity to set generator_input_info based on
+    # the params it will receive in the output phase.
+    if getattr(generator, "CalculateGeneratorInputInfo", None):
+        generator.CalculateGeneratorInputInfo(params)
+
+    # Fetch the generator specific info that gets fed to input, we use getattr
+    # so we can default things and the generators only have to provide what
+    # they need.
+    generator_input_info = {
+        "non_configuration_keys": getattr(
+            generator, "generator_additional_non_configuration_keys", []
+        ),
+        "path_sections": getattr(generator, "generator_additional_path_sections", []),
+        "extra_sources_for_rules": getattr(
+            generator, "generator_extra_sources_for_rules", []
+        ),
+        "generator_supports_multiple_toolsets": getattr(
+            generator, "generator_supports_multiple_toolsets", False
+        ),
+        "generator_wants_static_library_dependencies_adjusted": getattr(
+            generator, "generator_wants_static_library_dependencies_adjusted", True
+        ),
+        "generator_wants_sorted_dependencies": getattr(
+            generator, "generator_wants_sorted_dependencies", False
+        ),
+        "generator_filelist_paths": getattr(
+            generator, "generator_filelist_paths", None
+        ),
+    }
+
+    # Process the input specific to this generator.
+    result = gyp.input.Load(
+        build_files,
+        default_variables,
+        includes[:],
+        depth,
+        generator_input_info,
+        check,
+        circular_check,
+        params["parallel"],
+        params["root_targets"],
+    )
+    return [generator] + result
+
 
 def NameValueListToDict(name_value_list):
-  """
+    """
   Takes an array of strings of the form 'NAME=VALUE' and creates a dictionary
   of the pairs.  If a string is simply NAME, then the value in the dictionary
   is set to True.  If VALUE can be converted to an integer, it is.
   """
-  result = { }
-  for item in name_value_list:
-    tokens = item.split('=', 1)
-    if len(tokens) == 2:
-      # If we can make it an int, use that, otherwise, use the string.
-      try:
-        token_value = int(tokens[1])
-      except ValueError:
-        token_value = tokens[1]
-      # Set the variable to the supplied value.
-      result[tokens[0]] = token_value
-    else:
-      # No value supplied, treat it as a boolean and set it.
-      result[tokens[0]] = True
-  return result
+    result = {}
+    for item in name_value_list:
+        tokens = item.split("=", 1)
+        if len(tokens) == 2:
+            # If we can make it an int, use that, otherwise, use the string.
+            try:
+                token_value = int(tokens[1])
+            except ValueError:
+                token_value = tokens[1]
+            # Set the variable to the supplied value.
+            result[tokens[0]] = token_value
+        else:
+            # No value supplied, treat it as a boolean and set it.
+            result[tokens[0]] = True
+    return result
+
 
 def ShlexEnv(env_name):
-  flags = os.environ.get(env_name, [])
-  if flags:
-    flags = shlex.split(flags)
-  return flags
+    flags = os.environ.get(env_name, [])
+    if flags:
+        flags = shlex.split(flags)
+    return flags
+
 
 def FormatOpt(opt, value):
-  if opt.startswith('--'):
-    return '%s=%s' % (opt, value)
-  return opt + value
+    if opt.startswith("--"):
+        return "%s=%s" % (opt, value)
+    return opt + value
+
 
 def RegenerateAppendFlag(flag, values, predicate, env_name, options):
-  """Regenerate a list of command line flags, for an option of action='append'.
+    """Regenerate a list of command line flags, for an option of action='append'.
 
   The |env_name|, if given, is checked in the environment and used to generate
   an initial list of options, then the options that were specified on the
@@ -182,20 +207,21 @@ def RegenerateAppendFlag(flag, values, predicate, env_name, options):
   the environment, while not requiring the environment to be set when the flags
   are used again.
   """
-  flags = []
-  if options.use_environment and env_name:
-    for flag_value in ShlexEnv(env_name):
-      value = FormatOpt(flag, predicate(flag_value))
-      if value in flags:
-        flags.remove(value)
-      flags.append(value)
-  if values:
-    for flag_value in values:
-      flags.append(FormatOpt(flag, predicate(flag_value)))
-  return flags
+    flags = []
+    if options.use_environment and env_name:
+        for flag_value in ShlexEnv(env_name):
+            value = FormatOpt(flag, predicate(flag_value))
+            if value in flags:
+                flags.remove(value)
+            flags.append(value)
+    if values:
+        for flag_value in values:
+            flags.append(FormatOpt(flag, predicate(flag_value)))
+    return flags
+
 
 def RegenerateFlags(options):
-  """Given a parsed options object, and taking the environment variables into
+    """Given a parsed options object, and taking the environment variables into
   account, returns a list of flags that should regenerate an equivalent options
   object (even in the absence of the environment variables.)
 
@@ -204,53 +230,62 @@ def RegenerateFlags(options):
   The format flag is not included, as it is assumed the calling generator will
   set that as appropriate.
   """
-  def FixPath(path):
-    path = gyp.common.FixIfRelativePath(path, options.depth)
-    if not path:
-      return os.path.curdir
-    return path
-
-  def Noop(value):
-    return value
-
-  # We always want to ignore the environment when regenerating, to avoid
-  # duplicate or changed flags in the environment at the time of regeneration.
-  flags = ['--ignore-environment']
-  for name, metadata in options._regeneration_metadata.items():
-    opt = metadata['opt']
-    value = getattr(options, name)
-    value_predicate = metadata['type'] == 'path' and FixPath or Noop
-    action = metadata['action']
-    env_name = metadata['env_name']
-    if action == 'append':
-      flags.extend(RegenerateAppendFlag(opt, value, value_predicate,
-                                        env_name, options))
-    elif action in ('store', None):  # None is a synonym for 'store'.
-      if value:
-        flags.append(FormatOpt(opt, value_predicate(value)))
-      elif options.use_environment and env_name and os.environ.get(env_name):
-        flags.append(FormatOpt(opt, value_predicate(os.environ.get(env_name))))
-    elif action in ('store_true', 'store_false'):
-      if ((action == 'store_true' and value) or
-          (action == 'store_false' and not value)):
-        flags.append(opt)
-      elif options.use_environment and env_name:
-        print('Warning: environment regeneration unimplemented '
-                             'for %s flag %r env_name %r' % (action, opt,
-                                                             env_name), file=sys.stderr)
-    else:
-      print('Warning: regeneration unimplemented for action %r '
-                           'flag %r' % (action, opt), file=sys.stderr)
 
-  return flags
+    def FixPath(path):
+        path = gyp.common.FixIfRelativePath(path, options.depth)
+        if not path:
+            return os.path.curdir
+        return path
+
+    def Noop(value):
+        return value
+
+    # We always want to ignore the environment when regenerating, to avoid
+    # duplicate or changed flags in the environment at the time of regeneration.
+    flags = ["--ignore-environment"]
+    for name, metadata in options._regeneration_metadata.items():
+        opt = metadata["opt"]
+        value = getattr(options, name)
+        value_predicate = metadata["type"] == "path" and FixPath or Noop
+        action = metadata["action"]
+        env_name = metadata["env_name"]
+        if action == "append":
+            flags.extend(
+                RegenerateAppendFlag(opt, value, value_predicate, env_name, options)
+            )
+        elif action in ("store", None):  # None is a synonym for 'store'.
+            if value:
+                flags.append(FormatOpt(opt, value_predicate(value)))
+            elif options.use_environment and env_name and os.environ.get(env_name):
+                flags.append(FormatOpt(opt, value_predicate(os.environ.get(env_name))))
+        elif action in ("store_true", "store_false"):
+            if (action == "store_true" and value) or (
+                action == "store_false" and not value
+            ):
+                flags.append(opt)
+            elif options.use_environment and env_name:
+                print(
+                    "Warning: environment regeneration unimplemented "
+                    "for %s flag %r env_name %r" % (action, opt, env_name),
+                    file=sys.stderr,
+                )
+        else:
+            print(
+                "Warning: regeneration unimplemented for action %r "
+                "flag %r" % (action, opt),
+                file=sys.stderr,
+            )
+
+    return flags
+
 
 class RegeneratableOptionParser(argparse.ArgumentParser):
-  def __init__(self, usage):
-    self.__regeneratable_options = {}
-    argparse.ArgumentParser.__init__(self, usage=usage)
+    def __init__(self, usage):
+        self.__regeneratable_options = {}
+        argparse.ArgumentParser.__init__(self, usage=usage)
 
-  def add_argument(self, *args, **kw):
-    """Add an option to the parser.
+    def add_argument(self, *args, **kw):
+        """Add an option to the parser.
 
     This accepts the same arguments as ArgumentParser.add_argument, plus the
     following:
@@ -261,297 +296,379 @@ class RegeneratableOptionParser(argparse.ArgumentParser):
       type: adds type='path', to tell the regenerator that the values of
             this option need to be made relative to options.depth
     """
-    env_name = kw.pop('env_name', None)
-    if 'dest' in kw and kw.pop('regenerate', True):
-      dest = kw['dest']
-
-      # The path type is needed for regenerating, for optparse we can just treat
-      # it as a string.
-      type = kw.get('type')
-      if type == 'path':
-        kw['type'] = str
-
-      self.__regeneratable_options[dest] = {
-          'action': kw.get('action'),
-          'type': type,
-          'env_name': env_name,
-          'opt': args[0],
-        }
+        env_name = kw.pop("env_name", None)
+        if "dest" in kw and kw.pop("regenerate", True):
+            dest = kw["dest"]
+
+            # The path type is needed for regenerating, for optparse we can just treat
+            # it as a string.
+            type = kw.get("type")
+            if type == "path":
+                kw["type"] = str
+
+            self.__regeneratable_options[dest] = {
+                "action": kw.get("action"),
+                "type": type,
+                "env_name": env_name,
+                "opt": args[0],
+            }
 
-    argparse.ArgumentParser.add_argument(self, *args, **kw)
+        argparse.ArgumentParser.add_argument(self, *args, **kw)
+
+    def parse_args(self, *args):
+        values, args = argparse.ArgumentParser.parse_known_args(self, *args)
+        values._regeneration_metadata = self.__regeneratable_options
+        return values, args
 
-  def parse_args(self, *args):
-    values, args = argparse.ArgumentParser.parse_known_args(self, *args)
-    values._regeneration_metadata = self.__regeneratable_options
-    return values, args
 
 def gyp_main(args):
-  my_name = os.path.basename(sys.argv[0])
-  usage = 'usage: %(prog)s [options ...] [build_file ...]'
-
-
-  parser = RegeneratableOptionParser(usage=usage.replace('%s', '%(prog)s'))
-  parser.add_argument('--build', dest='configs', action='append',
-                    help='configuration for build after project generation')
-  parser.add_argument('--check', dest='check', action='store_true',
-                    help='check format of gyp files')
-  parser.add_argument('--config-dir', dest='config_dir', action='store',
-                    env_name='GYP_CONFIG_DIR', default=None,
-                    help='The location for configuration files like '
-                    'include.gypi.')
-  parser.add_argument('-d', '--debug', dest='debug', metavar='DEBUGMODE',
-                    action='append', default=[], help='turn on a debugging '
-                    'mode for debugging GYP.  Supported modes are "variables", '
-                    '"includes" and "general" or "all" for all of them.')
-  parser.add_argument('-D', dest='defines', action='append', metavar='VAR=VAL',
-                    env_name='GYP_DEFINES',
-                    help='sets variable VAR to value VAL')
-  parser.add_argument('--depth', dest='depth', metavar='PATH', type='path',
-                    help='set DEPTH gyp variable to a relative path to PATH')
-  parser.add_argument('-f', '--format', dest='formats', action='append',
-                    env_name='GYP_GENERATORS', regenerate=False,
-                    help='output formats to generate')
-  parser.add_argument('-G', dest='generator_flags', action='append', default=[],
-                    metavar='FLAG=VAL', env_name='GYP_GENERATOR_FLAGS',
-                    help='sets generator flag FLAG to VAL')
-  parser.add_argument('--generator-output', dest='generator_output',
-                    action='store', default=None, metavar='DIR', type='path',
-                    env_name='GYP_GENERATOR_OUTPUT',
-                    help='puts generated build files under DIR')
-  parser.add_argument('--ignore-environment', dest='use_environment',
-                    action='store_false', default=True, regenerate=False,
-                    help='do not read options from environment variables')
-  parser.add_argument('-I', '--include', dest='includes', action='append',
-                    metavar='INCLUDE', type='path',
-                    help='files to include in all loaded .gyp files')
-  # --no-circular-check disables the check for circular relationships between
-  # .gyp files.  These relationships should not exist, but they've only been
-  # observed to be harmful with the Xcode generator.  Chromium's .gyp files
-  # currently have some circular relationships on non-Mac platforms, so this
-  # option allows the strict behavior to be used on Macs and the lenient
-  # behavior to be used elsewhere.
-  # TODO(mark): Remove this option when http://crbug.com/35878 is fixed.
-  parser.add_argument('--no-circular-check', dest='circular_check',
-                    action='store_false', default=True, regenerate=False,
-                    help="don't check for circular relationships between files")
-  # --no-duplicate-basename-check disables the check for duplicate basenames
-  # in a static_library/shared_library project. Visual C++ 2008 generator
-  # doesn't support this configuration. Libtool on Mac also generates warnings
-  # when duplicate basenames are passed into Make generator on Mac.
-  # TODO(yukawa): Remove this option when these legacy generators are
-  # deprecated.
-  parser.add_argument('--no-duplicate-basename-check',
-                    dest='duplicate_basename_check', action='store_false',
-                    default=True, regenerate=False,
-                    help="don't check for duplicate basenames")
-  parser.add_argument('--no-parallel', action='store_true', default=False,
-                    help='Disable multiprocessing')
-  parser.add_argument('-S', '--suffix', dest='suffix', default='',
-                    help='suffix to add to generated files')
-  parser.add_argument('--toplevel-dir', dest='toplevel_dir', action='store',
-                    default=None, metavar='DIR', type='path',
-                    help='directory to use as the root of the source tree')
-  parser.add_argument('-R', '--root-target', dest='root_targets',
-                    action='append', metavar='TARGET',
-                    help='include only TARGET and its deep dependencies')
-
-  options, build_files_arg = parser.parse_args(args)
-  build_files = build_files_arg
-
-  # Set up the configuration directory (defaults to ~/.gyp)
-  if not options.config_dir:
-    home = None
-    home_dot_gyp = None
+    my_name = os.path.basename(sys.argv[0])
+    usage = "usage: %(prog)s [options ...] [build_file ...]"
+
+    parser = RegeneratableOptionParser(usage=usage.replace("%s", "%(prog)s"))
+    parser.add_argument(
+        "--build",
+        dest="configs",
+        action="append",
+        help="configuration for build after project generation",
+    )
+    parser.add_argument(
+        "--check", dest="check", action="store_true", help="check format of gyp files"
+    )
+    parser.add_argument(
+        "--config-dir",
+        dest="config_dir",
+        action="store",
+        env_name="GYP_CONFIG_DIR",
+        default=None,
+        help="The location for configuration files like " "include.gypi.",
+    )
+    parser.add_argument(
+        "-d",
+        "--debug",
+        dest="debug",
+        metavar="DEBUGMODE",
+        action="append",
+        default=[],
+        help="turn on a debugging "
+        'mode for debugging GYP.  Supported modes are "variables", '
+        '"includes" and "general" or "all" for all of them.',
+    )
+    parser.add_argument(
+        "-D",
+        dest="defines",
+        action="append",
+        metavar="VAR=VAL",
+        env_name="GYP_DEFINES",
+        help="sets variable VAR to value VAL",
+    )
+    parser.add_argument(
+        "--depth",
+        dest="depth",
+        metavar="PATH",
+        type="path",
+        help="set DEPTH gyp variable to a relative path to PATH",
+    )
+    parser.add_argument(
+        "-f",
+        "--format",
+        dest="formats",
+        action="append",
+        env_name="GYP_GENERATORS",
+        regenerate=False,
+        help="output formats to generate",
+    )
+    parser.add_argument(
+        "-G",
+        dest="generator_flags",
+        action="append",
+        default=[],
+        metavar="FLAG=VAL",
+        env_name="GYP_GENERATOR_FLAGS",
+        help="sets generator flag FLAG to VAL",
+    )
+    parser.add_argument(
+        "--generator-output",
+        dest="generator_output",
+        action="store",
+        default=None,
+        metavar="DIR",
+        type="path",
+        env_name="GYP_GENERATOR_OUTPUT",
+        help="puts generated build files under DIR",
+    )
+    parser.add_argument(
+        "--ignore-environment",
+        dest="use_environment",
+        action="store_false",
+        default=True,
+        regenerate=False,
+        help="do not read options from environment variables",
+    )
+    parser.add_argument(
+        "-I",
+        "--include",
+        dest="includes",
+        action="append",
+        metavar="INCLUDE",
+        type="path",
+        help="files to include in all loaded .gyp files",
+    )
+    # --no-circular-check disables the check for circular relationships between
+    # .gyp files.  These relationships should not exist, but they've only been
+    # observed to be harmful with the Xcode generator.  Chromium's .gyp files
+    # currently have some circular relationships on non-Mac platforms, so this
+    # option allows the strict behavior to be used on Macs and the lenient
+    # behavior to be used elsewhere.
+    # TODO(mark): Remove this option when http://crbug.com/35878 is fixed.
+    parser.add_argument(
+        "--no-circular-check",
+        dest="circular_check",
+        action="store_false",
+        default=True,
+        regenerate=False,
+        help="don't check for circular relationships between files",
+    )
+    parser.add_argument(
+        "--no-parallel",
+        action="store_true",
+        default=False,
+        help="Disable multiprocessing",
+    )
+    parser.add_argument(
+        "-S",
+        "--suffix",
+        dest="suffix",
+        default="",
+        help="suffix to add to generated files",
+    )
+    parser.add_argument(
+        "--toplevel-dir",
+        dest="toplevel_dir",
+        action="store",
+        default=None,
+        metavar="DIR",
+        type="path",
+        help="directory to use as the root of the source tree",
+    )
+    parser.add_argument(
+        "-R",
+        "--root-target",
+        dest="root_targets",
+        action="append",
+        metavar="TARGET",
+        help="include only TARGET and its deep dependencies",
+    )
+
+    options, build_files_arg = parser.parse_args(args)
+    build_files = build_files_arg
+
+    # Set up the configuration directory (defaults to ~/.gyp)
+    if not options.config_dir:
+        home = None
+        home_dot_gyp = None
+        if options.use_environment:
+            home_dot_gyp = os.environ.get("GYP_CONFIG_DIR", None)
+            if home_dot_gyp:
+                home_dot_gyp = os.path.expanduser(home_dot_gyp)
+
+        if not home_dot_gyp:
+            home_vars = ["HOME"]
+            if sys.platform in ("cygwin", "win32"):
+                home_vars.append("USERPROFILE")
+            for home_var in home_vars:
+                home = os.getenv(home_var)
+                if home:
+                    home_dot_gyp = os.path.join(home, ".gyp")
+                    if not os.path.exists(home_dot_gyp):
+                        home_dot_gyp = None
+                    else:
+                        break
+    else:
+        home_dot_gyp = os.path.expanduser(options.config_dir)
+
+    if home_dot_gyp and not os.path.exists(home_dot_gyp):
+        home_dot_gyp = None
+
+    if not options.formats:
+        # If no format was given on the command line, then check the env variable.
+        generate_formats = []
+        if options.use_environment:
+            generate_formats = os.environ.get("GYP_GENERATORS", [])
+        if generate_formats:
+            generate_formats = re.split(r"[\s,]", generate_formats)
+        if generate_formats:
+            options.formats = generate_formats
+        else:
+            # Nothing in the variable, default based on platform.
+            if sys.platform == "darwin":
+                options.formats = ["xcode"]
+            elif sys.platform in ("win32", "cygwin"):
+                options.formats = ["msvs"]
+            else:
+                options.formats = ["make"]
+
+    if not options.generator_output and options.use_environment:
+        g_o = os.environ.get("GYP_GENERATOR_OUTPUT")
+        if g_o:
+            options.generator_output = g_o
+
+    options.parallel = not options.no_parallel
+
+    for mode in options.debug:
+        gyp.debug[mode] = 1
+
+    # Do an extra check to avoid work when we're not debugging.
+    if DEBUG_GENERAL in gyp.debug:
+        DebugOutput(DEBUG_GENERAL, "running with these options:")
+        for option, value in sorted(options.__dict__.items()):
+            if option[0] == "_":
+                continue
+            if isinstance(value, string_types):
+                DebugOutput(DEBUG_GENERAL, "  %s: '%s'", option, value)
+            else:
+                DebugOutput(DEBUG_GENERAL, "  %s: %s", option, value)
+
+    if not build_files:
+        build_files = FindBuildFiles()
+    if not build_files:
+        raise GypError((usage + "\n\n%s: error: no build_file") % (my_name, my_name))
+
+    # TODO(mark): Chromium-specific hack!
+    # For Chromium, the gyp "depth" variable should always be a relative path
+    # to Chromium's top-level "src" directory.  If no depth variable was set
+    # on the command line, try to find a "src" directory by looking at the
+    # absolute path to each build file's directory.  The first "src" component
+    # found will be treated as though it were the path used for --depth.
+    if not options.depth:
+        for build_file in build_files:
+            build_file_dir = os.path.abspath(os.path.dirname(build_file))
+            build_file_dir_components = build_file_dir.split(os.path.sep)
+            components_len = len(build_file_dir_components)
+            for index in range(components_len - 1, -1, -1):
+                if build_file_dir_components[index] == "src":
+                    options.depth = os.path.sep.join(build_file_dir_components)
+                    break
+                del build_file_dir_components[index]
+
+            # If the inner loop found something, break without advancing to another
+            # build file.
+            if options.depth:
+                break
+
+        if not options.depth:
+            raise GypError(
+                "Could not automatically locate src directory.  This is"
+                "a temporary Chromium feature that will be removed.  Use"
+                "--depth as a workaround."
+            )
+
+    # If toplevel-dir is not set, we assume that depth is the root of our source
+    # tree.
+    if not options.toplevel_dir:
+        options.toplevel_dir = options.depth
+
+    # -D on the command line sets variable defaults - D isn't just for define,
+    # it's for default.  Perhaps there should be a way to force (-F?) a
+    # variable's value so that it can't be overridden by anything else.
+    cmdline_default_variables = {}
+    defines = []
     if options.use_environment:
-      home_dot_gyp = os.environ.get('GYP_CONFIG_DIR', None)
-      if home_dot_gyp:
-        home_dot_gyp = os.path.expanduser(home_dot_gyp)
-
-    if not home_dot_gyp:
-      home_vars = ['HOME']
-      if sys.platform in ('cygwin', 'win32'):
-        home_vars.append('USERPROFILE')
-      for home_var in home_vars:
-        home = os.getenv(home_var)
-        if home != None:
-          home_dot_gyp = os.path.join(home, '.gyp')
-          if not os.path.exists(home_dot_gyp):
-            home_dot_gyp = None
-          else:
-            break
-  else:
-    home_dot_gyp = os.path.expanduser(options.config_dir)
-
-  if home_dot_gyp and not os.path.exists(home_dot_gyp):
-    home_dot_gyp = None
-
-  if not options.formats:
-    # If no format was given on the command line, then check the env variable.
-    generate_formats = []
+        defines += ShlexEnv("GYP_DEFINES")
+    if options.defines:
+        defines += options.defines
+    cmdline_default_variables = NameValueListToDict(defines)
+    if DEBUG_GENERAL in gyp.debug:
+        DebugOutput(
+            DEBUG_GENERAL, "cmdline_default_variables: %s", cmdline_default_variables
+        )
+
+    # Set up includes.
+    includes = []
+
+    # If ~/.gyp/include.gypi exists, it'll be forcibly included into every
+    # .gyp file that's loaded, before anything else is included.
+    if home_dot_gyp:
+        default_include = os.path.join(home_dot_gyp, "include.gypi")
+        if os.path.exists(default_include):
+            print("Using overrides found in " + default_include)
+            includes.append(default_include)
+
+    # Command-line --include files come after the default include.
+    if options.includes:
+        includes.extend(options.includes)
+
+    # Generator flags should be prefixed with the target generator since they
+    # are global across all generator runs.
+    gen_flags = []
     if options.use_environment:
-      generate_formats = os.environ.get('GYP_GENERATORS', [])
-    if generate_formats:
-      generate_formats = re.split(r'[\s,]', generate_formats)
-    if generate_formats:
-      options.formats = generate_formats
-    else:
-      # Nothing in the variable, default based on platform.
-      if sys.platform == 'darwin':
-        options.formats = ['xcode']
-      elif sys.platform in ('win32', 'cygwin'):
-        options.formats = ['msvs']
-      else:
-        options.formats = ['make']
-
-  if not options.generator_output and options.use_environment:
-    g_o = os.environ.get('GYP_GENERATOR_OUTPUT')
-    if g_o:
-      options.generator_output = g_o
-
-  options.parallel = not options.no_parallel
-
-  for mode in options.debug:
-    gyp.debug[mode] = 1
-
-  # Do an extra check to avoid work when we're not debugging.
-  if DEBUG_GENERAL in gyp.debug:
-    DebugOutput(DEBUG_GENERAL, 'running with these options:')
-    for option, value in sorted(options.__dict__.items()):
-      if option[0] == '_':
-        continue
-      if isinstance(value, string_types):
-        DebugOutput(DEBUG_GENERAL, "  %s: '%s'", option, value)
-      else:
-        DebugOutput(DEBUG_GENERAL, "  %s: %s", option, value)
-
-  if not build_files:
-    build_files = FindBuildFiles()
-  if not build_files:
-    raise GypError((usage + '\n\n%s: error: no build_file') %
-                   (my_name, my_name))
-
-  # TODO(mark): Chromium-specific hack!
-  # For Chromium, the gyp "depth" variable should always be a relative path
-  # to Chromium's top-level "src" directory.  If no depth variable was set
-  # on the command line, try to find a "src" directory by looking at the
-  # absolute path to each build file's directory.  The first "src" component
-  # found will be treated as though it were the path used for --depth.
-  if not options.depth:
-    for build_file in build_files:
-      build_file_dir = os.path.abspath(os.path.dirname(build_file))
-      build_file_dir_components = build_file_dir.split(os.path.sep)
-      components_len = len(build_file_dir_components)
-      for index in range(components_len - 1, -1, -1):
-        if build_file_dir_components[index] == 'src':
-          options.depth = os.path.sep.join(build_file_dir_components)
-          break
-        del build_file_dir_components[index]
-
-      # If the inner loop found something, break without advancing to another
-      # build file.
-      if options.depth:
-        break
+        gen_flags += ShlexEnv("GYP_GENERATOR_FLAGS")
+    if options.generator_flags:
+        gen_flags += options.generator_flags
+    generator_flags = NameValueListToDict(gen_flags)
+    if DEBUG_GENERAL in gyp.debug.keys():
+        DebugOutput(DEBUG_GENERAL, "generator_flags: %s", generator_flags)
+
+    # Generate all requested formats (use a set in case we got one format request
+    # twice)
+    for format in set(options.formats):
+        params = {
+            "options": options,
+            "build_files": build_files,
+            "generator_flags": generator_flags,
+            "cwd": os.getcwd(),
+            "build_files_arg": build_files_arg,
+            "gyp_binary": sys.argv[0],
+            "home_dot_gyp": home_dot_gyp,
+            "parallel": options.parallel,
+            "root_targets": options.root_targets,
+            "target_arch": cmdline_default_variables.get("target_arch", ""),
+        }
 
-    if not options.depth:
-      raise GypError('Could not automatically locate src directory.  This is'
-                     'a temporary Chromium feature that will be removed.  Use'
-                     '--depth as a workaround.')
-
-  # If toplevel-dir is not set, we assume that depth is the root of our source
-  # tree.
-  if not options.toplevel_dir:
-    options.toplevel_dir = options.depth
-
-  # -D on the command line sets variable defaults - D isn't just for define,
-  # it's for default.  Perhaps there should be a way to force (-F?) a
-  # variable's value so that it can't be overridden by anything else.
-  cmdline_default_variables = {}
-  defines = []
-  if options.use_environment:
-    defines += ShlexEnv('GYP_DEFINES')
-  if options.defines:
-    defines += options.defines
-  cmdline_default_variables = NameValueListToDict(defines)
-  if DEBUG_GENERAL in gyp.debug:
-    DebugOutput(DEBUG_GENERAL,
-                "cmdline_default_variables: %s", cmdline_default_variables)
-
-  # Set up includes.
-  includes = []
-
-  # If ~/.gyp/include.gypi exists, it'll be forcibly included into every
-  # .gyp file that's loaded, before anything else is included.
-  if home_dot_gyp != None:
-    default_include = os.path.join(home_dot_gyp, 'include.gypi')
-    if os.path.exists(default_include):
-      print('Using overrides found in ' + default_include)
-      includes.append(default_include)
-
-  # Command-line --include files come after the default include.
-  if options.includes:
-    includes.extend(options.includes)
-
-  # Generator flags should be prefixed with the target generator since they
-  # are global across all generator runs.
-  gen_flags = []
-  if options.use_environment:
-    gen_flags += ShlexEnv('GYP_GENERATOR_FLAGS')
-  if options.generator_flags:
-    gen_flags += options.generator_flags
-  generator_flags = NameValueListToDict(gen_flags)
-  if DEBUG_GENERAL in gyp.debug.keys():
-    DebugOutput(DEBUG_GENERAL, "generator_flags: %s", generator_flags)
-
-  # Generate all requested formats (use a set in case we got one format request
-  # twice)
-  for format in set(options.formats):
-    params = {'options': options,
-              'build_files': build_files,
-              'generator_flags': generator_flags,
-              'cwd': os.getcwd(),
-              'build_files_arg': build_files_arg,
-              'gyp_binary': sys.argv[0],
-              'home_dot_gyp': home_dot_gyp,
-              'parallel': options.parallel,
-              'root_targets': options.root_targets,
-              'target_arch': cmdline_default_variables.get('target_arch', '')}
-
-    # Start with the default variables from the command line.
-    [generator, flat_list, targets, data] = Load(
-        build_files, format, cmdline_default_variables, includes, options.depth,
-        params, options.check, options.circular_check,
-        options.duplicate_basename_check)
-
-    # TODO(mark): Pass |data| for now because the generator needs a list of
-    # build files that came in.  In the future, maybe it should just accept
-    # a list, and not the whole data dict.
-    # NOTE: flat_list is the flattened dependency graph specifying the order
-    # that targets may be built.  Build systems that operate serially or that
-    # need to have dependencies defined before dependents reference them should
-    # generate targets in the order specified in flat_list.
-    generator.GenerateOutput(flat_list, targets, data, params)
-
-    if options.configs:
-      valid_configs = targets[flat_list[0]]['configurations'].keys()
-      for conf in options.configs:
-        if conf not in valid_configs:
-          raise GypError('Invalid config specified via --build: %s' % conf)
-      generator.PerformBuild(data, options.configs, params)
-
-  # Done
-  return 0
+        # Start with the default variables from the command line.
+        [generator, flat_list, targets, data] = Load(
+            build_files,
+            format,
+            cmdline_default_variables,
+            includes,
+            options.depth,
+            params,
+            options.check,
+            options.circular_check,
+        )
+
+        # TODO(mark): Pass |data| for now because the generator needs a list of
+        # build files that came in.  In the future, maybe it should just accept
+        # a list, and not the whole data dict.
+        # NOTE: flat_list is the flattened dependency graph specifying the order
+        # that targets may be built.  Build systems that operate serially or that
+        # need to have dependencies defined before dependents reference them should
+        # generate targets in the order specified in flat_list.
+        generator.GenerateOutput(flat_list, targets, data, params)
+
+        if options.configs:
+            valid_configs = targets[flat_list[0]]["configurations"]
+            for conf in options.configs:
+                if conf not in valid_configs:
+                    raise GypError("Invalid config specified via --build: %s" % conf)
+            generator.PerformBuild(data, options.configs, params)
+
+    # Done
+    return 0
 
 
 def main(args):
-  try:
-    return gyp_main(args)
-  except GypError as e:
-    sys.stderr.write("gyp: %s\n" % e)
-    return 1
+    try:
+        return gyp_main(args)
+    except GypError as e:
+        sys.stderr.write("gyp: %s\n" % e)
+        return 1
+
 
 # NOTE: setuptools generated console_scripts calls function with no arguments
 def script_main():
-  return main(sys.argv[1:])
+    return main(sys.argv[1:])
+
 
-if __name__ == '__main__':
-  sys.exit(script_main())
+if __name__ == "__main__":
+    sys.exit(script_main())
diff --git a/tools/gyp/pylib/gyp/common.py b/tools/gyp/pylib/gyp/common.py
index aa410e1dfddbab14931fc2251bb44f09fd4b50e2..a915643867293ff4f25348d2be2eaf2e73d16a95 100644
--- a/tools/gyp/pylib/gyp/common.py
+++ b/tools/gyp/pylib/gyp/common.py
@@ -11,9 +11,9 @@ import sys
 import subprocess
 
 try:
-  from collections.abc import MutableSet
+    from collections.abc import MutableSet
 except ImportError:
-  from collections import MutableSet
+    from collections import MutableSet
 
 PY3 = bytes != str
 
@@ -21,191 +21,197 @@ PY3 = bytes != str
 # A minimal memoizing decorator. It'll blow up if the args aren't immutable,
 # among other "problems".
 class memoize(object):
-  def __init__(self, func):
-    self.func = func
-    self.cache = {}
-  def __call__(self, *args):
-    try:
-      return self.cache[args]
-    except KeyError:
-      result = self.func(*args)
-      self.cache[args] = result
-      return result
+    def __init__(self, func):
+        self.func = func
+        self.cache = {}
+
+    def __call__(self, *args):
+        try:
+            return self.cache[args]
+        except KeyError:
+            result = self.func(*args)
+            self.cache[args] = result
+            return result
 
 
 class GypError(Exception):
-  """Error class representing an error, which is to be presented
+    """Error class representing an error, which is to be presented
   to the user.  The main entry point will catch and display this.
   """
-  pass
+
+    pass
 
 
 def ExceptionAppend(e, msg):
-  """Append a message to the given exception's message."""
-  if not e.args:
-    e.args = (msg,)
-  elif len(e.args) == 1:
-    e.args = (str(e.args[0]) + ' ' + msg,)
-  else:
-    e.args = (str(e.args[0]) + ' ' + msg,) + e.args[1:]
+    """Append a message to the given exception's message."""
+    if not e.args:
+        e.args = (msg,)
+    elif len(e.args) == 1:
+        e.args = (str(e.args[0]) + " " + msg,)
+    else:
+        e.args = (str(e.args[0]) + " " + msg,) + e.args[1:]
 
 
 def FindQualifiedTargets(target, qualified_list):
-  """
+    """
   Given a list of qualified targets, return the qualified targets for the
   specified |target|.
   """
-  return [t for t in qualified_list if ParseQualifiedTarget(t)[1] == target]
+    return [t for t in qualified_list if ParseQualifiedTarget(t)[1] == target]
 
 
 def ParseQualifiedTarget(target):
-  # Splits a qualified target into a build file, target name and toolset.
+    # Splits a qualified target into a build file, target name and toolset.
 
-  # NOTE: rsplit is used to disambiguate the Windows drive letter separator.
-  target_split = target.rsplit(':', 1)
-  if len(target_split) == 2:
-    [build_file, target] = target_split
-  else:
-    build_file = None
+    # NOTE: rsplit is used to disambiguate the Windows drive letter separator.
+    target_split = target.rsplit(":", 1)
+    if len(target_split) == 2:
+        [build_file, target] = target_split
+    else:
+        build_file = None
 
-  target_split = target.rsplit('#', 1)
-  if len(target_split) == 2:
-    [target, toolset] = target_split
-  else:
-    toolset = None
+    target_split = target.rsplit("#", 1)
+    if len(target_split) == 2:
+        [target, toolset] = target_split
+    else:
+        toolset = None
 
-  return [build_file, target, toolset]
+    return [build_file, target, toolset]
 
 
 def ResolveTarget(build_file, target, toolset):
-  # This function resolves a target into a canonical form:
-  # - a fully defined build file, either absolute or relative to the current
-  # directory
-  # - a target name
-  # - a toolset
-  #
-  # build_file is the file relative to which 'target' is defined.
-  # target is the qualified target.
-  # toolset is the default toolset for that target.
-  [parsed_build_file, target, parsed_toolset] = ParseQualifiedTarget(target)
-
-  if parsed_build_file:
-    if build_file:
-      # If a relative path, parsed_build_file is relative to the directory
-      # containing build_file.  If build_file is not in the current directory,
-      # parsed_build_file is not a usable path as-is.  Resolve it by
-      # interpreting it as relative to build_file.  If parsed_build_file is
-      # absolute, it is usable as a path regardless of the current directory,
-      # and os.path.join will return it as-is.
-      build_file = os.path.normpath(os.path.join(os.path.dirname(build_file),
-                                                 parsed_build_file))
-      # Further (to handle cases like ../cwd), make it relative to cwd)
-      if not os.path.isabs(build_file):
-        build_file = RelativePath(build_file, '.')
-    else:
-      build_file = parsed_build_file
+    # This function resolves a target into a canonical form:
+    # - a fully defined build file, either absolute or relative to the current
+    # directory
+    # - a target name
+    # - a toolset
+    #
+    # build_file is the file relative to which 'target' is defined.
+    # target is the qualified target.
+    # toolset is the default toolset for that target.
+    [parsed_build_file, target, parsed_toolset] = ParseQualifiedTarget(target)
+
+    if parsed_build_file:
+        if build_file:
+            # If a relative path, parsed_build_file is relative to the directory
+            # containing build_file.  If build_file is not in the current directory,
+            # parsed_build_file is not a usable path as-is.  Resolve it by
+            # interpreting it as relative to build_file.  If parsed_build_file is
+            # absolute, it is usable as a path regardless of the current directory,
+            # and os.path.join will return it as-is.
+            build_file = os.path.normpath(
+                os.path.join(os.path.dirname(build_file), parsed_build_file)
+            )
+            # Further (to handle cases like ../cwd), make it relative to cwd)
+            if not os.path.isabs(build_file):
+                build_file = RelativePath(build_file, ".")
+        else:
+            build_file = parsed_build_file
 
-  if parsed_toolset:
-    toolset = parsed_toolset
+    if parsed_toolset:
+        toolset = parsed_toolset
 
-  return [build_file, target, toolset]
+    return [build_file, target, toolset]
 
 
 def BuildFile(fully_qualified_target):
-  # Extracts the build file from the fully qualified target.
-  return ParseQualifiedTarget(fully_qualified_target)[0]
+    # Extracts the build file from the fully qualified target.
+    return ParseQualifiedTarget(fully_qualified_target)[0]
 
 
 def GetEnvironFallback(var_list, default):
-  """Look up a key in the environment, with fallback to secondary keys
+    """Look up a key in the environment, with fallback to secondary keys
   and finally falling back to a default value."""
-  for var in var_list:
-    if var in os.environ:
-      return os.environ[var]
-  return default
+    for var in var_list:
+        if var in os.environ:
+            return os.environ[var]
+    return default
 
 
 def QualifiedTarget(build_file, target, toolset):
-  # "Qualified" means the file that a target was defined in and the target
-  # name, separated by a colon, suffixed by a # and the toolset name:
-  # /path/to/file.gyp:target_name#toolset
-  fully_qualified = build_file + ':' + target
-  if toolset:
-    fully_qualified = fully_qualified + '#' + toolset
-  return fully_qualified
+    # "Qualified" means the file that a target was defined in and the target
+    # name, separated by a colon, suffixed by a # and the toolset name:
+    # /path/to/file.gyp:target_name#toolset
+    fully_qualified = build_file + ":" + target
+    if toolset:
+        fully_qualified = fully_qualified + "#" + toolset
+    return fully_qualified
 
 
 @memoize
 def RelativePath(path, relative_to, follow_path_symlink=True):
-  # Assuming both |path| and |relative_to| are relative to the current
-  # directory, returns a relative path that identifies path relative to
-  # relative_to.
-  # If |follow_symlink_path| is true (default) and |path| is a symlink, then
-  # this method returns a path to the real file represented by |path|. If it is
-  # false, this method returns a path to the symlink. If |path| is not a
-  # symlink, this option has no effect.
-
-  # Convert to normalized (and therefore absolute paths).
-  if follow_path_symlink:
-    path = os.path.realpath(path)
-  else:
-    path = os.path.abspath(path)
-  relative_to = os.path.realpath(relative_to)
-
-  # On Windows, we can't create a relative path to a different drive, so just
-  # use the absolute path.
-  if sys.platform == 'win32':
-    if (os.path.splitdrive(path)[0].lower() !=
-        os.path.splitdrive(relative_to)[0].lower()):
-      return path
-
-  # Split the paths into components.
-  path_split = path.split(os.path.sep)
-  relative_to_split = relative_to.split(os.path.sep)
-
-  # Determine how much of the prefix the two paths share.
-  prefix_len = len(os.path.commonprefix([path_split, relative_to_split]))
-
-  # Put enough ".." components to back up out of relative_to to the common
-  # prefix, and then append the part of path_split after the common prefix.
-  relative_split = [os.path.pardir] * (len(relative_to_split) - prefix_len) + \
-                   path_split[prefix_len:]
-
-  if len(relative_split) == 0:
-    # The paths were the same.
-    return ''
-
-  # Turn it back into a string and we're done.
-  return os.path.join(*relative_split)
+    # Assuming both |path| and |relative_to| are relative to the current
+    # directory, returns a relative path that identifies path relative to
+    # relative_to.
+    # If |follow_symlink_path| is true (default) and |path| is a symlink, then
+    # this method returns a path to the real file represented by |path|. If it is
+    # false, this method returns a path to the symlink. If |path| is not a
+    # symlink, this option has no effect.
+
+    # Convert to normalized (and therefore absolute paths).
+    if follow_path_symlink:
+        path = os.path.realpath(path)
+    else:
+        path = os.path.abspath(path)
+    relative_to = os.path.realpath(relative_to)
+
+    # On Windows, we can't create a relative path to a different drive, so just
+    # use the absolute path.
+    if sys.platform == "win32":
+        if (
+            os.path.splitdrive(path)[0].lower()
+            != os.path.splitdrive(relative_to)[0].lower()
+        ):
+            return path
+
+    # Split the paths into components.
+    path_split = path.split(os.path.sep)
+    relative_to_split = relative_to.split(os.path.sep)
+
+    # Determine how much of the prefix the two paths share.
+    prefix_len = len(os.path.commonprefix([path_split, relative_to_split]))
+
+    # Put enough ".." components to back up out of relative_to to the common
+    # prefix, and then append the part of path_split after the common prefix.
+    relative_split = [os.path.pardir] * (
+        len(relative_to_split) - prefix_len
+    ) + path_split[prefix_len:]
+
+    if len(relative_split) == 0:
+        # The paths were the same.
+        return ""
+
+    # Turn it back into a string and we're done.
+    return os.path.join(*relative_split)
 
 
 @memoize
 def InvertRelativePath(path, toplevel_dir=None):
-  """Given a path like foo/bar that is relative to toplevel_dir, return
+    """Given a path like foo/bar that is relative to toplevel_dir, return
   the inverse relative path back to the toplevel_dir.
 
   E.g. os.path.normpath(os.path.join(path, InvertRelativePath(path)))
   should always produce the empty string, unless the path contains symlinks.
   """
-  if not path:
-    return path
-  toplevel_dir = '.' if toplevel_dir is None else toplevel_dir
-  return RelativePath(toplevel_dir, os.path.join(toplevel_dir, path))
+    if not path:
+        return path
+    toplevel_dir = "." if toplevel_dir is None else toplevel_dir
+    return RelativePath(toplevel_dir, os.path.join(toplevel_dir, path))
 
 
 def FixIfRelativePath(path, relative_to):
-  # Like RelativePath but returns |path| unchanged if it is absolute.
-  if os.path.isabs(path):
-    return path
-  return RelativePath(path, relative_to)
+    # Like RelativePath but returns |path| unchanged if it is absolute.
+    if os.path.isabs(path):
+        return path
+    return RelativePath(path, relative_to)
 
 
 def UnrelativePath(path, relative_to):
-  # Assuming that |relative_to| is relative to the current directory, and |path|
-  # is a path relative to the dirname of |relative_to|, returns a path that
-  # identifies |path| relative to the current directory.
-  rel_dir = os.path.dirname(relative_to)
-  return os.path.normpath(os.path.join(rel_dir, path))
+    # Assuming that |relative_to| is relative to the current directory, and |path|
+    # is a path relative to the dirname of |relative_to|, returns a path that
+    # identifies |path| relative to the current directory.
+    rel_dir = os.path.dirname(relative_to)
+    return os.path.normpath(os.path.join(rel_dir, path))
 
 
 # re objects used by EncodePOSIXShellArgument.  See IEEE 1003.1 XCU.2.2 at
@@ -234,7 +240,7 @@ def UnrelativePath(path, relative_to):
 # This does not match the characters in _escape, because those need to be
 # backslash-escaped regardless of whether they appear in a double-quoted
 # string.
-_quote = re.compile('[\t\n #$%&\'()*;<=>?[{|}~]|^$')
+_quote = re.compile("[\t\n #$%&'()*;<=>?[{|}~]|^$")
 
 # _escape is a pattern that should match any character that needs to be
 # escaped with a backslash, whether or not the argument matched the _quote
@@ -262,8 +268,9 @@ _quote = re.compile('[\t\n #$%&\'()*;<=>?[{|}~]|^$')
 # shells, there is no room for error here by ignoring !.
 _escape = re.compile(r'(["\\`])')
 
+
 def EncodePOSIXShellArgument(argument):
-  """Encodes |argument| suitably for consumption by POSIX shells.
+    """Encodes |argument| suitably for consumption by POSIX shells.
 
   argument may be quoted and escaped as necessary to ensure that POSIX shells
   treat the returned value as a literal representing the argument passed to
@@ -272,67 +279,67 @@ def EncodePOSIXShellArgument(argument):
   references to variables to be expanded by the shell.
   """
 
-  if not isinstance(argument, str):
-    argument = str(argument)
+    if not isinstance(argument, str):
+        argument = str(argument)
 
-  if _quote.search(argument):
-    quote = '"'
-  else:
-    quote = ''
+    if _quote.search(argument):
+        quote = '"'
+    else:
+        quote = ""
 
-  encoded = quote + re.sub(_escape, r'\\\1', argument) + quote
+    encoded = quote + re.sub(_escape, r"\\\1", argument) + quote
 
-  return encoded
+    return encoded
 
 
 def EncodePOSIXShellList(list):
-  """Encodes |list| suitably for consumption by POSIX shells.
+    """Encodes |list| suitably for consumption by POSIX shells.
 
   Returns EncodePOSIXShellArgument for each item in list, and joins them
   together using the space character as an argument separator.
   """
 
-  encoded_arguments = []
-  for argument in list:
-    encoded_arguments.append(EncodePOSIXShellArgument(argument))
-  return ' '.join(encoded_arguments)
+    encoded_arguments = []
+    for argument in list:
+        encoded_arguments.append(EncodePOSIXShellArgument(argument))
+    return " ".join(encoded_arguments)
 
 
 def DeepDependencyTargets(target_dicts, roots):
-  """Returns the recursive list of target dependencies."""
-  dependencies = set()
-  pending = set(roots)
-  while pending:
-    # Pluck out one.
-    r = pending.pop()
-    # Skip if visited already.
-    if r in dependencies:
-      continue
-    # Add it.
-    dependencies.add(r)
-    # Add its children.
-    spec = target_dicts[r]
-    pending.update(set(spec.get('dependencies', [])))
-    pending.update(set(spec.get('dependencies_original', [])))
-  return list(dependencies - set(roots))
+    """Returns the recursive list of target dependencies."""
+    dependencies = set()
+    pending = set(roots)
+    while pending:
+        # Pluck out one.
+        r = pending.pop()
+        # Skip if visited already.
+        if r in dependencies:
+            continue
+        # Add it.
+        dependencies.add(r)
+        # Add its children.
+        spec = target_dicts[r]
+        pending.update(set(spec.get("dependencies", [])))
+        pending.update(set(spec.get("dependencies_original", [])))
+    return list(dependencies - set(roots))
 
 
 def BuildFileTargets(target_list, build_file):
-  """From a target_list, returns the subset from the specified build_file.
+    """From a target_list, returns the subset from the specified build_file.
   """
-  return [p for p in target_list if BuildFile(p) == build_file]
+    return [p for p in target_list if BuildFile(p) == build_file]
 
 
 def AllTargets(target_list, target_dicts, build_file):
-  """Returns all targets (direct and dependencies) for the specified build_file.
+    """Returns all targets (direct and dependencies) for the specified build_file.
   """
-  bftargets = BuildFileTargets(target_list, build_file)
-  deptargets = DeepDependencyTargets(target_dicts, bftargets)
-  return bftargets + deptargets
+    bftargets = BuildFileTargets(target_list, build_file)
+    deptargets = DeepDependencyTargets(target_dicts, bftargets)
+    return bftargets + deptargets
 
 
 def WriteOnDiff(filename):
-  """Write to a file only if the new contents differ.
+    """Write to a file only if the new contents differ.
 
   Arguments:
     filename: name of the file to potentially write to.
@@ -341,148 +348,152 @@ def WriteOnDiff(filename):
     the target if it differs (on close).
   """
 
-  class Writer(object):
-    """Wrapper around file which only covers the target if it differs."""
-    def __init__(self):
-      # On Cygwin remove the "dir" argument because `C:` prefixed paths are treated as relative,
-      # consequently ending up with current dir "/cygdrive/c/..." being prefixed to those, which was
-      # obviously a non-existent path, for example: "/cygdrive/c/<some folder>/C:\<my win style abs path>".
-      # See https://docs.python.org/2/library/tempfile.html#tempfile.mkstemp for more details
-      base_temp_dir = "" if IsCygwin() else os.path.dirname(filename)
-      # Pick temporary file.
-      tmp_fd, self.tmp_path = tempfile.mkstemp(
-          suffix='.tmp',
-          prefix=os.path.split(filename)[1] + '.gyp.',
-          dir=base_temp_dir)
-      try:
-        self.tmp_file = os.fdopen(tmp_fd, 'wb')
-      except Exception:
-        # Don't leave turds behind.
-        os.unlink(self.tmp_path)
-        raise
-
-    def __getattr__(self, attrname):
-      # Delegate everything else to self.tmp_file
-      return getattr(self.tmp_file, attrname)
-
-    def close(self):
-      try:
-        # Close tmp file.
-        self.tmp_file.close()
-        # Determine if different.
-        same = False
-        try:
-          same = filecmp.cmp(self.tmp_path, filename, False)
-        except OSError as e:
-          if e.errno != errno.ENOENT:
-            raise
-
-        if same:
-          # The new file is identical to the old one, just get rid of the new
-          # one.
-          os.unlink(self.tmp_path)
-        else:
-          # The new file is different from the old one, or there is no old one.
-          # Rename the new file to the permanent name.
-          #
-          # tempfile.mkstemp uses an overly restrictive mode, resulting in a
-          # file that can only be read by the owner, regardless of the umask.
-          # There's no reason to not respect the umask here, which means that
-          # an extra hoop is required to fetch it and reset the new file's mode.
-          #
-          # No way to get the umask without setting a new one?  Set a safe one
-          # and then set it back to the old value.
-          umask = os.umask(0o77)
-          os.umask(umask)
-          os.chmod(self.tmp_path, 0o666 & ~umask)
-          if sys.platform == 'win32' and os.path.exists(filename):
-            # NOTE: on windows (but not cygwin) rename will not replace an
-            # existing file, so it must be preceded with a remove. Sadly there
-            # is no way to make the switch atomic.
-            os.remove(filename)
-          os.rename(self.tmp_path, filename)
-      except Exception:
-        # Don't leave turds behind.
-        os.unlink(self.tmp_path)
-        raise
-
-    def write(self, s):
-      self.tmp_file.write(s.encode('utf-8'))
-
-  return Writer()
+    class Writer(object):
+        """Wrapper around file which only covers the target if it differs."""
+
+        def __init__(self):
+            # On Cygwin remove the "dir" argument
+            # `C:` prefixed paths are treated as relative,
+            # consequently ending up with current dir "/cygdrive/c/..."
+            # being prefixed to those, which was
+            # obviously a non-existent path,
+            # for example: "/cygdrive/c/<some folder>/C:\<my win style abs path>".
+            # For more details see:
+            # https://docs.python.org/2/library/tempfile.html#tempfile.mkstemp
+            base_temp_dir = "" if IsCygwin() else os.path.dirname(filename)
+            # Pick temporary file.
+            tmp_fd, self.tmp_path = tempfile.mkstemp(
+                suffix=".tmp",
+                prefix=os.path.split(filename)[1] + ".gyp.",
+                dir=base_temp_dir,
+            )
+            try:
+                self.tmp_file = os.fdopen(tmp_fd, "wb")
+            except Exception:
+                # Don't leave turds behind.
+                os.unlink(self.tmp_path)
+                raise
+
+        def __getattr__(self, attrname):
+            # Delegate everything else to self.tmp_file
+            return getattr(self.tmp_file, attrname)
+
+        def close(self):
+            try:
+                # Close tmp file.
+                self.tmp_file.close()
+                # Determine if different.
+                same = False
+                try:
+                    same = filecmp.cmp(self.tmp_path, filename, False)
+                except OSError as e:
+                    if e.errno != errno.ENOENT:
+                        raise
+
+                if same:
+                    # The new file is identical to the old one, just get rid of the new
+                    # one.
+                    os.unlink(self.tmp_path)
+                else:
+                    # The new file is different from the old one,
+                    # or there is no old one.
+                    # Rename the new file to the permanent name.
+                    #
+                    # tempfile.mkstemp uses an overly restrictive mode, resulting in a
+                    # file that can only be read by the owner, regardless of the umask.
+                    # There's no reason to not respect the umask here,
+                    # which means that an extra hoop is required
+                    # to fetch it and reset the new file's mode.
+                    #
+                    # No way to get the umask without setting a new one?  Set a safe one
+                    # and then set it back to the old value.
+                    umask = os.umask(0o77)
+                    os.umask(umask)
+                    os.chmod(self.tmp_path, 0o666 & ~umask)
+                    if sys.platform == "win32" and os.path.exists(filename):
+                        # NOTE: on windows (but not cygwin) rename will not replace an
+                        # existing file, so it must be preceded with a remove.
+                        # Sadly there is no way to make the switch atomic.
+                        os.remove(filename)
+                    os.rename(self.tmp_path, filename)
+            except Exception:
+                # Don't leave turds behind.
+                os.unlink(self.tmp_path)
+                raise
+
+        def write(self, s):
+            self.tmp_file.write(s.encode("utf-8"))
+
+    return Writer()
 
 
 def EnsureDirExists(path):
-  """Make sure the directory for |path| exists."""
-  try:
-    os.makedirs(os.path.dirname(path))
-  except OSError:
-    pass
+    """Make sure the directory for |path| exists."""
+    try:
+        os.makedirs(os.path.dirname(path))
+    except OSError:
+        pass
 
 
 def GetFlavor(params):
-  """Returns |params.flavor| if it's set, the system's default flavor else."""
-  flavors = {
-    'cygwin': 'win',
-    'win32': 'win',
-    'darwin': 'mac',
-  }
-
-  if 'flavor' in params:
-    return params['flavor']
-  if sys.platform in flavors:
-    return flavors[sys.platform]
-  if sys.platform.startswith('sunos'):
-    return 'solaris'
-  if sys.platform.startswith(('dragonfly', 'freebsd')):
-    return 'freebsd'
-  if sys.platform.startswith('openbsd'):
-    return 'openbsd'
-  if sys.platform.startswith('netbsd'):
-    return 'netbsd'
-  if sys.platform.startswith('aix'):
-    return 'aix'
-  if sys.platform.startswith(('os390', 'zos')):
-    return 'zos'
-
-  return 'linux'
+    """Returns |params.flavor| if it's set, the system's default flavor else."""
+    flavors = {
+        "cygwin": "win",
+        "win32": "win",
+        "darwin": "mac",
+    }
+
+    if "flavor" in params:
+        return params["flavor"]
+    if sys.platform in flavors:
+        return flavors[sys.platform]
+    if sys.platform.startswith("sunos"):
+        return "solaris"
+    if sys.platform.startswith(("dragonfly", "freebsd")):
+        return "freebsd"
+    if sys.platform.startswith("openbsd"):
+        return "openbsd"
+    if sys.platform.startswith("netbsd"):
+        return "netbsd"
+    if sys.platform.startswith("aix"):
+        return "aix"
+    if sys.platform.startswith(("os390", "zos")):
+        return "zos"
+
+    return "linux"
 
 
 def CopyTool(flavor, out_path, generator_flags={}):
-  """Finds (flock|mac|win)_tool.gyp in the gyp directory and copies it
+    """Finds (flock|mac|win)_tool.gyp in the gyp directory and copies it
   to |out_path|."""
-  # aix and solaris just need flock emulation. mac and win use more complicated
-  # support scripts.
-  prefix = {
-      'aix': 'flock',
-      'solaris': 'flock',
-      'mac': 'mac',
-      'win': 'win'
-      }.get(flavor, None)
-  if not prefix:
-    return
-
-  # Slurp input file.
-  source_path = os.path.join(
-      os.path.dirname(os.path.abspath(__file__)), '%s_tool.py' % prefix)
-  with open(source_path) as source_file:
-    source = source_file.readlines()
-
-  # Set custom header flags.
-  header = '# Generated by gyp. Do not edit.\n'
-  mac_toolchain_dir =  generator_flags.get('mac_toolchain_dir', None)
-  if flavor == 'mac' and mac_toolchain_dir:
-    header += "import os;\nos.environ['DEVELOPER_DIR']='%s'\n" \
-        % mac_toolchain_dir
-
-  # Add header and write it out.
-  tool_path = os.path.join(out_path, 'gyp-%s-tool' % prefix)
-  with open(tool_path, 'w') as tool_file:
-    tool_file.write(
-        ''.join([source[0], header] + source[1:]))
-
-  # Make file executable.
-  os.chmod(tool_path, 0o755)
+    # aix and solaris just need flock emulation. mac and win use more complicated
+    # support scripts.
+    prefix = {"aix": "flock", "solaris": "flock", "mac": "mac", "win": "win"}.get(
+        flavor, None
+    )
+    if not prefix:
+        return
+
+    # Slurp input file.
+    source_path = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), "%s_tool.py" % prefix
+    )
+    with open(source_path) as source_file:
+        source = source_file.readlines()
+
+    # Set custom header flags.
+    header = "# Generated by gyp. Do not edit.\n"
+    mac_toolchain_dir = generator_flags.get("mac_toolchain_dir", None)
+    if flavor == "mac" and mac_toolchain_dir:
+        header += "import os;\nos.environ['DEVELOPER_DIR']='%s'\n" % mac_toolchain_dir
+
+    # Add header and write it out.
+    tool_path = os.path.join(out_path, "gyp-%s-tool" % prefix)
+    with open(tool_path, "w") as tool_file:
+        tool_file.write("".join([source[0], header] + source[1:]))
+
+    # Make file executable.
+    os.chmod(tool_path, 0o755)
 
 
 # From Alex Martelli,
@@ -491,14 +502,14 @@ def CopyTool(flavor, out_path, generator_flags={}):
 # First comment, dated 2001/10/13.
 # (Also in the printed Python Cookbook.)
 
-def uniquer(seq, idfun=None):
-    if idfun is None:
-        idfun = lambda x: x
+
+def uniquer(seq, idfun=lambda x: x):
     seen = {}
     result = []
     for item in seq:
         marker = idfun(item)
-        if marker in seen: continue
+        if marker in seen:
+            continue
         seen[marker] = 1
         result.append(item)
     return result
@@ -506,80 +517,82 @@ def uniquer(seq, idfun=None):
 
 # Based on http://code.activestate.com/recipes/576694/.
 class OrderedSet(MutableSet):
-  def __init__(self, iterable=None):
-    self.end = end = []
-    end += [None, end, end]         # sentinel node for doubly linked list
-    self.map = {}                   # key --> [key, prev, next]
-    if iterable is not None:
-      self |= iterable
-
-  def __len__(self):
-    return len(self.map)
-
-  def __contains__(self, key):
-    return key in self.map
-
-  def add(self, key):
-    if key not in self.map:
-      end = self.end
-      curr = end[1]
-      curr[2] = end[1] = self.map[key] = [key, curr, end]
-
-  def discard(self, key):
-    if key in self.map:
-      key, prev_item, next_item = self.map.pop(key)
-      prev_item[2] = next_item
-      next_item[1] = prev_item
-
-  def __iter__(self):
-    end = self.end
-    curr = end[2]
-    while curr is not end:
-      yield curr[0]
-      curr = curr[2]
-
-  def __reversed__(self):
-    end = self.end
-    curr = end[1]
-    while curr is not end:
-      yield curr[0]
-      curr = curr[1]
-
-  # The second argument is an addition that causes a pylint warning.
-  def pop(self, last=True):  # pylint: disable=W0221
-    if not self:
-      raise KeyError('set is empty')
-    key = self.end[1][0] if last else self.end[2][0]
-    self.discard(key)
-    return key
-
-  def __repr__(self):
-    if not self:
-      return '%s()' % (self.__class__.__name__,)
-    return '%s(%r)' % (self.__class__.__name__, list(self))
-
-  def __eq__(self, other):
-    if isinstance(other, OrderedSet):
-      return len(self) == len(other) and list(self) == list(other)
-    return set(self) == set(other)
-
-  # Extensions to the recipe.
-  def update(self, iterable):
-    for i in iterable:
-      if i not in self:
-        self.add(i)
+    def __init__(self, iterable=None):
+        self.end = end = []
+        end += [None, end, end]  # sentinel node for doubly linked list
+        self.map = {}  # key --> [key, prev, next]
+        if iterable is not None:
+            self |= iterable
+
+    def __len__(self):
+        return len(self.map)
+
+    def __contains__(self, key):
+        return key in self.map
+
+    def add(self, key):
+        if key not in self.map:
+            end = self.end
+            curr = end[1]
+            curr[2] = end[1] = self.map[key] = [key, curr, end]
+
+    def discard(self, key):
+        if key in self.map:
+            key, prev_item, next_item = self.map.pop(key)
+            prev_item[2] = next_item
+            next_item[1] = prev_item
+
+    def __iter__(self):
+        end = self.end
+        curr = end[2]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[2]
+
+    def __reversed__(self):
+        end = self.end
+        curr = end[1]
+        while curr is not end:
+            yield curr[0]
+            curr = curr[1]
+
+    # The second argument is an addition that causes a pylint warning.
+    def pop(self, last=True):  # pylint: disable=W0221
+        if not self:
+            raise KeyError("set is empty")
+        key = self.end[1][0] if last else self.end[2][0]
+        self.discard(key)
+        return key
+
+    def __repr__(self):
+        if not self:
+            return "%s()" % (self.__class__.__name__,)
+        return "%s(%r)" % (self.__class__.__name__, list(self))
+
+    def __eq__(self, other):
+        if isinstance(other, OrderedSet):
+            return len(self) == len(other) and list(self) == list(other)
+        return set(self) == set(other)
+
+    # Extensions to the recipe.
+    def update(self, iterable):
+        for i in iterable:
+            if i not in self:
+                self.add(i)
 
 
 class CycleError(Exception):
-  """An exception raised when an unexpected cycle is detected."""
-  def __init__(self, nodes):
-    self.nodes = nodes
-  def __str__(self):
-    return 'CycleError: cycle involving: ' + str(self.nodes)
+    """An exception raised when an unexpected cycle is detected."""
+
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def __str__(self):
+        return "CycleError: cycle involving: " + str(self.nodes)
 
 
 def TopologicallySorted(graph, get_edges):
-  r"""Topologically sort based on a user provided edge definition.
+    r"""Topologically sort based on a user provided edge definition.
 
   Args:
     graph: A list of node names.
@@ -599,44 +612,50 @@ def TopologicallySorted(graph, get_edges):
     ==>
     ['a', 'c', b']
   """
-  get_edges = memoize(get_edges)
-  visited = set()
-  visiting = set()
-  ordered_nodes = []
-  def Visit(node):
-    if node in visiting:
-      raise CycleError(visiting)
-    if node in visited:
-      return
-    visited.add(node)
-    visiting.add(node)
-    for neighbor in get_edges(node):
-      Visit(neighbor)
-    visiting.remove(node)
-    ordered_nodes.insert(0, node)
-  for node in sorted(graph):
-    Visit(node)
-  return ordered_nodes
+    get_edges = memoize(get_edges)
+    visited = set()
+    visiting = set()
+    ordered_nodes = []
+
+    def Visit(node):
+        if node in visiting:
+            raise CycleError(visiting)
+        if node in visited:
+            return
+        visited.add(node)
+        visiting.add(node)
+        for neighbor in get_edges(node):
+            Visit(neighbor)
+        visiting.remove(node)
+        ordered_nodes.insert(0, node)
+
+    for node in sorted(graph):
+        Visit(node)
+    return ordered_nodes
+
 
 def CrossCompileRequested():
-  # TODO: figure out how to not build extra host objects in the
-  # non-cross-compile case when this is enabled, and enable unconditionally.
-  return (os.environ.get('GYP_CROSSCOMPILE') or
-          os.environ.get('AR_host') or
-          os.environ.get('CC_host') or
-          os.environ.get('CXX_host') or
-          os.environ.get('AR_target') or
-          os.environ.get('CC_target') or
-          os.environ.get('CXX_target'))
+    # TODO: figure out how to not build extra host objects in the
+    # non-cross-compile case when this is enabled, and enable unconditionally.
+    return (
+        os.environ.get("GYP_CROSSCOMPILE")
+        or os.environ.get("AR_host")
+        or os.environ.get("CC_host")
+        or os.environ.get("CXX_host")
+        or os.environ.get("AR_target")
+        or os.environ.get("CC_target")
+        or os.environ.get("CXX_target")
+    )
+
 
 def IsCygwin():
-  try:
-    out = subprocess.Popen("uname",
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT)
-    stdout, stderr = out.communicate()
-    if PY3:
-      stdout = stdout.decode("utf-8")
-    return "CYGWIN" in str(stdout)
-  except Exception:
-    return False
+    try:
+        out = subprocess.Popen(
+            "uname", stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        stdout, stderr = out.communicate()
+        if PY3:
+            stdout = stdout.decode("utf-8")
+        return "CYGWIN" in str(stdout)
+    except Exception:
+        return False
diff --git a/tools/gyp/pylib/gyp/common_test.py b/tools/gyp/pylib/gyp/common_test.py
index b75bbb8412b6f80491dbcf9703744cd7a289e5a7..0310fb266c4e4f5c3474c965630f627afa0cbf60 100755
--- a/tools/gyp/pylib/gyp/common_test.py
+++ b/tools/gyp/pylib/gyp/common_test.py
@@ -12,61 +12,67 @@ import sys
 
 
 class TestTopologicallySorted(unittest.TestCase):
-  def test_Valid(self):
-    """Test that sorting works on a valid graph with one possible order."""
-    graph = {
-        'a': ['b', 'c'],
-        'b': [],
-        'c': ['d'],
-        'd': ['b'],
+    def test_Valid(self):
+        """Test that sorting works on a valid graph with one possible order."""
+        graph = {
+            "a": ["b", "c"],
+            "b": [],
+            "c": ["d"],
+            "d": ["b"],
         }
-    def GetEdge(node):
-      return tuple(graph[node])
-    self.assertEqual(
-      gyp.common.TopologicallySorted(graph.keys(), GetEdge),
-      ['a', 'c', 'd', 'b'])
-
-  def test_Cycle(self):
-    """Test that an exception is thrown on a cyclic graph."""
-    graph = {
-        'a': ['b'],
-        'b': ['c'],
-        'c': ['d'],
-        'd': ['a'],
+
+        def GetEdge(node):
+            return tuple(graph[node])
+
+        self.assertEqual(
+            gyp.common.TopologicallySorted(graph.keys(), GetEdge), ["a", "c", "d", "b"]
+        )
+
+    def test_Cycle(self):
+        """Test that an exception is thrown on a cyclic graph."""
+        graph = {
+            "a": ["b"],
+            "b": ["c"],
+            "c": ["d"],
+            "d": ["a"],
         }
-    def GetEdge(node):
-      return tuple(graph[node])
-    self.assertRaises(
-      gyp.common.CycleError, gyp.common.TopologicallySorted,
-      graph.keys(), GetEdge)
+
+        def GetEdge(node):
+            return tuple(graph[node])
+
+        self.assertRaises(
+            gyp.common.CycleError, gyp.common.TopologicallySorted, graph.keys(), GetEdge
+        )
 
 
 class TestGetFlavor(unittest.TestCase):
-  """Test that gyp.common.GetFlavor works as intended"""
-  original_platform = ''
+    """Test that gyp.common.GetFlavor works as intended"""
+
+    original_platform = ""
 
-  def setUp(self):
-    self.original_platform = sys.platform
+    def setUp(self):
+        self.original_platform = sys.platform
 
-  def tearDown(self):
-    sys.platform = self.original_platform
+    def tearDown(self):
+        sys.platform = self.original_platform
 
-  def assertFlavor(self, expected, argument, param):
-    sys.platform = argument
-    self.assertEqual(expected, gyp.common.GetFlavor(param))
+    def assertFlavor(self, expected, argument, param):
+        sys.platform = argument
+        self.assertEqual(expected, gyp.common.GetFlavor(param))
 
-  def test_platform_default(self):
-    self.assertFlavor('freebsd', 'freebsd9' , {})
-    self.assertFlavor('freebsd', 'freebsd10', {})
-    self.assertFlavor('openbsd', 'openbsd5' , {})
-    self.assertFlavor('solaris', 'sunos5'   , {})
-    self.assertFlavor('solaris', 'sunos'    , {})
-    self.assertFlavor('linux'  , 'linux2'   , {})
-    self.assertFlavor('linux'  , 'linux3'   , {})
+    def test_platform_default(self):
+        self.assertFlavor("freebsd", "freebsd9", {})
+        self.assertFlavor("freebsd", "freebsd10", {})
+        self.assertFlavor("openbsd", "openbsd5", {})
+        self.assertFlavor("solaris", "sunos5", {})
+        self.assertFlavor("solaris", "sunos", {})
+        self.assertFlavor("linux", "linux2", {})
+        self.assertFlavor("linux", "linux3", {})
+        self.assertFlavor("linux", "linux", {})
 
-  def test_param(self):
-    self.assertFlavor('foobar', 'linux2' , {'flavor': 'foobar'})
+    def test_param(self):
+        self.assertFlavor("foobar", "linux2", {"flavor": "foobar"})
 
 
-if __name__ == '__main__':
-  unittest.main()
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/gyp/pylib/gyp/easy_xml.py b/tools/gyp/pylib/gyp/easy_xml.py
index 86d0ba6c0c57d4d3a7a267daa4a01d9da53d41d6..e0628ef4d8310a917f732f4f50617abb4a285db9 100644
--- a/tools/gyp/pylib/gyp/easy_xml.py
+++ b/tools/gyp/pylib/gyp/easy_xml.py
@@ -8,8 +8,8 @@ import locale
 from functools import reduce
 
 
-def XmlToString(content, encoding='utf-8', pretty=False):
-  """ Writes the XML content to disk, touching the file only if it has changed.
+def XmlToString(content, encoding="utf-8", pretty=False):
+    """ Writes the XML content to disk, touching the file only if it has changed.
 
   Visual Studio files have a lot of pre-defined structures.  This function makes
   it easy to represent these structures as Python data structures, instead of
@@ -46,18 +46,18 @@ def XmlToString(content, encoding='utf-8', pretty=False):
   Returns:
     The XML content as a string.
   """
-  # We create a huge list of all the elements of the file.
-  xml_parts = ['<?xml version="1.0" encoding="%s"?>' % encoding]
-  if pretty:
-    xml_parts.append('\n')
-  _ConstructContentList(xml_parts, content, pretty)
+    # We create a huge list of all the elements of the file.
+    xml_parts = ['<?xml version="1.0" encoding="%s"?>' % encoding]
+    if pretty:
+        xml_parts.append("\n")
+    _ConstructContentList(xml_parts, content, pretty)
 
-  # Convert it to a string
-  return ''.join(xml_parts)
+    # Convert it to a string
+    return "".join(xml_parts)
 
 
 def _ConstructContentList(xml_parts, specification, pretty, level=0):
-  """ Appends the XML parts corresponding to the specification.
+    """ Appends the XML parts corresponding to the specification.
 
   Args:
     xml_parts: A list of XML parts to be appended to.
@@ -65,48 +65,49 @@ def _ConstructContentList(xml_parts, specification, pretty, level=0):
     pretty: True if we want pretty printing with indents and new lines.
     level: Indentation level.
   """
-  # The first item in a specification is the name of the element.
-  if pretty:
-    indentation = '  ' * level
-    new_line = '\n'
-  else:
-    indentation = ''
-    new_line = ''
-  name = specification[0]
-  if not isinstance(name, str):
-    raise Exception('The first item of an EasyXml specification should be '
-                    'a string.  Specification was ' + str(specification))
-  xml_parts.append(indentation + '<' + name)
-
-  # Optionally in second position is a dictionary of the attributes.
-  rest = specification[1:]
-  if rest and isinstance(rest[0], dict):
-    for at, val in sorted(rest[0].items()):
-      xml_parts.append(' %s="%s"' % (at, _XmlEscape(val, attr=True)))
-    rest = rest[1:]
-  if rest:
-    xml_parts.append('>')
-    all_strings = reduce(lambda x, y: x and isinstance(y, str), rest, True)
-    multi_line = not all_strings
-    if multi_line and new_line:
-      xml_parts.append(new_line)
-    for child_spec in rest:
-      # If it's a string, append a text node.
-      # Otherwise recurse over that child definition
-      if isinstance(child_spec, str):
-       xml_parts.append(_XmlEscape(child_spec))
-      else:
-        _ConstructContentList(xml_parts, child_spec, pretty, level + 1)
-    if multi_line and indentation:
-      xml_parts.append(indentation)
-    xml_parts.append('</%s>%s' % (name, new_line))
-  else:
-    xml_parts.append('/>%s' % new_line)
-
-
-def WriteXmlIfChanged(content, path, encoding='utf-8', pretty=False,
-                      win32=False):
-  """ Writes the XML content to disk, touching the file only if it has changed.
+    # The first item in a specification is the name of the element.
+    if pretty:
+        indentation = "  " * level
+        new_line = "\n"
+    else:
+        indentation = ""
+        new_line = ""
+    name = specification[0]
+    if not isinstance(name, str):
+        raise Exception(
+            "The first item of an EasyXml specification should be "
+            "a string.  Specification was " + str(specification)
+        )
+    xml_parts.append(indentation + "<" + name)
+
+    # Optionally in second position is a dictionary of the attributes.
+    rest = specification[1:]
+    if rest and isinstance(rest[0], dict):
+        for at, val in sorted(rest[0].items()):
+            xml_parts.append(' %s="%s"' % (at, _XmlEscape(val, attr=True)))
+        rest = rest[1:]
+    if rest:
+        xml_parts.append(">")
+        all_strings = reduce(lambda x, y: x and isinstance(y, str), rest, True)
+        multi_line = not all_strings
+        if multi_line and new_line:
+            xml_parts.append(new_line)
+        for child_spec in rest:
+            # If it's a string, append a text node.
+            # Otherwise recurse over that child definition
+            if isinstance(child_spec, str):
+                xml_parts.append(_XmlEscape(child_spec))
+            else:
+                _ConstructContentList(xml_parts, child_spec, pretty, level + 1)
+        if multi_line and indentation:
+            xml_parts.append(indentation)
+        xml_parts.append("</%s>%s" % (name, new_line))
+    else:
+        xml_parts.append("/>%s" % new_line)
+
+
+def WriteXmlIfChanged(content, path, encoding="utf-8", pretty=False, win32=False):
+    """ Writes the XML content to disk, touching the file only if it has changed.
 
   Args:
     content:  The structured content to be written.
@@ -114,50 +115,49 @@ def WriteXmlIfChanged(content, path, encoding='utf-8', pretty=False,
     encoding: The encoding to report on the first line of the XML file.
     pretty: True if we want pretty printing with indents and new lines.
   """
-  xml_string = XmlToString(content, encoding, pretty)
-  if win32 and os.linesep != '\r\n':
-    xml_string = xml_string.replace('\n', '\r\n')
+    xml_string = XmlToString(content, encoding, pretty)
+    if win32 and os.linesep != "\r\n":
+        xml_string = xml_string.replace("\n", "\r\n")
 
-  default_encoding = locale.getdefaultlocale()[1]
-  if default_encoding and default_encoding.upper() != encoding.upper():
-    xml_string = xml_string.encode(encoding)
+    default_encoding = locale.getdefaultlocale()[1]
+    if default_encoding and default_encoding.upper() != encoding.upper():
+        xml_string = xml_string.encode(encoding)
 
-  # Get the old content
-  try:
-    f = open(path, 'r')
-    existing = f.read()
-    f.close()
-  except:
-    existing = None
+    # Get the old content
+    try:
+        with open(path, "r") as file:
+            existing = file.read()
+    except IOError:
+        existing = None
 
-  # It has changed, write it
-  if existing != xml_string:
-    f = open(path, 'wb')
-    f.write(xml_string)
-    f.close()
+    # It has changed, write it
+    if existing != xml_string:
+        with open(path, "wb") as file:
+            file.write(xml_string)
 
 
 _xml_escape_map = {
-    '"': '&quot;',
-    "'": '&apos;',
-    '<': '&lt;',
-    '>': '&gt;',
-    '&': '&amp;',
-    '\n': '&#xA;',
-    '\r': '&#xD;',
+    '"': "&quot;",
+    "'": "&apos;",
+    "<": "&lt;",
+    ">": "&gt;",
+    "&": "&amp;",
+    "\n": "&#xA;",
+    "\r": "&#xD;",
 }
 
 
-_xml_escape_re = re.compile(
-    "(%s)" % "|".join(map(re.escape, _xml_escape_map.keys())))
+_xml_escape_re = re.compile("(%s)" % "|".join(map(re.escape, _xml_escape_map.keys())))
 
 
 def _XmlEscape(value, attr=False):
-  """ Escape a string for inclusion in XML."""
-  def replace(match):
-    m = match.string[match.start() : match.end()]
-    # don't replace single quotes in attrs
-    if attr and m == "'":
-      return m
-    return _xml_escape_map[m]
-  return _xml_escape_re.sub(replace, value)
+    """ Escape a string for inclusion in XML."""
+
+    def replace(match):
+        m = match.string[match.start() : match.end()]
+        # don't replace single quotes in attrs
+        if attr and m == "'":
+            return m
+        return _xml_escape_map[m]
+
+    return _xml_escape_re.sub(replace, value)
diff --git a/tools/gyp/pylib/gyp/easy_xml_test.py b/tools/gyp/pylib/gyp/easy_xml_test.py
index 664b538a58db602ef28ee8900167104d5bab5677..5bc795ddbe441b5f6ce27d5c8ef3833af418cb33 100755
--- a/tools/gyp/pylib/gyp/easy_xml_test.py
+++ b/tools/gyp/pylib/gyp/easy_xml_test.py
@@ -10,98 +10,103 @@ import gyp.easy_xml as easy_xml
 import unittest
 
 try:
-  from StringIO import StringIO  # Python 2
+    from StringIO import StringIO  # Python 2
 except ImportError:
-  from io import StringIO  # Python 3
+    from io import StringIO  # Python 3
 
 
 class TestSequenceFunctions(unittest.TestCase):
-
-  def setUp(self):
-    self.stderr = StringIO()
-
-  def test_EasyXml_simple(self):
-    self.assertEqual(
-      easy_xml.XmlToString(['test']),
-      '<?xml version="1.0" encoding="utf-8"?><test/>')
-
-    self.assertEqual(
-      easy_xml.XmlToString(['test'], encoding='Windows-1252'),
-      '<?xml version="1.0" encoding="Windows-1252"?><test/>')
-
-  def test_EasyXml_simple_with_attributes(self):
-    self.assertEqual(
-      easy_xml.XmlToString(['test2', {'a': 'value1', 'b': 'value2'}]),
-      '<?xml version="1.0" encoding="utf-8"?><test2 a="value1" b="value2"/>')
-
-  def test_EasyXml_escaping(self):
-    original = '<test>\'"\r&\nfoo'
-    converted = '&lt;test&gt;\'&quot;&#xD;&amp;&#xA;foo'
-    converted_apos = converted.replace("'", '&apos;')
-    self.assertEqual(
-      easy_xml.XmlToString(['test3', {'a': original}, original]),
-      '<?xml version="1.0" encoding="utf-8"?><test3 a="%s">%s</test3>' %
-      (converted, converted_apos))
-
-  def test_EasyXml_pretty(self):
-    self.assertEqual(
-      easy_xml.XmlToString(
-          ['test3',
-            ['GrandParent',
-              ['Parent1',
-                ['Child']
-              ],
-              ['Parent2']
+    def setUp(self):
+        self.stderr = StringIO()
+
+    def test_EasyXml_simple(self):
+        self.assertEqual(
+            easy_xml.XmlToString(["test"]),
+            '<?xml version="1.0" encoding="utf-8"?><test/>',
+        )
+
+        self.assertEqual(
+            easy_xml.XmlToString(["test"], encoding="Windows-1252"),
+            '<?xml version="1.0" encoding="Windows-1252"?><test/>',
+        )
+
+    def test_EasyXml_simple_with_attributes(self):
+        self.assertEqual(
+            easy_xml.XmlToString(["test2", {"a": "value1", "b": "value2"}]),
+            '<?xml version="1.0" encoding="utf-8"?><test2 a="value1" b="value2"/>',
+        )
+
+    def test_EasyXml_escaping(self):
+        original = "<test>'\"\r&\nfoo"
+        converted = "&lt;test&gt;'&quot;&#xD;&amp;&#xA;foo"
+        converted_apos = converted.replace("'", "&apos;")
+        self.assertEqual(
+            easy_xml.XmlToString(["test3", {"a": original}, original]),
+            '<?xml version="1.0" encoding="utf-8"?><test3 a="%s">%s</test3>'
+            % (converted, converted_apos),
+        )
+
+    def test_EasyXml_pretty(self):
+        self.assertEqual(
+            easy_xml.XmlToString(
+                ["test3", ["GrandParent", ["Parent1", ["Child"]], ["Parent2"]]],
+                pretty=True,
+            ),
+            '<?xml version="1.0" encoding="utf-8"?>\n'
+            "<test3>\n"
+            "  <GrandParent>\n"
+            "    <Parent1>\n"
+            "      <Child/>\n"
+            "    </Parent1>\n"
+            "    <Parent2/>\n"
+            "  </GrandParent>\n"
+            "</test3>\n",
+        )
+
+    def test_EasyXml_complex(self):
+        # We want to create:
+        target = (
+            '<?xml version="1.0" encoding="utf-8"?>'
+            "<Project>"
+            '<PropertyGroup Label="Globals">'
+            "<ProjectGuid>{D2250C20-3A94-4FB9-AF73-11BC5B73884B}</ProjectGuid>"
+            "<Keyword>Win32Proj</Keyword>"
+            "<RootNamespace>automated_ui_tests</RootNamespace>"
+            "</PropertyGroup>"
+            '<Import Project="$(VCTargetsPath)\\Microsoft.Cpp.props"/>'
+            "<PropertyGroup "
+            "Condition=\"'$(Configuration)|$(Platform)'=="
+            '\'Debug|Win32\'" Label="Configuration">'
+            "<ConfigurationType>Application</ConfigurationType>"
+            "<CharacterSet>Unicode</CharacterSet>"
+            "</PropertyGroup>"
+            "</Project>"
+        )
+
+        xml = easy_xml.XmlToString(
+            [
+                "Project",
+                [
+                    "PropertyGroup",
+                    {"Label": "Globals"},
+                    ["ProjectGuid", "{D2250C20-3A94-4FB9-AF73-11BC5B73884B}"],
+                    ["Keyword", "Win32Proj"],
+                    ["RootNamespace", "automated_ui_tests"],
+                ],
+                ["Import", {"Project": "$(VCTargetsPath)\\Microsoft.Cpp.props"}],
+                [
+                    "PropertyGroup",
+                    {
+                        "Condition": "'$(Configuration)|$(Platform)'=='Debug|Win32'",
+                        "Label": "Configuration",
+                    },
+                    ["ConfigurationType", "Application"],
+                    ["CharacterSet", "Unicode"],
+                ],
             ]
-          ],
-          pretty=True),
-      '<?xml version="1.0" encoding="utf-8"?>\n'
-      '<test3>\n'
-      '  <GrandParent>\n'
-      '    <Parent1>\n'
-      '      <Child/>\n'
-      '    </Parent1>\n'
-      '    <Parent2/>\n'
-      '  </GrandParent>\n'
-      '</test3>\n')
-
-
-  def test_EasyXml_complex(self):
-    # We want to create:
-    target = (
-      '<?xml version="1.0" encoding="utf-8"?>'
-      '<Project>'
-        '<PropertyGroup Label="Globals">'
-          '<ProjectGuid>{D2250C20-3A94-4FB9-AF73-11BC5B73884B}</ProjectGuid>'
-          '<Keyword>Win32Proj</Keyword>'
-          '<RootNamespace>automated_ui_tests</RootNamespace>'
-        '</PropertyGroup>'
-        '<Import Project="$(VCTargetsPath)\\Microsoft.Cpp.props"/>'
-        '<PropertyGroup '
-            'Condition="\'$(Configuration)|$(Platform)\'=='
-                       '\'Debug|Win32\'" Label="Configuration">'
-          '<ConfigurationType>Application</ConfigurationType>'
-          '<CharacterSet>Unicode</CharacterSet>'
-        '</PropertyGroup>'
-      '</Project>')
-
-    xml = easy_xml.XmlToString(
-        ['Project',
-          ['PropertyGroup', {'Label': 'Globals'},
-            ['ProjectGuid', '{D2250C20-3A94-4FB9-AF73-11BC5B73884B}'],
-            ['Keyword', 'Win32Proj'],
-            ['RootNamespace', 'automated_ui_tests']
-          ],
-          ['Import', {'Project': '$(VCTargetsPath)\\Microsoft.Cpp.props'}],
-          ['PropertyGroup',
-            {'Condition': "'$(Configuration)|$(Platform)'=='Debug|Win32'",
-             'Label': 'Configuration'},
-            ['ConfigurationType', 'Application'],
-            ['CharacterSet', 'Unicode']
-          ]
-        ])
-    self.assertEqual(xml, target)
+        )
+        self.assertEqual(xml, target)
 
 
-if __name__ == '__main__':
-  unittest.main()
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/gyp/pylib/gyp/flock_tool.py b/tools/gyp/pylib/gyp/flock_tool.py
index 81fb79d136a0a58ebd7ab80bcda5e974f81b1512..f9f89e520ac6841bd96061fef729a544122b4eb7 100755
--- a/tools/gyp/pylib/gyp/flock_tool.py
+++ b/tools/gyp/pylib/gyp/flock_tool.py
@@ -14,41 +14,42 @@ import sys
 
 
 def main(args):
-  executor = FlockTool()
-  executor.Dispatch(args)
+    executor = FlockTool()
+    executor.Dispatch(args)
 
 
 class FlockTool(object):
-  """This class emulates the 'flock' command."""
-  def Dispatch(self, args):
-    """Dispatches a string command to a method."""
-    if len(args) < 1:
-      raise Exception("Not enough arguments")
-
-    method = "Exec%s" % self._CommandifyName(args[0])
-    getattr(self, method)(*args[1:])
-
-  def _CommandifyName(self, name_string):
-    """Transforms a tool name like copy-info-plist to CopyInfoPlist"""
-    return name_string.title().replace('-', '')
-
-  def ExecFlock(self, lockfile, *cmd_list):
-    """Emulates the most basic behavior of Linux's flock(1)."""
-    # Rely on exception handling to report errors.
-    # Note that the stock python on SunOS has a bug
-    # where fcntl.flock(fd, LOCK_EX) always fails
-    # with EBADF, that's why we use this F_SETLK
-    # hack instead.
-    fd = os.open(lockfile, os.O_WRONLY|os.O_NOCTTY|os.O_CREAT, 0o666)
-    if sys.platform.startswith('aix'):
-      # Python on AIX is compiled with LARGEFILE support, which changes the
-      # struct size.
-      op = struct.pack('hhIllqq', fcntl.F_WRLCK, 0, 0, 0, 0, 0, 0)
-    else:
-      op = struct.pack('hhllhhl', fcntl.F_WRLCK, 0, 0, 0, 0, 0, 0)
-    fcntl.fcntl(fd, fcntl.F_SETLK, op)
-    return subprocess.call(cmd_list)
-
-
-if __name__ == '__main__':
-  sys.exit(main(sys.argv[1:]))
+    """This class emulates the 'flock' command."""
+
+    def Dispatch(self, args):
+        """Dispatches a string command to a method."""
+        if len(args) < 1:
+            raise Exception("Not enough arguments")
+
+        method = "Exec%s" % self._CommandifyName(args[0])
+        getattr(self, method)(*args[1:])
+
+    def _CommandifyName(self, name_string):
+        """Transforms a tool name like copy-info-plist to CopyInfoPlist"""
+        return name_string.title().replace("-", "")
+
+    def ExecFlock(self, lockfile, *cmd_list):
+        """Emulates the most basic behavior of Linux's flock(1)."""
+        # Rely on exception handling to report errors.
+        # Note that the stock python on SunOS has a bug
+        # where fcntl.flock(fd, LOCK_EX) always fails
+        # with EBADF, that's why we use this F_SETLK
+        # hack instead.
+        fd = os.open(lockfile, os.O_WRONLY | os.O_NOCTTY | os.O_CREAT, 0o666)
+        if sys.platform.startswith("aix"):
+            # Python on AIX is compiled with LARGEFILE support, which changes the
+            # struct size.
+            op = struct.pack("hhIllqq", fcntl.F_WRLCK, 0, 0, 0, 0, 0, 0)
+        else:
+            op = struct.pack("hhllhhl", fcntl.F_WRLCK, 0, 0, 0, 0, 0, 0)
+        fcntl.fcntl(fd, fcntl.F_SETLK, op)
+        return subprocess.call(cmd_list)
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/tools/gyp/pylib/gyp/generator/analyzer.py b/tools/gyp/pylib/gyp/generator/analyzer.py
index 59d73dbedbd3199441da13cf5485ba063b64982c..7a393c1f9393dacafbfe7fefc402b2afe0997d6e 100644
--- a/tools/gyp/pylib/gyp/generator/analyzer.py
+++ b/tools/gyp/pylib/gyp/generator/analyzer.py
@@ -65,18 +65,16 @@ then the "all" target includes "b1" and "b2".
 from __future__ import print_function
 
 import gyp.common
-import gyp.ninja_syntax as ninja_syntax
 import json
 import os
 import posixpath
-import sys
 
 debug = False
 
-found_dependency_string = 'Found dependency'
-no_dependency_string = 'No dependencies'
+found_dependency_string = "Found dependency"
+no_dependency_string = "No dependencies"
 # Status when it should be assumed that everything has changed.
-all_changed_string = 'Found dependency (all)'
+all_changed_string = "Found dependency (all)"
 
 # MatchStatus is used indicate if and how a target depends upon the supplied
 # sources.
@@ -96,118 +94,130 @@ generator_supports_multiple_toolsets = gyp.common.CrossCompileRequested()
 
 generator_wants_static_library_dependencies_adjusted = False
 
-generator_default_variables = {
-}
-for dirname in ['INTERMEDIATE_DIR', 'SHARED_INTERMEDIATE_DIR', 'PRODUCT_DIR',
-                'LIB_DIR', 'SHARED_LIB_DIR']:
-  generator_default_variables[dirname] = '!!!'
-
-for unused in ['RULE_INPUT_PATH', 'RULE_INPUT_ROOT', 'RULE_INPUT_NAME',
-               'RULE_INPUT_DIRNAME', 'RULE_INPUT_EXT',
-               'EXECUTABLE_PREFIX', 'EXECUTABLE_SUFFIX',
-               'STATIC_LIB_PREFIX', 'STATIC_LIB_SUFFIX',
-               'SHARED_LIB_PREFIX', 'SHARED_LIB_SUFFIX',
-               'CONFIGURATION_NAME']:
-  generator_default_variables[unused] = ''
+generator_default_variables = {}
+for dirname in [
+    "INTERMEDIATE_DIR",
+    "SHARED_INTERMEDIATE_DIR",
+    "PRODUCT_DIR",
+    "LIB_DIR",
+    "SHARED_LIB_DIR",
+]:
+    generator_default_variables[dirname] = "!!!"
+
+for unused in [
+    "RULE_INPUT_PATH",
+    "RULE_INPUT_ROOT",
+    "RULE_INPUT_NAME",
+    "RULE_INPUT_DIRNAME",
+    "RULE_INPUT_EXT",
+    "EXECUTABLE_PREFIX",
+    "EXECUTABLE_SUFFIX",
+    "STATIC_LIB_PREFIX",
+    "STATIC_LIB_SUFFIX",
+    "SHARED_LIB_PREFIX",
+    "SHARED_LIB_SUFFIX",
+    "CONFIGURATION_NAME",
+]:
+    generator_default_variables[unused] = ""
 
 
 def _ToGypPath(path):
-  """Converts a path to the format used by gyp."""
-  if os.sep == '\\' and os.altsep == '/':
-    return path.replace('\\', '/')
-  return path
+    """Converts a path to the format used by gyp."""
+    if os.sep == "\\" and os.altsep == "/":
+        return path.replace("\\", "/")
+    return path
 
 
 def _ResolveParent(path, base_path_components):
-  """Resolves |path|, which starts with at least one '../'. Returns an empty
+    """Resolves |path|, which starts with at least one '../'. Returns an empty
   string if the path shouldn't be considered. See _AddSources() for a
   description of |base_path_components|."""
-  depth = 0
-  while path.startswith('../'):
-    depth += 1
-    path = path[3:]
-  # Relative includes may go outside the source tree. For example, an action may
-  # have inputs in /usr/include, which are not in the source tree.
-  if depth > len(base_path_components):
-    return ''
-  if depth == len(base_path_components):
-    return path
-  return '/'.join(base_path_components[0:len(base_path_components) - depth]) + \
-      '/' + path
+    depth = 0
+    while path.startswith("../"):
+        depth += 1
+        path = path[3:]
+    # Relative includes may go outside the source tree. For example, an action may
+    # have inputs in /usr/include, which are not in the source tree.
+    if depth > len(base_path_components):
+        return ""
+    if depth == len(base_path_components):
+        return path
+    return (
+        "/".join(base_path_components[0 : len(base_path_components) - depth])
+        + "/"
+        + path
+    )
 
 
 def _AddSources(sources, base_path, base_path_components, result):
-  """Extracts valid sources from |sources| and adds them to |result|. Each
+    """Extracts valid sources from |sources| and adds them to |result|. Each
   source file is relative to |base_path|, but may contain '..'. To make
   resolving '..' easier |base_path_components| contains each of the
   directories in |base_path|. Additionally each source may contain variables.
   Such sources are ignored as it is assumed dependencies on them are expressed
   and tracked in some other means."""
-  # NOTE: gyp paths are always posix style.
-  for source in sources:
-    if not len(source) or source.startswith('!!!') or source.startswith('$'):
-      continue
-    # variable expansion may lead to //.
-    org_source = source
-    source = source[0] + source[1:].replace('//', '/')
-    if source.startswith('../'):
-      source = _ResolveParent(source, base_path_components)
-      if len(source):
-        result.append(source)
-      continue
-    result.append(base_path + source)
-    if debug:
-      print('AddSource', org_source, result[len(result) - 1])
-
-
-def _ExtractSourcesFromAction(action, base_path, base_path_components,
-                              results):
-  if 'inputs' in action:
-    _AddSources(action['inputs'], base_path, base_path_components, results)
+    # NOTE: gyp paths are always posix style.
+    for source in sources:
+        if not len(source) or source.startswith("!!!") or source.startswith("$"):
+            continue
+        # variable expansion may lead to //.
+        org_source = source
+        source = source[0] + source[1:].replace("//", "/")
+        if source.startswith("../"):
+            source = _ResolveParent(source, base_path_components)
+            if len(source):
+                result.append(source)
+            continue
+        result.append(base_path + source)
+        if debug:
+            print("AddSource", org_source, result[len(result) - 1])
+
+
+def _ExtractSourcesFromAction(action, base_path, base_path_components, results):
+    if "inputs" in action:
+        _AddSources(action["inputs"], base_path, base_path_components, results)
 
 
 def _ToLocalPath(toplevel_dir, path):
-  """Converts |path| to a path relative to |toplevel_dir|."""
-  if path == toplevel_dir:
-    return ''
-  if path.startswith(toplevel_dir + '/'):
-    return path[len(toplevel_dir) + len('/'):]
-  return path
+    """Converts |path| to a path relative to |toplevel_dir|."""
+    if path == toplevel_dir:
+        return ""
+    if path.startswith(toplevel_dir + "/"):
+        return path[len(toplevel_dir) + len("/") :]
+    return path
 
 
 def _ExtractSources(target, target_dict, toplevel_dir):
-  # |target| is either absolute or relative and in the format of the OS. Gyp
-  # source paths are always posix. Convert |target| to a posix path relative to
-  # |toplevel_dir_|. This is done to make it easy to build source paths.
-  base_path = posixpath.dirname(_ToLocalPath(toplevel_dir, _ToGypPath(target)))
-  base_path_components = base_path.split('/')
-
-  # Add a trailing '/' so that _AddSources() can easily build paths.
-  if len(base_path):
-    base_path += '/'
-
-  if debug:
-    print('ExtractSources', target, base_path)
-
-  results = []
-  if 'sources' in target_dict:
-    _AddSources(target_dict['sources'], base_path, base_path_components,
-                results)
-  # Include the inputs from any actions. Any changes to these affect the
-  # resulting output.
-  if 'actions' in target_dict:
-    for action in target_dict['actions']:
-      _ExtractSourcesFromAction(action, base_path, base_path_components,
-                                results)
-  if 'rules' in target_dict:
-    for rule in target_dict['rules']:
-      _ExtractSourcesFromAction(rule, base_path, base_path_components, results)
-
-  return results
+    # |target| is either absolute or relative and in the format of the OS. Gyp
+    # source paths are always posix. Convert |target| to a posix path relative to
+    # |toplevel_dir_|. This is done to make it easy to build source paths.
+    base_path = posixpath.dirname(_ToLocalPath(toplevel_dir, _ToGypPath(target)))
+    base_path_components = base_path.split("/")
+
+    # Add a trailing '/' so that _AddSources() can easily build paths.
+    if len(base_path):
+        base_path += "/"
+
+    if debug:
+        print("ExtractSources", target, base_path)
+
+    results = []
+    if "sources" in target_dict:
+        _AddSources(target_dict["sources"], base_path, base_path_components, results)
+    # Include the inputs from any actions. Any changes to these affect the
+    # resulting output.
+    if "actions" in target_dict:
+        for action in target_dict["actions"]:
+            _ExtractSourcesFromAction(action, base_path, base_path_components, results)
+    if "rules" in target_dict:
+        for rule in target_dict["rules"]:
+            _ExtractSourcesFromAction(rule, base_path, base_path_components, results)
+
+    return results
 
 
 class Target(object):
-  """Holds information about a particular target:
+    """Holds information about a particular target:
   deps: set of Targets this Target depends upon. This is not recursive, only the
     direct dependent Targets.
   match_status: one of the MatchStatus values.
@@ -225,101 +235,111 @@ class Target(object):
   is_static_library: true if the type of target is static_library.
   is_or_has_linked_ancestor: true if the target does a link (eg executable), or
     if there is a target in back_deps that does a link."""
-  def __init__(self, name):
-    self.deps = set()
-    self.match_status = MATCH_STATUS_TBD
-    self.back_deps = set()
-    self.name = name
-    # TODO(sky): I don't like hanging this off Target. This state is specific
-    # to certain functions and should be isolated there.
-    self.visited = False
-    self.requires_build = False
-    self.added_to_compile_targets = False
-    self.in_roots = False
-    self.is_executable = False
-    self.is_static_library = False
-    self.is_or_has_linked_ancestor = False
+
+    def __init__(self, name):
+        self.deps = set()
+        self.match_status = MATCH_STATUS_TBD
+        self.back_deps = set()
+        self.name = name
+        # TODO(sky): I don't like hanging this off Target. This state is specific
+        # to certain functions and should be isolated there.
+        self.visited = False
+        self.requires_build = False
+        self.added_to_compile_targets = False
+        self.in_roots = False
+        self.is_executable = False
+        self.is_static_library = False
+        self.is_or_has_linked_ancestor = False
 
 
 class Config(object):
-  """Details what we're looking for
+    """Details what we're looking for
   files: set of files to search for
   targets: see file description for details."""
-  def __init__(self):
-    self.files = []
-    self.targets = set()
-    self.additional_compile_target_names = set()
-    self.test_target_names = set()
-
-  def Init(self, params):
-    """Initializes Config. This is a separate method as it raises an exception
+
+    def __init__(self):
+        self.files = []
+        self.targets = set()
+        self.additional_compile_target_names = set()
+        self.test_target_names = set()
+
+    def Init(self, params):
+        """Initializes Config. This is a separate method as it raises an exception
     if there is a parse error."""
-    generator_flags = params.get('generator_flags', {})
-    config_path = generator_flags.get('config_path', None)
-    if not config_path:
-      return
-    try:
-      f = open(config_path, 'r')
-      config = json.load(f)
-      f.close()
-    except IOError:
-      raise Exception('Unable to open file ' + config_path)
-    except ValueError as e:
-      raise Exception('Unable to parse config file ' + config_path + str(e))
-    if not isinstance(config, dict):
-      raise Exception('config_path must be a JSON file containing a dictionary')
-    self.files = config.get('files', [])
-    self.additional_compile_target_names = set(
-      config.get('additional_compile_targets', []))
-    self.test_target_names = set(config.get('test_targets', []))
+        generator_flags = params.get("generator_flags", {})
+        config_path = generator_flags.get("config_path", None)
+        if not config_path:
+            return
+        try:
+            f = open(config_path, "r")
+            config = json.load(f)
+            f.close()
+        except IOError:
+            raise Exception("Unable to open file " + config_path)
+        except ValueError as e:
+            raise Exception("Unable to parse config file " + config_path + str(e))
+        if not isinstance(config, dict):
+            raise Exception("config_path must be a JSON file containing a dictionary")
+        self.files = config.get("files", [])
+        self.additional_compile_target_names = set(
+            config.get("additional_compile_targets", [])
+        )
+        self.test_target_names = set(config.get("test_targets", []))
 
 
 def _WasBuildFileModified(build_file, data, files, toplevel_dir):
-  """Returns true if the build file |build_file| is either in |files| or
+    """Returns true if the build file |build_file| is either in |files| or
   one of the files included by |build_file| is in |files|. |toplevel_dir| is
   the root of the source tree."""
-  if _ToLocalPath(toplevel_dir, _ToGypPath(build_file)) in files:
-    if debug:
-      print('gyp file modified', build_file)
-    return True
+    if _ToLocalPath(toplevel_dir, _ToGypPath(build_file)) in files:
+        if debug:
+            print("gyp file modified", build_file)
+        return True
 
-  # First element of included_files is the file itself.
-  if len(data[build_file]['included_files']) <= 1:
+    # First element of included_files is the file itself.
+    if len(data[build_file]["included_files"]) <= 1:
+        return False
+
+    for include_file in data[build_file]["included_files"][1:]:
+        # |included_files| are relative to the directory of the |build_file|.
+        rel_include_file = _ToGypPath(
+            gyp.common.UnrelativePath(include_file, build_file)
+        )
+        if _ToLocalPath(toplevel_dir, rel_include_file) in files:
+            if debug:
+                print(
+                    "included gyp file modified, gyp_file=",
+                    build_file,
+                    "included file=",
+                    rel_include_file,
+                )
+            return True
     return False
 
-  for include_file in data[build_file]['included_files'][1:]:
-    # |included_files| are relative to the directory of the |build_file|.
-    rel_include_file = \
-        _ToGypPath(gyp.common.UnrelativePath(include_file, build_file))
-    if _ToLocalPath(toplevel_dir, rel_include_file) in files:
-      if debug:
-        print('included gyp file modified, gyp_file=', build_file,
-              'included file=', rel_include_file)
-      return True
-  return False
-
 
 def _GetOrCreateTargetByName(targets, target_name):
-  """Creates or returns the Target at targets[target_name]. If there is no
+    """Creates or returns the Target at targets[target_name]. If there is no
   Target for |target_name| one is created. Returns a tuple of whether a new
   Target was created and the Target."""
-  if target_name in targets:
-    return False, targets[target_name]
-  target = Target(target_name)
-  targets[target_name] = target
-  return True, target
+    if target_name in targets:
+        return False, targets[target_name]
+    target = Target(target_name)
+    targets[target_name] = target
+    return True, target
 
 
 def _DoesTargetTypeRequireBuild(target_dict):
-  """Returns true if the target type is such that it needs to be built."""
-  # If a 'none' target has rules or actions we assume it requires a build.
-  return bool(target_dict['type'] != 'none' or
-              target_dict.get('actions') or target_dict.get('rules'))
+    """Returns true if the target type is such that it needs to be built."""
+    # If a 'none' target has rules or actions we assume it requires a build.
+    return bool(
+        target_dict["type"] != "none"
+        or target_dict.get("actions")
+        or target_dict.get("rules")
+    )
 
 
-def _GenerateTargets(data, target_list, target_dicts, toplevel_dir, files,
-                     build_files):
-  """Returns a tuple of the following:
+def _GenerateTargets(data, target_list, target_dicts, toplevel_dir, files, build_files):
+    """Returns a tuple of the following:
   . A dictionary mapping from fully qualified name to Target.
   . A list of the targets that have a source file in |files|.
   . Targets that constitute the 'all' target. See description at top of file
@@ -327,417 +347,463 @@ def _GenerateTargets(data, target_list, target_dicts, toplevel_dir, files,
   This sets the |match_status| of the targets that contain any of the source
   files in |files| to MATCH_STATUS_MATCHES.
   |toplevel_dir| is the root of the source tree."""
-  # Maps from target name to Target.
-  name_to_target = {}
-
-  # Targets that matched.
-  matching_targets = []
-
-  # Queue of targets to visit.
-  targets_to_visit = target_list[:]
-
-  # Maps from build file to a boolean indicating whether the build file is in
-  # |files|.
-  build_file_in_files = {}
-
-  # Root targets across all files.
-  roots = set()
-
-  # Set of Targets in |build_files|.
-  build_file_targets = set()
-
-  while len(targets_to_visit) > 0:
-    target_name = targets_to_visit.pop()
-    created_target, target = _GetOrCreateTargetByName(name_to_target,
-                                                      target_name)
-    if created_target:
-      roots.add(target)
-    elif target.visited:
-      continue
-
-    target.visited = True
-    target.requires_build = _DoesTargetTypeRequireBuild(
-        target_dicts[target_name])
-    target_type = target_dicts[target_name]['type']
-    target.is_executable = target_type == 'executable'
-    target.is_static_library = target_type == 'static_library'
-    target.is_or_has_linked_ancestor = (target_type == 'executable' or
-                                        target_type == 'shared_library')
-
-    build_file = gyp.common.ParseQualifiedTarget(target_name)[0]
-    if not build_file in build_file_in_files:
-      build_file_in_files[build_file] = \
-          _WasBuildFileModified(build_file, data, files, toplevel_dir)
-
-    if build_file in build_files:
-      build_file_targets.add(target)
-
-    # If a build file (or any of its included files) is modified we assume all
-    # targets in the file are modified.
-    if build_file_in_files[build_file]:
-      print('matching target from modified build file', target_name)
-      target.match_status = MATCH_STATUS_MATCHES
-      matching_targets.append(target)
-    else:
-      sources = _ExtractSources(target_name, target_dicts[target_name],
-                                toplevel_dir)
-      for source in sources:
-        if _ToGypPath(os.path.normpath(source)) in files:
-          print('target', target_name, 'matches', source)
-          target.match_status = MATCH_STATUS_MATCHES
-          matching_targets.append(target)
-          break
-
-    # Add dependencies to visit as well as updating back pointers for deps.
-    for dep in target_dicts[target_name].get('dependencies', []):
-      targets_to_visit.append(dep)
-
-      created_dep_target, dep_target = _GetOrCreateTargetByName(name_to_target,
-                                                                dep)
-      if not created_dep_target:
-        roots.discard(dep_target)
-
-      target.deps.add(dep_target)
-      dep_target.back_deps.add(target)
-
-  return name_to_target, matching_targets, roots & build_file_targets
+    # Maps from target name to Target.
+    name_to_target = {}
+
+    # Targets that matched.
+    matching_targets = []
+
+    # Queue of targets to visit.
+    targets_to_visit = target_list[:]
+
+    # Maps from build file to a boolean indicating whether the build file is in
+    # |files|.
+    build_file_in_files = {}
+
+    # Root targets across all files.
+    roots = set()
+
+    # Set of Targets in |build_files|.
+    build_file_targets = set()
+
+    while len(targets_to_visit) > 0:
+        target_name = targets_to_visit.pop()
+        created_target, target = _GetOrCreateTargetByName(name_to_target, target_name)
+        if created_target:
+            roots.add(target)
+        elif target.visited:
+            continue
+
+        target.visited = True
+        target.requires_build = _DoesTargetTypeRequireBuild(target_dicts[target_name])
+        target_type = target_dicts[target_name]["type"]
+        target.is_executable = target_type == "executable"
+        target.is_static_library = target_type == "static_library"
+        target.is_or_has_linked_ancestor = (
+            target_type == "executable" or target_type == "shared_library"
+        )
+
+        build_file = gyp.common.ParseQualifiedTarget(target_name)[0]
+        if build_file not in build_file_in_files:
+            build_file_in_files[build_file] = _WasBuildFileModified(
+                build_file, data, files, toplevel_dir
+            )
+
+        if build_file in build_files:
+            build_file_targets.add(target)
+
+        # If a build file (or any of its included files) is modified we assume all
+        # targets in the file are modified.
+        if build_file_in_files[build_file]:
+            print("matching target from modified build file", target_name)
+            target.match_status = MATCH_STATUS_MATCHES
+            matching_targets.append(target)
+        else:
+            sources = _ExtractSources(
+                target_name, target_dicts[target_name], toplevel_dir
+            )
+            for source in sources:
+                if _ToGypPath(os.path.normpath(source)) in files:
+                    print("target", target_name, "matches", source)
+                    target.match_status = MATCH_STATUS_MATCHES
+                    matching_targets.append(target)
+                    break
+
+        # Add dependencies to visit as well as updating back pointers for deps.
+        for dep in target_dicts[target_name].get("dependencies", []):
+            targets_to_visit.append(dep)
+
+            created_dep_target, dep_target = _GetOrCreateTargetByName(
+                name_to_target, dep
+            )
+            if not created_dep_target:
+                roots.discard(dep_target)
+
+            target.deps.add(dep_target)
+            dep_target.back_deps.add(target)
+
+    return name_to_target, matching_targets, roots & build_file_targets
 
 
 def _GetUnqualifiedToTargetMapping(all_targets, to_find):
-  """Returns a tuple of the following:
+    """Returns a tuple of the following:
   . mapping (dictionary) from unqualified name to Target for all the
     Targets in |to_find|.
   . any target names not found. If this is empty all targets were found."""
-  result = {}
-  if not to_find:
-    return {}, []
-  to_find = set(to_find)
-  for target_name in all_targets.keys():
-    extracted = gyp.common.ParseQualifiedTarget(target_name)
-    if len(extracted) > 1 and extracted[1] in to_find:
-      to_find.remove(extracted[1])
-      result[extracted[1]] = all_targets[target_name]
-      if not to_find:
-        return result, []
-  return result, [x for x in to_find]
+    result = {}
+    if not to_find:
+        return {}, []
+    to_find = set(to_find)
+    for target_name in all_targets.keys():
+        extracted = gyp.common.ParseQualifiedTarget(target_name)
+        if len(extracted) > 1 and extracted[1] in to_find:
+            to_find.remove(extracted[1])
+            result[extracted[1]] = all_targets[target_name]
+            if not to_find:
+                return result, []
+    return result, [x for x in to_find]
 
 
 def _DoesTargetDependOnMatchingTargets(target):
-  """Returns true if |target| or any of its dependencies is one of the
+    """Returns true if |target| or any of its dependencies is one of the
   targets containing the files supplied as input to analyzer. This updates
   |matches| of the Targets as it recurses.
   target: the Target to look for."""
-  if target.match_status == MATCH_STATUS_DOESNT_MATCH:
+    if target.match_status == MATCH_STATUS_DOESNT_MATCH:
+        return False
+    if (
+        target.match_status == MATCH_STATUS_MATCHES
+        or target.match_status == MATCH_STATUS_MATCHES_BY_DEPENDENCY
+    ):
+        return True
+    for dep in target.deps:
+        if _DoesTargetDependOnMatchingTargets(dep):
+            target.match_status = MATCH_STATUS_MATCHES_BY_DEPENDENCY
+            print("\t", target.name, "matches by dep", dep.name)
+            return True
+    target.match_status = MATCH_STATUS_DOESNT_MATCH
     return False
-  if target.match_status == MATCH_STATUS_MATCHES or \
-      target.match_status == MATCH_STATUS_MATCHES_BY_DEPENDENCY:
-    return True
-  for dep in target.deps:
-    if _DoesTargetDependOnMatchingTargets(dep):
-      target.match_status = MATCH_STATUS_MATCHES_BY_DEPENDENCY
-      print('\t', target.name, 'matches by dep', dep.name)
-      return True
-  target.match_status = MATCH_STATUS_DOESNT_MATCH
-  return False
 
 
 def _GetTargetsDependingOnMatchingTargets(possible_targets):
-  """Returns the list of Targets in |possible_targets| that depend (either
+    """Returns the list of Targets in |possible_targets| that depend (either
   directly on indirectly) on at least one of the targets containing the files
   supplied as input to analyzer.
   possible_targets: targets to search from."""
-  found = []
-  print('Targets that matched by dependency:')
-  for target in possible_targets:
-    if _DoesTargetDependOnMatchingTargets(target):
-      found.append(target)
-  return found
+    found = []
+    print("Targets that matched by dependency:")
+    for target in possible_targets:
+        if _DoesTargetDependOnMatchingTargets(target):
+            found.append(target)
+    return found
 
 
 def _AddCompileTargets(target, roots, add_if_no_ancestor, result):
-  """Recurses through all targets that depend on |target|, adding all targets
+    """Recurses through all targets that depend on |target|, adding all targets
   that need to be built (and are in |roots|) to |result|.
   roots: set of root targets.
   add_if_no_ancestor: If true and there are no ancestors of |target| then add
   |target| to |result|. |target| must still be in |roots|.
   result: targets that need to be built are added here."""
-  if target.visited:
-    return
-
-  target.visited = True
-  target.in_roots = target in roots
-
-  for back_dep_target in target.back_deps:
-    _AddCompileTargets(back_dep_target, roots, False, result)
-    target.added_to_compile_targets |= back_dep_target.added_to_compile_targets
-    target.in_roots |= back_dep_target.in_roots
-    target.is_or_has_linked_ancestor |= (
-      back_dep_target.is_or_has_linked_ancestor)
-
-  # Always add 'executable' targets. Even though they may be built by other
-  # targets that depend upon them it makes detection of what is going to be
-  # built easier.
-  # And always add static_libraries that have no dependencies on them from
-  # linkables. This is necessary as the other dependencies on them may be
-  # static libraries themselves, which are not compile time dependencies.
-  if target.in_roots and \
-        (target.is_executable or
-         (not target.added_to_compile_targets and
-          (add_if_no_ancestor or target.requires_build)) or
-         (target.is_static_library and add_if_no_ancestor and
-          not target.is_or_has_linked_ancestor)):
-    print('\t\tadding to compile targets', target.name, 'executable',
-           target.is_executable, 'added_to_compile_targets',
-           target.added_to_compile_targets, 'add_if_no_ancestor',
-           add_if_no_ancestor, 'requires_build', target.requires_build,
-           'is_static_library', target.is_static_library,
-           'is_or_has_linked_ancestor', target.is_or_has_linked_ancestor)
-    result.add(target)
-    target.added_to_compile_targets = True
+    if target.visited:
+        return
+
+    target.visited = True
+    target.in_roots = target in roots
+
+    for back_dep_target in target.back_deps:
+        _AddCompileTargets(back_dep_target, roots, False, result)
+        target.added_to_compile_targets |= back_dep_target.added_to_compile_targets
+        target.in_roots |= back_dep_target.in_roots
+        target.is_or_has_linked_ancestor |= back_dep_target.is_or_has_linked_ancestor
+
+    # Always add 'executable' targets. Even though they may be built by other
+    # targets that depend upon them it makes detection of what is going to be
+    # built easier.
+    # And always add static_libraries that have no dependencies on them from
+    # linkables. This is necessary as the other dependencies on them may be
+    # static libraries themselves, which are not compile time dependencies.
+    if target.in_roots and (
+        target.is_executable
+        or (
+            not target.added_to_compile_targets
+            and (add_if_no_ancestor or target.requires_build)
+        )
+        or (
+            target.is_static_library
+            and add_if_no_ancestor
+            and not target.is_or_has_linked_ancestor
+        )
+    ):
+        print(
+            "\t\tadding to compile targets",
+            target.name,
+            "executable",
+            target.is_executable,
+            "added_to_compile_targets",
+            target.added_to_compile_targets,
+            "add_if_no_ancestor",
+            add_if_no_ancestor,
+            "requires_build",
+            target.requires_build,
+            "is_static_library",
+            target.is_static_library,
+            "is_or_has_linked_ancestor",
+            target.is_or_has_linked_ancestor,
+        )
+        result.add(target)
+        target.added_to_compile_targets = True
 
 
 def _GetCompileTargets(matching_targets, supplied_targets):
-  """Returns the set of Targets that require a build.
+    """Returns the set of Targets that require a build.
   matching_targets: targets that changed and need to be built.
   supplied_targets: set of targets supplied to analyzer to search from."""
-  result = set()
-  for target in matching_targets:
-    print('finding compile targets for match', target.name)
-    _AddCompileTargets(target, supplied_targets, True, result)
-  return result
+    result = set()
+    for target in matching_targets:
+        print("finding compile targets for match", target.name)
+        _AddCompileTargets(target, supplied_targets, True, result)
+    return result
 
 
 def _WriteOutput(params, **values):
-  """Writes the output, either to stdout or a file is specified."""
-  if 'error' in values:
-    print('Error:', values['error'])
-  if 'status' in values:
-    print(values['status'])
-  if 'targets' in values:
-    values['targets'].sort()
-    print('Supplied targets that depend on changed files:')
-    for target in values['targets']:
-      print('\t', target)
-  if 'invalid_targets' in values:
-    values['invalid_targets'].sort()
-    print('The following targets were not found:')
-    for target in values['invalid_targets']:
-      print('\t', target)
-  if 'build_targets' in values:
-    values['build_targets'].sort()
-    print('Targets that require a build:')
-    for target in values['build_targets']:
-      print('\t', target)
-  if 'compile_targets' in values:
-    values['compile_targets'].sort()
-    print('Targets that need to be built:')
-    for target in values['compile_targets']:
-      print('\t', target)
-  if 'test_targets' in values:
-    values['test_targets'].sort()
-    print('Test targets:')
-    for target in values['test_targets']:
-      print('\t', target)
-
-  output_path = params.get('generator_flags', {}).get(
-      'analyzer_output_path', None)
-  if not output_path:
-    print(json.dumps(values))
-    return
-  try:
-    f = open(output_path, 'w')
-    f.write(json.dumps(values) + '\n')
-    f.close()
-  except IOError as e:
-    print('Error writing to output file', output_path, str(e))
+    """Writes the output, either to stdout or a file is specified."""
+    if "error" in values:
+        print("Error:", values["error"])
+    if "status" in values:
+        print(values["status"])
+    if "targets" in values:
+        values["targets"].sort()
+        print("Supplied targets that depend on changed files:")
+        for target in values["targets"]:
+            print("\t", target)
+    if "invalid_targets" in values:
+        values["invalid_targets"].sort()
+        print("The following targets were not found:")
+        for target in values["invalid_targets"]:
+            print("\t", target)
+    if "build_targets" in values:
+        values["build_targets"].sort()
+        print("Targets that require a build:")
+        for target in values["build_targets"]:
+            print("\t", target)
+    if "compile_targets" in values:
+        values["compile_targets"].sort()
+        print("Targets that need to be built:")
+        for target in values["compile_targets"]:
+            print("\t", target)
+    if "test_targets" in values:
+        values["test_targets"].sort()
+        print("Test targets:")
+        for target in values["test_targets"]:
+            print("\t", target)
+
+    output_path = params.get("generator_flags", {}).get("analyzer_output_path", None)
+    if not output_path:
+        print(json.dumps(values))
+        return
+    try:
+        f = open(output_path, "w")
+        f.write(json.dumps(values) + "\n")
+        f.close()
+    except IOError as e:
+        print("Error writing to output file", output_path, str(e))
 
 
 def _WasGypIncludeFileModified(params, files):
-  """Returns true if one of the files in |files| is in the set of included
+    """Returns true if one of the files in |files| is in the set of included
   files."""
-  if params['options'].includes:
-    for include in params['options'].includes:
-      if _ToGypPath(os.path.normpath(include)) in files:
-        print('Include file modified, assuming all changed', include)
-        return True
-  return False
+    if params["options"].includes:
+        for include in params["options"].includes:
+            if _ToGypPath(os.path.normpath(include)) in files:
+                print("Include file modified, assuming all changed", include)
+                return True
+    return False
 
 
 def _NamesNotIn(names, mapping):
-  """Returns a list of the values in |names| that are not in |mapping|."""
-  return [name for name in names if name not in mapping]
+    """Returns a list of the values in |names| that are not in |mapping|."""
+    return [name for name in names if name not in mapping]
 
 
 def _LookupTargets(names, mapping):
-  """Returns a list of the mapping[name] for each value in |names| that is in
+    """Returns a list of the mapping[name] for each value in |names| that is in
   |mapping|."""
-  return [mapping[name] for name in names if name in mapping]
+    return [mapping[name] for name in names if name in mapping]
 
 
 def CalculateVariables(default_variables, params):
-  """Calculate additional variables for use in the build (called by gyp)."""
-  flavor = gyp.common.GetFlavor(params)
-  if flavor == 'mac':
-    default_variables.setdefault('OS', 'mac')
-  elif flavor == 'win':
-    default_variables.setdefault('OS', 'win')
-    # Copy additional generator configuration data from VS, which is shared
-    # by the Windows Ninja generator.
-    import gyp.generator.msvs as msvs_generator
-    generator_additional_non_configuration_keys = getattr(msvs_generator,
-        'generator_additional_non_configuration_keys', [])
-    generator_additional_path_sections = getattr(msvs_generator,
-        'generator_additional_path_sections', [])
-
-    gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
-  else:
-    operating_system = flavor
-    if flavor == 'android':
-      operating_system = 'linux'  # Keep this legacy behavior for now.
-    default_variables.setdefault('OS', operating_system)
+    """Calculate additional variables for use in the build (called by gyp)."""
+    flavor = gyp.common.GetFlavor(params)
+    if flavor == "mac":
+        default_variables.setdefault("OS", "mac")
+    elif flavor == "win":
+        default_variables.setdefault("OS", "win")
+        gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
+    else:
+        operating_system = flavor
+        if flavor == "android":
+            operating_system = "linux"  # Keep this legacy behavior for now.
+        default_variables.setdefault("OS", operating_system)
 
 
 class TargetCalculator(object):
-  """Calculates the matching test_targets and matching compile_targets."""
-  def __init__(self, files, additional_compile_target_names, test_target_names,
-               data, target_list, target_dicts, toplevel_dir, build_files):
-    self._additional_compile_target_names = set(additional_compile_target_names)
-    self._test_target_names = set(test_target_names)
-    self._name_to_target, self._changed_targets, self._root_targets = (
-      _GenerateTargets(data, target_list, target_dicts, toplevel_dir,
-                       frozenset(files), build_files))
-    self._unqualified_mapping, self.invalid_targets = (
-      _GetUnqualifiedToTargetMapping(self._name_to_target,
-                                     self._supplied_target_names_no_all()))
-
-  def _supplied_target_names(self):
-    return self._additional_compile_target_names | self._test_target_names
-
-  def _supplied_target_names_no_all(self):
-    """Returns the supplied test targets without 'all'."""
-    result = self._supplied_target_names()
-    result.discard('all')
-    return result
-
-  def is_build_impacted(self):
-    """Returns true if the supplied files impact the build at all."""
-    return self._changed_targets
-
-  def find_matching_test_target_names(self):
-    """Returns the set of output test targets."""
-    assert self.is_build_impacted()
-    # Find the test targets first. 'all' is special cased to mean all the
-    # root targets. To deal with all the supplied |test_targets| are expanded
-    # to include the root targets during lookup. If any of the root targets
-    # match, we remove it and replace it with 'all'.
-    test_target_names_no_all = set(self._test_target_names)
-    test_target_names_no_all.discard('all')
-    test_targets_no_all = _LookupTargets(test_target_names_no_all,
-                                         self._unqualified_mapping)
-    test_target_names_contains_all = 'all' in self._test_target_names
-    if test_target_names_contains_all:
-      test_targets = [x for x in (set(test_targets_no_all) |
-                                  set(self._root_targets))]
-    else:
-      test_targets = [x for x in test_targets_no_all]
-    print('supplied test_targets')
-    for target_name in self._test_target_names:
-      print('\t', target_name)
-    print('found test_targets')
-    for target in test_targets:
-      print('\t', target.name)
-    print('searching for matching test targets')
-    matching_test_targets = _GetTargetsDependingOnMatchingTargets(test_targets)
-    matching_test_targets_contains_all = (test_target_names_contains_all and
-                                          set(matching_test_targets) &
-                                          set(self._root_targets))
-    if matching_test_targets_contains_all:
-      # Remove any of the targets for all that were not explicitly supplied,
-      # 'all' is subsequentely added to the matching names below.
-      matching_test_targets = [x for x in (set(matching_test_targets) &
-                                           set(test_targets_no_all))]
-    print('matched test_targets')
-    for target in matching_test_targets:
-      print('\t', target.name)
-    matching_target_names = [gyp.common.ParseQualifiedTarget(target.name)[1]
-                             for target in matching_test_targets]
-    if matching_test_targets_contains_all:
-      matching_target_names.append('all')
-      print('\tall')
-    return matching_target_names
-
-  def find_matching_compile_target_names(self):
-    """Returns the set of output compile targets."""
-    assert self.is_build_impacted()
-    # Compile targets are found by searching up from changed targets.
-    # Reset the visited status for _GetBuildTargets.
-    for target in self._name_to_target.values():
-      target.visited = False
-
-    supplied_targets = _LookupTargets(self._supplied_target_names_no_all(),
-                                      self._unqualified_mapping)
-    if 'all' in self._supplied_target_names():
-      supplied_targets = [x for x in (set(supplied_targets) |
-                                      set(self._root_targets))]
-    print('Supplied test_targets & compile_targets')
-    for target in supplied_targets:
-      print('\t', target.name)
-    print('Finding compile targets')
-    compile_targets = _GetCompileTargets(self._changed_targets,
-                                         supplied_targets)
-    return [gyp.common.ParseQualifiedTarget(target.name)[1]
-            for target in compile_targets]
+    """Calculates the matching test_targets and matching compile_targets."""
+
+    def __init__(
+        self,
+        files,
+        additional_compile_target_names,
+        test_target_names,
+        data,
+        target_list,
+        target_dicts,
+        toplevel_dir,
+        build_files,
+    ):
+        self._additional_compile_target_names = set(additional_compile_target_names)
+        self._test_target_names = set(test_target_names)
+        (
+            self._name_to_target,
+            self._changed_targets,
+            self._root_targets,
+        ) = _GenerateTargets(
+            data, target_list, target_dicts, toplevel_dir, frozenset(files), build_files
+        )
+        (
+            self._unqualified_mapping,
+            self.invalid_targets,
+        ) = _GetUnqualifiedToTargetMapping(
+            self._name_to_target, self._supplied_target_names_no_all()
+        )
+
+    def _supplied_target_names(self):
+        return self._additional_compile_target_names | self._test_target_names
+
+    def _supplied_target_names_no_all(self):
+        """Returns the supplied test targets without 'all'."""
+        result = self._supplied_target_names()
+        result.discard("all")
+        return result
+
+    def is_build_impacted(self):
+        """Returns true if the supplied files impact the build at all."""
+        return self._changed_targets
+
+    def find_matching_test_target_names(self):
+        """Returns the set of output test targets."""
+        assert self.is_build_impacted()
+        # Find the test targets first. 'all' is special cased to mean all the
+        # root targets. To deal with all the supplied |test_targets| are expanded
+        # to include the root targets during lookup. If any of the root targets
+        # match, we remove it and replace it with 'all'.
+        test_target_names_no_all = set(self._test_target_names)
+        test_target_names_no_all.discard("all")
+        test_targets_no_all = _LookupTargets(
+            test_target_names_no_all, self._unqualified_mapping
+        )
+        test_target_names_contains_all = "all" in self._test_target_names
+        if test_target_names_contains_all:
+            test_targets = [
+                x for x in (set(test_targets_no_all) | set(self._root_targets))
+            ]
+        else:
+            test_targets = [x for x in test_targets_no_all]
+        print("supplied test_targets")
+        for target_name in self._test_target_names:
+            print("\t", target_name)
+        print("found test_targets")
+        for target in test_targets:
+            print("\t", target.name)
+        print("searching for matching test targets")
+        matching_test_targets = _GetTargetsDependingOnMatchingTargets(test_targets)
+        matching_test_targets_contains_all = test_target_names_contains_all and set(
+            matching_test_targets
+        ) & set(self._root_targets)
+        if matching_test_targets_contains_all:
+            # Remove any of the targets for all that were not explicitly supplied,
+            # 'all' is subsequentely added to the matching names below.
+            matching_test_targets = [
+                x for x in (set(matching_test_targets) & set(test_targets_no_all))
+            ]
+        print("matched test_targets")
+        for target in matching_test_targets:
+            print("\t", target.name)
+        matching_target_names = [
+            gyp.common.ParseQualifiedTarget(target.name)[1]
+            for target in matching_test_targets
+        ]
+        if matching_test_targets_contains_all:
+            matching_target_names.append("all")
+            print("\tall")
+        return matching_target_names
+
+    def find_matching_compile_target_names(self):
+        """Returns the set of output compile targets."""
+        assert self.is_build_impacted()
+        # Compile targets are found by searching up from changed targets.
+        # Reset the visited status for _GetBuildTargets.
+        for target in self._name_to_target.values():
+            target.visited = False
+
+        supplied_targets = _LookupTargets(
+            self._supplied_target_names_no_all(), self._unqualified_mapping
+        )
+        if "all" in self._supplied_target_names():
+            supplied_targets = [
+                x for x in (set(supplied_targets) | set(self._root_targets))
+            ]
+        print("Supplied test_targets & compile_targets")
+        for target in supplied_targets:
+            print("\t", target.name)
+        print("Finding compile targets")
+        compile_targets = _GetCompileTargets(self._changed_targets, supplied_targets)
+        return [
+            gyp.common.ParseQualifiedTarget(target.name)[1]
+            for target in compile_targets
+        ]
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  """Called by gyp as the final stage. Outputs results."""
-  config = Config()
-  try:
-    config.Init(params)
-
-    if not config.files:
-      raise Exception('Must specify files to analyze via config_path generator '
-                      'flag')
-
-    toplevel_dir = _ToGypPath(os.path.abspath(params['options'].toplevel_dir))
-    if debug:
-      print('toplevel_dir', toplevel_dir)
-
-    if _WasGypIncludeFileModified(params, config.files):
-      result_dict = { 'status': all_changed_string,
-                      'test_targets': list(config.test_target_names),
-                      'compile_targets': list(
-                        config.additional_compile_target_names |
-                        config.test_target_names) }
-      _WriteOutput(params, **result_dict)
-      return
-
-    calculator = TargetCalculator(config.files,
-                                  config.additional_compile_target_names,
-                                  config.test_target_names, data,
-                                  target_list, target_dicts, toplevel_dir,
-                                  params['build_files'])
-    if not calculator.is_build_impacted():
-      result_dict = { 'status': no_dependency_string,
-                      'test_targets': [],
-                      'compile_targets': [] }
-      if calculator.invalid_targets:
-        result_dict['invalid_targets'] = calculator.invalid_targets
-      _WriteOutput(params, **result_dict)
-      return
-
-    test_target_names = calculator.find_matching_test_target_names()
-    compile_target_names = calculator.find_matching_compile_target_names()
-    found_at_least_one_target = compile_target_names or test_target_names
-    result_dict = { 'test_targets': test_target_names,
-                    'status': found_dependency_string if
-                        found_at_least_one_target else no_dependency_string,
-                    'compile_targets': list(
-                        set(compile_target_names) |
-                        set(test_target_names)) }
-    if calculator.invalid_targets:
-      result_dict['invalid_targets'] = calculator.invalid_targets
-    _WriteOutput(params, **result_dict)
-
-  except Exception as e:
-    _WriteOutput(params, error=str(e))
+    """Called by gyp as the final stage. Outputs results."""
+    config = Config()
+    try:
+        config.Init(params)
+
+        if not config.files:
+            raise Exception(
+                "Must specify files to analyze via config_path generator " "flag"
+            )
+
+        toplevel_dir = _ToGypPath(os.path.abspath(params["options"].toplevel_dir))
+        if debug:
+            print("toplevel_dir", toplevel_dir)
+
+        if _WasGypIncludeFileModified(params, config.files):
+            result_dict = {
+                "status": all_changed_string,
+                "test_targets": list(config.test_target_names),
+                "compile_targets": list(
+                    config.additional_compile_target_names | config.test_target_names
+                ),
+            }
+            _WriteOutput(params, **result_dict)
+            return
+
+        calculator = TargetCalculator(
+            config.files,
+            config.additional_compile_target_names,
+            config.test_target_names,
+            data,
+            target_list,
+            target_dicts,
+            toplevel_dir,
+            params["build_files"],
+        )
+        if not calculator.is_build_impacted():
+            result_dict = {
+                "status": no_dependency_string,
+                "test_targets": [],
+                "compile_targets": [],
+            }
+            if calculator.invalid_targets:
+                result_dict["invalid_targets"] = calculator.invalid_targets
+            _WriteOutput(params, **result_dict)
+            return
+
+        test_target_names = calculator.find_matching_test_target_names()
+        compile_target_names = calculator.find_matching_compile_target_names()
+        found_at_least_one_target = compile_target_names or test_target_names
+        result_dict = {
+            "test_targets": test_target_names,
+            "status": found_dependency_string
+            if found_at_least_one_target
+            else no_dependency_string,
+            "compile_targets": list(set(compile_target_names) | set(test_target_names)),
+        }
+        if calculator.invalid_targets:
+            result_dict["invalid_targets"] = calculator.invalid_targets
+        _WriteOutput(params, **result_dict)
+
+    except Exception as e:
+        _WriteOutput(params, error=str(e))
diff --git a/tools/gyp/pylib/gyp/generator/android.py b/tools/gyp/pylib/gyp/generator/android.py
index cecb28c3660b5e936f18155d0308950ff9bedd2e..16728847c5c9f27e32b014015a60c256748d8a14 100644
--- a/tools/gyp/pylib/gyp/generator/android.py
+++ b/tools/gyp/pylib/gyp/generator/android.py
@@ -24,24 +24,24 @@ import re
 import subprocess
 
 generator_default_variables = {
-  'OS': 'android',
-  'EXECUTABLE_PREFIX': '',
-  'EXECUTABLE_SUFFIX': '',
-  'STATIC_LIB_PREFIX': 'lib',
-  'SHARED_LIB_PREFIX': 'lib',
-  'STATIC_LIB_SUFFIX': '.a',
-  'SHARED_LIB_SUFFIX': '.so',
-  'INTERMEDIATE_DIR': '$(gyp_intermediate_dir)',
-  'SHARED_INTERMEDIATE_DIR': '$(gyp_shared_intermediate_dir)',
-  'PRODUCT_DIR': '$(gyp_shared_intermediate_dir)',
-  'SHARED_LIB_DIR': '$(builddir)/lib.$(TOOLSET)',
-  'LIB_DIR': '$(obj).$(TOOLSET)',
-  'RULE_INPUT_ROOT': '%(INPUT_ROOT)s',  # This gets expanded by Python.
-  'RULE_INPUT_DIRNAME': '%(INPUT_DIRNAME)s',  # This gets expanded by Python.
-  'RULE_INPUT_PATH': '$(RULE_SOURCES)',
-  'RULE_INPUT_EXT': '$(suffix $<)',
-  'RULE_INPUT_NAME': '$(notdir $<)',
-  'CONFIGURATION_NAME': '$(GYP_CONFIGURATION)',
+    "OS": "android",
+    "EXECUTABLE_PREFIX": "",
+    "EXECUTABLE_SUFFIX": "",
+    "STATIC_LIB_PREFIX": "lib",
+    "SHARED_LIB_PREFIX": "lib",
+    "STATIC_LIB_SUFFIX": ".a",
+    "SHARED_LIB_SUFFIX": ".so",
+    "INTERMEDIATE_DIR": "$(gyp_intermediate_dir)",
+    "SHARED_INTERMEDIATE_DIR": "$(gyp_shared_intermediate_dir)",
+    "PRODUCT_DIR": "$(gyp_shared_intermediate_dir)",
+    "SHARED_LIB_DIR": "$(builddir)/lib.$(TOOLSET)",
+    "LIB_DIR": "$(obj).$(TOOLSET)",
+    "RULE_INPUT_ROOT": "%(INPUT_ROOT)s",  # This gets expanded by Python.
+    "RULE_INPUT_DIRNAME": "%(INPUT_DIRNAME)s",  # This gets expanded by Python.
+    "RULE_INPUT_PATH": "$(RULE_SOURCES)",
+    "RULE_INPUT_EXT": "$(suffix $<)",
+    "RULE_INPUT_NAME": "$(notdir $<)",
+    "CONFIGURATION_NAME": "$(GYP_CONFIGURATION)",
 }
 
 # Make supports multiple toolsets
@@ -51,9 +51,9 @@ generator_supports_multiple_toolsets = True
 # Generator-specific gyp specs.
 generator_additional_non_configuration_keys = [
     # Boolean to declare that this target does not want its name mangled.
-    'android_unmangled_name',
+    "android_unmangled_name",
     # Map of android build system variables to set.
-    'aosp_build_settings',
+    "aosp_build_settings",
 ]
 generator_additional_path_sections = []
 generator_extra_sources_for_rules = []
@@ -72,20 +72,20 @@ header = """\
 
 # Map gyp target types to Android module classes.
 MODULE_CLASSES = {
-    'static_library': 'STATIC_LIBRARIES',
-    'shared_library': 'SHARED_LIBRARIES',
-    'executable': 'EXECUTABLES',
+    "static_library": "STATIC_LIBRARIES",
+    "shared_library": "SHARED_LIBRARIES",
+    "executable": "EXECUTABLES",
 }
 
 
 def IsCPPExtension(ext):
-  return make.COMPILABLE_EXTENSIONS.get(ext) == 'cxx'
+    return make.COMPILABLE_EXTENSIONS.get(ext) == "cxx"
 
 
 def Sourceify(path):
-  """Convert a path to its source directory form. The Android backend does not
+    """Convert a path to its source directory form. The Android backend does not
      support options.generator_output, so this function is a noop."""
-  return path
+    return path
 
 
 # Map from qualified target to path to output.
@@ -101,17 +101,27 @@ target_link_deps = {}
 
 
 class AndroidMkWriter(object):
-  """AndroidMkWriter packages up the writing of one target-specific Android.mk.
+    """AndroidMkWriter packages up the writing of one target-specific Android.mk.
 
   Its only real entry point is Write(), and is mostly used for namespacing.
   """
 
-  def __init__(self, android_top_dir):
-    self.android_top_dir = android_top_dir
-
-  def Write(self, qualified_target, relative_target, base_path, output_filename,
-            spec, configs, part_of_all, write_alias_target, sdk_version):
-    """The main entry point: writes a .mk file for a single target.
+    def __init__(self, android_top_dir):
+        self.android_top_dir = android_top_dir
+
+    def Write(
+        self,
+        qualified_target,
+        relative_target,
+        base_path,
+        output_filename,
+        spec,
+        configs,
+        part_of_all,
+        write_alias_target,
+        sdk_version,
+    ):
+        """The main entry point: writes a .mk file for a single target.
 
     Arguments:
       qualified_target: target we're generating
@@ -125,114 +135,124 @@ class AndroidMkWriter(object):
                           this target
       sdk_version: what to emit for LOCAL_SDK_VERSION in output
     """
-    gyp.common.EnsureDirExists(output_filename)
-
-    self.fp = open(output_filename, 'w')
-
-    self.fp.write(header)
-
-    self.qualified_target = qualified_target
-    self.relative_target = relative_target
-    self.path = base_path
-    self.target = spec['target_name']
-    self.type = spec['type']
-    self.toolset = spec['toolset']
-
-    deps, link_deps = self.ComputeDeps(spec)
-
-    # Some of the generation below can add extra output, sources, or
-    # link dependencies.  All of the out params of the functions that
-    # follow use names like extra_foo.
-    extra_outputs = []
-    extra_sources = []
-
-    self.android_class = MODULE_CLASSES.get(self.type, 'GYP')
-    self.android_module = self.ComputeAndroidModule(spec)
-    (self.android_stem, self.android_suffix) = self.ComputeOutputParts(spec)
-    self.output = self.output_binary = self.ComputeOutput(spec)
-
-    # Standard header.
-    self.WriteLn('include $(CLEAR_VARS)\n')
-
-    # Module class and name.
-    self.WriteLn('LOCAL_MODULE_CLASS := ' + self.android_class)
-    self.WriteLn('LOCAL_MODULE := ' + self.android_module)
-    # Only emit LOCAL_MODULE_STEM if it's different to LOCAL_MODULE.
-    # The library module classes fail if the stem is set. ComputeOutputParts
-    # makes sure that stem == modulename in these cases.
-    if self.android_stem != self.android_module:
-      self.WriteLn('LOCAL_MODULE_STEM := ' + self.android_stem)
-    self.WriteLn('LOCAL_MODULE_SUFFIX := ' + self.android_suffix)
-    if self.toolset == 'host':
-      self.WriteLn('LOCAL_IS_HOST_MODULE := true')
-      self.WriteLn('LOCAL_MULTILIB := $(GYP_HOST_MULTILIB)')
-    elif sdk_version > 0:
-      self.WriteLn('LOCAL_MODULE_TARGET_ARCH := '
-                   '$(TARGET_$(GYP_VAR_PREFIX)ARCH)')
-      self.WriteLn('LOCAL_SDK_VERSION := %s' % sdk_version)
-
-    # Grab output directories; needed for Actions and Rules.
-    if self.toolset == 'host':
-      self.WriteLn('gyp_intermediate_dir := '
-                   '$(call local-intermediates-dir,,$(GYP_HOST_VAR_PREFIX))')
-    else:
-      self.WriteLn('gyp_intermediate_dir := '
-                   '$(call local-intermediates-dir,,$(GYP_VAR_PREFIX))')
-    self.WriteLn('gyp_shared_intermediate_dir := '
-                 '$(call intermediates-dir-for,GYP,shared,,,$(GYP_VAR_PREFIX))')
-    self.WriteLn()
-
-    # List files this target depends on so that actions/rules/copies/sources
-    # can depend on the list.
-    # TODO: doesn't pull in things through transitive link deps; needed?
-    target_dependencies = [x[1] for x in deps if x[0] == 'path']
-    self.WriteLn('# Make sure our deps are built first.')
-    self.WriteList(target_dependencies, 'GYP_TARGET_DEPENDENCIES',
-                   local_pathify=True)
-
-    # Actions must come first, since they can generate more OBJs for use below.
-    if 'actions' in spec:
-      self.WriteActions(spec['actions'], extra_sources, extra_outputs)
-
-    # Rules must be early like actions.
-    if 'rules' in spec:
-      self.WriteRules(spec['rules'], extra_sources, extra_outputs)
-
-    if 'copies' in spec:
-      self.WriteCopies(spec['copies'], extra_outputs)
-
-    # GYP generated outputs.
-    self.WriteList(extra_outputs, 'GYP_GENERATED_OUTPUTS', local_pathify=True)
-
-    # Set LOCAL_ADDITIONAL_DEPENDENCIES so that Android's build rules depend
-    # on both our dependency targets and our generated files.
-    self.WriteLn('# Make sure our deps and generated files are built first.')
-    self.WriteLn('LOCAL_ADDITIONAL_DEPENDENCIES := $(GYP_TARGET_DEPENDENCIES) '
-                 '$(GYP_GENERATED_OUTPUTS)')
-    self.WriteLn()
-
-    # Sources.
-    if spec.get('sources', []) or extra_sources:
-      self.WriteSources(spec, configs, extra_sources)
-
-    self.WriteTarget(spec, configs, deps, link_deps, part_of_all,
-                     write_alias_target)
-
-    # Update global list of target outputs, used in dependency tracking.
-    target_outputs[qualified_target] = ('path', self.output_binary)
-
-    # Update global list of link dependencies.
-    if self.type == 'static_library':
-      target_link_deps[qualified_target] = ('static', self.android_module)
-    elif self.type == 'shared_library':
-      target_link_deps[qualified_target] = ('shared', self.android_module)
-
-    self.fp.close()
-    return self.android_module
-
-
-  def WriteActions(self, actions, extra_sources, extra_outputs):
-    """Write Makefile code for any 'actions' from the gyp input.
+        gyp.common.EnsureDirExists(output_filename)
+
+        self.fp = open(output_filename, "w")
+
+        self.fp.write(header)
+
+        self.qualified_target = qualified_target
+        self.relative_target = relative_target
+        self.path = base_path
+        self.target = spec["target_name"]
+        self.type = spec["type"]
+        self.toolset = spec["toolset"]
+
+        deps, link_deps = self.ComputeDeps(spec)
+
+        # Some of the generation below can add extra output, sources, or
+        # link dependencies.  All of the out params of the functions that
+        # follow use names like extra_foo.
+        extra_outputs = []
+        extra_sources = []
+
+        self.android_class = MODULE_CLASSES.get(self.type, "GYP")
+        self.android_module = self.ComputeAndroidModule(spec)
+        (self.android_stem, self.android_suffix) = self.ComputeOutputParts(spec)
+        self.output = self.output_binary = self.ComputeOutput(spec)
+
+        # Standard header.
+        self.WriteLn("include $(CLEAR_VARS)\n")
+
+        # Module class and name.
+        self.WriteLn("LOCAL_MODULE_CLASS := " + self.android_class)
+        self.WriteLn("LOCAL_MODULE := " + self.android_module)
+        # Only emit LOCAL_MODULE_STEM if it's different to LOCAL_MODULE.
+        # The library module classes fail if the stem is set. ComputeOutputParts
+        # makes sure that stem == modulename in these cases.
+        if self.android_stem != self.android_module:
+            self.WriteLn("LOCAL_MODULE_STEM := " + self.android_stem)
+        self.WriteLn("LOCAL_MODULE_SUFFIX := " + self.android_suffix)
+        if self.toolset == "host":
+            self.WriteLn("LOCAL_IS_HOST_MODULE := true")
+            self.WriteLn("LOCAL_MULTILIB := $(GYP_HOST_MULTILIB)")
+        elif sdk_version > 0:
+            self.WriteLn(
+                "LOCAL_MODULE_TARGET_ARCH := " "$(TARGET_$(GYP_VAR_PREFIX)ARCH)"
+            )
+            self.WriteLn("LOCAL_SDK_VERSION := %s" % sdk_version)
+
+        # Grab output directories; needed for Actions and Rules.
+        if self.toolset == "host":
+            self.WriteLn(
+                "gyp_intermediate_dir := "
+                "$(call local-intermediates-dir,,$(GYP_HOST_VAR_PREFIX))"
+            )
+        else:
+            self.WriteLn(
+                "gyp_intermediate_dir := "
+                "$(call local-intermediates-dir,,$(GYP_VAR_PREFIX))"
+            )
+        self.WriteLn(
+            "gyp_shared_intermediate_dir := "
+            "$(call intermediates-dir-for,GYP,shared,,,$(GYP_VAR_PREFIX))"
+        )
+        self.WriteLn()
+
+        # List files this target depends on so that actions/rules/copies/sources
+        # can depend on the list.
+        # TODO: doesn't pull in things through transitive link deps; needed?
+        target_dependencies = [x[1] for x in deps if x[0] == "path"]
+        self.WriteLn("# Make sure our deps are built first.")
+        self.WriteList(
+            target_dependencies, "GYP_TARGET_DEPENDENCIES", local_pathify=True
+        )
+
+        # Actions must come first, since they can generate more OBJs for use below.
+        if "actions" in spec:
+            self.WriteActions(spec["actions"], extra_sources, extra_outputs)
+
+        # Rules must be early like actions.
+        if "rules" in spec:
+            self.WriteRules(spec["rules"], extra_sources, extra_outputs)
+
+        if "copies" in spec:
+            self.WriteCopies(spec["copies"], extra_outputs)
+
+        # GYP generated outputs.
+        self.WriteList(extra_outputs, "GYP_GENERATED_OUTPUTS", local_pathify=True)
+
+        # Set LOCAL_ADDITIONAL_DEPENDENCIES so that Android's build rules depend
+        # on both our dependency targets and our generated files.
+        self.WriteLn("# Make sure our deps and generated files are built first.")
+        self.WriteLn(
+            "LOCAL_ADDITIONAL_DEPENDENCIES := $(GYP_TARGET_DEPENDENCIES) "
+            "$(GYP_GENERATED_OUTPUTS)"
+        )
+        self.WriteLn()
+
+        # Sources.
+        if spec.get("sources", []) or extra_sources:
+            self.WriteSources(spec, configs, extra_sources)
+
+        self.WriteTarget(
+            spec, configs, deps, link_deps, part_of_all, write_alias_target
+        )
+
+        # Update global list of target outputs, used in dependency tracking.
+        target_outputs[qualified_target] = ("path", self.output_binary)
+
+        # Update global list of link dependencies.
+        if self.type == "static_library":
+            target_link_deps[qualified_target] = ("static", self.android_module)
+        elif self.type == "shared_library":
+            target_link_deps[qualified_target] = ("shared", self.android_module)
+
+        self.fp.close()
+        return self.android_module
+
+    def WriteActions(self, actions, extra_sources, extra_outputs):
+        """Write Makefile code for any 'actions' from the gyp input.
 
     extra_sources: a list that will be filled in with newly generated source
                    files, if any
@@ -240,457 +260,496 @@ class AndroidMkWriter(object):
                    actions (used to make other pieces dependent on these
                    actions)
     """
-    for action in actions:
-      name = make.StringToMakefileVariable('%s_%s' % (self.relative_target,
-                                                      action['action_name']))
-      self.WriteLn('### Rules for action "%s":' % action['action_name'])
-      inputs = action['inputs']
-      outputs = action['outputs']
-
-      # Build up a list of outputs.
-      # Collect the output dirs we'll need.
-      dirs = set()
-      for out in outputs:
-        if not out.startswith('$'):
-          print('WARNING: Action for target "%s" writes output to local path '
-                 '"%s".' % (self.target, out))
-        dir = os.path.split(out)[0]
-        if dir:
-          dirs.add(dir)
-      if int(action.get('process_outputs_as_sources', False)):
-        extra_sources += outputs
-
-      # Prepare the actual command.
-      command = gyp.common.EncodePOSIXShellList(action['action'])
-      if 'message' in action:
-        quiet_cmd = 'Gyp action: %s ($@)' % action['message']
-      else:
-        quiet_cmd = 'Gyp action: %s ($@)' % name
-      if len(dirs) > 0:
-        command = 'mkdir -p %s' % ' '.join(dirs) + '; ' + command
-
-      cd_action = 'cd $(gyp_local_path)/%s; ' % self.path
-      command = cd_action + command
-
-      # The makefile rules are all relative to the top dir, but the gyp actions
-      # are defined relative to their containing dir.  This replaces the gyp_*
-      # variables for the action rule with an absolute version so that the
-      # output goes in the right place.
-      # Only write the gyp_* rules for the "primary" output (:1);
-      # it's superfluous for the "extra outputs", and this avoids accidentally
-      # writing duplicate dummy rules for those outputs.
-      main_output = make.QuoteSpaces(self.LocalPathify(outputs[0]))
-      self.WriteLn('%s: gyp_local_path := $(LOCAL_PATH)' % main_output)
-      self.WriteLn('%s: gyp_var_prefix := $(GYP_VAR_PREFIX)' % main_output)
-      self.WriteLn('%s: gyp_intermediate_dir := '
-                   '$(abspath $(gyp_intermediate_dir))' % main_output)
-      self.WriteLn('%s: gyp_shared_intermediate_dir := '
-                   '$(abspath $(gyp_shared_intermediate_dir))' % main_output)
-
-      # Android's envsetup.sh adds a number of directories to the path including
-      # the built host binary directory. This causes actions/rules invoked by
-      # gyp to sometimes use these instead of system versions, e.g. bison.
-      # The built host binaries may not be suitable, and can cause errors.
-      # So, we remove them from the PATH using the ANDROID_BUILD_PATHS variable
-      # set by envsetup.
-      self.WriteLn('%s: export PATH := $(subst $(ANDROID_BUILD_PATHS),,$(PATH))'
-                   % main_output)
-
-      # Don't allow spaces in input/output filenames, but make an exception for
-      # filenames which start with '$(' since it's okay for there to be spaces
-      # inside of make function/macro invocations.
-      for input in inputs:
-        if not input.startswith('$(') and ' ' in input:
-          raise gyp.common.GypError(
-              'Action input filename "%s" in target %s contains a space' %
-              (input, self.target))
-      for output in outputs:
-        if not output.startswith('$(') and ' ' in output:
-          raise gyp.common.GypError(
-              'Action output filename "%s" in target %s contains a space' %
-              (output, self.target))
-
-      self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES)' %
-                   (main_output, ' '.join(map(self.LocalPathify, inputs))))
-      self.WriteLn('\t@echo "%s"' % quiet_cmd)
-      self.WriteLn('\t$(hide)%s\n' % command)
-      for output in outputs[1:]:
-        # Make each output depend on the main output, with an empty command
-        # to force make to notice that the mtime has changed.
-        self.WriteLn('%s: %s ;' % (self.LocalPathify(output), main_output))
-
-      extra_outputs += outputs
-      self.WriteLn()
-
-    self.WriteLn()
-
-
-  def WriteRules(self, rules, extra_sources, extra_outputs):
-    """Write Makefile code for any 'rules' from the gyp input.
+        for action in actions:
+            name = make.StringToMakefileVariable(
+                "%s_%s" % (self.relative_target, action["action_name"])
+            )
+            self.WriteLn('### Rules for action "%s":' % action["action_name"])
+            inputs = action["inputs"]
+            outputs = action["outputs"]
+
+            # Build up a list of outputs.
+            # Collect the output dirs we'll need.
+            dirs = set()
+            for out in outputs:
+                if not out.startswith("$"):
+                    print(
+                        'WARNING: Action for target "%s" writes output to local path '
+                        '"%s".' % (self.target, out)
+                    )
+                dir = os.path.split(out)[0]
+                if dir:
+                    dirs.add(dir)
+            if int(action.get("process_outputs_as_sources", False)):
+                extra_sources += outputs
+
+            # Prepare the actual command.
+            command = gyp.common.EncodePOSIXShellList(action["action"])
+            if "message" in action:
+                quiet_cmd = "Gyp action: %s ($@)" % action["message"]
+            else:
+                quiet_cmd = "Gyp action: %s ($@)" % name
+            if len(dirs) > 0:
+                command = "mkdir -p %s" % " ".join(dirs) + "; " + command
+
+            cd_action = "cd $(gyp_local_path)/%s; " % self.path
+            command = cd_action + command
+
+            # The makefile rules are all relative to the top dir, but the gyp actions
+            # are defined relative to their containing dir.  This replaces the gyp_*
+            # variables for the action rule with an absolute version so that the
+            # output goes in the right place.
+            # Only write the gyp_* rules for the "primary" output (:1);
+            # it's superfluous for the "extra outputs", and this avoids accidentally
+            # writing duplicate dummy rules for those outputs.
+            main_output = make.QuoteSpaces(self.LocalPathify(outputs[0]))
+            self.WriteLn("%s: gyp_local_path := $(LOCAL_PATH)" % main_output)
+            self.WriteLn("%s: gyp_var_prefix := $(GYP_VAR_PREFIX)" % main_output)
+            self.WriteLn(
+                "%s: gyp_intermediate_dir := "
+                "$(abspath $(gyp_intermediate_dir))" % main_output
+            )
+            self.WriteLn(
+                "%s: gyp_shared_intermediate_dir := "
+                "$(abspath $(gyp_shared_intermediate_dir))" % main_output
+            )
+
+            # Android's envsetup.sh adds a number of directories to the path including
+            # the built host binary directory. This causes actions/rules invoked by
+            # gyp to sometimes use these instead of system versions, e.g. bison.
+            # The built host binaries may not be suitable, and can cause errors.
+            # So, we remove them from the PATH using the ANDROID_BUILD_PATHS variable
+            # set by envsetup.
+            self.WriteLn(
+                "%s: export PATH := $(subst $(ANDROID_BUILD_PATHS),,$(PATH))"
+                % main_output
+            )
+
+            # Don't allow spaces in input/output filenames, but make an exception for
+            # filenames which start with '$(' since it's okay for there to be spaces
+            # inside of make function/macro invocations.
+            for input in inputs:
+                if not input.startswith("$(") and " " in input:
+                    raise gyp.common.GypError(
+                        'Action input filename "%s" in target %s contains a space'
+                        % (input, self.target)
+                    )
+            for output in outputs:
+                if not output.startswith("$(") and " " in output:
+                    raise gyp.common.GypError(
+                        'Action output filename "%s" in target %s contains a space'
+                        % (output, self.target)
+                    )
+
+            self.WriteLn(
+                "%s: %s $(GYP_TARGET_DEPENDENCIES)"
+                % (main_output, " ".join(map(self.LocalPathify, inputs)))
+            )
+            self.WriteLn('\t@echo "%s"' % quiet_cmd)
+            self.WriteLn("\t$(hide)%s\n" % command)
+            for output in outputs[1:]:
+                # Make each output depend on the main output, with an empty command
+                # to force make to notice that the mtime has changed.
+                self.WriteLn("%s: %s ;" % (self.LocalPathify(output), main_output))
+
+            extra_outputs += outputs
+            self.WriteLn()
+
+        self.WriteLn()
+
+    def WriteRules(self, rules, extra_sources, extra_outputs):
+        """Write Makefile code for any 'rules' from the gyp input.
 
     extra_sources: a list that will be filled in with newly generated source
                    files, if any
     extra_outputs: a list that will be filled in with any outputs of these
                    rules (used to make other pieces dependent on these rules)
     """
-    if len(rules) == 0:
-      return
-
-    for rule in rules:
-      if len(rule.get('rule_sources', [])) == 0:
-        continue
-      name = make.StringToMakefileVariable('%s_%s' % (self.relative_target,
-                                                      rule['rule_name']))
-      self.WriteLn('\n### Generated for rule "%s":' % name)
-      self.WriteLn('# "%s":' % rule)
-
-      inputs = rule.get('inputs')
-      for rule_source in rule.get('rule_sources', []):
-        (rule_source_dirname, rule_source_basename) = os.path.split(rule_source)
-        (rule_source_root, rule_source_ext) = \
-            os.path.splitext(rule_source_basename)
-
-        outputs = [self.ExpandInputRoot(out, rule_source_root,
-                                        rule_source_dirname)
-                   for out in rule['outputs']]
-
-        dirs = set()
-        for out in outputs:
-          if not out.startswith('$'):
-            print('WARNING: Rule for target %s writes output to local path %s'
-                   % (self.target, out))
-          dir = os.path.dirname(out)
-          if dir:
-            dirs.add(dir)
-        extra_outputs += outputs
-        if int(rule.get('process_outputs_as_sources', False)):
-          extra_sources.extend(outputs)
-
-        components = []
-        for component in rule['action']:
-          component = self.ExpandInputRoot(component, rule_source_root,
-                                           rule_source_dirname)
-          if '$(RULE_SOURCES)' in component:
-            component = component.replace('$(RULE_SOURCES)',
-                                          rule_source)
-          components.append(component)
-
-        command = gyp.common.EncodePOSIXShellList(components)
-        cd_action = 'cd $(gyp_local_path)/%s; ' % self.path
-        command = cd_action + command
-        if dirs:
-          command = 'mkdir -p %s' % ' '.join(dirs) + '; ' + command
-
-        # We set up a rule to build the first output, and then set up
-        # a rule for each additional output to depend on the first.
-        outputs = map(self.LocalPathify, outputs)
-        main_output = outputs[0]
-        self.WriteLn('%s: gyp_local_path := $(LOCAL_PATH)' % main_output)
-        self.WriteLn('%s: gyp_var_prefix := $(GYP_VAR_PREFIX)' % main_output)
-        self.WriteLn('%s: gyp_intermediate_dir := '
-                     '$(abspath $(gyp_intermediate_dir))' % main_output)
-        self.WriteLn('%s: gyp_shared_intermediate_dir := '
-                     '$(abspath $(gyp_shared_intermediate_dir))' % main_output)
-
-        # See explanation in WriteActions.
-        self.WriteLn('%s: export PATH := '
-                     '$(subst $(ANDROID_BUILD_PATHS),,$(PATH))' % main_output)
-
-        main_output_deps = self.LocalPathify(rule_source)
-        if inputs:
-          main_output_deps += ' '
-          main_output_deps += ' '.join([self.LocalPathify(f) for f in inputs])
-
-        self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES)' %
-                     (main_output, main_output_deps))
-        self.WriteLn('\t%s\n' % command)
-        for output in outputs[1:]:
-          # Make each output depend on the main output, with an empty command
-          # to force make to notice that the mtime has changed.
-          self.WriteLn('%s: %s ;' % (output, main_output))
-        self.WriteLn()
-
-    self.WriteLn()
+        if len(rules) == 0:
+            return
+
+        for rule in rules:
+            if len(rule.get("rule_sources", [])) == 0:
+                continue
+            name = make.StringToMakefileVariable(
+                "%s_%s" % (self.relative_target, rule["rule_name"])
+            )
+            self.WriteLn('\n### Generated for rule "%s":' % name)
+            self.WriteLn('# "%s":' % rule)
+
+            inputs = rule.get("inputs")
+            for rule_source in rule.get("rule_sources", []):
+                (rule_source_dirname, rule_source_basename) = os.path.split(rule_source)
+                (rule_source_root, rule_source_ext) = os.path.splitext(
+                    rule_source_basename
+                )
+
+                outputs = [
+                    self.ExpandInputRoot(out, rule_source_root, rule_source_dirname)
+                    for out in rule["outputs"]
+                ]
+
+                dirs = set()
+                for out in outputs:
+                    if not out.startswith("$"):
+                        print(
+                            "WARNING: Rule for target %s writes output to local path %s"
+                            % (self.target, out)
+                        )
+                    dir = os.path.dirname(out)
+                    if dir:
+                        dirs.add(dir)
+                extra_outputs += outputs
+                if int(rule.get("process_outputs_as_sources", False)):
+                    extra_sources.extend(outputs)
+
+                components = []
+                for component in rule["action"]:
+                    component = self.ExpandInputRoot(
+                        component, rule_source_root, rule_source_dirname
+                    )
+                    if "$(RULE_SOURCES)" in component:
+                        component = component.replace("$(RULE_SOURCES)", rule_source)
+                    components.append(component)
+
+                command = gyp.common.EncodePOSIXShellList(components)
+                cd_action = "cd $(gyp_local_path)/%s; " % self.path
+                command = cd_action + command
+                if dirs:
+                    command = "mkdir -p %s" % " ".join(dirs) + "; " + command
+
+                # We set up a rule to build the first output, and then set up
+                # a rule for each additional output to depend on the first.
+                outputs = map(self.LocalPathify, outputs)
+                main_output = outputs[0]
+                self.WriteLn("%s: gyp_local_path := $(LOCAL_PATH)" % main_output)
+                self.WriteLn("%s: gyp_var_prefix := $(GYP_VAR_PREFIX)" % main_output)
+                self.WriteLn(
+                    "%s: gyp_intermediate_dir := "
+                    "$(abspath $(gyp_intermediate_dir))" % main_output
+                )
+                self.WriteLn(
+                    "%s: gyp_shared_intermediate_dir := "
+                    "$(abspath $(gyp_shared_intermediate_dir))" % main_output
+                )
+
+                # See explanation in WriteActions.
+                self.WriteLn(
+                    "%s: export PATH := "
+                    "$(subst $(ANDROID_BUILD_PATHS),,$(PATH))" % main_output
+                )
+
+                main_output_deps = self.LocalPathify(rule_source)
+                if inputs:
+                    main_output_deps += " "
+                    main_output_deps += " ".join([self.LocalPathify(f) for f in inputs])
+
+                self.WriteLn(
+                    "%s: %s $(GYP_TARGET_DEPENDENCIES)"
+                    % (main_output, main_output_deps)
+                )
+                self.WriteLn("\t%s\n" % command)
+                for output in outputs[1:]:
+                    # Make each output depend on the main output, with an empty command
+                    # to force make to notice that the mtime has changed.
+                    self.WriteLn("%s: %s ;" % (output, main_output))
+                self.WriteLn()
 
+        self.WriteLn()
 
-  def WriteCopies(self, copies, extra_outputs):
-    """Write Makefile code for any 'copies' from the gyp input.
+    def WriteCopies(self, copies, extra_outputs):
+        """Write Makefile code for any 'copies' from the gyp input.
 
     extra_outputs: a list that will be filled in with any outputs of this action
                    (used to make other pieces dependent on this action)
     """
-    self.WriteLn('### Generated for copy rule.')
-
-    variable = make.StringToMakefileVariable(self.relative_target + '_copies')
-    outputs = []
-    for copy in copies:
-      for path in copy['files']:
-        # The Android build system does not allow generation of files into the
-        # source tree. The destination should start with a variable, which will
-        # typically be $(gyp_intermediate_dir) or
-        # $(gyp_shared_intermediate_dir). Note that we can't use an assertion
-        # because some of the gyp tests depend on this.
-        if not copy['destination'].startswith('$'):
-          print('WARNING: Copy rule for target %s writes output to '
-                 'local path %s' % (self.target, copy['destination']))
-
-        # LocalPathify() calls normpath, stripping trailing slashes.
-        path = Sourceify(self.LocalPathify(path))
-        filename = os.path.split(path)[1]
-        output = Sourceify(self.LocalPathify(os.path.join(copy['destination'],
-                                                          filename)))
-
-        self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES) | $(ACP)' %
-                     (output, path))
-        self.WriteLn('\t@echo Copying: $@')
-        self.WriteLn('\t$(hide) mkdir -p $(dir $@)')
-        self.WriteLn('\t$(hide) $(ACP) -rpf $< $@')
+        self.WriteLn("### Generated for copy rule.")
+
+        variable = make.StringToMakefileVariable(self.relative_target + "_copies")
+        outputs = []
+        for copy in copies:
+            for path in copy["files"]:
+                # The Android build system does not allow generation of files into the
+                # source tree. The destination should start with a variable, which will
+                # typically be $(gyp_intermediate_dir) or
+                # $(gyp_shared_intermediate_dir). Note that we can't use an assertion
+                # because some of the gyp tests depend on this.
+                if not copy["destination"].startswith("$"):
+                    print(
+                        "WARNING: Copy rule for target %s writes output to "
+                        "local path %s" % (self.target, copy["destination"])
+                    )
+
+                # LocalPathify() calls normpath, stripping trailing slashes.
+                path = Sourceify(self.LocalPathify(path))
+                filename = os.path.split(path)[1]
+                output = Sourceify(
+                    self.LocalPathify(os.path.join(copy["destination"], filename))
+                )
+
+                self.WriteLn(
+                    "%s: %s $(GYP_TARGET_DEPENDENCIES) | $(ACP)" % (output, path)
+                )
+                self.WriteLn("\t@echo Copying: $@")
+                self.WriteLn("\t$(hide) mkdir -p $(dir $@)")
+                self.WriteLn("\t$(hide) $(ACP) -rpf $< $@")
+                self.WriteLn()
+                outputs.append(output)
+        self.WriteLn("%s = %s" % (variable, " ".join(map(make.QuoteSpaces, outputs))))
+        extra_outputs.append("$(%s)" % variable)
         self.WriteLn()
-        outputs.append(output)
-    self.WriteLn('%s = %s' % (variable,
-                              ' '.join(map(make.QuoteSpaces, outputs))))
-    extra_outputs.append('$(%s)' % variable)
-    self.WriteLn()
 
-
-  def WriteSourceFlags(self, spec, configs):
-    """Write out the flags and include paths used to compile source files for
+    def WriteSourceFlags(self, spec, configs):
+        """Write out the flags and include paths used to compile source files for
     the current target.
 
     Args:
       spec, configs: input from gyp.
     """
-    for configname, config in sorted(configs.items()):
-      extracted_includes = []
-
-      self.WriteLn('\n# Flags passed to both C and C++ files.')
-      cflags, includes_from_cflags = self.ExtractIncludesFromCFlags(
-          config.get('cflags', []) + config.get('cflags_c', []))
-      extracted_includes.extend(includes_from_cflags)
-      self.WriteList(cflags, 'MY_CFLAGS_%s' % configname)
-
-      self.WriteList(config.get('defines'), 'MY_DEFS_%s' % configname,
-                     prefix='-D', quoter=make.EscapeCppDefine)
-
-      self.WriteLn('\n# Include paths placed before CFLAGS/CPPFLAGS')
-      includes = list(config.get('include_dirs', []))
-      includes.extend(extracted_includes)
-      includes = map(Sourceify, map(self.LocalPathify, includes))
-      includes = self.NormalizeIncludePaths(includes)
-      self.WriteList(includes, 'LOCAL_C_INCLUDES_%s' % configname)
-
-      self.WriteLn('\n# Flags passed to only C++ (and not C) files.')
-      self.WriteList(config.get('cflags_cc'), 'LOCAL_CPPFLAGS_%s' % configname)
-
-    self.WriteLn('\nLOCAL_CFLAGS := $(MY_CFLAGS_$(GYP_CONFIGURATION)) '
-                 '$(MY_DEFS_$(GYP_CONFIGURATION))')
-    # Undefine ANDROID for host modules
-    # TODO: the source code should not use macro ANDROID to tell if it's host
-    # or target module.
-    if self.toolset == 'host':
-      self.WriteLn('# Undefine ANDROID for host modules')
-      self.WriteLn('LOCAL_CFLAGS += -UANDROID')
-    self.WriteLn('LOCAL_C_INCLUDES := $(GYP_COPIED_SOURCE_ORIGIN_DIRS) '
-                                     '$(LOCAL_C_INCLUDES_$(GYP_CONFIGURATION))')
-    self.WriteLn('LOCAL_CPPFLAGS := $(LOCAL_CPPFLAGS_$(GYP_CONFIGURATION))')
-    # Android uses separate flags for assembly file invocations, but gyp expects
-    # the same CFLAGS to be applied:
-    self.WriteLn('LOCAL_ASFLAGS := $(LOCAL_CFLAGS)')
-
-
-  def WriteSources(self, spec, configs, extra_sources):
-    """Write Makefile code for any 'sources' from the gyp input.
+        for configname, config in sorted(configs.items()):
+            extracted_includes = []
+
+            self.WriteLn("\n# Flags passed to both C and C++ files.")
+            cflags, includes_from_cflags = self.ExtractIncludesFromCFlags(
+                config.get("cflags", []) + config.get("cflags_c", [])
+            )
+            extracted_includes.extend(includes_from_cflags)
+            self.WriteList(cflags, "MY_CFLAGS_%s" % configname)
+
+            self.WriteList(
+                config.get("defines"),
+                "MY_DEFS_%s" % configname,
+                prefix="-D",
+                quoter=make.EscapeCppDefine,
+            )
+
+            self.WriteLn("\n# Include paths placed before CFLAGS/CPPFLAGS")
+            includes = list(config.get("include_dirs", []))
+            includes.extend(extracted_includes)
+            includes = map(Sourceify, map(self.LocalPathify, includes))
+            includes = self.NormalizeIncludePaths(includes)
+            self.WriteList(includes, "LOCAL_C_INCLUDES_%s" % configname)
+
+            self.WriteLn("\n# Flags passed to only C++ (and not C) files.")
+            self.WriteList(config.get("cflags_cc"), "LOCAL_CPPFLAGS_%s" % configname)
+
+        self.WriteLn(
+            "\nLOCAL_CFLAGS := $(MY_CFLAGS_$(GYP_CONFIGURATION)) "
+            "$(MY_DEFS_$(GYP_CONFIGURATION))"
+        )
+        # Undefine ANDROID for host modules
+        # TODO: the source code should not use macro ANDROID to tell if it's host
+        # or target module.
+        if self.toolset == "host":
+            self.WriteLn("# Undefine ANDROID for host modules")
+            self.WriteLn("LOCAL_CFLAGS += -UANDROID")
+        self.WriteLn(
+            "LOCAL_C_INCLUDES := $(GYP_COPIED_SOURCE_ORIGIN_DIRS) "
+            "$(LOCAL_C_INCLUDES_$(GYP_CONFIGURATION))"
+        )
+        self.WriteLn("LOCAL_CPPFLAGS := $(LOCAL_CPPFLAGS_$(GYP_CONFIGURATION))")
+        # Android uses separate flags for assembly file invocations, but gyp expects
+        # the same CFLAGS to be applied:
+        self.WriteLn("LOCAL_ASFLAGS := $(LOCAL_CFLAGS)")
+
+    def WriteSources(self, spec, configs, extra_sources):
+        """Write Makefile code for any 'sources' from the gyp input.
     These are source files necessary to build the current target.
     We need to handle shared_intermediate directory source files as
     a special case by copying them to the intermediate directory and
-    treating them as a genereated sources. Otherwise the Android build
+    treating them as a generated sources. Otherwise the Android build
     rules won't pick them up.
 
     Args:
       spec, configs: input from gyp.
       extra_sources: Sources generated from Actions or Rules.
     """
-    sources = filter(make.Compilable, spec.get('sources', []))
-    generated_not_sources = [x for x in extra_sources if not make.Compilable(x)]
-    extra_sources = filter(make.Compilable, extra_sources)
-
-    # Determine and output the C++ extension used by these sources.
-    # We simply find the first C++ file and use that extension.
-    all_sources = sources + extra_sources
-    local_cpp_extension = '.cpp'
-    for source in all_sources:
-      (root, ext) = os.path.splitext(source)
-      if IsCPPExtension(ext):
-        local_cpp_extension = ext
-        break
-    if local_cpp_extension != '.cpp':
-      self.WriteLn('LOCAL_CPP_EXTENSION := %s' % local_cpp_extension)
-
-    # We need to move any non-generated sources that are coming from the
-    # shared intermediate directory out of LOCAL_SRC_FILES and put them
-    # into LOCAL_GENERATED_SOURCES. We also need to move over any C++ files
-    # that don't match our local_cpp_extension, since Android will only
-    # generate Makefile rules for a single LOCAL_CPP_EXTENSION.
-    local_files = []
-    for source in sources:
-      (root, ext) = os.path.splitext(source)
-      if '$(gyp_shared_intermediate_dir)' in source:
-        extra_sources.append(source)
-      elif '$(gyp_intermediate_dir)' in source:
-        extra_sources.append(source)
-      elif IsCPPExtension(ext) and ext != local_cpp_extension:
-        extra_sources.append(source)
-      else:
-        local_files.append(os.path.normpath(os.path.join(self.path, source)))
-
-    # For any generated source, if it is coming from the shared intermediate
-    # directory then we add a Make rule to copy them to the local intermediate
-    # directory first. This is because the Android LOCAL_GENERATED_SOURCES
-    # must be in the local module intermediate directory for the compile rules
-    # to work properly. If the file has the wrong C++ extension, then we add
-    # a rule to copy that to intermediates and use the new version.
-    final_generated_sources = []
-    # If a source file gets copied, we still need to add the original source
-    # directory as header search path, for GCC searches headers in the
-    # directory that contains the source file by default.
-    origin_src_dirs = []
-    for source in extra_sources:
-      local_file = source
-      if not '$(gyp_intermediate_dir)/' in local_file:
-        basename = os.path.basename(local_file)
-        local_file = '$(gyp_intermediate_dir)/' + basename
-      (root, ext) = os.path.splitext(local_file)
-      if IsCPPExtension(ext) and ext != local_cpp_extension:
-        local_file = root + local_cpp_extension
-      if local_file != source:
-        self.WriteLn('%s: %s' % (local_file, self.LocalPathify(source)))
-        self.WriteLn('\tmkdir -p $(@D); cp $< $@')
-        origin_src_dirs.append(os.path.dirname(source))
-      final_generated_sources.append(local_file)
-
-    # We add back in all of the non-compilable stuff to make sure that the
-    # make rules have dependencies on them.
-    final_generated_sources.extend(generated_not_sources)
-    self.WriteList(final_generated_sources, 'LOCAL_GENERATED_SOURCES')
-
-    origin_src_dirs = gyp.common.uniquer(origin_src_dirs)
-    origin_src_dirs = map(Sourceify, map(self.LocalPathify, origin_src_dirs))
-    self.WriteList(origin_src_dirs, 'GYP_COPIED_SOURCE_ORIGIN_DIRS')
-
-    self.WriteList(local_files, 'LOCAL_SRC_FILES')
-
-    # Write out the flags used to compile the source; this must be done last
-    # so that GYP_COPIED_SOURCE_ORIGIN_DIRS can be used as an include path.
-    self.WriteSourceFlags(spec, configs)
-
-
-  def ComputeAndroidModule(self, spec):
-    """Return the Android module name used for a gyp spec.
+        sources = filter(make.Compilable, spec.get("sources", []))
+        generated_not_sources = [x for x in extra_sources if not make.Compilable(x)]
+        extra_sources = filter(make.Compilable, extra_sources)
+
+        # Determine and output the C++ extension used by these sources.
+        # We simply find the first C++ file and use that extension.
+        all_sources = sources + extra_sources
+        local_cpp_extension = ".cpp"
+        for source in all_sources:
+            (root, ext) = os.path.splitext(source)
+            if IsCPPExtension(ext):
+                local_cpp_extension = ext
+                break
+        if local_cpp_extension != ".cpp":
+            self.WriteLn("LOCAL_CPP_EXTENSION := %s" % local_cpp_extension)
+
+        # We need to move any non-generated sources that are coming from the
+        # shared intermediate directory out of LOCAL_SRC_FILES and put them
+        # into LOCAL_GENERATED_SOURCES. We also need to move over any C++ files
+        # that don't match our local_cpp_extension, since Android will only
+        # generate Makefile rules for a single LOCAL_CPP_EXTENSION.
+        local_files = []
+        for source in sources:
+            (root, ext) = os.path.splitext(source)
+            if "$(gyp_shared_intermediate_dir)" in source:
+                extra_sources.append(source)
+            elif "$(gyp_intermediate_dir)" in source:
+                extra_sources.append(source)
+            elif IsCPPExtension(ext) and ext != local_cpp_extension:
+                extra_sources.append(source)
+            else:
+                local_files.append(os.path.normpath(os.path.join(self.path, source)))
+
+        # For any generated source, if it is coming from the shared intermediate
+        # directory then we add a Make rule to copy them to the local intermediate
+        # directory first. This is because the Android LOCAL_GENERATED_SOURCES
+        # must be in the local module intermediate directory for the compile rules
+        # to work properly. If the file has the wrong C++ extension, then we add
+        # a rule to copy that to intermediates and use the new version.
+        final_generated_sources = []
+        # If a source file gets copied, we still need to add the original source
+        # directory as header search path, for GCC searches headers in the
+        # directory that contains the source file by default.
+        origin_src_dirs = []
+        for source in extra_sources:
+            local_file = source
+            if "$(gyp_intermediate_dir)/" not in local_file:
+                basename = os.path.basename(local_file)
+                local_file = "$(gyp_intermediate_dir)/" + basename
+            (root, ext) = os.path.splitext(local_file)
+            if IsCPPExtension(ext) and ext != local_cpp_extension:
+                local_file = root + local_cpp_extension
+            if local_file != source:
+                self.WriteLn("%s: %s" % (local_file, self.LocalPathify(source)))
+                self.WriteLn("\tmkdir -p $(@D); cp $< $@")
+                origin_src_dirs.append(os.path.dirname(source))
+            final_generated_sources.append(local_file)
+
+        # We add back in all of the non-compilable stuff to make sure that the
+        # make rules have dependencies on them.
+        final_generated_sources.extend(generated_not_sources)
+        self.WriteList(final_generated_sources, "LOCAL_GENERATED_SOURCES")
+
+        origin_src_dirs = gyp.common.uniquer(origin_src_dirs)
+        origin_src_dirs = map(Sourceify, map(self.LocalPathify, origin_src_dirs))
+        self.WriteList(origin_src_dirs, "GYP_COPIED_SOURCE_ORIGIN_DIRS")
+
+        self.WriteList(local_files, "LOCAL_SRC_FILES")
+
+        # Write out the flags used to compile the source; this must be done last
+        # so that GYP_COPIED_SOURCE_ORIGIN_DIRS can be used as an include path.
+        self.WriteSourceFlags(spec, configs)
+
+    def ComputeAndroidModule(self, spec):
+        """Return the Android module name used for a gyp spec.
 
     We use the complete qualified target name to avoid collisions between
     duplicate targets in different directories. We also add a suffix to
     distinguish gyp-generated module names.
     """
 
-    if int(spec.get('android_unmangled_name', 0)):
-      assert self.type != 'shared_library' or self.target.startswith('lib')
-      return self.target
-
-    if self.type == 'shared_library':
-      # For reasons of convention, the Android build system requires that all
-      # shared library modules are named 'libfoo' when generating -l flags.
-      prefix = 'lib_'
-    else:
-      prefix = ''
+        if int(spec.get("android_unmangled_name", 0)):
+            assert self.type != "shared_library" or self.target.startswith("lib")
+            return self.target
 
-    if spec['toolset'] == 'host':
-      suffix = '_$(TARGET_$(GYP_VAR_PREFIX)ARCH)_host_gyp'
-    else:
-      suffix = '_gyp'
+        if self.type == "shared_library":
+            # For reasons of convention, the Android build system requires that all
+            # shared library modules are named 'libfoo' when generating -l flags.
+            prefix = "lib_"
+        else:
+            prefix = ""
 
-    if self.path:
-      middle = make.StringToMakefileVariable('%s_%s' % (self.path, self.target))
-    else:
-      middle = make.StringToMakefileVariable(self.target)
+        if spec["toolset"] == "host":
+            suffix = "_$(TARGET_$(GYP_VAR_PREFIX)ARCH)_host_gyp"
+        else:
+            suffix = "_gyp"
 
-    return ''.join([prefix, middle, suffix])
+        if self.path:
+            middle = make.StringToMakefileVariable("%s_%s" % (self.path, self.target))
+        else:
+            middle = make.StringToMakefileVariable(self.target)
 
+        return "".join([prefix, middle, suffix])
 
-  def ComputeOutputParts(self, spec):
-    """Return the 'output basename' of a gyp spec, split into filename + ext.
+    def ComputeOutputParts(self, spec):
+        """Return the 'output basename' of a gyp spec, split into filename + ext.
 
     Android libraries must be named the same thing as their module name,
     otherwise the linker can't find them, so product_name and so on must be
     ignored if we are building a library, and the "lib" prepending is
     not done for Android.
     """
-    assert self.type != 'loadable_module' # TODO: not supported?
-
-    target = spec['target_name']
-    target_prefix = ''
-    target_ext = ''
-    if self.type == 'static_library':
-      target = self.ComputeAndroidModule(spec)
-      target_ext = '.a'
-    elif self.type == 'shared_library':
-      target = self.ComputeAndroidModule(spec)
-      target_ext = '.so'
-    elif self.type == 'none':
-      target_ext = '.stamp'
-    elif self.type != 'executable':
-      print("ERROR: What output file should be generated?",
-             "type", self.type, "target", target)
-
-    if self.type != 'static_library' and self.type != 'shared_library':
-      target_prefix = spec.get('product_prefix', target_prefix)
-      target = spec.get('product_name', target)
-      product_ext = spec.get('product_extension')
-      if product_ext:
-        target_ext = '.' + product_ext
-
-    target_stem = target_prefix + target
-    return (target_stem, target_ext)
-
-
-  def ComputeOutputBasename(self, spec):
-    """Return the 'output basename' of a gyp spec.
+        assert self.type != "loadable_module"  # TODO: not supported?
+
+        target = spec["target_name"]
+        target_prefix = ""
+        target_ext = ""
+        if self.type == "static_library":
+            target = self.ComputeAndroidModule(spec)
+            target_ext = ".a"
+        elif self.type == "shared_library":
+            target = self.ComputeAndroidModule(spec)
+            target_ext = ".so"
+        elif self.type == "none":
+            target_ext = ".stamp"
+        elif self.type != "executable":
+            print(
+                "ERROR: What output file should be generated?",
+                "type",
+                self.type,
+                "target",
+                target,
+            )
+
+        if self.type != "static_library" and self.type != "shared_library":
+            target_prefix = spec.get("product_prefix", target_prefix)
+            target = spec.get("product_name", target)
+            product_ext = spec.get("product_extension")
+            if product_ext:
+                target_ext = "." + product_ext
+
+        target_stem = target_prefix + target
+        return (target_stem, target_ext)
+
+    def ComputeOutputBasename(self, spec):
+        """Return the 'output basename' of a gyp spec.
 
     E.g., the loadable module 'foobar' in directory 'baz' will produce
       'libfoobar.so'
     """
-    return ''.join(self.ComputeOutputParts(spec))
-
+        return "".join(self.ComputeOutputParts(spec))
 
-  def ComputeOutput(self, spec):
-    """Return the 'output' (full output path) of a gyp spec.
+    def ComputeOutput(self, spec):
+        """Return the 'output' (full output path) of a gyp spec.
 
     E.g., the loadable module 'foobar' in directory 'baz' will produce
       '$(obj)/baz/libfoobar.so'
     """
-    if self.type == 'executable':
-      # We install host executables into shared_intermediate_dir so they can be
-      # run by gyp rules that refer to PRODUCT_DIR.
-      path = '$(gyp_shared_intermediate_dir)'
-    elif self.type == 'shared_library':
-      if self.toolset == 'host':
-        path = '$($(GYP_HOST_VAR_PREFIX)HOST_OUT_INTERMEDIATE_LIBRARIES)'
-      else:
-        path = '$($(GYP_VAR_PREFIX)TARGET_OUT_INTERMEDIATE_LIBRARIES)'
-    else:
-      # Other targets just get built into their intermediate dir.
-      if self.toolset == 'host':
-        path = ('$(call intermediates-dir-for,%s,%s,true,,'
-                '$(GYP_HOST_VAR_PREFIX))' % (self.android_class,
-                                             self.android_module))
-      else:
-        path = ('$(call intermediates-dir-for,%s,%s,,,$(GYP_VAR_PREFIX))'
-                % (self.android_class, self.android_module))
-
-    assert spec.get('product_dir') is None # TODO: not supported?
-    return os.path.join(path, self.ComputeOutputBasename(spec))
-
-  def NormalizeIncludePaths(self, include_paths):
-    """ Normalize include_paths.
+        if self.type == "executable":
+            # We install host executables into shared_intermediate_dir so they can be
+            # run by gyp rules that refer to PRODUCT_DIR.
+            path = "$(gyp_shared_intermediate_dir)"
+        elif self.type == "shared_library":
+            if self.toolset == "host":
+                path = "$($(GYP_HOST_VAR_PREFIX)HOST_OUT_INTERMEDIATE_LIBRARIES)"
+            else:
+                path = "$($(GYP_VAR_PREFIX)TARGET_OUT_INTERMEDIATE_LIBRARIES)"
+        else:
+            # Other targets just get built into their intermediate dir.
+            if self.toolset == "host":
+                path = (
+                    "$(call intermediates-dir-for,%s,%s,true,,"
+                    "$(GYP_HOST_VAR_PREFIX))"
+                    % (self.android_class, self.android_module)
+                )
+            else:
+                path = "$(call intermediates-dir-for,%s,%s,,,$(GYP_VAR_PREFIX))" % (
+                    self.android_class,
+                    self.android_module,
+                )
+
+        assert spec.get("product_dir") is None  # TODO: not supported?
+        return os.path.join(path, self.ComputeOutputBasename(spec))
+
+    def NormalizeIncludePaths(self, include_paths):
+        """ Normalize include_paths.
     Convert absolute paths to relative to the Android top directory.
 
     Args:
@@ -698,33 +757,33 @@ class AndroidMkWriter(object):
     Returns:
       A list of normalized include paths.
     """
-    normalized = []
-    for path in include_paths:
-      if path[0] == '/':
-        path = gyp.common.RelativePath(path, self.android_top_dir)
-      normalized.append(path)
-    return normalized
+        normalized = []
+        for path in include_paths:
+            if path[0] == "/":
+                path = gyp.common.RelativePath(path, self.android_top_dir)
+            normalized.append(path)
+        return normalized
 
-  def ExtractIncludesFromCFlags(self, cflags):
-    """Extract includes "-I..." out from cflags
+    def ExtractIncludesFromCFlags(self, cflags):
+        """Extract includes "-I..." out from cflags
 
     Args:
       cflags: A list of compiler flags, which may be mixed with "-I.."
     Returns:
       A tuple of lists: (clean_clfags, include_paths). "-I.." is trimmed.
     """
-    clean_cflags = []
-    include_paths = []
-    for flag in cflags:
-      if flag.startswith('-I'):
-        include_paths.append(flag[2:])
-      else:
-        clean_cflags.append(flag)
+        clean_cflags = []
+        include_paths = []
+        for flag in cflags:
+            if flag.startswith("-I"):
+                include_paths.append(flag[2:])
+            else:
+                clean_cflags.append(flag)
 
-    return (clean_cflags, include_paths)
+        return (clean_cflags, include_paths)
 
-  def FilterLibraries(self, libraries):
-    """Filter the 'libraries' key to separate things that shouldn't be ldflags.
+    def FilterLibraries(self, libraries):
+        """Filter the 'libraries' key to separate things that shouldn't be ldflags.
 
     Library entries that look like filenames should be converted to android
     module names instead of being passed to the linker as flags.
@@ -734,96 +793,103 @@ class AndroidMkWriter(object):
     Returns:
       A tuple (static_lib_modules, dynamic_lib_modules, ldflags)
     """
-    static_lib_modules = []
-    dynamic_lib_modules = []
-    ldflags = []
-    for libs in libraries:
-      # Libs can have multiple words.
-      for lib in libs.split():
-        # Filter the system libraries, which are added by default by the Android
-        # build system.
-        if (lib == '-lc' or lib == '-lstdc++' or lib == '-lm' or
-            lib.endswith('libgcc.a')):
-          continue
-        match = re.search(r'([^/]+)\.a$', lib)
-        if match:
-          static_lib_modules.append(match.group(1))
-          continue
-        match = re.search(r'([^/]+)\.so$', lib)
-        if match:
-          dynamic_lib_modules.append(match.group(1))
-          continue
-        if lib.startswith('-l'):
-          ldflags.append(lib)
-    return (static_lib_modules, dynamic_lib_modules, ldflags)
-
-
-  def ComputeDeps(self, spec):
-    """Compute the dependencies of a gyp spec.
+        static_lib_modules = []
+        dynamic_lib_modules = []
+        ldflags = []
+        for libs in libraries:
+            # Libs can have multiple words.
+            for lib in libs.split():
+                # Filter the system libraries, which are added by default by the Android
+                # build system.
+                if (
+                    lib == "-lc"
+                    or lib == "-lstdc++"
+                    or lib == "-lm"
+                    or lib.endswith("libgcc.a")
+                ):
+                    continue
+                match = re.search(r"([^/]+)\.a$", lib)
+                if match:
+                    static_lib_modules.append(match.group(1))
+                    continue
+                match = re.search(r"([^/]+)\.so$", lib)
+                if match:
+                    dynamic_lib_modules.append(match.group(1))
+                    continue
+                if lib.startswith("-l"):
+                    ldflags.append(lib)
+        return (static_lib_modules, dynamic_lib_modules, ldflags)
+
+    def ComputeDeps(self, spec):
+        """Compute the dependencies of a gyp spec.
 
     Returns a tuple (deps, link_deps), where each is a list of
     filenames that will need to be put in front of make for either
     building (deps) or linking (link_deps).
     """
-    deps = []
-    link_deps = []
-    if 'dependencies' in spec:
-      deps.extend([target_outputs[dep] for dep in spec['dependencies']
-                   if target_outputs[dep]])
-      for dep in spec['dependencies']:
-        if dep in target_link_deps:
-          link_deps.append(target_link_deps[dep])
-      deps.extend(link_deps)
-    return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
-
-
-  def WriteTargetFlags(self, spec, configs, link_deps):
-    """Write Makefile code to specify the link flags and library dependencies.
+        deps = []
+        link_deps = []
+        if "dependencies" in spec:
+            deps.extend(
+                [
+                    target_outputs[dep]
+                    for dep in spec["dependencies"]
+                    if target_outputs[dep]
+                ]
+            )
+            for dep in spec["dependencies"]:
+                if dep in target_link_deps:
+                    link_deps.append(target_link_deps[dep])
+            deps.extend(link_deps)
+        return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
+
+    def WriteTargetFlags(self, spec, configs, link_deps):
+        """Write Makefile code to specify the link flags and library dependencies.
 
     spec, configs: input from gyp.
     link_deps: link dependency list; see ComputeDeps()
     """
-    # Libraries (i.e. -lfoo)
-    # These must be included even for static libraries as some of them provide
-    # implicit include paths through the build system.
-    libraries = gyp.common.uniquer(spec.get('libraries', []))
-    static_libs, dynamic_libs, ldflags_libs = self.FilterLibraries(libraries)
-
-    if self.type != 'static_library':
-      for configname, config in sorted(configs.items()):
-        ldflags = list(config.get('ldflags', []))
-        self.WriteLn('')
-        self.WriteList(ldflags, 'LOCAL_LDFLAGS_%s' % configname)
-      self.WriteList(ldflags_libs, 'LOCAL_GYP_LIBS')
-      self.WriteLn('LOCAL_LDFLAGS := $(LOCAL_LDFLAGS_$(GYP_CONFIGURATION)) '
-                   '$(LOCAL_GYP_LIBS)')
-
-    # Link dependencies (i.e. other gyp targets this target depends on)
-    # These need not be included for static libraries as within the gyp build
-    # we do not use the implicit include path mechanism.
-    if self.type != 'static_library':
-      static_link_deps = [x[1] for x in link_deps if x[0] == 'static']
-      shared_link_deps = [x[1] for x in link_deps if x[0] == 'shared']
-    else:
-      static_link_deps = []
-      shared_link_deps = []
-
-    # Only write the lists if they are non-empty.
-    if static_libs or static_link_deps:
-      self.WriteLn('')
-      self.WriteList(static_libs + static_link_deps,
-                     'LOCAL_STATIC_LIBRARIES')
-      self.WriteLn('# Enable grouping to fix circular references')
-      self.WriteLn('LOCAL_GROUP_STATIC_LIBRARIES := true')
-    if dynamic_libs or shared_link_deps:
-      self.WriteLn('')
-      self.WriteList(dynamic_libs + shared_link_deps,
-                     'LOCAL_SHARED_LIBRARIES')
-
-
-  def WriteTarget(self, spec, configs, deps, link_deps, part_of_all,
-                  write_alias_target):
-    """Write Makefile code to produce the final target of the gyp spec.
+        # Libraries (i.e. -lfoo)
+        # These must be included even for static libraries as some of them provide
+        # implicit include paths through the build system.
+        libraries = gyp.common.uniquer(spec.get("libraries", []))
+        static_libs, dynamic_libs, ldflags_libs = self.FilterLibraries(libraries)
+
+        if self.type != "static_library":
+            for configname, config in sorted(configs.items()):
+                ldflags = list(config.get("ldflags", []))
+                self.WriteLn("")
+                self.WriteList(ldflags, "LOCAL_LDFLAGS_%s" % configname)
+            self.WriteList(ldflags_libs, "LOCAL_GYP_LIBS")
+            self.WriteLn(
+                "LOCAL_LDFLAGS := $(LOCAL_LDFLAGS_$(GYP_CONFIGURATION)) "
+                "$(LOCAL_GYP_LIBS)"
+            )
+
+        # Link dependencies (i.e. other gyp targets this target depends on)
+        # These need not be included for static libraries as within the gyp build
+        # we do not use the implicit include path mechanism.
+        if self.type != "static_library":
+            static_link_deps = [x[1] for x in link_deps if x[0] == "static"]
+            shared_link_deps = [x[1] for x in link_deps if x[0] == "shared"]
+        else:
+            static_link_deps = []
+            shared_link_deps = []
+
+        # Only write the lists if they are non-empty.
+        if static_libs or static_link_deps:
+            self.WriteLn("")
+            self.WriteList(static_libs + static_link_deps, "LOCAL_STATIC_LIBRARIES")
+            self.WriteLn("# Enable grouping to fix circular references")
+            self.WriteLn("LOCAL_GROUP_STATIC_LIBRARIES := true")
+        if dynamic_libs or shared_link_deps:
+            self.WriteLn("")
+            self.WriteList(dynamic_libs + shared_link_deps, "LOCAL_SHARED_LIBRARIES")
+
+    def WriteTarget(
+        self, spec, configs, deps, link_deps, part_of_all, write_alias_target
+    ):
+        """Write Makefile code to produce the final target of the gyp spec.
 
     spec, configs: input from gyp.
     deps, link_deps: dependency lists; see ComputeDeps()
@@ -831,267 +897,278 @@ class AndroidMkWriter(object):
     write_alias_target: flag indicating whether to create short aliases for this
                         target
     """
-    self.WriteLn('### Rules for final target.')
-
-    if self.type != 'none':
-      self.WriteTargetFlags(spec, configs, link_deps)
-
-    settings = spec.get('aosp_build_settings', {})
-    if settings:
-      self.WriteLn('### Set directly by aosp_build_settings.')
-      for k, v in settings.items():
-        if isinstance(v, list):
-          self.WriteList(v, k)
+        self.WriteLn("### Rules for final target.")
+
+        if self.type != "none":
+            self.WriteTargetFlags(spec, configs, link_deps)
+
+        settings = spec.get("aosp_build_settings", {})
+        if settings:
+            self.WriteLn("### Set directly by aosp_build_settings.")
+            for k, v in settings.items():
+                if isinstance(v, list):
+                    self.WriteList(v, k)
+                else:
+                    self.WriteLn("%s := %s" % (k, make.QuoteIfNecessary(v)))
+            self.WriteLn("")
+
+        # Add to the set of targets which represent the gyp 'all' target. We use the
+        # name 'gyp_all_modules' as the Android build system doesn't allow the use
+        # of the Make target 'all' and because 'all_modules' is the equivalent of
+        # the Make target 'all' on Android.
+        if part_of_all and write_alias_target:
+            self.WriteLn('# Add target alias to "gyp_all_modules" target.')
+            self.WriteLn(".PHONY: gyp_all_modules")
+            self.WriteLn("gyp_all_modules: %s" % self.android_module)
+            self.WriteLn("")
+
+        # Add an alias from the gyp target name to the Android module name. This
+        # simplifies manual builds of the target, and is required by the test
+        # framework.
+        if self.target != self.android_module and write_alias_target:
+            self.WriteLn("# Alias gyp target name.")
+            self.WriteLn(".PHONY: %s" % self.target)
+            self.WriteLn("%s: %s" % (self.target, self.android_module))
+            self.WriteLn("")
+
+        # Add the command to trigger build of the target type depending
+        # on the toolset. Ex: BUILD_STATIC_LIBRARY vs. BUILD_HOST_STATIC_LIBRARY
+        # NOTE: This has to come last!
+        modifier = ""
+        if self.toolset == "host":
+            modifier = "HOST_"
+        if self.type == "static_library":
+            self.WriteLn("include $(BUILD_%sSTATIC_LIBRARY)" % modifier)
+        elif self.type == "shared_library":
+            self.WriteLn("LOCAL_PRELINK_MODULE := false")
+            self.WriteLn("include $(BUILD_%sSHARED_LIBRARY)" % modifier)
+        elif self.type == "executable":
+            self.WriteLn("LOCAL_CXX_STL := libc++_static")
+            # Executables are for build and test purposes only, so they're installed
+            # to a directory that doesn't get included in the system image.
+            self.WriteLn("LOCAL_MODULE_PATH := $(gyp_shared_intermediate_dir)")
+            self.WriteLn("include $(BUILD_%sEXECUTABLE)" % modifier)
         else:
-          self.WriteLn('%s := %s' % (k, make.QuoteIfNecessary(v)))
-      self.WriteLn('')
-
-    # Add to the set of targets which represent the gyp 'all' target. We use the
-    # name 'gyp_all_modules' as the Android build system doesn't allow the use
-    # of the Make target 'all' and because 'all_modules' is the equivalent of
-    # the Make target 'all' on Android.
-    if part_of_all and write_alias_target:
-      self.WriteLn('# Add target alias to "gyp_all_modules" target.')
-      self.WriteLn('.PHONY: gyp_all_modules')
-      self.WriteLn('gyp_all_modules: %s' % self.android_module)
-      self.WriteLn('')
-
-    # Add an alias from the gyp target name to the Android module name. This
-    # simplifies manual builds of the target, and is required by the test
-    # framework.
-    if self.target != self.android_module and write_alias_target:
-      self.WriteLn('# Alias gyp target name.')
-      self.WriteLn('.PHONY: %s' % self.target)
-      self.WriteLn('%s: %s' % (self.target, self.android_module))
-      self.WriteLn('')
-
-    # Add the command to trigger build of the target type depending
-    # on the toolset. Ex: BUILD_STATIC_LIBRARY vs. BUILD_HOST_STATIC_LIBRARY
-    # NOTE: This has to come last!
-    modifier = ''
-    if self.toolset == 'host':
-      modifier = 'HOST_'
-    if self.type == 'static_library':
-      self.WriteLn('include $(BUILD_%sSTATIC_LIBRARY)' % modifier)
-    elif self.type == 'shared_library':
-      self.WriteLn('LOCAL_PRELINK_MODULE := false')
-      self.WriteLn('include $(BUILD_%sSHARED_LIBRARY)' % modifier)
-    elif self.type == 'executable':
-      self.WriteLn('LOCAL_CXX_STL := libc++_static')
-      # Executables are for build and test purposes only, so they're installed
-      # to a directory that doesn't get included in the system image.
-      self.WriteLn('LOCAL_MODULE_PATH := $(gyp_shared_intermediate_dir)')
-      self.WriteLn('include $(BUILD_%sEXECUTABLE)' % modifier)
-    else:
-      self.WriteLn('LOCAL_MODULE_PATH := $(PRODUCT_OUT)/gyp_stamp')
-      self.WriteLn('LOCAL_UNINSTALLABLE_MODULE := true')
-      if self.toolset == 'target':
-        self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX := $(GYP_VAR_PREFIX)')
-      else:
-        self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX := $(GYP_HOST_VAR_PREFIX)')
-      self.WriteLn()
-      self.WriteLn('include $(BUILD_SYSTEM)/base_rules.mk')
-      self.WriteLn()
-      self.WriteLn('$(LOCAL_BUILT_MODULE): $(LOCAL_ADDITIONAL_DEPENDENCIES)')
-      self.WriteLn('\t$(hide) echo "Gyp timestamp: $@"')
-      self.WriteLn('\t$(hide) mkdir -p $(dir $@)')
-      self.WriteLn('\t$(hide) touch $@')
-      self.WriteLn()
-      self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX :=')
-
-
-  def WriteList(self, value_list, variable=None, prefix='',
-                quoter=make.QuoteIfNecessary, local_pathify=False):
-    """Write a variable definition that is a list of values.
+            self.WriteLn("LOCAL_MODULE_PATH := $(PRODUCT_OUT)/gyp_stamp")
+            self.WriteLn("LOCAL_UNINSTALLABLE_MODULE := true")
+            if self.toolset == "target":
+                self.WriteLn("LOCAL_2ND_ARCH_VAR_PREFIX := $(GYP_VAR_PREFIX)")
+            else:
+                self.WriteLn("LOCAL_2ND_ARCH_VAR_PREFIX := $(GYP_HOST_VAR_PREFIX)")
+            self.WriteLn()
+            self.WriteLn("include $(BUILD_SYSTEM)/base_rules.mk")
+            self.WriteLn()
+            self.WriteLn("$(LOCAL_BUILT_MODULE): $(LOCAL_ADDITIONAL_DEPENDENCIES)")
+            self.WriteLn('\t$(hide) echo "Gyp timestamp: $@"')
+            self.WriteLn("\t$(hide) mkdir -p $(dir $@)")
+            self.WriteLn("\t$(hide) touch $@")
+            self.WriteLn()
+            self.WriteLn("LOCAL_2ND_ARCH_VAR_PREFIX :=")
+
+    def WriteList(
+        self,
+        value_list,
+        variable=None,
+        prefix="",
+        quoter=make.QuoteIfNecessary,
+        local_pathify=False,
+    ):
+        """Write a variable definition that is a list of values.
 
     E.g. WriteList(['a','b'], 'foo', prefix='blah') writes out
          foo = blaha blahb
     but in a pretty-printed style.
     """
-    values = ''
-    if value_list:
-      value_list = [quoter(prefix + l) for l in value_list]
-      if local_pathify:
-        value_list = [self.LocalPathify(l) for l in value_list]
-      values = ' \\\n\t' + ' \\\n\t'.join(value_list)
-    self.fp.write('%s :=%s\n\n' % (variable, values))
-
-
-  def WriteLn(self, text=''):
-    self.fp.write(text + '\n')
-
-
-  def LocalPathify(self, path):
-    """Convert a subdirectory-relative path into a normalized path which starts
+        values = ""
+        if value_list:
+            value_list = [quoter(prefix + value) for value in value_list]
+            if local_pathify:
+                value_list = [self.LocalPathify(value) for value in value_list]
+            values = " \\\n\t" + " \\\n\t".join(value_list)
+        self.fp.write("%s :=%s\n\n" % (variable, values))
+
+    def WriteLn(self, text=""):
+        self.fp.write(text + "\n")
+
+    def LocalPathify(self, path):
+        """Convert a subdirectory-relative path into a normalized path which starts
     with the make variable $(LOCAL_PATH) (i.e. the top of the project tree).
     Absolute paths, or paths that contain variables, are just normalized."""
-    if '$(' in path or os.path.isabs(path):
-      # path is not a file in the project tree in this case, but calling
-      # normpath is still important for trimming trailing slashes.
-      return os.path.normpath(path)
-    local_path = os.path.join('$(LOCAL_PATH)', self.path, path)
-    local_path = os.path.normpath(local_path)
-    # Check that normalizing the path didn't ../ itself out of $(LOCAL_PATH)
-    # - i.e. that the resulting path is still inside the project tree. The
-    # path may legitimately have ended up containing just $(LOCAL_PATH), though,
-    # so we don't look for a slash.
-    assert local_path.startswith('$(LOCAL_PATH)'), (
-           'Path %s attempts to escape from gyp path %s !)' % (path, self.path))
-    return local_path
-
-
-  def ExpandInputRoot(self, template, expansion, dirname):
-    if '%(INPUT_ROOT)s' not in template and '%(INPUT_DIRNAME)s' not in template:
-      return template
-    path = template % {
-        'INPUT_ROOT': expansion,
-        'INPUT_DIRNAME': dirname,
+        if "$(" in path or os.path.isabs(path):
+            # path is not a file in the project tree in this case, but calling
+            # normpath is still important for trimming trailing slashes.
+            return os.path.normpath(path)
+        local_path = os.path.join("$(LOCAL_PATH)", self.path, path)
+        local_path = os.path.normpath(local_path)
+        # Check that normalizing the path didn't ../ itself out of $(LOCAL_PATH)
+        # - i.e. that the resulting path is still inside the project tree. The
+        # path may legitimately have ended up containing just $(LOCAL_PATH), though,
+        # so we don't look for a slash.
+        assert local_path.startswith(
+            "$(LOCAL_PATH)"
+        ), "Path %s attempts to escape from gyp path %s !)" % (path, self.path)
+        return local_path
+
+    def ExpandInputRoot(self, template, expansion, dirname):
+        if "%(INPUT_ROOT)s" not in template and "%(INPUT_DIRNAME)s" not in template:
+            return template
+        path = template % {
+            "INPUT_ROOT": expansion,
+            "INPUT_DIRNAME": dirname,
         }
-    return os.path.normpath(path)
+        return os.path.normpath(path)
 
 
 def PerformBuild(data, configurations, params):
-  # The android backend only supports the default configuration.
-  options = params['options']
-  makefile = os.path.abspath(os.path.join(options.toplevel_dir,
-                                          'GypAndroid.mk'))
-  env = dict(os.environ)
-  env['ONE_SHOT_MAKEFILE'] = makefile
-  arguments = ['make', '-C', os.environ['ANDROID_BUILD_TOP'], 'gyp_all_modules']
-  print('Building: %s' % arguments)
-  subprocess.check_call(arguments, env=env)
+    # The android backend only supports the default configuration.
+    options = params["options"]
+    makefile = os.path.abspath(os.path.join(options.toplevel_dir, "GypAndroid.mk"))
+    env = dict(os.environ)
+    env["ONE_SHOT_MAKEFILE"] = makefile
+    arguments = ["make", "-C", os.environ["ANDROID_BUILD_TOP"], "gyp_all_modules"]
+    print("Building: %s" % arguments)
+    subprocess.check_call(arguments, env=env)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  options = params['options']
-  generator_flags = params.get('generator_flags', {})
-  builddir_name = generator_flags.get('output_dir', 'out')
-  limit_to_target_all = generator_flags.get('limit_to_target_all', False)
-  write_alias_targets = generator_flags.get('write_alias_targets', True)
-  sdk_version = generator_flags.get('aosp_sdk_version', 0)
-  android_top_dir = os.environ.get('ANDROID_BUILD_TOP')
-  assert android_top_dir, '$ANDROID_BUILD_TOP not set; you need to run lunch.'
-
-  def CalculateMakefilePath(build_file, base_name):
-    """Determine where to write a Makefile for a given gyp file."""
-    # Paths in gyp files are relative to the .gyp file, but we want
-    # paths relative to the source root for the master makefile.  Grab
-    # the path of the .gyp file as the base to relativize against.
-    # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".
-    base_path = gyp.common.RelativePath(os.path.dirname(build_file),
-                                        options.depth)
-    # We write the file in the base_path directory.
-    output_file = os.path.join(options.depth, base_path, base_name)
-    assert not options.generator_output, (
-        'The Android backend does not support options.generator_output.')
-    base_path = gyp.common.RelativePath(os.path.dirname(build_file),
-                                        options.toplevel_dir)
-    return base_path, output_file
-
-  # TODO:  search for the first non-'Default' target.  This can go
-  # away when we add verification that all targets have the
-  # necessary configurations.
-  default_configuration = None
-  toolsets = set([target_dicts[target]['toolset'] for target in target_list])
-  for target in target_list:
-    spec = target_dicts[target]
-    if spec['default_configuration'] != 'Default':
-      default_configuration = spec['default_configuration']
-      break
-  if not default_configuration:
-    default_configuration = 'Default'
-
-  srcdir = '.'
-  makefile_name = 'GypAndroid' + options.suffix + '.mk'
-  makefile_path = os.path.join(options.toplevel_dir, makefile_name)
-  assert not options.generator_output, (
-      'The Android backend does not support options.generator_output.')
-  gyp.common.EnsureDirExists(makefile_path)
-  root_makefile = open(makefile_path, 'w')
-
-  root_makefile.write(header)
-
-  # We set LOCAL_PATH just once, here, to the top of the project tree. This
-  # allows all the other paths we use to be relative to the Android.mk file,
-  # as the Android build system expects.
-  root_makefile.write('\nLOCAL_PATH := $(call my-dir)\n')
-
-  # Find the list of targets that derive from the gyp file(s) being built.
-  needed_targets = set()
-  for build_file in params['build_files']:
-    for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
-      needed_targets.add(target)
-
-  build_files = set()
-  include_list = set()
-  android_modules = {}
-  for qualified_target in target_list:
-    build_file, target, toolset = gyp.common.ParseQualifiedTarget(
-        qualified_target)
-    relative_build_file = gyp.common.RelativePath(build_file,
-                                                  options.toplevel_dir)
-    build_files.add(relative_build_file)
-    included_files = data[build_file]['included_files']
-    for included_file in included_files:
-      # The included_files entries are relative to the dir of the build file
-      # that included them, so we have to undo that and then make them relative
-      # to the root dir.
-      relative_include_file = gyp.common.RelativePath(
-          gyp.common.UnrelativePath(included_file, build_file),
-          options.toplevel_dir)
-      abs_include_file = os.path.abspath(relative_include_file)
-      # If the include file is from the ~/.gyp dir, we should use absolute path
-      # so that relocating the src dir doesn't break the path.
-      if (params['home_dot_gyp'] and
-          abs_include_file.startswith(params['home_dot_gyp'])):
-        build_files.add(abs_include_file)
-      else:
-        build_files.add(relative_include_file)
-
-    base_path, output_file = CalculateMakefilePath(build_file,
-        target + '.' + toolset + options.suffix + '.mk')
-
-    spec = target_dicts[qualified_target]
-    configs = spec['configurations']
-
-    part_of_all = qualified_target in needed_targets
-    if limit_to_target_all and not part_of_all:
-      continue
-
-    relative_target = gyp.common.QualifiedTarget(relative_build_file, target,
-                                                 toolset)
-    writer = AndroidMkWriter(android_top_dir)
-    android_module = writer.Write(qualified_target, relative_target, base_path,
-                                  output_file, spec, configs,
-                                  part_of_all=part_of_all,
-                                  write_alias_target=write_alias_targets,
-                                  sdk_version=sdk_version)
-    if android_module in android_modules:
-      print('ERROR: Android module names must be unique. The following '
-             'targets both generate Android module name %s.\n  %s\n  %s' %
-             (android_module, android_modules[android_module],
-              qualified_target))
-      return
-    android_modules[android_module] = qualified_target
-
-    # Our root_makefile lives at the source root.  Compute the relative path
-    # from there to the output_file for including.
-    mkfile_rel_path = gyp.common.RelativePath(output_file,
-                                              os.path.dirname(makefile_path))
-    include_list.add(mkfile_rel_path)
-
-  root_makefile.write('GYP_CONFIGURATION ?= %s\n' % default_configuration)
-  root_makefile.write('GYP_VAR_PREFIX ?=\n')
-  root_makefile.write('GYP_HOST_VAR_PREFIX ?=\n')
-  root_makefile.write('GYP_HOST_MULTILIB ?= first\n')
-
-  # Write out the sorted list of includes.
-  root_makefile.write('\n')
-  for include_file in sorted(include_list):
-    root_makefile.write('include $(LOCAL_PATH)/' + include_file + '\n')
-  root_makefile.write('\n')
-
-  if write_alias_targets:
-    root_makefile.write(ALL_MODULES_FOOTER)
-
-  root_makefile.close()
+    options = params["options"]
+    generator_flags = params.get("generator_flags", {})
+    limit_to_target_all = generator_flags.get("limit_to_target_all", False)
+    write_alias_targets = generator_flags.get("write_alias_targets", True)
+    sdk_version = generator_flags.get("aosp_sdk_version", 0)
+    android_top_dir = os.environ.get("ANDROID_BUILD_TOP")
+    assert android_top_dir, "$ANDROID_BUILD_TOP not set; you need to run lunch."
+
+    def CalculateMakefilePath(build_file, base_name):
+        """Determine where to write a Makefile for a given gyp file."""
+        # Paths in gyp files are relative to the .gyp file, but we want
+        # paths relative to the source root for the master makefile.  Grab
+        # the path of the .gyp file as the base to relativize against.
+        # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".
+        base_path = gyp.common.RelativePath(os.path.dirname(build_file), options.depth)
+        # We write the file in the base_path directory.
+        output_file = os.path.join(options.depth, base_path, base_name)
+        assert (
+            not options.generator_output
+        ), "The Android backend does not support options.generator_output."
+        base_path = gyp.common.RelativePath(
+            os.path.dirname(build_file), options.toplevel_dir
+        )
+        return base_path, output_file
+
+    # TODO:  search for the first non-'Default' target.  This can go
+    # away when we add verification that all targets have the
+    # necessary configurations.
+    default_configuration = None
+    for target in target_list:
+        spec = target_dicts[target]
+        if spec["default_configuration"] != "Default":
+            default_configuration = spec["default_configuration"]
+            break
+    if not default_configuration:
+        default_configuration = "Default"
+
+    makefile_name = "GypAndroid" + options.suffix + ".mk"
+    makefile_path = os.path.join(options.toplevel_dir, makefile_name)
+    assert (
+        not options.generator_output
+    ), "The Android backend does not support options.generator_output."
+    gyp.common.EnsureDirExists(makefile_path)
+    root_makefile = open(makefile_path, "w")
+
+    root_makefile.write(header)
+
+    # We set LOCAL_PATH just once, here, to the top of the project tree. This
+    # allows all the other paths we use to be relative to the Android.mk file,
+    # as the Android build system expects.
+    root_makefile.write("\nLOCAL_PATH := $(call my-dir)\n")
+
+    # Find the list of targets that derive from the gyp file(s) being built.
+    needed_targets = set()
+    for build_file in params["build_files"]:
+        for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
+            needed_targets.add(target)
+
+    build_files = set()
+    include_list = set()
+    android_modules = {}
+    for qualified_target in target_list:
+        build_file, target, toolset = gyp.common.ParseQualifiedTarget(qualified_target)
+        relative_build_file = gyp.common.RelativePath(build_file, options.toplevel_dir)
+        build_files.add(relative_build_file)
+        included_files = data[build_file]["included_files"]
+        for included_file in included_files:
+            # The included_files entries are relative to the dir of the build file
+            # that included them, so we have to undo that and then make them relative
+            # to the root dir.
+            relative_include_file = gyp.common.RelativePath(
+                gyp.common.UnrelativePath(included_file, build_file),
+                options.toplevel_dir,
+            )
+            abs_include_file = os.path.abspath(relative_include_file)
+            # If the include file is from the ~/.gyp dir, we should use absolute path
+            # so that relocating the src dir doesn't break the path.
+            if params["home_dot_gyp"] and abs_include_file.startswith(
+                params["home_dot_gyp"]
+            ):
+                build_files.add(abs_include_file)
+            else:
+                build_files.add(relative_include_file)
+
+        base_path, output_file = CalculateMakefilePath(
+            build_file, target + "." + toolset + options.suffix + ".mk"
+        )
+
+        spec = target_dicts[qualified_target]
+        configs = spec["configurations"]
+
+        part_of_all = qualified_target in needed_targets
+        if limit_to_target_all and not part_of_all:
+            continue
+
+        relative_target = gyp.common.QualifiedTarget(
+            relative_build_file, target, toolset
+        )
+        writer = AndroidMkWriter(android_top_dir)
+        android_module = writer.Write(
+            qualified_target,
+            relative_target,
+            base_path,
+            output_file,
+            spec,
+            configs,
+            part_of_all=part_of_all,
+            write_alias_target=write_alias_targets,
+            sdk_version=sdk_version,
+        )
+        if android_module in android_modules:
+            print(
+                "ERROR: Android module names must be unique. The following "
+                "targets both generate Android module name %s.\n  %s\n  %s"
+                % (android_module, android_modules[android_module], qualified_target)
+            )
+            return
+        android_modules[android_module] = qualified_target
+
+        # Our root_makefile lives at the source root.  Compute the relative path
+        # from there to the output_file for including.
+        mkfile_rel_path = gyp.common.RelativePath(
+            output_file, os.path.dirname(makefile_path)
+        )
+        include_list.add(mkfile_rel_path)
+
+    root_makefile.write("GYP_CONFIGURATION ?= %s\n" % default_configuration)
+    root_makefile.write("GYP_VAR_PREFIX ?=\n")
+    root_makefile.write("GYP_HOST_VAR_PREFIX ?=\n")
+    root_makefile.write("GYP_HOST_MULTILIB ?= first\n")
+
+    # Write out the sorted list of includes.
+    root_makefile.write("\n")
+    for include_file in sorted(include_list):
+        root_makefile.write("include $(LOCAL_PATH)/" + include_file + "\n")
+    root_makefile.write("\n")
+
+    if write_alias_targets:
+        root_makefile.write(ALL_MODULES_FOOTER)
+
+    root_makefile.close()
diff --git a/tools/gyp/pylib/gyp/generator/cmake.py b/tools/gyp/pylib/gyp/generator/cmake.py
index e966a8f23e1f090970ccc6c4b07654736d59abdb..75f5822369735a0e14dd2a54a41711a0497fe0b3 100644
--- a/tools/gyp/pylib/gyp/generator/cmake.py
+++ b/tools/gyp/pylib/gyp/generator/cmake.py
@@ -38,91 +38,98 @@ import subprocess
 import gyp.common
 import gyp.xcode_emulation
 
+try:
+    # maketrans moved to str in python3.
+    _maketrans = string.maketrans
+except (NameError, AttributeError):
+    _maketrans = str.maketrans
+
 generator_default_variables = {
-  'EXECUTABLE_PREFIX': '',
-  'EXECUTABLE_SUFFIX': '',
-  'STATIC_LIB_PREFIX': 'lib',
-  'STATIC_LIB_SUFFIX': '.a',
-  'SHARED_LIB_PREFIX': 'lib',
-  'SHARED_LIB_SUFFIX': '.so',
-  'SHARED_LIB_DIR': '${builddir}/lib.${TOOLSET}',
-  'LIB_DIR': '${obj}.${TOOLSET}',
-  'INTERMEDIATE_DIR': '${obj}.${TOOLSET}/${TARGET}/geni',
-  'SHARED_INTERMEDIATE_DIR': '${obj}/gen',
-  'PRODUCT_DIR': '${builddir}',
-  'RULE_INPUT_PATH': '${RULE_INPUT_PATH}',
-  'RULE_INPUT_DIRNAME': '${RULE_INPUT_DIRNAME}',
-  'RULE_INPUT_NAME': '${RULE_INPUT_NAME}',
-  'RULE_INPUT_ROOT': '${RULE_INPUT_ROOT}',
-  'RULE_INPUT_EXT': '${RULE_INPUT_EXT}',
-  'CONFIGURATION_NAME': '${configuration}',
+    "EXECUTABLE_PREFIX": "",
+    "EXECUTABLE_SUFFIX": "",
+    "STATIC_LIB_PREFIX": "lib",
+    "STATIC_LIB_SUFFIX": ".a",
+    "SHARED_LIB_PREFIX": "lib",
+    "SHARED_LIB_SUFFIX": ".so",
+    "SHARED_LIB_DIR": "${builddir}/lib.${TOOLSET}",
+    "LIB_DIR": "${obj}.${TOOLSET}",
+    "INTERMEDIATE_DIR": "${obj}.${TOOLSET}/${TARGET}/geni",
+    "SHARED_INTERMEDIATE_DIR": "${obj}/gen",
+    "PRODUCT_DIR": "${builddir}",
+    "RULE_INPUT_PATH": "${RULE_INPUT_PATH}",
+    "RULE_INPUT_DIRNAME": "${RULE_INPUT_DIRNAME}",
+    "RULE_INPUT_NAME": "${RULE_INPUT_NAME}",
+    "RULE_INPUT_ROOT": "${RULE_INPUT_ROOT}",
+    "RULE_INPUT_EXT": "${RULE_INPUT_EXT}",
+    "CONFIGURATION_NAME": "${configuration}",
 }
 
-FULL_PATH_VARS = ('${CMAKE_CURRENT_LIST_DIR}', '${builddir}', '${obj}')
+FULL_PATH_VARS = ("${CMAKE_CURRENT_LIST_DIR}", "${builddir}", "${obj}")
 
 generator_supports_multiple_toolsets = True
 generator_wants_static_library_dependencies_adjusted = True
 
 COMPILABLE_EXTENSIONS = {
-  '.c': 'cc',
-  '.cc': 'cxx',
-  '.cpp': 'cxx',
-  '.cxx': 'cxx',
-  '.s': 's', # cc
-  '.S': 's', # cc
+    ".c": "cc",
+    ".cc": "cxx",
+    ".cpp": "cxx",
+    ".cxx": "cxx",
+    ".s": "s",  # cc
+    ".S": "s",  # cc
 }
 
 
 def RemovePrefix(a, prefix):
-  """Returns 'a' without 'prefix' if it starts with 'prefix'."""
-  return a[len(prefix):] if a.startswith(prefix) else a
+    """Returns 'a' without 'prefix' if it starts with 'prefix'."""
+    return a[len(prefix) :] if a.startswith(prefix) else a
 
 
 def CalculateVariables(default_variables, params):
-  """Calculate additional variables for use in the build (called by gyp)."""
-  default_variables.setdefault('OS', gyp.common.GetFlavor(params))
+    """Calculate additional variables for use in the build (called by gyp)."""
+    default_variables.setdefault("OS", gyp.common.GetFlavor(params))
 
 
 def Compilable(filename):
-  """Return true if the file is compilable (should be in OBJS)."""
-  return any(filename.endswith(e) for e in COMPILABLE_EXTENSIONS)
+    """Return true if the file is compilable (should be in OBJS)."""
+    return any(filename.endswith(e) for e in COMPILABLE_EXTENSIONS)
 
 
 def Linkable(filename):
-  """Return true if the file is linkable (should be on the link line)."""
-  return filename.endswith('.o')
+    """Return true if the file is linkable (should be on the link line)."""
+    return filename.endswith(".o")
 
 
 def NormjoinPathForceCMakeSource(base_path, rel_path):
-  """Resolves rel_path against base_path and returns the result.
+    """Resolves rel_path against base_path and returns the result.
 
   If rel_path is an absolute path it is returned unchanged.
   Otherwise it is resolved against base_path and normalized.
   If the result is a relative path, it is forced to be relative to the
   CMakeLists.txt.
   """
-  if os.path.isabs(rel_path):
-    return rel_path
-  if any([rel_path.startswith(var) for var in FULL_PATH_VARS]):
-    return rel_path
-  # TODO: do we need to check base_path for absolute variables as well?
-  return os.path.join('${CMAKE_CURRENT_LIST_DIR}',
-                      os.path.normpath(os.path.join(base_path, rel_path)))
+    if os.path.isabs(rel_path):
+        return rel_path
+    if any([rel_path.startswith(var) for var in FULL_PATH_VARS]):
+        return rel_path
+    # TODO: do we need to check base_path for absolute variables as well?
+    return os.path.join(
+        "${CMAKE_CURRENT_LIST_DIR}", os.path.normpath(os.path.join(base_path, rel_path))
+    )
 
 
 def NormjoinPath(base_path, rel_path):
-  """Resolves rel_path against base_path and returns the result.
+    """Resolves rel_path against base_path and returns the result.
   TODO: what is this really used for?
   If rel_path begins with '$' it is returned unchanged.
   Otherwise it is resolved against base_path if relative, then normalized.
   """
-  if rel_path.startswith('$') and not rel_path.startswith('${configuration}'):
-    return rel_path
-  return os.path.normpath(os.path.join(base_path, rel_path))
+    if rel_path.startswith("$") and not rel_path.startswith("${configuration}"):
+        return rel_path
+    return os.path.normpath(os.path.join(base_path, rel_path))
 
 
 def CMakeStringEscape(a):
-  """Escapes the string 'a' for use inside a CMake string.
+    """Escapes the string 'a' for use inside a CMake string.
 
   This means escaping
   '\' otherwise it may be seen as modifying the next character
@@ -137,118 +144,114 @@ def CMakeStringEscape(a):
       but text $ should be escaped
       what is wanted is to know which $ come from generator variables
   """
-  return a.replace('\\', '\\\\').replace(';', '\\;').replace('"', '\\"')
+    return a.replace("\\", "\\\\").replace(";", "\\;").replace('"', '\\"')
 
 
 def SetFileProperty(output, source_name, property_name, values, sep):
-  """Given a set of source file, sets the given property on them."""
-  output.write('set_source_files_properties(')
-  output.write(source_name)
-  output.write(' PROPERTIES ')
-  output.write(property_name)
-  output.write(' "')
-  for value in values:
-    output.write(CMakeStringEscape(value))
-    output.write(sep)
-  output.write('")\n')
+    """Given a set of source file, sets the given property on them."""
+    output.write("set_source_files_properties(")
+    output.write(source_name)
+    output.write(" PROPERTIES ")
+    output.write(property_name)
+    output.write(' "')
+    for value in values:
+        output.write(CMakeStringEscape(value))
+        output.write(sep)
+    output.write('")\n')
 
 
 def SetFilesProperty(output, variable, property_name, values, sep):
-  """Given a set of source files, sets the given property on them."""
-  output.write('set_source_files_properties(')
-  WriteVariable(output, variable)
-  output.write(' PROPERTIES ')
-  output.write(property_name)
-  output.write(' "')
-  for value in values:
-    output.write(CMakeStringEscape(value))
-    output.write(sep)
-  output.write('")\n')
-
-
-def SetTargetProperty(output, target_name, property_name, values, sep=''):
-  """Given a target, sets the given property."""
-  output.write('set_target_properties(')
-  output.write(target_name)
-  output.write(' PROPERTIES ')
-  output.write(property_name)
-  output.write(' "')
-  for value in values:
-    output.write(CMakeStringEscape(value))
-    output.write(sep)
-  output.write('")\n')
+    """Given a set of source files, sets the given property on them."""
+    output.write("set_source_files_properties(")
+    WriteVariable(output, variable)
+    output.write(" PROPERTIES ")
+    output.write(property_name)
+    output.write(' "')
+    for value in values:
+        output.write(CMakeStringEscape(value))
+        output.write(sep)
+    output.write('")\n')
+
+
+def SetTargetProperty(output, target_name, property_name, values, sep=""):
+    """Given a target, sets the given property."""
+    output.write("set_target_properties(")
+    output.write(target_name)
+    output.write(" PROPERTIES ")
+    output.write(property_name)
+    output.write(' "')
+    for value in values:
+        output.write(CMakeStringEscape(value))
+        output.write(sep)
+    output.write('")\n')
 
 
 def SetVariable(output, variable_name, value):
-  """Sets a CMake variable."""
-  output.write('set(')
-  output.write(variable_name)
-  output.write(' "')
-  output.write(CMakeStringEscape(value))
-  output.write('")\n')
+    """Sets a CMake variable."""
+    output.write("set(")
+    output.write(variable_name)
+    output.write(' "')
+    output.write(CMakeStringEscape(value))
+    output.write('")\n')
 
 
 def SetVariableList(output, variable_name, values):
-  """Sets a CMake variable to a list."""
-  if not values:
-    return SetVariable(output, variable_name, "")
-  if len(values) == 1:
-    return SetVariable(output, variable_name, values[0])
-  output.write('list(APPEND ')
-  output.write(variable_name)
-  output.write('\n  "')
-  output.write('"\n  "'.join([CMakeStringEscape(value) for value in values]))
-  output.write('")\n')
+    """Sets a CMake variable to a list."""
+    if not values:
+        return SetVariable(output, variable_name, "")
+    if len(values) == 1:
+        return SetVariable(output, variable_name, values[0])
+    output.write("list(APPEND ")
+    output.write(variable_name)
+    output.write('\n  "')
+    output.write('"\n  "'.join([CMakeStringEscape(value) for value in values]))
+    output.write('")\n')
 
 
 def UnsetVariable(output, variable_name):
-  """Unsets a CMake variable."""
-  output.write('unset(')
-  output.write(variable_name)
-  output.write(')\n')
+    """Unsets a CMake variable."""
+    output.write("unset(")
+    output.write(variable_name)
+    output.write(")\n")
 
 
 def WriteVariable(output, variable_name, prepend=None):
-  if prepend:
-    output.write(prepend)
-  output.write('${')
-  output.write(variable_name)
-  output.write('}')
+    if prepend:
+        output.write(prepend)
+    output.write("${")
+    output.write(variable_name)
+    output.write("}")
 
 
 class CMakeTargetType(object):
-  def __init__(self, command, modifier, property_modifier):
-    self.command = command
-    self.modifier = modifier
-    self.property_modifier = property_modifier
+    def __init__(self, command, modifier, property_modifier):
+        self.command = command
+        self.modifier = modifier
+        self.property_modifier = property_modifier
 
 
 cmake_target_type_from_gyp_target_type = {
-  'executable': CMakeTargetType('add_executable', None, 'RUNTIME'),
-  'static_library': CMakeTargetType('add_library', 'STATIC', 'ARCHIVE'),
-  'shared_library': CMakeTargetType('add_library', 'SHARED', 'LIBRARY'),
-  'loadable_module': CMakeTargetType('add_library', 'MODULE', 'LIBRARY'),
-  'none': CMakeTargetType('add_custom_target', 'SOURCES', None),
+    "executable": CMakeTargetType("add_executable", None, "RUNTIME"),
+    "static_library": CMakeTargetType("add_library", "STATIC", "ARCHIVE"),
+    "shared_library": CMakeTargetType("add_library", "SHARED", "LIBRARY"),
+    "loadable_module": CMakeTargetType("add_library", "MODULE", "LIBRARY"),
+    "none": CMakeTargetType("add_custom_target", "SOURCES", None),
 }
 
 
 def StringToCMakeTargetName(a):
-  """Converts the given string 'a' to a valid CMake target name.
+    """Converts the given string 'a' to a valid CMake target name.
 
   All invalid characters are replaced by '_'.
   Invalid for cmake: ' ', '/', '(', ')', '"'
   Invalid for make: ':'
   Invalid for unknown reasons but cause failures: '.'
   """
-  try:
-      return a.translate(str.maketrans(' /():."', '_______'))
-  except AttributeError:
-      return a.translate(string.maketrans(' /():."', '_______'))
+    return a.translate(_maketrans(' /():."', "_______"))
 
 
-def WriteActions(target_name, actions, extra_sources, extra_deps,
-                 path_to_gyp, output):
-  """Write CMake for the 'actions' in the target.
+def WriteActions(target_name, actions, extra_sources, extra_deps, path_to_gyp, output):
+    """Write CMake for the 'actions' in the target.
 
   Args:
     target_name: the name of the CMake target being generated.
@@ -258,83 +261,86 @@ def WriteActions(target_name, actions, extra_sources, extra_deps,
     path_to_gyp: relative path from CMakeLists.txt being generated to
         the Gyp file in which the target being generated is defined.
   """
-  for action in actions:
-    action_name = StringToCMakeTargetName(action['action_name'])
-    action_target_name = '%s__%s' % (target_name, action_name)
-
-    inputs = action['inputs']
-    inputs_name = action_target_name + '__input'
-    SetVariableList(output, inputs_name,
-        [NormjoinPathForceCMakeSource(path_to_gyp, dep) for dep in inputs])
-
-    outputs = action['outputs']
-    cmake_outputs = [NormjoinPathForceCMakeSource(path_to_gyp, out)
-                     for out in outputs]
-    outputs_name = action_target_name + '__output'
-    SetVariableList(output, outputs_name, cmake_outputs)
-
-    # Build up a list of outputs.
-    # Collect the output dirs we'll need.
-    dirs = set(dir for dir in (os.path.dirname(o) for o in outputs) if dir)
-
-    if int(action.get('process_outputs_as_sources', False)):
-      extra_sources.extend(zip(cmake_outputs, outputs))
-
-    # add_custom_command
-    output.write('add_custom_command(OUTPUT ')
-    WriteVariable(output, outputs_name)
-    output.write('\n')
-
-    if len(dirs) > 0:
-      for directory in dirs:
-        output.write('  COMMAND ${CMAKE_COMMAND} -E make_directory ')
-        output.write(directory)
-        output.write('\n')
-
-    output.write('  COMMAND ')
-    output.write(gyp.common.EncodePOSIXShellList(action['action']))
-    output.write('\n')
-
-    output.write('  DEPENDS ')
-    WriteVariable(output, inputs_name)
-    output.write('\n')
-
-    output.write('  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/')
-    output.write(path_to_gyp)
-    output.write('\n')
-
-    output.write('  COMMENT ')
-    if 'message' in action:
-      output.write(action['message'])
-    else:
-      output.write(action_target_name)
-    output.write('\n')
-
-    output.write('  VERBATIM\n')
-    output.write(')\n')
-
-    # add_custom_target
-    output.write('add_custom_target(')
-    output.write(action_target_name)
-    output.write('\n  DEPENDS ')
-    WriteVariable(output, outputs_name)
-    output.write('\n  SOURCES ')
-    WriteVariable(output, inputs_name)
-    output.write('\n)\n')
-
-    extra_deps.append(action_target_name)
+    for action in actions:
+        action_name = StringToCMakeTargetName(action["action_name"])
+        action_target_name = "%s__%s" % (target_name, action_name)
+
+        inputs = action["inputs"]
+        inputs_name = action_target_name + "__input"
+        SetVariableList(
+            output,
+            inputs_name,
+            [NormjoinPathForceCMakeSource(path_to_gyp, dep) for dep in inputs],
+        )
+
+        outputs = action["outputs"]
+        cmake_outputs = [
+            NormjoinPathForceCMakeSource(path_to_gyp, out) for out in outputs
+        ]
+        outputs_name = action_target_name + "__output"
+        SetVariableList(output, outputs_name, cmake_outputs)
+
+        # Build up a list of outputs.
+        # Collect the output dirs we'll need.
+        dirs = set(dir for dir in (os.path.dirname(o) for o in outputs) if dir)
+
+        if int(action.get("process_outputs_as_sources", False)):
+            extra_sources.extend(zip(cmake_outputs, outputs))
+
+        # add_custom_command
+        output.write("add_custom_command(OUTPUT ")
+        WriteVariable(output, outputs_name)
+        output.write("\n")
+
+        if len(dirs) > 0:
+            for directory in dirs:
+                output.write("  COMMAND ${CMAKE_COMMAND} -E make_directory ")
+                output.write(directory)
+                output.write("\n")
+
+        output.write("  COMMAND ")
+        output.write(gyp.common.EncodePOSIXShellList(action["action"]))
+        output.write("\n")
+
+        output.write("  DEPENDS ")
+        WriteVariable(output, inputs_name)
+        output.write("\n")
+
+        output.write("  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/")
+        output.write(path_to_gyp)
+        output.write("\n")
+
+        output.write("  COMMENT ")
+        if "message" in action:
+            output.write(action["message"])
+        else:
+            output.write(action_target_name)
+        output.write("\n")
+
+        output.write("  VERBATIM\n")
+        output.write(")\n")
+
+        # add_custom_target
+        output.write("add_custom_target(")
+        output.write(action_target_name)
+        output.write("\n  DEPENDS ")
+        WriteVariable(output, outputs_name)
+        output.write("\n  SOURCES ")
+        WriteVariable(output, inputs_name)
+        output.write("\n)\n")
+
+        extra_deps.append(action_target_name)
 
 
 def NormjoinRulePathForceCMakeSource(base_path, rel_path, rule_source):
-  if rel_path.startswith(("${RULE_INPUT_PATH}","${RULE_INPUT_DIRNAME}")):
-    if any([rule_source.startswith(var) for var in FULL_PATH_VARS]):
-      return rel_path
-  return NormjoinPathForceCMakeSource(base_path, rel_path)
+    if rel_path.startswith(("${RULE_INPUT_PATH}", "${RULE_INPUT_DIRNAME}")):
+        if any([rule_source.startswith(var) for var in FULL_PATH_VARS]):
+            return rel_path
+    return NormjoinPathForceCMakeSource(base_path, rel_path)
 
 
-def WriteRules(target_name, rules, extra_sources, extra_deps,
-               path_to_gyp, output):
-  """Write CMake for the 'rules' in the target.
+def WriteRules(target_name, rules, extra_sources, extra_deps, path_to_gyp, output):
+    """Write CMake for the 'rules' in the target.
 
   Args:
     target_name: the name of the CMake target being generated.
@@ -344,110 +350,115 @@ def WriteRules(target_name, rules, extra_sources, extra_deps,
     path_to_gyp: relative path from CMakeLists.txt being generated to
         the Gyp file in which the target being generated is defined.
   """
-  for rule in rules:
-    rule_name = StringToCMakeTargetName(target_name + '__' + rule['rule_name'])
-
-    inputs = rule.get('inputs', [])
-    inputs_name = rule_name + '__input'
-    SetVariableList(output, inputs_name,
-        [NormjoinPathForceCMakeSource(path_to_gyp, dep) for dep in inputs])
-    outputs = rule['outputs']
-    var_outputs = []
-
-    for count, rule_source in enumerate(rule.get('rule_sources', [])):
-      action_name = rule_name + '_' + str(count)
-
-      rule_source_dirname, rule_source_basename = os.path.split(rule_source)
-      rule_source_root, rule_source_ext = os.path.splitext(rule_source_basename)
-
-      SetVariable(output, 'RULE_INPUT_PATH', rule_source)
-      SetVariable(output, 'RULE_INPUT_DIRNAME', rule_source_dirname)
-      SetVariable(output, 'RULE_INPUT_NAME', rule_source_basename)
-      SetVariable(output, 'RULE_INPUT_ROOT', rule_source_root)
-      SetVariable(output, 'RULE_INPUT_EXT', rule_source_ext)
-
-      # Build up a list of outputs.
-      # Collect the output dirs we'll need.
-      dirs = set(dir for dir in (os.path.dirname(o) for o in outputs) if dir)
-
-      # Create variables for the output, as 'local' variable will be unset.
-      these_outputs = []
-      for output_index, out in enumerate(outputs):
-        output_name = action_name + '_' + str(output_index)
-        SetVariable(output, output_name,
-                     NormjoinRulePathForceCMakeSource(path_to_gyp, out,
-                                                      rule_source))
-        if int(rule.get('process_outputs_as_sources', False)):
-          extra_sources.append(('${' + output_name + '}', out))
-        these_outputs.append('${' + output_name + '}')
-        var_outputs.append('${' + output_name + '}')
-
-      # add_custom_command
-      output.write('add_custom_command(OUTPUT\n')
-      for out in these_outputs:
-        output.write('  ')
-        output.write(out)
-        output.write('\n')
-
-      for directory in dirs:
-        output.write('  COMMAND ${CMAKE_COMMAND} -E make_directory ')
-        output.write(directory)
-        output.write('\n')
-
-      output.write('  COMMAND ')
-      output.write(gyp.common.EncodePOSIXShellList(rule['action']))
-      output.write('\n')
-
-      output.write('  DEPENDS ')
-      WriteVariable(output, inputs_name)
-      output.write(' ')
-      output.write(NormjoinPath(path_to_gyp, rule_source))
-      output.write('\n')
-
-      # CMAKE_CURRENT_LIST_DIR is where the CMakeLists.txt lives.
-      # The cwd is the current build directory.
-      output.write('  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/')
-      output.write(path_to_gyp)
-      output.write('\n')
-
-      output.write('  COMMENT ')
-      if 'message' in rule:
-        output.write(rule['message'])
-      else:
-        output.write(action_name)
-      output.write('\n')
-
-      output.write('  VERBATIM\n')
-      output.write(')\n')
-
-      UnsetVariable(output, 'RULE_INPUT_PATH')
-      UnsetVariable(output, 'RULE_INPUT_DIRNAME')
-      UnsetVariable(output, 'RULE_INPUT_NAME')
-      UnsetVariable(output, 'RULE_INPUT_ROOT')
-      UnsetVariable(output, 'RULE_INPUT_EXT')
-
-    # add_custom_target
-    output.write('add_custom_target(')
-    output.write(rule_name)
-    output.write(' DEPENDS\n')
-    for out in var_outputs:
-      output.write('  ')
-      output.write(out)
-      output.write('\n')
-    output.write('SOURCES ')
-    WriteVariable(output, inputs_name)
-    output.write('\n')
-    for rule_source in rule.get('rule_sources', []):
-      output.write('  ')
-      output.write(NormjoinPath(path_to_gyp, rule_source))
-      output.write('\n')
-    output.write(')\n')
-
-    extra_deps.append(rule_name)
+    for rule in rules:
+        rule_name = StringToCMakeTargetName(target_name + "__" + rule["rule_name"])
+
+        inputs = rule.get("inputs", [])
+        inputs_name = rule_name + "__input"
+        SetVariableList(
+            output,
+            inputs_name,
+            [NormjoinPathForceCMakeSource(path_to_gyp, dep) for dep in inputs],
+        )
+        outputs = rule["outputs"]
+        var_outputs = []
+
+        for count, rule_source in enumerate(rule.get("rule_sources", [])):
+            action_name = rule_name + "_" + str(count)
+
+            rule_source_dirname, rule_source_basename = os.path.split(rule_source)
+            rule_source_root, rule_source_ext = os.path.splitext(rule_source_basename)
+
+            SetVariable(output, "RULE_INPUT_PATH", rule_source)
+            SetVariable(output, "RULE_INPUT_DIRNAME", rule_source_dirname)
+            SetVariable(output, "RULE_INPUT_NAME", rule_source_basename)
+            SetVariable(output, "RULE_INPUT_ROOT", rule_source_root)
+            SetVariable(output, "RULE_INPUT_EXT", rule_source_ext)
+
+            # Build up a list of outputs.
+            # Collect the output dirs we'll need.
+            dirs = set(dir for dir in (os.path.dirname(o) for o in outputs) if dir)
+
+            # Create variables for the output, as 'local' variable will be unset.
+            these_outputs = []
+            for output_index, out in enumerate(outputs):
+                output_name = action_name + "_" + str(output_index)
+                SetVariable(
+                    output,
+                    output_name,
+                    NormjoinRulePathForceCMakeSource(path_to_gyp, out, rule_source),
+                )
+                if int(rule.get("process_outputs_as_sources", False)):
+                    extra_sources.append(("${" + output_name + "}", out))
+                these_outputs.append("${" + output_name + "}")
+                var_outputs.append("${" + output_name + "}")
+
+            # add_custom_command
+            output.write("add_custom_command(OUTPUT\n")
+            for out in these_outputs:
+                output.write("  ")
+                output.write(out)
+                output.write("\n")
+
+            for directory in dirs:
+                output.write("  COMMAND ${CMAKE_COMMAND} -E make_directory ")
+                output.write(directory)
+                output.write("\n")
+
+            output.write("  COMMAND ")
+            output.write(gyp.common.EncodePOSIXShellList(rule["action"]))
+            output.write("\n")
+
+            output.write("  DEPENDS ")
+            WriteVariable(output, inputs_name)
+            output.write(" ")
+            output.write(NormjoinPath(path_to_gyp, rule_source))
+            output.write("\n")
+
+            # CMAKE_CURRENT_LIST_DIR is where the CMakeLists.txt lives.
+            # The cwd is the current build directory.
+            output.write("  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/")
+            output.write(path_to_gyp)
+            output.write("\n")
+
+            output.write("  COMMENT ")
+            if "message" in rule:
+                output.write(rule["message"])
+            else:
+                output.write(action_name)
+            output.write("\n")
+
+            output.write("  VERBATIM\n")
+            output.write(")\n")
+
+            UnsetVariable(output, "RULE_INPUT_PATH")
+            UnsetVariable(output, "RULE_INPUT_DIRNAME")
+            UnsetVariable(output, "RULE_INPUT_NAME")
+            UnsetVariable(output, "RULE_INPUT_ROOT")
+            UnsetVariable(output, "RULE_INPUT_EXT")
+
+        # add_custom_target
+        output.write("add_custom_target(")
+        output.write(rule_name)
+        output.write(" DEPENDS\n")
+        for out in var_outputs:
+            output.write("  ")
+            output.write(out)
+            output.write("\n")
+        output.write("SOURCES ")
+        WriteVariable(output, inputs_name)
+        output.write("\n")
+        for rule_source in rule.get("rule_sources", []):
+            output.write("  ")
+            output.write(NormjoinPath(path_to_gyp, rule_source))
+            output.write("\n")
+        output.write(")\n")
+
+        extra_deps.append(rule_name)
 
 
 def WriteCopies(target_name, copies, extra_deps, path_to_gyp, output):
-  """Write CMake for the 'copies' in the target.
+    """Write CMake for the 'copies' in the target.
 
   Args:
     target_name: the name of the CMake target being generated.
@@ -456,126 +467,128 @@ def WriteCopies(target_name, copies, extra_deps, path_to_gyp, output):
     path_to_gyp: relative path from CMakeLists.txt being generated to
         the Gyp file in which the target being generated is defined.
   """
-  copy_name = target_name + '__copies'
+    copy_name = target_name + "__copies"
+
+    # CMake gets upset with custom targets with OUTPUT which specify no output.
+    have_copies = any(copy["files"] for copy in copies)
+    if not have_copies:
+        output.write("add_custom_target(")
+        output.write(copy_name)
+        output.write(")\n")
+        extra_deps.append(copy_name)
+        return
+
+    class Copy(object):
+        def __init__(self, ext, command):
+            self.cmake_inputs = []
+            self.cmake_outputs = []
+            self.gyp_inputs = []
+            self.gyp_outputs = []
+            self.ext = ext
+            self.inputs_name = None
+            self.outputs_name = None
+            self.command = command
+
+    file_copy = Copy("", "copy")
+    dir_copy = Copy("_dirs", "copy_directory")
+
+    for copy in copies:
+        files = copy["files"]
+        destination = copy["destination"]
+        for src in files:
+            path = os.path.normpath(src)
+            basename = os.path.split(path)[1]
+            dst = os.path.join(destination, basename)
+
+            copy = file_copy if os.path.basename(src) else dir_copy
+
+            copy.cmake_inputs.append(NormjoinPathForceCMakeSource(path_to_gyp, src))
+            copy.cmake_outputs.append(NormjoinPathForceCMakeSource(path_to_gyp, dst))
+            copy.gyp_inputs.append(src)
+            copy.gyp_outputs.append(dst)
+
+    for copy in (file_copy, dir_copy):
+        if copy.cmake_inputs:
+            copy.inputs_name = copy_name + "__input" + copy.ext
+            SetVariableList(output, copy.inputs_name, copy.cmake_inputs)
+
+            copy.outputs_name = copy_name + "__output" + copy.ext
+            SetVariableList(output, copy.outputs_name, copy.cmake_outputs)
+
+    # add_custom_command
+    output.write("add_custom_command(\n")
+
+    output.write("OUTPUT")
+    for copy in (file_copy, dir_copy):
+        if copy.outputs_name:
+            WriteVariable(output, copy.outputs_name, " ")
+    output.write("\n")
+
+    for copy in (file_copy, dir_copy):
+        for src, dst in zip(copy.gyp_inputs, copy.gyp_outputs):
+            # 'cmake -E copy src dst' will create the 'dst' directory if needed.
+            output.write("COMMAND ${CMAKE_COMMAND} -E %s " % copy.command)
+            output.write(src)
+            output.write(" ")
+            output.write(dst)
+            output.write("\n")
+
+    output.write("DEPENDS")
+    for copy in (file_copy, dir_copy):
+        if copy.inputs_name:
+            WriteVariable(output, copy.inputs_name, " ")
+    output.write("\n")
+
+    output.write("WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/")
+    output.write(path_to_gyp)
+    output.write("\n")
+
+    output.write("COMMENT Copying for ")
+    output.write(target_name)
+    output.write("\n")
 
-  # CMake gets upset with custom targets with OUTPUT which specify no output.
-  have_copies = any(copy['files'] for copy in copies)
-  if not have_copies:
-    output.write('add_custom_target(')
+    output.write("VERBATIM\n")
+    output.write(")\n")
+
+    # add_custom_target
+    output.write("add_custom_target(")
     output.write(copy_name)
-    output.write(')\n')
+    output.write("\n  DEPENDS")
+    for copy in (file_copy, dir_copy):
+        if copy.outputs_name:
+            WriteVariable(output, copy.outputs_name, " ")
+    output.write("\n  SOURCES")
+    if file_copy.inputs_name:
+        WriteVariable(output, file_copy.inputs_name, " ")
+    output.write("\n)\n")
+
     extra_deps.append(copy_name)
-    return
-
-  class Copy(object):
-    def __init__(self, ext, command):
-      self.cmake_inputs = []
-      self.cmake_outputs = []
-      self.gyp_inputs = []
-      self.gyp_outputs = []
-      self.ext = ext
-      self.inputs_name = None
-      self.outputs_name = None
-      self.command = command
-
-  file_copy = Copy('', 'copy')
-  dir_copy = Copy('_dirs', 'copy_directory')
-
-  for copy in copies:
-    files = copy['files']
-    destination = copy['destination']
-    for src in files:
-      path = os.path.normpath(src)
-      basename = os.path.split(path)[1]
-      dst = os.path.join(destination, basename)
-
-      copy = file_copy if os.path.basename(src) else dir_copy
-
-      copy.cmake_inputs.append(NormjoinPathForceCMakeSource(path_to_gyp, src))
-      copy.cmake_outputs.append(NormjoinPathForceCMakeSource(path_to_gyp, dst))
-      copy.gyp_inputs.append(src)
-      copy.gyp_outputs.append(dst)
-
-  for copy in (file_copy, dir_copy):
-    if copy.cmake_inputs:
-      copy.inputs_name = copy_name + '__input' + copy.ext
-      SetVariableList(output, copy.inputs_name, copy.cmake_inputs)
-
-      copy.outputs_name = copy_name + '__output' + copy.ext
-      SetVariableList(output, copy.outputs_name, copy.cmake_outputs)
-
-  # add_custom_command
-  output.write('add_custom_command(\n')
-
-  output.write('OUTPUT')
-  for copy in (file_copy, dir_copy):
-    if copy.outputs_name:
-      WriteVariable(output, copy.outputs_name, ' ')
-  output.write('\n')
-
-  for copy in (file_copy, dir_copy):
-    for src, dst in zip(copy.gyp_inputs, copy.gyp_outputs):
-      # 'cmake -E copy src dst' will create the 'dst' directory if needed.
-      output.write('COMMAND ${CMAKE_COMMAND} -E %s ' % copy.command)
-      output.write(src)
-      output.write(' ')
-      output.write(dst)
-      output.write("\n")
-
-  output.write('DEPENDS')
-  for copy in (file_copy, dir_copy):
-    if copy.inputs_name:
-      WriteVariable(output, copy.inputs_name, ' ')
-  output.write('\n')
-
-  output.write('WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/')
-  output.write(path_to_gyp)
-  output.write('\n')
-
-  output.write('COMMENT Copying for ')
-  output.write(target_name)
-  output.write('\n')
-
-  output.write('VERBATIM\n')
-  output.write(')\n')
-
-  # add_custom_target
-  output.write('add_custom_target(')
-  output.write(copy_name)
-  output.write('\n  DEPENDS')
-  for copy in (file_copy, dir_copy):
-    if copy.outputs_name:
-      WriteVariable(output, copy.outputs_name, ' ')
-  output.write('\n  SOURCES')
-  if file_copy.inputs_name:
-    WriteVariable(output, file_copy.inputs_name, ' ')
-  output.write('\n)\n')
-
-  extra_deps.append(copy_name)
 
 
 def CreateCMakeTargetBaseName(qualified_target):
-  """This is the name we would like the target to have."""
-  _, gyp_target_name, gyp_target_toolset = (
-      gyp.common.ParseQualifiedTarget(qualified_target))
-  cmake_target_base_name = gyp_target_name
-  if gyp_target_toolset and gyp_target_toolset != 'target':
-    cmake_target_base_name += '_' + gyp_target_toolset
-  return StringToCMakeTargetName(cmake_target_base_name)
+    """This is the name we would like the target to have."""
+    _, gyp_target_name, gyp_target_toolset = gyp.common.ParseQualifiedTarget(
+        qualified_target
+    )
+    cmake_target_base_name = gyp_target_name
+    if gyp_target_toolset and gyp_target_toolset != "target":
+        cmake_target_base_name += "_" + gyp_target_toolset
+    return StringToCMakeTargetName(cmake_target_base_name)
 
 
 def CreateCMakeTargetFullName(qualified_target):
-  """An unambiguous name for the target."""
-  gyp_file, gyp_target_name, gyp_target_toolset = (
-      gyp.common.ParseQualifiedTarget(qualified_target))
-  cmake_target_full_name = gyp_file + ':' + gyp_target_name
-  if gyp_target_toolset and gyp_target_toolset != 'target':
-    cmake_target_full_name += '_' + gyp_target_toolset
-  return StringToCMakeTargetName(cmake_target_full_name)
+    """An unambiguous name for the target."""
+    gyp_file, gyp_target_name, gyp_target_toolset = gyp.common.ParseQualifiedTarget(
+        qualified_target
+    )
+    cmake_target_full_name = gyp_file + ":" + gyp_target_name
+    if gyp_target_toolset and gyp_target_toolset != "target":
+        cmake_target_full_name += "_" + gyp_target_toolset
+    return StringToCMakeTargetName(cmake_target_full_name)
 
 
 class CMakeNamer(object):
-  """Converts Gyp target names into CMake target names.
+    """Converts Gyp target names into CMake target names.
 
   CMake requires that target names be globally unique. One way to ensure
   this is to fully qualify the names of the targets. Unfortunately, this
@@ -594,660 +607,721 @@ class CMakeNamer(object):
   building. However, it also makes sense for an IDE, as it is possible for
   defines to be different.
   """
-  def __init__(self, target_list):
-    self.cmake_target_base_names_conficting = set()
 
-    cmake_target_base_names_seen = set()
-    for qualified_target in target_list:
-      cmake_target_base_name = CreateCMakeTargetBaseName(qualified_target)
-
-      if cmake_target_base_name not in cmake_target_base_names_seen:
-        cmake_target_base_names_seen.add(cmake_target_base_name)
-      else:
-        self.cmake_target_base_names_conficting.add(cmake_target_base_name)
-
-  def CreateCMakeTargetName(self, qualified_target):
-    base_name = CreateCMakeTargetBaseName(qualified_target)
-    if base_name in self.cmake_target_base_names_conficting:
-      return CreateCMakeTargetFullName(qualified_target)
-    return base_name
-
-
-def WriteTarget(namer, qualified_target, target_dicts, build_dir, config_to_use,
-                options, generator_flags, all_qualified_targets, flavor,
-                output):
-  # The make generator does this always.
-  # TODO: It would be nice to be able to tell CMake all dependencies.
-  circular_libs = generator_flags.get('circular', True)
-
-  if not generator_flags.get('standalone', False):
-    output.write('\n#')
-    output.write(qualified_target)
-    output.write('\n')
-
-  gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
-  rel_gyp_file = gyp.common.RelativePath(gyp_file, options.toplevel_dir)
-  rel_gyp_dir = os.path.dirname(rel_gyp_file)
-
-  # Relative path from build dir to top dir.
-  build_to_top = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
-  # Relative path from build dir to gyp dir.
-  build_to_gyp = os.path.join(build_to_top, rel_gyp_dir)
-
-  path_from_cmakelists_to_gyp = build_to_gyp
-
-  spec = target_dicts.get(qualified_target, {})
-  config = spec.get('configurations', {}).get(config_to_use, {})
-
-  xcode_settings = None
-  if flavor == 'mac':
-    xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
-
-  target_name = spec.get('target_name', '<missing target name>')
-  target_type = spec.get('type', '<missing target type>')
-  target_toolset = spec.get('toolset')
-
-  cmake_target_type = cmake_target_type_from_gyp_target_type.get(target_type)
-  if cmake_target_type is None:
-    print('Target %s has unknown target type %s, skipping.' %
-          (        target_name,               target_type  ))
-    return
-
-  SetVariable(output, 'TARGET', target_name)
-  SetVariable(output, 'TOOLSET', target_toolset)
-
-  cmake_target_name = namer.CreateCMakeTargetName(qualified_target)
-
-  extra_sources = []
-  extra_deps = []
-
-  # Actions must come first, since they can generate more OBJs for use below.
-  if 'actions' in spec:
-    WriteActions(cmake_target_name, spec['actions'], extra_sources, extra_deps,
-                 path_from_cmakelists_to_gyp, output)
-
-  # Rules must be early like actions.
-  if 'rules' in spec:
-    WriteRules(cmake_target_name, spec['rules'], extra_sources, extra_deps,
-               path_from_cmakelists_to_gyp, output)
-
-  # Copies
-  if 'copies' in spec:
-    WriteCopies(cmake_target_name, spec['copies'], extra_deps,
-                path_from_cmakelists_to_gyp, output)
-
-  # Target and sources
-  srcs = spec.get('sources', [])
-
-  # Gyp separates the sheep from the goats based on file extensions.
-  # A full separation is done here because of flag handing (see below).
-  s_sources = []
-  c_sources = []
-  cxx_sources = []
-  linkable_sources = []
-  other_sources = []
-  for src in srcs:
-    _, ext = os.path.splitext(src)
-    src_type = COMPILABLE_EXTENSIONS.get(ext, None)
-    src_norm_path = NormjoinPath(path_from_cmakelists_to_gyp, src)
-
-    if src_type == 's':
-      s_sources.append(src_norm_path)
-    elif src_type == 'cc':
-      c_sources.append(src_norm_path)
-    elif src_type == 'cxx':
-      cxx_sources.append(src_norm_path)
-    elif Linkable(ext):
-      linkable_sources.append(src_norm_path)
-    else:
-      other_sources.append(src_norm_path)
-
-  for extra_source in extra_sources:
-    src, real_source = extra_source
-    _, ext = os.path.splitext(real_source)
-    src_type = COMPILABLE_EXTENSIONS.get(ext, None)
-
-    if src_type == 's':
-      s_sources.append(src)
-    elif src_type == 'cc':
-      c_sources.append(src)
-    elif src_type == 'cxx':
-      cxx_sources.append(src)
-    elif Linkable(ext):
-      linkable_sources.append(src)
-    else:
-      other_sources.append(src)
-
-  s_sources_name = None
-  if s_sources:
-    s_sources_name = cmake_target_name + '__asm_srcs'
-    SetVariableList(output, s_sources_name, s_sources)
-
-  c_sources_name = None
-  if c_sources:
-    c_sources_name = cmake_target_name + '__c_srcs'
-    SetVariableList(output, c_sources_name, c_sources)
-
-  cxx_sources_name = None
-  if cxx_sources:
-    cxx_sources_name = cmake_target_name + '__cxx_srcs'
-    SetVariableList(output, cxx_sources_name, cxx_sources)
-
-  linkable_sources_name = None
-  if linkable_sources:
-    linkable_sources_name = cmake_target_name + '__linkable_srcs'
-    SetVariableList(output, linkable_sources_name, linkable_sources)
-
-  other_sources_name = None
-  if other_sources:
-    other_sources_name = cmake_target_name + '__other_srcs'
-    SetVariableList(output, other_sources_name, other_sources)
-
-  # CMake gets upset when executable targets provide no sources.
-  # http://www.cmake.org/pipermail/cmake/2010-July/038461.html
-  dummy_sources_name = None
-  has_sources = (s_sources_name or
-                 c_sources_name or
-                 cxx_sources_name or
-                 linkable_sources_name or
-                 other_sources_name)
-  if target_type == 'executable' and not has_sources:
-    dummy_sources_name = cmake_target_name + '__dummy_srcs'
-    SetVariable(output, dummy_sources_name,
-                "${obj}.${TOOLSET}/${TARGET}/genc/dummy.c")
-    output.write('if(NOT EXISTS "')
-    WriteVariable(output, dummy_sources_name)
-    output.write('")\n')
-    output.write('  file(WRITE "')
-    WriteVariable(output, dummy_sources_name)
-    output.write('" "")\n')
-    output.write("endif()\n")
-
-
-  # CMake is opposed to setting linker directories and considers the practice
-  # of setting linker directories dangerous. Instead, it favors the use of
-  # find_library and passing absolute paths to target_link_libraries.
-  # However, CMake does provide the command link_directories, which adds
-  # link directories to targets defined after it is called.
-  # As a result, link_directories must come before the target definition.
-  # CMake unfortunately has no means of removing entries from LINK_DIRECTORIES.
-  library_dirs = config.get('library_dirs')
-  if library_dirs is not None:
-    output.write('link_directories(')
-    for library_dir in library_dirs:
-      output.write(' ')
-      output.write(NormjoinPath(path_from_cmakelists_to_gyp, library_dir))
-      output.write('\n')
-    output.write(')\n')
-
-  output.write(cmake_target_type.command)
-  output.write('(')
-  output.write(cmake_target_name)
-
-  if cmake_target_type.modifier is not None:
-    output.write(' ')
-    output.write(cmake_target_type.modifier)
-
-  if s_sources_name:
-    WriteVariable(output, s_sources_name, ' ')
-  if c_sources_name:
-    WriteVariable(output, c_sources_name, ' ')
-  if cxx_sources_name:
-    WriteVariable(output, cxx_sources_name, ' ')
-  if linkable_sources_name:
-    WriteVariable(output, linkable_sources_name, ' ')
-  if other_sources_name:
-    WriteVariable(output, other_sources_name, ' ')
-  if dummy_sources_name:
-    WriteVariable(output, dummy_sources_name, ' ')
-
-  output.write(')\n')
-
-  # Let CMake know if the 'all' target should depend on this target.
-  exclude_from_all = ('TRUE' if qualified_target not in all_qualified_targets
-                             else 'FALSE')
-  SetTargetProperty(output, cmake_target_name,
-                      'EXCLUDE_FROM_ALL', exclude_from_all)
-  for extra_target_name in extra_deps:
-    SetTargetProperty(output, extra_target_name,
-                        'EXCLUDE_FROM_ALL', exclude_from_all)
-
-  # Output name and location.
-  if target_type != 'none':
-    # Link as 'C' if there are no other files
-    if not c_sources and not cxx_sources:
-      SetTargetProperty(output, cmake_target_name, 'LINKER_LANGUAGE', ['C'])
-
-    # Mark uncompiled sources as uncompiled.
-    if other_sources_name:
-      output.write('set_source_files_properties(')
-      WriteVariable(output, other_sources_name, '')
-      output.write(' PROPERTIES HEADER_FILE_ONLY "TRUE")\n')
+    def __init__(self, target_list):
+        self.cmake_target_base_names_conficting = set()
+
+        cmake_target_base_names_seen = set()
+        for qualified_target in target_list:
+            cmake_target_base_name = CreateCMakeTargetBaseName(qualified_target)
+
+            if cmake_target_base_name not in cmake_target_base_names_seen:
+                cmake_target_base_names_seen.add(cmake_target_base_name)
+            else:
+                self.cmake_target_base_names_conficting.add(cmake_target_base_name)
+
+    def CreateCMakeTargetName(self, qualified_target):
+        base_name = CreateCMakeTargetBaseName(qualified_target)
+        if base_name in self.cmake_target_base_names_conficting:
+            return CreateCMakeTargetFullName(qualified_target)
+        return base_name
+
+
+def WriteTarget(
+    namer,
+    qualified_target,
+    target_dicts,
+    build_dir,
+    config_to_use,
+    options,
+    generator_flags,
+    all_qualified_targets,
+    flavor,
+    output,
+):
+    # The make generator does this always.
+    # TODO: It would be nice to be able to tell CMake all dependencies.
+    circular_libs = generator_flags.get("circular", True)
+
+    if not generator_flags.get("standalone", False):
+        output.write("\n#")
+        output.write(qualified_target)
+        output.write("\n")
+
+    gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
+    rel_gyp_file = gyp.common.RelativePath(gyp_file, options.toplevel_dir)
+    rel_gyp_dir = os.path.dirname(rel_gyp_file)
+
+    # Relative path from build dir to top dir.
+    build_to_top = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
+    # Relative path from build dir to gyp dir.
+    build_to_gyp = os.path.join(build_to_top, rel_gyp_dir)
+
+    path_from_cmakelists_to_gyp = build_to_gyp
+
+    spec = target_dicts.get(qualified_target, {})
+    config = spec.get("configurations", {}).get(config_to_use, {})
+
+    xcode_settings = None
+    if flavor == "mac":
+        xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
+
+    target_name = spec.get("target_name", "<missing target name>")
+    target_type = spec.get("type", "<missing target type>")
+    target_toolset = spec.get("toolset")
+
+    cmake_target_type = cmake_target_type_from_gyp_target_type.get(target_type)
+    if cmake_target_type is None:
+        print(
+            "Target %s has unknown target type %s, skipping."
+            % (target_name, target_type)
+        )
+        return
+
+    SetVariable(output, "TARGET", target_name)
+    SetVariable(output, "TOOLSET", target_toolset)
+
+    cmake_target_name = namer.CreateCMakeTargetName(qualified_target)
+
+    extra_sources = []
+    extra_deps = []
+
+    # Actions must come first, since they can generate more OBJs for use below.
+    if "actions" in spec:
+        WriteActions(
+            cmake_target_name,
+            spec["actions"],
+            extra_sources,
+            extra_deps,
+            path_from_cmakelists_to_gyp,
+            output,
+        )
+
+    # Rules must be early like actions.
+    if "rules" in spec:
+        WriteRules(
+            cmake_target_name,
+            spec["rules"],
+            extra_sources,
+            extra_deps,
+            path_from_cmakelists_to_gyp,
+            output,
+        )
+
+    # Copies
+    if "copies" in spec:
+        WriteCopies(
+            cmake_target_name,
+            spec["copies"],
+            extra_deps,
+            path_from_cmakelists_to_gyp,
+            output,
+        )
+
+    # Target and sources
+    srcs = spec.get("sources", [])
+
+    # Gyp separates the sheep from the goats based on file extensions.
+    # A full separation is done here because of flag handing (see below).
+    s_sources = []
+    c_sources = []
+    cxx_sources = []
+    linkable_sources = []
+    other_sources = []
+    for src in srcs:
+        _, ext = os.path.splitext(src)
+        src_type = COMPILABLE_EXTENSIONS.get(ext, None)
+        src_norm_path = NormjoinPath(path_from_cmakelists_to_gyp, src)
+
+        if src_type == "s":
+            s_sources.append(src_norm_path)
+        elif src_type == "cc":
+            c_sources.append(src_norm_path)
+        elif src_type == "cxx":
+            cxx_sources.append(src_norm_path)
+        elif Linkable(ext):
+            linkable_sources.append(src_norm_path)
+        else:
+            other_sources.append(src_norm_path)
+
+    for extra_source in extra_sources:
+        src, real_source = extra_source
+        _, ext = os.path.splitext(real_source)
+        src_type = COMPILABLE_EXTENSIONS.get(ext, None)
+
+        if src_type == "s":
+            s_sources.append(src)
+        elif src_type == "cc":
+            c_sources.append(src)
+        elif src_type == "cxx":
+            cxx_sources.append(src)
+        elif Linkable(ext):
+            linkable_sources.append(src)
+        else:
+            other_sources.append(src)
+
+    s_sources_name = None
+    if s_sources:
+        s_sources_name = cmake_target_name + "__asm_srcs"
+        SetVariableList(output, s_sources_name, s_sources)
+
+    c_sources_name = None
+    if c_sources:
+        c_sources_name = cmake_target_name + "__c_srcs"
+        SetVariableList(output, c_sources_name, c_sources)
+
+    cxx_sources_name = None
+    if cxx_sources:
+        cxx_sources_name = cmake_target_name + "__cxx_srcs"
+        SetVariableList(output, cxx_sources_name, cxx_sources)
+
+    linkable_sources_name = None
+    if linkable_sources:
+        linkable_sources_name = cmake_target_name + "__linkable_srcs"
+        SetVariableList(output, linkable_sources_name, linkable_sources)
+
+    other_sources_name = None
+    if other_sources:
+        other_sources_name = cmake_target_name + "__other_srcs"
+        SetVariableList(output, other_sources_name, other_sources)
+
+    # CMake gets upset when executable targets provide no sources.
+    # http://www.cmake.org/pipermail/cmake/2010-July/038461.html
+    dummy_sources_name = None
+    has_sources = (
+        s_sources_name
+        or c_sources_name
+        or cxx_sources_name
+        or linkable_sources_name
+        or other_sources_name
+    )
+    if target_type == "executable" and not has_sources:
+        dummy_sources_name = cmake_target_name + "__dummy_srcs"
+        SetVariable(
+            output, dummy_sources_name, "${obj}.${TOOLSET}/${TARGET}/genc/dummy.c"
+        )
+        output.write('if(NOT EXISTS "')
+        WriteVariable(output, dummy_sources_name)
+        output.write('")\n')
+        output.write('  file(WRITE "')
+        WriteVariable(output, dummy_sources_name)
+        output.write('" "")\n')
+        output.write("endif()\n")
+
+    # CMake is opposed to setting linker directories and considers the practice
+    # of setting linker directories dangerous. Instead, it favors the use of
+    # find_library and passing absolute paths to target_link_libraries.
+    # However, CMake does provide the command link_directories, which adds
+    # link directories to targets defined after it is called.
+    # As a result, link_directories must come before the target definition.
+    # CMake unfortunately has no means of removing entries from LINK_DIRECTORIES.
+    library_dirs = config.get("library_dirs")
+    if library_dirs is not None:
+        output.write("link_directories(")
+        for library_dir in library_dirs:
+            output.write(" ")
+            output.write(NormjoinPath(path_from_cmakelists_to_gyp, library_dir))
+            output.write("\n")
+        output.write(")\n")
+
+    output.write(cmake_target_type.command)
+    output.write("(")
+    output.write(cmake_target_name)
 
-    # Mark object sources as linkable.
+    if cmake_target_type.modifier is not None:
+        output.write(" ")
+        output.write(cmake_target_type.modifier)
+
+    if s_sources_name:
+        WriteVariable(output, s_sources_name, " ")
+    if c_sources_name:
+        WriteVariable(output, c_sources_name, " ")
+    if cxx_sources_name:
+        WriteVariable(output, cxx_sources_name, " ")
     if linkable_sources_name:
-      output.write('set_source_files_properties(')
-      WriteVariable(output, other_sources_name, '')
-      output.write(' PROPERTIES EXTERNAL_OBJECT "TRUE")\n')
-
-    # Output directory
-    target_output_directory = spec.get('product_dir')
-    if target_output_directory is None:
-      if target_type in ('executable', 'loadable_module'):
-        target_output_directory = generator_default_variables['PRODUCT_DIR']
-      elif target_type == 'shared_library':
-        target_output_directory = '${builddir}/lib.${TOOLSET}'
-      elif spec.get('standalone_static_library', False):
-        target_output_directory = generator_default_variables['PRODUCT_DIR']
-      else:
-        base_path = gyp.common.RelativePath(os.path.dirname(gyp_file),
-                                            options.toplevel_dir)
-        target_output_directory = '${obj}.${TOOLSET}'
-        target_output_directory = (
-            os.path.join(target_output_directory, base_path))
-
-    cmake_target_output_directory = NormjoinPathForceCMakeSource(
-                                        path_from_cmakelists_to_gyp,
-                                        target_output_directory)
-    SetTargetProperty(output,
-        cmake_target_name,
-        cmake_target_type.property_modifier + '_OUTPUT_DIRECTORY',
-        cmake_target_output_directory)
-
-    # Output name
-    default_product_prefix = ''
-    default_product_name = target_name
-    default_product_ext = ''
-    if target_type == 'static_library':
-      static_library_prefix = generator_default_variables['STATIC_LIB_PREFIX']
-      default_product_name = RemovePrefix(default_product_name,
-                                          static_library_prefix)
-      default_product_prefix = static_library_prefix
-      default_product_ext = generator_default_variables['STATIC_LIB_SUFFIX']
-
-    elif target_type in ('loadable_module', 'shared_library'):
-      shared_library_prefix = generator_default_variables['SHARED_LIB_PREFIX']
-      default_product_name = RemovePrefix(default_product_name,
-                                          shared_library_prefix)
-      default_product_prefix = shared_library_prefix
-      default_product_ext = generator_default_variables['SHARED_LIB_SUFFIX']
-
-    elif target_type != 'executable':
-      print('ERROR: What output file should be generated?',
-            'type', target_type, 'target', target_name)
-
-    product_prefix = spec.get('product_prefix', default_product_prefix)
-    product_name = spec.get('product_name', default_product_name)
-    product_ext = spec.get('product_extension')
-    if product_ext:
-      product_ext = '.' + product_ext
-    else:
-      product_ext = default_product_ext
-
-    SetTargetProperty(output, cmake_target_name, 'PREFIX', product_prefix)
-    SetTargetProperty(output, cmake_target_name,
-                        cmake_target_type.property_modifier + '_OUTPUT_NAME',
-                        product_name)
-    SetTargetProperty(output, cmake_target_name, 'SUFFIX', product_ext)
-
-    # Make the output of this target referenceable as a source.
-    cmake_target_output_basename = product_prefix + product_name + product_ext
-    cmake_target_output = os.path.join(cmake_target_output_directory,
-                                       cmake_target_output_basename)
-    SetFileProperty(output, cmake_target_output, 'GENERATED', ['TRUE'], '')
-
-    # Includes
-    includes = config.get('include_dirs')
-    if includes:
-      # This (target include directories) is what requires CMake 2.8.8
-      includes_name = cmake_target_name + '__include_dirs'
-      SetVariableList(output, includes_name,
-          [NormjoinPathForceCMakeSource(path_from_cmakelists_to_gyp, include)
-           for include in includes])
-      output.write('set_property(TARGET ')
-      output.write(cmake_target_name)
-      output.write(' APPEND PROPERTY INCLUDE_DIRECTORIES ')
-      WriteVariable(output, includes_name, '')
-      output.write(')\n')
-
-    # Defines
-    defines = config.get('defines')
-    if defines is not None:
-      SetTargetProperty(output,
-                        cmake_target_name,
-                        'COMPILE_DEFINITIONS',
-                        defines,
-                        ';')
-
-    # Compile Flags - http://www.cmake.org/Bug/view.php?id=6493
-    # CMake currently does not have target C and CXX flags.
-    # So, instead of doing...
-
-    # cflags_c = config.get('cflags_c')
-    # if cflags_c is not None:
-    #   SetTargetProperty(output, cmake_target_name,
-    #                       'C_COMPILE_FLAGS', cflags_c, ' ')
-
-    # cflags_cc = config.get('cflags_cc')
-    # if cflags_cc is not None:
-    #   SetTargetProperty(output, cmake_target_name,
-    #                       'CXX_COMPILE_FLAGS', cflags_cc, ' ')
-
-    # Instead we must...
-    cflags = config.get('cflags', [])
-    cflags_c = config.get('cflags_c', [])
-    cflags_cxx = config.get('cflags_cc', [])
-    if xcode_settings:
-      cflags = xcode_settings.GetCflags(config_to_use)
-      cflags_c = xcode_settings.GetCflagsC(config_to_use)
-      cflags_cxx = xcode_settings.GetCflagsCC(config_to_use)
-      #cflags_objc = xcode_settings.GetCflagsObjC(config_to_use)
-      #cflags_objcc = xcode_settings.GetCflagsObjCC(config_to_use)
-
-    if (not cflags_c or not c_sources) and (not cflags_cxx or not cxx_sources):
-      SetTargetProperty(output, cmake_target_name, 'COMPILE_FLAGS', cflags, ' ')
-
-    elif c_sources and not (s_sources or cxx_sources):
-      flags = []
-      flags.extend(cflags)
-      flags.extend(cflags_c)
-      SetTargetProperty(output, cmake_target_name, 'COMPILE_FLAGS', flags, ' ')
-
-    elif cxx_sources and not (s_sources or c_sources):
-      flags = []
-      flags.extend(cflags)
-      flags.extend(cflags_cxx)
-      SetTargetProperty(output, cmake_target_name, 'COMPILE_FLAGS', flags, ' ')
+        WriteVariable(output, linkable_sources_name, " ")
+    if other_sources_name:
+        WriteVariable(output, other_sources_name, " ")
+    if dummy_sources_name:
+        WriteVariable(output, dummy_sources_name, " ")
+
+    output.write(")\n")
+
+    # Let CMake know if the 'all' target should depend on this target.
+    exclude_from_all = (
+        "TRUE" if qualified_target not in all_qualified_targets else "FALSE"
+    )
+    SetTargetProperty(output, cmake_target_name, "EXCLUDE_FROM_ALL", exclude_from_all)
+    for extra_target_name in extra_deps:
+        SetTargetProperty(
+            output, extra_target_name, "EXCLUDE_FROM_ALL", exclude_from_all
+        )
+
+    # Output name and location.
+    if target_type != "none":
+        # Link as 'C' if there are no other files
+        if not c_sources and not cxx_sources:
+            SetTargetProperty(output, cmake_target_name, "LINKER_LANGUAGE", ["C"])
+
+        # Mark uncompiled sources as uncompiled.
+        if other_sources_name:
+            output.write("set_source_files_properties(")
+            WriteVariable(output, other_sources_name, "")
+            output.write(' PROPERTIES HEADER_FILE_ONLY "TRUE")\n')
+
+        # Mark object sources as linkable.
+        if linkable_sources_name:
+            output.write("set_source_files_properties(")
+            WriteVariable(output, other_sources_name, "")
+            output.write(' PROPERTIES EXTERNAL_OBJECT "TRUE")\n')
+
+        # Output directory
+        target_output_directory = spec.get("product_dir")
+        if target_output_directory is None:
+            if target_type in ("executable", "loadable_module"):
+                target_output_directory = generator_default_variables["PRODUCT_DIR"]
+            elif target_type == "shared_library":
+                target_output_directory = "${builddir}/lib.${TOOLSET}"
+            elif spec.get("standalone_static_library", False):
+                target_output_directory = generator_default_variables["PRODUCT_DIR"]
+            else:
+                base_path = gyp.common.RelativePath(
+                    os.path.dirname(gyp_file), options.toplevel_dir
+                )
+                target_output_directory = "${obj}.${TOOLSET}"
+                target_output_directory = os.path.join(
+                    target_output_directory, base_path
+                )
+
+        cmake_target_output_directory = NormjoinPathForceCMakeSource(
+            path_from_cmakelists_to_gyp, target_output_directory
+        )
+        SetTargetProperty(
+            output,
+            cmake_target_name,
+            cmake_target_type.property_modifier + "_OUTPUT_DIRECTORY",
+            cmake_target_output_directory,
+        )
+
+        # Output name
+        default_product_prefix = ""
+        default_product_name = target_name
+        default_product_ext = ""
+        if target_type == "static_library":
+            static_library_prefix = generator_default_variables["STATIC_LIB_PREFIX"]
+            default_product_name = RemovePrefix(
+                default_product_name, static_library_prefix
+            )
+            default_product_prefix = static_library_prefix
+            default_product_ext = generator_default_variables["STATIC_LIB_SUFFIX"]
+
+        elif target_type in ("loadable_module", "shared_library"):
+            shared_library_prefix = generator_default_variables["SHARED_LIB_PREFIX"]
+            default_product_name = RemovePrefix(
+                default_product_name, shared_library_prefix
+            )
+            default_product_prefix = shared_library_prefix
+            default_product_ext = generator_default_variables["SHARED_LIB_SUFFIX"]
+
+        elif target_type != "executable":
+            print(
+                "ERROR: What output file should be generated?",
+                "type",
+                target_type,
+                "target",
+                target_name,
+            )
+
+        product_prefix = spec.get("product_prefix", default_product_prefix)
+        product_name = spec.get("product_name", default_product_name)
+        product_ext = spec.get("product_extension")
+        if product_ext:
+            product_ext = "." + product_ext
+        else:
+            product_ext = default_product_ext
+
+        SetTargetProperty(output, cmake_target_name, "PREFIX", product_prefix)
+        SetTargetProperty(
+            output,
+            cmake_target_name,
+            cmake_target_type.property_modifier + "_OUTPUT_NAME",
+            product_name,
+        )
+        SetTargetProperty(output, cmake_target_name, "SUFFIX", product_ext)
+
+        # Make the output of this target referenceable as a source.
+        cmake_target_output_basename = product_prefix + product_name + product_ext
+        cmake_target_output = os.path.join(
+            cmake_target_output_directory, cmake_target_output_basename
+        )
+        SetFileProperty(output, cmake_target_output, "GENERATED", ["TRUE"], "")
+
+        # Includes
+        includes = config.get("include_dirs")
+        if includes:
+            # This (target include directories) is what requires CMake 2.8.8
+            includes_name = cmake_target_name + "__include_dirs"
+            SetVariableList(
+                output,
+                includes_name,
+                [
+                    NormjoinPathForceCMakeSource(path_from_cmakelists_to_gyp, include)
+                    for include in includes
+                ],
+            )
+            output.write("set_property(TARGET ")
+            output.write(cmake_target_name)
+            output.write(" APPEND PROPERTY INCLUDE_DIRECTORIES ")
+            WriteVariable(output, includes_name, "")
+            output.write(")\n")
+
+        # Defines
+        defines = config.get("defines")
+        if defines is not None:
+            SetTargetProperty(
+                output, cmake_target_name, "COMPILE_DEFINITIONS", defines, ";"
+            )
+
+        # Compile Flags - http://www.cmake.org/Bug/view.php?id=6493
+        # CMake currently does not have target C and CXX flags.
+        # So, instead of doing...
+
+        # cflags_c = config.get('cflags_c')
+        # if cflags_c is not None:
+        #   SetTargetProperty(output, cmake_target_name,
+        #                       'C_COMPILE_FLAGS', cflags_c, ' ')
+
+        # cflags_cc = config.get('cflags_cc')
+        # if cflags_cc is not None:
+        #   SetTargetProperty(output, cmake_target_name,
+        #                       'CXX_COMPILE_FLAGS', cflags_cc, ' ')
+
+        # Instead we must...
+        cflags = config.get("cflags", [])
+        cflags_c = config.get("cflags_c", [])
+        cflags_cxx = config.get("cflags_cc", [])
+        if xcode_settings:
+            cflags = xcode_settings.GetCflags(config_to_use)
+            cflags_c = xcode_settings.GetCflagsC(config_to_use)
+            cflags_cxx = xcode_settings.GetCflagsCC(config_to_use)
+            # cflags_objc = xcode_settings.GetCflagsObjC(config_to_use)
+            # cflags_objcc = xcode_settings.GetCflagsObjCC(config_to_use)
+
+        if (not cflags_c or not c_sources) and (not cflags_cxx or not cxx_sources):
+            SetTargetProperty(output, cmake_target_name, "COMPILE_FLAGS", cflags, " ")
+
+        elif c_sources and not (s_sources or cxx_sources):
+            flags = []
+            flags.extend(cflags)
+            flags.extend(cflags_c)
+            SetTargetProperty(output, cmake_target_name, "COMPILE_FLAGS", flags, " ")
+
+        elif cxx_sources and not (s_sources or c_sources):
+            flags = []
+            flags.extend(cflags)
+            flags.extend(cflags_cxx)
+            SetTargetProperty(output, cmake_target_name, "COMPILE_FLAGS", flags, " ")
+
+        else:
+            # TODO: This is broken, one cannot generally set properties on files,
+            # as other targets may require different properties on the same files.
+            if s_sources and cflags:
+                SetFilesProperty(output, s_sources_name, "COMPILE_FLAGS", cflags, " ")
+
+            if c_sources and (cflags or cflags_c):
+                flags = []
+                flags.extend(cflags)
+                flags.extend(cflags_c)
+                SetFilesProperty(output, c_sources_name, "COMPILE_FLAGS", flags, " ")
+
+            if cxx_sources and (cflags or cflags_cxx):
+                flags = []
+                flags.extend(cflags)
+                flags.extend(cflags_cxx)
+                SetFilesProperty(output, cxx_sources_name, "COMPILE_FLAGS", flags, " ")
+
+        # Linker flags
+        ldflags = config.get("ldflags")
+        if ldflags is not None:
+            SetTargetProperty(output, cmake_target_name, "LINK_FLAGS", ldflags, " ")
+
+        # XCode settings
+        xcode_settings = config.get("xcode_settings", {})
+        for xcode_setting, xcode_value in xcode_settings.items():
+            SetTargetProperty(
+                output,
+                cmake_target_name,
+                "XCODE_ATTRIBUTE_%s" % xcode_setting,
+                xcode_value,
+                "" if isinstance(xcode_value, str) else " ",
+            )
+
+    # Note on Dependencies and Libraries:
+    # CMake wants to handle link order, resolving the link line up front.
+    # Gyp does not retain or enforce specifying enough information to do so.
+    # So do as other gyp generators and use --start-group and --end-group.
+    # Give CMake as little information as possible so that it doesn't mess it up.
+
+    # Dependencies
+    rawDeps = spec.get("dependencies", [])
+
+    static_deps = []
+    shared_deps = []
+    other_deps = []
+    for rawDep in rawDeps:
+        dep_cmake_name = namer.CreateCMakeTargetName(rawDep)
+        dep_spec = target_dicts.get(rawDep, {})
+        dep_target_type = dep_spec.get("type", None)
+
+        if dep_target_type == "static_library":
+            static_deps.append(dep_cmake_name)
+        elif dep_target_type == "shared_library":
+            shared_deps.append(dep_cmake_name)
+        else:
+            other_deps.append(dep_cmake_name)
+
+    # ensure all external dependencies are complete before internal dependencies
+    # extra_deps currently only depend on their own deps, so otherwise run early
+    if static_deps or shared_deps or other_deps:
+        for extra_dep in extra_deps:
+            output.write("add_dependencies(")
+            output.write(extra_dep)
+            output.write("\n")
+            for deps in (static_deps, shared_deps, other_deps):
+                for dep in gyp.common.uniquer(deps):
+                    output.write("  ")
+                    output.write(dep)
+                    output.write("\n")
+            output.write(")\n")
+
+    linkable = target_type in ("executable", "loadable_module", "shared_library")
+    other_deps.extend(extra_deps)
+    if other_deps or (not linkable and (static_deps or shared_deps)):
+        output.write("add_dependencies(")
+        output.write(cmake_target_name)
+        output.write("\n")
+        for dep in gyp.common.uniquer(other_deps):
+            output.write("  ")
+            output.write(dep)
+            output.write("\n")
+        if not linkable:
+            for deps in (static_deps, shared_deps):
+                for lib_dep in gyp.common.uniquer(deps):
+                    output.write("  ")
+                    output.write(lib_dep)
+                    output.write("\n")
+        output.write(")\n")
+
+    # Libraries
+    if linkable:
+        external_libs = [lib for lib in spec.get("libraries", []) if len(lib) > 0]
+        if external_libs or static_deps or shared_deps:
+            output.write("target_link_libraries(")
+            output.write(cmake_target_name)
+            output.write("\n")
+            if static_deps:
+                write_group = circular_libs and len(static_deps) > 1 and flavor != "mac"
+                if write_group:
+                    output.write("-Wl,--start-group\n")
+                for dep in gyp.common.uniquer(static_deps):
+                    output.write("  ")
+                    output.write(dep)
+                    output.write("\n")
+                if write_group:
+                    output.write("-Wl,--end-group\n")
+            if shared_deps:
+                for dep in gyp.common.uniquer(shared_deps):
+                    output.write("  ")
+                    output.write(dep)
+                    output.write("\n")
+            if external_libs:
+                for lib in gyp.common.uniquer(external_libs):
+                    output.write('  "')
+                    output.write(RemovePrefix(lib, "$(SDKROOT)"))
+                    output.write('"\n')
+
+            output.write(")\n")
+
+    UnsetVariable(output, "TOOLSET")
+    UnsetVariable(output, "TARGET")
+
+
+def GenerateOutputForConfig(target_list, target_dicts, data, params, config_to_use):
+    options = params["options"]
+    generator_flags = params["generator_flags"]
+    flavor = gyp.common.GetFlavor(params)
+
+    # generator_dir: relative path from pwd to where make puts build files.
+    # Makes migrating from make to cmake easier, cmake doesn't put anything here.
+    # Each Gyp configuration creates a different CMakeLists.txt file
+    # to avoid incompatibilities between Gyp and CMake configurations.
+    generator_dir = os.path.relpath(options.generator_output or ".")
+
+    # output_dir: relative path from generator_dir to the build directory.
+    output_dir = generator_flags.get("output_dir", "out")
 
-    else:
-      # TODO: This is broken, one cannot generally set properties on files,
-      # as other targets may require different properties on the same files.
-      if s_sources and cflags:
-        SetFilesProperty(output, s_sources_name, 'COMPILE_FLAGS', cflags, ' ')
-
-      if c_sources and (cflags or cflags_c):
-        flags = []
-        flags.extend(cflags)
-        flags.extend(cflags_c)
-        SetFilesProperty(output, c_sources_name, 'COMPILE_FLAGS', flags, ' ')
-
-      if cxx_sources and (cflags or cflags_cxx):
-        flags = []
-        flags.extend(cflags)
-        flags.extend(cflags_cxx)
-        SetFilesProperty(output, cxx_sources_name, 'COMPILE_FLAGS', flags, ' ')
-
-    # Linker flags
-    ldflags = config.get('ldflags')
-    if ldflags is not None:
-      SetTargetProperty(output, cmake_target_name, 'LINK_FLAGS', ldflags, ' ')
-
-    # XCode settings
-    xcode_settings = config.get('xcode_settings', {})
-    for xcode_setting, xcode_value in xcode_settings.viewitems():
-      SetTargetProperty(output, cmake_target_name,
-                        "XCODE_ATTRIBUTE_%s" % xcode_setting, xcode_value,
-                        '' if isinstance(xcode_value, str) else ' ')
-
-  # Note on Dependencies and Libraries:
-  # CMake wants to handle link order, resolving the link line up front.
-  # Gyp does not retain or enforce specifying enough information to do so.
-  # So do as other gyp generators and use --start-group and --end-group.
-  # Give CMake as little information as possible so that it doesn't mess it up.
-
-  # Dependencies
-  rawDeps = spec.get('dependencies', [])
-
-  static_deps = []
-  shared_deps = []
-  other_deps = []
-  for rawDep in rawDeps:
-    dep_cmake_name = namer.CreateCMakeTargetName(rawDep)
-    dep_spec = target_dicts.get(rawDep, {})
-    dep_target_type = dep_spec.get('type', None)
-
-    if dep_target_type == 'static_library':
-      static_deps.append(dep_cmake_name)
-    elif dep_target_type ==  'shared_library':
-      shared_deps.append(dep_cmake_name)
-    else:
-      other_deps.append(dep_cmake_name)
-
-  # ensure all external dependencies are complete before internal dependencies
-  # extra_deps currently only depend on their own deps, so otherwise run early
-  if static_deps or shared_deps or other_deps:
-    for extra_dep in extra_deps:
-      output.write('add_dependencies(')
-      output.write(extra_dep)
-      output.write('\n')
-      for deps in (static_deps, shared_deps, other_deps):
-        for dep in gyp.common.uniquer(deps):
-          output.write('  ')
-          output.write(dep)
-          output.write('\n')
-      output.write(')\n')
-
-  linkable = target_type in ('executable', 'loadable_module', 'shared_library')
-  other_deps.extend(extra_deps)
-  if other_deps or (not linkable and (static_deps or shared_deps)):
-    output.write('add_dependencies(')
-    output.write(cmake_target_name)
-    output.write('\n')
-    for dep in gyp.common.uniquer(other_deps):
-      output.write('  ')
-      output.write(dep)
-      output.write('\n')
-    if not linkable:
-      for deps in (static_deps, shared_deps):
-        for lib_dep in gyp.common.uniquer(deps):
-          output.write('  ')
-          output.write(lib_dep)
-          output.write('\n')
-    output.write(')\n')
-
-  # Libraries
-  if linkable:
-    external_libs = [lib for lib in spec.get('libraries', []) if len(lib) > 0]
-    if external_libs or static_deps or shared_deps:
-      output.write('target_link_libraries(')
-      output.write(cmake_target_name)
-      output.write('\n')
-      if static_deps:
-        write_group = circular_libs and len(static_deps) > 1 and flavor != 'mac'
-        if write_group:
-          output.write('-Wl,--start-group\n')
-        for dep in gyp.common.uniquer(static_deps):
-          output.write('  ')
-          output.write(dep)
-          output.write('\n')
-        if write_group:
-          output.write('-Wl,--end-group\n')
-      if shared_deps:
-        for dep in gyp.common.uniquer(shared_deps):
-          output.write('  ')
-          output.write(dep)
-          output.write('\n')
-      if external_libs:
-        for lib in gyp.common.uniquer(external_libs):
-          output.write('  "')
-          output.write(RemovePrefix(lib, "$(SDKROOT)"))
-          output.write('"\n')
-
-      output.write(')\n')
-
-  UnsetVariable(output, 'TOOLSET')
-  UnsetVariable(output, 'TARGET')
-
-
-def GenerateOutputForConfig(target_list, target_dicts, data,
-                            params, config_to_use):
-  options = params['options']
-  generator_flags = params['generator_flags']
-  flavor = gyp.common.GetFlavor(params)
-
-  # generator_dir: relative path from pwd to where make puts build files.
-  # Makes migrating from make to cmake easier, cmake doesn't put anything here.
-  # Each Gyp configuration creates a different CMakeLists.txt file
-  # to avoid incompatibilities between Gyp and CMake configurations.
-  generator_dir = os.path.relpath(options.generator_output or '.')
-
-  # output_dir: relative path from generator_dir to the build directory.
-  output_dir = generator_flags.get('output_dir', 'out')
-
-  # build_dir: relative path from source root to our output files.
-  # e.g. "out/Debug"
-  build_dir = os.path.normpath(os.path.join(generator_dir,
-                                            output_dir,
-                                            config_to_use))
-
-  toplevel_build = os.path.join(options.toplevel_dir, build_dir)
-
-  output_file = os.path.join(toplevel_build, 'CMakeLists.txt')
-  gyp.common.EnsureDirExists(output_file)
-
-  output = open(output_file, 'w')
-  output.write('cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n')
-  output.write('cmake_policy(VERSION 2.8.8)\n')
-
-  gyp_file, project_target, _ = gyp.common.ParseQualifiedTarget(target_list[-1])
-  output.write('project(')
-  output.write(project_target)
-  output.write(')\n')
-
-  SetVariable(output, 'configuration', config_to_use)
-
-  ar = None
-  cc = None
-  cxx = None
-
-  make_global_settings = data[gyp_file].get('make_global_settings', [])
-  build_to_top = gyp.common.InvertRelativePath(build_dir,
-                                               options.toplevel_dir)
-  for key, value in make_global_settings:
-    if key == 'AR':
-      ar = os.path.join(build_to_top, value)
-    if key == 'CC':
-      cc = os.path.join(build_to_top, value)
-    if key == 'CXX':
-      cxx = os.path.join(build_to_top, value)
-
-  ar = gyp.common.GetEnvironFallback(['AR_target', 'AR'], ar)
-  cc = gyp.common.GetEnvironFallback(['CC_target', 'CC'], cc)
-  cxx = gyp.common.GetEnvironFallback(['CXX_target', 'CXX'], cxx)
-
-  if ar:
-    SetVariable(output, 'CMAKE_AR', ar)
-  if cc:
-    SetVariable(output, 'CMAKE_C_COMPILER', cc)
-  if cxx:
-    SetVariable(output, 'CMAKE_CXX_COMPILER', cxx)
-
-  # The following appears to be as-yet undocumented.
-  # http://public.kitware.com/Bug/view.php?id=8392
-  output.write('enable_language(ASM)\n')
-  # ASM-ATT does not support .S files.
-  # output.write('enable_language(ASM-ATT)\n')
-
-  if cc:
-    SetVariable(output, 'CMAKE_ASM_COMPILER', cc)
-
-  SetVariable(output, 'builddir', '${CMAKE_CURRENT_BINARY_DIR}')
-  SetVariable(output, 'obj', '${builddir}/obj')
-  output.write('\n')
-
-  # TODO: Undocumented/unsupported (the CMake Java generator depends on it).
-  # CMake by default names the object resulting from foo.c to be foo.c.o.
-  # Gyp traditionally names the object resulting from foo.c foo.o.
-  # This should be irrelevant, but some targets extract .o files from .a
-  # and depend on the name of the extracted .o files.
-  output.write('set(CMAKE_C_OUTPUT_EXTENSION_REPLACE 1)\n')
-  output.write('set(CMAKE_CXX_OUTPUT_EXTENSION_REPLACE 1)\n')
-  output.write('\n')
-
-  # Force ninja to use rsp files. Otherwise link and ar lines can get too long,
-  # resulting in 'Argument list too long' errors.
-  # However, rsp files don't work correctly on Mac.
-  if flavor != 'mac':
-    output.write('set(CMAKE_NINJA_FORCE_RESPONSE_FILE 1)\n')
-  output.write('\n')
-
-  namer = CMakeNamer(target_list)
-
-  # The list of targets upon which the 'all' target should depend.
-  # CMake has it's own implicit 'all' target, one is not created explicitly.
-  all_qualified_targets = set()
-  for build_file in params['build_files']:
-    for qualified_target in gyp.common.AllTargets(target_list,
-                                                  target_dicts,
-                                                  os.path.normpath(build_file)):
-      all_qualified_targets.add(qualified_target)
-
-  for qualified_target in target_list:
-    if flavor == 'mac':
-      gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
-      spec = target_dicts[qualified_target]
-      gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[gyp_file], spec)
-
-    WriteTarget(namer, qualified_target, target_dicts, build_dir, config_to_use,
-                options, generator_flags, all_qualified_targets, flavor, output)
-
-  output.close()
+    # build_dir: relative path from source root to our output files.
+    # e.g. "out/Debug"
+    build_dir = os.path.normpath(os.path.join(generator_dir, output_dir, config_to_use))
+
+    toplevel_build = os.path.join(options.toplevel_dir, build_dir)
+
+    output_file = os.path.join(toplevel_build, "CMakeLists.txt")
+    gyp.common.EnsureDirExists(output_file)
+
+    output = open(output_file, "w")
+    output.write("cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n")
+    output.write("cmake_policy(VERSION 2.8.8)\n")
+
+    gyp_file, project_target, _ = gyp.common.ParseQualifiedTarget(target_list[-1])
+    output.write("project(")
+    output.write(project_target)
+    output.write(")\n")
+
+    SetVariable(output, "configuration", config_to_use)
+
+    ar = None
+    cc = None
+    cxx = None
+
+    make_global_settings = data[gyp_file].get("make_global_settings", [])
+    build_to_top = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
+    for key, value in make_global_settings:
+        if key == "AR":
+            ar = os.path.join(build_to_top, value)
+        if key == "CC":
+            cc = os.path.join(build_to_top, value)
+        if key == "CXX":
+            cxx = os.path.join(build_to_top, value)
+
+    ar = gyp.common.GetEnvironFallback(["AR_target", "AR"], ar)
+    cc = gyp.common.GetEnvironFallback(["CC_target", "CC"], cc)
+    cxx = gyp.common.GetEnvironFallback(["CXX_target", "CXX"], cxx)
+
+    if ar:
+        SetVariable(output, "CMAKE_AR", ar)
+    if cc:
+        SetVariable(output, "CMAKE_C_COMPILER", cc)
+    if cxx:
+        SetVariable(output, "CMAKE_CXX_COMPILER", cxx)
+
+    # The following appears to be as-yet undocumented.
+    # http://public.kitware.com/Bug/view.php?id=8392
+    output.write("enable_language(ASM)\n")
+    # ASM-ATT does not support .S files.
+    # output.write('enable_language(ASM-ATT)\n')
+
+    if cc:
+        SetVariable(output, "CMAKE_ASM_COMPILER", cc)
+
+    SetVariable(output, "builddir", "${CMAKE_CURRENT_BINARY_DIR}")
+    SetVariable(output, "obj", "${builddir}/obj")
+    output.write("\n")
+
+    # TODO: Undocumented/unsupported (the CMake Java generator depends on it).
+    # CMake by default names the object resulting from foo.c to be foo.c.o.
+    # Gyp traditionally names the object resulting from foo.c foo.o.
+    # This should be irrelevant, but some targets extract .o files from .a
+    # and depend on the name of the extracted .o files.
+    output.write("set(CMAKE_C_OUTPUT_EXTENSION_REPLACE 1)\n")
+    output.write("set(CMAKE_CXX_OUTPUT_EXTENSION_REPLACE 1)\n")
+    output.write("\n")
+
+    # Force ninja to use rsp files. Otherwise link and ar lines can get too long,
+    # resulting in 'Argument list too long' errors.
+    # However, rsp files don't work correctly on Mac.
+    if flavor != "mac":
+        output.write("set(CMAKE_NINJA_FORCE_RESPONSE_FILE 1)\n")
+    output.write("\n")
+
+    namer = CMakeNamer(target_list)
+
+    # The list of targets upon which the 'all' target should depend.
+    # CMake has it's own implicit 'all' target, one is not created explicitly.
+    all_qualified_targets = set()
+    for build_file in params["build_files"]:
+        for qualified_target in gyp.common.AllTargets(
+            target_list, target_dicts, os.path.normpath(build_file)
+        ):
+            all_qualified_targets.add(qualified_target)
+
+    for qualified_target in target_list:
+        if flavor == "mac":
+            gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
+            spec = target_dicts[qualified_target]
+            gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[gyp_file], spec)
+
+        WriteTarget(
+            namer,
+            qualified_target,
+            target_dicts,
+            build_dir,
+            config_to_use,
+            options,
+            generator_flags,
+            all_qualified_targets,
+            flavor,
+            output,
+        )
+
+    output.close()
 
 
 def PerformBuild(data, configurations, params):
-  options = params['options']
-  generator_flags = params['generator_flags']
+    options = params["options"]
+    generator_flags = params["generator_flags"]
 
-  # generator_dir: relative path from pwd to where make puts build files.
-  # Makes migrating from make to cmake easier, cmake doesn't put anything here.
-  generator_dir = os.path.relpath(options.generator_output or '.')
+    # generator_dir: relative path from pwd to where make puts build files.
+    # Makes migrating from make to cmake easier, cmake doesn't put anything here.
+    generator_dir = os.path.relpath(options.generator_output or ".")
 
-  # output_dir: relative path from generator_dir to the build directory.
-  output_dir = generator_flags.get('output_dir', 'out')
+    # output_dir: relative path from generator_dir to the build directory.
+    output_dir = generator_flags.get("output_dir", "out")
 
-  for config_name in configurations:
-    # build_dir: relative path from source root to our output files.
-    # e.g. "out/Debug"
-    build_dir = os.path.normpath(os.path.join(generator_dir,
-                                              output_dir,
-                                              config_name))
-    arguments = ['cmake', '-G', 'Ninja']
-    print('Generating [%s]: %s' % (config_name, arguments))
-    subprocess.check_call(arguments, cwd=build_dir)
+    for config_name in configurations:
+        # build_dir: relative path from source root to our output files.
+        # e.g. "out/Debug"
+        build_dir = os.path.normpath(
+            os.path.join(generator_dir, output_dir, config_name)
+        )
+        arguments = ["cmake", "-G", "Ninja"]
+        print("Generating [%s]: %s" % (config_name, arguments))
+        subprocess.check_call(arguments, cwd=build_dir)
 
-    arguments = ['ninja', '-C', build_dir]
-    print('Building [%s]: %s' % (config_name, arguments))
-    subprocess.check_call(arguments)
+        arguments = ["ninja", "-C", build_dir]
+        print("Building [%s]: %s" % (config_name, arguments))
+        subprocess.check_call(arguments)
 
 
 def CallGenerateOutputForConfig(arglist):
-  # Ignore the interrupt signal so that the parent process catches it and
-  # kills all multiprocessing children.
-  signal.signal(signal.SIGINT, signal.SIG_IGN)
+    # Ignore the interrupt signal so that the parent process catches it and
+    # kills all multiprocessing children.
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
 
-  target_list, target_dicts, data, params, config_name = arglist
-  GenerateOutputForConfig(target_list, target_dicts, data, params, config_name)
+    target_list, target_dicts, data, params, config_name = arglist
+    GenerateOutputForConfig(target_list, target_dicts, data, params, config_name)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  user_config = params.get('generator_flags', {}).get('config', None)
-  if user_config:
-    GenerateOutputForConfig(target_list, target_dicts, data,
-                            params, user_config)
-  else:
-    config_names = target_dicts[target_list[0]]['configurations'].keys()
-    if params['parallel']:
-      try:
-        pool = multiprocessing.Pool(len(config_names))
-        arglists = []
-        for config_name in config_names:
-          arglists.append((target_list, target_dicts, data,
-                           params, config_name))
-          pool.map(CallGenerateOutputForConfig, arglists)
-      except KeyboardInterrupt as e:
-        pool.terminate()
-        raise e
+    user_config = params.get("generator_flags", {}).get("config", None)
+    if user_config:
+        GenerateOutputForConfig(target_list, target_dicts, data, params, user_config)
     else:
-      for config_name in config_names:
-        GenerateOutputForConfig(target_list, target_dicts, data,
-                                params, config_name)
+        config_names = target_dicts[target_list[0]]["configurations"]
+        if params["parallel"]:
+            try:
+                pool = multiprocessing.Pool(len(config_names))
+                arglists = []
+                for config_name in config_names:
+                    arglists.append(
+                        (target_list, target_dicts, data, params, config_name)
+                    )
+                    pool.map(CallGenerateOutputForConfig, arglists)
+            except KeyboardInterrupt as e:
+                pool.terminate()
+                raise e
+        else:
+            for config_name in config_names:
+                GenerateOutputForConfig(
+                    target_list, target_dicts, data, params, config_name
+                )
diff --git a/tools/gyp/pylib/gyp/generator/compile_commands_json.py b/tools/gyp/pylib/gyp/generator/compile_commands_json.py
index 1b8490451f9793259988a6943b0b6c5d95cf46d3..f330a04dea4c53b393d728eac7c192f39ca35cbb 100644
--- a/tools/gyp/pylib/gyp/generator/compile_commands_json.py
+++ b/tools/gyp/pylib/gyp/generator/compile_commands_json.py
@@ -16,100 +16,105 @@ generator_wants_sorted_dependencies = False
 
 # Lifted from make.py.  The actual values don't matter much.
 generator_default_variables = {
-  'CONFIGURATION_NAME': '$(BUILDTYPE)',
-  'EXECUTABLE_PREFIX': '',
-  'EXECUTABLE_SUFFIX': '',
-  'INTERMEDIATE_DIR': '$(obj).$(TOOLSET)/$(TARGET)/geni',
-  'PRODUCT_DIR': '$(builddir)',
-  'RULE_INPUT_DIRNAME': '%(INPUT_DIRNAME)s',
-  'RULE_INPUT_EXT': '$(suffix $<)',
-  'RULE_INPUT_NAME': '$(notdir $<)',
-  'RULE_INPUT_PATH': '$(abspath $<)',
-  'RULE_INPUT_ROOT': '%(INPUT_ROOT)s',
-  'SHARED_INTERMEDIATE_DIR': '$(obj)/gen',
-  'SHARED_LIB_PREFIX': 'lib',
-  'STATIC_LIB_PREFIX': 'lib',
-  'STATIC_LIB_SUFFIX': '.a',
+    "CONFIGURATION_NAME": "$(BUILDTYPE)",
+    "EXECUTABLE_PREFIX": "",
+    "EXECUTABLE_SUFFIX": "",
+    "INTERMEDIATE_DIR": "$(obj).$(TOOLSET)/$(TARGET)/geni",
+    "PRODUCT_DIR": "$(builddir)",
+    "RULE_INPUT_DIRNAME": "%(INPUT_DIRNAME)s",
+    "RULE_INPUT_EXT": "$(suffix $<)",
+    "RULE_INPUT_NAME": "$(notdir $<)",
+    "RULE_INPUT_PATH": "$(abspath $<)",
+    "RULE_INPUT_ROOT": "%(INPUT_ROOT)s",
+    "SHARED_INTERMEDIATE_DIR": "$(obj)/gen",
+    "SHARED_LIB_PREFIX": "lib",
+    "STATIC_LIB_PREFIX": "lib",
+    "STATIC_LIB_SUFFIX": ".a",
 }
 
 
 def IsMac(params):
-  return 'mac' == gyp.common.GetFlavor(params)
+    return "mac" == gyp.common.GetFlavor(params)
 
 
 def CalculateVariables(default_variables, params):
-  default_variables.setdefault('OS', gyp.common.GetFlavor(params))
+    default_variables.setdefault("OS", gyp.common.GetFlavor(params))
 
 
 def AddCommandsForTarget(cwd, target, params, per_config_commands):
-  output_dir = params['generator_flags']['output_dir']
-  for configuration_name, configuration in target['configurations'].items():
-    builddir_name = os.path.join(output_dir, configuration_name)
-
-    if IsMac(params):
-      xcode_settings = gyp.xcode_emulation.XcodeSettings(target)
-      cflags = xcode_settings.GetCflags(configuration_name)
-      cflags_c = xcode_settings.GetCflagsC(configuration_name)
-      cflags_cc = xcode_settings.GetCflagsCC(configuration_name)
-    else:
-      cflags = configuration.get('cflags', [])
-      cflags_c = configuration.get('cflags_c', [])
-      cflags_cc = configuration.get('cflags_cc', [])
-
-    cflags_c = cflags + cflags_c
-    cflags_cc = cflags + cflags_cc
-
-    defines = configuration.get('defines', [])
-    defines = ['-D' + s for s in defines]
-
-    # TODO(bnoordhuis) Handle generated source files.
-    sources = target.get('sources', [])
-    sources = [s for s in sources if s.endswith('.c') or s.endswith('.cc')]
-
-    def resolve(filename):
-      return os.path.abspath(os.path.join(cwd, filename))
-
-    # TODO(bnoordhuis) Handle generated header files.
-    include_dirs = configuration.get('include_dirs', [])
-    include_dirs = [s for s in include_dirs if not s.startswith('$(obj)')]
-    includes = ['-I' + resolve(s) for s in include_dirs]
-
-    defines = gyp.common.EncodePOSIXShellList(defines)
-    includes = gyp.common.EncodePOSIXShellList(includes)
-    cflags_c = gyp.common.EncodePOSIXShellList(cflags_c)
-    cflags_cc = gyp.common.EncodePOSIXShellList(cflags_cc)
-
-    commands = per_config_commands.setdefault(configuration_name, [])
-    for source in sources:
-      file = resolve(source)
-      isc = source.endswith('.c')
-      cc = 'cc' if isc else 'c++'
-      cflags = cflags_c if isc else cflags_cc
-      command = ' '.join((cc, defines, includes, cflags,
-                          '-c', gyp.common.EncodePOSIXShellArgument(file)))
-      commands.append(dict(command=command, directory=output_dir, file=file))
+    output_dir = params["generator_flags"].get("output_dir", "out")
+    for configuration_name, configuration in target["configurations"].items():
+        if IsMac(params):
+            xcode_settings = gyp.xcode_emulation.XcodeSettings(target)
+            cflags = xcode_settings.GetCflags(configuration_name)
+            cflags_c = xcode_settings.GetCflagsC(configuration_name)
+            cflags_cc = xcode_settings.GetCflagsCC(configuration_name)
+        else:
+            cflags = configuration.get("cflags", [])
+            cflags_c = configuration.get("cflags_c", [])
+            cflags_cc = configuration.get("cflags_cc", [])
+
+        cflags_c = cflags + cflags_c
+        cflags_cc = cflags + cflags_cc
+
+        defines = configuration.get("defines", [])
+        defines = ["-D" + s for s in defines]
+
+        # TODO(bnoordhuis) Handle generated source files.
+        extensions = (".c", ".cc", ".cpp", ".cxx")
+        sources = [s for s in target.get("sources", []) if s.endswith(extensions)]
+
+        def resolve(filename):
+            return os.path.abspath(os.path.join(cwd, filename))
+
+        # TODO(bnoordhuis) Handle generated header files.
+        include_dirs = configuration.get("include_dirs", [])
+        include_dirs = [s for s in include_dirs if not s.startswith("$(obj)")]
+        includes = ["-I" + resolve(s) for s in include_dirs]
+
+        defines = gyp.common.EncodePOSIXShellList(defines)
+        includes = gyp.common.EncodePOSIXShellList(includes)
+        cflags_c = gyp.common.EncodePOSIXShellList(cflags_c)
+        cflags_cc = gyp.common.EncodePOSIXShellList(cflags_cc)
+
+        commands = per_config_commands.setdefault(configuration_name, [])
+        for source in sources:
+            file = resolve(source)
+            isc = source.endswith(".c")
+            cc = "cc" if isc else "c++"
+            cflags = cflags_c if isc else cflags_cc
+            command = " ".join(
+                (
+                    cc,
+                    defines,
+                    includes,
+                    cflags,
+                    "-c",
+                    gyp.common.EncodePOSIXShellArgument(file),
+                )
+            )
+            commands.append(dict(command=command, directory=output_dir, file=file))
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  per_config_commands = {}
-  for qualified_target, target in target_dicts.items():
-    build_file, target_name, toolset = (
-        gyp.common.ParseQualifiedTarget(qualified_target))
-    if IsMac(params):
-      settings = data[build_file]
-      gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(settings, target)
-    cwd = os.path.dirname(build_file)
-    AddCommandsForTarget(cwd, target, params, per_config_commands)
-
-  output_dir = params['generator_flags']['output_dir']
-  for configuration_name, commands in per_config_commands.items():
-    filename = os.path.join(output_dir,
-                            configuration_name,
-                            'compile_commands.json')
-    gyp.common.EnsureDirExists(filename)
-    fp = open(filename, 'w')
-    json.dump(commands, fp=fp, indent=0, check_circular=False)
+    per_config_commands = {}
+    for qualified_target, target in target_dicts.items():
+        build_file, target_name, toolset = gyp.common.ParseQualifiedTarget(
+            qualified_target
+        )
+        if IsMac(params):
+            settings = data[build_file]
+            gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(settings, target)
+        cwd = os.path.dirname(build_file)
+        AddCommandsForTarget(cwd, target, params, per_config_commands)
+
+    output_dir = params["generator_flags"].get("output_dir", "out")
+    for configuration_name, commands in per_config_commands.items():
+        filename = os.path.join(output_dir, configuration_name, "compile_commands.json")
+        gyp.common.EnsureDirExists(filename)
+        fp = open(filename, "w")
+        json.dump(commands, fp=fp, indent=0, check_circular=False)
 
 
 def PerformBuild(data, configurations, params):
-  pass
+    pass
diff --git a/tools/gyp/pylib/gyp/generator/dump_dependency_json.py b/tools/gyp/pylib/gyp/generator/dump_dependency_json.py
index 8e4f3168f3e7ef1c45a4845718a027454308249a..46f68e038418f36e459ebb6ffa38a210bc37a3e4 100644
--- a/tools/gyp/pylib/gyp/generator/dump_dependency_json.py
+++ b/tools/gyp/pylib/gyp/generator/dump_dependency_json.py
@@ -1,100 +1,104 @@
-from __future__ import print_function
 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import collections
+from __future__ import print_function
+
 import os
 import gyp
 import gyp.common
 import gyp.msvs_emulation
 import json
-import sys
 
 generator_supports_multiple_toolsets = True
 
 generator_wants_static_library_dependencies_adjusted = False
 
-generator_filelist_paths = {
-}
-
-generator_default_variables = {
-}
-for dirname in ['INTERMEDIATE_DIR', 'SHARED_INTERMEDIATE_DIR', 'PRODUCT_DIR',
-                'LIB_DIR', 'SHARED_LIB_DIR']:
-  # Some gyp steps fail if these are empty(!).
-  generator_default_variables[dirname] = 'dir'
-for unused in ['RULE_INPUT_PATH', 'RULE_INPUT_ROOT', 'RULE_INPUT_NAME',
-               'RULE_INPUT_DIRNAME', 'RULE_INPUT_EXT',
-               'EXECUTABLE_PREFIX', 'EXECUTABLE_SUFFIX',
-               'STATIC_LIB_PREFIX', 'STATIC_LIB_SUFFIX',
-               'SHARED_LIB_PREFIX', 'SHARED_LIB_SUFFIX',
-               'CONFIGURATION_NAME']:
-  generator_default_variables[unused] = ''
+generator_filelist_paths = {}
+
+generator_default_variables = {}
+for dirname in [
+    "INTERMEDIATE_DIR",
+    "SHARED_INTERMEDIATE_DIR",
+    "PRODUCT_DIR",
+    "LIB_DIR",
+    "SHARED_LIB_DIR",
+]:
+    # Some gyp steps fail if these are empty(!).
+    generator_default_variables[dirname] = "dir"
+for unused in [
+    "RULE_INPUT_PATH",
+    "RULE_INPUT_ROOT",
+    "RULE_INPUT_NAME",
+    "RULE_INPUT_DIRNAME",
+    "RULE_INPUT_EXT",
+    "EXECUTABLE_PREFIX",
+    "EXECUTABLE_SUFFIX",
+    "STATIC_LIB_PREFIX",
+    "STATIC_LIB_SUFFIX",
+    "SHARED_LIB_PREFIX",
+    "SHARED_LIB_SUFFIX",
+    "CONFIGURATION_NAME",
+]:
+    generator_default_variables[unused] = ""
 
 
 def CalculateVariables(default_variables, params):
-  generator_flags = params.get('generator_flags', {})
-  for key, val in generator_flags.items():
-    default_variables.setdefault(key, val)
-  default_variables.setdefault('OS', gyp.common.GetFlavor(params))
-
-  flavor = gyp.common.GetFlavor(params)
-  if flavor =='win':
-    # Copy additional generator configuration data from VS, which is shared
-    # by the Windows Ninja generator.
-    import gyp.generator.msvs as msvs_generator
-    generator_additional_non_configuration_keys = getattr(msvs_generator,
-        'generator_additional_non_configuration_keys', [])
-    generator_additional_path_sections = getattr(msvs_generator,
-        'generator_additional_path_sections', [])
+    generator_flags = params.get("generator_flags", {})
+    for key, val in generator_flags.items():
+        default_variables.setdefault(key, val)
+    default_variables.setdefault("OS", gyp.common.GetFlavor(params))
 
-    gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
+    flavor = gyp.common.GetFlavor(params)
+    if flavor == "win":
+        gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
 
 
 def CalculateGeneratorInputInfo(params):
-  """Calculate the generator specific info that gets fed to input (called by
+    """Calculate the generator specific info that gets fed to input (called by
   gyp)."""
-  generator_flags = params.get('generator_flags', {})
-  if generator_flags.get('adjust_static_libraries', False):
-    global generator_wants_static_library_dependencies_adjusted
-    generator_wants_static_library_dependencies_adjusted = True
-
-  toplevel = params['options'].toplevel_dir
-  generator_dir = os.path.relpath(params['options'].generator_output or '.')
-  # output_dir: relative path from generator_dir to the build directory.
-  output_dir = generator_flags.get('output_dir', 'out')
-  qualified_out_dir = os.path.normpath(os.path.join(
-      toplevel, generator_dir, output_dir, 'gypfiles'))
-  global generator_filelist_paths
-  generator_filelist_paths = {
-      'toplevel': toplevel,
-      'qualified_out_dir': qualified_out_dir,
-  }
+    generator_flags = params.get("generator_flags", {})
+    if generator_flags.get("adjust_static_libraries", False):
+        global generator_wants_static_library_dependencies_adjusted
+        generator_wants_static_library_dependencies_adjusted = True
+
+    toplevel = params["options"].toplevel_dir
+    generator_dir = os.path.relpath(params["options"].generator_output or ".")
+    # output_dir: relative path from generator_dir to the build directory.
+    output_dir = generator_flags.get("output_dir", "out")
+    qualified_out_dir = os.path.normpath(
+        os.path.join(toplevel, generator_dir, output_dir, "gypfiles")
+    )
+    global generator_filelist_paths
+    generator_filelist_paths = {
+        "toplevel": toplevel,
+        "qualified_out_dir": qualified_out_dir,
+    }
+
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  # Map of target -> list of targets it depends on.
-  edges = {}
-
-  # Queue of targets to visit.
-  targets_to_visit = target_list[:]
-
-  while len(targets_to_visit) > 0:
-    target = targets_to_visit.pop()
-    if target in edges:
-      continue
-    edges[target] = []
-
-    for dep in target_dicts[target].get('dependencies', []):
-      edges[target].append(dep)
-      targets_to_visit.append(dep)
-
-  try:
-    filepath = params['generator_flags']['output_dir']
-  except KeyError:
-    filepath = '.'
-  filename = os.path.join(filepath, 'dump.json')
-  f = open(filename, 'w')
-  json.dump(edges, f)
-  f.close()
-  print('Wrote json to %s.' % filename)
+    # Map of target -> list of targets it depends on.
+    edges = {}
+
+    # Queue of targets to visit.
+    targets_to_visit = target_list[:]
+
+    while len(targets_to_visit) > 0:
+        target = targets_to_visit.pop()
+        if target in edges:
+            continue
+        edges[target] = []
+
+        for dep in target_dicts[target].get("dependencies", []):
+            edges[target].append(dep)
+            targets_to_visit.append(dep)
+
+    try:
+        filepath = params["generator_flags"]["output_dir"]
+    except KeyError:
+        filepath = "."
+    filename = os.path.join(filepath, "dump.json")
+    f = open(filename, "w")
+    json.dump(edges, f)
+    f.close()
+    print("Wrote json to %s." % filename)
diff --git a/tools/gyp/pylib/gyp/generator/eclipse.py b/tools/gyp/pylib/gyp/generator/eclipse.py
index 80e5fb6302c5d5d5e3f5c8ad751984083ebfa158..4bd49725dc1e8935ac17e59127f3a10bb38fec13 100644
--- a/tools/gyp/pylib/gyp/generator/eclipse.py
+++ b/tools/gyp/pylib/gyp/generator/eclipse.py
@@ -30,402 +30,441 @@ PY3 = bytes != str
 
 generator_wants_static_library_dependencies_adjusted = False
 
-generator_default_variables = {
-}
-
-for dirname in ['INTERMEDIATE_DIR', 'PRODUCT_DIR', 'LIB_DIR', 'SHARED_LIB_DIR']:
-  # Some gyp steps fail if these are empty(!), so we convert them to variables
-  generator_default_variables[dirname] = '$' + dirname
-
-for unused in ['RULE_INPUT_PATH', 'RULE_INPUT_ROOT', 'RULE_INPUT_NAME',
-               'RULE_INPUT_DIRNAME', 'RULE_INPUT_EXT',
-               'EXECUTABLE_PREFIX', 'EXECUTABLE_SUFFIX',
-               'STATIC_LIB_PREFIX', 'STATIC_LIB_SUFFIX',
-               'SHARED_LIB_PREFIX', 'SHARED_LIB_SUFFIX',
-               'CONFIGURATION_NAME']:
-  generator_default_variables[unused] = ''
+generator_default_variables = {}
+
+for dirname in ["INTERMEDIATE_DIR", "PRODUCT_DIR", "LIB_DIR", "SHARED_LIB_DIR"]:
+    # Some gyp steps fail if these are empty(!), so we convert them to variables
+    generator_default_variables[dirname] = "$" + dirname
+
+for unused in [
+    "RULE_INPUT_PATH",
+    "RULE_INPUT_ROOT",
+    "RULE_INPUT_NAME",
+    "RULE_INPUT_DIRNAME",
+    "RULE_INPUT_EXT",
+    "EXECUTABLE_PREFIX",
+    "EXECUTABLE_SUFFIX",
+    "STATIC_LIB_PREFIX",
+    "STATIC_LIB_SUFFIX",
+    "SHARED_LIB_PREFIX",
+    "SHARED_LIB_SUFFIX",
+    "CONFIGURATION_NAME",
+]:
+    generator_default_variables[unused] = ""
 
 # Include dirs will occasionally use the SHARED_INTERMEDIATE_DIR variable as
 # part of the path when dealing with generated headers.  This value will be
 # replaced dynamically for each configuration.
-generator_default_variables['SHARED_INTERMEDIATE_DIR'] = \
-    '$SHARED_INTERMEDIATE_DIR'
+generator_default_variables["SHARED_INTERMEDIATE_DIR"] = "$SHARED_INTERMEDIATE_DIR"
 
 
 def CalculateVariables(default_variables, params):
-  generator_flags = params.get('generator_flags', {})
-  for key, val in generator_flags.items():
-    default_variables.setdefault(key, val)
-  flavor = gyp.common.GetFlavor(params)
-  default_variables.setdefault('OS', flavor)
-  if flavor == 'win':
-    # Copy additional generator configuration data from VS, which is shared
-    # by the Eclipse generator.
-    import gyp.generator.msvs as msvs_generator
-    generator_additional_non_configuration_keys = getattr(msvs_generator,
-        'generator_additional_non_configuration_keys', [])
-    generator_additional_path_sections = getattr(msvs_generator,
-        'generator_additional_path_sections', [])
-
-    gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
+    generator_flags = params.get("generator_flags", {})
+    for key, val in generator_flags.items():
+        default_variables.setdefault(key, val)
+    flavor = gyp.common.GetFlavor(params)
+    default_variables.setdefault("OS", flavor)
+    if flavor == "win":
+        gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
 
 
 def CalculateGeneratorInputInfo(params):
-  """Calculate the generator specific info that gets fed to input (called by
+    """Calculate the generator specific info that gets fed to input (called by
   gyp)."""
-  generator_flags = params.get('generator_flags', {})
-  if generator_flags.get('adjust_static_libraries', False):
-    global generator_wants_static_library_dependencies_adjusted
-    generator_wants_static_library_dependencies_adjusted = True
-
-
-def GetAllIncludeDirectories(target_list, target_dicts,
-                             shared_intermediate_dirs, config_name, params,
-                             compiler_path):
-  """Calculate the set of include directories to be used.
+    generator_flags = params.get("generator_flags", {})
+    if generator_flags.get("adjust_static_libraries", False):
+        global generator_wants_static_library_dependencies_adjusted
+        generator_wants_static_library_dependencies_adjusted = True
+
+
+def GetAllIncludeDirectories(
+    target_list,
+    target_dicts,
+    shared_intermediate_dirs,
+    config_name,
+    params,
+    compiler_path,
+):
+    """Calculate the set of include directories to be used.
 
   Returns:
     A list including all the include_dir's specified for every target followed
     by any include directories that were added as cflag compiler options.
   """
 
-  gyp_includes_set = set()
-  compiler_includes_list = []
-
-  # Find compiler's default include dirs.
-  if compiler_path:
-    command = shlex.split(compiler_path)
-    command.extend(['-E', '-xc++', '-v', '-'])
-    proc = subprocess.Popen(args=command, stdin=subprocess.PIPE,
-                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    output = proc.communicate()[1]
-    if PY3:
-      output = output.decode('utf-8')
-    # Extract the list of include dirs from the output, which has this format:
-    #   ...
-    #   #include "..." search starts here:
-    #   #include <...> search starts here:
-    #    /usr/include/c++/4.6
-    #    /usr/local/include
-    #   End of search list.
-    #   ...
-    in_include_list = False
-    for line in output.splitlines():
-      if line.startswith('#include'):
-        in_include_list = True
-        continue
-      if line.startswith('End of search list.'):
-        break
-      if in_include_list:
-        include_dir = line.strip()
-        if include_dir not in compiler_includes_list:
-          compiler_includes_list.append(include_dir)
-
-  flavor = gyp.common.GetFlavor(params)
-  if flavor == 'win':
-    generator_flags = params.get('generator_flags', {})
-  for target_name in target_list:
-    target = target_dicts[target_name]
-    if config_name in target['configurations']:
-      config = target['configurations'][config_name]
-
-      # Look for any include dirs that were explicitly added via cflags. This
-      # may be done in gyp files to force certain includes to come at the end.
-      # TODO(jgreenwald): Change the gyp files to not abuse cflags for this, and
-      # remove this.
-      if flavor == 'win':
-        msvs_settings = gyp.msvs_emulation.MsvsSettings(target, generator_flags)
-        cflags = msvs_settings.GetCflags(config_name)
-      else:
-        cflags = config['cflags']
-      for cflag in cflags:
-        if cflag.startswith('-I'):
-          include_dir = cflag[2:]
-          if include_dir not in compiler_includes_list:
-            compiler_includes_list.append(include_dir)
-
-      # Find standard gyp include dirs.
-      if 'include_dirs' in config:
-        include_dirs = config['include_dirs']
-        for shared_intermediate_dir in shared_intermediate_dirs:
-          for include_dir in include_dirs:
-            include_dir = include_dir.replace('$SHARED_INTERMEDIATE_DIR',
-                                              shared_intermediate_dir)
-            if not os.path.isabs(include_dir):
-              base_dir = os.path.dirname(target_name)
-
-              include_dir = base_dir + '/' + include_dir
-              include_dir = os.path.abspath(include_dir)
-
-            gyp_includes_set.add(include_dir)
-
-  # Generate a list that has all the include dirs.
-  all_includes_list = list(gyp_includes_set)
-  all_includes_list.sort()
-  for compiler_include in compiler_includes_list:
-    if not compiler_include in gyp_includes_set:
-      all_includes_list.append(compiler_include)
-
-  # All done.
-  return all_includes_list
+    gyp_includes_set = set()
+    compiler_includes_list = []
+
+    # Find compiler's default include dirs.
+    if compiler_path:
+        command = shlex.split(compiler_path)
+        command.extend(["-E", "-xc++", "-v", "-"])
+        proc = subprocess.Popen(
+            args=command,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        output = proc.communicate()[1]
+        if PY3:
+            output = output.decode("utf-8")
+        # Extract the list of include dirs from the output, which has this format:
+        #   ...
+        #   #include "..." search starts here:
+        #   #include <...> search starts here:
+        #    /usr/include/c++/4.6
+        #    /usr/local/include
+        #   End of search list.
+        #   ...
+        in_include_list = False
+        for line in output.splitlines():
+            if line.startswith("#include"):
+                in_include_list = True
+                continue
+            if line.startswith("End of search list."):
+                break
+            if in_include_list:
+                include_dir = line.strip()
+                if include_dir not in compiler_includes_list:
+                    compiler_includes_list.append(include_dir)
+
+    flavor = gyp.common.GetFlavor(params)
+    if flavor == "win":
+        generator_flags = params.get("generator_flags", {})
+    for target_name in target_list:
+        target = target_dicts[target_name]
+        if config_name in target["configurations"]:
+            config = target["configurations"][config_name]
+
+            # Look for any include dirs that were explicitly added via cflags. This
+            # may be done in gyp files to force certain includes to come at the end.
+            # TODO(jgreenwald): Change the gyp files to not abuse cflags for this, and
+            # remove this.
+            if flavor == "win":
+                msvs_settings = gyp.msvs_emulation.MsvsSettings(target, generator_flags)
+                cflags = msvs_settings.GetCflags(config_name)
+            else:
+                cflags = config["cflags"]
+            for cflag in cflags:
+                if cflag.startswith("-I"):
+                    include_dir = cflag[2:]
+                    if include_dir not in compiler_includes_list:
+                        compiler_includes_list.append(include_dir)
+
+            # Find standard gyp include dirs.
+            if "include_dirs" in config:
+                include_dirs = config["include_dirs"]
+                for shared_intermediate_dir in shared_intermediate_dirs:
+                    for include_dir in include_dirs:
+                        include_dir = include_dir.replace(
+                            "$SHARED_INTERMEDIATE_DIR", shared_intermediate_dir
+                        )
+                        if not os.path.isabs(include_dir):
+                            base_dir = os.path.dirname(target_name)
+
+                            include_dir = base_dir + "/" + include_dir
+                            include_dir = os.path.abspath(include_dir)
+
+                        gyp_includes_set.add(include_dir)
+
+    # Generate a list that has all the include dirs.
+    all_includes_list = list(gyp_includes_set)
+    all_includes_list.sort()
+    for compiler_include in compiler_includes_list:
+        if compiler_include not in gyp_includes_set:
+            all_includes_list.append(compiler_include)
+
+    # All done.
+    return all_includes_list
 
 
 def GetCompilerPath(target_list, data, options):
-  """Determine a command that can be used to invoke the compiler.
+    """Determine a command that can be used to invoke the compiler.
 
   Returns:
     If this is a gyp project that has explicit make settings, try to determine
     the compiler from that.  Otherwise, see if a compiler was specified via the
     CC_target environment variable.
   """
-  # First, see if the compiler is configured in make's settings.
-  build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
-  make_global_settings_dict = data[build_file].get('make_global_settings', {})
-  for key, value in make_global_settings_dict:
-    if key in ['CC', 'CXX']:
-      return os.path.join(options.toplevel_dir, value)
+    # First, see if the compiler is configured in make's settings.
+    build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
+    make_global_settings_dict = data[build_file].get("make_global_settings", {})
+    for key, value in make_global_settings_dict:
+        if key in ["CC", "CXX"]:
+            return os.path.join(options.toplevel_dir, value)
 
-  # Check to see if the compiler was specified as an environment variable.
-  for key in ['CC_target', 'CC', 'CXX']:
-    compiler = os.environ.get(key)
-    if compiler:
-      return compiler
+    # Check to see if the compiler was specified as an environment variable.
+    for key in ["CC_target", "CC", "CXX"]:
+        compiler = os.environ.get(key)
+        if compiler:
+            return compiler
 
-  return 'gcc'
+    return "gcc"
 
 
-def GetAllDefines(target_list, target_dicts, data, config_name, params,
-                  compiler_path):
-  """Calculate the defines for a project.
+def GetAllDefines(target_list, target_dicts, data, config_name, params, compiler_path):
+    """Calculate the defines for a project.
 
   Returns:
     A dict that includes explicit defines declared in gyp files along with all
     of the default defines that the compiler uses.
   """
 
-  # Get defines declared in the gyp files.
-  all_defines = {}
-  flavor = gyp.common.GetFlavor(params)
-  if flavor == 'win':
-    generator_flags = params.get('generator_flags', {})
-  for target_name in target_list:
-    target = target_dicts[target_name]
-
-    if flavor == 'win':
-      msvs_settings = gyp.msvs_emulation.MsvsSettings(target, generator_flags)
-      extra_defines = msvs_settings.GetComputedDefines(config_name)
-    else:
-      extra_defines = []
-    if config_name in target['configurations']:
-      config = target['configurations'][config_name]
-      target_defines = config['defines']
-    else:
-      target_defines = []
-    for define in target_defines + extra_defines:
-      split_define = define.split('=', 1)
-      if len(split_define) == 1:
-        split_define.append('1')
-      if split_define[0].strip() in all_defines:
-        # Already defined
-        continue
-      all_defines[split_define[0].strip()] = split_define[1].strip()
-  # Get default compiler defines (if possible).
-  if flavor == 'win':
-    return all_defines  # Default defines already processed in the loop above.
-  if compiler_path:
-    command = shlex.split(compiler_path)
-    command.extend(['-E', '-dM', '-'])
-    cpp_proc = subprocess.Popen(args=command, cwd='.',
-                                stdin=subprocess.PIPE, stdout=subprocess.PIPE)
-    cpp_output = cpp_proc.communicate()[0]
-    if PY3:
-      cpp_output = cpp_output.decode('utf-8')
-    cpp_lines = cpp_output.split('\n')
-    for cpp_line in cpp_lines:
-      if not cpp_line.strip():
-        continue
-      cpp_line_parts = cpp_line.split(' ', 2)
-      key = cpp_line_parts[1]
-      if len(cpp_line_parts) >= 3:
-        val = cpp_line_parts[2]
-      else:
-        val = '1'
-      all_defines[key] = val
-
-  return all_defines
+    # Get defines declared in the gyp files.
+    all_defines = {}
+    flavor = gyp.common.GetFlavor(params)
+    if flavor == "win":
+        generator_flags = params.get("generator_flags", {})
+    for target_name in target_list:
+        target = target_dicts[target_name]
+
+        if flavor == "win":
+            msvs_settings = gyp.msvs_emulation.MsvsSettings(target, generator_flags)
+            extra_defines = msvs_settings.GetComputedDefines(config_name)
+        else:
+            extra_defines = []
+        if config_name in target["configurations"]:
+            config = target["configurations"][config_name]
+            target_defines = config["defines"]
+        else:
+            target_defines = []
+        for define in target_defines + extra_defines:
+            split_define = define.split("=", 1)
+            if len(split_define) == 1:
+                split_define.append("1")
+            if split_define[0].strip() in all_defines:
+                # Already defined
+                continue
+            all_defines[split_define[0].strip()] = split_define[1].strip()
+    # Get default compiler defines (if possible).
+    if flavor == "win":
+        return all_defines  # Default defines already processed in the loop above.
+    if compiler_path:
+        command = shlex.split(compiler_path)
+        command.extend(["-E", "-dM", "-"])
+        cpp_proc = subprocess.Popen(
+            args=command, cwd=".", stdin=subprocess.PIPE, stdout=subprocess.PIPE
+        )
+        cpp_output = cpp_proc.communicate()[0]
+        if PY3:
+            cpp_output = cpp_output.decode("utf-8")
+        cpp_lines = cpp_output.split("\n")
+        for cpp_line in cpp_lines:
+            if not cpp_line.strip():
+                continue
+            cpp_line_parts = cpp_line.split(" ", 2)
+            key = cpp_line_parts[1]
+            if len(cpp_line_parts) >= 3:
+                val = cpp_line_parts[2]
+            else:
+                val = "1"
+            all_defines[key] = val
+
+    return all_defines
 
 
 def WriteIncludePaths(out, eclipse_langs, include_dirs):
-  """Write the includes section of a CDT settings export file."""
-
-  out.write('  <section name="org.eclipse.cdt.internal.ui.wizards.' \
-            'settingswizards.IncludePaths">\n')
-  out.write('    <language name="holder for library settings"></language>\n')
-  for lang in eclipse_langs:
-    out.write('    <language name="%s">\n' % lang)
-    for include_dir in include_dirs:
-      out.write('      <includepath workspace_path="false">%s</includepath>\n' %
-                include_dir)
-    out.write('    </language>\n')
-  out.write('  </section>\n')
+    """Write the includes section of a CDT settings export file."""
+
+    out.write(
+        '  <section name="org.eclipse.cdt.internal.ui.wizards.'
+        'settingswizards.IncludePaths">\n'
+    )
+    out.write('    <language name="holder for library settings"></language>\n')
+    for lang in eclipse_langs:
+        out.write('    <language name="%s">\n' % lang)
+        for include_dir in include_dirs:
+            out.write(
+                '      <includepath workspace_path="false">%s</includepath>\n'
+                % include_dir
+            )
+        out.write("    </language>\n")
+    out.write("  </section>\n")
 
 
 def WriteMacros(out, eclipse_langs, defines):
-  """Write the macros section of a CDT settings export file."""
-
-  out.write('  <section name="org.eclipse.cdt.internal.ui.wizards.' \
-            'settingswizards.Macros">\n')
-  out.write('    <language name="holder for library settings"></language>\n')
-  for lang in eclipse_langs:
-    out.write('    <language name="%s">\n' % lang)
-    for key in sorted(defines):
-      out.write('      <macro><name>%s</name><value>%s</value></macro>\n' %
-                (escape(key), escape(defines[key])))
-    out.write('    </language>\n')
-  out.write('  </section>\n')
-
-
-def GenerateOutputForConfig(target_list, target_dicts, data, params,
-                            config_name):
-  options = params['options']
-  generator_flags = params.get('generator_flags', {})
-
-  # build_dir: relative path from source root to our output files.
-  # e.g. "out/Debug"
-  build_dir = os.path.join(generator_flags.get('output_dir', 'out'),
-                           config_name)
-
-  toplevel_build = os.path.join(options.toplevel_dir, build_dir)
-  # Ninja uses out/Debug/gen while make uses out/Debug/obj/gen as the
-  # SHARED_INTERMEDIATE_DIR. Include both possible locations.
-  shared_intermediate_dirs = [os.path.join(toplevel_build, 'obj', 'gen'),
-                              os.path.join(toplevel_build, 'gen')]
-
-  GenerateCdtSettingsFile(target_list,
-                          target_dicts,
-                          data,
-                          params,
-                          config_name,
-                          os.path.join(toplevel_build,
-                                       'eclipse-cdt-settings.xml'),
-                          options,
-                          shared_intermediate_dirs)
-  GenerateClasspathFile(target_list,
-                        target_dicts,
-                        options.toplevel_dir,
-                        toplevel_build,
-                        os.path.join(toplevel_build,
-                                     'eclipse-classpath.xml'))
-
-
-def GenerateCdtSettingsFile(target_list, target_dicts, data, params,
-                            config_name, out_name, options,
-                            shared_intermediate_dirs):
-  gyp.common.EnsureDirExists(out_name)
-  with open(out_name, 'w') as out:
-    out.write('<?xml version="1.0" encoding="UTF-8"?>\n')
-    out.write('<cdtprojectproperties>\n')
-
-    eclipse_langs = ['C++ Source File', 'C Source File', 'Assembly Source File',
-                     'GNU C++', 'GNU C', 'Assembly']
-    compiler_path = GetCompilerPath(target_list, data, options)
-    include_dirs = GetAllIncludeDirectories(target_list, target_dicts,
-                                            shared_intermediate_dirs,
-                                            config_name, params, compiler_path)
-    WriteIncludePaths(out, eclipse_langs, include_dirs)
-    defines = GetAllDefines(target_list, target_dicts, data, config_name,
-                            params, compiler_path)
-    WriteMacros(out, eclipse_langs, defines)
-
-    out.write('</cdtprojectproperties>\n')
-
-
-def GenerateClasspathFile(target_list, target_dicts, toplevel_dir,
-                          toplevel_build, out_name):
-  '''Generates a classpath file suitable for symbol navigation and code
+    """Write the macros section of a CDT settings export file."""
+
+    out.write(
+        '  <section name="org.eclipse.cdt.internal.ui.wizards.'
+        'settingswizards.Macros">\n'
+    )
+    out.write('    <language name="holder for library settings"></language>\n')
+    for lang in eclipse_langs:
+        out.write('    <language name="%s">\n' % lang)
+        for key in sorted(defines):
+            out.write(
+                "      <macro><name>%s</name><value>%s</value></macro>\n"
+                % (escape(key), escape(defines[key]))
+            )
+        out.write("    </language>\n")
+    out.write("  </section>\n")
+
+
+def GenerateOutputForConfig(target_list, target_dicts, data, params, config_name):
+    options = params["options"]
+    generator_flags = params.get("generator_flags", {})
+
+    # build_dir: relative path from source root to our output files.
+    # e.g. "out/Debug"
+    build_dir = os.path.join(generator_flags.get("output_dir", "out"), config_name)
+
+    toplevel_build = os.path.join(options.toplevel_dir, build_dir)
+    # Ninja uses out/Debug/gen while make uses out/Debug/obj/gen as the
+    # SHARED_INTERMEDIATE_DIR. Include both possible locations.
+    shared_intermediate_dirs = [
+        os.path.join(toplevel_build, "obj", "gen"),
+        os.path.join(toplevel_build, "gen"),
+    ]
+
+    GenerateCdtSettingsFile(
+        target_list,
+        target_dicts,
+        data,
+        params,
+        config_name,
+        os.path.join(toplevel_build, "eclipse-cdt-settings.xml"),
+        options,
+        shared_intermediate_dirs,
+    )
+    GenerateClasspathFile(
+        target_list,
+        target_dicts,
+        options.toplevel_dir,
+        toplevel_build,
+        os.path.join(toplevel_build, "eclipse-classpath.xml"),
+    )
+
+
+def GenerateCdtSettingsFile(
+    target_list,
+    target_dicts,
+    data,
+    params,
+    config_name,
+    out_name,
+    options,
+    shared_intermediate_dirs,
+):
+    gyp.common.EnsureDirExists(out_name)
+    with open(out_name, "w") as out:
+        out.write('<?xml version="1.0" encoding="UTF-8"?>\n')
+        out.write("<cdtprojectproperties>\n")
+
+        eclipse_langs = [
+            "C++ Source File",
+            "C Source File",
+            "Assembly Source File",
+            "GNU C++",
+            "GNU C",
+            "Assembly",
+        ]
+        compiler_path = GetCompilerPath(target_list, data, options)
+        include_dirs = GetAllIncludeDirectories(
+            target_list,
+            target_dicts,
+            shared_intermediate_dirs,
+            config_name,
+            params,
+            compiler_path,
+        )
+        WriteIncludePaths(out, eclipse_langs, include_dirs)
+        defines = GetAllDefines(
+            target_list, target_dicts, data, config_name, params, compiler_path
+        )
+        WriteMacros(out, eclipse_langs, defines)
+
+        out.write("</cdtprojectproperties>\n")
+
+
+def GenerateClasspathFile(
+    target_list, target_dicts, toplevel_dir, toplevel_build, out_name
+):
+    """Generates a classpath file suitable for symbol navigation and code
   completion of Java code (such as in Android projects) by finding all
-  .java and .jar files used as action inputs.'''
-  gyp.common.EnsureDirExists(out_name)
-  result = ET.Element('classpath')
-
-  def AddElements(kind, paths):
-    # First, we need to normalize the paths so they are all relative to the
-    # toplevel dir.
-    rel_paths = set()
-    for path in paths:
-      if os.path.isabs(path):
-        rel_paths.add(os.path.relpath(path, toplevel_dir))
-      else:
-        rel_paths.add(path)
-
-    for path in sorted(rel_paths):
-      entry_element = ET.SubElement(result, 'classpathentry')
-      entry_element.set('kind', kind)
-      entry_element.set('path', path)
-
-  AddElements('lib', GetJavaJars(target_list, target_dicts, toplevel_dir))
-  AddElements('src', GetJavaSourceDirs(target_list, target_dicts, toplevel_dir))
-  # Include the standard JRE container and a dummy out folder
-  AddElements('con', ['org.eclipse.jdt.launching.JRE_CONTAINER'])
-  # Include a dummy out folder so that Eclipse doesn't use the default /bin
-  # folder in the root of the project.
-  AddElements('output', [os.path.join(toplevel_build, '.eclipse-java-build')])
-
-  ET.ElementTree(result).write(out_name)
+  .java and .jar files used as action inputs."""
+    gyp.common.EnsureDirExists(out_name)
+    result = ET.Element("classpath")
+
+    def AddElements(kind, paths):
+        # First, we need to normalize the paths so they are all relative to the
+        # toplevel dir.
+        rel_paths = set()
+        for path in paths:
+            if os.path.isabs(path):
+                rel_paths.add(os.path.relpath(path, toplevel_dir))
+            else:
+                rel_paths.add(path)
+
+        for path in sorted(rel_paths):
+            entry_element = ET.SubElement(result, "classpathentry")
+            entry_element.set("kind", kind)
+            entry_element.set("path", path)
+
+    AddElements("lib", GetJavaJars(target_list, target_dicts, toplevel_dir))
+    AddElements("src", GetJavaSourceDirs(target_list, target_dicts, toplevel_dir))
+    # Include the standard JRE container and a dummy out folder
+    AddElements("con", ["org.eclipse.jdt.launching.JRE_CONTAINER"])
+    # Include a dummy out folder so that Eclipse doesn't use the default /bin
+    # folder in the root of the project.
+    AddElements("output", [os.path.join(toplevel_build, ".eclipse-java-build")])
+
+    ET.ElementTree(result).write(out_name)
 
 
 def GetJavaJars(target_list, target_dicts, toplevel_dir):
-  '''Generates a sequence of all .jars used as inputs.'''
-  for target_name in target_list:
-    target = target_dicts[target_name]
-    for action in target.get('actions', []):
-      for input_ in action['inputs']:
-        if os.path.splitext(input_)[1] == '.jar' and not input_.startswith('$'):
-          if os.path.isabs(input_):
-            yield input_
-          else:
-            yield os.path.join(os.path.dirname(target_name), input_)
+    """Generates a sequence of all .jars used as inputs."""
+    for target_name in target_list:
+        target = target_dicts[target_name]
+        for action in target.get("actions", []):
+            for input_ in action["inputs"]:
+                if os.path.splitext(input_)[1] == ".jar" and not input_.startswith("$"):
+                    if os.path.isabs(input_):
+                        yield input_
+                    else:
+                        yield os.path.join(os.path.dirname(target_name), input_)
 
 
 def GetJavaSourceDirs(target_list, target_dicts, toplevel_dir):
-  '''Generates a sequence of all likely java package root directories.'''
-  for target_name in target_list:
-    target = target_dicts[target_name]
-    for action in target.get('actions', []):
-      for input_ in action['inputs']:
-        if (os.path.splitext(input_)[1] == '.java' and
-            not input_.startswith('$')):
-          dir_ = os.path.dirname(os.path.join(os.path.dirname(target_name),
-                                              input_))
-          # If there is a parent 'src' or 'java' folder, navigate up to it -
-          # these are canonical package root names in Chromium.  This will
-          # break if 'src' or 'java' exists in the package structure. This
-          # could be further improved by inspecting the java file for the
-          # package name if this proves to be too fragile in practice.
-          parent_search = dir_
-          while os.path.basename(parent_search) not in ['src', 'java']:
-            parent_search, _ = os.path.split(parent_search)
-            if not parent_search or parent_search == toplevel_dir:
-              # Didn't find a known root, just return the original path
-              yield dir_
-              break
-          else:
-            yield parent_search
+    """Generates a sequence of all likely java package root directories."""
+    for target_name in target_list:
+        target = target_dicts[target_name]
+        for action in target.get("actions", []):
+            for input_ in action["inputs"]:
+                if os.path.splitext(input_)[1] == ".java" and not input_.startswith(
+                    "$"
+                ):
+                    dir_ = os.path.dirname(
+                        os.path.join(os.path.dirname(target_name), input_)
+                    )
+                    # If there is a parent 'src' or 'java' folder, navigate up to it -
+                    # these are canonical package root names in Chromium.  This will
+                    # break if 'src' or 'java' exists in the package structure. This
+                    # could be further improved by inspecting the java file for the
+                    # package name if this proves to be too fragile in practice.
+                    parent_search = dir_
+                    while os.path.basename(parent_search) not in ["src", "java"]:
+                        parent_search, _ = os.path.split(parent_search)
+                        if not parent_search or parent_search == toplevel_dir:
+                            # Didn't find a known root, just return the original path
+                            yield dir_
+                            break
+                    else:
+                        yield parent_search
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  """Generate an XML settings file that can be imported into a CDT project."""
+    """Generate an XML settings file that can be imported into a CDT project."""
 
-  if params['options'].generator_output:
-    raise NotImplementedError("--generator_output not implemented for eclipse")
-
-  user_config = params.get('generator_flags', {}).get('config', None)
-  if user_config:
-    GenerateOutputForConfig(target_list, target_dicts, data, params,
-                            user_config)
-  else:
-    config_names = target_dicts[target_list[0]]['configurations'].keys()
-    for config_name in config_names:
-      GenerateOutputForConfig(target_list, target_dicts, data, params,
-                              config_name)
+    if params["options"].generator_output:
+        raise NotImplementedError("--generator_output not implemented for eclipse")
 
+    user_config = params.get("generator_flags", {}).get("config", None)
+    if user_config:
+        GenerateOutputForConfig(target_list, target_dicts, data, params, user_config)
+    else:
+        config_names = target_dicts[target_list[0]]["configurations"]
+        for config_name in config_names:
+            GenerateOutputForConfig(
+                target_list, target_dicts, data, params, config_name
+            )
diff --git a/tools/gyp/pylib/gyp/generator/gypd.py b/tools/gyp/pylib/gyp/generator/gypd.py
index 78eeaa61b2294a223f1ec5016b3fdef9e0560148..4171704c47a4b6424530b13be7314f88e79a25df 100644
--- a/tools/gyp/pylib/gyp/generator/gypd.py
+++ b/tools/gyp/pylib/gyp/generator/gypd.py
@@ -32,36 +32,33 @@ to change.
 
 
 import gyp.common
-import errno
-import os
 import pprint
 
 
 # These variables should just be spit back out as variable references.
 _generator_identity_variables = [
-  'CONFIGURATION_NAME',
-  'EXECUTABLE_PREFIX',
-  'EXECUTABLE_SUFFIX',
-  'INTERMEDIATE_DIR',
-  'LIB_DIR',
-  'PRODUCT_DIR',
-  'RULE_INPUT_ROOT',
-  'RULE_INPUT_DIRNAME',
-  'RULE_INPUT_EXT',
-  'RULE_INPUT_NAME',
-  'RULE_INPUT_PATH',
-  'SHARED_INTERMEDIATE_DIR',
-  'SHARED_LIB_DIR',
-  'SHARED_LIB_PREFIX',
-  'SHARED_LIB_SUFFIX',
-  'STATIC_LIB_PREFIX',
-  'STATIC_LIB_SUFFIX',
+    "CONFIGURATION_NAME",
+    "EXECUTABLE_PREFIX",
+    "EXECUTABLE_SUFFIX",
+    "INTERMEDIATE_DIR",
+    "LIB_DIR",
+    "PRODUCT_DIR",
+    "RULE_INPUT_ROOT",
+    "RULE_INPUT_DIRNAME",
+    "RULE_INPUT_EXT",
+    "RULE_INPUT_NAME",
+    "RULE_INPUT_PATH",
+    "SHARED_INTERMEDIATE_DIR",
+    "SHARED_LIB_DIR",
+    "SHARED_LIB_PREFIX",
+    "SHARED_LIB_SUFFIX",
+    "STATIC_LIB_PREFIX",
+    "STATIC_LIB_SUFFIX",
 ]
 
 # gypd doesn't define a default value for OS like many other generator
 # modules.  Specify "-D OS=whatever" on the command line to provide a value.
-generator_default_variables = {
-}
+generator_default_variables = {}
 
 # gypd supports multiple toolsets
 generator_supports_multiple_toolsets = True
@@ -71,24 +68,22 @@ generator_supports_multiple_toolsets = True
 # module should use < for the early phase and then switch to > for the late
 # phase.  Bonus points for carrying @ back into the output too.
 for v in _generator_identity_variables:
-  generator_default_variables[v] = '<(%s)' % v
+    generator_default_variables[v] = "<(%s)" % v
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  output_files = {}
-  for qualified_target in target_list:
-    [input_file, target] = \
-        gyp.common.ParseQualifiedTarget(qualified_target)[0:2]
-
-    if input_file[-4:] != '.gyp':
-      continue
-    input_file_stem = input_file[:-4]
-    output_file = input_file_stem + params['options'].suffix + '.gypd'
-
-    if not output_file in output_files:
-      output_files[output_file] = input_file
-
-  for output_file, input_file in output_files.items():
-    output = open(output_file, 'w')
-    pprint.pprint(data[input_file], output)
-    output.close()
+    output_files = {}
+    for qualified_target in target_list:
+        [input_file, target] = gyp.common.ParseQualifiedTarget(qualified_target)[0:2]
+
+        if input_file[-4:] != ".gyp":
+            continue
+        input_file_stem = input_file[:-4]
+        output_file = input_file_stem + params["options"].suffix + ".gypd"
+
+        output_files[output_file] = output_files.get(output_file, input_file)
+
+    for output_file, input_file in output_files.items():
+        output = open(output_file, "w")
+        pprint.pprint(data[input_file], output)
+        output.close()
diff --git a/tools/gyp/pylib/gyp/generator/gypsh.py b/tools/gyp/pylib/gyp/generator/gypsh.py
index bd405f43a993d452ef50528382fb69a1a92b2fd7..2d8aba5d1c19e9f981b3f6aeac3ce0b2bd53cb67 100644
--- a/tools/gyp/pylib/gyp/generator/gypsh.py
+++ b/tools/gyp/pylib/gyp/generator/gypsh.py
@@ -21,36 +21,38 @@ import sys
 # All of this stuff about generator variables was lovingly ripped from gypd.py.
 # That module has a much better description of what's going on and why.
 _generator_identity_variables = [
-  'EXECUTABLE_PREFIX',
-  'EXECUTABLE_SUFFIX',
-  'INTERMEDIATE_DIR',
-  'PRODUCT_DIR',
-  'RULE_INPUT_ROOT',
-  'RULE_INPUT_DIRNAME',
-  'RULE_INPUT_EXT',
-  'RULE_INPUT_NAME',
-  'RULE_INPUT_PATH',
-  'SHARED_INTERMEDIATE_DIR',
+    "EXECUTABLE_PREFIX",
+    "EXECUTABLE_SUFFIX",
+    "INTERMEDIATE_DIR",
+    "PRODUCT_DIR",
+    "RULE_INPUT_ROOT",
+    "RULE_INPUT_DIRNAME",
+    "RULE_INPUT_EXT",
+    "RULE_INPUT_NAME",
+    "RULE_INPUT_PATH",
+    "SHARED_INTERMEDIATE_DIR",
 ]
 
-generator_default_variables = {
-}
+generator_default_variables = {}
 
 for v in _generator_identity_variables:
-  generator_default_variables[v] = '<(%s)' % v
+    generator_default_variables[v] = "<(%s)" % v
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  locals = {
-        'target_list':  target_list,
-        'target_dicts': target_dicts,
-        'data':         data,
-      }
-
-  # Use a banner that looks like the stock Python one and like what
-  # code.interact uses by default, but tack on something to indicate what
-  # locals are available, and identify gypsh.
-  banner='Python %s on %s\nlocals.keys() = %s\ngypsh' % \
-         (sys.version, sys.platform, repr(sorted(locals.keys())))
-
-  code.interact(banner, local=locals)
+    locals = {
+        "target_list": target_list,
+        "target_dicts": target_dicts,
+        "data": data,
+    }
+
+    # Use a banner that looks like the stock Python one and like what
+    # code.interact uses by default, but tack on something to indicate what
+    # locals are available, and identify gypsh.
+    banner = "Python %s on %s\nlocals.keys() = %s\ngypsh" % (
+        sys.version,
+        sys.platform,
+        repr(sorted(locals.keys())),
+    )
+
+    code.interact(banner, local=locals)
diff --git a/tools/gyp/pylib/gyp/generator/make.py b/tools/gyp/pylib/gyp/generator/make.py
index 848418d3fb6f16db4696cb637e69a82dff00138e..d163ae3135a7f18a3d5fe858a53592283e60402f 100644
--- a/tools/gyp/pylib/gyp/generator/make.py
+++ b/tools/gyp/pylib/gyp/generator/make.py
@@ -25,31 +25,29 @@ from __future__ import print_function
 
 import os
 import re
-import sys
 import subprocess
 import gyp
 import gyp.common
 import gyp.xcode_emulation
 from gyp.common import GetEnvironFallback
-from gyp.common import GypError
 
 import hashlib
 
 generator_default_variables = {
-  'EXECUTABLE_PREFIX': '',
-  'EXECUTABLE_SUFFIX': '',
-  'STATIC_LIB_PREFIX': 'lib',
-  'SHARED_LIB_PREFIX': 'lib',
-  'STATIC_LIB_SUFFIX': '.a',
-  'INTERMEDIATE_DIR': '$(obj).$(TOOLSET)/$(TARGET)/geni',
-  'SHARED_INTERMEDIATE_DIR': '$(obj)/gen',
-  'PRODUCT_DIR': '$(builddir)',
-  'RULE_INPUT_ROOT': '%(INPUT_ROOT)s',  # This gets expanded by Python.
-  'RULE_INPUT_DIRNAME': '%(INPUT_DIRNAME)s',  # This gets expanded by Python.
-  'RULE_INPUT_PATH': '$(abspath $<)',
-  'RULE_INPUT_EXT': '$(suffix $<)',
-  'RULE_INPUT_NAME': '$(notdir $<)',
-  'CONFIGURATION_NAME': '$(BUILDTYPE)',
+    "EXECUTABLE_PREFIX": "",
+    "EXECUTABLE_SUFFIX": "",
+    "STATIC_LIB_PREFIX": "lib",
+    "SHARED_LIB_PREFIX": "lib",
+    "STATIC_LIB_SUFFIX": ".a",
+    "INTERMEDIATE_DIR": "$(obj).$(TOOLSET)/$(TARGET)/geni",
+    "SHARED_INTERMEDIATE_DIR": "$(obj)/gen",
+    "PRODUCT_DIR": "$(builddir)",
+    "RULE_INPUT_ROOT": "%(INPUT_ROOT)s",  # This gets expanded by Python.
+    "RULE_INPUT_DIRNAME": "%(INPUT_DIRNAME)s",  # This gets expanded by Python.
+    "RULE_INPUT_PATH": "$(abspath $<)",
+    "RULE_INPUT_EXT": "$(suffix $<)",
+    "RULE_INPUT_NAME": "$(notdir $<)",
+    "CONFIGURATION_NAME": "$(BUILDTYPE)",
 }
 
 # Make supports multiple toolsets
@@ -66,63 +64,69 @@ generator_filelist_paths = None
 
 
 def CalculateVariables(default_variables, params):
-  """Calculate additional variables for use in the build (called by gyp)."""
-  flavor = gyp.common.GetFlavor(params)
-  if flavor == 'mac':
-    default_variables.setdefault('OS', 'mac')
-    default_variables.setdefault('SHARED_LIB_SUFFIX', '.dylib')
-    default_variables.setdefault('SHARED_LIB_DIR',
-                                 generator_default_variables['PRODUCT_DIR'])
-    default_variables.setdefault('LIB_DIR',
-                                 generator_default_variables['PRODUCT_DIR'])
-
-    # Copy additional generator configuration data from Xcode, which is shared
-    # by the Mac Make generator.
-    import gyp.generator.xcode as xcode_generator
-    global generator_additional_non_configuration_keys
-    generator_additional_non_configuration_keys = getattr(xcode_generator,
-        'generator_additional_non_configuration_keys', [])
-    global generator_additional_path_sections
-    generator_additional_path_sections = getattr(xcode_generator,
-        'generator_additional_path_sections', [])
-    global generator_extra_sources_for_rules
-    generator_extra_sources_for_rules = getattr(xcode_generator,
-        'generator_extra_sources_for_rules', [])
-    COMPILABLE_EXTENSIONS.update({'.m': 'objc', '.mm' : 'objcxx'})
-  else:
-    operating_system = flavor
-    if flavor == 'android':
-      operating_system = 'linux'  # Keep this legacy behavior for now.
-    default_variables.setdefault('OS', operating_system)
-    if flavor == 'aix':
-      default_variables.setdefault('SHARED_LIB_SUFFIX', '.a')
+    """Calculate additional variables for use in the build (called by gyp)."""
+    flavor = gyp.common.GetFlavor(params)
+    if flavor == "mac":
+        default_variables.setdefault("OS", "mac")
+        default_variables.setdefault("SHARED_LIB_SUFFIX", ".dylib")
+        default_variables.setdefault(
+            "SHARED_LIB_DIR", generator_default_variables["PRODUCT_DIR"]
+        )
+        default_variables.setdefault(
+            "LIB_DIR", generator_default_variables["PRODUCT_DIR"]
+        )
+
+        # Copy additional generator configuration data from Xcode, which is shared
+        # by the Mac Make generator.
+        import gyp.generator.xcode as xcode_generator
+
+        global generator_additional_non_configuration_keys
+        generator_additional_non_configuration_keys = getattr(
+            xcode_generator, "generator_additional_non_configuration_keys", []
+        )
+        global generator_additional_path_sections
+        generator_additional_path_sections = getattr(
+            xcode_generator, "generator_additional_path_sections", []
+        )
+        global generator_extra_sources_for_rules
+        generator_extra_sources_for_rules = getattr(
+            xcode_generator, "generator_extra_sources_for_rules", []
+        )
+        COMPILABLE_EXTENSIONS.update({".m": "objc", ".mm": "objcxx"})
     else:
-      default_variables.setdefault('SHARED_LIB_SUFFIX', '.so')
-    default_variables.setdefault('SHARED_LIB_DIR','$(builddir)/lib.$(TOOLSET)')
-    default_variables.setdefault('LIB_DIR', '$(obj).$(TOOLSET)')
+        operating_system = flavor
+        if flavor == "android":
+            operating_system = "linux"  # Keep this legacy behavior for now.
+        default_variables.setdefault("OS", operating_system)
+        if flavor == "aix":
+            default_variables.setdefault("SHARED_LIB_SUFFIX", ".a")
+        else:
+            default_variables.setdefault("SHARED_LIB_SUFFIX", ".so")
+        default_variables.setdefault("SHARED_LIB_DIR", "$(builddir)/lib.$(TOOLSET)")
+        default_variables.setdefault("LIB_DIR", "$(obj).$(TOOLSET)")
 
 
 def CalculateGeneratorInputInfo(params):
-  """Calculate the generator specific info that gets fed to input (called by
+    """Calculate the generator specific info that gets fed to input (called by
   gyp)."""
-  generator_flags = params.get('generator_flags', {})
-  android_ndk_version = generator_flags.get('android_ndk_version', None)
-  # Android NDK requires a strict link order.
-  if android_ndk_version:
-    global generator_wants_sorted_dependencies
-    generator_wants_sorted_dependencies = True
-
-  output_dir = params['options'].generator_output or \
-               params['options'].toplevel_dir
-  builddir_name = generator_flags.get('output_dir', 'out')
-  qualified_out_dir = os.path.normpath(os.path.join(
-    output_dir, builddir_name, 'gypfiles'))
-
-  global generator_filelist_paths
-  generator_filelist_paths = {
-    'toplevel': params['options'].toplevel_dir,
-    'qualified_out_dir': qualified_out_dir,
-  }
+    generator_flags = params.get("generator_flags", {})
+    android_ndk_version = generator_flags.get("android_ndk_version", None)
+    # Android NDK requires a strict link order.
+    if android_ndk_version:
+        global generator_wants_sorted_dependencies
+        generator_wants_sorted_dependencies = True
+
+    output_dir = params["options"].generator_output or params["options"].toplevel_dir
+    builddir_name = generator_flags.get("output_dir", "out")
+    qualified_out_dir = os.path.normpath(
+        os.path.join(output_dir, builddir_name, "gypfiles")
+    )
+
+    global generator_filelist_paths
+    generator_filelist_paths = {
+        "toplevel": params["options"].toplevel_dir,
+        "qualified_out_dir": qualified_out_dir,
+    }
 
 
 # The .d checking code below uses these functions:
@@ -135,7 +139,7 @@ def CalculateGeneratorInputInfo(params):
 # is for example
 #     out/Release/.deps/out/Release/Chromium?Framework.framework/foo
 # This is the replacement character.
-SPACE_REPLACEMENT = '?'
+SPACE_REPLACEMENT = "?"
 
 
 LINK_COMMANDS_LINUX = """\
@@ -172,7 +176,7 @@ cmd_solink = $(LINK.$(TOOLSET)) -o $@ -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET
 
 quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
 cmd_solink_module = $(LINK.$(TOOLSET)) -o $@ -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
-"""
+"""  # noqa: E501
 
 LINK_COMMANDS_MAC = """\
 quiet_cmd_alink = LIBTOOL-STATIC $@
@@ -186,7 +190,7 @@ cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o
 
 quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
 cmd_solink_module = $(LINK.$(TOOLSET)) -bundle $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
-"""
+"""  # noqa: E501
 
 LINK_COMMANDS_ANDROID = """\
 quiet_cmd_alink = AR($(TOOLSET)) $@
@@ -213,7 +217,7 @@ quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
 cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
 quiet_cmd_solink_module_host = SOLINK_MODULE($(TOOLSET)) $@
 cmd_solink_module_host = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
-"""
+"""  # noqa: E501
 
 
 LINK_COMMANDS_AIX = """\
@@ -231,7 +235,7 @@ cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o
 
 quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
 cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
-"""
+"""  # noqa: E501
 
 
 LINK_COMMANDS_OS390 = """\
@@ -249,13 +253,13 @@ cmd_solink = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_
 
 quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
 cmd_solink_module = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS) -Wl,DLL
-
-"""
+"""  # noqa: E501
 
 
 # Header of toplevel Makefile.
 # This should go into the build tree, but it's easier to keep it here for now.
-SHARED_HEADER = ("""\
+SHARED_HEADER = (
+    """\
 # We borrow heavily from the kernel build setup, though we are simpler since
 # we don't have Kconfig tweaking settings on us.
 
@@ -327,8 +331,12 @@ empty :=
 space := $(empty) $(empty)
 
 # http://stackoverflow.com/questions/1189781/using-make-dir-or-notdir-on-a-path-with-spaces
-replace_spaces = $(subst $(space),""" + SPACE_REPLACEMENT + """,$1)
-unreplace_spaces = $(subst """ + SPACE_REPLACEMENT + """,$(space),$1)
+replace_spaces = $(subst $(space),"""
+    + SPACE_REPLACEMENT
+    + """,$1)
+unreplace_spaces = $(subst """
+    + SPACE_REPLACEMENT
+    + """,$(space),$1)
 dirx = $(call unreplace_spaces,$(dir $(call replace_spaces,$1)))
 
 # Flags to make gcc output dependency info.  Note that you need to be
@@ -358,7 +366,7 @@ DEPFLAGS = %(makedep_args)s -MF $(depfile).raw
 # and dollar signs past make, the shell, and sed at the same time.
 # Doesn't work with spaces, but that's fine: .d files have spaces in
 # their names replaced with other characters."""
-r"""
+    r"""
 define fixup_dep
 # The depfile may not exist if the input file didn't have any #includes.
 touch $(depfile).raw
@@ -375,7 +383,7 @@ sed -e 's|\\||' -e 'y| |\n|' $(depfile).raw |\
 rm $(depfile).raw
 endef
 """
-"""
+    """
 # Command definitions:
 # - cmd_foo is the actual command to run;
 # - quiet_cmd_foo is the brief-output summary of the command.
@@ -394,9 +402,8 @@ quiet_cmd_copy = COPY $@
 cmd_copy = ln -f "$<" "$@" 2>/dev/null || (rm -rf "$@" && cp %(copy_archive_args)s "$<" "$@")
 
 %(link_commands)s
-"""
-
-r"""
+"""  # noqa: E501
+    r"""
 # Define an escape_quotes function to escape single quotes.
 # This allows us to handle quotes properly as long as we always use
 # use single quotes and escape_quotes.
@@ -412,7 +419,7 @@ escape_vars = $(subst $$,$$$$,$(1))
 # (e.g., dash, bash).
 exact_echo = printf '%%s\n' '$(call escape_quotes,$(1))'
 """
-"""
+    """
 # Helper to compare the command we're about to run against the command
 # we logged the last time we ran the command.  Produces an empty
 # string (false) when the commands match.
@@ -423,8 +430,9 @@ exact_echo = printf '%%s\n' '$(call escape_quotes,$(1))'
 #                       $(filter-out $(cmd_$@), $(cmd_$(1))))
 # We instead substitute each for the empty string into the other, and
 # say they're equal if both substitutions produce the empty string.
-# .d files contain """ + SPACE_REPLACEMENT + \
-                   """ instead of spaces, take that into account.
+# .d files contain """
+    + SPACE_REPLACEMENT
+    + """ instead of spaces, take that into account.
 command_changed = $(or $(subst $(cmd_$(1)),,$(cmd_$(call replace_spaces,$@))),\\
                        $(subst $(cmd_$(call replace_spaces,$@)),,$(cmd_$(1))))
 
@@ -455,10 +463,12 @@ endef
 # Should always run for a given target to handle command-line changes.
 # Second argument, if non-zero, makes it do asm/C/C++ dependency munging.
 # Third argument, if non-zero, makes it do POSTBUILDS processing.
-# Note: We intentionally do NOT call dirx for depfile, since it contains """ + \
-                                                     SPACE_REPLACEMENT + """ for
-# spaces already and dirx strips the """ + SPACE_REPLACEMENT + \
-                                     """ characters.
+# Note: We intentionally do NOT call dirx for depfile, since it contains """
+    + SPACE_REPLACEMENT
+    + """ for
+# spaces already and dirx strips the """
+    + SPACE_REPLACEMENT
+    + """ characters.
 define do_cmd
 $(if $(or $(command_changed),$(prereq_changed)),
   @$(call exact_echo,  $($(quiet)cmd_$(1)))
@@ -491,7 +501,8 @@ endef
 .PHONY: FORCE_DO_CMD
 FORCE_DO_CMD:
 
-""")
+"""  # noqa: E501
+)
 
 SHARED_HEADER_MAC_COMMANDS = """
 quiet_cmd_objc = CXX($(TOOLSET)) $@
@@ -521,37 +532,38 @@ cmd_mac_package_framework = ./gyp-mac-tool package-framework "$@" $(4)
 
 quiet_cmd_infoplist = INFOPLIST $@
 cmd_infoplist = $(CC.$(TOOLSET)) -E -P -Wno-trigraphs -x c $(INFOPLIST_DEFINES) "$<" -o "$@"
-"""
+"""  # noqa: E501
 
 
 def WriteRootHeaderSuffixRules(writer):
-  extensions = sorted(COMPILABLE_EXTENSIONS.keys(), key=str.lower)
-
-  writer.write('# Suffix rules, putting all outputs into $(obj).\n')
-  for ext in extensions:
-    writer.write('$(obj).$(TOOLSET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD\n' % ext)
-    writer.write('\t@$(call do_cmd,%s,1)\n' % COMPILABLE_EXTENSIONS[ext])
-
-  writer.write('\n# Try building from generated source, too.\n')
-  for ext in extensions:
-    writer.write(
-        '$(obj).$(TOOLSET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD\n' % ext)
-    writer.write('\t@$(call do_cmd,%s,1)\n' % COMPILABLE_EXTENSIONS[ext])
-  writer.write('\n')
-  for ext in extensions:
-    writer.write('$(obj).$(TOOLSET)/%%.o: $(obj)/%%%s FORCE_DO_CMD\n' % ext)
-    writer.write('\t@$(call do_cmd,%s,1)\n' % COMPILABLE_EXTENSIONS[ext])
-  writer.write('\n')
-
-
-SHARED_HEADER_SUFFIX_RULES_COMMENT1 = ("""\
+    extensions = sorted(COMPILABLE_EXTENSIONS.keys(), key=str.lower)
+
+    writer.write("# Suffix rules, putting all outputs into $(obj).\n")
+    for ext in extensions:
+        writer.write("$(obj).$(TOOLSET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD\n" % ext)
+        writer.write("\t@$(call do_cmd,%s,1)\n" % COMPILABLE_EXTENSIONS[ext])
+
+    writer.write("\n# Try building from generated source, too.\n")
+    for ext in extensions:
+        writer.write(
+            "$(obj).$(TOOLSET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD\n" % ext
+        )
+        writer.write("\t@$(call do_cmd,%s,1)\n" % COMPILABLE_EXTENSIONS[ext])
+    writer.write("\n")
+    for ext in extensions:
+        writer.write("$(obj).$(TOOLSET)/%%.o: $(obj)/%%%s FORCE_DO_CMD\n" % ext)
+        writer.write("\t@$(call do_cmd,%s,1)\n" % COMPILABLE_EXTENSIONS[ext])
+    writer.write("\n")
+
+
+SHARED_HEADER_SUFFIX_RULES_COMMENT1 = """\
 # Suffix rules, putting all outputs into $(obj).
-""")
+"""
 
 
-SHARED_HEADER_SUFFIX_RULES_COMMENT2 = ("""\
+SHARED_HEADER_SUFFIX_RULES_COMMENT2 = """\
 # Try building from generated source, too.
-""")
+"""
 
 
 SHARED_FOOTER = """\
@@ -574,114 +586,88 @@ header = """\
 
 # Maps every compilable file extension to the do_cmd that compiles it.
 COMPILABLE_EXTENSIONS = {
-  '.c': 'cc',
-  '.cc': 'cxx',
-  '.cpp': 'cxx',
-  '.cxx': 'cxx',
-  '.s': 'cc',
-  '.S': 'cc',
+    ".c": "cc",
+    ".cc": "cxx",
+    ".cpp": "cxx",
+    ".cxx": "cxx",
+    ".s": "cc",
+    ".S": "cc",
 }
 
+
 def Compilable(filename):
-  """Return true if the file is compilable (should be in OBJS)."""
-  for res in (filename.endswith(e) for e in COMPILABLE_EXTENSIONS):
-    if res:
-      return True
-  return False
+    """Return true if the file is compilable (should be in OBJS)."""
+    for res in (filename.endswith(e) for e in COMPILABLE_EXTENSIONS):
+        if res:
+            return True
+    return False
 
 
 def Linkable(filename):
-  """Return true if the file is linkable (should be on the link line)."""
-  return filename.endswith('.o')
+    """Return true if the file is linkable (should be on the link line)."""
+    return filename.endswith(".o")
 
 
 def Target(filename):
-  """Translate a compilable filename to its .o target."""
-  return os.path.splitext(filename)[0] + '.o'
+    """Translate a compilable filename to its .o target."""
+    return os.path.splitext(filename)[0] + ".o"
 
 
 def EscapeShellArgument(s):
-  """Quotes an argument so that it will be interpreted literally by a POSIX
+    """Quotes an argument so that it will be interpreted literally by a POSIX
      shell. Taken from
      http://stackoverflow.com/questions/35817/whats-the-best-way-to-escape-ossystem-calls-in-python
      """
-  return "'" + s.replace("'", "'\\''") + "'"
+    return "'" + s.replace("'", "'\\''") + "'"
 
 
 def EscapeMakeVariableExpansion(s):
-  """Make has its own variable expansion syntax using $. We must escape it for
+    """Make has its own variable expansion syntax using $. We must escape it for
      string to be interpreted literally."""
-  return s.replace('$', '$$')
+    return s.replace("$", "$$")
 
 
 def EscapeCppDefine(s):
-  """Escapes a CPP define so that it will reach the compiler unaltered."""
-  s = EscapeShellArgument(s)
-  s = EscapeMakeVariableExpansion(s)
-  # '#' characters must be escaped even embedded in a string, else Make will
-  # treat it as the start of a comment.
-  return s.replace('#', r'\#')
+    """Escapes a CPP define so that it will reach the compiler unaltered."""
+    s = EscapeShellArgument(s)
+    s = EscapeMakeVariableExpansion(s)
+    # '#' characters must be escaped even embedded in a string, else Make will
+    # treat it as the start of a comment.
+    return s.replace("#", r"\#")
 
 
 def QuoteIfNecessary(string):
-  """TODO: Should this ideally be replaced with one or more of the above
+    """TODO: Should this ideally be replaced with one or more of the above
      functions?"""
-  if '"' in string:
-    string = '"' + string.replace('"', '\\"') + '"'
-  return string
+    if '"' in string:
+        string = '"' + string.replace('"', '\\"') + '"'
+    return string
 
 
 def StringToMakefileVariable(string):
-  """Convert a string to a value that is acceptable as a make variable name."""
-  return re.sub('[^a-zA-Z0-9_]', '_', string)
+    """Convert a string to a value that is acceptable as a make variable name."""
+    return re.sub("[^a-zA-Z0-9_]", "_", string)
 
 
-srcdir_prefix = ''
-def Sourceify(path):
-  """Convert a path to its source directory form."""
-  if '$(' in path:
-    return path
-  if os.path.isabs(path):
-    return path
-  return srcdir_prefix + path
+srcdir_prefix = ""
+
 
+def Sourceify(path):
+    """Convert a path to its source directory form."""
+    if "$(" in path:
+        return path
+    if os.path.isabs(path):
+        return path
+    return srcdir_prefix + path
 
-def QuoteSpaces(s, quote=r'\ '):
-  return s.replace(' ', quote)
 
-def SourceifyAndQuoteSpaces(path):
-  """Convert a path to its source directory form and quote spaces."""
-  return QuoteSpaces(Sourceify(path))
+def QuoteSpaces(s, quote=r"\ "):
+    return s.replace(" ", quote)
 
-# TODO: Avoid code duplication with _ValidateSourcesForMSVSProject in msvs.py.
-def _ValidateSourcesForOSX(spec, all_sources):
-  """Makes sure if duplicate basenames are not specified in the source list.
 
-  Arguments:
-    spec: The target dictionary containing the properties of the target.
-  """
-  if spec.get('type', None) != 'static_library':
-    return
-
-  basenames = {}
-  for source in all_sources:
-    name, ext = os.path.splitext(source)
-    is_compiled_file = ext in [
-        '.c', '.cc', '.cpp', '.cxx', '.m', '.mm', '.s', '.S']
-    if not is_compiled_file:
-      continue
-    basename = os.path.basename(name)  # Don't include extension.
-    basenames.setdefault(basename, []).append(source)
-
-  error = ''
-  for basename, files in basenames.items():
-    if len(files) > 1:
-      error += '  %s: %s\n' % (basename, ' '.join(files))
-
-  if error:
-    print(('static library %s has several files with the same basename:\n' % spec['target_name'])
-           + error + 'libtool on OS X will generate' + ' warnings for them.')
-    raise GypError('Duplicate basenames in sources section, see list above')
+def SourceifyAndQuoteSpaces(path):
+    """Convert a path to its source directory form and quote spaces."""
+    return QuoteSpaces(Sourceify(path))
 
 
 # Map from qualified target to path to output.
@@ -694,41 +680,62 @@ target_link_deps = {}
 
 
 class MakefileWriter(object):
-  """MakefileWriter packages up the writing of one target-specific foobar.mk.
+    """MakefileWriter packages up the writing of one target-specific foobar.mk.
 
   Its only real entry point is Write(), and is mostly used for namespacing.
   """
 
-  def __init__(self, generator_flags, flavor):
-    self.generator_flags = generator_flags
-    self.flavor = flavor
-
-    self.suffix_rules_srcdir = {}
-    self.suffix_rules_objdir1 = {}
-    self.suffix_rules_objdir2 = {}
-
-    # Generate suffix rules for all compilable extensions.
-    for ext in COMPILABLE_EXTENSIONS.keys():
-      # Suffix rules for source folder.
-      self.suffix_rules_srcdir.update({ext: ("""\
+    def __init__(self, generator_flags, flavor):
+        self.generator_flags = generator_flags
+        self.flavor = flavor
+
+        self.suffix_rules_srcdir = {}
+        self.suffix_rules_objdir1 = {}
+        self.suffix_rules_objdir2 = {}
+
+        # Generate suffix rules for all compilable extensions.
+        for ext in COMPILABLE_EXTENSIONS.keys():
+            # Suffix rules for source folder.
+            self.suffix_rules_srcdir.update(
+                {
+                    ext: (
+                        """\
 $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD
-	@$(call do_cmd,%s,1)
-""" % (ext, COMPILABLE_EXTENSIONS[ext]))})
-
-      # Suffix rules for generated source files.
-      self.suffix_rules_objdir1.update({ext: ("""\
+\t@$(call do_cmd,%s,1)
+"""
+                        % (ext, COMPILABLE_EXTENSIONS[ext])
+                    )
+                }
+            )
+
+            # Suffix rules for generated source files.
+            self.suffix_rules_objdir1.update(
+                {
+                    ext: (
+                        """\
 $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD
-	@$(call do_cmd,%s,1)
-""" % (ext, COMPILABLE_EXTENSIONS[ext]))})
-      self.suffix_rules_objdir2.update({ext: ("""\
+\t@$(call do_cmd,%s,1)
+"""
+                        % (ext, COMPILABLE_EXTENSIONS[ext])
+                    )
+                }
+            )
+            self.suffix_rules_objdir2.update(
+                {
+                    ext: (
+                        """\
 $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
-	@$(call do_cmd,%s,1)
-""" % (ext, COMPILABLE_EXTENSIONS[ext]))})
-
+\t@$(call do_cmd,%s,1)
+"""
+                        % (ext, COMPILABLE_EXTENSIONS[ext])
+                    )
+                }
+            )
 
-  def Write(self, qualified_target, base_path, output_filename, spec, configs,
-            part_of_all):
-    """The main entry point: writes a .mk file for a single target.
+    def Write(
+        self, qualified_target, base_path, output_filename, spec, configs, part_of_all
+    ):
+        """The main entry point: writes a .mk file for a single target.
 
     Arguments:
       qualified_target: target we're generating
@@ -738,129 +745,148 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
       spec, configs: gyp info
       part_of_all: flag indicating this target is part of 'all'
     """
-    gyp.common.EnsureDirExists(output_filename)
-
-    self.fp = open(output_filename, 'w')
-
-    self.fp.write(header)
-
-    self.qualified_target = qualified_target
-    self.path = base_path
-    self.target = spec['target_name']
-    self.type = spec['type']
-    self.toolset = spec['toolset']
-
-    self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
-    if self.flavor == 'mac':
-      self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
-    else:
-      self.xcode_settings = None
-
-    deps, link_deps = self.ComputeDeps(spec)
-
-    # Some of the generation below can add extra output, sources, or
-    # link dependencies.  All of the out params of the functions that
-    # follow use names like extra_foo.
-    extra_outputs = []
-    extra_sources = []
-    extra_link_deps = []
-    extra_mac_bundle_resources = []
-    mac_bundle_deps = []
-
-    if self.is_mac_bundle:
-      self.output = self.ComputeMacBundleOutput(spec)
-      self.output_binary = self.ComputeMacBundleBinaryOutput(spec)
-    else:
-      self.output = self.output_binary = self.ComputeOutput(spec)
-
-    self.is_standalone_static_library = bool(
-        spec.get('standalone_static_library', 0))
-    self._INSTALLABLE_TARGETS = ('executable', 'loadable_module',
-                                 'shared_library')
-    if (self.is_standalone_static_library or
-        self.type in self._INSTALLABLE_TARGETS):
-      self.alias = os.path.basename(self.output)
-      install_path = self._InstallableTargetInstallPath()
-    else:
-      self.alias = self.output
-      install_path = self.output
-
-    self.WriteLn("TOOLSET := " + self.toolset)
-    self.WriteLn("TARGET := " + self.target)
-
-    # Actions must come first, since they can generate more OBJs for use below.
-    if 'actions' in spec:
-      self.WriteActions(spec['actions'], extra_sources, extra_outputs,
-                        extra_mac_bundle_resources, part_of_all)
-
-    # Rules must be early like actions.
-    if 'rules' in spec:
-      self.WriteRules(spec['rules'], extra_sources, extra_outputs,
-                      extra_mac_bundle_resources, part_of_all)
-
-    if 'copies' in spec:
-      self.WriteCopies(spec['copies'], extra_outputs, part_of_all)
-
-    # Bundle resources.
-    if self.is_mac_bundle:
-      all_mac_bundle_resources = (
-          spec.get('mac_bundle_resources', []) + extra_mac_bundle_resources)
-      self.WriteMacBundleResources(all_mac_bundle_resources, mac_bundle_deps)
-      self.WriteMacInfoPlist(mac_bundle_deps)
-
-    # Sources.
-    all_sources = spec.get('sources', []) + extra_sources
-    if all_sources:
-      if self.flavor == 'mac':
-        # libtool on OS X generates warnings for duplicate basenames in the same
-        # target.
-        _ValidateSourcesForOSX(spec, all_sources)
-      self.WriteSources(
-          configs, deps, all_sources, extra_outputs,
-          extra_link_deps, part_of_all,
-          gyp.xcode_emulation.MacPrefixHeader(
-              self.xcode_settings, lambda p: Sourceify(self.Absolutify(p)),
-              self.Pchify))
-      sources = list(filter(Compilable, all_sources))
-      if sources:
-        self.WriteLn(SHARED_HEADER_SUFFIX_RULES_COMMENT1)
-        extensions = set([os.path.splitext(s)[1] for s in sources])
-        for ext in extensions:
-          if ext in self.suffix_rules_srcdir:
-            self.WriteLn(self.suffix_rules_srcdir[ext])
-        self.WriteLn(SHARED_HEADER_SUFFIX_RULES_COMMENT2)
-        for ext in extensions:
-          if ext in self.suffix_rules_objdir1:
-            self.WriteLn(self.suffix_rules_objdir1[ext])
-        for ext in extensions:
-          if ext in self.suffix_rules_objdir2:
-            self.WriteLn(self.suffix_rules_objdir2[ext])
-        self.WriteLn('# End of this set of suffix rules')
-
-        # Add dependency from bundle to bundle binary.
-        if self.is_mac_bundle:
-          mac_bundle_deps.append(self.output_binary)
+        gyp.common.EnsureDirExists(output_filename)
 
-    self.WriteTarget(spec, configs, deps, extra_link_deps + link_deps,
-                     mac_bundle_deps, extra_outputs, part_of_all)
+        self.fp = open(output_filename, "w")
 
-    # Update global list of target outputs, used in dependency tracking.
-    target_outputs[qualified_target] = install_path
+        self.fp.write(header)
 
-    # Update global list of link dependencies.
-    if self.type in ('static_library', 'shared_library'):
-      target_link_deps[qualified_target] = self.output_binary
+        self.qualified_target = qualified_target
+        self.path = base_path
+        self.target = spec["target_name"]
+        self.type = spec["type"]
+        self.toolset = spec["toolset"]
 
-    # Currently any versions have the same effect, but in future the behavior
-    # could be different.
-    if self.generator_flags.get('android_ndk_version', None):
-      self.WriteAndroidNdkModuleRule(self.target, all_sources, link_deps)
+        self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
+        if self.flavor == "mac":
+            self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
+        else:
+            self.xcode_settings = None
 
-    self.fp.close()
+        deps, link_deps = self.ComputeDeps(spec)
 
+        # Some of the generation below can add extra output, sources, or
+        # link dependencies.  All of the out params of the functions that
+        # follow use names like extra_foo.
+        extra_outputs = []
+        extra_sources = []
+        extra_link_deps = []
+        extra_mac_bundle_resources = []
+        mac_bundle_deps = []
 
-  def WriteSubMake(self, output_filename, makefile_path, targets, build_dir):
-    """Write a "sub-project" Makefile.
+        if self.is_mac_bundle:
+            self.output = self.ComputeMacBundleOutput(spec)
+            self.output_binary = self.ComputeMacBundleBinaryOutput(spec)
+        else:
+            self.output = self.output_binary = self.ComputeOutput(spec)
+
+        self.is_standalone_static_library = bool(
+            spec.get("standalone_static_library", 0)
+        )
+        self._INSTALLABLE_TARGETS = ("executable", "loadable_module", "shared_library")
+        if self.is_standalone_static_library or self.type in self._INSTALLABLE_TARGETS:
+            self.alias = os.path.basename(self.output)
+            install_path = self._InstallableTargetInstallPath()
+        else:
+            self.alias = self.output
+            install_path = self.output
+
+        self.WriteLn("TOOLSET := " + self.toolset)
+        self.WriteLn("TARGET := " + self.target)
+
+        # Actions must come first, since they can generate more OBJs for use below.
+        if "actions" in spec:
+            self.WriteActions(
+                spec["actions"],
+                extra_sources,
+                extra_outputs,
+                extra_mac_bundle_resources,
+                part_of_all,
+            )
+
+        # Rules must be early like actions.
+        if "rules" in spec:
+            self.WriteRules(
+                spec["rules"],
+                extra_sources,
+                extra_outputs,
+                extra_mac_bundle_resources,
+                part_of_all,
+            )
+
+        if "copies" in spec:
+            self.WriteCopies(spec["copies"], extra_outputs, part_of_all)
+
+        # Bundle resources.
+        if self.is_mac_bundle:
+            all_mac_bundle_resources = (
+                spec.get("mac_bundle_resources", []) + extra_mac_bundle_resources
+            )
+            self.WriteMacBundleResources(all_mac_bundle_resources, mac_bundle_deps)
+            self.WriteMacInfoPlist(mac_bundle_deps)
+
+        # Sources.
+        all_sources = spec.get("sources", []) + extra_sources
+        if all_sources:
+            self.WriteSources(
+                configs,
+                deps,
+                all_sources,
+                extra_outputs,
+                extra_link_deps,
+                part_of_all,
+                gyp.xcode_emulation.MacPrefixHeader(
+                    self.xcode_settings,
+                    lambda p: Sourceify(self.Absolutify(p)),
+                    self.Pchify,
+                ),
+            )
+            sources = [x for x in all_sources if Compilable(x)]
+            if sources:
+                self.WriteLn(SHARED_HEADER_SUFFIX_RULES_COMMENT1)
+                extensions = set([os.path.splitext(s)[1] for s in sources])
+                for ext in extensions:
+                    if ext in self.suffix_rules_srcdir:
+                        self.WriteLn(self.suffix_rules_srcdir[ext])
+                self.WriteLn(SHARED_HEADER_SUFFIX_RULES_COMMENT2)
+                for ext in extensions:
+                    if ext in self.suffix_rules_objdir1:
+                        self.WriteLn(self.suffix_rules_objdir1[ext])
+                for ext in extensions:
+                    if ext in self.suffix_rules_objdir2:
+                        self.WriteLn(self.suffix_rules_objdir2[ext])
+                self.WriteLn("# End of this set of suffix rules")
+
+                # Add dependency from bundle to bundle binary.
+                if self.is_mac_bundle:
+                    mac_bundle_deps.append(self.output_binary)
+
+        self.WriteTarget(
+            spec,
+            configs,
+            deps,
+            extra_link_deps + link_deps,
+            mac_bundle_deps,
+            extra_outputs,
+            part_of_all,
+        )
+
+        # Update global list of target outputs, used in dependency tracking.
+        target_outputs[qualified_target] = install_path
+
+        # Update global list of link dependencies.
+        if self.type in ("static_library", "shared_library"):
+            target_link_deps[qualified_target] = self.output_binary
+
+        # Currently any versions have the same effect, but in future the behavior
+        # could be different.
+        if self.generator_flags.get("android_ndk_version", None):
+            self.WriteAndroidNdkModuleRule(self.target, all_sources, link_deps)
+
+        self.fp.close()
+
+    def WriteSubMake(self, output_filename, makefile_path, targets, build_dir):
+        """Write a "sub-project" Makefile.
 
     This is a small, wrapper Makefile that calls the top-level Makefile to build
     the targets from a single gyp file (i.e. a sub-project).
@@ -871,24 +897,31 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
       targets: list of "all" targets for this sub-project
       build_dir: build output directory, relative to the sub-project
     """
-    gyp.common.EnsureDirExists(output_filename)
-    self.fp = open(output_filename, 'w')
-    self.fp.write(header)
-    # For consistency with other builders, put sub-project build output in the
-    # sub-project dir (see test/subdirectory/gyptest-subdir-all.py).
-    self.WriteLn('export builddir_name ?= %s' %
-                 os.path.join(os.path.dirname(output_filename), build_dir))
-    self.WriteLn('.PHONY: all')
-    self.WriteLn('all:')
-    if makefile_path:
-      makefile_path = ' -C ' + makefile_path
-    self.WriteLn('\t$(MAKE)%s %s' % (makefile_path, ' '.join(targets)))
-    self.fp.close()
-
-
-  def WriteActions(self, actions, extra_sources, extra_outputs,
-                   extra_mac_bundle_resources, part_of_all):
-    """Write Makefile code for any 'actions' from the gyp input.
+        gyp.common.EnsureDirExists(output_filename)
+        self.fp = open(output_filename, "w")
+        self.fp.write(header)
+        # For consistency with other builders, put sub-project build output in the
+        # sub-project dir (see test/subdirectory/gyptest-subdir-all.py).
+        self.WriteLn(
+            "export builddir_name ?= %s"
+            % os.path.join(os.path.dirname(output_filename), build_dir)
+        )
+        self.WriteLn(".PHONY: all")
+        self.WriteLn("all:")
+        if makefile_path:
+            makefile_path = " -C " + makefile_path
+        self.WriteLn("\t$(MAKE)%s %s" % (makefile_path, " ".join(targets)))
+        self.fp.close()
+
+    def WriteActions(
+        self,
+        actions,
+        extra_sources,
+        extra_outputs,
+        extra_mac_bundle_resources,
+        part_of_all,
+    ):
+        """Write Makefile code for any 'actions' from the gyp input.
 
     extra_sources: a list that will be filled in with newly generated source
                    files, if any
@@ -897,98 +930,113 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
                    actions)
     part_of_all: flag indicating this target is part of 'all'
     """
-    env = self.GetSortedXcodeEnv()
-    for action in actions:
-      name = StringToMakefileVariable('%s_%s' % (self.qualified_target,
-                                                 action['action_name']))
-      self.WriteLn('### Rules for action "%s":' % action['action_name'])
-      inputs = action['inputs']
-      outputs = action['outputs']
-
-      # Build up a list of outputs.
-      # Collect the output dirs we'll need.
-      dirs = set()
-      for out in outputs:
-        dir = os.path.split(out)[0]
-        if dir:
-          dirs.add(dir)
-      if int(action.get('process_outputs_as_sources', False)):
-        extra_sources += outputs
-      if int(action.get('process_outputs_as_mac_bundle_resources', False)):
-        extra_mac_bundle_resources += outputs
-
-      # Write the actual command.
-      action_commands = action['action']
-      if self.flavor == 'mac':
-        action_commands = [gyp.xcode_emulation.ExpandEnvVars(command, env)
-                          for command in action_commands]
-      command = gyp.common.EncodePOSIXShellList(action_commands)
-      if 'message' in action:
-        self.WriteLn('quiet_cmd_%s = ACTION %s $@' % (name, action['message']))
-      else:
-        self.WriteLn('quiet_cmd_%s = ACTION %s $@' % (name, name))
-      if len(dirs) > 0:
-        command = 'mkdir -p %s' % ' '.join(dirs) + '; ' + command
-
-      cd_action = 'cd %s; ' % Sourceify(self.path or '.')
-
-      # command and cd_action get written to a toplevel variable called
-      # cmd_foo. Toplevel variables can't handle things that change per
-      # makefile like $(TARGET), so hardcode the target.
-      command = command.replace('$(TARGET)', self.target)
-      cd_action = cd_action.replace('$(TARGET)', self.target)
-
-      # Set LD_LIBRARY_PATH in case the action runs an executable from this
-      # build which links to shared libs from this build.
-      # actions run on the host, so they should in theory only use host
-      # libraries, but until everything is made cross-compile safe, also use
-      # target libraries.
-      # TODO(piman): when everything is cross-compile safe, remove lib.target
-      self.WriteLn('cmd_%s = LD_LIBRARY_PATH=$(builddir)/lib.host:'
-                   '$(builddir)/lib.target:$$LD_LIBRARY_PATH; '
-                   'export LD_LIBRARY_PATH; '
-                   '%s%s'
-                   % (name, cd_action, command))
-      self.WriteLn()
-      outputs = [self.Absolutify(o) for o in outputs]
-      # The makefile rules are all relative to the top dir, but the gyp actions
-      # are defined relative to their containing dir.  This replaces the obj
-      # variable for the action rule with an absolute version so that the output
-      # goes in the right place.
-      # Only write the 'obj' and 'builddir' rules for the "primary" output (:1);
-      # it's superfluous for the "extra outputs", and this avoids accidentally
-      # writing duplicate dummy rules for those outputs.
-      # Same for environment.
-      self.WriteLn("%s: obj := $(abs_obj)" % QuoteSpaces(outputs[0]))
-      self.WriteLn("%s: builddir := $(abs_builddir)" % QuoteSpaces(outputs[0]))
-      self.WriteSortedXcodeEnv(outputs[0], self.GetSortedXcodeEnv())
-
-      for input in inputs:
-        assert ' ' not in input, (
-            "Spaces in action input filenames not supported (%s)"  % input)
-      for output in outputs:
-        assert ' ' not in output, (
-            "Spaces in action output filenames not supported (%s)"  % output)
-
-      # See the comment in WriteCopies about expanding env vars.
-      outputs = [gyp.xcode_emulation.ExpandEnvVars(o, env) for o in outputs]
-      inputs = [gyp.xcode_emulation.ExpandEnvVars(i, env) for i in inputs]
-
-      self.WriteDoCmd(outputs, [Sourceify(self.Absolutify(i)) for i in inputs],
-                      part_of_all=part_of_all, command=name)
-
-      # Stuff the outputs in a variable so we can refer to them later.
-      outputs_variable = 'action_%s_outputs' % name
-      self.WriteLn('%s := %s' % (outputs_variable, ' '.join(outputs)))
-      extra_outputs.append('$(%s)' % outputs_variable)
-      self.WriteLn()
-
-    self.WriteLn()
-
-
-  def WriteRules(self, rules, extra_sources, extra_outputs,
-                 extra_mac_bundle_resources, part_of_all):
-    """Write Makefile code for any 'rules' from the gyp input.
+        env = self.GetSortedXcodeEnv()
+        for action in actions:
+            name = StringToMakefileVariable(
+                "%s_%s" % (self.qualified_target, action["action_name"])
+            )
+            self.WriteLn('### Rules for action "%s":' % action["action_name"])
+            inputs = action["inputs"]
+            outputs = action["outputs"]
+
+            # Build up a list of outputs.
+            # Collect the output dirs we'll need.
+            dirs = set()
+            for out in outputs:
+                dir = os.path.split(out)[0]
+                if dir:
+                    dirs.add(dir)
+            if int(action.get("process_outputs_as_sources", False)):
+                extra_sources += outputs
+            if int(action.get("process_outputs_as_mac_bundle_resources", False)):
+                extra_mac_bundle_resources += outputs
+
+            # Write the actual command.
+            action_commands = action["action"]
+            if self.flavor == "mac":
+                action_commands = [
+                    gyp.xcode_emulation.ExpandEnvVars(command, env)
+                    for command in action_commands
+                ]
+            command = gyp.common.EncodePOSIXShellList(action_commands)
+            if "message" in action:
+                self.WriteLn("quiet_cmd_%s = ACTION %s $@" % (name, action["message"]))
+            else:
+                self.WriteLn("quiet_cmd_%s = ACTION %s $@" % (name, name))
+            if len(dirs) > 0:
+                command = "mkdir -p %s" % " ".join(dirs) + "; " + command
+
+            cd_action = "cd %s; " % Sourceify(self.path or ".")
+
+            # command and cd_action get written to a toplevel variable called
+            # cmd_foo. Toplevel variables can't handle things that change per
+            # makefile like $(TARGET), so hardcode the target.
+            command = command.replace("$(TARGET)", self.target)
+            cd_action = cd_action.replace("$(TARGET)", self.target)
+
+            # Set LD_LIBRARY_PATH in case the action runs an executable from this
+            # build which links to shared libs from this build.
+            # actions run on the host, so they should in theory only use host
+            # libraries, but until everything is made cross-compile safe, also use
+            # target libraries.
+            # TODO(piman): when everything is cross-compile safe, remove lib.target
+            self.WriteLn(
+                "cmd_%s = LD_LIBRARY_PATH=$(builddir)/lib.host:"
+                "$(builddir)/lib.target:$$LD_LIBRARY_PATH; "
+                "export LD_LIBRARY_PATH; "
+                "%s%s" % (name, cd_action, command)
+            )
+            self.WriteLn()
+            outputs = [self.Absolutify(o) for o in outputs]
+            # The makefile rules are all relative to the top dir, but the gyp actions
+            # are defined relative to their containing dir.  This replaces the obj
+            # variable for the action rule with an absolute version so that the output
+            # goes in the right place.
+            # Only write the 'obj' and 'builddir' rules for the "primary" output (:1);
+            # it's superfluous for the "extra outputs", and this avoids accidentally
+            # writing duplicate dummy rules for those outputs.
+            # Same for environment.
+            self.WriteLn("%s: obj := $(abs_obj)" % QuoteSpaces(outputs[0]))
+            self.WriteLn("%s: builddir := $(abs_builddir)" % QuoteSpaces(outputs[0]))
+            self.WriteSortedXcodeEnv(outputs[0], self.GetSortedXcodeEnv())
+
+            for input in inputs:
+                assert " " not in input, (
+                    "Spaces in action input filenames not supported (%s)" % input
+                )
+            for output in outputs:
+                assert " " not in output, (
+                    "Spaces in action output filenames not supported (%s)" % output
+                )
+
+            # See the comment in WriteCopies about expanding env vars.
+            outputs = [gyp.xcode_emulation.ExpandEnvVars(o, env) for o in outputs]
+            inputs = [gyp.xcode_emulation.ExpandEnvVars(i, env) for i in inputs]
+
+            self.WriteDoCmd(
+                outputs,
+                [Sourceify(self.Absolutify(i)) for i in inputs],
+                part_of_all=part_of_all,
+                command=name,
+            )
+
+            # Stuff the outputs in a variable so we can refer to them later.
+            outputs_variable = "action_%s_outputs" % name
+            self.WriteLn("%s := %s" % (outputs_variable, " ".join(outputs)))
+            extra_outputs.append("$(%s)" % outputs_variable)
+            self.WriteLn()
+
+        self.WriteLn()
+
+    def WriteRules(
+        self,
+        rules,
+        extra_sources,
+        extra_outputs,
+        extra_mac_bundle_resources,
+        part_of_all,
+    ):
+        """Write Makefile code for any 'rules' from the gyp input.
 
     extra_sources: a list that will be filled in with newly generated source
                    files, if any
@@ -996,208 +1044,240 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
                    rules (used to make other pieces dependent on these rules)
     part_of_all: flag indicating this target is part of 'all'
     """
-    env = self.GetSortedXcodeEnv()
-    for rule in rules:
-      name = StringToMakefileVariable('%s_%s' % (self.qualified_target,
-                                                 rule['rule_name']))
-      count = 0
-      self.WriteLn('### Generated for rule %s:' % name)
-
-      all_outputs = []
-
-      for rule_source in rule.get('rule_sources', []):
-        dirs = set()
-        (rule_source_dirname, rule_source_basename) = os.path.split(rule_source)
-        (rule_source_root, rule_source_ext) = \
-            os.path.splitext(rule_source_basename)
-
-        outputs = [self.ExpandInputRoot(out, rule_source_root,
-                                        rule_source_dirname)
-                   for out in rule['outputs']]
-
-        for out in outputs:
-          dir = os.path.dirname(out)
-          if dir:
-            dirs.add(dir)
-        if int(rule.get('process_outputs_as_sources', False)):
-          extra_sources += outputs
-        if int(rule.get('process_outputs_as_mac_bundle_resources', False)):
-          extra_mac_bundle_resources += outputs
-        inputs = [Sourceify(self.Absolutify(i)) for i
-                  in [rule_source] + rule.get('inputs', [])]
-        actions = ['$(call do_cmd,%s_%d)' % (name, count)]
-
-        if name == 'resources_grit':
-          # HACK: This is ugly.  Grit intentionally doesn't touch the
-          # timestamp of its output file when the file doesn't change,
-          # which is fine in hash-based dependency systems like scons
-          # and forge, but not kosher in the make world.  After some
-          # discussion, hacking around it here seems like the least
-          # amount of pain.
-          actions += ['@touch --no-create $@']
-
-        # See the comment in WriteCopies about expanding env vars.
-        outputs = [gyp.xcode_emulation.ExpandEnvVars(o, env) for o in outputs]
-        inputs = [gyp.xcode_emulation.ExpandEnvVars(i, env) for i in inputs]
-
-        outputs = [self.Absolutify(o) for o in outputs]
-        all_outputs += outputs
-        # Only write the 'obj' and 'builddir' rules for the "primary" output
-        # (:1); it's superfluous for the "extra outputs", and this avoids
-        # accidentally writing duplicate dummy rules for those outputs.
-        self.WriteLn('%s: obj := $(abs_obj)' % outputs[0])
-        self.WriteLn('%s: builddir := $(abs_builddir)' % outputs[0])
-        self.WriteMakeRule(outputs, inputs, actions,
-                           command="%s_%d" % (name, count))
-        # Spaces in rule filenames are not supported, but rule variables have
-        # spaces in them (e.g. RULE_INPUT_PATH expands to '$(abspath $<)').
-        # The spaces within the variables are valid, so remove the variables
-        # before checking.
-        variables_with_spaces = re.compile(r'\$\([^ ]* \$<\)')
-        for output in outputs:
-          output = re.sub(variables_with_spaces, '', output)
-          assert ' ' not in output, (
-              "Spaces in rule filenames not yet supported (%s)"  % output)
-        self.WriteLn('all_deps += %s' % ' '.join(outputs))
-
-        action = [self.ExpandInputRoot(ac, rule_source_root,
-                                       rule_source_dirname)
-                  for ac in rule['action']]
-        mkdirs = ''
-        if len(dirs) > 0:
-          mkdirs = 'mkdir -p %s; ' % ' '.join(dirs)
-        cd_action = 'cd %s; ' % Sourceify(self.path or '.')
-
-        # action, cd_action, and mkdirs get written to a toplevel variable
-        # called cmd_foo. Toplevel variables can't handle things that change
-        # per makefile like $(TARGET), so hardcode the target.
-        if self.flavor == 'mac':
-          action = [gyp.xcode_emulation.ExpandEnvVars(command, env)
-                    for command in action]
-        action = gyp.common.EncodePOSIXShellList(action)
-        action = action.replace('$(TARGET)', self.target)
-        cd_action = cd_action.replace('$(TARGET)', self.target)
-        mkdirs = mkdirs.replace('$(TARGET)', self.target)
-
-        # Set LD_LIBRARY_PATH in case the rule runs an executable from this
-        # build which links to shared libs from this build.
-        # rules run on the host, so they should in theory only use host
-        # libraries, but until everything is made cross-compile safe, also use
-        # target libraries.
-        # TODO(piman): when everything is cross-compile safe, remove lib.target
-        self.WriteLn(
-            "cmd_%(name)s_%(count)d = LD_LIBRARY_PATH="
-              "$(builddir)/lib.host:$(builddir)/lib.target:$$LD_LIBRARY_PATH; "
-              "export LD_LIBRARY_PATH; "
-              "%(cd_action)s%(mkdirs)s%(action)s" % {
-          'action': action,
-          'cd_action': cd_action,
-          'count': count,
-          'mkdirs': mkdirs,
-          'name': name,
-        })
-        self.WriteLn(
-            'quiet_cmd_%(name)s_%(count)d = RULE %(name)s_%(count)d $@' % {
-          'count': count,
-          'name': name,
-        })
-        self.WriteLn()
-        count += 1
-
-      outputs_variable = 'rule_%s_outputs' % name
-      self.WriteList(all_outputs, outputs_variable)
-      extra_outputs.append('$(%s)' % outputs_variable)
-
-      self.WriteLn('### Finished generating for rule: %s' % name)
-      self.WriteLn()
-    self.WriteLn('### Finished generating for all rules')
-    self.WriteLn('')
-
-
-  def WriteCopies(self, copies, extra_outputs, part_of_all):
-    """Write Makefile code for any 'copies' from the gyp input.
+        env = self.GetSortedXcodeEnv()
+        for rule in rules:
+            name = StringToMakefileVariable(
+                "%s_%s" % (self.qualified_target, rule["rule_name"])
+            )
+            count = 0
+            self.WriteLn("### Generated for rule %s:" % name)
+
+            all_outputs = []
+
+            for rule_source in rule.get("rule_sources", []):
+                dirs = set()
+                (rule_source_dirname, rule_source_basename) = os.path.split(rule_source)
+                (rule_source_root, rule_source_ext) = os.path.splitext(
+                    rule_source_basename
+                )
+
+                outputs = [
+                    self.ExpandInputRoot(out, rule_source_root, rule_source_dirname)
+                    for out in rule["outputs"]
+                ]
+
+                for out in outputs:
+                    dir = os.path.dirname(out)
+                    if dir:
+                        dirs.add(dir)
+                if int(rule.get("process_outputs_as_sources", False)):
+                    extra_sources += outputs
+                if int(rule.get("process_outputs_as_mac_bundle_resources", False)):
+                    extra_mac_bundle_resources += outputs
+                inputs = [
+                    Sourceify(self.Absolutify(i))
+                    for i in [rule_source] + rule.get("inputs", [])
+                ]
+                actions = ["$(call do_cmd,%s_%d)" % (name, count)]
+
+                if name == "resources_grit":
+                    # HACK: This is ugly.  Grit intentionally doesn't touch the
+                    # timestamp of its output file when the file doesn't change,
+                    # which is fine in hash-based dependency systems like scons
+                    # and forge, but not kosher in the make world.  After some
+                    # discussion, hacking around it here seems like the least
+                    # amount of pain.
+                    actions += ["@touch --no-create $@"]
+
+                # See the comment in WriteCopies about expanding env vars.
+                outputs = [gyp.xcode_emulation.ExpandEnvVars(o, env) for o in outputs]
+                inputs = [gyp.xcode_emulation.ExpandEnvVars(i, env) for i in inputs]
+
+                outputs = [self.Absolutify(o) for o in outputs]
+                all_outputs += outputs
+                # Only write the 'obj' and 'builddir' rules for the "primary" output
+                # (:1); it's superfluous for the "extra outputs", and this avoids
+                # accidentally writing duplicate dummy rules for those outputs.
+                self.WriteLn("%s: obj := $(abs_obj)" % outputs[0])
+                self.WriteLn("%s: builddir := $(abs_builddir)" % outputs[0])
+                self.WriteMakeRule(
+                    outputs, inputs, actions, command="%s_%d" % (name, count)
+                )
+                # Spaces in rule filenames are not supported, but rule variables have
+                # spaces in them (e.g. RULE_INPUT_PATH expands to '$(abspath $<)').
+                # The spaces within the variables are valid, so remove the variables
+                # before checking.
+                variables_with_spaces = re.compile(r"\$\([^ ]* \$<\)")
+                for output in outputs:
+                    output = re.sub(variables_with_spaces, "", output)
+                    assert " " not in output, (
+                        "Spaces in rule filenames not yet supported (%s)" % output
+                    )
+                self.WriteLn("all_deps += %s" % " ".join(outputs))
+
+                action = [
+                    self.ExpandInputRoot(ac, rule_source_root, rule_source_dirname)
+                    for ac in rule["action"]
+                ]
+                mkdirs = ""
+                if len(dirs) > 0:
+                    mkdirs = "mkdir -p %s; " % " ".join(dirs)
+                cd_action = "cd %s; " % Sourceify(self.path or ".")
+
+                # action, cd_action, and mkdirs get written to a toplevel variable
+                # called cmd_foo. Toplevel variables can't handle things that change
+                # per makefile like $(TARGET), so hardcode the target.
+                if self.flavor == "mac":
+                    action = [
+                        gyp.xcode_emulation.ExpandEnvVars(command, env)
+                        for command in action
+                    ]
+                action = gyp.common.EncodePOSIXShellList(action)
+                action = action.replace("$(TARGET)", self.target)
+                cd_action = cd_action.replace("$(TARGET)", self.target)
+                mkdirs = mkdirs.replace("$(TARGET)", self.target)
+
+                # Set LD_LIBRARY_PATH in case the rule runs an executable from this
+                # build which links to shared libs from this build.
+                # rules run on the host, so they should in theory only use host
+                # libraries, but until everything is made cross-compile safe, also use
+                # target libraries.
+                # TODO(piman): when everything is cross-compile safe, remove lib.target
+                self.WriteLn(
+                    "cmd_%(name)s_%(count)d = LD_LIBRARY_PATH="
+                    "$(builddir)/lib.host:$(builddir)/lib.target:$$LD_LIBRARY_PATH; "
+                    "export LD_LIBRARY_PATH; "
+                    "%(cd_action)s%(mkdirs)s%(action)s"
+                    % {
+                        "action": action,
+                        "cd_action": cd_action,
+                        "count": count,
+                        "mkdirs": mkdirs,
+                        "name": name,
+                    }
+                )
+                self.WriteLn(
+                    "quiet_cmd_%(name)s_%(count)d = RULE %(name)s_%(count)d $@"
+                    % {"count": count, "name": name}
+                )
+                self.WriteLn()
+                count += 1
+
+            outputs_variable = "rule_%s_outputs" % name
+            self.WriteList(all_outputs, outputs_variable)
+            extra_outputs.append("$(%s)" % outputs_variable)
+
+            self.WriteLn("### Finished generating for rule: %s" % name)
+            self.WriteLn()
+        self.WriteLn("### Finished generating for all rules")
+        self.WriteLn("")
+
+    def WriteCopies(self, copies, extra_outputs, part_of_all):
+        """Write Makefile code for any 'copies' from the gyp input.
 
     extra_outputs: a list that will be filled in with any outputs of this action
                    (used to make other pieces dependent on this action)
     part_of_all: flag indicating this target is part of 'all'
     """
-    self.WriteLn('### Generated for copy rule.')
-
-    variable = StringToMakefileVariable(self.qualified_target + '_copies')
-    outputs = []
-    for copy in copies:
-      for path in copy['files']:
-        # Absolutify() may call normpath, and will strip trailing slashes.
-        path = Sourceify(self.Absolutify(path))
-        filename = os.path.split(path)[1]
-        output = Sourceify(self.Absolutify(os.path.join(copy['destination'],
-                                                        filename)))
-
-        # If the output path has variables in it, which happens in practice for
-        # 'copies', writing the environment as target-local doesn't work,
-        # because the variables are already needed for the target name.
-        # Copying the environment variables into global make variables doesn't
-        # work either, because then the .d files will potentially contain spaces
-        # after variable expansion, and .d file handling cannot handle spaces.
-        # As a workaround, manually expand variables at gyp time. Since 'copies'
-        # can't run scripts, there's no need to write the env then.
-        # WriteDoCmd() will escape spaces for .d files.
-        env = self.GetSortedXcodeEnv()
-        output = gyp.xcode_emulation.ExpandEnvVars(output, env)
-        path = gyp.xcode_emulation.ExpandEnvVars(path, env)
-        self.WriteDoCmd([output], [path], 'copy', part_of_all)
-        outputs.append(output)
-    self.WriteLn('%s = %s' % (variable, ' '.join(QuoteSpaces(o) for o in outputs)))
-    extra_outputs.append('$(%s)' % variable)
-    self.WriteLn()
-
-
-  def WriteMacBundleResources(self, resources, bundle_deps):
-    """Writes Makefile code for 'mac_bundle_resources'."""
-    self.WriteLn('### Generated for mac_bundle_resources')
-
-    for output, res in gyp.xcode_emulation.GetMacBundleResources(
-        generator_default_variables['PRODUCT_DIR'], self.xcode_settings,
-        [Sourceify(self.Absolutify(r)) for r in resources]):
-      _, ext = os.path.splitext(output)
-      if ext != '.xcassets':
-        # Make does not supports '.xcassets' emulation.
-        self.WriteDoCmd([output], [res], 'mac_tool,,,copy-bundle-resource',
-                        part_of_all=True)
-        bundle_deps.append(output)
-
-
-  def WriteMacInfoPlist(self, bundle_deps):
-    """Write Makefile code for bundle Info.plist files."""
-    info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(
-        generator_default_variables['PRODUCT_DIR'], self.xcode_settings,
-        lambda p: Sourceify(self.Absolutify(p)))
-    if not info_plist:
-      return
-    if defines:
-      # Create an intermediate file to store preprocessed results.
-      intermediate_plist = ('$(obj).$(TOOLSET)/$(TARGET)/' +
-          os.path.basename(info_plist))
-      self.WriteList(defines, intermediate_plist + ': INFOPLIST_DEFINES', '-D',
-          quoter=EscapeCppDefine)
-      self.WriteMakeRule([intermediate_plist], [info_plist],
-          ['$(call do_cmd,infoplist)',
-           # "Convert" the plist so that any weird whitespace changes from the
-           # preprocessor do not affect the XML parser in mac_tool.
-           '@plutil -convert xml1 $@ $@'])
-      info_plist = intermediate_plist
-    # plists can contain envvars and substitute them into the file.
-    self.WriteSortedXcodeEnv(
-        out, self.GetSortedXcodeEnv(additional_settings=extra_env))
-    self.WriteDoCmd([out], [info_plist], 'mac_tool,,,copy-info-plist',
-                    part_of_all=True)
-    bundle_deps.append(out)
-
-
-  def WriteSources(self, configs, deps, sources,
-                   extra_outputs, extra_link_deps,
-                   part_of_all, precompiled_header):
-    """Write Makefile code for any 'sources' from the gyp input.
+        self.WriteLn("### Generated for copy rule.")
+
+        variable = StringToMakefileVariable(self.qualified_target + "_copies")
+        outputs = []
+        for copy in copies:
+            for path in copy["files"]:
+                # Absolutify() may call normpath, and will strip trailing slashes.
+                path = Sourceify(self.Absolutify(path))
+                filename = os.path.split(path)[1]
+                output = Sourceify(
+                    self.Absolutify(os.path.join(copy["destination"], filename))
+                )
+
+                # If the output path has variables in it, which happens in practice for
+                # 'copies', writing the environment as target-local doesn't work,
+                # because the variables are already needed for the target name.
+                # Copying the environment variables into global make variables doesn't
+                # work either, because then the .d files will potentially contain spaces
+                # after variable expansion, and .d file handling cannot handle spaces.
+                # As a workaround, manually expand variables at gyp time. Since 'copies'
+                # can't run scripts, there's no need to write the env then.
+                # WriteDoCmd() will escape spaces for .d files.
+                env = self.GetSortedXcodeEnv()
+                output = gyp.xcode_emulation.ExpandEnvVars(output, env)
+                path = gyp.xcode_emulation.ExpandEnvVars(path, env)
+                self.WriteDoCmd([output], [path], "copy", part_of_all)
+                outputs.append(output)
+        self.WriteLn("%s = %s" % (variable, " ".join(QuoteSpaces(o) for o in outputs)))
+        extra_outputs.append("$(%s)" % variable)
+        self.WriteLn()
+
+    def WriteMacBundleResources(self, resources, bundle_deps):
+        """Writes Makefile code for 'mac_bundle_resources'."""
+        self.WriteLn("### Generated for mac_bundle_resources")
+
+        for output, res in gyp.xcode_emulation.GetMacBundleResources(
+            generator_default_variables["PRODUCT_DIR"],
+            self.xcode_settings,
+            [Sourceify(self.Absolutify(r)) for r in resources],
+        ):
+            _, ext = os.path.splitext(output)
+            if ext != ".xcassets":
+                # Make does not supports '.xcassets' emulation.
+                self.WriteDoCmd(
+                    [output], [res], "mac_tool,,,copy-bundle-resource", part_of_all=True
+                )
+                bundle_deps.append(output)
+
+    def WriteMacInfoPlist(self, bundle_deps):
+        """Write Makefile code for bundle Info.plist files."""
+        info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(
+            generator_default_variables["PRODUCT_DIR"],
+            self.xcode_settings,
+            lambda p: Sourceify(self.Absolutify(p)),
+        )
+        if not info_plist:
+            return
+        if defines:
+            # Create an intermediate file to store preprocessed results.
+            intermediate_plist = "$(obj).$(TOOLSET)/$(TARGET)/" + os.path.basename(
+                info_plist
+            )
+            self.WriteList(
+                defines,
+                intermediate_plist + ": INFOPLIST_DEFINES",
+                "-D",
+                quoter=EscapeCppDefine,
+            )
+            self.WriteMakeRule(
+                [intermediate_plist],
+                [info_plist],
+                [
+                    "$(call do_cmd,infoplist)",
+                    # "Convert" the plist so that any weird whitespace changes from the
+                    # preprocessor do not affect the XML parser in mac_tool.
+                    "@plutil -convert xml1 $@ $@",
+                ],
+            )
+            info_plist = intermediate_plist
+        # plists can contain envvars and substitute them into the file.
+        self.WriteSortedXcodeEnv(
+            out, self.GetSortedXcodeEnv(additional_settings=extra_env)
+        )
+        self.WriteDoCmd(
+            [out], [info_plist], "mac_tool,,,copy-info-plist", part_of_all=True
+        )
+        bundle_deps.append(out)
+
+    def WriteSources(
+        self,
+        configs,
+        deps,
+        sources,
+        extra_outputs,
+        extra_link_deps,
+        part_of_all,
+        precompiled_header,
+    ):
+        """Write Makefile code for any 'sources' from the gyp input.
     These are source files necessary to build the current target.
 
     configs, deps, sources: input from gyp.
@@ -1208,256 +1288,288 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
     part_of_all: flag indicating this target is part of 'all'
     """
 
-    # Write configuration-specific variables for CFLAGS, etc.
-    for configname in sorted(configs.keys()):
-      config = configs[configname]
-      self.WriteList(config.get('defines'), 'DEFS_%s' % configname, prefix='-D',
-          quoter=EscapeCppDefine)
-
-      if self.flavor == 'mac':
-        cflags = self.xcode_settings.GetCflags(configname)
-        cflags_c = self.xcode_settings.GetCflagsC(configname)
-        cflags_cc = self.xcode_settings.GetCflagsCC(configname)
-        cflags_objc = self.xcode_settings.GetCflagsObjC(configname)
-        cflags_objcc = self.xcode_settings.GetCflagsObjCC(configname)
-      else:
-        cflags = config.get('cflags')
-        cflags_c = config.get('cflags_c')
-        cflags_cc = config.get('cflags_cc')
-
-      self.WriteLn("# Flags passed to all source files.")
-      self.WriteList(cflags, 'CFLAGS_%s' % configname)
-      self.WriteLn("# Flags passed to only C files.")
-      self.WriteList(cflags_c, 'CFLAGS_C_%s' % configname)
-      self.WriteLn("# Flags passed to only C++ files.")
-      self.WriteList(cflags_cc, 'CFLAGS_CC_%s' % configname)
-      if self.flavor == 'mac':
-        self.WriteLn("# Flags passed to only ObjC files.")
-        self.WriteList(cflags_objc, 'CFLAGS_OBJC_%s' % configname)
-        self.WriteLn("# Flags passed to only ObjC++ files.")
-        self.WriteList(cflags_objcc, 'CFLAGS_OBJCC_%s' % configname)
-      includes = config.get('include_dirs')
-      if includes:
-        includes = [Sourceify(self.Absolutify(i)) for i in includes]
-      self.WriteList(includes, 'INCS_%s' % configname, prefix='-I')
-
-    compilable = list(filter(Compilable, sources))
-    objs = [self.Objectify(self.Absolutify(Target(c))) for c in compilable]
-    self.WriteList(objs, 'OBJS')
-
-    for obj in objs:
-      assert ' ' not in obj, (
-          "Spaces in object filenames not supported (%s)"  % obj)
-    self.WriteLn('# Add to the list of files we specially track '
-                 'dependencies for.')
-    self.WriteLn('all_deps += $(OBJS)')
-    self.WriteLn()
-
-    # Make sure our dependencies are built first.
-    if deps:
-      self.WriteMakeRule(['$(OBJS)'], deps,
-                         comment = 'Make sure our dependencies are built '
-                                   'before any of us.',
-                         order_only = True)
-
-    # Make sure the actions and rules run first.
-    # If they generate any extra headers etc., the per-.o file dep tracking
-    # will catch the proper rebuilds, so order only is still ok here.
-    if extra_outputs:
-      self.WriteMakeRule(['$(OBJS)'], extra_outputs,
-                         comment = 'Make sure our actions/rules run '
-                                   'before any of us.',
-                         order_only = True)
-
-    pchdeps = precompiled_header.GetObjDependencies(compilable, objs )
-    if pchdeps:
-      self.WriteLn('# Dependencies from obj files to their precompiled headers')
-      for source, obj, gch in pchdeps:
-        self.WriteLn('%s: %s' % (obj, gch))
-      self.WriteLn('# End precompiled header dependencies')
-
-    if objs:
-      extra_link_deps.append('$(OBJS)')
-      self.WriteLn("""\
+        # Write configuration-specific variables for CFLAGS, etc.
+        for configname in sorted(configs.keys()):
+            config = configs[configname]
+            self.WriteList(
+                config.get("defines"),
+                "DEFS_%s" % configname,
+                prefix="-D",
+                quoter=EscapeCppDefine,
+            )
+
+            if self.flavor == "mac":
+                cflags = self.xcode_settings.GetCflags(
+                    configname,
+                    arch=config.get('xcode_configuration_platform')
+                )
+                cflags_c = self.xcode_settings.GetCflagsC(configname)
+                cflags_cc = self.xcode_settings.GetCflagsCC(configname)
+                cflags_objc = self.xcode_settings.GetCflagsObjC(configname)
+                cflags_objcc = self.xcode_settings.GetCflagsObjCC(configname)
+            else:
+                cflags = config.get("cflags")
+                cflags_c = config.get("cflags_c")
+                cflags_cc = config.get("cflags_cc")
+
+            self.WriteLn("# Flags passed to all source files.")
+            self.WriteList(cflags, "CFLAGS_%s" % configname)
+            self.WriteLn("# Flags passed to only C files.")
+            self.WriteList(cflags_c, "CFLAGS_C_%s" % configname)
+            self.WriteLn("# Flags passed to only C++ files.")
+            self.WriteList(cflags_cc, "CFLAGS_CC_%s" % configname)
+            if self.flavor == "mac":
+                self.WriteLn("# Flags passed to only ObjC files.")
+                self.WriteList(cflags_objc, "CFLAGS_OBJC_%s" % configname)
+                self.WriteLn("# Flags passed to only ObjC++ files.")
+                self.WriteList(cflags_objcc, "CFLAGS_OBJCC_%s" % configname)
+            includes = config.get("include_dirs")
+            if includes:
+                includes = [Sourceify(self.Absolutify(i)) for i in includes]
+            self.WriteList(includes, "INCS_%s" % configname, prefix="-I")
+
+        compilable = list(filter(Compilable, sources))
+        objs = [self.Objectify(self.Absolutify(Target(c))) for c in compilable]
+        self.WriteList(objs, "OBJS")
+
+        for obj in objs:
+            assert " " not in obj, "Spaces in object filenames not supported (%s)" % obj
+        self.WriteLn(
+            "# Add to the list of files we specially track " "dependencies for."
+        )
+        self.WriteLn("all_deps += $(OBJS)")
+        self.WriteLn()
+
+        # Make sure our dependencies are built first.
+        if deps:
+            self.WriteMakeRule(
+                ["$(OBJS)"],
+                deps,
+                comment="Make sure our dependencies are built " "before any of us.",
+                order_only=True,
+            )
+
+        # Make sure the actions and rules run first.
+        # If they generate any extra headers etc., the per-.o file dep tracking
+        # will catch the proper rebuilds, so order only is still ok here.
+        if extra_outputs:
+            self.WriteMakeRule(
+                ["$(OBJS)"],
+                extra_outputs,
+                comment="Make sure our actions/rules run " "before any of us.",
+                order_only=True,
+            )
+
+        pchdeps = precompiled_header.GetObjDependencies(compilable, objs)
+        if pchdeps:
+            self.WriteLn("# Dependencies from obj files to their precompiled headers")
+            for source, obj, gch in pchdeps:
+                self.WriteLn("%s: %s" % (obj, gch))
+            self.WriteLn("# End precompiled header dependencies")
+
+        if objs:
+            extra_link_deps.append("$(OBJS)")
+            self.WriteLn(
+                """\
 # CFLAGS et al overrides must be target-local.
-# See "Target-specific Variable Values" in the GNU Make manual.""")
-      self.WriteLn("$(OBJS): TOOLSET := $(TOOLSET)")
-      self.WriteLn("$(OBJS): GYP_CFLAGS := "
-                   "$(DEFS_$(BUILDTYPE)) "
-                   "$(INCS_$(BUILDTYPE)) "
-                   "%s " % precompiled_header.GetInclude('c') +
-                   "$(CFLAGS_$(BUILDTYPE)) "
-                   "$(CFLAGS_C_$(BUILDTYPE))")
-      self.WriteLn("$(OBJS): GYP_CXXFLAGS := "
-                   "$(DEFS_$(BUILDTYPE)) "
-                   "$(INCS_$(BUILDTYPE)) "
-                   "%s " % precompiled_header.GetInclude('cc') +
-                   "$(CFLAGS_$(BUILDTYPE)) "
-                   "$(CFLAGS_CC_$(BUILDTYPE))")
-      if self.flavor == 'mac':
-        self.WriteLn("$(OBJS): GYP_OBJCFLAGS := "
-                     "$(DEFS_$(BUILDTYPE)) "
-                     "$(INCS_$(BUILDTYPE)) "
-                     "%s " % precompiled_header.GetInclude('m') +
-                     "$(CFLAGS_$(BUILDTYPE)) "
-                     "$(CFLAGS_C_$(BUILDTYPE)) "
-                     "$(CFLAGS_OBJC_$(BUILDTYPE))")
-        self.WriteLn("$(OBJS): GYP_OBJCXXFLAGS := "
-                     "$(DEFS_$(BUILDTYPE)) "
-                     "$(INCS_$(BUILDTYPE)) "
-                     "%s " % precompiled_header.GetInclude('mm') +
-                     "$(CFLAGS_$(BUILDTYPE)) "
-                     "$(CFLAGS_CC_$(BUILDTYPE)) "
-                     "$(CFLAGS_OBJCC_$(BUILDTYPE))")
-
-    self.WritePchTargets(precompiled_header.GetPchBuildCommands())
-
-    # If there are any object files in our input file list, link them into our
-    # output.
-    extra_link_deps += list(filter(Linkable, sources))
-
-    self.WriteLn()
-
-  def WritePchTargets(self, pch_commands):
-    """Writes make rules to compile prefix headers."""
-    if not pch_commands:
-      return
-
-    for gch, lang_flag, lang, input in pch_commands:
-      extra_flags = {
-        'c': '$(CFLAGS_C_$(BUILDTYPE))',
-        'cc': '$(CFLAGS_CC_$(BUILDTYPE))',
-        'm': '$(CFLAGS_C_$(BUILDTYPE)) $(CFLAGS_OBJC_$(BUILDTYPE))',
-        'mm': '$(CFLAGS_CC_$(BUILDTYPE)) $(CFLAGS_OBJCC_$(BUILDTYPE))',
-      }[lang]
-      var_name = {
-        'c': 'GYP_PCH_CFLAGS',
-        'cc': 'GYP_PCH_CXXFLAGS',
-        'm': 'GYP_PCH_OBJCFLAGS',
-        'mm': 'GYP_PCH_OBJCXXFLAGS',
-      }[lang]
-      self.WriteLn("%s: %s := %s " % (gch, var_name, lang_flag) +
-                   "$(DEFS_$(BUILDTYPE)) "
-                   "$(INCS_$(BUILDTYPE)) "
-                   "$(CFLAGS_$(BUILDTYPE)) " +
-                   extra_flags)
-
-      self.WriteLn('%s: %s FORCE_DO_CMD' % (gch, input))
-      self.WriteLn('\t@$(call do_cmd,pch_%s,1)' % lang)
-      self.WriteLn('')
-      assert ' ' not in gch, (
-          "Spaces in gch filenames not supported (%s)"  % gch)
-      self.WriteLn('all_deps += %s' % gch)
-      self.WriteLn('')
-
-
-  def ComputeOutputBasename(self, spec):
-    """Return the 'output basename' of a gyp spec.
+# See "Target-specific Variable Values" in the GNU Make manual."""
+            )
+            self.WriteLn("$(OBJS): TOOLSET := $(TOOLSET)")
+            self.WriteLn(
+                "$(OBJS): GYP_CFLAGS := "
+                "$(DEFS_$(BUILDTYPE)) "
+                "$(INCS_$(BUILDTYPE)) "
+                "%s " % precompiled_header.GetInclude("c") + "$(CFLAGS_$(BUILDTYPE)) "
+                "$(CFLAGS_C_$(BUILDTYPE))"
+            )
+            self.WriteLn(
+                "$(OBJS): GYP_CXXFLAGS := "
+                "$(DEFS_$(BUILDTYPE)) "
+                "$(INCS_$(BUILDTYPE)) "
+                "%s " % precompiled_header.GetInclude("cc") + "$(CFLAGS_$(BUILDTYPE)) "
+                "$(CFLAGS_CC_$(BUILDTYPE))"
+            )
+            if self.flavor == "mac":
+                self.WriteLn(
+                    "$(OBJS): GYP_OBJCFLAGS := "
+                    "$(DEFS_$(BUILDTYPE)) "
+                    "$(INCS_$(BUILDTYPE)) "
+                    "%s " % precompiled_header.GetInclude("m")
+                    + "$(CFLAGS_$(BUILDTYPE)) "
+                    "$(CFLAGS_C_$(BUILDTYPE)) "
+                    "$(CFLAGS_OBJC_$(BUILDTYPE))"
+                )
+                self.WriteLn(
+                    "$(OBJS): GYP_OBJCXXFLAGS := "
+                    "$(DEFS_$(BUILDTYPE)) "
+                    "$(INCS_$(BUILDTYPE)) "
+                    "%s " % precompiled_header.GetInclude("mm")
+                    + "$(CFLAGS_$(BUILDTYPE)) "
+                    "$(CFLAGS_CC_$(BUILDTYPE)) "
+                    "$(CFLAGS_OBJCC_$(BUILDTYPE))"
+                )
+
+        self.WritePchTargets(precompiled_header.GetPchBuildCommands())
+
+        # If there are any object files in our input file list, link them into our
+        # output.
+        extra_link_deps += [source for source in sources if Linkable(source)]
+
+        self.WriteLn()
+
+    def WritePchTargets(self, pch_commands):
+        """Writes make rules to compile prefix headers."""
+        if not pch_commands:
+            return
+
+        for gch, lang_flag, lang, input in pch_commands:
+            extra_flags = {
+                "c": "$(CFLAGS_C_$(BUILDTYPE))",
+                "cc": "$(CFLAGS_CC_$(BUILDTYPE))",
+                "m": "$(CFLAGS_C_$(BUILDTYPE)) $(CFLAGS_OBJC_$(BUILDTYPE))",
+                "mm": "$(CFLAGS_CC_$(BUILDTYPE)) $(CFLAGS_OBJCC_$(BUILDTYPE))",
+            }[lang]
+            var_name = {
+                "c": "GYP_PCH_CFLAGS",
+                "cc": "GYP_PCH_CXXFLAGS",
+                "m": "GYP_PCH_OBJCFLAGS",
+                "mm": "GYP_PCH_OBJCXXFLAGS",
+            }[lang]
+            self.WriteLn(
+                "%s: %s := %s " % (gch, var_name, lang_flag) + "$(DEFS_$(BUILDTYPE)) "
+                "$(INCS_$(BUILDTYPE)) "
+                "$(CFLAGS_$(BUILDTYPE)) " + extra_flags
+            )
+
+            self.WriteLn("%s: %s FORCE_DO_CMD" % (gch, input))
+            self.WriteLn("\t@$(call do_cmd,pch_%s,1)" % lang)
+            self.WriteLn("")
+            assert " " not in gch, "Spaces in gch filenames not supported (%s)" % gch
+            self.WriteLn("all_deps += %s" % gch)
+            self.WriteLn("")
+
+    def ComputeOutputBasename(self, spec):
+        """Return the 'output basename' of a gyp spec.
 
     E.g., the loadable module 'foobar' in directory 'baz' will produce
       'libfoobar.so'
     """
-    assert not self.is_mac_bundle
-
-    if self.flavor == 'mac' and self.type in (
-        'static_library', 'executable', 'shared_library', 'loadable_module'):
-      return self.xcode_settings.GetExecutablePath()
-
-    target = spec['target_name']
-    target_prefix = ''
-    target_ext = ''
-    if self.type == 'static_library':
-      if target[:3] == 'lib':
-        target = target[3:]
-      target_prefix = 'lib'
-      target_ext = '.a'
-    elif self.type in ('loadable_module', 'shared_library'):
-      if target[:3] == 'lib':
-        target = target[3:]
-      target_prefix = 'lib'
-      if self.flavor == 'aix':
-        target_ext = '.a'
-      else:
-        target_ext = '.so'
-    elif self.type == 'none':
-      target = '%s.stamp' % target
-    elif self.type != 'executable':
-      print("ERROR: What output file should be generated?",
-            "type", self.type, "target", target)
-
-    target_prefix = spec.get('product_prefix', target_prefix)
-    target = spec.get('product_name', target)
-    product_ext = spec.get('product_extension')
-    if product_ext:
-      target_ext = '.' + product_ext
-
-    return target_prefix + target + target_ext
-
-
-  def _InstallImmediately(self):
-    return self.toolset == 'target' and self.flavor == 'mac' and self.type in (
-          'static_library', 'executable', 'shared_library', 'loadable_module')
-
-
-  def ComputeOutput(self, spec):
-    """Return the 'output' (full output path) of a gyp spec.
+        assert not self.is_mac_bundle
+
+        if self.flavor == "mac" and self.type in (
+            "static_library",
+            "executable",
+            "shared_library",
+            "loadable_module",
+        ):
+            return self.xcode_settings.GetExecutablePath()
+
+        target = spec["target_name"]
+        target_prefix = ""
+        target_ext = ""
+        if self.type == "static_library":
+            if target[:3] == "lib":
+                target = target[3:]
+            target_prefix = "lib"
+            target_ext = ".a"
+        elif self.type in ("loadable_module", "shared_library"):
+            if target[:3] == "lib":
+                target = target[3:]
+            target_prefix = "lib"
+            if self.flavor == "aix":
+                target_ext = ".a"
+            else:
+                target_ext = ".so"
+        elif self.type == "none":
+            target = "%s.stamp" % target
+        elif self.type != "executable":
+            print(
+                "ERROR: What output file should be generated?",
+                "type",
+                self.type,
+                "target",
+                target,
+            )
+
+        target_prefix = spec.get("product_prefix", target_prefix)
+        target = spec.get("product_name", target)
+        product_ext = spec.get("product_extension")
+        if product_ext:
+            target_ext = "." + product_ext
+
+        return target_prefix + target + target_ext
+
+    def _InstallImmediately(self):
+        return (
+            self.toolset == "target"
+            and self.flavor == "mac"
+            and self.type
+            in ("static_library", "executable", "shared_library", "loadable_module")
+        )
+
+    def ComputeOutput(self, spec):
+        """Return the 'output' (full output path) of a gyp spec.
 
     E.g., the loadable module 'foobar' in directory 'baz' will produce
       '$(obj)/baz/libfoobar.so'
     """
-    assert not self.is_mac_bundle
-
-    path = os.path.join('$(obj).' + self.toolset, self.path)
-    if self.type == 'executable' or self._InstallImmediately():
-      path = '$(builddir)'
-    path = spec.get('product_dir', path)
-    return os.path.join(path, self.ComputeOutputBasename(spec))
-
+        assert not self.is_mac_bundle
 
-  def ComputeMacBundleOutput(self, spec):
-    """Return the 'output' (full output path) to a bundle output directory."""
-    assert self.is_mac_bundle
-    path = generator_default_variables['PRODUCT_DIR']
-    return os.path.join(path, self.xcode_settings.GetWrapperName())
+        path = os.path.join("$(obj)." + self.toolset, self.path)
+        if self.type == "executable" or self._InstallImmediately():
+            path = "$(builddir)"
+        path = spec.get("product_dir", path)
+        return os.path.join(path, self.ComputeOutputBasename(spec))
 
+    def ComputeMacBundleOutput(self, spec):
+        """Return the 'output' (full output path) to a bundle output directory."""
+        assert self.is_mac_bundle
+        path = generator_default_variables["PRODUCT_DIR"]
+        return os.path.join(path, self.xcode_settings.GetWrapperName())
 
-  def ComputeMacBundleBinaryOutput(self, spec):
-    """Return the 'output' (full output path) to the binary in a bundle."""
-    path = generator_default_variables['PRODUCT_DIR']
-    return os.path.join(path, self.xcode_settings.GetExecutablePath())
+    def ComputeMacBundleBinaryOutput(self, spec):
+        """Return the 'output' (full output path) to the binary in a bundle."""
+        path = generator_default_variables["PRODUCT_DIR"]
+        return os.path.join(path, self.xcode_settings.GetExecutablePath())
 
-
-  def ComputeDeps(self, spec):
-    """Compute the dependencies of a gyp spec.
+    def ComputeDeps(self, spec):
+        """Compute the dependencies of a gyp spec.
 
     Returns a tuple (deps, link_deps), where each is a list of
     filenames that will need to be put in front of make for either
     building (deps) or linking (link_deps).
     """
-    deps = []
-    link_deps = []
-    if 'dependencies' in spec:
-      deps.extend([target_outputs[dep] for dep in spec['dependencies']
-                   if target_outputs[dep]])
-      for dep in spec['dependencies']:
-        if dep in target_link_deps:
-          link_deps.append(target_link_deps[dep])
-      deps.extend(link_deps)
-      # TODO: It seems we need to transitively link in libraries (e.g. -lfoo)?
-      # This hack makes it work:
-      # link_deps.extend(spec.get('libraries', []))
-    return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
-
-
-  def WriteDependencyOnExtraOutputs(self, target, extra_outputs):
-    self.WriteMakeRule([self.output_binary], extra_outputs,
-                       comment = 'Build our special outputs first.',
-                       order_only = True)
-
-
-  def WriteTarget(self, spec, configs, deps, link_deps, bundle_deps,
-                  extra_outputs, part_of_all):
-    """Write Makefile code to produce the final target of the gyp spec.
+        deps = []
+        link_deps = []
+        if "dependencies" in spec:
+            deps.extend(
+                [
+                    target_outputs[dep]
+                    for dep in spec["dependencies"]
+                    if target_outputs[dep]
+                ]
+            )
+            for dep in spec["dependencies"]:
+                if dep in target_link_deps:
+                    link_deps.append(target_link_deps[dep])
+            deps.extend(link_deps)
+            # TODO: It seems we need to transitively link in libraries (e.g. -lfoo)?
+            # This hack makes it work:
+            # link_deps.extend(spec.get('libraries', []))
+        return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
+
+    def WriteDependencyOnExtraOutputs(self, target, extra_outputs):
+        self.WriteMakeRule(
+            [self.output_binary],
+            extra_outputs,
+            comment="Build our special outputs first.",
+            order_only=True,
+        )
+
+    def WriteTarget(
+        self, spec, configs, deps, link_deps, bundle_deps, extra_outputs, part_of_all
+    ):
+        """Write Makefile code to produce the final target of the gyp spec.
 
     spec, configs: input from gyp.
     deps, link_deps: dependency lists; see ComputeDeps()
@@ -1465,274 +1577,375 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
     part_of_all: flag indicating this target is part of 'all'
     """
 
-    self.WriteLn('### Rules for final target.')
-
-    if extra_outputs:
-      self.WriteDependencyOnExtraOutputs(self.output_binary, extra_outputs)
-      self.WriteMakeRule(extra_outputs, deps,
-                         comment=('Preserve order dependency of '
-                                  'special output on deps.'),
-                         order_only = True)
-
-    target_postbuilds = {}
-    if self.type != 'none':
-      for configname in sorted(configs.keys()):
-        config = configs[configname]
-        if self.flavor == 'mac':
-          ldflags = self.xcode_settings.GetLdflags(configname,
-              generator_default_variables['PRODUCT_DIR'],
-              lambda p: Sourceify(self.Absolutify(p)))
-
-          # TARGET_POSTBUILDS_$(BUILDTYPE) is added to postbuilds later on.
-          gyp_to_build = gyp.common.InvertRelativePath(self.path)
-          target_postbuild = self.xcode_settings.AddImplicitPostbuilds(
-              configname,
-              QuoteSpaces(os.path.normpath(os.path.join(gyp_to_build,
-                                                        self.output))),
-              QuoteSpaces(os.path.normpath(os.path.join(gyp_to_build,
-                                                        self.output_binary))))
-          if target_postbuild:
-            target_postbuilds[configname] = target_postbuild
+        self.WriteLn("### Rules for final target.")
+
+        if extra_outputs:
+            self.WriteDependencyOnExtraOutputs(self.output_binary, extra_outputs)
+            self.WriteMakeRule(
+                extra_outputs,
+                deps,
+                comment=("Preserve order dependency of " "special output on deps."),
+                order_only=True,
+            )
+
+        target_postbuilds = {}
+        if self.type != "none":
+            for configname in sorted(configs.keys()):
+                config = configs[configname]
+                if self.flavor == "mac":
+                    ldflags = self.xcode_settings.GetLdflags(
+                        configname,
+                        generator_default_variables["PRODUCT_DIR"],
+                        lambda p: Sourceify(self.Absolutify(p)),
+                        arch=config.get('xcode_configuration_platform')
+                    )
+
+                    # TARGET_POSTBUILDS_$(BUILDTYPE) is added to postbuilds later on.
+                    gyp_to_build = gyp.common.InvertRelativePath(self.path)
+                    target_postbuild = self.xcode_settings.AddImplicitPostbuilds(
+                        configname,
+                        QuoteSpaces(
+                            os.path.normpath(os.path.join(gyp_to_build, self.output))
+                        ),
+                        QuoteSpaces(
+                            os.path.normpath(
+                                os.path.join(gyp_to_build, self.output_binary)
+                            )
+                        ),
+                    )
+                    if target_postbuild:
+                        target_postbuilds[configname] = target_postbuild
+                else:
+                    ldflags = config.get("ldflags", [])
+                    # Compute an rpath for this output if needed.
+                    if any(dep.endswith(".so") or ".so." in dep for dep in deps):
+                        # We want to get the literal string "$ORIGIN"
+                        # into the link command, so we need lots of escaping.
+                        ldflags.append(r"-Wl,-rpath=\$$ORIGIN/")
+                        ldflags.append(r"-Wl,-rpath-link=\$(builddir)/")
+                library_dirs = config.get("library_dirs", [])
+                ldflags += [("-L%s" % library_dir) for library_dir in library_dirs]
+                self.WriteList(ldflags, "LDFLAGS_%s" % configname)
+                if self.flavor == "mac":
+                    self.WriteList(
+                        self.xcode_settings.GetLibtoolflags(configname),
+                        "LIBTOOLFLAGS_%s" % configname,
+                    )
+            libraries = spec.get("libraries")
+            if libraries:
+                # Remove duplicate entries
+                libraries = gyp.common.uniquer(libraries)
+                if self.flavor == "mac":
+                    libraries = self.xcode_settings.AdjustLibraries(libraries)
+            self.WriteList(libraries, "LIBS")
+            self.WriteLn(
+                "%s: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))"
+                % QuoteSpaces(self.output_binary)
+            )
+            self.WriteLn("%s: LIBS := $(LIBS)" % QuoteSpaces(self.output_binary))
+
+            if self.flavor == "mac":
+                self.WriteLn(
+                    "%s: GYP_LIBTOOLFLAGS := $(LIBTOOLFLAGS_$(BUILDTYPE))"
+                    % QuoteSpaces(self.output_binary)
+                )
+
+        # Postbuild actions. Like actions, but implicitly depend on the target's
+        # output.
+        postbuilds = []
+        if self.flavor == "mac":
+            if target_postbuilds:
+                postbuilds.append("$(TARGET_POSTBUILDS_$(BUILDTYPE))")
+            postbuilds.extend(gyp.xcode_emulation.GetSpecPostbuildCommands(spec))
+
+        if postbuilds:
+            # Envvars may be referenced by TARGET_POSTBUILDS_$(BUILDTYPE),
+            # so we must output its definition first, since we declare variables
+            # using ":=".
+            self.WriteSortedXcodeEnv(self.output, self.GetSortedXcodePostbuildEnv())
+
+            for configname in target_postbuilds:
+                self.WriteLn(
+                    "%s: TARGET_POSTBUILDS_%s := %s"
+                    % (
+                        QuoteSpaces(self.output),
+                        configname,
+                        gyp.common.EncodePOSIXShellList(target_postbuilds[configname]),
+                    )
+                )
+
+            # Postbuilds expect to be run in the gyp file's directory, so insert an
+            # implicit postbuild to cd to there.
+            postbuilds.insert(0, gyp.common.EncodePOSIXShellList(["cd", self.path]))
+            for i, postbuild in enumerate(postbuilds):
+                if not postbuild.startswith("$"):
+                    postbuilds[i] = EscapeShellArgument(postbuild)
+            self.WriteLn("%s: builddir := $(abs_builddir)" % QuoteSpaces(self.output))
+            self.WriteLn(
+                "%s: POSTBUILDS := %s"
+                % (QuoteSpaces(self.output), " ".join(postbuilds))
+            )
+
+        # A bundle directory depends on its dependencies such as bundle resources
+        # and bundle binary. When all dependencies have been built, the bundle
+        # needs to be packaged.
+        if self.is_mac_bundle:
+            # If the framework doesn't contain a binary, then nothing depends
+            # on the actions -- make the framework depend on them directly too.
+            self.WriteDependencyOnExtraOutputs(self.output, extra_outputs)
+
+            # Bundle dependencies. Note that the code below adds actions to this
+            # target, so if you move these two lines, move the lines below as well.
+            self.WriteList([QuoteSpaces(dep) for dep in bundle_deps], "BUNDLE_DEPS")
+            self.WriteLn("%s: $(BUNDLE_DEPS)" % QuoteSpaces(self.output))
+
+            # After the framework is built, package it. Needs to happen before
+            # postbuilds, since postbuilds depend on this.
+            if self.type in ("shared_library", "loadable_module"):
+                self.WriteLn(
+                    "\t@$(call do_cmd,mac_package_framework,,,%s)"
+                    % self.xcode_settings.GetFrameworkVersion()
+                )
+
+            # Bundle postbuilds can depend on the whole bundle, so run them after
+            # the bundle is packaged, not already after the bundle binary is done.
+            if postbuilds:
+                self.WriteLn("\t@$(call do_postbuilds)")
+            postbuilds = []  # Don't write postbuilds for target's output.
+
+            # Needed by test/mac/gyptest-rebuild.py.
+            self.WriteLn("\t@true  # No-op, used by tests")
+
+            # Since this target depends on binary and resources which are in
+            # nested subfolders, the framework directory will be older than
+            # its dependencies usually. To prevent this rule from executing
+            # on every build (expensive, especially with postbuilds), expliclity
+            # update the time on the framework directory.
+            self.WriteLn("\t@touch -c %s" % QuoteSpaces(self.output))
+
+        if postbuilds:
+            assert not self.is_mac_bundle, (
+                "Postbuilds for bundles should be done "
+                "on the bundle, not the binary (target '%s')" % self.target
+            )
+            assert "product_dir" not in spec, (
+                "Postbuilds do not work with " "custom product_dir"
+            )
+
+        if self.type == "executable":
+            self.WriteLn(
+                "%s: LD_INPUTS := %s"
+                % (
+                    QuoteSpaces(self.output_binary),
+                    " ".join(QuoteSpaces(dep) for dep in link_deps),
+                )
+            )
+            if self.toolset == "host" and self.flavor == "android":
+                self.WriteDoCmd(
+                    [self.output_binary],
+                    link_deps,
+                    "link_host",
+                    part_of_all,
+                    postbuilds=postbuilds,
+                )
+            else:
+                self.WriteDoCmd(
+                    [self.output_binary],
+                    link_deps,
+                    "link",
+                    part_of_all,
+                    postbuilds=postbuilds,
+                )
+
+        elif self.type == "static_library":
+            for link_dep in link_deps:
+                assert " " not in link_dep, (
+                    "Spaces in alink input filenames not supported (%s)" % link_dep
+                )
+            if (
+                self.flavor not in ("mac", "openbsd", "netbsd", "win")
+                and not self.is_standalone_static_library
+            ):
+                self.WriteDoCmd(
+                    [self.output_binary],
+                    link_deps,
+                    "alink_thin",
+                    part_of_all,
+                    postbuilds=postbuilds,
+                )
+            else:
+                self.WriteDoCmd(
+                    [self.output_binary],
+                    link_deps,
+                    "alink",
+                    part_of_all,
+                    postbuilds=postbuilds,
+                )
+        elif self.type == "shared_library":
+            self.WriteLn(
+                "%s: LD_INPUTS := %s"
+                % (
+                    QuoteSpaces(self.output_binary),
+                    " ".join(QuoteSpaces(dep) for dep in link_deps),
+                )
+            )
+            self.WriteDoCmd(
+                [self.output_binary],
+                link_deps,
+                "solink",
+                part_of_all,
+                postbuilds=postbuilds,
+            )
+        elif self.type == "loadable_module":
+            for link_dep in link_deps:
+                assert " " not in link_dep, (
+                    "Spaces in module input filenames not supported (%s)" % link_dep
+                )
+            if self.toolset == "host" and self.flavor == "android":
+                self.WriteDoCmd(
+                    [self.output_binary],
+                    link_deps,
+                    "solink_module_host",
+                    part_of_all,
+                    postbuilds=postbuilds,
+                )
+            else:
+                self.WriteDoCmd(
+                    [self.output_binary],
+                    link_deps,
+                    "solink_module",
+                    part_of_all,
+                    postbuilds=postbuilds,
+                )
+        elif self.type == "none":
+            # Write a stamp line.
+            self.WriteDoCmd(
+                [self.output_binary], deps, "touch", part_of_all, postbuilds=postbuilds
+            )
         else:
-          ldflags = config.get('ldflags', [])
-          # Compute an rpath for this output if needed.
-          if any(dep.endswith('.so') or '.so.' in dep for dep in deps):
-            # We want to get the literal string "$ORIGIN" into the link command,
-            # so we need lots of escaping.
-            ldflags.append(r'-Wl,-rpath=\$$ORIGIN/lib.%s/' % self.toolset)
-            ldflags.append(r'-Wl,-rpath-link=\$(builddir)/lib.%s/' %
-                           self.toolset)
-        library_dirs = config.get('library_dirs', [])
-        ldflags += [('-L%s' % library_dir) for library_dir in library_dirs]
-        self.WriteList(ldflags, 'LDFLAGS_%s' % configname)
-        if self.flavor == 'mac':
-          self.WriteList(self.xcode_settings.GetLibtoolflags(configname),
-                         'LIBTOOLFLAGS_%s' % configname)
-      libraries = spec.get('libraries')
-      if libraries:
-        # Remove duplicate entries
-        libraries = gyp.common.uniquer(libraries)
-        if self.flavor == 'mac':
-          libraries = self.xcode_settings.AdjustLibraries(libraries)
-      self.WriteList(libraries, 'LIBS')
-      self.WriteLn('%s: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))' %
-          QuoteSpaces(self.output_binary))
-      self.WriteLn('%s: LIBS := $(LIBS)' % QuoteSpaces(self.output_binary))
-
-      if self.flavor == 'mac':
-        self.WriteLn('%s: GYP_LIBTOOLFLAGS := $(LIBTOOLFLAGS_$(BUILDTYPE))' %
-            QuoteSpaces(self.output_binary))
-
-    # Postbuild actions. Like actions, but implicitly depend on the target's
-    # output.
-    postbuilds = []
-    if self.flavor == 'mac':
-      if target_postbuilds:
-        postbuilds.append('$(TARGET_POSTBUILDS_$(BUILDTYPE))')
-      postbuilds.extend(
-          gyp.xcode_emulation.GetSpecPostbuildCommands(spec))
-
-    if postbuilds:
-      # Envvars may be referenced by TARGET_POSTBUILDS_$(BUILDTYPE),
-      # so we must output its definition first, since we declare variables
-      # using ":=".
-      self.WriteSortedXcodeEnv(self.output, self.GetSortedXcodePostbuildEnv())
-
-      for configname in target_postbuilds:
-        self.WriteLn('%s: TARGET_POSTBUILDS_%s := %s' %
-            (QuoteSpaces(self.output),
-             configname,
-             gyp.common.EncodePOSIXShellList(target_postbuilds[configname])))
-
-      # Postbuilds expect to be run in the gyp file's directory, so insert an
-      # implicit postbuild to cd to there.
-      postbuilds.insert(0, gyp.common.EncodePOSIXShellList(['cd', self.path]))
-      for i in range(len(postbuilds)):
-        if not postbuilds[i].startswith('$'):
-          postbuilds[i] = EscapeShellArgument(postbuilds[i])
-      self.WriteLn('%s: builddir := $(abs_builddir)' % QuoteSpaces(self.output))
-      self.WriteLn('%s: POSTBUILDS := %s' % (
-          QuoteSpaces(self.output), ' '.join(postbuilds)))
-
-    # A bundle directory depends on its dependencies such as bundle resources
-    # and bundle binary. When all dependencies have been built, the bundle
-    # needs to be packaged.
-    if self.is_mac_bundle:
-      # If the framework doesn't contain a binary, then nothing depends
-      # on the actions -- make the framework depend on them directly too.
-      self.WriteDependencyOnExtraOutputs(self.output, extra_outputs)
-
-      # Bundle dependencies. Note that the code below adds actions to this
-      # target, so if you move these two lines, move the lines below as well.
-      self.WriteList([QuoteSpaces(dep) for dep in bundle_deps], 'BUNDLE_DEPS')
-      self.WriteLn('%s: $(BUNDLE_DEPS)' % QuoteSpaces(self.output))
-
-      # After the framework is built, package it. Needs to happen before
-      # postbuilds, since postbuilds depend on this.
-      if self.type in ('shared_library', 'loadable_module'):
-        self.WriteLn('\t@$(call do_cmd,mac_package_framework,,,%s)' %
-            self.xcode_settings.GetFrameworkVersion())
-
-      # Bundle postbuilds can depend on the whole bundle, so run them after
-      # the bundle is packaged, not already after the bundle binary is done.
-      if postbuilds:
-        self.WriteLn('\t@$(call do_postbuilds)')
-      postbuilds = []  # Don't write postbuilds for target's output.
-
-      # Needed by test/mac/gyptest-rebuild.py.
-      self.WriteLn('\t@true  # No-op, used by tests')
-
-      # Since this target depends on binary and resources which are in
-      # nested subfolders, the framework directory will be older than
-      # its dependencies usually. To prevent this rule from executing
-      # on every build (expensive, especially with postbuilds), expliclity
-      # update the time on the framework directory.
-      self.WriteLn('\t@touch -c %s' % QuoteSpaces(self.output))
-
-    if postbuilds:
-      assert not self.is_mac_bundle, ('Postbuilds for bundles should be done '
-          'on the bundle, not the binary (target \'%s\')' % self.target)
-      assert 'product_dir' not in spec, ('Postbuilds do not work with '
-          'custom product_dir')
-
-    if self.type == 'executable':
-      self.WriteLn('%s: LD_INPUTS := %s' % (
-          QuoteSpaces(self.output_binary),
-          ' '.join(QuoteSpaces(dep) for dep in link_deps)))
-      if self.toolset == 'host' and self.flavor == 'android':
-        self.WriteDoCmd([self.output_binary], link_deps, 'link_host',
-                        part_of_all, postbuilds=postbuilds)
-      else:
-        self.WriteDoCmd([self.output_binary], link_deps, 'link', part_of_all,
-                        postbuilds=postbuilds)
-
-    elif self.type == 'static_library':
-      for link_dep in link_deps:
-        assert ' ' not in link_dep, (
-            "Spaces in alink input filenames not supported (%s)"  % link_dep)
-      if (self.flavor not in ('mac', 'openbsd', 'netbsd', 'win') and not
-          self.is_standalone_static_library):
-        self.WriteDoCmd([self.output_binary], link_deps, 'alink_thin',
-                        part_of_all, postbuilds=postbuilds)
-      else:
-        self.WriteDoCmd([self.output_binary], link_deps, 'alink', part_of_all,
-                        postbuilds=postbuilds)
-    elif self.type == 'shared_library':
-      self.WriteLn('%s: LD_INPUTS := %s' % (
-            QuoteSpaces(self.output_binary),
-            ' '.join(QuoteSpaces(dep) for dep in link_deps)))
-      self.WriteDoCmd([self.output_binary], link_deps, 'solink', part_of_all,
-                      postbuilds=postbuilds)
-    elif self.type == 'loadable_module':
-      for link_dep in link_deps:
-        assert ' ' not in link_dep, (
-            "Spaces in module input filenames not supported (%s)"  % link_dep)
-      if self.toolset == 'host' and self.flavor == 'android':
-        self.WriteDoCmd([self.output_binary], link_deps, 'solink_module_host',
-                        part_of_all, postbuilds=postbuilds)
-      else:
-        self.WriteDoCmd(
-            [self.output_binary], link_deps, 'solink_module', part_of_all,
-            postbuilds=postbuilds)
-    elif self.type == 'none':
-      # Write a stamp line.
-      self.WriteDoCmd([self.output_binary], deps, 'touch', part_of_all,
-                      postbuilds=postbuilds)
-    else:
-      print("WARNING: no output for", self.type, self.target)
-
-    # Add an alias for each target (if there are any outputs).
-    # Installable target aliases are created below.
-    if ((self.output and self.output != self.target) and
-        (self.type not in self._INSTALLABLE_TARGETS)):
-      self.WriteMakeRule([self.target], [self.output],
-                         comment='Add target alias', phony = True)
-      if part_of_all:
-        self.WriteMakeRule(['all'], [self.target],
-                           comment = 'Add target alias to "all" target.',
-                           phony = True)
-
-    # Add special-case rules for our installable targets.
-    # 1) They need to install to the build dir or "product" dir.
-    # 2) They get shortcuts for building (e.g. "make chrome").
-    # 3) They are part of "make all".
-    if (self.type in self._INSTALLABLE_TARGETS or
-        self.is_standalone_static_library):
-      if self.type == 'shared_library':
-        file_desc = 'shared library'
-      elif self.type == 'static_library':
-        file_desc = 'static library'
-      else:
-        file_desc = 'executable'
-      install_path = self._InstallableTargetInstallPath()
-      installable_deps = [self.output]
-      if (self.flavor == 'mac' and not 'product_dir' in spec and
-          self.toolset == 'target'):
-        # On mac, products are created in install_path immediately.
-        assert install_path == self.output, '%s != %s' % (
-            install_path, self.output)
-
-      # Point the target alias to the final binary output.
-      self.WriteMakeRule([self.target], [install_path],
-                         comment='Add target alias', phony = True)
-      if install_path != self.output:
-        assert not self.is_mac_bundle  # See comment a few lines above.
-        self.WriteDoCmd([install_path], [self.output], 'copy',
-                        comment = 'Copy this to the %s output path.' %
-                        file_desc, part_of_all=part_of_all)
-        installable_deps.append(install_path)
-      if self.output != self.alias and self.alias != self.target:
-        self.WriteMakeRule([self.alias], installable_deps,
-                           comment = 'Short alias for building this %s.' %
-                           file_desc, phony = True)
-      if part_of_all:
-        self.WriteMakeRule(['all'], [install_path],
-                           comment = 'Add %s to "all" target.' % file_desc,
-                           phony = True)
-
-
-  def WriteList(self, value_list, variable=None, prefix='',
-                quoter=QuoteIfNecessary):
-    """Write a variable definition that is a list of values.
+            print("WARNING: no output for", self.type, self.target)
+
+        # Add an alias for each target (if there are any outputs).
+        # Installable target aliases are created below.
+        if (self.output and self.output != self.target) and (
+            self.type not in self._INSTALLABLE_TARGETS
+        ):
+            self.WriteMakeRule(
+                [self.target], [self.output], comment="Add target alias", phony=True
+            )
+            if part_of_all:
+                self.WriteMakeRule(
+                    ["all"],
+                    [self.target],
+                    comment='Add target alias to "all" target.',
+                    phony=True,
+                )
+
+        # Add special-case rules for our installable targets.
+        # 1) They need to install to the build dir or "product" dir.
+        # 2) They get shortcuts for building (e.g. "make chrome").
+        # 3) They are part of "make all".
+        if self.type in self._INSTALLABLE_TARGETS or self.is_standalone_static_library:
+            if self.type == "shared_library":
+                file_desc = "shared library"
+            elif self.type == "static_library":
+                file_desc = "static library"
+            else:
+                file_desc = "executable"
+            install_path = self._InstallableTargetInstallPath()
+            installable_deps = [self.output]
+            if (
+                self.flavor == "mac"
+                and "product_dir" not in spec
+                and self.toolset == "target"
+            ):
+                # On mac, products are created in install_path immediately.
+                assert install_path == self.output, "%s != %s" % (
+                    install_path,
+                    self.output,
+                )
+
+            # Point the target alias to the final binary output.
+            self.WriteMakeRule(
+                [self.target], [install_path], comment="Add target alias", phony=True
+            )
+            if install_path != self.output:
+                assert not self.is_mac_bundle  # See comment a few lines above.
+                self.WriteDoCmd(
+                    [install_path],
+                    [self.output],
+                    "copy",
+                    comment="Copy this to the %s output path." % file_desc,
+                    part_of_all=part_of_all,
+                )
+                installable_deps.append(install_path)
+            if self.output != self.alias and self.alias != self.target:
+                self.WriteMakeRule(
+                    [self.alias],
+                    installable_deps,
+                    comment="Short alias for building this %s." % file_desc,
+                    phony=True,
+                )
+            if part_of_all:
+                self.WriteMakeRule(
+                    ["all"],
+                    [install_path],
+                    comment='Add %s to "all" target.' % file_desc,
+                    phony=True,
+                )
+
+    def WriteList(self, value_list, variable=None, prefix="", quoter=QuoteIfNecessary):
+        """Write a variable definition that is a list of values.
 
     E.g. WriteList(['a','b'], 'foo', prefix='blah') writes out
          foo = blaha blahb
     but in a pretty-printed style.
     """
-    values = ''
-    if value_list:
-      value_list = [quoter(prefix + l) for l in value_list]
-      values = ' \\\n\t' + ' \\\n\t'.join(value_list)
-    self.fp.write('%s :=%s\n\n' % (variable, values))
-
+        values = ""
+        if value_list:
+            value_list = [quoter(prefix + value) for value in value_list]
+            values = " \\\n\t" + " \\\n\t".join(value_list)
+        self.fp.write("%s :=%s\n\n" % (variable, values))
 
-  def WriteDoCmd(self, outputs, inputs, command, part_of_all, comment=None,
-                 postbuilds=False):
-    """Write a Makefile rule that uses do_cmd.
+    def WriteDoCmd(
+        self, outputs, inputs, command, part_of_all, comment=None, postbuilds=False
+    ):
+        """Write a Makefile rule that uses do_cmd.
 
     This makes the outputs dependent on the command line that was run,
     as well as support the V= make command line flag.
     """
-    suffix = ''
-    if postbuilds:
-      assert ',' not in command
-      suffix = ',,1'  # Tell do_cmd to honor $POSTBUILDS
-    self.WriteMakeRule(outputs, inputs,
-                       actions = ['$(call do_cmd,%s%s)' % (command, suffix)],
-                       comment = comment,
-                       command = command,
-                       force = True)
-    # Add our outputs to the list of targets we read depfiles from.
-    # all_deps is only used for deps file reading, and for deps files we replace
-    # spaces with ? because escaping doesn't work with make's $(sort) and
-    # other functions.
-    outputs = [QuoteSpaces(o, SPACE_REPLACEMENT) for o in outputs]
-    self.WriteLn('all_deps += %s' % ' '.join(outputs))
-
-
-  def WriteMakeRule(self, outputs, inputs, actions=None, comment=None,
-                    order_only=False, force=False, phony=False, command=None):
-    """Write a Makefile rule, with some extra tricks.
+        suffix = ""
+        if postbuilds:
+            assert "," not in command
+            suffix = ",,1"  # Tell do_cmd to honor $POSTBUILDS
+        self.WriteMakeRule(
+            outputs,
+            inputs,
+            actions=["$(call do_cmd,%s%s)" % (command, suffix)],
+            comment=comment,
+            command=command,
+            force=True,
+        )
+        # Add our outputs to the list of targets we read depfiles from.
+        # all_deps is only used for deps file reading, and for deps files we replace
+        # spaces with ? because escaping doesn't work with make's $(sort) and
+        # other functions.
+        outputs = [QuoteSpaces(o, SPACE_REPLACEMENT) for o in outputs]
+        self.WriteLn("all_deps += %s" % " ".join(outputs))
+
+    def WriteMakeRule(
+        self,
+        outputs,
+        inputs,
+        actions=None,
+        comment=None,
+        order_only=False,
+        force=False,
+        phony=False,
+        command=None,
+    ):
+        """Write a Makefile rule, with some extra tricks.
 
     outputs: a list of outputs for the rule (note: this is not directly
              supported by make; see comments below)
@@ -1746,53 +1959,54 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
            output is just a name to run the rule
     command: (optional) command name to generate unambiguous labels
     """
-    outputs = [QuoteSpaces(o) for o in outputs]
-    inputs = [QuoteSpaces(i) for i in inputs]
-
-    if comment:
-      self.WriteLn('# ' + comment)
-    if phony:
-      self.WriteLn('.PHONY: ' + ' '.join(outputs))
-    if actions:
-      self.WriteLn("%s: TOOLSET := $(TOOLSET)" % outputs[0])
-    force_append = ' FORCE_DO_CMD' if force else ''
-
-    if order_only:
-      # Order only rule: Just write a simple rule.
-      # TODO(evanm): just make order_only a list of deps instead of this hack.
-      self.WriteLn('%s: | %s%s' %
-                   (' '.join(outputs), ' '.join(inputs), force_append))
-    elif len(outputs) == 1:
-      # Regular rule, one output: Just write a simple rule.
-      self.WriteLn('%s: %s%s' % (outputs[0], ' '.join(inputs), force_append))
-    else:
-      # Regular rule, more than one output: Multiple outputs are tricky in
-      # make. We will write three rules:
-      # - All outputs depend on an intermediate file.
-      # - Make .INTERMEDIATE depend on the intermediate.
-      # - The intermediate file depends on the inputs and executes the
-      #   actual command.
-      # - The intermediate recipe will 'touch' the intermediate file.
-      # - The multi-output rule will have an do-nothing recipe.
-
-      # Hash the target name to avoid generating overlong filenames.
-      cmddigest = hashlib.sha1((command or self.target).encode('utf-8')).hexdigest()
-      intermediate = "%s.intermediate" % cmddigest
-      self.WriteLn('%s: %s' % (' '.join(outputs), intermediate))
-      self.WriteLn('\t%s' % '@:')
-      self.WriteLn('%s: %s' % ('.INTERMEDIATE', intermediate))
-      self.WriteLn('%s: %s%s' %
-                   (intermediate, ' '.join(inputs), force_append))
-      actions.insert(0, '$(call do_cmd,touch)')
-
-    if actions:
-      for action in actions:
-        self.WriteLn('\t%s' % action)
-    self.WriteLn()
-
-
-  def WriteAndroidNdkModuleRule(self, module_name, all_sources, link_deps):
-    """Write a set of LOCAL_XXX definitions for Android NDK.
+        outputs = [QuoteSpaces(o) for o in outputs]
+        inputs = [QuoteSpaces(i) for i in inputs]
+
+        if comment:
+            self.WriteLn("# " + comment)
+        if phony:
+            self.WriteLn(".PHONY: " + " ".join(outputs))
+        if actions:
+            self.WriteLn("%s: TOOLSET := $(TOOLSET)" % outputs[0])
+        force_append = " FORCE_DO_CMD" if force else ""
+
+        if order_only:
+            # Order only rule: Just write a simple rule.
+            # TODO(evanm): just make order_only a list of deps instead of this hack.
+            self.WriteLn(
+                "%s: | %s%s" % (" ".join(outputs), " ".join(inputs), force_append)
+            )
+        elif len(outputs) == 1:
+            # Regular rule, one output: Just write a simple rule.
+            self.WriteLn("%s: %s%s" % (outputs[0], " ".join(inputs), force_append))
+        else:
+            # Regular rule, more than one output: Multiple outputs are tricky in
+            # make. We will write three rules:
+            # - All outputs depend on an intermediate file.
+            # - Make .INTERMEDIATE depend on the intermediate.
+            # - The intermediate file depends on the inputs and executes the
+            #   actual command.
+            # - The intermediate recipe will 'touch' the intermediate file.
+            # - The multi-output rule will have an do-nothing recipe.
+
+            # Hash the target name to avoid generating overlong filenames.
+            cmddigest = hashlib.sha1(
+                (command or self.target).encode("utf-8")
+            ).hexdigest()
+            intermediate = "%s.intermediate" % cmddigest
+            self.WriteLn("%s: %s" % (" ".join(outputs), intermediate))
+            self.WriteLn("\t%s" % "@:")
+            self.WriteLn("%s: %s" % (".INTERMEDIATE", intermediate))
+            self.WriteLn("%s: %s%s" % (intermediate, " ".join(inputs), force_append))
+            actions.insert(0, "$(call do_cmd,touch)")
+
+        if actions:
+            for action in actions:
+                self.WriteLn("\t%s" % action)
+        self.WriteLn()
+
+    def WriteAndroidNdkModuleRule(self, module_name, all_sources, link_deps):
+        """Write a set of LOCAL_XXX definitions for Android NDK.
 
     These variable definitions will be used by Android NDK but do nothing for
     non-Android applications.
@@ -1804,460 +2018,497 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
       link_deps: A list of link dependencies, which must be sorted in
           the order from dependencies to dependents.
     """
-    if self.type not in ('executable', 'shared_library', 'static_library'):
-      return
-
-    self.WriteLn('# Variable definitions for Android applications')
-    self.WriteLn('include $(CLEAR_VARS)')
-    self.WriteLn('LOCAL_MODULE := ' + module_name)
-    self.WriteLn('LOCAL_CFLAGS := $(CFLAGS_$(BUILDTYPE)) '
-                 '$(DEFS_$(BUILDTYPE)) '
-                 # LOCAL_CFLAGS is applied to both of C and C++.  There is
-                 # no way to specify $(CFLAGS_C_$(BUILDTYPE)) only for C
-                 # sources.
-                 '$(CFLAGS_C_$(BUILDTYPE)) '
-                 # $(INCS_$(BUILDTYPE)) includes the prefix '-I' while
-                 # LOCAL_C_INCLUDES does not expect it.  So put it in
-                 # LOCAL_CFLAGS.
-                 '$(INCS_$(BUILDTYPE))')
-    # LOCAL_CXXFLAGS is obsolete and LOCAL_CPPFLAGS is preferred.
-    self.WriteLn('LOCAL_CPPFLAGS := $(CFLAGS_CC_$(BUILDTYPE))')
-    self.WriteLn('LOCAL_C_INCLUDES :=')
-    self.WriteLn('LOCAL_LDLIBS := $(LDFLAGS_$(BUILDTYPE)) $(LIBS)')
-
-    # Detect the C++ extension.
-    cpp_ext = {'.cc': 0, '.cpp': 0, '.cxx': 0}
-    default_cpp_ext = '.cpp'
-    for filename in all_sources:
-      ext = os.path.splitext(filename)[1]
-      if ext in cpp_ext:
-        cpp_ext[ext] += 1
-        if cpp_ext[ext] > cpp_ext[default_cpp_ext]:
-          default_cpp_ext = ext
-    self.WriteLn('LOCAL_CPP_EXTENSION := ' + default_cpp_ext)
-
-    self.WriteList(list(map(self.Absolutify, filter(Compilable, all_sources))),
-                   'LOCAL_SRC_FILES')
-
-    # Filter out those which do not match prefix and suffix and produce
-    # the resulting list without prefix and suffix.
-    def DepsToModules(deps, prefix, suffix):
-      modules = []
-      for filepath in deps:
-        filename = os.path.basename(filepath)
-        if filename.startswith(prefix) and filename.endswith(suffix):
-          modules.append(filename[len(prefix):-len(suffix)])
-      return modules
-
-    # Retrieve the default value of 'SHARED_LIB_SUFFIX'
-    params = {'flavor': 'linux'}
-    default_variables = {}
-    CalculateVariables(default_variables, params)
-
-    self.WriteList(
-        DepsToModules(link_deps,
-                      generator_default_variables['SHARED_LIB_PREFIX'],
-                      default_variables['SHARED_LIB_SUFFIX']),
-        'LOCAL_SHARED_LIBRARIES')
-    self.WriteList(
-        DepsToModules(link_deps,
-                      generator_default_variables['STATIC_LIB_PREFIX'],
-                      generator_default_variables['STATIC_LIB_SUFFIX']),
-        'LOCAL_STATIC_LIBRARIES')
-
-    if self.type == 'executable':
-      self.WriteLn('include $(BUILD_EXECUTABLE)')
-    elif self.type == 'shared_library':
-      self.WriteLn('include $(BUILD_SHARED_LIBRARY)')
-    elif self.type == 'static_library':
-      self.WriteLn('include $(BUILD_STATIC_LIBRARY)')
-    self.WriteLn()
-
-
-  def WriteLn(self, text=''):
-    self.fp.write(text + '\n')
-
-
-  def GetSortedXcodeEnv(self, additional_settings=None):
-    return gyp.xcode_emulation.GetSortedXcodeEnv(
-        self.xcode_settings, "$(abs_builddir)",
-        os.path.join("$(abs_srcdir)", self.path), "$(BUILDTYPE)",
-        additional_settings)
-
-
-  def GetSortedXcodePostbuildEnv(self):
-    # CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.
-    # TODO(thakis): It would be nice to have some general mechanism instead.
-    strip_save_file = self.xcode_settings.GetPerTargetSetting(
-        'CHROMIUM_STRIP_SAVE_FILE', '')
-    # Even if strip_save_file is empty, explicitly write it. Else a postbuild
-    # might pick up an export from an earlier target.
-    return self.GetSortedXcodeEnv(
-        additional_settings={'CHROMIUM_STRIP_SAVE_FILE': strip_save_file})
-
-
-  def WriteSortedXcodeEnv(self, target, env):
-    for k, v in env:
-      # For
-      #  foo := a\ b
-      # the escaped space does the right thing. For
-      #  export foo := a\ b
-      # it does not -- the backslash is written to the env as literal character.
-      # So don't escape spaces in |env[k]|.
-      self.WriteLn('%s: export %s := %s' % (QuoteSpaces(target), k, v))
-
-
-  def Objectify(self, path):
-    """Convert a path to its output directory form."""
-    if '$(' in path:
-      path = path.replace('$(obj)/', '$(obj).%s/$(TARGET)/' % self.toolset)
-    if not '$(obj)' in path:
-      path = '$(obj).%s/$(TARGET)/%s' % (self.toolset, path)
-    return path
-
-
-  def Pchify(self, path, lang):
-    """Convert a prefix header path to its output directory form."""
-    path = self.Absolutify(path)
-    if '$(' in path:
-      path = path.replace('$(obj)/', '$(obj).%s/$(TARGET)/pch-%s' %
-                          (self.toolset, lang))
-      return path
-    return '$(obj).%s/$(TARGET)/pch-%s/%s' % (self.toolset, lang, path)
-
-
-  def Absolutify(self, path):
-    """Convert a subdirectory-relative path into a base-relative path.
+        if self.type not in ("executable", "shared_library", "static_library"):
+            return
+
+        self.WriteLn("# Variable definitions for Android applications")
+        self.WriteLn("include $(CLEAR_VARS)")
+        self.WriteLn("LOCAL_MODULE := " + module_name)
+        self.WriteLn(
+            "LOCAL_CFLAGS := $(CFLAGS_$(BUILDTYPE)) "
+            "$(DEFS_$(BUILDTYPE)) "
+            # LOCAL_CFLAGS is applied to both of C and C++.  There is
+            # no way to specify $(CFLAGS_C_$(BUILDTYPE)) only for C
+            # sources.
+            "$(CFLAGS_C_$(BUILDTYPE)) "
+            # $(INCS_$(BUILDTYPE)) includes the prefix '-I' while
+            # LOCAL_C_INCLUDES does not expect it.  So put it in
+            # LOCAL_CFLAGS.
+            "$(INCS_$(BUILDTYPE))"
+        )
+        # LOCAL_CXXFLAGS is obsolete and LOCAL_CPPFLAGS is preferred.
+        self.WriteLn("LOCAL_CPPFLAGS := $(CFLAGS_CC_$(BUILDTYPE))")
+        self.WriteLn("LOCAL_C_INCLUDES :=")
+        self.WriteLn("LOCAL_LDLIBS := $(LDFLAGS_$(BUILDTYPE)) $(LIBS)")
+
+        # Detect the C++ extension.
+        cpp_ext = {".cc": 0, ".cpp": 0, ".cxx": 0}
+        default_cpp_ext = ".cpp"
+        for filename in all_sources:
+            ext = os.path.splitext(filename)[1]
+            if ext in cpp_ext:
+                cpp_ext[ext] += 1
+                if cpp_ext[ext] > cpp_ext[default_cpp_ext]:
+                    default_cpp_ext = ext
+        self.WriteLn("LOCAL_CPP_EXTENSION := " + default_cpp_ext)
+
+        self.WriteList(
+            list(map(self.Absolutify, filter(Compilable, all_sources))),
+            "LOCAL_SRC_FILES",
+        )
+
+        # Filter out those which do not match prefix and suffix and produce
+        # the resulting list without prefix and suffix.
+        def DepsToModules(deps, prefix, suffix):
+            modules = []
+            for filepath in deps:
+                filename = os.path.basename(filepath)
+                if filename.startswith(prefix) and filename.endswith(suffix):
+                    modules.append(filename[len(prefix) : -len(suffix)])
+            return modules
+
+        # Retrieve the default value of 'SHARED_LIB_SUFFIX'
+        params = {"flavor": "linux"}
+        default_variables = {}
+        CalculateVariables(default_variables, params)
+
+        self.WriteList(
+            DepsToModules(
+                link_deps,
+                generator_default_variables["SHARED_LIB_PREFIX"],
+                default_variables["SHARED_LIB_SUFFIX"],
+            ),
+            "LOCAL_SHARED_LIBRARIES",
+        )
+        self.WriteList(
+            DepsToModules(
+                link_deps,
+                generator_default_variables["STATIC_LIB_PREFIX"],
+                generator_default_variables["STATIC_LIB_SUFFIX"],
+            ),
+            "LOCAL_STATIC_LIBRARIES",
+        )
+
+        if self.type == "executable":
+            self.WriteLn("include $(BUILD_EXECUTABLE)")
+        elif self.type == "shared_library":
+            self.WriteLn("include $(BUILD_SHARED_LIBRARY)")
+        elif self.type == "static_library":
+            self.WriteLn("include $(BUILD_STATIC_LIBRARY)")
+        self.WriteLn()
+
+    def WriteLn(self, text=""):
+        self.fp.write(text + "\n")
+
+    def GetSortedXcodeEnv(self, additional_settings=None):
+        return gyp.xcode_emulation.GetSortedXcodeEnv(
+            self.xcode_settings,
+            "$(abs_builddir)",
+            os.path.join("$(abs_srcdir)", self.path),
+            "$(BUILDTYPE)",
+            additional_settings,
+        )
+
+    def GetSortedXcodePostbuildEnv(self):
+        # CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.
+        # TODO(thakis): It would be nice to have some general mechanism instead.
+        strip_save_file = self.xcode_settings.GetPerTargetSetting(
+            "CHROMIUM_STRIP_SAVE_FILE", ""
+        )
+        # Even if strip_save_file is empty, explicitly write it. Else a postbuild
+        # might pick up an export from an earlier target.
+        return self.GetSortedXcodeEnv(
+            additional_settings={"CHROMIUM_STRIP_SAVE_FILE": strip_save_file}
+        )
+
+    def WriteSortedXcodeEnv(self, target, env):
+        for k, v in env:
+            # For
+            #  foo := a\ b
+            # the escaped space does the right thing. For
+            #  export foo := a\ b
+            # it does not -- the backslash is written to the env as literal character.
+            # So don't escape spaces in |env[k]|.
+            self.WriteLn("%s: export %s := %s" % (QuoteSpaces(target), k, v))
+
+    def Objectify(self, path):
+        """Convert a path to its output directory form."""
+        if "$(" in path:
+            path = path.replace("$(obj)/", "$(obj).%s/$(TARGET)/" % self.toolset)
+        if "$(obj)" not in path:
+            path = "$(obj).%s/$(TARGET)/%s" % (self.toolset, path)
+        return path
+
+    def Pchify(self, path, lang):
+        """Convert a prefix header path to its output directory form."""
+        path = self.Absolutify(path)
+        if "$(" in path:
+            path = path.replace(
+                "$(obj)/", "$(obj).%s/$(TARGET)/pch-%s" % (self.toolset, lang)
+            )
+            return path
+        return "$(obj).%s/$(TARGET)/pch-%s/%s" % (self.toolset, lang, path)
+
+    def Absolutify(self, path):
+        """Convert a subdirectory-relative path into a base-relative path.
     Skips over paths that contain variables."""
-    if '$(' in path:
-      # Don't call normpath in this case, as it might collapse the
-      # path too aggressively if it features '..'. However it's still
-      # important to strip trailing slashes.
-      return path.rstrip('/')
-    return os.path.normpath(os.path.join(self.path, path))
-
-
-  def ExpandInputRoot(self, template, expansion, dirname):
-    if '%(INPUT_ROOT)s' not in template and '%(INPUT_DIRNAME)s' not in template:
-      return template
-    path = template % {
-        'INPUT_ROOT': expansion,
-        'INPUT_DIRNAME': dirname,
+        if "$(" in path:
+            # Don't call normpath in this case, as it might collapse the
+            # path too aggressively if it features '..'. However it's still
+            # important to strip trailing slashes.
+            return path.rstrip("/")
+        return os.path.normpath(os.path.join(self.path, path))
+
+    def ExpandInputRoot(self, template, expansion, dirname):
+        if "%(INPUT_ROOT)s" not in template and "%(INPUT_DIRNAME)s" not in template:
+            return template
+        path = template % {
+            "INPUT_ROOT": expansion,
+            "INPUT_DIRNAME": dirname,
+        }
+        return path
+
+    def _InstallableTargetInstallPath(self):
+        """Returns the location of the final output for an installable target."""
+        # Functionality removed for all platforms to match Xcode and hoist
+        # shared libraries into PRODUCT_DIR for users:
+        # Xcode puts shared_library results into PRODUCT_DIR, and some gyp files
+        # rely on this. Emulate this behavior for mac.
+        # if self.type == "shared_library" and (
+        #     self.flavor != "mac" or self.toolset != "target"
+        # ):
+        #    # Install all shared libs into a common directory (per toolset) for
+        #    # convenient access with LD_LIBRARY_PATH.
+        #    return "$(builddir)/lib.%s/%s" % (self.toolset, self.alias)
+        return "$(builddir)/" + self.alias
+
+
+def WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files):
+    """Write the target to regenerate the Makefile."""
+    options = params["options"]
+    build_files_args = [
+        gyp.common.RelativePath(filename, options.toplevel_dir)
+        for filename in params["build_files_arg"]
+    ]
+
+    gyp_binary = gyp.common.FixIfRelativePath(
+        params["gyp_binary"], options.toplevel_dir
+    )
+    if not gyp_binary.startswith(os.sep):
+        gyp_binary = os.path.join(".", gyp_binary)
+
+    root_makefile.write(
+        "quiet_cmd_regen_makefile = ACTION Regenerating $@\n"
+        "cmd_regen_makefile = cd $(srcdir); %(cmd)s\n"
+        "%(makefile_name)s: %(deps)s\n"
+        "\t$(call do_cmd,regen_makefile)\n\n"
+        % {
+            "makefile_name": makefile_name,
+            "deps": " ".join(SourceifyAndQuoteSpaces(bf) for bf in build_files),
+            "cmd": gyp.common.EncodePOSIXShellList(
+                [gyp_binary, "-fmake"] + gyp.RegenerateFlags(options) + build_files_args
+            ),
         }
-    return path
-
-
-  def _InstallableTargetInstallPath(self):
-    """Returns the location of the final output for an installable target."""
-    # Xcode puts shared_library results into PRODUCT_DIR, and some gyp files
-    # rely on this. Emulate this behavior for mac.
-    if (self.type == 'shared_library' and
-        (self.flavor != 'mac' or self.toolset != 'target')):
-      # Install all shared libs into a common directory (per toolset) for
-      # convenient access with LD_LIBRARY_PATH.
-      return '$(builddir)/lib.%s/%s' % (self.toolset, self.alias)
-    return '$(builddir)/' + self.alias
-
-
-def WriteAutoRegenerationRule(params, root_makefile, makefile_name,
-                              build_files):
-  """Write the target to regenerate the Makefile."""
-  options = params['options']
-  build_files_args = [gyp.common.RelativePath(filename, options.toplevel_dir)
-                      for filename in params['build_files_arg']]
-
-  gyp_binary = gyp.common.FixIfRelativePath(params['gyp_binary'],
-                                            options.toplevel_dir)
-  if not gyp_binary.startswith(os.sep):
-    gyp_binary = os.path.join('.', gyp_binary)
-
-  root_makefile.write(
-      "quiet_cmd_regen_makefile = ACTION Regenerating $@\n"
-      "cmd_regen_makefile = cd $(srcdir); %(cmd)s\n"
-      "%(makefile_name)s: %(deps)s\n"
-      "\t$(call do_cmd,regen_makefile)\n\n" % {
-          'makefile_name': makefile_name,
-          'deps': ' '.join(SourceifyAndQuoteSpaces(bf) for bf in build_files),
-          'cmd': gyp.common.EncodePOSIXShellList(
-                     [gyp_binary, '-fmake'] +
-                     gyp.RegenerateFlags(options) +
-                     build_files_args)})
+    )
 
 
 def PerformBuild(data, configurations, params):
-  options = params['options']
-  for config in configurations:
-    arguments = ['make']
-    if options.toplevel_dir and options.toplevel_dir != '.':
-      arguments += '-C', options.toplevel_dir
-    arguments.append('BUILDTYPE=' + config)
-    print('Building [%s]: %s' % (config, arguments))
-    subprocess.check_call(arguments)
+    options = params["options"]
+    for config in configurations:
+        arguments = ["make"]
+        if options.toplevel_dir and options.toplevel_dir != ".":
+            arguments += "-C", options.toplevel_dir
+        arguments.append("BUILDTYPE=" + config)
+        print("Building [%s]: %s" % (config, arguments))
+        subprocess.check_call(arguments)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  options = params['options']
-  flavor = gyp.common.GetFlavor(params)
-  generator_flags = params.get('generator_flags', {})
-  builddir_name = generator_flags.get('output_dir', 'out')
-  android_ndk_version = generator_flags.get('android_ndk_version', None)
-  default_target = generator_flags.get('default_target', 'all')
-
-  def CalculateMakefilePath(build_file, base_name):
-    """Determine where to write a Makefile for a given gyp file."""
-    # Paths in gyp files are relative to the .gyp file, but we want
-    # paths relative to the source root for the master makefile.  Grab
-    # the path of the .gyp file as the base to relativize against.
-    # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".
-    base_path = gyp.common.RelativePath(os.path.dirname(build_file),
-                                        options.depth)
-    # We write the file in the base_path directory.
-    output_file = os.path.join(options.depth, base_path, base_name)
+    options = params["options"]
+    flavor = gyp.common.GetFlavor(params)
+    generator_flags = params.get("generator_flags", {})
+    builddir_name = generator_flags.get("output_dir", "out")
+    android_ndk_version = generator_flags.get("android_ndk_version", None)
+    default_target = generator_flags.get("default_target", "all")
+
+    def CalculateMakefilePath(build_file, base_name):
+        """Determine where to write a Makefile for a given gyp file."""
+        # Paths in gyp files are relative to the .gyp file, but we want
+        # paths relative to the source root for the master makefile.  Grab
+        # the path of the .gyp file as the base to relativize against.
+        # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".
+        base_path = gyp.common.RelativePath(os.path.dirname(build_file), options.depth)
+        # We write the file in the base_path directory.
+        output_file = os.path.join(options.depth, base_path, base_name)
+        if options.generator_output:
+            output_file = os.path.join(
+                options.depth, options.generator_output, base_path, base_name
+            )
+        base_path = gyp.common.RelativePath(
+            os.path.dirname(build_file), options.toplevel_dir
+        )
+        return base_path, output_file
+
+    # TODO:  search for the first non-'Default' target.  This can go
+    # away when we add verification that all targets have the
+    # necessary configurations.
+    default_configuration = None
+    toolsets = set([target_dicts[target]["toolset"] for target in target_list])
+    for target in target_list:
+        spec = target_dicts[target]
+        if spec["default_configuration"] != "Default":
+            default_configuration = spec["default_configuration"]
+            break
+    if not default_configuration:
+        default_configuration = "Default"
+
+    srcdir = "."
+    makefile_name = "Makefile" + options.suffix
+    makefile_path = os.path.join(options.toplevel_dir, makefile_name)
     if options.generator_output:
-      output_file = os.path.join(
-          options.depth, options.generator_output, base_path, base_name)
-    base_path = gyp.common.RelativePath(os.path.dirname(build_file),
-                                        options.toplevel_dir)
-    return base_path, output_file
-
-  # TODO:  search for the first non-'Default' target.  This can go
-  # away when we add verification that all targets have the
-  # necessary configurations.
-  default_configuration = None
-  toolsets = set([target_dicts[target]['toolset'] for target in target_list])
-  for target in target_list:
-    spec = target_dicts[target]
-    if spec['default_configuration'] != 'Default':
-      default_configuration = spec['default_configuration']
-      break
-  if not default_configuration:
-    default_configuration = 'Default'
-
-  srcdir = '.'
-  makefile_name = 'Makefile' + options.suffix
-  makefile_path = os.path.join(options.toplevel_dir, makefile_name)
-  if options.generator_output:
-    global srcdir_prefix
-    makefile_path = os.path.join(
-        options.toplevel_dir, options.generator_output, makefile_name)
-    srcdir = gyp.common.RelativePath(srcdir, options.generator_output)
-    srcdir_prefix = '$(srcdir)/'
-
-  flock_command= 'flock'
-  copy_archive_arguments = '-af'
-  makedep_arguments = '-MMD'
-  header_params = {
-      'default_target': default_target,
-      'builddir': builddir_name,
-      'default_configuration': default_configuration,
-      'flock': flock_command,
-      'flock_index': 1,
-      'link_commands': LINK_COMMANDS_LINUX,
-      'extra_commands': '',
-      'srcdir': srcdir,
-      'copy_archive_args': copy_archive_arguments,
-      'makedep_args': makedep_arguments,
-      'CC.target':   GetEnvironFallback(('CC_target', 'CC'), '$(CC)'),
-      'AR.target':   GetEnvironFallback(('AR_target', 'AR'), '$(AR)'),
-      'CXX.target':  GetEnvironFallback(('CXX_target', 'CXX'), '$(CXX)'),
-      'LINK.target': GetEnvironFallback(('LINK_target', 'LINK'), '$(LINK)'),
-      'CC.host':     GetEnvironFallback(('CC_host', 'CC'), 'gcc'),
-      'AR.host':     GetEnvironFallback(('AR_host', 'AR'), 'ar'),
-      'CXX.host':    GetEnvironFallback(('CXX_host', 'CXX'), 'g++'),
-      'LINK.host':   GetEnvironFallback(('LINK_host', 'LINK'), '$(CXX.host)'),
+        global srcdir_prefix
+        makefile_path = os.path.join(
+            options.toplevel_dir, options.generator_output, makefile_name
+        )
+        srcdir = gyp.common.RelativePath(srcdir, options.generator_output)
+        srcdir_prefix = "$(srcdir)/"
+
+    flock_command = "flock"
+    copy_archive_arguments = "-af"
+    makedep_arguments = "-MMD"
+    header_params = {
+        "default_target": default_target,
+        "builddir": builddir_name,
+        "default_configuration": default_configuration,
+        "flock": flock_command,
+        "flock_index": 1,
+        "link_commands": LINK_COMMANDS_LINUX,
+        "extra_commands": "",
+        "srcdir": srcdir,
+        "copy_archive_args": copy_archive_arguments,
+        "makedep_args": makedep_arguments,
+        "CC.target": GetEnvironFallback(("CC_target", "CC"), "$(CC)"),
+        "AR.target": GetEnvironFallback(("AR_target", "AR"), "$(AR)"),
+        "CXX.target": GetEnvironFallback(("CXX_target", "CXX"), "$(CXX)"),
+        "LINK.target": GetEnvironFallback(("LINK_target", "LINK"), "$(LINK)"),
+        "CC.host": GetEnvironFallback(("CC_host", "CC"), "gcc"),
+        "AR.host": GetEnvironFallback(("AR_host", "AR"), "ar"),
+        "CXX.host": GetEnvironFallback(("CXX_host", "CXX"), "g++"),
+        "LINK.host": GetEnvironFallback(("LINK_host", "LINK"), "$(CXX.host)"),
     }
-  if flavor == 'mac':
-    flock_command = './gyp-mac-tool flock'
-    header_params.update({
-        'flock': flock_command,
-        'flock_index': 2,
-        'link_commands': LINK_COMMANDS_MAC,
-        'extra_commands': SHARED_HEADER_MAC_COMMANDS,
-    })
-  elif flavor == 'android':
-    header_params.update({
-        'link_commands': LINK_COMMANDS_ANDROID,
-    })
-  elif flavor == 'zos':
-    copy_archive_arguments = '-fPR'
-    makedep_arguments = '-qmakedep=gcc'
-    header_params.update({
-        'copy_archive_args': copy_archive_arguments,
-        'makedep_args': makedep_arguments,
-        'link_commands': LINK_COMMANDS_OS390,
-        'CC.target':   GetEnvironFallback(('CC_target', 'CC'), 'njsc'),
-        'CXX.target':  GetEnvironFallback(('CXX_target', 'CXX'), 'njsc++'),
-        'CC.host':     GetEnvironFallback(('CC_host', 'CC'), 'njsc'),
-        'CXX.host':    GetEnvironFallback(('CXX_host', 'CXX'), 'njsc++'),
-    })
-  elif flavor == 'solaris':
-    header_params.update({
-        'flock': './gyp-flock-tool flock',
-        'flock_index': 2,
-    })
-  elif flavor == 'freebsd':
-    # Note: OpenBSD has sysutils/flock. lockf seems to be FreeBSD specific.
-    header_params.update({
-        'flock': 'lockf',
-    })
-  elif flavor == 'openbsd':
-    copy_archive_arguments = '-pPRf'
-    header_params.update({
-        'copy_archive_args': copy_archive_arguments,
-    })
-  elif flavor == 'aix':
-    copy_archive_arguments = '-pPRf'
-    header_params.update({
-        'copy_archive_args': copy_archive_arguments,
-        'link_commands': LINK_COMMANDS_AIX,
-        'flock': './gyp-flock-tool flock',
-        'flock_index': 2,
-    })
-
-  build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
-  make_global_settings_array = data[build_file].get('make_global_settings', [])
-  wrappers = {}
-  for key, value in make_global_settings_array:
-    if key.endswith('_wrapper'):
-      wrappers[key[:-len('_wrapper')]] = '$(abspath %s)' % value
-  make_global_settings = ''
-  for key, value in make_global_settings_array:
-    if re.match('.*_wrapper', key):
-      continue
-    if value[0] != '$':
-      value = '$(abspath %s)' % value
-    wrapper = wrappers.get(key)
-    if wrapper:
-      value = '%s %s' % (wrapper, value)
-      del wrappers[key]
-    if key in ('CC', 'CC.host', 'CXX', 'CXX.host'):
-      make_global_settings += (
-          'ifneq (,$(filter $(origin %s), undefined default))\n' % key)
-      # Let gyp-time envvars win over global settings.
-      env_key = key.replace('.', '_')  # CC.host -> CC_host
-      if env_key in os.environ:
-        value = os.environ[env_key]
-      make_global_settings += '  %s = %s\n' % (key, value)
-      make_global_settings += 'endif\n'
-    else:
-      make_global_settings += '%s ?= %s\n' % (key, value)
-  # TODO(ukai): define cmd when only wrapper is specified in
-  # make_global_settings.
-
-  header_params['make_global_settings'] = make_global_settings
-
-  gyp.common.EnsureDirExists(makefile_path)
-  root_makefile = open(makefile_path, 'w')
-  root_makefile.write(SHARED_HEADER % header_params)
-  # Currently any versions have the same effect, but in future the behavior
-  # could be different.
-  if android_ndk_version:
-    root_makefile.write(
-        '# Define LOCAL_PATH for build of Android applications.\n'
-        'LOCAL_PATH := $(call my-dir)\n'
-        '\n')
-  for toolset in toolsets:
-    root_makefile.write('TOOLSET := %s\n' % toolset)
-    WriteRootHeaderSuffixRules(root_makefile)
-
-  # Put build-time support tools next to the root Makefile.
-  dest_path = os.path.dirname(makefile_path)
-  gyp.common.CopyTool(flavor, dest_path)
-
-  # Find the list of targets that derive from the gyp file(s) being built.
-  needed_targets = set()
-  for build_file in params['build_files']:
-    for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
-      needed_targets.add(target)
-
-  build_files = set()
-  include_list = set()
-  for qualified_target in target_list:
-    build_file, target, toolset = gyp.common.ParseQualifiedTarget(
-        qualified_target)
-
-    this_make_global_settings = data[build_file].get('make_global_settings', [])
-    assert make_global_settings_array == this_make_global_settings, (
-        "make_global_settings needs to be the same for all targets. %s vs. %s" %
-        (this_make_global_settings, make_global_settings))
-
-    build_files.add(gyp.common.RelativePath(build_file, options.toplevel_dir))
-    included_files = data[build_file]['included_files']
-    for included_file in included_files:
-      # The included_files entries are relative to the dir of the build file
-      # that included them, so we have to undo that and then make them relative
-      # to the root dir.
-      relative_include_file = gyp.common.RelativePath(
-          gyp.common.UnrelativePath(included_file, build_file),
-          options.toplevel_dir)
-      abs_include_file = os.path.abspath(relative_include_file)
-      # If the include file is from the ~/.gyp dir, we should use absolute path
-      # so that relocating the src dir doesn't break the path.
-      if (params['home_dot_gyp'] and
-          abs_include_file.startswith(params['home_dot_gyp'])):
-        build_files.add(abs_include_file)
-      else:
-        build_files.add(relative_include_file)
-
-    base_path, output_file = CalculateMakefilePath(build_file,
-        target + '.' + toolset + options.suffix + '.mk')
-
-    spec = target_dicts[qualified_target]
-    configs = spec['configurations']
-
-    if flavor == 'mac':
-      gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
-
-    writer = MakefileWriter(generator_flags, flavor)
-    writer.Write(qualified_target, base_path, output_file, spec, configs,
-                 part_of_all=qualified_target in needed_targets)
-
-    # Our root_makefile lives at the source root.  Compute the relative path
-    # from there to the output_file for including.
-    mkfile_rel_path = gyp.common.RelativePath(output_file,
-                                              os.path.dirname(makefile_path))
-    include_list.add(mkfile_rel_path)
-
-  # Write out per-gyp (sub-project) Makefiles.
-  depth_rel_path = gyp.common.RelativePath(options.depth, os.getcwd())
-  for build_file in build_files:
-    # The paths in build_files were relativized above, so undo that before
-    # testing against the non-relativized items in target_list and before
-    # calculating the Makefile path.
-    build_file = os.path.join(depth_rel_path, build_file)
-    gyp_targets = [target_dicts[target]['target_name'] for target in target_list
-                   if target.startswith(build_file) and
-                   target in needed_targets]
-    # Only generate Makefiles for gyp files with targets.
-    if not gyp_targets:
-      continue
-    base_path, output_file = CalculateMakefilePath(build_file,
-        os.path.splitext(os.path.basename(build_file))[0] + '.Makefile')
-    makefile_rel_path = gyp.common.RelativePath(os.path.dirname(makefile_path),
-                                                os.path.dirname(output_file))
-    writer.WriteSubMake(output_file, makefile_rel_path, gyp_targets,
-                        builddir_name)
-
-
-  # Write out the sorted list of includes.
-  root_makefile.write('\n')
-  for include_file in sorted(include_list):
-    # We wrap each .mk include in an if statement so users can tell make to
-    # not load a file by setting NO_LOAD.  The below make code says, only
-    # load the .mk file if the .mk filename doesn't start with a token in
-    # NO_LOAD.
-    root_makefile.write(
-        "ifeq ($(strip $(foreach prefix,$(NO_LOAD),\\\n"
-        "    $(findstring $(join ^,$(prefix)),\\\n"
-        "                 $(join ^," + include_file + ")))),)\n")
-    root_makefile.write("  include " + include_file + "\n")
-    root_makefile.write("endif\n")
-  root_makefile.write('\n')
-
-  if (not generator_flags.get('standalone')
-      and generator_flags.get('auto_regeneration', True)):
-    WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files)
+    if flavor == "mac":
+        flock_command = "./gyp-mac-tool flock"
+        header_params.update(
+            {
+                "flock": flock_command,
+                "flock_index": 2,
+                "link_commands": LINK_COMMANDS_MAC,
+                "extra_commands": SHARED_HEADER_MAC_COMMANDS,
+            }
+        )
+    elif flavor == "android":
+        header_params.update({"link_commands": LINK_COMMANDS_ANDROID})
+    elif flavor == "zos":
+        copy_archive_arguments = "-fPR"
+        makedep_arguments = "-qmakedep=gcc"
+        header_params.update(
+            {
+                "copy_archive_args": copy_archive_arguments,
+                "makedep_args": makedep_arguments,
+                "link_commands": LINK_COMMANDS_OS390,
+                "CC.target": GetEnvironFallback(("CC_target", "CC"), "njsc"),
+                "CXX.target": GetEnvironFallback(("CXX_target", "CXX"), "njsc++"),
+                "CC.host": GetEnvironFallback(("CC_host", "CC"), "njsc"),
+                "CXX.host": GetEnvironFallback(("CXX_host", "CXX"), "njsc++"),
+            }
+        )
+    elif flavor == "solaris":
+        copy_archive_arguments = "-pPRf@"
+        header_params.update(
+            {
+                "copy_archive_args": copy_archive_arguments,
+                "flock": "./gyp-flock-tool flock",
+                "flock_index": 2
+            }
+        )
+    elif flavor == "freebsd":
+        # Note: OpenBSD has sysutils/flock. lockf seems to be FreeBSD specific.
+        header_params.update({"flock": "lockf"})
+    elif flavor == "openbsd":
+        copy_archive_arguments = "-pPRf"
+        header_params.update({"copy_archive_args": copy_archive_arguments})
+    elif flavor == "aix":
+        copy_archive_arguments = "-pPRf"
+        header_params.update(
+            {
+                "copy_archive_args": copy_archive_arguments,
+                "link_commands": LINK_COMMANDS_AIX,
+                "flock": "./gyp-flock-tool flock",
+                "flock_index": 2,
+            }
+        )
+
+    build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
+    make_global_settings_array = data[build_file].get("make_global_settings", [])
+    wrappers = {}
+    for key, value in make_global_settings_array:
+        if key.endswith("_wrapper"):
+            wrappers[key[: -len("_wrapper")]] = "$(abspath %s)" % value
+    make_global_settings = ""
+    for key, value in make_global_settings_array:
+        if re.match(".*_wrapper", key):
+            continue
+        if value[0] != "$":
+            value = "$(abspath %s)" % value
+        wrapper = wrappers.get(key)
+        if wrapper:
+            value = "%s %s" % (wrapper, value)
+            del wrappers[key]
+        if key in ("CC", "CC.host", "CXX", "CXX.host"):
+            make_global_settings += (
+                "ifneq (,$(filter $(origin %s), undefined default))\n" % key
+            )
+            # Let gyp-time envvars win over global settings.
+            env_key = key.replace(".", "_")  # CC.host -> CC_host
+            if env_key in os.environ:
+                value = os.environ[env_key]
+            make_global_settings += "  %s = %s\n" % (key, value)
+            make_global_settings += "endif\n"
+        else:
+            make_global_settings += "%s ?= %s\n" % (key, value)
+    # TODO(ukai): define cmd when only wrapper is specified in
+    # make_global_settings.
 
-  root_makefile.write(SHARED_FOOTER)
+    header_params["make_global_settings"] = make_global_settings
 
-  root_makefile.close()
+    gyp.common.EnsureDirExists(makefile_path)
+    root_makefile = open(makefile_path, "w")
+    root_makefile.write(SHARED_HEADER % header_params)
+    # Currently any versions have the same effect, but in future the behavior
+    # could be different.
+    if android_ndk_version:
+        root_makefile.write(
+            "# Define LOCAL_PATH for build of Android applications.\n"
+            "LOCAL_PATH := $(call my-dir)\n"
+            "\n"
+        )
+    for toolset in toolsets:
+        root_makefile.write("TOOLSET := %s\n" % toolset)
+        WriteRootHeaderSuffixRules(root_makefile)
+
+    # Put build-time support tools next to the root Makefile.
+    dest_path = os.path.dirname(makefile_path)
+    gyp.common.CopyTool(flavor, dest_path)
+
+    # Find the list of targets that derive from the gyp file(s) being built.
+    needed_targets = set()
+    for build_file in params["build_files"]:
+        for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
+            needed_targets.add(target)
+
+    build_files = set()
+    include_list = set()
+    for qualified_target in target_list:
+        build_file, target, toolset = gyp.common.ParseQualifiedTarget(qualified_target)
+
+        this_make_global_settings = data[build_file].get("make_global_settings", [])
+        assert make_global_settings_array == this_make_global_settings, (
+            "make_global_settings needs to be the same for all targets. %s vs. %s"
+            % (this_make_global_settings, make_global_settings)
+        )
+
+        build_files.add(gyp.common.RelativePath(build_file, options.toplevel_dir))
+        included_files = data[build_file]["included_files"]
+        for included_file in included_files:
+            # The included_files entries are relative to the dir of the build file
+            # that included them, so we have to undo that and then make them relative
+            # to the root dir.
+            relative_include_file = gyp.common.RelativePath(
+                gyp.common.UnrelativePath(included_file, build_file),
+                options.toplevel_dir,
+            )
+            abs_include_file = os.path.abspath(relative_include_file)
+            # If the include file is from the ~/.gyp dir, we should use absolute path
+            # so that relocating the src dir doesn't break the path.
+            if params["home_dot_gyp"] and abs_include_file.startswith(
+                params["home_dot_gyp"]
+            ):
+                build_files.add(abs_include_file)
+            else:
+                build_files.add(relative_include_file)
+
+        base_path, output_file = CalculateMakefilePath(
+            build_file, target + "." + toolset + options.suffix + ".mk"
+        )
+
+        spec = target_dicts[qualified_target]
+        configs = spec["configurations"]
+
+        if flavor == "mac":
+            gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
+
+        writer = MakefileWriter(generator_flags, flavor)
+        writer.Write(
+            qualified_target,
+            base_path,
+            output_file,
+            spec,
+            configs,
+            part_of_all=qualified_target in needed_targets,
+        )
+
+        # Our root_makefile lives at the source root.  Compute the relative path
+        # from there to the output_file for including.
+        mkfile_rel_path = gyp.common.RelativePath(
+            output_file, os.path.dirname(makefile_path)
+        )
+        include_list.add(mkfile_rel_path)
+
+    # Write out per-gyp (sub-project) Makefiles.
+    depth_rel_path = gyp.common.RelativePath(options.depth, os.getcwd())
+    for build_file in build_files:
+        # The paths in build_files were relativized above, so undo that before
+        # testing against the non-relativized items in target_list and before
+        # calculating the Makefile path.
+        build_file = os.path.join(depth_rel_path, build_file)
+        gyp_targets = [
+            target_dicts[qualified_target]["target_name"]
+            for qualified_target in target_list
+            if qualified_target.startswith(build_file)
+            and qualified_target in needed_targets
+        ]
+        # Only generate Makefiles for gyp files with targets.
+        if not gyp_targets:
+            continue
+        base_path, output_file = CalculateMakefilePath(
+            build_file, os.path.splitext(os.path.basename(build_file))[0] + ".Makefile"
+        )
+        makefile_rel_path = gyp.common.RelativePath(
+            os.path.dirname(makefile_path), os.path.dirname(output_file)
+        )
+        writer.WriteSubMake(output_file, makefile_rel_path, gyp_targets, builddir_name)
+
+    # Write out the sorted list of includes.
+    root_makefile.write("\n")
+    for include_file in sorted(include_list):
+        # We wrap each .mk include in an if statement so users can tell make to
+        # not load a file by setting NO_LOAD.  The below make code says, only
+        # load the .mk file if the .mk filename doesn't start with a token in
+        # NO_LOAD.
+        root_makefile.write(
+            "ifeq ($(strip $(foreach prefix,$(NO_LOAD),\\\n"
+            "    $(findstring $(join ^,$(prefix)),\\\n"
+            "                 $(join ^," + include_file + ")))),)\n"
+        )
+        root_makefile.write("  include " + include_file + "\n")
+        root_makefile.write("endif\n")
+    root_makefile.write("\n")
+
+    if not generator_flags.get("standalone") and generator_flags.get(
+        "auto_regeneration", True
+    ):
+        WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files)
+
+    root_makefile.write(SHARED_FOOTER)
+
+    root_makefile.close()
diff --git a/tools/gyp/pylib/gyp/generator/msvs.py b/tools/gyp/pylib/gyp/generator/msvs.py
index 933042c7113c59b1bd45f50a2b48e66073b7bc02..96283b275756e575b1e3536992f2e50297d851ff 100644
--- a/tools/gyp/pylib/gyp/generator/msvs.py
+++ b/tools/gyp/pylib/gyp/generator/msvs.py
@@ -4,7 +4,6 @@
 
 from __future__ import print_function
 
-import copy
 import ntpath
 import os
 import posixpath
@@ -38,64 +37,64 @@ PY3 = bytes != str
 # if IncrediBuild is executed from inside Visual Studio.  This regex
 # validates that the string looks like a GUID with all uppercase hex
 # letters.
-VALID_MSVS_GUID_CHARS = re.compile(r'^[A-F0-9\-]+$')
+VALID_MSVS_GUID_CHARS = re.compile(r"^[A-F0-9\-]+$")
 
+generator_supports_multiple_toolsets = gyp.common.CrossCompileRequested()
 
 generator_default_variables = {
-    'DRIVER_PREFIX': '',
-    'DRIVER_SUFFIX': '.sys',
-    'EXECUTABLE_PREFIX': '',
-    'EXECUTABLE_SUFFIX': '.exe',
-    'STATIC_LIB_PREFIX': '',
-    'SHARED_LIB_PREFIX': '',
-    'STATIC_LIB_SUFFIX': '.lib',
-    'SHARED_LIB_SUFFIX': '.dll',
-    'INTERMEDIATE_DIR': '$(IntDir)',
-    'SHARED_INTERMEDIATE_DIR': '$(OutDir)obj/global_intermediate',
-    'OS': 'win',
-    'PRODUCT_DIR': '$(OutDir)',
-    'LIB_DIR': '$(OutDir)lib',
-    'RULE_INPUT_ROOT': '$(InputName)',
-    'RULE_INPUT_DIRNAME': '$(InputDir)',
-    'RULE_INPUT_EXT': '$(InputExt)',
-    'RULE_INPUT_NAME': '$(InputFileName)',
-    'RULE_INPUT_PATH': '$(InputPath)',
-    'CONFIGURATION_NAME': '$(ConfigurationName)',
+    "DRIVER_PREFIX": "",
+    "DRIVER_SUFFIX": ".sys",
+    "EXECUTABLE_PREFIX": "",
+    "EXECUTABLE_SUFFIX": ".exe",
+    "STATIC_LIB_PREFIX": "",
+    "SHARED_LIB_PREFIX": "",
+    "STATIC_LIB_SUFFIX": ".lib",
+    "SHARED_LIB_SUFFIX": ".dll",
+    "INTERMEDIATE_DIR": "$(IntDir)",
+    "SHARED_INTERMEDIATE_DIR": "$(OutDir)/obj/global_intermediate",
+    "OS": "win",
+    "PRODUCT_DIR": "$(OutDir)",
+    "LIB_DIR": "$(OutDir)lib",
+    "RULE_INPUT_ROOT": "$(InputName)",
+    "RULE_INPUT_DIRNAME": "$(InputDir)",
+    "RULE_INPUT_EXT": "$(InputExt)",
+    "RULE_INPUT_NAME": "$(InputFileName)",
+    "RULE_INPUT_PATH": "$(InputPath)",
+    "CONFIGURATION_NAME": "$(ConfigurationName)",
 }
 
 
 # The msvs specific sections that hold paths
 generator_additional_path_sections = [
-    'msvs_cygwin_dirs',
-    'msvs_props',
+    "msvs_cygwin_dirs",
+    "msvs_props",
 ]
 
 
 generator_additional_non_configuration_keys = [
-    'msvs_cygwin_dirs',
-    'msvs_cygwin_shell',
-    'msvs_large_pdb',
-    'msvs_shard',
-    'msvs_external_builder',
-    'msvs_external_builder_out_dir',
-    'msvs_external_builder_build_cmd',
-    'msvs_external_builder_clean_cmd',
-    'msvs_external_builder_clcompile_cmd',
-    'msvs_enable_winrt',
-    'msvs_requires_importlibrary',
-    'msvs_enable_winphone',
-    'msvs_enable_marmasm',
-    'msvs_application_type_revision',
-    'msvs_target_platform_version',
-    'msvs_target_platform_minversion',
+    "msvs_cygwin_dirs",
+    "msvs_cygwin_shell",
+    "msvs_large_pdb",
+    "msvs_shard",
+    "msvs_external_builder",
+    "msvs_external_builder_out_dir",
+    "msvs_external_builder_build_cmd",
+    "msvs_external_builder_clean_cmd",
+    "msvs_external_builder_clcompile_cmd",
+    "msvs_enable_winrt",
+    "msvs_requires_importlibrary",
+    "msvs_enable_winphone",
+    "msvs_application_type_revision",
+    "msvs_target_platform_version",
+    "msvs_target_platform_minversion",
 ]
 
 generator_filelist_paths = None
 
 # List of precompiled header related keys.
 precomp_keys = [
-    'msvs_precompiled_header',
-    'msvs_precompiled_source',
+    "msvs_precompiled_header",
+    "msvs_precompiled_source",
 ]
 
 
@@ -110,36 +109,38 @@ cached_domain = None
 # python version in depot_tools has been updated to work on Vista
 # 64-bit.
 def _GetDomainAndUserName():
-  if sys.platform not in ('win32', 'cygwin'):
-    return ('DOMAIN', 'USERNAME')
-  global cached_username
-  global cached_domain
-  if not cached_domain or not cached_username:
-    domain = os.environ.get('USERDOMAIN')
-    username = os.environ.get('USERNAME')
-    if not domain or not username:
-      call = subprocess.Popen(['net', 'config', 'Workstation'],
-                              stdout=subprocess.PIPE)
-      config = call.communicate()[0]
-      if PY3:
-        config = config.decode('utf-8')
-      username_re = re.compile(r'^User name\s+(\S+)', re.MULTILINE)
-      username_match = username_re.search(config)
-      if username_match:
-        username = username_match.group(1)
-      domain_re = re.compile(r'^Logon domain\s+(\S+)', re.MULTILINE)
-      domain_match = domain_re.search(config)
-      if domain_match:
-        domain = domain_match.group(1)
-    cached_domain = domain
-    cached_username = username
-  return (cached_domain, cached_username)
+    if sys.platform not in ("win32", "cygwin"):
+        return ("DOMAIN", "USERNAME")
+    global cached_username
+    global cached_domain
+    if not cached_domain or not cached_username:
+        domain = os.environ.get("USERDOMAIN")
+        username = os.environ.get("USERNAME")
+        if not domain or not username:
+            call = subprocess.Popen(
+                ["net", "config", "Workstation"], stdout=subprocess.PIPE
+            )
+            config = call.communicate()[0]
+            if PY3:
+                config = config.decode("utf-8")
+            username_re = re.compile(r"^User name\s+(\S+)", re.MULTILINE)
+            username_match = username_re.search(config)
+            if username_match:
+                username = username_match.group(1)
+            domain_re = re.compile(r"^Logon domain\s+(\S+)", re.MULTILINE)
+            domain_match = domain_re.search(config)
+            if domain_match:
+                domain = domain_match.group(1)
+        cached_domain = domain
+        cached_username = username
+    return (cached_domain, cached_username)
+
 
 fixpath_prefix = None
 
 
 def _NormalizedSource(source):
-  """Normalize the path.
+    """Normalize the path.
 
   But not if that gets rid of a variable, as this may expand to something
   larger than one directory.
@@ -150,46 +151,54 @@ def _NormalizedSource(source):
   Returns:
       The normalized path.
   """
-  normalized = os.path.normpath(source)
-  if source.count('$') == normalized.count('$'):
-    source = normalized
-  return source
+    normalized = os.path.normpath(source)
+    if source.count("$") == normalized.count("$"):
+        source = normalized
+    return source
 
 
 def _FixPath(path):
-  """Convert paths to a form that will make sense in a vcproj file.
+    """Convert paths to a form that will make sense in a vcproj file.
 
   Arguments:
     path: The path to convert, may contain / etc.
   Returns:
     The path with all slashes made into backslashes.
   """
-  if fixpath_prefix and path and not os.path.isabs(path) and not path[0] == '$' and not _IsWindowsAbsPath(path):
-    path = os.path.join(fixpath_prefix, path)
-  path = path.replace('/', '\\')
-  path = _NormalizedSource(path)
-  if path and path[-1] == '\\':
-    path = path[:-1]
-  return path
+    if (
+        fixpath_prefix
+        and path
+        and not os.path.isabs(path)
+        and not path[0] == "$"
+        and not _IsWindowsAbsPath(path)
+    ):
+        path = os.path.join(fixpath_prefix, path)
+    path = path.replace("/", "\\")
+    path = _NormalizedSource(path)
+    if path and path[-1] == "\\":
+        path = path[:-1]
+    return path
 
 
 def _IsWindowsAbsPath(path):
-  """
-  On Cygwin systems Python needs a little help determining if a path is an absolute Windows path or not, so that
+    """
+  On Cygwin systems Python needs a little help determining if a path
+  is an absolute Windows path or not, so that
   it does not treat those as relative, which results in bad paths like:
-  '..\C:\<some path>\some_source_code_file.cc'
+  '..\\C:\\<some path>\\some_source_code_file.cc'
   """
-  return path.startswith('c:') or path.startswith('C:')
+    return path.startswith("c:") or path.startswith("C:")
 
 
 def _FixPaths(paths):
-  """Fix each of the paths of the list."""
-  return [_FixPath(i) for i in paths]
+    """Fix each of the paths of the list."""
+    return [_FixPath(i) for i in paths]
 
 
-def _ConvertSourcesToFilterHierarchy(sources, prefix=None, excluded=None,
-                                     list_excluded=True, msvs_version=None):
-  """Converts a list split source file paths into a vcproj folder hierarchy.
+def _ConvertSourcesToFilterHierarchy(
+    sources, prefix=None, excluded=None, list_excluded=True, msvs_version=None
+):
+    """Converts a list split source file paths into a vcproj folder hierarchy.
 
   Arguments:
     sources: A list of source file paths split.
@@ -207,221 +216,242 @@ def _ConvertSourcesToFilterHierarchy(sources, prefix=None, excluded=None,
     [MSVSProject.Filter('a', contents=['joe\\a\\bob1.c']),
      MSVSProject.Filter('b', contents=['joe\\b\\bob2.c'])]
   """
-  if not prefix: prefix = []
-  result = []
-  excluded_result = []
-  folders = OrderedDict()
-  # Gather files into the final result, excluded, or folders.
-  for s in sources:
-    if len(s) == 1:
-      filename = _NormalizedSource('\\'.join(prefix + s))
-      if filename in excluded:
-        excluded_result.append(filename)
-      else:
-        result.append(filename)
-    elif msvs_version and not msvs_version.UsesVcxproj():
-      # For MSVS 2008 and earlier, we need to process all files before walking
-      # the sub folders.
-      if not folders.get(s[0]):
-        folders[s[0]] = []
-      folders[s[0]].append(s[1:])
-    else:
-      contents = _ConvertSourcesToFilterHierarchy([s[1:]], prefix + [s[0]],
-                                                  excluded=excluded,
-                                                  list_excluded=list_excluded,
-                                                  msvs_version=msvs_version)
-      contents = MSVSProject.Filter(s[0], contents=contents)
-      result.append(contents)
-  # Add a folder for excluded files.
-  if excluded_result and list_excluded:
-    excluded_folder = MSVSProject.Filter('_excluded_files',
-                                         contents=excluded_result)
-    result.append(excluded_folder)
-
-  if msvs_version and msvs_version.UsesVcxproj():
+    if not prefix:
+        prefix = []
+    result = []
+    excluded_result = []
+    folders = OrderedDict()
+    # Gather files into the final result, excluded, or folders.
+    for s in sources:
+        if len(s) == 1:
+            filename = _NormalizedSource("\\".join(prefix + s))
+            if filename in excluded:
+                excluded_result.append(filename)
+            else:
+                result.append(filename)
+        elif msvs_version and not msvs_version.UsesVcxproj():
+            # For MSVS 2008 and earlier, we need to process all files before walking
+            # the sub folders.
+            if not folders.get(s[0]):
+                folders[s[0]] = []
+            folders[s[0]].append(s[1:])
+        else:
+            contents = _ConvertSourcesToFilterHierarchy(
+                [s[1:]],
+                prefix + [s[0]],
+                excluded=excluded,
+                list_excluded=list_excluded,
+                msvs_version=msvs_version,
+            )
+            contents = MSVSProject.Filter(s[0], contents=contents)
+            result.append(contents)
+    # Add a folder for excluded files.
+    if excluded_result and list_excluded:
+        excluded_folder = MSVSProject.Filter(
+            "_excluded_files", contents=excluded_result
+        )
+        result.append(excluded_folder)
+
+    if msvs_version and msvs_version.UsesVcxproj():
+        return result
+
+    # Populate all the folders.
+    for f in folders:
+        contents = _ConvertSourcesToFilterHierarchy(
+            folders[f],
+            prefix=prefix + [f],
+            excluded=excluded,
+            list_excluded=list_excluded,
+            msvs_version=msvs_version,
+        )
+        contents = MSVSProject.Filter(f, contents=contents)
+        result.append(contents)
     return result
 
-  # Populate all the folders.
-  for f in folders:
-    contents = _ConvertSourcesToFilterHierarchy(folders[f], prefix=prefix + [f],
-                                                excluded=excluded,
-                                                list_excluded=list_excluded,
-                                                msvs_version=msvs_version)
-    contents = MSVSProject.Filter(f, contents=contents)
-    result.append(contents)
-  return result
-
 
 def _ToolAppend(tools, tool_name, setting, value, only_if_unset=False):
-  if not value: return
-  _ToolSetOrAppend(tools, tool_name, setting, value, only_if_unset)
+    if not value:
+        return
+    _ToolSetOrAppend(tools, tool_name, setting, value, only_if_unset)
 
 
 def _ToolSetOrAppend(tools, tool_name, setting, value, only_if_unset=False):
-  # TODO(bradnelson): ugly hack, fix this more generally!!!
-  if 'Directories' in setting or 'Dependencies' in setting:
-    if type(value) == str:
-      value = value.replace('/', '\\')
-    else:
-      value = [i.replace('/', '\\') for i in value]
-  if not tools.get(tool_name):
-    tools[tool_name] = dict()
-  tool = tools[tool_name]
-  if 'CompileAsWinRT' == setting:
-    return
-  if tool.get(setting):
-    if only_if_unset: return
-    if type(tool[setting]) == list and type(value) == list:
-      tool[setting] += value
+    # TODO(bradnelson): ugly hack, fix this more generally!!!
+    if "Directories" in setting or "Dependencies" in setting:
+        if type(value) == str:
+            value = value.replace("/", "\\")
+        else:
+            value = [i.replace("/", "\\") for i in value]
+    if not tools.get(tool_name):
+        tools[tool_name] = dict()
+    tool = tools[tool_name]
+    if "CompileAsWinRT" == setting:
+        return
+    if tool.get(setting):
+        if only_if_unset:
+            return
+        if type(tool[setting]) == list and type(value) == list:
+            tool[setting] += value
+        else:
+            raise TypeError(
+                'Appending "%s" to a non-list setting "%s" for tool "%s" is '
+                "not allowed, previous value: %s"
+                % (value, setting, tool_name, str(tool[setting]))
+            )
     else:
-      raise TypeError(
-          'Appending "%s" to a non-list setting "%s" for tool "%s" is '
-          'not allowed, previous value: %s' % (
-              value, setting, tool_name, str(tool[setting])))
-  else:
-    tool[setting] = value
+        tool[setting] = value
 
 
 def _ConfigTargetVersion(config_data):
-  return config_data.get('msvs_target_version', 'Windows7')
+    return config_data.get("msvs_target_version", "Windows7")
 
 
 def _ConfigPlatform(config_data):
-  return config_data.get('msvs_configuration_platform', 'Win32')
+    return config_data.get("msvs_configuration_platform", "Win32")
 
 
 def _ConfigBaseName(config_name, platform_name):
-  if config_name.endswith('_' + platform_name):
-    return config_name[0:-len(platform_name) - 1]
-  else:
-    return config_name
+    if config_name.endswith("_" + platform_name):
+        return config_name[0 : -len(platform_name) - 1]
+    else:
+        return config_name
 
 
 def _ConfigFullName(config_name, config_data):
-  platform_name = _ConfigPlatform(config_data)
-  return '%s|%s' % (_ConfigBaseName(config_name, platform_name), platform_name)
+    platform_name = _ConfigPlatform(config_data)
+    return "%s|%s" % (_ConfigBaseName(config_name, platform_name), platform_name)
 
 
 def _ConfigWindowsTargetPlatformVersion(config_data, version):
-  target_ver = config_data.get('msvs_windows_target_platform_version')
-  if target_ver and re.match(r'^\d+', target_ver):
-    return target_ver
-  config_ver = config_data.get('msvs_windows_sdk_version')
-  vers = [config_ver] if config_ver else version.compatible_sdks
-  for ver in vers:
-    for key in [
-      r'HKLM\Software\Microsoft\Microsoft SDKs\Windows\%s',
-      r'HKLM\Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows\%s']:
-      sdk_dir = MSVSVersion._RegistryGetValue(key % ver, 'InstallationFolder')
-      if not sdk_dir:
-        continue
-      version = MSVSVersion._RegistryGetValue(key % ver, 'ProductVersion') or ''
-      # Find a matching entry in sdk_dir\include.
-      expected_sdk_dir=r'%s\include' % sdk_dir
-      names = sorted([x for x in (os.listdir(expected_sdk_dir)
-                                  if os.path.isdir(expected_sdk_dir)
-                                  else []
-                                  )
-                      if x.startswith(version)], reverse=True)
-      if names:
-        return names[0]
-      else:
-        print('Warning: No include files found for detected '
-              'Windows SDK version %s' % (version), file=sys.stdout)
-
-
-def _BuildCommandLineForRuleRaw(spec, cmd, cygwin_shell, has_input_path,
-                                quote_cmd, do_setup_env):
-
-  if [x for x in cmd if '$(InputDir)' in x]:
-    input_dir_preamble = (
-      'set INPUTDIR=$(InputDir)\n'
-      'if NOT DEFINED INPUTDIR set INPUTDIR=.\\\n'
-      'set INPUTDIR=%INPUTDIR:~0,-1%\n'
-      )
-  else:
-    input_dir_preamble = ''
-
-  if cygwin_shell:
-    # Find path to cygwin.
-    cygwin_dir = _FixPath(spec.get('msvs_cygwin_dirs', ['.'])[0])
-    # Prepare command.
-    direct_cmd = cmd
-    direct_cmd = [i.replace('$(IntDir)',
-                            '`cygpath -m "${INTDIR}"`') for i in direct_cmd]
-    direct_cmd = [i.replace('$(OutDir)',
-                            '`cygpath -m "${OUTDIR}"`') for i in direct_cmd]
-    direct_cmd = [i.replace('$(InputDir)',
-                            '`cygpath -m "${INPUTDIR}"`') for i in direct_cmd]
-    if has_input_path:
-      direct_cmd = [i.replace('$(InputPath)',
-                              '`cygpath -m "${INPUTPATH}"`')
-                    for i in direct_cmd]
-    direct_cmd = ['\\"%s\\"' % i.replace('"', '\\\\\\"') for i in direct_cmd]
-    # direct_cmd = gyp.common.EncodePOSIXShellList(direct_cmd)
-    direct_cmd = ' '.join(direct_cmd)
-    # TODO(quote):  regularize quoting path names throughout the module
-    cmd = ''
-    if do_setup_env:
-      cmd += 'call "$(ProjectDir)%(cygwin_dir)s\\setup_env.bat" && '
-    cmd += 'set CYGWIN=nontsec&& '
-    if direct_cmd.find('NUMBER_OF_PROCESSORS') >= 0:
-      cmd += 'set /a NUMBER_OF_PROCESSORS_PLUS_1=%%NUMBER_OF_PROCESSORS%%+1&& '
-    if direct_cmd.find('INTDIR') >= 0:
-      cmd += 'set INTDIR=$(IntDir)&& '
-    if direct_cmd.find('OUTDIR') >= 0:
-      cmd += 'set OUTDIR=$(OutDir)&& '
-    if has_input_path and direct_cmd.find('INPUTPATH') >= 0:
-      cmd += 'set INPUTPATH=$(InputPath) && '
-    cmd += 'bash -c "%(cmd)s"'
-    cmd = cmd % {'cygwin_dir': cygwin_dir,
-                 'cmd': direct_cmd}
-    return input_dir_preamble + cmd
-  else:
-    # Convert cat --> type to mimic unix.
-    if cmd[0] == 'cat':
-      command = ['type']
+    target_ver = config_data.get("msvs_windows_target_platform_version")
+    if target_ver and re.match(r"^\d+", target_ver):
+        return target_ver
+    config_ver = config_data.get("msvs_windows_sdk_version")
+    vers = [config_ver] if config_ver else version.compatible_sdks
+    for ver in vers:
+        for key in [
+            r"HKLM\Software\Microsoft\Microsoft SDKs\Windows\%s",
+            r"HKLM\Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows\%s",
+        ]:
+            sdk_dir = MSVSVersion._RegistryGetValue(key % ver, "InstallationFolder")
+            if not sdk_dir:
+                continue
+            version = MSVSVersion._RegistryGetValue(key % ver, "ProductVersion") or ""
+            # Find a matching entry in sdk_dir\include.
+            expected_sdk_dir = r"%s\include" % sdk_dir
+            names = sorted(
+                [
+                    x
+                    for x in (
+                        os.listdir(expected_sdk_dir)
+                        if os.path.isdir(expected_sdk_dir)
+                        else []
+                    )
+                    if x.startswith(version)
+                ],
+                reverse=True,
+            )
+            if names:
+                return names[0]
+            else:
+                print(
+                    "Warning: No include files found for detected "
+                    "Windows SDK version %s" % (version),
+                    file=sys.stdout,
+                )
+
+
+def _BuildCommandLineForRuleRaw(
+    spec, cmd, cygwin_shell, has_input_path, quote_cmd, do_setup_env
+):
+
+    if [x for x in cmd if "$(InputDir)" in x]:
+        input_dir_preamble = (
+            "set INPUTDIR=$(InputDir)\n"
+            "if NOT DEFINED INPUTDIR set INPUTDIR=.\\\n"
+            "set INPUTDIR=%INPUTDIR:~0,-1%\n"
+        )
     else:
-      command = [cmd[0].replace('/', '\\')]
-    # Add call before command to ensure that commands can be tied together one
-    # after the other without aborting in Incredibuild, since IB makes a bat
-    # file out of the raw command string, and some commands (like python) are
-    # actually batch files themselves.
-    command.insert(0, 'call')
-    # Fix the paths
-    # TODO(quote): This is a really ugly heuristic, and will miss path fixing
-    #              for arguments like "--arg=path" or "/opt:path".
-    # If the argument starts with a slash or dash, it's probably a command line
-    # switch
-    arguments = [i if (i[:1] in "/-") else _FixPath(i) for i in cmd[1:]]
-    arguments = [i.replace('$(InputDir)', '%INPUTDIR%') for i in arguments]
-    arguments = [MSVSSettings.FixVCMacroSlashes(i) for i in arguments]
-    if quote_cmd:
-      # Support a mode for using cmd directly.
-      # Convert any paths to native form (first element is used directly).
-      # TODO(quote):  regularize quoting path names throughout the module
-      arguments = ['"%s"' % i for i in arguments]
-    # Collapse into a single command.
-    return input_dir_preamble + ' '.join(command + arguments)
+        input_dir_preamble = ""
+
+    if cygwin_shell:
+        # Find path to cygwin.
+        cygwin_dir = _FixPath(spec.get("msvs_cygwin_dirs", ["."])[0])
+        # Prepare command.
+        direct_cmd = cmd
+        direct_cmd = [
+            i.replace("$(IntDir)", '`cygpath -m "${INTDIR}"`') for i in direct_cmd
+        ]
+        direct_cmd = [
+            i.replace("$(OutDir)", '`cygpath -m "${OUTDIR}"`') for i in direct_cmd
+        ]
+        direct_cmd = [
+            i.replace("$(InputDir)", '`cygpath -m "${INPUTDIR}"`') for i in direct_cmd
+        ]
+        if has_input_path:
+            direct_cmd = [
+                i.replace("$(InputPath)", '`cygpath -m "${INPUTPATH}"`')
+                for i in direct_cmd
+            ]
+        direct_cmd = ['\\"%s\\"' % i.replace('"', '\\\\\\"') for i in direct_cmd]
+        # direct_cmd = gyp.common.EncodePOSIXShellList(direct_cmd)
+        direct_cmd = " ".join(direct_cmd)
+        # TODO(quote):  regularize quoting path names throughout the module
+        cmd = ""
+        if do_setup_env:
+            cmd += 'call "$(ProjectDir)%(cygwin_dir)s\\setup_env.bat" && '
+        cmd += "set CYGWIN=nontsec&& "
+        if direct_cmd.find("NUMBER_OF_PROCESSORS") >= 0:
+            cmd += "set /a NUMBER_OF_PROCESSORS_PLUS_1=%%NUMBER_OF_PROCESSORS%%+1&& "
+        if direct_cmd.find("INTDIR") >= 0:
+            cmd += "set INTDIR=$(IntDir)&& "
+        if direct_cmd.find("OUTDIR") >= 0:
+            cmd += "set OUTDIR=$(OutDir)&& "
+        if has_input_path and direct_cmd.find("INPUTPATH") >= 0:
+            cmd += "set INPUTPATH=$(InputPath) && "
+        cmd += 'bash -c "%(cmd)s"'
+        cmd = cmd % {"cygwin_dir": cygwin_dir, "cmd": direct_cmd}
+        return input_dir_preamble + cmd
+    else:
+        # Convert cat --> type to mimic unix.
+        if cmd[0] == "cat":
+            command = ["type"]
+        else:
+            command = [cmd[0].replace("/", "\\")]
+        # Add call before command to ensure that commands can be tied together one
+        # after the other without aborting in Incredibuild, since IB makes a bat
+        # file out of the raw command string, and some commands (like python) are
+        # actually batch files themselves.
+        command.insert(0, "call")
+        arguments = [i.replace("$(InputDir)", "%INPUTDIR%") for i in cmd[1:]]
+        arguments = [MSVSSettings.FixVCMacroSlashes(i) for i in arguments]
+        if quote_cmd:
+            # Support a mode for using cmd directly.
+            # Convert any paths to native form (first element is used directly).
+            # TODO(quote):  regularize quoting path names throughout the module
+            arguments = ['"%s"' % i for i in arguments]
+        # Collapse into a single command.
+        return input_dir_preamble + " ".join(command + arguments)
 
 
 def _BuildCommandLineForRule(spec, rule, has_input_path, do_setup_env):
-  # Currently this weird argument munging is used to duplicate the way a
-  # python script would need to be run as part of the chrome tree.
-  # Eventually we should add some sort of rule_default option to set this
-  # per project. For now the behavior chrome needs is the default.
-  mcs = rule.get('msvs_cygwin_shell')
-  if mcs is None:
-    mcs = int(spec.get('msvs_cygwin_shell', 1))
-  elif isinstance(mcs, str):
-    mcs = int(mcs)
-  quote_cmd = int(rule.get('msvs_quote_cmd', 1))
-  return _BuildCommandLineForRuleRaw(spec, rule['action'], mcs, has_input_path,
-                                     quote_cmd, do_setup_env=do_setup_env)
+    # Currently this weird argument munging is used to duplicate the way a
+    # python script would need to be run as part of the chrome tree.
+    # Eventually we should add some sort of rule_default option to set this
+    # per project. For now the behavior chrome needs is the default.
+    mcs = rule.get("msvs_cygwin_shell")
+    if mcs is None:
+        mcs = int(spec.get("msvs_cygwin_shell", 1))
+    elif isinstance(mcs, str):
+        mcs = int(mcs)
+    quote_cmd = int(rule.get("msvs_quote_cmd", 1))
+    return _BuildCommandLineForRuleRaw(
+        spec, rule["action"], mcs, has_input_path, quote_cmd, do_setup_env=do_setup_env
+    )
 
 
 def _AddActionStep(actions_dict, inputs, outputs, description, command):
-  """Merge action into an existing list of actions.
+    """Merge action into an existing list of actions.
 
   Care must be taken so that actions which have overlapping inputs either don't
   get assigned to the same input, or get collapsed into one.
@@ -434,30 +464,31 @@ def _AddActionStep(actions_dict, inputs, outputs, description, command):
     description: description of the action
     command: command line to execute
   """
-  # Require there to be at least one input (call sites will ensure this).
-  assert inputs
-
-  action = {
-      'inputs': inputs,
-      'outputs': outputs,
-      'description': description,
-      'command': command,
-  }
+    # Require there to be at least one input (call sites will ensure this).
+    assert inputs
+
+    action = {
+        "inputs": inputs,
+        "outputs": outputs,
+        "description": description,
+        "command": command,
+    }
 
-  # Pick where to stick this action.
-  # While less than optimal in terms of build time, attach them to the first
-  # input for now.
-  chosen_input = inputs[0]
+    # Pick where to stick this action.
+    # While less than optimal in terms of build time, attach them to the first
+    # input for now.
+    chosen_input = inputs[0]
 
-  # Add it there.
-  if chosen_input not in actions_dict:
-    actions_dict[chosen_input] = []
-  actions_dict[chosen_input].append(action)
+    # Add it there.
+    if chosen_input not in actions_dict:
+        actions_dict[chosen_input] = []
+    actions_dict[chosen_input].append(action)
 
 
-def _AddCustomBuildToolForMSVS(p, spec, primary_input,
-                               inputs, outputs, description, cmd):
-  """Add a custom build tool to execute something.
+def _AddCustomBuildToolForMSVS(
+    p, spec, primary_input, inputs, outputs, description, cmd
+):
+    """Add a custom build tool to execute something.
 
   Arguments:
     p: the target project
@@ -468,23 +499,26 @@ def _AddCustomBuildToolForMSVS(p, spec, primary_input,
     description: description of the action
     cmd: command line to execute
   """
-  inputs = _FixPaths(inputs)
-  outputs = _FixPaths(outputs)
-  tool = MSVSProject.Tool(
-      'VCCustomBuildTool',
-      {'Description': description,
-       'AdditionalDependencies': ';'.join(inputs),
-       'Outputs': ';'.join(outputs),
-       'CommandLine': cmd,
-      })
-  # Add to the properties of primary input for each config.
-  for config_name, c_data in spec['configurations'].items():
-    p.AddFileConfig(_FixPath(primary_input),
-                    _ConfigFullName(config_name, c_data), tools=[tool])
+    inputs = _FixPaths(inputs)
+    outputs = _FixPaths(outputs)
+    tool = MSVSProject.Tool(
+        "VCCustomBuildTool",
+        {
+            "Description": description,
+            "AdditionalDependencies": ";".join(inputs),
+            "Outputs": ";".join(outputs),
+            "CommandLine": cmd,
+        },
+    )
+    # Add to the properties of primary input for each config.
+    for config_name, c_data in spec["configurations"].items():
+        p.AddFileConfig(
+            _FixPath(primary_input), _ConfigFullName(config_name, c_data), tools=[tool]
+        )
 
 
 def _AddAccumulatedActionsToMSVS(p, spec, actions_dict):
-  """Add actions accumulated into an actions_dict, merging as needed.
+    """Add actions accumulated into an actions_dict, merging as needed.
 
   Arguments:
     p: the target project
@@ -492,29 +526,32 @@ def _AddAccumulatedActionsToMSVS(p, spec, actions_dict):
     actions_dict: dictionary keyed on input name, which maps to a list of
         dicts describing the actions attached to that input file.
   """
-  for primary_input in actions_dict:
-    inputs = OrderedSet()
-    outputs = OrderedSet()
-    descriptions = []
-    commands = []
-    for action in actions_dict[primary_input]:
-      inputs.update(OrderedSet(action['inputs']))
-      outputs.update(OrderedSet(action['outputs']))
-      descriptions.append(action['description'])
-      commands.append(action['command'])
-    # Add the custom build step for one input file.
-    description = ', and also '.join(descriptions)
-    command = '\r\n'.join(commands)
-    _AddCustomBuildToolForMSVS(p, spec,
-                               primary_input=primary_input,
-                               inputs=inputs,
-                               outputs=outputs,
-                               description=description,
-                               cmd=command)
+    for primary_input in actions_dict:
+        inputs = OrderedSet()
+        outputs = OrderedSet()
+        descriptions = []
+        commands = []
+        for action in actions_dict[primary_input]:
+            inputs.update(OrderedSet(action["inputs"]))
+            outputs.update(OrderedSet(action["outputs"]))
+            descriptions.append(action["description"])
+            commands.append(action["command"])
+        # Add the custom build step for one input file.
+        description = ", and also ".join(descriptions)
+        command = "\r\n".join(commands)
+        _AddCustomBuildToolForMSVS(
+            p,
+            spec,
+            primary_input=primary_input,
+            inputs=inputs,
+            outputs=outputs,
+            description=description,
+            cmd=command,
+        )
 
 
 def _RuleExpandPath(path, input_file):
-  """Given the input file to which a rule applied, string substitute a path.
+    """Given the input file to which a rule applied, string substitute a path.
 
   Arguments:
     path: a path to string expand
@@ -522,18 +559,20 @@ def _RuleExpandPath(path, input_file):
   Returns:
     The string substituted path.
   """
-  path = path.replace('$(InputName)',
-                      os.path.splitext(os.path.split(input_file)[1])[0])
-  path = path.replace('$(InputDir)', os.path.dirname(input_file))
-  path = path.replace('$(InputExt)',
-                      os.path.splitext(os.path.split(input_file)[1])[1])
-  path = path.replace('$(InputFileName)', os.path.split(input_file)[1])
-  path = path.replace('$(InputPath)', input_file)
-  return path
+    path = path.replace(
+        "$(InputName)", os.path.splitext(os.path.split(input_file)[1])[0]
+    )
+    path = path.replace("$(InputDir)", os.path.dirname(input_file))
+    path = path.replace(
+        "$(InputExt)", os.path.splitext(os.path.split(input_file)[1])[1]
+    )
+    path = path.replace("$(InputFileName)", os.path.split(input_file)[1])
+    path = path.replace("$(InputPath)", input_file)
+    return path
 
 
 def _FindRuleTriggerFiles(rule, sources):
-  """Find the list of files which a particular rule applies to.
+    """Find the list of files which a particular rule applies to.
 
   Arguments:
     rule: the rule in question
@@ -541,11 +580,11 @@ def _FindRuleTriggerFiles(rule, sources):
   Returns:
     The list of sources that trigger a particular rule.
   """
-  return rule.get('rule_sources', [])
+    return rule.get("rule_sources", [])
 
 
 def _RuleInputsAndOutputs(rule, trigger_file):
-  """Find the inputs and outputs generated by a rule.
+    """Find the inputs and outputs generated by a rule.
 
   Arguments:
     rule: the rule in question.
@@ -553,20 +592,20 @@ def _RuleInputsAndOutputs(rule, trigger_file):
   Returns:
     The pair of (inputs, outputs) involved in this rule.
   """
-  raw_inputs = _FixPaths(rule.get('inputs', []))
-  raw_outputs = _FixPaths(rule.get('outputs', []))
-  inputs = OrderedSet()
-  outputs = OrderedSet()
-  inputs.add(trigger_file)
-  for i in raw_inputs:
-    inputs.add(_RuleExpandPath(i, trigger_file))
-  for o in raw_outputs:
-    outputs.add(_RuleExpandPath(o, trigger_file))
-  return (inputs, outputs)
+    raw_inputs = _FixPaths(rule.get("inputs", []))
+    raw_outputs = _FixPaths(rule.get("outputs", []))
+    inputs = OrderedSet()
+    outputs = OrderedSet()
+    inputs.add(trigger_file)
+    for i in raw_inputs:
+        inputs.add(_RuleExpandPath(i, trigger_file))
+    for o in raw_outputs:
+        outputs.add(_RuleExpandPath(o, trigger_file))
+    return (inputs, outputs)
 
 
 def _GenerateNativeRulesForMSVS(p, rules, output_dir, spec, options):
-  """Generate a native rules file.
+    """Generate a native rules file.
 
   Arguments:
     p: the target project
@@ -575,43 +614,43 @@ def _GenerateNativeRulesForMSVS(p, rules, output_dir, spec, options):
     spec: the project dict
     options: global generator options
   """
-  rules_filename = '%s%s.rules' % (spec['target_name'],
-                                   options.suffix)
-  rules_file = MSVSToolFile.Writer(os.path.join(output_dir, rules_filename),
-                                   spec['target_name'])
-  # Add each rule.
-  for r in rules:
-    rule_name = r['rule_name']
-    rule_ext = r['extension']
-    inputs = _FixPaths(r.get('inputs', []))
-    outputs = _FixPaths(r.get('outputs', []))
-    # Skip a rule with no action and no inputs.
-    if 'action' not in r and not r.get('rule_sources', []):
-      continue
-    cmd = _BuildCommandLineForRule(spec, r, has_input_path=True,
-                                   do_setup_env=True)
-    rules_file.AddCustomBuildRule(name=rule_name,
-                                  description=r.get('message', rule_name),
-                                  extensions=[rule_ext],
-                                  additional_dependencies=inputs,
-                                  outputs=outputs,
-                                  cmd=cmd)
-  # Write out rules file.
-  rules_file.WriteIfChanged()
-
-  # Add rules file to project.
-  p.AddToolFile(rules_filename)
+    rules_filename = "%s%s.rules" % (spec["target_name"], options.suffix)
+    rules_file = MSVSToolFile.Writer(
+        os.path.join(output_dir, rules_filename), spec["target_name"]
+    )
+    # Add each rule.
+    for r in rules:
+        rule_name = r["rule_name"]
+        rule_ext = r["extension"]
+        inputs = _FixPaths(r.get("inputs", []))
+        outputs = _FixPaths(r.get("outputs", []))
+        # Skip a rule with no action and no inputs.
+        if "action" not in r and not r.get("rule_sources", []):
+            continue
+        cmd = _BuildCommandLineForRule(spec, r, has_input_path=True, do_setup_env=True)
+        rules_file.AddCustomBuildRule(
+            name=rule_name,
+            description=r.get("message", rule_name),
+            extensions=[rule_ext],
+            additional_dependencies=inputs,
+            outputs=outputs,
+            cmd=cmd,
+        )
+    # Write out rules file.
+    rules_file.WriteIfChanged()
+
+    # Add rules file to project.
+    p.AddToolFile(rules_filename)
 
 
 def _Cygwinify(path):
-  path = path.replace('$(OutDir)', '$(OutDirCygwin)')
-  path = path.replace('$(IntDir)', '$(IntDirCygwin)')
-  return path
+    path = path.replace("$(OutDir)", "$(OutDirCygwin)")
+    path = path.replace("$(IntDir)", "$(IntDirCygwin)")
+    return path
 
 
-def _GenerateExternalRules(rules, output_dir, spec,
-                           sources, options, actions_to_add):
-  """Generate an external makefile to do a set of rules.
+def _GenerateExternalRules(rules, output_dir, spec, sources, options, actions_to_add):
+    """Generate an external makefile to do a set of rules.
 
   Arguments:
     rules: the list of rules to include
@@ -621,77 +660,82 @@ def _GenerateExternalRules(rules, output_dir, spec,
     options: global generator options
     actions_to_add: The list of actions we will add to.
   """
-  filename = '%s_rules%s.mk' % (spec['target_name'], options.suffix)
-  mk_file = gyp.common.WriteOnDiff(os.path.join(output_dir, filename))
-  # Find cygwin style versions of some paths.
-  mk_file.write('OutDirCygwin:=$(shell cygpath -u "$(OutDir)")\n')
-  mk_file.write('IntDirCygwin:=$(shell cygpath -u "$(IntDir)")\n')
-  # Gather stuff needed to emit all: target.
-  all_inputs = OrderedSet()
-  all_outputs = OrderedSet()
-  all_output_dirs = OrderedSet()
-  first_outputs = []
-  for rule in rules:
-    trigger_files = _FindRuleTriggerFiles(rule, sources)
-    for tf in trigger_files:
-      inputs, outputs = _RuleInputsAndOutputs(rule, tf)
-      all_inputs.update(OrderedSet(inputs))
-      all_outputs.update(OrderedSet(outputs))
-      # Only use one target from each rule as the dependency for
-      # 'all' so we don't try to build each rule multiple times.
-      first_outputs.append(list(outputs)[0])
-      # Get the unique output directories for this rule.
-      output_dirs = [os.path.split(i)[0] for i in outputs]
-      for od in output_dirs:
-        all_output_dirs.add(od)
-  first_outputs_cyg = [_Cygwinify(i) for i in first_outputs]
-  # Write out all: target, including mkdir for each output directory.
-  mk_file.write('all: %s\n' % ' '.join(first_outputs_cyg))
-  for od in all_output_dirs:
-    if od:
-      mk_file.write('\tmkdir -p `cygpath -u "%s"`\n' % od)
-  mk_file.write('\n')
-  # Define how each output is generated.
-  for rule in rules:
-    trigger_files = _FindRuleTriggerFiles(rule, sources)
-    for tf in trigger_files:
-      # Get all the inputs and outputs for this rule for this trigger file.
-      inputs, outputs = _RuleInputsAndOutputs(rule, tf)
-      inputs = [_Cygwinify(i) for i in inputs]
-      outputs = [_Cygwinify(i) for i in outputs]
-      # Prepare the command line for this rule.
-      cmd = [_RuleExpandPath(c, tf) for c in rule['action']]
-      cmd = ['"%s"' % i for i in cmd]
-      cmd = ' '.join(cmd)
-      # Add it to the makefile.
-      mk_file.write('%s: %s\n' % (' '.join(outputs), ' '.join(inputs)))
-      mk_file.write('\t%s\n\n' % cmd)
-  # Close up the file.
-  mk_file.close()
-
-  # Add makefile to list of sources.
-  sources.add(filename)
-  # Add a build action to call makefile.
-  cmd = ['make',
-         'OutDir=$(OutDir)',
-         'IntDir=$(IntDir)',
-         '-j', '${NUMBER_OF_PROCESSORS_PLUS_1}',
-         '-f', filename]
-  cmd = _BuildCommandLineForRuleRaw(spec, cmd, True, False, True, True)
-  # Insert makefile as 0'th input, so it gets the action attached there,
-  # as this is easier to understand from in the IDE.
-  all_inputs = list(all_inputs)
-  all_inputs.insert(0, filename)
-  _AddActionStep(actions_to_add,
-                 inputs=_FixPaths(all_inputs),
-                 outputs=_FixPaths(all_outputs),
-                 description='Running external rules for %s' %
-                     spec['target_name'],
-                 command=cmd)
+    filename = "%s_rules%s.mk" % (spec["target_name"], options.suffix)
+    mk_file = gyp.common.WriteOnDiff(os.path.join(output_dir, filename))
+    # Find cygwin style versions of some paths.
+    mk_file.write('OutDirCygwin:=$(shell cygpath -u "$(OutDir)")\n')
+    mk_file.write('IntDirCygwin:=$(shell cygpath -u "$(IntDir)")\n')
+    # Gather stuff needed to emit all: target.
+    all_inputs = OrderedSet()
+    all_outputs = OrderedSet()
+    all_output_dirs = OrderedSet()
+    first_outputs = []
+    for rule in rules:
+        trigger_files = _FindRuleTriggerFiles(rule, sources)
+        for tf in trigger_files:
+            inputs, outputs = _RuleInputsAndOutputs(rule, tf)
+            all_inputs.update(OrderedSet(inputs))
+            all_outputs.update(OrderedSet(outputs))
+            # Only use one target from each rule as the dependency for
+            # 'all' so we don't try to build each rule multiple times.
+            first_outputs.append(list(outputs)[0])
+            # Get the unique output directories for this rule.
+            output_dirs = [os.path.split(i)[0] for i in outputs]
+            for od in output_dirs:
+                all_output_dirs.add(od)
+    first_outputs_cyg = [_Cygwinify(i) for i in first_outputs]
+    # Write out all: target, including mkdir for each output directory.
+    mk_file.write("all: %s\n" % " ".join(first_outputs_cyg))
+    for od in all_output_dirs:
+        if od:
+            mk_file.write('\tmkdir -p `cygpath -u "%s"`\n' % od)
+    mk_file.write("\n")
+    # Define how each output is generated.
+    for rule in rules:
+        trigger_files = _FindRuleTriggerFiles(rule, sources)
+        for tf in trigger_files:
+            # Get all the inputs and outputs for this rule for this trigger file.
+            inputs, outputs = _RuleInputsAndOutputs(rule, tf)
+            inputs = [_Cygwinify(i) for i in inputs]
+            outputs = [_Cygwinify(i) for i in outputs]
+            # Prepare the command line for this rule.
+            cmd = [_RuleExpandPath(c, tf) for c in rule["action"]]
+            cmd = ['"%s"' % i for i in cmd]
+            cmd = " ".join(cmd)
+            # Add it to the makefile.
+            mk_file.write("%s: %s\n" % (" ".join(outputs), " ".join(inputs)))
+            mk_file.write("\t%s\n\n" % cmd)
+    # Close up the file.
+    mk_file.close()
+
+    # Add makefile to list of sources.
+    sources.add(filename)
+    # Add a build action to call makefile.
+    cmd = [
+        "make",
+        "OutDir=$(OutDir)",
+        "IntDir=$(IntDir)",
+        "-j",
+        "${NUMBER_OF_PROCESSORS_PLUS_1}",
+        "-f",
+        filename,
+    ]
+    cmd = _BuildCommandLineForRuleRaw(spec, cmd, True, False, True, True)
+    # Insert makefile as 0'th input, so it gets the action attached there,
+    # as this is easier to understand from in the IDE.
+    all_inputs = list(all_inputs)
+    all_inputs.insert(0, filename)
+    _AddActionStep(
+        actions_to_add,
+        inputs=_FixPaths(all_inputs),
+        outputs=_FixPaths(all_outputs),
+        description="Running external rules for %s" % spec["target_name"],
+        command=cmd,
+    )
 
 
 def _EscapeEnvironmentVariableExpansion(s):
-  """Escapes % characters.
+    """Escapes % characters.
 
   Escapes any % characters so that Windows-style environment variable
   expansions will leave them alone.
@@ -703,16 +747,16 @@ def _EscapeEnvironmentVariableExpansion(s):
 
   Returns:
       The escaped string.
-  """
-  s = s.replace('%', '%%')
-  return s
+  """  # noqa: E731,E123,E501
+    s = s.replace("%", "%%")
+    return s
 
 
 quote_replacer_regex = re.compile(r'(\\*)"')
 
 
 def _EscapeCommandLineArgumentForMSVS(s):
-  """Escapes a Windows command-line argument.
+    """Escapes a Windows command-line argument.
 
   So that the Win32 CommandLineToArgv function will turn the escaped result back
   into the original string.
@@ -726,24 +770,24 @@ def _EscapeCommandLineArgumentForMSVS(s):
       the escaped string.
   """
 
-  def _Replace(match):
-    # For a literal quote, CommandLineToArgv requires an odd number of
-    # backslashes preceding it, and it produces half as many literal backslashes
-    # (rounded down). So we need to produce 2n+1 backslashes.
-    return 2 * match.group(1) + '\\"'
+    def _Replace(match):
+        # For a literal quote, CommandLineToArgv requires an odd number of
+        # backslashes preceding it, and it produces half as many literal backslashes
+        # (rounded down). So we need to produce 2n+1 backslashes.
+        return 2 * match.group(1) + '\\"'
 
-  # Escape all quotes so that they are interpreted literally.
-  s = quote_replacer_regex.sub(_Replace, s)
-  # Now add unescaped quotes so that any whitespace is interpreted literally.
-  s = '"' + s + '"'
-  return s
+    # Escape all quotes so that they are interpreted literally.
+    s = quote_replacer_regex.sub(_Replace, s)
+    # Now add unescaped quotes so that any whitespace is interpreted literally.
+    s = '"' + s + '"'
+    return s
 
 
-delimiters_replacer_regex = re.compile(r'(\\*)([,;]+)')
+delimiters_replacer_regex = re.compile(r"(\\*)([,;]+)")
 
 
 def _EscapeVCProjCommandLineArgListItem(s):
-  """Escapes command line arguments for MSVS.
+    """Escapes command line arguments for MSVS.
 
   The VCProj format stores string lists in a single string using commas and
   semi-colons as separators, which must be quoted if they are to be
@@ -764,85 +808,87 @@ def _EscapeVCProjCommandLineArgListItem(s):
       the escaped string.
   """
 
-  def _Replace(match):
-    # For a non-literal quote, CommandLineToArgv requires an even number of
-    # backslashes preceding it, and it produces half as many literal
-    # backslashes. So we need to produce 2n backslashes.
-    return 2 * match.group(1) + '"' + match.group(2) + '"'
-
-  segments = s.split('"')
-  # The unquoted segments are at the even-numbered indices.
-  for i in range(0, len(segments), 2):
-    segments[i] = delimiters_replacer_regex.sub(_Replace, segments[i])
-  # Concatenate back into a single string
-  s = '"'.join(segments)
-  if len(segments) % 2 == 0:
-    # String ends while still quoted according to VCProj's convention. This
-    # means the delimiter and the next list item that follow this one in the
-    # .vcproj file will be misinterpreted as part of this item. There is nothing
-    # we can do about this. Adding an extra quote would correct the problem in
-    # the VCProj but cause the same problem on the final command-line. Moving
-    # the item to the end of the list does works, but that's only possible if
-    # there's only one such item. Let's just warn the user.
-    print('Warning: MSVS may misinterpret the odd number of ' +
-                          'quotes in ' + s, file=sys.stderr)
-  return s
+    def _Replace(match):
+        # For a non-literal quote, CommandLineToArgv requires an even number of
+        # backslashes preceding it, and it produces half as many literal
+        # backslashes. So we need to produce 2n backslashes.
+        return 2 * match.group(1) + '"' + match.group(2) + '"'
+
+    segments = s.split('"')
+    # The unquoted segments are at the even-numbered indices.
+    for i in range(0, len(segments), 2):
+        segments[i] = delimiters_replacer_regex.sub(_Replace, segments[i])
+    # Concatenate back into a single string
+    s = '"'.join(segments)
+    if len(segments) % 2 == 0:
+        # String ends while still quoted according to VCProj's convention. This
+        # means the delimiter and the next list item that follow this one in the
+        # .vcproj file will be misinterpreted as part of this item. There is nothing
+        # we can do about this. Adding an extra quote would correct the problem in
+        # the VCProj but cause the same problem on the final command-line. Moving
+        # the item to the end of the list does works, but that's only possible if
+        # there's only one such item. Let's just warn the user.
+        print(
+            "Warning: MSVS may misinterpret the odd number of " + "quotes in " + s,
+            file=sys.stderr,
+        )
+    return s
 
 
 def _EscapeCppDefineForMSVS(s):
-  """Escapes a CPP define so that it will reach the compiler unaltered."""
-  s = _EscapeEnvironmentVariableExpansion(s)
-  s = _EscapeCommandLineArgumentForMSVS(s)
-  s = _EscapeVCProjCommandLineArgListItem(s)
-  # cl.exe replaces literal # characters with = in preprocesor definitions for
-  # some reason. Octal-encode to work around that.
-  s = s.replace('#', '\\%03o' % ord('#'))
-  return s
+    """Escapes a CPP define so that it will reach the compiler unaltered."""
+    s = _EscapeEnvironmentVariableExpansion(s)
+    s = _EscapeCommandLineArgumentForMSVS(s)
+    s = _EscapeVCProjCommandLineArgListItem(s)
+    # cl.exe replaces literal # characters with = in preprocessor definitions for
+    # some reason. Octal-encode to work around that.
+    s = s.replace("#", "\\%03o" % ord("#"))
+    return s
 
 
 quote_replacer_regex2 = re.compile(r'(\\+)"')
 
 
 def _EscapeCommandLineArgumentForMSBuild(s):
-  """Escapes a Windows command-line argument for use by MSBuild."""
+    """Escapes a Windows command-line argument for use by MSBuild."""
 
-  def _Replace(match):
-    return (len(match.group(1)) / 2 * 4) * '\\' + '\\"'
+    def _Replace(match):
+        return (len(match.group(1)) / 2 * 4) * "\\" + '\\"'
 
-  # Escape all quotes so that they are interpreted literally.
-  s = quote_replacer_regex2.sub(_Replace, s)
-  return s
+    # Escape all quotes so that they are interpreted literally.
+    s = quote_replacer_regex2.sub(_Replace, s)
+    return s
 
 
 def _EscapeMSBuildSpecialCharacters(s):
-  escape_dictionary = {
-      '%': '%25',
-      '$': '%24',
-      '@': '%40',
-      "'": '%27',
-      ';': '%3B',
-      '?': '%3F',
-      '*': '%2A'
-      }
-  result = ''.join([escape_dictionary.get(c, c) for c in s])
-  return result
+    escape_dictionary = {
+        "%": "%25",
+        "$": "%24",
+        "@": "%40",
+        "'": "%27",
+        ";": "%3B",
+        "?": "%3F",
+        "*": "%2A",
+    }
+    result = "".join([escape_dictionary.get(c, c) for c in s])
+    return result
 
 
 def _EscapeCppDefineForMSBuild(s):
-  """Escapes a CPP define so that it will reach the compiler unaltered."""
-  s = _EscapeEnvironmentVariableExpansion(s)
-  s = _EscapeCommandLineArgumentForMSBuild(s)
-  s = _EscapeMSBuildSpecialCharacters(s)
-  # cl.exe replaces literal # characters with = in preprocesor definitions for
-  # some reason. Octal-encode to work around that.
-  s = s.replace('#', '\\%03o' % ord('#'))
-  return s
+    """Escapes a CPP define so that it will reach the compiler unaltered."""
+    s = _EscapeEnvironmentVariableExpansion(s)
+    s = _EscapeCommandLineArgumentForMSBuild(s)
+    s = _EscapeMSBuildSpecialCharacters(s)
+    # cl.exe replaces literal # characters with = in preprocessor definitions for
+    # some reason. Octal-encode to work around that.
+    s = s.replace("#", "\\%03o" % ord("#"))
+    return s
 
 
-def _GenerateRulesForMSVS(p, output_dir, options, spec,
-                          sources, excluded_sources,
-                          actions_to_add):
-  """Generate all the rules for a particular project.
+def _GenerateRulesForMSVS(
+    p, output_dir, options, spec, sources, excluded_sources, actions_to_add
+):
+    """Generate all the rules for a particular project.
 
   Arguments:
     p: the project
@@ -853,45 +899,46 @@ def _GenerateRulesForMSVS(p, output_dir, options, spec,
     excluded_sources: the set of sources excluded from normal processing
     actions_to_add: deferred list of actions to add in
   """
-  rules = spec.get('rules', [])
-  rules_native = [r for r in rules if not int(r.get('msvs_external_rule', 0))]
-  rules_external = [r for r in rules if int(r.get('msvs_external_rule', 0))]
+    rules = spec.get("rules", [])
+    rules_native = [r for r in rules if not int(r.get("msvs_external_rule", 0))]
+    rules_external = [r for r in rules if int(r.get("msvs_external_rule", 0))]
 
-  # Handle rules that use a native rules file.
-  if rules_native:
-    _GenerateNativeRulesForMSVS(p, rules_native, output_dir, spec, options)
+    # Handle rules that use a native rules file.
+    if rules_native:
+        _GenerateNativeRulesForMSVS(p, rules_native, output_dir, spec, options)
 
-  # Handle external rules (non-native rules).
-  if rules_external:
-    _GenerateExternalRules(rules_external, output_dir, spec,
-                           sources, options, actions_to_add)
-  _AdjustSourcesForRules(rules, sources, excluded_sources, False)
+    # Handle external rules (non-native rules).
+    if rules_external:
+        _GenerateExternalRules(
+            rules_external, output_dir, spec, sources, options, actions_to_add
+        )
+    _AdjustSourcesForRules(rules, sources, excluded_sources, False)
 
 
 def _AdjustSourcesForRules(rules, sources, excluded_sources, is_msbuild):
-  # Add outputs generated by each rule (if applicable).
-  for rule in rules:
-    # Add in the outputs from this rule.
-    trigger_files = _FindRuleTriggerFiles(rule, sources)
-    for trigger_file in trigger_files:
-      # Remove trigger_file from excluded_sources to let the rule be triggered
-      # (e.g. rule trigger ax_enums.idl is added to excluded_sources
-      # because it's also in an action's inputs in the same project)
-      excluded_sources.discard(_FixPath(trigger_file))
-      # Done if not processing outputs as sources.
-      if int(rule.get('process_outputs_as_sources', False)):
-        inputs, outputs = _RuleInputsAndOutputs(rule, trigger_file)
-        inputs = OrderedSet(_FixPaths(inputs))
-        outputs = OrderedSet(_FixPaths(outputs))
-        inputs.remove(_FixPath(trigger_file))
-        sources.update(inputs)
-        if not is_msbuild:
-          excluded_sources.update(inputs)
-        sources.update(outputs)
+    # Add outputs generated by each rule (if applicable).
+    for rule in rules:
+        # Add in the outputs from this rule.
+        trigger_files = _FindRuleTriggerFiles(rule, sources)
+        for trigger_file in trigger_files:
+            # Remove trigger_file from excluded_sources to let the rule be triggered
+            # (e.g. rule trigger ax_enums.idl is added to excluded_sources
+            # because it's also in an action's inputs in the same project)
+            excluded_sources.discard(_FixPath(trigger_file))
+            # Done if not processing outputs as sources.
+            if int(rule.get("process_outputs_as_sources", False)):
+                inputs, outputs = _RuleInputsAndOutputs(rule, trigger_file)
+                inputs = OrderedSet(_FixPaths(inputs))
+                outputs = OrderedSet(_FixPaths(outputs))
+                inputs.remove(_FixPath(trigger_file))
+                sources.update(inputs)
+                if not is_msbuild:
+                    excluded_sources.update(inputs)
+                sources.update(outputs)
 
 
 def _FilterActionsFromExcluded(excluded_sources, actions_to_add):
-  """Take inputs with actions attached out of the list of exclusions.
+    """Take inputs with actions attached out of the list of exclusions.
 
   Arguments:
     excluded_sources: list of source files not to be built.
@@ -899,16 +946,16 @@ def _FilterActionsFromExcluded(excluded_sources, actions_to_add):
   Returns:
     excluded_sources with files that have actions attached removed.
   """
-  must_keep = OrderedSet(_FixPaths(actions_to_add.keys()))
-  return [s for s in excluded_sources if s not in must_keep]
+    must_keep = OrderedSet(_FixPaths(actions_to_add.keys()))
+    return [s for s in excluded_sources if s not in must_keep]
 
 
 def _GetDefaultConfiguration(spec):
-  return spec['configurations'][spec['default_configuration']]
+    return spec["configurations"][spec["default_configuration"]]
 
 
 def _GetGuidOfProject(proj_path, spec):
-  """Get the guid for the project.
+    """Get the guid for the project.
 
   Arguments:
     proj_path: Path of the vcproj or vcxproj file to generate.
@@ -918,21 +965,23 @@ def _GetGuidOfProject(proj_path, spec):
   Raises:
     ValueError: if the specified GUID is invalid.
   """
-  # Pluck out the default configuration.
-  default_config = _GetDefaultConfiguration(spec)
-  # Decide the guid of the project.
-  guid = default_config.get('msvs_guid')
-  if guid:
-    if VALID_MSVS_GUID_CHARS.match(guid) is None:
-      raise ValueError('Invalid MSVS guid: "%s".  Must match regex: "%s".' %
-                       (guid, VALID_MSVS_GUID_CHARS.pattern))
-    guid = '{%s}' % guid
-  guid = guid or MSVSNew.MakeGuid(proj_path)
-  return guid
+    # Pluck out the default configuration.
+    default_config = _GetDefaultConfiguration(spec)
+    # Decide the guid of the project.
+    guid = default_config.get("msvs_guid")
+    if guid:
+        if VALID_MSVS_GUID_CHARS.match(guid) is None:
+            raise ValueError(
+                'Invalid MSVS guid: "%s".  Must match regex: "%s".'
+                % (guid, VALID_MSVS_GUID_CHARS.pattern)
+            )
+        guid = "{%s}" % guid
+    guid = guid or MSVSNew.MakeGuid(proj_path)
+    return guid
 
 
 def _GetMsbuildToolsetOfProject(proj_path, spec, version):
-  """Get the platform toolset for the project.
+    """Get the platform toolset for the project.
 
   Arguments:
     proj_path: Path of the vcproj or vcxproj file to generate.
@@ -941,18 +990,18 @@ def _GetMsbuildToolsetOfProject(proj_path, spec, version):
   Returns:
     the platform toolset string or None.
   """
-  # Pluck out the default configuration.
-  default_config = _GetDefaultConfiguration(spec)
-  toolset = default_config.get('msbuild_toolset')
-  if not toolset and version.DefaultToolset():
-    toolset = version.DefaultToolset()
-  if spec['type'] == 'windows_driver':
-    toolset = 'WindowsKernelModeDriver10.0'
-  return toolset
+    # Pluck out the default configuration.
+    default_config = _GetDefaultConfiguration(spec)
+    toolset = default_config.get("msbuild_toolset")
+    if not toolset and version.DefaultToolset():
+        toolset = version.DefaultToolset()
+    if spec["type"] == "windows_driver":
+        toolset = "WindowsKernelModeDriver10.0"
+    return toolset
 
 
-def _GenerateProject(project, options, version, generator_flags):
-  """Generates a vcproj file.
+def _GenerateProject(project, options, version, generator_flags, spec):
+    """Generates a vcproj file.
 
   Arguments:
     project: the MSVSProject object.
@@ -962,56 +1011,20 @@ def _GenerateProject(project, options, version, generator_flags):
   Returns:
     A list of source files that cannot be found on disk.
   """
-  default_config = _GetDefaultConfiguration(project.spec)
-
-  # Skip emitting anything if told to with msvs_existing_vcproj option.
-  if default_config.get('msvs_existing_vcproj'):
-    return []
-
-  if version.UsesVcxproj():
-    return _GenerateMSBuildProject(project, options, version, generator_flags)
-  else:
-    return _GenerateMSVSProject(project, options, version, generator_flags)
+    default_config = _GetDefaultConfiguration(project.spec)
 
+    # Skip emitting anything if told to with msvs_existing_vcproj option.
+    if default_config.get("msvs_existing_vcproj"):
+        return []
 
-# TODO: Avoid code duplication with _ValidateSourcesForOSX in make.py.
-def _ValidateSourcesForMSVSProject(spec, version):
-  """Makes sure if duplicate basenames are not specified in the source list.
-
-  Arguments:
-    spec: The target dictionary containing the properties of the target.
-    version: The VisualStudioVersion object.
-  """
-  # This validation should not be applied to MSVC2010 and later.
-  assert not version.UsesVcxproj()
-
-  # TODO: Check if MSVC allows this for loadable_module targets.
-  if spec.get('type', None) not in ('static_library', 'shared_library'):
-    return
-  sources = spec.get('sources', [])
-  basenames = {}
-  for source in sources:
-    name, ext = os.path.splitext(source)
-    is_compiled_file = ext in [
-        '.c', '.cc', '.cpp', '.cxx', '.m', '.mm', '.s', '.S']
-    if not is_compiled_file:
-      continue
-    basename = os.path.basename(name)  # Don't include extension.
-    basenames.setdefault(basename, []).append(source)
-
-  error = ''
-  for basename, files in basenames.items():
-    if len(files) > 1:
-      error += '  %s: %s\n' % (basename, ' '.join(files))
-
-  if error:
-    print('static library %s has several files with the same basename:\n' % spec['target_name']
-          + error + 'MSVC08 cannot handle that.')
-    raise GypError('Duplicate basenames in sources section, see list above')
+    if version.UsesVcxproj():
+        return _GenerateMSBuildProject(project, options, version, generator_flags, spec)
+    else:
+        return _GenerateMSVSProject(project, options, version, generator_flags)
 
 
 def _GenerateMSVSProject(project, options, version, generator_flags):
-  """Generates a .vcproj file.  It may create .rules and .user files too.
+    """Generates a .vcproj file.  It may create .rules and .user files too.
 
   Arguments:
     project: The project object we will generate the file for.
@@ -1019,85 +1032,77 @@ def _GenerateMSVSProject(project, options, version, generator_flags):
     version: The VisualStudioVersion object.
     generator_flags: dict of generator-specific flags.
   """
-  spec = project.spec
-  gyp.common.EnsureDirExists(project.path)
-
-  platforms = _GetUniquePlatforms(spec)
-  p = MSVSProject.Writer(project.path, version, spec['target_name'],
-                         project.guid, platforms)
-
-  # Get directory project file is in.
-  project_dir = os.path.split(project.path)[0]
-  gyp_path = _NormalizedSource(project.build_file)
-  relative_path_of_gyp_file = gyp.common.RelativePath(gyp_path, project_dir)
-
-  config_type = _GetMSVSConfigurationType(spec, project.build_file)
-  for config_name, config in spec['configurations'].items():
-    _AddConfigurationToMSVSProject(p, spec, config_type, config_name, config)
-
-  # MSVC08 and prior version cannot handle duplicate basenames in the same
-  # target.
-  # TODO: Take excluded sources into consideration if possible.
-  _ValidateSourcesForMSVSProject(spec, version)
-
-  # Prepare list of sources and excluded sources.
-  gyp_file = os.path.split(project.build_file)[1]
-  sources, excluded_sources = _PrepareListOfSources(spec, generator_flags,
-                                                    gyp_file)
-
-  # Add rules.
-  actions_to_add = {}
-  _GenerateRulesForMSVS(p, project_dir, options, spec,
-                        sources, excluded_sources,
-                        actions_to_add)
-  list_excluded = generator_flags.get('msvs_list_excluded_files', True)
-  sources, excluded_sources, excluded_idl = (
-      _AdjustSourcesAndConvertToFilterHierarchy(spec, options, project_dir,
-                                                sources, excluded_sources,
-                                                list_excluded, version))
-
-  # Add in files.
-  missing_sources = _VerifySourcesExist(sources, project_dir)
-  p.AddFiles(sources)
-
-  _AddToolFilesToMSVS(p, spec)
-  _HandlePreCompiledHeaders(p, sources, spec)
-  _AddActions(actions_to_add, spec, relative_path_of_gyp_file)
-  _AddCopies(actions_to_add, spec)
-  _WriteMSVSUserFile(project.path, version, spec)
-
-  # NOTE: this stanza must appear after all actions have been decided.
-  # Don't excluded sources with actions attached, or they won't run.
-  excluded_sources = _FilterActionsFromExcluded(
-      excluded_sources, actions_to_add)
-  _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources, excluded_idl,
-                              list_excluded)
-  _AddAccumulatedActionsToMSVS(p, spec, actions_to_add)
-
-  # Write it out.
-  p.WriteIfChanged()
-
-  return missing_sources
+    spec = project.spec
+    gyp.common.EnsureDirExists(project.path)
+
+    platforms = _GetUniquePlatforms(spec)
+    p = MSVSProject.Writer(
+        project.path, version, spec["target_name"], project.guid, platforms
+    )
+
+    # Get directory project file is in.
+    project_dir = os.path.split(project.path)[0]
+    gyp_path = _NormalizedSource(project.build_file)
+    relative_path_of_gyp_file = gyp.common.RelativePath(gyp_path, project_dir)
+
+    config_type = _GetMSVSConfigurationType(spec, project.build_file)
+    for config_name, config in spec["configurations"].items():
+        _AddConfigurationToMSVSProject(p, spec, config_type, config_name, config)
+
+    # Prepare list of sources and excluded sources.
+    gyp_file = os.path.split(project.build_file)[1]
+    sources, excluded_sources = _PrepareListOfSources(spec, generator_flags, gyp_file)
+
+    # Add rules.
+    actions_to_add = {}
+    _GenerateRulesForMSVS(
+        p, project_dir, options, spec, sources, excluded_sources, actions_to_add
+    )
+    list_excluded = generator_flags.get("msvs_list_excluded_files", True)
+    sources, excluded_sources, excluded_idl = _AdjustSourcesAndConvertToFilterHierarchy(
+        spec, options, project_dir, sources, excluded_sources, list_excluded, version
+    )
+
+    # Add in files.
+    missing_sources = _VerifySourcesExist(sources, project_dir)
+    p.AddFiles(sources)
+
+    _AddToolFilesToMSVS(p, spec)
+    _HandlePreCompiledHeaders(p, sources, spec)
+    _AddActions(actions_to_add, spec, relative_path_of_gyp_file)
+    _AddCopies(actions_to_add, spec)
+    _WriteMSVSUserFile(project.path, version, spec)
+
+    # NOTE: this stanza must appear after all actions have been decided.
+    # Don't excluded sources with actions attached, or they won't run.
+    excluded_sources = _FilterActionsFromExcluded(excluded_sources, actions_to_add)
+    _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources, excluded_idl, list_excluded)
+    _AddAccumulatedActionsToMSVS(p, spec, actions_to_add)
+
+    # Write it out.
+    p.WriteIfChanged()
+
+    return missing_sources
 
 
 def _GetUniquePlatforms(spec):
-  """Returns the list of unique platforms for this spec, e.g ['win32', ...].
+    """Returns the list of unique platforms for this spec, e.g ['win32', ...].
 
   Arguments:
     spec: The target dictionary containing the properties of the target.
   Returns:
     The MSVSUserFile object created.
   """
-  # Gather list of unique platforms.
-  platforms = OrderedSet()
-  for configuration in spec['configurations']:
-    platforms.add(_ConfigPlatform(spec['configurations'][configuration]))
-  platforms = list(platforms)
-  return platforms
+    # Gather list of unique platforms.
+    platforms = OrderedSet()
+    for configuration in spec["configurations"]:
+        platforms.add(_ConfigPlatform(spec["configurations"][configuration]))
+    platforms = list(platforms)
+    return platforms
 
 
 def _CreateMSVSUserFile(proj_path, version, spec):
-  """Generates a .user file for the user running this Gyp program.
+    """Generates a .user file for the user running this Gyp program.
 
   Arguments:
     proj_path: The path of the project file being created.  The .user file
@@ -1107,15 +1112,14 @@ def _CreateMSVSUserFile(proj_path, version, spec):
   Returns:
     The MSVSUserFile object created.
   """
-  (domain, username) = _GetDomainAndUserName()
-  vcuser_filename = '.'.join([proj_path, domain, username, 'user'])
-  user_file = MSVSUserFile.Writer(vcuser_filename, version,
-                                  spec['target_name'])
-  return user_file
+    (domain, username) = _GetDomainAndUserName()
+    vcuser_filename = ".".join([proj_path, domain, username, "user"])
+    user_file = MSVSUserFile.Writer(vcuser_filename, version, spec["target_name"])
+    return user_file
 
 
 def _GetMSVSConfigurationType(spec, build_file):
-  """Returns the configuration type for this project.
+    """Returns the configuration type for this project.
 
   It's a number defined by Microsoft.  May raise an exception.
 
@@ -1125,28 +1129,31 @@ def _GetMSVSConfigurationType(spec, build_file):
   Returns:
       An integer, the configuration type.
   """
-  try:
-    config_type = {
-        'executable': '1',  # .exe
-        'shared_library': '2',  # .dll
-        'loadable_module': '2',  # .dll
-        'static_library': '4',  # .lib
-        'windows_driver': '5',  # .sys
-        'none': '10',  # Utility type
-        }[spec['type']]
-  except KeyError:
-    if spec.get('type'):
-      raise GypError('Target type %s is not a valid target type for '
-                     'target %s in %s.' %
-                     (spec['type'], spec['target_name'], build_file))
-    else:
-      raise GypError('Missing type field for target %s in %s.' %
-                     (spec['target_name'], build_file))
-  return config_type
+    try:
+        config_type = {
+            "executable": "1",  # .exe
+            "shared_library": "2",  # .dll
+            "loadable_module": "2",  # .dll
+            "static_library": "4",  # .lib
+            "windows_driver": "5",  # .sys
+            "none": "10",  # Utility type
+        }[spec["type"]]
+    except KeyError:
+        if spec.get("type"):
+            raise GypError(
+                "Target type %s is not a valid target type for "
+                "target %s in %s." % (spec["type"], spec["target_name"], build_file)
+            )
+        else:
+            raise GypError(
+                "Missing type field for target %s in %s."
+                % (spec["target_name"], build_file)
+            )
+    return config_type
 
 
 def _AddConfigurationToMSVSProject(p, spec, config_type, config_name, config):
-  """Adds a configuration to the MSVS project.
+    """Adds a configuration to the MSVS project.
 
   Many settings in a vcproj file are specific to a configuration.  This
   function the main part of the vcproj file that's configuration specific.
@@ -1159,81 +1166,84 @@ def _AddConfigurationToMSVSProject(p, spec, config_type, config_name, config):
     config: The dictionary that defines the special processing to be done
             for this configuration.
   """
-  # Get the information for this configuration
-  include_dirs, midl_include_dirs, resource_include_dirs = \
-      _GetIncludeDirs(config)
-  libraries = _GetLibraries(spec)
-  library_dirs = _GetLibraryDirs(config)
-  out_file, vc_tool, _ = _GetOutputFilePathAndTool(spec, msbuild=False)
-  defines = _GetDefines(config)
-  defines = [_EscapeCppDefineForMSVS(d) for d in defines]
-  disabled_warnings = _GetDisabledWarnings(config)
-  prebuild = config.get('msvs_prebuild')
-  postbuild = config.get('msvs_postbuild')
-  def_file = _GetModuleDefinition(spec)
-  precompiled_header = config.get('msvs_precompiled_header')
-
-  # Prepare the list of tools as a dictionary.
-  tools = dict()
-  # Add in user specified msvs_settings.
-  msvs_settings = config.get('msvs_settings', {})
-  MSVSSettings.ValidateMSVSSettings(msvs_settings)
-
-  # Prevent default library inheritance from the environment.
-  _ToolAppend(tools, 'VCLinkerTool', 'AdditionalDependencies', ['$(NOINHERIT)'])
-
-  for tool in msvs_settings:
-    settings = config['msvs_settings'][tool]
-    for setting in settings:
-      _ToolAppend(tools, tool, setting, settings[setting])
-  # Add the information to the appropriate tool
-  _ToolAppend(tools, 'VCCLCompilerTool',
-              'AdditionalIncludeDirectories', include_dirs)
-  _ToolAppend(tools, 'VCMIDLTool',
-              'AdditionalIncludeDirectories', midl_include_dirs)
-  _ToolAppend(tools, 'VCResourceCompilerTool',
-              'AdditionalIncludeDirectories', resource_include_dirs)
-  # Add in libraries.
-  _ToolAppend(tools, 'VCLinkerTool', 'AdditionalDependencies', libraries)
-  _ToolAppend(tools, 'VCLinkerTool', 'AdditionalLibraryDirectories',
-              library_dirs)
-  if out_file:
-    _ToolAppend(tools, vc_tool, 'OutputFile', out_file, only_if_unset=True)
-  # Add defines.
-  _ToolAppend(tools, 'VCCLCompilerTool', 'PreprocessorDefinitions', defines)
-  _ToolAppend(tools, 'VCResourceCompilerTool', 'PreprocessorDefinitions',
-              defines)
-  # Change program database directory to prevent collisions.
-  _ToolAppend(tools, 'VCCLCompilerTool', 'ProgramDataBaseFileName',
-              '$(IntDir)$(ProjectName)\\vc80.pdb', only_if_unset=True)
-  # Add disabled warnings.
-  _ToolAppend(tools, 'VCCLCompilerTool',
-              'DisableSpecificWarnings', disabled_warnings)
-  # Add Pre-build.
-  _ToolAppend(tools, 'VCPreBuildEventTool', 'CommandLine', prebuild)
-  # Add Post-build.
-  _ToolAppend(tools, 'VCPostBuildEventTool', 'CommandLine', postbuild)
-  # Turn on precompiled headers if appropriate.
-  if precompiled_header:
-    precompiled_header = os.path.split(precompiled_header)[1]
-    _ToolAppend(tools, 'VCCLCompilerTool', 'UsePrecompiledHeader', '2')
-    _ToolAppend(tools, 'VCCLCompilerTool',
-                'PrecompiledHeaderThrough', precompiled_header)
-    _ToolAppend(tools, 'VCCLCompilerTool',
-                'ForcedIncludeFiles', precompiled_header)
-  # Loadable modules don't generate import libraries;
-  # tell dependent projects to not expect one.
-  if spec['type'] == 'loadable_module':
-    _ToolAppend(tools, 'VCLinkerTool', 'IgnoreImportLibrary', 'true')
-  # Set the module definition file if any.
-  if def_file:
-    _ToolAppend(tools, 'VCLinkerTool', 'ModuleDefinitionFile', def_file)
-
-  _AddConfigurationToMSVS(p, spec, tools, config, config_type, config_name)
+    # Get the information for this configuration
+    include_dirs, midl_include_dirs, resource_include_dirs = _GetIncludeDirs(config)
+    libraries = _GetLibraries(spec)
+    library_dirs = _GetLibraryDirs(config)
+    out_file, vc_tool, _ = _GetOutputFilePathAndTool(spec, msbuild=False)
+    defines = _GetDefines(config)
+    defines = [_EscapeCppDefineForMSVS(d) for d in defines]
+    disabled_warnings = _GetDisabledWarnings(config)
+    prebuild = config.get("msvs_prebuild")
+    postbuild = config.get("msvs_postbuild")
+    def_file = _GetModuleDefinition(spec)
+    precompiled_header = config.get("msvs_precompiled_header")
+
+    # Prepare the list of tools as a dictionary.
+    tools = dict()
+    # Add in user specified msvs_settings.
+    msvs_settings = config.get("msvs_settings", {})
+    MSVSSettings.ValidateMSVSSettings(msvs_settings)
+
+    # Prevent default library inheritance from the environment.
+    _ToolAppend(tools, "VCLinkerTool", "AdditionalDependencies", ["$(NOINHERIT)"])
+
+    for tool in msvs_settings:
+        settings = config["msvs_settings"][tool]
+        for setting in settings:
+            _ToolAppend(tools, tool, setting, settings[setting])
+    # Add the information to the appropriate tool
+    _ToolAppend(tools, "VCCLCompilerTool", "AdditionalIncludeDirectories", include_dirs)
+    _ToolAppend(tools, "VCMIDLTool", "AdditionalIncludeDirectories", midl_include_dirs)
+    _ToolAppend(
+        tools,
+        "VCResourceCompilerTool",
+        "AdditionalIncludeDirectories",
+        resource_include_dirs,
+    )
+    # Add in libraries.
+    _ToolAppend(tools, "VCLinkerTool", "AdditionalDependencies", libraries)
+    _ToolAppend(tools, "VCLinkerTool", "AdditionalLibraryDirectories", library_dirs)
+    if out_file:
+        _ToolAppend(tools, vc_tool, "OutputFile", out_file, only_if_unset=True)
+    # Add defines.
+    _ToolAppend(tools, "VCCLCompilerTool", "PreprocessorDefinitions", defines)
+    _ToolAppend(tools, "VCResourceCompilerTool", "PreprocessorDefinitions", defines)
+    # Change program database directory to prevent collisions.
+    _ToolAppend(
+        tools,
+        "VCCLCompilerTool",
+        "ProgramDataBaseFileName",
+        "$(IntDir)$(ProjectName)\\vc80.pdb",
+        only_if_unset=True,
+    )
+    # Add disabled warnings.
+    _ToolAppend(tools, "VCCLCompilerTool", "DisableSpecificWarnings", disabled_warnings)
+    # Add Pre-build.
+    _ToolAppend(tools, "VCPreBuildEventTool", "CommandLine", prebuild)
+    # Add Post-build.
+    _ToolAppend(tools, "VCPostBuildEventTool", "CommandLine", postbuild)
+    # Turn on precompiled headers if appropriate.
+    if precompiled_header:
+        precompiled_header = os.path.split(precompiled_header)[1]
+        _ToolAppend(tools, "VCCLCompilerTool", "UsePrecompiledHeader", "2")
+        _ToolAppend(
+            tools, "VCCLCompilerTool", "PrecompiledHeaderThrough", precompiled_header
+        )
+        _ToolAppend(tools, "VCCLCompilerTool", "ForcedIncludeFiles", precompiled_header)
+    # Loadable modules don't generate import libraries;
+    # tell dependent projects to not expect one.
+    if spec["type"] == "loadable_module":
+        _ToolAppend(tools, "VCLinkerTool", "IgnoreImportLibrary", "true")
+    # Set the module definition file if any.
+    if def_file:
+        _ToolAppend(tools, "VCLinkerTool", "ModuleDefinitionFile", def_file)
+
+    _AddConfigurationToMSVS(p, spec, tools, config, config_type, config_name)
 
 
 def _GetIncludeDirs(config):
-  """Returns the list of directories to be used for #include directives.
+    """Returns the list of directories to be used for #include directives.
 
   Arguments:
     config: The dictionary that defines the special processing to be done
@@ -1241,23 +1251,23 @@ def _GetIncludeDirs(config):
   Returns:
     The list of directory paths.
   """
-  # TODO(bradnelson): include_dirs should really be flexible enough not to
-  #                   require this sort of thing.
-  include_dirs = (
-      config.get('include_dirs', []) +
-      config.get('msvs_system_include_dirs', []))
-  midl_include_dirs = (
-      config.get('midl_include_dirs', []) +
-      config.get('msvs_system_include_dirs', []))
-  resource_include_dirs = config.get('resource_include_dirs', include_dirs)
-  include_dirs = _FixPaths(include_dirs)
-  midl_include_dirs = _FixPaths(midl_include_dirs)
-  resource_include_dirs = _FixPaths(resource_include_dirs)
-  return include_dirs, midl_include_dirs, resource_include_dirs
+    # TODO(bradnelson): include_dirs should really be flexible enough not to
+    #                   require this sort of thing.
+    include_dirs = config.get("include_dirs", []) + config.get(
+        "msvs_system_include_dirs", []
+    )
+    midl_include_dirs = config.get("midl_include_dirs", []) + config.get(
+        "msvs_system_include_dirs", []
+    )
+    resource_include_dirs = config.get("resource_include_dirs", include_dirs)
+    include_dirs = _FixPaths(include_dirs)
+    midl_include_dirs = _FixPaths(midl_include_dirs)
+    resource_include_dirs = _FixPaths(resource_include_dirs)
+    return include_dirs, midl_include_dirs, resource_include_dirs
 
 
 def _GetLibraryDirs(config):
-  """Returns the list of directories to be used for library search paths.
+    """Returns the list of directories to be used for library search paths.
 
   Arguments:
     config: The dictionary that defines the special processing to be done
@@ -1266,39 +1276,39 @@ def _GetLibraryDirs(config):
     The list of directory paths.
   """
 
-  library_dirs = config.get('library_dirs', [])
-  library_dirs = _FixPaths(library_dirs)
-  return library_dirs
+    library_dirs = config.get("library_dirs", [])
+    library_dirs = _FixPaths(library_dirs)
+    return library_dirs
 
 
 def _GetLibraries(spec):
-  """Returns the list of libraries for this configuration.
+    """Returns the list of libraries for this configuration.
 
   Arguments:
     spec: The target dictionary containing the properties of the target.
   Returns:
     The list of directory paths.
   """
-  libraries = spec.get('libraries', [])
-  # Strip out -l, as it is not used on windows (but is needed so we can pass
-  # in libraries that are assumed to be in the default library path).
-  # Also remove duplicate entries, leaving only the last duplicate, while
-  # preserving order.
-  found = OrderedSet()
-  unique_libraries_list = []
-  for entry in reversed(libraries):
-    library = re.sub(r'^\-l', '', entry)
-    if not os.path.splitext(library)[1]:
-      library += '.lib'
-    if library not in found:
-      found.add(library)
-      unique_libraries_list.append(library)
-  unique_libraries_list.reverse()
-  return unique_libraries_list
+    libraries = spec.get("libraries", [])
+    # Strip out -l, as it is not used on windows (but is needed so we can pass
+    # in libraries that are assumed to be in the default library path).
+    # Also remove duplicate entries, leaving only the last duplicate, while
+    # preserving order.
+    found = OrderedSet()
+    unique_libraries_list = []
+    for entry in reversed(libraries):
+        library = re.sub(r"^\-l", "", entry)
+        if not os.path.splitext(library)[1]:
+            library += ".lib"
+        if library not in found:
+            found.add(library)
+            unique_libraries_list.append(library)
+    unique_libraries_list.reverse()
+    return unique_libraries_list
 
 
 def _GetOutputFilePathAndTool(spec, msbuild):
-  """Returns the path and tool to use for this target.
+    """Returns the path and tool to use for this target.
 
   Figures out the path of the file this spec will create and the name of
   the VC tool that will create it.
@@ -1308,36 +1318,36 @@ def _GetOutputFilePathAndTool(spec, msbuild):
   Returns:
     A triple of (file path, name of the vc tool, name of the msbuild tool)
   """
-  # Select a name for the output file.
-  out_file = ''
-  vc_tool = ''
-  msbuild_tool = ''
-  output_file_map = {
-      'executable': ('VCLinkerTool', 'Link', '$(OutDir)', '.exe'),
-      'shared_library': ('VCLinkerTool', 'Link', '$(OutDir)', '.dll'),
-      'loadable_module': ('VCLinkerTool', 'Link', '$(OutDir)', '.dll'),
-      'windows_driver': ('VCLinkerTool', 'Link', '$(OutDir)', '.sys'),
-      'static_library': ('VCLibrarianTool', 'Lib', '$(OutDir)lib\\', '.lib'),
-  }
-  output_file_props = output_file_map.get(spec['type'])
-  if output_file_props and int(spec.get('msvs_auto_output_file', 1)):
-    vc_tool, msbuild_tool, out_dir, suffix = output_file_props
-    if spec.get('standalone_static_library', 0):
-      out_dir = '$(OutDir)'
-    out_dir = spec.get('product_dir', out_dir)
-    product_extension = spec.get('product_extension')
-    if product_extension:
-      suffix = '.' + product_extension
-    elif msbuild:
-      suffix = '$(TargetExt)'
-    prefix = spec.get('product_prefix', '')
-    product_name = spec.get('product_name', '$(ProjectName)')
-    out_file = ntpath.join(out_dir, prefix + product_name + suffix)
-  return out_file, vc_tool, msbuild_tool
+    # Select a name for the output file.
+    out_file = ""
+    vc_tool = ""
+    msbuild_tool = ""
+    output_file_map = {
+        "executable": ("VCLinkerTool", "Link", "$(OutDir)", ".exe"),
+        "shared_library": ("VCLinkerTool", "Link", "$(OutDir)", ".dll"),
+        "loadable_module": ("VCLinkerTool", "Link", "$(OutDir)", ".dll"),
+        "windows_driver": ("VCLinkerTool", "Link", "$(OutDir)", ".sys"),
+        "static_library": ("VCLibrarianTool", "Lib", "$(OutDir)lib\\", ".lib"),
+    }
+    output_file_props = output_file_map.get(spec["type"])
+    if output_file_props and int(spec.get("msvs_auto_output_file", 1)):
+        vc_tool, msbuild_tool, out_dir, suffix = output_file_props
+        if spec.get("standalone_static_library", 0):
+            out_dir = "$(OutDir)"
+        out_dir = spec.get("product_dir", out_dir)
+        product_extension = spec.get("product_extension")
+        if product_extension:
+            suffix = "." + product_extension
+        elif msbuild:
+            suffix = "$(TargetExt)"
+        prefix = spec.get("product_prefix", "")
+        product_name = spec.get("product_name", "$(ProjectName)")
+        out_file = ntpath.join(out_dir, prefix + product_name + suffix)
+    return out_file, vc_tool, msbuild_tool
 
 
 def _GetOutputTargetExt(spec):
-  """Returns the extension for this target, including the dot
+    """Returns the extension for this target, including the dot
 
   If product_extension is specified, set target_extension to this to avoid
   MSB8012, returns None otherwise. Ignores any target_extension settings in
@@ -1348,14 +1358,14 @@ def _GetOutputTargetExt(spec):
   Returns:
     A string with the extension, or None
   """
-  target_extension = spec.get('product_extension')
-  if target_extension:
-    return '.' + target_extension
-  return None
+    target_extension = spec.get("product_extension")
+    if target_extension:
+        return "." + target_extension
+    return None
 
 
 def _GetDefines(config):
-  """Returns the list of preprocessor definitions for this configuation.
+    """Returns the list of preprocessor definitions for this configuration.
 
   Arguments:
     config: The dictionary that defines the special processing to be done
@@ -1363,64 +1373,68 @@ def _GetDefines(config):
   Returns:
     The list of preprocessor definitions.
   """
-  defines = []
-  for d in config.get('defines', []):
-    if type(d) == list:
-      fd = '='.join([str(dpart) for dpart in d])
-    else:
-      fd = str(d)
-    defines.append(fd)
-  return defines
+    defines = []
+    for d in config.get("defines", []):
+        if type(d) == list:
+            fd = "=".join([str(dpart) for dpart in d])
+        else:
+            fd = str(d)
+        defines.append(fd)
+    return defines
 
 
 def _GetDisabledWarnings(config):
-  return [str(i) for i in config.get('msvs_disabled_warnings', [])]
+    return [str(i) for i in config.get("msvs_disabled_warnings", [])]
 
 
 def _GetModuleDefinition(spec):
-  def_file = ''
-  if spec['type'] in ['shared_library', 'loadable_module', 'executable',
-                      'windows_driver']:
-    def_files = [s for s in spec.get('sources', []) if s.endswith('.def')]
-    if len(def_files) == 1:
-      def_file = _FixPath(def_files[0])
-    elif def_files:
-      raise ValueError(
-          'Multiple module definition files in one target, target %s lists '
-          'multiple .def files: %s' % (
-              spec['target_name'], ' '.join(def_files)))
-  return def_file
+    def_file = ""
+    if spec["type"] in [
+        "shared_library",
+        "loadable_module",
+        "executable",
+        "windows_driver",
+    ]:
+        def_files = [s for s in spec.get("sources", []) if s.endswith(".def")]
+        if len(def_files) == 1:
+            def_file = _FixPath(def_files[0])
+        elif def_files:
+            raise ValueError(
+                "Multiple module definition files in one target, target %s lists "
+                "multiple .def files: %s" % (spec["target_name"], " ".join(def_files))
+            )
+    return def_file
 
 
 def _ConvertToolsToExpectedForm(tools):
-  """Convert tools to a form expected by Visual Studio.
+    """Convert tools to a form expected by Visual Studio.
 
   Arguments:
     tools: A dictionary of settings; the tool name is the key.
   Returns:
     A list of Tool objects.
   """
-  tool_list = []
-  for tool, settings in tools.items():
-    # Collapse settings with lists.
-    settings_fixed = {}
-    for setting, value in settings.items():
-      if type(value) == list:
-        if ((tool == 'VCLinkerTool' and
-             setting == 'AdditionalDependencies') or
-            setting == 'AdditionalOptions'):
-          settings_fixed[setting] = ' '.join(value)
-        else:
-          settings_fixed[setting] = ';'.join(value)
-      else:
-        settings_fixed[setting] = value
-    # Add in this tool.
-    tool_list.append(MSVSProject.Tool(tool, settings_fixed))
-  return tool_list
+    tool_list = []
+    for tool, settings in tools.items():
+        # Collapse settings with lists.
+        settings_fixed = {}
+        for setting, value in settings.items():
+            if type(value) == list:
+                if (
+                    tool == "VCLinkerTool" and setting == "AdditionalDependencies"
+                ) or setting == "AdditionalOptions":
+                    settings_fixed[setting] = " ".join(value)
+                else:
+                    settings_fixed[setting] = ";".join(value)
+            else:
+                settings_fixed[setting] = value
+        # Add in this tool.
+        tool_list.append(MSVSProject.Tool(tool, settings_fixed))
+    return tool_list
 
 
 def _AddConfigurationToMSVS(p, spec, tools, config, config_type, config_name):
-  """Add to the project file the configuration specified by config.
+    """Add to the project file the configuration specified by config.
 
   Arguments:
     p: The target project being generated.
@@ -1431,45 +1445,45 @@ def _AddConfigurationToMSVS(p, spec, tools, config, config_type, config_name):
     config_type: The configuration type, a number as defined by Microsoft.
     config_name: The name of the configuration.
   """
-  attributes = _GetMSVSAttributes(spec, config, config_type)
-  # Add in this configuration.
-  tool_list = _ConvertToolsToExpectedForm(tools)
-  p.AddConfig(_ConfigFullName(config_name, config),
-              attrs=attributes, tools=tool_list)
+    attributes = _GetMSVSAttributes(spec, config, config_type)
+    # Add in this configuration.
+    tool_list = _ConvertToolsToExpectedForm(tools)
+    p.AddConfig(_ConfigFullName(config_name, config), attrs=attributes, tools=tool_list)
 
 
 def _GetMSVSAttributes(spec, config, config_type):
-  # Prepare configuration attributes.
-  prepared_attrs = {}
-  source_attrs = config.get('msvs_configuration_attributes', {})
-  for a in source_attrs:
-    prepared_attrs[a] = source_attrs[a]
-  # Add props files.
-  vsprops_dirs = config.get('msvs_props', [])
-  vsprops_dirs = _FixPaths(vsprops_dirs)
-  if vsprops_dirs:
-    prepared_attrs['InheritedPropertySheets'] = ';'.join(vsprops_dirs)
-  # Set configuration type.
-  prepared_attrs['ConfigurationType'] = config_type
-  output_dir = prepared_attrs.get('OutputDirectory',
-                                  '$(SolutionDir)$(ConfigurationName)')
-  prepared_attrs['OutputDirectory'] = _FixPath(output_dir) + '\\'
-  if 'IntermediateDirectory' not in prepared_attrs:
-    intermediate = '$(ConfigurationName)\\obj\\$(ProjectName)'
-    prepared_attrs['IntermediateDirectory'] = _FixPath(intermediate) + '\\'
-  else:
-    intermediate = _FixPath(prepared_attrs['IntermediateDirectory']) + '\\'
-    intermediate = MSVSSettings.FixVCMacroSlashes(intermediate)
-    prepared_attrs['IntermediateDirectory'] = intermediate
-  return prepared_attrs
+    # Prepare configuration attributes.
+    prepared_attrs = {}
+    source_attrs = config.get("msvs_configuration_attributes", {})
+    for a in source_attrs:
+        prepared_attrs[a] = source_attrs[a]
+    # Add props files.
+    vsprops_dirs = config.get("msvs_props", [])
+    vsprops_dirs = _FixPaths(vsprops_dirs)
+    if vsprops_dirs:
+        prepared_attrs["InheritedPropertySheets"] = ";".join(vsprops_dirs)
+    # Set configuration type.
+    prepared_attrs["ConfigurationType"] = config_type
+    output_dir = prepared_attrs.get(
+        "OutputDirectory", "$(SolutionDir)$(ConfigurationName)"
+    )
+    prepared_attrs["OutputDirectory"] = _FixPath(output_dir) + "\\"
+    if "IntermediateDirectory" not in prepared_attrs:
+        intermediate = "$(ConfigurationName)\\obj\\$(ProjectName)"
+        prepared_attrs["IntermediateDirectory"] = _FixPath(intermediate) + "\\"
+    else:
+        intermediate = _FixPath(prepared_attrs["IntermediateDirectory"]) + "\\"
+        intermediate = MSVSSettings.FixVCMacroSlashes(intermediate)
+        prepared_attrs["IntermediateDirectory"] = intermediate
+    return prepared_attrs
 
 
 def _AddNormalizedSources(sources_set, sources_array):
-  sources_set.update(_NormalizedSource(s) for s in sources_array)
+    sources_set.update(_NormalizedSource(s) for s in sources_array)
 
 
 def _PrepareListOfSources(spec, generator_flags, gyp_file):
-  """Prepare list of sources and excluded sources.
+    """Prepare list of sources and excluded sources.
 
   Besides the sources specified directly in the spec, adds the gyp file so
   that a change to it will cause a re-compile. Also adds appropriate sources
@@ -1483,33 +1497,34 @@ def _PrepareListOfSources(spec, generator_flags, gyp_file):
     A pair of (list of sources, list of excluded sources).
     The sources will be relative to the gyp file.
   """
-  sources = OrderedSet()
-  _AddNormalizedSources(sources, spec.get('sources', []))
-  excluded_sources = OrderedSet()
-  # Add in the gyp file.
-  if not generator_flags.get('standalone'):
-    sources.add(gyp_file)
-
-  # Add in 'action' inputs and outputs.
-  for a in spec.get('actions', []):
-    inputs = a['inputs']
-    inputs = [_NormalizedSource(i) for i in inputs]
-    # Add all inputs to sources and excluded sources.
-    inputs = OrderedSet(inputs)
-    sources.update(inputs)
-    if not spec.get('msvs_external_builder'):
-      excluded_sources.update(inputs)
-    if int(a.get('process_outputs_as_sources', False)):
-      _AddNormalizedSources(sources, a.get('outputs', []))
-  # Add in 'copies' inputs and outputs.
-  for cpy in spec.get('copies', []):
-    _AddNormalizedSources(sources, cpy.get('files', []))
-  return (sources, excluded_sources)
+    sources = OrderedSet()
+    _AddNormalizedSources(sources, spec.get("sources", []))
+    excluded_sources = OrderedSet()
+    # Add in the gyp file.
+    if not generator_flags.get("standalone"):
+        sources.add(gyp_file)
+
+    # Add in 'action' inputs and outputs.
+    for a in spec.get("actions", []):
+        inputs = a["inputs"]
+        inputs = [_NormalizedSource(i) for i in inputs]
+        # Add all inputs to sources and excluded sources.
+        inputs = OrderedSet(inputs)
+        sources.update(inputs)
+        if not spec.get("msvs_external_builder"):
+            excluded_sources.update(inputs)
+        if int(a.get("process_outputs_as_sources", False)):
+            _AddNormalizedSources(sources, a.get("outputs", []))
+    # Add in 'copies' inputs and outputs.
+    for cpy in spec.get("copies", []):
+        _AddNormalizedSources(sources, cpy.get("files", []))
+    return (sources, excluded_sources)
 
 
 def _AdjustSourcesAndConvertToFilterHierarchy(
-    spec, options, gyp_dir, sources, excluded_sources, list_excluded, version):
-  """Adjusts the list of sources and excluded sources.
+    spec, options, gyp_dir, sources, excluded_sources, list_excluded, version
+):
+    """Adjusts the list of sources and excluded sources.
 
   Also converts the sets to lists.
 
@@ -1524,330 +1539,377 @@ def _AdjustSourcesAndConvertToFilterHierarchy(
     A trio of (list of sources, list of excluded sources,
                path of excluded IDL file)
   """
-  # Exclude excluded sources coming into the generator.
-  excluded_sources.update(OrderedSet(spec.get('sources_excluded', [])))
-  # Add excluded sources into sources for good measure.
-  sources.update(excluded_sources)
-  # Convert to proper windows form.
-  # NOTE: sources goes from being a set to a list here.
-  # NOTE: excluded_sources goes from being a set to a list here.
-  sources = _FixPaths(sources)
-  # Convert to proper windows form.
-  excluded_sources = _FixPaths(excluded_sources)
-
-  excluded_idl = _IdlFilesHandledNonNatively(spec, sources)
-
-  precompiled_related = _GetPrecompileRelatedFiles(spec)
-  # Find the excluded ones, minus the precompiled header related ones.
-  fully_excluded = [i for i in excluded_sources if i not in precompiled_related]
-
-  # Convert to folders and the right slashes.
-  sources = [i.split('\\') for i in sources]
-  sources = _ConvertSourcesToFilterHierarchy(sources, excluded=fully_excluded,
-                                             list_excluded=list_excluded,
-                                             msvs_version=version)
-
-  # Prune filters with a single child to flatten ugly directory structures
-  # such as ../../src/modules/module1 etc.
-  if version.UsesVcxproj():
-    while all([isinstance(s, MSVSProject.Filter) for s in sources]) \
-        and len(set([s.name for s in sources])) == 1:
-      assert all([len(s.contents) == 1 for s in sources])
-      sources = [s.contents[0] for s in sources]
-  else:
-    while len(sources) == 1 and isinstance(sources[0], MSVSProject.Filter):
-      sources = sources[0].contents
-
-  return sources, excluded_sources, excluded_idl
+    # Exclude excluded sources coming into the generator.
+    excluded_sources.update(OrderedSet(spec.get("sources_excluded", [])))
+    # Add excluded sources into sources for good measure.
+    sources.update(excluded_sources)
+    # Convert to proper windows form.
+    # NOTE: sources goes from being a set to a list here.
+    # NOTE: excluded_sources goes from being a set to a list here.
+    sources = _FixPaths(sources)
+    # Convert to proper windows form.
+    excluded_sources = _FixPaths(excluded_sources)
+
+    excluded_idl = _IdlFilesHandledNonNatively(spec, sources)
+
+    precompiled_related = _GetPrecompileRelatedFiles(spec)
+    # Find the excluded ones, minus the precompiled header related ones.
+    fully_excluded = [i for i in excluded_sources if i not in precompiled_related]
+
+    # Convert to folders and the right slashes.
+    sources = [i.split("\\") for i in sources]
+    sources = _ConvertSourcesToFilterHierarchy(
+        sources,
+        excluded=fully_excluded,
+        list_excluded=list_excluded,
+        msvs_version=version,
+    )
+
+    # Prune filters with a single child to flatten ugly directory structures
+    # such as ../../src/modules/module1 etc.
+    if version.UsesVcxproj():
+        while (
+            all([isinstance(s, MSVSProject.Filter) for s in sources])
+            and len(set([s.name for s in sources])) == 1
+        ):
+            assert all([len(s.contents) == 1 for s in sources])
+            sources = [s.contents[0] for s in sources]
+    else:
+        while len(sources) == 1 and isinstance(sources[0], MSVSProject.Filter):
+            sources = sources[0].contents
+
+    return sources, excluded_sources, excluded_idl
 
 
 def _IdlFilesHandledNonNatively(spec, sources):
-  # If any non-native rules use 'idl' as an extension exclude idl files.
-  # Gather a list here to use later.
-  using_idl = False
-  for rule in spec.get('rules', []):
-    if rule['extension'] == 'idl' and int(rule.get('msvs_external_rule', 0)):
-      using_idl = True
-      break
-  if using_idl:
-    excluded_idl = [i for i in sources if i.endswith('.idl')]
-  else:
-    excluded_idl = []
-  return excluded_idl
+    # If any non-native rules use 'idl' as an extension exclude idl files.
+    # Gather a list here to use later.
+    using_idl = False
+    for rule in spec.get("rules", []):
+        if rule["extension"] == "idl" and int(rule.get("msvs_external_rule", 0)):
+            using_idl = True
+            break
+    if using_idl:
+        excluded_idl = [i for i in sources if i.endswith(".idl")]
+    else:
+        excluded_idl = []
+    return excluded_idl
 
 
 def _GetPrecompileRelatedFiles(spec):
-  # Gather a list of precompiled header related sources.
-  precompiled_related = []
-  for _, config in spec['configurations'].items():
-    for k in precomp_keys:
-      f = config.get(k)
-      if f:
-        precompiled_related.append(_FixPath(f))
-  return precompiled_related
-
-
-def _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources, excluded_idl,
-                                list_excluded):
-  exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
-  for file_name, excluded_configs in exclusions.items():
-    if (not list_excluded and
-            len(excluded_configs) == len(spec['configurations'])):
-      # If we're not listing excluded files, then they won't appear in the
-      # project, so don't try to configure them to be excluded.
-      pass
-    else:
-      for config_name, config in excluded_configs:
-        p.AddFileConfig(file_name, _ConfigFullName(config_name, config),
-                        {'ExcludedFromBuild': 'true'})
+    # Gather a list of precompiled header related sources.
+    precompiled_related = []
+    for _, config in spec["configurations"].items():
+        for k in precomp_keys:
+            f = config.get(k)
+            if f:
+                precompiled_related.append(_FixPath(f))
+    return precompiled_related
+
+
+def _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources, excluded_idl, list_excluded):
+    exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
+    for file_name, excluded_configs in exclusions.items():
+        if not list_excluded and len(excluded_configs) == len(spec["configurations"]):
+            # If we're not listing excluded files, then they won't appear in the
+            # project, so don't try to configure them to be excluded.
+            pass
+        else:
+            for config_name, config in excluded_configs:
+                p.AddFileConfig(
+                    file_name,
+                    _ConfigFullName(config_name, config),
+                    {"ExcludedFromBuild": "true"},
+                )
 
 
 def _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl):
-  exclusions = {}
-  # Exclude excluded sources from being built.
-  for f in excluded_sources:
-    excluded_configs = []
-    for config_name, config in spec['configurations'].items():
-      precomped = [_FixPath(config.get(i, '')) for i in precomp_keys]
-      # Don't do this for ones that are precompiled header related.
-      if f not in precomped:
-        excluded_configs.append((config_name, config))
-    exclusions[f] = excluded_configs
-  # If any non-native rules use 'idl' as an extension exclude idl files.
-  # Exclude them now.
-  for f in excluded_idl:
-    excluded_configs = []
-    for config_name, config in spec['configurations'].items():
-      excluded_configs.append((config_name, config))
-    exclusions[f] = excluded_configs
-  return exclusions
+    exclusions = {}
+    # Exclude excluded sources from being built.
+    for f in excluded_sources:
+        excluded_configs = []
+        for config_name, config in spec["configurations"].items():
+            precomped = [_FixPath(config.get(i, "")) for i in precomp_keys]
+            # Don't do this for ones that are precompiled header related.
+            if f not in precomped:
+                excluded_configs.append((config_name, config))
+        exclusions[f] = excluded_configs
+    # If any non-native rules use 'idl' as an extension exclude idl files.
+    # Exclude them now.
+    for f in excluded_idl:
+        excluded_configs = []
+        for config_name, config in spec["configurations"].items():
+            excluded_configs.append((config_name, config))
+        exclusions[f] = excluded_configs
+    return exclusions
 
 
 def _AddToolFilesToMSVS(p, spec):
-  # Add in tool files (rules).
-  tool_files = OrderedSet()
-  for _, config in spec['configurations'].items():
-    for f in config.get('msvs_tool_files', []):
-      tool_files.add(f)
-  for f in tool_files:
-    p.AddToolFile(f)
+    # Add in tool files (rules).
+    tool_files = OrderedSet()
+    for _, config in spec["configurations"].items():
+        for f in config.get("msvs_tool_files", []):
+            tool_files.add(f)
+    for f in tool_files:
+        p.AddToolFile(f)
 
 
 def _HandlePreCompiledHeaders(p, sources, spec):
-  # Pre-compiled header source stubs need a different compiler flag
-  # (generate precompiled header) and any source file not of the same
-  # kind (i.e. C vs. C++) as the precompiled header source stub needs
-  # to have use of precompiled headers disabled.
-  extensions_excluded_from_precompile = []
-  for config_name, config in spec['configurations'].items():
-    source = config.get('msvs_precompiled_source')
-    if source:
-      source = _FixPath(source)
-      # UsePrecompiledHeader=1 for if using precompiled headers.
-      tool = MSVSProject.Tool('VCCLCompilerTool',
-                              {'UsePrecompiledHeader': '1'})
-      p.AddFileConfig(source, _ConfigFullName(config_name, config),
-                      {}, tools=[tool])
-      basename, extension = os.path.splitext(source)
-      if extension == '.c':
-        extensions_excluded_from_precompile = ['.cc', '.cpp', '.cxx']
-      else:
-        extensions_excluded_from_precompile = ['.c']
-  def DisableForSourceTree(source_tree):
-    for source in source_tree:
-      if isinstance(source, MSVSProject.Filter):
-        DisableForSourceTree(source.contents)
-      else:
-        basename, extension = os.path.splitext(source)
-        if extension in extensions_excluded_from_precompile:
-          for config_name, config in spec['configurations'].items():
-            tool = MSVSProject.Tool('VCCLCompilerTool',
-                                    {'UsePrecompiledHeader': '0',
-                                     'ForcedIncludeFiles': '$(NOINHERIT)'})
-            p.AddFileConfig(_FixPath(source),
+    # Pre-compiled header source stubs need a different compiler flag
+    # (generate precompiled header) and any source file not of the same
+    # kind (i.e. C vs. C++) as the precompiled header source stub needs
+    # to have use of precompiled headers disabled.
+    extensions_excluded_from_precompile = []
+    for config_name, config in spec["configurations"].items():
+        source = config.get("msvs_precompiled_source")
+        if source:
+            source = _FixPath(source)
+            # UsePrecompiledHeader=1 for if using precompiled headers.
+            tool = MSVSProject.Tool("VCCLCompilerTool", {"UsePrecompiledHeader": "1"})
+            p.AddFileConfig(
+                source, _ConfigFullName(config_name, config), {}, tools=[tool]
+            )
+            basename, extension = os.path.splitext(source)
+            if extension == ".c":
+                extensions_excluded_from_precompile = [".cc", ".cpp", ".cxx"]
+            else:
+                extensions_excluded_from_precompile = [".c"]
+
+    def DisableForSourceTree(source_tree):
+        for source in source_tree:
+            if isinstance(source, MSVSProject.Filter):
+                DisableForSourceTree(source.contents)
+            else:
+                basename, extension = os.path.splitext(source)
+                if extension in extensions_excluded_from_precompile:
+                    for config_name, config in spec["configurations"].items():
+                        tool = MSVSProject.Tool(
+                            "VCCLCompilerTool",
+                            {
+                                "UsePrecompiledHeader": "0",
+                                "ForcedIncludeFiles": "$(NOINHERIT)",
+                            },
+                        )
+                        p.AddFileConfig(
+                            _FixPath(source),
                             _ConfigFullName(config_name, config),
-                            {}, tools=[tool])
-  # Do nothing if there was no precompiled source.
-  if extensions_excluded_from_precompile:
-    DisableForSourceTree(sources)
+                            {},
+                            tools=[tool],
+                        )
+
+    # Do nothing if there was no precompiled source.
+    if extensions_excluded_from_precompile:
+        DisableForSourceTree(sources)
 
 
 def _AddActions(actions_to_add, spec, relative_path_of_gyp_file):
-  # Add actions.
-  actions = spec.get('actions', [])
-  # Don't setup_env every time. When all the actions are run together in one
-  # batch file in VS, the PATH will grow too long.
-  # Membership in this set means that the cygwin environment has been set up,
-  # and does not need to be set up again.
-  have_setup_env = set()
-  for a in actions:
-    # Attach actions to the gyp file if nothing else is there.
-    inputs = a.get('inputs') or [relative_path_of_gyp_file]
-    attached_to = inputs[0]
-    need_setup_env = attached_to not in have_setup_env
-    cmd = _BuildCommandLineForRule(spec, a, has_input_path=False,
-                                   do_setup_env=need_setup_env)
-    have_setup_env.add(attached_to)
-    # Add the action.
-    _AddActionStep(actions_to_add,
-                   inputs=inputs,
-                   outputs=a.get('outputs', []),
-                   description=a.get('message', a['action_name']),
-                   command=cmd)
+    # Add actions.
+    actions = spec.get("actions", [])
+    # Don't setup_env every time. When all the actions are run together in one
+    # batch file in VS, the PATH will grow too long.
+    # Membership in this set means that the cygwin environment has been set up,
+    # and does not need to be set up again.
+    have_setup_env = set()
+    for a in actions:
+        # Attach actions to the gyp file if nothing else is there.
+        inputs = a.get("inputs") or [relative_path_of_gyp_file]
+        attached_to = inputs[0]
+        need_setup_env = attached_to not in have_setup_env
+        cmd = _BuildCommandLineForRule(
+            spec, a, has_input_path=False, do_setup_env=need_setup_env
+        )
+        have_setup_env.add(attached_to)
+        # Add the action.
+        _AddActionStep(
+            actions_to_add,
+            inputs=inputs,
+            outputs=a.get("outputs", []),
+            description=a.get("message", a["action_name"]),
+            command=cmd,
+        )
 
 
 def _WriteMSVSUserFile(project_path, version, spec):
-  # Add run_as and test targets.
-  if 'run_as' in spec:
-    run_as = spec['run_as']
-    action = run_as.get('action', [])
-    environment = run_as.get('environment', [])
-    working_directory = run_as.get('working_directory', '.')
-  elif int(spec.get('test', 0)):
-    action = ['$(TargetPath)', '--gtest_print_time']
-    environment = []
-    working_directory = '.'
-  else:
-    return  # Nothing to add
-  # Write out the user file.
-  user_file = _CreateMSVSUserFile(project_path, version, spec)
-  for config_name, c_data in spec['configurations'].items():
-    user_file.AddDebugSettings(_ConfigFullName(config_name, c_data),
-                               action, environment, working_directory)
-  user_file.WriteIfChanged()
+    # Add run_as and test targets.
+    if "run_as" in spec:
+        run_as = spec["run_as"]
+        action = run_as.get("action", [])
+        environment = run_as.get("environment", [])
+        working_directory = run_as.get("working_directory", ".")
+    elif int(spec.get("test", 0)):
+        action = ["$(TargetPath)", "--gtest_print_time"]
+        environment = []
+        working_directory = "."
+    else:
+        return  # Nothing to add
+    # Write out the user file.
+    user_file = _CreateMSVSUserFile(project_path, version, spec)
+    for config_name, c_data in spec["configurations"].items():
+        user_file.AddDebugSettings(
+            _ConfigFullName(config_name, c_data), action, environment, working_directory
+        )
+    user_file.WriteIfChanged()
 
 
 def _AddCopies(actions_to_add, spec):
-  copies = _GetCopies(spec)
-  for inputs, outputs, cmd, description in copies:
-    _AddActionStep(actions_to_add, inputs=inputs, outputs=outputs,
-                   description=description, command=cmd)
+    copies = _GetCopies(spec)
+    for inputs, outputs, cmd, description in copies:
+        _AddActionStep(
+            actions_to_add,
+            inputs=inputs,
+            outputs=outputs,
+            description=description,
+            command=cmd,
+        )
 
 
 def _GetCopies(spec):
-  copies = []
-  # Add copies.
-  for cpy in spec.get('copies', []):
-    for src in cpy.get('files', []):
-      dst = os.path.join(cpy['destination'], os.path.basename(src))
-      # _AddCustomBuildToolForMSVS() will call _FixPath() on the inputs and
-      # outputs, so do the same for our generated command line.
-      if src.endswith('/'):
-        src_bare = src[:-1]
-        base_dir = posixpath.split(src_bare)[0]
-        outer_dir = posixpath.split(src_bare)[1]
-        fixed_dst = _FixPath(dst)
-        full_dst = '"%s\\%s\\"' % (fixed_dst, outer_dir)
-        cmd = 'mkdir %s 2>nul & cd "%s" && xcopy /e /f /y "%s" %s' % (
-            full_dst, _FixPath(base_dir), outer_dir, full_dst)
-        copies.append(([src], ['dummy_copies', dst], cmd,
-                       'Copying %s to %s' % (src, fixed_dst)))
-      else:
-        fix_dst = _FixPath(cpy['destination'])
-        cmd = 'mkdir "%s" 2>nul & set ERRORLEVEL=0 & copy /Y "%s" "%s"' % (
-            fix_dst, _FixPath(src), _FixPath(dst))
-        copies.append(([src], [dst], cmd, 'Copying %s to %s' % (src, fix_dst)))
-  return copies
+    copies = []
+    # Add copies.
+    for cpy in spec.get("copies", []):
+        for src in cpy.get("files", []):
+            dst = os.path.join(cpy["destination"], os.path.basename(src))
+            # _AddCustomBuildToolForMSVS() will call _FixPath() on the inputs and
+            # outputs, so do the same for our generated command line.
+            if src.endswith("/"):
+                src_bare = src[:-1]
+                base_dir = posixpath.split(src_bare)[0]
+                outer_dir = posixpath.split(src_bare)[1]
+                fixed_dst = _FixPath(dst)
+                full_dst = '"%s\\%s\\"' % (fixed_dst, outer_dir)
+                cmd = 'mkdir %s 2>nul & cd "%s" && xcopy /e /f /y "%s" %s' % (
+                    full_dst,
+                    _FixPath(base_dir),
+                    outer_dir,
+                    full_dst,
+                )
+                copies.append(
+                    (
+                        [src],
+                        ["dummy_copies", dst],
+                        cmd,
+                        "Copying %s to %s" % (src, fixed_dst),
+                    )
+                )
+            else:
+                fix_dst = _FixPath(cpy["destination"])
+                cmd = 'mkdir "%s" 2>nul & set ERRORLEVEL=0 & copy /Y "%s" "%s"' % (
+                    fix_dst,
+                    _FixPath(src),
+                    _FixPath(dst),
+                )
+                copies.append(([src], [dst], cmd, "Copying %s to %s" % (src, fix_dst)))
+    return copies
 
 
 def _GetPathDict(root, path):
-  # |path| will eventually be empty (in the recursive calls) if it was initially
-  # relative; otherwise it will eventually end up as '\', 'D:\', etc.
-  if not path or path.endswith(os.sep):
-    return root
-  parent, folder = os.path.split(path)
-  parent_dict = _GetPathDict(root, parent)
-  if folder not in parent_dict:
-    parent_dict[folder] = dict()
-  return parent_dict[folder]
+    # |path| will eventually be empty (in the recursive calls) if it was initially
+    # relative; otherwise it will eventually end up as '\', 'D:\', etc.
+    if not path or path.endswith(os.sep):
+        return root
+    parent, folder = os.path.split(path)
+    parent_dict = _GetPathDict(root, parent)
+    if folder not in parent_dict:
+        parent_dict[folder] = dict()
+    return parent_dict[folder]
 
 
 def _DictsToFolders(base_path, bucket, flat):
-  # Convert to folders recursively.
-  children = []
-  for folder, contents in bucket.items():
-    if type(contents) == dict:
-      folder_children = _DictsToFolders(os.path.join(base_path, folder),
-                                        contents, flat)
-      if flat:
-        children += folder_children
-      else:
-        folder_children = MSVSNew.MSVSFolder(os.path.join(base_path, folder),
-                                             name='(' + folder + ')',
-                                             entries=folder_children)
-        children.append(folder_children)
-    else:
-      children.append(contents)
-  return children
+    # Convert to folders recursively.
+    children = []
+    for folder, contents in bucket.items():
+        if type(contents) == dict:
+            folder_children = _DictsToFolders(
+                os.path.join(base_path, folder), contents, flat
+            )
+            if flat:
+                children += folder_children
+            else:
+                folder_children = MSVSNew.MSVSFolder(
+                    os.path.join(base_path, folder),
+                    name="(" + folder + ")",
+                    entries=folder_children,
+                )
+                children.append(folder_children)
+        else:
+            children.append(contents)
+    return children
 
 
 def _CollapseSingles(parent, node):
-  # Recursively explorer the tree of dicts looking for projects which are
-  # the sole item in a folder which has the same name as the project. Bring
-  # such projects up one level.
-  if (type(node) == dict and
-      len(node) == 1 and
-      list(node)[0] == parent + '.vcproj'):
-    return node[list(node)[0]]
-  if type(node) != dict:
+    # Recursively explorer the tree of dicts looking for projects which are
+    # the sole item in a folder which has the same name as the project. Bring
+    # such projects up one level.
+    if type(node) == dict and len(node) == 1 and next(iter(node)) == parent + ".vcproj":
+        return node[next(iter(node))]
+    if type(node) != dict:
+        return node
+    for child in node:
+        node[child] = _CollapseSingles(child, node[child])
     return node
-  for child in node:
-    node[child] = _CollapseSingles(child, node[child])
-  return node
 
 
 def _GatherSolutionFolders(sln_projects, project_objects, flat):
-  root = {}
-  # Convert into a tree of dicts on path.
-  for p in sln_projects:
-    gyp_file, target = gyp.common.ParseQualifiedTarget(p)[0:2]
-    gyp_dir = os.path.dirname(gyp_file)
-    path_dict = _GetPathDict(root, gyp_dir)
-    path_dict[target + '.vcproj'] = project_objects[p]
-  # Walk down from the top until we hit a folder that has more than one entry.
-  # In practice, this strips the top-level "src/" dir from the hierarchy in
-  # the solution.
-  while len(root) == 1 and type(root[list(root)[0]]) == dict:
-    root = root[list(root)[0]]
-  # Collapse singles.
-  root = _CollapseSingles('', root)
-  # Merge buckets until everything is a root entry.
-  return _DictsToFolders('', root, flat)
+    root = {}
+    # Convert into a tree of dicts on path.
+    for p in sln_projects:
+        gyp_file, target = gyp.common.ParseQualifiedTarget(p)[0:2]
+        if p.endswith("#host"):
+            target += "_host"
+        gyp_dir = os.path.dirname(gyp_file)
+        path_dict = _GetPathDict(root, gyp_dir)
+        path_dict[target + ".vcproj"] = project_objects[p]
+    # Walk down from the top until we hit a folder that has more than one entry.
+    # In practice, this strips the top-level "src/" dir from the hierarchy in
+    # the solution.
+    while len(root) == 1 and type(root[next(iter(root))]) == dict:
+        root = root[next(iter(root))]
+    # Collapse singles.
+    root = _CollapseSingles("", root)
+    # Merge buckets until everything is a root entry.
+    return _DictsToFolders("", root, flat)
 
 
 def _GetPathOfProject(qualified_target, spec, options, msvs_version):
-  default_config = _GetDefaultConfiguration(spec)
-  proj_filename = default_config.get('msvs_existing_vcproj')
-  if not proj_filename:
-    proj_filename = (spec['target_name'] + options.suffix +
-                     msvs_version.ProjectExtension())
-
-  build_file = gyp.common.BuildFile(qualified_target)
-  proj_path = os.path.join(os.path.dirname(build_file), proj_filename)
-  fix_prefix = None
-  if options.generator_output:
-    project_dir_path = os.path.dirname(os.path.abspath(proj_path))
-    proj_path = os.path.join(options.generator_output, proj_path)
-    fix_prefix = gyp.common.RelativePath(project_dir_path,
-                                         os.path.dirname(proj_path))
-  return proj_path, fix_prefix
+    default_config = _GetDefaultConfiguration(spec)
+    proj_filename = default_config.get("msvs_existing_vcproj")
+    if not proj_filename:
+        proj_filename = spec["target_name"]
+        if spec["toolset"] == "host":
+            proj_filename += "_host"
+        proj_filename = proj_filename + options.suffix + msvs_version.ProjectExtension()
+
+    build_file = gyp.common.BuildFile(qualified_target)
+    proj_path = os.path.join(os.path.dirname(build_file), proj_filename)
+    fix_prefix = None
+    if options.generator_output:
+        project_dir_path = os.path.dirname(os.path.abspath(proj_path))
+        proj_path = os.path.join(options.generator_output, proj_path)
+        fix_prefix = gyp.common.RelativePath(
+            project_dir_path, os.path.dirname(proj_path)
+        )
+    return proj_path, fix_prefix
 
 
 def _GetPlatformOverridesOfProject(spec):
-  # Prepare a dict indicating which project configurations are used for which
-  # solution configurations for this target.
-  config_platform_overrides = {}
-  for config_name, c in spec['configurations'].items():
-    config_fullname = _ConfigFullName(config_name, c)
-    platform = c.get('msvs_target_platform', _ConfigPlatform(c))
-    fixed_config_fullname = '%s|%s' % (
-        _ConfigBaseName(config_name, _ConfigPlatform(c)), platform)
-    config_platform_overrides[config_fullname] = fixed_config_fullname
-  return config_platform_overrides
+    # Prepare a dict indicating which project configurations are used for which
+    # solution configurations for this target.
+    config_platform_overrides = {}
+    for config_name, c in spec["configurations"].items():
+        config_fullname = _ConfigFullName(config_name, c)
+        platform = c.get("msvs_target_platform", _ConfigPlatform(c))
+        fixed_config_fullname = "%s|%s" % (
+            _ConfigBaseName(config_name, _ConfigPlatform(c)),
+            platform,
+        )
+        if spec["toolset"] == "host" and generator_supports_multiple_toolsets:
+            fixed_config_fullname = "%s|x64" % (config_name,)
+        config_platform_overrides[config_fullname] = fixed_config_fullname
+    return config_platform_overrides
 
 
 def _CreateProjectObjects(target_list, target_dicts, options, msvs_version):
-  """Create a MSVSProject object for the targets found in target list.
+    """Create a MSVSProject object for the targets found in target list.
 
   Arguments:
     target_list: the list of targets to generate project objects for.
@@ -1857,46 +1919,48 @@ def _CreateProjectObjects(target_list, target_dicts, options, msvs_version):
   Returns:
     A set of created projects, keyed by target.
   """
-  global fixpath_prefix
-  # Generate each project.
-  projects = {}
-  for qualified_target in target_list:
-    spec = target_dicts[qualified_target]
-    if spec['toolset'] != 'target':
-      raise GypError(
-          'Multiple toolsets not supported in msvs build (target %s)' %
-          qualified_target)
-    proj_path, fixpath_prefix = _GetPathOfProject(qualified_target, spec,
-                                                  options, msvs_version)
-    guid = _GetGuidOfProject(proj_path, spec)
-    overrides = _GetPlatformOverridesOfProject(spec)
-    build_file = gyp.common.BuildFile(qualified_target)
-    # Create object for this project.
-    obj = MSVSNew.MSVSProject(
-        proj_path,
-        name=spec['target_name'],
-        guid=guid,
-        spec=spec,
-        build_file=build_file,
-        config_platform_overrides=overrides,
-        fixpath_prefix=fixpath_prefix)
-    # Set project toolset if any (MS build only)
-    if msvs_version.UsesVcxproj():
-      obj.set_msbuild_toolset(
-          _GetMsbuildToolsetOfProject(proj_path, spec, msvs_version))
-    projects[qualified_target] = obj
-  # Set all the dependencies, but not if we are using an external builder like
-  # ninja
-  for project in projects.values():
-    if not project.spec.get('msvs_external_builder'):
-      deps = project.spec.get('dependencies', [])
-      deps = [projects[d] for d in deps]
-      project.set_dependencies(deps)
-  return projects
+    global fixpath_prefix
+    # Generate each project.
+    projects = {}
+    for qualified_target in target_list:
+        spec = target_dicts[qualified_target]
+        proj_path, fixpath_prefix = _GetPathOfProject(
+            qualified_target, spec, options, msvs_version
+        )
+        guid = _GetGuidOfProject(proj_path, spec)
+        overrides = _GetPlatformOverridesOfProject(spec)
+        build_file = gyp.common.BuildFile(qualified_target)
+        # Create object for this project.
+        target_name = spec["target_name"]
+        if spec["toolset"] == "host":
+            target_name += "_host"
+        obj = MSVSNew.MSVSProject(
+            proj_path,
+            name=target_name,
+            guid=guid,
+            spec=spec,
+            build_file=build_file,
+            config_platform_overrides=overrides,
+            fixpath_prefix=fixpath_prefix,
+        )
+        # Set project toolset if any (MS build only)
+        if msvs_version.UsesVcxproj():
+            obj.set_msbuild_toolset(
+                _GetMsbuildToolsetOfProject(proj_path, spec, msvs_version)
+            )
+        projects[qualified_target] = obj
+    # Set all the dependencies, but not if we are using an external builder like
+    # ninja
+    for project in projects.values():
+        if not project.spec.get("msvs_external_builder"):
+            deps = project.spec.get("dependencies", [])
+            deps = [projects[d] for d in deps]
+            project.set_dependencies(deps)
+    return projects
 
 
 def _InitNinjaFlavor(params, target_list, target_dicts):
-  """Initialize targets for the ninja flavor.
+    """Initialize targets for the ninja flavor.
 
   This sets up the necessary variables in the targets to generate msvs projects
   that use ninja as an external builder. The variables in the spec are only set
@@ -1907,106 +1971,115 @@ def _InitNinjaFlavor(params, target_list, target_dicts):
     target_list: List of target pairs: 'base/base.gyp:base'.
     target_dicts: Dict of target properties keyed on target pair.
   """
-  for qualified_target in target_list:
-    spec = target_dicts[qualified_target]
-    if spec.get('msvs_external_builder'):
-      # The spec explicitly defined an external builder, so don't change it.
-      continue
-
-    path_to_ninja = spec.get('msvs_path_to_ninja', 'ninja.exe')
-
-    spec['msvs_external_builder'] = 'ninja'
-    if not spec.get('msvs_external_builder_out_dir'):
-      gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
-      gyp_dir = os.path.dirname(gyp_file)
-      configuration = '$(Configuration)'
-      if params.get('target_arch') == 'x64':
-        configuration += '_x64'
-      if params.get('target_arch') == 'arm64':
-        configuration += '_arm64'
-      spec['msvs_external_builder_out_dir'] = os.path.join(
-          gyp.common.RelativePath(params['options'].toplevel_dir, gyp_dir),
-          ninja_generator.ComputeOutputDir(params),
-          configuration)
-    if not spec.get('msvs_external_builder_build_cmd'):
-      spec['msvs_external_builder_build_cmd'] = [
-        path_to_ninja,
-        '-C',
-        '$(OutDir)',
-        '$(ProjectName)',
-      ]
-    if not spec.get('msvs_external_builder_clean_cmd'):
-      spec['msvs_external_builder_clean_cmd'] = [
-        path_to_ninja,
-        '-C',
-        '$(OutDir)',
-        '-tclean',
-        '$(ProjectName)',
-      ]
+    for qualified_target in target_list:
+        spec = target_dicts[qualified_target]
+        if spec.get("msvs_external_builder"):
+            # The spec explicitly defined an external builder, so don't change it.
+            continue
+
+        path_to_ninja = spec.get("msvs_path_to_ninja", "ninja.exe")
+
+        spec["msvs_external_builder"] = "ninja"
+        if not spec.get("msvs_external_builder_out_dir"):
+            gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
+            gyp_dir = os.path.dirname(gyp_file)
+            configuration = "$(Configuration)"
+            if params.get("target_arch") == "x64":
+                configuration += "_x64"
+            if params.get("target_arch") == "arm64":
+                configuration += "_arm64"
+            spec["msvs_external_builder_out_dir"] = os.path.join(
+                gyp.common.RelativePath(params["options"].toplevel_dir, gyp_dir),
+                ninja_generator.ComputeOutputDir(params),
+                configuration,
+            )
+        if not spec.get("msvs_external_builder_build_cmd"):
+            spec["msvs_external_builder_build_cmd"] = [
+                path_to_ninja,
+                "-C",
+                "$(OutDir)",
+                "$(ProjectName)",
+            ]
+        if not spec.get("msvs_external_builder_clean_cmd"):
+            spec["msvs_external_builder_clean_cmd"] = [
+                path_to_ninja,
+                "-C",
+                "$(OutDir)",
+                "-tclean",
+                "$(ProjectName)",
+            ]
 
 
 def CalculateVariables(default_variables, params):
-  """Generated variables that require params to be known."""
-
-  generator_flags = params.get('generator_flags', {})
-
-  # Select project file format version (if unset, default to auto detecting).
-  msvs_version = MSVSVersion.SelectVisualStudioVersion(
-      generator_flags.get('msvs_version', 'auto'))
-  # Stash msvs_version for later (so we don't have to probe the system twice).
-  params['msvs_version'] = msvs_version
-
-  # Set a variable so conditions can be based on msvs_version.
-  default_variables['MSVS_VERSION'] = msvs_version.ShortName()
-
-  # To determine processor word size on Windows, in addition to checking
-  # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
-  # process), it is also necessary to check PROCESSOR_ARCITEW6432 (which
-  # contains the actual word size of the system when running thru WOW64).
-  if (os.environ.get('PROCESSOR_ARCHITECTURE', '').find('64') >= 0 or
-      os.environ.get('PROCESSOR_ARCHITEW6432', '').find('64') >= 0):
-    default_variables['MSVS_OS_BITS'] = 64
-  else:
-    default_variables['MSVS_OS_BITS'] = 32
+    """Generated variables that require params to be known."""
+
+    generator_flags = params.get("generator_flags", {})
+
+    # Select project file format version (if unset, default to auto detecting).
+    msvs_version = MSVSVersion.SelectVisualStudioVersion(
+        generator_flags.get("msvs_version", "auto")
+    )
+    # Stash msvs_version for later (so we don't have to probe the system twice).
+    params["msvs_version"] = msvs_version
+
+    # Set a variable so conditions can be based on msvs_version.
+    default_variables["MSVS_VERSION"] = msvs_version.ShortName()
+
+    # To determine processor word size on Windows, in addition to checking
+    # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
+    # process), it is also necessary to check PROCESSOR_ARCITEW6432 (which
+    # contains the actual word size of the system when running thru WOW64).
+    if (
+        os.environ.get("PROCESSOR_ARCHITECTURE", "").find("64") >= 0
+        or os.environ.get("PROCESSOR_ARCHITEW6432", "").find("64") >= 0
+    ):
+        default_variables["MSVS_OS_BITS"] = 64
+    else:
+        default_variables["MSVS_OS_BITS"] = 32
 
-  if gyp.common.GetFlavor(params) == 'ninja':
-    default_variables['SHARED_INTERMEDIATE_DIR'] = '$(OutDir)gen'
+    if gyp.common.GetFlavor(params) == "ninja":
+        default_variables["SHARED_INTERMEDIATE_DIR"] = "$(OutDir)gen"
 
 
 def PerformBuild(data, configurations, params):
-  options = params['options']
-  msvs_version = params['msvs_version']
-  devenv = os.path.join(msvs_version.path, 'Common7', 'IDE', 'devenv.com')
-
-  for build_file, build_file_dict in data.items():
-    (build_file_root, build_file_ext) = os.path.splitext(build_file)
-    if build_file_ext != '.gyp':
-      continue
-    sln_path = build_file_root + options.suffix + '.sln'
-    if options.generator_output:
-      sln_path = os.path.join(options.generator_output, sln_path)
+    options = params["options"]
+    msvs_version = params["msvs_version"]
+    devenv = os.path.join(msvs_version.path, "Common7", "IDE", "devenv.com")
+
+    for build_file, build_file_dict in data.items():
+        (build_file_root, build_file_ext) = os.path.splitext(build_file)
+        if build_file_ext != ".gyp":
+            continue
+        sln_path = build_file_root + options.suffix + ".sln"
+        if options.generator_output:
+            sln_path = os.path.join(options.generator_output, sln_path)
 
-  for config in configurations:
-    arguments = [devenv, sln_path, '/Build', config]
-    print('Building [%s]: %s' % (config, arguments))
-    rtn = subprocess.check_call(arguments)
+    for config in configurations:
+        arguments = [devenv, sln_path, "/Build", config]
+        print("Building [%s]: %s" % (config, arguments))
+        subprocess.check_call(arguments)
 
 
 def CalculateGeneratorInputInfo(params):
-  if params.get('flavor') == 'ninja':
-    toplevel = params['options'].toplevel_dir
-    qualified_out_dir = os.path.normpath(os.path.join(
-        toplevel, ninja_generator.ComputeOutputDir(params),
-        'gypfiles-msvs-ninja'))
-
-    global generator_filelist_paths
-    generator_filelist_paths = {
-        'toplevel': toplevel,
-        'qualified_out_dir': qualified_out_dir,
-    }
+    if params.get("flavor") == "ninja":
+        toplevel = params["options"].toplevel_dir
+        qualified_out_dir = os.path.normpath(
+            os.path.join(
+                toplevel,
+                ninja_generator.ComputeOutputDir(params),
+                "gypfiles-msvs-ninja",
+            )
+        )
+
+        global generator_filelist_paths
+        generator_filelist_paths = {
+            "toplevel": toplevel,
+            "qualified_out_dir": qualified_out_dir,
+        }
+
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  """Generate .sln and .vcproj files.
+    """Generate .sln and .vcproj files.
 
   This is the entry point for this generator.
   Arguments:
@@ -2014,82 +2087,98 @@ def GenerateOutput(target_list, target_dicts, data, params):
     target_dicts: Dict of target properties keyed on target pair.
     data: Dictionary containing per .gyp data.
   """
-  global fixpath_prefix
-
-  options = params['options']
-
-  # Get the project file format version back out of where we stashed it in
-  # GeneratorCalculatedVariables.
-  msvs_version = params['msvs_version']
-
-  generator_flags = params.get('generator_flags', {})
-
-  # Optionally shard targets marked with 'msvs_shard': SHARD_COUNT.
-  (target_list, target_dicts) = MSVSUtil.ShardTargets(target_list, target_dicts)
-
-  # Optionally use the large PDB workaround for targets marked with
-  # 'msvs_large_pdb': 1.
-  (target_list, target_dicts) = MSVSUtil.InsertLargePdbShims(
-        target_list, target_dicts, generator_default_variables)
-
-  # Optionally configure each spec to use ninja as the external builder.
-  if params.get('flavor') == 'ninja':
-    _InitNinjaFlavor(params, target_list, target_dicts)
-
-  # Prepare the set of configurations.
-  configs = set()
-  for qualified_target in target_list:
-    spec = target_dicts[qualified_target]
-    for config_name, config in spec['configurations'].items():
-      configs.add(_ConfigFullName(config_name, config))
-  configs = list(configs)
-
-  # Figure out all the projects that will be generated and their guids
-  project_objects = _CreateProjectObjects(target_list, target_dicts, options,
-                                          msvs_version)
-
-  # Generate each project.
-  missing_sources = []
-  for project in project_objects.values():
-    fixpath_prefix = project.fixpath_prefix
-    missing_sources.extend(_GenerateProject(project, options, msvs_version,
-                                            generator_flags))
-  fixpath_prefix = None
-
-  for build_file in data:
-    # Validate build_file extension
-    if not build_file.endswith('.gyp'):
-      continue
-    sln_path = os.path.splitext(build_file)[0] + options.suffix + '.sln'
-    if options.generator_output:
-      sln_path = os.path.join(options.generator_output, sln_path)
-    # Get projects in the solution, and their dependents.
-    sln_projects = gyp.common.BuildFileTargets(target_list, build_file)
-    sln_projects += gyp.common.DeepDependencyTargets(target_dicts, sln_projects)
-    # Create folder hierarchy.
-    root_entries = _GatherSolutionFolders(
-        sln_projects, project_objects, flat=msvs_version.FlatSolution())
-    # Create solution.
-    sln = MSVSNew.MSVSSolution(sln_path,
-                               entries=root_entries,
-                               variants=configs,
-                               websiteProperties=False,
-                               version=msvs_version)
-    sln.Write()
-
-  if missing_sources:
-    error_message = "Missing input files:\n" + \
-                    '\n'.join(set(missing_sources))
-    if generator_flags.get('msvs_error_on_missing_sources', False):
-      raise GypError(error_message)
-    else:
-      print("Warning: " + error_message, file=sys.stdout)
+    global fixpath_prefix
+
+    options = params["options"]
+
+    # Get the project file format version back out of where we stashed it in
+    # GeneratorCalculatedVariables.
+    msvs_version = params["msvs_version"]
+
+    generator_flags = params.get("generator_flags", {})
+
+    # Optionally shard targets marked with 'msvs_shard': SHARD_COUNT.
+    (target_list, target_dicts) = MSVSUtil.ShardTargets(target_list, target_dicts)
+
+    # Optionally use the large PDB workaround for targets marked with
+    # 'msvs_large_pdb': 1.
+    (target_list, target_dicts) = MSVSUtil.InsertLargePdbShims(
+        target_list, target_dicts, generator_default_variables
+    )
+
+    # Optionally configure each spec to use ninja as the external builder.
+    if params.get("flavor") == "ninja":
+        _InitNinjaFlavor(params, target_list, target_dicts)
+
+    # Prepare the set of configurations.
+    configs = set()
+    for qualified_target in target_list:
+        spec = target_dicts[qualified_target]
+        for config_name, config in spec["configurations"].items():
+            config_name = _ConfigFullName(config_name, config)
+            configs.add(config_name)
+            if config_name == "Release|arm64":
+                configs.add("Release|x64")
+    configs = list(configs)
+
+    # Figure out all the projects that will be generated and their guids
+    project_objects = _CreateProjectObjects(
+        target_list, target_dicts, options, msvs_version
+    )
+
+    # Generate each project.
+    missing_sources = []
+    for project in project_objects.values():
+        fixpath_prefix = project.fixpath_prefix
+        missing_sources.extend(
+            _GenerateProject(project, options, msvs_version, generator_flags, spec)
+        )
+    fixpath_prefix = None
+
+    for build_file in data:
+        # Validate build_file extension
+        target_only_configs = configs
+        if generator_supports_multiple_toolsets:
+            target_only_configs = [i for i in configs if i.endswith("arm64")]
+        if not build_file.endswith(".gyp"):
+            continue
+        sln_path = os.path.splitext(build_file)[0] + options.suffix + ".sln"
+        if options.generator_output:
+            sln_path = os.path.join(options.generator_output, sln_path)
+        # Get projects in the solution, and their dependents.
+        sln_projects = gyp.common.BuildFileTargets(target_list, build_file)
+        sln_projects += gyp.common.DeepDependencyTargets(target_dicts, sln_projects)
+        # Create folder hierarchy.
+        root_entries = _GatherSolutionFolders(
+            sln_projects, project_objects, flat=msvs_version.FlatSolution()
+        )
+        # Create solution.
+        sln = MSVSNew.MSVSSolution(
+            sln_path,
+            entries=root_entries,
+            variants=target_only_configs,
+            websiteProperties=False,
+            version=msvs_version,
+        )
+        sln.Write()
+
+    if missing_sources:
+        error_message = "Missing input files:\n" + "\n".join(set(missing_sources))
+        if generator_flags.get("msvs_error_on_missing_sources", False):
+            raise GypError(error_message)
+        else:
+            print("Warning: " + error_message, file=sys.stdout)
 
 
-def _GenerateMSBuildFiltersFile(filters_path, source_files,
-                                rule_dependencies, extension_to_rule_name,
-                                platforms):
-  """Generate the filters file.
+def _GenerateMSBuildFiltersFile(
+    filters_path,
+    source_files,
+    rule_dependencies,
+    extension_to_rule_name,
+    platforms,
+    toolset,
+):
+    """Generate the filters file.
 
   This file is used by Visual Studio to organize the presentation of source
   files into folders.
@@ -2099,29 +2188,45 @@ def _GenerateMSBuildFiltersFile(filters_path, source_files,
       source_files: The hierarchical structure of all the sources.
       extension_to_rule_name: A dictionary mapping file extensions to rules.
   """
-  filter_group = []
-  source_group = []
-  _AppendFiltersForMSBuild('', source_files, rule_dependencies,
-                           extension_to_rule_name, platforms,
-                           filter_group, source_group)
-  if filter_group:
-    content = ['Project',
-               {'ToolsVersion': '4.0',
-                'xmlns': 'http://schemas.microsoft.com/developer/msbuild/2003'
-               },
-               ['ItemGroup'] + filter_group,
-               ['ItemGroup'] + source_group
-              ]
-    easy_xml.WriteXmlIfChanged(content, filters_path, pretty=True, win32=True)
-  elif os.path.exists(filters_path):
-    # We don't need this filter anymore.  Delete the old filter file.
-    os.unlink(filters_path)
-
-
-def _AppendFiltersForMSBuild(parent_filter_name, sources, rule_dependencies,
-                             extension_to_rule_name, platforms,
-                             filter_group, source_group):
-  """Creates the list of filters and sources to be added in the filter file.
+    filter_group = []
+    source_group = []
+    _AppendFiltersForMSBuild(
+        "",
+        source_files,
+        rule_dependencies,
+        extension_to_rule_name,
+        platforms,
+        toolset,
+        filter_group,
+        source_group,
+    )
+    if filter_group:
+        content = [
+            "Project",
+            {
+                "ToolsVersion": "4.0",
+                "xmlns": "http://schemas.microsoft.com/developer/msbuild/2003",
+            },
+            ["ItemGroup"] + filter_group,
+            ["ItemGroup"] + source_group,
+        ]
+        easy_xml.WriteXmlIfChanged(content, filters_path, pretty=True, win32=True)
+    elif os.path.exists(filters_path):
+        # We don't need this filter anymore.  Delete the old filter file.
+        os.unlink(filters_path)
+
+
+def _AppendFiltersForMSBuild(
+    parent_filter_name,
+    sources,
+    rule_dependencies,
+    extension_to_rule_name,
+    platforms,
+    toolset,
+    filter_group,
+    source_group,
+):
+    """Creates the list of filters and sources to be added in the filter file.
 
   Args:
       parent_filter_name: The name of the filter under which the sources are
@@ -2129,38 +2234,50 @@ def _AppendFiltersForMSBuild(parent_filter_name, sources, rule_dependencies,
       sources: The hierarchy of filters and sources to process.
       extension_to_rule_name: A dictionary mapping file extensions to rules.
       filter_group: The list to which filter entries will be appended.
-      source_group: The list to which source entries will be appeneded.
+      source_group: The list to which source entries will be appended.
   """
-  for source in sources:
-    if isinstance(source, MSVSProject.Filter):
-      # We have a sub-filter.  Create the name of that sub-filter.
-      if not parent_filter_name:
-        filter_name = source.name
-      else:
-        filter_name = '%s\\%s' % (parent_filter_name, source.name)
-      # Add the filter to the group.
-      filter_group.append(
-          ['Filter', {'Include': filter_name},
-           ['UniqueIdentifier', MSVSNew.MakeGuid(source.name)]])
-      # Recurse and add its dependents.
-      _AppendFiltersForMSBuild(filter_name, source.contents,
-                               rule_dependencies, extension_to_rule_name,
-                               platforms, filter_group, source_group)
-    else:
-      # It's a source.  Create a source entry.
-      _, element = _MapFileToMsBuildSourceType(source, rule_dependencies,
-                                               extension_to_rule_name,
-                                               platforms)
-      source_entry = [element, {'Include': source}]
-      # Specify the filter it is part of, if any.
-      if parent_filter_name:
-        source_entry.append(['Filter', parent_filter_name])
-      source_group.append(source_entry)
-
-
-def _MapFileToMsBuildSourceType(source, rule_dependencies,
-                                extension_to_rule_name, platforms):
-  """Returns the group and element type of the source file.
+    for source in sources:
+        if isinstance(source, MSVSProject.Filter):
+            # We have a sub-filter.  Create the name of that sub-filter.
+            if not parent_filter_name:
+                filter_name = source.name
+            else:
+                filter_name = "%s\\%s" % (parent_filter_name, source.name)
+            # Add the filter to the group.
+            filter_group.append(
+                [
+                    "Filter",
+                    {"Include": filter_name},
+                    ["UniqueIdentifier", MSVSNew.MakeGuid(source.name)],
+                ]
+            )
+            # Recurse and add its dependents.
+            _AppendFiltersForMSBuild(
+                filter_name,
+                source.contents,
+                rule_dependencies,
+                extension_to_rule_name,
+                platforms,
+                toolset,
+                filter_group,
+                source_group,
+            )
+        else:
+            # It's a source.  Create a source entry.
+            _, element = _MapFileToMsBuildSourceType(
+                source, rule_dependencies, extension_to_rule_name, platforms, toolset
+            )
+            source_entry = [element, {"Include": source}]
+            # Specify the filter it is part of, if any.
+            if parent_filter_name:
+                source_entry.append(["Filter", parent_filter_name])
+            source_group.append(source_entry)
+
+
+def _MapFileToMsBuildSourceType(
+    source, rule_dependencies, extension_to_rule_name, platforms, toolset
+):
+    """Returns the group and element type of the source file.
 
   Arguments:
       source: The source file name.
@@ -2169,85 +2286,92 @@ def _MapFileToMsBuildSourceType(source, rule_dependencies,
   Returns:
       A pair of (group this file should be part of, the label of element)
   """
-  _, ext = os.path.splitext(source)
-  ext = ext.lower()
-  if ext in extension_to_rule_name:
-    group = 'rule'
-    element = extension_to_rule_name[ext]
-  elif ext in ['.cc', '.cpp', '.c', '.cxx', '.mm']:
-    group = 'compile'
-    element = 'ClCompile'
-  elif ext in ['.h', '.hxx']:
-    group = 'include'
-    element = 'ClInclude'
-  elif ext == '.rc':
-    group = 'resource'
-    element = 'ResourceCompile'
-  elif ext in ['.s', '.asm']:
-    group = 'masm'
-    element = 'MASM'
-    for platform in platforms:
-      if platform.lower() in ['arm', 'arm64']:
-        element = 'MARMASM'
-  elif ext == '.idl':
-    group = 'midl'
-    element = 'Midl'
-  elif source in rule_dependencies:
-    group = 'rule_dependency'
-    element = 'CustomBuild'
-  else:
-    group = 'none'
-    element = 'None'
-  return (group, element)
-
-
-def _GenerateRulesForMSBuild(output_dir, options, spec,
-                             sources, excluded_sources,
-                             props_files_of_rules, targets_files_of_rules,
-                             actions_to_add, rule_dependencies,
-                             extension_to_rule_name):
-  # MSBuild rules are implemented using three files: an XML file, a .targets
-  # file and a .props file.
-  # See http://blogs.msdn.com/b/vcblog/archive/2010/04/21/quick-help-on-vs2010-custom-build-rule.aspx
-  # for more details.
-  rules = spec.get('rules', [])
-  rules_native = [r for r in rules if not int(r.get('msvs_external_rule', 0))]
-  rules_external = [r for r in rules if int(r.get('msvs_external_rule', 0))]
-
-  msbuild_rules = []
-  for rule in rules_native:
-    # Skip a rule with no action and no inputs.
-    if 'action' not in rule and not rule.get('rule_sources', []):
-      continue
-    msbuild_rule = MSBuildRule(rule, spec)
-    msbuild_rules.append(msbuild_rule)
-    rule_dependencies.update(msbuild_rule.additional_dependencies.split(';'))
-    extension_to_rule_name[msbuild_rule.extension] = msbuild_rule.rule_name
-  if msbuild_rules:
-    base = spec['target_name'] + options.suffix
-    props_name = base + '.props'
-    targets_name = base + '.targets'
-    xml_name = base + '.xml'
-
-    props_files_of_rules.add(props_name)
-    targets_files_of_rules.add(targets_name)
-
-    props_path = os.path.join(output_dir, props_name)
-    targets_path = os.path.join(output_dir, targets_name)
-    xml_path = os.path.join(output_dir, xml_name)
-
-    _GenerateMSBuildRulePropsFile(props_path, msbuild_rules)
-    _GenerateMSBuildRuleTargetsFile(targets_path, msbuild_rules)
-    _GenerateMSBuildRuleXmlFile(xml_path, msbuild_rules)
-
-  if rules_external:
-    _GenerateExternalRules(rules_external, output_dir, spec,
-                           sources, options, actions_to_add)
-  _AdjustSourcesForRules(rules, sources, excluded_sources, True)
+    _, ext = os.path.splitext(source)
+    ext = ext.lower()
+    if ext in extension_to_rule_name:
+        group = "rule"
+        element = extension_to_rule_name[ext]
+    elif ext in [".cc", ".cpp", ".c", ".cxx", ".mm"]:
+        group = "compile"
+        element = "ClCompile"
+    elif ext in [".h", ".hxx"]:
+        group = "include"
+        element = "ClInclude"
+    elif ext == ".rc":
+        group = "resource"
+        element = "ResourceCompile"
+    elif ext in [".s", ".asm"]:
+        group = "masm"
+        element = "MASM"
+        if "arm64" in platforms and toolset == "target":
+            element = "MARMASM"
+    elif ext == ".idl":
+        group = "midl"
+        element = "Midl"
+    elif source in rule_dependencies:
+        group = "rule_dependency"
+        element = "CustomBuild"
+    else:
+        group = "none"
+        element = "None"
+    return (group, element)
+
+
+def _GenerateRulesForMSBuild(
+    output_dir,
+    options,
+    spec,
+    sources,
+    excluded_sources,
+    props_files_of_rules,
+    targets_files_of_rules,
+    actions_to_add,
+    rule_dependencies,
+    extension_to_rule_name,
+):
+    # MSBuild rules are implemented using three files: an XML file, a .targets
+    # file and a .props file.
+    # For more details see:
+    # https://devblogs.microsoft.com/cppblog/quick-help-on-vs2010-custom-build-rule/
+    rules = spec.get("rules", [])
+    rules_native = [r for r in rules if not int(r.get("msvs_external_rule", 0))]
+    rules_external = [r for r in rules if int(r.get("msvs_external_rule", 0))]
+
+    msbuild_rules = []
+    for rule in rules_native:
+        # Skip a rule with no action and no inputs.
+        if "action" not in rule and not rule.get("rule_sources", []):
+            continue
+        msbuild_rule = MSBuildRule(rule, spec)
+        msbuild_rules.append(msbuild_rule)
+        rule_dependencies.update(msbuild_rule.additional_dependencies.split(";"))
+        extension_to_rule_name[msbuild_rule.extension] = msbuild_rule.rule_name
+    if msbuild_rules:
+        base = spec["target_name"] + options.suffix
+        props_name = base + ".props"
+        targets_name = base + ".targets"
+        xml_name = base + ".xml"
+
+        props_files_of_rules.add(props_name)
+        targets_files_of_rules.add(targets_name)
+
+        props_path = os.path.join(output_dir, props_name)
+        targets_path = os.path.join(output_dir, targets_name)
+        xml_path = os.path.join(output_dir, xml_name)
+
+        _GenerateMSBuildRulePropsFile(props_path, msbuild_rules)
+        _GenerateMSBuildRuleTargetsFile(targets_path, msbuild_rules)
+        _GenerateMSBuildRuleXmlFile(xml_path, msbuild_rules)
+
+    if rules_external:
+        _GenerateExternalRules(
+            rules_external, output_dir, spec, sources, options, actions_to_add
+        )
+    _AdjustSourcesForRules(rules, sources, excluded_sources, True)
 
 
 class MSBuildRule(object):
-  """Used to store information used to generate an MSBuild rule.
+    """Used to store information used to generate an MSBuild rule.
 
   Attributes:
     rule_name: The rule name, sanitized to use in XML.
@@ -2266,718 +2390,844 @@ class MSBuildRule(object):
     command: The command used to run the rule.
   """
 
-  def __init__(self, rule, spec):
-    self.display_name = rule['rule_name']
-    # Assure that the rule name is only characters and numbers
-    self.rule_name = re.sub(r'\W', '_', self.display_name)
-    # Create the various element names, following the example set by the
-    # Visual Studio 2008 to 2010 conversion.  I don't know if VS2010
-    # is sensitive to the exact names.
-    self.target_name = '_' + self.rule_name
-    self.after_targets = self.rule_name + 'AfterTargets'
-    self.before_targets = self.rule_name + 'BeforeTargets'
-    self.depends_on = self.rule_name + 'DependsOn'
-    self.compute_output = 'Compute%sOutput' % self.rule_name
-    self.dirs_to_make = self.rule_name + 'DirsToMake'
-    self.inputs = self.rule_name + '_inputs'
-    self.tlog = self.rule_name + '_tlog'
-    self.extension = rule['extension']
-    if not self.extension.startswith('.'):
-      self.extension = '.' + self.extension
-
-    self.description = MSVSSettings.ConvertVCMacrosToMSBuild(
-        rule.get('message', self.rule_name))
-    old_additional_dependencies = _FixPaths(rule.get('inputs', []))
-    self.additional_dependencies = (
-        ';'.join([MSVSSettings.ConvertVCMacrosToMSBuild(i)
-                  for i in old_additional_dependencies]))
-    old_outputs = _FixPaths(rule.get('outputs', []))
-    self.outputs = ';'.join([MSVSSettings.ConvertVCMacrosToMSBuild(i)
-                             for i in old_outputs])
-    old_command = _BuildCommandLineForRule(spec, rule, has_input_path=True,
-                                           do_setup_env=True)
-    self.command = MSVSSettings.ConvertVCMacrosToMSBuild(old_command)
+    def __init__(self, rule, spec):
+        self.display_name = rule["rule_name"]
+        # Assure that the rule name is only characters and numbers
+        self.rule_name = re.sub(r"\W", "_", self.display_name)
+        # Create the various element names, following the example set by the
+        # Visual Studio 2008 to 2010 conversion.  I don't know if VS2010
+        # is sensitive to the exact names.
+        self.target_name = "_" + self.rule_name
+        self.after_targets = self.rule_name + "AfterTargets"
+        self.before_targets = self.rule_name + "BeforeTargets"
+        self.depends_on = self.rule_name + "DependsOn"
+        self.compute_output = "Compute%sOutput" % self.rule_name
+        self.dirs_to_make = self.rule_name + "DirsToMake"
+        self.inputs = self.rule_name + "_inputs"
+        self.tlog = self.rule_name + "_tlog"
+        self.extension = rule["extension"]
+        if not self.extension.startswith("."):
+            self.extension = "." + self.extension
+
+        self.description = MSVSSettings.ConvertVCMacrosToMSBuild(
+            rule.get("message", self.rule_name)
+        )
+        old_additional_dependencies = _FixPaths(rule.get("inputs", []))
+        self.additional_dependencies = ";".join(
+            [
+                MSVSSettings.ConvertVCMacrosToMSBuild(i)
+                for i in old_additional_dependencies
+            ]
+        )
+        old_outputs = _FixPaths(rule.get("outputs", []))
+        self.outputs = ";".join(
+            [MSVSSettings.ConvertVCMacrosToMSBuild(i) for i in old_outputs]
+        )
+        old_command = _BuildCommandLineForRule(
+            spec, rule, has_input_path=True, do_setup_env=True
+        )
+        self.command = MSVSSettings.ConvertVCMacrosToMSBuild(old_command)
 
 
 def _GenerateMSBuildRulePropsFile(props_path, msbuild_rules):
-  """Generate the .props file."""
-  content = ['Project',
-             {'xmlns': 'http://schemas.microsoft.com/developer/msbuild/2003'}]
-  for rule in msbuild_rules:
-    content.extend([
-        ['PropertyGroup',
-         {'Condition': "'$(%s)' == '' and '$(%s)' == '' and "
-          "'$(ConfigurationType)' != 'Makefile'" % (rule.before_targets,
-                                                    rule.after_targets)
-         },
-         [rule.before_targets, 'Midl'],
-         [rule.after_targets, 'CustomBuild'],
-        ],
-        ['PropertyGroup',
-         [rule.depends_on,
-          {'Condition': "'$(ConfigurationType)' != 'Makefile'"},
-          '_SelectedFiles;$(%s)' % rule.depends_on
-         ],
-        ],
-        ['ItemDefinitionGroup',
-         [rule.rule_name,
-          ['CommandLineTemplate', rule.command],
-          ['Outputs', rule.outputs],
-          ['ExecutionDescription', rule.description],
-          ['AdditionalDependencies', rule.additional_dependencies],
-         ],
-        ]
-    ])
-  easy_xml.WriteXmlIfChanged(content, props_path, pretty=True, win32=True)
+    """Generate the .props file."""
+    content = [
+        "Project",
+        {"xmlns": "http://schemas.microsoft.com/developer/msbuild/2003"},
+    ]
+    for rule in msbuild_rules:
+        content.extend(
+            [
+                [
+                    "PropertyGroup",
+                    {
+                        "Condition": "'$(%s)' == '' and '$(%s)' == '' and "
+                        "'$(ConfigurationType)' != 'Makefile'"
+                        % (rule.before_targets, rule.after_targets)
+                    },
+                    [rule.before_targets, "Midl"],
+                    [rule.after_targets, "CustomBuild"],
+                ],
+                [
+                    "PropertyGroup",
+                    [
+                        rule.depends_on,
+                        {"Condition": "'$(ConfigurationType)' != 'Makefile'"},
+                        "_SelectedFiles;$(%s)" % rule.depends_on,
+                    ],
+                ],
+                [
+                    "ItemDefinitionGroup",
+                    [
+                        rule.rule_name,
+                        ["CommandLineTemplate", rule.command],
+                        ["Outputs", rule.outputs],
+                        ["ExecutionDescription", rule.description],
+                        ["AdditionalDependencies", rule.additional_dependencies],
+                    ],
+                ],
+            ]
+        )
+    easy_xml.WriteXmlIfChanged(content, props_path, pretty=True, win32=True)
 
 
 def _GenerateMSBuildRuleTargetsFile(targets_path, msbuild_rules):
-  """Generate the .targets file."""
-  content = ['Project',
-             {'xmlns': 'http://schemas.microsoft.com/developer/msbuild/2003'
-             }
-            ]
-  item_group = [
-      'ItemGroup',
-      ['PropertyPageSchema',
-       {'Include': '$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml'}
-      ]
-    ]
-  for rule in msbuild_rules:
-    item_group.append(
-        ['AvailableItemName',
-         {'Include': rule.rule_name},
-         ['Targets', rule.target_name],
-        ])
-  content.append(item_group)
-
-  for rule in msbuild_rules:
-    content.append(
-        ['UsingTask',
-         {'TaskName': rule.rule_name,
-          'TaskFactory': 'XamlTaskFactory',
-          'AssemblyName': 'Microsoft.Build.Tasks.v4.0'
-         },
-         ['Task', '$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml'],
-        ])
-  for rule in msbuild_rules:
-    rule_name = rule.rule_name
-    target_outputs = '%%(%s.Outputs)' % rule_name
-    target_inputs = ('%%(%s.Identity);%%(%s.AdditionalDependencies);'
-                     '$(MSBuildProjectFile)') % (rule_name, rule_name)
-    rule_inputs = '%%(%s.Identity)' % rule_name
-    extension_condition = ("'%(Extension)'=='.obj' or "
-                           "'%(Extension)'=='.res' or "
-                           "'%(Extension)'=='.rsc' or "
-                           "'%(Extension)'=='.lib'")
-    remove_section = [
-        'ItemGroup',
-        {'Condition': "'@(SelectedFiles)' != ''"},
-        [rule_name,
-         {'Remove': '@(%s)' % rule_name,
-          'Condition': "'%(Identity)' != '@(SelectedFiles)'"
-         }
-        ]
+    """Generate the .targets file."""
+    content = [
+        "Project",
+        {"xmlns": "http://schemas.microsoft.com/developer/msbuild/2003"},
     ]
-    inputs_section = [
-        'ItemGroup',
-        [rule.inputs, {'Include': '%%(%s.AdditionalDependencies)' % rule_name}]
-    ]
-    logging_section = [
-        'ItemGroup',
-        [rule.tlog,
-         {'Include': '%%(%s.Outputs)' % rule_name,
-          'Condition': ("'%%(%s.Outputs)' != '' and "
-                        "'%%(%s.ExcludedFromBuild)' != 'true'" %
-                        (rule_name, rule_name))
-         },
-         ['Source', "@(%s, '|')" % rule_name],
-         ['Inputs', "@(%s -> '%%(Fullpath)', ';')" % rule.inputs],
+    item_group = [
+        "ItemGroup",
+        [
+            "PropertyPageSchema",
+            {"Include": "$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml"},
         ],
     ]
-    message_section = [
-        'Message',
-        {'Importance': 'High',
-         'Text': '%%(%s.ExecutionDescription)' % rule_name
-        }
-    ]
-    write_tlog_section = [
-        'WriteLinesToFile',
-        {'Condition': "'@(%s)' != '' and '%%(%s.ExcludedFromBuild)' != "
-         "'true'" % (rule.tlog, rule.tlog),
-         'File': '$(IntDir)$(ProjectName).write.1.tlog',
-         'Lines': "^%%(%s.Source);@(%s->'%%(Fullpath)')" % (rule.tlog,
-                                                            rule.tlog)
-        }
-    ]
-    read_tlog_section = [
-        'WriteLinesToFile',
-        {'Condition': "'@(%s)' != '' and '%%(%s.ExcludedFromBuild)' != "
-         "'true'" % (rule.tlog, rule.tlog),
-         'File': '$(IntDir)$(ProjectName).read.1.tlog',
-         'Lines': "^%%(%s.Source);%%(%s.Inputs)" % (rule.tlog, rule.tlog)
-        }
-    ]
-    command_and_input_section = [
-        rule_name,
-        {'Condition': "'@(%s)' != '' and '%%(%s.ExcludedFromBuild)' != "
-         "'true'" % (rule_name, rule_name),
-         'EchoOff': 'true',
-         'StandardOutputImportance': 'High',
-         'StandardErrorImportance': 'High',
-         'CommandLineTemplate': '%%(%s.CommandLineTemplate)' % rule_name,
-         'AdditionalOptions': '%%(%s.AdditionalOptions)' % rule_name,
-         'Inputs': rule_inputs
-        }
-    ]
-    content.extend([
-        ['Target',
-         {'Name': rule.target_name,
-          'BeforeTargets': '$(%s)' % rule.before_targets,
-          'AfterTargets': '$(%s)' % rule.after_targets,
-          'Condition': "'@(%s)' != ''" % rule_name,
-          'DependsOnTargets': '$(%s);%s' % (rule.depends_on,
-                                            rule.compute_output),
-          'Outputs': target_outputs,
-          'Inputs': target_inputs
-         },
-         remove_section,
-         inputs_section,
-         logging_section,
-         message_section,
-         write_tlog_section,
-         read_tlog_section,
-         command_and_input_section,
-        ],
-        ['PropertyGroup',
-         ['ComputeLinkInputsTargets',
-          '$(ComputeLinkInputsTargets);',
-          '%s;' % rule.compute_output
-         ],
-         ['ComputeLibInputsTargets',
-          '$(ComputeLibInputsTargets);',
-          '%s;' % rule.compute_output
-         ],
-        ],
-        ['Target',
-         {'Name': rule.compute_output,
-          'Condition': "'@(%s)' != ''" % rule_name
-         },
-         ['ItemGroup',
-          [rule.dirs_to_make,
-           {'Condition': "'@(%s)' != '' and "
-            "'%%(%s.ExcludedFromBuild)' != 'true'" % (rule_name, rule_name),
-            'Include': '%%(%s.Outputs)' % rule_name
-           }
-          ],
-          ['Link',
-           {'Include': '%%(%s.Identity)' % rule.dirs_to_make,
-            'Condition': extension_condition
-           }
-          ],
-          ['Lib',
-           {'Include': '%%(%s.Identity)' % rule.dirs_to_make,
-            'Condition': extension_condition
-           }
-          ],
-          ['ImpLib',
-           {'Include': '%%(%s.Identity)' % rule.dirs_to_make,
-            'Condition': extension_condition
-           }
-          ],
-         ],
-         ['MakeDir',
-          {'Directories': ("@(%s->'%%(RootDir)%%(Directory)')" %
-                           rule.dirs_to_make)
-          }
-         ]
-        ],
-    ])
-  easy_xml.WriteXmlIfChanged(content, targets_path, pretty=True, win32=True)
-
-
-def _GenerateMSBuildRuleXmlFile(xml_path, msbuild_rules):
-  # Generate the .xml file
-  content = [
-      'ProjectSchemaDefinitions',
-      {'xmlns': ('clr-namespace:Microsoft.Build.Framework.XamlTypes;'
-                 'assembly=Microsoft.Build.Framework'),
-       'xmlns:x': 'http://schemas.microsoft.com/winfx/2006/xaml',
-       'xmlns:sys': 'clr-namespace:System;assembly=mscorlib',
-       'xmlns:transformCallback':
-       'Microsoft.Cpp.Dev10.ConvertPropertyCallback'
-      }
-  ]
-  for rule in msbuild_rules:
-    content.extend([
-        ['Rule',
-         {'Name': rule.rule_name,
-          'PageTemplate': 'tool',
-          'DisplayName': rule.display_name,
-          'Order': '200'
-         },
-         ['Rule.DataSource',
-          ['DataSource',
-           {'Persistence': 'ProjectFile',
-            'ItemType': rule.rule_name
-           }
-          ]
-         ],
-         ['Rule.Categories',
-          ['Category',
-           {'Name': 'General'},
-           ['Category.DisplayName',
-            ['sys:String', 'General'],
-           ],
-          ],
-          ['Category',
-           {'Name': 'Command Line',
-            'Subtype': 'CommandLine'
-           },
-           ['Category.DisplayName',
-            ['sys:String', 'Command Line'],
-           ],
-          ],
-         ],
-         ['StringListProperty',
-          {'Name': 'Inputs',
-           'Category': 'Command Line',
-           'IsRequired': 'true',
-           'Switch': ' '
-          },
-          ['StringListProperty.DataSource',
-           ['DataSource',
-            {'Persistence': 'ProjectFile',
-             'ItemType': rule.rule_name,
-             'SourceType': 'Item'
-            }
-           ]
-          ],
-         ],
-         ['StringProperty',
-          {'Name': 'CommandLineTemplate',
-           'DisplayName': 'Command Line',
-           'Visible': 'False',
-           'IncludeInCommandLine': 'False'
-          }
-         ],
-         ['DynamicEnumProperty',
-          {'Name': rule.before_targets,
-           'Category': 'General',
-           'EnumProvider': 'Targets',
-           'IncludeInCommandLine': 'False'
-          },
-          ['DynamicEnumProperty.DisplayName',
-           ['sys:String', 'Execute Before'],
-          ],
-          ['DynamicEnumProperty.Description',
-           ['sys:String', 'Specifies the targets for the build customization'
-            ' to run before.'
-           ],
-          ],
-          ['DynamicEnumProperty.ProviderSettings',
-           ['NameValuePair',
-            {'Name': 'Exclude',
-             'Value': '^%s|^Compute' % rule.before_targets
-            }
-           ]
-          ],
-          ['DynamicEnumProperty.DataSource',
-           ['DataSource',
-            {'Persistence': 'ProjectFile',
-             'HasConfigurationCondition': 'true'
-            }
-           ]
-          ],
-         ],
-         ['DynamicEnumProperty',
-          {'Name': rule.after_targets,
-           'Category': 'General',
-           'EnumProvider': 'Targets',
-           'IncludeInCommandLine': 'False'
-          },
-          ['DynamicEnumProperty.DisplayName',
-           ['sys:String', 'Execute After'],
-          ],
-          ['DynamicEnumProperty.Description',
-           ['sys:String', ('Specifies the targets for the build customization'
-                           ' to run after.')
-           ],
-          ],
-          ['DynamicEnumProperty.ProviderSettings',
-           ['NameValuePair',
-            {'Name': 'Exclude',
-             'Value': '^%s|^Compute' % rule.after_targets
-            }
-           ]
-          ],
-          ['DynamicEnumProperty.DataSource',
-           ['DataSource',
-            {'Persistence': 'ProjectFile',
-             'ItemType': '',
-             'HasConfigurationCondition': 'true'
-            }
-           ]
-          ],
-         ],
-         ['StringListProperty',
-          {'Name': 'Outputs',
-           'DisplayName': 'Outputs',
-           'Visible': 'False',
-           'IncludeInCommandLine': 'False'
-          }
-         ],
-         ['StringProperty',
-          {'Name': 'ExecutionDescription',
-           'DisplayName': 'Execution Description',
-           'Visible': 'False',
-           'IncludeInCommandLine': 'False'
-          }
-         ],
-         ['StringListProperty',
-          {'Name': 'AdditionalDependencies',
-           'DisplayName': 'Additional Dependencies',
-           'IncludeInCommandLine': 'False',
-           'Visible': 'false'
-          }
-         ],
-         ['StringProperty',
-          {'Subtype': 'AdditionalOptions',
-           'Name': 'AdditionalOptions',
-           'Category': 'Command Line'
-          },
-          ['StringProperty.DisplayName',
-           ['sys:String', 'Additional Options'],
-          ],
-          ['StringProperty.Description',
-           ['sys:String', 'Additional Options'],
-          ],
-         ],
-        ],
-        ['ItemType',
-         {'Name': rule.rule_name,
-          'DisplayName': rule.display_name
-         }
-        ],
-        ['FileExtension',
-         {'Name': '*' + rule.extension,
-          'ContentType': rule.rule_name
-         }
-        ],
-        ['ContentType',
-         {'Name': rule.rule_name,
-          'DisplayName': '',
-          'ItemType': rule.rule_name
-         }
+    for rule in msbuild_rules:
+        item_group.append(
+            [
+                "AvailableItemName",
+                {"Include": rule.rule_name},
+                ["Targets", rule.target_name],
+            ]
+        )
+    content.append(item_group)
+
+    for rule in msbuild_rules:
+        content.append(
+            [
+                "UsingTask",
+                {
+                    "TaskName": rule.rule_name,
+                    "TaskFactory": "XamlTaskFactory",
+                    "AssemblyName": "Microsoft.Build.Tasks.v4.0",
+                },
+                ["Task", "$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml"],
+            ]
+        )
+    for rule in msbuild_rules:
+        rule_name = rule.rule_name
+        target_outputs = "%%(%s.Outputs)" % rule_name
+        target_inputs = (
+            "%%(%s.Identity);%%(%s.AdditionalDependencies);" "$(MSBuildProjectFile)"
+        ) % (rule_name, rule_name)
+        rule_inputs = "%%(%s.Identity)" % rule_name
+        extension_condition = (
+            "'%(Extension)'=='.obj' or "
+            "'%(Extension)'=='.res' or "
+            "'%(Extension)'=='.rsc' or "
+            "'%(Extension)'=='.lib'"
+        )
+        remove_section = [
+            "ItemGroup",
+            {"Condition": "'@(SelectedFiles)' != ''"},
+            [
+                rule_name,
+                {
+                    "Remove": "@(%s)" % rule_name,
+                    "Condition": "'%(Identity)' != '@(SelectedFiles)'",
+                },
+            ],
         ]
-    ])
-  easy_xml.WriteXmlIfChanged(content, xml_path, pretty=True, win32=True)
-
-
-def _GetConfigurationAndPlatform(name, settings):
-  configuration = name.rsplit('_', 1)[0]
-  platform = settings.get('msvs_configuration_platform', 'Win32')
-  return (configuration, platform)
-
-
-def _GetConfigurationCondition(name, settings):
-  return (r"'$(Configuration)|$(Platform)'=='%s|%s'" %
-          _GetConfigurationAndPlatform(name, settings))
+        inputs_section = [
+            "ItemGroup",
+            [rule.inputs, {"Include": "%%(%s.AdditionalDependencies)" % rule_name}],
+        ]
+        logging_section = [
+            "ItemGroup",
+            [
+                rule.tlog,
+                {
+                    "Include": "%%(%s.Outputs)" % rule_name,
+                    "Condition": (
+                        "'%%(%s.Outputs)' != '' and "
+                        "'%%(%s.ExcludedFromBuild)' != 'true'" % (rule_name, rule_name)
+                    ),
+                },
+                ["Source", "@(%s, '|')" % rule_name],
+                ["Inputs", "@(%s -> '%%(Fullpath)', ';')" % rule.inputs],
+            ],
+        ]
+        message_section = [
+            "Message",
+            {"Importance": "High", "Text": "%%(%s.ExecutionDescription)" % rule_name},
+        ]
+        write_tlog_section = [
+            "WriteLinesToFile",
+            {
+                "Condition": "'@(%s)' != '' and '%%(%s.ExcludedFromBuild)' != "
+                "'true'" % (rule.tlog, rule.tlog),
+                "File": "$(IntDir)$(ProjectName).write.1.tlog",
+                "Lines": "^%%(%s.Source);@(%s->'%%(Fullpath)')"
+                % (rule.tlog, rule.tlog),
+            },
+        ]
+        read_tlog_section = [
+            "WriteLinesToFile",
+            {
+                "Condition": "'@(%s)' != '' and '%%(%s.ExcludedFromBuild)' != "
+                "'true'" % (rule.tlog, rule.tlog),
+                "File": "$(IntDir)$(ProjectName).read.1.tlog",
+                "Lines": "^%%(%s.Source);%%(%s.Inputs)" % (rule.tlog, rule.tlog),
+            },
+        ]
+        command_and_input_section = [
+            rule_name,
+            {
+                "Condition": "'@(%s)' != '' and '%%(%s.ExcludedFromBuild)' != "
+                "'true'" % (rule_name, rule_name),
+                "EchoOff": "true",
+                "StandardOutputImportance": "High",
+                "StandardErrorImportance": "High",
+                "CommandLineTemplate": "%%(%s.CommandLineTemplate)" % rule_name,
+                "AdditionalOptions": "%%(%s.AdditionalOptions)" % rule_name,
+                "Inputs": rule_inputs,
+            },
+        ]
+        content.extend(
+            [
+                [
+                    "Target",
+                    {
+                        "Name": rule.target_name,
+                        "BeforeTargets": "$(%s)" % rule.before_targets,
+                        "AfterTargets": "$(%s)" % rule.after_targets,
+                        "Condition": "'@(%s)' != ''" % rule_name,
+                        "DependsOnTargets": "$(%s);%s"
+                        % (rule.depends_on, rule.compute_output),
+                        "Outputs": target_outputs,
+                        "Inputs": target_inputs,
+                    },
+                    remove_section,
+                    inputs_section,
+                    logging_section,
+                    message_section,
+                    write_tlog_section,
+                    read_tlog_section,
+                    command_and_input_section,
+                ],
+                [
+                    "PropertyGroup",
+                    [
+                        "ComputeLinkInputsTargets",
+                        "$(ComputeLinkInputsTargets);",
+                        "%s;" % rule.compute_output,
+                    ],
+                    [
+                        "ComputeLibInputsTargets",
+                        "$(ComputeLibInputsTargets);",
+                        "%s;" % rule.compute_output,
+                    ],
+                ],
+                [
+                    "Target",
+                    {
+                        "Name": rule.compute_output,
+                        "Condition": "'@(%s)' != ''" % rule_name,
+                    },
+                    [
+                        "ItemGroup",
+                        [
+                            rule.dirs_to_make,
+                            {
+                                "Condition": "'@(%s)' != '' and "
+                                "'%%(%s.ExcludedFromBuild)' != 'true'"
+                                % (rule_name, rule_name),
+                                "Include": "%%(%s.Outputs)" % rule_name,
+                            },
+                        ],
+                        [
+                            "Link",
+                            {
+                                "Include": "%%(%s.Identity)" % rule.dirs_to_make,
+                                "Condition": extension_condition,
+                            },
+                        ],
+                        [
+                            "Lib",
+                            {
+                                "Include": "%%(%s.Identity)" % rule.dirs_to_make,
+                                "Condition": extension_condition,
+                            },
+                        ],
+                        [
+                            "ImpLib",
+                            {
+                                "Include": "%%(%s.Identity)" % rule.dirs_to_make,
+                                "Condition": extension_condition,
+                            },
+                        ],
+                    ],
+                    [
+                        "MakeDir",
+                        {
+                            "Directories": (
+                                "@(%s->'%%(RootDir)%%(Directory)')" % rule.dirs_to_make
+                            )
+                        },
+                    ],
+                ],
+            ]
+        )
+    easy_xml.WriteXmlIfChanged(content, targets_path, pretty=True, win32=True)
 
 
-def _GetMSBuildProjectConfigurations(configurations):
-  group = ['ItemGroup', {'Label': 'ProjectConfigurations'}]
-  for (name, settings) in sorted(configurations.items()):
-    configuration, platform = _GetConfigurationAndPlatform(name, settings)
-    designation = '%s|%s' % (configuration, platform)
-    group.append(
-        ['ProjectConfiguration', {'Include': designation},
-         ['Configuration', configuration],
-         ['Platform', platform]])
-  return [group]
+def _GenerateMSBuildRuleXmlFile(xml_path, msbuild_rules):
+    # Generate the .xml file
+    content = [
+        "ProjectSchemaDefinitions",
+        {
+            "xmlns": (
+                "clr-namespace:Microsoft.Build.Framework.XamlTypes;"
+                "assembly=Microsoft.Build.Framework"
+            ),
+            "xmlns:x": "http://schemas.microsoft.com/winfx/2006/xaml",
+            "xmlns:sys": "clr-namespace:System;assembly=mscorlib",
+            "xmlns:transformCallback": "Microsoft.Cpp.Dev10.ConvertPropertyCallback",
+        },
+    ]
+    for rule in msbuild_rules:
+        content.extend(
+            [
+                [
+                    "Rule",
+                    {
+                        "Name": rule.rule_name,
+                        "PageTemplate": "tool",
+                        "DisplayName": rule.display_name,
+                        "Order": "200",
+                    },
+                    [
+                        "Rule.DataSource",
+                        [
+                            "DataSource",
+                            {"Persistence": "ProjectFile", "ItemType": rule.rule_name},
+                        ],
+                    ],
+                    [
+                        "Rule.Categories",
+                        [
+                            "Category",
+                            {"Name": "General"},
+                            ["Category.DisplayName", ["sys:String", "General"]],
+                        ],
+                        [
+                            "Category",
+                            {"Name": "Command Line", "Subtype": "CommandLine"},
+                            ["Category.DisplayName", ["sys:String", "Command Line"]],
+                        ],
+                    ],
+                    [
+                        "StringListProperty",
+                        {
+                            "Name": "Inputs",
+                            "Category": "Command Line",
+                            "IsRequired": "true",
+                            "Switch": " ",
+                        },
+                        [
+                            "StringListProperty.DataSource",
+                            [
+                                "DataSource",
+                                {
+                                    "Persistence": "ProjectFile",
+                                    "ItemType": rule.rule_name,
+                                    "SourceType": "Item",
+                                },
+                            ],
+                        ],
+                    ],
+                    [
+                        "StringProperty",
+                        {
+                            "Name": "CommandLineTemplate",
+                            "DisplayName": "Command Line",
+                            "Visible": "False",
+                            "IncludeInCommandLine": "False",
+                        },
+                    ],
+                    [
+                        "DynamicEnumProperty",
+                        {
+                            "Name": rule.before_targets,
+                            "Category": "General",
+                            "EnumProvider": "Targets",
+                            "IncludeInCommandLine": "False",
+                        },
+                        [
+                            "DynamicEnumProperty.DisplayName",
+                            ["sys:String", "Execute Before"],
+                        ],
+                        [
+                            "DynamicEnumProperty.Description",
+                            [
+                                "sys:String",
+                                "Specifies the targets for the build customization"
+                                " to run before.",
+                            ],
+                        ],
+                        [
+                            "DynamicEnumProperty.ProviderSettings",
+                            [
+                                "NameValuePair",
+                                {
+                                    "Name": "Exclude",
+                                    "Value": "^%s|^Compute" % rule.before_targets,
+                                },
+                            ],
+                        ],
+                        [
+                            "DynamicEnumProperty.DataSource",
+                            [
+                                "DataSource",
+                                {
+                                    "Persistence": "ProjectFile",
+                                    "HasConfigurationCondition": "true",
+                                },
+                            ],
+                        ],
+                    ],
+                    [
+                        "DynamicEnumProperty",
+                        {
+                            "Name": rule.after_targets,
+                            "Category": "General",
+                            "EnumProvider": "Targets",
+                            "IncludeInCommandLine": "False",
+                        },
+                        [
+                            "DynamicEnumProperty.DisplayName",
+                            ["sys:String", "Execute After"],
+                        ],
+                        [
+                            "DynamicEnumProperty.Description",
+                            [
+                                "sys:String",
+                                (
+                                    "Specifies the targets for the build customization"
+                                    " to run after."
+                                ),
+                            ],
+                        ],
+                        [
+                            "DynamicEnumProperty.ProviderSettings",
+                            [
+                                "NameValuePair",
+                                {
+                                    "Name": "Exclude",
+                                    "Value": "^%s|^Compute" % rule.after_targets,
+                                },
+                            ],
+                        ],
+                        [
+                            "DynamicEnumProperty.DataSource",
+                            [
+                                "DataSource",
+                                {
+                                    "Persistence": "ProjectFile",
+                                    "ItemType": "",
+                                    "HasConfigurationCondition": "true",
+                                },
+                            ],
+                        ],
+                    ],
+                    [
+                        "StringListProperty",
+                        {
+                            "Name": "Outputs",
+                            "DisplayName": "Outputs",
+                            "Visible": "False",
+                            "IncludeInCommandLine": "False",
+                        },
+                    ],
+                    [
+                        "StringProperty",
+                        {
+                            "Name": "ExecutionDescription",
+                            "DisplayName": "Execution Description",
+                            "Visible": "False",
+                            "IncludeInCommandLine": "False",
+                        },
+                    ],
+                    [
+                        "StringListProperty",
+                        {
+                            "Name": "AdditionalDependencies",
+                            "DisplayName": "Additional Dependencies",
+                            "IncludeInCommandLine": "False",
+                            "Visible": "false",
+                        },
+                    ],
+                    [
+                        "StringProperty",
+                        {
+                            "Subtype": "AdditionalOptions",
+                            "Name": "AdditionalOptions",
+                            "Category": "Command Line",
+                        },
+                        [
+                            "StringProperty.DisplayName",
+                            ["sys:String", "Additional Options"],
+                        ],
+                        [
+                            "StringProperty.Description",
+                            ["sys:String", "Additional Options"],
+                        ],
+                    ],
+                ],
+                [
+                    "ItemType",
+                    {"Name": rule.rule_name, "DisplayName": rule.display_name},
+                ],
+                [
+                    "FileExtension",
+                    {"Name": "*" + rule.extension, "ContentType": rule.rule_name},
+                ],
+                [
+                    "ContentType",
+                    {
+                        "Name": rule.rule_name,
+                        "DisplayName": "",
+                        "ItemType": rule.rule_name,
+                    },
+                ],
+            ]
+        )
+    easy_xml.WriteXmlIfChanged(content, xml_path, pretty=True, win32=True)
+
+
+def _GetConfigurationAndPlatform(name, settings, spec):
+    configuration = name.rsplit("_", 1)[0]
+    platform = settings.get("msvs_configuration_platform", "Win32")
+    if spec["toolset"] == "host" and platform == "arm64":
+        platform = "x64"  # Host-only tools are always built for x64
+    return (configuration, platform)
+
+
+def _GetConfigurationCondition(name, settings, spec):
+    return r"'$(Configuration)|$(Platform)'=='%s|%s'" % _GetConfigurationAndPlatform(
+        name, settings, spec
+    )
+
+
+def _GetMSBuildProjectConfigurations(configurations, spec):
+    group = ["ItemGroup", {"Label": "ProjectConfigurations"}]
+    for (name, settings) in sorted(configurations.items()):
+        configuration, platform = _GetConfigurationAndPlatform(name, settings, spec)
+        designation = "%s|%s" % (configuration, platform)
+        group.append(
+            [
+                "ProjectConfiguration",
+                {"Include": designation},
+                ["Configuration", configuration],
+                ["Platform", platform],
+            ]
+        )
+    return [group]
 
 
 def _GetMSBuildGlobalProperties(spec, version, guid, gyp_file_name):
-  namespace = os.path.splitext(gyp_file_name)[0]
-  properties = [
-      ['PropertyGroup', {'Label': 'Globals'},
-        ['ProjectGuid', guid],
-        ['Keyword', 'Win32Proj'],
-        ['RootNamespace', namespace],
-        ['IgnoreWarnCompileDuplicatedFilename', 'true'],
-      ]
+    namespace = os.path.splitext(gyp_file_name)[0]
+    properties = [
+        [
+            "PropertyGroup",
+            {"Label": "Globals"},
+            ["ProjectGuid", guid],
+            ["Keyword", "Win32Proj"],
+            ["RootNamespace", namespace],
+            ["IgnoreWarnCompileDuplicatedFilename", "true"],
+        ]
     ]
 
-  if os.environ.get('PROCESSOR_ARCHITECTURE') == 'AMD64' or \
-     os.environ.get('PROCESSOR_ARCHITEW6432') == 'AMD64':
-    properties[0].append(['PreferredToolArchitecture', 'x64'])
-
-  if spec.get('msvs_target_platform_version'):
-    target_platform_version = spec.get('msvs_target_platform_version')
-    properties[0].append(['WindowsTargetPlatformVersion',
-                          target_platform_version])
-    if spec.get('msvs_target_platform_minversion'):
-      target_platform_minversion = spec.get('msvs_target_platform_minversion')
-      properties[0].append(['WindowsTargetPlatformMinVersion',
-                            target_platform_minversion])
-    else:
-      properties[0].append(['WindowsTargetPlatformMinVersion',
-                            target_platform_version])
-
-  if spec.get('msvs_enable_winrt'):
-    properties[0].append(['DefaultLanguage', 'en-US'])
-    properties[0].append(['AppContainerApplication', 'true'])
-    if spec.get('msvs_application_type_revision'):
-      app_type_revision = spec.get('msvs_application_type_revision')
-      properties[0].append(['ApplicationTypeRevision', app_type_revision])
-    else:
-      properties[0].append(['ApplicationTypeRevision', '8.1'])
-    if spec.get('msvs_enable_winphone'):
-      properties[0].append(['ApplicationType', 'Windows Phone'])
-    else:
-      properties[0].append(['ApplicationType', 'Windows Store'])
-
-  platform_name = None
-  msvs_windows_sdk_version = None
-  for configuration in spec['configurations'].values():
-    platform_name = platform_name or _ConfigPlatform(configuration)
-    msvs_windows_sdk_version = (msvs_windows_sdk_version or
-                  _ConfigWindowsTargetPlatformVersion(configuration, version))
-    if platform_name and msvs_windows_sdk_version:
-      break
-  if msvs_windows_sdk_version:
-    properties[0].append(['WindowsTargetPlatformVersion',
-                          str(msvs_windows_sdk_version)])
-  elif version.compatible_sdks:
-    raise GypError('%s requires any SDK of %s version, but none were found' %
-                   (version.description, version.compatible_sdks))
-
-  if platform_name == 'ARM':
-    properties[0].append(['WindowsSDKDesktopARMSupport', 'true'])
-
-  return properties
+    if (
+        os.environ.get("PROCESSOR_ARCHITECTURE") == "AMD64"
+        or os.environ.get("PROCESSOR_ARCHITEW6432") == "AMD64"
+    ):
+        properties[0].append(["PreferredToolArchitecture", "x64"])
+
+    if spec.get("msvs_target_platform_version"):
+        target_platform_version = spec.get("msvs_target_platform_version")
+        properties[0].append(["WindowsTargetPlatformVersion", target_platform_version])
+        if spec.get("msvs_target_platform_minversion"):
+            target_platform_minversion = spec.get("msvs_target_platform_minversion")
+            properties[0].append(
+                ["WindowsTargetPlatformMinVersion", target_platform_minversion]
+            )
+        else:
+            properties[0].append(
+                ["WindowsTargetPlatformMinVersion", target_platform_version]
+            )
+
+    if spec.get("msvs_enable_winrt"):
+        properties[0].append(["DefaultLanguage", "en-US"])
+        properties[0].append(["AppContainerApplication", "true"])
+        if spec.get("msvs_application_type_revision"):
+            app_type_revision = spec.get("msvs_application_type_revision")
+            properties[0].append(["ApplicationTypeRevision", app_type_revision])
+        else:
+            properties[0].append(["ApplicationTypeRevision", "8.1"])
+        if spec.get("msvs_enable_winphone"):
+            properties[0].append(["ApplicationType", "Windows Phone"])
+        else:
+            properties[0].append(["ApplicationType", "Windows Store"])
+
+    platform_name = None
+    msvs_windows_sdk_version = None
+    for configuration in spec["configurations"].values():
+        platform_name = platform_name or _ConfigPlatform(configuration)
+        msvs_windows_sdk_version = (
+            msvs_windows_sdk_version
+            or _ConfigWindowsTargetPlatformVersion(configuration, version)
+        )
+        if platform_name and msvs_windows_sdk_version:
+            break
+    if msvs_windows_sdk_version:
+        properties[0].append(
+            ["WindowsTargetPlatformVersion", str(msvs_windows_sdk_version)]
+        )
+    elif version.compatible_sdks:
+        raise GypError(
+            "%s requires any SDK of %s version, but none were found"
+            % (version.description, version.compatible_sdks)
+        )
+
+    if platform_name == "ARM":
+        properties[0].append(["WindowsSDKDesktopARMSupport", "true"])
+
+    return properties
 
 
 def _GetMSBuildConfigurationDetails(spec, build_file):
-  properties = {}
-  for name, settings in spec['configurations'].items():
-    msbuild_attributes = _GetMSBuildAttributes(spec, settings, build_file)
-    condition = _GetConfigurationCondition(name, settings)
-    character_set = msbuild_attributes.get('CharacterSet')
-    config_type = msbuild_attributes.get('ConfigurationType')
-    _AddConditionalProperty(properties, condition, 'ConfigurationType',
-                            config_type)
-    if config_type == 'Driver':
-      _AddConditionalProperty(properties, condition, 'DriverType', 'WDM')
-      _AddConditionalProperty(properties, condition, 'TargetVersion',
-                              _ConfigTargetVersion(settings))
-    if character_set:
-      if 'msvs_enable_winrt' not in spec :
-        _AddConditionalProperty(properties, condition, 'CharacterSet',
-                                character_set)
-  return _GetMSBuildPropertyGroup(spec, 'Configuration', properties)
+    properties = {}
+    for name, settings in spec["configurations"].items():
+        msbuild_attributes = _GetMSBuildAttributes(spec, settings, build_file)
+        condition = _GetConfigurationCondition(name, settings, spec)
+        character_set = msbuild_attributes.get("CharacterSet")
+        config_type = msbuild_attributes.get("ConfigurationType")
+        _AddConditionalProperty(properties, condition, "ConfigurationType", config_type)
+        if config_type == "Driver":
+            _AddConditionalProperty(properties, condition, "DriverType", "WDM")
+            _AddConditionalProperty(
+                properties, condition, "TargetVersion", _ConfigTargetVersion(settings)
+            )
+        if character_set:
+            if "msvs_enable_winrt" not in spec:
+                _AddConditionalProperty(
+                    properties, condition, "CharacterSet", character_set
+                )
+    return _GetMSBuildPropertyGroup(spec, "Configuration", properties)
 
 
 def _GetMSBuildLocalProperties(msbuild_toolset):
-  # Currently the only local property we support is PlatformToolset
-  properties = {}
-  if msbuild_toolset:
-    properties = [
-        ['PropertyGroup', {'Label': 'Locals'},
-          ['PlatformToolset', msbuild_toolset],
-        ]
-      ]
-  return properties
-
-
-def _GetMSBuildPropertySheets(configurations):
-  user_props = r'$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props'
-  additional_props = {}
-  props_specified = False
-  for name, settings in sorted(configurations.items()):
-    configuration = _GetConfigurationCondition(name, settings)
-    if 'msbuild_props' in settings:
-      additional_props[configuration] = _FixPaths(settings['msbuild_props'])
-      props_specified = True
-    else:
-     additional_props[configuration] = ''
-
-  if not props_specified:
-    return [
-        ['ImportGroup',
-         {'Label': 'PropertySheets'},
-         ['Import',
-          {'Project': user_props,
-           'Condition': "exists('%s')" % user_props,
-           'Label': 'LocalAppDataPlatform'
-          }
-         ]
+    # Currently the only local property we support is PlatformToolset
+    properties = {}
+    if msbuild_toolset:
+        properties = [
+            [
+                "PropertyGroup",
+                {"Label": "Locals"},
+                ["PlatformToolset", msbuild_toolset],
+            ]
         ]
-    ]
-  else:
-    sheets = []
-    for condition, props in additional_props.items():
-      import_group = [
-        'ImportGroup',
-        {'Label': 'PropertySheets',
-         'Condition': condition
-        },
-        ['Import',
-         {'Project': user_props,
-          'Condition': "exists('%s')" % user_props,
-          'Label': 'LocalAppDataPlatform'
-         }
+    return properties
+
+
+def _GetMSBuildPropertySheets(configurations, spec):
+    user_props = r"$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props"
+    additional_props = {}
+    props_specified = False
+    for name, settings in sorted(configurations.items()):
+        configuration = _GetConfigurationCondition(name, settings, spec)
+        if "msbuild_props" in settings:
+            additional_props[configuration] = _FixPaths(settings["msbuild_props"])
+            props_specified = True
+        else:
+            additional_props[configuration] = ""
+
+    if not props_specified:
+        return [
+            [
+                "ImportGroup",
+                {"Label": "PropertySheets"},
+                [
+                    "Import",
+                    {
+                        "Project": user_props,
+                        "Condition": "exists('%s')" % user_props,
+                        "Label": "LocalAppDataPlatform",
+                    },
+                ],
+            ]
         ]
-      ]
-      for props_file in props:
-        import_group.append(['Import', {'Project':props_file}])
-      sheets.append(import_group)
-    return sheets
+    else:
+        sheets = []
+        for condition, props in additional_props.items():
+            import_group = [
+                "ImportGroup",
+                {"Label": "PropertySheets", "Condition": condition},
+                [
+                    "Import",
+                    {
+                        "Project": user_props,
+                        "Condition": "exists('%s')" % user_props,
+                        "Label": "LocalAppDataPlatform",
+                    },
+                ],
+            ]
+            for props_file in props:
+                import_group.append(["Import", {"Project": props_file}])
+            sheets.append(import_group)
+        return sheets
+
 
 def _ConvertMSVSBuildAttributes(spec, config, build_file):
-  config_type = _GetMSVSConfigurationType(spec, build_file)
-  msvs_attributes = _GetMSVSAttributes(spec, config, config_type)
-  msbuild_attributes = {}
-  for a in msvs_attributes:
-    if a in ['IntermediateDirectory', 'OutputDirectory']:
-      directory = MSVSSettings.ConvertVCMacrosToMSBuild(msvs_attributes[a])
-      if not directory.endswith('\\'):
-        directory += '\\'
-      msbuild_attributes[a] = directory
-    elif a == 'CharacterSet':
-      msbuild_attributes[a] = _ConvertMSVSCharacterSet(msvs_attributes[a])
-    elif a == 'ConfigurationType':
-      msbuild_attributes[a] = _ConvertMSVSConfigurationType(msvs_attributes[a])
-    else:
-      print('Warning: Do not know how to convert MSVS attribute ' + a)
-  return msbuild_attributes
+    config_type = _GetMSVSConfigurationType(spec, build_file)
+    msvs_attributes = _GetMSVSAttributes(spec, config, config_type)
+    msbuild_attributes = {}
+    for a in msvs_attributes:
+        if a in ["IntermediateDirectory", "OutputDirectory"]:
+            directory = MSVSSettings.ConvertVCMacrosToMSBuild(msvs_attributes[a])
+            if not directory.endswith("\\"):
+                directory += "\\"
+            msbuild_attributes[a] = directory
+        elif a == "CharacterSet":
+            msbuild_attributes[a] = _ConvertMSVSCharacterSet(msvs_attributes[a])
+        elif a == "ConfigurationType":
+            msbuild_attributes[a] = _ConvertMSVSConfigurationType(msvs_attributes[a])
+        else:
+            print("Warning: Do not know how to convert MSVS attribute " + a)
+    return msbuild_attributes
 
 
 def _ConvertMSVSCharacterSet(char_set):
-  if char_set.isdigit():
-    char_set = {
-        '0': 'MultiByte',
-        '1': 'Unicode',
-        '2': 'MultiByte',
-    }[char_set]
-  return char_set
+    if char_set.isdigit():
+        char_set = {"0": "MultiByte", "1": "Unicode", "2": "MultiByte"}[char_set]
+    return char_set
 
 
 def _ConvertMSVSConfigurationType(config_type):
-  if config_type.isdigit():
-    config_type = {
-        '1': 'Application',
-        '2': 'DynamicLibrary',
-        '4': 'StaticLibrary',
-        '5': 'Driver',
-        '10': 'Utility'
-    }[config_type]
-  return config_type
+    if config_type.isdigit():
+        config_type = {
+            "1": "Application",
+            "2": "DynamicLibrary",
+            "4": "StaticLibrary",
+            "5": "Driver",
+            "10": "Utility",
+        }[config_type]
+    return config_type
 
 
 def _GetMSBuildAttributes(spec, config, build_file):
-  if 'msbuild_configuration_attributes' not in config:
-    msbuild_attributes = _ConvertMSVSBuildAttributes(spec, config, build_file)
+    if "msbuild_configuration_attributes" not in config:
+        msbuild_attributes = _ConvertMSVSBuildAttributes(spec, config, build_file)
 
-  else:
-    config_type = _GetMSVSConfigurationType(spec, build_file)
-    config_type = _ConvertMSVSConfigurationType(config_type)
-    msbuild_attributes = config.get('msbuild_configuration_attributes', {})
-    msbuild_attributes.setdefault('ConfigurationType', config_type)
-    output_dir = msbuild_attributes.get('OutputDirectory',
-                                      '$(SolutionDir)$(Configuration)')
-    msbuild_attributes['OutputDirectory'] = _FixPath(output_dir) + '\\'
-    if 'IntermediateDirectory' not in msbuild_attributes:
-      intermediate = _FixPath('$(Configuration)') + '\\'
-      msbuild_attributes['IntermediateDirectory'] = intermediate
-    if 'CharacterSet' in msbuild_attributes:
-      msbuild_attributes['CharacterSet'] = _ConvertMSVSCharacterSet(
-          msbuild_attributes['CharacterSet'])
-  if 'TargetName' not in msbuild_attributes:
-    prefix = spec.get('product_prefix', '')
-    product_name = spec.get('product_name', '$(ProjectName)')
-    target_name = prefix + product_name
-    msbuild_attributes['TargetName'] = target_name
-  if 'TargetExt' not in msbuild_attributes and 'product_extension' in spec:
-    ext = spec.get('product_extension')
-    msbuild_attributes['TargetExt'] = '.' + ext
-
-  if spec.get('msvs_external_builder'):
-    external_out_dir = spec.get('msvs_external_builder_out_dir', '.')
-    msbuild_attributes['OutputDirectory'] = _FixPath(external_out_dir) + '\\'
-
-  # Make sure that 'TargetPath' matches 'Lib.OutputFile' or 'Link.OutputFile'
-  # (depending on the tool used) to avoid MSB8012 warning.
-  msbuild_tool_map = {
-      'executable': 'Link',
-      'shared_library': 'Link',
-      'loadable_module': 'Link',
-      'windows_driver': 'Link',
-      'static_library': 'Lib',
-  }
-  msbuild_tool = msbuild_tool_map.get(spec['type'])
-  if msbuild_tool:
-    msbuild_settings = config['finalized_msbuild_settings']
-    out_file = msbuild_settings[msbuild_tool].get('OutputFile')
-    if out_file:
-      msbuild_attributes['TargetPath'] = _FixPath(out_file)
-    target_ext = msbuild_settings[msbuild_tool].get('TargetExt')
-    if target_ext:
-      msbuild_attributes['TargetExt'] = target_ext
+    else:
+        config_type = _GetMSVSConfigurationType(spec, build_file)
+        config_type = _ConvertMSVSConfigurationType(config_type)
+        msbuild_attributes = config.get("msbuild_configuration_attributes", {})
+        msbuild_attributes.setdefault("ConfigurationType", config_type)
+        output_dir = msbuild_attributes.get(
+            "OutputDirectory", "$(SolutionDir)$(Configuration)"
+        )
+        msbuild_attributes["OutputDirectory"] = _FixPath(output_dir) + "\\"
+        if "IntermediateDirectory" not in msbuild_attributes:
+            intermediate = _FixPath("$(Configuration)") + "\\"
+            msbuild_attributes["IntermediateDirectory"] = intermediate
+        if "CharacterSet" in msbuild_attributes:
+            msbuild_attributes["CharacterSet"] = _ConvertMSVSCharacterSet(
+                msbuild_attributes["CharacterSet"]
+            )
+    if "TargetName" not in msbuild_attributes:
+        prefix = spec.get("product_prefix", "")
+        product_name = spec.get("product_name", "$(ProjectName)")
+        target_name = prefix + product_name
+        msbuild_attributes["TargetName"] = target_name
+    if "TargetExt" not in msbuild_attributes and "product_extension" in spec:
+        ext = spec.get("product_extension")
+        msbuild_attributes["TargetExt"] = "." + ext
+
+    if spec.get("msvs_external_builder"):
+        external_out_dir = spec.get("msvs_external_builder_out_dir", ".")
+        msbuild_attributes["OutputDirectory"] = _FixPath(external_out_dir) + "\\"
+
+    # Make sure that 'TargetPath' matches 'Lib.OutputFile' or 'Link.OutputFile'
+    # (depending on the tool used) to avoid MSB8012 warning.
+    msbuild_tool_map = {
+        "executable": "Link",
+        "shared_library": "Link",
+        "loadable_module": "Link",
+        "windows_driver": "Link",
+        "static_library": "Lib",
+    }
+    msbuild_tool = msbuild_tool_map.get(spec["type"])
+    if msbuild_tool:
+        msbuild_settings = config["finalized_msbuild_settings"]
+        out_file = msbuild_settings[msbuild_tool].get("OutputFile")
+        if out_file:
+            msbuild_attributes["TargetPath"] = _FixPath(out_file)
+        target_ext = msbuild_settings[msbuild_tool].get("TargetExt")
+        if target_ext:
+            msbuild_attributes["TargetExt"] = target_ext
 
-  return msbuild_attributes
+    return msbuild_attributes
 
 
 def _GetMSBuildConfigurationGlobalProperties(spec, configurations, build_file):
-  # TODO(jeanluc) We could optimize out the following and do it only if
-  # there are actions.
-  # TODO(jeanluc) Handle the equivalent of setting 'CYGWIN=nontsec'.
-  new_paths = []
-  cygwin_dirs = spec.get('msvs_cygwin_dirs', ['.'])[0]
-  if cygwin_dirs:
-    cyg_path = '$(MSBuildProjectDirectory)\\%s\\bin\\' % _FixPath(cygwin_dirs)
-    new_paths.append(cyg_path)
-    # TODO(jeanluc) Change the convention to have both a cygwin_dir and a
-    # python_dir.
-    python_path = cyg_path.replace('cygwin\\bin', 'python_26')
-    new_paths.append(python_path)
-    if new_paths:
-      new_paths = '$(ExecutablePath);' + ';'.join(new_paths)
-
-  properties = {}
-  for (name, configuration) in sorted(configurations.items()):
-    condition = _GetConfigurationCondition(name, configuration)
-    attributes = _GetMSBuildAttributes(spec, configuration, build_file)
-    msbuild_settings = configuration['finalized_msbuild_settings']
-    _AddConditionalProperty(properties, condition, 'IntDir',
-                            attributes['IntermediateDirectory'])
-    _AddConditionalProperty(properties, condition, 'OutDir',
-                            attributes['OutputDirectory'])
-    _AddConditionalProperty(properties, condition, 'TargetName',
-                            attributes['TargetName'])
-    if 'TargetExt' in attributes:
-      _AddConditionalProperty(properties, condition, 'TargetExt',
-                              attributes['TargetExt'])
-
-    if attributes.get('TargetPath'):
-      _AddConditionalProperty(properties, condition, 'TargetPath',
-                              attributes['TargetPath'])
-    if attributes.get('TargetExt'):
-      _AddConditionalProperty(properties, condition, 'TargetExt',
-                              attributes['TargetExt'])
-
-    if new_paths:
-      _AddConditionalProperty(properties, condition, 'ExecutablePath',
-                              new_paths)
-    tool_settings = msbuild_settings.get('', {})
-    for name, value in sorted(tool_settings.items()):
-      formatted_value = _GetValueFormattedForMSBuild('', name, value)
-      _AddConditionalProperty(properties, condition, name, formatted_value)
-  return _GetMSBuildPropertyGroup(spec, None, properties)
+    # TODO(jeanluc) We could optimize out the following and do it only if
+    # there are actions.
+    # TODO(jeanluc) Handle the equivalent of setting 'CYGWIN=nontsec'.
+    new_paths = []
+    cygwin_dirs = spec.get("msvs_cygwin_dirs", ["."])[0]
+    if cygwin_dirs:
+        cyg_path = "$(MSBuildProjectDirectory)\\%s\\bin\\" % _FixPath(cygwin_dirs)
+        new_paths.append(cyg_path)
+        # TODO(jeanluc) Change the convention to have both a cygwin_dir and a
+        # python_dir.
+        python_path = cyg_path.replace("cygwin\\bin", "python_26")
+        new_paths.append(python_path)
+        if new_paths:
+            new_paths = "$(ExecutablePath);" + ";".join(new_paths)
+
+    properties = {}
+    for (name, configuration) in sorted(configurations.items()):
+        condition = _GetConfigurationCondition(name, configuration, spec)
+        attributes = _GetMSBuildAttributes(spec, configuration, build_file)
+        msbuild_settings = configuration["finalized_msbuild_settings"]
+        _AddConditionalProperty(
+            properties, condition, "IntDir", attributes["IntermediateDirectory"]
+        )
+        _AddConditionalProperty(
+            properties, condition, "OutDir", attributes["OutputDirectory"]
+        )
+        _AddConditionalProperty(
+            properties, condition, "TargetName", attributes["TargetName"]
+        )
+        if "TargetExt" in attributes:
+            _AddConditionalProperty(
+                properties, condition, "TargetExt", attributes["TargetExt"]
+            )
+
+        if attributes.get("TargetPath"):
+            _AddConditionalProperty(
+                properties, condition, "TargetPath", attributes["TargetPath"]
+            )
+        if attributes.get("TargetExt"):
+            _AddConditionalProperty(
+                properties, condition, "TargetExt", attributes["TargetExt"]
+            )
+
+        if new_paths:
+            _AddConditionalProperty(properties, condition, "ExecutablePath", new_paths)
+        tool_settings = msbuild_settings.get("", {})
+        for name, value in sorted(tool_settings.items()):
+            formatted_value = _GetValueFormattedForMSBuild("", name, value)
+            _AddConditionalProperty(properties, condition, name, formatted_value)
+    return _GetMSBuildPropertyGroup(spec, None, properties)
 
 
 def _AddConditionalProperty(properties, condition, name, value):
-  """Adds a property / conditional value pair to a dictionary.
+    """Adds a property / conditional value pair to a dictionary.
 
   Arguments:
     properties: The dictionary to be modified.  The key is the name of the
@@ -2987,21 +3237,21 @@ def _AddConditionalProperty(properties, condition, name, value):
     name: The name of the property.
     value: The value of the property.
   """
-  if name not in properties:
-    properties[name] = {}
-  values = properties[name]
-  if value not in values:
-    values[value] = []
-  conditions = values[value]
-  conditions.append(condition)
+    if name not in properties:
+        properties[name] = {}
+    values = properties[name]
+    if value not in values:
+        values[value] = []
+    conditions = values[value]
+    conditions.append(condition)
 
 
 # Regex for msvs variable references ( i.e. $(FOO) ).
-MSVS_VARIABLE_REFERENCE = re.compile(r'\$\(([a-zA-Z_][a-zA-Z0-9_]*)\)')
+MSVS_VARIABLE_REFERENCE = re.compile(r"\$\(([a-zA-Z_][a-zA-Z0-9_]*)\)")
 
 
 def _GetMSBuildPropertyGroup(spec, label, properties):
-  """Returns a PropertyGroup definition for the specified properties.
+    """Returns a PropertyGroup definition for the specified properties.
 
   Arguments:
     spec: The target project dict.
@@ -3010,191 +3260,215 @@ def _GetMSBuildPropertyGroup(spec, label, properties):
         property.  The value is itself a dictionary; its key is the value and
         the value a list of condition for which this value is true.
   """
-  group = ['PropertyGroup']
-  if label:
-    group.append({'Label': label})
-  num_configurations = len(spec['configurations'])
-  def GetEdges(node):
-    # Use a definition of edges such that user_of_variable -> used_varible.
-    # This happens to be easier in this case, since a variable's
-    # definition contains all variables it references in a single string.
-    edges = set()
-    for value in sorted(properties[node].keys()):
-      # Add to edges all $(...) references to variables.
-      #
-      # Variable references that refer to names not in properties are excluded
-      # These can exist for instance to refer built in definitions like
-      # $(SolutionDir).
-      #
-      # Self references are ignored. Self reference is used in a few places to
-      # append to the default value. I.e. PATH=$(PATH);other_path
-      edges.update(set([v for v in MSVS_VARIABLE_REFERENCE.findall(value)
-                        if v in properties and v != node]))
-    return edges
-  properties_ordered = gyp.common.TopologicallySorted(
-      properties.keys(), GetEdges)
-  # Walk properties in the reverse of a topological sort on
-  # user_of_variable -> used_variable as this ensures variables are
-  # defined before they are used.
-  # NOTE: reverse(topsort(DAG)) = topsort(reverse_edges(DAG))
-  for name in reversed(properties_ordered):
-    values = properties[name]
-    for value, conditions in sorted(values.items()):
-      if len(conditions) == num_configurations:
-        # If the value is the same all configurations,
-        # just add one unconditional entry.
-        group.append([name, value])
-      else:
-        for condition in conditions:
-          group.append([name, {'Condition': condition}, value])
-  return [group]
+    group = ["PropertyGroup"]
+    if label:
+        group.append({"Label": label})
+    num_configurations = len(spec["configurations"])
+
+    def GetEdges(node):
+        # Use a definition of edges such that user_of_variable -> used_varible.
+        # This happens to be easier in this case, since a variable's
+        # definition contains all variables it references in a single string.
+        edges = set()
+        for value in sorted(properties[node].keys()):
+            # Add to edges all $(...) references to variables.
+            #
+            # Variable references that refer to names not in properties are excluded
+            # These can exist for instance to refer built in definitions like
+            # $(SolutionDir).
+            #
+            # Self references are ignored. Self reference is used in a few places to
+            # append to the default value. I.e. PATH=$(PATH);other_path
+            edges.update(
+                set(
+                    [
+                        v
+                        for v in MSVS_VARIABLE_REFERENCE.findall(value)
+                        if v in properties and v != node
+                    ]
+                )
+            )
+        return edges
+
+    properties_ordered = gyp.common.TopologicallySorted(properties.keys(), GetEdges)
+    # Walk properties in the reverse of a topological sort on
+    # user_of_variable -> used_variable as this ensures variables are
+    # defined before they are used.
+    # NOTE: reverse(topsort(DAG)) = topsort(reverse_edges(DAG))
+    for name in reversed(properties_ordered):
+        values = properties[name]
+        for value, conditions in sorted(values.items()):
+            if len(conditions) == num_configurations:
+                # If the value is the same all configurations,
+                # just add one unconditional entry.
+                group.append([name, value])
+            else:
+                for condition in conditions:
+                    group.append([name, {"Condition": condition}, value])
+    return [group]
 
 
 def _GetMSBuildToolSettingsSections(spec, configurations):
-  groups = []
-  for (name, configuration) in sorted(configurations.items()):
-    msbuild_settings = configuration['finalized_msbuild_settings']
-    group = ['ItemDefinitionGroup',
-             {'Condition': _GetConfigurationCondition(name, configuration)}
-            ]
-    for tool_name, tool_settings in sorted(msbuild_settings.items()):
-      # Skip the tool named '' which is a holder of global settings handled
-      # by _GetMSBuildConfigurationGlobalProperties.
-      if tool_name:
-        if tool_settings:
-          tool = [tool_name]
-          for name, value in sorted(tool_settings.items()):
-            formatted_value = _GetValueFormattedForMSBuild(tool_name, name,
-                                                           value)
-            tool.append([name, formatted_value])
-          group.append(tool)
-    groups.append(group)
-  return groups
+    groups = []
+    for (name, configuration) in sorted(configurations.items()):
+        msbuild_settings = configuration["finalized_msbuild_settings"]
+        group = [
+            "ItemDefinitionGroup",
+            {"Condition": _GetConfigurationCondition(name, configuration, spec)},
+        ]
+        for tool_name, tool_settings in sorted(msbuild_settings.items()):
+            # Skip the tool named '' which is a holder of global settings handled
+            # by _GetMSBuildConfigurationGlobalProperties.
+            if tool_name:
+                if tool_settings:
+                    tool = [tool_name]
+                    for name, value in sorted(tool_settings.items()):
+                        formatted_value = _GetValueFormattedForMSBuild(
+                            tool_name, name, value
+                        )
+                        tool.append([name, formatted_value])
+                    group.append(tool)
+        groups.append(group)
+    return groups
 
 
 def _FinalizeMSBuildSettings(spec, configuration):
-  if 'msbuild_settings' in configuration:
-    converted = False
-    msbuild_settings = configuration['msbuild_settings']
-    MSVSSettings.ValidateMSBuildSettings(msbuild_settings)
-  else:
-    converted = True
-    msvs_settings = configuration.get('msvs_settings', {})
-    msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(msvs_settings)
-  include_dirs, midl_include_dirs, resource_include_dirs = \
-      _GetIncludeDirs(configuration)
-  libraries = _GetLibraries(spec)
-  library_dirs = _GetLibraryDirs(configuration)
-  out_file, _, msbuild_tool = _GetOutputFilePathAndTool(spec, msbuild=True)
-  target_ext = _GetOutputTargetExt(spec)
-  defines = _GetDefines(configuration)
-  if converted:
-    # Visual Studio 2010 has TR1
-    defines = [d for d in defines if d != '_HAS_TR1=0']
-    # Warn of ignored settings
-    ignored_settings = ['msvs_tool_files']
-    for ignored_setting in ignored_settings:
-      value = configuration.get(ignored_setting)
-      if value:
-        print('Warning: The automatic conversion to MSBuild does not handle '
-              '%s.  Ignoring setting of %s' % (ignored_setting, str(value)))
-
-  defines = [_EscapeCppDefineForMSBuild(d) for d in defines]
-  disabled_warnings = _GetDisabledWarnings(configuration)
-  prebuild = configuration.get('msvs_prebuild')
-  postbuild = configuration.get('msvs_postbuild')
-  def_file = _GetModuleDefinition(spec)
-  precompiled_header = configuration.get('msvs_precompiled_header')
-
-  # Add the information to the appropriate tool
-  # TODO(jeanluc) We could optimize and generate these settings only if
-  # the corresponding files are found, e.g. don't generate ResourceCompile
-  # if you don't have any resources.
-  _ToolAppend(msbuild_settings, 'ClCompile',
-              'AdditionalIncludeDirectories', include_dirs)
-  _ToolAppend(msbuild_settings, 'Midl',
-              'AdditionalIncludeDirectories', midl_include_dirs)
-  _ToolAppend(msbuild_settings, 'ResourceCompile',
-              'AdditionalIncludeDirectories', resource_include_dirs)
-  # Add in libraries, note that even for empty libraries, we want this
-  # set, to prevent inheriting default libraries from the environment.
-  _ToolSetOrAppend(msbuild_settings, 'Link', 'AdditionalDependencies',
-                  libraries)
-  _ToolAppend(msbuild_settings, 'Link', 'AdditionalLibraryDirectories',
-              library_dirs)
-  if out_file:
-    _ToolAppend(msbuild_settings, msbuild_tool, 'OutputFile', out_file,
-                only_if_unset=True)
-  if target_ext:
-    _ToolAppend(msbuild_settings, msbuild_tool, 'TargetExt', target_ext,
-                only_if_unset=True)
-  # Add defines.
-  _ToolAppend(msbuild_settings, 'ClCompile',
-              'PreprocessorDefinitions', defines)
-  _ToolAppend(msbuild_settings, 'ResourceCompile',
-              'PreprocessorDefinitions', defines)
-  # Add disabled warnings.
-  _ToolAppend(msbuild_settings, 'ClCompile',
-              'DisableSpecificWarnings', disabled_warnings)
-  # Turn on precompiled headers if appropriate.
-  if precompiled_header:
-    precompiled_header = os.path.split(precompiled_header)[1]
-    _ToolAppend(msbuild_settings, 'ClCompile', 'PrecompiledHeader', 'Use')
-    _ToolAppend(msbuild_settings, 'ClCompile',
-                'PrecompiledHeaderFile', precompiled_header)
-    _ToolAppend(msbuild_settings, 'ClCompile',
-                'ForcedIncludeFiles', [precompiled_header])
-  else:
-    _ToolAppend(msbuild_settings, 'ClCompile', 'PrecompiledHeader', 'NotUsing')
-  # Turn off WinRT compilation
-  _ToolAppend(msbuild_settings, 'ClCompile', 'CompileAsWinRT', 'false')
-  # Turn on import libraries if appropriate
-  if spec.get('msvs_requires_importlibrary'):
-   _ToolAppend(msbuild_settings, '', 'IgnoreImportLibrary', 'false')
-  # Loadable modules don't generate import libraries;
-  # tell dependent projects to not expect one.
-  if spec['type'] == 'loadable_module':
-    _ToolAppend(msbuild_settings, '', 'IgnoreImportLibrary', 'true')
-  # Set the module definition file if any.
-  if def_file:
-    _ToolAppend(msbuild_settings, 'Link', 'ModuleDefinitionFile', def_file)
-  configuration['finalized_msbuild_settings'] = msbuild_settings
-  if prebuild:
-    _ToolAppend(msbuild_settings, 'PreBuildEvent', 'Command', prebuild)
-  if postbuild:
-    _ToolAppend(msbuild_settings, 'PostBuildEvent', 'Command', postbuild)
+    if "msbuild_settings" in configuration:
+        converted = False
+        msbuild_settings = configuration["msbuild_settings"]
+        MSVSSettings.ValidateMSBuildSettings(msbuild_settings)
+    else:
+        converted = True
+        msvs_settings = configuration.get("msvs_settings", {})
+        msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(msvs_settings)
+    include_dirs, midl_include_dirs, resource_include_dirs = _GetIncludeDirs(
+        configuration
+    )
+    libraries = _GetLibraries(spec)
+    library_dirs = _GetLibraryDirs(configuration)
+    out_file, _, msbuild_tool = _GetOutputFilePathAndTool(spec, msbuild=True)
+    target_ext = _GetOutputTargetExt(spec)
+    defines = _GetDefines(configuration)
+    if converted:
+        # Visual Studio 2010 has TR1
+        defines = [d for d in defines if d != "_HAS_TR1=0"]
+        # Warn of ignored settings
+        ignored_settings = ["msvs_tool_files"]
+        for ignored_setting in ignored_settings:
+            value = configuration.get(ignored_setting)
+            if value:
+                print(
+                    "Warning: The automatic conversion to MSBuild does not handle "
+                    "%s.  Ignoring setting of %s" % (ignored_setting, str(value))
+                )
+
+    defines = [_EscapeCppDefineForMSBuild(d) for d in defines]
+    disabled_warnings = _GetDisabledWarnings(configuration)
+    prebuild = configuration.get("msvs_prebuild")
+    postbuild = configuration.get("msvs_postbuild")
+    def_file = _GetModuleDefinition(spec)
+    precompiled_header = configuration.get("msvs_precompiled_header")
+
+    # Add the information to the appropriate tool
+    # TODO(jeanluc) We could optimize and generate these settings only if
+    # the corresponding files are found, e.g. don't generate ResourceCompile
+    # if you don't have any resources.
+    _ToolAppend(
+        msbuild_settings, "ClCompile", "AdditionalIncludeDirectories", include_dirs
+    )
+    _ToolAppend(
+        msbuild_settings, "Midl", "AdditionalIncludeDirectories", midl_include_dirs
+    )
+    _ToolAppend(
+        msbuild_settings,
+        "ResourceCompile",
+        "AdditionalIncludeDirectories",
+        resource_include_dirs,
+    )
+    # Add in libraries, note that even for empty libraries, we want this
+    # set, to prevent inheriting default libraries from the environment.
+    _ToolSetOrAppend(msbuild_settings, "Link", "AdditionalDependencies", libraries)
+    _ToolAppend(msbuild_settings, "Link", "AdditionalLibraryDirectories", library_dirs)
+    if out_file:
+        _ToolAppend(
+            msbuild_settings, msbuild_tool, "OutputFile", out_file, only_if_unset=True
+        )
+    if target_ext:
+        _ToolAppend(
+            msbuild_settings, msbuild_tool, "TargetExt", target_ext, only_if_unset=True
+        )
+    # Add defines.
+    _ToolAppend(msbuild_settings, "ClCompile", "PreprocessorDefinitions", defines)
+    _ToolAppend(msbuild_settings, "ResourceCompile", "PreprocessorDefinitions", defines)
+    # Add disabled warnings.
+    _ToolAppend(
+        msbuild_settings, "ClCompile", "DisableSpecificWarnings", disabled_warnings
+    )
+    # Turn on precompiled headers if appropriate.
+    if precompiled_header:
+        precompiled_header = os.path.split(precompiled_header)[1]
+        _ToolAppend(msbuild_settings, "ClCompile", "PrecompiledHeader", "Use")
+        _ToolAppend(
+            msbuild_settings, "ClCompile", "PrecompiledHeaderFile", precompiled_header
+        )
+        _ToolAppend(
+            msbuild_settings, "ClCompile", "ForcedIncludeFiles", [precompiled_header]
+        )
+    else:
+        _ToolAppend(msbuild_settings, "ClCompile", "PrecompiledHeader", "NotUsing")
+    # Turn off WinRT compilation
+    _ToolAppend(msbuild_settings, "ClCompile", "CompileAsWinRT", "false")
+    # Turn on import libraries if appropriate
+    if spec.get("msvs_requires_importlibrary"):
+        _ToolAppend(msbuild_settings, "", "IgnoreImportLibrary", "false")
+    # Loadable modules don't generate import libraries;
+    # tell dependent projects to not expect one.
+    if spec["type"] == "loadable_module":
+        _ToolAppend(msbuild_settings, "", "IgnoreImportLibrary", "true")
+    # Set the module definition file if any.
+    if def_file:
+        _ToolAppend(msbuild_settings, "Link", "ModuleDefinitionFile", def_file)
+    configuration["finalized_msbuild_settings"] = msbuild_settings
+    if prebuild:
+        _ToolAppend(msbuild_settings, "PreBuildEvent", "Command", prebuild)
+    if postbuild:
+        _ToolAppend(msbuild_settings, "PostBuildEvent", "Command", postbuild)
 
 
 def _GetValueFormattedForMSBuild(tool_name, name, value):
-  if type(value) == list:
-    # For some settings, VS2010 does not automatically extends the settings
-    # TODO(jeanluc) Is this what we want?
-    if name in ['AdditionalIncludeDirectories',
-                'AdditionalLibraryDirectories',
-                'AdditionalOptions',
-                'DelayLoadDLLs',
-                'DisableSpecificWarnings',
-                'PreprocessorDefinitions']:
-      value.append('%%(%s)' % name)
-    # For most tools, entries in a list should be separated with ';' but some
-    # settings use a space.  Check for those first.
-    exceptions = {
-        'ClCompile': ['AdditionalOptions'],
-        'Link': ['AdditionalOptions'],
-        'Lib': ['AdditionalOptions']}
-    if tool_name in exceptions and name in exceptions[tool_name]:
-      char = ' '
+    if type(value) == list:
+        # For some settings, VS2010 does not automatically extends the settings
+        # TODO(jeanluc) Is this what we want?
+        if name in [
+            "AdditionalIncludeDirectories",
+            "AdditionalLibraryDirectories",
+            "AdditionalOptions",
+            "DelayLoadDLLs",
+            "DisableSpecificWarnings",
+            "PreprocessorDefinitions",
+        ]:
+            value.append("%%(%s)" % name)
+        # For most tools, entries in a list should be separated with ';' but some
+        # settings use a space.  Check for those first.
+        exceptions = {
+            "ClCompile": ["AdditionalOptions"],
+            "Link": ["AdditionalOptions"],
+            "Lib": ["AdditionalOptions"],
+        }
+        if tool_name in exceptions and name in exceptions[tool_name]:
+            char = " "
+        else:
+            char = ";"
+        formatted_value = char.join(
+            [MSVSSettings.ConvertVCMacrosToMSBuild(i) for i in value]
+        )
     else:
-      char = ';'
-    formatted_value = char.join(
-        [MSVSSettings.ConvertVCMacrosToMSBuild(i) for i in value])
-  else:
-    formatted_value = MSVSSettings.ConvertVCMacrosToMSBuild(value)
-  return formatted_value
+        formatted_value = MSVSSettings.ConvertVCMacrosToMSBuild(value)
+    return formatted_value
 
 
 def _VerifySourcesExist(sources, root_dir):
-  """Verifies that all source files exist on disk.
+    """Verifies that all source files exist on disk.
 
   Checks that all regular source files, i.e. not created at run time,
   exist on disk.  Missing files cause needless recompilation but no otherwise
@@ -3206,253 +3480,349 @@ def _VerifySourcesExist(sources, root_dir):
   Returns:
     A list of source files that cannot be found on disk.
   """
-  missing_sources = []
-  for source in sources:
-    if isinstance(source, MSVSProject.Filter):
-      missing_sources.extend(_VerifySourcesExist(source.contents, root_dir))
-    else:
-      if '$' not in source:
-        full_path = os.path.join(root_dir, source)
-        if not os.path.exists(full_path):
-          missing_sources.append(full_path)
-  return missing_sources
-
-
-def _GetMSBuildSources(spec, sources, exclusions, rule_dependencies,
-                       extension_to_rule_name, actions_spec,
-                       sources_handled_by_action, list_excluded):
-  groups = ['none', 'masm', 'midl', 'include', 'compile', 'resource', 'rule',
-            'rule_dependency']
-  grouped_sources = {}
-  for g in groups:
-    grouped_sources[g] = []
-
-  _AddSources2(spec, sources, exclusions, grouped_sources,
-               rule_dependencies, extension_to_rule_name,
-               sources_handled_by_action, list_excluded)
-  sources = []
-  for g in groups:
-    if grouped_sources[g]:
-      sources.append(['ItemGroup'] + grouped_sources[g])
-  if actions_spec:
-    sources.append(['ItemGroup'] + actions_spec)
-  return sources
-
-
-def _AddSources2(spec, sources, exclusions, grouped_sources,
-                 rule_dependencies, extension_to_rule_name,
-                 sources_handled_by_action,
-                 list_excluded):
-  extensions_excluded_from_precompile = []
-  for source in sources:
-    if isinstance(source, MSVSProject.Filter):
-      _AddSources2(spec, source.contents, exclusions, grouped_sources,
-                   rule_dependencies, extension_to_rule_name,
-                   sources_handled_by_action,
-                   list_excluded)
-    else:
-      if not source in sources_handled_by_action:
-        detail = []
-        excluded_configurations = exclusions.get(source, [])
-        if len(excluded_configurations) == len(spec['configurations']):
-          detail.append(['ExcludedFromBuild', 'true'])
+    missing_sources = []
+    for source in sources:
+        if isinstance(source, MSVSProject.Filter):
+            missing_sources.extend(_VerifySourcesExist(source.contents, root_dir))
         else:
-          for config_name, configuration in sorted(excluded_configurations):
-            condition = _GetConfigurationCondition(config_name, configuration)
-            detail.append(['ExcludedFromBuild',
-                           {'Condition': condition},
-                           'true'])
-        # Add precompile if needed
-        for config_name, configuration in spec['configurations'].items():
-          precompiled_source = configuration.get('msvs_precompiled_source', '')
-          if precompiled_source != '':
-            precompiled_source = _FixPath(precompiled_source)
-            if not extensions_excluded_from_precompile:
-              # If the precompiled header is generated by a C source, we must
-              # not try to use it for C++ sources, and vice versa.
-              basename, extension = os.path.splitext(precompiled_source)
-              if extension == '.c':
-                extensions_excluded_from_precompile = ['.cc', '.cpp', '.cxx']
-              else:
-                extensions_excluded_from_precompile = ['.c']
-
-          if precompiled_source == source:
-            condition = _GetConfigurationCondition(config_name, configuration)
-            detail.append(['PrecompiledHeader',
-                           {'Condition': condition},
-                           'Create'
-                          ])
-          else:
-            # Turn off precompiled header usage for source files of a
-            # different type than the file that generated the
-            # precompiled header.
-            for extension in extensions_excluded_from_precompile:
-              if source.endswith(extension):
-                detail.append(['PrecompiledHeader', ''])
-                detail.append(['ForcedIncludeFiles', ''])
-
-        group, element = _MapFileToMsBuildSourceType(source, rule_dependencies,
-                                                     extension_to_rule_name,
-                                                     _GetUniquePlatforms(spec))
-        grouped_sources[group].append([element, {'Include': source}] + detail)
+            if "$" not in source:
+                full_path = os.path.join(root_dir, source)
+                if not os.path.exists(full_path):
+                    missing_sources.append(full_path)
+    return missing_sources
+
+
+def _GetMSBuildSources(
+    spec,
+    sources,
+    exclusions,
+    rule_dependencies,
+    extension_to_rule_name,
+    actions_spec,
+    sources_handled_by_action,
+    list_excluded,
+):
+    groups = [
+        "none",
+        "masm",
+        "midl",
+        "include",
+        "compile",
+        "resource",
+        "rule",
+        "rule_dependency",
+    ]
+    grouped_sources = {}
+    for g in groups:
+        grouped_sources[g] = []
+
+    _AddSources2(
+        spec,
+        sources,
+        exclusions,
+        grouped_sources,
+        rule_dependencies,
+        extension_to_rule_name,
+        sources_handled_by_action,
+        list_excluded,
+    )
+    sources = []
+    for g in groups:
+        if grouped_sources[g]:
+            sources.append(["ItemGroup"] + grouped_sources[g])
+    if actions_spec:
+        sources.append(["ItemGroup"] + actions_spec)
+    return sources
+
+
+def _AddSources2(
+    spec,
+    sources,
+    exclusions,
+    grouped_sources,
+    rule_dependencies,
+    extension_to_rule_name,
+    sources_handled_by_action,
+    list_excluded,
+):
+    extensions_excluded_from_precompile = []
+    for source in sources:
+        if isinstance(source, MSVSProject.Filter):
+            _AddSources2(
+                spec,
+                source.contents,
+                exclusions,
+                grouped_sources,
+                rule_dependencies,
+                extension_to_rule_name,
+                sources_handled_by_action,
+                list_excluded,
+            )
+        else:
+            if source not in sources_handled_by_action:
+                detail = []
+                excluded_configurations = exclusions.get(source, [])
+                if len(excluded_configurations) == len(spec["configurations"]):
+                    detail.append(["ExcludedFromBuild", "true"])
+                else:
+                    for config_name, configuration in sorted(excluded_configurations):
+                        condition = _GetConfigurationCondition(
+                            config_name, configuration
+                        )
+                        detail.append(
+                            ["ExcludedFromBuild", {"Condition": condition}, "true"]
+                        )
+                # Add precompile if needed
+                for config_name, configuration in spec["configurations"].items():
+                    precompiled_source = configuration.get(
+                        "msvs_precompiled_source", ""
+                    )
+                    if precompiled_source != "":
+                        precompiled_source = _FixPath(precompiled_source)
+                        if not extensions_excluded_from_precompile:
+                            # If the precompiled header is generated by a C source,
+                            # we must not try to use it for C++ sources,
+                            # and vice versa.
+                            basename, extension = os.path.splitext(precompiled_source)
+                            if extension == ".c":
+                                extensions_excluded_from_precompile = [
+                                    ".cc",
+                                    ".cpp",
+                                    ".cxx",
+                                ]
+                            else:
+                                extensions_excluded_from_precompile = [".c"]
+
+                    if precompiled_source == source:
+                        condition = _GetConfigurationCondition(
+                            config_name, configuration, spec
+                        )
+                        detail.append(
+                            ["PrecompiledHeader", {"Condition": condition}, "Create"]
+                        )
+                    else:
+                        # Turn off precompiled header usage for source files of a
+                        # different type than the file that generated the
+                        # precompiled header.
+                        for extension in extensions_excluded_from_precompile:
+                            if source.endswith(extension):
+                                detail.append(["PrecompiledHeader", ""])
+                                detail.append(["ForcedIncludeFiles", ""])
+
+                group, element = _MapFileToMsBuildSourceType(
+                    source,
+                    rule_dependencies,
+                    extension_to_rule_name,
+                    _GetUniquePlatforms(spec),
+                    spec["toolset"],
+                )
+                if group == "compile" and not os.path.isabs(source):
+                    # Add an <ObjectFileName> value to support duplicate source
+                    # file basenames, except for absolute paths to avoid paths
+                    # with more than 260 characters.
+                    file_name = os.path.splitext(source)[0] + ".obj"
+                    if file_name.startswith("..\\"):
+                        file_name = re.sub(r"^(\.\.\\)+", "", file_name)
+                    elif file_name.startswith("$("):
+                        file_name = re.sub(r"^\$\([^)]+\)\\", "", file_name)
+                    detail.append(["ObjectFileName", "$(IntDir)\\" + file_name])
+                grouped_sources[group].append([element, {"Include": source}] + detail)
 
 
 def _GetMSBuildProjectReferences(project):
-  references = []
-  if project.dependencies:
-    group = ['ItemGroup']
-    for dependency in project.dependencies:
-      guid = dependency.guid
-      project_dir = os.path.split(project.path)[0]
-      relative_path = gyp.common.RelativePath(dependency.path, project_dir)
-      project_ref = ['ProjectReference',
-          {'Include': relative_path},
-          ['Project', guid],
-          ['ReferenceOutputAssembly', 'false']
-          ]
-      for config in dependency.spec.get('configurations', {}).values():
-        if config.get('msvs_use_library_dependency_inputs', 0):
-          project_ref.append(['UseLibraryDependencyInputs', 'true'])
-          break
-        # If it's disabled in any config, turn it off in the reference.
-        if config.get('msvs_2010_disable_uldi_when_referenced', 0):
-          project_ref.append(['UseLibraryDependencyInputs', 'false'])
-          break
-      group.append(project_ref)
-    references.append(group)
-  return references
-
-
-def _GenerateMSBuildProject(project, options, version, generator_flags):
-  spec = project.spec
-  configurations = spec['configurations']
-  project_dir, project_file_name = os.path.split(project.path)
-  gyp.common.EnsureDirExists(project.path)
-  # Prepare list of sources and excluded sources.
-  gyp_path = _NormalizedSource(project.build_file)
-  relative_path_of_gyp_file = gyp.common.RelativePath(gyp_path, project_dir)
-
-  gyp_file = os.path.split(project.build_file)[1]
-  sources, excluded_sources = _PrepareListOfSources(spec, generator_flags,
-                                                    gyp_file)
-  # Add rules.
-  actions_to_add = {}
-  props_files_of_rules = set()
-  targets_files_of_rules = set()
-  rule_dependencies = set()
-  extension_to_rule_name = {}
-  list_excluded = generator_flags.get('msvs_list_excluded_files', True)
-
-  # Don't generate rules if we are using an external builder like ninja.
-  if not spec.get('msvs_external_builder'):
-    _GenerateRulesForMSBuild(project_dir, options, spec,
-                             sources, excluded_sources,
-                             props_files_of_rules, targets_files_of_rules,
-                             actions_to_add, rule_dependencies,
-                             extension_to_rule_name)
-  else:
-    rules = spec.get('rules', [])
-    _AdjustSourcesForRules(rules, sources, excluded_sources, True)
-
-  sources, excluded_sources, excluded_idl = (
-      _AdjustSourcesAndConvertToFilterHierarchy(spec, options,
-                                                project_dir, sources,
-                                                excluded_sources,
-                                                list_excluded, version))
-
-  # Don't add actions if we are using an external builder like ninja.
-  if not spec.get('msvs_external_builder'):
-    _AddActions(actions_to_add, spec, project.build_file)
-    _AddCopies(actions_to_add, spec)
+    references = []
+    if project.dependencies:
+        group = ["ItemGroup"]
+        added_dependency_set = set()
+        for dependency in project.dependencies:
+            dependency_spec = dependency.spec
+            should_skip_dep = False
+            if project.spec["toolset"] == "target":
+                if dependency_spec["toolset"] == "host":
+                    if dependency_spec["type"] == "static_library":
+                        should_skip_dep = True
+            if dependency.name.startswith("run_"):
+                should_skip_dep = False
+            if should_skip_dep:
+                continue
+
+            canonical_name = dependency.name.replace("_host", "")
+            added_dependency_set.add(canonical_name)
+            guid = dependency.guid
+            project_dir = os.path.split(project.path)[0]
+            relative_path = gyp.common.RelativePath(dependency.path, project_dir)
+            project_ref = [
+                "ProjectReference",
+                {"Include": relative_path},
+                ["Project", guid],
+                ["ReferenceOutputAssembly", "false"],
+            ]
+            for config in dependency.spec.get("configurations", {}).values():
+                if config.get("msvs_use_library_dependency_inputs", 0):
+                    project_ref.append(["UseLibraryDependencyInputs", "true"])
+                    break
+                # If it's disabled in any config, turn it off in the reference.
+                if config.get("msvs_2010_disable_uldi_when_referenced", 0):
+                    project_ref.append(["UseLibraryDependencyInputs", "false"])
+                    break
+            group.append(project_ref)
+        references.append(group)
+    return references
+
+
+def _GenerateMSBuildProject(project, options, version, generator_flags, spec):
+    spec = project.spec
+    configurations = spec["configurations"]
+    toolset = spec["toolset"]
+    project_dir, project_file_name = os.path.split(project.path)
+    gyp.common.EnsureDirExists(project.path)
+    # Prepare list of sources and excluded sources.
+
+    gyp_file = os.path.split(project.build_file)[1]
+    sources, excluded_sources = _PrepareListOfSources(spec, generator_flags, gyp_file)
+    # Add rules.
+    actions_to_add = {}
+    props_files_of_rules = set()
+    targets_files_of_rules = set()
+    rule_dependencies = set()
+    extension_to_rule_name = {}
+    list_excluded = generator_flags.get("msvs_list_excluded_files", True)
+    platforms = _GetUniquePlatforms(spec)
+
+    # Don't generate rules if we are using an external builder like ninja.
+    if not spec.get("msvs_external_builder"):
+        _GenerateRulesForMSBuild(
+            project_dir,
+            options,
+            spec,
+            sources,
+            excluded_sources,
+            props_files_of_rules,
+            targets_files_of_rules,
+            actions_to_add,
+            rule_dependencies,
+            extension_to_rule_name,
+        )
+    else:
+        rules = spec.get("rules", [])
+        _AdjustSourcesForRules(rules, sources, excluded_sources, True)
+
+    sources, excluded_sources, excluded_idl = _AdjustSourcesAndConvertToFilterHierarchy(
+        spec, options, project_dir, sources, excluded_sources, list_excluded, version
+    )
+
+    # Don't add actions if we are using an external builder like ninja.
+    if not spec.get("msvs_external_builder"):
+        _AddActions(actions_to_add, spec, project.build_file)
+        _AddCopies(actions_to_add, spec)
+
+        # NOTE: this stanza must appear after all actions have been decided.
+        # Don't excluded sources with actions attached, or they won't run.
+        excluded_sources = _FilterActionsFromExcluded(excluded_sources, actions_to_add)
+
+    exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
+    actions_spec, sources_handled_by_action = _GenerateActionsForMSBuild(
+        spec, actions_to_add
+    )
+
+    _GenerateMSBuildFiltersFile(
+        project.path + ".filters",
+        sources,
+        rule_dependencies,
+        extension_to_rule_name,
+        platforms,
+        toolset,
+    )
+    missing_sources = _VerifySourcesExist(sources, project_dir)
+
+    for configuration in configurations.values():
+        _FinalizeMSBuildSettings(spec, configuration)
+
+    # Add attributes to root element
+
+    import_default_section = [
+        ["Import", {"Project": r"$(VCTargetsPath)\Microsoft.Cpp.Default.props"}]
+    ]
+    import_cpp_props_section = [
+        ["Import", {"Project": r"$(VCTargetsPath)\Microsoft.Cpp.props"}]
+    ]
+    import_cpp_targets_section = [
+        ["Import", {"Project": r"$(VCTargetsPath)\Microsoft.Cpp.targets"}]
+    ]
+    import_masm_props_section = [
+        ["Import", {"Project": r"$(VCTargetsPath)\BuildCustomizations\masm.props"}]
+    ]
+    import_masm_targets_section = [
+        ["Import", {"Project": r"$(VCTargetsPath)\BuildCustomizations\masm.targets"}]
+    ]
+    import_marmasm_props_section = [
+        ["Import", {"Project": r"$(VCTargetsPath)\BuildCustomizations\marmasm.props"}]
+    ]
+    import_marmasm_targets_section = [
+        ["Import", {"Project": r"$(VCTargetsPath)\BuildCustomizations\marmasm.targets"}]
+    ]
+    macro_section = [["PropertyGroup", {"Label": "UserMacros"}]]
+
+    content = [
+        "Project",
+        {
+            "xmlns": "http://schemas.microsoft.com/developer/msbuild/2003",
+            "ToolsVersion": version.ProjectVersion(),
+            "DefaultTargets": "Build",
+        },
+    ]
 
-    # NOTE: this stanza must appear after all actions have been decided.
-    # Don't excluded sources with actions attached, or they won't run.
-    excluded_sources = _FilterActionsFromExcluded(
-        excluded_sources, actions_to_add)
-
-  exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
-  actions_spec, sources_handled_by_action = _GenerateActionsForMSBuild(
-      spec, actions_to_add)
-
-  _GenerateMSBuildFiltersFile(project.path + '.filters', sources,
-                              rule_dependencies,
-                              extension_to_rule_name, _GetUniquePlatforms(spec))
-  missing_sources = _VerifySourcesExist(sources, project_dir)
-
-  for configuration in configurations.values():
-    _FinalizeMSBuildSettings(spec, configuration)
-
-  # Add attributes to root element
-
-  import_default_section = [
-      ['Import', {'Project': r'$(VCTargetsPath)\Microsoft.Cpp.Default.props'}]]
-  import_cpp_props_section = [
-      ['Import', {'Project': r'$(VCTargetsPath)\Microsoft.Cpp.props'}]]
-  import_cpp_targets_section = [
-      ['Import', {'Project': r'$(VCTargetsPath)\Microsoft.Cpp.targets'}]]
-  import_masm_props_section = [
-      ['Import',
-        {'Project': r'$(VCTargetsPath)\BuildCustomizations\masm.props'}]]
-  import_masm_targets_section = [
-      ['Import',
-        {'Project': r'$(VCTargetsPath)\BuildCustomizations\masm.targets'}]]
-  import_marmasm_props_section = [
-      ['Import',
-        {'Project': r'$(VCTargetsPath)\BuildCustomizations\marmasm.props'}]]
-  import_marmasm_targets_section = [
-      ['Import',
-        {'Project': r'$(VCTargetsPath)\BuildCustomizations\marmasm.targets'}]]
-  macro_section = [['PropertyGroup', {'Label': 'UserMacros'}]]
-
-  content = [
-      'Project',
-      {'xmlns': 'http://schemas.microsoft.com/developer/msbuild/2003',
-       'ToolsVersion': version.ProjectVersion(),
-       'DefaultTargets': 'Build'
-      }]
-
-  content += _GetMSBuildProjectConfigurations(configurations)
-  content += _GetMSBuildGlobalProperties(spec, version, project.guid,
-                                         project_file_name)
-  content += import_default_section
-  content += _GetMSBuildConfigurationDetails(spec, project.build_file)
-  if spec.get('msvs_enable_winphone'):
-   content += _GetMSBuildLocalProperties('v120_wp81')
-  else:
-   content += _GetMSBuildLocalProperties(project.msbuild_toolset)
-  content += import_cpp_props_section
-  content += import_masm_props_section
-  if spec.get('msvs_enable_marmasm'):
-    content += import_marmasm_props_section
-  content += _GetMSBuildExtensions(props_files_of_rules)
-  content += _GetMSBuildPropertySheets(configurations)
-  content += macro_section
-  content += _GetMSBuildConfigurationGlobalProperties(spec, configurations,
-                                                      project.build_file)
-  content += _GetMSBuildToolSettingsSections(spec, configurations)
-  content += _GetMSBuildSources(
-      spec, sources, exclusions, rule_dependencies, extension_to_rule_name,
-      actions_spec, sources_handled_by_action, list_excluded)
-  content += _GetMSBuildProjectReferences(project)
-  content += import_cpp_targets_section
-  content += import_masm_targets_section
-  if spec.get('msvs_enable_marmasm'):
-    content += import_marmasm_targets_section
-  content += _GetMSBuildExtensionTargets(targets_files_of_rules)
-
-  if spec.get('msvs_external_builder'):
-    content += _GetMSBuildExternalBuilderTargets(spec)
-
-  # TODO(jeanluc) File a bug to get rid of runas.  We had in MSVS:
-  # has_run_as = _WriteMSVSUserFile(project.path, version, spec)
-
-  easy_xml.WriteXmlIfChanged(content, project.path, pretty=True, win32=True)
-
-  return missing_sources
+    content += _GetMSBuildProjectConfigurations(configurations, spec)
+    content += _GetMSBuildGlobalProperties(
+        spec, version, project.guid, project_file_name
+    )
+    content += import_default_section
+    content += _GetMSBuildConfigurationDetails(spec, project.build_file)
+    if spec.get("msvs_enable_winphone"):
+        content += _GetMSBuildLocalProperties("v120_wp81")
+    else:
+        content += _GetMSBuildLocalProperties(project.msbuild_toolset)
+    content += import_cpp_props_section
+    content += import_masm_props_section
+    if "arm64" in platforms and toolset == "target":
+        content += import_marmasm_props_section
+    content += _GetMSBuildExtensions(props_files_of_rules)
+    content += _GetMSBuildPropertySheets(configurations, spec)
+    content += macro_section
+    content += _GetMSBuildConfigurationGlobalProperties(
+        spec, configurations, project.build_file
+    )
+    content += _GetMSBuildToolSettingsSections(spec, configurations)
+    content += _GetMSBuildSources(
+        spec,
+        sources,
+        exclusions,
+        rule_dependencies,
+        extension_to_rule_name,
+        actions_spec,
+        sources_handled_by_action,
+        list_excluded,
+    )
+    content += _GetMSBuildProjectReferences(project)
+    content += import_cpp_targets_section
+    content += import_masm_targets_section
+    if "arm64" in platforms and toolset == "target":
+        content += import_marmasm_targets_section
+    content += _GetMSBuildExtensionTargets(targets_files_of_rules)
+
+    if spec.get("msvs_external_builder"):
+        content += _GetMSBuildExternalBuilderTargets(spec)
+
+    # TODO(jeanluc) File a bug to get rid of runas.  We had in MSVS:
+    # has_run_as = _WriteMSVSUserFile(project.path, version, spec)
+
+    easy_xml.WriteXmlIfChanged(content, project.path, pretty=True, win32=True)
+
+    return missing_sources
 
 
 def _GetMSBuildExternalBuilderTargets(spec):
-  """Return a list of MSBuild targets for external builders.
+    """Return a list of MSBuild targets for external builders.
 
   The "Build" and "Clean" targets are always generated.  If the spec contains
   'msvs_external_builder_clcompile_cmd', then the "ClCompile" target will also
@@ -3463,47 +3833,52 @@ def _GetMSBuildExternalBuilderTargets(spec):
   Returns:
     List of MSBuild 'Target' specs.
   """
-  build_cmd = _BuildCommandLineForRuleRaw(
-      spec, spec['msvs_external_builder_build_cmd'],
-      False, False, False, False)
-  build_target = ['Target', {'Name': 'Build'}]
-  build_target.append(['Exec', {'Command': build_cmd}])
-
-  clean_cmd = _BuildCommandLineForRuleRaw(
-      spec, spec['msvs_external_builder_clean_cmd'],
-      False, False, False, False)
-  clean_target = ['Target', {'Name': 'Clean'}]
-  clean_target.append(['Exec', {'Command': clean_cmd}])
-
-  targets = [build_target, clean_target]
-
-  if spec.get('msvs_external_builder_clcompile_cmd'):
-    clcompile_cmd = _BuildCommandLineForRuleRaw(
-        spec, spec['msvs_external_builder_clcompile_cmd'],
-        False, False, False, False)
-    clcompile_target = ['Target', {'Name': 'ClCompile'}]
-    clcompile_target.append(['Exec', {'Command': clcompile_cmd}])
-    targets.append(clcompile_target)
-
-  return targets
+    build_cmd = _BuildCommandLineForRuleRaw(
+        spec, spec["msvs_external_builder_build_cmd"], False, False, False, False
+    )
+    build_target = ["Target", {"Name": "Build"}]
+    build_target.append(["Exec", {"Command": build_cmd}])
+
+    clean_cmd = _BuildCommandLineForRuleRaw(
+        spec, spec["msvs_external_builder_clean_cmd"], False, False, False, False
+    )
+    clean_target = ["Target", {"Name": "Clean"}]
+    clean_target.append(["Exec", {"Command": clean_cmd}])
+
+    targets = [build_target, clean_target]
+
+    if spec.get("msvs_external_builder_clcompile_cmd"):
+        clcompile_cmd = _BuildCommandLineForRuleRaw(
+            spec,
+            spec["msvs_external_builder_clcompile_cmd"],
+            False,
+            False,
+            False,
+            False,
+        )
+        clcompile_target = ["Target", {"Name": "ClCompile"}]
+        clcompile_target.append(["Exec", {"Command": clcompile_cmd}])
+        targets.append(clcompile_target)
+
+    return targets
 
 
 def _GetMSBuildExtensions(props_files_of_rules):
-  extensions = ['ImportGroup', {'Label': 'ExtensionSettings'}]
-  for props_file in props_files_of_rules:
-    extensions.append(['Import', {'Project': props_file}])
-  return [extensions]
+    extensions = ["ImportGroup", {"Label": "ExtensionSettings"}]
+    for props_file in props_files_of_rules:
+        extensions.append(["Import", {"Project": props_file}])
+    return [extensions]
 
 
 def _GetMSBuildExtensionTargets(targets_files_of_rules):
-  targets_node = ['ImportGroup', {'Label': 'ExtensionTargets'}]
-  for targets_file in sorted(targets_files_of_rules):
-    targets_node.append(['Import', {'Project': targets_file}])
-  return [targets_node]
+    targets_node = ["ImportGroup", {"Label": "ExtensionTargets"}]
+    for targets_file in sorted(targets_files_of_rules):
+        targets_node.append(["Import", {"Project": targets_file}])
+    return [targets_node]
 
 
 def _GenerateActionsForMSBuild(spec, actions_to_add):
-  """Add actions accumulated into an actions_to_add, merging as needed.
+    """Add actions accumulated into an actions_to_add, merging as needed.
 
   Arguments:
     spec: the target project dict
@@ -3513,63 +3888,87 @@ def _GenerateActionsForMSBuild(spec, actions_to_add):
   Returns:
     A pair of (action specification, the sources handled by this action).
   """
-  sources_handled_by_action = OrderedSet()
-  actions_spec = []
-  for primary_input, actions in actions_to_add.items():
-    inputs = OrderedSet()
-    outputs = OrderedSet()
-    descriptions = []
-    commands = []
-    for action in actions:
-      inputs.update(OrderedSet(action['inputs']))
-      outputs.update(OrderedSet(action['outputs']))
-      descriptions.append(action['description'])
-      cmd = action['command']
-      # For most actions, add 'call' so that actions that invoke batch files
-      # return and continue executing.  msbuild_use_call provides a way to
-      # disable this but I have not seen any adverse effect from doing that
-      # for everything.
-      if action.get('msbuild_use_call', True):
-        cmd = 'call ' + cmd
-      commands.append(cmd)
-    # Add the custom build action for one input file.
-    description = ', and also '.join(descriptions)
-
-    # We can't join the commands simply with && because the command line will
-    # get too long. See also _AddActions: cygwin's setup_env mustn't be called
-    # for every invocation or the command that sets the PATH will grow too
-    # long.
-    command = '\r\n'.join([c + '\r\nif %errorlevel% neq 0 exit /b %errorlevel%'
-                           for c in commands])
-    _AddMSBuildAction(spec,
-                      primary_input,
-                      inputs,
-                      outputs,
-                      command,
-                      description,
-                      sources_handled_by_action,
-                      actions_spec)
-  return actions_spec, sources_handled_by_action
-
-
-def _AddMSBuildAction(spec, primary_input, inputs, outputs, cmd, description,
-                      sources_handled_by_action, actions_spec):
-  command = MSVSSettings.ConvertVCMacrosToMSBuild(cmd)
-  primary_input = _FixPath(primary_input)
-  inputs_array = _FixPaths(inputs)
-  outputs_array = _FixPaths(outputs)
-  additional_inputs = ';'.join([i for i in inputs_array
-                                if i != primary_input])
-  outputs = ';'.join(outputs_array)
-  sources_handled_by_action.add(primary_input)
-  action_spec = ['CustomBuild', {'Include': primary_input}]
-  action_spec.extend(
-      # TODO(jeanluc) 'Document' for all or just if as_sources?
-      [['FileType', 'Document'],
-       ['Command', command],
-       ['Message', description],
-       ['Outputs', outputs]
-      ])
-  if additional_inputs:
-    action_spec.append(['AdditionalInputs', additional_inputs])
-  actions_spec.append(action_spec)
+    sources_handled_by_action = OrderedSet()
+    actions_spec = []
+    for primary_input, actions in actions_to_add.items():
+        if generator_supports_multiple_toolsets:
+            primary_input = primary_input.replace(".exe", "_host.exe")
+        inputs = OrderedSet()
+        outputs = OrderedSet()
+        descriptions = []
+        commands = []
+        for action in actions:
+
+            def fixup_host_exe(i):
+                if "$(OutDir)" in i:
+                    i = i.replace(".exe", "_host.exe")
+                return i
+
+            if generator_supports_multiple_toolsets:
+                action["inputs"] = [fixup_host_exe(i) for i in action["inputs"]]
+            inputs.update(OrderedSet(action["inputs"]))
+            outputs.update(OrderedSet(action["outputs"]))
+            descriptions.append(action["description"])
+            cmd = action["command"]
+            if generator_supports_multiple_toolsets:
+                cmd = cmd.replace(".exe", "_host.exe")
+            # For most actions, add 'call' so that actions that invoke batch files
+            # return and continue executing.  msbuild_use_call provides a way to
+            # disable this but I have not seen any adverse effect from doing that
+            # for everything.
+            if action.get("msbuild_use_call", True):
+                cmd = "call " + cmd
+            commands.append(cmd)
+        # Add the custom build action for one input file.
+        description = ", and also ".join(descriptions)
+
+        # We can't join the commands simply with && because the command line will
+        # get too long. See also _AddActions: cygwin's setup_env mustn't be called
+        # for every invocation or the command that sets the PATH will grow too
+        # long.
+        command = "\r\n".join(
+            [c + "\r\nif %errorlevel% neq 0 exit /b %errorlevel%" for c in commands]
+        )
+        _AddMSBuildAction(
+            spec,
+            primary_input,
+            inputs,
+            outputs,
+            command,
+            description,
+            sources_handled_by_action,
+            actions_spec,
+        )
+    return actions_spec, sources_handled_by_action
+
+
+def _AddMSBuildAction(
+    spec,
+    primary_input,
+    inputs,
+    outputs,
+    cmd,
+    description,
+    sources_handled_by_action,
+    actions_spec,
+):
+    command = MSVSSettings.ConvertVCMacrosToMSBuild(cmd)
+    primary_input = _FixPath(primary_input)
+    inputs_array = _FixPaths(inputs)
+    outputs_array = _FixPaths(outputs)
+    additional_inputs = ";".join([i for i in inputs_array if i != primary_input])
+    outputs = ";".join(outputs_array)
+    sources_handled_by_action.add(primary_input)
+    action_spec = ["CustomBuild", {"Include": primary_input}]
+    action_spec.extend(
+        # TODO(jeanluc) 'Document' for all or just if as_sources?
+        [
+            ["FileType", "Document"],
+            ["Command", command],
+            ["Message", description],
+            ["Outputs", outputs],
+        ]
+    )
+    if additional_inputs:
+        action_spec.append(["AdditionalInputs", additional_inputs])
+    actions_spec.append(action_spec)
diff --git a/tools/gyp/pylib/gyp/generator/msvs_test.py b/tools/gyp/pylib/gyp/generator/msvs_test.py
index 1b0cdd17201d5b845575bddcbb4a92a45cc27409..e001f417d53aa58b39e4f1dbceae513c8cee9413 100755
--- a/tools/gyp/pylib/gyp/generator/msvs_test.py
+++ b/tools/gyp/pylib/gyp/generator/msvs_test.py
@@ -9,33 +9,39 @@ import gyp.generator.msvs as msvs
 import unittest
 
 try:
-  from StringIO import StringIO  # Python 2
+    from StringIO import StringIO  # Python 2
 except ImportError:
-  from io import StringIO  # Python 3
+    from io import StringIO  # Python 3
 
 
 class TestSequenceFunctions(unittest.TestCase):
-
-  def setUp(self):
-    self.stderr = StringIO()
-
-  def test_GetLibraries(self):
-    self.assertEqual(
-      msvs._GetLibraries({}),
-      [])
-    self.assertEqual(
-      msvs._GetLibraries({'libraries': []}),
-      [])
-    self.assertEqual(
-      msvs._GetLibraries({'other':'foo', 'libraries': ['a.lib']}),
-      ['a.lib'])
-    self.assertEqual(
-      msvs._GetLibraries({'libraries': ['-la']}),
-      ['a.lib'])
-    self.assertEqual(
-      msvs._GetLibraries({'libraries': ['a.lib', 'b.lib', 'c.lib', '-lb.lib',
-                                   '-lb.lib', 'd.lib', 'a.lib']}),
-      ['c.lib', 'b.lib', 'd.lib', 'a.lib'])
-
-if __name__ == '__main__':
-  unittest.main()
+    def setUp(self):
+        self.stderr = StringIO()
+
+    def test_GetLibraries(self):
+        self.assertEqual(msvs._GetLibraries({}), [])
+        self.assertEqual(msvs._GetLibraries({"libraries": []}), [])
+        self.assertEqual(
+            msvs._GetLibraries({"other": "foo", "libraries": ["a.lib"]}), ["a.lib"]
+        )
+        self.assertEqual(msvs._GetLibraries({"libraries": ["-la"]}), ["a.lib"])
+        self.assertEqual(
+            msvs._GetLibraries(
+                {
+                    "libraries": [
+                        "a.lib",
+                        "b.lib",
+                        "c.lib",
+                        "-lb.lib",
+                        "-lb.lib",
+                        "d.lib",
+                        "a.lib",
+                    ]
+                }
+            ),
+            ["c.lib", "b.lib", "d.lib", "a.lib"],
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/gyp/pylib/gyp/generator/ninja.py b/tools/gyp/pylib/gyp/generator/ninja.py
index d5006bf84a0b2afef6e9b045bc004c41dec3aab1..e064bad7ed84042d8f72d6a37a3073451667f9aa 100644
--- a/tools/gyp/pylib/gyp/generator/ninja.py
+++ b/tools/gyp/pylib/gyp/generator/ninja.py
@@ -16,49 +16,47 @@ import subprocess
 import sys
 import gyp
 import gyp.common
-from gyp.common import OrderedSet
 import gyp.msvs_emulation
 import gyp.MSVSUtil as MSVSUtil
 import gyp.xcode_emulation
+
 try:
-  from cStringIO import StringIO
+    from cStringIO import StringIO
 except ImportError:
-  from io import StringIO
+    from io import StringIO
 
 from gyp.common import GetEnvironFallback
 import gyp.ninja_syntax as ninja_syntax
 
 generator_default_variables = {
-  'EXECUTABLE_PREFIX': '',
-  'EXECUTABLE_SUFFIX': '',
-  'STATIC_LIB_PREFIX': 'lib',
-  'STATIC_LIB_SUFFIX': '.a',
-  'SHARED_LIB_PREFIX': 'lib',
-
-  # Gyp expects the following variables to be expandable by the build
-  # system to the appropriate locations.  Ninja prefers paths to be
-  # known at gyp time.  To resolve this, introduce special
-  # variables starting with $! and $| (which begin with a $ so gyp knows it
-  # should be treated specially, but is otherwise an invalid
-  # ninja/shell variable) that are passed to gyp here but expanded
-  # before writing out into the target .ninja files; see
-  # ExpandSpecial.
-  # $! is used for variables that represent a path and that can only appear at
-  # the start of a string, while $| is used for variables that can appear
-  # anywhere in a string.
-  'INTERMEDIATE_DIR': '$!INTERMEDIATE_DIR',
-  'SHARED_INTERMEDIATE_DIR': '$!PRODUCT_DIR/gen',
-  'PRODUCT_DIR': '$!PRODUCT_DIR',
-  'CONFIGURATION_NAME': '$|CONFIGURATION_NAME',
-
-  # Special variables that may be used by gyp 'rule' targets.
-  # We generate definitions for these variables on the fly when processing a
-  # rule.
-  'RULE_INPUT_ROOT': '${root}',
-  'RULE_INPUT_DIRNAME': '${dirname}',
-  'RULE_INPUT_PATH': '${source}',
-  'RULE_INPUT_EXT': '${ext}',
-  'RULE_INPUT_NAME': '${name}',
+    "EXECUTABLE_PREFIX": "",
+    "EXECUTABLE_SUFFIX": "",
+    "STATIC_LIB_PREFIX": "lib",
+    "STATIC_LIB_SUFFIX": ".a",
+    "SHARED_LIB_PREFIX": "lib",
+    # Gyp expects the following variables to be expandable by the build
+    # system to the appropriate locations.  Ninja prefers paths to be
+    # known at gyp time.  To resolve this, introduce special
+    # variables starting with $! and $| (which begin with a $ so gyp knows it
+    # should be treated specially, but is otherwise an invalid
+    # ninja/shell variable) that are passed to gyp here but expanded
+    # before writing out into the target .ninja files; see
+    # ExpandSpecial.
+    # $! is used for variables that represent a path and that can only appear at
+    # the start of a string, while $| is used for variables that can appear
+    # anywhere in a string.
+    "INTERMEDIATE_DIR": "$!INTERMEDIATE_DIR",
+    "SHARED_INTERMEDIATE_DIR": "$!PRODUCT_DIR/gen",
+    "PRODUCT_DIR": "$!PRODUCT_DIR",
+    "CONFIGURATION_NAME": "$|CONFIGURATION_NAME",
+    # Special variables that may be used by gyp 'rule' targets.
+    # We generate definitions for these variables on the fly when processing a
+    # rule.
+    "RULE_INPUT_ROOT": "${root}",
+    "RULE_INPUT_DIRNAME": "${dirname}",
+    "RULE_INPUT_PATH": "${source}",
+    "RULE_INPUT_EXT": "${ext}",
+    "RULE_INPUT_NAME": "${name}",
 }
 
 # Placates pylint.
@@ -69,42 +67,43 @@ generator_filelist_paths = None
 
 generator_supports_multiple_toolsets = gyp.common.CrossCompileRequested()
 
+
 def StripPrefix(arg, prefix):
-  if arg.startswith(prefix):
-    return arg[len(prefix):]
-  return arg
+    if arg.startswith(prefix):
+        return arg[len(prefix) :]
+    return arg
 
 
 def QuoteShellArgument(arg, flavor):
-  """Quote a string such that it will be interpreted as a single argument
+    """Quote a string such that it will be interpreted as a single argument
   by the shell."""
-  # Rather than attempting to enumerate the bad shell characters, just
-  # whitelist common OK ones and quote anything else.
-  if re.match(r'^[a-zA-Z0-9_=.\\/-]+$', arg):
-    return arg  # No quoting necessary.
-  if flavor == 'win':
-    return gyp.msvs_emulation.QuoteForRspFile(arg)
-  return "'" + arg.replace("'", "'" + '"\'"' + "'")  + "'"
+    # Rather than attempting to enumerate the bad shell characters, just
+    # allow common OK ones and quote anything else.
+    if re.match(r"^[a-zA-Z0-9_=.\\/-]+$", arg):
+        return arg  # No quoting necessary.
+    if flavor == "win":
+        return gyp.msvs_emulation.QuoteForRspFile(arg)
+    return "'" + arg.replace("'", "'" + '"\'"' + "'") + "'"
 
 
 def Define(d, flavor):
-  """Takes a preprocessor define and returns a -D parameter that's ninja- and
+    """Takes a preprocessor define and returns a -D parameter that's ninja- and
   shell-escaped."""
-  if flavor == 'win':
-    # cl.exe replaces literal # characters with = in preprocesor definitions for
-    # some reason. Octal-encode to work around that.
-    d = d.replace('#', '\\%03o' % ord('#'))
-  return QuoteShellArgument(ninja_syntax.escape('-D' + d), flavor)
+    if flavor == "win":
+        # cl.exe replaces literal # characters with = in preprocessor definitions for
+        # some reason. Octal-encode to work around that.
+        d = d.replace("#", "\\%03o" % ord("#"))
+    return QuoteShellArgument(ninja_syntax.escape("-D" + d), flavor)
 
 
 def AddArch(output, arch):
-  """Adds an arch string to an output path."""
-  output, extension = os.path.splitext(output)
-  return '%s.%s%s' % (output, arch, extension)
+    """Adds an arch string to an output path."""
+    output, extension = os.path.splitext(output)
+    return "%s.%s%s" % (output, arch, extension)
 
 
 class Target(object):
-  """Target represents the paths used within a single gyp target.
+    """Target represents the paths used within a single gyp target.
 
   Conceptually, building a single target A is a series of steps:
 
@@ -126,67 +125,68 @@ class Target(object):
   variables only store concrete paths to single files, while methods
   compute derived values like "the last output of the target".
   """
-  def __init__(self, type):
-    # Gyp type ("static_library", etc.) of this target.
-    self.type = type
-    # File representing whether any input dependencies necessary for
-    # dependent actions have completed.
-    self.preaction_stamp = None
-    # File representing whether any input dependencies necessary for
-    # dependent compiles have completed.
-    self.precompile_stamp = None
-    # File representing the completion of actions/rules/copies, if any.
-    self.actions_stamp = None
-    # Path to the output of the link step, if any.
-    self.binary = None
-    # Path to the file representing the completion of building the bundle,
-    # if any.
-    self.bundle = None
-    # On Windows, incremental linking requires linking against all the .objs
-    # that compose a .lib (rather than the .lib itself). That list is stored
-    # here. In this case, we also need to save the compile_deps for the target,
-    # so that the target that directly depends on the .objs can also depend
-    # on those.
-    self.component_objs = None
-    self.compile_deps = None
-    # Windows only. The import .lib is the output of a build step, but
-    # because dependents only link against the lib (not both the lib and the
-    # dll) we keep track of the import library here.
-    self.import_lib = None
-    # Track if this target contains any C++ files, to decide if gcc or g++
-    # should be used for linking.
-    self.uses_cpp = False
-
-  def Linkable(self):
-    """Return true if this is a target that can be linked against."""
-    return self.type in ('static_library', 'shared_library')
-
-  def UsesToc(self, flavor):
-    """Return true if the target should produce a restat rule based on a TOC
+
+    def __init__(self, type):
+        # Gyp type ("static_library", etc.) of this target.
+        self.type = type
+        # File representing whether any input dependencies necessary for
+        # dependent actions have completed.
+        self.preaction_stamp = None
+        # File representing whether any input dependencies necessary for
+        # dependent compiles have completed.
+        self.precompile_stamp = None
+        # File representing the completion of actions/rules/copies, if any.
+        self.actions_stamp = None
+        # Path to the output of the link step, if any.
+        self.binary = None
+        # Path to the file representing the completion of building the bundle,
+        # if any.
+        self.bundle = None
+        # On Windows, incremental linking requires linking against all the .objs
+        # that compose a .lib (rather than the .lib itself). That list is stored
+        # here. In this case, we also need to save the compile_deps for the target,
+        # so that the target that directly depends on the .objs can also depend
+        # on those.
+        self.component_objs = None
+        self.compile_deps = None
+        # Windows only. The import .lib is the output of a build step, but
+        # because dependents only link against the lib (not both the lib and the
+        # dll) we keep track of the import library here.
+        self.import_lib = None
+        # Track if this target contains any C++ files, to decide if gcc or g++
+        # should be used for linking.
+        self.uses_cpp = False
+
+    def Linkable(self):
+        """Return true if this is a target that can be linked against."""
+        return self.type in ("static_library", "shared_library")
+
+    def UsesToc(self, flavor):
+        """Return true if the target should produce a restat rule based on a TOC
     file."""
-    # For bundles, the .TOC should be produced for the binary, not for
-    # FinalOutput(). But the naive approach would put the TOC file into the
-    # bundle, so don't do this for bundles for now.
-    if flavor == 'win' or self.bundle:
-      return False
-    return self.type in ('shared_library', 'loadable_module')
-
-  def PreActionInput(self, flavor):
-    """Return the path, if any, that should be used as a dependency of
+        # For bundles, the .TOC should be produced for the binary, not for
+        # FinalOutput(). But the naive approach would put the TOC file into the
+        # bundle, so don't do this for bundles for now.
+        if flavor == "win" or self.bundle:
+            return False
+        return self.type in ("shared_library", "loadable_module")
+
+    def PreActionInput(self, flavor):
+        """Return the path, if any, that should be used as a dependency of
     any dependent action step."""
-    if self.UsesToc(flavor):
-      return self.FinalOutput() + '.TOC'
-    return self.FinalOutput() or self.preaction_stamp
+        if self.UsesToc(flavor):
+            return self.FinalOutput() + ".TOC"
+        return self.FinalOutput() or self.preaction_stamp
 
-  def PreCompileInput(self):
-    """Return the path, if any, that should be used as a dependency of
+    def PreCompileInput(self):
+        """Return the path, if any, that should be used as a dependency of
     any dependent compile step."""
-    return self.actions_stamp or self.precompile_stamp
+        return self.actions_stamp or self.precompile_stamp
 
-  def FinalOutput(self):
-    """Return the last output of the target, which depends on all prior
+    def FinalOutput(self):
+        """Return the last output of the target, which depends on all prior
     steps."""
-    return self.bundle or self.binary or self.actions_stamp
+        return self.bundle or self.binary or self.actions_stamp
 
 
 # A small discourse on paths as used within the Ninja build:
@@ -213,108 +213,116 @@ class Target(object):
 #   an output file; the result can be namespaced such that it is unique
 #   to the input file name as well as the output target name.
 
+
 class NinjaWriter(object):
-  def __init__(self, hash_for_rules, target_outputs, base_dir, build_dir,
-               output_file, toplevel_build, output_file_name, flavor,
-               toplevel_dir=None):
-    """
+    def __init__(
+        self,
+        hash_for_rules,
+        target_outputs,
+        base_dir,
+        build_dir,
+        output_file,
+        toplevel_build,
+        output_file_name,
+        flavor,
+        toplevel_dir=None,
+    ):
+        """
     base_dir: path from source root to directory containing this gyp file,
               by gyp semantics, all input paths are relative to this
     build_dir: path from source root to build output
     toplevel_dir: path to the toplevel directory
     """
 
-    self.hash_for_rules = hash_for_rules
-    self.target_outputs = target_outputs
-    self.base_dir = base_dir
-    self.build_dir = build_dir
-    self.ninja = ninja_syntax.Writer(output_file)
-    self.toplevel_build = toplevel_build
-    self.output_file_name = output_file_name
-
-    self.flavor = flavor
-    self.abs_build_dir = None
-    if toplevel_dir is not None:
-      self.abs_build_dir = os.path.abspath(os.path.join(toplevel_dir,
-                                                        build_dir))
-    self.obj_ext = '.obj' if flavor == 'win' else '.o'
-    if flavor == 'win':
-      # See docstring of msvs_emulation.GenerateEnvironmentFiles().
-      self.win_env = {}
-      for arch in ('x86', 'x64'):
-        self.win_env[arch] = 'environment.' + arch
-
-    # Relative path from build output dir to base dir.
-    build_to_top = gyp.common.InvertRelativePath(build_dir, toplevel_dir)
-    self.build_to_base = os.path.join(build_to_top, base_dir)
-    # Relative path from base dir to build dir.
-    base_to_top = gyp.common.InvertRelativePath(base_dir, toplevel_dir)
-    self.base_to_build = os.path.join(base_to_top, build_dir)
-
-  def ExpandSpecial(self, path, product_dir=None):
-    """Expand specials like $!PRODUCT_DIR in |path|.
+        self.hash_for_rules = hash_for_rules
+        self.target_outputs = target_outputs
+        self.base_dir = base_dir
+        self.build_dir = build_dir
+        self.ninja = ninja_syntax.Writer(output_file)
+        self.toplevel_build = toplevel_build
+        self.output_file_name = output_file_name
+
+        self.flavor = flavor
+        self.abs_build_dir = None
+        if toplevel_dir is not None:
+            self.abs_build_dir = os.path.abspath(os.path.join(toplevel_dir, build_dir))
+        self.obj_ext = ".obj" if flavor == "win" else ".o"
+        if flavor == "win":
+            # See docstring of msvs_emulation.GenerateEnvironmentFiles().
+            self.win_env = {}
+            for arch in ("x86", "x64"):
+                self.win_env[arch] = "environment." + arch
+
+        # Relative path from build output dir to base dir.
+        build_to_top = gyp.common.InvertRelativePath(build_dir, toplevel_dir)
+        self.build_to_base = os.path.join(build_to_top, base_dir)
+        # Relative path from base dir to build dir.
+        base_to_top = gyp.common.InvertRelativePath(base_dir, toplevel_dir)
+        self.base_to_build = os.path.join(base_to_top, build_dir)
+
+    def ExpandSpecial(self, path, product_dir=None):
+        """Expand specials like $!PRODUCT_DIR in |path|.
 
     If |product_dir| is None, assumes the cwd is already the product
     dir.  Otherwise, |product_dir| is the relative path to the product
     dir.
     """
 
-    PRODUCT_DIR = '$!PRODUCT_DIR'
-    if PRODUCT_DIR in path:
-      if product_dir:
-        path = path.replace(PRODUCT_DIR, product_dir)
-      else:
-        path = path.replace(PRODUCT_DIR + '/', '')
-        path = path.replace(PRODUCT_DIR + '\\', '')
-        path = path.replace(PRODUCT_DIR, '.')
-
-    INTERMEDIATE_DIR = '$!INTERMEDIATE_DIR'
-    if INTERMEDIATE_DIR in path:
-      int_dir = self.GypPathToUniqueOutput('gen')
-      # GypPathToUniqueOutput generates a path relative to the product dir,
-      # so insert product_dir in front if it is provided.
-      path = path.replace(INTERMEDIATE_DIR,
-                          os.path.join(product_dir or '', int_dir))
-
-    CONFIGURATION_NAME = '$|CONFIGURATION_NAME'
-    path = path.replace(CONFIGURATION_NAME, self.config_name)
-
-    return path
-
-  def ExpandRuleVariables(self, path, root, dirname, source, ext, name):
-    if self.flavor == 'win':
-      path = self.msvs_settings.ConvertVSMacros(
-          path, config=self.config_name)
-    path = path.replace(generator_default_variables['RULE_INPUT_ROOT'], root)
-    path = path.replace(generator_default_variables['RULE_INPUT_DIRNAME'],
-                        dirname)
-    path = path.replace(generator_default_variables['RULE_INPUT_PATH'], source)
-    path = path.replace(generator_default_variables['RULE_INPUT_EXT'], ext)
-    path = path.replace(generator_default_variables['RULE_INPUT_NAME'], name)
-    return path
-
-  def GypPathToNinja(self, path, env=None):
-    """Translate a gyp path to a ninja path, optionally expanding environment
+        PRODUCT_DIR = "$!PRODUCT_DIR"
+        if PRODUCT_DIR in path:
+            if product_dir:
+                path = path.replace(PRODUCT_DIR, product_dir)
+            else:
+                path = path.replace(PRODUCT_DIR + "/", "")
+                path = path.replace(PRODUCT_DIR + "\\", "")
+                path = path.replace(PRODUCT_DIR, ".")
+
+        INTERMEDIATE_DIR = "$!INTERMEDIATE_DIR"
+        if INTERMEDIATE_DIR in path:
+            int_dir = self.GypPathToUniqueOutput("gen")
+            # GypPathToUniqueOutput generates a path relative to the product dir,
+            # so insert product_dir in front if it is provided.
+            path = path.replace(
+                INTERMEDIATE_DIR, os.path.join(product_dir or "", int_dir)
+            )
+
+        CONFIGURATION_NAME = "$|CONFIGURATION_NAME"
+        path = path.replace(CONFIGURATION_NAME, self.config_name)
+
+        return path
+
+    def ExpandRuleVariables(self, path, root, dirname, source, ext, name):
+        if self.flavor == "win":
+            path = self.msvs_settings.ConvertVSMacros(path, config=self.config_name)
+        path = path.replace(generator_default_variables["RULE_INPUT_ROOT"], root)
+        path = path.replace(generator_default_variables["RULE_INPUT_DIRNAME"], dirname)
+        path = path.replace(generator_default_variables["RULE_INPUT_PATH"], source)
+        path = path.replace(generator_default_variables["RULE_INPUT_EXT"], ext)
+        path = path.replace(generator_default_variables["RULE_INPUT_NAME"], name)
+        return path
+
+    def GypPathToNinja(self, path, env=None):
+        """Translate a gyp path to a ninja path, optionally expanding environment
     variable references in |path| with |env|.
 
     See the above discourse on path conversions."""
-    if env:
-      if self.flavor == 'mac':
-        path = gyp.xcode_emulation.ExpandEnvVars(path, env)
-      elif self.flavor == 'win':
-        path = gyp.msvs_emulation.ExpandMacros(path, env)
-    if path.startswith('$!'):
-      expanded = self.ExpandSpecial(path)
-      if self.flavor == 'win':
-        expanded = os.path.normpath(expanded)
-      return expanded
-    if '$|' in path:
-      path = self.ExpandSpecial(path)
-    assert '$' not in path, path
-    return os.path.normpath(os.path.join(self.build_to_base, path))
-
-  def GypPathToUniqueOutput(self, path, qualified=True):
-    """Translate a gyp path to a ninja path for writing output.
+        if env:
+            if self.flavor == "mac":
+                path = gyp.xcode_emulation.ExpandEnvVars(path, env)
+            elif self.flavor == "win":
+                path = gyp.msvs_emulation.ExpandMacros(path, env)
+        if path.startswith("$!"):
+            expanded = self.ExpandSpecial(path)
+            if self.flavor == "win":
+                expanded = os.path.normpath(expanded)
+            return expanded
+        if "$|" in path:
+            path = self.ExpandSpecial(path)
+        assert "$" not in path, path
+        return os.path.normpath(os.path.join(self.build_to_base, path))
+
+    def GypPathToUniqueOutput(self, path, qualified=True):
+        """Translate a gyp path to a ninja path for writing output.
 
     If qualified is True, qualify the resulting filename with the name
     of the target.  This is necessary when e.g. compiling the same
@@ -322,2180 +330,2611 @@ class NinjaWriter(object):
 
     See the above discourse on path conversions."""
 
-    path = self.ExpandSpecial(path)
-    assert not path.startswith('$'), path
-
-    # Translate the path following this scheme:
-    #   Input: foo/bar.gyp, target targ, references baz/out.o
-    #   Output: obj/foo/baz/targ.out.o (if qualified)
-    #           obj/foo/baz/out.o (otherwise)
-    #     (and obj.host instead of obj for cross-compiles)
-    #
-    # Why this scheme and not some other one?
-    # 1) for a given input, you can compute all derived outputs by matching
-    #    its path, even if the input is brought via a gyp file with '..'.
-    # 2) simple files like libraries and stamps have a simple filename.
-
-    obj = 'obj'
-    if self.toolset != 'target':
-      obj += '.' + self.toolset
-
-    path_dir, path_basename = os.path.split(path)
-    assert not os.path.isabs(path_dir), (
-        "'%s' can not be absolute path (see crbug.com/462153)." % path_dir)
-
-    if qualified:
-      path_basename = self.name + '.' + path_basename
-    return os.path.normpath(os.path.join(obj, self.base_dir, path_dir,
-                                         path_basename))
-
-  def WriteCollapsedDependencies(self, name, targets, order_only=None):
-    """Given a list of targets, return a path for a single file
+        path = self.ExpandSpecial(path)
+        assert not path.startswith("$"), path
+
+        # Translate the path following this scheme:
+        #   Input: foo/bar.gyp, target targ, references baz/out.o
+        #   Output: obj/foo/baz/targ.out.o (if qualified)
+        #           obj/foo/baz/out.o (otherwise)
+        #     (and obj.host instead of obj for cross-compiles)
+        #
+        # Why this scheme and not some other one?
+        # 1) for a given input, you can compute all derived outputs by matching
+        #    its path, even if the input is brought via a gyp file with '..'.
+        # 2) simple files like libraries and stamps have a simple filename.
+
+        obj = "obj"
+        if self.toolset != "target":
+            obj += "." + self.toolset
+
+        path_dir, path_basename = os.path.split(path)
+        assert not os.path.isabs(path_dir), (
+            "'%s' can not be absolute path (see crbug.com/462153)." % path_dir
+        )
+
+        if qualified:
+            path_basename = self.name + "." + path_basename
+        return os.path.normpath(
+            os.path.join(obj, self.base_dir, path_dir, path_basename)
+        )
+
+    def WriteCollapsedDependencies(self, name, targets, order_only=None):
+        """Given a list of targets, return a path for a single file
     representing the result of building all the targets or None.
 
     Uses a stamp file if necessary."""
 
-    assert targets == [item for item in targets if item], targets
-    if len(targets) == 0:
-      assert not order_only
-      return None
-    if len(targets) > 1 or order_only:
-      stamp = self.GypPathToUniqueOutput(name + '.stamp')
-      targets = self.ninja.build(stamp, 'stamp', targets, order_only=order_only)
-      self.ninja.newline()
-    return targets[0]
+        assert targets == [item for item in targets if item], targets
+        if len(targets) == 0:
+            assert not order_only
+            return None
+        if len(targets) > 1 or order_only:
+            stamp = self.GypPathToUniqueOutput(name + ".stamp")
+            targets = self.ninja.build(stamp, "stamp", targets, order_only=order_only)
+            self.ninja.newline()
+        return targets[0]
 
-  def _SubninjaNameForArch(self, arch):
-    output_file_base = os.path.splitext(self.output_file_name)[0]
-    return '%s.%s.ninja' % (output_file_base, arch)
+    def _SubninjaNameForArch(self, arch):
+        output_file_base = os.path.splitext(self.output_file_name)[0]
+        return "%s.%s.ninja" % (output_file_base, arch)
 
-  def WriteSpec(self, spec, config_name, generator_flags):
-    """The main entry point for NinjaWriter: write the build rules for a spec.
+    def WriteSpec(self, spec, config_name, generator_flags):
+        """The main entry point for NinjaWriter: write the build rules for a spec.
 
     Returns a Target object, which represents the output paths for this spec.
     Returns None if there are no outputs (e.g. a settings-only 'none' type
     target)."""
 
-    self.config_name = config_name
-    self.name = spec['target_name']
-    self.toolset = spec['toolset']
-    config = spec['configurations'][config_name]
-    self.target = Target(spec['type'])
-    self.is_standalone_static_library = bool(
-        spec.get('standalone_static_library', 0))
-
-    self.target_rpath = generator_flags.get('target_rpath', r'\$$ORIGIN/lib/')
-
-    self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
-    self.xcode_settings = self.msvs_settings = None
-    if self.flavor == 'mac':
-      self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
-      mac_toolchain_dir = generator_flags.get('mac_toolchain_dir', None)
-      if mac_toolchain_dir:
-        self.xcode_settings.mac_toolchain_dir = mac_toolchain_dir
-
-    if self.flavor == 'win':
-      self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec,
-                                                           generator_flags)
-      arch = self.msvs_settings.GetArch(config_name)
-      self.ninja.variable('arch', self.win_env[arch])
-      self.ninja.variable('cc', '$cl_' + arch)
-      self.ninja.variable('cxx', '$cl_' + arch)
-      self.ninja.variable('cc_host', '$cl_' + arch)
-      self.ninja.variable('cxx_host', '$cl_' + arch)
-      self.ninja.variable('asm', '$ml_' + arch)
-
-    if self.flavor == 'mac':
-      self.archs = self.xcode_settings.GetActiveArchs(config_name)
-      if len(self.archs) > 1:
-        self.arch_subninjas = dict(
-            (arch, ninja_syntax.Writer(
-                OpenOutput(os.path.join(self.toplevel_build,
-                                        self._SubninjaNameForArch(arch)),
-                           'w')))
-            for arch in self.archs)
-
-    # Compute predepends for all rules.
-    # actions_depends is the dependencies this target depends on before running
-    # any of its action/rule/copy steps.
-    # compile_depends is the dependencies this target depends on before running
-    # any of its compile steps.
-    actions_depends = []
-    compile_depends = []
-    # TODO(evan): it is rather confusing which things are lists and which
-    # are strings.  Fix these.
-    if 'dependencies' in spec:
-      for dep in spec['dependencies']:
-        if dep in self.target_outputs:
-          target = self.target_outputs[dep]
-          actions_depends.append(target.PreActionInput(self.flavor))
-          compile_depends.append(target.PreCompileInput())
-          if target.uses_cpp:
-            self.target.uses_cpp = True
-      actions_depends = [item for item in actions_depends if item]
-      compile_depends = [item for item in compile_depends if item]
-      actions_depends = self.WriteCollapsedDependencies('actions_depends',
-                                                        actions_depends)
-      compile_depends = self.WriteCollapsedDependencies('compile_depends',
-                                                        compile_depends)
-      self.target.preaction_stamp = actions_depends
-      self.target.precompile_stamp = compile_depends
-
-    # Write out actions, rules, and copies.  These must happen before we
-    # compile any sources, so compute a list of predependencies for sources
-    # while we do it.
-    extra_sources = []
-    mac_bundle_depends = []
-    self.target.actions_stamp = self.WriteActionsRulesCopies(
-        spec, extra_sources, actions_depends, mac_bundle_depends)
-
-    # If we have actions/rules/copies, we depend directly on those, but
-    # otherwise we depend on dependent target's actions/rules/copies etc.
-    # We never need to explicitly depend on previous target's link steps,
-    # because no compile ever depends on them.
-    compile_depends_stamp = (self.target.actions_stamp or compile_depends)
-
-    # Write out the compilation steps, if any.
-    link_deps = []
-    try:
-      sources = extra_sources + spec.get('sources', [])
-    except TypeError:
-      print('extra_sources: ', str(extra_sources))
-      print('spec.get("sources"): ', str(spec.get('sources')))
-      raise
-    if sources:
-      if self.flavor == 'mac' and len(self.archs) > 1:
-        # Write subninja file containing compile and link commands scoped to
-        # a single arch if a fat binary is being built.
-        for arch in self.archs:
-          self.ninja.subninja(self._SubninjaNameForArch(arch))
-
-      pch = None
-      if self.flavor == 'win':
-        gyp.msvs_emulation.VerifyMissingSources(
-            sources, self.abs_build_dir, generator_flags, self.GypPathToNinja)
-        pch = gyp.msvs_emulation.PrecompiledHeader(
-            self.msvs_settings, config_name, self.GypPathToNinja,
-            self.GypPathToUniqueOutput, self.obj_ext)
-      else:
-        pch = gyp.xcode_emulation.MacPrefixHeader(
-            self.xcode_settings, self.GypPathToNinja,
-            lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang))
-      link_deps = self.WriteSources(
-          self.ninja, config_name, config, sources, compile_depends_stamp, pch,
-          spec)
-      # Some actions/rules output 'sources' that are already object files.
-      obj_outputs = [f for f in sources if f.endswith(self.obj_ext)]
-      if obj_outputs:
-        if self.flavor != 'mac' or len(self.archs) == 1:
-          link_deps += [self.GypPathToNinja(o) for o in obj_outputs]
-        else:
-          print("Warning: Actions/rules writing object files don't work with "
-                "multiarch targets, dropping. (target %s)" % spec['target_name'])
-    elif self.flavor == 'mac' and len(self.archs) > 1:
-      link_deps = collections.defaultdict(list)
-
-    compile_deps = self.target.actions_stamp or actions_depends
-    if self.flavor == 'win' and self.target.type == 'static_library':
-      self.target.component_objs = link_deps
-      self.target.compile_deps = compile_deps
-
-    # Write out a link step, if needed.
-    output = None
-    is_empty_bundle = not link_deps and not mac_bundle_depends
-    if link_deps or self.target.actions_stamp or actions_depends:
-      output = self.WriteTarget(spec, config_name, config, link_deps,
-                                compile_deps)
-      if self.is_mac_bundle:
-        mac_bundle_depends.append(output)
-
-    # Bundle all of the above together, if needed.
-    if self.is_mac_bundle:
-      output = self.WriteMacBundle(spec, mac_bundle_depends, is_empty_bundle)
-
-    if not output:
-      return None
-
-    assert self.target.FinalOutput(), output
-    return self.target
-
-  def _WinIdlRule(self, source, prebuild, outputs):
-    """Handle the implicit VS .idl rule for one source file. Fills |outputs|
-    with files that are generated."""
-    outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(
-        source, self.config_name)
-    outdir = self.GypPathToNinja(outdir)
-    def fix_path(path, rel=None):
-      path = os.path.join(outdir, path)
-      dirname, basename = os.path.split(source)
-      root, ext = os.path.splitext(basename)
-      path = self.ExpandRuleVariables(
-          path, root, dirname, source, ext, basename)
-      if rel:
-        path = os.path.relpath(path, rel)
-      return path
-    vars = [(name, fix_path(value, outdir)) for name, value in vars]
-    output = [fix_path(p) for p in output]
-    vars.append(('outdir', outdir))
-    vars.append(('idlflags', flags))
-    input = self.GypPathToNinja(source)
-    self.ninja.build(output, 'idl', input,
-        variables=vars, order_only=prebuild)
-    outputs.extend(output)
-
-  def WriteWinIdlFiles(self, spec, prebuild):
-    """Writes rules to match MSVS's implicit idl handling."""
-    assert self.flavor == 'win'
-    if self.msvs_settings.HasExplicitIdlRulesOrActions(spec):
-      return []
-    outputs = []
-    for source in filter(lambda x: x.endswith('.idl'), spec['sources']):
-      self._WinIdlRule(source, prebuild, outputs)
-    return outputs
-
-  def WriteActionsRulesCopies(self, spec, extra_sources, prebuild,
-                              mac_bundle_depends):
-    """Write out the Actions, Rules, and Copies steps.  Return a path
-    representing the outputs of these steps."""
-    outputs = []
-    if self.is_mac_bundle:
-      mac_bundle_resources = spec.get('mac_bundle_resources', [])[:]
-    else:
-      mac_bundle_resources = []
-    extra_mac_bundle_resources = []
-
-    if 'actions' in spec:
-      outputs += self.WriteActions(spec['actions'], extra_sources, prebuild,
-                                   extra_mac_bundle_resources)
-    if 'rules' in spec:
-      outputs += self.WriteRules(spec['rules'], extra_sources, prebuild,
-                                 mac_bundle_resources,
-                                 extra_mac_bundle_resources)
-    if 'copies' in spec:
-      outputs += self.WriteCopies(spec['copies'], prebuild, mac_bundle_depends)
+        self.config_name = config_name
+        self.name = spec["target_name"]
+        self.toolset = spec["toolset"]
+        config = spec["configurations"][config_name]
+        self.target = Target(spec["type"])
+        self.is_standalone_static_library = bool(
+            spec.get("standalone_static_library", 0)
+        )
+
+        self.target_rpath = generator_flags.get("target_rpath", r"\$$ORIGIN/lib/")
+
+        self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
+        self.xcode_settings = self.msvs_settings = None
+        if self.flavor == "mac":
+            self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
+            mac_toolchain_dir = generator_flags.get("mac_toolchain_dir", None)
+            if mac_toolchain_dir:
+                self.xcode_settings.mac_toolchain_dir = mac_toolchain_dir
+
+        if self.flavor == "win":
+            self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec, generator_flags)
+            arch = self.msvs_settings.GetArch(config_name)
+            self.ninja.variable("arch", self.win_env[arch])
+            self.ninja.variable("cc", "$cl_" + arch)
+            self.ninja.variable("cxx", "$cl_" + arch)
+            self.ninja.variable("cc_host", "$cl_" + arch)
+            self.ninja.variable("cxx_host", "$cl_" + arch)
+            self.ninja.variable("asm", "$ml_" + arch)
+
+        if self.flavor == "mac":
+            self.archs = self.xcode_settings.GetActiveArchs(config_name)
+            if len(self.archs) > 1:
+                self.arch_subninjas = dict(
+                    (
+                        arch,
+                        ninja_syntax.Writer(
+                            OpenOutput(
+                                os.path.join(
+                                    self.toplevel_build, self._SubninjaNameForArch(arch)
+                                ),
+                                "w",
+                            )
+                        ),
+                    )
+                    for arch in self.archs
+                )
+
+        # Compute predepends for all rules.
+        # actions_depends is the dependencies this target depends on before running
+        # any of its action/rule/copy steps.
+        # compile_depends is the dependencies this target depends on before running
+        # any of its compile steps.
+        actions_depends = []
+        compile_depends = []
+        # TODO(evan): it is rather confusing which things are lists and which
+        # are strings.  Fix these.
+        if "dependencies" in spec:
+            for dep in spec["dependencies"]:
+                if dep in self.target_outputs:
+                    target = self.target_outputs[dep]
+                    actions_depends.append(target.PreActionInput(self.flavor))
+                    compile_depends.append(target.PreCompileInput())
+                    if target.uses_cpp:
+                        self.target.uses_cpp = True
+            actions_depends = [item for item in actions_depends if item]
+            compile_depends = [item for item in compile_depends if item]
+            actions_depends = self.WriteCollapsedDependencies(
+                "actions_depends", actions_depends
+            )
+            compile_depends = self.WriteCollapsedDependencies(
+                "compile_depends", compile_depends
+            )
+            self.target.preaction_stamp = actions_depends
+            self.target.precompile_stamp = compile_depends
+
+        # Write out actions, rules, and copies.  These must happen before we
+        # compile any sources, so compute a list of predependencies for sources
+        # while we do it.
+        extra_sources = []
+        mac_bundle_depends = []
+        self.target.actions_stamp = self.WriteActionsRulesCopies(
+            spec, extra_sources, actions_depends, mac_bundle_depends
+        )
+
+        # If we have actions/rules/copies, we depend directly on those, but
+        # otherwise we depend on dependent target's actions/rules/copies etc.
+        # We never need to explicitly depend on previous target's link steps,
+        # because no compile ever depends on them.
+        compile_depends_stamp = self.target.actions_stamp or compile_depends
+
+        # Write out the compilation steps, if any.
+        link_deps = []
+        try:
+            sources = extra_sources + spec.get("sources", [])
+        except TypeError:
+            print("extra_sources: ", str(extra_sources))
+            print('spec.get("sources"): ', str(spec.get("sources")))
+            raise
+        if sources:
+            if self.flavor == "mac" and len(self.archs) > 1:
+                # Write subninja file containing compile and link commands scoped to
+                # a single arch if a fat binary is being built.
+                for arch in self.archs:
+                    self.ninja.subninja(self._SubninjaNameForArch(arch))
+
+            pch = None
+            if self.flavor == "win":
+                gyp.msvs_emulation.VerifyMissingSources(
+                    sources, self.abs_build_dir, generator_flags, self.GypPathToNinja
+                )
+                pch = gyp.msvs_emulation.PrecompiledHeader(
+                    self.msvs_settings,
+                    config_name,
+                    self.GypPathToNinja,
+                    self.GypPathToUniqueOutput,
+                    self.obj_ext,
+                )
+            else:
+                pch = gyp.xcode_emulation.MacPrefixHeader(
+                    self.xcode_settings,
+                    self.GypPathToNinja,
+                    lambda path, lang: self.GypPathToUniqueOutput(path + "-" + lang),
+                )
+            link_deps = self.WriteSources(
+                self.ninja,
+                config_name,
+                config,
+                sources,
+                compile_depends_stamp,
+                pch,
+                spec,
+            )
+            # Some actions/rules output 'sources' that are already object files.
+            obj_outputs = [f for f in sources if f.endswith(self.obj_ext)]
+            if obj_outputs:
+                if self.flavor != "mac" or len(self.archs) == 1:
+                    link_deps += [self.GypPathToNinja(o) for o in obj_outputs]
+                else:
+                    print(
+                        "Warning: Actions/rules writing object files don't work with "
+                        "multiarch targets, dropping. (target %s)" % spec["target_name"]
+                    )
+        elif self.flavor == "mac" and len(self.archs) > 1:
+            link_deps = collections.defaultdict(list)
+
+        compile_deps = self.target.actions_stamp or actions_depends
+        if self.flavor == "win" and self.target.type == "static_library":
+            self.target.component_objs = link_deps
+            self.target.compile_deps = compile_deps
+
+        # Write out a link step, if needed.
+        output = None
+        is_empty_bundle = not link_deps and not mac_bundle_depends
+        if link_deps or self.target.actions_stamp or actions_depends:
+            output = self.WriteTarget(
+                spec, config_name, config, link_deps, compile_deps
+            )
+            if self.is_mac_bundle:
+                mac_bundle_depends.append(output)
+
+        # Bundle all of the above together, if needed.
+        if self.is_mac_bundle:
+            output = self.WriteMacBundle(spec, mac_bundle_depends, is_empty_bundle)
 
-    if 'sources' in spec and self.flavor == 'win':
-      outputs += self.WriteWinIdlFiles(spec, prebuild)
+        if not output:
+            return None
 
-    if self.xcode_settings and self.xcode_settings.IsIosFramework():
-      self.WriteiOSFrameworkHeaders(spec, outputs, prebuild)
+        assert self.target.FinalOutput(), output
+        return self.target
 
-    stamp = self.WriteCollapsedDependencies('actions_rules_copies', outputs)
+    def _WinIdlRule(self, source, prebuild, outputs):
+        """Handle the implicit VS .idl rule for one source file. Fills |outputs|
+    with files that are generated."""
+        outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(
+            source, self.config_name
+        )
+        outdir = self.GypPathToNinja(outdir)
+
+        def fix_path(path, rel=None):
+            path = os.path.join(outdir, path)
+            dirname, basename = os.path.split(source)
+            root, ext = os.path.splitext(basename)
+            path = self.ExpandRuleVariables(path, root, dirname, source, ext, basename)
+            if rel:
+                path = os.path.relpath(path, rel)
+            return path
+
+        vars = [(name, fix_path(value, outdir)) for name, value in vars]
+        output = [fix_path(p) for p in output]
+        vars.append(("outdir", outdir))
+        vars.append(("idlflags", flags))
+        input = self.GypPathToNinja(source)
+        self.ninja.build(output, "idl", input, variables=vars, order_only=prebuild)
+        outputs.extend(output)
+
+    def WriteWinIdlFiles(self, spec, prebuild):
+        """Writes rules to match MSVS's implicit idl handling."""
+        assert self.flavor == "win"
+        if self.msvs_settings.HasExplicitIdlRulesOrActions(spec):
+            return []
+        outputs = []
+        for source in filter(lambda x: x.endswith(".idl"), spec["sources"]):
+            self._WinIdlRule(source, prebuild, outputs)
+        return outputs
+
+    def WriteActionsRulesCopies(
+        self, spec, extra_sources, prebuild, mac_bundle_depends
+    ):
+        """Write out the Actions, Rules, and Copies steps.  Return a path
+    representing the outputs of these steps."""
+        outputs = []
+        if self.is_mac_bundle:
+            mac_bundle_resources = spec.get("mac_bundle_resources", [])[:]
+        else:
+            mac_bundle_resources = []
+        extra_mac_bundle_resources = []
+
+        if "actions" in spec:
+            outputs += self.WriteActions(
+                spec["actions"], extra_sources, prebuild, extra_mac_bundle_resources
+            )
+        if "rules" in spec:
+            outputs += self.WriteRules(
+                spec["rules"],
+                extra_sources,
+                prebuild,
+                mac_bundle_resources,
+                extra_mac_bundle_resources,
+            )
+        if "copies" in spec:
+            outputs += self.WriteCopies(spec["copies"], prebuild, mac_bundle_depends)
+
+        if "sources" in spec and self.flavor == "win":
+            outputs += self.WriteWinIdlFiles(spec, prebuild)
+
+        if self.xcode_settings and self.xcode_settings.IsIosFramework():
+            self.WriteiOSFrameworkHeaders(spec, outputs, prebuild)
+
+        stamp = self.WriteCollapsedDependencies("actions_rules_copies", outputs)
 
-    if self.is_mac_bundle:
-      xcassets = self.WriteMacBundleResources(
-          extra_mac_bundle_resources + mac_bundle_resources, mac_bundle_depends)
-      partial_info_plist = self.WriteMacXCassets(xcassets, mac_bundle_depends)
-      self.WriteMacInfoPlist(partial_info_plist, mac_bundle_depends)
+        if self.is_mac_bundle:
+            xcassets = self.WriteMacBundleResources(
+                extra_mac_bundle_resources + mac_bundle_resources, mac_bundle_depends
+            )
+            partial_info_plist = self.WriteMacXCassets(xcassets, mac_bundle_depends)
+            self.WriteMacInfoPlist(partial_info_plist, mac_bundle_depends)
 
-    return stamp
+        return stamp
 
-  def GenerateDescription(self, verb, message, fallback):
-    """Generate and return a description of a build step.
+    def GenerateDescription(self, verb, message, fallback):
+        """Generate and return a description of a build step.
 
     |verb| is the short summary, e.g. ACTION or RULE.
     |message| is a hand-written description, or None if not available.
     |fallback| is the gyp-level name of the step, usable as a fallback.
     """
-    if self.toolset != 'target':
-      verb += '(%s)' % self.toolset
-    if message:
-      return '%s %s' % (verb, self.ExpandSpecial(message))
-    else:
-      return '%s %s: %s' % (verb, self.name, fallback)
-
-  def WriteActions(self, actions, extra_sources, prebuild,
-                   extra_mac_bundle_resources):
-    # Actions cd into the base directory.
-    env = self.GetToolchainEnv()
-    all_outputs = []
-    for action in actions:
-      # First write out a rule for the action.
-      name = '%s_%s' % (action['action_name'], self.hash_for_rules)
-      description = self.GenerateDescription('ACTION',
-                                             action.get('message', None),
-                                             name)
-      is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(action)
-                   if self.flavor == 'win' else False)
-      args = action['action']
-      depfile = action.get('depfile', None)
-      if depfile:
-        depfile = self.ExpandSpecial(depfile, self.base_to_build)
-      pool = 'console' if int(action.get('ninja_use_console', 0)) else None
-      rule_name, _ = self.WriteNewNinjaRule(name, args, description,
-                                            is_cygwin, env, pool,
-                                            depfile=depfile)
-
-      inputs = [self.GypPathToNinja(i, env) for i in action['inputs']]
-      if int(action.get('process_outputs_as_sources', False)):
-        extra_sources += action['outputs']
-      if int(action.get('process_outputs_as_mac_bundle_resources', False)):
-        extra_mac_bundle_resources += action['outputs']
-      outputs = [self.GypPathToNinja(o, env) for o in action['outputs']]
-
-      # Then write out an edge using the rule.
-      self.ninja.build(outputs, rule_name, inputs,
-                       order_only=prebuild)
-      all_outputs += outputs
-
-      self.ninja.newline()
-
-    return all_outputs
-
-  def WriteRules(self, rules, extra_sources, prebuild,
-                 mac_bundle_resources, extra_mac_bundle_resources):
-    env = self.GetToolchainEnv()
-    all_outputs = []
-    for rule in rules:
-      # Skip a rule with no action and no inputs.
-      if 'action' not in rule and not rule.get('rule_sources', []):
-        continue
-
-      # First write out a rule for the rule action.
-      name = '%s_%s' % (rule['rule_name'], self.hash_for_rules)
-
-      args = rule['action']
-      description = self.GenerateDescription(
-          'RULE',
-          rule.get('message', None),
-          ('%s ' + generator_default_variables['RULE_INPUT_PATH']) % name)
-      is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(rule)
-                   if self.flavor == 'win' else False)
-      pool = 'console' if int(rule.get('ninja_use_console', 0)) else None
-      rule_name, args = self.WriteNewNinjaRule(
-          name, args, description, is_cygwin, env, pool)
-
-      # TODO: if the command references the outputs directly, we should
-      # simplify it to just use $out.
-
-      # Rules can potentially make use of some special variables which
-      # must vary per source file.
-      # Compute the list of variables we'll need to provide.
-      special_locals = ('source', 'root', 'dirname', 'ext', 'name')
-      needed_variables = set(['source'])
-      for argument in args:
-        for var in special_locals:
-          if '${%s}' % var in argument:
-            needed_variables.add(var)
-      needed_variables = sorted(needed_variables)
-
-      def cygwin_munge(path):
-        # pylint: disable=cell-var-from-loop
-        if is_cygwin:
-          return path.replace('\\', '/')
-        return path
-
-      inputs = [self.GypPathToNinja(i, env) for i in rule.get('inputs', [])]
-
-      # If there are n source files matching the rule, and m additional rule
-      # inputs, then adding 'inputs' to each build edge written below will
-      # write m * n inputs. Collapsing reduces this to m + n.
-      sources = rule.get('rule_sources', [])
-      num_inputs = len(inputs)
-      if prebuild:
-        num_inputs += 1
-      if num_inputs > 2 and len(sources) > 2:
-        inputs = [self.WriteCollapsedDependencies(
-          rule['rule_name'], inputs, order_only=prebuild)]
-        prebuild = []
-
-      # For each source file, write an edge that generates all the outputs.
-      for source in sources:
-        source = os.path.normpath(source)
-        dirname, basename = os.path.split(source)
-        root, ext = os.path.splitext(basename)
-
-        # Gather the list of inputs and outputs, expanding $vars if possible.
-        outputs = [self.ExpandRuleVariables(o, root, dirname,
-                                            source, ext, basename)
-                   for o in rule['outputs']]
-
-        if int(rule.get('process_outputs_as_sources', False)):
-          extra_sources += outputs
-
-        was_mac_bundle_resource = source in mac_bundle_resources
-        if was_mac_bundle_resource or \
-            int(rule.get('process_outputs_as_mac_bundle_resources', False)):
-          extra_mac_bundle_resources += outputs
-          # Note: This is n_resources * n_outputs_in_rule.  Put to-be-removed
-          # items in a set and remove them all in a single pass if this becomes
-          # a performance issue.
-          if was_mac_bundle_resource:
-            mac_bundle_resources.remove(source)
-
-        extra_bindings = []
-        for var in needed_variables:
-          if var == 'root':
-            extra_bindings.append(('root', cygwin_munge(root)))
-          elif var == 'dirname':
-            # '$dirname' is a parameter to the rule action, which means
-            # it shouldn't be converted to a Ninja path.  But we don't
-            # want $!PRODUCT_DIR in there either.
-            dirname_expanded = self.ExpandSpecial(dirname, self.base_to_build)
-            extra_bindings.append(('dirname', cygwin_munge(dirname_expanded)))
-          elif var == 'source':
-            # '$source' is a parameter to the rule action, which means
-            # it shouldn't be converted to a Ninja path.  But we don't
-            # want $!PRODUCT_DIR in there either.
-            source_expanded = self.ExpandSpecial(source, self.base_to_build)
-            extra_bindings.append(('source', cygwin_munge(source_expanded)))
-          elif var == 'ext':
-            extra_bindings.append(('ext', ext))
-          elif var == 'name':
-            extra_bindings.append(('name', cygwin_munge(basename)))
-          else:
-            assert var is None, repr(var)
-
-        outputs = [self.GypPathToNinja(o, env) for o in outputs]
-        if self.flavor == 'win':
-          # WriteNewNinjaRule uses unique_name for creating an rsp file on win.
-          extra_bindings.append(('unique_name',
-              hashlib.md5(outputs[0]).hexdigest()))
-
-        self.ninja.build(outputs, rule_name, self.GypPathToNinja(source),
-                         implicit=inputs,
-                         order_only=prebuild,
-                         variables=extra_bindings)
-
-        all_outputs.extend(outputs)
-
-    return all_outputs
-
-  def WriteCopies(self, copies, prebuild, mac_bundle_depends):
-    outputs = []
-    if self.xcode_settings:
-      extra_env = self.xcode_settings.GetPerTargetSettings()
-      env = self.GetToolchainEnv(additional_settings=extra_env)
-    else:
-      env = self.GetToolchainEnv()
-    for copy in copies:
-      for path in copy['files']:
-        # Normalize the path so trailing slashes don't confuse us.
-        path = os.path.normpath(path)
-        basename = os.path.split(path)[1]
-        src = self.GypPathToNinja(path, env)
-        dst = self.GypPathToNinja(os.path.join(copy['destination'], basename),
-                                  env)
-        outputs += self.ninja.build(dst, 'copy', src, order_only=prebuild)
-        if self.is_mac_bundle:
-          # gyp has mac_bundle_resources to copy things into a bundle's
-          # Resources folder, but there's no built-in way to copy files to other
-          # places in the bundle. Hence, some targets use copies for this. Check
-          # if this file is copied into the current bundle, and if so add it to
-          # the bundle depends so that dependent targets get rebuilt if the copy
-          # input changes.
-          if dst.startswith(self.xcode_settings.GetBundleContentsFolderPath()):
-            mac_bundle_depends.append(dst)
-
-    return outputs
-
-  def WriteiOSFrameworkHeaders(self, spec, outputs, prebuild):
-    """Prebuild steps to generate hmap files and copy headers to destination."""
-    framework = self.ComputeMacBundleOutput()
-    all_sources = spec['sources']
-    copy_headers = spec['mac_framework_headers']
-    output = self.GypPathToUniqueOutput('headers.hmap')
-    self.xcode_settings.header_map_path = output
-    all_headers = map(self.GypPathToNinja,
-                      filter(lambda x:x.endswith(('.h')), all_sources))
-    variables = [('framework', framework),
-                 ('copy_headers', map(self.GypPathToNinja, copy_headers))]
-    outputs.extend(self.ninja.build(
-        output, 'compile_ios_framework_headers', all_headers,
-        variables=variables, order_only=prebuild))
-
-  def WriteMacBundleResources(self, resources, bundle_depends):
-    """Writes ninja edges for 'mac_bundle_resources'."""
-    xcassets = []
-
-    extra_env = self.xcode_settings.GetPerTargetSettings()
-    env = self.GetSortedXcodeEnv(additional_settings=extra_env)
-    env = self.ComputeExportEnvString(env)
-    isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
-
-    for output, res in gyp.xcode_emulation.GetMacBundleResources(
-        generator_default_variables['PRODUCT_DIR'],
-        self.xcode_settings, map(self.GypPathToNinja, resources)):
-      output = self.ExpandSpecial(output)
-      if os.path.splitext(output)[-1] != '.xcassets':
-        self.ninja.build(output, 'mac_tool', res,
-                         variables=[('mactool_cmd', 'copy-bundle-resource'), \
-                                    ('env', env), ('binary', isBinary)])
-        bundle_depends.append(output)
-      else:
-        xcassets.append(res)
-    return xcassets
-
-  def WriteMacXCassets(self, xcassets, bundle_depends):
-    """Writes ninja edges for 'mac_bundle_resources' .xcassets files.
+        if self.toolset != "target":
+            verb += "(%s)" % self.toolset
+        if message:
+            return "%s %s" % (verb, self.ExpandSpecial(message))
+        else:
+            return "%s %s: %s" % (verb, self.name, fallback)
+
+    def WriteActions(
+        self, actions, extra_sources, prebuild, extra_mac_bundle_resources
+    ):
+        # Actions cd into the base directory.
+        env = self.GetToolchainEnv()
+        all_outputs = []
+        for action in actions:
+            # First write out a rule for the action.
+            name = "%s_%s" % (action["action_name"], self.hash_for_rules)
+            description = self.GenerateDescription(
+                "ACTION", action.get("message", None), name
+            )
+            is_cygwin = (
+                self.msvs_settings.IsRuleRunUnderCygwin(action)
+                if self.flavor == "win"
+                else False
+            )
+            args = action["action"]
+            depfile = action.get("depfile", None)
+            if depfile:
+                depfile = self.ExpandSpecial(depfile, self.base_to_build)
+            pool = "console" if int(action.get("ninja_use_console", 0)) else None
+            rule_name, _ = self.WriteNewNinjaRule(
+                name, args, description, is_cygwin, env, pool, depfile=depfile
+            )
+
+            inputs = [self.GypPathToNinja(i, env) for i in action["inputs"]]
+            if int(action.get("process_outputs_as_sources", False)):
+                extra_sources += action["outputs"]
+            if int(action.get("process_outputs_as_mac_bundle_resources", False)):
+                extra_mac_bundle_resources += action["outputs"]
+            outputs = [self.GypPathToNinja(o, env) for o in action["outputs"]]
+
+            # Then write out an edge using the rule.
+            self.ninja.build(outputs, rule_name, inputs, order_only=prebuild)
+            all_outputs += outputs
+
+            self.ninja.newline()
+
+        return all_outputs
+
+    def WriteRules(
+        self,
+        rules,
+        extra_sources,
+        prebuild,
+        mac_bundle_resources,
+        extra_mac_bundle_resources,
+    ):
+        env = self.GetToolchainEnv()
+        all_outputs = []
+        for rule in rules:
+            # Skip a rule with no action and no inputs.
+            if "action" not in rule and not rule.get("rule_sources", []):
+                continue
+
+            # First write out a rule for the rule action.
+            name = "%s_%s" % (rule["rule_name"], self.hash_for_rules)
+
+            args = rule["action"]
+            description = self.GenerateDescription(
+                "RULE",
+                rule.get("message", None),
+                ("%s " + generator_default_variables["RULE_INPUT_PATH"]) % name,
+            )
+            is_cygwin = (
+                self.msvs_settings.IsRuleRunUnderCygwin(rule)
+                if self.flavor == "win"
+                else False
+            )
+            pool = "console" if int(rule.get("ninja_use_console", 0)) else None
+            rule_name, args = self.WriteNewNinjaRule(
+                name, args, description, is_cygwin, env, pool
+            )
+
+            # TODO: if the command references the outputs directly, we should
+            # simplify it to just use $out.
+
+            # Rules can potentially make use of some special variables which
+            # must vary per source file.
+            # Compute the list of variables we'll need to provide.
+            special_locals = ("source", "root", "dirname", "ext", "name")
+            needed_variables = set(["source"])
+            for argument in args:
+                for var in special_locals:
+                    if "${%s}" % var in argument:
+                        needed_variables.add(var)
+            needed_variables = sorted(needed_variables)
+
+            def cygwin_munge(path):
+                # pylint: disable=cell-var-from-loop
+                if is_cygwin:
+                    return path.replace("\\", "/")
+                return path
+
+            inputs = [self.GypPathToNinja(i, env) for i in rule.get("inputs", [])]
+
+            # If there are n source files matching the rule, and m additional rule
+            # inputs, then adding 'inputs' to each build edge written below will
+            # write m * n inputs. Collapsing reduces this to m + n.
+            sources = rule.get("rule_sources", [])
+            num_inputs = len(inputs)
+            if prebuild:
+                num_inputs += 1
+            if num_inputs > 2 and len(sources) > 2:
+                inputs = [
+                    self.WriteCollapsedDependencies(
+                        rule["rule_name"], inputs, order_only=prebuild
+                    )
+                ]
+                prebuild = []
+
+            # For each source file, write an edge that generates all the outputs.
+            for source in sources:
+                source = os.path.normpath(source)
+                dirname, basename = os.path.split(source)
+                root, ext = os.path.splitext(basename)
+
+                # Gather the list of inputs and outputs, expanding $vars if possible.
+                outputs = [
+                    self.ExpandRuleVariables(o, root, dirname, source, ext, basename)
+                    for o in rule["outputs"]
+                ]
+
+                if int(rule.get("process_outputs_as_sources", False)):
+                    extra_sources += outputs
+
+                was_mac_bundle_resource = source in mac_bundle_resources
+                if was_mac_bundle_resource or int(
+                    rule.get("process_outputs_as_mac_bundle_resources", False)
+                ):
+                    extra_mac_bundle_resources += outputs
+                    # Note: This is n_resources * n_outputs_in_rule.
+                    # Put to-be-removed items in a set and
+                    # remove them all in a single pass
+                    # if this becomes a performance issue.
+                    if was_mac_bundle_resource:
+                        mac_bundle_resources.remove(source)
+
+                extra_bindings = []
+                for var in needed_variables:
+                    if var == "root":
+                        extra_bindings.append(("root", cygwin_munge(root)))
+                    elif var == "dirname":
+                        # '$dirname' is a parameter to the rule action, which means
+                        # it shouldn't be converted to a Ninja path.  But we don't
+                        # want $!PRODUCT_DIR in there either.
+                        dirname_expanded = self.ExpandSpecial(
+                            dirname, self.base_to_build
+                        )
+                        extra_bindings.append(
+                            ("dirname", cygwin_munge(dirname_expanded))
+                        )
+                    elif var == "source":
+                        # '$source' is a parameter to the rule action, which means
+                        # it shouldn't be converted to a Ninja path.  But we don't
+                        # want $!PRODUCT_DIR in there either.
+                        source_expanded = self.ExpandSpecial(source, self.base_to_build)
+                        extra_bindings.append(("source", cygwin_munge(source_expanded)))
+                    elif var == "ext":
+                        extra_bindings.append(("ext", ext))
+                    elif var == "name":
+                        extra_bindings.append(("name", cygwin_munge(basename)))
+                    else:
+                        assert var is None, repr(var)
+
+                outputs = [self.GypPathToNinja(o, env) for o in outputs]
+                if self.flavor == "win":
+                    # WriteNewNinjaRule uses unique_name to create a rsp file on win.
+                    extra_bindings.append(
+                        ("unique_name", hashlib.md5(outputs[0]).hexdigest())
+                    )
+
+                self.ninja.build(
+                    outputs,
+                    rule_name,
+                    self.GypPathToNinja(source),
+                    implicit=inputs,
+                    order_only=prebuild,
+                    variables=extra_bindings,
+                )
+
+                all_outputs.extend(outputs)
+
+        return all_outputs
+
+    def WriteCopies(self, copies, prebuild, mac_bundle_depends):
+        outputs = []
+        if self.xcode_settings:
+            extra_env = self.xcode_settings.GetPerTargetSettings()
+            env = self.GetToolchainEnv(additional_settings=extra_env)
+        else:
+            env = self.GetToolchainEnv()
+        for to_copy in copies:
+            for path in to_copy["files"]:
+                # Normalize the path so trailing slashes don't confuse us.
+                path = os.path.normpath(path)
+                basename = os.path.split(path)[1]
+                src = self.GypPathToNinja(path, env)
+                dst = self.GypPathToNinja(
+                    os.path.join(to_copy["destination"], basename), env
+                )
+                outputs += self.ninja.build(dst, "copy", src, order_only=prebuild)
+                if self.is_mac_bundle:
+                    # gyp has mac_bundle_resources to copy things into a bundle's
+                    # Resources folder, but there's no built-in way to copy files
+                    # to other places in the bundle.
+                    # Hence, some targets use copies for this.
+                    # Check if this file is copied into the current bundle,
+                    # and if so add it to the bundle depends so
+                    # that dependent targets get rebuilt if the copy input changes.
+                    if dst.startswith(
+                        self.xcode_settings.GetBundleContentsFolderPath()
+                    ):
+                        mac_bundle_depends.append(dst)
+
+        return outputs
+
+    def WriteiOSFrameworkHeaders(self, spec, outputs, prebuild):
+        """Prebuild steps to generate hmap files and copy headers to destination."""
+        framework = self.ComputeMacBundleOutput()
+        all_sources = spec["sources"]
+        copy_headers = spec["mac_framework_headers"]
+        output = self.GypPathToUniqueOutput("headers.hmap")
+        self.xcode_settings.header_map_path = output
+        all_headers = map(
+            self.GypPathToNinja, filter(lambda x: x.endswith((".h")), all_sources)
+        )
+        variables = [
+            ("framework", framework),
+            ("copy_headers", map(self.GypPathToNinja, copy_headers)),
+        ]
+        outputs.extend(
+            self.ninja.build(
+                output,
+                "compile_ios_framework_headers",
+                all_headers,
+                variables=variables,
+                order_only=prebuild,
+            )
+        )
+
+    def WriteMacBundleResources(self, resources, bundle_depends):
+        """Writes ninja edges for 'mac_bundle_resources'."""
+        xcassets = []
+
+        extra_env = self.xcode_settings.GetPerTargetSettings()
+        env = self.GetSortedXcodeEnv(additional_settings=extra_env)
+        env = self.ComputeExportEnvString(env)
+        isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
+
+        for output, res in gyp.xcode_emulation.GetMacBundleResources(
+            generator_default_variables["PRODUCT_DIR"],
+            self.xcode_settings,
+            map(self.GypPathToNinja, resources),
+        ):
+            output = self.ExpandSpecial(output)
+            if os.path.splitext(output)[-1] != ".xcassets":
+                self.ninja.build(
+                    output,
+                    "mac_tool",
+                    res,
+                    variables=[
+                        ("mactool_cmd", "copy-bundle-resource"),
+                        ("env", env),
+                        ("binary", isBinary),
+                    ],
+                )
+                bundle_depends.append(output)
+            else:
+                xcassets.append(res)
+        return xcassets
+
+    def WriteMacXCassets(self, xcassets, bundle_depends):
+        """Writes ninja edges for 'mac_bundle_resources' .xcassets files.
 
     This add an invocation of 'actool' via the 'mac_tool.py' helper script.
     It assumes that the assets catalogs define at least one imageset and
     thus an Assets.car file will be generated in the application resources
     directory. If this is not the case, then the build will probably be done
     at each invocation of ninja."""
-    if not xcassets:
-      return
-
-    extra_arguments = {}
-    settings_to_arg = {
-        'XCASSETS_APP_ICON': 'app-icon',
-        'XCASSETS_LAUNCH_IMAGE': 'launch-image',
-    }
-    settings = self.xcode_settings.xcode_settings[self.config_name]
-    for settings_key, arg_name in settings_to_arg.items():
-      value = settings.get(settings_key)
-      if value:
-        extra_arguments[arg_name] = value
-
-    partial_info_plist = None
-    if extra_arguments:
-      partial_info_plist = self.GypPathToUniqueOutput(
-          'assetcatalog_generated_info.plist')
-      extra_arguments['output-partial-info-plist'] = partial_info_plist
-
-    outputs = []
-    outputs.append(
-        os.path.join(
-            self.xcode_settings.GetBundleResourceFolder(),
-            'Assets.car'))
-    if partial_info_plist:
-      outputs.append(partial_info_plist)
-
-    keys = QuoteShellArgument(json.dumps(extra_arguments), self.flavor)
-    extra_env = self.xcode_settings.GetPerTargetSettings()
-    env = self.GetSortedXcodeEnv(additional_settings=extra_env)
-    env = self.ComputeExportEnvString(env)
-
-    bundle_depends.extend(self.ninja.build(
-        outputs, 'compile_xcassets', xcassets,
-        variables=[('env', env), ('keys', keys)]))
-    return partial_info_plist
-
-  def WriteMacInfoPlist(self, partial_info_plist, bundle_depends):
-    """Write build rules for bundle Info.plist files."""
-    info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(
-        generator_default_variables['PRODUCT_DIR'],
-        self.xcode_settings, self.GypPathToNinja)
-    if not info_plist:
-      return
-    out = self.ExpandSpecial(out)
-    if defines:
-      # Create an intermediate file to store preprocessed results.
-      intermediate_plist = self.GypPathToUniqueOutput(
-          os.path.basename(info_plist))
-      defines = ' '.join([Define(d, self.flavor) for d in defines])
-      info_plist = self.ninja.build(
-          intermediate_plist, 'preprocess_infoplist', info_plist,
-          variables=[('defines',defines)])
-
-    env = self.GetSortedXcodeEnv(additional_settings=extra_env)
-    env = self.ComputeExportEnvString(env)
-
-    if partial_info_plist:
-      intermediate_plist = self.GypPathToUniqueOutput('merged_info.plist')
-      info_plist = self.ninja.build(
-          intermediate_plist, 'merge_infoplist',
-          [partial_info_plist, info_plist])
-
-    keys = self.xcode_settings.GetExtraPlistItems(self.config_name)
-    keys = QuoteShellArgument(json.dumps(keys), self.flavor)
-    isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
-    self.ninja.build(out, 'copy_infoplist', info_plist,
-                     variables=[('env', env), ('keys', keys),
-                                ('binary', isBinary)])
-    bundle_depends.append(out)
-
-  def WriteSources(self, ninja_file, config_name, config, sources, predepends,
-                   precompiled_header, spec):
-    """Write build rules to compile all of |sources|."""
-    if self.toolset == 'host':
-      self.ninja.variable('ar', '$ar_host')
-      self.ninja.variable('cc', '$cc_host')
-      self.ninja.variable('cxx', '$cxx_host')
-      self.ninja.variable('ld', '$ld_host')
-      self.ninja.variable('ldxx', '$ldxx_host')
-      self.ninja.variable('nm', '$nm_host')
-      self.ninja.variable('readelf', '$readelf_host')
-
-    if self.flavor != 'mac' or len(self.archs) == 1:
-      return self.WriteSourcesForArch(
-          self.ninja, config_name, config, sources, predepends,
-          precompiled_header, spec)
-    else:
-      return dict((arch, self.WriteSourcesForArch(
-            self.arch_subninjas[arch], config_name, config, sources, predepends,
-            precompiled_header, spec, arch=arch))
-          for arch in self.archs)
-
-  def WriteSourcesForArch(self, ninja_file, config_name, config, sources,
-                          predepends, precompiled_header, spec, arch=None):
-    """Write build rules to compile all of |sources|."""
-
-    extra_defines = []
-    if self.flavor == 'mac':
-      cflags = self.xcode_settings.GetCflags(config_name, arch=arch)
-      cflags_c = self.xcode_settings.GetCflagsC(config_name)
-      cflags_cc = self.xcode_settings.GetCflagsCC(config_name)
-      cflags_objc = ['$cflags_c'] + \
-                    self.xcode_settings.GetCflagsObjC(config_name)
-      cflags_objcc = ['$cflags_cc'] + \
-                     self.xcode_settings.GetCflagsObjCC(config_name)
-    elif self.flavor == 'win':
-      asmflags = self.msvs_settings.GetAsmflags(config_name)
-      cflags = self.msvs_settings.GetCflags(config_name)
-      cflags_c = self.msvs_settings.GetCflagsC(config_name)
-      cflags_cc = self.msvs_settings.GetCflagsCC(config_name)
-      extra_defines = self.msvs_settings.GetComputedDefines(config_name)
-      # See comment at cc_command for why there's two .pdb files.
-      pdbpath_c = pdbpath_cc = self.msvs_settings.GetCompilerPdbName(
-          config_name, self.ExpandSpecial)
-      if not pdbpath_c:
-        obj = 'obj'
-        if self.toolset != 'target':
-          obj += '.' + self.toolset
-        pdbpath = os.path.normpath(os.path.join(obj, self.base_dir, self.name))
-        pdbpath_c = pdbpath + '.c.pdb'
-        pdbpath_cc = pdbpath + '.cc.pdb'
-      self.WriteVariableList(ninja_file, 'pdbname_c', [pdbpath_c])
-      self.WriteVariableList(ninja_file, 'pdbname_cc', [pdbpath_cc])
-      self.WriteVariableList(ninja_file, 'pchprefix', [self.name])
-    else:
-      cflags = config.get('cflags', [])
-      cflags_c = config.get('cflags_c', [])
-      cflags_cc = config.get('cflags_cc', [])
-
-    # Respect environment variables related to build, but target-specific
-    # flags can still override them.
-    if self.toolset == 'target':
-      cflags_c = (os.environ.get('CPPFLAGS', '').split() +
-                  os.environ.get('CFLAGS', '').split() + cflags_c)
-      cflags_cc = (os.environ.get('CPPFLAGS', '').split() +
-                   os.environ.get('CXXFLAGS', '').split() + cflags_cc)
-    elif self.toolset == 'host':
-      cflags_c = (os.environ.get('CPPFLAGS_host', '').split() +
-                  os.environ.get('CFLAGS_host', '').split() + cflags_c)
-      cflags_cc = (os.environ.get('CPPFLAGS_host', '').split() +
-                   os.environ.get('CXXFLAGS_host', '').split() + cflags_cc)
-
-    defines = config.get('defines', []) + extra_defines
-    self.WriteVariableList(ninja_file, 'defines',
-                           [Define(d, self.flavor) for d in defines])
-    if self.flavor == 'win':
-      self.WriteVariableList(ninja_file, 'asmflags',
-                             map(self.ExpandSpecial, asmflags))
-      self.WriteVariableList(ninja_file, 'rcflags',
-          [QuoteShellArgument(self.ExpandSpecial(f), self.flavor)
-           for f in self.msvs_settings.GetRcflags(config_name,
-                                                  self.GypPathToNinja)])
-
-    include_dirs = config.get('include_dirs', [])
-
-    env = self.GetToolchainEnv()
-    if self.flavor == 'win':
-      include_dirs = self.msvs_settings.AdjustIncludeDirs(include_dirs,
-                                                          config_name)
-    self.WriteVariableList(ninja_file, 'includes',
-        [QuoteShellArgument('-I' + self.GypPathToNinja(i, env), self.flavor)
-         for i in include_dirs])
-
-    if self.flavor == 'win':
-      midl_include_dirs = config.get('midl_include_dirs', [])
-      midl_include_dirs = self.msvs_settings.AdjustMidlIncludeDirs(
-          midl_include_dirs, config_name)
-      self.WriteVariableList(ninja_file, 'midl_includes',
-          [QuoteShellArgument('-I' + self.GypPathToNinja(i, env), self.flavor)
-           for i in midl_include_dirs])
-
-    pch_commands = precompiled_header.GetPchBuildCommands(arch)
-    if self.flavor == 'mac':
-      # Most targets use no precompiled headers, so only write these if needed.
-      for ext, var in [('c', 'cflags_pch_c'), ('cc', 'cflags_pch_cc'),
-                       ('m', 'cflags_pch_objc'), ('mm', 'cflags_pch_objcc')]:
-        include = precompiled_header.GetInclude(ext, arch)
-        if include: ninja_file.variable(var, include)
-
-    arflags = config.get('arflags', [])
-
-    self.WriteVariableList(ninja_file, 'cflags',
-                           map(self.ExpandSpecial, cflags))
-    self.WriteVariableList(ninja_file, 'cflags_c',
-                           map(self.ExpandSpecial, cflags_c))
-    self.WriteVariableList(ninja_file, 'cflags_cc',
-                           map(self.ExpandSpecial, cflags_cc))
-    if self.flavor == 'mac':
-      self.WriteVariableList(ninja_file, 'cflags_objc',
-                             map(self.ExpandSpecial, cflags_objc))
-      self.WriteVariableList(ninja_file, 'cflags_objcc',
-                             map(self.ExpandSpecial, cflags_objcc))
-    self.WriteVariableList(ninja_file, 'arflags',
-                           map(self.ExpandSpecial, arflags))
-    ninja_file.newline()
-    outputs = []
-    has_rc_source = False
-    for source in sources:
-      filename, ext = os.path.splitext(source)
-      ext = ext[1:]
-      obj_ext = self.obj_ext
-      if ext in ('cc', 'cpp', 'cxx'):
-        command = 'cxx'
-        self.target.uses_cpp = True
-      elif ext == 'c' or (ext == 'S' and self.flavor != 'win'):
-        command = 'cc'
-      elif ext == 's' and self.flavor != 'win':  # Doesn't generate .o.d files.
-        command = 'cc_s'
-      elif (self.flavor == 'win' and ext == 'asm' and
-            not self.msvs_settings.HasExplicitAsmRules(spec)):
-        command = 'asm'
-        # Add the _asm suffix as msvs is capable of handling .cc and
-        # .asm files of the same name without collision.
-        obj_ext = '_asm.obj'
-      elif self.flavor == 'mac' and ext == 'm':
-        command = 'objc'
-      elif self.flavor == 'mac' and ext == 'mm':
-        command = 'objcxx'
-        self.target.uses_cpp = True
-      elif self.flavor == 'win' and ext == 'rc':
-        command = 'rc'
-        obj_ext = '.res'
-        has_rc_source = True
-      else:
-        # Ignore unhandled extensions.
-        continue
-      input = self.GypPathToNinja(source)
-      output = self.GypPathToUniqueOutput(filename + obj_ext)
-      if arch is not None:
-        output = AddArch(output, arch)
-      implicit = precompiled_header.GetObjDependencies([input], [output], arch)
-      variables = []
-      if self.flavor == 'win':
-        variables, output, implicit = precompiled_header.GetFlagsModifications(
-            input, output, implicit, command, cflags_c, cflags_cc,
-            self.ExpandSpecial)
-      ninja_file.build(output, command, input,
-                       implicit=[gch for _, _, gch in implicit],
-                       order_only=predepends, variables=variables)
-      outputs.append(output)
-
-    if has_rc_source:
-      resource_include_dirs = config.get('resource_include_dirs', include_dirs)
-      self.WriteVariableList(ninja_file, 'resource_includes',
-          [QuoteShellArgument('-I' + self.GypPathToNinja(i, env), self.flavor)
-           for i in resource_include_dirs])
-
-    self.WritePchTargets(ninja_file, pch_commands)
-
-    ninja_file.newline()
-    return outputs
-
-  def WritePchTargets(self, ninja_file, pch_commands):
-    """Writes ninja rules to compile prefix headers."""
-    if not pch_commands:
-      return
-
-    for gch, lang_flag, lang, input in pch_commands:
-      var_name = {
-        'c': 'cflags_pch_c',
-        'cc': 'cflags_pch_cc',
-        'm': 'cflags_pch_objc',
-        'mm': 'cflags_pch_objcc',
-      }[lang]
-
-      map = { 'c': 'cc', 'cc': 'cxx', 'm': 'objc', 'mm': 'objcxx', }
-      cmd = map.get(lang)
-      ninja_file.build(gch, cmd, input, variables=[(var_name, lang_flag)])
-
-  def WriteLink(self, spec, config_name, config, link_deps, compile_deps):
-    """Write out a link step. Fills out target.binary. """
-    if self.flavor != 'mac' or len(self.archs) == 1:
-      return self.WriteLinkForArch(
-          self.ninja, spec, config_name, config, link_deps, compile_deps)
-    else:
-      output = self.ComputeOutput(spec)
-      inputs = [self.WriteLinkForArch(self.arch_subninjas[arch], spec,
-                                      config_name, config, link_deps[arch],
-                                      compile_deps, arch=arch)
-                for arch in self.archs]
-      extra_bindings = []
-      build_output = output
-      if not self.is_mac_bundle:
-        self.AppendPostbuildVariable(extra_bindings, spec, output, output)
-
-      # TODO(yyanagisawa): more work needed to fix:
-      # https://code.google.com/p/gyp/issues/detail?id=411
-      if (spec['type'] in ('shared_library', 'loadable_module') and
-          not self.is_mac_bundle):
-        extra_bindings.append(('lib', output))
-        self.ninja.build([output, output + '.TOC'], 'solipo', inputs,
-            variables=extra_bindings)
-      else:
-        self.ninja.build(build_output, 'lipo', inputs, variables=extra_bindings)
-      return output
-
-  def WriteLinkForArch(self, ninja_file, spec, config_name, config,
-                       link_deps, compile_deps, arch=None):
-    """Write out a link step. Fills out target.binary. """
-    command = {
-      'executable':      'link',
-      'loadable_module': 'solink_module',
-      'shared_library':  'solink',
-    }[spec['type']]
-    command_suffix = ''
-
-    implicit_deps = set()
-    solibs = set()
-    order_deps = set()
-
-    if compile_deps:
-      # Normally, the compiles of the target already depend on compile_deps,
-      # but a shared_library target might have no sources and only link together
-      # a few static_library deps, so the link step also needs to depend
-      # on compile_deps to make sure actions in the shared_library target
-      # get run before the link.
-      order_deps.add(compile_deps)
-
-    if 'dependencies' in spec:
-      # Two kinds of dependencies:
-      # - Linkable dependencies (like a .a or a .so): add them to the link line.
-      # - Non-linkable dependencies (like a rule that generates a file
-      #   and writes a stamp file): add them to implicit_deps
-      extra_link_deps = set()
-      for dep in spec['dependencies']:
-        target = self.target_outputs.get(dep)
-        if not target:
-          continue
-        linkable = target.Linkable()
-        if linkable:
-          new_deps = []
-          if (self.flavor == 'win' and
-              target.component_objs and
-              self.msvs_settings.IsUseLibraryDependencyInputs(config_name)):
-            new_deps = target.component_objs
-            if target.compile_deps:
-              order_deps.add(target.compile_deps)
-          elif self.flavor == 'win' and target.import_lib:
-            new_deps = [target.import_lib]
-          elif target.UsesToc(self.flavor):
-            solibs.add(target.binary)
-            implicit_deps.add(target.binary + '.TOC')
-          else:
-            new_deps = [target.binary]
-          for new_dep in new_deps:
-            if new_dep not in extra_link_deps:
-              extra_link_deps.add(new_dep)
-              link_deps.append(new_dep)
-
-        final_output = target.FinalOutput()
-        if not linkable or final_output != target.binary:
-          implicit_deps.add(final_output)
-
-    extra_bindings = []
-    if self.target.uses_cpp and self.flavor != 'win':
-      extra_bindings.append(('ld', '$ldxx'))
-
-    output = self.ComputeOutput(spec, arch)
-    if arch is None and not self.is_mac_bundle:
-      self.AppendPostbuildVariable(extra_bindings, spec, output, output)
-
-    is_executable = spec['type'] == 'executable'
-    # The ldflags config key is not used on mac or win. On those platforms
-    # linker flags are set via xcode_settings and msvs_settings, respectively.
-    env_ldflags = os.environ.get('LDFLAGS', '').split()
-    if self.flavor == 'mac':
-      ldflags = self.xcode_settings.GetLdflags(config_name,
-          self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
-          self.GypPathToNinja, arch)
-      ldflags = env_ldflags + ldflags
-    elif self.flavor == 'win':
-      manifest_base_name = self.GypPathToUniqueOutput(
-          self.ComputeOutputFileName(spec))
-      ldflags, intermediate_manifest, manifest_files = \
-          self.msvs_settings.GetLdflags(config_name, self.GypPathToNinja,
-                                        self.ExpandSpecial, manifest_base_name,
-                                        output, is_executable,
-                                        self.toplevel_build)
-      ldflags = env_ldflags + ldflags
-      self.WriteVariableList(ninja_file, 'manifests', manifest_files)
-      implicit_deps = implicit_deps.union(manifest_files)
-      if intermediate_manifest:
+        if not xcassets:
+            return
+
+        extra_arguments = {}
+        settings_to_arg = {
+            "XCASSETS_APP_ICON": "app-icon",
+            "XCASSETS_LAUNCH_IMAGE": "launch-image",
+        }
+        settings = self.xcode_settings.xcode_settings[self.config_name]
+        for settings_key, arg_name in settings_to_arg.items():
+            value = settings.get(settings_key)
+            if value:
+                extra_arguments[arg_name] = value
+
+        partial_info_plist = None
+        if extra_arguments:
+            partial_info_plist = self.GypPathToUniqueOutput(
+                "assetcatalog_generated_info.plist"
+            )
+            extra_arguments["output-partial-info-plist"] = partial_info_plist
+
+        outputs = []
+        outputs.append(
+            os.path.join(self.xcode_settings.GetBundleResourceFolder(), "Assets.car")
+        )
+        if partial_info_plist:
+            outputs.append(partial_info_plist)
+
+        keys = QuoteShellArgument(json.dumps(extra_arguments), self.flavor)
+        extra_env = self.xcode_settings.GetPerTargetSettings()
+        env = self.GetSortedXcodeEnv(additional_settings=extra_env)
+        env = self.ComputeExportEnvString(env)
+
+        bundle_depends.extend(
+            self.ninja.build(
+                outputs,
+                "compile_xcassets",
+                xcassets,
+                variables=[("env", env), ("keys", keys)],
+            )
+        )
+        return partial_info_plist
+
+    def WriteMacInfoPlist(self, partial_info_plist, bundle_depends):
+        """Write build rules for bundle Info.plist files."""
+        info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(
+            generator_default_variables["PRODUCT_DIR"],
+            self.xcode_settings,
+            self.GypPathToNinja,
+        )
+        if not info_plist:
+            return
+        out = self.ExpandSpecial(out)
+        if defines:
+            # Create an intermediate file to store preprocessed results.
+            intermediate_plist = self.GypPathToUniqueOutput(
+                os.path.basename(info_plist)
+            )
+            defines = " ".join([Define(d, self.flavor) for d in defines])
+            info_plist = self.ninja.build(
+                intermediate_plist,
+                "preprocess_infoplist",
+                info_plist,
+                variables=[("defines", defines)],
+            )
+
+        env = self.GetSortedXcodeEnv(additional_settings=extra_env)
+        env = self.ComputeExportEnvString(env)
+
+        if partial_info_plist:
+            intermediate_plist = self.GypPathToUniqueOutput("merged_info.plist")
+            info_plist = self.ninja.build(
+                intermediate_plist, "merge_infoplist", [partial_info_plist, info_plist]
+            )
+
+        keys = self.xcode_settings.GetExtraPlistItems(self.config_name)
+        keys = QuoteShellArgument(json.dumps(keys), self.flavor)
+        isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
+        self.ninja.build(
+            out,
+            "copy_infoplist",
+            info_plist,
+            variables=[("env", env), ("keys", keys), ("binary", isBinary)],
+        )
+        bundle_depends.append(out)
+
+    def WriteSources(
+        self,
+        ninja_file,
+        config_name,
+        config,
+        sources,
+        predepends,
+        precompiled_header,
+        spec,
+    ):
+        """Write build rules to compile all of |sources|."""
+        if self.toolset == "host":
+            self.ninja.variable("ar", "$ar_host")
+            self.ninja.variable("cc", "$cc_host")
+            self.ninja.variable("cxx", "$cxx_host")
+            self.ninja.variable("ld", "$ld_host")
+            self.ninja.variable("ldxx", "$ldxx_host")
+            self.ninja.variable("nm", "$nm_host")
+            self.ninja.variable("readelf", "$readelf_host")
+
+        if self.flavor != "mac" or len(self.archs) == 1:
+            return self.WriteSourcesForArch(
+                self.ninja,
+                config_name,
+                config,
+                sources,
+                predepends,
+                precompiled_header,
+                spec,
+            )
+        else:
+            return dict(
+                (
+                    arch,
+                    self.WriteSourcesForArch(
+                        self.arch_subninjas[arch],
+                        config_name,
+                        config,
+                        sources,
+                        predepends,
+                        precompiled_header,
+                        spec,
+                        arch=arch,
+                    ),
+                )
+                for arch in self.archs
+            )
+
+    def WriteSourcesForArch(
+        self,
+        ninja_file,
+        config_name,
+        config,
+        sources,
+        predepends,
+        precompiled_header,
+        spec,
+        arch=None,
+    ):
+        """Write build rules to compile all of |sources|."""
+
+        extra_defines = []
+        if self.flavor == "mac":
+            cflags = self.xcode_settings.GetCflags(config_name, arch=arch)
+            cflags_c = self.xcode_settings.GetCflagsC(config_name)
+            cflags_cc = self.xcode_settings.GetCflagsCC(config_name)
+            cflags_objc = ["$cflags_c"] + self.xcode_settings.GetCflagsObjC(config_name)
+            cflags_objcc = ["$cflags_cc"] + self.xcode_settings.GetCflagsObjCC(
+                config_name
+            )
+        elif self.flavor == "win":
+            asmflags = self.msvs_settings.GetAsmflags(config_name)
+            cflags = self.msvs_settings.GetCflags(config_name)
+            cflags_c = self.msvs_settings.GetCflagsC(config_name)
+            cflags_cc = self.msvs_settings.GetCflagsCC(config_name)
+            extra_defines = self.msvs_settings.GetComputedDefines(config_name)
+            # See comment at cc_command for why there's two .pdb files.
+            pdbpath_c = pdbpath_cc = self.msvs_settings.GetCompilerPdbName(
+                config_name, self.ExpandSpecial
+            )
+            if not pdbpath_c:
+                obj = "obj"
+                if self.toolset != "target":
+                    obj += "." + self.toolset
+                pdbpath = os.path.normpath(os.path.join(obj, self.base_dir, self.name))
+                pdbpath_c = pdbpath + ".c.pdb"
+                pdbpath_cc = pdbpath + ".cc.pdb"
+            self.WriteVariableList(ninja_file, "pdbname_c", [pdbpath_c])
+            self.WriteVariableList(ninja_file, "pdbname_cc", [pdbpath_cc])
+            self.WriteVariableList(ninja_file, "pchprefix", [self.name])
+        else:
+            cflags = config.get("cflags", [])
+            cflags_c = config.get("cflags_c", [])
+            cflags_cc = config.get("cflags_cc", [])
+
+        # Respect environment variables related to build, but target-specific
+        # flags can still override them.
+        if self.toolset == "target":
+            cflags_c = (
+                os.environ.get("CPPFLAGS", "").split()
+                + os.environ.get("CFLAGS", "").split()
+                + cflags_c
+            )
+            cflags_cc = (
+                os.environ.get("CPPFLAGS", "").split()
+                + os.environ.get("CXXFLAGS", "").split()
+                + cflags_cc
+            )
+        elif self.toolset == "host":
+            cflags_c = (
+                os.environ.get("CPPFLAGS_host", "").split()
+                + os.environ.get("CFLAGS_host", "").split()
+                + cflags_c
+            )
+            cflags_cc = (
+                os.environ.get("CPPFLAGS_host", "").split()
+                + os.environ.get("CXXFLAGS_host", "").split()
+                + cflags_cc
+            )
+
+        defines = config.get("defines", []) + extra_defines
         self.WriteVariableList(
-            ninja_file, 'intermediatemanifest', [intermediate_manifest])
-      command_suffix = _GetWinLinkRuleNameSuffix(
-          self.msvs_settings.IsEmbedManifest(config_name))
-      def_file = self.msvs_settings.GetDefFile(self.GypPathToNinja)
-      if def_file:
-        implicit_deps.add(def_file)
-    else:
-      # Respect environment variables related to build, but target-specific
-      # flags can still override them.
-      ldflags = env_ldflags + config.get('ldflags', [])
-      if is_executable and len(solibs):
-        rpath = 'lib/'
-        if self.toolset != 'target':
-          rpath += self.toolset
-          ldflags.append(r'-Wl,-rpath=\$$ORIGIN/%s' % rpath)
+            ninja_file, "defines", [Define(d, self.flavor) for d in defines]
+        )
+        if self.flavor == "win":
+            self.WriteVariableList(
+                ninja_file, "asmflags", map(self.ExpandSpecial, asmflags)
+            )
+            self.WriteVariableList(
+                ninja_file,
+                "rcflags",
+                [
+                    QuoteShellArgument(self.ExpandSpecial(f), self.flavor)
+                    for f in self.msvs_settings.GetRcflags(
+                        config_name, self.GypPathToNinja
+                    )
+                ],
+            )
+
+        include_dirs = config.get("include_dirs", [])
+
+        env = self.GetToolchainEnv()
+        if self.flavor == "win":
+            include_dirs = self.msvs_settings.AdjustIncludeDirs(
+                include_dirs, config_name
+            )
+        self.WriteVariableList(
+            ninja_file,
+            "includes",
+            [
+                QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
+                for i in include_dirs
+            ],
+        )
+
+        if self.flavor == "win":
+            midl_include_dirs = config.get("midl_include_dirs", [])
+            midl_include_dirs = self.msvs_settings.AdjustMidlIncludeDirs(
+                midl_include_dirs, config_name
+            )
+            self.WriteVariableList(
+                ninja_file,
+                "midl_includes",
+                [
+                    QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
+                    for i in midl_include_dirs
+                ],
+            )
+
+        pch_commands = precompiled_header.GetPchBuildCommands(arch)
+        if self.flavor == "mac":
+            # Most targets use no precompiled headers, so only write these if needed.
+            for ext, var in [
+                ("c", "cflags_pch_c"),
+                ("cc", "cflags_pch_cc"),
+                ("m", "cflags_pch_objc"),
+                ("mm", "cflags_pch_objcc"),
+            ]:
+                include = precompiled_header.GetInclude(ext, arch)
+                if include:
+                    ninja_file.variable(var, include)
+
+        arflags = config.get("arflags", [])
+
+        self.WriteVariableList(ninja_file, "cflags", map(self.ExpandSpecial, cflags))
+        self.WriteVariableList(
+            ninja_file, "cflags_c", map(self.ExpandSpecial, cflags_c)
+        )
+        self.WriteVariableList(
+            ninja_file, "cflags_cc", map(self.ExpandSpecial, cflags_cc)
+        )
+        if self.flavor == "mac":
+            self.WriteVariableList(
+                ninja_file, "cflags_objc", map(self.ExpandSpecial, cflags_objc)
+            )
+            self.WriteVariableList(
+                ninja_file, "cflags_objcc", map(self.ExpandSpecial, cflags_objcc)
+            )
+        self.WriteVariableList(ninja_file, "arflags", map(self.ExpandSpecial, arflags))
+        ninja_file.newline()
+        outputs = []
+        has_rc_source = False
+        for source in sources:
+            filename, ext = os.path.splitext(source)
+            ext = ext[1:]
+            obj_ext = self.obj_ext
+            if ext in ("cc", "cpp", "cxx"):
+                command = "cxx"
+                self.target.uses_cpp = True
+            elif ext == "c" or (ext == "S" and self.flavor != "win"):
+                command = "cc"
+            elif ext == "s" and self.flavor != "win":  # Doesn't generate .o.d files.
+                command = "cc_s"
+            elif (
+                self.flavor == "win"
+                and ext == "asm"
+                and not self.msvs_settings.HasExplicitAsmRules(spec)
+            ):
+                command = "asm"
+                # Add the _asm suffix as msvs is capable of handling .cc and
+                # .asm files of the same name without collision.
+                obj_ext = "_asm.obj"
+            elif self.flavor == "mac" and ext == "m":
+                command = "objc"
+            elif self.flavor == "mac" and ext == "mm":
+                command = "objcxx"
+                self.target.uses_cpp = True
+            elif self.flavor == "win" and ext == "rc":
+                command = "rc"
+                obj_ext = ".res"
+                has_rc_source = True
+            else:
+                # Ignore unhandled extensions.
+                continue
+            input = self.GypPathToNinja(source)
+            output = self.GypPathToUniqueOutput(filename + obj_ext)
+            if arch is not None:
+                output = AddArch(output, arch)
+            implicit = precompiled_header.GetObjDependencies([input], [output], arch)
+            variables = []
+            if self.flavor == "win":
+                variables, output, implicit = precompiled_header.GetFlagsModifications(
+                    input,
+                    output,
+                    implicit,
+                    command,
+                    cflags_c,
+                    cflags_cc,
+                    self.ExpandSpecial,
+                )
+            ninja_file.build(
+                output,
+                command,
+                input,
+                implicit=[gch for _, _, gch in implicit],
+                order_only=predepends,
+                variables=variables,
+            )
+            outputs.append(output)
+
+        if has_rc_source:
+            resource_include_dirs = config.get("resource_include_dirs", include_dirs)
+            self.WriteVariableList(
+                ninja_file,
+                "resource_includes",
+                [
+                    QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
+                    for i in resource_include_dirs
+                ],
+            )
+
+        self.WritePchTargets(ninja_file, pch_commands)
+
+        ninja_file.newline()
+        return outputs
+
+    def WritePchTargets(self, ninja_file, pch_commands):
+        """Writes ninja rules to compile prefix headers."""
+        if not pch_commands:
+            return
+
+        for gch, lang_flag, lang, input in pch_commands:
+            var_name = {
+                "c": "cflags_pch_c",
+                "cc": "cflags_pch_cc",
+                "m": "cflags_pch_objc",
+                "mm": "cflags_pch_objcc",
+            }[lang]
+
+            map = {
+                "c": "cc",
+                "cc": "cxx",
+                "m": "objc",
+                "mm": "objcxx",
+            }
+            cmd = map.get(lang)
+            ninja_file.build(gch, cmd, input, variables=[(var_name, lang_flag)])
+
+    def WriteLink(self, spec, config_name, config, link_deps, compile_deps):
+        """Write out a link step. Fills out target.binary. """
+        if self.flavor != "mac" or len(self.archs) == 1:
+            return self.WriteLinkForArch(
+                self.ninja, spec, config_name, config, link_deps, compile_deps
+            )
         else:
-          ldflags.append('-Wl,-rpath=%s' % self.target_rpath)
-        ldflags.append('-Wl,-rpath-link=%s' % rpath)
-    self.WriteVariableList(ninja_file, 'ldflags',
-                           map(self.ExpandSpecial, ldflags))
-
-    library_dirs = config.get('library_dirs', [])
-    if self.flavor == 'win':
-      library_dirs = [self.msvs_settings.ConvertVSMacros(l, config_name)
-                      for l in library_dirs]
-      library_dirs = ['/LIBPATH:' + QuoteShellArgument(self.GypPathToNinja(l),
-                                                       self.flavor)
-                      for l in library_dirs]
-    else:
-      library_dirs = [QuoteShellArgument('-L' + self.GypPathToNinja(l),
-                                         self.flavor)
-                      for l in library_dirs]
-
-    libraries = gyp.common.uniquer(map(self.ExpandSpecial,
-                                       spec.get('libraries', [])))
-    if self.flavor == 'mac':
-      libraries = self.xcode_settings.AdjustLibraries(libraries, config_name)
-    elif self.flavor == 'win':
-      libraries = self.msvs_settings.AdjustLibraries(libraries)
-
-    self.WriteVariableList(ninja_file, 'libs', library_dirs + libraries)
-
-    linked_binary = output
-
-    if command in ('solink', 'solink_module'):
-      extra_bindings.append(('soname', os.path.split(output)[1]))
-      extra_bindings.append(('lib',
-                            gyp.common.EncodePOSIXShellArgument(output)))
-      if self.flavor != 'win':
-        link_file_list = output
-        if self.is_mac_bundle:
-          # 'Dependency Framework.framework/Versions/A/Dependency Framework' ->
-          # 'Dependency Framework.framework.rsp'
-          link_file_list = self.xcode_settings.GetWrapperName()
-        if arch:
-          link_file_list += '.' + arch
-        link_file_list += '.rsp'
-        # If an rspfile contains spaces, ninja surrounds the filename with
-        # quotes around it and then passes it to open(), creating a file with
-        # quotes in its name (and when looking for the rsp file, the name
-        # makes it through bash which strips the quotes) :-/
-        link_file_list = link_file_list.replace(' ', '_')
-        extra_bindings.append(
-          ('link_file_list',
-            gyp.common.EncodePOSIXShellArgument(link_file_list)))
-      if self.flavor == 'win':
-        extra_bindings.append(('binary', output))
-        if ('/NOENTRY' not in ldflags and
-            not self.msvs_settings.GetNoImportLibrary(config_name)):
-          self.target.import_lib = output + '.lib'
-          extra_bindings.append(('implibflag',
-                                 '/IMPLIB:%s' % self.target.import_lib))
-          pdbname = self.msvs_settings.GetPDBName(
-              config_name, self.ExpandSpecial, output + '.pdb')
-          output = [output, self.target.import_lib]
-          if pdbname:
-            output.append(pdbname)
-      elif not self.is_mac_bundle:
-        output = [output, output + '.TOC']
-      else:
-        command = command + '_notoc'
-    elif self.flavor == 'win':
-      extra_bindings.append(('binary', output))
-      pdbname = self.msvs_settings.GetPDBName(
-          config_name, self.ExpandSpecial, output + '.pdb')
-      if pdbname:
-        output = [output, pdbname]
-
-
-    if len(solibs):
-      extra_bindings.append(('solibs',
-          gyp.common.EncodePOSIXShellList(sorted(solibs))))
-
-    ninja_file.build(output, command + command_suffix, link_deps,
-                     implicit=sorted(implicit_deps),
-                     order_only=list(order_deps),
-                     variables=extra_bindings)
-    return linked_binary
-
-  def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
-    extra_link_deps = any(self.target_outputs.get(dep).Linkable()
-                          for dep in spec.get('dependencies', [])
-                          if dep in self.target_outputs)
-    if spec['type'] == 'none' or (not link_deps and not extra_link_deps):
-      # TODO(evan): don't call this function for 'none' target types, as
-      # it doesn't do anything, and we fake out a 'binary' with a stamp file.
-      self.target.binary = compile_deps
-      self.target.type = 'none'
-    elif spec['type'] == 'static_library':
-      self.target.binary = self.ComputeOutput(spec)
-      if (self.flavor not in ('mac', 'openbsd', 'netbsd', 'win') and not
-          self.is_standalone_static_library):
-        self.ninja.build(self.target.binary, 'alink_thin', link_deps,
-                         order_only=compile_deps)
-      else:
+            output = self.ComputeOutput(spec)
+            inputs = [
+                self.WriteLinkForArch(
+                    self.arch_subninjas[arch],
+                    spec,
+                    config_name,
+                    config,
+                    link_deps[arch],
+                    compile_deps,
+                    arch=arch,
+                )
+                for arch in self.archs
+            ]
+            extra_bindings = []
+            build_output = output
+            if not self.is_mac_bundle:
+                self.AppendPostbuildVariable(extra_bindings, spec, output, output)
+
+            # TODO(yyanagisawa): more work needed to fix:
+            # https://code.google.com/p/gyp/issues/detail?id=411
+            if (
+                spec["type"] in ("shared_library", "loadable_module")
+                and not self.is_mac_bundle
+            ):
+                extra_bindings.append(("lib", output))
+                self.ninja.build(
+                    [output, output + ".TOC"],
+                    "solipo",
+                    inputs,
+                    variables=extra_bindings,
+                )
+            else:
+                self.ninja.build(build_output, "lipo", inputs, variables=extra_bindings)
+            return output
+
+    def WriteLinkForArch(
+        self, ninja_file, spec, config_name, config, link_deps, compile_deps, arch=None
+    ):
+        """Write out a link step. Fills out target.binary. """
+        command = {
+            "executable": "link",
+            "loadable_module": "solink_module",
+            "shared_library": "solink",
+        }[spec["type"]]
+        command_suffix = ""
+
+        implicit_deps = set()
+        solibs = set()
+        order_deps = set()
+
+        if compile_deps:
+            # Normally, the compiles of the target already depend on compile_deps,
+            # but a shared_library target might have no sources and only link together
+            # a few static_library deps, so the link step also needs to depend
+            # on compile_deps to make sure actions in the shared_library target
+            # get run before the link.
+            order_deps.add(compile_deps)
+
+        if "dependencies" in spec:
+            # Two kinds of dependencies:
+            # - Linkable dependencies (like a .a or a .so): add them to the link line.
+            # - Non-linkable dependencies (like a rule that generates a file
+            #   and writes a stamp file): add them to implicit_deps
+            extra_link_deps = set()
+            for dep in spec["dependencies"]:
+                target = self.target_outputs.get(dep)
+                if not target:
+                    continue
+                linkable = target.Linkable()
+                if linkable:
+                    new_deps = []
+                    if (
+                        self.flavor == "win"
+                        and target.component_objs
+                        and self.msvs_settings.IsUseLibraryDependencyInputs(config_name)
+                    ):
+                        new_deps = target.component_objs
+                        if target.compile_deps:
+                            order_deps.add(target.compile_deps)
+                    elif self.flavor == "win" and target.import_lib:
+                        new_deps = [target.import_lib]
+                    elif target.UsesToc(self.flavor):
+                        solibs.add(target.binary)
+                        implicit_deps.add(target.binary + ".TOC")
+                    else:
+                        new_deps = [target.binary]
+                    for new_dep in new_deps:
+                        if new_dep not in extra_link_deps:
+                            extra_link_deps.add(new_dep)
+                            link_deps.append(new_dep)
+
+                final_output = target.FinalOutput()
+                if not linkable or final_output != target.binary:
+                    implicit_deps.add(final_output)
+
+        extra_bindings = []
+        if self.target.uses_cpp and self.flavor != "win":
+            extra_bindings.append(("ld", "$ldxx"))
+
+        output = self.ComputeOutput(spec, arch)
+        if arch is None and not self.is_mac_bundle:
+            self.AppendPostbuildVariable(extra_bindings, spec, output, output)
+
+        is_executable = spec["type"] == "executable"
+        # The ldflags config key is not used on mac or win. On those platforms
+        # linker flags are set via xcode_settings and msvs_settings, respectively.
+        env_ldflags = os.environ.get("LDFLAGS", "").split()
+        if self.flavor == "mac":
+            ldflags = self.xcode_settings.GetLdflags(
+                config_name,
+                self.ExpandSpecial(generator_default_variables["PRODUCT_DIR"]),
+                self.GypPathToNinja,
+                arch,
+            )
+            ldflags = env_ldflags + ldflags
+        elif self.flavor == "win":
+            manifest_base_name = self.GypPathToUniqueOutput(
+                self.ComputeOutputFileName(spec)
+            )
+            (
+                ldflags,
+                intermediate_manifest,
+                manifest_files,
+            ) = self.msvs_settings.GetLdflags(
+                config_name,
+                self.GypPathToNinja,
+                self.ExpandSpecial,
+                manifest_base_name,
+                output,
+                is_executable,
+                self.toplevel_build,
+            )
+            ldflags = env_ldflags + ldflags
+            self.WriteVariableList(ninja_file, "manifests", manifest_files)
+            implicit_deps = implicit_deps.union(manifest_files)
+            if intermediate_manifest:
+                self.WriteVariableList(
+                    ninja_file, "intermediatemanifest", [intermediate_manifest]
+                )
+            command_suffix = _GetWinLinkRuleNameSuffix(
+                self.msvs_settings.IsEmbedManifest(config_name)
+            )
+            def_file = self.msvs_settings.GetDefFile(self.GypPathToNinja)
+            if def_file:
+                implicit_deps.add(def_file)
+        else:
+            # Respect environment variables related to build, but target-specific
+            # flags can still override them.
+            ldflags = env_ldflags + config.get("ldflags", [])
+            if is_executable and len(solibs):
+                rpath = "lib/"
+                if self.toolset != "target":
+                    rpath += self.toolset
+                    ldflags.append(r"-Wl,-rpath=\$$ORIGIN/%s" % rpath)
+                else:
+                    ldflags.append("-Wl,-rpath=%s" % self.target_rpath)
+                ldflags.append("-Wl,-rpath-link=%s" % rpath)
+        self.WriteVariableList(ninja_file, "ldflags", map(self.ExpandSpecial, ldflags))
+
+        library_dirs = config.get("library_dirs", [])
+        if self.flavor == "win":
+            library_dirs = [
+                self.msvs_settings.ConvertVSMacros(library_dir, config_name)
+                for library_dir in library_dirs
+            ]
+            library_dirs = [
+                "/LIBPATH:"
+                + QuoteShellArgument(self.GypPathToNinja(library_dir), self.flavor)
+                for library_dir in library_dirs
+            ]
+        else:
+            library_dirs = [
+                QuoteShellArgument("-L" + self.GypPathToNinja(library_dir), self.flavor)
+                for library_dir in library_dirs
+            ]
+
+        libraries = gyp.common.uniquer(
+            map(self.ExpandSpecial, spec.get("libraries", []))
+        )
+        if self.flavor == "mac":
+            libraries = self.xcode_settings.AdjustLibraries(libraries, config_name)
+        elif self.flavor == "win":
+            libraries = self.msvs_settings.AdjustLibraries(libraries)
+
+        self.WriteVariableList(ninja_file, "libs", library_dirs + libraries)
+
+        linked_binary = output
+
+        if command in ("solink", "solink_module"):
+            extra_bindings.append(("soname", os.path.split(output)[1]))
+            extra_bindings.append(("lib", gyp.common.EncodePOSIXShellArgument(output)))
+            if self.flavor != "win":
+                link_file_list = output
+                if self.is_mac_bundle:
+                    # 'Dependency Framework.framework/Versions/A/Dependency Framework'
+                    # -> 'Dependency Framework.framework.rsp'
+                    link_file_list = self.xcode_settings.GetWrapperName()
+                if arch:
+                    link_file_list += "." + arch
+                link_file_list += ".rsp"
+                # If an rspfile contains spaces, ninja surrounds the filename with
+                # quotes around it and then passes it to open(), creating a file with
+                # quotes in its name (and when looking for the rsp file, the name
+                # makes it through bash which strips the quotes) :-/
+                link_file_list = link_file_list.replace(" ", "_")
+                extra_bindings.append(
+                    (
+                        "link_file_list",
+                        gyp.common.EncodePOSIXShellArgument(link_file_list),
+                    )
+                )
+            if self.flavor == "win":
+                extra_bindings.append(("binary", output))
+                if (
+                    "/NOENTRY" not in ldflags
+                    and not self.msvs_settings.GetNoImportLibrary(config_name)
+                ):
+                    self.target.import_lib = output + ".lib"
+                    extra_bindings.append(
+                        ("implibflag", "/IMPLIB:%s" % self.target.import_lib)
+                    )
+                    pdbname = self.msvs_settings.GetPDBName(
+                        config_name, self.ExpandSpecial, output + ".pdb"
+                    )
+                    output = [output, self.target.import_lib]
+                    if pdbname:
+                        output.append(pdbname)
+            elif not self.is_mac_bundle:
+                output = [output, output + ".TOC"]
+            else:
+                command = command + "_notoc"
+        elif self.flavor == "win":
+            extra_bindings.append(("binary", output))
+            pdbname = self.msvs_settings.GetPDBName(
+                config_name, self.ExpandSpecial, output + ".pdb"
+            )
+            if pdbname:
+                output = [output, pdbname]
+
+        if len(solibs):
+            extra_bindings.append(
+                ("solibs", gyp.common.EncodePOSIXShellList(sorted(solibs)))
+            )
+
+        ninja_file.build(
+            output,
+            command + command_suffix,
+            link_deps,
+            implicit=sorted(implicit_deps),
+            order_only=list(order_deps),
+            variables=extra_bindings,
+        )
+        return linked_binary
+
+    def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
+        extra_link_deps = any(
+            self.target_outputs.get(dep).Linkable()
+            for dep in spec.get("dependencies", [])
+            if dep in self.target_outputs
+        )
+        if spec["type"] == "none" or (not link_deps and not extra_link_deps):
+            # TODO(evan): don't call this function for 'none' target types, as
+            # it doesn't do anything, and we fake out a 'binary' with a stamp file.
+            self.target.binary = compile_deps
+            self.target.type = "none"
+        elif spec["type"] == "static_library":
+            self.target.binary = self.ComputeOutput(spec)
+            if (
+                self.flavor not in ("mac", "openbsd", "netbsd", "win")
+                and not self.is_standalone_static_library
+            ):
+                self.ninja.build(
+                    self.target.binary, "alink_thin", link_deps, order_only=compile_deps
+                )
+            else:
+                variables = []
+                if self.xcode_settings:
+                    libtool_flags = self.xcode_settings.GetLibtoolflags(config_name)
+                    if libtool_flags:
+                        variables.append(("libtool_flags", libtool_flags))
+                if self.msvs_settings:
+                    libflags = self.msvs_settings.GetLibFlags(
+                        config_name, self.GypPathToNinja
+                    )
+                    variables.append(("libflags", libflags))
+
+                if self.flavor != "mac" or len(self.archs) == 1:
+                    self.AppendPostbuildVariable(
+                        variables, spec, self.target.binary, self.target.binary
+                    )
+                    self.ninja.build(
+                        self.target.binary,
+                        "alink",
+                        link_deps,
+                        order_only=compile_deps,
+                        variables=variables,
+                    )
+                else:
+                    inputs = []
+                    for arch in self.archs:
+                        output = self.ComputeOutput(spec, arch)
+                        self.arch_subninjas[arch].build(
+                            output,
+                            "alink",
+                            link_deps[arch],
+                            order_only=compile_deps,
+                            variables=variables,
+                        )
+                        inputs.append(output)
+                    # TODO: It's not clear if
+                    # libtool_flags should be passed to the alink
+                    # call that combines single-arch .a files into a fat .a file.
+                    self.AppendPostbuildVariable(
+                        variables, spec, self.target.binary, self.target.binary
+                    )
+                    self.ninja.build(
+                        self.target.binary,
+                        "alink",
+                        inputs,
+                        # FIXME: test proving order_only=compile_deps isn't
+                        # needed.
+                        variables=variables,
+                    )
+        else:
+            self.target.binary = self.WriteLink(
+                spec, config_name, config, link_deps, compile_deps
+            )
+        return self.target.binary
+
+    def WriteMacBundle(self, spec, mac_bundle_depends, is_empty):
+        assert self.is_mac_bundle
+        package_framework = spec["type"] in ("shared_library", "loadable_module")
+        output = self.ComputeMacBundleOutput()
+        if is_empty:
+            output += ".stamp"
         variables = []
-        if self.xcode_settings:
-          libtool_flags = self.xcode_settings.GetLibtoolflags(config_name)
-          if libtool_flags:
-            variables.append(('libtool_flags', libtool_flags))
-        if self.msvs_settings:
-          libflags = self.msvs_settings.GetLibFlags(config_name,
-                                                    self.GypPathToNinja)
-          variables.append(('libflags', libflags))
-
-        if self.flavor != 'mac' or len(self.archs) == 1:
-          self.AppendPostbuildVariable(variables, spec,
-                                       self.target.binary, self.target.binary)
-          self.ninja.build(self.target.binary, 'alink', link_deps,
-                           order_only=compile_deps, variables=variables)
+        self.AppendPostbuildVariable(
+            variables,
+            spec,
+            output,
+            self.target.binary,
+            is_command_start=not package_framework,
+        )
+        if package_framework and not is_empty:
+            if spec["type"] == "shared_library" and self.xcode_settings.isIOS:
+                self.ninja.build(
+                    output,
+                    "package_ios_framework",
+                    mac_bundle_depends,
+                    variables=variables,
+                )
+            else:
+                variables.append(("version", self.xcode_settings.GetFrameworkVersion()))
+                self.ninja.build(
+                    output, "package_framework", mac_bundle_depends, variables=variables
+                )
         else:
-          inputs = []
-          for arch in self.archs:
-            output = self.ComputeOutput(spec, arch)
-            self.arch_subninjas[arch].build(output, 'alink', link_deps[arch],
-                                            order_only=compile_deps,
-                                            variables=variables)
-            inputs.append(output)
-          # TODO: It's not clear if libtool_flags should be passed to the alink
-          # call that combines single-arch .a files into a fat .a file.
-          self.AppendPostbuildVariable(variables, spec,
-                                       self.target.binary, self.target.binary)
-          self.ninja.build(self.target.binary, 'alink', inputs,
-                           # FIXME: test proving order_only=compile_deps isn't
-                           # needed.
-                           variables=variables)
-    else:
-      self.target.binary = self.WriteLink(spec, config_name, config, link_deps,
-                                          compile_deps)
-    return self.target.binary
-
-  def WriteMacBundle(self, spec, mac_bundle_depends, is_empty):
-    assert self.is_mac_bundle
-    package_framework = spec['type'] in ('shared_library', 'loadable_module')
-    output = self.ComputeMacBundleOutput()
-    if is_empty:
-      output += '.stamp'
-    variables = []
-    self.AppendPostbuildVariable(variables, spec, output, self.target.binary,
-                                 is_command_start=not package_framework)
-    if package_framework and not is_empty:
-      if spec['type'] == 'shared_library' and self.xcode_settings.isIOS:
-        self.ninja.build(output, 'package_ios_framework', mac_bundle_depends,
-                         variables=variables)
-      else:
-        variables.append(('version', self.xcode_settings.GetFrameworkVersion()))
-        self.ninja.build(output, 'package_framework', mac_bundle_depends,
-                         variables=variables)
-    else:
-      self.ninja.build(output, 'stamp', mac_bundle_depends,
-                       variables=variables)
-    self.target.bundle = output
-    return output
-
-  def GetToolchainEnv(self, additional_settings=None):
-    """Returns the variables toolchain would set for build steps."""
-    env = self.GetSortedXcodeEnv(additional_settings=additional_settings)
-    if self.flavor == 'win':
-      env = self.GetMsvsToolchainEnv(
-          additional_settings=additional_settings)
-    return env
-
-  def GetMsvsToolchainEnv(self, additional_settings=None):
-    """Returns the variables Visual Studio would set for build steps."""
-    return self.msvs_settings.GetVSMacroEnv('$!PRODUCT_DIR',
-                                             config=self.config_name)
-
-  def GetSortedXcodeEnv(self, additional_settings=None):
-    """Returns the variables Xcode would set for build steps."""
-    assert self.abs_build_dir
-    abs_build_dir = self.abs_build_dir
-    return gyp.xcode_emulation.GetSortedXcodeEnv(
-        self.xcode_settings, abs_build_dir,
-        os.path.join(abs_build_dir, self.build_to_base), self.config_name,
-        additional_settings)
-
-  def GetSortedXcodePostbuildEnv(self):
-    """Returns the variables Xcode would set for postbuild steps."""
-    postbuild_settings = {}
-    # CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.
-    # TODO(thakis): It would be nice to have some general mechanism instead.
-    strip_save_file = self.xcode_settings.GetPerTargetSetting(
-        'CHROMIUM_STRIP_SAVE_FILE')
-    if strip_save_file:
-      postbuild_settings['CHROMIUM_STRIP_SAVE_FILE'] = strip_save_file
-    return self.GetSortedXcodeEnv(additional_settings=postbuild_settings)
-
-  def AppendPostbuildVariable(self, variables, spec, output, binary,
-                              is_command_start=False):
-    """Adds a 'postbuild' variable if there is a postbuild for |output|."""
-    postbuild = self.GetPostbuildCommand(spec, output, binary, is_command_start)
-    if postbuild:
-      variables.append(('postbuilds', postbuild))
-
-  def GetPostbuildCommand(self, spec, output, output_binary, is_command_start):
-    """Returns a shell command that runs all the postbuilds, and removes
+            self.ninja.build(output, "stamp", mac_bundle_depends, variables=variables)
+        self.target.bundle = output
+        return output
+
+    def GetToolchainEnv(self, additional_settings=None):
+        """Returns the variables toolchain would set for build steps."""
+        env = self.GetSortedXcodeEnv(additional_settings=additional_settings)
+        if self.flavor == "win":
+            env = self.GetMsvsToolchainEnv(additional_settings=additional_settings)
+        return env
+
+    def GetMsvsToolchainEnv(self, additional_settings=None):
+        """Returns the variables Visual Studio would set for build steps."""
+        return self.msvs_settings.GetVSMacroEnv(
+            "$!PRODUCT_DIR", config=self.config_name
+        )
+
+    def GetSortedXcodeEnv(self, additional_settings=None):
+        """Returns the variables Xcode would set for build steps."""
+        assert self.abs_build_dir
+        abs_build_dir = self.abs_build_dir
+        return gyp.xcode_emulation.GetSortedXcodeEnv(
+            self.xcode_settings,
+            abs_build_dir,
+            os.path.join(abs_build_dir, self.build_to_base),
+            self.config_name,
+            additional_settings,
+        )
+
+    def GetSortedXcodePostbuildEnv(self):
+        """Returns the variables Xcode would set for postbuild steps."""
+        postbuild_settings = {}
+        # CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.
+        # TODO(thakis): It would be nice to have some general mechanism instead.
+        strip_save_file = self.xcode_settings.GetPerTargetSetting(
+            "CHROMIUM_STRIP_SAVE_FILE"
+        )
+        if strip_save_file:
+            postbuild_settings["CHROMIUM_STRIP_SAVE_FILE"] = strip_save_file
+        return self.GetSortedXcodeEnv(additional_settings=postbuild_settings)
+
+    def AppendPostbuildVariable(
+        self, variables, spec, output, binary, is_command_start=False
+    ):
+        """Adds a 'postbuild' variable if there is a postbuild for |output|."""
+        postbuild = self.GetPostbuildCommand(spec, output, binary, is_command_start)
+        if postbuild:
+            variables.append(("postbuilds", postbuild))
+
+    def GetPostbuildCommand(self, spec, output, output_binary, is_command_start):
+        """Returns a shell command that runs all the postbuilds, and removes
     |output| if any of them fails. If |is_command_start| is False, then the
     returned string will start with ' && '."""
-    if not self.xcode_settings or spec['type'] == 'none' or not output:
-      return ''
-    output = QuoteShellArgument(output, self.flavor)
-    postbuilds = gyp.xcode_emulation.GetSpecPostbuildCommands(spec, quiet=True)
-    if output_binary is not None:
-      postbuilds = self.xcode_settings.AddImplicitPostbuilds(
-          self.config_name,
-          os.path.normpath(os.path.join(self.base_to_build, output)),
-          QuoteShellArgument(
-              os.path.normpath(os.path.join(self.base_to_build, output_binary)),
-              self.flavor),
-          postbuilds, quiet=True)
-
-    if not postbuilds:
-      return ''
-    # Postbuilds expect to be run in the gyp file's directory, so insert an
-    # implicit postbuild to cd to there.
-    postbuilds.insert(0, gyp.common.EncodePOSIXShellList(
-        ['cd', self.build_to_base]))
-    env = self.ComputeExportEnvString(self.GetSortedXcodePostbuildEnv())
-    # G will be non-null if any postbuild fails. Run all postbuilds in a
-    # subshell.
-    commands = env + ' (' + \
-        ' && '.join([ninja_syntax.escape(command) for command in postbuilds])
-    command_string = (commands + '); G=$$?; '
-                      # Remove the final output if any postbuild failed.
-                      '((exit $$G) || rm -rf %s) ' % output + '&& exit $$G)')
-    if is_command_start:
-      return '(' + command_string + ' && '
-    else:
-      return '$ && (' + command_string
+        if not self.xcode_settings or spec["type"] == "none" or not output:
+            return ""
+        output = QuoteShellArgument(output, self.flavor)
+        postbuilds = gyp.xcode_emulation.GetSpecPostbuildCommands(spec, quiet=True)
+        if output_binary is not None:
+            postbuilds = self.xcode_settings.AddImplicitPostbuilds(
+                self.config_name,
+                os.path.normpath(os.path.join(self.base_to_build, output)),
+                QuoteShellArgument(
+                    os.path.normpath(os.path.join(self.base_to_build, output_binary)),
+                    self.flavor,
+                ),
+                postbuilds,
+                quiet=True,
+            )
+
+        if not postbuilds:
+            return ""
+        # Postbuilds expect to be run in the gyp file's directory, so insert an
+        # implicit postbuild to cd to there.
+        postbuilds.insert(
+            0, gyp.common.EncodePOSIXShellList(["cd", self.build_to_base])
+        )
+        env = self.ComputeExportEnvString(self.GetSortedXcodePostbuildEnv())
+        # G will be non-null if any postbuild fails. Run all postbuilds in a
+        # subshell.
+        commands = (
+            env
+            + " ("
+            + " && ".join([ninja_syntax.escape(command) for command in postbuilds])
+        )
+        command_string = (
+            commands
+            + "); G=$$?; "
+            # Remove the final output if any postbuild failed.
+            "((exit $$G) || rm -rf %s) " % output
+            + "&& exit $$G)"
+        )
+        if is_command_start:
+            return "(" + command_string + " && "
+        else:
+            return "$ && (" + command_string
 
-  def ComputeExportEnvString(self, env):
-    """Given an environment, returns a string looking like
+    def ComputeExportEnvString(self, env):
+        """Given an environment, returns a string looking like
         'export FOO=foo; export BAR="${FOO} bar;'
     that exports |env| to the shell."""
-    export_str = []
-    for k, v in env:
-      export_str.append('export %s=%s;' %
-          (k, ninja_syntax.escape(gyp.common.EncodePOSIXShellArgument(v))))
-    return ' '.join(export_str)
-
-  def ComputeMacBundleOutput(self):
-    """Return the 'output' (full output path) to a bundle output directory."""
-    assert self.is_mac_bundle
-    path = generator_default_variables['PRODUCT_DIR']
-    return self.ExpandSpecial(
-        os.path.join(path, self.xcode_settings.GetWrapperName()))
-
-  def ComputeOutputFileName(self, spec, type=None):
-    """Compute the filename of the final output for the current target."""
-    if not type:
-      type = spec['type']
-
-    default_variables = copy.copy(generator_default_variables)
-    CalculateVariables(default_variables, {'flavor': self.flavor})
-
-    # Compute filename prefix: the product prefix, or a default for
-    # the product type.
-    DEFAULT_PREFIX = {
-      'loadable_module': default_variables['SHARED_LIB_PREFIX'],
-      'shared_library': default_variables['SHARED_LIB_PREFIX'],
-      'static_library': default_variables['STATIC_LIB_PREFIX'],
-      'executable': default_variables['EXECUTABLE_PREFIX'],
-      }
-    prefix = spec.get('product_prefix', DEFAULT_PREFIX.get(type, ''))
-
-    # Compute filename extension: the product extension, or a default
-    # for the product type.
-    DEFAULT_EXTENSION = {
-        'loadable_module': default_variables['SHARED_LIB_SUFFIX'],
-        'shared_library': default_variables['SHARED_LIB_SUFFIX'],
-        'static_library': default_variables['STATIC_LIB_SUFFIX'],
-        'executable': default_variables['EXECUTABLE_SUFFIX'],
-      }
-    extension = spec.get('product_extension')
-    if extension:
-      extension = '.' + extension
-    else:
-      extension = DEFAULT_EXTENSION.get(type, '')
-
-    if 'product_name' in spec:
-      # If we were given an explicit name, use that.
-      target = spec['product_name']
-    else:
-      # Otherwise, derive a name from the target name.
-      target = spec['target_name']
-      if prefix == 'lib':
-        # Snip out an extra 'lib' from libs if appropriate.
-        target = StripPrefix(target, 'lib')
-
-    if type in ('static_library', 'loadable_module', 'shared_library',
-                        'executable'):
-      return '%s%s%s' % (prefix, target, extension)
-    elif type == 'none':
-      return '%s.stamp' % target
-    else:
-      raise Exception('Unhandled output type %s' % type)
-
-  def ComputeOutput(self, spec, arch=None):
-    """Compute the path for the final output of the spec."""
-    type = spec['type']
-
-    if self.flavor == 'win':
-      override = self.msvs_settings.GetOutputName(self.config_name,
-                                                  self.ExpandSpecial)
-      if override:
-        return override
+        export_str = []
+        for k, v in env:
+            export_str.append(
+                "export %s=%s;"
+                % (k, ninja_syntax.escape(gyp.common.EncodePOSIXShellArgument(v)))
+            )
+        return " ".join(export_str)
+
+    def ComputeMacBundleOutput(self):
+        """Return the 'output' (full output path) to a bundle output directory."""
+        assert self.is_mac_bundle
+        path = generator_default_variables["PRODUCT_DIR"]
+        return self.ExpandSpecial(
+            os.path.join(path, self.xcode_settings.GetWrapperName())
+        )
+
+    def ComputeOutputFileName(self, spec, type=None):
+        """Compute the filename of the final output for the current target."""
+        if not type:
+            type = spec["type"]
+
+        default_variables = copy.copy(generator_default_variables)
+        CalculateVariables(default_variables, {"flavor": self.flavor})
+
+        # Compute filename prefix: the product prefix, or a default for
+        # the product type.
+        DEFAULT_PREFIX = {
+            "loadable_module": default_variables["SHARED_LIB_PREFIX"],
+            "shared_library": default_variables["SHARED_LIB_PREFIX"],
+            "static_library": default_variables["STATIC_LIB_PREFIX"],
+            "executable": default_variables["EXECUTABLE_PREFIX"],
+        }
+        prefix = spec.get("product_prefix", DEFAULT_PREFIX.get(type, ""))
+
+        # Compute filename extension: the product extension, or a default
+        # for the product type.
+        DEFAULT_EXTENSION = {
+            "loadable_module": default_variables["SHARED_LIB_SUFFIX"],
+            "shared_library": default_variables["SHARED_LIB_SUFFIX"],
+            "static_library": default_variables["STATIC_LIB_SUFFIX"],
+            "executable": default_variables["EXECUTABLE_SUFFIX"],
+        }
+        extension = spec.get("product_extension")
+        if extension:
+            extension = "." + extension
+        else:
+            extension = DEFAULT_EXTENSION.get(type, "")
 
-    if arch is None and self.flavor == 'mac' and type in (
-        'static_library', 'executable', 'shared_library', 'loadable_module'):
-      filename = self.xcode_settings.GetExecutablePath()
-    else:
-      filename = self.ComputeOutputFileName(spec, type)
-
-    if arch is None and 'product_dir' in spec:
-      path = os.path.join(spec['product_dir'], filename)
-      return self.ExpandSpecial(path)
-
-    # Some products go into the output root, libraries go into shared library
-    # dir, and everything else goes into the normal place.
-    type_in_output_root = ['executable', 'loadable_module']
-    if self.flavor == 'mac' and self.toolset == 'target':
-      type_in_output_root += ['shared_library', 'static_library']
-    elif self.flavor == 'win' and self.toolset == 'target':
-      type_in_output_root += ['shared_library']
-
-    if arch is not None:
-      # Make sure partial executables don't end up in a bundle or the regular
-      # output directory.
-      archdir = 'arch'
-      if self.toolset != 'target':
-        archdir = os.path.join('arch', '%s' % self.toolset)
-      return os.path.join(archdir, AddArch(filename, arch))
-    elif type in type_in_output_root or self.is_standalone_static_library:
-      return filename
-    elif type == 'shared_library':
-      libdir = 'lib'
-      if self.toolset != 'target':
-        libdir = os.path.join('lib', '%s' % self.toolset)
-      return os.path.join(libdir, filename)
-    else:
-      return self.GypPathToUniqueOutput(filename, qualified=False)
+        if "product_name" in spec:
+            # If we were given an explicit name, use that.
+            target = spec["product_name"]
+        else:
+            # Otherwise, derive a name from the target name.
+            target = spec["target_name"]
+            if prefix == "lib":
+                # Snip out an extra 'lib' from libs if appropriate.
+                target = StripPrefix(target, "lib")
+
+        if type in (
+            "static_library",
+            "loadable_module",
+            "shared_library",
+            "executable",
+        ):
+            return "%s%s%s" % (prefix, target, extension)
+        elif type == "none":
+            return "%s.stamp" % target
+        else:
+            raise Exception("Unhandled output type %s" % type)
+
+    def ComputeOutput(self, spec, arch=None):
+        """Compute the path for the final output of the spec."""
+        type = spec["type"]
+
+        if self.flavor == "win":
+            override = self.msvs_settings.GetOutputName(
+                self.config_name, self.ExpandSpecial
+            )
+            if override:
+                return override
+
+        if (
+            arch is None
+            and self.flavor == "mac"
+            and type
+            in ("static_library", "executable", "shared_library", "loadable_module")
+        ):
+            filename = self.xcode_settings.GetExecutablePath()
+        else:
+            filename = self.ComputeOutputFileName(spec, type)
+
+        if arch is None and "product_dir" in spec:
+            path = os.path.join(spec["product_dir"], filename)
+            return self.ExpandSpecial(path)
+
+        # Some products go into the output root, libraries go into shared library
+        # dir, and everything else goes into the normal place.
+        type_in_output_root = ["executable", "loadable_module"]
+        if self.flavor == "mac" and self.toolset == "target":
+            type_in_output_root += ["shared_library", "static_library"]
+        elif self.flavor == "win" and self.toolset == "target":
+            type_in_output_root += ["shared_library"]
+
+        if arch is not None:
+            # Make sure partial executables don't end up in a bundle or the regular
+            # output directory.
+            archdir = "arch"
+            if self.toolset != "target":
+                archdir = os.path.join("arch", "%s" % self.toolset)
+            return os.path.join(archdir, AddArch(filename, arch))
+        elif type in type_in_output_root or self.is_standalone_static_library:
+            return filename
+        elif type == "shared_library":
+            libdir = "lib"
+            if self.toolset != "target":
+                libdir = os.path.join("lib", "%s" % self.toolset)
+            return os.path.join(libdir, filename)
+        else:
+            return self.GypPathToUniqueOutput(filename, qualified=False)
 
-  def WriteVariableList(self, ninja_file, var, values):
-    assert not isinstance(values, str)
-    if values is None:
-      values = []
-    ninja_file.variable(var, ' '.join(values))
+    def WriteVariableList(self, ninja_file, var, values):
+        assert not isinstance(values, str)
+        if values is None:
+            values = []
+        ninja_file.variable(var, " ".join(values))
 
-  def WriteNewNinjaRule(self, name, args, description, is_cygwin, env, pool,
-                        depfile=None):
-    """Write out a new ninja "rule" statement for a given command.
+    def WriteNewNinjaRule(
+        self, name, args, description, is_cygwin, env, pool, depfile=None
+    ):
+        """Write out a new ninja "rule" statement for a given command.
 
     Returns the name of the new rule, and a copy of |args| with variables
     expanded."""
 
-    if self.flavor == 'win':
-      args = [self.msvs_settings.ConvertVSMacros(
-                  arg, self.base_to_build, config=self.config_name)
-              for arg in args]
-      description = self.msvs_settings.ConvertVSMacros(
-          description, config=self.config_name)
-    elif self.flavor == 'mac':
-      # |env| is an empty list on non-mac.
-      args = [gyp.xcode_emulation.ExpandEnvVars(arg, env) for arg in args]
-      description = gyp.xcode_emulation.ExpandEnvVars(description, env)
-
-    # TODO: we shouldn't need to qualify names; we do it because
-    # currently the ninja rule namespace is global, but it really
-    # should be scoped to the subninja.
-    rule_name = self.name
-    if self.toolset == 'target':
-      rule_name += '.' + self.toolset
-    rule_name += '.' + name
-    rule_name = re.sub('[^a-zA-Z0-9_]', '_', rule_name)
-
-    # Remove variable references, but not if they refer to the magic rule
-    # variables.  This is not quite right, as it also protects these for
-    # actions, not just for rules where they are valid. Good enough.
-    protect = [ '${root}', '${dirname}', '${source}', '${ext}', '${name}' ]
-    protect = '(?!' + '|'.join(map(re.escape, protect)) + ')'
-    description = re.sub(protect + r'\$', '_', description)
-
-    # gyp dictates that commands are run from the base directory.
-    # cd into the directory before running, and adjust paths in
-    # the arguments to point to the proper locations.
-    rspfile = None
-    rspfile_content = None
-    args = [self.ExpandSpecial(arg, self.base_to_build) for arg in args]
-    if self.flavor == 'win':
-      rspfile = rule_name + '.$unique_name.rsp'
-      # The cygwin case handles this inside the bash sub-shell.
-      run_in = '' if is_cygwin else ' ' + self.build_to_base
-      if is_cygwin:
-        rspfile_content = self.msvs_settings.BuildCygwinBashCommandLine(
-            args, self.build_to_base)
-      else:
-        rspfile_content = gyp.msvs_emulation.EncodeRspFileList(args)
-      command = ('%s gyp-win-tool action-wrapper $arch ' % sys.executable +
-                 rspfile + run_in)
-    else:
-      env = self.ComputeExportEnvString(env)
-      command = gyp.common.EncodePOSIXShellList(args)
-      command = 'cd %s; ' % self.build_to_base + env + command
-
-    # GYP rules/actions express being no-ops by not touching their outputs.
-    # Avoid executing downstream dependencies in this case by specifying
-    # restat=1 to ninja.
-    self.ninja.rule(rule_name, command, description, depfile=depfile,
-                    restat=True, pool=pool,
-                    rspfile=rspfile, rspfile_content=rspfile_content)
-    self.ninja.newline()
-
-    return rule_name, args
+        if self.flavor == "win":
+            args = [
+                self.msvs_settings.ConvertVSMacros(
+                    arg, self.base_to_build, config=self.config_name
+                )
+                for arg in args
+            ]
+            description = self.msvs_settings.ConvertVSMacros(
+                description, config=self.config_name
+            )
+        elif self.flavor == "mac":
+            # |env| is an empty list on non-mac.
+            args = [gyp.xcode_emulation.ExpandEnvVars(arg, env) for arg in args]
+            description = gyp.xcode_emulation.ExpandEnvVars(description, env)
+
+        # TODO: we shouldn't need to qualify names; we do it because
+        # currently the ninja rule namespace is global, but it really
+        # should be scoped to the subninja.
+        rule_name = self.name
+        if self.toolset == "target":
+            rule_name += "." + self.toolset
+        rule_name += "." + name
+        rule_name = re.sub("[^a-zA-Z0-9_]", "_", rule_name)
+
+        # Remove variable references, but not if they refer to the magic rule
+        # variables.  This is not quite right, as it also protects these for
+        # actions, not just for rules where they are valid. Good enough.
+        protect = ["${root}", "${dirname}", "${source}", "${ext}", "${name}"]
+        protect = "(?!" + "|".join(map(re.escape, protect)) + ")"
+        description = re.sub(protect + r"\$", "_", description)
+
+        # gyp dictates that commands are run from the base directory.
+        # cd into the directory before running, and adjust paths in
+        # the arguments to point to the proper locations.
+        rspfile = None
+        rspfile_content = None
+        args = [self.ExpandSpecial(arg, self.base_to_build) for arg in args]
+        if self.flavor == "win":
+            rspfile = rule_name + ".$unique_name.rsp"
+            # The cygwin case handles this inside the bash sub-shell.
+            run_in = "" if is_cygwin else " " + self.build_to_base
+            if is_cygwin:
+                rspfile_content = self.msvs_settings.BuildCygwinBashCommandLine(
+                    args, self.build_to_base
+                )
+            else:
+                rspfile_content = gyp.msvs_emulation.EncodeRspFileList(args)
+            command = (
+                "%s gyp-win-tool action-wrapper $arch " % sys.executable
+                + rspfile
+                + run_in
+            )
+        else:
+            env = self.ComputeExportEnvString(env)
+            command = gyp.common.EncodePOSIXShellList(args)
+            command = "cd %s; " % self.build_to_base + env + command
+
+        # GYP rules/actions express being no-ops by not touching their outputs.
+        # Avoid executing downstream dependencies in this case by specifying
+        # restat=1 to ninja.
+        self.ninja.rule(
+            rule_name,
+            command,
+            description,
+            depfile=depfile,
+            restat=True,
+            pool=pool,
+            rspfile=rspfile,
+            rspfile_content=rspfile_content,
+        )
+        self.ninja.newline()
+
+        return rule_name, args
 
 
 def CalculateVariables(default_variables, params):
-  """Calculate additional variables for use in the build (called by gyp)."""
-  global generator_additional_non_configuration_keys
-  global generator_additional_path_sections
-  flavor = gyp.common.GetFlavor(params)
-  if flavor == 'mac':
-    default_variables.setdefault('OS', 'mac')
-    default_variables.setdefault('SHARED_LIB_SUFFIX', '.dylib')
-    default_variables.setdefault('SHARED_LIB_DIR',
-                                 generator_default_variables['PRODUCT_DIR'])
-    default_variables.setdefault('LIB_DIR',
-                                 generator_default_variables['PRODUCT_DIR'])
-
-    # Copy additional generator configuration data from Xcode, which is shared
-    # by the Mac Ninja generator.
-    import gyp.generator.xcode as xcode_generator
-    generator_additional_non_configuration_keys = getattr(xcode_generator,
-        'generator_additional_non_configuration_keys', [])
-    generator_additional_path_sections = getattr(xcode_generator,
-        'generator_additional_path_sections', [])
-    global generator_extra_sources_for_rules
-    generator_extra_sources_for_rules = getattr(xcode_generator,
-        'generator_extra_sources_for_rules', [])
-  elif flavor == 'win':
-    exts = gyp.MSVSUtil.TARGET_TYPE_EXT
-    default_variables.setdefault('OS', 'win')
-    default_variables['EXECUTABLE_SUFFIX'] = '.' + exts['executable']
-    default_variables['STATIC_LIB_PREFIX'] = ''
-    default_variables['STATIC_LIB_SUFFIX'] = '.' + exts['static_library']
-    default_variables['SHARED_LIB_PREFIX'] = ''
-    default_variables['SHARED_LIB_SUFFIX'] = '.' + exts['shared_library']
-
-    # Copy additional generator configuration data from VS, which is shared
-    # by the Windows Ninja generator.
-    import gyp.generator.msvs as msvs_generator
-    generator_additional_non_configuration_keys = getattr(msvs_generator,
-        'generator_additional_non_configuration_keys', [])
-    generator_additional_path_sections = getattr(msvs_generator,
-        'generator_additional_path_sections', [])
-
-    gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
-  else:
-    operating_system = flavor
-    if flavor == 'android':
-      operating_system = 'linux'  # Keep this legacy behavior for now.
-    default_variables.setdefault('OS', operating_system)
-    default_variables.setdefault('SHARED_LIB_SUFFIX', '.so')
-    default_variables.setdefault('SHARED_LIB_DIR',
-                                 os.path.join('$!PRODUCT_DIR', 'lib'))
-    default_variables.setdefault('LIB_DIR',
-                                 os.path.join('$!PRODUCT_DIR', 'obj'))
+    """Calculate additional variables for use in the build (called by gyp)."""
+    global generator_additional_non_configuration_keys
+    global generator_additional_path_sections
+    flavor = gyp.common.GetFlavor(params)
+    if flavor == "mac":
+        default_variables.setdefault("OS", "mac")
+        default_variables.setdefault("SHARED_LIB_SUFFIX", ".dylib")
+        default_variables.setdefault(
+            "SHARED_LIB_DIR", generator_default_variables["PRODUCT_DIR"]
+        )
+        default_variables.setdefault(
+            "LIB_DIR", generator_default_variables["PRODUCT_DIR"]
+        )
+
+        # Copy additional generator configuration data from Xcode, which is shared
+        # by the Mac Ninja generator.
+        import gyp.generator.xcode as xcode_generator
+
+        generator_additional_non_configuration_keys = getattr(
+            xcode_generator, "generator_additional_non_configuration_keys", []
+        )
+        generator_additional_path_sections = getattr(
+            xcode_generator, "generator_additional_path_sections", []
+        )
+        global generator_extra_sources_for_rules
+        generator_extra_sources_for_rules = getattr(
+            xcode_generator, "generator_extra_sources_for_rules", []
+        )
+    elif flavor == "win":
+        exts = gyp.MSVSUtil.TARGET_TYPE_EXT
+        default_variables.setdefault("OS", "win")
+        default_variables["EXECUTABLE_SUFFIX"] = "." + exts["executable"]
+        default_variables["STATIC_LIB_PREFIX"] = ""
+        default_variables["STATIC_LIB_SUFFIX"] = "." + exts["static_library"]
+        default_variables["SHARED_LIB_PREFIX"] = ""
+        default_variables["SHARED_LIB_SUFFIX"] = "." + exts["shared_library"]
+
+        # Copy additional generator configuration data from VS, which is shared
+        # by the Windows Ninja generator.
+        import gyp.generator.msvs as msvs_generator
+
+        generator_additional_non_configuration_keys = getattr(
+            msvs_generator, "generator_additional_non_configuration_keys", []
+        )
+        generator_additional_path_sections = getattr(
+            msvs_generator, "generator_additional_path_sections", []
+        )
+
+        gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
+    else:
+        operating_system = flavor
+        if flavor == "android":
+            operating_system = "linux"  # Keep this legacy behavior for now.
+        default_variables.setdefault("OS", operating_system)
+        default_variables.setdefault("SHARED_LIB_SUFFIX", ".so")
+        default_variables.setdefault(
+            "SHARED_LIB_DIR", os.path.join("$!PRODUCT_DIR", "lib")
+        )
+        default_variables.setdefault("LIB_DIR", os.path.join("$!PRODUCT_DIR", "obj"))
+
 
 def ComputeOutputDir(params):
-  """Returns the path from the toplevel_dir to the build output directory."""
-  # generator_dir: relative path from pwd to where make puts build files.
-  # Makes migrating from make to ninja easier, ninja doesn't put anything here.
-  generator_dir = os.path.relpath(params['options'].generator_output or '.')
+    """Returns the path from the toplevel_dir to the build output directory."""
+    # generator_dir: relative path from pwd to where make puts build files.
+    # Makes migrating from make to ninja easier, ninja doesn't put anything here.
+    generator_dir = os.path.relpath(params["options"].generator_output or ".")
 
-  # output_dir: relative path from generator_dir to the build directory.
-  output_dir = params.get('generator_flags', {}).get('output_dir', 'out')
+    # output_dir: relative path from generator_dir to the build directory.
+    output_dir = params.get("generator_flags", {}).get("output_dir", "out")
 
-  # Relative path from source root to our output files.  e.g. "out"
-  return os.path.normpath(os.path.join(generator_dir, output_dir))
+    # Relative path from source root to our output files.  e.g. "out"
+    return os.path.normpath(os.path.join(generator_dir, output_dir))
 
 
 def CalculateGeneratorInputInfo(params):
-  """Called by __init__ to initialize generator values based on params."""
-  # E.g. "out/gypfiles"
-  toplevel = params['options'].toplevel_dir
-  qualified_out_dir = os.path.normpath(os.path.join(
-      toplevel, ComputeOutputDir(params), 'gypfiles'))
-
-  global generator_filelist_paths
-  generator_filelist_paths = {
-      'toplevel': toplevel,
-      'qualified_out_dir': qualified_out_dir,
-  }
+    """Called by __init__ to initialize generator values based on params."""
+    # E.g. "out/gypfiles"
+    toplevel = params["options"].toplevel_dir
+    qualified_out_dir = os.path.normpath(
+        os.path.join(toplevel, ComputeOutputDir(params), "gypfiles")
+    )
+
+    global generator_filelist_paths
+    generator_filelist_paths = {
+        "toplevel": toplevel,
+        "qualified_out_dir": qualified_out_dir,
+    }
 
 
-def OpenOutput(path, mode='w'):
-  """Open |path| for writing, creating directories if necessary."""
-  gyp.common.EnsureDirExists(path)
-  return open(path, mode)
+def OpenOutput(path, mode="w"):
+    """Open |path| for writing, creating directories if necessary."""
+    gyp.common.EnsureDirExists(path)
+    return open(path, mode)
 
 
 def CommandWithWrapper(cmd, wrappers, prog):
-  wrapper = wrappers.get(cmd, '')
-  if wrapper:
-    return wrapper + ' ' + prog
-  return prog
+    wrapper = wrappers.get(cmd, "")
+    if wrapper:
+        return wrapper + " " + prog
+    return prog
 
 
 def GetDefaultConcurrentLinks():
-  """Returns a best-guess for a number of concurrent links."""
-  pool_size = int(os.environ.get('GYP_LINK_CONCURRENCY', 0))
-  if pool_size:
-    return pool_size
-
-  if sys.platform in ('win32', 'cygwin'):
-    import ctypes
-
-    class MEMORYSTATUSEX(ctypes.Structure):
-      _fields_ = [
-        ("dwLength", ctypes.c_ulong),
-        ("dwMemoryLoad", ctypes.c_ulong),
-        ("ullTotalPhys", ctypes.c_ulonglong),
-        ("ullAvailPhys", ctypes.c_ulonglong),
-        ("ullTotalPageFile", ctypes.c_ulonglong),
-        ("ullAvailPageFile", ctypes.c_ulonglong),
-        ("ullTotalVirtual", ctypes.c_ulonglong),
-        ("ullAvailVirtual", ctypes.c_ulonglong),
-        ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
-      ]
-
-    stat = MEMORYSTATUSEX()
-    stat.dwLength = ctypes.sizeof(stat)
-    ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
-
-    # VS 2015 uses 20% more working set than VS 2013 and can consume all RAM
-    # on a 64 GB machine.
-    mem_limit = max(1, stat.ullTotalPhys / (5 * (2 ** 30)))  # total / 5GB
-    hard_cap = max(1, int(os.environ.get('GYP_LINK_CONCURRENCY_MAX', 2**32)))
-    return min(mem_limit, hard_cap)
-  elif sys.platform.startswith('linux'):
-    if os.path.exists("/proc/meminfo"):
-      with open("/proc/meminfo") as meminfo:
-        memtotal_re = re.compile(r'^MemTotal:\s*(\d*)\s*kB')
-        for line in meminfo:
-          match = memtotal_re.match(line)
-          if not match:
-            continue
-          # Allow 8Gb per link on Linux because Gold is quite memory hungry
-          return max(1, int(match.group(1)) / (8 * (2 ** 20)))
-    return 1
-  elif sys.platform == 'darwin':
-    try:
-      avail_bytes = int(subprocess.check_output(['sysctl', '-n', 'hw.memsize']))
-      # A static library debug build of Chromium's unit_tests takes ~2.7GB, so
-      # 4GB per ld process allows for some more bloat.
-      return max(1, avail_bytes / (4 * (2 ** 30)))  # total / 4GB
-    except:
-      return 1
-  else:
-    # TODO(scottmg): Implement this for other platforms.
-    return 1
+    """Returns a best-guess for a number of concurrent links."""
+    pool_size = int(os.environ.get("GYP_LINK_CONCURRENCY", 0))
+    if pool_size:
+        return pool_size
+
+    if sys.platform in ("win32", "cygwin"):
+        import ctypes
+
+        class MEMORYSTATUSEX(ctypes.Structure):
+            _fields_ = [
+                ("dwLength", ctypes.c_ulong),
+                ("dwMemoryLoad", ctypes.c_ulong),
+                ("ullTotalPhys", ctypes.c_ulonglong),
+                ("ullAvailPhys", ctypes.c_ulonglong),
+                ("ullTotalPageFile", ctypes.c_ulonglong),
+                ("ullAvailPageFile", ctypes.c_ulonglong),
+                ("ullTotalVirtual", ctypes.c_ulonglong),
+                ("ullAvailVirtual", ctypes.c_ulonglong),
+                ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
+            ]
+
+        stat = MEMORYSTATUSEX()
+        stat.dwLength = ctypes.sizeof(stat)
+        ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
+
+        # VS 2015 uses 20% more working set than VS 2013 and can consume all RAM
+        # on a 64 GB machine.
+        mem_limit = max(1, stat.ullTotalPhys // (5 * (2 ** 30)))  # total / 5GB
+        hard_cap = max(1, int(os.environ.get("GYP_LINK_CONCURRENCY_MAX", 2 ** 32)))
+        return min(mem_limit, hard_cap)
+    elif sys.platform.startswith("linux"):
+        if os.path.exists("/proc/meminfo"):
+            with open("/proc/meminfo") as meminfo:
+                memtotal_re = re.compile(r"^MemTotal:\s*(\d*)\s*kB")
+                for line in meminfo:
+                    match = memtotal_re.match(line)
+                    if not match:
+                        continue
+                    # Allow 8Gb per link on Linux because Gold is quite memory hungry
+                    return max(1, int(match.group(1)) // (8 * (2 ** 20)))
+        return 1
+    elif sys.platform == "darwin":
+        try:
+            avail_bytes = int(subprocess.check_output(["sysctl", "-n", "hw.memsize"]))
+            # A static library debug build of Chromium's unit_tests takes ~2.7GB, so
+            # 4GB per ld process allows for some more bloat.
+            return max(1, avail_bytes // (4 * (2 ** 30)))  # total / 4GB
+        except subprocess.CalledProcessError:
+            return 1
+    else:
+        # TODO(scottmg): Implement this for other platforms.
+        return 1
 
 
 def _GetWinLinkRuleNameSuffix(embed_manifest):
-  """Returns the suffix used to select an appropriate linking rule depending on
+    """Returns the suffix used to select an appropriate linking rule depending on
   whether the manifest embedding is enabled."""
-  return '_embed' if embed_manifest else ''
+    return "_embed" if embed_manifest else ""
 
 
 def _AddWinLinkRules(master_ninja, embed_manifest):
-  """Adds link rules for Windows platform to |master_ninja|."""
-  def FullLinkCommand(ldcmd, out, binary_type):
-    resource_name = {
-      'exe': '1',
-      'dll': '2',
-    }[binary_type]
-    return '%(python)s gyp-win-tool link-with-manifests $arch %(embed)s ' \
-           '%(out)s "%(ldcmd)s" %(resname)s $mt $rc "$intermediatemanifest" ' \
-           '$manifests' % {
-               'python': sys.executable,
-               'out': out,
-               'ldcmd': ldcmd,
-               'resname': resource_name,
-               'embed': embed_manifest }
-  rule_name_suffix = _GetWinLinkRuleNameSuffix(embed_manifest)
-  use_separate_mspdbsrv = (
-      int(os.environ.get('GYP_USE_SEPARATE_MSPDBSRV', '0')) != 0)
-  dlldesc = 'LINK%s(DLL) $binary' % rule_name_suffix.upper()
-  dllcmd = ('%s gyp-win-tool link-wrapper $arch %s '
-            '$ld /nologo $implibflag /DLL /OUT:$binary '
-            '@$binary.rsp' % (sys.executable, use_separate_mspdbsrv))
-  dllcmd = FullLinkCommand(dllcmd, '$binary', 'dll')
-  master_ninja.rule('solink' + rule_name_suffix,
-                    description=dlldesc, command=dllcmd,
-                    rspfile='$binary.rsp',
-                    rspfile_content='$libs $in_newline $ldflags',
-                    restat=True,
-                    pool='link_pool')
-  master_ninja.rule('solink_module' + rule_name_suffix,
-                    description=dlldesc, command=dllcmd,
-                    rspfile='$binary.rsp',
-                    rspfile_content='$libs $in_newline $ldflags',
-                    restat=True,
-                    pool='link_pool')
-  # Note that ldflags goes at the end so that it has the option of
-  # overriding default settings earlier in the command line.
-  exe_cmd = ('%s gyp-win-tool link-wrapper $arch %s '
-             '$ld /nologo /OUT:$binary @$binary.rsp' %
-              (sys.executable, use_separate_mspdbsrv))
-  exe_cmd = FullLinkCommand(exe_cmd, '$binary', 'exe')
-  master_ninja.rule('link' + rule_name_suffix,
-                    description='LINK%s $binary' % rule_name_suffix.upper(),
-                    command=exe_cmd,
-                    rspfile='$binary.rsp',
-                    rspfile_content='$in_newline $libs $ldflags',
-                    pool='link_pool')
-
-
-def GenerateOutputForConfig(target_list, target_dicts, data, params,
-                            config_name):
-  options = params['options']
-  flavor = gyp.common.GetFlavor(params)
-  generator_flags = params.get('generator_flags', {})
-
-  # build_dir: relative path from source root to our output files.
-  # e.g. "out/Debug"
-  build_dir = os.path.normpath(
-      os.path.join(ComputeOutputDir(params), config_name))
-
-  toplevel_build = os.path.join(options.toplevel_dir, build_dir)
-
-  master_ninja_file = OpenOutput(os.path.join(toplevel_build, 'build.ninja'))
-  master_ninja = ninja_syntax.Writer(master_ninja_file, width=120)
-
-  # Put build-time support tools in out/{config_name}.
-  gyp.common.CopyTool(flavor, toplevel_build, generator_flags)
-
-  # Grab make settings for CC/CXX.
-  # The rules are
-  # - The priority from low to high is gcc/g++, the 'make_global_settings' in
-  #   gyp, the environment variable.
-  # - If there is no 'make_global_settings' for CC.host/CXX.host or
-  #   'CC_host'/'CXX_host' environment variable, cc_host/cxx_host should be set
-  #   to cc/cxx.
-  if flavor == 'win':
-    ar = 'lib.exe'
-    # cc and cxx must be set to the correct architecture by overriding with one
-    # of cl_x86 or cl_x64 below.
-    cc = 'UNSET'
-    cxx = 'UNSET'
-    ld = 'link.exe'
-    ld_host = '$ld'
-  else:
-    ar = 'ar'
-    cc = 'cc'
-    cxx = 'c++'
-    ld = '$cc'
-    ldxx = '$cxx'
-    ld_host = '$cc_host'
-    ldxx_host = '$cxx_host'
-
-  ar_host = ar
-  cc_host = None
-  cxx_host = None
-  cc_host_global_setting = None
-  cxx_host_global_setting = None
-  clang_cl = None
-  nm = 'nm'
-  nm_host = 'nm'
-  readelf = 'readelf'
-  readelf_host = 'readelf'
-
-  build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
-  make_global_settings = data[build_file].get('make_global_settings', [])
-  build_to_root = gyp.common.InvertRelativePath(build_dir,
-                                                options.toplevel_dir)
-  wrappers = {}
-  for key, value in make_global_settings:
-    if key == 'AR':
-      ar = os.path.join(build_to_root, value)
-    if key == 'AR.host':
-      ar_host = os.path.join(build_to_root, value)
-    if key == 'CC':
-      cc = os.path.join(build_to_root, value)
-      if cc.endswith('clang-cl'):
-        clang_cl = cc
-    if key == 'CXX':
-      cxx = os.path.join(build_to_root, value)
-    if key == 'CC.host':
-      cc_host = os.path.join(build_to_root, value)
-      cc_host_global_setting = value
-    if key == 'CXX.host':
-      cxx_host = os.path.join(build_to_root, value)
-      cxx_host_global_setting = value
-    if key == 'LD':
-      ld = os.path.join(build_to_root, value)
-    if key == 'LD.host':
-      ld_host = os.path.join(build_to_root, value)
-    if key == 'LDXX':
-      ldxx = os.path.join(build_to_root, value)
-    if key == 'LDXX.host':
-      ldxx_host = os.path.join(build_to_root, value)
-    if key == 'NM':
-      nm = os.path.join(build_to_root, value)
-    if key == 'NM.host':
-      nm_host = os.path.join(build_to_root, value)
-    if key == 'READELF':
-      readelf = os.path.join(build_to_root, value)
-    if key == 'READELF.host':
-      readelf_host = os.path.join(build_to_root, value)
-    if key.endswith('_wrapper'):
-      wrappers[key[:-len('_wrapper')]] = os.path.join(build_to_root, value)
-
-  # Support wrappers from environment variables too.
-  for key, value in os.environ.items():
-    if key.lower().endswith('_wrapper'):
-      key_prefix = key[:-len('_wrapper')]
-      key_prefix = re.sub(r'\.HOST$', '.host', key_prefix)
-      wrappers[key_prefix] = os.path.join(build_to_root, value)
-
-  mac_toolchain_dir = generator_flags.get('mac_toolchain_dir', None)
-  if mac_toolchain_dir:
-    wrappers['LINK'] = "export DEVELOPER_DIR='%s' &&" % mac_toolchain_dir
-
-  if flavor == 'win':
-    configs = [target_dicts[qualified_target]['configurations'][config_name]
-               for qualified_target in target_list]
-    shared_system_includes = None
-    if not generator_flags.get('ninja_use_custom_environment_files', 0):
-      shared_system_includes = \
-          gyp.msvs_emulation.ExtractSharedMSVSSystemIncludes(
-              configs, generator_flags)
-    cl_paths = gyp.msvs_emulation.GenerateEnvironmentFiles(
-        toplevel_build, generator_flags, shared_system_includes, OpenOutput)
-    for arch, path in sorted(cl_paths.items()):
-      if clang_cl:
-        # If we have selected clang-cl, use that instead.
-        path = clang_cl
-      command = CommandWithWrapper('CC', wrappers,
-          QuoteShellArgument(path, 'win'))
-      if clang_cl:
-        # Use clang-cl to cross-compile for x86 or x86_64.
-        command += (' -m32' if arch == 'x86' else ' -m64')
-      master_ninja.variable('cl_' + arch, command)
-
-  cc = GetEnvironFallback(['CC_target', 'CC'], cc)
-  master_ninja.variable('cc', CommandWithWrapper('CC', wrappers, cc))
-  cxx = GetEnvironFallback(['CXX_target', 'CXX'], cxx)
-  master_ninja.variable('cxx', CommandWithWrapper('CXX', wrappers, cxx))
-
-  if flavor == 'win':
-    master_ninja.variable('ld', ld)
-    master_ninja.variable('idl', 'midl.exe')
-    master_ninja.variable('ar', ar)
-    master_ninja.variable('rc', 'rc.exe')
-    master_ninja.variable('ml_x86', 'ml.exe')
-    master_ninja.variable('ml_x64', 'ml64.exe')
-    master_ninja.variable('mt', 'mt.exe')
-  else:
-    master_ninja.variable('ld', CommandWithWrapper('LINK', wrappers, ld))
-    master_ninja.variable('ldxx', CommandWithWrapper('LINK', wrappers, ldxx))
-    master_ninja.variable('ar', GetEnvironFallback(['AR_target', 'AR'], ar))
-    if flavor != 'mac':
-      # Mac does not use readelf/nm for .TOC generation, so avoiding polluting
-      # the master ninja with extra unused variables.
-      master_ninja.variable(
-          'nm', GetEnvironFallback(['NM_target', 'NM'], nm))
-      master_ninja.variable(
-          'readelf', GetEnvironFallback(['READELF_target', 'READELF'], readelf))
-
-  if generator_supports_multiple_toolsets:
-    if not cc_host:
-      cc_host = cc
-    if not cxx_host:
-      cxx_host = cxx
-
-    master_ninja.variable('ar_host', GetEnvironFallback(['AR_host'], ar_host))
-    master_ninja.variable('nm_host', GetEnvironFallback(['NM_host'], nm_host))
-    master_ninja.variable('readelf_host',
-                          GetEnvironFallback(['READELF_host'], readelf_host))
-    cc_host = GetEnvironFallback(['CC_host'], cc_host)
-    cxx_host = GetEnvironFallback(['CXX_host'], cxx_host)
-
-    # The environment variable could be used in 'make_global_settings', like
-    # ['CC.host', '$(CC)'] or ['CXX.host', '$(CXX)'], transform them here.
-    if '$(CC)' in cc_host and cc_host_global_setting:
-      cc_host = cc_host_global_setting.replace('$(CC)', cc)
-    if '$(CXX)' in cxx_host and cxx_host_global_setting:
-      cxx_host = cxx_host_global_setting.replace('$(CXX)', cxx)
-    master_ninja.variable('cc_host',
-                          CommandWithWrapper('CC.host', wrappers, cc_host))
-    master_ninja.variable('cxx_host',
-                          CommandWithWrapper('CXX.host', wrappers, cxx_host))
-    if flavor == 'win':
-      master_ninja.variable('ld_host', ld_host)
-      master_ninja.variable('ldxx_host', ldxx_host)
-    else:
-      master_ninja.variable('ld_host', CommandWithWrapper(
-          'LINK', wrappers, ld_host))
-      master_ninja.variable('ldxx_host', CommandWithWrapper(
-          'LINK', wrappers, ldxx_host))
-
-  master_ninja.newline()
-
-  master_ninja.pool('link_pool', depth=GetDefaultConcurrentLinks())
-  master_ninja.newline()
-
-  deps = 'msvc' if flavor == 'win' else 'gcc'
-
-  if flavor != 'win':
-    master_ninja.rule(
-      'cc',
-      description='CC $out',
-      command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_c '
-              '$cflags_pch_c -c $in -o $out'),
-      depfile='$out.d',
-      deps=deps)
-    master_ninja.rule(
-      'cc_s',
-      description='CC $out',
-      command=('$cc $defines $includes $cflags $cflags_c '
-              '$cflags_pch_c -c $in -o $out'))
-    master_ninja.rule(
-      'cxx',
-      description='CXX $out',
-      command=('$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_cc '
-              '$cflags_pch_cc -c $in -o $out'),
-      depfile='$out.d',
-      deps=deps)
-  else:
-    # TODO(scottmg) Separate pdb names is a test to see if it works around
-    # http://crbug.com/142362. It seems there's a race between the creation of
-    # the .pdb by the precompiled header step for .cc and the compilation of
-    # .c files. This should be handled by mspdbsrv, but rarely errors out with
-    #   c1xx : fatal error C1033: cannot open program database
-    # By making the rules target separate pdb files this might be avoided.
-    cc_command = ('ninja -t msvc -e $arch ' +
-                  '-- '
-                  '$cc /nologo /showIncludes /FC '
-                  '@$out.rsp /c $in /Fo$out /Fd$pdbname_c ')
-    cxx_command = ('ninja -t msvc -e $arch ' +
-                   '-- '
-                   '$cxx /nologo /showIncludes /FC '
-                   '@$out.rsp /c $in /Fo$out /Fd$pdbname_cc ')
-    master_ninja.rule(
-      'cc',
-      description='CC $out',
-      command=cc_command,
-      rspfile='$out.rsp',
-      rspfile_content='$defines $includes $cflags $cflags_c',
-      deps=deps)
-    master_ninja.rule(
-      'cxx',
-      description='CXX $out',
-      command=cxx_command,
-      rspfile='$out.rsp',
-      rspfile_content='$defines $includes $cflags $cflags_cc',
-      deps=deps)
-    master_ninja.rule(
-      'idl',
-      description='IDL $in',
-      command=('%s gyp-win-tool midl-wrapper $arch $outdir '
-               '$tlb $h $dlldata $iid $proxy $in '
-               '$midl_includes $idlflags' % sys.executable))
-    master_ninja.rule(
-      'rc',
-      description='RC $in',
-      # Note: $in must be last otherwise rc.exe complains.
-      command=('%s gyp-win-tool rc-wrapper '
-               '$arch $rc $defines $resource_includes $rcflags /fo$out $in' %
-               sys.executable))
-    master_ninja.rule(
-      'asm',
-      description='ASM $out',
-      command=('%s gyp-win-tool asm-wrapper '
-               '$arch $asm $defines $includes $asmflags /c /Fo $out $in' %
-               sys.executable))
-
-  if flavor != 'mac' and flavor != 'win':
-    master_ninja.rule(
-      'alink',
-      description='AR $out',
-      command='rm -f $out && $ar rcs $arflags $out $in')
-    master_ninja.rule(
-      'alink_thin',
-      description='AR $out',
-      command='rm -f $out && $ar rcsT $arflags $out $in')
-
-    # This allows targets that only need to depend on $lib's API to declare an
-    # order-only dependency on $lib.TOC and avoid relinking such downstream
-    # dependencies when $lib changes only in non-public ways.
-    # The resulting string leaves an uninterpolated %{suffix} which
-    # is used in the final substitution below.
-    mtime_preserving_solink_base = (
-        'if [ ! -e $lib -o ! -e $lib.TOC ]; then '
-        '%(solink)s && %(extract_toc)s > $lib.TOC; else '
-        '%(solink)s && %(extract_toc)s > $lib.tmp && '
-        'if ! cmp -s $lib.tmp $lib.TOC; then mv $lib.tmp $lib.TOC ; '
-        'fi; fi'
-        % { 'solink':
-              '$ld -shared $ldflags -o $lib -Wl,-soname=$soname %(suffix)s',
-            'extract_toc':
-              ('{ $readelf -d $lib | grep SONAME ; '
-               '$nm -gD -f p $lib | cut -f1-2 -d\' \'; }')})
-
-    master_ninja.rule(
-      'solink',
-      description='SOLINK $lib',
-      restat=True,
-      command=mtime_preserving_solink_base % {'suffix': '@$link_file_list'},
-      rspfile='$link_file_list',
-      rspfile_content=
-          '-Wl,--whole-archive $in $solibs -Wl,--no-whole-archive $libs',
-      pool='link_pool')
-    master_ninja.rule(
-      'solink_module',
-      description='SOLINK(module) $lib',
-      restat=True,
-      command=mtime_preserving_solink_base % {'suffix': '@$link_file_list'},
-      rspfile='$link_file_list',
-      rspfile_content='-Wl,--start-group $in $solibs $libs -Wl,--end-group',
-      pool='link_pool')
-    master_ninja.rule(
-      'link',
-      description='LINK $out',
-      command=('$ld $ldflags -o $out '
-               '-Wl,--start-group $in $solibs $libs -Wl,--end-group'),
-      pool='link_pool')
-  elif flavor == 'win':
+    """Adds link rules for Windows platform to |master_ninja|."""
+
+    def FullLinkCommand(ldcmd, out, binary_type):
+        resource_name = {"exe": "1", "dll": "2"}[binary_type]
+        return (
+            "%(python)s gyp-win-tool link-with-manifests $arch %(embed)s "
+            '%(out)s "%(ldcmd)s" %(resname)s $mt $rc "$intermediatemanifest" '
+            "$manifests"
+            % {
+                "python": sys.executable,
+                "out": out,
+                "ldcmd": ldcmd,
+                "resname": resource_name,
+                "embed": embed_manifest,
+            }
+        )
+
+    rule_name_suffix = _GetWinLinkRuleNameSuffix(embed_manifest)
+    use_separate_mspdbsrv = int(os.environ.get("GYP_USE_SEPARATE_MSPDBSRV", "0")) != 0
+    dlldesc = "LINK%s(DLL) $binary" % rule_name_suffix.upper()
+    dllcmd = (
+        "%s gyp-win-tool link-wrapper $arch %s "
+        "$ld /nologo $implibflag /DLL /OUT:$binary "
+        "@$binary.rsp" % (sys.executable, use_separate_mspdbsrv)
+    )
+    dllcmd = FullLinkCommand(dllcmd, "$binary", "dll")
     master_ninja.rule(
-        'alink',
-        description='LIB $out',
-        command=('%s gyp-win-tool link-wrapper $arch False '
-                 '$ar /nologo /ignore:4221 /OUT:$out @$out.rsp' %
-                 sys.executable),
-        rspfile='$out.rsp',
-        rspfile_content='$in_newline $libflags')
-    _AddWinLinkRules(master_ninja, embed_manifest=True)
-    _AddWinLinkRules(master_ninja, embed_manifest=False)
-  else:
+        "solink" + rule_name_suffix,
+        description=dlldesc,
+        command=dllcmd,
+        rspfile="$binary.rsp",
+        rspfile_content="$libs $in_newline $ldflags",
+        restat=True,
+        pool="link_pool",
+    )
     master_ninja.rule(
-      'objc',
-      description='OBJC $out',
-      command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_objc '
-               '$cflags_pch_objc -c $in -o $out'),
-      depfile='$out.d',
-      deps=deps)
+        "solink_module" + rule_name_suffix,
+        description=dlldesc,
+        command=dllcmd,
+        rspfile="$binary.rsp",
+        rspfile_content="$libs $in_newline $ldflags",
+        restat=True,
+        pool="link_pool",
+    )
+    # Note that ldflags goes at the end so that it has the option of
+    # overriding default settings earlier in the command line.
+    exe_cmd = (
+        "%s gyp-win-tool link-wrapper $arch %s "
+        "$ld /nologo /OUT:$binary @$binary.rsp"
+        % (sys.executable, use_separate_mspdbsrv)
+    )
+    exe_cmd = FullLinkCommand(exe_cmd, "$binary", "exe")
     master_ninja.rule(
-      'objcxx',
-      description='OBJCXX $out',
-      command=('$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_objcc '
-               '$cflags_pch_objcc -c $in -o $out'),
-      depfile='$out.d',
-      deps=deps)
-    master_ninja.rule(
-      'alink',
-      description='LIBTOOL-STATIC $out, POSTBUILDS',
-      command='rm -f $out && '
-              './gyp-mac-tool filter-libtool libtool $libtool_flags '
-              '-static -o $out $in'
-              '$postbuilds')
-    master_ninja.rule(
-      'lipo',
-      description='LIPO $out, POSTBUILDS',
-      command='rm -f $out && lipo -create $in -output $out$postbuilds')
-    master_ninja.rule(
-      'solipo',
-      description='SOLIPO $out, POSTBUILDS',
-      command=(
-          'rm -f $lib $lib.TOC && lipo -create $in -output $lib$postbuilds &&'
-          '%(extract_toc)s > $lib.TOC'
-          % { 'extract_toc':
-                '{ otool -l $lib | grep LC_ID_DYLIB -A 5; '
-                'nm -gP $lib | cut -f1-2 -d\' \' | grep -v U$$; true; }'}))
-
-
-    # Record the public interface of $lib in $lib.TOC. See the corresponding
-    # comment in the posix section above for details.
-    solink_base = '$ld %(type)s $ldflags -o $lib %(suffix)s'
-    mtime_preserving_solink_base = (
-        'if [ ! -e $lib -o ! -e $lib.TOC ] || '
-             # Always force dependent targets to relink if this library
-             # reexports something. Handling this correctly would require
-             # recursive TOC dumping but this is rare in practice, so punt.
-             'otool -l $lib | grep -q LC_REEXPORT_DYLIB ; then '
-          '%(solink)s && %(extract_toc)s > $lib.TOC; '
-        'else '
-          '%(solink)s && %(extract_toc)s > $lib.tmp && '
-          'if ! cmp -s $lib.tmp $lib.TOC; then '
-            'mv $lib.tmp $lib.TOC ; '
-          'fi; '
-        'fi'
-        % { 'solink': solink_base,
-            'extract_toc':
-              '{ otool -l $lib | grep LC_ID_DYLIB -A 5; '
-              'nm -gP $lib | cut -f1-2 -d\' \' | grep -v U$$; true; }'})
-
-
-    solink_suffix = '@$link_file_list$postbuilds'
-    master_ninja.rule(
-      'solink',
-      description='SOLINK $lib, POSTBUILDS',
-      restat=True,
-      command=mtime_preserving_solink_base % {'suffix': solink_suffix,
-                                              'type': '-shared'},
-      rspfile='$link_file_list',
-      rspfile_content='$in $solibs $libs',
-      pool='link_pool')
-    master_ninja.rule(
-      'solink_notoc',
-      description='SOLINK $lib, POSTBUILDS',
-      restat=True,
-      command=solink_base % {'suffix':solink_suffix, 'type': '-shared'},
-      rspfile='$link_file_list',
-      rspfile_content='$in $solibs $libs',
-      pool='link_pool')
-
-    master_ninja.rule(
-      'solink_module',
-      description='SOLINK(module) $lib, POSTBUILDS',
-      restat=True,
-      command=mtime_preserving_solink_base % {'suffix': solink_suffix,
-                                              'type': '-bundle'},
-      rspfile='$link_file_list',
-      rspfile_content='$in $solibs $libs',
-      pool='link_pool')
-    master_ninja.rule(
-      'solink_module_notoc',
-      description='SOLINK(module) $lib, POSTBUILDS',
-      restat=True,
-      command=solink_base % {'suffix': solink_suffix, 'type': '-bundle'},
-      rspfile='$link_file_list',
-      rspfile_content='$in $solibs $libs',
-      pool='link_pool')
-
-    master_ninja.rule(
-      'link',
-      description='LINK $out, POSTBUILDS',
-      command=('$ld $ldflags -o $out '
-               '$in $solibs $libs$postbuilds'),
-      pool='link_pool')
-    master_ninja.rule(
-      'preprocess_infoplist',
-      description='PREPROCESS INFOPLIST $out',
-      command=('$cc -E -P -Wno-trigraphs -x c $defines $in -o $out && '
-               'plutil -convert xml1 $out $out'))
-    master_ninja.rule(
-      'copy_infoplist',
-      description='COPY INFOPLIST $in',
-      command='$env ./gyp-mac-tool copy-info-plist $in $out $binary $keys')
-    master_ninja.rule(
-      'merge_infoplist',
-      description='MERGE INFOPLISTS $in',
-      command='$env ./gyp-mac-tool merge-info-plist $out $in')
-    master_ninja.rule(
-      'compile_xcassets',
-      description='COMPILE XCASSETS $in',
-      command='$env ./gyp-mac-tool compile-xcassets $keys $in')
-    master_ninja.rule(
-      'compile_ios_framework_headers',
-      description='COMPILE HEADER MAPS AND COPY FRAMEWORK HEADERS $in',
-      command='$env ./gyp-mac-tool compile-ios-framework-header-map $out '
-              '$framework $in && $env ./gyp-mac-tool '
-              'copy-ios-framework-headers $framework $copy_headers')
-    master_ninja.rule(
-      'mac_tool',
-      description='MACTOOL $mactool_cmd $in',
-      command='$env ./gyp-mac-tool $mactool_cmd $in $out $binary')
-    master_ninja.rule(
-      'package_framework',
-      description='PACKAGE FRAMEWORK $out, POSTBUILDS',
-      command='./gyp-mac-tool package-framework $out $version$postbuilds '
-              '&& touch $out')
-    master_ninja.rule(
-      'package_ios_framework',
-      description='PACKAGE IOS FRAMEWORK $out, POSTBUILDS',
-      command='./gyp-mac-tool package-ios-framework $out $postbuilds '
-              '&& touch $out')
-  if flavor == 'win':
-    master_ninja.rule(
-      'stamp',
-      description='STAMP $out',
-      command='%s gyp-win-tool stamp $out' % sys.executable)
-  else:
-    master_ninja.rule(
-      'stamp',
-      description='STAMP $out',
-      command='${postbuilds}touch $out')
-  if flavor == 'win':
-    master_ninja.rule(
-      'copy',
-      description='COPY $in $out',
-      command='%s gyp-win-tool recursive-mirror $in $out' % sys.executable)
-  elif flavor == 'zos':
-    master_ninja.rule(
-      'copy',
-      description='COPY $in $out',
-      command='rm -rf $out && cp -fRP $in $out')
-  else:
-    master_ninja.rule(
-      'copy',
-      description='COPY $in $out',
-      command='ln -f $in $out 2>/dev/null || (rm -rf $out && cp -af $in $out)')
-  master_ninja.newline()
-
-  all_targets = set()
-  for build_file in params['build_files']:
-    for target in gyp.common.AllTargets(target_list,
-                                        target_dicts,
-                                        os.path.normpath(build_file)):
-      all_targets.add(target)
-  all_outputs = set()
-
-  # target_outputs is a map from qualified target name to a Target object.
-  target_outputs = {}
-  # target_short_names is a map from target short name to a list of Target
-  # objects.
-  target_short_names = {}
-
-  # short name of targets that were skipped because they didn't contain anything
-  # interesting.
-  # NOTE: there may be overlap between this an non_empty_target_names.
-  empty_target_names = set()
-
-  # Set of non-empty short target names.
-  # NOTE: there may be overlap between this an empty_target_names.
-  non_empty_target_names = set()
-
-  for qualified_target in target_list:
-    # qualified_target is like: third_party/icu/icu.gyp:icui18n#target
-    build_file, name, toolset = \
-        gyp.common.ParseQualifiedTarget(qualified_target)
-
-    this_make_global_settings = data[build_file].get('make_global_settings', [])
-    assert make_global_settings == this_make_global_settings, (
-        "make_global_settings needs to be the same for all targets. %s vs. %s" %
-        (this_make_global_settings, make_global_settings))
-
-    spec = target_dicts[qualified_target]
-    if flavor == 'mac':
-      gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
-
-    # If build_file is a symlink, we must not follow it because there's a chance
-    # it could point to a path above toplevel_dir, and we cannot correctly deal
-    # with that case at the moment.
-    build_file = gyp.common.RelativePath(build_file, options.toplevel_dir,
-                                         False)
-
-    qualified_target_for_hash = gyp.common.QualifiedTarget(build_file, name,
-                                                           toolset)
-    qualified_target_for_hash = qualified_target_for_hash.encode('utf-8')
-    hash_for_rules = hashlib.md5(qualified_target_for_hash).hexdigest()
-
-    base_path = os.path.dirname(build_file)
-    obj = 'obj'
-    if toolset != 'target':
-      obj += '.' + toolset
-    output_file = os.path.join(obj, base_path, name + '.ninja')
-
-    ninja_output = StringIO()
-    writer = NinjaWriter(hash_for_rules, target_outputs, base_path, build_dir,
-                         ninja_output,
-                         toplevel_build, output_file,
-                         flavor, toplevel_dir=options.toplevel_dir)
-
-    target = writer.WriteSpec(spec, config_name, generator_flags)
-
-    if ninja_output.tell() > 0:
-      # Only create files for ninja files that actually have contents.
-      with OpenOutput(os.path.join(toplevel_build, output_file)) as ninja_file:
-        ninja_file.write(ninja_output.getvalue())
-      ninja_output.close()
-      master_ninja.subninja(output_file)
-
-    if target:
-      if name != target.FinalOutput() and spec['toolset'] == 'target':
-        target_short_names.setdefault(name, []).append(target)
-      target_outputs[qualified_target] = target
-      if qualified_target in all_targets:
-        all_outputs.add(target.FinalOutput())
-      non_empty_target_names.add(name)
+        "link" + rule_name_suffix,
+        description="LINK%s $binary" % rule_name_suffix.upper(),
+        command=exe_cmd,
+        rspfile="$binary.rsp",
+        rspfile_content="$in_newline $libs $ldflags",
+        pool="link_pool",
+    )
+
+
+def GenerateOutputForConfig(target_list, target_dicts, data, params, config_name):
+    options = params["options"]
+    flavor = gyp.common.GetFlavor(params)
+    generator_flags = params.get("generator_flags", {})
+
+    # build_dir: relative path from source root to our output files.
+    # e.g. "out/Debug"
+    build_dir = os.path.normpath(os.path.join(ComputeOutputDir(params), config_name))
+
+    toplevel_build = os.path.join(options.toplevel_dir, build_dir)
+
+    master_ninja_file = OpenOutput(os.path.join(toplevel_build, "build.ninja"))
+    master_ninja = ninja_syntax.Writer(master_ninja_file, width=120)
+
+    # Put build-time support tools in out/{config_name}.
+    gyp.common.CopyTool(flavor, toplevel_build, generator_flags)
+
+    # Grab make settings for CC/CXX.
+    # The rules are
+    # - The priority from low to high is gcc/g++, the 'make_global_settings' in
+    #   gyp, the environment variable.
+    # - If there is no 'make_global_settings' for CC.host/CXX.host or
+    #   'CC_host'/'CXX_host' environment variable, cc_host/cxx_host should be set
+    #   to cc/cxx.
+    if flavor == "win":
+        ar = "lib.exe"
+        # cc and cxx must be set to the correct architecture by overriding with one
+        # of cl_x86 or cl_x64 below.
+        cc = "UNSET"
+        cxx = "UNSET"
+        ld = "link.exe"
+        ld_host = "$ld"
+    else:
+        ar = "ar"
+        cc = "cc"
+        cxx = "c++"
+        ld = "$cc"
+        ldxx = "$cxx"
+        ld_host = "$cc_host"
+        ldxx_host = "$cxx_host"
+
+    ar_host = ar
+    cc_host = None
+    cxx_host = None
+    cc_host_global_setting = None
+    cxx_host_global_setting = None
+    clang_cl = None
+    nm = "nm"
+    nm_host = "nm"
+    readelf = "readelf"
+    readelf_host = "readelf"
+
+    build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
+    make_global_settings = data[build_file].get("make_global_settings", [])
+    build_to_root = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
+    wrappers = {}
+    for key, value in make_global_settings:
+        if key == "AR":
+            ar = os.path.join(build_to_root, value)
+        if key == "AR.host":
+            ar_host = os.path.join(build_to_root, value)
+        if key == "CC":
+            cc = os.path.join(build_to_root, value)
+            if cc.endswith("clang-cl"):
+                clang_cl = cc
+        if key == "CXX":
+            cxx = os.path.join(build_to_root, value)
+        if key == "CC.host":
+            cc_host = os.path.join(build_to_root, value)
+            cc_host_global_setting = value
+        if key == "CXX.host":
+            cxx_host = os.path.join(build_to_root, value)
+            cxx_host_global_setting = value
+        if key == "LD":
+            ld = os.path.join(build_to_root, value)
+        if key == "LD.host":
+            ld_host = os.path.join(build_to_root, value)
+        if key == "LDXX":
+            ldxx = os.path.join(build_to_root, value)
+        if key == "LDXX.host":
+            ldxx_host = os.path.join(build_to_root, value)
+        if key == "NM":
+            nm = os.path.join(build_to_root, value)
+        if key == "NM.host":
+            nm_host = os.path.join(build_to_root, value)
+        if key == "READELF":
+            readelf = os.path.join(build_to_root, value)
+        if key == "READELF.host":
+            readelf_host = os.path.join(build_to_root, value)
+        if key.endswith("_wrapper"):
+            wrappers[key[: -len("_wrapper")]] = os.path.join(build_to_root, value)
+
+    # Support wrappers from environment variables too.
+    for key, value in os.environ.items():
+        if key.lower().endswith("_wrapper"):
+            key_prefix = key[: -len("_wrapper")]
+            key_prefix = re.sub(r"\.HOST$", ".host", key_prefix)
+            wrappers[key_prefix] = os.path.join(build_to_root, value)
+
+    mac_toolchain_dir = generator_flags.get("mac_toolchain_dir", None)
+    if mac_toolchain_dir:
+        wrappers["LINK"] = "export DEVELOPER_DIR='%s' &&" % mac_toolchain_dir
+
+    if flavor == "win":
+        configs = [
+            target_dicts[qualified_target]["configurations"][config_name]
+            for qualified_target in target_list
+        ]
+        shared_system_includes = None
+        if not generator_flags.get("ninja_use_custom_environment_files", 0):
+            shared_system_includes = gyp.msvs_emulation.ExtractSharedMSVSSystemIncludes(
+                configs, generator_flags
+            )
+        cl_paths = gyp.msvs_emulation.GenerateEnvironmentFiles(
+            toplevel_build, generator_flags, shared_system_includes, OpenOutput
+        )
+        for arch, path in sorted(cl_paths.items()):
+            if clang_cl:
+                # If we have selected clang-cl, use that instead.
+                path = clang_cl
+            command = CommandWithWrapper(
+                "CC", wrappers, QuoteShellArgument(path, "win")
+            )
+            if clang_cl:
+                # Use clang-cl to cross-compile for x86 or x86_64.
+                command += " -m32" if arch == "x86" else " -m64"
+            master_ninja.variable("cl_" + arch, command)
+
+    cc = GetEnvironFallback(["CC_target", "CC"], cc)
+    master_ninja.variable("cc", CommandWithWrapper("CC", wrappers, cc))
+    cxx = GetEnvironFallback(["CXX_target", "CXX"], cxx)
+    master_ninja.variable("cxx", CommandWithWrapper("CXX", wrappers, cxx))
+
+    if flavor == "win":
+        master_ninja.variable("ld", ld)
+        master_ninja.variable("idl", "midl.exe")
+        master_ninja.variable("ar", ar)
+        master_ninja.variable("rc", "rc.exe")
+        master_ninja.variable("ml_x86", "ml.exe")
+        master_ninja.variable("ml_x64", "ml64.exe")
+        master_ninja.variable("mt", "mt.exe")
     else:
-      empty_target_names.add(name)
+        master_ninja.variable("ld", CommandWithWrapper("LINK", wrappers, ld))
+        master_ninja.variable("ldxx", CommandWithWrapper("LINK", wrappers, ldxx))
+        master_ninja.variable("ar", GetEnvironFallback(["AR_target", "AR"], ar))
+        if flavor != "mac":
+            # Mac does not use readelf/nm for .TOC generation, so avoiding polluting
+            # the master ninja with extra unused variables.
+            master_ninja.variable("nm", GetEnvironFallback(["NM_target", "NM"], nm))
+            master_ninja.variable(
+                "readelf", GetEnvironFallback(["READELF_target", "READELF"], readelf)
+            )
+
+    if generator_supports_multiple_toolsets:
+        if not cc_host:
+            cc_host = cc
+        if not cxx_host:
+            cxx_host = cxx
+
+        master_ninja.variable("ar_host", GetEnvironFallback(["AR_host"], ar_host))
+        master_ninja.variable("nm_host", GetEnvironFallback(["NM_host"], nm_host))
+        master_ninja.variable(
+            "readelf_host", GetEnvironFallback(["READELF_host"], readelf_host)
+        )
+        cc_host = GetEnvironFallback(["CC_host"], cc_host)
+        cxx_host = GetEnvironFallback(["CXX_host"], cxx_host)
+
+        # The environment variable could be used in 'make_global_settings', like
+        # ['CC.host', '$(CC)'] or ['CXX.host', '$(CXX)'], transform them here.
+        if "$(CC)" in cc_host and cc_host_global_setting:
+            cc_host = cc_host_global_setting.replace("$(CC)", cc)
+        if "$(CXX)" in cxx_host and cxx_host_global_setting:
+            cxx_host = cxx_host_global_setting.replace("$(CXX)", cxx)
+        master_ninja.variable(
+            "cc_host", CommandWithWrapper("CC.host", wrappers, cc_host)
+        )
+        master_ninja.variable(
+            "cxx_host", CommandWithWrapper("CXX.host", wrappers, cxx_host)
+        )
+        if flavor == "win":
+            master_ninja.variable("ld_host", ld_host)
+            master_ninja.variable("ldxx_host", ldxx_host)
+        else:
+            master_ninja.variable(
+                "ld_host", CommandWithWrapper("LINK", wrappers, ld_host)
+            )
+            master_ninja.variable(
+                "ldxx_host", CommandWithWrapper("LINK", wrappers, ldxx_host)
+            )
 
-  if target_short_names:
-    # Write a short name to build this target.  This benefits both the
-    # "build chrome" case as well as the gyp tests, which expect to be
-    # able to run actions and build libraries by their short name.
     master_ninja.newline()
-    master_ninja.comment('Short names for targets.')
-    for short_name in sorted(target_short_names):
-      master_ninja.build(short_name, 'phony', [x.FinalOutput() for x in
-                                               target_short_names[short_name]])
-
-  # Write phony targets for any empty targets that weren't written yet. As
-  # short names are  not necessarily unique only do this for short names that
-  # haven't already been output for another target.
-  empty_target_names = empty_target_names - non_empty_target_names
-  if empty_target_names:
+
+    master_ninja.pool("link_pool", depth=GetDefaultConcurrentLinks())
     master_ninja.newline()
-    master_ninja.comment('Empty targets (output for completeness).')
-    for name in sorted(empty_target_names):
-      master_ninja.build(name, 'phony')
 
-  if all_outputs:
+    deps = "msvc" if flavor == "win" else "gcc"
+
+    if flavor != "win":
+        master_ninja.rule(
+            "cc",
+            description="CC $out",
+            command=(
+                "$cc -MMD -MF $out.d $defines $includes $cflags $cflags_c "
+                "$cflags_pch_c -c $in -o $out"
+            ),
+            depfile="$out.d",
+            deps=deps,
+        )
+        master_ninja.rule(
+            "cc_s",
+            description="CC $out",
+            command=(
+                "$cc $defines $includes $cflags $cflags_c "
+                "$cflags_pch_c -c $in -o $out"
+            ),
+        )
+        master_ninja.rule(
+            "cxx",
+            description="CXX $out",
+            command=(
+                "$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_cc "
+                "$cflags_pch_cc -c $in -o $out"
+            ),
+            depfile="$out.d",
+            deps=deps,
+        )
+    else:
+        # TODO(scottmg) Separate pdb names is a test to see if it works around
+        # http://crbug.com/142362. It seems there's a race between the creation of
+        # the .pdb by the precompiled header step for .cc and the compilation of
+        # .c files. This should be handled by mspdbsrv, but rarely errors out with
+        #   c1xx : fatal error C1033: cannot open program database
+        # By making the rules target separate pdb files this might be avoided.
+        cc_command = (
+            "ninja -t msvc -e $arch " + "-- "
+            "$cc /nologo /showIncludes /FC "
+            "@$out.rsp /c $in /Fo$out /Fd$pdbname_c "
+        )
+        cxx_command = (
+            "ninja -t msvc -e $arch " + "-- "
+            "$cxx /nologo /showIncludes /FC "
+            "@$out.rsp /c $in /Fo$out /Fd$pdbname_cc "
+        )
+        master_ninja.rule(
+            "cc",
+            description="CC $out",
+            command=cc_command,
+            rspfile="$out.rsp",
+            rspfile_content="$defines $includes $cflags $cflags_c",
+            deps=deps,
+        )
+        master_ninja.rule(
+            "cxx",
+            description="CXX $out",
+            command=cxx_command,
+            rspfile="$out.rsp",
+            rspfile_content="$defines $includes $cflags $cflags_cc",
+            deps=deps,
+        )
+        master_ninja.rule(
+            "idl",
+            description="IDL $in",
+            command=(
+                "%s gyp-win-tool midl-wrapper $arch $outdir "
+                "$tlb $h $dlldata $iid $proxy $in "
+                "$midl_includes $idlflags" % sys.executable
+            ),
+        )
+        master_ninja.rule(
+            "rc",
+            description="RC $in",
+            # Note: $in must be last otherwise rc.exe complains.
+            command=(
+                "%s gyp-win-tool rc-wrapper "
+                "$arch $rc $defines $resource_includes $rcflags /fo$out $in"
+                % sys.executable
+            ),
+        )
+        master_ninja.rule(
+            "asm",
+            description="ASM $out",
+            command=(
+                "%s gyp-win-tool asm-wrapper "
+                "$arch $asm $defines $includes $asmflags /c /Fo $out $in"
+                % sys.executable
+            ),
+        )
+
+    if flavor != "mac" and flavor != "win":
+        master_ninja.rule(
+            "alink",
+            description="AR $out",
+            command="rm -f $out && $ar rcs $arflags $out $in",
+        )
+        master_ninja.rule(
+            "alink_thin",
+            description="AR $out",
+            command="rm -f $out && $ar rcsT $arflags $out $in",
+        )
+
+        # This allows targets that only need to depend on $lib's API to declare an
+        # order-only dependency on $lib.TOC and avoid relinking such downstream
+        # dependencies when $lib changes only in non-public ways.
+        # The resulting string leaves an uninterpolated %{suffix} which
+        # is used in the final substitution below.
+        mtime_preserving_solink_base = (
+            "if [ ! -e $lib -o ! -e $lib.TOC ]; then "
+            "%(solink)s && %(extract_toc)s > $lib.TOC; else "
+            "%(solink)s && %(extract_toc)s > $lib.tmp && "
+            "if ! cmp -s $lib.tmp $lib.TOC; then mv $lib.tmp $lib.TOC ; "
+            "fi; fi"
+            % {
+                "solink": "$ld -shared $ldflags -o $lib -Wl,-soname=$soname %(suffix)s",
+                "extract_toc": (
+                    "{ $readelf -d $lib | grep SONAME ; "
+                    "$nm -gD -f p $lib | cut -f1-2 -d' '; }"
+                ),
+            }
+        )
+
+        master_ninja.rule(
+            "solink",
+            description="SOLINK $lib",
+            restat=True,
+            command=mtime_preserving_solink_base % {"suffix": "@$link_file_list"},  # noqa: E501
+            rspfile="$link_file_list",
+            rspfile_content=("-Wl,--whole-archive $in $solibs -Wl,"
+                             "--no-whole-archive $libs"),
+            pool="link_pool",
+        )
+        master_ninja.rule(
+            "solink_module",
+            description="SOLINK(module) $lib",
+            restat=True,
+            command=mtime_preserving_solink_base % {"suffix": "@$link_file_list"},
+            rspfile="$link_file_list",
+            rspfile_content="-Wl,--start-group $in $solibs $libs -Wl,--end-group",
+            pool="link_pool",
+        )
+        master_ninja.rule(
+            "link",
+            description="LINK $out",
+            command=(
+                "$ld $ldflags -o $out "
+                "-Wl,--start-group $in $solibs $libs -Wl,--end-group"
+            ),
+            pool="link_pool",
+        )
+    elif flavor == "win":
+        master_ninja.rule(
+            "alink",
+            description="LIB $out",
+            command=(
+                "%s gyp-win-tool link-wrapper $arch False "
+                "$ar /nologo /ignore:4221 /OUT:$out @$out.rsp" % sys.executable
+            ),
+            rspfile="$out.rsp",
+            rspfile_content="$in_newline $libflags",
+        )
+        _AddWinLinkRules(master_ninja, embed_manifest=True)
+        _AddWinLinkRules(master_ninja, embed_manifest=False)
+    else:
+        master_ninja.rule(
+            "objc",
+            description="OBJC $out",
+            command=(
+                "$cc -MMD -MF $out.d $defines $includes $cflags $cflags_objc "
+                "$cflags_pch_objc -c $in -o $out"
+            ),
+            depfile="$out.d",
+            deps=deps,
+        )
+        master_ninja.rule(
+            "objcxx",
+            description="OBJCXX $out",
+            command=(
+                "$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_objcc "
+                "$cflags_pch_objcc -c $in -o $out"
+            ),
+            depfile="$out.d",
+            deps=deps,
+        )
+        master_ninja.rule(
+            "alink",
+            description="LIBTOOL-STATIC $out, POSTBUILDS",
+            command="rm -f $out && "
+            "./gyp-mac-tool filter-libtool libtool $libtool_flags "
+            "-static -o $out $in"
+            "$postbuilds",
+        )
+        master_ninja.rule(
+            "lipo",
+            description="LIPO $out, POSTBUILDS",
+            command="rm -f $out && lipo -create $in -output $out$postbuilds",
+        )
+        master_ninja.rule(
+            "solipo",
+            description="SOLIPO $out, POSTBUILDS",
+            command=(
+                "rm -f $lib $lib.TOC && lipo -create $in -output $lib$postbuilds &&"
+                "%(extract_toc)s > $lib.TOC"
+                % {
+                    "extract_toc": "{ otool -l $lib | grep LC_ID_DYLIB -A 5; "
+                    "nm -gP $lib | cut -f1-2 -d' ' | grep -v U$$; true; }"
+                }
+            ),
+        )
+
+        # Record the public interface of $lib in $lib.TOC. See the corresponding
+        # comment in the posix section above for details.
+        solink_base = "$ld %(type)s $ldflags -o $lib %(suffix)s"
+        mtime_preserving_solink_base = (
+            "if [ ! -e $lib -o ! -e $lib.TOC ] || "
+            # Always force dependent targets to relink if this library
+            # reexports something. Handling this correctly would require
+            # recursive TOC dumping but this is rare in practice, so punt.
+            "otool -l $lib | grep -q LC_REEXPORT_DYLIB ; then "
+            "%(solink)s && %(extract_toc)s > $lib.TOC; "
+            "else "
+            "%(solink)s && %(extract_toc)s > $lib.tmp && "
+            "if ! cmp -s $lib.tmp $lib.TOC; then "
+            "mv $lib.tmp $lib.TOC ; "
+            "fi; "
+            "fi"
+            % {
+                "solink": solink_base,
+                "extract_toc": "{ otool -l $lib | grep LC_ID_DYLIB -A 5; "
+                "nm -gP $lib | cut -f1-2 -d' ' | grep -v U$$; true; }",
+            }
+        )
+
+        solink_suffix = "@$link_file_list$postbuilds"
+        master_ninja.rule(
+            "solink",
+            description="SOLINK $lib, POSTBUILDS",
+            restat=True,
+            command=mtime_preserving_solink_base
+            % {"suffix": solink_suffix, "type": "-shared"},
+            rspfile="$link_file_list",
+            rspfile_content="$in $solibs $libs",
+            pool="link_pool",
+        )
+        master_ninja.rule(
+            "solink_notoc",
+            description="SOLINK $lib, POSTBUILDS",
+            restat=True,
+            command=solink_base % {"suffix": solink_suffix, "type": "-shared"},
+            rspfile="$link_file_list",
+            rspfile_content="$in $solibs $libs",
+            pool="link_pool",
+        )
+
+        master_ninja.rule(
+            "solink_module",
+            description="SOLINK(module) $lib, POSTBUILDS",
+            restat=True,
+            command=mtime_preserving_solink_base
+            % {"suffix": solink_suffix, "type": "-bundle"},
+            rspfile="$link_file_list",
+            rspfile_content="$in $solibs $libs",
+            pool="link_pool",
+        )
+        master_ninja.rule(
+            "solink_module_notoc",
+            description="SOLINK(module) $lib, POSTBUILDS",
+            restat=True,
+            command=solink_base % {"suffix": solink_suffix, "type": "-bundle"},
+            rspfile="$link_file_list",
+            rspfile_content="$in $solibs $libs",
+            pool="link_pool",
+        )
+
+        master_ninja.rule(
+            "link",
+            description="LINK $out, POSTBUILDS",
+            command=("$ld $ldflags -o $out " "$in $solibs $libs$postbuilds"),
+            pool="link_pool",
+        )
+        master_ninja.rule(
+            "preprocess_infoplist",
+            description="PREPROCESS INFOPLIST $out",
+            command=(
+                "$cc -E -P -Wno-trigraphs -x c $defines $in -o $out && "
+                "plutil -convert xml1 $out $out"
+            ),
+        )
+        master_ninja.rule(
+            "copy_infoplist",
+            description="COPY INFOPLIST $in",
+            command="$env ./gyp-mac-tool copy-info-plist $in $out $binary $keys",
+        )
+        master_ninja.rule(
+            "merge_infoplist",
+            description="MERGE INFOPLISTS $in",
+            command="$env ./gyp-mac-tool merge-info-plist $out $in",
+        )
+        master_ninja.rule(
+            "compile_xcassets",
+            description="COMPILE XCASSETS $in",
+            command="$env ./gyp-mac-tool compile-xcassets $keys $in",
+        )
+        master_ninja.rule(
+            "compile_ios_framework_headers",
+            description="COMPILE HEADER MAPS AND COPY FRAMEWORK HEADERS $in",
+            command="$env ./gyp-mac-tool compile-ios-framework-header-map $out "
+            "$framework $in && $env ./gyp-mac-tool "
+            "copy-ios-framework-headers $framework $copy_headers",
+        )
+        master_ninja.rule(
+            "mac_tool",
+            description="MACTOOL $mactool_cmd $in",
+            command="$env ./gyp-mac-tool $mactool_cmd $in $out $binary",
+        )
+        master_ninja.rule(
+            "package_framework",
+            description="PACKAGE FRAMEWORK $out, POSTBUILDS",
+            command="./gyp-mac-tool package-framework $out $version$postbuilds "
+            "&& touch $out",
+        )
+        master_ninja.rule(
+            "package_ios_framework",
+            description="PACKAGE IOS FRAMEWORK $out, POSTBUILDS",
+            command="./gyp-mac-tool package-ios-framework $out $postbuilds "
+            "&& touch $out",
+        )
+    if flavor == "win":
+        master_ninja.rule(
+            "stamp",
+            description="STAMP $out",
+            command="%s gyp-win-tool stamp $out" % sys.executable,
+        )
+    else:
+        master_ninja.rule(
+            "stamp", description="STAMP $out", command="${postbuilds}touch $out"
+        )
+    if flavor == "win":
+        master_ninja.rule(
+            "copy",
+            description="COPY $in $out",
+            command="%s gyp-win-tool recursive-mirror $in $out" % sys.executable,
+        )
+    elif flavor == "zos":
+        master_ninja.rule(
+            "copy",
+            description="COPY $in $out",
+            command="rm -rf $out && cp -fRP $in $out",
+        )
+    else:
+        master_ninja.rule(
+            "copy",
+            description="COPY $in $out",
+            command="ln -f $in $out 2>/dev/null || (rm -rf $out && cp -af $in $out)",
+        )
     master_ninja.newline()
-    master_ninja.build('all', 'phony', sorted(all_outputs))
-    master_ninja.default(generator_flags.get('default_target', 'all'))
 
-  master_ninja_file.close()
+    all_targets = set()
+    for build_file in params["build_files"]:
+        for target in gyp.common.AllTargets(
+            target_list, target_dicts, os.path.normpath(build_file)
+        ):
+            all_targets.add(target)
+    all_outputs = set()
+
+    # target_outputs is a map from qualified target name to a Target object.
+    target_outputs = {}
+    # target_short_names is a map from target short name to a list of Target
+    # objects.
+    target_short_names = {}
+
+    # short name of targets that were skipped because they didn't contain anything
+    # interesting.
+    # NOTE: there may be overlap between this an non_empty_target_names.
+    empty_target_names = set()
+
+    # Set of non-empty short target names.
+    # NOTE: there may be overlap between this an empty_target_names.
+    non_empty_target_names = set()
+
+    for qualified_target in target_list:
+        # qualified_target is like: third_party/icu/icu.gyp:icui18n#target
+        build_file, name, toolset = gyp.common.ParseQualifiedTarget(qualified_target)
+
+        this_make_global_settings = data[build_file].get("make_global_settings", [])
+        assert make_global_settings == this_make_global_settings, (
+            "make_global_settings needs to be the same for all targets. %s vs. %s"
+            % (this_make_global_settings, make_global_settings)
+        )
+
+        spec = target_dicts[qualified_target]
+        if flavor == "mac":
+            gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
+
+        # If build_file is a symlink, we must not follow it because there's a chance
+        # it could point to a path above toplevel_dir, and we cannot correctly deal
+        # with that case at the moment.
+        build_file = gyp.common.RelativePath(build_file, options.toplevel_dir, False)
+
+        qualified_target_for_hash = gyp.common.QualifiedTarget(
+            build_file, name, toolset
+        )
+        qualified_target_for_hash = qualified_target_for_hash.encode("utf-8")
+        hash_for_rules = hashlib.md5(qualified_target_for_hash).hexdigest()
+
+        base_path = os.path.dirname(build_file)
+        obj = "obj"
+        if toolset != "target":
+            obj += "." + toolset
+        output_file = os.path.join(obj, base_path, name + ".ninja")
+
+        ninja_output = StringIO()
+        writer = NinjaWriter(
+            hash_for_rules,
+            target_outputs,
+            base_path,
+            build_dir,
+            ninja_output,
+            toplevel_build,
+            output_file,
+            flavor,
+            toplevel_dir=options.toplevel_dir,
+        )
+
+        target = writer.WriteSpec(spec, config_name, generator_flags)
+
+        if ninja_output.tell() > 0:
+            # Only create files for ninja files that actually have contents.
+            with OpenOutput(os.path.join(toplevel_build, output_file)) as ninja_file:
+                ninja_file.write(ninja_output.getvalue())
+            ninja_output.close()
+            master_ninja.subninja(output_file)
+
+        if target:
+            if name != target.FinalOutput() and spec["toolset"] == "target":
+                target_short_names.setdefault(name, []).append(target)
+            target_outputs[qualified_target] = target
+            if qualified_target in all_targets:
+                all_outputs.add(target.FinalOutput())
+            non_empty_target_names.add(name)
+        else:
+            empty_target_names.add(name)
+
+    if target_short_names:
+        # Write a short name to build this target.  This benefits both the
+        # "build chrome" case as well as the gyp tests, which expect to be
+        # able to run actions and build libraries by their short name.
+        master_ninja.newline()
+        master_ninja.comment("Short names for targets.")
+        for short_name in sorted(target_short_names):
+            master_ninja.build(
+                short_name,
+                "phony",
+                [x.FinalOutput() for x in target_short_names[short_name]],
+            )
+
+    # Write phony targets for any empty targets that weren't written yet. As
+    # short names are  not necessarily unique only do this for short names that
+    # haven't already been output for another target.
+    empty_target_names = empty_target_names - non_empty_target_names
+    if empty_target_names:
+        master_ninja.newline()
+        master_ninja.comment("Empty targets (output for completeness).")
+        for name in sorted(empty_target_names):
+            master_ninja.build(name, "phony")
+
+    if all_outputs:
+        master_ninja.newline()
+        master_ninja.build("all", "phony", sorted(all_outputs))
+        master_ninja.default(generator_flags.get("default_target", "all"))
+
+    master_ninja_file.close()
 
 
 def PerformBuild(data, configurations, params):
-  options = params['options']
-  for config in configurations:
-    builddir = os.path.join(options.toplevel_dir, 'out', config)
-    arguments = ['ninja', '-C', builddir]
-    print('Building [%s]: %s' % (config, arguments))
-    subprocess.check_call(arguments)
+    options = params["options"]
+    for config in configurations:
+        builddir = os.path.join(options.toplevel_dir, "out", config)
+        arguments = ["ninja", "-C", builddir]
+        print("Building [%s]: %s" % (config, arguments))
+        subprocess.check_call(arguments)
 
 
 def CallGenerateOutputForConfig(arglist):
-  # Ignore the interrupt signal so that the parent process catches it and
-  # kills all multiprocessing children.
-  signal.signal(signal.SIGINT, signal.SIG_IGN)
+    # Ignore the interrupt signal so that the parent process catches it and
+    # kills all multiprocessing children.
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
 
-  (target_list, target_dicts, data, params, config_name) = arglist
-  GenerateOutputForConfig(target_list, target_dicts, data, params, config_name)
+    (target_list, target_dicts, data, params, config_name) = arglist
+    GenerateOutputForConfig(target_list, target_dicts, data, params, config_name)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  # Update target_dicts for iOS device builds.
-  target_dicts = gyp.xcode_emulation.CloneConfigurationForDeviceAndEmulator(
-      target_dicts)
-
-  user_config = params.get('generator_flags', {}).get('config', None)
-  if gyp.common.GetFlavor(params) == 'win':
-    target_list, target_dicts = MSVSUtil.ShardTargets(target_list, target_dicts)
-    target_list, target_dicts = MSVSUtil.InsertLargePdbShims(
-        target_list, target_dicts, generator_default_variables)
-
-  if user_config:
-    GenerateOutputForConfig(target_list, target_dicts, data, params,
-                            user_config)
-  else:
-    config_names = target_dicts[target_list[0]]['configurations'].keys()
-    if params['parallel']:
-      try:
-        pool = multiprocessing.Pool(len(config_names))
-        arglists = []
-        for config_name in config_names:
-          arglists.append(
-              (target_list, target_dicts, data, params, config_name))
-        pool.map(CallGenerateOutputForConfig, arglists)
-      except KeyboardInterrupt as e:
-        pool.terminate()
-        raise e
+    # Update target_dicts for iOS device builds.
+    target_dicts = gyp.xcode_emulation.CloneConfigurationForDeviceAndEmulator(
+        target_dicts
+    )
+
+    user_config = params.get("generator_flags", {}).get("config", None)
+    if gyp.common.GetFlavor(params) == "win":
+        target_list, target_dicts = MSVSUtil.ShardTargets(target_list, target_dicts)
+        target_list, target_dicts = MSVSUtil.InsertLargePdbShims(
+            target_list, target_dicts, generator_default_variables
+        )
+
+    if user_config:
+        GenerateOutputForConfig(target_list, target_dicts, data, params, user_config)
     else:
-      for config_name in config_names:
-        GenerateOutputForConfig(target_list, target_dicts, data, params,
-                                config_name)
+        config_names = target_dicts[target_list[0]]["configurations"]
+        if params["parallel"]:
+            try:
+                pool = multiprocessing.Pool(len(config_names))
+                arglists = []
+                for config_name in config_names:
+                    arglists.append(
+                        (target_list, target_dicts, data, params, config_name)
+                    )
+                pool.map(CallGenerateOutputForConfig, arglists)
+            except KeyboardInterrupt as e:
+                pool.terminate()
+                raise e
+        else:
+            for config_name in config_names:
+                GenerateOutputForConfig(
+                    target_list, target_dicts, data, params, config_name
+                )
diff --git a/tools/gyp/pylib/gyp/generator/ninja_test.py b/tools/gyp/pylib/gyp/generator/ninja_test.py
index c8adc251c97d502ccf39954f769bb4bc20b0da6a..abadcd9828e8b2e65df7a14903c2c1376a7bbe6e 100644
--- a/tools/gyp/pylib/gyp/generator/ninja_test.py
+++ b/tools/gyp/pylib/gyp/generator/ninja_test.py
@@ -13,34 +13,43 @@ import gyp.generator.ninja as ninja
 
 
 class TestPrefixesAndSuffixes(unittest.TestCase):
-  def test_BinaryNamesWindows(self):
-    # These cannot run on non-Windows as they require a VS installation to
-    # correctly handle variable expansion.
-    if sys.platform.startswith('win'):
-      writer = ninja.NinjaWriter('foo', 'wee', '.', '.', 'build.ninja', '.',
-          'build.ninja', 'win')
-      spec = { 'target_name': 'wee' }
-      self.assertTrue(writer.ComputeOutputFileName(spec, 'executable').
-          endswith('.exe'))
-      self.assertTrue(writer.ComputeOutputFileName(spec, 'shared_library').
-          endswith('.dll'))
-      self.assertTrue(writer.ComputeOutputFileName(spec, 'static_library').
-          endswith('.lib'))
-
-  def test_BinaryNamesLinux(self):
-    writer = ninja.NinjaWriter('foo', 'wee', '.', '.', 'build.ninja', '.',
-        'build.ninja', 'linux')
-    spec = { 'target_name': 'wee' }
-    self.assertTrue('.' not in writer.ComputeOutputFileName(spec,
-                                                            'executable'))
-    self.assertTrue(writer.ComputeOutputFileName(spec, 'shared_library').
-        startswith('lib'))
-    self.assertTrue(writer.ComputeOutputFileName(spec, 'static_library').
-        startswith('lib'))
-    self.assertTrue(writer.ComputeOutputFileName(spec, 'shared_library').
-        endswith('.so'))
-    self.assertTrue(writer.ComputeOutputFileName(spec, 'static_library').
-        endswith('.a'))
-
-if __name__ == '__main__':
-  unittest.main()
+    def test_BinaryNamesWindows(self):
+        # These cannot run on non-Windows as they require a VS installation to
+        # correctly handle variable expansion.
+        if sys.platform.startswith("win"):
+            writer = ninja.NinjaWriter(
+                "foo", "wee", ".", ".", "build.ninja", ".", "build.ninja", "win"
+            )
+            spec = {"target_name": "wee"}
+            self.assertTrue(
+                writer.ComputeOutputFileName(spec, "executable").endswith(".exe")
+            )
+            self.assertTrue(
+                writer.ComputeOutputFileName(spec, "shared_library").endswith(".dll")
+            )
+            self.assertTrue(
+                writer.ComputeOutputFileName(spec, "static_library").endswith(".lib")
+            )
+
+    def test_BinaryNamesLinux(self):
+        writer = ninja.NinjaWriter(
+            "foo", "wee", ".", ".", "build.ninja", ".", "build.ninja", "linux"
+        )
+        spec = {"target_name": "wee"}
+        self.assertTrue("." not in writer.ComputeOutputFileName(spec, "executable"))
+        self.assertTrue(
+            writer.ComputeOutputFileName(spec, "shared_library").startswith("lib")
+        )
+        self.assertTrue(
+            writer.ComputeOutputFileName(spec, "static_library").startswith("lib")
+        )
+        self.assertTrue(
+            writer.ComputeOutputFileName(spec, "shared_library").endswith(".so")
+        )
+        self.assertTrue(
+            writer.ComputeOutputFileName(spec, "static_library").endswith(".a")
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/gyp/pylib/gyp/generator/xcode.py b/tools/gyp/pylib/gyp/generator/xcode.py
index 4917ba77b9d57712aea46ca61fdaa1f75e19f11d..9e7e99e9e13d2d638e9db3ce5e101d3eb376b4c4 100644
--- a/tools/gyp/pylib/gyp/generator/xcode.py
+++ b/tools/gyp/pylib/gyp/generator/xcode.py
@@ -27,511 +27,543 @@ import tempfile
 # PROJECT_DERIVED_FILE_DIR, is unsuitable because while it is project-specific,
 # it is not configuration-specific.  INTERMEDIATE_DIR is defined as
 # $(PROJECT_DERIVED_FILE_DIR)/$(CONFIGURATION).
-_intermediate_var = 'INTERMEDIATE_DIR'
+_intermediate_var = "INTERMEDIATE_DIR"
 
 # SHARED_INTERMEDIATE_DIR is the same, except that it is shared among all
 # targets that share the same BUILT_PRODUCTS_DIR.
-_shared_intermediate_var = 'SHARED_INTERMEDIATE_DIR'
+_shared_intermediate_var = "SHARED_INTERMEDIATE_DIR"
 
-_library_search_paths_var = 'LIBRARY_SEARCH_PATHS'
+_library_search_paths_var = "LIBRARY_SEARCH_PATHS"
 
 generator_default_variables = {
-  'EXECUTABLE_PREFIX': '',
-  'EXECUTABLE_SUFFIX': '',
-  'STATIC_LIB_PREFIX': 'lib',
-  'SHARED_LIB_PREFIX': 'lib',
-  'STATIC_LIB_SUFFIX': '.a',
-  'SHARED_LIB_SUFFIX': '.dylib',
-  # INTERMEDIATE_DIR is a place for targets to build up intermediate products.
-  # It is specific to each build environment.  It is only guaranteed to exist
-  # and be constant within the context of a project, corresponding to a single
-  # input file.  Some build environments may allow their intermediate directory
-  # to be shared on a wider scale, but this is not guaranteed.
-  'INTERMEDIATE_DIR': '$(%s)' % _intermediate_var,
-  'OS': 'mac',
-  'PRODUCT_DIR': '$(BUILT_PRODUCTS_DIR)',
-  'LIB_DIR': '$(BUILT_PRODUCTS_DIR)',
-  'RULE_INPUT_ROOT': '$(INPUT_FILE_BASE)',
-  'RULE_INPUT_EXT': '$(INPUT_FILE_SUFFIX)',
-  'RULE_INPUT_NAME': '$(INPUT_FILE_NAME)',
-  'RULE_INPUT_PATH': '$(INPUT_FILE_PATH)',
-  'RULE_INPUT_DIRNAME': '$(INPUT_FILE_DIRNAME)',
-  'SHARED_INTERMEDIATE_DIR': '$(%s)' % _shared_intermediate_var,
-  'CONFIGURATION_NAME': '$(CONFIGURATION)',
+    "EXECUTABLE_PREFIX": "",
+    "EXECUTABLE_SUFFIX": "",
+    "STATIC_LIB_PREFIX": "lib",
+    "SHARED_LIB_PREFIX": "lib",
+    "STATIC_LIB_SUFFIX": ".a",
+    "SHARED_LIB_SUFFIX": ".dylib",
+    # INTERMEDIATE_DIR is a place for targets to build up intermediate products.
+    # It is specific to each build environment.  It is only guaranteed to exist
+    # and be constant within the context of a project, corresponding to a single
+    # input file.  Some build environments may allow their intermediate directory
+    # to be shared on a wider scale, but this is not guaranteed.
+    "INTERMEDIATE_DIR": "$(%s)" % _intermediate_var,
+    "OS": "mac",
+    "PRODUCT_DIR": "$(BUILT_PRODUCTS_DIR)",
+    "LIB_DIR": "$(BUILT_PRODUCTS_DIR)",
+    "RULE_INPUT_ROOT": "$(INPUT_FILE_BASE)",
+    "RULE_INPUT_EXT": "$(INPUT_FILE_SUFFIX)",
+    "RULE_INPUT_NAME": "$(INPUT_FILE_NAME)",
+    "RULE_INPUT_PATH": "$(INPUT_FILE_PATH)",
+    "RULE_INPUT_DIRNAME": "$(INPUT_FILE_DIRNAME)",
+    "SHARED_INTERMEDIATE_DIR": "$(%s)" % _shared_intermediate_var,
+    "CONFIGURATION_NAME": "$(CONFIGURATION)",
 }
 
 # The Xcode-specific sections that hold paths.
 generator_additional_path_sections = [
-  'mac_bundle_resources',
-  'mac_framework_headers',
-  'mac_framework_private_headers',
-  # 'mac_framework_dirs', input already handles _dirs endings.
+    "mac_bundle_resources",
+    "mac_framework_headers",
+    "mac_framework_private_headers",
+    # 'mac_framework_dirs', input already handles _dirs endings.
 ]
 
 # The Xcode-specific keys that exist on targets and aren't moved down to
 # configurations.
 generator_additional_non_configuration_keys = [
-  'ios_app_extension',
-  'ios_watch_app',
-  'ios_watchkit_extension',
-  'mac_bundle',
-  'mac_bundle_resources',
-  'mac_framework_headers',
-  'mac_framework_private_headers',
-  'mac_xctest_bundle',
-  'mac_xcuitest_bundle',
-  'xcode_create_dependents_test_runner',
+    "ios_app_extension",
+    "ios_watch_app",
+    "ios_watchkit_extension",
+    "mac_bundle",
+    "mac_bundle_resources",
+    "mac_framework_headers",
+    "mac_framework_private_headers",
+    "mac_xctest_bundle",
+    "mac_xcuitest_bundle",
+    "xcode_create_dependents_test_runner",
 ]
 
 # We want to let any rules apply to files that are resources also.
 generator_extra_sources_for_rules = [
-  'mac_bundle_resources',
-  'mac_framework_headers',
-  'mac_framework_private_headers',
+    "mac_bundle_resources",
+    "mac_framework_headers",
+    "mac_framework_private_headers",
 ]
 
 generator_filelist_paths = None
 
 # Xcode's standard set of library directories, which don't need to be duplicated
 # in LIBRARY_SEARCH_PATHS. This list is not exhaustive, but that's okay.
-xcode_standard_library_dirs = frozenset([
-  '$(SDKROOT)/usr/lib',
-  '$(SDKROOT)/usr/local/lib',
-])
+xcode_standard_library_dirs = frozenset(
+    ["$(SDKROOT)/usr/lib", "$(SDKROOT)/usr/local/lib"]
+)
+
 
 def CreateXCConfigurationList(configuration_names):
-  xccl = gyp.xcodeproj_file.XCConfigurationList({'buildConfigurations': []})
-  if len(configuration_names) == 0:
-    configuration_names = ['Default']
-  for configuration_name in configuration_names:
-    xcbc = gyp.xcodeproj_file.XCBuildConfiguration({
-        'name': configuration_name})
-    xccl.AppendProperty('buildConfigurations', xcbc)
-  xccl.SetProperty('defaultConfigurationName', configuration_names[0])
-  return xccl
+    xccl = gyp.xcodeproj_file.XCConfigurationList({"buildConfigurations": []})
+    if len(configuration_names) == 0:
+        configuration_names = ["Default"]
+    for configuration_name in configuration_names:
+        xcbc = gyp.xcodeproj_file.XCBuildConfiguration({"name": configuration_name})
+        xccl.AppendProperty("buildConfigurations", xcbc)
+    xccl.SetProperty("defaultConfigurationName", configuration_names[0])
+    return xccl
 
 
 class XcodeProject(object):
-  def __init__(self, gyp_path, path, build_file_dict):
-    self.gyp_path = gyp_path
-    self.path = path
-    self.project = gyp.xcodeproj_file.PBXProject(path=path)
-    projectDirPath = gyp.common.RelativePath(
-                         os.path.dirname(os.path.abspath(self.gyp_path)),
-                         os.path.dirname(path) or '.')
-    self.project.SetProperty('projectDirPath', projectDirPath)
-    self.project_file = \
-        gyp.xcodeproj_file.XCProjectFile({'rootObject': self.project})
-    self.build_file_dict = build_file_dict
-
-    # TODO(mark): add destructor that cleans up self.path if created_dir is
-    # True and things didn't complete successfully.  Or do something even
-    # better with "try"?
-    self.created_dir = False
-    try:
-      os.makedirs(self.path)
-      self.created_dir = True
-    except OSError as e:
-      if e.errno != errno.EEXIST:
-        raise
-
-  def Finalize1(self, xcode_targets, serialize_all_tests):
-    # Collect a list of all of the build configuration names used by the
-    # various targets in the file.  It is very heavily advised to keep each
-    # target in an entire project (even across multiple project files) using
-    # the same set of configuration names.
-    configurations = []
-    for xct in self.project.GetProperty('targets'):
-      xccl = xct.GetProperty('buildConfigurationList')
-      xcbcs = xccl.GetProperty('buildConfigurations')
-      for xcbc in xcbcs:
-        name = xcbc.GetProperty('name')
-        if name not in configurations:
-          configurations.append(name)
-
-    # Replace the XCConfigurationList attached to the PBXProject object with
-    # a new one specifying all of the configuration names used by the various
-    # targets.
-    try:
-      xccl = CreateXCConfigurationList(configurations)
-      self.project.SetProperty('buildConfigurationList', xccl)
-    except:
-      sys.stderr.write("Problem with gyp file %s\n" % self.gyp_path)
-      raise
-
-    # The need for this setting is explained above where _intermediate_var is
-    # defined.  The comments below about wanting to avoid project-wide build
-    # settings apply here too, but this needs to be set on a project-wide basis
-    # so that files relative to the _intermediate_var setting can be displayed
-    # properly in the Xcode UI.
-    #
-    # Note that for configuration-relative files such as anything relative to
-    # _intermediate_var, for the purposes of UI tree view display, Xcode will
-    # only resolve the configuration name once, when the project file is
-    # opened.  If the active build configuration is changed, the project file
-    # must be closed and reopened if it is desired for the tree view to update.
-    # This is filed as Apple radar 6588391.
-    xccl.SetBuildSetting(_intermediate_var,
-                         '$(PROJECT_DERIVED_FILE_DIR)/$(CONFIGURATION)')
-    xccl.SetBuildSetting(_shared_intermediate_var,
-                         '$(SYMROOT)/DerivedSources/$(CONFIGURATION)')
-
-    # Set user-specified project-wide build settings and config files.  This
-    # is intended to be used very sparingly.  Really, almost everything should
-    # go into target-specific build settings sections.  The project-wide
-    # settings are only intended to be used in cases where Xcode attempts to
-    # resolve variable references in a project context as opposed to a target
-    # context, such as when resolving sourceTree references while building up
-    # the tree tree view for UI display.
-    # Any values set globally are applied to all configurations, then any
-    # per-configuration values are applied.
-    for xck, xcv in self.build_file_dict.get('xcode_settings', {}).items():
-      xccl.SetBuildSetting(xck, xcv)
-    if 'xcode_config_file' in self.build_file_dict:
-      config_ref = self.project.AddOrGetFileInRootGroup(
-          self.build_file_dict['xcode_config_file'])
-      xccl.SetBaseConfiguration(config_ref)
-    build_file_configurations = self.build_file_dict.get('configurations', {})
-    if build_file_configurations:
-      for config_name in configurations:
-        build_file_configuration_named = \
-            build_file_configurations.get(config_name, {})
-        if build_file_configuration_named:
-          xcc = xccl.ConfigurationNamed(config_name)
-          for xck, xcv in build_file_configuration_named.get('xcode_settings',
-                                                             {}).items():
-            xcc.SetBuildSetting(xck, xcv)
-          if 'xcode_config_file' in build_file_configuration_named:
+    def __init__(self, gyp_path, path, build_file_dict):
+        self.gyp_path = gyp_path
+        self.path = path
+        self.project = gyp.xcodeproj_file.PBXProject(path=path)
+        projectDirPath = gyp.common.RelativePath(
+            os.path.dirname(os.path.abspath(self.gyp_path)),
+            os.path.dirname(path) or ".",
+        )
+        self.project.SetProperty("projectDirPath", projectDirPath)
+        self.project_file = gyp.xcodeproj_file.XCProjectFile(
+            {"rootObject": self.project}
+        )
+        self.build_file_dict = build_file_dict
+
+        # TODO(mark): add destructor that cleans up self.path if created_dir is
+        # True and things didn't complete successfully.  Or do something even
+        # better with "try"?
+        self.created_dir = False
+        try:
+            os.makedirs(self.path)
+            self.created_dir = True
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+    def Finalize1(self, xcode_targets, serialize_all_tests):
+        # Collect a list of all of the build configuration names used by the
+        # various targets in the file.  It is very heavily advised to keep each
+        # target in an entire project (even across multiple project files) using
+        # the same set of configuration names.
+        configurations = []
+        for xct in self.project.GetProperty("targets"):
+            xccl = xct.GetProperty("buildConfigurationList")
+            xcbcs = xccl.GetProperty("buildConfigurations")
+            for xcbc in xcbcs:
+                name = xcbc.GetProperty("name")
+                if name not in configurations:
+                    configurations.append(name)
+
+        # Replace the XCConfigurationList attached to the PBXProject object with
+        # a new one specifying all of the configuration names used by the various
+        # targets.
+        try:
+            xccl = CreateXCConfigurationList(configurations)
+            self.project.SetProperty("buildConfigurationList", xccl)
+        except Exception:
+            sys.stderr.write("Problem with gyp file %s\n" % self.gyp_path)
+            raise
+
+        # The need for this setting is explained above where _intermediate_var is
+        # defined.  The comments below about wanting to avoid project-wide build
+        # settings apply here too, but this needs to be set on a project-wide basis
+        # so that files relative to the _intermediate_var setting can be displayed
+        # properly in the Xcode UI.
+        #
+        # Note that for configuration-relative files such as anything relative to
+        # _intermediate_var, for the purposes of UI tree view display, Xcode will
+        # only resolve the configuration name once, when the project file is
+        # opened.  If the active build configuration is changed, the project file
+        # must be closed and reopened if it is desired for the tree view to update.
+        # This is filed as Apple radar 6588391.
+        xccl.SetBuildSetting(
+            _intermediate_var, "$(PROJECT_DERIVED_FILE_DIR)/$(CONFIGURATION)"
+        )
+        xccl.SetBuildSetting(
+            _shared_intermediate_var, "$(SYMROOT)/DerivedSources/$(CONFIGURATION)"
+        )
+
+        # Set user-specified project-wide build settings and config files.  This
+        # is intended to be used very sparingly.  Really, almost everything should
+        # go into target-specific build settings sections.  The project-wide
+        # settings are only intended to be used in cases where Xcode attempts to
+        # resolve variable references in a project context as opposed to a target
+        # context, such as when resolving sourceTree references while building up
+        # the tree tree view for UI display.
+        # Any values set globally are applied to all configurations, then any
+        # per-configuration values are applied.
+        for xck, xcv in self.build_file_dict.get("xcode_settings", {}).items():
+            xccl.SetBuildSetting(xck, xcv)
+        if "xcode_config_file" in self.build_file_dict:
             config_ref = self.project.AddOrGetFileInRootGroup(
-                build_file_configurations[config_name]['xcode_config_file'])
-            xcc.SetBaseConfiguration(config_ref)
-
-    # Sort the targets based on how they appeared in the input.
-    # TODO(mark): Like a lot of other things here, this assumes internal
-    # knowledge of PBXProject - in this case, of its "targets" property.
-
-    # ordinary_targets are ordinary targets that are already in the project
-    # file. run_test_targets are the targets that run unittests and should be
-    # used for the Run All Tests target.  support_targets are the action/rule
-    # targets used by GYP file targets, just kept for the assert check.
-    ordinary_targets = []
-    run_test_targets = []
-    support_targets = []
-
-    # targets is full list of targets in the project.
-    targets = []
-
-    # does the it define it's own "all"?
-    has_custom_all = False
-
-    # targets_for_all is the list of ordinary_targets that should be listed
-    # in this project's "All" target.  It includes each non_runtest_target
-    # that does not have suppress_wildcard set.
-    targets_for_all = []
-
-    for target in self.build_file_dict['targets']:
-      target_name = target['target_name']
-      toolset = target['toolset']
-      qualified_target = gyp.common.QualifiedTarget(self.gyp_path, target_name,
-                                                    toolset)
-      xcode_target = xcode_targets[qualified_target]
-      # Make sure that the target being added to the sorted list is already in
-      # the unsorted list.
-      assert xcode_target in self.project._properties['targets']
-      targets.append(xcode_target)
-      ordinary_targets.append(xcode_target)
-      if xcode_target.support_target:
-        support_targets.append(xcode_target.support_target)
-        targets.append(xcode_target.support_target)
-
-      if not int(target.get('suppress_wildcard', False)):
-        targets_for_all.append(xcode_target)
-
-      if target_name.lower() == 'all':
-        has_custom_all = True
-
-      # If this target has a 'run_as' attribute, add its target to the
-      # targets, and add it to the test targets.
-      if target.get('run_as'):
-        # Make a target to run something.  It should have one
-        # dependency, the parent xcode target.
-        xccl = CreateXCConfigurationList(configurations)
-        run_target = gyp.xcodeproj_file.PBXAggregateTarget({
-              'name':                   'Run ' + target_name,
-              'productName':            xcode_target.GetProperty('productName'),
-              'buildConfigurationList': xccl,
-            },
-            parent=self.project)
-        run_target.AddDependency(xcode_target)
-
-        command = target['run_as']
-        script = ''
-        if command.get('working_directory'):
-          script = script + 'cd "%s"\n' % \
-                   gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
-                       command.get('working_directory'))
-
-        if command.get('environment'):
-          script = script + "\n".join(
-            ['export %s="%s"' %
-             (key, gyp.xcodeproj_file.ConvertVariablesToShellSyntax(val))
-             for (key, val) in command.get('environment').items()]) + "\n"
-
-        # Some test end up using sockets, files on disk, etc. and can get
-        # confused if more then one test runs at a time.  The generator
-        # flag 'xcode_serialize_all_test_runs' controls the forcing of all
-        # tests serially.  It defaults to True.  To get serial runs this
-        # little bit of python does the same as the linux flock utility to
-        # make sure only one runs at a time.
-        command_prefix = ''
-        if serialize_all_tests:
-          command_prefix = \
-"""python -c "import fcntl, subprocess, sys
+                self.build_file_dict["xcode_config_file"]
+            )
+            xccl.SetBaseConfiguration(config_ref)
+        build_file_configurations = self.build_file_dict.get("configurations", {})
+        if build_file_configurations:
+            for config_name in configurations:
+                build_file_configuration_named = build_file_configurations.get(
+                    config_name, {}
+                )
+                if build_file_configuration_named:
+                    xcc = xccl.ConfigurationNamed(config_name)
+                    for xck, xcv in build_file_configuration_named.get(
+                        "xcode_settings", {}
+                    ).items():
+                        xcc.SetBuildSetting(xck, xcv)
+                    if "xcode_config_file" in build_file_configuration_named:
+                        config_ref = self.project.AddOrGetFileInRootGroup(
+                            build_file_configurations[config_name]["xcode_config_file"]
+                        )
+                        xcc.SetBaseConfiguration(config_ref)
+
+        # Sort the targets based on how they appeared in the input.
+        # TODO(mark): Like a lot of other things here, this assumes internal
+        # knowledge of PBXProject - in this case, of its "targets" property.
+
+        # ordinary_targets are ordinary targets that are already in the project
+        # file. run_test_targets are the targets that run unittests and should be
+        # used for the Run All Tests target.  support_targets are the action/rule
+        # targets used by GYP file targets, just kept for the assert check.
+        ordinary_targets = []
+        run_test_targets = []
+        support_targets = []
+
+        # targets is full list of targets in the project.
+        targets = []
+
+        # does the it define it's own "all"?
+        has_custom_all = False
+
+        # targets_for_all is the list of ordinary_targets that should be listed
+        # in this project's "All" target.  It includes each non_runtest_target
+        # that does not have suppress_wildcard set.
+        targets_for_all = []
+
+        for target in self.build_file_dict["targets"]:
+            target_name = target["target_name"]
+            toolset = target["toolset"]
+            qualified_target = gyp.common.QualifiedTarget(
+                self.gyp_path, target_name, toolset
+            )
+            xcode_target = xcode_targets[qualified_target]
+            # Make sure that the target being added to the sorted list is already in
+            # the unsorted list.
+            assert xcode_target in self.project._properties["targets"]
+            targets.append(xcode_target)
+            ordinary_targets.append(xcode_target)
+            if xcode_target.support_target:
+                support_targets.append(xcode_target.support_target)
+                targets.append(xcode_target.support_target)
+
+            if not int(target.get("suppress_wildcard", False)):
+                targets_for_all.append(xcode_target)
+
+            if target_name.lower() == "all":
+                has_custom_all = True
+
+            # If this target has a 'run_as' attribute, add its target to the
+            # targets, and add it to the test targets.
+            if target.get("run_as"):
+                # Make a target to run something.  It should have one
+                # dependency, the parent xcode target.
+                xccl = CreateXCConfigurationList(configurations)
+                run_target = gyp.xcodeproj_file.PBXAggregateTarget(
+                    {
+                        "name": "Run " + target_name,
+                        "productName": xcode_target.GetProperty("productName"),
+                        "buildConfigurationList": xccl,
+                    },
+                    parent=self.project,
+                )
+                run_target.AddDependency(xcode_target)
+
+                command = target["run_as"]
+                script = ""
+                if command.get("working_directory"):
+                    script = (
+                        script
+                        + 'cd "%s"\n'
+                        % gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
+                            command.get("working_directory")
+                        )
+                    )
+
+                if command.get("environment"):
+                    script = (
+                        script
+                        + "\n".join(
+                            [
+                                'export %s="%s"'
+                                % (
+                                    key,
+                                    gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
+                                        val
+                                    ),
+                                )
+                                for (key, val) in command.get("environment").items()
+                            ]
+                        )
+                        + "\n"
+                    )
+
+                # Some test end up using sockets, files on disk, etc. and can get
+                # confused if more then one test runs at a time.  The generator
+                # flag 'xcode_serialize_all_test_runs' controls the forcing of all
+                # tests serially.  It defaults to True.  To get serial runs this
+                # little bit of python does the same as the linux flock utility to
+                # make sure only one runs at a time.
+                command_prefix = ""
+                if serialize_all_tests:
+                    command_prefix = """python -c "import fcntl, subprocess, sys
 file = open('$TMPDIR/GYP_serialize_test_runs', 'a')
 fcntl.flock(file.fileno(), fcntl.LOCK_EX)
 sys.exit(subprocess.call(sys.argv[1:]))" """
 
-        # If we were unable to exec for some reason, we want to exit
-        # with an error, and fixup variable references to be shell
-        # syntax instead of xcode syntax.
-        script = script + 'exec ' + command_prefix + '%s\nexit 1\n' % \
-                 gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
-                     gyp.common.EncodePOSIXShellList(command.get('action')))
-
-        ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
-              'shellScript':      script,
-              'showEnvVarsInLog': 0,
-            })
-        run_target.AppendProperty('buildPhases', ssbp)
-
-        # Add the run target to the project file.
-        targets.append(run_target)
-        run_test_targets.append(run_target)
-        xcode_target.test_runner = run_target
-
-
-    # Make sure that the list of targets being replaced is the same length as
-    # the one replacing it, but allow for the added test runner targets.
-    assert len(self.project._properties['targets']) == \
-      len(ordinary_targets) + len(support_targets)
-
-    self.project._properties['targets'] = targets
-
-    # Get rid of unnecessary levels of depth in groups like the Source group.
-    self.project.RootGroupsTakeOverOnlyChildren(True)
-
-    # Sort the groups nicely.  Do this after sorting the targets, because the
-    # Products group is sorted based on the order of the targets.
-    self.project.SortGroups()
-
-    # Create an "All" target if there's more than one target in this project
-    # file and the project didn't define its own "All" target.  Put a generated
-    # "All" target first so that people opening up the project for the first
-    # time will build everything by default.
-    if len(targets_for_all) > 1 and not has_custom_all:
-      xccl = CreateXCConfigurationList(configurations)
-      all_target = gyp.xcodeproj_file.PBXAggregateTarget(
-          {
-            'buildConfigurationList': xccl,
-            'name':                   'All',
-          },
-          parent=self.project)
-
-      for target in targets_for_all:
-        all_target.AddDependency(target)
-
-      # TODO(mark): This is evil because it relies on internal knowledge of
-      # PBXProject._properties.  It's important to get the "All" target first,
-      # though.
-      self.project._properties['targets'].insert(0, all_target)
-
-    # The same, but for run_test_targets.
-    if len(run_test_targets) > 1:
-      xccl = CreateXCConfigurationList(configurations)
-      run_all_tests_target = gyp.xcodeproj_file.PBXAggregateTarget(
-          {
-            'buildConfigurationList': xccl,
-            'name':                   'Run All Tests',
-          },
-          parent=self.project)
-      for run_test_target in run_test_targets:
-        run_all_tests_target.AddDependency(run_test_target)
-
-      # Insert after the "All" target, which must exist if there is more than
-      # one run_test_target.
-      self.project._properties['targets'].insert(1, run_all_tests_target)
-
-  def Finalize2(self, xcode_targets, xcode_target_to_target_dict):
-    # Finalize2 needs to happen in a separate step because the process of
-    # updating references to other projects depends on the ordering of targets
-    # within remote project files.  Finalize1 is responsible for sorting duty,
-    # and once all project files are sorted, Finalize2 can come in and update
-    # these references.
-
-    # To support making a "test runner" target that will run all the tests
-    # that are direct dependents of any given target, we look for
-    # xcode_create_dependents_test_runner being set on an Aggregate target,
-    # and generate a second target that will run the tests runners found under
-    # the marked target.
-    for bf_tgt in self.build_file_dict['targets']:
-      if int(bf_tgt.get('xcode_create_dependents_test_runner', 0)):
-        tgt_name = bf_tgt['target_name']
-        toolset = bf_tgt['toolset']
-        qualified_target = gyp.common.QualifiedTarget(self.gyp_path,
-                                                      tgt_name, toolset)
-        xcode_target = xcode_targets[qualified_target]
-        if isinstance(xcode_target, gyp.xcodeproj_file.PBXAggregateTarget):
-          # Collect all the run test targets.
-          all_run_tests = []
-          pbxtds = xcode_target.GetProperty('dependencies')
-          for pbxtd in pbxtds:
-            pbxcip = pbxtd.GetProperty('targetProxy')
-            dependency_xct = pbxcip.GetProperty('remoteGlobalIDString')
-            if hasattr(dependency_xct, 'test_runner'):
-              all_run_tests.append(dependency_xct.test_runner)
-
-          # Directly depend on all the runners as they depend on the target
-          # that builds them.
-          if len(all_run_tests) > 0:
-            run_all_target = gyp.xcodeproj_file.PBXAggregateTarget({
-                  'name':        'Run %s Tests' % tgt_name,
-                  'productName': tgt_name,
-                },
-                parent=self.project)
-            for run_test_target in all_run_tests:
-              run_all_target.AddDependency(run_test_target)
-
-            # Insert the test runner after the related target.
-            idx = self.project._properties['targets'].index(xcode_target)
-            self.project._properties['targets'].insert(idx + 1, run_all_target)
-
-    # Update all references to other projects, to make sure that the lists of
-    # remote products are complete.  Otherwise, Xcode will fill them in when
-    # it opens the project file, which will result in unnecessary diffs.
-    # TODO(mark): This is evil because it relies on internal knowledge of
-    # PBXProject._other_pbxprojects.
-    for other_pbxproject in self.project._other_pbxprojects.keys():
-      self.project.AddOrGetProjectReference(other_pbxproject)
-
-    self.project.SortRemoteProductReferences()
-
-    # Give everything an ID.
-    self.project_file.ComputeIDs()
-
-    # Make sure that no two objects in the project file have the same ID.  If
-    # multiple objects wind up with the same ID, upon loading the file, Xcode
-    # will only recognize one object (the last one in the file?) and the
-    # results are unpredictable.
-    self.project_file.EnsureNoIDCollisions()
-
-  def Write(self):
-    # Write the project file to a temporary location first.  Xcode watches for
-    # changes to the project file and presents a UI sheet offering to reload
-    # the project when it does change.  However, in some cases, especially when
-    # multiple projects are open or when Xcode is busy, things don't work so
-    # seamlessly.  Sometimes, Xcode is able to detect that a project file has
-    # changed but can't unload it because something else is referencing it.
-    # To mitigate this problem, and to avoid even having Xcode present the UI
-    # sheet when an open project is rewritten for inconsequential changes, the
-    # project file is written to a temporary file in the xcodeproj directory
-    # first.  The new temporary file is then compared to the existing project
-    # file, if any.  If they differ, the new file replaces the old; otherwise,
-    # the new project file is simply deleted.  Xcode properly detects a file
-    # being renamed over an open project file as a change and so it remains
-    # able to present the "project file changed" sheet under this system.
-    # Writing to a temporary file first also avoids the possible problem of
-    # Xcode rereading an incomplete project file.
-    (output_fd, new_pbxproj_path) = \
-        tempfile.mkstemp(suffix='.tmp', prefix='project.pbxproj.gyp.',
-                         dir=self.path)
-
-    try:
-      output_file = os.fdopen(output_fd, 'wb')
-
-      self.project_file.Print(output_file)
-      output_file.close()
-
-      pbxproj_path = os.path.join(self.path, 'project.pbxproj')
-
-      same = False
-      try:
-        same = filecmp.cmp(pbxproj_path, new_pbxproj_path, False)
-      except OSError as e:
-        if e.errno != errno.ENOENT:
-          raise
-
-      if same:
-        # The new file is identical to the old one, just get rid of the new
-        # one.
-        os.unlink(new_pbxproj_path)
-      else:
-        # The new file is different from the old one, or there is no old one.
-        # Rename the new file to the permanent name.
-        #
-        # tempfile.mkstemp uses an overly restrictive mode, resulting in a
-        # file that can only be read by the owner, regardless of the umask.
-        # There's no reason to not respect the umask here, which means that
-        # an extra hoop is required to fetch it and reset the new file's mode.
-        #
-        # No way to get the umask without setting a new one?  Set a safe one
-        # and then set it back to the old value.
-        umask = os.umask(0o77)
-        os.umask(umask)
-
-        os.chmod(new_pbxproj_path, 0o666 & ~umask)
-        os.rename(new_pbxproj_path, pbxproj_path)
-
-    except Exception:
-      # Don't leave turds behind.  In fact, if this code was responsible for
-      # creating the xcodeproj directory, get rid of that too.
-      os.unlink(new_pbxproj_path)
-      if self.created_dir:
-        shutil.rmtree(self.path, True)
-      raise
+                # If we were unable to exec for some reason, we want to exit
+                # with an error, and fixup variable references to be shell
+                # syntax instead of xcode syntax.
+                script = (
+                    script
+                    + "exec "
+                    + command_prefix
+                    + "%s\nexit 1\n"
+                    % gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
+                        gyp.common.EncodePOSIXShellList(command.get("action"))
+                    )
+                )
+
+                ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase(
+                    {"shellScript": script, "showEnvVarsInLog": 0}
+                )
+                run_target.AppendProperty("buildPhases", ssbp)
+
+                # Add the run target to the project file.
+                targets.append(run_target)
+                run_test_targets.append(run_target)
+                xcode_target.test_runner = run_target
+
+        # Make sure that the list of targets being replaced is the same length as
+        # the one replacing it, but allow for the added test runner targets.
+        assert len(self.project._properties["targets"]) == len(ordinary_targets) + len(
+            support_targets
+        )
+
+        self.project._properties["targets"] = targets
+
+        # Get rid of unnecessary levels of depth in groups like the Source group.
+        self.project.RootGroupsTakeOverOnlyChildren(True)
+
+        # Sort the groups nicely.  Do this after sorting the targets, because the
+        # Products group is sorted based on the order of the targets.
+        self.project.SortGroups()
+
+        # Create an "All" target if there's more than one target in this project
+        # file and the project didn't define its own "All" target.  Put a generated
+        # "All" target first so that people opening up the project for the first
+        # time will build everything by default.
+        if len(targets_for_all) > 1 and not has_custom_all:
+            xccl = CreateXCConfigurationList(configurations)
+            all_target = gyp.xcodeproj_file.PBXAggregateTarget(
+                {"buildConfigurationList": xccl, "name": "All"}, parent=self.project
+            )
+
+            for target in targets_for_all:
+                all_target.AddDependency(target)
+
+            # TODO(mark): This is evil because it relies on internal knowledge of
+            # PBXProject._properties.  It's important to get the "All" target first,
+            # though.
+            self.project._properties["targets"].insert(0, all_target)
+
+        # The same, but for run_test_targets.
+        if len(run_test_targets) > 1:
+            xccl = CreateXCConfigurationList(configurations)
+            run_all_tests_target = gyp.xcodeproj_file.PBXAggregateTarget(
+                {"buildConfigurationList": xccl, "name": "Run All Tests"},
+                parent=self.project,
+            )
+            for run_test_target in run_test_targets:
+                run_all_tests_target.AddDependency(run_test_target)
+
+            # Insert after the "All" target, which must exist if there is more than
+            # one run_test_target.
+            self.project._properties["targets"].insert(1, run_all_tests_target)
+
+    def Finalize2(self, xcode_targets, xcode_target_to_target_dict):
+        # Finalize2 needs to happen in a separate step because the process of
+        # updating references to other projects depends on the ordering of targets
+        # within remote project files.  Finalize1 is responsible for sorting duty,
+        # and once all project files are sorted, Finalize2 can come in and update
+        # these references.
+
+        # To support making a "test runner" target that will run all the tests
+        # that are direct dependents of any given target, we look for
+        # xcode_create_dependents_test_runner being set on an Aggregate target,
+        # and generate a second target that will run the tests runners found under
+        # the marked target.
+        for bf_tgt in self.build_file_dict["targets"]:
+            if int(bf_tgt.get("xcode_create_dependents_test_runner", 0)):
+                tgt_name = bf_tgt["target_name"]
+                toolset = bf_tgt["toolset"]
+                qualified_target = gyp.common.QualifiedTarget(
+                    self.gyp_path, tgt_name, toolset
+                )
+                xcode_target = xcode_targets[qualified_target]
+                if isinstance(xcode_target, gyp.xcodeproj_file.PBXAggregateTarget):
+                    # Collect all the run test targets.
+                    all_run_tests = []
+                    pbxtds = xcode_target.GetProperty("dependencies")
+                    for pbxtd in pbxtds:
+                        pbxcip = pbxtd.GetProperty("targetProxy")
+                        dependency_xct = pbxcip.GetProperty("remoteGlobalIDString")
+                        if hasattr(dependency_xct, "test_runner"):
+                            all_run_tests.append(dependency_xct.test_runner)
+
+                    # Directly depend on all the runners as they depend on the target
+                    # that builds them.
+                    if len(all_run_tests) > 0:
+                        run_all_target = gyp.xcodeproj_file.PBXAggregateTarget(
+                            {
+                                "name": "Run %s Tests" % tgt_name,
+                                "productName": tgt_name,
+                            },
+                            parent=self.project,
+                        )
+                        for run_test_target in all_run_tests:
+                            run_all_target.AddDependency(run_test_target)
+
+                        # Insert the test runner after the related target.
+                        idx = self.project._properties["targets"].index(xcode_target)
+                        self.project._properties["targets"].insert(
+                            idx + 1, run_all_target
+                        )
+
+        # Update all references to other projects, to make sure that the lists of
+        # remote products are complete.  Otherwise, Xcode will fill them in when
+        # it opens the project file, which will result in unnecessary diffs.
+        # TODO(mark): This is evil because it relies on internal knowledge of
+        # PBXProject._other_pbxprojects.
+        for other_pbxproject in self.project._other_pbxprojects.keys():
+            self.project.AddOrGetProjectReference(other_pbxproject)
+
+        self.project.SortRemoteProductReferences()
+
+        # Give everything an ID.
+        self.project_file.ComputeIDs()
+
+        # Make sure that no two objects in the project file have the same ID.  If
+        # multiple objects wind up with the same ID, upon loading the file, Xcode
+        # will only recognize one object (the last one in the file?) and the
+        # results are unpredictable.
+        self.project_file.EnsureNoIDCollisions()
+
+    def Write(self):
+        # Write the project file to a temporary location first.  Xcode watches for
+        # changes to the project file and presents a UI sheet offering to reload
+        # the project when it does change.  However, in some cases, especially when
+        # multiple projects are open or when Xcode is busy, things don't work so
+        # seamlessly.  Sometimes, Xcode is able to detect that a project file has
+        # changed but can't unload it because something else is referencing it.
+        # To mitigate this problem, and to avoid even having Xcode present the UI
+        # sheet when an open project is rewritten for inconsequential changes, the
+        # project file is written to a temporary file in the xcodeproj directory
+        # first.  The new temporary file is then compared to the existing project
+        # file, if any.  If they differ, the new file replaces the old; otherwise,
+        # the new project file is simply deleted.  Xcode properly detects a file
+        # being renamed over an open project file as a change and so it remains
+        # able to present the "project file changed" sheet under this system.
+        # Writing to a temporary file first also avoids the possible problem of
+        # Xcode rereading an incomplete project file.
+        (output_fd, new_pbxproj_path) = tempfile.mkstemp(
+            suffix=".tmp", prefix="project.pbxproj.gyp.", dir=self.path
+        )
+
+        try:
+            output_file = os.fdopen(output_fd, "w")
+
+            self.project_file.Print(output_file)
+            output_file.close()
+
+            pbxproj_path = os.path.join(self.path, "project.pbxproj")
+
+            same = False
+            try:
+                same = filecmp.cmp(pbxproj_path, new_pbxproj_path, False)
+            except OSError as e:
+                if e.errno != errno.ENOENT:
+                    raise
+
+            if same:
+                # The new file is identical to the old one, just get rid of the new
+                # one.
+                os.unlink(new_pbxproj_path)
+            else:
+                # The new file is different from the old one, or there is no old one.
+                # Rename the new file to the permanent name.
+                #
+                # tempfile.mkstemp uses an overly restrictive mode, resulting in a
+                # file that can only be read by the owner, regardless of the umask.
+                # There's no reason to not respect the umask here, which means that
+                # an extra hoop is required to fetch it and reset the new file's mode.
+                #
+                # No way to get the umask without setting a new one?  Set a safe one
+                # and then set it back to the old value.
+                umask = os.umask(0o77)
+                os.umask(umask)
+
+                os.chmod(new_pbxproj_path, 0o666 & ~umask)
+                os.rename(new_pbxproj_path, pbxproj_path)
+
+        except Exception:
+            # Don't leave turds behind.  In fact, if this code was responsible for
+            # creating the xcodeproj directory, get rid of that too.
+            os.unlink(new_pbxproj_path)
+            if self.created_dir:
+                shutil.rmtree(self.path, True)
+            raise
 
 
 def AddSourceToTarget(source, type, pbxp, xct):
-  # TODO(mark): Perhaps source_extensions and library_extensions can be made a
-  # little bit fancier.
-  source_extensions = ['c', 'cc', 'cpp', 'cxx', 'm', 'mm', 's', 'swift']
-
-  # .o is conceptually more of a "source" than a "library," but Xcode thinks
-  # of "sources" as things to compile and "libraries" (or "frameworks") as
-  # things to link with. Adding an object file to an Xcode target's frameworks
-  # phase works properly.
-  library_extensions = ['a', 'dylib', 'framework', 'o']
-
-  basename = posixpath.basename(source)
-  (root, ext) = posixpath.splitext(basename)
-  if ext:
-    ext = ext[1:].lower()
-
-  if ext in source_extensions and type != 'none':
-    xct.SourcesPhase().AddFile(source)
-  elif ext in library_extensions and type != 'none':
-    xct.FrameworksPhase().AddFile(source)
-  else:
-    # Files that aren't added to a sources or frameworks build phase can still
-    # go into the project file, just not as part of a build phase.
-    pbxp.AddOrGetFileInRootGroup(source)
+    # TODO(mark): Perhaps source_extensions and library_extensions can be made a
+    # little bit fancier.
+    source_extensions = ["c", "cc", "cpp", "cxx", "m", "mm", "s", "swift"]
+
+    # .o is conceptually more of a "source" than a "library," but Xcode thinks
+    # of "sources" as things to compile and "libraries" (or "frameworks") as
+    # things to link with. Adding an object file to an Xcode target's frameworks
+    # phase works properly.
+    library_extensions = ["a", "dylib", "framework", "o"]
+
+    basename = posixpath.basename(source)
+    (root, ext) = posixpath.splitext(basename)
+    if ext:
+        ext = ext[1:].lower()
+
+    if ext in source_extensions and type != "none":
+        xct.SourcesPhase().AddFile(source)
+    elif ext in library_extensions and type != "none":
+        xct.FrameworksPhase().AddFile(source)
+    else:
+        # Files that aren't added to a sources or frameworks build phase can still
+        # go into the project file, just not as part of a build phase.
+        pbxp.AddOrGetFileInRootGroup(source)
 
 
 def AddResourceToTarget(resource, pbxp, xct):
-  # TODO(mark): Combine with AddSourceToTarget above?  Or just inline this call
-  # where it's used.
-  xct.ResourcesPhase().AddFile(resource)
+    # TODO(mark): Combine with AddSourceToTarget above?  Or just inline this call
+    # where it's used.
+    xct.ResourcesPhase().AddFile(resource)
 
 
 def AddHeaderToTarget(header, pbxp, xct, is_public):
-  # TODO(mark): Combine with AddSourceToTarget above?  Or just inline this call
-  # where it's used.
-  settings = '{ATTRIBUTES = (%s, ); }' % ('Private', 'Public')[is_public]
-  xct.HeadersPhase().AddFile(header, settings)
+    # TODO(mark): Combine with AddSourceToTarget above?  Or just inline this call
+    # where it's used.
+    settings = "{ATTRIBUTES = (%s, ); }" % ("Private", "Public")[is_public]
+    xct.HeadersPhase().AddFile(header, settings)
+
+
+_xcode_variable_re = re.compile(r"(\$\((.*?)\))")
 
 
-_xcode_variable_re = re.compile(r'(\$\((.*?)\))')
 def ExpandXcodeVariables(string, expansions):
-  """Expands Xcode-style $(VARIABLES) in string per the expansions dict.
+    """Expands Xcode-style $(VARIABLES) in string per the expansions dict.
 
   In some rare cases, it is appropriate to expand Xcode variables when a
   project file is generated.  For any substring $(VAR) in string, if VAR is a
@@ -540,774 +572,824 @@ def ExpandXcodeVariables(string, expansions):
   dict will remain in the returned string.
   """
 
-  matches = _xcode_variable_re.findall(string)
-  if matches is None:
-    return string
+    matches = _xcode_variable_re.findall(string)
+    if matches is None:
+        return string
 
-  matches.reverse()
-  for match in matches:
-    (to_replace, variable) = match
-    if not variable in expansions:
-      continue
+    matches.reverse()
+    for match in matches:
+        (to_replace, variable) = match
+        if variable not in expansions:
+            continue
 
-    replacement = expansions[variable]
-    string = re.sub(re.escape(to_replace), replacement, string)
+        replacement = expansions[variable]
+        string = re.sub(re.escape(to_replace), replacement, string)
+
+    return string
 
-  return string
+
+_xcode_define_re = re.compile(r"([\\\"\' ])")
 
 
-_xcode_define_re = re.compile(r'([\\\"\' ])')
 def EscapeXcodeDefine(s):
-  """We must escape the defines that we give to XCode so that it knows not to
+    """We must escape the defines that we give to XCode so that it knows not to
      split on spaces and to respect backslash and quote literals. However, we
-     must not quote the define, or Xcode will incorrectly intepret variables
+     must not quote the define, or Xcode will incorrectly interpret variables
      especially $(inherited)."""
-  return re.sub(_xcode_define_re, r'\\\1', s)
+    return re.sub(_xcode_define_re, r"\\\1", s)
 
 
 def PerformBuild(data, configurations, params):
-  options = params['options']
+    options = params["options"]
 
-  for build_file, build_file_dict in data.items():
-    (build_file_root, build_file_ext) = os.path.splitext(build_file)
-    if build_file_ext != '.gyp':
-      continue
-    xcodeproj_path = build_file_root + options.suffix + '.xcodeproj'
-    if options.generator_output:
-      xcodeproj_path = os.path.join(options.generator_output, xcodeproj_path)
+    for build_file, build_file_dict in data.items():
+        (build_file_root, build_file_ext) = os.path.splitext(build_file)
+        if build_file_ext != ".gyp":
+            continue
+        xcodeproj_path = build_file_root + options.suffix + ".xcodeproj"
+        if options.generator_output:
+            xcodeproj_path = os.path.join(options.generator_output, xcodeproj_path)
 
-  for config in configurations:
-    arguments = ['xcodebuild', '-project', xcodeproj_path]
-    arguments += ['-configuration', config]
-    print("Building [%s]: %s" % (config, arguments))
-    subprocess.check_call(arguments)
+    for config in configurations:
+        arguments = ["xcodebuild", "-project", xcodeproj_path]
+        arguments += ["-configuration", config]
+        print("Building [%s]: %s" % (config, arguments))
+        subprocess.check_call(arguments)
 
 
 def CalculateGeneratorInputInfo(params):
-  toplevel = params['options'].toplevel_dir
-  if params.get('flavor') == 'ninja':
-    generator_dir = os.path.relpath(params['options'].generator_output or '.')
-    output_dir = params.get('generator_flags', {}).get('output_dir', 'out')
-    output_dir = os.path.normpath(os.path.join(generator_dir, output_dir))
-    qualified_out_dir = os.path.normpath(os.path.join(
-        toplevel, output_dir, 'gypfiles-xcode-ninja'))
-  else:
-    output_dir = os.path.normpath(os.path.join(toplevel, 'xcodebuild'))
-    qualified_out_dir = os.path.normpath(os.path.join(
-        toplevel, output_dir, 'gypfiles'))
-
-  global generator_filelist_paths
-  generator_filelist_paths = {
-      'toplevel': toplevel,
-      'qualified_out_dir': qualified_out_dir,
-  }
+    toplevel = params["options"].toplevel_dir
+    if params.get("flavor") == "ninja":
+        generator_dir = os.path.relpath(params["options"].generator_output or ".")
+        output_dir = params.get("generator_flags", {}).get("output_dir", "out")
+        output_dir = os.path.normpath(os.path.join(generator_dir, output_dir))
+        qualified_out_dir = os.path.normpath(
+            os.path.join(toplevel, output_dir, "gypfiles-xcode-ninja")
+        )
+    else:
+        output_dir = os.path.normpath(os.path.join(toplevel, "xcodebuild"))
+        qualified_out_dir = os.path.normpath(
+            os.path.join(toplevel, output_dir, "gypfiles")
+        )
+
+    global generator_filelist_paths
+    generator_filelist_paths = {
+        "toplevel": toplevel,
+        "qualified_out_dir": qualified_out_dir,
+    }
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
-  # Optionally configure each spec to use ninja as the external builder.
-  ninja_wrapper = params.get('flavor') == 'ninja'
-  if ninja_wrapper:
-    (target_list, target_dicts, data) = \
-        gyp.xcode_ninja.CreateWrapper(target_list, target_dicts, data, params)
-
-  options = params['options']
-  generator_flags = params.get('generator_flags', {})
-  parallel_builds = generator_flags.get('xcode_parallel_builds', True)
-  serialize_all_tests = \
-      generator_flags.get('xcode_serialize_all_test_runs', True)
-  upgrade_check_project_version = \
-      generator_flags.get('xcode_upgrade_check_project_version', None)
-
-  # Format upgrade_check_project_version with leading zeros as needed.
-  if upgrade_check_project_version:
-    upgrade_check_project_version = str(upgrade_check_project_version)
-    while len(upgrade_check_project_version) < 4:
-      upgrade_check_project_version = '0' + upgrade_check_project_version
-
-  skip_excluded_files = \
-      not generator_flags.get('xcode_list_excluded_files', True)
-  xcode_projects = {}
-  for build_file, build_file_dict in data.items():
-    (build_file_root, build_file_ext) = os.path.splitext(build_file)
-    if build_file_ext != '.gyp':
-      continue
-    xcodeproj_path = build_file_root + options.suffix + '.xcodeproj'
-    if options.generator_output:
-      xcodeproj_path = os.path.join(options.generator_output, xcodeproj_path)
-    xcp = XcodeProject(build_file, xcodeproj_path, build_file_dict)
-    xcode_projects[build_file] = xcp
-    pbxp = xcp.project
-
-    # Set project-level attributes from multiple options
-    project_attributes = {}
-    if parallel_builds:
-      project_attributes['BuildIndependentTargetsInParallel'] = 'YES'
+    # Optionally configure each spec to use ninja as the external builder.
+    ninja_wrapper = params.get("flavor") == "ninja"
+    if ninja_wrapper:
+        (target_list, target_dicts, data) = gyp.xcode_ninja.CreateWrapper(
+            target_list, target_dicts, data, params
+        )
+
+    options = params["options"]
+    generator_flags = params.get("generator_flags", {})
+    parallel_builds = generator_flags.get("xcode_parallel_builds", True)
+    serialize_all_tests = generator_flags.get("xcode_serialize_all_test_runs", True)
+    upgrade_check_project_version = generator_flags.get(
+        "xcode_upgrade_check_project_version", None
+    )
+
+    # Format upgrade_check_project_version with leading zeros as needed.
     if upgrade_check_project_version:
-      project_attributes['LastUpgradeCheck'] = upgrade_check_project_version
-      project_attributes['LastTestingUpgradeCheck'] = \
-          upgrade_check_project_version
-      project_attributes['LastSwiftUpdateCheck'] = \
-          upgrade_check_project_version
-    pbxp.SetProperty('attributes', project_attributes)
-
-    # Add gyp/gypi files to project
-    if not generator_flags.get('standalone'):
-      main_group = pbxp.GetProperty('mainGroup')
-      build_group = gyp.xcodeproj_file.PBXGroup({'name': 'Build'})
-      main_group.AppendChild(build_group)
-      for included_file in build_file_dict['included_files']:
-        build_group.AddOrGetFileByPath(included_file, False)
-
-  xcode_targets = {}
-  xcode_target_to_target_dict = {}
-  for qualified_target in target_list:
-    [build_file, target_name, toolset] = \
-        gyp.common.ParseQualifiedTarget(qualified_target)
-
-    spec = target_dicts[qualified_target]
-    if spec['toolset'] != 'target':
-      raise Exception(
-          'Multiple toolsets not supported in xcode build (target %s)' %
-          qualified_target)
-    configuration_names = [spec['default_configuration']]
-    for configuration_name in sorted(spec['configurations'].keys()):
-      if configuration_name not in configuration_names:
-        configuration_names.append(configuration_name)
-    xcp = xcode_projects[build_file]
-    pbxp = xcp.project
-
-    # Set up the configurations for the target according to the list of names
-    # supplied.
-    xccl = CreateXCConfigurationList(configuration_names)
-
-    # Create an XCTarget subclass object for the target. The type with
-    # "+bundle" appended will be used if the target has "mac_bundle" set.
-    # loadable_modules not in a mac_bundle are mapped to
-    # com.googlecode.gyp.xcode.bundle, a pseudo-type that xcode.py interprets
-    # to create a single-file mh_bundle.
-    _types = {
-      'executable':                  'com.apple.product-type.tool',
-      'loadable_module':             'com.googlecode.gyp.xcode.bundle',
-      'shared_library':              'com.apple.product-type.library.dynamic',
-      'static_library':              'com.apple.product-type.library.static',
-      'mac_kernel_extension':        'com.apple.product-type.kernel-extension',
-      'executable+bundle':           'com.apple.product-type.application',
-      'loadable_module+bundle':      'com.apple.product-type.bundle',
-      'loadable_module+xctest':      'com.apple.product-type.bundle.unit-test',
-      'loadable_module+xcuitest':    'com.apple.product-type.bundle.ui-testing',
-      'shared_library+bundle':       'com.apple.product-type.framework',
-      'executable+extension+bundle': 'com.apple.product-type.app-extension',
-      'executable+watch+extension+bundle':
-          'com.apple.product-type.watchkit-extension',
-      'executable+watch+bundle':
-          'com.apple.product-type.application.watchapp',
-      'mac_kernel_extension+bundle': 'com.apple.product-type.kernel-extension',
-    }
-
-    target_properties = {
-      'buildConfigurationList': xccl,
-      'name':                   target_name,
-    }
+        upgrade_check_project_version = str(upgrade_check_project_version)
+        while len(upgrade_check_project_version) < 4:
+            upgrade_check_project_version = "0" + upgrade_check_project_version
+
+    skip_excluded_files = not generator_flags.get("xcode_list_excluded_files", True)
+    xcode_projects = {}
+    for build_file, build_file_dict in data.items():
+        (build_file_root, build_file_ext) = os.path.splitext(build_file)
+        if build_file_ext != ".gyp":
+            continue
+        xcodeproj_path = build_file_root + options.suffix + ".xcodeproj"
+        if options.generator_output:
+            xcodeproj_path = os.path.join(options.generator_output, xcodeproj_path)
+        xcp = XcodeProject(build_file, xcodeproj_path, build_file_dict)
+        xcode_projects[build_file] = xcp
+        pbxp = xcp.project
+
+        # Set project-level attributes from multiple options
+        project_attributes = {}
+        if parallel_builds:
+            project_attributes["BuildIndependentTargetsInParallel"] = "YES"
+        if upgrade_check_project_version:
+            project_attributes["LastUpgradeCheck"] = upgrade_check_project_version
+            project_attributes[
+                "LastTestingUpgradeCheck"
+            ] = upgrade_check_project_version
+            project_attributes["LastSwiftUpdateCheck"] = upgrade_check_project_version
+        pbxp.SetProperty("attributes", project_attributes)
+
+        # Add gyp/gypi files to project
+        if not generator_flags.get("standalone"):
+            main_group = pbxp.GetProperty("mainGroup")
+            build_group = gyp.xcodeproj_file.PBXGroup({"name": "Build"})
+            main_group.AppendChild(build_group)
+            for included_file in build_file_dict["included_files"]:
+                build_group.AddOrGetFileByPath(included_file, False)
+
+    xcode_targets = {}
+    xcode_target_to_target_dict = {}
+    for qualified_target in target_list:
+        [build_file, target_name, toolset] = gyp.common.ParseQualifiedTarget(
+            qualified_target
+        )
+
+        spec = target_dicts[qualified_target]
+        if spec["toolset"] != "target":
+            raise Exception(
+                "Multiple toolsets not supported in xcode build (target %s)"
+                % qualified_target
+            )
+        configuration_names = [spec["default_configuration"]]
+        for configuration_name in sorted(spec["configurations"].keys()):
+            if configuration_name not in configuration_names:
+                configuration_names.append(configuration_name)
+        xcp = xcode_projects[build_file]
+        pbxp = xcp.project
+
+        # Set up the configurations for the target according to the list of names
+        # supplied.
+        xccl = CreateXCConfigurationList(configuration_names)
+
+        # Create an XCTarget subclass object for the target. The type with
+        # "+bundle" appended will be used if the target has "mac_bundle" set.
+        # loadable_modules not in a mac_bundle are mapped to
+        # com.googlecode.gyp.xcode.bundle, a pseudo-type that xcode.py interprets
+        # to create a single-file mh_bundle.
+        _types = {
+            "executable": "com.apple.product-type.tool",
+            "loadable_module": "com.googlecode.gyp.xcode.bundle",
+            "shared_library": "com.apple.product-type.library.dynamic",
+            "static_library": "com.apple.product-type.library.static",
+            "mac_kernel_extension": "com.apple.product-type.kernel-extension",
+            "executable+bundle": "com.apple.product-type.application",
+            "loadable_module+bundle": "com.apple.product-type.bundle",
+            "loadable_module+xctest": "com.apple.product-type.bundle.unit-test",
+            "loadable_module+xcuitest": "com.apple.product-type.bundle.ui-testing",
+            "shared_library+bundle": "com.apple.product-type.framework",
+            "executable+extension+bundle": "com.apple.product-type.app-extension",
+            "executable+watch+extension+bundle":
+                "com.apple.product-type.watchkit-extension",
+            "executable+watch+bundle": "com.apple.product-type.application.watchapp",
+            "mac_kernel_extension+bundle": "com.apple.product-type.kernel-extension",
+        }
 
-    type = spec['type']
-    is_xctest = int(spec.get('mac_xctest_bundle', 0))
-    is_xcuitest = int(spec.get('mac_xcuitest_bundle', 0))
-    is_bundle = int(spec.get('mac_bundle', 0)) or is_xctest
-    is_app_extension = int(spec.get('ios_app_extension', 0))
-    is_watchkit_extension = int(spec.get('ios_watchkit_extension', 0))
-    is_watch_app = int(spec.get('ios_watch_app', 0))
-    if type != 'none':
-      type_bundle_key = type
-      if is_xcuitest:
-        type_bundle_key += '+xcuitest'
-        assert type == 'loadable_module', (
-            'mac_xcuitest_bundle targets must have type loadable_module '
-            '(target %s)' % target_name)
-      elif is_xctest:
-        type_bundle_key += '+xctest'
-        assert type == 'loadable_module', (
-            'mac_xctest_bundle targets must have type loadable_module '
-            '(target %s)' % target_name)
-      elif is_app_extension:
-        assert is_bundle, ('ios_app_extension flag requires mac_bundle '
-            '(target %s)' % target_name)
-        type_bundle_key += '+extension+bundle'
-      elif is_watchkit_extension:
-        assert is_bundle, ('ios_watchkit_extension flag requires mac_bundle '
-            '(target %s)' % target_name)
-        type_bundle_key += '+watch+extension+bundle'
-      elif is_watch_app:
-        assert is_bundle, ('ios_watch_app flag requires mac_bundle '
-            '(target %s)' % target_name)
-        type_bundle_key += '+watch+bundle'
-      elif is_bundle:
-        type_bundle_key += '+bundle'
-
-      xctarget_type = gyp.xcodeproj_file.PBXNativeTarget
-      try:
-        target_properties['productType'] = _types[type_bundle_key]
-      except KeyError as e:
-        gyp.common.ExceptionAppend(e, "-- unknown product type while "
-                                   "writing target %s" % target_name)
-        raise
-    else:
-      xctarget_type = gyp.xcodeproj_file.PBXAggregateTarget
-      assert not is_bundle, (
-          'mac_bundle targets cannot have type none (target "%s")' %
-          target_name)
-      assert not is_xcuitest, (
-          'mac_xcuitest_bundle targets cannot have type none (target "%s")' %
-          target_name)
-      assert not is_xctest, (
-          'mac_xctest_bundle targets cannot have type none (target "%s")' %
-          target_name)
-
-    target_product_name = spec.get('product_name')
-    if target_product_name is not None:
-      target_properties['productName'] = target_product_name
-
-    xct = xctarget_type(target_properties, parent=pbxp,
-                        force_outdir=spec.get('product_dir'),
-                        force_prefix=spec.get('product_prefix'),
-                        force_extension=spec.get('product_extension'))
-    pbxp.AppendProperty('targets', xct)
-    xcode_targets[qualified_target] = xct
-    xcode_target_to_target_dict[xct] = spec
-
-    spec_actions = spec.get('actions', [])
-    spec_rules = spec.get('rules', [])
-
-    # Xcode has some "issues" with checking dependencies for the "Compile
-    # sources" step with any source files/headers generated by actions/rules.
-    # To work around this, if a target is building anything directly (not
-    # type "none"), then a second target is used to run the GYP actions/rules
-    # and is made a dependency of this target.  This way the work is done
-    # before the dependency checks for what should be recompiled.
-    support_xct = None
-    # The Xcode "issues" don't affect xcode-ninja builds, since the dependency
-    # logic all happens in ninja.  Don't bother creating the extra targets in
-    # that case.
-    if type != 'none' and (spec_actions or spec_rules) and not ninja_wrapper:
-      support_xccl = CreateXCConfigurationList(configuration_names)
-      support_target_suffix = generator_flags.get(
-          'support_target_suffix', ' Support')
-      support_target_properties = {
-        'buildConfigurationList': support_xccl,
-        'name':                   target_name + support_target_suffix,
-      }
-      if target_product_name:
-        support_target_properties['productName'] = \
-            target_product_name + ' Support'
-      support_xct = \
-          gyp.xcodeproj_file.PBXAggregateTarget(support_target_properties,
-                                                parent=pbxp)
-      pbxp.AppendProperty('targets', support_xct)
-      xct.AddDependency(support_xct)
-    # Hang the support target off the main target so it can be tested/found
-    # by the generator during Finalize.
-    xct.support_target = support_xct
-
-    prebuild_index = 0
-
-    # Add custom shell script phases for "actions" sections.
-    for action in spec_actions:
-      # There's no need to write anything into the script to ensure that the
-      # output directories already exist, because Xcode will look at the
-      # declared outputs and automatically ensure that they exist for us.
-
-      # Do we have a message to print when this action runs?
-      message = action.get('message')
-      if message:
-        message = 'echo note: ' + gyp.common.EncodePOSIXShellArgument(message)
-      else:
-        message = ''
-
-      # Turn the list into a string that can be passed to a shell.
-      action_string = gyp.common.EncodePOSIXShellList(action['action'])
-
-      # Convert Xcode-type variable references to sh-compatible environment
-      # variable references.
-      message_sh = gyp.xcodeproj_file.ConvertVariablesToShellSyntax(message)
-      action_string_sh = gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
-        action_string)
-
-      script = ''
-      # Include the optional message
-      if message_sh:
-        script += message_sh + '\n'
-      # Be sure the script runs in exec, and that if exec fails, the script
-      # exits signalling an error.
-      script += 'exec ' + action_string_sh + '\nexit 1\n'
-      ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
-            'inputPaths': action['inputs'],
-            'name': 'Action "' + action['action_name'] + '"',
-            'outputPaths': action['outputs'],
-            'shellScript': script,
-            'showEnvVarsInLog': 0,
-          })
-
-      if support_xct:
-        support_xct.AppendProperty('buildPhases', ssbp)
-      else:
-        # TODO(mark): this assumes too much knowledge of the internals of
-        # xcodeproj_file; some of these smarts should move into xcodeproj_file
-        # itself.
-        xct._properties['buildPhases'].insert(prebuild_index, ssbp)
-        prebuild_index = prebuild_index + 1
-
-      # TODO(mark): Should verify that at most one of these is specified.
-      if int(action.get('process_outputs_as_sources', False)):
-        for output in action['outputs']:
-          AddSourceToTarget(output, type, pbxp, xct)
-
-      if int(action.get('process_outputs_as_mac_bundle_resources', False)):
-        for output in action['outputs']:
-          AddResourceToTarget(output, pbxp, xct)
-
-    # tgt_mac_bundle_resources holds the list of bundle resources so
-    # the rule processing can check against it.
-    if is_bundle:
-      tgt_mac_bundle_resources = spec.get('mac_bundle_resources', [])
-    else:
-      tgt_mac_bundle_resources = []
-
-    # Add custom shell script phases driving "make" for "rules" sections.
-    #
-    # Xcode's built-in rule support is almost powerful enough to use directly,
-    # but there are a few significant deficiencies that render them unusable.
-    # There are workarounds for some of its inadequacies, but in aggregate,
-    # the workarounds added complexity to the generator, and some workarounds
-    # actually require input files to be crafted more carefully than I'd like.
-    # Consequently, until Xcode rules are made more capable, "rules" input
-    # sections will be handled in Xcode output by shell script build phases
-    # performed prior to the compilation phase.
-    #
-    # The following problems with Xcode rules were found.  The numbers are
-    # Apple radar IDs.  I hope that these shortcomings are addressed, I really
-    # liked having the rules handled directly in Xcode during the period that
-    # I was prototyping this.
-    #
-    # 6588600 Xcode compiles custom script rule outputs too soon, compilation
-    #         fails.  This occurs when rule outputs from distinct inputs are
-    #         interdependent.  The only workaround is to put rules and their
-    #         inputs in a separate target from the one that compiles the rule
-    #         outputs.  This requires input file cooperation and it means that
-    #         process_outputs_as_sources is unusable.
-    # 6584932 Need to declare that custom rule outputs should be excluded from
-    #         compilation.  A possible workaround is to lie to Xcode about a
-    #         rule's output, giving it a dummy file it doesn't know how to
-    #         compile.  The rule action script would need to touch the dummy.
-    # 6584839 I need a way to declare additional inputs to a custom rule.
-    #         A possible workaround is a shell script phase prior to
-    #         compilation that touches a rule's primary input files if any
-    #         would-be additional inputs are newer than the output.  Modifying
-    #         the source tree - even just modification times - feels dirty.
-    # 6564240 Xcode "custom script" build rules always dump all environment
-    #         variables.  This is a low-prioroty problem and is not a
-    #         show-stopper.
-    rules_by_ext = {}
-    for rule in spec_rules:
-      rules_by_ext[rule['extension']] = rule
-
-      # First, some definitions:
-      #
-      # A "rule source" is a file that was listed in a target's "sources"
-      # list and will have a rule applied to it on the basis of matching the
-      # rule's "extensions" attribute.  Rule sources are direct inputs to
-      # rules.
-      #
-      # Rule definitions may specify additional inputs in their "inputs"
-      # attribute.  These additional inputs are used for dependency tracking
-      # purposes.
-      #
-      # A "concrete output" is a rule output with input-dependent variables
-      # resolved.  For example, given a rule with:
-      #   'extension': 'ext', 'outputs': ['$(INPUT_FILE_BASE).cc'],
-      # if the target's "sources" list contained "one.ext" and "two.ext",
-      # the "concrete output" for rule input "two.ext" would be "two.cc".  If
-      # a rule specifies multiple outputs, each input file that the rule is
-      # applied to will have the same number of concrete outputs.
-      #
-      # If any concrete outputs are outdated or missing relative to their
-      # corresponding rule_source or to any specified additional input, the
-      # rule action must be performed to generate the concrete outputs.
-
-      # concrete_outputs_by_rule_source will have an item at the same index
-      # as the rule['rule_sources'] that it corresponds to.  Each item is a
-      # list of all of the concrete outputs for the rule_source.
-      concrete_outputs_by_rule_source = []
-
-      # concrete_outputs_all is a flat list of all concrete outputs that this
-      # rule is able to produce, given the known set of input files
-      # (rule_sources) that apply to it.
-      concrete_outputs_all = []
-
-      # messages & actions are keyed by the same indices as rule['rule_sources']
-      # and concrete_outputs_by_rule_source.  They contain the message and
-      # action to perform after resolving input-dependent variables.  The
-      # message is optional, in which case None is stored for each rule source.
-      messages = []
-      actions = []
-
-      for rule_source in rule.get('rule_sources', []):
-        rule_source_dirname, rule_source_basename = \
-            posixpath.split(rule_source)
-        (rule_source_root, rule_source_ext) = \
-            posixpath.splitext(rule_source_basename)
-
-        # These are the same variable names that Xcode uses for its own native
-        # rule support.  Because Xcode's rule engine is not being used, they
-        # need to be expanded as they are written to the makefile.
-        rule_input_dict = {
-          'INPUT_FILE_BASE':   rule_source_root,
-          'INPUT_FILE_SUFFIX': rule_source_ext,
-          'INPUT_FILE_NAME':   rule_source_basename,
-          'INPUT_FILE_PATH':   rule_source,
-          'INPUT_FILE_DIRNAME': rule_source_dirname,
+        target_properties = {
+            "buildConfigurationList": xccl,
+            "name": target_name,
         }
 
-        concrete_outputs_for_this_rule_source = []
-        for output in rule.get('outputs', []):
-          # Fortunately, Xcode and make both use $(VAR) format for their
-          # variables, so the expansion is the only transformation necessary.
-          # Any remaning $(VAR)-type variables in the string can be given
-          # directly to make, which will pick up the correct settings from
-          # what Xcode puts into the environment.
-          concrete_output = ExpandXcodeVariables(output, rule_input_dict)
-          concrete_outputs_for_this_rule_source.append(concrete_output)
-
-          # Add all concrete outputs to the project.
-          pbxp.AddOrGetFileInRootGroup(concrete_output)
-
-        concrete_outputs_by_rule_source.append( \
-            concrete_outputs_for_this_rule_source)
-        concrete_outputs_all.extend(concrete_outputs_for_this_rule_source)
-
-        # TODO(mark): Should verify that at most one of these is specified.
-        if int(rule.get('process_outputs_as_sources', False)):
-          for output in concrete_outputs_for_this_rule_source:
-            AddSourceToTarget(output, type, pbxp, xct)
-
-        # If the file came from the mac_bundle_resources list or if the rule
-        # is marked to process outputs as bundle resource, do so.
-        was_mac_bundle_resource = rule_source in tgt_mac_bundle_resources
-        if was_mac_bundle_resource or \
-            int(rule.get('process_outputs_as_mac_bundle_resources', False)):
-          for output in concrete_outputs_for_this_rule_source:
-            AddResourceToTarget(output, pbxp, xct)
-
-        # Do we have a message to print when this rule runs?
-        message = rule.get('message')
-        if message:
-          message = gyp.common.EncodePOSIXShellArgument(message)
-          message = ExpandXcodeVariables(message, rule_input_dict)
-        messages.append(message)
-
-        # Turn the list into a string that can be passed to a shell.
-        action_string = gyp.common.EncodePOSIXShellList(rule['action'])
-
-        action = ExpandXcodeVariables(action_string, rule_input_dict)
-        actions.append(action)
-
-      if len(concrete_outputs_all) > 0:
-        # TODO(mark): There's a possibility for collision here.  Consider
-        # target "t" rule "A_r" and target "t_A" rule "r".
-        makefile_name = '%s.make' % re.sub(
-            '[^a-zA-Z0-9_]', '_' , '%s_%s' % (target_name, rule['rule_name']))
-        makefile_path = os.path.join(xcode_projects[build_file].path,
-                                     makefile_name)
-        # TODO(mark): try/close?  Write to a temporary file and swap it only
-        # if it's got changes?
-        makefile = open(makefile_path, 'wb')
-
-        # make will build the first target in the makefile by default.  By
-        # convention, it's called "all".  List all (or at least one)
-        # concrete output for each rule source as a prerequisite of the "all"
-        # target.
-        makefile.write('all: \\\n')
-        for concrete_output_index in \
-            range(0, len(concrete_outputs_by_rule_source)):
-          # Only list the first (index [0]) concrete output of each input
-          # in the "all" target.  Otherwise, a parallel make (-j > 1) would
-          # attempt to process each input multiple times simultaneously.
-          # Otherwise, "all" could just contain the entire list of
-          # concrete_outputs_all.
-          concrete_output = \
-              concrete_outputs_by_rule_source[concrete_output_index][0]
-          if concrete_output_index == len(concrete_outputs_by_rule_source) - 1:
-            eol = ''
-          else:
-            eol = ' \\'
-          makefile.write('    %s%s\n' % (concrete_output, eol))
-
-        for (rule_source, concrete_outputs, message, action) in \
-            zip(rule['rule_sources'], concrete_outputs_by_rule_source,
-                messages, actions):
-          makefile.write('\n')
-
-          # Add a rule that declares it can build each concrete output of a
-          # rule source.  Collect the names of the directories that are
-          # required.
-          concrete_output_dirs = []
-          for concrete_output_index in range(0, len(concrete_outputs)):
-            concrete_output = concrete_outputs[concrete_output_index]
-            if concrete_output_index == 0:
-              bol = ''
+        type = spec["type"]
+        is_xctest = int(spec.get("mac_xctest_bundle", 0))
+        is_xcuitest = int(spec.get("mac_xcuitest_bundle", 0))
+        is_bundle = int(spec.get("mac_bundle", 0)) or is_xctest
+        is_app_extension = int(spec.get("ios_app_extension", 0))
+        is_watchkit_extension = int(spec.get("ios_watchkit_extension", 0))
+        is_watch_app = int(spec.get("ios_watch_app", 0))
+        if type != "none":
+            type_bundle_key = type
+            if is_xcuitest:
+                type_bundle_key += "+xcuitest"
+                assert type == "loadable_module", (
+                    "mac_xcuitest_bundle targets must have type loadable_module "
+                    "(target %s)" % target_name
+                )
+            elif is_xctest:
+                type_bundle_key += "+xctest"
+                assert type == "loadable_module", (
+                    "mac_xctest_bundle targets must have type loadable_module "
+                    "(target %s)" % target_name
+                )
+            elif is_app_extension:
+                assert is_bundle, (
+                    "ios_app_extension flag requires mac_bundle "
+                    "(target %s)" % target_name
+                )
+                type_bundle_key += "+extension+bundle"
+            elif is_watchkit_extension:
+                assert is_bundle, (
+                    "ios_watchkit_extension flag requires mac_bundle "
+                    "(target %s)" % target_name
+                )
+                type_bundle_key += "+watch+extension+bundle"
+            elif is_watch_app:
+                assert is_bundle, (
+                    "ios_watch_app flag requires mac_bundle "
+                    "(target %s)" % target_name
+                )
+                type_bundle_key += "+watch+bundle"
+            elif is_bundle:
+                type_bundle_key += "+bundle"
+
+            xctarget_type = gyp.xcodeproj_file.PBXNativeTarget
+            try:
+                target_properties["productType"] = _types[type_bundle_key]
+            except KeyError as e:
+                gyp.common.ExceptionAppend(
+                    e,
+                    "-- unknown product type while " "writing target %s" % target_name,
+                )
+                raise
+        else:
+            xctarget_type = gyp.xcodeproj_file.PBXAggregateTarget
+            assert not is_bundle, (
+                'mac_bundle targets cannot have type none (target "%s")' % target_name
+            )
+            assert not is_xcuitest, (
+                'mac_xcuitest_bundle targets cannot have type none (target "%s")'
+                % target_name
+            )
+            assert not is_xctest, (
+                'mac_xctest_bundle targets cannot have type none (target "%s")'
+                % target_name
+            )
+
+        target_product_name = spec.get("product_name")
+        if target_product_name is not None:
+            target_properties["productName"] = target_product_name
+
+        xct = xctarget_type(
+            target_properties,
+            parent=pbxp,
+            force_outdir=spec.get("product_dir"),
+            force_prefix=spec.get("product_prefix"),
+            force_extension=spec.get("product_extension"),
+        )
+        pbxp.AppendProperty("targets", xct)
+        xcode_targets[qualified_target] = xct
+        xcode_target_to_target_dict[xct] = spec
+
+        spec_actions = spec.get("actions", [])
+        spec_rules = spec.get("rules", [])
+
+        # Xcode has some "issues" with checking dependencies for the "Compile
+        # sources" step with any source files/headers generated by actions/rules.
+        # To work around this, if a target is building anything directly (not
+        # type "none"), then a second target is used to run the GYP actions/rules
+        # and is made a dependency of this target.  This way the work is done
+        # before the dependency checks for what should be recompiled.
+        support_xct = None
+        # The Xcode "issues" don't affect xcode-ninja builds, since the dependency
+        # logic all happens in ninja.  Don't bother creating the extra targets in
+        # that case.
+        if type != "none" and (spec_actions or spec_rules) and not ninja_wrapper:
+            support_xccl = CreateXCConfigurationList(configuration_names)
+            support_target_suffix = generator_flags.get(
+                "support_target_suffix", " Support"
+            )
+            support_target_properties = {
+                "buildConfigurationList": support_xccl,
+                "name": target_name + support_target_suffix,
+            }
+            if target_product_name:
+                support_target_properties["productName"] = (
+                    target_product_name + " Support"
+                )
+            support_xct = gyp.xcodeproj_file.PBXAggregateTarget(
+                support_target_properties, parent=pbxp
+            )
+            pbxp.AppendProperty("targets", support_xct)
+            xct.AddDependency(support_xct)
+        # Hang the support target off the main target so it can be tested/found
+        # by the generator during Finalize.
+        xct.support_target = support_xct
+
+        prebuild_index = 0
+
+        # Add custom shell script phases for "actions" sections.
+        for action in spec_actions:
+            # There's no need to write anything into the script to ensure that the
+            # output directories already exist, because Xcode will look at the
+            # declared outputs and automatically ensure that they exist for us.
+
+            # Do we have a message to print when this action runs?
+            message = action.get("message")
+            if message:
+                message = "echo note: " + gyp.common.EncodePOSIXShellArgument(message)
             else:
-              bol = '    '
-            makefile.write('%s%s \\\n' % (bol, concrete_output))
-
-            concrete_output_dir = posixpath.dirname(concrete_output)
-            if (concrete_output_dir and
-                concrete_output_dir not in concrete_output_dirs):
-              concrete_output_dirs.append(concrete_output_dir)
-
-          makefile.write('    : \\\n')
-
-          # The prerequisites for this rule are the rule source itself and
-          # the set of additional rule inputs, if any.
-          prerequisites = [rule_source]
-          prerequisites.extend(rule.get('inputs', []))
-          for prerequisite_index in range(0, len(prerequisites)):
-            prerequisite = prerequisites[prerequisite_index]
-            if prerequisite_index == len(prerequisites) - 1:
-              eol = ''
+                message = ""
+
+            # Turn the list into a string that can be passed to a shell.
+            action_string = gyp.common.EncodePOSIXShellList(action["action"])
+
+            # Convert Xcode-type variable references to sh-compatible environment
+            # variable references.
+            message_sh = gyp.xcodeproj_file.ConvertVariablesToShellSyntax(message)
+            action_string_sh = gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
+                action_string
+            )
+
+            script = ""
+            # Include the optional message
+            if message_sh:
+                script += message_sh + "\n"
+            # Be sure the script runs in exec, and that if exec fails, the script
+            # exits signalling an error.
+            script += "exec " + action_string_sh + "\nexit 1\n"
+            ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase(
+                {
+                    "inputPaths": action["inputs"],
+                    "name": 'Action "' + action["action_name"] + '"',
+                    "outputPaths": action["outputs"],
+                    "shellScript": script,
+                    "showEnvVarsInLog": 0,
+                }
+            )
+
+            if support_xct:
+                support_xct.AppendProperty("buildPhases", ssbp)
             else:
-              eol = ' \\'
-            makefile.write('    %s%s\n' % (prerequisite, eol))
-
-          # Make sure that output directories exist before executing the rule
-          # action.
-          if len(concrete_output_dirs) > 0:
-            makefile.write('\t@mkdir -p "%s"\n' %
-                           '" "'.join(concrete_output_dirs))
-
-          # The rule message and action have already had the necessary variable
-          # substitutions performed.
-          if message:
-            # Mark it with note: so Xcode picks it up in build output.
-            makefile.write('\t@echo note: %s\n' % message)
-          makefile.write('\t%s\n' % action)
-
-        makefile.close()
-
-        # It might be nice to ensure that needed output directories exist
-        # here rather than in each target in the Makefile, but that wouldn't
-        # work if there ever was a concrete output that had an input-dependent
-        # variable anywhere other than in the leaf position.
-
-        # Don't declare any inputPaths or outputPaths.  If they're present,
-        # Xcode will provide a slight optimization by only running the script
-        # phase if any output is missing or outdated relative to any input.
-        # Unfortunately, it will also assume that all outputs are touched by
-        # the script, and if the outputs serve as files in a compilation
-        # phase, they will be unconditionally rebuilt.  Since make might not
-        # rebuild everything that could be declared here as an output, this
-        # extra compilation activity is unnecessary.  With inputPaths and
-        # outputPaths not supplied, make will always be called, but it knows
-        # enough to not do anything when everything is up-to-date.
-
-        # To help speed things up, pass -j COUNT to make so it does some work
-        # in parallel.  Don't use ncpus because Xcode will build ncpus targets
-        # in parallel and if each target happens to have a rules step, there
-        # would be ncpus^2 things going.  With a machine that has 2 quad-core
-        # Xeons, a build can quickly run out of processes based on
-        # scheduling/other tasks, and randomly failing builds are no good.
-        script = \
-"""JOB_COUNT="$(/usr/sbin/sysctl -n hw.ncpu)"
+                # TODO(mark): this assumes too much knowledge of the internals of
+                # xcodeproj_file; some of these smarts should move into xcodeproj_file
+                # itself.
+                xct._properties["buildPhases"].insert(prebuild_index, ssbp)
+                prebuild_index = prebuild_index + 1
+
+            # TODO(mark): Should verify that at most one of these is specified.
+            if int(action.get("process_outputs_as_sources", False)):
+                for output in action["outputs"]:
+                    AddSourceToTarget(output, type, pbxp, xct)
+
+            if int(action.get("process_outputs_as_mac_bundle_resources", False)):
+                for output in action["outputs"]:
+                    AddResourceToTarget(output, pbxp, xct)
+
+        # tgt_mac_bundle_resources holds the list of bundle resources so
+        # the rule processing can check against it.
+        if is_bundle:
+            tgt_mac_bundle_resources = spec.get("mac_bundle_resources", [])
+        else:
+            tgt_mac_bundle_resources = []
+
+        # Add custom shell script phases driving "make" for "rules" sections.
+        #
+        # Xcode's built-in rule support is almost powerful enough to use directly,
+        # but there are a few significant deficiencies that render them unusable.
+        # There are workarounds for some of its inadequacies, but in aggregate,
+        # the workarounds added complexity to the generator, and some workarounds
+        # actually require input files to be crafted more carefully than I'd like.
+        # Consequently, until Xcode rules are made more capable, "rules" input
+        # sections will be handled in Xcode output by shell script build phases
+        # performed prior to the compilation phase.
+        #
+        # The following problems with Xcode rules were found.  The numbers are
+        # Apple radar IDs.  I hope that these shortcomings are addressed, I really
+        # liked having the rules handled directly in Xcode during the period that
+        # I was prototyping this.
+        #
+        # 6588600 Xcode compiles custom script rule outputs too soon, compilation
+        #         fails.  This occurs when rule outputs from distinct inputs are
+        #         interdependent.  The only workaround is to put rules and their
+        #         inputs in a separate target from the one that compiles the rule
+        #         outputs.  This requires input file cooperation and it means that
+        #         process_outputs_as_sources is unusable.
+        # 6584932 Need to declare that custom rule outputs should be excluded from
+        #         compilation.  A possible workaround is to lie to Xcode about a
+        #         rule's output, giving it a dummy file it doesn't know how to
+        #         compile.  The rule action script would need to touch the dummy.
+        # 6584839 I need a way to declare additional inputs to a custom rule.
+        #         A possible workaround is a shell script phase prior to
+        #         compilation that touches a rule's primary input files if any
+        #         would-be additional inputs are newer than the output.  Modifying
+        #         the source tree - even just modification times - feels dirty.
+        # 6564240 Xcode "custom script" build rules always dump all environment
+        #         variables.  This is a low-prioroty problem and is not a
+        #         show-stopper.
+        rules_by_ext = {}
+        for rule in spec_rules:
+            rules_by_ext[rule["extension"]] = rule
+
+            # First, some definitions:
+            #
+            # A "rule source" is a file that was listed in a target's "sources"
+            # list and will have a rule applied to it on the basis of matching the
+            # rule's "extensions" attribute.  Rule sources are direct inputs to
+            # rules.
+            #
+            # Rule definitions may specify additional inputs in their "inputs"
+            # attribute.  These additional inputs are used for dependency tracking
+            # purposes.
+            #
+            # A "concrete output" is a rule output with input-dependent variables
+            # resolved.  For example, given a rule with:
+            #   'extension': 'ext', 'outputs': ['$(INPUT_FILE_BASE).cc'],
+            # if the target's "sources" list contained "one.ext" and "two.ext",
+            # the "concrete output" for rule input "two.ext" would be "two.cc".  If
+            # a rule specifies multiple outputs, each input file that the rule is
+            # applied to will have the same number of concrete outputs.
+            #
+            # If any concrete outputs are outdated or missing relative to their
+            # corresponding rule_source or to any specified additional input, the
+            # rule action must be performed to generate the concrete outputs.
+
+            # concrete_outputs_by_rule_source will have an item at the same index
+            # as the rule['rule_sources'] that it corresponds to.  Each item is a
+            # list of all of the concrete outputs for the rule_source.
+            concrete_outputs_by_rule_source = []
+
+            # concrete_outputs_all is a flat list of all concrete outputs that this
+            # rule is able to produce, given the known set of input files
+            # (rule_sources) that apply to it.
+            concrete_outputs_all = []
+
+            # messages & actions are keyed by the same indices as rule['rule_sources']
+            # and concrete_outputs_by_rule_source.  They contain the message and
+            # action to perform after resolving input-dependent variables.  The
+            # message is optional, in which case None is stored for each rule source.
+            messages = []
+            actions = []
+
+            for rule_source in rule.get("rule_sources", []):
+                rule_source_dirname, rule_source_basename = posixpath.split(rule_source)
+                (rule_source_root, rule_source_ext) = posixpath.splitext(
+                    rule_source_basename
+                )
+
+                # These are the same variable names that Xcode uses for its own native
+                # rule support.  Because Xcode's rule engine is not being used, they
+                # need to be expanded as they are written to the makefile.
+                rule_input_dict = {
+                    "INPUT_FILE_BASE": rule_source_root,
+                    "INPUT_FILE_SUFFIX": rule_source_ext,
+                    "INPUT_FILE_NAME": rule_source_basename,
+                    "INPUT_FILE_PATH": rule_source,
+                    "INPUT_FILE_DIRNAME": rule_source_dirname,
+                }
+
+                concrete_outputs_for_this_rule_source = []
+                for output in rule.get("outputs", []):
+                    # Fortunately, Xcode and make both use $(VAR) format for their
+                    # variables, so the expansion is the only transformation necessary.
+                    # Any remaining $(VAR)-type variables in the string can be given
+                    # directly to make, which will pick up the correct settings from
+                    # what Xcode puts into the environment.
+                    concrete_output = ExpandXcodeVariables(output, rule_input_dict)
+                    concrete_outputs_for_this_rule_source.append(concrete_output)
+
+                    # Add all concrete outputs to the project.
+                    pbxp.AddOrGetFileInRootGroup(concrete_output)
+
+                concrete_outputs_by_rule_source.append(
+                    concrete_outputs_for_this_rule_source
+                )
+                concrete_outputs_all.extend(concrete_outputs_for_this_rule_source)
+
+                # TODO(mark): Should verify that at most one of these is specified.
+                if int(rule.get("process_outputs_as_sources", False)):
+                    for output in concrete_outputs_for_this_rule_source:
+                        AddSourceToTarget(output, type, pbxp, xct)
+
+                # If the file came from the mac_bundle_resources list or if the rule
+                # is marked to process outputs as bundle resource, do so.
+                was_mac_bundle_resource = rule_source in tgt_mac_bundle_resources
+                if was_mac_bundle_resource or int(
+                    rule.get("process_outputs_as_mac_bundle_resources", False)
+                ):
+                    for output in concrete_outputs_for_this_rule_source:
+                        AddResourceToTarget(output, pbxp, xct)
+
+                # Do we have a message to print when this rule runs?
+                message = rule.get("message")
+                if message:
+                    message = gyp.common.EncodePOSIXShellArgument(message)
+                    message = ExpandXcodeVariables(message, rule_input_dict)
+                messages.append(message)
+
+                # Turn the list into a string that can be passed to a shell.
+                action_string = gyp.common.EncodePOSIXShellList(rule["action"])
+
+                action = ExpandXcodeVariables(action_string, rule_input_dict)
+                actions.append(action)
+
+            if len(concrete_outputs_all) > 0:
+                # TODO(mark): There's a possibility for collision here.  Consider
+                # target "t" rule "A_r" and target "t_A" rule "r".
+                makefile_name = "%s.make" % re.sub(
+                    "[^a-zA-Z0-9_]", "_", "%s_%s" % (target_name, rule["rule_name"])
+                )
+                makefile_path = os.path.join(
+                    xcode_projects[build_file].path, makefile_name
+                )
+                # TODO(mark): try/close?  Write to a temporary file and swap it only
+                # if it's got changes?
+                makefile = open(makefile_path, "w")
+
+                # make will build the first target in the makefile by default.  By
+                # convention, it's called "all".  List all (or at least one)
+                # concrete output for each rule source as a prerequisite of the "all"
+                # target.
+                makefile.write("all: \\\n")
+                for concrete_output_index, concrete_output_by_rule_source in enumerate(
+                    concrete_outputs_by_rule_source
+                ):
+                    # Only list the first (index [0]) concrete output of each input
+                    # in the "all" target.  Otherwise, a parallel make (-j > 1) would
+                    # attempt to process each input multiple times simultaneously.
+                    # Otherwise, "all" could just contain the entire list of
+                    # concrete_outputs_all.
+                    concrete_output = concrete_output_by_rule_source[0]
+                    if (
+                        concrete_output_index
+                        == len(concrete_outputs_by_rule_source) - 1
+                    ):
+                        eol = ""
+                    else:
+                        eol = " \\"
+                    makefile.write("    %s%s\n" % (concrete_output, eol))
+
+                for (rule_source, concrete_outputs, message, action) in zip(
+                    rule["rule_sources"],
+                    concrete_outputs_by_rule_source,
+                    messages,
+                    actions,
+                ):
+                    makefile.write("\n")
+
+                    # Add a rule that declares it can build each concrete output of a
+                    # rule source.  Collect the names of the directories that are
+                    # required.
+                    concrete_output_dirs = []
+                    for concrete_output_index, concrete_output in enumerate(
+                        concrete_outputs
+                    ):
+                        if concrete_output_index == 0:
+                            bol = ""
+                        else:
+                            bol = "    "
+                        makefile.write("%s%s \\\n" % (bol, concrete_output))
+
+                        concrete_output_dir = posixpath.dirname(concrete_output)
+                        if (
+                            concrete_output_dir
+                            and concrete_output_dir not in concrete_output_dirs
+                        ):
+                            concrete_output_dirs.append(concrete_output_dir)
+
+                    makefile.write("    : \\\n")
+
+                    # The prerequisites for this rule are the rule source itself and
+                    # the set of additional rule inputs, if any.
+                    prerequisites = [rule_source]
+                    prerequisites.extend(rule.get("inputs", []))
+                    for prerequisite_index, prerequisite in enumerate(prerequisites):
+                        if prerequisite_index == len(prerequisites) - 1:
+                            eol = ""
+                        else:
+                            eol = " \\"
+                        makefile.write("    %s%s\n" % (prerequisite, eol))
+
+                    # Make sure that output directories exist before executing the rule
+                    # action.
+                    if len(concrete_output_dirs) > 0:
+                        makefile.write(
+                            '\t@mkdir -p "%s"\n' % '" "'.join(concrete_output_dirs)
+                        )
+
+                    # The rule message and action have already had
+                    # the necessary variable substitutions performed.
+                    if message:
+                        # Mark it with note: so Xcode picks it up in build output.
+                        makefile.write("\t@echo note: %s\n" % message)
+                    makefile.write("\t%s\n" % action)
+
+                makefile.close()
+
+                # It might be nice to ensure that needed output directories exist
+                # here rather than in each target in the Makefile, but that wouldn't
+                # work if there ever was a concrete output that had an input-dependent
+                # variable anywhere other than in the leaf position.
+
+                # Don't declare any inputPaths or outputPaths.  If they're present,
+                # Xcode will provide a slight optimization by only running the script
+                # phase if any output is missing or outdated relative to any input.
+                # Unfortunately, it will also assume that all outputs are touched by
+                # the script, and if the outputs serve as files in a compilation
+                # phase, they will be unconditionally rebuilt.  Since make might not
+                # rebuild everything that could be declared here as an output, this
+                # extra compilation activity is unnecessary.  With inputPaths and
+                # outputPaths not supplied, make will always be called, but it knows
+                # enough to not do anything when everything is up-to-date.
+
+                # To help speed things up, pass -j COUNT to make so it does some work
+                # in parallel.  Don't use ncpus because Xcode will build ncpus targets
+                # in parallel and if each target happens to have a rules step, there
+                # would be ncpus^2 things going.  With a machine that has 2 quad-core
+                # Xeons, a build can quickly run out of processes based on
+                # scheduling/other tasks, and randomly failing builds are no good.
+                script = (
+                    """JOB_COUNT="$(/usr/sbin/sysctl -n hw.ncpu)"
 if [ "${JOB_COUNT}" -gt 4 ]; then
   JOB_COUNT=4
 fi
 exec xcrun make -f "${PROJECT_FILE_PATH}/%s" -j "${JOB_COUNT}"
 exit 1
-""" % makefile_name
-        ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
-              'name': 'Rule "' + rule['rule_name'] + '"',
-              'shellScript': script,
-              'showEnvVarsInLog': 0,
-            })
-
-        if support_xct:
-          support_xct.AppendProperty('buildPhases', ssbp)
-        else:
-          # TODO(mark): this assumes too much knowledge of the internals of
-          # xcodeproj_file; some of these smarts should move into xcodeproj_file
-          # itself.
-          xct._properties['buildPhases'].insert(prebuild_index, ssbp)
-          prebuild_index = prebuild_index + 1
-
-      # Extra rule inputs also go into the project file.  Concrete outputs were
-      # already added when they were computed.
-      groups = ['inputs', 'inputs_excluded']
-      if skip_excluded_files:
-        groups = [x for x in groups if not x.endswith('_excluded')]
-      for group in groups:
-        for item in rule.get(group, []):
-          pbxp.AddOrGetFileInRootGroup(item)
-
-    # Add "sources".
-    for source in spec.get('sources', []):
-      (source_root, source_extension) = posixpath.splitext(source)
-      if source_extension[1:] not in rules_by_ext:
-        # AddSourceToTarget will add the file to a root group if it's not
-        # already there.
-        AddSourceToTarget(source, type, pbxp, xct)
-      else:
-        pbxp.AddOrGetFileInRootGroup(source)
-
-    # Add "mac_bundle_resources" and "mac_framework_private_headers" if
-    # it's a bundle of any type.
-    if is_bundle:
-      for resource in tgt_mac_bundle_resources:
-        (resource_root, resource_extension) = posixpath.splitext(resource)
-        if resource_extension[1:] not in rules_by_ext:
-          AddResourceToTarget(resource, pbxp, xct)
-        else:
-          pbxp.AddOrGetFileInRootGroup(resource)
-
-      for header in spec.get('mac_framework_private_headers', []):
-        AddHeaderToTarget(header, pbxp, xct, False)
-
-    # Add "mac_framework_headers". These can be valid for both frameworks
-    # and static libraries.
-    if is_bundle or type == 'static_library':
-      for header in spec.get('mac_framework_headers', []):
-        AddHeaderToTarget(header, pbxp, xct, True)
-
-    # Add "copies".
-    pbxcp_dict = {}
-    for copy_group in spec.get('copies', []):
-      dest = copy_group['destination']
-      if dest[0] not in ('/', '$'):
-        # Relative paths are relative to $(SRCROOT).
-        dest = '$(SRCROOT)/' + dest
-
-      code_sign = int(copy_group.get('xcode_code_sign', 0))
-      settings = (None, '{ATTRIBUTES = (CodeSignOnCopy, ); }')[code_sign]
-
-      # Coalesce multiple "copies" sections in the same target with the same
-      # "destination" property into the same PBXCopyFilesBuildPhase, otherwise
-      # they'll wind up with ID collisions.
-      pbxcp = pbxcp_dict.get(dest, None)
-      if pbxcp is None:
-        pbxcp = gyp.xcodeproj_file.PBXCopyFilesBuildPhase({
-              'name': 'Copy to ' + copy_group['destination']
-            },
-            parent=xct)
-        pbxcp.SetDestination(dest)
-
-        # TODO(mark): The usual comment about this knowing too much about
-        # gyp.xcodeproj_file internals applies.
-        xct._properties['buildPhases'].insert(prebuild_index, pbxcp)
-
-        pbxcp_dict[dest] = pbxcp
-
-      for file in copy_group['files']:
-        pbxcp.AddFile(file, settings)
-
-    # Excluded files can also go into the project file.
-    if not skip_excluded_files:
-      for key in ['sources', 'mac_bundle_resources', 'mac_framework_headers',
-                  'mac_framework_private_headers']:
-        excluded_key = key + '_excluded'
-        for item in spec.get(excluded_key, []):
-          pbxp.AddOrGetFileInRootGroup(item)
-
-    # So can "inputs" and "outputs" sections of "actions" groups.
-    groups = ['inputs', 'inputs_excluded', 'outputs', 'outputs_excluded']
-    if skip_excluded_files:
-      groups = [x for x in groups if not x.endswith('_excluded')]
-    for action in spec.get('actions', []):
-      for group in groups:
-        for item in action.get(group, []):
-          # Exclude anything in BUILT_PRODUCTS_DIR.  They're products, not
-          # sources.
-          if not item.startswith('$(BUILT_PRODUCTS_DIR)/'):
-            pbxp.AddOrGetFileInRootGroup(item)
-
-    for postbuild in spec.get('postbuilds', []):
-      action_string_sh = gyp.common.EncodePOSIXShellList(postbuild['action'])
-      script = 'exec ' + action_string_sh + '\nexit 1\n'
-
-      # Make the postbuild step depend on the output of ld or ar from this
-      # target. Apparently putting the script step after the link step isn't
-      # sufficient to ensure proper ordering in all cases. With an input
-      # declared but no outputs, the script step should run every time, as
-      # desired.
-      ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
-            'inputPaths': ['$(BUILT_PRODUCTS_DIR)/$(EXECUTABLE_PATH)'],
-            'name': 'Postbuild "' + postbuild['postbuild_name'] + '"',
-            'shellScript': script,
-            'showEnvVarsInLog': 0,
-          })
-      xct.AppendProperty('buildPhases', ssbp)
-
-    # Add dependencies before libraries, because adding a dependency may imply
-    # adding a library.  It's preferable to keep dependencies listed first
-    # during a link phase so that they can override symbols that would
-    # otherwise be provided by libraries, which will usually include system
-    # libraries.  On some systems, ld is finicky and even requires the
-    # libraries to be ordered in such a way that unresolved symbols in
-    # earlier-listed libraries may only be resolved by later-listed libraries.
-    # The Mac linker doesn't work that way, but other platforms do, and so
-    # their linker invocations need to be constructed in this way.  There's
-    # no compelling reason for Xcode's linker invocations to differ.
-
-    if 'dependencies' in spec:
-      for dependency in spec['dependencies']:
-        xct.AddDependency(xcode_targets[dependency])
-        # The support project also gets the dependencies (in case they are
-        # needed for the actions/rules to work).
-        if support_xct:
-          support_xct.AddDependency(xcode_targets[dependency])
-
-    if 'libraries' in spec:
-      for library in spec['libraries']:
-        xct.FrameworksPhase().AddFile(library)
-        # Add the library's directory to LIBRARY_SEARCH_PATHS if necessary.
-        # I wish Xcode handled this automatically.
-        library_dir = posixpath.dirname(library)
-        if library_dir not in xcode_standard_library_dirs and (
-            not xct.HasBuildSetting(_library_search_paths_var) or
-            library_dir not in xct.GetBuildSetting(_library_search_paths_var)):
-          xct.AppendBuildSetting(_library_search_paths_var, library_dir)
-
-    for configuration_name in configuration_names:
-      configuration = spec['configurations'][configuration_name]
-      xcbc = xct.ConfigurationNamed(configuration_name)
-      for include_dir in configuration.get('mac_framework_dirs', []):
-        xcbc.AppendBuildSetting('FRAMEWORK_SEARCH_PATHS', include_dir)
-      for include_dir in configuration.get('include_dirs', []):
-        xcbc.AppendBuildSetting('HEADER_SEARCH_PATHS', include_dir)
-      for library_dir in configuration.get('library_dirs', []):
-        if library_dir not in xcode_standard_library_dirs and (
-            not xcbc.HasBuildSetting(_library_search_paths_var) or
-            library_dir not in xcbc.GetBuildSetting(_library_search_paths_var)):
-          xcbc.AppendBuildSetting(_library_search_paths_var, library_dir)
-
-      if 'defines' in configuration:
-        for define in configuration['defines']:
-          set_define = EscapeXcodeDefine(define)
-          xcbc.AppendBuildSetting('GCC_PREPROCESSOR_DEFINITIONS', set_define)
-      if 'xcode_settings' in configuration:
-        for xck, xcv in configuration['xcode_settings'].items():
-          xcbc.SetBuildSetting(xck, xcv)
-      if 'xcode_config_file' in configuration:
-        config_ref = pbxp.AddOrGetFileInRootGroup(
-            configuration['xcode_config_file'])
-        xcbc.SetBaseConfiguration(config_ref)
-
-  build_files = []
-  for build_file, build_file_dict in data.items():
-    if build_file.endswith('.gyp'):
-      build_files.append(build_file)
-
-  for build_file in build_files:
-    xcode_projects[build_file].Finalize1(xcode_targets, serialize_all_tests)
-
-  for build_file in build_files:
-    xcode_projects[build_file].Finalize2(xcode_targets,
-                                         xcode_target_to_target_dict)
-
-  for build_file in build_files:
-    xcode_projects[build_file].Write()
+"""
+                    % makefile_name
+                )
+                ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase(
+                    {
+                        "name": 'Rule "' + rule["rule_name"] + '"',
+                        "shellScript": script,
+                        "showEnvVarsInLog": 0,
+                    }
+                )
+
+                if support_xct:
+                    support_xct.AppendProperty("buildPhases", ssbp)
+                else:
+                    # TODO(mark): this assumes too much knowledge of the internals of
+                    # xcodeproj_file; some of these smarts should move
+                    # into xcodeproj_file itself.
+                    xct._properties["buildPhases"].insert(prebuild_index, ssbp)
+                    prebuild_index = prebuild_index + 1
+
+            # Extra rule inputs also go into the project file.  Concrete outputs were
+            # already added when they were computed.
+            groups = ["inputs", "inputs_excluded"]
+            if skip_excluded_files:
+                groups = [x for x in groups if not x.endswith("_excluded")]
+            for group in groups:
+                for item in rule.get(group, []):
+                    pbxp.AddOrGetFileInRootGroup(item)
+
+        # Add "sources".
+        for source in spec.get("sources", []):
+            (source_root, source_extension) = posixpath.splitext(source)
+            if source_extension[1:] not in rules_by_ext:
+                # AddSourceToTarget will add the file to a root group if it's not
+                # already there.
+                AddSourceToTarget(source, type, pbxp, xct)
+            else:
+                pbxp.AddOrGetFileInRootGroup(source)
+
+        # Add "mac_bundle_resources" and "mac_framework_private_headers" if
+        # it's a bundle of any type.
+        if is_bundle:
+            for resource in tgt_mac_bundle_resources:
+                (resource_root, resource_extension) = posixpath.splitext(resource)
+                if resource_extension[1:] not in rules_by_ext:
+                    AddResourceToTarget(resource, pbxp, xct)
+                else:
+                    pbxp.AddOrGetFileInRootGroup(resource)
+
+            for header in spec.get("mac_framework_private_headers", []):
+                AddHeaderToTarget(header, pbxp, xct, False)
+
+        # Add "mac_framework_headers". These can be valid for both frameworks
+        # and static libraries.
+        if is_bundle or type == "static_library":
+            for header in spec.get("mac_framework_headers", []):
+                AddHeaderToTarget(header, pbxp, xct, True)
+
+        # Add "copies".
+        pbxcp_dict = {}
+        for copy_group in spec.get("copies", []):
+            dest = copy_group["destination"]
+            if dest[0] not in ("/", "$"):
+                # Relative paths are relative to $(SRCROOT).
+                dest = "$(SRCROOT)/" + dest
+
+            code_sign = int(copy_group.get("xcode_code_sign", 0))
+            settings = (None, "{ATTRIBUTES = (CodeSignOnCopy, ); }")[code_sign]
+
+            # Coalesce multiple "copies" sections in the same target with the same
+            # "destination" property into the same PBXCopyFilesBuildPhase, otherwise
+            # they'll wind up with ID collisions.
+            pbxcp = pbxcp_dict.get(dest, None)
+            if pbxcp is None:
+                pbxcp = gyp.xcodeproj_file.PBXCopyFilesBuildPhase(
+                    {"name": "Copy to " + copy_group["destination"]}, parent=xct
+                )
+                pbxcp.SetDestination(dest)
+
+                # TODO(mark): The usual comment about this knowing too much about
+                # gyp.xcodeproj_file internals applies.
+                xct._properties["buildPhases"].insert(prebuild_index, pbxcp)
+
+                pbxcp_dict[dest] = pbxcp
+
+            for file in copy_group["files"]:
+                pbxcp.AddFile(file, settings)
+
+        # Excluded files can also go into the project file.
+        if not skip_excluded_files:
+            for key in [
+                "sources",
+                "mac_bundle_resources",
+                "mac_framework_headers",
+                "mac_framework_private_headers",
+            ]:
+                excluded_key = key + "_excluded"
+                for item in spec.get(excluded_key, []):
+                    pbxp.AddOrGetFileInRootGroup(item)
+
+        # So can "inputs" and "outputs" sections of "actions" groups.
+        groups = ["inputs", "inputs_excluded", "outputs", "outputs_excluded"]
+        if skip_excluded_files:
+            groups = [x for x in groups if not x.endswith("_excluded")]
+        for action in spec.get("actions", []):
+            for group in groups:
+                for item in action.get(group, []):
+                    # Exclude anything in BUILT_PRODUCTS_DIR.  They're products, not
+                    # sources.
+                    if not item.startswith("$(BUILT_PRODUCTS_DIR)/"):
+                        pbxp.AddOrGetFileInRootGroup(item)
+
+        for postbuild in spec.get("postbuilds", []):
+            action_string_sh = gyp.common.EncodePOSIXShellList(postbuild["action"])
+            script = "exec " + action_string_sh + "\nexit 1\n"
+
+            # Make the postbuild step depend on the output of ld or ar from this
+            # target. Apparently putting the script step after the link step isn't
+            # sufficient to ensure proper ordering in all cases. With an input
+            # declared but no outputs, the script step should run every time, as
+            # desired.
+            ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase(
+                {
+                    "inputPaths": ["$(BUILT_PRODUCTS_DIR)/$(EXECUTABLE_PATH)"],
+                    "name": 'Postbuild "' + postbuild["postbuild_name"] + '"',
+                    "shellScript": script,
+                    "showEnvVarsInLog": 0,
+                }
+            )
+            xct.AppendProperty("buildPhases", ssbp)
+
+        # Add dependencies before libraries, because adding a dependency may imply
+        # adding a library.  It's preferable to keep dependencies listed first
+        # during a link phase so that they can override symbols that would
+        # otherwise be provided by libraries, which will usually include system
+        # libraries.  On some systems, ld is finicky and even requires the
+        # libraries to be ordered in such a way that unresolved symbols in
+        # earlier-listed libraries may only be resolved by later-listed libraries.
+        # The Mac linker doesn't work that way, but other platforms do, and so
+        # their linker invocations need to be constructed in this way.  There's
+        # no compelling reason for Xcode's linker invocations to differ.
+
+        if "dependencies" in spec:
+            for dependency in spec["dependencies"]:
+                xct.AddDependency(xcode_targets[dependency])
+                # The support project also gets the dependencies (in case they are
+                # needed for the actions/rules to work).
+                if support_xct:
+                    support_xct.AddDependency(xcode_targets[dependency])
+
+        if "libraries" in spec:
+            for library in spec["libraries"]:
+                xct.FrameworksPhase().AddFile(library)
+                # Add the library's directory to LIBRARY_SEARCH_PATHS if necessary.
+                # I wish Xcode handled this automatically.
+                library_dir = posixpath.dirname(library)
+                if library_dir not in xcode_standard_library_dirs and (
+                    not xct.HasBuildSetting(_library_search_paths_var)
+                    or library_dir not in xct.GetBuildSetting(_library_search_paths_var)
+                ):
+                    xct.AppendBuildSetting(_library_search_paths_var, library_dir)
+
+        for configuration_name in configuration_names:
+            configuration = spec["configurations"][configuration_name]
+            xcbc = xct.ConfigurationNamed(configuration_name)
+            for include_dir in configuration.get("mac_framework_dirs", []):
+                xcbc.AppendBuildSetting("FRAMEWORK_SEARCH_PATHS", include_dir)
+            for include_dir in configuration.get("include_dirs", []):
+                xcbc.AppendBuildSetting("HEADER_SEARCH_PATHS", include_dir)
+            for library_dir in configuration.get("library_dirs", []):
+                if library_dir not in xcode_standard_library_dirs and (
+                    not xcbc.HasBuildSetting(_library_search_paths_var)
+                    or library_dir
+                    not in xcbc.GetBuildSetting(_library_search_paths_var)
+                ):
+                    xcbc.AppendBuildSetting(_library_search_paths_var, library_dir)
+
+            if "defines" in configuration:
+                for define in configuration["defines"]:
+                    set_define = EscapeXcodeDefine(define)
+                    xcbc.AppendBuildSetting("GCC_PREPROCESSOR_DEFINITIONS", set_define)
+            if "xcode_settings" in configuration:
+                for xck, xcv in configuration["xcode_settings"].items():
+                    xcbc.SetBuildSetting(xck, xcv)
+            if "xcode_config_file" in configuration:
+                config_ref = pbxp.AddOrGetFileInRootGroup(
+                    configuration["xcode_config_file"]
+                )
+                xcbc.SetBaseConfiguration(config_ref)
+
+    build_files = []
+    for build_file, build_file_dict in data.items():
+        if build_file.endswith(".gyp"):
+            build_files.append(build_file)
+
+    for build_file in build_files:
+        xcode_projects[build_file].Finalize1(xcode_targets, serialize_all_tests)
+
+    for build_file in build_files:
+        xcode_projects[build_file].Finalize2(xcode_targets, xcode_target_to_target_dict)
+
+    for build_file in build_files:
+        xcode_projects[build_file].Write()
diff --git a/tools/gyp/pylib/gyp/generator/xcode_test.py b/tools/gyp/pylib/gyp/generator/xcode_test.py
index 260324a43f3e2341bef5ded968f7ca0ab5036b53..51fbca6a2a28f0606c2e278eb15131a2a53f30bc 100644
--- a/tools/gyp/pylib/gyp/generator/xcode_test.py
+++ b/tools/gyp/pylib/gyp/generator/xcode_test.py
@@ -12,12 +12,14 @@ import sys
 
 
 class TestEscapeXcodeDefine(unittest.TestCase):
-  if sys.platform == 'darwin':
-    def test_InheritedRemainsUnescaped(self):
-      self.assertEqual(xcode.EscapeXcodeDefine('$(inherited)'), '$(inherited)')
+    if sys.platform == "darwin":
 
-    def test_Escaping(self):
-      self.assertEqual(xcode.EscapeXcodeDefine('a b"c\\'), 'a\\ b\\"c\\\\')
+        def test_InheritedRemainsUnescaped(self):
+            self.assertEqual(xcode.EscapeXcodeDefine("$(inherited)"), "$(inherited)")
 
-if __name__ == '__main__':
-  unittest.main()
+        def test_Escaping(self):
+            self.assertEqual(xcode.EscapeXcodeDefine('a b"c\\'), 'a\\ b\\"c\\\\')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/gyp/pylib/gyp/input.py b/tools/gyp/pylib/gyp/input.py
index 1f40abb06951bbfac9d444afa34acb4b30e7658f..90397762404a7c5c83bfacdd026cc6270cf7c5e3 100644
--- a/tools/gyp/pylib/gyp/input.py
+++ b/tools/gyp/pylib/gyp/input.py
@@ -9,7 +9,6 @@ import ast
 import gyp.common
 import gyp.simple_copy
 import multiprocessing
-import optparse
 import os.path
 import re
 import shlex
@@ -17,7 +16,6 @@ import signal
 import subprocess
 import sys
 import threading
-import time
 import traceback
 from distutils.version import StrictVersion
 from gyp.common import GypError
@@ -27,28 +25,28 @@ PY3 = bytes != str
 
 # A list of types that are treated as linkable.
 linkable_types = [
-  'executable',
-  'shared_library',
-  'loadable_module',
-  'mac_kernel_extension',
-  'windows_driver',
+    "executable",
+    "shared_library",
+    "loadable_module",
+    "mac_kernel_extension",
+    "windows_driver",
 ]
 
 # A list of sections that contain links to other targets.
-dependency_sections = ['dependencies', 'export_dependent_settings']
+dependency_sections = ["dependencies", "export_dependent_settings"]
 
 # base_path_sections is a list of sections defined by GYP that contain
 # pathnames.  The generators can provide more keys, the two lists are merged
 # into path_sections, but you should call IsPathSection instead of using either
 # list directly.
 base_path_sections = [
-  'destination',
-  'files',
-  'include_dirs',
-  'inputs',
-  'libraries',
-  'outputs',
-  'sources',
+    "destination",
+    "files",
+    "include_dirs",
+    "inputs",
+    "libraries",
+    "outputs",
+    "sources",
 ]
 path_sections = set()
 
@@ -57,77 +55,78 @@ path_sections = set()
 per_process_data = {}
 per_process_aux_data = {}
 
+
 def IsPathSection(section):
-  # If section ends in one of the '=+?!' characters, it's applied to a section
-  # without the trailing characters.  '/' is notably absent from this list,
-  # because there's no way for a regular expression to be treated as a path.
-  while section and section[-1:] in '=+?!':
-    section = section[:-1]
-
-  if section in path_sections:
-    return True
-
-  # Sections mathing the regexp '_(dir|file|path)s?$' are also
-  # considered PathSections. Using manual string matching since that
-  # is much faster than the regexp and this can be called hundreds of
-  # thousands of times so micro performance matters.
-  if "_" in section:
-    tail = section[-6:]
-    if tail[-1] == 's':
-      tail = tail[:-1]
-    if tail[-5:] in ('_file', '_path'):
-      return True
-    return tail[-4:] == '_dir'
-
-  return False
+    # If section ends in one of the '=+?!' characters, it's applied to a section
+    # without the trailing characters.  '/' is notably absent from this list,
+    # because there's no way for a regular expression to be treated as a path.
+    while section and section[-1:] in "=+?!":
+        section = section[:-1]
+
+    if section in path_sections:
+        return True
+
+    # Sections matching the regexp '_(dir|file|path)s?$' are also
+    # considered PathSections. Using manual string matching since that
+    # is much faster than the regexp and this can be called hundreds of
+    # thousands of times so micro performance matters.
+    if "_" in section:
+        tail = section[-6:]
+        if tail[-1] == "s":
+            tail = tail[:-1]
+        if tail[-5:] in ("_file", "_path"):
+            return True
+        return tail[-4:] == "_dir"
+
+    return False
+
 
 # base_non_configuration_keys is a list of key names that belong in the target
 # itself and should not be propagated into its configurations.  It is merged
 # with a list that can come from the generator to
 # create non_configuration_keys.
 base_non_configuration_keys = [
-  # Sections that must exist inside targets and not configurations.
-  'actions',
-  'configurations',
-  'copies',
-  'default_configuration',
-  'dependencies',
-  'dependencies_original',
-  'libraries',
-  'postbuilds',
-  'product_dir',
-  'product_extension',
-  'product_name',
-  'product_prefix',
-  'rules',
-  'run_as',
-  'sources',
-  'standalone_static_library',
-  'suppress_wildcard',
-  'target_name',
-  'toolset',
-  'toolsets',
-  'type',
-
-  # Sections that can be found inside targets or configurations, but that
-  # should not be propagated from targets into their configurations.
-  'variables',
+    # Sections that must exist inside targets and not configurations.
+    "actions",
+    "configurations",
+    "copies",
+    "default_configuration",
+    "dependencies",
+    "dependencies_original",
+    "libraries",
+    "postbuilds",
+    "product_dir",
+    "product_extension",
+    "product_name",
+    "product_prefix",
+    "rules",
+    "run_as",
+    "sources",
+    "standalone_static_library",
+    "suppress_wildcard",
+    "target_name",
+    "toolset",
+    "toolsets",
+    "type",
+    # Sections that can be found inside targets or configurations, but that
+    # should not be propagated from targets into their configurations.
+    "variables",
 ]
 non_configuration_keys = []
 
 # Keys that do not belong inside a configuration dictionary.
 invalid_configuration_keys = [
-  'actions',
-  'all_dependent_settings',
-  'configurations',
-  'dependencies',
-  'direct_dependent_settings',
-  'libraries',
-  'link_settings',
-  'sources',
-  'standalone_static_library',
-  'target_name',
-  'type',
+    "actions",
+    "all_dependent_settings",
+    "configurations",
+    "dependencies",
+    "direct_dependent_settings",
+    "libraries",
+    "link_settings",
+    "sources",
+    "standalone_static_library",
+    "target_name",
+    "type",
 ]
 
 # Controls whether or not the generator supports multiple toolsets.
@@ -139,8 +138,9 @@ multiple_toolsets = False
 # }
 generator_filelist_paths = None
 
+
 def GetIncludedBuildFiles(build_file_path, aux_data, included=None):
-  """Return a list of all build files included into build_file_path.
+    """Return a list of all build files included into build_file_path.
 
   The returned list will contain build_file_path as well as all other files
   that it included, either directly or indirectly.  Note that the list may
@@ -158,535 +158,595 @@ def GetIncludedBuildFiles(build_file_path, aux_data, included=None):
   in the list will be relative to the current directory.
   """
 
-  if included is None:
-    included = []
+    if included is None:
+        included = []
 
-  if build_file_path in included:
-    return included
+    if build_file_path in included:
+        return included
 
-  included.append(build_file_path)
+    included.append(build_file_path)
 
-  for included_build_file in aux_data[build_file_path].get('included', []):
-    GetIncludedBuildFiles(included_build_file, aux_data, included)
+    for included_build_file in aux_data[build_file_path].get("included", []):
+        GetIncludedBuildFiles(included_build_file, aux_data, included)
 
-  return included
+    return included
 
 
 def CheckedEval(file_contents):
-  """Return the eval of a gyp file.
+    """Return the eval of a gyp file.
   The gyp file is restricted to dictionaries and lists only, and
   repeated keys are not allowed.
   Note that this is slower than eval() is.
   """
 
-  syntax_tree = ast.parse(file_contents)
-  assert isinstance(syntax_tree, ast.Module)
-  c1 = syntax_tree.body
-  assert len(c1) == 1
-  c2 = c1[0]
-  assert isinstance(c2, ast.Expr)
-  return CheckNode(c2.value, [])
+    syntax_tree = ast.parse(file_contents)
+    assert isinstance(syntax_tree, ast.Module)
+    c1 = syntax_tree.body
+    assert len(c1) == 1
+    c2 = c1[0]
+    assert isinstance(c2, ast.Expr)
+    return CheckNode(c2.value, [])
 
 
 def CheckNode(node, keypath):
-  if isinstance(node, ast.Dict):
-    c = node.getChildren()
-    dict = {}
-    for key, value in zip(node.keys, node.values):
-      assert isinstance(key, ast.Str)
-      key = key.s
-      if key in dict:
-        raise GypError("Key '" + key + "' repeated at level " +
-              repr(len(keypath) + 1) + " with key path '" +
-              '.'.join(keypath) + "'")
-      kp = list(keypath)  # Make a copy of the list for descending this node.
-      kp.append(key)
-      dict[key] = CheckNode(value, kp)
-    return dict
-  elif isinstance(node, ast.List):
-    children = []
-    for index, child in enumerate(node.elts):
-      kp = list(keypath)  # Copy list.
-      kp.append(repr(index))
-      children.append(CheckNode(child, kp))
-    return children
-  elif isinstance(node, ast.Str):
-    return node.s
-  else:
-    raise TypeError("Unknown AST node at key path '" + '.'.join(keypath) +
-        "': " + repr(node))
-
-
-def LoadOneBuildFile(build_file_path, data, aux_data, includes,
-                     is_target, check):
-  if build_file_path in data:
-    return data[build_file_path]
-
-  if os.path.exists(build_file_path):
-    # Open the build file for read ('r') with universal-newlines mode ('U')
-    # to make sure platform specific newlines ('\r\n' or '\r') are converted to '\n'
-    # which otherwise will fail eval()
-    if sys.platform == 'zos':
-      # On z/OS, universal-newlines mode treats the file as an ascii file. But since
-      # node-gyp produces ebcdic files, do not use that mode.
-      build_file_contents = open(build_file_path, 'r').read()
+    if isinstance(node, ast.Dict):
+        dict = {}
+        for key, value in zip(node.keys, node.values):
+            assert isinstance(key, ast.Str)
+            key = key.s
+            if key in dict:
+                raise GypError(
+                    "Key '"
+                    + key
+                    + "' repeated at level "
+                    + repr(len(keypath) + 1)
+                    + " with key path '"
+                    + ".".join(keypath)
+                    + "'"
+                )
+            kp = list(keypath)  # Make a copy of the list for descending this node.
+            kp.append(key)
+            dict[key] = CheckNode(value, kp)
+        return dict
+    elif isinstance(node, ast.List):
+        children = []
+        for index, child in enumerate(node.elts):
+            kp = list(keypath)  # Copy list.
+            kp.append(repr(index))
+            children.append(CheckNode(child, kp))
+        return children
+    elif isinstance(node, ast.Str):
+        return node.s
     else:
-      build_file_contents = open(build_file_path, 'rU').read()
-  else:
-    raise GypError("%s not found (cwd: %s)" % (build_file_path, os.getcwd()))
-
-  build_file_data = None
-  try:
-    if check:
-      build_file_data = CheckedEval(build_file_contents)
+        raise TypeError(
+            "Unknown AST node at key path '" + ".".join(keypath) + "': " + repr(node)
+        )
+
+
+def LoadOneBuildFile(build_file_path, data, aux_data, includes, is_target, check):
+    if build_file_path in data:
+        return data[build_file_path]
+
+    if os.path.exists(build_file_path):
+        # Open the build file for read ('r') with universal-newlines mode ('U')
+        # to make sure platform specific newlines ('\r\n' or '\r') are converted to '\n'
+        # which otherwise will fail eval()
+        if PY3 or sys.platform == "zos":
+            # On z/OS, universal-newlines mode treats the file as an ascii file.
+            # But since node-gyp produces ebcdic files, do not use that mode.
+            build_file_contents = open(build_file_path, "r").read()
+        else:
+            build_file_contents = open(build_file_path, "rU").read()
     else:
-      build_file_data = eval(build_file_contents, {'__builtins__': {}},
-                             None)
-  except SyntaxError as e:
-    e.filename = build_file_path
-    raise
-  except Exception as e:
-    gyp.common.ExceptionAppend(e, 'while reading ' + build_file_path)
-    raise
-
-  if type(build_file_data) is not dict:
-    raise GypError("%s does not evaluate to a dictionary." % build_file_path)
-
-  data[build_file_path] = build_file_data
-  aux_data[build_file_path] = {}
-
-  # Scan for includes and merge them in.
-  if ('skip_includes' not in build_file_data or
-      not build_file_data['skip_includes']):
+        raise GypError("%s not found (cwd: %s)" % (build_file_path, os.getcwd()))
+
+    build_file_data = None
     try:
-      if is_target:
-        LoadBuildFileIncludesIntoDict(build_file_data, build_file_path, data,
-                                      aux_data, includes, check)
-      else:
-        LoadBuildFileIncludesIntoDict(build_file_data, build_file_path, data,
-                                      aux_data, None, check)
+        if check:
+            build_file_data = CheckedEval(build_file_contents)
+        else:
+            build_file_data = eval(build_file_contents, {"__builtins__": {}}, None)
+    except SyntaxError as e:
+        e.filename = build_file_path
+        raise
     except Exception as e:
-      gyp.common.ExceptionAppend(e,
-                                 'while reading includes of ' + build_file_path)
-      raise
-
-  return build_file_data
-
-
-def LoadBuildFileIncludesIntoDict(subdict, subdict_path, data, aux_data,
-                                  includes, check):
-  includes_list = []
-  if includes != None:
-    includes_list.extend(includes)
-  if 'includes' in subdict:
-    for include in subdict['includes']:
-      # "include" is specified relative to subdict_path, so compute the real
-      # path to include by appending the provided "include" to the directory
-      # in which subdict_path resides.
-      relative_include = \
-          os.path.normpath(os.path.join(os.path.dirname(subdict_path), include))
-      includes_list.append(relative_include)
-    # Unhook the includes list, it's no longer needed.
-    del subdict['includes']
-
-  # Merge in the included files.
-  for include in includes_list:
-    if not 'included' in aux_data[subdict_path]:
-      aux_data[subdict_path]['included'] = []
-    aux_data[subdict_path]['included'].append(include)
-
-    gyp.DebugOutput(gyp.DEBUG_INCLUDES, "Loading Included File: '%s'", include)
-
-    MergeDicts(subdict,
-               LoadOneBuildFile(include, data, aux_data, None, False, check),
-               subdict_path, include)
-
-  # Recurse into subdictionaries.
-  for k, v in subdict.items():
-    if type(v) is dict:
-      LoadBuildFileIncludesIntoDict(v, subdict_path, data, aux_data,
-                                    None, check)
-    elif type(v) is list:
-      LoadBuildFileIncludesIntoList(v, subdict_path, data, aux_data,
-                                    check)
+        gyp.common.ExceptionAppend(e, "while reading " + build_file_path)
+        raise
+
+    if type(build_file_data) is not dict:
+        raise GypError("%s does not evaluate to a dictionary." % build_file_path)
+
+    data[build_file_path] = build_file_data
+    aux_data[build_file_path] = {}
+
+    # Scan for includes and merge them in.
+    if "skip_includes" not in build_file_data or not build_file_data["skip_includes"]:
+        try:
+            if is_target:
+                LoadBuildFileIncludesIntoDict(
+                    build_file_data, build_file_path, data, aux_data, includes, check
+                )
+            else:
+                LoadBuildFileIncludesIntoDict(
+                    build_file_data, build_file_path, data, aux_data, None, check
+                )
+        except Exception as e:
+            gyp.common.ExceptionAppend(
+                e, "while reading includes of " + build_file_path
+            )
+            raise
+
+    return build_file_data
+
+
+def LoadBuildFileIncludesIntoDict(
+    subdict, subdict_path, data, aux_data, includes, check
+):
+    includes_list = []
+    if includes is not None:
+        includes_list.extend(includes)
+    if "includes" in subdict:
+        for include in subdict["includes"]:
+            # "include" is specified relative to subdict_path, so compute the real
+            # path to include by appending the provided "include" to the directory
+            # in which subdict_path resides.
+            relative_include = os.path.normpath(
+                os.path.join(os.path.dirname(subdict_path), include)
+            )
+            includes_list.append(relative_include)
+        # Unhook the includes list, it's no longer needed.
+        del subdict["includes"]
+
+    # Merge in the included files.
+    for include in includes_list:
+        if "included" not in aux_data[subdict_path]:
+            aux_data[subdict_path]["included"] = []
+        aux_data[subdict_path]["included"].append(include)
+
+        gyp.DebugOutput(gyp.DEBUG_INCLUDES, "Loading Included File: '%s'", include)
+
+        MergeDicts(
+            subdict,
+            LoadOneBuildFile(include, data, aux_data, None, False, check),
+            subdict_path,
+            include,
+        )
+
+    # Recurse into subdictionaries.
+    for k, v in subdict.items():
+        if type(v) is dict:
+            LoadBuildFileIncludesIntoDict(v, subdict_path, data, aux_data, None, check)
+        elif type(v) is list:
+            LoadBuildFileIncludesIntoList(v, subdict_path, data, aux_data, check)
 
 
 # This recurses into lists so that it can look for dicts.
 def LoadBuildFileIncludesIntoList(sublist, sublist_path, data, aux_data, check):
-  for item in sublist:
-    if type(item) is dict:
-      LoadBuildFileIncludesIntoDict(item, sublist_path, data, aux_data,
-                                    None, check)
-    elif type(item) is list:
-      LoadBuildFileIncludesIntoList(item, sublist_path, data, aux_data, check)
+    for item in sublist:
+        if type(item) is dict:
+            LoadBuildFileIncludesIntoDict(
+                item, sublist_path, data, aux_data, None, check
+            )
+        elif type(item) is list:
+            LoadBuildFileIncludesIntoList(item, sublist_path, data, aux_data, check)
+
 
 # Processes toolsets in all the targets. This recurses into condition entries
 # since they can contain toolsets as well.
 def ProcessToolsetsInDict(data):
-  if 'targets' in data:
-    target_list = data['targets']
-    new_target_list = []
-    for target in target_list:
-      # If this target already has an explicit 'toolset', and no 'toolsets'
-      # list, don't modify it further.
-      if 'toolset' in target and 'toolsets' not in target:
-        new_target_list.append(target)
-        continue
-      if multiple_toolsets:
-        toolsets = target.get('toolsets', ['target'])
-      else:
-        toolsets = ['target']
-      # Make sure this 'toolsets' definition is only processed once.
-      if 'toolsets' in target:
-        del target['toolsets']
-      if len(toolsets) > 0:
-        # Optimization: only do copies if more than one toolset is specified.
-        for build in toolsets[1:]:
-          new_target = gyp.simple_copy.deepcopy(target)
-          new_target['toolset'] = build
-          new_target_list.append(new_target)
-        target['toolset'] = toolsets[0]
-        new_target_list.append(target)
-    data['targets'] = new_target_list
-  if 'conditions' in data:
-    for condition in data['conditions']:
-      if type(condition) is list:
-        for condition_dict in condition[1:]:
-          if type(condition_dict) is dict:
-            ProcessToolsetsInDict(condition_dict)
+    if "targets" in data:
+        target_list = data["targets"]
+        new_target_list = []
+        for target in target_list:
+            # If this target already has an explicit 'toolset', and no 'toolsets'
+            # list, don't modify it further.
+            if "toolset" in target and "toolsets" not in target:
+                new_target_list.append(target)
+                continue
+            if multiple_toolsets:
+                toolsets = target.get("toolsets", ["target"])
+            else:
+                toolsets = ["target"]
+            # Make sure this 'toolsets' definition is only processed once.
+            if "toolsets" in target:
+                del target["toolsets"]
+            if len(toolsets) > 0:
+                # Optimization: only do copies if more than one toolset is specified.
+                for build in toolsets[1:]:
+                    new_target = gyp.simple_copy.deepcopy(target)
+                    new_target["toolset"] = build
+                    new_target_list.append(new_target)
+                target["toolset"] = toolsets[0]
+                new_target_list.append(target)
+        data["targets"] = new_target_list
+    if "conditions" in data:
+        for condition in data["conditions"]:
+            if type(condition) is list:
+                for condition_dict in condition[1:]:
+                    if type(condition_dict) is dict:
+                        ProcessToolsetsInDict(condition_dict)
 
 
 # TODO(mark): I don't love this name.  It just means that it's going to load
 # a build file that contains targets and is expected to provide a targets dict
 # that contains the targets...
-def LoadTargetBuildFile(build_file_path, data, aux_data, variables, includes,
-                        depth, check, load_dependencies):
-  # If depth is set, predefine the DEPTH variable to be a relative path from
-  # this build file's directory to the directory identified by depth.
-  if depth:
-    # TODO(dglazkov) The backslash/forward-slash replacement at the end is a
-    # temporary measure. This should really be addressed by keeping all paths
-    # in POSIX until actual project generation.
-    d = gyp.common.RelativePath(depth, os.path.dirname(build_file_path))
-    if d == '':
-      variables['DEPTH'] = '.'
+def LoadTargetBuildFile(
+    build_file_path,
+    data,
+    aux_data,
+    variables,
+    includes,
+    depth,
+    check,
+    load_dependencies,
+):
+    # If depth is set, predefine the DEPTH variable to be a relative path from
+    # this build file's directory to the directory identified by depth.
+    if depth:
+        # TODO(dglazkov) The backslash/forward-slash replacement at the end is a
+        # temporary measure. This should really be addressed by keeping all paths
+        # in POSIX until actual project generation.
+        d = gyp.common.RelativePath(depth, os.path.dirname(build_file_path))
+        if d == "":
+            variables["DEPTH"] = "."
+        else:
+            variables["DEPTH"] = d.replace("\\", "/")
+
+    # The 'target_build_files' key is only set when loading target build files in
+    # the non-parallel code path, where LoadTargetBuildFile is called
+    # recursively.  In the parallel code path, we don't need to check whether the
+    # |build_file_path| has already been loaded, because the 'scheduled' set in
+    # ParallelState guarantees that we never load the same |build_file_path|
+    # twice.
+    if "target_build_files" in data:
+        if build_file_path in data["target_build_files"]:
+            # Already loaded.
+            return False
+        data["target_build_files"].add(build_file_path)
+
+    gyp.DebugOutput(
+        gyp.DEBUG_INCLUDES, "Loading Target Build File '%s'", build_file_path
+    )
+
+    build_file_data = LoadOneBuildFile(
+        build_file_path, data, aux_data, includes, True, check
+    )
+
+    # Store DEPTH for later use in generators.
+    build_file_data["_DEPTH"] = depth
+
+    # Set up the included_files key indicating which .gyp files contributed to
+    # this target dict.
+    if "included_files" in build_file_data:
+        raise GypError(build_file_path + " must not contain included_files key")
+
+    included = GetIncludedBuildFiles(build_file_path, aux_data)
+    build_file_data["included_files"] = []
+    for included_file in included:
+        # included_file is relative to the current directory, but it needs to
+        # be made relative to build_file_path's directory.
+        included_relative = gyp.common.RelativePath(
+            included_file, os.path.dirname(build_file_path)
+        )
+        build_file_data["included_files"].append(included_relative)
+
+    # Do a first round of toolsets expansion so that conditions can be defined
+    # per toolset.
+    ProcessToolsetsInDict(build_file_data)
+
+    # Apply "pre"/"early" variable expansions and condition evaluations.
+    ProcessVariablesAndConditionsInDict(
+        build_file_data, PHASE_EARLY, variables, build_file_path
+    )
+
+    # Since some toolsets might have been defined conditionally, perform
+    # a second round of toolsets expansion now.
+    ProcessToolsetsInDict(build_file_data)
+
+    # Look at each project's target_defaults dict, and merge settings into
+    # targets.
+    if "target_defaults" in build_file_data:
+        if "targets" not in build_file_data:
+            raise GypError("Unable to find targets in build file %s" % build_file_path)
+
+        index = 0
+        while index < len(build_file_data["targets"]):
+            # This procedure needs to give the impression that target_defaults is
+            # used as defaults, and the individual targets inherit from that.
+            # The individual targets need to be merged into the defaults.  Make
+            # a deep copy of the defaults for each target, merge the target dict
+            # as found in the input file into that copy, and then hook up the
+            # copy with the target-specific data merged into it as the replacement
+            # target dict.
+            old_target_dict = build_file_data["targets"][index]
+            new_target_dict = gyp.simple_copy.deepcopy(
+                build_file_data["target_defaults"]
+            )
+            MergeDicts(
+                new_target_dict, old_target_dict, build_file_path, build_file_path
+            )
+            build_file_data["targets"][index] = new_target_dict
+            index += 1
+
+        # No longer needed.
+        del build_file_data["target_defaults"]
+
+    # Look for dependencies.  This means that dependency resolution occurs
+    # after "pre" conditionals and variable expansion, but before "post" -
+    # in other words, you can't put a "dependencies" section inside a "post"
+    # conditional within a target.
+
+    dependencies = []
+    if "targets" in build_file_data:
+        for target_dict in build_file_data["targets"]:
+            if "dependencies" not in target_dict:
+                continue
+            for dependency in target_dict["dependencies"]:
+                dependencies.append(
+                    gyp.common.ResolveTarget(build_file_path, dependency, None)[0]
+                )
+
+    if load_dependencies:
+        for dependency in dependencies:
+            try:
+                LoadTargetBuildFile(
+                    dependency,
+                    data,
+                    aux_data,
+                    variables,
+                    includes,
+                    depth,
+                    check,
+                    load_dependencies,
+                )
+            except Exception as e:
+                gyp.common.ExceptionAppend(
+                    e, "while loading dependencies of %s" % build_file_path
+                )
+                raise
     else:
-      variables['DEPTH'] = d.replace('\\', '/')
-
-  # The 'target_build_files' key is only set when loading target build files in
-  # the non-parallel code path, where LoadTargetBuildFile is called
-  # recursively.  In the parallel code path, we don't need to check whether the
-  # |build_file_path| has already been loaded, because the 'scheduled' set in
-  # ParallelState guarantees that we never load the same |build_file_path|
-  # twice.
-  if 'target_build_files' in data:
-    if build_file_path in data['target_build_files']:
-      # Already loaded.
-      return False
-    data['target_build_files'].add(build_file_path)
-
-  gyp.DebugOutput(gyp.DEBUG_INCLUDES,
-                  "Loading Target Build File '%s'", build_file_path)
-
-  build_file_data = LoadOneBuildFile(build_file_path, data, aux_data,
-                                     includes, True, check)
-
-  # Store DEPTH for later use in generators.
-  build_file_data['_DEPTH'] = depth
-
-  # Set up the included_files key indicating which .gyp files contributed to
-  # this target dict.
-  if 'included_files' in build_file_data:
-    raise GypError(build_file_path + ' must not contain included_files key')
-
-  included = GetIncludedBuildFiles(build_file_path, aux_data)
-  build_file_data['included_files'] = []
-  for included_file in included:
-    # included_file is relative to the current directory, but it needs to
-    # be made relative to build_file_path's directory.
-    included_relative = \
-        gyp.common.RelativePath(included_file,
-                                os.path.dirname(build_file_path))
-    build_file_data['included_files'].append(included_relative)
-
-  # Do a first round of toolsets expansion so that conditions can be defined
-  # per toolset.
-  ProcessToolsetsInDict(build_file_data)
-
-  # Apply "pre"/"early" variable expansions and condition evaluations.
-  ProcessVariablesAndConditionsInDict(
-      build_file_data, PHASE_EARLY, variables, build_file_path)
-
-  # Since some toolsets might have been defined conditionally, perform
-  # a second round of toolsets expansion now.
-  ProcessToolsetsInDict(build_file_data)
-
-  # Look at each project's target_defaults dict, and merge settings into
-  # targets.
-  if 'target_defaults' in build_file_data:
-    if 'targets' not in build_file_data:
-      raise GypError("Unable to find targets in build file %s" %
-                     build_file_path)
+        return (build_file_path, dependencies)
 
-    index = 0
-    while index < len(build_file_data['targets']):
-      # This procedure needs to give the impression that target_defaults is
-      # used as defaults, and the individual targets inherit from that.
-      # The individual targets need to be merged into the defaults.  Make
-      # a deep copy of the defaults for each target, merge the target dict
-      # as found in the input file into that copy, and then hook up the
-      # copy with the target-specific data merged into it as the replacement
-      # target dict.
-      old_target_dict = build_file_data['targets'][index]
-      new_target_dict = gyp.simple_copy.deepcopy(
-        build_file_data['target_defaults'])
-      MergeDicts(new_target_dict, old_target_dict,
-                 build_file_path, build_file_path)
-      build_file_data['targets'][index] = new_target_dict
-      index += 1
-
-    # No longer needed.
-    del build_file_data['target_defaults']
-
-  # Look for dependencies.  This means that dependency resolution occurs
-  # after "pre" conditionals and variable expansion, but before "post" -
-  # in other words, you can't put a "dependencies" section inside a "post"
-  # conditional within a target.
-
-  dependencies = []
-  if 'targets' in build_file_data:
-    for target_dict in build_file_data['targets']:
-      if 'dependencies' not in target_dict:
-        continue
-      for dependency in target_dict['dependencies']:
-        dependencies.append(
-            gyp.common.ResolveTarget(build_file_path, dependency, None)[0])
-
-  if load_dependencies:
-    for dependency in dependencies:
-      try:
-        LoadTargetBuildFile(dependency, data, aux_data, variables,
-                            includes, depth, check, load_dependencies)
-      except Exception as e:
-        gyp.common.ExceptionAppend(
-          e, 'while loading dependencies of %s' % build_file_path)
-        raise
-  else:
-    return (build_file_path, dependencies)
 
-def CallLoadTargetBuildFile(global_flags,
-                            build_file_path, variables,
-                            includes, depth, check,
-                            generator_input_info):
-  """Wrapper around LoadTargetBuildFile for parallel processing.
+def CallLoadTargetBuildFile(
+    global_flags,
+    build_file_path,
+    variables,
+    includes,
+    depth,
+    check,
+    generator_input_info,
+):
+    """Wrapper around LoadTargetBuildFile for parallel processing.
 
      This wrapper is used when LoadTargetBuildFile is executed in
      a worker process.
   """
 
-  try:
-    signal.signal(signal.SIGINT, signal.SIG_IGN)
-
-    # Apply globals so that the worker process behaves the same.
-    for key, value in global_flags.items():
-      globals()[key] = value
-
-    SetGeneratorGlobals(generator_input_info)
-    result = LoadTargetBuildFile(build_file_path, per_process_data,
-                                 per_process_aux_data, variables,
-                                 includes, depth, check, False)
-    if not result:
-      return result
-
-    (build_file_path, dependencies) = result
-
-    # We can safely pop the build_file_data from per_process_data because it
-    # will never be referenced by this process again, so we don't need to keep
-    # it in the cache.
-    build_file_data = per_process_data.pop(build_file_path)
-
-    # This gets serialized and sent back to the main process via a pipe.
-    # It's handled in LoadTargetBuildFileCallback.
-    return (build_file_path,
-            build_file_data,
-            dependencies)
-  except GypError as e:
-    sys.stderr.write("gyp: %s\n" % e)
-    return None
-  except Exception as e:
-    print('Exception:', e, file=sys.stderr)
-    print(traceback.format_exc(), file=sys.stderr)
-    return None
+    try:
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+        # Apply globals so that the worker process behaves the same.
+        for key, value in global_flags.items():
+            globals()[key] = value
+
+        SetGeneratorGlobals(generator_input_info)
+        result = LoadTargetBuildFile(
+            build_file_path,
+            per_process_data,
+            per_process_aux_data,
+            variables,
+            includes,
+            depth,
+            check,
+            False,
+        )
+        if not result:
+            return result
+
+        (build_file_path, dependencies) = result
+
+        # We can safely pop the build_file_data from per_process_data because it
+        # will never be referenced by this process again, so we don't need to keep
+        # it in the cache.
+        build_file_data = per_process_data.pop(build_file_path)
+
+        # This gets serialized and sent back to the main process via a pipe.
+        # It's handled in LoadTargetBuildFileCallback.
+        return (build_file_path, build_file_data, dependencies)
+    except GypError as e:
+        sys.stderr.write("gyp: %s\n" % e)
+        return None
+    except Exception as e:
+        print("Exception:", e, file=sys.stderr)
+        print(traceback.format_exc(), file=sys.stderr)
+        return None
 
 
 class ParallelProcessingError(Exception):
-  pass
+    pass
 
 
 class ParallelState(object):
-  """Class to keep track of state when processing input files in parallel.
+    """Class to keep track of state when processing input files in parallel.
 
   If build files are loaded in parallel, use this to keep track of
   state during farming out and processing parallel jobs. It's stored
   in a global so that the callback function can have access to it.
   """
 
-  def __init__(self):
-    # The multiprocessing pool.
-    self.pool = None
-    # The condition variable used to protect this object and notify
-    # the main loop when there might be more data to process.
-    self.condition = None
-    # The "data" dict that was passed to LoadTargetBuildFileParallel
-    self.data = None
-    # The number of parallel calls outstanding; decremented when a response
-    # was received.
-    self.pending = 0
-    # The set of all build files that have been scheduled, so we don't
-    # schedule the same one twice.
-    self.scheduled = set()
-    # A list of dependency build file paths that haven't been scheduled yet.
-    self.dependencies = []
-    # Flag to indicate if there was an error in a child process.
-    self.error = False
-
-  def LoadTargetBuildFileCallback(self, result):
-    """Handle the results of running LoadTargetBuildFile in another process.
+    def __init__(self):
+        # The multiprocessing pool.
+        self.pool = None
+        # The condition variable used to protect this object and notify
+        # the main loop when there might be more data to process.
+        self.condition = None
+        # The "data" dict that was passed to LoadTargetBuildFileParallel
+        self.data = None
+        # The number of parallel calls outstanding; decremented when a response
+        # was received.
+        self.pending = 0
+        # The set of all build files that have been scheduled, so we don't
+        # schedule the same one twice.
+        self.scheduled = set()
+        # A list of dependency build file paths that haven't been scheduled yet.
+        self.dependencies = []
+        # Flag to indicate if there was an error in a child process.
+        self.error = False
+
+    def LoadTargetBuildFileCallback(self, result):
+        """Handle the results of running LoadTargetBuildFile in another process.
     """
-    self.condition.acquire()
-    if not result:
-      self.error = True
-      self.condition.notify()
-      self.condition.release()
-      return
-    (build_file_path0, build_file_data0, dependencies0) = result
-    self.data[build_file_path0] = build_file_data0
-    self.data['target_build_files'].add(build_file_path0)
-    for new_dependency in dependencies0:
-      if new_dependency not in self.scheduled:
-        self.scheduled.add(new_dependency)
-        self.dependencies.append(new_dependency)
-    self.pending -= 1
-    self.condition.notify()
-    self.condition.release()
-
-
-def LoadTargetBuildFilesParallel(build_files, data, variables, includes, depth,
-                                 check, generator_input_info):
-  parallel_state = ParallelState()
-  parallel_state.condition = threading.Condition()
-  # Make copies of the build_files argument that we can modify while working.
-  parallel_state.dependencies = list(build_files)
-  parallel_state.scheduled = set(build_files)
-  parallel_state.pending = 0
-  parallel_state.data = data
-
-  try:
-    parallel_state.condition.acquire()
-    while parallel_state.dependencies or parallel_state.pending:
-      if parallel_state.error:
-        break
-      if not parallel_state.dependencies:
-        parallel_state.condition.wait()
-        continue
-
-      dependency = parallel_state.dependencies.pop()
-
-      parallel_state.pending += 1
-      global_flags = {
-        'path_sections': globals()['path_sections'],
-        'non_configuration_keys': globals()['non_configuration_keys'],
-        'multiple_toolsets': globals()['multiple_toolsets']}
-
-      if not parallel_state.pool:
-        parallel_state.pool = multiprocessing.Pool(multiprocessing.cpu_count())
-      parallel_state.pool.apply_async(
-          CallLoadTargetBuildFile,
-          args = (global_flags, dependency,
-                  variables, includes, depth, check, generator_input_info),
-          callback = parallel_state.LoadTargetBuildFileCallback)
-  except KeyboardInterrupt as e:
-    parallel_state.pool.terminate()
-    raise e
-
-  parallel_state.condition.release()
-
-  parallel_state.pool.close()
-  parallel_state.pool.join()
-  parallel_state.pool = None
-
-  if parallel_state.error:
-    sys.exit(1)
+        self.condition.acquire()
+        if not result:
+            self.error = True
+            self.condition.notify()
+            self.condition.release()
+            return
+        (build_file_path0, build_file_data0, dependencies0) = result
+        self.data[build_file_path0] = build_file_data0
+        self.data["target_build_files"].add(build_file_path0)
+        for new_dependency in dependencies0:
+            if new_dependency not in self.scheduled:
+                self.scheduled.add(new_dependency)
+                self.dependencies.append(new_dependency)
+        self.pending -= 1
+        self.condition.notify()
+        self.condition.release()
+
+
+def LoadTargetBuildFilesParallel(
+    build_files, data, variables, includes, depth, check, generator_input_info
+):
+    parallel_state = ParallelState()
+    parallel_state.condition = threading.Condition()
+    # Make copies of the build_files argument that we can modify while working.
+    parallel_state.dependencies = list(build_files)
+    parallel_state.scheduled = set(build_files)
+    parallel_state.pending = 0
+    parallel_state.data = data
+
+    try:
+        parallel_state.condition.acquire()
+        while parallel_state.dependencies or parallel_state.pending:
+            if parallel_state.error:
+                break
+            if not parallel_state.dependencies:
+                parallel_state.condition.wait()
+                continue
+
+            dependency = parallel_state.dependencies.pop()
+
+            parallel_state.pending += 1
+            global_flags = {
+                "path_sections": globals()["path_sections"],
+                "non_configuration_keys": globals()["non_configuration_keys"],
+                "multiple_toolsets": globals()["multiple_toolsets"],
+            }
+
+            if not parallel_state.pool:
+                parallel_state.pool = multiprocessing.Pool(multiprocessing.cpu_count())
+            parallel_state.pool.apply_async(
+                CallLoadTargetBuildFile,
+                args=(
+                    global_flags,
+                    dependency,
+                    variables,
+                    includes,
+                    depth,
+                    check,
+                    generator_input_info,
+                ),
+                callback=parallel_state.LoadTargetBuildFileCallback,
+            )
+    except KeyboardInterrupt as e:
+        parallel_state.pool.terminate()
+        raise e
+
+    parallel_state.condition.release()
+
+    parallel_state.pool.close()
+    parallel_state.pool.join()
+    parallel_state.pool = None
+
+    if parallel_state.error:
+        sys.exit(1)
+
 
 # Look for the bracket that matches the first bracket seen in a
 # string, and return the start and end as a tuple.  For example, if
 # the input is something like "<(foo <(bar)) blah", then it would
 # return (1, 13), indicating the entire string except for the leading
 # "<" and trailing " blah".
-LBRACKETS= set('{[(')
-BRACKETS = {'}': '{', ']': '[', ')': '('}
+LBRACKETS = set("{[(")
+BRACKETS = {"}": "{", "]": "[", ")": "("}
+
+
 def FindEnclosingBracketGroup(input_str):
-  stack = []
-  start = -1
-  for index, char in enumerate(input_str):
-    if char in LBRACKETS:
-      stack.append(char)
-      if start == -1:
-        start = index
-    elif char in BRACKETS:
-      if not stack:
-        return (-1, -1)
-      if stack.pop() != BRACKETS[char]:
-        return (-1, -1)
-      if not stack:
-        return (start, index + 1)
-  return (-1, -1)
+    stack = []
+    start = -1
+    for index, char in enumerate(input_str):
+        if char in LBRACKETS:
+            stack.append(char)
+            if start == -1:
+                start = index
+        elif char in BRACKETS:
+            if not stack:
+                return (-1, -1)
+            if stack.pop() != BRACKETS[char]:
+                return (-1, -1)
+            if not stack:
+                return (start, index + 1)
+    return (-1, -1)
 
 
 def IsStrCanonicalInt(string):
-  """Returns True if |string| is in its canonical integer form.
+    """Returns True if |string| is in its canonical integer form.
 
   The canonical form is such that str(int(string)) == string.
   """
-  if type(string) is str:
-    # This function is called a lot so for maximum performance, avoid
-    # involving regexps which would otherwise make the code much
-    # shorter. Regexps would need twice the time of this function.
-    if string:
-      if string == "0":
-        return True
-      if string[0] == "-":
-        string = string[1:]
-        if not string:
-          return False
-      if '1' <= string[0] <= '9':
-        return string.isdigit()
-
-  return False
+    if type(string) is str:
+        # This function is called a lot so for maximum performance, avoid
+        # involving regexps which would otherwise make the code much
+        # shorter. Regexps would need twice the time of this function.
+        if string:
+            if string == "0":
+                return True
+            if string[0] == "-":
+                string = string[1:]
+                if not string:
+                    return False
+            if "1" <= string[0] <= "9":
+                return string.isdigit()
+
+    return False
 
 
 # This matches things like "<(asdf)", "<!(cmd)", "<!@(cmd)", "<|(list)",
 # "<!interpreter(arguments)", "<([list])", and even "<([)" and "<(<())".
 # In the last case, the inner "<()" is captured in match['content'].
 early_variable_re = re.compile(
-    r'(?P<replace>(?P<type><(?:(?:!?@?)|\|)?)'
-    r'(?P<command_string>[-a-zA-Z0-9_.]+)?'
-    r'\((?P<is_array>\s*\[?)'
-    r'(?P<content>.*?)(\]?)\))')
+    r"(?P<replace>(?P<type><(?:(?:!?@?)|\|)?)"
+    r"(?P<command_string>[-a-zA-Z0-9_.]+)?"
+    r"\((?P<is_array>\s*\[?)"
+    r"(?P<content>.*?)(\]?)\))"
+)
 
 # This matches the same as early_variable_re, but with '>' instead of '<'.
 late_variable_re = re.compile(
-    r'(?P<replace>(?P<type>>(?:(?:!?@?)|\|)?)'
-    r'(?P<command_string>[-a-zA-Z0-9_.]+)?'
-    r'\((?P<is_array>\s*\[?)'
-    r'(?P<content>.*?)(\]?)\))')
+    r"(?P<replace>(?P<type>>(?:(?:!?@?)|\|)?)"
+    r"(?P<command_string>[-a-zA-Z0-9_.]+)?"
+    r"\((?P<is_array>\s*\[?)"
+    r"(?P<content>.*?)(\]?)\))"
+)
 
 # This matches the same as early_variable_re, but with '^' instead of '<'.
 latelate_variable_re = re.compile(
-    r'(?P<replace>(?P<type>[\^](?:(?:!?@?)|\|)?)'
-    r'(?P<command_string>[-a-zA-Z0-9_.]+)?'
-    r'\((?P<is_array>\s*\[?)'
-    r'(?P<content>.*?)(\]?)\))')
+    r"(?P<replace>(?P<type>[\^](?:(?:!?@?)|\|)?)"
+    r"(?P<command_string>[-a-zA-Z0-9_.]+)?"
+    r"\((?P<is_array>\s*\[?)"
+    r"(?P<content>.*?)(\]?)\))"
+)
 
 # Global cache of results from running commands so they don't have to be run
 # more then once.
@@ -694,12 +754,12 @@ cached_command_results = {}
 
 
 def FixupPlatformCommand(cmd):
-  if sys.platform == 'win32':
-    if type(cmd) is list:
-      cmd = [re.sub('^cat ', 'type ', cmd[0])] + cmd[1:]
-    else:
-      cmd = re.sub('^cat ', 'type ', cmd)
-  return cmd
+    if sys.platform == "win32":
+        if type(cmd) is list:
+            cmd = [re.sub("^cat ", "type ", cmd[0])] + cmd[1:]
+        else:
+            cmd = re.sub("^cat ", "type ", cmd)
+    return cmd
 
 
 PHASE_EARLY = 0
@@ -708,640 +768,702 @@ PHASE_LATELATE = 2
 
 
 def ExpandVariables(input, phase, variables, build_file):
-  # Look for the pattern that gets expanded into variables
-  if phase == PHASE_EARLY:
-    variable_re = early_variable_re
-    expansion_symbol = '<'
-  elif phase == PHASE_LATE:
-    variable_re = late_variable_re
-    expansion_symbol = '>'
-  elif phase == PHASE_LATELATE:
-    variable_re = latelate_variable_re
-    expansion_symbol = '^'
-  else:
-    assert False
-
-  input_str = str(input)
-  if IsStrCanonicalInt(input_str):
-    return int(input_str)
-
-  # Do a quick scan to determine if an expensive regex search is warranted.
-  if expansion_symbol not in input_str:
-    return input_str
-
-  # Get the entire list of matches as a list of MatchObject instances.
-  # (using findall here would return strings instead of MatchObjects).
-  matches = list(variable_re.finditer(input_str))
-  if not matches:
-    return input_str
-
-  output = input_str
-  # Reverse the list of matches so that replacements are done right-to-left.
-  # That ensures that earlier replacements won't mess up the string in a
-  # way that causes later calls to find the earlier substituted text instead
-  # of what's intended for replacement.
-  matches.reverse()
-  for match_group in matches:
-    match = match_group.groupdict()
-    gyp.DebugOutput(gyp.DEBUG_VARIABLES, "Matches: %r", match)
-    # match['replace'] is the substring to look for, match['type']
-    # is the character code for the replacement type (< > <! >! <| >| <@
-    # >@ <!@ >!@), match['is_array'] contains a '[' for command
-    # arrays, and match['content'] is the name of the variable (< >)
-    # or command to run (<! >!). match['command_string'] is an optional
-    # command string. Currently, only 'pymod_do_main' is supported.
-
-    # run_command is true if a ! variant is used.
-    run_command = '!' in match['type']
-    command_string = match['command_string']
-
-    # file_list is true if a | variant is used.
-    file_list = '|' in match['type']
-
-    # Capture these now so we can adjust them later.
-    replace_start = match_group.start('replace')
-    replace_end = match_group.end('replace')
-
-    # Find the ending paren, and re-evaluate the contained string.
-    (c_start, c_end) = FindEnclosingBracketGroup(input_str[replace_start:])
-
-    # Adjust the replacement range to match the entire command
-    # found by FindEnclosingBracketGroup (since the variable_re
-    # probably doesn't match the entire command if it contained
-    # nested variables).
-    replace_end = replace_start + c_end
-
-    # Find the "real" replacement, matching the appropriate closing
-    # paren, and adjust the replacement start and end.
-    replacement = input_str[replace_start:replace_end]
-
-    # Figure out what the contents of the variable parens are.
-    contents_start = replace_start + c_start + 1
-    contents_end = replace_end - 1
-    contents = input_str[contents_start:contents_end]
-
-    # Do filter substitution now for <|().
-    # Admittedly, this is different than the evaluation order in other
-    # contexts. However, since filtration has no chance to run on <|(),
-    # this seems like the only obvious way to give them access to filters.
-    if file_list:
-      processed_variables = gyp.simple_copy.deepcopy(variables)
-      ProcessListFiltersInDict(contents, processed_variables)
-      # Recurse to expand variables in the contents
-      contents = ExpandVariables(contents, phase,
-                                 processed_variables, build_file)
+    # Look for the pattern that gets expanded into variables
+    if phase == PHASE_EARLY:
+        variable_re = early_variable_re
+        expansion_symbol = "<"
+    elif phase == PHASE_LATE:
+        variable_re = late_variable_re
+        expansion_symbol = ">"
+    elif phase == PHASE_LATELATE:
+        variable_re = latelate_variable_re
+        expansion_symbol = "^"
     else:
-      # Recurse to expand variables in the contents
-      contents = ExpandVariables(contents, phase, variables, build_file)
-
-    # Strip off leading/trailing whitespace so that variable matches are
-    # simpler below (and because they are rarely needed).
-    contents = contents.strip()
-
-    # expand_to_list is true if an @ variant is used.  In that case,
-    # the expansion should result in a list.  Note that the caller
-    # is to be expecting a list in return, and not all callers do
-    # because not all are working in list context.  Also, for list
-    # expansions, there can be no other text besides the variable
-    # expansion in the input string.
-    expand_to_list = '@' in match['type'] and input_str == replacement
-
-    if run_command or file_list:
-      # Find the build file's directory, so commands can be run or file lists
-      # generated relative to it.
-      build_file_dir = os.path.dirname(build_file)
-      if build_file_dir == '' and not file_list:
-        # If build_file is just a leaf filename indicating a file in the
-        # current directory, build_file_dir might be an empty string.  Set
-        # it to None to signal to subprocess.Popen that it should run the
-        # command in the current directory.
-        build_file_dir = None
-
-    # Support <|(listfile.txt ...) which generates a file
-    # containing items from a gyp list, generated at gyp time.
-    # This works around actions/rules which have more inputs than will
-    # fit on the command line.
-    if file_list:
-      if type(contents) is list:
-        contents_list = contents
-      else:
-        contents_list = contents.split(' ')
-      replacement = contents_list[0]
-      if os.path.isabs(replacement):
-        raise GypError('| cannot handle absolute paths, got "%s"' % replacement)
-
-      if not generator_filelist_paths:
-        path = os.path.join(build_file_dir, replacement)
-      else:
-        if os.path.isabs(build_file_dir):
-          toplevel = generator_filelist_paths['toplevel']
-          rel_build_file_dir = gyp.common.RelativePath(build_file_dir, toplevel)
+        assert False
+
+    input_str = str(input)
+    if IsStrCanonicalInt(input_str):
+        return int(input_str)
+
+    # Do a quick scan to determine if an expensive regex search is warranted.
+    if expansion_symbol not in input_str:
+        return input_str
+
+    # Get the entire list of matches as a list of MatchObject instances.
+    # (using findall here would return strings instead of MatchObjects).
+    matches = list(variable_re.finditer(input_str))
+    if not matches:
+        return input_str
+
+    output = input_str
+    # Reverse the list of matches so that replacements are done right-to-left.
+    # That ensures that earlier replacements won't mess up the string in a
+    # way that causes later calls to find the earlier substituted text instead
+    # of what's intended for replacement.
+    matches.reverse()
+    for match_group in matches:
+        match = match_group.groupdict()
+        gyp.DebugOutput(gyp.DEBUG_VARIABLES, "Matches: %r", match)
+        # match['replace'] is the substring to look for, match['type']
+        # is the character code for the replacement type (< > <! >! <| >| <@
+        # >@ <!@ >!@), match['is_array'] contains a '[' for command
+        # arrays, and match['content'] is the name of the variable (< >)
+        # or command to run (<! >!). match['command_string'] is an optional
+        # command string. Currently, only 'pymod_do_main' is supported.
+
+        # run_command is true if a ! variant is used.
+        run_command = "!" in match["type"]
+        command_string = match["command_string"]
+
+        # file_list is true if a | variant is used.
+        file_list = "|" in match["type"]
+
+        # Capture these now so we can adjust them later.
+        replace_start = match_group.start("replace")
+        replace_end = match_group.end("replace")
+
+        # Find the ending paren, and re-evaluate the contained string.
+        (c_start, c_end) = FindEnclosingBracketGroup(input_str[replace_start:])
+
+        # Adjust the replacement range to match the entire command
+        # found by FindEnclosingBracketGroup (since the variable_re
+        # probably doesn't match the entire command if it contained
+        # nested variables).
+        replace_end = replace_start + c_end
+
+        # Find the "real" replacement, matching the appropriate closing
+        # paren, and adjust the replacement start and end.
+        replacement = input_str[replace_start:replace_end]
+
+        # Figure out what the contents of the variable parens are.
+        contents_start = replace_start + c_start + 1
+        contents_end = replace_end - 1
+        contents = input_str[contents_start:contents_end]
+
+        # Do filter substitution now for <|().
+        # Admittedly, this is different than the evaluation order in other
+        # contexts. However, since filtration has no chance to run on <|(),
+        # this seems like the only obvious way to give them access to filters.
+        if file_list:
+            processed_variables = gyp.simple_copy.deepcopy(variables)
+            ProcessListFiltersInDict(contents, processed_variables)
+            # Recurse to expand variables in the contents
+            contents = ExpandVariables(contents, phase, processed_variables, build_file)
         else:
-          rel_build_file_dir = build_file_dir
-        qualified_out_dir = generator_filelist_paths['qualified_out_dir']
-        path = os.path.join(qualified_out_dir, rel_build_file_dir, replacement)
-        gyp.common.EnsureDirExists(path)
-
-      replacement = gyp.common.RelativePath(path, build_file_dir)
-      f = gyp.common.WriteOnDiff(path)
-      for i in contents_list[1:]:
-        f.write('%s\n' % i)
-      f.close()
-
-    elif run_command:
-      use_shell = True
-      if match['is_array']:
-        contents = eval(contents)
-        use_shell = False
-
-      # Check for a cached value to avoid executing commands, or generating
-      # file lists more than once. The cache key contains the command to be
-      # run as well as the directory to run it from, to account for commands
-      # that depend on their current directory.
-      # TODO(http://code.google.com/p/gyp/issues/detail?id=111): In theory,
-      # someone could author a set of GYP files where each time the command
-      # is invoked it produces different output by design. When the need
-      # arises, the syntax should be extended to support no caching off a
-      # command's output so it is run every time.
-      cache_key = (str(contents), build_file_dir)
-      cached_value = cached_command_results.get(cache_key, None)
-      if cached_value is None:
-        gyp.DebugOutput(gyp.DEBUG_VARIABLES,
-                        "Executing command '%s' in directory '%s'",
-                        contents, build_file_dir)
-
-        replacement = ''
-
-        if command_string == 'pymod_do_main':
-          # <!pymod_do_main(modulename param eters) loads |modulename| as a
-          # python module and then calls that module's DoMain() function,
-          # passing ["param", "eters"] as a single list argument. For modules
-          # that don't load quickly, this can be faster than
-          # <!(python modulename param eters). Do this in |build_file_dir|.
-          oldwd = os.getcwd()  # Python doesn't like os.open('.'): no fchdir.
-          if build_file_dir:  # build_file_dir may be None (see above).
-            os.chdir(build_file_dir)
-          sys.path.append(os.getcwd())
-          try:
-
-            parsed_contents = shlex.split(contents)
-            try:
-              py_module = __import__(parsed_contents[0])
-            except ImportError as e:
-              raise GypError("Error importing pymod_do_main"
-                             "module (%s): %s" % (parsed_contents[0], e))
-            replacement = str(py_module.DoMain(parsed_contents[1:])).rstrip()
-          finally:
-            sys.path.pop()
-            os.chdir(oldwd)
-          assert replacement != None
-        elif command_string:
-          raise GypError("Unknown command string '%s' in '%s'." %
-                         (command_string, contents))
-        else:
-          # Fix up command with platform specific workarounds.
-          contents = FixupPlatformCommand(contents)
-          try:
-            p = subprocess.Popen(contents, shell=use_shell,
-                                 stdout=subprocess.PIPE,
-                                 stderr=subprocess.PIPE,
-                                 stdin=subprocess.PIPE,
-                                 cwd=build_file_dir)
-          except Exception as e:
-            raise GypError("%s while executing command '%s' in %s" %
-                           (e, contents, build_file))
-
-          p_stdout, p_stderr = p.communicate('')
-          if PY3:
-            p_stdout = p_stdout.decode('utf-8')
-            p_stderr = p_stderr.decode('utf-8')
-
-          if p.wait() != 0 or p_stderr:
-            sys.stderr.write(p_stderr)
-            # Simulate check_call behavior, since check_call only exists
-            # in python 2.5 and later.
-            raise GypError("Call to '%s' returned exit status %d while in %s." %
-                           (contents, p.returncode, build_file))
-          replacement = p_stdout.rstrip()
-
-        cached_command_results[cache_key] = replacement
-      else:
-        gyp.DebugOutput(gyp.DEBUG_VARIABLES,
-                        "Had cache value for command '%s' in directory '%s'",
-                        contents,build_file_dir)
-        replacement = cached_value
+            # Recurse to expand variables in the contents
+            contents = ExpandVariables(contents, phase, variables, build_file)
+
+        # Strip off leading/trailing whitespace so that variable matches are
+        # simpler below (and because they are rarely needed).
+        contents = contents.strip()
+
+        # expand_to_list is true if an @ variant is used.  In that case,
+        # the expansion should result in a list.  Note that the caller
+        # is to be expecting a list in return, and not all callers do
+        # because not all are working in list context.  Also, for list
+        # expansions, there can be no other text besides the variable
+        # expansion in the input string.
+        expand_to_list = "@" in match["type"] and input_str == replacement
+
+        if run_command or file_list:
+            # Find the build file's directory, so commands can be run or file lists
+            # generated relative to it.
+            build_file_dir = os.path.dirname(build_file)
+            if build_file_dir == "" and not file_list:
+                # If build_file is just a leaf filename indicating a file in the
+                # current directory, build_file_dir might be an empty string.  Set
+                # it to None to signal to subprocess.Popen that it should run the
+                # command in the current directory.
+                build_file_dir = None
+
+        # Support <|(listfile.txt ...) which generates a file
+        # containing items from a gyp list, generated at gyp time.
+        # This works around actions/rules which have more inputs than will
+        # fit on the command line.
+        if file_list:
+            if type(contents) is list:
+                contents_list = contents
+            else:
+                contents_list = contents.split(" ")
+            replacement = contents_list[0]
+            if os.path.isabs(replacement):
+                raise GypError('| cannot handle absolute paths, got "%s"' % replacement)
+
+            if not generator_filelist_paths:
+                path = os.path.join(build_file_dir, replacement)
+            else:
+                if os.path.isabs(build_file_dir):
+                    toplevel = generator_filelist_paths["toplevel"]
+                    rel_build_file_dir = gyp.common.RelativePath(
+                        build_file_dir, toplevel
+                    )
+                else:
+                    rel_build_file_dir = build_file_dir
+                qualified_out_dir = generator_filelist_paths["qualified_out_dir"]
+                path = os.path.join(qualified_out_dir, rel_build_file_dir, replacement)
+                gyp.common.EnsureDirExists(path)
+
+            replacement = gyp.common.RelativePath(path, build_file_dir)
+            f = gyp.common.WriteOnDiff(path)
+            for i in contents_list[1:]:
+                f.write("%s\n" % i)
+            f.close()
+
+        elif run_command:
+            use_shell = True
+            if match["is_array"]:
+                contents = eval(contents)
+                use_shell = False
+
+            # Check for a cached value to avoid executing commands, or generating
+            # file lists more than once. The cache key contains the command to be
+            # run as well as the directory to run it from, to account for commands
+            # that depend on their current directory.
+            # TODO(http://code.google.com/p/gyp/issues/detail?id=111): In theory,
+            # someone could author a set of GYP files where each time the command
+            # is invoked it produces different output by design. When the need
+            # arises, the syntax should be extended to support no caching off a
+            # command's output so it is run every time.
+            cache_key = (str(contents), build_file_dir)
+            cached_value = cached_command_results.get(cache_key, None)
+            if cached_value is None:
+                gyp.DebugOutput(
+                    gyp.DEBUG_VARIABLES,
+                    "Executing command '%s' in directory '%s'",
+                    contents,
+                    build_file_dir,
+                )
+
+                replacement = ""
+
+                if command_string == "pymod_do_main":
+                    # <!pymod_do_main(modulename param eters) loads |modulename| as a
+                    # python module and then calls that module's DoMain() function,
+                    # passing ["param", "eters"] as a single list argument. For modules
+                    # that don't load quickly, this can be faster than
+                    # <!(python modulename param eters). Do this in |build_file_dir|.
+                    oldwd = os.getcwd()  # Python doesn't like os.open('.'): no fchdir.
+                    if build_file_dir:  # build_file_dir may be None (see above).
+                        os.chdir(build_file_dir)
+                    sys.path.append(os.getcwd())
+                    try:
+
+                        parsed_contents = shlex.split(contents)
+                        try:
+                            py_module = __import__(parsed_contents[0])
+                        except ImportError as e:
+                            raise GypError(
+                                "Error importing pymod_do_main"
+                                "module (%s): %s" % (parsed_contents[0], e)
+                            )
+                        replacement = str(
+                            py_module.DoMain(parsed_contents[1:])
+                        ).rstrip()
+                    finally:
+                        sys.path.pop()
+                        os.chdir(oldwd)
+                    assert replacement is not None
+                elif command_string:
+                    raise GypError(
+                        "Unknown command string '%s' in '%s'."
+                        % (command_string, contents)
+                    )
+                else:
+                    # Fix up command with platform specific workarounds.
+                    contents = FixupPlatformCommand(contents)
+                    try:
+                        p = subprocess.Popen(
+                            contents,
+                            shell=use_shell,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            stdin=subprocess.PIPE,
+                            cwd=build_file_dir,
+                        )
+                    except Exception as e:
+                        raise GypError(
+                            "%s while executing command '%s' in %s"
+                            % (e, contents, build_file)
+                        )
+
+                    p_stdout, p_stderr = p.communicate("")
+                    if PY3:
+                        p_stdout = p_stdout.decode("utf-8")
+                        p_stderr = p_stderr.decode("utf-8")
+
+                    if p.wait() != 0 or p_stderr:
+                        sys.stderr.write(p_stderr)
+                        # Simulate check_call behavior, since check_call only exists
+                        # in python 2.5 and later.
+                        raise GypError(
+                            "Call to '%s' returned exit status %d while in %s."
+                            % (contents, p.returncode, build_file)
+                        )
+                    replacement = p_stdout.rstrip()
+
+                cached_command_results[cache_key] = replacement
+            else:
+                gyp.DebugOutput(
+                    gyp.DEBUG_VARIABLES,
+                    "Had cache value for command '%s' in directory '%s'",
+                    contents,
+                    build_file_dir,
+                )
+                replacement = cached_value
 
-    else:
-      if not contents in variables:
-        if contents[-1] in ['!', '/']:
-          # In order to allow cross-compiles (nacl) to happen more naturally,
-          # we will allow references to >(sources/) etc. to resolve to
-          # and empty list if undefined. This allows actions to:
-          # 'action!': [
-          #   '>@(_sources!)',
-          # ],
-          # 'action/': [
-          #   '>@(_sources/)',
-          # ],
-          replacement = []
         else:
-          raise GypError('Undefined variable ' + contents +
-                         ' in ' + build_file)
-      else:
-        replacement = variables[contents]
-
-    if isinstance(replacement, bytes) and not isinstance(replacement, str):
-      replacement = replacement.decode("utf-8")  # done on Python 3 only
-    if type(replacement) is list:
-      for item in replacement:
-        if isinstance(item, bytes) and not isinstance(item, str):
-          item = item.decode("utf-8")  # done on Python 3 only
-        if not contents[-1] == '/' and type(item) not in (str, int):
-          raise GypError('Variable ' + contents +
-                         ' must expand to a string or list of strings; ' +
-                         'list contains a ' +
-                         item.__class__.__name__)
-      # Run through the list and handle variable expansions in it.  Since
-      # the list is guaranteed not to contain dicts, this won't do anything
-      # with conditions sections.
-      ProcessVariablesAndConditionsInList(replacement, phase, variables,
-                                          build_file)
-    elif type(replacement) not in (str, int):
-          raise GypError('Variable ' + contents +
-                         ' must expand to a string or list of strings; ' +
-                         'found a ' + replacement.__class__.__name__)
-
-    if expand_to_list:
-      # Expanding in list context.  It's guaranteed that there's only one
-      # replacement to do in |input_str| and that it's this replacement.  See
-      # above.
-      if type(replacement) is list:
-        # If it's already a list, make a copy.
-        output = replacement[:]
-      else:
-        # Split it the same way sh would split arguments.
-        output = shlex.split(str(replacement))
+            if contents not in variables:
+                if contents[-1] in ["!", "/"]:
+                    # In order to allow cross-compiles (nacl) to happen more naturally,
+                    # we will allow references to >(sources/) etc. to resolve to
+                    # and empty list if undefined. This allows actions to:
+                    # 'action!': [
+                    #   '>@(_sources!)',
+                    # ],
+                    # 'action/': [
+                    #   '>@(_sources/)',
+                    # ],
+                    replacement = []
+                else:
+                    raise GypError(
+                        "Undefined variable " + contents + " in " + build_file
+                    )
+            else:
+                replacement = variables[contents]
+
+        if isinstance(replacement, bytes) and not isinstance(replacement, str):
+            replacement = replacement.decode("utf-8")  # done on Python 3 only
+        if type(replacement) is list:
+            for item in replacement:
+                if isinstance(item, bytes) and not isinstance(item, str):
+                    item = item.decode("utf-8")  # done on Python 3 only
+                if not contents[-1] == "/" and type(item) not in (str, int):
+                    raise GypError(
+                        "Variable "
+                        + contents
+                        + " must expand to a string or list of strings; "
+                        + "list contains a "
+                        + item.__class__.__name__
+                    )
+            # Run through the list and handle variable expansions in it.  Since
+            # the list is guaranteed not to contain dicts, this won't do anything
+            # with conditions sections.
+            ProcessVariablesAndConditionsInList(
+                replacement, phase, variables, build_file
+            )
+        elif type(replacement) not in (str, int):
+            raise GypError(
+                "Variable "
+                + contents
+                + " must expand to a string or list of strings; "
+                + "found a "
+                + replacement.__class__.__name__
+            )
+
+        if expand_to_list:
+            # Expanding in list context.  It's guaranteed that there's only one
+            # replacement to do in |input_str| and that it's this replacement.  See
+            # above.
+            if type(replacement) is list:
+                # If it's already a list, make a copy.
+                output = replacement[:]
+            else:
+                # Split it the same way sh would split arguments.
+                output = shlex.split(str(replacement))
+        else:
+            # Expanding in string context.
+            encoded_replacement = ""
+            if type(replacement) is list:
+                # When expanding a list into string context, turn the list items
+                # into a string in a way that will work with a subprocess call.
+                #
+                # TODO(mark): This isn't completely correct.  This should
+                # call a generator-provided function that observes the
+                # proper list-to-argument quoting rules on a specific
+                # platform instead of just calling the POSIX encoding
+                # routine.
+                encoded_replacement = gyp.common.EncodePOSIXShellList(replacement)
+            else:
+                encoded_replacement = replacement
+
+            output = (
+                output[:replace_start] + str(encoded_replacement) + output[replace_end:]
+            )
+        # Prepare for the next match iteration.
+        input_str = output
+
+    if output == input:
+        gyp.DebugOutput(
+            gyp.DEBUG_VARIABLES,
+            "Found only identity matches on %r, avoiding infinite " "recursion.",
+            output,
+        )
     else:
-      # Expanding in string context.
-      encoded_replacement = ''
-      if type(replacement) is list:
-        # When expanding a list into string context, turn the list items
-        # into a string in a way that will work with a subprocess call.
-        #
-        # TODO(mark): This isn't completely correct.  This should
-        # call a generator-provided function that observes the
-        # proper list-to-argument quoting rules on a specific
-        # platform instead of just calling the POSIX encoding
-        # routine.
-        encoded_replacement = gyp.common.EncodePOSIXShellList(replacement)
-      else:
-        encoded_replacement = replacement
-
-      output = output[:replace_start] + str(encoded_replacement) + \
-               output[replace_end:]
-    # Prepare for the next match iteration.
-    input_str = output
-
-  if output == input:
-    gyp.DebugOutput(gyp.DEBUG_VARIABLES,
-                    "Found only identity matches on %r, avoiding infinite "
-                    "recursion.",
-                    output)
-  else:
-    # Look for more matches now that we've replaced some, to deal with
-    # expanding local variables (variables defined in the same
-    # variables block as this one).
-    gyp.DebugOutput(gyp.DEBUG_VARIABLES, "Found output %r, recursing.", output)
+        # Look for more matches now that we've replaced some, to deal with
+        # expanding local variables (variables defined in the same
+        # variables block as this one).
+        gyp.DebugOutput(gyp.DEBUG_VARIABLES, "Found output %r, recursing.", output)
+        if type(output) is list:
+            if output and type(output[0]) is list:
+                # Leave output alone if it's a list of lists.
+                # We don't want such lists to be stringified.
+                pass
+            else:
+                new_output = []
+                for item in output:
+                    new_output.append(
+                        ExpandVariables(item, phase, variables, build_file)
+                    )
+                output = new_output
+        else:
+            output = ExpandVariables(output, phase, variables, build_file)
+
+    # Convert all strings that are canonically-represented integers into integers.
     if type(output) is list:
-      if output and type(output[0]) is list:
-        # Leave output alone if it's a list of lists.
-        # We don't want such lists to be stringified.
-        pass
-      else:
-        new_output = []
-        for item in output:
-          new_output.append(
-              ExpandVariables(item, phase, variables, build_file))
-        output = new_output
-    else:
-      output = ExpandVariables(output, phase, variables, build_file)
+        for index, outstr in enumerate(output):
+            if IsStrCanonicalInt(outstr):
+                output[index] = int(outstr)
+    elif IsStrCanonicalInt(output):
+        output = int(output)
 
-  # Convert all strings that are canonically-represented integers into integers.
-  if type(output) is list:
-    for index in range(0, len(output)):
-      if IsStrCanonicalInt(output[index]):
-        output[index] = int(output[index])
-  elif IsStrCanonicalInt(output):
-    output = int(output)
+    return output
 
-  return output
 
 # The same condition is often evaluated over and over again so it
 # makes sense to cache as much as possible between evaluations.
 cached_conditions_asts = {}
 
+
 def EvalCondition(condition, conditions_key, phase, variables, build_file):
-  """Returns the dict that should be used or None if the result was
+    """Returns the dict that should be used or None if the result was
   that nothing should be used."""
-  if type(condition) is not list:
-    raise GypError(conditions_key + ' must be a list')
-  if len(condition) < 2:
-    # It's possible that condition[0] won't work in which case this
-    # attempt will raise its own IndexError.  That's probably fine.
-    raise GypError(conditions_key + ' ' + condition[0] +
-                   ' must be at least length 2, not ' + str(len(condition)))
-
-  i = 0
-  result = None
-  while i < len(condition):
-    cond_expr = condition[i]
-    true_dict = condition[i + 1]
-    if type(true_dict) is not dict:
-      raise GypError('{} {} must be followed by a dictionary, not {}'.format(
-        conditions_key, cond_expr, type(true_dict)))
-    if len(condition) > i + 2 and type(condition[i + 2]) is dict:
-      false_dict = condition[i + 2]
-      i = i + 3
-      if i != len(condition):
-        raise GypError('{} {} has {} unexpected trailing items'.format(
-          conditions_key, cond_expr, len(condition) - i))
-    else:
-      false_dict = None
-      i = i + 2
-    if result is None:
-      result = EvalSingleCondition(
-          cond_expr, true_dict, false_dict, phase, variables, build_file)
+    if type(condition) is not list:
+        raise GypError(conditions_key + " must be a list")
+    if len(condition) < 2:
+        # It's possible that condition[0] won't work in which case this
+        # attempt will raise its own IndexError.  That's probably fine.
+        raise GypError(
+            conditions_key
+            + " "
+            + condition[0]
+            + " must be at least length 2, not "
+            + str(len(condition))
+        )
+
+    i = 0
+    result = None
+    while i < len(condition):
+        cond_expr = condition[i]
+        true_dict = condition[i + 1]
+        if type(true_dict) is not dict:
+            raise GypError(
+                "{} {} must be followed by a dictionary, not {}".format(
+                    conditions_key, cond_expr, type(true_dict)
+                )
+            )
+        if len(condition) > i + 2 and type(condition[i + 2]) is dict:
+            false_dict = condition[i + 2]
+            i = i + 3
+            if i != len(condition):
+                raise GypError(
+                    "{} {} has {} unexpected trailing items".format(
+                        conditions_key, cond_expr, len(condition) - i
+                    )
+                )
+        else:
+            false_dict = None
+            i = i + 2
+        if result is None:
+            result = EvalSingleCondition(
+                cond_expr, true_dict, false_dict, phase, variables, build_file
+            )
 
-  return result
+    return result
 
 
-def EvalSingleCondition(
-    cond_expr, true_dict, false_dict, phase, variables, build_file):
-  """Returns true_dict if cond_expr evaluates to true, and false_dict
+def EvalSingleCondition(cond_expr, true_dict, false_dict, phase, variables, build_file):
+    """Returns true_dict if cond_expr evaluates to true, and false_dict
   otherwise."""
-  # Do expansions on the condition itself.  Since the condition can naturally
-  # contain variable references without needing to resort to GYP expansion
-  # syntax, this is of dubious value for variables, but someone might want to
-  # use a command expansion directly inside a condition.
-  cond_expr_expanded = ExpandVariables(cond_expr, phase, variables,
-                                       build_file)
-  if type(cond_expr_expanded) not in (str, int):
-    raise ValueError(
-          'Variable expansion in this context permits str and int ' + \
-            'only, found ' + cond_expr_expanded.__class__.__name__)
-
-  try:
-    if cond_expr_expanded in cached_conditions_asts:
-      ast_code = cached_conditions_asts[cond_expr_expanded]
-    else:
-      ast_code = compile(cond_expr_expanded, '<string>', 'eval')
-      cached_conditions_asts[cond_expr_expanded] = ast_code
-    env = {'__builtins__': {}, 'v': StrictVersion}
-    if eval(ast_code, env, variables):
-      return true_dict
-    return false_dict
-  except SyntaxError as e:
-    syntax_error = SyntaxError('%s while evaluating condition \'%s\' in %s '
-                               'at character %d.' %
-                               (str(e.args[0]), e.text, build_file, e.offset),
-                               e.filename, e.lineno, e.offset, e.text)
-    raise syntax_error
-  except NameError as e:
-    gyp.common.ExceptionAppend(e, 'while evaluating condition \'%s\' in %s' %
-                               (cond_expr_expanded, build_file))
-    raise GypError(e)
+    # Do expansions on the condition itself.  Since the condition can naturally
+    # contain variable references without needing to resort to GYP expansion
+    # syntax, this is of dubious value for variables, but someone might want to
+    # use a command expansion directly inside a condition.
+    cond_expr_expanded = ExpandVariables(cond_expr, phase, variables, build_file)
+    if type(cond_expr_expanded) not in (str, int):
+        raise ValueError(
+            "Variable expansion in this context permits str and int "
+            + "only, found "
+            + cond_expr_expanded.__class__.__name__
+        )
+
+    try:
+        if cond_expr_expanded in cached_conditions_asts:
+            ast_code = cached_conditions_asts[cond_expr_expanded]
+        else:
+            ast_code = compile(cond_expr_expanded, "<string>", "eval")
+            cached_conditions_asts[cond_expr_expanded] = ast_code
+        env = {"__builtins__": {}, "v": StrictVersion}
+        if eval(ast_code, env, variables):
+            return true_dict
+        return false_dict
+    except SyntaxError as e:
+        syntax_error = SyntaxError(
+            "%s while evaluating condition '%s' in %s "
+            "at character %d." % (str(e.args[0]), e.text, build_file, e.offset),
+            e.filename,
+            e.lineno,
+            e.offset,
+            e.text,
+        )
+        raise syntax_error
+    except NameError as e:
+        gyp.common.ExceptionAppend(
+            e,
+            "while evaluating condition '%s' in %s" % (cond_expr_expanded, build_file),
+        )
+        raise GypError(e)
 
 
 def ProcessConditionsInDict(the_dict, phase, variables, build_file):
-  # Process a 'conditions' or 'target_conditions' section in the_dict,
-  # depending on phase.
-  # early -> conditions
-  # late -> target_conditions
-  # latelate -> no conditions
-  #
-  # Each item in a conditions list consists of cond_expr, a string expression
-  # evaluated as the condition, and true_dict, a dict that will be merged into
-  # the_dict if cond_expr evaluates to true.  Optionally, a third item,
-  # false_dict, may be present.  false_dict is merged into the_dict if
-  # cond_expr evaluates to false.
-  #
-  # Any dict merged into the_dict will be recursively processed for nested
-  # conditionals and other expansions, also according to phase, immediately
-  # prior to being merged.
-
-  if phase == PHASE_EARLY:
-    conditions_key = 'conditions'
-  elif phase == PHASE_LATE:
-    conditions_key = 'target_conditions'
-  elif phase == PHASE_LATELATE:
-    return
-  else:
-    assert False
-
-  if not conditions_key in the_dict:
-    return
-
-  conditions_list = the_dict[conditions_key]
-  # Unhook the conditions list, it's no longer needed.
-  del the_dict[conditions_key]
-
-  for condition in conditions_list:
-    merge_dict = EvalCondition(condition, conditions_key, phase, variables,
-                               build_file)
-
-    if merge_dict != None:
-      # Expand variables and nested conditinals in the merge_dict before
-      # merging it.
-      ProcessVariablesAndConditionsInDict(merge_dict, phase,
-                                          variables, build_file)
-
-      MergeDicts(the_dict, merge_dict, build_file, build_file)
+    # Process a 'conditions' or 'target_conditions' section in the_dict,
+    # depending on phase.
+    # early -> conditions
+    # late -> target_conditions
+    # latelate -> no conditions
+    #
+    # Each item in a conditions list consists of cond_expr, a string expression
+    # evaluated as the condition, and true_dict, a dict that will be merged into
+    # the_dict if cond_expr evaluates to true.  Optionally, a third item,
+    # false_dict, may be present.  false_dict is merged into the_dict if
+    # cond_expr evaluates to false.
+    #
+    # Any dict merged into the_dict will be recursively processed for nested
+    # conditionals and other expansions, also according to phase, immediately
+    # prior to being merged.
+
+    if phase == PHASE_EARLY:
+        conditions_key = "conditions"
+    elif phase == PHASE_LATE:
+        conditions_key = "target_conditions"
+    elif phase == PHASE_LATELATE:
+        return
+    else:
+        assert False
+
+    if conditions_key not in the_dict:
+        return
+
+    conditions_list = the_dict[conditions_key]
+    # Unhook the conditions list, it's no longer needed.
+    del the_dict[conditions_key]
+
+    for condition in conditions_list:
+        merge_dict = EvalCondition(
+            condition, conditions_key, phase, variables, build_file
+        )
+
+        if merge_dict is not None:
+            # Expand variables and nested conditinals in the merge_dict before
+            # merging it.
+            ProcessVariablesAndConditionsInDict(
+                merge_dict, phase, variables, build_file
+            )
+
+            MergeDicts(the_dict, merge_dict, build_file, build_file)
 
 
 def LoadAutomaticVariablesFromDict(variables, the_dict):
-  # Any keys with plain string values in the_dict become automatic variables.
-  # The variable name is the key name with a "_" character prepended.
-  for key, value in the_dict.items():
-    if type(value) in (str, int, list):
-      variables['_' + key] = value
+    # Any keys with plain string values in the_dict become automatic variables.
+    # The variable name is the key name with a "_" character prepended.
+    for key, value in the_dict.items():
+        if type(value) in (str, int, list):
+            variables["_" + key] = value
 
 
 def LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key):
-  # Any keys in the_dict's "variables" dict, if it has one, becomes a
-  # variable.  The variable name is the key name in the "variables" dict.
-  # Variables that end with the % character are set only if they are unset in
-  # the variables dict.  the_dict_key is the name of the key that accesses
-  # the_dict in the_dict's parent dict.  If the_dict's parent is not a dict
-  # (it could be a list or it could be parentless because it is a root dict),
-  # the_dict_key will be None.
-  for key, value in the_dict.get('variables', {}).items():
-    if type(value) not in (str, int, list):
-      continue
-
-    if key.endswith('%'):
-      variable_name = key[:-1]
-      if variable_name in variables:
-        # If the variable is already set, don't set it.
-        continue
-      if the_dict_key == 'variables' and variable_name in the_dict:
-        # If the variable is set without a % in the_dict, and the_dict is a
-        # variables dict (making |variables| a variables sub-dict of a
-        # variables dict), use the_dict's definition.
-        value = the_dict[variable_name]
-    else:
-      variable_name = key
+    # Any keys in the_dict's "variables" dict, if it has one, becomes a
+    # variable.  The variable name is the key name in the "variables" dict.
+    # Variables that end with the % character are set only if they are unset in
+    # the variables dict.  the_dict_key is the name of the key that accesses
+    # the_dict in the_dict's parent dict.  If the_dict's parent is not a dict
+    # (it could be a list or it could be parentless because it is a root dict),
+    # the_dict_key will be None.
+    for key, value in the_dict.get("variables", {}).items():
+        if type(value) not in (str, int, list):
+            continue
+
+        if key.endswith("%"):
+            variable_name = key[:-1]
+            if variable_name in variables:
+                # If the variable is already set, don't set it.
+                continue
+            if the_dict_key == "variables" and variable_name in the_dict:
+                # If the variable is set without a % in the_dict, and the_dict is a
+                # variables dict (making |variables| a variables sub-dict of a
+                # variables dict), use the_dict's definition.
+                value = the_dict[variable_name]
+        else:
+            variable_name = key
 
-    variables[variable_name] = value
+        variables[variable_name] = value
 
 
-def ProcessVariablesAndConditionsInDict(the_dict, phase, variables_in,
-                                        build_file, the_dict_key=None):
-  """Handle all variable and command expansion and conditional evaluation.
+def ProcessVariablesAndConditionsInDict(
+    the_dict, phase, variables_in, build_file, the_dict_key=None
+):
+    """Handle all variable and command expansion and conditional evaluation.
 
   This function is the public entry point for all variable expansions and
   conditional evaluations.  The variables_in dictionary will not be modified
   by this function.
   """
 
-  # Make a copy of the variables_in dict that can be modified during the
-  # loading of automatics and the loading of the variables dict.
-  variables = variables_in.copy()
-  LoadAutomaticVariablesFromDict(variables, the_dict)
-
-  if 'variables' in the_dict:
-    # Make sure all the local variables are added to the variables
-    # list before we process them so that you can reference one
-    # variable from another.  They will be fully expanded by recursion
-    # in ExpandVariables.
-    for key, value in the_dict['variables'].items():
-      variables[key] = value
-
-    # Handle the associated variables dict first, so that any variable
-    # references within can be resolved prior to using them as variables.
-    # Pass a copy of the variables dict to avoid having it be tainted.
-    # Otherwise, it would have extra automatics added for everything that
-    # should just be an ordinary variable in this scope.
-    ProcessVariablesAndConditionsInDict(the_dict['variables'], phase,
-                                        variables, build_file, 'variables')
-
-  LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
-
-  for key, value in the_dict.items():
-    # Skip "variables", which was already processed if present.
-    if key != 'variables' and type(value) is str:
-      expanded = ExpandVariables(value, phase, variables, build_file)
-      if type(expanded) not in (str, int):
-        raise ValueError(
-              'Variable expansion in this context permits str and int ' + \
-              'only, found ' + expanded.__class__.__name__ + ' for ' + key)
-      the_dict[key] = expanded
-
-  # Variable expansion may have resulted in changes to automatics.  Reload.
-  # TODO(mark): Optimization: only reload if no changes were made.
-  variables = variables_in.copy()
-  LoadAutomaticVariablesFromDict(variables, the_dict)
-  LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
-
-  # Process conditions in this dict.  This is done after variable expansion
-  # so that conditions may take advantage of expanded variables.  For example,
-  # if the_dict contains:
-  #   {'type':       '<(library_type)',
-  #    'conditions': [['_type=="static_library"', { ... }]]},
-  # _type, as used in the condition, will only be set to the value of
-  # library_type if variable expansion is performed before condition
-  # processing.  However, condition processing should occur prior to recursion
-  # so that variables (both automatic and "variables" dict type) may be
-  # adjusted by conditions sections, merged into the_dict, and have the
-  # intended impact on contained dicts.
-  #
-  # This arrangement means that a "conditions" section containing a "variables"
-  # section will only have those variables effective in subdicts, not in
-  # the_dict.  The workaround is to put a "conditions" section within a
-  # "variables" section.  For example:
-  #   {'conditions': [['os=="mac"', {'variables': {'define': 'IS_MAC'}}]],
-  #    'defines':    ['<(define)'],
-  #    'my_subdict': {'defines': ['<(define)']}},
-  # will not result in "IS_MAC" being appended to the "defines" list in the
-  # current scope but would result in it being appended to the "defines" list
-  # within "my_subdict".  By comparison:
-  #   {'variables': {'conditions': [['os=="mac"', {'define': 'IS_MAC'}]]},
-  #    'defines':    ['<(define)'],
-  #    'my_subdict': {'defines': ['<(define)']}},
-  # will append "IS_MAC" to both "defines" lists.
-
-  # Evaluate conditions sections, allowing variable expansions within them
-  # as well as nested conditionals.  This will process a 'conditions' or
-  # 'target_conditions' section, perform appropriate merging and recursive
-  # conditional and variable processing, and then remove the conditions section
-  # from the_dict if it is present.
-  ProcessConditionsInDict(the_dict, phase, variables, build_file)
-
-  # Conditional processing may have resulted in changes to automatics or the
-  # variables dict.  Reload.
-  variables = variables_in.copy()
-  LoadAutomaticVariablesFromDict(variables, the_dict)
-  LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
-
-  # Recurse into child dicts, or process child lists which may result in
-  # further recursion into descendant dicts.
-  for key, value in the_dict.items():
-    # Skip "variables" and string values, which were already processed if
-    # present.
-    if key == 'variables' or type(value) is str:
-      continue
-    if type(value) is dict:
-      # Pass a copy of the variables dict so that subdicts can't influence
-      # parents.
-      ProcessVariablesAndConditionsInDict(value, phase, variables,
-                                          build_file, key)
-    elif type(value) is list:
-      # The list itself can't influence the variables dict, and
-      # ProcessVariablesAndConditionsInList will make copies of the variables
-      # dict if it needs to pass it to something that can influence it.  No
-      # copy is necessary here.
-      ProcessVariablesAndConditionsInList(value, phase, variables,
-                                          build_file)
-    elif type(value) is not int:
-      raise TypeError('Unknown type ' + value.__class__.__name__ + \
-                      ' for ' + key)
-
-
-def ProcessVariablesAndConditionsInList(the_list, phase, variables,
-                                        build_file):
-  # Iterate using an index so that new values can be assigned into the_list.
-  index = 0
-  while index < len(the_list):
-    item = the_list[index]
-    if type(item) is dict:
-      # Make a copy of the variables dict so that it won't influence anything
-      # outside of its own scope.
-      ProcessVariablesAndConditionsInDict(item, phase, variables, build_file)
-    elif type(item) is list:
-      ProcessVariablesAndConditionsInList(item, phase, variables, build_file)
-    elif type(item) is str:
-      expanded = ExpandVariables(item, phase, variables, build_file)
-      if type(expanded) in (str, int):
-        the_list[index] = expanded
-      elif type(expanded) is list:
-        the_list[index:index+1] = expanded
-        index += len(expanded)
-
-        # index now identifies the next item to examine.  Continue right now
-        # without falling into the index increment below.
-        continue
-      else:
-        raise ValueError(
-              'Variable expansion in this context permits strings and ' + \
-              'lists only, found ' + expanded.__class__.__name__ + ' at ' + \
-              index)
-    elif type(item) is not int:
-      raise TypeError('Unknown type ' + item.__class__.__name__ + \
-                      ' at index ' + index)
-    index = index + 1
+    # Make a copy of the variables_in dict that can be modified during the
+    # loading of automatics and the loading of the variables dict.
+    variables = variables_in.copy()
+    LoadAutomaticVariablesFromDict(variables, the_dict)
+
+    if "variables" in the_dict:
+        # Make sure all the local variables are added to the variables
+        # list before we process them so that you can reference one
+        # variable from another.  They will be fully expanded by recursion
+        # in ExpandVariables.
+        for key, value in the_dict["variables"].items():
+            variables[key] = value
+
+        # Handle the associated variables dict first, so that any variable
+        # references within can be resolved prior to using them as variables.
+        # Pass a copy of the variables dict to avoid having it be tainted.
+        # Otherwise, it would have extra automatics added for everything that
+        # should just be an ordinary variable in this scope.
+        ProcessVariablesAndConditionsInDict(
+            the_dict["variables"], phase, variables, build_file, "variables"
+        )
+
+    LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
+
+    for key, value in the_dict.items():
+        # Skip "variables", which was already processed if present.
+        if key != "variables" and type(value) is str:
+            expanded = ExpandVariables(value, phase, variables, build_file)
+            if type(expanded) not in (str, int):
+                raise ValueError(
+                    "Variable expansion in this context permits str and int "
+                    + "only, found "
+                    + expanded.__class__.__name__
+                    + " for "
+                    + key
+                )
+            the_dict[key] = expanded
+
+    # Variable expansion may have resulted in changes to automatics.  Reload.
+    # TODO(mark): Optimization: only reload if no changes were made.
+    variables = variables_in.copy()
+    LoadAutomaticVariablesFromDict(variables, the_dict)
+    LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
+
+    # Process conditions in this dict.  This is done after variable expansion
+    # so that conditions may take advantage of expanded variables.  For example,
+    # if the_dict contains:
+    #   {'type':       '<(library_type)',
+    #    'conditions': [['_type=="static_library"', { ... }]]},
+    # _type, as used in the condition, will only be set to the value of
+    # library_type if variable expansion is performed before condition
+    # processing.  However, condition processing should occur prior to recursion
+    # so that variables (both automatic and "variables" dict type) may be
+    # adjusted by conditions sections, merged into the_dict, and have the
+    # intended impact on contained dicts.
+    #
+    # This arrangement means that a "conditions" section containing a "variables"
+    # section will only have those variables effective in subdicts, not in
+    # the_dict.  The workaround is to put a "conditions" section within a
+    # "variables" section.  For example:
+    #   {'conditions': [['os=="mac"', {'variables': {'define': 'IS_MAC'}}]],
+    #    'defines':    ['<(define)'],
+    #    'my_subdict': {'defines': ['<(define)']}},
+    # will not result in "IS_MAC" being appended to the "defines" list in the
+    # current scope but would result in it being appended to the "defines" list
+    # within "my_subdict".  By comparison:
+    #   {'variables': {'conditions': [['os=="mac"', {'define': 'IS_MAC'}]]},
+    #    'defines':    ['<(define)'],
+    #    'my_subdict': {'defines': ['<(define)']}},
+    # will append "IS_MAC" to both "defines" lists.
+
+    # Evaluate conditions sections, allowing variable expansions within them
+    # as well as nested conditionals.  This will process a 'conditions' or
+    # 'target_conditions' section, perform appropriate merging and recursive
+    # conditional and variable processing, and then remove the conditions section
+    # from the_dict if it is present.
+    ProcessConditionsInDict(the_dict, phase, variables, build_file)
+
+    # Conditional processing may have resulted in changes to automatics or the
+    # variables dict.  Reload.
+    variables = variables_in.copy()
+    LoadAutomaticVariablesFromDict(variables, the_dict)
+    LoadVariablesFromVariablesDict(variables, the_dict, the_dict_key)
+
+    # Recurse into child dicts, or process child lists which may result in
+    # further recursion into descendant dicts.
+    for key, value in the_dict.items():
+        # Skip "variables" and string values, which were already processed if
+        # present.
+        if key == "variables" or type(value) is str:
+            continue
+        if type(value) is dict:
+            # Pass a copy of the variables dict so that subdicts can't influence
+            # parents.
+            ProcessVariablesAndConditionsInDict(
+                value, phase, variables, build_file, key
+            )
+        elif type(value) is list:
+            # The list itself can't influence the variables dict, and
+            # ProcessVariablesAndConditionsInList will make copies of the variables
+            # dict if it needs to pass it to something that can influence it.  No
+            # copy is necessary here.
+            ProcessVariablesAndConditionsInList(value, phase, variables, build_file)
+        elif type(value) is not int:
+            raise TypeError("Unknown type " + value.__class__.__name__ + " for " + key)
+
+
+def ProcessVariablesAndConditionsInList(the_list, phase, variables, build_file):
+    # Iterate using an index so that new values can be assigned into the_list.
+    index = 0
+    while index < len(the_list):
+        item = the_list[index]
+        if type(item) is dict:
+            # Make a copy of the variables dict so that it won't influence anything
+            # outside of its own scope.
+            ProcessVariablesAndConditionsInDict(item, phase, variables, build_file)
+        elif type(item) is list:
+            ProcessVariablesAndConditionsInList(item, phase, variables, build_file)
+        elif type(item) is str:
+            expanded = ExpandVariables(item, phase, variables, build_file)
+            if type(expanded) in (str, int):
+                the_list[index] = expanded
+            elif type(expanded) is list:
+                the_list[index : index + 1] = expanded
+                index += len(expanded)
+
+                # index now identifies the next item to examine.  Continue right now
+                # without falling into the index increment below.
+                continue
+            else:
+                raise ValueError(
+                    "Variable expansion in this context permits strings and "
+                    + "lists only, found "
+                    + expanded.__class__.__name__
+                    + " at "
+                    + index
+                )
+        elif type(item) is not int:
+            raise TypeError(
+                "Unknown type " + item.__class__.__name__ + " at index " + index
+            )
+        index = index + 1
 
 
 def BuildTargetsDict(data):
-  """Builds a dict mapping fully-qualified target names to their target dicts.
+    """Builds a dict mapping fully-qualified target names to their target dicts.
 
   |data| is a dict mapping loaded build files by pathname relative to the
   current directory.  Values in |data| are build file contents.  For each
@@ -1353,21 +1475,21 @@ def BuildTargetsDict(data):
   the dicts in the "targets" lists.
   """
 
-  targets = {}
-  for build_file in data['target_build_files']:
-    for target in data[build_file].get('targets', []):
-      target_name = gyp.common.QualifiedTarget(build_file,
-                                               target['target_name'],
-                                               target['toolset'])
-      if target_name in targets:
-        raise GypError('Duplicate target definitions for ' + target_name)
-      targets[target_name] = target
+    targets = {}
+    for build_file in data["target_build_files"]:
+        for target in data[build_file].get("targets", []):
+            target_name = gyp.common.QualifiedTarget(
+                build_file, target["target_name"], target["toolset"]
+            )
+            if target_name in targets:
+                raise GypError("Duplicate target definitions for " + target_name)
+            targets[target_name] = target
 
-  return targets
+    return targets
 
 
 def QualifyDependencies(targets):
-  """Make dependency links fully-qualified relative to the current directory.
+    """Make dependency links fully-qualified relative to the current directory.
 
   |targets| is a dict mapping fully-qualified target names to their target
   dicts.  For each target in this dict, keys known to contain dependency
@@ -1377,36 +1499,46 @@ def QualifyDependencies(targets):
   similar dict.
   """
 
-  all_dependency_sections = [dep + op
-                             for dep in dependency_sections
-                             for op in ('', '!', '/')]
-
-  for target, target_dict in targets.items():
-    target_build_file = gyp.common.BuildFile(target)
-    toolset = target_dict['toolset']
-    for dependency_key in all_dependency_sections:
-      dependencies = target_dict.get(dependency_key, [])
-      for index in range(0, len(dependencies)):
-        dep_file, dep_target, dep_toolset = gyp.common.ResolveTarget(
-            target_build_file, dependencies[index], toolset)
-        if not multiple_toolsets:
-          # Ignore toolset specification in the dependency if it is specified.
-          dep_toolset = toolset
-        dependency = gyp.common.QualifiedTarget(dep_file,
-                                                dep_target,
-                                                dep_toolset)
-        dependencies[index] = dependency
-
-        # Make sure anything appearing in a list other than "dependencies" also
-        # appears in the "dependencies" list.
-        if dependency_key != 'dependencies' and \
-           dependency not in target_dict['dependencies']:
-          raise GypError('Found ' + dependency + ' in ' + dependency_key +
-                         ' of ' + target + ', but not in dependencies')
+    all_dependency_sections = [
+        dep + op for dep in dependency_sections for op in ("", "!", "/")
+    ]
+
+    for target, target_dict in targets.items():
+        target_build_file = gyp.common.BuildFile(target)
+        toolset = target_dict["toolset"]
+        for dependency_key in all_dependency_sections:
+            dependencies = target_dict.get(dependency_key, [])
+            for index, dep in enumerate(dependencies):
+                dep_file, dep_target, dep_toolset = gyp.common.ResolveTarget(
+                    target_build_file, dep, toolset
+                )
+                if not multiple_toolsets:
+                    # Ignore toolset specification in the dependency if it is specified.
+                    dep_toolset = toolset
+                dependency = gyp.common.QualifiedTarget(
+                    dep_file, dep_target, dep_toolset
+                )
+                dependencies[index] = dependency
+
+                # Make sure anything appearing in a list other than "dependencies" also
+                # appears in the "dependencies" list.
+                if (
+                    dependency_key != "dependencies"
+                    and dependency not in target_dict["dependencies"]
+                ):
+                    raise GypError(
+                        "Found "
+                        + dependency
+                        + " in "
+                        + dependency_key
+                        + " of "
+                        + target
+                        + ", but not in dependencies"
+                    )
 
 
 def ExpandWildcardDependencies(targets, data):
-  """Expands dependencies specified as build_file:*.
+    """Expands dependencies specified as build_file:*.
 
   For each target in |targets|, examines sections containing links to other
   targets.  If any such section contains a link of the form build_file:*, it
@@ -1421,110 +1553,130 @@ def ExpandWildcardDependencies(targets, data):
   dependency list, must be qualified when this function is called.
   """
 
-  for target, target_dict in targets.items():
-    toolset = target_dict['toolset']
-    target_build_file = gyp.common.BuildFile(target)
-    for dependency_key in dependency_sections:
-      dependencies = target_dict.get(dependency_key, [])
-
-      # Loop this way instead of "for dependency in" or "for index in range"
-      # because the dependencies list will be modified within the loop body.
-      index = 0
-      while index < len(dependencies):
-        (dependency_build_file, dependency_target, dependency_toolset) = \
-            gyp.common.ParseQualifiedTarget(dependencies[index])
-        if dependency_target != '*' and dependency_toolset != '*':
-          # Not a wildcard.  Keep it moving.
-          index = index + 1
-          continue
-
-        if dependency_build_file == target_build_file:
-          # It's an error for a target to depend on all other targets in
-          # the same file, because a target cannot depend on itself.
-          raise GypError('Found wildcard in ' + dependency_key + ' of ' +
-                         target + ' referring to same build file')
-
-        # Take the wildcard out and adjust the index so that the next
-        # dependency in the list will be processed the next time through the
-        # loop.
-        del dependencies[index]
-        index = index - 1
-
-        # Loop through the targets in the other build file, adding them to
-        # this target's list of dependencies in place of the removed
-        # wildcard.
-        dependency_target_dicts = data[dependency_build_file]['targets']
-        for dependency_target_dict in dependency_target_dicts:
-          if int(dependency_target_dict.get('suppress_wildcard', False)):
-            continue
-          dependency_target_name = dependency_target_dict['target_name']
-          if (dependency_target != '*' and
-              dependency_target != dependency_target_name):
-            continue
-          dependency_target_toolset = dependency_target_dict['toolset']
-          if (dependency_toolset != '*' and
-              dependency_toolset != dependency_target_toolset):
-            continue
-          dependency = gyp.common.QualifiedTarget(dependency_build_file,
-                                                  dependency_target_name,
-                                                  dependency_target_toolset)
-          index = index + 1
-          dependencies.insert(index, dependency)
-
-        index = index + 1
-
-
-def Unify(l):
-  """Removes duplicate elements from l, keeping the first element."""
-  seen = {}
-  return [seen.setdefault(e, e) for e in l if e not in seen]
+    for target, target_dict in targets.items():
+        target_build_file = gyp.common.BuildFile(target)
+        for dependency_key in dependency_sections:
+            dependencies = target_dict.get(dependency_key, [])
+
+            # Loop this way instead of "for dependency in" or "for index in range"
+            # because the dependencies list will be modified within the loop body.
+            index = 0
+            while index < len(dependencies):
+                (
+                    dependency_build_file,
+                    dependency_target,
+                    dependency_toolset,
+                ) = gyp.common.ParseQualifiedTarget(dependencies[index])
+                if dependency_target != "*" and dependency_toolset != "*":
+                    # Not a wildcard.  Keep it moving.
+                    index = index + 1
+                    continue
+
+                if dependency_build_file == target_build_file:
+                    # It's an error for a target to depend on all other targets in
+                    # the same file, because a target cannot depend on itself.
+                    raise GypError(
+                        "Found wildcard in "
+                        + dependency_key
+                        + " of "
+                        + target
+                        + " referring to same build file"
+                    )
+
+                # Take the wildcard out and adjust the index so that the next
+                # dependency in the list will be processed the next time through the
+                # loop.
+                del dependencies[index]
+                index = index - 1
+
+                # Loop through the targets in the other build file, adding them to
+                # this target's list of dependencies in place of the removed
+                # wildcard.
+                dependency_target_dicts = data[dependency_build_file]["targets"]
+                for dependency_target_dict in dependency_target_dicts:
+                    if int(dependency_target_dict.get("suppress_wildcard", False)):
+                        continue
+                    dependency_target_name = dependency_target_dict["target_name"]
+                    if (
+                        dependency_target != "*"
+                        and dependency_target != dependency_target_name
+                    ):
+                        continue
+                    dependency_target_toolset = dependency_target_dict["toolset"]
+                    if (
+                        dependency_toolset != "*"
+                        and dependency_toolset != dependency_target_toolset
+                    ):
+                        continue
+                    dependency = gyp.common.QualifiedTarget(
+                        dependency_build_file,
+                        dependency_target_name,
+                        dependency_target_toolset,
+                    )
+                    index = index + 1
+                    dependencies.insert(index, dependency)
+
+                index = index + 1
+
+
+def Unify(items):
+    """Removes duplicate elements from items, keeping the first element."""
+    seen = {}
+    return [seen.setdefault(e, e) for e in items if e not in seen]
 
 
 def RemoveDuplicateDependencies(targets):
-  """Makes sure every dependency appears only once in all targets's dependency
+    """Makes sure every dependency appears only once in all targets's dependency
   lists."""
-  for target_name, target_dict in targets.items():
-    for dependency_key in dependency_sections:
-      dependencies = target_dict.get(dependency_key, [])
-      if dependencies:
-        target_dict[dependency_key] = Unify(dependencies)
+    for target_name, target_dict in targets.items():
+        for dependency_key in dependency_sections:
+            dependencies = target_dict.get(dependency_key, [])
+            if dependencies:
+                target_dict[dependency_key] = Unify(dependencies)
 
 
-def Filter(l, item):
-  """Removes item from l."""
-  res = {}
-  return [res.setdefault(e, e) for e in l if e != item]
+def Filter(items, item):
+    """Removes item from items."""
+    res = {}
+    return [res.setdefault(e, e) for e in items if e != item]
 
 
 def RemoveSelfDependencies(targets):
-  """Remove self dependencies from targets that have the prune_self_dependency
+    """Remove self dependencies from targets that have the prune_self_dependency
   variable set."""
-  for target_name, target_dict in targets.items():
-    for dependency_key in dependency_sections:
-      dependencies = target_dict.get(dependency_key, [])
-      if dependencies:
-        for t in dependencies:
-          if t == target_name:
-            if targets[t].get('variables', {}).get('prune_self_dependency', 0):
-              target_dict[dependency_key] = Filter(dependencies, target_name)
+    for target_name, target_dict in targets.items():
+        for dependency_key in dependency_sections:
+            dependencies = target_dict.get(dependency_key, [])
+            if dependencies:
+                for t in dependencies:
+                    if t == target_name:
+                        if (
+                            targets[t]
+                            .get("variables", {})
+                            .get("prune_self_dependency", 0)
+                        ):
+                            target_dict[dependency_key] = Filter(
+                                dependencies, target_name
+                            )
 
 
 def RemoveLinkDependenciesFromNoneTargets(targets):
-  """Remove dependencies having the 'link_dependency' attribute from the 'none'
+    """Remove dependencies having the 'link_dependency' attribute from the 'none'
   targets."""
-  for target_name, target_dict in targets.items():
-    for dependency_key in dependency_sections:
-      dependencies = target_dict.get(dependency_key, [])
-      if dependencies:
-        for t in dependencies:
-          if target_dict.get('type', None) == 'none':
-            if targets[t].get('variables', {}).get('link_dependency', 0):
-              target_dict[dependency_key] = \
-                  Filter(target_dict[dependency_key], t)
+    for target_name, target_dict in targets.items():
+        for dependency_key in dependency_sections:
+            dependencies = target_dict.get(dependency_key, [])
+            if dependencies:
+                for t in dependencies:
+                    if target_dict.get("type", None) == "none":
+                        if targets[t].get("variables", {}).get("link_dependency", 0):
+                            target_dict[dependency_key] = Filter(
+                                target_dict[dependency_key], t
+                            )
 
 
 class DependencyGraphNode(object):
-  """
+    """
 
   Attributes:
     ref: A reference to an object that this DependencyGraphNode represents.
@@ -1532,101 +1684,102 @@ class DependencyGraphNode(object):
     dependents: List of DependencyGraphNodes that depend on this one.
   """
 
-  class CircularException(GypError):
-    pass
+    class CircularException(GypError):
+        pass
 
-  def __init__(self, ref):
-    self.ref = ref
-    self.dependencies = []
-    self.dependents = []
-
-  def __repr__(self):
-    return '<DependencyGraphNode: %r>' % self.ref
-
-  def FlattenToList(self):
-    # flat_list is the sorted list of dependencies - actually, the list items
-    # are the "ref" attributes of DependencyGraphNodes.  Every target will
-    # appear in flat_list after all of its dependencies, and before all of its
-    # dependents.
-    flat_list = OrderedSet()
-
-    def ExtractNodeRef(node):
-      """Extracts the object that the node represents from the given node."""
-      return node.ref
-
-    # in_degree_zeros is the list of DependencyGraphNodes that have no
-    # dependencies not in flat_list.  Initially, it is a copy of the children
-    # of this node, because when the graph was built, nodes with no
-    # dependencies were made implicit dependents of the root node.
-    in_degree_zeros = sorted(self.dependents[:], key=ExtractNodeRef)
-
-    while in_degree_zeros:
-      # Nodes in in_degree_zeros have no dependencies not in flat_list, so they
-      # can be appended to flat_list.  Take these nodes out of in_degree_zeros
-      # as work progresses, so that the next node to process from the list can
-      # always be accessed at a consistent position.
-      node = in_degree_zeros.pop()
-      flat_list.add(node.ref)
-
-      # Look at dependents of the node just added to flat_list.  Some of them
-      # may now belong in in_degree_zeros.
-      for node_dependent in sorted(node.dependents, key=ExtractNodeRef):
-        is_in_degree_zero = True
-        # TODO: We want to check through the
-        # node_dependent.dependencies list but if it's long and we
-        # always start at the beginning, then we get O(n^2) behaviour.
-        for node_dependent_dependency in (sorted(node_dependent.dependencies,
-                                                 key=ExtractNodeRef)):
-          if not node_dependent_dependency.ref in flat_list:
-            # The dependent one or more dependencies not in flat_list.  There
-            # will be more chances to add it to flat_list when examining
-            # it again as a dependent of those other dependencies, provided
-            # that there are no cycles.
-            is_in_degree_zero = False
-            break
-
-        if is_in_degree_zero:
-          # All of the dependent's dependencies are already in flat_list.  Add
-          # it to in_degree_zeros where it will be processed in a future
-          # iteration of the outer loop.
-          in_degree_zeros += [node_dependent]
-
-    return list(flat_list)
-
-  def FindCycles(self):
-    """
+    def __init__(self, ref):
+        self.ref = ref
+        self.dependencies = []
+        self.dependents = []
+
+    def __repr__(self):
+        return "<DependencyGraphNode: %r>" % self.ref
+
+    def FlattenToList(self):
+        # flat_list is the sorted list of dependencies - actually, the list items
+        # are the "ref" attributes of DependencyGraphNodes.  Every target will
+        # appear in flat_list after all of its dependencies, and before all of its
+        # dependents.
+        flat_list = OrderedSet()
+
+        def ExtractNodeRef(node):
+            """Extracts the object that the node represents from the given node."""
+            return node.ref
+
+        # in_degree_zeros is the list of DependencyGraphNodes that have no
+        # dependencies not in flat_list.  Initially, it is a copy of the children
+        # of this node, because when the graph was built, nodes with no
+        # dependencies were made implicit dependents of the root node.
+        in_degree_zeros = sorted(self.dependents[:], key=ExtractNodeRef)
+
+        while in_degree_zeros:
+            # Nodes in in_degree_zeros have no dependencies not in flat_list, so they
+            # can be appended to flat_list.  Take these nodes out of in_degree_zeros
+            # as work progresses, so that the next node to process from the list can
+            # always be accessed at a consistent position.
+            node = in_degree_zeros.pop()
+            flat_list.add(node.ref)
+
+            # Look at dependents of the node just added to flat_list.  Some of them
+            # may now belong in in_degree_zeros.
+            for node_dependent in sorted(node.dependents, key=ExtractNodeRef):
+                is_in_degree_zero = True
+                # TODO: We want to check through the
+                # node_dependent.dependencies list but if it's long and we
+                # always start at the beginning, then we get O(n^2) behaviour.
+                for node_dependent_dependency in sorted(
+                    node_dependent.dependencies, key=ExtractNodeRef
+                ):
+                    if node_dependent_dependency.ref not in flat_list:
+                        # The dependent one or more dependencies not in flat_list.
+                        # There will be more chances to add it to flat_list
+                        # when examining it again as a dependent of those other
+                        # dependencies, provided that there are no cycles.
+                        is_in_degree_zero = False
+                        break
+
+                if is_in_degree_zero:
+                    # All of the dependent's dependencies are already in flat_list.  Add
+                    # it to in_degree_zeros where it will be processed in a future
+                    # iteration of the outer loop.
+                    in_degree_zeros += [node_dependent]
+
+        return list(flat_list)
+
+    def FindCycles(self):
+        """
     Returns a list of cycles in the graph, where each cycle is its own list.
     """
-    results = []
-    visited = set()
+        results = []
+        visited = set()
 
-    def Visit(node, path):
-      for child in node.dependents:
-        if child in path:
-          results.append([child] + path[:path.index(child) + 1])
-        elif not child in visited:
-          visited.add(child)
-          Visit(child, [child] + path)
+        def Visit(node, path):
+            for child in node.dependents:
+                if child in path:
+                    results.append([child] + path[: path.index(child) + 1])
+                elif child not in visited:
+                    visited.add(child)
+                    Visit(child, [child] + path)
 
-    visited.add(self)
-    Visit(self, [self])
+        visited.add(self)
+        Visit(self, [self])
 
-    return results
+        return results
 
-  def DirectDependencies(self, dependencies=None):
-    """Returns a list of just direct dependencies."""
-    if dependencies is None:
-      dependencies = []
+    def DirectDependencies(self, dependencies=None):
+        """Returns a list of just direct dependencies."""
+        if dependencies is None:
+            dependencies = []
 
-    for dependency in self.dependencies:
-      # Check for None, corresponding to the root node.
-      if dependency.ref != None and dependency.ref not in dependencies:
-        dependencies.append(dependency.ref)
+        for dependency in self.dependencies:
+            # Check for None, corresponding to the root node.
+            if dependency.ref and dependency.ref not in dependencies:
+                dependencies.append(dependency.ref)
 
-    return dependencies
+        return dependencies
 
-  def _AddImportedDependencies(self, targets, dependencies=None):
-    """Given a list of direct dependencies, adds indirect dependencies that
+    def _AddImportedDependencies(self, targets, dependencies=None):
+        """Given a list of direct dependencies, adds indirect dependencies that
     other dependencies have declared to export their settings.
 
     This method does not operate on self.  Rather, it operates on the list
@@ -1643,58 +1796,60 @@ class DependencyGraphNode(object):
     public entry point.
     """
 
-    if dependencies is None:
-      dependencies = []
-
-    index = 0
-    while index < len(dependencies):
-      dependency = dependencies[index]
-      dependency_dict = targets[dependency]
-      # Add any dependencies whose settings should be imported to the list
-      # if not already present.  Newly-added items will be checked for
-      # their own imports when the list iteration reaches them.
-      # Rather than simply appending new items, insert them after the
-      # dependency that exported them.  This is done to more closely match
-      # the depth-first method used by DeepDependencies.
-      add_index = 1
-      for imported_dependency in \
-          dependency_dict.get('export_dependent_settings', []):
-        if imported_dependency not in dependencies:
-          dependencies.insert(index + add_index, imported_dependency)
-          add_index = add_index + 1
-      index = index + 1
-
-    return dependencies
-
-  def DirectAndImportedDependencies(self, targets, dependencies=None):
-    """Returns a list of a target's direct dependencies and all indirect
+        if dependencies is None:
+            dependencies = []
+
+        index = 0
+        while index < len(dependencies):
+            dependency = dependencies[index]
+            dependency_dict = targets[dependency]
+            # Add any dependencies whose settings should be imported to the list
+            # if not already present.  Newly-added items will be checked for
+            # their own imports when the list iteration reaches them.
+            # Rather than simply appending new items, insert them after the
+            # dependency that exported them.  This is done to more closely match
+            # the depth-first method used by DeepDependencies.
+            add_index = 1
+            for imported_dependency in dependency_dict.get(
+                "export_dependent_settings", []
+            ):
+                if imported_dependency not in dependencies:
+                    dependencies.insert(index + add_index, imported_dependency)
+                    add_index = add_index + 1
+            index = index + 1
+
+        return dependencies
+
+    def DirectAndImportedDependencies(self, targets, dependencies=None):
+        """Returns a list of a target's direct dependencies and all indirect
     dependencies that a dependency has advertised settings should be exported
     through the dependency for.
     """
 
-    dependencies = self.DirectDependencies(dependencies)
-    return self._AddImportedDependencies(targets, dependencies)
-
-  def DeepDependencies(self, dependencies=None):
-    """Returns an OrderedSet of all of a target's dependencies, recursively."""
-    if dependencies is None:
-      # Using a list to get ordered output and a set to do fast "is it
-      # already added" checks.
-      dependencies = OrderedSet()
-
-    for dependency in self.dependencies:
-      # Check for None, corresponding to the root node.
-      if dependency.ref is None:
-        continue
-      if dependency.ref not in dependencies:
-        dependency.DeepDependencies(dependencies)
-        dependencies.add(dependency.ref)
-
-    return dependencies
-
-  def _LinkDependenciesInternal(self, targets, include_shared_libraries,
-                                dependencies=None, initial=True):
-    """Returns an OrderedSet of dependency targets that are linked
+        dependencies = self.DirectDependencies(dependencies)
+        return self._AddImportedDependencies(targets, dependencies)
+
+    def DeepDependencies(self, dependencies=None):
+        """Returns an OrderedSet of all of a target's dependencies, recursively."""
+        if dependencies is None:
+            # Using a list to get ordered output and a set to do fast "is it
+            # already added" checks.
+            dependencies = OrderedSet()
+
+        for dependency in self.dependencies:
+            # Check for None, corresponding to the root node.
+            if dependency.ref is None:
+                continue
+            if dependency.ref not in dependencies:
+                dependency.DeepDependencies(dependencies)
+                dependencies.add(dependency.ref)
+
+        return dependencies
+
+    def _LinkDependenciesInternal(
+        self, targets, include_shared_libraries, dependencies=None, initial=True
+    ):
+        """Returns an OrderedSet of dependency targets that are linked
     into this target.
 
     This function has a split personality, depending on the setting of
@@ -1708,625 +1863,683 @@ class DependencyGraphNode(object):
     If |include_shared_libraries| is False, the resulting dependencies will not
     include shared_library targets that are linked into this target.
     """
-    if dependencies is None:
-      # Using a list to get ordered output and a set to do fast "is it
-      # already added" checks.
-      dependencies = OrderedSet()
-
-    # Check for None, corresponding to the root node.
-    if self.ref is None:
-      return dependencies
-
-    # It's kind of sucky that |targets| has to be passed into this function,
-    # but that's presently the easiest way to access the target dicts so that
-    # this function can find target types.
-
-    if 'target_name' not in targets[self.ref]:
-      raise GypError("Missing 'target_name' field in target.")
-
-    if 'type' not in targets[self.ref]:
-      raise GypError("Missing 'type' field in target %s" %
-                     targets[self.ref]['target_name'])
-
-    target_type = targets[self.ref]['type']
-
-    is_linkable = target_type in linkable_types
-
-    if initial and not is_linkable:
-      # If this is the first target being examined and it's not linkable,
-      # return an empty list of link dependencies, because the link
-      # dependencies are intended to apply to the target itself (initial is
-      # True) and this target won't be linked.
-      return dependencies
-
-    # Don't traverse 'none' targets if explicitly excluded.
-    if (target_type == 'none' and
-        not targets[self.ref].get('dependencies_traverse', True)):
-      dependencies.add(self.ref)
-      return dependencies
-
-    # Executables, mac kernel extensions, windows drivers and loadable modules
-    # are already fully and finally linked. Nothing else can be a link
-    # dependency of them, there can only be dependencies in the sense that a
-    # dependent target might run an executable or load the loadable_module.
-    if not initial and target_type in ('executable', 'loadable_module',
-                                       'mac_kernel_extension',
-                                       'windows_driver'):
-      return dependencies
-
-    # Shared libraries are already fully linked.  They should only be included
-    # in |dependencies| when adjusting static library dependencies (in order to
-    # link against the shared_library's import lib), but should not be included
-    # in |dependencies| when propagating link_settings.
-    # The |include_shared_libraries| flag controls which of these two cases we
-    # are handling.
-    if (not initial and target_type == 'shared_library' and
-        not include_shared_libraries):
-      return dependencies
-
-    # The target is linkable, add it to the list of link dependencies.
-    if self.ref not in dependencies:
-      dependencies.add(self.ref)
-      if initial or not is_linkable:
-        # If this is a subsequent target and it's linkable, don't look any
-        # further for linkable dependencies, as they'll already be linked into
-        # this target linkable.  Always look at dependencies of the initial
-        # target, and always look at dependencies of non-linkables.
-        for dependency in self.dependencies:
-          dependency._LinkDependenciesInternal(targets,
-                                               include_shared_libraries,
-                                               dependencies, False)
-
-    return dependencies
-
-  def DependenciesForLinkSettings(self, targets):
-    """
+        if dependencies is None:
+            # Using a list to get ordered output and a set to do fast "is it
+            # already added" checks.
+            dependencies = OrderedSet()
+
+        # Check for None, corresponding to the root node.
+        if self.ref is None:
+            return dependencies
+
+        # It's kind of sucky that |targets| has to be passed into this function,
+        # but that's presently the easiest way to access the target dicts so that
+        # this function can find target types.
+
+        if "target_name" not in targets[self.ref]:
+            raise GypError("Missing 'target_name' field in target.")
+
+        if "type" not in targets[self.ref]:
+            raise GypError(
+                "Missing 'type' field in target %s" % targets[self.ref]["target_name"]
+            )
+
+        target_type = targets[self.ref]["type"]
+
+        is_linkable = target_type in linkable_types
+
+        if initial and not is_linkable:
+            # If this is the first target being examined and it's not linkable,
+            # return an empty list of link dependencies, because the link
+            # dependencies are intended to apply to the target itself (initial is
+            # True) and this target won't be linked.
+            return dependencies
+
+        # Don't traverse 'none' targets if explicitly excluded.
+        if target_type == "none" and not targets[self.ref].get(
+            "dependencies_traverse", True
+        ):
+            dependencies.add(self.ref)
+            return dependencies
+
+        # Executables, mac kernel extensions, windows drivers and loadable modules
+        # are already fully and finally linked. Nothing else can be a link
+        # dependency of them, there can only be dependencies in the sense that a
+        # dependent target might run an executable or load the loadable_module.
+        if not initial and target_type in (
+            "executable",
+            "loadable_module",
+            "mac_kernel_extension",
+            "windows_driver",
+        ):
+            return dependencies
+
+        # Shared libraries are already fully linked.  They should only be included
+        # in |dependencies| when adjusting static library dependencies (in order to
+        # link against the shared_library's import lib), but should not be included
+        # in |dependencies| when propagating link_settings.
+        # The |include_shared_libraries| flag controls which of these two cases we
+        # are handling.
+        if (
+            not initial
+            and target_type == "shared_library"
+            and not include_shared_libraries
+        ):
+            return dependencies
+
+        # The target is linkable, add it to the list of link dependencies.
+        if self.ref not in dependencies:
+            dependencies.add(self.ref)
+            if initial or not is_linkable:
+                # If this is a subsequent target and it's linkable, don't look any
+                # further for linkable dependencies, as they'll already be linked into
+                # this target linkable.  Always look at dependencies of the initial
+                # target, and always look at dependencies of non-linkables.
+                for dependency in self.dependencies:
+                    dependency._LinkDependenciesInternal(
+                        targets, include_shared_libraries, dependencies, False
+                    )
+
+        return dependencies
+
+    def DependenciesForLinkSettings(self, targets):
+        """
     Returns a list of dependency targets whose link_settings should be merged
     into this target.
     """
 
-    # TODO(sbaig) Currently, chrome depends on the bug that shared libraries'
-    # link_settings are propagated.  So for now, we will allow it, unless the
-    # 'allow_sharedlib_linksettings_propagation' flag is explicitly set to
-    # False.  Once chrome is fixed, we can remove this flag.
-    include_shared_libraries = \
-        targets[self.ref].get('allow_sharedlib_linksettings_propagation', True)
-    return self._LinkDependenciesInternal(targets, include_shared_libraries)
-
-  def DependenciesToLinkAgainst(self, targets):
-    """
+        # TODO(sbaig) Currently, chrome depends on the bug that shared libraries'
+        # link_settings are propagated.  So for now, we will allow it, unless the
+        # 'allow_sharedlib_linksettings_propagation' flag is explicitly set to
+        # False.  Once chrome is fixed, we can remove this flag.
+        include_shared_libraries = targets[self.ref].get(
+            "allow_sharedlib_linksettings_propagation", True
+        )
+        return self._LinkDependenciesInternal(targets, include_shared_libraries)
+
+    def DependenciesToLinkAgainst(self, targets):
+        """
     Returns a list of dependency targets that are linked into this target.
     """
-    return self._LinkDependenciesInternal(targets, True)
+        return self._LinkDependenciesInternal(targets, True)
 
 
 def BuildDependencyList(targets):
-  # Create a DependencyGraphNode for each target.  Put it into a dict for easy
-  # access.
-  dependency_nodes = {}
-  for target, spec in targets.items():
-    if target not in dependency_nodes:
-      dependency_nodes[target] = DependencyGraphNode(target)
-
-  # Set up the dependency links.  Targets that have no dependencies are treated
-  # as dependent on root_node.
-  root_node = DependencyGraphNode(None)
-  for target, spec in targets.items():
-    target_node = dependency_nodes[target]
-    target_build_file = gyp.common.BuildFile(target)
-    dependencies = spec.get('dependencies')
-    if not dependencies:
-      target_node.dependencies = [root_node]
-      root_node.dependents.append(target_node)
-    else:
-      for dependency in dependencies:
-        dependency_node = dependency_nodes.get(dependency)
-        if not dependency_node:
-          raise GypError("Dependency '%s' not found while "
-                         "trying to load target %s" % (dependency, target))
-        target_node.dependencies.append(dependency_node)
-        dependency_node.dependents.append(target_node)
-
-  flat_list = root_node.FlattenToList()
-
-  # If there's anything left unvisited, there must be a circular dependency
-  # (cycle).
-  if len(flat_list) != len(targets):
-    if not root_node.dependents:
-      # If all targets have dependencies, add the first target as a dependent
-      # of root_node so that the cycle can be discovered from root_node.
-      target = targets.keys()[0]
-      target_node = dependency_nodes[target]
-      target_node.dependencies.append(root_node)
-      root_node.dependents.append(target_node)
-
-    cycles = []
-    for cycle in root_node.FindCycles():
-      paths = [node.ref for node in cycle]
-      cycles.append('Cycle: %s' % ' -> '.join(paths))
-    raise DependencyGraphNode.CircularException(
-        'Cycles in dependency graph detected:\n' + '\n'.join(cycles))
-
-  return [dependency_nodes, flat_list]
+    # Create a DependencyGraphNode for each target.  Put it into a dict for easy
+    # access.
+    dependency_nodes = {}
+    for target, spec in targets.items():
+        if target not in dependency_nodes:
+            dependency_nodes[target] = DependencyGraphNode(target)
+
+    # Set up the dependency links.  Targets that have no dependencies are treated
+    # as dependent on root_node.
+    root_node = DependencyGraphNode(None)
+    for target, spec in targets.items():
+        target_node = dependency_nodes[target]
+        dependencies = spec.get("dependencies")
+        if not dependencies:
+            target_node.dependencies = [root_node]
+            root_node.dependents.append(target_node)
+        else:
+            for dependency in dependencies:
+                dependency_node = dependency_nodes.get(dependency)
+                if not dependency_node:
+                    raise GypError(
+                        "Dependency '%s' not found while "
+                        "trying to load target %s" % (dependency, target)
+                    )
+                target_node.dependencies.append(dependency_node)
+                dependency_node.dependents.append(target_node)
+
+    flat_list = root_node.FlattenToList()
+
+    # If there's anything left unvisited, there must be a circular dependency
+    # (cycle).
+    if len(flat_list) != len(targets):
+        if not root_node.dependents:
+            # If all targets have dependencies, add the first target as a dependent
+            # of root_node so that the cycle can be discovered from root_node.
+            target = next(iter(targets))
+            target_node = dependency_nodes[target]
+            target_node.dependencies.append(root_node)
+            root_node.dependents.append(target_node)
+
+        cycles = []
+        for cycle in root_node.FindCycles():
+            paths = [node.ref for node in cycle]
+            cycles.append("Cycle: %s" % " -> ".join(paths))
+        raise DependencyGraphNode.CircularException(
+            "Cycles in dependency graph detected:\n" + "\n".join(cycles)
+        )
+
+    return [dependency_nodes, flat_list]
 
 
 def VerifyNoGYPFileCircularDependencies(targets):
-  # Create a DependencyGraphNode for each gyp file containing a target.  Put
-  # it into a dict for easy access.
-  dependency_nodes = {}
-  for target in targets:
-    build_file = gyp.common.BuildFile(target)
-    if not build_file in dependency_nodes:
-      dependency_nodes[build_file] = DependencyGraphNode(build_file)
-
-  # Set up the dependency links.
-  for target, spec in targets.items():
-    build_file = gyp.common.BuildFile(target)
-    build_file_node = dependency_nodes[build_file]
-    target_dependencies = spec.get('dependencies', [])
-    for dependency in target_dependencies:
-      try:
-        dependency_build_file = gyp.common.BuildFile(dependency)
-      except GypError as e:
-        gyp.common.ExceptionAppend(
-            e, 'while computing dependencies of .gyp file %s' % build_file)
-        raise
-
-      if dependency_build_file == build_file:
-        # A .gyp file is allowed to refer back to itself.
-        continue
-      dependency_node = dependency_nodes.get(dependency_build_file)
-      if not dependency_node:
-        raise GypError("Dependency '%s' not found" % dependency_build_file)
-      if dependency_node not in build_file_node.dependencies:
-        build_file_node.dependencies.append(dependency_node)
-        dependency_node.dependents.append(build_file_node)
-
-
-  # Files that have no dependencies are treated as dependent on root_node.
-  root_node = DependencyGraphNode(None)
-  for build_file_node in dependency_nodes.values():
-    if len(build_file_node.dependencies) == 0:
-      build_file_node.dependencies.append(root_node)
-      root_node.dependents.append(build_file_node)
-
-  flat_list = root_node.FlattenToList()
-
-  # If there's anything left unvisited, there must be a circular dependency
-  # (cycle).
-  if len(flat_list) != len(dependency_nodes):
-    if not root_node.dependents:
-      # If all files have dependencies, add the first file as a dependent
-      # of root_node so that the cycle can be discovered from root_node.
-      file_node = dependency_nodes.values()[0]
-      file_node.dependencies.append(root_node)
-      root_node.dependents.append(file_node)
-    cycles = []
-    for cycle in root_node.FindCycles():
-      paths = [node.ref for node in cycle]
-      cycles.append('Cycle: %s' % ' -> '.join(paths))
-    raise DependencyGraphNode.CircularException(
-        'Cycles in .gyp file dependency graph detected:\n' + '\n'.join(cycles))
+    # Create a DependencyGraphNode for each gyp file containing a target.  Put
+    # it into a dict for easy access.
+    dependency_nodes = {}
+    for target in targets:
+        build_file = gyp.common.BuildFile(target)
+        if build_file not in dependency_nodes:
+            dependency_nodes[build_file] = DependencyGraphNode(build_file)
+
+    # Set up the dependency links.
+    for target, spec in targets.items():
+        build_file = gyp.common.BuildFile(target)
+        build_file_node = dependency_nodes[build_file]
+        target_dependencies = spec.get("dependencies", [])
+        for dependency in target_dependencies:
+            try:
+                dependency_build_file = gyp.common.BuildFile(dependency)
+            except GypError as e:
+                gyp.common.ExceptionAppend(
+                    e, "while computing dependencies of .gyp file %s" % build_file
+                )
+                raise
+
+            if dependency_build_file == build_file:
+                # A .gyp file is allowed to refer back to itself.
+                continue
+            dependency_node = dependency_nodes.get(dependency_build_file)
+            if not dependency_node:
+                raise GypError("Dependency '%s' not found" % dependency_build_file)
+            if dependency_node not in build_file_node.dependencies:
+                build_file_node.dependencies.append(dependency_node)
+                dependency_node.dependents.append(build_file_node)
+
+    # Files that have no dependencies are treated as dependent on root_node.
+    root_node = DependencyGraphNode(None)
+    for build_file_node in dependency_nodes.values():
+        if len(build_file_node.dependencies) == 0:
+            build_file_node.dependencies.append(root_node)
+            root_node.dependents.append(build_file_node)
+
+    flat_list = root_node.FlattenToList()
+
+    # If there's anything left unvisited, there must be a circular dependency
+    # (cycle).
+    if len(flat_list) != len(dependency_nodes):
+        if not root_node.dependents:
+            # If all files have dependencies, add the first file as a dependent
+            # of root_node so that the cycle can be discovered from root_node.
+            file_node = next(iter(dependency_nodes.values()))
+            file_node.dependencies.append(root_node)
+            root_node.dependents.append(file_node)
+        cycles = []
+        for cycle in root_node.FindCycles():
+            paths = [node.ref for node in cycle]
+            cycles.append("Cycle: %s" % " -> ".join(paths))
+        raise DependencyGraphNode.CircularException(
+            "Cycles in .gyp file dependency graph detected:\n" + "\n".join(cycles)
+        )
 
 
 def DoDependentSettings(key, flat_list, targets, dependency_nodes):
-  # key should be one of all_dependent_settings, direct_dependent_settings,
-  # or link_settings.
-
-  for target in flat_list:
-    target_dict = targets[target]
-    build_file = gyp.common.BuildFile(target)
+    # key should be one of all_dependent_settings, direct_dependent_settings,
+    # or link_settings.
 
-    if key == 'all_dependent_settings':
-      dependencies = dependency_nodes[target].DeepDependencies()
-    elif key == 'direct_dependent_settings':
-      dependencies = \
-          dependency_nodes[target].DirectAndImportedDependencies(targets)
-    elif key == 'link_settings':
-      dependencies = \
-          dependency_nodes[target].DependenciesForLinkSettings(targets)
-    else:
-      raise GypError("DoDependentSettings doesn't know how to determine "
-                      'dependencies for ' + key)
-
-    for dependency in dependencies:
-      dependency_dict = targets[dependency]
-      if not key in dependency_dict:
-        continue
-      dependency_build_file = gyp.common.BuildFile(dependency)
-      MergeDicts(target_dict, dependency_dict[key],
-                 build_file, dependency_build_file)
-
-
-def AdjustStaticLibraryDependencies(flat_list, targets, dependency_nodes,
-                                    sort_dependencies):
-  # Recompute target "dependencies" properties.  For each static library
-  # target, remove "dependencies" entries referring to other static libraries,
-  # unless the dependency has the "hard_dependency" attribute set.  For each
-  # linkable target, add a "dependencies" entry referring to all of the
-  # target's computed list of link dependencies (including static libraries
-  # if no such entry is already present.
-  for target in flat_list:
-    target_dict = targets[target]
-    target_type = target_dict['type']
-
-    if target_type == 'static_library':
-      if not 'dependencies' in target_dict:
-        continue
-
-      target_dict['dependencies_original'] = target_dict.get(
-          'dependencies', [])[:]
-
-      # A static library should not depend on another static library unless
-      # the dependency relationship is "hard," which should only be done when
-      # a dependent relies on some side effect other than just the build
-      # product, like a rule or action output. Further, if a target has a
-      # non-hard dependency, but that dependency exports a hard dependency,
-      # the non-hard dependency can safely be removed, but the exported hard
-      # dependency must be added to the target to keep the same dependency
-      # ordering.
-      dependencies = \
-          dependency_nodes[target].DirectAndImportedDependencies(targets)
-      index = 0
-      while index < len(dependencies):
-        dependency = dependencies[index]
-        dependency_dict = targets[dependency]
-
-        # Remove every non-hard static library dependency and remove every
-        # non-static library dependency that isn't a direct dependency.
-        if (dependency_dict['type'] == 'static_library' and \
-            not dependency_dict.get('hard_dependency', False)) or \
-           (dependency_dict['type'] != 'static_library' and \
-            not dependency in target_dict['dependencies']):
-          # Take the dependency out of the list, and don't increment index
-          # because the next dependency to analyze will shift into the index
-          # formerly occupied by the one being removed.
-          del dependencies[index]
+    for target in flat_list:
+        target_dict = targets[target]
+        build_file = gyp.common.BuildFile(target)
+
+        if key == "all_dependent_settings":
+            dependencies = dependency_nodes[target].DeepDependencies()
+        elif key == "direct_dependent_settings":
+            dependencies = dependency_nodes[target].DirectAndImportedDependencies(
+                targets
+            )
+        elif key == "link_settings":
+            dependencies = dependency_nodes[target].DependenciesForLinkSettings(targets)
         else:
-          index = index + 1
-
-      # Update the dependencies. If the dependencies list is empty, it's not
-      # needed, so unhook it.
-      if len(dependencies) > 0:
-        target_dict['dependencies'] = dependencies
-      else:
-        del target_dict['dependencies']
-
-    elif target_type in linkable_types:
-      # Get a list of dependency targets that should be linked into this
-      # target.  Add them to the dependencies list if they're not already
-      # present.
-
-      link_dependencies = \
-          dependency_nodes[target].DependenciesToLinkAgainst(targets)
-      for dependency in link_dependencies:
-        if dependency == target:
-          continue
-        if not 'dependencies' in target_dict:
-          target_dict['dependencies'] = []
-        if not dependency in target_dict['dependencies']:
-          target_dict['dependencies'].append(dependency)
-      # Sort the dependencies list in the order from dependents to dependencies.
-      # e.g. If A and B depend on C and C depends on D, sort them in A, B, C, D.
-      # Note: flat_list is already sorted in the order from dependencies to
-      # dependents.
-      if sort_dependencies and 'dependencies' in target_dict:
-        target_dict['dependencies'] = [dep for dep in reversed(flat_list)
-                                       if dep in target_dict['dependencies']]
+            raise GypError(
+                "DoDependentSettings doesn't know how to determine "
+                "dependencies for " + key
+            )
+
+        for dependency in dependencies:
+            dependency_dict = targets[dependency]
+            if key not in dependency_dict:
+                continue
+            dependency_build_file = gyp.common.BuildFile(dependency)
+            MergeDicts(
+                target_dict, dependency_dict[key], build_file, dependency_build_file
+            )
+
+
+def AdjustStaticLibraryDependencies(
+    flat_list, targets, dependency_nodes, sort_dependencies
+):
+    # Recompute target "dependencies" properties.  For each static library
+    # target, remove "dependencies" entries referring to other static libraries,
+    # unless the dependency has the "hard_dependency" attribute set.  For each
+    # linkable target, add a "dependencies" entry referring to all of the
+    # target's computed list of link dependencies (including static libraries
+    # if no such entry is already present.
+    for target in flat_list:
+        target_dict = targets[target]
+        target_type = target_dict["type"]
+
+        if target_type == "static_library":
+            if "dependencies" not in target_dict:
+                continue
+
+            target_dict["dependencies_original"] = target_dict.get("dependencies", [])[
+                :
+            ]
+
+            # A static library should not depend on another static library unless
+            # the dependency relationship is "hard," which should only be done when
+            # a dependent relies on some side effect other than just the build
+            # product, like a rule or action output. Further, if a target has a
+            # non-hard dependency, but that dependency exports a hard dependency,
+            # the non-hard dependency can safely be removed, but the exported hard
+            # dependency must be added to the target to keep the same dependency
+            # ordering.
+            dependencies = dependency_nodes[target].DirectAndImportedDependencies(
+                targets
+            )
+            index = 0
+            while index < len(dependencies):
+                dependency = dependencies[index]
+                dependency_dict = targets[dependency]
+
+                # Remove every non-hard static library dependency and remove every
+                # non-static library dependency that isn't a direct dependency.
+                if (
+                    dependency_dict["type"] == "static_library"
+                    and not dependency_dict.get("hard_dependency", False)
+                ) or (
+                    dependency_dict["type"] != "static_library"
+                    and dependency not in target_dict["dependencies"]
+                ):
+                    # Take the dependency out of the list, and don't increment index
+                    # because the next dependency to analyze will shift into the index
+                    # formerly occupied by the one being removed.
+                    del dependencies[index]
+                else:
+                    index = index + 1
+
+            # Update the dependencies. If the dependencies list is empty, it's not
+            # needed, so unhook it.
+            if len(dependencies) > 0:
+                target_dict["dependencies"] = dependencies
+            else:
+                del target_dict["dependencies"]
+
+        elif target_type in linkable_types:
+            # Get a list of dependency targets that should be linked into this
+            # target.  Add them to the dependencies list if they're not already
+            # present.
+
+            link_dependencies = dependency_nodes[target].DependenciesToLinkAgainst(
+                targets
+            )
+            for dependency in link_dependencies:
+                if dependency == target:
+                    continue
+                if "dependencies" not in target_dict:
+                    target_dict["dependencies"] = []
+                if dependency not in target_dict["dependencies"]:
+                    target_dict["dependencies"].append(dependency)
+            # Sort the dependencies list in the order from dependents to dependencies.
+            # e.g. If A and B depend on C and C depends on D, sort them in A, B, C, D.
+            # Note: flat_list is already sorted in the order from dependencies to
+            # dependents.
+            if sort_dependencies and "dependencies" in target_dict:
+                target_dict["dependencies"] = [
+                    dep
+                    for dep in reversed(flat_list)
+                    if dep in target_dict["dependencies"]
+                ]
 
 
 # Initialize this here to speed up MakePathRelative.
-exception_re = re.compile(r'''["']?[-/$<>^]''')
+exception_re = re.compile(r"""["']?[-/$<>^]""")
 
 
 def MakePathRelative(to_file, fro_file, item):
-  # If item is a relative path, it's relative to the build file dict that it's
-  # coming from.  Fix it up to make it relative to the build file dict that
-  # it's going into.
-  # Exception: any |item| that begins with these special characters is
-  # returned without modification.
-  #   /   Used when a path is already absolute (shortcut optimization;
-  #       such paths would be returned as absolute anyway)
-  #   $   Used for build environment variables
-  #   -   Used for some build environment flags (such as -lapr-1 in a
-  #       "libraries" section)
-  #   <   Used for our own variable and command expansions (see ExpandVariables)
-  #   >   Used for our own variable and command expansions (see ExpandVariables)
-  #   ^   Used for our own variable and command expansions (see ExpandVariables)
-  #
-  #   "/' Used when a value is quoted.  If these are present, then we
-  #       check the second character instead.
-  #
-  if to_file == fro_file or exception_re.match(item):
-    return item
-  else:
-    # TODO(dglazkov) The backslash/forward-slash replacement at the end is a
-    # temporary measure. This should really be addressed by keeping all paths
-    # in POSIX until actual project generation.
-    ret = os.path.normpath(os.path.join(
-        gyp.common.RelativePath(os.path.dirname(fro_file),
-                                os.path.dirname(to_file)),
-                                item)).replace('\\', '/')
-    if item.endswith('/'):
-      ret += '/'
-    return ret
-
-def MergeLists(to, fro, to_file, fro_file, is_paths=False, append=True):
-  # Python documentation recommends objects which do not support hash
-  # set this value to None. Python library objects follow this rule.
-  is_hashable = lambda val: val.__hash__
-
-  # If x is hashable, returns whether x is in s. Else returns whether x is in l.
-  def is_in_set_or_list(x, s, l):
-    if is_hashable(x):
-      return x in s
-    return x in l
-
-  prepend_index = 0
-
-  # Make membership testing of hashables in |to| (in particular, strings)
-  # faster.
-  hashable_to_set = set(x for x in to if is_hashable(x))
-  for item in fro:
-    singleton = False
-    if type(item) in (str, int):
-      # The cheap and easy case.
-      if is_paths:
-        to_item = MakePathRelative(to_file, fro_file, item)
-      else:
-        to_item = item
-
-      if not (type(item) is str and item.startswith('-')):
-        # Any string that doesn't begin with a "-" is a singleton - it can
-        # only appear once in a list, to be enforced by the list merge append
-        # or prepend.
-        singleton = True
-    elif type(item) is dict:
-      # Make a copy of the dictionary, continuing to look for paths to fix.
-      # The other intelligent aspects of merge processing won't apply because
-      # item is being merged into an empty dict.
-      to_item = {}
-      MergeDicts(to_item, item, to_file, fro_file)
-    elif type(item) is list:
-      # Recurse, making a copy of the list.  If the list contains any
-      # descendant dicts, path fixing will occur.  Note that here, custom
-      # values for is_paths and append are dropped; those are only to be
-      # applied to |to| and |fro|, not sublists of |fro|.  append shouldn't
-      # matter anyway because the new |to_item| list is empty.
-      to_item = []
-      MergeLists(to_item, item, to_file, fro_file)
-    else:
-      raise TypeError(
-          'Attempt to merge list item of unsupported type ' + \
-          item.__class__.__name__)
-
-    if append:
-      # If appending a singleton that's already in the list, don't append.
-      # This ensures that the earliest occurrence of the item will stay put.
-      if not singleton or not is_in_set_or_list(to_item, hashable_to_set, to):
-        to.append(to_item)
-        if is_hashable(to_item):
-          hashable_to_set.add(to_item)
-    else:
-      # If prepending a singleton that's already in the list, remove the
-      # existing instance and proceed with the prepend.  This ensures that the
-      # item appears at the earliest possible position in the list.
-      while singleton and to_item in to:
-        to.remove(to_item)
-
-      # Don't just insert everything at index 0.  That would prepend the new
-      # items to the list in reverse order, which would be an unwelcome
-      # surprise.
-      to.insert(prepend_index, to_item)
-      if is_hashable(to_item):
-        hashable_to_set.add(to_item)
-      prepend_index = prepend_index + 1
-
-
-def MergeDicts(to, fro, to_file, fro_file):
-  # I wanted to name the parameter "from" but it's a Python keyword...
-  for k, v in fro.items():
-    # It would be nice to do "if not k in to: to[k] = v" but that wouldn't give
-    # copy semantics.  Something else may want to merge from the |fro| dict
-    # later, and having the same dict ref pointed to twice in the tree isn't
-    # what anyone wants considering that the dicts may subsequently be
-    # modified.
-    if k in to:
-      bad_merge = False
-      if type(v) in (str, int):
-        if type(to[k]) not in (str, int):
-          bad_merge = True
-      elif type(v) is not type(to[k]):
-        bad_merge = True
-
-      if bad_merge:
-        raise TypeError(
-            'Attempt to merge dict value of type ' + v.__class__.__name__ + \
-            ' into incompatible type ' + to[k].__class__.__name__ + \
-            ' for key ' + k)
-    if type(v) in (str, int):
-      # Overwrite the existing value, if any.  Cheap and easy.
-      is_path = IsPathSection(k)
-      if is_path:
-        to[k] = MakePathRelative(to_file, fro_file, v)
-      else:
-        to[k] = v
-    elif type(v) is dict:
-      # Recurse, guaranteeing copies will be made of objects that require it.
-      if not k in to:
-        to[k] = {}
-      MergeDicts(to[k], v, to_file, fro_file)
-    elif type(v) is list:
-      # Lists in dicts can be merged with different policies, depending on
-      # how the key in the "from" dict (k, the from-key) is written.
-      #
-      # If the from-key has          ...the to-list will have this action
-      # this character appended:...     applied when receiving the from-list:
-      #                           =  replace
-      #                           +  prepend
-      #                           ?  set, only if to-list does not yet exist
-      #                      (none)  append
-      #
-      # This logic is list-specific, but since it relies on the associated
-      # dict key, it's checked in this dict-oriented function.
-      ext = k[-1]
-      append = True
-      if ext == '=':
-        list_base = k[:-1]
-        lists_incompatible = [list_base, list_base + '?']
-        to[list_base] = []
-      elif ext == '+':
-        list_base = k[:-1]
-        lists_incompatible = [list_base + '=', list_base + '?']
-        append = False
-      elif ext == '?':
-        list_base = k[:-1]
-        lists_incompatible = [list_base, list_base + '=', list_base + '+']
-      else:
-        list_base = k
-        lists_incompatible = [list_base + '=', list_base + '?']
-
-      # Some combinations of merge policies appearing together are meaningless.
-      # It's stupid to replace and append simultaneously, for example.  Append
-      # and prepend are the only policies that can coexist.
-      for list_incompatible in lists_incompatible:
-        if list_incompatible in fro:
-          raise GypError('Incompatible list policies ' + k + ' and ' +
-                         list_incompatible)
-
-      if list_base in to:
-        if ext == '?':
-          # If the key ends in "?", the list will only be merged if it doesn't
-          # already exist.
-          continue
-        elif type(to[list_base]) is not list:
-          # This may not have been checked above if merging in a list with an
-          # extension character.
-          raise TypeError(
-              'Attempt to merge dict value of type ' + v.__class__.__name__ + \
-              ' into incompatible type ' + to[list_base].__class__.__name__ + \
-              ' for key ' + list_base + '(' + k + ')')
-      else:
-        to[list_base] = []
-
-      # Call MergeLists, which will make copies of objects that require it.
-      # MergeLists can recurse back into MergeDicts, although this will be
-      # to make copies of dicts (with paths fixed), there will be no
-      # subsequent dict "merging" once entering a list because lists are
-      # always replaced, appended to, or prepended to.
-      is_paths = IsPathSection(list_base)
-      MergeLists(to[list_base], v, to_file, fro_file, is_paths, append)
+    # If item is a relative path, it's relative to the build file dict that it's
+    # coming from.  Fix it up to make it relative to the build file dict that
+    # it's going into.
+    # Exception: any |item| that begins with these special characters is
+    # returned without modification.
+    #   /   Used when a path is already absolute (shortcut optimization;
+    #       such paths would be returned as absolute anyway)
+    #   $   Used for build environment variables
+    #   -   Used for some build environment flags (such as -lapr-1 in a
+    #       "libraries" section)
+    #   <   Used for our own variable and command expansions (see ExpandVariables)
+    #   >   Used for our own variable and command expansions (see ExpandVariables)
+    #   ^   Used for our own variable and command expansions (see ExpandVariables)
+    #
+    #   "/' Used when a value is quoted.  If these are present, then we
+    #       check the second character instead.
+    #
+    if to_file == fro_file or exception_re.match(item):
+        return item
     else:
-      raise TypeError(
-          'Attempt to merge dict value of unsupported type ' + \
-          v.__class__.__name__ + ' for key ' + k)
+        # TODO(dglazkov) The backslash/forward-slash replacement at the end is a
+        # temporary measure. This should really be addressed by keeping all paths
+        # in POSIX until actual project generation.
+        ret = os.path.normpath(
+            os.path.join(
+                gyp.common.RelativePath(
+                    os.path.dirname(fro_file), os.path.dirname(to_file)
+                ),
+                item,
+            )
+        ).replace("\\", "/")
+        if item.endswith("/"):
+            ret += "/"
+        return ret
 
 
-def MergeConfigWithInheritance(new_configuration_dict, build_file,
-                               target_dict, configuration, visited):
-  # Skip if previously visted.
-  if configuration in visited:
-    return
-
-  # Look at this configuration.
-  configuration_dict = target_dict['configurations'][configuration]
+def MergeLists(to, fro, to_file, fro_file, is_paths=False, append=True):
+    # Python documentation recommends objects which do not support hash
+    # set this value to None. Python library objects follow this rule.
+    def is_hashable(val):
+        return val.__hash__
+
+    # If x is hashable, returns whether x is in s. Else returns whether x is in items.
+    def is_in_set_or_list(x, s, items):
+        if is_hashable(x):
+            return x in s
+        return x in items
+
+    prepend_index = 0
+
+    # Make membership testing of hashables in |to| (in particular, strings)
+    # faster.
+    hashable_to_set = set(x for x in to if is_hashable(x))
+    for item in fro:
+        singleton = False
+        if type(item) in (str, int):
+            # The cheap and easy case.
+            if is_paths:
+                to_item = MakePathRelative(to_file, fro_file, item)
+            else:
+                to_item = item
+
+            if not (type(item) is str and item.startswith("-")):
+                # Any string that doesn't begin with a "-" is a singleton - it can
+                # only appear once in a list, to be enforced by the list merge append
+                # or prepend.
+                singleton = True
+        elif type(item) is dict:
+            # Make a copy of the dictionary, continuing to look for paths to fix.
+            # The other intelligent aspects of merge processing won't apply because
+            # item is being merged into an empty dict.
+            to_item = {}
+            MergeDicts(to_item, item, to_file, fro_file)
+        elif type(item) is list:
+            # Recurse, making a copy of the list.  If the list contains any
+            # descendant dicts, path fixing will occur.  Note that here, custom
+            # values for is_paths and append are dropped; those are only to be
+            # applied to |to| and |fro|, not sublists of |fro|.  append shouldn't
+            # matter anyway because the new |to_item| list is empty.
+            to_item = []
+            MergeLists(to_item, item, to_file, fro_file)
+        else:
+            raise TypeError(
+                "Attempt to merge list item of unsupported type "
+                + item.__class__.__name__
+            )
+
+        if append:
+            # If appending a singleton that's already in the list, don't append.
+            # This ensures that the earliest occurrence of the item will stay put.
+            if not singleton or not is_in_set_or_list(to_item, hashable_to_set, to):
+                to.append(to_item)
+                if is_hashable(to_item):
+                    hashable_to_set.add(to_item)
+        else:
+            # If prepending a singleton that's already in the list, remove the
+            # existing instance and proceed with the prepend.  This ensures that the
+            # item appears at the earliest possible position in the list.
+            while singleton and to_item in to:
+                to.remove(to_item)
 
-  # Merge in parents.
-  for parent in configuration_dict.get('inherit_from', []):
-    MergeConfigWithInheritance(new_configuration_dict, build_file,
-                               target_dict, parent, visited + [configuration])
+            # Don't just insert everything at index 0.  That would prepend the new
+            # items to the list in reverse order, which would be an unwelcome
+            # surprise.
+            to.insert(prepend_index, to_item)
+            if is_hashable(to_item):
+                hashable_to_set.add(to_item)
+            prepend_index = prepend_index + 1
 
-  # Merge it into the new config.
-  MergeDicts(new_configuration_dict, configuration_dict,
-             build_file, build_file)
 
-  # Drop abstract.
-  if 'abstract' in new_configuration_dict:
-    del new_configuration_dict['abstract']
+def MergeDicts(to, fro, to_file, fro_file):
+    # I wanted to name the parameter "from" but it's a Python keyword...
+    for k, v in fro.items():
+        # It would be nice to do "if not k in to: to[k] = v" but that wouldn't give
+        # copy semantics.  Something else may want to merge from the |fro| dict
+        # later, and having the same dict ref pointed to twice in the tree isn't
+        # what anyone wants considering that the dicts may subsequently be
+        # modified.
+        if k in to:
+            bad_merge = False
+            if type(v) in (str, int):
+                if type(to[k]) not in (str, int):
+                    bad_merge = True
+            elif not isinstance(v, type(to[k])):
+                bad_merge = True
+
+            if bad_merge:
+                raise TypeError(
+                    "Attempt to merge dict value of type "
+                    + v.__class__.__name__
+                    + " into incompatible type "
+                    + to[k].__class__.__name__
+                    + " for key "
+                    + k
+                )
+        if type(v) in (str, int):
+            # Overwrite the existing value, if any.  Cheap and easy.
+            is_path = IsPathSection(k)
+            if is_path:
+                to[k] = MakePathRelative(to_file, fro_file, v)
+            else:
+                to[k] = v
+        elif type(v) is dict:
+            # Recurse, guaranteeing copies will be made of objects that require it.
+            if k not in to:
+                to[k] = {}
+            MergeDicts(to[k], v, to_file, fro_file)
+        elif type(v) is list:
+            # Lists in dicts can be merged with different policies, depending on
+            # how the key in the "from" dict (k, the from-key) is written.
+            #
+            # If the from-key has          ...the to-list will have this action
+            # this character appended:...     applied when receiving the from-list:
+            #                           =  replace
+            #                           +  prepend
+            #                           ?  set, only if to-list does not yet exist
+            #                      (none)  append
+            #
+            # This logic is list-specific, but since it relies on the associated
+            # dict key, it's checked in this dict-oriented function.
+            ext = k[-1]
+            append = True
+            if ext == "=":
+                list_base = k[:-1]
+                lists_incompatible = [list_base, list_base + "?"]
+                to[list_base] = []
+            elif ext == "+":
+                list_base = k[:-1]
+                lists_incompatible = [list_base + "=", list_base + "?"]
+                append = False
+            elif ext == "?":
+                list_base = k[:-1]
+                lists_incompatible = [list_base, list_base + "=", list_base + "+"]
+            else:
+                list_base = k
+                lists_incompatible = [list_base + "=", list_base + "?"]
+
+            # Some combinations of merge policies appearing together are meaningless.
+            # It's stupid to replace and append simultaneously, for example.  Append
+            # and prepend are the only policies that can coexist.
+            for list_incompatible in lists_incompatible:
+                if list_incompatible in fro:
+                    raise GypError(
+                        "Incompatible list policies " + k + " and " + list_incompatible
+                    )
+
+            if list_base in to:
+                if ext == "?":
+                    # If the key ends in "?", the list will only be merged if it doesn't
+                    # already exist.
+                    continue
+                elif type(to[list_base]) is not list:
+                    # This may not have been checked above if merging in a list with an
+                    # extension character.
+                    raise TypeError(
+                        "Attempt to merge dict value of type "
+                        + v.__class__.__name__
+                        + " into incompatible type "
+                        + to[list_base].__class__.__name__
+                        + " for key "
+                        + list_base
+                        + "("
+                        + k
+                        + ")"
+                    )
+            else:
+                to[list_base] = []
+
+            # Call MergeLists, which will make copies of objects that require it.
+            # MergeLists can recurse back into MergeDicts, although this will be
+            # to make copies of dicts (with paths fixed), there will be no
+            # subsequent dict "merging" once entering a list because lists are
+            # always replaced, appended to, or prepended to.
+            is_paths = IsPathSection(list_base)
+            MergeLists(to[list_base], v, to_file, fro_file, is_paths, append)
+        else:
+            raise TypeError(
+                "Attempt to merge dict value of unsupported type "
+                + v.__class__.__name__
+                + " for key "
+                + k
+            )
+
+
+def MergeConfigWithInheritance(
+    new_configuration_dict, build_file, target_dict, configuration, visited
+):
+    # Skip if previously visited.
+    if configuration in visited:
+        return
+
+    # Look at this configuration.
+    configuration_dict = target_dict["configurations"][configuration]
+
+    # Merge in parents.
+    for parent in configuration_dict.get("inherit_from", []):
+        MergeConfigWithInheritance(
+            new_configuration_dict,
+            build_file,
+            target_dict,
+            parent,
+            visited + [configuration],
+        )
+
+    # Merge it into the new config.
+    MergeDicts(new_configuration_dict, configuration_dict, build_file, build_file)
+
+    # Drop abstract.
+    if "abstract" in new_configuration_dict:
+        del new_configuration_dict["abstract"]
 
 
 def SetUpConfigurations(target, target_dict):
-  # key_suffixes is a list of key suffixes that might appear on key names.
-  # These suffixes are handled in conditional evaluations (for =, +, and ?)
-  # and rules/exclude processing (for ! and /).  Keys with these suffixes
-  # should be treated the same as keys without.
-  key_suffixes = ['=', '+', '?', '!', '/']
-
-  build_file = gyp.common.BuildFile(target)
-
-  # Provide a single configuration by default if none exists.
-  # TODO(mark): Signal an error if default_configurations exists but
-  # configurations does not.
-  if not 'configurations' in target_dict:
-    target_dict['configurations'] = {'Default': {}}
-  if not 'default_configuration' in target_dict:
-    concrete = [i for (i, config) in target_dict['configurations'].items()
-                if not config.get('abstract')]
-    target_dict['default_configuration'] = sorted(concrete)[0]
-
-  merged_configurations = {}
-  configs = target_dict['configurations']
-  for (configuration, old_configuration_dict) in configs.items():
-    # Skip abstract configurations (saves work only).
-    if old_configuration_dict.get('abstract'):
-      continue
-    # Configurations inherit (most) settings from the enclosing target scope.
-    # Get the inheritance relationship right by making a copy of the target
-    # dict.
-    new_configuration_dict = {}
-    for (key, target_val) in target_dict.items():
-      key_ext = key[-1:]
-      if key_ext in key_suffixes:
-        key_base = key[:-1]
-      else:
-        key_base = key
-      if not key_base in non_configuration_keys:
-        new_configuration_dict[key] = gyp.simple_copy.deepcopy(target_val)
-
-    # Merge in configuration (with all its parents first).
-    MergeConfigWithInheritance(new_configuration_dict, build_file,
-                               target_dict, configuration, [])
-
-    merged_configurations[configuration] = new_configuration_dict
-
-  # Put the new configurations back into the target dict as a configuration.
-  for configuration in merged_configurations.keys():
-    target_dict['configurations'][configuration] = (
-        merged_configurations[configuration])
-
-  # Now drop all the abstract ones.
-  for configuration in list(target_dict['configurations']):
-    old_configuration_dict = target_dict['configurations'][configuration]
-    if old_configuration_dict.get('abstract'):
-      del target_dict['configurations'][configuration]
-
-  # Now that all of the target's configurations have been built, go through
-  # the target dict's keys and remove everything that's been moved into a
-  # "configurations" section.
-  delete_keys = []
-  for key in target_dict:
-    key_ext = key[-1:]
-    if key_ext in key_suffixes:
-      key_base = key[:-1]
-    else:
-      key_base = key
-    if not key_base in non_configuration_keys:
-      delete_keys.append(key)
-  for key in delete_keys:
-    del target_dict[key]
+    # key_suffixes is a list of key suffixes that might appear on key names.
+    # These suffixes are handled in conditional evaluations (for =, +, and ?)
+    # and rules/exclude processing (for ! and /).  Keys with these suffixes
+    # should be treated the same as keys without.
+    key_suffixes = ["=", "+", "?", "!", "/"]
 
-  # Check the configurations to see if they contain invalid keys.
-  for configuration in target_dict['configurations'].keys():
-    configuration_dict = target_dict['configurations'][configuration]
-    for key in configuration_dict.keys():
-      if key in invalid_configuration_keys:
-        raise GypError('%s not allowed in the %s configuration, found in '
-                       'target %s' % (key, configuration, target))
+    build_file = gyp.common.BuildFile(target)
 
+    # Provide a single configuration by default if none exists.
+    # TODO(mark): Signal an error if default_configurations exists but
+    # configurations does not.
+    if "configurations" not in target_dict:
+        target_dict["configurations"] = {"Default": {}}
+    if "default_configuration" not in target_dict:
+        concrete = [
+            i
+            for (i, config) in target_dict["configurations"].items()
+            if not config.get("abstract")
+        ]
+        target_dict["default_configuration"] = sorted(concrete)[0]
+
+    merged_configurations = {}
+    configs = target_dict["configurations"]
+    for (configuration, old_configuration_dict) in configs.items():
+        # Skip abstract configurations (saves work only).
+        if old_configuration_dict.get("abstract"):
+            continue
+        # Configurations inherit (most) settings from the enclosing target scope.
+        # Get the inheritance relationship right by making a copy of the target
+        # dict.
+        new_configuration_dict = {}
+        for (key, target_val) in target_dict.items():
+            key_ext = key[-1:]
+            if key_ext in key_suffixes:
+                key_base = key[:-1]
+            else:
+                key_base = key
+            if key_base not in non_configuration_keys:
+                new_configuration_dict[key] = gyp.simple_copy.deepcopy(target_val)
+
+        # Merge in configuration (with all its parents first).
+        MergeConfigWithInheritance(
+            new_configuration_dict, build_file, target_dict, configuration, []
+        )
+
+        merged_configurations[configuration] = new_configuration_dict
+
+    # Put the new configurations back into the target dict as a configuration.
+    for configuration in merged_configurations.keys():
+        target_dict["configurations"][configuration] = merged_configurations[
+            configuration
+        ]
+
+    # Now drop all the abstract ones.
+    configs = target_dict["configurations"]
+    target_dict["configurations"] = {
+        k: v for k, v in configs.items() if not v.get("abstract")
+    }
+
+    # Now that all of the target's configurations have been built, go through
+    # the target dict's keys and remove everything that's been moved into a
+    # "configurations" section.
+    delete_keys = []
+    for key in target_dict:
+        key_ext = key[-1:]
+        if key_ext in key_suffixes:
+            key_base = key[:-1]
+        else:
+            key_base = key
+        if key_base not in non_configuration_keys:
+            delete_keys.append(key)
+    for key in delete_keys:
+        del target_dict[key]
+
+    # Check the configurations to see if they contain invalid keys.
+    for configuration in target_dict["configurations"].keys():
+        configuration_dict = target_dict["configurations"][configuration]
+        for key in configuration_dict.keys():
+            if key in invalid_configuration_keys:
+                raise GypError(
+                    "%s not allowed in the %s configuration, found in "
+                    "target %s" % (key, configuration, target)
+                )
 
 
 def ProcessListFiltersInDict(name, the_dict):
-  """Process regular expression and exclusion-based filters on lists.
+    """Process regular expression and exclusion-based filters on lists.
 
   An exclusion list is in a dict key named with a trailing "!", like
   "sources!".  Every item in such a list is removed from the associated
@@ -2348,151 +2561,163 @@ def ProcessListFiltersInDict(name, the_dict):
   patterns can still cause items to be excluded after matching an "include".
   """
 
-  # Look through the dictionary for any lists whose keys end in "!" or "/".
-  # These are lists that will be treated as exclude lists and regular
-  # expression-based exclude/include lists.  Collect the lists that are
-  # needed first, looking for the lists that they operate on, and assemble
-  # then into |lists|.  This is done in a separate loop up front, because
-  # the _included and _excluded keys need to be added to the_dict, and that
-  # can't be done while iterating through it.
-
-  lists = []
-  del_lists = []
-  for key, value in the_dict.items():
-    operation = key[-1]
-    if operation != '!' and operation != '/':
-      continue
-
-    if type(value) is not list:
-      raise ValueError(name + ' key ' + key + ' must be list, not ' + \
-                       value.__class__.__name__)
-
-    list_key = key[:-1]
-    if list_key not in the_dict:
-      # This happens when there's a list like "sources!" but no corresponding
-      # "sources" list.  Since there's nothing for it to operate on, queue up
-      # the "sources!" list for deletion now.
-      del_lists.append(key)
-      continue
-
-    if type(the_dict[list_key]) is not list:
-      value = the_dict[list_key]
-      raise ValueError(name + ' key ' + list_key + \
-                       ' must be list, not ' + \
-                       value.__class__.__name__ + ' when applying ' + \
-                       {'!': 'exclusion', '/': 'regex'}[operation])
-
-    if not list_key in lists:
-      lists.append(list_key)
-
-  # Delete the lists that are known to be unneeded at this point.
-  for del_list in del_lists:
-    del the_dict[del_list]
-
-  for list_key in lists:
-    the_list = the_dict[list_key]
-
-    # Initialize the list_actions list, which is parallel to the_list.  Each
-    # item in list_actions identifies whether the corresponding item in
-    # the_list should be excluded, unconditionally preserved (included), or
-    # whether no exclusion or inclusion has been applied.  Items for which
-    # no exclusion or inclusion has been applied (yet) have value -1, items
-    # excluded have value 0, and items included have value 1.  Includes and
-    # excludes override previous actions.  All items in list_actions are
-    # initialized to -1 because no excludes or includes have been processed
-    # yet.
-    list_actions = list((-1,) * len(the_list))
-
-    exclude_key = list_key + '!'
-    if exclude_key in the_dict:
-      for exclude_item in the_dict[exclude_key]:
-        for index in range(0, len(the_list)):
-          if exclude_item == the_list[index]:
-            # This item matches the exclude_item, so set its action to 0
-            # (exclude).
-            list_actions[index] = 0
-
-      # The "whatever!" list is no longer needed, dump it.
-      del the_dict[exclude_key]
-
-    regex_key = list_key + '/'
-    if regex_key in the_dict:
-      for regex_item in the_dict[regex_key]:
-        [action, pattern] = regex_item
-        pattern_re = re.compile(pattern)
-
-        if action == 'exclude':
-          # This item matches an exclude regex, so set its value to 0 (exclude).
-          action_value = 0
-        elif action == 'include':
-          # This item matches an include regex, so set its value to 1 (include).
-          action_value = 1
-        else:
-          # This is an action that doesn't make any sense.
-          raise ValueError('Unrecognized action ' + action + ' in ' + name + \
-                           ' key ' + regex_key)
-
-        for index in range(0, len(the_list)):
-          list_item = the_list[index]
-          if list_actions[index] == action_value:
-            # Even if the regex matches, nothing will change so continue (regex
-            # searches are expensive).
+    # Look through the dictionary for any lists whose keys end in "!" or "/".
+    # These are lists that will be treated as exclude lists and regular
+    # expression-based exclude/include lists.  Collect the lists that are
+    # needed first, looking for the lists that they operate on, and assemble
+    # then into |lists|.  This is done in a separate loop up front, because
+    # the _included and _excluded keys need to be added to the_dict, and that
+    # can't be done while iterating through it.
+
+    lists = []
+    del_lists = []
+    for key, value in the_dict.items():
+        operation = key[-1]
+        if operation != "!" and operation != "/":
             continue
-          if pattern_re.search(list_item):
-            # Regular expression match.
-            list_actions[index] = action_value
 
-      # The "whatever/" list is no longer needed, dump it.
-      del the_dict[regex_key]
+        if type(value) is not list:
+            raise ValueError(
+                name + " key " + key + " must be list, not " + value.__class__.__name__
+            )
+
+        list_key = key[:-1]
+        if list_key not in the_dict:
+            # This happens when there's a list like "sources!" but no corresponding
+            # "sources" list.  Since there's nothing for it to operate on, queue up
+            # the "sources!" list for deletion now.
+            del_lists.append(key)
+            continue
 
-    # Add excluded items to the excluded list.
-    #
-    # Note that exclude_key ("sources!") is different from excluded_key
-    # ("sources_excluded").  The exclude_key list is input and it was already
-    # processed and deleted; the excluded_key list is output and it's about
-    # to be created.
-    excluded_key = list_key + '_excluded'
-    if excluded_key in the_dict:
-      raise GypError(name + ' key ' + excluded_key +
-                     ' must not be present prior '
-                     ' to applying exclusion/regex filters for ' + list_key)
-
-    excluded_list = []
-
-    # Go backwards through the list_actions list so that as items are deleted,
-    # the indices of items that haven't been seen yet don't shift.  That means
-    # that things need to be prepended to excluded_list to maintain them in the
-    # same order that they existed in the_list.
-    for index in range(len(list_actions) - 1, -1, -1):
-      if list_actions[index] == 0:
-        # Dump anything with action 0 (exclude).  Keep anything with action 1
-        # (include) or -1 (no include or exclude seen for the item).
-        excluded_list.insert(0, the_list[index])
-        del the_list[index]
-
-    # If anything was excluded, put the excluded list into the_dict at
-    # excluded_key.
-    if len(excluded_list) > 0:
-      the_dict[excluded_key] = excluded_list
-
-  # Now recurse into subdicts and lists that may contain dicts.
-  for key, value in the_dict.items():
-    if type(value) is dict:
-      ProcessListFiltersInDict(key, value)
-    elif type(value) is list:
-      ProcessListFiltersInList(key, value)
+        if type(the_dict[list_key]) is not list:
+            value = the_dict[list_key]
+            raise ValueError(
+                name
+                + " key "
+                + list_key
+                + " must be list, not "
+                + value.__class__.__name__
+                + " when applying "
+                + {"!": "exclusion", "/": "regex"}[operation]
+            )
+
+        if list_key not in lists:
+            lists.append(list_key)
+
+    # Delete the lists that are known to be unneeded at this point.
+    for del_list in del_lists:
+        del the_dict[del_list]
+
+    for list_key in lists:
+        the_list = the_dict[list_key]
+
+        # Initialize the list_actions list, which is parallel to the_list.  Each
+        # item in list_actions identifies whether the corresponding item in
+        # the_list should be excluded, unconditionally preserved (included), or
+        # whether no exclusion or inclusion has been applied.  Items for which
+        # no exclusion or inclusion has been applied (yet) have value -1, items
+        # excluded have value 0, and items included have value 1.  Includes and
+        # excludes override previous actions.  All items in list_actions are
+        # initialized to -1 because no excludes or includes have been processed
+        # yet.
+        list_actions = list((-1,) * len(the_list))
+
+        exclude_key = list_key + "!"
+        if exclude_key in the_dict:
+            for exclude_item in the_dict[exclude_key]:
+                for index, list_item in enumerate(the_list):
+                    if exclude_item == list_item:
+                        # This item matches the exclude_item, so set its action to 0
+                        # (exclude).
+                        list_actions[index] = 0
+
+            # The "whatever!" list is no longer needed, dump it.
+            del the_dict[exclude_key]
+
+        regex_key = list_key + "/"
+        if regex_key in the_dict:
+            for regex_item in the_dict[regex_key]:
+                [action, pattern] = regex_item
+                pattern_re = re.compile(pattern)
+
+                if action == "exclude":
+                    # This item matches an exclude regex, set its value to 0 (exclude).
+                    action_value = 0
+                elif action == "include":
+                    # This item matches an include regex, set its value to 1 (include).
+                    action_value = 1
+                else:
+                    # This is an action that doesn't make any sense.
+                    raise ValueError(
+                        "Unrecognized action "
+                        + action
+                        + " in "
+                        + name
+                        + " key "
+                        + regex_key
+                    )
+
+                for index, list_item in enumerate(the_list):
+                    if list_actions[index] == action_value:
+                        # Even if the regex matches, nothing will change so continue
+                        # (regex searches are expensive).
+                        continue
+                    if pattern_re.search(list_item):
+                        # Regular expression match.
+                        list_actions[index] = action_value
+
+            # The "whatever/" list is no longer needed, dump it.
+            del the_dict[regex_key]
+
+        # Add excluded items to the excluded list.
+        #
+        # Note that exclude_key ("sources!") is different from excluded_key
+        # ("sources_excluded").  The exclude_key list is input and it was already
+        # processed and deleted; the excluded_key list is output and it's about
+        # to be created.
+        excluded_key = list_key + "_excluded"
+        if excluded_key in the_dict:
+            raise GypError(
+                name + " key " + excluded_key + " must not be present prior "
+                " to applying exclusion/regex filters for " + list_key
+            )
+
+        excluded_list = []
+
+        # Go backwards through the list_actions list so that as items are deleted,
+        # the indices of items that haven't been seen yet don't shift.  That means
+        # that things need to be prepended to excluded_list to maintain them in the
+        # same order that they existed in the_list.
+        for index in range(len(list_actions) - 1, -1, -1):
+            if list_actions[index] == 0:
+                # Dump anything with action 0 (exclude).  Keep anything with action 1
+                # (include) or -1 (no include or exclude seen for the item).
+                excluded_list.insert(0, the_list[index])
+                del the_list[index]
+
+        # If anything was excluded, put the excluded list into the_dict at
+        # excluded_key.
+        if len(excluded_list) > 0:
+            the_dict[excluded_key] = excluded_list
+
+    # Now recurse into subdicts and lists that may contain dicts.
+    for key, value in the_dict.items():
+        if type(value) is dict:
+            ProcessListFiltersInDict(key, value)
+        elif type(value) is list:
+            ProcessListFiltersInList(key, value)
 
 
 def ProcessListFiltersInList(name, the_list):
-  for item in the_list:
-    if type(item) is dict:
-      ProcessListFiltersInDict(name, item)
-    elif type(item) is list:
-      ProcessListFiltersInList(name, item)
+    for item in the_list:
+        if type(item) is dict:
+            ProcessListFiltersInDict(name, item)
+        elif type(item) is list:
+            ProcessListFiltersInList(name, item)
 
 
 def ValidateTargetType(target, target_dict):
-  """Ensures the 'type' field on the target is one of the known types.
+    """Ensures the 'type' field on the target is one of the known types.
 
   Arguments:
     target: string, name of target.
@@ -2500,52 +2725,33 @@ def ValidateTargetType(target, target_dict):
 
   Raises an exception on error.
   """
-  VALID_TARGET_TYPES = ('executable', 'loadable_module',
-                        'static_library', 'shared_library',
-                        'mac_kernel_extension', 'none', 'windows_driver')
-  target_type = target_dict.get('type', None)
-  if target_type not in VALID_TARGET_TYPES:
-    raise GypError("Target %s has an invalid target type '%s'.  "
-                   "Must be one of %s." %
-                   (target, target_type, '/'.join(VALID_TARGET_TYPES)))
-  if (target_dict.get('standalone_static_library', 0) and
-      not target_type == 'static_library'):
-    raise GypError('Target %s has type %s but standalone_static_library flag is'
-                   ' only valid for static_library type.' % (target,
-                                                             target_type))
-
-
-def ValidateSourcesInTarget(target, target_dict, build_file,
-                            duplicate_basename_check):
-  if not duplicate_basename_check:
-    return
-  if target_dict.get('type', None) != 'static_library':
-    return
-  sources = target_dict.get('sources', [])
-  basenames = {}
-  for source in sources:
-    name, ext = os.path.splitext(source)
-    is_compiled_file = ext in [
-        '.c', '.cc', '.cpp', '.cxx', '.m', '.mm', '.s', '.S']
-    if not is_compiled_file:
-      continue
-    basename = os.path.basename(name)  # Don't include extension.
-    basenames.setdefault(basename, []).append(source)
-
-  error = ''
-  for basename, files in basenames.items():
-    if len(files) > 1:
-      error += '  %s: %s\n' % (basename, ' '.join(files))
-
-  if error:
-    print('static library %s has several files with the same basename:\n' % target
-          + error + 'libtool on Mac cannot handle that. Use '
-          '--no-duplicate-basename-check to disable this validation.')
-    raise GypError('Duplicate basenames in sources section, see list above')
+    VALID_TARGET_TYPES = (
+        "executable",
+        "loadable_module",
+        "static_library",
+        "shared_library",
+        "mac_kernel_extension",
+        "none",
+        "windows_driver",
+    )
+    target_type = target_dict.get("type", None)
+    if target_type not in VALID_TARGET_TYPES:
+        raise GypError(
+            "Target %s has an invalid target type '%s'.  "
+            "Must be one of %s." % (target, target_type, "/".join(VALID_TARGET_TYPES))
+        )
+    if (
+        target_dict.get("standalone_static_library", 0)
+        and not target_type == "static_library"
+    ):
+        raise GypError(
+            "Target %s has type %s but standalone_static_library flag is"
+            " only valid for static_library type." % (target, target_type)
+        )
 
 
 def ValidateRulesInTarget(target, target_dict, extra_sources_for_rules):
-  """Ensures that the rules sections in target_dict are valid and consistent,
+    """Ensures that the rules sections in target_dict are valid and consistent,
   and determines which sources they apply to.
 
   Arguments:
@@ -2555,357 +2761,389 @@ def ValidateRulesInTarget(target, target_dict, extra_sources_for_rules):
         addition to 'sources'.
   """
 
-  # Dicts to map between values found in rules' 'rule_name' and 'extension'
-  # keys and the rule dicts themselves.
-  rule_names = {}
-  rule_extensions = {}
-
-  rules = target_dict.get('rules', [])
-  for rule in rules:
-    # Make sure that there's no conflict among rule names and extensions.
-    rule_name = rule['rule_name']
-    if rule_name in rule_names:
-      raise GypError('rule %s exists in duplicate, target %s' %
-                     (rule_name, target))
-    rule_names[rule_name] = rule
-
-    rule_extension = rule['extension']
-    if rule_extension.startswith('.'):
-      rule_extension = rule_extension[1:]
-    if rule_extension in rule_extensions:
-      raise GypError(('extension %s associated with multiple rules, ' +
-                      'target %s rules %s and %s') %
-                     (rule_extension, target,
-                      rule_extensions[rule_extension]['rule_name'],
-                      rule_name))
-    rule_extensions[rule_extension] = rule
-
-    # Make sure rule_sources isn't already there.  It's going to be
-    # created below if needed.
-    if 'rule_sources' in rule:
-      raise GypError(
-            'rule_sources must not exist in input, target %s rule %s' %
-            (target, rule_name))
-
-    rule_sources = []
-    source_keys = ['sources']
-    source_keys.extend(extra_sources_for_rules)
-    for source_key in source_keys:
-      for source in target_dict.get(source_key, []):
-        (source_root, source_extension) = os.path.splitext(source)
-        if source_extension.startswith('.'):
-          source_extension = source_extension[1:]
-        if source_extension == rule_extension:
-          rule_sources.append(source)
-
-    if len(rule_sources) > 0:
-      rule['rule_sources'] = rule_sources
+    # Dicts to map between values found in rules' 'rule_name' and 'extension'
+    # keys and the rule dicts themselves.
+    rule_names = {}
+    rule_extensions = {}
+
+    rules = target_dict.get("rules", [])
+    for rule in rules:
+        # Make sure that there's no conflict among rule names and extensions.
+        rule_name = rule["rule_name"]
+        if rule_name in rule_names:
+            raise GypError(
+                "rule %s exists in duplicate, target %s" % (rule_name, target)
+            )
+        rule_names[rule_name] = rule
+
+        rule_extension = rule["extension"]
+        if rule_extension.startswith("."):
+            rule_extension = rule_extension[1:]
+        if rule_extension in rule_extensions:
+            raise GypError(
+                (
+                    "extension %s associated with multiple rules, "
+                    + "target %s rules %s and %s"
+                )
+                % (
+                    rule_extension,
+                    target,
+                    rule_extensions[rule_extension]["rule_name"],
+                    rule_name,
+                )
+            )
+        rule_extensions[rule_extension] = rule
+
+        # Make sure rule_sources isn't already there.  It's going to be
+        # created below if needed.
+        if "rule_sources" in rule:
+            raise GypError(
+                "rule_sources must not exist in input, target %s rule %s"
+                % (target, rule_name)
+            )
+
+        rule_sources = []
+        source_keys = ["sources"]
+        source_keys.extend(extra_sources_for_rules)
+        for source_key in source_keys:
+            for source in target_dict.get(source_key, []):
+                (source_root, source_extension) = os.path.splitext(source)
+                if source_extension.startswith("."):
+                    source_extension = source_extension[1:]
+                if source_extension == rule_extension:
+                    rule_sources.append(source)
+
+        if len(rule_sources) > 0:
+            rule["rule_sources"] = rule_sources
 
 
 def ValidateRunAsInTarget(target, target_dict, build_file):
-  target_name = target_dict.get('target_name')
-  run_as = target_dict.get('run_as')
-  if not run_as:
-    return
-  if type(run_as) is not dict:
-    raise GypError("The 'run_as' in target %s from file %s should be a "
-                   "dictionary." %
-                   (target_name, build_file))
-  action = run_as.get('action')
-  if not action:
-    raise GypError("The 'run_as' in target %s from file %s must have an "
-                   "'action' section." %
-                   (target_name, build_file))
-  if type(action) is not list:
-    raise GypError("The 'action' for 'run_as' in target %s from file %s "
-                   "must be a list." %
-                   (target_name, build_file))
-  working_directory = run_as.get('working_directory')
-  if working_directory and type(working_directory) is not str:
-    raise GypError("The 'working_directory' for 'run_as' in target %s "
-                   "in file %s should be a string." %
-                   (target_name, build_file))
-  environment = run_as.get('environment')
-  if environment and type(environment) is not dict:
-    raise GypError("The 'environment' for 'run_as' in target %s "
-                   "in file %s should be a dictionary." %
-                   (target_name, build_file))
+    target_name = target_dict.get("target_name")
+    run_as = target_dict.get("run_as")
+    if not run_as:
+        return
+    if type(run_as) is not dict:
+        raise GypError(
+            "The 'run_as' in target %s from file %s should be a "
+            "dictionary." % (target_name, build_file)
+        )
+    action = run_as.get("action")
+    if not action:
+        raise GypError(
+            "The 'run_as' in target %s from file %s must have an "
+            "'action' section." % (target_name, build_file)
+        )
+    if type(action) is not list:
+        raise GypError(
+            "The 'action' for 'run_as' in target %s from file %s "
+            "must be a list." % (target_name, build_file)
+        )
+    working_directory = run_as.get("working_directory")
+    if working_directory and type(working_directory) is not str:
+        raise GypError(
+            "The 'working_directory' for 'run_as' in target %s "
+            "in file %s should be a string." % (target_name, build_file)
+        )
+    environment = run_as.get("environment")
+    if environment and type(environment) is not dict:
+        raise GypError(
+            "The 'environment' for 'run_as' in target %s "
+            "in file %s should be a dictionary." % (target_name, build_file)
+        )
 
 
 def ValidateActionsInTarget(target, target_dict, build_file):
-  '''Validates the inputs to the actions in a target.'''
-  target_name = target_dict.get('target_name')
-  actions = target_dict.get('actions', [])
-  for action in actions:
-    action_name = action.get('action_name')
-    if not action_name:
-      raise GypError("Anonymous action in target %s.  "
-                     "An action must have an 'action_name' field." %
-                     target_name)
-    inputs = action.get('inputs', None)
-    if inputs is None:
-      raise GypError('Action in target %s has no inputs.' % target_name)
-    action_command = action.get('action')
-    if action_command and not action_command[0]:
-      raise GypError("Empty action as command in target %s." % target_name)
+    """Validates the inputs to the actions in a target."""
+    target_name = target_dict.get("target_name")
+    actions = target_dict.get("actions", [])
+    for action in actions:
+        action_name = action.get("action_name")
+        if not action_name:
+            raise GypError(
+                "Anonymous action in target %s.  "
+                "An action must have an 'action_name' field." % target_name
+            )
+        inputs = action.get("inputs", None)
+        if inputs is None:
+            raise GypError("Action in target %s has no inputs." % target_name)
+        action_command = action.get("action")
+        if action_command and not action_command[0]:
+            raise GypError("Empty action as command in target %s." % target_name)
 
 
 def TurnIntIntoStrInDict(the_dict):
-  """Given dict the_dict, recursively converts all integers into strings.
+    """Given dict the_dict, recursively converts all integers into strings.
   """
-  # Use items instead of iteritems because there's no need to try to look at
-  # reinserted keys and their associated values.
-  for k, v in the_dict.items():
-    if type(v) is int:
-      v = str(v)
-      the_dict[k] = v
-    elif type(v) is dict:
-      TurnIntIntoStrInDict(v)
-    elif type(v) is list:
-      TurnIntIntoStrInList(v)
-
-    if type(k) is int:
-      del the_dict[k]
-      the_dict[str(k)] = v
+    # Use items instead of iteritems because there's no need to try to look at
+    # reinserted keys and their associated values.
+    for k, v in the_dict.items():
+        if type(v) is int:
+            v = str(v)
+            the_dict[k] = v
+        elif type(v) is dict:
+            TurnIntIntoStrInDict(v)
+        elif type(v) is list:
+            TurnIntIntoStrInList(v)
+
+        if type(k) is int:
+            del the_dict[k]
+            the_dict[str(k)] = v
 
 
 def TurnIntIntoStrInList(the_list):
-  """Given list the_list, recursively converts all integers into strings.
+    """Given list the_list, recursively converts all integers into strings.
   """
-  for index in range(0, len(the_list)):
-    item = the_list[index]
-    if type(item) is int:
-      the_list[index] = str(item)
-    elif type(item) is dict:
-      TurnIntIntoStrInDict(item)
-    elif type(item) is list:
-      TurnIntIntoStrInList(item)
-
-
-def PruneUnwantedTargets(targets, flat_list, dependency_nodes, root_targets,
-                         data):
-  """Return only the targets that are deep dependencies of |root_targets|."""
-  qualified_root_targets = []
-  for target in root_targets:
-    target = target.strip()
-    qualified_targets = gyp.common.FindQualifiedTargets(target, flat_list)
-    if not qualified_targets:
-      raise GypError("Could not find target %s" % target)
-    qualified_root_targets.extend(qualified_targets)
-
-  wanted_targets = {}
-  for target in qualified_root_targets:
-    wanted_targets[target] = targets[target]
-    for dependency in dependency_nodes[target].DeepDependencies():
-      wanted_targets[dependency] = targets[dependency]
-
-  wanted_flat_list = [t for t in flat_list if t in wanted_targets]
-
-  # Prune unwanted targets from each build_file's data dict.
-  for build_file in data['target_build_files']:
-    if not 'targets' in data[build_file]:
-      continue
-    new_targets = []
-    for target in data[build_file]['targets']:
-      qualified_name = gyp.common.QualifiedTarget(build_file,
-                                                  target['target_name'],
-                                                  target['toolset'])
-      if qualified_name in wanted_targets:
-        new_targets.append(target)
-    data[build_file]['targets'] = new_targets
-
-  return wanted_targets, wanted_flat_list
+    for index, item in enumerate(the_list):
+        if type(item) is int:
+            the_list[index] = str(item)
+        elif type(item) is dict:
+            TurnIntIntoStrInDict(item)
+        elif type(item) is list:
+            TurnIntIntoStrInList(item)
+
+
+def PruneUnwantedTargets(targets, flat_list, dependency_nodes, root_targets, data):
+    """Return only the targets that are deep dependencies of |root_targets|."""
+    qualified_root_targets = []
+    for target in root_targets:
+        target = target.strip()
+        qualified_targets = gyp.common.FindQualifiedTargets(target, flat_list)
+        if not qualified_targets:
+            raise GypError("Could not find target %s" % target)
+        qualified_root_targets.extend(qualified_targets)
+
+    wanted_targets = {}
+    for target in qualified_root_targets:
+        wanted_targets[target] = targets[target]
+        for dependency in dependency_nodes[target].DeepDependencies():
+            wanted_targets[dependency] = targets[dependency]
+
+    wanted_flat_list = [t for t in flat_list if t in wanted_targets]
+
+    # Prune unwanted targets from each build_file's data dict.
+    for build_file in data["target_build_files"]:
+        if "targets" not in data[build_file]:
+            continue
+        new_targets = []
+        for target in data[build_file]["targets"]:
+            qualified_name = gyp.common.QualifiedTarget(
+                build_file, target["target_name"], target["toolset"]
+            )
+            if qualified_name in wanted_targets:
+                new_targets.append(target)
+        data[build_file]["targets"] = new_targets
+
+    return wanted_targets, wanted_flat_list
 
 
 def VerifyNoCollidingTargets(targets):
-  """Verify that no two targets in the same directory share the same name.
+    """Verify that no two targets in the same directory share the same name.
 
   Arguments:
     targets: A list of targets in the form 'path/to/file.gyp:target_name'.
   """
-  # Keep a dict going from 'subdirectory:target_name' to 'foo.gyp'.
-  used = {}
-  for target in targets:
-    # Separate out 'path/to/file.gyp, 'target_name' from
-    # 'path/to/file.gyp:target_name'.
-    path, name = target.rsplit(':', 1)
-    # Separate out 'path/to', 'file.gyp' from 'path/to/file.gyp'.
-    subdir, gyp = os.path.split(path)
-    # Use '.' for the current directory '', so that the error messages make
-    # more sense.
-    if not subdir:
-      subdir = '.'
-    # Prepare a key like 'path/to:target_name'.
-    key = subdir + ':' + name
-    if key in used:
-      # Complain if this target is already used.
-      raise GypError('Duplicate target name "%s" in directory "%s" used both '
-                     'in "%s" and "%s".' % (name, subdir, gyp, used[key]))
-    used[key] = gyp
+    # Keep a dict going from 'subdirectory:target_name' to 'foo.gyp'.
+    used = {}
+    for target in targets:
+        # Separate out 'path/to/file.gyp, 'target_name' from
+        # 'path/to/file.gyp:target_name'.
+        path, name = target.rsplit(":", 1)
+        # Separate out 'path/to', 'file.gyp' from 'path/to/file.gyp'.
+        subdir, gyp = os.path.split(path)
+        # Use '.' for the current directory '', so that the error messages make
+        # more sense.
+        if not subdir:
+            subdir = "."
+        # Prepare a key like 'path/to:target_name'.
+        key = subdir + ":" + name
+        if key in used:
+            # Complain if this target is already used.
+            raise GypError(
+                'Duplicate target name "%s" in directory "%s" used both '
+                'in "%s" and "%s".' % (name, subdir, gyp, used[key])
+            )
+        used[key] = gyp
 
 
 def SetGeneratorGlobals(generator_input_info):
-  # Set up path_sections and non_configuration_keys with the default data plus
-  # the generator-specific data.
-  global path_sections
-  path_sections = set(base_path_sections)
-  path_sections.update(generator_input_info['path_sections'])
-
-  global non_configuration_keys
-  non_configuration_keys = base_non_configuration_keys[:]
-  non_configuration_keys.extend(generator_input_info['non_configuration_keys'])
-
-  global multiple_toolsets
-  multiple_toolsets = generator_input_info[
-      'generator_supports_multiple_toolsets']
-
-  global generator_filelist_paths
-  generator_filelist_paths = generator_input_info['generator_filelist_paths']
-
-
-def Load(build_files, variables, includes, depth, generator_input_info, check,
-         circular_check, duplicate_basename_check, parallel, root_targets):
-  SetGeneratorGlobals(generator_input_info)
-  # A generator can have other lists (in addition to sources) be processed
-  # for rules.
-  extra_sources_for_rules = generator_input_info['extra_sources_for_rules']
-
-  # Load build files.  This loads every target-containing build file into
-  # the |data| dictionary such that the keys to |data| are build file names,
-  # and the values are the entire build file contents after "early" or "pre"
-  # processing has been done and includes have been resolved.
-  # NOTE: data contains both "target" files (.gyp) and "includes" (.gypi), as
-  # well as meta-data (e.g. 'included_files' key). 'target_build_files' keeps
-  # track of the keys corresponding to "target" files.
-  data = {'target_build_files': set()}
-  # Normalize paths everywhere.  This is important because paths will be
-  # used as keys to the data dict and for references between input files.
-  build_files = set(map(os.path.normpath, build_files))
-  if parallel:
-    LoadTargetBuildFilesParallel(build_files, data, variables, includes, depth,
-                                 check, generator_input_info)
-  else:
-    aux_data = {}
-    for build_file in build_files:
-      try:
-        LoadTargetBuildFile(build_file, data, aux_data,
-                            variables, includes, depth, check, True)
-      except Exception as e:
-        gyp.common.ExceptionAppend(e, 'while trying to load %s' % build_file)
-        raise
-
-  # Build a dict to access each target's subdict by qualified name.
-  targets = BuildTargetsDict(data)
-
-  # Fully qualify all dependency links.
-  QualifyDependencies(targets)
-
-  # Remove self-dependencies from targets that have 'prune_self_dependencies'
-  # set to 1.
-  RemoveSelfDependencies(targets)
-
-  # Expand dependencies specified as build_file:*.
-  ExpandWildcardDependencies(targets, data)
-
-  # Remove all dependencies marked as 'link_dependency' from the targets of
-  # type 'none'.
-  RemoveLinkDependenciesFromNoneTargets(targets)
-
-  # Apply exclude (!) and regex (/) list filters only for dependency_sections.
-  for target_name, target_dict in targets.items():
-    tmp_dict = {}
-    for key_base in dependency_sections:
-      for op in ('', '!', '/'):
-        key = key_base + op
-        if key in target_dict:
-          tmp_dict[key] = target_dict[key]
-          del target_dict[key]
-    ProcessListFiltersInDict(target_name, tmp_dict)
-    # Write the results back to |target_dict|.
-    for key in tmp_dict:
-      target_dict[key] = tmp_dict[key]
-
-  # Make sure every dependency appears at most once.
-  RemoveDuplicateDependencies(targets)
-
-  if circular_check:
-    # Make sure that any targets in a.gyp don't contain dependencies in other
-    # .gyp files that further depend on a.gyp.
-    VerifyNoGYPFileCircularDependencies(targets)
-
-  [dependency_nodes, flat_list] = BuildDependencyList(targets)
-
-  if root_targets:
-    # Remove, from |targets| and |flat_list|, the targets that are not deep
-    # dependencies of the targets specified in |root_targets|.
-    targets, flat_list = PruneUnwantedTargets(
-        targets, flat_list, dependency_nodes, root_targets, data)
-
-  # Check that no two targets in the same directory have the same name.
-  VerifyNoCollidingTargets(flat_list)
-
-  # Handle dependent settings of various types.
-  for settings_type in ['all_dependent_settings',
-                        'direct_dependent_settings',
-                        'link_settings']:
-    DoDependentSettings(settings_type, flat_list, targets, dependency_nodes)
-
-    # Take out the dependent settings now that they've been published to all
-    # of the targets that require them.
+    # Set up path_sections and non_configuration_keys with the default data plus
+    # the generator-specific data.
+    global path_sections
+    path_sections = set(base_path_sections)
+    path_sections.update(generator_input_info["path_sections"])
+
+    global non_configuration_keys
+    non_configuration_keys = base_non_configuration_keys[:]
+    non_configuration_keys.extend(generator_input_info["non_configuration_keys"])
+
+    global multiple_toolsets
+    multiple_toolsets = generator_input_info["generator_supports_multiple_toolsets"]
+
+    global generator_filelist_paths
+    generator_filelist_paths = generator_input_info["generator_filelist_paths"]
+
+
+def Load(
+    build_files,
+    variables,
+    includes,
+    depth,
+    generator_input_info,
+    check,
+    circular_check,
+    parallel,
+    root_targets,
+):
+    SetGeneratorGlobals(generator_input_info)
+    # A generator can have other lists (in addition to sources) be processed
+    # for rules.
+    extra_sources_for_rules = generator_input_info["extra_sources_for_rules"]
+
+    # Load build files.  This loads every target-containing build file into
+    # the |data| dictionary such that the keys to |data| are build file names,
+    # and the values are the entire build file contents after "early" or "pre"
+    # processing has been done and includes have been resolved.
+    # NOTE: data contains both "target" files (.gyp) and "includes" (.gypi), as
+    # well as meta-data (e.g. 'included_files' key). 'target_build_files' keeps
+    # track of the keys corresponding to "target" files.
+    data = {"target_build_files": set()}
+    # Normalize paths everywhere.  This is important because paths will be
+    # used as keys to the data dict and for references between input files.
+    build_files = set(map(os.path.normpath, build_files))
+    if parallel:
+        LoadTargetBuildFilesParallel(
+            build_files, data, variables, includes, depth, check, generator_input_info
+        )
+    else:
+        aux_data = {}
+        for build_file in build_files:
+            try:
+                LoadTargetBuildFile(
+                    build_file, data, aux_data, variables, includes, depth, check, True
+                )
+            except Exception as e:
+                gyp.common.ExceptionAppend(e, "while trying to load %s" % build_file)
+                raise
+
+    # Build a dict to access each target's subdict by qualified name.
+    targets = BuildTargetsDict(data)
+
+    # Fully qualify all dependency links.
+    QualifyDependencies(targets)
+
+    # Remove self-dependencies from targets that have 'prune_self_dependencies'
+    # set to 1.
+    RemoveSelfDependencies(targets)
+
+    # Expand dependencies specified as build_file:*.
+    ExpandWildcardDependencies(targets, data)
+
+    # Remove all dependencies marked as 'link_dependency' from the targets of
+    # type 'none'.
+    RemoveLinkDependenciesFromNoneTargets(targets)
+
+    # Apply exclude (!) and regex (/) list filters only for dependency_sections.
+    for target_name, target_dict in targets.items():
+        tmp_dict = {}
+        for key_base in dependency_sections:
+            for op in ("", "!", "/"):
+                key = key_base + op
+                if key in target_dict:
+                    tmp_dict[key] = target_dict[key]
+                    del target_dict[key]
+        ProcessListFiltersInDict(target_name, tmp_dict)
+        # Write the results back to |target_dict|.
+        for key in tmp_dict:
+            target_dict[key] = tmp_dict[key]
+
+    # Make sure every dependency appears at most once.
+    RemoveDuplicateDependencies(targets)
+
+    if circular_check:
+        # Make sure that any targets in a.gyp don't contain dependencies in other
+        # .gyp files that further depend on a.gyp.
+        VerifyNoGYPFileCircularDependencies(targets)
+
+    [dependency_nodes, flat_list] = BuildDependencyList(targets)
+
+    if root_targets:
+        # Remove, from |targets| and |flat_list|, the targets that are not deep
+        # dependencies of the targets specified in |root_targets|.
+        targets, flat_list = PruneUnwantedTargets(
+            targets, flat_list, dependency_nodes, root_targets, data
+        )
+
+    # Check that no two targets in the same directory have the same name.
+    VerifyNoCollidingTargets(flat_list)
+
+    # Handle dependent settings of various types.
+    for settings_type in [
+        "all_dependent_settings",
+        "direct_dependent_settings",
+        "link_settings",
+    ]:
+        DoDependentSettings(settings_type, flat_list, targets, dependency_nodes)
+
+        # Take out the dependent settings now that they've been published to all
+        # of the targets that require them.
+        for target in flat_list:
+            if settings_type in targets[target]:
+                del targets[target][settings_type]
+
+    # Make sure static libraries don't declare dependencies on other static
+    # libraries, but that linkables depend on all unlinked static libraries
+    # that they need so that their link steps will be correct.
+    gii = generator_input_info
+    if gii["generator_wants_static_library_dependencies_adjusted"]:
+        AdjustStaticLibraryDependencies(
+            flat_list,
+            targets,
+            dependency_nodes,
+            gii["generator_wants_sorted_dependencies"],
+        )
+
+    # Apply "post"/"late"/"target" variable expansions and condition evaluations.
     for target in flat_list:
-      if settings_type in targets[target]:
-        del targets[target][settings_type]
-
-  # Make sure static libraries don't declare dependencies on other static
-  # libraries, but that linkables depend on all unlinked static libraries
-  # that they need so that their link steps will be correct.
-  gii = generator_input_info
-  if gii['generator_wants_static_library_dependencies_adjusted']:
-    AdjustStaticLibraryDependencies(flat_list, targets, dependency_nodes,
-                                    gii['generator_wants_sorted_dependencies'])
-
-  # Apply "post"/"late"/"target" variable expansions and condition evaluations.
-  for target in flat_list:
-    target_dict = targets[target]
-    build_file = gyp.common.BuildFile(target)
-    ProcessVariablesAndConditionsInDict(
-        target_dict, PHASE_LATE, variables, build_file)
+        target_dict = targets[target]
+        build_file = gyp.common.BuildFile(target)
+        ProcessVariablesAndConditionsInDict(
+            target_dict, PHASE_LATE, variables, build_file
+        )
 
-  # Move everything that can go into a "configurations" section into one.
-  for target in flat_list:
-    target_dict = targets[target]
-    SetUpConfigurations(target, target_dict)
+    # Move everything that can go into a "configurations" section into one.
+    for target in flat_list:
+        target_dict = targets[target]
+        SetUpConfigurations(target, target_dict)
 
-  # Apply exclude (!) and regex (/) list filters.
-  for target in flat_list:
-    target_dict = targets[target]
-    ProcessListFiltersInDict(target, target_dict)
+    # Apply exclude (!) and regex (/) list filters.
+    for target in flat_list:
+        target_dict = targets[target]
+        ProcessListFiltersInDict(target, target_dict)
 
-  # Apply "latelate" variable expansions and condition evaluations.
-  for target in flat_list:
-    target_dict = targets[target]
-    build_file = gyp.common.BuildFile(target)
-    ProcessVariablesAndConditionsInDict(
-        target_dict, PHASE_LATELATE, variables, build_file)
-
-  # Make sure that the rules make sense, and build up rule_sources lists as
-  # needed.  Not all generators will need to use the rule_sources lists, but
-  # some may, and it seems best to build the list in a common spot.
-  # Also validate actions and run_as elements in targets.
-  for target in flat_list:
-    target_dict = targets[target]
-    build_file = gyp.common.BuildFile(target)
-    ValidateTargetType(target, target_dict)
-    ValidateSourcesInTarget(target, target_dict, build_file,
-                            duplicate_basename_check)
-    ValidateRulesInTarget(target, target_dict, extra_sources_for_rules)
-    ValidateRunAsInTarget(target, target_dict, build_file)
-    ValidateActionsInTarget(target, target_dict, build_file)
-
-  # Generators might not expect ints.  Turn them into strs.
-  TurnIntIntoStrInDict(data)
-
-  # TODO(mark): Return |data| for now because the generator needs a list of
-  # build files that came in.  In the future, maybe it should just accept
-  # a list, and not the whole data dict.
-  return [flat_list, targets, data]
+    # Apply "latelate" variable expansions and condition evaluations.
+    for target in flat_list:
+        target_dict = targets[target]
+        build_file = gyp.common.BuildFile(target)
+        ProcessVariablesAndConditionsInDict(
+            target_dict, PHASE_LATELATE, variables, build_file
+        )
+
+    # Make sure that the rules make sense, and build up rule_sources lists as
+    # needed.  Not all generators will need to use the rule_sources lists, but
+    # some may, and it seems best to build the list in a common spot.
+    # Also validate actions and run_as elements in targets.
+    for target in flat_list:
+        target_dict = targets[target]
+        build_file = gyp.common.BuildFile(target)
+        ValidateTargetType(target, target_dict)
+        ValidateRulesInTarget(target, target_dict, extra_sources_for_rules)
+        ValidateRunAsInTarget(target, target_dict, build_file)
+        ValidateActionsInTarget(target, target_dict, build_file)
+
+    # Generators might not expect ints.  Turn them into strs.
+    TurnIntIntoStrInDict(data)
+
+    # TODO(mark): Return |data| for now because the generator needs a list of
+    # build files that came in.  In the future, maybe it should just accept
+    # a list, and not the whole data dict.
+    return [flat_list, targets, data]
diff --git a/tools/gyp/pylib/gyp/input_test.py b/tools/gyp/pylib/gyp/input_test.py
index 1bc5e3d3081ea6441561da535a87b2b117377b84..6672ddc014b1507a7cb61e42c7e65a36807be0e5 100755
--- a/tools/gyp/pylib/gyp/input_test.py
+++ b/tools/gyp/pylib/gyp/input_test.py
@@ -8,83 +8,91 @@
 
 import gyp.input
 import unittest
-import sys
 
 
 class TestFindCycles(unittest.TestCase):
-  def setUp(self):
-    self.nodes = {}
-    for x in ('a', 'b', 'c', 'd', 'e'):
-      self.nodes[x] = gyp.input.DependencyGraphNode(x)
-
-  def _create_dependency(self, dependent, dependency):
-    dependent.dependencies.append(dependency)
-    dependency.dependents.append(dependent)
-
-  def test_no_cycle_empty_graph(self):
-    for label, node in self.nodes.items():
-      self.assertEqual([], node.FindCycles())
-
-  def test_no_cycle_line(self):
-    self._create_dependency(self.nodes['a'], self.nodes['b'])
-    self._create_dependency(self.nodes['b'], self.nodes['c'])
-    self._create_dependency(self.nodes['c'], self.nodes['d'])
-
-    for label, node in self.nodes.items():
-      self.assertEqual([], node.FindCycles())
-
-  def test_no_cycle_dag(self):
-    self._create_dependency(self.nodes['a'], self.nodes['b'])
-    self._create_dependency(self.nodes['a'], self.nodes['c'])
-    self._create_dependency(self.nodes['b'], self.nodes['c'])
-
-    for label, node in self.nodes.items():
-      self.assertEqual([], node.FindCycles())
-
-  def test_cycle_self_reference(self):
-    self._create_dependency(self.nodes['a'], self.nodes['a'])
-
-    self.assertEqual([[self.nodes['a'], self.nodes['a']]],
-                      self.nodes['a'].FindCycles())
-
-  def test_cycle_two_nodes(self):
-    self._create_dependency(self.nodes['a'], self.nodes['b'])
-    self._create_dependency(self.nodes['b'], self.nodes['a'])
-
-    self.assertEqual([[self.nodes['a'], self.nodes['b'], self.nodes['a']]],
-                      self.nodes['a'].FindCycles())
-    self.assertEqual([[self.nodes['b'], self.nodes['a'], self.nodes['b']]],
-                      self.nodes['b'].FindCycles())
-
-  def test_two_cycles(self):
-    self._create_dependency(self.nodes['a'], self.nodes['b'])
-    self._create_dependency(self.nodes['b'], self.nodes['a'])
-
-    self._create_dependency(self.nodes['b'], self.nodes['c'])
-    self._create_dependency(self.nodes['c'], self.nodes['b'])
-
-    cycles = self.nodes['a'].FindCycles()
-    self.assertTrue(
-       [self.nodes['a'], self.nodes['b'], self.nodes['a']] in cycles)
-    self.assertTrue(
-       [self.nodes['b'], self.nodes['c'], self.nodes['b']] in cycles)
-    self.assertEqual(2, len(cycles))
-
-  def test_big_cycle(self):
-    self._create_dependency(self.nodes['a'], self.nodes['b'])
-    self._create_dependency(self.nodes['b'], self.nodes['c'])
-    self._create_dependency(self.nodes['c'], self.nodes['d'])
-    self._create_dependency(self.nodes['d'], self.nodes['e'])
-    self._create_dependency(self.nodes['e'], self.nodes['a'])
-
-    self.assertEqual([[self.nodes['a'],
-                        self.nodes['b'],
-                        self.nodes['c'],
-                        self.nodes['d'],
-                        self.nodes['e'],
-                        self.nodes['a']]],
-                      self.nodes['a'].FindCycles())
-
-
-if __name__ == '__main__':
-  unittest.main()
+    def setUp(self):
+        self.nodes = {}
+        for x in ("a", "b", "c", "d", "e"):
+            self.nodes[x] = gyp.input.DependencyGraphNode(x)
+
+    def _create_dependency(self, dependent, dependency):
+        dependent.dependencies.append(dependency)
+        dependency.dependents.append(dependent)
+
+    def test_no_cycle_empty_graph(self):
+        for label, node in self.nodes.items():
+            self.assertEqual([], node.FindCycles())
+
+    def test_no_cycle_line(self):
+        self._create_dependency(self.nodes["a"], self.nodes["b"])
+        self._create_dependency(self.nodes["b"], self.nodes["c"])
+        self._create_dependency(self.nodes["c"], self.nodes["d"])
+
+        for label, node in self.nodes.items():
+            self.assertEqual([], node.FindCycles())
+
+    def test_no_cycle_dag(self):
+        self._create_dependency(self.nodes["a"], self.nodes["b"])
+        self._create_dependency(self.nodes["a"], self.nodes["c"])
+        self._create_dependency(self.nodes["b"], self.nodes["c"])
+
+        for label, node in self.nodes.items():
+            self.assertEqual([], node.FindCycles())
+
+    def test_cycle_self_reference(self):
+        self._create_dependency(self.nodes["a"], self.nodes["a"])
+
+        self.assertEqual(
+            [[self.nodes["a"], self.nodes["a"]]], self.nodes["a"].FindCycles()
+        )
+
+    def test_cycle_two_nodes(self):
+        self._create_dependency(self.nodes["a"], self.nodes["b"])
+        self._create_dependency(self.nodes["b"], self.nodes["a"])
+
+        self.assertEqual(
+            [[self.nodes["a"], self.nodes["b"], self.nodes["a"]]],
+            self.nodes["a"].FindCycles(),
+        )
+        self.assertEqual(
+            [[self.nodes["b"], self.nodes["a"], self.nodes["b"]]],
+            self.nodes["b"].FindCycles(),
+        )
+
+    def test_two_cycles(self):
+        self._create_dependency(self.nodes["a"], self.nodes["b"])
+        self._create_dependency(self.nodes["b"], self.nodes["a"])
+
+        self._create_dependency(self.nodes["b"], self.nodes["c"])
+        self._create_dependency(self.nodes["c"], self.nodes["b"])
+
+        cycles = self.nodes["a"].FindCycles()
+        self.assertTrue([self.nodes["a"], self.nodes["b"], self.nodes["a"]] in cycles)
+        self.assertTrue([self.nodes["b"], self.nodes["c"], self.nodes["b"]] in cycles)
+        self.assertEqual(2, len(cycles))
+
+    def test_big_cycle(self):
+        self._create_dependency(self.nodes["a"], self.nodes["b"])
+        self._create_dependency(self.nodes["b"], self.nodes["c"])
+        self._create_dependency(self.nodes["c"], self.nodes["d"])
+        self._create_dependency(self.nodes["d"], self.nodes["e"])
+        self._create_dependency(self.nodes["e"], self.nodes["a"])
+
+        self.assertEqual(
+            [
+                [
+                    self.nodes["a"],
+                    self.nodes["b"],
+                    self.nodes["c"],
+                    self.nodes["d"],
+                    self.nodes["e"],
+                    self.nodes["a"],
+                ]
+            ],
+            self.nodes["a"].FindCycles(),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/gyp/pylib/gyp/mac_tool.py b/tools/gyp/pylib/gyp/mac_tool.py
index 781a8633bc2c7f80bef005ad5345d5c3ad252f75..07412578d19a2452618f784a799ddf4435c2f91b 100755
--- a/tools/gyp/pylib/gyp/mac_tool.py
+++ b/tools/gyp/pylib/gyp/mac_tool.py
@@ -18,7 +18,6 @@ import os
 import plistlib
 import re
 import shutil
-import string
 import struct
 import subprocess
 import sys
@@ -28,328 +27,345 @@ PY3 = bytes != str
 
 
 def main(args):
-  executor = MacTool()
-  exit_code = executor.Dispatch(args)
-  if exit_code is not None:
-    sys.exit(exit_code)
+    executor = MacTool()
+    exit_code = executor.Dispatch(args)
+    if exit_code is not None:
+        sys.exit(exit_code)
 
 
 class MacTool(object):
-  """This class performs all the Mac tooling steps. The methods can either be
+    """This class performs all the Mac tooling steps. The methods can either be
   executed directly, or dispatched from an argument list."""
 
-  def Dispatch(self, args):
-    """Dispatches a string command to a method."""
-    if len(args) < 1:
-      raise Exception("Not enough arguments")
+    def Dispatch(self, args):
+        """Dispatches a string command to a method."""
+        if len(args) < 1:
+            raise Exception("Not enough arguments")
 
-    method = "Exec%s" % self._CommandifyName(args[0])
-    return getattr(self, method)(*args[1:])
+        method = "Exec%s" % self._CommandifyName(args[0])
+        return getattr(self, method)(*args[1:])
 
-  def _CommandifyName(self, name_string):
-    """Transforms a tool name like copy-info-plist to CopyInfoPlist"""
-    return name_string.title().replace('-', '')
+    def _CommandifyName(self, name_string):
+        """Transforms a tool name like copy-info-plist to CopyInfoPlist"""
+        return name_string.title().replace("-", "")
 
-  def ExecCopyBundleResource(self, source, dest, convert_to_binary):
-    """Copies a resource file to the bundle/Resources directory, performing any
+    def ExecCopyBundleResource(self, source, dest, convert_to_binary):
+        """Copies a resource file to the bundle/Resources directory, performing any
     necessary compilation on each resource."""
-    convert_to_binary = convert_to_binary == 'True'
-    extension = os.path.splitext(source)[1].lower()
-    if os.path.isdir(source):
-      # Copy tree.
-      # TODO(thakis): This copies file attributes like mtime, while the
-      # single-file branch below doesn't. This should probably be changed to
-      # be consistent with the single-file branch.
-      if os.path.exists(dest):
-        shutil.rmtree(dest)
-      shutil.copytree(source, dest)
-    elif extension == '.xib':
-      return self._CopyXIBFile(source, dest)
-    elif extension == '.storyboard':
-      return self._CopyXIBFile(source, dest)
-    elif extension == '.strings' and not convert_to_binary:
-      self._CopyStringsFile(source, dest)
-    else:
-      if os.path.exists(dest):
-        os.unlink(dest)
-      shutil.copy(source, dest)
-
-    if convert_to_binary and extension in ('.plist', '.strings'):
-      self._ConvertToBinary(dest)
-
-  def _CopyXIBFile(self, source, dest):
-    """Compiles a XIB file with ibtool into a binary plist in the bundle."""
-
-    # ibtool sometimes crashes with relative paths. See crbug.com/314728.
-    base = os.path.dirname(os.path.realpath(__file__))
-    if os.path.relpath(source):
-      source = os.path.join(base, source)
-    if os.path.relpath(dest):
-      dest = os.path.join(base, dest)
-
-    args = ['xcrun', 'ibtool', '--errors', '--warnings', '--notices']
-
-    if os.environ['XCODE_VERSION_ACTUAL'] > '0700':
-      args.extend(['--auto-activate-custom-fonts'])
-      if 'IPHONEOS_DEPLOYMENT_TARGET' in os.environ:
-        args.extend([
-            '--target-device', 'iphone', '--target-device', 'ipad',
-            '--minimum-deployment-target',
-            os.environ['IPHONEOS_DEPLOYMENT_TARGET'],
-        ])
-      else:
-        args.extend([
-            '--target-device', 'mac',
-            '--minimum-deployment-target',
-            os.environ['MACOSX_DEPLOYMENT_TARGET'],
-        ])
-
-    args.extend(['--output-format', 'human-readable-text', '--compile', dest,
-        source])
-
-    ibtool_section_re = re.compile(r'/\*.*\*/')
-    ibtool_re = re.compile(r'.*note:.*is clipping its content')
-    try:
-      stdout = subprocess.check_output(args)
-    except subprocess.CalledProcessError as e:
-      print(e.output)
-      raise
-    current_section_header = None
-    for line in stdout.splitlines():
-      if ibtool_section_re.match(line):
-        current_section_header = line
-      elif not ibtool_re.match(line):
-        if current_section_header:
-          print(current_section_header)
-          current_section_header = None
-        print(line)
-    return 0
-
-  def _ConvertToBinary(self, dest):
-    subprocess.check_call([
-        'xcrun', 'plutil', '-convert', 'binary1', '-o', dest, dest])
-
-  def _CopyStringsFile(self, source, dest):
-    """Copies a .strings file using iconv to reconvert the input into UTF-16."""
-    input_code = self._DetectInputEncoding(source) or "UTF-8"
-
-    # Xcode's CpyCopyStringsFile / builtin-copyStrings seems to call
-    # CFPropertyListCreateFromXMLData() behind the scenes; at least it prints
-    #     CFPropertyListCreateFromXMLData(): Old-style plist parser: missing
-    #     semicolon in dictionary.
-    # on invalid files. Do the same kind of validation.
-    import CoreFoundation
-    with open(source, 'rb') as in_file:
-      s = in_file.read()
-    d = CoreFoundation.CFDataCreate(None, s, len(s))
-    _, error = CoreFoundation.CFPropertyListCreateFromXMLData(None, d, 0, None)
-    if error:
-      return
-
-    with open(dest, 'wb') as fp:
-      fp.write(s.decode(input_code).encode('UTF-16'))
-
-  def _DetectInputEncoding(self, file_name):
-    """Reads the first few bytes from file_name and tries to guess the text
+        convert_to_binary = convert_to_binary == "True"
+        extension = os.path.splitext(source)[1].lower()
+        if os.path.isdir(source):
+            # Copy tree.
+            # TODO(thakis): This copies file attributes like mtime, while the
+            # single-file branch below doesn't. This should probably be changed to
+            # be consistent with the single-file branch.
+            if os.path.exists(dest):
+                shutil.rmtree(dest)
+            shutil.copytree(source, dest)
+        elif extension == ".xib":
+            return self._CopyXIBFile(source, dest)
+        elif extension == ".storyboard":
+            return self._CopyXIBFile(source, dest)
+        elif extension == ".strings" and not convert_to_binary:
+            self._CopyStringsFile(source, dest)
+        else:
+            if os.path.exists(dest):
+                os.unlink(dest)
+            shutil.copy(source, dest)
+
+        if convert_to_binary and extension in (".plist", ".strings"):
+            self._ConvertToBinary(dest)
+
+    def _CopyXIBFile(self, source, dest):
+        """Compiles a XIB file with ibtool into a binary plist in the bundle."""
+
+        # ibtool sometimes crashes with relative paths. See crbug.com/314728.
+        base = os.path.dirname(os.path.realpath(__file__))
+        if os.path.relpath(source):
+            source = os.path.join(base, source)
+        if os.path.relpath(dest):
+            dest = os.path.join(base, dest)
+
+        args = ["xcrun", "ibtool", "--errors", "--warnings", "--notices"]
+
+        if os.environ["XCODE_VERSION_ACTUAL"] > "0700":
+            args.extend(["--auto-activate-custom-fonts"])
+            if "IPHONEOS_DEPLOYMENT_TARGET" in os.environ:
+                args.extend(
+                    [
+                        "--target-device",
+                        "iphone",
+                        "--target-device",
+                        "ipad",
+                        "--minimum-deployment-target",
+                        os.environ["IPHONEOS_DEPLOYMENT_TARGET"],
+                    ]
+                )
+            else:
+                args.extend(
+                    [
+                        "--target-device",
+                        "mac",
+                        "--minimum-deployment-target",
+                        os.environ["MACOSX_DEPLOYMENT_TARGET"],
+                    ]
+                )
+
+        args.extend(
+            ["--output-format", "human-readable-text", "--compile", dest, source]
+        )
+
+        ibtool_section_re = re.compile(r"/\*.*\*/")
+        ibtool_re = re.compile(r".*note:.*is clipping its content")
+        try:
+            stdout = subprocess.check_output(args)
+        except subprocess.CalledProcessError as e:
+            print(e.output)
+            raise
+        current_section_header = None
+        for line in stdout.splitlines():
+            if ibtool_section_re.match(line):
+                current_section_header = line
+            elif not ibtool_re.match(line):
+                if current_section_header:
+                    print(current_section_header)
+                    current_section_header = None
+                print(line)
+        return 0
+
+    def _ConvertToBinary(self, dest):
+        subprocess.check_call(
+            ["xcrun", "plutil", "-convert", "binary1", "-o", dest, dest]
+        )
+
+    def _CopyStringsFile(self, source, dest):
+        """Copies a .strings file using iconv to reconvert the input into UTF-16."""
+        input_code = self._DetectInputEncoding(source) or "UTF-8"
+
+        # Xcode's CpyCopyStringsFile / builtin-copyStrings seems to call
+        # CFPropertyListCreateFromXMLData() behind the scenes; at least it prints
+        #     CFPropertyListCreateFromXMLData(): Old-style plist parser: missing
+        #     semicolon in dictionary.
+        # on invalid files. Do the same kind of validation.
+        import CoreFoundation
+
+        with open(source, "rb") as in_file:
+            s = in_file.read()
+        d = CoreFoundation.CFDataCreate(None, s, len(s))
+        _, error = CoreFoundation.CFPropertyListCreateFromXMLData(None, d, 0, None)
+        if error:
+            return
+
+        with open(dest, "wb") as fp:
+            fp.write(s.decode(input_code).encode("UTF-16"))
+
+    def _DetectInputEncoding(self, file_name):
+        """Reads the first few bytes from file_name and tries to guess the text
     encoding. Returns None as a guess if it can't detect it."""
-    with open(file_name, 'rb') as fp:
-      try:
-        header = fp.read(3)
-      except Exception:
-        return None
-    if header.startswith(("\xFE\xFF", "\xFF\xFE")):
-      return "UTF-16"
-    elif header.startswith("\xEF\xBB\xBF"):
-      return "UTF-8"
-    else:
-      return None
-
-  def ExecCopyInfoPlist(self, source, dest, convert_to_binary, *keys):
-    """Copies the |source| Info.plist to the destination directory |dest|."""
-    # Read the source Info.plist into memory.
-    with open(source, 'r') as fd:
-      lines = fd.read()
-
-    # Insert synthesized key/value pairs (e.g. BuildMachineOSBuild).
-    plist = plistlib.readPlistFromString(lines)
-    if keys:
-      plist = dict(plist.items() + json.loads(keys[0]).items())
-    lines = plistlib.writePlistToString(plist)
-
-    # Go through all the environment variables and replace them as variables in
-    # the file.
-    IDENT_RE = re.compile(r'[_/\s]')
-    for key in os.environ:
-      if key.startswith('_'):
-        continue
-      evar = '${%s}' % key
-      evalue = os.environ[key]
-      lines = string.replace(lines, evar, evalue)
-
-      # Xcode supports various suffices on environment variables, which are
-      # all undocumented. :rfc1034identifier is used in the standard project
-      # template these days, and :identifier was used earlier. They are used to
-      # convert non-url characters into things that look like valid urls --
-      # except that the replacement character for :identifier, '_' isn't valid
-      # in a URL either -- oops, hence :rfc1034identifier was born.
-      evar = '${%s:identifier}' % key
-      evalue = IDENT_RE.sub('_', os.environ[key])
-      lines = string.replace(lines, evar, evalue)
-
-      evar = '${%s:rfc1034identifier}' % key
-      evalue = IDENT_RE.sub('-', os.environ[key])
-      lines = string.replace(lines, evar, evalue)
-
-    # Remove any keys with values that haven't been replaced.
-    lines = lines.splitlines()
-    for i in range(len(lines)):
-      if lines[i].strip().startswith("<string>${"):
-        lines[i] = None
-        lines[i - 1] = None
-    lines = '\n'.join(line for line in lines if line is not None)
-
-    # Write out the file with variables replaced.
-    with open(dest, 'w') as fd:
-      fd.write(lines)
-
-    # Now write out PkgInfo file now that the Info.plist file has been
-    # "compiled".
-    self._WritePkgInfo(dest)
-
-    if convert_to_binary == 'True':
-      self._ConvertToBinary(dest)
-
-  def _WritePkgInfo(self, info_plist):
-    """This writes the PkgInfo file from the data stored in Info.plist."""
-    plist = plistlib.readPlist(info_plist)
-    if not plist:
-      return
-
-    # Only create PkgInfo for executable types.
-    package_type = plist['CFBundlePackageType']
-    if package_type != 'APPL':
-      return
-
-    # The format of PkgInfo is eight characters, representing the bundle type
-    # and bundle signature, each four characters. If that is missing, four
-    # '?' characters are used instead.
-    signature_code = plist.get('CFBundleSignature', '????')
-    if len(signature_code) != 4:  # Wrong length resets everything, too.
-      signature_code = '?' * 4
-
-    dest = os.path.join(os.path.dirname(info_plist), 'PkgInfo')
-    with open(dest, 'w') as fp:
-      fp.write('%s%s' % (package_type, signature_code))
-
-  def ExecFlock(self, lockfile, *cmd_list):
-    """Emulates the most basic behavior of Linux's flock(1)."""
-    # Rely on exception handling to report errors.
-    fd = os.open(lockfile, os.O_RDONLY|os.O_NOCTTY|os.O_CREAT, 0o666)
-    fcntl.flock(fd, fcntl.LOCK_EX)
-    return subprocess.call(cmd_list)
-
-  def ExecFilterLibtool(self, *cmd_list):
-    """Calls libtool and filters out '/path/to/libtool: file: foo.o has no
+        with open(file_name, "rb") as fp:
+            try:
+                header = fp.read(3)
+            except Exception:
+                return None
+        if header.startswith(b"\xFE\xFF"):
+            return "UTF-16"
+        elif header.startswith(b"\xFF\xFE"):
+            return "UTF-16"
+        elif header.startswith(b"\xEF\xBB\xBF"):
+            return "UTF-8"
+        else:
+            return None
+
+    def ExecCopyInfoPlist(self, source, dest, convert_to_binary, *keys):
+        """Copies the |source| Info.plist to the destination directory |dest|."""
+        # Read the source Info.plist into memory.
+        with open(source, "r") as fd:
+            lines = fd.read()
+
+        # Insert synthesized key/value pairs (e.g. BuildMachineOSBuild).
+        plist = plistlib.readPlistFromString(lines)
+        if keys:
+            plist.update(json.loads(keys[0]))
+        lines = plistlib.writePlistToString(plist)
+
+        # Go through all the environment variables and replace them as variables in
+        # the file.
+        IDENT_RE = re.compile(r"[_/\s]")
+        for key in os.environ:
+            if key.startswith("_"):
+                continue
+            evar = "${%s}" % key
+            evalue = os.environ[key]
+            lines = lines.replace(lines, evar, evalue)
+
+            # Xcode supports various suffices on environment variables, which are
+            # all undocumented. :rfc1034identifier is used in the standard project
+            # template these days, and :identifier was used earlier. They are used to
+            # convert non-url characters into things that look like valid urls --
+            # except that the replacement character for :identifier, '_' isn't valid
+            # in a URL either -- oops, hence :rfc1034identifier was born.
+            evar = "${%s:identifier}" % key
+            evalue = IDENT_RE.sub("_", os.environ[key])
+            lines = lines.replace(lines, evar, evalue)
+
+            evar = "${%s:rfc1034identifier}" % key
+            evalue = IDENT_RE.sub("-", os.environ[key])
+            lines = lines.replace(lines, evar, evalue)
+
+        # Remove any keys with values that haven't been replaced.
+        lines = lines.splitlines()
+        for i in range(len(lines)):
+            if lines[i].strip().startswith("<string>${"):
+                lines[i] = None
+                lines[i - 1] = None
+        lines = "\n".join(line for line in lines if line is not None)
+
+        # Write out the file with variables replaced.
+        with open(dest, "w") as fd:
+            fd.write(lines)
+
+        # Now write out PkgInfo file now that the Info.plist file has been
+        # "compiled".
+        self._WritePkgInfo(dest)
+
+        if convert_to_binary == "True":
+            self._ConvertToBinary(dest)
+
+    def _WritePkgInfo(self, info_plist):
+        """This writes the PkgInfo file from the data stored in Info.plist."""
+        plist = plistlib.readPlist(info_plist)
+        if not plist:
+            return
+
+        # Only create PkgInfo for executable types.
+        package_type = plist["CFBundlePackageType"]
+        if package_type != "APPL":
+            return
+
+        # The format of PkgInfo is eight characters, representing the bundle type
+        # and bundle signature, each four characters. If that is missing, four
+        # '?' characters are used instead.
+        signature_code = plist.get("CFBundleSignature", "????")
+        if len(signature_code) != 4:  # Wrong length resets everything, too.
+            signature_code = "?" * 4
+
+        dest = os.path.join(os.path.dirname(info_plist), "PkgInfo")
+        with open(dest, "w") as fp:
+            fp.write("%s%s" % (package_type, signature_code))
+
+    def ExecFlock(self, lockfile, *cmd_list):
+        """Emulates the most basic behavior of Linux's flock(1)."""
+        # Rely on exception handling to report errors.
+        fd = os.open(lockfile, os.O_RDONLY | os.O_NOCTTY | os.O_CREAT, 0o666)
+        fcntl.flock(fd, fcntl.LOCK_EX)
+        return subprocess.call(cmd_list)
+
+    def ExecFilterLibtool(self, *cmd_list):
+        """Calls libtool and filters out '/path/to/libtool: file: foo.o has no
     symbols'."""
-    libtool_re = re.compile(r'^.*libtool: (?:for architecture: \S* )?'
-                            r'file: .* has no symbols$')
-    libtool_re5 = re.compile(
-        r'^.*libtool: warning for library: ' +
-        r'.* the table of contents is empty ' +
-        r'\(no object file members in the library define global symbols\)$')
-    env = os.environ.copy()
-    # Ref:
-    # http://www.opensource.apple.com/source/cctools/cctools-809/misc/libtool.c
-    # The problem with this flag is that it resets the file mtime on the file to
-    # epoch=0, e.g. 1970-1-1 or 1969-12-31 depending on timezone.
-    env['ZERO_AR_DATE'] = '1'
-    libtoolout = subprocess.Popen(cmd_list, stderr=subprocess.PIPE, env=env)
-    _, err = libtoolout.communicate()
-    if PY3:
-      err = err.decode('utf-8')
-    for line in err.splitlines():
-      if not libtool_re.match(line) and not libtool_re5.match(line):
-        print(line, file=sys.stderr)
-    # Unconditionally touch the output .a file on the command line if present
-    # and the command succeeded. A bit hacky.
-    if not libtoolout.returncode:
-      for i in range(len(cmd_list) - 1):
-        if cmd_list[i] == "-o" and cmd_list[i+1].endswith('.a'):
-          os.utime(cmd_list[i+1], None)
-          break
-    return libtoolout.returncode
-
-  def ExecPackageIosFramework(self, framework):
-    # Find the name of the binary based on the part before the ".framework".
-    binary = os.path.basename(framework).split('.')[0]
-    module_path = os.path.join(framework, 'Modules')
-    if not os.path.exists(module_path):
-      os.mkdir(module_path)
-    module_template = 'framework module %s {\n' \
-                      '  umbrella header "%s.h"\n' \
-                      '\n' \
-                      '  export *\n' \
-                      '  module * { export * }\n' \
-                      '}\n' % (binary, binary)
-
-    with open(os.path.join(module_path, 'module.modulemap'), "w") as module_file:
-      module_file.write(module_template)
-
-  def ExecPackageFramework(self, framework, version):
-    """Takes a path to Something.framework and the Current version of that and
+        libtool_re = re.compile(
+            r"^.*libtool: (?:for architecture: \S* )?" r"file: .* has no symbols$"
+        )
+        libtool_re5 = re.compile(
+            r"^.*libtool: warning for library: "
+            + r".* the table of contents is empty "
+            + r"\(no object file members in the library define global symbols\)$"
+        )
+        env = os.environ.copy()
+        # Ref:
+        # http://www.opensource.apple.com/source/cctools/cctools-809/misc/libtool.c
+        # The problem with this flag is that it resets the file mtime on the file to
+        # epoch=0, e.g. 1970-1-1 or 1969-12-31 depending on timezone.
+        env["ZERO_AR_DATE"] = "1"
+        libtoolout = subprocess.Popen(cmd_list, stderr=subprocess.PIPE, env=env)
+        _, err = libtoolout.communicate()
+        if PY3:
+            err = err.decode("utf-8")
+        for line in err.splitlines():
+            if not libtool_re.match(line) and not libtool_re5.match(line):
+                print(line, file=sys.stderr)
+        # Unconditionally touch the output .a file on the command line if present
+        # and the command succeeded. A bit hacky.
+        if not libtoolout.returncode:
+            for i in range(len(cmd_list) - 1):
+                if cmd_list[i] == "-o" and cmd_list[i + 1].endswith(".a"):
+                    os.utime(cmd_list[i + 1], None)
+                    break
+        return libtoolout.returncode
+
+    def ExecPackageIosFramework(self, framework):
+        # Find the name of the binary based on the part before the ".framework".
+        binary = os.path.basename(framework).split(".")[0]
+        module_path = os.path.join(framework, "Modules")
+        if not os.path.exists(module_path):
+            os.mkdir(module_path)
+        module_template = (
+            "framework module %s {\n"
+            '  umbrella header "%s.h"\n'
+            "\n"
+            "  export *\n"
+            "  module * { export * }\n"
+            "}\n" % (binary, binary)
+        )
+
+        with open(os.path.join(module_path, "module.modulemap"), "w") as module_file:
+            module_file.write(module_template)
+
+    def ExecPackageFramework(self, framework, version):
+        """Takes a path to Something.framework and the Current version of that and
     sets up all the symlinks."""
-    # Find the name of the binary based on the part before the ".framework".
-    binary = os.path.basename(framework).split('.')[0]
+        # Find the name of the binary based on the part before the ".framework".
+        binary = os.path.basename(framework).split(".")[0]
 
-    CURRENT = 'Current'
-    RESOURCES = 'Resources'
-    VERSIONS = 'Versions'
+        CURRENT = "Current"
+        RESOURCES = "Resources"
+        VERSIONS = "Versions"
 
-    if not os.path.exists(os.path.join(framework, VERSIONS, version, binary)):
-      # Binary-less frameworks don't seem to contain symlinks (see e.g.
-      # chromium's out/Debug/org.chromium.Chromium.manifest/ bundle).
-      return
+        if not os.path.exists(os.path.join(framework, VERSIONS, version, binary)):
+            # Binary-less frameworks don't seem to contain symlinks (see e.g.
+            # chromium's out/Debug/org.chromium.Chromium.manifest/ bundle).
+            return
 
-    # Move into the framework directory to set the symlinks correctly.
-    pwd = os.getcwd()
-    os.chdir(framework)
+        # Move into the framework directory to set the symlinks correctly.
+        pwd = os.getcwd()
+        os.chdir(framework)
 
-    # Set up the Current version.
-    self._Relink(version, os.path.join(VERSIONS, CURRENT))
+        # Set up the Current version.
+        self._Relink(version, os.path.join(VERSIONS, CURRENT))
 
-    # Set up the root symlinks.
-    self._Relink(os.path.join(VERSIONS, CURRENT, binary), binary)
-    self._Relink(os.path.join(VERSIONS, CURRENT, RESOURCES), RESOURCES)
+        # Set up the root symlinks.
+        self._Relink(os.path.join(VERSIONS, CURRENT, binary), binary)
+        self._Relink(os.path.join(VERSIONS, CURRENT, RESOURCES), RESOURCES)
 
-    # Back to where we were before!
-    os.chdir(pwd)
+        # Back to where we were before!
+        os.chdir(pwd)
 
-  def _Relink(self, dest, link):
-    """Creates a symlink to |dest| named |link|. If |link| already exists,
+    def _Relink(self, dest, link):
+        """Creates a symlink to |dest| named |link|. If |link| already exists,
     it is overwritten."""
-    if os.path.lexists(link):
-      os.remove(link)
-    os.symlink(dest, link)
-
-  def ExecCompileIosFrameworkHeaderMap(self, out, framework, *all_headers):
-    framework_name = os.path.basename(framework).split('.')[0]
-    all_headers = [os.path.abspath(header) for header in all_headers]
-    filelist = {}
-    for header in all_headers:
-      filename = os.path.basename(header)
-      filelist[filename] = header
-      filelist[os.path.join(framework_name, filename)] = header
-    WriteHmap(out, filelist)
-
-  def ExecCopyIosFrameworkHeaders(self, framework, *copy_headers):
-    header_path = os.path.join(framework, 'Headers')
-    if not os.path.exists(header_path):
-      os.makedirs(header_path)
-    for header in copy_headers:
-      shutil.copy(header, os.path.join(header_path, os.path.basename(header)))
-
-  def ExecCompileXcassets(self, keys, *inputs):
-    """Compiles multiple .xcassets files into a single .car file.
+        if os.path.lexists(link):
+            os.remove(link)
+        os.symlink(dest, link)
+
+    def ExecCompileIosFrameworkHeaderMap(self, out, framework, *all_headers):
+        framework_name = os.path.basename(framework).split(".")[0]
+        all_headers = [os.path.abspath(header) for header in all_headers]
+        filelist = {}
+        for header in all_headers:
+            filename = os.path.basename(header)
+            filelist[filename] = header
+            filelist[os.path.join(framework_name, filename)] = header
+        WriteHmap(out, filelist)
+
+    def ExecCopyIosFrameworkHeaders(self, framework, *copy_headers):
+        header_path = os.path.join(framework, "Headers")
+        if not os.path.exists(header_path):
+            os.makedirs(header_path)
+        for header in copy_headers:
+            shutil.copy(header, os.path.join(header_path, os.path.basename(header)))
+
+    def ExecCompileXcassets(self, keys, *inputs):
+        """Compiles multiple .xcassets files into a single .car file.
 
     This invokes 'actool' to compile all the inputs .xcassets files. The
     |keys| arguments is a json-encoded dictionary of extra arguments to
@@ -359,57 +375,77 @@ class MacTool(object):
     Note that 'actool' does not create the Assets.car file if the asset
     catalogs does not contains imageset.
     """
-    command_line = [
-      'xcrun', 'actool', '--output-format', 'human-readable-text',
-      '--compress-pngs', '--notices', '--warnings', '--errors',
-    ]
-    is_iphone_target = 'IPHONEOS_DEPLOYMENT_TARGET' in os.environ
-    if is_iphone_target:
-      platform = os.environ['CONFIGURATION'].split('-')[-1]
-      if platform not in ('iphoneos', 'iphonesimulator'):
-        platform = 'iphonesimulator'
-      command_line.extend([
-          '--platform', platform, '--target-device', 'iphone',
-          '--target-device', 'ipad', '--minimum-deployment-target',
-          os.environ['IPHONEOS_DEPLOYMENT_TARGET'], '--compile',
-          os.path.abspath(os.environ['CONTENTS_FOLDER_PATH']),
-      ])
-    else:
-      command_line.extend([
-          '--platform', 'macosx', '--target-device', 'mac',
-          '--minimum-deployment-target', os.environ['MACOSX_DEPLOYMENT_TARGET'],
-          '--compile',
-          os.path.abspath(os.environ['UNLOCALIZED_RESOURCES_FOLDER_PATH']),
-      ])
-    if keys:
-      keys = json.loads(keys)
-      for key, value in keys.items():
-        arg_name = '--' + key
-        if isinstance(value, bool):
-          if value:
-            command_line.append(arg_name)
-        elif isinstance(value, list):
-          for v in value:
-            command_line.append(arg_name)
-            command_line.append(str(v))
+        command_line = [
+            "xcrun",
+            "actool",
+            "--output-format",
+            "human-readable-text",
+            "--compress-pngs",
+            "--notices",
+            "--warnings",
+            "--errors",
+        ]
+        is_iphone_target = "IPHONEOS_DEPLOYMENT_TARGET" in os.environ
+        if is_iphone_target:
+            platform = os.environ["CONFIGURATION"].split("-")[-1]
+            if platform not in ("iphoneos", "iphonesimulator"):
+                platform = "iphonesimulator"
+            command_line.extend(
+                [
+                    "--platform",
+                    platform,
+                    "--target-device",
+                    "iphone",
+                    "--target-device",
+                    "ipad",
+                    "--minimum-deployment-target",
+                    os.environ["IPHONEOS_DEPLOYMENT_TARGET"],
+                    "--compile",
+                    os.path.abspath(os.environ["CONTENTS_FOLDER_PATH"]),
+                ]
+            )
         else:
-          command_line.append(arg_name)
-          command_line.append(str(value))
-    # Note: actool crashes if inputs path are relative, so use os.path.abspath
-    # to get absolute path name for inputs.
-    command_line.extend(map(os.path.abspath, inputs))
-    subprocess.check_call(command_line)
-
-  def ExecMergeInfoPlist(self, output, *inputs):
-    """Merge multiple .plist files into a single .plist file."""
-    merged_plist = {}
-    for path in inputs:
-      plist = self._LoadPlistMaybeBinary(path)
-      self._MergePlist(merged_plist, plist)
-    plistlib.writePlist(merged_plist, output)
-
-  def ExecCodeSignBundle(self, key, entitlements, provisioning, path, preserve):
-    """Code sign a bundle.
+            command_line.extend(
+                [
+                    "--platform",
+                    "macosx",
+                    "--target-device",
+                    "mac",
+                    "--minimum-deployment-target",
+                    os.environ["MACOSX_DEPLOYMENT_TARGET"],
+                    "--compile",
+                    os.path.abspath(os.environ["UNLOCALIZED_RESOURCES_FOLDER_PATH"]),
+                ]
+            )
+        if keys:
+            keys = json.loads(keys)
+            for key, value in keys.items():
+                arg_name = "--" + key
+                if isinstance(value, bool):
+                    if value:
+                        command_line.append(arg_name)
+                elif isinstance(value, list):
+                    for v in value:
+                        command_line.append(arg_name)
+                        command_line.append(str(v))
+                else:
+                    command_line.append(arg_name)
+                    command_line.append(str(value))
+        # Note: actool crashes if inputs path are relative, so use os.path.abspath
+        # to get absolute path name for inputs.
+        command_line.extend(map(os.path.abspath, inputs))
+        subprocess.check_call(command_line)
+
+    def ExecMergeInfoPlist(self, output, *inputs):
+        """Merge multiple .plist files into a single .plist file."""
+        merged_plist = {}
+        for path in inputs:
+            plist = self._LoadPlistMaybeBinary(path)
+            self._MergePlist(merged_plist, plist)
+        plistlib.writePlist(merged_plist, output)
+
+    def ExecCodeSignBundle(self, key, entitlements, provisioning, path, preserve):
+        """Code sign a bundle.
 
     This function tries to code sign an iOS bundle, following the same
     algorithm as Xcode:
@@ -418,21 +454,23 @@ class MacTool(object):
       2. copy Entitlements.plist from user or SDK next to the bundle,
       3. code sign the bundle.
     """
-    substitutions, overrides = self._InstallProvisioningProfile(
-        provisioning, self._GetCFBundleIdentifier())
-    entitlements_path = self._InstallEntitlements(
-        entitlements, substitutions, overrides)
-
-    args = ['codesign', '--force', '--sign', key]
-    if preserve == 'True':
-      args.extend(['--deep', '--preserve-metadata=identifier,entitlements'])
-    else:
-      args.extend(['--entitlements', entitlements_path])
-    args.extend(['--timestamp=none', path])
-    subprocess.check_call(args)
-
-  def _InstallProvisioningProfile(self, profile, bundle_identifier):
-    """Installs embedded.mobileprovision into the bundle.
+        substitutions, overrides = self._InstallProvisioningProfile(
+            provisioning, self._GetCFBundleIdentifier()
+        )
+        entitlements_path = self._InstallEntitlements(
+            entitlements, substitutions, overrides
+        )
+
+        args = ["codesign", "--force", "--sign", key]
+        if preserve == "True":
+            args.extend(["--deep", "--preserve-metadata=identifier,entitlements"])
+        else:
+            args.extend(["--entitlements", entitlements_path])
+        args.extend(["--timestamp=none", path])
+        subprocess.check_call(args)
+
+    def _InstallProvisioningProfile(self, profile, bundle_identifier):
+        """Installs embedded.mobileprovision into the bundle.
 
     Args:
       profile: string, optional, short name of the .mobileprovision file
@@ -444,18 +482,20 @@ class MacTool(object):
       A tuple containing two dictionary: variables substitutions and values
       to overrides when generating the entitlements file.
     """
-    source_path, provisioning_data, team_id = self._FindProvisioningProfile(
-        profile, bundle_identifier)
-    target_path = os.path.join(
-        os.environ['BUILT_PRODUCTS_DIR'],
-        os.environ['CONTENTS_FOLDER_PATH'],
-        'embedded.mobileprovision')
-    shutil.copy2(source_path, target_path)
-    substitutions = self._GetSubstitutions(bundle_identifier, team_id + '.')
-    return substitutions, provisioning_data['Entitlements']
-
-  def _FindProvisioningProfile(self, profile, bundle_identifier):
-    """Finds the .mobileprovision file to use for signing the bundle.
+        source_path, provisioning_data, team_id = self._FindProvisioningProfile(
+            profile, bundle_identifier
+        )
+        target_path = os.path.join(
+            os.environ["BUILT_PRODUCTS_DIR"],
+            os.environ["CONTENTS_FOLDER_PATH"],
+            "embedded.mobileprovision",
+        )
+        shutil.copy2(source_path, target_path)
+        substitutions = self._GetSubstitutions(bundle_identifier, team_id + ".")
+        return substitutions, provisioning_data["Entitlements"]
+
+    def _FindProvisioningProfile(self, profile, bundle_identifier):
+        """Finds the .mobileprovision file to use for signing the bundle.
 
     Checks all the installed provisioning profiles (or if the user specified
     the PROVISIONING_PROFILE variable, only consult it) and select the most
@@ -475,40 +515,52 @@ class MacTool(object):
     Raises:
       SystemExit: if no .mobileprovision can be used to sign the bundle.
     """
-    profiles_dir = os.path.join(
-        os.environ['HOME'], 'Library', 'MobileDevice', 'Provisioning Profiles')
-    if not os.path.isdir(profiles_dir):
-      print('cannot find mobile provisioning for %s' % (bundle_identifier), file=sys.stderr)
-      sys.exit(1)
-    provisioning_profiles = None
-    if profile:
-      profile_path = os.path.join(profiles_dir, profile + '.mobileprovision')
-      if os.path.exists(profile_path):
-        provisioning_profiles = [profile_path]
-    if not provisioning_profiles:
-      provisioning_profiles = glob.glob(
-          os.path.join(profiles_dir, '*.mobileprovision'))
-    valid_provisioning_profiles = {}
-    for profile_path in provisioning_profiles:
-      profile_data = self._LoadProvisioningProfile(profile_path)
-      app_id_pattern = profile_data.get(
-          'Entitlements', {}).get('application-identifier', '')
-      for team_identifier in profile_data.get('TeamIdentifier', []):
-        app_id = '%s.%s' % (team_identifier, bundle_identifier)
-        if fnmatch.fnmatch(app_id, app_id_pattern):
-          valid_provisioning_profiles[app_id_pattern] = (
-              profile_path, profile_data, team_identifier)
-    if not valid_provisioning_profiles:
-      print('cannot find mobile provisioning for %s' % (bundle_identifier), file=sys.stderr)
-      sys.exit(1)
-    # If the user has multiple provisioning profiles installed that can be
-    # used for ${bundle_identifier}, pick the most specific one (ie. the
-    # provisioning profile whose pattern is the longest).
-    selected_key = max(valid_provisioning_profiles, key=lambda v: len(v))
-    return valid_provisioning_profiles[selected_key]
-
-  def _LoadProvisioningProfile(self, profile_path):
-    """Extracts the plist embedded in a provisioning profile.
+        profiles_dir = os.path.join(
+            os.environ["HOME"], "Library", "MobileDevice", "Provisioning Profiles"
+        )
+        if not os.path.isdir(profiles_dir):
+            print(
+                "cannot find mobile provisioning for %s" % (bundle_identifier),
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        provisioning_profiles = None
+        if profile:
+            profile_path = os.path.join(profiles_dir, profile + ".mobileprovision")
+            if os.path.exists(profile_path):
+                provisioning_profiles = [profile_path]
+        if not provisioning_profiles:
+            provisioning_profiles = glob.glob(
+                os.path.join(profiles_dir, "*.mobileprovision")
+            )
+        valid_provisioning_profiles = {}
+        for profile_path in provisioning_profiles:
+            profile_data = self._LoadProvisioningProfile(profile_path)
+            app_id_pattern = profile_data.get("Entitlements", {}).get(
+                "application-identifier", ""
+            )
+            for team_identifier in profile_data.get("TeamIdentifier", []):
+                app_id = "%s.%s" % (team_identifier, bundle_identifier)
+                if fnmatch.fnmatch(app_id, app_id_pattern):
+                    valid_provisioning_profiles[app_id_pattern] = (
+                        profile_path,
+                        profile_data,
+                        team_identifier,
+                    )
+        if not valid_provisioning_profiles:
+            print(
+                "cannot find mobile provisioning for %s" % (bundle_identifier),
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        # If the user has multiple provisioning profiles installed that can be
+        # used for ${bundle_identifier}, pick the most specific one (ie. the
+        # provisioning profile whose pattern is the longest).
+        selected_key = max(valid_provisioning_profiles, key=lambda v: len(v))
+        return valid_provisioning_profiles[selected_key]
+
+    def _LoadProvisioningProfile(self, profile_path):
+        """Extracts the plist embedded in a provisioning profile.
 
     Args:
       profile_path: string, path to the .mobileprovision file
@@ -516,26 +568,27 @@ class MacTool(object):
     Returns:
       Content of the plist embedded in the provisioning profile as a dictionary.
     """
-    with tempfile.NamedTemporaryFile() as temp:
-      subprocess.check_call([
-          'security', 'cms', '-D', '-i', profile_path, '-o', temp.name])
-      return self._LoadPlistMaybeBinary(temp.name)
-
-  def _MergePlist(self, merged_plist, plist):
-    """Merge |plist| into |merged_plist|."""
-    for key, value in plist.items():
-      if isinstance(value, dict):
-        merged_value = merged_plist.get(key, {})
-        if isinstance(merged_value, dict):
-          self._MergePlist(merged_value, value)
-          merged_plist[key] = merged_value
-        else:
-          merged_plist[key] = value
-      else:
-        merged_plist[key] = value
-
-  def _LoadPlistMaybeBinary(self, plist_path):
-    """Loads into a memory a plist possibly encoded in binary format.
+        with tempfile.NamedTemporaryFile() as temp:
+            subprocess.check_call(
+                ["security", "cms", "-D", "-i", profile_path, "-o", temp.name]
+            )
+            return self._LoadPlistMaybeBinary(temp.name)
+
+    def _MergePlist(self, merged_plist, plist):
+        """Merge |plist| into |merged_plist|."""
+        for key, value in plist.items():
+            if isinstance(value, dict):
+                merged_value = merged_plist.get(key, {})
+                if isinstance(merged_value, dict):
+                    self._MergePlist(merged_value, value)
+                    merged_plist[key] = merged_value
+                else:
+                    merged_plist[key] = value
+            else:
+                merged_plist[key] = value
+
+    def _LoadPlistMaybeBinary(self, plist_path):
+        """Loads into a memory a plist possibly encoded in binary format.
 
     This is a wrapper around plistlib.readPlist that tries to convert the
     plist to the XML format if it can't be parsed (assuming that it is in
@@ -547,20 +600,20 @@ class MacTool(object):
     Returns:
       Content of the plist as a dictionary.
     """
-    try:
-      # First, try to read the file using plistlib that only supports XML,
-      # and if an exception is raised, convert a temporary copy to XML and
-      # load that copy.
-      return plistlib.readPlist(plist_path)
-    except:
-      pass
-    with tempfile.NamedTemporaryFile() as temp:
-      shutil.copy2(plist_path, temp.name)
-      subprocess.check_call(['plutil', '-convert', 'xml1', temp.name])
-      return plistlib.readPlist(temp.name)
-
-  def _GetSubstitutions(self, bundle_identifier, app_identifier_prefix):
-    """Constructs a dictionary of variable substitutions for Entitlements.plist.
+        try:
+            # First, try to read the file using plistlib that only supports XML,
+            # and if an exception is raised, convert a temporary copy to XML and
+            # load that copy.
+            return plistlib.readPlist(plist_path)
+        except Exception:
+            pass
+        with tempfile.NamedTemporaryFile() as temp:
+            shutil.copy2(plist_path, temp.name)
+            subprocess.check_call(["plutil", "-convert", "xml1", temp.name])
+            return plistlib.readPlist(temp.name)
+
+    def _GetSubstitutions(self, bundle_identifier, app_identifier_prefix):
+        """Constructs a dictionary of variable substitutions for Entitlements.plist.
 
     Args:
       bundle_identifier: string, value of CFBundleIdentifier from Info.plist
@@ -569,25 +622,25 @@ class MacTool(object):
     Returns:
       Dictionary of substitutions to apply when generating Entitlements.plist.
     """
-    return {
-      'CFBundleIdentifier': bundle_identifier,
-      'AppIdentifierPrefix': app_identifier_prefix,
-    }
+        return {
+            "CFBundleIdentifier": bundle_identifier,
+            "AppIdentifierPrefix": app_identifier_prefix,
+        }
 
-  def _GetCFBundleIdentifier(self):
-    """Extracts CFBundleIdentifier value from Info.plist in the bundle.
+    def _GetCFBundleIdentifier(self):
+        """Extracts CFBundleIdentifier value from Info.plist in the bundle.
 
     Returns:
       Value of CFBundleIdentifier in the Info.plist located in the bundle.
     """
-    info_plist_path = os.path.join(
-        os.environ['TARGET_BUILD_DIR'],
-        os.environ['INFOPLIST_PATH'])
-    info_plist_data = self._LoadPlistMaybeBinary(info_plist_path)
-    return info_plist_data['CFBundleIdentifier']
+        info_plist_path = os.path.join(
+            os.environ["TARGET_BUILD_DIR"], os.environ["INFOPLIST_PATH"]
+        )
+        info_plist_data = self._LoadPlistMaybeBinary(info_plist_path)
+        return info_plist_data["CFBundleIdentifier"]
 
-  def _InstallEntitlements(self, entitlements, substitutions, overrides):
-    """Generates and install the ${BundleName}.xcent entitlements file.
+    def _InstallEntitlements(self, entitlements, substitutions, overrides):
+        """Generates and install the ${BundleName}.xcent entitlements file.
 
     Expands variables "$(variable)" pattern in the source entitlements file,
     add extra entitlements defined in the .mobileprovision file and the copy
@@ -602,26 +655,24 @@ class MacTool(object):
     Returns:
       Path to the generated entitlements file.
     """
-    source_path = entitlements
-    target_path = os.path.join(
-        os.environ['BUILT_PRODUCTS_DIR'],
-        os.environ['PRODUCT_NAME'] + '.xcent')
-    if not source_path:
-      source_path = os.path.join(
-          os.environ['SDKROOT'],
-          'Entitlements.plist')
-    shutil.copy2(source_path, target_path)
-    data = self._LoadPlistMaybeBinary(target_path)
-    data = self._ExpandVariables(data, substitutions)
-    if overrides:
-      for key in overrides:
-        if key not in data:
-          data[key] = overrides[key]
-    plistlib.writePlist(data, target_path)
-    return target_path
-
-  def _ExpandVariables(self, data, substitutions):
-    """Expands variables "$(variable)" in data.
+        source_path = entitlements
+        target_path = os.path.join(
+            os.environ["BUILT_PRODUCTS_DIR"], os.environ["PRODUCT_NAME"] + ".xcent"
+        )
+        if not source_path:
+            source_path = os.path.join(os.environ["SDKROOT"], "Entitlements.plist")
+        shutil.copy2(source_path, target_path)
+        data = self._LoadPlistMaybeBinary(target_path)
+        data = self._ExpandVariables(data, substitutions)
+        if overrides:
+            for key in overrides:
+                if key not in data:
+                    data[key] = overrides[key]
+        plistlib.writePlist(data, target_path)
+        return target_path
+
+    def _ExpandVariables(self, data, substitutions):
+        """Expands variables "$(variable)" in data.
 
     Args:
       data: object, can be either string, list or dictionary
@@ -632,21 +683,23 @@ class MacTool(object):
       by the corresponding value found in substitutions, or left intact if
       the key was not found.
     """
-    if isinstance(data, str):
-      for key, value in substitutions.items():
-        data = data.replace('$(%s)' % key, value)
-      return data
-    if isinstance(data, list):
-      return [self._ExpandVariables(v, substitutions) for v in data]
-    if isinstance(data, dict):
-      return {k: self._ExpandVariables(data[k], substitutions) for k in data}
-    return data
+        if isinstance(data, str):
+            for key, value in substitutions.items():
+                data = data.replace("$(%s)" % key, value)
+            return data
+        if isinstance(data, list):
+            return [self._ExpandVariables(v, substitutions) for v in data]
+        if isinstance(data, dict):
+            return {k: self._ExpandVariables(data[k], substitutions) for k in data}
+        return data
+
 
 def NextGreaterPowerOf2(x):
-  return 2**(x).bit_length()
+    return 2 ** (x).bit_length()
+
 
 def WriteHmap(output_name, filelist):
-  """Generates a header map based on |filelist|.
+    """Generates a header map based on |filelist|.
 
   Per Mark Mentovai:
     A header map is structured essentially as a hash table, keyed by names used
@@ -657,56 +710,67 @@ def WriteHmap(output_name, filelist):
   while also looking at the implementation in clang in:
     https://llvm.org/svn/llvm-project/cfe/trunk/lib/Lex/HeaderMap.cpp
   """
-  magic = 1751998832
-  version = 1
-  _reserved = 0
-  count = len(filelist)
-  capacity = NextGreaterPowerOf2(count)
-  strings_offset = 24 + (12 * capacity)
-  max_value_length = max(len(value) for value in filelist.values())
-
-  out = open(output_name, "wb")
-  out.write(struct.pack('<LHHLLLL', magic, version, _reserved, strings_offset,
-                        count, capacity, max_value_length))
-
-  # Create empty hashmap buckets.
-  buckets = [None] * capacity
-  for file, path in filelist.items():
-    key = 0
-    for c in file:
-      key += ord(c.lower()) * 13
-
-    # Fill next empty bucket.
-    while buckets[key & capacity - 1] is not None:
-      key = key + 1
-    buckets[key & capacity - 1] = (file, path)
-
-  next_offset = 1
-  for bucket in buckets:
-    if bucket is None:
-      out.write(struct.pack('<LLL', 0, 0, 0))
-    else:
-      (file, path) = bucket
-      key_offset = next_offset
-      prefix_offset = key_offset + len(file) + 1
-      suffix_offset = prefix_offset + len(os.path.dirname(path) + os.sep) + 1
-      next_offset = suffix_offset + len(os.path.basename(path)) + 1
-      out.write(struct.pack('<LLL', key_offset, prefix_offset, suffix_offset))
-
-  # Pad byte since next offset starts at 1.
-  out.write(struct.pack('<x'))
-
-  for bucket in buckets:
-    if bucket is not None:
-      (file, path) = bucket
-      out.write(struct.pack('<%ds' % len(file), file))
-      out.write(struct.pack('<s', '\0'))
-      base = os.path.dirname(path) + os.sep
-      out.write(struct.pack('<%ds' % len(base), base))
-      out.write(struct.pack('<s', '\0'))
-      path = os.path.basename(path)
-      out.write(struct.pack('<%ds' % len(path), path))
-      out.write(struct.pack('<s', '\0'))
-
-if __name__ == '__main__':
-  sys.exit(main(sys.argv[1:]))
+    magic = 1751998832
+    version = 1
+    _reserved = 0
+    count = len(filelist)
+    capacity = NextGreaterPowerOf2(count)
+    strings_offset = 24 + (12 * capacity)
+    max_value_length = max(len(value) for value in filelist.values())
+
+    out = open(output_name, "wb")
+    out.write(
+        struct.pack(
+            "<LHHLLLL",
+            magic,
+            version,
+            _reserved,
+            strings_offset,
+            count,
+            capacity,
+            max_value_length,
+        )
+    )
+
+    # Create empty hashmap buckets.
+    buckets = [None] * capacity
+    for file, path in filelist.items():
+        key = 0
+        for c in file:
+            key += ord(c.lower()) * 13
+
+        # Fill next empty bucket.
+        while buckets[key & capacity - 1] is not None:
+            key = key + 1
+        buckets[key & capacity - 1] = (file, path)
+
+    next_offset = 1
+    for bucket in buckets:
+        if bucket is None:
+            out.write(struct.pack("<LLL", 0, 0, 0))
+        else:
+            (file, path) = bucket
+            key_offset = next_offset
+            prefix_offset = key_offset + len(file) + 1
+            suffix_offset = prefix_offset + len(os.path.dirname(path) + os.sep) + 1
+            next_offset = suffix_offset + len(os.path.basename(path)) + 1
+            out.write(struct.pack("<LLL", key_offset, prefix_offset, suffix_offset))
+
+    # Pad byte since next offset starts at 1.
+    out.write(struct.pack("<x"))
+
+    for bucket in buckets:
+        if bucket is not None:
+            (file, path) = bucket
+            out.write(struct.pack("<%ds" % len(file), file))
+            out.write(struct.pack("<s", "\0"))
+            base = os.path.dirname(path) + os.sep
+            out.write(struct.pack("<%ds" % len(base), base))
+            out.write(struct.pack("<s", "\0"))
+            path = os.path.basename(path)
+            out.write(struct.pack("<%ds" % len(path), path))
+            out.write(struct.pack("<s", "\0"))
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/tools/gyp/pylib/gyp/msvs_emulation.py b/tools/gyp/pylib/gyp/msvs_emulation.py
index d42e2e47b98a53fc7adb56bbd292f0e51af2ca41..1afc1d687ed3f0dc879f9d32ee1104d916eb8b1a 100644
--- a/tools/gyp/pylib/gyp/msvs_emulation.py
+++ b/tools/gyp/pylib/gyp/msvs_emulation.py
@@ -22,797 +22,900 @@ windows_quoter_regex = re.compile(r'(\\*)"')
 
 
 def QuoteForRspFile(arg):
-  """Quote a command line argument so that it appears as one argument when
+    """Quote a command line argument so that it appears as one argument when
   processed via cmd.exe and parsed by CommandLineToArgvW (as is typical for
   Windows programs)."""
-  # See http://goo.gl/cuFbX and http://goo.gl/dhPnp including the comment
-  # threads. This is actually the quoting rules for CommandLineToArgvW, not
-  # for the shell, because the shell doesn't do anything in Windows. This
-  # works more or less because most programs (including the compiler, etc.)
-  # use that function to handle command line arguments.
+    # See http://goo.gl/cuFbX and http://goo.gl/dhPnp including the comment
+    # threads. This is actually the quoting rules for CommandLineToArgvW, not
+    # for the shell, because the shell doesn't do anything in Windows. This
+    # works more or less because most programs (including the compiler, etc.)
+    # use that function to handle command line arguments.
 
-  # Use a heuristic to try to find args that are paths, and normalize them
-  if arg.find('/') > 0 or arg.count('/') > 1:
-    arg = os.path.normpath(arg)
+    # Use a heuristic to try to find args that are paths, and normalize them
+    if arg.find("/") > 0 or arg.count("/") > 1:
+        arg = os.path.normpath(arg)
 
-  # For a literal quote, CommandLineToArgvW requires 2n+1 backslashes
-  # preceding it, and results in n backslashes + the quote. So we substitute
-  # in 2* what we match, +1 more, plus the quote.
-  arg = windows_quoter_regex.sub(lambda mo: 2 * mo.group(1) + '\\"', arg)
+    # For a literal quote, CommandLineToArgvW requires 2n+1 backslashes
+    # preceding it, and results in n backslashes + the quote. So we substitute
+    # in 2* what we match, +1 more, plus the quote.
+    arg = windows_quoter_regex.sub(lambda mo: 2 * mo.group(1) + '\\"', arg)
 
-  # %'s also need to be doubled otherwise they're interpreted as batch
-  # positional arguments. Also make sure to escape the % so that they're
-  # passed literally through escaping so they can be singled to just the
-  # original %. Otherwise, trying to pass the literal representation that
-  # looks like an environment variable to the shell (e.g. %PATH%) would fail.
-  arg = arg.replace('%', '%%')
+    # %'s also need to be doubled otherwise they're interpreted as batch
+    # positional arguments. Also make sure to escape the % so that they're
+    # passed literally through escaping so they can be singled to just the
+    # original %. Otherwise, trying to pass the literal representation that
+    # looks like an environment variable to the shell (e.g. %PATH%) would fail.
+    arg = arg.replace("%", "%%")
 
-  # These commands are used in rsp files, so no escaping for the shell (via ^)
-  # is necessary.
+    # These commands are used in rsp files, so no escaping for the shell (via ^)
+    # is necessary.
 
-  # Finally, wrap the whole thing in quotes so that the above quote rule
-  # applies and whitespace isn't a word break.
-  return '"' + arg + '"'
+    # Finally, wrap the whole thing in quotes so that the above quote rule
+    # applies and whitespace isn't a word break.
+    return '"' + arg + '"'
 
 
 def EncodeRspFileList(args):
-  """Process a list of arguments using QuoteCmdExeArgument."""
-  # Note that the first argument is assumed to be the command. Don't add
-  # quotes around it because then built-ins like 'echo', etc. won't work.
-  # Take care to normpath only the path in the case of 'call ../x.bat' because
-  # otherwise the whole thing is incorrectly interpreted as a path and not
-  # normalized correctly.
-  if not args: return ''
-  if args[0].startswith('call '):
-    call, program = args[0].split(' ', 1)
-    program = call + ' ' + os.path.normpath(program)
-  else:
-    program = os.path.normpath(args[0])
-  return program + ' ' + ' '.join(QuoteForRspFile(arg) for arg in args[1:])
+    """Process a list of arguments using QuoteCmdExeArgument."""
+    # Note that the first argument is assumed to be the command. Don't add
+    # quotes around it because then built-ins like 'echo', etc. won't work.
+    # Take care to normpath only the path in the case of 'call ../x.bat' because
+    # otherwise the whole thing is incorrectly interpreted as a path and not
+    # normalized correctly.
+    if not args:
+        return ""
+    if args[0].startswith("call "):
+        call, program = args[0].split(" ", 1)
+        program = call + " " + os.path.normpath(program)
+    else:
+        program = os.path.normpath(args[0])
+    return program + " " + " ".join(QuoteForRspFile(arg) for arg in args[1:])
 
 
 def _GenericRetrieve(root, default, path):
-  """Given a list of dictionary keys |path| and a tree of dicts |root|, find
+    """Given a list of dictionary keys |path| and a tree of dicts |root|, find
   value at path, or return |default| if any of the path doesn't exist."""
-  if not root:
-    return default
-  if not path:
-    return root
-  return _GenericRetrieve(root.get(path[0]), default, path[1:])
+    if not root:
+        return default
+    if not path:
+        return root
+    return _GenericRetrieve(root.get(path[0]), default, path[1:])
 
 
 def _AddPrefix(element, prefix):
-  """Add |prefix| to |element| or each subelement if element is iterable."""
-  if element is None:
-    return element
-  # Note, not Iterable because we don't want to handle strings like that.
-  if isinstance(element, list) or isinstance(element, tuple):
-    return [prefix + e for e in element]
-  else:
-    return prefix + element
+    """Add |prefix| to |element| or each subelement if element is iterable."""
+    if element is None:
+        return element
+    # Note, not Iterable because we don't want to handle strings like that.
+    if isinstance(element, list) or isinstance(element, tuple):
+        return [prefix + e for e in element]
+    else:
+        return prefix + element
 
 
 def _DoRemapping(element, map):
-  """If |element| then remap it through |map|. If |element| is iterable then
+    """If |element| then remap it through |map|. If |element| is iterable then
   each item will be remapped. Any elements not found will be removed."""
-  if map is not None and element is not None:
-    if not callable(map):
-      map = map.get # Assume it's a dict, otherwise a callable to do the remap.
-    if isinstance(element, list) or isinstance(element, tuple):
-      element = filter(None, [map(elem) for elem in element])
-    else:
-      element = map(element)
-  return element
+    if map is not None and element is not None:
+        if not callable(map):
+            map = map.get  # Assume it's a dict, otherwise a callable to do the remap.
+        if isinstance(element, list) or isinstance(element, tuple):
+            element = filter(None, [map(elem) for elem in element])
+        else:
+            element = map(element)
+    return element
 
 
 def _AppendOrReturn(append, element):
-  """If |append| is None, simply return |element|. If |append| is not None,
+    """If |append| is None, simply return |element|. If |append| is not None,
   then add |element| to it, adding each item in |element| if it's a list or
   tuple."""
-  if append is not None and element is not None:
-    if isinstance(element, list) or isinstance(element, tuple):
-      append.extend(element)
+    if append is not None and element is not None:
+        if isinstance(element, list) or isinstance(element, tuple):
+            append.extend(element)
+        else:
+            append.append(element)
     else:
-      append.append(element)
-  else:
-    return element
+        return element
 
 
 def _FindDirectXInstallation():
-  """Try to find an installation location for the DirectX SDK. Check for the
+    """Try to find an installation location for the DirectX SDK. Check for the
   standard environment variable, and if that doesn't exist, try to find
   via the registry. May return None if not found in either location."""
-  # Return previously calculated value, if there is one
-  if hasattr(_FindDirectXInstallation, 'dxsdk_dir'):
-    return _FindDirectXInstallation.dxsdk_dir
-
-  dxsdk_dir = os.environ.get('DXSDK_DIR')
-  if not dxsdk_dir:
-    # Setup params to pass to and attempt to launch reg.exe.
-    cmd = ['reg.exe', 'query', r'HKLM\Software\Microsoft\DirectX', '/s']
-    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    stdout = p.communicate()[0]
-    if PY3:
-      stdout = stdout.decode('utf-8')
-    for line in stdout.splitlines():
-      if 'InstallPath' in line:
-        dxsdk_dir = line.split('    ')[3] + "\\"
-
-  # Cache return value
-  _FindDirectXInstallation.dxsdk_dir = dxsdk_dir
-  return dxsdk_dir
+    # Return previously calculated value, if there is one
+    if hasattr(_FindDirectXInstallation, "dxsdk_dir"):
+        return _FindDirectXInstallation.dxsdk_dir
+
+    dxsdk_dir = os.environ.get("DXSDK_DIR")
+    if not dxsdk_dir:
+        # Setup params to pass to and attempt to launch reg.exe.
+        cmd = ["reg.exe", "query", r"HKLM\Software\Microsoft\DirectX", "/s"]
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout = p.communicate()[0]
+        if PY3:
+            stdout = stdout.decode("utf-8")
+        for line in stdout.splitlines():
+            if "InstallPath" in line:
+                dxsdk_dir = line.split("    ")[3] + "\\"
+
+    # Cache return value
+    _FindDirectXInstallation.dxsdk_dir = dxsdk_dir
+    return dxsdk_dir
 
 
 def GetGlobalVSMacroEnv(vs_version):
-  """Get a dict of variables mapping internal VS macro names to their gyp
+    """Get a dict of variables mapping internal VS macro names to their gyp
   equivalents. Returns all variables that are independent of the target."""
-  env = {}
-  # '$(VSInstallDir)' and '$(VCInstallDir)' are available when and only when
-  # Visual Studio is actually installed.
-  if vs_version.Path():
-    env['$(VSInstallDir)'] = vs_version.Path()
-    env['$(VCInstallDir)'] = os.path.join(vs_version.Path(), 'VC') + '\\'
-  # Chromium uses DXSDK_DIR in include/lib paths, but it may or may not be
-  # set. This happens when the SDK is sync'd via src-internal, rather than
-  # by typical end-user installation of the SDK. If it's not set, we don't
-  # want to leave the unexpanded variable in the path, so simply strip it.
-  dxsdk_dir = _FindDirectXInstallation()
-  env['$(DXSDK_DIR)'] = dxsdk_dir if dxsdk_dir else ''
-  # Try to find an installation location for the Windows DDK by checking
-  # the WDK_DIR environment variable, may be None.
-  env['$(WDK_DIR)'] = os.environ.get('WDK_DIR', '')
-  return env
+    env = {}
+    # '$(VSInstallDir)' and '$(VCInstallDir)' are available when and only when
+    # Visual Studio is actually installed.
+    if vs_version.Path():
+        env["$(VSInstallDir)"] = vs_version.Path()
+        env["$(VCInstallDir)"] = os.path.join(vs_version.Path(), "VC") + "\\"
+    # Chromium uses DXSDK_DIR in include/lib paths, but it may or may not be
+    # set. This happens when the SDK is sync'd via src-internal, rather than
+    # by typical end-user installation of the SDK. If it's not set, we don't
+    # want to leave the unexpanded variable in the path, so simply strip it.
+    dxsdk_dir = _FindDirectXInstallation()
+    env["$(DXSDK_DIR)"] = dxsdk_dir if dxsdk_dir else ""
+    # Try to find an installation location for the Windows DDK by checking
+    # the WDK_DIR environment variable, may be None.
+    env["$(WDK_DIR)"] = os.environ.get("WDK_DIR", "")
+    return env
+
 
 def ExtractSharedMSVSSystemIncludes(configs, generator_flags):
-  """Finds msvs_system_include_dirs that are common to all targets, removes
+    """Finds msvs_system_include_dirs that are common to all targets, removes
   them from all targets, and returns an OrderedSet containing them."""
-  all_system_includes = OrderedSet(
-      configs[0].get('msvs_system_include_dirs', []))
-  for config in configs[1:]:
-    system_includes = config.get('msvs_system_include_dirs', [])
-    all_system_includes = all_system_includes & OrderedSet(system_includes)
-  if not all_system_includes:
-    return None
-  # Expand macros in all_system_includes.
-  env = GetGlobalVSMacroEnv(GetVSVersion(generator_flags))
-  expanded_system_includes = OrderedSet([ExpandMacros(include, env)
-                                         for include in all_system_includes])
-  if any(['$' in include for include in expanded_system_includes]):
-    # Some path relies on target-specific variables, bail.
-    return None
-
-  # Remove system includes shared by all targets from the targets.
-  for config in configs:
-    includes = config.get('msvs_system_include_dirs', [])
-    if includes:  # Don't insert a msvs_system_include_dirs key if not needed.
-      # This must check the unexpanded includes list:
-      new_includes = [i for i in includes if i not in all_system_includes]
-      config['msvs_system_include_dirs'] = new_includes
-  return expanded_system_includes
+    all_system_includes = OrderedSet(configs[0].get("msvs_system_include_dirs", []))
+    for config in configs[1:]:
+        system_includes = config.get("msvs_system_include_dirs", [])
+        all_system_includes = all_system_includes & OrderedSet(system_includes)
+    if not all_system_includes:
+        return None
+    # Expand macros in all_system_includes.
+    env = GetGlobalVSMacroEnv(GetVSVersion(generator_flags))
+    expanded_system_includes = OrderedSet(
+        [ExpandMacros(include, env) for include in all_system_includes]
+    )
+    if any(["$" in include for include in expanded_system_includes]):
+        # Some path relies on target-specific variables, bail.
+        return None
+
+    # Remove system includes shared by all targets from the targets.
+    for config in configs:
+        includes = config.get("msvs_system_include_dirs", [])
+        if includes:  # Don't insert a msvs_system_include_dirs key if not needed.
+            # This must check the unexpanded includes list:
+            new_includes = [i for i in includes if i not in all_system_includes]
+            config["msvs_system_include_dirs"] = new_includes
+    return expanded_system_includes
 
 
 class MsvsSettings(object):
-  """A class that understands the gyp 'msvs_...' values (especially the
+    """A class that understands the gyp 'msvs_...' values (especially the
   msvs_settings field). They largely correpond to the VS2008 IDE DOM. This
   class helps map those settings to command line options."""
 
-  def __init__(self, spec, generator_flags):
-    self.spec = spec
-    self.vs_version = GetVSVersion(generator_flags)
-
-    supported_fields = [
-        ('msvs_configuration_attributes', dict),
-        ('msvs_settings', dict),
-        ('msvs_system_include_dirs', list),
-        ('msvs_disabled_warnings', list),
-        ('msvs_precompiled_header', str),
-        ('msvs_precompiled_source', str),
-        ('msvs_configuration_platform', str),
-        ('msvs_target_platform', str),
+    def __init__(self, spec, generator_flags):
+        self.spec = spec
+        self.vs_version = GetVSVersion(generator_flags)
+
+        supported_fields = [
+            ("msvs_configuration_attributes", dict),
+            ("msvs_settings", dict),
+            ("msvs_system_include_dirs", list),
+            ("msvs_disabled_warnings", list),
+            ("msvs_precompiled_header", str),
+            ("msvs_precompiled_source", str),
+            ("msvs_configuration_platform", str),
+            ("msvs_target_platform", str),
+        ]
+        configs = spec["configurations"]
+        for field, default in supported_fields:
+            setattr(self, field, {})
+            for configname, config in configs.items():
+                getattr(self, field)[configname] = config.get(field, default())
+
+        self.msvs_cygwin_dirs = spec.get("msvs_cygwin_dirs", ["."])
+
+        unsupported_fields = [
+            "msvs_prebuild",
+            "msvs_postbuild",
         ]
-    configs = spec['configurations']
-    for field, default in supported_fields:
-      setattr(self, field, {})
-      for configname, config in configs.items():
-        getattr(self, field)[configname] = config.get(field, default())
-
-    self.msvs_cygwin_dirs = spec.get('msvs_cygwin_dirs', ['.'])
-
-    unsupported_fields = [
-        'msvs_prebuild',
-        'msvs_postbuild',
-    ]
-    unsupported = []
-    for field in unsupported_fields:
-      for config in configs.values():
-        if field in config:
-          unsupported += ["%s not supported (target %s)." %
-                          (field, spec['target_name'])]
-    if unsupported:
-      raise Exception('\n'.join(unsupported))
-
-  def GetExtension(self):
-    """Returns the extension for the target, with no leading dot.
+        unsupported = []
+        for field in unsupported_fields:
+            for config in configs.values():
+                if field in config:
+                    unsupported += [
+                        "%s not supported (target %s)." % (field, spec["target_name"])
+                    ]
+        if unsupported:
+            raise Exception("\n".join(unsupported))
+
+    def GetExtension(self):
+        """Returns the extension for the target, with no leading dot.
 
     Uses 'product_extension' if specified, otherwise uses MSVS defaults based on
     the target type.
     """
-    ext = self.spec.get('product_extension', None)
-    if ext:
-      return ext
-    return gyp.MSVSUtil.TARGET_TYPE_EXT.get(self.spec['type'], '')
+        ext = self.spec.get("product_extension", None)
+        if ext:
+            return ext
+        return gyp.MSVSUtil.TARGET_TYPE_EXT.get(self.spec["type"], "")
 
-  def GetVSMacroEnv(self, base_to_build=None, config=None):
-    """Get a dict of variables mapping internal VS macro names to their gyp
+    def GetVSMacroEnv(self, base_to_build=None, config=None):
+        """Get a dict of variables mapping internal VS macro names to their gyp
     equivalents."""
-    target_arch = self.GetArch(config)
-    if target_arch == 'x86':
-      target_platform = 'Win32'
-    else:
-      target_platform = target_arch
-    target_name = self.spec.get('product_prefix', '') + \
-        self.spec.get('product_name', self.spec['target_name'])
-    target_dir = base_to_build + '\\' if base_to_build else ''
-    target_ext = '.' + self.GetExtension()
-    target_file_name = target_name + target_ext
-
-    replacements = {
-        '$(InputName)': '${root}',
-        '$(InputPath)': '${source}',
-        '$(IntDir)': '$!INTERMEDIATE_DIR',
-        '$(OutDir)\\': target_dir,
-        '$(PlatformName)': target_platform,
-        '$(ProjectDir)\\': '',
-        '$(ProjectName)': self.spec['target_name'],
-        '$(TargetDir)\\': target_dir,
-        '$(TargetExt)': target_ext,
-        '$(TargetFileName)': target_file_name,
-        '$(TargetName)': target_name,
-        '$(TargetPath)': os.path.join(target_dir, target_file_name),
-    }
-    replacements.update(GetGlobalVSMacroEnv(self.vs_version))
-    return replacements
-
-  def ConvertVSMacros(self, s, base_to_build=None, config=None):
-    """Convert from VS macro names to something equivalent."""
-    env = self.GetVSMacroEnv(base_to_build, config=config)
-    return ExpandMacros(s, env)
-
-  def AdjustLibraries(self, libraries):
-    """Strip -l from library if it's specified with that."""
-    libs = [lib[2:] if lib.startswith('-l') else lib for lib in libraries]
-    return [lib + '.lib' if not lib.lower().endswith('.lib') \
-            and not lib.lower().endswith('.obj') else lib for lib in libs]
-
-  def _GetAndMunge(self, field, path, default, prefix, append, map):
-    """Retrieve a value from |field| at |path| or return |default|. If
+        target_arch = self.GetArch(config)
+        if target_arch == "x86":
+            target_platform = "Win32"
+        else:
+            target_platform = target_arch
+        target_name = self.spec.get("product_prefix", "") + self.spec.get(
+            "product_name", self.spec["target_name"]
+        )
+        target_dir = base_to_build + "\\" if base_to_build else ""
+        target_ext = "." + self.GetExtension()
+        target_file_name = target_name + target_ext
+
+        replacements = {
+            "$(InputName)": "${root}",
+            "$(InputPath)": "${source}",
+            "$(IntDir)": "$!INTERMEDIATE_DIR",
+            "$(OutDir)\\": target_dir,
+            "$(PlatformName)": target_platform,
+            "$(ProjectDir)\\": "",
+            "$(ProjectName)": self.spec["target_name"],
+            "$(TargetDir)\\": target_dir,
+            "$(TargetExt)": target_ext,
+            "$(TargetFileName)": target_file_name,
+            "$(TargetName)": target_name,
+            "$(TargetPath)": os.path.join(target_dir, target_file_name),
+        }
+        replacements.update(GetGlobalVSMacroEnv(self.vs_version))
+        return replacements
+
+    def ConvertVSMacros(self, s, base_to_build=None, config=None):
+        """Convert from VS macro names to something equivalent."""
+        env = self.GetVSMacroEnv(base_to_build, config=config)
+        return ExpandMacros(s, env)
+
+    def AdjustLibraries(self, libraries):
+        """Strip -l from library if it's specified with that."""
+        libs = [lib[2:] if lib.startswith("-l") else lib for lib in libraries]
+        return [
+            lib + ".lib"
+            if not lib.lower().endswith(".lib") and not lib.lower().endswith(".obj")
+            else lib
+            for lib in libs
+        ]
+
+    def _GetAndMunge(self, field, path, default, prefix, append, map):
+        """Retrieve a value from |field| at |path| or return |default|. If
     |append| is specified, and the item is found, it will be appended to that
     object instead of returned. If |map| is specified, results will be
     remapped through |map| before being returned or appended."""
-    result = _GenericRetrieve(field, default, path)
-    result = _DoRemapping(result, map)
-    result = _AddPrefix(result, prefix)
-    return _AppendOrReturn(append, result)
-
-  class _GetWrapper(object):
-    def __init__(self, parent, field, base_path, append=None):
-      self.parent = parent
-      self.field = field
-      self.base_path = [base_path]
-      self.append = append
-    def __call__(self, name, map=None, prefix='', default=None):
-      return self.parent._GetAndMunge(self.field, self.base_path + [name],
-          default=default, prefix=prefix, append=self.append, map=map)
-
-  def GetArch(self, config):
-    """Get architecture based on msvs_configuration_platform and
+        result = _GenericRetrieve(field, default, path)
+        result = _DoRemapping(result, map)
+        result = _AddPrefix(result, prefix)
+        return _AppendOrReturn(append, result)
+
+    class _GetWrapper(object):
+        def __init__(self, parent, field, base_path, append=None):
+            self.parent = parent
+            self.field = field
+            self.base_path = [base_path]
+            self.append = append
+
+        def __call__(self, name, map=None, prefix="", default=None):
+            return self.parent._GetAndMunge(
+                self.field,
+                self.base_path + [name],
+                default=default,
+                prefix=prefix,
+                append=self.append,
+                map=map,
+            )
+
+    def GetArch(self, config):
+        """Get architecture based on msvs_configuration_platform and
     msvs_target_platform. Returns either 'x86' or 'x64'."""
-    configuration_platform = self.msvs_configuration_platform.get(config, '')
-    platform = self.msvs_target_platform.get(config, '')
-    if not platform: # If no specific override, use the configuration's.
-      platform = configuration_platform
-    # Map from platform to architecture.
-    return {'Win32': 'x86', 'x64': 'x64', 'ARM64': 'arm64'}.get(platform, 'x86')
-
-  def _TargetConfig(self, config):
-    """Returns the target-specific configuration."""
-    # There's two levels of architecture/platform specification in VS. The
-    # first level is globally for the configuration (this is what we consider
-    # "the" config at the gyp level, which will be something like 'Debug' or
-    # 'Release'), VS2015 and later only use this level
-    if self.vs_version.short_name >= 2015:
-      return config
-    # and a second target-specific configuration, which is an
-    # override for the global one. |config| is remapped here to take into
-    # account the local target-specific overrides to the global configuration.
-    arch = self.GetArch(config)
-    if arch == 'x64' and not config.endswith('_x64'):
-      config += '_x64'
-    if arch == 'x86' and config.endswith('_x64'):
-      config = config.rsplit('_', 1)[0]
-    return config
-
-  def _Setting(self, path, config,
-              default=None, prefix='', append=None, map=None):
-    """_GetAndMunge for msvs_settings."""
-    return self._GetAndMunge(
-        self.msvs_settings[config], path, default, prefix, append, map)
-
-  def _ConfigAttrib(self, path, config,
-                   default=None, prefix='', append=None, map=None):
-    """_GetAndMunge for msvs_configuration_attributes."""
-    return self._GetAndMunge(
-        self.msvs_configuration_attributes[config],
-        path, default, prefix, append, map)
-
-  def AdjustIncludeDirs(self, include_dirs, config):
-    """Updates include_dirs to expand VS specific paths, and adds the system
+        configuration_platform = self.msvs_configuration_platform.get(config, "")
+        platform = self.msvs_target_platform.get(config, "")
+        if not platform:  # If no specific override, use the configuration's.
+            platform = configuration_platform
+        # Map from platform to architecture.
+        return {"Win32": "x86", "x64": "x64", "ARM64": "arm64"}.get(platform, "x86")
+
+    def _TargetConfig(self, config):
+        """Returns the target-specific configuration."""
+        # There's two levels of architecture/platform specification in VS. The
+        # first level is globally for the configuration (this is what we consider
+        # "the" config at the gyp level, which will be something like 'Debug' or
+        # 'Release'), VS2015 and later only use this level
+        if self.vs_version.short_name >= 2015:
+            return config
+        # and a second target-specific configuration, which is an
+        # override for the global one. |config| is remapped here to take into
+        # account the local target-specific overrides to the global configuration.
+        arch = self.GetArch(config)
+        if arch == "x64" and not config.endswith("_x64"):
+            config += "_x64"
+        if arch == "x86" and config.endswith("_x64"):
+            config = config.rsplit("_", 1)[0]
+        return config
+
+    def _Setting(self, path, config, default=None, prefix="", append=None, map=None):
+        """_GetAndMunge for msvs_settings."""
+        return self._GetAndMunge(
+            self.msvs_settings[config], path, default, prefix, append, map
+        )
+
+    def _ConfigAttrib(
+        self, path, config, default=None, prefix="", append=None, map=None
+    ):
+        """_GetAndMunge for msvs_configuration_attributes."""
+        return self._GetAndMunge(
+            self.msvs_configuration_attributes[config],
+            path,
+            default,
+            prefix,
+            append,
+            map,
+        )
+
+    def AdjustIncludeDirs(self, include_dirs, config):
+        """Updates include_dirs to expand VS specific paths, and adds the system
     include dirs used for platform SDK and similar."""
-    config = self._TargetConfig(config)
-    includes = include_dirs + self.msvs_system_include_dirs[config]
-    includes.extend(self._Setting(
-      ('VCCLCompilerTool', 'AdditionalIncludeDirectories'), config, default=[]))
-    return [self.ConvertVSMacros(p, config=config) for p in includes]
-
-  def AdjustMidlIncludeDirs(self, midl_include_dirs, config):
-    """Updates midl_include_dirs to expand VS specific paths, and adds the
+        config = self._TargetConfig(config)
+        includes = include_dirs + self.msvs_system_include_dirs[config]
+        includes.extend(
+            self._Setting(
+                ("VCCLCompilerTool", "AdditionalIncludeDirectories"), config, default=[]
+            )
+        )
+        return [self.ConvertVSMacros(p, config=config) for p in includes]
+
+    def AdjustMidlIncludeDirs(self, midl_include_dirs, config):
+        """Updates midl_include_dirs to expand VS specific paths, and adds the
     system include dirs used for platform SDK and similar."""
-    config = self._TargetConfig(config)
-    includes = midl_include_dirs + self.msvs_system_include_dirs[config]
-    includes.extend(self._Setting(
-      ('VCMIDLTool', 'AdditionalIncludeDirectories'), config, default=[]))
-    return [self.ConvertVSMacros(p, config=config) for p in includes]
-
-  def GetComputedDefines(self, config):
-    """Returns the set of defines that are injected to the defines list based
+        config = self._TargetConfig(config)
+        includes = midl_include_dirs + self.msvs_system_include_dirs[config]
+        includes.extend(
+            self._Setting(
+                ("VCMIDLTool", "AdditionalIncludeDirectories"), config, default=[]
+            )
+        )
+        return [self.ConvertVSMacros(p, config=config) for p in includes]
+
+    def GetComputedDefines(self, config):
+        """Returns the set of defines that are injected to the defines list based
     on other VS settings."""
-    config = self._TargetConfig(config)
-    defines = []
-    if self._ConfigAttrib(['CharacterSet'], config) == '1':
-      defines.extend(('_UNICODE', 'UNICODE'))
-    if self._ConfigAttrib(['CharacterSet'], config) == '2':
-      defines.append('_MBCS')
-    defines.extend(self._Setting(
-        ('VCCLCompilerTool', 'PreprocessorDefinitions'), config, default=[]))
-    return defines
-
-  def GetCompilerPdbName(self, config, expand_special):
-    """Get the pdb file name that should be used for compiler invocations, or
+        config = self._TargetConfig(config)
+        defines = []
+        if self._ConfigAttrib(["CharacterSet"], config) == "1":
+            defines.extend(("_UNICODE", "UNICODE"))
+        if self._ConfigAttrib(["CharacterSet"], config) == "2":
+            defines.append("_MBCS")
+        defines.extend(
+            self._Setting(
+                ("VCCLCompilerTool", "PreprocessorDefinitions"), config, default=[]
+            )
+        )
+        return defines
+
+    def GetCompilerPdbName(self, config, expand_special):
+        """Get the pdb file name that should be used for compiler invocations, or
     None if there's no explicit name specified."""
-    config = self._TargetConfig(config)
-    pdbname = self._Setting(
-        ('VCCLCompilerTool', 'ProgramDataBaseFileName'), config)
-    if pdbname:
-      pdbname = expand_special(self.ConvertVSMacros(pdbname))
-    return pdbname
-
-  def GetMapFileName(self, config, expand_special):
-    """Gets the explicitly overridden map file name for a target or returns None
+        config = self._TargetConfig(config)
+        pdbname = self._Setting(("VCCLCompilerTool", "ProgramDataBaseFileName"), config)
+        if pdbname:
+            pdbname = expand_special(self.ConvertVSMacros(pdbname))
+        return pdbname
+
+    def GetMapFileName(self, config, expand_special):
+        """Gets the explicitly overridden map file name for a target or returns None
     if it's not set."""
-    config = self._TargetConfig(config)
-    map_file = self._Setting(('VCLinkerTool', 'MapFileName'), config)
-    if map_file:
-      map_file = expand_special(self.ConvertVSMacros(map_file, config=config))
-    return map_file
-
-  def GetOutputName(self, config, expand_special):
-    """Gets the explicitly overridden output name for a target or returns None
+        config = self._TargetConfig(config)
+        map_file = self._Setting(("VCLinkerTool", "MapFileName"), config)
+        if map_file:
+            map_file = expand_special(self.ConvertVSMacros(map_file, config=config))
+        return map_file
+
+    def GetOutputName(self, config, expand_special):
+        """Gets the explicitly overridden output name for a target or returns None
     if it's not overridden."""
-    config = self._TargetConfig(config)
-    type = self.spec['type']
-    root = 'VCLibrarianTool' if type == 'static_library' else 'VCLinkerTool'
-    # TODO(scottmg): Handle OutputDirectory without OutputFile.
-    output_file = self._Setting((root, 'OutputFile'), config)
-    if output_file:
-      output_file = expand_special(self.ConvertVSMacros(
-          output_file, config=config))
-    return output_file
-
-  def GetPDBName(self, config, expand_special, default):
-    """Gets the explicitly overridden pdb name for a target or returns
+        config = self._TargetConfig(config)
+        type = self.spec["type"]
+        root = "VCLibrarianTool" if type == "static_library" else "VCLinkerTool"
+        # TODO(scottmg): Handle OutputDirectory without OutputFile.
+        output_file = self._Setting((root, "OutputFile"), config)
+        if output_file:
+            output_file = expand_special(
+                self.ConvertVSMacros(output_file, config=config)
+            )
+        return output_file
+
+    def GetPDBName(self, config, expand_special, default):
+        """Gets the explicitly overridden pdb name for a target or returns
     default if it's not overridden, or if no pdb will be generated."""
-    config = self._TargetConfig(config)
-    output_file = self._Setting(('VCLinkerTool', 'ProgramDatabaseFile'), config)
-    generate_debug_info = self._Setting(
-        ('VCLinkerTool', 'GenerateDebugInformation'), config)
-    if generate_debug_info == 'true':
-      if output_file:
-        return expand_special(self.ConvertVSMacros(output_file, config=config))
-      else:
-        return default
-    else:
-      return None
-
-  def GetNoImportLibrary(self, config):
-    """If NoImportLibrary: true, ninja will not expect the output to include
+        config = self._TargetConfig(config)
+        output_file = self._Setting(("VCLinkerTool", "ProgramDatabaseFile"), config)
+        generate_debug_info = self._Setting(
+            ("VCLinkerTool", "GenerateDebugInformation"), config
+        )
+        if generate_debug_info == "true":
+            if output_file:
+                return expand_special(self.ConvertVSMacros(output_file, config=config))
+            else:
+                return default
+        else:
+            return None
+
+    def GetNoImportLibrary(self, config):
+        """If NoImportLibrary: true, ninja will not expect the output to include
     an import library."""
-    config = self._TargetConfig(config)
-    noimplib = self._Setting(('NoImportLibrary',), config)
-    return noimplib == 'true'
-
-  def GetAsmflags(self, config):
-    """Returns the flags that need to be added to ml invocations."""
-    config = self._TargetConfig(config)
-    asmflags = []
-    safeseh = self._Setting(('MASM', 'UseSafeExceptionHandlers'), config)
-    if safeseh == 'true':
-      asmflags.append('/safeseh')
-    return asmflags
-
-  def GetCflags(self, config):
-    """Returns the flags that need to be added to .c and .cc compilations."""
-    config = self._TargetConfig(config)
-    cflags = []
-    cflags.extend(['/wd' + w for w in self.msvs_disabled_warnings[config]])
-    cl = self._GetWrapper(self, self.msvs_settings[config],
-                          'VCCLCompilerTool', append=cflags)
-    cl('Optimization',
-       map={'0': 'd', '1': '1', '2': '2', '3': 'x'}, prefix='/O', default='2')
-    cl('InlineFunctionExpansion', prefix='/Ob')
-    cl('DisableSpecificWarnings', prefix='/wd')
-    cl('StringPooling', map={'true': '/GF'})
-    cl('EnableFiberSafeOptimizations', map={'true': '/GT'})
-    cl('OmitFramePointers', map={'false': '-', 'true': ''}, prefix='/Oy')
-    cl('EnableIntrinsicFunctions', map={'false': '-', 'true': ''}, prefix='/Oi')
-    cl('FavorSizeOrSpeed', map={'1': 't', '2': 's'}, prefix='/O')
-    cl('FloatingPointModel',
-        map={'0': 'precise', '1': 'strict', '2': 'fast'}, prefix='/fp:',
-        default='0')
-    cl('CompileAsManaged', map={'false': '', 'true': '/clr'})
-    cl('WholeProgramOptimization', map={'true': '/GL'})
-    cl('WarningLevel', prefix='/W')
-    cl('WarnAsError', map={'true': '/WX'})
-    cl('CallingConvention',
-        map={'0': 'd', '1': 'r', '2': 'z', '3': 'v'}, prefix='/G')
-    cl('DebugInformationFormat',
-        map={'1': '7', '3': 'i', '4': 'I'}, prefix='/Z')
-    cl('RuntimeTypeInfo', map={'true': '/GR', 'false': '/GR-'})
-    cl('EnableFunctionLevelLinking', map={'true': '/Gy', 'false': '/Gy-'})
-    cl('MinimalRebuild', map={'true': '/Gm'})
-    cl('BufferSecurityCheck', map={'true': '/GS', 'false': '/GS-'})
-    cl('BasicRuntimeChecks', map={'1': 's', '2': 'u', '3': '1'}, prefix='/RTC')
-    cl('RuntimeLibrary',
-        map={'0': 'T', '1': 'Td', '2': 'D', '3': 'Dd'}, prefix='/M')
-    cl('ExceptionHandling', map={'1': 'sc','2': 'a'}, prefix='/EH')
-    cl('DefaultCharIsUnsigned', map={'true': '/J'})
-    cl('TreatWChar_tAsBuiltInType',
-        map={'false': '-', 'true': ''}, prefix='/Zc:wchar_t')
-    cl('EnablePREfast', map={'true': '/analyze'})
-    cl('AdditionalOptions', prefix='')
-    cl('EnableEnhancedInstructionSet',
-        map={'1': 'SSE', '2': 'SSE2', '3': 'AVX', '4': 'IA32', '5': 'AVX2'},
-        prefix='/arch:')
-    cflags.extend(['/FI' + f for f in self._Setting(
-        ('VCCLCompilerTool', 'ForcedIncludeFiles'), config, default=[])])
-    if self.vs_version.project_version >= 12.0:
-      # New flag introduced in VS2013 (project version 12.0) Forces writes to
-      # the program database (PDB) to be serialized through MSPDBSRV.EXE.
-      # https://msdn.microsoft.com/en-us/library/dn502518.aspx
-      cflags.append('/FS')
-    # ninja handles parallelism by itself, don't have the compiler do it too.
-    cflags = filter(lambda x: not x.startswith('/MP'), cflags)
-    return cflags
-
-  def _GetPchFlags(self, config, extension):
-    """Get the flags to be added to the cflags for precompiled header support.
+        config = self._TargetConfig(config)
+        noimplib = self._Setting(("NoImportLibrary",), config)
+        return noimplib == "true"
+
+    def GetAsmflags(self, config):
+        """Returns the flags that need to be added to ml invocations."""
+        config = self._TargetConfig(config)
+        asmflags = []
+        safeseh = self._Setting(("MASM", "UseSafeExceptionHandlers"), config)
+        if safeseh == "true":
+            asmflags.append("/safeseh")
+        return asmflags
+
+    def GetCflags(self, config):
+        """Returns the flags that need to be added to .c and .cc compilations."""
+        config = self._TargetConfig(config)
+        cflags = []
+        cflags.extend(["/wd" + w for w in self.msvs_disabled_warnings[config]])
+        cl = self._GetWrapper(
+            self, self.msvs_settings[config], "VCCLCompilerTool", append=cflags
+        )
+        cl(
+            "Optimization",
+            map={"0": "d", "1": "1", "2": "2", "3": "x"},
+            prefix="/O",
+            default="2",
+        )
+        cl("InlineFunctionExpansion", prefix="/Ob")
+        cl("DisableSpecificWarnings", prefix="/wd")
+        cl("StringPooling", map={"true": "/GF"})
+        cl("EnableFiberSafeOptimizations", map={"true": "/GT"})
+        cl("OmitFramePointers", map={"false": "-", "true": ""}, prefix="/Oy")
+        cl("EnableIntrinsicFunctions", map={"false": "-", "true": ""}, prefix="/Oi")
+        cl("FavorSizeOrSpeed", map={"1": "t", "2": "s"}, prefix="/O")
+        cl(
+            "FloatingPointModel",
+            map={"0": "precise", "1": "strict", "2": "fast"},
+            prefix="/fp:",
+            default="0",
+        )
+        cl("CompileAsManaged", map={"false": "", "true": "/clr"})
+        cl("WholeProgramOptimization", map={"true": "/GL"})
+        cl("WarningLevel", prefix="/W")
+        cl("WarnAsError", map={"true": "/WX"})
+        cl(
+            "CallingConvention",
+            map={"0": "d", "1": "r", "2": "z", "3": "v"},
+            prefix="/G",
+        )
+        cl("DebugInformationFormat", map={"1": "7", "3": "i", "4": "I"}, prefix="/Z")
+        cl("RuntimeTypeInfo", map={"true": "/GR", "false": "/GR-"})
+        cl("EnableFunctionLevelLinking", map={"true": "/Gy", "false": "/Gy-"})
+        cl("MinimalRebuild", map={"true": "/Gm"})
+        cl("BufferSecurityCheck", map={"true": "/GS", "false": "/GS-"})
+        cl("BasicRuntimeChecks", map={"1": "s", "2": "u", "3": "1"}, prefix="/RTC")
+        cl(
+            "RuntimeLibrary",
+            map={"0": "T", "1": "Td", "2": "D", "3": "Dd"},
+            prefix="/M",
+        )
+        cl("ExceptionHandling", map={"1": "sc", "2": "a"}, prefix="/EH")
+        cl("DefaultCharIsUnsigned", map={"true": "/J"})
+        cl(
+            "TreatWChar_tAsBuiltInType",
+            map={"false": "-", "true": ""},
+            prefix="/Zc:wchar_t",
+        )
+        cl("EnablePREfast", map={"true": "/analyze"})
+        cl("AdditionalOptions", prefix="")
+        cl(
+            "EnableEnhancedInstructionSet",
+            map={"1": "SSE", "2": "SSE2", "3": "AVX", "4": "IA32", "5": "AVX2"},
+            prefix="/arch:",
+        )
+        cflags.extend(
+            [
+                "/FI" + f
+                for f in self._Setting(
+                    ("VCCLCompilerTool", "ForcedIncludeFiles"), config, default=[]
+                )
+            ]
+        )
+        if self.vs_version.project_version >= 12.0:
+            # New flag introduced in VS2013 (project version 12.0) Forces writes to
+            # the program database (PDB) to be serialized through MSPDBSRV.EXE.
+            # https://msdn.microsoft.com/en-us/library/dn502518.aspx
+            cflags.append("/FS")
+        # ninja handles parallelism by itself, don't have the compiler do it too.
+        cflags = [x for x in cflags if not x.startswith("/MP")]
+        return cflags
+
+    def _GetPchFlags(self, config, extension):
+        """Get the flags to be added to the cflags for precompiled header support.
     """
-    config = self._TargetConfig(config)
-    # The PCH is only built once by a particular source file. Usage of PCH must
-    # only be for the same language (i.e. C vs. C++), so only include the pch
-    # flags when the language matches.
-    if self.msvs_precompiled_header[config]:
-      source_ext = os.path.splitext(self.msvs_precompiled_source[config])[1]
-      if _LanguageMatchesForPch(source_ext, extension):
-        pch = self.msvs_precompiled_header[config]
-        pchbase = os.path.split(pch)[1]
-        return ['/Yu' + pch, '/FI' + pch, '/Fp${pchprefix}.' + pchbase + '.pch']
-    return  []
-
-  def GetCflagsC(self, config):
-    """Returns the flags that need to be added to .c compilations."""
-    config = self._TargetConfig(config)
-    return self._GetPchFlags(config, '.c')
-
-  def GetCflagsCC(self, config):
-    """Returns the flags that need to be added to .cc compilations."""
-    config = self._TargetConfig(config)
-    return ['/TP'] + self._GetPchFlags(config, '.cc')
-
-  def _GetAdditionalLibraryDirectories(self, root, config, gyp_to_build_path):
-    """Get and normalize the list of paths in AdditionalLibraryDirectories
+        config = self._TargetConfig(config)
+        # The PCH is only built once by a particular source file. Usage of PCH must
+        # only be for the same language (i.e. C vs. C++), so only include the pch
+        # flags when the language matches.
+        if self.msvs_precompiled_header[config]:
+            source_ext = os.path.splitext(self.msvs_precompiled_source[config])[1]
+            if _LanguageMatchesForPch(source_ext, extension):
+                pch = self.msvs_precompiled_header[config]
+                pchbase = os.path.split(pch)[1]
+                return ["/Yu" + pch, "/FI" + pch, "/Fp${pchprefix}." + pchbase + ".pch"]
+        return []
+
+    def GetCflagsC(self, config):
+        """Returns the flags that need to be added to .c compilations."""
+        config = self._TargetConfig(config)
+        return self._GetPchFlags(config, ".c")
+
+    def GetCflagsCC(self, config):
+        """Returns the flags that need to be added to .cc compilations."""
+        config = self._TargetConfig(config)
+        return ["/TP"] + self._GetPchFlags(config, ".cc")
+
+    def _GetAdditionalLibraryDirectories(self, root, config, gyp_to_build_path):
+        """Get and normalize the list of paths in AdditionalLibraryDirectories
     setting."""
-    config = self._TargetConfig(config)
-    libpaths = self._Setting((root, 'AdditionalLibraryDirectories'),
-                             config, default=[])
-    libpaths = [os.path.normpath(
-                    gyp_to_build_path(self.ConvertVSMacros(p, config=config)))
-                for p in libpaths]
-    return ['/LIBPATH:"' + p + '"' for p in libpaths]
-
-  def GetLibFlags(self, config, gyp_to_build_path):
-    """Returns the flags that need to be added to lib commands."""
-    config = self._TargetConfig(config)
-    libflags = []
-    lib = self._GetWrapper(self, self.msvs_settings[config],
-                          'VCLibrarianTool', append=libflags)
-    libflags.extend(self._GetAdditionalLibraryDirectories(
-        'VCLibrarianTool', config, gyp_to_build_path))
-    lib('LinkTimeCodeGeneration', map={'true': '/LTCG'})
-    lib('TargetMachine', map={'1': 'X86', '17': 'X64', '3': 'ARM'},
-        prefix='/MACHINE:')
-    lib('AdditionalOptions')
-    return libflags
-
-  def GetDefFile(self, gyp_to_build_path):
-    """Returns the .def file from sources, if any.  Otherwise returns None."""
-    spec = self.spec
-    if spec['type'] in ('shared_library', 'loadable_module', 'executable'):
-      def_files = [s for s in spec.get('sources', [])
-                   if s.lower().endswith('.def')]
-      if len(def_files) == 1:
-        return gyp_to_build_path(def_files[0])
-      elif len(def_files) > 1:
-        raise Exception("Multiple .def files")
-    return None
-
-  def _GetDefFileAsLdflags(self, ldflags, gyp_to_build_path):
-    """.def files get implicitly converted to a ModuleDefinitionFile for the
+        config = self._TargetConfig(config)
+        libpaths = self._Setting(
+            (root, "AdditionalLibraryDirectories"), config, default=[]
+        )
+        libpaths = [
+            os.path.normpath(gyp_to_build_path(self.ConvertVSMacros(p, config=config)))
+            for p in libpaths
+        ]
+        return ['/LIBPATH:"' + p + '"' for p in libpaths]
+
+    def GetLibFlags(self, config, gyp_to_build_path):
+        """Returns the flags that need to be added to lib commands."""
+        config = self._TargetConfig(config)
+        libflags = []
+        lib = self._GetWrapper(
+            self, self.msvs_settings[config], "VCLibrarianTool", append=libflags
+        )
+        libflags.extend(
+            self._GetAdditionalLibraryDirectories(
+                "VCLibrarianTool", config, gyp_to_build_path
+            )
+        )
+        lib("LinkTimeCodeGeneration", map={"true": "/LTCG"})
+        lib(
+            "TargetMachine",
+            map={"1": "X86", "17": "X64", "3": "ARM"},
+            prefix="/MACHINE:",
+        )
+        lib("AdditionalOptions")
+        return libflags
+
+    def GetDefFile(self, gyp_to_build_path):
+        """Returns the .def file from sources, if any.  Otherwise returns None."""
+        spec = self.spec
+        if spec["type"] in ("shared_library", "loadable_module", "executable"):
+            def_files = [
+                s for s in spec.get("sources", []) if s.lower().endswith(".def")
+            ]
+            if len(def_files) == 1:
+                return gyp_to_build_path(def_files[0])
+            elif len(def_files) > 1:
+                raise Exception("Multiple .def files")
+        return None
+
+    def _GetDefFileAsLdflags(self, ldflags, gyp_to_build_path):
+        """.def files get implicitly converted to a ModuleDefinitionFile for the
     linker in the VS generator. Emulate that behaviour here."""
-    def_file = self.GetDefFile(gyp_to_build_path)
-    if def_file:
-      ldflags.append('/DEF:"%s"' % def_file)
+        def_file = self.GetDefFile(gyp_to_build_path)
+        if def_file:
+            ldflags.append('/DEF:"%s"' % def_file)
 
-  def GetPGDName(self, config, expand_special):
-    """Gets the explicitly overridden pgd name for a target or returns None
+    def GetPGDName(self, config, expand_special):
+        """Gets the explicitly overridden pgd name for a target or returns None
     if it's not overridden."""
-    config = self._TargetConfig(config)
-    output_file = self._Setting(
-        ('VCLinkerTool', 'ProfileGuidedDatabase'), config)
-    if output_file:
-      output_file = expand_special(self.ConvertVSMacros(
-          output_file, config=config))
-    return output_file
-
-  def GetLdflags(self, config, gyp_to_build_path, expand_special,
-                 manifest_base_name, output_name, is_executable, build_dir):
-    """Returns the flags that need to be added to link commands, and the
+        config = self._TargetConfig(config)
+        output_file = self._Setting(("VCLinkerTool", "ProfileGuidedDatabase"), config)
+        if output_file:
+            output_file = expand_special(
+                self.ConvertVSMacros(output_file, config=config)
+            )
+        return output_file
+
+    def GetLdflags(
+        self,
+        config,
+        gyp_to_build_path,
+        expand_special,
+        manifest_base_name,
+        output_name,
+        is_executable,
+        build_dir,
+    ):
+        """Returns the flags that need to be added to link commands, and the
     manifest files."""
-    config = self._TargetConfig(config)
-    ldflags = []
-    ld = self._GetWrapper(self, self.msvs_settings[config],
-                          'VCLinkerTool', append=ldflags)
-    self._GetDefFileAsLdflags(ldflags, gyp_to_build_path)
-    ld('GenerateDebugInformation', map={'true': '/DEBUG'})
-    # TODO: These 'map' values come from machineTypeOption enum,
-    # and does not have an official value for ARM64 in VS2017 (yet).
-    # It needs to verify the ARM64 value when machineTypeOption is updated.
-    ld('TargetMachine', map={'1': 'X86', '17': 'X64', '3': 'ARM', '18': 'ARM64'},
-       prefix='/MACHINE:')
-    ldflags.extend(self._GetAdditionalLibraryDirectories(
-        'VCLinkerTool', config, gyp_to_build_path))
-    ld('DelayLoadDLLs', prefix='/DELAYLOAD:')
-    ld('TreatLinkerWarningAsErrors', prefix='/WX',
-       map={'true': '', 'false': ':NO'})
-    out = self.GetOutputName(config, expand_special)
-    if out:
-      ldflags.append('/OUT:' + out)
-    pdb = self.GetPDBName(config, expand_special, output_name + '.pdb')
-    if pdb:
-      ldflags.append('/PDB:' + pdb)
-    pgd = self.GetPGDName(config, expand_special)
-    if pgd:
-      ldflags.append('/PGD:' + pgd)
-    map_file = self.GetMapFileName(config, expand_special)
-    ld('GenerateMapFile', map={'true': '/MAP:' + map_file if map_file
-        else '/MAP'})
-    ld('MapExports', map={'true': '/MAPINFO:EXPORTS'})
-    ld('AdditionalOptions', prefix='')
-
-    minimum_required_version = self._Setting(
-        ('VCLinkerTool', 'MinimumRequiredVersion'), config, default='')
-    if minimum_required_version:
-      minimum_required_version = ',' + minimum_required_version
-    ld('SubSystem',
-       map={'1': 'CONSOLE%s' % minimum_required_version,
-            '2': 'WINDOWS%s' % minimum_required_version},
-       prefix='/SUBSYSTEM:')
-
-    stack_reserve_size = self._Setting(
-        ('VCLinkerTool', 'StackReserveSize'), config, default='')
-    if stack_reserve_size:
-      stack_commit_size = self._Setting(
-          ('VCLinkerTool', 'StackCommitSize'), config, default='')
-      if stack_commit_size:
-        stack_commit_size = ',' + stack_commit_size
-      ldflags.append('/STACK:%s%s' % (stack_reserve_size, stack_commit_size))
-
-    ld('TerminalServerAware', map={'1': ':NO', '2': ''}, prefix='/TSAWARE')
-    ld('LinkIncremental', map={'1': ':NO', '2': ''}, prefix='/INCREMENTAL')
-    ld('BaseAddress', prefix='/BASE:')
-    ld('FixedBaseAddress', map={'1': ':NO', '2': ''}, prefix='/FIXED')
-    ld('RandomizedBaseAddress',
-        map={'1': ':NO', '2': ''}, prefix='/DYNAMICBASE')
-    ld('DataExecutionPrevention',
-        map={'1': ':NO', '2': ''}, prefix='/NXCOMPAT')
-    ld('OptimizeReferences', map={'1': 'NOREF', '2': 'REF'}, prefix='/OPT:')
-    ld('ForceSymbolReferences', prefix='/INCLUDE:')
-    ld('EnableCOMDATFolding', map={'1': 'NOICF', '2': 'ICF'}, prefix='/OPT:')
-    ld('LinkTimeCodeGeneration',
-        map={'1': '', '2': ':PGINSTRUMENT', '3': ':PGOPTIMIZE',
-             '4': ':PGUPDATE'},
-        prefix='/LTCG')
-    ld('IgnoreDefaultLibraryNames', prefix='/NODEFAULTLIB:')
-    ld('ResourceOnlyDLL', map={'true': '/NOENTRY'})
-    ld('EntryPointSymbol', prefix='/ENTRY:')
-    ld('Profile', map={'true': '/PROFILE'})
-    ld('LargeAddressAware',
-        map={'1': ':NO', '2': ''}, prefix='/LARGEADDRESSAWARE')
-    # TODO(scottmg): This should sort of be somewhere else (not really a flag).
-    ld('AdditionalDependencies', prefix='')
-
-    if self.GetArch(config) == 'x86':
-      safeseh_default = 'true'
-    else:
-      safeseh_default = None
-    ld('ImageHasSafeExceptionHandlers',
-        map={'false': ':NO', 'true': ''}, prefix='/SAFESEH',
-        default=safeseh_default)
-
-    # If the base address is not specifically controlled, DYNAMICBASE should
-    # be on by default.
-    base_flags = filter(lambda x: 'DYNAMICBASE' in x or x == '/FIXED',
-                        ldflags)
-    if not base_flags:
-      ldflags.append('/DYNAMICBASE')
-
-    # If the NXCOMPAT flag has not been specified, default to on. Despite the
-    # documentation that says this only defaults to on when the subsystem is
-    # Vista or greater (which applies to the linker), the IDE defaults it on
-    # unless it's explicitly off.
-    if not filter(lambda x: 'NXCOMPAT' in x, ldflags):
-      ldflags.append('/NXCOMPAT')
-
-    have_def_file = filter(lambda x: x.startswith('/DEF:'), ldflags)
-    manifest_flags, intermediate_manifest, manifest_files = \
-        self._GetLdManifestFlags(config, manifest_base_name, gyp_to_build_path,
-                                 is_executable and not have_def_file, build_dir)
-    ldflags.extend(manifest_flags)
-    return ldflags, intermediate_manifest, manifest_files
-
-  def _GetLdManifestFlags(self, config, name, gyp_to_build_path,
-                          allow_isolation, build_dir):
-    """Returns a 3-tuple:
+        config = self._TargetConfig(config)
+        ldflags = []
+        ld = self._GetWrapper(
+            self, self.msvs_settings[config], "VCLinkerTool", append=ldflags
+        )
+        self._GetDefFileAsLdflags(ldflags, gyp_to_build_path)
+        ld("GenerateDebugInformation", map={"true": "/DEBUG"})
+        # TODO: These 'map' values come from machineTypeOption enum,
+        # and does not have an official value for ARM64 in VS2017 (yet).
+        # It needs to verify the ARM64 value when machineTypeOption is updated.
+        ld(
+            "TargetMachine",
+            map={"1": "X86", "17": "X64", "3": "ARM", "18": "ARM64"},
+            prefix="/MACHINE:",
+        )
+        ldflags.extend(
+            self._GetAdditionalLibraryDirectories(
+                "VCLinkerTool", config, gyp_to_build_path
+            )
+        )
+        ld("DelayLoadDLLs", prefix="/DELAYLOAD:")
+        ld("TreatLinkerWarningAsErrors", prefix="/WX", map={"true": "", "false": ":NO"})
+        out = self.GetOutputName(config, expand_special)
+        if out:
+            ldflags.append("/OUT:" + out)
+        pdb = self.GetPDBName(config, expand_special, output_name + ".pdb")
+        if pdb:
+            ldflags.append("/PDB:" + pdb)
+        pgd = self.GetPGDName(config, expand_special)
+        if pgd:
+            ldflags.append("/PGD:" + pgd)
+        map_file = self.GetMapFileName(config, expand_special)
+        ld("GenerateMapFile", map={"true": "/MAP:" + map_file if map_file else "/MAP"})
+        ld("MapExports", map={"true": "/MAPINFO:EXPORTS"})
+        ld("AdditionalOptions", prefix="")
+
+        minimum_required_version = self._Setting(
+            ("VCLinkerTool", "MinimumRequiredVersion"), config, default=""
+        )
+        if minimum_required_version:
+            minimum_required_version = "," + minimum_required_version
+        ld(
+            "SubSystem",
+            map={
+                "1": "CONSOLE%s" % minimum_required_version,
+                "2": "WINDOWS%s" % minimum_required_version,
+            },
+            prefix="/SUBSYSTEM:",
+        )
+
+        stack_reserve_size = self._Setting(
+            ("VCLinkerTool", "StackReserveSize"), config, default=""
+        )
+        if stack_reserve_size:
+            stack_commit_size = self._Setting(
+                ("VCLinkerTool", "StackCommitSize"), config, default=""
+            )
+            if stack_commit_size:
+                stack_commit_size = "," + stack_commit_size
+            ldflags.append("/STACK:%s%s" % (stack_reserve_size, stack_commit_size))
+
+        ld("TerminalServerAware", map={"1": ":NO", "2": ""}, prefix="/TSAWARE")
+        ld("LinkIncremental", map={"1": ":NO", "2": ""}, prefix="/INCREMENTAL")
+        ld("BaseAddress", prefix="/BASE:")
+        ld("FixedBaseAddress", map={"1": ":NO", "2": ""}, prefix="/FIXED")
+        ld("RandomizedBaseAddress", map={"1": ":NO", "2": ""}, prefix="/DYNAMICBASE")
+        ld("DataExecutionPrevention", map={"1": ":NO", "2": ""}, prefix="/NXCOMPAT")
+        ld("OptimizeReferences", map={"1": "NOREF", "2": "REF"}, prefix="/OPT:")
+        ld("ForceSymbolReferences", prefix="/INCLUDE:")
+        ld("EnableCOMDATFolding", map={"1": "NOICF", "2": "ICF"}, prefix="/OPT:")
+        ld(
+            "LinkTimeCodeGeneration",
+            map={"1": "", "2": ":PGINSTRUMENT", "3": ":PGOPTIMIZE", "4": ":PGUPDATE"},
+            prefix="/LTCG",
+        )
+        ld("IgnoreDefaultLibraryNames", prefix="/NODEFAULTLIB:")
+        ld("ResourceOnlyDLL", map={"true": "/NOENTRY"})
+        ld("EntryPointSymbol", prefix="/ENTRY:")
+        ld("Profile", map={"true": "/PROFILE"})
+        ld("LargeAddressAware", map={"1": ":NO", "2": ""}, prefix="/LARGEADDRESSAWARE")
+        # TODO(scottmg): This should sort of be somewhere else (not really a flag).
+        ld("AdditionalDependencies", prefix="")
+
+        if self.GetArch(config) == "x86":
+            safeseh_default = "true"
+        else:
+            safeseh_default = None
+        ld(
+            "ImageHasSafeExceptionHandlers",
+            map={"false": ":NO", "true": ""},
+            prefix="/SAFESEH",
+            default=safeseh_default,
+        )
+
+        # If the base address is not specifically controlled, DYNAMICBASE should
+        # be on by default.
+        if not any("DYNAMICBASE" in flag or flag == "/FIXED" for flag in ldflags):
+            ldflags.append("/DYNAMICBASE")
+
+        # If the NXCOMPAT flag has not been specified, default to on. Despite the
+        # documentation that says this only defaults to on when the subsystem is
+        # Vista or greater (which applies to the linker), the IDE defaults it on
+        # unless it's explicitly off.
+        if not any("NXCOMPAT" in flag for flag in ldflags):
+            ldflags.append("/NXCOMPAT")
+
+        have_def_file = any(flag.startswith("/DEF:") for flag in ldflags)
+        (
+            manifest_flags,
+            intermediate_manifest,
+            manifest_files,
+        ) = self._GetLdManifestFlags(
+            config,
+            manifest_base_name,
+            gyp_to_build_path,
+            is_executable and not have_def_file,
+            build_dir,
+        )
+        ldflags.extend(manifest_flags)
+        return ldflags, intermediate_manifest, manifest_files
+
+    def _GetLdManifestFlags(
+        self, config, name, gyp_to_build_path, allow_isolation, build_dir
+    ):
+        """Returns a 3-tuple:
     - the set of flags that need to be added to the link to generate
       a default manifest
     - the intermediate manifest that the linker will generate that should be
       used to assert it doesn't add anything to the merged one.
     - the list of all the manifest files to be merged by the manifest tool and
       included into the link."""
-    generate_manifest = self._Setting(('VCLinkerTool', 'GenerateManifest'),
-                                      config,
-                                      default='true')
-    if generate_manifest != 'true':
-      # This means not only that the linker should not generate the intermediate
-      # manifest but also that the manifest tool should do nothing even when
-      # additional manifests are specified.
-      return ['/MANIFEST:NO'], [], []
-
-    output_name = name + '.intermediate.manifest'
-    flags = [
-      '/MANIFEST',
-      '/ManifestFile:' + output_name,
-    ]
-
-    # Instead of using the MANIFESTUAC flags, we generate a .manifest to
-    # include into the list of manifests. This allows us to avoid the need to
-    # do two passes during linking. The /MANIFEST flag and /ManifestFile are
-    # still used, and the intermediate manifest is used to assert that the
-    # final manifest we get from merging all the additional manifest files
-    # (plus the one we generate here) isn't modified by merging the
-    # intermediate into it.
-
-    # Always NO, because we generate a manifest file that has what we want.
-    flags.append('/MANIFESTUAC:NO')
-
-    config = self._TargetConfig(config)
-    enable_uac = self._Setting(('VCLinkerTool', 'EnableUAC'), config,
-                               default='true')
-    manifest_files = []
-    generated_manifest_outer = \
-"<?xml version='1.0' encoding='UTF-8' standalone='yes'?>" \
-"<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>%s" \
-"</assembly>"
-    if enable_uac == 'true':
-      execution_level = self._Setting(('VCLinkerTool', 'UACExecutionLevel'),
-                                      config, default='0')
-      execution_level_map = {
-        '0': 'asInvoker',
-        '1': 'highestAvailable',
-        '2': 'requireAdministrator'
-      }
-
-      ui_access = self._Setting(('VCLinkerTool', 'UACUIAccess'), config,
-                                default='false')
-
-      inner = '''
+        generate_manifest = self._Setting(
+            ("VCLinkerTool", "GenerateManifest"), config, default="true"
+        )
+        if generate_manifest != "true":
+            # This means not only that the linker should not generate the intermediate
+            # manifest but also that the manifest tool should do nothing even when
+            # additional manifests are specified.
+            return ["/MANIFEST:NO"], [], []
+
+        output_name = name + ".intermediate.manifest"
+        flags = [
+            "/MANIFEST",
+            "/ManifestFile:" + output_name,
+        ]
+
+        # Instead of using the MANIFESTUAC flags, we generate a .manifest to
+        # include into the list of manifests. This allows us to avoid the need to
+        # do two passes during linking. The /MANIFEST flag and /ManifestFile are
+        # still used, and the intermediate manifest is used to assert that the
+        # final manifest we get from merging all the additional manifest files
+        # (plus the one we generate here) isn't modified by merging the
+        # intermediate into it.
+
+        # Always NO, because we generate a manifest file that has what we want.
+        flags.append("/MANIFESTUAC:NO")
+
+        config = self._TargetConfig(config)
+        enable_uac = self._Setting(
+            ("VCLinkerTool", "EnableUAC"), config, default="true"
+        )
+        manifest_files = []
+        generated_manifest_outer = (
+            "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>"
+            "<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>"
+            "%s</assembly>"
+        )
+        if enable_uac == "true":
+            execution_level = self._Setting(
+                ("VCLinkerTool", "UACExecutionLevel"), config, default="0"
+            )
+            execution_level_map = {
+                "0": "asInvoker",
+                "1": "highestAvailable",
+                "2": "requireAdministrator",
+            }
+
+            ui_access = self._Setting(
+                ("VCLinkerTool", "UACUIAccess"), config, default="false"
+            )
+
+            inner = """
 <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
   <security>
     <requestedPrivileges>
       <requestedExecutionLevel level='%s' uiAccess='%s' />
     </requestedPrivileges>
   </security>
-</trustInfo>''' % (execution_level_map[execution_level], ui_access)
-    else:
-      inner = ''
-
-    generated_manifest_contents = generated_manifest_outer % inner
-    generated_name = name + '.generated.manifest'
-    # Need to join with the build_dir here as we're writing it during
-    # generation time, but we return the un-joined version because the build
-    # will occur in that directory. We only write the file if the contents
-    # have changed so that simply regenerating the project files doesn't
-    # cause a relink.
-    build_dir_generated_name = os.path.join(build_dir, generated_name)
-    gyp.common.EnsureDirExists(build_dir_generated_name)
-    f = gyp.common.WriteOnDiff(build_dir_generated_name)
-    f.write(generated_manifest_contents)
-    f.close()
-    manifest_files = [generated_name]
-
-    if allow_isolation:
-      flags.append('/ALLOWISOLATION')
-
-    manifest_files += self._GetAdditionalManifestFiles(config,
-                                                       gyp_to_build_path)
-    return flags, output_name, manifest_files
-
-  def _GetAdditionalManifestFiles(self, config, gyp_to_build_path):
-    """Gets additional manifest files that are added to the default one
+</trustInfo>""" % (
+                execution_level_map[execution_level],
+                ui_access,
+            )
+        else:
+            inner = ""
+
+        generated_manifest_contents = generated_manifest_outer % inner
+        generated_name = name + ".generated.manifest"
+        # Need to join with the build_dir here as we're writing it during
+        # generation time, but we return the un-joined version because the build
+        # will occur in that directory. We only write the file if the contents
+        # have changed so that simply regenerating the project files doesn't
+        # cause a relink.
+        build_dir_generated_name = os.path.join(build_dir, generated_name)
+        gyp.common.EnsureDirExists(build_dir_generated_name)
+        f = gyp.common.WriteOnDiff(build_dir_generated_name)
+        f.write(generated_manifest_contents)
+        f.close()
+        manifest_files = [generated_name]
+
+        if allow_isolation:
+            flags.append("/ALLOWISOLATION")
+
+        manifest_files += self._GetAdditionalManifestFiles(config, gyp_to_build_path)
+        return flags, output_name, manifest_files
+
+    def _GetAdditionalManifestFiles(self, config, gyp_to_build_path):
+        """Gets additional manifest files that are added to the default one
     generated by the linker."""
-    files = self._Setting(('VCManifestTool', 'AdditionalManifestFiles'), config,
-                          default=[])
-    if isinstance(files, str):
-      files = files.split(';')
-    return [os.path.normpath(
-                gyp_to_build_path(self.ConvertVSMacros(f, config=config)))
-            for f in files]
-
-  def IsUseLibraryDependencyInputs(self, config):
-    """Returns whether the target should be linked via Use Library Dependency
+        files = self._Setting(
+            ("VCManifestTool", "AdditionalManifestFiles"), config, default=[]
+        )
+        if isinstance(files, str):
+            files = files.split(";")
+        return [
+            os.path.normpath(gyp_to_build_path(self.ConvertVSMacros(f, config=config)))
+            for f in files
+        ]
+
+    def IsUseLibraryDependencyInputs(self, config):
+        """Returns whether the target should be linked via Use Library Dependency
     Inputs (using component .objs of a given .lib)."""
-    config = self._TargetConfig(config)
-    uldi = self._Setting(('VCLinkerTool', 'UseLibraryDependencyInputs'), config)
-    return uldi == 'true'
-
-  def IsEmbedManifest(self, config):
-    """Returns whether manifest should be linked into binary."""
-    config = self._TargetConfig(config)
-    embed = self._Setting(('VCManifestTool', 'EmbedManifest'), config,
-                          default='true')
-    return embed == 'true'
-
-  def IsLinkIncremental(self, config):
-    """Returns whether the target should be linked incrementally."""
-    config = self._TargetConfig(config)
-    link_inc = self._Setting(('VCLinkerTool', 'LinkIncremental'), config)
-    return link_inc != '1'
-
-  def GetRcflags(self, config, gyp_to_ninja_path):
-    """Returns the flags that need to be added to invocations of the resource
+        config = self._TargetConfig(config)
+        uldi = self._Setting(("VCLinkerTool", "UseLibraryDependencyInputs"), config)
+        return uldi == "true"
+
+    def IsEmbedManifest(self, config):
+        """Returns whether manifest should be linked into binary."""
+        config = self._TargetConfig(config)
+        embed = self._Setting(
+            ("VCManifestTool", "EmbedManifest"), config, default="true"
+        )
+        return embed == "true"
+
+    def IsLinkIncremental(self, config):
+        """Returns whether the target should be linked incrementally."""
+        config = self._TargetConfig(config)
+        link_inc = self._Setting(("VCLinkerTool", "LinkIncremental"), config)
+        return link_inc != "1"
+
+    def GetRcflags(self, config, gyp_to_ninja_path):
+        """Returns the flags that need to be added to invocations of the resource
     compiler."""
-    config = self._TargetConfig(config)
-    rcflags = []
-    rc = self._GetWrapper(self, self.msvs_settings[config],
-        'VCResourceCompilerTool', append=rcflags)
-    rc('AdditionalIncludeDirectories', map=gyp_to_ninja_path, prefix='/I')
-    rcflags.append('/I' + gyp_to_ninja_path('.'))
-    rc('PreprocessorDefinitions', prefix='/d')
-    # /l arg must be in hex without leading '0x'
-    rc('Culture', prefix='/l', map=lambda x: hex(int(x))[2:])
-    return rcflags
-
-  def BuildCygwinBashCommandLine(self, args, path_to_base):
-    """Build a command line that runs args via cygwin bash. We assume that all
+        config = self._TargetConfig(config)
+        rcflags = []
+        rc = self._GetWrapper(
+            self, self.msvs_settings[config], "VCResourceCompilerTool", append=rcflags
+        )
+        rc("AdditionalIncludeDirectories", map=gyp_to_ninja_path, prefix="/I")
+        rcflags.append("/I" + gyp_to_ninja_path("."))
+        rc("PreprocessorDefinitions", prefix="/d")
+        # /l arg must be in hex without leading '0x'
+        rc("Culture", prefix="/l", map=lambda x: hex(int(x))[2:])
+        return rcflags
+
+    def BuildCygwinBashCommandLine(self, args, path_to_base):
+        """Build a command line that runs args via cygwin bash. We assume that all
     incoming paths are in Windows normpath'd form, so they need to be
     converted to posix style for the part of the command line that's passed to
     bash. We also have to do some Visual Studio macro emulation here because
@@ -820,216 +923,246 @@ class MsvsSettings(object):
     contain ninja variables cannot be fixed here (for example ${source}), so
     the outer generator needs to make sure that the paths that are written out
     are in posix style, if the command line will be used here."""
-    cygwin_dir = os.path.normpath(
-        os.path.join(path_to_base, self.msvs_cygwin_dirs[0]))
-    cd = ('cd %s' % path_to_base).replace('\\', '/')
-    args = [a.replace('\\', '/').replace('"', '\\"') for a in args]
-    args = ["'%s'" % a.replace("'", "'\\''") for a in args]
-    bash_cmd = ' '.join(args)
-    cmd = (
-        'call "%s\\setup_env.bat" && set CYGWIN=nontsec && ' % cygwin_dir +
-        'bash -c "%s ; %s"' % (cd, bash_cmd))
-    return cmd
-
-  def IsRuleRunUnderCygwin(self, rule):
-    """Determine if an action should be run under cygwin. If the variable is
+        cygwin_dir = os.path.normpath(
+            os.path.join(path_to_base, self.msvs_cygwin_dirs[0])
+        )
+        cd = ("cd %s" % path_to_base).replace("\\", "/")
+        args = [a.replace("\\", "/").replace('"', '\\"') for a in args]
+        args = ["'%s'" % a.replace("'", "'\\''") for a in args]
+        bash_cmd = " ".join(args)
+        cmd = (
+            'call "%s\\setup_env.bat" && set CYGWIN=nontsec && ' % cygwin_dir
+            + 'bash -c "%s ; %s"' % (cd, bash_cmd)
+        )
+        return cmd
+
+    def IsRuleRunUnderCygwin(self, rule):
+        """Determine if an action should be run under cygwin. If the variable is
     unset, or set to 1 we use cygwin."""
-    return int(rule.get('msvs_cygwin_shell',
-                        self.spec.get('msvs_cygwin_shell', 1))) != 0
-
-  def _HasExplicitRuleForExtension(self, spec, extension):
-    """Determine if there's an explicit rule for a particular extension."""
-    for rule in spec.get('rules', []):
-      if rule['extension'] == extension:
-        return True
-    return False
-
-  def _HasExplicitIdlActions(self, spec):
-    """Determine if an action should not run midl for .idl files."""
-    return any([action.get('explicit_idl_action', 0)
-                for action in spec.get('actions', [])])
-
-  def HasExplicitIdlRulesOrActions(self, spec):
-    """Determine if there's an explicit rule or action for idl files. When
+        return (
+            int(rule.get("msvs_cygwin_shell", self.spec.get("msvs_cygwin_shell", 1)))
+            != 0
+        )
+
+    def _HasExplicitRuleForExtension(self, spec, extension):
+        """Determine if there's an explicit rule for a particular extension."""
+        for rule in spec.get("rules", []):
+            if rule["extension"] == extension:
+                return True
+        return False
+
+    def _HasExplicitIdlActions(self, spec):
+        """Determine if an action should not run midl for .idl files."""
+        return any(
+            [action.get("explicit_idl_action", 0) for action in spec.get("actions", [])]
+        )
+
+    def HasExplicitIdlRulesOrActions(self, spec):
+        """Determine if there's an explicit rule or action for idl files. When
     there isn't we need to generate implicit rules to build MIDL .idl files."""
-    return (self._HasExplicitRuleForExtension(spec, 'idl') or
-            self._HasExplicitIdlActions(spec))
+        return self._HasExplicitRuleForExtension(
+            spec, "idl"
+        ) or self._HasExplicitIdlActions(spec)
 
-  def HasExplicitAsmRules(self, spec):
-    """Determine if there's an explicit rule for asm files. When there isn't we
+    def HasExplicitAsmRules(self, spec):
+        """Determine if there's an explicit rule for asm files. When there isn't we
     need to generate implicit rules to assemble .asm files."""
-    return self._HasExplicitRuleForExtension(spec, 'asm')
+        return self._HasExplicitRuleForExtension(spec, "asm")
 
-  def GetIdlBuildData(self, source, config):
-    """Determine the implicit outputs for an idl file. Returns output
+    def GetIdlBuildData(self, source, config):
+        """Determine the implicit outputs for an idl file. Returns output
     directory, outputs, and variables and flags that are required."""
-    config = self._TargetConfig(config)
-    midl_get = self._GetWrapper(self, self.msvs_settings[config], 'VCMIDLTool')
-    def midl(name, default=None):
-      return self.ConvertVSMacros(midl_get(name, default=default),
-                                  config=config)
-    tlb = midl('TypeLibraryName', default='${root}.tlb')
-    header = midl('HeaderFileName', default='${root}.h')
-    dlldata = midl('DLLDataFileName', default='dlldata.c')
-    iid = midl('InterfaceIdentifierFileName', default='${root}_i.c')
-    proxy = midl('ProxyFileName', default='${root}_p.c')
-    # Note that .tlb is not included in the outputs as it is not always
-    # generated depending on the content of the input idl file.
-    outdir = midl('OutputDirectory', default='')
-    output = [header, dlldata, iid, proxy]
-    variables = [('tlb', tlb),
-                 ('h', header),
-                 ('dlldata', dlldata),
-                 ('iid', iid),
-                 ('proxy', proxy)]
-    # TODO(scottmg): Are there configuration settings to set these flags?
-    target_platform = self.GetArch(config)
-    if target_platform == 'x86':
-      target_platform = 'win32'
-    flags = ['/char', 'signed', '/env', target_platform, '/Oicf']
-    return outdir, output, variables, flags
+        config = self._TargetConfig(config)
+        midl_get = self._GetWrapper(self, self.msvs_settings[config], "VCMIDLTool")
+
+        def midl(name, default=None):
+            return self.ConvertVSMacros(midl_get(name, default=default), config=config)
+
+        tlb = midl("TypeLibraryName", default="${root}.tlb")
+        header = midl("HeaderFileName", default="${root}.h")
+        dlldata = midl("DLLDataFileName", default="dlldata.c")
+        iid = midl("InterfaceIdentifierFileName", default="${root}_i.c")
+        proxy = midl("ProxyFileName", default="${root}_p.c")
+        # Note that .tlb is not included in the outputs as it is not always
+        # generated depending on the content of the input idl file.
+        outdir = midl("OutputDirectory", default="")
+        output = [header, dlldata, iid, proxy]
+        variables = [
+            ("tlb", tlb),
+            ("h", header),
+            ("dlldata", dlldata),
+            ("iid", iid),
+            ("proxy", proxy),
+        ]
+        # TODO(scottmg): Are there configuration settings to set these flags?
+        target_platform = self.GetArch(config)
+        if target_platform == "x86":
+            target_platform = "win32"
+        flags = ["/char", "signed", "/env", target_platform, "/Oicf"]
+        return outdir, output, variables, flags
 
 
 def _LanguageMatchesForPch(source_ext, pch_source_ext):
-  c_exts = ('.c',)
-  cc_exts = ('.cc', '.cxx', '.cpp')
-  return ((source_ext in c_exts and pch_source_ext in c_exts) or
-          (source_ext in cc_exts and pch_source_ext in cc_exts))
+    c_exts = (".c",)
+    cc_exts = (".cc", ".cxx", ".cpp")
+    return (source_ext in c_exts and pch_source_ext in c_exts) or (
+        source_ext in cc_exts and pch_source_ext in cc_exts
+    )
 
 
 class PrecompiledHeader(object):
-  """Helper to generate dependencies and build rules to handle generation of
+    """Helper to generate dependencies and build rules to handle generation of
   precompiled headers. Interface matches the GCH handler in xcode_emulation.py.
   """
-  def __init__(
-      self, settings, config, gyp_to_build_path, gyp_to_unique_output, obj_ext):
-    self.settings = settings
-    self.config = config
-    pch_source = self.settings.msvs_precompiled_source[self.config]
-    self.pch_source = gyp_to_build_path(pch_source)
-    filename, _ = os.path.splitext(pch_source)
-    self.output_obj = gyp_to_unique_output(filename + obj_ext).lower()
-
-  def _PchHeader(self):
-    """Get the header that will appear in an #include line for all source
+
+    def __init__(
+        self, settings, config, gyp_to_build_path, gyp_to_unique_output, obj_ext
+    ):
+        self.settings = settings
+        self.config = config
+        pch_source = self.settings.msvs_precompiled_source[self.config]
+        self.pch_source = gyp_to_build_path(pch_source)
+        filename, _ = os.path.splitext(pch_source)
+        self.output_obj = gyp_to_unique_output(filename + obj_ext).lower()
+
+    def _PchHeader(self):
+        """Get the header that will appear in an #include line for all source
     files."""
-    return self.settings.msvs_precompiled_header[self.config]
+        return self.settings.msvs_precompiled_header[self.config]
 
-  def GetObjDependencies(self, sources, objs, arch):
-    """Given a list of sources files and the corresponding object files,
+    def GetObjDependencies(self, sources, objs, arch):
+        """Given a list of sources files and the corresponding object files,
     returns a list of the pch files that should be depended upon. The
     additional wrapping in the return value is for interface compatibility
     with make.py on Mac, and xcode_emulation.py."""
-    assert arch is None
-    if not self._PchHeader():
-      return []
-    pch_ext = os.path.splitext(self.pch_source)[1]
-    for source in sources:
-      if _LanguageMatchesForPch(os.path.splitext(source)[1], pch_ext):
-        return [(None, None, self.output_obj)]
-    return []
-
-  def GetPchBuildCommands(self, arch):
-    """Not used on Windows as there are no additional build steps required
+        assert arch is None
+        if not self._PchHeader():
+            return []
+        pch_ext = os.path.splitext(self.pch_source)[1]
+        for source in sources:
+            if _LanguageMatchesForPch(os.path.splitext(source)[1], pch_ext):
+                return [(None, None, self.output_obj)]
+        return []
+
+    def GetPchBuildCommands(self, arch):
+        """Not used on Windows as there are no additional build steps required
     (instead, existing steps are modified in GetFlagsModifications below)."""
-    return []
+        return []
 
-  def GetFlagsModifications(self, input, output, implicit, command,
-                            cflags_c, cflags_cc, expand_special):
-    """Get the modified cflags and implicit dependencies that should be used
+    def GetFlagsModifications(
+        self, input, output, implicit, command, cflags_c, cflags_cc, expand_special
+    ):
+        """Get the modified cflags and implicit dependencies that should be used
     for the pch compilation step."""
-    if input == self.pch_source:
-      pch_output = ['/Yc' + self._PchHeader()]
-      if command == 'cxx':
-        return ([('cflags_cc', map(expand_special, cflags_cc + pch_output))],
-                self.output_obj, [])
-      elif command == 'cc':
-        return ([('cflags_c', map(expand_special, cflags_c + pch_output))],
-                self.output_obj, [])
-    return [], output, implicit
+        if input == self.pch_source:
+            pch_output = ["/Yc" + self._PchHeader()]
+            if command == "cxx":
+                return (
+                    [("cflags_cc", map(expand_special, cflags_cc + pch_output))],
+                    self.output_obj,
+                    [],
+                )
+            elif command == "cc":
+                return (
+                    [("cflags_c", map(expand_special, cflags_c + pch_output))],
+                    self.output_obj,
+                    [],
+                )
+        return [], output, implicit
 
 
 vs_version = None
+
+
 def GetVSVersion(generator_flags):
-  global vs_version
-  if not vs_version:
-    vs_version = gyp.MSVSVersion.SelectVisualStudioVersion(
-        generator_flags.get('msvs_version', 'auto'),
-        allow_fallback=False)
-  return vs_version
+    global vs_version
+    if not vs_version:
+        vs_version = gyp.MSVSVersion.SelectVisualStudioVersion(
+            generator_flags.get("msvs_version", "auto"), allow_fallback=False
+        )
+    return vs_version
+
 
 def _GetVsvarsSetupArgs(generator_flags, arch):
-  vs = GetVSVersion(generator_flags)
-  return vs.SetupScript()
+    vs = GetVSVersion(generator_flags)
+    return vs.SetupScript()
+
 
 def ExpandMacros(string, expansions):
-  """Expand $(Variable) per expansions dict. See MsvsSettings.GetVSMacroEnv
+    """Expand $(Variable) per expansions dict. See MsvsSettings.GetVSMacroEnv
   for the canonical way to retrieve a suitable dict."""
-  if '$' in string:
-    for old, new in expansions.items():
-      assert '$(' not in new, new
-      string = string.replace(old, new)
-  return string
+    if "$" in string:
+        for old, new in expansions.items():
+            assert "$(" not in new, new
+            string = string.replace(old, new)
+    return string
+
 
 def _ExtractImportantEnvironment(output_of_set):
-  """Extracts environment variables required for the toolchain to run from
+    """Extracts environment variables required for the toolchain to run from
   a textual dump output by the cmd.exe 'set' command."""
-  envvars_to_save = (
-      'goma_.*', # TODO(scottmg): This is ugly, but needed for goma.
-      'include',
-      'lib',
-      'libpath',
-      'path',
-      'pathext',
-      'systemroot',
-      'temp',
-      'tmp',
-      )
-  env = {}
-  # This occasionally happens and leads to misleading SYSTEMROOT error messages
-  # if not caught here.
-  if output_of_set.count('=') == 0:
-    raise Exception('Invalid output_of_set. Value is:\n%s' % output_of_set)
-  for line in output_of_set.splitlines():
-    for envvar in envvars_to_save:
-      if re.match(envvar + '=', line.lower()):
-        var, setting = line.split('=', 1)
-        if envvar == 'path':
-          # Our own rules (for running gyp-win-tool) and other actions in
-          # Chromium rely on python being in the path. Add the path to this
-          # python here so that if it's not in the path when ninja is run
-          # later, python will still be found.
-          setting = os.path.dirname(sys.executable) + os.pathsep + setting
-        env[var.upper()] = setting
-        break
-  for required in ('SYSTEMROOT', 'TEMP', 'TMP'):
-    if required not in env:
-      raise Exception('Environment variable "%s" '
-                      'required to be set to valid path' % required)
-  return env
+    envvars_to_save = (
+        "goma_.*",  # TODO(scottmg): This is ugly, but needed for goma.
+        "include",
+        "lib",
+        "libpath",
+        "path",
+        "pathext",
+        "systemroot",
+        "temp",
+        "tmp",
+    )
+    env = {}
+    # This occasionally happens and leads to misleading SYSTEMROOT error messages
+    # if not caught here.
+    if output_of_set.count("=") == 0:
+        raise Exception("Invalid output_of_set. Value is:\n%s" % output_of_set)
+    for line in output_of_set.splitlines():
+        for envvar in envvars_to_save:
+            if re.match(envvar + "=", line.lower()):
+                var, setting = line.split("=", 1)
+                if envvar == "path":
+                    # Our own rules (for running gyp-win-tool) and other actions in
+                    # Chromium rely on python being in the path. Add the path to this
+                    # python here so that if it's not in the path when ninja is run
+                    # later, python will still be found.
+                    setting = os.path.dirname(sys.executable) + os.pathsep + setting
+                env[var.upper()] = setting
+                break
+    for required in ("SYSTEMROOT", "TEMP", "TMP"):
+        if required not in env:
+            raise Exception(
+                'Environment variable "%s" '
+                "required to be set to valid path" % required
+            )
+    return env
+
 
 def _FormatAsEnvironmentBlock(envvar_dict):
-  """Format as an 'environment block' directly suitable for CreateProcess.
+    """Format as an 'environment block' directly suitable for CreateProcess.
   Briefly this is a list of key=value\0, terminated by an additional \0. See
   CreateProcess documentation for more details."""
-  block = ''
-  nul = '\0'
-  for key, value in envvar_dict.items():
-    block += key + '=' + value + nul
-  block += nul
-  return block
+    block = ""
+    nul = "\0"
+    for key, value in envvar_dict.items():
+        block += key + "=" + value + nul
+    block += nul
+    return block
+
 
 def _ExtractCLPath(output_of_where):
-  """Gets the path to cl.exe based on the output of calling the environment
+    """Gets the path to cl.exe based on the output of calling the environment
   setup batch file, followed by the equivalent of `where`."""
-  # Take the first line, as that's the first found in the PATH.
-  for line in output_of_where.strip().splitlines():
-    if line.startswith('LOC:'):
-      return line[len('LOC:'):].strip()
-
-def GenerateEnvironmentFiles(toplevel_build_dir, generator_flags,
-                             system_includes, open_out):
-  """It's not sufficient to have the absolute path to the compiler, linker,
+    # Take the first line, as that's the first found in the PATH.
+    for line in output_of_where.strip().splitlines():
+        if line.startswith("LOC:"):
+            return line[len("LOC:") :].strip()
+
+
+def GenerateEnvironmentFiles(
+    toplevel_build_dir, generator_flags, system_includes, open_out
+):
+    """It's not sufficient to have the absolute path to the compiler, linker,
   etc. on Windows, as those tools rely on .dlls being in the PATH. We also
   need to support both x86 and x64 compilers within the same build (to support
   msvs_target_platform hackery). Different architectures require a different
@@ -1043,80 +1176,86 @@ def GenerateEnvironmentFiles(toplevel_build_dir, generator_flags,
   meet your requirement (e.g. for custom toolchains), you can pass
   "-G ninja_use_custom_environment_files" to the gyp to suppress file
   generation and use custom environment files prepared by yourself."""
-  archs = ('x86', 'x64')
-  if generator_flags.get('ninja_use_custom_environment_files', 0):
+    archs = ("x86", "x64")
+    if generator_flags.get("ninja_use_custom_environment_files", 0):
+        cl_paths = {}
+        for arch in archs:
+            cl_paths[arch] = "cl.exe"
+        return cl_paths
+    vs = GetVSVersion(generator_flags)
     cl_paths = {}
     for arch in archs:
-      cl_paths[arch] = 'cl.exe'
+        # Extract environment variables for subprocesses.
+        args = vs.SetupScript(arch)
+        args.extend(("&&", "set"))
+        popen = subprocess.Popen(
+            args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        variables, _ = popen.communicate()
+        if PY3:
+            variables = variables.decode("utf-8")
+        if popen.returncode != 0:
+            raise Exception('"%s" failed with error %d' % (args, popen.returncode))
+        env = _ExtractImportantEnvironment(variables)
+
+        # Inject system includes from gyp files into INCLUDE.
+        if system_includes:
+            system_includes = system_includes | OrderedSet(
+                env.get("INCLUDE", "").split(";")
+            )
+            env["INCLUDE"] = ";".join(system_includes)
+
+        env_block = _FormatAsEnvironmentBlock(env)
+        f = open_out(os.path.join(toplevel_build_dir, "environment." + arch), "w")
+        f.write(env_block)
+        f.close()
+
+        # Find cl.exe location for this architecture.
+        args = vs.SetupScript(arch)
+        args.extend(
+            ("&&", "for", "%i", "in", "(cl.exe)", "do", "@echo", "LOC:%~$PATH:i")
+        )
+        popen = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE)
+        output, _ = popen.communicate()
+        if PY3:
+            output = output.decode("utf-8")
+        cl_paths[arch] = _ExtractCLPath(output)
     return cl_paths
-  vs = GetVSVersion(generator_flags)
-  cl_paths = {}
-  for arch in archs:
-    # Extract environment variables for subprocesses.
-    args = vs.SetupScript(arch)
-    args.extend(('&&', 'set'))
-    popen = subprocess.Popen(
-        args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    variables, _ = popen.communicate()
-    if PY3:
-      variables = variables.decode('utf-8')
-    if popen.returncode != 0:
-      raise Exception('"%s" failed with error %d' % (args, popen.returncode))
-    env = _ExtractImportantEnvironment(variables)
-
-    # Inject system includes from gyp files into INCLUDE.
-    if system_includes:
-      system_includes = system_includes | OrderedSet(
-                                              env.get('INCLUDE', '').split(';'))
-      env['INCLUDE'] = ';'.join(system_includes)
-
-    env_block = _FormatAsEnvironmentBlock(env)
-    f = open_out(os.path.join(toplevel_build_dir, 'environment.' + arch), 'wb')
-    f.write(env_block)
-    f.close()
-
-    # Find cl.exe location for this architecture.
-    args = vs.SetupScript(arch)
-    args.extend(('&&',
-      'for', '%i', 'in', '(cl.exe)', 'do', '@echo', 'LOC:%~$PATH:i'))
-    popen = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE)
-    output, _ = popen.communicate()
-    if PY3:
-      output = output.decode('utf-8')
-    cl_paths[arch] = _ExtractCLPath(output)
-  return cl_paths
+
 
 def VerifyMissingSources(sources, build_dir, generator_flags, gyp_to_ninja):
-  """Emulate behavior of msvs_error_on_missing_sources present in the msvs
+    """Emulate behavior of msvs_error_on_missing_sources present in the msvs
   generator: Check that all regular source files, i.e. not created at run time,
   exist on disk. Missing files cause needless recompilation when building via
   VS, and we want this check to match for people/bots that build using ninja,
   so they're not surprised when the VS build fails."""
-  if int(generator_flags.get('msvs_error_on_missing_sources', 0)):
-    no_specials = filter(lambda x: '$' not in x, sources)
-    relative = [os.path.join(build_dir, gyp_to_ninja(s)) for s in no_specials]
-    missing = filter(lambda x: not os.path.exists(x), relative)
-    if missing:
-      # They'll look like out\Release\..\..\stuff\things.cc, so normalize the
-      # path for a slightly less crazy looking output.
-      cleaned_up = [os.path.normpath(x) for x in missing]
-      raise Exception('Missing input files:\n%s' % '\n'.join(cleaned_up))
+    if int(generator_flags.get("msvs_error_on_missing_sources", 0)):
+        no_specials = filter(lambda x: "$" not in x, sources)
+        relative = [os.path.join(build_dir, gyp_to_ninja(s)) for s in no_specials]
+        missing = [x for x in relative if not os.path.exists(x)]
+        if missing:
+            # They'll look like out\Release\..\..\stuff\things.cc, so normalize the
+            # path for a slightly less crazy looking output.
+            cleaned_up = [os.path.normpath(x) for x in missing]
+            raise Exception("Missing input files:\n%s" % "\n".join(cleaned_up))
+
 
 # Sets some values in default_variables, which are required for many
 # generators, run on Windows.
 def CalculateCommonVariables(default_variables, params):
-  generator_flags = params.get('generator_flags', {})
-
-  # Set a variable so conditions can be based on msvs_version.
-  msvs_version = gyp.msvs_emulation.GetVSVersion(generator_flags)
-  default_variables['MSVS_VERSION'] = msvs_version.ShortName()
-
-  # To determine processor word size on Windows, in addition to checking
-  # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
-  # process), it is also necessary to check PROCESSOR_ARCHITEW6432 (which
-  # contains the actual word size of the system when running thru WOW64).
-  if ('64' in os.environ.get('PROCESSOR_ARCHITECTURE', '') or
-      '64' in os.environ.get('PROCESSOR_ARCHITEW6432', '')):
-    default_variables['MSVS_OS_BITS'] = 64
-  else:
-    default_variables['MSVS_OS_BITS'] = 32
+    generator_flags = params.get("generator_flags", {})
+
+    # Set a variable so conditions can be based on msvs_version.
+    msvs_version = gyp.msvs_emulation.GetVSVersion(generator_flags)
+    default_variables["MSVS_VERSION"] = msvs_version.ShortName()
+
+    # To determine processor word size on Windows, in addition to checking
+    # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
+    # process), it is also necessary to check PROCESSOR_ARCHITEW6432 (which
+    # contains the actual word size of the system when running thru WOW64).
+    if "64" in os.environ.get("PROCESSOR_ARCHITECTURE", "") or "64" in os.environ.get(
+        "PROCESSOR_ARCHITEW6432", ""
+    ):
+        default_variables["MSVS_OS_BITS"] = 64
+    else:
+        default_variables["MSVS_OS_BITS"] = 32
diff --git a/tools/gyp/pylib/gyp/ninja_syntax.py b/tools/gyp/pylib/gyp/ninja_syntax.py
index d2948f06c08e36a8347a04bedc807413e0fbc05f..14212358082a622e7a49f187c338a502f952ce6d 100644
--- a/tools/gyp/pylib/gyp/ninja_syntax.py
+++ b/tools/gyp/pylib/gyp/ninja_syntax.py
@@ -10,10 +10,11 @@ use Python.
 """
 
 import textwrap
-import re
+
 
 def escape_path(word):
-    return word.replace('$ ','$$ ').replace(' ','$ ').replace(':', '$:')
+    return word.replace("$ ", "$$ ").replace(" ", "$ ").replace(":", "$:")
+
 
 class Writer(object):
     def __init__(self, output, width=78):
@@ -21,47 +22,58 @@ class Writer(object):
         self.width = width
 
     def newline(self):
-        self.output.write('\n')
+        self.output.write("\n")
 
     def comment(self, text):
         for line in textwrap.wrap(text, self.width - 2):
-            self.output.write('# ' + line + '\n')
+            self.output.write("# " + line + "\n")
 
     def variable(self, key, value, indent=0):
         if value is None:
             return
         if isinstance(value, list):
-            value = ' '.join(filter(None, value))  # Filter out empty strings.
-        self._line('%s = %s' % (key, value), indent)
+            value = " ".join(filter(None, value))  # Filter out empty strings.
+        self._line("%s = %s" % (key, value), indent)
 
     def pool(self, name, depth):
-        self._line('pool %s' % name)
-        self.variable('depth', depth, indent=1)
-
-    def rule(self, name, command, description=None, depfile=None,
-             generator=False, pool=None, restat=False, rspfile=None,
-             rspfile_content=None, deps=None):
-        self._line('rule %s' % name)
-        self.variable('command', command, indent=1)
+        self._line("pool %s" % name)
+        self.variable("depth", depth, indent=1)
+
+    def rule(
+        self,
+        name,
+        command,
+        description=None,
+        depfile=None,
+        generator=False,
+        pool=None,
+        restat=False,
+        rspfile=None,
+        rspfile_content=None,
+        deps=None,
+    ):
+        self._line("rule %s" % name)
+        self.variable("command", command, indent=1)
         if description:
-            self.variable('description', description, indent=1)
+            self.variable("description", description, indent=1)
         if depfile:
-            self.variable('depfile', depfile, indent=1)
+            self.variable("depfile", depfile, indent=1)
         if generator:
-            self.variable('generator', '1', indent=1)
+            self.variable("generator", "1", indent=1)
         if pool:
-            self.variable('pool', pool, indent=1)
+            self.variable("pool", pool, indent=1)
         if restat:
-            self.variable('restat', '1', indent=1)
+            self.variable("restat", "1", indent=1)
         if rspfile:
-            self.variable('rspfile', rspfile, indent=1)
+            self.variable("rspfile", rspfile, indent=1)
         if rspfile_content:
-            self.variable('rspfile_content', rspfile_content, indent=1)
+            self.variable("rspfile_content", rspfile_content, indent=1)
         if deps:
-            self.variable('deps', deps, indent=1)
+            self.variable("deps", deps, indent=1)
 
-    def build(self, outputs, rule, inputs=None, implicit=None, order_only=None,
-              variables=None):
+    def build(
+        self, outputs, rule, inputs=None, implicit=None, order_only=None, variables=None
+    ):
         outputs = self._as_list(outputs)
         all_inputs = self._as_list(inputs)[:]
         out_outputs = list(map(escape_path, outputs))
@@ -69,15 +81,16 @@ class Writer(object):
 
         if implicit:
             implicit = map(escape_path, self._as_list(implicit))
-            all_inputs.append('|')
+            all_inputs.append("|")
             all_inputs.extend(implicit)
         if order_only:
             order_only = map(escape_path, self._as_list(order_only))
-            all_inputs.append('||')
+            all_inputs.append("||")
             all_inputs.extend(order_only)
 
-        self._line('build %s: %s' % (' '.join(out_outputs),
-                                        ' '.join([rule] + all_inputs)))
+        self._line(
+            "build %s: %s" % (" ".join(out_outputs), " ".join([rule] + all_inputs))
+        )
 
         if variables:
             if isinstance(variables, dict):
@@ -91,58 +104,59 @@ class Writer(object):
         return outputs
 
     def include(self, path):
-        self._line('include %s' % path)
+        self._line("include %s" % path)
 
     def subninja(self, path):
-        self._line('subninja %s' % path)
+        self._line("subninja %s" % path)
 
     def default(self, paths):
-        self._line('default %s' % ' '.join(self._as_list(paths)))
+        self._line("default %s" % " ".join(self._as_list(paths)))
 
     def _count_dollars_before_index(self, s, i):
-      """Returns the number of '$' characters right in front of s[i]."""
-      dollar_count = 0
-      dollar_index = i - 1
-      while dollar_index > 0 and s[dollar_index] == '$':
-        dollar_count += 1
-        dollar_index -= 1
-      return dollar_count
+        """Returns the number of '$' characters right in front of s[i]."""
+        dollar_count = 0
+        dollar_index = i - 1
+        while dollar_index > 0 and s[dollar_index] == "$":
+            dollar_count += 1
+            dollar_index -= 1
+        return dollar_count
 
     def _line(self, text, indent=0):
         """Write 'text' word-wrapped at self.width characters."""
-        leading_space = '  ' * indent
+        leading_space = "  " * indent
         while len(leading_space) + len(text) > self.width:
             # The text is too wide; wrap if possible.
 
             # Find the rightmost space that would obey our width constraint and
             # that's not an escaped space.
-            available_space = self.width - len(leading_space) - len(' $')
+            available_space = self.width - len(leading_space) - len(" $")
             space = available_space
             while True:
-              space = text.rfind(' ', 0, space)
-              if space < 0 or \
-                 self._count_dollars_before_index(text, space) % 2 == 0:
-                break
+                space = text.rfind(" ", 0, space)
+                if space < 0 or self._count_dollars_before_index(text, space) % 2 == 0:
+                    break
 
             if space < 0:
                 # No such space; just use the first unescaped space we can find.
                 space = available_space - 1
                 while True:
-                  space = text.find(' ', space + 1)
-                  if space < 0 or \
-                     self._count_dollars_before_index(text, space) % 2 == 0:
-                    break
+                    space = text.find(" ", space + 1)
+                    if (
+                        space < 0
+                        or self._count_dollars_before_index(text, space) % 2 == 0
+                    ):
+                        break
             if space < 0:
                 # Give up on breaking.
                 break
 
-            self.output.write(leading_space + text[0:space] + ' $\n')
-            text = text[space+1:]
+            self.output.write(leading_space + text[0:space] + " $\n")
+            text = text[space + 1 :]
 
             # Subsequent lines are continuations, so indent them.
-            leading_space = '  ' * (indent+2)
+            leading_space = "  " * (indent + 2)
 
-        self.output.write(leading_space + text + '\n')
+        self.output.write(leading_space + text + "\n")
 
     def _as_list(self, input):
         if input is None:
@@ -155,6 +169,6 @@ class Writer(object):
 def escape(string):
     """Escape a string such that it can be embedded into a Ninja file without
     further interpretation."""
-    assert '\n' not in string, 'Ninja syntax does not allow newlines'
+    assert "\n" not in string, "Ninja syntax does not allow newlines"
     # We only have one special metacharacter: '$'.
-    return string.replace('$', '$$')
+    return string.replace("$", "$$")
diff --git a/tools/gyp/pylib/gyp/simple_copy.py b/tools/gyp/pylib/gyp/simple_copy.py
index 94a6f17dab5d1c294e5978f91a98dd6dd0e775c9..e01106f9c4821a1f974f29f340d7cbe6f609d09a 100644
--- a/tools/gyp/pylib/gyp/simple_copy.py
+++ b/tools/gyp/pylib/gyp/simple_copy.py
@@ -7,44 +7,58 @@ structures or complex types except for dicts and lists. This is
 because gyp copies so large structure that small copy overhead ends up
 taking seconds in a project the size of Chromium."""
 
+
 class Error(Exception):
-  pass
+    pass
+
 
 __all__ = ["Error", "deepcopy"]
 
+
 def deepcopy(x):
-  """Deep copy operation on gyp objects such as strings, ints, dicts
+    """Deep copy operation on gyp objects such as strings, ints, dicts
   and lists. More than twice as fast as copy.deepcopy but much less
   generic."""
 
-  try:
-    return _deepcopy_dispatch[type(x)](x)
-  except KeyError:
-    raise Error('Unsupported type %s for deepcopy. Use copy.deepcopy ' +
-                'or expand simple_copy support.' % type(x))
+    try:
+        return _deepcopy_dispatch[type(x)](x)
+    except KeyError:
+        raise Error(
+            "Unsupported type %s for deepcopy. Use copy.deepcopy "
+            + "or expand simple_copy support." % type(x)
+        )
+
 
 _deepcopy_dispatch = d = {}
 
+
 def _deepcopy_atomic(x):
-  return x
+    return x
+
 
 try:
-  types = bool, float, int, str, type, type(None), long, unicode
+    types = bool, float, int, str, type, type(None), long, unicode
 except NameError:  # Python 3
-  types = bool, float, int, str, type, type(None)
+    types = bool, float, int, str, type, type(None)
 
 for x in types:
-  d[x] = _deepcopy_atomic
+    d[x] = _deepcopy_atomic
+
 
 def _deepcopy_list(x):
-  return [deepcopy(a) for a in x]
+    return [deepcopy(a) for a in x]
+
+
 d[list] = _deepcopy_list
 
+
 def _deepcopy_dict(x):
-  y = {}
-  for key, value in x.items():
-    y[deepcopy(key)] = deepcopy(value)
-  return y
+    y = {}
+    for key, value in x.items():
+        y[deepcopy(key)] = deepcopy(value)
+    return y
+
+
 d[dict] = _deepcopy_dict
 
 del d
diff --git a/tools/gyp/pylib/gyp/win_tool.py b/tools/gyp/pylib/gyp/win_tool.py
index cfdacb0d7ccd104350502dc30189036968862f37..758e9f5c456221e5f07fe71c6e048dc1cb1289ee 100755
--- a/tools/gyp/pylib/gyp/win_tool.py
+++ b/tools/gyp/pylib/gyp/win_tool.py
@@ -24,312 +24,362 @@ PY3 = bytes != str
 
 # A regex matching an argument corresponding to the output filename passed to
 # link.exe.
-_LINK_EXE_OUT_ARG = re.compile('/OUT:(?P<out>.+)$', re.IGNORECASE)
+_LINK_EXE_OUT_ARG = re.compile("/OUT:(?P<out>.+)$", re.IGNORECASE)
+
 
 def main(args):
-  executor = WinTool()
-  exit_code = executor.Dispatch(args)
-  if exit_code is not None:
-    sys.exit(exit_code)
+    executor = WinTool()
+    exit_code = executor.Dispatch(args)
+    if exit_code is not None:
+        sys.exit(exit_code)
 
 
 class WinTool(object):
-  """This class performs all the Windows tooling steps. The methods can either
+    """This class performs all the Windows tooling steps. The methods can either
   be executed directly, or dispatched from an argument list."""
 
-  def _UseSeparateMspdbsrv(self, env, args):
-    """Allows to use a unique instance of mspdbsrv.exe per linker instead of a
+    def _UseSeparateMspdbsrv(self, env, args):
+        """Allows to use a unique instance of mspdbsrv.exe per linker instead of a
     shared one."""
-    if len(args) < 1:
-      raise Exception("Not enough arguments")
-
-    if args[0] != 'link.exe':
-      return
-
-    # Use the output filename passed to the linker to generate an endpoint name
-    # for mspdbsrv.exe.
-    endpoint_name = None
-    for arg in args:
-      m = _LINK_EXE_OUT_ARG.match(arg)
-      if m:
-        endpoint_name = re.sub(r'\W+', '',
-            '%s_%d' % (m.group('out'), os.getpid()))
-        break
-
-    if endpoint_name is None:
-      return
-
-    # Adds the appropriate environment variable. This will be read by link.exe
-    # to know which instance of mspdbsrv.exe it should connect to (if it's
-    # not set then the default endpoint is used).
-    env['_MSPDBSRV_ENDPOINT_'] = endpoint_name
-
-  def Dispatch(self, args):
-    """Dispatches a string command to a method."""
-    if len(args) < 1:
-      raise Exception("Not enough arguments")
-
-    method = "Exec%s" % self._CommandifyName(args[0])
-    return getattr(self, method)(*args[1:])
-
-  def _CommandifyName(self, name_string):
-    """Transforms a tool name like recursive-mirror to RecursiveMirror."""
-    return name_string.title().replace('-', '')
-
-  def _GetEnv(self, arch):
-    """Gets the saved environment from a file for a given architecture."""
-    # The environment is saved as an "environment block" (see CreateProcess
-    # and msvs_emulation for details). We convert to a dict here.
-    # Drop last 2 NULs, one for list terminator, one for trailing vs. separator.
-    pairs = open(arch).read()[:-2].split('\0')
-    kvs = [item.split('=', 1) for item in pairs]
-    return dict(kvs)
-
-  def ExecStamp(self, path):
-    """Simple stamp command."""
-    open(path, 'w').close()
-
-  def ExecRecursiveMirror(self, source, dest):
-    """Emulation of rm -rf out && cp -af in out."""
-    if os.path.exists(dest):
-      if os.path.isdir(dest):
-        def _on_error(fn, path, excinfo):
-          # The operation failed, possibly because the file is set to
-          # read-only. If that's why, make it writable and try the op again.
-          if not os.access(path, os.W_OK):
-            os.chmod(path, stat.S_IWRITE)
-          fn(path)
-        shutil.rmtree(dest, onerror=_on_error)
-      else:
-        if not os.access(dest, os.W_OK):
-          # Attempt to make the file writable before deleting it.
-          os.chmod(dest, stat.S_IWRITE)
-        os.unlink(dest)
-
-    if os.path.isdir(source):
-      shutil.copytree(source, dest)
-    else:
-      shutil.copy2(source, dest)
-
-  def ExecLinkWrapper(self, arch, use_separate_mspdbsrv, *args):
-    """Filter diagnostic output from link that looks like:
+        if len(args) < 1:
+            raise Exception("Not enough arguments")
+
+        if args[0] != "link.exe":
+            return
+
+        # Use the output filename passed to the linker to generate an endpoint name
+        # for mspdbsrv.exe.
+        endpoint_name = None
+        for arg in args:
+            m = _LINK_EXE_OUT_ARG.match(arg)
+            if m:
+                endpoint_name = re.sub(
+                    r"\W+", "", "%s_%d" % (m.group("out"), os.getpid())
+                )
+                break
+
+        if endpoint_name is None:
+            return
+
+        # Adds the appropriate environment variable. This will be read by link.exe
+        # to know which instance of mspdbsrv.exe it should connect to (if it's
+        # not set then the default endpoint is used).
+        env["_MSPDBSRV_ENDPOINT_"] = endpoint_name
+
+    def Dispatch(self, args):
+        """Dispatches a string command to a method."""
+        if len(args) < 1:
+            raise Exception("Not enough arguments")
+
+        method = "Exec%s" % self._CommandifyName(args[0])
+        return getattr(self, method)(*args[1:])
+
+    def _CommandifyName(self, name_string):
+        """Transforms a tool name like recursive-mirror to RecursiveMirror."""
+        return name_string.title().replace("-", "")
+
+    def _GetEnv(self, arch):
+        """Gets the saved environment from a file for a given architecture."""
+        # The environment is saved as an "environment block" (see CreateProcess
+        # and msvs_emulation for details). We convert to a dict here.
+        # Drop last 2 NULs, one for list terminator, one for trailing vs. separator.
+        pairs = open(arch).read()[:-2].split("\0")
+        kvs = [item.split("=", 1) for item in pairs]
+        return dict(kvs)
+
+    def ExecStamp(self, path):
+        """Simple stamp command."""
+        open(path, "w").close()
+
+    def ExecRecursiveMirror(self, source, dest):
+        """Emulation of rm -rf out && cp -af in out."""
+        if os.path.exists(dest):
+            if os.path.isdir(dest):
+
+                def _on_error(fn, path, excinfo):
+                    # The operation failed, possibly because the file is set to
+                    # read-only. If that's why, make it writable and try the op again.
+                    if not os.access(path, os.W_OK):
+                        os.chmod(path, stat.S_IWRITE)
+                    fn(path)
+
+                shutil.rmtree(dest, onerror=_on_error)
+            else:
+                if not os.access(dest, os.W_OK):
+                    # Attempt to make the file writable before deleting it.
+                    os.chmod(dest, stat.S_IWRITE)
+                os.unlink(dest)
+
+        if os.path.isdir(source):
+            shutil.copytree(source, dest)
+        else:
+            shutil.copy2(source, dest)
+
+    def ExecLinkWrapper(self, arch, use_separate_mspdbsrv, *args):
+        """Filter diagnostic output from link that looks like:
     '   Creating library ui.dll.lib and object ui.dll.exp'
     This happens when there are exports from the dll or exe.
     """
-    env = self._GetEnv(arch)
-    if use_separate_mspdbsrv == 'True':
-      self._UseSeparateMspdbsrv(env, args)
-    if sys.platform == 'win32':
-      args = list(args)  # *args is a tuple by default, which is read-only.
-      args[0] = args[0].replace('/', '\\')
-    # https://docs.python.org/2/library/subprocess.html:
-    # "On Unix with shell=True [...] if args is a sequence, the first item
-    # specifies the command string, and any additional items will be treated as
-    # additional arguments to the shell itself.  That is to say, Popen does the
-    # equivalent of:
-    #   Popen(['/bin/sh', '-c', args[0], args[1], ...])"
-    # For that reason, since going through the shell doesn't seem necessary on
-    # non-Windows don't do that there.
-    link = subprocess.Popen(args, shell=sys.platform == 'win32', env=env,
-                            stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    out, _ = link.communicate()
-    if PY3:
-      out = out.decode('utf-8')
-    for line in out.splitlines():
-      if (not line.startswith('   Creating library ') and
-          not line.startswith('Generating code') and
-          not line.startswith('Finished generating code')):
-        print(line)
-    return link.returncode
-
-  def ExecLinkWithManifests(self, arch, embed_manifest, out, ldcmd, resname,
-                            mt, rc, intermediate_manifest, *manifests):
-    """A wrapper for handling creating a manifest resource and then executing
+        env = self._GetEnv(arch)
+        if use_separate_mspdbsrv == "True":
+            self._UseSeparateMspdbsrv(env, args)
+        if sys.platform == "win32":
+            args = list(args)  # *args is a tuple by default, which is read-only.
+            args[0] = args[0].replace("/", "\\")
+        # https://docs.python.org/2/library/subprocess.html:
+        # "On Unix with shell=True [...] if args is a sequence, the first item
+        # specifies the command string, and any additional items will be treated as
+        # additional arguments to the shell itself.  That is to say, Popen does the
+        # equivalent of:
+        #   Popen(['/bin/sh', '-c', args[0], args[1], ...])"
+        # For that reason, since going through the shell doesn't seem necessary on
+        # non-Windows don't do that there.
+        link = subprocess.Popen(
+            args,
+            shell=sys.platform == "win32",
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        out, _ = link.communicate()
+        if PY3:
+            out = out.decode("utf-8")
+        for line in out.splitlines():
+            if (
+                not line.startswith("   Creating library ")
+                and not line.startswith("Generating code")
+                and not line.startswith("Finished generating code")
+            ):
+                print(line)
+        return link.returncode
+
+    def ExecLinkWithManifests(
+        self,
+        arch,
+        embed_manifest,
+        out,
+        ldcmd,
+        resname,
+        mt,
+        rc,
+        intermediate_manifest,
+        *manifests
+    ):
+        """A wrapper for handling creating a manifest resource and then executing
     a link command."""
-    # The 'normal' way to do manifests is to have link generate a manifest
-    # based on gathering dependencies from the object files, then merge that
-    # manifest with other manifests supplied as sources, convert the merged
-    # manifest to a resource, and then *relink*, including the compiled
-    # version of the manifest resource. This breaks incremental linking, and
-    # is generally overly complicated. Instead, we merge all the manifests
-    # provided (along with one that includes what would normally be in the
-    # linker-generated one, see msvs_emulation.py), and include that into the
-    # first and only link. We still tell link to generate a manifest, but we
-    # only use that to assert that our simpler process did not miss anything.
-    variables = {
-      'python': sys.executable,
-      'arch': arch,
-      'out': out,
-      'ldcmd': ldcmd,
-      'resname': resname,
-      'mt': mt,
-      'rc': rc,
-      'intermediate_manifest': intermediate_manifest,
-      'manifests': ' '.join(manifests),
-    }
-    add_to_ld = ''
-    if manifests:
-      subprocess.check_call(
-          '%(python)s gyp-win-tool manifest-wrapper %(arch)s %(mt)s -nologo '
-          '-manifest %(manifests)s -out:%(out)s.manifest' % variables)
-      if embed_manifest == 'True':
-        subprocess.check_call(
-            '%(python)s gyp-win-tool manifest-to-rc %(arch)s %(out)s.manifest'
-          ' %(out)s.manifest.rc %(resname)s' % variables)
-        subprocess.check_call(
-            '%(python)s gyp-win-tool rc-wrapper %(arch)s %(rc)s '
-            '%(out)s.manifest.rc' % variables)
-        add_to_ld = ' %(out)s.manifest.res' % variables
-    subprocess.check_call(ldcmd + add_to_ld)
-
-    # Run mt.exe on the theoretically complete manifest we generated, merging
-    # it with the one the linker generated to confirm that the linker
-    # generated one does not add anything. This is strictly unnecessary for
-    # correctness, it's only to verify that e.g. /MANIFESTDEPENDENCY was not
-    # used in a #pragma comment.
-    if manifests:
-      # Merge the intermediate one with ours to .assert.manifest, then check
-      # that .assert.manifest is identical to ours.
-      subprocess.check_call(
-          '%(python)s gyp-win-tool manifest-wrapper %(arch)s %(mt)s -nologo '
-          '-manifest %(out)s.manifest %(intermediate_manifest)s '
-          '-out:%(out)s.assert.manifest' % variables)
-      assert_manifest = '%(out)s.assert.manifest' % variables
-      our_manifest = '%(out)s.manifest' % variables
-      # Load and normalize the manifests. mt.exe sometimes removes whitespace,
-      # and sometimes doesn't unfortunately.
-      with open(our_manifest, 'rb') as our_f:
-        with open(assert_manifest, 'rb') as assert_f:
-          our_data = our_f.read().translate(None, string.whitespace)
-          assert_data = assert_f.read().translate(None, string.whitespace)
-      if our_data != assert_data:
-        os.unlink(out)
-        def dump(filename):
-          sys.stderr.write('%s\n-----\n' % filename)
-          with open(filename, 'rb') as f:
-            sys.stderr.write(f.read() + '\n-----\n')
-        dump(intermediate_manifest)
-        dump(our_manifest)
-        dump(assert_manifest)
-        sys.stderr.write(
-            'Linker generated manifest "%s" added to final manifest "%s" '
-            '(result in "%s"). '
-            'Were /MANIFEST switches used in #pragma statements? ' % (
-              intermediate_manifest, our_manifest, assert_manifest))
-        return 1
-
-  def ExecManifestWrapper(self, arch, *args):
-    """Run manifest tool with environment set. Strip out undesirable warning
+        # The 'normal' way to do manifests is to have link generate a manifest
+        # based on gathering dependencies from the object files, then merge that
+        # manifest with other manifests supplied as sources, convert the merged
+        # manifest to a resource, and then *relink*, including the compiled
+        # version of the manifest resource. This breaks incremental linking, and
+        # is generally overly complicated. Instead, we merge all the manifests
+        # provided (along with one that includes what would normally be in the
+        # linker-generated one, see msvs_emulation.py), and include that into the
+        # first and only link. We still tell link to generate a manifest, but we
+        # only use that to assert that our simpler process did not miss anything.
+        variables = {
+            "python": sys.executable,
+            "arch": arch,
+            "out": out,
+            "ldcmd": ldcmd,
+            "resname": resname,
+            "mt": mt,
+            "rc": rc,
+            "intermediate_manifest": intermediate_manifest,
+            "manifests": " ".join(manifests),
+        }
+        add_to_ld = ""
+        if manifests:
+            subprocess.check_call(
+                "%(python)s gyp-win-tool manifest-wrapper %(arch)s %(mt)s -nologo "
+                "-manifest %(manifests)s -out:%(out)s.manifest" % variables
+            )
+            if embed_manifest == "True":
+                subprocess.check_call(
+                    "%(python)s gyp-win-tool manifest-to-rc %(arch)s %(out)s.manifest"
+                    " %(out)s.manifest.rc %(resname)s" % variables
+                )
+                subprocess.check_call(
+                    "%(python)s gyp-win-tool rc-wrapper %(arch)s %(rc)s "
+                    "%(out)s.manifest.rc" % variables
+                )
+                add_to_ld = " %(out)s.manifest.res" % variables
+        subprocess.check_call(ldcmd + add_to_ld)
+
+        # Run mt.exe on the theoretically complete manifest we generated, merging
+        # it with the one the linker generated to confirm that the linker
+        # generated one does not add anything. This is strictly unnecessary for
+        # correctness, it's only to verify that e.g. /MANIFESTDEPENDENCY was not
+        # used in a #pragma comment.
+        if manifests:
+            # Merge the intermediate one with ours to .assert.manifest, then check
+            # that .assert.manifest is identical to ours.
+            subprocess.check_call(
+                "%(python)s gyp-win-tool manifest-wrapper %(arch)s %(mt)s -nologo "
+                "-manifest %(out)s.manifest %(intermediate_manifest)s "
+                "-out:%(out)s.assert.manifest" % variables
+            )
+            assert_manifest = "%(out)s.assert.manifest" % variables
+            our_manifest = "%(out)s.manifest" % variables
+            # Load and normalize the manifests. mt.exe sometimes removes whitespace,
+            # and sometimes doesn't unfortunately.
+            with open(our_manifest, "r") as our_f:
+                with open(assert_manifest, "r") as assert_f:
+                    our_data = our_f.read().translate(None, string.whitespace)
+                    assert_data = assert_f.read().translate(None, string.whitespace)
+            if our_data != assert_data:
+                os.unlink(out)
+
+                def dump(filename):
+                    print(filename, file=sys.stderr)
+                    print("-----", file=sys.stderr)
+                    with open(filename, "r") as f:
+                        print(f.read(), file=sys.stderr)
+                        print("-----", file=sys.stderr)
+
+                dump(intermediate_manifest)
+                dump(our_manifest)
+                dump(assert_manifest)
+                sys.stderr.write(
+                    'Linker generated manifest "%s" added to final manifest "%s" '
+                    '(result in "%s"). '
+                    "Were /MANIFEST switches used in #pragma statements? "
+                    % (intermediate_manifest, our_manifest, assert_manifest)
+                )
+                return 1
+
+    def ExecManifestWrapper(self, arch, *args):
+        """Run manifest tool with environment set. Strip out undesirable warning
     (some XML blocks are recognized by the OS loader, but not the manifest
     tool)."""
-    env = self._GetEnv(arch)
-    popen = subprocess.Popen(args, shell=True, env=env,
-                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    out, _ = popen.communicate()
-    if PY3:
-      out = out.decode('utf-8')
-    for line in out.splitlines():
-      if line and 'manifest authoring warning 81010002' not in line:
-        print(line)
-    return popen.returncode
-
-  def ExecManifestToRc(self, arch, *args):
-    """Creates a resource file pointing a SxS assembly manifest.
+        env = self._GetEnv(arch)
+        popen = subprocess.Popen(
+            args, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        out, _ = popen.communicate()
+        if PY3:
+            out = out.decode("utf-8")
+        for line in out.splitlines():
+            if line and "manifest authoring warning 81010002" not in line:
+                print(line)
+        return popen.returncode
+
+    def ExecManifestToRc(self, arch, *args):
+        """Creates a resource file pointing a SxS assembly manifest.
     |args| is tuple containing path to resource file, path to manifest file
     and resource name which can be "1" (for executables) or "2" (for DLLs)."""
-    manifest_path, resource_path, resource_name = args
-    with open(resource_path, 'wb') as output:
-      output.write('#include <windows.h>\n%s RT_MANIFEST "%s"' % (
-        resource_name,
-        os.path.abspath(manifest_path).replace('\\', '/')))
-
-  def ExecMidlWrapper(self, arch, outdir, tlb, h, dlldata, iid, proxy, idl,
-                      *flags):
-    """Filter noisy filenames output from MIDL compile step that isn't
+        manifest_path, resource_path, resource_name = args
+        with open(resource_path, "w") as output:
+            output.write(
+                '#include <windows.h>\n%s RT_MANIFEST "%s"'
+                % (resource_name, os.path.abspath(manifest_path).replace("\\", "/"))
+            )
+
+    def ExecMidlWrapper(self, arch, outdir, tlb, h, dlldata, iid, proxy, idl, *flags):
+        """Filter noisy filenames output from MIDL compile step that isn't
     quietable via command line flags.
     """
-    args = ['midl', '/nologo'] + list(flags) + [
-        '/out', outdir,
-        '/tlb', tlb,
-        '/h', h,
-        '/dlldata', dlldata,
-        '/iid', iid,
-        '/proxy', proxy,
-        idl]
-    env = self._GetEnv(arch)
-    popen = subprocess.Popen(args, shell=True, env=env,
-                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    out, _ = popen.communicate()
-    if PY3:
-      out = out.decode('utf-8')
-    # Filter junk out of stdout, and write filtered versions. Output we want
-    # to filter is pairs of lines that look like this:
-    # Processing C:\Program Files (x86)\Microsoft SDKs\...\include\objidl.idl
-    # objidl.idl
-    lines = out.splitlines()
-    prefixes = ('Processing ', '64 bit Processing ')
-    processing = set(os.path.basename(x)
-                     for x in lines if x.startswith(prefixes))
-    for line in lines:
-      if not line.startswith(prefixes) and line not in processing:
-        print(line)
-    return popen.returncode
-
-  def ExecAsmWrapper(self, arch, *args):
-    """Filter logo banner from invocations of asm.exe."""
-    env = self._GetEnv(arch)
-    popen = subprocess.Popen(args, shell=True, env=env,
-                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    out, _ = popen.communicate()
-    if PY3:
-      out = out.decode('utf-8')
-    for line in out.splitlines():
-      if (not line.startswith('Copyright (C) Microsoft Corporation') and
-          not line.startswith('Microsoft (R) Macro Assembler') and
-          not line.startswith(' Assembling: ') and
-          line):
-        print(line)
-    return popen.returncode
-
-  def ExecRcWrapper(self, arch, *args):
-    """Filter logo banner from invocations of rc.exe. Older versions of RC
+        args = (
+            ["midl", "/nologo"]
+            + list(flags)
+            + [
+                "/out",
+                outdir,
+                "/tlb",
+                tlb,
+                "/h",
+                h,
+                "/dlldata",
+                dlldata,
+                "/iid",
+                iid,
+                "/proxy",
+                proxy,
+                idl,
+            ]
+        )
+        env = self._GetEnv(arch)
+        popen = subprocess.Popen(
+            args, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        out, _ = popen.communicate()
+        if PY3:
+            out = out.decode("utf-8")
+        # Filter junk out of stdout, and write filtered versions. Output we want
+        # to filter is pairs of lines that look like this:
+        # Processing C:\Program Files (x86)\Microsoft SDKs\...\include\objidl.idl
+        # objidl.idl
+        lines = out.splitlines()
+        prefixes = ("Processing ", "64 bit Processing ")
+        processing = set(os.path.basename(x) for x in lines if x.startswith(prefixes))
+        for line in lines:
+            if not line.startswith(prefixes) and line not in processing:
+                print(line)
+        return popen.returncode
+
+    def ExecAsmWrapper(self, arch, *args):
+        """Filter logo banner from invocations of asm.exe."""
+        env = self._GetEnv(arch)
+        popen = subprocess.Popen(
+            args, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        out, _ = popen.communicate()
+        if PY3:
+            out = out.decode("utf-8")
+        for line in out.splitlines():
+            if (
+                not line.startswith("Copyright (C) Microsoft Corporation")
+                and not line.startswith("Microsoft (R) Macro Assembler")
+                and not line.startswith(" Assembling: ")
+                and line
+            ):
+                print(line)
+        return popen.returncode
+
+    def ExecRcWrapper(self, arch, *args):
+        """Filter logo banner from invocations of rc.exe. Older versions of RC
     don't support the /nologo flag."""
-    env = self._GetEnv(arch)
-    popen = subprocess.Popen(args, shell=True, env=env,
-                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    out, _ = popen.communicate()
-    if PY3:
-      out = out.decode('utf-8')
-    for line in out.splitlines():
-      if (not line.startswith('Microsoft (R) Windows (R) Resource Compiler') and
-          not line.startswith('Copyright (C) Microsoft Corporation') and
-          line):
-        print(line)
-    return popen.returncode
-
-  def ExecActionWrapper(self, arch, rspfile, *dir):
-    """Runs an action command line from a response file using the environment
+        env = self._GetEnv(arch)
+        popen = subprocess.Popen(
+            args, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        out, _ = popen.communicate()
+        if PY3:
+            out = out.decode("utf-8")
+        for line in out.splitlines():
+            if (
+                not line.startswith("Microsoft (R) Windows (R) Resource Compiler")
+                and not line.startswith("Copyright (C) Microsoft Corporation")
+                and line
+            ):
+                print(line)
+        return popen.returncode
+
+    def ExecActionWrapper(self, arch, rspfile, *dir):
+        """Runs an action command line from a response file using the environment
     for |arch|. If |dir| is supplied, use that as the working directory."""
-    env = self._GetEnv(arch)
-    # TODO(scottmg): This is a temporary hack to get some specific variables
-    # through to actions that are set after gyp-time. http://crbug.com/333738.
-    for k, v in os.environ.items():
-      if k not in env:
-        env[k] = v
-    args = open(rspfile).read()
-    dir = dir[0] if dir else None
-    return subprocess.call(args, shell=True, env=env, cwd=dir)
-
-  def ExecClCompile(self, project_dir, selected_files):
-    """Executed by msvs-ninja projects when the 'ClCompile' target is used to
+        env = self._GetEnv(arch)
+        # TODO(scottmg): This is a temporary hack to get some specific variables
+        # through to actions that are set after gyp-time. http://crbug.com/333738.
+        for k, v in os.environ.items():
+            if k not in env:
+                env[k] = v
+        args = open(rspfile).read()
+        dir = dir[0] if dir else None
+        return subprocess.call(args, shell=True, env=env, cwd=dir)
+
+    def ExecClCompile(self, project_dir, selected_files):
+        """Executed by msvs-ninja projects when the 'ClCompile' target is used to
     build selected C/C++ files."""
-    project_dir = os.path.relpath(project_dir, BASE_DIR)
-    selected_files = selected_files.split(';')
-    ninja_targets = [os.path.join(project_dir, filename) + '^^'
-        for filename in selected_files]
-    cmd = ['ninja.exe']
-    cmd.extend(ninja_targets)
-    return subprocess.call(cmd, shell=True, cwd=BASE_DIR)
-
-if __name__ == '__main__':
-  sys.exit(main(sys.argv[1:]))
+        project_dir = os.path.relpath(project_dir, BASE_DIR)
+        selected_files = selected_files.split(";")
+        ninja_targets = [
+            os.path.join(project_dir, filename) + "^^" for filename in selected_files
+        ]
+        cmd = ["ninja.exe"]
+        cmd.extend(ninja_targets)
+        return subprocess.call(cmd, shell=True, cwd=BASE_DIR)
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/tools/gyp/pylib/gyp/xcode_emulation.py b/tools/gyp/pylib/gyp/xcode_emulation.py
index c3daba5fb82e1add1db3f21f90883e38dd8310a7..a79aaa41fbcee87066a5e92ccd8878d36c09c9d2 100644
--- a/tools/gyp/pylib/gyp/xcode_emulation.py
+++ b/tools/gyp/pylib/gyp/xcode_emulation.py
@@ -17,7 +17,6 @@ import re
 import shlex
 import subprocess
 import sys
-import tempfile
 from gyp.common import GypError
 
 PY3 = bytes != str
@@ -33,71 +32,72 @@ XCODE_ARCHS_DEFAULT_CACHE = None
 
 
 def XcodeArchsVariableMapping(archs, archs_including_64_bit=None):
-  """Constructs a dictionary with expansion for $(ARCHS_STANDARD) variable,
+    """Constructs a dictionary with expansion for $(ARCHS_STANDARD) variable,
   and optionally for $(ARCHS_STANDARD_INCLUDING_64_BIT)."""
-  mapping = {'$(ARCHS_STANDARD)': archs}
-  if archs_including_64_bit:
-    mapping['$(ARCHS_STANDARD_INCLUDING_64_BIT)'] = archs_including_64_bit
-  return mapping
+    mapping = {"$(ARCHS_STANDARD)": archs}
+    if archs_including_64_bit:
+        mapping["$(ARCHS_STANDARD_INCLUDING_64_BIT)"] = archs_including_64_bit
+    return mapping
+
 
 class XcodeArchsDefault(object):
-  """A class to resolve ARCHS variable from xcode_settings, resolving Xcode
+    """A class to resolve ARCHS variable from xcode_settings, resolving Xcode
   macros and implementing filtering by VALID_ARCHS. The expansion of macros
   depends on the SDKROOT used ("macosx", "iphoneos", "iphonesimulator") and
   on the version of Xcode.
   """
 
-  # Match variable like $(ARCHS_STANDARD).
-  variable_pattern = re.compile(r'\$\([a-zA-Z_][a-zA-Z0-9_]*\)$')
+    # Match variable like $(ARCHS_STANDARD).
+    variable_pattern = re.compile(r"\$\([a-zA-Z_][a-zA-Z0-9_]*\)$")
 
-  def __init__(self, default, mac, iphonesimulator, iphoneos):
-    self._default = (default,)
-    self._archs = {'mac': mac, 'ios': iphoneos, 'iossim': iphonesimulator}
+    def __init__(self, default, mac, iphonesimulator, iphoneos):
+        self._default = (default,)
+        self._archs = {"mac": mac, "ios": iphoneos, "iossim": iphonesimulator}
 
-  def _VariableMapping(self, sdkroot):
-    """Returns the dictionary of variable mapping depending on the SDKROOT."""
-    sdkroot = sdkroot.lower()
-    if 'iphoneos' in sdkroot:
-      return self._archs['ios']
-    elif 'iphonesimulator' in sdkroot:
-      return self._archs['iossim']
-    else:
-      return self._archs['mac']
-
-  def _ExpandArchs(self, archs, sdkroot):
-    """Expands variables references in ARCHS, and remove duplicates."""
-    variable_mapping = self._VariableMapping(sdkroot)
-    expanded_archs = []
-    for arch in archs:
-      if self.variable_pattern.match(arch):
-        variable = arch
-        try:
-          variable_expansion = variable_mapping[variable]
-          for arch in variable_expansion:
-            if arch not in expanded_archs:
-              expanded_archs.append(arch)
-        except KeyError as e:
-          print('Warning: Ignoring unsupported variable "%s".' % variable)
-      elif arch not in expanded_archs:
-        expanded_archs.append(arch)
-    return expanded_archs
-
-  def ActiveArchs(self, archs, valid_archs, sdkroot):
-    """Expands variables references in ARCHS, and filter by VALID_ARCHS if it
+    def _VariableMapping(self, sdkroot):
+        """Returns the dictionary of variable mapping depending on the SDKROOT."""
+        sdkroot = sdkroot.lower()
+        if "iphoneos" in sdkroot:
+            return self._archs["ios"]
+        elif "iphonesimulator" in sdkroot:
+            return self._archs["iossim"]
+        else:
+            return self._archs["mac"]
+
+    def _ExpandArchs(self, archs, sdkroot):
+        """Expands variables references in ARCHS, and remove duplicates."""
+        variable_mapping = self._VariableMapping(sdkroot)
+        expanded_archs = []
+        for arch in archs:
+            if self.variable_pattern.match(arch):
+                variable = arch
+                try:
+                    variable_expansion = variable_mapping[variable]
+                    for arch in variable_expansion:
+                        if arch not in expanded_archs:
+                            expanded_archs.append(arch)
+                except KeyError:
+                    print('Warning: Ignoring unsupported variable "%s".' % variable)
+            elif arch not in expanded_archs:
+                expanded_archs.append(arch)
+        return expanded_archs
+
+    def ActiveArchs(self, archs, valid_archs, sdkroot):
+        """Expands variables references in ARCHS, and filter by VALID_ARCHS if it
     is defined (if not set, Xcode accept any value in ARCHS, otherwise, only
     values present in VALID_ARCHS are kept)."""
-    expanded_archs = self._ExpandArchs(archs or self._default, sdkroot or '')
-    if valid_archs:
-      filtered_archs = []
-      for arch in expanded_archs:
-        if arch in valid_archs:
-          filtered_archs.append(arch)
-      expanded_archs = filtered_archs
-    return expanded_archs
+        expanded_archs = self._ExpandArchs(archs or self._default, sdkroot or "")
+        if valid_archs:
+            filtered_archs = []
+            for arch in expanded_archs:
+                if arch in valid_archs:
+                    filtered_archs.append(arch)
+            expanded_archs = filtered_archs
+        return expanded_archs
 
 
 def GetXcodeArchsDefault():
-  """Returns the |XcodeArchsDefault| object to use to expand ARCHS for the
+    """Returns the |XcodeArchsDefault| object to use to expand ARCHS for the
   installed version of Xcode. The default values used by Xcode for ARCHS
   and the expansion of the variables depends on the version of Xcode used.
 
@@ -113,741 +113,793 @@ def GetXcodeArchsDefault():
   of $(ARCHS_STANDARD_INCLUDING_64_BIT) from Xcode 5.0. From Xcode 5.1, they
   are also part of $(ARCHS_STANDARD).
 
-  All thoses rules are coded in the construction of the |XcodeArchsDefault|
+  All these rules are coded in the construction of the |XcodeArchsDefault|
   object to use depending on the version of Xcode detected. The object is
   for performance reason."""
-  global XCODE_ARCHS_DEFAULT_CACHE
-  if XCODE_ARCHS_DEFAULT_CACHE:
+    global XCODE_ARCHS_DEFAULT_CACHE
+    if XCODE_ARCHS_DEFAULT_CACHE:
+        return XCODE_ARCHS_DEFAULT_CACHE
+    xcode_version, _ = XcodeVersion()
+    if xcode_version < "0500":
+        XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
+            "$(ARCHS_STANDARD)",
+            XcodeArchsVariableMapping(["i386"]),
+            XcodeArchsVariableMapping(["i386"]),
+            XcodeArchsVariableMapping(["armv7"]),
+        )
+    elif xcode_version < "0510":
+        XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
+            "$(ARCHS_STANDARD_INCLUDING_64_BIT)",
+            XcodeArchsVariableMapping(["x86_64"], ["x86_64"]),
+            XcodeArchsVariableMapping(["i386"], ["i386", "x86_64"]),
+            XcodeArchsVariableMapping(
+                ["armv7", "armv7s"], ["armv7", "armv7s", "arm64"]
+            ),
+        )
+    else:
+        XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
+            "$(ARCHS_STANDARD)",
+            XcodeArchsVariableMapping(["x86_64"], ["x86_64"]),
+            XcodeArchsVariableMapping(["i386", "x86_64"], ["i386", "x86_64"]),
+            XcodeArchsVariableMapping(
+                ["armv7", "armv7s", "arm64"], ["armv7", "armv7s", "arm64"]
+            ),
+        )
     return XCODE_ARCHS_DEFAULT_CACHE
-  xcode_version, _ = XcodeVersion()
-  if xcode_version < '0500':
-    XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
-        '$(ARCHS_STANDARD)',
-        XcodeArchsVariableMapping(['i386']),
-        XcodeArchsVariableMapping(['i386']),
-        XcodeArchsVariableMapping(['armv7']))
-  elif xcode_version < '0510':
-    XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
-        '$(ARCHS_STANDARD_INCLUDING_64_BIT)',
-        XcodeArchsVariableMapping(['x86_64'], ['x86_64']),
-        XcodeArchsVariableMapping(['i386'], ['i386', 'x86_64']),
-        XcodeArchsVariableMapping(
-            ['armv7', 'armv7s'],
-            ['armv7', 'armv7s', 'arm64']))
-  else:
-    XCODE_ARCHS_DEFAULT_CACHE = XcodeArchsDefault(
-        '$(ARCHS_STANDARD)',
-        XcodeArchsVariableMapping(['x86_64'], ['x86_64']),
-        XcodeArchsVariableMapping(['i386', 'x86_64'], ['i386', 'x86_64']),
-        XcodeArchsVariableMapping(
-            ['armv7', 'armv7s', 'arm64'],
-            ['armv7', 'armv7s', 'arm64']))
-  return XCODE_ARCHS_DEFAULT_CACHE
 
 
 class XcodeSettings(object):
-  """A class that understands the gyp 'xcode_settings' object."""
-
-  # Populated lazily by _SdkPath(). Shared by all XcodeSettings, so cached
-  # at class-level for efficiency.
-  _sdk_path_cache = {}
-  _platform_path_cache = {}
-  _sdk_root_cache = {}
-
-  # Populated lazily by GetExtraPlistItems(). Shared by all XcodeSettings, so
-  # cached at class-level for efficiency.
-  _plist_cache = {}
-
-  # Populated lazily by GetIOSPostbuilds.  Shared by all XcodeSettings, so
-  # cached at class-level for efficiency.
-  _codesigning_key_cache = {}
-
-  def __init__(self, spec):
-    self.spec = spec
-
-    self.isIOS = False
-    self.mac_toolchain_dir = None
-    self.header_map_path = None
-
-    # Per-target 'xcode_settings' are pushed down into configs earlier by gyp.
-    # This means self.xcode_settings[config] always contains all settings
-    # for that config -- the per-target settings as well. Settings that are
-    # the same for all configs are implicitly per-target settings.
-    self.xcode_settings = {}
-    configs = spec['configurations']
-    for configname, config in configs.items():
-      self.xcode_settings[configname] = config.get('xcode_settings', {})
-      self._ConvertConditionalKeys(configname)
-      if self.xcode_settings[configname].get('IPHONEOS_DEPLOYMENT_TARGET',
-                                             None):
-        self.isIOS = True
-
-    # This is only non-None temporarily during the execution of some methods.
-    self.configname = None
-
-    # Used by _AdjustLibrary to match .a and .dylib entries in libraries.
-    self.library_re = re.compile(r'^lib([^/]+)\.(a|dylib)$')
-
-  def _ConvertConditionalKeys(self, configname):
-    """Converts or warns on conditional keys.  Xcode supports conditional keys,
+    """A class that understands the gyp 'xcode_settings' object."""
+
+    # Populated lazily by _SdkPath(). Shared by all XcodeSettings, so cached
+    # at class-level for efficiency.
+    _sdk_path_cache = {}
+    _platform_path_cache = {}
+    _sdk_root_cache = {}
+
+    # Populated lazily by GetExtraPlistItems(). Shared by all XcodeSettings, so
+    # cached at class-level for efficiency.
+    _plist_cache = {}
+
+    # Populated lazily by GetIOSPostbuilds.  Shared by all XcodeSettings, so
+    # cached at class-level for efficiency.
+    _codesigning_key_cache = {}
+
+    def __init__(self, spec):
+        self.spec = spec
+
+        self.isIOS = False
+        self.mac_toolchain_dir = None
+        self.header_map_path = None
+
+        # Per-target 'xcode_settings' are pushed down into configs earlier by gyp.
+        # This means self.xcode_settings[config] always contains all settings
+        # for that config -- the per-target settings as well. Settings that are
+        # the same for all configs are implicitly per-target settings.
+        self.xcode_settings = {}
+        configs = spec["configurations"]
+        for configname, config in configs.items():
+            self.xcode_settings[configname] = config.get("xcode_settings", {})
+            self._ConvertConditionalKeys(configname)
+            if self.xcode_settings[configname].get("IPHONEOS_DEPLOYMENT_TARGET", None):
+                self.isIOS = True
+
+        # This is only non-None temporarily during the execution of some methods.
+        self.configname = None
+
+        # Used by _AdjustLibrary to match .a and .dylib entries in libraries.
+        self.library_re = re.compile(r"^lib([^/]+)\.(a|dylib)$")
+
+    def _ConvertConditionalKeys(self, configname):
+        """Converts or warns on conditional keys.  Xcode supports conditional keys,
     such as CODE_SIGN_IDENTITY[sdk=iphoneos*].  This is a partial implementation
     with some keys converted while the rest force a warning."""
-    settings = self.xcode_settings[configname]
-    conditional_keys = [key for key in settings if key.endswith(']')]
-    for key in conditional_keys:
-      # If you need more, speak up at http://crbug.com/122592
-      if key.endswith("[sdk=iphoneos*]"):
-        if configname.endswith("iphoneos"):
-          new_key = key.split("[")[0]
-          settings[new_key] = settings[key]
-      else:
-        print('Warning: Conditional keys not implemented, ignoring:',
-              ' '.join(conditional_keys))
-      del settings[key]
-
-  def _Settings(self):
-    assert self.configname
-    return self.xcode_settings[self.configname]
-
-  def _Test(self, test_key, cond_key, default):
-    return self._Settings().get(test_key, default) == cond_key
-
-  def _Appendf(self, lst, test_key, format_str, default=None):
-    if test_key in self._Settings():
-      lst.append(format_str % str(self._Settings()[test_key]))
-    elif default:
-      lst.append(format_str % str(default))
-
-  def _WarnUnimplemented(self, test_key):
-    if test_key in self._Settings():
-      print('Warning: Ignoring not yet implemented key "%s".' % test_key)
-
-  def IsBinaryOutputFormat(self, configname):
-    default = "binary" if self.isIOS else "xml"
-    format = self.xcode_settings[configname].get('INFOPLIST_OUTPUT_FORMAT',
-                                                 default)
-    return format == "binary"
-
-  def IsIosFramework(self):
-    return self.spec['type'] == 'shared_library' and self._IsBundle() and \
-        self.isIOS
-
-  def _IsBundle(self):
-    return int(self.spec.get('mac_bundle', 0)) != 0 or self._IsXCTest() or \
-        self._IsXCUiTest()
-
-  def _IsXCTest(self):
-    return int(self.spec.get('mac_xctest_bundle', 0)) != 0
-
-  def _IsXCUiTest(self):
-    return int(self.spec.get('mac_xcuitest_bundle', 0)) != 0
-
-  def _IsIosAppExtension(self):
-    return int(self.spec.get('ios_app_extension', 0)) != 0
-
-  def _IsIosWatchKitExtension(self):
-    return int(self.spec.get('ios_watchkit_extension', 0)) != 0
-
-  def _IsIosWatchApp(self):
-    return int(self.spec.get('ios_watch_app', 0)) != 0
-
-  def GetFrameworkVersion(self):
-    """Returns the framework version of the current target. Only valid for
+        settings = self.xcode_settings[configname]
+        conditional_keys = [key for key in settings if key.endswith("]")]
+        for key in conditional_keys:
+            # If you need more, speak up at http://crbug.com/122592
+            if key.endswith("[sdk=iphoneos*]"):
+                if configname.endswith("iphoneos"):
+                    new_key = key.split("[")[0]
+                    settings[new_key] = settings[key]
+            else:
+                print(
+                    "Warning: Conditional keys not implemented, ignoring:",
+                    " ".join(conditional_keys),
+                )
+            del settings[key]
+
+    def _Settings(self):
+        assert self.configname
+        return self.xcode_settings[self.configname]
+
+    def _Test(self, test_key, cond_key, default):
+        return self._Settings().get(test_key, default) == cond_key
+
+    def _Appendf(self, lst, test_key, format_str, default=None):
+        if test_key in self._Settings():
+            lst.append(format_str % str(self._Settings()[test_key]))
+        elif default:
+            lst.append(format_str % str(default))
+
+    def _WarnUnimplemented(self, test_key):
+        if test_key in self._Settings():
+            print('Warning: Ignoring not yet implemented key "%s".' % test_key)
+
+    def IsBinaryOutputFormat(self, configname):
+        default = "binary" if self.isIOS else "xml"
+        format = self.xcode_settings[configname].get("INFOPLIST_OUTPUT_FORMAT", default)
+        return format == "binary"
+
+    def IsIosFramework(self):
+        return self.spec["type"] == "shared_library" and self._IsBundle() and self.isIOS
+
+    def _IsBundle(self):
+        return (
+            int(self.spec.get("mac_bundle", 0)) != 0
+            or self._IsXCTest()
+            or self._IsXCUiTest()
+        )
+
+    def _IsXCTest(self):
+        return int(self.spec.get("mac_xctest_bundle", 0)) != 0
+
+    def _IsXCUiTest(self):
+        return int(self.spec.get("mac_xcuitest_bundle", 0)) != 0
+
+    def _IsIosAppExtension(self):
+        return int(self.spec.get("ios_app_extension", 0)) != 0
+
+    def _IsIosWatchKitExtension(self):
+        return int(self.spec.get("ios_watchkit_extension", 0)) != 0
+
+    def _IsIosWatchApp(self):
+        return int(self.spec.get("ios_watch_app", 0)) != 0
+
+    def GetFrameworkVersion(self):
+        """Returns the framework version of the current target. Only valid for
     bundles."""
-    assert self._IsBundle()
-    return self.GetPerTargetSetting('FRAMEWORK_VERSION', default='A')
+        assert self._IsBundle()
+        return self.GetPerTargetSetting("FRAMEWORK_VERSION", default="A")
 
-  def GetWrapperExtension(self):
-    """Returns the bundle extension (.app, .framework, .plugin, etc).  Only
+    def GetWrapperExtension(self):
+        """Returns the bundle extension (.app, .framework, .plugin, etc).  Only
     valid for bundles."""
-    assert self._IsBundle()
-    if self.spec['type'] in ('loadable_module', 'shared_library'):
-      default_wrapper_extension = {
-        'loadable_module': 'bundle',
-        'shared_library': 'framework',
-      }[self.spec['type']]
-      wrapper_extension = self.GetPerTargetSetting(
-          'WRAPPER_EXTENSION', default=default_wrapper_extension)
-      return '.' + self.spec.get('product_extension', wrapper_extension)
-    elif self.spec['type'] == 'executable':
-      if self._IsIosAppExtension() or self._IsIosWatchKitExtension():
-        return '.' + self.spec.get('product_extension', 'appex')
-      else:
-        return '.' + self.spec.get('product_extension', 'app')
-    else:
-      assert False, "Don't know extension for '%s', target '%s'" % (
-          self.spec['type'], self.spec['target_name'])
-
-  def GetProductName(self):
-    """Returns PRODUCT_NAME."""
-    return self.spec.get('product_name', self.spec['target_name'])
-
-  def GetFullProductName(self):
-    """Returns FULL_PRODUCT_NAME."""
-    if self._IsBundle():
-      return self.GetWrapperName()
-    else:
-      return self._GetStandaloneBinaryPath()
+        assert self._IsBundle()
+        if self.spec["type"] in ("loadable_module", "shared_library"):
+            default_wrapper_extension = {
+                "loadable_module": "bundle",
+                "shared_library": "framework",
+            }[self.spec["type"]]
+            wrapper_extension = self.GetPerTargetSetting(
+                "WRAPPER_EXTENSION", default=default_wrapper_extension
+            )
+            return "." + self.spec.get("product_extension", wrapper_extension)
+        elif self.spec["type"] == "executable":
+            if self._IsIosAppExtension() or self._IsIosWatchKitExtension():
+                return "." + self.spec.get("product_extension", "appex")
+            else:
+                return "." + self.spec.get("product_extension", "app")
+        else:
+            assert False, "Don't know extension for '%s', target '%s'" % (
+                self.spec["type"],
+                self.spec["target_name"],
+            )
+
+    def GetProductName(self):
+        """Returns PRODUCT_NAME."""
+        return self.spec.get("product_name", self.spec["target_name"])
+
+    def GetFullProductName(self):
+        """Returns FULL_PRODUCT_NAME."""
+        if self._IsBundle():
+            return self.GetWrapperName()
+        else:
+            return self._GetStandaloneBinaryPath()
 
-  def GetWrapperName(self):
-    """Returns the directory name of the bundle represented by this target.
+    def GetWrapperName(self):
+        """Returns the directory name of the bundle represented by this target.
     Only valid for bundles."""
-    assert self._IsBundle()
-    return self.GetProductName() + self.GetWrapperExtension()
+        assert self._IsBundle()
+        return self.GetProductName() + self.GetWrapperExtension()
 
-  def GetBundleContentsFolderPath(self):
-    """Returns the qualified path to the bundle's contents folder. E.g.
+    def GetBundleContentsFolderPath(self):
+        """Returns the qualified path to the bundle's contents folder. E.g.
     Chromium.app/Contents or Foo.bundle/Versions/A. Only valid for bundles."""
-    if self.isIOS:
-      return self.GetWrapperName()
-    assert self._IsBundle()
-    if self.spec['type'] == 'shared_library':
-      return os.path.join(
-          self.GetWrapperName(), 'Versions', self.GetFrameworkVersion())
-    else:
-      # loadable_modules have a 'Contents' folder like executables.
-      return os.path.join(self.GetWrapperName(), 'Contents')
+        if self.isIOS:
+            return self.GetWrapperName()
+        assert self._IsBundle()
+        if self.spec["type"] == "shared_library":
+            return os.path.join(
+                self.GetWrapperName(), "Versions", self.GetFrameworkVersion()
+            )
+        else:
+            # loadable_modules have a 'Contents' folder like executables.
+            return os.path.join(self.GetWrapperName(), "Contents")
 
-  def GetBundleResourceFolder(self):
-    """Returns the qualified path to the bundle's resource folder. E.g.
+    def GetBundleResourceFolder(self):
+        """Returns the qualified path to the bundle's resource folder. E.g.
     Chromium.app/Contents/Resources. Only valid for bundles."""
-    assert self._IsBundle()
-    if self.isIOS:
-      return self.GetBundleContentsFolderPath()
-    return os.path.join(self.GetBundleContentsFolderPath(), 'Resources')
+        assert self._IsBundle()
+        if self.isIOS:
+            return self.GetBundleContentsFolderPath()
+        return os.path.join(self.GetBundleContentsFolderPath(), "Resources")
 
-  def GetBundleExecutableFolderPath(self):
-    """Returns the qualified path to the bundle's executables folder. E.g.
+    def GetBundleExecutableFolderPath(self):
+        """Returns the qualified path to the bundle's executables folder. E.g.
     Chromium.app/Contents/MacOS. Only valid for bundles."""
-    assert self._IsBundle()
-    if self.spec['type'] in ('shared_library') or self.isIOS:
-      return self.GetBundleContentsFolderPath()
-    elif self.spec['type'] in ('executable', 'loadable_module'):
-      return os.path.join(self.GetBundleContentsFolderPath(), 'MacOS')
-
-  def GetBundleJavaFolderPath(self):
-    """Returns the qualified path to the bundle's Java resource folder.
+        assert self._IsBundle()
+        if self.spec["type"] in ("shared_library") or self.isIOS:
+            return self.GetBundleContentsFolderPath()
+        elif self.spec["type"] in ("executable", "loadable_module"):
+            return os.path.join(self.GetBundleContentsFolderPath(), "MacOS")
+
+    def GetBundleJavaFolderPath(self):
+        """Returns the qualified path to the bundle's Java resource folder.
     E.g. Chromium.app/Contents/Resources/Java. Only valid for bundles."""
-    assert self._IsBundle()
-    return os.path.join(self.GetBundleResourceFolder(), 'Java')
+        assert self._IsBundle()
+        return os.path.join(self.GetBundleResourceFolder(), "Java")
 
-  def GetBundleFrameworksFolderPath(self):
-    """Returns the qualified path to the bundle's frameworks folder. E.g,
+    def GetBundleFrameworksFolderPath(self):
+        """Returns the qualified path to the bundle's frameworks folder. E.g,
     Chromium.app/Contents/Frameworks. Only valid for bundles."""
-    assert self._IsBundle()
-    return os.path.join(self.GetBundleContentsFolderPath(), 'Frameworks')
+        assert self._IsBundle()
+        return os.path.join(self.GetBundleContentsFolderPath(), "Frameworks")
 
-  def GetBundleSharedFrameworksFolderPath(self):
-    """Returns the qualified path to the bundle's frameworks folder. E.g,
+    def GetBundleSharedFrameworksFolderPath(self):
+        """Returns the qualified path to the bundle's frameworks folder. E.g,
     Chromium.app/Contents/SharedFrameworks. Only valid for bundles."""
-    assert self._IsBundle()
-    return os.path.join(self.GetBundleContentsFolderPath(),
-                        'SharedFrameworks')
+        assert self._IsBundle()
+        return os.path.join(self.GetBundleContentsFolderPath(), "SharedFrameworks")
 
-  def GetBundleSharedSupportFolderPath(self):
-    """Returns the qualified path to the bundle's shared support folder. E.g,
+    def GetBundleSharedSupportFolderPath(self):
+        """Returns the qualified path to the bundle's shared support folder. E.g,
     Chromium.app/Contents/SharedSupport. Only valid for bundles."""
-    assert self._IsBundle()
-    if self.spec['type'] == 'shared_library':
-      return self.GetBundleResourceFolder()
-    else:
-      return os.path.join(self.GetBundleContentsFolderPath(),
-                          'SharedSupport')
+        assert self._IsBundle()
+        if self.spec["type"] == "shared_library":
+            return self.GetBundleResourceFolder()
+        else:
+            return os.path.join(self.GetBundleContentsFolderPath(), "SharedSupport")
 
-  def GetBundlePlugInsFolderPath(self):
-    """Returns the qualified path to the bundle's plugins folder. E.g,
+    def GetBundlePlugInsFolderPath(self):
+        """Returns the qualified path to the bundle's plugins folder. E.g,
     Chromium.app/Contents/PlugIns. Only valid for bundles."""
-    assert self._IsBundle()
-    return os.path.join(self.GetBundleContentsFolderPath(), 'PlugIns')
+        assert self._IsBundle()
+        return os.path.join(self.GetBundleContentsFolderPath(), "PlugIns")
 
-  def GetBundleXPCServicesFolderPath(self):
-    """Returns the qualified path to the bundle's XPC services folder. E.g,
+    def GetBundleXPCServicesFolderPath(self):
+        """Returns the qualified path to the bundle's XPC services folder. E.g,
     Chromium.app/Contents/XPCServices. Only valid for bundles."""
-    assert self._IsBundle()
-    return os.path.join(self.GetBundleContentsFolderPath(), 'XPCServices')
+        assert self._IsBundle()
+        return os.path.join(self.GetBundleContentsFolderPath(), "XPCServices")
 
-  def GetBundlePlistPath(self):
-    """Returns the qualified path to the bundle's plist file. E.g.
+    def GetBundlePlistPath(self):
+        """Returns the qualified path to the bundle's plist file. E.g.
     Chromium.app/Contents/Info.plist. Only valid for bundles."""
-    assert self._IsBundle()
-    if self.spec['type'] in ('executable', 'loadable_module') or \
-        self.IsIosFramework():
-      return os.path.join(self.GetBundleContentsFolderPath(), 'Info.plist')
-    else:
-      return os.path.join(self.GetBundleContentsFolderPath(),
-                          'Resources', 'Info.plist')
-
-  def GetProductType(self):
-    """Returns the PRODUCT_TYPE of this target."""
-    if self._IsIosAppExtension():
-      assert self._IsBundle(), ('ios_app_extension flag requires mac_bundle '
-          '(target %s)' % self.spec['target_name'])
-      return 'com.apple.product-type.app-extension'
-    if self._IsIosWatchKitExtension():
-      assert self._IsBundle(), ('ios_watchkit_extension flag requires '
-          'mac_bundle (target %s)' % self.spec['target_name'])
-      return 'com.apple.product-type.watchkit-extension'
-    if self._IsIosWatchApp():
-      assert self._IsBundle(), ('ios_watch_app flag requires mac_bundle '
-          '(target %s)' % self.spec['target_name'])
-      return 'com.apple.product-type.application.watchapp'
-    if self._IsXCUiTest():
-      assert self._IsBundle(), ('mac_xcuitest_bundle flag requires mac_bundle '
-          '(target %s)' % self.spec['target_name'])
-      return 'com.apple.product-type.bundle.ui-testing'
-    if self._IsBundle():
-      return {
-        'executable': 'com.apple.product-type.application',
-        'loadable_module': 'com.apple.product-type.bundle',
-        'shared_library': 'com.apple.product-type.framework',
-      }[self.spec['type']]
-    else:
-      return {
-        'executable': 'com.apple.product-type.tool',
-        'loadable_module': 'com.apple.product-type.library.dynamic',
-        'shared_library': 'com.apple.product-type.library.dynamic',
-        'static_library': 'com.apple.product-type.library.static',
-      }[self.spec['type']]
-
-  def GetMachOType(self):
-    """Returns the MACH_O_TYPE of this target."""
-    # Weird, but matches Xcode.
-    if not self._IsBundle() and self.spec['type'] == 'executable':
-      return ''
-    return {
-      'executable': 'mh_execute',
-      'static_library': 'staticlib',
-      'shared_library': 'mh_dylib',
-      'loadable_module': 'mh_bundle',
-    }[self.spec['type']]
-
-  def _GetBundleBinaryPath(self):
-    """Returns the name of the bundle binary of by this target.
+        assert self._IsBundle()
+        if (
+            self.spec["type"] in ("executable", "loadable_module")
+            or self.IsIosFramework()
+        ):
+            return os.path.join(self.GetBundleContentsFolderPath(), "Info.plist")
+        else:
+            return os.path.join(
+                self.GetBundleContentsFolderPath(), "Resources", "Info.plist"
+            )
+
+    def GetProductType(self):
+        """Returns the PRODUCT_TYPE of this target."""
+        if self._IsIosAppExtension():
+            assert self._IsBundle(), (
+                "ios_app_extension flag requires mac_bundle "
+                "(target %s)" % self.spec["target_name"]
+            )
+            return "com.apple.product-type.app-extension"
+        if self._IsIosWatchKitExtension():
+            assert self._IsBundle(), (
+                "ios_watchkit_extension flag requires "
+                "mac_bundle (target %s)" % self.spec["target_name"]
+            )
+            return "com.apple.product-type.watchkit-extension"
+        if self._IsIosWatchApp():
+            assert self._IsBundle(), (
+                "ios_watch_app flag requires mac_bundle "
+                "(target %s)" % self.spec["target_name"]
+            )
+            return "com.apple.product-type.application.watchapp"
+        if self._IsXCUiTest():
+            assert self._IsBundle(), (
+                "mac_xcuitest_bundle flag requires mac_bundle "
+                "(target %s)" % self.spec["target_name"]
+            )
+            return "com.apple.product-type.bundle.ui-testing"
+        if self._IsBundle():
+            return {
+                "executable": "com.apple.product-type.application",
+                "loadable_module": "com.apple.product-type.bundle",
+                "shared_library": "com.apple.product-type.framework",
+            }[self.spec["type"]]
+        else:
+            return {
+                "executable": "com.apple.product-type.tool",
+                "loadable_module": "com.apple.product-type.library.dynamic",
+                "shared_library": "com.apple.product-type.library.dynamic",
+                "static_library": "com.apple.product-type.library.static",
+            }[self.spec["type"]]
+
+    def GetMachOType(self):
+        """Returns the MACH_O_TYPE of this target."""
+        # Weird, but matches Xcode.
+        if not self._IsBundle() and self.spec["type"] == "executable":
+            return ""
+        return {
+            "executable": "mh_execute",
+            "static_library": "staticlib",
+            "shared_library": "mh_dylib",
+            "loadable_module": "mh_bundle",
+        }[self.spec["type"]]
+
+    def _GetBundleBinaryPath(self):
+        """Returns the name of the bundle binary of by this target.
     E.g. Chromium.app/Contents/MacOS/Chromium. Only valid for bundles."""
-    assert self._IsBundle()
-    return os.path.join(self.GetBundleExecutableFolderPath(), \
-                        self.GetExecutableName())
-
-  def _GetStandaloneExecutableSuffix(self):
-    if 'product_extension' in self.spec:
-      return '.' + self.spec['product_extension']
-    return {
-      'executable': '',
-      'static_library': '.a',
-      'shared_library': '.dylib',
-      'loadable_module': '.so',
-    }[self.spec['type']]
-
-  def _GetStandaloneExecutablePrefix(self):
-    return self.spec.get('product_prefix', {
-      'executable': '',
-      'static_library': 'lib',
-      'shared_library': 'lib',
-      # Non-bundled loadable_modules are called foo.so for some reason
-      # (that is, .so and no prefix) with the xcode build -- match that.
-      'loadable_module': '',
-    }[self.spec['type']])
-
-  def _GetStandaloneBinaryPath(self):
-    """Returns the name of the non-bundle binary represented by this target.
+        assert self._IsBundle()
+        return os.path.join(
+            self.GetBundleExecutableFolderPath(), self.GetExecutableName()
+        )
+
+    def _GetStandaloneExecutableSuffix(self):
+        if "product_extension" in self.spec:
+            return "." + self.spec["product_extension"]
+        return {
+            "executable": "",
+            "static_library": ".a",
+            "shared_library": ".dylib",
+            "loadable_module": ".so",
+        }[self.spec["type"]]
+
+    def _GetStandaloneExecutablePrefix(self):
+        return self.spec.get(
+            "product_prefix",
+            {
+                "executable": "",
+                "static_library": "lib",
+                "shared_library": "lib",
+                # Non-bundled loadable_modules are called foo.so for some reason
+                # (that is, .so and no prefix) with the xcode build -- match that.
+                "loadable_module": "",
+            }[self.spec["type"]],
+        )
+
+    def _GetStandaloneBinaryPath(self):
+        """Returns the name of the non-bundle binary represented by this target.
     E.g. hello_world. Only valid for non-bundles."""
-    assert not self._IsBundle()
-    assert self.spec['type'] in (
-        'executable', 'shared_library', 'static_library', 'loadable_module'), (
-        'Unexpected type %s' % self.spec['type'])
-    target = self.spec['target_name']
-    if self.spec['type'] == 'static_library':
-      if target[:3] == 'lib':
-        target = target[3:]
-    elif self.spec['type'] in ('loadable_module', 'shared_library'):
-      if target[:3] == 'lib':
-        target = target[3:]
-
-    target_prefix = self._GetStandaloneExecutablePrefix()
-    target = self.spec.get('product_name', target)
-    target_ext = self._GetStandaloneExecutableSuffix()
-    return target_prefix + target + target_ext
-
-  def GetExecutableName(self):
-    """Returns the executable name of the bundle represented by this target.
+        assert not self._IsBundle()
+        assert self.spec["type"] in (
+            "executable",
+            "shared_library",
+            "static_library",
+            "loadable_module",
+        ), ("Unexpected type %s" % self.spec["type"])
+        target = self.spec["target_name"]
+        if self.spec["type"] == "static_library":
+            if target[:3] == "lib":
+                target = target[3:]
+        elif self.spec["type"] in ("loadable_module", "shared_library"):
+            if target[:3] == "lib":
+                target = target[3:]
+
+        target_prefix = self._GetStandaloneExecutablePrefix()
+        target = self.spec.get("product_name", target)
+        target_ext = self._GetStandaloneExecutableSuffix()
+        return target_prefix + target + target_ext
+
+    def GetExecutableName(self):
+        """Returns the executable name of the bundle represented by this target.
     E.g. Chromium."""
-    if self._IsBundle():
-      return self.spec.get('product_name', self.spec['target_name'])
-    else:
-      return self._GetStandaloneBinaryPath()
+        if self._IsBundle():
+            return self.spec.get("product_name", self.spec["target_name"])
+        else:
+            return self._GetStandaloneBinaryPath()
 
-  def GetExecutablePath(self):
-    """Returns the qualified path to the primary executable of the bundle
+    def GetExecutablePath(self):
+        """Returns the qualified path to the primary executable of the bundle
     represented by this target. E.g. Chromium.app/Contents/MacOS/Chromium."""
-    if self._IsBundle():
-      return self._GetBundleBinaryPath()
-    else:
-      return self._GetStandaloneBinaryPath()
-
-  def GetActiveArchs(self, configname):
-    """Returns the architectures this target should be built for."""
-    config_settings = self.xcode_settings[configname]
-    xcode_archs_default = GetXcodeArchsDefault()
-    return xcode_archs_default.ActiveArchs(
-        config_settings.get('ARCHS'),
-        config_settings.get('VALID_ARCHS'),
-        config_settings.get('SDKROOT'))
-
-  def _GetSdkVersionInfoItem(self, sdk, infoitem):
-    # xcodebuild requires Xcode and can't run on Command Line Tools-only
-    # systems from 10.7 onward.
-    # Since the CLT has no SDK paths anyway, returning None is the
-    # most sensible route and should still do the right thing.
-    try:
-      return GetStdoutQuiet(['xcrun', '--sdk', sdk, infoitem])
-    except GypError:
-      pass
-
-  def _SdkRoot(self, configname):
-    if configname is None:
-      configname = self.configname
-    return self.GetPerConfigSetting('SDKROOT', configname, default='')
-
-  def _XcodePlatformPath(self, configname=None):
-    sdk_root = self._SdkRoot(configname)
-    if sdk_root not in XcodeSettings._platform_path_cache:
-      platform_path = self._GetSdkVersionInfoItem(sdk_root,
-                                                  '--show-sdk-platform-path')
-      XcodeSettings._platform_path_cache[sdk_root] = platform_path
-    return XcodeSettings._platform_path_cache[sdk_root]
-
-  def _SdkPath(self, configname=None):
-    sdk_root = self._SdkRoot(configname)
-    if sdk_root.startswith('/'):
-      return sdk_root
-    return self._XcodeSdkPath(sdk_root)
-
-  def _XcodeSdkPath(self, sdk_root):
-    if sdk_root not in XcodeSettings._sdk_path_cache:
-      sdk_path = self._GetSdkVersionInfoItem(sdk_root, '--show-sdk-path')
-      XcodeSettings._sdk_path_cache[sdk_root] = sdk_path
-      if sdk_root:
-        XcodeSettings._sdk_root_cache[sdk_path] = sdk_root
-    return XcodeSettings._sdk_path_cache[sdk_root]
-
-  def _AppendPlatformVersionMinFlags(self, lst):
-    self._Appendf(lst, 'MACOSX_DEPLOYMENT_TARGET', '-mmacosx-version-min=%s')
-    if 'IPHONEOS_DEPLOYMENT_TARGET' in self._Settings():
-      # TODO: Implement this better?
-      sdk_path_basename = os.path.basename(self._SdkPath())
-      if sdk_path_basename.lower().startswith('iphonesimulator'):
-        self._Appendf(lst, 'IPHONEOS_DEPLOYMENT_TARGET',
-                      '-mios-simulator-version-min=%s')
-      else:
-        self._Appendf(lst, 'IPHONEOS_DEPLOYMENT_TARGET',
-                      '-miphoneos-version-min=%s')
-
-  def GetCflags(self, configname, arch=None):
-    """Returns flags that need to be added to .c, .cc, .m, and .mm
+        if self._IsBundle():
+            return self._GetBundleBinaryPath()
+        else:
+            return self._GetStandaloneBinaryPath()
+
+    def GetActiveArchs(self, configname):
+        """Returns the architectures this target should be built for."""
+        config_settings = self.xcode_settings[configname]
+        xcode_archs_default = GetXcodeArchsDefault()
+        return xcode_archs_default.ActiveArchs(
+            config_settings.get("ARCHS"),
+            config_settings.get("VALID_ARCHS"),
+            config_settings.get("SDKROOT"),
+        )
+
+    def _GetSdkVersionInfoItem(self, sdk, infoitem):
+        # xcodebuild requires Xcode and can't run on Command Line Tools-only
+        # systems from 10.7 onward.
+        # Since the CLT has no SDK paths anyway, returning None is the
+        # most sensible route and should still do the right thing.
+        try:
+            return GetStdoutQuiet(["xcrun", "--sdk", sdk, infoitem])
+        except GypError:
+            pass
+
+    def _SdkRoot(self, configname):
+        if configname is None:
+            configname = self.configname
+        return self.GetPerConfigSetting("SDKROOT", configname, default="")
+
+    def _XcodePlatformPath(self, configname=None):
+        sdk_root = self._SdkRoot(configname)
+        if sdk_root not in XcodeSettings._platform_path_cache:
+            platform_path = self._GetSdkVersionInfoItem(
+                sdk_root, "--show-sdk-platform-path"
+            )
+            XcodeSettings._platform_path_cache[sdk_root] = platform_path
+        return XcodeSettings._platform_path_cache[sdk_root]
+
+    def _SdkPath(self, configname=None):
+        sdk_root = self._SdkRoot(configname)
+        if sdk_root.startswith("/"):
+            return sdk_root
+        return self._XcodeSdkPath(sdk_root)
+
+    def _XcodeSdkPath(self, sdk_root):
+        if sdk_root not in XcodeSettings._sdk_path_cache:
+            sdk_path = self._GetSdkVersionInfoItem(sdk_root, "--show-sdk-path")
+            XcodeSettings._sdk_path_cache[sdk_root] = sdk_path
+            if sdk_root:
+                XcodeSettings._sdk_root_cache[sdk_path] = sdk_root
+        return XcodeSettings._sdk_path_cache[sdk_root]
+
+    def _AppendPlatformVersionMinFlags(self, lst):
+        self._Appendf(lst, "MACOSX_DEPLOYMENT_TARGET", "-mmacosx-version-min=%s")
+        if "IPHONEOS_DEPLOYMENT_TARGET" in self._Settings():
+            # TODO: Implement this better?
+            sdk_path_basename = os.path.basename(self._SdkPath())
+            if sdk_path_basename.lower().startswith("iphonesimulator"):
+                self._Appendf(
+                    lst, "IPHONEOS_DEPLOYMENT_TARGET", "-mios-simulator-version-min=%s"
+                )
+            else:
+                self._Appendf(
+                    lst, "IPHONEOS_DEPLOYMENT_TARGET", "-miphoneos-version-min=%s"
+                )
+
+    def GetCflags(self, configname, arch=None):
+        """Returns flags that need to be added to .c, .cc, .m, and .mm
     compilations."""
-    # This functions (and the similar ones below) do not offer complete
-    # emulation of all xcode_settings keys. They're implemented on demand.
+        # This functions (and the similar ones below) do not offer complete
+        # emulation of all xcode_settings keys. They're implemented on demand.
 
-    self.configname = configname
-    cflags = []
+        self.configname = configname
+        cflags = []
 
-    sdk_root = self._SdkPath()
-    if 'SDKROOT' in self._Settings() and sdk_root:
-      cflags.append('-isysroot %s' % sdk_root)
+        sdk_root = self._SdkPath()
+        if "SDKROOT" in self._Settings() and sdk_root:
+            cflags.append("-isysroot %s" % sdk_root)
 
-    if self.header_map_path:
-      cflags.append('-I%s' % self.header_map_path)
+        if self.header_map_path:
+            cflags.append("-I%s" % self.header_map_path)
 
-    if self._Test('CLANG_WARN_CONSTANT_CONVERSION', 'YES', default='NO'):
-      cflags.append('-Wconstant-conversion')
+        if self._Test("CLANG_WARN_CONSTANT_CONVERSION", "YES", default="NO"):
+            cflags.append("-Wconstant-conversion")
 
-    if self._Test('GCC_CHAR_IS_UNSIGNED_CHAR', 'YES', default='NO'):
-      cflags.append('-funsigned-char')
+        if self._Test("GCC_CHAR_IS_UNSIGNED_CHAR", "YES", default="NO"):
+            cflags.append("-funsigned-char")
 
-    if self._Test('GCC_CW_ASM_SYNTAX', 'YES', default='YES'):
-      cflags.append('-fasm-blocks')
+        if self._Test("GCC_CW_ASM_SYNTAX", "YES", default="YES"):
+            cflags.append("-fasm-blocks")
 
-    if 'GCC_DYNAMIC_NO_PIC' in self._Settings():
-      if self._Settings()['GCC_DYNAMIC_NO_PIC'] == 'YES':
-        cflags.append('-mdynamic-no-pic')
-    else:
-      pass
-      # TODO: In this case, it depends on the target. xcode passes
-      # mdynamic-no-pic by default for executable and possibly static lib
-      # according to mento
-
-    if self._Test('GCC_ENABLE_PASCAL_STRINGS', 'YES', default='YES'):
-      cflags.append('-mpascal-strings')
-
-    self._Appendf(cflags, 'GCC_OPTIMIZATION_LEVEL', '-O%s', default='s')
-
-    if self._Test('GCC_GENERATE_DEBUGGING_SYMBOLS', 'YES', default='YES'):
-      dbg_format = self._Settings().get('DEBUG_INFORMATION_FORMAT', 'dwarf')
-      if dbg_format == 'dwarf':
-        cflags.append('-gdwarf-2')
-      elif dbg_format == 'stabs':
-        raise NotImplementedError('stabs debug format is not supported yet.')
-      elif dbg_format == 'dwarf-with-dsym':
-        cflags.append('-gdwarf-2')
-      else:
-        raise NotImplementedError('Unknown debug format %s' % dbg_format)
-
-    if self._Settings().get('GCC_STRICT_ALIASING') == 'YES':
-      cflags.append('-fstrict-aliasing')
-    elif self._Settings().get('GCC_STRICT_ALIASING') == 'NO':
-      cflags.append('-fno-strict-aliasing')
-
-    if self._Test('GCC_SYMBOLS_PRIVATE_EXTERN', 'YES', default='NO'):
-      cflags.append('-fvisibility=hidden')
-
-    if self._Test('GCC_TREAT_WARNINGS_AS_ERRORS', 'YES', default='NO'):
-      cflags.append('-Werror')
-
-    if self._Test('GCC_WARN_ABOUT_MISSING_NEWLINE', 'YES', default='NO'):
-      cflags.append('-Wnewline-eof')
-
-    # In Xcode, this is only activated when GCC_COMPILER_VERSION is clang or
-    # llvm-gcc. It also requires a fairly recent libtool, and
-    # if the system clang isn't used, DYLD_LIBRARY_PATH needs to contain the
-    # path to the libLTO.dylib that matches the used clang.
-    if self._Test('LLVM_LTO', 'YES', default='NO'):
-      cflags.append('-flto')
-
-    self._AppendPlatformVersionMinFlags(cflags)
-
-    # TODO:
-    if self._Test('COPY_PHASE_STRIP', 'YES', default='NO'):
-      self._WarnUnimplemented('COPY_PHASE_STRIP')
-    self._WarnUnimplemented('GCC_DEBUGGING_SYMBOLS')
-    self._WarnUnimplemented('GCC_ENABLE_OBJC_EXCEPTIONS')
-
-    # TODO: This is exported correctly, but assigning to it is not supported.
-    self._WarnUnimplemented('MACH_O_TYPE')
-    self._WarnUnimplemented('PRODUCT_TYPE')
-
-    if arch is not None:
-      archs = [arch]
-    else:
-      assert self.configname
-      archs = self.GetActiveArchs(self.configname)
-    if len(archs) != 1:
-      # TODO: Supporting fat binaries will be annoying.
-      self._WarnUnimplemented('ARCHS')
-      archs = ['i386']
-    cflags.append('-arch ' + archs[0])
-
-    if archs[0] in ('i386', 'x86_64'):
-      if self._Test('GCC_ENABLE_SSE3_EXTENSIONS', 'YES', default='NO'):
-        cflags.append('-msse3')
-      if self._Test('GCC_ENABLE_SUPPLEMENTAL_SSE3_INSTRUCTIONS', 'YES',
-                    default='NO'):
-        cflags.append('-mssse3')  # Note 3rd 's'.
-      if self._Test('GCC_ENABLE_SSE41_EXTENSIONS', 'YES', default='NO'):
-        cflags.append('-msse4.1')
-      if self._Test('GCC_ENABLE_SSE42_EXTENSIONS', 'YES', default='NO'):
-        cflags.append('-msse4.2')
-
-    cflags += self._Settings().get('WARNING_CFLAGS', [])
-
-    if self._IsXCTest():
-      platform_root = self._XcodePlatformPath(configname)
-      if platform_root:
-        cflags.append('-F' + platform_root + '/Developer/Library/Frameworks/')
-
-    if sdk_root:
-      framework_root = sdk_root
-    else:
-      framework_root = ''
-    config = self.spec['configurations'][self.configname]
-    framework_dirs = config.get('mac_framework_dirs', [])
-    for directory in framework_dirs:
-      cflags.append('-F' + directory.replace('$(SDKROOT)', framework_root))
-
-    self.configname = None
-    return cflags
-
-  def GetCflagsC(self, configname):
-    """Returns flags that need to be added to .c, and .m compilations."""
-    self.configname = configname
-    cflags_c = []
-    if self._Settings().get('GCC_C_LANGUAGE_STANDARD', '') == 'ansi':
-      cflags_c.append('-ansi')
-    else:
-      self._Appendf(cflags_c, 'GCC_C_LANGUAGE_STANDARD', '-std=%s')
-    cflags_c += self._Settings().get('OTHER_CFLAGS', [])
-    self.configname = None
-    return cflags_c
-
-  def GetCflagsCC(self, configname):
-    """Returns flags that need to be added to .cc, and .mm compilations."""
-    self.configname = configname
-    cflags_cc = []
-
-    clang_cxx_language_standard = self._Settings().get(
-        'CLANG_CXX_LANGUAGE_STANDARD')
-    # Note: Don't make c++0x to c++11 so that c++0x can be used with older
-    # clangs that don't understand c++11 yet (like Xcode 4.2's).
-    if clang_cxx_language_standard:
-      cflags_cc.append('-std=%s' % clang_cxx_language_standard)
-
-    self._Appendf(cflags_cc, 'CLANG_CXX_LIBRARY', '-stdlib=%s')
-
-    if self._Test('GCC_ENABLE_CPP_RTTI', 'NO', default='YES'):
-      cflags_cc.append('-fno-rtti')
-    if self._Test('GCC_ENABLE_CPP_EXCEPTIONS', 'NO', default='YES'):
-      cflags_cc.append('-fno-exceptions')
-    if self._Test('GCC_INLINES_ARE_PRIVATE_EXTERN', 'YES', default='NO'):
-      cflags_cc.append('-fvisibility-inlines-hidden')
-    if self._Test('GCC_THREADSAFE_STATICS', 'NO', default='YES'):
-      cflags_cc.append('-fno-threadsafe-statics')
-    # Note: This flag is a no-op for clang, it only has an effect for gcc.
-    if self._Test('GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO', 'NO', default='YES'):
-      cflags_cc.append('-Wno-invalid-offsetof')
-
-    other_ccflags = []
-
-    for flag in self._Settings().get('OTHER_CPLUSPLUSFLAGS', ['$(inherited)']):
-      # TODO: More general variable expansion. Missing in many other places too.
-      if flag in ('$inherited', '$(inherited)', '${inherited}'):
-        flag = '$OTHER_CFLAGS'
-      if flag in ('$OTHER_CFLAGS', '$(OTHER_CFLAGS)', '${OTHER_CFLAGS}'):
-        other_ccflags += self._Settings().get('OTHER_CFLAGS', [])
-      else:
-        other_ccflags.append(flag)
-    cflags_cc += other_ccflags
-
-    self.configname = None
-    return cflags_cc
-
-  def _AddObjectiveCGarbageCollectionFlags(self, flags):
-    gc_policy = self._Settings().get('GCC_ENABLE_OBJC_GC', 'unsupported')
-    if gc_policy == 'supported':
-      flags.append('-fobjc-gc')
-    elif gc_policy == 'required':
-      flags.append('-fobjc-gc-only')
-
-  def _AddObjectiveCARCFlags(self, flags):
-    if self._Test('CLANG_ENABLE_OBJC_ARC', 'YES', default='NO'):
-      flags.append('-fobjc-arc')
-
-  def _AddObjectiveCMissingPropertySynthesisFlags(self, flags):
-    if self._Test('CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS',
-                  'YES', default='NO'):
-      flags.append('-Wobjc-missing-property-synthesis')
-
-  def GetCflagsObjC(self, configname):
-    """Returns flags that need to be added to .m compilations."""
-    self.configname = configname
-    cflags_objc = []
-    self._AddObjectiveCGarbageCollectionFlags(cflags_objc)
-    self._AddObjectiveCARCFlags(cflags_objc)
-    self._AddObjectiveCMissingPropertySynthesisFlags(cflags_objc)
-    self.configname = None
-    return cflags_objc
-
-  def GetCflagsObjCC(self, configname):
-    """Returns flags that need to be added to .mm compilations."""
-    self.configname = configname
-    cflags_objcc = []
-    self._AddObjectiveCGarbageCollectionFlags(cflags_objcc)
-    self._AddObjectiveCARCFlags(cflags_objcc)
-    self._AddObjectiveCMissingPropertySynthesisFlags(cflags_objcc)
-    if self._Test('GCC_OBJC_CALL_CXX_CDTORS', 'YES', default='NO'):
-      cflags_objcc.append('-fobjc-call-cxx-cdtors')
-    self.configname = None
-    return cflags_objcc
-
-  def GetInstallNameBase(self):
-    """Return DYLIB_INSTALL_NAME_BASE for this target."""
-    # Xcode sets this for shared_libraries, and for nonbundled loadable_modules.
-    if (self.spec['type'] != 'shared_library' and
-        (self.spec['type'] != 'loadable_module' or self._IsBundle())):
-      return None
-    install_base = self.GetPerTargetSetting(
-        'DYLIB_INSTALL_NAME_BASE',
-        default='/Library/Frameworks' if self._IsBundle() else '/usr/local/lib')
-    return install_base
-
-  def _StandardizePath(self, path):
-    """Do :standardizepath processing for path."""
-    # I'm not quite sure what :standardizepath does. Just call normpath(),
-    # but don't let @executable_path/../foo collapse to foo.
-    if '/' in path:
-      prefix, rest = '', path
-      if path.startswith('@'):
-        prefix, rest = path.split('/', 1)
-      rest = os.path.normpath(rest)  # :standardizepath
-      path = os.path.join(prefix, rest)
-    return path
-
-  def GetInstallName(self):
-    """Return LD_DYLIB_INSTALL_NAME for this target."""
-    # Xcode sets this for shared_libraries, and for nonbundled loadable_modules.
-    if (self.spec['type'] != 'shared_library' and
-        (self.spec['type'] != 'loadable_module' or self._IsBundle())):
-      return None
-
-    default_install_name = \
-        '$(DYLIB_INSTALL_NAME_BASE:standardizepath)/$(EXECUTABLE_PATH)'
-    install_name = self.GetPerTargetSetting(
-        'LD_DYLIB_INSTALL_NAME', default=default_install_name)
-
-    # Hardcode support for the variables used in chromium for now, to
-    # unblock people using the make build.
-    if '$' in install_name:
-      assert install_name in ('$(DYLIB_INSTALL_NAME_BASE:standardizepath)/'
-          '$(WRAPPER_NAME)/$(PRODUCT_NAME)', default_install_name), (
-          'Variables in LD_DYLIB_INSTALL_NAME are not generally supported '
-          'yet in target \'%s\' (got \'%s\')' %
-              (self.spec['target_name'], install_name))
-
-      install_name = install_name.replace(
-          '$(DYLIB_INSTALL_NAME_BASE:standardizepath)',
-          self._StandardizePath(self.GetInstallNameBase()))
-      if self._IsBundle():
-        # These are only valid for bundles, hence the |if|.
-        install_name = install_name.replace(
-            '$(WRAPPER_NAME)', self.GetWrapperName())
-        install_name = install_name.replace(
-            '$(PRODUCT_NAME)', self.GetProductName())
-      else:
-        assert '$(WRAPPER_NAME)' not in install_name
-        assert '$(PRODUCT_NAME)' not in install_name
-
-      install_name = install_name.replace(
-          '$(EXECUTABLE_PATH)', self.GetExecutablePath())
-    return install_name
-
-  def _MapLinkerFlagFilename(self, ldflag, gyp_to_build_path):
-    """Checks if ldflag contains a filename and if so remaps it from
+        if "GCC_DYNAMIC_NO_PIC" in self._Settings():
+            if self._Settings()["GCC_DYNAMIC_NO_PIC"] == "YES":
+                cflags.append("-mdynamic-no-pic")
+        else:
+            pass
+            # TODO: In this case, it depends on the target. xcode passes
+            # mdynamic-no-pic by default for executable and possibly static lib
+            # according to mento
+
+        if self._Test("GCC_ENABLE_PASCAL_STRINGS", "YES", default="YES"):
+            cflags.append("-mpascal-strings")
+
+        self._Appendf(cflags, "GCC_OPTIMIZATION_LEVEL", "-O%s", default="s")
+
+        if self._Test("GCC_GENERATE_DEBUGGING_SYMBOLS", "YES", default="YES"):
+            dbg_format = self._Settings().get("DEBUG_INFORMATION_FORMAT", "dwarf")
+            if dbg_format == "dwarf":
+                cflags.append("-gdwarf-2")
+            elif dbg_format == "stabs":
+                raise NotImplementedError("stabs debug format is not supported yet.")
+            elif dbg_format == "dwarf-with-dsym":
+                cflags.append("-gdwarf-2")
+            else:
+                raise NotImplementedError("Unknown debug format %s" % dbg_format)
+
+        if self._Settings().get("GCC_STRICT_ALIASING") == "YES":
+            cflags.append("-fstrict-aliasing")
+        elif self._Settings().get("GCC_STRICT_ALIASING") == "NO":
+            cflags.append("-fno-strict-aliasing")
+
+        if self._Test("GCC_SYMBOLS_PRIVATE_EXTERN", "YES", default="NO"):
+            cflags.append("-fvisibility=hidden")
+
+        if self._Test("GCC_TREAT_WARNINGS_AS_ERRORS", "YES", default="NO"):
+            cflags.append("-Werror")
+
+        if self._Test("GCC_WARN_ABOUT_MISSING_NEWLINE", "YES", default="NO"):
+            cflags.append("-Wnewline-eof")
+
+        # In Xcode, this is only activated when GCC_COMPILER_VERSION is clang or
+        # llvm-gcc. It also requires a fairly recent libtool, and
+        # if the system clang isn't used, DYLD_LIBRARY_PATH needs to contain the
+        # path to the libLTO.dylib that matches the used clang.
+        if self._Test("LLVM_LTO", "YES", default="NO"):
+            cflags.append("-flto")
+
+        self._AppendPlatformVersionMinFlags(cflags)
+
+        # TODO:
+        if self._Test("COPY_PHASE_STRIP", "YES", default="NO"):
+            self._WarnUnimplemented("COPY_PHASE_STRIP")
+        self._WarnUnimplemented("GCC_DEBUGGING_SYMBOLS")
+        self._WarnUnimplemented("GCC_ENABLE_OBJC_EXCEPTIONS")
+
+        # TODO: This is exported correctly, but assigning to it is not supported.
+        self._WarnUnimplemented("MACH_O_TYPE")
+        self._WarnUnimplemented("PRODUCT_TYPE")
+
+        # If GYP_CROSSCOMPILE (--cross-compiling), disable architecture-specific
+        # additions and assume these will be provided as required via CC_host,
+        # CXX_host, CC_target and CXX_target.
+        if not gyp.common.CrossCompileRequested():
+            if arch is not None:
+                archs = [arch]
+            else:
+                assert self.configname
+                archs = self.GetActiveArchs(self.configname)
+            if len(archs) != 1:
+                # TODO: Supporting fat binaries will be annoying.
+                self._WarnUnimplemented("ARCHS")
+                archs = ["i386"]
+            cflags.append("-arch " + archs[0])
+
+            if archs[0] in ("i386", "x86_64"):
+                if self._Test("GCC_ENABLE_SSE3_EXTENSIONS", "YES", default="NO"):
+                    cflags.append("-msse3")
+                if self._Test(
+                    "GCC_ENABLE_SUPPLEMENTAL_SSE3_INSTRUCTIONS", "YES", default="NO"
+                ):
+                    cflags.append("-mssse3")  # Note 3rd 's'.
+                if self._Test("GCC_ENABLE_SSE41_EXTENSIONS", "YES", default="NO"):
+                    cflags.append("-msse4.1")
+                if self._Test("GCC_ENABLE_SSE42_EXTENSIONS", "YES", default="NO"):
+                    cflags.append("-msse4.2")
+
+        cflags += self._Settings().get("WARNING_CFLAGS", [])
+
+        if self._IsXCTest():
+            platform_root = self._XcodePlatformPath(configname)
+            if platform_root:
+                cflags.append("-F" + platform_root + "/Developer/Library/Frameworks/")
+
+        if sdk_root:
+            framework_root = sdk_root
+        else:
+            framework_root = ""
+        config = self.spec["configurations"][self.configname]
+        framework_dirs = config.get("mac_framework_dirs", [])
+        for directory in framework_dirs:
+            cflags.append("-F" + directory.replace("$(SDKROOT)", framework_root))
+
+        self.configname = None
+        return cflags
+
+    def GetCflagsC(self, configname):
+        """Returns flags that need to be added to .c, and .m compilations."""
+        self.configname = configname
+        cflags_c = []
+        if self._Settings().get("GCC_C_LANGUAGE_STANDARD", "") == "ansi":
+            cflags_c.append("-ansi")
+        else:
+            self._Appendf(cflags_c, "GCC_C_LANGUAGE_STANDARD", "-std=%s")
+        cflags_c += self._Settings().get("OTHER_CFLAGS", [])
+        self.configname = None
+        return cflags_c
+
+    def GetCflagsCC(self, configname):
+        """Returns flags that need to be added to .cc, and .mm compilations."""
+        self.configname = configname
+        cflags_cc = []
+
+        clang_cxx_language_standard = self._Settings().get(
+            "CLANG_CXX_LANGUAGE_STANDARD"
+        )
+        # Note: Don't make c++0x to c++11 so that c++0x can be used with older
+        # clangs that don't understand c++11 yet (like Xcode 4.2's).
+        if clang_cxx_language_standard:
+            cflags_cc.append("-std=%s" % clang_cxx_language_standard)
+
+        self._Appendf(cflags_cc, "CLANG_CXX_LIBRARY", "-stdlib=%s")
+
+        if self._Test("GCC_ENABLE_CPP_RTTI", "NO", default="YES"):
+            cflags_cc.append("-fno-rtti")
+        if self._Test("GCC_ENABLE_CPP_EXCEPTIONS", "NO", default="YES"):
+            cflags_cc.append("-fno-exceptions")
+        if self._Test("GCC_INLINES_ARE_PRIVATE_EXTERN", "YES", default="NO"):
+            cflags_cc.append("-fvisibility-inlines-hidden")
+        if self._Test("GCC_THREADSAFE_STATICS", "NO", default="YES"):
+            cflags_cc.append("-fno-threadsafe-statics")
+        # Note: This flag is a no-op for clang, it only has an effect for gcc.
+        if self._Test("GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO", "NO", default="YES"):
+            cflags_cc.append("-Wno-invalid-offsetof")
+
+        other_ccflags = []
+
+        for flag in self._Settings().get("OTHER_CPLUSPLUSFLAGS", ["$(inherited)"]):
+            # TODO: More general variable expansion. Missing in many other places too.
+            if flag in ("$inherited", "$(inherited)", "${inherited}"):
+                flag = "$OTHER_CFLAGS"
+            if flag in ("$OTHER_CFLAGS", "$(OTHER_CFLAGS)", "${OTHER_CFLAGS}"):
+                other_ccflags += self._Settings().get("OTHER_CFLAGS", [])
+            else:
+                other_ccflags.append(flag)
+        cflags_cc += other_ccflags
+
+        self.configname = None
+        return cflags_cc
+
+    def _AddObjectiveCGarbageCollectionFlags(self, flags):
+        gc_policy = self._Settings().get("GCC_ENABLE_OBJC_GC", "unsupported")
+        if gc_policy == "supported":
+            flags.append("-fobjc-gc")
+        elif gc_policy == "required":
+            flags.append("-fobjc-gc-only")
+
+    def _AddObjectiveCARCFlags(self, flags):
+        if self._Test("CLANG_ENABLE_OBJC_ARC", "YES", default="NO"):
+            flags.append("-fobjc-arc")
+
+    def _AddObjectiveCMissingPropertySynthesisFlags(self, flags):
+        if self._Test(
+            "CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS", "YES", default="NO"
+        ):
+            flags.append("-Wobjc-missing-property-synthesis")
+
+    def GetCflagsObjC(self, configname):
+        """Returns flags that need to be added to .m compilations."""
+        self.configname = configname
+        cflags_objc = []
+        self._AddObjectiveCGarbageCollectionFlags(cflags_objc)
+        self._AddObjectiveCARCFlags(cflags_objc)
+        self._AddObjectiveCMissingPropertySynthesisFlags(cflags_objc)
+        self.configname = None
+        return cflags_objc
+
+    def GetCflagsObjCC(self, configname):
+        """Returns flags that need to be added to .mm compilations."""
+        self.configname = configname
+        cflags_objcc = []
+        self._AddObjectiveCGarbageCollectionFlags(cflags_objcc)
+        self._AddObjectiveCARCFlags(cflags_objcc)
+        self._AddObjectiveCMissingPropertySynthesisFlags(cflags_objcc)
+        if self._Test("GCC_OBJC_CALL_CXX_CDTORS", "YES", default="NO"):
+            cflags_objcc.append("-fobjc-call-cxx-cdtors")
+        self.configname = None
+        return cflags_objcc
+
+    def GetInstallNameBase(self):
+        """Return DYLIB_INSTALL_NAME_BASE for this target."""
+        # Xcode sets this for shared_libraries, and for nonbundled loadable_modules.
+        if self.spec["type"] != "shared_library" and (
+            self.spec["type"] != "loadable_module" or self._IsBundle()
+        ):
+            return None
+        install_base = self.GetPerTargetSetting(
+            "DYLIB_INSTALL_NAME_BASE",
+            default="/Library/Frameworks" if self._IsBundle() else "/usr/local/lib",
+        )
+        return install_base
+
+    def _StandardizePath(self, path):
+        """Do :standardizepath processing for path."""
+        # I'm not quite sure what :standardizepath does. Just call normpath(),
+        # but don't let @executable_path/../foo collapse to foo.
+        if "/" in path:
+            prefix, rest = "", path
+            if path.startswith("@"):
+                prefix, rest = path.split("/", 1)
+            rest = os.path.normpath(rest)  # :standardizepath
+            path = os.path.join(prefix, rest)
+        return path
+
+    def GetInstallName(self):
+        """Return LD_DYLIB_INSTALL_NAME for this target."""
+        # Xcode sets this for shared_libraries, and for nonbundled loadable_modules.
+        if self.spec["type"] != "shared_library" and (
+            self.spec["type"] != "loadable_module" or self._IsBundle()
+        ):
+            return None
+
+        default_install_name = (
+            "$(DYLIB_INSTALL_NAME_BASE:standardizepath)/$(EXECUTABLE_PATH)"
+        )
+        install_name = self.GetPerTargetSetting(
+            "LD_DYLIB_INSTALL_NAME", default=default_install_name
+        )
+
+        # Hardcode support for the variables used in chromium for now, to
+        # unblock people using the make build.
+        if "$" in install_name:
+            assert install_name in (
+                "$(DYLIB_INSTALL_NAME_BASE:standardizepath)/"
+                "$(WRAPPER_NAME)/$(PRODUCT_NAME)",
+                default_install_name,
+            ), (
+                "Variables in LD_DYLIB_INSTALL_NAME are not generally supported "
+                "yet in target '%s' (got '%s')"
+                % (self.spec["target_name"], install_name)
+            )
+
+            install_name = install_name.replace(
+                "$(DYLIB_INSTALL_NAME_BASE:standardizepath)",
+                self._StandardizePath(self.GetInstallNameBase()),
+            )
+            if self._IsBundle():
+                # These are only valid for bundles, hence the |if|.
+                install_name = install_name.replace(
+                    "$(WRAPPER_NAME)", self.GetWrapperName()
+                )
+                install_name = install_name.replace(
+                    "$(PRODUCT_NAME)", self.GetProductName()
+                )
+            else:
+                assert "$(WRAPPER_NAME)" not in install_name
+                assert "$(PRODUCT_NAME)" not in install_name
+
+            install_name = install_name.replace(
+                "$(EXECUTABLE_PATH)", self.GetExecutablePath()
+            )
+        return install_name
+
+    def _MapLinkerFlagFilename(self, ldflag, gyp_to_build_path):
+        """Checks if ldflag contains a filename and if so remaps it from
     gyp-directory-relative to build-directory-relative."""
-    # This list is expanded on demand.
-    # They get matched as:
-    #   -exported_symbols_list file
-    #   -Wl,exported_symbols_list file
-    #   -Wl,exported_symbols_list,file
-    LINKER_FILE = r'(\S+)'
-    WORD = r'\S+'
-    linker_flags = [
-      ['-exported_symbols_list', LINKER_FILE],    # Needed for NaCl.
-      ['-unexported_symbols_list', LINKER_FILE],
-      ['-reexported_symbols_list', LINKER_FILE],
-      ['-sectcreate', WORD, WORD, LINKER_FILE],   # Needed for remoting.
-    ]
-    for flag_pattern in linker_flags:
-      regex = re.compile('(?:-Wl,)?' + '[ ,]'.join(flag_pattern))
-      m = regex.match(ldflag)
-      if m:
-        ldflag = ldflag[:m.start(1)] + gyp_to_build_path(m.group(1)) + \
-                 ldflag[m.end(1):]
-    # Required for ffmpeg (no idea why they don't use LIBRARY_SEARCH_PATHS,
-    # TODO(thakis): Update ffmpeg.gyp):
-    if ldflag.startswith('-L'):
-      ldflag = '-L' + gyp_to_build_path(ldflag[len('-L'):])
-    return ldflag
-
-  def GetLdflags(self, configname, product_dir, gyp_to_build_path, arch=None):
-    """Returns flags that need to be passed to the linker.
+        # This list is expanded on demand.
+        # They get matched as:
+        #   -exported_symbols_list file
+        #   -Wl,exported_symbols_list file
+        #   -Wl,exported_symbols_list,file
+        LINKER_FILE = r"(\S+)"
+        WORD = r"\S+"
+        linker_flags = [
+            ["-exported_symbols_list", LINKER_FILE],  # Needed for NaCl.
+            ["-unexported_symbols_list", LINKER_FILE],
+            ["-reexported_symbols_list", LINKER_FILE],
+            ["-sectcreate", WORD, WORD, LINKER_FILE],  # Needed for remoting.
+        ]
+        for flag_pattern in linker_flags:
+            regex = re.compile("(?:-Wl,)?" + "[ ,]".join(flag_pattern))
+            m = regex.match(ldflag)
+            if m:
+                ldflag = (
+                    ldflag[: m.start(1)]
+                    + gyp_to_build_path(m.group(1))
+                    + ldflag[m.end(1) :]
+                )
+        # Required for ffmpeg (no idea why they don't use LIBRARY_SEARCH_PATHS,
+        # TODO(thakis): Update ffmpeg.gyp):
+        if ldflag.startswith("-L"):
+            ldflag = "-L" + gyp_to_build_path(ldflag[len("-L") :])
+        return ldflag
+
+    def GetLdflags(self, configname, product_dir, gyp_to_build_path, arch=None):
+        """Returns flags that need to be passed to the linker.
 
     Args:
         configname: The name of the configuration to get ld flags for.
@@ -856,431 +908,471 @@ class XcodeSettings(object):
         gyp_to_build_path: A function that converts paths relative to the
             current gyp file to paths relative to the build directory.
     """
-    self.configname = configname
-    ldflags = []
-
-    # The xcode build is relative to a gyp file's directory, and OTHER_LDFLAGS
-    # can contain entries that depend on this. Explicitly absolutify these.
-    for ldflag in self._Settings().get('OTHER_LDFLAGS', []):
-      ldflags.append(self._MapLinkerFlagFilename(ldflag, gyp_to_build_path))
-
-    if self._Test('DEAD_CODE_STRIPPING', 'YES', default='NO'):
-      ldflags.append('-Wl,-dead_strip')
-
-    if self._Test('PREBINDING', 'YES', default='NO'):
-      ldflags.append('-Wl,-prebind')
-
-    self._Appendf(
-        ldflags, 'DYLIB_COMPATIBILITY_VERSION', '-compatibility_version %s')
-    self._Appendf(
-        ldflags, 'DYLIB_CURRENT_VERSION', '-current_version %s')
-
-    self._AppendPlatformVersionMinFlags(ldflags)
-
-    if 'SDKROOT' in self._Settings() and self._SdkPath():
-      ldflags.append('-isysroot ' + self._SdkPath())
-
-    for library_path in self._Settings().get('LIBRARY_SEARCH_PATHS', []):
-      ldflags.append('-L' + gyp_to_build_path(library_path))
-
-    if 'ORDER_FILE' in self._Settings():
-      ldflags.append('-Wl,-order_file ' +
-                     '-Wl,' + gyp_to_build_path(
-                                  self._Settings()['ORDER_FILE']))
-
-    if arch is not None:
-      archs = [arch]
-    else:
-      assert self.configname
-      archs = self.GetActiveArchs(self.configname)
-    if len(archs) != 1:
-      # TODO: Supporting fat binaries will be annoying.
-      self._WarnUnimplemented('ARCHS')
-      archs = ['i386']
-    ldflags.append('-arch ' + archs[0])
-
-    # Xcode adds the product directory by default.
-    # Rewrite -L. to -L./ to work around http://www.openradar.me/25313838
-    ldflags.append('-L' + (product_dir if product_dir != '.' else './'))
-
-    install_name = self.GetInstallName()
-    if install_name and self.spec['type'] != 'loadable_module':
-      ldflags.append('-install_name ' + install_name.replace(' ', r'\ '))
-
-    for rpath in self._Settings().get('LD_RUNPATH_SEARCH_PATHS', []):
-      ldflags.append('-Wl,-rpath,' + rpath)
-
-    sdk_root = self._SdkPath()
-    if not sdk_root:
-      sdk_root = ''
-    config = self.spec['configurations'][self.configname]
-    framework_dirs = config.get('mac_framework_dirs', [])
-    for directory in framework_dirs:
-      ldflags.append('-F' + directory.replace('$(SDKROOT)', sdk_root))
-
-    if self._IsXCTest():
-      platform_root = self._XcodePlatformPath(configname)
-      if sdk_root and platform_root:
-        ldflags.append('-F' + platform_root + '/Developer/Library/Frameworks/')
-        ldflags.append('-framework XCTest')
-
-    is_extension = self._IsIosAppExtension() or self._IsIosWatchKitExtension()
-    if sdk_root and is_extension:
-      # Adds the link flags for extensions. These flags are common for all
-      # extensions and provide loader and main function.
-      # These flags reflect the compilation options used by xcode to compile
-      # extensions.
-      xcode_version, _ = XcodeVersion()
-      if xcode_version < '0900':
-        ldflags.append('-lpkstart')
-        ldflags.append(sdk_root +
-            '/System/Library/PrivateFrameworks/PlugInKit.framework/PlugInKit')
-      else:
-        ldflags.append('-e _NSExtensionMain')
-      ldflags.append('-fapplication-extension')
-
-    self._Appendf(ldflags, 'CLANG_CXX_LIBRARY', '-stdlib=%s')
-
-    self.configname = None
-    return ldflags
-
-  def GetLibtoolflags(self, configname):
-    """Returns flags that need to be passed to the static linker.
+        self.configname = configname
+        ldflags = []
+
+        # The xcode build is relative to a gyp file's directory, and OTHER_LDFLAGS
+        # can contain entries that depend on this. Explicitly absolutify these.
+        for ldflag in self._Settings().get("OTHER_LDFLAGS", []):
+            ldflags.append(self._MapLinkerFlagFilename(ldflag, gyp_to_build_path))
+
+        if self._Test("DEAD_CODE_STRIPPING", "YES", default="NO"):
+            ldflags.append("-Wl,-dead_strip")
+
+        if self._Test("PREBINDING", "YES", default="NO"):
+            ldflags.append("-Wl,-prebind")
+
+        self._Appendf(
+            ldflags, "DYLIB_COMPATIBILITY_VERSION", "-compatibility_version %s"
+        )
+        self._Appendf(ldflags, "DYLIB_CURRENT_VERSION", "-current_version %s")
+
+        self._AppendPlatformVersionMinFlags(ldflags)
+
+        if "SDKROOT" in self._Settings() and self._SdkPath():
+            ldflags.append("-isysroot " + self._SdkPath())
+
+        for library_path in self._Settings().get("LIBRARY_SEARCH_PATHS", []):
+            ldflags.append("-L" + gyp_to_build_path(library_path))
+
+        if "ORDER_FILE" in self._Settings():
+            ldflags.append(
+                "-Wl,-order_file "
+                + "-Wl,"
+                + gyp_to_build_path(self._Settings()["ORDER_FILE"])
+            )
+
+        if not gyp.common.CrossCompileRequested():
+            if arch is not None:
+                archs = [arch]
+            else:
+                assert self.configname
+                archs = self.GetActiveArchs(self.configname)
+            if len(archs) != 1:
+                # TODO: Supporting fat binaries will be annoying.
+                self._WarnUnimplemented("ARCHS")
+                archs = ["i386"]
+            ldflags.append("-arch " + archs[0])
+
+        # Xcode adds the product directory by default.
+        # Rewrite -L. to -L./ to work around http://www.openradar.me/25313838
+        ldflags.append("-L" + (product_dir if product_dir != "." else "./"))
+
+        install_name = self.GetInstallName()
+        if install_name and self.spec["type"] != "loadable_module":
+            ldflags.append("-install_name " + install_name.replace(" ", r"\ "))
+
+        for rpath in self._Settings().get("LD_RUNPATH_SEARCH_PATHS", []):
+            ldflags.append("-Wl,-rpath," + rpath)
+
+        sdk_root = self._SdkPath()
+        if not sdk_root:
+            sdk_root = ""
+        config = self.spec["configurations"][self.configname]
+        framework_dirs = config.get("mac_framework_dirs", [])
+        for directory in framework_dirs:
+            ldflags.append("-F" + directory.replace("$(SDKROOT)", sdk_root))
+
+        if self._IsXCTest():
+            platform_root = self._XcodePlatformPath(configname)
+            if sdk_root and platform_root:
+                ldflags.append("-F" + platform_root + "/Developer/Library/Frameworks/")
+                ldflags.append("-framework XCTest")
+
+        is_extension = self._IsIosAppExtension() or self._IsIosWatchKitExtension()
+        if sdk_root and is_extension:
+            # Adds the link flags for extensions. These flags are common for all
+            # extensions and provide loader and main function.
+            # These flags reflect the compilation options used by xcode to compile
+            # extensions.
+            xcode_version, _ = XcodeVersion()
+            if xcode_version < "0900":
+                ldflags.append("-lpkstart")
+                ldflags.append(
+                    sdk_root
+                    + "/System/Library/PrivateFrameworks/PlugInKit.framework/PlugInKit"
+                )
+            else:
+                ldflags.append("-e _NSExtensionMain")
+            ldflags.append("-fapplication-extension")
+
+        self._Appendf(ldflags, "CLANG_CXX_LIBRARY", "-stdlib=%s")
+
+        self.configname = None
+        return ldflags
+
+    def GetLibtoolflags(self, configname):
+        """Returns flags that need to be passed to the static linker.
 
     Args:
         configname: The name of the configuration to get ld flags for.
     """
-    self.configname = configname
-    libtoolflags = []
+        self.configname = configname
+        libtoolflags = []
 
-    for libtoolflag in self._Settings().get('OTHER_LDFLAGS', []):
-      libtoolflags.append(libtoolflag)
-    # TODO(thakis): ARCHS?
+        for libtoolflag in self._Settings().get("OTHER_LDFLAGS", []):
+            libtoolflags.append(libtoolflag)
+        # TODO(thakis): ARCHS?
 
-    self.configname = None
-    return libtoolflags
+        self.configname = None
+        return libtoolflags
 
-  def GetPerTargetSettings(self):
-    """Gets a list of all the per-target settings. This will only fetch keys
+    def GetPerTargetSettings(self):
+        """Gets a list of all the per-target settings. This will only fetch keys
     whose values are the same across all configurations."""
-    first_pass = True
-    result = {}
-    for configname in sorted(self.xcode_settings.keys()):
-      if first_pass:
-        result = dict(self.xcode_settings[configname])
-        first_pass = False
-      else:
-        for key, value in self.xcode_settings[configname].items():
-          if key not in result:
-            continue
-          elif result[key] != value:
-            del result[key]
-    return result
-
-  def GetPerConfigSetting(self, setting, configname, default=None):
-    if configname in self.xcode_settings:
-      return self.xcode_settings[configname].get(setting, default)
-    else:
-      return self.GetPerTargetSetting(setting, default)
+        first_pass = True
+        result = {}
+        for configname in sorted(self.xcode_settings.keys()):
+            if first_pass:
+                result = dict(self.xcode_settings[configname])
+                first_pass = False
+            else:
+                for key, value in self.xcode_settings[configname].items():
+                    if key not in result:
+                        continue
+                    elif result[key] != value:
+                        del result[key]
+        return result
+
+    def GetPerConfigSetting(self, setting, configname, default=None):
+        if configname in self.xcode_settings:
+            return self.xcode_settings[configname].get(setting, default)
+        else:
+            return self.GetPerTargetSetting(setting, default)
 
-  def GetPerTargetSetting(self, setting, default=None):
-    """Tries to get xcode_settings.setting from spec. Assumes that the setting
+    def GetPerTargetSetting(self, setting, default=None):
+        """Tries to get xcode_settings.setting from spec. Assumes that the setting
        has the same value in all configurations and throws otherwise."""
-    is_first_pass = True
-    result = None
-    for configname in sorted(self.xcode_settings.keys()):
-      if is_first_pass:
-        result = self.xcode_settings[configname].get(setting, None)
-        is_first_pass = False
-      else:
-        assert result == self.xcode_settings[configname].get(setting, None), (
-            "Expected per-target setting for '%s', got per-config setting "
-            "(target %s)" % (setting, self.spec['target_name']))
-    if result is None:
-      return default
-    return result
-
-  def _GetStripPostbuilds(self, configname, output_binary, quiet):
-    """Returns a list of shell commands that contain the shell commands
+        is_first_pass = True
+        result = None
+        for configname in sorted(self.xcode_settings.keys()):
+            if is_first_pass:
+                result = self.xcode_settings[configname].get(setting, None)
+                is_first_pass = False
+            else:
+                assert result == self.xcode_settings[configname].get(setting, None), (
+                    "Expected per-target setting for '%s', got per-config setting "
+                    "(target %s)" % (setting, self.spec["target_name"])
+                )
+        if result is None:
+            return default
+        return result
+
+    def _GetStripPostbuilds(self, configname, output_binary, quiet):
+        """Returns a list of shell commands that contain the shell commands
     necessary to strip this target's binary. These should be run as postbuilds
     before the actual postbuilds run."""
-    self.configname = configname
-
-    result = []
-    if (self._Test('DEPLOYMENT_POSTPROCESSING', 'YES', default='NO') and
-        self._Test('STRIP_INSTALLED_PRODUCT', 'YES', default='NO')):
-
-      default_strip_style = 'debugging'
-      if ((self.spec['type'] == 'loadable_module' or self._IsIosAppExtension())
-          and self._IsBundle()):
-        default_strip_style = 'non-global'
-      elif self.spec['type'] == 'executable':
-        default_strip_style = 'all'
-
-      strip_style = self._Settings().get('STRIP_STYLE', default_strip_style)
-      strip_flags = {
-        'all': '',
-        'non-global': '-x',
-        'debugging': '-S',
-      }[strip_style]
-
-      explicit_strip_flags = self._Settings().get('STRIPFLAGS', '')
-      if explicit_strip_flags:
-        strip_flags += ' ' + _NormalizeEnvVarReferences(explicit_strip_flags)
-
-      if not quiet:
-        result.append('echo STRIP\\(%s\\)' % self.spec['target_name'])
-      result.append('strip %s %s' % (strip_flags, output_binary))
-
-    self.configname = None
-    return result
-
-  def _GetDebugInfoPostbuilds(self, configname, output, output_binary, quiet):
-    """Returns a list of shell commands that contain the shell commands
+        self.configname = configname
+
+        result = []
+        if self._Test("DEPLOYMENT_POSTPROCESSING", "YES", default="NO") and self._Test(
+            "STRIP_INSTALLED_PRODUCT", "YES", default="NO"
+        ):
+
+            default_strip_style = "debugging"
+            if (
+                self.spec["type"] == "loadable_module" or self._IsIosAppExtension()
+            ) and self._IsBundle():
+                default_strip_style = "non-global"
+            elif self.spec["type"] == "executable":
+                default_strip_style = "all"
+
+            strip_style = self._Settings().get("STRIP_STYLE", default_strip_style)
+            strip_flags = {"all": "", "non-global": "-x", "debugging": "-S"}[
+                strip_style
+            ]
+
+            explicit_strip_flags = self._Settings().get("STRIPFLAGS", "")
+            if explicit_strip_flags:
+                strip_flags += " " + _NormalizeEnvVarReferences(explicit_strip_flags)
+
+            if not quiet:
+                result.append("echo STRIP\\(%s\\)" % self.spec["target_name"])
+            result.append("strip %s %s" % (strip_flags, output_binary))
+
+        self.configname = None
+        return result
+
+    def _GetDebugInfoPostbuilds(self, configname, output, output_binary, quiet):
+        """Returns a list of shell commands that contain the shell commands
     necessary to massage this target's debug information. These should be run
     as postbuilds before the actual postbuilds run."""
-    self.configname = configname
-
-    # For static libraries, no dSYMs are created.
-    result = []
-    if (self._Test('GCC_GENERATE_DEBUGGING_SYMBOLS', 'YES', default='YES') and
-        self._Test(
-            'DEBUG_INFORMATION_FORMAT', 'dwarf-with-dsym', default='dwarf') and
-        self.spec['type'] != 'static_library'):
-      if not quiet:
-        result.append('echo DSYMUTIL\\(%s\\)' % self.spec['target_name'])
-      result.append('dsymutil %s -o %s' % (output_binary, output + '.dSYM'))
-
-    self.configname = None
-    return result
-
-  def _GetTargetPostbuilds(self, configname, output, output_binary,
-                           quiet=False):
-    """Returns a list of shell commands that contain the shell commands
+        self.configname = configname
+
+        # For static libraries, no dSYMs are created.
+        result = []
+        if (
+            self._Test("GCC_GENERATE_DEBUGGING_SYMBOLS", "YES", default="YES")
+            and self._Test(
+                "DEBUG_INFORMATION_FORMAT", "dwarf-with-dsym", default="dwarf"
+            )
+            and self.spec["type"] != "static_library"
+        ):
+            if not quiet:
+                result.append("echo DSYMUTIL\\(%s\\)" % self.spec["target_name"])
+            result.append("dsymutil %s -o %s" % (output_binary, output + ".dSYM"))
+
+        self.configname = None
+        return result
+
+    def _GetTargetPostbuilds(self, configname, output, output_binary, quiet=False):
+        """Returns a list of shell commands that contain the shell commands
     to run as postbuilds for this target, before the actual postbuilds."""
-    # dSYMs need to build before stripping happens.
-    return (
-        self._GetDebugInfoPostbuilds(configname, output, output_binary, quiet) +
-        self._GetStripPostbuilds(configname, output_binary, quiet))
+        # dSYMs need to build before stripping happens.
+        return self._GetDebugInfoPostbuilds(
+            configname, output, output_binary, quiet
+        ) + self._GetStripPostbuilds(configname, output_binary, quiet)
 
-  def _GetIOSPostbuilds(self, configname, output_binary):
-    """Return a shell command to codesign the iOS output binary so it can
+    def _GetIOSPostbuilds(self, configname, output_binary):
+        """Return a shell command to codesign the iOS output binary so it can
     be deployed to a device.  This should be run as the very last step of the
     build."""
-    if not (self.isIOS and
-        (self.spec['type'] == 'executable' or self._IsXCTest()) or
-         self.IsIosFramework()):
-      return []
-
-    postbuilds = []
-    product_name = self.GetFullProductName()
-    settings = self.xcode_settings[configname]
-
-    # Xcode expects XCTests to be copied into the TEST_HOST dir.
-    if self._IsXCTest():
-      source = os.path.join("${BUILT_PRODUCTS_DIR}", product_name)
-      test_host = os.path.dirname(settings.get('TEST_HOST'))
-      xctest_destination = os.path.join(test_host, 'PlugIns', product_name)
-      postbuilds.extend(['ditto %s %s' % (source, xctest_destination)])
-
-    key = self._GetIOSCodeSignIdentityKey(settings)
-    if not key:
-      return postbuilds
-
-    # Warn for any unimplemented signing xcode keys.
-    unimpl = ['OTHER_CODE_SIGN_FLAGS']
-    unimpl = set(unimpl) & set(self.xcode_settings[configname].keys())
-    if unimpl:
-      print('Warning: Some codesign keys not implemented, ignoring: %s' %
-            ', '.join(sorted(unimpl)))
-
-    if self._IsXCTest():
-      # For device xctests, Xcode copies two extra frameworks into $TEST_HOST.
-      test_host = os.path.dirname(settings.get('TEST_HOST'))
-      frameworks_dir = os.path.join(test_host, 'Frameworks')
-      platform_root = self._XcodePlatformPath(configname)
-      frameworks = \
-          ['Developer/Library/PrivateFrameworks/IDEBundleInjection.framework',
-           'Developer/Library/Frameworks/XCTest.framework']
-      for framework in frameworks:
-        source = os.path.join(platform_root, framework)
-        destination = os.path.join(frameworks_dir, os.path.basename(framework))
-        postbuilds.extend(['ditto %s %s' % (source, destination)])
-
-        # Then re-sign everything with 'preserve=True'
-        postbuilds.extend(['%s code-sign-bundle "%s" "%s" "%s" "%s" %s' % (
-            os.path.join('${TARGET_BUILD_DIR}', 'gyp-mac-tool'), key,
-            settings.get('CODE_SIGN_ENTITLEMENTS', ''),
-            settings.get('PROVISIONING_PROFILE', ''), destination, True)
-        ])
-      plugin_dir = os.path.join(test_host, 'PlugIns')
-      targets = [os.path.join(plugin_dir, product_name), test_host]
-      for target in targets:
-        postbuilds.extend(['%s code-sign-bundle "%s" "%s" "%s" "%s" %s' % (
-            os.path.join('${TARGET_BUILD_DIR}', 'gyp-mac-tool'), key,
-            settings.get('CODE_SIGN_ENTITLEMENTS', ''),
-            settings.get('PROVISIONING_PROFILE', ''), target, True)
-        ])
-
-    postbuilds.extend(['%s code-sign-bundle "%s" "%s" "%s" "%s" %s' % (
-        os.path.join('${TARGET_BUILD_DIR}', 'gyp-mac-tool'), key,
-        settings.get('CODE_SIGN_ENTITLEMENTS', ''),
-        settings.get('PROVISIONING_PROFILE', ''),
-        os.path.join("${BUILT_PRODUCTS_DIR}", product_name), False)
-    ])
-    return postbuilds
-
-  def _GetIOSCodeSignIdentityKey(self, settings):
-    identity = settings.get('CODE_SIGN_IDENTITY')
-    if not identity:
-      return None
-    if identity not in XcodeSettings._codesigning_key_cache:
-      output = subprocess.check_output(
-          ['security', 'find-identity', '-p', 'codesigning', '-v'])
-      for line in output.splitlines():
-        if identity in line:
-          fingerprint = line.split()[1]
-          cache = XcodeSettings._codesigning_key_cache
-          assert identity not in cache or fingerprint == cache[identity], (
-              "Multiple codesigning fingerprints for identity: %s" % identity)
-          XcodeSettings._codesigning_key_cache[identity] = fingerprint
-    return XcodeSettings._codesigning_key_cache.get(identity, '')
-
-  def AddImplicitPostbuilds(self, configname, output, output_binary,
-                            postbuilds=[], quiet=False):
-    """Returns a list of shell commands that should run before and after
+        if not (
+            self.isIOS
+            and (self.spec["type"] == "executable" or self._IsXCTest())
+            or self.IsIosFramework()
+        ):
+            return []
+
+        postbuilds = []
+        product_name = self.GetFullProductName()
+        settings = self.xcode_settings[configname]
+
+        # Xcode expects XCTests to be copied into the TEST_HOST dir.
+        if self._IsXCTest():
+            source = os.path.join("${BUILT_PRODUCTS_DIR}", product_name)
+            test_host = os.path.dirname(settings.get("TEST_HOST"))
+            xctest_destination = os.path.join(test_host, "PlugIns", product_name)
+            postbuilds.extend(["ditto %s %s" % (source, xctest_destination)])
+
+        key = self._GetIOSCodeSignIdentityKey(settings)
+        if not key:
+            return postbuilds
+
+        # Warn for any unimplemented signing xcode keys.
+        unimpl = ["OTHER_CODE_SIGN_FLAGS"]
+        unimpl = set(unimpl) & set(self.xcode_settings[configname].keys())
+        if unimpl:
+            print(
+                "Warning: Some codesign keys not implemented, ignoring: %s"
+                % ", ".join(sorted(unimpl))
+            )
+
+        if self._IsXCTest():
+            # For device xctests, Xcode copies two extra frameworks into $TEST_HOST.
+            test_host = os.path.dirname(settings.get("TEST_HOST"))
+            frameworks_dir = os.path.join(test_host, "Frameworks")
+            platform_root = self._XcodePlatformPath(configname)
+            frameworks = [
+                "Developer/Library/PrivateFrameworks/IDEBundleInjection.framework",
+                "Developer/Library/Frameworks/XCTest.framework",
+            ]
+            for framework in frameworks:
+                source = os.path.join(platform_root, framework)
+                destination = os.path.join(frameworks_dir, os.path.basename(framework))
+                postbuilds.extend(["ditto %s %s" % (source, destination)])
+
+                # Then re-sign everything with 'preserve=True'
+                postbuilds.extend(
+                    [
+                        '%s code-sign-bundle "%s" "%s" "%s" "%s" %s'
+                        % (
+                            os.path.join("${TARGET_BUILD_DIR}", "gyp-mac-tool"),
+                            key,
+                            settings.get("CODE_SIGN_ENTITLEMENTS", ""),
+                            settings.get("PROVISIONING_PROFILE", ""),
+                            destination,
+                            True,
+                        )
+                    ]
+                )
+            plugin_dir = os.path.join(test_host, "PlugIns")
+            targets = [os.path.join(plugin_dir, product_name), test_host]
+            for target in targets:
+                postbuilds.extend(
+                    [
+                        '%s code-sign-bundle "%s" "%s" "%s" "%s" %s'
+                        % (
+                            os.path.join("${TARGET_BUILD_DIR}", "gyp-mac-tool"),
+                            key,
+                            settings.get("CODE_SIGN_ENTITLEMENTS", ""),
+                            settings.get("PROVISIONING_PROFILE", ""),
+                            target,
+                            True,
+                        )
+                    ]
+                )
+
+        postbuilds.extend(
+            [
+                '%s code-sign-bundle "%s" "%s" "%s" "%s" %s'
+                % (
+                    os.path.join("${TARGET_BUILD_DIR}", "gyp-mac-tool"),
+                    key,
+                    settings.get("CODE_SIGN_ENTITLEMENTS", ""),
+                    settings.get("PROVISIONING_PROFILE", ""),
+                    os.path.join("${BUILT_PRODUCTS_DIR}", product_name),
+                    False,
+                )
+            ]
+        )
+        return postbuilds
+
+    def _GetIOSCodeSignIdentityKey(self, settings):
+        identity = settings.get("CODE_SIGN_IDENTITY")
+        if not identity:
+            return None
+        if identity not in XcodeSettings._codesigning_key_cache:
+            output = subprocess.check_output(
+                ["security", "find-identity", "-p", "codesigning", "-v"]
+            )
+            for line in output.splitlines():
+                if identity in line:
+                    fingerprint = line.split()[1]
+                    cache = XcodeSettings._codesigning_key_cache
+                    assert identity not in cache or fingerprint == cache[identity], (
+                        "Multiple codesigning fingerprints for identity: %s" % identity
+                    )
+                    XcodeSettings._codesigning_key_cache[identity] = fingerprint
+        return XcodeSettings._codesigning_key_cache.get(identity, "")
+
+    def AddImplicitPostbuilds(
+        self, configname, output, output_binary, postbuilds=[], quiet=False
+    ):
+        """Returns a list of shell commands that should run before and after
     |postbuilds|."""
-    assert output_binary is not None
-    pre = self._GetTargetPostbuilds(configname, output, output_binary, quiet)
-    post = self._GetIOSPostbuilds(configname, output_binary)
-    return pre + postbuilds + post
-
-  def _AdjustLibrary(self, library, config_name=None):
-    if library.endswith('.framework'):
-      l = '-framework ' + os.path.splitext(os.path.basename(library))[0]
-    else:
-      m = self.library_re.match(library)
-      if m:
-        l = '-l' + m.group(1)
-      else:
-        l = library
-
-    sdk_root = self._SdkPath(config_name)
-    if not sdk_root:
-      sdk_root = ''
-    # Xcode 7 started shipping with ".tbd" (text based stubs) files instead of
-    # ".dylib" without providing a real support for them. What it does, for
-    # "/usr/lib" libraries, is do "-L/usr/lib -lname" which is dependent on the
-    # library order and cause collision when building Chrome.
-    #
-    # Instead substitute ".tbd" to ".dylib" in the generated project when the
-    # following conditions are both true:
-    # - library is referenced in the gyp file as "$(SDKROOT)/**/*.dylib",
-    # - the ".dylib" file does not exists but a ".tbd" file do.
-    library = l.replace('$(SDKROOT)', sdk_root)
-    if l.startswith('$(SDKROOT)'):
-      basename, ext = os.path.splitext(library)
-      if ext == '.dylib' and not os.path.exists(library):
-        tbd_library = basename + '.tbd'
-        if os.path.exists(tbd_library):
-          library = tbd_library
-    return library
-
-  def AdjustLibraries(self, libraries, config_name=None):
-    """Transforms entries like 'Cocoa.framework' in libraries into entries like
+        assert output_binary is not None
+        pre = self._GetTargetPostbuilds(configname, output, output_binary, quiet)
+        post = self._GetIOSPostbuilds(configname, output_binary)
+        return pre + postbuilds + post
+
+    def _AdjustLibrary(self, library, config_name=None):
+        if library.endswith(".framework"):
+            l_flag = "-framework " + os.path.splitext(os.path.basename(library))[0]
+        else:
+            m = self.library_re.match(library)
+            if m:
+                l_flag = "-l" + m.group(1)
+            else:
+                l_flag = library
+
+        sdk_root = self._SdkPath(config_name)
+        if not sdk_root:
+            sdk_root = ""
+        # Xcode 7 started shipping with ".tbd" (text based stubs) files instead of
+        # ".dylib" without providing a real support for them. What it does, for
+        # "/usr/lib" libraries, is do "-L/usr/lib -lname" which is dependent on the
+        # library order and cause collision when building Chrome.
+        #
+        # Instead substitute ".tbd" to ".dylib" in the generated project when the
+        # following conditions are both true:
+        # - library is referenced in the gyp file as "$(SDKROOT)/**/*.dylib",
+        # - the ".dylib" file does not exists but a ".tbd" file do.
+        library = l_flag.replace("$(SDKROOT)", sdk_root)
+        if l_flag.startswith("$(SDKROOT)"):
+            basename, ext = os.path.splitext(library)
+            if ext == ".dylib" and not os.path.exists(library):
+                tbd_library = basename + ".tbd"
+                if os.path.exists(tbd_library):
+                    library = tbd_library
+        return library
+
+    def AdjustLibraries(self, libraries, config_name=None):
+        """Transforms entries like 'Cocoa.framework' in libraries into entries like
     '-framework Cocoa', 'libcrypto.dylib' into '-lcrypto', etc.
     """
-    libraries = [self._AdjustLibrary(library, config_name)
-                 for library in libraries]
-    return libraries
-
-  def _BuildMachineOSBuild(self):
-    return GetStdout(['sw_vers', '-buildVersion'])
-
-  def _XcodeIOSDeviceFamily(self, configname):
-    family = self.xcode_settings[configname].get('TARGETED_DEVICE_FAMILY', '1')
-    return [int(x) for x in family.split(',')]
-
-  def GetExtraPlistItems(self, configname=None):
-    """Returns a dictionary with extra items to insert into Info.plist."""
-    if configname not in XcodeSettings._plist_cache:
-      cache = {}
-      cache['BuildMachineOSBuild'] = self._BuildMachineOSBuild()
-
-      xcode_version, xcode_build = XcodeVersion()
-      cache['DTXcode'] = xcode_version
-      cache['DTXcodeBuild'] = xcode_build
-      compiler = self.xcode_settings[configname].get('GCC_VERSION')
-      if compiler is not None:
-        cache['DTCompiler'] = compiler
-
-      sdk_root = self._SdkRoot(configname)
-      if not sdk_root:
-        sdk_root = self._DefaultSdkRoot()
-      sdk_version = self._GetSdkVersionInfoItem(sdk_root, '--show-sdk-version')
-      cache['DTSDKName'] = sdk_root + (sdk_version or '')
-      if xcode_version >= '0720':
-        cache['DTSDKBuild'] = self._GetSdkVersionInfoItem(
-            sdk_root, '--show-sdk-build-version')
-      elif xcode_version >= '0430':
-        cache['DTSDKBuild'] = sdk_version
-      else:
-        cache['DTSDKBuild'] = cache['BuildMachineOSBuild']
-
-      if self.isIOS:
-        cache['MinimumOSVersion'] = self.xcode_settings[configname].get(
-            'IPHONEOS_DEPLOYMENT_TARGET')
-        cache['DTPlatformName'] = sdk_root
-        cache['DTPlatformVersion'] = sdk_version
-
-        if configname.endswith("iphoneos"):
-          cache['CFBundleSupportedPlatforms'] = ['iPhoneOS']
-          cache['DTPlatformBuild'] = cache['DTSDKBuild']
-        else:
-          cache['CFBundleSupportedPlatforms'] = ['iPhoneSimulator']
-          # This is weird, but Xcode sets DTPlatformBuild to an empty field
-          # for simulator builds.
-          cache['DTPlatformBuild'] = ""
-      XcodeSettings._plist_cache[configname] = cache
-
-    # Include extra plist items that are per-target, not per global
-    # XcodeSettings.
-    items = dict(XcodeSettings._plist_cache[configname])
-    if self.isIOS:
-      items['UIDeviceFamily'] = self._XcodeIOSDeviceFamily(configname)
-    return items
-
-  def _DefaultSdkRoot(self):
-    """Returns the default SDKROOT to use.
+        libraries = [self._AdjustLibrary(library, config_name) for library in libraries]
+        return libraries
+
+    def _BuildMachineOSBuild(self):
+        return GetStdout(["sw_vers", "-buildVersion"])
+
+    def _XcodeIOSDeviceFamily(self, configname):
+        family = self.xcode_settings[configname].get("TARGETED_DEVICE_FAMILY", "1")
+        return [int(x) for x in family.split(",")]
+
+    def GetExtraPlistItems(self, configname=None):
+        """Returns a dictionary with extra items to insert into Info.plist."""
+        if configname not in XcodeSettings._plist_cache:
+            cache = {}
+            cache["BuildMachineOSBuild"] = self._BuildMachineOSBuild()
+
+            xcode_version, xcode_build = XcodeVersion()
+            cache["DTXcode"] = xcode_version
+            cache["DTXcodeBuild"] = xcode_build
+            compiler = self.xcode_settings[configname].get("GCC_VERSION")
+            if compiler is not None:
+                cache["DTCompiler"] = compiler
+
+            sdk_root = self._SdkRoot(configname)
+            if not sdk_root:
+                sdk_root = self._DefaultSdkRoot()
+            sdk_version = self._GetSdkVersionInfoItem(sdk_root, "--show-sdk-version")
+            cache["DTSDKName"] = sdk_root + (sdk_version or "")
+            if xcode_version >= "0720":
+                cache["DTSDKBuild"] = self._GetSdkVersionInfoItem(
+                    sdk_root, "--show-sdk-build-version"
+                )
+            elif xcode_version >= "0430":
+                cache["DTSDKBuild"] = sdk_version
+            else:
+                cache["DTSDKBuild"] = cache["BuildMachineOSBuild"]
+
+            if self.isIOS:
+                cache["MinimumOSVersion"] = self.xcode_settings[configname].get(
+                    "IPHONEOS_DEPLOYMENT_TARGET"
+                )
+                cache["DTPlatformName"] = sdk_root
+                cache["DTPlatformVersion"] = sdk_version
+
+                if configname.endswith("iphoneos"):
+                    cache["CFBundleSupportedPlatforms"] = ["iPhoneOS"]
+                    cache["DTPlatformBuild"] = cache["DTSDKBuild"]
+                else:
+                    cache["CFBundleSupportedPlatforms"] = ["iPhoneSimulator"]
+                    # This is weird, but Xcode sets DTPlatformBuild to an empty field
+                    # for simulator builds.
+                    cache["DTPlatformBuild"] = ""
+            XcodeSettings._plist_cache[configname] = cache
+
+        # Include extra plist items that are per-target, not per global
+        # XcodeSettings.
+        items = dict(XcodeSettings._plist_cache[configname])
+        if self.isIOS:
+            items["UIDeviceFamily"] = self._XcodeIOSDeviceFamily(configname)
+        return items
+
+    def _DefaultSdkRoot(self):
+        """Returns the default SDKROOT to use.
 
     Prior to version 5.0.0, if SDKROOT was not explicitly set in the Xcode
     project, then the environment variable was empty. Starting with this
     version, Xcode uses the name of the newest SDK installed.
     """
-    xcode_version, _ = XcodeVersion()
-    if xcode_version < '0500':
-      return ''
-    default_sdk_path = self._XcodeSdkPath('')
-    default_sdk_root = XcodeSettings._sdk_root_cache.get(default_sdk_path)
-    if default_sdk_root:
-      return default_sdk_root
-    try:
-      all_sdks = GetStdout(['xcodebuild', '-showsdks'])
-    except GypError:
-      # If xcodebuild fails, there will be no valid SDKs
-      return ''
-    for line in all_sdks.splitlines():
-      items = line.split()
-      if len(items) >= 3 and items[-2] == '-sdk':
-        sdk_root = items[-1]
-        sdk_path = self._XcodeSdkPath(sdk_root)
-        if sdk_path == default_sdk_path:
-          return sdk_root
-    return ''
+        xcode_version, _ = XcodeVersion()
+        if xcode_version < "0500":
+            return ""
+        default_sdk_path = self._XcodeSdkPath("")
+        default_sdk_root = XcodeSettings._sdk_root_cache.get(default_sdk_path)
+        if default_sdk_root:
+            return default_sdk_root
+        try:
+            all_sdks = GetStdout(["xcodebuild", "-showsdks"])
+        except GypError:
+            # If xcodebuild fails, there will be no valid SDKs
+            return ""
+        for line in all_sdks.splitlines():
+            items = line.split()
+            if len(items) >= 3 and items[-2] == "-sdk":
+                sdk_root = items[-1]
+                sdk_path = self._XcodeSdkPath(sdk_root)
+                if sdk_path == default_sdk_path:
+                    return sdk_root
+        return ""
 
 
 class MacPrefixHeader(object):
-  """A class that helps with emulating Xcode's GCC_PREFIX_HEADER feature.
+    """A class that helps with emulating Xcode's GCC_PREFIX_HEADER feature.
 
   This feature consists of several pieces:
   * If GCC_PREFIX_HEADER is present, all compilations in that project get an
@@ -1301,9 +1393,11 @@ class MacPrefixHeader(object):
   system for writing dependencies to the gch files, for writing build commands
   for the gch files, and for figuring out the location of the gch files.
   """
-  def __init__(self, xcode_settings,
-               gyp_path_to_build_path, gyp_path_to_build_output):
-    """If xcode_settings is None, all methods on this class are no-ops.
+
+    def __init__(
+        self, xcode_settings, gyp_path_to_build_path, gyp_path_to_build_output
+    ):
+        """If xcode_settings is None, all methods on this class are no-ops.
 
     Args:
         gyp_path_to_build_path: A function that takes a gyp-relative path,
@@ -1313,201 +1407,219 @@ class MacPrefixHeader(object):
             to where the output of precompiling that path for that language
             should be placed (without the trailing '.gch').
     """
-    # This doesn't support per-configuration prefix headers. Good enough
-    # for now.
-    self.header = None
-    self.compile_headers = False
-    if xcode_settings:
-      self.header = xcode_settings.GetPerTargetSetting('GCC_PREFIX_HEADER')
-      self.compile_headers = xcode_settings.GetPerTargetSetting(
-          'GCC_PRECOMPILE_PREFIX_HEADER', default='NO') != 'NO'
-    self.compiled_headers = {}
-    if self.header:
-      if self.compile_headers:
-        for lang in ['c', 'cc', 'm', 'mm']:
-          self.compiled_headers[lang] = gyp_path_to_build_output(
-              self.header, lang)
-      self.header = gyp_path_to_build_path(self.header)
-
-  def _CompiledHeader(self, lang, arch):
-    assert self.compile_headers
-    h = self.compiled_headers[lang]
-    if arch:
-      h += '.' + arch
-    return h
-
-  def GetInclude(self, lang, arch=None):
-    """Gets the cflags to include the prefix header for language |lang|."""
-    if self.compile_headers and lang in self.compiled_headers:
-      return '-include %s' % self._CompiledHeader(lang, arch)
-    elif self.header:
-      return '-include %s' % self.header
-    else:
-      return ''
+        # This doesn't support per-configuration prefix headers. Good enough
+        # for now.
+        self.header = None
+        self.compile_headers = False
+        if xcode_settings:
+            self.header = xcode_settings.GetPerTargetSetting("GCC_PREFIX_HEADER")
+            self.compile_headers = (
+                xcode_settings.GetPerTargetSetting(
+                    "GCC_PRECOMPILE_PREFIX_HEADER", default="NO"
+                )
+                != "NO"
+            )
+        self.compiled_headers = {}
+        if self.header:
+            if self.compile_headers:
+                for lang in ["c", "cc", "m", "mm"]:
+                    self.compiled_headers[lang] = gyp_path_to_build_output(
+                        self.header, lang
+                    )
+            self.header = gyp_path_to_build_path(self.header)
+
+    def _CompiledHeader(self, lang, arch):
+        assert self.compile_headers
+        h = self.compiled_headers[lang]
+        if arch:
+            h += "." + arch
+        return h
+
+    def GetInclude(self, lang, arch=None):
+        """Gets the cflags to include the prefix header for language |lang|."""
+        if self.compile_headers and lang in self.compiled_headers:
+            return "-include %s" % self._CompiledHeader(lang, arch)
+        elif self.header:
+            return "-include %s" % self.header
+        else:
+            return ""
 
-  def _Gch(self, lang, arch):
-    """Returns the actual file name of the prefix header for language |lang|."""
-    assert self.compile_headers
-    return self._CompiledHeader(lang, arch) + '.gch'
+    def _Gch(self, lang, arch):
+        """Returns the actual file name of the prefix header for language |lang|."""
+        assert self.compile_headers
+        return self._CompiledHeader(lang, arch) + ".gch"
 
-  def GetObjDependencies(self, sources, objs, arch=None):
-    """Given a list of source files and the corresponding object files, returns
+    def GetObjDependencies(self, sources, objs, arch=None):
+        """Given a list of source files and the corresponding object files, returns
     a list of (source, object, gch) tuples, where |gch| is the build-directory
     relative path to the gch file each object file depends on.  |compilable[i]|
     has to be the source file belonging to |objs[i]|."""
-    if not self.header or not self.compile_headers:
-      return []
-
-    result = []
-    for source, obj in zip(sources, objs):
-      ext = os.path.splitext(source)[1]
-      lang = {
-        '.c': 'c',
-        '.cpp': 'cc', '.cc': 'cc', '.cxx': 'cc',
-        '.m': 'm',
-        '.mm': 'mm',
-      }.get(ext, None)
-      if lang:
-        result.append((source, obj, self._Gch(lang, arch)))
-    return result
-
-  def GetPchBuildCommands(self, arch=None):
-    """Returns [(path_to_gch, language_flag, language, header)].
+        if not self.header or not self.compile_headers:
+            return []
+
+        result = []
+        for source, obj in zip(sources, objs):
+            ext = os.path.splitext(source)[1]
+            lang = {
+                ".c": "c",
+                ".cpp": "cc",
+                ".cc": "cc",
+                ".cxx": "cc",
+                ".m": "m",
+                ".mm": "mm",
+            }.get(ext, None)
+            if lang:
+                result.append((source, obj, self._Gch(lang, arch)))
+        return result
+
+    def GetPchBuildCommands(self, arch=None):
+        """Returns [(path_to_gch, language_flag, language, header)].
     |path_to_gch| and |header| are relative to the build directory.
     """
-    if not self.header or not self.compile_headers:
-      return []
-    return [
-      (self._Gch('c', arch), '-x c-header', 'c', self.header),
-      (self._Gch('cc', arch), '-x c++-header', 'cc', self.header),
-      (self._Gch('m', arch), '-x objective-c-header', 'm', self.header),
-      (self._Gch('mm', arch), '-x objective-c++-header', 'mm', self.header),
-    ]
+        if not self.header or not self.compile_headers:
+            return []
+        return [
+            (self._Gch("c", arch), "-x c-header", "c", self.header),
+            (self._Gch("cc", arch), "-x c++-header", "cc", self.header),
+            (self._Gch("m", arch), "-x objective-c-header", "m", self.header),
+            (self._Gch("mm", arch), "-x objective-c++-header", "mm", self.header),
+        ]
 
 
 def XcodeVersion():
-  """Returns a tuple of version and build version of installed Xcode."""
-  # `xcodebuild -version` output looks like
-  #    Xcode 4.6.3
-  #    Build version 4H1503
-  # or like
-  #    Xcode 3.2.6
-  #    Component versions: DevToolsCore-1809.0; DevToolsSupport-1806.0
-  #    BuildVersion: 10M2518
-  # Convert that to ('0463', '4H1503') or ('0326', '10M2518').
-  global XCODE_VERSION_CACHE
-  if XCODE_VERSION_CACHE:
+    """Returns a tuple of version and build version of installed Xcode."""
+    # `xcodebuild -version` output looks like
+    #    Xcode 4.6.3
+    #    Build version 4H1503
+    # or like
+    #    Xcode 3.2.6
+    #    Component versions: DevToolsCore-1809.0; DevToolsSupport-1806.0
+    #    BuildVersion: 10M2518
+    # Convert that to ('0463', '4H1503') or ('0326', '10M2518').
+    global XCODE_VERSION_CACHE
+    if XCODE_VERSION_CACHE:
+        return XCODE_VERSION_CACHE
+    version = ""
+    build = ""
+    try:
+        version_list = GetStdoutQuiet(["xcodebuild", "-version"]).splitlines()
+        # In some circumstances xcodebuild exits 0 but doesn't return
+        # the right results; for example, a user on 10.7 or 10.8 with
+        # a bogus path set via xcode-select
+        # In that case this may be a CLT-only install so fall back to
+        # checking that version.
+        if len(version_list) < 2:
+            raise GypError("xcodebuild returned unexpected results")
+        version = version_list[0].split()[-1]  # Last word on first line
+        build = version_list[-1].split()[-1]  # Last word on last line
+    except GypError:  # Xcode not installed so look for XCode Command Line Tools
+        version = CLTVersion()  # macOS Catalina returns 11.0.0.0.1.1567737322
+        if not version:
+            raise GypError("No Xcode or CLT version detected!")
+    # Be careful to convert "4.2.3" to "0423" and "11.0.0" to "1100":
+    version = version.split(".")[:3]  # Just major, minor, micro
+    version[0] = version[0].zfill(2)  # Add a leading zero if major is one digit
+    version = ("".join(version) + "00")[:4]  # Limit to exactly four characters
+    XCODE_VERSION_CACHE = (version, build)
     return XCODE_VERSION_CACHE
-  version = ""
-  build = ""
-  try:
-    version_list = GetStdoutQuiet(['xcodebuild', '-version']).splitlines()
-    # In some circumstances xcodebuild exits 0 but doesn't return
-    # the right results; for example, a user on 10.7 or 10.8 with
-    # a bogus path set via xcode-select
-    # In that case this may be a CLT-only install so fall back to
-    # checking that version.
-    if len(version_list) < 2:
-      raise GypError("xcodebuild returned unexpected results")
-    version = version_list[0].split()[-1]  # Last word on first line
-    build = version_list[-1].split()[-1]   # Last word on last line
-  except GypError:  # Xcode not installed so look for XCode Command Line Tools
-    version = CLTVersion()  # macOS Catalina returns 11.0.0.0.1.1567737322
-    if not version:
-      raise GypError("No Xcode or CLT version detected!")
-  # Be careful to convert "4.2.3" to "0423" and "11.0.0" to "1100":
-  version = version.split(".")[:3]  # Just major, minor, micro
-  version[0] = version[0].zfill(2)  # Add a leading zero if major is one digit
-  version = ("".join(version) + "00")[:4]  # Limit to exactly four characters
-  XCODE_VERSION_CACHE = (version, build)
-  return XCODE_VERSION_CACHE
 
 
 # This function ported from the logic in Homebrew's CLT version check
 def CLTVersion():
-  """Returns the version of command-line tools from pkgutil."""
-  # pkgutil output looks like
-  #   package-id: com.apple.pkg.CLTools_Executables
-  #   version: 5.0.1.0.1.1382131676
-  #   volume: /
-  #   location: /
-  #   install-time: 1382544035
-  #   groups: com.apple.FindSystemFiles.pkg-group com.apple.DevToolsBoth.pkg-group com.apple.DevToolsNonRelocatableShared.pkg-group
-  STANDALONE_PKG_ID = "com.apple.pkg.DeveloperToolsCLILeo"
-  FROM_XCODE_PKG_ID = "com.apple.pkg.DeveloperToolsCLI"
-  MAVERICKS_PKG_ID = "com.apple.pkg.CLTools_Executables"
-
-  regex = re.compile('version: (?P<version>.+)')
-  for key in [MAVERICKS_PKG_ID, STANDALONE_PKG_ID, FROM_XCODE_PKG_ID]:
+    """Returns the version of command-line tools from pkgutil."""
+    # pkgutil output looks like
+    #   package-id: com.apple.pkg.CLTools_Executables
+    #   version: 5.0.1.0.1.1382131676
+    #   volume: /
+    #   location: /
+    #   install-time: 1382544035
+    #   groups: com.apple.FindSystemFiles.pkg-group
+    #           com.apple.DevToolsBoth.pkg-group
+    #           com.apple.DevToolsNonRelocatableShared.pkg-group
+    STANDALONE_PKG_ID = "com.apple.pkg.DeveloperToolsCLILeo"
+    FROM_XCODE_PKG_ID = "com.apple.pkg.DeveloperToolsCLI"
+    MAVERICKS_PKG_ID = "com.apple.pkg.CLTools_Executables"
+
+    regex = re.compile("version: (?P<version>.+)")
+    for key in [MAVERICKS_PKG_ID, STANDALONE_PKG_ID, FROM_XCODE_PKG_ID]:
+        try:
+            output = GetStdout(["/usr/sbin/pkgutil", "--pkg-info", key])
+            return re.search(regex, output).groupdict()["version"]
+        except GypError:
+            continue
+
+    regex = re.compile(r'Command Line Tools for Xcode\s+(?P<version>\S+)')
     try:
-      output = GetStdout(['/usr/sbin/pkgutil', '--pkg-info', key])
-      return re.search(regex, output).groupdict()['version']
+        output = GetStdout(["/usr/sbin/softwareupdate", "--history"])
+        return re.search(regex, output).groupdict()["version"]
     except GypError:
-      continue
+        return None
 
 
 def GetStdoutQuiet(cmdlist):
-  """Returns the content of standard output returned by invoking |cmdlist|.
+    """Returns the content of standard output returned by invoking |cmdlist|.
   Ignores the stderr.
   Raises |GypError| if the command return with a non-zero return code."""
-  job = subprocess.Popen(cmdlist, stdout=subprocess.PIPE,
-                         stderr=subprocess.PIPE)
-  out = job.communicate()[0]
-  if PY3:
-    out = out.decode("utf-8")
-  if job.returncode != 0:
-    raise GypError('Error %d running %s' % (job.returncode, cmdlist[0]))
-  return out.rstrip('\n')
+    job = subprocess.Popen(cmdlist, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    out = job.communicate()[0]
+    if PY3:
+        out = out.decode("utf-8")
+    if job.returncode != 0:
+        raise GypError("Error %d running %s" % (job.returncode, cmdlist[0]))
+    return out.rstrip("\n")
 
 
 def GetStdout(cmdlist):
-  """Returns the content of standard output returned by invoking |cmdlist|.
+    """Returns the content of standard output returned by invoking |cmdlist|.
   Raises |GypError| if the command return with a non-zero return code."""
-  job = subprocess.Popen(cmdlist, stdout=subprocess.PIPE)
-  out = job.communicate()[0]
-  if PY3:
-    out = out.decode("utf-8")
-  if job.returncode != 0:
-    sys.stderr.write(out + '\n')
-    raise GypError('Error %d running %s' % (job.returncode, cmdlist[0]))
-  return out.rstrip('\n')
+    job = subprocess.Popen(cmdlist, stdout=subprocess.PIPE)
+    out = job.communicate()[0]
+    if PY3:
+        out = out.decode("utf-8")
+    if job.returncode != 0:
+        sys.stderr.write(out + "\n")
+        raise GypError("Error %d running %s" % (job.returncode, cmdlist[0]))
+    return out.rstrip("\n")
 
 
 def MergeGlobalXcodeSettingsToSpec(global_dict, spec):
-  """Merges the global xcode_settings dictionary into each configuration of the
+    """Merges the global xcode_settings dictionary into each configuration of the
   target represented by spec. For keys that are both in the global and the local
   xcode_settings dict, the local key gets precedence.
   """
-  # The xcode generator special-cases global xcode_settings and does something
-  # that amounts to merging in the global xcode_settings into each local
-  # xcode_settings dict.
-  global_xcode_settings = global_dict.get('xcode_settings', {})
-  for config in spec['configurations'].values():
-    if 'xcode_settings' in config:
-      new_settings = global_xcode_settings.copy()
-      new_settings.update(config['xcode_settings'])
-      config['xcode_settings'] = new_settings
+    # The xcode generator special-cases global xcode_settings and does something
+    # that amounts to merging in the global xcode_settings into each local
+    # xcode_settings dict.
+    global_xcode_settings = global_dict.get("xcode_settings", {})
+    for config in spec["configurations"].values():
+        if "xcode_settings" in config:
+            new_settings = global_xcode_settings.copy()
+            new_settings.update(config["xcode_settings"])
+            config["xcode_settings"] = new_settings
 
 
 def IsMacBundle(flavor, spec):
-  """Returns if |spec| should be treated as a bundle.
+    """Returns if |spec| should be treated as a bundle.
 
   Bundles are directories with a certain subdirectory structure, instead of
   just a single file. Bundle rules do not produce a binary but also package
   resources into that directory."""
-  is_mac_bundle = int(spec.get('mac_xctest_bundle', 0)) != 0 or \
-      int(spec.get('mac_xcuitest_bundle', 0)) != 0 or \
-      (int(spec.get('mac_bundle', 0)) != 0 and flavor == 'mac')
+    is_mac_bundle = (
+        int(spec.get("mac_xctest_bundle", 0)) != 0
+        or int(spec.get("mac_xcuitest_bundle", 0)) != 0
+        or (int(spec.get("mac_bundle", 0)) != 0 and flavor == "mac")
+    )
 
-  if is_mac_bundle:
-    assert spec['type'] != 'none', (
-        'mac_bundle targets cannot have type none (target "%s")' %
-        spec['target_name'])
-  return is_mac_bundle
+    if is_mac_bundle:
+        assert spec["type"] != "none", (
+            'mac_bundle targets cannot have type none (target "%s")'
+            % spec["target_name"]
+        )
+    return is_mac_bundle
 
 
 def GetMacBundleResources(product_dir, xcode_settings, resources):
-  """Yields (output, resource) pairs for every resource in |resources|.
+    """Yields (output, resource) pairs for every resource in |resources|.
   Only call this for mac bundle targets.
 
   Args:
@@ -1516,38 +1628,36 @@ def GetMacBundleResources(product_dir, xcode_settings, resources):
       xcode_settings: The XcodeSettings of the current target.
       resources: A list of bundle resources, relative to the build directory.
   """
-  dest = os.path.join(product_dir,
-                      xcode_settings.GetBundleResourceFolder())
-  for res in resources:
-    output = dest
+    dest = os.path.join(product_dir, xcode_settings.GetBundleResourceFolder())
+    for res in resources:
+        output = dest
 
-    # The make generator doesn't support it, so forbid it everywhere
-    # to keep the generators more interchangeable.
-    assert ' ' not in res, (
-      "Spaces in resource filenames not supported (%s)"  % res)
+        # The make generator doesn't support it, so forbid it everywhere
+        # to keep the generators more interchangeable.
+        assert " " not in res, "Spaces in resource filenames not supported (%s)" % res
 
-    # Split into (path,file).
-    res_parts = os.path.split(res)
+        # Split into (path,file).
+        res_parts = os.path.split(res)
 
-    # Now split the path into (prefix,maybe.lproj).
-    lproj_parts = os.path.split(res_parts[0])
-    # If the resource lives in a .lproj bundle, add that to the destination.
-    if lproj_parts[1].endswith('.lproj'):
-      output = os.path.join(output, lproj_parts[1])
+        # Now split the path into (prefix,maybe.lproj).
+        lproj_parts = os.path.split(res_parts[0])
+        # If the resource lives in a .lproj bundle, add that to the destination.
+        if lproj_parts[1].endswith(".lproj"):
+            output = os.path.join(output, lproj_parts[1])
 
-    output = os.path.join(output, res_parts[1])
-    # Compiled XIB files are referred to by .nib.
-    if output.endswith('.xib'):
-      output = os.path.splitext(output)[0] + '.nib'
-    # Compiled storyboard files are referred to by .storyboardc.
-    if output.endswith('.storyboard'):
-      output = os.path.splitext(output)[0] + '.storyboardc'
+        output = os.path.join(output, res_parts[1])
+        # Compiled XIB files are referred to by .nib.
+        if output.endswith(".xib"):
+            output = os.path.splitext(output)[0] + ".nib"
+        # Compiled storyboard files are referred to by .storyboardc.
+        if output.endswith(".storyboard"):
+            output = os.path.splitext(output)[0] + ".storyboardc"
 
-    yield output, res
+        yield output, res
 
 
 def GetMacInfoPlist(product_dir, xcode_settings, gyp_path_to_build_path):
-  """Returns (info_plist, dest_plist, defines, extra_env), where:
+    """Returns (info_plist, dest_plist, defines, extra_env), where:
   * |info_plist| is the source plist path, relative to the
     build directory,
   * |dest_plist| is the destination plist path, relative to the
@@ -1566,36 +1676,43 @@ def GetMacInfoPlist(product_dir, xcode_settings, gyp_path_to_build_path):
       gyp_to_build_path: A function that converts paths relative to the
           current gyp file to paths relative to the build directory.
   """
-  info_plist = xcode_settings.GetPerTargetSetting('INFOPLIST_FILE')
-  if not info_plist:
-    return None, None, [], {}
+    info_plist = xcode_settings.GetPerTargetSetting("INFOPLIST_FILE")
+    if not info_plist:
+        return None, None, [], {}
 
-  # The make generator doesn't support it, so forbid it everywhere
-  # to keep the generators more interchangeable.
-  assert ' ' not in info_plist, (
-    "Spaces in Info.plist filenames not supported (%s)"  % info_plist)
-
-  info_plist = gyp_path_to_build_path(info_plist)
-
-  # If explicitly set to preprocess the plist, invoke the C preprocessor and
-  # specify any defines as -D flags.
-  if xcode_settings.GetPerTargetSetting(
-      'INFOPLIST_PREPROCESS', default='NO') == 'YES':
-    # Create an intermediate file based on the path.
-    defines = shlex.split(xcode_settings.GetPerTargetSetting(
-        'INFOPLIST_PREPROCESSOR_DEFINITIONS', default=''))
-  else:
-    defines = []
+    # The make generator doesn't support it, so forbid it everywhere
+    # to keep the generators more interchangeable.
+    assert " " not in info_plist, (
+        "Spaces in Info.plist filenames not supported (%s)" % info_plist
+    )
+
+    info_plist = gyp_path_to_build_path(info_plist)
+
+    # If explicitly set to preprocess the plist, invoke the C preprocessor and
+    # specify any defines as -D flags.
+    if (
+        xcode_settings.GetPerTargetSetting("INFOPLIST_PREPROCESS", default="NO")
+        == "YES"
+    ):
+        # Create an intermediate file based on the path.
+        defines = shlex.split(
+            xcode_settings.GetPerTargetSetting(
+                "INFOPLIST_PREPROCESSOR_DEFINITIONS", default=""
+            )
+        )
+    else:
+        defines = []
 
-  dest_plist = os.path.join(product_dir, xcode_settings.GetBundlePlistPath())
-  extra_env = xcode_settings.GetPerTargetSettings()
+    dest_plist = os.path.join(product_dir, xcode_settings.GetBundlePlistPath())
+    extra_env = xcode_settings.GetPerTargetSettings()
 
-  return info_plist, dest_plist, defines, extra_env
+    return info_plist, dest_plist, defines, extra_env
 
 
-def _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
-                additional_settings=None):
-  """Return the environment variables that Xcode would set. See
+def _GetXcodeEnv(
+    xcode_settings, built_products_dir, srcroot, configuration, additional_settings=None
+):
+    """Return the environment variables that Xcode would set. See
   http://developer.apple.com/library/mac/#documentation/DeveloperTools/Reference/XcodeBuildSettingRef/1-Build_Setting_Reference/build_setting_ref.html#//apple_ref/doc/uid/TP40003931-CH3-SW153
   for a full list.
 
@@ -1609,209 +1726,221 @@ def _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
           result.
   """
 
-  if not xcode_settings: return {}
-
-  # This function is considered a friend of XcodeSettings, so let it reach into
-  # its implementation details.
-  spec = xcode_settings.spec
-
-  # These are filled in on an as-needed basis.
-  env = {
-    'BUILT_FRAMEWORKS_DIR' : built_products_dir,
-    'BUILT_PRODUCTS_DIR' : built_products_dir,
-    'CONFIGURATION' : configuration,
-    'PRODUCT_NAME' : xcode_settings.GetProductName(),
-    # See /Developer/Platforms/MacOSX.platform/Developer/Library/Xcode/Specifications/MacOSX\ Product\ Types.xcspec for FULL_PRODUCT_NAME
-    'SRCROOT' : srcroot,
-    'SOURCE_ROOT': '${SRCROOT}',
-    # This is not true for static libraries, but currently the env is only
-    # written for bundles:
-    'TARGET_BUILD_DIR' : built_products_dir,
-    'TEMP_DIR' : '${TMPDIR}',
-    'XCODE_VERSION_ACTUAL' : XcodeVersion()[0],
-  }
-  if xcode_settings.GetPerConfigSetting('SDKROOT', configuration):
-    env['SDKROOT'] = xcode_settings._SdkPath(configuration)
-  else:
-    env['SDKROOT'] = ''
-
-  if xcode_settings.mac_toolchain_dir:
-    env['DEVELOPER_DIR'] = xcode_settings.mac_toolchain_dir
-
-  if spec['type'] in (
-      'executable', 'static_library', 'shared_library', 'loadable_module'):
-    env['EXECUTABLE_NAME'] = xcode_settings.GetExecutableName()
-    env['EXECUTABLE_PATH'] = xcode_settings.GetExecutablePath()
-    env['FULL_PRODUCT_NAME'] = xcode_settings.GetFullProductName()
-    mach_o_type = xcode_settings.GetMachOType()
-    if mach_o_type:
-      env['MACH_O_TYPE'] = mach_o_type
-    env['PRODUCT_TYPE'] = xcode_settings.GetProductType()
-  if xcode_settings._IsBundle():
-    # xcodeproj_file.py sets the same Xcode subfolder value for this as for
-    # FRAMEWORKS_FOLDER_PATH so Xcode builds will actually use FFP's value.
-    env['BUILT_FRAMEWORKS_DIR'] = \
-        os.path.join(built_products_dir + os.sep \
-                     + xcode_settings.GetBundleFrameworksFolderPath())
-    env['CONTENTS_FOLDER_PATH'] = \
-        xcode_settings.GetBundleContentsFolderPath()
-    env['EXECUTABLE_FOLDER_PATH'] = \
-        xcode_settings.GetBundleExecutableFolderPath()
-    env['UNLOCALIZED_RESOURCES_FOLDER_PATH'] = \
-        xcode_settings.GetBundleResourceFolder()
-    env['JAVA_FOLDER_PATH'] = xcode_settings.GetBundleJavaFolderPath()
-    env['FRAMEWORKS_FOLDER_PATH'] = \
-        xcode_settings.GetBundleFrameworksFolderPath()
-    env['SHARED_FRAMEWORKS_FOLDER_PATH'] = \
-        xcode_settings.GetBundleSharedFrameworksFolderPath()
-    env['SHARED_SUPPORT_FOLDER_PATH'] = \
-        xcode_settings.GetBundleSharedSupportFolderPath()
-    env['PLUGINS_FOLDER_PATH'] = xcode_settings.GetBundlePlugInsFolderPath()
-    env['XPCSERVICES_FOLDER_PATH'] = \
-        xcode_settings.GetBundleXPCServicesFolderPath()
-    env['INFOPLIST_PATH'] = xcode_settings.GetBundlePlistPath()
-    env['WRAPPER_NAME'] = xcode_settings.GetWrapperName()
-
-  install_name = xcode_settings.GetInstallName()
-  if install_name:
-    env['LD_DYLIB_INSTALL_NAME'] = install_name
-  install_name_base = xcode_settings.GetInstallNameBase()
-  if install_name_base:
-    env['DYLIB_INSTALL_NAME_BASE'] = install_name_base
-  xcode_version, _ = XcodeVersion()
-  if xcode_version >= '0500' and not env.get('SDKROOT'):
-    sdk_root = xcode_settings._SdkRoot(configuration)
-    if not sdk_root:
-      sdk_root = xcode_settings._XcodeSdkPath('')
-    if sdk_root is None:
-      sdk_root = ''
-    env['SDKROOT'] = sdk_root
-
-  if not additional_settings:
-    additional_settings = {}
-  else:
-    # Flatten lists to strings.
-    for k in additional_settings:
-      if not isinstance(additional_settings[k], str):
-        additional_settings[k] = ' '.join(additional_settings[k])
-  additional_settings.update(env)
+    if not xcode_settings:
+        return {}
+
+    # This function is considered a friend of XcodeSettings, so let it reach into
+    # its implementation details.
+    spec = xcode_settings.spec
+
+    # These are filled in on an as-needed basis.
+    env = {
+        "BUILT_FRAMEWORKS_DIR": built_products_dir,
+        "BUILT_PRODUCTS_DIR": built_products_dir,
+        "CONFIGURATION": configuration,
+        "PRODUCT_NAME": xcode_settings.GetProductName(),
+        # For FULL_PRODUCT_NAME see:
+        # /Developer/Platforms/MacOSX.platform/Developer/Library/Xcode/Specifications/MacOSX\ Product\ Types.xcspec  # noqa: E501
+        "SRCROOT": srcroot,
+        "SOURCE_ROOT": "${SRCROOT}",
+        # This is not true for static libraries, but currently the env is only
+        # written for bundles:
+        "TARGET_BUILD_DIR": built_products_dir,
+        "TEMP_DIR": "${TMPDIR}",
+        "XCODE_VERSION_ACTUAL": XcodeVersion()[0],
+    }
+    if xcode_settings.GetPerConfigSetting("SDKROOT", configuration):
+        env["SDKROOT"] = xcode_settings._SdkPath(configuration)
+    else:
+        env["SDKROOT"] = ""
+
+    if xcode_settings.mac_toolchain_dir:
+        env["DEVELOPER_DIR"] = xcode_settings.mac_toolchain_dir
+
+    if spec["type"] in (
+        "executable",
+        "static_library",
+        "shared_library",
+        "loadable_module",
+    ):
+        env["EXECUTABLE_NAME"] = xcode_settings.GetExecutableName()
+        env["EXECUTABLE_PATH"] = xcode_settings.GetExecutablePath()
+        env["FULL_PRODUCT_NAME"] = xcode_settings.GetFullProductName()
+        mach_o_type = xcode_settings.GetMachOType()
+        if mach_o_type:
+            env["MACH_O_TYPE"] = mach_o_type
+        env["PRODUCT_TYPE"] = xcode_settings.GetProductType()
+    if xcode_settings._IsBundle():
+        # xcodeproj_file.py sets the same Xcode subfolder value for this as for
+        # FRAMEWORKS_FOLDER_PATH so Xcode builds will actually use FFP's value.
+        env["BUILT_FRAMEWORKS_DIR"] = os.path.join(
+            built_products_dir + os.sep + xcode_settings.GetBundleFrameworksFolderPath()
+        )
+        env["CONTENTS_FOLDER_PATH"] = xcode_settings.GetBundleContentsFolderPath()
+        env["EXECUTABLE_FOLDER_PATH"] = xcode_settings.GetBundleExecutableFolderPath()
+        env[
+            "UNLOCALIZED_RESOURCES_FOLDER_PATH"
+        ] = xcode_settings.GetBundleResourceFolder()
+        env["JAVA_FOLDER_PATH"] = xcode_settings.GetBundleJavaFolderPath()
+        env["FRAMEWORKS_FOLDER_PATH"] = xcode_settings.GetBundleFrameworksFolderPath()
+        env[
+            "SHARED_FRAMEWORKS_FOLDER_PATH"
+        ] = xcode_settings.GetBundleSharedFrameworksFolderPath()
+        env[
+            "SHARED_SUPPORT_FOLDER_PATH"
+        ] = xcode_settings.GetBundleSharedSupportFolderPath()
+        env["PLUGINS_FOLDER_PATH"] = xcode_settings.GetBundlePlugInsFolderPath()
+        env["XPCSERVICES_FOLDER_PATH"] = xcode_settings.GetBundleXPCServicesFolderPath()
+        env["INFOPLIST_PATH"] = xcode_settings.GetBundlePlistPath()
+        env["WRAPPER_NAME"] = xcode_settings.GetWrapperName()
+
+    install_name = xcode_settings.GetInstallName()
+    if install_name:
+        env["LD_DYLIB_INSTALL_NAME"] = install_name
+    install_name_base = xcode_settings.GetInstallNameBase()
+    if install_name_base:
+        env["DYLIB_INSTALL_NAME_BASE"] = install_name_base
+    xcode_version, _ = XcodeVersion()
+    if xcode_version >= "0500" and not env.get("SDKROOT"):
+        sdk_root = xcode_settings._SdkRoot(configuration)
+        if not sdk_root:
+            sdk_root = xcode_settings._XcodeSdkPath("")
+        if sdk_root is None:
+            sdk_root = ""
+        env["SDKROOT"] = sdk_root
+
+    if not additional_settings:
+        additional_settings = {}
+    else:
+        # Flatten lists to strings.
+        for k in additional_settings:
+            if not isinstance(additional_settings[k], str):
+                additional_settings[k] = " ".join(additional_settings[k])
+    additional_settings.update(env)
 
-  for k in additional_settings:
-    additional_settings[k] = _NormalizeEnvVarReferences(additional_settings[k])
+    for k in additional_settings:
+        additional_settings[k] = _NormalizeEnvVarReferences(additional_settings[k])
 
-  return additional_settings
+    return additional_settings
 
 
 def _NormalizeEnvVarReferences(str):
-  """Takes a string containing variable references in the form ${FOO}, $(FOO),
+    """Takes a string containing variable references in the form ${FOO}, $(FOO),
   or $FOO, and returns a string with all variable references in the form ${FOO}.
   """
-  # $FOO -> ${FOO}
-  str = re.sub(r'\$([a-zA-Z_][a-zA-Z0-9_]*)', r'${\1}', str)
+    # $FOO -> ${FOO}
+    str = re.sub(r"\$([a-zA-Z_][a-zA-Z0-9_]*)", r"${\1}", str)
 
-  # $(FOO) -> ${FOO}
-  matches = re.findall(r'(\$\(([a-zA-Z0-9\-_]+)\))', str)
-  for match in matches:
-    to_replace, variable = match
-    assert '$(' not in match, '$($(FOO)) variables not supported: ' + match
-    str = str.replace(to_replace, '${' + variable + '}')
+    # $(FOO) -> ${FOO}
+    matches = re.findall(r"(\$\(([a-zA-Z0-9\-_]+)\))", str)
+    for match in matches:
+        to_replace, variable = match
+        assert "$(" not in match, "$($(FOO)) variables not supported: " + match
+        str = str.replace(to_replace, "${" + variable + "}")
 
-  return str
+    return str
 
 
 def ExpandEnvVars(string, expansions):
-  """Expands ${VARIABLES}, $(VARIABLES), and $VARIABLES in string per the
+    """Expands ${VARIABLES}, $(VARIABLES), and $VARIABLES in string per the
   expansions list. If the variable expands to something that references
   another variable, this variable is expanded as well if it's in env --
   until no variables present in env are left."""
-  for k, v in reversed(expansions):
-    string = string.replace('${' + k + '}', v)
-    string = string.replace('$(' + k + ')', v)
-    string = string.replace('$' + k, v)
-  return string
+    for k, v in reversed(expansions):
+        string = string.replace("${" + k + "}", v)
+        string = string.replace("$(" + k + ")", v)
+        string = string.replace("$" + k, v)
+    return string
 
 
 def _TopologicallySortedEnvVarKeys(env):
-  """Takes a dict |env| whose values are strings that can refer to other keys,
+    """Takes a dict |env| whose values are strings that can refer to other keys,
   for example env['foo'] = '$(bar) and $(baz)'. Returns a list L of all keys of
   env such that key2 is after key1 in L if env[key2] refers to env[key1].
 
   Throws an Exception in case of dependency cycles.
   """
-  # Since environment variables can refer to other variables, the evaluation
-  # order is important. Below is the logic to compute the dependency graph
-  # and sort it.
-  regex = re.compile(r'\$\{([a-zA-Z0-9\-_]+)\}')
-  def GetEdges(node):
-    # Use a definition of edges such that user_of_variable -> used_varible.
-    # This happens to be easier in this case, since a variable's
-    # definition contains all variables it references in a single string.
-    # We can then reverse the result of the topological sort at the end.
-    # Since: reverse(topsort(DAG)) = topsort(reverse_edges(DAG))
-    matches = set([v for v in regex.findall(env[node]) if v in env])
-    for dependee in matches:
-      assert '${' not in dependee, 'Nested variables not supported: ' + dependee
-    return matches
-
-  try:
-    # Topologically sort, and then reverse, because we used an edge definition
-    # that's inverted from the expected result of this function (see comment
-    # above).
-    order = gyp.common.TopologicallySorted(env.keys(), GetEdges)
-    order.reverse()
-    return order
-  except gyp.common.CycleError as e:
-    raise GypError(
-        'Xcode environment variables are cyclically dependent: ' + str(e.nodes))
-
-
-def GetSortedXcodeEnv(xcode_settings, built_products_dir, srcroot,
-                      configuration, additional_settings=None):
-  env = _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
-                    additional_settings)
-  return [(key, env[key]) for key in _TopologicallySortedEnvVarKeys(env)]
+    # Since environment variables can refer to other variables, the evaluation
+    # order is important. Below is the logic to compute the dependency graph
+    # and sort it.
+    regex = re.compile(r"\$\{([a-zA-Z0-9\-_]+)\}")
+
+    def GetEdges(node):
+        # Use a definition of edges such that user_of_variable -> used_varible.
+        # This happens to be easier in this case, since a variable's
+        # definition contains all variables it references in a single string.
+        # We can then reverse the result of the topological sort at the end.
+        # Since: reverse(topsort(DAG)) = topsort(reverse_edges(DAG))
+        matches = set([v for v in regex.findall(env[node]) if v in env])
+        for dependee in matches:
+            assert "${" not in dependee, "Nested variables not supported: " + dependee
+        return matches
+
+    try:
+        # Topologically sort, and then reverse, because we used an edge definition
+        # that's inverted from the expected result of this function (see comment
+        # above).
+        order = gyp.common.TopologicallySorted(env.keys(), GetEdges)
+        order.reverse()
+        return order
+    except gyp.common.CycleError as e:
+        raise GypError(
+            "Xcode environment variables are cyclically dependent: " + str(e.nodes)
+        )
+
+
+def GetSortedXcodeEnv(
+    xcode_settings, built_products_dir, srcroot, configuration, additional_settings=None
+):
+    env = _GetXcodeEnv(
+        xcode_settings, built_products_dir, srcroot, configuration, additional_settings
+    )
+    return [(key, env[key]) for key in _TopologicallySortedEnvVarKeys(env)]
 
 
 def GetSpecPostbuildCommands(spec, quiet=False):
-  """Returns the list of postbuilds explicitly defined on |spec|, in a form
+    """Returns the list of postbuilds explicitly defined on |spec|, in a form
   executable by a shell."""
-  postbuilds = []
-  for postbuild in spec.get('postbuilds', []):
-    if not quiet:
-      postbuilds.append('echo POSTBUILD\\(%s\\) %s' % (
-            spec['target_name'], postbuild['postbuild_name']))
-    postbuilds.append(gyp.common.EncodePOSIXShellList(postbuild['action']))
-  return postbuilds
+    postbuilds = []
+    for postbuild in spec.get("postbuilds", []):
+        if not quiet:
+            postbuilds.append(
+                "echo POSTBUILD\\(%s\\) %s"
+                % (spec["target_name"], postbuild["postbuild_name"])
+            )
+        postbuilds.append(gyp.common.EncodePOSIXShellList(postbuild["action"]))
+    return postbuilds
 
 
 def _HasIOSTarget(targets):
-  """Returns true if any target contains the iOS specific key
+    """Returns true if any target contains the iOS specific key
   IPHONEOS_DEPLOYMENT_TARGET."""
-  for target_dict in targets.values():
-    for config in target_dict['configurations'].values():
-      if config.get('xcode_settings', {}).get('IPHONEOS_DEPLOYMENT_TARGET'):
-        return True
-  return False
+    for target_dict in targets.values():
+        for config in target_dict["configurations"].values():
+            if config.get("xcode_settings", {}).get("IPHONEOS_DEPLOYMENT_TARGET"):
+                return True
+    return False
 
 
 def _AddIOSDeviceConfigurations(targets):
-  """Clone all targets and append -iphoneos to the name. Configure these targets
+    """Clone all targets and append -iphoneos to the name. Configure these targets
   to build for iOS devices and use correct architectures for those builds."""
-  for target_dict in targets.values():
-    toolset = target_dict['toolset']
-    configs = target_dict['configurations']
-    for config_name, simulator_config_dict in dict(configs).items():
-      iphoneos_config_dict = copy.deepcopy(simulator_config_dict)
-      configs[config_name + '-iphoneos'] = iphoneos_config_dict
-      configs[config_name + '-iphonesimulator'] = simulator_config_dict
-      if toolset == 'target':
-        simulator_config_dict['xcode_settings']['SDKROOT'] = 'iphonesimulator'
-        iphoneos_config_dict['xcode_settings']['SDKROOT'] = 'iphoneos'
-  return targets
+    for target_dict in targets.values():
+        toolset = target_dict["toolset"]
+        configs = target_dict["configurations"]
+        for config_name, simulator_config_dict in dict(configs).items():
+            iphoneos_config_dict = copy.deepcopy(simulator_config_dict)
+            configs[config_name + "-iphoneos"] = iphoneos_config_dict
+            configs[config_name + "-iphonesimulator"] = simulator_config_dict
+            if toolset == "target":
+                simulator_config_dict["xcode_settings"]["SDKROOT"] = "iphonesimulator"
+                iphoneos_config_dict["xcode_settings"]["SDKROOT"] = "iphoneos"
+    return targets
+
 
 def CloneConfigurationForDeviceAndEmulator(target_dicts):
-  """If |target_dicts| contains any iOS targets, automatically create -iphoneos
+    """If |target_dicts| contains any iOS targets, automatically create -iphoneos
   targets for iOS device builds."""
-  if _HasIOSTarget(target_dicts):
-    return _AddIOSDeviceConfigurations(target_dicts)
-  return target_dicts
+    if _HasIOSTarget(target_dicts):
+        return _AddIOSDeviceConfigurations(target_dicts)
+    return target_dicts
diff --git a/tools/gyp/pylib/gyp/xcode_ninja.py b/tools/gyp/pylib/gyp/xcode_ninja.py
index 2bc2143340229ba51a5ade490382624acf62048b..10ddcbccd0310bbab19ec487062527683033a11a 100644
--- a/tools/gyp/pylib/gyp/xcode_ninja.py
+++ b/tools/gyp/pylib/gyp/xcode_ninja.py
@@ -20,116 +20,122 @@ import xml.sax.saxutils
 
 
 def _WriteWorkspace(main_gyp, sources_gyp, params):
-  """ Create a workspace to wrap main and sources gyp paths. """
-  (build_file_root, build_file_ext) = os.path.splitext(main_gyp)
-  workspace_path = build_file_root + '.xcworkspace'
-  options = params['options']
-  if options.generator_output:
-    workspace_path = os.path.join(options.generator_output, workspace_path)
-  try:
-    os.makedirs(workspace_path)
-  except OSError as e:
-    if e.errno != errno.EEXIST:
-      raise
-  output_string = '<?xml version="1.0" encoding="UTF-8"?>\n' + \
-                  '<Workspace version = "1.0">\n'
-  for gyp_name in [main_gyp, sources_gyp]:
-    name = os.path.splitext(os.path.basename(gyp_name))[0] + '.xcodeproj'
-    name = xml.sax.saxutils.quoteattr("group:" + name)
-    output_string += '  <FileRef location = %s></FileRef>\n' % name
-  output_string += '</Workspace>\n'
-
-  workspace_file = os.path.join(workspace_path, "contents.xcworkspacedata")
-
-  try:
-    with open(workspace_file, 'r') as input_file:
-      input_string = input_file.read()
-      if input_string == output_string:
-        return
-  except IOError:
-    # Ignore errors if the file doesn't exist.
-    pass
-
-  with open(workspace_file, 'w') as output_file:
-    output_file.write(output_string)
+    """ Create a workspace to wrap main and sources gyp paths. """
+    (build_file_root, build_file_ext) = os.path.splitext(main_gyp)
+    workspace_path = build_file_root + ".xcworkspace"
+    options = params["options"]
+    if options.generator_output:
+        workspace_path = os.path.join(options.generator_output, workspace_path)
+    try:
+        os.makedirs(workspace_path)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
+    output_string = (
+        '<?xml version="1.0" encoding="UTF-8"?>\n' + '<Workspace version = "1.0">\n'
+    )
+    for gyp_name in [main_gyp, sources_gyp]:
+        name = os.path.splitext(os.path.basename(gyp_name))[0] + ".xcodeproj"
+        name = xml.sax.saxutils.quoteattr("group:" + name)
+        output_string += "  <FileRef location = %s></FileRef>\n" % name
+    output_string += "</Workspace>\n"
+
+    workspace_file = os.path.join(workspace_path, "contents.xcworkspacedata")
+
+    try:
+        with open(workspace_file, "r") as input_file:
+            input_string = input_file.read()
+            if input_string == output_string:
+                return
+    except IOError:
+        # Ignore errors if the file doesn't exist.
+        pass
+
+    with open(workspace_file, "w") as output_file:
+        output_file.write(output_string)
+
 
 def _TargetFromSpec(old_spec, params):
-  """ Create fake target for xcode-ninja wrapper. """
-  # Determine ninja top level build dir (e.g. /path/to/out).
-  ninja_toplevel = None
-  jobs = 0
-  if params:
-    options = params['options']
-    ninja_toplevel = \
-        os.path.join(options.toplevel_dir,
-                     gyp.generator.ninja.ComputeOutputDir(params))
-    jobs = params.get('generator_flags', {}).get('xcode_ninja_jobs', 0)
-
-  target_name = old_spec.get('target_name')
-  product_name = old_spec.get('product_name', target_name)
-  product_extension = old_spec.get('product_extension')
-
-  ninja_target = {}
-  ninja_target['target_name'] = target_name
-  ninja_target['product_name'] = product_name
-  if product_extension:
-    ninja_target['product_extension'] = product_extension
-  ninja_target['toolset'] = old_spec.get('toolset')
-  ninja_target['default_configuration'] = old_spec.get('default_configuration')
-  ninja_target['configurations'] = {}
-
-  # Tell Xcode to look in |ninja_toplevel| for build products.
-  new_xcode_settings = {}
-  if ninja_toplevel:
-    new_xcode_settings['CONFIGURATION_BUILD_DIR'] = \
-        "%s/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)" % ninja_toplevel
-
-  if 'configurations' in old_spec:
-    for config in old_spec['configurations']:
-      old_xcode_settings = \
-        old_spec['configurations'][config].get('xcode_settings', {})
-      if 'IPHONEOS_DEPLOYMENT_TARGET' in old_xcode_settings:
-        new_xcode_settings['CODE_SIGNING_REQUIRED'] = "NO"
-        new_xcode_settings['IPHONEOS_DEPLOYMENT_TARGET'] = \
-            old_xcode_settings['IPHONEOS_DEPLOYMENT_TARGET']
-      for key in ['BUNDLE_LOADER', 'TEST_HOST']:
-        if key in old_xcode_settings:
-          new_xcode_settings[key] = old_xcode_settings[key]
-
-      ninja_target['configurations'][config] = {}
-      ninja_target['configurations'][config]['xcode_settings'] = \
-          new_xcode_settings
-
-  ninja_target['mac_bundle'] = old_spec.get('mac_bundle', 0)
-  ninja_target['mac_xctest_bundle'] = old_spec.get('mac_xctest_bundle', 0)
-  ninja_target['ios_app_extension'] = old_spec.get('ios_app_extension', 0)
-  ninja_target['ios_watchkit_extension'] = \
-      old_spec.get('ios_watchkit_extension', 0)
-  ninja_target['ios_watchkit_app'] = old_spec.get('ios_watchkit_app', 0)
-  ninja_target['type'] = old_spec['type']
-  if ninja_toplevel:
-    ninja_target['actions'] = [
-      {
-        'action_name': 'Compile and copy %s via ninja' % target_name,
-        'inputs': [],
-        'outputs': [],
-        'action': [
-          'env',
-          'PATH=%s' % os.environ['PATH'],
-          'ninja',
-          '-C',
-          new_xcode_settings['CONFIGURATION_BUILD_DIR'],
-          target_name,
-        ],
-        'message': 'Compile and copy %s via ninja' % target_name,
-      },
-    ]
-    if jobs > 0:
-      ninja_target['actions'][0]['action'].extend(('-j', jobs))
-  return ninja_target
+    """ Create fake target for xcode-ninja wrapper. """
+    # Determine ninja top level build dir (e.g. /path/to/out).
+    ninja_toplevel = None
+    jobs = 0
+    if params:
+        options = params["options"]
+        ninja_toplevel = os.path.join(
+            options.toplevel_dir, gyp.generator.ninja.ComputeOutputDir(params)
+        )
+        jobs = params.get("generator_flags", {}).get("xcode_ninja_jobs", 0)
+
+    target_name = old_spec.get("target_name")
+    product_name = old_spec.get("product_name", target_name)
+    product_extension = old_spec.get("product_extension")
+
+    ninja_target = {}
+    ninja_target["target_name"] = target_name
+    ninja_target["product_name"] = product_name
+    if product_extension:
+        ninja_target["product_extension"] = product_extension
+    ninja_target["toolset"] = old_spec.get("toolset")
+    ninja_target["default_configuration"] = old_spec.get("default_configuration")
+    ninja_target["configurations"] = {}
+
+    # Tell Xcode to look in |ninja_toplevel| for build products.
+    new_xcode_settings = {}
+    if ninja_toplevel:
+        new_xcode_settings["CONFIGURATION_BUILD_DIR"] = (
+            "%s/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)" % ninja_toplevel
+        )
+
+    if "configurations" in old_spec:
+        for config in old_spec["configurations"]:
+            old_xcode_settings = old_spec["configurations"][config].get(
+                "xcode_settings", {}
+            )
+            if "IPHONEOS_DEPLOYMENT_TARGET" in old_xcode_settings:
+                new_xcode_settings["CODE_SIGNING_REQUIRED"] = "NO"
+                new_xcode_settings["IPHONEOS_DEPLOYMENT_TARGET"] = old_xcode_settings[
+                    "IPHONEOS_DEPLOYMENT_TARGET"
+                ]
+            for key in ["BUNDLE_LOADER", "TEST_HOST"]:
+                if key in old_xcode_settings:
+                    new_xcode_settings[key] = old_xcode_settings[key]
+
+            ninja_target["configurations"][config] = {}
+            ninja_target["configurations"][config][
+                "xcode_settings"
+            ] = new_xcode_settings
+
+    ninja_target["mac_bundle"] = old_spec.get("mac_bundle", 0)
+    ninja_target["mac_xctest_bundle"] = old_spec.get("mac_xctest_bundle", 0)
+    ninja_target["ios_app_extension"] = old_spec.get("ios_app_extension", 0)
+    ninja_target["ios_watchkit_extension"] = old_spec.get("ios_watchkit_extension", 0)
+    ninja_target["ios_watchkit_app"] = old_spec.get("ios_watchkit_app", 0)
+    ninja_target["type"] = old_spec["type"]
+    if ninja_toplevel:
+        ninja_target["actions"] = [
+            {
+                "action_name": "Compile and copy %s via ninja" % target_name,
+                "inputs": [],
+                "outputs": [],
+                "action": [
+                    "env",
+                    "PATH=%s" % os.environ["PATH"],
+                    "ninja",
+                    "-C",
+                    new_xcode_settings["CONFIGURATION_BUILD_DIR"],
+                    target_name,
+                ],
+                "message": "Compile and copy %s via ninja" % target_name,
+            },
+        ]
+        if jobs > 0:
+            ninja_target["actions"][0]["action"].extend(("-j", jobs))
+    return ninja_target
+
 
 def IsValidTargetForWrapper(target_extras, executable_target_pattern, spec):
-  """Limit targets for Xcode wrapper.
+    """Limit targets for Xcode wrapper.
 
   Xcode sometimes performs poorly with too many targets, so only include
   proper executable targets, with filters to customize.
@@ -138,25 +144,27 @@ def IsValidTargetForWrapper(target_extras, executable_target_pattern, spec):
     executable_target_pattern: Regular expression limiting executable targets.
     spec: Specifications for target.
   """
-  target_name = spec.get('target_name')
-  # Always include targets matching target_extras.
-  if target_extras is not None and re.search(target_extras, target_name):
-    return True
-
-  # Otherwise just show executable targets and xc_tests.
-  if (int(spec.get('mac_xctest_bundle', 0)) != 0 or
-      (spec.get('type', '') == 'executable' and
-       spec.get('product_extension', '') != 'bundle')):
-
-    # If there is a filter and the target does not match, exclude the target.
-    if executable_target_pattern is not None:
-      if not re.search(executable_target_pattern, target_name):
-        return False
-    return True
-  return False
+    target_name = spec.get("target_name")
+    # Always include targets matching target_extras.
+    if target_extras is not None and re.search(target_extras, target_name):
+        return True
+
+    # Otherwise just show executable targets and xc_tests.
+    if int(spec.get("mac_xctest_bundle", 0)) != 0 or (
+        spec.get("type", "") == "executable"
+        and spec.get("product_extension", "") != "bundle"
+    ):
+
+        # If there is a filter and the target does not match, exclude the target.
+        if executable_target_pattern is not None:
+            if not re.search(executable_target_pattern, target_name):
+                return False
+        return True
+    return False
+
 
 def CreateWrapper(target_list, target_dicts, data, params):
-  """Initialize targets for the ninja wrapper.
+    """Initialize targets for the ninja wrapper.
 
   This sets up the necessary variables in the targets to generate Xcode projects
   that use ninja as an external builder.
@@ -166,124 +174,129 @@ def CreateWrapper(target_list, target_dicts, data, params):
     data: Dict of flattened build files keyed on gyp path.
     params: Dict of global options for gyp.
   """
-  orig_gyp = params['build_files'][0]
-  for gyp_name, gyp_dict in data.items():
-    if gyp_name == orig_gyp:
-      depth = gyp_dict['_DEPTH']
-
-  # Check for custom main gyp name, otherwise use the default CHROMIUM_GYP_FILE
-  # and prepend .ninja before the .gyp extension.
-  generator_flags = params.get('generator_flags', {})
-  main_gyp = generator_flags.get('xcode_ninja_main_gyp', None)
-  if main_gyp is None:
-    (build_file_root, build_file_ext) = os.path.splitext(orig_gyp)
-    main_gyp = build_file_root + ".ninja" + build_file_ext
-
-  # Create new |target_list|, |target_dicts| and |data| data structures.
-  new_target_list = []
-  new_target_dicts = {}
-  new_data = {}
-
-  # Set base keys needed for |data|.
-  new_data[main_gyp] = {}
-  new_data[main_gyp]['included_files'] = []
-  new_data[main_gyp]['targets'] = []
-  new_data[main_gyp]['xcode_settings'] = \
-      data[orig_gyp].get('xcode_settings', {})
-
-  # Normally the xcode-ninja generator includes only valid executable targets.
-  # If |xcode_ninja_executable_target_pattern| is set, that list is reduced to
-  # executable targets that match the pattern. (Default all)
-  executable_target_pattern = \
-      generator_flags.get('xcode_ninja_executable_target_pattern', None)
-
-  # For including other non-executable targets, add the matching target name
-  # to the |xcode_ninja_target_pattern| regular expression. (Default none)
-  target_extras = generator_flags.get('xcode_ninja_target_pattern', None)
-
-  for old_qualified_target in target_list:
-    spec = target_dicts[old_qualified_target]
-    if IsValidTargetForWrapper(target_extras, executable_target_pattern, spec):
-      # Add to new_target_list.
-      target_name = spec.get('target_name')
-      new_target_name = '%s:%s#target' % (main_gyp, target_name)
-      new_target_list.append(new_target_name)
-
-      # Add to new_target_dicts.
-      new_target_dicts[new_target_name] = _TargetFromSpec(spec, params)
-
-      # Add to new_data.
-      for old_target in data[old_qualified_target.split(':')[0]]['targets']:
-        if old_target['target_name'] == target_name:
-          new_data_target = {}
-          new_data_target['target_name'] = old_target['target_name']
-          new_data_target['toolset'] = old_target['toolset']
-          new_data[main_gyp]['targets'].append(new_data_target)
-
-  # Create sources target.
-  sources_target_name = 'sources_for_indexing'
-  sources_target = _TargetFromSpec(
-    { 'target_name' : sources_target_name,
-      'toolset': 'target',
-      'default_configuration': 'Default',
-      'mac_bundle': '0',
-      'type': 'executable'
-    }, None)
-
-  # Tell Xcode to look everywhere for headers.
-  sources_target['configurations'] = {'Default': { 'include_dirs': [ depth ] } }
-
-  # Put excluded files into the sources target so they can be opened in Xcode.
-  skip_excluded_files = \
-      not generator_flags.get('xcode_ninja_list_excluded_files', True)
-
-  sources = []
-  for target, target_dict in target_dicts.items():
-    base = os.path.dirname(target)
-    files = target_dict.get('sources', []) + \
-            target_dict.get('mac_bundle_resources', [])
-
-    if not skip_excluded_files:
-      files.extend(target_dict.get('sources_excluded', []) +
-                   target_dict.get('mac_bundle_resources_excluded', []))
-
-    for action in target_dict.get('actions', []):
-      files.extend(action.get('inputs', []))
-
-      if not skip_excluded_files:
-        files.extend(action.get('inputs_excluded', []))
-
-    # Remove files starting with $. These are mostly intermediate files for the
-    # build system.
-    files = [ file for file in files if not file.startswith('$')]
-
-    # Make sources relative to root build file.
-    relative_path = os.path.dirname(main_gyp)
-    sources += [ os.path.relpath(os.path.join(base, file), relative_path)
-                    for file in files ]
-
-  sources_target['sources'] = sorted(set(sources))
-
-  # Put sources_to_index in it's own gyp.
-  sources_gyp = \
-      os.path.join(os.path.dirname(main_gyp), sources_target_name + ".gyp")
-  fully_qualified_target_name = \
-      '%s:%s#target' % (sources_gyp, sources_target_name)
-
-  # Add to new_target_list, new_target_dicts and new_data.
-  new_target_list.append(fully_qualified_target_name)
-  new_target_dicts[fully_qualified_target_name] = sources_target
-  new_data_target = {}
-  new_data_target['target_name'] = sources_target['target_name']
-  new_data_target['_DEPTH'] = depth
-  new_data_target['toolset'] = "target"
-  new_data[sources_gyp] = {}
-  new_data[sources_gyp]['targets'] = []
-  new_data[sources_gyp]['included_files'] = []
-  new_data[sources_gyp]['xcode_settings'] = \
-      data[orig_gyp].get('xcode_settings', {})
-  new_data[sources_gyp]['targets'].append(new_data_target)
-
-  # Write workspace to file.
-  _WriteWorkspace(main_gyp, sources_gyp, params)
-  return (new_target_list, new_target_dicts, new_data)
+    orig_gyp = params["build_files"][0]
+    for gyp_name, gyp_dict in data.items():
+        if gyp_name == orig_gyp:
+            depth = gyp_dict["_DEPTH"]
+
+    # Check for custom main gyp name, otherwise use the default CHROMIUM_GYP_FILE
+    # and prepend .ninja before the .gyp extension.
+    generator_flags = params.get("generator_flags", {})
+    main_gyp = generator_flags.get("xcode_ninja_main_gyp", None)
+    if main_gyp is None:
+        (build_file_root, build_file_ext) = os.path.splitext(orig_gyp)
+        main_gyp = build_file_root + ".ninja" + build_file_ext
+
+    # Create new |target_list|, |target_dicts| and |data| data structures.
+    new_target_list = []
+    new_target_dicts = {}
+    new_data = {}
+
+    # Set base keys needed for |data|.
+    new_data[main_gyp] = {}
+    new_data[main_gyp]["included_files"] = []
+    new_data[main_gyp]["targets"] = []
+    new_data[main_gyp]["xcode_settings"] = data[orig_gyp].get("xcode_settings", {})
+
+    # Normally the xcode-ninja generator includes only valid executable targets.
+    # If |xcode_ninja_executable_target_pattern| is set, that list is reduced to
+    # executable targets that match the pattern. (Default all)
+    executable_target_pattern = generator_flags.get(
+        "xcode_ninja_executable_target_pattern", None
+    )
+
+    # For including other non-executable targets, add the matching target name
+    # to the |xcode_ninja_target_pattern| regular expression. (Default none)
+    target_extras = generator_flags.get("xcode_ninja_target_pattern", None)
+
+    for old_qualified_target in target_list:
+        spec = target_dicts[old_qualified_target]
+        if IsValidTargetForWrapper(target_extras, executable_target_pattern, spec):
+            # Add to new_target_list.
+            target_name = spec.get("target_name")
+            new_target_name = "%s:%s#target" % (main_gyp, target_name)
+            new_target_list.append(new_target_name)
+
+            # Add to new_target_dicts.
+            new_target_dicts[new_target_name] = _TargetFromSpec(spec, params)
+
+            # Add to new_data.
+            for old_target in data[old_qualified_target.split(":")[0]]["targets"]:
+                if old_target["target_name"] == target_name:
+                    new_data_target = {}
+                    new_data_target["target_name"] = old_target["target_name"]
+                    new_data_target["toolset"] = old_target["toolset"]
+                    new_data[main_gyp]["targets"].append(new_data_target)
+
+    # Create sources target.
+    sources_target_name = "sources_for_indexing"
+    sources_target = _TargetFromSpec(
+        {
+            "target_name": sources_target_name,
+            "toolset": "target",
+            "default_configuration": "Default",
+            "mac_bundle": "0",
+            "type": "executable",
+        },
+        None,
+    )
+
+    # Tell Xcode to look everywhere for headers.
+    sources_target["configurations"] = {"Default": {"include_dirs": [depth]}}
+
+    # Put excluded files into the sources target so they can be opened in Xcode.
+    skip_excluded_files = not generator_flags.get(
+        "xcode_ninja_list_excluded_files", True
+    )
+
+    sources = []
+    for target, target_dict in target_dicts.items():
+        base = os.path.dirname(target)
+        files = target_dict.get("sources", []) + target_dict.get(
+            "mac_bundle_resources", []
+        )
+
+        if not skip_excluded_files:
+            files.extend(
+                target_dict.get("sources_excluded", [])
+                + target_dict.get("mac_bundle_resources_excluded", [])
+            )
+
+        for action in target_dict.get("actions", []):
+            files.extend(action.get("inputs", []))
+
+            if not skip_excluded_files:
+                files.extend(action.get("inputs_excluded", []))
+
+        # Remove files starting with $. These are mostly intermediate files for the
+        # build system.
+        files = [file for file in files if not file.startswith("$")]
+
+        # Make sources relative to root build file.
+        relative_path = os.path.dirname(main_gyp)
+        sources += [
+            os.path.relpath(os.path.join(base, file), relative_path) for file in files
+        ]
+
+    sources_target["sources"] = sorted(set(sources))
+
+    # Put sources_to_index in it's own gyp.
+    sources_gyp = os.path.join(os.path.dirname(main_gyp), sources_target_name + ".gyp")
+    fully_qualified_target_name = "%s:%s#target" % (sources_gyp, sources_target_name)
+
+    # Add to new_target_list, new_target_dicts and new_data.
+    new_target_list.append(fully_qualified_target_name)
+    new_target_dicts[fully_qualified_target_name] = sources_target
+    new_data_target = {}
+    new_data_target["target_name"] = sources_target["target_name"]
+    new_data_target["_DEPTH"] = depth
+    new_data_target["toolset"] = "target"
+    new_data[sources_gyp] = {}
+    new_data[sources_gyp]["targets"] = []
+    new_data[sources_gyp]["included_files"] = []
+    new_data[sources_gyp]["xcode_settings"] = data[orig_gyp].get("xcode_settings", {})
+    new_data[sources_gyp]["targets"].append(new_data_target)
+
+    # Write workspace to file.
+    _WriteWorkspace(main_gyp, sources_gyp, params)
+    return (new_target_list, new_target_dicts, new_data)
diff --git a/tools/gyp/pylib/gyp/xcodeproj_file.py b/tools/gyp/pylib/gyp/xcodeproj_file.py
index 1e950dce8f0a05f0abeb6517d31c3f4aab64ee69..d90dd99dccecf9d0eadcfbdb3951ade0f2fc45f2 100644
--- a/tools/gyp/pylib/gyp/xcodeproj_file.py
+++ b/tools/gyp/pylib/gyp/xcodeproj_file.py
@@ -145,11 +145,12 @@ import struct
 import sys
 
 try:
-  basestring, cmp, unicode
+    basestring, cmp, unicode
 except NameError:  # Python 3
-  basestring = unicode = str
-  def cmp(x, y):
-    return (x > y) - (x < y)
+    basestring = unicode = str
+
+    def cmp(x, y):
+        return (x > y) - (x < y)
 
 
 # See XCObject._EncodeString.  This pattern is used to determine when a string
@@ -158,11 +159,11 @@ except NameError:  # Python 3
 # transformed to be properly encoded.  Note that this expression matches the
 # characters listed with "+", for 1 or more occurrences: if a string is empty,
 # it must not match this pattern, because it needs to be encoded as "".
-_unquoted = re.compile('^[A-Za-z0-9$./_]+$')
+_unquoted = re.compile("^[A-Za-z0-9$./_]+$")
 
 # Strings that match this pattern are quoted regardless of what _unquoted says.
 # Oddly, Xcode will quote any string with a run of three or more underscores.
-_quoted = re.compile('___')
+_quoted = re.compile("___")
 
 # This pattern should match any character that needs to be escaped by
 # XCObject._EncodeString.  See that function.
@@ -170,10 +171,11 @@ _escaped = re.compile('[\\\\"]|[\x00-\x1f]')
 
 
 # Used by SourceTreeAndPathFromPath
-_path_leading_variable = re.compile(r'^\$\((.*?)\)(/(.*))?$')
+_path_leading_variable = re.compile(r"^\$\((.*?)\)(/(.*))?$")
+
 
 def SourceTreeAndPathFromPath(input_path):
-  """Given input_path, returns a tuple with sourceTree and path values.
+    """Given input_path, returns a tuple with sourceTree and path values.
 
   Examples:
     input_path     (source_tree, output_path)
@@ -182,21 +184,23 @@ def SourceTreeAndPathFromPath(input_path):
     'path'         (None, 'path')
   """
 
-  source_group_match = _path_leading_variable.match(input_path)
-  if source_group_match:
-    source_tree = source_group_match.group(1)
-    output_path = source_group_match.group(3)  # This may be None.
-  else:
-    source_tree = None
-    output_path = input_path
+    source_group_match = _path_leading_variable.match(input_path)
+    if source_group_match:
+        source_tree = source_group_match.group(1)
+        output_path = source_group_match.group(3)  # This may be None.
+    else:
+        source_tree = None
+        output_path = input_path
+
+    return (source_tree, output_path)
 
-  return (source_tree, output_path)
 
 def ConvertVariablesToShellSyntax(input_string):
-  return re.sub(r'\$\((.*?)\)', '${\\1}', input_string)
+    return re.sub(r"\$\((.*?)\)", "${\\1}", input_string)
+
 
 class XCObject(object):
-  """The abstract base of all class types used in Xcode project files.
+    """The abstract base of all class types used in Xcode project files.
 
   Class variables:
     _schema: A dictionary defining the properties of this class.  The keys to
@@ -263,45 +267,45 @@ class XCObject(object):
                  described by its class' _schema variable.
   """
 
-  _schema = {}
-  _should_print_single_line = False
-
-  # See _EncodeString.
-  _encode_transforms = []
-  i = 0
-  while i < ord(' '):
-    _encode_transforms.append('\\U%04x' % i)
-    i = i + 1
-  _encode_transforms[7] = '\\a'
-  _encode_transforms[8] = '\\b'
-  _encode_transforms[9] = '\\t'
-  _encode_transforms[10] = '\\n'
-  _encode_transforms[11] = '\\v'
-  _encode_transforms[12] = '\\f'
-  _encode_transforms[13] = '\\n'
-
-  _alternate_encode_transforms = list(_encode_transforms)
-  _alternate_encode_transforms[9] = chr(9)
-  _alternate_encode_transforms[10] = chr(10)
-  _alternate_encode_transforms[11] = chr(11)
-
-  def __init__(self, properties=None, id=None, parent=None):
-    self.id = id
-    self.parent = parent
-    self._properties = {}
-    self._hashables = []
-    self._SetDefaultsFromSchema()
-    self.UpdateProperties(properties)
-
-  def __repr__(self):
-    try:
-      name = self.Name()
-    except NotImplementedError:
-      return '<%s at 0x%x>' % (self.__class__.__name__, id(self))
-    return '<%s %r at 0x%x>' % (self.__class__.__name__, name, id(self))
-
-  def Copy(self):
-    """Make a copy of this object.
+    _schema = {}
+    _should_print_single_line = False
+
+    # See _EncodeString.
+    _encode_transforms = []
+    i = 0
+    while i < ord(" "):
+        _encode_transforms.append("\\U%04x" % i)
+        i = i + 1
+    _encode_transforms[7] = "\\a"
+    _encode_transforms[8] = "\\b"
+    _encode_transforms[9] = "\\t"
+    _encode_transforms[10] = "\\n"
+    _encode_transforms[11] = "\\v"
+    _encode_transforms[12] = "\\f"
+    _encode_transforms[13] = "\\n"
+
+    _alternate_encode_transforms = list(_encode_transforms)
+    _alternate_encode_transforms[9] = chr(9)
+    _alternate_encode_transforms[10] = chr(10)
+    _alternate_encode_transforms[11] = chr(11)
+
+    def __init__(self, properties=None, id=None, parent=None):
+        self.id = id
+        self.parent = parent
+        self._properties = {}
+        self._hashables = []
+        self._SetDefaultsFromSchema()
+        self.UpdateProperties(properties)
+
+    def __repr__(self):
+        try:
+            name = self.Name()
+        except NotImplementedError:
+            return "<%s at 0x%x>" % (self.__class__.__name__, id(self))
+        return "<%s %r at 0x%x>" % (self.__class__.__name__, name, id(self))
+
+    def Copy(self):
+        """Make a copy of this object.
 
     The new object will have its own copy of lists and dicts.  Any XCObject
     objects owned by this object (marked "strong") will be copied in the
@@ -310,62 +314,70 @@ class XCObject(object):
     object without making a copy.
     """
 
-    that = self.__class__(id=self.id, parent=self.parent)
-    for key, value in self._properties.items():
-      is_strong = self._schema[key][2]
-
-      if isinstance(value, XCObject):
-        if is_strong:
-          new_value = value.Copy()
-          new_value.parent = that
-          that._properties[key] = new_value
-        else:
-          that._properties[key] = value
-      elif isinstance(value, (basestring, int)):
-        that._properties[key] = value
-      elif isinstance(value, list):
-        if is_strong:
-          # If is_strong is True, each element is an XCObject, so it's safe to
-          # call Copy.
-          that._properties[key] = []
-          for item in value:
-            new_item = item.Copy()
-            new_item.parent = that
-            that._properties[key].append(new_item)
-        else:
-          that._properties[key] = value[:]
-      elif isinstance(value, dict):
-        # dicts are never strong.
-        if is_strong:
-          raise TypeError('Strong dict for key ' + key + ' in ' + \
-                          self.__class__.__name__)
-        else:
-          that._properties[key] = value.copy()
-      else:
-        raise TypeError('Unexpected type ' + value.__class__.__name__ + \
-                        ' for key ' + key + ' in ' + self.__class__.__name__)
-
-    return that
-
-  def Name(self):
-    """Return the name corresponding to an object.
+        that = self.__class__(id=self.id, parent=self.parent)
+        for key, value in self._properties.items():
+            is_strong = self._schema[key][2]
+
+            if isinstance(value, XCObject):
+                if is_strong:
+                    new_value = value.Copy()
+                    new_value.parent = that
+                    that._properties[key] = new_value
+                else:
+                    that._properties[key] = value
+            elif isinstance(value, (basestring, int)):
+                that._properties[key] = value
+            elif isinstance(value, list):
+                if is_strong:
+                    # If is_strong is True, each element is an XCObject, so it's safe to
+                    # call Copy.
+                    that._properties[key] = []
+                    for item in value:
+                        new_item = item.Copy()
+                        new_item.parent = that
+                        that._properties[key].append(new_item)
+                else:
+                    that._properties[key] = value[:]
+            elif isinstance(value, dict):
+                # dicts are never strong.
+                if is_strong:
+                    raise TypeError(
+                        "Strong dict for key " + key + " in " + self.__class__.__name__
+                    )
+                else:
+                    that._properties[key] = value.copy()
+            else:
+                raise TypeError(
+                    "Unexpected type "
+                    + value.__class__.__name__
+                    + " for key "
+                    + key
+                    + " in "
+                    + self.__class__.__name__
+                )
+
+        return that
+
+    def Name(self):
+        """Return the name corresponding to an object.
 
     Not all objects necessarily need to be nameable, and not all that do have
     a "name" property.  Override as needed.
     """
 
-    # If the schema indicates that "name" is required, try to access the
-    # property even if it doesn't exist.  This will result in a KeyError
-    # being raised for the property that should be present, which seems more
-    # appropriate than NotImplementedError in this case.
-    if 'name' in self._properties or \
-        ('name' in self._schema and self._schema['name'][3]):
-      return self._properties['name']
+        # If the schema indicates that "name" is required, try to access the
+        # property even if it doesn't exist.  This will result in a KeyError
+        # being raised for the property that should be present, which seems more
+        # appropriate than NotImplementedError in this case.
+        if "name" in self._properties or (
+            "name" in self._schema and self._schema["name"][3]
+        ):
+            return self._properties["name"]
 
-    raise NotImplementedError(self.__class__.__name__ + ' must implement Name')
+        raise NotImplementedError(self.__class__.__name__ + " must implement Name")
 
-  def Comment(self):
-    """Return a comment string for the object.
+    def Comment(self):
+        """Return a comment string for the object.
 
     Most objects just use their name as the comment, but PBXProject uses
     different values.
@@ -374,24 +386,24 @@ class XCObject(object):
     strings applied to it.
     """
 
-    return self.Name()
+        return self.Name()
 
-  def Hashables(self):
-    hashables = [self.__class__.__name__]
+    def Hashables(self):
+        hashables = [self.__class__.__name__]
 
-    name = self.Name()
-    if name != None:
-      hashables.append(name)
+        name = self.Name()
+        if name is not None:
+            hashables.append(name)
 
-    hashables.extend(self._hashables)
+        hashables.extend(self._hashables)
 
-    return hashables
+        return hashables
 
-  def HashablesForChild(self):
-    return None
+    def HashablesForChild(self):
+        return None
 
-  def ComputeIDs(self, recursive=True, overwrite=True, seed_hash=None):
-    """Set "id" properties deterministically.
+    def ComputeIDs(self, recursive=True, overwrite=True, seed_hash=None):
+        """Set "id" properties deterministically.
 
     An object's "id" property is set based on a hash of its class type and
     name, as well as the class type and name of all ancestor objects.  As
@@ -405,8 +417,8 @@ class XCObject(object):
     replaced.
     """
 
-    def _HashUpdate(hash, data):
-      """Update hash with data's length and contents.
+        def _HashUpdate(hash, data):
+            """Update hash with data's length and contents.
 
       If the hash were updated only with the value of data, it would be
       possible for clowns to induce collisions by manipulating the names of
@@ -414,162 +426,167 @@ class XCObject(object):
       ID collisions will be encountered, intentionally or not.
       """
 
-      hash.update(struct.pack('>i', len(data)))
-      hash.update(data)
-
-    if seed_hash is None:
-      seed_hash = hashlib.sha1()
-
-    hash = seed_hash.copy()
-
-    hashables = self.Hashables()
-    assert len(hashables) > 0
-    for hashable in hashables:
-      _HashUpdate(hash, hashable)
-
-    if recursive:
-      hashables_for_child = self.HashablesForChild()
-      if hashables_for_child is None:
-        child_hash = hash
-      else:
-        assert len(hashables_for_child) > 0
-        child_hash = seed_hash.copy()
-        for hashable in hashables_for_child:
-          _HashUpdate(child_hash, hashable)
-
-      for child in self.Children():
-        child.ComputeIDs(recursive, overwrite, child_hash)
-
-    if overwrite or self.id is None:
-      # Xcode IDs are only 96 bits (24 hex characters), but a SHA-1 digest is
-      # is 160 bits.  Instead of throwing out 64 bits of the digest, xor them
-      # into the portion that gets used.
-      assert hash.digest_size % 4 == 0
-      digest_int_count = hash.digest_size / 4
-      digest_ints = struct.unpack('>' + 'I' * digest_int_count, hash.digest())
-      id_ints = [0, 0, 0]
-      for index in range(0, digest_int_count):
-        id_ints[index % 3] ^= digest_ints[index]
-      self.id = '%08X%08X%08X' % tuple(id_ints)
-
-  def EnsureNoIDCollisions(self):
-    """Verifies that no two objects have the same ID.  Checks all descendants.
+            hash.update(struct.pack(">i", len(data)))
+            hash.update(data)
+
+        if seed_hash is None:
+            seed_hash = hashlib.sha1()
+
+        hash = seed_hash.copy()
+
+        hashables = self.Hashables()
+        assert len(hashables) > 0
+        for hashable in hashables:
+            _HashUpdate(hash, hashable)
+
+        if recursive:
+            hashables_for_child = self.HashablesForChild()
+            if hashables_for_child is None:
+                child_hash = hash
+            else:
+                assert len(hashables_for_child) > 0
+                child_hash = seed_hash.copy()
+                for hashable in hashables_for_child:
+                    _HashUpdate(child_hash, hashable)
+
+            for child in self.Children():
+                child.ComputeIDs(recursive, overwrite, child_hash)
+
+        if overwrite or self.id is None:
+            # Xcode IDs are only 96 bits (24 hex characters), but a SHA-1 digest is
+            # is 160 bits.  Instead of throwing out 64 bits of the digest, xor them
+            # into the portion that gets used.
+            assert hash.digest_size % 4 == 0
+            digest_int_count = hash.digest_size // 4
+            digest_ints = struct.unpack(">" + "I" * digest_int_count, hash.digest())
+            id_ints = [0, 0, 0]
+            for index in range(0, digest_int_count):
+                id_ints[index % 3] ^= digest_ints[index]
+            self.id = "%08X%08X%08X" % tuple(id_ints)
+
+    def EnsureNoIDCollisions(self):
+        """Verifies that no two objects have the same ID.  Checks all descendants.
     """
 
-    ids = {}
-    descendants = self.Descendants()
-    for descendant in descendants:
-      if descendant.id in ids:
-        other = ids[descendant.id]
-        raise KeyError(
-              'Duplicate ID %s, objects "%s" and "%s" in "%s"' % \
-              (descendant.id, str(descendant._properties),
-               str(other._properties), self._properties['rootObject'].Name()))
-      ids[descendant.id] = descendant
-
-  def Children(self):
-    """Returns a list of all of this object's owned (strong) children."""
-
-    children = []
-    for property, attributes in self._schema.items():
-      (is_list, property_type, is_strong) = attributes[0:3]
-      if is_strong and property in self._properties:
-        if not is_list:
-          children.append(self._properties[property])
-        else:
-          children.extend(self._properties[property])
-    return children
-
-  def Descendants(self):
-    """Returns a list of all of this object's descendants, including this
+        ids = {}
+        descendants = self.Descendants()
+        for descendant in descendants:
+            if descendant.id in ids:
+                other = ids[descendant.id]
+                raise KeyError(
+                    'Duplicate ID %s, objects "%s" and "%s" in "%s"'
+                    % (
+                        descendant.id,
+                        str(descendant._properties),
+                        str(other._properties),
+                        self._properties["rootObject"].Name(),
+                    )
+                )
+            ids[descendant.id] = descendant
+
+    def Children(self):
+        """Returns a list of all of this object's owned (strong) children."""
+
+        children = []
+        for property, attributes in self._schema.items():
+            (is_list, property_type, is_strong) = attributes[0:3]
+            if is_strong and property in self._properties:
+                if not is_list:
+                    children.append(self._properties[property])
+                else:
+                    children.extend(self._properties[property])
+        return children
+
+    def Descendants(self):
+        """Returns a list of all of this object's descendants, including this
     object.
     """
 
-    children = self.Children()
-    descendants = [self]
-    for child in children:
-      descendants.extend(child.Descendants())
-    return descendants
+        children = self.Children()
+        descendants = [self]
+        for child in children:
+            descendants.extend(child.Descendants())
+        return descendants
 
-  def PBXProjectAncestor(self):
-    # The base case for recursion is defined at PBXProject.PBXProjectAncestor.
-    if self.parent:
-      return self.parent.PBXProjectAncestor()
-    return None
+    def PBXProjectAncestor(self):
+        # The base case for recursion is defined at PBXProject.PBXProjectAncestor.
+        if self.parent:
+            return self.parent.PBXProjectAncestor()
+        return None
 
-  def _EncodeComment(self, comment):
-    """Encodes a comment to be placed in the project file output, mimicing
+    def _EncodeComment(self, comment):
+        """Encodes a comment to be placed in the project file output, mimicking
     Xcode behavior.
     """
 
-    # This mimics Xcode behavior by wrapping the comment in "/*" and "*/".  If
-    # the string already contains a "*/", it is turned into "(*)/".  This keeps
-    # the file writer from outputting something that would be treated as the
-    # end of a comment in the middle of something intended to be entirely a
-    # comment.
-
-    return '/* ' + comment.replace('*/', '(*)/') + ' */'
-
-  def _EncodeTransform(self, match):
-    # This function works closely with _EncodeString.  It will only be called
-    # by re.sub with match.group(0) containing a character matched by the
-    # the _escaped expression.
-    char = match.group(0)
-
-    # Backslashes (\) and quotation marks (") are always replaced with a
-    # backslash-escaped version of the same.  Everything else gets its
-    # replacement from the class' _encode_transforms array.
-    if char == '\\':
-      return '\\\\'
-    if char == '"':
-      return '\\"'
-    return self._encode_transforms[ord(char)]
-
-  def _EncodeString(self, value):
-    """Encodes a string to be placed in the project file output, mimicing
+        # This mimics Xcode behavior by wrapping the comment in "/*" and "*/".  If
+        # the string already contains a "*/", it is turned into "(*)/".  This keeps
+        # the file writer from outputting something that would be treated as the
+        # end of a comment in the middle of something intended to be entirely a
+        # comment.
+
+        return "/* " + comment.replace("*/", "(*)/") + " */"
+
+    def _EncodeTransform(self, match):
+        # This function works closely with _EncodeString.  It will only be called
+        # by re.sub with match.group(0) containing a character matched by the
+        # the _escaped expression.
+        char = match.group(0)
+
+        # Backslashes (\) and quotation marks (") are always replaced with a
+        # backslash-escaped version of the same.  Everything else gets its
+        # replacement from the class' _encode_transforms array.
+        if char == "\\":
+            return "\\\\"
+        if char == '"':
+            return '\\"'
+        return self._encode_transforms[ord(char)]
+
+    def _EncodeString(self, value):
+        """Encodes a string to be placed in the project file output, mimicking
     Xcode behavior.
     """
 
-    # Use quotation marks when any character outside of the range A-Z, a-z, 0-9,
-    # $ (dollar sign), . (period), and _ (underscore) is present.  Also use
-    # quotation marks to represent empty strings.
-    #
-    # Escape " (double-quote) and \ (backslash) by preceding them with a
-    # backslash.
-    #
-    # Some characters below the printable ASCII range are encoded specially:
-    #     7 ^G BEL is encoded as "\a"
-    #     8 ^H BS  is encoded as "\b"
-    #    11 ^K VT  is encoded as "\v"
-    #    12 ^L NP  is encoded as "\f"
-    #   127 ^? DEL is passed through as-is without escaping
-    #  - In PBXFileReference and PBXBuildFile objects:
-    #     9 ^I HT  is passed through as-is without escaping
-    #    10 ^J NL  is passed through as-is without escaping
-    #    13 ^M CR  is passed through as-is without escaping
-    #  - In other objects:
-    #     9 ^I HT  is encoded as "\t"
-    #    10 ^J NL  is encoded as "\n"
-    #    13 ^M CR  is encoded as "\n" rendering it indistinguishable from
-    #              10 ^J NL
-    # All other characters within the ASCII control character range (0 through
-    # 31 inclusive) are encoded as "\U001f" referring to the Unicode code point
-    # in hexadecimal.  For example, character 14 (^N SO) is encoded as "\U000e".
-    # Characters above the ASCII range are passed through to the output encoded
-    # as UTF-8 without any escaping.  These mappings are contained in the
-    # class' _encode_transforms list.
-
-    if _unquoted.search(value) and not _quoted.search(value):
-      return value
-
-    return '"' + _escaped.sub(self._EncodeTransform, value) + '"'
-
-  def _XCPrint(self, file, tabs, line):
-    file.write('\t' * tabs + line)
-
-  def _XCPrintableValue(self, tabs, value, flatten_list=False):
-    """Returns a representation of value that may be printed in a project file,
-    mimicing Xcode's behavior.
+        # Use quotation marks when any character outside of the range A-Z, a-z, 0-9,
+        # $ (dollar sign), . (period), and _ (underscore) is present.  Also use
+        # quotation marks to represent empty strings.
+        #
+        # Escape " (double-quote) and \ (backslash) by preceding them with a
+        # backslash.
+        #
+        # Some characters below the printable ASCII range are encoded specially:
+        #     7 ^G BEL is encoded as "\a"
+        #     8 ^H BS  is encoded as "\b"
+        #    11 ^K VT  is encoded as "\v"
+        #    12 ^L NP  is encoded as "\f"
+        #   127 ^? DEL is passed through as-is without escaping
+        #  - In PBXFileReference and PBXBuildFile objects:
+        #     9 ^I HT  is passed through as-is without escaping
+        #    10 ^J NL  is passed through as-is without escaping
+        #    13 ^M CR  is passed through as-is without escaping
+        #  - In other objects:
+        #     9 ^I HT  is encoded as "\t"
+        #    10 ^J NL  is encoded as "\n"
+        #    13 ^M CR  is encoded as "\n" rendering it indistinguishable from
+        #              10 ^J NL
+        # All other characters within the ASCII control character range (0 through
+        # 31 inclusive) are encoded as "\U001f" referring to the Unicode code point
+        # in hexadecimal.  For example, character 14 (^N SO) is encoded as "\U000e".
+        # Characters above the ASCII range are passed through to the output encoded
+        # as UTF-8 without any escaping.  These mappings are contained in the
+        # class' _encode_transforms list.
+
+        if _unquoted.search(value) and not _quoted.search(value):
+            return value
+
+        return '"' + _escaped.sub(self._EncodeTransform, value) + '"'
+
+    def _XCPrint(self, file, tabs, line):
+        file.write("\t" * tabs + line)
+
+    def _XCPrintableValue(self, tabs, value, flatten_list=False):
+        """Returns a representation of value that may be printed in a project file,
+    mimicking Xcode's behavior.
 
     _XCPrintableValue can handle str and int values, XCObjects (which are
     made printable by returning their id property), and list and dict objects
@@ -582,58 +599,65 @@ class XCObject(object):
     strings.
     """
 
-    printable = ''
-    comment = None
+        printable = ""
+        comment = None
 
-    if self._should_print_single_line:
-      sep = ' '
-      element_tabs = ''
-      end_tabs = ''
-    else:
-      sep = '\n'
-      element_tabs = '\t' * (tabs + 1)
-      end_tabs = '\t' * tabs
-
-    if isinstance(value, XCObject):
-      printable += value.id
-      comment = value.Comment()
-    elif isinstance(value, str):
-      printable += self._EncodeString(value)
-    elif isinstance(value, unicode):
-      printable += self._EncodeString(value.encode('utf-8'))
-    elif isinstance(value, int):
-      printable += str(value)
-    elif isinstance(value, list):
-      if flatten_list and len(value) <= 1:
-        if len(value) == 0:
-          printable += self._EncodeString('')
+        if self._should_print_single_line:
+            sep = " "
+            element_tabs = ""
+            end_tabs = ""
         else:
-          printable += self._EncodeString(value[0])
-      else:
-        printable = '(' + sep
-        for item in value:
-          printable += element_tabs + \
-                       self._XCPrintableValue(tabs + 1, item, flatten_list) + \
-                       ',' + sep
-        printable += end_tabs + ')'
-    elif isinstance(value, dict):
-      printable = '{' + sep
-      for item_key, item_value in sorted(value.items()):
-        printable += element_tabs + \
-            self._XCPrintableValue(tabs + 1, item_key, flatten_list) + ' = ' + \
-            self._XCPrintableValue(tabs + 1, item_value, flatten_list) + ';' + \
-            sep
-      printable += end_tabs + '}'
-    else:
-      raise TypeError("Can't make " + value.__class__.__name__ + ' printable')
+            sep = "\n"
+            element_tabs = "\t" * (tabs + 1)
+            end_tabs = "\t" * tabs
+
+        if isinstance(value, XCObject):
+            printable += value.id
+            comment = value.Comment()
+        elif isinstance(value, str):
+            printable += self._EncodeString(value)
+        elif isinstance(value, basestring):
+            printable += self._EncodeString(value.encode("utf-8"))
+        elif isinstance(value, int):
+            printable += str(value)
+        elif isinstance(value, list):
+            if flatten_list and len(value) <= 1:
+                if len(value) == 0:
+                    printable += self._EncodeString("")
+                else:
+                    printable += self._EncodeString(value[0])
+            else:
+                printable = "(" + sep
+                for item in value:
+                    printable += (
+                        element_tabs
+                        + self._XCPrintableValue(tabs + 1, item, flatten_list)
+                        + ","
+                        + sep
+                    )
+                printable += end_tabs + ")"
+        elif isinstance(value, dict):
+            printable = "{" + sep
+            for item_key, item_value in sorted(value.items()):
+                printable += (
+                    element_tabs
+                    + self._XCPrintableValue(tabs + 1, item_key, flatten_list)
+                    + " = "
+                    + self._XCPrintableValue(tabs + 1, item_value, flatten_list)
+                    + ";"
+                    + sep
+                )
+            printable += end_tabs + "}"
+        else:
+            raise TypeError("Can't make " + value.__class__.__name__ + " printable")
 
-    if comment != None:
-      printable += ' ' + self._EncodeComment(comment)
+        if comment:
+            printable += " " + self._EncodeComment(comment)
 
-    return printable
+        return printable
 
-  def _XCKVPrint(self, file, tabs, key, value):
-    """Prints a key and value, members of an XCObject's _properties dictionary,
+    def _XCKVPrint(self, file, tabs, key, value):
+        """Prints a key and value, members of an XCObject's _properties dictionary,
     to file.
 
     tabs is an int identifying the indentation level.  If the class'
@@ -641,99 +665,100 @@ class XCObject(object):
     key-value pair will be followed by a space insead of a newline.
     """
 
-    if self._should_print_single_line:
-      printable = ''
-      after_kv = ' '
-    else:
-      printable = '\t' * tabs
-      after_kv = '\n'
-
-    # Xcode usually prints remoteGlobalIDString values in PBXContainerItemProxy
-    # objects without comments.  Sometimes it prints them with comments, but
-    # the majority of the time, it doesn't.  To avoid unnecessary changes to
-    # the project file after Xcode opens it, don't write comments for
-    # remoteGlobalIDString.  This is a sucky hack and it would certainly be
-    # cleaner to extend the schema to indicate whether or not a comment should
-    # be printed, but since this is the only case where the problem occurs and
-    # Xcode itself can't seem to make up its mind, the hack will suffice.
-    #
-    # Also see PBXContainerItemProxy._schema['remoteGlobalIDString'].
-    if key == 'remoteGlobalIDString' and isinstance(self,
-                                                    PBXContainerItemProxy):
-      value_to_print = value.id
-    else:
-      value_to_print = value
+        if self._should_print_single_line:
+            printable = ""
+            after_kv = " "
+        else:
+            printable = "\t" * tabs
+            after_kv = "\n"
+
+        # Xcode usually prints remoteGlobalIDString values in PBXContainerItemProxy
+        # objects without comments.  Sometimes it prints them with comments, but
+        # the majority of the time, it doesn't.  To avoid unnecessary changes to
+        # the project file after Xcode opens it, don't write comments for
+        # remoteGlobalIDString.  This is a sucky hack and it would certainly be
+        # cleaner to extend the schema to indicate whether or not a comment should
+        # be printed, but since this is the only case where the problem occurs and
+        # Xcode itself can't seem to make up its mind, the hack will suffice.
+        #
+        # Also see PBXContainerItemProxy._schema['remoteGlobalIDString'].
+        if key == "remoteGlobalIDString" and isinstance(self, PBXContainerItemProxy):
+            value_to_print = value.id
+        else:
+            value_to_print = value
 
-    # PBXBuildFile's settings property is represented in the output as a dict,
-    # but a hack here has it represented as a string. Arrange to strip off the
-    # quotes so that it shows up in the output as expected.
-    if key == 'settings' and isinstance(self, PBXBuildFile):
-      strip_value_quotes = True
-    else:
-      strip_value_quotes = False
+        # PBXBuildFile's settings property is represented in the output as a dict,
+        # but a hack here has it represented as a string. Arrange to strip off the
+        # quotes so that it shows up in the output as expected.
+        if key == "settings" and isinstance(self, PBXBuildFile):
+            strip_value_quotes = True
+        else:
+            strip_value_quotes = False
 
-    # In another one-off, let's set flatten_list on buildSettings properties
-    # of XCBuildConfiguration objects, because that's how Xcode treats them.
-    if key == 'buildSettings' and isinstance(self, XCBuildConfiguration):
-      flatten_list = True
-    else:
-      flatten_list = False
-
-    try:
-      printable_key = self._XCPrintableValue(tabs, key, flatten_list)
-      printable_value = self._XCPrintableValue(tabs, value_to_print,
-                                               flatten_list)
-      if strip_value_quotes and len(printable_value) > 1 and \
-          printable_value[0] == '"' and printable_value[-1] == '"':
-        printable_value = printable_value[1:-1]
-      printable += printable_key + ' = ' + printable_value + ';' + after_kv
-    except TypeError as e:
-      gyp.common.ExceptionAppend(e,
-                                 'while printing key "%s"' % key)
-      raise
-
-    self._XCPrint(file, 0, printable)
-
-  def Print(self, file=sys.stdout):
-    """Prints a reprentation of this object to file, adhering to Xcode output
+        # In another one-off, let's set flatten_list on buildSettings properties
+        # of XCBuildConfiguration objects, because that's how Xcode treats them.
+        if key == "buildSettings" and isinstance(self, XCBuildConfiguration):
+            flatten_list = True
+        else:
+            flatten_list = False
+
+        try:
+            printable_key = self._XCPrintableValue(tabs, key, flatten_list)
+            printable_value = self._XCPrintableValue(tabs, value_to_print, flatten_list)
+            if (
+                strip_value_quotes
+                and len(printable_value) > 1
+                and printable_value[0] == '"'
+                and printable_value[-1] == '"'
+            ):
+                printable_value = printable_value[1:-1]
+            printable += printable_key + " = " + printable_value + ";" + after_kv
+        except TypeError as e:
+            gyp.common.ExceptionAppend(e, 'while printing key "%s"' % key)
+            raise
+
+        self._XCPrint(file, 0, printable)
+
+    def Print(self, file=sys.stdout):
+        """Prints a reprentation of this object to file, adhering to Xcode output
     formatting.
     """
 
-    self.VerifyHasRequiredProperties()
-
-    if self._should_print_single_line:
-      # When printing an object in a single line, Xcode doesn't put any space
-      # between the beginning of a dictionary (or presumably a list) and the
-      # first contained item, so you wind up with snippets like
-      #   ...CDEF = {isa = PBXFileReference; fileRef = 0123...
-      # If it were me, I would have put a space in there after the opening
-      # curly, but I guess this is just another one of those inconsistencies
-      # between how Xcode prints PBXFileReference and PBXBuildFile objects as
-      # compared to other objects.  Mimic Xcode's behavior here by using an
-      # empty string for sep.
-      sep = ''
-      end_tabs = 0
-    else:
-      sep = '\n'
-      end_tabs = 2
+        self.VerifyHasRequiredProperties()
+
+        if self._should_print_single_line:
+            # When printing an object in a single line, Xcode doesn't put any space
+            # between the beginning of a dictionary (or presumably a list) and the
+            # first contained item, so you wind up with snippets like
+            #   ...CDEF = {isa = PBXFileReference; fileRef = 0123...
+            # If it were me, I would have put a space in there after the opening
+            # curly, but I guess this is just another one of those inconsistencies
+            # between how Xcode prints PBXFileReference and PBXBuildFile objects as
+            # compared to other objects.  Mimic Xcode's behavior here by using an
+            # empty string for sep.
+            sep = ""
+            end_tabs = 0
+        else:
+            sep = "\n"
+            end_tabs = 2
 
-    # Start the object.  For example, '\t\tPBXProject = {\n'.
-    self._XCPrint(file, 2, self._XCPrintableValue(2, self) + ' = {' + sep)
+        # Start the object.  For example, '\t\tPBXProject = {\n'.
+        self._XCPrint(file, 2, self._XCPrintableValue(2, self) + " = {" + sep)
 
-    # "isa" isn't in the _properties dictionary, it's an intrinsic property
-    # of the class which the object belongs to.  Xcode always outputs "isa"
-    # as the first element of an object dictionary.
-    self._XCKVPrint(file, 3, 'isa', self.__class__.__name__)
+        # "isa" isn't in the _properties dictionary, it's an intrinsic property
+        # of the class which the object belongs to.  Xcode always outputs "isa"
+        # as the first element of an object dictionary.
+        self._XCKVPrint(file, 3, "isa", self.__class__.__name__)
 
-    # The remaining elements of an object dictionary are sorted alphabetically.
-    for property, value in sorted(self._properties.items()):
-      self._XCKVPrint(file, 3, property, value)
+        # The remaining elements of an object dictionary are sorted alphabetically.
+        for property, value in sorted(self._properties.items()):
+            self._XCKVPrint(file, 3, property, value)
 
-    # End the object.
-    self._XCPrint(file, end_tabs, '};\n')
+        # End the object.
+        self._XCPrint(file, end_tabs, "};\n")
 
-  def UpdateProperties(self, properties, do_copy=False):
-    """Merge the supplied properties into the _properties dictionary.
+    def UpdateProperties(self, properties, do_copy=False):
+        """Merge the supplied properties into the _properties dictionary.
 
     The input properties must adhere to the class schema or a KeyError or
     TypeError exception will be raised.  If adding an object of an XCObject
@@ -745,206 +770,244 @@ class XCObject(object):
     references added.
     """
 
-    if properties is None:
-      return
-
-    for property, value in properties.items():
-      # Make sure the property is in the schema.
-      if not property in self._schema:
-        raise KeyError(property + ' not in ' + self.__class__.__name__)
-
-      # Make sure the property conforms to the schema.
-      (is_list, property_type, is_strong) = self._schema[property][0:3]
-      if is_list:
-        if value.__class__ != list:
-          raise TypeError(
-                property + ' of ' + self.__class__.__name__ + \
-                ' must be list, not ' + value.__class__.__name__)
-        for item in value:
-          if not isinstance(item, property_type) and \
-             not (item.__class__ == unicode and property_type == str):
-            # Accept unicode where str is specified.  str is treated as
-            # UTF-8-encoded.
-            raise TypeError(
-                  'item of ' + property + ' of ' + self.__class__.__name__ + \
-                  ' must be ' + property_type.__name__ + ', not ' + \
-                  item.__class__.__name__)
-      elif not isinstance(value, property_type) and \
-           not (value.__class__ == unicode and property_type == str):
-        # Accept unicode where str is specified.  str is treated as
-        # UTF-8-encoded.
-        raise TypeError(
-              property + ' of ' + self.__class__.__name__ + ' must be ' + \
-              property_type.__name__ + ', not ' + value.__class__.__name__)
-
-      # Checks passed, perform the assignment.
-      if do_copy:
-        if isinstance(value, XCObject):
-          if is_strong:
-            self._properties[property] = value.Copy()
-          else:
-            self._properties[property] = value
-        elif isinstance(value, (basestring, int)):
-          self._properties[property] = value
-        elif isinstance(value, list):
-          if is_strong:
-            # If is_strong is True, each element is an XCObject, so it's safe
-            # to call Copy.
-            self._properties[property] = []
-            for item in value:
-              self._properties[property].append(item.Copy())
-          else:
-            self._properties[property] = value[:]
-        elif isinstance(value, dict):
-          self._properties[property] = value.copy()
-        else:
-          raise TypeError("Don't know how to copy a " + \
-                          value.__class__.__name__ + ' object for ' + \
-                          property + ' in ' + self.__class__.__name__)
-      else:
-        self._properties[property] = value
-
-      # Set up the child's back-reference to this object.  Don't use |value|
-      # any more because it may not be right if do_copy is true.
-      if is_strong:
+        if properties is None:
+            return
+
+        for property, value in properties.items():
+            # Make sure the property is in the schema.
+            if property not in self._schema:
+                raise KeyError(property + " not in " + self.__class__.__name__)
+
+            # Make sure the property conforms to the schema.
+            (is_list, property_type, is_strong) = self._schema[property][0:3]
+            if is_list:
+                if value.__class__ != list:
+                    raise TypeError(
+                        property
+                        + " of "
+                        + self.__class__.__name__
+                        + " must be list, not "
+                        + value.__class__.__name__
+                    )
+                for item in value:
+                    if not isinstance(item, property_type) and not (
+                        isinstance(item, basestring) and property_type == str
+                    ):
+                        # Accept unicode where str is specified.  str is treated as
+                        # UTF-8-encoded.
+                        raise TypeError(
+                            "item of "
+                            + property
+                            + " of "
+                            + self.__class__.__name__
+                            + " must be "
+                            + property_type.__name__
+                            + ", not "
+                            + item.__class__.__name__
+                        )
+            elif not isinstance(value, property_type) and not (
+                isinstance(value, basestring) and property_type == str
+            ):
+                # Accept unicode where str is specified.  str is treated as
+                # UTF-8-encoded.
+                raise TypeError(
+                    property
+                    + " of "
+                    + self.__class__.__name__
+                    + " must be "
+                    + property_type.__name__
+                    + ", not "
+                    + value.__class__.__name__
+                )
+
+            # Checks passed, perform the assignment.
+            if do_copy:
+                if isinstance(value, XCObject):
+                    if is_strong:
+                        self._properties[property] = value.Copy()
+                    else:
+                        self._properties[property] = value
+                elif isinstance(value, (basestring, int)):
+                    self._properties[property] = value
+                elif isinstance(value, list):
+                    if is_strong:
+                        # If is_strong is True, each element is an XCObject,
+                        # so it's safe to call Copy.
+                        self._properties[property] = []
+                        for item in value:
+                            self._properties[property].append(item.Copy())
+                    else:
+                        self._properties[property] = value[:]
+                elif isinstance(value, dict):
+                    self._properties[property] = value.copy()
+                else:
+                    raise TypeError(
+                        "Don't know how to copy a "
+                        + value.__class__.__name__
+                        + " object for "
+                        + property
+                        + " in "
+                        + self.__class__.__name__
+                    )
+            else:
+                self._properties[property] = value
+
+            # Set up the child's back-reference to this object.  Don't use |value|
+            # any more because it may not be right if do_copy is true.
+            if is_strong:
+                if not is_list:
+                    self._properties[property].parent = self
+                else:
+                    for item in self._properties[property]:
+                        item.parent = self
+
+    def HasProperty(self, key):
+        return key in self._properties
+
+    def GetProperty(self, key):
+        return self._properties[key]
+
+    def SetProperty(self, key, value):
+        self.UpdateProperties({key: value})
+
+    def DelProperty(self, key):
+        if key in self._properties:
+            del self._properties[key]
+
+    def AppendProperty(self, key, value):
+        # TODO(mark): Support ExtendProperty too (and make this call that)?
+
+        # Schema validation.
+        if key not in self._schema:
+            raise KeyError(key + " not in " + self.__class__.__name__)
+
+        (is_list, property_type, is_strong) = self._schema[key][0:3]
         if not is_list:
-          self._properties[property].parent = self
-        else:
-          for item in self._properties[property]:
-            item.parent = self
-
-  def HasProperty(self, key):
-    return key in self._properties
-
-  def GetProperty(self, key):
-    return self._properties[key]
-
-  def SetProperty(self, key, value):
-    self.UpdateProperties({key: value})
-
-  def DelProperty(self, key):
-    if key in self._properties:
-      del self._properties[key]
-
-  def AppendProperty(self, key, value):
-    # TODO(mark): Support ExtendProperty too (and make this call that)?
-
-    # Schema validation.
-    if not key in self._schema:
-      raise KeyError(key + ' not in ' + self.__class__.__name__)
-
-    (is_list, property_type, is_strong) = self._schema[key][0:3]
-    if not is_list:
-      raise TypeError(key + ' of ' + self.__class__.__name__ + ' must be list')
-    if not isinstance(value, property_type):
-      raise TypeError('item of ' + key + ' of ' + self.__class__.__name__ + \
-                      ' must be ' + property_type.__name__ + ', not ' + \
-                      value.__class__.__name__)
-
-    # If the property doesn't exist yet, create a new empty list to receive the
-    # item.
-    if not key in self._properties:
-      self._properties[key] = []
-
-    # Set up the ownership link.
-    if is_strong:
-      value.parent = self
+            raise TypeError(key + " of " + self.__class__.__name__ + " must be list")
+        if not isinstance(value, property_type):
+            raise TypeError(
+                "item of "
+                + key
+                + " of "
+                + self.__class__.__name__
+                + " must be "
+                + property_type.__name__
+                + ", not "
+                + value.__class__.__name__
+            )
+
+        # If the property doesn't exist yet, create a new empty list to receive the
+        # item.
+        self._properties[key] = self._properties.get(key, [])
+
+        # Set up the ownership link.
+        if is_strong:
+            value.parent = self
 
-    # Store the item.
-    self._properties[key].append(value)
+        # Store the item.
+        self._properties[key].append(value)
 
-  def VerifyHasRequiredProperties(self):
-    """Ensure that all properties identified as required by the schema are
+    def VerifyHasRequiredProperties(self):
+        """Ensure that all properties identified as required by the schema are
     set.
     """
 
-    # TODO(mark): A stronger verification mechanism is needed.  Some
-    # subclasses need to perform validation beyond what the schema can enforce.
-    for property, attributes in self._schema.items():
-      (is_list, property_type, is_strong, is_required) = attributes[0:4]
-      if is_required and not property in self._properties:
-        raise KeyError(self.__class__.__name__ + ' requires ' + property)
+        # TODO(mark): A stronger verification mechanism is needed.  Some
+        # subclasses need to perform validation beyond what the schema can enforce.
+        for property, attributes in self._schema.items():
+            (is_list, property_type, is_strong, is_required) = attributes[0:4]
+            if is_required and property not in self._properties:
+                raise KeyError(self.__class__.__name__ + " requires " + property)
 
-  def _SetDefaultsFromSchema(self):
-    """Assign object default values according to the schema.  This will not
+    def _SetDefaultsFromSchema(self):
+        """Assign object default values according to the schema.  This will not
     overwrite properties that have already been set."""
 
-    defaults = {}
-    for property, attributes in self._schema.items():
-      (is_list, property_type, is_strong, is_required) = attributes[0:4]
-      if is_required and len(attributes) >= 5 and \
-          not property in self._properties:
-        default = attributes[4]
+        defaults = {}
+        for property, attributes in self._schema.items():
+            (is_list, property_type, is_strong, is_required) = attributes[0:4]
+            if (
+                is_required
+                and len(attributes) >= 5
+                and property not in self._properties
+            ):
+                default = attributes[4]
 
-        defaults[property] = default
+                defaults[property] = default
 
-    if len(defaults) > 0:
-      # Use do_copy=True so that each new object gets its own copy of strong
-      # objects, lists, and dicts.
-      self.UpdateProperties(defaults, do_copy=True)
+        if len(defaults) > 0:
+            # Use do_copy=True so that each new object gets its own copy of strong
+            # objects, lists, and dicts.
+            self.UpdateProperties(defaults, do_copy=True)
 
 
 class XCHierarchicalElement(XCObject):
-  """Abstract base for PBXGroup and PBXFileReference.  Not represented in a
+    """Abstract base for PBXGroup and PBXFileReference.  Not represented in a
   project file."""
 
-  # TODO(mark): Do name and path belong here?  Probably so.
-  # If path is set and name is not, name may have a default value.  Name will
-  # be set to the basename of path, if the basename of path is different from
-  # the full value of path.  If path is already just a leaf name, name will
-  # not be set.
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'comments':       [0, str, 0, 0],
-    'fileEncoding':   [0, str, 0, 0],
-    'includeInIndex': [0, int, 0, 0],
-    'indentWidth':    [0, int, 0, 0],
-    'lineEnding':     [0, int, 0, 0],
-    'sourceTree':     [0, str, 0, 1, '<group>'],
-    'tabWidth':       [0, int, 0, 0],
-    'usesTabs':       [0, int, 0, 0],
-    'wrapsLines':     [0, int, 0, 0],
-  })
-
-  def __init__(self, properties=None, id=None, parent=None):
-    # super
-    XCObject.__init__(self, properties, id, parent)
-    if 'path' in self._properties and not 'name' in self._properties:
-      path = self._properties['path']
-      name = posixpath.basename(path)
-      if name != '' and path != name:
-        self.SetProperty('name', name)
-
-    if 'path' in self._properties and \
-        (not 'sourceTree' in self._properties or \
-         self._properties['sourceTree'] == '<group>'):
-      # If the pathname begins with an Xcode variable like "$(SDKROOT)/", take
-      # the variable out and make the path be relative to that variable by
-      # assigning the variable name as the sourceTree.
-      (source_tree, path) = SourceTreeAndPathFromPath(self._properties['path'])
-      if source_tree != None:
-        self._properties['sourceTree'] = source_tree
-      if path != None:
-        self._properties['path'] = path
-      if source_tree != None and path is None and \
-         not 'name' in self._properties:
-        # The path was of the form "$(SDKROOT)" with no path following it.
-        # This object is now relative to that variable, so it has no path
-        # attribute of its own.  It does, however, keep a name.
-        del self._properties['path']
-        self._properties['name'] = source_tree
-
-  def Name(self):
-    if 'name' in self._properties:
-      return self._properties['name']
-    elif 'path' in self._properties:
-      return self._properties['path']
-    else:
-      # This happens in the case of the root PBXGroup.
-      return None
+    # TODO(mark): Do name and path belong here?  Probably so.
+    # If path is set and name is not, name may have a default value.  Name will
+    # be set to the basename of path, if the basename of path is different from
+    # the full value of path.  If path is already just a leaf name, name will
+    # not be set.
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "comments": [0, str, 0, 0],
+            "fileEncoding": [0, str, 0, 0],
+            "includeInIndex": [0, int, 0, 0],
+            "indentWidth": [0, int, 0, 0],
+            "lineEnding": [0, int, 0, 0],
+            "sourceTree": [0, str, 0, 1, "<group>"],
+            "tabWidth": [0, int, 0, 0],
+            "usesTabs": [0, int, 0, 0],
+            "wrapsLines": [0, int, 0, 0],
+        }
+    )
+
+    def __init__(self, properties=None, id=None, parent=None):
+        # super
+        XCObject.__init__(self, properties, id, parent)
+        if "path" in self._properties and "name" not in self._properties:
+            path = self._properties["path"]
+            name = posixpath.basename(path)
+            if name != "" and path != name:
+                self.SetProperty("name", name)
+
+        if "path" in self._properties and (
+            "sourceTree" not in self._properties
+            or self._properties["sourceTree"] == "<group>"
+        ):
+            # If the pathname begins with an Xcode variable like "$(SDKROOT)/", take
+            # the variable out and make the path be relative to that variable by
+            # assigning the variable name as the sourceTree.
+            (source_tree, path) = SourceTreeAndPathFromPath(self._properties["path"])
+            if source_tree is not None:
+                self._properties["sourceTree"] = source_tree
+            if path is not None:
+                self._properties["path"] = path
+            if (
+                source_tree is not None
+                and path is None
+                and "name" not in self._properties
+            ):
+                # The path was of the form "$(SDKROOT)" with no path following it.
+                # This object is now relative to that variable, so it has no path
+                # attribute of its own.  It does, however, keep a name.
+                del self._properties["path"]
+                self._properties["name"] = source_tree
+
+    def Name(self):
+        if "name" in self._properties:
+            return self._properties["name"]
+        elif "path" in self._properties:
+            return self._properties["path"]
+        else:
+            # This happens in the case of the root PBXGroup.
+            return None
 
-  def Hashables(self):
-    """Custom hashables for XCHierarchicalElements.
+    def Hashables(self):
+        """Custom hashables for XCHierarchicalElements.
 
     XCHierarchicalElements are special.  Generally, their hashes shouldn't
     change if the paths don't change.  The normal XCObject implementation of
@@ -968,128 +1031,134 @@ class XCHierarchicalElement(XCObject):
     is not considered a problem because there can be only one main group.
     """
 
-    if self == self.PBXProjectAncestor()._properties['mainGroup']:
-      # super
-      return XCObject.Hashables(self)
-
-    hashables = []
-
-    # Put the name in first, ensuring that if TakeOverOnlyChild collapses
-    # children into a top-level group like "Source", the name always goes
-    # into the list of hashables without interfering with path components.
-    if 'name' in self._properties:
-      # Make it less likely for people to manipulate hashes by following the
-      # pattern of always pushing an object type value onto the list first.
-      hashables.append(self.__class__.__name__ + '.name')
-      hashables.append(self._properties['name'])
-
-    # NOTE: This still has the problem that if an absolute path is encountered,
-    # including paths with a sourceTree, they'll still inherit their parents'
-    # hashables, even though the paths aren't relative to their parents.  This
-    # is not expected to be much of a problem in practice.
-    path = self.PathFromSourceTreeAndPath()
-    if path != None:
-      components = path.split(posixpath.sep)
-      for component in components:
-        hashables.append(self.__class__.__name__ + '.path')
-        hashables.append(component)
-
-    hashables.extend(self._hashables)
-
-    return hashables
-
-  def Compare(self, other):
-    # Allow comparison of these types.  PBXGroup has the highest sort rank;
-    # PBXVariantGroup is treated as equal to PBXFileReference.
-    valid_class_types = {
-      PBXFileReference: 'file',
-      PBXGroup:         'group',
-      PBXVariantGroup:  'file',
-    }
-    self_type = valid_class_types[self.__class__]
-    other_type = valid_class_types[other.__class__]
-
-    if self_type == other_type:
-      # If the two objects are of the same sort rank, compare their names.
-      return cmp(self.Name(), other.Name())
-
-    # Otherwise, sort groups before everything else.
-    if self_type == 'group':
-      return -1
-    return 1
-
-  def CompareRootGroup(self, other):
-    # This function should be used only to compare direct children of the
-    # containing PBXProject's mainGroup.  These groups should appear in the
-    # listed order.
-    # TODO(mark): "Build" is used by gyp.generator.xcode, perhaps the
-    # generator should have a way of influencing this list rather than having
-    # to hardcode for the generator here.
-    order = ['Source', 'Intermediates', 'Projects', 'Frameworks', 'Products',
-             'Build']
-
-    # If the groups aren't in the listed order, do a name comparison.
-    # Otherwise, groups in the listed order should come before those that
-    # aren't.
-    self_name = self.Name()
-    other_name = other.Name()
-    self_in = isinstance(self, PBXGroup) and self_name in order
-    other_in = isinstance(self, PBXGroup) and other_name in order
-    if not self_in and not other_in:
-      return self.Compare(other)
-    if self_name in order and not other_name in order:
-      return -1
-    if other_name in order and not self_name in order:
-      return 1
-
-    # If both groups are in the listed order, go by the defined order.
-    self_index = order.index(self_name)
-    other_index = order.index(other_name)
-    if self_index < other_index:
-      return -1
-    if self_index > other_index:
-      return 1
-    return 0
-
-  def PathFromSourceTreeAndPath(self):
-    # Turn the object's sourceTree and path properties into a single flat
-    # string of a form comparable to the path parameter.  If there's a
-    # sourceTree property other than "<group>", wrap it in $(...) for the
-    # comparison.
-    components = []
-    if self._properties['sourceTree'] != '<group>':
-      components.append('$(' + self._properties['sourceTree'] + ')')
-    if 'path' in self._properties:
-      components.append(self._properties['path'])
-
-    if len(components) > 0:
-      return posixpath.join(*components)
-
-    return None
-
-  def FullPath(self):
-    # Returns a full path to self relative to the project file, or relative
-    # to some other source tree.  Start with self, and walk up the chain of
-    # parents prepending their paths, if any, until no more parents are
-    # available (project-relative path) or until a path relative to some
-    # source tree is found.
-    xche = self
-    path = None
-    while isinstance(xche, XCHierarchicalElement) and \
-          (path is None or \
-           (not path.startswith('/') and not path.startswith('$'))):
-      this_path = xche.PathFromSourceTreeAndPath()
-      if this_path != None and path != None:
-        path = posixpath.join(this_path, path)
-      elif this_path != None:
-        path = this_path
-      xche = xche.parent
-
-    return path
+        if self == self.PBXProjectAncestor()._properties["mainGroup"]:
+            # super
+            return XCObject.Hashables(self)
+
+        hashables = []
+
+        # Put the name in first, ensuring that if TakeOverOnlyChild collapses
+        # children into a top-level group like "Source", the name always goes
+        # into the list of hashables without interfering with path components.
+        if "name" in self._properties:
+            # Make it less likely for people to manipulate hashes by following the
+            # pattern of always pushing an object type value onto the list first.
+            hashables.append(self.__class__.__name__ + ".name")
+            hashables.append(self._properties["name"])
+
+        # NOTE: This still has the problem that if an absolute path is encountered,
+        # including paths with a sourceTree, they'll still inherit their parents'
+        # hashables, even though the paths aren't relative to their parents.  This
+        # is not expected to be much of a problem in practice.
+        path = self.PathFromSourceTreeAndPath()
+        if path is not None:
+            components = path.split(posixpath.sep)
+            for component in components:
+                hashables.append(self.__class__.__name__ + ".path")
+                hashables.append(component)
+
+        hashables.extend(self._hashables)
+
+        return hashables
+
+    def Compare(self, other):
+        # Allow comparison of these types.  PBXGroup has the highest sort rank;
+        # PBXVariantGroup is treated as equal to PBXFileReference.
+        valid_class_types = {
+            PBXFileReference: "file",
+            PBXGroup: "group",
+            PBXVariantGroup: "file",
+        }
+        self_type = valid_class_types[self.__class__]
+        other_type = valid_class_types[other.__class__]
+
+        if self_type == other_type:
+            # If the two objects are of the same sort rank, compare their names.
+            return cmp(self.Name(), other.Name())
+
+        # Otherwise, sort groups before everything else.
+        if self_type == "group":
+            return -1
+        return 1
+
+    def CompareRootGroup(self, other):
+        # This function should be used only to compare direct children of the
+        # containing PBXProject's mainGroup.  These groups should appear in the
+        # listed order.
+        # TODO(mark): "Build" is used by gyp.generator.xcode, perhaps the
+        # generator should have a way of influencing this list rather than having
+        # to hardcode for the generator here.
+        order = [
+            "Source",
+            "Intermediates",
+            "Projects",
+            "Frameworks",
+            "Products",
+            "Build",
+        ]
+
+        # If the groups aren't in the listed order, do a name comparison.
+        # Otherwise, groups in the listed order should come before those that
+        # aren't.
+        self_name = self.Name()
+        other_name = other.Name()
+        self_in = isinstance(self, PBXGroup) and self_name in order
+        other_in = isinstance(self, PBXGroup) and other_name in order
+        if not self_in and not other_in:
+            return self.Compare(other)
+        if self_name in order and other_name not in order:
+            return -1
+        if other_name in order and self_name not in order:
+            return 1
+
+        # If both groups are in the listed order, go by the defined order.
+        self_index = order.index(self_name)
+        other_index = order.index(other_name)
+        if self_index < other_index:
+            return -1
+        if self_index > other_index:
+            return 1
+        return 0
+
+    def PathFromSourceTreeAndPath(self):
+        # Turn the object's sourceTree and path properties into a single flat
+        # string of a form comparable to the path parameter.  If there's a
+        # sourceTree property other than "<group>", wrap it in $(...) for the
+        # comparison.
+        components = []
+        if self._properties["sourceTree"] != "<group>":
+            components.append("$(" + self._properties["sourceTree"] + ")")
+        if "path" in self._properties:
+            components.append(self._properties["path"])
+
+        if len(components) > 0:
+            return posixpath.join(*components)
+
+        return None
+
+    def FullPath(self):
+        # Returns a full path to self relative to the project file, or relative
+        # to some other source tree.  Start with self, and walk up the chain of
+        # parents prepending their paths, if any, until no more parents are
+        # available (project-relative path) or until a path relative to some
+        # source tree is found.
+        xche = self
+        path = None
+        while isinstance(xche, XCHierarchicalElement) and (
+            path is None or (not path.startswith("/") and not path.startswith("$"))
+        ):
+            this_path = xche.PathFromSourceTreeAndPath()
+            if this_path is not None and path is not None:
+                path = posixpath.join(this_path, path)
+            elif this_path is not None:
+                path = this_path
+            xche = xche.parent
+
+        return path
 
 
 class PBXGroup(XCHierarchicalElement):
-  """
+    """
   Attributes:
     _children_by_path: Maps pathnames of children of this PBXGroup to the
       actual child XCHierarchicalElement objects.
@@ -1097,116 +1166,122 @@ class PBXGroup(XCHierarchicalElement):
       PBXVariantGroup children to the actual child PBXVariantGroup objects.
   """
 
-  _schema = XCHierarchicalElement._schema.copy()
-  _schema.update({
-    'children': [1, XCHierarchicalElement, 1, 1, []],
-    'name':     [0, str,                   0, 0],
-    'path':     [0, str,                   0, 0],
-  })
-
-  def __init__(self, properties=None, id=None, parent=None):
-    # super
-    XCHierarchicalElement.__init__(self, properties, id, parent)
-    self._children_by_path = {}
-    self._variant_children_by_name_and_path = {}
-    for child in self._properties.get('children', []):
-      self._AddChildToDicts(child)
-
-  def Hashables(self):
-    # super
-    hashables = XCHierarchicalElement.Hashables(self)
-
-    # It is not sufficient to just rely on name and parent to build a unique
-    # hashable : a node could have two child PBXGroup sharing a common name.
-    # To add entropy the hashable is enhanced with the names of all its
-    # children.
-    for child in self._properties.get('children', []):
-      child_name = child.Name()
-      if child_name != None:
-        hashables.append(child_name)
-
-    return hashables
-
-  def HashablesForChild(self):
-    # To avoid a circular reference the hashables used to compute a child id do
-    # not include the child names.
-    return XCHierarchicalElement.Hashables(self)
-
-  def _AddChildToDicts(self, child):
-    # Sets up this PBXGroup object's dicts to reference the child properly.
-    child_path = child.PathFromSourceTreeAndPath()
-    if child_path:
-      if child_path in self._children_by_path:
-        raise ValueError('Found multiple children with path ' + child_path)
-      self._children_by_path[child_path] = child
-
-    if isinstance(child, PBXVariantGroup):
-      child_name = child._properties.get('name', None)
-      key = (child_name, child_path)
-      if key in self._variant_children_by_name_and_path:
-        raise ValueError('Found multiple PBXVariantGroup children with ' + \
-                         'name ' + str(child_name) + ' and path ' + \
-                         str(child_path))
-      self._variant_children_by_name_and_path[key] = child
-
-  def AppendChild(self, child):
-    # Callers should use this instead of calling
-    # AppendProperty('children', child) directly because this function
-    # maintains the group's dicts.
-    self.AppendProperty('children', child)
-    self._AddChildToDicts(child)
-
-  def GetChildByName(self, name):
-    # This is not currently optimized with a dict as GetChildByPath is because
-    # it has few callers.  Most callers probably want GetChildByPath.  This
-    # function is only useful to get children that have names but no paths,
-    # which is rare.  The children of the main group ("Source", "Products",
-    # etc.) is pretty much the only case where this likely to come up.
-    #
-    # TODO(mark): Maybe this should raise an error if more than one child is
-    # present with the same name.
-    if not 'children' in self._properties:
-      return None
+    _schema = XCHierarchicalElement._schema.copy()
+    _schema.update(
+        {
+            "children": [1, XCHierarchicalElement, 1, 1, []],
+            "name": [0, str, 0, 0],
+            "path": [0, str, 0, 0],
+        }
+    )
+
+    def __init__(self, properties=None, id=None, parent=None):
+        # super
+        XCHierarchicalElement.__init__(self, properties, id, parent)
+        self._children_by_path = {}
+        self._variant_children_by_name_and_path = {}
+        for child in self._properties.get("children", []):
+            self._AddChildToDicts(child)
+
+    def Hashables(self):
+        # super
+        hashables = XCHierarchicalElement.Hashables(self)
+
+        # It is not sufficient to just rely on name and parent to build a unique
+        # hashable : a node could have two child PBXGroup sharing a common name.
+        # To add entropy the hashable is enhanced with the names of all its
+        # children.
+        for child in self._properties.get("children", []):
+            child_name = child.Name()
+            if child_name is not None:
+                hashables.append(child_name)
+
+        return hashables
+
+    def HashablesForChild(self):
+        # To avoid a circular reference the hashables used to compute a child id do
+        # not include the child names.
+        return XCHierarchicalElement.Hashables(self)
+
+    def _AddChildToDicts(self, child):
+        # Sets up this PBXGroup object's dicts to reference the child properly.
+        child_path = child.PathFromSourceTreeAndPath()
+        if child_path:
+            if child_path in self._children_by_path:
+                raise ValueError("Found multiple children with path " + child_path)
+            self._children_by_path[child_path] = child
+
+        if isinstance(child, PBXVariantGroup):
+            child_name = child._properties.get("name", None)
+            key = (child_name, child_path)
+            if key in self._variant_children_by_name_and_path:
+                raise ValueError(
+                    "Found multiple PBXVariantGroup children with "
+                    + "name "
+                    + str(child_name)
+                    + " and path "
+                    + str(child_path)
+                )
+            self._variant_children_by_name_and_path[key] = child
+
+    def AppendChild(self, child):
+        # Callers should use this instead of calling
+        # AppendProperty('children', child) directly because this function
+        # maintains the group's dicts.
+        self.AppendProperty("children", child)
+        self._AddChildToDicts(child)
+
+    def GetChildByName(self, name):
+        # This is not currently optimized with a dict as GetChildByPath is because
+        # it has few callers.  Most callers probably want GetChildByPath.  This
+        # function is only useful to get children that have names but no paths,
+        # which is rare.  The children of the main group ("Source", "Products",
+        # etc.) is pretty much the only case where this likely to come up.
+        #
+        # TODO(mark): Maybe this should raise an error if more than one child is
+        # present with the same name.
+        if "children" not in self._properties:
+            return None
 
-    for child in self._properties['children']:
-      if child.Name() == name:
-        return child
+        for child in self._properties["children"]:
+            if child.Name() == name:
+                return child
 
-    return None
+        return None
 
-  def GetChildByPath(self, path):
-    if not path:
-      return None
+    def GetChildByPath(self, path):
+        if not path:
+            return None
 
-    if path in self._children_by_path:
-      return self._children_by_path[path]
+        if path in self._children_by_path:
+            return self._children_by_path[path]
 
-    return None
+        return None
 
-  def GetChildByRemoteObject(self, remote_object):
-    # This method is a little bit esoteric.  Given a remote_object, which
-    # should be a PBXFileReference in another project file, this method will
-    # return this group's PBXReferenceProxy object serving as a local proxy
-    # for the remote PBXFileReference.
-    #
-    # This function might benefit from a dict optimization as GetChildByPath
-    # for some workloads, but profiling shows that it's not currently a
-    # problem.
-    if not 'children' in self._properties:
-      return None
+    def GetChildByRemoteObject(self, remote_object):
+        # This method is a little bit esoteric.  Given a remote_object, which
+        # should be a PBXFileReference in another project file, this method will
+        # return this group's PBXReferenceProxy object serving as a local proxy
+        # for the remote PBXFileReference.
+        #
+        # This function might benefit from a dict optimization as GetChildByPath
+        # for some workloads, but profiling shows that it's not currently a
+        # problem.
+        if "children" not in self._properties:
+            return None
 
-    for child in self._properties['children']:
-      if not isinstance(child, PBXReferenceProxy):
-        continue
+        for child in self._properties["children"]:
+            if not isinstance(child, PBXReferenceProxy):
+                continue
 
-      container_proxy = child._properties['remoteRef']
-      if container_proxy._properties['remoteGlobalIDString'] == remote_object:
-        return child
+            container_proxy = child._properties["remoteRef"]
+            if container_proxy._properties["remoteGlobalIDString"] == remote_object:
+                return child
 
-    return None
+        return None
 
-  def AddOrGetFileByPath(self, path, hierarchical):
-    """Returns an existing or new file reference corresponding to path.
+    def AddOrGetFileByPath(self, path, hierarchical):
+        """Returns an existing or new file reference corresponding to path.
 
     If hierarchical is True, this method will create or use the necessary
     hierarchical group structure corresponding to path.  Otherwise, it will
@@ -1223,83 +1298,88 @@ class PBXGroup(XCHierarchicalElement):
     all other paths, a "normal" PBXFileReference will be returned.
     """
 
-    # Adding or getting a directory?  Directories end with a trailing slash.
-    is_dir = False
-    if path.endswith('/'):
-      is_dir = True
-    path = posixpath.normpath(path)
-    if is_dir:
-      path = path + '/'
-
-    # Adding or getting a variant?  Variants are files inside directories
-    # with an ".lproj" extension.  Xcode uses variants for localization.  For
-    # a variant path/to/Language.lproj/MainMenu.nib, put a variant group named
-    # MainMenu.nib inside path/to, and give it a variant named Language.  In
-    # this example, grandparent would be set to path/to and parent_root would
-    # be set to Language.
-    variant_name = None
-    parent = posixpath.dirname(path)
-    grandparent = posixpath.dirname(parent)
-    parent_basename = posixpath.basename(parent)
-    (parent_root, parent_ext) = posixpath.splitext(parent_basename)
-    if parent_ext == '.lproj':
-      variant_name = parent_root
-    if grandparent == '':
-      grandparent = None
-
-    # Putting a directory inside a variant group is not currently supported.
-    assert not is_dir or variant_name is None
-
-    path_split = path.split(posixpath.sep)
-    if len(path_split) == 1 or \
-       ((is_dir or variant_name != None) and len(path_split) == 2) or \
-       not hierarchical:
-      # The PBXFileReference or PBXVariantGroup will be added to or gotten from
-      # this PBXGroup, no recursion necessary.
-      if variant_name is None:
-        # Add or get a PBXFileReference.
-        file_ref = self.GetChildByPath(path)
-        if file_ref != None:
-          assert file_ref.__class__ == PBXFileReference
+        # Adding or getting a directory?  Directories end with a trailing slash.
+        is_dir = False
+        if path.endswith("/"):
+            is_dir = True
+        path = posixpath.normpath(path)
+        if is_dir:
+            path = path + "/"
+
+        # Adding or getting a variant?  Variants are files inside directories
+        # with an ".lproj" extension.  Xcode uses variants for localization.  For
+        # a variant path/to/Language.lproj/MainMenu.nib, put a variant group named
+        # MainMenu.nib inside path/to, and give it a variant named Language.  In
+        # this example, grandparent would be set to path/to and parent_root would
+        # be set to Language.
+        variant_name = None
+        parent = posixpath.dirname(path)
+        grandparent = posixpath.dirname(parent)
+        parent_basename = posixpath.basename(parent)
+        (parent_root, parent_ext) = posixpath.splitext(parent_basename)
+        if parent_ext == ".lproj":
+            variant_name = parent_root
+        if grandparent == "":
+            grandparent = None
+
+        # Putting a directory inside a variant group is not currently supported.
+        assert not is_dir or variant_name is None
+
+        path_split = path.split(posixpath.sep)
+        if (
+            len(path_split) == 1
+            or ((is_dir or variant_name is not None) and len(path_split) == 2)
+            or not hierarchical
+        ):
+            # The PBXFileReference or PBXVariantGroup will be added to or gotten from
+            # this PBXGroup, no recursion necessary.
+            if variant_name is None:
+                # Add or get a PBXFileReference.
+                file_ref = self.GetChildByPath(path)
+                if file_ref is not None:
+                    assert file_ref.__class__ == PBXFileReference
+                else:
+                    file_ref = PBXFileReference({"path": path})
+                    self.AppendChild(file_ref)
+            else:
+                # Add or get a PBXVariantGroup.  The variant group name is the same
+                # as the basename (MainMenu.nib in the example above).  grandparent
+                # specifies the path to the variant group itself, and path_split[-2:]
+                # is the path of the specific variant relative to its group.
+                variant_group_name = posixpath.basename(path)
+                variant_group_ref = self.AddOrGetVariantGroupByNameAndPath(
+                    variant_group_name, grandparent
+                )
+                variant_path = posixpath.sep.join(path_split[-2:])
+                variant_ref = variant_group_ref.GetChildByPath(variant_path)
+                if variant_ref is not None:
+                    assert variant_ref.__class__ == PBXFileReference
+                else:
+                    variant_ref = PBXFileReference(
+                        {"name": variant_name, "path": variant_path}
+                    )
+                    variant_group_ref.AppendChild(variant_ref)
+                # The caller is interested in the variant group, not the specific
+                # variant file.
+                file_ref = variant_group_ref
+            return file_ref
         else:
-          file_ref = PBXFileReference({'path': path})
-          self.AppendChild(file_ref)
-      else:
-        # Add or get a PBXVariantGroup.  The variant group name is the same
-        # as the basename (MainMenu.nib in the example above).  grandparent
-        # specifies the path to the variant group itself, and path_split[-2:]
-        # is the path of the specific variant relative to its group.
-        variant_group_name = posixpath.basename(path)
-        variant_group_ref = self.AddOrGetVariantGroupByNameAndPath(
-            variant_group_name, grandparent)
-        variant_path = posixpath.sep.join(path_split[-2:])
-        variant_ref = variant_group_ref.GetChildByPath(variant_path)
-        if variant_ref != None:
-          assert variant_ref.__class__ == PBXFileReference
-        else:
-          variant_ref = PBXFileReference({'name': variant_name,
-                                          'path': variant_path})
-          variant_group_ref.AppendChild(variant_ref)
-        # The caller is interested in the variant group, not the specific
-        # variant file.
-        file_ref = variant_group_ref
-      return file_ref
-    else:
-      # Hierarchical recursion.  Add or get a PBXGroup corresponding to the
-      # outermost path component, and then recurse into it, chopping off that
-      # path component.
-      next_dir = path_split[0]
-      group_ref = self.GetChildByPath(next_dir)
-      if group_ref != None:
-        assert group_ref.__class__ == PBXGroup
-      else:
-        group_ref = PBXGroup({'path': next_dir})
-        self.AppendChild(group_ref)
-      return group_ref.AddOrGetFileByPath(posixpath.sep.join(path_split[1:]),
-                                          hierarchical)
-
-  def AddOrGetVariantGroupByNameAndPath(self, name, path):
-    """Returns an existing or new PBXVariantGroup for name and path.
+            # Hierarchical recursion.  Add or get a PBXGroup corresponding to the
+            # outermost path component, and then recurse into it, chopping off that
+            # path component.
+            next_dir = path_split[0]
+            group_ref = self.GetChildByPath(next_dir)
+            if group_ref is not None:
+                assert group_ref.__class__ == PBXGroup
+            else:
+                group_ref = PBXGroup({"path": next_dir})
+                self.AppendChild(group_ref)
+            return group_ref.AddOrGetFileByPath(
+                posixpath.sep.join(path_split[1:]), hierarchical
+            )
+
+    def AddOrGetVariantGroupByNameAndPath(self, name, path):
+        """Returns an existing or new PBXVariantGroup for name and path.
 
     If a PBXVariantGroup identified by the name and path arguments is already
     present as a child of this object, it is returned.  Otherwise, a new
@@ -1311,22 +1391,22 @@ class PBXGroup(XCHierarchicalElement):
     passed to it.
     """
 
-    key = (name, path)
-    if key in self._variant_children_by_name_and_path:
-      variant_group_ref = self._variant_children_by_name_and_path[key]
-      assert variant_group_ref.__class__ == PBXVariantGroup
-      return variant_group_ref
+        key = (name, path)
+        if key in self._variant_children_by_name_and_path:
+            variant_group_ref = self._variant_children_by_name_and_path[key]
+            assert variant_group_ref.__class__ == PBXVariantGroup
+            return variant_group_ref
 
-    variant_group_properties = {'name': name}
-    if path != None:
-      variant_group_properties['path'] = path
-    variant_group_ref = PBXVariantGroup(variant_group_properties)
-    self.AppendChild(variant_group_ref)
+        variant_group_properties = {"name": name}
+        if path is not None:
+            variant_group_properties["path"] = path
+        variant_group_ref = PBXVariantGroup(variant_group_properties)
+        self.AppendChild(variant_group_ref)
 
-    return variant_group_ref
+        return variant_group_ref
 
-  def TakeOverOnlyChild(self, recurse=False):
-    """If this PBXGroup has only one child and it's also a PBXGroup, take
+    def TakeOverOnlyChild(self, recurse=False):
+        """If this PBXGroup has only one child and it's also a PBXGroup, take
     it over by making all of its children this object's children.
 
     This function will continue to take over only children when those children
@@ -1341,210 +1421,226 @@ class PBXGroup(XCHierarchicalElement):
     a group for a/b/c containing a group for d3/e.
     """
 
-    # At this stage, check that child class types are PBXGroup exactly,
-    # instead of using isinstance.  The only subclass of PBXGroup,
-    # PBXVariantGroup, should not participate in reparenting in the same way:
-    # reparenting by merging different object types would be wrong.
-    while len(self._properties['children']) == 1 and \
-          self._properties['children'][0].__class__ == PBXGroup:
-      # Loop to take over the innermost only-child group possible.
-
-      child = self._properties['children'][0]
-
-      # Assume the child's properties, including its children.  Save a copy
-      # of this object's old properties, because they'll still be needed.
-      # This object retains its existing id and parent attributes.
-      old_properties = self._properties
-      self._properties = child._properties
-      self._children_by_path = child._children_by_path
-
-      if not 'sourceTree' in self._properties or \
-         self._properties['sourceTree'] == '<group>':
-        # The child was relative to its parent.  Fix up the path.  Note that
-        # children with a sourceTree other than "<group>" are not relative to
-        # their parents, so no path fix-up is needed in that case.
-        if 'path' in old_properties:
-          if 'path' in self._properties:
-            # Both the original parent and child have paths set.
-            self._properties['path'] = posixpath.join(old_properties['path'],
-                                                      self._properties['path'])
-          else:
-            # Only the original parent has a path, use it.
-            self._properties['path'] = old_properties['path']
-        if 'sourceTree' in old_properties:
-          # The original parent had a sourceTree set, use it.
-          self._properties['sourceTree'] = old_properties['sourceTree']
-
-      # If the original parent had a name set, keep using it.  If the original
-      # parent didn't have a name but the child did, let the child's name
-      # live on.  If the name attribute seems unnecessary now, get rid of it.
-      if 'name' in old_properties and old_properties['name'] != None and \
-         old_properties['name'] != self.Name():
-        self._properties['name'] = old_properties['name']
-      if 'name' in self._properties and 'path' in self._properties and \
-         self._properties['name'] == self._properties['path']:
-        del self._properties['name']
-
-      # Notify all children of their new parent.
-      for child in self._properties['children']:
-        child.parent = self
-
-    # If asked to recurse, recurse.
-    if recurse:
-      for child in self._properties['children']:
-        if child.__class__ == PBXGroup:
-          child.TakeOverOnlyChild(recurse)
-
-  def SortGroup(self):
-    self._properties['children'] = \
-        sorted(self._properties['children'], cmp=lambda x,y: x.Compare(y))
-
-    # Recurse.
-    for child in self._properties['children']:
-      if isinstance(child, PBXGroup):
-        child.SortGroup()
+        # At this stage, check that child class types are PBXGroup exactly,
+        # instead of using isinstance.  The only subclass of PBXGroup,
+        # PBXVariantGroup, should not participate in reparenting in the same way:
+        # reparenting by merging different object types would be wrong.
+        while (
+            len(self._properties["children"]) == 1
+            and self._properties["children"][0].__class__ == PBXGroup
+        ):
+            # Loop to take over the innermost only-child group possible.
+
+            child = self._properties["children"][0]
+
+            # Assume the child's properties, including its children.  Save a copy
+            # of this object's old properties, because they'll still be needed.
+            # This object retains its existing id and parent attributes.
+            old_properties = self._properties
+            self._properties = child._properties
+            self._children_by_path = child._children_by_path
+
+            if (
+                "sourceTree" not in self._properties
+                or self._properties["sourceTree"] == "<group>"
+            ):
+                # The child was relative to its parent.  Fix up the path.  Note that
+                # children with a sourceTree other than "<group>" are not relative to
+                # their parents, so no path fix-up is needed in that case.
+                if "path" in old_properties:
+                    if "path" in self._properties:
+                        # Both the original parent and child have paths set.
+                        self._properties["path"] = posixpath.join(
+                            old_properties["path"], self._properties["path"]
+                        )
+                    else:
+                        # Only the original parent has a path, use it.
+                        self._properties["path"] = old_properties["path"]
+                if "sourceTree" in old_properties:
+                    # The original parent had a sourceTree set, use it.
+                    self._properties["sourceTree"] = old_properties["sourceTree"]
+
+            # If the original parent had a name set, keep using it.  If the original
+            # parent didn't have a name but the child did, let the child's name
+            # live on.  If the name attribute seems unnecessary now, get rid of it.
+            if "name" in old_properties and old_properties["name"] not in (
+                None,
+                self.Name(),
+            ):
+                self._properties["name"] = old_properties["name"]
+            if (
+                "name" in self._properties
+                and "path" in self._properties
+                and self._properties["name"] == self._properties["path"]
+            ):
+                del self._properties["name"]
+
+            # Notify all children of their new parent.
+            for child in self._properties["children"]:
+                child.parent = self
+
+        # If asked to recurse, recurse.
+        if recurse:
+            for child in self._properties["children"]:
+                if child.__class__ == PBXGroup:
+                    child.TakeOverOnlyChild(recurse)
+
+    def SortGroup(self):
+        self._properties["children"] = sorted(
+            self._properties["children"], cmp=lambda x, y: x.Compare(y)
+        )
+
+        # Recurse.
+        for child in self._properties["children"]:
+            if isinstance(child, PBXGroup):
+                child.SortGroup()
 
 
 class XCFileLikeElement(XCHierarchicalElement):
-  # Abstract base for objects that can be used as the fileRef property of
-  # PBXBuildFile.
-
-  def PathHashables(self):
-    # A PBXBuildFile that refers to this object will call this method to
-    # obtain additional hashables specific to this XCFileLikeElement.  Don't
-    # just use this object's hashables, they're not specific and unique enough
-    # on their own (without access to the parent hashables.)  Instead, provide
-    # hashables that identify this object by path by getting its hashables as
-    # well as the hashables of ancestor XCHierarchicalElement objects.
-
-    hashables = []
-    xche = self
-    while xche != None and isinstance(xche, XCHierarchicalElement):
-      xche_hashables = xche.Hashables()
-      for index in range(0, len(xche_hashables)):
-        hashables.insert(index, xche_hashables[index])
-      xche = xche.parent
-    return hashables
+    # Abstract base for objects that can be used as the fileRef property of
+    # PBXBuildFile.
+
+    def PathHashables(self):
+        # A PBXBuildFile that refers to this object will call this method to
+        # obtain additional hashables specific to this XCFileLikeElement.  Don't
+        # just use this object's hashables, they're not specific and unique enough
+        # on their own (without access to the parent hashables.)  Instead, provide
+        # hashables that identify this object by path by getting its hashables as
+        # well as the hashables of ancestor XCHierarchicalElement objects.
+
+        hashables = []
+        xche = self
+        while isinstance(xche, XCHierarchicalElement):
+            xche_hashables = xche.Hashables()
+            for index, xche_hashable in enumerate(xche_hashables):
+                hashables.insert(index, xche_hashable)
+            xche = xche.parent
+        return hashables
 
 
 class XCContainerPortal(XCObject):
-  # Abstract base for objects that can be used as the containerPortal property
-  # of PBXContainerItemProxy.
-  pass
+    # Abstract base for objects that can be used as the containerPortal property
+    # of PBXContainerItemProxy.
+    pass
 
 
 class XCRemoteObject(XCObject):
-  # Abstract base for objects that can be used as the remoteGlobalIDString
-  # property of PBXContainerItemProxy.
-  pass
+    # Abstract base for objects that can be used as the remoteGlobalIDString
+    # property of PBXContainerItemProxy.
+    pass
 
 
 class PBXFileReference(XCFileLikeElement, XCContainerPortal, XCRemoteObject):
-  _schema = XCFileLikeElement._schema.copy()
-  _schema.update({
-    'explicitFileType':  [0, str, 0, 0],
-    'lastKnownFileType': [0, str, 0, 0],
-    'name':              [0, str, 0, 0],
-    'path':              [0, str, 0, 1],
-  })
-
-  # Weird output rules for PBXFileReference.
-  _should_print_single_line = True
-  # super
-  _encode_transforms = XCFileLikeElement._alternate_encode_transforms
-
-  def __init__(self, properties=None, id=None, parent=None):
+    _schema = XCFileLikeElement._schema.copy()
+    _schema.update(
+        {
+            "explicitFileType": [0, str, 0, 0],
+            "lastKnownFileType": [0, str, 0, 0],
+            "name": [0, str, 0, 0],
+            "path": [0, str, 0, 1],
+        }
+    )
+
+    # Weird output rules for PBXFileReference.
+    _should_print_single_line = True
     # super
-    XCFileLikeElement.__init__(self, properties, id, parent)
-    if 'path' in self._properties and self._properties['path'].endswith('/'):
-      self._properties['path'] = self._properties['path'][:-1]
-      is_dir = True
-    else:
-      is_dir = False
-
-    if 'path' in self._properties and \
-        not 'lastKnownFileType' in self._properties and \
-        not 'explicitFileType' in self._properties:
-      # TODO(mark): This is the replacement for a replacement for a quick hack.
-      # It is no longer incredibly sucky, but this list needs to be extended.
-      extension_map = {
-        'a':           'archive.ar',
-        'app':         'wrapper.application',
-        'bdic':        'file',
-        'bundle':      'wrapper.cfbundle',
-        'c':           'sourcecode.c.c',
-        'cc':          'sourcecode.cpp.cpp',
-        'cpp':         'sourcecode.cpp.cpp',
-        'css':         'text.css',
-        'cxx':         'sourcecode.cpp.cpp',
-        'dart':        'sourcecode',
-        'dylib':       'compiled.mach-o.dylib',
-        'framework':   'wrapper.framework',
-        'gyp':         'sourcecode',
-        'gypi':        'sourcecode',
-        'h':           'sourcecode.c.h',
-        'hxx':         'sourcecode.cpp.h',
-        'icns':        'image.icns',
-        'java':        'sourcecode.java',
-        'js':          'sourcecode.javascript',
-        'kext':        'wrapper.kext',
-        'm':           'sourcecode.c.objc',
-        'mm':          'sourcecode.cpp.objcpp',
-        'nib':         'wrapper.nib',
-        'o':           'compiled.mach-o.objfile',
-        'pdf':         'image.pdf',
-        'pl':          'text.script.perl',
-        'plist':       'text.plist.xml',
-        'pm':          'text.script.perl',
-        'png':         'image.png',
-        'py':          'text.script.python',
-        'r':           'sourcecode.rez',
-        'rez':         'sourcecode.rez',
-        's':           'sourcecode.asm',
-        'storyboard':  'file.storyboard',
-        'strings':     'text.plist.strings',
-        'swift':       'sourcecode.swift',
-        'ttf':         'file',
-        'xcassets':    'folder.assetcatalog',
-        'xcconfig':    'text.xcconfig',
-        'xcdatamodel': 'wrapper.xcdatamodel',
-        'xcdatamodeld':'wrapper.xcdatamodeld',
-        'xib':         'file.xib',
-        'y':           'sourcecode.yacc',
-      }
-
-      prop_map = {
-        'dart':        'explicitFileType',
-        'gyp':         'explicitFileType',
-        'gypi':        'explicitFileType',
-      }
-
-      if is_dir:
-        file_type = 'folder'
-        prop_name = 'lastKnownFileType'
-      else:
-        basename = posixpath.basename(self._properties['path'])
-        (root, ext) = posixpath.splitext(basename)
-        # Check the map using a lowercase extension.
-        # TODO(mark): Maybe it should try with the original case first and fall
-        # back to lowercase, in case there are any instances where case
-        # matters.  There currently aren't.
-        if ext != '':
-          ext = ext[1:].lower()
-
-        # TODO(mark): "text" is the default value, but "file" is appropriate
-        # for unrecognized files not containing text.  Xcode seems to choose
-        # based on content.
-        file_type = extension_map.get(ext, 'text')
-        prop_name = prop_map.get(ext, 'lastKnownFileType')
-
-      self._properties[prop_name] = file_type
+    _encode_transforms = XCFileLikeElement._alternate_encode_transforms
+
+    def __init__(self, properties=None, id=None, parent=None):
+        # super
+        XCFileLikeElement.__init__(self, properties, id, parent)
+        if "path" in self._properties and self._properties["path"].endswith("/"):
+            self._properties["path"] = self._properties["path"][:-1]
+            is_dir = True
+        else:
+            is_dir = False
+
+        if (
+            "path" in self._properties
+            and "lastKnownFileType" not in self._properties
+            and "explicitFileType" not in self._properties
+        ):
+            # TODO(mark): This is the replacement for a replacement for a quick hack.
+            # It is no longer incredibly sucky, but this list needs to be extended.
+            extension_map = {
+                "a": "archive.ar",
+                "app": "wrapper.application",
+                "bdic": "file",
+                "bundle": "wrapper.cfbundle",
+                "c": "sourcecode.c.c",
+                "cc": "sourcecode.cpp.cpp",
+                "cpp": "sourcecode.cpp.cpp",
+                "css": "text.css",
+                "cxx": "sourcecode.cpp.cpp",
+                "dart": "sourcecode",
+                "dylib": "compiled.mach-o.dylib",
+                "framework": "wrapper.framework",
+                "gyp": "sourcecode",
+                "gypi": "sourcecode",
+                "h": "sourcecode.c.h",
+                "hxx": "sourcecode.cpp.h",
+                "icns": "image.icns",
+                "java": "sourcecode.java",
+                "js": "sourcecode.javascript",
+                "kext": "wrapper.kext",
+                "m": "sourcecode.c.objc",
+                "mm": "sourcecode.cpp.objcpp",
+                "nib": "wrapper.nib",
+                "o": "compiled.mach-o.objfile",
+                "pdf": "image.pdf",
+                "pl": "text.script.perl",
+                "plist": "text.plist.xml",
+                "pm": "text.script.perl",
+                "png": "image.png",
+                "py": "text.script.python",
+                "r": "sourcecode.rez",
+                "rez": "sourcecode.rez",
+                "s": "sourcecode.asm",
+                "storyboard": "file.storyboard",
+                "strings": "text.plist.strings",
+                "swift": "sourcecode.swift",
+                "ttf": "file",
+                "xcassets": "folder.assetcatalog",
+                "xcconfig": "text.xcconfig",
+                "xcdatamodel": "wrapper.xcdatamodel",
+                "xcdatamodeld": "wrapper.xcdatamodeld",
+                "xib": "file.xib",
+                "y": "sourcecode.yacc",
+            }
+
+            prop_map = {
+                "dart": "explicitFileType",
+                "gyp": "explicitFileType",
+                "gypi": "explicitFileType",
+            }
+
+            if is_dir:
+                file_type = "folder"
+                prop_name = "lastKnownFileType"
+            else:
+                basename = posixpath.basename(self._properties["path"])
+                (root, ext) = posixpath.splitext(basename)
+                # Check the map using a lowercase extension.
+                # TODO(mark): Maybe it should try with the original case first and fall
+                # back to lowercase, in case there are any instances where case
+                # matters.  There currently aren't.
+                if ext != "":
+                    ext = ext[1:].lower()
+
+                # TODO(mark): "text" is the default value, but "file" is appropriate
+                # for unrecognized files not containing text.  Xcode seems to choose
+                # based on content.
+                file_type = extension_map.get(ext, "text")
+                prop_name = prop_map.get(ext, "lastKnownFileType")
+
+            self._properties[prop_name] = file_type
 
 
 class PBXVariantGroup(PBXGroup, XCFileLikeElement):
-  """PBXVariantGroup is used by Xcode to represent localizations."""
-  # No additions to the schema relative to PBXGroup.
-  pass
+    """PBXVariantGroup is used by Xcode to represent localizations."""
+
+    # No additions to the schema relative to PBXGroup.
+    pass
 
 
 # PBXReferenceProxy is also an XCFileLikeElement subclass.  It is defined below
@@ -1552,65 +1648,77 @@ class PBXVariantGroup(PBXGroup, XCFileLikeElement):
 
 
 class XCBuildConfiguration(XCObject):
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'baseConfigurationReference': [0, PBXFileReference, 0, 0],
-    'buildSettings':              [0, dict, 0, 1, {}],
-    'name':                       [0, str,  0, 1],
-  })
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "baseConfigurationReference": [0, PBXFileReference, 0, 0],
+            "buildSettings": [0, dict, 0, 1, {}],
+            "name": [0, str, 0, 1],
+        }
+    )
+
+    def HasBuildSetting(self, key):
+        return key in self._properties["buildSettings"]
 
-  def HasBuildSetting(self, key):
-    return key in self._properties['buildSettings']
+    def GetBuildSetting(self, key):
+        return self._properties["buildSettings"][key]
 
-  def GetBuildSetting(self, key):
-    return self._properties['buildSettings'][key]
+    def SetBuildSetting(self, key, value):
+        # TODO(mark): If a list, copy?
+        self._properties["buildSettings"][key] = value
 
-  def SetBuildSetting(self, key, value):
-    # TODO(mark): If a list, copy?
-    self._properties['buildSettings'][key] = value
+    def AppendBuildSetting(self, key, value):
+        if key not in self._properties["buildSettings"]:
+            self._properties["buildSettings"][key] = []
+        self._properties["buildSettings"][key].append(value)
 
-  def AppendBuildSetting(self, key, value):
-    if not key in self._properties['buildSettings']:
-      self._properties['buildSettings'][key] = []
-    self._properties['buildSettings'][key].append(value)
+    def DelBuildSetting(self, key):
+        if key in self._properties["buildSettings"]:
+            del self._properties["buildSettings"][key]
 
-  def DelBuildSetting(self, key):
-    if key in self._properties['buildSettings']:
-      del self._properties['buildSettings'][key]
+    def SetBaseConfiguration(self, value):
+        self._properties["baseConfigurationReference"] = value
 
-  def SetBaseConfiguration(self, value):
-    self._properties['baseConfigurationReference'] = value
 
 class XCConfigurationList(XCObject):
-  # _configs is the default list of configurations.
-  _configs = [ XCBuildConfiguration({'name': 'Debug'}),
-               XCBuildConfiguration({'name': 'Release'}) ]
-
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'buildConfigurations':           [1, XCBuildConfiguration, 1, 1, _configs],
-    'defaultConfigurationIsVisible': [0, int,                  0, 1, 1],
-    'defaultConfigurationName':      [0, str,                  0, 1, 'Release'],
-  })
-
-  def Name(self):
-    return 'Build configuration list for ' + \
-           self.parent.__class__.__name__ + ' "' + self.parent.Name() + '"'
-
-  def ConfigurationNamed(self, name):
-    """Convenience accessor to obtain an XCBuildConfiguration by name."""
-    for configuration in self._properties['buildConfigurations']:
-      if configuration._properties['name'] == name:
-        return configuration
-
-    raise KeyError(name)
-
-  def DefaultConfiguration(self):
-    """Convenience accessor to obtain the default XCBuildConfiguration."""
-    return self.ConfigurationNamed(self._properties['defaultConfigurationName'])
-
-  def HasBuildSetting(self, key):
-    """Determines the state of a build setting in all XCBuildConfiguration
+    # _configs is the default list of configurations.
+    _configs = [
+        XCBuildConfiguration({"name": "Debug"}),
+        XCBuildConfiguration({"name": "Release"}),
+    ]
+
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "buildConfigurations": [1, XCBuildConfiguration, 1, 1, _configs],
+            "defaultConfigurationIsVisible": [0, int, 0, 1, 1],
+            "defaultConfigurationName": [0, str, 0, 1, "Release"],
+        }
+    )
+
+    def Name(self):
+        return (
+            "Build configuration list for "
+            + self.parent.__class__.__name__
+            + ' "'
+            + self.parent.Name()
+            + '"'
+        )
+
+    def ConfigurationNamed(self, name):
+        """Convenience accessor to obtain an XCBuildConfiguration by name."""
+        for configuration in self._properties["buildConfigurations"]:
+            if configuration._properties["name"] == name:
+                return configuration
+
+        raise KeyError(name)
+
+    def DefaultConfiguration(self):
+        """Convenience accessor to obtain the default XCBuildConfiguration."""
+        return self.ConfigurationNamed(self._properties["defaultConfigurationName"])
+
+    def HasBuildSetting(self, key):
+        """Determines the state of a build setting in all XCBuildConfiguration
     child objects.
 
     If all child objects have key in their build settings, and the value is the
@@ -1622,112 +1730,114 @@ class XCConfigurationList(XCObject):
     or if any children have different values for the key, returns -1.
     """
 
-    has = None
-    value = None
-    for configuration in self._properties['buildConfigurations']:
-      configuration_has = configuration.HasBuildSetting(key)
-      if has is None:
-        has = configuration_has
-      elif has != configuration_has:
-        return -1
+        has = None
+        value = None
+        for configuration in self._properties["buildConfigurations"]:
+            configuration_has = configuration.HasBuildSetting(key)
+            if has is None:
+                has = configuration_has
+            elif has != configuration_has:
+                return -1
 
-      if configuration_has:
-        configuration_value = configuration.GetBuildSetting(key)
-        if value is None:
-          value = configuration_value
-        elif value != configuration_value:
-          return -1
+            if configuration_has:
+                configuration_value = configuration.GetBuildSetting(key)
+                if value is None:
+                    value = configuration_value
+                elif value != configuration_value:
+                    return -1
 
-    if not has:
-      return 0
+        if not has:
+            return 0
 
-    return 1
+        return 1
 
-  def GetBuildSetting(self, key):
-    """Gets the build setting for key.
+    def GetBuildSetting(self, key):
+        """Gets the build setting for key.
 
     All child XCConfiguration objects must have the same value set for the
     setting, or a ValueError will be raised.
     """
 
-    # TODO(mark): This is wrong for build settings that are lists.  The list
-    # contents should be compared (and a list copy returned?)
+        # TODO(mark): This is wrong for build settings that are lists.  The list
+        # contents should be compared (and a list copy returned?)
 
-    value = None
-    for configuration in self._properties['buildConfigurations']:
-      configuration_value = configuration.GetBuildSetting(key)
-      if value is None:
-        value = configuration_value
-      else:
-        if value != configuration_value:
-          raise ValueError('Variant values for ' + key)
+        value = None
+        for configuration in self._properties["buildConfigurations"]:
+            configuration_value = configuration.GetBuildSetting(key)
+            if value is None:
+                value = configuration_value
+            else:
+                if value != configuration_value:
+                    raise ValueError("Variant values for " + key)
 
-    return value
+        return value
 
-  def SetBuildSetting(self, key, value):
-    """Sets the build setting for key to value in all child
+    def SetBuildSetting(self, key, value):
+        """Sets the build setting for key to value in all child
     XCBuildConfiguration objects.
     """
 
-    for configuration in self._properties['buildConfigurations']:
-      configuration.SetBuildSetting(key, value)
+        for configuration in self._properties["buildConfigurations"]:
+            configuration.SetBuildSetting(key, value)
 
-  def AppendBuildSetting(self, key, value):
-    """Appends value to the build setting for key, which is treated as a list,
+    def AppendBuildSetting(self, key, value):
+        """Appends value to the build setting for key, which is treated as a list,
     in all child XCBuildConfiguration objects.
     """
 
-    for configuration in self._properties['buildConfigurations']:
-      configuration.AppendBuildSetting(key, value)
+        for configuration in self._properties["buildConfigurations"]:
+            configuration.AppendBuildSetting(key, value)
 
-  def DelBuildSetting(self, key):
-    """Deletes the build setting key from all child XCBuildConfiguration
+    def DelBuildSetting(self, key):
+        """Deletes the build setting key from all child XCBuildConfiguration
     objects.
     """
 
-    for configuration in self._properties['buildConfigurations']:
-      configuration.DelBuildSetting(key)
+        for configuration in self._properties["buildConfigurations"]:
+            configuration.DelBuildSetting(key)
 
-  def SetBaseConfiguration(self, value):
-    """Sets the build configuration in all child XCBuildConfiguration objects.
+    def SetBaseConfiguration(self, value):
+        """Sets the build configuration in all child XCBuildConfiguration objects.
     """
 
-    for configuration in self._properties['buildConfigurations']:
-      configuration.SetBaseConfiguration(value)
+        for configuration in self._properties["buildConfigurations"]:
+            configuration.SetBaseConfiguration(value)
 
 
 class PBXBuildFile(XCObject):
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'fileRef':  [0, XCFileLikeElement, 0, 1],
-    'settings': [0, str,               0, 0],  # hack, it's a dict
-  })
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "fileRef": [0, XCFileLikeElement, 0, 1],
+            "settings": [0, str, 0, 0],  # hack, it's a dict
+        }
+    )
 
-  # Weird output rules for PBXBuildFile.
-  _should_print_single_line = True
-  _encode_transforms = XCObject._alternate_encode_transforms
+    # Weird output rules for PBXBuildFile.
+    _should_print_single_line = True
+    _encode_transforms = XCObject._alternate_encode_transforms
 
-  def Name(self):
-    # Example: "main.cc in Sources"
-    return self._properties['fileRef'].Name() + ' in ' + self.parent.Name()
+    def Name(self):
+        # Example: "main.cc in Sources"
+        return self._properties["fileRef"].Name() + " in " + self.parent.Name()
 
-  def Hashables(self):
-    # super
-    hashables = XCObject.Hashables(self)
+    def Hashables(self):
+        # super
+        hashables = XCObject.Hashables(self)
 
-    # It is not sufficient to just rely on Name() to get the
-    # XCFileLikeElement's name, because that is not a complete pathname.
-    # PathHashables returns hashables unique enough that no two
-    # PBXBuildFiles should wind up with the same set of hashables, unless
-    # someone adds the same file multiple times to the same target.  That
-    # would be considered invalid anyway.
-    hashables.extend(self._properties['fileRef'].PathHashables())
+        # It is not sufficient to just rely on Name() to get the
+        # XCFileLikeElement's name, because that is not a complete pathname.
+        # PathHashables returns hashables unique enough that no two
+        # PBXBuildFiles should wind up with the same set of hashables, unless
+        # someone adds the same file multiple times to the same target.  That
+        # would be considered invalid anyway.
+        hashables.extend(self._properties["fileRef"].PathHashables())
 
-    return hashables
+        return hashables
 
 
 class XCBuildPhase(XCObject):
-  """Abstract base for build phase classes.  Not represented in a project
+    """Abstract base for build phase classes.  Not represented in a project
   file.
 
   Attributes:
@@ -1737,51 +1847,52 @@ class XCBuildPhase(XCObject):
       to the corresponding PBXBuildFile children (values).
   """
 
-  # TODO(mark): Some build phase types, like PBXShellScriptBuildPhase, don't
-  # actually have a "files" list.  XCBuildPhase should not have "files" but
-  # another abstract subclass of it should provide this, and concrete build
-  # phase types that do have "files" lists should be derived from that new
-  # abstract subclass.  XCBuildPhase should only provide buildActionMask and
-  # runOnlyForDeploymentPostprocessing, and not files or the various
-  # file-related methods and attributes.
-
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'buildActionMask':                    [0, int,          0, 1, 0x7fffffff],
-    'files':                              [1, PBXBuildFile, 1, 1, []],
-    'runOnlyForDeploymentPostprocessing': [0, int,          0, 1, 0],
-  })
-
-  def __init__(self, properties=None, id=None, parent=None):
-    # super
-    XCObject.__init__(self, properties, id, parent)
+    # TODO(mark): Some build phase types, like PBXShellScriptBuildPhase, don't
+    # actually have a "files" list.  XCBuildPhase should not have "files" but
+    # another abstract subclass of it should provide this, and concrete build
+    # phase types that do have "files" lists should be derived from that new
+    # abstract subclass.  XCBuildPhase should only provide buildActionMask and
+    # runOnlyForDeploymentPostprocessing, and not files or the various
+    # file-related methods and attributes.
+
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "buildActionMask": [0, int, 0, 1, 0x7FFFFFFF],
+            "files": [1, PBXBuildFile, 1, 1, []],
+            "runOnlyForDeploymentPostprocessing": [0, int, 0, 1, 0],
+        }
+    )
 
-    self._files_by_path = {}
-    self._files_by_xcfilelikeelement = {}
-    for pbxbuildfile in self._properties.get('files', []):
-      self._AddBuildFileToDicts(pbxbuildfile)
+    def __init__(self, properties=None, id=None, parent=None):
+        # super
+        XCObject.__init__(self, properties, id, parent)
 
-  def FileGroup(self, path):
-    # Subclasses must override this by returning a two-element tuple.  The
-    # first item in the tuple should be the PBXGroup to which "path" should be
-    # added, either as a child or deeper descendant.  The second item should
-    # be a boolean indicating whether files should be added into hierarchical
-    # groups or one single flat group.
-    raise NotImplementedError(
-          self.__class__.__name__ + ' must implement FileGroup')
+        self._files_by_path = {}
+        self._files_by_xcfilelikeelement = {}
+        for pbxbuildfile in self._properties.get("files", []):
+            self._AddBuildFileToDicts(pbxbuildfile)
 
-  def _AddPathToDict(self, pbxbuildfile, path):
-    """Adds path to the dict tracking paths belonging to this build phase.
+    def FileGroup(self, path):
+        # Subclasses must override this by returning a two-element tuple.  The
+        # first item in the tuple should be the PBXGroup to which "path" should be
+        # added, either as a child or deeper descendant.  The second item should
+        # be a boolean indicating whether files should be added into hierarchical
+        # groups or one single flat group.
+        raise NotImplementedError(self.__class__.__name__ + " must implement FileGroup")
+
+    def _AddPathToDict(self, pbxbuildfile, path):
+        """Adds path to the dict tracking paths belonging to this build phase.
 
     If the path is already a member of this build phase, raises an exception.
     """
 
-    if path in self._files_by_path:
-      raise ValueError('Found multiple build files with path ' + path)
-    self._files_by_path[path] = pbxbuildfile
+        if path in self._files_by_path:
+            raise ValueError("Found multiple build files with path " + path)
+        self._files_by_path[path] = pbxbuildfile
 
-  def _AddBuildFileToDicts(self, pbxbuildfile, path=None):
-    """Maintains the _files_by_path and _files_by_xcfilelikeelement dicts.
+    def _AddBuildFileToDicts(self, pbxbuildfile, path=None):
+        """Maintains the _files_by_path and _files_by_xcfilelikeelement dicts.
 
     If path is specified, then it is the path that is being added to the
     phase, and pbxbuildfile must contain either a PBXFileReference directly
@@ -1806,751 +1917,825 @@ class XCBuildPhase(XCObject):
     the PBXBuildFile if it is already present in the list of children.
     """
 
-    xcfilelikeelement = pbxbuildfile._properties['fileRef']
+        xcfilelikeelement = pbxbuildfile._properties["fileRef"]
 
-    paths = []
-    if path != None:
-      # It's best when the caller provides the path.
-      if isinstance(xcfilelikeelement, PBXVariantGroup):
-        paths.append(path)
-    else:
-      # If the caller didn't provide a path, there can be either multiple
-      # paths (PBXVariantGroup) or one.
-      if isinstance(xcfilelikeelement, PBXVariantGroup):
-        for variant in xcfilelikeelement._properties['children']:
-          paths.append(variant.FullPath())
-      else:
-        paths.append(xcfilelikeelement.FullPath())
-
-    # Add the paths first, because if something's going to raise, the
-    # messages provided by _AddPathToDict are more useful owing to its
-    # having access to a real pathname and not just an object's Name().
-    for a_path in paths:
-      self._AddPathToDict(pbxbuildfile, a_path)
-
-    # If another PBXBuildFile references this XCFileLikeElement, there's a
-    # problem.
-    if xcfilelikeelement in self._files_by_xcfilelikeelement and \
-       self._files_by_xcfilelikeelement[xcfilelikeelement] != pbxbuildfile:
-      raise ValueError('Found multiple build files for ' + \
-                       xcfilelikeelement.Name())
-    self._files_by_xcfilelikeelement[xcfilelikeelement] = pbxbuildfile
-
-  def AppendBuildFile(self, pbxbuildfile, path=None):
-    # Callers should use this instead of calling
-    # AppendProperty('files', pbxbuildfile) directly because this function
-    # maintains the object's dicts.  Better yet, callers can just call AddFile
-    # with a pathname and not worry about building their own PBXBuildFile
-    # objects.
-    self.AppendProperty('files', pbxbuildfile)
-    self._AddBuildFileToDicts(pbxbuildfile, path)
-
-  def AddFile(self, path, settings=None):
-    (file_group, hierarchical) = self.FileGroup(path)
-    file_ref = file_group.AddOrGetFileByPath(path, hierarchical)
-
-    if file_ref in self._files_by_xcfilelikeelement and \
-       isinstance(file_ref, PBXVariantGroup):
-      # There's already a PBXBuildFile in this phase corresponding to the
-      # PBXVariantGroup.  path just provides a new variant that belongs to
-      # the group.  Add the path to the dict.
-      pbxbuildfile = self._files_by_xcfilelikeelement[file_ref]
-      self._AddBuildFileToDicts(pbxbuildfile, path)
-    else:
-      # Add a new PBXBuildFile to get file_ref into the phase.
-      if settings is None:
-        pbxbuildfile = PBXBuildFile({'fileRef': file_ref})
-      else:
-        pbxbuildfile = PBXBuildFile({'fileRef': file_ref, 'settings': settings})
-      self.AppendBuildFile(pbxbuildfile, path)
+        paths = []
+        if path is not None:
+            # It's best when the caller provides the path.
+            if isinstance(xcfilelikeelement, PBXVariantGroup):
+                paths.append(path)
+        else:
+            # If the caller didn't provide a path, there can be either multiple
+            # paths (PBXVariantGroup) or one.
+            if isinstance(xcfilelikeelement, PBXVariantGroup):
+                for variant in xcfilelikeelement._properties["children"]:
+                    paths.append(variant.FullPath())
+            else:
+                paths.append(xcfilelikeelement.FullPath())
+
+        # Add the paths first, because if something's going to raise, the
+        # messages provided by _AddPathToDict are more useful owing to its
+        # having access to a real pathname and not just an object's Name().
+        for a_path in paths:
+            self._AddPathToDict(pbxbuildfile, a_path)
+
+        # If another PBXBuildFile references this XCFileLikeElement, there's a
+        # problem.
+        if (
+            xcfilelikeelement in self._files_by_xcfilelikeelement
+            and self._files_by_xcfilelikeelement[xcfilelikeelement] != pbxbuildfile
+        ):
+            raise ValueError(
+                "Found multiple build files for " + xcfilelikeelement.Name()
+            )
+        self._files_by_xcfilelikeelement[xcfilelikeelement] = pbxbuildfile
+
+    def AppendBuildFile(self, pbxbuildfile, path=None):
+        # Callers should use this instead of calling
+        # AppendProperty('files', pbxbuildfile) directly because this function
+        # maintains the object's dicts.  Better yet, callers can just call AddFile
+        # with a pathname and not worry about building their own PBXBuildFile
+        # objects.
+        self.AppendProperty("files", pbxbuildfile)
+        self._AddBuildFileToDicts(pbxbuildfile, path)
+
+    def AddFile(self, path, settings=None):
+        (file_group, hierarchical) = self.FileGroup(path)
+        file_ref = file_group.AddOrGetFileByPath(path, hierarchical)
+
+        if file_ref in self._files_by_xcfilelikeelement and isinstance(
+            file_ref, PBXVariantGroup
+        ):
+            # There's already a PBXBuildFile in this phase corresponding to the
+            # PBXVariantGroup.  path just provides a new variant that belongs to
+            # the group.  Add the path to the dict.
+            pbxbuildfile = self._files_by_xcfilelikeelement[file_ref]
+            self._AddBuildFileToDicts(pbxbuildfile, path)
+        else:
+            # Add a new PBXBuildFile to get file_ref into the phase.
+            if settings is None:
+                pbxbuildfile = PBXBuildFile({"fileRef": file_ref})
+            else:
+                pbxbuildfile = PBXBuildFile({"fileRef": file_ref, "settings": settings})
+            self.AppendBuildFile(pbxbuildfile, path)
 
 
 class PBXHeadersBuildPhase(XCBuildPhase):
-  # No additions to the schema relative to XCBuildPhase.
+    # No additions to the schema relative to XCBuildPhase.
 
-  def Name(self):
-    return 'Headers'
+    def Name(self):
+        return "Headers"
 
-  def FileGroup(self, path):
-    return self.PBXProjectAncestor().RootGroupForPath(path)
+    def FileGroup(self, path):
+        return self.PBXProjectAncestor().RootGroupForPath(path)
 
 
 class PBXResourcesBuildPhase(XCBuildPhase):
-  # No additions to the schema relative to XCBuildPhase.
+    # No additions to the schema relative to XCBuildPhase.
 
-  def Name(self):
-    return 'Resources'
+    def Name(self):
+        return "Resources"
 
-  def FileGroup(self, path):
-    return self.PBXProjectAncestor().RootGroupForPath(path)
+    def FileGroup(self, path):
+        return self.PBXProjectAncestor().RootGroupForPath(path)
 
 
 class PBXSourcesBuildPhase(XCBuildPhase):
-  # No additions to the schema relative to XCBuildPhase.
+    # No additions to the schema relative to XCBuildPhase.
 
-  def Name(self):
-    return 'Sources'
+    def Name(self):
+        return "Sources"
 
-  def FileGroup(self, path):
-    return self.PBXProjectAncestor().RootGroupForPath(path)
+    def FileGroup(self, path):
+        return self.PBXProjectAncestor().RootGroupForPath(path)
 
 
 class PBXFrameworksBuildPhase(XCBuildPhase):
-  # No additions to the schema relative to XCBuildPhase.
-
-  def Name(self):
-    return 'Frameworks'
-
-  def FileGroup(self, path):
-    (root, ext) = posixpath.splitext(path)
-    if ext != '':
-      ext = ext[1:].lower()
-    if ext == 'o':
-      # .o files are added to Xcode Frameworks phases, but conceptually aren't
-      # frameworks, they're more like sources or intermediates. Redirect them
-      # to show up in one of those other groups.
-      return self.PBXProjectAncestor().RootGroupForPath(path)
-    else:
-      return (self.PBXProjectAncestor().FrameworksGroup(), False)
+    # No additions to the schema relative to XCBuildPhase.
+
+    def Name(self):
+        return "Frameworks"
+
+    def FileGroup(self, path):
+        (root, ext) = posixpath.splitext(path)
+        if ext != "":
+            ext = ext[1:].lower()
+        if ext == "o":
+            # .o files are added to Xcode Frameworks phases, but conceptually aren't
+            # frameworks, they're more like sources or intermediates. Redirect them
+            # to show up in one of those other groups.
+            return self.PBXProjectAncestor().RootGroupForPath(path)
+        else:
+            return (self.PBXProjectAncestor().FrameworksGroup(), False)
 
 
 class PBXShellScriptBuildPhase(XCBuildPhase):
-  _schema = XCBuildPhase._schema.copy()
-  _schema.update({
-    'inputPaths':       [1, str, 0, 1, []],
-    'name':             [0, str, 0, 0],
-    'outputPaths':      [1, str, 0, 1, []],
-    'shellPath':        [0, str, 0, 1, '/bin/sh'],
-    'shellScript':      [0, str, 0, 1],
-    'showEnvVarsInLog': [0, int, 0, 0],
-  })
+    _schema = XCBuildPhase._schema.copy()
+    _schema.update(
+        {
+            "inputPaths": [1, str, 0, 1, []],
+            "name": [0, str, 0, 0],
+            "outputPaths": [1, str, 0, 1, []],
+            "shellPath": [0, str, 0, 1, "/bin/sh"],
+            "shellScript": [0, str, 0, 1],
+            "showEnvVarsInLog": [0, int, 0, 0],
+        }
+    )
 
-  def Name(self):
-    if 'name' in self._properties:
-      return self._properties['name']
+    def Name(self):
+        if "name" in self._properties:
+            return self._properties["name"]
 
-    return 'ShellScript'
+        return "ShellScript"
 
 
 class PBXCopyFilesBuildPhase(XCBuildPhase):
-  _schema = XCBuildPhase._schema.copy()
-  _schema.update({
-    'dstPath':          [0, str, 0, 1],
-    'dstSubfolderSpec': [0, int, 0, 1],
-    'name':             [0, str, 0, 0],
-  })
-
-  # path_tree_re matches "$(DIR)/path", "$(DIR)/$(DIR2)/path" or just "$(DIR)".
-  # Match group 1 is "DIR", group 3 is "path" or "$(DIR2") or "$(DIR2)/path"
-  # or None. If group 3 is "path", group 4 will be None otherwise group 4 is
-  # "DIR2" and group 6 is "path".
-  path_tree_re = re.compile(r'^\$\((.*?)\)(/(\$\((.*?)\)(/(.*)|)|(.*)|)|)$')
-
-  # path_tree_{first,second}_to_subfolder map names of Xcode variables to the
-  # associated dstSubfolderSpec property value used in a PBXCopyFilesBuildPhase
-  # object.
-  path_tree_first_to_subfolder = {
-    # Types that can be chosen via the Xcode UI.
-    'BUILT_PRODUCTS_DIR':               16,  # Products Directory
-    'BUILT_FRAMEWORKS_DIR':             10,  # Not an official Xcode macro.
-                                             # Existed before support for the
-                                             # names below was added. Maps to
-                                             # "Frameworks".
-  }
-
-  path_tree_second_to_subfolder = {
-    'WRAPPER_NAME':                      1,  # Wrapper
-    # Although Xcode's friendly name is "Executables", the destination
-    # is demonstrably the value of the build setting
-    # EXECUTABLE_FOLDER_PATH not EXECUTABLES_FOLDER_PATH.
-    'EXECUTABLE_FOLDER_PATH':            6,  # Executables.
-    'UNLOCALIZED_RESOURCES_FOLDER_PATH': 7,  # Resources
-    'JAVA_FOLDER_PATH':                 15,  # Java Resources
-    'FRAMEWORKS_FOLDER_PATH':           10,  # Frameworks
-    'SHARED_FRAMEWORKS_FOLDER_PATH':    11,  # Shared Frameworks
-    'SHARED_SUPPORT_FOLDER_PATH':       12,  # Shared Support
-    'PLUGINS_FOLDER_PATH':              13,  # PlugIns
-    # For XPC Services, Xcode sets both dstPath and dstSubfolderSpec.
-    # Note that it re-uses the BUILT_PRODUCTS_DIR value for
-    # dstSubfolderSpec. dstPath is set below.
-    'XPCSERVICES_FOLDER_PATH':          16,  # XPC Services.
-  }
-
-  def Name(self):
-    if 'name' in self._properties:
-      return self._properties['name']
-
-    return 'CopyFiles'
-
-  def FileGroup(self, path):
-    return self.PBXProjectAncestor().RootGroupForPath(path)
-
-  def SetDestination(self, path):
-    """Set the dstSubfolderSpec and dstPath properties from path.
+    _schema = XCBuildPhase._schema.copy()
+    _schema.update(
+        {
+            "dstPath": [0, str, 0, 1],
+            "dstSubfolderSpec": [0, int, 0, 1],
+            "name": [0, str, 0, 0],
+        }
+    )
+
+    # path_tree_re matches "$(DIR)/path", "$(DIR)/$(DIR2)/path" or just "$(DIR)".
+    # Match group 1 is "DIR", group 3 is "path" or "$(DIR2") or "$(DIR2)/path"
+    # or None. If group 3 is "path", group 4 will be None otherwise group 4 is
+    # "DIR2" and group 6 is "path".
+    path_tree_re = re.compile(r"^\$\((.*?)\)(/(\$\((.*?)\)(/(.*)|)|(.*)|)|)$")
+
+    # path_tree_{first,second}_to_subfolder map names of Xcode variables to the
+    # associated dstSubfolderSpec property value used in a PBXCopyFilesBuildPhase
+    # object.
+    path_tree_first_to_subfolder = {
+        # Types that can be chosen via the Xcode UI.
+        "BUILT_PRODUCTS_DIR": 16,  # Products Directory
+        "BUILT_FRAMEWORKS_DIR": 10,  # Not an official Xcode macro.
+        # Existed before support for the
+        # names below was added. Maps to
+        # "Frameworks".
+    }
+
+    path_tree_second_to_subfolder = {
+        "WRAPPER_NAME": 1,  # Wrapper
+        # Although Xcode's friendly name is "Executables", the destination
+        # is demonstrably the value of the build setting
+        # EXECUTABLE_FOLDER_PATH not EXECUTABLES_FOLDER_PATH.
+        "EXECUTABLE_FOLDER_PATH": 6,  # Executables.
+        "UNLOCALIZED_RESOURCES_FOLDER_PATH": 7,  # Resources
+        "JAVA_FOLDER_PATH": 15,  # Java Resources
+        "FRAMEWORKS_FOLDER_PATH": 10,  # Frameworks
+        "SHARED_FRAMEWORKS_FOLDER_PATH": 11,  # Shared Frameworks
+        "SHARED_SUPPORT_FOLDER_PATH": 12,  # Shared Support
+        "PLUGINS_FOLDER_PATH": 13,  # PlugIns
+        # For XPC Services, Xcode sets both dstPath and dstSubfolderSpec.
+        # Note that it re-uses the BUILT_PRODUCTS_DIR value for
+        # dstSubfolderSpec. dstPath is set below.
+        "XPCSERVICES_FOLDER_PATH": 16,  # XPC Services.
+    }
+
+    def Name(self):
+        if "name" in self._properties:
+            return self._properties["name"]
+
+        return "CopyFiles"
+
+    def FileGroup(self, path):
+        return self.PBXProjectAncestor().RootGroupForPath(path)
+
+    def SetDestination(self, path):
+        """Set the dstSubfolderSpec and dstPath properties from path.
 
     path may be specified in the same notation used for XCHierarchicalElements,
     specifically, "$(DIR)/path".
     """
 
-    path_tree_match = self.path_tree_re.search(path)
-    if path_tree_match:
-      path_tree = path_tree_match.group(1)
-      if path_tree in self.path_tree_first_to_subfolder:
-        subfolder = self.path_tree_first_to_subfolder[path_tree]
-        relative_path = path_tree_match.group(3)
-        if relative_path is None:
-          relative_path = ''
-
-        if subfolder == 16 and path_tree_match.group(4) is not None:
-          # BUILT_PRODUCTS_DIR (16) is the first element in a path whose
-          # second element is possibly one of the variable names in
-          # path_tree_second_to_subfolder. Xcode sets the values of all these
-          # variables to relative paths so .gyp files must prefix them with
-          # BUILT_PRODUCTS_DIR, e.g.
-          # $(BUILT_PRODUCTS_DIR)/$(PLUGINS_FOLDER_PATH). Then
-          # xcode_emulation.py can export these variables with the same values
-          # as Xcode yet make & ninja files can determine the absolute path
-          # to the target. Xcode uses the dstSubfolderSpec value set here
-          # to determine the full path.
-          #
-          # An alternative of xcode_emulation.py setting the values to absolute
-          # paths when exporting these variables has been ruled out because
-          # then the values would be different depending on the build tool.
-          #
-          # Another alternative is to invent new names for the variables used
-          # to match to the subfolder indices in the second table. .gyp files
-          # then will not need to prepend $(BUILT_PRODUCTS_DIR) because
-          # xcode_emulation.py can set the values of those variables to
-          # the absolute paths when exporting. This is possibly the thinking
-          # behind BUILT_FRAMEWORKS_DIR which is used in exactly this manner.
-          #
-          # Requiring prepending BUILT_PRODUCTS_DIR has been chosen because
-          # this same way could be used to specify destinations in .gyp files
-          # that pre-date this addition to GYP. However they would only work
-          # with the Xcode generator. The previous version of xcode_emulation.py
-          # does not export these variables. Such files will get the benefit
-          # of the Xcode UI showing the proper destination name simply by
-          # regenerating the projects with this version of GYP.
-          path_tree = path_tree_match.group(4)
-          relative_path = path_tree_match.group(6)
-          separator = '/'
-
-          if path_tree in self.path_tree_second_to_subfolder:
-            subfolder = self.path_tree_second_to_subfolder[path_tree]
-            if relative_path is None:
-              relative_path = ''
-              separator = ''
-            if path_tree == 'XPCSERVICES_FOLDER_PATH':
-              relative_path = '$(CONTENTS_FOLDER_PATH)/XPCServices' \
-                              + separator + relative_path
-          else:
-            # subfolder = 16 from above
-            # The second element of the path is an unrecognized variable.
-            # Include it and any remaining elements in relative_path.
-            relative_path = path_tree_match.group(3)
-
-      else:
-        # The path starts with an unrecognized Xcode variable
-        # name like $(SRCROOT).  Xcode will still handle this
-        # as an "absolute path" that starts with the variable.
-        subfolder = 0
-        relative_path = path
-    elif path.startswith('/'):
-      # Special case.  Absolute paths are in dstSubfolderSpec 0.
-      subfolder = 0
-      relative_path = path[1:]
-    else:
-      raise ValueError('Can\'t use path %s in a %s' % \
-                       (path, self.__class__.__name__))
+        path_tree_match = self.path_tree_re.search(path)
+        if path_tree_match:
+            path_tree = path_tree_match.group(1)
+            if path_tree in self.path_tree_first_to_subfolder:
+                subfolder = self.path_tree_first_to_subfolder[path_tree]
+                relative_path = path_tree_match.group(3)
+                if relative_path is None:
+                    relative_path = ""
+
+                if subfolder == 16 and path_tree_match.group(4) is not None:
+                    # BUILT_PRODUCTS_DIR (16) is the first element in a path whose
+                    # second element is possibly one of the variable names in
+                    # path_tree_second_to_subfolder. Xcode sets the values of all these
+                    # variables to relative paths so .gyp files must prefix them with
+                    # BUILT_PRODUCTS_DIR, e.g.
+                    # $(BUILT_PRODUCTS_DIR)/$(PLUGINS_FOLDER_PATH). Then
+                    # xcode_emulation.py can export these variables with the same values
+                    # as Xcode yet make & ninja files can determine the absolute path
+                    # to the target. Xcode uses the dstSubfolderSpec value set here
+                    # to determine the full path.
+                    #
+                    # An alternative of xcode_emulation.py setting the values to
+                    # absolute paths when exporting these variables has been
+                    # ruled out because then the values would be different
+                    # depending on the build tool.
+                    #
+                    # Another alternative is to invent new names for the variables used
+                    # to match to the subfolder indices in the second table. .gyp files
+                    # then will not need to prepend $(BUILT_PRODUCTS_DIR) because
+                    # xcode_emulation.py can set the values of those variables to
+                    # the absolute paths when exporting. This is possibly the thinking
+                    # behind BUILT_FRAMEWORKS_DIR which is used in exactly this manner.
+                    #
+                    # Requiring prepending BUILT_PRODUCTS_DIR has been chosen because
+                    # this same way could be used to specify destinations in .gyp files
+                    # that pre-date this addition to GYP. However they would only work
+                    # with the Xcode generator.
+                    # The previous version of xcode_emulation.py
+                    # does not export these variables. Such files will get the benefit
+                    # of the Xcode UI showing the proper destination name simply by
+                    # regenerating the projects with this version of GYP.
+                    path_tree = path_tree_match.group(4)
+                    relative_path = path_tree_match.group(6)
+                    separator = "/"
+
+                    if path_tree in self.path_tree_second_to_subfolder:
+                        subfolder = self.path_tree_second_to_subfolder[path_tree]
+                        if relative_path is None:
+                            relative_path = ""
+                            separator = ""
+                        if path_tree == "XPCSERVICES_FOLDER_PATH":
+                            relative_path = (
+                                "$(CONTENTS_FOLDER_PATH)/XPCServices"
+                                + separator
+                                + relative_path
+                            )
+                    else:
+                        # subfolder = 16 from above
+                        # The second element of the path is an unrecognized variable.
+                        # Include it and any remaining elements in relative_path.
+                        relative_path = path_tree_match.group(3)
+
+            else:
+                # The path starts with an unrecognized Xcode variable
+                # name like $(SRCROOT).  Xcode will still handle this
+                # as an "absolute path" that starts with the variable.
+                subfolder = 0
+                relative_path = path
+        elif path.startswith("/"):
+            # Special case.  Absolute paths are in dstSubfolderSpec 0.
+            subfolder = 0
+            relative_path = path[1:]
+        else:
+            raise ValueError(
+                "Can't use path %s in a %s" % (path, self.__class__.__name__)
+            )
 
-    self._properties['dstPath'] = relative_path
-    self._properties['dstSubfolderSpec'] = subfolder
+        self._properties["dstPath"] = relative_path
+        self._properties["dstSubfolderSpec"] = subfolder
 
 
 class PBXBuildRule(XCObject):
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'compilerSpec': [0, str, 0, 1],
-    'filePatterns': [0, str, 0, 0],
-    'fileType':     [0, str, 0, 1],
-    'isEditable':   [0, int, 0, 1, 1],
-    'outputFiles':  [1, str, 0, 1, []],
-    'script':       [0, str, 0, 0],
-  })
-
-  def Name(self):
-    # Not very inspired, but it's what Xcode uses.
-    return self.__class__.__name__
-
-  def Hashables(self):
-    # super
-    hashables = XCObject.Hashables(self)
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "compilerSpec": [0, str, 0, 1],
+            "filePatterns": [0, str, 0, 0],
+            "fileType": [0, str, 0, 1],
+            "isEditable": [0, int, 0, 1, 1],
+            "outputFiles": [1, str, 0, 1, []],
+            "script": [0, str, 0, 0],
+        }
+    )
 
-    # Use the hashables of the weak objects that this object refers to.
-    hashables.append(self._properties['fileType'])
-    if 'filePatterns' in self._properties:
-      hashables.append(self._properties['filePatterns'])
-    return hashables
+    def Name(self):
+        # Not very inspired, but it's what Xcode uses.
+        return self.__class__.__name__
+
+    def Hashables(self):
+        # super
+        hashables = XCObject.Hashables(self)
+
+        # Use the hashables of the weak objects that this object refers to.
+        hashables.append(self._properties["fileType"])
+        if "filePatterns" in self._properties:
+            hashables.append(self._properties["filePatterns"])
+        return hashables
 
 
 class PBXContainerItemProxy(XCObject):
-  # When referencing an item in this project file, containerPortal is the
-  # PBXProject root object of this project file.  When referencing an item in
-  # another project file, containerPortal is a PBXFileReference identifying
-  # the other project file.
-  #
-  # When serving as a proxy to an XCTarget (in this project file or another),
-  # proxyType is 1.  When serving as a proxy to a PBXFileReference (in another
-  # project file), proxyType is 2.  Type 2 is used for references to the
-  # producs of the other project file's targets.
-  #
-  # Xcode is weird about remoteGlobalIDString.  Usually, it's printed without
-  # a comment, indicating that it's tracked internally simply as a string, but
-  # sometimes it's printed with a comment (usually when the object is initially
-  # created), indicating that it's tracked as a project file object at least
-  # sometimes.  This module always tracks it as an object, but contains a hack
-  # to prevent it from printing the comment in the project file output.  See
-  # _XCKVPrint.
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'containerPortal':      [0, XCContainerPortal, 0, 1],
-    'proxyType':            [0, int,               0, 1],
-    'remoteGlobalIDString': [0, XCRemoteObject,    0, 1],
-    'remoteInfo':           [0, str,               0, 1],
-  })
-
-  def __repr__(self):
-    props = self._properties
-    name = '%s.gyp:%s' % (props['containerPortal'].Name(), props['remoteInfo'])
-    return '<%s %r at 0x%x>' % (self.__class__.__name__, name, id(self))
-
-  def Name(self):
-    # Admittedly not the best name, but it's what Xcode uses.
-    return self.__class__.__name__
-
-  def Hashables(self):
-    # super
-    hashables = XCObject.Hashables(self)
+    # When referencing an item in this project file, containerPortal is the
+    # PBXProject root object of this project file.  When referencing an item in
+    # another project file, containerPortal is a PBXFileReference identifying
+    # the other project file.
+    #
+    # When serving as a proxy to an XCTarget (in this project file or another),
+    # proxyType is 1.  When serving as a proxy to a PBXFileReference (in another
+    # project file), proxyType is 2.  Type 2 is used for references to the
+    # producs of the other project file's targets.
+    #
+    # Xcode is weird about remoteGlobalIDString.  Usually, it's printed without
+    # a comment, indicating that it's tracked internally simply as a string, but
+    # sometimes it's printed with a comment (usually when the object is initially
+    # created), indicating that it's tracked as a project file object at least
+    # sometimes.  This module always tracks it as an object, but contains a hack
+    # to prevent it from printing the comment in the project file output.  See
+    # _XCKVPrint.
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "containerPortal": [0, XCContainerPortal, 0, 1],
+            "proxyType": [0, int, 0, 1],
+            "remoteGlobalIDString": [0, XCRemoteObject, 0, 1],
+            "remoteInfo": [0, str, 0, 1],
+        }
+    )
+
+    def __repr__(self):
+        props = self._properties
+        name = "%s.gyp:%s" % (props["containerPortal"].Name(), props["remoteInfo"])
+        return "<%s %r at 0x%x>" % (self.__class__.__name__, name, id(self))
+
+    def Name(self):
+        # Admittedly not the best name, but it's what Xcode uses.
+        return self.__class__.__name__
+
+    def Hashables(self):
+        # super
+        hashables = XCObject.Hashables(self)
 
-    # Use the hashables of the weak objects that this object refers to.
-    hashables.extend(self._properties['containerPortal'].Hashables())
-    hashables.extend(self._properties['remoteGlobalIDString'].Hashables())
-    return hashables
+        # Use the hashables of the weak objects that this object refers to.
+        hashables.extend(self._properties["containerPortal"].Hashables())
+        hashables.extend(self._properties["remoteGlobalIDString"].Hashables())
+        return hashables
 
 
 class PBXTargetDependency(XCObject):
-  # The "target" property accepts an XCTarget object, and obviously not
-  # NoneType.  But XCTarget is defined below, so it can't be put into the
-  # schema yet.  The definition of PBXTargetDependency can't be moved below
-  # XCTarget because XCTarget's own schema references PBXTargetDependency.
-  # Python doesn't deal well with this circular relationship, and doesn't have
-  # a real way to do forward declarations.  To work around, the type of
-  # the "target" property is reset below, after XCTarget is defined.
-  #
-  # At least one of "name" and "target" is required.
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'name':        [0, str,                   0, 0],
-    'target':      [0, None.__class__,        0, 0],
-    'targetProxy': [0, PBXContainerItemProxy, 1, 1],
-  })
-
-  def __repr__(self):
-    name = self._properties.get('name') or self._properties['target'].Name()
-    return '<%s %r at 0x%x>' % (self.__class__.__name__, name, id(self))
-
-  def Name(self):
-    # Admittedly not the best name, but it's what Xcode uses.
-    return self.__class__.__name__
-
-  def Hashables(self):
-    # super
-    hashables = XCObject.Hashables(self)
+    # The "target" property accepts an XCTarget object, and obviously not
+    # NoneType.  But XCTarget is defined below, so it can't be put into the
+    # schema yet.  The definition of PBXTargetDependency can't be moved below
+    # XCTarget because XCTarget's own schema references PBXTargetDependency.
+    # Python doesn't deal well with this circular relationship, and doesn't have
+    # a real way to do forward declarations.  To work around, the type of
+    # the "target" property is reset below, after XCTarget is defined.
+    #
+    # At least one of "name" and "target" is required.
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "name": [0, str, 0, 0],
+            "target": [0, None.__class__, 0, 0],
+            "targetProxy": [0, PBXContainerItemProxy, 1, 1],
+        }
+    )
+
+    def __repr__(self):
+        name = self._properties.get("name") or self._properties["target"].Name()
+        return "<%s %r at 0x%x>" % (self.__class__.__name__, name, id(self))
+
+    def Name(self):
+        # Admittedly not the best name, but it's what Xcode uses.
+        return self.__class__.__name__
 
-    # Use the hashables of the weak objects that this object refers to.
-    hashables.extend(self._properties['targetProxy'].Hashables())
-    return hashables
+    def Hashables(self):
+        # super
+        hashables = XCObject.Hashables(self)
+
+        # Use the hashables of the weak objects that this object refers to.
+        hashables.extend(self._properties["targetProxy"].Hashables())
+        return hashables
 
 
 class PBXReferenceProxy(XCFileLikeElement):
-  _schema = XCFileLikeElement._schema.copy()
-  _schema.update({
-    'fileType':  [0, str,                   0, 1],
-    'path':      [0, str,                   0, 1],
-    'remoteRef': [0, PBXContainerItemProxy, 1, 1],
-  })
+    _schema = XCFileLikeElement._schema.copy()
+    _schema.update(
+        {
+            "fileType": [0, str, 0, 1],
+            "path": [0, str, 0, 1],
+            "remoteRef": [0, PBXContainerItemProxy, 1, 1],
+        }
+    )
 
 
 class XCTarget(XCRemoteObject):
-  # An XCTarget is really just an XCObject, the XCRemoteObject thing is just
-  # to allow PBXProject to be used in the remoteGlobalIDString property of
-  # PBXContainerItemProxy.
-  #
-  # Setting a "name" property at instantiation may also affect "productName",
-  # which may in turn affect the "PRODUCT_NAME" build setting in children of
-  # "buildConfigurationList".  See __init__ below.
-  _schema = XCRemoteObject._schema.copy()
-  _schema.update({
-    'buildConfigurationList': [0, XCConfigurationList, 1, 1,
-                               XCConfigurationList()],
-    'buildPhases':            [1, XCBuildPhase,        1, 1, []],
-    'dependencies':           [1, PBXTargetDependency, 1, 1, []],
-    'name':                   [0, str,                 0, 1],
-    'productName':            [0, str,                 0, 1],
-  })
-
-  def __init__(self, properties=None, id=None, parent=None,
-               force_outdir=None, force_prefix=None, force_extension=None):
-    # super
-    XCRemoteObject.__init__(self, properties, id, parent)
-
-    # Set up additional defaults not expressed in the schema.  If a "name"
-    # property was supplied, set "productName" if it is not present.  Also set
-    # the "PRODUCT_NAME" build setting in each configuration, but only if
-    # the setting is not present in any build configuration.
-    if 'name' in self._properties:
-      if not 'productName' in self._properties:
-        self.SetProperty('productName', self._properties['name'])
-
-    if 'productName' in self._properties:
-      if 'buildConfigurationList' in self._properties:
-        configs = self._properties['buildConfigurationList']
-        if configs.HasBuildSetting('PRODUCT_NAME') == 0:
-          configs.SetBuildSetting('PRODUCT_NAME',
-                                  self._properties['productName'])
-
-  def AddDependency(self, other):
-    pbxproject = self.PBXProjectAncestor()
-    other_pbxproject = other.PBXProjectAncestor()
-    if pbxproject == other_pbxproject:
-      # Add a dependency to another target in the same project file.
-      container = PBXContainerItemProxy({'containerPortal':      pbxproject,
-                                         'proxyType':            1,
-                                         'remoteGlobalIDString': other,
-                                         'remoteInfo':           other.Name()})
-      dependency = PBXTargetDependency({'target':      other,
-                                        'targetProxy': container})
-      self.AppendProperty('dependencies', dependency)
-    else:
-      # Add a dependency to a target in a different project file.
-      other_project_ref = \
-          pbxproject.AddOrGetProjectReference(other_pbxproject)[1]
-      container = PBXContainerItemProxy({
-            'containerPortal':      other_project_ref,
-            'proxyType':            1,
-            'remoteGlobalIDString': other,
-            'remoteInfo':           other.Name(),
-          })
-      dependency = PBXTargetDependency({'name':        other.Name(),
-                                        'targetProxy': container})
-      self.AppendProperty('dependencies', dependency)
+    # An XCTarget is really just an XCObject, the XCRemoteObject thing is just
+    # to allow PBXProject to be used in the remoteGlobalIDString property of
+    # PBXContainerItemProxy.
+    #
+    # Setting a "name" property at instantiation may also affect "productName",
+    # which may in turn affect the "PRODUCT_NAME" build setting in children of
+    # "buildConfigurationList".  See __init__ below.
+    _schema = XCRemoteObject._schema.copy()
+    _schema.update(
+        {
+            "buildConfigurationList": [
+                0,
+                XCConfigurationList,
+                1,
+                1,
+                XCConfigurationList(),
+            ],
+            "buildPhases": [1, XCBuildPhase, 1, 1, []],
+            "dependencies": [1, PBXTargetDependency, 1, 1, []],
+            "name": [0, str, 0, 1],
+            "productName": [0, str, 0, 1],
+        }
+    )
+
+    def __init__(
+        self,
+        properties=None,
+        id=None,
+        parent=None,
+        force_outdir=None,
+        force_prefix=None,
+        force_extension=None,
+    ):
+        # super
+        XCRemoteObject.__init__(self, properties, id, parent)
+
+        # Set up additional defaults not expressed in the schema.  If a "name"
+        # property was supplied, set "productName" if it is not present.  Also set
+        # the "PRODUCT_NAME" build setting in each configuration, but only if
+        # the setting is not present in any build configuration.
+        if "name" in self._properties:
+            if "productName" not in self._properties:
+                self.SetProperty("productName", self._properties["name"])
+
+        if "productName" in self._properties:
+            if "buildConfigurationList" in self._properties:
+                configs = self._properties["buildConfigurationList"]
+                if configs.HasBuildSetting("PRODUCT_NAME") == 0:
+                    configs.SetBuildSetting(
+                        "PRODUCT_NAME", self._properties["productName"]
+                    )
+
+    def AddDependency(self, other):
+        pbxproject = self.PBXProjectAncestor()
+        other_pbxproject = other.PBXProjectAncestor()
+        if pbxproject == other_pbxproject:
+            # Add a dependency to another target in the same project file.
+            container = PBXContainerItemProxy(
+                {
+                    "containerPortal": pbxproject,
+                    "proxyType": 1,
+                    "remoteGlobalIDString": other,
+                    "remoteInfo": other.Name(),
+                }
+            )
+            dependency = PBXTargetDependency(
+                {"target": other, "targetProxy": container}
+            )
+            self.AppendProperty("dependencies", dependency)
+        else:
+            # Add a dependency to a target in a different project file.
+            other_project_ref = pbxproject.AddOrGetProjectReference(other_pbxproject)[1]
+            container = PBXContainerItemProxy(
+                {
+                    "containerPortal": other_project_ref,
+                    "proxyType": 1,
+                    "remoteGlobalIDString": other,
+                    "remoteInfo": other.Name(),
+                }
+            )
+            dependency = PBXTargetDependency(
+                {"name": other.Name(), "targetProxy": container}
+            )
+            self.AppendProperty("dependencies", dependency)
 
-  # Proxy all of these through to the build configuration list.
+    # Proxy all of these through to the build configuration list.
 
-  def ConfigurationNamed(self, name):
-    return self._properties['buildConfigurationList'].ConfigurationNamed(name)
+    def ConfigurationNamed(self, name):
+        return self._properties["buildConfigurationList"].ConfigurationNamed(name)
 
-  def DefaultConfiguration(self):
-    return self._properties['buildConfigurationList'].DefaultConfiguration()
+    def DefaultConfiguration(self):
+        return self._properties["buildConfigurationList"].DefaultConfiguration()
 
-  def HasBuildSetting(self, key):
-    return self._properties['buildConfigurationList'].HasBuildSetting(key)
+    def HasBuildSetting(self, key):
+        return self._properties["buildConfigurationList"].HasBuildSetting(key)
 
-  def GetBuildSetting(self, key):
-    return self._properties['buildConfigurationList'].GetBuildSetting(key)
+    def GetBuildSetting(self, key):
+        return self._properties["buildConfigurationList"].GetBuildSetting(key)
 
-  def SetBuildSetting(self, key, value):
-    return self._properties['buildConfigurationList'].SetBuildSetting(key, \
-                                                                      value)
+    def SetBuildSetting(self, key, value):
+        return self._properties["buildConfigurationList"].SetBuildSetting(key, value)
 
-  def AppendBuildSetting(self, key, value):
-    return self._properties['buildConfigurationList'].AppendBuildSetting(key, \
-                                                                         value)
+    def AppendBuildSetting(self, key, value):
+        return self._properties["buildConfigurationList"].AppendBuildSetting(key, value)
 
-  def DelBuildSetting(self, key):
-    return self._properties['buildConfigurationList'].DelBuildSetting(key)
+    def DelBuildSetting(self, key):
+        return self._properties["buildConfigurationList"].DelBuildSetting(key)
 
 
 # Redefine the type of the "target" property.  See PBXTargetDependency._schema
 # above.
-PBXTargetDependency._schema['target'][1] = XCTarget
+PBXTargetDependency._schema["target"][1] = XCTarget
 
 
 class PBXNativeTarget(XCTarget):
-  # buildPhases is overridden in the schema to be able to set defaults.
-  #
-  # NOTE: Contrary to most objects, it is advisable to set parent when
-  # constructing PBXNativeTarget.  A parent of an XCTarget must be a PBXProject
-  # object.  A parent reference is required for a PBXNativeTarget during
-  # construction to be able to set up the target defaults for productReference,
-  # because a PBXBuildFile object must be created for the target and it must
-  # be added to the PBXProject's mainGroup hierarchy.
-  _schema = XCTarget._schema.copy()
-  _schema.update({
-    'buildPhases':      [1, XCBuildPhase,     1, 1,
-                         [PBXSourcesBuildPhase(), PBXFrameworksBuildPhase()]],
-    'buildRules':       [1, PBXBuildRule,     1, 1, []],
-    'productReference': [0, PBXFileReference, 0, 1],
-    'productType':      [0, str,              0, 1],
-  })
-
-  # Mapping from Xcode product-types to settings.  The settings are:
-  #  filetype : used for explicitFileType in the project file
-  #  prefix : the prefix for the file name
-  #  suffix : the suffix for the file name
-  _product_filetypes = {
-    'com.apple.product-type.application':           ['wrapper.application',
-                                                     '', '.app'],
-    'com.apple.product-type.application.watchapp':  ['wrapper.application',
-                                                     '', '.app'],
-    'com.apple.product-type.watchkit-extension':    ['wrapper.app-extension',
-                                                     '', '.appex'],
-    'com.apple.product-type.app-extension':         ['wrapper.app-extension',
-                                                     '', '.appex'],
-    'com.apple.product-type.bundle':            ['wrapper.cfbundle',
-                                                 '', '.bundle'],
-    'com.apple.product-type.framework':         ['wrapper.framework',
-                                                 '', '.framework'],
-    'com.apple.product-type.library.dynamic':   ['compiled.mach-o.dylib',
-                                                 'lib', '.dylib'],
-    'com.apple.product-type.library.static':    ['archive.ar',
-                                                 'lib', '.a'],
-    'com.apple.product-type.tool':              ['compiled.mach-o.executable',
-                                                 '', ''],
-    'com.apple.product-type.bundle.unit-test':  ['wrapper.cfbundle',
-                                                 '', '.xctest'],
-    'com.apple.product-type.bundle.ui-testing':  ['wrapper.cfbundle',
-                                                  '', '.xctest'],
-    'com.googlecode.gyp.xcode.bundle':          ['compiled.mach-o.dylib',
-                                                 '', '.so'],
-    'com.apple.product-type.kernel-extension':  ['wrapper.kext',
-                                                 '', '.kext'],
-  }
-
-  def __init__(self, properties=None, id=None, parent=None,
-               force_outdir=None, force_prefix=None, force_extension=None):
-    # super
-    XCTarget.__init__(self, properties, id, parent)
-
-    if 'productName' in self._properties and \
-       'productType' in self._properties and \
-       not 'productReference' in self._properties and \
-       self._properties['productType'] in self._product_filetypes:
-      products_group = None
-      pbxproject = self.PBXProjectAncestor()
-      if pbxproject != None:
-        products_group = pbxproject.ProductsGroup()
-
-      if products_group != None:
-        (filetype, prefix, suffix) = \
-            self._product_filetypes[self._properties['productType']]
-        # Xcode does not have a distinct type for loadable modules that are
-        # pure BSD targets (not in a bundle wrapper). GYP allows such modules
-        # to be specified by setting a target type to loadable_module without
-        # having mac_bundle set. These are mapped to the pseudo-product type
-        # com.googlecode.gyp.xcode.bundle.
-        #
-        # By picking up this special type and converting it to a dynamic
-        # library (com.apple.product-type.library.dynamic) with fix-ups,
-        # single-file loadable modules can be produced.
-        #
-        # MACH_O_TYPE is changed to mh_bundle to produce the proper file type
-        # (as opposed to mh_dylib). In order for linking to succeed,
-        # DYLIB_CURRENT_VERSION and DYLIB_COMPATIBILITY_VERSION must be
-        # cleared. They are meaningless for type mh_bundle.
-        #
-        # Finally, the .so extension is forcibly applied over the default
-        # (.dylib), unless another forced extension is already selected.
-        # .dylib is plainly wrong, and .bundle is used by loadable_modules in
-        # bundle wrappers (com.apple.product-type.bundle). .so seems an odd
-        # choice because it's used as the extension on many other systems that
-        # don't distinguish between linkable shared libraries and non-linkable
-        # loadable modules, but there's precedent: Python loadable modules on
-        # Mac OS X use an .so extension.
-        if self._properties['productType'] == 'com.googlecode.gyp.xcode.bundle':
-          self._properties['productType'] = \
-              'com.apple.product-type.library.dynamic'
-          self.SetBuildSetting('MACH_O_TYPE', 'mh_bundle')
-          self.SetBuildSetting('DYLIB_CURRENT_VERSION', '')
-          self.SetBuildSetting('DYLIB_COMPATIBILITY_VERSION', '')
-          if force_extension is None:
-            force_extension = suffix[1:]
-
-        if self._properties['productType'] == \
-           'com.apple.product-type-bundle.unit.test' or \
-           self._properties['productType'] == \
-           'com.apple.product-type-bundle.ui-testing':
-          if force_extension is None:
-            force_extension = suffix[1:]
-
-        if force_extension is not None:
-          # If it's a wrapper (bundle), set WRAPPER_EXTENSION.
-          # Extension override.
-          suffix = '.' + force_extension
-          if filetype.startswith('wrapper.'):
-            self.SetBuildSetting('WRAPPER_EXTENSION', force_extension)
-          else:
-            self.SetBuildSetting('EXECUTABLE_EXTENSION', force_extension)
-
-          if filetype.startswith('compiled.mach-o.executable'):
-            product_name = self._properties['productName']
-            product_name += suffix
-            suffix = ''
-            self.SetProperty('productName', product_name)
-            self.SetBuildSetting('PRODUCT_NAME', product_name)
-
-        # Xcode handles most prefixes based on the target type, however there
-        # are exceptions.  If a "BSD Dynamic Library" target is added in the
-        # Xcode UI, Xcode sets EXECUTABLE_PREFIX.  This check duplicates that
-        # behavior.
-        if force_prefix is not None:
-          prefix = force_prefix
-        if filetype.startswith('wrapper.'):
-          self.SetBuildSetting('WRAPPER_PREFIX', prefix)
-        else:
-          self.SetBuildSetting('EXECUTABLE_PREFIX', prefix)
-
-        if force_outdir is not None:
-          self.SetBuildSetting('TARGET_BUILD_DIR', force_outdir)
-
-        # TODO(tvl): Remove the below hack.
-        #    http://code.google.com/p/gyp/issues/detail?id=122
-
-        # Some targets include the prefix in the target_name.  These targets
-        # really should just add a product_name setting that doesn't include
-        # the prefix.  For example:
-        #  target_name = 'libevent', product_name = 'event'
-        # This check cleans up for them.
-        product_name = self._properties['productName']
-        prefix_len = len(prefix)
-        if prefix_len and (product_name[:prefix_len] == prefix):
-          product_name = product_name[prefix_len:]
-          self.SetProperty('productName', product_name)
-          self.SetBuildSetting('PRODUCT_NAME', product_name)
-
-        ref_props = {
-          'explicitFileType': filetype,
-          'includeInIndex':   0,
-          'path':             prefix + product_name + suffix,
-          'sourceTree':       'BUILT_PRODUCTS_DIR',
+    # buildPhases is overridden in the schema to be able to set defaults.
+    #
+    # NOTE: Contrary to most objects, it is advisable to set parent when
+    # constructing PBXNativeTarget.  A parent of an XCTarget must be a PBXProject
+    # object.  A parent reference is required for a PBXNativeTarget during
+    # construction to be able to set up the target defaults for productReference,
+    # because a PBXBuildFile object must be created for the target and it must
+    # be added to the PBXProject's mainGroup hierarchy.
+    _schema = XCTarget._schema.copy()
+    _schema.update(
+        {
+            "buildPhases": [
+                1,
+                XCBuildPhase,
+                1,
+                1,
+                [PBXSourcesBuildPhase(), PBXFrameworksBuildPhase()],
+            ],
+            "buildRules": [1, PBXBuildRule, 1, 1, []],
+            "productReference": [0, PBXFileReference, 0, 1],
+            "productType": [0, str, 0, 1],
         }
-        file_ref = PBXFileReference(ref_props)
-        products_group.AppendChild(file_ref)
-        self.SetProperty('productReference', file_ref)
-
-  def GetBuildPhaseByType(self, type):
-    if not 'buildPhases' in self._properties:
-      return None
-
-    the_phase = None
-    for phase in self._properties['buildPhases']:
-      if isinstance(phase, type):
-        # Some phases may be present in multiples in a well-formed project file,
-        # but phases like PBXSourcesBuildPhase may only be present singly, and
-        # this function is intended as an aid to GetBuildPhaseByType.  Loop
-        # over the entire list of phases and assert if more than one of the
-        # desired type is found.
-        assert the_phase is None
-        the_phase = phase
-
-    return the_phase
-
-  def HeadersPhase(self):
-    headers_phase = self.GetBuildPhaseByType(PBXHeadersBuildPhase)
-    if headers_phase is None:
-      headers_phase = PBXHeadersBuildPhase()
-
-      # The headers phase should come before the resources, sources, and
-      # frameworks phases, if any.
-      insert_at = len(self._properties['buildPhases'])
-      for index in range(0, len(self._properties['buildPhases'])):
-        phase = self._properties['buildPhases'][index]
-        if isinstance(phase, PBXResourcesBuildPhase) or \
-           isinstance(phase, PBXSourcesBuildPhase) or \
-           isinstance(phase, PBXFrameworksBuildPhase):
-          insert_at = index
-          break
-
-      self._properties['buildPhases'].insert(insert_at, headers_phase)
-      headers_phase.parent = self
-
-    return headers_phase
-
-  def ResourcesPhase(self):
-    resources_phase = self.GetBuildPhaseByType(PBXResourcesBuildPhase)
-    if resources_phase is None:
-      resources_phase = PBXResourcesBuildPhase()
-
-      # The resources phase should come before the sources and frameworks
-      # phases, if any.
-      insert_at = len(self._properties['buildPhases'])
-      for index in range(0, len(self._properties['buildPhases'])):
-        phase = self._properties['buildPhases'][index]
-        if isinstance(phase, PBXSourcesBuildPhase) or \
-           isinstance(phase, PBXFrameworksBuildPhase):
-          insert_at = index
-          break
-
-      self._properties['buildPhases'].insert(insert_at, resources_phase)
-      resources_phase.parent = self
-
-    return resources_phase
-
-  def SourcesPhase(self):
-    sources_phase = self.GetBuildPhaseByType(PBXSourcesBuildPhase)
-    if sources_phase is None:
-      sources_phase = PBXSourcesBuildPhase()
-      self.AppendProperty('buildPhases', sources_phase)
-
-    return sources_phase
-
-  def FrameworksPhase(self):
-    frameworks_phase = self.GetBuildPhaseByType(PBXFrameworksBuildPhase)
-    if frameworks_phase is None:
-      frameworks_phase = PBXFrameworksBuildPhase()
-      self.AppendProperty('buildPhases', frameworks_phase)
-
-    return frameworks_phase
-
-  def AddDependency(self, other):
-    # super
-    XCTarget.AddDependency(self, other)
-
-    static_library_type = 'com.apple.product-type.library.static'
-    shared_library_type = 'com.apple.product-type.library.dynamic'
-    framework_type = 'com.apple.product-type.framework'
-    if isinstance(other, PBXNativeTarget) and \
-       'productType' in self._properties and \
-       self._properties['productType'] != static_library_type and \
-       'productType' in other._properties and \
-       (other._properties['productType'] == static_library_type or \
-        ((other._properties['productType'] == shared_library_type or \
-          other._properties['productType'] == framework_type) and \
-         ((not other.HasBuildSetting('MACH_O_TYPE')) or
-          other.GetBuildSetting('MACH_O_TYPE') != 'mh_bundle'))):
-
-      file_ref = other.GetProperty('productReference')
-
-      pbxproject = self.PBXProjectAncestor()
-      other_pbxproject = other.PBXProjectAncestor()
-      if pbxproject != other_pbxproject:
-        other_project_product_group = \
-            pbxproject.AddOrGetProjectReference(other_pbxproject)[0]
-        file_ref = other_project_product_group.GetChildByRemoteObject(file_ref)
-
-      self.FrameworksPhase().AppendProperty('files',
-                                            PBXBuildFile({'fileRef': file_ref}))
+    )
+
+    # Mapping from Xcode product-types to settings.  The settings are:
+    #  filetype : used for explicitFileType in the project file
+    #  prefix : the prefix for the file name
+    #  suffix : the suffix for the file name
+    _product_filetypes = {
+        "com.apple.product-type.application": ["wrapper.application", "", ".app"],
+        "com.apple.product-type.application.watchapp": [
+            "wrapper.application",
+            "",
+            ".app",
+        ],
+        "com.apple.product-type.watchkit-extension": [
+            "wrapper.app-extension",
+            "",
+            ".appex",
+        ],
+        "com.apple.product-type.app-extension": ["wrapper.app-extension", "", ".appex"],
+        "com.apple.product-type.bundle": ["wrapper.cfbundle", "", ".bundle"],
+        "com.apple.product-type.framework": ["wrapper.framework", "", ".framework"],
+        "com.apple.product-type.library.dynamic": [
+            "compiled.mach-o.dylib",
+            "lib",
+            ".dylib",
+        ],
+        "com.apple.product-type.library.static": ["archive.ar", "lib", ".a"],
+        "com.apple.product-type.tool": ["compiled.mach-o.executable", "", ""],
+        "com.apple.product-type.bundle.unit-test": ["wrapper.cfbundle", "", ".xctest"],
+        "com.apple.product-type.bundle.ui-testing": ["wrapper.cfbundle", "", ".xctest"],
+        "com.googlecode.gyp.xcode.bundle": ["compiled.mach-o.dylib", "", ".so"],
+        "com.apple.product-type.kernel-extension": ["wrapper.kext", "", ".kext"],
+    }
+
+    def __init__(
+        self,
+        properties=None,
+        id=None,
+        parent=None,
+        force_outdir=None,
+        force_prefix=None,
+        force_extension=None,
+    ):
+        # super
+        XCTarget.__init__(self, properties, id, parent)
+
+        if (
+            "productName" in self._properties
+            and "productType" in self._properties
+            and "productReference" not in self._properties
+            and self._properties["productType"] in self._product_filetypes
+        ):
+            products_group = None
+            pbxproject = self.PBXProjectAncestor()
+            if pbxproject is not None:
+                products_group = pbxproject.ProductsGroup()
+
+            if products_group is not None:
+                (filetype, prefix, suffix) = self._product_filetypes[
+                    self._properties["productType"]
+                ]
+                # Xcode does not have a distinct type for loadable modules that are
+                # pure BSD targets (not in a bundle wrapper). GYP allows such modules
+                # to be specified by setting a target type to loadable_module without
+                # having mac_bundle set. These are mapped to the pseudo-product type
+                # com.googlecode.gyp.xcode.bundle.
+                #
+                # By picking up this special type and converting it to a dynamic
+                # library (com.apple.product-type.library.dynamic) with fix-ups,
+                # single-file loadable modules can be produced.
+                #
+                # MACH_O_TYPE is changed to mh_bundle to produce the proper file type
+                # (as opposed to mh_dylib). In order for linking to succeed,
+                # DYLIB_CURRENT_VERSION and DYLIB_COMPATIBILITY_VERSION must be
+                # cleared. They are meaningless for type mh_bundle.
+                #
+                # Finally, the .so extension is forcibly applied over the default
+                # (.dylib), unless another forced extension is already selected.
+                # .dylib is plainly wrong, and .bundle is used by loadable_modules in
+                # bundle wrappers (com.apple.product-type.bundle). .so seems an odd
+                # choice because it's used as the extension on many other systems that
+                # don't distinguish between linkable shared libraries and non-linkable
+                # loadable modules, but there's precedent: Python loadable modules on
+                # Mac OS X use an .so extension.
+                if self._properties["productType"] == "com.googlecode.gyp.xcode.bundle":
+                    self._properties[
+                        "productType"
+                    ] = "com.apple.product-type.library.dynamic"
+                    self.SetBuildSetting("MACH_O_TYPE", "mh_bundle")
+                    self.SetBuildSetting("DYLIB_CURRENT_VERSION", "")
+                    self.SetBuildSetting("DYLIB_COMPATIBILITY_VERSION", "")
+                    if force_extension is None:
+                        force_extension = suffix[1:]
+
+                if (
+                    self._properties["productType"]
+                    == "com.apple.product-type-bundle.unit.test"
+                    or self._properties["productType"]
+                    == "com.apple.product-type-bundle.ui-testing"
+                ):
+                    if force_extension is None:
+                        force_extension = suffix[1:]
+
+                if force_extension is not None:
+                    # If it's a wrapper (bundle), set WRAPPER_EXTENSION.
+                    # Extension override.
+                    suffix = "." + force_extension
+                    if filetype.startswith("wrapper."):
+                        self.SetBuildSetting("WRAPPER_EXTENSION", force_extension)
+                    else:
+                        self.SetBuildSetting("EXECUTABLE_EXTENSION", force_extension)
+
+                    if filetype.startswith("compiled.mach-o.executable"):
+                        product_name = self._properties["productName"]
+                        product_name += suffix
+                        suffix = ""
+                        self.SetProperty("productName", product_name)
+                        self.SetBuildSetting("PRODUCT_NAME", product_name)
+
+                # Xcode handles most prefixes based on the target type, however there
+                # are exceptions.  If a "BSD Dynamic Library" target is added in the
+                # Xcode UI, Xcode sets EXECUTABLE_PREFIX.  This check duplicates that
+                # behavior.
+                if force_prefix is not None:
+                    prefix = force_prefix
+                if filetype.startswith("wrapper."):
+                    self.SetBuildSetting("WRAPPER_PREFIX", prefix)
+                else:
+                    self.SetBuildSetting("EXECUTABLE_PREFIX", prefix)
+
+                if force_outdir is not None:
+                    self.SetBuildSetting("TARGET_BUILD_DIR", force_outdir)
+
+                # TODO(tvl): Remove the below hack.
+                #    http://code.google.com/p/gyp/issues/detail?id=122
+
+                # Some targets include the prefix in the target_name.  These targets
+                # really should just add a product_name setting that doesn't include
+                # the prefix.  For example:
+                #  target_name = 'libevent', product_name = 'event'
+                # This check cleans up for them.
+                product_name = self._properties["productName"]
+                prefix_len = len(prefix)
+                if prefix_len and (product_name[:prefix_len] == prefix):
+                    product_name = product_name[prefix_len:]
+                    self.SetProperty("productName", product_name)
+                    self.SetBuildSetting("PRODUCT_NAME", product_name)
+
+                ref_props = {
+                    "explicitFileType": filetype,
+                    "includeInIndex": 0,
+                    "path": prefix + product_name + suffix,
+                    "sourceTree": "BUILT_PRODUCTS_DIR",
+                }
+                file_ref = PBXFileReference(ref_props)
+                products_group.AppendChild(file_ref)
+                self.SetProperty("productReference", file_ref)
+
+    def GetBuildPhaseByType(self, type):
+        if "buildPhases" not in self._properties:
+            return None
+
+        the_phase = None
+        for phase in self._properties["buildPhases"]:
+            if isinstance(phase, type):
+                # Some phases may be present in multiples in a well-formed project file,
+                # but phases like PBXSourcesBuildPhase may only be present singly, and
+                # this function is intended as an aid to GetBuildPhaseByType.  Loop
+                # over the entire list of phases and assert if more than one of the
+                # desired type is found.
+                assert the_phase is None
+                the_phase = phase
+
+        return the_phase
+
+    def HeadersPhase(self):
+        headers_phase = self.GetBuildPhaseByType(PBXHeadersBuildPhase)
+        if headers_phase is None:
+            headers_phase = PBXHeadersBuildPhase()
+
+            # The headers phase should come before the resources, sources, and
+            # frameworks phases, if any.
+            insert_at = len(self._properties["buildPhases"])
+            for index, phase in enumerate(self._properties["buildPhases"]):
+                if (
+                    isinstance(phase, PBXResourcesBuildPhase)
+                    or isinstance(phase, PBXSourcesBuildPhase)
+                    or isinstance(phase, PBXFrameworksBuildPhase)
+                ):
+                    insert_at = index
+                    break
+
+            self._properties["buildPhases"].insert(insert_at, headers_phase)
+            headers_phase.parent = self
+
+        return headers_phase
+
+    def ResourcesPhase(self):
+        resources_phase = self.GetBuildPhaseByType(PBXResourcesBuildPhase)
+        if resources_phase is None:
+            resources_phase = PBXResourcesBuildPhase()
+
+            # The resources phase should come before the sources and frameworks
+            # phases, if any.
+            insert_at = len(self._properties["buildPhases"])
+            for index, phase in enumerate(self._properties["buildPhases"]):
+                if isinstance(phase, PBXSourcesBuildPhase) or isinstance(
+                    phase, PBXFrameworksBuildPhase
+                ):
+                    insert_at = index
+                    break
+
+            self._properties["buildPhases"].insert(insert_at, resources_phase)
+            resources_phase.parent = self
+
+        return resources_phase
+
+    def SourcesPhase(self):
+        sources_phase = self.GetBuildPhaseByType(PBXSourcesBuildPhase)
+        if sources_phase is None:
+            sources_phase = PBXSourcesBuildPhase()
+            self.AppendProperty("buildPhases", sources_phase)
+
+        return sources_phase
+
+    def FrameworksPhase(self):
+        frameworks_phase = self.GetBuildPhaseByType(PBXFrameworksBuildPhase)
+        if frameworks_phase is None:
+            frameworks_phase = PBXFrameworksBuildPhase()
+            self.AppendProperty("buildPhases", frameworks_phase)
+
+        return frameworks_phase
+
+    def AddDependency(self, other):
+        # super
+        XCTarget.AddDependency(self, other)
+
+        static_library_type = "com.apple.product-type.library.static"
+        shared_library_type = "com.apple.product-type.library.dynamic"
+        framework_type = "com.apple.product-type.framework"
+        if (
+            isinstance(other, PBXNativeTarget)
+            and "productType" in self._properties
+            and self._properties["productType"] != static_library_type
+            and "productType" in other._properties
+            and (
+                other._properties["productType"] == static_library_type
+                or (
+                    (
+                        other._properties["productType"] == shared_library_type
+                        or other._properties["productType"] == framework_type
+                    )
+                    and (
+                        (not other.HasBuildSetting("MACH_O_TYPE"))
+                        or other.GetBuildSetting("MACH_O_TYPE") != "mh_bundle"
+                    )
+                )
+            )
+        ):
+
+            file_ref = other.GetProperty("productReference")
+
+            pbxproject = self.PBXProjectAncestor()
+            other_pbxproject = other.PBXProjectAncestor()
+            if pbxproject != other_pbxproject:
+                other_project_product_group = pbxproject.AddOrGetProjectReference(
+                    other_pbxproject
+                )[0]
+                file_ref = other_project_product_group.GetChildByRemoteObject(file_ref)
+
+            self.FrameworksPhase().AppendProperty(
+                "files", PBXBuildFile({"fileRef": file_ref})
+            )
 
 
 class PBXAggregateTarget(XCTarget):
-  pass
+    pass
 
 
 class PBXProject(XCContainerPortal):
-  # A PBXProject is really just an XCObject, the XCContainerPortal thing is
-  # just to allow PBXProject to be used in the containerPortal property of
-  # PBXContainerItemProxy.
-  """
+    # A PBXProject is really just an XCObject, the XCContainerPortal thing is
+    # just to allow PBXProject to be used in the containerPortal property of
+    # PBXContainerItemProxy.
+    """
 
   Attributes:
     path: "sample.xcodeproj".  TODO(mark) Document me!
@@ -2560,91 +2745,98 @@ class PBXProject(XCContainerPortal):
                         PBXProject.
   """
 
-  _schema = XCContainerPortal._schema.copy()
-  _schema.update({
-    'attributes':             [0, dict,                0, 0],
-    'buildConfigurationList': [0, XCConfigurationList, 1, 1,
-                               XCConfigurationList()],
-    'compatibilityVersion':   [0, str,                 0, 1, 'Xcode 3.2'],
-    'hasScannedForEncodings': [0, int,                 0, 1, 1],
-    'mainGroup':              [0, PBXGroup,            1, 1, PBXGroup()],
-    'projectDirPath':         [0, str,                 0, 1, ''],
-    'projectReferences':      [1, dict,                0, 0],
-    'projectRoot':            [0, str,                 0, 1, ''],
-    'targets':                [1, XCTarget,            1, 1, []],
-  })
-
-  def __init__(self, properties=None, id=None, parent=None, path=None):
-    self.path = path
-    self._other_pbxprojects = {}
-    # super
-    return XCContainerPortal.__init__(self, properties, id, parent)
+    _schema = XCContainerPortal._schema.copy()
+    _schema.update(
+        {
+            "attributes": [0, dict, 0, 0],
+            "buildConfigurationList": [
+                0,
+                XCConfigurationList,
+                1,
+                1,
+                XCConfigurationList(),
+            ],
+            "compatibilityVersion": [0, str, 0, 1, "Xcode 3.2"],
+            "hasScannedForEncodings": [0, int, 0, 1, 1],
+            "mainGroup": [0, PBXGroup, 1, 1, PBXGroup()],
+            "projectDirPath": [0, str, 0, 1, ""],
+            "projectReferences": [1, dict, 0, 0],
+            "projectRoot": [0, str, 0, 1, ""],
+            "targets": [1, XCTarget, 1, 1, []],
+        }
+    )
 
-  def Name(self):
-    name = self.path
-    if name[-10:] == '.xcodeproj':
-      name = name[:-10]
-    return posixpath.basename(name)
+    def __init__(self, properties=None, id=None, parent=None, path=None):
+        self.path = path
+        self._other_pbxprojects = {}
+        # super
+        return XCContainerPortal.__init__(self, properties, id, parent)
 
-  def Path(self):
-    return self.path
+    def Name(self):
+        name = self.path
+        if name[-10:] == ".xcodeproj":
+            name = name[:-10]
+        return posixpath.basename(name)
 
-  def Comment(self):
-    return 'Project object'
+    def Path(self):
+        return self.path
 
-  def Children(self):
-    # super
-    children = XCContainerPortal.Children(self)
+    def Comment(self):
+        return "Project object"
+
+    def Children(self):
+        # super
+        children = XCContainerPortal.Children(self)
 
-    # Add children that the schema doesn't know about.  Maybe there's a more
-    # elegant way around this, but this is the only case where we need to own
-    # objects in a dictionary (that is itself in a list), and three lines for
-    # a one-off isn't that big a deal.
-    if 'projectReferences' in self._properties:
-      for reference in self._properties['projectReferences']:
-        children.append(reference['ProductGroup'])
+        # Add children that the schema doesn't know about.  Maybe there's a more
+        # elegant way around this, but this is the only case where we need to own
+        # objects in a dictionary (that is itself in a list), and three lines for
+        # a one-off isn't that big a deal.
+        if "projectReferences" in self._properties:
+            for reference in self._properties["projectReferences"]:
+                children.append(reference["ProductGroup"])
 
-    return children
+        return children
 
-  def PBXProjectAncestor(self):
-    return self
+    def PBXProjectAncestor(self):
+        return self
 
-  def _GroupByName(self, name):
-    if not 'mainGroup' in self._properties:
-      self.SetProperty('mainGroup', PBXGroup())
+    def _GroupByName(self, name):
+        if "mainGroup" not in self._properties:
+            self.SetProperty("mainGroup", PBXGroup())
 
-    main_group = self._properties['mainGroup']
-    group = main_group.GetChildByName(name)
-    if group is None:
-      group = PBXGroup({'name': name})
-      main_group.AppendChild(group)
+        main_group = self._properties["mainGroup"]
+        group = main_group.GetChildByName(name)
+        if group is None:
+            group = PBXGroup({"name": name})
+            main_group.AppendChild(group)
 
-    return group
+        return group
 
-  # SourceGroup and ProductsGroup are created by default in Xcode's own
-  # templates.
-  def SourceGroup(self):
-    return self._GroupByName('Source')
+    # SourceGroup and ProductsGroup are created by default in Xcode's own
+    # templates.
+    def SourceGroup(self):
+        return self._GroupByName("Source")
 
-  def ProductsGroup(self):
-    return self._GroupByName('Products')
+    def ProductsGroup(self):
+        return self._GroupByName("Products")
 
-  # IntermediatesGroup is used to collect source-like files that are generated
-  # by rules or script phases and are placed in intermediate directories such
-  # as DerivedSources.
-  def IntermediatesGroup(self):
-    return self._GroupByName('Intermediates')
+    # IntermediatesGroup is used to collect source-like files that are generated
+    # by rules or script phases and are placed in intermediate directories such
+    # as DerivedSources.
+    def IntermediatesGroup(self):
+        return self._GroupByName("Intermediates")
 
-  # FrameworksGroup and ProjectsGroup are top-level groups used to collect
-  # frameworks and projects.
-  def FrameworksGroup(self):
-    return self._GroupByName('Frameworks')
+    # FrameworksGroup and ProjectsGroup are top-level groups used to collect
+    # frameworks and projects.
+    def FrameworksGroup(self):
+        return self._GroupByName("Frameworks")
 
-  def ProjectsGroup(self):
-    return self._GroupByName('Projects')
+    def ProjectsGroup(self):
+        return self._GroupByName("Projects")
 
-  def RootGroupForPath(self, path):
-    """Returns a PBXGroup child of this object to which path should be added.
+    def RootGroupForPath(self, path):
+        """Returns a PBXGroup child of this object to which path should be added.
 
     This method is intended to choose between SourceGroup and
     IntermediatesGroup on the basis of whether path is present in a source
@@ -2658,83 +2850,84 @@ class PBXProject(XCContainerPortal):
     organized hierarchically (True) or as a single flat list (False).
     """
 
-    # TODO(mark): make this a class variable and bind to self on call?
-    # Also, this list is nowhere near exhaustive.
-    # INTERMEDIATE_DIR and SHARED_INTERMEDIATE_DIR are used by
-    # gyp.generator.xcode.  There should probably be some way for that module
-    # to push the names in, rather than having to hard-code them here.
-    source_tree_groups = {
-      'DERIVED_FILE_DIR':         (self.IntermediatesGroup, True),
-      'INTERMEDIATE_DIR':         (self.IntermediatesGroup, True),
-      'PROJECT_DERIVED_FILE_DIR': (self.IntermediatesGroup, True),
-      'SHARED_INTERMEDIATE_DIR':  (self.IntermediatesGroup, True),
-    }
+        # TODO(mark): make this a class variable and bind to self on call?
+        # Also, this list is nowhere near exhaustive.
+        # INTERMEDIATE_DIR and SHARED_INTERMEDIATE_DIR are used by
+        # gyp.generator.xcode.  There should probably be some way for that module
+        # to push the names in, rather than having to hard-code them here.
+        source_tree_groups = {
+            "DERIVED_FILE_DIR": (self.IntermediatesGroup, True),
+            "INTERMEDIATE_DIR": (self.IntermediatesGroup, True),
+            "PROJECT_DERIVED_FILE_DIR": (self.IntermediatesGroup, True),
+            "SHARED_INTERMEDIATE_DIR": (self.IntermediatesGroup, True),
+        }
 
-    (source_tree, path) = SourceTreeAndPathFromPath(path)
-    if source_tree != None and source_tree in source_tree_groups:
-      (group_func, hierarchical) = source_tree_groups[source_tree]
-      group = group_func()
-      return (group, hierarchical)
+        (source_tree, path) = SourceTreeAndPathFromPath(path)
+        if source_tree is not None and source_tree in source_tree_groups:
+            (group_func, hierarchical) = source_tree_groups[source_tree]
+            group = group_func()
+            return (group, hierarchical)
 
-    # TODO(mark): make additional choices based on file extension.
+        # TODO(mark): make additional choices based on file extension.
 
-    return (self.SourceGroup(), True)
+        return (self.SourceGroup(), True)
 
-  def AddOrGetFileInRootGroup(self, path):
-    """Returns a PBXFileReference corresponding to path in the correct group
+    def AddOrGetFileInRootGroup(self, path):
+        """Returns a PBXFileReference corresponding to path in the correct group
     according to RootGroupForPath's heuristics.
 
     If an existing PBXFileReference for path exists, it will be returned.
     Otherwise, one will be created and returned.
     """
 
-    (group, hierarchical) = self.RootGroupForPath(path)
-    return group.AddOrGetFileByPath(path, hierarchical)
-
-  def RootGroupsTakeOverOnlyChildren(self, recurse=False):
-    """Calls TakeOverOnlyChild for all groups in the main group."""
-
-    for group in self._properties['mainGroup']._properties['children']:
-      if isinstance(group, PBXGroup):
-        group.TakeOverOnlyChild(recurse)
-
-  def SortGroups(self):
-    # Sort the children of the mainGroup (like "Source" and "Products")
-    # according to their defined order.
-    self._properties['mainGroup']._properties['children'] = \
-        sorted(self._properties['mainGroup']._properties['children'],
-               cmp=lambda x,y: x.CompareRootGroup(y))
-
-    # Sort everything else by putting group before files, and going
-    # alphabetically by name within sections of groups and files.  SortGroup
-    # is recursive.
-    for group in self._properties['mainGroup']._properties['children']:
-      if not isinstance(group, PBXGroup):
-        continue
-
-      if group.Name() == 'Products':
-        # The Products group is a special case.  Instead of sorting
-        # alphabetically, sort things in the order of the targets that
-        # produce the products.  To do this, just build up a new list of
-        # products based on the targets.
-        products = []
-        for target in self._properties['targets']:
-          if not isinstance(target, PBXNativeTarget):
-            continue
-          product = target._properties['productReference']
-          # Make sure that the product is already in the products group.
-          assert product in group._properties['children']
-          products.append(product)
-
-        # Make sure that this process doesn't miss anything that was already
-        # in the products group.
-        assert len(products) == len(group._properties['children'])
-        group._properties['children'] = products
-      else:
-        group.SortGroup()
-
-  def AddOrGetProjectReference(self, other_pbxproject):
-    """Add a reference to another project file (via PBXProject object) to this
+        (group, hierarchical) = self.RootGroupForPath(path)
+        return group.AddOrGetFileByPath(path, hierarchical)
+
+    def RootGroupsTakeOverOnlyChildren(self, recurse=False):
+        """Calls TakeOverOnlyChild for all groups in the main group."""
+
+        for group in self._properties["mainGroup"]._properties["children"]:
+            if isinstance(group, PBXGroup):
+                group.TakeOverOnlyChild(recurse)
+
+    def SortGroups(self):
+        # Sort the children of the mainGroup (like "Source" and "Products")
+        # according to their defined order.
+        self._properties["mainGroup"]._properties["children"] = sorted(
+            self._properties["mainGroup"]._properties["children"],
+            cmp=lambda x, y: x.CompareRootGroup(y),
+        )
+
+        # Sort everything else by putting group before files, and going
+        # alphabetically by name within sections of groups and files.  SortGroup
+        # is recursive.
+        for group in self._properties["mainGroup"]._properties["children"]:
+            if not isinstance(group, PBXGroup):
+                continue
+
+            if group.Name() == "Products":
+                # The Products group is a special case.  Instead of sorting
+                # alphabetically, sort things in the order of the targets that
+                # produce the products.  To do this, just build up a new list of
+                # products based on the targets.
+                products = []
+                for target in self._properties["targets"]:
+                    if not isinstance(target, PBXNativeTarget):
+                        continue
+                    product = target._properties["productReference"]
+                    # Make sure that the product is already in the products group.
+                    assert product in group._properties["children"]
+                    products.append(product)
+
+                # Make sure that this process doesn't miss anything that was already
+                # in the products group.
+                assert len(products) == len(group._properties["children"])
+                group._properties["children"] = products
+            else:
+                group.SortGroup()
+
+    def AddOrGetProjectReference(self, other_pbxproject):
+        """Add a reference to another project file (via PBXProject object) to this
     one.
 
     Returns [ProductGroup, ProjectRef].  ProductGroup is a PBXGroup object in
@@ -2747,243 +2940,259 @@ class PBXProject(XCContainerPortal):
     still be updated if necessary.
     """
 
-    if not 'projectReferences' in self._properties:
-      self._properties['projectReferences'] = []
-
-    product_group = None
-    project_ref = None
-
-    if not other_pbxproject in self._other_pbxprojects:
-      # This project file isn't yet linked to the other one.  Establish the
-      # link.
-      product_group = PBXGroup({'name': 'Products'})
-
-      # ProductGroup is strong.
-      product_group.parent = self
-
-      # There's nothing unique about this PBXGroup, and if left alone, it will
-      # wind up with the same set of hashables as all other PBXGroup objects
-      # owned by the projectReferences list.  Add the hashables of the
-      # remote PBXProject that it's related to.
-      product_group._hashables.extend(other_pbxproject.Hashables())
-
-      # The other project reports its path as relative to the same directory
-      # that this project's path is relative to.  The other project's path
-      # is not necessarily already relative to this project.  Figure out the
-      # pathname that this project needs to use to refer to the other one.
-      this_path = posixpath.dirname(self.Path())
-      projectDirPath = self.GetProperty('projectDirPath')
-      if projectDirPath:
-        if posixpath.isabs(projectDirPath[0]):
-          this_path = projectDirPath
+        if "projectReferences" not in self._properties:
+            self._properties["projectReferences"] = []
+
+        product_group = None
+        project_ref = None
+
+        if other_pbxproject not in self._other_pbxprojects:
+            # This project file isn't yet linked to the other one.  Establish the
+            # link.
+            product_group = PBXGroup({"name": "Products"})
+
+            # ProductGroup is strong.
+            product_group.parent = self
+
+            # There's nothing unique about this PBXGroup, and if left alone, it will
+            # wind up with the same set of hashables as all other PBXGroup objects
+            # owned by the projectReferences list.  Add the hashables of the
+            # remote PBXProject that it's related to.
+            product_group._hashables.extend(other_pbxproject.Hashables())
+
+            # The other project reports its path as relative to the same directory
+            # that this project's path is relative to.  The other project's path
+            # is not necessarily already relative to this project.  Figure out the
+            # pathname that this project needs to use to refer to the other one.
+            this_path = posixpath.dirname(self.Path())
+            projectDirPath = self.GetProperty("projectDirPath")
+            if projectDirPath:
+                if posixpath.isabs(projectDirPath[0]):
+                    this_path = projectDirPath
+                else:
+                    this_path = posixpath.join(this_path, projectDirPath)
+            other_path = gyp.common.RelativePath(other_pbxproject.Path(), this_path)
+
+            # ProjectRef is weak (it's owned by the mainGroup hierarchy).
+            project_ref = PBXFileReference(
+                {
+                    "lastKnownFileType": "wrapper.pb-project",
+                    "path": other_path,
+                    "sourceTree": "SOURCE_ROOT",
+                }
+            )
+            self.ProjectsGroup().AppendChild(project_ref)
+
+            ref_dict = {"ProductGroup": product_group, "ProjectRef": project_ref}
+            self._other_pbxprojects[other_pbxproject] = ref_dict
+            self.AppendProperty("projectReferences", ref_dict)
+
+            # Xcode seems to sort this list case-insensitively
+            self._properties["projectReferences"] = sorted(
+                self._properties["projectReferences"],
+                cmp=lambda x, y: cmp(
+                    x["ProjectRef"].Name().lower(), y["ProjectRef"].Name().lower()
+                ),
+            )
         else:
-          this_path = posixpath.join(this_path, projectDirPath)
-      other_path = gyp.common.RelativePath(other_pbxproject.Path(), this_path)
-
-      # ProjectRef is weak (it's owned by the mainGroup hierarchy).
-      project_ref = PBXFileReference({
-            'lastKnownFileType': 'wrapper.pb-project',
-            'path':              other_path,
-            'sourceTree':        'SOURCE_ROOT',
-          })
-      self.ProjectsGroup().AppendChild(project_ref)
-
-      ref_dict = {'ProductGroup': product_group, 'ProjectRef': project_ref}
-      self._other_pbxprojects[other_pbxproject] = ref_dict
-      self.AppendProperty('projectReferences', ref_dict)
-
-      # Xcode seems to sort this list case-insensitively
-      self._properties['projectReferences'] = \
-          sorted(self._properties['projectReferences'], cmp=lambda x,y:
-                 cmp(x['ProjectRef'].Name().lower(),
-                     y['ProjectRef'].Name().lower()))
-    else:
-      # The link already exists.  Pull out the relevnt data.
-      project_ref_dict = self._other_pbxprojects[other_pbxproject]
-      product_group = project_ref_dict['ProductGroup']
-      project_ref = project_ref_dict['ProjectRef']
-
-    self._SetUpProductReferences(other_pbxproject, product_group, project_ref)
-
-    inherit_unique_symroot = self._AllSymrootsUnique(other_pbxproject, False)
-    targets = other_pbxproject.GetProperty('targets')
-    if all(self._AllSymrootsUnique(t, inherit_unique_symroot) for t in targets):
-      dir_path = project_ref._properties['path']
-      product_group._hashables.extend(dir_path)
-
-    return [product_group, project_ref]
-
-  def _AllSymrootsUnique(self, target, inherit_unique_symroot):
-    # Returns True if all configurations have a unique 'SYMROOT' attribute.
-    # The value of inherit_unique_symroot decides, if a configuration is assumed
-    # to inherit a unique 'SYMROOT' attribute from its parent, if it doesn't
-    # define an explicit value for 'SYMROOT'.
-    symroots = self._DefinedSymroots(target)
-    for s in self._DefinedSymroots(target):
-      if (s is not None and not self._IsUniqueSymrootForTarget(s) or
-          s is None and not inherit_unique_symroot):
+            # The link already exists.  Pull out the relevnt data.
+            project_ref_dict = self._other_pbxprojects[other_pbxproject]
+            product_group = project_ref_dict["ProductGroup"]
+            project_ref = project_ref_dict["ProjectRef"]
+
+        self._SetUpProductReferences(other_pbxproject, product_group, project_ref)
+
+        inherit_unique_symroot = self._AllSymrootsUnique(other_pbxproject, False)
+        targets = other_pbxproject.GetProperty("targets")
+        if all(self._AllSymrootsUnique(t, inherit_unique_symroot) for t in targets):
+            dir_path = project_ref._properties["path"]
+            product_group._hashables.extend(dir_path)
+
+        return [product_group, project_ref]
+
+    def _AllSymrootsUnique(self, target, inherit_unique_symroot):
+        # Returns True if all configurations have a unique 'SYMROOT' attribute.
+        # The value of inherit_unique_symroot decides, if a configuration is assumed
+        # to inherit a unique 'SYMROOT' attribute from its parent, if it doesn't
+        # define an explicit value for 'SYMROOT'.
+        symroots = self._DefinedSymroots(target)
+        for s in self._DefinedSymroots(target):
+            if (
+                s is not None
+                and not self._IsUniqueSymrootForTarget(s)
+                or s is None
+                and not inherit_unique_symroot
+            ):
+                return False
+        return True if symroots else inherit_unique_symroot
+
+    def _DefinedSymroots(self, target):
+        # Returns all values for the 'SYMROOT' attribute defined in all
+        # configurations for this target. If any configuration doesn't define the
+        # 'SYMROOT' attribute, None is added to the returned set. If all
+        # configurations don't define the 'SYMROOT' attribute, an empty set is
+        # returned.
+        config_list = target.GetProperty("buildConfigurationList")
+        symroots = set()
+        for config in config_list.GetProperty("buildConfigurations"):
+            setting = config.GetProperty("buildSettings")
+            if "SYMROOT" in setting:
+                symroots.add(setting["SYMROOT"])
+            else:
+                symroots.add(None)
+        if len(symroots) == 1 and None in symroots:
+            return set()
+        return symroots
+
+    def _IsUniqueSymrootForTarget(self, symroot):
+        # This method returns True if all configurations in target contain a
+        # 'SYMROOT' attribute that is unique for the given target. A value is
+        # unique, if the Xcode macro '$SRCROOT' appears in it in any form.
+        uniquifier = ["$SRCROOT", "$(SRCROOT)"]
+        if any(x in symroot for x in uniquifier):
+            return True
         return False
-    return True if symroots else inherit_unique_symroot
-
-  def _DefinedSymroots(self, target):
-    # Returns all values for the 'SYMROOT' attribute defined in all
-    # configurations for this target. If any configuration doesn't define the
-    # 'SYMROOT' attribute, None is added to the returned set. If all
-    # configurations don't define the 'SYMROOT' attribute, an empty set is
-    # returned.
-    config_list = target.GetProperty('buildConfigurationList')
-    symroots = set()
-    for config in config_list.GetProperty('buildConfigurations'):
-      setting = config.GetProperty('buildSettings')
-      if 'SYMROOT' in setting:
-        symroots.add(setting['SYMROOT'])
-      else:
-        symroots.add(None)
-    if len(symroots) == 1 and None in symroots:
-      return set()
-    return symroots
-
-  def _IsUniqueSymrootForTarget(self, symroot):
-    # This method returns True if all configurations in target contain a
-    # 'SYMROOT' attribute that is unique for the given target. A value is
-    # unique, if the Xcode macro '$SRCROOT' appears in it in any form.
-    uniquifier = ['$SRCROOT', '$(SRCROOT)']
-    if any(x in symroot for x in uniquifier):
-      return True
-    return False
-
-  def _SetUpProductReferences(self, other_pbxproject, product_group,
-                              project_ref):
-    # TODO(mark): This only adds references to products in other_pbxproject
-    # when they don't exist in this pbxproject.  Perhaps it should also
-    # remove references from this pbxproject that are no longer present in
-    # other_pbxproject.  Perhaps it should update various properties if they
-    # change.
-    for target in other_pbxproject._properties['targets']:
-      if not isinstance(target, PBXNativeTarget):
-        continue
-
-      other_fileref = target._properties['productReference']
-      if product_group.GetChildByRemoteObject(other_fileref) is None:
-        # Xcode sets remoteInfo to the name of the target and not the name
-        # of its product, despite this proxy being a reference to the product.
-        container_item = PBXContainerItemProxy({
-              'containerPortal':      project_ref,
-              'proxyType':            2,
-              'remoteGlobalIDString': other_fileref,
-              'remoteInfo':           target.Name()
-            })
-        # TODO(mark): Does sourceTree get copied straight over from the other
-        # project?  Can the other project ever have lastKnownFileType here
-        # instead of explicitFileType?  (Use it if so?)  Can path ever be
-        # unset?  (I don't think so.)  Can other_fileref have name set, and
-        # does it impact the PBXReferenceProxy if so?  These are the questions
-        # that perhaps will be answered one day.
-        reference_proxy = PBXReferenceProxy({
-              'fileType':   other_fileref._properties['explicitFileType'],
-              'path':       other_fileref._properties['path'],
-              'sourceTree': other_fileref._properties['sourceTree'],
-              'remoteRef':  container_item,
-            })
-
-        product_group.AppendChild(reference_proxy)
-
-  def SortRemoteProductReferences(self):
-    # For each remote project file, sort the associated ProductGroup in the
-    # same order that the targets are sorted in the remote project file.  This
-    # is the sort order used by Xcode.
-
-    def CompareProducts(x, y, remote_products):
-      # x and y are PBXReferenceProxy objects.  Go through their associated
-      # PBXContainerItem to get the remote PBXFileReference, which will be
-      # present in the remote_products list.
-      x_remote = x._properties['remoteRef']._properties['remoteGlobalIDString']
-      y_remote = y._properties['remoteRef']._properties['remoteGlobalIDString']
-      x_index = remote_products.index(x_remote)
-      y_index = remote_products.index(y_remote)
-
-      # Use the order of each remote PBXFileReference in remote_products to
-      # determine the sort order.
-      return cmp(x_index, y_index)
-
-    for other_pbxproject, ref_dict in self._other_pbxprojects.items():
-      # Build up a list of products in the remote project file, ordered the
-      # same as the targets that produce them.
-      remote_products = []
-      for target in other_pbxproject._properties['targets']:
-        if not isinstance(target, PBXNativeTarget):
-          continue
-        remote_products.append(target._properties['productReference'])
-
-      # Sort the PBXReferenceProxy children according to the list of remote
-      # products.
-      product_group = ref_dict['ProductGroup']
-      product_group._properties['children'] = sorted(
-          product_group._properties['children'],
-          cmp=lambda x, y, rp=remote_products: CompareProducts(x, y, rp))
+
+    def _SetUpProductReferences(self, other_pbxproject, product_group, project_ref):
+        # TODO(mark): This only adds references to products in other_pbxproject
+        # when they don't exist in this pbxproject.  Perhaps it should also
+        # remove references from this pbxproject that are no longer present in
+        # other_pbxproject.  Perhaps it should update various properties if they
+        # change.
+        for target in other_pbxproject._properties["targets"]:
+            if not isinstance(target, PBXNativeTarget):
+                continue
+
+            other_fileref = target._properties["productReference"]
+            if product_group.GetChildByRemoteObject(other_fileref) is None:
+                # Xcode sets remoteInfo to the name of the target and not the name
+                # of its product, despite this proxy being a reference to the product.
+                container_item = PBXContainerItemProxy(
+                    {
+                        "containerPortal": project_ref,
+                        "proxyType": 2,
+                        "remoteGlobalIDString": other_fileref,
+                        "remoteInfo": target.Name(),
+                    }
+                )
+                # TODO(mark): Does sourceTree get copied straight over from the other
+                # project?  Can the other project ever have lastKnownFileType here
+                # instead of explicitFileType?  (Use it if so?)  Can path ever be
+                # unset?  (I don't think so.)  Can other_fileref have name set, and
+                # does it impact the PBXReferenceProxy if so?  These are the questions
+                # that perhaps will be answered one day.
+                reference_proxy = PBXReferenceProxy(
+                    {
+                        "fileType": other_fileref._properties["explicitFileType"],
+                        "path": other_fileref._properties["path"],
+                        "sourceTree": other_fileref._properties["sourceTree"],
+                        "remoteRef": container_item,
+                    }
+                )
+
+                product_group.AppendChild(reference_proxy)
+
+    def SortRemoteProductReferences(self):
+        # For each remote project file, sort the associated ProductGroup in the
+        # same order that the targets are sorted in the remote project file.  This
+        # is the sort order used by Xcode.
+
+        def CompareProducts(x, y, remote_products):
+            # x and y are PBXReferenceProxy objects.  Go through their associated
+            # PBXContainerItem to get the remote PBXFileReference, which will be
+            # present in the remote_products list.
+            x_remote = x._properties["remoteRef"]._properties["remoteGlobalIDString"]
+            y_remote = y._properties["remoteRef"]._properties["remoteGlobalIDString"]
+            x_index = remote_products.index(x_remote)
+            y_index = remote_products.index(y_remote)
+
+            # Use the order of each remote PBXFileReference in remote_products to
+            # determine the sort order.
+            return cmp(x_index, y_index)
+
+        for other_pbxproject, ref_dict in self._other_pbxprojects.items():
+            # Build up a list of products in the remote project file, ordered the
+            # same as the targets that produce them.
+            remote_products = []
+            for target in other_pbxproject._properties["targets"]:
+                if not isinstance(target, PBXNativeTarget):
+                    continue
+                remote_products.append(target._properties["productReference"])
+
+            # Sort the PBXReferenceProxy children according to the list of remote
+            # products.
+            product_group = ref_dict["ProductGroup"]
+            product_group._properties["children"] = sorted(
+                product_group._properties["children"],
+                cmp=lambda x, y, rp=remote_products: CompareProducts(x, y, rp),
+            )
 
 
 class XCProjectFile(XCObject):
-  _schema = XCObject._schema.copy()
-  _schema.update({
-    'archiveVersion': [0, int,        0, 1, 1],
-    'classes':        [0, dict,       0, 1, {}],
-    'objectVersion':  [0, int,        0, 1, 46],
-    'rootObject':     [0, PBXProject, 1, 1],
-  })
-
-  def ComputeIDs(self, recursive=True, overwrite=True, hash=None):
-    # Although XCProjectFile is implemented here as an XCObject, it's not a
-    # proper object in the Xcode sense, and it certainly doesn't have its own
-    # ID.  Pass through an attempt to update IDs to the real root object.
-    if recursive:
-      self._properties['rootObject'].ComputeIDs(recursive, overwrite, hash)
-
-  def Print(self, file=sys.stdout):
-    self.VerifyHasRequiredProperties()
-
-    # Add the special "objects" property, which will be caught and handled
-    # separately during printing.  This structure allows a fairly standard
-    # loop do the normal printing.
-    self._properties['objects'] = {}
-    self._XCPrint(file, 0, '// !$*UTF8*$!\n')
-    if self._should_print_single_line:
-      self._XCPrint(file, 0, '{ ')
-    else:
-      self._XCPrint(file, 0, '{\n')
-    for property, value in sorted(self._properties.items(),
-                                  cmp=lambda x, y: cmp(x, y)):
-      if property == 'objects':
-        self._PrintObjects(file)
-      else:
-        self._XCKVPrint(file, 1, property, value)
-    self._XCPrint(file, 0, '}\n')
-    del self._properties['objects']
-
-  def _PrintObjects(self, file):
-    if self._should_print_single_line:
-      self._XCPrint(file, 0, 'objects = {')
-    else:
-      self._XCPrint(file, 1, 'objects = {\n')
-
-    objects_by_class = {}
-    for object in self.Descendants():
-      if object == self:
-        continue
-      class_name = object.__class__.__name__
-      if not class_name in objects_by_class:
-        objects_by_class[class_name] = []
-      objects_by_class[class_name].append(object)
-
-    for class_name in sorted(objects_by_class):
-      self._XCPrint(file, 0, '\n')
-      self._XCPrint(file, 0, '/* Begin ' + class_name + ' section */\n')
-      for object in sorted(objects_by_class[class_name],
-                           cmp=lambda x, y: cmp(x.id, y.id)):
-        object.Print(file)
-      self._XCPrint(file, 0, '/* End ' + class_name + ' section */\n')
-
-    if self._should_print_single_line:
-      self._XCPrint(file, 0, '}; ')
-    else:
-      self._XCPrint(file, 1, '};\n')
+    _schema = XCObject._schema.copy()
+    _schema.update(
+        {
+            "archiveVersion": [0, int, 0, 1, 1],
+            "classes": [0, dict, 0, 1, {}],
+            "objectVersion": [0, int, 0, 1, 46],
+            "rootObject": [0, PBXProject, 1, 1],
+        }
+    )
+
+    def ComputeIDs(self, recursive=True, overwrite=True, hash=None):
+        # Although XCProjectFile is implemented here as an XCObject, it's not a
+        # proper object in the Xcode sense, and it certainly doesn't have its own
+        # ID.  Pass through an attempt to update IDs to the real root object.
+        if recursive:
+            self._properties["rootObject"].ComputeIDs(recursive, overwrite, hash)
+
+    def Print(self, file=sys.stdout):
+        self.VerifyHasRequiredProperties()
+
+        # Add the special "objects" property, which will be caught and handled
+        # separately during printing.  This structure allows a fairly standard
+        # loop do the normal printing.
+        self._properties["objects"] = {}
+        self._XCPrint(file, 0, "// !$*UTF8*$!\n")
+        if self._should_print_single_line:
+            self._XCPrint(file, 0, "{ ")
+        else:
+            self._XCPrint(file, 0, "{\n")
+        for property, value in sorted(
+            self._properties.items(), cmp=lambda x, y: cmp(x, y)
+        ):
+            if property == "objects":
+                self._PrintObjects(file)
+            else:
+                self._XCKVPrint(file, 1, property, value)
+        self._XCPrint(file, 0, "}\n")
+        del self._properties["objects"]
+
+    def _PrintObjects(self, file):
+        if self._should_print_single_line:
+            self._XCPrint(file, 0, "objects = {")
+        else:
+            self._XCPrint(file, 1, "objects = {\n")
+
+        objects_by_class = {}
+        for object in self.Descendants():
+            if object == self:
+                continue
+            class_name = object.__class__.__name__
+            if class_name not in objects_by_class:
+                objects_by_class[class_name] = []
+            objects_by_class[class_name].append(object)
+
+        for class_name in sorted(objects_by_class):
+            self._XCPrint(file, 0, "\n")
+            self._XCPrint(file, 0, "/* Begin " + class_name + " section */\n")
+            for object in sorted(
+                objects_by_class[class_name], cmp=lambda x, y: cmp(x.id, y.id)
+            ):
+                object.Print(file)
+            self._XCPrint(file, 0, "/* End " + class_name + " section */\n")
+
+        if self._should_print_single_line:
+            self._XCPrint(file, 0, "}; ")
+        else:
+            self._XCPrint(file, 1, "};\n")
diff --git a/tools/gyp/pylib/gyp/xml_fix.py b/tools/gyp/pylib/gyp/xml_fix.py
index 5de848158d28997db6f8558954b194933dad2ad3..0a945322b4587aeef52a47b9381a4afc18fe4240 100644
--- a/tools/gyp/pylib/gyp/xml_fix.py
+++ b/tools/gyp/pylib/gyp/xml_fix.py
@@ -14,56 +14,52 @@ import xml.dom.minidom
 
 
 def _Replacement_write_data(writer, data, is_attrib=False):
-  """Writes datachars to writer."""
-  data = data.replace("&", "&amp;").replace("<", "&lt;")
-  data = data.replace("\"", "&quot;").replace(">", "&gt;")
-  if is_attrib:
-    data = data.replace(
-        "\r", "&#xD;").replace(
-        "\n", "&#xA;").replace(
-        "\t", "&#x9;")
-  writer.write(data)
+    """Writes datachars to writer."""
+    data = data.replace("&", "&amp;").replace("<", "&lt;")
+    data = data.replace('"', "&quot;").replace(">", "&gt;")
+    if is_attrib:
+        data = data.replace("\r", "&#xD;").replace("\n", "&#xA;").replace("\t", "&#x9;")
+    writer.write(data)
 
 
 def _Replacement_writexml(self, writer, indent="", addindent="", newl=""):
-  # indent = current indentation
-  # addindent = indentation to add to higher levels
-  # newl = newline string
-  writer.write(indent+"<" + self.tagName)
+    # indent = current indentation
+    # addindent = indentation to add to higher levels
+    # newl = newline string
+    writer.write(indent + "<" + self.tagName)
 
-  attrs = self._get_attributes()
-  a_names = attrs.keys()
-  a_names.sort()
+    attrs = self._get_attributes()
+    a_names = sorted(attrs.keys())
 
-  for a_name in a_names:
-    writer.write(" %s=\"" % a_name)
-    _Replacement_write_data(writer, attrs[a_name].value, is_attrib=True)
-    writer.write("\"")
-  if self.childNodes:
-    writer.write(">%s" % newl)
-    for node in self.childNodes:
-      node.writexml(writer, indent + addindent, addindent, newl)
-    writer.write("%s</%s>%s" % (indent, self.tagName, newl))
-  else:
-    writer.write("/>%s" % newl)
+    for a_name in a_names:
+        writer.write(' %s="' % a_name)
+        _Replacement_write_data(writer, attrs[a_name].value, is_attrib=True)
+        writer.write('"')
+    if self.childNodes:
+        writer.write(">%s" % newl)
+        for node in self.childNodes:
+            node.writexml(writer, indent + addindent, addindent, newl)
+        writer.write("%s</%s>%s" % (indent, self.tagName, newl))
+    else:
+        writer.write("/>%s" % newl)
 
 
 class XmlFix(object):
-  """Object to manage temporary patching of xml.dom.minidom."""
+    """Object to manage temporary patching of xml.dom.minidom."""
 
-  def __init__(self):
-    # Preserve current xml.dom.minidom functions.
-    self.write_data = xml.dom.minidom._write_data
-    self.writexml = xml.dom.minidom.Element.writexml
-    # Inject replacement versions of a function and a method.
-    xml.dom.minidom._write_data = _Replacement_write_data
-    xml.dom.minidom.Element.writexml = _Replacement_writexml
+    def __init__(self):
+        # Preserve current xml.dom.minidom functions.
+        self.write_data = xml.dom.minidom._write_data
+        self.writexml = xml.dom.minidom.Element.writexml
+        # Inject replacement versions of a function and a method.
+        xml.dom.minidom._write_data = _Replacement_write_data
+        xml.dom.minidom.Element.writexml = _Replacement_writexml
 
-  def Cleanup(self):
-    if self.write_data:
-      xml.dom.minidom._write_data = self.write_data
-      xml.dom.minidom.Element.writexml = self.writexml
-      self.write_data = None
+    def Cleanup(self):
+        if self.write_data:
+            xml.dom.minidom._write_data = self.write_data
+            xml.dom.minidom.Element.writexml = self.writexml
+            self.write_data = None
 
-  def __del__(self):
-    self.Cleanup()
+    def __del__(self):
+        self.Cleanup()
diff --git a/tools/gyp/requirements_dev.txt b/tools/gyp/requirements_dev.txt
new file mode 100644
index 0000000000000000000000000000000000000000..28ecacab6029381bd43d65f8dcfc0cc704870f71
--- /dev/null
+++ b/tools/gyp/requirements_dev.txt
@@ -0,0 +1,2 @@
+flake8
+pytest
diff --git a/tools/gyp/samples/samples b/tools/gyp/samples/samples
deleted file mode 100755
index 804b618998747de6224ab44ca6e3fcebdb123e61..0000000000000000000000000000000000000000
--- a/tools/gyp/samples/samples
+++ /dev/null
@@ -1,81 +0,0 @@
-#!/usr/bin/python
-
-# Copyright (c) 2009 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-import os.path
-import shutil
-import sys
-
-
-gyps = [
-    'app/app.gyp',
-    'base/base.gyp',
-    'build/temp_gyp/googleurl.gyp',
-    'build/all.gyp',
-    'build/common.gypi',
-    'build/external_code.gypi',
-    'chrome/test/security_tests/security_tests.gyp',
-    'chrome/third_party/hunspell/hunspell.gyp',
-    'chrome/chrome.gyp',
-    'media/media.gyp',
-    'net/net.gyp',
-    'printing/printing.gyp',
-    'sdch/sdch.gyp',
-    'skia/skia.gyp',
-    'testing/gmock.gyp',
-    'testing/gtest.gyp',
-    'third_party/bzip2/bzip2.gyp',
-    'third_party/icu38/icu38.gyp',
-    'third_party/libevent/libevent.gyp',
-    'third_party/libjpeg/libjpeg.gyp',
-    'third_party/libpng/libpng.gyp',
-    'third_party/libxml/libxml.gyp',
-    'third_party/libxslt/libxslt.gyp',
-    'third_party/lzma_sdk/lzma_sdk.gyp',
-    'third_party/modp_b64/modp_b64.gyp',
-    'third_party/npapi/npapi.gyp',
-    'third_party/sqlite/sqlite.gyp',
-    'third_party/zlib/zlib.gyp',
-    'v8/tools/gyp/v8.gyp',
-    'webkit/activex_shim/activex_shim.gyp',
-    'webkit/activex_shim_dll/activex_shim_dll.gyp',
-    'webkit/build/action_csspropertynames.py',
-    'webkit/build/action_cssvaluekeywords.py',
-    'webkit/build/action_jsconfig.py',
-    'webkit/build/action_makenames.py',
-    'webkit/build/action_maketokenizer.py',
-    'webkit/build/action_useragentstylesheets.py',
-    'webkit/build/rule_binding.py',
-    'webkit/build/rule_bison.py',
-    'webkit/build/rule_gperf.py',
-    'webkit/tools/test_shell/test_shell.gyp',
-    'webkit/webkit.gyp',
-]
-
-
-def Main(argv):
-  if len(argv) != 3 or argv[1] not in ['push', 'pull']:
-    print 'Usage: %s push/pull PATH_TO_CHROME' % argv[0]
-    return 1
-
-  path_to_chrome = argv[2]
-
-  for g in gyps:
-    chrome_file = os.path.join(path_to_chrome, g)
-    local_file = os.path.join(os.path.dirname(argv[0]), os.path.split(g)[1])
-    if argv[1] == 'push':
-      print 'Copying %s to %s' % (local_file, chrome_file)
-      shutil.copyfile(local_file, chrome_file)
-    elif argv[1] == 'pull':
-      print 'Copying %s to %s' % (chrome_file, local_file)
-      shutil.copyfile(chrome_file, local_file)
-    else:
-      assert False
-
-  return 0
-
-
-if __name__ == '__main__':
-  sys.exit(Main(sys.argv))
diff --git a/tools/gyp/samples/samples.bat b/tools/gyp/samples/samples.bat
deleted file mode 100644
index 778d9c90f06066484ffab2c54c35a8eee9a28452..0000000000000000000000000000000000000000
--- a/tools/gyp/samples/samples.bat
+++ /dev/null
@@ -1,5 +0,0 @@
-@rem Copyright (c) 2009 Google Inc. All rights reserved.
-@rem Use of this source code is governed by a BSD-style license that can be
-@rem found in the LICENSE file.
-
-@python %~dp0/samples %*
diff --git a/tools/gyp/setup.py b/tools/gyp/setup.py
old mode 100755
new mode 100644
index 75a42558d8026bd685cd6c0db40537ff7f7f47c7..766a7651ba09f5d38a561762792733121b5921c7
--- a/tools/gyp/setup.py
+++ b/tools/gyp/setup.py
@@ -4,16 +4,41 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+from os import path
+
 from setuptools import setup
 
+here = path.abspath(path.dirname(__file__))
+# Get the long description from the README file
+with open(path.join(here, "README.md")) as in_file:
+    long_description = in_file.read()
+
 setup(
-  name='gyp',
-  version='0.1',
-  description='Generate Your Projects',
-  author='Chromium Authors',
-  author_email='chromium-dev@googlegroups.com',
-  url='http://code.google.com/p/gyp',
-  package_dir = {'': 'pylib'},
-  packages=['gyp', 'gyp.generator'],
-  entry_points = {'console_scripts': ['gyp=gyp:script_main'] }
+    name="gyp-next",
+    version="0.7.0",
+    description="A fork of the GYP build system for use in the Node.js projects",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Node.js contributors",
+    author_email="ryzokuken@disroot.org",
+    url="https://github.com/nodejs/gyp-next",
+    package_dir={"": "pylib"},
+    packages=["gyp", "gyp.generator"],
+    entry_points={"console_scripts": ["gyp=gyp:script_main"]},
+    python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Environment :: Console",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: BSD License",
+        "Natural Language :: English",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+    ],
 )
diff --git a/tools/gyp/test_gyp.py b/tools/gyp/test_gyp.py
new file mode 100755
index 0000000000000000000000000000000000000000..382e75272d8b6b1d564828271871cdc034d6cc21
--- /dev/null
+++ b/tools/gyp/test_gyp.py
@@ -0,0 +1,268 @@
+#!/usr/bin/env python
+# Copyright (c) 2012 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""gyptest.py -- test runner for GYP tests."""
+
+from __future__ import print_function
+
+import argparse
+import os
+import platform
+import subprocess
+import sys
+import time
+
+
+def is_test_name(f):
+    return f.startswith("gyptest") and f.endswith(".py")
+
+
+def find_all_gyptest_files(directory):
+    result = []
+    for root, dirs, files in os.walk(directory):
+        result.extend([os.path.join(root, f) for f in files if is_test_name(f)])
+    result.sort()
+    return result
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-a", "--all", action="store_true", help="run all tests")
+    parser.add_argument("-C", "--chdir", action="store", help="change to directory")
+    parser.add_argument(
+        "-f",
+        "--format",
+        action="store",
+        default="",
+        help="run tests with the specified formats",
+    )
+    parser.add_argument(
+        "-G",
+        "--gyp_option",
+        action="append",
+        default=[],
+        help="Add -G options to the gyp command line",
+    )
+    parser.add_argument(
+        "-l", "--list", action="store_true", help="list available tests and exit"
+    )
+    parser.add_argument(
+        "-n",
+        "--no-exec",
+        action="store_true",
+        help="no execute, just print the command line",
+    )
+    parser.add_argument(
+        "--path", action="append", default=[], help="additional $PATH directory"
+    )
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="quiet, don't print anything unless there are failures",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="print configuration info and test results.",
+    )
+    parser.add_argument("tests", nargs="*")
+    args = parser.parse_args(argv[1:])
+
+    if args.chdir:
+        os.chdir(args.chdir)
+
+    if args.path:
+        extra_path = [os.path.abspath(p) for p in args.path]
+        extra_path = os.pathsep.join(extra_path)
+        os.environ["PATH"] = extra_path + os.pathsep + os.environ["PATH"]
+
+    if not args.tests:
+        if not args.all:
+            sys.stderr.write("Specify -a to get all tests.\n")
+            return 1
+        args.tests = ["test"]
+
+    tests = []
+    for arg in args.tests:
+        if os.path.isdir(arg):
+            tests.extend(find_all_gyptest_files(os.path.normpath(arg)))
+        else:
+            if not is_test_name(os.path.basename(arg)):
+                print(arg, "is not a valid gyp test name.", file=sys.stderr)
+                sys.exit(1)
+            tests.append(arg)
+
+    if args.list:
+        for test in tests:
+            print(test)
+        sys.exit(0)
+
+    os.environ["PYTHONPATH"] = os.path.abspath("test/lib")
+
+    if args.verbose:
+        print_configuration_info()
+
+    if args.gyp_option and not args.quiet:
+        print("Extra Gyp options: %s\n" % args.gyp_option)
+
+    if args.format:
+        format_list = args.format.split(",")
+    else:
+        format_list = {
+            "aix5": ["make"],
+            "freebsd7": ["make"],
+            "freebsd8": ["make"],
+            "openbsd5": ["make"],
+            "cygwin": ["msvs"],
+            "win32": ["msvs", "ninja"],
+            "linux": ["make", "ninja"],
+            "linux2": ["make", "ninja"],
+            "linux3": ["make", "ninja"],
+            # TODO: Re-enable xcode-ninja.
+            # https://bugs.chromium.org/p/gyp/issues/detail?id=530
+            # 'darwin':   ['make', 'ninja', 'xcode', 'xcode-ninja'],
+            "darwin": ["make", "ninja", "xcode"],
+        }[sys.platform]
+
+    gyp_options = []
+    for option in args.gyp_option:
+        gyp_options += ["-G", option]
+
+    runner = Runner(format_list, tests, gyp_options, args.verbose)
+    runner.run()
+
+    if not args.quiet:
+        runner.print_results()
+
+    if runner.failures:
+        return 1
+    else:
+        return 0
+
+
+def print_configuration_info():
+    print("Test configuration:")
+    if sys.platform == "darwin":
+        sys.path.append(os.path.abspath("test/lib"))
+        import TestMac
+
+        print("  Mac %s %s" % (platform.mac_ver()[0], platform.mac_ver()[2]))
+        print("  Xcode %s" % TestMac.Xcode.Version())
+    elif sys.platform == "win32":
+        sys.path.append(os.path.abspath("pylib"))
+        import gyp.MSVSVersion
+
+        print("  Win %s %s\n" % platform.win32_ver()[0:2])
+        print("  MSVS %s" % gyp.MSVSVersion.SelectVisualStudioVersion().Description())
+    elif sys.platform in ("linux", "linux2"):
+        print("  Linux %s" % " ".join(platform.linux_distribution()))
+    print("  Python %s" % platform.python_version())
+    print("  PYTHONPATH=%s" % os.environ["PYTHONPATH"])
+    print()
+
+
+class Runner(object):
+    def __init__(self, formats, tests, gyp_options, verbose):
+        self.formats = formats
+        self.tests = tests
+        self.verbose = verbose
+        self.gyp_options = gyp_options
+        self.failures = []
+        self.num_tests = len(formats) * len(tests)
+        num_digits = len(str(self.num_tests))
+        self.fmt_str = "[%%%dd/%%%dd] (%%s) %%s" % (num_digits, num_digits)
+        self.isatty = sys.stdout.isatty() and not self.verbose
+        self.env = os.environ.copy()
+        self.hpos = 0
+
+    def run(self):
+        run_start = time.time()
+
+        i = 1
+        for fmt in self.formats:
+            for test in self.tests:
+                self.run_test(test, fmt, i)
+                i += 1
+
+        if self.isatty:
+            self.erase_current_line()
+
+        self.took = time.time() - run_start
+
+    def run_test(self, test, fmt, i):
+        if self.isatty:
+            self.erase_current_line()
+
+        msg = self.fmt_str % (i, self.num_tests, fmt, test)
+        self.print_(msg)
+
+        start = time.time()
+        cmd = [sys.executable, test] + self.gyp_options
+        self.env["TESTGYP_FORMAT"] = fmt
+        proc = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=self.env
+        )
+        proc.wait()
+        took = time.time() - start
+
+        stdout = proc.stdout.read().decode("utf8")
+        if proc.returncode == 2:
+            res = "skipped"
+        elif proc.returncode:
+            res = "failed"
+            self.failures.append("(%s) %s" % (test, fmt))
+        else:
+            res = "passed"
+        res_msg = " %s %.3fs" % (res, took)
+        self.print_(res_msg)
+
+        if (
+            stdout
+            and not stdout.endswith("PASSED\n")
+            and not (stdout.endswith("NO RESULT\n"))
+        ):
+            print()
+            print("\n".join("    %s" % line for line in stdout.splitlines()))
+        elif not self.isatty:
+            print()
+
+    def print_(self, msg):
+        print(msg, end="")
+        index = msg.rfind("\n")
+        if index == -1:
+            self.hpos += len(msg)
+        else:
+            self.hpos = len(msg) - index
+        sys.stdout.flush()
+
+    def erase_current_line(self):
+        print("\b" * self.hpos + " " * self.hpos + "\b" * self.hpos, end="")
+        sys.stdout.flush()
+        self.hpos = 0
+
+    def print_results(self):
+        num_failures = len(self.failures)
+        if num_failures:
+            print()
+            if num_failures == 1:
+                print("Failed the following test:")
+            else:
+                print("Failed the following %d tests:" % num_failures)
+            print("\t" + "\n\t".join(sorted(self.failures)))
+            print()
+        print(
+            "Ran %d tests in %.3fs, %d failed."
+            % (self.num_tests, self.took, num_failures)
+        )
+        print()
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/gyp/tools/graphviz.py b/tools/gyp/tools/graphviz.py
index 538b059da4a7e640ab9365686f08d45664dfd528..1f3acf37fccd8adad7a4880ceb7260b7d1fc55f4 100755
--- a/tools/gyp/tools/graphviz.py
+++ b/tools/gyp/tools/graphviz.py
@@ -16,87 +16,88 @@ import sys
 
 
 def ParseTarget(target):
-  target, _, suffix = target.partition('#')
-  filename, _, target = target.partition(':')
-  return filename, target, suffix
+    target, _, suffix = target.partition("#")
+    filename, _, target = target.partition(":")
+    return filename, target, suffix
 
 
 def LoadEdges(filename, targets):
-  """Load the edges map from the dump file, and filter it to only
+    """Load the edges map from the dump file, and filter it to only
   show targets in |targets| and their depedendents."""
 
-  file = open('dump.json')
-  edges = json.load(file)
-  file.close()
+    file = open("dump.json")
+    edges = json.load(file)
+    file.close()
 
-  # Copy out only the edges we're interested in from the full edge list.
-  target_edges = {}
-  to_visit = targets[:]
-  while to_visit:
-    src = to_visit.pop()
-    if src in target_edges:
-      continue
-    target_edges[src] = edges[src]
-    to_visit.extend(edges[src])
+    # Copy out only the edges we're interested in from the full edge list.
+    target_edges = {}
+    to_visit = targets[:]
+    while to_visit:
+        src = to_visit.pop()
+        if src in target_edges:
+            continue
+        target_edges[src] = edges[src]
+        to_visit.extend(edges[src])
 
-  return target_edges
+    return target_edges
 
 
 def WriteGraph(edges):
-  """Print a graphviz graph to stdout.
+    """Print a graphviz graph to stdout.
   |edges| is a map of target to a list of other targets it depends on."""
 
-  # Bucket targets by file.
-  files = collections.defaultdict(list)
-  for src, dst in edges.items():
-    build_file, target_name, toolset = ParseTarget(src)
-    files[build_file].append(src)
-
-  print('digraph D {')
-  print('  fontsize=8')  # Used by subgraphs.
-  print('  node [fontsize=8]')
-
-  # Output nodes by file.  We must first write out each node within
-  # its file grouping before writing out any edges that may refer
-  # to those nodes.
-  for filename, targets in files.items():
-    if len(targets) == 1:
-      # If there's only one node for this file, simplify
-      # the display by making it a box without an internal node.
-      target = targets[0]
-      build_file, target_name, toolset = ParseTarget(target)
-      print('  "%s" [shape=box, label="%s\\n%s"]' % (target, filename,
-                                                     target_name))
-    else:
-      # Group multiple nodes together in a subgraph.
-      print('  subgraph "cluster_%s" {' % filename)
-      print('    label = "%s"' % filename)
-      for target in targets:
-        build_file, target_name, toolset = ParseTarget(target)
-        print('    "%s" [label="%s"]' % (target, target_name))
-      print('  }')
-
-  # Now that we've placed all the nodes within subgraphs, output all
-  # the edges between nodes.
-  for src, dsts in edges.items():
-    for dst in dsts:
-      print('  "%s" -> "%s"' % (src, dst))
-
-  print('}')
+    # Bucket targets by file.
+    files = collections.defaultdict(list)
+    for src, dst in edges.items():
+        build_file, target_name, toolset = ParseTarget(src)
+        files[build_file].append(src)
+
+    print("digraph D {")
+    print("  fontsize=8")  # Used by subgraphs.
+    print("  node [fontsize=8]")
+
+    # Output nodes by file.  We must first write out each node within
+    # its file grouping before writing out any edges that may refer
+    # to those nodes.
+    for filename, targets in files.items():
+        if len(targets) == 1:
+            # If there's only one node for this file, simplify
+            # the display by making it a box without an internal node.
+            target = targets[0]
+            build_file, target_name, toolset = ParseTarget(target)
+            print(
+                '  "%s" [shape=box, label="%s\\n%s"]' % (target, filename, target_name)
+            )
+        else:
+            # Group multiple nodes together in a subgraph.
+            print('  subgraph "cluster_%s" {' % filename)
+            print('    label = "%s"' % filename)
+            for target in targets:
+                build_file, target_name, toolset = ParseTarget(target)
+                print('    "%s" [label="%s"]' % (target, target_name))
+            print("  }")
+
+    # Now that we've placed all the nodes within subgraphs, output all
+    # the edges between nodes.
+    for src, dsts in edges.items():
+        for dst in dsts:
+            print('  "%s" -> "%s"' % (src, dst))
+
+    print("}")
 
 
 def main():
-  if len(sys.argv) < 2:
-    print(__doc__, file=sys.stderr)
-    print(file=sys.stderr)
-    print('usage: %s target1 target2...' % (sys.argv[0]), file=sys.stderr)
-    return 1
+    if len(sys.argv) < 2:
+        print(__doc__, file=sys.stderr)
+        print(file=sys.stderr)
+        print("usage: %s target1 target2..." % (sys.argv[0]), file=sys.stderr)
+        return 1
 
-  edges = LoadEdges('dump.json', sys.argv[1:])
+    edges = LoadEdges("dump.json", sys.argv[1:])
 
-  WriteGraph(edges)
-  return 0
+    WriteGraph(edges)
+    return 0
 
 
-if __name__ == '__main__':
-  sys.exit(main())
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/gyp/tools/pretty_gyp.py b/tools/gyp/tools/pretty_gyp.py
index 633048a59ad28c1a534456458399912de76bd5ca..7313b4fe1b6710b870cd1b5fc5e324db752a43ff 100755
--- a/tools/gyp/tools/pretty_gyp.py
+++ b/tools/gyp/tools/pretty_gyp.py
@@ -13,7 +13,7 @@ import re
 
 
 # Regex to remove comments when we're counting braces.
-COMMENT_RE = re.compile(r'\s*#.*')
+COMMENT_RE = re.compile(r"\s*#.*")
 
 # Regex to remove quoted strings when we're counting braces.
 # It takes into account quoted quotes, and makes sure that the quotes match.
@@ -24,45 +24,47 @@ QUOTE_RE = re.compile(QUOTE_RE_STR)
 
 
 def comment_replace(matchobj):
-  return matchobj.group(1) + matchobj.group(2) + '#' * len(matchobj.group(3))
+    return matchobj.group(1) + matchobj.group(2) + "#" * len(matchobj.group(3))
 
 
 def mask_comments(input):
-  """Mask the quoted strings so we skip braces inside quoted strings."""
-  search_re = re.compile(r'(.*?)(#)(.*)')
-  return [search_re.sub(comment_replace, line) for line in input]
+    """Mask the quoted strings so we skip braces inside quoted strings."""
+    search_re = re.compile(r"(.*?)(#)(.*)")
+    return [search_re.sub(comment_replace, line) for line in input]
 
 
 def quote_replace(matchobj):
-  return "%s%s%s%s" % (matchobj.group(1),
-                       matchobj.group(2),
-                       'x'*len(matchobj.group(3)),
-                       matchobj.group(2))
+    return "%s%s%s%s" % (
+        matchobj.group(1),
+        matchobj.group(2),
+        "x" * len(matchobj.group(3)),
+        matchobj.group(2),
+    )
 
 
 def mask_quotes(input):
-  """Mask the quoted strings so we skip braces inside quoted strings."""
-  search_re = re.compile(r'(.*?)' + QUOTE_RE_STR)
-  return [search_re.sub(quote_replace, line) for line in input]
+    """Mask the quoted strings so we skip braces inside quoted strings."""
+    search_re = re.compile(r"(.*?)" + QUOTE_RE_STR)
+    return [search_re.sub(quote_replace, line) for line in input]
 
 
 def do_split(input, masked_input, search_re):
-  output = []
-  mask_output = []
-  for (line, masked_line) in zip(input, masked_input):
-    m = search_re.match(masked_line)
-    while m:
-      split = len(m.group(1))
-      line = line[:split] + r'\n' + line[split:]
-      masked_line = masked_line[:split] + r'\n' + masked_line[split:]
-      m = search_re.match(masked_line)
-    output.extend(line.split(r'\n'))
-    mask_output.extend(masked_line.split(r'\n'))
-  return (output, mask_output)
+    output = []
+    mask_output = []
+    for (line, masked_line) in zip(input, masked_input):
+        m = search_re.match(masked_line)
+        while m:
+            split = len(m.group(1))
+            line = line[:split] + r"\n" + line[split:]
+            masked_line = masked_line[:split] + r"\n" + masked_line[split:]
+            m = search_re.match(masked_line)
+        output.extend(line.split(r"\n"))
+        mask_output.extend(masked_line.split(r"\n"))
+    return (output, mask_output)
 
 
 def split_double_braces(input):
-  """Masks out the quotes and comments, and then splits appropriate
+    """Masks out the quotes and comments, and then splits appropriate
   lines (lines that matche the double_*_brace re's above) before
   indenting them below.
 
@@ -70,88 +72,86 @@ def split_double_braces(input):
   that the indentation looks prettier when all laid out (e.g. closing
   braces make a nice diagonal line).
   """
-  double_open_brace_re = re.compile(r'(.*?[\[\{\(,])(\s*)([\[\{\(])')
-  double_close_brace_re = re.compile(r'(.*?[\]\}\)],?)(\s*)([\]\}\)])')
+    double_open_brace_re = re.compile(r"(.*?[\[\{\(,])(\s*)([\[\{\(])")
+    double_close_brace_re = re.compile(r"(.*?[\]\}\)],?)(\s*)([\]\}\)])")
 
-  masked_input = mask_quotes(input)
-  masked_input = mask_comments(masked_input)
+    masked_input = mask_quotes(input)
+    masked_input = mask_comments(masked_input)
 
-  (output, mask_output) = do_split(input, masked_input, double_open_brace_re)
-  (output, mask_output) = do_split(output, mask_output, double_close_brace_re)
+    (output, mask_output) = do_split(input, masked_input, double_open_brace_re)
+    (output, mask_output) = do_split(output, mask_output, double_close_brace_re)
 
-  return output
+    return output
 
 
 def count_braces(line):
-  """keeps track of the number of braces on a given line and returns the result.
+    """keeps track of the number of braces on a given line and returns the result.
 
   It starts at zero and subtracts for closed braces, and adds for open braces.
   """
-  open_braces = ['[', '(', '{']
-  close_braces = [']', ')', '}']
-  closing_prefix_re = re.compile(r'(.*?[^\s\]\}\)]+.*?)([\]\}\)],?)\s*$')
-  cnt = 0
-  stripline = COMMENT_RE.sub(r'', line)
-  stripline = QUOTE_RE.sub(r"''", stripline)
-  for char in stripline:
-    for brace in open_braces:
-      if char == brace:
-        cnt += 1
-    for brace in close_braces:
-      if char == brace:
-        cnt -= 1
-
-  after = False
-  if cnt > 0:
-    after = True
-
-  # This catches the special case of a closing brace having something
-  # other than just whitespace ahead of it -- we don't want to
-  # unindent that until after this line is printed so it stays with
-  # the previous indentation level.
-  if cnt < 0 and closing_prefix_re.match(stripline):
-    after = True
-  return (cnt, after)
+    open_braces = ["[", "(", "{"]
+    close_braces = ["]", ")", "}"]
+    closing_prefix_re = re.compile(r"(.*?[^\s\]\}\)]+.*?)([\]\}\)],?)\s*$")
+    cnt = 0
+    stripline = COMMENT_RE.sub(r"", line)
+    stripline = QUOTE_RE.sub(r"''", stripline)
+    for char in stripline:
+        for brace in open_braces:
+            if char == brace:
+                cnt += 1
+        for brace in close_braces:
+            if char == brace:
+                cnt -= 1
+
+    after = False
+    if cnt > 0:
+        after = True
+
+    # This catches the special case of a closing brace having something
+    # other than just whitespace ahead of it -- we don't want to
+    # unindent that until after this line is printed so it stays with
+    # the previous indentation level.
+    if cnt < 0 and closing_prefix_re.match(stripline):
+        after = True
+    return (cnt, after)
 
 
 def prettyprint_input(lines):
-  """Does the main work of indenting the input based on the brace counts."""
-  indent = 0
-  basic_offset = 2
-  last_line = ""
-  for line in lines:
-    if COMMENT_RE.match(line):
-      print(line)
-    else:
-      line = line.strip('\r\n\t ')  # Otherwise doesn't strip \r on Unix.
-      if len(line) > 0:
-        (brace_diff, after) = count_braces(line)
-        if brace_diff != 0:
-          if after:
-            print(" " * (basic_offset * indent) + line)
-            indent += brace_diff
-          else:
-            indent += brace_diff
-            print(" " * (basic_offset * indent) + line)
+    """Does the main work of indenting the input based on the brace counts."""
+    indent = 0
+    basic_offset = 2
+    for line in lines:
+        if COMMENT_RE.match(line):
+            print(line)
         else:
-          print(" " * (basic_offset * indent) + line)
-      else:
-        print("")
-      last_line = line
+            line = line.strip("\r\n\t ")  # Otherwise doesn't strip \r on Unix.
+            if len(line) > 0:
+                (brace_diff, after) = count_braces(line)
+                if brace_diff != 0:
+                    if after:
+                        print(" " * (basic_offset * indent) + line)
+                        indent += brace_diff
+                    else:
+                        indent += brace_diff
+                        print(" " * (basic_offset * indent) + line)
+                else:
+                    print(" " * (basic_offset * indent) + line)
+            else:
+                print("")
 
 
 def main():
-  if len(sys.argv) > 1:
-    data = open(sys.argv[1]).read().splitlines()
-  else:
-    data = sys.stdin.read().splitlines()
-  # Split up the double braces.
-  lines = split_double_braces(data)
+    if len(sys.argv) > 1:
+        data = open(sys.argv[1]).read().splitlines()
+    else:
+        data = sys.stdin.read().splitlines()
+    # Split up the double braces.
+    lines = split_double_braces(data)
 
-  # Indent and print the output.
-  prettyprint_input(lines)
-  return 0
+    # Indent and print the output.
+    prettyprint_input(lines)
+    return 0
 
 
-if __name__ == '__main__':
-  sys.exit(main())
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/gyp/tools/pretty_sln.py b/tools/gyp/tools/pretty_sln.py
index 196566fb9e44700148f5737a97f7cfe45a9be5b5..2b1cb1de7475776e9113667460b62e6c00bb8222 100755
--- a/tools/gyp/tools/pretty_sln.py
+++ b/tools/gyp/tools/pretty_sln.py
@@ -19,153 +19,164 @@ import re
 import sys
 import pretty_vcproj
 
-__author__ = 'nsylvain (Nicolas Sylvain)'
+__author__ = "nsylvain (Nicolas Sylvain)"
+
 
 def BuildProject(project, built, projects, deps):
-  # if all dependencies are done, we can build it, otherwise we try to build the
-  # dependency.
-  # This is not infinite-recursion proof.
-  for dep in deps[project]:
-    if dep not in built:
-      BuildProject(dep, built, projects, deps)
-  print(project)
-  built.append(project)
+    # if all dependencies are done, we can build it, otherwise we try to build the
+    # dependency.
+    # This is not infinite-recursion proof.
+    for dep in deps[project]:
+        if dep not in built:
+            BuildProject(dep, built, projects, deps)
+    print(project)
+    built.append(project)
+
 
 def ParseSolution(solution_file):
-  # All projects, their clsid and paths.
-  projects = dict()
-
-  # A list of dependencies associated with a project.
-  dependencies = dict()
-
-  # Regular expressions that matches the SLN format.
-  # The first line of a project definition.
-  begin_project = re.compile(r'^Project\("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942'
-                             r'}"\) = "(.*)", "(.*)", "(.*)"$')
-  # The last line of a project definition.
-  end_project = re.compile('^EndProject$')
-  # The first line of a dependency list.
-  begin_dep = re.compile(
-      r'ProjectSection\(ProjectDependencies\) = postProject$')
-  # The last line of a dependency list.
-  end_dep = re.compile('EndProjectSection$')
-  # A line describing a dependency.
-  dep_line = re.compile(' *({.*}) = ({.*})$')
-
-  in_deps = False
-  solution = open(solution_file)
-  for line in solution:
-    results = begin_project.search(line)
-    if results:
-      # Hack to remove icu because the diff is too different.
-      if results.group(1).find('icu') != -1:
-        continue
-      # We remove "_gyp" from the names because it helps to diff them.
-      current_project = results.group(1).replace('_gyp', '')
-      projects[current_project] = [results.group(2).replace('_gyp', ''),
-                                   results.group(3),
-                                   results.group(2)]
-      dependencies[current_project] = []
-      continue
-
-    results = end_project.search(line)
-    if results:
-      current_project = None
-      continue
-
-    results = begin_dep.search(line)
-    if results:
-      in_deps = True
-      continue
-
-    results = end_dep.search(line)
-    if results:
-      in_deps = False
-      continue
-
-    results = dep_line.search(line)
-    if results and in_deps and current_project:
-      dependencies[current_project].append(results.group(1))
-      continue
-
-  # Change all dependencies clsid to name instead.
-  for project in dependencies:
-    # For each dependencies in this project
-    new_dep_array = []
-    for dep in dependencies[project]:
-      # Look for the project name matching this cldis
-      for project_info in projects:
-        if projects[project_info][1] == dep:
-          new_dep_array.append(project_info)
-    dependencies[project] = sorted(new_dep_array)
-
-  return (projects, dependencies)
+    # All projects, their clsid and paths.
+    projects = dict()
+
+    # A list of dependencies associated with a project.
+    dependencies = dict()
+
+    # Regular expressions that matches the SLN format.
+    # The first line of a project definition.
+    begin_project = re.compile(
+        r'^Project\("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942'
+        r'}"\) = "(.*)", "(.*)", "(.*)"$'
+    )
+    # The last line of a project definition.
+    end_project = re.compile("^EndProject$")
+    # The first line of a dependency list.
+    begin_dep = re.compile(r"ProjectSection\(ProjectDependencies\) = postProject$")
+    # The last line of a dependency list.
+    end_dep = re.compile("EndProjectSection$")
+    # A line describing a dependency.
+    dep_line = re.compile(" *({.*}) = ({.*})$")
+
+    in_deps = False
+    solution = open(solution_file)
+    for line in solution:
+        results = begin_project.search(line)
+        if results:
+            # Hack to remove icu because the diff is too different.
+            if results.group(1).find("icu") != -1:
+                continue
+            # We remove "_gyp" from the names because it helps to diff them.
+            current_project = results.group(1).replace("_gyp", "")
+            projects[current_project] = [
+                results.group(2).replace("_gyp", ""),
+                results.group(3),
+                results.group(2),
+            ]
+            dependencies[current_project] = []
+            continue
+
+        results = end_project.search(line)
+        if results:
+            current_project = None
+            continue
+
+        results = begin_dep.search(line)
+        if results:
+            in_deps = True
+            continue
+
+        results = end_dep.search(line)
+        if results:
+            in_deps = False
+            continue
+
+        results = dep_line.search(line)
+        if results and in_deps and current_project:
+            dependencies[current_project].append(results.group(1))
+            continue
+
+    # Change all dependencies clsid to name instead.
+    for project in dependencies:
+        # For each dependencies in this project
+        new_dep_array = []
+        for dep in dependencies[project]:
+            # Look for the project name matching this cldis
+            for project_info in projects:
+                if projects[project_info][1] == dep:
+                    new_dep_array.append(project_info)
+        dependencies[project] = sorted(new_dep_array)
+
+    return (projects, dependencies)
+
 
 def PrintDependencies(projects, deps):
-  print("---------------------------------------")
-  print("Dependencies for all projects")
-  print("---------------------------------------")
-  print("--                                   --")
+    print("---------------------------------------")
+    print("Dependencies for all projects")
+    print("---------------------------------------")
+    print("--                                   --")
+
+    for (project, dep_list) in sorted(deps.items()):
+        print("Project : %s" % project)
+        print("Path : %s" % projects[project][0])
+        if dep_list:
+            for dep in dep_list:
+                print("  - %s" % dep)
+        print("")
 
-  for (project, dep_list) in sorted(deps.items()):
-    print("Project : %s" % project)
-    print("Path : %s" % projects[project][0])
-    if dep_list:
-      for dep in dep_list:
-        print("  - %s" % dep)
-    print("")
+    print("--                                   --")
 
-  print("--                                   --")
 
 def PrintBuildOrder(projects, deps):
-  print("---------------------------------------")
-  print("Build order                            ")
-  print("---------------------------------------")
-  print("--                                   --")
+    print("---------------------------------------")
+    print("Build order                            ")
+    print("---------------------------------------")
+    print("--                                   --")
 
-  built = []
-  for (project, _) in sorted(deps.items()):
-    if project not in built:
-      BuildProject(project, built, projects, deps)
+    built = []
+    for (project, _) in sorted(deps.items()):
+        if project not in built:
+            BuildProject(project, built, projects, deps)
 
-  print("--                                   --")
+    print("--                                   --")
 
-def PrintVCProj(projects):
 
-  for project in projects:
-    print("-------------------------------------")
-    print("-------------------------------------")
-    print(project)
-    print(project)
-    print(project)
-    print("-------------------------------------")
-    print("-------------------------------------")
+def PrintVCProj(projects):
 
-    project_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[1]),
-                                                projects[project][2]))
+    for project in projects:
+        print("-------------------------------------")
+        print("-------------------------------------")
+        print(project)
+        print(project)
+        print(project)
+        print("-------------------------------------")
+        print("-------------------------------------")
+
+        project_path = os.path.abspath(
+            os.path.join(os.path.dirname(sys.argv[1]), projects[project][2])
+        )
+
+        pretty = pretty_vcproj
+        argv = [
+            "",
+            project_path,
+            "$(SolutionDir)=%s\\" % os.path.dirname(sys.argv[1]),
+        ]
+        argv.extend(sys.argv[3:])
+        pretty.main(argv)
 
-    pretty = pretty_vcproj
-    argv = [ '',
-             project_path,
-             '$(SolutionDir)=%s\\' % os.path.dirname(sys.argv[1]),
-           ]
-    argv.extend(sys.argv[3:])
-    pretty.main(argv)
 
 def main():
-  # check if we have exactly 1 parameter.
-  if len(sys.argv) < 2:
-    print('Usage: %s "c:\\path\\to\\project.sln"' % sys.argv[0])
-    return 1
+    # check if we have exactly 1 parameter.
+    if len(sys.argv) < 2:
+        print('Usage: %s "c:\\path\\to\\project.sln"' % sys.argv[0])
+        return 1
 
-  (projects, deps) = ParseSolution(sys.argv[1])
-  PrintDependencies(projects, deps)
-  PrintBuildOrder(projects, deps)
+    (projects, deps) = ParseSolution(sys.argv[1])
+    PrintDependencies(projects, deps)
+    PrintBuildOrder(projects, deps)
 
-  if '--recursive' in sys.argv:
-    PrintVCProj(projects)
-  return 0
+    if "--recursive" in sys.argv:
+        PrintVCProj(projects)
+    return 0
 
 
-if __name__ == '__main__':
-  sys.exit(main())
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/gyp/tools/pretty_vcproj.py b/tools/gyp/tools/pretty_vcproj.py
index 3212626004778e37a1ecded4b262aba80238ffdb..b171fae6cf4442b339f437e003abdbacbd227c16 100755
--- a/tools/gyp/tools/pretty_vcproj.py
+++ b/tools/gyp/tools/pretty_vcproj.py
@@ -20,318 +20,326 @@ import sys
 from xml.dom.minidom import parse
 from xml.dom.minidom import Node
 
-__author__ = 'nsylvain (Nicolas Sylvain)'
+__author__ = "nsylvain (Nicolas Sylvain)"
 
 try:
-  cmp
+    cmp
 except NameError:
-  def cmp(x, y):
-    return (x > y) - (x < y)
+
+    def cmp(x, y):
+        return (x > y) - (x < y)
+
 
 REPLACEMENTS = dict()
 ARGUMENTS = None
 
 
 class CmpTuple(object):
-  """Compare function between 2 tuple."""
-  def __call__(self, x, y):
-    return cmp(x[0], y[0])
+    """Compare function between 2 tuple."""
+
+    def __call__(self, x, y):
+        return cmp(x[0], y[0])
 
 
 class CmpNode(object):
-  """Compare function between 2 xml nodes."""
+    """Compare function between 2 xml nodes."""
 
-  def __call__(self, x, y):
-    def get_string(node):
-      node_string = "node"
-      node_string += node.nodeName
-      if node.nodeValue:
-        node_string += node.nodeValue
+    def __call__(self, x, y):
+        def get_string(node):
+            node_string = "node"
+            node_string += node.nodeName
+            if node.nodeValue:
+                node_string += node.nodeValue
 
-      if node.attributes:
-        # We first sort by name, if present.
-        node_string += node.getAttribute("Name")
+            if node.attributes:
+                # We first sort by name, if present.
+                node_string += node.getAttribute("Name")
 
-        all_nodes = []
-        for (name, value) in node.attributes.items():
-          all_nodes.append((name, value))
+                all_nodes = []
+                for (name, value) in node.attributes.items():
+                    all_nodes.append((name, value))
 
-        all_nodes.sort(CmpTuple())
-        for (name, value) in all_nodes:
-          node_string += name
-          node_string += value
+                all_nodes.sort(CmpTuple())
+                for (name, value) in all_nodes:
+                    node_string += name
+                    node_string += value
 
-      return node_string
+            return node_string
 
-    return cmp(get_string(x), get_string(y))
+        return cmp(get_string(x), get_string(y))
 
 
 def PrettyPrintNode(node, indent=0):
-  if node.nodeType == Node.TEXT_NODE:
-    if node.data.strip():
-      print('%s%s' % (' '*indent, node.data.strip()))
-    return
-
-  if node.childNodes:
-    node.normalize()
-  # Get the number of attributes
-  attr_count = 0
-  if node.attributes:
-    attr_count = node.attributes.length
-
-  # Print the main tag
-  if attr_count == 0:
-    print('%s<%s>' % (' '*indent, node.nodeName))
-  else:
-    print('%s<%s' % (' '*indent, node.nodeName))
-
-    all_attributes = []
-    for (name, value) in node.attributes.items():
-      all_attributes.append((name, value))
-      all_attributes.sort(CmpTuple())
-    for (name, value) in all_attributes:
-      print('%s  %s="%s"' % (' '*indent, name, value))
-    print('%s>' % (' '*indent))
-  if node.nodeValue:
-    print('%s  %s' % (' '*indent, node.nodeValue))
-
-  for sub_node in node.childNodes:
-    PrettyPrintNode(sub_node, indent=indent+2)
-  print('%s</%s>' % (' '*indent, node.nodeName))
+    if node.nodeType == Node.TEXT_NODE:
+        if node.data.strip():
+            print("%s%s" % (" " * indent, node.data.strip()))
+        return
+
+    if node.childNodes:
+        node.normalize()
+    # Get the number of attributes
+    attr_count = 0
+    if node.attributes:
+        attr_count = node.attributes.length
+
+    # Print the main tag
+    if attr_count == 0:
+        print("%s<%s>" % (" " * indent, node.nodeName))
+    else:
+        print("%s<%s" % (" " * indent, node.nodeName))
+
+        all_attributes = []
+        for (name, value) in node.attributes.items():
+            all_attributes.append((name, value))
+            all_attributes.sort(CmpTuple())
+        for (name, value) in all_attributes:
+            print('%s  %s="%s"' % (" " * indent, name, value))
+        print("%s>" % (" " * indent))
+    if node.nodeValue:
+        print("%s  %s" % (" " * indent, node.nodeValue))
+
+    for sub_node in node.childNodes:
+        PrettyPrintNode(sub_node, indent=indent + 2)
+    print("%s</%s>" % (" " * indent, node.nodeName))
 
 
 def FlattenFilter(node):
-  """Returns a list of all the node and sub nodes."""
-  node_list = []
+    """Returns a list of all the node and sub nodes."""
+    node_list = []
 
-  if (node.attributes and
-      node.getAttribute('Name') == '_excluded_files'):
-      # We don't add the "_excluded_files" filter.
-    return []
+    if node.attributes and node.getAttribute("Name") == "_excluded_files":
+        # We don't add the "_excluded_files" filter.
+        return []
 
-  for current in node.childNodes:
-    if current.nodeName == 'Filter':
-      node_list.extend(FlattenFilter(current))
-    else:
-      node_list.append(current)
+    for current in node.childNodes:
+        if current.nodeName == "Filter":
+            node_list.extend(FlattenFilter(current))
+        else:
+            node_list.append(current)
 
-  return node_list
+    return node_list
 
 
 def FixFilenames(filenames, current_directory):
-  new_list = []
-  for filename in filenames:
-    if filename:
-      for key in REPLACEMENTS:
-        filename = filename.replace(key, REPLACEMENTS[key])
-      os.chdir(current_directory)
-      filename = filename.strip('"\' ')
-      if filename.startswith('$'):
-        new_list.append(filename)
-      else:
-        new_list.append(os.path.abspath(filename))
-  return new_list
+    new_list = []
+    for filename in filenames:
+        if filename:
+            for key in REPLACEMENTS:
+                filename = filename.replace(key, REPLACEMENTS[key])
+            os.chdir(current_directory)
+            filename = filename.strip("\"' ")
+            if filename.startswith("$"):
+                new_list.append(filename)
+            else:
+                new_list.append(os.path.abspath(filename))
+    return new_list
 
 
 def AbsoluteNode(node):
-  """Makes all the properties we know about in this node absolute."""
-  if node.attributes:
-    for (name, value) in node.attributes.items():
-      if name in ['InheritedPropertySheets', 'RelativePath',
-                  'AdditionalIncludeDirectories',
-                  'IntermediateDirectory', 'OutputDirectory',
-                  'AdditionalLibraryDirectories']:
-        # We want to fix up these paths
-        path_list = value.split(';')
-        new_list = FixFilenames(path_list, os.path.dirname(ARGUMENTS[1]))
-        node.setAttribute(name, ';'.join(new_list))
-      if not value:
-        node.removeAttribute(name)
+    """Makes all the properties we know about in this node absolute."""
+    if node.attributes:
+        for (name, value) in node.attributes.items():
+            if name in [
+                "InheritedPropertySheets",
+                "RelativePath",
+                "AdditionalIncludeDirectories",
+                "IntermediateDirectory",
+                "OutputDirectory",
+                "AdditionalLibraryDirectories",
+            ]:
+                # We want to fix up these paths
+                path_list = value.split(";")
+                new_list = FixFilenames(path_list, os.path.dirname(ARGUMENTS[1]))
+                node.setAttribute(name, ";".join(new_list))
+            if not value:
+                node.removeAttribute(name)
 
 
 def CleanupVcproj(node):
-  """For each sub node, we call recursively this function."""
-  for sub_node in node.childNodes:
-    AbsoluteNode(sub_node)
-    CleanupVcproj(sub_node)
-
-  # Normalize the node, and remove all extranous whitespaces.
-  for sub_node in node.childNodes:
-    if sub_node.nodeType == Node.TEXT_NODE:
-      sub_node.data = sub_node.data.replace("\r", "")
-      sub_node.data = sub_node.data.replace("\n", "")
-      sub_node.data = sub_node.data.rstrip()
-
-  # Fix all the semicolon separated attributes to be sorted, and we also
-  # remove the dups.
-  if node.attributes:
-    for (name, value) in node.attributes.items():
-      sorted_list = sorted(value.split(';'))
-      unique_list = []
-      for i in sorted_list:
-        if not unique_list.count(i):
-          unique_list.append(i)
-      node.setAttribute(name, ';'.join(unique_list))
-      if not value:
-        node.removeAttribute(name)
-
-  if node.childNodes:
-    node.normalize()
-
-  # For each node, take a copy, and remove it from the list.
-  node_array = []
-  while node.childNodes and node.childNodes[0]:
-    # Take a copy of the node and remove it from the list.
-    current = node.childNodes[0]
-    node.removeChild(current)
-
-    # If the child is a filter, we want to append all its children
-    # to this same list.
-    if current.nodeName == 'Filter':
-      node_array.extend(FlattenFilter(current))
-    else:
-      node_array.append(current)
-
-
-  # Sort the list.
-  node_array.sort(CmpNode())
-
-  # Insert the nodes in the correct order.
-  for new_node in node_array:
-    # But don't append empty tool node.
-    if new_node.nodeName == 'Tool':
-      if new_node.attributes and new_node.attributes.length == 1:
-        # This one was empty.
-        continue
-    if new_node.nodeName == 'UserMacro':
-      continue
-    node.appendChild(new_node)
+    """For each sub node, we call recursively this function."""
+    for sub_node in node.childNodes:
+        AbsoluteNode(sub_node)
+        CleanupVcproj(sub_node)
+
+    # Normalize the node, and remove all extraneous whitespaces.
+    for sub_node in node.childNodes:
+        if sub_node.nodeType == Node.TEXT_NODE:
+            sub_node.data = sub_node.data.replace("\r", "")
+            sub_node.data = sub_node.data.replace("\n", "")
+            sub_node.data = sub_node.data.rstrip()
+
+    # Fix all the semicolon separated attributes to be sorted, and we also
+    # remove the dups.
+    if node.attributes:
+        for (name, value) in node.attributes.items():
+            sorted_list = sorted(value.split(";"))
+            unique_list = []
+            for i in sorted_list:
+                if not unique_list.count(i):
+                    unique_list.append(i)
+            node.setAttribute(name, ";".join(unique_list))
+            if not value:
+                node.removeAttribute(name)
+
+    if node.childNodes:
+        node.normalize()
+
+    # For each node, take a copy, and remove it from the list.
+    node_array = []
+    while node.childNodes and node.childNodes[0]:
+        # Take a copy of the node and remove it from the list.
+        current = node.childNodes[0]
+        node.removeChild(current)
+
+        # If the child is a filter, we want to append all its children
+        # to this same list.
+        if current.nodeName == "Filter":
+            node_array.extend(FlattenFilter(current))
+        else:
+            node_array.append(current)
+
+    # Sort the list.
+    node_array.sort(CmpNode())
+
+    # Insert the nodes in the correct order.
+    for new_node in node_array:
+        # But don't append empty tool node.
+        if new_node.nodeName == "Tool":
+            if new_node.attributes and new_node.attributes.length == 1:
+                # This one was empty.
+                continue
+        if new_node.nodeName == "UserMacro":
+            continue
+        node.appendChild(new_node)
 
 
 def GetConfiguationNodes(vcproj):
-  #TODO(nsylvain): Find a better way to navigate the xml.
-  nodes = []
-  for node in vcproj.childNodes:
-    if node.nodeName == "Configurations":
-      for sub_node in node.childNodes:
-        if sub_node.nodeName == "Configuration":
-          nodes.append(sub_node)
+    # TODO(nsylvain): Find a better way to navigate the xml.
+    nodes = []
+    for node in vcproj.childNodes:
+        if node.nodeName == "Configurations":
+            for sub_node in node.childNodes:
+                if sub_node.nodeName == "Configuration":
+                    nodes.append(sub_node)
 
-  return nodes
+    return nodes
 
 
 def GetChildrenVsprops(filename):
-  dom = parse(filename)
-  if dom.documentElement.attributes:
-    vsprops = dom.documentElement.getAttribute('InheritedPropertySheets')
-    return FixFilenames(vsprops.split(';'), os.path.dirname(filename))
-  return []
+    dom = parse(filename)
+    if dom.documentElement.attributes:
+        vsprops = dom.documentElement.getAttribute("InheritedPropertySheets")
+        return FixFilenames(vsprops.split(";"), os.path.dirname(filename))
+    return []
 
-def SeekToNode(node1, child2):
-  # A text node does not have properties.
-  if child2.nodeType == Node.TEXT_NODE:
-    return None
 
-  # Get the name of the current node.
-  current_name = child2.getAttribute("Name")
-  if not current_name:
-    # There is no name. We don't know how to merge.
+def SeekToNode(node1, child2):
+    # A text node does not have properties.
+    if child2.nodeType == Node.TEXT_NODE:
+        return None
+
+    # Get the name of the current node.
+    current_name = child2.getAttribute("Name")
+    if not current_name:
+        # There is no name. We don't know how to merge.
+        return None
+
+    # Look through all the nodes to find a match.
+    for sub_node in node1.childNodes:
+        if sub_node.nodeName == child2.nodeName:
+            name = sub_node.getAttribute("Name")
+            if name == current_name:
+                return sub_node
+
+    # No match. We give up.
     return None
 
-  # Look through all the nodes to find a match.
-  for sub_node in node1.childNodes:
-    if sub_node.nodeName == child2.nodeName:
-      name = sub_node.getAttribute("Name")
-      if name == current_name:
-        return sub_node
-
-  # No match. We give up.
-  return None
-
 
 def MergeAttributes(node1, node2):
-  # No attributes to merge?
-  if not node2.attributes:
-    return
-
-  for (name, value2) in node2.attributes.items():
-    # Don't merge the 'Name' attribute.
-    if name == 'Name':
-      continue
-    value1 = node1.getAttribute(name)
-    if value1:
-      # The attribute exist in the main node. If it's equal, we leave it
-      # untouched, otherwise we concatenate it.
-      if value1 != value2:
-        node1.setAttribute(name, ';'.join([value1, value2]))
-    else:
-      # The attribute does not exist in the main node. We append this one.
-      node1.setAttribute(name, value2)
-
-    # If the attribute was a property sheet attributes, we remove it, since
-    # they are useless.
-    if name == 'InheritedPropertySheets':
-      node1.removeAttribute(name)
+    # No attributes to merge?
+    if not node2.attributes:
+        return
+
+    for (name, value2) in node2.attributes.items():
+        # Don't merge the 'Name' attribute.
+        if name == "Name":
+            continue
+        value1 = node1.getAttribute(name)
+        if value1:
+            # The attribute exist in the main node. If it's equal, we leave it
+            # untouched, otherwise we concatenate it.
+            if value1 != value2:
+                node1.setAttribute(name, ";".join([value1, value2]))
+        else:
+            # The attribute does not exist in the main node. We append this one.
+            node1.setAttribute(name, value2)
+
+        # If the attribute was a property sheet attributes, we remove it, since
+        # they are useless.
+        if name == "InheritedPropertySheets":
+            node1.removeAttribute(name)
 
 
 def MergeProperties(node1, node2):
-  MergeAttributes(node1, node2)
-  for child2 in node2.childNodes:
-    child1 = SeekToNode(node1, child2)
-    if child1:
-      MergeProperties(child1, child2)
-    else:
-      node1.appendChild(child2.cloneNode(True))
+    MergeAttributes(node1, node2)
+    for child2 in node2.childNodes:
+        child1 = SeekToNode(node1, child2)
+        if child1:
+            MergeProperties(child1, child2)
+        else:
+            node1.appendChild(child2.cloneNode(True))
 
 
 def main(argv):
-  """Main function of this vcproj prettifier."""
-  global ARGUMENTS
-  ARGUMENTS = argv
-
-  # check if we have exactly 1 parameter.
-  if len(argv) < 2:
-    print('Usage: %s "c:\\path\\to\\vcproj.vcproj" [key1=value1] '
-          '[key2=value2]' % argv[0])
-    return 1
-
-  # Parse the keys
-  for i in range(2, len(argv)):
-    (key, value) = argv[i].split('=')
-    REPLACEMENTS[key] = value
-
-  # Open the vcproj and parse the xml.
-  dom = parse(argv[1])
-
-  # First thing we need to do is find the Configuration Node and merge them
-  # with the vsprops they include.
-  for configuration_node in GetConfiguationNodes(dom.documentElement):
-    # Get the property sheets associated with this configuration.
-    vsprops = configuration_node.getAttribute('InheritedPropertySheets')
-
-    # Fix the filenames to be absolute.
-    vsprops_list = FixFilenames(vsprops.strip().split(';'),
-                                os.path.dirname(argv[1]))
-
-    # Extend the list of vsprops with all vsprops contained in the current
-    # vsprops.
-    for current_vsprops in vsprops_list:
-      vsprops_list.extend(GetChildrenVsprops(current_vsprops))
-
-    # Now that we have all the vsprops, we need to merge them.
-    for current_vsprops in vsprops_list:
-      MergeProperties(configuration_node,
-                      parse(current_vsprops).documentElement)
-
-  # Now that everything is merged, we need to cleanup the xml.
-  CleanupVcproj(dom.documentElement)
-
-  # Finally, we use the prett xml function to print the vcproj back to the
-  # user.
-  #print dom.toprettyxml(newl="\n")
-  PrettyPrintNode(dom.documentElement)
-  return 0
-
-
-if __name__ == '__main__':
-  sys.exit(main(sys.argv))
+    """Main function of this vcproj prettifier."""
+    global ARGUMENTS
+    ARGUMENTS = argv
+
+    # check if we have exactly 1 parameter.
+    if len(argv) < 2:
+        print(
+            'Usage: %s "c:\\path\\to\\vcproj.vcproj" [key1=value1] '
+            "[key2=value2]" % argv[0]
+        )
+        return 1
+
+    # Parse the keys
+    for i in range(2, len(argv)):
+        (key, value) = argv[i].split("=")
+        REPLACEMENTS[key] = value
+
+    # Open the vcproj and parse the xml.
+    dom = parse(argv[1])
+
+    # First thing we need to do is find the Configuration Node and merge them
+    # with the vsprops they include.
+    for configuration_node in GetConfiguationNodes(dom.documentElement):
+        # Get the property sheets associated with this configuration.
+        vsprops = configuration_node.getAttribute("InheritedPropertySheets")
+
+        # Fix the filenames to be absolute.
+        vsprops_list = FixFilenames(
+            vsprops.strip().split(";"), os.path.dirname(argv[1])
+        )
+
+        # Extend the list of vsprops with all vsprops contained in the current
+        # vsprops.
+        for current_vsprops in vsprops_list:
+            vsprops_list.extend(GetChildrenVsprops(current_vsprops))
+
+        # Now that we have all the vsprops, we need to merge them.
+        for current_vsprops in vsprops_list:
+            MergeProperties(configuration_node, parse(current_vsprops).documentElement)
+
+    # Now that everything is merged, we need to cleanup the xml.
+    CleanupVcproj(dom.documentElement)
+
+    # Finally, we use the prett xml function to print the vcproj back to the
+    # user.
+    # print dom.toprettyxml(newl="\n")
+    PrettyPrintNode(dom.documentElement)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))
diff --git a/tools/icu/README.md b/tools/icu/README.md
index 011ce1f24f7ca9b70a207e5d3ebfc13c2fa1adae..ab90b760b8c844a141c8135372a22e7b7acf374c 100644
--- a/tools/icu/README.md
+++ b/tools/icu/README.md
@@ -1,8 +1,8 @@
 # Notes about the `tools/icu` subdirectory
 
-This directory contains tools, data, and information about the [ICU](http://icu-project.org)
-(International Components for Unicode) integration. ICU is used to provide
-internationalization functionality.
+This directory contains tools and information about the
+[International Components for Unicode][ICU] (ICU) integration.
+Both V8 and Node.js use ICU to provide internationalization functionality.
 
 * `patches/` are one-off patches, actually entire source file replacements,
   organized by ICU version number.
@@ -14,123 +14,24 @@ internationalization functionality.
    is invoked. It builds against the `pkg-config` located ICU.
 * `iculslocs.cc` is source for the `iculslocs` utility, invoked by `icutrim.py`
    as part of repackaging. Not used separately. See source for more details.
-* `no-op.cc` — empty function to convince gyp to use a C++ compiler.
-* `README.md` — you are here
-* `shrink-icu-src.py` — this is used during upgrade (see guide below)
+* `no-op.cc` contains an empty function to convince gyp to use a C++ compiler.
+* `shrink-icu-src.py` is used during upgrade (see guide below).
 
-## How to upgrade ICU
+Note:
+> The files in this directory were written for the Node.js v0.12 effort.
+> The original intent was to merge the tools such as `icutrim.py` and `iculslocs.cc`
+> back into ICU. ICU has gained its own “data slicer” tool.
+> There is an issue open, <https://github.com/nodejs/node/issues/25136>
+> for replacing `icutrim.py` with the [ICU data slicer][].
 
-* Make sure your Node.js workspace is clean (clean `git status`) should be
-  sufficient.
-* Configure Node.js with the specific [ICU version](http://icu-project.org/download)
-  you want to upgrade to, for example:
+## See Also
 
-```bash
-./configure \
-    --with-intl=small-icu \
-    --with-icu-source=http://download.icu-project.org/files/icu4c/58.1/icu4c-58_1-src.tgz
-make
-```
+* [docs/guides/maintaining-icu.md](../../doc/guides/maintaining-icu.md) for
+information on maintaining ICU in Node.js
 
-> _Note_ in theory, the equivalent `vcbuild.bat` commands should work also,
-> but the commands below are makefile-centric.
+* [docs/api/intl.md](../../doc/api/intl.md) for information on the
+internationalization-related APIs in Node.js
+* [The ICU Homepage][ICU]
 
-* If there are ICU version-specific changes needed, you may need to make changes
-  in `icu-generic.gyp` or add patch files to `tools/icu/patches`.
-  * Specifically, look for the lists in `sources!` in the `icu-generic.gyp` for
-  files to exclude.
-
-* Verify the Node.js build works:
-
-```bash
-make test-ci
-```
-
-Also running
-
-<!-- eslint-disable strict -->
-
-```js
-new Intl.DateTimeFormat('es', {month: 'long'}).format(new Date(9E8));
-```
-
-…Should return `January` not `enero`.
-
-* Now, copy `deps/icu` over to `deps/icu-small`
-
-```bash
-python tools/icu/shrink-icu-src.py
-```
-
-* Now, do a clean rebuild of Node.js to test:
-
-```bash
-make -k distclean
-./configure
-make
-```
-
-* Test this newly default-generated Node.js
-
-<!-- eslint-disable strict -->
-
-```js
-process.versions.icu;
-new Intl.DateTimeFormat('es', {month: 'long'}).format(new Date(9E8));
-```
-
-(This should print your updated ICU version number, and also `January` again.)
-
-You are ready to check in the updated `deps/small-icu`. This is a big commit,
-so make this a separate commit from the smaller changes.
-
-* Now, rebuild the Node.js license.
-
-```bash
-# clean up - remove deps/icu
-make clean
-tools/license-builder.sh
-```
-
-* Update the URL and hash for the full ICU file in `tools/icu/current_ver.dep`.
-It should match the ICU URL used in the first step.  When this is done, the
-following should build with full ICU.
-
-```bash
-# clean up
-rm -rf out deps/icu deps/icu4c*
-./configure --with-intl=full-icu --download=all
-make
-make test-ci
-```
-
-* commit the change to `tools/icu/current_ver.dep` and `LICENSE` files.
-
-  * Note: To simplify review, I often will “pre-land” this patch, meaning that
-  I run the patch through `curl -L https://github.com/nodejs/node/pull/xxx.patch
-  | git am -3 --whitespace=fix` per the collaborator’s guide… and then push that
-  patched branch into my PR's branch. This reduces the whitespace changes that
-  show up in the PR, since the final land will eliminate those anyway.
-
------
-
-## Postscript about the tools
-
-The files in this directory were written for the Node.js effort.
-It was the intent of their author (Steven R. Loomis / srl295) to
-merge them upstream into ICU, pending much discussion within the
-ICU-TC.
-
-`icu_small.json` is somewhat node-specific as it specifies a "small ICU"
-configuration file for the `icutrim.py` script. `icutrim.py` and
-`iculslocs.cpp` may themselves be superseded by components built into
-ICU in the future. As of this writing, however, the tools are separate
-entities within Node.js, although theyare being scrutinized by interested
-members of the ICU-TC. The “upstream” ICU bugs are given below.
-
-* [#10919](http://bugs.icu-project.org/trac/ticket/10919)
-  (experimental branch - may copy any source patches here)
-* [#10922](http://bugs.icu-project.org/trac/ticket/10922)
-  (data packaging improvements)
-* [#10923](http://bugs.icu-project.org/trac/ticket/10923)
-  (rewrite data building in python)
+[ICU]: http://icu-project.org
+[ICU data slicer]: https://github.com/unicode-org/icu/blob/master/docs/userguide/icu_data/buildtool.md
diff --git a/tools/icu/current_ver.dep b/tools/icu/current_ver.dep
index f22f158c30bcfd5cacbc5d64493023e534bb0bcc..4ab415d8757b24a2fdae6be90817b37900728f3c 100644
--- a/tools/icu/current_ver.dep
+++ b/tools/icu/current_ver.dep
@@ -1,6 +1,6 @@
 [
   {
-    "url": "https://github.com/unicode-org/icu/releases/download/release-67-1/icu4c-67_1-src.tgz",
-    "md5": "c4d62b497cbd89ab2a9ca6b543e57b30"
+    "url": "https://github.com/unicode-org/icu/releases/download/release-69-1/icu4c-69_1-src.tgz",
+    "md5": "9403db682507369d0f60a25ea67014c4"
   }
 ]
diff --git a/tools/icu/icu-generic.gyp b/tools/icu/icu-generic.gyp
index b8f0d13836dee176b5fdea348594aaba1f1bac3b..363391449260966a3c4186d0cda84d07188c1447 100644
--- a/tools/icu/icu-generic.gyp
+++ b/tools/icu/icu-generic.gyp
@@ -107,80 +107,6 @@
           'sources': [
             '<@(icu_src_i18n)'
           ],
-          ## if your compiler can dead-strip, these exclusions will
-          ## make ZERO difference to binary size.
-          ## Made ICU-specific for future-proofing.
-          'conditions': [
-            [ 'icu_ver_major == 55', { 'sources!': [
-              # alphabetic index
-              '<(icu_path)/source/i18n/alphaindex.cpp',
-              # BOCSU
-              # misc
-              '<(icu_path)/source/i18n/regexcmp.cpp',
-              '<(icu_path)/source/i18n/regexcmp.h',
-              '<(icu_path)/source/i18n/regexcst.h',
-              '<(icu_path)/source/i18n/regeximp.cpp',
-              '<(icu_path)/source/i18n/regeximp.h',
-              '<(icu_path)/source/i18n/regexst.cpp',
-              '<(icu_path)/source/i18n/regexst.h',
-              '<(icu_path)/source/i18n/regextxt.cpp',
-              '<(icu_path)/source/i18n/regextxt.h',
-              '<(icu_path)/source/i18n/region.cpp',
-              '<(icu_path)/source/i18n/region_impl.h',
-              '<(icu_path)/source/i18n/reldatefmt.cpp',
-              '<(icu_path)/source/i18n/reldatefmt.h'
-              '<(icu_path)/source/i18n/scientificformathelper.cpp',
-              '<(icu_path)/source/i18n/tmunit.cpp',
-              '<(icu_path)/source/i18n/tmutamt.cpp',
-              '<(icu_path)/source/i18n/tmutfmt.cpp',
-              '<(icu_path)/source/i18n/uregex.cpp',
-              '<(icu_path)/source/i18n/uregexc.cpp',
-              '<(icu_path)/source/i18n/uregion.cpp',
-              '<(icu_path)/source/i18n/uspoof.cpp',
-              '<(icu_path)/source/i18n/uspoof_build.cpp',
-              '<(icu_path)/source/i18n/uspoof_conf.cpp',
-              '<(icu_path)/source/i18n/uspoof_conf.h',
-              '<(icu_path)/source/i18n/uspoof_impl.cpp',
-              '<(icu_path)/source/i18n/uspoof_impl.h',
-              '<(icu_path)/source/i18n/uspoof_wsconf.cpp',
-              '<(icu_path)/source/i18n/uspoof_wsconf.h',
-            ]}],
-            [ 'icu_ver_major == 57', { 'sources!': [
-
-              # alphabetic index
-              '<(icu_path)/source/i18n/alphaindex.cpp',
-              # BOCSU
-              # misc
-              '<(icu_path)/source/i18n/regexcmp.cpp',
-              '<(icu_path)/source/i18n/regexcmp.h',
-              '<(icu_path)/source/i18n/regexcst.h',
-              '<(icu_path)/source/i18n/regeximp.cpp',
-              '<(icu_path)/source/i18n/regeximp.h',
-              '<(icu_path)/source/i18n/regexst.cpp',
-              '<(icu_path)/source/i18n/regexst.h',
-              '<(icu_path)/source/i18n/regextxt.cpp',
-              '<(icu_path)/source/i18n/regextxt.h',
-              '<(icu_path)/source/i18n/region.cpp',
-              '<(icu_path)/source/i18n/region_impl.h',
-              '<(icu_path)/source/i18n/reldatefmt.cpp',
-              '<(icu_path)/source/i18n/reldatefmt.h'
-              '<(icu_path)/source/i18n/scientificformathelper.cpp',
-              '<(icu_path)/source/i18n/tmunit.cpp',
-              '<(icu_path)/source/i18n/tmutamt.cpp',
-              '<(icu_path)/source/i18n/tmutfmt.cpp',
-              '<(icu_path)/source/i18n/uregex.cpp',
-              '<(icu_path)/source/i18n/uregexc.cpp',
-              '<(icu_path)/source/i18n/uregion.cpp',
-              '<(icu_path)/source/i18n/uspoof.cpp',
-              '<(icu_path)/source/i18n/uspoof_build.cpp',
-              '<(icu_path)/source/i18n/uspoof_conf.cpp',
-              '<(icu_path)/source/i18n/uspoof_conf.h',
-              '<(icu_path)/source/i18n/uspoof_impl.cpp',
-              '<(icu_path)/source/i18n/uspoof_impl.h',
-              '<(icu_path)/source/i18n/uspoof_wsconf.cpp',
-              '<(icu_path)/source/i18n/uspoof_wsconf.h',
-            ]}],
-            ],
           'include_dirs': [
             '<(icu_path)/source/i18n',
           ],
@@ -197,7 +123,7 @@
         }],
         ['_toolset=="host"', {
           'type': 'none',
-          'dependencies': [ 'icutools' ],
+          'dependencies': [ 'icutools#host' ],
           'export_dependent_settings': [ 'icutools' ],
         }],
       ],
@@ -212,16 +138,17 @@
           'conditions': [
             [ 'icu_small == "false"', { # and OS=win
               # full data - just build the full data file, then we are done.
-              'sources': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.obj' ],
+              'sources': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.<(icu_asm_ext)' ],
               'dependencies': [ 'genccode#host' ],
               'actions': [
                 {
                   'action_name': 'icudata',
                   'msvs_quote_cmd': 0,
                   'inputs': [ '<(icu_data_in)' ],
-                  'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.obj' ],
-                  'action': [ '<(PRODUCT_DIR)/genccode',
-                              '-o',
+                  'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.<(icu_asm_ext)' ],
+                  # on Windows, we can go directly to .obj file (-o) option.
+                  'action': [ '<(PRODUCT_DIR)/genccode<(EXECUTABLE_SUFFIX)',
+                              '<@(icu_asm_opts)', # -o
                               '-d', '<(SHARED_INTERMEDIATE_DIR)',
                               '-n', 'icudata',
                               '-e', 'icudt<(icu_ver_major)',
@@ -256,9 +183,9 @@
                   'action_name': 'genccode',
                   'msvs_quote_cmd': 0,
                   'inputs': [ '<(SHARED_INTERMEDIATE_DIR)/icutmp/icudt<(icu_ver_major)<(icu_endianness).dat' ],
-                  'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.obj' ],
-                  'action': [ '<(PRODUCT_DIR)/genccode',
-                              '-o',
+                  'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.<(icu_asm_ext)' ],
+                  'action': [ '<(PRODUCT_DIR)/genccode<(EXECUTABLE_SUFFIX)',
+                              '<@(icu_asm_opts)', # -o
                               '-d', '<(SHARED_INTERMEDIATE_DIR)/',
                               '-n', 'icudata',
                               '-e', 'icusmdt<(icu_ver_major)',
@@ -266,31 +193,31 @@
                 },
               ],
               # This file contains the small ICU data.
-              'sources': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.obj' ],
+              'sources': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness)_dat.<(icu_asm_ext)' ],
             } ] ], #end of OS==win and icu_small == true
         }, { # OS != win
           'conditions': [
             [ 'icu_small == "false"', {
-              # full data - just build the full data file, then we are done.
-              'sources': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)_dat.c' ],
+              # full data - no trim needed
+              'sources': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)_dat.<(icu_asm_ext)' ],
               'dependencies': [ 'genccode#host', 'icupkg#host', 'icu_implementation#host', 'icu_uconfig' ],
               'include_dirs': [
                 '<(icu_path)/source/common',
               ],
               'actions': [
                 {
-                   # Swap endianness (if needed), or at least copy the file
+                   # Copy the .dat file, swapping endianness if needed.
                    'action_name': 'icupkg',
                    'inputs': [ '<(icu_data_in)' ],
                    'outputs':[ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness).dat' ],
-                   'action': [ '<(PRODUCT_DIR)/icupkg',
+                   'action': [ '<(PRODUCT_DIR)/icupkg<(EXECUTABLE_SUFFIX)',
                                '-t<(icu_endianness)',
                                '<@(_inputs)',
                                '<@(_outputs)',
                              ],
                 },
                 {
-                   # Rename without the endianness marker
+                   # Rename without the endianness marker (icudt64l.dat -> icudt64.dat)
                    'action_name': 'copy',
                    'inputs': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)<(icu_endianness).dat' ],
                    'outputs':[ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major).dat' ],
@@ -300,12 +227,14 @@
                              ],
                 },
                 {
+                  # convert full ICU data file to .c, or .S, etc.
                   'action_name': 'icudata',
                   'inputs': [ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major).dat' ],
-                  'outputs':[ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)_dat.c' ],
-                  'action': [ '<(PRODUCT_DIR)/genccode',
+                  'outputs':[ '<(SHARED_INTERMEDIATE_DIR)/icudt<(icu_ver_major)_dat.<(icu_asm_ext)' ],
+                  'action': [ '<(PRODUCT_DIR)/genccode<(EXECUTABLE_SUFFIX)',
                               '-e', 'icudt<(icu_ver_major)',
                               '-d', '<(SHARED_INTERMEDIATE_DIR)',
+                              '<@(icu_asm_opts)',
                               '-f', 'icudt<(icu_ver_major)_dat',
                               '<@(_inputs)' ],
                 },
@@ -318,7 +247,8 @@
               'export_dependent_settings': [ 'icustubdata' ],
               'actions': [
                 {
-                  # trim down ICU
+                  # Trim down ICU.
+                  # Note that icupkg is invoked automatically, swapping endianness if needed.
                   'action_name': 'icutrim',
                   'inputs': [ '<(icu_data_in)', 'icu_small.json' ],
                   'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icutmp/icudt<(icu_ver_major)<(icu_endianness).dat' ],
@@ -333,7 +263,7 @@
                               '-v',
                               '-L', '<(icu_locales)'],
                 }, {
-                  # rename to get the final entrypoint name right
+                  # rename to get the final entrypoint name right (icudt64l.dat -> icusmdt64.dat)
                    'action_name': 'rename',
                    'inputs': [ '<(SHARED_INTERMEDIATE_DIR)/icutmp/icudt<(icu_ver_major)<(icu_endianness).dat' ],
                    'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icutmp/icusmdt<(icu_ver_major).dat' ],
@@ -342,17 +272,18 @@
                                '<@(_outputs)',
                              ],
                 }, {
-                  # build final .dat -> .obj
+                  # For icu-small, always use .c, don't try to use .S, etc.
                   'action_name': 'genccode',
                   'inputs': [ '<(SHARED_INTERMEDIATE_DIR)/icutmp/icusmdt<(icu_ver_major).dat' ],
-                  'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icusmdt<(icu_ver_major)_dat.c' ],
-                  'action': [ '<(PRODUCT_DIR)/genccode',
+                  'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/icusmdt<(icu_ver_major)_dat.<(icu_asm_ext)' ],
+                  'action': [ '<(PRODUCT_DIR)/genccode<(EXECUTABLE_SUFFIX)',
+                              '<@(icu_asm_opts)',
                               '-d', '<(SHARED_INTERMEDIATE_DIR)',
                               '<@(_inputs)' ],
                 },
               ],
               # This file contains the small ICU data
-              'sources': [ '<(SHARED_INTERMEDIATE_DIR)/icusmdt<(icu_ver_major)_dat.c' ],
+              'sources': [ '<(SHARED_INTERMEDIATE_DIR)/icusmdt<(icu_ver_major)_dat.<(icu_asm_ext)' ],
               # for umachine.h
               'include_dirs': [
                 '<(icu_path)/source/common',
@@ -383,7 +314,7 @@
       'toolsets': [ 'target', 'host' ],
       'conditions' : [
         ['_toolset=="host"', {
-          'dependencies': [ 'icutools' ],
+          'dependencies': [ 'icutools#host' ],
           'export_dependent_settings': [ 'icutools' ],
         }],
         ['_toolset=="target"', {
@@ -405,35 +336,6 @@
           ## make ZERO difference to binary size.
           ## Made ICU-specific for future-proofing.
       'conditions': [
-        [ 'icu_ver_major == 55', { 'sources!': [
-
-          # bidi- not needed (yet!)
-          '<(icu_path)/source/common/ubidi.c',
-          '<(icu_path)/source/common/ubidiimp.h',
-          '<(icu_path)/source/common/ubidiln.c',
-          '<(icu_path)/source/common/ubidiwrt.c',
-          #'<(icu_path)/source/common/ubidi_props.c',
-          #'<(icu_path)/source/common/ubidi_props.h',
-          #'<(icu_path)/source/common/ubidi_props_data.h',
-          # and the callers
-          '<(icu_path)/source/common/ushape.cpp',
-        ]}],
-        [ 'icu_ver_major == 57', { 'sources!': [
-          # work around http://bugs.icu-project.org/trac/ticket/12451
-          # (benign afterwards)
-          '<(icu_path)/source/common/cstr.cpp',
-
-          # bidi- not needed (yet!)
-          '<(icu_path)/source/common/ubidi.c',
-          '<(icu_path)/source/common/ubidiimp.h',
-          '<(icu_path)/source/common/ubidiln.c',
-          '<(icu_path)/source/common/ubidiwrt.c',
-          #'<(icu_path)/source/common/ubidi_props.c',
-          #'<(icu_path)/source/common/ubidi_props.h',
-          #'<(icu_path)/source/common/ubidi_props_data.h',
-          # and the callers
-          '<(icu_path)/source/common/ushape.cpp',
-        ]}],
         [ 'OS == "solaris"', { 'defines': [
           '_XOPEN_SOURCE_EXTENDED=0',
         ]}],
diff --git a/tools/icu/icu_versions.json b/tools/icu/icu_versions.json
index e6929ac6a3bc590c289f264526f60044dcfa154b..a14ea6db2887ae20c4e93d1009f72ef933957570 100644
--- a/tools/icu/icu_versions.json
+++ b/tools/icu/icu_versions.json
@@ -1,3 +1,3 @@
 {
-    "minimum_icu": 64
+    "minimum_icu": 65
 }
diff --git a/tools/icu/iculslocs.cc b/tools/icu/iculslocs.cc
index e0de23774594f3e70b7d6a906fdc796716239ec6..ad4fc37cb49aea80165fecd2d254048c2f2afa16 100644
--- a/tools/icu/iculslocs.cc
+++ b/tools/icu/iculslocs.cc
@@ -150,7 +150,7 @@ int localeExists(const char* loc, UBool* exists) {
   }
   icu::LocalUResourceBundlePointer aResource(
       ures_openDirect(packageName.data(), loc, &status));
-  *exists = FALSE;
+  *exists = false;
   if (U_SUCCESS(status)) {
     *exists = true;
     if (VERBOSE > 1) {
diff --git a/tools/icu/patches/64/source/common/putil.cpp b/tools/icu/patches/64/source/common/putil.cpp
deleted file mode 100644
index 59cf232afee6a8d18e371ed95cfdf321ab6b02bb..0000000000000000000000000000000000000000
--- a/tools/icu/patches/64/source/common/putil.cpp
+++ /dev/null
@@ -1,2415 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 1997-2016, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*
-*  FILE NAME : putil.c (previously putil.cpp and ptypes.cpp)
-*
-*   Date        Name        Description
-*   04/14/97    aliu        Creation.
-*   04/24/97    aliu        Added getDefaultDataDirectory() and
-*                            getDefaultLocaleID().
-*   04/28/97    aliu        Rewritten to assume Unix and apply general methods
-*                            for assumed case.  Non-UNIX platforms must be
-*                            special-cased.  Rewrote numeric methods dealing
-*                            with NaN and Infinity to be platform independent
-*                             over all IEEE 754 platforms.
-*   05/13/97    aliu        Restored sign of timezone
-*                            (semantics are hours West of GMT)
-*   06/16/98    erm         Added IEEE_754 stuff, cleaned up isInfinite, isNan,
-*                             nextDouble..
-*   07/22/98    stephen     Added remainder, max, min, trunc
-*   08/13/98    stephen     Added isNegativeInfinity, isPositiveInfinity
-*   08/24/98    stephen     Added longBitsFromDouble
-*   09/08/98    stephen     Minor changes for Mac Port
-*   03/02/99    stephen     Removed openFile().  Added AS400 support.
-*                            Fixed EBCDIC tables
-*   04/15/99    stephen     Converted to C.
-*   06/28/99    stephen     Removed mutex locking in u_isBigEndian().
-*   08/04/99    jeffrey R.  Added OS/2 changes
-*   11/15/99    helena      Integrated S/390 IEEE support.
-*   04/26/01    Barry N.    OS/400 support for uprv_getDefaultLocaleID
-*   08/15/01    Steven H.   OS/400 support for uprv_getDefaultCodepage
-*   01/03/08    Steven L.   Fake Time Support
-******************************************************************************
-*/
-
-// Defines _XOPEN_SOURCE for access to POSIX functions.
-// Must be before any other #includes.
-#include "uposixdefs.h"
-
-// First, the platform type. Need this for U_PLATFORM.
-#include "unicode/platform.h"
-
-#if U_PLATFORM == U_PF_MINGW && defined __STRICT_ANSI__
-/* tzset isn't defined in strict ANSI on MinGW. */
-#undef __STRICT_ANSI__
-#endif
-
-/*
- * Cygwin with GCC requires inclusion of time.h after the above disabling strict asci mode statement.
- */
-#include <time.h>
-
-#if !U_PLATFORM_USES_ONLY_WIN32_API
-#include <sys/time.h>
-#endif
-
-/* include the rest of the ICU headers */
-#include "unicode/putil.h"
-#include "unicode/ustring.h"
-#include "putilimp.h"
-#include "uassert.h"
-#include "umutex.h"
-#include "cmemory.h"
-#include "cstring.h"
-#include "locmap.h"
-#include "ucln_cmn.h"
-#include "charstr.h"
-
-/* Include standard headers. */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <locale.h>
-#include <float.h>
-
-#ifndef U_COMMON_IMPLEMENTATION
-#error U_COMMON_IMPLEMENTATION not set - must be set for all ICU source files in common/ - see http://userguide.icu-project.org/howtouseicu
-#endif
-
-
-/* include system headers */
-#if U_PLATFORM_USES_ONLY_WIN32_API
-    /*
-     * TODO: U_PLATFORM_USES_ONLY_WIN32_API includes MinGW.
-     * Should Cygwin be included as well (U_PLATFORM_HAS_WIN32_API)
-     * to use native APIs as much as possible?
-     */
-#ifndef WIN32_LEAN_AND_MEAN
-#   define WIN32_LEAN_AND_MEAN
-#endif
-#   define VC_EXTRALEAN
-#   define NOUSER
-#   define NOSERVICE
-#   define NOIME
-#   define NOMCX
-#   include <windows.h>
-#   include "unicode/uloc.h"
-#   include "wintz.h"
-#elif U_PLATFORM == U_PF_OS400
-#   include <float.h>
-#   include <qusec.h>       /* error code structure */
-#   include <qusrjobi.h>
-#   include <qliept.h>      /* EPT_CALL macro  - this include must be after all other "QSYSINCs" */
-#   include <mih/testptr.h> /* For uprv_maximumPtr */
-#elif U_PLATFORM == U_PF_OS390
-#   include "unicode/ucnv.h"   /* Needed for UCNV_SWAP_LFNL_OPTION_STRING */
-#elif U_PLATFORM_IS_DARWIN_BASED || U_PLATFORM_IS_LINUX_BASED || U_PLATFORM == U_PF_BSD || U_PLATFORM == U_PF_SOLARIS
-#   include <limits.h>
-#   include <unistd.h>
-#   if U_PLATFORM == U_PF_SOLARIS
-#       ifndef _XPG4_2
-#           define _XPG4_2
-#       endif
-#   endif
-#elif U_PLATFORM == U_PF_QNX
-#   include <sys/neutrino.h>
-#endif
-
-/*
- * Only include langinfo.h if we have a way to get the codeset. If we later
- * depend on more feature, we can test on U_HAVE_NL_LANGINFO.
- *
- */
-
-#if U_HAVE_NL_LANGINFO_CODESET
-#include <langinfo.h>
-#endif
-
-/**
- * Simple things (presence of functions, etc) should just go in configure.in and be added to
- * icucfg.h via autoheader.
- */
-#if U_PLATFORM_IMPLEMENTS_POSIX
-#   if U_PLATFORM == U_PF_OS400
-#    define HAVE_DLFCN_H 0
-#    define HAVE_DLOPEN 0
-#   else
-#   ifndef HAVE_DLFCN_H
-#    define HAVE_DLFCN_H 1
-#   endif
-#   ifndef HAVE_DLOPEN
-#    define HAVE_DLOPEN 1
-#   endif
-#   endif
-#   ifndef HAVE_GETTIMEOFDAY
-#    define HAVE_GETTIMEOFDAY 1
-#   endif
-#else
-#   define HAVE_DLFCN_H 0
-#   define HAVE_DLOPEN 0
-#   define HAVE_GETTIMEOFDAY 0
-#endif
-
-U_NAMESPACE_USE
-
-/* Define the extension for data files, again... */
-#define DATA_TYPE "dat"
-
-/* Leave this copyright notice here! */
-static const char copyright[] = U_COPYRIGHT_STRING;
-
-/* floating point implementations ------------------------------------------- */
-
-/* We return QNAN rather than SNAN*/
-#define SIGN 0x80000000U
-
-/* Make it easy to define certain types of constants */
-typedef union {
-    int64_t i64; /* This must be defined first in order to allow the initialization to work. This is a C89 feature. */
-    double d64;
-} BitPatternConversion;
-static const BitPatternConversion gNan = { (int64_t) INT64_C(0x7FF8000000000000) };
-static const BitPatternConversion gInf = { (int64_t) INT64_C(0x7FF0000000000000) };
-
-/*---------------------------------------------------------------------------
-  Platform utilities
-  Our general strategy is to assume we're on a POSIX platform.  Platforms which
-  are non-POSIX must declare themselves so.  The default POSIX implementation
-  will sometimes work for non-POSIX platforms as well (e.g., the NaN-related
-  functions).
-  ---------------------------------------------------------------------------*/
-
-#if U_PLATFORM_USES_ONLY_WIN32_API || U_PLATFORM == U_PF_OS400
-#   undef U_POSIX_LOCALE
-#else
-#   define U_POSIX_LOCALE    1
-#endif
-
-/*
-    WARNING! u_topNBytesOfDouble and u_bottomNBytesOfDouble
-    can't be properly optimized by the gcc compiler sometimes (i.e. gcc 3.2).
-*/
-#if !IEEE_754
-static char*
-u_topNBytesOfDouble(double* d, int n)
-{
-#if U_IS_BIG_ENDIAN
-    return (char*)d;
-#else
-    return (char*)(d + 1) - n;
-#endif
-}
-
-static char*
-u_bottomNBytesOfDouble(double* d, int n)
-{
-#if U_IS_BIG_ENDIAN
-    return (char*)(d + 1) - n;
-#else
-    return (char*)d;
-#endif
-}
-#endif   /* !IEEE_754 */
-
-#if IEEE_754
-static UBool
-u_signBit(double d) {
-    uint8_t hiByte;
-#if U_IS_BIG_ENDIAN
-    hiByte = *(uint8_t *)&d;
-#else
-    hiByte = *(((uint8_t *)&d) + sizeof(double) - 1);
-#endif
-    return (hiByte & 0x80) != 0;
-}
-#endif
-
-
-
-#if defined (U_DEBUG_FAKETIME)
-/* Override the clock to test things without having to move the system clock.
- * Assumes POSIX gettimeofday() will function
- */
-UDate fakeClock_t0 = 0; /** Time to start the clock from **/
-UDate fakeClock_dt = 0; /** Offset (fake time - real time) **/
-UBool fakeClock_set = FALSE; /** True if fake clock has spun up **/
-
-static UDate getUTCtime_real() {
-    struct timeval posixTime;
-    gettimeofday(&posixTime, NULL);
-    return (UDate)(((int64_t)posixTime.tv_sec * U_MILLIS_PER_SECOND) + (posixTime.tv_usec/1000));
-}
-
-static UDate getUTCtime_fake() {
-    static UMutex fakeClockMutex = U_MUTEX_INTIALIZER;
-    umtx_lock(&fakeClockMutex);
-    if(!fakeClock_set) {
-        UDate real = getUTCtime_real();
-        const char *fake_start = getenv("U_FAKETIME_START");
-        if((fake_start!=NULL) && (fake_start[0]!=0)) {
-            sscanf(fake_start,"%lf",&fakeClock_t0);
-            fakeClock_dt = fakeClock_t0 - real;
-            fprintf(stderr,"U_DEBUG_FAKETIME was set at compile time, so the ICU clock will start at a preset value\n"
-                    "env variable U_FAKETIME_START=%.0f (%s) for an offset of %.0f ms from the current time %.0f\n",
-                    fakeClock_t0, fake_start, fakeClock_dt, real);
-        } else {
-          fakeClock_dt = 0;
-            fprintf(stderr,"U_DEBUG_FAKETIME was set at compile time, but U_FAKETIME_START was not set.\n"
-                    "Set U_FAKETIME_START to the number of milliseconds since 1/1/1970 to set the ICU clock.\n");
-        }
-        fakeClock_set = TRUE;
-    }
-    umtx_unlock(&fakeClockMutex);
-
-    return getUTCtime_real() + fakeClock_dt;
-}
-#endif
-
-#if U_PLATFORM_USES_ONLY_WIN32_API
-typedef union {
-    int64_t int64;
-    FILETIME fileTime;
-} FileTimeConversion;   /* This is like a ULARGE_INTEGER */
-
-/* Number of 100 nanoseconds from 1/1/1601 to 1/1/1970 */
-#define EPOCH_BIAS  INT64_C(116444736000000000)
-#define HECTONANOSECOND_PER_MILLISECOND   10000
-
-#endif
-
-/*---------------------------------------------------------------------------
-  Universal Implementations
-  These are designed to work on all platforms.  Try these, and if they
-  don't work on your platform, then special case your platform with new
-  implementations.
----------------------------------------------------------------------------*/
-
-U_CAPI UDate U_EXPORT2
-uprv_getUTCtime()
-{
-#if defined(U_DEBUG_FAKETIME)
-    return getUTCtime_fake(); /* Hook for overriding the clock */
-#else
-    return uprv_getRawUTCtime();
-#endif
-}
-
-/* Return UTC (GMT) time measured in milliseconds since 0:00 on 1/1/70.*/
-U_CAPI UDate U_EXPORT2
-uprv_getRawUTCtime()
-{
-#if U_PLATFORM_USES_ONLY_WIN32_API
-
-    FileTimeConversion winTime;
-    GetSystemTimeAsFileTime(&winTime.fileTime);
-    return (UDate)((winTime.int64 - EPOCH_BIAS) / HECTONANOSECOND_PER_MILLISECOND);
-#else
-
-#if HAVE_GETTIMEOFDAY
-    struct timeval posixTime;
-    gettimeofday(&posixTime, NULL);
-    return (UDate)(((int64_t)posixTime.tv_sec * U_MILLIS_PER_SECOND) + (posixTime.tv_usec/1000));
-#else
-    time_t epochtime;
-    time(&epochtime);
-    return (UDate)epochtime * U_MILLIS_PER_SECOND;
-#endif
-
-#endif
-}
-
-/*-----------------------------------------------------------------------------
-  IEEE 754
-  These methods detect and return NaN and infinity values for doubles
-  conforming to IEEE 754.  Platforms which support this standard include X86,
-  Mac 680x0, Mac PowerPC, AIX RS/6000, and most others.
-  If this doesn't work on your platform, you have non-IEEE floating-point, and
-  will need to code your own versions.  A naive implementation is to return 0.0
-  for getNaN and getInfinity, and false for isNaN and isInfinite.
-  ---------------------------------------------------------------------------*/
-
-U_CAPI UBool U_EXPORT2
-uprv_isNaN(double number)
-{
-#if IEEE_754
-    BitPatternConversion convertedNumber;
-    convertedNumber.d64 = number;
-    /* Infinity is 0x7FF0000000000000U. Anything greater than that is a NaN */
-    return (UBool)((convertedNumber.i64 & U_INT64_MAX) > gInf.i64);
-
-#elif U_PLATFORM == U_PF_OS390
-    uint32_t highBits = *(uint32_t*)u_topNBytesOfDouble(&number,
-                        sizeof(uint32_t));
-    uint32_t lowBits  = *(uint32_t*)u_bottomNBytesOfDouble(&number,
-                        sizeof(uint32_t));
-
-    return ((highBits & 0x7F080000L) == 0x7F080000L) &&
-      (lowBits == 0x00000000L);
-
-#else
-    /* If your platform doesn't support IEEE 754 but *does* have an NaN value,*/
-    /* you'll need to replace this default implementation with what's correct*/
-    /* for your platform.*/
-    return number != number;
-#endif
-}
-
-U_CAPI UBool U_EXPORT2
-uprv_isInfinite(double number)
-{
-#if IEEE_754
-    BitPatternConversion convertedNumber;
-    convertedNumber.d64 = number;
-    /* Infinity is exactly 0x7FF0000000000000U. */
-    return (UBool)((convertedNumber.i64 & U_INT64_MAX) == gInf.i64);
-#elif U_PLATFORM == U_PF_OS390
-    uint32_t highBits = *(uint32_t*)u_topNBytesOfDouble(&number,
-                        sizeof(uint32_t));
-    uint32_t lowBits  = *(uint32_t*)u_bottomNBytesOfDouble(&number,
-                        sizeof(uint32_t));
-
-    return ((highBits  & ~SIGN) == 0x70FF0000L) && (lowBits == 0x00000000L);
-
-#else
-    /* If your platform doesn't support IEEE 754 but *does* have an infinity*/
-    /* value, you'll need to replace this default implementation with what's*/
-    /* correct for your platform.*/
-    return number == (2.0 * number);
-#endif
-}
-
-U_CAPI UBool U_EXPORT2
-uprv_isPositiveInfinity(double number)
-{
-#if IEEE_754 || U_PLATFORM == U_PF_OS390
-    return (UBool)(number > 0 && uprv_isInfinite(number));
-#else
-    return uprv_isInfinite(number);
-#endif
-}
-
-U_CAPI UBool U_EXPORT2
-uprv_isNegativeInfinity(double number)
-{
-#if IEEE_754 || U_PLATFORM == U_PF_OS390
-    return (UBool)(number < 0 && uprv_isInfinite(number));
-
-#else
-    uint32_t highBits = *(uint32_t*)u_topNBytesOfDouble(&number,
-                        sizeof(uint32_t));
-    return((highBits & SIGN) && uprv_isInfinite(number));
-
-#endif
-}
-
-U_CAPI double U_EXPORT2
-uprv_getNaN()
-{
-#if IEEE_754 || U_PLATFORM == U_PF_OS390
-    return gNan.d64;
-#else
-    /* If your platform doesn't support IEEE 754 but *does* have an NaN value,*/
-    /* you'll need to replace this default implementation with what's correct*/
-    /* for your platform.*/
-    return 0.0;
-#endif
-}
-
-U_CAPI double U_EXPORT2
-uprv_getInfinity()
-{
-#if IEEE_754 || U_PLATFORM == U_PF_OS390
-    return gInf.d64;
-#else
-    /* If your platform doesn't support IEEE 754 but *does* have an infinity*/
-    /* value, you'll need to replace this default implementation with what's*/
-    /* correct for your platform.*/
-    return 0.0;
-#endif
-}
-
-U_CAPI double U_EXPORT2
-uprv_floor(double x)
-{
-    return floor(x);
-}
-
-U_CAPI double U_EXPORT2
-uprv_ceil(double x)
-{
-    return ceil(x);
-}
-
-U_CAPI double U_EXPORT2
-uprv_round(double x)
-{
-    return uprv_floor(x + 0.5);
-}
-
-U_CAPI double U_EXPORT2
-uprv_fabs(double x)
-{
-    return fabs(x);
-}
-
-U_CAPI double U_EXPORT2
-uprv_modf(double x, double* y)
-{
-    return modf(x, y);
-}
-
-U_CAPI double U_EXPORT2
-uprv_fmod(double x, double y)
-{
-    return fmod(x, y);
-}
-
-U_CAPI double U_EXPORT2
-uprv_pow(double x, double y)
-{
-    /* This is declared as "double pow(double x, double y)" */
-    return pow(x, y);
-}
-
-U_CAPI double U_EXPORT2
-uprv_pow10(int32_t x)
-{
-    return pow(10.0, (double)x);
-}
-
-U_CAPI double U_EXPORT2
-uprv_fmax(double x, double y)
-{
-#if IEEE_754
-    /* first handle NaN*/
-    if(uprv_isNaN(x) || uprv_isNaN(y))
-        return uprv_getNaN();
-
-    /* check for -0 and 0*/
-    if(x == 0.0 && y == 0.0 && u_signBit(x))
-        return y;
-
-#endif
-
-    /* this should work for all flt point w/o NaN and Inf special cases */
-    return (x > y ? x : y);
-}
-
-U_CAPI double U_EXPORT2
-uprv_fmin(double x, double y)
-{
-#if IEEE_754
-    /* first handle NaN*/
-    if(uprv_isNaN(x) || uprv_isNaN(y))
-        return uprv_getNaN();
-
-    /* check for -0 and 0*/
-    if(x == 0.0 && y == 0.0 && u_signBit(y))
-        return y;
-
-#endif
-
-    /* this should work for all flt point w/o NaN and Inf special cases */
-    return (x > y ? y : x);
-}
-
-U_CAPI UBool U_EXPORT2
-uprv_add32_overflow(int32_t a, int32_t b, int32_t* res) {
-    // NOTE: Some compilers (GCC, Clang) have primitives available, like __builtin_add_overflow.
-    // This function could be optimized by calling one of those primitives.
-    auto a64 = static_cast<int64_t>(a);
-    auto b64 = static_cast<int64_t>(b);
-    int64_t res64 = a64 + b64;
-    *res = static_cast<int32_t>(res64);
-    return res64 != *res;
-}
-
-U_CAPI UBool U_EXPORT2
-uprv_mul32_overflow(int32_t a, int32_t b, int32_t* res) {
-    // NOTE: Some compilers (GCC, Clang) have primitives available, like __builtin_mul_overflow.
-    // This function could be optimized by calling one of those primitives.
-    auto a64 = static_cast<int64_t>(a);
-    auto b64 = static_cast<int64_t>(b);
-    int64_t res64 = a64 * b64;
-    *res = static_cast<int32_t>(res64);
-    return res64 != *res;
-}
-
-/**
- * Truncates the given double.
- * trunc(3.3) = 3.0, trunc (-3.3) = -3.0
- * This is different than calling floor() or ceil():
- * floor(3.3) = 3, floor(-3.3) = -4
- * ceil(3.3) = 4, ceil(-3.3) = -3
- */
-U_CAPI double U_EXPORT2
-uprv_trunc(double d)
-{
-#if IEEE_754
-    /* handle error cases*/
-    if(uprv_isNaN(d))
-        return uprv_getNaN();
-    if(uprv_isInfinite(d))
-        return uprv_getInfinity();
-
-    if(u_signBit(d))    /* Signbit() picks up -0.0;  d<0 does not. */
-        return ceil(d);
-    else
-        return floor(d);
-
-#else
-    return d >= 0 ? floor(d) : ceil(d);
-
-#endif
-}
-
-/**
- * Return the largest positive number that can be represented by an integer
- * type of arbitrary bit length.
- */
-U_CAPI double U_EXPORT2
-uprv_maxMantissa(void)
-{
-    return pow(2.0, DBL_MANT_DIG + 1.0) - 1.0;
-}
-
-U_CAPI double U_EXPORT2
-uprv_log(double d)
-{
-    return log(d);
-}
-
-U_CAPI void * U_EXPORT2
-uprv_maximumPtr(void * base)
-{
-#if U_PLATFORM == U_PF_OS400
-    /*
-     * With the provided function we should never be out of range of a given segment
-     * (a traditional/typical segment that is).  Our segments have 5 bytes for the
-     * id and 3 bytes for the offset.  The key is that the casting takes care of
-     * only retrieving the offset portion minus x1000.  Hence, the smallest offset
-     * seen in a program is x001000 and when casted to an int would be 0.
-     * That's why we can only add 0xffefff.  Otherwise, we would exceed the segment.
-     *
-     * Currently, 16MB is the current addressing limitation on i5/OS if the activation is
-     * non-TERASPACE.  If it is TERASPACE it is 2GB - 4k(header information).
-     * This function determines the activation based on the pointer that is passed in and
-     * calculates the appropriate maximum available size for
-     * each pointer type (TERASPACE and non-TERASPACE)
-     *
-     * Unlike other operating systems, the pointer model isn't determined at
-     * compile time on i5/OS.
-     */
-    if ((base != NULL) && (_TESTPTR(base, _C_TERASPACE_CHECK))) {
-        /* if it is a TERASPACE pointer the max is 2GB - 4k */
-        return ((void *)(((char *)base)-((uint32_t)(base))+((uint32_t)0x7fffefff)));
-    }
-    /* otherwise 16MB since NULL ptr is not checkable or the ptr is not TERASPACE */
-    return ((void *)(((char *)base)-((uint32_t)(base))+((uint32_t)0xffefff)));
-
-#else
-    return U_MAX_PTR(base);
-#endif
-}
-
-/*---------------------------------------------------------------------------
-  Platform-specific Implementations
-  Try these, and if they don't work on your platform, then special case your
-  platform with new implementations.
-  ---------------------------------------------------------------------------*/
-
-/* Generic time zone layer -------------------------------------------------- */
-
-/* Time zone utilities */
-U_CAPI void U_EXPORT2
-uprv_tzset()
-{
-#if defined(U_TZSET)
-    U_TZSET();
-#else
-    /* no initialization*/
-#endif
-}
-
-U_CAPI int32_t U_EXPORT2
-uprv_timezone()
-{
-#ifdef U_TIMEZONE
-    return U_TIMEZONE;
-#else
-    time_t t, t1, t2;
-    struct tm tmrec;
-    int32_t tdiff = 0;
-
-    time(&t);
-    uprv_memcpy( &tmrec, localtime(&t), sizeof(tmrec) );
-#if U_PLATFORM != U_PF_IPHONE
-    UBool dst_checked = (tmrec.tm_isdst != 0); /* daylight savings time is checked*/
-#endif
-    t1 = mktime(&tmrec);                 /* local time in seconds*/
-    uprv_memcpy( &tmrec, gmtime(&t), sizeof(tmrec) );
-    t2 = mktime(&tmrec);                 /* GMT (or UTC) in seconds*/
-    tdiff = t2 - t1;
-
-#if U_PLATFORM != U_PF_IPHONE
-    /* imitate NT behaviour, which returns same timezone offset to GMT for
-       winter and summer.
-       This does not work on all platforms. For instance, on glibc on Linux
-       and on Mac OS 10.5, tdiff calculated above remains the same
-       regardless of whether DST is in effect or not. iOS is another
-       platform where this does not work. Linux + glibc and Mac OS 10.5
-       have U_TIMEZONE defined so that this code is not reached.
-    */
-    if (dst_checked)
-        tdiff += 3600;
-#endif
-    return tdiff;
-#endif
-}
-
-/* Note that U_TZNAME does *not* have to be tzname, but if it is,
-   some platforms need to have it declared here. */
-
-#if defined(U_TZNAME) && (U_PLATFORM == U_PF_IRIX || U_PLATFORM_IS_DARWIN_BASED)
-/* RS6000 and others reject char **tzname.  */
-extern U_IMPORT char *U_TZNAME[];
-#endif
-
-#if !UCONFIG_NO_FILE_IO && ((U_PLATFORM_IS_DARWIN_BASED && (U_PLATFORM != U_PF_IPHONE || defined(U_TIMEZONE))) || U_PLATFORM_IS_LINUX_BASED || U_PLATFORM == U_PF_BSD || U_PLATFORM == U_PF_SOLARIS)
-/* These platforms are likely to use Olson timezone IDs. */
-/* common targets of the symbolic link at TZDEFAULT are:
- * "/usr/share/zoneinfo/<olsonID>" default, older Linux distros, macOS to 10.12
- * "../usr/share/zoneinfo/<olsonID>" newer Linux distros: Red Hat Enterprise Linux 7, Ubuntu 16, SuSe Linux 12
- * "/usr/share/lib/zoneinfo/<olsonID>" Solaris
- * "../usr/share/lib/zoneinfo/<olsonID>" Solaris
- * "/var/db/timezone/zoneinfo/<olsonID>" macOS 10.13
- * To avoid checking lots of paths, just check that the target path
- * before the <olsonID> ends with "/zoneinfo/", and the <olsonID> is valid.
- */
-
-#define CHECK_LOCALTIME_LINK 1
-#if U_PLATFORM_IS_DARWIN_BASED
-#include <tzfile.h>
-#define TZZONEINFO      (TZDIR "/")
-#elif U_PLATFORM == U_PF_SOLARIS
-#define TZDEFAULT       "/etc/localtime"
-#define TZZONEINFO      "/usr/share/lib/zoneinfo/"
-#define TZ_ENV_CHECK    "localtime"
-#else
-#define TZDEFAULT       "/etc/localtime"
-#define TZZONEINFO      "/usr/share/zoneinfo/"
-#endif
-#define TZZONEINFOTAIL  "/zoneinfo/"
-#if U_HAVE_DIRENT_H
-#define TZFILE_SKIP     "posixrules" /* tz file to skip when searching. */
-/* Some Linux distributions have 'localtime' in /usr/share/zoneinfo
-   symlinked to /etc/localtime, which makes searchForTZFile return
-   'localtime' when it's the first match. */
-#define TZFILE_SKIP2    "localtime"
-#define SEARCH_TZFILE
-#include <dirent.h>  /* Needed to search through system timezone files */
-#endif
-static char gTimeZoneBuffer[PATH_MAX];
-static char *gTimeZoneBufferPtr = NULL;
-#endif
-
-#if !U_PLATFORM_USES_ONLY_WIN32_API
-#define isNonDigit(ch) (ch < '0' || '9' < ch)
-static UBool isValidOlsonID(const char *id) {
-    int32_t idx = 0;
-
-    /* Determine if this is something like Iceland (Olson ID)
-    or AST4ADT (non-Olson ID) */
-    while (id[idx] && isNonDigit(id[idx]) && id[idx] != ',') {
-        idx++;
-    }
-
-    /* If we went through the whole string, then it might be okay.
-    The timezone is sometimes set to "CST-7CDT", "CST6CDT5,J129,J131/19:30",
-    "GRNLNDST3GRNLNDDT" or similar, so we cannot use it.
-    The rest of the time it could be an Olson ID. George */
-    return (UBool)(id[idx] == 0
-        || uprv_strcmp(id, "PST8PDT") == 0
-        || uprv_strcmp(id, "MST7MDT") == 0
-        || uprv_strcmp(id, "CST6CDT") == 0
-        || uprv_strcmp(id, "EST5EDT") == 0);
-}
-
-/* On some Unix-like OS, 'posix' subdirectory in
-   /usr/share/zoneinfo replicates the top-level contents. 'right'
-   subdirectory has the same set of files, but individual files
-   are different from those in the top-level directory or 'posix'
-   because 'right' has files for TAI (Int'l Atomic Time) while 'posix'
-   has files for UTC.
-   When the first match for /etc/localtime is in either of them
-   (usually in posix because 'right' has different file contents),
-   or TZ environment variable points to one of them, createTimeZone
-   fails because, say, 'posix/America/New_York' is not an Olson
-   timezone id ('America/New_York' is). So, we have to skip
-   'posix/' and 'right/' at the beginning. */
-static void skipZoneIDPrefix(const char** id) {
-    if (uprv_strncmp(*id, "posix/", 6) == 0
-        || uprv_strncmp(*id, "right/", 6) == 0)
-    {
-        *id += 6;
-    }
-}
-#endif
-
-#if defined(U_TZNAME) && !U_PLATFORM_USES_ONLY_WIN32_API
-
-#define CONVERT_HOURS_TO_SECONDS(offset) (int32_t)(offset*3600)
-typedef struct OffsetZoneMapping {
-    int32_t offsetSeconds;
-    int32_t daylightType; /* 0=U_DAYLIGHT_NONE, 1=daylight in June-U_DAYLIGHT_JUNE, 2=daylight in December=U_DAYLIGHT_DECEMBER*/
-    const char *stdID;
-    const char *dstID;
-    const char *olsonID;
-} OffsetZoneMapping;
-
-enum { U_DAYLIGHT_NONE=0,U_DAYLIGHT_JUNE=1,U_DAYLIGHT_DECEMBER=2 };
-
-/*
-This list tries to disambiguate a set of abbreviated timezone IDs and offsets
-and maps it to an Olson ID.
-Before adding anything to this list, take a look at
-icu/source/tools/tzcode/tz.alias
-Sometimes no daylight savings (0) is important to define due to aliases.
-This list can be tested with icu/source/test/compat/tzone.pl
-More values could be added to daylightType to increase precision.
-*/
-static const struct OffsetZoneMapping OFFSET_ZONE_MAPPINGS[] = {
-    {-45900, 2, "CHAST", "CHADT", "Pacific/Chatham"},
-    {-43200, 1, "PETT", "PETST", "Asia/Kamchatka"},
-    {-43200, 2, "NZST", "NZDT", "Pacific/Auckland"},
-    {-43200, 1, "ANAT", "ANAST", "Asia/Anadyr"},
-    {-39600, 1, "MAGT", "MAGST", "Asia/Magadan"},
-    {-37800, 2, "LHST", "LHST", "Australia/Lord_Howe"},
-    {-36000, 2, "EST", "EST", "Australia/Sydney"},
-    {-36000, 1, "SAKT", "SAKST", "Asia/Sakhalin"},
-    {-36000, 1, "VLAT", "VLAST", "Asia/Vladivostok"},
-    {-34200, 2, "CST", "CST", "Australia/South"},
-    {-32400, 1, "YAKT", "YAKST", "Asia/Yakutsk"},
-    {-32400, 1, "CHOT", "CHOST", "Asia/Choibalsan"},
-    {-31500, 2, "CWST", "CWST", "Australia/Eucla"},
-    {-28800, 1, "IRKT", "IRKST", "Asia/Irkutsk"},
-    {-28800, 1, "ULAT", "ULAST", "Asia/Ulaanbaatar"},
-    {-28800, 2, "WST", "WST", "Australia/West"},
-    {-25200, 1, "HOVT", "HOVST", "Asia/Hovd"},
-    {-25200, 1, "KRAT", "KRAST", "Asia/Krasnoyarsk"},
-    {-21600, 1, "NOVT", "NOVST", "Asia/Novosibirsk"},
-    {-21600, 1, "OMST", "OMSST", "Asia/Omsk"},
-    {-18000, 1, "YEKT", "YEKST", "Asia/Yekaterinburg"},
-    {-14400, 1, "SAMT", "SAMST", "Europe/Samara"},
-    {-14400, 1, "AMT", "AMST", "Asia/Yerevan"},
-    {-14400, 1, "AZT", "AZST", "Asia/Baku"},
-    {-10800, 1, "AST", "ADT", "Asia/Baghdad"},
-    {-10800, 1, "MSK", "MSD", "Europe/Moscow"},
-    {-10800, 1, "VOLT", "VOLST", "Europe/Volgograd"},
-    {-7200, 0, "EET", "CEST", "Africa/Tripoli"},
-    {-7200, 1, "EET", "EEST", "Europe/Athens"}, /* Conflicts with Africa/Cairo */
-    {-7200, 1, "IST", "IDT", "Asia/Jerusalem"},
-    {-3600, 0, "CET", "WEST", "Africa/Algiers"},
-    {-3600, 2, "WAT", "WAST", "Africa/Windhoek"},
-    {0, 1, "GMT", "IST", "Europe/Dublin"},
-    {0, 1, "GMT", "BST", "Europe/London"},
-    {0, 0, "WET", "WEST", "Africa/Casablanca"},
-    {0, 0, "WET", "WET", "Africa/El_Aaiun"},
-    {3600, 1, "AZOT", "AZOST", "Atlantic/Azores"},
-    {3600, 1, "EGT", "EGST", "America/Scoresbysund"},
-    {10800, 1, "PMST", "PMDT", "America/Miquelon"},
-    {10800, 2, "UYT", "UYST", "America/Montevideo"},
-    {10800, 1, "WGT", "WGST", "America/Godthab"},
-    {10800, 2, "BRT", "BRST", "Brazil/East"},
-    {12600, 1, "NST", "NDT", "America/St_Johns"},
-    {14400, 1, "AST", "ADT", "Canada/Atlantic"},
-    {14400, 2, "AMT", "AMST", "America/Cuiaba"},
-    {14400, 2, "CLT", "CLST", "Chile/Continental"},
-    {14400, 2, "FKT", "FKST", "Atlantic/Stanley"},
-    {14400, 2, "PYT", "PYST", "America/Asuncion"},
-    {18000, 1, "CST", "CDT", "America/Havana"},
-    {18000, 1, "EST", "EDT", "US/Eastern"}, /* Conflicts with America/Grand_Turk */
-    {21600, 2, "EAST", "EASST", "Chile/EasterIsland"},
-    {21600, 0, "CST", "MDT", "Canada/Saskatchewan"},
-    {21600, 0, "CST", "CDT", "America/Guatemala"},
-    {21600, 1, "CST", "CDT", "US/Central"}, /* Conflicts with Mexico/General */
-    {25200, 1, "MST", "MDT", "US/Mountain"}, /* Conflicts with Mexico/BajaSur */
-    {28800, 0, "PST", "PST", "Pacific/Pitcairn"},
-    {28800, 1, "PST", "PDT", "US/Pacific"}, /* Conflicts with Mexico/BajaNorte */
-    {32400, 1, "AKST", "AKDT", "US/Alaska"},
-    {36000, 1, "HAST", "HADT", "US/Aleutian"}
-};
-
-/*#define DEBUG_TZNAME*/
-
-static const char* remapShortTimeZone(const char *stdID, const char *dstID, int32_t daylightType, int32_t offset)
-{
-    int32_t idx;
-#ifdef DEBUG_TZNAME
-    fprintf(stderr, "TZ=%s std=%s dst=%s daylight=%d offset=%d\n", getenv("TZ"), stdID, dstID, daylightType, offset);
-#endif
-    for (idx = 0; idx < UPRV_LENGTHOF(OFFSET_ZONE_MAPPINGS); idx++)
-    {
-        if (offset == OFFSET_ZONE_MAPPINGS[idx].offsetSeconds
-            && daylightType == OFFSET_ZONE_MAPPINGS[idx].daylightType
-            && strcmp(OFFSET_ZONE_MAPPINGS[idx].stdID, stdID) == 0
-            && strcmp(OFFSET_ZONE_MAPPINGS[idx].dstID, dstID) == 0)
-        {
-            return OFFSET_ZONE_MAPPINGS[idx].olsonID;
-        }
-    }
-    return NULL;
-}
-#endif
-
-#ifdef SEARCH_TZFILE
-#define MAX_READ_SIZE 512
-
-typedef struct DefaultTZInfo {
-    char* defaultTZBuffer;
-    int64_t defaultTZFileSize;
-    FILE* defaultTZFilePtr;
-    UBool defaultTZstatus;
-    int32_t defaultTZPosition;
-} DefaultTZInfo;
-
-/*
- * This method compares the two files given to see if they are a match.
- * It is currently use to compare two TZ files.
- */
-static UBool compareBinaryFiles(const char* defaultTZFileName, const char* TZFileName, DefaultTZInfo* tzInfo) {
-    FILE* file;
-    int64_t sizeFile;
-    int64_t sizeFileLeft;
-    int32_t sizeFileRead;
-    int32_t sizeFileToRead;
-    char bufferFile[MAX_READ_SIZE];
-    UBool result = TRUE;
-
-    if (tzInfo->defaultTZFilePtr == NULL) {
-        tzInfo->defaultTZFilePtr = fopen(defaultTZFileName, "r");
-    }
-    file = fopen(TZFileName, "r");
-
-    tzInfo->defaultTZPosition = 0; /* reset position to begin search */
-
-    if (file != NULL && tzInfo->defaultTZFilePtr != NULL) {
-        /* First check that the file size are equal. */
-        if (tzInfo->defaultTZFileSize == 0) {
-            fseek(tzInfo->defaultTZFilePtr, 0, SEEK_END);
-            tzInfo->defaultTZFileSize = ftell(tzInfo->defaultTZFilePtr);
-        }
-        fseek(file, 0, SEEK_END);
-        sizeFile = ftell(file);
-        sizeFileLeft = sizeFile;
-
-        if (sizeFile != tzInfo->defaultTZFileSize) {
-            result = FALSE;
-        } else {
-            /* Store the data from the files in seperate buffers and
-             * compare each byte to determine equality.
-             */
-            if (tzInfo->defaultTZBuffer == NULL) {
-                rewind(tzInfo->defaultTZFilePtr);
-                tzInfo->defaultTZBuffer = (char*)uprv_malloc(sizeof(char) * tzInfo->defaultTZFileSize);
-                sizeFileRead = fread(tzInfo->defaultTZBuffer, 1, tzInfo->defaultTZFileSize, tzInfo->defaultTZFilePtr);
-            }
-            rewind(file);
-            while(sizeFileLeft > 0) {
-                uprv_memset(bufferFile, 0, MAX_READ_SIZE);
-                sizeFileToRead = sizeFileLeft < MAX_READ_SIZE ? sizeFileLeft : MAX_READ_SIZE;
-
-                sizeFileRead = fread(bufferFile, 1, sizeFileToRead, file);
-                if (memcmp(tzInfo->defaultTZBuffer + tzInfo->defaultTZPosition, bufferFile, sizeFileRead) != 0) {
-                    result = FALSE;
-                    break;
-                }
-                sizeFileLeft -= sizeFileRead;
-                tzInfo->defaultTZPosition += sizeFileRead;
-            }
-        }
-    } else {
-        result = FALSE;
-    }
-
-    if (file != NULL) {
-        fclose(file);
-    }
-
-    return result;
-}
-
-
-/* dirent also lists two entries: "." and ".." that we can safely ignore. */
-#define SKIP1 "."
-#define SKIP2 ".."
-static UBool U_CALLCONV putil_cleanup(void);
-static CharString *gSearchTZFileResult = NULL;
-
-/*
- * This method recursively traverses the directory given for a matching TZ file and returns the first match.
- * This function is not thread safe - it uses a global, gSearchTZFileResult, to hold its results.
- */
-static char* searchForTZFile(const char* path, DefaultTZInfo* tzInfo) {
-    DIR* dirp = NULL;
-    struct dirent* dirEntry = NULL;
-    char* result = NULL;
-    UErrorCode status = U_ZERO_ERROR;
-
-    /* Save the current path */
-    CharString curpath(path, -1, status);
-    if (U_FAILURE(status)) {
-        goto cleanupAndReturn;
-    }
-
-    dirp = opendir(path);
-    if (dirp == NULL) {
-        goto cleanupAndReturn;
-    }
-
-    if (gSearchTZFileResult == NULL) {
-        gSearchTZFileResult = new CharString;
-        if (gSearchTZFileResult == NULL) {
-            goto cleanupAndReturn;
-        }
-        ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup);
-    }
-
-    /* Check each entry in the directory. */
-    while((dirEntry = readdir(dirp)) != NULL) {
-        const char* dirName = dirEntry->d_name;
-        if (uprv_strcmp(dirName, SKIP1) != 0 && uprv_strcmp(dirName, SKIP2) != 0
-            && uprv_strcmp(TZFILE_SKIP, dirName) != 0 && uprv_strcmp(TZFILE_SKIP2, dirName) != 0) {
-            /* Create a newpath with the new entry to test each entry in the directory. */
-            CharString newpath(curpath, status);
-            newpath.append(dirName, -1, status);
-            if (U_FAILURE(status)) {
-                break;
-            }
-
-            DIR* subDirp = NULL;
-            if ((subDirp = opendir(newpath.data())) != NULL) {
-                /* If this new path is a directory, make a recursive call with the newpath. */
-                closedir(subDirp);
-                newpath.append('/', status);
-                if (U_FAILURE(status)) {
-                    break;
-                }
-                result = searchForTZFile(newpath.data(), tzInfo);
-                /*
-                 Have to get out here. Otherwise, we'd keep looking
-                 and return the first match in the top-level directory
-                 if there's a match in the top-level. If not, this function
-                 would return NULL and set gTimeZoneBufferPtr to NULL in initDefault().
-                 It worked without this in most cases because we have a fallback of calling
-                 localtime_r to figure out the default timezone.
-                */
-                if (result != NULL)
-                    break;
-            } else {
-                if(compareBinaryFiles(TZDEFAULT, newpath.data(), tzInfo)) {
-                    int32_t amountToSkip = sizeof(TZZONEINFO) - 1;
-                    if (amountToSkip > newpath.length()) {
-                        amountToSkip = newpath.length();
-                    }
-                    const char* zoneid = newpath.data() + amountToSkip;
-                    skipZoneIDPrefix(&zoneid);
-                    gSearchTZFileResult->clear();
-                    gSearchTZFileResult->append(zoneid, -1, status);
-                    if (U_FAILURE(status)) {
-                        break;
-                    }
-                    result = gSearchTZFileResult->data();
-                    /* Get out after the first one found. */
-                    break;
-                }
-            }
-        }
-    }
-
-  cleanupAndReturn:
-    if (dirp) {
-        closedir(dirp);
-    }
-    return result;
-}
-#endif
-
-U_CAPI void U_EXPORT2
-uprv_tzname_clear_cache()
-{
-#if defined(CHECK_LOCALTIME_LINK) && !defined(DEBUG_SKIP_LOCALTIME_LINK)
-    gTimeZoneBufferPtr = NULL;
-#endif
-}
-
-U_CAPI const char* U_EXPORT2
-uprv_tzname(int n)
-{
-    (void)n; // Avoid unreferenced parameter warning.
-    const char *tzid = NULL;
-#if U_PLATFORM_USES_ONLY_WIN32_API
-    tzid = uprv_detectWindowsTimeZone();
-
-    if (tzid != NULL) {
-        return tzid;
-    }
-
-#ifndef U_TZNAME
-    // The return value is free'd in timezone.cpp on Windows because
-    // the other code path returns a pointer to a heap location.
-    // If we don't have a name already, then tzname wouldn't be any
-    // better, so just fall back.
-    return uprv_strdup("");
-#endif // !U_TZNAME
-
-#else
-
-/*#if U_PLATFORM_IS_DARWIN_BASED
-    int ret;
-
-    tzid = getenv("TZFILE");
-    if (tzid != NULL) {
-        return tzid;
-    }
-#endif*/
-
-/* This code can be temporarily disabled to test tzname resolution later on. */
-#ifndef DEBUG_TZNAME
-    tzid = getenv("TZ");
-    if (tzid != NULL && isValidOlsonID(tzid)
-#if U_PLATFORM == U_PF_SOLARIS
-    /* When TZ equals localtime on Solaris, check the /etc/localtime file. */
-        && uprv_strcmp(tzid, TZ_ENV_CHECK) != 0
-#endif
-    ) {
-        /* The colon forces tzset() to treat the remainder as zoneinfo path */
-        if (tzid[0] == ':') {
-            tzid++;
-        }
-        /* This might be a good Olson ID. */
-        skipZoneIDPrefix(&tzid);
-        return tzid;
-    }
-    /* else U_TZNAME will give a better result. */
-#endif
-
-#if defined(CHECK_LOCALTIME_LINK) && !defined(DEBUG_SKIP_LOCALTIME_LINK)
-    /* Caller must handle threading issues */
-    if (gTimeZoneBufferPtr == NULL) {
-        /*
-        This is a trick to look at the name of the link to get the Olson ID
-        because the tzfile contents is underspecified.
-        This isn't guaranteed to work because it may not be a symlink.
-        */
-        int32_t ret = (int32_t)readlink(TZDEFAULT, gTimeZoneBuffer, sizeof(gTimeZoneBuffer)-1);
-        if (0 < ret) {
-            int32_t tzZoneInfoTailLen = uprv_strlen(TZZONEINFOTAIL);
-            gTimeZoneBuffer[ret] = 0;
-            char *  tzZoneInfoTailPtr = uprv_strstr(gTimeZoneBuffer, TZZONEINFOTAIL);
-
-            if (tzZoneInfoTailPtr != NULL
-                && isValidOlsonID(tzZoneInfoTailPtr + tzZoneInfoTailLen))
-            {
-                return (gTimeZoneBufferPtr = tzZoneInfoTailPtr + tzZoneInfoTailLen);
-            }
-        } else {
-#if defined(SEARCH_TZFILE)
-            DefaultTZInfo* tzInfo = (DefaultTZInfo*)uprv_malloc(sizeof(DefaultTZInfo));
-            if (tzInfo != NULL) {
-                tzInfo->defaultTZBuffer = NULL;
-                tzInfo->defaultTZFileSize = 0;
-                tzInfo->defaultTZFilePtr = NULL;
-                tzInfo->defaultTZstatus = FALSE;
-                tzInfo->defaultTZPosition = 0;
-
-                gTimeZoneBufferPtr = searchForTZFile(TZZONEINFO, tzInfo);
-
-                /* Free previously allocated memory */
-                if (tzInfo->defaultTZBuffer != NULL) {
-                    uprv_free(tzInfo->defaultTZBuffer);
-                }
-                if (tzInfo->defaultTZFilePtr != NULL) {
-                    fclose(tzInfo->defaultTZFilePtr);
-                }
-                uprv_free(tzInfo);
-            }
-
-            if (gTimeZoneBufferPtr != NULL && isValidOlsonID(gTimeZoneBufferPtr)) {
-                return gTimeZoneBufferPtr;
-            }
-#endif
-        }
-    }
-    else {
-        return gTimeZoneBufferPtr;
-    }
-#endif
-#endif
-
-#ifdef U_TZNAME
-#if U_PLATFORM_USES_ONLY_WIN32_API
-    /* The return value is free'd in timezone.cpp on Windows because
-     * the other code path returns a pointer to a heap location. */
-    return uprv_strdup(U_TZNAME[n]);
-#else
-    /*
-    U_TZNAME is usually a non-unique abbreviation, which isn't normally usable.
-    So we remap the abbreviation to an olson ID.
-
-    Since Windows exposes a little more timezone information,
-    we normally don't use this code on Windows because
-    uprv_detectWindowsTimeZone should have already given the correct answer.
-    */
-    {
-        struct tm juneSol, decemberSol;
-        int daylightType;
-        static const time_t juneSolstice=1182478260; /*2007-06-21 18:11 UT*/
-        static const time_t decemberSolstice=1198332540; /*2007-12-22 06:09 UT*/
-
-        /* This probing will tell us when daylight savings occurs.  */
-        localtime_r(&juneSolstice, &juneSol);
-        localtime_r(&decemberSolstice, &decemberSol);
-        if(decemberSol.tm_isdst > 0) {
-          daylightType = U_DAYLIGHT_DECEMBER;
-        } else if(juneSol.tm_isdst > 0) {
-          daylightType = U_DAYLIGHT_JUNE;
-        } else {
-          daylightType = U_DAYLIGHT_NONE;
-        }
-        tzid = remapShortTimeZone(U_TZNAME[0], U_TZNAME[1], daylightType, uprv_timezone());
-        if (tzid != NULL) {
-            return tzid;
-        }
-    }
-    return U_TZNAME[n];
-#endif
-#else
-    return "";
-#endif
-}
-
-/* Get and set the ICU data directory --------------------------------------- */
-
-static icu::UInitOnce gDataDirInitOnce = U_INITONCE_INITIALIZER;
-static char *gDataDirectory = NULL;
-
-UInitOnce gTimeZoneFilesInitOnce = U_INITONCE_INITIALIZER;
-static CharString *gTimeZoneFilesDirectory = NULL;
-
-#if U_POSIX_LOCALE || U_PLATFORM_USES_ONLY_WIN32_API
- static const char *gCorrectedPOSIXLocale = NULL; /* Sometimes heap allocated */
- static bool gCorrectedPOSIXLocaleHeapAllocated = false;
-#endif
-
-static UBool U_CALLCONV putil_cleanup(void)
-{
-    if (gDataDirectory && *gDataDirectory) {
-        uprv_free(gDataDirectory);
-    }
-    gDataDirectory = NULL;
-    gDataDirInitOnce.reset();
-
-    delete gTimeZoneFilesDirectory;
-    gTimeZoneFilesDirectory = NULL;
-    gTimeZoneFilesInitOnce.reset();
-
-#ifdef SEARCH_TZFILE
-    delete gSearchTZFileResult;
-    gSearchTZFileResult = NULL;
-#endif
-
-#if U_POSIX_LOCALE || U_PLATFORM_USES_ONLY_WIN32_API
-    if (gCorrectedPOSIXLocale && gCorrectedPOSIXLocaleHeapAllocated) {
-        uprv_free(const_cast<char *>(gCorrectedPOSIXLocale));
-        gCorrectedPOSIXLocale = NULL;
-        gCorrectedPOSIXLocaleHeapAllocated = false;
-    }
-#endif
-    return TRUE;
-}
-
-/*
- * Set the data directory.
- *    Make a copy of the passed string, and set the global data dir to point to it.
- */
-U_CAPI void U_EXPORT2
-u_setDataDirectory(const char *directory) {
-    char *newDataDir;
-    int32_t length;
-
-    if(directory==NULL || *directory==0) {
-        /* A small optimization to prevent the malloc and copy when the
-        shared library is used, and this is a way to make sure that NULL
-        is never returned.
-        */
-        newDataDir = (char *)"";
-    }
-    else {
-        length=(int32_t)uprv_strlen(directory);
-        newDataDir = (char *)uprv_malloc(length + 2);
-        /* Exit out if newDataDir could not be created. */
-        if (newDataDir == NULL) {
-            return;
-        }
-        uprv_strcpy(newDataDir, directory);
-
-#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR)
-        {
-            char *p;
-            while((p = uprv_strchr(newDataDir, U_FILE_ALT_SEP_CHAR)) != NULL) {
-                *p = U_FILE_SEP_CHAR;
-            }
-        }
-#endif
-    }
-
-    if (gDataDirectory && *gDataDirectory) {
-        uprv_free(gDataDirectory);
-    }
-    gDataDirectory = newDataDir;
-    ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup);
-}
-
-U_CAPI UBool U_EXPORT2
-uprv_pathIsAbsolute(const char *path)
-{
-  if(!path || !*path) {
-    return FALSE;
-  }
-
-  if(*path == U_FILE_SEP_CHAR) {
-    return TRUE;
-  }
-
-#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR)
-  if(*path == U_FILE_ALT_SEP_CHAR) {
-    return TRUE;
-  }
-#endif
-
-#if U_PLATFORM_USES_ONLY_WIN32_API
-  if( (((path[0] >= 'A') && (path[0] <= 'Z')) ||
-       ((path[0] >= 'a') && (path[0] <= 'z'))) &&
-      path[1] == ':' ) {
-    return TRUE;
-  }
-#endif
-
-  return FALSE;
-}
-
-/* Backup setting of ICU_DATA_DIR_PREFIX_ENV_VAR
-   (needed for some Darwin ICU build environments) */
-#if U_PLATFORM_IS_DARWIN_BASED && TARGET_OS_SIMULATOR
-# if !defined(ICU_DATA_DIR_PREFIX_ENV_VAR)
-#  define ICU_DATA_DIR_PREFIX_ENV_VAR "IPHONE_SIMULATOR_ROOT"
-# endif
-#endif
-
-#if U_PLATFORM_HAS_WINUWP_API != 0
-// Helper function to get the ICU Data Directory under the Windows directory location.
-static BOOL U_CALLCONV getIcuDataDirectoryUnderWindowsDirectory(char* directoryBuffer, UINT bufferLength)
-{
-#if defined(ICU_DATA_DIR_WINDOWS)
-    wchar_t windowsPath[MAX_PATH];
-    char windowsPathUtf8[MAX_PATH];
-
-    UINT length = GetSystemWindowsDirectoryW(windowsPath, UPRV_LENGTHOF(windowsPath));
-    if ((length > 0) && (length < (UPRV_LENGTHOF(windowsPath) - 1))) {
-        // Convert UTF-16 to a UTF-8 string.
-        UErrorCode status = U_ZERO_ERROR;
-        int32_t windowsPathUtf8Len = 0;
-        u_strToUTF8(windowsPathUtf8, static_cast<int32_t>(UPRV_LENGTHOF(windowsPathUtf8)),
-            &windowsPathUtf8Len, reinterpret_cast<const UChar*>(windowsPath), -1, &status);
-
-        if (U_SUCCESS(status) && (status != U_STRING_NOT_TERMINATED_WARNING) &&
-            (windowsPathUtf8Len < (UPRV_LENGTHOF(windowsPathUtf8) - 1))) {
-            // Ensure it always has a separator, so we can append the ICU data path.
-            if (windowsPathUtf8[windowsPathUtf8Len - 1] != U_FILE_SEP_CHAR) {
-                windowsPathUtf8[windowsPathUtf8Len++] = U_FILE_SEP_CHAR;
-                windowsPathUtf8[windowsPathUtf8Len] = '\0';
-            }
-            // Check if the concatenated string will fit.
-            if ((windowsPathUtf8Len + UPRV_LENGTHOF(ICU_DATA_DIR_WINDOWS)) < bufferLength) {
-                uprv_strcpy(directoryBuffer, windowsPathUtf8);
-                uprv_strcat(directoryBuffer, ICU_DATA_DIR_WINDOWS);
-                return TRUE;
-            }
-        }
-    }
-#endif
-
-    return FALSE;
-}
-#endif
-
-static void U_CALLCONV dataDirectoryInitFn() {
-    /* If we already have the directory, then return immediately. Will happen if user called
-     * u_setDataDirectory().
-     */
-    if (gDataDirectory) {
-        return;
-    }
-
-    const char *path = NULL;
-#if defined(ICU_DATA_DIR_PREFIX_ENV_VAR)
-    char datadir_path_buffer[PATH_MAX];
-#endif
-
-    /*
-    When ICU_NO_USER_DATA_OVERRIDE is defined, users aren't allowed to
-    override ICU's data with the ICU_DATA environment variable. This prevents
-    problems where multiple custom copies of ICU's specific version of data
-    are installed on a system. Either the application must define the data
-    directory with u_setDataDirectory, define ICU_DATA_DIR when compiling
-    ICU, set the data with udata_setCommonData or trust that all of the
-    required data is contained in ICU's data library that contains
-    the entry point defined by U_ICUDATA_ENTRY_POINT.
-
-    There may also be some platforms where environment variables
-    are not allowed.
-    */
-#   if !defined(ICU_NO_USER_DATA_OVERRIDE) && !UCONFIG_NO_FILE_IO
-    /* First try to get the environment variable */
-#       if U_PLATFORM_HAS_WINUWP_API == 0  // Windows UWP does not support getenv
-        path=getenv("ICU_DATA");
-#       endif
-#   endif
-
-    /* ICU_DATA_DIR may be set as a compile option.
-     * U_ICU_DATA_DEFAULT_DIR is provided and is set by ICU at compile time
-     * and is used only when data is built in archive mode eliminating the need
-     * for ICU_DATA_DIR to be set. U_ICU_DATA_DEFAULT_DIR is set to the installation
-     * directory of the data dat file. Users should use ICU_DATA_DIR if they want to
-     * set their own path.
-     */
-#if defined(ICU_DATA_DIR) || defined(U_ICU_DATA_DEFAULT_DIR)
-    if(path==NULL || *path==0) {
-# if defined(ICU_DATA_DIR_PREFIX_ENV_VAR)
-        const char *prefix = getenv(ICU_DATA_DIR_PREFIX_ENV_VAR);
-# endif
-# ifdef ICU_DATA_DIR
-        path=ICU_DATA_DIR;
-# else
-        path=U_ICU_DATA_DEFAULT_DIR;
-# endif
-# if defined(ICU_DATA_DIR_PREFIX_ENV_VAR)
-        if (prefix != NULL) {
-            snprintf(datadir_path_buffer, PATH_MAX, "%s%s", prefix, path);
-            path=datadir_path_buffer;
-        }
-# endif
-    }
-#endif
-
-#if U_PLATFORM_HAS_WINUWP_API != 0  && defined(ICU_DATA_DIR_WINDOWS)
-    char datadir_path_buffer[MAX_PATH];
-    if (getIcuDataDirectoryUnderWindowsDirectory(datadir_path_buffer, UPRV_LENGTHOF(datadir_path_buffer))) {
-        path = datadir_path_buffer;
-    }
-#endif
-
-    if(path==NULL) {
-        /* It looks really bad, set it to something. */
-        path = "";
-    }
-
-    u_setDataDirectory(path);
-    return;
-}
-
-U_CAPI const char * U_EXPORT2
-u_getDataDirectory(void) {
-    umtx_initOnce(gDataDirInitOnce, &dataDirectoryInitFn);
-    return gDataDirectory;
-}
-
-static void setTimeZoneFilesDir(const char *path, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    gTimeZoneFilesDirectory->clear();
-    gTimeZoneFilesDirectory->append(path, status);
-#if (U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR)
-    char *p = gTimeZoneFilesDirectory->data();
-    while ((p = uprv_strchr(p, U_FILE_ALT_SEP_CHAR)) != NULL) {
-        *p = U_FILE_SEP_CHAR;
-    }
-#endif
-}
-
-#define TO_STRING(x) TO_STRING_2(x)
-#define TO_STRING_2(x) #x
-
-static void U_CALLCONV TimeZoneDataDirInitFn(UErrorCode &status) {
-    U_ASSERT(gTimeZoneFilesDirectory == NULL);
-    ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup);
-    gTimeZoneFilesDirectory = new CharString();
-    if (gTimeZoneFilesDirectory == NULL) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return;
-    }
-
-    const char *dir = "";
-
-#if U_PLATFORM_HAS_WINUWP_API != 0
-    // The UWP version does not support the environment variable setting, but can possibly pick them up from the Windows directory.
-    char datadir_path_buffer[MAX_PATH];
-    if (getIcuDataDirectoryUnderWindowsDirectory(datadir_path_buffer, UPRV_LENGTHOF(datadir_path_buffer))) {
-        dir = datadir_path_buffer;
-    }
-#else
-    dir = getenv("ICU_TIMEZONE_FILES_DIR");
-#endif // U_PLATFORM_HAS_WINUWP_API
-
-#if defined(U_TIMEZONE_FILES_DIR)
-    if (dir == NULL) {
-        // Build time configuration setting.
-        dir = TO_STRING(U_TIMEZONE_FILES_DIR);
-    }
-#endif
-
-    if (dir == NULL) {
-        dir = "";
-    }
-
-    setTimeZoneFilesDir(dir, status);
-}
-
-
-U_CAPI const char * U_EXPORT2
-u_getTimeZoneFilesDirectory(UErrorCode *status) {
-    umtx_initOnce(gTimeZoneFilesInitOnce, &TimeZoneDataDirInitFn, *status);
-    return U_SUCCESS(*status) ? gTimeZoneFilesDirectory->data() : "";
-}
-
-U_CAPI void U_EXPORT2
-u_setTimeZoneFilesDirectory(const char *path, UErrorCode *status) {
-    umtx_initOnce(gTimeZoneFilesInitOnce, &TimeZoneDataDirInitFn, *status);
-    setTimeZoneFilesDir(path, *status);
-
-    // Note: this function does some extra churn, first setting based on the
-    //       environment, then immediately replacing with the value passed in.
-    //       The logic is simpler that way, and performance shouldn't be an issue.
-}
-
-
-#if U_POSIX_LOCALE
-/* A helper function used by uprv_getPOSIXIDForDefaultLocale and
- * uprv_getPOSIXIDForDefaultCodepage. Returns the posix locale id for
- * LC_CTYPE and LC_MESSAGES. It doesn't support other locale categories.
- */
-static const char *uprv_getPOSIXIDForCategory(int category)
-{
-    const char* posixID = NULL;
-    if (category == LC_MESSAGES || category == LC_CTYPE) {
-        /*
-        * On Solaris two different calls to setlocale can result in
-        * different values. Only get this value once.
-        *
-        * We must check this first because an application can set this.
-        *
-        * LC_ALL can't be used because it's platform dependent. The LANG
-        * environment variable seems to affect LC_CTYPE variable by default.
-        * Here is what setlocale(LC_ALL, NULL) can return.
-        * HPUX can return 'C C C C C C C'
-        * Solaris can return /en_US/C/C/C/C/C on the second try.
-        * Linux can return LC_CTYPE=C;LC_NUMERIC=C;...
-        *
-        * The default codepage detection also needs to use LC_CTYPE.
-        *
-        * Do not call setlocale(LC_*, "")! Using an empty string instead
-        * of NULL, will modify the libc behavior.
-        */
-        posixID = setlocale(category, NULL);
-        if ((posixID == 0)
-            || (uprv_strcmp("C", posixID) == 0)
-            || (uprv_strcmp("POSIX", posixID) == 0))
-        {
-            /* Maybe we got some garbage.  Try something more reasonable */
-            posixID = getenv("LC_ALL");
-            /* Solaris speaks POSIX -  See IEEE Std 1003.1-2008
-             * This is needed to properly handle empty env. variables
-             */
-#if U_PLATFORM == U_PF_SOLARIS
-            if ((posixID == 0) || (posixID[0] == '\0')) {
-                posixID = getenv(category == LC_MESSAGES ? "LC_MESSAGES" : "LC_CTYPE");
-                if ((posixID == 0) || (posixID[0] == '\0')) {
-#else
-            if (posixID == 0) {
-                posixID = getenv(category == LC_MESSAGES ? "LC_MESSAGES" : "LC_CTYPE");
-                if (posixID == 0) {
-#endif
-                    posixID = getenv("LANG");
-                }
-            }
-        }
-    }
-    if ((posixID==0)
-        || (uprv_strcmp("C", posixID) == 0)
-        || (uprv_strcmp("POSIX", posixID) == 0))
-    {
-        /* Nothing worked.  Give it a nice POSIX default value. */
-        posixID = "en_US_POSIX";
-        // Note: this test will not catch 'C.UTF-8',
-        // that will be handled in uprv_getDefaultLocaleID().
-        // Leave this mapping here for the uprv_getPOSIXIDForDefaultCodepage()
-        // caller which expects to see "en_US_POSIX" in many branches.
-    }
-    return posixID;
-}
-
-/* Return just the POSIX id for the default locale, whatever happens to be in
- * it. It gets the value from LC_MESSAGES and indirectly from LC_ALL and LANG.
- */
-static const char *uprv_getPOSIXIDForDefaultLocale(void)
-{
-    static const char* posixID = NULL;
-    if (posixID == 0) {
-        posixID = uprv_getPOSIXIDForCategory(LC_MESSAGES);
-    }
-    return posixID;
-}
-
-#if !U_CHARSET_IS_UTF8
-/* Return just the POSIX id for the default codepage, whatever happens to be in
- * it. It gets the value from LC_CTYPE and indirectly from LC_ALL and LANG.
- */
-static const char *uprv_getPOSIXIDForDefaultCodepage(void)
-{
-    static const char* posixID = NULL;
-    if (posixID == 0) {
-        posixID = uprv_getPOSIXIDForCategory(LC_CTYPE);
-    }
-    return posixID;
-}
-#endif
-#endif
-
-/* NOTE: The caller should handle thread safety */
-U_CAPI const char* U_EXPORT2
-uprv_getDefaultLocaleID()
-{
-#if U_POSIX_LOCALE
-/*
-  Note that:  (a '!' means the ID is improper somehow)
-     LC_ALL  ---->     default_loc          codepage
---------------------------------------------------------
-     ab.CD             ab                   CD
-     ab@CD             ab__CD               -
-     ab@CD.EF          ab__CD               EF
-
-     ab_CD.EF@GH       ab_CD_GH             EF
-
-Some 'improper' ways to do the same as above:
-  !  ab_CD@GH.EF       ab_CD_GH             EF
-  !  ab_CD.EF@GH.IJ    ab_CD_GH             EF
-  !  ab_CD@ZZ.EF@GH.IJ ab_CD_GH             EF
-
-     _CD@GH            _CD_GH               -
-     _CD.EF@GH         _CD_GH               EF
-
-The variant cannot have dots in it.
-The 'rightmost' variant (@xxx) wins.
-The leftmost codepage (.xxx) wins.
-*/
-    const char* posixID = uprv_getPOSIXIDForDefaultLocale();
-
-    /* Format: (no spaces)
-    ll [ _CC ] [ . MM ] [ @ VV]
-
-      l = lang, C = ctry, M = charmap, V = variant
-    */
-
-    if (gCorrectedPOSIXLocale != nullptr) {
-        return gCorrectedPOSIXLocale;
-    }
-
-    // Copy the ID into owned memory.
-    // Over-allocate in case we replace "C" with "en_US_POSIX" (+10), + null termination
-    char *correctedPOSIXLocale = static_cast<char *>(uprv_malloc(uprv_strlen(posixID) + 10 + 1));
-    if (correctedPOSIXLocale == nullptr) {
-        return nullptr;
-    }
-    uprv_strcpy(correctedPOSIXLocale, posixID);
-
-    char *limit;
-    if ((limit = uprv_strchr(correctedPOSIXLocale, '.')) != nullptr) {
-        *limit = 0;
-    }
-    if ((limit = uprv_strchr(correctedPOSIXLocale, '@')) != nullptr) {
-        *limit = 0;
-    }
-
-    if ((uprv_strcmp("C", correctedPOSIXLocale) == 0) // no @ variant
-        || (uprv_strcmp("POSIX", correctedPOSIXLocale) == 0)) {
-      // Raw input was C.* or POSIX.*, Give it a nice POSIX default value.
-      // (The "C"/"POSIX" case is handled in uprv_getPOSIXIDForCategory())
-      uprv_strcpy(correctedPOSIXLocale, "en_US_POSIX");
-    }
-
-    /* Note that we scan the *uncorrected* ID. */
-    const char *p;
-    if ((p = uprv_strrchr(posixID, '@')) != nullptr) {
-        p++;
-
-        /* Take care of any special cases here.. */
-        if (!uprv_strcmp(p, "nynorsk")) {
-            p = "NY";
-            /* Don't worry about no__NY. In practice, it won't appear. */
-        }
-
-        if (uprv_strchr(correctedPOSIXLocale,'_') == nullptr) {
-            uprv_strcat(correctedPOSIXLocale, "__"); /* aa@b -> aa__b (note this can make the new locale 1 char longer) */
-        }
-        else {
-            uprv_strcat(correctedPOSIXLocale, "_"); /* aa_CC@b -> aa_CC_b */
-        }
-
-        const char *q;
-        if ((q = uprv_strchr(p, '.')) != nullptr) {
-            /* How big will the resulting string be? */
-            int32_t len = (int32_t)(uprv_strlen(correctedPOSIXLocale) + (q-p));
-            uprv_strncat(correctedPOSIXLocale, p, q-p); // do not include charset
-            correctedPOSIXLocale[len] = 0;
-        }
-        else {
-            /* Anything following the @ sign */
-            uprv_strcat(correctedPOSIXLocale, p);
-        }
-
-        /* Should there be a map from 'no@nynorsk' -> no_NO_NY here?
-         * How about 'russian' -> 'ru'?
-         * Many of the other locales using ISO codes will be handled by the
-         * canonicalization functions in uloc_getDefault.
-         */
-    }
-
-    if (gCorrectedPOSIXLocale == nullptr) {
-        gCorrectedPOSIXLocale = correctedPOSIXLocale;
-        gCorrectedPOSIXLocaleHeapAllocated = true;
-        ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup);
-        correctedPOSIXLocale = nullptr;
-    }
-    posixID = gCorrectedPOSIXLocale;
-
-    if (correctedPOSIXLocale != nullptr) {  /* Was already set - clean up. */
-        uprv_free(correctedPOSIXLocale);
-    }
-
-    return posixID;
-
-#elif U_PLATFORM_USES_ONLY_WIN32_API
-#define POSIX_LOCALE_CAPACITY 64
-    UErrorCode status = U_ZERO_ERROR;
-    char *correctedPOSIXLocale = nullptr;
-
-    // If we have already figured this out just use the cached value
-    if (gCorrectedPOSIXLocale != nullptr) {
-        return gCorrectedPOSIXLocale;
-    }
-
-    // No cached value, need to determine the current value
-    static WCHAR windowsLocale[LOCALE_NAME_MAX_LENGTH] = {};
-    int length = GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_SNAME, windowsLocale, LOCALE_NAME_MAX_LENGTH);
-
-    // Now we should have a Windows locale name that needs converted to the POSIX style.
-    if (length > 0) // If length is 0, then the GetLocaleInfoEx failed.
-    {
-        // First we need to go from UTF-16 to char (and also convert from _ to - while we're at it.)
-        char modifiedWindowsLocale[LOCALE_NAME_MAX_LENGTH] = {};
-
-        int32_t i;
-        for (i = 0; i < UPRV_LENGTHOF(modifiedWindowsLocale); i++)
-        {
-            if (windowsLocale[i] == '_')
-            {
-                modifiedWindowsLocale[i] = '-';
-            }
-            else
-            {
-                modifiedWindowsLocale[i] = static_cast<char>(windowsLocale[i]);
-            }
-
-            if (modifiedWindowsLocale[i] == '\0')
-            {
-                break;
-            }
-        }
-
-        if (i >= UPRV_LENGTHOF(modifiedWindowsLocale))
-        {
-            // Ran out of room, can't really happen, maybe we'll be lucky about a matching
-            // locale when tags are dropped
-            modifiedWindowsLocale[UPRV_LENGTHOF(modifiedWindowsLocale) - 1] = '\0';
-        }
-
-        // Now normalize the resulting name
-        correctedPOSIXLocale = static_cast<char *>(uprv_malloc(POSIX_LOCALE_CAPACITY + 1));
-        /* TODO: Should we just exit on memory allocation failure? */
-        if (correctedPOSIXLocale)
-        {
-            int32_t posixLen = uloc_canonicalize(modifiedWindowsLocale, correctedPOSIXLocale, POSIX_LOCALE_CAPACITY, &status);
-            if (U_SUCCESS(status))
-            {
-                *(correctedPOSIXLocale + posixLen) = 0;
-                gCorrectedPOSIXLocale = correctedPOSIXLocale;
-                gCorrectedPOSIXLocaleHeapAllocated = true;
-                ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup);
-            }
-            else
-            {
-                uprv_free(correctedPOSIXLocale);
-            }
-        }
-    }
-
-    // If unable to find a locale we can agree upon, use en-US by default
-    if (gCorrectedPOSIXLocale == nullptr) {
-        gCorrectedPOSIXLocale = "en_US";
-    }
-    return gCorrectedPOSIXLocale;
-
-#elif U_PLATFORM == U_PF_OS400
-    /* locales are process scoped and are by definition thread safe */
-    static char correctedLocale[64];
-    const  char *localeID = getenv("LC_ALL");
-           char *p;
-
-    if (localeID == NULL)
-        localeID = getenv("LANG");
-    if (localeID == NULL)
-        localeID = setlocale(LC_ALL, NULL);
-    /* Make sure we have something... */
-    if (localeID == NULL)
-        return "en_US_POSIX";
-
-    /* Extract the locale name from the path. */
-    if((p = uprv_strrchr(localeID, '/')) != NULL)
-    {
-        /* Increment p to start of locale name. */
-        p++;
-        localeID = p;
-    }
-
-    /* Copy to work location. */
-    uprv_strcpy(correctedLocale, localeID);
-
-    /* Strip off the '.locale' extension. */
-    if((p = uprv_strchr(correctedLocale, '.')) != NULL) {
-        *p = 0;
-    }
-
-    /* Upper case the locale name. */
-    T_CString_toUpperCase(correctedLocale);
-
-    /* See if we are using the POSIX locale.  Any of the
-    * following are equivalent and use the same QLGPGCMA
-    * (POSIX) locale.
-    * QLGPGCMA2 means UCS2
-    * QLGPGCMA_4 means UTF-32
-    * QLGPGCMA_8 means UTF-8
-    */
-    if ((uprv_strcmp("C", correctedLocale) == 0) ||
-        (uprv_strcmp("POSIX", correctedLocale) == 0) ||
-        (uprv_strncmp("QLGPGCMA", correctedLocale, 8) == 0))
-    {
-        uprv_strcpy(correctedLocale, "en_US_POSIX");
-    }
-    else
-    {
-        int16_t LocaleLen;
-
-        /* Lower case the lang portion. */
-        for(p = correctedLocale; *p != 0 && *p != '_'; p++)
-        {
-            *p = uprv_tolower(*p);
-        }
-
-        /* Adjust for Euro.  After '_E' add 'URO'. */
-        LocaleLen = uprv_strlen(correctedLocale);
-        if (correctedLocale[LocaleLen - 2] == '_' &&
-            correctedLocale[LocaleLen - 1] == 'E')
-        {
-            uprv_strcat(correctedLocale, "URO");
-        }
-
-        /* If using Lotus-based locale then convert to
-         * equivalent non Lotus.
-         */
-        else if (correctedLocale[LocaleLen - 2] == '_' &&
-            correctedLocale[LocaleLen - 1] == 'L')
-        {
-            correctedLocale[LocaleLen - 2] = 0;
-        }
-
-        /* There are separate simplified and traditional
-         * locales called zh_HK_S and zh_HK_T.
-         */
-        else if (uprv_strncmp(correctedLocale, "zh_HK", 5) == 0)
-        {
-            uprv_strcpy(correctedLocale, "zh_HK");
-        }
-
-        /* A special zh_CN_GBK locale...
-        */
-        else if (uprv_strcmp(correctedLocale, "zh_CN_GBK") == 0)
-        {
-            uprv_strcpy(correctedLocale, "zh_CN");
-        }
-
-    }
-
-    return correctedLocale;
-#endif
-
-}
-
-#if !U_CHARSET_IS_UTF8
-#if U_POSIX_LOCALE
-/*
-Due to various platform differences, one platform may specify a charset,
-when they really mean a different charset. Remap the names so that they are
-compatible with ICU. Only conflicting/ambiguous aliases should be resolved
-here. Before adding anything to this function, please consider adding unique
-names to the ICU alias table in the data directory.
-*/
-static const char*
-remapPlatformDependentCodepage(const char *locale, const char *name) {
-    if (locale != NULL && *locale == 0) {
-        /* Make sure that an empty locale is handled the same way. */
-        locale = NULL;
-    }
-    if (name == NULL) {
-        return NULL;
-    }
-#if U_PLATFORM == U_PF_AIX
-    if (uprv_strcmp(name, "IBM-943") == 0) {
-        /* Use the ASCII compatible ibm-943 */
-        name = "Shift-JIS";
-    }
-    else if (uprv_strcmp(name, "IBM-1252") == 0) {
-        /* Use the windows-1252 that contains the Euro */
-        name = "IBM-5348";
-    }
-#elif U_PLATFORM == U_PF_SOLARIS
-    if (locale != NULL && uprv_strcmp(name, "EUC") == 0) {
-        /* Solaris underspecifies the "EUC" name. */
-        if (uprv_strcmp(locale, "zh_CN") == 0) {
-            name = "EUC-CN";
-        }
-        else if (uprv_strcmp(locale, "zh_TW") == 0) {
-            name = "EUC-TW";
-        }
-        else if (uprv_strcmp(locale, "ko_KR") == 0) {
-            name = "EUC-KR";
-        }
-    }
-    else if (uprv_strcmp(name, "eucJP") == 0) {
-        /*
-        ibm-954 is the best match.
-        ibm-33722 is the default for eucJP (similar to Windows).
-        */
-        name = "eucjis";
-    }
-    else if (uprv_strcmp(name, "646") == 0) {
-        /*
-         * The default codepage given by Solaris is 646 but the C library routines treat it as if it was
-         * ISO-8859-1 instead of US-ASCII(646).
-         */
-        name = "ISO-8859-1";
-    }
-#elif U_PLATFORM_IS_DARWIN_BASED
-    if (locale == NULL && *name == 0) {
-        /*
-        No locale was specified, and an empty name was passed in.
-        This usually indicates that nl_langinfo didn't return valid information.
-        Mac OS X uses UTF-8 by default (especially the locale data and console).
-        */
-        name = "UTF-8";
-    }
-    else if (uprv_strcmp(name, "CP949") == 0) {
-        /* Remap CP949 to a similar codepage to avoid issues with backslash and won symbol. */
-        name = "EUC-KR";
-    }
-    else if (locale != NULL && uprv_strcmp(locale, "en_US_POSIX") != 0 && uprv_strcmp(name, "US-ASCII") == 0) {
-        /*
-         * For non C/POSIX locale, default the code page to UTF-8 instead of US-ASCII.
-         */
-        name = "UTF-8";
-    }
-#elif U_PLATFORM == U_PF_BSD
-    if (uprv_strcmp(name, "CP949") == 0) {
-        /* Remap CP949 to a similar codepage to avoid issues with backslash and won symbol. */
-        name = "EUC-KR";
-    }
-#elif U_PLATFORM == U_PF_HPUX
-    if (locale != NULL && uprv_strcmp(locale, "zh_HK") == 0 && uprv_strcmp(name, "big5") == 0) {
-        /* HP decided to extend big5 as hkbig5 even though it's not compatible :-( */
-        /* zh_TW.big5 is not the same charset as zh_HK.big5! */
-        name = "hkbig5";
-    }
-    else if (uprv_strcmp(name, "eucJP") == 0) {
-        /*
-        ibm-1350 is the best match, but unavailable.
-        ibm-954 is mostly a superset of ibm-1350.
-        ibm-33722 is the default for eucJP (similar to Windows).
-        */
-        name = "eucjis";
-    }
-#elif U_PLATFORM == U_PF_LINUX
-    if (locale != NULL && uprv_strcmp(name, "euc") == 0) {
-        /* Linux underspecifies the "EUC" name. */
-        if (uprv_strcmp(locale, "korean") == 0) {
-            name = "EUC-KR";
-        }
-        else if (uprv_strcmp(locale, "japanese") == 0) {
-            /* See comment below about eucJP */
-            name = "eucjis";
-        }
-    }
-    else if (uprv_strcmp(name, "eucjp") == 0) {
-        /*
-        ibm-1350 is the best match, but unavailable.
-        ibm-954 is mostly a superset of ibm-1350.
-        ibm-33722 is the default for eucJP (similar to Windows).
-        */
-        name = "eucjis";
-    }
-    else if (locale != NULL && uprv_strcmp(locale, "en_US_POSIX") != 0 &&
-            (uprv_strcmp(name, "ANSI_X3.4-1968") == 0 || uprv_strcmp(name, "US-ASCII") == 0)) {
-        /*
-         * For non C/POSIX locale, default the code page to UTF-8 instead of US-ASCII.
-         */
-        name = "UTF-8";
-    }
-    /*
-     * Linux returns ANSI_X3.4-1968 for C/POSIX, but the call site takes care of
-     * it by falling back to 'US-ASCII' when NULL is returned from this
-     * function. So, we don't have to worry about it here.
-     */
-#endif
-    /* return NULL when "" is passed in */
-    if (*name == 0) {
-        name = NULL;
-    }
-    return name;
-}
-
-static const char*
-getCodepageFromPOSIXID(const char *localeName, char * buffer, int32_t buffCapacity)
-{
-    char localeBuf[100];
-    const char *name = NULL;
-    char *variant = NULL;
-
-    if (localeName != NULL && (name = (uprv_strchr(localeName, '.'))) != NULL) {
-        size_t localeCapacity = uprv_min(sizeof(localeBuf), (name-localeName)+1);
-        uprv_strncpy(localeBuf, localeName, localeCapacity);
-        localeBuf[localeCapacity-1] = 0; /* ensure NULL termination */
-        name = uprv_strncpy(buffer, name+1, buffCapacity);
-        buffer[buffCapacity-1] = 0; /* ensure NULL termination */
-        if ((variant = const_cast<char *>(uprv_strchr(name, '@'))) != NULL) {
-            *variant = 0;
-        }
-        name = remapPlatformDependentCodepage(localeBuf, name);
-    }
-    return name;
-}
-#endif
-
-static const char*
-int_getDefaultCodepage()
-{
-#if U_PLATFORM == U_PF_OS400
-    uint32_t ccsid = 37; /* Default to ibm-37 */
-    static char codepage[64];
-    Qwc_JOBI0400_t jobinfo;
-    Qus_EC_t error = { sizeof(Qus_EC_t) }; /* SPI error code */
-
-    EPT_CALL(QUSRJOBI)(&jobinfo, sizeof(jobinfo), "JOBI0400",
-        "*                         ", "                ", &error);
-
-    if (error.Bytes_Available == 0) {
-        if (jobinfo.Coded_Char_Set_ID != 0xFFFF) {
-            ccsid = (uint32_t)jobinfo.Coded_Char_Set_ID;
-        }
-        else if (jobinfo.Default_Coded_Char_Set_Id != 0xFFFF) {
-            ccsid = (uint32_t)jobinfo.Default_Coded_Char_Set_Id;
-        }
-        /* else use the default */
-    }
-    sprintf(codepage,"ibm-%d", ccsid);
-    return codepage;
-
-#elif U_PLATFORM == U_PF_OS390
-    static char codepage[64];
-
-    strncpy(codepage, nl_langinfo(CODESET),63-strlen(UCNV_SWAP_LFNL_OPTION_STRING));
-    strcat(codepage,UCNV_SWAP_LFNL_OPTION_STRING);
-    codepage[63] = 0; /* NULL terminate */
-
-    return codepage;
-
-#elif U_PLATFORM_USES_ONLY_WIN32_API
-    static char codepage[64];
-    DWORD codepageNumber = 0;
-
-#if U_PLATFORM_HAS_WINUWP_API > 0
-    // UWP doesn't have a direct API to get the default ACP as Microsoft would rather
-    // have folks use Unicode than a "system" code page, however this is the same
-    // codepage as the system default locale codepage.  (FWIW, the system locale is
-    // ONLY used for codepage, it should never be used for anything else)
-    GetLocaleInfoEx(LOCALE_NAME_SYSTEM_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
-        (LPWSTR)&codepageNumber, sizeof(codepageNumber) / sizeof(WCHAR));
-#else
-    // Win32 apps can call GetACP
-    codepageNumber = GetACP();
-#endif
-    // Special case for UTF-8
-    if (codepageNumber == 65001)
-    {
-        return "UTF-8";
-    }
-    // Windows codepages can look like windows-1252, so format the found number
-    // the numbers are eclectic, however all valid system code pages, besides UTF-8
-    // are between 3 and 19999
-    if (codepageNumber > 0 && codepageNumber < 20000)
-    {
-        sprintf(codepage, "windows-%ld", codepageNumber);
-        return codepage;
-    }
-    // If the codepage number call failed then return UTF-8
-    return "UTF-8";
-
-#elif U_POSIX_LOCALE
-    static char codesetName[100];
-    const char *localeName = NULL;
-    const char *name = NULL;
-
-    localeName = uprv_getPOSIXIDForDefaultCodepage();
-    uprv_memset(codesetName, 0, sizeof(codesetName));
-    /* On Solaris nl_langinfo returns C locale values unless setlocale
-     * was called earlier.
-     */
-#if (U_HAVE_NL_LANGINFO_CODESET && U_PLATFORM != U_PF_SOLARIS)
-    /* When available, check nl_langinfo first because it usually gives more
-       useful names. It depends on LC_CTYPE.
-       nl_langinfo may use the same buffer as setlocale. */
-    {
-        const char *codeset = nl_langinfo(U_NL_LANGINFO_CODESET);
-#if U_PLATFORM_IS_DARWIN_BASED || U_PLATFORM_IS_LINUX_BASED
-        /*
-         * On Linux and MacOSX, ensure that default codepage for non C/POSIX locale is UTF-8
-         * instead of ASCII.
-         */
-        if (uprv_strcmp(localeName, "en_US_POSIX") != 0) {
-            codeset = remapPlatformDependentCodepage(localeName, codeset);
-        } else
-#endif
-        {
-            codeset = remapPlatformDependentCodepage(NULL, codeset);
-        }
-
-        if (codeset != NULL) {
-            uprv_strncpy(codesetName, codeset, sizeof(codesetName));
-            codesetName[sizeof(codesetName)-1] = 0;
-            return codesetName;
-        }
-    }
-#endif
-
-    /* Use setlocale in a nice way, and then check some environment variables.
-       Maybe the application used setlocale already.
-    */
-    uprv_memset(codesetName, 0, sizeof(codesetName));
-    name = getCodepageFromPOSIXID(localeName, codesetName, sizeof(codesetName));
-    if (name) {
-        /* if we can find the codeset name from setlocale, return that. */
-        return name;
-    }
-
-    if (*codesetName == 0)
-    {
-        /* Everything failed. Return US ASCII (ISO 646). */
-        (void)uprv_strcpy(codesetName, "US-ASCII");
-    }
-    return codesetName;
-#else
-    return "US-ASCII";
-#endif
-}
-
-
-U_CAPI const char*  U_EXPORT2
-uprv_getDefaultCodepage()
-{
-    static char const  *name = NULL;
-    umtx_lock(NULL);
-    if (name == NULL) {
-        name = int_getDefaultCodepage();
-    }
-    umtx_unlock(NULL);
-    return name;
-}
-#endif  /* !U_CHARSET_IS_UTF8 */
-
-
-/* end of platform-specific implementation -------------- */
-
-/* version handling --------------------------------------------------------- */
-
-U_CAPI void U_EXPORT2
-u_versionFromString(UVersionInfo versionArray, const char *versionString) {
-    char *end;
-    uint16_t part=0;
-
-    if(versionArray==NULL) {
-        return;
-    }
-
-    if(versionString!=NULL) {
-        for(;;) {
-            versionArray[part]=(uint8_t)uprv_strtoul(versionString, &end, 10);
-            if(end==versionString || ++part==U_MAX_VERSION_LENGTH || *end!=U_VERSION_DELIMITER) {
-                break;
-            }
-            versionString=end+1;
-        }
-    }
-
-    while(part<U_MAX_VERSION_LENGTH) {
-        versionArray[part++]=0;
-    }
-}
-
-U_CAPI void U_EXPORT2
-u_versionFromUString(UVersionInfo versionArray, const UChar *versionString) {
-    if(versionArray!=NULL && versionString!=NULL) {
-        char versionChars[U_MAX_VERSION_STRING_LENGTH+1];
-        int32_t len = u_strlen(versionString);
-        if(len>U_MAX_VERSION_STRING_LENGTH) {
-            len = U_MAX_VERSION_STRING_LENGTH;
-        }
-        u_UCharsToChars(versionString, versionChars, len);
-        versionChars[len]=0;
-        u_versionFromString(versionArray, versionChars);
-    }
-}
-
-U_CAPI void U_EXPORT2
-u_versionToString(const UVersionInfo versionArray, char *versionString) {
-    uint16_t count, part;
-    uint8_t field;
-
-    if(versionString==NULL) {
-        return;
-    }
-
-    if(versionArray==NULL) {
-        versionString[0]=0;
-        return;
-    }
-
-    /* count how many fields need to be written */
-    for(count=4; count>0 && versionArray[count-1]==0; --count) {
-    }
-
-    if(count <= 1) {
-        count = 2;
-    }
-
-    /* write the first part */
-    /* write the decimal field value */
-    field=versionArray[0];
-    if(field>=100) {
-        *versionString++=(char)('0'+field/100);
-        field%=100;
-    }
-    if(field>=10) {
-        *versionString++=(char)('0'+field/10);
-        field%=10;
-    }
-    *versionString++=(char)('0'+field);
-
-    /* write the following parts */
-    for(part=1; part<count; ++part) {
-        /* write a dot first */
-        *versionString++=U_VERSION_DELIMITER;
-
-        /* write the decimal field value */
-        field=versionArray[part];
-        if(field>=100) {
-            *versionString++=(char)('0'+field/100);
-            field%=100;
-        }
-        if(field>=10) {
-            *versionString++=(char)('0'+field/10);
-            field%=10;
-        }
-        *versionString++=(char)('0'+field);
-    }
-
-    /* NUL-terminate */
-    *versionString=0;
-}
-
-U_CAPI void U_EXPORT2
-u_getVersion(UVersionInfo versionArray) {
-    (void)copyright;   // Suppress unused variable warning from clang.
-    u_versionFromString(versionArray, U_ICU_VERSION);
-}
-
-/**
- * icucfg.h dependent code
- */
-
-#if U_ENABLE_DYLOAD && HAVE_DLOPEN && !U_PLATFORM_USES_ONLY_WIN32_API
-
-#if HAVE_DLFCN_H
-#ifdef __MVS__
-#ifndef __SUSV3
-#define __SUSV3 1
-#endif
-#endif
-#include <dlfcn.h>
-#endif /* HAVE_DLFCN_H */
-
-U_INTERNAL void * U_EXPORT2
-uprv_dl_open(const char *libName, UErrorCode *status) {
-  void *ret = NULL;
-  if(U_FAILURE(*status)) return ret;
-  ret =  dlopen(libName, RTLD_NOW|RTLD_GLOBAL);
-  if(ret==NULL) {
-#ifdef U_TRACE_DYLOAD
-    printf("dlerror on dlopen(%s): %s\n", libName, dlerror());
-#endif
-    *status = U_MISSING_RESOURCE_ERROR;
-  }
-  return ret;
-}
-
-U_INTERNAL void U_EXPORT2
-uprv_dl_close(void *lib, UErrorCode *status) {
-  if(U_FAILURE(*status)) return;
-  dlclose(lib);
-}
-
-U_INTERNAL UVoidFunction* U_EXPORT2
-uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) {
-  union {
-      UVoidFunction *fp;
-      void *vp;
-  } uret;
-  uret.fp = NULL;
-  if(U_FAILURE(*status)) return uret.fp;
-  uret.vp = dlsym(lib, sym);
-  if(uret.vp == NULL) {
-#ifdef U_TRACE_DYLOAD
-    printf("dlerror on dlsym(%p,%s): %s\n", lib,sym, dlerror());
-#endif
-    *status = U_MISSING_RESOURCE_ERROR;
-  }
-  return uret.fp;
-}
-
-#elif U_ENABLE_DYLOAD && U_PLATFORM_USES_ONLY_WIN32_API && !U_PLATFORM_HAS_WINUWP_API
-
-/* Windows API implementation. */
-// Note: UWP does not expose/allow these APIs, so the UWP version gets the null implementation. */
-
-U_INTERNAL void * U_EXPORT2
-uprv_dl_open(const char *libName, UErrorCode *status) {
-  HMODULE lib = NULL;
-
-  if(U_FAILURE(*status)) return NULL;
-
-  lib = LoadLibraryA(libName);
-
-  if(lib==NULL) {
-    *status = U_MISSING_RESOURCE_ERROR;
-  }
-
-  return (void*)lib;
-}
-
-U_INTERNAL void U_EXPORT2
-uprv_dl_close(void *lib, UErrorCode *status) {
-  HMODULE handle = (HMODULE)lib;
-  if(U_FAILURE(*status)) return;
-
-  FreeLibrary(handle);
-
-  return;
-}
-
-U_INTERNAL UVoidFunction* U_EXPORT2
-uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) {
-  HMODULE handle = (HMODULE)lib;
-  UVoidFunction* addr = NULL;
-
-  if(U_FAILURE(*status) || lib==NULL) return NULL;
-
-  addr = (UVoidFunction*)GetProcAddress(handle, sym);
-
-  if(addr==NULL) {
-    DWORD lastError = GetLastError();
-    if(lastError == ERROR_PROC_NOT_FOUND) {
-      *status = U_MISSING_RESOURCE_ERROR;
-    } else {
-      *status = U_UNSUPPORTED_ERROR; /* other unknown error. */
-    }
-  }
-
-  return addr;
-}
-
-#else
-
-/* No dynamic loading, null (nonexistent) implementation. */
-
-U_INTERNAL void * U_EXPORT2
-uprv_dl_open(const char *libName, UErrorCode *status) {
-    (void)libName;
-    if(U_FAILURE(*status)) return NULL;
-    *status = U_UNSUPPORTED_ERROR;
-    return NULL;
-}
-
-U_INTERNAL void U_EXPORT2
-uprv_dl_close(void *lib, UErrorCode *status) {
-    (void)lib;
-    if(U_FAILURE(*status)) return;
-    *status = U_UNSUPPORTED_ERROR;
-    return;
-}
-
-U_INTERNAL UVoidFunction* U_EXPORT2
-uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) {
-  (void)lib;
-  (void)sym;
-  if(U_SUCCESS(*status)) {
-    *status = U_UNSUPPORTED_ERROR;
-  }
-  return (UVoidFunction*)NULL;
-}
-
-#endif
-
-/*
- * Hey, Emacs, please set the following:
- *
- * Local Variables:
- * indent-tabs-mode: nil
- * End:
- *
- */
diff --git a/tools/icu/patches/64/source/i18n/dtptngen.cpp b/tools/icu/patches/64/source/i18n/dtptngen.cpp
deleted file mode 100644
index eb8bcfb971f427cf283fb41d2f03c46ec086f914..0000000000000000000000000000000000000000
--- a/tools/icu/patches/64/source/i18n/dtptngen.cpp
+++ /dev/null
@@ -1,2778 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2007-2016, International Business Machines Corporation and
-* others. All Rights Reserved.
-*******************************************************************************
-*
-* File DTPTNGEN.CPP
-*
-*******************************************************************************
-*/
-
-#include "unicode/utypes.h"
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/datefmt.h"
-#include "unicode/decimfmt.h"
-#include "unicode/dtfmtsym.h"
-#include "unicode/dtptngen.h"
-#include "unicode/localpointer.h"
-#include "unicode/simpleformatter.h"
-#include "unicode/smpdtfmt.h"
-#include "unicode/udat.h"
-#include "unicode/udatpg.h"
-#include "unicode/uniset.h"
-#include "unicode/uloc.h"
-#include "unicode/ures.h"
-#include "unicode/ustring.h"
-#include "unicode/rep.h"
-#include "cpputils.h"
-#include "mutex.h"
-#include "umutex.h"
-#include "cmemory.h"
-#include "cstring.h"
-#include "locbased.h"
-#include "hash.h"
-#include "uhash.h"
-#include "uresimp.h"
-#include "dtptngen_impl.h"
-#include "ucln_in.h"
-#include "charstr.h"
-#include "uassert.h"
-
-#if U_CHARSET_FAMILY==U_EBCDIC_FAMILY
-/**
- * If we are on EBCDIC, use an iterator which will
- * traverse the bundles in ASCII order.
- */
-#define U_USE_ASCII_BUNDLE_ITERATOR
-#define U_SORT_ASCII_BUNDLE_ITERATOR
-#endif
-
-#if defined(U_USE_ASCII_BUNDLE_ITERATOR)
-
-#include "unicode/ustring.h"
-#include "uarrsort.h"
-
-struct UResAEntry {
-    UChar *key;
-    UResourceBundle *item;
-};
-
-struct UResourceBundleAIterator {
-    UResourceBundle  *bund;
-    UResAEntry *entries;
-    int32_t num;
-    int32_t cursor;
-};
-
-/* Must be C linkage to pass function pointer to the sort function */
-
-U_CDECL_BEGIN
-
-static int32_t U_CALLCONV
-ures_a_codepointSort(const void *context, const void *left, const void *right) {
-    //CompareContext *cmp=(CompareContext *)context;
-    return u_strcmp(((const UResAEntry *)left)->key,
-                    ((const UResAEntry *)right)->key);
-}
-
-U_CDECL_END
-
-static void ures_a_open(UResourceBundleAIterator *aiter, UResourceBundle *bund, UErrorCode *status) {
-    if(U_FAILURE(*status)) {
-        return;
-    }
-    aiter->bund = bund;
-    aiter->num = ures_getSize(aiter->bund);
-    aiter->cursor = 0;
-#if !defined(U_SORT_ASCII_BUNDLE_ITERATOR)
-    aiter->entries = nullptr;
-#else
-    aiter->entries = (UResAEntry*)uprv_malloc(sizeof(UResAEntry)*aiter->num);
-    for(int i=0;i<aiter->num;i++) {
-        aiter->entries[i].item = ures_getByIndex(aiter->bund, i, nullptr, status);
-        const char *akey = ures_getKey(aiter->entries[i].item);
-        int32_t len = uprv_strlen(akey)+1;
-        aiter->entries[i].key = (UChar*)uprv_malloc(len*sizeof(UChar));
-        u_charsToUChars(akey, aiter->entries[i].key, len);
-    }
-    uprv_sortArray(aiter->entries, aiter->num, sizeof(UResAEntry), ures_a_codepointSort, nullptr, TRUE, status);
-#endif
-}
-
-static void ures_a_close(UResourceBundleAIterator *aiter) {
-#if defined(U_SORT_ASCII_BUNDLE_ITERATOR)
-    for(int i=0;i<aiter->num;i++) {
-        uprv_free(aiter->entries[i].key);
-        ures_close(aiter->entries[i].item);
-    }
-#endif
-}
-
-static const UChar *ures_a_getNextString(UResourceBundleAIterator *aiter, int32_t *len, const char **key, UErrorCode *err) {
-#if !defined(U_SORT_ASCII_BUNDLE_ITERATOR)
-    return ures_getNextString(aiter->bund, len, key, err);
-#else
-    if(U_FAILURE(*err)) return nullptr;
-    UResourceBundle *item = aiter->entries[aiter->cursor].item;
-    const UChar* ret = ures_getString(item, len, err);
-    *key = ures_getKey(item);
-    aiter->cursor++;
-    return ret;
-#endif
-}
-
-
-#endif
-
-
-U_NAMESPACE_BEGIN
-
-// *****************************************************************************
-// class DateTimePatternGenerator
-// *****************************************************************************
-static const UChar Canonical_Items[] = {
-    // GyQMwWEDFdaHmsSv
-    CAP_G, LOW_Y, CAP_Q, CAP_M, LOW_W, CAP_W, CAP_E,
-    CAP_D, CAP_F, LOW_D, LOW_A, // The UDATPG_x_FIELD constants and these fields have a different order than in ICU4J
-    CAP_H, LOW_M, LOW_S, CAP_S, LOW_V, 0
-};
-
-static const dtTypeElem dtTypes[] = {
-    // patternChar, field, type, minLen, weight
-    {CAP_G, UDATPG_ERA_FIELD, DT_SHORT, 1, 3,},
-    {CAP_G, UDATPG_ERA_FIELD, DT_LONG,  4, 0},
-    {CAP_G, UDATPG_ERA_FIELD, DT_NARROW, 5, 0},
-
-    {LOW_Y, UDATPG_YEAR_FIELD, DT_NUMERIC, 1, 20},
-    {CAP_Y, UDATPG_YEAR_FIELD, DT_NUMERIC + DT_DELTA, 1, 20},
-    {LOW_U, UDATPG_YEAR_FIELD, DT_NUMERIC + 2*DT_DELTA, 1, 20},
-    {LOW_R, UDATPG_YEAR_FIELD, DT_NUMERIC + 3*DT_DELTA, 1, 20},
-    {CAP_U, UDATPG_YEAR_FIELD, DT_SHORT, 1, 3},
-    {CAP_U, UDATPG_YEAR_FIELD, DT_LONG, 4, 0},
-    {CAP_U, UDATPG_YEAR_FIELD, DT_NARROW, 5, 0},
-
-    {CAP_Q, UDATPG_QUARTER_FIELD, DT_NUMERIC, 1, 2},
-    {CAP_Q, UDATPG_QUARTER_FIELD, DT_SHORT, 3, 0},
-    {CAP_Q, UDATPG_QUARTER_FIELD, DT_LONG, 4, 0},
-    {CAP_Q, UDATPG_QUARTER_FIELD, DT_NARROW, 5, 0},
-    {LOW_Q, UDATPG_QUARTER_FIELD, DT_NUMERIC + DT_DELTA, 1, 2},
-    {LOW_Q, UDATPG_QUARTER_FIELD, DT_SHORT - DT_DELTA, 3, 0},
-    {LOW_Q, UDATPG_QUARTER_FIELD, DT_LONG - DT_DELTA, 4, 0},
-    {LOW_Q, UDATPG_QUARTER_FIELD, DT_NARROW - DT_DELTA, 5, 0},
-
-    {CAP_M, UDATPG_MONTH_FIELD, DT_NUMERIC, 1, 2},
-    {CAP_M, UDATPG_MONTH_FIELD, DT_SHORT, 3, 0},
-    {CAP_M, UDATPG_MONTH_FIELD, DT_LONG, 4, 0},
-    {CAP_M, UDATPG_MONTH_FIELD, DT_NARROW, 5, 0},
-    {CAP_L, UDATPG_MONTH_FIELD, DT_NUMERIC + DT_DELTA, 1, 2},
-    {CAP_L, UDATPG_MONTH_FIELD, DT_SHORT - DT_DELTA, 3, 0},
-    {CAP_L, UDATPG_MONTH_FIELD, DT_LONG - DT_DELTA, 4, 0},
-    {CAP_L, UDATPG_MONTH_FIELD, DT_NARROW - DT_DELTA, 5, 0},
-    {LOW_L, UDATPG_MONTH_FIELD, DT_NUMERIC + DT_DELTA, 1, 1},
-
-    {LOW_W, UDATPG_WEEK_OF_YEAR_FIELD, DT_NUMERIC, 1, 2},
-
-    {CAP_W, UDATPG_WEEK_OF_MONTH_FIELD, DT_NUMERIC, 1, 0},
-
-    {CAP_E, UDATPG_WEEKDAY_FIELD, DT_SHORT, 1, 3},
-    {CAP_E, UDATPG_WEEKDAY_FIELD, DT_LONG, 4, 0},
-    {CAP_E, UDATPG_WEEKDAY_FIELD, DT_NARROW, 5, 0},
-    {CAP_E, UDATPG_WEEKDAY_FIELD, DT_SHORTER, 6, 0},
-    {LOW_C, UDATPG_WEEKDAY_FIELD, DT_NUMERIC + 2*DT_DELTA, 1, 2},
-    {LOW_C, UDATPG_WEEKDAY_FIELD, DT_SHORT - 2*DT_DELTA, 3, 0},
-    {LOW_C, UDATPG_WEEKDAY_FIELD, DT_LONG - 2*DT_DELTA, 4, 0},
-    {LOW_C, UDATPG_WEEKDAY_FIELD, DT_NARROW - 2*DT_DELTA, 5, 0},
-    {LOW_C, UDATPG_WEEKDAY_FIELD, DT_SHORTER - 2*DT_DELTA, 6, 0},
-    {LOW_E, UDATPG_WEEKDAY_FIELD, DT_NUMERIC + DT_DELTA, 1, 2}, // LOW_E is currently not used in CLDR data, should not be canonical
-    {LOW_E, UDATPG_WEEKDAY_FIELD, DT_SHORT - DT_DELTA, 3, 0},
-    {LOW_E, UDATPG_WEEKDAY_FIELD, DT_LONG - DT_DELTA, 4, 0},
-    {LOW_E, UDATPG_WEEKDAY_FIELD, DT_NARROW - DT_DELTA, 5, 0},
-    {LOW_E, UDATPG_WEEKDAY_FIELD, DT_SHORTER - DT_DELTA, 6, 0},
-
-    {LOW_D, UDATPG_DAY_FIELD, DT_NUMERIC, 1, 2},
-    {LOW_G, UDATPG_DAY_FIELD, DT_NUMERIC + DT_DELTA, 1, 20}, // really internal use, so we don't care
-
-    {CAP_D, UDATPG_DAY_OF_YEAR_FIELD, DT_NUMERIC, 1, 3},
-
-    {CAP_F, UDATPG_DAY_OF_WEEK_IN_MONTH_FIELD, DT_NUMERIC, 1, 0},
-
-    {LOW_A, UDATPG_DAYPERIOD_FIELD, DT_SHORT, 1, 3},
-    {LOW_A, UDATPG_DAYPERIOD_FIELD, DT_LONG, 4, 0},
-    {LOW_A, UDATPG_DAYPERIOD_FIELD, DT_NARROW, 5, 0},
-    {LOW_B, UDATPG_DAYPERIOD_FIELD, DT_SHORT - DT_DELTA, 1, 3},
-    {LOW_B, UDATPG_DAYPERIOD_FIELD, DT_LONG - DT_DELTA, 4, 0},
-    {LOW_B, UDATPG_DAYPERIOD_FIELD, DT_NARROW - DT_DELTA, 5, 0},
-    // b needs to be closer to a than to B, so we make this 3*DT_DELTA
-    {CAP_B, UDATPG_DAYPERIOD_FIELD, DT_SHORT - 3*DT_DELTA, 1, 3},
-    {CAP_B, UDATPG_DAYPERIOD_FIELD, DT_LONG - 3*DT_DELTA, 4, 0},
-    {CAP_B, UDATPG_DAYPERIOD_FIELD, DT_NARROW - 3*DT_DELTA, 5, 0},
-
-    {CAP_H, UDATPG_HOUR_FIELD, DT_NUMERIC + 10*DT_DELTA, 1, 2}, // 24 hour
-    {LOW_K, UDATPG_HOUR_FIELD, DT_NUMERIC + 11*DT_DELTA, 1, 2}, // 24 hour
-    {LOW_H, UDATPG_HOUR_FIELD, DT_NUMERIC, 1, 2}, // 12 hour
-    {CAP_K, UDATPG_HOUR_FIELD, DT_NUMERIC + DT_DELTA, 1, 2}, // 12 hour
-    // The C code has had versions of the following 3, keep & update. Should not need these, but...
-    // Without these, certain tests using e.g. staticGetSkeleton fail because j/J in patterns
-    // get skipped instead of mapped to the right hour chars, for example in
-    //   DateFormatTest::TestPatternFromSkeleton
-    //   IntlTestDateTimePatternGeneratorAPI:: testStaticGetSkeleton
-    //   DateIntervalFormatTest::testTicket11985
-    // Need to investigate better handling of jJC replacement e.g. in staticGetSkeleton.
-    {CAP_J, UDATPG_HOUR_FIELD, DT_NUMERIC + 5*DT_DELTA, 1, 2}, // 12/24 hour no AM/PM
-    {LOW_J, UDATPG_HOUR_FIELD, DT_NUMERIC + 6*DT_DELTA, 1, 6}, // 12/24 hour
-    {CAP_C, UDATPG_HOUR_FIELD, DT_NUMERIC + 7*DT_DELTA, 1, 6}, // 12/24 hour with preferred dayPeriods for 12
-
-    {LOW_M, UDATPG_MINUTE_FIELD, DT_NUMERIC, 1, 2},
-
-    {LOW_S, UDATPG_SECOND_FIELD, DT_NUMERIC, 1, 2},
-    {CAP_A, UDATPG_SECOND_FIELD, DT_NUMERIC + DT_DELTA, 1, 1000},
-
-    {CAP_S, UDATPG_FRACTIONAL_SECOND_FIELD, DT_NUMERIC, 1, 1000},
-
-    {LOW_V, UDATPG_ZONE_FIELD, DT_SHORT - 2*DT_DELTA, 1, 0},
-    {LOW_V, UDATPG_ZONE_FIELD, DT_LONG - 2*DT_DELTA, 4, 0},
-    {LOW_Z, UDATPG_ZONE_FIELD, DT_SHORT, 1, 3},
-    {LOW_Z, UDATPG_ZONE_FIELD, DT_LONG, 4, 0},
-    {CAP_Z, UDATPG_ZONE_FIELD, DT_NARROW - DT_DELTA, 1, 3},
-    {CAP_Z, UDATPG_ZONE_FIELD, DT_LONG - DT_DELTA, 4, 0},
-    {CAP_Z, UDATPG_ZONE_FIELD, DT_SHORT - DT_DELTA, 5, 0},
-    {CAP_O, UDATPG_ZONE_FIELD, DT_SHORT - DT_DELTA, 1, 0},
-    {CAP_O, UDATPG_ZONE_FIELD, DT_LONG - DT_DELTA, 4, 0},
-    {CAP_V, UDATPG_ZONE_FIELD, DT_SHORT - DT_DELTA, 1, 0},
-    {CAP_V, UDATPG_ZONE_FIELD, DT_LONG - DT_DELTA, 2, 0},
-    {CAP_V, UDATPG_ZONE_FIELD, DT_LONG-1 - DT_DELTA, 3, 0},
-    {CAP_V, UDATPG_ZONE_FIELD, DT_LONG-2 - DT_DELTA, 4, 0},
-    {CAP_X, UDATPG_ZONE_FIELD, DT_NARROW - DT_DELTA, 1, 0},
-    {CAP_X, UDATPG_ZONE_FIELD, DT_SHORT - DT_DELTA, 2, 0},
-    {CAP_X, UDATPG_ZONE_FIELD, DT_LONG - DT_DELTA, 4, 0},
-    {LOW_X, UDATPG_ZONE_FIELD, DT_NARROW - DT_DELTA, 1, 0},
-    {LOW_X, UDATPG_ZONE_FIELD, DT_SHORT - DT_DELTA, 2, 0},
-    {LOW_X, UDATPG_ZONE_FIELD, DT_LONG - DT_DELTA, 4, 0},
-
-    {0, UDATPG_FIELD_COUNT, 0, 0, 0} , // last row of dtTypes[]
- };
-
-static const char* const CLDR_FIELD_APPEND[] = {
-    "Era", "Year", "Quarter", "Month", "Week", "*", "Day-Of-Week",
-    "*", "*", "Day", "*", // The UDATPG_x_FIELD constants and these fields have a different order than in ICU4J
-    "Hour", "Minute", "Second", "*", "Timezone"
-};
-
-static const char* const CLDR_FIELD_NAME[UDATPG_FIELD_COUNT] = {
-    "era", "year", "quarter", "month", "week", "weekOfMonth", "weekday",
-    "dayOfYear", "weekdayOfMonth", "day", "dayperiod", // The UDATPG_x_FIELD constants and these fields have a different order than in ICU4J
-    "hour", "minute", "second", "*", "zone"
-};
-
-static const char* const CLDR_FIELD_WIDTH[] = { // [UDATPG_WIDTH_COUNT]
-    "", "-short", "-narrow"
-};
-
-// TODO(ticket:13619): remove when definition uncommented in dtptngen.h.
-static const int32_t UDATPG_WIDTH_COUNT = UDATPG_NARROW + 1;
-static constexpr UDateTimePGDisplayWidth UDATPG_WIDTH_APPENDITEM = UDATPG_WIDE;
-static constexpr int32_t UDATPG_FIELD_KEY_MAX = 24; // max length of CLDR field tag (type + width)
-
-// For appendItems
-static const UChar UDATPG_ItemFormat[]= {0x7B, 0x30, 0x7D, 0x20, 0x251C, 0x7B, 0x32, 0x7D, 0x3A,
-    0x20, 0x7B, 0x31, 0x7D, 0x2524, 0};  // {0} \u251C{2}: {1}\u2524
-
-//static const UChar repeatedPatterns[6]={CAP_G, CAP_E, LOW_Z, LOW_V, CAP_Q, 0}; // "GEzvQ"
-
-static const char DT_DateTimePatternsTag[]="DateTimePatterns";
-static const char DT_DateTimeCalendarTag[]="calendar";
-static const char DT_DateTimeGregorianTag[]="gregorian";
-static const char DT_DateTimeAppendItemsTag[]="appendItems";
-static const char DT_DateTimeFieldsTag[]="fields";
-static const char DT_DateTimeAvailableFormatsTag[]="availableFormats";
-//static const UnicodeString repeatedPattern=UnicodeString(repeatedPatterns);
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateTimePatternGenerator)
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DTSkeletonEnumeration)
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DTRedundantEnumeration)
-
-DateTimePatternGenerator*  U_EXPORT2
-DateTimePatternGenerator::createInstance(UErrorCode& status) {
-    return createInstance(Locale::getDefault(), status);
-}
-
-DateTimePatternGenerator* U_EXPORT2
-DateTimePatternGenerator::createInstance(const Locale& locale, UErrorCode& status) {
-    if (U_FAILURE(status)) {
-        return nullptr;
-    }
-    LocalPointer<DateTimePatternGenerator> result(
-            new DateTimePatternGenerator(locale, status), status);
-    return U_SUCCESS(status) ? result.orphan() : nullptr;
-}
-
-DateTimePatternGenerator*  U_EXPORT2
-DateTimePatternGenerator::createEmptyInstance(UErrorCode& status) {
-    if (U_FAILURE(status)) {
-        return nullptr;
-    }
-    LocalPointer<DateTimePatternGenerator> result(
-            new DateTimePatternGenerator(status), status);
-    return U_SUCCESS(status) ? result.orphan() : nullptr;
-}
-
-DateTimePatternGenerator::DateTimePatternGenerator(UErrorCode &status) :
-    skipMatcher(nullptr),
-    fAvailableFormatKeyHash(nullptr),
-    internalErrorCode(U_ZERO_ERROR)
-{
-    fp = new FormatParser();
-    dtMatcher = new DateTimeMatcher();
-    distanceInfo = new DistanceInfo();
-    patternMap = new PatternMap();
-    if (fp == nullptr || dtMatcher == nullptr || distanceInfo == nullptr || patternMap == nullptr) {
-        internalErrorCode = status = U_MEMORY_ALLOCATION_ERROR;
-    }
-}
-
-DateTimePatternGenerator::DateTimePatternGenerator(const Locale& locale, UErrorCode &status) :
-    skipMatcher(nullptr),
-    fAvailableFormatKeyHash(nullptr),
-    internalErrorCode(U_ZERO_ERROR)
-{
-    fp = new FormatParser();
-    dtMatcher = new DateTimeMatcher();
-    distanceInfo = new DistanceInfo();
-    patternMap = new PatternMap();
-    if (fp == nullptr || dtMatcher == nullptr || distanceInfo == nullptr || patternMap == nullptr) {
-        internalErrorCode = status = U_MEMORY_ALLOCATION_ERROR;
-    }
-    else {
-        initData(locale, status);
-    }
-}
-
-DateTimePatternGenerator::DateTimePatternGenerator(const DateTimePatternGenerator& other) :
-    UObject(),
-    skipMatcher(nullptr),
-    fAvailableFormatKeyHash(nullptr),
-    internalErrorCode(U_ZERO_ERROR)
-{
-    fp = new FormatParser();
-    dtMatcher = new DateTimeMatcher();
-    distanceInfo = new DistanceInfo();
-    patternMap = new PatternMap();
-    if (fp == nullptr || dtMatcher == nullptr || distanceInfo == nullptr || patternMap == nullptr) {
-        internalErrorCode = U_MEMORY_ALLOCATION_ERROR;
-    }
-    *this=other;
-}
-
-DateTimePatternGenerator&
-DateTimePatternGenerator::operator=(const DateTimePatternGenerator& other) {
-    // reflexive case
-    if (&other == this) {
-        return *this;
-    }
-    internalErrorCode = other.internalErrorCode;
-    pLocale = other.pLocale;
-    fDefaultHourFormatChar = other.fDefaultHourFormatChar;
-    *fp = *(other.fp);
-    dtMatcher->copyFrom(other.dtMatcher->skeleton);
-    *distanceInfo = *(other.distanceInfo);
-    dateTimeFormat = other.dateTimeFormat;
-    decimal = other.decimal;
-    // NUL-terminate for the C API.
-    dateTimeFormat.getTerminatedBuffer();
-    decimal.getTerminatedBuffer();
-    delete skipMatcher;
-    if ( other.skipMatcher == nullptr ) {
-        skipMatcher = nullptr;
-    }
-    else {
-        skipMatcher = new DateTimeMatcher(*other.skipMatcher);
-        if (skipMatcher == nullptr)
-        {
-            internalErrorCode = U_MEMORY_ALLOCATION_ERROR;
-            return *this;
-        }
-    }
-    for (int32_t i=0; i< UDATPG_FIELD_COUNT; ++i ) {
-        appendItemFormats[i] = other.appendItemFormats[i];
-        appendItemFormats[i].getTerminatedBuffer(); // NUL-terminate for the C API.
-        for (int32_t j=0; j< UDATPG_WIDTH_COUNT; ++j ) {
-            fieldDisplayNames[i][j] = other.fieldDisplayNames[i][j];
-            fieldDisplayNames[i][j].getTerminatedBuffer(); // NUL-terminate for the C API.
-        }
-    }
-    patternMap->copyFrom(*other.patternMap, internalErrorCode);
-    copyHashtable(other.fAvailableFormatKeyHash, internalErrorCode);
-    return *this;
-}
-
-
-UBool
-DateTimePatternGenerator::operator==(const DateTimePatternGenerator& other) const {
-    if (this == &other) {
-        return TRUE;
-    }
-    if ((pLocale==other.pLocale) && (patternMap->equals(*other.patternMap)) &&
-        (dateTimeFormat==other.dateTimeFormat) && (decimal==other.decimal)) {
-        for ( int32_t i=0 ; i<UDATPG_FIELD_COUNT; ++i ) {
-            if (appendItemFormats[i] != other.appendItemFormats[i]) {
-                return FALSE;
-            }
-            for (int32_t j=0; j< UDATPG_WIDTH_COUNT; ++j ) {
-                if (fieldDisplayNames[i][j] != other.fieldDisplayNames[i][j]) {
-                    return FALSE;
-                }
-            }
-        }
-        return TRUE;
-    }
-    else {
-        return FALSE;
-    }
-}
-
-UBool
-DateTimePatternGenerator::operator!=(const DateTimePatternGenerator& other) const {
-    return  !operator==(other);
-}
-
-DateTimePatternGenerator::~DateTimePatternGenerator() {
-    if (fAvailableFormatKeyHash!=nullptr) {
-        delete fAvailableFormatKeyHash;
-    }
-
-    if (fp != nullptr) delete fp;
-    if (dtMatcher != nullptr) delete dtMatcher;
-    if (distanceInfo != nullptr) delete distanceInfo;
-    if (patternMap != nullptr) delete patternMap;
-    if (skipMatcher != nullptr) delete skipMatcher;
-}
-
-namespace {
-
-UInitOnce initOnce = U_INITONCE_INITIALIZER;
-UHashtable *localeToAllowedHourFormatsMap = nullptr;
-
-// Value deleter for hashmap.
-U_CFUNC void U_CALLCONV deleteAllowedHourFormats(void *ptr) {
-    uprv_free(ptr);
-}
-
-// Close hashmap at cleanup.
-U_CFUNC UBool U_CALLCONV allowedHourFormatsCleanup() {
-    uhash_close(localeToAllowedHourFormatsMap);
-    return TRUE;
-}
-
-enum AllowedHourFormat{
-    ALLOWED_HOUR_FORMAT_UNKNOWN = -1,
-    ALLOWED_HOUR_FORMAT_h,
-    ALLOWED_HOUR_FORMAT_H,
-    ALLOWED_HOUR_FORMAT_K,  // Added ICU-20383, used by JP
-    ALLOWED_HOUR_FORMAT_k,  // Added ICU-20383, not currently used
-    ALLOWED_HOUR_FORMAT_hb,
-    ALLOWED_HOUR_FORMAT_hB,
-    ALLOWED_HOUR_FORMAT_Kb, // Added ICU-20383, not currently used
-    ALLOWED_HOUR_FORMAT_KB, // Added ICU-20383, not currently used
-    // ICU-20383 The following are unlikely and not currently used
-    ALLOWED_HOUR_FORMAT_Hb,
-    ALLOWED_HOUR_FORMAT_HB
-};
-
-}  // namespace
-
-void
-DateTimePatternGenerator::initData(const Locale& locale, UErrorCode &status) {
-    //const char *baseLangName = locale.getBaseName(); // unused
-
-    skipMatcher = nullptr;
-    fAvailableFormatKeyHash=nullptr;
-    addCanonicalItems(status);
-    addICUPatterns(locale, status);
-    addCLDRData(locale, status);
-    setDateTimeFromCalendar(locale, status);
-    setDecimalSymbols(locale, status);
-    umtx_initOnce(initOnce, loadAllowedHourFormatsData, status);
-    getAllowedHourFormats(locale, status);
-    // If any of the above methods failed then the object is in an invalid state.
-    internalErrorCode = status;
-} // DateTimePatternGenerator::initData
-
-namespace {
-
-struct AllowedHourFormatsSink : public ResourceSink {
-    // Initialize sub-sinks.
-    AllowedHourFormatsSink() {}
-    virtual ~AllowedHourFormatsSink();
-
-    virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
-                     UErrorCode &errorCode) {
-        ResourceTable timeData = value.getTable(errorCode);
-        if (U_FAILURE(errorCode)) { return; }
-        for (int32_t i = 0; timeData.getKeyAndValue(i, key, value); ++i) {
-            const char *regionOrLocale = key;
-            ResourceTable formatList = value.getTable(errorCode);
-            if (U_FAILURE(errorCode)) { return; }
-            // below we construct a list[] that has an entry for the "preferred" value at [0],
-            // followed by 1 or more entries for the "allowed" values, terminated with an
-            // entry for ALLOWED_HOUR_FORMAT_UNKNOWN (not included in length below)
-            LocalMemory<int32_t> list;
-            int32_t length = 0;
-            int32_t preferredFormat = ALLOWED_HOUR_FORMAT_UNKNOWN;
-            for (int32_t j = 0; formatList.getKeyAndValue(j, key, value); ++j) {
-                if (uprv_strcmp(key, "allowed") == 0) {
-                    if (value.getType() == URES_STRING) {
-                        length = 2; // 1 preferred to add later, 1 allowed to add now
-                        if (list.allocateInsteadAndReset(length + 1) == nullptr) {
-                            errorCode = U_MEMORY_ALLOCATION_ERROR;
-                            return;
-                        }
-                        list[1] = getHourFormatFromUnicodeString(value.getUnicodeString(errorCode));
-                    }
-                    else {
-                        ResourceArray allowedFormats = value.getArray(errorCode);
-                        length = allowedFormats.getSize() + 1; // 1 preferred, getSize allowed
-                        if (list.allocateInsteadAndReset(length + 1) == nullptr) {
-                            errorCode = U_MEMORY_ALLOCATION_ERROR;
-                            return;
-                        }
-                        for (int32_t k = 1; k < length; ++k) {
-                            allowedFormats.getValue(k-1, value);
-                            list[k] = getHourFormatFromUnicodeString(value.getUnicodeString(errorCode));
-                        }
-                    }
-                } else if (uprv_strcmp(key, "preferred") == 0) {
-                    preferredFormat = getHourFormatFromUnicodeString(value.getUnicodeString(errorCode));
-                }
-            }
-            if (length > 1) {
-                list[0] = (preferredFormat!=ALLOWED_HOUR_FORMAT_UNKNOWN)? preferredFormat: list[1];
-            } else {
-                // fallback handling for missing data
-                length = 2; // 1 preferred, 1 allowed
-                if (list.allocateInsteadAndReset(length + 1) == nullptr) {
-                    errorCode = U_MEMORY_ALLOCATION_ERROR;
-                    return;
-                }
-                list[0] = (preferredFormat!=ALLOWED_HOUR_FORMAT_UNKNOWN)? preferredFormat: ALLOWED_HOUR_FORMAT_H;
-                list[1] = list[0];
-            }
-            list[length] = ALLOWED_HOUR_FORMAT_UNKNOWN;
-            // At this point list[] will have at least two non-ALLOWED_HOUR_FORMAT_UNKNOWN entries,
-            // followed by ALLOWED_HOUR_FORMAT_UNKNOWN.
-            uhash_put(localeToAllowedHourFormatsMap, const_cast<char *>(regionOrLocale), list.orphan(), &errorCode);
-            if (U_FAILURE(errorCode)) { return; }
-        }
-    }
-
-    AllowedHourFormat getHourFormatFromUnicodeString(const UnicodeString &s) {
-        if (s.length() == 1) {
-            if (s[0] == LOW_H) { return ALLOWED_HOUR_FORMAT_h; }
-            if (s[0] == CAP_H) { return ALLOWED_HOUR_FORMAT_H; }
-            if (s[0] == CAP_K) { return ALLOWED_HOUR_FORMAT_K; }
-            if (s[0] == LOW_K) { return ALLOWED_HOUR_FORMAT_k; }
-        } else if (s.length() == 2) {
-            if (s[0] == LOW_H && s[1] == LOW_B) { return ALLOWED_HOUR_FORMAT_hb; }
-            if (s[0] == LOW_H && s[1] == CAP_B) { return ALLOWED_HOUR_FORMAT_hB; }
-            if (s[0] == CAP_K && s[1] == LOW_B) { return ALLOWED_HOUR_FORMAT_Kb; }
-            if (s[0] == CAP_K && s[1] == CAP_B) { return ALLOWED_HOUR_FORMAT_KB; }
-            if (s[0] == CAP_H && s[1] == LOW_B) { return ALLOWED_HOUR_FORMAT_Hb; }
-            if (s[0] == CAP_H && s[1] == CAP_B) { return ALLOWED_HOUR_FORMAT_HB; }
-        }
-
-        return ALLOWED_HOUR_FORMAT_UNKNOWN;
-    }
-};
-
-}  // namespace
-
-AllowedHourFormatsSink::~AllowedHourFormatsSink() {}
-
-U_CFUNC void U_CALLCONV DateTimePatternGenerator::loadAllowedHourFormatsData(UErrorCode &status) {
-    if (U_FAILURE(status)) { return; }
-    localeToAllowedHourFormatsMap = uhash_open(
-        uhash_hashChars, uhash_compareChars, nullptr, &status);
-    if (U_FAILURE(status)) { return; }
-
-    uhash_setValueDeleter(localeToAllowedHourFormatsMap, deleteAllowedHourFormats);
-    ucln_i18n_registerCleanup(UCLN_I18N_ALLOWED_HOUR_FORMATS, allowedHourFormatsCleanup);
-
-    LocalUResourceBundlePointer rb(ures_openDirect(nullptr, "supplementalData", &status));
-    if (U_FAILURE(status)) { return; }
-
-    AllowedHourFormatsSink sink;
-    // TODO: Currently in the enumeration each table allocates a new array.
-    // Try to reduce the number of memory allocations. Consider storing a
-    // UVector32 with the concatenation of all of the sub-arrays, put the start index
-    // into the hashmap, store 6 single-value sub-arrays right at the beginning of the
-    // vector (at index enum*2) for easy data sharing, copy sub-arrays into runtime
-    // object. Remember to clean up the vector, too.
-    ures_getAllItemsWithFallback(rb.getAlias(), "timeData", sink, status);
-}
-
-void DateTimePatternGenerator::getAllowedHourFormats(const Locale &locale, UErrorCode &status) {
-    if (U_FAILURE(status)) { return; }
-    Locale maxLocale(locale);
-    maxLocale.addLikelySubtags(status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    const char *country = maxLocale.getCountry();
-    if (*country == '\0') { country = "001"; }
-    const char *language = maxLocale.getLanguage();
-
-    CharString langCountry;
-    langCountry.append(language, static_cast<int32_t>(uprv_strlen(language)), status);
-    langCountry.append('_', status);
-    langCountry.append(country, static_cast<int32_t>(uprv_strlen(country)), status);
-
-    int32_t *allowedFormats;
-    allowedFormats = (int32_t *)uhash_get(localeToAllowedHourFormatsMap, langCountry.data());
-    if (allowedFormats == nullptr) {
-        allowedFormats = (int32_t *)uhash_get(localeToAllowedHourFormatsMap, const_cast<char *>(country));
-    }
-
-    if (allowedFormats != nullptr) {  // Lookup is successful
-        // Here allowedFormats points to a list consisting of key for preferredFormat,
-        // followed by one or more keys for allowedFormats, then followed by ALLOWED_HOUR_FORMAT_UNKNOWN.
-        switch (allowedFormats[0]) {
-            case ALLOWED_HOUR_FORMAT_h: fDefaultHourFormatChar = LOW_H; break;
-            case ALLOWED_HOUR_FORMAT_H: fDefaultHourFormatChar = CAP_H; break;
-            case ALLOWED_HOUR_FORMAT_K: fDefaultHourFormatChar = CAP_K; break;
-            case ALLOWED_HOUR_FORMAT_k: fDefaultHourFormatChar = LOW_K; break;
-            default: fDefaultHourFormatChar = CAP_H; break;
-        }
-        for (int32_t i = 0; i < UPRV_LENGTHOF(fAllowedHourFormats); ++i) {
-            fAllowedHourFormats[i] = allowedFormats[i + 1];
-            if (fAllowedHourFormats[i] == ALLOWED_HOUR_FORMAT_UNKNOWN) {
-                break;
-            }
-        }
-    } else {  // Lookup failed, twice
-        fDefaultHourFormatChar = CAP_H;
-        fAllowedHourFormats[0] = ALLOWED_HOUR_FORMAT_H;
-        fAllowedHourFormats[1] = ALLOWED_HOUR_FORMAT_UNKNOWN;
-    }
-}
-
-UnicodeString
-DateTimePatternGenerator::getSkeleton(const UnicodeString& pattern, UErrorCode&
-/*status*/) {
-    FormatParser fp2;
-    DateTimeMatcher matcher;
-    PtnSkeleton localSkeleton;
-    matcher.set(pattern, &fp2, localSkeleton);
-    return localSkeleton.getSkeleton();
-}
-
-UnicodeString
-DateTimePatternGenerator::staticGetSkeleton(
-        const UnicodeString& pattern, UErrorCode& /*status*/) {
-    FormatParser fp;
-    DateTimeMatcher matcher;
-    PtnSkeleton localSkeleton;
-    matcher.set(pattern, &fp, localSkeleton);
-    return localSkeleton.getSkeleton();
-}
-
-UnicodeString
-DateTimePatternGenerator::getBaseSkeleton(const UnicodeString& pattern, UErrorCode& /*status*/) {
-    FormatParser fp2;
-    DateTimeMatcher matcher;
-    PtnSkeleton localSkeleton;
-    matcher.set(pattern, &fp2, localSkeleton);
-    return localSkeleton.getBaseSkeleton();
-}
-
-UnicodeString
-DateTimePatternGenerator::staticGetBaseSkeleton(
-        const UnicodeString& pattern, UErrorCode& /*status*/) {
-    FormatParser fp;
-    DateTimeMatcher matcher;
-    PtnSkeleton localSkeleton;
-    matcher.set(pattern, &fp, localSkeleton);
-    return localSkeleton.getBaseSkeleton();
-}
-
-void
-DateTimePatternGenerator::addICUPatterns(const Locale& locale, UErrorCode& status) {
-    if (U_FAILURE(status)) { return; }
-    UnicodeString dfPattern;
-    UnicodeString conflictingString;
-    DateFormat* df;
-
-    // Load with ICU patterns
-    for (int32_t i=DateFormat::kFull; i<=DateFormat::kShort; i++) {
-        DateFormat::EStyle style = (DateFormat::EStyle)i;
-        df = DateFormat::createDateInstance(style, locale);
-        SimpleDateFormat* sdf;
-        if (df != nullptr && (sdf = dynamic_cast<SimpleDateFormat*>(df)) != nullptr) {
-            sdf->toPattern(dfPattern);
-            addPattern(dfPattern, FALSE, conflictingString, status);
-        }
-        // TODO Maybe we should return an error when the date format isn't simple.
-        delete df;
-        if (U_FAILURE(status)) { return; }
-
-        df = DateFormat::createTimeInstance(style, locale);
-        if (df != nullptr && (sdf = dynamic_cast<SimpleDateFormat*>(df)) != nullptr) {
-            sdf->toPattern(dfPattern);
-            addPattern(dfPattern, FALSE, conflictingString, status);
-
-            // TODO: C++ and Java are inconsistent (see #12568).
-            // C++ uses MEDIUM, but Java uses SHORT.
-            if ( i==DateFormat::kShort && !dfPattern.isEmpty() ) {
-                consumeShortTimePattern(dfPattern, status);
-            }
-        }
-        // TODO Maybe we should return an error when the date format isn't simple.
-        delete df;
-        if (U_FAILURE(status)) { return; }
-    }
-}
-
-void
-DateTimePatternGenerator::hackTimes(const UnicodeString& hackPattern, UErrorCode& status)  {
-    UnicodeString conflictingString;
-
-    fp->set(hackPattern);
-    UnicodeString mmss;
-    UBool gotMm=FALSE;
-    for (int32_t i=0; i<fp->itemNumber; ++i) {
-        UnicodeString field = fp->items[i];
-        if ( fp->isQuoteLiteral(field) ) {
-            if ( gotMm ) {
-               UnicodeString quoteLiteral;
-               fp->getQuoteLiteral(quoteLiteral, &i);
-               mmss += quoteLiteral;
-            }
-        }
-        else {
-            if (fp->isPatternSeparator(field) && gotMm) {
-                mmss+=field;
-            }
-            else {
-                UChar ch=field.charAt(0);
-                if (ch==LOW_M) {
-                    gotMm=TRUE;
-                    mmss+=field;
-                }
-                else {
-                    if (ch==LOW_S) {
-                        if (!gotMm) {
-                            break;
-                        }
-                        mmss+= field;
-                        addPattern(mmss, FALSE, conflictingString, status);
-                        break;
-                    }
-                    else {
-                        if (gotMm || ch==LOW_Z || ch==CAP_Z || ch==LOW_V || ch==CAP_V) {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-#define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY)
-
-void
-DateTimePatternGenerator::getCalendarTypeToUse(const Locale& locale, CharString& destination, UErrorCode& err) {
-    destination.clear().append(DT_DateTimeGregorianTag, -1, err); // initial default
-    if ( U_SUCCESS(err) ) {
-        UErrorCode localStatus = U_ZERO_ERROR;
-        char localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY];
-        // obtain a locale that always has the calendar key value that should be used
-        ures_getFunctionalEquivalent(
-            localeWithCalendarKey,
-            ULOC_LOCALE_IDENTIFIER_CAPACITY,
-            nullptr,
-            "calendar",
-            "calendar",
-            locale.getName(),
-            nullptr,
-            FALSE,
-            &localStatus);
-        localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY-1] = 0; // ensure null termination
-        // now get the calendar key value from that locale
-        char calendarType[ULOC_KEYWORDS_CAPACITY];
-        int32_t calendarTypeLen = uloc_getKeywordValue(
-            localeWithCalendarKey,
-            "calendar",
-            calendarType,
-            ULOC_KEYWORDS_CAPACITY,
-            &localStatus);
-        // If the input locale was invalid, don't fail with missing resource error, instead
-        // continue with default of Gregorian.
-        if (U_FAILURE(localStatus) && localStatus != U_MISSING_RESOURCE_ERROR) {
-            err = localStatus;
-            return;
-        }
-        if (calendarTypeLen < ULOC_KEYWORDS_CAPACITY) {
-            destination.clear().append(calendarType, -1, err);
-            if (U_FAILURE(err)) { return; }
-        }
-    }
-}
-
-void
-DateTimePatternGenerator::consumeShortTimePattern(const UnicodeString& shortTimePattern,
-        UErrorCode& status) {
-    if (U_FAILURE(status)) { return; }
-    // ICU-20383 No longer set fDefaultHourFormatChar to the hour format character from
-    // this pattern; instead it is set from localeToAllowedHourFormatsMap which now
-    // includes entries for both preferred and allowed formats.
-
-    // HACK for hh:ss
-    hackTimes(shortTimePattern, status);
-}
-
-struct DateTimePatternGenerator::AppendItemFormatsSink : public ResourceSink {
-
-    // Destination for data, modified via setters.
-    DateTimePatternGenerator& dtpg;
-
-    AppendItemFormatsSink(DateTimePatternGenerator& _dtpg) : dtpg(_dtpg) {}
-    virtual ~AppendItemFormatsSink();
-
-    virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
-            UErrorCode &errorCode) {
-        ResourceTable itemsTable = value.getTable(errorCode);
-        if (U_FAILURE(errorCode)) { return; }
-        for (int32_t i = 0; itemsTable.getKeyAndValue(i, key, value); ++i) {
-            UDateTimePatternField field = dtpg.getAppendFormatNumber(key);
-            if (field == UDATPG_FIELD_COUNT) { continue; }
-            const UnicodeString& valueStr = value.getUnicodeString(errorCode);
-            if (dtpg.getAppendItemFormat(field).isEmpty() && !valueStr.isEmpty()) {
-                dtpg.setAppendItemFormat(field, valueStr);
-            }
-        }
-    }
-
-    void fillInMissing() {
-        UnicodeString defaultItemFormat(TRUE, UDATPG_ItemFormat, UPRV_LENGTHOF(UDATPG_ItemFormat)-1);  // Read-only alias.
-        for (int32_t i = 0; i < UDATPG_FIELD_COUNT; i++) {
-            UDateTimePatternField field = (UDateTimePatternField)i;
-            if (dtpg.getAppendItemFormat(field).isEmpty()) {
-                dtpg.setAppendItemFormat(field, defaultItemFormat);
-            }
-        }
-    }
-};
-
-struct DateTimePatternGenerator::AppendItemNamesSink : public ResourceSink {
-
-    // Destination for data, modified via setters.
-    DateTimePatternGenerator& dtpg;
-
-    AppendItemNamesSink(DateTimePatternGenerator& _dtpg) : dtpg(_dtpg) {}
-    virtual ~AppendItemNamesSink();
-
-    virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
-            UErrorCode &errorCode) {
-        ResourceTable itemsTable = value.getTable(errorCode);
-        if (U_FAILURE(errorCode)) { return; }
-        for (int32_t i = 0; itemsTable.getKeyAndValue(i, key, value); ++i) {
-            UDateTimePGDisplayWidth width;
-            UDateTimePatternField field = dtpg.getFieldAndWidthIndices(key, &width);
-            if (field == UDATPG_FIELD_COUNT) { continue; }
-            ResourceTable detailsTable = value.getTable(errorCode);
-            if (U_FAILURE(errorCode)) { return; }
-            for (int32_t j = 0; detailsTable.getKeyAndValue(j, key, value); ++j) {
-                if (uprv_strcmp(key, "dn") != 0) { continue; }
-                const UnicodeString& valueStr = value.getUnicodeString(errorCode);
-                if (dtpg.getFieldDisplayName(field,width).isEmpty() && !valueStr.isEmpty()) {
-                    dtpg.setFieldDisplayName(field,width,valueStr);
-                }
-                break;
-            }
-        }
-    }
-
-    void fillInMissing() {
-        for (int32_t i = 0; i < UDATPG_FIELD_COUNT; i++) {
-            UnicodeString& valueStr = dtpg.getMutableFieldDisplayName((UDateTimePatternField)i, UDATPG_WIDE);
-            if (valueStr.isEmpty()) {
-                valueStr = CAP_F;
-                U_ASSERT(i < 20);
-                if (i < 10) {
-                    // F0, F1, ..., F9
-                    valueStr += (UChar)(i+0x30);
-                } else {
-                    // F10, F11, ...
-                    valueStr += (UChar)0x31;
-                    valueStr += (UChar)(i-10 + 0x30);
-                }
-                // NUL-terminate for the C API.
-                valueStr.getTerminatedBuffer();
-            }
-            for (int32_t j = 1; j < UDATPG_WIDTH_COUNT; j++) {
-                UnicodeString& valueStr2 = dtpg.getMutableFieldDisplayName((UDateTimePatternField)i, (UDateTimePGDisplayWidth)j);
-                if (valueStr2.isEmpty()) {
-                    valueStr2 = dtpg.getFieldDisplayName((UDateTimePatternField)i, (UDateTimePGDisplayWidth)(j-1));
-                }
-            }
-        }
-    }
-};
-
-struct DateTimePatternGenerator::AvailableFormatsSink : public ResourceSink {
-
-    // Destination for data, modified via setters.
-    DateTimePatternGenerator& dtpg;
-
-    // Temporary variable, required for calling addPatternWithSkeleton.
-    UnicodeString conflictingPattern;
-
-    AvailableFormatsSink(DateTimePatternGenerator& _dtpg) : dtpg(_dtpg) {}
-    virtual ~AvailableFormatsSink();
-
-    virtual void put(const char *key, ResourceValue &value, UBool isRoot,
-            UErrorCode &errorCode) {
-        ResourceTable itemsTable = value.getTable(errorCode);
-        if (U_FAILURE(errorCode)) { return; }
-        for (int32_t i = 0; itemsTable.getKeyAndValue(i, key, value); ++i) {
-            const UnicodeString formatKey(key, -1, US_INV);
-            if (!dtpg.isAvailableFormatSet(formatKey) ) {
-                dtpg.setAvailableFormat(formatKey, errorCode);
-                // Add pattern with its associated skeleton. Override any duplicate
-                // derived from std patterns, but not a previous availableFormats entry:
-                const UnicodeString& formatValue = value.getUnicodeString(errorCode);
-                conflictingPattern.remove();
-                dtpg.addPatternWithSkeleton(formatValue, &formatKey, !isRoot, conflictingPattern, errorCode);
-            }
-        }
-    }
-};
-
-// Virtual destructors must be defined out of line.
-DateTimePatternGenerator::AppendItemFormatsSink::~AppendItemFormatsSink() {}
-DateTimePatternGenerator::AppendItemNamesSink::~AppendItemNamesSink() {}
-DateTimePatternGenerator::AvailableFormatsSink::~AvailableFormatsSink() {}
-
-void
-DateTimePatternGenerator::addCLDRData(const Locale& locale, UErrorCode& errorCode) {
-    if (U_FAILURE(errorCode)) { return; }
-    UnicodeString rbPattern, value, field;
-    CharString path;
-
-    LocalUResourceBundlePointer rb(ures_open(nullptr, locale.getName(), &errorCode));
-    if (U_FAILURE(errorCode)) { return; }
-
-    CharString calendarTypeToUse; // to be filled in with the type to use, if all goes well
-    getCalendarTypeToUse(locale, calendarTypeToUse, errorCode);
-    if (U_FAILURE(errorCode)) { return; }
-
-    // Local err to ignore resource not found exceptions
-    UErrorCode err = U_ZERO_ERROR;
-
-    // Load append item formats.
-    AppendItemFormatsSink appendItemFormatsSink(*this);
-    path.clear()
-        .append(DT_DateTimeCalendarTag, errorCode)
-        .append('/', errorCode)
-        .append(calendarTypeToUse, errorCode)
-        .append('/', errorCode)
-        .append(DT_DateTimeAppendItemsTag, errorCode); // i.e., calendar/xxx/appendItems
-    if (U_FAILURE(errorCode)) { return; }
-    ures_getAllItemsWithFallback(rb.getAlias(), path.data(), appendItemFormatsSink, err);
-    appendItemFormatsSink.fillInMissing();
-
-    // Load CLDR item names.
-    err = U_ZERO_ERROR;
-    AppendItemNamesSink appendItemNamesSink(*this);
-    ures_getAllItemsWithFallback(rb.getAlias(), DT_DateTimeFieldsTag, appendItemNamesSink, err);
-    appendItemNamesSink.fillInMissing();
-
-    // Load the available formats from CLDR.
-    err = U_ZERO_ERROR;
-    initHashtable(errorCode);
-    if (U_FAILURE(errorCode)) { return; }
-    AvailableFormatsSink availableFormatsSink(*this);
-    path.clear()
-        .append(DT_DateTimeCalendarTag, errorCode)
-        .append('/', errorCode)
-        .append(calendarTypeToUse, errorCode)
-        .append('/', errorCode)
-        .append(DT_DateTimeAvailableFormatsTag, errorCode); // i.e., calendar/xxx/availableFormats
-    if (U_FAILURE(errorCode)) { return; }
-    ures_getAllItemsWithFallback(rb.getAlias(), path.data(), availableFormatsSink, err);
-}
-
-void
-DateTimePatternGenerator::initHashtable(UErrorCode& err) {
-    if (U_FAILURE(err)) { return; }
-    if (fAvailableFormatKeyHash!=nullptr) {
-        return;
-    }
-    LocalPointer<Hashtable> hash(new Hashtable(FALSE, err), err);
-    if (U_SUCCESS(err)) {
-        fAvailableFormatKeyHash = hash.orphan();
-    }
-}
-
-void
-DateTimePatternGenerator::setAppendItemFormat(UDateTimePatternField field, const UnicodeString& value) {
-    appendItemFormats[field] = value;
-    // NUL-terminate for the C API.
-    appendItemFormats[field].getTerminatedBuffer();
-}
-
-const UnicodeString&
-DateTimePatternGenerator::getAppendItemFormat(UDateTimePatternField field) const {
-    return appendItemFormats[field];
-}
-
-void
-DateTimePatternGenerator::setAppendItemName(UDateTimePatternField field, const UnicodeString& value) {
-    setFieldDisplayName(field, UDATPG_WIDTH_APPENDITEM, value);
-}
-
-const UnicodeString&
-DateTimePatternGenerator::getAppendItemName(UDateTimePatternField field) const {
-    return fieldDisplayNames[field][UDATPG_WIDTH_APPENDITEM];
-}
-
-void
-DateTimePatternGenerator::setFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width, const UnicodeString& value) {
-    fieldDisplayNames[field][width] = value;
-    // NUL-terminate for the C API.
-    fieldDisplayNames[field][width].getTerminatedBuffer();
-}
-
-UnicodeString
-DateTimePatternGenerator::getFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width) const {
-    return fieldDisplayNames[field][width];
-}
-
-UnicodeString&
-DateTimePatternGenerator::getMutableFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width) {
-    return fieldDisplayNames[field][width];
-}
-
-void
-DateTimePatternGenerator::getAppendName(UDateTimePatternField field, UnicodeString& value) {
-    value = SINGLE_QUOTE;
-    value += fieldDisplayNames[field][UDATPG_WIDTH_APPENDITEM];
-    value += SINGLE_QUOTE;
-}
-
-UnicodeString
-DateTimePatternGenerator::getBestPattern(const UnicodeString& patternForm, UErrorCode& status) {
-    return getBestPattern(patternForm, UDATPG_MATCH_NO_OPTIONS, status);
-}
-
-UnicodeString
-DateTimePatternGenerator::getBestPattern(const UnicodeString& patternForm, UDateTimePatternMatchOptions options, UErrorCode& status) {
-    if (U_FAILURE(status)) {
-        return UnicodeString();
-    }
-    if (U_FAILURE(internalErrorCode)) {
-        status = internalErrorCode;
-        return UnicodeString();
-    }
-    const UnicodeString *bestPattern = nullptr;
-    UnicodeString dtFormat;
-    UnicodeString resultPattern;
-    int32_t flags = kDTPGNoFlags;
-
-    int32_t dateMask=(1<<UDATPG_DAYPERIOD_FIELD) - 1;
-    int32_t timeMask=(1<<UDATPG_FIELD_COUNT) - 1 - dateMask;
-
-    // Replace hour metacharacters 'j', 'C' and 'J', set flags as necessary
-    UnicodeString patternFormMapped = mapSkeletonMetacharacters(patternForm, &flags, status);
-    if (U_FAILURE(status)) {
-        return UnicodeString();
-    }
-
-    resultPattern.remove();
-    dtMatcher->set(patternFormMapped, fp);
-    const PtnSkeleton* specifiedSkeleton = nullptr;
-    bestPattern=getBestRaw(*dtMatcher, -1, distanceInfo, status, &specifiedSkeleton);
-    if (U_FAILURE(status)) {
-        return UnicodeString();
-    }
-
-    if ( distanceInfo->missingFieldMask==0 && distanceInfo->extraFieldMask==0 ) {
-        resultPattern = adjustFieldTypes(*bestPattern, specifiedSkeleton, flags, options);
-
-        return resultPattern;
-    }
-    int32_t neededFields = dtMatcher->getFieldMask();
-    UnicodeString datePattern=getBestAppending(neededFields & dateMask, flags, status, options);
-    UnicodeString timePattern=getBestAppending(neededFields & timeMask, flags, status, options);
-    if (U_FAILURE(status)) {
-        return UnicodeString();
-    }
-    if (datePattern.length()==0) {
-        if (timePattern.length()==0) {
-            resultPattern.remove();
-        }
-        else {
-            return timePattern;
-        }
-    }
-    if (timePattern.length()==0) {
-        return datePattern;
-    }
-    resultPattern.remove();
-    status = U_ZERO_ERROR;
-    dtFormat=getDateTimeFormat();
-    SimpleFormatter(dtFormat, 2, 2, status).format(timePattern, datePattern, resultPattern, status);
-    return resultPattern;
-}
-
-/*
- * Map a skeleton that may have metacharacters jJC to one without, by replacing
- * the metacharacters with locale-appropriate fields of h/H/k/K and of a/b/B
- * (depends on fDefaultHourFormatChar and fAllowedHourFormats being set, which in
- * turn depends on initData having been run). This method also updates the flags
- * as necessary. Returns the updated skeleton.
- */
-UnicodeString
-DateTimePatternGenerator::mapSkeletonMetacharacters(const UnicodeString& patternForm, int32_t* flags, UErrorCode& status) {
-    UnicodeString patternFormMapped;
-    patternFormMapped.remove();
-    UBool inQuoted = FALSE;
-    int32_t patPos, patLen = patternForm.length();
-    for (patPos = 0; patPos < patLen; patPos++) {
-        UChar patChr = patternForm.charAt(patPos);
-        if (patChr == SINGLE_QUOTE) {
-            inQuoted = !inQuoted;
-        } else if (!inQuoted) {
-            // Handle special mappings for 'j' and 'C' in which fields lengths
-            // 1,3,5 => hour field length 1
-            // 2,4,6 => hour field length 2
-            // 1,2 => abbreviated dayPeriod (field length 1..3)
-            // 3,4 => long dayPeriod (field length 4)
-            // 5,6 => narrow dayPeriod (field length 5)
-            if (patChr == LOW_J || patChr == CAP_C) {
-                int32_t extraLen = 0; // 1 less than total field length
-                while (patPos+1 < patLen && patternForm.charAt(patPos+1)==patChr) {
-                    extraLen++;
-                    patPos++;
-                }
-                int32_t hourLen = 1 + (extraLen & 1);
-                int32_t dayPeriodLen = (extraLen < 2)? 1: 3 + (extraLen >> 1);
-                UChar hourChar = LOW_H;
-                UChar dayPeriodChar = LOW_A;
-                if (patChr == LOW_J) {
-                    hourChar = fDefaultHourFormatChar;
-                } else {
-                    AllowedHourFormat bestAllowed;
-                    if (fAllowedHourFormats[0] != ALLOWED_HOUR_FORMAT_UNKNOWN) {
-                        bestAllowed = (AllowedHourFormat)fAllowedHourFormats[0];
-                    } else {
-                        status = U_INVALID_FORMAT_ERROR;
-                        return UnicodeString();
-                    }
-                    if (bestAllowed == ALLOWED_HOUR_FORMAT_H || bestAllowed == ALLOWED_HOUR_FORMAT_HB || bestAllowed == ALLOWED_HOUR_FORMAT_Hb) {
-                        hourChar = CAP_H;
-                    } else if (bestAllowed == ALLOWED_HOUR_FORMAT_K || bestAllowed == ALLOWED_HOUR_FORMAT_KB || bestAllowed == ALLOWED_HOUR_FORMAT_Kb) {
-                        hourChar = CAP_K;
-                    } else if (bestAllowed == ALLOWED_HOUR_FORMAT_k) {
-                        hourChar = LOW_K;
-                    }
-                    // in #13183 just add b/B to skeleton, no longer need to set special flags
-                    if (bestAllowed == ALLOWED_HOUR_FORMAT_HB || bestAllowed == ALLOWED_HOUR_FORMAT_hB || bestAllowed == ALLOWED_HOUR_FORMAT_KB) {
-                        dayPeriodChar = CAP_B;
-                    } else if (bestAllowed == ALLOWED_HOUR_FORMAT_Hb || bestAllowed == ALLOWED_HOUR_FORMAT_hb || bestAllowed == ALLOWED_HOUR_FORMAT_Kb) {
-                        dayPeriodChar = LOW_B;
-                    }
-                }
-                if (hourChar==CAP_H || hourChar==LOW_K) {
-                    dayPeriodLen = 0;
-                }
-                while (dayPeriodLen-- > 0) {
-                    patternFormMapped.append(dayPeriodChar);
-                }
-                while (hourLen-- > 0) {
-                    patternFormMapped.append(hourChar);
-                }
-            } else if (patChr == CAP_J) {
-                // Get pattern for skeleton with H, then replace H or k
-                // with fDefaultHourFormatChar (if different)
-                patternFormMapped.append(CAP_H);
-                *flags |= kDTPGSkeletonUsesCapJ;
-            } else {
-                patternFormMapped.append(patChr);
-            }
-        }
-    }
-    return patternFormMapped;
-}
-
-UnicodeString
-DateTimePatternGenerator::replaceFieldTypes(const UnicodeString& pattern,
-                                            const UnicodeString& skeleton,
-                                            UErrorCode& status) {
-    return replaceFieldTypes(pattern, skeleton, UDATPG_MATCH_NO_OPTIONS, status);
-}
-
-UnicodeString
-DateTimePatternGenerator::replaceFieldTypes(const UnicodeString& pattern,
-                                            const UnicodeString& skeleton,
-                                            UDateTimePatternMatchOptions options,
-                                            UErrorCode& status) {
-    if (U_FAILURE(status)) {
-        return UnicodeString();
-    }
-    if (U_FAILURE(internalErrorCode)) {
-        status = internalErrorCode;
-        return UnicodeString();
-    }
-    dtMatcher->set(skeleton, fp);
-    UnicodeString result = adjustFieldTypes(pattern, nullptr, kDTPGNoFlags, options);
-    return result;
-}
-
-void
-DateTimePatternGenerator::setDecimal(const UnicodeString& newDecimal) {
-    this->decimal = newDecimal;
-    // NUL-terminate for the C API.
-    this->decimal.getTerminatedBuffer();
-}
-
-const UnicodeString&
-DateTimePatternGenerator::getDecimal() const {
-    return decimal;
-}
-
-void
-DateTimePatternGenerator::addCanonicalItems(UErrorCode& status) {
-    if (U_FAILURE(status)) { return; }
-    UnicodeString  conflictingPattern;
-
-    for (int32_t i=0; i<UDATPG_FIELD_COUNT; i++) {
-        if (Canonical_Items[i] > 0) {
-            addPattern(UnicodeString(Canonical_Items[i]), FALSE, conflictingPattern, status);
-        }
-        if (U_FAILURE(status)) { return; }
-    }
-}
-
-void
-DateTimePatternGenerator::setDateTimeFormat(const UnicodeString& dtFormat) {
-    dateTimeFormat = dtFormat;
-    // NUL-terminate for the C API.
-    dateTimeFormat.getTerminatedBuffer();
-}
-
-const UnicodeString&
-DateTimePatternGenerator::getDateTimeFormat() const {
-    return dateTimeFormat;
-}
-
-void
-DateTimePatternGenerator::setDateTimeFromCalendar(const Locale& locale, UErrorCode& status) {
-    if (U_FAILURE(status)) { return; }
-
-    const UChar *resStr;
-    int32_t resStrLen = 0;
-
-    LocalPointer<Calendar> fCalendar(Calendar::createInstance(locale, status), status);
-    if (U_FAILURE(status)) { return; }
-
-    LocalUResourceBundlePointer calData(ures_open(nullptr, locale.getBaseName(), &status));
-    if (U_FAILURE(status)) { return; }
-    ures_getByKey(calData.getAlias(), DT_DateTimeCalendarTag, calData.getAlias(), &status);
-    if (U_FAILURE(status)) { return; }
-
-    LocalUResourceBundlePointer dateTimePatterns;
-    if (fCalendar->getType() != nullptr && *fCalendar->getType() != '\0'
-            && uprv_strcmp(fCalendar->getType(), DT_DateTimeGregorianTag) != 0) {
-        dateTimePatterns.adoptInstead(ures_getByKeyWithFallback(calData.getAlias(), fCalendar->getType(),
-                                                                nullptr, &status));
-        ures_getByKeyWithFallback(dateTimePatterns.getAlias(), DT_DateTimePatternsTag,
-                                  dateTimePatterns.getAlias(), &status);
-    }
-
-    if (dateTimePatterns.isNull() || status == U_MISSING_RESOURCE_ERROR) {
-        status = U_ZERO_ERROR;
-        dateTimePatterns.adoptInstead(ures_getByKeyWithFallback(calData.getAlias(), DT_DateTimeGregorianTag,
-                                                                dateTimePatterns.orphan(), &status));
-        ures_getByKeyWithFallback(dateTimePatterns.getAlias(), DT_DateTimePatternsTag,
-                                  dateTimePatterns.getAlias(), &status);
-    }
-    if (U_FAILURE(status)) { return; }
-
-    if (ures_getSize(dateTimePatterns.getAlias()) <= DateFormat::kDateTime)
-    {
-        status = U_INVALID_FORMAT_ERROR;
-        return;
-    }
-    resStr = ures_getStringByIndex(dateTimePatterns.getAlias(), (int32_t)DateFormat::kDateTime, &resStrLen, &status);
-    setDateTimeFormat(UnicodeString(TRUE, resStr, resStrLen));
-}
-
-void
-DateTimePatternGenerator::setDecimalSymbols(const Locale& locale, UErrorCode& status) {
-    DecimalFormatSymbols dfs = DecimalFormatSymbols(locale, status);
-    if(U_SUCCESS(status)) {
-        decimal = dfs.getSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
-        // NUL-terminate for the C API.
-        decimal.getTerminatedBuffer();
-    }
-}
-
-UDateTimePatternConflict
-DateTimePatternGenerator::addPattern(
-    const UnicodeString& pattern,
-    UBool override,
-    UnicodeString &conflictingPattern,
-    UErrorCode& status)
-{
-    if (U_FAILURE(internalErrorCode)) {
-        status = internalErrorCode;
-        return UDATPG_NO_CONFLICT;
-    }
-
-    return addPatternWithSkeleton(pattern, nullptr, override, conflictingPattern, status);
-}
-
-// For DateTimePatternGenerator::addPatternWithSkeleton -
-// If skeletonToUse is specified, then an availableFormats entry is being added. In this case:
-// 1. We pass that skeleton to matcher.set instead of having it derive a skeleton from the pattern.
-// 2. If the new entry's skeleton or basePattern does match an existing entry but that entry also had a skeleton specified
-// (i.e. it was also from availableFormats), then the new entry does not override it regardless of the value of the override
-// parameter. This prevents later availableFormats entries from a parent locale overriding earlier ones from the actual
-// specified locale. However, availableFormats entries *should* override entries with matching skeleton whose skeleton was
-// derived (i.e. entries derived from the standard date/time patters for the specified locale).
-// 3. When adding the pattern (patternMap->add), we set a new boolean to indicate that the added entry had a
-// specified skeleton (which sets a new field in the PtnElem in the PatternMap).
-UDateTimePatternConflict
-DateTimePatternGenerator::addPatternWithSkeleton(
-    const UnicodeString& pattern,
-    const UnicodeString* skeletonToUse,
-    UBool override,
-    UnicodeString& conflictingPattern,
-    UErrorCode& status)
-{
-    if (U_FAILURE(internalErrorCode)) {
-        status = internalErrorCode;
-        return UDATPG_NO_CONFLICT;
-    }
-
-    UnicodeString basePattern;
-    PtnSkeleton   skeleton;
-    UDateTimePatternConflict conflictingStatus = UDATPG_NO_CONFLICT;
-
-    DateTimeMatcher matcher;
-    if ( skeletonToUse == nullptr ) {
-        matcher.set(pattern, fp, skeleton);
-        matcher.getBasePattern(basePattern);
-    } else {
-        matcher.set(*skeletonToUse, fp, skeleton); // no longer trims skeleton fields to max len 3, per #7930
-        matcher.getBasePattern(basePattern); // or perhaps instead: basePattern = *skeletonToUse;
-    }
-    // We only care about base conflicts - and replacing the pattern associated with a base - if:
-    // 1. the conflicting previous base pattern did *not* have an explicit skeleton; in that case the previous
-    // base + pattern combination was derived from either (a) a canonical item, (b) a standard format, or
-    // (c) a pattern specified programmatically with a previous call to addPattern (which would only happen
-    // if we are getting here from a subsequent call to addPattern).
-    // 2. a skeleton is specified for the current pattern, but override=false; in that case we are checking
-    // availableFormats items from root, which should not override any previous entry with the same base.
-    UBool entryHadSpecifiedSkeleton;
-    const UnicodeString *duplicatePattern = patternMap->getPatternFromBasePattern(basePattern, entryHadSpecifiedSkeleton);
-    if (duplicatePattern != nullptr && (!entryHadSpecifiedSkeleton || (skeletonToUse != nullptr && !override))) {
-        conflictingStatus = UDATPG_BASE_CONFLICT;
-        conflictingPattern = *duplicatePattern;
-        if (!override) {
-            return conflictingStatus;
-        }
-    }
-    // The only time we get here with override=true and skeletonToUse!=null is when adding availableFormats
-    // items from CLDR data. In that case, we don't want an item from a parent locale to replace an item with
-    // same skeleton from the specified locale, so skip the current item if skeletonWasSpecified is true for
-    // the previously-specified conflicting item.
-    const PtnSkeleton* entrySpecifiedSkeleton = nullptr;
-    duplicatePattern = patternMap->getPatternFromSkeleton(skeleton, &entrySpecifiedSkeleton);
-    if (duplicatePattern != nullptr ) {
-        conflictingStatus = UDATPG_CONFLICT;
-        conflictingPattern = *duplicatePattern;
-        if (!override || (skeletonToUse != nullptr && entrySpecifiedSkeleton != nullptr)) {
-            return conflictingStatus;
-        }
-    }
-    patternMap->add(basePattern, skeleton, pattern, skeletonToUse != nullptr, status);
-    if(U_FAILURE(status)) {
-        return conflictingStatus;
-    }
-
-    return UDATPG_NO_CONFLICT;
-}
-
-
-UDateTimePatternField
-DateTimePatternGenerator::getAppendFormatNumber(const char* field) const {
-    for (int32_t i=0; i<UDATPG_FIELD_COUNT; ++i ) {
-        if (uprv_strcmp(CLDR_FIELD_APPEND[i], field)==0) {
-            return (UDateTimePatternField)i;
-        }
-    }
-    return UDATPG_FIELD_COUNT;
-}
-
-UDateTimePatternField
-DateTimePatternGenerator::getFieldAndWidthIndices(const char* key, UDateTimePGDisplayWidth* widthP) const {
-    char cldrFieldKey[UDATPG_FIELD_KEY_MAX + 1];
-    uprv_strncpy(cldrFieldKey, key, UDATPG_FIELD_KEY_MAX);
-    cldrFieldKey[UDATPG_FIELD_KEY_MAX]=0; // ensure termination
-    *widthP = UDATPG_WIDE;
-    char* hyphenPtr = uprv_strchr(cldrFieldKey, '-');
-    if (hyphenPtr) {
-        for (int32_t i=UDATPG_WIDTH_COUNT-1; i>0; --i) {
-            if (uprv_strcmp(CLDR_FIELD_WIDTH[i], hyphenPtr)==0) {
-                *widthP=(UDateTimePGDisplayWidth)i;
-                break;
-            }
-        }
-        *hyphenPtr = 0; // now delete width portion of key
-    }
-    for (int32_t i=0; i<UDATPG_FIELD_COUNT; ++i ) {
-        if (uprv_strcmp(CLDR_FIELD_NAME[i],cldrFieldKey)==0) {
-            return (UDateTimePatternField)i;
-        }
-    }
-    return UDATPG_FIELD_COUNT;
-}
-
-const UnicodeString*
-DateTimePatternGenerator::getBestRaw(DateTimeMatcher& source,
-                                     int32_t includeMask,
-                                     DistanceInfo* missingFields,
-                                     UErrorCode &status,
-                                     const PtnSkeleton** specifiedSkeletonPtr) {
-    int32_t bestDistance = 0x7fffffff;
-    DistanceInfo tempInfo;
-    const UnicodeString *bestPattern=nullptr;
-    const PtnSkeleton* specifiedSkeleton=nullptr;
-
-    PatternMapIterator it(status);
-    if (U_FAILURE(status)) { return nullptr; }
-
-    for (it.set(*patternMap); it.hasNext(); ) {
-        DateTimeMatcher trial = it.next();
-        if (trial.equals(skipMatcher)) {
-            continue;
-        }
-        int32_t distance=source.getDistance(trial, includeMask, tempInfo);
-        if (distance<bestDistance) {
-            bestDistance=distance;
-            bestPattern=patternMap->getPatternFromSkeleton(*trial.getSkeletonPtr(), &specifiedSkeleton);
-            missingFields->setTo(tempInfo);
-            if (distance==0) {
-                break;
-            }
-        }
-    }
-
-    // If the best raw match had a specified skeleton and that skeleton was requested by the caller,
-    // then return it too. This generally happens when the caller needs to pass that skeleton
-    // through to adjustFieldTypes so the latter can do a better job.
-    if (bestPattern && specifiedSkeletonPtr) {
-        *specifiedSkeletonPtr = specifiedSkeleton;
-    }
-    return bestPattern;
-}
-
-UnicodeString
-DateTimePatternGenerator::adjustFieldTypes(const UnicodeString& pattern,
-                                           const PtnSkeleton* specifiedSkeleton,
-                                           int32_t flags,
-                                           UDateTimePatternMatchOptions options) {
-    UnicodeString newPattern;
-    fp->set(pattern);
-    for (int32_t i=0; i < fp->itemNumber; i++) {
-        UnicodeString field = fp->items[i];
-        if ( fp->isQuoteLiteral(field) ) {
-
-            UnicodeString quoteLiteral;
-            fp->getQuoteLiteral(quoteLiteral, &i);
-            newPattern += quoteLiteral;
-        }
-        else {
-            if (fp->isPatternSeparator(field)) {
-                newPattern+=field;
-                continue;
-            }
-            int32_t canonicalIndex = fp->getCanonicalIndex(field);
-            if (canonicalIndex < 0) {
-                newPattern+=field;
-                continue;  // don't adjust
-            }
-            const dtTypeElem *row = &dtTypes[canonicalIndex];
-            int32_t typeValue = row->field;
-
-            // handle day periods - with #13183, no longer need special handling here, integrated with normal types
-
-            if ((flags & kDTPGFixFractionalSeconds) != 0 && typeValue == UDATPG_SECOND_FIELD) {
-                field += decimal;
-                dtMatcher->skeleton.original.appendFieldTo(UDATPG_FRACTIONAL_SECOND_FIELD, field);
-            } else if (dtMatcher->skeleton.type[typeValue]!=0) {
-                    // Here:
-                    // - "reqField" is the field from the originally requested skeleton, with length
-                    // "reqFieldLen".
-                    // - "field" is the field from the found pattern.
-                    //
-                    // The adjusted field should consist of characters from the originally requested
-                    // skeleton, except in the case of UDATPG_HOUR_FIELD or UDATPG_MONTH_FIELD or
-                    // UDATPG_WEEKDAY_FIELD or UDATPG_YEAR_FIELD, in which case it should consist
-                    // of characters from the  found pattern.
-                    //
-                    // The length of the adjusted field (adjFieldLen) should match that in the originally
-                    // requested skeleton, except that in the following cases the length of the adjusted field
-                    // should match that in the found pattern (i.e. the length of this pattern field should
-                    // not be adjusted):
-                    // 1. typeValue is UDATPG_HOUR_FIELD/MINUTE/SECOND and the corresponding bit in options is
-                    //    not set (ticket #7180). Note, we may want to implement a similar change for other
-                    //    numeric fields (MM, dd, etc.) so the default behavior is to get locale preference for
-                    //    field length, but options bits can be used to override this.
-                    // 2. There is a specified skeleton for the found pattern and one of the following is true:
-                    //    a) The length of the field in the skeleton (skelFieldLen) is equal to reqFieldLen.
-                    //    b) The pattern field is numeric and the skeleton field is not, or vice versa.
-
-                    UChar reqFieldChar = dtMatcher->skeleton.original.getFieldChar(typeValue);
-                    int32_t reqFieldLen = dtMatcher->skeleton.original.getFieldLength(typeValue);
-                    if (reqFieldChar == CAP_E && reqFieldLen < 3)
-                        reqFieldLen = 3; // 1-3 for E are equivalent to 3 for c,e
-                    int32_t adjFieldLen = reqFieldLen;
-                    if ( (typeValue==UDATPG_HOUR_FIELD && (options & UDATPG_MATCH_HOUR_FIELD_LENGTH)==0) ||
-                         (typeValue==UDATPG_MINUTE_FIELD && (options & UDATPG_MATCH_MINUTE_FIELD_LENGTH)==0) ||
-                         (typeValue==UDATPG_SECOND_FIELD && (options & UDATPG_MATCH_SECOND_FIELD_LENGTH)==0) ) {
-                         adjFieldLen = field.length();
-                    } else if (specifiedSkeleton) {
-                        int32_t skelFieldLen = specifiedSkeleton->original.getFieldLength(typeValue);
-                        UBool patFieldIsNumeric = (row->type > 0);
-                        UBool skelFieldIsNumeric = (specifiedSkeleton->type[typeValue] > 0);
-                        if (skelFieldLen == reqFieldLen || (patFieldIsNumeric && !skelFieldIsNumeric) || (skelFieldIsNumeric && !patFieldIsNumeric)) {
-                            // don't adjust the field length in the found pattern
-                            adjFieldLen = field.length();
-                        }
-                    }
-                    UChar c = (typeValue!= UDATPG_HOUR_FIELD
-                            && typeValue!= UDATPG_MONTH_FIELD
-                            && typeValue!= UDATPG_WEEKDAY_FIELD
-                            && (typeValue!= UDATPG_YEAR_FIELD || reqFieldChar==CAP_Y))
-                            ? reqFieldChar
-                            : field.charAt(0);
-                    if (typeValue == UDATPG_HOUR_FIELD && (flags & kDTPGSkeletonUsesCapJ) != 0) {
-                        c = fDefaultHourFormatChar;
-                    }
-                    field.remove();
-                    for (int32_t j=adjFieldLen; j>0; --j) {
-                        field += c;
-                    }
-            }
-            newPattern+=field;
-        }
-    }
-    return newPattern;
-}
-
-UnicodeString
-DateTimePatternGenerator::getBestAppending(int32_t missingFields, int32_t flags, UErrorCode &status, UDateTimePatternMatchOptions options) {
-    if (U_FAILURE(status)) {
-        return UnicodeString();
-    }
-    UnicodeString  resultPattern, tempPattern;
-    const UnicodeString* tempPatternPtr;
-    int32_t lastMissingFieldMask=0;
-    if (missingFields!=0) {
-        resultPattern=UnicodeString();
-        const PtnSkeleton* specifiedSkeleton=nullptr;
-        tempPatternPtr = getBestRaw(*dtMatcher, missingFields, distanceInfo, status, &specifiedSkeleton);
-        if (U_FAILURE(status)) {
-            return UnicodeString();
-        }
-        tempPattern = *tempPatternPtr;
-        resultPattern = adjustFieldTypes(tempPattern, specifiedSkeleton, flags, options);
-        if ( distanceInfo->missingFieldMask==0 ) {
-            return resultPattern;
-        }
-        while (distanceInfo->missingFieldMask!=0) { // precondition: EVERY single field must work!
-            if ( lastMissingFieldMask == distanceInfo->missingFieldMask ) {
-                break;  // cannot find the proper missing field
-            }
-            if (((distanceInfo->missingFieldMask & UDATPG_SECOND_AND_FRACTIONAL_MASK)==UDATPG_FRACTIONAL_MASK) &&
-                ((missingFields & UDATPG_SECOND_AND_FRACTIONAL_MASK) == UDATPG_SECOND_AND_FRACTIONAL_MASK)) {
-                resultPattern = adjustFieldTypes(resultPattern, specifiedSkeleton, flags | kDTPGFixFractionalSeconds, options);
-                distanceInfo->missingFieldMask &= ~UDATPG_FRACTIONAL_MASK;
-                continue;
-            }
-            int32_t startingMask = distanceInfo->missingFieldMask;
-            tempPatternPtr = getBestRaw(*dtMatcher, distanceInfo->missingFieldMask, distanceInfo, status, &specifiedSkeleton);
-            if (U_FAILURE(status)) {
-                return UnicodeString();
-            }
-            tempPattern = *tempPatternPtr;
-            tempPattern = adjustFieldTypes(tempPattern, specifiedSkeleton, flags, options);
-            int32_t foundMask=startingMask& ~distanceInfo->missingFieldMask;
-            int32_t topField=getTopBitNumber(foundMask);
-
-            if (appendItemFormats[topField].length() != 0) {
-                UnicodeString appendName;
-                getAppendName((UDateTimePatternField)topField, appendName);
-                const UnicodeString *values[3] = {
-                    &resultPattern,
-                    &tempPattern,
-                    &appendName
-                };
-                SimpleFormatter(appendItemFormats[topField], 2, 3, status).
-                    formatAndReplace(values, 3, resultPattern, nullptr, 0, status);
-            }
-            lastMissingFieldMask = distanceInfo->missingFieldMask;
-        }
-    }
-    return resultPattern;
-}
-
-int32_t
-DateTimePatternGenerator::getTopBitNumber(int32_t foundMask) const {
-    if ( foundMask==0 ) {
-        return 0;
-    }
-    int32_t i=0;
-    while (foundMask!=0) {
-        foundMask >>=1;
-        ++i;
-    }
-    if (i-1 >UDATPG_ZONE_FIELD) {
-        return UDATPG_ZONE_FIELD;
-    }
-    else
-        return i-1;
-}
-
-void
-DateTimePatternGenerator::setAvailableFormat(const UnicodeString &key, UErrorCode& err)
-{
-    fAvailableFormatKeyHash->puti(key, 1, err);
-}
-
-UBool
-DateTimePatternGenerator::isAvailableFormatSet(const UnicodeString &key) const {
-    return (UBool)(fAvailableFormatKeyHash->geti(key) == 1);
-}
-
-void
-DateTimePatternGenerator::copyHashtable(Hashtable *other, UErrorCode &status) {
-    if (other == nullptr || U_FAILURE(status)) {
-        return;
-    }
-    if (fAvailableFormatKeyHash != nullptr) {
-        delete fAvailableFormatKeyHash;
-        fAvailableFormatKeyHash = nullptr;
-    }
-    initHashtable(status);
-    if(U_FAILURE(status)){
-        return;
-    }
-    int32_t pos = UHASH_FIRST;
-    const UHashElement* elem = nullptr;
-    // walk through the hash table and create a deep clone
-    while((elem = other->nextElement(pos))!= nullptr){
-        const UHashTok otherKeyTok = elem->key;
-        UnicodeString* otherKey = (UnicodeString*)otherKeyTok.pointer;
-        fAvailableFormatKeyHash->puti(*otherKey, 1, status);
-        if(U_FAILURE(status)){
-            return;
-        }
-    }
-}
-
-StringEnumeration*
-DateTimePatternGenerator::getSkeletons(UErrorCode& status) const {
-    if (U_FAILURE(status)) {
-        return nullptr;
-    }
-    if (U_FAILURE(internalErrorCode)) {
-        status = internalErrorCode;
-        return nullptr;
-    }
-    LocalPointer<StringEnumeration> skeletonEnumerator(
-        new DTSkeletonEnumeration(*patternMap, DT_SKELETON, status), status);
-
-    return U_SUCCESS(status) ? skeletonEnumerator.orphan() : nullptr;
-}
-
-const UnicodeString&
-DateTimePatternGenerator::getPatternForSkeleton(const UnicodeString& skeleton) const {
-    PtnElem *curElem;
-
-    if (skeleton.length() ==0) {
-        return emptyString;
-    }
-    curElem = patternMap->getHeader(skeleton.charAt(0));
-    while ( curElem != nullptr ) {
-        if ( curElem->skeleton->getSkeleton()==skeleton ) {
-            return curElem->pattern;
-        }
-        curElem = curElem->next.getAlias();
-    }
-    return emptyString;
-}
-
-StringEnumeration*
-DateTimePatternGenerator::getBaseSkeletons(UErrorCode& status) const {
-    if (U_FAILURE(status)) {
-        return nullptr;
-    }
-    if (U_FAILURE(internalErrorCode)) {
-        status = internalErrorCode;
-        return nullptr;
-    }
-    LocalPointer<StringEnumeration> baseSkeletonEnumerator(
-        new DTSkeletonEnumeration(*patternMap, DT_BASESKELETON, status), status);
-
-    return U_SUCCESS(status) ? baseSkeletonEnumerator.orphan() : nullptr;
-}
-
-StringEnumeration*
-DateTimePatternGenerator::getRedundants(UErrorCode& status) {
-    if (U_FAILURE(status)) { return nullptr; }
-    if (U_FAILURE(internalErrorCode)) {
-        status = internalErrorCode;
-        return nullptr;
-    }
-    LocalPointer<StringEnumeration> output(new DTRedundantEnumeration(), status);
-    if (U_FAILURE(status)) { return nullptr; }
-    const UnicodeString *pattern;
-    PatternMapIterator it(status);
-    if (U_FAILURE(status)) { return nullptr; }
-
-    for (it.set(*patternMap); it.hasNext(); ) {
-        DateTimeMatcher current = it.next();
-        pattern = patternMap->getPatternFromSkeleton(*(it.getSkeleton()));
-        if ( isCanonicalItem(*pattern) ) {
-            continue;
-        }
-        if ( skipMatcher == nullptr ) {
-            skipMatcher = new DateTimeMatcher(current);
-            if (skipMatcher == nullptr) {
-                status = U_MEMORY_ALLOCATION_ERROR;
-                return nullptr;
-            }
-        }
-        else {
-            *skipMatcher = current;
-        }
-        UnicodeString trial = getBestPattern(current.getPattern(), status);
-        if (U_FAILURE(status)) { return nullptr; }
-        if (trial == *pattern) {
-            ((DTRedundantEnumeration *)output.getAlias())->add(*pattern, status);
-            if (U_FAILURE(status)) { return nullptr; }
-        }
-        if (current.equals(skipMatcher)) {
-            continue;
-        }
-    }
-    return output.orphan();
-}
-
-UBool
-DateTimePatternGenerator::isCanonicalItem(const UnicodeString& item) const {
-    if ( item.length() != 1 ) {
-        return FALSE;
-    }
-    for (int32_t i=0; i<UDATPG_FIELD_COUNT; ++i) {
-        if (item.charAt(0)==Canonical_Items[i]) {
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
-
-DateTimePatternGenerator*
-DateTimePatternGenerator::clone() const {
-    return new DateTimePatternGenerator(*this);
-}
-
-PatternMap::PatternMap() {
-   for (int32_t i=0; i < MAX_PATTERN_ENTRIES; ++i ) {
-       boot[i] = nullptr;
-   }
-   isDupAllowed = TRUE;
-}
-
-void
-PatternMap::copyFrom(const PatternMap& other, UErrorCode& status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    this->isDupAllowed = other.isDupAllowed;
-    for (int32_t bootIndex = 0; bootIndex < MAX_PATTERN_ENTRIES; ++bootIndex) {
-        PtnElem *curElem, *otherElem, *prevElem=nullptr;
-        otherElem = other.boot[bootIndex];
-        while (otherElem != nullptr) {
-            LocalPointer<PtnElem> newElem(new PtnElem(otherElem->basePattern, otherElem->pattern), status);
-            if (U_FAILURE(status)) {
-                return; // out of memory
-            }
-            newElem->skeleton.adoptInsteadAndCheckErrorCode(new PtnSkeleton(*(otherElem->skeleton)), status);
-            if (U_FAILURE(status)) {
-                return; // out of memory
-            }
-            newElem->skeletonWasSpecified = otherElem->skeletonWasSpecified;
-
-            // Release ownership from the LocalPointer of the PtnElem object.
-            // The PtnElem will now be owned by either the boot (for the first entry in the linked-list)
-            // or owned by the previous PtnElem object in the linked-list.
-            curElem = newElem.orphan();
-
-            if (this->boot[bootIndex] == nullptr) {
-                this->boot[bootIndex] = curElem;
-            } else {
-                if (prevElem != nullptr) {
-                    prevElem->next.adoptInstead(curElem);
-                } else {
-                    UPRV_UNREACHABLE;
-                }
-            }
-            prevElem = curElem;
-            otherElem = otherElem->next.getAlias();
-        }
-
-    }
-}
-
-PtnElem*
-PatternMap::getHeader(UChar baseChar) const {
-    PtnElem* curElem;
-
-    if ( (baseChar >= CAP_A) && (baseChar <= CAP_Z) ) {
-         curElem = boot[baseChar-CAP_A];
-    }
-    else {
-        if ( (baseChar >=LOW_A) && (baseChar <= LOW_Z) ) {
-            curElem = boot[26+baseChar-LOW_A];
-        }
-        else {
-            return nullptr;
-        }
-    }
-    return curElem;
-}
-
-PatternMap::~PatternMap() {
-   for (int32_t i=0; i < MAX_PATTERN_ENTRIES; ++i ) {
-       if (boot[i] != nullptr ) {
-           delete boot[i];
-           boot[i] = nullptr;
-       }
-   }
-}  // PatternMap destructor
-
-void
-PatternMap::add(const UnicodeString& basePattern,
-                const PtnSkeleton& skeleton,
-                const UnicodeString& value,// mapped pattern value
-                UBool skeletonWasSpecified,
-                UErrorCode &status) {
-    UChar baseChar = basePattern.charAt(0);
-    PtnElem *curElem, *baseElem;
-    status = U_ZERO_ERROR;
-
-    // the baseChar must be A-Z or a-z
-    if ((baseChar >= CAP_A) && (baseChar <= CAP_Z)) {
-        baseElem = boot[baseChar-CAP_A];
-    }
-    else {
-        if ((baseChar >=LOW_A) && (baseChar <= LOW_Z)) {
-            baseElem = boot[26+baseChar-LOW_A];
-         }
-         else {
-             status = U_ILLEGAL_CHARACTER;
-             return;
-         }
-    }
-
-    if (baseElem == nullptr) {
-        LocalPointer<PtnElem> newElem(new PtnElem(basePattern, value), status);
-        if (U_FAILURE(status)) {
-            return; // out of memory
-        }
-        newElem->skeleton.adoptInsteadAndCheckErrorCode(new PtnSkeleton(skeleton), status);
-        if (U_FAILURE(status)) {
-            return; // out of memory
-        }
-        newElem->skeletonWasSpecified = skeletonWasSpecified;
-        if (baseChar >= LOW_A) {
-            boot[26 + (baseChar - LOW_A)] = newElem.orphan(); // the boot array now owns the PtnElem.
-        }
-        else {
-            boot[baseChar - CAP_A] = newElem.orphan(); // the boot array now owns the PtnElem.
-        }
-    }
-    if ( baseElem != nullptr ) {
-        curElem = getDuplicateElem(basePattern, skeleton, baseElem);
-
-        if (curElem == nullptr) {
-            // add new element to the list.
-            curElem = baseElem;
-            while( curElem -> next != nullptr )
-            {
-                curElem = curElem->next.getAlias();
-            }
-
-            LocalPointer<PtnElem> newElem(new PtnElem(basePattern, value), status);
-            if (U_FAILURE(status)) {
-                return; // out of memory
-            }
-            newElem->skeleton.adoptInsteadAndCheckErrorCode(new PtnSkeleton(skeleton), status);
-            if (U_FAILURE(status)) {
-                return; // out of memory
-            }
-            newElem->skeletonWasSpecified = skeletonWasSpecified;
-            curElem->next.adoptInstead(newElem.orphan());
-            curElem = curElem->next.getAlias();
-        }
-        else {
-            // Pattern exists in the list already.
-            if ( !isDupAllowed ) {
-                return;
-            }
-            // Overwrite the value.
-            curElem->pattern = value;
-            // It was a bug that we were not doing the following previously,
-            // though that bug hid other problems by making things partly work.
-            curElem->skeletonWasSpecified = skeletonWasSpecified;
-        }
-    }
-}  // PatternMap::add
-
-// Find the pattern from the given basePattern string.
-const UnicodeString *
-PatternMap::getPatternFromBasePattern(const UnicodeString& basePattern, UBool& skeletonWasSpecified) const { // key to search for
-   PtnElem *curElem;
-
-   if ((curElem=getHeader(basePattern.charAt(0)))==nullptr) {
-       return nullptr;  // no match
-   }
-
-   do  {
-       if ( basePattern.compare(curElem->basePattern)==0 ) {
-          skeletonWasSpecified = curElem->skeletonWasSpecified;
-          return &(curElem->pattern);
-       }
-       curElem = curElem->next.getAlias();
-   } while (curElem != nullptr);
-
-   return nullptr;
-}  // PatternMap::getFromBasePattern
-
-
-// Find the pattern from the given skeleton.
-// At least when this is called from getBestRaw & addPattern (in which case specifiedSkeletonPtr is non-NULL),
-// the comparison should be based on skeleton.original (which is unique and tied to the distance measurement in bestRaw)
-// and not skeleton.baseOriginal (which is not unique); otherwise we may pick a different skeleton than the one with the
-// optimum distance value in getBestRaw. When this is called from public getRedundants (specifiedSkeletonPtr is NULL),
-// for now it will continue to compare based on baseOriginal so as not to change the behavior unnecessarily.
-const UnicodeString *
-PatternMap::getPatternFromSkeleton(const PtnSkeleton& skeleton, const PtnSkeleton** specifiedSkeletonPtr) const { // key to search for
-   PtnElem *curElem;
-
-   if (specifiedSkeletonPtr) {
-       *specifiedSkeletonPtr = nullptr;
-   }
-
-   // find boot entry
-   UChar baseChar = skeleton.getFirstChar();
-   if ((curElem=getHeader(baseChar))==nullptr) {
-       return nullptr;  // no match
-   }
-
-   do  {
-       UBool equal;
-       if (specifiedSkeletonPtr != nullptr) { // called from DateTimePatternGenerator::getBestRaw or addPattern, use original
-           equal = curElem->skeleton->original == skeleton.original;
-       } else { // called from DateTimePatternGenerator::getRedundants, use baseOriginal
-           equal = curElem->skeleton->baseOriginal == skeleton.baseOriginal;
-       }
-       if (equal) {
-           if (specifiedSkeletonPtr && curElem->skeletonWasSpecified) {
-               *specifiedSkeletonPtr = curElem->skeleton.getAlias();
-           }
-           return &(curElem->pattern);
-       }
-       curElem = curElem->next.getAlias();
-   } while (curElem != nullptr);
-
-   return nullptr;
-}
-
-UBool
-PatternMap::equals(const PatternMap& other) const {
-    if ( this==&other ) {
-        return TRUE;
-    }
-    for (int32_t bootIndex = 0; bootIndex < MAX_PATTERN_ENTRIES; ++bootIndex) {
-        if (boot[bootIndex] == other.boot[bootIndex]) {
-            continue;
-        }
-        if ((boot[bootIndex] == nullptr) || (other.boot[bootIndex] == nullptr)) {
-            return FALSE;
-        }
-        PtnElem *otherElem = other.boot[bootIndex];
-        PtnElem *myElem = boot[bootIndex];
-        while ((otherElem != nullptr) || (myElem != nullptr)) {
-            if ( myElem == otherElem ) {
-                break;
-            }
-            if ((otherElem == nullptr) || (myElem == nullptr)) {
-                return FALSE;
-            }
-            if ( (myElem->basePattern != otherElem->basePattern) ||
-                 (myElem->pattern != otherElem->pattern) ) {
-                return FALSE;
-            }
-            if ((myElem->skeleton.getAlias() != otherElem->skeleton.getAlias()) &&
-                !myElem->skeleton->equals(*(otherElem->skeleton))) {
-                return FALSE;
-            }
-            myElem = myElem->next.getAlias();
-            otherElem = otherElem->next.getAlias();
-        }
-    }
-    return TRUE;
-}
-
-// find any key existing in the mapping table already.
-// return TRUE if there is an existing key, otherwise return FALSE.
-PtnElem*
-PatternMap::getDuplicateElem(
-            const UnicodeString &basePattern,
-            const PtnSkeleton &skeleton,
-            PtnElem *baseElem) {
-   PtnElem *curElem;
-
-   if ( baseElem == nullptr ) {
-         return nullptr;
-   }
-   else {
-         curElem = baseElem;
-   }
-   do {
-     if ( basePattern.compare(curElem->basePattern)==0 ) {
-         UBool isEqual = TRUE;
-         for (int32_t i = 0; i < UDATPG_FIELD_COUNT; ++i) {
-            if (curElem->skeleton->type[i] != skeleton.type[i] ) {
-                isEqual = FALSE;
-                break;
-            }
-        }
-        if (isEqual) {
-            return curElem;
-        }
-     }
-     curElem = curElem->next.getAlias();
-   } while( curElem != nullptr );
-
-   // end of the list
-   return nullptr;
-
-}  // PatternMap::getDuplicateElem
-
-DateTimeMatcher::DateTimeMatcher(void) {
-}
-
-DateTimeMatcher::~DateTimeMatcher() {}
-
-DateTimeMatcher::DateTimeMatcher(const DateTimeMatcher& other) {
-    copyFrom(other.skeleton);
-}
-
-
-void
-DateTimeMatcher::set(const UnicodeString& pattern, FormatParser* fp) {
-    PtnSkeleton localSkeleton;
-    return set(pattern, fp, localSkeleton);
-}
-
-void
-DateTimeMatcher::set(const UnicodeString& pattern, FormatParser* fp, PtnSkeleton& skeletonResult) {
-    int32_t i;
-    for (i=0; i<UDATPG_FIELD_COUNT; ++i) {
-        skeletonResult.type[i] = NONE;
-    }
-    skeletonResult.original.clear();
-    skeletonResult.baseOriginal.clear();
-    skeletonResult.addedDefaultDayPeriod = FALSE;
-
-    fp->set(pattern);
-    for (i=0; i < fp->itemNumber; i++) {
-        const UnicodeString& value = fp->items[i];
-        // don't skip 'a' anymore, dayPeriod handled specially below
-
-        if ( fp->isQuoteLiteral(value) ) {
-            UnicodeString quoteLiteral;
-            fp->getQuoteLiteral(quoteLiteral, &i);
-            continue;
-        }
-        int32_t canonicalIndex = fp->getCanonicalIndex(value);
-        if (canonicalIndex < 0) {
-            continue;
-        }
-        const dtTypeElem *row = &dtTypes[canonicalIndex];
-        int32_t field = row->field;
-        skeletonResult.original.populate(field, value);
-        UChar repeatChar = row->patternChar;
-        int32_t repeatCount = row->minLen;
-        skeletonResult.baseOriginal.populate(field, repeatChar, repeatCount);
-        int16_t subField = row->type;
-        if (row->type > 0) {
-            U_ASSERT(value.length() < INT16_MAX);
-            subField += static_cast<int16_t>(value.length());
-        }
-        skeletonResult.type[field] = subField;
-    }
-    // #13183, handle special behavior for day period characters (a, b, B)
-    if (!skeletonResult.original.isFieldEmpty(UDATPG_HOUR_FIELD)) {
-        if (skeletonResult.original.getFieldChar(UDATPG_HOUR_FIELD)==LOW_H || skeletonResult.original.getFieldChar(UDATPG_HOUR_FIELD)==CAP_K) {
-            // We have a skeleton with 12-hour-cycle format
-            if (skeletonResult.original.isFieldEmpty(UDATPG_DAYPERIOD_FIELD)) {
-                // But we do not have a day period in the skeleton; add the default DAYPERIOD (currently "a")
-                for (i = 0; dtTypes[i].patternChar != 0; i++) {
-                    if ( dtTypes[i].field == UDATPG_DAYPERIOD_FIELD ) {
-                        // first entry for UDATPG_DAYPERIOD_FIELD
-                        skeletonResult.original.populate(UDATPG_DAYPERIOD_FIELD, dtTypes[i].patternChar, dtTypes[i].minLen);
-                        skeletonResult.baseOriginal.populate(UDATPG_DAYPERIOD_FIELD, dtTypes[i].patternChar, dtTypes[i].minLen);
-                        skeletonResult.type[UDATPG_DAYPERIOD_FIELD] = dtTypes[i].type;
-                        skeletonResult.addedDefaultDayPeriod = TRUE;
-                        break;
-                    }
-                }
-            }
-        } else {
-            // Skeleton has 24-hour-cycle hour format and has dayPeriod, delete dayPeriod (i.e. ignore it)
-            skeletonResult.original.clearField(UDATPG_DAYPERIOD_FIELD);
-            skeletonResult.baseOriginal.clearField(UDATPG_DAYPERIOD_FIELD);
-            skeletonResult.type[UDATPG_DAYPERIOD_FIELD] = NONE;
-        }
-    }
-    copyFrom(skeletonResult);
-}
-
-void
-DateTimeMatcher::getBasePattern(UnicodeString &result ) {
-    result.remove(); // Reset the result first.
-    skeleton.baseOriginal.appendTo(result);
-}
-
-UnicodeString
-DateTimeMatcher::getPattern() {
-    UnicodeString result;
-    return skeleton.original.appendTo(result);
-}
-
-int32_t
-DateTimeMatcher::getDistance(const DateTimeMatcher& other, int32_t includeMask, DistanceInfo& distanceInfo) const {
-    int32_t result = 0;
-    distanceInfo.clear();
-    for (int32_t i=0; i<UDATPG_FIELD_COUNT; ++i ) {
-        int32_t myType = (includeMask&(1<<i))==0 ? 0 : skeleton.type[i];
-        int32_t otherType = other.skeleton.type[i];
-        if (myType==otherType) {
-            continue;
-        }
-        if (myType==0) {// and other is not
-            result += EXTRA_FIELD;
-            distanceInfo.addExtra(i);
-        }
-        else {
-            if (otherType==0) {
-                result += MISSING_FIELD;
-                distanceInfo.addMissing(i);
-            }
-            else {
-                result += abs(myType - otherType);
-            }
-        }
-
-    }
-    return result;
-}
-
-void
-DateTimeMatcher::copyFrom(const PtnSkeleton& newSkeleton) {
-    skeleton.copyFrom(newSkeleton);
-}
-
-void
-DateTimeMatcher::copyFrom() {
-    // same as clear
-    skeleton.clear();
-}
-
-UBool
-DateTimeMatcher::equals(const DateTimeMatcher* other) const {
-    if (other==nullptr) { return FALSE; }
-    return skeleton.original == other->skeleton.original;
-}
-
-int32_t
-DateTimeMatcher::getFieldMask() const {
-    int32_t result = 0;
-
-    for (int32_t i=0; i<UDATPG_FIELD_COUNT; ++i) {
-        if (skeleton.type[i]!=0) {
-            result |= (1<<i);
-        }
-    }
-    return result;
-}
-
-PtnSkeleton*
-DateTimeMatcher::getSkeletonPtr() {
-    return &skeleton;
-}
-
-FormatParser::FormatParser () {
-    status = START;
-    itemNumber = 0;
-}
-
-
-FormatParser::~FormatParser () {
-}
-
-
-// Find the next token with the starting position and length
-// Note: the startPos may
-FormatParser::TokenStatus
-FormatParser::setTokens(const UnicodeString& pattern, int32_t startPos, int32_t *len) {
-    int32_t curLoc = startPos;
-    if ( curLoc >= pattern.length()) {
-        return DONE;
-    }
-    // check the current char is between A-Z or a-z
-    do {
-        UChar c=pattern.charAt(curLoc);
-        if ( (c>=CAP_A && c<=CAP_Z) || (c>=LOW_A && c<=LOW_Z) ) {
-           curLoc++;
-        }
-        else {
-               startPos = curLoc;
-               *len=1;
-               return ADD_TOKEN;
-        }
-
-        if ( pattern.charAt(curLoc)!= pattern.charAt(startPos) ) {
-            break;  // not the same token
-        }
-    } while(curLoc <= pattern.length());
-    *len = curLoc-startPos;
-    return ADD_TOKEN;
-}
-
-void
-FormatParser::set(const UnicodeString& pattern) {
-    int32_t startPos = 0;
-    TokenStatus result = START;
-    int32_t len = 0;
-    itemNumber = 0;
-
-    do {
-        result = setTokens( pattern, startPos, &len );
-        if ( result == ADD_TOKEN )
-        {
-            items[itemNumber++] = UnicodeString(pattern, startPos, len );
-            startPos += len;
-        }
-        else {
-            break;
-        }
-    } while (result==ADD_TOKEN && itemNumber < MAX_DT_TOKEN);
-}
-
-int32_t
-FormatParser::getCanonicalIndex(const UnicodeString& s, UBool strict) {
-    int32_t len = s.length();
-    if (len == 0) {
-        return -1;
-    }
-    UChar ch = s.charAt(0);
-
-    // Verify that all are the same character.
-    for (int32_t l = 1; l < len; l++) {
-        if (ch != s.charAt(l)) {
-            return -1;
-        }
-    }
-    int32_t i = 0;
-    int32_t bestRow = -1;
-    while (dtTypes[i].patternChar != 0x0000) {
-        if ( dtTypes[i].patternChar != ch ) {
-            ++i;
-            continue;
-        }
-        bestRow = i;
-        if (dtTypes[i].patternChar != dtTypes[i+1].patternChar) {
-            return i;
-        }
-        if (dtTypes[i+1].minLen <= len) {
-            ++i;
-            continue;
-        }
-        return i;
-    }
-    return strict ? -1 : bestRow;
-}
-
-UBool
-FormatParser::isQuoteLiteral(const UnicodeString& s) {
-    return (UBool)(s.charAt(0) == SINGLE_QUOTE);
-}
-
-// This function assumes the current itemIndex points to the quote literal.
-// Please call isQuoteLiteral prior to this function.
-void
-FormatParser::getQuoteLiteral(UnicodeString& quote, int32_t *itemIndex) {
-    int32_t i = *itemIndex;
-
-    quote.remove();
-    if (items[i].charAt(0)==SINGLE_QUOTE) {
-        quote += items[i];
-        ++i;
-    }
-    while ( i < itemNumber ) {
-        if ( items[i].charAt(0)==SINGLE_QUOTE ) {
-            if ( (i+1<itemNumber) && (items[i+1].charAt(0)==SINGLE_QUOTE)) {
-                // two single quotes e.g. 'o''clock'
-                quote += items[i++];
-                quote += items[i++];
-                continue;
-            }
-            else {
-                quote += items[i];
-                break;
-            }
-        }
-        else {
-            quote += items[i];
-        }
-        ++i;
-    }
-    *itemIndex=i;
-}
-
-UBool
-FormatParser::isPatternSeparator(const UnicodeString& field) const {
-    for (int32_t i=0; i<field.length(); ++i ) {
-        UChar c= field.charAt(i);
-        if ( (c==SINGLE_QUOTE) || (c==BACKSLASH) || (c==SPACE) || (c==COLON) ||
-             (c==QUOTATION_MARK) || (c==COMMA) || (c==HYPHEN) ||(items[i].charAt(0)==DOT) ) {
-            continue;
-        }
-        else {
-            return FALSE;
-        }
-    }
-    return TRUE;
-}
-
-DistanceInfo::~DistanceInfo() {}
-
-void
-DistanceInfo::setTo(const DistanceInfo& other) {
-    missingFieldMask = other.missingFieldMask;
-    extraFieldMask= other.extraFieldMask;
-}
-
-PatternMapIterator::PatternMapIterator(UErrorCode& status) :
-    bootIndex(0), nodePtr(nullptr), matcher(nullptr), patternMap(nullptr)
-{
-    if (U_FAILURE(status)) { return; }
-    matcher.adoptInsteadAndCheckErrorCode(new DateTimeMatcher(), status);
-}
-
-PatternMapIterator::~PatternMapIterator() {
-}
-
-void
-PatternMapIterator::set(PatternMap& newPatternMap) {
-    this->patternMap=&newPatternMap;
-}
-
-PtnSkeleton*
-PatternMapIterator::getSkeleton() const {
-    if ( nodePtr == nullptr ) {
-        return nullptr;
-    }
-    else {
-        return nodePtr->skeleton.getAlias();
-    }
-}
-
-UBool
-PatternMapIterator::hasNext() const {
-    int32_t headIndex = bootIndex;
-    PtnElem *curPtr = nodePtr;
-
-    if (patternMap==nullptr) {
-        return FALSE;
-    }
-    while ( headIndex < MAX_PATTERN_ENTRIES ) {
-        if ( curPtr != nullptr ) {
-            if ( curPtr->next != nullptr ) {
-                return TRUE;
-            }
-            else {
-                headIndex++;
-                curPtr=nullptr;
-                continue;
-            }
-        }
-        else {
-            if ( patternMap->boot[headIndex] != nullptr ) {
-                return TRUE;
-            }
-            else {
-                headIndex++;
-                continue;
-            }
-        }
-    }
-    return FALSE;
-}
-
-DateTimeMatcher&
-PatternMapIterator::next() {
-    while ( bootIndex < MAX_PATTERN_ENTRIES ) {
-        if ( nodePtr != nullptr ) {
-            if ( nodePtr->next != nullptr ) {
-                nodePtr = nodePtr->next.getAlias();
-                break;
-            }
-            else {
-                bootIndex++;
-                nodePtr=nullptr;
-                continue;
-            }
-        }
-        else {
-            if ( patternMap->boot[bootIndex] != nullptr ) {
-                nodePtr = patternMap->boot[bootIndex];
-                break;
-            }
-            else {
-                bootIndex++;
-                continue;
-            }
-        }
-    }
-    if (nodePtr!=nullptr) {
-        matcher->copyFrom(*nodePtr->skeleton);
-    }
-    else {
-        matcher->copyFrom();
-    }
-    return *matcher;
-}
-
-
-SkeletonFields::SkeletonFields() {
-    // Set initial values to zero
-    clear();
-}
-
-void SkeletonFields::clear() {
-    uprv_memset(chars, 0, sizeof(chars));
-    uprv_memset(lengths, 0, sizeof(lengths));
-}
-
-void SkeletonFields::copyFrom(const SkeletonFields& other) {
-    uprv_memcpy(chars, other.chars, sizeof(chars));
-    uprv_memcpy(lengths, other.lengths, sizeof(lengths));
-}
-
-void SkeletonFields::clearField(int32_t field) {
-    chars[field] = 0;
-    lengths[field] = 0;
-}
-
-UChar SkeletonFields::getFieldChar(int32_t field) const {
-    return chars[field];
-}
-
-int32_t SkeletonFields::getFieldLength(int32_t field) const {
-    return lengths[field];
-}
-
-void SkeletonFields::populate(int32_t field, const UnicodeString& value) {
-    populate(field, value.charAt(0), value.length());
-}
-
-void SkeletonFields::populate(int32_t field, UChar ch, int32_t length) {
-    chars[field] = (int8_t) ch;
-    lengths[field] = (int8_t) length;
-}
-
-UBool SkeletonFields::isFieldEmpty(int32_t field) const {
-    return lengths[field] == 0;
-}
-
-UnicodeString& SkeletonFields::appendTo(UnicodeString& string) const {
-    for (int32_t i = 0; i < UDATPG_FIELD_COUNT; ++i) {
-        appendFieldTo(i, string);
-    }
-    return string;
-}
-
-UnicodeString& SkeletonFields::appendFieldTo(int32_t field, UnicodeString& string) const {
-    UChar ch(chars[field]);
-    int32_t length = (int32_t) lengths[field];
-
-    for (int32_t i=0; i<length; i++) {
-        string += ch;
-    }
-    return string;
-}
-
-UChar SkeletonFields::getFirstChar() const {
-    for (int32_t i = 0; i < UDATPG_FIELD_COUNT; ++i) {
-        if (lengths[i] != 0) {
-            return chars[i];
-        }
-    }
-    return '\0';
-}
-
-
-PtnSkeleton::PtnSkeleton() {
-}
-
-PtnSkeleton::PtnSkeleton(const PtnSkeleton& other) {
-    copyFrom(other);
-}
-
-void PtnSkeleton::copyFrom(const PtnSkeleton& other) {
-    uprv_memcpy(type, other.type, sizeof(type));
-    original.copyFrom(other.original);
-    baseOriginal.copyFrom(other.baseOriginal);
-}
-
-void PtnSkeleton::clear() {
-    uprv_memset(type, 0, sizeof(type));
-    original.clear();
-    baseOriginal.clear();
-}
-
-UBool
-PtnSkeleton::equals(const PtnSkeleton& other) const  {
-    return (original == other.original)
-        && (baseOriginal == other.baseOriginal)
-        && (uprv_memcmp(type, other.type, sizeof(type)) == 0);
-}
-
-UnicodeString
-PtnSkeleton::getSkeleton() const {
-    UnicodeString result;
-    result = original.appendTo(result);
-    int32_t pos;
-    if (addedDefaultDayPeriod && (pos = result.indexOf(LOW_A)) >= 0) {
-        // for backward compatibility: if DateTimeMatcher.set added a single 'a' that
-        // was not in the provided skeleton, remove it here before returning skeleton.
-        result.remove(pos, 1);
-    }
-    return result;
-}
-
-UnicodeString
-PtnSkeleton::getBaseSkeleton() const {
-    UnicodeString result;
-    result = baseOriginal.appendTo(result);
-    int32_t pos;
-    if (addedDefaultDayPeriod && (pos = result.indexOf(LOW_A)) >= 0) {
-        // for backward compatibility: if DateTimeMatcher.set added a single 'a' that
-        // was not in the provided skeleton, remove it here before returning skeleton.
-        result.remove(pos, 1);
-    }
-    return result;
-}
-
-UChar
-PtnSkeleton::getFirstChar() const {
-    return baseOriginal.getFirstChar();
-}
-
-PtnSkeleton::~PtnSkeleton() {
-}
-
-PtnElem::PtnElem(const UnicodeString &basePat, const UnicodeString &pat) :
-    basePattern(basePat), skeleton(nullptr), pattern(pat), next(nullptr)
-{
-}
-
-PtnElem::~PtnElem() {
-}
-
-DTSkeletonEnumeration::DTSkeletonEnumeration(PatternMap& patternMap, dtStrEnum type, UErrorCode& status) : fSkeletons(nullptr) {
-    PtnElem  *curElem;
-    PtnSkeleton *curSkeleton;
-    UnicodeString s;
-    int32_t bootIndex;
-
-    pos=0;
-    fSkeletons.adoptInsteadAndCheckErrorCode(new UVector(status), status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    for (bootIndex=0; bootIndex<MAX_PATTERN_ENTRIES; ++bootIndex ) {
-        curElem = patternMap.boot[bootIndex];
-        while (curElem!=nullptr) {
-            switch(type) {
-                case DT_BASESKELETON:
-                    s=curElem->basePattern;
-                    break;
-                case DT_PATTERN:
-                    s=curElem->pattern;
-                    break;
-                case DT_SKELETON:
-                    curSkeleton=curElem->skeleton.getAlias();
-                    s=curSkeleton->getSkeleton();
-                    break;
-            }
-            if ( !isCanonicalItem(s) ) {
-                LocalPointer<UnicodeString> newElem(new UnicodeString(s), status);
-                if (U_FAILURE(status)) {
-                    return;
-                }
-                fSkeletons->addElement(newElem.getAlias(), status);
-                if (U_FAILURE(status)) {
-                    fSkeletons.adoptInstead(nullptr);
-                    return;
-                }
-                newElem.orphan(); // fSkeletons vector now owns the UnicodeString.
-            }
-            curElem = curElem->next.getAlias();
-        }
-    }
-    if ((bootIndex==MAX_PATTERN_ENTRIES) && (curElem!=nullptr) ) {
-        status = U_BUFFER_OVERFLOW_ERROR;
-    }
-}
-
-const UnicodeString*
-DTSkeletonEnumeration::snext(UErrorCode& status) {
-    if (U_SUCCESS(status) && fSkeletons.isValid() && pos < fSkeletons->size()) {
-        return (const UnicodeString*)fSkeletons->elementAt(pos++);
-    }
-    return nullptr;
-}
-
-void
-DTSkeletonEnumeration::reset(UErrorCode& /*status*/) {
-    pos=0;
-}
-
-int32_t
-DTSkeletonEnumeration::count(UErrorCode& /*status*/) const {
-   return (fSkeletons.isNull()) ? 0 : fSkeletons->size();
-}
-
-UBool
-DTSkeletonEnumeration::isCanonicalItem(const UnicodeString& item) {
-    if ( item.length() != 1 ) {
-        return FALSE;
-    }
-    for (int32_t i=0; i<UDATPG_FIELD_COUNT; ++i) {
-        if (item.charAt(0)==Canonical_Items[i]) {
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
-DTSkeletonEnumeration::~DTSkeletonEnumeration() {
-    UnicodeString *s;
-    if (fSkeletons.isValid()) {
-        for (int32_t i = 0; i < fSkeletons->size(); ++i) {
-            if ((s = (UnicodeString *)fSkeletons->elementAt(i)) != nullptr) {
-                delete s;
-            }
-        }
-    }
-}
-
-DTRedundantEnumeration::DTRedundantEnumeration() : pos(0), fPatterns(nullptr) {
-}
-
-void
-DTRedundantEnumeration::add(const UnicodeString& pattern, UErrorCode& status) {
-    if (U_FAILURE(status)) { return; }
-    if (fPatterns.isNull())  {
-        fPatterns.adoptInsteadAndCheckErrorCode(new UVector(status), status);
-        if (U_FAILURE(status)) {
-            return;
-       }
-    }
-    LocalPointer<UnicodeString> newElem(new UnicodeString(pattern), status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-    fPatterns->addElement(newElem.getAlias(), status);
-    if (U_FAILURE(status)) {
-        fPatterns.adoptInstead(nullptr);
-        return;
-    }
-    newElem.orphan(); // fPatterns now owns the string.
-}
-
-const UnicodeString*
-DTRedundantEnumeration::snext(UErrorCode& status) {
-    if (U_SUCCESS(status) && fPatterns.isValid() && pos < fPatterns->size()) {
-        return (const UnicodeString*)fPatterns->elementAt(pos++);
-    }
-    return nullptr;
-}
-
-void
-DTRedundantEnumeration::reset(UErrorCode& /*status*/) {
-    pos=0;
-}
-
-int32_t
-DTRedundantEnumeration::count(UErrorCode& /*status*/) const {
-    return (fPatterns.isNull()) ? 0 : fPatterns->size();
-}
-
-UBool
-DTRedundantEnumeration::isCanonicalItem(const UnicodeString& item) const {
-    if ( item.length() != 1 ) {
-        return FALSE;
-    }
-    for (int32_t i=0; i<UDATPG_FIELD_COUNT; ++i) {
-        if (item.charAt(0)==Canonical_Items[i]) {
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
-DTRedundantEnumeration::~DTRedundantEnumeration() {
-    UnicodeString *s;
-    if (fPatterns.isValid()) {
-        for (int32_t i = 0; i < fPatterns->size(); ++i) {
-            if ((s = (UnicodeString *)fPatterns->elementAt(i)) != nullptr) {
-                delete s;
-            }
-        }
-    }
-}
-
-U_NAMESPACE_END
-
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
-
-//eof
diff --git a/tools/icu/shrink-icu-src.py b/tools/icu/shrink-icu-src.py
index 0df16cde2117d6c06b13583f769197e99a8963e6..3a9ba2fbfbf11833cae361bb9c3a4a4be808c9aa 100644
--- a/tools/icu/shrink-icu-src.py
+++ b/tools/icu/shrink-icu-src.py
@@ -5,14 +5,15 @@ import os
 import re
 import sys
 import shutil
+import bz2
 
 parser = optparse.OptionParser()
 
-parser.add_option('--icu-small',
+parser.add_option('--icudst',
     action='store',
-    dest='icusmall',
+    dest='icudst',
     default='deps/icu-small',
-    help='path to target ICU directory to shrink. Will be deleted.')
+    help='path to target ICU directory. Will be deleted.')
 
 parser.add_option('--icu-src',
     action='store',
@@ -26,18 +27,26 @@ parser.add_option('--icutmp',
     default='out/Release/obj/gen/icutmp',
     help='path to icutmp dir.')
 
-
 (options, args) = parser.parse_args()
 
-if os.path.isdir(options.icusmall):
-    print('Deleting existing icusmall %s' % (options.icusmall))
-    shutil.rmtree(options.icusmall)
+if os.path.isdir(options.icudst):
+    print('Deleting existing icudst %s' % (options.icudst))
+    shutil.rmtree(options.icudst)
 
 if not os.path.isdir(options.icusrc):
     print('Missing source ICU dir --icusrc=%s' % (options.icusrc))
     sys.exit(1)
 
+# compression stuff. Keep the suffix and the compression function in sync.
+compression_suffix = '.bz2'
+def compress_data(infp, outfp):
+    with open(infp, 'rb') as inf:
+        with bz2.BZ2File(outfp, 'wb') as outf:
+            shutil.copyfileobj(inf, outf)
 
+def print_size(fn):
+    size = (os.stat(fn).st_size) / 1024000
+    print('%dM\t%s' % (size, fn))
 
 ignore_regex = re.compile('^.*\.(vcxproj|filters|nrm|icu|dat|xml|txt|ac|guess|m4|in|sub|py|mak)$')
 
@@ -90,38 +99,41 @@ def icu_info(icu_full_path):
     return (icu_ver_major, icu_endianness)
 
 (icu_ver_major, icu_endianness) = icu_info(options.icusrc)
-print("icudt%s%s" % (icu_ver_major, icu_endianness))
+print("Data file root: icudt%s%s" % (icu_ver_major, icu_endianness))
+dst_datafile = os.path.join(options.icudst, "source","data","in", "icudt%s%s.dat" % (icu_ver_major, icu_endianness))
 
-src_datafile = os.path.join(options.icutmp, "icusmdt%s.dat" % (icu_ver_major))
-dst_datafile = os.path.join(options.icusmall, "source","data","in", "icudt%s%s.dat" % (icu_ver_major, icu_endianness))
+src_datafile = os.path.join(options.icusrc, "source/data/in/icudt%sl.dat" % (icu_ver_major))
+dst_cmp_datafile = "%s%s" % (dst_datafile, compression_suffix)
 
 if not os.path.isfile(src_datafile):
-    print("Could not find source datafile %s - did you build small-icu node?" % src_datafile)
-    sys.exit(1)
-else:
-    print("will use small datafile %s" % (src_datafile))
-print('%s --> %s' % (options.icusrc, options.icusmall))
-shutil.copytree(options.icusrc, options.icusmall, ignore=icu_ignore)
-print('%s --> %s' % (src_datafile, dst_datafile))
+    print("Error: icu data file not found: %s" % src_datafile)
+    exit(1)
+
+print("will use datafile %s" % (src_datafile))
+
+print('%s --> %s' % (options.icusrc, options.icudst))
+shutil.copytree(options.icusrc, options.icudst, ignore=icu_ignore)
 
 # now, make the data dir (since we ignored it)
-os.mkdir(os.path.join(os.path.join(options.icusmall, "source", "data")))
-os.mkdir(os.path.join(os.path.join(options.icusmall, "source", "data", "in")))
+icudst_data = os.path.join(options.icudst, "source", "data")
+icudst_in = os.path.join(icudst_data, "in")
+os.mkdir(icudst_data)
+os.mkdir(icudst_in)
+
+print_size(src_datafile)
 
-# OK, now copy the data file
-shutil.copy(src_datafile, dst_datafile)
+print('%s --compress-> %s' % (src_datafile, dst_cmp_datafile))
+compress_data(src_datafile, dst_cmp_datafile)
+print_size(dst_cmp_datafile)
+readme_name = os.path.join(options.icudst, "README-FULL-ICU.txt" )
 
 # Now, print a short notice
-readme_name = os.path.join(options.icusmall, "README-SMALL-ICU.txt" )
-
-fi = open(readme_name, 'wb')
-print("Small ICU sources - auto generated by shrink-icu-src.py", file=fi)
-print("", file=fi)
-print("This directory contains the ICU subset used by --with-intl=small-icu (the default)", file=fi)
-print("It is a strict subset of ICU %s source files with the following exception(s):" % (icu_ver_major), file=fi)
-print("* %s : Reduced-size data file" % (dst_datafile), file=fi)
-print("", file=fi)
-print("", file=fi)
-print("To rebuild this directory, see ../../tools/icu/README.md", file=fi)
-print("", file=fi)
-fi.close()
+msg_fmt = """\
+ICU sources - auto generated by shrink-icu-src.py\n
+This directory contains the ICU subset used by --with-intl=full-icu
+It is a strict subset of ICU {} source files with the following exception(s):
+* {} : compressed data file\n\n
+To rebuild this directory, see ../../tools/icu/README.md\n"""
+
+with open(readme_name, 'w') as out_file:
+    print(msg_fmt.format(icu_ver_major, dst_cmp_datafile), file=out_file)
diff --git a/tools/inspector_protocol/code_generator.py b/tools/inspector_protocol/code_generator.py
index c1f78dc7492d782fabc20bfa1a89ba78538ff9be..0b8baea0ae710e418195d8761a033baaa77ab357 100755
--- a/tools/inspector_protocol/code_generator.py
+++ b/tools/inspector_protocol/code_generator.py
@@ -103,6 +103,17 @@ def read_config():
             ".lib": False,
             ".lib.export_macro": "",
             ".lib.export_header": False,
+            # The encoding lib consists of encoding/encoding.h and
+            # encoding/encoding.cc in its subdirectory, which binaries
+            # may link / depend on, instead of relying on the
+            # JINJA2 templates lib/encoding_{h,cc}.template.
+            # In that case, |header| identifies the include file
+            # and |namespace| is the namespace it's using. Usually
+            # inspector_protocol_encoding but for v8's copy it's
+            # v8_inspector_protocol_encoding.
+            # TODO(johannes): Migrate away from lib/encoding_{h,cc}.template
+            #                 in favor of this.
+            ".encoding_lib": { "header": "", "namespace": []},
         }
         for key_value in config_values:
             parts = key_value.split("=")
diff --git a/tools/inspector_protocol/encoding/encoding.cc b/tools/inspector_protocol/encoding/encoding.cc
index f7858c9a22ba64c42a92ab86ac74fb3695b6517e..636281dd8ad8949c8409aa78ef8963811519187c 100644
--- a/tools/inspector_protocol/encoding/encoding.cc
+++ b/tools/inspector_protocol/encoding/encoding.cc
@@ -185,11 +185,10 @@ namespace internals {
 // |type| is the major type as specified in RFC 7049 Section 2.1.
 // |value| is the payload (e.g. for MajorType::UNSIGNED) or is the size
 // (e.g. for BYTE_STRING).
-// If successful, returns the number of bytes read. Otherwise returns -1.
-// TODO(johannes): change return type to size_t and use 0 for error.
-int8_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
+// If successful, returns the number of bytes read. Otherwise returns 0.
+size_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
   if (bytes.empty())
-    return -1;
+    return 0;
   uint8_t initial_byte = bytes[0];
   *type = MajorType((initial_byte & kMajorTypeMask) >> kMajorTypeBitShift);
 
@@ -203,32 +202,32 @@ int8_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
   if (additional_information == kAdditionalInformation1Byte) {
     // Values 24-255 are encoded with one initial byte, followed by the value.
     if (bytes.size() < 2)
-      return -1;
+      return 0;
     *value = ReadBytesMostSignificantByteFirst<uint8_t>(bytes.subspan(1));
     return 2;
   }
   if (additional_information == kAdditionalInformation2Bytes) {
     // Values 256-65535: 1 initial byte + 2 bytes payload.
     if (bytes.size() < 1 + sizeof(uint16_t))
-      return -1;
+      return 0;
     *value = ReadBytesMostSignificantByteFirst<uint16_t>(bytes.subspan(1));
     return 3;
   }
   if (additional_information == kAdditionalInformation4Bytes) {
     // 32 bit uint: 1 initial byte + 4 bytes payload.
     if (bytes.size() < 1 + sizeof(uint32_t))
-      return -1;
+      return 0;
     *value = ReadBytesMostSignificantByteFirst<uint32_t>(bytes.subspan(1));
     return 5;
   }
   if (additional_information == kAdditionalInformation8Bytes) {
     // 64 bit uint: 1 initial byte + 8 bytes payload.
     if (bytes.size() < 1 + sizeof(uint64_t))
-      return -1;
+      return 0;
     *value = ReadBytesMostSignificantByteFirst<uint64_t>(bytes.subspan(1));
     return 9;
   }
-  return -1;
+  return 0;
 }
 
 // Writes the start of a token with |type|. The |value| may indicate the size,
@@ -770,10 +769,10 @@ void CBORTokenizer::ReadNextToken(bool enter_envelope) {
       SetToken(CBORTokenTag::NULL_VALUE, 1);
       return;
     case kExpectedConversionToBase64Tag: {  // BINARY
-      const int8_t bytes_read = internals::ReadTokenStart(
+      const size_t bytes_read = internals::ReadTokenStart(
           bytes_.subspan(status_.pos + 1), &token_start_type_,
           &token_start_internal_value_);
-      if (bytes_read < 0 || token_start_type_ != MajorType::BYTE_STRING ||
+      if (!bytes_read || token_start_type_ != MajorType::BYTE_STRING ||
           token_start_internal_value_ > kMaxValidLength) {
         SetError(Error::CBOR_INVALID_BINARY);
         return;
@@ -823,46 +822,49 @@ void CBORTokenizer::ReadNextToken(bool enter_envelope) {
       return;
     }
     default: {
-      const int8_t token_start_length = internals::ReadTokenStart(
+      const size_t bytes_read = internals::ReadTokenStart(
           bytes_.subspan(status_.pos), &token_start_type_,
           &token_start_internal_value_);
-      const bool success = token_start_length >= 0;
       switch (token_start_type_) {
         case MajorType::UNSIGNED:  // INT32.
           // INT32 is a signed int32 (int32 makes sense for the
           // inspector_protocol, it's not a CBOR limitation), so we check
           // against the signed max, so that the allowable values are
           // 0, 1, 2, ... 2^31 - 1.
-          if (!success || std::numeric_limits<int32_t>::max() <
-                              token_start_internal_value_) {
+          if (!bytes_read ||
+                static_cast<int64_t>(std::numeric_limits<int32_t>::max()) <
+                  static_cast<int64_t>(token_start_internal_value_)) {
             SetError(Error::CBOR_INVALID_INT32);
             return;
           }
-          SetToken(CBORTokenTag::INT32, token_start_length);
+          SetToken(CBORTokenTag::INT32, bytes_read);
           return;
         case MajorType::NEGATIVE: {  // INT32.
           // INT32 is a signed int32 (int32 makes sense for the
-          // inspector_protocol, it's not a CBOR limitation); in CBOR,
-          // the negative values for INT32 are represented as NEGATIVE,
-          // that is, -1 INT32 is represented as 1 << 5 | 0 (major type 1,
-          // additional info value 0). So here, we compute the INT32 value
-          // and then check it against the INT32 min.
-          int64_t actual_value =
-              -static_cast<int64_t>(token_start_internal_value_) - 1;
-          if (!success || actual_value < std::numeric_limits<int32_t>::min()) {
+          // inspector_protocol, it's not a CBOR limitation); in CBOR, the
+          // negative values for INT32 are represented as NEGATIVE, that is, -1
+          // INT32 is represented as 1 << 5 | 0 (major type 1, additional info
+          // value 0).
+          // The represented allowed values range is -1 to -2^31.
+          // They are mapped into the encoded range of 0 to 2^31-1.
+          // We check the the payload in token_start_internal_value_ against
+          // that range (2^31-1 is also known as
+          // std::numeric_limits<int32_t>::max()).
+          if (!bytes_read ||
+	      static_cast<int64_t>(token_start_internal_value_) >
+                static_cast<int64_t>(std::numeric_limits<int32_t>::max())) {
             SetError(Error::CBOR_INVALID_INT32);
             return;
           }
-          SetToken(CBORTokenTag::INT32, token_start_length);
+          SetToken(CBORTokenTag::INT32, bytes_read);
           return;
         }
         case MajorType::STRING: {  // STRING8.
-          if (!success || token_start_internal_value_ > kMaxValidLength) {
+          if (!bytes_read || token_start_internal_value_ > kMaxValidLength) {
             SetError(Error::CBOR_INVALID_STRING8);
             return;
           }
-          uint64_t token_byte_length =
-              token_start_internal_value_ + token_start_length;
+          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
           if (token_byte_length > remaining_bytes) {
             SetError(Error::CBOR_INVALID_STRING8);
             return;
@@ -874,13 +876,12 @@ void CBORTokenizer::ReadNextToken(bool enter_envelope) {
         case MajorType::BYTE_STRING: {  // STRING16.
           // Length must be divisible by 2 since UTF16 is 2 bytes per
           // character, hence the &1 check.
-          if (!success || token_start_internal_value_ > kMaxValidLength ||
+          if (!bytes_read || token_start_internal_value_ > kMaxValidLength ||
               token_start_internal_value_ & 1) {
             SetError(Error::CBOR_INVALID_STRING16);
             return;
           }
-          uint64_t token_byte_length =
-              token_start_internal_value_ + token_start_length;
+          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
           if (token_byte_length > remaining_bytes) {
             SetError(Error::CBOR_INVALID_STRING16);
             return;
@@ -1856,7 +1857,7 @@ class JsonParser {
       // If the |Char| we're dealing with is really a byte, then
       // we have utf8 here, and we need to check for multibyte characters
       // and transcode them to utf16 (either one or two utf16 chars).
-      if (sizeof(Char) == sizeof(uint8_t) && c >= 0x7f) {
+      if (sizeof(Char) == sizeof(uint8_t) && c > 0x7f) {
         // Inspect the leading byte to figure out how long the utf8
         // byte sequence is; while doing this initialize |codepoint|
         // with the first few bits.
@@ -1895,7 +1896,7 @@ class JsonParser {
         // Disallow overlong encodings for ascii characters, as these
         // would include " and other characters significant to JSON
         // string termination / control.
-        if (codepoint < 0x7f)
+        if (codepoint <= 0x7f)
           return false;
         // Invalid in UTF8, and can't be represented in UTF16 anyway.
         if (codepoint > 0x10ffff)
diff --git a/tools/inspector_protocol/encoding/encoding.h b/tools/inspector_protocol/encoding/encoding.h
index 90916d42b36dae87ca1e2d3f9ffedb715ef76947..08596e9e1e43f045c0038dfa9209be050ca27cda 100644
--- a/tools/inspector_protocol/encoding/encoding.h
+++ b/tools/inspector_protocol/encoding/encoding.h
@@ -427,7 +427,7 @@ Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
                                    std::string* cbor);
 
 namespace internals {  // Exposed only for writing tests.
-int8_t ReadTokenStart(span<uint8_t> bytes,
+size_t ReadTokenStart(span<uint8_t> bytes,
                       cbor::MajorType* type,
                       uint64_t* value);
 
diff --git a/tools/inspector_protocol/encoding/encoding_test.cc b/tools/inspector_protocol/encoding/encoding_test.cc
index b8d75e09baaf31611bb0c826efdcdc01d8399465..6893fe2581683cfa5eccc20156449c93d717d592 100644
--- a/tools/inspector_protocol/encoding/encoding_test.cc
+++ b/tools/inspector_protocol/encoding/encoding_test.cc
@@ -234,6 +234,30 @@ TEST(EncodeDecodeInt32Test, RoundtripsInt32Max) {
   EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
 }
 
+TEST(EncodeDecodeInt32Test, RoundtripsInt32Min) {
+  // std::numeric_limits<int32_t> is encoded as a uint32 (4 unsigned bytes)
+  // after the initial byte, which effectively carries the sign by
+  // designating the token as NEGATIVE.
+  std::vector<uint8_t> encoded;
+  EncodeInt32(std::numeric_limits<int32_t>::min(), &encoded);
+  // 1 for initial byte, 4 for the uint32.
+  // first three bits: major type = 1;
+  // remaining five bits: additional info = 26, indicating payload is uint32.
+  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 5>{
+                           {1 << 5 | 26, 0x7f, 0xff, 0xff, 0xff}}));
+
+  // Reverse direction: decode with CBORTokenizer.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
+  EXPECT_EQ(std::numeric_limits<int32_t>::min(), tokenizer.GetInt32());
+  // It's nice to see how the min int32 value reads in hex:
+  // That is, -1 minus the unsigned payload (0x7fffffff, see above).
+  int32_t expected = -1 - 0x7fffffff;
+  EXPECT_EQ(expected, tokenizer.GetInt32());
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
 TEST(EncodeDecodeInt32Test, CantRoundtripUint32) {
   // 0xdeadbeef is a value which does not fit below
   // std::numerical_limits<int32_t>::max(), so we can't encode
@@ -261,15 +285,21 @@ TEST(EncodeDecodeInt32Test, DecodeErrorCases) {
     std::vector<uint8_t> data;
     std::string msg;
   };
-  std::vector<TestCase> tests{
-      {TestCase{
-           {24},
-           "additional info = 24 would require 1 byte of payload (but it's 0)"},
-       TestCase{{27, 0xaa, 0xbb, 0xcc},
-                "additional info = 27 would require 8 bytes of payload (but "
-                "it's 3)"},
-       TestCase{{29}, "additional info = 29 isn't recognized"}}};
-
+  std::vector<TestCase> tests{{
+      TestCase{
+          {24},
+          "additional info = 24 would require 1 byte of payload (but it's 0)"},
+      TestCase{{27, 0xaa, 0xbb, 0xcc},
+               "additional info = 27 would require 8 bytes of payload (but "
+               "it's 3)"},
+      TestCase{{29}, "additional info = 29 isn't recognized"},
+      TestCase{{1 << 5 | 27, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+               "Max UINT64 payload is outside the allowed range"},
+      TestCase{{1 << 5 | 26, 0xff, 0xff, 0xff, 0xff},
+               "Max UINT32 payload is outside the allowed range"},
+      TestCase{{1 << 5 | 26, 0x80, 0x00, 0x00, 0x00},
+               "UINT32 payload w/ high bit set is outside the allowed range"},
+  }};
   for (const TestCase& test : tests) {
     SCOPED_TRACE(test.msg);
     CBORTokenizer tokenizer(SpanFrom(test.data));
@@ -1517,6 +1547,22 @@ TEST_F(JsonParserTest, SimpleDictionary) {
       log_.str());
 }
 
+TEST_F(JsonParserTest, UsAsciiDelCornerCase) {
+  // DEL (0x7f) is a 7 bit US-ASCII character, and while it is a control
+  // character according to Unicode, it's not considered a control
+  // character in https://tools.ietf.org/html/rfc7159#section-7, so
+  // it can be placed directly into the JSON string, without JSON escaping.
+  std::string json = "{\"foo\": \"a\x7f\"}";
+  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: foo\n"
+      "string16: a\x7f\n"
+      "map end\n",
+      log_.str());
+}
+
 TEST_F(JsonParserTest, Whitespace) {
   std::string json = "\n  {\n\"msg\"\n: \v\"Hello, world.\"\t\r}\t";
   ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
diff --git a/tools/inspector_protocol/jinja2/tests.py b/tools/inspector_protocol/jinja2/tests.py
index 0adc3d4dbcbb881910bfd90214534449fafddcb3..39c7360253a70985faaf82ac910322f450722fa6 100644
--- a/tools/inspector_protocol/jinja2/tests.py
+++ b/tools/inspector_protocol/jinja2/tests.py
@@ -10,7 +10,10 @@
 """
 import operator
 import re
-from collections import Mapping
+try:
+  from collections.abc import Mapping
+except ImportError:
+  from collections import Mapping
 from jinja2.runtime import Undefined
 from jinja2._compat import text_type, string_types, integer_types
 import decimal
diff --git a/tools/inspector_protocol/lib/Values_cpp.template b/tools/inspector_protocol/lib/Values_cpp.template
index 764b4d37d9a7d5c98f0fa686a324b01daca693bc..8b4dfc91e3b9c99abbf97fbef18833e0b4ae4a17 100644
--- a/tools/inspector_protocol/lib/Values_cpp.template
+++ b/tools/inspector_protocol/lib/Values_cpp.template
@@ -6,6 +6,10 @@
 
 //#include "Values.h"
 
+{% if config.encoding_lib.header %}
+#include "{{config.encoding_lib.header}}"
+{% endif %}
+
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
@@ -64,6 +68,30 @@ void escapeStringForJSONInternal(const Char* str, unsigned len,
 // to this constant.
 static constexpr int kStackLimitValues = 1000;
 
+{% if config.encoding_lib.namespace %}
+using {{"::".join(config.encoding_lib.namespace)}}::Error;
+using {{"::".join(config.encoding_lib.namespace)}}::Status;
+using {{"::".join(config.encoding_lib.namespace)}}::span;
+namespace cbor {
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::CBORTokenTag;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::CBORTokenizer;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeBinary;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeDouble;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeFalse;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeFromLatin1;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeFromUTF16;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeIndefiniteLengthArrayStart;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeIndefiniteLengthMapStart;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeInt32;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeNull;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeStop;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeString8;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeTrue;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EnvelopeEncoder;
+using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::InitialByteForEnvelope;
+}  // namespace cbor
+{% endif %}
+
 // Below are three parsing routines for CBOR, which cover enough
 // to roundtrip JSON messages.
 std::unique_ptr<DictionaryValue> parseMap(int32_t stack_depth, cbor::CBORTokenizer* tokenizer);
@@ -178,7 +206,12 @@ std::unique_ptr<DictionaryValue> parseMap(
       key = StringUtil::fromUTF8(key_span.data(), key_span.size());
       tokenizer->Next();
     } else if (tokenizer->TokenTag() == cbor::CBORTokenTag::STRING16) {
-      return nullptr;  // STRING16 not supported yet.
+      span<uint8_t> key_span = tokenizer->GetString16WireRep();
+      if (key_span.size() & 1) return nullptr;  // UTF16 is 2 byte multiple.
+      key = StringUtil::fromUTF16(
+          reinterpret_cast<const uint16_t*>(key_span.data()),
+          key_span.size() / 2);
+      tokenizer->Next();
     } else {
       // Error::CBOR_INVALID_MAP_KEY
       return nullptr;
@@ -606,7 +639,7 @@ std::unique_ptr<Value> DictionaryValue::clone() const
         DCHECK(value != m_data.cend() && value->second);
         result->setValue(key, value->second->clone());
     }
-    return std::move(result);
+    return result;
 }
 
 DictionaryValue::DictionaryValue()
@@ -647,7 +680,7 @@ std::unique_ptr<Value> ListValue::clone() const
     std::unique_ptr<ListValue> result = ListValue::create();
     for (const std::unique_ptr<protocol::Value>& value : m_data)
         result->pushValue(value->clone());
-    return std::move(result);
+    return result;
 }
 
 ListValue::ListValue()
diff --git a/tools/inspector_protocol/lib/encoding_cpp.template b/tools/inspector_protocol/lib/encoding_cpp.template
index 54a46ecd203d4dd349695b122b107cab85443dfc..d3646491140663949875ac9c25860b4a6d37c0af 100644
--- a/tools/inspector_protocol/lib/encoding_cpp.template
+++ b/tools/inspector_protocol/lib/encoding_cpp.template
@@ -5,6 +5,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+{% if config.encoding_lib.header == "" %}
 
 #include <algorithm>
 #include <cassert>
@@ -192,11 +193,10 @@ namespace internals {
 // |type| is the major type as specified in RFC 7049 Section 2.1.
 // |value| is the payload (e.g. for MajorType::UNSIGNED) or is the size
 // (e.g. for BYTE_STRING).
-// If successful, returns the number of bytes read. Otherwise returns -1.
-// TODO(johannes): change return type to size_t and use 0 for error.
-int8_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
+// If successful, returns the number of bytes read. Otherwise returns 0.
+size_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
   if (bytes.empty())
-    return -1;
+    return 0;
   uint8_t initial_byte = bytes[0];
   *type = MajorType((initial_byte & kMajorTypeMask) >> kMajorTypeBitShift);
 
@@ -210,32 +210,32 @@ int8_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
   if (additional_information == kAdditionalInformation1Byte) {
     // Values 24-255 are encoded with one initial byte, followed by the value.
     if (bytes.size() < 2)
-      return -1;
+      return 0;
     *value = ReadBytesMostSignificantByteFirst<uint8_t>(bytes.subspan(1));
     return 2;
   }
   if (additional_information == kAdditionalInformation2Bytes) {
     // Values 256-65535: 1 initial byte + 2 bytes payload.
     if (bytes.size() < 1 + sizeof(uint16_t))
-      return -1;
+      return 0;
     *value = ReadBytesMostSignificantByteFirst<uint16_t>(bytes.subspan(1));
     return 3;
   }
   if (additional_information == kAdditionalInformation4Bytes) {
     // 32 bit uint: 1 initial byte + 4 bytes payload.
     if (bytes.size() < 1 + sizeof(uint32_t))
-      return -1;
+      return 0;
     *value = ReadBytesMostSignificantByteFirst<uint32_t>(bytes.subspan(1));
     return 5;
   }
   if (additional_information == kAdditionalInformation8Bytes) {
     // 64 bit uint: 1 initial byte + 8 bytes payload.
     if (bytes.size() < 1 + sizeof(uint64_t))
-      return -1;
+      return 0;
     *value = ReadBytesMostSignificantByteFirst<uint64_t>(bytes.subspan(1));
     return 9;
   }
-  return -1;
+  return 0;
 }
 
 // Writes the start of a token with |type|. The |value| may indicate the size,
@@ -739,7 +739,7 @@ span<uint8_t> CBORTokenizer::GetEnvelopeContents() const {
 //   and then checking whether the sum went past it.
 //
 // See also
-// https://chromium.googlesource.com/chromium/src/+/master/docs/security/integer-semantics.md
+// https://chromium.googlesource.com/chromium/src/+/HEAD/docs/security/integer-semantics.md
 static const uint64_t kMaxValidLength =
     std::min<uint64_t>(std::numeric_limits<uint64_t>::max() >> 2,
                        std::numeric_limits<size_t>::max());
@@ -777,10 +777,10 @@ void CBORTokenizer::ReadNextToken(bool enter_envelope) {
       SetToken(CBORTokenTag::NULL_VALUE, 1);
       return;
     case kExpectedConversionToBase64Tag: {  // BINARY
-      const int8_t bytes_read = internals::ReadTokenStart(
+      const size_t bytes_read = internals::ReadTokenStart(
           bytes_.subspan(status_.pos + 1), &token_start_type_,
           &token_start_internal_value_);
-      if (bytes_read < 0 || token_start_type_ != MajorType::BYTE_STRING ||
+      if (!bytes_read || token_start_type_ != MajorType::BYTE_STRING ||
           token_start_internal_value_ > kMaxValidLength) {
         SetError(Error::CBOR_INVALID_BINARY);
         return;
@@ -830,46 +830,49 @@ void CBORTokenizer::ReadNextToken(bool enter_envelope) {
       return;
     }
     default: {
-      const int8_t token_start_length = internals::ReadTokenStart(
+      const size_t bytes_read = internals::ReadTokenStart(
           bytes_.subspan(status_.pos), &token_start_type_,
           &token_start_internal_value_);
-      const bool success = token_start_length >= 0;
       switch (token_start_type_) {
         case MajorType::UNSIGNED:  // INT32.
           // INT32 is a signed int32 (int32 makes sense for the
           // inspector_protocol, it's not a CBOR limitation), so we check
           // against the signed max, so that the allowable values are
           // 0, 1, 2, ... 2^31 - 1.
-          if (!success || std::numeric_limits<int32_t>::max() <
-                              token_start_internal_value_) {
+          if (!bytes_read ||
+                static_cast<int64_t>(std::numeric_limits<int32_t>::max()) <
+                  static_cast<int64_t>(token_start_internal_value_)) {
             SetError(Error::CBOR_INVALID_INT32);
             return;
           }
-          SetToken(CBORTokenTag::INT32, token_start_length);
+          SetToken(CBORTokenTag::INT32, bytes_read);
           return;
         case MajorType::NEGATIVE: {  // INT32.
           // INT32 is a signed int32 (int32 makes sense for the
-          // inspector_protocol, it's not a CBOR limitation); in CBOR,
-          // the negative values for INT32 are represented as NEGATIVE,
-          // that is, -1 INT32 is represented as 1 << 5 | 0 (major type 1,
-          // additional info value 0). So here, we compute the INT32 value
-          // and then check it against the INT32 min.
-          int64_t actual_value =
-              -static_cast<int64_t>(token_start_internal_value_) - 1;
-          if (!success || actual_value < std::numeric_limits<int32_t>::min()) {
+          // inspector_protocol, it's not a CBOR limitation); in CBOR, the
+          // negative values for INT32 are represented as NEGATIVE, that is, -1
+          // INT32 is represented as 1 << 5 | 0 (major type 1, additional info
+          // value 0).
+          // The represented allowed values range is -1 to -2^31.
+          // They are mapped into the encoded range of 0 to 2^31-1.
+          // We check the the payload in token_start_internal_value_ against
+          // that range (2^31-1 is also known as
+          // std::numeric_limits<int32_t>::max()).
+          if (!bytes_read ||
+	        static_cast<int64_t>(token_start_internal_value_) >
+                  static_cast<int64_t>(std::numeric_limits<int32_t>::max())) {
             SetError(Error::CBOR_INVALID_INT32);
             return;
           }
-          SetToken(CBORTokenTag::INT32, token_start_length);
+          SetToken(CBORTokenTag::INT32, bytes_read);
           return;
         }
         case MajorType::STRING: {  // STRING8.
-          if (!success || token_start_internal_value_ > kMaxValidLength) {
+          if (!bytes_read || token_start_internal_value_ > kMaxValidLength) {
             SetError(Error::CBOR_INVALID_STRING8);
             return;
           }
-          uint64_t token_byte_length =
-              token_start_internal_value_ + token_start_length;
+          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
           if (token_byte_length > remaining_bytes) {
             SetError(Error::CBOR_INVALID_STRING8);
             return;
@@ -881,13 +884,12 @@ void CBORTokenizer::ReadNextToken(bool enter_envelope) {
         case MajorType::BYTE_STRING: {  // STRING16.
           // Length must be divisible by 2 since UTF16 is 2 bytes per
           // character, hence the &1 check.
-          if (!success || token_start_internal_value_ > kMaxValidLength ||
+          if (!bytes_read || token_start_internal_value_ > kMaxValidLength ||
               token_start_internal_value_ & 1) {
             SetError(Error::CBOR_INVALID_STRING16);
             return;
           }
-          uint64_t token_byte_length =
-              token_start_internal_value_ + token_start_length;
+          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
           if (token_byte_length > remaining_bytes) {
             SetError(Error::CBOR_INVALID_STRING16);
             return;
@@ -1863,7 +1865,7 @@ class JsonParser {
       // If the |Char| we're dealing with is really a byte, then
       // we have utf8 here, and we need to check for multibyte characters
       // and transcode them to utf16 (either one or two utf16 chars).
-      if (sizeof(Char) == sizeof(uint8_t) && c >= 0x7f) {
+      if (sizeof(Char) == sizeof(uint8_t) && c > 0x7f) {
         // Inspect the leading byte to figure out how long the utf8
         // byte sequence is; while doing this initialize |codepoint|
         // with the first few bits.
@@ -1902,7 +1904,7 @@ class JsonParser {
         // Disallow overlong encodings for ascii characters, as these
         // would include " and other characters significant to JSON
         // string termination / control.
-        if (codepoint < 0x7f)
+        if (codepoint <= 0x7f)
           return false;
         // Invalid in UTF8, and can't be represented in UTF16 anyway.
         if (codepoint > 0x10ffff)
@@ -2197,3 +2199,5 @@ Status ConvertJSONToCBOR(const Platform& platform,
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}
+
+{% endif %}
diff --git a/tools/inspector_protocol/lib/encoding_h.template b/tools/inspector_protocol/lib/encoding_h.template
index f1a52a1958a14d8cb475b0529a433a72ed6a1043..2c6cfc10d594c2b77f6dc0ec5d67ddc2c4c4ec83 100644
--- a/tools/inspector_protocol/lib/encoding_h.template
+++ b/tools/inspector_protocol/lib/encoding_h.template
@@ -5,6 +5,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+{% if config.encoding_lib.header == "" %}
 #ifndef {{"_".join(config.protocol.namespace)}}_encoding_h
 #define {{"_".join(config.protocol.namespace)}}_encoding_h
 
@@ -435,7 +436,7 @@ Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
                                    std::string* cbor);
 
 namespace internals {  // Exposed only for writing tests.
-int8_t ReadTokenStart(span<uint8_t> bytes,
+size_t ReadTokenStart(span<uint8_t> bytes,
                       cbor::MajorType* type,
                       uint64_t* value);
 
@@ -518,3 +519,4 @@ Status ConvertJSONToCBOR(const Platform& platform,
 } // namespace {{namespace}}
 {% endfor %}
 #endif // !defined({{"_".join(config.protocol.namespace)}}_encoding_h)
+{% endif %}
diff --git a/tools/install.py b/tools/install.py
index 655802980a6ea94d1d4ca1dc63c8c8e905fbb83a..693faff4c37ac4d83a47e818f4412900497a2b62 100755
--- a/tools/install.py
+++ b/tools/install.py
@@ -19,8 +19,8 @@ def abspath(*args):
   return os.path.abspath(path)
 
 def load_config():
-  s = open('config.gypi').read()
-  return ast.literal_eval(s)
+  with open('config.gypi') as f:
+    return ast.literal_eval(f.read())
 
 def try_unlink(path):
   try:
@@ -132,10 +132,6 @@ def files(action):
       output_file += '.dll'
     else:
       output_file = 'lib' + output_file + '.' + variables.get('shlib_suffix')
-      # GYP will output to lib.target except on OS X, this is hardcoded
-      # in its source - see the _InstallableTargetInstallPath function.
-      if sys.platform != 'darwin':
-        output_prefix += 'lib.target/'
 
   if 'false' == variables.get('node_shared'):
     action([output_prefix + output_file], 'bin/' + output_file)
@@ -227,11 +223,19 @@ def run(args):
   cmd = args[1] if len(args) > 1 else 'install'
 
   if os.environ.get('HEADERS_ONLY'):
-    if cmd == 'install': return headers(install)
-    if cmd == 'uninstall': return headers(uninstall)
+    if cmd == 'install':
+      headers(install)
+      return
+    if cmd == 'uninstall':
+      headers(uninstall)
+      return
   else:
-    if cmd == 'install': return files(install)
-    if cmd == 'uninstall': return files(uninstall)
+    if cmd == 'install':
+      files(install)
+      return
+    if cmd == 'uninstall':
+      files(uninstall)
+      return
 
   raise RuntimeError('Bad command: %s\n' % cmd)
 
diff --git a/tools/js2c.py b/tools/js2c.py
index 195e6a6189a98916bcfb7abb1b73595b8bc8eb38..30475308e29bb768481daab5a02b0bb11720a8bd 100755
--- a/tools/js2c.py
+++ b/tools/js2c.py
@@ -36,6 +36,7 @@ import os
 import re
 import functools
 import codecs
+import utils
 
 def ReadFile(filename):
   if is_verbose:
@@ -123,7 +124,7 @@ def AddModule(filename, definitions, initializers):
   initializers.append(initializer)
 
 def NormalizeFileName(filename):
-  split = filename.split(os.path.sep)
+  split = filename.split('/')
   if split[0] == 'deps':
     split = ['internal'] + split
   else:  # `lib/**/*.js` so drop the 'lib' part
@@ -163,9 +164,11 @@ def handle_config_gypi(config_filename):
 def jsonify(config):
   # 1. string comments
   config = re.sub(r'#.*?\n', '', config)
+  # 2. join multiline strings
+  config = re.sub(r"'$\s+'", '', config, flags=re.M)
   # 3. normalize string literals from ' into "
   config = re.sub('\'', '"', config)
-  # 2. turn pseudo-booleans strings into Booleans
+  # 4. turn pseudo-booleans strings into Booleans
   config = re.sub('"true"', 'true', config)
   config = re.sub('"false"', 'false', config)
   return config
@@ -200,12 +203,23 @@ def main():
     fromfile_prefix_chars='@'
   )
   parser.add_argument('--target', help='output file')
+  parser.add_argument(
+      '--directory',
+      default=None,
+      help='input file directory')
   parser.add_argument('--verbose', action='store_true', help='output file')
   parser.add_argument('sources', nargs='*', help='input files')
   options = parser.parse_args()
   global is_verbose
   is_verbose = options.verbose
-  source_files = functools.reduce(SourceFileByExt, options.sources, {})
+  sources = options.sources
+  if options.directory is not None:
+    js_files = utils.SearchFiles(options.directory, 'js')
+    mjs_files = utils.SearchFiles(options.directory, 'mjs')
+    sources = js_files + mjs_files + options.sources
+
+  source_files = functools.reduce(SourceFileByExt, sources, {})
+
   # Should have exactly 2 types: `.js`, and `.gypi`
   assert len(source_files) == 2
   # Currently config.gypi is the only `.gypi` file allowed
diff --git a/tools/lint-md.js b/tools/lint-md.mjs
similarity index 43%
rename from tools/lint-md.js
rename to tools/lint-md.mjs
index 9d8aa3d097ace81faaaceb84f3d8d33164cd3204..b614ae37d81af3a1cf5019bdb6bcfea6c9f0bafe 100644
--- a/tools/lint-md.js
+++ b/tools/lint-md.mjs
@@ -1,44698 +1,57684 @@
-'use strict';
+import path$b from 'path';
+import require$$0$3, { realpathSync as realpathSync$1, statSync, Stats } from 'fs';
+import { URL as URL$1, fileURLToPath, pathToFileURL } from 'url';
+import process$2 from 'node:process';
+import stream, { PassThrough } from 'node:stream';
+import require$$0$2 from 'os';
+import tty$1 from 'tty';
+import require$$0$5 from 'events';
+import require$$0$4, { format as format$2, inspect as inspect$1 } from 'util';
+import require$$1 from 'stream';
+import path$c from 'node:path';
+import { pathToFileURL as pathToFileURL$1 } from 'node:url';
+import assert$2 from 'assert';
+import fs$a from 'node:fs';
+import { EventEmitter as EventEmitter$1 } from 'node:events';
+import process$1 from 'process';
 
-// Don't change this file manually,
-// it is generated from tools/node-lint-md-cli-rollup
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var stream = _interopDefault(require('stream'));
-var path$1 = _interopDefault(require('path'));
-var module$1 = _interopDefault(require('module'));
-var util$2 = _interopDefault(require('util'));
-var os = _interopDefault(require('os'));
-var tty = _interopDefault(require('tty'));
-var fs$1 = _interopDefault(require('fs'));
-var events = _interopDefault(require('events'));
-var assert = _interopDefault(require('assert'));
-
-var vfileStatistics = statistics;
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-// Get stats for a file, list of files, or list of messages.
-function statistics(files) {
-  var result = {true: 0, false: 0, null: 0};
+function getAugmentedNamespace(n) {
+	if (n.__esModule) return n;
+	var a = Object.defineProperty({}, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
 
-  count(files);
+function commonjsRequire (path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
 
-  return {
-    fatal: result.true,
-    nonfatal: result.false + result.null,
-    warn: result.false,
-    info: result.null,
-    total: result.true + result.false + result.null
-  }
+var ansiStyles$2 = {exports: {}};
 
-  function count(value) {
-    if (value) {
-      if (value[0] && value[0].messages) {
-        // Multiple vfiles
-        countInAll(value);
-      } else {
-        // One vfile / messages
-        countAll(value.messages || value);
-      }
-    }
-  }
+var colorName$1 = {
+	"aliceblue": [240, 248, 255],
+	"antiquewhite": [250, 235, 215],
+	"aqua": [0, 255, 255],
+	"aquamarine": [127, 255, 212],
+	"azure": [240, 255, 255],
+	"beige": [245, 245, 220],
+	"bisque": [255, 228, 196],
+	"black": [0, 0, 0],
+	"blanchedalmond": [255, 235, 205],
+	"blue": [0, 0, 255],
+	"blueviolet": [138, 43, 226],
+	"brown": [165, 42, 42],
+	"burlywood": [222, 184, 135],
+	"cadetblue": [95, 158, 160],
+	"chartreuse": [127, 255, 0],
+	"chocolate": [210, 105, 30],
+	"coral": [255, 127, 80],
+	"cornflowerblue": [100, 149, 237],
+	"cornsilk": [255, 248, 220],
+	"crimson": [220, 20, 60],
+	"cyan": [0, 255, 255],
+	"darkblue": [0, 0, 139],
+	"darkcyan": [0, 139, 139],
+	"darkgoldenrod": [184, 134, 11],
+	"darkgray": [169, 169, 169],
+	"darkgreen": [0, 100, 0],
+	"darkgrey": [169, 169, 169],
+	"darkkhaki": [189, 183, 107],
+	"darkmagenta": [139, 0, 139],
+	"darkolivegreen": [85, 107, 47],
+	"darkorange": [255, 140, 0],
+	"darkorchid": [153, 50, 204],
+	"darkred": [139, 0, 0],
+	"darksalmon": [233, 150, 122],
+	"darkseagreen": [143, 188, 143],
+	"darkslateblue": [72, 61, 139],
+	"darkslategray": [47, 79, 79],
+	"darkslategrey": [47, 79, 79],
+	"darkturquoise": [0, 206, 209],
+	"darkviolet": [148, 0, 211],
+	"deeppink": [255, 20, 147],
+	"deepskyblue": [0, 191, 255],
+	"dimgray": [105, 105, 105],
+	"dimgrey": [105, 105, 105],
+	"dodgerblue": [30, 144, 255],
+	"firebrick": [178, 34, 34],
+	"floralwhite": [255, 250, 240],
+	"forestgreen": [34, 139, 34],
+	"fuchsia": [255, 0, 255],
+	"gainsboro": [220, 220, 220],
+	"ghostwhite": [248, 248, 255],
+	"gold": [255, 215, 0],
+	"goldenrod": [218, 165, 32],
+	"gray": [128, 128, 128],
+	"green": [0, 128, 0],
+	"greenyellow": [173, 255, 47],
+	"grey": [128, 128, 128],
+	"honeydew": [240, 255, 240],
+	"hotpink": [255, 105, 180],
+	"indianred": [205, 92, 92],
+	"indigo": [75, 0, 130],
+	"ivory": [255, 255, 240],
+	"khaki": [240, 230, 140],
+	"lavender": [230, 230, 250],
+	"lavenderblush": [255, 240, 245],
+	"lawngreen": [124, 252, 0],
+	"lemonchiffon": [255, 250, 205],
+	"lightblue": [173, 216, 230],
+	"lightcoral": [240, 128, 128],
+	"lightcyan": [224, 255, 255],
+	"lightgoldenrodyellow": [250, 250, 210],
+	"lightgray": [211, 211, 211],
+	"lightgreen": [144, 238, 144],
+	"lightgrey": [211, 211, 211],
+	"lightpink": [255, 182, 193],
+	"lightsalmon": [255, 160, 122],
+	"lightseagreen": [32, 178, 170],
+	"lightskyblue": [135, 206, 250],
+	"lightslategray": [119, 136, 153],
+	"lightslategrey": [119, 136, 153],
+	"lightsteelblue": [176, 196, 222],
+	"lightyellow": [255, 255, 224],
+	"lime": [0, 255, 0],
+	"limegreen": [50, 205, 50],
+	"linen": [250, 240, 230],
+	"magenta": [255, 0, 255],
+	"maroon": [128, 0, 0],
+	"mediumaquamarine": [102, 205, 170],
+	"mediumblue": [0, 0, 205],
+	"mediumorchid": [186, 85, 211],
+	"mediumpurple": [147, 112, 219],
+	"mediumseagreen": [60, 179, 113],
+	"mediumslateblue": [123, 104, 238],
+	"mediumspringgreen": [0, 250, 154],
+	"mediumturquoise": [72, 209, 204],
+	"mediumvioletred": [199, 21, 133],
+	"midnightblue": [25, 25, 112],
+	"mintcream": [245, 255, 250],
+	"mistyrose": [255, 228, 225],
+	"moccasin": [255, 228, 181],
+	"navajowhite": [255, 222, 173],
+	"navy": [0, 0, 128],
+	"oldlace": [253, 245, 230],
+	"olive": [128, 128, 0],
+	"olivedrab": [107, 142, 35],
+	"orange": [255, 165, 0],
+	"orangered": [255, 69, 0],
+	"orchid": [218, 112, 214],
+	"palegoldenrod": [238, 232, 170],
+	"palegreen": [152, 251, 152],
+	"paleturquoise": [175, 238, 238],
+	"palevioletred": [219, 112, 147],
+	"papayawhip": [255, 239, 213],
+	"peachpuff": [255, 218, 185],
+	"peru": [205, 133, 63],
+	"pink": [255, 192, 203],
+	"plum": [221, 160, 221],
+	"powderblue": [176, 224, 230],
+	"purple": [128, 0, 128],
+	"rebeccapurple": [102, 51, 153],
+	"red": [255, 0, 0],
+	"rosybrown": [188, 143, 143],
+	"royalblue": [65, 105, 225],
+	"saddlebrown": [139, 69, 19],
+	"salmon": [250, 128, 114],
+	"sandybrown": [244, 164, 96],
+	"seagreen": [46, 139, 87],
+	"seashell": [255, 245, 238],
+	"sienna": [160, 82, 45],
+	"silver": [192, 192, 192],
+	"skyblue": [135, 206, 235],
+	"slateblue": [106, 90, 205],
+	"slategray": [112, 128, 144],
+	"slategrey": [112, 128, 144],
+	"snow": [255, 250, 250],
+	"springgreen": [0, 255, 127],
+	"steelblue": [70, 130, 180],
+	"tan": [210, 180, 140],
+	"teal": [0, 128, 128],
+	"thistle": [216, 191, 216],
+	"tomato": [255, 99, 71],
+	"turquoise": [64, 224, 208],
+	"violet": [238, 130, 238],
+	"wheat": [245, 222, 179],
+	"white": [255, 255, 255],
+	"whitesmoke": [245, 245, 245],
+	"yellow": [255, 255, 0],
+	"yellowgreen": [154, 205, 50]
+};
 
-  function countInAll(files) {
-    var length = files.length;
-    var index = -1;
+/* MIT license */
 
-    while (++index < length) {
-      count(files[index].messages);
-    }
-  }
+/* eslint-disable no-mixed-operators */
+const cssKeywords$1 = colorName$1;
 
-  function countAll(messages) {
-    var length = messages.length;
-    var index = -1;
-    var fatal;
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+//       values that give correct `typeof` results).
+//       do not use box values types (i.e. Number(), String(), etc.)
 
-    while (++index < length) {
-      fatal = messages[index].fatal;
-      result[fatal === null || fatal === undefined ? null : Boolean(fatal)]++;
-    }
-  }
+const reverseKeywords$1 = {};
+for (const key of Object.keys(cssKeywords$1)) {
+	reverseKeywords$1[cssKeywords$1[key]] = key;
 }
 
-var slice = [].slice;
-
-var wrap_1 = wrap;
-
-// Wrap `fn`.
-// Can be sync or async; return a promise, receive a completion handler, return
-// new values and errors.
-function wrap(fn, callback) {
-  var invoked;
-
-  return wrapped
+const convert$4 = {
+	rgb: {channels: 3, labels: 'rgb'},
+	hsl: {channels: 3, labels: 'hsl'},
+	hsv: {channels: 3, labels: 'hsv'},
+	hwb: {channels: 3, labels: 'hwb'},
+	cmyk: {channels: 4, labels: 'cmyk'},
+	xyz: {channels: 3, labels: 'xyz'},
+	lab: {channels: 3, labels: 'lab'},
+	lch: {channels: 3, labels: 'lch'},
+	hex: {channels: 1, labels: ['hex']},
+	keyword: {channels: 1, labels: ['keyword']},
+	ansi16: {channels: 1, labels: ['ansi16']},
+	ansi256: {channels: 1, labels: ['ansi256']},
+	hcg: {channels: 3, labels: ['h', 'c', 'g']},
+	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
+	gray: {channels: 1, labels: ['gray']}
+};
 
-  function wrapped() {
-    var params = slice.call(arguments, 0);
-    var callback = fn.length > params.length;
-    var result;
+var conversions$5 = convert$4;
 
-    if (callback) {
-      params.push(done);
-    }
+// Hide .channels and .labels properties
+for (const model of Object.keys(convert$4)) {
+	if (!('channels' in convert$4[model])) {
+		throw new Error('missing channels property: ' + model);
+	}
 
-    try {
-      result = fn.apply(null, params);
-    } catch (error) {
-      // Well, this is quite the pickle.
-      // `fn` received a callback and invoked it (thus continuing the pipeline),
-      // but later also threw an error.
-      // We’re not about to restart the pipeline again, so the only thing left
-      // to do is to throw the thing instead.
-      if (callback && invoked) {
-        throw error
-      }
+	if (!('labels' in convert$4[model])) {
+		throw new Error('missing channel labels property: ' + model);
+	}
 
-      return done(error)
-    }
+	if (convert$4[model].labels.length !== convert$4[model].channels) {
+		throw new Error('channel and label counts mismatch: ' + model);
+	}
 
-    if (!callback) {
-      if (result && typeof result.then === 'function') {
-        result.then(then, done);
-      } else if (result instanceof Error) {
-        done(result);
-      } else {
-        then(result);
-      }
-    }
-  }
+	const {channels, labels} = convert$4[model];
+	delete convert$4[model].channels;
+	delete convert$4[model].labels;
+	Object.defineProperty(convert$4[model], 'channels', {value: channels});
+	Object.defineProperty(convert$4[model], 'labels', {value: labels});
+}
 
-  // Invoke `next`, only once.
-  function done() {
-    if (!invoked) {
-      invoked = true;
+convert$4.rgb.hsl = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const min = Math.min(r, g, b);
+	const max = Math.max(r, g, b);
+	const delta = max - min;
+	let h;
+	let s;
 
-      callback.apply(null, arguments);
-    }
-  }
+	if (max === min) {
+		h = 0;
+	} else if (r === max) {
+		h = (g - b) / delta;
+	} else if (g === max) {
+		h = 2 + (b - r) / delta;
+	} else if (b === max) {
+		h = 4 + (r - g) / delta;
+	}
 
-  // Invoke `done` with one value.
-  // Tracks if an error is passed, too.
-  function then(value) {
-    done(null, value);
-  }
-}
+	h = Math.min(h * 60, 360);
 
-var trough_1 = trough;
+	if (h < 0) {
+		h += 360;
+	}
 
-trough.wrap = wrap_1;
+	const l = (min + max) / 2;
 
-var slice$1 = [].slice;
+	if (max === min) {
+		s = 0;
+	} else if (l <= 0.5) {
+		s = delta / (max + min);
+	} else {
+		s = delta / (2 - max - min);
+	}
 
-// Create new middleware.
-function trough() {
-  var fns = [];
-  var middleware = {};
+	return [h, s * 100, l * 100];
+};
 
-  middleware.run = run;
-  middleware.use = use;
+convert$4.rgb.hsv = function (rgb) {
+	let rdif;
+	let gdif;
+	let bdif;
+	let h;
+	let s;
 
-  return middleware
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const v = Math.max(r, g, b);
+	const diff = v - Math.min(r, g, b);
+	const diffc = function (c) {
+		return (v - c) / 6 / diff + 1 / 2;
+	};
 
-  // Run `fns`.  Last argument must be a completion handler.
-  function run() {
-    var index = -1;
-    var input = slice$1.call(arguments, 0, -1);
-    var done = arguments[arguments.length - 1];
+	if (diff === 0) {
+		h = 0;
+		s = 0;
+	} else {
+		s = diff / v;
+		rdif = diffc(r);
+		gdif = diffc(g);
+		bdif = diffc(b);
 
-    if (typeof done !== 'function') {
-      throw new Error('Expected function as last argument, not ' + done)
-    }
+		if (r === v) {
+			h = bdif - gdif;
+		} else if (g === v) {
+			h = (1 / 3) + rdif - bdif;
+		} else if (b === v) {
+			h = (2 / 3) + gdif - rdif;
+		}
 
-    next.apply(null, [null].concat(input));
+		if (h < 0) {
+			h += 1;
+		} else if (h > 1) {
+			h -= 1;
+		}
+	}
 
-    // Run the next `fn`, if any.
-    function next(err) {
-      var fn = fns[++index];
-      var params = slice$1.call(arguments, 0);
-      var values = params.slice(1);
-      var length = input.length;
-      var pos = -1;
+	return [
+		h * 360,
+		s * 100,
+		v * 100
+	];
+};
 
-      if (err) {
-        done(err);
-        return
-      }
+convert$4.rgb.hwb = function (rgb) {
+	const r = rgb[0];
+	const g = rgb[1];
+	let b = rgb[2];
+	const h = convert$4.rgb.hsl(rgb)[0];
+	const w = 1 / 255 * Math.min(r, Math.min(g, b));
 
-      // Copy non-nully input into values.
-      while (++pos < length) {
-        if (values[pos] === null || values[pos] === undefined) {
-          values[pos] = input[pos];
-        }
-      }
+	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
 
-      input = values;
+	return [h, w * 100, b * 100];
+};
 
-      // Next or done.
-      if (fn) {
-        wrap_1(fn, next).apply(null, input);
-      } else {
-        done.apply(null, [null].concat(input));
-      }
-    }
-  }
+convert$4.rgb.cmyk = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
 
-  // Add `fn` to the list.
-  function use(fn) {
-    if (typeof fn !== 'function') {
-      throw new Error('Expected `fn` to be a function, not ' + fn)
-    }
+	const k = Math.min(1 - r, 1 - g, 1 - b);
+	const c = (1 - r - k) / (1 - k) || 0;
+	const m = (1 - g - k) / (1 - k) || 0;
+	const y = (1 - b - k) / (1 - k) || 0;
 
-    fns.push(fn);
+	return [c * 100, m * 100, y * 100, k * 100];
+};
 
-    return middleware
-  }
+function comparativeDistance$1(x, y) {
+	/*
+		See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+	*/
+	return (
+		((x[0] - y[0]) ** 2) +
+		((x[1] - y[1]) ** 2) +
+		((x[2] - y[2]) ** 2)
+	);
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+convert$4.rgb.keyword = function (rgb) {
+	const reversed = reverseKeywords$1[rgb];
+	if (reversed) {
+		return reversed;
+	}
 
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
+	let currentClosestDistance = Infinity;
+	let currentClosestKeyword;
 
-function unwrapExports (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
+	for (const keyword of Object.keys(cssKeywords$1)) {
+		const value = cssKeywords$1[keyword];
 
-function createCommonjsModule(fn, module) {
-	return module = { exports: {} }, fn(module, module.exports), module.exports;
-}
+		// Compute comparative distance
+		const distance = comparativeDistance$1(rgb, value);
 
-function getCjsExportFromNamespace (n) {
-	return n && n['default'] || n;
-}
+		// Check if its less, if so set as closest
+		if (distance < currentClosestDistance) {
+			currentClosestDistance = distance;
+			currentClosestKeyword = keyword;
+		}
+	}
 
-function isNothing(subject) {
-  return (typeof subject === 'undefined') || (subject === null);
-}
+	return currentClosestKeyword;
+};
 
+convert$4.keyword.rgb = function (keyword) {
+	return cssKeywords$1[keyword];
+};
 
-function isObject(subject) {
-  return (typeof subject === 'object') && (subject !== null);
-}
+convert$4.rgb.xyz = function (rgb) {
+	let r = rgb[0] / 255;
+	let g = rgb[1] / 255;
+	let b = rgb[2] / 255;
 
+	// Assume sRGB
+	r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
+	g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
+	b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
 
-function toArray(sequence) {
-  if (Array.isArray(sequence)) return sequence;
-  else if (isNothing(sequence)) return [];
+	const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+	const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+	const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
 
-  return [ sequence ];
-}
+	return [x * 100, y * 100, z * 100];
+};
 
+convert$4.rgb.lab = function (rgb) {
+	const xyz = convert$4.rgb.xyz(rgb);
+	let x = xyz[0];
+	let y = xyz[1];
+	let z = xyz[2];
 
-function extend(target, source) {
-  var index, length, key, sourceKeys;
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
 
-  if (source) {
-    sourceKeys = Object.keys(source);
+	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
 
-    for (index = 0, length = sourceKeys.length; index < length; index += 1) {
-      key = sourceKeys[index];
-      target[key] = source[key];
-    }
-  }
+	const l = (116 * y) - 16;
+	const a = 500 * (x - y);
+	const b = 200 * (y - z);
 
-  return target;
-}
+	return [l, a, b];
+};
 
+convert$4.hsl.rgb = function (hsl) {
+	const h = hsl[0] / 360;
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
+	let t2;
+	let t3;
+	let val;
 
-function repeat(string, count) {
-  var result = '', cycle;
+	if (s === 0) {
+		val = l * 255;
+		return [val, val, val];
+	}
 
-  for (cycle = 0; cycle < count; cycle += 1) {
-    result += string;
-  }
+	if (l < 0.5) {
+		t2 = l * (1 + s);
+	} else {
+		t2 = l + s - l * s;
+	}
 
-  return result;
-}
+	const t1 = 2 * l - t2;
 
+	const rgb = [0, 0, 0];
+	for (let i = 0; i < 3; i++) {
+		t3 = h + 1 / 3 * -(i - 1);
+		if (t3 < 0) {
+			t3++;
+		}
 
-function isNegativeZero(number) {
-  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
-}
+		if (t3 > 1) {
+			t3--;
+		}
 
+		if (6 * t3 < 1) {
+			val = t1 + (t2 - t1) * 6 * t3;
+		} else if (2 * t3 < 1) {
+			val = t2;
+		} else if (3 * t3 < 2) {
+			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+		} else {
+			val = t1;
+		}
 
-var isNothing_1      = isNothing;
-var isObject_1       = isObject;
-var toArray_1        = toArray;
-var repeat_1         = repeat;
-var isNegativeZero_1 = isNegativeZero;
-var extend_1         = extend;
+		rgb[i] = val * 255;
+	}
 
-var common = {
-	isNothing: isNothing_1,
-	isObject: isObject_1,
-	toArray: toArray_1,
-	repeat: repeat_1,
-	isNegativeZero: isNegativeZero_1,
-	extend: extend_1
+	return rgb;
 };
 
-// YAML error class. http://stackoverflow.com/questions/8458984
+convert$4.hsl.hsv = function (hsl) {
+	const h = hsl[0];
+	let s = hsl[1] / 100;
+	let l = hsl[2] / 100;
+	let smin = s;
+	const lmin = Math.max(l, 0.01);
 
-function YAMLException(reason, mark) {
-  // Super constructor
-  Error.call(this);
+	l *= 2;
+	s *= (l <= 1) ? l : 2 - l;
+	smin *= lmin <= 1 ? lmin : 2 - lmin;
+	const v = (l + s) / 2;
+	const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
 
-  this.name = 'YAMLException';
-  this.reason = reason;
-  this.mark = mark;
-  this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');
+	return [h, sv * 100, v * 100];
+};
 
-  // Include stack trace in error object
-  if (Error.captureStackTrace) {
-    // Chrome and NodeJS
-    Error.captureStackTrace(this, this.constructor);
-  } else {
-    // FF, IE 10+ and Safari 6+. Fallback for others
-    this.stack = (new Error()).stack || '';
-  }
-}
+convert$4.hsv.rgb = function (hsv) {
+	const h = hsv[0] / 60;
+	const s = hsv[1] / 100;
+	let v = hsv[2] / 100;
+	const hi = Math.floor(h) % 6;
 
+	const f = h - Math.floor(h);
+	const p = 255 * v * (1 - s);
+	const q = 255 * v * (1 - (s * f));
+	const t = 255 * v * (1 - (s * (1 - f)));
+	v *= 255;
 
-// Inherit from Error
-YAMLException.prototype = Object.create(Error.prototype);
-YAMLException.prototype.constructor = YAMLException;
+	switch (hi) {
+		case 0:
+			return [v, t, p];
+		case 1:
+			return [q, v, p];
+		case 2:
+			return [p, v, t];
+		case 3:
+			return [p, q, v];
+		case 4:
+			return [t, p, v];
+		case 5:
+			return [v, p, q];
+	}
+};
 
+convert$4.hsv.hsl = function (hsv) {
+	const h = hsv[0];
+	const s = hsv[1] / 100;
+	const v = hsv[2] / 100;
+	const vmin = Math.max(v, 0.01);
+	let sl;
+	let l;
 
-YAMLException.prototype.toString = function toString(compact) {
-  var result = this.name + ': ';
+	l = (2 - s) * v;
+	const lmin = (2 - s) * vmin;
+	sl = s * vmin;
+	sl /= (lmin <= 1) ? lmin : 2 - lmin;
+	sl = sl || 0;
+	l /= 2;
 
-  result += this.reason || '(unknown reason)';
+	return [h, sl * 100, l * 100];
+};
 
-  if (!compact && this.mark) {
-    result += ' ' + this.mark.toString();
-  }
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert$4.hwb.rgb = function (hwb) {
+	const h = hwb[0] / 360;
+	let wh = hwb[1] / 100;
+	let bl = hwb[2] / 100;
+	const ratio = wh + bl;
+	let f;
 
-  return result;
-};
+	// Wh + bl cant be > 1
+	if (ratio > 1) {
+		wh /= ratio;
+		bl /= ratio;
+	}
 
+	const i = Math.floor(6 * h);
+	const v = 1 - bl;
+	f = 6 * h - i;
 
-var exception = YAMLException;
+	if ((i & 0x01) !== 0) {
+		f = 1 - f;
+	}
 
-function Mark(name, buffer, position, line, column) {
-  this.name     = name;
-  this.buffer   = buffer;
-  this.position = position;
-  this.line     = line;
-  this.column   = column;
-}
+	const n = wh + f * (v - wh); // Linear interpolation
 
+	let r;
+	let g;
+	let b;
+	/* eslint-disable max-statements-per-line,no-multi-spaces */
+	switch (i) {
+		default:
+		case 6:
+		case 0: r = v;  g = n;  b = wh; break;
+		case 1: r = n;  g = v;  b = wh; break;
+		case 2: r = wh; g = v;  b = n; break;
+		case 3: r = wh; g = n;  b = v; break;
+		case 4: r = n;  g = wh; b = v; break;
+		case 5: r = v;  g = wh; b = n; break;
+	}
+	/* eslint-enable max-statements-per-line,no-multi-spaces */
 
-Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
-  var head, start, tail, end, snippet;
+	return [r * 255, g * 255, b * 255];
+};
 
-  if (!this.buffer) return null;
+convert$4.cmyk.rgb = function (cmyk) {
+	const c = cmyk[0] / 100;
+	const m = cmyk[1] / 100;
+	const y = cmyk[2] / 100;
+	const k = cmyk[3] / 100;
 
-  indent = indent || 4;
-  maxLength = maxLength || 75;
+	const r = 1 - Math.min(1, c * (1 - k) + k);
+	const g = 1 - Math.min(1, m * (1 - k) + k);
+	const b = 1 - Math.min(1, y * (1 - k) + k);
 
-  head = '';
-  start = this.position;
+	return [r * 255, g * 255, b * 255];
+};
 
-  while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {
-    start -= 1;
-    if (this.position - start > (maxLength / 2 - 1)) {
-      head = ' ... ';
-      start += 5;
-      break;
-    }
-  }
+convert$4.xyz.rgb = function (xyz) {
+	const x = xyz[0] / 100;
+	const y = xyz[1] / 100;
+	const z = xyz[2] / 100;
+	let r;
+	let g;
+	let b;
 
-  tail = '';
-  end = this.position;
+	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
 
-  while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) {
-    end += 1;
-    if (end - this.position > (maxLength / 2 - 1)) {
-      tail = ' ... ';
-      end -= 5;
-      break;
-    }
-  }
+	// Assume sRGB
+	r = r > 0.0031308
+		? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
+		: r * 12.92;
 
-  snippet = this.buffer.slice(start, end);
+	g = g > 0.0031308
+		? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
+		: g * 12.92;
 
-  return common.repeat(' ', indent) + head + snippet + tail + '\n' +
-         common.repeat(' ', indent + this.position - start + head.length) + '^';
-};
+	b = b > 0.0031308
+		? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
+		: b * 12.92;
 
+	r = Math.min(Math.max(0, r), 1);
+	g = Math.min(Math.max(0, g), 1);
+	b = Math.min(Math.max(0, b), 1);
 
-Mark.prototype.toString = function toString(compact) {
-  var snippet, where = '';
+	return [r * 255, g * 255, b * 255];
+};
 
-  if (this.name) {
-    where += 'in "' + this.name + '" ';
-  }
+convert$4.xyz.lab = function (xyz) {
+	let x = xyz[0];
+	let y = xyz[1];
+	let z = xyz[2];
 
-  where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
 
-  if (!compact) {
-    snippet = this.getSnippet();
+	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
 
-    if (snippet) {
-      where += ':\n' + snippet;
-    }
-  }
+	const l = (116 * y) - 16;
+	const a = 500 * (x - y);
+	const b = 200 * (y - z);
 
-  return where;
+	return [l, a, b];
 };
 
+convert$4.lab.xyz = function (lab) {
+	const l = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	let x;
+	let y;
+	let z;
 
-var mark = Mark;
+	y = (l + 16) / 116;
+	x = a / 500 + y;
+	z = y - b / 200;
 
-var TYPE_CONSTRUCTOR_OPTIONS = [
-  'kind',
-  'resolve',
-  'construct',
-  'instanceOf',
-  'predicate',
-  'represent',
-  'defaultStyle',
-  'styleAliases'
-];
+	const y2 = y ** 3;
+	const x2 = x ** 3;
+	const z2 = z ** 3;
+	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
 
-var YAML_NODE_KINDS = [
-  'scalar',
-  'sequence',
-  'mapping'
-];
+	x *= 95.047;
+	y *= 100;
+	z *= 108.883;
 
-function compileStyleAliases(map) {
-  var result = {};
+	return [x, y, z];
+};
 
-  if (map !== null) {
-    Object.keys(map).forEach(function (style) {
-      map[style].forEach(function (alias) {
-        result[String(alias)] = style;
-      });
-    });
-  }
+convert$4.lab.lch = function (lab) {
+	const l = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	let h;
 
-  return result;
-}
+	const hr = Math.atan2(b, a);
+	h = hr * 360 / 2 / Math.PI;
 
-function Type(tag, options) {
-  options = options || {};
+	if (h < 0) {
+		h += 360;
+	}
 
-  Object.keys(options).forEach(function (name) {
-    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
-      throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
-    }
-  });
+	const c = Math.sqrt(a * a + b * b);
 
-  // TODO: Add tag format check.
-  this.tag          = tag;
-  this.kind         = options['kind']         || null;
-  this.resolve      = options['resolve']      || function () { return true; };
-  this.construct    = options['construct']    || function (data) { return data; };
-  this.instanceOf   = options['instanceOf']   || null;
-  this.predicate    = options['predicate']    || null;
-  this.represent    = options['represent']    || null;
-  this.defaultStyle = options['defaultStyle'] || null;
-  this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
+	return [l, c, h];
+};
 
-  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
-    throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
-  }
-}
+convert$4.lch.lab = function (lch) {
+	const l = lch[0];
+	const c = lch[1];
+	const h = lch[2];
 
-var type = Type;
+	const hr = h / 360 * 2 * Math.PI;
+	const a = c * Math.cos(hr);
+	const b = c * Math.sin(hr);
 
-/*eslint-disable max-len*/
+	return [l, a, b];
+};
 
+convert$4.rgb.ansi16 = function (args, saturation = null) {
+	const [r, g, b] = args;
+	let value = saturation === null ? convert$4.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
 
+	value = Math.round(value / 50);
 
+	if (value === 0) {
+		return 30;
+	}
 
+	let ansi = 30
+		+ ((Math.round(b / 255) << 2)
+		| (Math.round(g / 255) << 1)
+		| Math.round(r / 255));
 
+	if (value === 2) {
+		ansi += 60;
+	}
 
-function compileList(schema, name, result) {
-  var exclude = [];
+	return ansi;
+};
 
-  schema.include.forEach(function (includedSchema) {
-    result = compileList(includedSchema, name, result);
-  });
+convert$4.hsv.ansi16 = function (args) {
+	// Optimization here; we already know the value and don't need to get
+	// it converted for us.
+	return convert$4.rgb.ansi16(convert$4.hsv.rgb(args), args[2]);
+};
 
-  schema[name].forEach(function (currentType) {
-    result.forEach(function (previousType, previousIndex) {
-      if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
-        exclude.push(previousIndex);
-      }
-    });
+convert$4.rgb.ansi256 = function (args) {
+	const r = args[0];
+	const g = args[1];
+	const b = args[2];
 
-    result.push(currentType);
-  });
+	// We use the extended greyscale palette here, with the exception of
+	// black and white. normal palette only has 4 greyscale shades.
+	if (r === g && g === b) {
+		if (r < 8) {
+			return 16;
+		}
 
-  return result.filter(function (type, index) {
-    return exclude.indexOf(index) === -1;
-  });
-}
+		if (r > 248) {
+			return 231;
+		}
 
+		return Math.round(((r - 8) / 247) * 24) + 232;
+	}
 
-function compileMap(/* lists... */) {
-  var result = {
-        scalar: {},
-        sequence: {},
-        mapping: {},
-        fallback: {}
-      }, index, length;
+	const ansi = 16
+		+ (36 * Math.round(r / 255 * 5))
+		+ (6 * Math.round(g / 255 * 5))
+		+ Math.round(b / 255 * 5);
 
-  function collectType(type) {
-    result[type.kind][type.tag] = result['fallback'][type.tag] = type;
-  }
+	return ansi;
+};
 
-  for (index = 0, length = arguments.length; index < length; index += 1) {
-    arguments[index].forEach(collectType);
-  }
-  return result;
-}
+convert$4.ansi16.rgb = function (args) {
+	let color = args % 10;
 
+	// Handle greyscale
+	if (color === 0 || color === 7) {
+		if (args > 50) {
+			color += 3.5;
+		}
 
-function Schema(definition) {
-  this.include  = definition.include  || [];
-  this.implicit = definition.implicit || [];
-  this.explicit = definition.explicit || [];
+		color = color / 10.5 * 255;
 
-  this.implicit.forEach(function (type) {
-    if (type.loadKind && type.loadKind !== 'scalar') {
-      throw new exception('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
-    }
-  });
+		return [color, color, color];
+	}
 
-  this.compiledImplicit = compileList(this, 'implicit', []);
-  this.compiledExplicit = compileList(this, 'explicit', []);
-  this.compiledTypeMap  = compileMap(this.compiledImplicit, this.compiledExplicit);
-}
+	const mult = (~~(args > 50) + 1) * 0.5;
+	const r = ((color & 1) * mult) * 255;
+	const g = (((color >> 1) & 1) * mult) * 255;
+	const b = (((color >> 2) & 1) * mult) * 255;
+
+	return [r, g, b];
+};
 
+convert$4.ansi256.rgb = function (args) {
+	// Handle greyscale
+	if (args >= 232) {
+		const c = (args - 232) * 10 + 8;
+		return [c, c, c];
+	}
 
-Schema.DEFAULT = null;
+	args -= 16;
 
+	let rem;
+	const r = Math.floor(args / 36) / 5 * 255;
+	const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+	const b = (rem % 6) / 5 * 255;
 
-Schema.create = function createSchema() {
-  var schemas, types;
+	return [r, g, b];
+};
 
-  switch (arguments.length) {
-    case 1:
-      schemas = Schema.DEFAULT;
-      types = arguments[0];
-      break;
+convert$4.rgb.hex = function (args) {
+	const integer = ((Math.round(args[0]) & 0xFF) << 16)
+		+ ((Math.round(args[1]) & 0xFF) << 8)
+		+ (Math.round(args[2]) & 0xFF);
 
-    case 2:
-      schemas = arguments[0];
-      types = arguments[1];
-      break;
+	const string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
 
-    default:
-      throw new exception('Wrong number of arguments for Schema.create function');
-  }
+convert$4.hex.rgb = function (args) {
+	const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+	if (!match) {
+		return [0, 0, 0];
+	}
 
-  schemas = common.toArray(schemas);
-  types = common.toArray(types);
+	let colorString = match[0];
 
-  if (!schemas.every(function (schema) { return schema instanceof Schema; })) {
-    throw new exception('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
-  }
+	if (match[0].length === 3) {
+		colorString = colorString.split('').map(char => {
+			return char + char;
+		}).join('');
+	}
 
-  if (!types.every(function (type$1) { return type$1 instanceof type; })) {
-    throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
-  }
+	const integer = parseInt(colorString, 16);
+	const r = (integer >> 16) & 0xFF;
+	const g = (integer >> 8) & 0xFF;
+	const b = integer & 0xFF;
 
-  return new Schema({
-    include: schemas,
-    explicit: types
-  });
+	return [r, g, b];
 };
 
+convert$4.rgb.hcg = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const max = Math.max(Math.max(r, g), b);
+	const min = Math.min(Math.min(r, g), b);
+	const chroma = (max - min);
+	let grayscale;
+	let hue;
 
-var schema = Schema;
+	if (chroma < 1) {
+		grayscale = min / (1 - chroma);
+	} else {
+		grayscale = 0;
+	}
 
-var str = new type('tag:yaml.org,2002:str', {
-  kind: 'scalar',
-  construct: function (data) { return data !== null ? data : ''; }
-});
+	if (chroma <= 0) {
+		hue = 0;
+	} else
+	if (max === r) {
+		hue = ((g - b) / chroma) % 6;
+	} else
+	if (max === g) {
+		hue = 2 + (b - r) / chroma;
+	} else {
+		hue = 4 + (r - g) / chroma;
+	}
 
-var seq = new type('tag:yaml.org,2002:seq', {
-  kind: 'sequence',
-  construct: function (data) { return data !== null ? data : []; }
-});
+	hue /= 6;
+	hue %= 1;
 
-var map = new type('tag:yaml.org,2002:map', {
-  kind: 'mapping',
-  construct: function (data) { return data !== null ? data : {}; }
-});
+	return [hue * 360, chroma * 100, grayscale * 100];
+};
 
-var failsafe = new schema({
-  explicit: [
-    str,
-    seq,
-    map
-  ]
-});
+convert$4.hsl.hcg = function (hsl) {
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
 
-function resolveYamlNull(data) {
-  if (data === null) return true;
+	const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
 
-  var max = data.length;
+	let f = 0;
+	if (c < 1.0) {
+		f = (l - 0.5 * c) / (1.0 - c);
+	}
 
-  return (max === 1 && data === '~') ||
-         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
-}
+	return [hsl[0], c * 100, f * 100];
+};
 
-function constructYamlNull() {
-  return null;
-}
+convert$4.hsv.hcg = function (hsv) {
+	const s = hsv[1] / 100;
+	const v = hsv[2] / 100;
 
-function isNull(object) {
-  return object === null;
-}
+	const c = s * v;
+	let f = 0;
 
-var _null = new type('tag:yaml.org,2002:null', {
-  kind: 'scalar',
-  resolve: resolveYamlNull,
-  construct: constructYamlNull,
-  predicate: isNull,
-  represent: {
-    canonical: function () { return '~';    },
-    lowercase: function () { return 'null'; },
-    uppercase: function () { return 'NULL'; },
-    camelcase: function () { return 'Null'; }
-  },
-  defaultStyle: 'lowercase'
-});
+	if (c < 1.0) {
+		f = (v - c) / (1 - c);
+	}
 
-function resolveYamlBoolean(data) {
-  if (data === null) return false;
+	return [hsv[0], c * 100, f * 100];
+};
 
-  var max = data.length;
+convert$4.hcg.rgb = function (hcg) {
+	const h = hcg[0] / 360;
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
 
-  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
-         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
-}
+	if (c === 0.0) {
+		return [g * 255, g * 255, g * 255];
+	}
 
-function constructYamlBoolean(data) {
-  return data === 'true' ||
-         data === 'True' ||
-         data === 'TRUE';
-}
+	const pure = [0, 0, 0];
+	const hi = (h % 1) * 6;
+	const v = hi % 1;
+	const w = 1 - v;
+	let mg = 0;
 
-function isBoolean(object) {
-  return Object.prototype.toString.call(object) === '[object Boolean]';
-}
+	/* eslint-disable max-statements-per-line */
+	switch (Math.floor(hi)) {
+		case 0:
+			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
+		case 1:
+			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
+		case 2:
+			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
+		case 3:
+			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
+		case 4:
+			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
+		default:
+			pure[0] = 1; pure[1] = 0; pure[2] = w;
+	}
+	/* eslint-enable max-statements-per-line */
 
-var bool = new type('tag:yaml.org,2002:bool', {
-  kind: 'scalar',
-  resolve: resolveYamlBoolean,
-  construct: constructYamlBoolean,
-  predicate: isBoolean,
-  represent: {
-    lowercase: function (object) { return object ? 'true' : 'false'; },
-    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
-    camelcase: function (object) { return object ? 'True' : 'False'; }
-  },
-  defaultStyle: 'lowercase'
-});
+	mg = (1.0 - c) * g;
 
-function isHexCode(c) {
-  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
-         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
-         ((0x61/* a */ <= c) && (c <= 0x66/* f */));
-}
+	return [
+		(c * pure[0] + mg) * 255,
+		(c * pure[1] + mg) * 255,
+		(c * pure[2] + mg) * 255
+	];
+};
 
-function isOctCode(c) {
-  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
-}
+convert$4.hcg.hsv = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
 
-function isDecCode(c) {
-  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
-}
+	const v = c + g * (1.0 - c);
+	let f = 0;
 
-function resolveYamlInteger(data) {
-  if (data === null) return false;
+	if (v > 0.0) {
+		f = c / v;
+	}
 
-  var max = data.length,
-      index = 0,
-      hasDigits = false,
-      ch;
+	return [hcg[0], f * 100, v * 100];
+};
 
-  if (!max) return false;
+convert$4.hcg.hsl = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
 
-  ch = data[index];
+	const l = g * (1.0 - c) + 0.5 * c;
+	let s = 0;
 
-  // sign
-  if (ch === '-' || ch === '+') {
-    ch = data[++index];
-  }
+	if (l > 0.0 && l < 0.5) {
+		s = c / (2 * l);
+	} else
+	if (l >= 0.5 && l < 1.0) {
+		s = c / (2 * (1 - l));
+	}
 
-  if (ch === '0') {
-    // 0
-    if (index + 1 === max) return true;
-    ch = data[++index];
+	return [hcg[0], s * 100, l * 100];
+};
 
-    // base 2, base 8, base 16
+convert$4.hcg.hwb = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+	const v = c + g * (1.0 - c);
+	return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
 
-    if (ch === 'b') {
-      // base 2
-      index++;
+convert$4.hwb.hcg = function (hwb) {
+	const w = hwb[1] / 100;
+	const b = hwb[2] / 100;
+	const v = 1 - b;
+	const c = v - w;
+	let g = 0;
 
-      for (; index < max; index++) {
-        ch = data[index];
-        if (ch === '_') continue;
-        if (ch !== '0' && ch !== '1') return false;
-        hasDigits = true;
-      }
-      return hasDigits && ch !== '_';
-    }
+	if (c < 1) {
+		g = (v - c) / (1 - c);
+	}
 
+	return [hwb[0], c * 100, g * 100];
+};
 
-    if (ch === 'x') {
-      // base 16
-      index++;
-
-      for (; index < max; index++) {
-        ch = data[index];
-        if (ch === '_') continue;
-        if (!isHexCode(data.charCodeAt(index))) return false;
-        hasDigits = true;
-      }
-      return hasDigits && ch !== '_';
-    }
-
-    // base 8
-    for (; index < max; index++) {
-      ch = data[index];
-      if (ch === '_') continue;
-      if (!isOctCode(data.charCodeAt(index))) return false;
-      hasDigits = true;
-    }
-    return hasDigits && ch !== '_';
-  }
-
-  // base 10 (except 0) or base 60
+convert$4.apple.rgb = function (apple) {
+	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
+};
 
-  // value should not start with `_`;
-  if (ch === '_') return false;
+convert$4.rgb.apple = function (rgb) {
+	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
+};
 
-  for (; index < max; index++) {
-    ch = data[index];
-    if (ch === '_') continue;
-    if (ch === ':') break;
-    if (!isDecCode(data.charCodeAt(index))) {
-      return false;
-    }
-    hasDigits = true;
-  }
+convert$4.gray.rgb = function (args) {
+	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+};
 
-  // Should have digits and should not end with `_`
-  if (!hasDigits || ch === '_') return false;
+convert$4.gray.hsl = function (args) {
+	return [0, 0, args[0]];
+};
 
-  // if !base60 - done;
-  if (ch !== ':') return true;
+convert$4.gray.hsv = convert$4.gray.hsl;
 
-  // base60 almost not used, no needs to optimize
-  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
-}
+convert$4.gray.hwb = function (gray) {
+	return [0, 100, gray[0]];
+};
 
-function constructYamlInteger(data) {
-  var value = data, sign = 1, ch, base, digits = [];
+convert$4.gray.cmyk = function (gray) {
+	return [0, 0, 0, gray[0]];
+};
 
-  if (value.indexOf('_') !== -1) {
-    value = value.replace(/_/g, '');
-  }
+convert$4.gray.lab = function (gray) {
+	return [gray[0], 0, 0];
+};
 
-  ch = value[0];
+convert$4.gray.hex = function (gray) {
+	const val = Math.round(gray[0] / 100 * 255) & 0xFF;
+	const integer = (val << 16) + (val << 8) + val;
 
-  if (ch === '-' || ch === '+') {
-    if (ch === '-') sign = -1;
-    value = value.slice(1);
-    ch = value[0];
-  }
+	const string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
 
-  if (value === '0') return 0;
+convert$4.rgb.gray = function (rgb) {
+	const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+	return [val / 255 * 100];
+};
 
-  if (ch === '0') {
-    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
-    if (value[1] === 'x') return sign * parseInt(value, 16);
-    return sign * parseInt(value, 8);
-  }
+const conversions$4 = conversions$5;
 
-  if (value.indexOf(':') !== -1) {
-    value.split(':').forEach(function (v) {
-      digits.unshift(parseInt(v, 10));
-    });
+/*
+	This function routes a model to all other models.
 
-    value = 0;
-    base = 1;
+	all functions that are routed have a property `.conversion` attached
+	to the returned synthetic function. This property is an array
+	of strings, each with the steps in between the 'from' and 'to'
+	color models (inclusive).
 
-    digits.forEach(function (d) {
-      value += (d * base);
-      base *= 60;
-    });
+	conversions that are not possible simply are not included.
+*/
 
-    return sign * value;
+function buildGraph$1() {
+	const graph = {};
+	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
+	const models = Object.keys(conversions$4);
 
-  }
+	for (let len = models.length, i = 0; i < len; i++) {
+		graph[models[i]] = {
+			// http://jsperf.com/1-vs-infinity
+			// micro-opt, but this is simple.
+			distance: -1,
+			parent: null
+		};
+	}
 
-  return sign * parseInt(value, 10);
+	return graph;
 }
 
-function isInteger(object) {
-  return (Object.prototype.toString.call(object)) === '[object Number]' &&
-         (object % 1 === 0 && !common.isNegativeZero(object));
-}
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS$1(fromModel) {
+	const graph = buildGraph$1();
+	const queue = [fromModel]; // Unshift -> queue -> pop
 
-var int_1 = new type('tag:yaml.org,2002:int', {
-  kind: 'scalar',
-  resolve: resolveYamlInteger,
-  construct: constructYamlInteger,
-  predicate: isInteger,
-  represent: {
-    binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
-    octal:       function (obj) { return obj >= 0 ? '0'  + obj.toString(8) : '-0'  + obj.toString(8).slice(1); },
-    decimal:     function (obj) { return obj.toString(10); },
-    /* eslint-disable max-len */
-    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }
-  },
-  defaultStyle: 'decimal',
-  styleAliases: {
-    binary:      [ 2,  'bin' ],
-    octal:       [ 8,  'oct' ],
-    decimal:     [ 10, 'dec' ],
-    hexadecimal: [ 16, 'hex' ]
-  }
-});
+	graph[fromModel].distance = 0;
 
-var YAML_FLOAT_PATTERN = new RegExp(
-  // 2.5e4, 2.5 and integers
-  '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
-  // .2e4, .2
-  // special case, seems not from spec
-  '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
-  // 20:59
-  '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' +
-  // .inf
-  '|[-+]?\\.(?:inf|Inf|INF)' +
-  // .nan
-  '|\\.(?:nan|NaN|NAN))$');
+	while (queue.length) {
+		const current = queue.pop();
+		const adjacents = Object.keys(conversions$4[current]);
 
-function resolveYamlFloat(data) {
-  if (data === null) return false;
+		for (let len = adjacents.length, i = 0; i < len; i++) {
+			const adjacent = adjacents[i];
+			const node = graph[adjacent];
 
-  if (!YAML_FLOAT_PATTERN.test(data) ||
-      // Quick hack to not allow integers end with `_`
-      // Probably should update regexp & check speed
-      data[data.length - 1] === '_') {
-    return false;
-  }
+			if (node.distance === -1) {
+				node.distance = graph[current].distance + 1;
+				node.parent = current;
+				queue.unshift(adjacent);
+			}
+		}
+	}
 
-  return true;
+	return graph;
 }
 
-function constructYamlFloat(data) {
-  var value, sign, base, digits;
+function link$2(from, to) {
+	return function (args) {
+		return to(from(args));
+	};
+}
 
-  value  = data.replace(/_/g, '').toLowerCase();
-  sign   = value[0] === '-' ? -1 : 1;
-  digits = [];
+function wrapConversion$1(toModel, graph) {
+	const path = [graph[toModel].parent, toModel];
+	let fn = conversions$4[graph[toModel].parent][toModel];
 
-  if ('+-'.indexOf(value[0]) >= 0) {
-    value = value.slice(1);
-  }
+	let cur = graph[toModel].parent;
+	while (graph[cur].parent) {
+		path.unshift(graph[cur].parent);
+		fn = link$2(conversions$4[graph[cur].parent][cur], fn);
+		cur = graph[cur].parent;
+	}
 
-  if (value === '.inf') {
-    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+	fn.conversion = path;
+	return fn;
+}
 
-  } else if (value === '.nan') {
-    return NaN;
+var route$3 = function (fromModel) {
+	const graph = deriveBFS$1(fromModel);
+	const conversion = {};
 
-  } else if (value.indexOf(':') >= 0) {
-    value.split(':').forEach(function (v) {
-      digits.unshift(parseFloat(v, 10));
-    });
+	const models = Object.keys(graph);
+	for (let len = models.length, i = 0; i < len; i++) {
+		const toModel = models[i];
+		const node = graph[toModel];
 
-    value = 0.0;
-    base = 1;
+		if (node.parent === null) {
+			// No possible conversion, or this node is the source model.
+			continue;
+		}
 
-    digits.forEach(function (d) {
-      value += d * base;
-      base *= 60;
-    });
+		conversion[toModel] = wrapConversion$1(toModel, graph);
+	}
 
-    return sign * value;
+	return conversion;
+};
 
-  }
-  return sign * parseFloat(value, 10);
-}
+const conversions$3 = conversions$5;
+const route$2 = route$3;
 
+const convert$3 = {};
 
-var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+const models$1 = Object.keys(conversions$3);
 
-function representYamlFloat(object, style) {
-  var res;
+function wrapRaw$1(fn) {
+	const wrappedFn = function (...args) {
+		const arg0 = args[0];
+		if (arg0 === undefined || arg0 === null) {
+			return arg0;
+		}
 
-  if (isNaN(object)) {
-    switch (style) {
-      case 'lowercase': return '.nan';
-      case 'uppercase': return '.NAN';
-      case 'camelcase': return '.NaN';
-    }
-  } else if (Number.POSITIVE_INFINITY === object) {
-    switch (style) {
-      case 'lowercase': return '.inf';
-      case 'uppercase': return '.INF';
-      case 'camelcase': return '.Inf';
-    }
-  } else if (Number.NEGATIVE_INFINITY === object) {
-    switch (style) {
-      case 'lowercase': return '-.inf';
-      case 'uppercase': return '-.INF';
-      case 'camelcase': return '-.Inf';
-    }
-  } else if (common.isNegativeZero(object)) {
-    return '-0.0';
-  }
+		if (arg0.length > 1) {
+			args = arg0;
+		}
 
-  res = object.toString(10);
+		return fn(args);
+	};
 
-  // JS stringifier can build scientific format without dots: 5e-100,
-  // while YAML requres dot: 5.e-100. Fix it with simple hack
+	// Preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
 
-  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
+	return wrappedFn;
 }
 
-function isFloat(object) {
-  return (Object.prototype.toString.call(object) === '[object Number]') &&
-         (object % 1 !== 0 || common.isNegativeZero(object));
-}
+function wrapRounded$1(fn) {
+	const wrappedFn = function (...args) {
+		const arg0 = args[0];
 
-var float_1 = new type('tag:yaml.org,2002:float', {
-  kind: 'scalar',
-  resolve: resolveYamlFloat,
-  construct: constructYamlFloat,
-  predicate: isFloat,
-  represent: representYamlFloat,
-  defaultStyle: 'lowercase'
-});
+		if (arg0 === undefined || arg0 === null) {
+			return arg0;
+		}
 
-var json = new schema({
-  include: [
-    failsafe
-  ],
-  implicit: [
-    _null,
-    bool,
-    int_1,
-    float_1
-  ]
-});
+		if (arg0.length > 1) {
+			args = arg0;
+		}
 
-var core = new schema({
-  include: [
-    json
-  ]
-});
+		const result = fn(args);
 
-var YAML_DATE_REGEXP = new RegExp(
-  '^([0-9][0-9][0-9][0-9])'          + // [1] year
-  '-([0-9][0-9])'                    + // [2] month
-  '-([0-9][0-9])$');                   // [3] day
+		// We're assuming the result is an array here.
+		// see notice in conversions.js; don't use box types
+		// in conversion functions.
+		if (typeof result === 'object') {
+			for (let len = result.length, i = 0; i < len; i++) {
+				result[i] = Math.round(result[i]);
+			}
+		}
 
-var YAML_TIMESTAMP_REGEXP = new RegExp(
-  '^([0-9][0-9][0-9][0-9])'          + // [1] year
-  '-([0-9][0-9]?)'                   + // [2] month
-  '-([0-9][0-9]?)'                   + // [3] day
-  '(?:[Tt]|[ \\t]+)'                 + // ...
-  '([0-9][0-9]?)'                    + // [4] hour
-  ':([0-9][0-9])'                    + // [5] minute
-  ':([0-9][0-9])'                    + // [6] second
-  '(?:\\.([0-9]*))?'                 + // [7] fraction
-  '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
-  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute
+		return result;
+	};
 
-function resolveYamlTimestamp(data) {
-  if (data === null) return false;
-  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
-  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
-  return false;
+	// Preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
+
+	return wrappedFn;
 }
 
-function constructYamlTimestamp(data) {
-  var match, year, month, day, hour, minute, second, fraction = 0,
-      delta = null, tz_hour, tz_minute, date;
+models$1.forEach(fromModel => {
+	convert$3[fromModel] = {};
 
-  match = YAML_DATE_REGEXP.exec(data);
-  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+	Object.defineProperty(convert$3[fromModel], 'channels', {value: conversions$3[fromModel].channels});
+	Object.defineProperty(convert$3[fromModel], 'labels', {value: conversions$3[fromModel].labels});
 
-  if (match === null) throw new Error('Date resolve error');
+	const routes = route$2(fromModel);
+	const routeModels = Object.keys(routes);
 
-  // match: [1] year [2] month [3] day
+	routeModels.forEach(toModel => {
+		const fn = routes[toModel];
 
-  year = +(match[1]);
-  month = +(match[2]) - 1; // JS month starts with 0
-  day = +(match[3]);
+		convert$3[fromModel][toModel] = wrapRounded$1(fn);
+		convert$3[fromModel][toModel].raw = wrapRaw$1(fn);
+	});
+});
 
-  if (!match[4]) { // no hour
-    return new Date(Date.UTC(year, month, day));
-  }
+var colorConvert$1 = convert$3;
 
-  // match: [4] hour [5] minute [6] second [7] fraction
+(function (module) {
 
-  hour = +(match[4]);
-  minute = +(match[5]);
-  second = +(match[6]);
+const wrapAnsi16 = (fn, offset) => (...args) => {
+	const code = fn(...args);
+	return `\u001B[${code + offset}m`;
+};
 
-  if (match[7]) {
-    fraction = match[7].slice(0, 3);
-    while (fraction.length < 3) { // milli-seconds
-      fraction += '0';
-    }
-    fraction = +fraction;
-  }
+const wrapAnsi256 = (fn, offset) => (...args) => {
+	const code = fn(...args);
+	return `\u001B[${38 + offset};5;${code}m`;
+};
 
-  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
+const wrapAnsi16m = (fn, offset) => (...args) => {
+	const rgb = fn(...args);
+	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
 
-  if (match[9]) {
-    tz_hour = +(match[10]);
-    tz_minute = +(match[11] || 0);
-    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
-    if (match[9] === '-') delta = -delta;
-  }
+const ansi2ansi = n => n;
+const rgb2rgb = (r, g, b) => [r, g, b];
 
-  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+const setLazyProperty = (object, property, get) => {
+	Object.defineProperty(object, property, {
+		get: () => {
+			const value = get();
 
-  if (delta) date.setTime(date.getTime() - delta);
+			Object.defineProperty(object, property, {
+				value,
+				enumerable: true,
+				configurable: true
+			});
 
-  return date;
-}
+			return value;
+		},
+		enumerable: true,
+		configurable: true
+	});
+};
 
-function representYamlTimestamp(object /*, style*/) {
-  return object.toISOString();
-}
+/** @type {typeof import('color-convert')} */
+let colorConvert;
+const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+	if (colorConvert === undefined) {
+		colorConvert = colorConvert$1;
+	}
 
-var timestamp = new type('tag:yaml.org,2002:timestamp', {
-  kind: 'scalar',
-  resolve: resolveYamlTimestamp,
-  construct: constructYamlTimestamp,
-  instanceOf: Date,
-  represent: representYamlTimestamp
-});
+	const offset = isBackground ? 10 : 0;
+	const styles = {};
 
-function resolveYamlMerge(data) {
-  return data === '<<' || data === null;
-}
+	for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+		const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
+		if (sourceSpace === targetSpace) {
+			styles[name] = wrap(identity, offset);
+		} else if (typeof suite === 'object') {
+			styles[name] = wrap(suite[targetSpace], offset);
+		}
+	}
 
-var merge = new type('tag:yaml.org,2002:merge', {
-  kind: 'scalar',
-  resolve: resolveYamlMerge
-});
+	return styles;
+};
 
-/*eslint-disable no-bitwise*/
+function assembleStyles() {
+	const codes = new Map();
+	const styles = {
+		modifier: {
+			reset: [0, 0],
+			// 21 isn't widely supported and 22 does the same thing
+			bold: [1, 22],
+			dim: [2, 22],
+			italic: [3, 23],
+			underline: [4, 24],
+			inverse: [7, 27],
+			hidden: [8, 28],
+			strikethrough: [9, 29]
+		},
+		color: {
+			black: [30, 39],
+			red: [31, 39],
+			green: [32, 39],
+			yellow: [33, 39],
+			blue: [34, 39],
+			magenta: [35, 39],
+			cyan: [36, 39],
+			white: [37, 39],
 
-var NodeBuffer;
+			// Bright color
+			blackBright: [90, 39],
+			redBright: [91, 39],
+			greenBright: [92, 39],
+			yellowBright: [93, 39],
+			blueBright: [94, 39],
+			magentaBright: [95, 39],
+			cyanBright: [96, 39],
+			whiteBright: [97, 39]
+		},
+		bgColor: {
+			bgBlack: [40, 49],
+			bgRed: [41, 49],
+			bgGreen: [42, 49],
+			bgYellow: [43, 49],
+			bgBlue: [44, 49],
+			bgMagenta: [45, 49],
+			bgCyan: [46, 49],
+			bgWhite: [47, 49],
 
-try {
-  // A trick for browserified version, to not include `Buffer` shim
-  var _require = commonjsRequire;
-  NodeBuffer = _require('buffer').Buffer;
-} catch (__) {}
+			// Bright color
+			bgBlackBright: [100, 49],
+			bgRedBright: [101, 49],
+			bgGreenBright: [102, 49],
+			bgYellowBright: [103, 49],
+			bgBlueBright: [104, 49],
+			bgMagentaBright: [105, 49],
+			bgCyanBright: [106, 49],
+			bgWhiteBright: [107, 49]
+		}
+	};
 
+	// Alias bright black as gray (and grey)
+	styles.color.gray = styles.color.blackBright;
+	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+	styles.color.grey = styles.color.blackBright;
+	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
 
+	for (const [groupName, group] of Object.entries(styles)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
 
+			group[styleName] = styles[styleName];
 
-// [ 64, 65, 66 ] -> [ padding, CR, LF ]
-var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
+			codes.set(style[0], style[1]);
+		}
 
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
 
-function resolveYamlBinary(data) {
-  if (data === null) return false;
+	Object.defineProperty(styles, 'codes', {
+		value: codes,
+		enumerable: false
+	});
 
-  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
+	styles.color.close = '\u001B[39m';
+	styles.bgColor.close = '\u001B[49m';
 
-  // Convert one by one.
-  for (idx = 0; idx < max; idx++) {
-    code = map.indexOf(data.charAt(idx));
+	setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
+	setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
+	setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
+	setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
+	setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
+	setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
 
-    // Skip CR/LF
-    if (code > 64) continue;
+	return styles;
+}
 
-    // Fail on illegal characters
-    if (code < 0) return false;
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+	enumerable: true,
+	get: assembleStyles
+});
+}(ansiStyles$2));
 
-    bitlen += 6;
-  }
+var hasFlag$4 = (flag, argv = process.argv) => {
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf('--');
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+};
 
-  // If there are any bits left, source was corrupted
-  return (bitlen % 8) === 0;
-}
+const os$2 = require$$0$2;
+const tty = tty$1;
+const hasFlag$3 = hasFlag$4;
 
-function constructYamlBinary(data) {
-  var idx, tailbits,
-      input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
-      max = input.length,
-      map = BASE64_MAP,
-      bits = 0,
-      result = [];
-
-  // Collect by 6*4 bits (3 bytes)
-
-  for (idx = 0; idx < max; idx++) {
-    if ((idx % 4 === 0) && idx) {
-      result.push((bits >> 16) & 0xFF);
-      result.push((bits >> 8) & 0xFF);
-      result.push(bits & 0xFF);
-    }
-
-    bits = (bits << 6) | map.indexOf(input.charAt(idx));
-  }
-
-  // Dump tail
+const {env: env$2} = process;
 
-  tailbits = (max % 4) * 6;
+let forceColor$1;
+if (hasFlag$3('no-color') ||
+	hasFlag$3('no-colors') ||
+	hasFlag$3('color=false') ||
+	hasFlag$3('color=never')) {
+	forceColor$1 = 0;
+} else if (hasFlag$3('color') ||
+	hasFlag$3('colors') ||
+	hasFlag$3('color=true') ||
+	hasFlag$3('color=always')) {
+	forceColor$1 = 1;
+}
 
-  if (tailbits === 0) {
-    result.push((bits >> 16) & 0xFF);
-    result.push((bits >> 8) & 0xFF);
-    result.push(bits & 0xFF);
-  } else if (tailbits === 18) {
-    result.push((bits >> 10) & 0xFF);
-    result.push((bits >> 2) & 0xFF);
-  } else if (tailbits === 12) {
-    result.push((bits >> 4) & 0xFF);
-  }
+if ('FORCE_COLOR' in env$2) {
+	if (env$2.FORCE_COLOR === 'true') {
+		forceColor$1 = 1;
+	} else if (env$2.FORCE_COLOR === 'false') {
+		forceColor$1 = 0;
+	} else {
+		forceColor$1 = env$2.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env$2.FORCE_COLOR, 10), 3);
+	}
+}
 
-  // Wrap into Buffer for NodeJS and leave Array for browser
-  if (NodeBuffer) {
-    // Support node 6.+ Buffer API when available
-    return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
-  }
+function translateLevel$2(level) {
+	if (level === 0) {
+		return false;
+	}
 
-  return result;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
 }
 
-function representYamlBinary(object /*, style*/) {
-  var result = '', bits = 0, idx, tail,
-      max = object.length,
-      map = BASE64_MAP;
-
-  // Convert every three bytes to 4 ASCII characters.
+function supportsColor$2(haveStream, streamIsTTY) {
+	if (forceColor$1 === 0) {
+		return 0;
+	}
 
-  for (idx = 0; idx < max; idx++) {
-    if ((idx % 3 === 0) && idx) {
-      result += map[(bits >> 18) & 0x3F];
-      result += map[(bits >> 12) & 0x3F];
-      result += map[(bits >> 6) & 0x3F];
-      result += map[bits & 0x3F];
-    }
+	if (hasFlag$3('color=16m') ||
+		hasFlag$3('color=full') ||
+		hasFlag$3('color=truecolor')) {
+		return 3;
+	}
 
-    bits = (bits << 8) + object[idx];
-  }
+	if (hasFlag$3('color=256')) {
+		return 2;
+	}
 
-  // Dump tail
+	if (haveStream && !streamIsTTY && forceColor$1 === undefined) {
+		return 0;
+	}
 
-  tail = max % 3;
+	const min = forceColor$1 || 0;
 
-  if (tail === 0) {
-    result += map[(bits >> 18) & 0x3F];
-    result += map[(bits >> 12) & 0x3F];
-    result += map[(bits >> 6) & 0x3F];
-    result += map[bits & 0x3F];
-  } else if (tail === 2) {
-    result += map[(bits >> 10) & 0x3F];
-    result += map[(bits >> 4) & 0x3F];
-    result += map[(bits << 2) & 0x3F];
-    result += map[64];
-  } else if (tail === 1) {
-    result += map[(bits >> 2) & 0x3F];
-    result += map[(bits << 4) & 0x3F];
-    result += map[64];
-    result += map[64];
-  }
+	if (env$2.TERM === 'dumb') {
+		return min;
+	}
 
-  return result;
-}
+	if (process.platform === 'win32') {
+		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+		const osRelease = os$2.release().split('.');
+		if (
+			Number(osRelease[0]) >= 10 &&
+			Number(osRelease[2]) >= 10586
+		) {
+			return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		}
 
-function isBinary(object) {
-  return NodeBuffer && NodeBuffer.isBuffer(object);
-}
+		return 1;
+	}
 
-var binary = new type('tag:yaml.org,2002:binary', {
-  kind: 'scalar',
-  resolve: resolveYamlBinary,
-  construct: constructYamlBinary,
-  predicate: isBinary,
-  represent: representYamlBinary
-});
+	if ('CI' in env$2) {
+		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env$2) || env$2.CI_NAME === 'codeship') {
+			return 1;
+		}
 
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-var _toString       = Object.prototype.toString;
+		return min;
+	}
 
-function resolveYamlOmap(data) {
-  if (data === null) return true;
+	if ('TEAMCITY_VERSION' in env$2) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$2.TEAMCITY_VERSION) ? 1 : 0;
+	}
 
-  var objectKeys = [], index, length, pair, pairKey, pairHasKey,
-      object = data;
+	if (env$2.COLORTERM === 'truecolor') {
+		return 3;
+	}
 
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
-    pairHasKey = false;
+	if ('TERM_PROGRAM' in env$2) {
+		const version = parseInt((env$2.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
 
-    if (_toString.call(pair) !== '[object Object]') return false;
+		switch (env$2.TERM_PROGRAM) {
+			case 'iTerm.app':
+				return version >= 3 ? 3 : 2;
+			case 'Apple_Terminal':
+				return 2;
+			// No default
+		}
+	}
 
-    for (pairKey in pair) {
-      if (_hasOwnProperty.call(pair, pairKey)) {
-        if (!pairHasKey) pairHasKey = true;
-        else return false;
-      }
-    }
+	if (/-256(color)?$/i.test(env$2.TERM)) {
+		return 2;
+	}
 
-    if (!pairHasKey) return false;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$2.TERM)) {
+		return 1;
+	}
 
-    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
-    else return false;
-  }
+	if ('COLORTERM' in env$2) {
+		return 1;
+	}
 
-  return true;
+	return min;
 }
 
-function constructYamlOmap(data) {
-  return data !== null ? data : [];
+function getSupportLevel$1(stream) {
+	const level = supportsColor$2(stream, stream && stream.isTTY);
+	return translateLevel$2(level);
 }
 
-var omap = new type('tag:yaml.org,2002:omap', {
-  kind: 'sequence',
-  resolve: resolveYamlOmap,
-  construct: constructYamlOmap
-});
-
-var _toString$1 = Object.prototype.toString;
-
-function resolveYamlPairs(data) {
-  if (data === null) return true;
+var supportsColor_1$1 = {
+	supportsColor: getSupportLevel$1,
+	stdout: translateLevel$2(supportsColor$2(true, tty.isatty(1))),
+	stderr: translateLevel$2(supportsColor$2(true, tty.isatty(2)))
+};
 
-  var index, length, pair, keys, result,
-      object = data;
+const stringReplaceAll$1 = (string, substring, replacer) => {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
 
-  result = new Array(object.length);
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
 
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
 
-    if (_toString$1.call(pair) !== '[object Object]') return false;
+const stringEncaseCRLFWithFirstIndex$1 = (string, prefix, postfix, index) => {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
 
-    keys = Object.keys(pair);
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
 
-    if (keys.length !== 1) return false;
+var util$4 = {
+	stringReplaceAll: stringReplaceAll$1,
+	stringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex$1
+};
 
-    result[index] = [ keys[0], pair[keys[0]] ];
-  }
+const TEMPLATE_REGEX$1 = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX$1 = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX$1 = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX$1 = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
 
-  return true;
-}
+const ESCAPES$1 = new Map([
+	['n', '\n'],
+	['r', '\r'],
+	['t', '\t'],
+	['b', '\b'],
+	['f', '\f'],
+	['v', '\v'],
+	['0', '\0'],
+	['\\', '\\'],
+	['e', '\u001B'],
+	['a', '\u0007']
+]);
 
-function constructYamlPairs(data) {
-  if (data === null) return [];
+function unescape$1(c) {
+	const u = c[0] === 'u';
+	const bracket = c[1] === '{';
 
-  var index, length, pair, keys, result,
-      object = data;
+	if ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+		return String.fromCharCode(parseInt(c.slice(1), 16));
+	}
 
-  result = new Array(object.length);
+	if (u && bracket) {
+		return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+	}
 
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
+	return ESCAPES$1.get(c) || c;
+}
 
-    keys = Object.keys(pair);
+function parseArguments$1(name, arguments_) {
+	const results = [];
+	const chunks = arguments_.trim().split(/\s*,\s*/g);
+	let matches;
 
-    result[index] = [ keys[0], pair[keys[0]] ];
-  }
+	for (const chunk of chunks) {
+		const number = Number(chunk);
+		if (!Number.isNaN(number)) {
+			results.push(number);
+		} else if ((matches = chunk.match(STRING_REGEX$1))) {
+			results.push(matches[2].replace(ESCAPE_REGEX$1, (m, escape, character) => escape ? unescape$1(escape) : character));
+		} else {
+			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+		}
+	}
 
-  return result;
+	return results;
 }
 
-var pairs = new type('tag:yaml.org,2002:pairs', {
-  kind: 'sequence',
-  resolve: resolveYamlPairs,
-  construct: constructYamlPairs
-});
-
-var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-
-function resolveYamlSet(data) {
-  if (data === null) return true;
+function parseStyle$1(style) {
+	STYLE_REGEX$1.lastIndex = 0;
 
-  var key, object = data;
+	const results = [];
+	let matches;
 
-  for (key in object) {
-    if (_hasOwnProperty$1.call(object, key)) {
-      if (object[key] !== null) return false;
-    }
-  }
+	while ((matches = STYLE_REGEX$1.exec(style)) !== null) {
+		const name = matches[1];
 
-  return true;
-}
+		if (matches[2]) {
+			const args = parseArguments$1(name, matches[2]);
+			results.push([name].concat(args));
+		} else {
+			results.push([name]);
+		}
+	}
 
-function constructYamlSet(data) {
-  return data !== null ? data : {};
+	return results;
 }
 
-var set = new type('tag:yaml.org,2002:set', {
-  kind: 'mapping',
-  resolve: resolveYamlSet,
-  construct: constructYamlSet
-});
+function buildStyle$1(chalk, styles) {
+	const enabled = {};
 
-var default_safe = new schema({
-  include: [
-    core
-  ],
-  implicit: [
-    timestamp,
-    merge
-  ],
-  explicit: [
-    binary,
-    omap,
-    pairs,
-    set
-  ]
-});
+	for (const layer of styles) {
+		for (const style of layer.styles) {
+			enabled[style[0]] = layer.inverse ? null : style.slice(1);
+		}
+	}
 
-function resolveJavascriptUndefined() {
-  return true;
-}
+	let current = chalk;
+	for (const [styleName, styles] of Object.entries(enabled)) {
+		if (!Array.isArray(styles)) {
+			continue;
+		}
 
-function constructJavascriptUndefined() {
-  /*eslint-disable no-undefined*/
-  return undefined;
-}
+		if (!(styleName in current)) {
+			throw new Error(`Unknown Chalk style: ${styleName}`);
+		}
 
-function representJavascriptUndefined() {
-  return '';
-}
+		current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
+	}
 
-function isUndefined(object) {
-  return typeof object === 'undefined';
+	return current;
 }
 
-var _undefined = new type('tag:yaml.org,2002:js/undefined', {
-  kind: 'scalar',
-  resolve: resolveJavascriptUndefined,
-  construct: constructJavascriptUndefined,
-  predicate: isUndefined,
-  represent: representJavascriptUndefined
-});
+var templates$1 = (chalk, temporary) => {
+	const styles = [];
+	const chunks = [];
+	let chunk = [];
 
-function resolveJavascriptRegExp(data) {
-  if (data === null) return false;
-  if (data.length === 0) return false;
+	// eslint-disable-next-line max-params
+	temporary.replace(TEMPLATE_REGEX$1, (m, escapeCharacter, inverse, style, close, character) => {
+		if (escapeCharacter) {
+			chunk.push(unescape$1(escapeCharacter));
+		} else if (style) {
+			const string = chunk.join('');
+			chunk = [];
+			chunks.push(styles.length === 0 ? string : buildStyle$1(chalk, styles)(string));
+			styles.push({inverse, styles: parseStyle$1(style)});
+		} else if (close) {
+			if (styles.length === 0) {
+				throw new Error('Found extraneous } in Chalk template literal');
+			}
 
-  var regexp = data,
-      tail   = /\/([gim]*)$/.exec(data),
-      modifiers = '';
+			chunks.push(buildStyle$1(chalk, styles)(chunk.join('')));
+			chunk = [];
+			styles.pop();
+		} else {
+			chunk.push(character);
+		}
+	});
 
-  // if regexp starts with '/' it can have modifiers and must be properly closed
-  // `/foo/gim` - modifiers tail can be maximum 3 chars
-  if (regexp[0] === '/') {
-    if (tail) modifiers = tail[1];
+	chunks.push(chunk.join(''));
 
-    if (modifiers.length > 3) return false;
-    // if expression starts with /, is should be properly terminated
-    if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;
-  }
+	if (styles.length > 0) {
+		const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+		throw new Error(errMessage);
+	}
 
-  return true;
-}
+	return chunks.join('');
+};
 
-function constructJavascriptRegExp(data) {
-  var regexp = data,
-      tail   = /\/([gim]*)$/.exec(data),
-      modifiers = '';
+const ansiStyles$1 = ansiStyles$2.exports;
+const {stdout: stdoutColor, stderr: stderrColor} = supportsColor_1$1;
+const {
+	stringReplaceAll,
+	stringEncaseCRLFWithFirstIndex
+} = util$4;
 
-  // `/foo/gim` - tail can be maximum 4 chars
-  if (regexp[0] === '/') {
-    if (tail) modifiers = tail[1];
-    regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
-  }
+const {isArray: isArray$2} = Array;
 
-  return new RegExp(regexp, modifiers);
-}
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = [
+	'ansi',
+	'ansi',
+	'ansi256',
+	'ansi16m'
+];
 
-function representJavascriptRegExp(object /*, style*/) {
-  var result = '/' + object.source + '/';
+const styles = Object.create(null);
 
-  if (object.global) result += 'g';
-  if (object.multiline) result += 'm';
-  if (object.ignoreCase) result += 'i';
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+		throw new Error('The `level` option should be an integer from 0 to 3');
+	}
 
-  return result;
-}
+	// Detect level if not set manually
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === undefined ? colorLevel : options.level;
+};
 
-function isRegExp(object) {
-  return Object.prototype.toString.call(object) === '[object RegExp]';
+class ChalkClass {
+	constructor(options) {
+		// eslint-disable-next-line no-constructor-return
+		return chalkFactory(options);
+	}
 }
 
-var regexp = new type('tag:yaml.org,2002:js/regexp', {
-  kind: 'scalar',
-  resolve: resolveJavascriptRegExp,
-  construct: constructJavascriptRegExp,
-  predicate: isRegExp,
-  represent: representJavascriptRegExp
-});
-
-var esprima;
+const chalkFactory = options => {
+	const chalk = {};
+	applyOptions(chalk, options);
 
-// Browserified version does not have esprima
-//
-// 1. For node.js just require module as deps
-// 2. For browser try to require mudule via external AMD system.
-//    If not found - try to fallback to window.esprima. If not
-//    found too - then fail to parse.
-//
-try {
-  // workaround to exclude package from browserify list.
-  var _require$1 = commonjsRequire;
-  esprima = _require$1('esprima');
-} catch (_) {
-  /*global window */
-  if (typeof window !== 'undefined') esprima = window.esprima;
-}
+	chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
 
+	Object.setPrototypeOf(chalk, Chalk.prototype);
+	Object.setPrototypeOf(chalk.template, chalk);
 
+	chalk.template.constructor = () => {
+		throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
+	};
 
-function resolveJavascriptFunction(data) {
-  if (data === null) return false;
+	chalk.template.Instance = ChalkClass;
 
-  try {
-    var source = '(' + data + ')',
-        ast    = esprima.parse(source, { range: true });
-
-    if (ast.type                    !== 'Program'             ||
-        ast.body.length             !== 1                     ||
-        ast.body[0].type            !== 'ExpressionStatement' ||
-        (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&
-          ast.body[0].expression.type !== 'FunctionExpression')) {
-      return false;
-    }
+	return chalk.template;
+};
 
-    return true;
-  } catch (err) {
-    return false;
-  }
+function Chalk(options) {
+	return chalkFactory(options);
 }
 
-function constructJavascriptFunction(data) {
-  /*jslint evil:true*/
-
-  var source = '(' + data + ')',
-      ast    = esprima.parse(source, { range: true }),
-      params = [],
-      body;
-
-  if (ast.type                    !== 'Program'             ||
-      ast.body.length             !== 1                     ||
-      ast.body[0].type            !== 'ExpressionStatement' ||
-      (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&
-        ast.body[0].expression.type !== 'FunctionExpression')) {
-    throw new Error('Failed to resolve function');
-  }
-
-  ast.body[0].expression.params.forEach(function (param) {
-    params.push(param.name);
-  });
+for (const [styleName, style] of Object.entries(ansiStyles$1)) {
+	styles[styleName] = {
+		get() {
+			const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+			Object.defineProperty(this, styleName, {value: builder});
+			return builder;
+		}
+	};
+}
 
-  body = ast.body[0].expression.body.range;
+styles.visible = {
+	get() {
+		const builder = createBuilder(this, this._styler, true);
+		Object.defineProperty(this, 'visible', {value: builder});
+		return builder;
+	}
+};
 
-  // Esprima's ranges include the first '{' and the last '}' characters on
-  // function expressions. So cut them out.
-  if (ast.body[0].expression.body.type === 'BlockStatement') {
-    /*eslint-disable no-new-func*/
-    return new Function(params, source.slice(body[0] + 1, body[1] - 1));
-  }
-  // ES6 arrow functions can omit the BlockStatement. In that case, just return
-  // the body.
-  /*eslint-disable no-new-func*/
-  return new Function(params, 'return ' + source.slice(body[0], body[1]));
-}
+const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
 
-function representJavascriptFunction(object /*, style*/) {
-  return object.toString();
+for (const model of usedModels) {
+	styles[model] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(ansiStyles$1.color[levelMapping[level]][model](...arguments_), ansiStyles$1.color.close, this._styler);
+				return createBuilder(this, styler, this._isEmpty);
+			};
+		}
+	};
 }
 
-function isFunction(object) {
-  return Object.prototype.toString.call(object) === '[object Function]';
+for (const model of usedModels) {
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(ansiStyles$1.bgColor[levelMapping[level]][model](...arguments_), ansiStyles$1.bgColor.close, this._styler);
+				return createBuilder(this, styler, this._isEmpty);
+			};
+		}
+	};
 }
 
-var _function = new type('tag:yaml.org,2002:js/function', {
-  kind: 'scalar',
-  resolve: resolveJavascriptFunction,
-  construct: constructJavascriptFunction,
-  predicate: isFunction,
-  represent: representJavascriptFunction
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this._generator.level;
+		},
+		set(level) {
+			this._generator.level = level;
+		}
+	}
 });
 
-var default_full = schema.DEFAULT = new schema({
-  include: [
-    default_safe
-  ],
-  explicit: [
-    _undefined,
-    regexp,
-    _function
-  ]
-});
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === undefined) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
 
-/*eslint-disable max-len,no-use-before-define*/
-
-
-
-
-
-
-
-
-var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
-
-
-var CONTEXT_FLOW_IN   = 1;
-var CONTEXT_FLOW_OUT  = 2;
-var CONTEXT_BLOCK_IN  = 3;
-var CONTEXT_BLOCK_OUT = 4;
-
-
-var CHOMPING_CLIP  = 1;
-var CHOMPING_STRIP = 2;
-var CHOMPING_KEEP  = 3;
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
 
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => {
+		if (isArray$2(arguments_[0]) && isArray$2(arguments_[0].raw)) {
+			// Called as a template literal, for example: chalk.red`2 + 3 = {bold ${2+3}}`
+			return applyStyle(builder, chalkTag(builder, ...arguments_));
+		}
 
-var PATTERN_NON_PRINTABLE         = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
-var PATTERN_FLOW_INDICATORS       = /[,\[\]\{\}]/;
-var PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\-]+!)$/i;
-var PATTERN_TAG_URI               = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+		// Single argument is hot path, implicit coercion is faster than anything
+		// eslint-disable-next-line no-implicit-coercion
+		return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+	};
 
+	// We alter the prototype because we must return a function, but there is
+	// no way to create a function with a different prototype
+	Object.setPrototypeOf(builder, proto);
 
-function _class(obj) { return Object.prototype.toString.call(obj); }
+	builder._generator = self;
+	builder._styler = _styler;
+	builder._isEmpty = _isEmpty;
 
-function is_EOL(c) {
-  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
-}
+	return builder;
+};
 
-function is_WHITE_SPACE(c) {
-  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
-}
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) {
+		return self._isEmpty ? '' : string;
+	}
 
-function is_WS_OR_EOL(c) {
-  return (c === 0x09/* Tab */) ||
-         (c === 0x20/* Space */) ||
-         (c === 0x0A/* LF */) ||
-         (c === 0x0D/* CR */);
-}
+	let styler = self._styler;
 
-function is_FLOW_INDICATOR(c) {
-  return c === 0x2C/* , */ ||
-         c === 0x5B/* [ */ ||
-         c === 0x5D/* ] */ ||
-         c === 0x7B/* { */ ||
-         c === 0x7D/* } */;
-}
+	if (styler === undefined) {
+		return string;
+	}
 
-function fromHexCode(c) {
-  var lc;
+	const {openAll, closeAll} = styler;
+	if (string.indexOf('\u001B') !== -1) {
+		while (styler !== undefined) {
+			// Replace any instances already present with a re-opening code
+			// otherwise only the part of the string until said closing code
+			// will be colored, and the rest will simply be 'plain'.
+			string = stringReplaceAll(string, styler.close, styler.open);
 
-  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
-    return c - 0x30;
-  }
+			styler = styler.parent;
+		}
+	}
 
-  /*eslint-disable no-bitwise*/
-  lc = c | 0x20;
+	// We can move both next actions out of loop, because remaining actions in loop won't have
+	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+	const lfIndex = string.indexOf('\n');
+	if (lfIndex !== -1) {
+		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	}
 
-  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
-    return lc - 0x61 + 10;
-  }
+	return openAll + string + closeAll;
+};
 
-  return -1;
-}
+let template;
+const chalkTag = (chalk, ...strings) => {
+	const [firstString] = strings;
 
-function escapedHexLen(c) {
-  if (c === 0x78/* x */) { return 2; }
-  if (c === 0x75/* u */) { return 4; }
-  if (c === 0x55/* U */) { return 8; }
-  return 0;
-}
+	if (!isArray$2(firstString) || !isArray$2(firstString.raw)) {
+		// If chalk() was called by itself or with a string,
+		// return the string itself as a string.
+		return strings.join(' ');
+	}
 
-function fromDecimalCode(c) {
-  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
-    return c - 0x30;
-  }
+	const arguments_ = strings.slice(1);
+	const parts = [firstString.raw[0]];
 
-  return -1;
-}
+	for (let i = 1; i < firstString.length; i++) {
+		parts.push(
+			String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
+			String(firstString.raw[i])
+		);
+	}
 
-function simpleEscapeSequence(c) {
-  /* eslint-disable indent */
-  return (c === 0x30/* 0 */) ? '\x00' :
-        (c === 0x61/* a */) ? '\x07' :
-        (c === 0x62/* b */) ? '\x08' :
-        (c === 0x74/* t */) ? '\x09' :
-        (c === 0x09/* Tab */) ? '\x09' :
-        (c === 0x6E/* n */) ? '\x0A' :
-        (c === 0x76/* v */) ? '\x0B' :
-        (c === 0x66/* f */) ? '\x0C' :
-        (c === 0x72/* r */) ? '\x0D' :
-        (c === 0x65/* e */) ? '\x1B' :
-        (c === 0x20/* Space */) ? ' ' :
-        (c === 0x22/* " */) ? '\x22' :
-        (c === 0x2F/* / */) ? '/' :
-        (c === 0x5C/* \ */) ? '\x5C' :
-        (c === 0x4E/* N */) ? '\x85' :
-        (c === 0x5F/* _ */) ? '\xA0' :
-        (c === 0x4C/* L */) ? '\u2028' :
-        (c === 0x50/* P */) ? '\u2029' : '';
-}
+	if (template === undefined) {
+		template = templates$1;
+	}
 
-function charFromCodepoint(c) {
-  if (c <= 0xFFFF) {
-    return String.fromCharCode(c);
-  }
-  // Encode UTF-16 surrogate pair
-  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
-  return String.fromCharCode(
-    ((c - 0x010000) >> 10) + 0xD800,
-    ((c - 0x010000) & 0x03FF) + 0xDC00
-  );
-}
+	return template(chalk, parts.join(''));
+};
 
-var simpleEscapeCheck = new Array(256); // integer, for fast access
-var simpleEscapeMap = new Array(256);
-for (var i = 0; i < 256; i++) {
-  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
-  simpleEscapeMap[i] = simpleEscapeSequence(i);
-}
+Object.defineProperties(Chalk.prototype, styles);
 
+const chalk$1 = Chalk(); // eslint-disable-line new-cap
+chalk$1.supportsColor = stdoutColor;
+chalk$1.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
+chalk$1.stderr.supportsColor = stderrColor;
 
-function State(input, options) {
-  this.input = input;
+var source$1 = chalk$1;
 
-  this.filename  = options['filename']  || null;
-  this.schema    = options['schema']    || default_full;
-  this.onWarning = options['onWarning'] || null;
-  this.legacy    = options['legacy']    || false;
-  this.json      = options['json']      || false;
-  this.listener  = options['listener']  || null;
+var chokidar = {};
 
-  this.implicitTypes = this.schema.compiledImplicit;
-  this.typeMap       = this.schema.compiledTypeMap;
+var utils$7 = {};
 
-  this.length     = input.length;
-  this.position   = 0;
-  this.line       = 0;
-  this.lineStart  = 0;
-  this.lineIndent = 0;
+const path$a = path$b;
+const WIN_SLASH = '\\\\/';
+const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
-  this.documents = [];
+/**
+ * Posix glob regex
+ */
 
-  /*
-  this.version;
-  this.checkLineBreaks;
-  this.tagMap;
-  this.anchorMap;
-  this.tag;
-  this.anchor;
-  this.kind;
-  this.result;*/
+const DOT_LITERAL = '\\.';
+const PLUS_LITERAL = '\\+';
+const QMARK_LITERAL = '\\?';
+const SLASH_LITERAL = '\\/';
+const ONE_CHAR = '(?=.)';
+const QMARK = '[^/]';
+const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+const NO_DOT = `(?!${DOT_LITERAL})`;
+const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+const STAR$1 = `${QMARK}*?`;
 
-}
+const POSIX_CHARS = {
+  DOT_LITERAL,
+  PLUS_LITERAL,
+  QMARK_LITERAL,
+  SLASH_LITERAL,
+  ONE_CHAR,
+  QMARK,
+  END_ANCHOR,
+  DOTS_SLASH,
+  NO_DOT,
+  NO_DOTS,
+  NO_DOT_SLASH,
+  NO_DOTS_SLASH,
+  QMARK_NO_DOT,
+  STAR: STAR$1,
+  START_ANCHOR
+};
 
+/**
+ * Windows glob regex
+ */
 
-function generateError(state, message) {
-  return new exception(
-    message,
-    new mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));
-}
+const WINDOWS_CHARS = {
+  ...POSIX_CHARS,
 
-function throwError(state, message) {
-  throw generateError(state, message);
-}
+  SLASH_LITERAL: `[${WIN_SLASH}]`,
+  QMARK: WIN_NO_SLASH,
+  STAR: `${WIN_NO_SLASH}*?`,
+  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+  NO_DOT: `(?!${DOT_LITERAL})`,
+  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+};
 
-function throwWarning(state, message) {
-  if (state.onWarning) {
-    state.onWarning.call(null, generateError(state, message));
-  }
-}
+/**
+ * POSIX Bracket Regex
+ */
 
+const POSIX_REGEX_SOURCE$1 = {
+  alnum: 'a-zA-Z0-9',
+  alpha: 'a-zA-Z',
+  ascii: '\\x00-\\x7F',
+  blank: ' \\t',
+  cntrl: '\\x00-\\x1F\\x7F',
+  digit: '0-9',
+  graph: '\\x21-\\x7E',
+  lower: 'a-z',
+  print: '\\x20-\\x7E ',
+  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+  space: ' \\t\\r\\n\\v\\f',
+  upper: 'A-Z',
+  word: 'A-Za-z0-9_',
+  xdigit: 'A-Fa-f0-9'
+};
 
-var directiveHandlers = {
+var constants$5 = {
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
 
-  YAML: function handleYamlDirective(state, name, args) {
+  // regular expressions
+  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
 
-    var match, major, minor;
+  // Replace globs with equivalent patterns to reduce parsing time.
+  REPLACEMENTS: {
+    '***': '*',
+    '**/**': '**',
+    '**/**/**': '**'
+  },
 
-    if (state.version !== null) {
-      throwError(state, 'duplication of %YAML directive');
-    }
+  // Digits
+  CHAR_0: 48, /* 0 */
+  CHAR_9: 57, /* 9 */
 
-    if (args.length !== 1) {
-      throwError(state, 'YAML directive accepts exactly one argument');
-    }
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 65, /* A */
+  CHAR_LOWERCASE_A: 97, /* a */
+  CHAR_UPPERCASE_Z: 90, /* Z */
+  CHAR_LOWERCASE_Z: 122, /* z */
 
-    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+  CHAR_LEFT_PARENTHESES: 40, /* ( */
+  CHAR_RIGHT_PARENTHESES: 41, /* ) */
 
-    if (match === null) {
-      throwError(state, 'ill-formed argument of the YAML directive');
-    }
+  CHAR_ASTERISK: 42, /* * */
 
-    major = parseInt(match[1], 10);
-    minor = parseInt(match[2], 10);
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: 38, /* & */
+  CHAR_AT: 64, /* @ */
+  CHAR_BACKWARD_SLASH: 92, /* \ */
+  CHAR_CARRIAGE_RETURN: 13, /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+  CHAR_COLON: 58, /* : */
+  CHAR_COMMA: 44, /* , */
+  CHAR_DOT: 46, /* . */
+  CHAR_DOUBLE_QUOTE: 34, /* " */
+  CHAR_EQUAL: 61, /* = */
+  CHAR_EXCLAMATION_MARK: 33, /* ! */
+  CHAR_FORM_FEED: 12, /* \f */
+  CHAR_FORWARD_SLASH: 47, /* / */
+  CHAR_GRAVE_ACCENT: 96, /* ` */
+  CHAR_HASH: 35, /* # */
+  CHAR_HYPHEN_MINUS: 45, /* - */
+  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+  CHAR_LINE_FEED: 10, /* \n */
+  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+  CHAR_PERCENT: 37, /* % */
+  CHAR_PLUS: 43, /* + */
+  CHAR_QUESTION_MARK: 63, /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+  CHAR_SEMICOLON: 59, /* ; */
+  CHAR_SINGLE_QUOTE: 39, /* ' */
+  CHAR_SPACE: 32, /*   */
+  CHAR_TAB: 9, /* \t */
+  CHAR_UNDERSCORE: 95, /* _ */
+  CHAR_VERTICAL_LINE: 124, /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
 
-    if (major !== 1) {
-      throwError(state, 'unacceptable YAML version of the document');
-    }
+  SEP: path$a.sep,
 
-    state.version = args[0];
-    state.checkLineBreaks = (minor < 2);
+  /**
+   * Create EXTGLOB_CHARS
+   */
 
-    if (minor !== 1 && minor !== 2) {
-      throwWarning(state, 'unsupported YAML version of the document');
-    }
+  extglobChars(chars) {
+    return {
+      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+      '?': { type: 'qmark', open: '(?:', close: ')?' },
+      '+': { type: 'plus', open: '(?:', close: ')+' },
+      '*': { type: 'star', open: '(?:', close: ')*' },
+      '@': { type: 'at', open: '(?:', close: ')' }
+    };
   },
 
-  TAG: function handleTagDirective(state, name, args) {
-
-    var handle, prefix;
+  /**
+   * Create GLOB_CHARS
+   */
 
-    if (args.length !== 2) {
-      throwError(state, 'TAG directive accepts exactly two arguments');
-    }
+  globChars(win32) {
+    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+  }
+};
 
-    handle = args[0];
-    prefix = args[1];
+(function (exports) {
 
-    if (!PATTERN_TAG_HANDLE.test(handle)) {
-      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
-    }
+const path = path$b;
+const win32 = process.platform === 'win32';
+const {
+  REGEX_BACKSLASH,
+  REGEX_REMOVE_BACKSLASH,
+  REGEX_SPECIAL_CHARS,
+  REGEX_SPECIAL_CHARS_GLOBAL
+} = constants$5;
 
-    if (_hasOwnProperty$2.call(state.tagMap, handle)) {
-      throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
-    }
+exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
 
-    if (!PATTERN_TAG_URI.test(prefix)) {
-      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
-    }
+exports.removeBackslashes = str => {
+  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+    return match === '\\' ? '' : match;
+  });
+};
 
-    state.tagMap[handle] = prefix;
+exports.supportsLookbehinds = () => {
+  const segs = process.version.slice(1).split('.').map(Number);
+  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+    return true;
   }
+  return false;
 };
 
+exports.isWindows = options => {
+  if (options && typeof options.windows === 'boolean') {
+    return options.windows;
+  }
+  return win32 === true || path.sep === '\\';
+};
 
-function captureSegment(state, start, end, checkJson) {
-  var _position, _length, _character, _result;
-
-  if (start < end) {
-    _result = state.input.slice(start, end);
-
-    if (checkJson) {
-      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
-        _character = _result.charCodeAt(_position);
-        if (!(_character === 0x09 ||
-              (0x20 <= _character && _character <= 0x10FFFF))) {
-          throwError(state, 'expected valid JSON character');
-        }
-      }
-    } else if (PATTERN_NON_PRINTABLE.test(_result)) {
-      throwError(state, 'the stream contains non-printable characters');
-    }
+exports.escapeLast = (input, char, lastIdx) => {
+  const idx = input.lastIndexOf(char, lastIdx);
+  if (idx === -1) return input;
+  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+};
 
-    state.result += _result;
+exports.removePrefix = (input, state = {}) => {
+  let output = input;
+  if (output.startsWith('./')) {
+    output = output.slice(2);
+    state.prefix = './';
   }
-}
+  return output;
+};
 
-function mergeMappings(state, destination, source, overridableKeys) {
-  var sourceKeys, key, index, quantity;
+exports.wrapOutput = (input, state = {}, options = {}) => {
+  const prepend = options.contains ? '' : '^';
+  const append = options.contains ? '' : '$';
 
-  if (!common.isObject(source)) {
-    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
+  let output = `${prepend}(?:${input})${append}`;
+  if (state.negated === true) {
+    output = `(?:^(?!${output}).*$)`;
   }
+  return output;
+};
+}(utils$7));
 
-  sourceKeys = Object.keys(source);
+const utils$6 = utils$7;
+const {
+  CHAR_ASTERISK: CHAR_ASTERISK$1,             /* * */
+  CHAR_AT,                   /* @ */
+  CHAR_BACKWARD_SLASH,       /* \ */
+  CHAR_COMMA: CHAR_COMMA$2,                /* , */
+  CHAR_DOT: CHAR_DOT$1,                  /* . */
+  CHAR_EXCLAMATION_MARK,     /* ! */
+  CHAR_FORWARD_SLASH,        /* / */
+  CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1,     /* { */
+  CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1,     /* ( */
+  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$2,  /* [ */
+  CHAR_PLUS,                 /* + */
+  CHAR_QUESTION_MARK,        /* ? */
+  CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1,    /* } */
+  CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1,    /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$2  /* ] */
+} = constants$5;
 
-  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
-    key = sourceKeys[index];
+const isPathSeparator = code => {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+};
 
-    if (!_hasOwnProperty$2.call(destination, key)) {
-      destination[key] = source[key];
-      overridableKeys[key] = true;
-    }
+const depth = token => {
+  if (token.isPrefix !== true) {
+    token.depth = token.isGlobstar ? Infinity : 1;
   }
-}
+};
 
-function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
-  var index, quantity;
+/**
+ * Quickly scans a glob pattern and returns an object with a handful of
+ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+ * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).
+ *
+ * ```js
+ * const pm = require('picomatch');
+ * console.log(pm.scan('foo/bar/*.js'));
+ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with tokens and regex source string.
+ * @api public
+ */
 
-  // The output is a plain object here, so keys can only be strings.
-  // We need to convert keyNode to a string, but doing so can hang the process
-  // (deeply nested arrays that explode exponentially using aliases).
-  if (Array.isArray(keyNode)) {
-    keyNode = Array.prototype.slice.call(keyNode);
+const scan$1 = (input, options) => {
+  const opts = options || {};
 
-    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
-      if (Array.isArray(keyNode[index])) {
-        throwError(state, 'nested arrays are not supported inside keys');
-      }
+  const length = input.length - 1;
+  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+  const slashes = [];
+  const tokens = [];
+  const parts = [];
 
-      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
-        keyNode[index] = '[object Object]';
-      }
-    }
-  }
-
-  // Avoid code execution in load() via toString property
-  // (still use its own toString for arrays, timestamps,
-  // and whatever user schema extensions happen to have @@toStringTag)
-  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
-    keyNode = '[object Object]';
-  }
+  let str = input;
+  let index = -1;
+  let start = 0;
+  let lastIndex = 0;
+  let isBrace = false;
+  let isBracket = false;
+  let isGlob = false;
+  let isExtglob = false;
+  let isGlobstar = false;
+  let braceEscaped = false;
+  let backslashes = false;
+  let negated = false;
+  let finished = false;
+  let braces = 0;
+  let prev;
+  let code;
+  let token = { value: '', depth: 0, isGlob: false };
 
+  const eos = () => index >= length;
+  const peek = () => str.charCodeAt(index + 1);
+  const advance = () => {
+    prev = code;
+    return str.charCodeAt(++index);
+  };
 
-  keyNode = String(keyNode);
+  while (index < length) {
+    code = advance();
+    let next;
 
-  if (_result === null) {
-    _result = {};
-  }
+    if (code === CHAR_BACKWARD_SLASH) {
+      backslashes = token.backslashes = true;
+      code = advance();
 
-  if (keyTag === 'tag:yaml.org,2002:merge') {
-    if (Array.isArray(valueNode)) {
-      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
-        mergeMappings(state, _result, valueNode[index], overridableKeys);
+      if (code === CHAR_LEFT_CURLY_BRACE$1) {
+        braceEscaped = true;
       }
-    } else {
-      mergeMappings(state, _result, valueNode, overridableKeys);
-    }
-  } else {
-    if (!state.json &&
-        !_hasOwnProperty$2.call(overridableKeys, keyNode) &&
-        _hasOwnProperty$2.call(_result, keyNode)) {
-      state.line = startLine || state.line;
-      state.position = startPos || state.position;
-      throwError(state, 'duplicated mapping key');
+      continue;
     }
-    _result[keyNode] = valueNode;
-    delete overridableKeys[keyNode];
-  }
 
-  return _result;
-}
+    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) {
+      braces++;
 
-function readLineBreak(state) {
-  var ch;
+      while (eos() !== true && (code = advance())) {
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
 
-  ch = state.input.charCodeAt(state.position);
+        if (code === CHAR_LEFT_CURLY_BRACE$1) {
+          braces++;
+          continue;
+        }
 
-  if (ch === 0x0A/* LF */) {
-    state.position++;
-  } else if (ch === 0x0D/* CR */) {
-    state.position++;
-    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
-      state.position++;
-    }
-  } else {
-    throwError(state, 'a line break is expected');
-  }
+        if (braceEscaped !== true && code === CHAR_DOT$1 && (code = advance()) === CHAR_DOT$1) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
 
-  state.line += 1;
-  state.lineStart = state.position;
-}
+          if (scanToEnd === true) {
+            continue;
+          }
 
-function skipSeparationSpace(state, allowComments, checkIndent) {
-  var lineBreaks = 0,
-      ch = state.input.charCodeAt(state.position);
+          break;
+        }
 
-  while (ch !== 0) {
-    while (is_WHITE_SPACE(ch)) {
-      ch = state.input.charCodeAt(++state.position);
-    }
+        if (braceEscaped !== true && code === CHAR_COMMA$2) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
 
-    if (allowComments && ch === 0x23/* # */) {
-      do {
-        ch = state.input.charCodeAt(++state.position);
-      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
-    }
+          if (scanToEnd === true) {
+            continue;
+          }
 
-    if (is_EOL(ch)) {
-      readLineBreak(state);
+          break;
+        }
 
-      ch = state.input.charCodeAt(state.position);
-      lineBreaks++;
-      state.lineIndent = 0;
+        if (code === CHAR_RIGHT_CURLY_BRACE$1) {
+          braces--;
 
-      while (ch === 0x20/* Space */) {
-        state.lineIndent++;
-        ch = state.input.charCodeAt(++state.position);
+          if (braces === 0) {
+            braceEscaped = false;
+            isBrace = token.isBrace = true;
+            finished = true;
+            break;
+          }
+        }
       }
-    } else {
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
       break;
     }
-  }
-
-  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
-    throwWarning(state, 'deficient indentation');
-  }
 
-  return lineBreaks;
-}
+    if (code === CHAR_FORWARD_SLASH) {
+      slashes.push(index);
+      tokens.push(token);
+      token = { value: '', depth: 0, isGlob: false };
 
-function testDocumentSeparator(state) {
-  var _position = state.position,
-      ch;
+      if (finished === true) continue;
+      if (prev === CHAR_DOT$1 && index === (start + 1)) {
+        start += 2;
+        continue;
+      }
 
-  ch = state.input.charCodeAt(_position);
+      lastIndex = index + 1;
+      continue;
+    }
 
-  // Condition state.position === state.lineStart is tested
-  // in parent on each call, for efficiency. No needs to test here again.
-  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
-      ch === state.input.charCodeAt(_position + 1) &&
-      ch === state.input.charCodeAt(_position + 2)) {
+    if (opts.noext !== true) {
+      const isExtglobChar = code === CHAR_PLUS
+        || code === CHAR_AT
+        || code === CHAR_ASTERISK$1
+        || code === CHAR_QUESTION_MARK
+        || code === CHAR_EXCLAMATION_MARK;
 
-    _position += 3;
+      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES$1) {
+        isGlob = token.isGlob = true;
+        isExtglob = token.isExtglob = true;
+        finished = true;
 
-    ch = state.input.charCodeAt(_position);
+        if (scanToEnd === true) {
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              code = advance();
+              continue;
+            }
 
-    if (ch === 0 || is_WS_OR_EOL(ch)) {
-      return true;
+            if (code === CHAR_RIGHT_PARENTHESES$1) {
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
     }
-  }
-
-  return false;
-}
 
-function writeFoldedLines(state, count) {
-  if (count === 1) {
-    state.result += ' ';
-  } else if (count > 1) {
-    state.result += common.repeat('\n', count - 1);
-  }
-}
+    if (code === CHAR_ASTERISK$1) {
+      if (prev === CHAR_ASTERISK$1) isGlobstar = token.isGlobstar = true;
+      isGlob = token.isGlob = true;
+      finished = true;
 
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
 
-function readPlainScalar(state, nodeIndent, withinFlowCollection) {
-  var preceding,
-      following,
-      captureStart,
-      captureEnd,
-      hasPendingContent,
-      _line,
-      _lineStart,
-      _lineIndent,
-      _kind = state.kind,
-      _result = state.result,
-      ch;
+    if (code === CHAR_QUESTION_MARK) {
+      isGlob = token.isGlob = true;
+      finished = true;
 
-  ch = state.input.charCodeAt(state.position);
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
 
-  if (is_WS_OR_EOL(ch)      ||
-      is_FLOW_INDICATOR(ch) ||
-      ch === 0x23/* # */    ||
-      ch === 0x26/* & */    ||
-      ch === 0x2A/* * */    ||
-      ch === 0x21/* ! */    ||
-      ch === 0x7C/* | */    ||
-      ch === 0x3E/* > */    ||
-      ch === 0x27/* ' */    ||
-      ch === 0x22/* " */    ||
-      ch === 0x25/* % */    ||
-      ch === 0x40/* @ */    ||
-      ch === 0x60/* ` */) {
-    return false;
-  }
+    if (code === CHAR_LEFT_SQUARE_BRACKET$2) {
+      while (eos() !== true && (next = advance())) {
+        if (next === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
 
-  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
-    following = state.input.charCodeAt(state.position + 1);
+        if (next === CHAR_RIGHT_SQUARE_BRACKET$2) {
+          isBracket = token.isBracket = true;
+          isGlob = token.isGlob = true;
+          finished = true;
 
-    if (is_WS_OR_EOL(following) ||
-        withinFlowCollection && is_FLOW_INDICATOR(following)) {
-      return false;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+      }
     }
-  }
-
-  state.kind = 'scalar';
-  state.result = '';
-  captureStart = captureEnd = state.position;
-  hasPendingContent = false;
 
-  while (ch !== 0) {
-    if (ch === 0x3A/* : */) {
-      following = state.input.charCodeAt(state.position + 1);
+    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+      negated = token.negated = true;
+      start++;
+      continue;
+    }
 
-      if (is_WS_OR_EOL(following) ||
-          withinFlowCollection && is_FLOW_INDICATOR(following)) {
-        break;
-      }
+    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES$1) {
+      isGlob = token.isGlob = true;
 
-    } else if (ch === 0x23/* # */) {
-      preceding = state.input.charCodeAt(state.position - 1);
+      if (scanToEnd === true) {
+        while (eos() !== true && (code = advance())) {
+          if (code === CHAR_LEFT_PARENTHESES$1) {
+            backslashes = token.backslashes = true;
+            code = advance();
+            continue;
+          }
 
-      if (is_WS_OR_EOL(preceding)) {
-        break;
+          if (code === CHAR_RIGHT_PARENTHESES$1) {
+            finished = true;
+            break;
+          }
+        }
+        continue;
       }
-
-    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
-               withinFlowCollection && is_FLOW_INDICATOR(ch)) {
       break;
+    }
 
-    } else if (is_EOL(ch)) {
-      _line = state.line;
-      _lineStart = state.lineStart;
-      _lineIndent = state.lineIndent;
-      skipSeparationSpace(state, false, -1);
+    if (isGlob === true) {
+      finished = true;
 
-      if (state.lineIndent >= nodeIndent) {
-        hasPendingContent = true;
-        ch = state.input.charCodeAt(state.position);
+      if (scanToEnd === true) {
         continue;
-      } else {
-        state.position = captureEnd;
-        state.line = _line;
-        state.lineStart = _lineStart;
-        state.lineIndent = _lineIndent;
-        break;
       }
-    }
-
-    if (hasPendingContent) {
-      captureSegment(state, captureStart, captureEnd, false);
-      writeFoldedLines(state, state.line - _line);
-      captureStart = captureEnd = state.position;
-      hasPendingContent = false;
-    }
 
-    if (!is_WHITE_SPACE(ch)) {
-      captureEnd = state.position + 1;
+      break;
     }
+  }
 
-    ch = state.input.charCodeAt(++state.position);
+  if (opts.noext === true) {
+    isExtglob = false;
+    isGlob = false;
   }
 
-  captureSegment(state, captureStart, captureEnd, false);
+  let base = str;
+  let prefix = '';
+  let glob = '';
 
-  if (state.result) {
-    return true;
+  if (start > 0) {
+    prefix = str.slice(0, start);
+    str = str.slice(start);
+    lastIndex -= start;
   }
 
-  state.kind = _kind;
-  state.result = _result;
-  return false;
-}
+  if (base && isGlob === true && lastIndex > 0) {
+    base = str.slice(0, lastIndex);
+    glob = str.slice(lastIndex);
+  } else if (isGlob === true) {
+    base = '';
+    glob = str;
+  } else {
+    base = str;
+  }
 
-function readSingleQuotedScalar(state, nodeIndent) {
-  var ch,
-      captureStart, captureEnd;
+  if (base && base !== '' && base !== '/' && base !== str) {
+    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+      base = base.slice(0, -1);
+    }
+  }
 
-  ch = state.input.charCodeAt(state.position);
+  if (opts.unescape === true) {
+    if (glob) glob = utils$6.removeBackslashes(glob);
 
-  if (ch !== 0x27/* ' */) {
-    return false;
+    if (base && backslashes === true) {
+      base = utils$6.removeBackslashes(base);
+    }
   }
 
-  state.kind = 'scalar';
-  state.result = '';
-  state.position++;
-  captureStart = captureEnd = state.position;
+  const state = {
+    prefix,
+    input,
+    start,
+    base,
+    glob,
+    isBrace,
+    isBracket,
+    isGlob,
+    isExtglob,
+    isGlobstar,
+    negated
+  };
 
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    if (ch === 0x27/* ' */) {
-      captureSegment(state, captureStart, state.position, true);
-      ch = state.input.charCodeAt(++state.position);
+  if (opts.tokens === true) {
+    state.maxDepth = 0;
+    if (!isPathSeparator(code)) {
+      tokens.push(token);
+    }
+    state.tokens = tokens;
+  }
 
-      if (ch === 0x27/* ' */) {
-        captureStart = state.position;
-        state.position++;
-        captureEnd = state.position;
-      } else {
-        return true;
-      }
+  if (opts.parts === true || opts.tokens === true) {
+    let prevIndex;
 
-    } else if (is_EOL(ch)) {
-      captureSegment(state, captureStart, captureEnd, true);
-      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-      captureStart = captureEnd = state.position;
+    for (let idx = 0; idx < slashes.length; idx++) {
+      const n = prevIndex ? prevIndex + 1 : start;
+      const i = slashes[idx];
+      const value = input.slice(n, i);
+      if (opts.tokens) {
+        if (idx === 0 && start !== 0) {
+          tokens[idx].isPrefix = true;
+          tokens[idx].value = prefix;
+        } else {
+          tokens[idx].value = value;
+        }
+        depth(tokens[idx]);
+        state.maxDepth += tokens[idx].depth;
+      }
+      if (idx !== 0 || value !== '') {
+        parts.push(value);
+      }
+      prevIndex = i;
+    }
 
-    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
-      throwError(state, 'unexpected end of the document within a single quoted scalar');
+    if (prevIndex && prevIndex + 1 < input.length) {
+      const value = input.slice(prevIndex + 1);
+      parts.push(value);
 
-    } else {
-      state.position++;
-      captureEnd = state.position;
+      if (opts.tokens) {
+        tokens[tokens.length - 1].value = value;
+        depth(tokens[tokens.length - 1]);
+        state.maxDepth += tokens[tokens.length - 1].depth;
+      }
     }
+
+    state.slashes = slashes;
+    state.parts = parts;
   }
 
-  throwError(state, 'unexpected end of the stream within a single quoted scalar');
-}
+  return state;
+};
 
-function readDoubleQuotedScalar(state, nodeIndent) {
-  var captureStart,
-      captureEnd,
-      hexLength,
-      hexResult,
-      tmp,
-      ch;
+var scan_1 = scan$1;
 
-  ch = state.input.charCodeAt(state.position);
+const constants$4 = constants$5;
+const utils$5 = utils$7;
 
-  if (ch !== 0x22/* " */) {
-    return false;
-  }
+/**
+ * Constants
+ */
 
-  state.kind = 'scalar';
-  state.result = '';
-  state.position++;
-  captureStart = captureEnd = state.position;
+const {
+  MAX_LENGTH: MAX_LENGTH$4,
+  POSIX_REGEX_SOURCE,
+  REGEX_NON_SPECIAL_CHARS,
+  REGEX_SPECIAL_CHARS_BACKREF,
+  REPLACEMENTS
+} = constants$4;
 
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    if (ch === 0x22/* " */) {
-      captureSegment(state, captureStart, state.position, true);
-      state.position++;
-      return true;
+/**
+ * Helpers
+ */
 
-    } else if (ch === 0x5C/* \ */) {
-      captureSegment(state, captureStart, state.position, true);
-      ch = state.input.charCodeAt(++state.position);
+const expandRange = (args, options) => {
+  if (typeof options.expandRange === 'function') {
+    return options.expandRange(...args, options);
+  }
 
-      if (is_EOL(ch)) {
-        skipSeparationSpace(state, false, nodeIndent);
+  args.sort();
+  const value = `[${args.join('-')}]`;
 
-        // TODO: rework to inline fn with no type cast?
-      } else if (ch < 256 && simpleEscapeCheck[ch]) {
-        state.result += simpleEscapeMap[ch];
-        state.position++;
+  try {
+    /* eslint-disable-next-line no-new */
+    new RegExp(value);
+  } catch (ex) {
+    return args.map(v => utils$5.escapeRegex(v)).join('..');
+  }
 
-      } else if ((tmp = escapedHexLen(ch)) > 0) {
-        hexLength = tmp;
-        hexResult = 0;
+  return value;
+};
 
-        for (; hexLength > 0; hexLength--) {
-          ch = state.input.charCodeAt(++state.position);
+/**
+ * Create the message for a syntax error
+ */
 
-          if ((tmp = fromHexCode(ch)) >= 0) {
-            hexResult = (hexResult << 4) + tmp;
+const syntaxError$1 = (type, char) => {
+  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+};
 
-          } else {
-            throwError(state, 'expected hexadecimal character');
-          }
-        }
+/**
+ * Parse the given input string.
+ * @param {String} input
+ * @param {Object} options
+ * @return {Object}
+ */
 
-        state.result += charFromCodepoint(hexResult);
+const parse$e = (input, options) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected a string');
+  }
 
-        state.position++;
+  input = REPLACEMENTS[input] || input;
 
-      } else {
-        throwError(state, 'unknown escape sequence');
-      }
+  const opts = { ...options };
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$4, opts.maxLength) : MAX_LENGTH$4;
 
-      captureStart = captureEnd = state.position;
+  let len = input.length;
+  if (len > max) {
+    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
 
-    } else if (is_EOL(ch)) {
-      captureSegment(state, captureStart, captureEnd, true);
-      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-      captureStart = captureEnd = state.position;
+  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+  const tokens = [bos];
 
-    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
-      throwError(state, 'unexpected end of the document within a double quoted scalar');
+  const capture = opts.capture ? '' : '?:';
+  const win32 = utils$5.isWindows(options);
 
-    } else {
-      state.position++;
-      captureEnd = state.position;
-    }
-  }
+  // create constants based on platform, for windows or posix
+  const PLATFORM_CHARS = constants$4.globChars(win32);
+  const EXTGLOB_CHARS = constants$4.extglobChars(PLATFORM_CHARS);
 
-  throwError(state, 'unexpected end of the stream within a double quoted scalar');
-}
+  const {
+    DOT_LITERAL,
+    PLUS_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOT_SLASH,
+    NO_DOTS_SLASH,
+    QMARK,
+    QMARK_NO_DOT,
+    STAR,
+    START_ANCHOR
+  } = PLATFORM_CHARS;
 
-function readFlowCollection(state, nodeIndent) {
-  var readNext = true,
-      _line,
-      _tag     = state.tag,
-      _result,
-      _anchor  = state.anchor,
-      following,
-      terminator,
-      isPair,
-      isExplicitPair,
-      isMapping,
-      overridableKeys = {},
-      keyNode,
-      keyTag,
-      valueNode,
-      ch;
+  const globstar = (opts) => {
+    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+  };
 
-  ch = state.input.charCodeAt(state.position);
+  const nodot = opts.dot ? '' : NO_DOT;
+  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+  let star = opts.bash === true ? globstar(opts) : STAR;
 
-  if (ch === 0x5B/* [ */) {
-    terminator = 0x5D;/* ] */
-    isMapping = false;
-    _result = [];
-  } else if (ch === 0x7B/* { */) {
-    terminator = 0x7D;/* } */
-    isMapping = true;
-    _result = {};
-  } else {
-    return false;
+  if (opts.capture) {
+    star = `(${star})`;
   }
 
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
+  // minimatch options support
+  if (typeof opts.noext === 'boolean') {
+    opts.noextglob = opts.noext;
   }
 
-  ch = state.input.charCodeAt(++state.position);
+  const state = {
+    input,
+    index: -1,
+    start: 0,
+    dot: opts.dot === true,
+    consumed: '',
+    output: '',
+    prefix: '',
+    backtrack: false,
+    negated: false,
+    brackets: 0,
+    braces: 0,
+    parens: 0,
+    quotes: 0,
+    globstar: false,
+    tokens
+  };
 
-  while (ch !== 0) {
-    skipSeparationSpace(state, true, nodeIndent);
+  input = utils$5.removePrefix(input, state);
+  len = input.length;
 
-    ch = state.input.charCodeAt(state.position);
+  const extglobs = [];
+  const braces = [];
+  const stack = [];
+  let prev = bos;
+  let value;
 
-    if (ch === terminator) {
-      state.position++;
-      state.tag = _tag;
-      state.anchor = _anchor;
-      state.kind = isMapping ? 'mapping' : 'sequence';
-      state.result = _result;
-      return true;
-    } else if (!readNext) {
-      throwError(state, 'missed comma between flow collection entries');
-    }
+  /**
+   * Tokenizing helpers
+   */
 
-    keyTag = keyNode = valueNode = null;
-    isPair = isExplicitPair = false;
+  const eos = () => state.index === len - 1;
+  const peek = state.peek = (n = 1) => input[state.index + n];
+  const advance = state.advance = () => input[++state.index];
+  const remaining = () => input.slice(state.index + 1);
+  const consume = (value = '', num = 0) => {
+    state.consumed += value;
+    state.index += num;
+  };
+  const append = token => {
+    state.output += token.output != null ? token.output : token.value;
+    consume(token.value);
+  };
 
-    if (ch === 0x3F/* ? */) {
-      following = state.input.charCodeAt(state.position + 1);
+  const negate = () => {
+    let count = 1;
 
-      if (is_WS_OR_EOL(following)) {
-        isPair = isExplicitPair = true;
-        state.position++;
-        skipSeparationSpace(state, true, nodeIndent);
-      }
+    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+      advance();
+      state.start++;
+      count++;
     }
 
-    _line = state.line;
-    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-    keyTag = state.tag;
-    keyNode = state.result;
-    skipSeparationSpace(state, true, nodeIndent);
+    if (count % 2 === 0) {
+      return false;
+    }
 
-    ch = state.input.charCodeAt(state.position);
+    state.negated = true;
+    state.start++;
+    return true;
+  };
 
-    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
-      isPair = true;
-      ch = state.input.charCodeAt(++state.position);
-      skipSeparationSpace(state, true, nodeIndent);
-      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-      valueNode = state.result;
-    }
+  const increment = type => {
+    state[type]++;
+    stack.push(type);
+  };
 
-    if (isMapping) {
-      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
-    } else if (isPair) {
-      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
-    } else {
-      _result.push(keyNode);
-    }
+  const decrement = type => {
+    state[type]--;
+    stack.pop();
+  };
 
-    skipSeparationSpace(state, true, nodeIndent);
+  /**
+   * Push tokens onto the tokens array. This helper speeds up
+   * tokenizing by 1) helping us avoid backtracking as much as possible,
+   * and 2) helping us avoid creating extra tokens when consecutive
+   * characters are plain text. This improves performance and simplifies
+   * lookbehinds.
+   */
 
-    ch = state.input.charCodeAt(state.position);
+  const push = tok => {
+    if (prev.type === 'globstar') {
+      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
 
-    if (ch === 0x2C/* , */) {
-      readNext = true;
-      ch = state.input.charCodeAt(++state.position);
-    } else {
-      readNext = false;
+      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+        state.output = state.output.slice(0, -prev.output.length);
+        prev.type = 'star';
+        prev.value = '*';
+        prev.output = star;
+        state.output += prev.output;
+      }
     }
-  }
 
-  throwError(state, 'unexpected end of the stream within a flow collection');
-}
+    if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
+      extglobs[extglobs.length - 1].inner += tok.value;
+    }
 
-function readBlockScalar(state, nodeIndent) {
-  var captureStart,
-      folding,
-      chomping       = CHOMPING_CLIP,
-      didReadContent = false,
-      detectedIndent = false,
-      textIndent     = nodeIndent,
-      emptyLines     = 0,
-      atMoreIndented = false,
-      tmp,
-      ch;
+    if (tok.value || tok.output) append(tok);
+    if (prev && prev.type === 'text' && tok.type === 'text') {
+      prev.value += tok.value;
+      prev.output = (prev.output || '') + tok.value;
+      return;
+    }
 
-  ch = state.input.charCodeAt(state.position);
+    tok.prev = prev;
+    tokens.push(tok);
+    prev = tok;
+  };
 
-  if (ch === 0x7C/* | */) {
-    folding = false;
-  } else if (ch === 0x3E/* > */) {
-    folding = true;
-  } else {
-    return false;
-  }
+  const extglobOpen = (type, value) => {
+    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
 
-  state.kind = 'scalar';
-  state.result = '';
+    token.prev = prev;
+    token.parens = state.parens;
+    token.output = state.output;
+    const output = (opts.capture ? '(' : '') + token.open;
 
-  while (ch !== 0) {
-    ch = state.input.charCodeAt(++state.position);
+    increment('parens');
+    push({ type, value, output: state.output ? '' : ONE_CHAR });
+    push({ type: 'paren', extglob: true, value: advance(), output });
+    extglobs.push(token);
+  };
 
-    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
-      if (CHOMPING_CLIP === chomping) {
-        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
-      } else {
-        throwError(state, 'repeat of a chomping mode identifier');
+  const extglobClose = token => {
+    let output = token.close + (opts.capture ? ')' : '');
+
+    if (token.type === 'negate') {
+      let extglobStar = star;
+
+      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+        extglobStar = globstar(opts);
       }
 
-    } else if ((tmp = fromDecimalCode(ch)) >= 0) {
-      if (tmp === 0) {
-        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
-      } else if (!detectedIndent) {
-        textIndent = nodeIndent + tmp - 1;
-        detectedIndent = true;
-      } else {
-        throwError(state, 'repeat of an indentation width identifier');
+      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+        output = token.close = `)$))${extglobStar}`;
       }
 
-    } else {
-      break;
+      if (token.prev.type === 'bos' && eos()) {
+        state.negatedExtglob = true;
+      }
     }
-  }
 
-  if (is_WHITE_SPACE(ch)) {
-    do { ch = state.input.charCodeAt(++state.position); }
-    while (is_WHITE_SPACE(ch));
+    push({ type: 'paren', extglob: true, value, output });
+    decrement('parens');
+  };
 
-    if (ch === 0x23/* # */) {
-      do { ch = state.input.charCodeAt(++state.position); }
-      while (!is_EOL(ch) && (ch !== 0));
-    }
-  }
+  /**
+   * Fast paths
+   */
 
-  while (ch !== 0) {
-    readLineBreak(state);
-    state.lineIndent = 0;
+  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+    let backslashes = false;
 
-    ch = state.input.charCodeAt(state.position);
+    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+      if (first === '\\') {
+        backslashes = true;
+        return m;
+      }
 
-    while ((!detectedIndent || state.lineIndent < textIndent) &&
-           (ch === 0x20/* Space */)) {
-      state.lineIndent++;
-      ch = state.input.charCodeAt(++state.position);
+      if (first === '?') {
+        if (esc) {
+          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+        }
+        if (index === 0) {
+          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+        }
+        return QMARK.repeat(chars.length);
+      }
+
+      if (first === '.') {
+        return DOT_LITERAL.repeat(chars.length);
+      }
+
+      if (first === '*') {
+        if (esc) {
+          return esc + first + (rest ? star : '');
+        }
+        return star;
+      }
+      return esc ? m : `\\${m}`;
+    });
+
+    if (backslashes === true) {
+      if (opts.unescape === true) {
+        output = output.replace(/\\/g, '');
+      } else {
+        output = output.replace(/\\+/g, m => {
+          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+        });
+      }
     }
 
-    if (!detectedIndent && state.lineIndent > textIndent) {
-      textIndent = state.lineIndent;
+    if (output === input && opts.contains === true) {
+      state.output = input;
+      return state;
     }
 
-    if (is_EOL(ch)) {
-      emptyLines++;
+    state.output = utils$5.wrapOutput(output, state, options);
+    return state;
+  }
+
+  /**
+   * Tokenize input until we reach end-of-string
+   */
+
+  while (!eos()) {
+    value = advance();
+
+    if (value === '\u0000') {
       continue;
     }
 
-    // End of the scalar.
-    if (state.lineIndent < textIndent) {
+    /**
+     * Escaped characters
+     */
 
-      // Perform the chomping.
-      if (chomping === CHOMPING_KEEP) {
-        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
-      } else if (chomping === CHOMPING_CLIP) {
-        if (didReadContent) { // i.e. only if the scalar is not empty.
-          state.result += '\n';
-        }
-      }
+    if (value === '\\') {
+      const next = peek();
 
-      // Break this `while` cycle and go to the funciton's epilogue.
-      break;
-    }
+      if (next === '/' && opts.bash !== true) {
+        continue;
+      }
 
-    // Folded style: use fancy rules to handle line breaks.
-    if (folding) {
+      if (next === '.' || next === ';') {
+        continue;
+      }
 
-      // Lines starting with white space characters (more-indented lines) are not folded.
-      if (is_WHITE_SPACE(ch)) {
-        atMoreIndented = true;
-        // except for the first content line (cf. Example 8.1)
-        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+      if (!next) {
+        value += '\\';
+        push({ type: 'text', value });
+        continue;
+      }
 
-      // End of more-indented block.
-      } else if (atMoreIndented) {
-        atMoreIndented = false;
-        state.result += common.repeat('\n', emptyLines + 1);
+      // collapse slashes to reduce potential for exploits
+      const match = /^\\+/.exec(remaining());
+      let slashes = 0;
 
-      // Just one line break - perceive as the same line.
-      } else if (emptyLines === 0) {
-        if (didReadContent) { // i.e. only if we have already read some scalar content.
-          state.result += ' ';
+      if (match && match[0].length > 2) {
+        slashes = match[0].length;
+        state.index += slashes;
+        if (slashes % 2 !== 0) {
+          value += '\\';
         }
+      }
 
-      // Several line breaks - perceive as different lines.
+      if (opts.unescape === true) {
+        value = advance() || '';
       } else {
-        state.result += common.repeat('\n', emptyLines);
+        value += advance() || '';
       }
 
-    // Literal style: just add exact number of line breaks between content lines.
-    } else {
-      // Keep all line breaks except the header line break.
-      state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+      if (state.brackets === 0) {
+        push({ type: 'text', value });
+        continue;
+      }
     }
 
-    didReadContent = true;
-    detectedIndent = true;
-    emptyLines = 0;
-    captureStart = state.position;
-
-    while (!is_EOL(ch) && (ch !== 0)) {
-      ch = state.input.charCodeAt(++state.position);
-    }
+    /**
+     * If we're inside a regex character class, continue
+     * until we reach the closing bracket.
+     */
 
-    captureSegment(state, captureStart, state.position, false);
-  }
+    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+      if (opts.posix !== false && value === ':') {
+        const inner = prev.value.slice(1);
+        if (inner.includes('[')) {
+          prev.posix = true;
 
-  return true;
-}
+          if (inner.includes(':')) {
+            const idx = prev.value.lastIndexOf('[');
+            const pre = prev.value.slice(0, idx);
+            const rest = prev.value.slice(idx + 2);
+            const posix = POSIX_REGEX_SOURCE[rest];
+            if (posix) {
+              prev.value = pre + posix;
+              state.backtrack = true;
+              advance();
 
-function readBlockSequence(state, nodeIndent) {
-  var _line,
-      _tag      = state.tag,
-      _anchor   = state.anchor,
-      _result   = [],
-      following,
-      detected  = false,
-      ch;
+              if (!bos.output && tokens.indexOf(prev) === 1) {
+                bos.output = ONE_CHAR;
+              }
+              continue;
+            }
+          }
+        }
+      }
 
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
-  }
+      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+        value = `\\${value}`;
+      }
 
-  ch = state.input.charCodeAt(state.position);
+      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+        value = `\\${value}`;
+      }
 
-  while (ch !== 0) {
+      if (opts.posix === true && value === '!' && prev.value === '[') {
+        value = '^';
+      }
 
-    if (ch !== 0x2D/* - */) {
-      break;
+      prev.value += value;
+      append({ value });
+      continue;
     }
 
-    following = state.input.charCodeAt(state.position + 1);
+    /**
+     * If we're inside a quoted string, continue
+     * until we reach the closing double quote.
+     */
 
-    if (!is_WS_OR_EOL(following)) {
-      break;
+    if (state.quotes === 1 && value !== '"') {
+      value = utils$5.escapeRegex(value);
+      prev.value += value;
+      append({ value });
+      continue;
     }
 
-    detected = true;
-    state.position++;
+    /**
+     * Double quotes
+     */
 
-    if (skipSeparationSpace(state, true, -1)) {
-      if (state.lineIndent <= nodeIndent) {
-        _result.push(null);
-        ch = state.input.charCodeAt(state.position);
-        continue;
+    if (value === '"') {
+      state.quotes = state.quotes === 1 ? 0 : 1;
+      if (opts.keepQuotes === true) {
+        push({ type: 'text', value });
       }
+      continue;
     }
 
-    _line = state.line;
-    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
-    _result.push(state.result);
-    skipSeparationSpace(state, true, -1);
-
-    ch = state.input.charCodeAt(state.position);
+    /**
+     * Parentheses
+     */
 
-    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
-      throwError(state, 'bad indentation of a sequence entry');
-    } else if (state.lineIndent < nodeIndent) {
-      break;
+    if (value === '(') {
+      increment('parens');
+      push({ type: 'paren', value });
+      continue;
     }
-  }
 
-  if (detected) {
-    state.tag = _tag;
-    state.anchor = _anchor;
-    state.kind = 'sequence';
-    state.result = _result;
-    return true;
-  }
-  return false;
-}
-
-function readBlockMapping(state, nodeIndent, flowIndent) {
-  var following,
-      allowCompact,
-      _line,
-      _pos,
-      _tag          = state.tag,
-      _anchor       = state.anchor,
-      _result       = {},
-      overridableKeys = {},
-      keyTag        = null,
-      keyNode       = null,
-      valueNode     = null,
-      atExplicitKey = false,
-      detected      = false,
-      ch;
-
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
-  }
+    if (value === ')') {
+      if (state.parens === 0 && opts.strictBrackets === true) {
+        throw new SyntaxError(syntaxError$1('opening', '('));
+      }
 
-  ch = state.input.charCodeAt(state.position);
+      const extglob = extglobs[extglobs.length - 1];
+      if (extglob && state.parens === extglob.parens + 1) {
+        extglobClose(extglobs.pop());
+        continue;
+      }
 
-  while (ch !== 0) {
-    following = state.input.charCodeAt(state.position + 1);
-    _line = state.line; // Save the current line.
-    _pos = state.position;
+      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+      decrement('parens');
+      continue;
+    }
 
-    //
-    // Explicit notation case. There are two separate blocks:
-    // first for the key (denoted by "?") and second for the value (denoted by ":")
-    //
-    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
+    /**
+     * Square brackets
+     */
 
-      if (ch === 0x3F/* ? */) {
-        if (atExplicitKey) {
-          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
-          keyTag = keyNode = valueNode = null;
+    if (value === '[') {
+      if (opts.nobracket === true || !remaining().includes(']')) {
+        if (opts.nobracket !== true && opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError$1('closing', ']'));
         }
 
-        detected = true;
-        atExplicitKey = true;
-        allowCompact = true;
-
-      } else if (atExplicitKey) {
-        // i.e. 0x3A/* : */ === character after the explicit key.
-        atExplicitKey = false;
-        allowCompact = true;
-
+        value = `\\${value}`;
       } else {
-        throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
+        increment('brackets');
       }
 
-      state.position += 1;
-      ch = following;
-
-    //
-    // Implicit notation case. Flow-style node as the key first, then ":", and the value.
-    //
-    } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
+      push({ type: 'bracket', value });
+      continue;
+    }
 
-      if (state.line === _line) {
-        ch = state.input.charCodeAt(state.position);
+    if (value === ']') {
+      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+        push({ type: 'text', value, output: `\\${value}` });
+        continue;
+      }
 
-        while (is_WHITE_SPACE(ch)) {
-          ch = state.input.charCodeAt(++state.position);
+      if (state.brackets === 0) {
+        if (opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError$1('opening', '['));
         }
 
-        if (ch === 0x3A/* : */) {
-          ch = state.input.charCodeAt(++state.position);
-
-          if (!is_WS_OR_EOL(ch)) {
-            throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
-          }
+        push({ type: 'text', value, output: `\\${value}` });
+        continue;
+      }
 
-          if (atExplicitKey) {
-            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
-            keyTag = keyNode = valueNode = null;
-          }
+      decrement('brackets');
 
-          detected = true;
-          atExplicitKey = false;
-          allowCompact = false;
-          keyTag = state.tag;
-          keyNode = state.result;
+      const prevValue = prev.value.slice(1);
+      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+        value = `/${value}`;
+      }
 
-        } else if (detected) {
-          throwError(state, 'can not read an implicit mapping pair; a colon is missed');
+      prev.value += value;
+      append({ value });
 
-        } else {
-          state.tag = _tag;
-          state.anchor = _anchor;
-          return true; // Keep the result of `composeNode`.
-        }
+      // when literal brackets are explicitly disabled
+      // assume we should match with a regex character class
+      if (opts.literalBrackets === false || utils$5.hasRegexChars(prevValue)) {
+        continue;
+      }
 
-      } else if (detected) {
-        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
+      const escaped = utils$5.escapeRegex(prev.value);
+      state.output = state.output.slice(0, -prev.value.length);
 
-      } else {
-        state.tag = _tag;
-        state.anchor = _anchor;
-        return true; // Keep the result of `composeNode`.
+      // when literal brackets are explicitly enabled
+      // assume we should escape the brackets to match literal characters
+      if (opts.literalBrackets === true) {
+        state.output += escaped;
+        prev.value = escaped;
+        continue;
       }
 
-    } else {
-      break; // Reading is done. Go to the epilogue.
+      // when the user specifies nothing, try to match both
+      prev.value = `(${capture}${escaped}|${prev.value})`;
+      state.output += prev.value;
+      continue;
     }
 
-    //
-    // Common reading code for both explicit and implicit notations.
-    //
-    if (state.line === _line || state.lineIndent > nodeIndent) {
-      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
-        if (atExplicitKey) {
-          keyNode = state.result;
-        } else {
-          valueNode = state.result;
-        }
-      }
+    /**
+     * Braces
+     */
 
-      if (!atExplicitKey) {
-        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
-        keyTag = keyNode = valueNode = null;
-      }
+    if (value === '{' && opts.nobrace !== true) {
+      increment('braces');
 
-      skipSeparationSpace(state, true, -1);
-      ch = state.input.charCodeAt(state.position);
-    }
+      const open = {
+        type: 'brace',
+        value,
+        output: '(',
+        outputIndex: state.output.length,
+        tokensIndex: state.tokens.length
+      };
 
-    if (state.lineIndent > nodeIndent && (ch !== 0)) {
-      throwError(state, 'bad indentation of a mapping entry');
-    } else if (state.lineIndent < nodeIndent) {
-      break;
+      braces.push(open);
+      push(open);
+      continue;
     }
-  }
-
-  //
-  // Epilogue.
-  //
 
-  // Special case: last mapping's node contains only the key in explicit notation.
-  if (atExplicitKey) {
-    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
-  }
+    if (value === '}') {
+      const brace = braces[braces.length - 1];
 
-  // Expose the resulting mapping.
-  if (detected) {
-    state.tag = _tag;
-    state.anchor = _anchor;
-    state.kind = 'mapping';
-    state.result = _result;
-  }
+      if (opts.nobrace === true || !brace) {
+        push({ type: 'text', value, output: value });
+        continue;
+      }
 
-  return detected;
-}
+      let output = ')';
 
-function readTagProperty(state) {
-  var _position,
-      isVerbatim = false,
-      isNamed    = false,
-      tagHandle,
-      tagName,
-      ch;
+      if (brace.dots === true) {
+        const arr = tokens.slice();
+        const range = [];
 
-  ch = state.input.charCodeAt(state.position);
+        for (let i = arr.length - 1; i >= 0; i--) {
+          tokens.pop();
+          if (arr[i].type === 'brace') {
+            break;
+          }
+          if (arr[i].type !== 'dots') {
+            range.unshift(arr[i].value);
+          }
+        }
 
-  if (ch !== 0x21/* ! */) return false;
+        output = expandRange(range, opts);
+        state.backtrack = true;
+      }
 
-  if (state.tag !== null) {
-    throwError(state, 'duplication of a tag property');
-  }
+      if (brace.comma !== true && brace.dots !== true) {
+        const out = state.output.slice(0, brace.outputIndex);
+        const toks = state.tokens.slice(brace.tokensIndex);
+        brace.value = brace.output = '\\{';
+        value = output = '\\}';
+        state.output = out;
+        for (const t of toks) {
+          state.output += (t.output || t.value);
+        }
+      }
 
-  ch = state.input.charCodeAt(++state.position);
+      push({ type: 'brace', value, output });
+      decrement('braces');
+      braces.pop();
+      continue;
+    }
 
-  if (ch === 0x3C/* < */) {
-    isVerbatim = true;
-    ch = state.input.charCodeAt(++state.position);
+    /**
+     * Pipes
+     */
 
-  } else if (ch === 0x21/* ! */) {
-    isNamed = true;
-    tagHandle = '!!';
-    ch = state.input.charCodeAt(++state.position);
+    if (value === '|') {
+      if (extglobs.length > 0) {
+        extglobs[extglobs.length - 1].conditions++;
+      }
+      push({ type: 'text', value });
+      continue;
+    }
 
-  } else {
-    tagHandle = '!';
-  }
+    /**
+     * Commas
+     */
 
-  _position = state.position;
+    if (value === ',') {
+      let output = value;
 
-  if (isVerbatim) {
-    do { ch = state.input.charCodeAt(++state.position); }
-    while (ch !== 0 && ch !== 0x3E/* > */);
+      const brace = braces[braces.length - 1];
+      if (brace && stack[stack.length - 1] === 'braces') {
+        brace.comma = true;
+        output = '|';
+      }
 
-    if (state.position < state.length) {
-      tagName = state.input.slice(_position, state.position);
-      ch = state.input.charCodeAt(++state.position);
-    } else {
-      throwError(state, 'unexpected end of the stream within a verbatim tag');
+      push({ type: 'comma', value, output });
+      continue;
     }
-  } else {
-    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-
-      if (ch === 0x21/* ! */) {
-        if (!isNamed) {
-          tagHandle = state.input.slice(_position - 1, state.position + 1);
 
-          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
-            throwError(state, 'named tag handle cannot contain such characters');
-          }
+    /**
+     * Slashes
+     */
 
-          isNamed = true;
-          _position = state.position + 1;
-        } else {
-          throwError(state, 'tag suffix cannot contain exclamation marks');
-        }
+    if (value === '/') {
+      // if the beginning of the glob is "./", advance the start
+      // to the current index, and don't add the "./" characters
+      // to the state. This greatly simplifies lookbehinds when
+      // checking for BOS characters like "!" and "." (not "./")
+      if (prev.type === 'dot' && state.index === state.start + 1) {
+        state.start = state.index + 1;
+        state.consumed = '';
+        state.output = '';
+        tokens.pop();
+        prev = bos; // reset "prev" to the first token
+        continue;
       }
 
-      ch = state.input.charCodeAt(++state.position);
+      push({ type: 'slash', value, output: SLASH_LITERAL });
+      continue;
     }
 
-    tagName = state.input.slice(_position, state.position);
+    /**
+     * Dots
+     */
 
-    if (PATTERN_FLOW_INDICATORS.test(tagName)) {
-      throwError(state, 'tag suffix cannot contain flow indicator characters');
+    if (value === '.') {
+      if (state.braces > 0 && prev.type === 'dot') {
+        if (prev.value === '.') prev.output = DOT_LITERAL;
+        const brace = braces[braces.length - 1];
+        prev.type = 'dots';
+        prev.output += value;
+        prev.value += value;
+        brace.dots = true;
+        continue;
+      }
+
+      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+        push({ type: 'text', value, output: DOT_LITERAL });
+        continue;
+      }
+
+      push({ type: 'dot', value, output: DOT_LITERAL });
+      continue;
     }
-  }
 
-  if (tagName && !PATTERN_TAG_URI.test(tagName)) {
-    throwError(state, 'tag name cannot contain such characters: ' + tagName);
-  }
+    /**
+     * Question marks
+     */
 
-  if (isVerbatim) {
-    state.tag = tagName;
+    if (value === '?') {
+      const isGroup = prev && prev.value === '(';
+      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        extglobOpen('qmark', value);
+        continue;
+      }
 
-  } else if (_hasOwnProperty$2.call(state.tagMap, tagHandle)) {
-    state.tag = state.tagMap[tagHandle] + tagName;
+      if (prev && prev.type === 'paren') {
+        const next = peek();
+        let output = value;
 
-  } else if (tagHandle === '!') {
-    state.tag = '!' + tagName;
+        if (next === '<' && !utils$5.supportsLookbehinds()) {
+          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+        }
 
-  } else if (tagHandle === '!!') {
-    state.tag = 'tag:yaml.org,2002:' + tagName;
+        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+          output = `\\${value}`;
+        }
 
-  } else {
-    throwError(state, 'undeclared tag handle "' + tagHandle + '"');
-  }
+        push({ type: 'text', value, output });
+        continue;
+      }
 
-  return true;
-}
+      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+        continue;
+      }
 
-function readAnchorProperty(state) {
-  var _position,
-      ch;
+      push({ type: 'qmark', value, output: QMARK });
+      continue;
+    }
 
-  ch = state.input.charCodeAt(state.position);
+    /**
+     * Exclamation
+     */
 
-  if (ch !== 0x26/* & */) return false;
+    if (value === '!') {
+      if (opts.noextglob !== true && peek() === '(') {
+        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+          extglobOpen('negate', value);
+          continue;
+        }
+      }
 
-  if (state.anchor !== null) {
-    throwError(state, 'duplication of an anchor property');
-  }
+      if (opts.nonegate !== true && state.index === 0) {
+        negate();
+        continue;
+      }
+    }
 
-  ch = state.input.charCodeAt(++state.position);
-  _position = state.position;
+    /**
+     * Plus
+     */
 
-  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
-    ch = state.input.charCodeAt(++state.position);
-  }
+    if (value === '+') {
+      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        extglobOpen('plus', value);
+        continue;
+      }
 
-  if (state.position === _position) {
-    throwError(state, 'name of an anchor node must contain at least one character');
-  }
+      if ((prev && prev.value === '(') || opts.regex === false) {
+        push({ type: 'plus', value, output: PLUS_LITERAL });
+        continue;
+      }
 
-  state.anchor = state.input.slice(_position, state.position);
-  return true;
-}
+      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+        push({ type: 'plus', value });
+        continue;
+      }
 
-function readAlias(state) {
-  var _position, alias,
-      ch;
+      push({ type: 'plus', value: PLUS_LITERAL });
+      continue;
+    }
 
-  ch = state.input.charCodeAt(state.position);
+    /**
+     * Plain text
+     */
 
-  if (ch !== 0x2A/* * */) return false;
+    if (value === '@') {
+      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        push({ type: 'at', extglob: true, value, output: '' });
+        continue;
+      }
 
-  ch = state.input.charCodeAt(++state.position);
-  _position = state.position;
+      push({ type: 'text', value });
+      continue;
+    }
 
-  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
-    ch = state.input.charCodeAt(++state.position);
-  }
+    /**
+     * Plain text
+     */
 
-  if (state.position === _position) {
-    throwError(state, 'name of an alias node must contain at least one character');
-  }
+    if (value !== '*') {
+      if (value === '$' || value === '^') {
+        value = `\\${value}`;
+      }
 
-  alias = state.input.slice(_position, state.position);
+      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+      if (match) {
+        value += match[0];
+        state.index += match[0].length;
+      }
 
-  if (!state.anchorMap.hasOwnProperty(alias)) {
-    throwError(state, 'unidentified alias "' + alias + '"');
-  }
+      push({ type: 'text', value });
+      continue;
+    }
 
-  state.result = state.anchorMap[alias];
-  skipSeparationSpace(state, true, -1);
-  return true;
-}
+    /**
+     * Stars
+     */
 
-function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
-  var allowBlockStyles,
-      allowBlockScalars,
-      allowBlockCollections,
-      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
-      atNewLine  = false,
-      hasContent = false,
-      typeIndex,
-      typeQuantity,
-      type,
-      flowIndent,
-      blockIndent;
-
-  if (state.listener !== null) {
-    state.listener('open', state);
-  }
+    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+      prev.type = 'star';
+      prev.star = true;
+      prev.value += value;
+      prev.output = star;
+      state.backtrack = true;
+      state.globstar = true;
+      consume(value);
+      continue;
+    }
 
-  state.tag    = null;
-  state.anchor = null;
-  state.kind   = null;
-  state.result = null;
+    let rest = remaining();
+    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+      extglobOpen('star', value);
+      continue;
+    }
 
-  allowBlockStyles = allowBlockScalars = allowBlockCollections =
-    CONTEXT_BLOCK_OUT === nodeContext ||
-    CONTEXT_BLOCK_IN  === nodeContext;
+    if (prev.type === 'star') {
+      if (opts.noglobstar === true) {
+        consume(value);
+        continue;
+      }
 
-  if (allowToSeek) {
-    if (skipSeparationSpace(state, true, -1)) {
-      atNewLine = true;
+      const prior = prev.prev;
+      const before = prior.prev;
+      const isStart = prior.type === 'slash' || prior.type === 'bos';
+      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
 
-      if (state.lineIndent > parentIndent) {
-        indentStatus = 1;
-      } else if (state.lineIndent === parentIndent) {
-        indentStatus = 0;
-      } else if (state.lineIndent < parentIndent) {
-        indentStatus = -1;
+      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+        push({ type: 'star', value, output: '' });
+        continue;
       }
-    }
-  }
 
-  if (indentStatus === 1) {
-    while (readTagProperty(state) || readAnchorProperty(state)) {
-      if (skipSeparationSpace(state, true, -1)) {
-        atNewLine = true;
-        allowBlockCollections = allowBlockStyles;
+      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+        push({ type: 'star', value, output: '' });
+        continue;
+      }
 
-        if (state.lineIndent > parentIndent) {
-          indentStatus = 1;
-        } else if (state.lineIndent === parentIndent) {
-          indentStatus = 0;
-        } else if (state.lineIndent < parentIndent) {
-          indentStatus = -1;
+      // strip consecutive `/**/`
+      while (rest.slice(0, 3) === '/**') {
+        const after = input[state.index + 4];
+        if (after && after !== '/') {
+          break;
         }
-      } else {
-        allowBlockCollections = false;
+        rest = rest.slice(3);
+        consume('/**', 3);
       }
-    }
-  }
-
-  if (allowBlockCollections) {
-    allowBlockCollections = atNewLine || allowCompact;
-  }
-
-  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
-    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
-      flowIndent = parentIndent;
-    } else {
-      flowIndent = parentIndent + 1;
-    }
-
-    blockIndent = state.position - state.lineStart;
-
-    if (indentStatus === 1) {
-      if (allowBlockCollections &&
-          (readBlockSequence(state, blockIndent) ||
-           readBlockMapping(state, blockIndent, flowIndent)) ||
-          readFlowCollection(state, flowIndent)) {
-        hasContent = true;
-      } else {
-        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
-            readSingleQuotedScalar(state, flowIndent) ||
-            readDoubleQuotedScalar(state, flowIndent)) {
-          hasContent = true;
 
-        } else if (readAlias(state)) {
-          hasContent = true;
+      if (prior.type === 'bos' && eos()) {
+        prev.type = 'globstar';
+        prev.value += value;
+        prev.output = globstar(opts);
+        state.output = prev.output;
+        state.globstar = true;
+        consume(value);
+        continue;
+      }
 
-          if (state.tag !== null || state.anchor !== null) {
-            throwError(state, 'alias node should not have any properties');
-          }
+      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+        prior.output = `(?:${prior.output}`;
 
-        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
-          hasContent = true;
+        prev.type = 'globstar';
+        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+        prev.value += value;
+        state.globstar = true;
+        state.output += prior.output + prev.output;
+        consume(value);
+        continue;
+      }
 
-          if (state.tag === null) {
-            state.tag = '?';
-          }
-        }
+      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+        const end = rest[1] !== void 0 ? '|$' : '';
 
-        if (state.anchor !== null) {
-          state.anchorMap[state.anchor] = state.result;
-        }
-      }
-    } else if (indentStatus === 0) {
-      // Special case: block sequences are allowed to have same indentation level as the parent.
-      // http://www.yaml.org/spec/1.2/spec.html#id2799784
-      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
-    }
-  }
+        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+        prior.output = `(?:${prior.output}`;
 
-  if (state.tag !== null && state.tag !== '!') {
-    if (state.tag === '?') {
-      for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
-        type = state.implicitTypes[typeIndex];
+        prev.type = 'globstar';
+        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+        prev.value += value;
 
-        // Implicit resolving is not allowed for non-scalar types, and '?'
-        // non-specific tag is only assigned to plain scalars. So, it isn't
-        // needed to check for 'kind' conformity.
+        state.output += prior.output + prev.output;
+        state.globstar = true;
 
-        if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
-          state.result = type.construct(state.result);
-          state.tag = type.tag;
-          if (state.anchor !== null) {
-            state.anchorMap[state.anchor] = state.result;
-          }
-          break;
-        }
-      }
-    } else if (_hasOwnProperty$2.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
-      type = state.typeMap[state.kind || 'fallback'][state.tag];
+        consume(value + advance());
 
-      if (state.result !== null && type.kind !== state.kind) {
-        throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
+        push({ type: 'slash', value: '/', output: '' });
+        continue;
       }
 
-      if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched
-        throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
-      } else {
-        state.result = type.construct(state.result);
-        if (state.anchor !== null) {
-          state.anchorMap[state.anchor] = state.result;
-        }
+      if (prior.type === 'bos' && rest[0] === '/') {
+        prev.type = 'globstar';
+        prev.value += value;
+        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+        state.output = prev.output;
+        state.globstar = true;
+        consume(value + advance());
+        push({ type: 'slash', value: '/', output: '' });
+        continue;
       }
-    } else {
-      throwError(state, 'unknown tag !<' + state.tag + '>');
-    }
-  }
-
-  if (state.listener !== null) {
-    state.listener('close', state);
-  }
-  return state.tag !== null ||  state.anchor !== null || hasContent;
-}
 
-function readDocument(state) {
-  var documentStart = state.position,
-      _position,
-      directiveName,
-      directiveArgs,
-      hasDirectives = false,
-      ch;
+      // remove single star from output
+      state.output = state.output.slice(0, -prev.output.length);
 
-  state.version = null;
-  state.checkLineBreaks = state.legacy;
-  state.tagMap = {};
-  state.anchorMap = {};
+      // reset previous token to globstar
+      prev.type = 'globstar';
+      prev.output = globstar(opts);
+      prev.value += value;
 
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    skipSeparationSpace(state, true, -1);
+      // reset output with globstar
+      state.output += prev.output;
+      state.globstar = true;
+      consume(value);
+      continue;
+    }
 
-    ch = state.input.charCodeAt(state.position);
+    const token = { type: 'star', value, output: star };
 
-    if (state.lineIndent > 0 || ch !== 0x25/* % */) {
-      break;
+    if (opts.bash === true) {
+      token.output = '.*?';
+      if (prev.type === 'bos' || prev.type === 'slash') {
+        token.output = nodot + token.output;
+      }
+      push(token);
+      continue;
     }
 
-    hasDirectives = true;
-    ch = state.input.charCodeAt(++state.position);
-    _position = state.position;
-
-    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-      ch = state.input.charCodeAt(++state.position);
+    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+      token.output = value;
+      push(token);
+      continue;
     }
 
-    directiveName = state.input.slice(_position, state.position);
-    directiveArgs = [];
+    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+      if (prev.type === 'dot') {
+        state.output += NO_DOT_SLASH;
+        prev.output += NO_DOT_SLASH;
 
-    if (directiveName.length < 1) {
-      throwError(state, 'directive name must not be less than one character in length');
-    }
+      } else if (opts.dot === true) {
+        state.output += NO_DOTS_SLASH;
+        prev.output += NO_DOTS_SLASH;
 
-    while (ch !== 0) {
-      while (is_WHITE_SPACE(ch)) {
-        ch = state.input.charCodeAt(++state.position);
+      } else {
+        state.output += nodot;
+        prev.output += nodot;
       }
 
-      if (ch === 0x23/* # */) {
-        do { ch = state.input.charCodeAt(++state.position); }
-        while (ch !== 0 && !is_EOL(ch));
-        break;
+      if (peek() !== '*') {
+        state.output += ONE_CHAR;
+        prev.output += ONE_CHAR;
       }
+    }
 
-      if (is_EOL(ch)) break;
-
-      _position = state.position;
+    push(token);
+  }
 
-      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-        ch = state.input.charCodeAt(++state.position);
-      }
+  while (state.brackets > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', ']'));
+    state.output = utils$5.escapeLast(state.output, '[');
+    decrement('brackets');
+  }
 
-      directiveArgs.push(state.input.slice(_position, state.position));
-    }
+  while (state.parens > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', ')'));
+    state.output = utils$5.escapeLast(state.output, '(');
+    decrement('parens');
+  }
 
-    if (ch !== 0) readLineBreak(state);
+  while (state.braces > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', '}'));
+    state.output = utils$5.escapeLast(state.output, '{');
+    decrement('braces');
+  }
 
-    if (_hasOwnProperty$2.call(directiveHandlers, directiveName)) {
-      directiveHandlers[directiveName](state, directiveName, directiveArgs);
-    } else {
-      throwWarning(state, 'unknown document directive "' + directiveName + '"');
-    }
+  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
   }
 
-  skipSeparationSpace(state, true, -1);
+  // rebuild the output if we had to backtrack at any point
+  if (state.backtrack === true) {
+    state.output = '';
 
-  if (state.lineIndent === 0 &&
-      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&
-      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
-      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
-    state.position += 3;
-    skipSeparationSpace(state, true, -1);
+    for (const token of state.tokens) {
+      state.output += token.output != null ? token.output : token.value;
 
-  } else if (hasDirectives) {
-    throwError(state, 'directives end mark is expected');
+      if (token.suffix) {
+        state.output += token.suffix;
+      }
+    }
   }
 
-  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
-  skipSeparationSpace(state, true, -1);
+  return state;
+};
 
-  if (state.checkLineBreaks &&
-      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
-    throwWarning(state, 'non-ASCII line breaks are interpreted as content');
+/**
+ * Fast paths for creating regular expressions for common glob patterns.
+ * This can significantly speed up processing and has very little downside
+ * impact when none of the fast paths match.
+ */
+
+parse$e.fastpaths = (input, options) => {
+  const opts = { ...options };
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$4, opts.maxLength) : MAX_LENGTH$4;
+  const len = input.length;
+  if (len > max) {
+    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
   }
 
-  state.documents.push(state.result);
+  input = REPLACEMENTS[input] || input;
+  const win32 = utils$5.isWindows(options);
 
-  if (state.position === state.lineStart && testDocumentSeparator(state)) {
+  // create constants based on platform, for windows or posix
+  const {
+    DOT_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOTS,
+    NO_DOTS_SLASH,
+    STAR,
+    START_ANCHOR
+  } = constants$4.globChars(win32);
 
-    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
-      state.position += 3;
-      skipSeparationSpace(state, true, -1);
-    }
-    return;
-  }
+  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+  const capture = opts.capture ? '' : '?:';
+  const state = { negated: false, prefix: '' };
+  let star = opts.bash === true ? '.*?' : STAR;
 
-  if (state.position < (state.length - 1)) {
-    throwError(state, 'end of the stream or a document separator is expected');
-  } else {
-    return;
+  if (opts.capture) {
+    star = `(${star})`;
   }
-}
 
+  const globstar = (opts) => {
+    if (opts.noglobstar === true) return star;
+    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+  };
 
-function loadDocuments(input, options) {
-  input = String(input);
-  options = options || {};
+  const create = str => {
+    switch (str) {
+      case '*':
+        return `${nodot}${ONE_CHAR}${star}`;
 
-  if (input.length !== 0) {
+      case '.*':
+        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
 
-    // Add tailing `\n` if not exists
-    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
-        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
-      input += '\n';
-    }
+      case '*.*':
+        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
 
-    // Strip BOM
-    if (input.charCodeAt(0) === 0xFEFF) {
-      input = input.slice(1);
-    }
-  }
+      case '*/*':
+        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
 
-  var state = new State(input, options);
+      case '**':
+        return nodot + globstar(opts);
 
-  // Use 0 as string terminator. That significantly simplifies bounds check.
-  state.input += '\0';
+      case '**/*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
 
-  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
-    state.lineIndent += 1;
-    state.position += 1;
-  }
+      case '**/*.*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
 
-  while (state.position < (state.length - 1)) {
-    readDocument(state);
-  }
+      case '**/.*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
 
-  return state.documents;
-}
+      default: {
+        const match = /^(.*?)\.(\w+)$/.exec(str);
+        if (!match) return;
 
+        const source = create(match[1]);
+        if (!source) return;
 
-function loadAll(input, iterator, options) {
-  var documents = loadDocuments(input, options), index, length;
+        return source + DOT_LITERAL + match[2];
+      }
+    }
+  };
 
-  if (typeof iterator !== 'function') {
-    return documents;
-  }
+  const output = utils$5.removePrefix(input, state);
+  let source = create(output);
 
-  for (index = 0, length = documents.length; index < length; index += 1) {
-    iterator(documents[index]);
+  if (source && opts.strictSlashes !== true) {
+    source += `${SLASH_LITERAL}?`;
   }
-}
 
+  return source;
+};
 
-function load(input, options) {
-  var documents = loadDocuments(input, options);
+var parse_1$2 = parse$e;
 
-  if (documents.length === 0) {
-    /*eslint-disable no-undefined*/
-    return undefined;
-  } else if (documents.length === 1) {
-    return documents[0];
-  }
-  throw new exception('expected a single document in the stream, but found more');
-}
+const path$9 = path$b;
+const scan = scan_1;
+const parse$d = parse_1$2;
+const utils$4 = utils$7;
+const constants$3 = constants$5;
+const isObject$3 = val => val && typeof val === 'object' && !Array.isArray(val);
 
+/**
+ * Creates a matcher function from one or more glob patterns. The
+ * returned function takes a string to match as its first argument,
+ * and returns true if the string is a match. The returned matcher
+ * function also takes a boolean as the second argument that, when true,
+ * returns an object with additional information.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch(glob[, options]);
+ *
+ * const isMatch = picomatch('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @name picomatch
+ * @param {String|Array} `globs` One or more glob patterns.
+ * @param {Object=} `options`
+ * @return {Function=} Returns a matcher function.
+ * @api public
+ */
 
-function safeLoadAll(input, output, options) {
-  if (typeof output === 'function') {
-    loadAll(input, output, common.extend({ schema: default_safe }, options));
-  } else {
-    return loadAll(input, common.extend({ schema: default_safe }, options));
+const picomatch$3 = (glob, options, returnState = false) => {
+  if (Array.isArray(glob)) {
+    const fns = glob.map(input => picomatch$3(input, options, returnState));
+    const arrayMatcher = str => {
+      for (const isMatch of fns) {
+        const state = isMatch(str);
+        if (state) return state;
+      }
+      return false;
+    };
+    return arrayMatcher;
   }
-}
 
+  const isState = isObject$3(glob) && glob.tokens && glob.input;
 
-function safeLoad(input, options) {
-  return load(input, common.extend({ schema: default_safe }, options));
-}
+  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+    throw new TypeError('Expected pattern to be a non-empty string');
+  }
 
+  const opts = options || {};
+  const posix = utils$4.isWindows(options);
+  const regex = isState
+    ? picomatch$3.compileRe(glob, options)
+    : picomatch$3.makeRe(glob, options, false, true);
 
-var loadAll_1     = loadAll;
-var load_1        = load;
-var safeLoadAll_1 = safeLoadAll;
-var safeLoad_1    = safeLoad;
+  const state = regex.state;
+  delete regex.state;
 
-var loader = {
-	loadAll: loadAll_1,
-	load: load_1,
-	safeLoadAll: safeLoadAll_1,
-	safeLoad: safeLoad_1
-};
+  let isIgnored = () => false;
+  if (opts.ignore) {
+    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+    isIgnored = picomatch$3(opts.ignore, ignoreOpts, returnState);
+  }
 
-/*eslint-disable no-use-before-define*/
+  const matcher = (input, returnObject = false) => {
+    const { isMatch, match, output } = picomatch$3.test(input, regex, options, { glob, posix });
+    const result = { glob, state, regex, posix, input, output, match, isMatch };
 
+    if (typeof opts.onResult === 'function') {
+      opts.onResult(result);
+    }
 
+    if (isMatch === false) {
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
 
+    if (isIgnored(input)) {
+      if (typeof opts.onIgnore === 'function') {
+        opts.onIgnore(result);
+      }
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
 
+    if (typeof opts.onMatch === 'function') {
+      opts.onMatch(result);
+    }
+    return returnObject ? result : true;
+  };
 
+  if (returnState) {
+    matcher.state = state;
+  }
 
-var _toString$2       = Object.prototype.toString;
-var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+  return matcher;
+};
 
-var CHAR_TAB                  = 0x09; /* Tab */
-var CHAR_LINE_FEED            = 0x0A; /* LF */
-var CHAR_SPACE                = 0x20; /* Space */
-var CHAR_EXCLAMATION          = 0x21; /* ! */
-var CHAR_DOUBLE_QUOTE         = 0x22; /* " */
-var CHAR_SHARP                = 0x23; /* # */
-var CHAR_PERCENT              = 0x25; /* % */
-var CHAR_AMPERSAND            = 0x26; /* & */
-var CHAR_SINGLE_QUOTE         = 0x27; /* ' */
-var CHAR_ASTERISK             = 0x2A; /* * */
-var CHAR_COMMA                = 0x2C; /* , */
-var CHAR_MINUS                = 0x2D; /* - */
-var CHAR_COLON                = 0x3A; /* : */
-var CHAR_GREATER_THAN         = 0x3E; /* > */
-var CHAR_QUESTION             = 0x3F; /* ? */
-var CHAR_COMMERCIAL_AT        = 0x40; /* @ */
-var CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */
-var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
-var CHAR_GRAVE_ACCENT         = 0x60; /* ` */
-var CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */
-var CHAR_VERTICAL_LINE        = 0x7C; /* | */
-var CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */
+/**
+ * Test `input` with the given `regex`. This is used by the main
+ * `picomatch()` function to test the input string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.test(input, regex[, options]);
+ *
+ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp} `regex`
+ * @return {Object} Returns an object with matching info.
+ * @api public
+ */
 
-var ESCAPE_SEQUENCES = {};
+picomatch$3.test = (input, regex, options, { glob, posix } = {}) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected input to be a string');
+  }
 
-ESCAPE_SEQUENCES[0x00]   = '\\0';
-ESCAPE_SEQUENCES[0x07]   = '\\a';
-ESCAPE_SEQUENCES[0x08]   = '\\b';
-ESCAPE_SEQUENCES[0x09]   = '\\t';
-ESCAPE_SEQUENCES[0x0A]   = '\\n';
-ESCAPE_SEQUENCES[0x0B]   = '\\v';
-ESCAPE_SEQUENCES[0x0C]   = '\\f';
-ESCAPE_SEQUENCES[0x0D]   = '\\r';
-ESCAPE_SEQUENCES[0x1B]   = '\\e';
-ESCAPE_SEQUENCES[0x22]   = '\\"';
-ESCAPE_SEQUENCES[0x5C]   = '\\\\';
-ESCAPE_SEQUENCES[0x85]   = '\\N';
-ESCAPE_SEQUENCES[0xA0]   = '\\_';
-ESCAPE_SEQUENCES[0x2028] = '\\L';
-ESCAPE_SEQUENCES[0x2029] = '\\P';
+  if (input === '') {
+    return { isMatch: false, output: '' };
+  }
 
-var DEPRECATED_BOOLEANS_SYNTAX = [
-  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
-  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
-];
+  const opts = options || {};
+  const format = opts.format || (posix ? utils$4.toPosixSlashes : null);
+  let match = input === glob;
+  let output = (match && format) ? format(input) : input;
 
-function compileStyleMap(schema, map) {
-  var result, keys, index, length, tag, style, type;
+  if (match === false) {
+    output = format ? format(input) : input;
+    match = output === glob;
+  }
 
-  if (map === null) return {};
+  if (match === false || opts.capture === true) {
+    if (opts.matchBase === true || opts.basename === true) {
+      match = picomatch$3.matchBase(input, regex, options, posix);
+    } else {
+      match = regex.exec(output);
+    }
+  }
 
-  result = {};
-  keys = Object.keys(map);
+  return { isMatch: Boolean(match), match, output };
+};
 
-  for (index = 0, length = keys.length; index < length; index += 1) {
-    tag = keys[index];
-    style = String(map[tag]);
+/**
+ * Match the basename of a filepath.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.matchBase(input, glob[, options]);
+ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+ * @return {Boolean}
+ * @api public
+ */
 
-    if (tag.slice(0, 2) === '!!') {
-      tag = 'tag:yaml.org,2002:' + tag.slice(2);
-    }
-    type = schema.compiledTypeMap['fallback'][tag];
+picomatch$3.matchBase = (input, glob, options, posix = utils$4.isWindows(options)) => {
+  const regex = glob instanceof RegExp ? glob : picomatch$3.makeRe(glob, options);
+  return regex.test(path$9.basename(input));
+};
 
-    if (type && _hasOwnProperty$3.call(type.styleAliases, style)) {
-      style = type.styleAliases[style];
-    }
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.isMatch(string, patterns[, options]);
+ *
+ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String|Array} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
 
-    result[tag] = style;
-  }
+picomatch$3.isMatch = (str, patterns, options) => picomatch$3(patterns, options)(str);
 
-  return result;
-}
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const result = picomatch.parse(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+ * @api public
+ */
 
-function encodeHex(character) {
-  var string, handle, length;
+picomatch$3.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch$3.parse(p, options));
+  return parse$d(pattern, { ...options, fastpaths: false });
+};
 
-  string = character.toString(16).toUpperCase();
+/**
+ * Scan a glob pattern to separate the pattern into segments.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.scan(input[, options]);
+ *
+ * const result = picomatch.scan('!./foo/*.js');
+ * console.log(result);
+ * { prefix: '!./',
+ *   input: '!./foo/*.js',
+ *   start: 3,
+ *   base: 'foo',
+ *   glob: '*.js',
+ *   isBrace: false,
+ *   isBracket: false,
+ *   isGlob: true,
+ *   isExtglob: false,
+ *   isGlobstar: false,
+ *   negated: true }
+ * ```
+ * @param {String} `input` Glob pattern to scan.
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
 
-  if (character <= 0xFF) {
-    handle = 'x';
-    length = 2;
-  } else if (character <= 0xFFFF) {
-    handle = 'u';
-    length = 4;
-  } else if (character <= 0xFFFFFFFF) {
-    handle = 'U';
-    length = 8;
-  } else {
-    throw new exception('code point within a string may not be greater than 0xFFFFFFFF');
-  }
+picomatch$3.scan = (input, options) => scan(input, options);
 
-  return '\\' + handle + common.repeat('0', length - string.length) + string;
-}
+/**
+ * Create a regular expression from a parsed glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
+ *
+ * console.log(picomatch.compileRe(state));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `options`
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
 
-function State$1(options) {
-  this.schema        = options['schema'] || default_full;
-  this.indent        = Math.max(1, (options['indent'] || 2));
-  this.noArrayIndent = options['noArrayIndent'] || false;
-  this.skipInvalid   = options['skipInvalid'] || false;
-  this.flowLevel     = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
-  this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);
-  this.sortKeys      = options['sortKeys'] || false;
-  this.lineWidth     = options['lineWidth'] || 80;
-  this.noRefs        = options['noRefs'] || false;
-  this.noCompatMode  = options['noCompatMode'] || false;
-  this.condenseFlow  = options['condenseFlow'] || false;
+picomatch$3.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
+  if (returnOutput === true) {
+    return parsed.output;
+  }
 
-  this.implicitTypes = this.schema.compiledImplicit;
-  this.explicitTypes = this.schema.compiledExplicit;
+  const opts = options || {};
+  const prepend = opts.contains ? '' : '^';
+  const append = opts.contains ? '' : '$';
 
-  this.tag = null;
-  this.result = '';
+  let source = `${prepend}(?:${parsed.output})${append}`;
+  if (parsed && parsed.negated === true) {
+    source = `^(?!${source}).*$`;
+  }
 
-  this.duplicates = [];
-  this.usedDuplicates = null;
-}
+  const regex = picomatch$3.toRegex(source, options);
+  if (returnState === true) {
+    regex.state = parsed;
+  }
 
-// Indents every line in a string. Empty lines (\n only) are not indented.
-function indentString(string, spaces) {
-  var ind = common.repeat(' ', spaces),
-      position = 0,
-      next = -1,
-      result = '',
-      line,
-      length = string.length;
+  return regex;
+};
 
-  while (position < length) {
-    next = string.indexOf('\n', position);
-    if (next === -1) {
-      line = string.slice(position);
-      position = length;
-    } else {
-      line = string.slice(position, next + 1);
-      position = next + 1;
-    }
+picomatch$3.makeRe = (input, options, returnOutput = false, returnState = false) => {
+  if (!input || typeof input !== 'string') {
+    throw new TypeError('Expected a non-empty string');
+  }
 
-    if (line.length && line !== '\n') result += ind;
+  const opts = options || {};
+  let parsed = { negated: false, fastpaths: true };
+  let prefix = '';
+  let output;
 
-    result += line;
+  if (input.startsWith('./')) {
+    input = input.slice(2);
+    prefix = parsed.prefix = './';
   }
 
-  return result;
-}
+  if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+    output = parse$d.fastpaths(input, options);
+  }
 
-function generateNextLine(state, level) {
-  return '\n' + common.repeat(' ', state.indent * level);
-}
+  if (output === undefined) {
+    parsed = parse$d(input, options);
+    parsed.prefix = prefix + (parsed.prefix || '');
+  } else {
+    parsed.output = output;
+  }
 
-function testImplicitResolving(state, str) {
-  var index, length, type;
+  return picomatch$3.compileRe(parsed, options, returnOutput, returnState);
+};
 
-  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
-    type = state.implicitTypes[index];
+/**
+ * Create a regular expression from the given regex source string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.toRegex(source[, options]);
+ *
+ * const { output } = picomatch.parse('*.js');
+ * console.log(picomatch.toRegex(output));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `source` Regular expression source string.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
 
-    if (type.resolve(str)) {
-      return true;
-    }
+picomatch$3.toRegex = (source, options) => {
+  try {
+    const opts = options || {};
+    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+  } catch (err) {
+    if (options && options.debug === true) throw err;
+    return /$^/;
   }
+};
 
-  return false;
-}
+/**
+ * Picomatch constants.
+ * @return {Object}
+ */
 
-// [33] s-white ::= s-space | s-tab
-function isWhitespace(c) {
-  return c === CHAR_SPACE || c === CHAR_TAB;
-}
+picomatch$3.constants = constants$3;
 
-// Returns true if the character can be printed without escaping.
-// From YAML 1.2: "any allowed characters known to be non-printable
-// should also be escaped. [However,] This isn’t mandatory"
-// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
-function isPrintable(c) {
-  return  (0x00020 <= c && c <= 0x00007E)
-      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
-      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */)
-      ||  (0x10000 <= c && c <= 0x10FFFF);
-}
+/**
+ * Expose "picomatch"
+ */
 
-// Simplified test for values allowed after the first character in plain style.
-function isPlainSafe(c) {
-  // Uses a subset of nb-char - c-flow-indicator - ":" - "#"
-  // where nb-char ::= c-printable - b-char - c-byte-order-mark.
-  return isPrintable(c) && c !== 0xFEFF
-    // - c-flow-indicator
-    && c !== CHAR_COMMA
-    && c !== CHAR_LEFT_SQUARE_BRACKET
-    && c !== CHAR_RIGHT_SQUARE_BRACKET
-    && c !== CHAR_LEFT_CURLY_BRACKET
-    && c !== CHAR_RIGHT_CURLY_BRACKET
-    // - ":" - "#"
-    && c !== CHAR_COLON
-    && c !== CHAR_SHARP;
-}
+var picomatch_1 = picomatch$3;
 
-// Simplified test for values allowed as the first character in plain style.
-function isPlainSafeFirst(c) {
-  // Uses a subset of ns-char - c-indicator
-  // where ns-char = nb-char - s-white.
-  return isPrintable(c) && c !== 0xFEFF
-    && !isWhitespace(c) // - s-white
-    // - (c-indicator ::=
-    // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
-    && c !== CHAR_MINUS
-    && c !== CHAR_QUESTION
-    && c !== CHAR_COLON
-    && c !== CHAR_COMMA
-    && c !== CHAR_LEFT_SQUARE_BRACKET
-    && c !== CHAR_RIGHT_SQUARE_BRACKET
-    && c !== CHAR_LEFT_CURLY_BRACKET
-    && c !== CHAR_RIGHT_CURLY_BRACKET
-    // | “#” | “&” | “*” | “!” | “|” | “>” | “'” | “"”
-    && c !== CHAR_SHARP
-    && c !== CHAR_AMPERSAND
-    && c !== CHAR_ASTERISK
-    && c !== CHAR_EXCLAMATION
-    && c !== CHAR_VERTICAL_LINE
-    && c !== CHAR_GREATER_THAN
-    && c !== CHAR_SINGLE_QUOTE
-    && c !== CHAR_DOUBLE_QUOTE
-    // | “%” | “@” | “`”)
-    && c !== CHAR_PERCENT
-    && c !== CHAR_COMMERCIAL_AT
-    && c !== CHAR_GRAVE_ACCENT;
-}
+var picomatch$2 = picomatch_1;
 
-// Determines whether block indentation indicator is required.
-function needIndentIndicator(string) {
-  var leadingSpaceRe = /^\n* /;
-  return leadingSpaceRe.test(string);
-}
+const fs$9 = require$$0$3;
+const { Readable } = require$$1;
+const sysPath$3 = path$b;
+const { promisify: promisify$3 } = require$$0$4;
+const picomatch$1 = picomatch$2;
 
-var STYLE_PLAIN   = 1,
-    STYLE_SINGLE  = 2,
-    STYLE_LITERAL = 3,
-    STYLE_FOLDED  = 4,
-    STYLE_DOUBLE  = 5;
+const readdir$1 = promisify$3(fs$9.readdir);
+const stat$3 = promisify$3(fs$9.stat);
+const lstat$2 = promisify$3(fs$9.lstat);
+const realpath$2 = promisify$3(fs$9.realpath);
 
-// Determines which scalar styles are possible and returns the preferred style.
-// lineWidth = -1 => no limit.
-// Pre-conditions: str.length > 0.
-// Post-conditions:
-//    STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
-//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
-//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
-function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
-  var i;
-  var char;
-  var hasLineBreak = false;
-  var hasFoldableLine = false; // only checked if shouldTrackWidth
-  var shouldTrackWidth = lineWidth !== -1;
-  var previousLineBreak = -1; // count the first line correctly
-  var plain = isPlainSafeFirst(string.charCodeAt(0))
-          && !isWhitespace(string.charCodeAt(string.length - 1));
+/**
+ * @typedef {Object} EntryInfo
+ * @property {String} path
+ * @property {String} fullPath
+ * @property {fs.Stats=} stats
+ * @property {fs.Dirent=} dirent
+ * @property {String} basename
+ */
 
-  if (singleLineOnly) {
-    // Case: no block styles.
-    // Check for disallowed characters to rule out plain and single.
-    for (i = 0; i < string.length; i++) {
-      char = string.charCodeAt(i);
-      if (!isPrintable(char)) {
-        return STYLE_DOUBLE;
+const BANG$2 = '!';
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const FILE_TYPE = 'files';
+const DIR_TYPE = 'directories';
+const FILE_DIR_TYPE = 'files_directories';
+const EVERYTHING_TYPE = 'all';
+const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
+
+const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);
+const [maj, min] = process.versions.node.split('.').slice(0, 2).map(n => Number.parseInt(n, 10));
+const wantBigintFsStats = process.platform === 'win32' && (maj > 10 || (maj === 10 && min >= 5));
+
+const normalizeFilter = filter => {
+  if (filter === undefined) return;
+  if (typeof filter === 'function') return filter;
+
+  if (typeof filter === 'string') {
+    const glob = picomatch$1(filter.trim());
+    return entry => glob(entry.basename);
+  }
+
+  if (Array.isArray(filter)) {
+    const positive = [];
+    const negative = [];
+    for (const item of filter) {
+      const trimmed = item.trim();
+      if (trimmed.charAt(0) === BANG$2) {
+        negative.push(picomatch$1(trimmed.slice(1)));
+      } else {
+        positive.push(picomatch$1(trimmed));
       }
-      plain = plain && isPlainSafe(char);
     }
-  } else {
-    // Case: block styles permitted.
-    for (i = 0; i < string.length; i++) {
-      char = string.charCodeAt(i);
-      if (char === CHAR_LINE_FEED) {
-        hasLineBreak = true;
-        // Check if any line can be folded.
-        if (shouldTrackWidth) {
-          hasFoldableLine = hasFoldableLine ||
-            // Foldable line = too long, and not more-indented.
-            (i - previousLineBreak - 1 > lineWidth &&
-             string[previousLineBreak + 1] !== ' ');
-          previousLineBreak = i;
-        }
-      } else if (!isPrintable(char)) {
-        return STYLE_DOUBLE;
+
+    if (negative.length > 0) {
+      if (positive.length > 0) {
+        return entry =>
+          positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
       }
-      plain = plain && isPlainSafe(char);
+      return entry => !negative.some(f => f(entry.basename));
     }
-    // in case the end is missing a \n
-    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
-      (i - previousLineBreak - 1 > lineWidth &&
-       string[previousLineBreak + 1] !== ' '));
-  }
-  // Although every style can represent \n without escaping, prefer block styles
-  // for multiline, since they're more readable and they don't add empty lines.
-  // Also prefer folding a super-long line.
-  if (!hasLineBreak && !hasFoldableLine) {
-    // Strings interpretable as another type have to be quoted;
-    // e.g. the string 'true' vs. the boolean true.
-    return plain && !testAmbiguousType(string)
-      ? STYLE_PLAIN : STYLE_SINGLE;
+    return entry => positive.some(f => f(entry.basename));
   }
-  // Edge case: block indentation indicator can only have one digit.
-  if (indentPerLevel > 9 && needIndentIndicator(string)) {
-    return STYLE_DOUBLE;
+};
+
+class ReaddirpStream extends Readable {
+  static get defaultOptions() {
+    return {
+      root: '.',
+      /* eslint-disable no-unused-vars */
+      fileFilter: (path) => true,
+      directoryFilter: (path) => true,
+      /* eslint-enable no-unused-vars */
+      type: FILE_TYPE,
+      lstat: false,
+      depth: 2147483648,
+      alwaysStat: false
+    };
   }
-  // At this point we know block styles are valid.
-  // Prefer literal style unless we want to fold.
-  return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
-}
 
-// Note: line breaking/folding is implemented for only the folded style.
-// NB. We drop the last trailing newline (if any) of a returned block scalar
-//  since the dumper adds its own newline. This always works:
-//    • No ending newline => unaffected; already using strip "-" chomping.
-//    • Ending newline    => removed then restored.
-//  Importantly, this keeps the "+" chomp indicator from gaining an extra line.
-function writeScalar(state, string, level, iskey) {
-  state.dump = (function () {
-    if (string.length === 0) {
-      return "''";
-    }
-    if (!state.noCompatMode &&
-        DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
-      return "'" + string + "'";
-    }
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark || 4096
+    });
+    const opts = { ...ReaddirpStream.defaultOptions, ...options };
+    const { root, type } = opts;
 
-    var indent = state.indent * Math.max(1, level); // no 0-indent scalars
-    // As indentation gets deeper, let the width decrease monotonically
-    // to the lower bound min(state.lineWidth, 40).
-    // Note that this implies
-    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
-    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.
-    // This behaves better than a constant minimum width which disallows narrower options,
-    // or an indent threshold which causes the width to suddenly increase.
-    var lineWidth = state.lineWidth === -1
-      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
 
-    // Without knowing if keys are implicit/explicit, assume implicit for safety.
-    var singleLineOnly = iskey
-      // No block styles in flow mode.
-      || (state.flowLevel > -1 && level >= state.flowLevel);
-    function testAmbiguity(string) {
-      return testImplicitResolving(state, string);
+    const statMethod = opts.lstat ? lstat$2 : stat$3;
+    // Use bigint stats if it's windows and stat() supports options (node 10+).
+    if (wantBigintFsStats) {
+      this._stat = path => statMethod(path, { bigint: true });
+    } else {
+      this._stat = statMethod;
     }
 
-    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
-      case STYLE_PLAIN:
-        return string;
-      case STYLE_SINGLE:
-        return "'" + string.replace(/'/g, "''") + "'";
-      case STYLE_LITERAL:
-        return '|' + blockHeader(string, state.indent)
-          + dropEndingNewline(indentString(string, indent));
-      case STYLE_FOLDED:
-        return '>' + blockHeader(string, state.indent)
-          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
-      case STYLE_DOUBLE:
-        return '"' + escapeString(string) + '"';
-      default:
-        throw new exception('impossible error: invalid scalar style');
-    }
-  }());
-}
-
-// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
-function blockHeader(string, indentPerLevel) {
-  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
+    this._maxDepth = opts.depth;
+    this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+    this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+    this._wantsEverything = type === EVERYTHING_TYPE;
+    this._root = sysPath$3.resolve(root);
+    this._isDirent = ('Dirent' in fs$9) && !opts.alwaysStat;
+    this._statsProp = this._isDirent ? 'dirent' : 'stats';
+    this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
 
-  // note the special case: the string '\n' counts as a "trailing" empty line.
-  var clip =          string[string.length - 1] === '\n';
-  var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
-  var chomp = keep ? '+' : (clip ? '' : '-');
+    // Launch stream with one parent, the root dir.
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = undefined;
+  }
 
-  return indentIndicator + chomp + '\n';
-}
+  async _read(batch) {
+    if (this.reading) return;
+    this.reading = true;
 
-// (See the note for writeScalar.)
-function dropEndingNewline(string) {
-  return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
-}
+    try {
+      while (!this.destroyed && batch > 0) {
+        const { path, depth, files = [] } = this.parent || {};
 
-// Note: a long line without a suitable break point will exceed the width limit.
-// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
-function foldString(string, width) {
-  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
-  // unless they're before or after a more-indented line, or at the very
-  // beginning or end, in which case $k$ maps to $k$.
-  // Therefore, parse each chunk as newline(s) followed by a content line.
-  var lineRe = /(\n+)([^\n]*)/g;
+        if (files.length > 0) {
+          const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
+          for (const entry of await Promise.all(slice)) {
+            if (this.destroyed) return;
 
-  // first line (possibly an empty line)
-  var result = (function () {
-    var nextLF = string.indexOf('\n');
-    nextLF = nextLF !== -1 ? nextLF : string.length;
-    lineRe.lastIndex = nextLF;
-    return foldLine(string.slice(0, nextLF), width);
-  }());
-  // If we haven't reached the first content line yet, don't add an extra \n.
-  var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
-  var moreIndented;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === 'directory' && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
 
-  // rest of the lines
-  var match;
-  while ((match = lineRe.exec(string))) {
-    var prefix = match[1], line = match[2];
-    moreIndented = (line[0] === ' ');
-    result += prefix
-      + (!prevMoreIndented && !moreIndented && line !== ''
-        ? '\n' : '')
-      + foldLine(line, width);
-    prevMoreIndented = moreIndented;
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed) return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
   }
 
-  return result;
-}
-
-// Greedy line breaking.
-// Picks the longest line under the limit each time,
-// otherwise settles for the shortest line over the limit.
-// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
-function foldLine(line, width) {
-  if (line === '' || line[0] === ' ') return line;
-
-  // Since a more-indented line adds a \n, breaks can't be followed by a space.
-  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
-  var match;
-  // start is an inclusive index. end, curr, and next are exclusive.
-  var start = 0, end, curr = 0, next = 0;
-  var result = '';
-
-  // Invariants: 0 <= start <= length-1.
-  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.
-  // Inside the loop:
-  //   A match implies length >= 2, so curr and next are <= length-2.
-  while ((match = breakRe.exec(line))) {
-    next = match.index;
-    // maintain invariant: curr - start <= width
-    if (next - start > width) {
-      end = (curr > start) ? curr : next; // derive end <= length-2
-      result += '\n' + line.slice(start, end);
-      // skip the space that was output as \n
-      start = end + 1;                    // derive start <= length-1
+  async _exploreDir(path, depth) {
+    let files;
+    try {
+      files = await readdir$1(path, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
     }
-    curr = next;
+    return { files, depth, path };
   }
 
-  // By the invariants, start <= length-1, so there is something left over.
-  // It is either the whole string or a part starting from non-whitespace.
-  result += '\n';
-  // Insert a break if the remainder is too long and there is a break available.
-  if (line.length - start > width && curr > start) {
-    result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
-  } else {
-    result += line.slice(start);
+  async _formatEntry(dirent, path) {
+    let entry;
+    try {
+      const basename = this._isDirent ? dirent.name : dirent;
+      const fullPath = sysPath$3.resolve(sysPath$3.join(path, basename));
+      entry = { path: sysPath$3.relative(this._root, fullPath), fullPath, basename };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+    }
+    return entry;
   }
 
-  return result.slice(1); // drop extra \n joiner
-}
-
-// Escapes a double-quoted string.
-function escapeString(string) {
-  var result = '';
-  var char, nextChar;
-  var escapeSeq;
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit('warn', err);
+    } else {
+      this.destroy(err);
+    }
+  }
 
-  for (var i = 0; i < string.length; i++) {
-    char = string.charCodeAt(i);
-    // Check for surrogate pairs (reference Unicode 3.0 section "3.7 Surrogates").
-    if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) {
-      nextChar = string.charCodeAt(i + 1);
-      if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) {
-        // Combine the surrogate pair and store it escaped.
-        result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);
-        // Advance index one extra since we already used that char here.
-        i++; continue;
+  async _getEntryType(entry) {
+    // entry may be undefined, because a warning or an error were emitted
+    // and the statsProp is undefined
+    const stats = entry && entry[this._statsProp];
+    if (!stats) {
+      return;
+    }
+    if (stats.isFile()) {
+      return 'file';
+    }
+    if (stats.isDirectory()) {
+      return 'directory';
+    }
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath$2(full);
+        const entryRealPathStats = await lstat$2(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return 'file';
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath$3.sep) {
+            const recursiveError = new Error(
+              `Circular symlink detected: "${full}" points to "${entryRealPath}"`
+            );
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return 'directory';
+        }
+      } catch (error) {
+        this._onError(error);
       }
     }
-    escapeSeq = ESCAPE_SEQUENCES[char];
-    result += !escapeSeq && isPrintable(char)
-      ? string[i]
-      : escapeSeq || encodeHex(char);
   }
 
-  return result;
-}
-
-function writeFlowSequence(state, level, object) {
-  var _result = '',
-      _tag    = state.tag,
-      index,
-      length;
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
 
-  for (index = 0, length = object.length; index < length; index += 1) {
-    // Write only valid elements.
-    if (writeNode(state, level, object[index], false, false)) {
-      if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');
-      _result += state.dump;
-    }
+    return stats && this._wantsEverything && !stats.isDirectory();
   }
-
-  state.tag = _tag;
-  state.dump = '[' + _result + ']';
 }
 
-function writeBlockSequence(state, level, object, compact) {
-  var _result = '',
-      _tag    = state.tag,
-      index,
-      length;
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    // Write only valid elements.
-    if (writeNode(state, level + 1, object[index], true, true)) {
-      if (!compact || index !== 0) {
-        _result += generateNextLine(state, level);
-      }
-
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-        _result += '-';
-      } else {
-        _result += '- ';
-      }
+/**
+ * @typedef {Object} ReaddirpArguments
+ * @property {Function=} fileFilter
+ * @property {Function=} directoryFilter
+ * @property {String=} type
+ * @property {Number=} depth
+ * @property {String=} root
+ * @property {Boolean=} lstat
+ * @property {Boolean=} bigint
+ */
 
-      _result += state.dump;
-    }
+/**
+ * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
+ * @param {String} root Root directory
+ * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
+ */
+const readdirp$1 = (root, options = {}) => {
+  let type = options.entryType || options.type;
+  if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
+  if (type) options.type = type;
+  if (!root) {
+    throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+  } else if (typeof root !== 'string') {
+    throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
   }
 
-  state.tag = _tag;
-  state.dump = _result || '[]'; // Empty sequence if no valid values.
-}
+  options.root = root;
+  return new ReaddirpStream(options);
+};
 
-function writeFlowMapping(state, level, object) {
-  var _result       = '',
-      _tag          = state.tag,
-      objectKeyList = Object.keys(object),
-      index,
-      length,
-      objectKey,
-      objectValue,
-      pairBuffer;
+const readdirpPromise = (root, options = {}) => {
+  return new Promise((resolve, reject) => {
+    const files = [];
+    readdirp$1(root, options)
+      .on('data', entry => files.push(entry))
+      .on('end', () => resolve(files))
+      .on('error', error => reject(error));
+  });
+};
 
-  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-    pairBuffer = state.condenseFlow ? '"' : '';
+readdirp$1.promise = readdirpPromise;
+readdirp$1.ReaddirpStream = ReaddirpStream;
+readdirp$1.default = readdirp$1;
 
-    if (index !== 0) pairBuffer += ', ';
+var readdirp_1 = readdirp$1;
 
-    objectKey = objectKeyList[index];
-    objectValue = object[objectKey];
+var anymatch$2 = {exports: {}};
 
-    if (!writeNode(state, level, objectKey, false, false)) {
-      continue; // Skip this pair because of invalid key;
-    }
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
 
-    if (state.dump.length > 1024) pairBuffer += '? ';
+var normalizePath$2 = function(path, stripTrailing) {
+  if (typeof path !== 'string') {
+    throw new TypeError('expected path to be a string');
+  }
 
-    pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
+  if (path === '\\' || path === '/') return '/';
 
-    if (!writeNode(state, level, objectValue, false, false)) {
-      continue; // Skip this pair because of invalid value.
-    }
+  var len = path.length;
+  if (len <= 1) return path;
 
-    pairBuffer += state.dump;
+  // ensure that win32 namespaces has two leading slashes, so that the path is
+  // handled properly by the win32 version of path.parse() after being normalized
+  // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
+  var prefix = '';
+  if (len > 4 && path[3] === '\\') {
+    var ch = path[2];
+    if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
+      path = path.slice(2);
+      prefix = '//';
+    }
+  }
 
-    // Both key and value are valid.
-    _result += pairBuffer;
+  var segs = path.split(/[/\\]+/);
+  if (stripTrailing !== false && segs[segs.length - 1] === '') {
+    segs.pop();
   }
+  return prefix + segs.join('/');
+};
 
-  state.tag = _tag;
-  state.dump = '{' + _result + '}';
-}
+Object.defineProperty(anymatch$2.exports, "__esModule", { value: true });
 
-function writeBlockMapping(state, level, object, compact) {
-  var _result       = '',
-      _tag          = state.tag,
-      objectKeyList = Object.keys(object),
-      index,
-      length,
-      objectKey,
-      objectValue,
-      explicitPair,
-      pairBuffer;
+const picomatch = picomatch$2;
+const normalizePath$1 = normalizePath$2;
 
-  // Allow sorting keys so that the output file is deterministic
-  if (state.sortKeys === true) {
-    // Default sorting
-    objectKeyList.sort();
-  } else if (typeof state.sortKeys === 'function') {
-    // Custom sort function
-    objectKeyList.sort(state.sortKeys);
-  } else if (state.sortKeys) {
-    // Something is wrong
-    throw new exception('sortKeys must be a boolean or a function');
+/**
+ * @typedef {(testString: string) => boolean} AnymatchFn
+ * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
+ * @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
+ */
+const BANG$1 = '!';
+const DEFAULT_OPTIONS = {returnIndex: false};
+const arrify$1 = (item) => Array.isArray(item) ? item : [item];
+
+/**
+ * @param {AnymatchPattern} matcher
+ * @param {object} options
+ * @returns {AnymatchFn}
+ */
+const createPattern = (matcher, options) => {
+  if (typeof matcher === 'function') {
+    return matcher;
+  }
+  if (typeof matcher === 'string') {
+    const glob = picomatch(matcher, options);
+    return (string) => matcher === string || glob(string);
+  }
+  if (matcher instanceof RegExp) {
+    return (string) => matcher.test(string);
   }
+  return (string) => false;
+};
 
-  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-    pairBuffer = '';
+/**
+ * @param {Array<Function>} patterns
+ * @param {Array<Function>} negPatterns
+ * @param {String|Array} args
+ * @param {Boolean} returnIndex
+ * @returns {boolean|number}
+ */
+const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
+  const isList = Array.isArray(args);
+  const _path = isList ? args[0] : args;
+  if (!isList && typeof _path !== 'string') {
+    throw new TypeError('anymatch: second argument must be a string: got ' +
+      Object.prototype.toString.call(_path))
+  }
+  const path = normalizePath$1(_path);
 
-    if (!compact || index !== 0) {
-      pairBuffer += generateNextLine(state, level);
+  for (let index = 0; index < negPatterns.length; index++) {
+    const nglob = negPatterns[index];
+    if (nglob(path)) {
+      return returnIndex ? -1 : false;
     }
+  }
 
-    objectKey = objectKeyList[index];
-    objectValue = object[objectKey];
-
-    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
-      continue; // Skip this pair because of invalid key.
+  const applied = isList && [path].concat(args.slice(1));
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (isList ? pattern(...applied) : pattern(path)) {
+      return returnIndex ? index : true;
     }
+  }
 
-    explicitPair = (state.tag !== null && state.tag !== '?') ||
-                   (state.dump && state.dump.length > 1024);
+  return returnIndex ? -1 : false;
+};
 
-    if (explicitPair) {
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-        pairBuffer += '?';
-      } else {
-        pairBuffer += '? ';
-      }
-    }
+/**
+ * @param {AnymatchMatcher} matchers
+ * @param {Array|string} testString
+ * @param {object} options
+ * @returns {boolean|number|Function}
+ */
+const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
+  if (matchers == null) {
+    throw new TypeError('anymatch: specify first argument');
+  }
+  const opts = typeof options === 'boolean' ? {returnIndex: options} : options;
+  const returnIndex = opts.returnIndex || false;
 
-    pairBuffer += state.dump;
+  // Early cache for matchers.
+  const mtchers = arrify$1(matchers);
+  const negatedGlobs = mtchers
+    .filter(item => typeof item === 'string' && item.charAt(0) === BANG$1)
+    .map(item => item.slice(1))
+    .map(item => picomatch(item, opts));
+  const patterns = mtchers
+    .filter(item => typeof item !== 'string' || (typeof item === 'string' && item.charAt(0) !== BANG$1))
+    .map(matcher => createPattern(matcher, opts));
 
-    if (explicitPair) {
-      pairBuffer += generateNextLine(state, level);
+  if (testString == null) {
+    return (testString, ri = false) => {
+      const returnIndex = typeof ri === 'boolean' ? ri : false;
+      return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
     }
+  }
 
-    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
-      continue; // Skip this pair because of invalid value.
-    }
+  return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+};
 
-    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-      pairBuffer += ':';
-    } else {
-      pairBuffer += ': ';
-    }
+anymatch$1.default = anymatch$1;
+anymatch$2.exports = anymatch$1;
 
-    pairBuffer += state.dump;
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
 
-    // Both key and value are valid.
-    _result += pairBuffer;
+var isExtglob$1 = function isExtglob(str) {
+  if (typeof str !== 'string' || str === '') {
+    return false;
   }
 
-  state.tag = _tag;
-  state.dump = _result || '{}'; // Empty mapping if no valid pairs.
-}
+  var match;
+  while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
+    if (match[2]) return true;
+    str = str.slice(match.index + match[0].length);
+  }
 
-function detectType(state, object, explicit) {
-  var _result, typeList, index, length, type, style;
+  return false;
+};
 
-  typeList = explicit ? state.explicitTypes : state.implicitTypes;
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
 
-  for (index = 0, length = typeList.length; index < length; index += 1) {
-    type = typeList[index];
+var isExtglob = isExtglob$1;
+var chars$1 = { '{': '}', '(': ')', '[': ']'};
+var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
+var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
 
-    if ((type.instanceOf  || type.predicate) &&
-        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
-        (!type.predicate  || type.predicate(object))) {
+var isGlob$2 = function isGlob(str, options) {
+  if (typeof str !== 'string' || str === '') {
+    return false;
+  }
 
-      state.tag = explicit ? type.tag : '?';
+  if (isExtglob(str)) {
+    return true;
+  }
 
-      if (type.represent) {
-        style = state.styleMap[type.tag] || type.defaultStyle;
+  var regex = strictRegex;
+  var match;
 
-        if (_toString$2.call(type.represent) === '[object Function]') {
-          _result = type.represent(object, style);
-        } else if (_hasOwnProperty$3.call(type.represent, style)) {
-          _result = type.represent[style](object, style);
-        } else {
-          throw new exception('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
-        }
+  // optionally relax regex
+  if (options && options.strict === false) {
+    regex = relaxedRegex;
+  }
 
-        state.dump = _result;
-      }
+  while ((match = regex.exec(str))) {
+    if (match[2]) return true;
+    var idx = match.index + match[0].length;
 
-      return true;
+    // if an open bracket/brace/paren is escaped,
+    // set the index to the next closing character
+    var open = match[1];
+    var close = open ? chars$1[open] : null;
+    if (open && close) {
+      var n = str.indexOf(close, idx);
+      if (n !== -1) {
+        idx = n + 1;
+      }
     }
-  }
 
+    str = str.slice(idx);
+  }
   return false;
-}
+};
 
-// Serializes `object` and writes it to global `result`.
-// Returns true on success, or false on invalid object.
-//
-function writeNode(state, level, object, block, compact, iskey) {
-  state.tag = null;
-  state.dump = object;
-
-  if (!detectType(state, object, false)) {
-    detectType(state, object, true);
-  }
+var isGlob$1 = isGlob$2;
+var pathPosixDirname = path$b.posix.dirname;
+var isWin32 = require$$0$2.platform() === 'win32';
 
-  var type = _toString$2.call(state.dump);
-
-  if (block) {
-    block = (state.flowLevel < 0 || state.flowLevel > level);
-  }
+var slash = '/';
+var backslash = /\\/g;
+var enclosure = /[\{\[].*[\}\]]$/;
+var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
 
-  var objectOrArray = type === '[object Object]' || type === '[object Array]',
-      duplicateIndex,
-      duplicate;
+/**
+ * @param {string} str
+ * @param {Object} opts
+ * @param {boolean} [opts.flipBackslashes=true]
+ * @returns {string}
+ */
+var globParent$1 = function globParent(str, opts) {
+  var options = Object.assign({ flipBackslashes: true }, opts);
 
-  if (objectOrArray) {
-    duplicateIndex = state.duplicates.indexOf(object);
-    duplicate = duplicateIndex !== -1;
+  // flip windows path separators
+  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+    str = str.replace(backslash, slash);
   }
 
-  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
-    compact = false;
+  // special case for strings ending in enclosure containing path separator
+  if (enclosure.test(str)) {
+    str += slash;
   }
 
-  if (duplicate && state.usedDuplicates[duplicateIndex]) {
-    state.dump = '*ref_' + duplicateIndex;
-  } else {
-    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
-      state.usedDuplicates[duplicateIndex] = true;
-    }
-    if (type === '[object Object]') {
-      if (block && (Object.keys(state.dump).length !== 0)) {
-        writeBlockMapping(state, level, state.dump, compact);
-        if (duplicate) {
-          state.dump = '&ref_' + duplicateIndex + state.dump;
-        }
-      } else {
-        writeFlowMapping(state, level, state.dump);
-        if (duplicate) {
-          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
-        }
-      }
-    } else if (type === '[object Array]') {
-      var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;
-      if (block && (state.dump.length !== 0)) {
-        writeBlockSequence(state, arrayLevel, state.dump, compact);
-        if (duplicate) {
-          state.dump = '&ref_' + duplicateIndex + state.dump;
-        }
-      } else {
-        writeFlowSequence(state, arrayLevel, state.dump);
-        if (duplicate) {
-          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
-        }
-      }
-    } else if (type === '[object String]') {
-      if (state.tag !== '?') {
-        writeScalar(state, state.dump, level, iskey);
-      }
-    } else {
-      if (state.skipInvalid) return false;
-      throw new exception('unacceptable kind of an object to dump ' + type);
-    }
+  // preserves full path in case of trailing path separator
+  str += 'a';
 
-    if (state.tag !== null && state.tag !== '?') {
-      state.dump = '!<' + state.tag + '> ' + state.dump;
-    }
-  }
+  // remove path parts that are globby
+  do {
+    str = pathPosixDirname(str);
+  } while (isGlob$1(str) || globby.test(str));
 
-  return true;
-}
+  // remove escape chars and return result
+  return str.replace(escaped, '$1');
+};
 
-function getDuplicateReferences(object, state) {
-  var objects = [],
-      duplicatesIndexes = [],
-      index,
-      length;
+var utils$3 = {};
 
-  inspectNode(object, objects, duplicatesIndexes);
+(function (exports) {
 
-  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
-    state.duplicates.push(objects[duplicatesIndexes[index]]);
+exports.isInteger = num => {
+  if (typeof num === 'number') {
+    return Number.isInteger(num);
   }
-  state.usedDuplicates = new Array(length);
-}
+  if (typeof num === 'string' && num.trim() !== '') {
+    return Number.isInteger(Number(num));
+  }
+  return false;
+};
 
-function inspectNode(object, objects, duplicatesIndexes) {
-  var objectKeyList,
-      index,
-      length;
+/**
+ * Find a node of the given type
+ */
 
-  if (object !== null && typeof object === 'object') {
-    index = objects.indexOf(object);
-    if (index !== -1) {
-      if (duplicatesIndexes.indexOf(index) === -1) {
-        duplicatesIndexes.push(index);
-      }
-    } else {
-      objects.push(object);
+exports.find = (node, type) => node.nodes.find(node => node.type === type);
 
-      if (Array.isArray(object)) {
-        for (index = 0, length = object.length; index < length; index += 1) {
-          inspectNode(object[index], objects, duplicatesIndexes);
-        }
-      } else {
-        objectKeyList = Object.keys(object);
+/**
+ * Find a node of the given type
+ */
 
-        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
-        }
-      }
+exports.exceedsLimit = (min, max, step = 1, limit) => {
+  if (limit === false) return false;
+  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+  return ((Number(max) - Number(min)) / Number(step)) >= limit;
+};
+
+/**
+ * Escape the given node with '\\' before node.value
+ */
+
+exports.escapeNode = (block, n = 0, type) => {
+  let node = block.nodes[n];
+  if (!node) return;
+
+  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
+    if (node.escaped !== true) {
+      node.value = '\\' + node.value;
+      node.escaped = true;
     }
   }
-}
+};
 
-function dump(input, options) {
-  options = options || {};
+/**
+ * Returns true if the given brace node should be enclosed in literal braces
+ */
+
+exports.encloseBrace = node => {
+  if (node.type !== 'brace') return false;
+  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
+    node.invalid = true;
+    return true;
+  }
+  return false;
+};
 
-  var state = new State$1(options);
+/**
+ * Returns true if a brace node is invalid.
+ */
 
-  if (!state.noRefs) getDuplicateReferences(input, state);
+exports.isInvalidBrace = block => {
+  if (block.type !== 'brace') return false;
+  if (block.invalid === true || block.dollar) return true;
+  if ((block.commas >> 0 + block.ranges >> 0) === 0) {
+    block.invalid = true;
+    return true;
+  }
+  if (block.open !== true || block.close !== true) {
+    block.invalid = true;
+    return true;
+  }
+  return false;
+};
 
-  if (writeNode(state, 0, input, true, true)) return state.dump + '\n';
+/**
+ * Returns true if a node is an open or close node
+ */
 
-  return '';
-}
+exports.isOpenOrClose = node => {
+  if (node.type === 'open' || node.type === 'close') {
+    return true;
+  }
+  return node.open === true || node.close === true;
+};
 
-function safeDump(input, options) {
-  return dump(input, common.extend({ schema: default_safe }, options));
-}
+/**
+ * Reduce an array of text nodes.
+ */
 
-var dump_1     = dump;
-var safeDump_1 = safeDump;
+exports.reduce = nodes => nodes.reduce((acc, node) => {
+  if (node.type === 'text') acc.push(node.value);
+  if (node.type === 'range') node.type = 'text';
+  return acc;
+}, []);
 
-var dumper = {
-	dump: dump_1,
-	safeDump: safeDump_1
-};
+/**
+ * Flatten an array
+ */
 
-function deprecated(name) {
-  return function () {
-    throw new Error('Function ' + name + ' is deprecated and cannot be used.');
+exports.flatten = (...args) => {
+  const result = [];
+  const flat = arr => {
+    for (let i = 0; i < arr.length; i++) {
+      let ele = arr[i];
+      Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
+    }
+    return result;
   };
-}
+  flat(args);
+  return result;
+};
+}(utils$3));
 
+const utils$2 = utils$3;
 
-var Type$1                = type;
-var Schema$1              = schema;
-var FAILSAFE_SCHEMA     = failsafe;
-var JSON_SCHEMA         = json;
-var CORE_SCHEMA         = core;
-var DEFAULT_SAFE_SCHEMA = default_safe;
-var DEFAULT_FULL_SCHEMA = default_full;
-var load$1                = loader.load;
-var loadAll$1             = loader.loadAll;
-var safeLoad$1            = loader.safeLoad;
-var safeLoadAll$1         = loader.safeLoadAll;
-var dump$1                = dumper.dump;
-var safeDump$1            = dumper.safeDump;
-var YAMLException$1       = exception;
-
-// Deprecated schema names from JS-YAML 2.0.x
-var MINIMAL_SCHEMA = failsafe;
-var SAFE_SCHEMA    = default_safe;
-var DEFAULT_SCHEMA = default_full;
-
-// Deprecated functions from JS-YAML 1.x.x
-var scan           = deprecated('scan');
-var parse          = deprecated('parse');
-var compose        = deprecated('compose');
-var addConstructor = deprecated('addConstructor');
+var stringify$6 = (ast, options = {}) => {
+  let stringify = (node, parent = {}) => {
+    let invalidBlock = options.escapeInvalid && utils$2.isInvalidBrace(parent);
+    let invalidNode = node.invalid === true && options.escapeInvalid === true;
+    let output = '';
 
-var jsYaml = {
-	Type: Type$1,
-	Schema: Schema$1,
-	FAILSAFE_SCHEMA: FAILSAFE_SCHEMA,
-	JSON_SCHEMA: JSON_SCHEMA,
-	CORE_SCHEMA: CORE_SCHEMA,
-	DEFAULT_SAFE_SCHEMA: DEFAULT_SAFE_SCHEMA,
-	DEFAULT_FULL_SCHEMA: DEFAULT_FULL_SCHEMA,
-	load: load$1,
-	loadAll: loadAll$1,
-	safeLoad: safeLoad$1,
-	safeLoadAll: safeLoadAll$1,
-	dump: dump$1,
-	safeDump: safeDump$1,
-	YAMLException: YAMLException$1,
-	MINIMAL_SCHEMA: MINIMAL_SCHEMA,
-	SAFE_SCHEMA: SAFE_SCHEMA,
-	DEFAULT_SCHEMA: DEFAULT_SCHEMA,
-	scan: scan,
-	parse: parse,
-	compose: compose,
-	addConstructor: addConstructor
-};
+    if (node.value) {
+      if ((invalidBlock || invalidNode) && utils$2.isOpenOrClose(node)) {
+        return '\\' + node.value;
+      }
+      return node.value;
+    }
 
-var jsYaml$1 = jsYaml;
+    if (node.value) {
+      return node.value;
+    }
 
-var isArrayish = function isArrayish(obj) {
-	if (!obj) {
-		return false;
-	}
+    if (node.nodes) {
+      for (let child of node.nodes) {
+        output += stringify(child);
+      }
+    }
+    return output;
+  };
 
-	return obj instanceof Array || Array.isArray(obj) ||
-		(obj.length >= 0 && obj.splice instanceof Function);
+  return stringify(ast);
 };
 
-var errorEx = function errorEx(name, properties) {
-	if (!name || name.constructor !== String) {
-		properties = name || {};
-		name = Error.name;
-	}
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
 
-	var errorExError = function ErrorEXError(message) {
-		if (!this) {
-			return new ErrorEXError(message);
-		}
+var isNumber$3 = function(num) {
+  if (typeof num === 'number') {
+    return num - num === 0;
+  }
+  if (typeof num === 'string' && num.trim() !== '') {
+    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+  }
+  return false;
+};
 
-		message = message instanceof Error
-			? message.message
-			: (message || this.message);
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
 
-		Error.call(this, message);
-		Error.captureStackTrace(this, errorExError);
+const isNumber$2 = isNumber$3;
 
-		this.name = name;
+const toRegexRange$1 = (min, max, options) => {
+  if (isNumber$2(min) === false) {
+    throw new TypeError('toRegexRange: expected the first argument to be a number');
+  }
 
-		Object.defineProperty(this, 'message', {
-			configurable: true,
-			enumerable: false,
-			get: function () {
-				var newMessage = message.split(/\r?\n/g);
+  if (max === void 0 || min === max) {
+    return String(min);
+  }
 
-				for (var key in properties) {
-					if (!properties.hasOwnProperty(key)) {
-						continue;
-					}
+  if (isNumber$2(max) === false) {
+    throw new TypeError('toRegexRange: expected the second argument to be a number.');
+  }
 
-					var modifier = properties[key];
+  let opts = { relaxZeros: true, ...options };
+  if (typeof opts.strictZeros === 'boolean') {
+    opts.relaxZeros = opts.strictZeros === false;
+  }
 
-					if ('message' in modifier) {
-						newMessage = modifier.message(this[key], newMessage) || newMessage;
-						if (!isArrayish(newMessage)) {
-							newMessage = [newMessage];
-						}
-					}
-				}
+  let relax = String(opts.relaxZeros);
+  let shorthand = String(opts.shorthand);
+  let capture = String(opts.capture);
+  let wrap = String(opts.wrap);
+  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
 
-				return newMessage.join('\n');
-			},
-			set: function (v) {
-				message = v;
-			}
-		});
+  if (toRegexRange$1.cache.hasOwnProperty(cacheKey)) {
+    return toRegexRange$1.cache[cacheKey].result;
+  }
 
-		var overwrittenStack = null;
+  let a = Math.min(min, max);
+  let b = Math.max(min, max);
 
-		var stackDescriptor = Object.getOwnPropertyDescriptor(this, 'stack');
-		var stackGetter = stackDescriptor.get;
-		var stackValue = stackDescriptor.value;
-		delete stackDescriptor.value;
-		delete stackDescriptor.writable;
+  if (Math.abs(a - b) === 1) {
+    let result = min + '|' + max;
+    if (opts.capture) {
+      return `(${result})`;
+    }
+    if (opts.wrap === false) {
+      return result;
+    }
+    return `(?:${result})`;
+  }
 
-		stackDescriptor.set = function (newstack) {
-			overwrittenStack = newstack;
-		};
+  let isPadded = hasPadding(min) || hasPadding(max);
+  let state = { min, max, a, b };
+  let positives = [];
+  let negatives = [];
 
-		stackDescriptor.get = function () {
-			var stack = (overwrittenStack || ((stackGetter)
-				? stackGetter.call(this)
-				: stackValue)).split(/\r?\n+/g);
+  if (isPadded) {
+    state.isPadded = isPadded;
+    state.maxLen = String(state.max).length;
+  }
 
-			// starting in Node 7, the stack builder caches the message.
-			// just replace it.
-			if (!overwrittenStack) {
-				stack[0] = this.name + ': ' + this.message;
-			}
+  if (a < 0) {
+    let newMin = b < 0 ? Math.abs(b) : 1;
+    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+    a = state.a = 0;
+  }
 
-			var lineCount = 1;
-			for (var key in properties) {
-				if (!properties.hasOwnProperty(key)) {
-					continue;
-				}
+  if (b >= 0) {
+    positives = splitToPatterns(a, b, state, opts);
+  }
 
-				var modifier = properties[key];
+  state.negatives = negatives;
+  state.positives = positives;
+  state.result = collatePatterns(negatives, positives);
 
-				if ('line' in modifier) {
-					var line = modifier.line(this[key]);
-					if (line) {
-						stack.splice(lineCount++, 0, '    ' + line);
-					}
-				}
+  if (opts.capture === true) {
+    state.result = `(${state.result})`;
+  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+    state.result = `(?:${state.result})`;
+  }
 
-				if ('stack' in modifier) {
-					modifier.stack(this[key], stack);
-				}
-			}
+  toRegexRange$1.cache[cacheKey] = state;
+  return state.result;
+};
 
-			return stack.join('\n');
-		};
+function collatePatterns(neg, pos, options) {
+  let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
+  let onlyPositive = filterPatterns(pos, neg, '', false) || [];
+  let intersected = filterPatterns(neg, pos, '-?', true) || [];
+  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+  return subpatterns.join('|');
+}
 
-		Object.defineProperty(this, 'stack', stackDescriptor);
-	};
+function splitToRanges(min, max) {
+  let nines = 1;
+  let zeros = 1;
 
-	if (Object.setPrototypeOf) {
-		Object.setPrototypeOf(errorExError.prototype, Error.prototype);
-		Object.setPrototypeOf(errorExError, Error);
-	} else {
-		util$2.inherits(errorExError, Error);
-	}
+  let stop = countNines(min, nines);
+  let stops = new Set([max]);
 
-	return errorExError;
-};
+  while (min <= stop && stop <= max) {
+    stops.add(stop);
+    nines += 1;
+    stop = countNines(min, nines);
+  }
 
-errorEx.append = function (str, def) {
-	return {
-		message: function (v, message) {
-			v = v || def;
+  stop = countZeros(max + 1, zeros) - 1;
 
-			if (v) {
-				message[0] += ' ' + str.replace('%s', v.toString());
-			}
+  while (min < stop && stop <= max) {
+    stops.add(stop);
+    zeros += 1;
+    stop = countZeros(max + 1, zeros) - 1;
+  }
 
-			return message;
-		}
-	};
-};
+  stops = [...stops];
+  stops.sort(compare$c);
+  return stops;
+}
 
-errorEx.line = function (str, def) {
-	return {
-		line: function (v) {
-			v = v || def;
+/**
+ * Convert a range to a regex pattern
+ * @param {Number} `start`
+ * @param {Number} `stop`
+ * @return {String}
+ */
 
-			if (v) {
-				return str.replace('%s', v.toString());
-			}
+function rangeToPattern(start, stop, options) {
+  if (start === stop) {
+    return { pattern: start, count: [], digits: 0 };
+  }
 
-			return null;
-		}
-	};
-};
+  let zipped = zip(start, stop);
+  let digits = zipped.length;
+  let pattern = '';
+  let count = 0;
 
-var errorEx_1 = errorEx;
+  for (let i = 0; i < digits; i++) {
+    let [startDigit, stopDigit] = zipped[i];
+
+    if (startDigit === stopDigit) {
+      pattern += startDigit;
+
+    } else if (startDigit !== '0' || stopDigit !== '9') {
+      pattern += toCharacterClass(startDigit, stopDigit);
 
-var jsonParseBetterErrors = parseJson;
-function parseJson (txt, reviver, context) {
-  context = context || 20;
-  try {
-    return JSON.parse(txt, reviver)
-  } catch (e) {
-    if (typeof txt !== 'string') {
-      const isEmptyArray = Array.isArray(txt) && txt.length === 0;
-      const errorMessage = 'Cannot parse ' +
-      (isEmptyArray ? 'an empty array' : String(txt));
-      throw new TypeError(errorMessage)
-    }
-    const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i);
-    const errIdx = syntaxErr
-    ? +syntaxErr[1]
-    : e.message.match(/^Unexpected end of JSON.*/i)
-    ? txt.length - 1
-    : null;
-    if (errIdx != null) {
-      const start = errIdx <= context
-      ? 0
-      : errIdx - context;
-      const end = errIdx + context >= txt.length
-      ? txt.length
-      : errIdx + context;
-      e.message += ` while parsing near '${
-        start === 0 ? '' : '...'
-      }${txt.slice(start, end)}${
-        end === txt.length ? '' : '...'
-      }'`;
     } else {
-      e.message += ` while parsing '${txt.slice(0, context * 2)}'`;
+      count++;
     }
-    throw e
   }
+
+  if (count) {
+    pattern += options.shorthand === true ? '\\d' : '[0-9]';
+  }
+
+  return { pattern, count: [count], digits };
 }
 
-var LF = '\n';
-var CR = '\r';
-var LinesAndColumns = (function () {
-    function LinesAndColumns(string) {
-        this.string = string;
-        var offsets = [0];
-        for (var offset = 0; offset < string.length;) {
-            switch (string[offset]) {
-                case LF:
-                    offset += LF.length;
-                    offsets.push(offset);
-                    break;
-                case CR:
-                    offset += CR.length;
-                    if (string[offset] === LF) {
-                        offset += LF.length;
-                    }
-                    offsets.push(offset);
-                    break;
-                default:
-                    offset++;
-                    break;
-            }
-        }
-        this.offsets = offsets;
-    }
-    LinesAndColumns.prototype.locationForIndex = function (index) {
-        if (index < 0 || index > this.string.length) {
-            return null;
-        }
-        var line = 0;
-        var offsets = this.offsets;
-        while (offsets[line + 1] <= index) {
-            line++;
-        }
-        var column = index - offsets[line];
-        return { line: line, column: column };
-    };
-    LinesAndColumns.prototype.indexForLocation = function (location) {
-        var line = location.line, column = location.column;
-        if (line < 0 || line >= this.offsets.length) {
-            return null;
-        }
-        if (column < 0 || column > this.lengthOfLine(line)) {
-            return null;
-        }
-        return this.offsets[line] + column;
-    };
-    LinesAndColumns.prototype.lengthOfLine = function (line) {
-        var offset = this.offsets[line];
-        var nextOffset = line === this.offsets.length - 1 ? this.string.length : this.offsets[line + 1];
-        return nextOffset - offset;
-    };
-    return LinesAndColumns;
-}());
+function splitToPatterns(min, max, tok, options) {
+  let ranges = splitToRanges(min, max);
+  let tokens = [];
+  let start = min;
+  let prev;
 
-var dist = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': LinesAndColumns
-});
+  for (let i = 0; i < ranges.length; i++) {
+    let max = ranges[i];
+    let obj = rangeToPattern(String(start), String(max), options);
+    let zeros = '';
 
-var jsTokens = createCommonjsModule(function (module, exports) {
-// Copyright 2014, 2015, 2016, 2017, 2018 Simon Lydell
-// License: MIT. (See LICENSE.)
+    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+      if (prev.count.length > 1) {
+        prev.count.pop();
+      }
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+      prev.count.push(obj.count[0]);
+      prev.string = prev.pattern + toQuantifier(prev.count);
+      start = max + 1;
+      continue;
+    }
 
-// This regex comes from regex.coffee, and is inserted here by generate-index.js
-// (run `npm run build`).
-exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g;
+    if (tok.isPadded) {
+      zeros = padZeros(max, tok, options);
+    }
 
-exports.matchToToken = function(match) {
-  var token = {type: "invalid", value: match[0], closed: undefined};
-       if (match[ 1]) token.type = "string" , token.closed = !!(match[3] || match[4]);
-  else if (match[ 5]) token.type = "comment";
-  else if (match[ 6]) token.type = "comment", token.closed = !!match[7];
-  else if (match[ 8]) token.type = "regex";
-  else if (match[ 9]) token.type = "number";
-  else if (match[10]) token.type = "name";
-  else if (match[11]) token.type = "punctuator";
-  else if (match[12]) token.type = "whitespace";
-  return token
-};
-});
+    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+    tokens.push(obj);
+    start = max + 1;
+    prev = obj;
+  }
 
-unwrapExports(jsTokens);
-var jsTokens_1 = jsTokens.matchToToken;
+  return tokens;
+}
 
-var identifier = createCommonjsModule(function (module, exports) {
+function filterPatterns(arr, comparison, prefix, intersection, options) {
+  let result = [];
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isIdentifierStart = isIdentifierStart;
-exports.isIdentifierChar = isIdentifierChar;
-exports.isIdentifierName = isIdentifierName;
-let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08c7\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\u9ffc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7ca\ua7f5-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf\u1ac0\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
-const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 107, 20, 28, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8952, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42717, 35, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
-const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+  for (let ele of arr) {
+    let { string } = ele;
 
-function isInAstralSet(code, set) {
-  let pos = 0x10000;
+    // only push if _both_ are negative...
+    if (!intersection && !contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
 
-  for (let i = 0, length = set.length; i < length; i += 2) {
-    pos += set[i];
-    if (pos > code) return false;
-    pos += set[i + 1];
-    if (pos >= code) return true;
+    // or _both_ are positive
+    if (intersection && contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
   }
+  return result;
+}
 
-  return false;
+/**
+ * Zip strings
+ */
+
+function zip(a, b) {
+  let arr = [];
+  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+  return arr;
 }
 
-function isIdentifierStart(code) {
-  if (code < 65) return code === 36;
-  if (code <= 90) return true;
-  if (code < 97) return code === 95;
-  if (code <= 122) return true;
+function compare$c(a, b) {
+  return a > b ? 1 : b > a ? -1 : 0;
+}
 
-  if (code <= 0xffff) {
-    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  }
+function contains(arr, key, val) {
+  return arr.some(ele => ele[key] === val);
+}
 
-  return isInAstralSet(code, astralIdentifierStartCodes);
+function countNines(min, len) {
+  return Number(String(min).slice(0, -len) + '9'.repeat(len));
 }
 
-function isIdentifierChar(code) {
-  if (code < 48) return code === 36;
-  if (code < 58) return true;
-  if (code < 65) return false;
-  if (code <= 90) return true;
-  if (code < 97) return code === 95;
-  if (code <= 122) return true;
+function countZeros(integer, zeros) {
+  return integer - (integer % Math.pow(10, zeros));
+}
 
-  if (code <= 0xffff) {
-    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+function toQuantifier(digits) {
+  let [start = 0, stop = ''] = digits;
+  if (stop || start > 1) {
+    return `{${start + (stop ? ',' + stop : '')}}`;
   }
+  return '';
+}
 
-  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+function toCharacterClass(a, b, options) {
+  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
 }
 
-function isIdentifierName(name) {
-  let isFirst = true;
+function hasPadding(str) {
+  return /^-?(0+)\d/.test(str);
+}
 
-  for (let _i = 0, _Array$from = Array.from(name); _i < _Array$from.length; _i++) {
-    const char = _Array$from[_i];
-    const cp = char.codePointAt(0);
+function padZeros(value, tok, options) {
+  if (!tok.isPadded) {
+    return value;
+  }
 
-    if (isFirst) {
-      if (!isIdentifierStart(cp)) {
-        return false;
-      }
+  let diff = Math.abs(tok.maxLen - String(value).length);
+  let relax = options.relaxZeros !== false;
 
-      isFirst = false;
-    } else if (!isIdentifierChar(cp)) {
-      return false;
+  switch (diff) {
+    case 0:
+      return '';
+    case 1:
+      return relax ? '0?' : '0';
+    case 2:
+      return relax ? '0{0,2}' : '00';
+    default: {
+      return relax ? `0{0,${diff}}` : `0{${diff}}`;
     }
   }
-
-  return !isFirst;
 }
-});
 
-unwrapExports(identifier);
-var identifier_1 = identifier.isIdentifierStart;
-var identifier_2 = identifier.isIdentifierChar;
-var identifier_3 = identifier.isIdentifierName;
+/**
+ * Cache
+ */
 
-var keyword = createCommonjsModule(function (module, exports) {
+toRegexRange$1.cache = {};
+toRegexRange$1.clearCache = () => (toRegexRange$1.cache = {});
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isReservedWord = isReservedWord;
-exports.isStrictReservedWord = isStrictReservedWord;
-exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
-exports.isStrictBindReservedWord = isStrictBindReservedWord;
-exports.isKeyword = isKeyword;
-const reservedWords = {
-  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
-  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
-  strictBind: ["eval", "arguments"]
-};
-const keywords = new Set(reservedWords.keyword);
-const reservedWordsStrictSet = new Set(reservedWords.strict);
-const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+/**
+ * Expose `toRegexRange`
+ */
 
-function isReservedWord(word, inModule) {
-  return inModule && word === "await" || word === "enum";
-}
+var toRegexRange_1 = toRegexRange$1;
 
-function isStrictReservedWord(word, inModule) {
-  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
-}
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
 
-function isStrictBindOnlyReservedWord(word) {
-  return reservedWordsStrictBindSet.has(word);
-}
+const util$3 = require$$0$4;
+const toRegexRange = toRegexRange_1;
 
-function isStrictBindReservedWord(word, inModule) {
-  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
-}
+const isObject$2 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 
-function isKeyword(word) {
-  return keywords.has(word);
-}
-});
+const transform$3 = toNumber => {
+  return value => toNumber === true ? Number(value) : String(value);
+};
 
-unwrapExports(keyword);
-var keyword_1 = keyword.isReservedWord;
-var keyword_2 = keyword.isStrictReservedWord;
-var keyword_3 = keyword.isStrictBindOnlyReservedWord;
-var keyword_4 = keyword.isStrictBindReservedWord;
-var keyword_5 = keyword.isKeyword;
+const isValidValue = value => {
+  return typeof value === 'number' || (typeof value === 'string' && value !== '');
+};
 
-var lib = createCommonjsModule(function (module, exports) {
+const isNumber$1 = num => Number.isInteger(+num);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "isIdentifierName", {
-  enumerable: true,
-  get: function () {
-    return identifier.isIdentifierName;
+const zeros = input => {
+  let value = `${input}`;
+  let index = -1;
+  if (value[0] === '-') value = value.slice(1);
+  if (value === '0') return false;
+  while (value[++index] === '0');
+  return index > 0;
+};
+
+const stringify$5 = (start, end, options) => {
+  if (typeof start === 'string' || typeof end === 'string') {
+    return true;
   }
-});
-Object.defineProperty(exports, "isIdentifierChar", {
-  enumerable: true,
-  get: function () {
-    return identifier.isIdentifierChar;
+  return options.stringify === true;
+};
+
+const pad = (input, maxLength, toNumber) => {
+  if (maxLength > 0) {
+    let dash = input[0] === '-' ? '-' : '';
+    if (dash) input = input.slice(1);
+    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
   }
-});
-Object.defineProperty(exports, "isIdentifierStart", {
-  enumerable: true,
-  get: function () {
-    return identifier.isIdentifierStart;
+  if (toNumber === false) {
+    return String(input);
   }
-});
-Object.defineProperty(exports, "isReservedWord", {
-  enumerable: true,
-  get: function () {
-    return keyword.isReservedWord;
+  return input;
+};
+
+const toMaxLen = (input, maxLength) => {
+  let negative = input[0] === '-' ? '-' : '';
+  if (negative) {
+    input = input.slice(1);
+    maxLength--;
   }
-});
-Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
-  enumerable: true,
-  get: function () {
-    return keyword.isStrictBindOnlyReservedWord;
+  while (input.length < maxLength) input = '0' + input;
+  return negative ? ('-' + input) : input;
+};
+
+const toSequence = (parts, options) => {
+  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+
+  let prefix = options.capture ? '' : '?:';
+  let positives = '';
+  let negatives = '';
+  let result;
+
+  if (parts.positives.length) {
+    positives = parts.positives.join('|');
   }
-});
-Object.defineProperty(exports, "isStrictBindReservedWord", {
-  enumerable: true,
-  get: function () {
-    return keyword.isStrictBindReservedWord;
+
+  if (parts.negatives.length) {
+    negatives = `-(${prefix}${parts.negatives.join('|')})`;
   }
-});
-Object.defineProperty(exports, "isStrictReservedWord", {
-  enumerable: true,
-  get: function () {
-    return keyword.isStrictReservedWord;
+
+  if (positives && negatives) {
+    result = `${positives}|${negatives}`;
+  } else {
+    result = positives || negatives;
   }
-});
-Object.defineProperty(exports, "isKeyword", {
-  enumerable: true,
-  get: function () {
-    return keyword.isKeyword;
+
+  if (options.wrap) {
+    return `(${prefix}${result})`;
   }
-});
-});
 
-unwrapExports(lib);
+  return result;
+};
 
-var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+const toRange = (a, b, isNumbers, options) => {
+  if (isNumbers) {
+    return toRegexRange(a, b, { wrap: false, ...options });
+  }
 
-var escapeStringRegexp = function (str) {
-	if (typeof str !== 'string') {
-		throw new TypeError('Expected a string');
-	}
+  let start = String.fromCharCode(a);
+  if (a === b) return start;
 
-	return str.replace(matchOperatorsRe, '\\$&');
+  let stop = String.fromCharCode(b);
+  return `[${start}-${stop}]`;
 };
 
-var colorName = {
-	"aliceblue": [240, 248, 255],
-	"antiquewhite": [250, 235, 215],
-	"aqua": [0, 255, 255],
-	"aquamarine": [127, 255, 212],
-	"azure": [240, 255, 255],
-	"beige": [245, 245, 220],
-	"bisque": [255, 228, 196],
-	"black": [0, 0, 0],
-	"blanchedalmond": [255, 235, 205],
-	"blue": [0, 0, 255],
-	"blueviolet": [138, 43, 226],
-	"brown": [165, 42, 42],
-	"burlywood": [222, 184, 135],
-	"cadetblue": [95, 158, 160],
-	"chartreuse": [127, 255, 0],
-	"chocolate": [210, 105, 30],
-	"coral": [255, 127, 80],
-	"cornflowerblue": [100, 149, 237],
-	"cornsilk": [255, 248, 220],
-	"crimson": [220, 20, 60],
-	"cyan": [0, 255, 255],
-	"darkblue": [0, 0, 139],
-	"darkcyan": [0, 139, 139],
-	"darkgoldenrod": [184, 134, 11],
-	"darkgray": [169, 169, 169],
-	"darkgreen": [0, 100, 0],
-	"darkgrey": [169, 169, 169],
-	"darkkhaki": [189, 183, 107],
-	"darkmagenta": [139, 0, 139],
-	"darkolivegreen": [85, 107, 47],
-	"darkorange": [255, 140, 0],
-	"darkorchid": [153, 50, 204],
-	"darkred": [139, 0, 0],
-	"darksalmon": [233, 150, 122],
-	"darkseagreen": [143, 188, 143],
-	"darkslateblue": [72, 61, 139],
-	"darkslategray": [47, 79, 79],
-	"darkslategrey": [47, 79, 79],
-	"darkturquoise": [0, 206, 209],
-	"darkviolet": [148, 0, 211],
-	"deeppink": [255, 20, 147],
-	"deepskyblue": [0, 191, 255],
-	"dimgray": [105, 105, 105],
-	"dimgrey": [105, 105, 105],
-	"dodgerblue": [30, 144, 255],
-	"firebrick": [178, 34, 34],
-	"floralwhite": [255, 250, 240],
-	"forestgreen": [34, 139, 34],
-	"fuchsia": [255, 0, 255],
-	"gainsboro": [220, 220, 220],
-	"ghostwhite": [248, 248, 255],
-	"gold": [255, 215, 0],
-	"goldenrod": [218, 165, 32],
-	"gray": [128, 128, 128],
-	"green": [0, 128, 0],
-	"greenyellow": [173, 255, 47],
-	"grey": [128, 128, 128],
-	"honeydew": [240, 255, 240],
-	"hotpink": [255, 105, 180],
-	"indianred": [205, 92, 92],
-	"indigo": [75, 0, 130],
-	"ivory": [255, 255, 240],
-	"khaki": [240, 230, 140],
-	"lavender": [230, 230, 250],
-	"lavenderblush": [255, 240, 245],
-	"lawngreen": [124, 252, 0],
-	"lemonchiffon": [255, 250, 205],
-	"lightblue": [173, 216, 230],
-	"lightcoral": [240, 128, 128],
-	"lightcyan": [224, 255, 255],
-	"lightgoldenrodyellow": [250, 250, 210],
-	"lightgray": [211, 211, 211],
-	"lightgreen": [144, 238, 144],
-	"lightgrey": [211, 211, 211],
-	"lightpink": [255, 182, 193],
-	"lightsalmon": [255, 160, 122],
-	"lightseagreen": [32, 178, 170],
-	"lightskyblue": [135, 206, 250],
-	"lightslategray": [119, 136, 153],
-	"lightslategrey": [119, 136, 153],
-	"lightsteelblue": [176, 196, 222],
-	"lightyellow": [255, 255, 224],
-	"lime": [0, 255, 0],
-	"limegreen": [50, 205, 50],
-	"linen": [250, 240, 230],
-	"magenta": [255, 0, 255],
-	"maroon": [128, 0, 0],
-	"mediumaquamarine": [102, 205, 170],
-	"mediumblue": [0, 0, 205],
-	"mediumorchid": [186, 85, 211],
-	"mediumpurple": [147, 112, 219],
-	"mediumseagreen": [60, 179, 113],
-	"mediumslateblue": [123, 104, 238],
-	"mediumspringgreen": [0, 250, 154],
-	"mediumturquoise": [72, 209, 204],
-	"mediumvioletred": [199, 21, 133],
-	"midnightblue": [25, 25, 112],
-	"mintcream": [245, 255, 250],
-	"mistyrose": [255, 228, 225],
-	"moccasin": [255, 228, 181],
-	"navajowhite": [255, 222, 173],
-	"navy": [0, 0, 128],
-	"oldlace": [253, 245, 230],
-	"olive": [128, 128, 0],
-	"olivedrab": [107, 142, 35],
-	"orange": [255, 165, 0],
-	"orangered": [255, 69, 0],
-	"orchid": [218, 112, 214],
-	"palegoldenrod": [238, 232, 170],
-	"palegreen": [152, 251, 152],
-	"paleturquoise": [175, 238, 238],
-	"palevioletred": [219, 112, 147],
-	"papayawhip": [255, 239, 213],
-	"peachpuff": [255, 218, 185],
-	"peru": [205, 133, 63],
-	"pink": [255, 192, 203],
-	"plum": [221, 160, 221],
-	"powderblue": [176, 224, 230],
-	"purple": [128, 0, 128],
-	"rebeccapurple": [102, 51, 153],
-	"red": [255, 0, 0],
-	"rosybrown": [188, 143, 143],
-	"royalblue": [65, 105, 225],
-	"saddlebrown": [139, 69, 19],
-	"salmon": [250, 128, 114],
-	"sandybrown": [244, 164, 96],
-	"seagreen": [46, 139, 87],
-	"seashell": [255, 245, 238],
-	"sienna": [160, 82, 45],
-	"silver": [192, 192, 192],
-	"skyblue": [135, 206, 235],
-	"slateblue": [106, 90, 205],
-	"slategray": [112, 128, 144],
-	"slategrey": [112, 128, 144],
-	"snow": [255, 250, 250],
-	"springgreen": [0, 255, 127],
-	"steelblue": [70, 130, 180],
-	"tan": [210, 180, 140],
-	"teal": [0, 128, 128],
-	"thistle": [216, 191, 216],
-	"tomato": [255, 99, 71],
-	"turquoise": [64, 224, 208],
-	"violet": [238, 130, 238],
-	"wheat": [245, 222, 179],
-	"white": [255, 255, 255],
-	"whitesmoke": [245, 245, 245],
-	"yellow": [255, 255, 0],
-	"yellowgreen": [154, 205, 50]
-};
-
-var conversions = createCommonjsModule(function (module) {
-/* MIT license */
-
-
-// NOTE: conversions should only return primitive values (i.e. arrays, or
-//       values that give correct `typeof` results).
-//       do not use box values types (i.e. Number(), String(), etc.)
+const toRegex = (start, end, options) => {
+  if (Array.isArray(start)) {
+    let wrap = options.wrap === true;
+    let prefix = options.capture ? '' : '?:';
+    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+  }
+  return toRegexRange(start, end, options);
+};
 
-var reverseKeywords = {};
-for (var key in colorName) {
-	if (colorName.hasOwnProperty(key)) {
-		reverseKeywords[colorName[key]] = key;
-	}
-}
+const rangeError = (...args) => {
+  return new RangeError('Invalid range arguments: ' + util$3.inspect(...args));
+};
 
-var convert = module.exports = {
-	rgb: {channels: 3, labels: 'rgb'},
-	hsl: {channels: 3, labels: 'hsl'},
-	hsv: {channels: 3, labels: 'hsv'},
-	hwb: {channels: 3, labels: 'hwb'},
-	cmyk: {channels: 4, labels: 'cmyk'},
-	xyz: {channels: 3, labels: 'xyz'},
-	lab: {channels: 3, labels: 'lab'},
-	lch: {channels: 3, labels: 'lch'},
-	hex: {channels: 1, labels: ['hex']},
-	keyword: {channels: 1, labels: ['keyword']},
-	ansi16: {channels: 1, labels: ['ansi16']},
-	ansi256: {channels: 1, labels: ['ansi256']},
-	hcg: {channels: 3, labels: ['h', 'c', 'g']},
-	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
-	gray: {channels: 1, labels: ['gray']}
+const invalidRange = (start, end, options) => {
+  if (options.strictRanges === true) throw rangeError([start, end]);
+  return [];
 };
 
-// hide .channels and .labels properties
-for (var model in convert) {
-	if (convert.hasOwnProperty(model)) {
-		if (!('channels' in convert[model])) {
-			throw new Error('missing channels property: ' + model);
-		}
+const invalidStep = (step, options) => {
+  if (options.strictRanges === true) {
+    throw new TypeError(`Expected step "${step}" to be a number`);
+  }
+  return [];
+};
 
-		if (!('labels' in convert[model])) {
-			throw new Error('missing channel labels property: ' + model);
-		}
+const fillNumbers = (start, end, step = 1, options = {}) => {
+  let a = Number(start);
+  let b = Number(end);
 
-		if (convert[model].labels.length !== convert[model].channels) {
-			throw new Error('channel and label counts mismatch: ' + model);
-		}
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    if (options.strictRanges === true) throw rangeError([start, end]);
+    return [];
+  }
 
-		var channels = convert[model].channels;
-		var labels = convert[model].labels;
-		delete convert[model].channels;
-		delete convert[model].labels;
-		Object.defineProperty(convert[model], 'channels', {value: channels});
-		Object.defineProperty(convert[model], 'labels', {value: labels});
-	}
-}
+  // fix negative zero
+  if (a === 0) a = 0;
+  if (b === 0) b = 0;
 
-convert.rgb.hsl = function (rgb) {
-	var r = rgb[0] / 255;
-	var g = rgb[1] / 255;
-	var b = rgb[2] / 255;
-	var min = Math.min(r, g, b);
-	var max = Math.max(r, g, b);
-	var delta = max - min;
-	var h;
-	var s;
-	var l;
+  let descending = a > b;
+  let startString = String(start);
+  let endString = String(end);
+  let stepString = String(step);
+  step = Math.max(Math.abs(step), 1);
 
-	if (max === min) {
-		h = 0;
-	} else if (r === max) {
-		h = (g - b) / delta;
-	} else if (g === max) {
-		h = 2 + (b - r) / delta;
-	} else if (b === max) {
-		h = 4 + (r - g) / delta;
-	}
+  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+  let toNumber = padded === false && stringify$5(start, end, options) === false;
+  let format = options.transform || transform$3(toNumber);
 
-	h = Math.min(h * 60, 360);
+  if (options.toRegex && step === 1) {
+    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+  }
 
-	if (h < 0) {
-		h += 360;
-	}
+  let parts = { negatives: [], positives: [] };
+  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+  let range = [];
+  let index = 0;
 
-	l = (min + max) / 2;
+  while (descending ? a >= b : a <= b) {
+    if (options.toRegex === true && step > 1) {
+      push(a);
+    } else {
+      range.push(pad(format(a, index), maxLen, toNumber));
+    }
+    a = descending ? a - step : a + step;
+    index++;
+  }
 
-	if (max === min) {
-		s = 0;
-	} else if (l <= 0.5) {
-		s = delta / (max + min);
-	} else {
-		s = delta / (2 - max - min);
-	}
+  if (options.toRegex === true) {
+    return step > 1
+      ? toSequence(parts, options)
+      : toRegex(range, null, { wrap: false, ...options });
+  }
 
-	return [h, s * 100, l * 100];
+  return range;
 };
 
-convert.rgb.hsv = function (rgb) {
-	var rdif;
-	var gdif;
-	var bdif;
-	var h;
-	var s;
-
-	var r = rgb[0] / 255;
-	var g = rgb[1] / 255;
-	var b = rgb[2] / 255;
-	var v = Math.max(r, g, b);
-	var diff = v - Math.min(r, g, b);
-	var diffc = function (c) {
-		return (v - c) / 6 / diff + 1 / 2;
-	};
+const fillLetters = (start, end, step = 1, options = {}) => {
+  if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {
+    return invalidRange(start, end, options);
+  }
 
-	if (diff === 0) {
-		h = s = 0;
-	} else {
-		s = diff / v;
-		rdif = diffc(r);
-		gdif = diffc(g);
-		bdif = diffc(b);
 
-		if (r === v) {
-			h = bdif - gdif;
-		} else if (g === v) {
-			h = (1 / 3) + rdif - bdif;
-		} else if (b === v) {
-			h = (2 / 3) + gdif - rdif;
-		}
-		if (h < 0) {
-			h += 1;
-		} else if (h > 1) {
-			h -= 1;
-		}
-	}
+  let format = options.transform || (val => String.fromCharCode(val));
+  let a = `${start}`.charCodeAt(0);
+  let b = `${end}`.charCodeAt(0);
 
-	return [
-		h * 360,
-		s * 100,
-		v * 100
-	];
-};
+  let descending = a > b;
+  let min = Math.min(a, b);
+  let max = Math.max(a, b);
 
-convert.rgb.hwb = function (rgb) {
-	var r = rgb[0];
-	var g = rgb[1];
-	var b = rgb[2];
-	var h = convert.rgb.hsl(rgb)[0];
-	var w = 1 / 255 * Math.min(r, Math.min(g, b));
+  if (options.toRegex && step === 1) {
+    return toRange(min, max, false, options);
+  }
 
-	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
-
-	return [h, w * 100, b * 100];
-};
+  let range = [];
+  let index = 0;
 
-convert.rgb.cmyk = function (rgb) {
-	var r = rgb[0] / 255;
-	var g = rgb[1] / 255;
-	var b = rgb[2] / 255;
-	var c;
-	var m;
-	var y;
-	var k;
+  while (descending ? a >= b : a <= b) {
+    range.push(format(a, index));
+    a = descending ? a - step : a + step;
+    index++;
+  }
 
-	k = Math.min(1 - r, 1 - g, 1 - b);
-	c = (1 - r - k) / (1 - k) || 0;
-	m = (1 - g - k) / (1 - k) || 0;
-	y = (1 - b - k) / (1 - k) || 0;
+  if (options.toRegex === true) {
+    return toRegex(range, null, { wrap: false, options });
+  }
 
-	return [c * 100, m * 100, y * 100, k * 100];
+  return range;
 };
 
-/**
- * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
- * */
-function comparativeDistance(x, y) {
-	return (
-		Math.pow(x[0] - y[0], 2) +
-		Math.pow(x[1] - y[1], 2) +
-		Math.pow(x[2] - y[2], 2)
-	);
-}
+const fill$2 = (start, end, step, options = {}) => {
+  if (end == null && isValidValue(start)) {
+    return [start];
+  }
 
-convert.rgb.keyword = function (rgb) {
-	var reversed = reverseKeywords[rgb];
-	if (reversed) {
-		return reversed;
-	}
+  if (!isValidValue(start) || !isValidValue(end)) {
+    return invalidRange(start, end, options);
+  }
 
-	var currentClosestDistance = Infinity;
-	var currentClosestKeyword;
+  if (typeof step === 'function') {
+    return fill$2(start, end, 1, { transform: step });
+  }
 
-	for (var keyword in colorName) {
-		if (colorName.hasOwnProperty(keyword)) {
-			var value = colorName[keyword];
+  if (isObject$2(step)) {
+    return fill$2(start, end, 0, step);
+  }
 
-			// Compute comparative distance
-			var distance = comparativeDistance(rgb, value);
+  let opts = { ...options };
+  if (opts.capture === true) opts.wrap = true;
+  step = step || opts.step || 1;
 
-			// Check if its less, if so set as closest
-			if (distance < currentClosestDistance) {
-				currentClosestDistance = distance;
-				currentClosestKeyword = keyword;
-			}
-		}
-	}
+  if (!isNumber$1(step)) {
+    if (step != null && !isObject$2(step)) return invalidStep(step, opts);
+    return fill$2(start, end, 1, step);
+  }
 
-	return currentClosestKeyword;
-};
+  if (isNumber$1(start) && isNumber$1(end)) {
+    return fillNumbers(start, end, step, opts);
+  }
 
-convert.keyword.rgb = function (keyword) {
-	return colorName[keyword];
+  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
 };
 
-convert.rgb.xyz = function (rgb) {
-	var r = rgb[0] / 255;
-	var g = rgb[1] / 255;
-	var b = rgb[2] / 255;
+var fillRange = fill$2;
 
-	// assume sRGB
-	r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
-	g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
-	b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
+const fill$1 = fillRange;
+const utils$1 = utils$3;
 
-	var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
-	var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
-	var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+const compile$1 = (ast, options = {}) => {
+  let walk = (node, parent = {}) => {
+    let invalidBlock = utils$1.isInvalidBrace(parent);
+    let invalidNode = node.invalid === true && options.escapeInvalid === true;
+    let invalid = invalidBlock === true || invalidNode === true;
+    let prefix = options.escapeInvalid === true ? '\\' : '';
+    let output = '';
 
-	return [x * 100, y * 100, z * 100];
-};
+    if (node.isOpen === true) {
+      return prefix + node.value;
+    }
+    if (node.isClose === true) {
+      return prefix + node.value;
+    }
 
-convert.rgb.lab = function (rgb) {
-	var xyz = convert.rgb.xyz(rgb);
-	var x = xyz[0];
-	var y = xyz[1];
-	var z = xyz[2];
-	var l;
-	var a;
-	var b;
+    if (node.type === 'open') {
+      return invalid ? (prefix + node.value) : '(';
+    }
 
-	x /= 95.047;
-	y /= 100;
-	z /= 108.883;
+    if (node.type === 'close') {
+      return invalid ? (prefix + node.value) : ')';
+    }
 
-	x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
-	y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
-	z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
+    if (node.type === 'comma') {
+      return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
+    }
 
-	l = (116 * y) - 16;
-	a = 500 * (x - y);
-	b = 200 * (y - z);
+    if (node.value) {
+      return node.value;
+    }
 
-	return [l, a, b];
-};
+    if (node.nodes && node.ranges > 0) {
+      let args = utils$1.reduce(node.nodes);
+      let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
 
-convert.hsl.rgb = function (hsl) {
-	var h = hsl[0] / 360;
-	var s = hsl[1] / 100;
-	var l = hsl[2] / 100;
-	var t1;
-	var t2;
-	var t3;
-	var rgb;
-	var val;
+      if (range.length !== 0) {
+        return args.length > 1 && range.length > 1 ? `(${range})` : range;
+      }
+    }
 
-	if (s === 0) {
-		val = l * 255;
-		return [val, val, val];
-	}
+    if (node.nodes) {
+      for (let child of node.nodes) {
+        output += walk(child, node);
+      }
+    }
+    return output;
+  };
 
-	if (l < 0.5) {
-		t2 = l * (1 + s);
-	} else {
-		t2 = l + s - l * s;
-	}
+  return walk(ast);
+};
 
-	t1 = 2 * l - t2;
+var compile_1 = compile$1;
 
-	rgb = [0, 0, 0];
-	for (var i = 0; i < 3; i++) {
-		t3 = h + 1 / 3 * -(i - 1);
-		if (t3 < 0) {
-			t3++;
-		}
-		if (t3 > 1) {
-			t3--;
-		}
+const fill = fillRange;
+const stringify$4 = stringify$6;
+const utils = utils$3;
 
-		if (6 * t3 < 1) {
-			val = t1 + (t2 - t1) * 6 * t3;
-		} else if (2 * t3 < 1) {
-			val = t2;
-		} else if (3 * t3 < 2) {
-			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
-		} else {
-			val = t1;
-		}
+const append = (queue = '', stash = '', enclose = false) => {
+  let result = [];
 
-		rgb[i] = val * 255;
-	}
+  queue = [].concat(queue);
+  stash = [].concat(stash);
 
-	return rgb;
+  if (!stash.length) return queue;
+  if (!queue.length) {
+    return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
+  }
+
+  for (let item of queue) {
+    if (Array.isArray(item)) {
+      for (let value of item) {
+        result.push(append(value, stash, enclose));
+      }
+    } else {
+      for (let ele of stash) {
+        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
+        result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
+      }
+    }
+  }
+  return utils.flatten(result);
 };
 
-convert.hsl.hsv = function (hsl) {
-	var h = hsl[0];
-	var s = hsl[1] / 100;
-	var l = hsl[2] / 100;
-	var smin = s;
-	var lmin = Math.max(l, 0.01);
-	var sv;
-	var v;
+const expand$4 = (ast, options = {}) => {
+  let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
 
-	l *= 2;
-	s *= (l <= 1) ? l : 2 - l;
-	smin *= lmin <= 1 ? lmin : 2 - lmin;
-	v = (l + s) / 2;
-	sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
+  let walk = (node, parent = {}) => {
+    node.queue = [];
 
-	return [h, sv * 100, v * 100];
-};
+    let p = parent;
+    let q = parent.queue;
 
-convert.hsv.rgb = function (hsv) {
-	var h = hsv[0] / 60;
-	var s = hsv[1] / 100;
-	var v = hsv[2] / 100;
-	var hi = Math.floor(h) % 6;
+    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
+      p = p.parent;
+      q = p.queue;
+    }
 
-	var f = h - Math.floor(h);
-	var p = 255 * v * (1 - s);
-	var q = 255 * v * (1 - (s * f));
-	var t = 255 * v * (1 - (s * (1 - f)));
-	v *= 255;
+    if (node.invalid || node.dollar) {
+      q.push(append(q.pop(), stringify$4(node, options)));
+      return;
+    }
 
-	switch (hi) {
-		case 0:
-			return [v, t, p];
-		case 1:
-			return [q, v, p];
-		case 2:
-			return [p, v, t];
-		case 3:
-			return [p, q, v];
-		case 4:
-			return [t, p, v];
-		case 5:
-			return [v, p, q];
-	}
-};
+    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
+      q.push(append(q.pop(), ['{}']));
+      return;
+    }
 
-convert.hsv.hsl = function (hsv) {
-	var h = hsv[0];
-	var s = hsv[1] / 100;
-	var v = hsv[2] / 100;
-	var vmin = Math.max(v, 0.01);
-	var lmin;
-	var sl;
-	var l;
+    if (node.nodes && node.ranges > 0) {
+      let args = utils.reduce(node.nodes);
 
-	l = (2 - s) * v;
-	lmin = (2 - s) * vmin;
-	sl = s * vmin;
-	sl /= (lmin <= 1) ? lmin : 2 - lmin;
-	sl = sl || 0;
-	l /= 2;
+      if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+      }
 
-	return [h, sl * 100, l * 100];
-};
+      let range = fill(...args, options);
+      if (range.length === 0) {
+        range = stringify$4(node, options);
+      }
 
-// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
-convert.hwb.rgb = function (hwb) {
-	var h = hwb[0] / 360;
-	var wh = hwb[1] / 100;
-	var bl = hwb[2] / 100;
-	var ratio = wh + bl;
-	var i;
-	var v;
-	var f;
-	var n;
+      q.push(append(q.pop(), range));
+      node.nodes = [];
+      return;
+    }
 
-	// wh + bl cant be > 1
-	if (ratio > 1) {
-		wh /= ratio;
-		bl /= ratio;
-	}
+    let enclose = utils.encloseBrace(node);
+    let queue = node.queue;
+    let block = node;
 
-	i = Math.floor(6 * h);
-	v = 1 - bl;
-	f = 6 * h - i;
+    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
+      block = block.parent;
+      queue = block.queue;
+    }
 
-	if ((i & 0x01) !== 0) {
-		f = 1 - f;
-	}
+    for (let i = 0; i < node.nodes.length; i++) {
+      let child = node.nodes[i];
 
-	n = wh + f * (v - wh); // linear interpolation
+      if (child.type === 'comma' && node.type === 'brace') {
+        if (i === 1) queue.push('');
+        queue.push('');
+        continue;
+      }
 
-	var r;
-	var g;
-	var b;
-	switch (i) {
-		default:
-		case 6:
-		case 0: r = v; g = n; b = wh; break;
-		case 1: r = n; g = v; b = wh; break;
-		case 2: r = wh; g = v; b = n; break;
-		case 3: r = wh; g = n; b = v; break;
-		case 4: r = n; g = wh; b = v; break;
-		case 5: r = v; g = wh; b = n; break;
-	}
+      if (child.type === 'close') {
+        q.push(append(q.pop(), queue, enclose));
+        continue;
+      }
 
-	return [r * 255, g * 255, b * 255];
-};
+      if (child.value && child.type !== 'open') {
+        queue.push(append(queue.pop(), child.value));
+        continue;
+      }
 
-convert.cmyk.rgb = function (cmyk) {
-	var c = cmyk[0] / 100;
-	var m = cmyk[1] / 100;
-	var y = cmyk[2] / 100;
-	var k = cmyk[3] / 100;
-	var r;
-	var g;
-	var b;
+      if (child.nodes) {
+        walk(child, node);
+      }
+    }
 
-	r = 1 - Math.min(1, c * (1 - k) + k);
-	g = 1 - Math.min(1, m * (1 - k) + k);
-	b = 1 - Math.min(1, y * (1 - k) + k);
+    return queue;
+  };
 
-	return [r * 255, g * 255, b * 255];
+  return utils.flatten(walk(ast));
 };
 
-convert.xyz.rgb = function (xyz) {
-	var x = xyz[0] / 100;
-	var y = xyz[1] / 100;
-	var z = xyz[2] / 100;
-	var r;
-	var g;
-	var b;
+var expand_1 = expand$4;
 
-	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
-	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
-	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+var constants$2 = {
+  MAX_LENGTH: 1024 * 64,
 
-	// assume sRGB
-	r = r > 0.0031308
-		? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
-		: r * 12.92;
+  // Digits
+  CHAR_0: '0', /* 0 */
+  CHAR_9: '9', /* 9 */
 
-	g = g > 0.0031308
-		? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
-		: g * 12.92;
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 'A', /* A */
+  CHAR_LOWERCASE_A: 'a', /* a */
+  CHAR_UPPERCASE_Z: 'Z', /* Z */
+  CHAR_LOWERCASE_Z: 'z', /* z */
 
-	b = b > 0.0031308
-		? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
-		: b * 12.92;
+  CHAR_LEFT_PARENTHESES: '(', /* ( */
+  CHAR_RIGHT_PARENTHESES: ')', /* ) */
 
-	r = Math.min(Math.max(0, r), 1);
-	g = Math.min(Math.max(0, g), 1);
-	b = Math.min(Math.max(0, b), 1);
+  CHAR_ASTERISK: '*', /* * */
 
-	return [r * 255, g * 255, b * 255];
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: '&', /* & */
+  CHAR_AT: '@', /* @ */
+  CHAR_BACKSLASH: '\\', /* \ */
+  CHAR_BACKTICK: '`', /* ` */
+  CHAR_CARRIAGE_RETURN: '\r', /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
+  CHAR_COLON: ':', /* : */
+  CHAR_COMMA: ',', /* , */
+  CHAR_DOLLAR: '$', /* . */
+  CHAR_DOT: '.', /* . */
+  CHAR_DOUBLE_QUOTE: '"', /* " */
+  CHAR_EQUAL: '=', /* = */
+  CHAR_EXCLAMATION_MARK: '!', /* ! */
+  CHAR_FORM_FEED: '\f', /* \f */
+  CHAR_FORWARD_SLASH: '/', /* / */
+  CHAR_HASH: '#', /* # */
+  CHAR_HYPHEN_MINUS: '-', /* - */
+  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
+  CHAR_LEFT_CURLY_BRACE: '{', /* { */
+  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
+  CHAR_LINE_FEED: '\n', /* \n */
+  CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
+  CHAR_PERCENT: '%', /* % */
+  CHAR_PLUS: '+', /* + */
+  CHAR_QUESTION_MARK: '?', /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
+  CHAR_RIGHT_CURLY_BRACE: '}', /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
+  CHAR_SEMICOLON: ';', /* ; */
+  CHAR_SINGLE_QUOTE: '\'', /* ' */
+  CHAR_SPACE: ' ', /*   */
+  CHAR_TAB: '\t', /* \t */
+  CHAR_UNDERSCORE: '_', /* _ */
+  CHAR_VERTICAL_LINE: '|', /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
 };
 
-convert.xyz.lab = function (xyz) {
-	var x = xyz[0];
-	var y = xyz[1];
-	var z = xyz[2];
-	var l;
-	var a;
-	var b;
-
-	x /= 95.047;
-	y /= 100;
-	z /= 108.883;
+const stringify$3 = stringify$6;
 
-	x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
-	y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
-	z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
+/**
+ * Constants
+ */
 
-	l = (116 * y) - 16;
-	a = 500 * (x - y);
-	b = 200 * (y - z);
+const {
+  MAX_LENGTH: MAX_LENGTH$3,
+  CHAR_BACKSLASH, /* \ */
+  CHAR_BACKTICK, /* ` */
+  CHAR_COMMA: CHAR_COMMA$1, /* , */
+  CHAR_DOT, /* . */
+  CHAR_LEFT_PARENTHESES, /* ( */
+  CHAR_RIGHT_PARENTHESES, /* ) */
+  CHAR_LEFT_CURLY_BRACE, /* { */
+  CHAR_RIGHT_CURLY_BRACE, /* } */
+  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */
+  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1, /* ] */
+  CHAR_DOUBLE_QUOTE: CHAR_DOUBLE_QUOTE$1, /* " */
+  CHAR_SINGLE_QUOTE: CHAR_SINGLE_QUOTE$1, /* ' */
+  CHAR_NO_BREAK_SPACE,
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE
+} = constants$2;
 
-	return [l, a, b];
-};
+/**
+ * parse
+ */
 
-convert.lab.xyz = function (lab) {
-	var l = lab[0];
-	var a = lab[1];
-	var b = lab[2];
-	var x;
-	var y;
-	var z;
+const parse$c = (input, options = {}) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected a string');
+  }
 
-	y = (l + 16) / 116;
-	x = a / 500 + y;
-	z = y - b / 200;
+  let opts = options || {};
+  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$3, opts.maxLength) : MAX_LENGTH$3;
+  if (input.length > max) {
+    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+  }
 
-	var y2 = Math.pow(y, 3);
-	var x2 = Math.pow(x, 3);
-	var z2 = Math.pow(z, 3);
-	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
-	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
-	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+  let ast = { type: 'root', input, nodes: [] };
+  let stack = [ast];
+  let block = ast;
+  let prev = ast;
+  let brackets = 0;
+  let length = input.length;
+  let index = 0;
+  let depth = 0;
+  let value;
 
-	x *= 95.047;
-	y *= 100;
-	z *= 108.883;
+  /**
+   * Helpers
+   */
 
-	return [x, y, z];
-};
+  const advance = () => input[index++];
+  const push = node => {
+    if (node.type === 'text' && prev.type === 'dot') {
+      prev.type = 'text';
+    }
 
-convert.lab.lch = function (lab) {
-	var l = lab[0];
-	var a = lab[1];
-	var b = lab[2];
-	var hr;
-	var h;
-	var c;
+    if (prev && prev.type === 'text' && node.type === 'text') {
+      prev.value += node.value;
+      return;
+    }
 
-	hr = Math.atan2(b, a);
-	h = hr * 360 / 2 / Math.PI;
+    block.nodes.push(node);
+    node.parent = block;
+    node.prev = prev;
+    prev = node;
+    return node;
+  };
 
-	if (h < 0) {
-		h += 360;
-	}
+  push({ type: 'bos' });
 
-	c = Math.sqrt(a * a + b * b);
+  while (index < length) {
+    block = stack[stack.length - 1];
+    value = advance();
 
-	return [l, c, h];
-};
+    /**
+     * Invalid chars
+     */
 
-convert.lch.lab = function (lch) {
-	var l = lch[0];
-	var c = lch[1];
-	var h = lch[2];
-	var a;
-	var b;
-	var hr;
+    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+      continue;
+    }
 
-	hr = h / 360 * 2 * Math.PI;
-	a = c * Math.cos(hr);
-	b = c * Math.sin(hr);
+    /**
+     * Escaped chars
+     */
 
-	return [l, a, b];
-};
+    if (value === CHAR_BACKSLASH) {
+      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
+      continue;
+    }
 
-convert.rgb.ansi16 = function (args) {
-	var r = args[0];
-	var g = args[1];
-	var b = args[2];
-	var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
+    /**
+     * Right square bracket (literal): ']'
+     */
 
-	value = Math.round(value / 50);
+    if (value === CHAR_RIGHT_SQUARE_BRACKET$1) {
+      push({ type: 'text', value: '\\' + value });
+      continue;
+    }
 
-	if (value === 0) {
-		return 30;
-	}
+    /**
+     * Left square bracket: '['
+     */
 
-	var ansi = 30
-		+ ((Math.round(b / 255) << 2)
-		| (Math.round(g / 255) << 1)
-		| Math.round(r / 255));
+    if (value === CHAR_LEFT_SQUARE_BRACKET$1) {
+      brackets++;
+      let next;
 
-	if (value === 2) {
-		ansi += 60;
-	}
+      while (index < length && (next = advance())) {
+        value += next;
 
-	return ansi;
-};
+        if (next === CHAR_LEFT_SQUARE_BRACKET$1) {
+          brackets++;
+          continue;
+        }
 
-convert.hsv.ansi16 = function (args) {
-	// optimization here; we already know the value and don't need to get
-	// it converted for us.
-	return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
-};
+        if (next === CHAR_BACKSLASH) {
+          value += advance();
+          continue;
+        }
 
-convert.rgb.ansi256 = function (args) {
-	var r = args[0];
-	var g = args[1];
-	var b = args[2];
+        if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
+          brackets--;
 
-	// we use the extended greyscale palette here, with the exception of
-	// black and white. normal palette only has 4 greyscale shades.
-	if (r === g && g === b) {
-		if (r < 8) {
-			return 16;
-		}
+          if (brackets === 0) {
+            break;
+          }
+        }
+      }
 
-		if (r > 248) {
-			return 231;
-		}
+      push({ type: 'text', value });
+      continue;
+    }
 
-		return Math.round(((r - 8) / 247) * 24) + 232;
-	}
+    /**
+     * Parentheses
+     */
 
-	var ansi = 16
-		+ (36 * Math.round(r / 255 * 5))
-		+ (6 * Math.round(g / 255 * 5))
-		+ Math.round(b / 255 * 5);
+    if (value === CHAR_LEFT_PARENTHESES) {
+      block = push({ type: 'paren', nodes: [] });
+      stack.push(block);
+      push({ type: 'text', value });
+      continue;
+    }
 
-	return ansi;
-};
+    if (value === CHAR_RIGHT_PARENTHESES) {
+      if (block.type !== 'paren') {
+        push({ type: 'text', value });
+        continue;
+      }
+      block = stack.pop();
+      push({ type: 'text', value });
+      block = stack[stack.length - 1];
+      continue;
+    }
 
-convert.ansi16.rgb = function (args) {
-	var color = args % 10;
+    /**
+     * Quotes: '|"|`
+     */
 
-	// handle greyscale
-	if (color === 0 || color === 7) {
-		if (args > 50) {
-			color += 3.5;
-		}
+    if (value === CHAR_DOUBLE_QUOTE$1 || value === CHAR_SINGLE_QUOTE$1 || value === CHAR_BACKTICK) {
+      let open = value;
+      let next;
 
-		color = color / 10.5 * 255;
+      if (options.keepQuotes !== true) {
+        value = '';
+      }
 
-		return [color, color, color];
-	}
+      while (index < length && (next = advance())) {
+        if (next === CHAR_BACKSLASH) {
+          value += next + advance();
+          continue;
+        }
 
-	var mult = (~~(args > 50) + 1) * 0.5;
-	var r = ((color & 1) * mult) * 255;
-	var g = (((color >> 1) & 1) * mult) * 255;
-	var b = (((color >> 2) & 1) * mult) * 255;
+        if (next === open) {
+          if (options.keepQuotes === true) value += next;
+          break;
+        }
 
-	return [r, g, b];
-};
+        value += next;
+      }
 
-convert.ansi256.rgb = function (args) {
-	// handle greyscale
-	if (args >= 232) {
-		var c = (args - 232) * 10 + 8;
-		return [c, c, c];
-	}
+      push({ type: 'text', value });
+      continue;
+    }
 
-	args -= 16;
+    /**
+     * Left curly brace: '{'
+     */
 
-	var rem;
-	var r = Math.floor(args / 36) / 5 * 255;
-	var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
-	var b = (rem % 6) / 5 * 255;
+    if (value === CHAR_LEFT_CURLY_BRACE) {
+      depth++;
 
-	return [r, g, b];
-};
+      let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+      let brace = {
+        type: 'brace',
+        open: true,
+        close: false,
+        dollar,
+        depth,
+        commas: 0,
+        ranges: 0,
+        nodes: []
+      };
 
-convert.rgb.hex = function (args) {
-	var integer = ((Math.round(args[0]) & 0xFF) << 16)
-		+ ((Math.round(args[1]) & 0xFF) << 8)
-		+ (Math.round(args[2]) & 0xFF);
+      block = push(brace);
+      stack.push(block);
+      push({ type: 'open', value });
+      continue;
+    }
 
-	var string = integer.toString(16).toUpperCase();
-	return '000000'.substring(string.length) + string;
-};
+    /**
+     * Right curly brace: '}'
+     */
 
-convert.hex.rgb = function (args) {
-	var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
-	if (!match) {
-		return [0, 0, 0];
-	}
+    if (value === CHAR_RIGHT_CURLY_BRACE) {
+      if (block.type !== 'brace') {
+        push({ type: 'text', value });
+        continue;
+      }
 
-	var colorString = match[0];
+      let type = 'close';
+      block = stack.pop();
+      block.close = true;
 
-	if (match[0].length === 3) {
-		colorString = colorString.split('').map(function (char) {
-			return char + char;
-		}).join('');
-	}
+      push({ type, value });
+      depth--;
 
-	var integer = parseInt(colorString, 16);
-	var r = (integer >> 16) & 0xFF;
-	var g = (integer >> 8) & 0xFF;
-	var b = integer & 0xFF;
+      block = stack[stack.length - 1];
+      continue;
+    }
 
-	return [r, g, b];
-};
+    /**
+     * Comma: ','
+     */
 
-convert.rgb.hcg = function (rgb) {
-	var r = rgb[0] / 255;
-	var g = rgb[1] / 255;
-	var b = rgb[2] / 255;
-	var max = Math.max(Math.max(r, g), b);
-	var min = Math.min(Math.min(r, g), b);
-	var chroma = (max - min);
-	var grayscale;
-	var hue;
+    if (value === CHAR_COMMA$1 && depth > 0) {
+      if (block.ranges > 0) {
+        block.ranges = 0;
+        let open = block.nodes.shift();
+        block.nodes = [open, { type: 'text', value: stringify$3(block) }];
+      }
 
-	if (chroma < 1) {
-		grayscale = min / (1 - chroma);
-	} else {
-		grayscale = 0;
-	}
+      push({ type: 'comma', value });
+      block.commas++;
+      continue;
+    }
 
-	if (chroma <= 0) {
-		hue = 0;
-	} else
-	if (max === r) {
-		hue = ((g - b) / chroma) % 6;
-	} else
-	if (max === g) {
-		hue = 2 + (b - r) / chroma;
-	} else {
-		hue = 4 + (r - g) / chroma + 4;
-	}
+    /**
+     * Dot: '.'
+     */
 
-	hue /= 6;
-	hue %= 1;
+    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+      let siblings = block.nodes;
 
-	return [hue * 360, chroma * 100, grayscale * 100];
-};
+      if (depth === 0 || siblings.length === 0) {
+        push({ type: 'text', value });
+        continue;
+      }
 
-convert.hsl.hcg = function (hsl) {
-	var s = hsl[1] / 100;
-	var l = hsl[2] / 100;
-	var c = 1;
-	var f = 0;
+      if (prev.type === 'dot') {
+        block.range = [];
+        prev.value += value;
+        prev.type = 'range';
 
-	if (l < 0.5) {
-		c = 2.0 * s * l;
-	} else {
-		c = 2.0 * s * (1.0 - l);
-	}
+        if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+          block.invalid = true;
+          block.ranges = 0;
+          prev.type = 'text';
+          continue;
+        }
 
-	if (c < 1.0) {
-		f = (l - 0.5 * c) / (1.0 - c);
-	}
+        block.ranges++;
+        block.args = [];
+        continue;
+      }
 
-	return [hsl[0], c * 100, f * 100];
-};
+      if (prev.type === 'range') {
+        siblings.pop();
 
-convert.hsv.hcg = function (hsv) {
-	var s = hsv[1] / 100;
-	var v = hsv[2] / 100;
+        let before = siblings[siblings.length - 1];
+        before.value += prev.value + value;
+        prev = before;
+        block.ranges--;
+        continue;
+      }
 
-	var c = s * v;
-	var f = 0;
+      push({ type: 'dot', value });
+      continue;
+    }
 
-	if (c < 1.0) {
-		f = (v - c) / (1 - c);
-	}
+    /**
+     * Text
+     */
 
-	return [hsv[0], c * 100, f * 100];
-};
+    push({ type: 'text', value });
+  }
 
-convert.hcg.rgb = function (hcg) {
-	var h = hcg[0] / 360;
-	var c = hcg[1] / 100;
-	var g = hcg[2] / 100;
+  // Mark imbalanced braces and brackets as invalid
+  do {
+    block = stack.pop();
 
-	if (c === 0.0) {
-		return [g * 255, g * 255, g * 255];
-	}
+    if (block.type !== 'root') {
+      block.nodes.forEach(node => {
+        if (!node.nodes) {
+          if (node.type === 'open') node.isOpen = true;
+          if (node.type === 'close') node.isClose = true;
+          if (!node.nodes) node.type = 'text';
+          node.invalid = true;
+        }
+      });
 
-	var pure = [0, 0, 0];
-	var hi = (h % 1) * 6;
-	var v = hi % 1;
-	var w = 1 - v;
-	var mg = 0;
+      // get the location of the block on parent.nodes (block's siblings)
+      let parent = stack[stack.length - 1];
+      let index = parent.nodes.indexOf(block);
+      // replace the (invalid) block with it's nodes
+      parent.nodes.splice(index, 1, ...block.nodes);
+    }
+  } while (stack.length > 0);
 
-	switch (Math.floor(hi)) {
-		case 0:
-			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
-		case 1:
-			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
-		case 2:
-			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
-		case 3:
-			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
-		case 4:
-			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
-		default:
-			pure[0] = 1; pure[1] = 0; pure[2] = w;
-	}
+  push({ type: 'eos' });
+  return ast;
+};
 
-	mg = (1.0 - c) * g;
+var parse_1$1 = parse$c;
 
-	return [
-		(c * pure[0] + mg) * 255,
-		(c * pure[1] + mg) * 255,
-		(c * pure[2] + mg) * 255
-	];
-};
+const stringify$2 = stringify$6;
+const compile = compile_1;
+const expand$3 = expand_1;
+const parse$b = parse_1$1;
 
-convert.hcg.hsv = function (hcg) {
-	var c = hcg[1] / 100;
-	var g = hcg[2] / 100;
+/**
+ * Expand the given pattern or create a regex-compatible string.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+ * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
 
-	var v = c + g * (1.0 - c);
-	var f = 0;
+const braces$1 = (input, options = {}) => {
+  let output = [];
 
-	if (v > 0.0) {
-		f = c / v;
-	}
+  if (Array.isArray(input)) {
+    for (let pattern of input) {
+      let result = braces$1.create(pattern, options);
+      if (Array.isArray(result)) {
+        output.push(...result);
+      } else {
+        output.push(result);
+      }
+    }
+  } else {
+    output = [].concat(braces$1.create(input, options));
+  }
 
-	return [hcg[0], f * 100, v * 100];
+  if (options && options.expand === true && options.nodupes === true) {
+    output = [...new Set(output)];
+  }
+  return output;
 };
 
-convert.hcg.hsl = function (hcg) {
-	var c = hcg[1] / 100;
-	var g = hcg[2] / 100;
+/**
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * // braces.parse(pattern, [, options]);
+ * const ast = braces.parse('a/{b,c}/d');
+ * console.log(ast);
+ * ```
+ * @param {String} pattern Brace pattern to parse
+ * @param {Object} options
+ * @return {Object} Returns an AST
+ * @api public
+ */
 
-	var l = g * (1.0 - c) + 0.5 * c;
-	var s = 0;
+braces$1.parse = (input, options = {}) => parse$b(input, options);
 
-	if (l > 0.0 && l < 0.5) {
-		s = c / (2 * l);
-	} else
-	if (l >= 0.5 && l < 1.0) {
-		s = c / (2 * (1 - l));
-	}
+/**
+ * Creates a braces string from an AST, or an AST node.
+ *
+ * ```js
+ * const braces = require('braces');
+ * let ast = braces.parse('foo/{a,b}/bar');
+ * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
 
-	return [hcg[0], s * 100, l * 100];
+braces$1.stringify = (input, options = {}) => {
+  if (typeof input === 'string') {
+    return stringify$2(braces$1.parse(input, options), options);
+  }
+  return stringify$2(input, options);
 };
 
-convert.hcg.hwb = function (hcg) {
-	var c = hcg[1] / 100;
-	var g = hcg[2] / 100;
-	var v = c + g * (1.0 - c);
-	return [hcg[0], (v - c) * 100, (1 - v) * 100];
+/**
+ * Compiles a brace pattern into a regex-compatible, optimized string.
+ * This method is called by the main [braces](#braces) function by default.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.compile('a/{b,c}/d'));
+ * //=> ['a/(b|c)/d']
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.compile = (input, options = {}) => {
+  if (typeof input === 'string') {
+    input = braces$1.parse(input, options);
+  }
+  return compile(input, options);
 };
 
-convert.hwb.hcg = function (hwb) {
-	var w = hwb[1] / 100;
-	var b = hwb[2] / 100;
-	var v = 1 - b;
-	var c = v - w;
-	var g = 0;
+/**
+ * Expands a brace pattern into an array. This method is called by the
+ * main [braces](#braces) function when `options.expand` is true. Before
+ * using this method it's recommended that you read the [performance notes](#performance))
+ * and advantages of using [.compile](#compile) instead.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/b/d', 'a/c/d'];
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
 
-	if (c < 1) {
-		g = (v - c) / (1 - c);
-	}
+braces$1.expand = (input, options = {}) => {
+  if (typeof input === 'string') {
+    input = braces$1.parse(input, options);
+  }
 
-	return [hwb[0], c * 100, g * 100];
-};
+  let result = expand$3(input, options);
 
-convert.apple.rgb = function (apple) {
-	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
+  // filter out empty strings if specified
+  if (options.noempty === true) {
+    result = result.filter(Boolean);
+  }
+
+  // filter out duplicates if specified
+  if (options.nodupes === true) {
+    result = [...new Set(result)];
+  }
+
+  return result;
+};
+
+/**
+ * Processes a brace pattern and returns either an expanded array
+ * (if `options.expand` is true), a highly optimized regex-compatible string.
+ * This method is called by the main [braces](#braces) function.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.create = (input, options = {}) => {
+  if (input === '' || input.length < 3) {
+    return [input];
+  }
+
+ return options.expand !== true
+    ? braces$1.compile(input, options)
+    : braces$1.expand(input, options);
+};
+
+/**
+ * Expose "braces"
+ */
+
+var braces_1 = braces$1;
+
+var require$$0$1 = [
+	"3dm",
+	"3ds",
+	"3g2",
+	"3gp",
+	"7z",
+	"a",
+	"aac",
+	"adp",
+	"ai",
+	"aif",
+	"aiff",
+	"alz",
+	"ape",
+	"apk",
+	"appimage",
+	"ar",
+	"arj",
+	"asf",
+	"au",
+	"avi",
+	"bak",
+	"baml",
+	"bh",
+	"bin",
+	"bk",
+	"bmp",
+	"btif",
+	"bz2",
+	"bzip2",
+	"cab",
+	"caf",
+	"cgm",
+	"class",
+	"cmx",
+	"cpio",
+	"cr2",
+	"cur",
+	"dat",
+	"dcm",
+	"deb",
+	"dex",
+	"djvu",
+	"dll",
+	"dmg",
+	"dng",
+	"doc",
+	"docm",
+	"docx",
+	"dot",
+	"dotm",
+	"dra",
+	"DS_Store",
+	"dsk",
+	"dts",
+	"dtshd",
+	"dvb",
+	"dwg",
+	"dxf",
+	"ecelp4800",
+	"ecelp7470",
+	"ecelp9600",
+	"egg",
+	"eol",
+	"eot",
+	"epub",
+	"exe",
+	"f4v",
+	"fbs",
+	"fh",
+	"fla",
+	"flac",
+	"flatpak",
+	"fli",
+	"flv",
+	"fpx",
+	"fst",
+	"fvt",
+	"g3",
+	"gh",
+	"gif",
+	"graffle",
+	"gz",
+	"gzip",
+	"h261",
+	"h263",
+	"h264",
+	"icns",
+	"ico",
+	"ief",
+	"img",
+	"ipa",
+	"iso",
+	"jar",
+	"jpeg",
+	"jpg",
+	"jpgv",
+	"jpm",
+	"jxr",
+	"key",
+	"ktx",
+	"lha",
+	"lib",
+	"lvp",
+	"lz",
+	"lzh",
+	"lzma",
+	"lzo",
+	"m3u",
+	"m4a",
+	"m4v",
+	"mar",
+	"mdi",
+	"mht",
+	"mid",
+	"midi",
+	"mj2",
+	"mka",
+	"mkv",
+	"mmr",
+	"mng",
+	"mobi",
+	"mov",
+	"movie",
+	"mp3",
+	"mp4",
+	"mp4a",
+	"mpeg",
+	"mpg",
+	"mpga",
+	"mxu",
+	"nef",
+	"npx",
+	"numbers",
+	"nupkg",
+	"o",
+	"odp",
+	"ods",
+	"odt",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"ott",
+	"pages",
+	"pbm",
+	"pcx",
+	"pdb",
+	"pdf",
+	"pea",
+	"pgm",
+	"pic",
+	"png",
+	"pnm",
+	"pot",
+	"potm",
+	"potx",
+	"ppa",
+	"ppam",
+	"ppm",
+	"pps",
+	"ppsm",
+	"ppsx",
+	"ppt",
+	"pptm",
+	"pptx",
+	"psd",
+	"pya",
+	"pyc",
+	"pyo",
+	"pyv",
+	"qt",
+	"rar",
+	"ras",
+	"raw",
+	"resources",
+	"rgb",
+	"rip",
+	"rlc",
+	"rmf",
+	"rmvb",
+	"rpm",
+	"rtf",
+	"rz",
+	"s3m",
+	"s7z",
+	"scpt",
+	"sgi",
+	"shar",
+	"snap",
+	"sil",
+	"sketch",
+	"slk",
+	"smv",
+	"snk",
+	"so",
+	"stl",
+	"suo",
+	"sub",
+	"swf",
+	"tar",
+	"tbz",
+	"tbz2",
+	"tga",
+	"tgz",
+	"thmx",
+	"tif",
+	"tiff",
+	"tlz",
+	"ttc",
+	"ttf",
+	"txz",
+	"udf",
+	"uvh",
+	"uvi",
+	"uvm",
+	"uvp",
+	"uvs",
+	"uvu",
+	"viv",
+	"vob",
+	"war",
+	"wav",
+	"wax",
+	"wbmp",
+	"wdp",
+	"weba",
+	"webm",
+	"webp",
+	"whl",
+	"wim",
+	"wm",
+	"wma",
+	"wmv",
+	"wmx",
+	"woff",
+	"woff2",
+	"wrm",
+	"wvx",
+	"xbm",
+	"xif",
+	"xla",
+	"xlam",
+	"xls",
+	"xlsb",
+	"xlsm",
+	"xlsx",
+	"xlt",
+	"xltm",
+	"xltx",
+	"xm",
+	"xmind",
+	"xpi",
+	"xpm",
+	"xwd",
+	"xz",
+	"z",
+	"zip",
+	"zipx"
+];
+
+var binaryExtensions$1 = require$$0$1;
+
+const path$8 = path$b;
+const binaryExtensions = binaryExtensions$1;
+
+const extensions = new Set(binaryExtensions);
+
+var isBinaryPath$1 = filePath => extensions.has(path$8.extname(filePath).slice(1).toLowerCase());
+
+var constants$1 = {};
+
+(function (exports) {
+
+const {sep} = path$b;
+const {platform} = process;
+const os = require$$0$2;
+
+exports.EV_ALL = 'all';
+exports.EV_READY = 'ready';
+exports.EV_ADD = 'add';
+exports.EV_CHANGE = 'change';
+exports.EV_ADD_DIR = 'addDir';
+exports.EV_UNLINK = 'unlink';
+exports.EV_UNLINK_DIR = 'unlinkDir';
+exports.EV_RAW = 'raw';
+exports.EV_ERROR = 'error';
+
+exports.STR_DATA = 'data';
+exports.STR_END = 'end';
+exports.STR_CLOSE = 'close';
+
+exports.FSEVENT_CREATED = 'created';
+exports.FSEVENT_MODIFIED = 'modified';
+exports.FSEVENT_DELETED = 'deleted';
+exports.FSEVENT_MOVED = 'moved';
+exports.FSEVENT_CLONED = 'cloned';
+exports.FSEVENT_UNKNOWN = 'unknown';
+exports.FSEVENT_TYPE_FILE = 'file';
+exports.FSEVENT_TYPE_DIRECTORY = 'directory';
+exports.FSEVENT_TYPE_SYMLINK = 'symlink';
+
+exports.KEY_LISTENERS = 'listeners';
+exports.KEY_ERR = 'errHandlers';
+exports.KEY_RAW = 'rawEmitters';
+exports.HANDLER_KEYS = [exports.KEY_LISTENERS, exports.KEY_ERR, exports.KEY_RAW];
+
+exports.DOT_SLASH = `.${sep}`;
+
+exports.BACK_SLASH_RE = /\\/g;
+exports.DOUBLE_SLASH_RE = /\/\//;
+exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
+exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+exports.REPLACER_RE = /^\.[/\\]/;
+
+exports.SLASH = '/';
+exports.SLASH_SLASH = '//';
+exports.BRACE_START = '{';
+exports.BANG = '!';
+exports.ONE_DOT = '.';
+exports.TWO_DOTS = '..';
+exports.STAR = '*';
+exports.GLOBSTAR = '**';
+exports.ROOT_GLOBSTAR = '/**/*';
+exports.SLASH_GLOBSTAR = '/**';
+exports.DIR_SUFFIX = 'Dir';
+exports.ANYMATCH_OPTS = {dot: true};
+exports.STRING_TYPE = 'string';
+exports.FUNCTION_TYPE = 'function';
+exports.EMPTY_STR = '';
+exports.EMPTY_FN = () => {};
+exports.IDENTITY_FN = val => val;
+
+exports.isWindows = platform === 'win32';
+exports.isMacos = platform === 'darwin';
+exports.isLinux = platform === 'linux';
+exports.isIBMi = os.type() === 'OS400';
+}(constants$1));
+
+const fs$8 = require$$0$3;
+const sysPath$2 = path$b;
+const { promisify: promisify$2 } = require$$0$4;
+const isBinaryPath = isBinaryPath$1;
+const {
+  isWindows: isWindows$3,
+  isLinux,
+  EMPTY_FN: EMPTY_FN$2,
+  EMPTY_STR: EMPTY_STR$1,
+  KEY_LISTENERS,
+  KEY_ERR,
+  KEY_RAW,
+  HANDLER_KEYS,
+  EV_CHANGE: EV_CHANGE$2,
+  EV_ADD: EV_ADD$2,
+  EV_ADD_DIR: EV_ADD_DIR$2,
+  EV_ERROR: EV_ERROR$2,
+  STR_DATA: STR_DATA$1,
+  STR_END: STR_END$2,
+  BRACE_START: BRACE_START$1,
+  STAR
+} = constants$1;
+
+const THROTTLE_MODE_WATCH = 'watch';
+
+const open = promisify$2(fs$8.open);
+const stat$2 = promisify$2(fs$8.stat);
+const lstat$1 = promisify$2(fs$8.lstat);
+const close = promisify$2(fs$8.close);
+const fsrealpath = promisify$2(fs$8.realpath);
+
+const statMethods$1 = { lstat: lstat$1, stat: stat$2 };
+
+// TODO: emit errors properly. Example: EMFILE on Macos.
+const foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+
+const addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = new Set([container]);
+  }
+  container.add(item);
+};
+
+const clearItem = cont => key => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+
+const delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+};
+
+const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+
+/**
+ * @typedef {String} Path
+ */
+
+// fs_watch helpers
+
+// object to hold per-process fs_watch instances
+// (may be shared across chokidar FSWatcher instances)
+
+/**
+ * @typedef {Object} FsWatchContainer
+ * @property {Set} listeners
+ * @property {Set} errHandlers
+ * @property {Set} rawEmitters
+ * @property {fs.FSWatcher=} watcher
+ * @property {Boolean=} watcherUnusable
+ */
+
+/**
+ * @type {Map<String,FsWatchContainer>}
+ */
+const FsWatchInstances = new Map();
+
+/**
+ * Instantiates the fs_watch interface
+ * @param {String} path to be watched
+ * @param {Object} options to be passed to fs_watch
+ * @param {Function} listener main event handler
+ * @param {Function} errHandler emits info about errors
+ * @param {Function} emitRaw emits raw event data
+ * @returns {fs.FSWatcher} new fsevents instance
+ */
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path);
+    emitRaw(rawEvent, evPath, {watchedPath: path});
+
+    // emit based on events occurring for files from a directory's watcher in
+    // case the file's watcher misses it (and rely on throttling to de-dupe)
+    if (evPath && path !== evPath) {
+      fsWatchBroadcast(
+        sysPath$2.resolve(path, evPath), KEY_LISTENERS, sysPath$2.join(path, evPath)
+      );
+    }
+  };
+  try {
+    return fs$8.watch(path, options, handleEvent);
+  } catch (error) {
+    errHandler(error);
+  }
+}
+
+/**
+ * Helper for passing fs_watch event data to a collection of listeners
+ * @param {Path} fullPath absolute path bound to fs_watch instance
+ * @param {String} type listener type
+ * @param {*=} val1 arguments to be passed to listeners
+ * @param {*=} val2
+ * @param {*=} val3
+ */
+const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont) return;
+  foreach(cont[type], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+
+/**
+ * Instantiates the fs_watch interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param {String} path
+ * @param {String} fullPath absolute path
+ * @param {Object} options to be passed to fs_watch
+ * @param {Object} handlers container for event listener functions
+ */
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+  const {listener, errHandler, rawEmitter} = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+
+  /** @type {fs.FSWatcher=} */
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(
+      path, options, listener, errHandler, rawEmitter
+    );
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler, // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher) return;
+    watcher.on(EV_ERROR$2, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      cont.watcherUnusable = true; // documented since Node 10.4.1
+      // Workaround for https://github.com/joyent/node/issues/4337
+      if (isWindows$3 && error.code === 'EPERM') {
+        try {
+          const fd = await open(path, 'r');
+          await close(fd);
+          broadcastErr(error);
+        } catch (err) {}
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  // const index = cont.listeners.indexOf(listener);
+
+  // removes this instance's listeners and closes the underlying fs_watch
+  // instance if there are no more listeners left
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      // Check to protect against issue gh-730.
+      // if (cont.watcherUnusable) {
+      cont.watcher.close();
+      // }
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+
+// fs_watchFile helpers
+
+// object to hold per-process fs_watchFile instances
+// (may be shared across chokidar FSWatcher instances)
+const FsWatchFileInstances = new Map();
+
+/**
+ * Instantiates the fs_watchFile interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param {String} path to be watched
+ * @param {String} fullPath absolute path
+ * @param {Object} options options to be passed to fs_watchFile
+ * @param {Object} handlers container for event listener functions
+ * @returns {Function} closer
+ */
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+  const {listener, rawEmitter} = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    fs$8.unwatchFile(fullPath);
+    cont = undefined;
+  }
+
+  /* eslint-enable no-unused-vars, prefer-destructuring */
+
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    // TODO
+    // listeners.add(listener);
+    // rawEmitters.add(rawEmitter);
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: fs$8.watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter) => {
+          rawEmitter(EV_CHANGE$2, fullPath, {curr, prev});
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener) => listener(path, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  // const index = cont.listeners.indexOf(listener);
+
+  // Removes this instance's listeners and closes the underlying fs_watchFile
+  // instance if there are no more listeners left.
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      fs$8.unwatchFile(fullPath);
+      cont.options = cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+
+/**
+ * @mixin
+ */
+class NodeFsHandler$1 {
+
+/**
+ * @param {import("../index").FSWatcher} fsW
+ */
+constructor(fsW) {
+  this.fsw = fsW;
+  this._boundHandleError = (error) => fsW._handleError(error);
+}
+
+/**
+ * Watch file for changes with fs_watchFile or fs_watch.
+ * @param {String} path to file or dir
+ * @param {Function} listener on fs change
+ * @returns {Function} closer for the watcher instance
+ */
+_watchWithNodeFs(path, listener) {
+  const opts = this.fsw.options;
+  const directory = sysPath$2.dirname(path);
+  const basename = sysPath$2.basename(path);
+  const parent = this.fsw._getWatchedDir(directory);
+  parent.add(basename);
+  const absolutePath = sysPath$2.resolve(path);
+  const options = {persistent: opts.persistent};
+  if (!listener) listener = EMPTY_FN$2;
+
+  let closer;
+  if (opts.usePolling) {
+    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
+      opts.binaryInterval : opts.interval;
+    closer = setFsWatchFileListener(path, absolutePath, options, {
+      listener,
+      rawEmitter: this.fsw._emitRaw
+    });
+  } else {
+    closer = setFsWatchListener(path, absolutePath, options, {
+      listener,
+      errHandler: this._boundHandleError,
+      rawEmitter: this.fsw._emitRaw
+    });
+  }
+  return closer;
+}
+
+/**
+ * Watch a file and emit add event if warranted.
+ * @param {Path} file Path
+ * @param {fs.Stats} stats result of fs_stat
+ * @param {Boolean} initialAdd was the file added at watch instantiation?
+ * @returns {Function} closer for the watcher instance
+ */
+_handleFile(file, stats, initialAdd) {
+  if (this.fsw.closed) {
+    return;
+  }
+  const dirname = sysPath$2.dirname(file);
+  const basename = sysPath$2.basename(file);
+  const parent = this.fsw._getWatchedDir(dirname);
+  // stats is always present
+  let prevStats = stats;
+
+  // if the file is already being watched, do nothing
+  if (parent.has(basename)) return;
+
+  const listener = async (path, newStats) => {
+    if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+    if (!newStats || newStats.mtimeMs === 0) {
+      try {
+        const newStats = await stat$2(file);
+        if (this.fsw.closed) return;
+        // Check that change event was not fired because of changed only accessTime.
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV_CHANGE$2, file, newStats);
+        }
+        if (isLinux && prevStats.ino !== newStats.ino) {
+          this.fsw._closeFile(path);
+          prevStats = newStats;
+          this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
+        } else {
+          prevStats = newStats;
+        }
+      } catch (error) {
+        // Fix issues where mtime is null but file is still present
+        this.fsw._remove(dirname, basename);
+      }
+      // add is about to be emitted if file not already tracked in parent
+    } else if (parent.has(basename)) {
+      // Check that change event was not fired because of changed only accessTime.
+      const at = newStats.atimeMs;
+      const mt = newStats.mtimeMs;
+      if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+        this.fsw._emit(EV_CHANGE$2, file, newStats);
+      }
+      prevStats = newStats;
+    }
+  };
+  // kick off the watcher
+  const closer = this._watchWithNodeFs(file, listener);
+
+  // emit an add event if we're supposed to
+  if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+    if (!this.fsw._throttle(EV_ADD$2, file, 0)) return;
+    this.fsw._emit(EV_ADD$2, file, stats);
+  }
+
+  return closer;
+}
+
+/**
+ * Handle symlinks encountered while reading a dir.
+ * @param {Object} entry returned by readdirp
+ * @param {String} directory path of dir being read
+ * @param {String} path of this item
+ * @param {String} item basename of this item
+ * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
+ */
+async _handleSymlink(entry, directory, path, item) {
+  if (this.fsw.closed) {
+    return;
+  }
+  const full = entry.fullPath;
+  const dir = this.fsw._getWatchedDir(directory);
+
+  if (!this.fsw.options.followSymlinks) {
+    // watch symlink directly (don't follow) and detect changes
+    this.fsw._incrReadyCount();
+    const linkPath = await fsrealpath(path);
+    if (this.fsw.closed) return;
+    if (dir.has(item)) {
+      if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV_CHANGE$2, path, entry.stats);
+      }
+    } else {
+      dir.add(item);
+      this.fsw._symlinkPaths.set(full, linkPath);
+      this.fsw._emit(EV_ADD$2, path, entry.stats);
+    }
+    this.fsw._emitReady();
+    return true;
+  }
+
+  // don't follow the same symlink more than once
+  if (this.fsw._symlinkPaths.has(full)) {
+    return true;
+  }
+
+  this.fsw._symlinkPaths.set(full, true);
+}
+
+_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+  // Normalize the directory name on Windows
+  directory = sysPath$2.join(directory, EMPTY_STR$1);
+
+  if (!wh.hasGlob) {
+    throttler = this.fsw._throttle('readdir', directory, 1000);
+    if (!throttler) return;
+  }
+
+  const previous = this.fsw._getWatchedDir(wh.path);
+  const current = new Set();
+
+  let stream = this.fsw._readdirp(directory, {
+    fileFilter: entry => wh.filterPath(entry),
+    directoryFilter: entry => wh.filterDir(entry),
+    depth: 0
+  }).on(STR_DATA$1, async (entry) => {
+    if (this.fsw.closed) {
+      stream = undefined;
+      return;
+    }
+    const item = entry.path;
+    let path = sysPath$2.join(directory, item);
+    current.add(item);
+
+    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+      return;
+    }
+
+    if (this.fsw.closed) {
+      stream = undefined;
+      return;
+    }
+    // Files that present in current directory snapshot
+    // but absent in previous are added to watch list and
+    // emit `add` event.
+    if (item === target || !target && !previous.has(item)) {
+      this.fsw._incrReadyCount();
+
+      // ensure relativeness of path is preserved in case of watcher reuse
+      path = sysPath$2.join(dir, sysPath$2.relative(dir, path));
+
+      this._addToNodeFs(path, initialAdd, wh, depth + 1);
+    }
+  }).on(EV_ERROR$2, this._boundHandleError);
+
+  return new Promise(resolve =>
+    stream.once(STR_END$2, () => {
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      const wasThrottled = throttler ? throttler.clear() : false;
+
+      resolve();
+
+      // Files that absent in current directory snapshot
+      // but present in previous emit `remove` event
+      // and are removed from @watched[directory].
+      previous.getChildren().filter((item) => {
+        return item !== directory &&
+          !current.has(item) &&
+          // in case of intersecting globs;
+          // a path may have been filtered out of this readdir, but
+          // shouldn't be removed because it matches a different glob
+          (!wh.hasGlob || wh.filterPath({
+            fullPath: sysPath$2.resolve(directory, item)
+          }));
+      }).forEach((item) => {
+        this.fsw._remove(directory, item);
+      });
+
+      stream = undefined;
+
+      // one more time for any missed in case changes came in extremely quickly
+      if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+    })
+  );
+}
+
+/**
+ * Read directory to add / remove files from `@watched` list and re-read it on change.
+ * @param {String} dir fs path
+ * @param {fs.Stats} stats
+ * @param {Boolean} initialAdd
+ * @param {Number} depth relative to user-supplied path
+ * @param {String} target child path targeted for watch
+ * @param {Object} wh Common watch helpers for this path
+ * @param {String} realpath
+ * @returns {Promise<Function>} closer for the watcher instance.
+ */
+async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+  const parentDir = this.fsw._getWatchedDir(sysPath$2.dirname(dir));
+  const tracked = parentDir.has(sysPath$2.basename(dir));
+  if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR$2, dir, stats);
+  }
+
+  // ensure dir is tracked (harmless if redundant)
+  parentDir.add(sysPath$2.basename(dir));
+  this.fsw._getWatchedDir(dir);
+  let throttler;
+  let closer;
+
+  const oDepth = this.fsw.options.depth;
+  if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+    if (!target) {
+      await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+      if (this.fsw.closed) return;
+    }
+
+    closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+      // if current directory is removed, do nothing
+      if (stats && stats.mtimeMs === 0) return;
+
+      this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+    });
+  }
+  return closer;
+}
+
+/**
+ * Handle added file, directory, or glob pattern.
+ * Delegates call to _handleFile / _handleDir after checks.
+ * @param {String} path to file or ir
+ * @param {Boolean} initialAdd was the file added at watch instantiation?
+ * @param {Object} priorWh depth relative to user-supplied path
+ * @param {Number} depth Child path actually targeted for watch
+ * @param {String=} target Child path actually targeted for watch
+ * @returns {Promise}
+ */
+async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+  const ready = this.fsw._emitReady;
+  if (this.fsw._isIgnored(path) || this.fsw.closed) {
+    ready();
+    return false;
+  }
+
+  const wh = this.fsw._getWatchHelpers(path, depth);
+  if (!wh.hasGlob && priorWh) {
+    wh.hasGlob = priorWh.hasGlob;
+    wh.globFilter = priorWh.globFilter;
+    wh.filterPath = entry => priorWh.filterPath(entry);
+    wh.filterDir = entry => priorWh.filterDir(entry);
+  }
+
+  // evaluate what is at the path we're being asked to watch
+  try {
+    const stats = await statMethods$1[wh.statMethod](wh.watchPath);
+    if (this.fsw.closed) return;
+    if (this.fsw._isIgnored(wh.watchPath, stats)) {
+      ready();
+      return false;
+    }
+
+    const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START$1);
+    let closer;
+    if (stats.isDirectory()) {
+      const absPath = sysPath$2.resolve(path);
+      const targetPath = follow ? await fsrealpath(path) : path;
+      if (this.fsw.closed) return;
+      closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+      if (this.fsw.closed) return;
+      // preserve this symlink's target path
+      if (absPath !== targetPath && targetPath !== undefined) {
+        this.fsw._symlinkPaths.set(absPath, targetPath);
+      }
+    } else if (stats.isSymbolicLink()) {
+      const targetPath = follow ? await fsrealpath(path) : path;
+      if (this.fsw.closed) return;
+      const parent = sysPath$2.dirname(wh.watchPath);
+      this.fsw._getWatchedDir(parent).add(wh.watchPath);
+      this.fsw._emit(EV_ADD$2, wh.watchPath, stats);
+      closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+      if (this.fsw.closed) return;
+
+      // preserve this symlink's target path
+      if (targetPath !== undefined) {
+        this.fsw._symlinkPaths.set(sysPath$2.resolve(path), targetPath);
+      }
+    } else {
+      closer = this._handleFile(wh.watchPath, stats, initialAdd);
+    }
+    ready();
+
+    this.fsw._addPathCloser(path, closer);
+    return false;
+
+  } catch (error) {
+    if (this.fsw._handleError(error)) {
+      ready();
+      return path;
+    }
+  }
+}
+
+}
+
+var nodefsHandler = NodeFsHandler$1;
+
+var fseventsHandler = {exports: {}};
+
+const fs$7 = require$$0$3;
+const sysPath$1 = path$b;
+const { promisify: promisify$1 } = require$$0$4;
+
+let fsevents;
+try {
+  fsevents = undefined;
+} catch (error) {
+  if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
+}
+
+if (fsevents) {
+  // TODO: real check
+  const mtch = process.version.match(/v(\d+)\.(\d+)/);
+  if (mtch && mtch[1] && mtch[2]) {
+    const maj = Number.parseInt(mtch[1], 10);
+    const min = Number.parseInt(mtch[2], 10);
+    if (maj === 8 && min < 16) {
+      fsevents = undefined;
+    }
+  }
+}
+
+const {
+  EV_ADD: EV_ADD$1,
+  EV_CHANGE: EV_CHANGE$1,
+  EV_ADD_DIR: EV_ADD_DIR$1,
+  EV_UNLINK: EV_UNLINK$1,
+  EV_ERROR: EV_ERROR$1,
+  STR_DATA,
+  STR_END: STR_END$1,
+  FSEVENT_CREATED,
+  FSEVENT_MODIFIED,
+  FSEVENT_DELETED,
+  FSEVENT_MOVED,
+  // FSEVENT_CLONED,
+  FSEVENT_UNKNOWN,
+  FSEVENT_TYPE_FILE,
+  FSEVENT_TYPE_DIRECTORY,
+  FSEVENT_TYPE_SYMLINK,
+
+  ROOT_GLOBSTAR,
+  DIR_SUFFIX,
+  DOT_SLASH,
+  FUNCTION_TYPE: FUNCTION_TYPE$1,
+  EMPTY_FN: EMPTY_FN$1,
+  IDENTITY_FN
+} = constants$1;
+
+const Depth = (value) => isNaN(value) ? {} : {depth: value};
+
+const stat$1 = promisify$1(fs$7.stat);
+const lstat = promisify$1(fs$7.lstat);
+const realpath$1 = promisify$1(fs$7.realpath);
+
+const statMethods = { stat: stat$1, lstat };
+
+/**
+ * @typedef {String} Path
+ */
+
+/**
+ * @typedef {Object} FsEventsWatchContainer
+ * @property {Set<Function>} listeners
+ * @property {Function} rawEmitter
+ * @property {{stop: Function}} watcher
+ */
+
+// fsevents instance helper functions
+/**
+ * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
+ * @type {Map<Path,FsEventsWatchContainer>}
+ */
+const FSEventsWatchers = new Map();
+
+// Threshold of duplicate path prefixes at which to start
+// consolidating going forward
+const consolidateThreshhold = 10;
+
+const wrongEventFlags = new Set([
+  69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
+]);
+
+/**
+ * Instantiates the fsevents interface
+ * @param {Path} path path to be watched
+ * @param {Function} callback called when fsevents is bound and ready
+ * @returns {{stop: Function}} new fsevents instance
+ */
+const createFSEventsInstance = (path, callback) => {
+  const stop = fsevents.watch(path, callback);
+  return {stop};
+};
+
+/**
+ * Instantiates the fsevents interface or binds listeners to an existing one covering
+ * the same file tree.
+ * @param {Path} path           - to be watched
+ * @param {Path} realPath       - real path for symlinks
+ * @param {Function} listener   - called when fsevents emits events
+ * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
+ * @returns {Function} closer
+ */
+function setFSEventsListener(path, realPath, listener, rawEmitter) {
+  let watchPath = sysPath$1.extname(realPath) ? sysPath$1.dirname(realPath) : realPath;
+
+  const parentPath = sysPath$1.dirname(watchPath);
+  let cont = FSEventsWatchers.get(watchPath);
+
+  // If we've accumulated a substantial number of paths that
+  // could have been consolidated by watching one directory
+  // above the current one, create a watcher on the parent
+  // path instead, so that we do consolidate going forward.
+  if (couldConsolidate(parentPath)) {
+    watchPath = parentPath;
+  }
+
+  const resolvedPath = sysPath$1.resolve(path);
+  const hasSymlink = resolvedPath !== realPath;
+
+  const filteredListener = (fullPath, flags, info) => {
+    if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
+    if (
+      fullPath === resolvedPath ||
+      !fullPath.indexOf(resolvedPath + sysPath$1.sep)
+    ) listener(fullPath, flags, info);
+  };
+
+  // check if there is already a watcher on a parent path
+  // modifies `watchPath` to the parent path when it finds a match
+  let watchedParent = false;
+  for (const watchedPath of FSEventsWatchers.keys()) {
+    if (realPath.indexOf(sysPath$1.resolve(watchedPath) + sysPath$1.sep) === 0) {
+      watchPath = watchedPath;
+      cont = FSEventsWatchers.get(watchPath);
+      watchedParent = true;
+      break;
+    }
+  }
+
+  if (cont || watchedParent) {
+    cont.listeners.add(filteredListener);
+  } else {
+    cont = {
+      listeners: new Set([filteredListener]),
+      rawEmitter,
+      watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
+        if (!cont.listeners.size) return;
+        const info = fsevents.getInfo(fullPath, flags);
+        cont.listeners.forEach(list => {
+          list(fullPath, flags, info);
+        });
+
+        cont.rawEmitter(info.event, fullPath, info);
+      })
+    };
+    FSEventsWatchers.set(watchPath, cont);
+  }
+
+  // removes this instance's listeners and closes the underlying fsevents
+  // instance if there are no more listeners left
+  return () => {
+    const lst = cont.listeners;
+
+    lst.delete(filteredListener);
+    if (!lst.size) {
+      FSEventsWatchers.delete(watchPath);
+      if (cont.watcher) return cont.watcher.stop().then(() => {
+        cont.rawEmitter = cont.watcher = undefined;
+        Object.freeze(cont);
+      });
+    }
+  };
+}
+
+// Decide whether or not we should start a new higher-level
+// parent watcher
+const couldConsolidate = (path) => {
+  let count = 0;
+  for (const watchPath of FSEventsWatchers.keys()) {
+    if (watchPath.indexOf(path) === 0) {
+      count++;
+      if (count >= consolidateThreshhold) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+// returns boolean indicating whether fsevents can be used
+const canUse = () => fsevents && FSEventsWatchers.size < 128;
+
+// determines subdirectory traversal levels from root to path
+const calcDepth = (path, root) => {
+  let i = 0;
+  while (!path.indexOf(root) && (path = sysPath$1.dirname(path)) !== root) i++;
+  return i;
+};
+
+// returns boolean indicating whether the fsevents' event info has the same type
+// as the one returned by fs.stat
+const sameTypes = (info, stats) => (
+  info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
+  info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
+  info.type === FSEVENT_TYPE_FILE && stats.isFile()
+);
+
+/**
+ * @mixin
+ */
+class FsEventsHandler$1 {
+
+/**
+ * @param {import('../index').FSWatcher} fsw
+ */
+constructor(fsw) {
+  this.fsw = fsw;
+}
+checkIgnored(path, stats) {
+  const ipaths = this.fsw._ignoredPaths;
+  if (this.fsw._isIgnored(path, stats)) {
+    ipaths.add(path);
+    if (stats && stats.isDirectory()) {
+      ipaths.add(path + ROOT_GLOBSTAR);
+    }
+    return true;
+  }
+
+  ipaths.delete(path);
+  ipaths.delete(path + ROOT_GLOBSTAR);
+}
+
+addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+  const event = watchedDir.has(item) ? EV_CHANGE$1 : EV_ADD$1;
+  this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+}
+
+async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+  try {
+    const stats = await stat$1(path);
+    if (this.fsw.closed) return;
+    if (sameTypes(info, stats)) {
+      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    } else {
+      this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    }
+  } catch (error) {
+    if (error.code === 'EACCES') {
+      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    } else {
+      this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    }
+  }
+}
+
+handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+  if (this.fsw.closed || this.checkIgnored(path)) return;
+
+  if (event === EV_UNLINK$1) {
+    const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
+    // suppress unlink events on never before seen files
+    if (isDirectory || watchedDir.has(item)) {
+      this.fsw._remove(parent, item, isDirectory);
+    }
+  } else {
+    if (event === EV_ADD$1) {
+      // track new directories
+      if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);
+
+      if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
+        // push symlinks back to the top of the stack to get handled
+        const curDepth = opts.depth === undefined ?
+          undefined : calcDepth(fullPath, realPath) + 1;
+        return this._addToFsEvents(path, false, true, curDepth);
+      }
+
+      // track new paths
+      // (other than symlinks being followed, which will be tracked soon)
+      this.fsw._getWatchedDir(parent).add(item);
+    }
+    /**
+     * @type {'add'|'addDir'|'unlink'|'unlinkDir'}
+     */
+    const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
+    this.fsw._emit(eventName, path);
+    if (eventName === EV_ADD_DIR$1) this._addToFsEvents(path, false, true);
+  }
+}
+
+/**
+ * Handle symlinks encountered during directory scan
+ * @param {String} watchPath  - file/dir path to be watched with fsevents
+ * @param {String} realPath   - real path (in case of symlinks)
+ * @param {Function} transform  - path transformer
+ * @param {Function} globFilter - path filter in case a glob pattern was provided
+ * @returns {Function} closer for the watcher instance
+*/
+_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
+  if (this.fsw.closed || this.fsw._isIgnored(watchPath)) return;
+  const opts = this.fsw.options;
+  const watchCallback = async (fullPath, flags, info) => {
+    if (this.fsw.closed) return;
+    if (
+      opts.depth !== undefined &&
+      calcDepth(fullPath, realPath) > opts.depth
+    ) return;
+    const path = transform(sysPath$1.join(
+      watchPath, sysPath$1.relative(watchPath, fullPath)
+    ));
+    if (globFilter && !globFilter(path)) return;
+    // ensure directories are tracked
+    const parent = sysPath$1.dirname(path);
+    const item = sysPath$1.basename(path);
+    const watchedDir = this.fsw._getWatchedDir(
+      info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
+    );
+
+    // correct for wrong events emitted
+    if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
+      if (typeof opts.ignored === FUNCTION_TYPE$1) {
+        let stats;
+        try {
+          stats = await stat$1(path);
+        } catch (error) {}
+        if (this.fsw.closed) return;
+        if (this.checkIgnored(path, stats)) return;
+        if (sameTypes(info, stats)) {
+          this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+        } else {
+          this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+        }
+      } else {
+        this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+      }
+    } else {
+      switch (info.event) {
+      case FSEVENT_CREATED:
+      case FSEVENT_MODIFIED:
+        return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+      case FSEVENT_DELETED:
+      case FSEVENT_MOVED:
+        return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+      }
+    }
+  };
+
+  const closer = setFSEventsListener(
+    watchPath,
+    realPath,
+    watchCallback,
+    this.fsw._emitRaw
+  );
+
+  this.fsw._emitReady();
+  return closer;
+}
+
+/**
+ * Handle symlinks encountered during directory scan
+ * @param {String} linkPath path to symlink
+ * @param {String} fullPath absolute path to the symlink
+ * @param {Function} transform pre-existing path transformer
+ * @param {Number} curDepth level of subdirectories traversed to where symlink is
+ * @returns {Promise<void>}
+ */
+async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
+  // don't follow the same symlink more than once
+  if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;
+
+  this.fsw._symlinkPaths.set(fullPath, true);
+  this.fsw._incrReadyCount();
+
+  try {
+    const linkTarget = await realpath$1(linkPath);
+    if (this.fsw.closed) return;
+    if (this.fsw._isIgnored(linkTarget)) {
+      return this.fsw._emitReady();
+    }
+
+    this.fsw._incrReadyCount();
+
+    // add the linkTarget for watching with a wrapper for transform
+    // that causes emitted paths to incorporate the link's path
+    this._addToFsEvents(linkTarget || linkPath, (path) => {
+      let aliasedPath = linkPath;
+      if (linkTarget && linkTarget !== DOT_SLASH) {
+        aliasedPath = path.replace(linkTarget, linkPath);
+      } else if (path !== DOT_SLASH) {
+        aliasedPath = sysPath$1.join(linkPath, path);
+      }
+      return transform(aliasedPath);
+    }, false, curDepth);
+  } catch(error) {
+    if (this.fsw._handleError(error)) {
+      return this.fsw._emitReady();
+    }
+  }
+}
+
+/**
+ *
+ * @param {Path} newPath
+ * @param {fs.Stats} stats
+ */
+emitAdd(newPath, stats, processPath, opts, forceAdd) {
+  const pp = processPath(newPath);
+  const isDir = stats.isDirectory();
+  const dirObj = this.fsw._getWatchedDir(sysPath$1.dirname(pp));
+  const base = sysPath$1.basename(pp);
+
+  // ensure empty dirs get tracked
+  if (isDir) this.fsw._getWatchedDir(pp);
+  if (dirObj.has(base)) return;
+  dirObj.add(base);
+
+  if (!opts.ignoreInitial || forceAdd === true) {
+    this.fsw._emit(isDir ? EV_ADD_DIR$1 : EV_ADD$1, pp, stats);
+  }
+}
+
+initWatch(realPath, path, wh, processPath) {
+  if (this.fsw.closed) return;
+  const closer = this._watchWithFsEvents(
+    wh.watchPath,
+    sysPath$1.resolve(realPath || wh.watchPath),
+    processPath,
+    wh.globFilter
+  );
+  this.fsw._addPathCloser(path, closer);
+}
+
+/**
+ * Handle added path with fsevents
+ * @param {String} path file/dir path or glob pattern
+ * @param {Function|Boolean=} transform converts working path to what the user expects
+ * @param {Boolean=} forceAdd ensure add is emitted
+ * @param {Number=} priorDepth Level of subdirectories already traversed.
+ * @returns {Promise<void>}
+ */
+async _addToFsEvents(path, transform, forceAdd, priorDepth) {
+  if (this.fsw.closed) {
+    return;
+  }
+  const opts = this.fsw.options;
+  const processPath = typeof transform === FUNCTION_TYPE$1 ? transform : IDENTITY_FN;
+
+  const wh = this.fsw._getWatchHelpers(path);
+
+  // evaluate what is at the path we're being asked to watch
+  try {
+    const stats = await statMethods[wh.statMethod](wh.watchPath);
+    if (this.fsw.closed) return;
+    if (this.fsw._isIgnored(wh.watchPath, stats)) {
+      throw null;
+    }
+    if (stats.isDirectory()) {
+      // emit addDir unless this is a glob parent
+      if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
+
+      // don't recurse further if it would exceed depth setting
+      if (priorDepth && priorDepth > opts.depth) return;
+
+      // scan the contents of the dir
+      this.fsw._readdirp(wh.watchPath, {
+        fileFilter: entry => wh.filterPath(entry),
+        directoryFilter: entry => wh.filterDir(entry),
+        ...Depth(opts.depth - (priorDepth || 0))
+      }).on(STR_DATA, (entry) => {
+        // need to check filterPath on dirs b/c filterDir is less restrictive
+        if (this.fsw.closed) {
+          return;
+        }
+        if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
+
+        const joinedPath = sysPath$1.join(wh.watchPath, entry.path);
+        const {fullPath} = entry;
+
+        if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
+          // preserve the current depth here since it can't be derived from
+          // real paths past the symlink
+          const curDepth = opts.depth === undefined ?
+            undefined : calcDepth(joinedPath, sysPath$1.resolve(wh.watchPath)) + 1;
+
+          this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
+        } else {
+          this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
+        }
+      }).on(EV_ERROR$1, EMPTY_FN$1).on(STR_END$1, () => {
+        this.fsw._emitReady();
+      });
+    } else {
+      this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
+      this.fsw._emitReady();
+    }
+  } catch (error) {
+    if (!error || this.fsw._handleError(error)) {
+      // TODO: Strange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
+      this.fsw._emitReady();
+      this.fsw._emitReady();
+    }
+  }
+
+  if (opts.persistent && forceAdd !== true) {
+    if (typeof transform === FUNCTION_TYPE$1) {
+      // realpath has already been resolved
+      this.initWatch(undefined, path, wh, processPath);
+    } else {
+      let realPath;
+      try {
+        realPath = await realpath$1(wh.watchPath);
+      } catch (e) {}
+      this.initWatch(realPath, path, wh, processPath);
+    }
+  }
+}
+
+}
+
+fseventsHandler.exports = FsEventsHandler$1;
+fseventsHandler.exports.canUse = canUse;
+
+const { EventEmitter } = require$$0$5;
+const fs$6 = require$$0$3;
+const sysPath = path$b;
+const { promisify } = require$$0$4;
+const readdirp = readdirp_1;
+const anymatch = anymatch$2.exports.default;
+const globParent = globParent$1;
+const isGlob = isGlob$2;
+const braces = braces_1;
+const normalizePath = normalizePath$2;
+
+const NodeFsHandler = nodefsHandler;
+const FsEventsHandler = fseventsHandler.exports;
+const {
+  EV_ALL,
+  EV_READY,
+  EV_ADD,
+  EV_CHANGE,
+  EV_UNLINK,
+  EV_ADD_DIR,
+  EV_UNLINK_DIR,
+  EV_RAW,
+  EV_ERROR,
+
+  STR_CLOSE,
+  STR_END,
+
+  BACK_SLASH_RE,
+  DOUBLE_SLASH_RE,
+  SLASH_OR_BACK_SLASH_RE,
+  DOT_RE,
+  REPLACER_RE,
+
+  SLASH: SLASH$1,
+  SLASH_SLASH,
+  BRACE_START,
+  BANG,
+  ONE_DOT,
+  TWO_DOTS,
+  GLOBSTAR: GLOBSTAR$1,
+  SLASH_GLOBSTAR,
+  ANYMATCH_OPTS,
+  STRING_TYPE,
+  FUNCTION_TYPE,
+  EMPTY_STR,
+  EMPTY_FN,
+
+  isWindows: isWindows$2,
+  isMacos,
+  isIBMi
+} = constants$1;
+
+const stat = promisify(fs$6.stat);
+const readdir = promisify(fs$6.readdir);
+
+/**
+ * @typedef {String} Path
+ * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
+ * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
+ */
+
+/**
+ *
+ * @typedef {Object} WatchHelpers
+ * @property {Boolean} followSymlinks
+ * @property {'stat'|'lstat'} statMethod
+ * @property {Path} path
+ * @property {Path} watchPath
+ * @property {Function} entryPath
+ * @property {Boolean} hasGlob
+ * @property {Object} globFilter
+ * @property {Function} filterPath
+ * @property {Function} filterDir
+ */
+
+const arrify = (value = []) => Array.isArray(value) ? value : [value];
+const flatten$1 = (list, result = []) => {
+  list.forEach(item => {
+    if (Array.isArray(item)) {
+      flatten$1(item, result);
+    } else {
+      result.push(item);
+    }
+  });
+  return result;
+};
+
+const unifyPaths = (paths_) => {
+  /**
+   * @type {Array<String>}
+   */
+  const paths = flatten$1(arrify(paths_));
+  if (!paths.every(p => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+
+// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+//     because "//StoragePC/DrivePool/Movies" is a valid network path
+const toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH$1);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  while (str.match(DOUBLE_SLASH_RE)) {
+    str = str.replace(DOUBLE_SLASH_RE, SLASH$1);
+  }
+  if (prepend) {
+    str = SLASH$1 + str;
+  }
+  return str;
+};
+
+// Our version of upath.normalize
+// TODO: this is not equal to path-normalize module - investigate why
+const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+
+const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
+  if (typeof path !== STRING_TYPE) return path;
+  return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+};
+
+const getAbsolutePath = (path, cwd) => {
+  if (sysPath.isAbsolute(path)) {
+    return path;
+  }
+  if (path.startsWith(BANG)) {
+    return BANG + sysPath.join(cwd, path.slice(1));
+  }
+  return sysPath.join(cwd, path);
+};
+
+const undef = (opts, key) => opts[key] === undefined;
+
+/**
+ * Directory entry.
+ * @property {Path} path
+ * @property {Set<Path>} items
+ */
+class DirEntry {
+  /**
+   * @param {Path} dir
+   * @param {Function} removeWatcher
+   */
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    /** @type {Set<Path>} */
+    this.items = new Set();
+  }
+
+  add(item) {
+    const {items} = this;
+    if (!items) return;
+    if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+  }
+
+  async remove(item) {
+    const {items} = this;
+    if (!items) return;
+    items.delete(item);
+    if (items.size > 0) return;
+
+    const dir = this.path;
+    try {
+      await readdir(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+      }
+    }
+  }
+
+  has(item) {
+    const {items} = this;
+    if (!items) return;
+    return items.has(item);
+  }
+
+  /**
+   * @returns {Array<String>}
+   */
+  getChildren() {
+    const {items} = this;
+    if (!items) return;
+    return [...items.values()];
+  }
+
+  dispose() {
+    this.items.clear();
+    delete this.path;
+    delete this._removeWatcher;
+    delete this.items;
+    Object.freeze(this);
+  }
+}
+
+const STAT_METHOD_F = 'stat';
+const STAT_METHOD_L = 'lstat';
+class WatchHelper {
+  constructor(path, watchPath, follow, fsw) {
+    this.fsw = fsw;
+    this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
+    this.watchPath = watchPath;
+    this.fullWatchPath = sysPath.resolve(watchPath);
+    this.hasGlob = watchPath !== path;
+    /** @type {object|boolean} */
+    if (path === EMPTY_STR) this.hasGlob = false;
+    this.globSymlink = this.hasGlob && follow ? undefined : false;
+    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
+    this.dirParts = this.getDirParts(path);
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1) parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+
+  checkGlobSymlink(entry) {
+    // only need to resolve once
+    // first entry should always have entry.parentDir === EMPTY_STR
+    if (this.globSymlink === undefined) {
+      this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
+        false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
+    }
+
+    if (this.globSymlink) {
+      return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
+    }
+
+    return entry.fullPath;
+  }
+
+  entryPath(entry) {
+    return sysPath.join(this.watchPath,
+      sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
+    );
+  }
+
+  filterPath(entry) {
+    const {stats} = entry;
+    if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ?
+      this.globFilter(resolvedPath) : true;
+    return matchesGlob &&
+      this.fsw._isntIgnored(resolvedPath, stats) &&
+      this.fsw._hasReadPermissions(stats);
+  }
+
+  getDirParts(path) {
+    if (!this.hasGlob) return [];
+    const parts = [];
+    const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
+    expandedPath.forEach((path) => {
+      parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+    });
+    return parts;
+  }
+
+  filterDir(entry) {
+    if (this.hasGlob) {
+      const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
+      let globstar = false;
+      this.unmatchedGlob = !this.dirParts.some((parts) => {
+        return parts.every((part, i) => {
+          if (part === GLOBSTAR$1) globstar = true;
+          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
+        });
+      });
+    }
+    return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+}
+
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+class FSWatcher extends EventEmitter {
+// Not indenting methods for history sake; for now.
+constructor(_opts) {
+  super();
+
+  const opts = {};
+  if (_opts) Object.assign(opts, _opts); // for frozen objects
+
+  /** @type {Map<String, DirEntry>} */
+  this._watched = new Map();
+  /** @type {Map<String, Array>} */
+  this._closers = new Map();
+  /** @type {Set<String>} */
+  this._ignoredPaths = new Set();
+
+  /** @type {Map<ThrottleType, Map>} */
+  this._throttled = new Map();
+
+  /** @type {Map<Path, String|Boolean>} */
+  this._symlinkPaths = new Map();
+
+  this._streams = new Set();
+  this.closed = false;
+
+  // Set up default options.
+  if (undef(opts, 'persistent')) opts.persistent = true;
+  if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
+  if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
+  if (undef(opts, 'interval')) opts.interval = 100;
+  if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
+  if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
+  opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
+
+  // Enable fsevents on OS X when polling isn't explicitly enabled.
+  if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
+
+  // If we can't use fsevents, ensure the options reflect it's disabled.
+  const canUseFsEvents = FsEventsHandler.canUse();
+  if (!canUseFsEvents) opts.useFsEvents = false;
+
+  // Use polling on Mac if not using fsevents.
+  // Other platforms use non-polling fs_watch.
+  if (undef(opts, 'usePolling') && !opts.useFsEvents) {
+    opts.usePolling = isMacos;
+  }
+
+  // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+  if(isIBMi) {
+    opts.usePolling = true;
+  }
+
+  // Global override (useful for end-developers that need to force polling for all
+  // instances of chokidar, regardless of usage/dependency depth)
+  const envPoll = process.env.CHOKIDAR_USEPOLLING;
+  if (envPoll !== undefined) {
+    const envLower = envPoll.toLowerCase();
+
+    if (envLower === 'false' || envLower === '0') {
+      opts.usePolling = false;
+    } else if (envLower === 'true' || envLower === '1') {
+      opts.usePolling = true;
+    } else {
+      opts.usePolling = !!envLower;
+    }
+  }
+  const envInterval = process.env.CHOKIDAR_INTERVAL;
+  if (envInterval) {
+    opts.interval = Number.parseInt(envInterval, 10);
+  }
+
+  // Editor atomic write normalization enabled by default with fs.watch
+  if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
+  if (opts.atomic) this._pendingUnlinks = new Map();
+
+  if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;
+
+  if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
+  if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
+  const awf = opts.awaitWriteFinish;
+  if (awf) {
+    if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
+    if (!awf.pollInterval) awf.pollInterval = 100;
+    this._pendingWrites = new Map();
+  }
+  if (opts.ignored) opts.ignored = arrify(opts.ignored);
+
+  let readyCalls = 0;
+  this._emitReady = () => {
+    readyCalls++;
+    if (readyCalls >= this._readyCount) {
+      this._emitReady = EMPTY_FN;
+      this._readyEmitted = true;
+      // use process.nextTick to allow time for listener to be bound
+      process.nextTick(() => this.emit(EV_READY));
+    }
+  };
+  this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
+  this._readyEmitted = false;
+  this.options = opts;
+
+  // Initialize with proper watcher.
+  if (opts.useFsEvents) {
+    this._fsEventsHandler = new FsEventsHandler(this);
+  } else {
+    this._nodeFsHandler = new NodeFsHandler(this);
+  }
+
+  // You’re frozen when your heart’s not open.
+  Object.freeze(opts);
+}
+
+// Public methods
+
+/**
+ * Adds paths to be watched on an existing FSWatcher instance
+ * @param {Path|Array<Path>} paths_
+ * @param {String=} _origAdd private; for handling non-existent paths to be watched
+ * @param {Boolean=} _internal private; indicates a non-user add
+ * @returns {FSWatcher} for chaining
+ */
+add(paths_, _origAdd, _internal) {
+  const {cwd, disableGlobbing} = this.options;
+  this.closed = false;
+  let paths = unifyPaths(paths_);
+  if (cwd) {
+    paths = paths.map((path) => {
+      const absPath = getAbsolutePath(path, cwd);
+
+      // Check `path` instead of `absPath` because the cwd portion can't be a glob
+      if (disableGlobbing || !isGlob(path)) {
+        return absPath;
+      }
+      return normalizePath(absPath);
+    });
+  }
+
+  // set aside negated glob strings
+  paths = paths.filter((path) => {
+    if (path.startsWith(BANG)) {
+      this._ignoredPaths.add(path.slice(1));
+      return false;
+    }
+
+    // if a path is being added that was previously ignored, stop ignoring it
+    this._ignoredPaths.delete(path);
+    this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
+
+    // reset the cached userIgnored anymatch fn
+    // to make ignoredPaths changes effective
+    this._userIgnored = undefined;
+
+    return true;
+  });
+
+  if (this.options.useFsEvents && this._fsEventsHandler) {
+    if (!this._readyCount) this._readyCount = paths.length;
+    if (this.options.persistent) this._readyCount *= 2;
+    paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
+  } else {
+    if (!this._readyCount) this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(
+      paths.map(async path => {
+        const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
+        if (res) this._emitReady();
+        return res;
+      })
+    ).then(results => {
+      if (this.closed) return;
+      results.filter(item => item).forEach(item => {
+        this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+      });
+    });
+  }
+
+  return this;
+}
+
+/**
+ * Close watchers or start ignoring events from specified paths.
+ * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
+ * @returns {FSWatcher} for chaining
+*/
+unwatch(paths_) {
+  if (this.closed) return this;
+  const paths = unifyPaths(paths_);
+  const {cwd} = this.options;
+
+  paths.forEach((path) => {
+    // convert to absolute path unless relative path already matches
+    if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+      if (cwd) path = sysPath.join(cwd, path);
+      path = sysPath.resolve(path);
+    }
+
+    this._closePath(path);
+
+    this._ignoredPaths.add(path);
+    if (this._watched.has(path)) {
+      this._ignoredPaths.add(path + SLASH_GLOBSTAR);
+    }
+
+    // reset the cached userIgnored anymatch fn
+    // to make ignoredPaths changes effective
+    this._userIgnored = undefined;
+  });
+
+  return this;
+}
+
+/**
+ * Close watchers and remove all listeners from watched paths.
+ * @returns {Promise<void>}.
+*/
+close() {
+  if (this.closed) return this._closePromise;
+  this.closed = true;
+
+  // Memory management.
+  this.removeAllListeners();
+  const closers = [];
+  this._closers.forEach(closerList => closerList.forEach(closer => {
+    const promise = closer();
+    if (promise instanceof Promise) closers.push(promise);
+  }));
+  this._streams.forEach(stream => stream.destroy());
+  this._userIgnored = undefined;
+  this._readyCount = 0;
+  this._readyEmitted = false;
+  this._watched.forEach(dirent => dirent.dispose());
+  ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
+    this[`_${key}`].clear();
+  });
+
+  this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
+  return this._closePromise;
+}
+
+/**
+ * Expose list of watched paths
+ * @returns {Object} for chaining
+*/
+getWatched() {
+  const watchList = {};
+  this._watched.forEach((entry, dir) => {
+    const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+    watchList[key || ONE_DOT] = entry.getChildren().sort();
+  });
+  return watchList;
+}
+
+emitWithAll(event, args) {
+  this.emit(...args);
+  if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
+}
+
+// Common helpers
+// --------------
+
+/**
+ * Normalize and emit events.
+ * Calling _emit DOES NOT MEAN emit() would be called!
+ * @param {EventName} event Type of event
+ * @param {Path} path File or directory path
+ * @param {*=} val1 arguments to be passed with event
+ * @param {*=} val2
+ * @param {*=} val3
+ * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+ */
+async _emit(event, path, val1, val2, val3) {
+  if (this.closed) return;
+
+  const opts = this.options;
+  if (isWindows$2) path = sysPath.normalize(path);
+  if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+  /** @type Array<any> */
+  const args = [event, path];
+  if (val3 !== undefined) args.push(val1, val2, val3);
+  else if (val2 !== undefined) args.push(val1, val2);
+  else if (val1 !== undefined) args.push(val1);
+
+  const awf = opts.awaitWriteFinish;
+  let pw;
+  if (awf && (pw = this._pendingWrites.get(path))) {
+    pw.lastChange = new Date();
+    return this;
+  }
+
+  if (opts.atomic) {
+    if (event === EV_UNLINK) {
+      this._pendingUnlinks.set(path, args);
+      setTimeout(() => {
+        this._pendingUnlinks.forEach((entry, path) => {
+          this.emit(...entry);
+          this.emit(EV_ALL, ...entry);
+          this._pendingUnlinks.delete(path);
+        });
+      }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+      return this;
+    }
+    if (event === EV_ADD && this._pendingUnlinks.has(path)) {
+      event = args[0] = EV_CHANGE;
+      this._pendingUnlinks.delete(path);
+    }
+  }
+
+  if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
+    const awfEmit = (err, stats) => {
+      if (err) {
+        event = args[0] = EV_ERROR;
+        args[1] = err;
+        this.emitWithAll(event, args);
+      } else if (stats) {
+        // if stats doesn't exist the file must have been deleted
+        if (args.length > 2) {
+          args[2] = stats;
+        } else {
+          args.push(stats);
+        }
+        this.emitWithAll(event, args);
+      }
+    };
+
+    this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+    return this;
+  }
+
+  if (event === EV_CHANGE) {
+    const isThrottled = !this._throttle(EV_CHANGE, path, 50);
+    if (isThrottled) return this;
+  }
+
+  if (opts.alwaysStat && val1 === undefined &&
+    (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
+  ) {
+    const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+    let stats;
+    try {
+      stats = await stat(fullPath);
+    } catch (err) {}
+    // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+    if (!stats || this.closed) return;
+    args.push(stats);
+  }
+  this.emitWithAll(event, args);
+
+  return this;
+}
+
+/**
+ * Common handler for errors
+ * @param {Error} error
+ * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+ */
+_handleError(error) {
+  const code = error && error.code;
+  if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
+    (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
+  ) {
+    this.emit(EV_ERROR, error);
+  }
+  return error || this.closed;
+}
+
+/**
+ * Helper utility for throttling
+ * @param {ThrottleType} actionType type being throttled
+ * @param {Path} path being acted upon
+ * @param {Number} timeout duration of time to suppress duplicate actions
+ * @returns {Object|false} tracking object or false if action should be suppressed
+ */
+_throttle(actionType, path, timeout) {
+  if (!this._throttled.has(actionType)) {
+    this._throttled.set(actionType, new Map());
+  }
+
+  /** @type {Map<Path, Object>} */
+  const action = this._throttled.get(actionType);
+  /** @type {Object} */
+  const actionPath = action.get(path);
+
+  if (actionPath) {
+    actionPath.count++;
+    return false;
+  }
+
+  let timeoutObject;
+  const clear = () => {
+    const item = action.get(path);
+    const count = item ? item.count : 0;
+    action.delete(path);
+    clearTimeout(timeoutObject);
+    if (item) clearTimeout(item.timeoutObject);
+    return count;
+  };
+  timeoutObject = setTimeout(clear, timeout);
+  const thr = {timeoutObject, clear, count: 0};
+  action.set(path, thr);
+  return thr;
+}
+
+_incrReadyCount() {
+  return this._readyCount++;
+}
+
+/**
+ * Awaits write operation to finish.
+ * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+ * @param {Path} path being acted upon
+ * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+ * @param {EventName} event
+ * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
+ */
+_awaitWriteFinish(path, threshold, event, awfEmit) {
+  let timeoutHandler;
+
+  let fullPath = path;
+  if (this.options.cwd && !sysPath.isAbsolute(path)) {
+    fullPath = sysPath.join(this.options.cwd, path);
+  }
+
+  const now = new Date();
+
+  const awaitWriteFinish = (prevStat) => {
+    fs$6.stat(fullPath, (err, curStat) => {
+      if (err || !this._pendingWrites.has(path)) {
+        if (err && err.code !== 'ENOENT') awfEmit(err);
+        return;
+      }
+
+      const now = Number(new Date());
+
+      if (prevStat && curStat.size !== prevStat.size) {
+        this._pendingWrites.get(path).lastChange = now;
+      }
+      const pw = this._pendingWrites.get(path);
+      const df = now - pw.lastChange;
+
+      if (df >= threshold) {
+        this._pendingWrites.delete(path);
+        awfEmit(undefined, curStat);
+      } else {
+        timeoutHandler = setTimeout(
+          awaitWriteFinish,
+          this.options.awaitWriteFinish.pollInterval,
+          curStat
+        );
+      }
+    });
+  };
+
+  if (!this._pendingWrites.has(path)) {
+    this._pendingWrites.set(path, {
+      lastChange: now,
+      cancelWait: () => {
+        this._pendingWrites.delete(path);
+        clearTimeout(timeoutHandler);
+        return event;
+      }
+    });
+    timeoutHandler = setTimeout(
+      awaitWriteFinish,
+      this.options.awaitWriteFinish.pollInterval
+    );
+  }
+}
+
+_getGlobIgnored() {
+  return [...this._ignoredPaths.values()];
+}
+
+/**
+ * Determines whether user has asked to ignore this path.
+ * @param {Path} path filepath or dir
+ * @param {fs.Stats=} stats result of fs.stat
+ * @returns {Boolean}
+ */
+_isIgnored(path, stats) {
+  if (this.options.atomic && DOT_RE.test(path)) return true;
+  if (!this._userIgnored) {
+    const {cwd} = this.options;
+    const ign = this.options.ignored;
+
+    const ignored = ign && ign.map(normalizeIgnored(cwd));
+    const paths = arrify(ignored)
+      .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
+      .map((path) => path + SLASH_GLOBSTAR);
+    const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
+    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
+  }
+
+  return this._userIgnored([path, stats]);
+}
+
+_isntIgnored(path, stat) {
+  return !this._isIgnored(path, stat);
+}
+
+/**
+ * Provides a set of common helpers and properties relating to symlink and glob handling.
+ * @param {Path} path file, directory, or glob pattern being watched
+ * @param {Number=} depth at any depth > 0, this isn't a glob
+ * @returns {WatchHelper} object containing helpers for this path
+ */
+_getWatchHelpers(path, depth) {
+  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
+  const follow = this.options.followSymlinks;
+
+  return new WatchHelper(path, watchPath, follow, this);
+}
+
+// Directory helpers
+// -----------------
+
+/**
+ * Provides directory tracking objects
+ * @param {String} directory path of the directory
+ * @returns {DirEntry} the directory's tracking object
+ */
+_getWatchedDir(directory) {
+  if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
+  const dir = sysPath.resolve(directory);
+  if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+  return this._watched.get(dir);
+}
+
+// File helpers
+// ------------
+
+/**
+ * Check for read permissions.
+ * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
+ * @param {fs.Stats} stats - object, result of fs_stat
+ * @returns {Boolean} indicates whether the file can be read
+*/
+_hasReadPermissions(stats) {
+  if (this.options.ignorePermissionErrors) return true;
+
+  // stats.mode may be bigint
+  const md = stats && Number.parseInt(stats.mode, 10);
+  const st = md & 0o777;
+  const it = Number.parseInt(st.toString(8)[0], 10);
+  return Boolean(4 & it);
+}
+
+/**
+ * Handles emitting unlink events for
+ * files and directories, and via recursion, for
+ * files and directories within directories that are unlinked
+ * @param {String} directory within which the following item is located
+ * @param {String} item      base path of item/directory
+ * @returns {void}
+*/
+_remove(directory, item, isDirectory) {
+  // if what is being deleted is a directory, get that directory's paths
+  // for recursive deleting and cleaning of watched object
+  // if it is not a directory, nestedDirectoryChildren will be empty array
+  const path = sysPath.join(directory, item);
+  const fullPath = sysPath.resolve(path);
+  isDirectory = isDirectory != null
+    ? isDirectory
+    : this._watched.has(path) || this._watched.has(fullPath);
+
+  // prevent duplicate handling in case of arriving here nearly simultaneously
+  // via multiple paths (such as _handleFile and _handleDir)
+  if (!this._throttle('remove', path, 100)) return;
+
+  // if the only watched file is removed, watch for its return
+  if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
+    this.add(directory, item, true);
+  }
+
+  // This will create a new entry in the watched object in either case
+  // so we got to do the directory check beforehand
+  const wp = this._getWatchedDir(path);
+  const nestedDirectoryChildren = wp.getChildren();
+
+  // Recursively remove children directories / files.
+  nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
+
+  // Check if item was on the watched list and remove it
+  const parent = this._getWatchedDir(directory);
+  const wasTracked = parent.has(item);
+  parent.remove(item);
+
+  // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+  // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+  // but never removed from the map in case the path was deleted.
+  // This leads to an incorrect state if the path was recreated:
+  // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+  if (this._symlinkPaths.has(fullPath)) {
+    this._symlinkPaths.delete(fullPath);
+  }
+
+  // If we wait for this file to be fully written, cancel the wait.
+  let relPath = path;
+  if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
+  if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+    const event = this._pendingWrites.get(relPath).cancelWait();
+    if (event === EV_ADD) return;
+  }
+
+  // The Entry will either be a directory that just got removed
+  // or a bogus entry to a file, in either case we have to remove it
+  this._watched.delete(path);
+  this._watched.delete(fullPath);
+  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
+  if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+
+  // Avoid conflicts if we later create another file with the same name
+  if (!this.options.useFsEvents) {
+    this._closePath(path);
+  }
+}
+
+/**
+ * Closes all watchers for a path
+ * @param {Path} path
+ */
+_closePath(path) {
+  this._closeFile(path);
+  const dir = sysPath.dirname(path);
+  this._getWatchedDir(dir).remove(sysPath.basename(path));
+}
+
+/**
+ * Closes only file-specific watchers
+ * @param {Path} path
+ */
+_closeFile(path) {
+  const closers = this._closers.get(path);
+  if (!closers) return;
+  closers.forEach(closer => closer());
+  this._closers.delete(path);
+}
+
+/**
+ *
+ * @param {Path} path
+ * @param {Function} closer
+ */
+_addPathCloser(path, closer) {
+  if (!closer) return;
+  let list = this._closers.get(path);
+  if (!list) {
+    list = [];
+    this._closers.set(path, list);
+  }
+  list.push(closer);
+}
+
+_readdirp(root, opts) {
+  if (this.closed) return;
+  const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
+  let stream = readdirp(root, options);
+  this._streams.add(stream);
+  stream.once(STR_CLOSE, () => {
+    stream = undefined;
+  });
+  stream.once(STR_END, () => {
+    if (stream) {
+      this._streams.delete(stream);
+      stream = undefined;
+    }
+  });
+  return stream;
+}
+
+}
+
+// Export FSWatcher class
+chokidar.FSWatcher = FSWatcher;
+
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param {String|Array<String>} paths file/directory paths and/or globs
+ * @param {Object=} options chokidar opts
+ * @returns an instance of FSWatcher for chaining.
+ */
+const watch = (paths, options) => {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+};
+
+chokidar.watch = watch;
+
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ *
+ * @typedef Statistics
+ * @property {number} fatal Fatal errors (`fatal: true`)
+ * @property {number} warn warning errors (`fatal: false`)
+ * @property {number} info informational messages (`fatal: null|undefined`)
+ * @property {number} nonfatal warning + info
+ * @property {number} total nonfatal + fatal
+ */
+
+/**
+ * Get stats for a file, list of files, or list of messages.
+ *
+ * @param {Array.<VFile|VFileMessage>|VFile|VFileMessage} [value]
+ * @returns {Statistics}
+ */
+function statistics(value) {
+  var result = {true: 0, false: 0, null: 0};
+
+  if (value) {
+    if (Array.isArray(value)) {
+      list(value);
+    } else {
+      one(value);
+    }
+  }
+
+  return {
+    fatal: result.true,
+    nonfatal: result.false + result.null,
+    warn: result.false,
+    info: result.null,
+    total: result.true + result.false + result.null
+  }
+
+  /**
+   * @param {Array.<VFile|VFileMessage>} value
+   * @returns {void}
+   */
+  function list(value) {
+    var index = -1;
+
+    while (++index < value.length) {
+      one(value[index]);
+    }
+  }
+
+  /**
+   * @param {VFile|VFileMessage} value
+   * @returns {void}
+   */
+  function one(value) {
+    if ('messages' in value) return list(value.messages)
+
+    result[
+      value.fatal === undefined || value.fatal === null
+        ? null
+        : Boolean(value.fatal)
+    ]++;
+  }
+}
+
+/**
+ * @typedef {(error?: Error|null|undefined, ...output: any[]) => void} Callback
+ * @typedef {(...input: any[]) => any} Middleware
+ *
+ * @typedef {(...input: any[]) => void} Run Call all middleware.
+ * @typedef {(fn: Middleware) => Pipeline} Use Add `fn` (middleware) to the list.
+ * @typedef {{run: Run, use: Use}} Pipeline
+ */
+
+/**
+ * Create new middleware.
+ *
+ * @returns {Pipeline}
+ */
+function trough() {
+  /** @type {Middleware[]} */
+  const fns = [];
+  /** @type {Pipeline} */
+  const pipeline = {run, use};
+
+  return pipeline
+
+  /** @type {Run} */
+  function run(...values) {
+    let middlewareIndex = -1;
+    /** @type {Callback} */
+    const callback = values.pop();
+
+    if (typeof callback !== 'function') {
+      throw new TypeError('Expected function as last argument, not ' + callback)
+    }
+
+    next(null, ...values);
+
+    /**
+     * Run the next `fn`, or we’re done.
+     *
+     * @param {Error|null|undefined} error
+     * @param {any[]} output
+     */
+    function next(error, ...output) {
+      const fn = fns[++middlewareIndex];
+      let index = -1;
+
+      if (error) {
+        callback(error);
+        return
+      }
+
+      // Copy non-nullish input into values.
+      while (++index < values.length) {
+        if (output[index] === null || output[index] === undefined) {
+          output[index] = values[index];
+        }
+      }
+
+      // Save the newly created `output` for the next call.
+      values = output;
+
+      // Next or done.
+      if (fn) {
+        wrap(fn, next)(...output);
+      } else {
+        callback(null, ...output);
+      }
+    }
+  }
+
+  /** @type {Use} */
+  function use(middelware) {
+    if (typeof middelware !== 'function') {
+      throw new TypeError(
+        'Expected `middelware` to be a function, not ' + middelware
+      )
+    }
+
+    fns.push(middelware);
+    return pipeline
+  }
+}
+
+/**
+ * Wrap `middleware`.
+ * Can be sync or async; return a promise, receive a callback, or return new
+ * values and errors.
+ *
+ * @param {Middleware} middleware
+ * @param {Callback} callback
+ */
+function wrap(middleware, callback) {
+  /** @type {boolean} */
+  let called;
+
+  return wrapped
+
+  /**
+   * Call `middleware`.
+   * @param {any[]} parameters
+   * @returns {void}
+   */
+  function wrapped(...parameters) {
+    const fnExpectsCallback = middleware.length > parameters.length;
+    /** @type {any} */
+    let result;
+
+    if (fnExpectsCallback) {
+      parameters.push(done);
+    }
+
+    try {
+      result = middleware(...parameters);
+    } catch (error) {
+      /** @type {Error} */
+      const exception = error;
+
+      // Well, this is quite the pickle.
+      // `middleware` received a callback and called it synchronously, but that
+      // threw an error.
+      // The only thing left to do is to throw the thing instead.
+      if (fnExpectsCallback && called) {
+        throw exception
+      }
+
+      return done(exception)
+    }
+
+    if (!fnExpectsCallback) {
+      if (result instanceof Promise) {
+        result.then(then, done);
+      } else if (result instanceof Error) {
+        done(result);
+      } else {
+        then(result);
+      }
+    }
+  }
+
+  /**
+   * Call `callback`, only once.
+   * @type {Callback}
+   */
+  function done(error, ...output) {
+    if (!called) {
+      called = true;
+      callback(error, ...output);
+    }
+  }
+
+  /**
+   * Call `done` with one value.
+   *
+   * @param {any} [value]
+   */
+  function then(value) {
+    done(null, value);
+  }
+}
+
+/*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */
+function isNothing(subject) {
+  return (typeof subject === 'undefined') || (subject === null);
+}
+
+
+function isObject$1(subject) {
+  return (typeof subject === 'object') && (subject !== null);
+}
+
+
+function toArray(sequence) {
+  if (Array.isArray(sequence)) return sequence;
+  else if (isNothing(sequence)) return [];
+
+  return [ sequence ];
+}
+
+
+function extend$2(target, source) {
+  var index, length, key, sourceKeys;
+
+  if (source) {
+    sourceKeys = Object.keys(source);
+
+    for (index = 0, length = sourceKeys.length; index < length; index += 1) {
+      key = sourceKeys[index];
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+
+function repeat$1(string, count) {
+  var result = '', cycle;
+
+  for (cycle = 0; cycle < count; cycle += 1) {
+    result += string;
+  }
+
+  return result;
+}
+
+
+function isNegativeZero(number) {
+  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
+}
+
+
+var isNothing_1      = isNothing;
+var isObject_1       = isObject$1;
+var toArray_1        = toArray;
+var repeat_1         = repeat$1;
+var isNegativeZero_1 = isNegativeZero;
+var extend_1         = extend$2;
+
+var common$4 = {
+	isNothing: isNothing_1,
+	isObject: isObject_1,
+	toArray: toArray_1,
+	repeat: repeat_1,
+	isNegativeZero: isNegativeZero_1,
+	extend: extend_1
+};
+
+// YAML error class. http://stackoverflow.com/questions/8458984
+
+
+function formatError(exception, compact) {
+  var where = '', message = exception.reason || '(unknown reason)';
+
+  if (!exception.mark) return message;
+
+  if (exception.mark.name) {
+    where += 'in "' + exception.mark.name + '" ';
+  }
+
+  where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')';
+
+  if (!compact && exception.mark.snippet) {
+    where += '\n\n' + exception.mark.snippet;
+  }
+
+  return message + ' ' + where;
+}
+
+
+function YAMLException$1(reason, mark) {
+  // Super constructor
+  Error.call(this);
+
+  this.name = 'YAMLException';
+  this.reason = reason;
+  this.mark = mark;
+  this.message = formatError(this, false);
+
+  // Include stack trace in error object
+  if (Error.captureStackTrace) {
+    // Chrome and NodeJS
+    Error.captureStackTrace(this, this.constructor);
+  } else {
+    // FF, IE 10+ and Safari 6+. Fallback for others
+    this.stack = (new Error()).stack || '';
+  }
+}
+
+
+// Inherit from Error
+YAMLException$1.prototype = Object.create(Error.prototype);
+YAMLException$1.prototype.constructor = YAMLException$1;
+
+
+YAMLException$1.prototype.toString = function toString(compact) {
+  return this.name + ': ' + formatError(this, compact);
+};
+
+
+var exception = YAMLException$1;
+
+// get snippet for a single line, respecting maxLength
+function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+  var head = '';
+  var tail = '';
+  var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+
+  if (position - lineStart > maxHalfLength) {
+    head = ' ... ';
+    lineStart = position - maxHalfLength + head.length;
+  }
+
+  if (lineEnd - position > maxHalfLength) {
+    tail = ' ...';
+    lineEnd = position + maxHalfLength - tail.length;
+  }
+
+  return {
+    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
+    pos: position - lineStart + head.length // relative position
+  };
+}
+
+
+function padStart(string, max) {
+  return common$4.repeat(' ', max - string.length) + string;
+}
+
+
+function makeSnippet(mark, options) {
+  options = Object.create(options || null);
+
+  if (!mark.buffer) return null;
+
+  if (!options.maxLength) options.maxLength = 79;
+  if (typeof options.indent      !== 'number') options.indent      = 1;
+  if (typeof options.linesBefore !== 'number') options.linesBefore = 3;
+  if (typeof options.linesAfter  !== 'number') options.linesAfter  = 2;
+
+  var re = /\r?\n|\r|\0/g;
+  var lineStarts = [ 0 ];
+  var lineEnds = [];
+  var match;
+  var foundLineNo = -1;
+
+  while ((match = re.exec(mark.buffer))) {
+    lineEnds.push(match.index);
+    lineStarts.push(match.index + match[0].length);
+
+    if (mark.position <= match.index && foundLineNo < 0) {
+      foundLineNo = lineStarts.length - 2;
+    }
+  }
+
+  if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
+
+  var result = '', i, line;
+  var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+  var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
+
+  for (i = 1; i <= options.linesBefore; i++) {
+    if (foundLineNo - i < 0) break;
+    line = getLine(
+      mark.buffer,
+      lineStarts[foundLineNo - i],
+      lineEnds[foundLineNo - i],
+      mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
+      maxLineLength
+    );
+    result = common$4.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
+      ' | ' + line.str + '\n' + result;
+  }
+
+  line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+  result += common$4.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
+    ' | ' + line.str + '\n';
+  result += common$4.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n';
+
+  for (i = 1; i <= options.linesAfter; i++) {
+    if (foundLineNo + i >= lineEnds.length) break;
+    line = getLine(
+      mark.buffer,
+      lineStarts[foundLineNo + i],
+      lineEnds[foundLineNo + i],
+      mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
+      maxLineLength
+    );
+    result += common$4.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
+      ' | ' + line.str + '\n';
+  }
+
+  return result.replace(/\n$/, '');
+}
+
+
+var snippet = makeSnippet;
+
+var TYPE_CONSTRUCTOR_OPTIONS = [
+  'kind',
+  'multi',
+  'resolve',
+  'construct',
+  'instanceOf',
+  'predicate',
+  'represent',
+  'representName',
+  'defaultStyle',
+  'styleAliases'
+];
+
+var YAML_NODE_KINDS = [
+  'scalar',
+  'sequence',
+  'mapping'
+];
+
+function compileStyleAliases(map) {
+  var result = {};
+
+  if (map !== null) {
+    Object.keys(map).forEach(function (style) {
+      map[style].forEach(function (alias) {
+        result[String(alias)] = style;
+      });
+    });
+  }
+
+  return result;
+}
+
+function Type$1(tag, options) {
+  options = options || {};
+
+  Object.keys(options).forEach(function (name) {
+    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
+      throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+    }
+  });
+
+  // TODO: Add tag format check.
+  this.options       = options; // keep original options in case user wants to extend this type later
+  this.tag           = tag;
+  this.kind          = options['kind']          || null;
+  this.resolve       = options['resolve']       || function () { return true; };
+  this.construct     = options['construct']     || function (data) { return data; };
+  this.instanceOf    = options['instanceOf']    || null;
+  this.predicate     = options['predicate']     || null;
+  this.represent     = options['represent']     || null;
+  this.representName = options['representName'] || null;
+  this.defaultStyle  = options['defaultStyle']  || null;
+  this.multi         = options['multi']         || false;
+  this.styleAliases  = compileStyleAliases(options['styleAliases'] || null);
+
+  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+    throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+  }
+}
+
+var type$1 = Type$1;
+
+/*eslint-disable max-len*/
+
+
+
+
+
+function compileList(schema, name) {
+  var result = [];
+
+  schema[name].forEach(function (currentType) {
+    var newIndex = result.length;
+
+    result.forEach(function (previousType, previousIndex) {
+      if (previousType.tag === currentType.tag &&
+          previousType.kind === currentType.kind &&
+          previousType.multi === currentType.multi) {
+
+        newIndex = previousIndex;
+      }
+    });
+
+    result[newIndex] = currentType;
+  });
+
+  return result;
+}
+
+
+function compileMap(/* lists... */) {
+  var result = {
+        scalar: {},
+        sequence: {},
+        mapping: {},
+        fallback: {},
+        multi: {
+          scalar: [],
+          sequence: [],
+          mapping: [],
+          fallback: []
+        }
+      }, index, length;
+
+  function collectType(type) {
+    if (type.multi) {
+      result.multi[type.kind].push(type);
+      result.multi['fallback'].push(type);
+    } else {
+      result[type.kind][type.tag] = result['fallback'][type.tag] = type;
+    }
+  }
+
+  for (index = 0, length = arguments.length; index < length; index += 1) {
+    arguments[index].forEach(collectType);
+  }
+  return result;
+}
+
+
+function Schema$1(definition) {
+  return this.extend(definition);
+}
+
+
+Schema$1.prototype.extend = function extend(definition) {
+  var implicit = [];
+  var explicit = [];
+
+  if (definition instanceof type$1) {
+    // Schema.extend(type)
+    explicit.push(definition);
+
+  } else if (Array.isArray(definition)) {
+    // Schema.extend([ type1, type2, ... ])
+    explicit = explicit.concat(definition);
+
+  } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+    // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
+    if (definition.implicit) implicit = implicit.concat(definition.implicit);
+    if (definition.explicit) explicit = explicit.concat(definition.explicit);
+
+  } else {
+    throw new exception('Schema.extend argument should be a Type, [ Type ], ' +
+      'or a schema definition ({ implicit: [...], explicit: [...] })');
+  }
+
+  implicit.forEach(function (type$1$1) {
+    if (!(type$1$1 instanceof type$1)) {
+      throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+    }
+
+    if (type$1$1.loadKind && type$1$1.loadKind !== 'scalar') {
+      throw new exception('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
+    }
+
+    if (type$1$1.multi) {
+      throw new exception('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.');
+    }
+  });
+
+  explicit.forEach(function (type$1$1) {
+    if (!(type$1$1 instanceof type$1)) {
+      throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+    }
+  });
+
+  var result = Object.create(Schema$1.prototype);
+
+  result.implicit = (this.implicit || []).concat(implicit);
+  result.explicit = (this.explicit || []).concat(explicit);
+
+  result.compiledImplicit = compileList(result, 'implicit');
+  result.compiledExplicit = compileList(result, 'explicit');
+  result.compiledTypeMap  = compileMap(result.compiledImplicit, result.compiledExplicit);
+
+  return result;
+};
+
+
+var schema$1 = Schema$1;
+
+var str = new type$1('tag:yaml.org,2002:str', {
+  kind: 'scalar',
+  construct: function (data) { return data !== null ? data : ''; }
+});
+
+var seq = new type$1('tag:yaml.org,2002:seq', {
+  kind: 'sequence',
+  construct: function (data) { return data !== null ? data : []; }
+});
+
+var map$3 = new type$1('tag:yaml.org,2002:map', {
+  kind: 'mapping',
+  construct: function (data) { return data !== null ? data : {}; }
+});
+
+var failsafe = new schema$1({
+  explicit: [
+    str,
+    seq,
+    map$3
+  ]
+});
+
+function resolveYamlNull(data) {
+  if (data === null) return true;
+
+  var max = data.length;
+
+  return (max === 1 && data === '~') ||
+         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
+}
+
+function constructYamlNull() {
+  return null;
+}
+
+function isNull(object) {
+  return object === null;
+}
+
+var _null = new type$1('tag:yaml.org,2002:null', {
+  kind: 'scalar',
+  resolve: resolveYamlNull,
+  construct: constructYamlNull,
+  predicate: isNull,
+  represent: {
+    canonical: function () { return '~';    },
+    lowercase: function () { return 'null'; },
+    uppercase: function () { return 'NULL'; },
+    camelcase: function () { return 'Null'; },
+    empty:     function () { return '';     }
+  },
+  defaultStyle: 'lowercase'
+});
+
+function resolveYamlBoolean(data) {
+  if (data === null) return false;
+
+  var max = data.length;
+
+  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
+         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
+}
+
+function constructYamlBoolean(data) {
+  return data === 'true' ||
+         data === 'True' ||
+         data === 'TRUE';
+}
+
+function isBoolean(object) {
+  return Object.prototype.toString.call(object) === '[object Boolean]';
+}
+
+var bool = new type$1('tag:yaml.org,2002:bool', {
+  kind: 'scalar',
+  resolve: resolveYamlBoolean,
+  construct: constructYamlBoolean,
+  predicate: isBoolean,
+  represent: {
+    lowercase: function (object) { return object ? 'true' : 'false'; },
+    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
+    camelcase: function (object) { return object ? 'True' : 'False'; }
+  },
+  defaultStyle: 'lowercase'
+});
+
+function isHexCode(c) {
+  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
+         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
+         ((0x61/* a */ <= c) && (c <= 0x66/* f */));
+}
+
+function isOctCode(c) {
+  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
+}
+
+function isDecCode(c) {
+  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
+}
+
+function resolveYamlInteger(data) {
+  if (data === null) return false;
+
+  var max = data.length,
+      index = 0,
+      hasDigits = false,
+      ch;
+
+  if (!max) return false;
+
+  ch = data[index];
+
+  // sign
+  if (ch === '-' || ch === '+') {
+    ch = data[++index];
+  }
+
+  if (ch === '0') {
+    // 0
+    if (index + 1 === max) return true;
+    ch = data[++index];
+
+    // base 2, base 8, base 16
+
+    if (ch === 'b') {
+      // base 2
+      index++;
+
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === '_') continue;
+        if (ch !== '0' && ch !== '1') return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== '_';
+    }
+
+
+    if (ch === 'x') {
+      // base 16
+      index++;
+
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === '_') continue;
+        if (!isHexCode(data.charCodeAt(index))) return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== '_';
+    }
+
+
+    if (ch === 'o') {
+      // base 8
+      index++;
+
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === '_') continue;
+        if (!isOctCode(data.charCodeAt(index))) return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== '_';
+    }
+  }
+
+  // base 10 (except 0)
+
+  // value should not start with `_`;
+  if (ch === '_') return false;
+
+  for (; index < max; index++) {
+    ch = data[index];
+    if (ch === '_') continue;
+    if (!isDecCode(data.charCodeAt(index))) {
+      return false;
+    }
+    hasDigits = true;
+  }
+
+  // Should have digits and should not end with `_`
+  if (!hasDigits || ch === '_') return false;
+
+  return true;
+}
+
+function constructYamlInteger(data) {
+  var value = data, sign = 1, ch;
+
+  if (value.indexOf('_') !== -1) {
+    value = value.replace(/_/g, '');
+  }
+
+  ch = value[0];
+
+  if (ch === '-' || ch === '+') {
+    if (ch === '-') sign = -1;
+    value = value.slice(1);
+    ch = value[0];
+  }
+
+  if (value === '0') return 0;
+
+  if (ch === '0') {
+    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
+    if (value[1] === 'x') return sign * parseInt(value.slice(2), 16);
+    if (value[1] === 'o') return sign * parseInt(value.slice(2), 8);
+  }
+
+  return sign * parseInt(value, 10);
+}
+
+function isInteger(object) {
+  return (Object.prototype.toString.call(object)) === '[object Number]' &&
+         (object % 1 === 0 && !common$4.isNegativeZero(object));
+}
+
+var int = new type$1('tag:yaml.org,2002:int', {
+  kind: 'scalar',
+  resolve: resolveYamlInteger,
+  construct: constructYamlInteger,
+  predicate: isInteger,
+  represent: {
+    binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
+    octal:       function (obj) { return obj >= 0 ? '0o'  + obj.toString(8) : '-0o'  + obj.toString(8).slice(1); },
+    decimal:     function (obj) { return obj.toString(10); },
+    /* eslint-disable max-len */
+    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }
+  },
+  defaultStyle: 'decimal',
+  styleAliases: {
+    binary:      [ 2,  'bin' ],
+    octal:       [ 8,  'oct' ],
+    decimal:     [ 10, 'dec' ],
+    hexadecimal: [ 16, 'hex' ]
+  }
+});
+
+var YAML_FLOAT_PATTERN = new RegExp(
+  // 2.5e4, 2.5 and integers
+  '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
+  // .2e4, .2
+  // special case, seems not from spec
+  '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
+  // .inf
+  '|[-+]?\\.(?:inf|Inf|INF)' +
+  // .nan
+  '|\\.(?:nan|NaN|NAN))$');
+
+function resolveYamlFloat(data) {
+  if (data === null) return false;
+
+  if (!YAML_FLOAT_PATTERN.test(data) ||
+      // Quick hack to not allow integers end with `_`
+      // Probably should update regexp & check speed
+      data[data.length - 1] === '_') {
+    return false;
+  }
+
+  return true;
+}
+
+function constructYamlFloat(data) {
+  var value, sign;
+
+  value  = data.replace(/_/g, '').toLowerCase();
+  sign   = value[0] === '-' ? -1 : 1;
+
+  if ('+-'.indexOf(value[0]) >= 0) {
+    value = value.slice(1);
+  }
+
+  if (value === '.inf') {
+    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+
+  } else if (value === '.nan') {
+    return NaN;
+  }
+  return sign * parseFloat(value, 10);
+}
+
+
+var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+
+function representYamlFloat(object, style) {
+  var res;
+
+  if (isNaN(object)) {
+    switch (style) {
+      case 'lowercase': return '.nan';
+      case 'uppercase': return '.NAN';
+      case 'camelcase': return '.NaN';
+    }
+  } else if (Number.POSITIVE_INFINITY === object) {
+    switch (style) {
+      case 'lowercase': return '.inf';
+      case 'uppercase': return '.INF';
+      case 'camelcase': return '.Inf';
+    }
+  } else if (Number.NEGATIVE_INFINITY === object) {
+    switch (style) {
+      case 'lowercase': return '-.inf';
+      case 'uppercase': return '-.INF';
+      case 'camelcase': return '-.Inf';
+    }
+  } else if (common$4.isNegativeZero(object)) {
+    return '-0.0';
+  }
+
+  res = object.toString(10);
+
+  // JS stringifier can build scientific format without dots: 5e-100,
+  // while YAML requres dot: 5.e-100. Fix it with simple hack
+
+  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
+}
+
+function isFloat(object) {
+  return (Object.prototype.toString.call(object) === '[object Number]') &&
+         (object % 1 !== 0 || common$4.isNegativeZero(object));
+}
+
+var float = new type$1('tag:yaml.org,2002:float', {
+  kind: 'scalar',
+  resolve: resolveYamlFloat,
+  construct: constructYamlFloat,
+  predicate: isFloat,
+  represent: representYamlFloat,
+  defaultStyle: 'lowercase'
+});
+
+var json = failsafe.extend({
+  implicit: [
+    _null,
+    bool,
+    int,
+    float
+  ]
+});
+
+var core = json;
+
+var YAML_DATE_REGEXP = new RegExp(
+  '^([0-9][0-9][0-9][0-9])'          + // [1] year
+  '-([0-9][0-9])'                    + // [2] month
+  '-([0-9][0-9])$');                   // [3] day
+
+var YAML_TIMESTAMP_REGEXP = new RegExp(
+  '^([0-9][0-9][0-9][0-9])'          + // [1] year
+  '-([0-9][0-9]?)'                   + // [2] month
+  '-([0-9][0-9]?)'                   + // [3] day
+  '(?:[Tt]|[ \\t]+)'                 + // ...
+  '([0-9][0-9]?)'                    + // [4] hour
+  ':([0-9][0-9])'                    + // [5] minute
+  ':([0-9][0-9])'                    + // [6] second
+  '(?:\\.([0-9]*))?'                 + // [7] fraction
+  '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
+  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute
+
+function resolveYamlTimestamp(data) {
+  if (data === null) return false;
+  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+  return false;
+}
+
+function constructYamlTimestamp(data) {
+  var match, year, month, day, hour, minute, second, fraction = 0,
+      delta = null, tz_hour, tz_minute, date;
+
+  match = YAML_DATE_REGEXP.exec(data);
+  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+
+  if (match === null) throw new Error('Date resolve error');
+
+  // match: [1] year [2] month [3] day
+
+  year = +(match[1]);
+  month = +(match[2]) - 1; // JS month starts with 0
+  day = +(match[3]);
+
+  if (!match[4]) { // no hour
+    return new Date(Date.UTC(year, month, day));
+  }
+
+  // match: [4] hour [5] minute [6] second [7] fraction
+
+  hour = +(match[4]);
+  minute = +(match[5]);
+  second = +(match[6]);
+
+  if (match[7]) {
+    fraction = match[7].slice(0, 3);
+    while (fraction.length < 3) { // milli-seconds
+      fraction += '0';
+    }
+    fraction = +fraction;
+  }
+
+  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
+
+  if (match[9]) {
+    tz_hour = +(match[10]);
+    tz_minute = +(match[11] || 0);
+    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
+    if (match[9] === '-') delta = -delta;
+  }
+
+  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+
+  if (delta) date.setTime(date.getTime() - delta);
+
+  return date;
+}
+
+function representYamlTimestamp(object /*, style*/) {
+  return object.toISOString();
+}
+
+var timestamp = new type$1('tag:yaml.org,2002:timestamp', {
+  kind: 'scalar',
+  resolve: resolveYamlTimestamp,
+  construct: constructYamlTimestamp,
+  instanceOf: Date,
+  represent: representYamlTimestamp
+});
+
+function resolveYamlMerge(data) {
+  return data === '<<' || data === null;
+}
+
+var merge$1 = new type$1('tag:yaml.org,2002:merge', {
+  kind: 'scalar',
+  resolve: resolveYamlMerge
+});
+
+/*eslint-disable no-bitwise*/
+
+
+
+
+
+// [ 64, 65, 66 ] -> [ padding, CR, LF ]
+var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
+
+
+function resolveYamlBinary(data) {
+  if (data === null) return false;
+
+  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
+
+  // Convert one by one.
+  for (idx = 0; idx < max; idx++) {
+    code = map.indexOf(data.charAt(idx));
+
+    // Skip CR/LF
+    if (code > 64) continue;
+
+    // Fail on illegal characters
+    if (code < 0) return false;
+
+    bitlen += 6;
+  }
+
+  // If there are any bits left, source was corrupted
+  return (bitlen % 8) === 0;
+}
+
+function constructYamlBinary(data) {
+  var idx, tailbits,
+      input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
+      max = input.length,
+      map = BASE64_MAP,
+      bits = 0,
+      result = [];
+
+  // Collect by 6*4 bits (3 bytes)
+
+  for (idx = 0; idx < max; idx++) {
+    if ((idx % 4 === 0) && idx) {
+      result.push((bits >> 16) & 0xFF);
+      result.push((bits >> 8) & 0xFF);
+      result.push(bits & 0xFF);
+    }
+
+    bits = (bits << 6) | map.indexOf(input.charAt(idx));
+  }
+
+  // Dump tail
+
+  tailbits = (max % 4) * 6;
+
+  if (tailbits === 0) {
+    result.push((bits >> 16) & 0xFF);
+    result.push((bits >> 8) & 0xFF);
+    result.push(bits & 0xFF);
+  } else if (tailbits === 18) {
+    result.push((bits >> 10) & 0xFF);
+    result.push((bits >> 2) & 0xFF);
+  } else if (tailbits === 12) {
+    result.push((bits >> 4) & 0xFF);
+  }
+
+  return new Uint8Array(result);
+}
+
+function representYamlBinary(object /*, style*/) {
+  var result = '', bits = 0, idx, tail,
+      max = object.length,
+      map = BASE64_MAP;
+
+  // Convert every three bytes to 4 ASCII characters.
+
+  for (idx = 0; idx < max; idx++) {
+    if ((idx % 3 === 0) && idx) {
+      result += map[(bits >> 18) & 0x3F];
+      result += map[(bits >> 12) & 0x3F];
+      result += map[(bits >> 6) & 0x3F];
+      result += map[bits & 0x3F];
+    }
+
+    bits = (bits << 8) + object[idx];
+  }
+
+  // Dump tail
+
+  tail = max % 3;
+
+  if (tail === 0) {
+    result += map[(bits >> 18) & 0x3F];
+    result += map[(bits >> 12) & 0x3F];
+    result += map[(bits >> 6) & 0x3F];
+    result += map[bits & 0x3F];
+  } else if (tail === 2) {
+    result += map[(bits >> 10) & 0x3F];
+    result += map[(bits >> 4) & 0x3F];
+    result += map[(bits << 2) & 0x3F];
+    result += map[64];
+  } else if (tail === 1) {
+    result += map[(bits >> 2) & 0x3F];
+    result += map[(bits << 4) & 0x3F];
+    result += map[64];
+    result += map[64];
+  }
+
+  return result;
+}
+
+function isBinary(obj) {
+  return Object.prototype.toString.call(obj) ===  '[object Uint8Array]';
+}
+
+var binary = new type$1('tag:yaml.org,2002:binary', {
+  kind: 'scalar',
+  resolve: resolveYamlBinary,
+  construct: constructYamlBinary,
+  predicate: isBinary,
+  represent: representYamlBinary
+});
+
+var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+var _toString$2       = Object.prototype.toString;
+
+function resolveYamlOmap(data) {
+  if (data === null) return true;
+
+  var objectKeys = [], index, length, pair, pairKey, pairHasKey,
+      object = data;
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+    pairHasKey = false;
+
+    if (_toString$2.call(pair) !== '[object Object]') return false;
+
+    for (pairKey in pair) {
+      if (_hasOwnProperty$3.call(pair, pairKey)) {
+        if (!pairHasKey) pairHasKey = true;
+        else return false;
+      }
+    }
+
+    if (!pairHasKey) return false;
+
+    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
+    else return false;
+  }
+
+  return true;
+}
+
+function constructYamlOmap(data) {
+  return data !== null ? data : [];
+}
+
+var omap = new type$1('tag:yaml.org,2002:omap', {
+  kind: 'sequence',
+  resolve: resolveYamlOmap,
+  construct: constructYamlOmap
+});
+
+var _toString$1 = Object.prototype.toString;
+
+function resolveYamlPairs(data) {
+  if (data === null) return true;
+
+  var index, length, pair, keys, result,
+      object = data;
+
+  result = new Array(object.length);
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+
+    if (_toString$1.call(pair) !== '[object Object]') return false;
+
+    keys = Object.keys(pair);
+
+    if (keys.length !== 1) return false;
+
+    result[index] = [ keys[0], pair[keys[0]] ];
+  }
+
+  return true;
+}
+
+function constructYamlPairs(data) {
+  if (data === null) return [];
+
+  var index, length, pair, keys, result,
+      object = data;
+
+  result = new Array(object.length);
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+
+    keys = Object.keys(pair);
+
+    result[index] = [ keys[0], pair[keys[0]] ];
+  }
+
+  return result;
+}
+
+var pairs = new type$1('tag:yaml.org,2002:pairs', {
+  kind: 'sequence',
+  resolve: resolveYamlPairs,
+  construct: constructYamlPairs
+});
+
+var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+
+function resolveYamlSet(data) {
+  if (data === null) return true;
+
+  var key, object = data;
+
+  for (key in object) {
+    if (_hasOwnProperty$2.call(object, key)) {
+      if (object[key] !== null) return false;
+    }
+  }
+
+  return true;
+}
+
+function constructYamlSet(data) {
+  return data !== null ? data : {};
+}
+
+var set = new type$1('tag:yaml.org,2002:set', {
+  kind: 'mapping',
+  resolve: resolveYamlSet,
+  construct: constructYamlSet
+});
+
+var _default$1 = core.extend({
+  implicit: [
+    timestamp,
+    merge$1
+  ],
+  explicit: [
+    binary,
+    omap,
+    pairs,
+    set
+  ]
+});
+
+/*eslint-disable max-len,no-use-before-define*/
+
+
+
+
+
+
+
+var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+
+
+var CONTEXT_FLOW_IN   = 1;
+var CONTEXT_FLOW_OUT  = 2;
+var CONTEXT_BLOCK_IN  = 3;
+var CONTEXT_BLOCK_OUT = 4;
+
+
+var CHOMPING_CLIP  = 1;
+var CHOMPING_STRIP = 2;
+var CHOMPING_KEEP  = 3;
+
+
+var PATTERN_NON_PRINTABLE         = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS       = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI               = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+
+
+function _class(obj) { return Object.prototype.toString.call(obj); }
+
+function is_EOL(c) {
+  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
+}
+
+function is_WHITE_SPACE(c) {
+  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
+}
+
+function is_WS_OR_EOL(c) {
+  return (c === 0x09/* Tab */) ||
+         (c === 0x20/* Space */) ||
+         (c === 0x0A/* LF */) ||
+         (c === 0x0D/* CR */);
+}
+
+function is_FLOW_INDICATOR(c) {
+  return c === 0x2C/* , */ ||
+         c === 0x5B/* [ */ ||
+         c === 0x5D/* ] */ ||
+         c === 0x7B/* { */ ||
+         c === 0x7D/* } */;
+}
+
+function fromHexCode(c) {
+  var lc;
+
+  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
+    return c - 0x30;
+  }
+
+  /*eslint-disable no-bitwise*/
+  lc = c | 0x20;
+
+  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
+    return lc - 0x61 + 10;
+  }
+
+  return -1;
+}
+
+function escapedHexLen(c) {
+  if (c === 0x78/* x */) { return 2; }
+  if (c === 0x75/* u */) { return 4; }
+  if (c === 0x55/* U */) { return 8; }
+  return 0;
+}
+
+function fromDecimalCode(c) {
+  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
+    return c - 0x30;
+  }
+
+  return -1;
+}
+
+function simpleEscapeSequence(c) {
+  /* eslint-disable indent */
+  return (c === 0x30/* 0 */) ? '\x00' :
+        (c === 0x61/* a */) ? '\x07' :
+        (c === 0x62/* b */) ? '\x08' :
+        (c === 0x74/* t */) ? '\x09' :
+        (c === 0x09/* Tab */) ? '\x09' :
+        (c === 0x6E/* n */) ? '\x0A' :
+        (c === 0x76/* v */) ? '\x0B' :
+        (c === 0x66/* f */) ? '\x0C' :
+        (c === 0x72/* r */) ? '\x0D' :
+        (c === 0x65/* e */) ? '\x1B' :
+        (c === 0x20/* Space */) ? ' ' :
+        (c === 0x22/* " */) ? '\x22' :
+        (c === 0x2F/* / */) ? '/' :
+        (c === 0x5C/* \ */) ? '\x5C' :
+        (c === 0x4E/* N */) ? '\x85' :
+        (c === 0x5F/* _ */) ? '\xA0' :
+        (c === 0x4C/* L */) ? '\u2028' :
+        (c === 0x50/* P */) ? '\u2029' : '';
+}
+
+function charFromCodepoint(c) {
+  if (c <= 0xFFFF) {
+    return String.fromCharCode(c);
+  }
+  // Encode UTF-16 surrogate pair
+  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
+  return String.fromCharCode(
+    ((c - 0x010000) >> 10) + 0xD800,
+    ((c - 0x010000) & 0x03FF) + 0xDC00
+  );
+}
+
+var simpleEscapeCheck = new Array(256); // integer, for fast access
+var simpleEscapeMap = new Array(256);
+for (var i = 0; i < 256; i++) {
+  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+  simpleEscapeMap[i] = simpleEscapeSequence(i);
+}
+
+
+function State$1(input, options) {
+  this.input = input;
+
+  this.filename  = options['filename']  || null;
+  this.schema    = options['schema']    || _default$1;
+  this.onWarning = options['onWarning'] || null;
+  // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
+  // if such documents have no explicit %YAML directive
+  this.legacy    = options['legacy']    || false;
+
+  this.json      = options['json']      || false;
+  this.listener  = options['listener']  || null;
+
+  this.implicitTypes = this.schema.compiledImplicit;
+  this.typeMap       = this.schema.compiledTypeMap;
+
+  this.length     = input.length;
+  this.position   = 0;
+  this.line       = 0;
+  this.lineStart  = 0;
+  this.lineIndent = 0;
+
+  // position of first leading tab in the current line,
+  // used to make sure there are no tabs in the indentation
+  this.firstTabInLine = -1;
+
+  this.documents = [];
+
+  /*
+  this.version;
+  this.checkLineBreaks;
+  this.tagMap;
+  this.anchorMap;
+  this.tag;
+  this.anchor;
+  this.kind;
+  this.result;*/
+
+}
+
+
+function generateError(state, message) {
+  var mark = {
+    name:     state.filename,
+    buffer:   state.input.slice(0, -1), // omit trailing \0
+    position: state.position,
+    line:     state.line,
+    column:   state.position - state.lineStart
+  };
+
+  mark.snippet = snippet(mark);
+
+  return new exception(message, mark);
+}
+
+function throwError$1(state, message) {
+  throw generateError(state, message);
+}
+
+function throwWarning(state, message) {
+  if (state.onWarning) {
+    state.onWarning.call(null, generateError(state, message));
+  }
+}
+
+
+var directiveHandlers = {
+
+  YAML: function handleYamlDirective(state, name, args) {
+
+    var match, major, minor;
+
+    if (state.version !== null) {
+      throwError$1(state, 'duplication of %YAML directive');
+    }
+
+    if (args.length !== 1) {
+      throwError$1(state, 'YAML directive accepts exactly one argument');
+    }
+
+    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+
+    if (match === null) {
+      throwError$1(state, 'ill-formed argument of the YAML directive');
+    }
+
+    major = parseInt(match[1], 10);
+    minor = parseInt(match[2], 10);
+
+    if (major !== 1) {
+      throwError$1(state, 'unacceptable YAML version of the document');
+    }
+
+    state.version = args[0];
+    state.checkLineBreaks = (minor < 2);
+
+    if (minor !== 1 && minor !== 2) {
+      throwWarning(state, 'unsupported YAML version of the document');
+    }
+  },
+
+  TAG: function handleTagDirective(state, name, args) {
+
+    var handle, prefix;
+
+    if (args.length !== 2) {
+      throwError$1(state, 'TAG directive accepts exactly two arguments');
+    }
+
+    handle = args[0];
+    prefix = args[1];
+
+    if (!PATTERN_TAG_HANDLE.test(handle)) {
+      throwError$1(state, 'ill-formed tag handle (first argument) of the TAG directive');
+    }
+
+    if (_hasOwnProperty$1.call(state.tagMap, handle)) {
+      throwError$1(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+    }
+
+    if (!PATTERN_TAG_URI.test(prefix)) {
+      throwError$1(state, 'ill-formed tag prefix (second argument) of the TAG directive');
+    }
+
+    try {
+      prefix = decodeURIComponent(prefix);
+    } catch (err) {
+      throwError$1(state, 'tag prefix is malformed: ' + prefix);
+    }
+
+    state.tagMap[handle] = prefix;
+  }
+};
+
+
+function captureSegment(state, start, end, checkJson) {
+  var _position, _length, _character, _result;
+
+  if (start < end) {
+    _result = state.input.slice(start, end);
+
+    if (checkJson) {
+      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
+        _character = _result.charCodeAt(_position);
+        if (!(_character === 0x09 ||
+              (0x20 <= _character && _character <= 0x10FFFF))) {
+          throwError$1(state, 'expected valid JSON character');
+        }
+      }
+    } else if (PATTERN_NON_PRINTABLE.test(_result)) {
+      throwError$1(state, 'the stream contains non-printable characters');
+    }
+
+    state.result += _result;
+  }
+}
+
+function mergeMappings(state, destination, source, overridableKeys) {
+  var sourceKeys, key, index, quantity;
+
+  if (!common$4.isObject(source)) {
+    throwError$1(state, 'cannot merge mappings; the provided source object is unacceptable');
+  }
+
+  sourceKeys = Object.keys(source);
+
+  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+    key = sourceKeys[index];
+
+    if (!_hasOwnProperty$1.call(destination, key)) {
+      destination[key] = source[key];
+      overridableKeys[key] = true;
+    }
+  }
+}
+
+function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode,
+  startLine, startLineStart, startPos) {
+
+  var index, quantity;
+
+  // The output is a plain object here, so keys can only be strings.
+  // We need to convert keyNode to a string, but doing so can hang the process
+  // (deeply nested arrays that explode exponentially using aliases).
+  if (Array.isArray(keyNode)) {
+    keyNode = Array.prototype.slice.call(keyNode);
+
+    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
+      if (Array.isArray(keyNode[index])) {
+        throwError$1(state, 'nested arrays are not supported inside keys');
+      }
+
+      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
+        keyNode[index] = '[object Object]';
+      }
+    }
+  }
+
+  // Avoid code execution in load() via toString property
+  // (still use its own toString for arrays, timestamps,
+  // and whatever user schema extensions happen to have @@toStringTag)
+  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
+    keyNode = '[object Object]';
+  }
+
+
+  keyNode = String(keyNode);
+
+  if (_result === null) {
+    _result = {};
+  }
+
+  if (keyTag === 'tag:yaml.org,2002:merge') {
+    if (Array.isArray(valueNode)) {
+      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+        mergeMappings(state, _result, valueNode[index], overridableKeys);
+      }
+    } else {
+      mergeMappings(state, _result, valueNode, overridableKeys);
+    }
+  } else {
+    if (!state.json &&
+        !_hasOwnProperty$1.call(overridableKeys, keyNode) &&
+        _hasOwnProperty$1.call(_result, keyNode)) {
+      state.line = startLine || state.line;
+      state.lineStart = startLineStart || state.lineStart;
+      state.position = startPos || state.position;
+      throwError$1(state, 'duplicated mapping key');
+    }
+
+    // used for this specific key only because Object.defineProperty is slow
+    if (keyNode === '__proto__') {
+      Object.defineProperty(_result, keyNode, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: valueNode
+      });
+    } else {
+      _result[keyNode] = valueNode;
+    }
+    delete overridableKeys[keyNode];
+  }
+
+  return _result;
+}
+
+function readLineBreak(state) {
+  var ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch === 0x0A/* LF */) {
+    state.position++;
+  } else if (ch === 0x0D/* CR */) {
+    state.position++;
+    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
+      state.position++;
+    }
+  } else {
+    throwError$1(state, 'a line break is expected');
+  }
+
+  state.line += 1;
+  state.lineStart = state.position;
+  state.firstTabInLine = -1;
+}
+
+function skipSeparationSpace(state, allowComments, checkIndent) {
+  var lineBreaks = 0,
+      ch = state.input.charCodeAt(state.position);
+
+  while (ch !== 0) {
+    while (is_WHITE_SPACE(ch)) {
+      if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
+        state.firstTabInLine = state.position;
+      }
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    if (allowComments && ch === 0x23/* # */) {
+      do {
+        ch = state.input.charCodeAt(++state.position);
+      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
+    }
+
+    if (is_EOL(ch)) {
+      readLineBreak(state);
+
+      ch = state.input.charCodeAt(state.position);
+      lineBreaks++;
+      state.lineIndent = 0;
+
+      while (ch === 0x20/* Space */) {
+        state.lineIndent++;
+        ch = state.input.charCodeAt(++state.position);
+      }
+    } else {
+      break;
+    }
+  }
+
+  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
+    throwWarning(state, 'deficient indentation');
+  }
+
+  return lineBreaks;
+}
+
+function testDocumentSeparator(state) {
+  var _position = state.position,
+      ch;
+
+  ch = state.input.charCodeAt(_position);
+
+  // Condition state.position === state.lineStart is tested
+  // in parent on each call, for efficiency. No needs to test here again.
+  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
+      ch === state.input.charCodeAt(_position + 1) &&
+      ch === state.input.charCodeAt(_position + 2)) {
+
+    _position += 3;
+
+    ch = state.input.charCodeAt(_position);
+
+    if (ch === 0 || is_WS_OR_EOL(ch)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function writeFoldedLines(state, count) {
+  if (count === 1) {
+    state.result += ' ';
+  } else if (count > 1) {
+    state.result += common$4.repeat('\n', count - 1);
+  }
+}
+
+
+function readPlainScalar(state, nodeIndent, withinFlowCollection) {
+  var preceding,
+      following,
+      captureStart,
+      captureEnd,
+      hasPendingContent,
+      _line,
+      _lineStart,
+      _lineIndent,
+      _kind = state.kind,
+      _result = state.result,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (is_WS_OR_EOL(ch)      ||
+      is_FLOW_INDICATOR(ch) ||
+      ch === 0x23/* # */    ||
+      ch === 0x26/* & */    ||
+      ch === 0x2A/* * */    ||
+      ch === 0x21/* ! */    ||
+      ch === 0x7C/* | */    ||
+      ch === 0x3E/* > */    ||
+      ch === 0x27/* ' */    ||
+      ch === 0x22/* " */    ||
+      ch === 0x25/* % */    ||
+      ch === 0x40/* @ */    ||
+      ch === 0x60/* ` */) {
+    return false;
+  }
+
+  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
+    following = state.input.charCodeAt(state.position + 1);
+
+    if (is_WS_OR_EOL(following) ||
+        withinFlowCollection && is_FLOW_INDICATOR(following)) {
+      return false;
+    }
+  }
+
+  state.kind = 'scalar';
+  state.result = '';
+  captureStart = captureEnd = state.position;
+  hasPendingContent = false;
+
+  while (ch !== 0) {
+    if (ch === 0x3A/* : */) {
+      following = state.input.charCodeAt(state.position + 1);
+
+      if (is_WS_OR_EOL(following) ||
+          withinFlowCollection && is_FLOW_INDICATOR(following)) {
+        break;
+      }
+
+    } else if (ch === 0x23/* # */) {
+      preceding = state.input.charCodeAt(state.position - 1);
+
+      if (is_WS_OR_EOL(preceding)) {
+        break;
+      }
+
+    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
+               withinFlowCollection && is_FLOW_INDICATOR(ch)) {
+      break;
+
+    } else if (is_EOL(ch)) {
+      _line = state.line;
+      _lineStart = state.lineStart;
+      _lineIndent = state.lineIndent;
+      skipSeparationSpace(state, false, -1);
+
+      if (state.lineIndent >= nodeIndent) {
+        hasPendingContent = true;
+        ch = state.input.charCodeAt(state.position);
+        continue;
+      } else {
+        state.position = captureEnd;
+        state.line = _line;
+        state.lineStart = _lineStart;
+        state.lineIndent = _lineIndent;
+        break;
+      }
+    }
+
+    if (hasPendingContent) {
+      captureSegment(state, captureStart, captureEnd, false);
+      writeFoldedLines(state, state.line - _line);
+      captureStart = captureEnd = state.position;
+      hasPendingContent = false;
+    }
+
+    if (!is_WHITE_SPACE(ch)) {
+      captureEnd = state.position + 1;
+    }
+
+    ch = state.input.charCodeAt(++state.position);
+  }
+
+  captureSegment(state, captureStart, captureEnd, false);
+
+  if (state.result) {
+    return true;
+  }
+
+  state.kind = _kind;
+  state.result = _result;
+  return false;
+}
+
+function readSingleQuotedScalar(state, nodeIndent) {
+  var ch,
+      captureStart, captureEnd;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x27/* ' */) {
+    return false;
+  }
+
+  state.kind = 'scalar';
+  state.result = '';
+  state.position++;
+  captureStart = captureEnd = state.position;
+
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    if (ch === 0x27/* ' */) {
+      captureSegment(state, captureStart, state.position, true);
+      ch = state.input.charCodeAt(++state.position);
+
+      if (ch === 0x27/* ' */) {
+        captureStart = state.position;
+        state.position++;
+        captureEnd = state.position;
+      } else {
+        return true;
+      }
+
+    } else if (is_EOL(ch)) {
+      captureSegment(state, captureStart, captureEnd, true);
+      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+      captureStart = captureEnd = state.position;
+
+    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+      throwError$1(state, 'unexpected end of the document within a single quoted scalar');
+
+    } else {
+      state.position++;
+      captureEnd = state.position;
+    }
+  }
+
+  throwError$1(state, 'unexpected end of the stream within a single quoted scalar');
+}
+
+function readDoubleQuotedScalar(state, nodeIndent) {
+  var captureStart,
+      captureEnd,
+      hexLength,
+      hexResult,
+      tmp,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x22/* " */) {
+    return false;
+  }
+
+  state.kind = 'scalar';
+  state.result = '';
+  state.position++;
+  captureStart = captureEnd = state.position;
+
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    if (ch === 0x22/* " */) {
+      captureSegment(state, captureStart, state.position, true);
+      state.position++;
+      return true;
+
+    } else if (ch === 0x5C/* \ */) {
+      captureSegment(state, captureStart, state.position, true);
+      ch = state.input.charCodeAt(++state.position);
+
+      if (is_EOL(ch)) {
+        skipSeparationSpace(state, false, nodeIndent);
+
+        // TODO: rework to inline fn with no type cast?
+      } else if (ch < 256 && simpleEscapeCheck[ch]) {
+        state.result += simpleEscapeMap[ch];
+        state.position++;
+
+      } else if ((tmp = escapedHexLen(ch)) > 0) {
+        hexLength = tmp;
+        hexResult = 0;
+
+        for (; hexLength > 0; hexLength--) {
+          ch = state.input.charCodeAt(++state.position);
+
+          if ((tmp = fromHexCode(ch)) >= 0) {
+            hexResult = (hexResult << 4) + tmp;
+
+          } else {
+            throwError$1(state, 'expected hexadecimal character');
+          }
+        }
+
+        state.result += charFromCodepoint(hexResult);
+
+        state.position++;
+
+      } else {
+        throwError$1(state, 'unknown escape sequence');
+      }
+
+      captureStart = captureEnd = state.position;
+
+    } else if (is_EOL(ch)) {
+      captureSegment(state, captureStart, captureEnd, true);
+      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+      captureStart = captureEnd = state.position;
+
+    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+      throwError$1(state, 'unexpected end of the document within a double quoted scalar');
+
+    } else {
+      state.position++;
+      captureEnd = state.position;
+    }
+  }
+
+  throwError$1(state, 'unexpected end of the stream within a double quoted scalar');
+}
+
+function readFlowCollection(state, nodeIndent) {
+  var readNext = true,
+      _line,
+      _lineStart,
+      _pos,
+      _tag     = state.tag,
+      _result,
+      _anchor  = state.anchor,
+      following,
+      terminator,
+      isPair,
+      isExplicitPair,
+      isMapping,
+      overridableKeys = Object.create(null),
+      keyNode,
+      keyTag,
+      valueNode,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch === 0x5B/* [ */) {
+    terminator = 0x5D;/* ] */
+    isMapping = false;
+    _result = [];
+  } else if (ch === 0x7B/* { */) {
+    terminator = 0x7D;/* } */
+    isMapping = true;
+    _result = {};
+  } else {
+    return false;
+  }
+
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+
+  ch = state.input.charCodeAt(++state.position);
+
+  while (ch !== 0) {
+    skipSeparationSpace(state, true, nodeIndent);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if (ch === terminator) {
+      state.position++;
+      state.tag = _tag;
+      state.anchor = _anchor;
+      state.kind = isMapping ? 'mapping' : 'sequence';
+      state.result = _result;
+      return true;
+    } else if (!readNext) {
+      throwError$1(state, 'missed comma between flow collection entries');
+    } else if (ch === 0x2C/* , */) {
+      // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
+      throwError$1(state, "expected the node content, but found ','");
+    }
+
+    keyTag = keyNode = valueNode = null;
+    isPair = isExplicitPair = false;
+
+    if (ch === 0x3F/* ? */) {
+      following = state.input.charCodeAt(state.position + 1);
+
+      if (is_WS_OR_EOL(following)) {
+        isPair = isExplicitPair = true;
+        state.position++;
+        skipSeparationSpace(state, true, nodeIndent);
+      }
+    }
+
+    _line = state.line; // Save the current line.
+    _lineStart = state.lineStart;
+    _pos = state.position;
+    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+    keyTag = state.tag;
+    keyNode = state.result;
+    skipSeparationSpace(state, true, nodeIndent);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
+      isPair = true;
+      ch = state.input.charCodeAt(++state.position);
+      skipSeparationSpace(state, true, nodeIndent);
+      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+      valueNode = state.result;
+    }
+
+    if (isMapping) {
+      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
+    } else if (isPair) {
+      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
+    } else {
+      _result.push(keyNode);
+    }
+
+    skipSeparationSpace(state, true, nodeIndent);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if (ch === 0x2C/* , */) {
+      readNext = true;
+      ch = state.input.charCodeAt(++state.position);
+    } else {
+      readNext = false;
+    }
+  }
+
+  throwError$1(state, 'unexpected end of the stream within a flow collection');
+}
+
+function readBlockScalar(state, nodeIndent) {
+  var captureStart,
+      folding,
+      chomping       = CHOMPING_CLIP,
+      didReadContent = false,
+      detectedIndent = false,
+      textIndent     = nodeIndent,
+      emptyLines     = 0,
+      atMoreIndented = false,
+      tmp,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch === 0x7C/* | */) {
+    folding = false;
+  } else if (ch === 0x3E/* > */) {
+    folding = true;
+  } else {
+    return false;
+  }
+
+  state.kind = 'scalar';
+  state.result = '';
+
+  while (ch !== 0) {
+    ch = state.input.charCodeAt(++state.position);
+
+    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
+      if (CHOMPING_CLIP === chomping) {
+        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
+      } else {
+        throwError$1(state, 'repeat of a chomping mode identifier');
+      }
+
+    } else if ((tmp = fromDecimalCode(ch)) >= 0) {
+      if (tmp === 0) {
+        throwError$1(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
+      } else if (!detectedIndent) {
+        textIndent = nodeIndent + tmp - 1;
+        detectedIndent = true;
+      } else {
+        throwError$1(state, 'repeat of an indentation width identifier');
+      }
+
+    } else {
+      break;
+    }
+  }
+
+  if (is_WHITE_SPACE(ch)) {
+    do { ch = state.input.charCodeAt(++state.position); }
+    while (is_WHITE_SPACE(ch));
+
+    if (ch === 0x23/* # */) {
+      do { ch = state.input.charCodeAt(++state.position); }
+      while (!is_EOL(ch) && (ch !== 0));
+    }
+  }
+
+  while (ch !== 0) {
+    readLineBreak(state);
+    state.lineIndent = 0;
+
+    ch = state.input.charCodeAt(state.position);
+
+    while ((!detectedIndent || state.lineIndent < textIndent) &&
+           (ch === 0x20/* Space */)) {
+      state.lineIndent++;
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    if (!detectedIndent && state.lineIndent > textIndent) {
+      textIndent = state.lineIndent;
+    }
+
+    if (is_EOL(ch)) {
+      emptyLines++;
+      continue;
+    }
+
+    // End of the scalar.
+    if (state.lineIndent < textIndent) {
+
+      // Perform the chomping.
+      if (chomping === CHOMPING_KEEP) {
+        state.result += common$4.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+      } else if (chomping === CHOMPING_CLIP) {
+        if (didReadContent) { // i.e. only if the scalar is not empty.
+          state.result += '\n';
+        }
+      }
+
+      // Break this `while` cycle and go to the funciton's epilogue.
+      break;
+    }
+
+    // Folded style: use fancy rules to handle line breaks.
+    if (folding) {
+
+      // Lines starting with white space characters (more-indented lines) are not folded.
+      if (is_WHITE_SPACE(ch)) {
+        atMoreIndented = true;
+        // except for the first content line (cf. Example 8.1)
+        state.result += common$4.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+
+      // End of more-indented block.
+      } else if (atMoreIndented) {
+        atMoreIndented = false;
+        state.result += common$4.repeat('\n', emptyLines + 1);
+
+      // Just one line break - perceive as the same line.
+      } else if (emptyLines === 0) {
+        if (didReadContent) { // i.e. only if we have already read some scalar content.
+          state.result += ' ';
+        }
+
+      // Several line breaks - perceive as different lines.
+      } else {
+        state.result += common$4.repeat('\n', emptyLines);
+      }
+
+    // Literal style: just add exact number of line breaks between content lines.
+    } else {
+      // Keep all line breaks except the header line break.
+      state.result += common$4.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+    }
+
+    didReadContent = true;
+    detectedIndent = true;
+    emptyLines = 0;
+    captureStart = state.position;
+
+    while (!is_EOL(ch) && (ch !== 0)) {
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    captureSegment(state, captureStart, state.position, false);
+  }
+
+  return true;
+}
+
+function readBlockSequence(state, nodeIndent) {
+  var _line,
+      _tag      = state.tag,
+      _anchor   = state.anchor,
+      _result   = [],
+      following,
+      detected  = false,
+      ch;
+
+  // there is a leading tab before this token, so it can't be a block sequence/mapping;
+  // it can still be flow sequence/mapping or a scalar
+  if (state.firstTabInLine !== -1) return false;
+
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+
+  ch = state.input.charCodeAt(state.position);
+
+  while (ch !== 0) {
+    if (state.firstTabInLine !== -1) {
+      state.position = state.firstTabInLine;
+      throwError$1(state, 'tab characters must not be used in indentation');
+    }
+
+    if (ch !== 0x2D/* - */) {
+      break;
+    }
+
+    following = state.input.charCodeAt(state.position + 1);
+
+    if (!is_WS_OR_EOL(following)) {
+      break;
+    }
+
+    detected = true;
+    state.position++;
+
+    if (skipSeparationSpace(state, true, -1)) {
+      if (state.lineIndent <= nodeIndent) {
+        _result.push(null);
+        ch = state.input.charCodeAt(state.position);
+        continue;
+      }
+    }
+
+    _line = state.line;
+    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
+    _result.push(state.result);
+    skipSeparationSpace(state, true, -1);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
+      throwError$1(state, 'bad indentation of a sequence entry');
+    } else if (state.lineIndent < nodeIndent) {
+      break;
+    }
+  }
+
+  if (detected) {
+    state.tag = _tag;
+    state.anchor = _anchor;
+    state.kind = 'sequence';
+    state.result = _result;
+    return true;
+  }
+  return false;
+}
+
+function readBlockMapping(state, nodeIndent, flowIndent) {
+  var following,
+      allowCompact,
+      _line,
+      _keyLine,
+      _keyLineStart,
+      _keyPos,
+      _tag          = state.tag,
+      _anchor       = state.anchor,
+      _result       = {},
+      overridableKeys = Object.create(null),
+      keyTag        = null,
+      keyNode       = null,
+      valueNode     = null,
+      atExplicitKey = false,
+      detected      = false,
+      ch;
+
+  // there is a leading tab before this token, so it can't be a block sequence/mapping;
+  // it can still be flow sequence/mapping or a scalar
+  if (state.firstTabInLine !== -1) return false;
+
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+
+  ch = state.input.charCodeAt(state.position);
+
+  while (ch !== 0) {
+    if (!atExplicitKey && state.firstTabInLine !== -1) {
+      state.position = state.firstTabInLine;
+      throwError$1(state, 'tab characters must not be used in indentation');
+    }
+
+    following = state.input.charCodeAt(state.position + 1);
+    _line = state.line; // Save the current line.
+
+    //
+    // Explicit notation case. There are two separate blocks:
+    // first for the key (denoted by "?") and second for the value (denoted by ":")
+    //
+    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
+
+      if (ch === 0x3F/* ? */) {
+        if (atExplicitKey) {
+          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+          keyTag = keyNode = valueNode = null;
+        }
+
+        detected = true;
+        atExplicitKey = true;
+        allowCompact = true;
+
+      } else if (atExplicitKey) {
+        // i.e. 0x3A/* : */ === character after the explicit key.
+        atExplicitKey = false;
+        allowCompact = true;
+
+      } else {
+        throwError$1(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
+      }
+
+      state.position += 1;
+      ch = following;
+
+    //
+    // Implicit notation case. Flow-style node as the key first, then ":", and the value.
+    //
+    } else {
+      _keyLine = state.line;
+      _keyLineStart = state.lineStart;
+      _keyPos = state.position;
+
+      if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
+        // Neither implicit nor explicit notation.
+        // Reading is done. Go to the epilogue.
+        break;
+      }
+
+      if (state.line === _line) {
+        ch = state.input.charCodeAt(state.position);
+
+        while (is_WHITE_SPACE(ch)) {
+          ch = state.input.charCodeAt(++state.position);
+        }
+
+        if (ch === 0x3A/* : */) {
+          ch = state.input.charCodeAt(++state.position);
+
+          if (!is_WS_OR_EOL(ch)) {
+            throwError$1(state, 'a whitespace character is expected after the key-value separator within a block mapping');
+          }
+
+          if (atExplicitKey) {
+            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+            keyTag = keyNode = valueNode = null;
+          }
+
+          detected = true;
+          atExplicitKey = false;
+          allowCompact = false;
+          keyTag = state.tag;
+          keyNode = state.result;
+
+        } else if (detected) {
+          throwError$1(state, 'can not read an implicit mapping pair; a colon is missed');
+
+        } else {
+          state.tag = _tag;
+          state.anchor = _anchor;
+          return true; // Keep the result of `composeNode`.
+        }
+
+      } else if (detected) {
+        throwError$1(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
+
+      } else {
+        state.tag = _tag;
+        state.anchor = _anchor;
+        return true; // Keep the result of `composeNode`.
+      }
+    }
+
+    //
+    // Common reading code for both explicit and implicit notations.
+    //
+    if (state.line === _line || state.lineIndent > nodeIndent) {
+      if (atExplicitKey) {
+        _keyLine = state.line;
+        _keyLineStart = state.lineStart;
+        _keyPos = state.position;
+      }
+
+      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+        if (atExplicitKey) {
+          keyNode = state.result;
+        } else {
+          valueNode = state.result;
+        }
+      }
+
+      if (!atExplicitKey) {
+        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
+        keyTag = keyNode = valueNode = null;
+      }
+
+      skipSeparationSpace(state, true, -1);
+      ch = state.input.charCodeAt(state.position);
+    }
+
+    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
+      throwError$1(state, 'bad indentation of a mapping entry');
+    } else if (state.lineIndent < nodeIndent) {
+      break;
+    }
+  }
+
+  //
+  // Epilogue.
+  //
+
+  // Special case: last mapping's node contains only the key in explicit notation.
+  if (atExplicitKey) {
+    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+  }
+
+  // Expose the resulting mapping.
+  if (detected) {
+    state.tag = _tag;
+    state.anchor = _anchor;
+    state.kind = 'mapping';
+    state.result = _result;
+  }
+
+  return detected;
+}
+
+function readTagProperty(state) {
+  var _position,
+      isVerbatim = false,
+      isNamed    = false,
+      tagHandle,
+      tagName,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x21/* ! */) return false;
+
+  if (state.tag !== null) {
+    throwError$1(state, 'duplication of a tag property');
+  }
+
+  ch = state.input.charCodeAt(++state.position);
+
+  if (ch === 0x3C/* < */) {
+    isVerbatim = true;
+    ch = state.input.charCodeAt(++state.position);
+
+  } else if (ch === 0x21/* ! */) {
+    isNamed = true;
+    tagHandle = '!!';
+    ch = state.input.charCodeAt(++state.position);
+
+  } else {
+    tagHandle = '!';
+  }
+
+  _position = state.position;
+
+  if (isVerbatim) {
+    do { ch = state.input.charCodeAt(++state.position); }
+    while (ch !== 0 && ch !== 0x3E/* > */);
+
+    if (state.position < state.length) {
+      tagName = state.input.slice(_position, state.position);
+      ch = state.input.charCodeAt(++state.position);
+    } else {
+      throwError$1(state, 'unexpected end of the stream within a verbatim tag');
+    }
+  } else {
+    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+
+      if (ch === 0x21/* ! */) {
+        if (!isNamed) {
+          tagHandle = state.input.slice(_position - 1, state.position + 1);
+
+          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
+            throwError$1(state, 'named tag handle cannot contain such characters');
+          }
+
+          isNamed = true;
+          _position = state.position + 1;
+        } else {
+          throwError$1(state, 'tag suffix cannot contain exclamation marks');
+        }
+      }
+
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    tagName = state.input.slice(_position, state.position);
+
+    if (PATTERN_FLOW_INDICATORS.test(tagName)) {
+      throwError$1(state, 'tag suffix cannot contain flow indicator characters');
+    }
+  }
+
+  if (tagName && !PATTERN_TAG_URI.test(tagName)) {
+    throwError$1(state, 'tag name cannot contain such characters: ' + tagName);
+  }
+
+  try {
+    tagName = decodeURIComponent(tagName);
+  } catch (err) {
+    throwError$1(state, 'tag name is malformed: ' + tagName);
+  }
+
+  if (isVerbatim) {
+    state.tag = tagName;
+
+  } else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) {
+    state.tag = state.tagMap[tagHandle] + tagName;
+
+  } else if (tagHandle === '!') {
+    state.tag = '!' + tagName;
+
+  } else if (tagHandle === '!!') {
+    state.tag = 'tag:yaml.org,2002:' + tagName;
+
+  } else {
+    throwError$1(state, 'undeclared tag handle "' + tagHandle + '"');
+  }
+
+  return true;
+}
+
+function readAnchorProperty(state) {
+  var _position,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x26/* & */) return false;
+
+  if (state.anchor !== null) {
+    throwError$1(state, 'duplication of an anchor property');
+  }
+
+  ch = state.input.charCodeAt(++state.position);
+  _position = state.position;
+
+  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
+    ch = state.input.charCodeAt(++state.position);
+  }
+
+  if (state.position === _position) {
+    throwError$1(state, 'name of an anchor node must contain at least one character');
+  }
+
+  state.anchor = state.input.slice(_position, state.position);
+  return true;
+}
+
+function readAlias(state) {
+  var _position, alias,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x2A/* * */) return false;
+
+  ch = state.input.charCodeAt(++state.position);
+  _position = state.position;
+
+  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
+    ch = state.input.charCodeAt(++state.position);
+  }
+
+  if (state.position === _position) {
+    throwError$1(state, 'name of an alias node must contain at least one character');
+  }
+
+  alias = state.input.slice(_position, state.position);
+
+  if (!_hasOwnProperty$1.call(state.anchorMap, alias)) {
+    throwError$1(state, 'unidentified alias "' + alias + '"');
+  }
+
+  state.result = state.anchorMap[alias];
+  skipSeparationSpace(state, true, -1);
+  return true;
+}
+
+function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+  var allowBlockStyles,
+      allowBlockScalars,
+      allowBlockCollections,
+      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
+      atNewLine  = false,
+      hasContent = false,
+      typeIndex,
+      typeQuantity,
+      typeList,
+      type,
+      flowIndent,
+      blockIndent;
+
+  if (state.listener !== null) {
+    state.listener('open', state);
+  }
+
+  state.tag    = null;
+  state.anchor = null;
+  state.kind   = null;
+  state.result = null;
+
+  allowBlockStyles = allowBlockScalars = allowBlockCollections =
+    CONTEXT_BLOCK_OUT === nodeContext ||
+    CONTEXT_BLOCK_IN  === nodeContext;
+
+  if (allowToSeek) {
+    if (skipSeparationSpace(state, true, -1)) {
+      atNewLine = true;
+
+      if (state.lineIndent > parentIndent) {
+        indentStatus = 1;
+      } else if (state.lineIndent === parentIndent) {
+        indentStatus = 0;
+      } else if (state.lineIndent < parentIndent) {
+        indentStatus = -1;
+      }
+    }
+  }
+
+  if (indentStatus === 1) {
+    while (readTagProperty(state) || readAnchorProperty(state)) {
+      if (skipSeparationSpace(state, true, -1)) {
+        atNewLine = true;
+        allowBlockCollections = allowBlockStyles;
+
+        if (state.lineIndent > parentIndent) {
+          indentStatus = 1;
+        } else if (state.lineIndent === parentIndent) {
+          indentStatus = 0;
+        } else if (state.lineIndent < parentIndent) {
+          indentStatus = -1;
+        }
+      } else {
+        allowBlockCollections = false;
+      }
+    }
+  }
+
+  if (allowBlockCollections) {
+    allowBlockCollections = atNewLine || allowCompact;
+  }
+
+  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
+    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
+      flowIndent = parentIndent;
+    } else {
+      flowIndent = parentIndent + 1;
+    }
+
+    blockIndent = state.position - state.lineStart;
+
+    if (indentStatus === 1) {
+      if (allowBlockCollections &&
+          (readBlockSequence(state, blockIndent) ||
+           readBlockMapping(state, blockIndent, flowIndent)) ||
+          readFlowCollection(state, flowIndent)) {
+        hasContent = true;
+      } else {
+        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
+            readSingleQuotedScalar(state, flowIndent) ||
+            readDoubleQuotedScalar(state, flowIndent)) {
+          hasContent = true;
+
+        } else if (readAlias(state)) {
+          hasContent = true;
+
+          if (state.tag !== null || state.anchor !== null) {
+            throwError$1(state, 'alias node should not have any properties');
+          }
+
+        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+          hasContent = true;
+
+          if (state.tag === null) {
+            state.tag = '?';
+          }
+        }
+
+        if (state.anchor !== null) {
+          state.anchorMap[state.anchor] = state.result;
+        }
+      }
+    } else if (indentStatus === 0) {
+      // Special case: block sequences are allowed to have same indentation level as the parent.
+      // http://www.yaml.org/spec/1.2/spec.html#id2799784
+      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+    }
+  }
+
+  if (state.tag === null) {
+    if (state.anchor !== null) {
+      state.anchorMap[state.anchor] = state.result;
+    }
+
+  } else if (state.tag === '?') {
+    // Implicit resolving is not allowed for non-scalar types, and '?'
+    // non-specific tag is only automatically assigned to plain scalars.
+    //
+    // We only need to check kind conformity in case user explicitly assigns '?'
+    // tag, for example like this: "!<?> [0]"
+    //
+    if (state.result !== null && state.kind !== 'scalar') {
+      throwError$1(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+    }
+
+    for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
+      type = state.implicitTypes[typeIndex];
+
+      if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
+        state.result = type.construct(state.result);
+        state.tag = type.tag;
+        if (state.anchor !== null) {
+          state.anchorMap[state.anchor] = state.result;
+        }
+        break;
+      }
+    }
+  } else if (state.tag !== '!') {
+    if (_hasOwnProperty$1.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
+      type = state.typeMap[state.kind || 'fallback'][state.tag];
+    } else {
+      // looking for multi type
+      type = null;
+      typeList = state.typeMap.multi[state.kind || 'fallback'];
+
+      for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
+        if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
+          type = typeList[typeIndex];
+          break;
+        }
+      }
+    }
+
+    if (!type) {
+      throwError$1(state, 'unknown tag !<' + state.tag + '>');
+    }
+
+    if (state.result !== null && type.kind !== state.kind) {
+      throwError$1(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
+    }
+
+    if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
+      throwError$1(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
+    } else {
+      state.result = type.construct(state.result, state.tag);
+      if (state.anchor !== null) {
+        state.anchorMap[state.anchor] = state.result;
+      }
+    }
+  }
+
+  if (state.listener !== null) {
+    state.listener('close', state);
+  }
+  return state.tag !== null ||  state.anchor !== null || hasContent;
+}
+
+function readDocument(state) {
+  var documentStart = state.position,
+      _position,
+      directiveName,
+      directiveArgs,
+      hasDirectives = false,
+      ch;
+
+  state.version = null;
+  state.checkLineBreaks = state.legacy;
+  state.tagMap = Object.create(null);
+  state.anchorMap = Object.create(null);
+
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    skipSeparationSpace(state, true, -1);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if (state.lineIndent > 0 || ch !== 0x25/* % */) {
+      break;
+    }
+
+    hasDirectives = true;
+    ch = state.input.charCodeAt(++state.position);
+    _position = state.position;
+
+    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    directiveName = state.input.slice(_position, state.position);
+    directiveArgs = [];
+
+    if (directiveName.length < 1) {
+      throwError$1(state, 'directive name must not be less than one character in length');
+    }
+
+    while (ch !== 0) {
+      while (is_WHITE_SPACE(ch)) {
+        ch = state.input.charCodeAt(++state.position);
+      }
+
+      if (ch === 0x23/* # */) {
+        do { ch = state.input.charCodeAt(++state.position); }
+        while (ch !== 0 && !is_EOL(ch));
+        break;
+      }
+
+      if (is_EOL(ch)) break;
+
+      _position = state.position;
+
+      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+        ch = state.input.charCodeAt(++state.position);
+      }
+
+      directiveArgs.push(state.input.slice(_position, state.position));
+    }
+
+    if (ch !== 0) readLineBreak(state);
+
+    if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) {
+      directiveHandlers[directiveName](state, directiveName, directiveArgs);
+    } else {
+      throwWarning(state, 'unknown document directive "' + directiveName + '"');
+    }
+  }
+
+  skipSeparationSpace(state, true, -1);
+
+  if (state.lineIndent === 0 &&
+      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&
+      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
+      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
+    state.position += 3;
+    skipSeparationSpace(state, true, -1);
+
+  } else if (hasDirectives) {
+    throwError$1(state, 'directives end mark is expected');
+  }
+
+  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+  skipSeparationSpace(state, true, -1);
+
+  if (state.checkLineBreaks &&
+      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
+    throwWarning(state, 'non-ASCII line breaks are interpreted as content');
+  }
+
+  state.documents.push(state.result);
+
+  if (state.position === state.lineStart && testDocumentSeparator(state)) {
+
+    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
+      state.position += 3;
+      skipSeparationSpace(state, true, -1);
+    }
+    return;
+  }
+
+  if (state.position < (state.length - 1)) {
+    throwError$1(state, 'end of the stream or a document separator is expected');
+  } else {
+    return;
+  }
+}
+
+
+function loadDocuments(input, options) {
+  input = String(input);
+  options = options || {};
+
+  if (input.length !== 0) {
+
+    // Add tailing `\n` if not exists
+    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
+        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
+      input += '\n';
+    }
+
+    // Strip BOM
+    if (input.charCodeAt(0) === 0xFEFF) {
+      input = input.slice(1);
+    }
+  }
+
+  var state = new State$1(input, options);
+
+  var nullpos = input.indexOf('\0');
+
+  if (nullpos !== -1) {
+    state.position = nullpos;
+    throwError$1(state, 'null byte is not allowed in input');
+  }
+
+  // Use 0 as string terminator. That significantly simplifies bounds check.
+  state.input += '\0';
+
+  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
+    state.lineIndent += 1;
+    state.position += 1;
+  }
+
+  while (state.position < (state.length - 1)) {
+    readDocument(state);
+  }
+
+  return state.documents;
+}
+
+
+function loadAll$1(input, iterator, options) {
+  if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
+    options = iterator;
+    iterator = null;
+  }
+
+  var documents = loadDocuments(input, options);
+
+  if (typeof iterator !== 'function') {
+    return documents;
+  }
+
+  for (var index = 0, length = documents.length; index < length; index += 1) {
+    iterator(documents[index]);
+  }
+}
+
+
+function load$1(input, options) {
+  var documents = loadDocuments(input, options);
+
+  if (documents.length === 0) {
+    /*eslint-disable no-undefined*/
+    return undefined;
+  } else if (documents.length === 1) {
+    return documents[0];
+  }
+  throw new exception('expected a single document in the stream, but found more');
+}
+
+
+var loadAll_1 = loadAll$1;
+var load_1    = load$1;
+
+var loader = {
+	loadAll: loadAll_1,
+	load: load_1
+};
+
+/*eslint-disable no-use-before-define*/
+
+
+
+
+
+var _toString       = Object.prototype.toString;
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var CHAR_BOM                  = 0xFEFF;
+var CHAR_TAB                  = 0x09; /* Tab */
+var CHAR_LINE_FEED            = 0x0A; /* LF */
+var CHAR_CARRIAGE_RETURN      = 0x0D; /* CR */
+var CHAR_SPACE                = 0x20; /* Space */
+var CHAR_EXCLAMATION          = 0x21; /* ! */
+var CHAR_DOUBLE_QUOTE         = 0x22; /* " */
+var CHAR_SHARP                = 0x23; /* # */
+var CHAR_PERCENT              = 0x25; /* % */
+var CHAR_AMPERSAND            = 0x26; /* & */
+var CHAR_SINGLE_QUOTE         = 0x27; /* ' */
+var CHAR_ASTERISK             = 0x2A; /* * */
+var CHAR_COMMA                = 0x2C; /* , */
+var CHAR_MINUS                = 0x2D; /* - */
+var CHAR_COLON                = 0x3A; /* : */
+var CHAR_EQUALS               = 0x3D; /* = */
+var CHAR_GREATER_THAN         = 0x3E; /* > */
+var CHAR_QUESTION             = 0x3F; /* ? */
+var CHAR_COMMERCIAL_AT        = 0x40; /* @ */
+var CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */
+var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
+var CHAR_GRAVE_ACCENT         = 0x60; /* ` */
+var CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */
+var CHAR_VERTICAL_LINE        = 0x7C; /* | */
+var CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */
+
+var ESCAPE_SEQUENCES = {};
+
+ESCAPE_SEQUENCES[0x00]   = '\\0';
+ESCAPE_SEQUENCES[0x07]   = '\\a';
+ESCAPE_SEQUENCES[0x08]   = '\\b';
+ESCAPE_SEQUENCES[0x09]   = '\\t';
+ESCAPE_SEQUENCES[0x0A]   = '\\n';
+ESCAPE_SEQUENCES[0x0B]   = '\\v';
+ESCAPE_SEQUENCES[0x0C]   = '\\f';
+ESCAPE_SEQUENCES[0x0D]   = '\\r';
+ESCAPE_SEQUENCES[0x1B]   = '\\e';
+ESCAPE_SEQUENCES[0x22]   = '\\"';
+ESCAPE_SEQUENCES[0x5C]   = '\\\\';
+ESCAPE_SEQUENCES[0x85]   = '\\N';
+ESCAPE_SEQUENCES[0xA0]   = '\\_';
+ESCAPE_SEQUENCES[0x2028] = '\\L';
+ESCAPE_SEQUENCES[0x2029] = '\\P';
+
+var DEPRECATED_BOOLEANS_SYNTAX = [
+  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
+  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
+];
+
+var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+
+function compileStyleMap(schema, map) {
+  var result, keys, index, length, tag, style, type;
+
+  if (map === null) return {};
+
+  result = {};
+  keys = Object.keys(map);
+
+  for (index = 0, length = keys.length; index < length; index += 1) {
+    tag = keys[index];
+    style = String(map[tag]);
+
+    if (tag.slice(0, 2) === '!!') {
+      tag = 'tag:yaml.org,2002:' + tag.slice(2);
+    }
+    type = schema.compiledTypeMap['fallback'][tag];
+
+    if (type && _hasOwnProperty.call(type.styleAliases, style)) {
+      style = type.styleAliases[style];
+    }
+
+    result[tag] = style;
+  }
+
+  return result;
+}
+
+function encodeHex(character) {
+  var string, handle, length;
+
+  string = character.toString(16).toUpperCase();
+
+  if (character <= 0xFF) {
+    handle = 'x';
+    length = 2;
+  } else if (character <= 0xFFFF) {
+    handle = 'u';
+    length = 4;
+  } else if (character <= 0xFFFFFFFF) {
+    handle = 'U';
+    length = 8;
+  } else {
+    throw new exception('code point within a string may not be greater than 0xFFFFFFFF');
+  }
+
+  return '\\' + handle + common$4.repeat('0', length - string.length) + string;
+}
+
+
+var QUOTING_TYPE_SINGLE = 1,
+    QUOTING_TYPE_DOUBLE = 2;
+
+function State(options) {
+  this.schema        = options['schema'] || _default$1;
+  this.indent        = Math.max(1, (options['indent'] || 2));
+  this.noArrayIndent = options['noArrayIndent'] || false;
+  this.skipInvalid   = options['skipInvalid'] || false;
+  this.flowLevel     = (common$4.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
+  this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);
+  this.sortKeys      = options['sortKeys'] || false;
+  this.lineWidth     = options['lineWidth'] || 80;
+  this.noRefs        = options['noRefs'] || false;
+  this.noCompatMode  = options['noCompatMode'] || false;
+  this.condenseFlow  = options['condenseFlow'] || false;
+  this.quotingType   = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
+  this.forceQuotes   = options['forceQuotes'] || false;
+  this.replacer      = typeof options['replacer'] === 'function' ? options['replacer'] : null;
+
+  this.implicitTypes = this.schema.compiledImplicit;
+  this.explicitTypes = this.schema.compiledExplicit;
+
+  this.tag = null;
+  this.result = '';
+
+  this.duplicates = [];
+  this.usedDuplicates = null;
+}
+
+// Indents every line in a string. Empty lines (\n only) are not indented.
+function indentString(string, spaces) {
+  var ind = common$4.repeat(' ', spaces),
+      position = 0,
+      next = -1,
+      result = '',
+      line,
+      length = string.length;
+
+  while (position < length) {
+    next = string.indexOf('\n', position);
+    if (next === -1) {
+      line = string.slice(position);
+      position = length;
+    } else {
+      line = string.slice(position, next + 1);
+      position = next + 1;
+    }
+
+    if (line.length && line !== '\n') result += ind;
+
+    result += line;
+  }
+
+  return result;
+}
+
+function generateNextLine(state, level) {
+  return '\n' + common$4.repeat(' ', state.indent * level);
+}
+
+function testImplicitResolving(state, str) {
+  var index, length, type;
+
+  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
+    type = state.implicitTypes[index];
+
+    if (type.resolve(str)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// [33] s-white ::= s-space | s-tab
+function isWhitespace(c) {
+  return c === CHAR_SPACE || c === CHAR_TAB;
+}
+
+// Returns true if the character can be printed without escaping.
+// From YAML 1.2: "any allowed characters known to be non-printable
+// should also be escaped. [However,] This isn’t mandatory"
+// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
+function isPrintable(c) {
+  return  (0x00020 <= c && c <= 0x00007E)
+      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
+      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM)
+      ||  (0x10000 <= c && c <= 0x10FFFF);
+}
+
+// [34] ns-char ::= nb-char - s-white
+// [27] nb-char ::= c-printable - b-char - c-byte-order-mark
+// [26] b-char  ::= b-line-feed | b-carriage-return
+// Including s-white (for some reason, examples doesn't match specs in this aspect)
+// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
+function isNsCharOrWhitespace(c) {
+  return isPrintable(c)
+    && c !== CHAR_BOM
+    // - b-char
+    && c !== CHAR_CARRIAGE_RETURN
+    && c !== CHAR_LINE_FEED;
+}
+
+// [127]  ns-plain-safe(c) ::= c = flow-out  ⇒ ns-plain-safe-out
+//                             c = flow-in   ⇒ ns-plain-safe-in
+//                             c = block-key ⇒ ns-plain-safe-out
+//                             c = flow-key  ⇒ ns-plain-safe-in
+// [128] ns-plain-safe-out ::= ns-char
+// [129]  ns-plain-safe-in ::= ns-char - c-flow-indicator
+// [130]  ns-plain-char(c) ::=  ( ns-plain-safe(c) - “:” - “#” )
+//                            | ( /* An ns-char preceding */ “#” )
+//                            | ( “:” /* Followed by an ns-plain-safe(c) */ )
+function isPlainSafe(c, prev, inblock) {
+  var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
+  var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
+  return (
+    // ns-plain-safe
+    inblock ? // c = flow-in
+      cIsNsCharOrWhitespace
+      : cIsNsCharOrWhitespace
+        // - c-flow-indicator
+        && c !== CHAR_COMMA
+        && c !== CHAR_LEFT_SQUARE_BRACKET
+        && c !== CHAR_RIGHT_SQUARE_BRACKET
+        && c !== CHAR_LEFT_CURLY_BRACKET
+        && c !== CHAR_RIGHT_CURLY_BRACKET
+  )
+    // ns-plain-char
+    && c !== CHAR_SHARP // false on '#'
+    && !(prev === CHAR_COLON && !cIsNsChar) // false on ': '
+    || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#'
+    || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]'
+}
+
+// Simplified test for values allowed as the first character in plain style.
+function isPlainSafeFirst(c) {
+  // Uses a subset of ns-char - c-indicator
+  // where ns-char = nb-char - s-white.
+  // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
+  return isPrintable(c) && c !== CHAR_BOM
+    && !isWhitespace(c) // - s-white
+    // - (c-indicator ::=
+    // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
+    && c !== CHAR_MINUS
+    && c !== CHAR_QUESTION
+    && c !== CHAR_COLON
+    && c !== CHAR_COMMA
+    && c !== CHAR_LEFT_SQUARE_BRACKET
+    && c !== CHAR_RIGHT_SQUARE_BRACKET
+    && c !== CHAR_LEFT_CURLY_BRACKET
+    && c !== CHAR_RIGHT_CURLY_BRACKET
+    // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
+    && c !== CHAR_SHARP
+    && c !== CHAR_AMPERSAND
+    && c !== CHAR_ASTERISK
+    && c !== CHAR_EXCLAMATION
+    && c !== CHAR_VERTICAL_LINE
+    && c !== CHAR_EQUALS
+    && c !== CHAR_GREATER_THAN
+    && c !== CHAR_SINGLE_QUOTE
+    && c !== CHAR_DOUBLE_QUOTE
+    // | “%” | “@” | “`”)
+    && c !== CHAR_PERCENT
+    && c !== CHAR_COMMERCIAL_AT
+    && c !== CHAR_GRAVE_ACCENT;
+}
+
+// Simplified test for values allowed as the last character in plain style.
+function isPlainSafeLast(c) {
+  // just not whitespace or colon, it will be checked to be plain character later
+  return !isWhitespace(c) && c !== CHAR_COLON;
+}
+
+// Same as 'string'.codePointAt(pos), but works in older browsers.
+function codePointAt(string, pos) {
+  var first = string.charCodeAt(pos), second;
+  if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
+    second = string.charCodeAt(pos + 1);
+    if (second >= 0xDC00 && second <= 0xDFFF) {
+      // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+      return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+    }
+  }
+  return first;
+}
+
+// Determines whether block indentation indicator is required.
+function needIndentIndicator(string) {
+  var leadingSpaceRe = /^\n* /;
+  return leadingSpaceRe.test(string);
+}
+
+var STYLE_PLAIN   = 1,
+    STYLE_SINGLE  = 2,
+    STYLE_LITERAL = 3,
+    STYLE_FOLDED  = 4,
+    STYLE_DOUBLE  = 5;
+
+// Determines which scalar styles are possible and returns the preferred style.
+// lineWidth = -1 => no limit.
+// Pre-conditions: str.length > 0.
+// Post-conditions:
+//    STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
+//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
+//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
+function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth,
+  testAmbiguousType, quotingType, forceQuotes, inblock) {
+
+  var i;
+  var char = 0;
+  var prevChar = null;
+  var hasLineBreak = false;
+  var hasFoldableLine = false; // only checked if shouldTrackWidth
+  var shouldTrackWidth = lineWidth !== -1;
+  var previousLineBreak = -1; // count the first line correctly
+  var plain = isPlainSafeFirst(codePointAt(string, 0))
+          && isPlainSafeLast(codePointAt(string, string.length - 1));
+
+  if (singleLineOnly || forceQuotes) {
+    // Case: no block styles.
+    // Check for disallowed characters to rule out plain and single.
+    for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
+      char = codePointAt(string, i);
+      if (!isPrintable(char)) {
+        return STYLE_DOUBLE;
+      }
+      plain = plain && isPlainSafe(char, prevChar, inblock);
+      prevChar = char;
+    }
+  } else {
+    // Case: block styles permitted.
+    for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
+      char = codePointAt(string, i);
+      if (char === CHAR_LINE_FEED) {
+        hasLineBreak = true;
+        // Check if any line can be folded.
+        if (shouldTrackWidth) {
+          hasFoldableLine = hasFoldableLine ||
+            // Foldable line = too long, and not more-indented.
+            (i - previousLineBreak - 1 > lineWidth &&
+             string[previousLineBreak + 1] !== ' ');
+          previousLineBreak = i;
+        }
+      } else if (!isPrintable(char)) {
+        return STYLE_DOUBLE;
+      }
+      plain = plain && isPlainSafe(char, prevChar, inblock);
+      prevChar = char;
+    }
+    // in case the end is missing a \n
+    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
+      (i - previousLineBreak - 1 > lineWidth &&
+       string[previousLineBreak + 1] !== ' '));
+  }
+  // Although every style can represent \n without escaping, prefer block styles
+  // for multiline, since they're more readable and they don't add empty lines.
+  // Also prefer folding a super-long line.
+  if (!hasLineBreak && !hasFoldableLine) {
+    // Strings interpretable as another type have to be quoted;
+    // e.g. the string 'true' vs. the boolean true.
+    if (plain && !forceQuotes && !testAmbiguousType(string)) {
+      return STYLE_PLAIN;
+    }
+    return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+  }
+  // Edge case: block indentation indicator can only have one digit.
+  if (indentPerLevel > 9 && needIndentIndicator(string)) {
+    return STYLE_DOUBLE;
+  }
+  // At this point we know block styles are valid.
+  // Prefer literal style unless we want to fold.
+  if (!forceQuotes) {
+    return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+  }
+  return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+}
+
+// Note: line breaking/folding is implemented for only the folded style.
+// NB. We drop the last trailing newline (if any) of a returned block scalar
+//  since the dumper adds its own newline. This always works:
+//    • No ending newline => unaffected; already using strip "-" chomping.
+//    • Ending newline    => removed then restored.
+//  Importantly, this keeps the "+" chomp indicator from gaining an extra line.
+function writeScalar(state, string, level, iskey, inblock) {
+  state.dump = (function () {
+    if (string.length === 0) {
+      return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
+    }
+    if (!state.noCompatMode) {
+      if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
+        return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'");
+      }
+    }
+
+    var indent = state.indent * Math.max(1, level); // no 0-indent scalars
+    // As indentation gets deeper, let the width decrease monotonically
+    // to the lower bound min(state.lineWidth, 40).
+    // Note that this implies
+    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
+    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.
+    // This behaves better than a constant minimum width which disallows narrower options,
+    // or an indent threshold which causes the width to suddenly increase.
+    var lineWidth = state.lineWidth === -1
+      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+
+    // Without knowing if keys are implicit/explicit, assume implicit for safety.
+    var singleLineOnly = iskey
+      // No block styles in flow mode.
+      || (state.flowLevel > -1 && level >= state.flowLevel);
+    function testAmbiguity(string) {
+      return testImplicitResolving(state, string);
+    }
+
+    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
+      testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
+
+      case STYLE_PLAIN:
+        return string;
+      case STYLE_SINGLE:
+        return "'" + string.replace(/'/g, "''") + "'";
+      case STYLE_LITERAL:
+        return '|' + blockHeader(string, state.indent)
+          + dropEndingNewline(indentString(string, indent));
+      case STYLE_FOLDED:
+        return '>' + blockHeader(string, state.indent)
+          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
+      case STYLE_DOUBLE:
+        return '"' + escapeString(string) + '"';
+      default:
+        throw new exception('impossible error: invalid scalar style');
+    }
+  }());
+}
+
+// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
+function blockHeader(string, indentPerLevel) {
+  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
+
+  // note the special case: the string '\n' counts as a "trailing" empty line.
+  var clip =          string[string.length - 1] === '\n';
+  var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
+  var chomp = keep ? '+' : (clip ? '' : '-');
+
+  return indentIndicator + chomp + '\n';
+}
+
+// (See the note for writeScalar.)
+function dropEndingNewline(string) {
+  return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
+}
+
+// Note: a long line without a suitable break point will exceed the width limit.
+// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
+function foldString(string, width) {
+  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
+  // unless they're before or after a more-indented line, or at the very
+  // beginning or end, in which case $k$ maps to $k$.
+  // Therefore, parse each chunk as newline(s) followed by a content line.
+  var lineRe = /(\n+)([^\n]*)/g;
+
+  // first line (possibly an empty line)
+  var result = (function () {
+    var nextLF = string.indexOf('\n');
+    nextLF = nextLF !== -1 ? nextLF : string.length;
+    lineRe.lastIndex = nextLF;
+    return foldLine(string.slice(0, nextLF), width);
+  }());
+  // If we haven't reached the first content line yet, don't add an extra \n.
+  var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
+  var moreIndented;
+
+  // rest of the lines
+  var match;
+  while ((match = lineRe.exec(string))) {
+    var prefix = match[1], line = match[2];
+    moreIndented = (line[0] === ' ');
+    result += prefix
+      + (!prevMoreIndented && !moreIndented && line !== ''
+        ? '\n' : '')
+      + foldLine(line, width);
+    prevMoreIndented = moreIndented;
+  }
+
+  return result;
+}
+
+// Greedy line breaking.
+// Picks the longest line under the limit each time,
+// otherwise settles for the shortest line over the limit.
+// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
+function foldLine(line, width) {
+  if (line === '' || line[0] === ' ') return line;
+
+  // Since a more-indented line adds a \n, breaks can't be followed by a space.
+  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
+  var match;
+  // start is an inclusive index. end, curr, and next are exclusive.
+  var start = 0, end, curr = 0, next = 0;
+  var result = '';
+
+  // Invariants: 0 <= start <= length-1.
+  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.
+  // Inside the loop:
+  //   A match implies length >= 2, so curr and next are <= length-2.
+  while ((match = breakRe.exec(line))) {
+    next = match.index;
+    // maintain invariant: curr - start <= width
+    if (next - start > width) {
+      end = (curr > start) ? curr : next; // derive end <= length-2
+      result += '\n' + line.slice(start, end);
+      // skip the space that was output as \n
+      start = end + 1;                    // derive start <= length-1
+    }
+    curr = next;
+  }
+
+  // By the invariants, start <= length-1, so there is something left over.
+  // It is either the whole string or a part starting from non-whitespace.
+  result += '\n';
+  // Insert a break if the remainder is too long and there is a break available.
+  if (line.length - start > width && curr > start) {
+    result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
+  } else {
+    result += line.slice(start);
+  }
+
+  return result.slice(1); // drop extra \n joiner
+}
+
+// Escapes a double-quoted string.
+function escapeString(string) {
+  var result = '';
+  var char = 0;
+  var escapeSeq;
+
+  for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
+    char = codePointAt(string, i);
+    escapeSeq = ESCAPE_SEQUENCES[char];
+
+    if (!escapeSeq && isPrintable(char)) {
+      result += string[i];
+      if (char >= 0x10000) result += string[i + 1];
+    } else {
+      result += escapeSeq || encodeHex(char);
+    }
+  }
+
+  return result;
+}
+
+function writeFlowSequence(state, level, object) {
+  var _result = '',
+      _tag    = state.tag,
+      index,
+      length,
+      value;
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    value = object[index];
+
+    if (state.replacer) {
+      value = state.replacer.call(object, String(index), value);
+    }
+
+    // Write only valid elements, put null instead of invalid elements.
+    if (writeNode(state, level, value, false, false) ||
+        (typeof value === 'undefined' &&
+         writeNode(state, level, null, false, false))) {
+
+      if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '');
+      _result += state.dump;
+    }
+  }
+
+  state.tag = _tag;
+  state.dump = '[' + _result + ']';
+}
+
+function writeBlockSequence(state, level, object, compact) {
+  var _result = '',
+      _tag    = state.tag,
+      index,
+      length,
+      value;
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    value = object[index];
+
+    if (state.replacer) {
+      value = state.replacer.call(object, String(index), value);
+    }
+
+    // Write only valid elements, put null instead of invalid elements.
+    if (writeNode(state, level + 1, value, true, true, false, true) ||
+        (typeof value === 'undefined' &&
+         writeNode(state, level + 1, null, true, true, false, true))) {
+
+      if (!compact || _result !== '') {
+        _result += generateNextLine(state, level);
+      }
+
+      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+        _result += '-';
+      } else {
+        _result += '- ';
+      }
+
+      _result += state.dump;
+    }
+  }
+
+  state.tag = _tag;
+  state.dump = _result || '[]'; // Empty sequence if no valid values.
+}
+
+function writeFlowMapping(state, level, object) {
+  var _result       = '',
+      _tag          = state.tag,
+      objectKeyList = Object.keys(object),
+      index,
+      length,
+      objectKey,
+      objectValue,
+      pairBuffer;
+
+  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+
+    pairBuffer = '';
+    if (_result !== '') pairBuffer += ', ';
+
+    if (state.condenseFlow) pairBuffer += '"';
+
+    objectKey = objectKeyList[index];
+    objectValue = object[objectKey];
+
+    if (state.replacer) {
+      objectValue = state.replacer.call(object, objectKey, objectValue);
+    }
+
+    if (!writeNode(state, level, objectKey, false, false)) {
+      continue; // Skip this pair because of invalid key;
+    }
+
+    if (state.dump.length > 1024) pairBuffer += '? ';
+
+    pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
+
+    if (!writeNode(state, level, objectValue, false, false)) {
+      continue; // Skip this pair because of invalid value.
+    }
+
+    pairBuffer += state.dump;
+
+    // Both key and value are valid.
+    _result += pairBuffer;
+  }
+
+  state.tag = _tag;
+  state.dump = '{' + _result + '}';
+}
+
+function writeBlockMapping(state, level, object, compact) {
+  var _result       = '',
+      _tag          = state.tag,
+      objectKeyList = Object.keys(object),
+      index,
+      length,
+      objectKey,
+      objectValue,
+      explicitPair,
+      pairBuffer;
+
+  // Allow sorting keys so that the output file is deterministic
+  if (state.sortKeys === true) {
+    // Default sorting
+    objectKeyList.sort();
+  } else if (typeof state.sortKeys === 'function') {
+    // Custom sort function
+    objectKeyList.sort(state.sortKeys);
+  } else if (state.sortKeys) {
+    // Something is wrong
+    throw new exception('sortKeys must be a boolean or a function');
+  }
+
+  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+    pairBuffer = '';
+
+    if (!compact || _result !== '') {
+      pairBuffer += generateNextLine(state, level);
+    }
+
+    objectKey = objectKeyList[index];
+    objectValue = object[objectKey];
+
+    if (state.replacer) {
+      objectValue = state.replacer.call(object, objectKey, objectValue);
+    }
+
+    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
+      continue; // Skip this pair because of invalid key.
+    }
+
+    explicitPair = (state.tag !== null && state.tag !== '?') ||
+                   (state.dump && state.dump.length > 1024);
+
+    if (explicitPair) {
+      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+        pairBuffer += '?';
+      } else {
+        pairBuffer += '? ';
+      }
+    }
+
+    pairBuffer += state.dump;
+
+    if (explicitPair) {
+      pairBuffer += generateNextLine(state, level);
+    }
+
+    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
+      continue; // Skip this pair because of invalid value.
+    }
+
+    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+      pairBuffer += ':';
+    } else {
+      pairBuffer += ': ';
+    }
+
+    pairBuffer += state.dump;
+
+    // Both key and value are valid.
+    _result += pairBuffer;
+  }
+
+  state.tag = _tag;
+  state.dump = _result || '{}'; // Empty mapping if no valid pairs.
+}
+
+function detectType(state, object, explicit) {
+  var _result, typeList, index, length, type, style;
+
+  typeList = explicit ? state.explicitTypes : state.implicitTypes;
+
+  for (index = 0, length = typeList.length; index < length; index += 1) {
+    type = typeList[index];
+
+    if ((type.instanceOf  || type.predicate) &&
+        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
+        (!type.predicate  || type.predicate(object))) {
+
+      if (explicit) {
+        if (type.multi && type.representName) {
+          state.tag = type.representName(object);
+        } else {
+          state.tag = type.tag;
+        }
+      } else {
+        state.tag = '?';
+      }
+
+      if (type.represent) {
+        style = state.styleMap[type.tag] || type.defaultStyle;
+
+        if (_toString.call(type.represent) === '[object Function]') {
+          _result = type.represent(object, style);
+        } else if (_hasOwnProperty.call(type.represent, style)) {
+          _result = type.represent[style](object, style);
+        } else {
+          throw new exception('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
+        }
+
+        state.dump = _result;
+      }
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Serializes `object` and writes it to global `result`.
+// Returns true on success, or false on invalid object.
+//
+function writeNode(state, level, object, block, compact, iskey, isblockseq) {
+  state.tag = null;
+  state.dump = object;
+
+  if (!detectType(state, object, false)) {
+    detectType(state, object, true);
+  }
+
+  var type = _toString.call(state.dump);
+  var inblock = block;
+  var tagStr;
+
+  if (block) {
+    block = (state.flowLevel < 0 || state.flowLevel > level);
+  }
+
+  var objectOrArray = type === '[object Object]' || type === '[object Array]',
+      duplicateIndex,
+      duplicate;
+
+  if (objectOrArray) {
+    duplicateIndex = state.duplicates.indexOf(object);
+    duplicate = duplicateIndex !== -1;
+  }
+
+  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
+    compact = false;
+  }
+
+  if (duplicate && state.usedDuplicates[duplicateIndex]) {
+    state.dump = '*ref_' + duplicateIndex;
+  } else {
+    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
+      state.usedDuplicates[duplicateIndex] = true;
+    }
+    if (type === '[object Object]') {
+      if (block && (Object.keys(state.dump).length !== 0)) {
+        writeBlockMapping(state, level, state.dump, compact);
+        if (duplicate) {
+          state.dump = '&ref_' + duplicateIndex + state.dump;
+        }
+      } else {
+        writeFlowMapping(state, level, state.dump);
+        if (duplicate) {
+          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
+        }
+      }
+    } else if (type === '[object Array]') {
+      if (block && (state.dump.length !== 0)) {
+        if (state.noArrayIndent && !isblockseq && level > 0) {
+          writeBlockSequence(state, level - 1, state.dump, compact);
+        } else {
+          writeBlockSequence(state, level, state.dump, compact);
+        }
+        if (duplicate) {
+          state.dump = '&ref_' + duplicateIndex + state.dump;
+        }
+      } else {
+        writeFlowSequence(state, level, state.dump);
+        if (duplicate) {
+          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
+        }
+      }
+    } else if (type === '[object String]') {
+      if (state.tag !== '?') {
+        writeScalar(state, state.dump, level, iskey, inblock);
+      }
+    } else if (type === '[object Undefined]') {
+      return false;
+    } else {
+      if (state.skipInvalid) return false;
+      throw new exception('unacceptable kind of an object to dump ' + type);
+    }
+
+    if (state.tag !== null && state.tag !== '?') {
+      // Need to encode all characters except those allowed by the spec:
+      //
+      // [35] ns-dec-digit    ::=  [#x30-#x39] /* 0-9 */
+      // [36] ns-hex-digit    ::=  ns-dec-digit
+      //                         | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
+      // [37] ns-ascii-letter ::=  [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
+      // [38] ns-word-char    ::=  ns-dec-digit | ns-ascii-letter | “-”
+      // [39] ns-uri-char     ::=  “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
+      //                         | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
+      //                         | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
+      //
+      // Also need to encode '!' because it has special meaning (end of tag prefix).
+      //
+      tagStr = encodeURI(
+        state.tag[0] === '!' ? state.tag.slice(1) : state.tag
+      ).replace(/!/g, '%21');
+
+      if (state.tag[0] === '!') {
+        tagStr = '!' + tagStr;
+      } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
+        tagStr = '!!' + tagStr.slice(18);
+      } else {
+        tagStr = '!<' + tagStr + '>';
+      }
+
+      state.dump = tagStr + ' ' + state.dump;
+    }
+  }
+
+  return true;
+}
+
+function getDuplicateReferences(object, state) {
+  var objects = [],
+      duplicatesIndexes = [],
+      index,
+      length;
+
+  inspectNode(object, objects, duplicatesIndexes);
+
+  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
+    state.duplicates.push(objects[duplicatesIndexes[index]]);
+  }
+  state.usedDuplicates = new Array(length);
+}
+
+function inspectNode(object, objects, duplicatesIndexes) {
+  var objectKeyList,
+      index,
+      length;
+
+  if (object !== null && typeof object === 'object') {
+    index = objects.indexOf(object);
+    if (index !== -1) {
+      if (duplicatesIndexes.indexOf(index) === -1) {
+        duplicatesIndexes.push(index);
+      }
+    } else {
+      objects.push(object);
+
+      if (Array.isArray(object)) {
+        for (index = 0, length = object.length; index < length; index += 1) {
+          inspectNode(object[index], objects, duplicatesIndexes);
+        }
+      } else {
+        objectKeyList = Object.keys(object);
+
+        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+        }
+      }
+    }
+  }
+}
+
+function dump$1(input, options) {
+  options = options || {};
+
+  var state = new State(options);
+
+  if (!state.noRefs) getDuplicateReferences(input, state);
+
+  var value = input;
+
+  if (state.replacer) {
+    value = state.replacer.call({ '': value }, '', value);
+  }
+
+  if (writeNode(state, 0, value, true, true)) return state.dump + '\n';
+
+  return '';
+}
+
+var dump_1 = dump$1;
+
+var dumper = {
+	dump: dump_1
+};
+
+function renamed(from, to) {
+  return function () {
+    throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
+      'Use yaml.' + to + ' instead, which is now safe by default.');
+  };
+}
+
+
+var Type                = type$1;
+var Schema              = schema$1;
+var FAILSAFE_SCHEMA     = failsafe;
+var JSON_SCHEMA         = json;
+var CORE_SCHEMA         = core;
+var DEFAULT_SCHEMA      = _default$1;
+var load                = loader.load;
+var loadAll             = loader.loadAll;
+var dump                = dumper.dump;
+var YAMLException       = exception;
+
+// Re-export all types in case user wants to create custom schema
+var types$1 = {
+  binary:    binary,
+  float:     float,
+  map:       map$3,
+  null:      _null,
+  pairs:     pairs,
+  set:       set,
+  timestamp: timestamp,
+  bool:      bool,
+  int:       int,
+  merge:     merge$1,
+  omap:      omap,
+  seq:       seq,
+  str:       str
+};
+
+// Removed functions from JS-YAML 3.0.x
+var safeLoad            = renamed('safeLoad', 'load');
+var safeLoadAll         = renamed('safeLoadAll', 'loadAll');
+var safeDump            = renamed('safeDump', 'dump');
+
+var jsYaml = {
+	Type: Type,
+	Schema: Schema,
+	FAILSAFE_SCHEMA: FAILSAFE_SCHEMA,
+	JSON_SCHEMA: JSON_SCHEMA,
+	CORE_SCHEMA: CORE_SCHEMA,
+	DEFAULT_SCHEMA: DEFAULT_SCHEMA,
+	load: load,
+	loadAll: loadAll,
+	dump: dump,
+	YAMLException: YAMLException,
+	types: types$1,
+	safeLoad: safeLoad,
+	safeLoadAll: safeLoadAll,
+	safeDump: safeDump
+};
+
+var isArrayish$2 = function isArrayish(obj) {
+	if (!obj) {
+		return false;
+	}
+
+	return obj instanceof Array || Array.isArray(obj) ||
+		(obj.length >= 0 && obj.splice instanceof Function);
+};
+
+var util$2 = require$$0$4;
+var isArrayish$1 = isArrayish$2;
+
+var errorEx$1 = function errorEx(name, properties) {
+	if (!name || name.constructor !== String) {
+		properties = name || {};
+		name = Error.name;
+	}
+
+	var errorExError = function ErrorEXError(message) {
+		if (!this) {
+			return new ErrorEXError(message);
+		}
+
+		message = message instanceof Error
+			? message.message
+			: (message || this.message);
+
+		Error.call(this, message);
+		Error.captureStackTrace(this, errorExError);
+
+		this.name = name;
+
+		Object.defineProperty(this, 'message', {
+			configurable: true,
+			enumerable: false,
+			get: function () {
+				var newMessage = message.split(/\r?\n/g);
+
+				for (var key in properties) {
+					if (!properties.hasOwnProperty(key)) {
+						continue;
+					}
+
+					var modifier = properties[key];
+
+					if ('message' in modifier) {
+						newMessage = modifier.message(this[key], newMessage) || newMessage;
+						if (!isArrayish$1(newMessage)) {
+							newMessage = [newMessage];
+						}
+					}
+				}
+
+				return newMessage.join('\n');
+			},
+			set: function (v) {
+				message = v;
+			}
+		});
+
+		var overwrittenStack = null;
+
+		var stackDescriptor = Object.getOwnPropertyDescriptor(this, 'stack');
+		var stackGetter = stackDescriptor.get;
+		var stackValue = stackDescriptor.value;
+		delete stackDescriptor.value;
+		delete stackDescriptor.writable;
+
+		stackDescriptor.set = function (newstack) {
+			overwrittenStack = newstack;
+		};
+
+		stackDescriptor.get = function () {
+			var stack = (overwrittenStack || ((stackGetter)
+				? stackGetter.call(this)
+				: stackValue)).split(/\r?\n+/g);
+
+			// starting in Node 7, the stack builder caches the message.
+			// just replace it.
+			if (!overwrittenStack) {
+				stack[0] = this.name + ': ' + this.message;
+			}
+
+			var lineCount = 1;
+			for (var key in properties) {
+				if (!properties.hasOwnProperty(key)) {
+					continue;
+				}
+
+				var modifier = properties[key];
+
+				if ('line' in modifier) {
+					var line = modifier.line(this[key]);
+					if (line) {
+						stack.splice(lineCount++, 0, '    ' + line);
+					}
+				}
+
+				if ('stack' in modifier) {
+					modifier.stack(this[key], stack);
+				}
+			}
+
+			return stack.join('\n');
+		};
+
+		Object.defineProperty(this, 'stack', stackDescriptor);
+	};
+
+	if (Object.setPrototypeOf) {
+		Object.setPrototypeOf(errorExError.prototype, Error.prototype);
+		Object.setPrototypeOf(errorExError, Error);
+	} else {
+		util$2.inherits(errorExError, Error);
+	}
+
+	return errorExError;
+};
+
+errorEx$1.append = function (str, def) {
+	return {
+		message: function (v, message) {
+			v = v || def;
+
+			if (v) {
+				message[0] += ' ' + str.replace('%s', v.toString());
+			}
+
+			return message;
+		}
+	};
+};
+
+errorEx$1.line = function (str, def) {
+	return {
+		line: function (v) {
+			v = v || def;
+
+			if (v) {
+				return str.replace('%s', v.toString());
+			}
+
+			return null;
+		}
+	};
+};
+
+var errorEx_1 = errorEx$1;
+
+const hexify = char => {
+  const h = char.charCodeAt(0).toString(16).toUpperCase();
+  return '0x' + (h.length % 2 ? '0' : '') + h
+};
+
+const parseError = (e, txt, context) => {
+  if (!txt) {
+    return {
+      message: e.message + ' while parsing empty string',
+      position: 0,
+    }
+  }
+  const badToken = e.message.match(/^Unexpected token (.) .*position\s+(\d+)/i);
+  const errIdx = badToken ? +badToken[2]
+    : e.message.match(/^Unexpected end of JSON.*/i) ? txt.length - 1
+    : null;
+
+  const msg = badToken ? e.message.replace(/^Unexpected token ./, `Unexpected token ${
+      JSON.stringify(badToken[1])
+    } (${hexify(badToken[1])})`)
+    : e.message;
+
+  if (errIdx !== null && errIdx !== undefined) {
+    const start = errIdx <= context ? 0
+      : errIdx - context;
+
+    const end = errIdx + context >= txt.length ? txt.length
+      : errIdx + context;
+
+    const slice = (start === 0 ? '' : '...') +
+      txt.slice(start, end) +
+      (end === txt.length ? '' : '...');
+
+    const near = txt === slice ? '' : 'near ';
+
+    return {
+      message: msg + ` while parsing ${near}${JSON.stringify(slice)}`,
+      position: errIdx,
+    }
+  } else {
+    return {
+      message: msg + ` while parsing '${txt.slice(0, context * 2)}'`,
+      position: 0,
+    }
+  }
+};
+
+class JSONParseError extends SyntaxError {
+  constructor (er, txt, context, caller) {
+    context = context || 20;
+    const metadata = parseError(er, txt, context);
+    super(metadata.message);
+    Object.assign(this, metadata);
+    this.code = 'EJSONPARSE';
+    this.systemError = er;
+    Error.captureStackTrace(this, caller || this.constructor);
+  }
+  get name () { return this.constructor.name }
+  set name (n) {}
+  get [Symbol.toStringTag] () { return this.constructor.name }
+}
+
+const kIndent = Symbol.for('indent');
+const kNewline = Symbol.for('newline');
+// only respect indentation if we got a line break, otherwise squash it
+// things other than objects and arrays aren't indented, so ignore those
+// Important: in both of these regexps, the $1 capture group is the newline
+// or undefined, and the $2 capture group is the indent, or undefined.
+const formatRE = /^\s*[{\[]((?:\r?\n)+)([\s\t]*)/;
+const emptyRE = /^(?:\{\}|\[\])((?:\r?\n)+)?$/;
+
+const parseJson$1 = (txt, reviver, context) => {
+  const parseText = stripBOM(txt);
+  context = context || 20;
+  try {
+    // get the indentation so that we can save it back nicely
+    // if the file starts with {" then we have an indent of '', ie, none
+    // otherwise, pick the indentation of the next line after the first \n
+    // If the pattern doesn't match, then it means no indentation.
+    // JSON.stringify ignores symbols, so this is reasonably safe.
+    // if the string is '{}' or '[]', then use the default 2-space indent.
+    const [, newline = '\n', indent = '  '] = parseText.match(emptyRE) ||
+      parseText.match(formatRE) ||
+      [, '', ''];
+
+    const result = JSON.parse(parseText, reviver);
+    if (result && typeof result === 'object') {
+      result[kNewline] = newline;
+      result[kIndent] = indent;
+    }
+    return result
+  } catch (e) {
+    if (typeof txt !== 'string' && !Buffer.isBuffer(txt)) {
+      const isEmptyArray = Array.isArray(txt) && txt.length === 0;
+      throw Object.assign(new TypeError(
+        `Cannot parse ${isEmptyArray ? 'an empty array' : String(txt)}`
+      ), {
+        code: 'EJSONPARSE',
+        systemError: e,
+      })
+    }
+
+    throw new JSONParseError(e, parseText, context, parseJson$1)
+  }
+};
+
+// Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+// because the buffer-to-string conversion in `fs.readFileSync()`
+// translates it to FEFF, the UTF-16 BOM.
+const stripBOM = txt => String(txt).replace(/^\uFEFF/, '');
+
+var jsonParseEvenBetterErrors = parseJson$1;
+parseJson$1.JSONParseError = JSONParseError;
+
+parseJson$1.noExceptions = (txt, reviver) => {
+  try {
+    return JSON.parse(stripBOM(txt), reviver)
+  } catch (e) {}
+};
+
+var LF = '\n';
+var CR = '\r';
+var LinesAndColumns$1 = (function () {
+    function LinesAndColumns(string) {
+        this.string = string;
+        var offsets = [0];
+        for (var offset = 0; offset < string.length;) {
+            switch (string[offset]) {
+                case LF:
+                    offset += LF.length;
+                    offsets.push(offset);
+                    break;
+                case CR:
+                    offset += CR.length;
+                    if (string[offset] === LF) {
+                        offset += LF.length;
+                    }
+                    offsets.push(offset);
+                    break;
+                default:
+                    offset++;
+                    break;
+            }
+        }
+        this.offsets = offsets;
+    }
+    LinesAndColumns.prototype.locationForIndex = function (index) {
+        if (index < 0 || index > this.string.length) {
+            return null;
+        }
+        var line = 0;
+        var offsets = this.offsets;
+        while (offsets[line + 1] <= index) {
+            line++;
+        }
+        var column = index - offsets[line];
+        return { line: line, column: column };
+    };
+    LinesAndColumns.prototype.indexForLocation = function (location) {
+        var line = location.line, column = location.column;
+        if (line < 0 || line >= this.offsets.length) {
+            return null;
+        }
+        if (column < 0 || column > this.lengthOfLine(line)) {
+            return null;
+        }
+        return this.offsets[line] + column;
+    };
+    LinesAndColumns.prototype.lengthOfLine = function (line) {
+        var offset = this.offsets[line];
+        var nextOffset = line === this.offsets.length - 1 ? this.string.length : this.offsets[line + 1];
+        return nextOffset - offset;
+    };
+    return LinesAndColumns;
+}());
+
+var dist = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	'default': LinesAndColumns$1
+});
+
+var require$$2 = /*@__PURE__*/getAugmentedNamespace(dist);
+
+var lib$4 = {};
+
+var lib$3 = {};
+
+var jsTokens = {};
+
+// Copyright 2014, 2015, 2016, 2017, 2018 Simon Lydell
+// License: MIT. (See LICENSE.)
+
+Object.defineProperty(jsTokens, "__esModule", {
+  value: true
+});
+
+// This regex comes from regex.coffee, and is inserted here by generate-index.js
+// (run `npm run build`).
+jsTokens.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g;
+
+jsTokens.matchToToken = function(match) {
+  var token = {type: "invalid", value: match[0], closed: undefined};
+       if (match[ 1]) token.type = "string" , token.closed = !!(match[3] || match[4]);
+  else if (match[ 5]) token.type = "comment";
+  else if (match[ 6]) token.type = "comment", token.closed = !!match[7];
+  else if (match[ 8]) token.type = "regex";
+  else if (match[ 9]) token.type = "number";
+  else if (match[10]) token.type = "name";
+  else if (match[11]) token.type = "punctuator";
+  else if (match[12]) token.type = "whitespace";
+  return token
+};
+
+var lib$2 = {};
+
+var identifier = {};
+
+Object.defineProperty(identifier, "__esModule", {
+  value: true
+});
+identifier.isIdentifierStart = isIdentifierStart;
+identifier.isIdentifierChar = isIdentifierChar;
+identifier.isIdentifierName = isIdentifierName;
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08c7\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\u9ffc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7ca\ua7f5-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf\u1ac0\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 107, 20, 28, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8952, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42717, 35, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+
+function isInAstralSet(code, set) {
+  let pos = 0x10000;
+
+  for (let i = 0, length = set.length; i < length; i += 2) {
+    pos += set[i];
+    if (pos > code) return false;
+    pos += set[i + 1];
+    if (pos >= code) return true;
+  }
+
+  return false;
+}
+
+function isIdentifierStart(code) {
+  if (code < 65) return code === 36;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  }
+
+  return isInAstralSet(code, astralIdentifierStartCodes);
+}
+
+function isIdentifierChar(code) {
+  if (code < 48) return code === 36;
+  if (code < 58) return true;
+  if (code < 65) return false;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  }
+
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}
+
+function isIdentifierName(name) {
+  let isFirst = true;
+
+  for (let i = 0; i < name.length; i++) {
+    let cp = name.charCodeAt(i);
+
+    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
+      const trail = name.charCodeAt(++i);
+
+      if ((trail & 0xfc00) === 0xdc00) {
+        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
+      }
+    }
+
+    if (isFirst) {
+      isFirst = false;
+
+      if (!isIdentifierStart(cp)) {
+        return false;
+      }
+    } else if (!isIdentifierChar(cp)) {
+      return false;
+    }
+  }
+
+  return !isFirst;
+}
+
+var keyword = {};
+
+Object.defineProperty(keyword, "__esModule", {
+  value: true
+});
+keyword.isReservedWord = isReservedWord;
+keyword.isStrictReservedWord = isStrictReservedWord;
+keyword.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+keyword.isStrictBindReservedWord = isStrictBindReservedWord;
+keyword.isKeyword = isKeyword;
+const reservedWords = {
+  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+  strictBind: ["eval", "arguments"]
 };
+const keywords$1 = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
 
-convert.rgb.apple = function (rgb) {
-	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
+function isReservedWord(word, inModule) {
+  return inModule && word === "await" || word === "enum";
+}
+
+function isStrictReservedWord(word, inModule) {
+  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+
+function isStrictBindOnlyReservedWord(word) {
+  return reservedWordsStrictBindSet.has(word);
+}
+
+function isStrictBindReservedWord(word, inModule) {
+  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+}
+
+function isKeyword(word) {
+  return keywords$1.has(word);
+}
+
+(function (exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isIdentifierName", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierName;
+  }
+});
+Object.defineProperty(exports, "isIdentifierChar", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierChar;
+  }
+});
+Object.defineProperty(exports, "isIdentifierStart", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierStart;
+  }
+});
+Object.defineProperty(exports, "isReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindOnlyReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictReservedWord;
+  }
+});
+Object.defineProperty(exports, "isKeyword", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isKeyword;
+  }
+});
+
+var _identifier = identifier;
+
+var _keyword = keyword;
+}(lib$2));
+
+var chalk = {exports: {}};
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+
+var escapeStringRegexp$1 = function (str) {
+	if (typeof str !== 'string') {
+		throw new TypeError('Expected a string');
+	}
+
+	return str.replace(matchOperatorsRe, '\\$&');
 };
 
-convert.gray.rgb = function (args) {
-	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+var ansiStyles = {exports: {}};
+
+var conversions$2 = {exports: {}};
+
+var colorName = {
+	"aliceblue": [240, 248, 255],
+	"antiquewhite": [250, 235, 215],
+	"aqua": [0, 255, 255],
+	"aquamarine": [127, 255, 212],
+	"azure": [240, 255, 255],
+	"beige": [245, 245, 220],
+	"bisque": [255, 228, 196],
+	"black": [0, 0, 0],
+	"blanchedalmond": [255, 235, 205],
+	"blue": [0, 0, 255],
+	"blueviolet": [138, 43, 226],
+	"brown": [165, 42, 42],
+	"burlywood": [222, 184, 135],
+	"cadetblue": [95, 158, 160],
+	"chartreuse": [127, 255, 0],
+	"chocolate": [210, 105, 30],
+	"coral": [255, 127, 80],
+	"cornflowerblue": [100, 149, 237],
+	"cornsilk": [255, 248, 220],
+	"crimson": [220, 20, 60],
+	"cyan": [0, 255, 255],
+	"darkblue": [0, 0, 139],
+	"darkcyan": [0, 139, 139],
+	"darkgoldenrod": [184, 134, 11],
+	"darkgray": [169, 169, 169],
+	"darkgreen": [0, 100, 0],
+	"darkgrey": [169, 169, 169],
+	"darkkhaki": [189, 183, 107],
+	"darkmagenta": [139, 0, 139],
+	"darkolivegreen": [85, 107, 47],
+	"darkorange": [255, 140, 0],
+	"darkorchid": [153, 50, 204],
+	"darkred": [139, 0, 0],
+	"darksalmon": [233, 150, 122],
+	"darkseagreen": [143, 188, 143],
+	"darkslateblue": [72, 61, 139],
+	"darkslategray": [47, 79, 79],
+	"darkslategrey": [47, 79, 79],
+	"darkturquoise": [0, 206, 209],
+	"darkviolet": [148, 0, 211],
+	"deeppink": [255, 20, 147],
+	"deepskyblue": [0, 191, 255],
+	"dimgray": [105, 105, 105],
+	"dimgrey": [105, 105, 105],
+	"dodgerblue": [30, 144, 255],
+	"firebrick": [178, 34, 34],
+	"floralwhite": [255, 250, 240],
+	"forestgreen": [34, 139, 34],
+	"fuchsia": [255, 0, 255],
+	"gainsboro": [220, 220, 220],
+	"ghostwhite": [248, 248, 255],
+	"gold": [255, 215, 0],
+	"goldenrod": [218, 165, 32],
+	"gray": [128, 128, 128],
+	"green": [0, 128, 0],
+	"greenyellow": [173, 255, 47],
+	"grey": [128, 128, 128],
+	"honeydew": [240, 255, 240],
+	"hotpink": [255, 105, 180],
+	"indianred": [205, 92, 92],
+	"indigo": [75, 0, 130],
+	"ivory": [255, 255, 240],
+	"khaki": [240, 230, 140],
+	"lavender": [230, 230, 250],
+	"lavenderblush": [255, 240, 245],
+	"lawngreen": [124, 252, 0],
+	"lemonchiffon": [255, 250, 205],
+	"lightblue": [173, 216, 230],
+	"lightcoral": [240, 128, 128],
+	"lightcyan": [224, 255, 255],
+	"lightgoldenrodyellow": [250, 250, 210],
+	"lightgray": [211, 211, 211],
+	"lightgreen": [144, 238, 144],
+	"lightgrey": [211, 211, 211],
+	"lightpink": [255, 182, 193],
+	"lightsalmon": [255, 160, 122],
+	"lightseagreen": [32, 178, 170],
+	"lightskyblue": [135, 206, 250],
+	"lightslategray": [119, 136, 153],
+	"lightslategrey": [119, 136, 153],
+	"lightsteelblue": [176, 196, 222],
+	"lightyellow": [255, 255, 224],
+	"lime": [0, 255, 0],
+	"limegreen": [50, 205, 50],
+	"linen": [250, 240, 230],
+	"magenta": [255, 0, 255],
+	"maroon": [128, 0, 0],
+	"mediumaquamarine": [102, 205, 170],
+	"mediumblue": [0, 0, 205],
+	"mediumorchid": [186, 85, 211],
+	"mediumpurple": [147, 112, 219],
+	"mediumseagreen": [60, 179, 113],
+	"mediumslateblue": [123, 104, 238],
+	"mediumspringgreen": [0, 250, 154],
+	"mediumturquoise": [72, 209, 204],
+	"mediumvioletred": [199, 21, 133],
+	"midnightblue": [25, 25, 112],
+	"mintcream": [245, 255, 250],
+	"mistyrose": [255, 228, 225],
+	"moccasin": [255, 228, 181],
+	"navajowhite": [255, 222, 173],
+	"navy": [0, 0, 128],
+	"oldlace": [253, 245, 230],
+	"olive": [128, 128, 0],
+	"olivedrab": [107, 142, 35],
+	"orange": [255, 165, 0],
+	"orangered": [255, 69, 0],
+	"orchid": [218, 112, 214],
+	"palegoldenrod": [238, 232, 170],
+	"palegreen": [152, 251, 152],
+	"paleturquoise": [175, 238, 238],
+	"palevioletred": [219, 112, 147],
+	"papayawhip": [255, 239, 213],
+	"peachpuff": [255, 218, 185],
+	"peru": [205, 133, 63],
+	"pink": [255, 192, 203],
+	"plum": [221, 160, 221],
+	"powderblue": [176, 224, 230],
+	"purple": [128, 0, 128],
+	"rebeccapurple": [102, 51, 153],
+	"red": [255, 0, 0],
+	"rosybrown": [188, 143, 143],
+	"royalblue": [65, 105, 225],
+	"saddlebrown": [139, 69, 19],
+	"salmon": [250, 128, 114],
+	"sandybrown": [244, 164, 96],
+	"seagreen": [46, 139, 87],
+	"seashell": [255, 245, 238],
+	"sienna": [160, 82, 45],
+	"silver": [192, 192, 192],
+	"skyblue": [135, 206, 235],
+	"slateblue": [106, 90, 205],
+	"slategray": [112, 128, 144],
+	"slategrey": [112, 128, 144],
+	"snow": [255, 250, 250],
+	"springgreen": [0, 255, 127],
+	"steelblue": [70, 130, 180],
+	"tan": [210, 180, 140],
+	"teal": [0, 128, 128],
+	"thistle": [216, 191, 216],
+	"tomato": [255, 99, 71],
+	"turquoise": [64, 224, 208],
+	"violet": [238, 130, 238],
+	"wheat": [245, 222, 179],
+	"white": [255, 255, 255],
+	"whitesmoke": [245, 245, 245],
+	"yellow": [255, 255, 0],
+	"yellowgreen": [154, 205, 50]
 };
 
-convert.gray.hsl = convert.gray.hsv = function (args) {
-	return [0, 0, args[0]];
+/* MIT license */
+
+var cssKeywords = colorName;
+
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+//       values that give correct `typeof` results).
+//       do not use box values types (i.e. Number(), String(), etc.)
+
+var reverseKeywords = {};
+for (var key$1 in cssKeywords) {
+	if (cssKeywords.hasOwnProperty(key$1)) {
+		reverseKeywords[cssKeywords[key$1]] = key$1;
+	}
+}
+
+var convert$2 = conversions$2.exports = {
+	rgb: {channels: 3, labels: 'rgb'},
+	hsl: {channels: 3, labels: 'hsl'},
+	hsv: {channels: 3, labels: 'hsv'},
+	hwb: {channels: 3, labels: 'hwb'},
+	cmyk: {channels: 4, labels: 'cmyk'},
+	xyz: {channels: 3, labels: 'xyz'},
+	lab: {channels: 3, labels: 'lab'},
+	lch: {channels: 3, labels: 'lch'},
+	hex: {channels: 1, labels: ['hex']},
+	keyword: {channels: 1, labels: ['keyword']},
+	ansi16: {channels: 1, labels: ['ansi16']},
+	ansi256: {channels: 1, labels: ['ansi256']},
+	hcg: {channels: 3, labels: ['h', 'c', 'g']},
+	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
+	gray: {channels: 1, labels: ['gray']}
 };
 
-convert.gray.hwb = function (gray) {
-	return [0, 100, gray[0]];
+// hide .channels and .labels properties
+for (var model in convert$2) {
+	if (convert$2.hasOwnProperty(model)) {
+		if (!('channels' in convert$2[model])) {
+			throw new Error('missing channels property: ' + model);
+		}
+
+		if (!('labels' in convert$2[model])) {
+			throw new Error('missing channel labels property: ' + model);
+		}
+
+		if (convert$2[model].labels.length !== convert$2[model].channels) {
+			throw new Error('channel and label counts mismatch: ' + model);
+		}
+
+		var channels = convert$2[model].channels;
+		var labels$1 = convert$2[model].labels;
+		delete convert$2[model].channels;
+		delete convert$2[model].labels;
+		Object.defineProperty(convert$2[model], 'channels', {value: channels});
+		Object.defineProperty(convert$2[model], 'labels', {value: labels$1});
+	}
+}
+
+convert$2.rgb.hsl = function (rgb) {
+	var r = rgb[0] / 255;
+	var g = rgb[1] / 255;
+	var b = rgb[2] / 255;
+	var min = Math.min(r, g, b);
+	var max = Math.max(r, g, b);
+	var delta = max - min;
+	var h;
+	var s;
+	var l;
+
+	if (max === min) {
+		h = 0;
+	} else if (r === max) {
+		h = (g - b) / delta;
+	} else if (g === max) {
+		h = 2 + (b - r) / delta;
+	} else if (b === max) {
+		h = 4 + (r - g) / delta;
+	}
+
+	h = Math.min(h * 60, 360);
+
+	if (h < 0) {
+		h += 360;
+	}
+
+	l = (min + max) / 2;
+
+	if (max === min) {
+		s = 0;
+	} else if (l <= 0.5) {
+		s = delta / (max + min);
+	} else {
+		s = delta / (2 - max - min);
+	}
+
+	return [h, s * 100, l * 100];
 };
 
-convert.gray.cmyk = function (gray) {
-	return [0, 0, 0, gray[0]];
+convert$2.rgb.hsv = function (rgb) {
+	var rdif;
+	var gdif;
+	var bdif;
+	var h;
+	var s;
+
+	var r = rgb[0] / 255;
+	var g = rgb[1] / 255;
+	var b = rgb[2] / 255;
+	var v = Math.max(r, g, b);
+	var diff = v - Math.min(r, g, b);
+	var diffc = function (c) {
+		return (v - c) / 6 / diff + 1 / 2;
+	};
+
+	if (diff === 0) {
+		h = s = 0;
+	} else {
+		s = diff / v;
+		rdif = diffc(r);
+		gdif = diffc(g);
+		bdif = diffc(b);
+
+		if (r === v) {
+			h = bdif - gdif;
+		} else if (g === v) {
+			h = (1 / 3) + rdif - bdif;
+		} else if (b === v) {
+			h = (2 / 3) + gdif - rdif;
+		}
+		if (h < 0) {
+			h += 1;
+		} else if (h > 1) {
+			h -= 1;
+		}
+	}
+
+	return [
+		h * 360,
+		s * 100,
+		v * 100
+	];
 };
 
-convert.gray.lab = function (gray) {
-	return [gray[0], 0, 0];
+convert$2.rgb.hwb = function (rgb) {
+	var r = rgb[0];
+	var g = rgb[1];
+	var b = rgb[2];
+	var h = convert$2.rgb.hsl(rgb)[0];
+	var w = 1 / 255 * Math.min(r, Math.min(g, b));
+
+	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+
+	return [h, w * 100, b * 100];
 };
 
-convert.gray.hex = function (gray) {
-	var val = Math.round(gray[0] / 100 * 255) & 0xFF;
-	var integer = (val << 16) + (val << 8) + val;
+convert$2.rgb.cmyk = function (rgb) {
+	var r = rgb[0] / 255;
+	var g = rgb[1] / 255;
+	var b = rgb[2] / 255;
+	var c;
+	var m;
+	var y;
+	var k;
 
-	var string = integer.toString(16).toUpperCase();
-	return '000000'.substring(string.length) + string;
+	k = Math.min(1 - r, 1 - g, 1 - b);
+	c = (1 - r - k) / (1 - k) || 0;
+	m = (1 - g - k) / (1 - k) || 0;
+	y = (1 - b - k) / (1 - k) || 0;
+
+	return [c * 100, m * 100, y * 100, k * 100];
 };
 
-convert.rgb.gray = function (rgb) {
-	var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
-	return [val / 255 * 100];
+/**
+ * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+ * */
+function comparativeDistance(x, y) {
+	return (
+		Math.pow(x[0] - y[0], 2) +
+		Math.pow(x[1] - y[1], 2) +
+		Math.pow(x[2] - y[2], 2)
+	);
+}
+
+convert$2.rgb.keyword = function (rgb) {
+	var reversed = reverseKeywords[rgb];
+	if (reversed) {
+		return reversed;
+	}
+
+	var currentClosestDistance = Infinity;
+	var currentClosestKeyword;
+
+	for (var keyword in cssKeywords) {
+		if (cssKeywords.hasOwnProperty(keyword)) {
+			var value = cssKeywords[keyword];
+
+			// Compute comparative distance
+			var distance = comparativeDistance(rgb, value);
+
+			// Check if its less, if so set as closest
+			if (distance < currentClosestDistance) {
+				currentClosestDistance = distance;
+				currentClosestKeyword = keyword;
+			}
+		}
+	}
+
+	return currentClosestKeyword;
 };
-});
-var conversions_1 = conversions.rgb;
-var conversions_2 = conversions.hsl;
-var conversions_3 = conversions.hsv;
-var conversions_4 = conversions.hwb;
-var conversions_5 = conversions.cmyk;
-var conversions_6 = conversions.xyz;
-var conversions_7 = conversions.lab;
-var conversions_8 = conversions.lch;
-var conversions_9 = conversions.hex;
-var conversions_10 = conversions.keyword;
-var conversions_11 = conversions.ansi16;
-var conversions_12 = conversions.ansi256;
-var conversions_13 = conversions.hcg;
-var conversions_14 = conversions.apple;
-var conversions_15 = conversions.gray;
 
-/*
-	this function routes a model to all other models.
+convert$2.keyword.rgb = function (keyword) {
+	return cssKeywords[keyword];
+};
 
-	all functions that are routed have a property `.conversion` attached
-	to the returned synthetic function. This property is an array
-	of strings, each with the steps in between the 'from' and 'to'
-	color models (inclusive).
+convert$2.rgb.xyz = function (rgb) {
+	var r = rgb[0] / 255;
+	var g = rgb[1] / 255;
+	var b = rgb[2] / 255;
 
-	conversions that are not possible simply are not included.
-*/
+	// assume sRGB
+	r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
+	g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
+	b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
 
-function buildGraph() {
-	var graph = {};
-	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
-	var models = Object.keys(conversions);
+	var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+	var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+	var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
 
-	for (var len = models.length, i = 0; i < len; i++) {
-		graph[models[i]] = {
-			// http://jsperf.com/1-vs-infinity
-			// micro-opt, but this is simple.
-			distance: -1,
-			parent: null
-		};
+	return [x * 100, y * 100, z * 100];
+};
+
+convert$2.rgb.lab = function (rgb) {
+	var xyz = convert$2.rgb.xyz(rgb);
+	var x = xyz[0];
+	var y = xyz[1];
+	var z = xyz[2];
+	var l;
+	var a;
+	var b;
+
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
+
+	x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
+
+	l = (116 * y) - 16;
+	a = 500 * (x - y);
+	b = 200 * (y - z);
+
+	return [l, a, b];
+};
+
+convert$2.hsl.rgb = function (hsl) {
+	var h = hsl[0] / 360;
+	var s = hsl[1] / 100;
+	var l = hsl[2] / 100;
+	var t1;
+	var t2;
+	var t3;
+	var rgb;
+	var val;
+
+	if (s === 0) {
+		val = l * 255;
+		return [val, val, val];
+	}
+
+	if (l < 0.5) {
+		t2 = l * (1 + s);
+	} else {
+		t2 = l + s - l * s;
+	}
+
+	t1 = 2 * l - t2;
+
+	rgb = [0, 0, 0];
+	for (var i = 0; i < 3; i++) {
+		t3 = h + 1 / 3 * -(i - 1);
+		if (t3 < 0) {
+			t3++;
+		}
+		if (t3 > 1) {
+			t3--;
+		}
+
+		if (6 * t3 < 1) {
+			val = t1 + (t2 - t1) * 6 * t3;
+		} else if (2 * t3 < 1) {
+			val = t2;
+		} else if (3 * t3 < 2) {
+			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+		} else {
+			val = t1;
+		}
+
+		rgb[i] = val * 255;
 	}
 
-	return graph;
-}
+	return rgb;
+};
 
-// https://en.wikipedia.org/wiki/Breadth-first_search
-function deriveBFS(fromModel) {
-	var graph = buildGraph();
-	var queue = [fromModel]; // unshift -> queue -> pop
+convert$2.hsl.hsv = function (hsl) {
+	var h = hsl[0];
+	var s = hsl[1] / 100;
+	var l = hsl[2] / 100;
+	var smin = s;
+	var lmin = Math.max(l, 0.01);
+	var sv;
+	var v;
 
-	graph[fromModel].distance = 0;
+	l *= 2;
+	s *= (l <= 1) ? l : 2 - l;
+	smin *= lmin <= 1 ? lmin : 2 - lmin;
+	v = (l + s) / 2;
+	sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
 
-	while (queue.length) {
-		var current = queue.pop();
-		var adjacents = Object.keys(conversions[current]);
+	return [h, sv * 100, v * 100];
+};
 
-		for (var len = adjacents.length, i = 0; i < len; i++) {
-			var adjacent = adjacents[i];
-			var node = graph[adjacent];
+convert$2.hsv.rgb = function (hsv) {
+	var h = hsv[0] / 60;
+	var s = hsv[1] / 100;
+	var v = hsv[2] / 100;
+	var hi = Math.floor(h) % 6;
 
-			if (node.distance === -1) {
-				node.distance = graph[current].distance + 1;
-				node.parent = current;
-				queue.unshift(adjacent);
-			}
-		}
+	var f = h - Math.floor(h);
+	var p = 255 * v * (1 - s);
+	var q = 255 * v * (1 - (s * f));
+	var t = 255 * v * (1 - (s * (1 - f)));
+	v *= 255;
+
+	switch (hi) {
+		case 0:
+			return [v, t, p];
+		case 1:
+			return [q, v, p];
+		case 2:
+			return [p, v, t];
+		case 3:
+			return [p, q, v];
+		case 4:
+			return [t, p, v];
+		case 5:
+			return [v, p, q];
 	}
+};
 
-	return graph;
-}
+convert$2.hsv.hsl = function (hsv) {
+	var h = hsv[0];
+	var s = hsv[1] / 100;
+	var v = hsv[2] / 100;
+	var vmin = Math.max(v, 0.01);
+	var lmin;
+	var sl;
+	var l;
 
-function link(from, to) {
-	return function (args) {
-		return to(from(args));
-	};
-}
+	l = (2 - s) * v;
+	lmin = (2 - s) * vmin;
+	sl = s * vmin;
+	sl /= (lmin <= 1) ? lmin : 2 - lmin;
+	sl = sl || 0;
+	l /= 2;
 
-function wrapConversion(toModel, graph) {
-	var path = [graph[toModel].parent, toModel];
-	var fn = conversions[graph[toModel].parent][toModel];
+	return [h, sl * 100, l * 100];
+};
 
-	var cur = graph[toModel].parent;
-	while (graph[cur].parent) {
-		path.unshift(graph[cur].parent);
-		fn = link(conversions[graph[cur].parent][cur], fn);
-		cur = graph[cur].parent;
-	}
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert$2.hwb.rgb = function (hwb) {
+	var h = hwb[0] / 360;
+	var wh = hwb[1] / 100;
+	var bl = hwb[2] / 100;
+	var ratio = wh + bl;
+	var i;
+	var v;
+	var f;
+	var n;
 
-	fn.conversion = path;
-	return fn;
-}
+	// wh + bl cant be > 1
+	if (ratio > 1) {
+		wh /= ratio;
+		bl /= ratio;
+	}
 
-var route = function (fromModel) {
-	var graph = deriveBFS(fromModel);
-	var conversion = {};
+	i = Math.floor(6 * h);
+	v = 1 - bl;
+	f = 6 * h - i;
 
-	var models = Object.keys(graph);
-	for (var len = models.length, i = 0; i < len; i++) {
-		var toModel = models[i];
-		var node = graph[toModel];
+	if ((i & 0x01) !== 0) {
+		f = 1 - f;
+	}
 
-		if (node.parent === null) {
-			// no possible conversion, or this node is the source model.
-			continue;
-		}
+	n = wh + f * (v - wh); // linear interpolation
 
-		conversion[toModel] = wrapConversion(toModel, graph);
+	var r;
+	var g;
+	var b;
+	switch (i) {
+		default:
+		case 6:
+		case 0: r = v; g = n; b = wh; break;
+		case 1: r = n; g = v; b = wh; break;
+		case 2: r = wh; g = v; b = n; break;
+		case 3: r = wh; g = n; b = v; break;
+		case 4: r = n; g = wh; b = v; break;
+		case 5: r = v; g = wh; b = n; break;
 	}
 
-	return conversion;
+	return [r * 255, g * 255, b * 255];
 };
 
-var convert = {};
+convert$2.cmyk.rgb = function (cmyk) {
+	var c = cmyk[0] / 100;
+	var m = cmyk[1] / 100;
+	var y = cmyk[2] / 100;
+	var k = cmyk[3] / 100;
+	var r;
+	var g;
+	var b;
 
-var models = Object.keys(conversions);
+	r = 1 - Math.min(1, c * (1 - k) + k);
+	g = 1 - Math.min(1, m * (1 - k) + k);
+	b = 1 - Math.min(1, y * (1 - k) + k);
 
-function wrapRaw(fn) {
-	var wrappedFn = function (args) {
-		if (args === undefined || args === null) {
-			return args;
-		}
+	return [r * 255, g * 255, b * 255];
+};
 
-		if (arguments.length > 1) {
-			args = Array.prototype.slice.call(arguments);
-		}
+convert$2.xyz.rgb = function (xyz) {
+	var x = xyz[0] / 100;
+	var y = xyz[1] / 100;
+	var z = xyz[2] / 100;
+	var r;
+	var g;
+	var b;
 
-		return fn(args);
-	};
+	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
 
-	// preserve .conversion property if there is one
-	if ('conversion' in fn) {
-		wrappedFn.conversion = fn.conversion;
-	}
+	// assume sRGB
+	r = r > 0.0031308
+		? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
+		: r * 12.92;
 
-	return wrappedFn;
-}
+	g = g > 0.0031308
+		? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
+		: g * 12.92;
 
-function wrapRounded(fn) {
-	var wrappedFn = function (args) {
-		if (args === undefined || args === null) {
-			return args;
-		}
+	b = b > 0.0031308
+		? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
+		: b * 12.92;
 
-		if (arguments.length > 1) {
-			args = Array.prototype.slice.call(arguments);
-		}
+	r = Math.min(Math.max(0, r), 1);
+	g = Math.min(Math.max(0, g), 1);
+	b = Math.min(Math.max(0, b), 1);
 
-		var result = fn(args);
+	return [r * 255, g * 255, b * 255];
+};
 
-		// we're assuming the result is an array here.
-		// see notice in conversions.js; don't use box types
-		// in conversion functions.
-		if (typeof result === 'object') {
-			for (var len = result.length, i = 0; i < len; i++) {
-				result[i] = Math.round(result[i]);
-			}
-		}
+convert$2.xyz.lab = function (xyz) {
+	var x = xyz[0];
+	var y = xyz[1];
+	var z = xyz[2];
+	var l;
+	var a;
+	var b;
 
-		return result;
-	};
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
 
-	// preserve .conversion property if there is one
-	if ('conversion' in fn) {
-		wrappedFn.conversion = fn.conversion;
-	}
+	x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
 
-	return wrappedFn;
-}
+	l = (116 * y) - 16;
+	a = 500 * (x - y);
+	b = 200 * (y - z);
 
-models.forEach(function (fromModel) {
-	convert[fromModel] = {};
+	return [l, a, b];
+};
 
-	Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
-	Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
+convert$2.lab.xyz = function (lab) {
+	var l = lab[0];
+	var a = lab[1];
+	var b = lab[2];
+	var x;
+	var y;
+	var z;
 
-	var routes = route(fromModel);
-	var routeModels = Object.keys(routes);
+	y = (l + 16) / 116;
+	x = a / 500 + y;
+	z = y - b / 200;
 
-	routeModels.forEach(function (toModel) {
-		var fn = routes[toModel];
+	var y2 = Math.pow(y, 3);
+	var x2 = Math.pow(x, 3);
+	var z2 = Math.pow(z, 3);
+	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
 
-		convert[fromModel][toModel] = wrapRounded(fn);
-		convert[fromModel][toModel].raw = wrapRaw(fn);
-	});
-});
+	x *= 95.047;
+	y *= 100;
+	z *= 108.883;
+
+	return [x, y, z];
+};
 
-var colorConvert = convert;
+convert$2.lab.lch = function (lab) {
+	var l = lab[0];
+	var a = lab[1];
+	var b = lab[2];
+	var hr;
+	var h;
+	var c;
 
-var ansiStyles = createCommonjsModule(function (module) {
+	hr = Math.atan2(b, a);
+	h = hr * 360 / 2 / Math.PI;
 
+	if (h < 0) {
+		h += 360;
+	}
 
-const wrapAnsi16 = (fn, offset) => function () {
-	const code = fn.apply(colorConvert, arguments);
-	return `\u001B[${code + offset}m`;
-};
+	c = Math.sqrt(a * a + b * b);
 
-const wrapAnsi256 = (fn, offset) => function () {
-	const code = fn.apply(colorConvert, arguments);
-	return `\u001B[${38 + offset};5;${code}m`;
+	return [l, c, h];
 };
 
-const wrapAnsi16m = (fn, offset) => function () {
-	const rgb = fn.apply(colorConvert, arguments);
-	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+convert$2.lch.lab = function (lch) {
+	var l = lch[0];
+	var c = lch[1];
+	var h = lch[2];
+	var a;
+	var b;
+	var hr;
+
+	hr = h / 360 * 2 * Math.PI;
+	a = c * Math.cos(hr);
+	b = c * Math.sin(hr);
+
+	return [l, a, b];
 };
 
-function assembleStyles() {
-	const codes = new Map();
-	const styles = {
-		modifier: {
-			reset: [0, 0],
-			// 21 isn't widely supported and 22 does the same thing
-			bold: [1, 22],
-			dim: [2, 22],
-			italic: [3, 23],
-			underline: [4, 24],
-			inverse: [7, 27],
-			hidden: [8, 28],
-			strikethrough: [9, 29]
-		},
-		color: {
-			black: [30, 39],
-			red: [31, 39],
-			green: [32, 39],
-			yellow: [33, 39],
-			blue: [34, 39],
-			magenta: [35, 39],
-			cyan: [36, 39],
-			white: [37, 39],
-			gray: [90, 39],
+convert$2.rgb.ansi16 = function (args) {
+	var r = args[0];
+	var g = args[1];
+	var b = args[2];
+	var value = 1 in arguments ? arguments[1] : convert$2.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
 
-			// Bright color
-			redBright: [91, 39],
-			greenBright: [92, 39],
-			yellowBright: [93, 39],
-			blueBright: [94, 39],
-			magentaBright: [95, 39],
-			cyanBright: [96, 39],
-			whiteBright: [97, 39]
-		},
-		bgColor: {
-			bgBlack: [40, 49],
-			bgRed: [41, 49],
-			bgGreen: [42, 49],
-			bgYellow: [43, 49],
-			bgBlue: [44, 49],
-			bgMagenta: [45, 49],
-			bgCyan: [46, 49],
-			bgWhite: [47, 49],
+	value = Math.round(value / 50);
 
-			// Bright color
-			bgBlackBright: [100, 49],
-			bgRedBright: [101, 49],
-			bgGreenBright: [102, 49],
-			bgYellowBright: [103, 49],
-			bgBlueBright: [104, 49],
-			bgMagentaBright: [105, 49],
-			bgCyanBright: [106, 49],
-			bgWhiteBright: [107, 49]
-		}
-	};
+	if (value === 0) {
+		return 30;
+	}
 
-	// Fix humans
-	styles.color.grey = styles.color.gray;
+	var ansi = 30
+		+ ((Math.round(b / 255) << 2)
+		| (Math.round(g / 255) << 1)
+		| Math.round(r / 255));
 
-	for (const groupName of Object.keys(styles)) {
-		const group = styles[groupName];
+	if (value === 2) {
+		ansi += 60;
+	}
 
-		for (const styleName of Object.keys(group)) {
-			const style = group[styleName];
+	return ansi;
+};
 
-			styles[styleName] = {
-				open: `\u001B[${style[0]}m`,
-				close: `\u001B[${style[1]}m`
-			};
+convert$2.hsv.ansi16 = function (args) {
+	// optimization here; we already know the value and don't need to get
+	// it converted for us.
+	return convert$2.rgb.ansi16(convert$2.hsv.rgb(args), args[2]);
+};
 
-			group[styleName] = styles[styleName];
+convert$2.rgb.ansi256 = function (args) {
+	var r = args[0];
+	var g = args[1];
+	var b = args[2];
 
-			codes.set(style[0], style[1]);
+	// we use the extended greyscale palette here, with the exception of
+	// black and white. normal palette only has 4 greyscale shades.
+	if (r === g && g === b) {
+		if (r < 8) {
+			return 16;
 		}
 
-		Object.defineProperty(styles, groupName, {
-			value: group,
-			enumerable: false
-		});
+		if (r > 248) {
+			return 231;
+		}
 
-		Object.defineProperty(styles, 'codes', {
-			value: codes,
-			enumerable: false
-		});
+		return Math.round(((r - 8) / 247) * 24) + 232;
 	}
 
-	const ansi2ansi = n => n;
-	const rgb2rgb = (r, g, b) => [r, g, b];
-
-	styles.color.close = '\u001B[39m';
-	styles.bgColor.close = '\u001B[49m';
+	var ansi = 16
+		+ (36 * Math.round(r / 255 * 5))
+		+ (6 * Math.round(g / 255 * 5))
+		+ Math.round(b / 255 * 5);
 
-	styles.color.ansi = {
-		ansi: wrapAnsi16(ansi2ansi, 0)
-	};
-	styles.color.ansi256 = {
-		ansi256: wrapAnsi256(ansi2ansi, 0)
-	};
-	styles.color.ansi16m = {
-		rgb: wrapAnsi16m(rgb2rgb, 0)
-	};
+	return ansi;
+};
 
-	styles.bgColor.ansi = {
-		ansi: wrapAnsi16(ansi2ansi, 10)
-	};
-	styles.bgColor.ansi256 = {
-		ansi256: wrapAnsi256(ansi2ansi, 10)
-	};
-	styles.bgColor.ansi16m = {
-		rgb: wrapAnsi16m(rgb2rgb, 10)
-	};
+convert$2.ansi16.rgb = function (args) {
+	var color = args % 10;
 
-	for (let key of Object.keys(colorConvert)) {
-		if (typeof colorConvert[key] !== 'object') {
-			continue;
+	// handle greyscale
+	if (color === 0 || color === 7) {
+		if (args > 50) {
+			color += 3.5;
 		}
 
-		const suite = colorConvert[key];
+		color = color / 10.5 * 255;
 
-		if (key === 'ansi16') {
-			key = 'ansi';
-		}
+		return [color, color, color];
+	}
 
-		if ('ansi16' in suite) {
-			styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
-			styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
-		}
+	var mult = (~~(args > 50) + 1) * 0.5;
+	var r = ((color & 1) * mult) * 255;
+	var g = (((color >> 1) & 1) * mult) * 255;
+	var b = (((color >> 2) & 1) * mult) * 255;
 
-		if ('ansi256' in suite) {
-			styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
-			styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
-		}
+	return [r, g, b];
+};
 
-		if ('rgb' in suite) {
-			styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
-			styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
-		}
+convert$2.ansi256.rgb = function (args) {
+	// handle greyscale
+	if (args >= 232) {
+		var c = (args - 232) * 10 + 8;
+		return [c, c, c];
 	}
 
-	return styles;
-}
+	args -= 16;
 
-// Make the export immutable
-Object.defineProperty(module, 'exports', {
-	enumerable: true,
-	get: assembleStyles
-});
-});
+	var rem;
+	var r = Math.floor(args / 36) / 5 * 255;
+	var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+	var b = (rem % 6) / 5 * 255;
 
-var hasFlag = (flag, argv) => {
-	argv = argv || process.argv;
-	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
-	const pos = argv.indexOf(prefix + flag);
-	const terminatorPos = argv.indexOf('--');
-	return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+	return [r, g, b];
 };
 
-const env = process.env;
-
-let forceColor;
-if (hasFlag('no-color') ||
-	hasFlag('no-colors') ||
-	hasFlag('color=false')) {
-	forceColor = false;
-} else if (hasFlag('color') ||
-	hasFlag('colors') ||
-	hasFlag('color=true') ||
-	hasFlag('color=always')) {
-	forceColor = true;
-}
-if ('FORCE_COLOR' in env) {
-	forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
-}
-
-function translateLevel(level) {
-	if (level === 0) {
-		return false;
-	}
-
-	return {
-		level,
-		hasBasic: true,
-		has256: level >= 2,
-		has16m: level >= 3
-	};
-}
+convert$2.rgb.hex = function (args) {
+	var integer = ((Math.round(args[0]) & 0xFF) << 16)
+		+ ((Math.round(args[1]) & 0xFF) << 8)
+		+ (Math.round(args[2]) & 0xFF);
 
-function supportsColor(stream) {
-	if (forceColor === false) {
-		return 0;
-	}
+	var string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
 
-	if (hasFlag('color=16m') ||
-		hasFlag('color=full') ||
-		hasFlag('color=truecolor')) {
-		return 3;
+convert$2.hex.rgb = function (args) {
+	var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+	if (!match) {
+		return [0, 0, 0];
 	}
 
-	if (hasFlag('color=256')) {
-		return 2;
-	}
+	var colorString = match[0];
 
-	if (stream && !stream.isTTY && forceColor !== true) {
-		return 0;
+	if (match[0].length === 3) {
+		colorString = colorString.split('').map(function (char) {
+			return char + char;
+		}).join('');
 	}
 
-	const min = forceColor ? 1 : 0;
-
-	if (process.platform === 'win32') {
-		// Node.js 7.5.0 is the first version of Node.js to include a patch to
-		// libuv that enables 256 color output on Windows. Anything earlier and it
-		// won't work. However, here we target Node.js 8 at minimum as it is an LTS
-		// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
-		// release that supports 256 colors. Windows 10 build 14931 is the first release
-		// that supports 16m/TrueColor.
-		const osRelease = os.release().split('.');
-		if (
-			Number(process.versions.node.split('.')[0]) >= 8 &&
-			Number(osRelease[0]) >= 10 &&
-			Number(osRelease[2]) >= 10586
-		) {
-			return Number(osRelease[2]) >= 14931 ? 3 : 2;
-		}
+	var integer = parseInt(colorString, 16);
+	var r = (integer >> 16) & 0xFF;
+	var g = (integer >> 8) & 0xFF;
+	var b = integer & 0xFF;
 
-		return 1;
-	}
+	return [r, g, b];
+};
 
-	if ('CI' in env) {
-		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
-			return 1;
-		}
+convert$2.rgb.hcg = function (rgb) {
+	var r = rgb[0] / 255;
+	var g = rgb[1] / 255;
+	var b = rgb[2] / 255;
+	var max = Math.max(Math.max(r, g), b);
+	var min = Math.min(Math.min(r, g), b);
+	var chroma = (max - min);
+	var grayscale;
+	var hue;
 
-		return min;
+	if (chroma < 1) {
+		grayscale = min / (1 - chroma);
+	} else {
+		grayscale = 0;
 	}
 
-	if ('TEAMCITY_VERSION' in env) {
-		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (chroma <= 0) {
+		hue = 0;
+	} else
+	if (max === r) {
+		hue = ((g - b) / chroma) % 6;
+	} else
+	if (max === g) {
+		hue = 2 + (b - r) / chroma;
+	} else {
+		hue = 4 + (r - g) / chroma + 4;
 	}
 
-	if (env.COLORTERM === 'truecolor') {
-		return 3;
-	}
+	hue /= 6;
+	hue %= 1;
 
-	if ('TERM_PROGRAM' in env) {
-		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+	return [hue * 360, chroma * 100, grayscale * 100];
+};
 
-		switch (env.TERM_PROGRAM) {
-			case 'iTerm.app':
-				return version >= 3 ? 3 : 2;
-			case 'Apple_Terminal':
-				return 2;
-			// No default
-		}
-	}
+convert$2.hsl.hcg = function (hsl) {
+	var s = hsl[1] / 100;
+	var l = hsl[2] / 100;
+	var c = 1;
+	var f = 0;
 
-	if (/-256(color)?$/i.test(env.TERM)) {
-		return 2;
+	if (l < 0.5) {
+		c = 2.0 * s * l;
+	} else {
+		c = 2.0 * s * (1.0 - l);
 	}
 
-	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-		return 1;
+	if (c < 1.0) {
+		f = (l - 0.5 * c) / (1.0 - c);
 	}
 
-	if ('COLORTERM' in env) {
-		return 1;
-	}
+	return [hsl[0], c * 100, f * 100];
+};
 
-	if (env.TERM === 'dumb') {
-		return min;
-	}
+convert$2.hsv.hcg = function (hsv) {
+	var s = hsv[1] / 100;
+	var v = hsv[2] / 100;
 
-	return min;
-}
+	var c = s * v;
+	var f = 0;
 
-function getSupportLevel(stream) {
-	const level = supportsColor(stream);
-	return translateLevel(level);
-}
+	if (c < 1.0) {
+		f = (v - c) / (1 - c);
+	}
 
-var supportsColor_1 = {
-	supportsColor: getSupportLevel,
-	stdout: getSupportLevel(process.stdout),
-	stderr: getSupportLevel(process.stderr)
+	return [hsv[0], c * 100, f * 100];
 };
 
-const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
-const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
-const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
-const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
-
-const ESCAPES = new Map([
-	['n', '\n'],
-	['r', '\r'],
-	['t', '\t'],
-	['b', '\b'],
-	['f', '\f'],
-	['v', '\v'],
-	['0', '\0'],
-	['\\', '\\'],
-	['e', '\u001B'],
-	['a', '\u0007']
-]);
+convert$2.hcg.rgb = function (hcg) {
+	var h = hcg[0] / 360;
+	var c = hcg[1] / 100;
+	var g = hcg[2] / 100;
 
-function unescape(c) {
-	if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
-		return String.fromCharCode(parseInt(c.slice(1), 16));
+	if (c === 0.0) {
+		return [g * 255, g * 255, g * 255];
 	}
 
-	return ESCAPES.get(c) || c;
-}
-
-function parseArguments(name, args) {
-	const results = [];
-	const chunks = args.trim().split(/\s*,\s*/g);
-	let matches;
+	var pure = [0, 0, 0];
+	var hi = (h % 1) * 6;
+	var v = hi % 1;
+	var w = 1 - v;
+	var mg = 0;
 
-	for (const chunk of chunks) {
-		if (!isNaN(chunk)) {
-			results.push(Number(chunk));
-		} else if ((matches = chunk.match(STRING_REGEX))) {
-			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
-		} else {
-			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
-		}
+	switch (Math.floor(hi)) {
+		case 0:
+			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
+		case 1:
+			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
+		case 2:
+			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
+		case 3:
+			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
+		case 4:
+			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
+		default:
+			pure[0] = 1; pure[1] = 0; pure[2] = w;
 	}
 
-	return results;
-}
+	mg = (1.0 - c) * g;
 
-function parseStyle(style) {
-	STYLE_REGEX.lastIndex = 0;
+	return [
+		(c * pure[0] + mg) * 255,
+		(c * pure[1] + mg) * 255,
+		(c * pure[2] + mg) * 255
+	];
+};
 
-	const results = [];
-	let matches;
+convert$2.hcg.hsv = function (hcg) {
+	var c = hcg[1] / 100;
+	var g = hcg[2] / 100;
 
-	while ((matches = STYLE_REGEX.exec(style)) !== null) {
-		const name = matches[1];
+	var v = c + g * (1.0 - c);
+	var f = 0;
 
-		if (matches[2]) {
-			const args = parseArguments(name, matches[2]);
-			results.push([name].concat(args));
-		} else {
-			results.push([name]);
-		}
+	if (v > 0.0) {
+		f = c / v;
 	}
 
-	return results;
-}
+	return [hcg[0], f * 100, v * 100];
+};
 
-function buildStyle(chalk, styles) {
-	const enabled = {};
+convert$2.hcg.hsl = function (hcg) {
+	var c = hcg[1] / 100;
+	var g = hcg[2] / 100;
 
-	for (const layer of styles) {
-		for (const style of layer.styles) {
-			enabled[style[0]] = layer.inverse ? null : style.slice(1);
-		}
+	var l = g * (1.0 - c) + 0.5 * c;
+	var s = 0;
+
+	if (l > 0.0 && l < 0.5) {
+		s = c / (2 * l);
+	} else
+	if (l >= 0.5 && l < 1.0) {
+		s = c / (2 * (1 - l));
 	}
 
-	let current = chalk;
-	for (const styleName of Object.keys(enabled)) {
-		if (Array.isArray(enabled[styleName])) {
-			if (!(styleName in current)) {
-				throw new Error(`Unknown Chalk style: ${styleName}`);
-			}
+	return [hcg[0], s * 100, l * 100];
+};
 
-			if (enabled[styleName].length > 0) {
-				current = current[styleName].apply(current, enabled[styleName]);
-			} else {
-				current = current[styleName];
-			}
-		}
+convert$2.hcg.hwb = function (hcg) {
+	var c = hcg[1] / 100;
+	var g = hcg[2] / 100;
+	var v = c + g * (1.0 - c);
+	return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
+
+convert$2.hwb.hcg = function (hwb) {
+	var w = hwb[1] / 100;
+	var b = hwb[2] / 100;
+	var v = 1 - b;
+	var c = v - w;
+	var g = 0;
+
+	if (c < 1) {
+		g = (v - c) / (1 - c);
 	}
 
-	return current;
-}
+	return [hwb[0], c * 100, g * 100];
+};
 
-var templates = (chalk, tmp) => {
-	const styles = [];
-	const chunks = [];
-	let chunk = [];
+convert$2.apple.rgb = function (apple) {
+	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
+};
 
-	// eslint-disable-next-line max-params
-	tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
-		if (escapeChar) {
-			chunk.push(unescape(escapeChar));
-		} else if (style) {
-			const str = chunk.join('');
-			chunk = [];
-			chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
-			styles.push({inverse, styles: parseStyle(style)});
-		} else if (close) {
-			if (styles.length === 0) {
-				throw new Error('Found extraneous } in Chalk template literal');
-			}
+convert$2.rgb.apple = function (rgb) {
+	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
+};
 
-			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
-			chunk = [];
-			styles.pop();
-		} else {
-			chunk.push(chr);
-		}
-	});
+convert$2.gray.rgb = function (args) {
+	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+};
 
-	chunks.push(chunk.join(''));
+convert$2.gray.hsl = convert$2.gray.hsv = function (args) {
+	return [0, 0, args[0]];
+};
 
-	if (styles.length > 0) {
-		const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
-		throw new Error(errMsg);
-	}
+convert$2.gray.hwb = function (gray) {
+	return [0, 100, gray[0]];
+};
 
-	return chunks.join('');
+convert$2.gray.cmyk = function (gray) {
+	return [0, 0, 0, gray[0]];
 };
 
-var chalk = createCommonjsModule(function (module) {
+convert$2.gray.lab = function (gray) {
+	return [gray[0], 0, 0];
+};
 
+convert$2.gray.hex = function (gray) {
+	var val = Math.round(gray[0] / 100 * 255) & 0xFF;
+	var integer = (val << 16) + (val << 8) + val;
 
-const stdoutColor = supportsColor_1.stdout;
+	var string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
 
+convert$2.rgb.gray = function (rgb) {
+	var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+	return [val / 255 * 100];
+};
 
+var conversions$1 = conversions$2.exports;
 
-const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
+/*
+	this function routes a model to all other models.
 
-// `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+	all functions that are routed have a property `.conversion` attached
+	to the returned synthetic function. This property is an array
+	of strings, each with the steps in between the 'from' and 'to'
+	color models (inclusive).
 
-// `color-convert` models to exclude from the Chalk API due to conflicts and such
-const skipModels = new Set(['gray']);
+	conversions that are not possible simply are not included.
+*/
 
-const styles = Object.create(null);
+function buildGraph() {
+	var graph = {};
+	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
+	var models = Object.keys(conversions$1);
 
-function applyOptions(obj, options) {
-	options = options || {};
+	for (var len = models.length, i = 0; i < len; i++) {
+		graph[models[i]] = {
+			// http://jsperf.com/1-vs-infinity
+			// micro-opt, but this is simple.
+			distance: -1,
+			parent: null
+		};
+	}
 
-	// Detect level if not set manually
-	const scLevel = stdoutColor ? stdoutColor.level : 0;
-	obj.level = options.level === undefined ? scLevel : options.level;
-	obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
+	return graph;
 }
 
-function Chalk(options) {
-	// We check for this.template here since calling `chalk.constructor()`
-	// by itself will have a `this` of a previously constructed chalk object
-	if (!this || !(this instanceof Chalk) || this.template) {
-		const chalk = {};
-		applyOptions(chalk, options);
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS(fromModel) {
+	var graph = buildGraph();
+	var queue = [fromModel]; // unshift -> queue -> pop
 
-		chalk.template = function () {
-			const args = [].slice.call(arguments);
-			return chalkTag.apply(null, [chalk.template].concat(args));
-		};
+	graph[fromModel].distance = 0;
 
-		Object.setPrototypeOf(chalk, Chalk.prototype);
-		Object.setPrototypeOf(chalk.template, chalk);
+	while (queue.length) {
+		var current = queue.pop();
+		var adjacents = Object.keys(conversions$1[current]);
 
-		chalk.template.constructor = Chalk;
+		for (var len = adjacents.length, i = 0; i < len; i++) {
+			var adjacent = adjacents[i];
+			var node = graph[adjacent];
 
-		return chalk.template;
+			if (node.distance === -1) {
+				node.distance = graph[current].distance + 1;
+				node.parent = current;
+				queue.unshift(adjacent);
+			}
+		}
 	}
 
-	applyOptions(this, options);
-}
-
-// Use bright blue on Windows as the normal blue color is illegible
-if (isSimpleWindowsTerm) {
-	ansiStyles.blue.open = '\u001B[94m';
+	return graph;
 }
 
-for (const key of Object.keys(ansiStyles)) {
-	ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
-
-	styles[key] = {
-		get() {
-			const codes = ansiStyles[key];
-			return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
-		}
+function link$1(from, to) {
+	return function (args) {
+		return to(from(args));
 	};
 }
 
-styles.visible = {
-	get() {
-		return build.call(this, this._styles || [], true, 'visible');
-	}
-};
+function wrapConversion(toModel, graph) {
+	var path = [graph[toModel].parent, toModel];
+	var fn = conversions$1[graph[toModel].parent][toModel];
 
-ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
-for (const model of Object.keys(ansiStyles.color.ansi)) {
-	if (skipModels.has(model)) {
-		continue;
+	var cur = graph[toModel].parent;
+	while (graph[cur].parent) {
+		path.unshift(graph[cur].parent);
+		fn = link$1(conversions$1[graph[cur].parent][cur], fn);
+		cur = graph[cur].parent;
 	}
 
-	styles[model] = {
-		get() {
-			const level = this.level;
-			return function () {
-				const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
-				const codes = {
-					open,
-					close: ansiStyles.color.close,
-					closeRe: ansiStyles.color.closeRe
-				};
-				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
-			};
-		}
-	};
+	fn.conversion = path;
+	return fn;
 }
 
-ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
-for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
-	if (skipModels.has(model)) {
-		continue;
-	}
+var route$1 = function (fromModel) {
+	var graph = deriveBFS(fromModel);
+	var conversion = {};
 
-	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
-	styles[bgModel] = {
-		get() {
-			const level = this.level;
-			return function () {
-				const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
-				const codes = {
-					open,
-					close: ansiStyles.bgColor.close,
-					closeRe: ansiStyles.bgColor.closeRe
-				};
-				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
-			};
+	var models = Object.keys(graph);
+	for (var len = models.length, i = 0; i < len; i++) {
+		var toModel = models[i];
+		var node = graph[toModel];
+
+		if (node.parent === null) {
+			// no possible conversion, or this node is the source model.
+			continue;
 		}
-	};
-}
 
-const proto = Object.defineProperties(() => {}, styles);
+		conversion[toModel] = wrapConversion(toModel, graph);
+	}
 
-function build(_styles, _empty, key) {
-	const builder = function () {
-		return applyStyle.apply(builder, arguments);
-	};
+	return conversion;
+};
 
-	builder._styles = _styles;
-	builder._empty = _empty;
+var conversions = conversions$2.exports;
+var route = route$1;
 
-	const self = this;
+var convert$1 = {};
 
-	Object.defineProperty(builder, 'level', {
-		enumerable: true,
-		get() {
-			return self.level;
-		},
-		set(level) {
-			self.level = level;
+var models = Object.keys(conversions);
+
+function wrapRaw(fn) {
+	var wrappedFn = function (args) {
+		if (args === undefined || args === null) {
+			return args;
 		}
-	});
 
-	Object.defineProperty(builder, 'enabled', {
-		enumerable: true,
-		get() {
-			return self.enabled;
-		},
-		set(enabled) {
-			self.enabled = enabled;
+		if (arguments.length > 1) {
+			args = Array.prototype.slice.call(arguments);
 		}
-	});
 
-	// See below for fix regarding invisible grey/dim combination on Windows
-	builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+		return fn(args);
+	};
 
-	// `__proto__` is used because we must return a function, but there is
-	// no way to create a function with a different prototype
-	builder.__proto__ = proto; // eslint-disable-line no-proto
+	// preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
 
-	return builder;
+	return wrappedFn;
 }
 
-function applyStyle() {
-	// Support varags, but simply cast to string in case there's only one arg
-	const args = arguments;
-	const argsLen = args.length;
-	let str = String(arguments[0]);
+function wrapRounded(fn) {
+	var wrappedFn = function (args) {
+		if (args === undefined || args === null) {
+			return args;
+		}
 
-	if (argsLen === 0) {
-		return '';
-	}
+		if (arguments.length > 1) {
+			args = Array.prototype.slice.call(arguments);
+		}
 
-	if (argsLen > 1) {
-		// Don't slice `arguments`, it prevents V8 optimizations
-		for (let a = 1; a < argsLen; a++) {
-			str += ' ' + args[a];
+		var result = fn(args);
+
+		// we're assuming the result is an array here.
+		// see notice in conversions.js; don't use box types
+		// in conversion functions.
+		if (typeof result === 'object') {
+			for (var len = result.length, i = 0; i < len; i++) {
+				result[i] = Math.round(result[i]);
+			}
 		}
-	}
 
-	if (!this.enabled || this.level <= 0 || !str) {
-		return this._empty ? '' : str;
-	}
+		return result;
+	};
 
-	// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
-	// see https://github.com/chalk/chalk/issues/58
-	// If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
-	const originalDim = ansiStyles.dim.open;
-	if (isSimpleWindowsTerm && this.hasGrey) {
-		ansiStyles.dim.open = '';
+	// preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
 	}
 
-	for (const code of this._styles.slice().reverse()) {
-		// Replace any instances already present with a re-opening code
-		// otherwise only the part of the string until said closing code
-		// will be colored, and the rest will simply be 'plain'.
-		str = code.open + str.replace(code.closeRe, code.open) + code.close;
+	return wrappedFn;
+}
 
-		// Close the styling before a linebreak and reopen
-		// after next line to fix a bleed issue on macOS
-		// https://github.com/chalk/chalk/pull/92
-		str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
-	}
+models.forEach(function (fromModel) {
+	convert$1[fromModel] = {};
 
-	// Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
-	ansiStyles.dim.open = originalDim;
+	Object.defineProperty(convert$1[fromModel], 'channels', {value: conversions[fromModel].channels});
+	Object.defineProperty(convert$1[fromModel], 'labels', {value: conversions[fromModel].labels});
 
-	return str;
-}
+	var routes = route(fromModel);
+	var routeModels = Object.keys(routes);
 
-function chalkTag(chalk, strings) {
-	if (!Array.isArray(strings)) {
-		// If chalk() was called by itself or with a string,
-		// return the string itself as a string.
-		return [].slice.call(arguments, 1).join(' ');
-	}
+	routeModels.forEach(function (toModel) {
+		var fn = routes[toModel];
 
-	const args = [].slice.call(arguments, 2);
-	const parts = [strings.raw[0]];
+		convert$1[fromModel][toModel] = wrapRounded(fn);
+		convert$1[fromModel][toModel].raw = wrapRaw(fn);
+	});
+});
 
-	for (let i = 1; i < strings.length; i++) {
-		parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
-		parts.push(String(strings.raw[i]));
-	}
+var colorConvert = convert$1;
 
-	return templates(chalk, parts.join(''));
-}
+(function (module) {
+const colorConvert$1 = colorConvert;
 
-Object.defineProperties(Chalk.prototype, styles);
+const wrapAnsi16 = (fn, offset) => function () {
+	const code = fn.apply(colorConvert$1, arguments);
+	return `\u001B[${code + offset}m`;
+};
 
-module.exports = Chalk(); // eslint-disable-line new-cap
-module.exports.supportsColor = stdoutColor;
-module.exports.default = module.exports; // For TypeScript
-});
-var chalk_1 = chalk.supportsColor;
+const wrapAnsi256 = (fn, offset) => function () {
+	const code = fn.apply(colorConvert$1, arguments);
+	return `\u001B[${38 + offset};5;${code}m`;
+};
+
+const wrapAnsi16m = (fn, offset) => function () {
+	const rgb = fn.apply(colorConvert$1, arguments);
+	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
 
-var lib$1 = createCommonjsModule(function (module, exports) {
+function assembleStyles() {
+	const codes = new Map();
+	const styles = {
+		modifier: {
+			reset: [0, 0],
+			// 21 isn't widely supported and 22 does the same thing
+			bold: [1, 22],
+			dim: [2, 22],
+			italic: [3, 23],
+			underline: [4, 24],
+			inverse: [7, 27],
+			hidden: [8, 28],
+			strikethrough: [9, 29]
+		},
+		color: {
+			black: [30, 39],
+			red: [31, 39],
+			green: [32, 39],
+			yellow: [33, 39],
+			blue: [34, 39],
+			magenta: [35, 39],
+			cyan: [36, 39],
+			white: [37, 39],
+			gray: [90, 39],
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.shouldHighlight = shouldHighlight;
-exports.getChalk = getChalk;
-exports.default = highlight;
+			// Bright color
+			redBright: [91, 39],
+			greenBright: [92, 39],
+			yellowBright: [93, 39],
+			blueBright: [94, 39],
+			magentaBright: [95, 39],
+			cyanBright: [96, 39],
+			whiteBright: [97, 39]
+		},
+		bgColor: {
+			bgBlack: [40, 49],
+			bgRed: [41, 49],
+			bgGreen: [42, 49],
+			bgYellow: [43, 49],
+			bgBlue: [44, 49],
+			bgMagenta: [45, 49],
+			bgCyan: [46, 49],
+			bgWhite: [47, 49],
+
+			// Bright color
+			bgBlackBright: [100, 49],
+			bgRedBright: [101, 49],
+			bgGreenBright: [102, 49],
+			bgYellowBright: [103, 49],
+			bgBlueBright: [104, 49],
+			bgMagentaBright: [105, 49],
+			bgCyanBright: [106, 49],
+			bgWhiteBright: [107, 49]
+		}
+	};
+
+	// Fix humans
+	styles.color.grey = styles.color.gray;
 
-var _jsTokens = _interopRequireWildcard(jsTokens);
+	for (const groupName of Object.keys(styles)) {
+		const group = styles[groupName];
 
+		for (const styleName of Object.keys(group)) {
+			const style = group[styleName];
 
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
 
-var _chalk = _interopRequireDefault(chalk);
+			group[styleName] = styles[styleName];
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+			codes.set(style[0], style[1]);
+		}
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false
+		});
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+		Object.defineProperty(styles, 'codes', {
+			value: codes,
+			enumerable: false
+		});
+	}
 
-function getDefs(chalk) {
-  return {
-    keyword: chalk.cyan,
-    capitalized: chalk.yellow,
-    jsx_tag: chalk.yellow,
-    punctuator: chalk.yellow,
-    number: chalk.magenta,
-    string: chalk.green,
-    regex: chalk.magenta,
-    comment: chalk.grey,
-    invalid: chalk.white.bgRed.bold
-  };
-}
+	const ansi2ansi = n => n;
+	const rgb2rgb = (r, g, b) => [r, g, b];
 
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-const JSX_TAG = /^[a-z][\w-]*$/i;
-const BRACKET = /^[()[\]{}]$/;
+	styles.color.close = '\u001B[39m';
+	styles.bgColor.close = '\u001B[49m';
 
-function getTokenType(match) {
-  const [offset, text] = match.slice(-2);
-  const token = (0, _jsTokens.matchToToken)(match);
+	styles.color.ansi = {
+		ansi: wrapAnsi16(ansi2ansi, 0)
+	};
+	styles.color.ansi256 = {
+		ansi256: wrapAnsi256(ansi2ansi, 0)
+	};
+	styles.color.ansi16m = {
+		rgb: wrapAnsi16m(rgb2rgb, 0)
+	};
 
-  if (token.type === "name") {
-    if ((0, lib.isKeyword)(token.value) || (0, lib.isReservedWord)(token.value)) {
-      return "keyword";
-    }
+	styles.bgColor.ansi = {
+		ansi: wrapAnsi16(ansi2ansi, 10)
+	};
+	styles.bgColor.ansi256 = {
+		ansi256: wrapAnsi256(ansi2ansi, 10)
+	};
+	styles.bgColor.ansi16m = {
+		rgb: wrapAnsi16m(rgb2rgb, 10)
+	};
 
-    if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == "</")) {
-      return "jsx_tag";
-    }
+	for (let key of Object.keys(colorConvert$1)) {
+		if (typeof colorConvert$1[key] !== 'object') {
+			continue;
+		}
 
-    if (token.value[0] !== token.value[0].toLowerCase()) {
-      return "capitalized";
-    }
-  }
+		const suite = colorConvert$1[key];
 
-  if (token.type === "punctuator" && BRACKET.test(token.value)) {
-    return "bracket";
-  }
+		if (key === 'ansi16') {
+			key = 'ansi';
+		}
 
-  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
-    return "punctuator";
-  }
+		if ('ansi16' in suite) {
+			styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+			styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+		}
 
-  return token.type;
-}
+		if ('ansi256' in suite) {
+			styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+			styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+		}
 
-function highlightTokens(defs, text) {
-  return text.replace(_jsTokens.default, function (...args) {
-    const type = getTokenType(args);
-    const colorize = defs[type];
+		if ('rgb' in suite) {
+			styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+			styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+		}
+	}
 
-    if (colorize) {
-      return args[0].split(NEWLINE).map(str => colorize(str)).join("\n");
-    } else {
-      return args[0];
-    }
-  });
+	return styles;
 }
 
-function shouldHighlight(options) {
-  return _chalk.default.supportsColor || options.forceColor;
-}
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+	enumerable: true,
+	get: assembleStyles
+});
+}(ansiStyles));
 
-function getChalk(options) {
-  let chalk = _chalk.default;
+var hasFlag$2 = (flag, argv) => {
+	argv = argv || process.argv;
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const pos = argv.indexOf(prefix + flag);
+	const terminatorPos = argv.indexOf('--');
+	return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};
 
-  if (options.forceColor) {
-    chalk = new _chalk.default.constructor({
-      enabled: true,
-      level: 1
-    });
-  }
+const os$1 = require$$0$2;
+const hasFlag$1 = hasFlag$2;
 
-  return chalk;
-}
+const env$1 = process.env;
 
-function highlight(code, options = {}) {
-  if (shouldHighlight(options)) {
-    const chalk = getChalk(options);
-    const defs = getDefs(chalk);
-    return highlightTokens(defs, code);
-  } else {
-    return code;
-  }
+let forceColor;
+if (hasFlag$1('no-color') ||
+	hasFlag$1('no-colors') ||
+	hasFlag$1('color=false')) {
+	forceColor = false;
+} else if (hasFlag$1('color') ||
+	hasFlag$1('colors') ||
+	hasFlag$1('color=true') ||
+	hasFlag$1('color=always')) {
+	forceColor = true;
 }
-});
+if ('FORCE_COLOR' in env$1) {
+	forceColor = env$1.FORCE_COLOR.length === 0 || parseInt(env$1.FORCE_COLOR, 10) !== 0;
+}
+
+function translateLevel$1(level) {
+	if (level === 0) {
+		return false;
+	}
 
-unwrapExports(lib$1);
-var lib_1 = lib$1.shouldHighlight;
-var lib_2 = lib$1.getChalk;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
 
-var lib$2 = createCommonjsModule(function (module, exports) {
+function supportsColor$1(stream) {
+	if (forceColor === false) {
+		return 0;
+	}
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.codeFrameColumns = codeFrameColumns;
-exports.default = _default;
+	if (hasFlag$1('color=16m') ||
+		hasFlag$1('color=full') ||
+		hasFlag$1('color=truecolor')) {
+		return 3;
+	}
 
-var _highlight = _interopRequireWildcard(lib$1);
+	if (hasFlag$1('color=256')) {
+		return 2;
+	}
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+	if (stream && !stream.isTTY && forceColor !== true) {
+		return 0;
+	}
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+	const min = forceColor ? 1 : 0;
 
-let deprecationWarningShown = false;
+	if (process.platform === 'win32') {
+		// Node.js 7.5.0 is the first version of Node.js to include a patch to
+		// libuv that enables 256 color output on Windows. Anything earlier and it
+		// won't work. However, here we target Node.js 8 at minimum as it is an LTS
+		// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+		// release that supports 256 colors. Windows 10 build 14931 is the first release
+		// that supports 16m/TrueColor.
+		const osRelease = os$1.release().split('.');
+		if (
+			Number(process.versions.node.split('.')[0]) >= 8 &&
+			Number(osRelease[0]) >= 10 &&
+			Number(osRelease[2]) >= 10586
+		) {
+			return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		}
 
-function getDefs(chalk) {
-  return {
-    gutter: chalk.grey,
-    marker: chalk.red.bold,
-    message: chalk.red.bold
-  };
-}
+		return 1;
+	}
 
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+	if ('CI' in env$1) {
+		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env$1) || env$1.CI_NAME === 'codeship') {
+			return 1;
+		}
 
-function getMarkerLines(loc, source, opts) {
-  const startLoc = Object.assign({
-    column: 0,
-    line: -1
-  }, loc.start);
-  const endLoc = Object.assign({}, startLoc, {}, loc.end);
-  const {
-    linesAbove = 2,
-    linesBelow = 3
-  } = opts || {};
-  const startLine = startLoc.line;
-  const startColumn = startLoc.column;
-  const endLine = endLoc.line;
-  const endColumn = endLoc.column;
-  let start = Math.max(startLine - (linesAbove + 1), 0);
-  let end = Math.min(source.length, endLine + linesBelow);
+		return min;
+	}
 
-  if (startLine === -1) {
-    start = 0;
-  }
+	if ('TEAMCITY_VERSION' in env$1) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0;
+	}
 
-  if (endLine === -1) {
-    end = source.length;
-  }
+	if (env$1.COLORTERM === 'truecolor') {
+		return 3;
+	}
 
-  const lineDiff = endLine - startLine;
-  const markerLines = {};
+	if ('TERM_PROGRAM' in env$1) {
+		const version = parseInt((env$1.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
 
-  if (lineDiff) {
-    for (let i = 0; i <= lineDiff; i++) {
-      const lineNumber = i + startLine;
+		switch (env$1.TERM_PROGRAM) {
+			case 'iTerm.app':
+				return version >= 3 ? 3 : 2;
+			case 'Apple_Terminal':
+				return 2;
+			// No default
+		}
+	}
 
-      if (!startColumn) {
-        markerLines[lineNumber] = true;
-      } else if (i === 0) {
-        const sourceLength = source[lineNumber - 1].length;
-        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
-      } else if (i === lineDiff) {
-        markerLines[lineNumber] = [0, endColumn];
-      } else {
-        const sourceLength = source[lineNumber - i].length;
-        markerLines[lineNumber] = [0, sourceLength];
-      }
-    }
-  } else {
-    if (startColumn === endColumn) {
-      if (startColumn) {
-        markerLines[startLine] = [startColumn, 0];
-      } else {
-        markerLines[startLine] = true;
-      }
-    } else {
-      markerLines[startLine] = [startColumn, endColumn - startColumn];
-    }
-  }
+	if (/-256(color)?$/i.test(env$1.TERM)) {
+		return 2;
+	}
 
-  return {
-    start,
-    end,
-    markerLines
-  };
-}
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$1.TERM)) {
+		return 1;
+	}
 
-function codeFrameColumns(rawLines, loc, opts = {}) {
-  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
-  const chalk = (0, _highlight.getChalk)(opts);
-  const defs = getDefs(chalk);
+	if ('COLORTERM' in env$1) {
+		return 1;
+	}
 
-  const maybeHighlight = (chalkFn, string) => {
-    return highlighted ? chalkFn(string) : string;
-  };
+	if (env$1.TERM === 'dumb') {
+		return min;
+	}
 
-  const lines = rawLines.split(NEWLINE);
-  const {
-    start,
-    end,
-    markerLines
-  } = getMarkerLines(loc, lines, opts);
-  const hasColumns = loc.start && typeof loc.start.column === "number";
-  const numberMaxWidth = String(end).length;
-  const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
-  let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
-    const number = start + 1 + index;
-    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
-    const gutter = ` ${paddedNumber} | `;
-    const hasMarker = markerLines[number];
-    const lastMarkerLine = !markerLines[number + 1];
+	return min;
+}
 
-    if (hasMarker) {
-      let markerLine = "";
+function getSupportLevel(stream) {
+	const level = supportsColor$1(stream);
+	return translateLevel$1(level);
+}
 
-      if (Array.isArray(hasMarker)) {
-        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
-        const numberOfMarkers = hasMarker[1] || 1;
-        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
+var supportsColor_1 = {
+	supportsColor: getSupportLevel,
+	stdout: getSupportLevel(process.stdout),
+	stderr: getSupportLevel(process.stderr)
+};
 
-        if (lastMarkerLine && opts.message) {
-          markerLine += " " + maybeHighlight(defs.message, opts.message);
-        }
-      }
+const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
 
-      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
-    } else {
-      return ` ${maybeHighlight(defs.gutter, gutter)}${line}`;
-    }
-  }).join("\n");
+const ESCAPES = new Map([
+	['n', '\n'],
+	['r', '\r'],
+	['t', '\t'],
+	['b', '\b'],
+	['f', '\f'],
+	['v', '\v'],
+	['0', '\0'],
+	['\\', '\\'],
+	['e', '\u001B'],
+	['a', '\u0007']
+]);
 
-  if (opts.message && !hasColumns) {
-    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
-  }
+function unescape(c) {
+	if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+		return String.fromCharCode(parseInt(c.slice(1), 16));
+	}
 
-  if (highlighted) {
-    return chalk.reset(frame);
-  } else {
-    return frame;
-  }
+	return ESCAPES.get(c) || c;
 }
 
-function _default(rawLines, lineNumber, colNumber, opts = {}) {
-  if (!deprecationWarningShown) {
-    deprecationWarningShown = true;
-    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+function parseArguments(name, args) {
+	const results = [];
+	const chunks = args.trim().split(/\s*,\s*/g);
+	let matches;
 
-    if (process.emitWarning) {
-      process.emitWarning(message, "DeprecationWarning");
-    } else {
-      const deprecationError = new Error(message);
-      deprecationError.name = "DeprecationWarning";
-      console.warn(new Error(message));
-    }
-  }
+	for (const chunk of chunks) {
+		if (!isNaN(chunk)) {
+			results.push(Number(chunk));
+		} else if ((matches = chunk.match(STRING_REGEX))) {
+			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+		} else {
+			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+		}
+	}
 
-  colNumber = Math.max(colNumber, 0);
-  const location = {
-    start: {
-      column: colNumber,
-      line: lineNumber
-    }
-  };
-  return codeFrameColumns(rawLines, location, opts);
+	return results;
 }
-});
 
-unwrapExports(lib$2);
-var lib_1$1 = lib$2.codeFrameColumns;
+function parseStyle(style) {
+	STYLE_REGEX.lastIndex = 0;
+
+	const results = [];
+	let matches;
+
+	while ((matches = STYLE_REGEX.exec(style)) !== null) {
+		const name = matches[1];
 
-var require$$0 = getCjsExportFromNamespace(dist);
+		if (matches[2]) {
+			const args = parseArguments(name, matches[2]);
+			results.push([name].concat(args));
+		} else {
+			results.push([name]);
+		}
+	}
 
-const {default: LinesAndColumns$1} = require$$0;
-const {codeFrameColumns} = lib$2;
+	return results;
+}
 
-const JSONError = errorEx_1('JSONError', {
-	fileName: errorEx_1.append('in %s'),
-	codeFrame: errorEx_1.append('\n\n%s\n')
-});
+function buildStyle(chalk, styles) {
+	const enabled = {};
 
-var parseJson$1 = (string, reviver, filename) => {
-	if (typeof reviver === 'string') {
-		filename = reviver;
-		reviver = null;
+	for (const layer of styles) {
+		for (const style of layer.styles) {
+			enabled[style[0]] = layer.inverse ? null : style.slice(1);
+		}
 	}
 
-	try {
-		try {
-			return JSON.parse(string, reviver);
-		} catch (error) {
-			jsonParseBetterErrors(string, reviver);
-			throw error;
-		}
-	} catch (error) {
-		error.message = error.message.replace(/\n/g, '');
-		const indexMatch = error.message.match(/in JSON at position (\d+) while parsing near/);
+	let current = chalk;
+	for (const styleName of Object.keys(enabled)) {
+		if (Array.isArray(enabled[styleName])) {
+			if (!(styleName in current)) {
+				throw new Error(`Unknown Chalk style: ${styleName}`);
+			}
 
-		const jsonError = new JSONError(error);
-		if (filename) {
-			jsonError.fileName = filename;
+			if (enabled[styleName].length > 0) {
+				current = current[styleName].apply(current, enabled[styleName]);
+			} else {
+				current = current[styleName];
+			}
 		}
+	}
 
-		if (indexMatch && indexMatch.length > 0) {
-			const lines = new LinesAndColumns$1(string);
-			const index = Number(indexMatch[1]);
-			const location = lines.locationForIndex(index);
-
-			const codeFrame = codeFrameColumns(
-				string,
-				{start: {line: location.line + 1, column: location.column + 1}},
-				{highlightCode: true}
-			);
+	return current;
+}
 
-			jsonError.codeFrame = codeFrame;
-		}
+var templates = (chalk, tmp) => {
+	const styles = [];
+	const chunks = [];
+	let chunk = [];
 
-		throw jsonError;
-	}
-};
+	// eslint-disable-next-line max-params
+	tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+		if (escapeChar) {
+			chunk.push(unescape(escapeChar));
+		} else if (style) {
+			const str = chunk.join('');
+			chunk = [];
+			chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+			styles.push({inverse, styles: parseStyle(style)});
+		} else if (close) {
+			if (styles.length === 0) {
+				throw new Error('Found extraneous } in Chalk template literal');
+			}
 
-/**
- * Helpers.
- */
+			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+			chunk = [];
+			styles.pop();
+		} else {
+			chunk.push(chr);
+		}
+	});
 
-var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var w = d * 7;
-var y = d * 365.25;
+	chunks.push(chunk.join(''));
 
-/**
- * Parse or format the given `val`.
- *
- * Options:
- *
- *  - `long` verbose formatting [false]
- *
- * @param {String|Number} val
- * @param {Object} [options]
- * @throws {Error} throw an error if val is not a non-empty string or a number
- * @return {String|Number}
- * @api public
- */
+	if (styles.length > 0) {
+		const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+		throw new Error(errMsg);
+	}
 
-var ms = function(val, options) {
-  options = options || {};
-  var type = typeof val;
-  if (type === 'string' && val.length > 0) {
-    return parse$1(val);
-  } else if (type === 'number' && isFinite(val)) {
-    return options.long ? fmtLong(val) : fmtShort(val);
-  }
-  throw new Error(
-    'val is not a non-empty string or a valid number. val=' +
-      JSON.stringify(val)
-  );
+	return chunks.join('');
 };
 
-/**
- * Parse the given `str` and return milliseconds.
- *
- * @param {String} str
- * @return {Number}
- * @api private
- */
+(function (module) {
+const escapeStringRegexp = escapeStringRegexp$1;
+const ansiStyles$1 = ansiStyles.exports;
+const stdoutColor = supportsColor_1.stdout;
 
-function parse$1(str) {
-  str = String(str);
-  if (str.length > 100) {
-    return;
-  }
-  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-    str
-  );
-  if (!match) {
-    return;
-  }
-  var n = parseFloat(match[1]);
-  var type = (match[2] || 'ms').toLowerCase();
-  switch (type) {
-    case 'years':
-    case 'year':
-    case 'yrs':
-    case 'yr':
-    case 'y':
-      return n * y;
-    case 'weeks':
-    case 'week':
-    case 'w':
-      return n * w;
-    case 'days':
-    case 'day':
-    case 'd':
-      return n * d;
-    case 'hours':
-    case 'hour':
-    case 'hrs':
-    case 'hr':
-    case 'h':
-      return n * h;
-    case 'minutes':
-    case 'minute':
-    case 'mins':
-    case 'min':
-    case 'm':
-      return n * m;
-    case 'seconds':
-    case 'second':
-    case 'secs':
-    case 'sec':
-    case 's':
-      return n * s;
-    case 'milliseconds':
-    case 'millisecond':
-    case 'msecs':
-    case 'msec':
-    case 'ms':
-      return n;
-    default:
-      return undefined;
-  }
-}
+const template = templates;
 
-/**
- * Short format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
+const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
 
-function fmtShort(ms) {
-  var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return Math.round(ms / d) + 'd';
-  }
-  if (msAbs >= h) {
-    return Math.round(ms / h) + 'h';
-  }
-  if (msAbs >= m) {
-    return Math.round(ms / m) + 'm';
-  }
-  if (msAbs >= s) {
-    return Math.round(ms / s) + 's';
-  }
-  return ms + 'ms';
-}
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
 
-/**
- * Long format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
+// `color-convert` models to exclude from the Chalk API due to conflicts and such
+const skipModels = new Set(['gray']);
 
-function fmtLong(ms) {
-  var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return plural(ms, msAbs, d, 'day');
-  }
-  if (msAbs >= h) {
-    return plural(ms, msAbs, h, 'hour');
-  }
-  if (msAbs >= m) {
-    return plural(ms, msAbs, m, 'minute');
-  }
-  if (msAbs >= s) {
-    return plural(ms, msAbs, s, 'second');
-  }
-  return ms + ' ms';
-}
+const styles = Object.create(null);
 
-/**
- * Pluralization helper.
- */
+function applyOptions(obj, options) {
+	options = options || {};
 
-function plural(ms, msAbs, n, name) {
-  var isPlural = msAbs >= n * 1.5;
-  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	// Detect level if not set manually
+	const scLevel = stdoutColor ? stdoutColor.level : 0;
+	obj.level = options.level === undefined ? scLevel : options.level;
+	obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
 }
 
-/**
- * This is the common logic for both the Node.js and web browser
- * implementations of `debug()`.
- */
+function Chalk(options) {
+	// We check for this.template here since calling `chalk.constructor()`
+	// by itself will have a `this` of a previously constructed chalk object
+	if (!this || !(this instanceof Chalk) || this.template) {
+		const chalk = {};
+		applyOptions(chalk, options);
 
-function setup(env) {
-	createDebug.debug = createDebug;
-	createDebug.default = createDebug;
-	createDebug.coerce = coerce;
-	createDebug.disable = disable;
-	createDebug.enable = enable;
-	createDebug.enabled = enabled;
-	createDebug.humanize = ms;
+		chalk.template = function () {
+			const args = [].slice.call(arguments);
+			return chalkTag.apply(null, [chalk.template].concat(args));
+		};
 
-	Object.keys(env).forEach(key => {
-		createDebug[key] = env[key];
-	});
+		Object.setPrototypeOf(chalk, Chalk.prototype);
+		Object.setPrototypeOf(chalk.template, chalk);
 
-	/**
-	* Active `debug` instances.
-	*/
-	createDebug.instances = [];
+		chalk.template.constructor = Chalk;
 
-	/**
-	* The currently active debug mode names, and names to skip.
-	*/
+		return chalk.template;
+	}
 
-	createDebug.names = [];
-	createDebug.skips = [];
+	applyOptions(this, options);
+}
 
-	/**
-	* Map of special "%n" handling functions, for the debug "format" argument.
-	*
-	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
-	*/
-	createDebug.formatters = {};
+// Use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+	ansiStyles$1.blue.open = '\u001B[94m';
+}
 
-	/**
-	* Selects a color for a debug namespace
-	* @param {String} namespace The namespace string for the for the debug instance to be colored
-	* @return {Number|String} An ANSI color code for the given namespace
-	* @api private
-	*/
-	function selectColor(namespace) {
-		let hash = 0;
+for (const key of Object.keys(ansiStyles$1)) {
+	ansiStyles$1[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles$1[key].close), 'g');
 
-		for (let i = 0; i < namespace.length; i++) {
-			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
-			hash |= 0; // Convert to 32bit integer
+	styles[key] = {
+		get() {
+			const codes = ansiStyles$1[key];
+			return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
 		}
+	};
+}
 
-		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+styles.visible = {
+	get() {
+		return build.call(this, this._styles || [], true, 'visible');
 	}
-	createDebug.selectColor = selectColor;
+};
 
-	/**
-	* Create a debugger with the given `namespace`.
-	*
-	* @param {String} namespace
-	* @return {Function}
-	* @api public
-	*/
-	function createDebug(namespace) {
-		let prevTime;
+ansiStyles$1.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles$1.color.close), 'g');
+for (const model of Object.keys(ansiStyles$1.color.ansi)) {
+	if (skipModels.has(model)) {
+		continue;
+	}
 
-		function debug(...args) {
-			// Disabled?
-			if (!debug.enabled) {
-				return;
-			}
+	styles[model] = {
+		get() {
+			const level = this.level;
+			return function () {
+				const open = ansiStyles$1.color[levelMapping[level]][model].apply(null, arguments);
+				const codes = {
+					open,
+					close: ansiStyles$1.color.close,
+					closeRe: ansiStyles$1.color.closeRe
+				};
+				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+			};
+		}
+	};
+}
 
-			const self = debug;
+ansiStyles$1.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles$1.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles$1.bgColor.ansi)) {
+	if (skipModels.has(model)) {
+		continue;
+	}
 
-			// Set `diff` timestamp
-			const curr = Number(new Date());
-			const ms = curr - (prevTime || curr);
-			self.diff = ms;
-			self.prev = prevTime;
-			self.curr = curr;
-			prevTime = curr;
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const level = this.level;
+			return function () {
+				const open = ansiStyles$1.bgColor[levelMapping[level]][model].apply(null, arguments);
+				const codes = {
+					open,
+					close: ansiStyles$1.bgColor.close,
+					closeRe: ansiStyles$1.bgColor.closeRe
+				};
+				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+			};
+		}
+	};
+}
 
-			args[0] = createDebug.coerce(args[0]);
+const proto = Object.defineProperties(() => {}, styles);
 
-			if (typeof args[0] !== 'string') {
-				// Anything else let's inspect with %O
-				args.unshift('%O');
-			}
+function build(_styles, _empty, key) {
+	const builder = function () {
+		return applyStyle.apply(builder, arguments);
+	};
 
-			// Apply any `formatters` transformations
-			let index = 0;
-			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-				// If we encounter an escaped % then don't increase the array index
-				if (match === '%%') {
-					return match;
-				}
-				index++;
-				const formatter = createDebug.formatters[format];
-				if (typeof formatter === 'function') {
-					const val = args[index];
-					match = formatter.call(self, val);
+	builder._styles = _styles;
+	builder._empty = _empty;
 
-					// Now we need to remove `args[index]` since it's inlined in the `format`
-					args.splice(index, 1);
-					index--;
-				}
-				return match;
-			});
+	const self = this;
 
-			// Apply env-specific formatting (colors, etc.)
-			createDebug.formatArgs.call(self, args);
+	Object.defineProperty(builder, 'level', {
+		enumerable: true,
+		get() {
+			return self.level;
+		},
+		set(level) {
+			self.level = level;
+		}
+	});
 
-			const logFn = self.log || createDebug.log;
-			logFn.apply(self, args);
+	Object.defineProperty(builder, 'enabled', {
+		enumerable: true,
+		get() {
+			return self.enabled;
+		},
+		set(enabled) {
+			self.enabled = enabled;
 		}
+	});
 
-		debug.namespace = namespace;
-		debug.enabled = createDebug.enabled(namespace);
-		debug.useColors = createDebug.useColors();
-		debug.color = selectColor(namespace);
-		debug.destroy = destroy;
-		debug.extend = extend;
-		// Debug.formatArgs = formatArgs;
-		// debug.rawLog = rawLog;
+	// See below for fix regarding invisible grey/dim combination on Windows
+	builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
 
-		// env-specific initialization logic for debug instances
-		if (typeof createDebug.init === 'function') {
-			createDebug.init(debug);
-		}
+	// `__proto__` is used because we must return a function, but there is
+	// no way to create a function with a different prototype
+	builder.__proto__ = proto; // eslint-disable-line no-proto
+
+	return builder;
+}
 
-		createDebug.instances.push(debug);
+function applyStyle() {
+	// Support varags, but simply cast to string in case there's only one arg
+	const args = arguments;
+	const argsLen = args.length;
+	let str = String(arguments[0]);
 
-		return debug;
+	if (argsLen === 0) {
+		return '';
 	}
 
-	function destroy() {
-		const index = createDebug.instances.indexOf(this);
-		if (index !== -1) {
-			createDebug.instances.splice(index, 1);
-			return true;
+	if (argsLen > 1) {
+		// Don't slice `arguments`, it prevents V8 optimizations
+		for (let a = 1; a < argsLen; a++) {
+			str += ' ' + args[a];
 		}
-		return false;
 	}
 
-	function extend(namespace, delimiter) {
-		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
-		newDebug.log = this.log;
-		return newDebug;
+	if (!this.enabled || this.level <= 0 || !str) {
+		return this._empty ? '' : str;
 	}
 
-	/**
-	* Enables a debug mode by namespaces. This can include modes
-	* separated by a colon and wildcards.
-	*
-	* @param {String} namespaces
-	* @api public
-	*/
-	function enable(namespaces) {
-		createDebug.save(namespaces);
-
-		createDebug.names = [];
-		createDebug.skips = [];
-
-		let i;
-		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
-		const len = split.length;
+	// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
+	// see https://github.com/chalk/chalk/issues/58
+	// If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
+	const originalDim = ansiStyles$1.dim.open;
+	if (isSimpleWindowsTerm && this.hasGrey) {
+		ansiStyles$1.dim.open = '';
+	}
 
-		for (i = 0; i < len; i++) {
-			if (!split[i]) {
-				// ignore empty strings
-				continue;
-			}
+	for (const code of this._styles.slice().reverse()) {
+		// Replace any instances already present with a re-opening code
+		// otherwise only the part of the string until said closing code
+		// will be colored, and the rest will simply be 'plain'.
+		str = code.open + str.replace(code.closeRe, code.open) + code.close;
 
-			namespaces = split[i].replace(/\*/g, '.*?');
+		// Close the styling before a linebreak and reopen
+		// after next line to fix a bleed issue on macOS
+		// https://github.com/chalk/chalk/pull/92
+		str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+	}
 
-			if (namespaces[0] === '-') {
-				createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
-			} else {
-				createDebug.names.push(new RegExp('^' + namespaces + '$'));
-			}
-		}
+	// Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
+	ansiStyles$1.dim.open = originalDim;
 
-		for (i = 0; i < createDebug.instances.length; i++) {
-			const instance = createDebug.instances[i];
-			instance.enabled = createDebug.enabled(instance.namespace);
-		}
-	}
+	return str;
+}
 
-	/**
-	* Disable debug output.
-	*
-	* @return {String} namespaces
-	* @api public
-	*/
-	function disable() {
-		const namespaces = [
-			...createDebug.names.map(toNamespace),
-			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
-		].join(',');
-		createDebug.enable('');
-		return namespaces;
+function chalkTag(chalk, strings) {
+	if (!Array.isArray(strings)) {
+		// If chalk() was called by itself or with a string,
+		// return the string itself as a string.
+		return [].slice.call(arguments, 1).join(' ');
 	}
 
-	/**
-	* Returns true if the given mode name is enabled, false otherwise.
-	*
-	* @param {String} name
-	* @return {Boolean}
-	* @api public
-	*/
-	function enabled(name) {
-		if (name[name.length - 1] === '*') {
-			return true;
-		}
+	const args = [].slice.call(arguments, 2);
+	const parts = [strings.raw[0]];
 
-		let i;
-		let len;
+	for (let i = 1; i < strings.length; i++) {
+		parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+		parts.push(String(strings.raw[i]));
+	}
 
-		for (i = 0, len = createDebug.skips.length; i < len; i++) {
-			if (createDebug.skips[i].test(name)) {
-				return false;
-			}
-		}
+	return template(chalk, parts.join(''));
+}
 
-		for (i = 0, len = createDebug.names.length; i < len; i++) {
-			if (createDebug.names[i].test(name)) {
-				return true;
-			}
-		}
+Object.defineProperties(Chalk.prototype, styles);
 
-		return false;
-	}
+module.exports = Chalk(); // eslint-disable-line new-cap
+module.exports.supportsColor = stdoutColor;
+module.exports.default = module.exports; // For TypeScript
+}(chalk));
 
-	/**
-	* Convert regexp to namespace
-	*
-	* @param {RegExp} regxep
-	* @return {String} namespace
-	* @api private
-	*/
-	function toNamespace(regexp) {
-		return regexp.toString()
-			.substring(2, regexp.toString().length - 2)
-			.replace(/\.\*\?$/, '*');
-	}
+Object.defineProperty(lib$3, "__esModule", {
+  value: true
+});
+lib$3.shouldHighlight = shouldHighlight;
+lib$3.getChalk = getChalk;
+lib$3.default = highlight;
 
-	/**
-	* Coerce `val`.
-	*
-	* @param {Mixed} val
-	* @return {Mixed}
-	* @api private
-	*/
-	function coerce(val) {
-		if (val instanceof Error) {
-			return val.stack || val.message;
-		}
-		return val;
-	}
+var _jsTokens = jsTokens;
 
-	createDebug.enable(createDebug.load());
+var _helperValidatorIdentifier = lib$2;
 
-	return createDebug;
+var _chalk = chalk.exports;
+
+const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
+
+function getDefs$1(chalk) {
+  return {
+    keyword: chalk.cyan,
+    capitalized: chalk.yellow,
+    jsxIdentifier: chalk.yellow,
+    punctuator: chalk.yellow,
+    number: chalk.magenta,
+    string: chalk.green,
+    regex: chalk.magenta,
+    comment: chalk.grey,
+    invalid: chalk.white.bgRed.bold
+  };
 }
 
-var common$1 = setup;
+const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
+const BRACKET = /^[()[\]{}]$/;
+let tokenize;
+{
+  const JSX_TAG = /^[a-z][\w-]*$/i;
 
-var browser = createCommonjsModule(function (module, exports) {
-/* eslint-env browser */
+  const getTokenType = function (token, offset, text) {
+    if (token.type === "name") {
+      if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isStrictReservedWord)(token.value, true) || sometimesKeywords.has(token.value)) {
+        return "keyword";
+      }
 
-/**
- * This is the web browser implementation of `debug()`.
- */
+      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == "</")) {
+        return "jsxIdentifier";
+      }
 
-exports.log = log;
-exports.formatArgs = formatArgs;
-exports.save = save;
-exports.load = load;
-exports.useColors = useColors;
-exports.storage = localstorage();
+      if (token.value[0] !== token.value[0].toLowerCase()) {
+        return "capitalized";
+      }
+    }
 
-/**
- * Colors.
- */
+    if (token.type === "punctuator" && BRACKET.test(token.value)) {
+      return "bracket";
+    }
 
-exports.colors = [
-	'#0000CC',
-	'#0000FF',
-	'#0033CC',
-	'#0033FF',
-	'#0066CC',
-	'#0066FF',
-	'#0099CC',
-	'#0099FF',
-	'#00CC00',
-	'#00CC33',
-	'#00CC66',
-	'#00CC99',
-	'#00CCCC',
-	'#00CCFF',
-	'#3300CC',
-	'#3300FF',
-	'#3333CC',
-	'#3333FF',
-	'#3366CC',
-	'#3366FF',
-	'#3399CC',
-	'#3399FF',
-	'#33CC00',
-	'#33CC33',
-	'#33CC66',
-	'#33CC99',
-	'#33CCCC',
-	'#33CCFF',
-	'#6600CC',
-	'#6600FF',
-	'#6633CC',
-	'#6633FF',
-	'#66CC00',
-	'#66CC33',
-	'#9900CC',
-	'#9900FF',
-	'#9933CC',
-	'#9933FF',
-	'#99CC00',
-	'#99CC33',
-	'#CC0000',
-	'#CC0033',
-	'#CC0066',
-	'#CC0099',
-	'#CC00CC',
-	'#CC00FF',
-	'#CC3300',
-	'#CC3333',
-	'#CC3366',
-	'#CC3399',
-	'#CC33CC',
-	'#CC33FF',
-	'#CC6600',
-	'#CC6633',
-	'#CC9900',
-	'#CC9933',
-	'#CCCC00',
-	'#CCCC33',
-	'#FF0000',
-	'#FF0033',
-	'#FF0066',
-	'#FF0099',
-	'#FF00CC',
-	'#FF00FF',
-	'#FF3300',
-	'#FF3333',
-	'#FF3366',
-	'#FF3399',
-	'#FF33CC',
-	'#FF33FF',
-	'#FF6600',
-	'#FF6633',
-	'#FF9900',
-	'#FF9933',
-	'#FFCC00',
-	'#FFCC33'
-];
+    if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+      return "punctuator";
+    }
 
-/**
- * Currently only WebKit-based Web Inspectors, Firefox >= v31,
- * and the Firebug extension (any Firefox version) are known
- * to support "%c" CSS customizations.
- *
- * TODO: add a `localStorage` variable to explicitly enable/disable colors
- */
+    return token.type;
+  };
 
-// eslint-disable-next-line complexity
-function useColors() {
-	// NB: In an Electron preload script, document will be defined but not fully
-	// initialized. Since we know we're in Chrome, we'll just detect this case
-	// explicitly
-	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
-		return true;
-	}
+  tokenize = function* (text) {
+    let match;
 
-	// Internet Explorer and Edge do not support colors.
-	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-		return false;
-	}
+    while (match = _jsTokens.default.exec(text)) {
+      const token = _jsTokens.matchToToken(match);
 
-	// Is webkit? http://stackoverflow.com/a/16459606/376773
-	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
-	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
-		// Is firebug? http://stackoverflow.com/a/398120/376773
-		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
-		// Is firefox >= v31?
-		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
-		// Double check webkit in userAgent just in case we are in a worker
-		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+      yield {
+        type: getTokenType(token, match.index, text),
+        value: token.value
+      };
+    }
+  };
 }
 
-/**
- * Colorize log arguments if enabled.
- *
- * @api public
- */
-
-function formatArgs(args) {
-	args[0] = (this.useColors ? '%c' : '') +
-		this.namespace +
-		(this.useColors ? ' %c' : ' ') +
-		args[0] +
-		(this.useColors ? '%c ' : ' ') +
-		'+' + module.exports.humanize(this.diff);
+function highlightTokens(defs, text) {
+  let highlighted = "";
 
-	if (!this.useColors) {
-		return;
-	}
+  for (const {
+    type,
+    value
+  } of tokenize(text)) {
+    const colorize = defs[type];
 
-	const c = 'color: ' + this.color;
-	args.splice(1, 0, c, 'color: inherit');
+    if (colorize) {
+      highlighted += value.split(NEWLINE$1).map(str => colorize(str)).join("\n");
+    } else {
+      highlighted += value;
+    }
+  }
 
-	// The final "%c" is somewhat tricky, because there could be other
-	// arguments passed either before or after the %c, so we need to
-	// figure out the correct index to insert the CSS into
-	let index = 0;
-	let lastC = 0;
-	args[0].replace(/%[a-zA-Z%]/g, match => {
-		if (match === '%%') {
-			return;
-		}
-		index++;
-		if (match === '%c') {
-			// We only are interested in the *last* %c
-			// (the user may have provided their own)
-			lastC = index;
-		}
-	});
+  return highlighted;
+}
 
-	args.splice(lastC, 0, c);
+function shouldHighlight(options) {
+  return !!_chalk.supportsColor || options.forceColor;
 }
 
-/**
- * Invokes `console.log()` when available.
- * No-op when `console.log` is not a "function".
- *
- * @api public
- */
-function log(...args) {
-	// This hackery is required for IE8/9, where
-	// the `console.log` function doesn't have 'apply'
-	return typeof console === 'object' &&
-		console.log &&
-		console.log(...args);
+function getChalk(options) {
+  return options.forceColor ? new _chalk.constructor({
+    enabled: true,
+    level: 1
+  }) : _chalk;
 }
 
-/**
- * Save `namespaces`.
- *
- * @param {String} namespaces
- * @api private
- */
-function save(namespaces) {
-	try {
-		if (namespaces) {
-			exports.storage.setItem('debug', namespaces);
-		} else {
-			exports.storage.removeItem('debug');
-		}
-	} catch (error) {
-		// Swallow
-		// XXX (@Qix-) should we be logging these?
-	}
+function highlight(code, options = {}) {
+  if (shouldHighlight(options)) {
+    const chalk = getChalk(options);
+    const defs = getDefs$1(chalk);
+    return highlightTokens(defs, code);
+  } else {
+    return code;
+  }
 }
 
-/**
- * Load `namespaces`.
- *
- * @return {String} returns the previously persisted debug modes
- * @api private
- */
-function load() {
-	let r;
-	try {
-		r = exports.storage.getItem('debug');
-	} catch (error) {
-		// Swallow
-		// XXX (@Qix-) should we be logging these?
-	}
+Object.defineProperty(lib$4, "__esModule", {
+  value: true
+});
+lib$4.codeFrameColumns = codeFrameColumns$1;
+lib$4.default = _default;
 
-	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
-	if (!r && typeof process !== 'undefined' && 'env' in process) {
-		r = process.env.DEBUG;
-	}
+var _highlight = lib$3;
 
-	return r;
+let deprecationWarningShown = false;
+
+function getDefs(chalk) {
+  return {
+    gutter: chalk.grey,
+    marker: chalk.red.bold,
+    message: chalk.red.bold
+  };
 }
 
-/**
- * Localstorage attempts to return the localstorage.
- *
- * This is necessary because safari throws
- * when a user disables cookies/localstorage
- * and you attempt to access it.
- *
- * @return {LocalStorage}
- * @api private
- */
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
 
-function localstorage() {
-	try {
-		// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
-		// The Browser also has localStorage in the global context.
-		return localStorage;
-	} catch (error) {
-		// Swallow
-		// XXX (@Qix-) should we be logging these?
-	}
-}
+function getMarkerLines(loc, source, opts) {
+  const startLoc = Object.assign({
+    column: 0,
+    line: -1
+  }, loc.start);
+  const endLoc = Object.assign({}, startLoc, loc.end);
+  const {
+    linesAbove = 2,
+    linesBelow = 3
+  } = opts || {};
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
 
-module.exports = common$1(exports);
+  if (startLine === -1) {
+    start = 0;
+  }
 
-const {formatters} = module.exports;
+  if (endLine === -1) {
+    end = source.length;
+  }
 
-/**
- * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
- */
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
 
-formatters.j = function (v) {
-	try {
-		return JSON.stringify(v);
-	} catch (error) {
-		return '[UnexpectedJSONParseError]: ' + error.message;
-	}
-};
-});
-var browser_1 = browser.log;
-var browser_2 = browser.formatArgs;
-var browser_3 = browser.save;
-var browser_4 = browser.load;
-var browser_5 = browser.useColors;
-var browser_6 = browser.storage;
-var browser_7 = browser.colors;
-
-var hasFlag$1 = (flag, argv = process.argv) => {
-	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
-	const position = argv.indexOf(prefix + flag);
-	const terminatorPosition = argv.indexOf('--');
-	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-};
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
 
-const {env: env$1} = process;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
 
-let forceColor$1;
-if (hasFlag$1('no-color') ||
-	hasFlag$1('no-colors') ||
-	hasFlag$1('color=false') ||
-	hasFlag$1('color=never')) {
-	forceColor$1 = 0;
-} else if (hasFlag$1('color') ||
-	hasFlag$1('colors') ||
-	hasFlag$1('color=true') ||
-	hasFlag$1('color=always')) {
-	forceColor$1 = 1;
+  return {
+    start,
+    end,
+    markerLines
+  };
 }
 
-if ('FORCE_COLOR' in env$1) {
-	if (env$1.FORCE_COLOR === 'true') {
-		forceColor$1 = 1;
-	} else if (env$1.FORCE_COLOR === 'false') {
-		forceColor$1 = 0;
-	} else {
-		forceColor$1 = env$1.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env$1.FORCE_COLOR, 10), 3);
-	}
-}
+function codeFrameColumns$1(rawLines, loc, opts = {}) {
+  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
+  const chalk = (0, _highlight.getChalk)(opts);
+  const defs = getDefs(chalk);
 
-function translateLevel$1(level) {
-	if (level === 0) {
-		return false;
-	}
+  const maybeHighlight = (chalkFn, string) => {
+    return highlighted ? chalkFn(string) : string;
+  };
 
-	return {
-		level,
-		hasBasic: true,
-		has256: level >= 2,
-		has16m: level >= 3
-	};
-}
+  const lines = rawLines.split(NEWLINE);
+  const {
+    start,
+    end,
+    markerLines
+  } = getMarkerLines(loc, lines, opts);
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const numberMaxWidth = String(end).length;
+  const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
+  let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} |`;
+    const hasMarker = markerLines[number];
+    const lastMarkerLine = !markerLines[number + 1];
 
-function supportsColor$1(haveStream, streamIsTTY) {
-	if (forceColor$1 === 0) {
-		return 0;
-	}
+    if (hasMarker) {
+      let markerLine = "";
 
-	if (hasFlag$1('color=16m') ||
-		hasFlag$1('color=full') ||
-		hasFlag$1('color=truecolor')) {
-		return 3;
-	}
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
 
-	if (hasFlag$1('color=256')) {
-		return 2;
-	}
+        if (lastMarkerLine && opts.message) {
+          markerLine += " " + maybeHighlight(defs.message, opts.message);
+        }
+      }
 
-	if (haveStream && !streamIsTTY && forceColor$1 === undefined) {
-		return 0;
-	}
+      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    } else {
+      return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+    }
+  }).join("\n");
 
-	const min = forceColor$1 || 0;
+  if (opts.message && !hasColumns) {
+    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+  }
 
-	if (env$1.TERM === 'dumb') {
-		return min;
-	}
+  if (highlighted) {
+    return chalk.reset(frame);
+  } else {
+    return frame;
+  }
+}
 
-	if (process.platform === 'win32') {
-		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
-		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
-		const osRelease = os.release().split('.');
-		if (
-			Number(osRelease[0]) >= 10 &&
-			Number(osRelease[2]) >= 10586
-		) {
-			return Number(osRelease[2]) >= 14931 ? 3 : 2;
-		}
+function _default(rawLines, lineNumber, colNumber, opts = {}) {
+  if (!deprecationWarningShown) {
+    deprecationWarningShown = true;
+    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+
+    if (process.emitWarning) {
+      process.emitWarning(message, "DeprecationWarning");
+    } else {
+      const deprecationError = new Error(message);
+      deprecationError.name = "DeprecationWarning";
+      console.warn(new Error(message));
+    }
+  }
+
+  colNumber = Math.max(colNumber, 0);
+  const location = {
+    start: {
+      column: colNumber,
+      line: lineNumber
+    }
+  };
+  return codeFrameColumns$1(rawLines, location, opts);
+}
 
-		return 1;
-	}
+const errorEx = errorEx_1;
+const fallback = jsonParseEvenBetterErrors;
+const {default: LinesAndColumns} = require$$2;
+const {codeFrameColumns} = lib$4;
 
-	if ('CI' in env$1) {
-		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env$1) || env$1.CI_NAME === 'codeship') {
-			return 1;
-		}
+const JSONError = errorEx('JSONError', {
+	fileName: errorEx.append('in %s'),
+	codeFrame: errorEx.append('\n\n%s\n')
+});
 
-		return min;
+const parseJson = (string, reviver, filename) => {
+	if (typeof reviver === 'string') {
+		filename = reviver;
+		reviver = null;
 	}
 
-	if ('TEAMCITY_VERSION' in env$1) {
-		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0;
-	}
+	try {
+		try {
+			return JSON.parse(string, reviver);
+		} catch (error) {
+			fallback(string, reviver);
+			throw error;
+		}
+	} catch (error) {
+		error.message = error.message.replace(/\n/g, '');
+		const indexMatch = error.message.match(/in JSON at position (\d+) while parsing/);
 
-	if ('GITHUB_ACTIONS' in env$1) {
-		return 1;
-	}
+		const jsonError = new JSONError(error);
+		if (filename) {
+			jsonError.fileName = filename;
+		}
 
-	if (env$1.COLORTERM === 'truecolor') {
-		return 3;
-	}
+		if (indexMatch && indexMatch.length > 0) {
+			const lines = new LinesAndColumns(string);
+			const index = Number(indexMatch[1]);
+			const location = lines.locationForIndex(index);
 
-	if ('TERM_PROGRAM' in env$1) {
-		const version = parseInt((env$1.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+			const codeFrame = codeFrameColumns(
+				string,
+				{start: {line: location.line + 1, column: location.column + 1}},
+				{highlightCode: true}
+			);
 
-		switch (env$1.TERM_PROGRAM) {
-			case 'iTerm.app':
-				return version >= 3 ? 3 : 2;
-			case 'Apple_Terminal':
-				return 2;
-			// No default
+			jsonError.codeFrame = codeFrame;
 		}
-	}
-
-	if (/-256(color)?$/i.test(env$1.TERM)) {
-		return 2;
-	}
 
-	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$1.TERM)) {
-		return 1;
+		throw jsonError;
 	}
+};
 
-	if ('COLORTERM' in env$1) {
-		return 1;
-	}
+parseJson.JSONError = JSONError;
 
-	return min;
-}
+var parseJson_1 = parseJson;
 
-function getSupportLevel$1(stream) {
-	const level = supportsColor$1(stream, stream && stream.isTTY);
-	return translateLevel$1(level);
-}
+var src = {exports: {}};
 
-var supportsColor_1$1 = {
-	supportsColor: getSupportLevel$1,
-	stdout: translateLevel$1(supportsColor$1(true, tty.isatty(1))),
-	stderr: translateLevel$1(supportsColor$1(true, tty.isatty(2)))
-};
+var browser = {exports: {}};
 
-var node = createCommonjsModule(function (module, exports) {
 /**
- * Module dependencies.
+ * Helpers.
  */
 
-
-
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
 
 /**
- * This is the Node.js implementation of `debug()`.
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
  */
 
-exports.init = init;
-exports.log = log;
-exports.formatArgs = formatArgs;
-exports.save = save;
-exports.load = load;
-exports.useColors = useColors;
+var ms = function(val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse$a(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
 
 /**
- * Colors.
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
  */
 
-exports.colors = [6, 2, 3, 4, 5, 1];
-
-try {
-	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
-	// eslint-disable-next-line import/no-extraneous-dependencies
-	const supportsColor = supportsColor_1$1;
-
-	if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
-		exports.colors = [
-			20,
-			21,
-			26,
-			27,
-			32,
-			33,
-			38,
-			39,
-			40,
-			41,
-			42,
-			43,
-			44,
-			45,
-			56,
-			57,
-			62,
-			63,
-			68,
-			69,
-			74,
-			75,
-			76,
-			77,
-			78,
-			79,
-			80,
-			81,
-			92,
-			93,
-			98,
-			99,
-			112,
-			113,
-			128,
-			129,
-			134,
-			135,
-			148,
-			149,
-			160,
-			161,
-			162,
-			163,
-			164,
-			165,
-			166,
-			167,
-			168,
-			169,
-			170,
-			171,
-			172,
-			173,
-			178,
-			179,
-			184,
-			185,
-			196,
-			197,
-			198,
-			199,
-			200,
-			201,
-			202,
-			203,
-			204,
-			205,
-			206,
-			207,
-			208,
-			209,
-			214,
-			215,
-			220,
-			221
-		];
-	}
-} catch (error) {
-	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+function parse$a(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
 }
 
 /**
- * Build up the default `inspectOpts` object from the environment variables.
+ * Short format for `ms`.
  *
- *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ * @param {Number} ms
+ * @return {String}
+ * @api private
  */
 
-exports.inspectOpts = Object.keys(process.env).filter(key => {
-	return /^debug_/i.test(key);
-}).reduce((obj, key) => {
-	// Camel-case
-	const prop = key
-		.substring(6)
-		.toLowerCase()
-		.replace(/_([a-z])/g, (_, k) => {
-			return k.toUpperCase();
-		});
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
 
-	// Coerce string value into JS value
-	let val = process.env[key];
-	if (/^(yes|on|true|enabled)$/i.test(val)) {
-		val = true;
-	} else if (/^(no|off|false|disabled)$/i.test(val)) {
-		val = false;
-	} else if (val === 'null') {
-		val = null;
-	} else {
-		val = Number(val);
-	}
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
 
-	obj[prop] = val;
-	return obj;
-}, {});
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural$1(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural$1(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural$1(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural$1(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
 
 /**
- * Is stdout a TTY? Colored output is enabled when `true`.
+ * Pluralization helper.
  */
 
-function useColors() {
-	return 'colors' in exports.inspectOpts ?
-		Boolean(exports.inspectOpts.colors) :
-		tty.isatty(process.stderr.fd);
+function plural$1(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
 }
 
 /**
- * Adds ANSI color escape codes if enabled.
- *
- * @api public
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
  */
 
-function formatArgs(args) {
-	const {namespace: name, useColors} = this;
+function setup(env) {
+	createDebug.debug = createDebug;
+	createDebug.default = createDebug;
+	createDebug.coerce = coerce;
+	createDebug.disable = disable;
+	createDebug.enable = enable;
+	createDebug.enabled = enabled;
+	createDebug.humanize = ms;
+	createDebug.destroy = destroy;
 
-	if (useColors) {
-		const c = this.color;
-		const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
-		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+	Object.keys(env).forEach(key => {
+		createDebug[key] = env[key];
+	});
 
-		args[0] = prefix + args[0].split('\n').join('\n' + prefix);
-		args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
-	} else {
-		args[0] = getDate() + name + ' ' + args[0];
-	}
-}
+	/**
+	* The currently active debug mode names, and names to skip.
+	*/
 
-function getDate() {
-	if (exports.inspectOpts.hideDate) {
-		return '';
-	}
-	return new Date().toISOString() + ' ';
-}
+	createDebug.names = [];
+	createDebug.skips = [];
 
-/**
- * Invokes `util.format()` with the specified arguments and writes to stderr.
- */
+	/**
+	* Map of special "%n" handling functions, for the debug "format" argument.
+	*
+	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	*/
+	createDebug.formatters = {};
 
-function log(...args) {
-	return process.stderr.write(util$2.format(...args) + '\n');
-}
+	/**
+	* Selects a color for a debug namespace
+	* @param {String} namespace The namespace string for the for the debug instance to be colored
+	* @return {Number|String} An ANSI color code for the given namespace
+	* @api private
+	*/
+	function selectColor(namespace) {
+		let hash = 0;
 
-/**
- * Save `namespaces`.
- *
- * @param {String} namespaces
- * @api private
- */
-function save(namespaces) {
-	if (namespaces) {
-		process.env.DEBUG = namespaces;
-	} else {
-		// If you set a process.env field to null or undefined, it gets cast to the
-		// string 'null' or 'undefined'. Just delete instead.
-		delete process.env.DEBUG;
+		for (let i = 0; i < namespace.length; i++) {
+			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+			hash |= 0; // Convert to 32bit integer
+		}
+
+		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
 	}
-}
+	createDebug.selectColor = selectColor;
 
-/**
- * Load `namespaces`.
- *
- * @return {String} returns the previously persisted debug modes
- * @api private
- */
+	/**
+	* Create a debugger with the given `namespace`.
+	*
+	* @param {String} namespace
+	* @return {Function}
+	* @api public
+	*/
+	function createDebug(namespace) {
+		let prevTime;
+		let enableOverride = null;
+		let namespacesCache;
+		let enabledCache;
 
-function load() {
-	return process.env.DEBUG;
-}
+		function debug(...args) {
+			// Disabled?
+			if (!debug.enabled) {
+				return;
+			}
 
-/**
- * Init logic for `debug` instances.
- *
- * Create a new `inspectOpts` object in case `useColors` is set
- * differently for a particular `debug` instance.
- */
+			const self = debug;
 
-function init(debug) {
-	debug.inspectOpts = {};
+			// Set `diff` timestamp
+			const curr = Number(new Date());
+			const ms = curr - (prevTime || curr);
+			self.diff = ms;
+			self.prev = prevTime;
+			self.curr = curr;
+			prevTime = curr;
 
-	const keys = Object.keys(exports.inspectOpts);
-	for (let i = 0; i < keys.length; i++) {
-		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+			args[0] = createDebug.coerce(args[0]);
+
+			if (typeof args[0] !== 'string') {
+				// Anything else let's inspect with %O
+				args.unshift('%O');
+			}
+
+			// Apply any `formatters` transformations
+			let index = 0;
+			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+				// If we encounter an escaped % then don't increase the array index
+				if (match === '%%') {
+					return '%';
+				}
+				index++;
+				const formatter = createDebug.formatters[format];
+				if (typeof formatter === 'function') {
+					const val = args[index];
+					match = formatter.call(self, val);
+
+					// Now we need to remove `args[index]` since it's inlined in the `format`
+					args.splice(index, 1);
+					index--;
+				}
+				return match;
+			});
+
+			// Apply env-specific formatting (colors, etc.)
+			createDebug.formatArgs.call(self, args);
+
+			const logFn = self.log || createDebug.log;
+			logFn.apply(self, args);
+		}
+
+		debug.namespace = namespace;
+		debug.useColors = createDebug.useColors();
+		debug.color = createDebug.selectColor(namespace);
+		debug.extend = extend;
+		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+		Object.defineProperty(debug, 'enabled', {
+			enumerable: true,
+			configurable: false,
+			get: () => {
+				if (enableOverride !== null) {
+					return enableOverride;
+				}
+				if (namespacesCache !== createDebug.namespaces) {
+					namespacesCache = createDebug.namespaces;
+					enabledCache = createDebug.enabled(namespace);
+				}
+
+				return enabledCache;
+			},
+			set: v => {
+				enableOverride = v;
+			}
+		});
+
+		// Env-specific initialization logic for debug instances
+		if (typeof createDebug.init === 'function') {
+			createDebug.init(debug);
+		}
+
+		return debug;
+	}
+
+	function extend(namespace, delimiter) {
+		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+		newDebug.log = this.log;
+		return newDebug;
 	}
-}
 
-module.exports = common$1(exports);
+	/**
+	* Enables a debug mode by namespaces. This can include modes
+	* separated by a colon and wildcards.
+	*
+	* @param {String} namespaces
+	* @api public
+	*/
+	function enable(namespaces) {
+		createDebug.save(namespaces);
+		createDebug.namespaces = namespaces;
 
-const {formatters} = module.exports;
+		createDebug.names = [];
+		createDebug.skips = [];
 
-/**
- * Map %o to `util.inspect()`, all on a single line.
- */
+		let i;
+		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+		const len = split.length;
 
-formatters.o = function (v) {
-	this.inspectOpts.colors = this.useColors;
-	return util$2.inspect(v, this.inspectOpts)
-		.replace(/\s*\n\s*/g, ' ');
-};
+		for (i = 0; i < len; i++) {
+			if (!split[i]) {
+				// ignore empty strings
+				continue;
+			}
 
-/**
- * Map %O to `util.inspect()`, allowing multiple lines if needed.
- */
+			namespaces = split[i].replace(/\*/g, '.*?');
 
-formatters.O = function (v) {
-	this.inspectOpts.colors = this.useColors;
-	return util$2.inspect(v, this.inspectOpts);
-};
-});
-var node_1 = node.init;
-var node_2 = node.log;
-var node_3 = node.formatArgs;
-var node_4 = node.save;
-var node_5 = node.load;
-var node_6 = node.useColors;
-var node_7 = node.colors;
-var node_8 = node.inspectOpts;
+			if (namespaces[0] === '-') {
+				createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+			} else {
+				createDebug.names.push(new RegExp('^' + namespaces + '$'));
+			}
+		}
+	}
 
-var src = createCommonjsModule(function (module) {
-/**
- * Detect Electron renderer / nwjs process, which is node, but we should
- * treat as a browser.
- */
+	/**
+	* Disable debug output.
+	*
+	* @return {String} namespaces
+	* @api public
+	*/
+	function disable() {
+		const namespaces = [
+			...createDebug.names.map(toNamespace),
+			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+		].join(',');
+		createDebug.enable('');
+		return namespaces;
+	}
 
-if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
-	module.exports = browser;
-} else {
-	module.exports = node;
-}
-});
+	/**
+	* Returns true if the given mode name is enabled, false otherwise.
+	*
+	* @param {String} name
+	* @return {Boolean}
+	* @api public
+	*/
+	function enabled(name) {
+		if (name[name.length - 1] === '*') {
+			return true;
+		}
 
-const resolveFrom = (fromDirectory, moduleId, silent) => {
-	if (typeof fromDirectory !== 'string') {
-		throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDirectory}\``);
-	}
+		let i;
+		let len;
 
-	if (typeof moduleId !== 'string') {
-		throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
-	}
+		for (i = 0, len = createDebug.skips.length; i < len; i++) {
+			if (createDebug.skips[i].test(name)) {
+				return false;
+			}
+		}
 
-	try {
-		fromDirectory = fs$1.realpathSync(fromDirectory);
-	} catch (error) {
-		if (error.code === 'ENOENT') {
-			fromDirectory = path$1.resolve(fromDirectory);
-		} else if (silent) {
-			return;
-		} else {
-			throw error;
+		for (i = 0, len = createDebug.names.length; i < len; i++) {
+			if (createDebug.names[i].test(name)) {
+				return true;
+			}
 		}
-	}
 
-	const fromFile = path$1.join(fromDirectory, 'noop.js');
+		return false;
+	}
 
-	const resolveFileName = () => module$1._resolveFilename(moduleId, {
-		id: fromFile,
-		filename: fromFile,
-		paths: module$1._nodeModulePaths(fromDirectory)
-	});
+	/**
+	* Convert regexp to namespace
+	*
+	* @param {RegExp} regxep
+	* @return {String} namespace
+	* @api private
+	*/
+	function toNamespace(regexp) {
+		return regexp.toString()
+			.substring(2, regexp.toString().length - 2)
+			.replace(/\.\*\?$/, '*');
+	}
 
-	if (silent) {
-		try {
-			return resolveFileName();
-		} catch (error) {
-			return;
+	/**
+	* Coerce `val`.
+	*
+	* @param {Mixed} val
+	* @return {Mixed}
+	* @api private
+	*/
+	function coerce(val) {
+		if (val instanceof Error) {
+			return val.stack || val.message;
 		}
+		return val;
 	}
 
-	return resolveFileName();
-};
+	/**
+	* XXX DO NOT USE. This is a temporary stub function.
+	* XXX It WILL be removed in the next major release.
+	*/
+	function destroy() {
+		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+	}
 
-var resolveFrom_1 = (fromDirectory, moduleId) => resolveFrom(fromDirectory, moduleId);
-var silent = (fromDirectory, moduleId) => resolveFrom(fromDirectory, moduleId, true);
-resolveFrom_1.silent = silent;
+	createDebug.enable(createDebug.load());
 
-class FiggyPudding {
-  constructor (specs, opts, providers) {
-    this.__specs = specs || {};
-    Object.keys(this.__specs).forEach(alias => {
-      if (typeof this.__specs[alias] === 'string') {
-        const key = this.__specs[alias];
-        const realSpec = this.__specs[key];
-        if (realSpec) {
-          const aliasArr = realSpec.aliases || [];
-          aliasArr.push(alias, key);
-          realSpec.aliases = [...(new Set(aliasArr))];
-          this.__specs[alias] = realSpec;
-        } else {
-          throw new Error(`Alias refers to invalid key: ${key} -> ${alias}`)
-        }
-      }
-    });
-    this.__opts = opts || {};
-    this.__providers = reverse((providers).filter(
-      x => x != null && typeof x === 'object'
-    ));
-    this.__isFiggyPudding = true;
-  }
-  get (key) {
-    return pudGet(this, key, true)
-  }
-  get [Symbol.toStringTag] () { return 'FiggyPudding' }
-  forEach (fn, thisArg = this) {
-    for (let [key, value] of this.entries()) {
-      fn.call(thisArg, value, key, this);
-    }
-  }
-  toJSON () {
-    const obj = {};
-    this.forEach((val, key) => {
-      obj[key] = val;
-    });
-    return obj
-  }
-  * entries (_matcher) {
-    for (let key of Object.keys(this.__specs)) {
-      yield [key, this.get(key)];
-    }
-    const matcher = _matcher || this.__opts.other;
-    if (matcher) {
-      const seen = new Set();
-      for (let p of this.__providers) {
-        const iter = p.entries ? p.entries(matcher) : entries(p);
-        for (let [key, val] of iter) {
-          if (matcher(key) && !seen.has(key)) {
-            seen.add(key);
-            yield [key, val];
-          }
-        }
-      }
-    }
-  }
-  * [Symbol.iterator] () {
-    for (let [key, value] of this.entries()) {
-      yield [key, value];
-    }
-  }
-  * keys () {
-    for (let [key] of this.entries()) {
-      yield key;
-    }
-  }
-  * values () {
-    for (let [, value] of this.entries()) {
-      yield value;
-    }
-  }
-  concat (...moreConfig) {
-    return new Proxy(new FiggyPudding(
-      this.__specs,
-      this.__opts,
-      reverse(this.__providers).concat(moreConfig)
-    ), proxyHandler)
-  }
+	return createDebug;
 }
-try {
-  const util = util$2;
-  FiggyPudding.prototype[util.inspect.custom] = function (depth, opts) {
-    return (
-      this[Symbol.toStringTag] + ' '
-    ) + util.inspect(this.toJSON(), opts)
-  };
-} catch (e) {}
 
-function BadKeyError (key) {
-  throw Object.assign(new Error(
-    `invalid config key requested: ${key}`
-  ), {code: 'EBADKEY'})
-}
+var common$3 = setup;
 
-function pudGet (pud, key, validate) {
-  let spec = pud.__specs[key];
-  if (validate && !spec && (!pud.__opts.other || !pud.__opts.other(key))) {
-    BadKeyError(key);
-  } else {
-    if (!spec) { spec = {}; }
-    let ret;
-    for (let p of pud.__providers) {
-      ret = tryGet(key, p);
-      if (ret === undefined && spec.aliases && spec.aliases.length) {
-        for (let alias of spec.aliases) {
-          if (alias === key) { continue }
-          ret = tryGet(alias, p);
-          if (ret !== undefined) {
-            break
-          }
-        }
-      }
-      if (ret !== undefined) {
-        break
-      }
-    }
-    if (ret === undefined && spec.default !== undefined) {
-      if (typeof spec.default === 'function') {
-        return spec.default(pud)
-      } else {
-        return spec.default
-      }
-    } else {
-      return ret
-    }
-  }
-}
+/* eslint-env browser */
 
-function tryGet (key, p) {
-  let ret;
-  if (p.__isFiggyPudding) {
-    ret = pudGet(p, key, false);
-  } else if (typeof p.get === 'function') {
-    ret = p.get(key);
-  } else {
-    ret = p[key];
-  }
-  return ret
-}
+(function (module, exports) {
+/**
+ * This is the web browser implementation of `debug()`.
+ */
 
-const proxyHandler = {
-  has (obj, prop) {
-    return prop in obj.__specs && pudGet(obj, prop, false) !== undefined
-  },
-  ownKeys (obj) {
-    return Object.keys(obj.__specs)
-  },
-  get (obj, prop) {
-    if (
-      typeof prop === 'symbol' ||
-      prop.slice(0, 2) === '__' ||
-      prop in FiggyPudding.prototype
-    ) {
-      return obj[prop]
-    }
-    return obj.get(prop)
-  },
-  set (obj, prop, value) {
-    if (
-      typeof prop === 'symbol' ||
-      prop.slice(0, 2) === '__'
-    ) {
-      obj[prop] = value;
-      return true
-    } else {
-      throw new Error('figgyPudding options cannot be modified. Use .concat() instead.')
-    }
-  },
-  deleteProperty () {
-    throw new Error('figgyPudding options cannot be deleted. Use .concat() and shadow them instead.')
-  }
-};
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = localstorage();
+exports.destroy = (() => {
+	let warned = false;
 
-var figgyPudding_1 = figgyPudding;
-function figgyPudding (specs, opts) {
-  function factory (...providers) {
-    return new Proxy(new FiggyPudding(
-      specs,
-      opts,
-      providers
-    ), proxyHandler)
-  }
-  return factory
-}
+	return () => {
+		if (!warned) {
+			warned = true;
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+	};
+})();
 
-function reverse (arr) {
-  const ret = [];
-  arr.forEach(x => ret.unshift(x));
-  return ret
-}
+/**
+ * Colors.
+ */
 
-function entries (obj) {
-  return Object.keys(obj).map(k => [k, obj[k]])
-}
+exports.colors = [
+	'#0000CC',
+	'#0000FF',
+	'#0033CC',
+	'#0033FF',
+	'#0066CC',
+	'#0066FF',
+	'#0099CC',
+	'#0099FF',
+	'#00CC00',
+	'#00CC33',
+	'#00CC66',
+	'#00CC99',
+	'#00CCCC',
+	'#00CCFF',
+	'#3300CC',
+	'#3300FF',
+	'#3333CC',
+	'#3333FF',
+	'#3366CC',
+	'#3366FF',
+	'#3399CC',
+	'#3399FF',
+	'#33CC00',
+	'#33CC33',
+	'#33CC66',
+	'#33CC99',
+	'#33CCCC',
+	'#33CCFF',
+	'#6600CC',
+	'#6600FF',
+	'#6633CC',
+	'#6633FF',
+	'#66CC00',
+	'#66CC33',
+	'#9900CC',
+	'#9900FF',
+	'#9933CC',
+	'#9933FF',
+	'#99CC00',
+	'#99CC33',
+	'#CC0000',
+	'#CC0033',
+	'#CC0066',
+	'#CC0099',
+	'#CC00CC',
+	'#CC00FF',
+	'#CC3300',
+	'#CC3333',
+	'#CC3366',
+	'#CC3399',
+	'#CC33CC',
+	'#CC33FF',
+	'#CC6600',
+	'#CC6633',
+	'#CC9900',
+	'#CC9933',
+	'#CCCC00',
+	'#CCCC33',
+	'#FF0000',
+	'#FF0033',
+	'#FF0066',
+	'#FF0099',
+	'#FF00CC',
+	'#FF00FF',
+	'#FF3300',
+	'#FF3333',
+	'#FF3366',
+	'#FF3399',
+	'#FF33CC',
+	'#FF33FF',
+	'#FF6600',
+	'#FF6633',
+	'#FF9900',
+	'#FF9933',
+	'#FFCC00',
+	'#FFCC33'
+];
 
-var pathExists = fp => new Promise(resolve => {
-	fs$1.access(fp, err => {
-		resolve(!err);
-	});
-});
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
 
-var sync = fp => {
-	try {
-		fs$1.accessSync(fp);
+// eslint-disable-next-line complexity
+function useColors() {
+	// NB: In an Electron preload script, document will be defined but not fully
+	// initialized. Since we know we're in Chrome, we'll just detect this case
+	// explicitly
+	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
 		return true;
-	} catch (err) {
-		return false;
 	}
-};
-pathExists.sync = sync;
-
-const pTry = (fn, ...arguments_) => new Promise(resolve => {
-	resolve(fn(...arguments_));
-});
 
-var pTry_1 = pTry;
-// TODO: remove this in the next major version
-var default_1 = pTry;
-pTry_1.default = default_1;
-
-const pLimit = concurrency => {
-	if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
-		return Promise.reject(new TypeError('Expected `concurrency` to be a number from 1 and up'));
+	// Internet Explorer and Edge do not support colors.
+	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+		return false;
 	}
 
-	const queue = [];
-	let activeCount = 0;
-
-	const next = () => {
-		activeCount--;
-
-		if (queue.length > 0) {
-			queue.shift()();
-		}
-	};
+	// Is webkit? http://stackoverflow.com/a/16459606/376773
+	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+		// Is firebug? http://stackoverflow.com/a/398120/376773
+		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+		// Is firefox >= v31?
+		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+		// Double check webkit in userAgent just in case we are in a worker
+		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+}
 
-	const run = (fn, resolve, ...args) => {
-		activeCount++;
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
 
-		const result = pTry_1(fn, ...args);
+function formatArgs(args) {
+	args[0] = (this.useColors ? '%c' : '') +
+		this.namespace +
+		(this.useColors ? ' %c' : ' ') +
+		args[0] +
+		(this.useColors ? '%c ' : ' ') +
+		'+' + module.exports.humanize(this.diff);
 
-		resolve(result);
+	if (!this.useColors) {
+		return;
+	}
 
-		result.then(next, next);
-	};
+	const c = 'color: ' + this.color;
+	args.splice(1, 0, c, 'color: inherit');
 
-	const enqueue = (fn, resolve, ...args) => {
-		if (activeCount < concurrency) {
-			run(fn, resolve, ...args);
-		} else {
-			queue.push(run.bind(null, fn, resolve, ...args));
+	// The final "%c" is somewhat tricky, because there could be other
+	// arguments passed either before or after the %c, so we need to
+	// figure out the correct index to insert the CSS into
+	let index = 0;
+	let lastC = 0;
+	args[0].replace(/%[a-zA-Z%]/g, match => {
+		if (match === '%%') {
+			return;
 		}
-	};
-
-	const generator = (fn, ...args) => new Promise(resolve => enqueue(fn, resolve, ...args));
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount
-		},
-		pendingCount: {
-			get: () => queue.length
-		},
-		clearQueue: {
-			value: () => {
-				queue.length = 0;
-			}
+		index++;
+		if (match === '%c') {
+			// We only are interested in the *last* %c
+			// (the user may have provided their own)
+			lastC = index;
 		}
 	});
 
-	return generator;
-};
+	args.splice(lastC, 0, c);
+}
 
-var pLimit_1 = pLimit;
-var default_1$1 = pLimit;
-pLimit_1.default = default_1$1;
+/**
+ * Invokes `console.debug()` when available.
+ * No-op when `console.debug` is not a "function".
+ * If `console.debug` is not available, falls back
+ * to `console.log`.
+ *
+ * @api public
+ */
+exports.log = console.debug || console.log || (() => {});
 
-class EndError extends Error {
-	constructor(value) {
-		super();
-		this.value = value;
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+	try {
+		if (namespaces) {
+			exports.storage.setItem('debug', namespaces);
+		} else {
+			exports.storage.removeItem('debug');
+		}
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
 	}
 }
 
-// The input can also be a promise, so we `Promise.resolve()` it
-const testElement = (el, tester) => Promise.resolve(el).then(tester);
-
-// The input can also be a promise, so we `Promise.all()` them both
-const finder = el => Promise.all(el).then(val => val[1] === true && Promise.reject(new EndError(val[0])));
-
-var pLocate = (iterable, tester, opts) => {
-	opts = Object.assign({
-		concurrency: Infinity,
-		preserveOrder: true
-	}, opts);
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+function load() {
+	let r;
+	try {
+		r = exports.storage.getItem('debug');
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
 
-	const limit = pLimit_1(opts.concurrency);
+	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+	if (!r && typeof process !== 'undefined' && 'env' in process) {
+		r = process.env.DEBUG;
+	}
 
-	// Start all the promises concurrently with optional limit
-	const items = [...iterable].map(el => [el, limit(testElement, el, tester)]);
+	return r;
+}
 
-	// Check the promises either serially or concurrently
-	const checkLimit = pLimit_1(opts.preserveOrder ? 1 : Infinity);
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
 
-	return Promise.all(items.map(el => checkLimit(finder, el)))
-		.then(() => {})
-		.catch(err => err instanceof EndError ? err.value : Promise.reject(err));
-};
+function localstorage() {
+	try {
+		// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+		// The Browser also has localStorage in the global context.
+		return localStorage;
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+}
 
-var locatePath = (iterable, options) => {
-	options = Object.assign({
-		cwd: process.cwd()
-	}, options);
+module.exports = common$3(exports);
 
-	return pLocate(iterable, el => pathExists(path$1.resolve(options.cwd, el)), options);
-};
+const {formatters} = module.exports;
 
-var sync$1 = (iterable, options) => {
-	options = Object.assign({
-		cwd: process.cwd()
-	}, options);
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
 
-	for (const el of iterable) {
-		if (pathExists.sync(path$1.resolve(options.cwd, el))) {
-			return el;
-		}
+formatters.j = function (v) {
+	try {
+		return JSON.stringify(v);
+	} catch (error) {
+		return '[UnexpectedJSONParseError]: ' + error.message;
 	}
 };
-locatePath.sync = sync$1;
+}(browser, browser.exports));
 
-var findUp = (filename, opts = {}) => {
-	const startDir = path$1.resolve(opts.cwd || '');
-	const {root} = path$1.parse(startDir);
+var node = {exports: {}};
 
-	const filenames = [].concat(filename);
+/**
+ * Module dependencies.
+ */
 
-	return new Promise(resolve => {
-		(function find(dir) {
-			locatePath(filenames, {cwd: dir}).then(file => {
-				if (file) {
-					resolve(path$1.join(dir, file));
-				} else if (dir === root) {
-					resolve(null);
-				} else {
-					find(path$1.dirname(dir));
-				}
-			});
-		})(startDir);
-	});
-};
+(function (module, exports) {
+const tty = tty$1;
+const util = require$$0$4;
 
-var sync$2 = (filename, opts = {}) => {
-	let dir = path$1.resolve(opts.cwd || '');
-	const {root} = path$1.parse(dir);
+/**
+ * This is the Node.js implementation of `debug()`.
+ */
 
-	const filenames = [].concat(filename);
+exports.init = init;
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.destroy = util.deprecate(
+	() => {},
+	'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+);
 
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		const file = locatePath.sync(filenames, {cwd: dir});
+/**
+ * Colors.
+ */
 
-		if (file) {
-			return path$1.join(dir, file);
-		}
+exports.colors = [6, 2, 3, 4, 5, 1];
 
-		if (dir === root) {
-			return null;
-		}
+try {
+	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+	// eslint-disable-next-line import/no-extraneous-dependencies
+	const supportsColor = supportsColor_1$1;
 
-		dir = path$1.dirname(dir);
+	if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+		exports.colors = [
+			20,
+			21,
+			26,
+			27,
+			32,
+			33,
+			38,
+			39,
+			40,
+			41,
+			42,
+			43,
+			44,
+			45,
+			56,
+			57,
+			62,
+			63,
+			68,
+			69,
+			74,
+			75,
+			76,
+			77,
+			78,
+			79,
+			80,
+			81,
+			92,
+			93,
+			98,
+			99,
+			112,
+			113,
+			128,
+			129,
+			134,
+			135,
+			148,
+			149,
+			160,
+			161,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			171,
+			172,
+			173,
+			178,
+			179,
+			184,
+			185,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			203,
+			204,
+			205,
+			206,
+			207,
+			208,
+			209,
+			214,
+			215,
+			220,
+			221
+		];
 	}
-};
-findUp.sync = sync$2;
-
-var ini = createCommonjsModule(function (module, exports) {
-exports.parse = exports.decode = decode;
+} catch (error) {
+	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+}
 
-exports.stringify = exports.encode = encode;
+/**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */
 
-exports.safe = safe;
-exports.unsafe = unsafe;
+exports.inspectOpts = Object.keys(process.env).filter(key => {
+	return /^debug_/i.test(key);
+}).reduce((obj, key) => {
+	// Camel-case
+	const prop = key
+		.substring(6)
+		.toLowerCase()
+		.replace(/_([a-z])/g, (_, k) => {
+			return k.toUpperCase();
+		});
 
-var eol = typeof process !== 'undefined' &&
-  process.platform === 'win32' ? '\r\n' : '\n';
+	// Coerce string value into JS value
+	let val = process.env[key];
+	if (/^(yes|on|true|enabled)$/i.test(val)) {
+		val = true;
+	} else if (/^(no|off|false|disabled)$/i.test(val)) {
+		val = false;
+	} else if (val === 'null') {
+		val = null;
+	} else {
+		val = Number(val);
+	}
 
-function encode (obj, opt) {
-  var children = [];
-  var out = '';
+	obj[prop] = val;
+	return obj;
+}, {});
 
-  if (typeof opt === 'string') {
-    opt = {
-      section: opt,
-      whitespace: false
-    };
-  } else {
-    opt = opt || {};
-    opt.whitespace = opt.whitespace === true;
-  }
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
 
-  var separator = opt.whitespace ? ' = ' : '=';
+function useColors() {
+	return 'colors' in exports.inspectOpts ?
+		Boolean(exports.inspectOpts.colors) :
+		tty.isatty(process.stderr.fd);
+}
 
-  Object.keys(obj).forEach(function (k, _, __) {
-    var val = obj[k];
-    if (val && Array.isArray(val)) {
-      val.forEach(function (item) {
-        out += safe(k + '[]') + separator + safe(item) + '\n';
-      });
-    } else if (val && typeof val === 'object') {
-      children.push(k);
-    } else {
-      out += safe(k) + separator + safe(val) + eol;
-    }
-  });
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
 
-  if (opt.section && out.length) {
-    out = '[' + safe(opt.section) + ']' + eol + out;
-  }
+function formatArgs(args) {
+	const {namespace: name, useColors} = this;
 
-  children.forEach(function (k, _, __) {
-    var nk = dotSplit(k).join('\\.');
-    var section = (opt.section ? opt.section + '.' : '') + nk;
-    var child = encode(obj[k], {
-      section: section,
-      whitespace: opt.whitespace
-    });
-    if (out.length && child.length) {
-      out += eol;
-    }
-    out += child;
-  });
+	if (useColors) {
+		const c = this.color;
+		const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
 
-  return out
+		args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+		args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+	} else {
+		args[0] = getDate() + name + ' ' + args[0];
+	}
 }
 
-function dotSplit (str) {
-  return str.replace(/\1/g, '\u0002LITERAL\\1LITERAL\u0002')
-    .replace(/\\\./g, '\u0001')
-    .split(/\./).map(function (part) {
-      return part.replace(/\1/g, '\\.')
-      .replace(/\2LITERAL\\1LITERAL\2/g, '\u0001')
-    })
+function getDate() {
+	if (exports.inspectOpts.hideDate) {
+		return '';
+	}
+	return new Date().toISOString() + ' ';
 }
 
-function decode (str) {
-  var out = {};
-  var p = out;
-  var section = null;
-  //          section     |key      = value
-  var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
-  var lines = str.split(/[\r\n]+/g);
-
-  lines.forEach(function (line, _, __) {
-    if (!line || line.match(/^\s*[;#]/)) return
-    var match = line.match(re);
-    if (!match) return
-    if (match[1] !== undefined) {
-      section = unsafe(match[1]);
-      p = out[section] = out[section] || {};
-      return
-    }
-    var key = unsafe(match[2]);
-    var value = match[3] ? unsafe(match[4]) : true;
-    switch (value) {
-      case 'true':
-      case 'false':
-      case 'null': value = JSON.parse(value);
-    }
-
-    // Convert keys with '[]' suffix to an array
-    if (key.length > 2 && key.slice(-2) === '[]') {
-      key = key.substring(0, key.length - 2);
-      if (!p[key]) {
-        p[key] = [];
-      } else if (!Array.isArray(p[key])) {
-        p[key] = [p[key]];
-      }
-    }
-
-    // safeguard against resetting a previously defined
-    // array by accidentally forgetting the brackets
-    if (Array.isArray(p[key])) {
-      p[key].push(value);
-    } else {
-      p[key] = value;
-    }
-  });
-
-  // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
-  // use a filter to return the keys that have to be deleted.
-  Object.keys(out).filter(function (k, _, __) {
-    if (!out[k] ||
-      typeof out[k] !== 'object' ||
-      Array.isArray(out[k])) {
-      return false
-    }
-    // see if the parent section is also an object.
-    // if so, add it to that, and mark this one for deletion
-    var parts = dotSplit(k);
-    var p = out;
-    var l = parts.pop();
-    var nl = l.replace(/\\\./g, '.');
-    parts.forEach(function (part, _, __) {
-      if (!p[part] || typeof p[part] !== 'object') p[part] = {};
-      p = p[part];
-    });
-    if (p === out && nl === l) {
-      return false
-    }
-    p[nl] = out[k];
-    return true
-  }).forEach(function (del, _, __) {
-    delete out[del];
-  });
+/**
+ * Invokes `util.format()` with the specified arguments and writes to stderr.
+ */
 
-  return out
+function log(...args) {
+	return process.stderr.write(util.format(...args) + '\n');
 }
 
-function isQuoted (val) {
-  return (val.charAt(0) === '"' && val.slice(-1) === '"') ||
-    (val.charAt(0) === "'" && val.slice(-1) === "'")
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+	if (namespaces) {
+		process.env.DEBUG = namespaces;
+	} else {
+		// If you set a process.env field to null or undefined, it gets cast to the
+		// string 'null' or 'undefined'. Just delete instead.
+		delete process.env.DEBUG;
+	}
 }
 
-function safe (val) {
-  return (typeof val !== 'string' ||
-    val.match(/[=\r\n]/) ||
-    val.match(/^\[/) ||
-    (val.length > 1 &&
-     isQuoted(val)) ||
-    val !== val.trim())
-      ? JSON.stringify(val)
-      : val.replace(/;/g, '\\;').replace(/#/g, '\\#')
-}
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
 
-function unsafe (val, doUnesc) {
-  val = (val || '').trim();
-  if (isQuoted(val)) {
-    // remove the single quotes before calling JSON.parse
-    if (val.charAt(0) === "'") {
-      val = val.substr(1, val.length - 2);
-    }
-    try { val = JSON.parse(val); } catch (_) {}
-  } else {
-    // walk the val to find the first not-escaped ; character
-    var esc = false;
-    var unesc = '';
-    for (var i = 0, l = val.length; i < l; i++) {
-      var c = val.charAt(i);
-      if (esc) {
-        if ('\\;#'.indexOf(c) !== -1) {
-          unesc += c;
-        } else {
-          unesc += '\\' + c;
-        }
-        esc = false;
-      } else if (';#'.indexOf(c) !== -1) {
-        break
-      } else if (c === '\\') {
-        esc = true;
-      } else {
-        unesc += c;
-      }
-    }
-    if (esc) {
-      unesc += '\\';
-    }
-    return unesc.trim()
-  }
-  return val
+function load() {
+	return process.env.DEBUG;
 }
-});
-var ini_1 = ini.parse;
-var ini_2 = ini.decode;
-var ini_3 = ini.stringify;
-var ini_4 = ini.encode;
-var ini_5 = ini.safe;
-var ini_6 = ini.unsafe;
-
-const NpmConfig = figgyPudding_1({}, {
-  // Open up the pudding object.
-  other () { return true }
-});
-
-const ConfigOpts = figgyPudding_1({
-  cache: { default: path$1.join(os.homedir(), '.npm') },
-  configNames: { default: ['npmrc', '.npmrc'] },
-  envPrefix: { default: /^npm_config_/i },
-  cwd: { default: () => process.cwd() },
-  globalconfig: {
-    default: () => path$1.join(getGlobalPrefix(), 'etc', 'npmrc')
-  },
-  userconfig: { default: path$1.join(os.homedir(), '.npmrc') }
-});
 
-var read = getNpmConfig;
-function getNpmConfig (_opts, _builtin) {
-  const builtin = ConfigOpts(_builtin);
-  const env = {};
-  for (let key of Object.keys(process.env)) {
-    if (!key.match(builtin.envPrefix)) continue
-    const newKey = key.toLowerCase()
-      .replace(builtin.envPrefix, '')
-      .replace(/(?!^)_/g, '-');
-    env[newKey] = process.env[key];
-  }
-  const cli = NpmConfig(_opts);
-  const userConfPath = (
-    builtin.userconfig ||
-    cli.userconfig ||
-    env.userconfig
-  );
-  const user = userConfPath && maybeReadIni(userConfPath);
-  const globalConfPath = (
-    builtin.globalconfig ||
-    cli.globalconfig ||
-    env.globalconfig
-  );
-  const global = globalConfPath && maybeReadIni(globalConfPath);
-  const projConfPath = findUp.sync(builtin.configNames, { cwd: builtin.cwd });
-  let proj = {};
-  if (projConfPath && projConfPath !== userConfPath) {
-    proj = maybeReadIni(projConfPath);
-  }
-  const newOpts = NpmConfig(builtin, global, user, proj, env, cli);
-  if (newOpts.cache) {
-    return newOpts.concat({
-      cache: path$1.resolve(
-        (
-          (cli.cache || env.cache)
-            ? builtin.cwd
-            : proj.cache
-              ? path$1.dirname(projConfPath)
-              : user.cache
-                ? path$1.dirname(userConfPath)
-                : global.cache
-                  ? path$1.dirname(globalConfPath)
-                  : path$1.dirname(userConfPath)
-        ),
-        newOpts.cache
-      )
-    })
-  } else {
-    return newOpts
-  }
-}
+/**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */
 
-function maybeReadIni (f) {
-  let txt;
-  try {
-    txt = fs$1.readFileSync(f, 'utf8');
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      return ''
-    } else {
-      throw err
-    }
-  }
-  return ini.parse(txt)
+function init(debug) {
+	debug.inspectOpts = {};
+
+	const keys = Object.keys(exports.inspectOpts);
+	for (let i = 0; i < keys.length; i++) {
+		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+	}
 }
 
-function getGlobalPrefix () {
-  if (process.env.PREFIX) {
-    return process.env.PREFIX
-  } else if (process.platform === 'win32') {
-    // c:\node\node.exe --> prefix=c:\node\
-    return path$1.dirname(process.execPath)
-  } else {
-    // /usr/local/bin/node --> prefix=/usr/local
-    let pref = path$1.dirname(path$1.dirname(process.execPath));
-    // destdir only is respected on Unix
-    if (process.env.DESTDIR) {
-      pref = path$1.join(process.env.DESTDIR, pref);
-    }
-    return pref
-  }
+module.exports = common$3(exports);
+
+const {formatters} = module.exports;
+
+/**
+ * Map %o to `util.inspect()`, all on a single line.
+ */
+
+formatters.o = function (v) {
+	this.inspectOpts.colors = this.useColors;
+	return util.inspect(v, this.inspectOpts)
+		.split('\n')
+		.map(str => str.trim())
+		.join(' ');
+};
+
+/**
+ * Map %O to `util.inspect()`, allowing multiple lines if needed.
+ */
+
+formatters.O = function (v) {
+	this.inspectOpts.colors = this.useColors;
+	return util.inspect(v, this.inspectOpts);
+};
+}(node, node.exports));
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+	src.exports = browser.exports;
+} else {
+	src.exports = node.exports;
 }
 
-var libnpmconfig = {
-	read: read
+var createDebug = src.exports;
+
+var re$6 = {exports: {}};
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+const SEMVER_SPEC_VERSION = '2.0.0';
+
+const MAX_LENGTH$2 = 256;
+const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
+  /* istanbul ignore next */ 9007199254740991;
+
+// Max safe segment length for coercion.
+const MAX_SAFE_COMPONENT_LENGTH = 16;
+
+var constants = {
+  SEMVER_SPEC_VERSION,
+  MAX_LENGTH: MAX_LENGTH$2,
+  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+  MAX_SAFE_COMPONENT_LENGTH
 };
 
-var resolve = resolveFrom_1.silent;
-var readNpmConfig = libnpmconfig.read;
+const debug$f = (
+  typeof process === 'object' &&
+  process.env &&
+  process.env.NODE_DEBUG &&
+  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+) ? (...args) => console.error('SEMVER', ...args)
+  : () => {};
 
-var loadPlugin_1 = loadPlugin;
-loadPlugin.resolve = resolvePlugin;
+var debug_1 = debug$f;
 
-var electron = process.versions.electron !== undefined;
-var windows = process.platform === 'win32';
+(function (module, exports) {
+const { MAX_SAFE_COMPONENT_LENGTH } = constants;
+const debug = debug_1;
+exports = module.exports = {};
 
-var argv = process.argv[1] || /* istanbul ignore next */ '';
-var nvm = process.env.NVM_BIN;
-var appData = process.env.APPDATA;
+// The actual regexps go on exports.re
+const re = exports.re = [];
+const src = exports.src = [];
+const t = exports.t = {};
+let R = 0;
 
-/* istanbul ignore next */
-var globalsLibrary = windows ? '' : 'lib';
+const createToken = (name, value, isGlobal) => {
+  const index = R++;
+  debug(index, value);
+  t[name] = index;
+  src[index] = value;
+  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+};
 
-var builtinNpmConfig;
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
 
-// The prefix config defaults to the location where node is installed.
-// On Windows, this is in a place called `%AppData%`, which we have to
-// pass to `libnpmconfig` explicitly:
-/* istanbul ignore next */
-if (windows && appData) {
-  builtinNpmConfig = {prefix: path$1.join(appData, 'npm')};
-}
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
 
-var npmPrefix = readNpmConfig(null, builtinNpmConfig).prefix;
+createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
+createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+');
 
-// If there is no prefix defined, use the defaults
-// See: <https://github.com/eush77/npm-prefix/blob/master/index.js>
-/* istanbul ignore next */
-if (!npmPrefix) {
-  npmPrefix = windows
-    ? path$1.dirname(process.execPath)
-    : path$1.resolve(process.execPath, '../..');
-}
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
 
-var globally = electron || argv.indexOf(npmPrefix) === 0;
-var globals = path$1.resolve(npmPrefix, globalsLibrary, 'node_modules');
+createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');
 
-// If we’re in Electron, we’re running in a modified Node that cannot really
-// install global node modules.
-// To find the actual modules, the user has to set `prefix` somewhere in an
-// `.npmrc` (which is picked up by `libnpmconfig`).
-// Most people don’t do that, and some use NVM instead to manage different
-// versions of Node.
-// Luckily NVM leaks some environment variables that we can pick up on to try
-// and detect the actual modules.
-/* istanbul ignore next */
-if (electron && nvm && !fs$1.existsSync(globals)) {
-  globals = path$1.resolve(nvm, '..', globalsLibrary, 'node_modules');
-}
+// ## Main Version
+// Three dot-separated numeric identifiers.
 
-// Load the plugin found using `resolvePlugin`.
-function loadPlugin(name, options) {
-  return commonjsRequire(resolvePlugin(name, options) || name)
-}
+createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})`);
 
-// Find a plugin.
-//
-// See also:
-// <https://docs.npmjs.com/files/folders#node-modules>
-// <https://github.com/sindresorhus/resolve-from>
-//
-// Uses the standard node module loading strategy to find $name in each given
-// `cwd` (and optionally the global `node_modules` directory).
-//
-// If a prefix is given and $name is not a path, `$prefix-$name` is also
-// searched (preferring these over non-prefixed modules).
-function resolvePlugin(name, options) {
-  var settings = options || {};
-  var prefix = settings.prefix;
-  var cwd = settings.cwd;
-  var global = settings.global;
-  var filePath;
-  var sources;
-  var length;
-  var index;
-  var plugin;
-  var slash;
-  var scope = '';
+createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
 
-  if (global === null || global === undefined) {
-    global = globally;
-  }
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
 
-  if (cwd && typeof cwd === 'object') {
-    sources = cwd.concat();
-  } else {
-    sources = [cwd || process.cwd()];
+createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
+}|${src[t.NONNUMERICIDENTIFIER]})`);
+
+createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
+}|${src[t.NONNUMERICIDENTIFIER]})`);
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
+}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+
+createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
+}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
+}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
+}${src[t.PRERELEASE]}?${
+  src[t.BUILD]}?`);
+
+createToken('FULL', `^${src[t.FULLPLAIN]}$`);
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
+}${src[t.PRERELEASELOOSE]}?${
+  src[t.BUILD]}?`);
+
+createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
+
+createToken('GTLT', '((?:<|>)?=?)');
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+
+createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:${src[t.PRERELEASE]})?${
+                     src[t.BUILD]}?` +
+                   `)?)?`);
+
+createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:${src[t.PRERELEASELOOSE]})?${
+                          src[t.BUILD]}?` +
+                        `)?)?`);
+
+createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+createToken('COERCE', `${'(^|[^\\d])' +
+              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+              `(?:$|[^\\d])`);
+createToken('COERCERTL', src[t.COERCE], true);
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+createToken('LONETILDE', '(?:~>?)');
+
+createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+exports.tildeTrimReplace = '$1~';
+
+createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+createToken('LONECARET', '(?:\\^)');
+
+createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
+exports.caretTrimReplace = '$1^';
+
+createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
+}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+exports.comparatorTrimReplace = '$1$2$3';
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
+                   `\\s+-\\s+` +
+                   `(${src[t.XRANGEPLAIN]})` +
+                   `\\s*$`);
+
+createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s+-\\s+` +
+                        `(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s*$`);
+
+// Star ranges basically just allow anything at all.
+createToken('STAR', '(<|>)?=?\\s*\\*');
+// >=0.0.0 is like a star
+createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$');
+createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$');
+}(re$6, re$6.exports));
+
+// parse out just the options we care about so we always get a consistent
+// obj with keys in a consistent order.
+const opts = ['includePrerelease', 'loose', 'rtl'];
+const parseOptions$4 = options =>
+  !options ? {}
+  : typeof options !== 'object' ? { loose: true }
+  : opts.filter(k => options[k]).reduce((options, k) => {
+    options[k] = true;
+    return options
+  }, {});
+var parseOptions_1 = parseOptions$4;
+
+const numeric$1 = /^[0-9]+$/;
+const compareIdentifiers$1 = (a, b) => {
+  const anum = numeric$1.test(a);
+  const bnum = numeric$1.test(b);
+
+  if (anum && bnum) {
+    a = +a;
+    b = +b;
   }
 
-  // Non-path.
-  if (name.charAt(0) !== '.') {
-    if (global) {
-      sources.push(globals);
-    }
+  return a === b ? 0
+    : (anum && !bnum) ? -1
+    : (bnum && !anum) ? 1
+    : a < b ? -1
+    : 1
+};
 
-    // Unprefix module.
-    if (prefix) {
-      prefix = prefix.charAt(prefix.length - 1) === '-' ? prefix : prefix + '-';
+const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
 
-      // Scope?
-      if (name.charAt(0) === '@') {
-        slash = name.indexOf('/');
+var identifiers = {
+  compareIdentifiers: compareIdentifiers$1,
+  rcompareIdentifiers
+};
 
-        // Let’s keep the algorithm simple.
-        // No need to care if this is a “valid” scope (I think?).
-        // But we do check for the slash.
-        if (slash !== -1) {
-          scope = name.slice(0, slash + 1);
-          name = name.slice(slash + 1);
-        }
-      }
+const debug$e = debug_1;
+const { MAX_LENGTH: MAX_LENGTH$1, MAX_SAFE_INTEGER } = constants;
+const { re: re$5, t: t$4 } = re$6.exports;
 
-      if (name.slice(0, prefix.length) !== prefix) {
-        plugin = scope + prefix + name;
+const parseOptions$3 = parseOptions_1;
+const { compareIdentifiers } = identifiers;
+class SemVer$e {
+  constructor (version, options) {
+    options = parseOptions$3(options);
+
+    if (version instanceof SemVer$e) {
+      if (version.loose === !!options.loose &&
+          version.includePrerelease === !!options.includePrerelease) {
+        return version
+      } else {
+        version = version.version;
       }
+    } else if (typeof version !== 'string') {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
 
-      name = scope + name;
+    if (version.length > MAX_LENGTH$1) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH$1} characters`
+      )
     }
-  }
 
-  length = sources.length;
-  index = -1;
+    debug$e('SemVer', version, options);
+    this.options = options;
+    this.loose = !!options.loose;
+    // this isn't actually relevant for versions, but keep it so that we
+    // don't run into trouble passing this.options around.
+    this.includePrerelease = !!options.includePrerelease;
 
-  while (++index < length) {
-    cwd = sources[index];
-    filePath = (plugin && resolve(cwd, plugin)) || resolve(cwd, name);
+    const m = version.trim().match(options.loose ? re$5[t$4.LOOSE] : re$5[t$4.FULL]);
 
-    if (filePath) {
-      return filePath
+    if (!m) {
+      throw new TypeError(`Invalid Version: ${version}`)
     }
-  }
 
-  return null
-}
+    this.raw = version;
 
-var isPlainObj = value => {
-	if (Object.prototype.toString.call(value) !== '[object Object]') {
-		return false;
-	}
+    // these are actually numbers
+    this.major = +m[1];
+    this.minor = +m[2];
+    this.patch = +m[3];
 
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype;
-};
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError('Invalid major version')
+    }
 
-var format = createCommonjsModule(function (module) {
-(function() {
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError('Invalid minor version')
+    }
 
-  //// Export the API
-  var namespace;
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError('Invalid patch version')
+    }
 
-  // CommonJS / Node module
-  {
-    namespace = module.exports = format;
+    // numberify any prerelease numeric ids
+    if (!m[4]) {
+      this.prerelease = [];
+    } else {
+      this.prerelease = m[4].split('.').map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id;
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num
+          }
+        }
+        return id
+      });
+    }
+
+    this.build = m[5] ? m[5].split('.') : [];
+    this.format();
   }
 
-  namespace.format = format;
-  namespace.vsprintf = vsprintf;
+  format () {
+    this.version = `${this.major}.${this.minor}.${this.patch}`;
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join('.')}`;
+    }
+    return this.version
+  }
 
-  if (typeof console !== 'undefined' && typeof console.log === 'function') {
-    namespace.printf = printf;
+  toString () {
+    return this.version
   }
 
-  function printf(/* ... */) {
-    console.log(format.apply(null, arguments));
+  compare (other) {
+    debug$e('SemVer.compare', this.version, this.options, other);
+    if (!(other instanceof SemVer$e)) {
+      if (typeof other === 'string' && other === this.version) {
+        return 0
+      }
+      other = new SemVer$e(other, this.options);
+    }
+
+    if (other.version === this.version) {
+      return 0
+    }
+
+    return this.compareMain(other) || this.comparePre(other)
   }
 
-  function vsprintf(fmt, replacements) {
-    return format.apply(null, [fmt].concat(replacements));
+  compareMain (other) {
+    if (!(other instanceof SemVer$e)) {
+      other = new SemVer$e(other, this.options);
+    }
+
+    return (
+      compareIdentifiers(this.major, other.major) ||
+      compareIdentifiers(this.minor, other.minor) ||
+      compareIdentifiers(this.patch, other.patch)
+    )
   }
 
-  function format(fmt) {
-    var argIndex = 1 // skip initial format argument
-      , args = [].slice.call(arguments)
-      , i = 0
-      , n = fmt.length
-      , result = ''
-      , c
-      , escaped = false
-      , arg
-      , tmp
-      , leadingZero = false
-      , precision
-      , nextArg = function() { return args[argIndex++]; }
-      , slurpNumber = function() {
-          var digits = '';
-          while (/\d/.test(fmt[i])) {
-            digits += fmt[i++];
-            c = fmt[i];
-          }
-          return digits.length > 0 ? parseInt(digits) : null;
-        }
-      ;
-    for (; i < n; ++i) {
-      c = fmt[i];
-      if (escaped) {
-        escaped = false;
-        if (c == '.') {
-          leadingZero = false;
-          c = fmt[++i];
+  comparePre (other) {
+    if (!(other instanceof SemVer$e)) {
+      other = new SemVer$e(other, this.options);
+    }
+
+    // NOT having a prerelease is > having one
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0
+    }
+
+    let i = 0;
+    do {
+      const a = this.prerelease[i];
+      const b = other.prerelease[i];
+      debug$e('prerelease compare', i, a, b);
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  compareBuild (other) {
+    if (!(other instanceof SemVer$e)) {
+      other = new SemVer$e(other, this.options);
+    }
+
+    let i = 0;
+    do {
+      const a = this.build[i];
+      const b = other.build[i];
+      debug$e('prerelease compare', i, a, b);
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc (release, identifier) {
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+        this.inc('pre', identifier);
+        break
+      case 'preminor':
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor++;
+        this.inc('pre', identifier);
+        break
+      case 'prepatch':
+        // If this is already a prerelease, it will bump to the next version
+        // drop any prereleases that might already exist, since they are not
+        // relevant at this point.
+        this.prerelease.length = 0;
+        this.inc('patch', identifier);
+        this.inc('pre', identifier);
+        break
+      // If the input is a non-prerelease version, this acts the same as
+      // prepatch.
+      case 'prerelease':
+        if (this.prerelease.length === 0) {
+          this.inc('patch', identifier);
         }
-        else if (c == '0' && fmt[i + 1] == '.') {
-          leadingZero = true;
-          i += 2;
-          c = fmt[i];
+        this.inc('pre', identifier);
+        break
+
+      case 'major':
+        // If this is a pre-major version, bump up to the same major version.
+        // Otherwise increment major.
+        // 1.0.0-5 bumps to 1.0.0
+        // 1.1.0 bumps to 2.0.0
+        if (
+          this.minor !== 0 ||
+          this.patch !== 0 ||
+          this.prerelease.length === 0
+        ) {
+          this.major++;
         }
-        else {
-          leadingZero = true;
+        this.minor = 0;
+        this.patch = 0;
+        this.prerelease = [];
+        break
+      case 'minor':
+        // If this is a pre-minor version, bump up to the same minor version.
+        // Otherwise increment minor.
+        // 1.2.0-5 bumps to 1.2.0
+        // 1.2.1 bumps to 1.3.0
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++;
+        }
+        this.patch = 0;
+        this.prerelease = [];
+        break
+      case 'patch':
+        // If this is not a pre-release version, it will increment the patch.
+        // If it is a pre-release it will bump up to the same patch version.
+        // 1.2.0-5 patches to 1.2.0
+        // 1.2.0 patches to 1.2.1
+        if (this.prerelease.length === 0) {
+          this.patch++;
+        }
+        this.prerelease = [];
+        break
+      // This probably shouldn't be used publicly.
+      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+      case 'pre':
+        if (this.prerelease.length === 0) {
+          this.prerelease = [0];
+        } else {
+          let i = this.prerelease.length;
+          while (--i >= 0) {
+            if (typeof this.prerelease[i] === 'number') {
+              this.prerelease[i]++;
+              i = -2;
+            }
+          }
+          if (i === -1) {
+            // didn't increment anything
+            this.prerelease.push(0);
+          }
         }
-        precision = slurpNumber();
-        switch (c) {
-        case 'b': // number in binary
-          result += parseInt(nextArg(), 10).toString(2);
-          break;
-        case 'c': // character
-          arg = nextArg();
-          if (typeof arg === 'string' || arg instanceof String)
-            result += arg;
-          else
-            result += String.fromCharCode(parseInt(arg, 10));
-          break;
-        case 'd': // number in decimal
-          result += parseInt(nextArg(), 10);
-          break;
-        case 'f': // floating point number
-          tmp = String(parseFloat(nextArg()).toFixed(precision || 6));
-          result += leadingZero ? tmp : tmp.replace(/^0/, '');
-          break;
-        case 'j': // JSON
-          result += JSON.stringify(nextArg());
-          break;
-        case 'o': // number in octal
-          result += '0' + parseInt(nextArg(), 10).toString(8);
-          break;
-        case 's': // string
-          result += nextArg();
-          break;
-        case 'x': // lowercase hexadecimal
-          result += '0x' + parseInt(nextArg(), 10).toString(16);
-          break;
-        case 'X': // uppercase hexadecimal
-          result += '0x' + parseInt(nextArg(), 10).toString(16).toUpperCase();
-          break;
-        default:
-          result += c;
-          break;
+        if (identifier) {
+          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+          if (this.prerelease[0] === identifier) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = [identifier, 0];
+            }
+          } else {
+            this.prerelease = [identifier, 0];
+          }
         }
-      } else if (c === '%') {
-        escaped = true;
-      } else {
-        result += c;
-      }
+        break
+
+      default:
+        throw new Error(`invalid increment argument: ${release}`)
     }
-    return result;
+    this.format();
+    this.raw = this.version;
+    return this
+  }
+}
+
+var semver$2 = SemVer$e;
+
+const {MAX_LENGTH} = constants;
+const { re: re$4, t: t$3 } = re$6.exports;
+const SemVer$d = semver$2;
+
+const parseOptions$2 = parseOptions_1;
+const parse$9 = (version, options) => {
+  options = parseOptions$2(options);
+
+  if (version instanceof SemVer$d) {
+    return version
   }
 
-}());
-});
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  if (version.length > MAX_LENGTH) {
+    return null
+  }
 
-var fault = create(Error);
+  const r = options.loose ? re$4[t$3.LOOSE] : re$4[t$3.FULL];
+  if (!r.test(version)) {
+    return null
+  }
 
-var fault_1 = fault;
+  try {
+    return new SemVer$d(version, options)
+  } catch (er) {
+    return null
+  }
+};
 
-fault.eval = create(EvalError);
-fault.range = create(RangeError);
-fault.reference = create(ReferenceError);
-fault.syntax = create(SyntaxError);
-fault.type = create(TypeError);
-fault.uri = create(URIError);
+var parse_1 = parse$9;
 
-fault.create = create;
+const parse$8 = parse_1;
+const valid$1 = (version, options) => {
+  const v = parse$8(version, options);
+  return v ? v.version : null
+};
+var valid_1 = valid$1;
 
-// Create a new `EConstructor`, with the formatted `format` as a first argument.
-function create(EConstructor) {
-  FormattedError.displayName = EConstructor.displayName || EConstructor.name;
+const parse$7 = parse_1;
+const clean = (version, options) => {
+  const s = parse$7(version.trim().replace(/^[=v]+/, ''), options);
+  return s ? s.version : null
+};
+var clean_1 = clean;
 
-  return FormattedError
+const SemVer$c = semver$2;
 
-  function FormattedError(format$1) {
-    if (format$1) {
-      format$1 = format.apply(null, arguments);
-    }
+const inc = (version, release, options, identifier) => {
+  if (typeof (options) === 'string') {
+    identifier = options;
+    options = undefined;
+  }
 
-    return new EConstructor(format$1)
+  try {
+    return new SemVer$c(version, options).inc(release, identifier).version
+  } catch (er) {
+    return null
   }
-}
+};
+var inc_1 = inc;
 
-var debug = src('unified-engine:find-up');
+const SemVer$b = semver$2;
+const compare$b = (a, b, loose) =>
+  new SemVer$b(a, loose).compare(new SemVer$b(b, loose));
 
-var findUp$1 = FindUp;
+var compare_1 = compare$b;
 
-var read$1 = fs$1.readFile;
-var resolve$1 = path$1.resolve;
-var relative = path$1.relative;
-var join = path$1.join;
-var dirname = path$1.dirname;
+const compare$a = compare_1;
+const eq$2 = (a, b, loose) => compare$a(a, b, loose) === 0;
+var eq_1 = eq$2;
 
-FindUp.prototype.load = load$2;
+const parse$6 = parse_1;
+const eq$1 = eq_1;
 
-function FindUp(options) {
-  var self = this;
-  var fp = options.filePath;
+const diff = (version1, version2) => {
+  if (eq$1(version1, version2)) {
+    return null
+  } else {
+    const v1 = parse$6(version1);
+    const v2 = parse$6(version2);
+    const hasPre = v1.prerelease.length || v2.prerelease.length;
+    const prefix = hasPre ? 'pre' : '';
+    const defaultResult = hasPre ? 'prerelease' : '';
+    for (const key in v1) {
+      if (key === 'major' || key === 'minor' || key === 'patch') {
+        if (v1[key] !== v2[key]) {
+          return prefix + key
+        }
+      }
+    }
+    return defaultResult // may be undefined
+  }
+};
+var diff_1 = diff;
+
+const SemVer$a = semver$2;
+const major = (a, loose) => new SemVer$a(a, loose).major;
+var major_1 = major;
+
+const SemVer$9 = semver$2;
+const minor = (a, loose) => new SemVer$9(a, loose).minor;
+var minor_1 = minor;
+
+const SemVer$8 = semver$2;
+const patch = (a, loose) => new SemVer$8(a, loose).patch;
+var patch_1 = patch;
+
+const parse$5 = parse_1;
+const prerelease = (version, options) => {
+  const parsed = parse$5(version, options);
+  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+};
+var prerelease_1 = prerelease;
+
+const compare$9 = compare_1;
+const rcompare = (a, b, loose) => compare$9(b, a, loose);
+var rcompare_1 = rcompare;
+
+const compare$8 = compare_1;
+const compareLoose = (a, b) => compare$8(a, b, true);
+var compareLoose_1 = compareLoose;
+
+const SemVer$7 = semver$2;
+const compareBuild$2 = (a, b, loose) => {
+  const versionA = new SemVer$7(a, loose);
+  const versionB = new SemVer$7(b, loose);
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+};
+var compareBuild_1 = compareBuild$2;
+
+const compareBuild$1 = compareBuild_1;
+const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(a, b, loose));
+var sort_1 = sort$1;
+
+const compareBuild = compareBuild_1;
+const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+var rsort_1 = rsort;
+
+const compare$7 = compare_1;
+const gt$3 = (a, b, loose) => compare$7(a, b, loose) > 0;
+var gt_1 = gt$3;
 
-  self.cache = {};
-  self.cwd = options.cwd;
-  self.detect = options.detect;
-  self.names = options.names;
-  self.create = options.create;
+const compare$6 = compare_1;
+const lt$2 = (a, b, loose) => compare$6(a, b, loose) < 0;
+var lt_1 = lt$2;
 
-  if (fp) {
-    self.givenFilePath = resolve$1(options.cwd, fp);
+const compare$5 = compare_1;
+const neq$1 = (a, b, loose) => compare$5(a, b, loose) !== 0;
+var neq_1 = neq$1;
+
+const compare$4 = compare_1;
+const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0;
+var gte_1 = gte$3;
+
+const compare$3 = compare_1;
+const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0;
+var lte_1 = lte$3;
+
+const eq = eq_1;
+const neq = neq_1;
+const gt$2 = gt_1;
+const gte$2 = gte_1;
+const lt$1 = lt_1;
+const lte$2 = lte_1;
+
+const cmp$1 = (a, op, b, loose) => {
+  switch (op) {
+    case '===':
+      if (typeof a === 'object')
+        a = a.version;
+      if (typeof b === 'object')
+        b = b.version;
+      return a === b
+
+    case '!==':
+      if (typeof a === 'object')
+        a = a.version;
+      if (typeof b === 'object')
+        b = b.version;
+      return a !== b
+
+    case '':
+    case '=':
+    case '==':
+      return eq(a, b, loose)
+
+    case '!=':
+      return neq(a, b, loose)
+
+    case '>':
+      return gt$2(a, b, loose)
+
+    case '>=':
+      return gte$2(a, b, loose)
+
+    case '<':
+      return lt$1(a, b, loose)
+
+    case '<=':
+      return lte$2(a, b, loose)
+
+    default:
+      throw new TypeError(`Invalid operator: ${op}`)
   }
-}
+};
+var cmp_1 = cmp$1;
 
-function load$2(filePath, callback) {
-  var self = this;
-  var cache = self.cache;
-  var givenFilePath = self.givenFilePath;
-  var givenFile = self.givenFile;
-  var names = self.names;
-  var create = self.create;
-  var cwd = self.cwd;
-  var parent;
-
-  if (givenFilePath) {
-    if (givenFile) {
-      apply(callback, givenFile);
-    } else {
-      givenFile = [callback];
-      self.givenFile = givenFile;
-      debug('Checking given file `%s`', givenFilePath);
-      read$1(givenFilePath, loadGiven);
-    }
+const SemVer$6 = semver$2;
+const parse$4 = parse_1;
+const {re: re$3, t: t$2} = re$6.exports;
 
-    return
+const coerce$I = (version, options) => {
+  if (version instanceof SemVer$6) {
+    return version
+  }
+
+  if (typeof version === 'number') {
+    version = String(version);
   }
 
-  if (!self.detect) {
-    return callback()
+  if (typeof version !== 'string') {
+    return null
   }
 
-  filePath = resolve$1(cwd, filePath);
-  parent = dirname(filePath);
+  options = options || {};
 
-  if (parent in cache) {
-    apply(callback, cache[parent]);
+  let match = null;
+  if (!options.rtl) {
+    match = version.match(re$3[t$2.COERCE]);
   } else {
-    cache[parent] = [callback];
-    find(parent);
+    // Find the right-most coercible string that does not share
+    // a terminus with a more left-ward coercible string.
+    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    //
+    // Walk through the string checking with a /g regexp
+    // Manually set the index so as to pick up overlapping matches.
+    // Stop when we get a match that ends at the string end, since no
+    // coercible string can be more right-ward without the same terminus.
+    let next;
+    while ((next = re$3[t$2.COERCERTL].exec(version)) &&
+        (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+            next.index + next[0].length !== match.index + match[0].length) {
+        match = next;
+      }
+      re$3[t$2.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+    }
+    // leave it in a clean state
+    re$3[t$2.COERCERTL].lastIndex = -1;
   }
 
-  function loadGiven(error, buf) {
-    var cbs = self.givenFile;
-    var result;
+  if (match === null)
+    return null
 
-    if (error) {
-      result = fault_1(
-        'Cannot read given file `%s`\n%s',
-        relative(cwd, givenFilePath),
-        error.stack
-      );
-      result.code = 'ENOENT';
-      result.path = error.path;
-      result.syscall = error.syscall;
-    } else {
-      try {
-        result = create(buf, givenFilePath);
-        debug('Read given file `%s`', givenFilePath);
-      } catch (error_) {
-        result = fault_1(
-          'Cannot parse given file `%s`\n%s',
-          relative(cwd, givenFilePath),
-          error_.stack
-        );
-        debug(error_.message);
-      }
+  return parse$4(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
+};
+var coerce_1 = coerce$I;
+
+var iterator = function (Yallist) {
+  Yallist.prototype[Symbol.iterator] = function* () {
+    for (let walker = this.head; walker; walker = walker.next) {
+      yield walker.value;
     }
+  };
+};
+
+var yallist = Yallist$1;
 
-    givenFile = result;
-    self.givenFile = result;
-    applyAll(cbs, result);
+Yallist$1.Node = Node;
+Yallist$1.create = Yallist$1;
+
+function Yallist$1 (list) {
+  var self = this;
+  if (!(self instanceof Yallist$1)) {
+    self = new Yallist$1();
   }
 
-  function find(directory) {
-    var index = -1;
-    var length = names.length;
+  self.tail = null;
+  self.head = null;
+  self.length = 0;
 
-    next();
+  if (list && typeof list.forEach === 'function') {
+    list.forEach(function (item) {
+      self.push(item);
+    });
+  } else if (arguments.length > 0) {
+    for (var i = 0, l = arguments.length; i < l; i++) {
+      self.push(arguments[i]);
+    }
+  }
+
+  return self
+}
 
-    function next() {
-      var parent;
+Yallist$1.prototype.removeNode = function (node) {
+  if (node.list !== this) {
+    throw new Error('removing node which does not belong to this list')
+  }
 
-      // Try to read the next file.
-      // We do not use `readdir` because on huge directories, that could be
-      // *very* slow.
-      if (++index < length) {
-        read$1(join(directory, names[index]), done);
-      } else {
-        parent = dirname(directory);
+  var next = node.next;
+  var prev = node.prev;
 
-        if (directory === parent) {
-          debug('No files found for `%s`', filePath);
-          found();
-        } else if (parent in cache) {
-          apply(found, cache[parent]);
-        } else {
-          cache[parent] = [found];
-          find(parent);
-        }
-      }
-    }
+  if (next) {
+    next.prev = prev;
+  }
 
-    function done(error, buf) {
-      var name = names[index];
-      var fp = join(directory, name);
-      var contents;
+  if (prev) {
+    prev.next = next;
+  }
 
-      /* istanbul ignore if - Hard to test. */
-      if (error) {
-        if (error.code === 'ENOENT') {
-          return next()
-        }
+  if (node === this.head) {
+    this.head = next;
+  }
+  if (node === this.tail) {
+    this.tail = prev;
+  }
 
-        error = fault_1(
-          'Cannot read file `%s`\n%s',
-          relative(cwd, fp),
-          error.message
-        );
-        debug(error.message);
-        return found(error)
-      }
+  node.list.length--;
+  node.next = null;
+  node.prev = null;
+  node.list = null;
 
-      try {
-        contents = create(buf, fp);
-      } catch (error_) {
-        return found(
-          fault_1('Cannot parse file `%s`\n%s', relative(cwd, fp), error_.message)
-        )
-      }
+  return next
+};
 
-      /* istanbul ignore else - maybe used in the future. */
-      if (contents) {
-        debug('Read file `%s`', fp);
-        found(null, contents);
-      } else {
-        next();
-      }
-    }
+Yallist$1.prototype.unshiftNode = function (node) {
+  if (node === this.head) {
+    return
+  }
 
-    function found(error, result) {
-      var cbs = cache[directory];
-      cache[directory] = error || result;
-      applyAll(cbs, error || result);
-    }
+  if (node.list) {
+    node.list.removeNode(node);
   }
 
-  function applyAll(cbs, result) {
-    var index = cbs.length;
+  var head = this.head;
+  node.list = this;
+  node.next = head;
+  if (head) {
+    head.prev = node;
+  }
 
-    while (index--) {
-      apply(cbs[index], result);
-    }
+  this.head = node;
+  if (!this.tail) {
+    this.tail = node;
   }
+  this.length++;
+};
 
-  function apply(cb, result) {
-    if (
-      result !== null &&
-      typeof result === 'object' &&
-      typeof result[0] === 'function'
-    ) {
-      result.push(cb);
-    } else if (result instanceof Error) {
-      cb(result);
-    } else {
-      cb(null, result);
-    }
+Yallist$1.prototype.pushNode = function (node) {
+  if (node === this.tail) {
+    return
   }
-}
 
-var configuration = createCommonjsModule(function (module) {
+  if (node.list) {
+    node.list.removeNode(node);
+  }
 
+  var tail = this.tail;
+  node.list = this;
+  node.prev = tail;
+  if (tail) {
+    tail.next = node;
+  }
 
+  this.tail = node;
+  if (!this.head) {
+    this.head = node;
+  }
+  this.length++;
+};
 
+Yallist$1.prototype.push = function () {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    push$2(this, arguments[i]);
+  }
+  return this.length
+};
 
+Yallist$1.prototype.unshift = function () {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    unshift(this, arguments[i]);
+  }
+  return this.length
+};
 
-var debug = src('unified-engine:configuration');
-var resolve = loadPlugin_1.resolve;
+Yallist$1.prototype.pop = function () {
+  if (!this.tail) {
+    return undefined
+  }
 
+  var res = this.tail.value;
+  this.tail = this.tail.prev;
+  if (this.tail) {
+    this.tail.next = null;
+  } else {
+    this.head = null;
+  }
+  this.length--;
+  return res
+};
 
+Yallist$1.prototype.shift = function () {
+  if (!this.head) {
+    return undefined
+  }
 
+  var res = this.head.value;
+  this.head = this.head.next;
+  if (this.head) {
+    this.head.prev = null;
+  } else {
+    this.tail = null;
+  }
+  this.length--;
+  return res
+};
 
-module.exports = Config;
+Yallist$1.prototype.forEach = function (fn, thisp) {
+  thisp = thisp || this;
+  for (var walker = this.head, i = 0; walker !== null; i++) {
+    fn.call(thisp, walker.value, i, this);
+    walker = walker.next;
+  }
+};
 
-var own = {}.hasOwnProperty;
-var extname = path$1.extname;
-var basename = path$1.basename;
-var dirname = path$1.dirname;
-var relative = path$1.relative;
+Yallist$1.prototype.forEachReverse = function (fn, thisp) {
+  thisp = thisp || this;
+  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+    fn.call(thisp, walker.value, i, this);
+    walker = walker.prev;
+  }
+};
 
-var loaders = {
-  '.json': loadJson,
-  '.js': loadScript,
-  '.yaml': loadYaml,
-  '.yml': loadYaml
+Yallist$1.prototype.get = function (n) {
+  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+    // abort out of the list early if we hit a cycle
+    walker = walker.next;
+  }
+  if (i === n && walker !== null) {
+    return walker.value
+  }
 };
 
-var defaultLoader = loadJson;
+Yallist$1.prototype.getReverse = function (n) {
+  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+    // abort out of the list early if we hit a cycle
+    walker = walker.prev;
+  }
+  if (i === n && walker !== null) {
+    return walker.value
+  }
+};
 
-Config.prototype.load = load;
+Yallist$1.prototype.map = function (fn, thisp) {
+  thisp = thisp || this;
+  var res = new Yallist$1();
+  for (var walker = this.head; walker !== null;) {
+    res.push(fn.call(thisp, walker.value, this));
+    walker = walker.next;
+  }
+  return res
+};
 
-function Config(options) {
-  var rcName = options.rcName;
-  var packageField = options.packageField;
-  var names = [];
+Yallist$1.prototype.mapReverse = function (fn, thisp) {
+  thisp = thisp || this;
+  var res = new Yallist$1();
+  for (var walker = this.tail; walker !== null;) {
+    res.push(fn.call(thisp, walker.value, this));
+    walker = walker.prev;
+  }
+  return res
+};
 
-  this.cwd = options.cwd;
-  this.packageField = options.packageField;
-  this.pluginPrefix = options.pluginPrefix;
-  this.configTransform = options.configTransform;
-  this.defaultConfig = options.defaultConfig;
+Yallist$1.prototype.reduce = function (fn, initial) {
+  var acc;
+  var walker = this.head;
+  if (arguments.length > 1) {
+    acc = initial;
+  } else if (this.head) {
+    walker = this.head.next;
+    acc = this.head.value;
+  } else {
+    throw new TypeError('Reduce of empty list with no initial value')
+  }
 
-  if (rcName) {
-    names.push(rcName, rcName + '.js', rcName + '.yml', rcName + '.yaml');
-    debug('Looking for `%s` configuration files', names);
+  for (var i = 0; walker !== null; i++) {
+    acc = fn(acc, walker.value, i);
+    walker = walker.next;
   }
 
-  if (packageField) {
-    names.push('package.json');
-    debug('Looking for `%s` fields in `package.json` files', packageField);
+  return acc
+};
+
+Yallist$1.prototype.reduceReverse = function (fn, initial) {
+  var acc;
+  var walker = this.tail;
+  if (arguments.length > 1) {
+    acc = initial;
+  } else if (this.tail) {
+    walker = this.tail.prev;
+    acc = this.tail.value;
+  } else {
+    throw new TypeError('Reduce of empty list with no initial value')
   }
 
-  this.given = {settings: options.settings, plugins: options.plugins};
-  this.create = create.bind(this);
+  for (var i = this.length - 1; walker !== null; i--) {
+    acc = fn(acc, walker.value, i);
+    walker = walker.prev;
+  }
 
-  this.findUp = new findUp$1({
-    filePath: options.rcPath,
-    cwd: options.cwd,
-    detect: options.detectConfig,
-    names: names,
-    create: this.create
-  });
-}
+  return acc
+};
 
-function load(filePath, callback) {
-  var self = this;
-  var searchPath = filePath || path$1.resolve(this.cwd, 'stdin.js');
+Yallist$1.prototype.toArray = function () {
+  var arr = new Array(this.length);
+  for (var i = 0, walker = this.head; walker !== null; i++) {
+    arr[i] = walker.value;
+    walker = walker.next;
+  }
+  return arr
+};
 
-  self.findUp.load(searchPath, done);
+Yallist$1.prototype.toArrayReverse = function () {
+  var arr = new Array(this.length);
+  for (var i = 0, walker = this.tail; walker !== null; i++) {
+    arr[i] = walker.value;
+    walker = walker.prev;
+  }
+  return arr
+};
 
-  function done(error, file) {
-    if (error || file) {
-      return callback(error, file)
-    }
+Yallist$1.prototype.slice = function (from, to) {
+  to = to || this.length;
+  if (to < 0) {
+    to += this.length;
+  }
+  from = from || 0;
+  if (from < 0) {
+    from += this.length;
+  }
+  var ret = new Yallist$1();
+  if (to < from || to < 0) {
+    return ret
+  }
+  if (from < 0) {
+    from = 0;
+  }
+  if (to > this.length) {
+    to = this.length;
+  }
+  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+    walker = walker.next;
+  }
+  for (; walker !== null && i < to; i++, walker = walker.next) {
+    ret.push(walker.value);
+  }
+  return ret
+};
 
-    callback(null, self.create());
+Yallist$1.prototype.sliceReverse = function (from, to) {
+  to = to || this.length;
+  if (to < 0) {
+    to += this.length;
   }
-}
+  from = from || 0;
+  if (from < 0) {
+    from += this.length;
+  }
+  var ret = new Yallist$1();
+  if (to < from || to < 0) {
+    return ret
+  }
+  if (from < 0) {
+    from = 0;
+  }
+  if (to > this.length) {
+    to = this.length;
+  }
+  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+    walker = walker.prev;
+  }
+  for (; walker !== null && i > from; i--, walker = walker.prev) {
+    ret.push(walker.value);
+  }
+  return ret
+};
 
-function create(buf, filePath) {
-  var self = this;
-  var transform = self.configTransform;
-  var defaults = self.defaultConfig;
-  var fn = (filePath && loaders[extname(filePath)]) || defaultLoader;
-  var options = {prefix: self.pluginPrefix, cwd: self.cwd};
-  var result = {settings: {}, plugins: []};
-  var contents = buf ? fn.apply(self, arguments) : undefined;
+Yallist$1.prototype.splice = function (start, deleteCount, ...nodes) {
+  if (start > this.length) {
+    start = this.length - 1;
+  }
+  if (start < 0) {
+    start = this.length + start;
+  }
 
-  if (transform && contents !== undefined) {
-    contents = transform(contents, filePath);
+  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+    walker = walker.next;
   }
 
-  // Exit if we did find a `package.json`, but it does not have configuration.
-  if (buf && contents === undefined && basename(filePath) === 'package.json') {
-    return
+  var ret = [];
+  for (var i = 0; walker && i < deleteCount; i++) {
+    ret.push(walker.value);
+    walker = this.removeNode(walker);
+  }
+  if (walker === null) {
+    walker = this.tail;
   }
 
-  if (contents === undefined) {
-    if (defaults) {
-      merge(result, defaults, Object.assign({}, options, {root: self.cwd}));
-    }
-  } else {
-    merge(
-      result,
-      contents,
-      Object.assign({}, options, {root: dirname(filePath)})
-    );
+  if (walker !== this.head && walker !== this.tail) {
+    walker = walker.prev;
   }
 
-  merge(result, self.given, Object.assign({}, options, {root: self.cwd}));
+  for (var i = 0; i < nodes.length; i++) {
+    walker = insert(this, walker, nodes[i]);
+  }
+  return ret;
+};
 
-  return result
-}
+Yallist$1.prototype.reverse = function () {
+  var head = this.head;
+  var tail = this.tail;
+  for (var walker = head; walker !== null; walker = walker.prev) {
+    var p = walker.prev;
+    walker.prev = walker.next;
+    walker.next = p;
+  }
+  this.head = tail;
+  this.tail = head;
+  return this
+};
 
-// Basically `Module.prototype.load`, but for a buffer instead of a file path.
-function loadScript(buf, filePath) {
-  var submodule = module$1._cache[filePath];
+function insert (self, node, value) {
+  var inserted = node === self.head ?
+    new Node(value, null, node, self) :
+    new Node(value, node, node.next, self);
 
-  if (!submodule) {
-    submodule = new module$1(filePath, module);
-    submodule.filename = filePath;
-    submodule.paths = module$1._nodeModulePaths(dirname(filePath));
-    submodule._compile(String(buf), filePath);
-    submodule.loaded = true;
-    module$1._cache[filePath] = submodule;
+  if (inserted.next === null) {
+    self.tail = inserted;
+  }
+  if (inserted.prev === null) {
+    self.head = inserted;
   }
 
-  return submodule.exports
+  self.length++;
+
+  return inserted
 }
 
-function loadYaml(buf, filePath) {
-  return jsYaml$1.safeLoad(buf, {filename: basename(filePath)})
+function push$2 (self, item) {
+  self.tail = new Node(item, self.tail, null, self);
+  if (!self.head) {
+    self.head = self.tail;
+  }
+  self.length++;
 }
 
-function loadJson(buf, filePath) {
-  var result = parseJson$1(buf, filePath);
+function unshift (self, item) {
+  self.head = new Node(item, null, self.head, self);
+  if (!self.tail) {
+    self.tail = self.head;
+  }
+  self.length++;
+}
 
-  if (basename(filePath) === 'package.json') {
-    result = result[this.packageField];
+function Node (value, prev, next, list) {
+  if (!(this instanceof Node)) {
+    return new Node(value, prev, next, list)
   }
 
-  return result
-}
+  this.list = list;
+  this.value = value;
 
-function merge(target, raw, options) {
-  var root = options.root;
-  var cwd = options.cwd;
-  var prefix = options.prefix;
+  if (prev) {
+    prev.next = this;
+    this.prev = prev;
+  } else {
+    this.prev = null;
+  }
 
-  if (typeof raw === 'object' && raw !== null) {
-    addPreset(raw);
+  if (next) {
+    next.prev = this;
+    this.next = next;
   } else {
-    throw new Error('Expected preset, not `' + raw + '`')
+    this.next = null;
   }
+}
 
-  return target
+try {
+  // add if support for Symbol.iterator is present
+  iterator(Yallist$1);
+} catch (er) {}
 
-  function addPreset(result) {
-    var plugins = result.plugins;
+// A linked list to keep track of recently-used-ness
+const Yallist = yallist;
+
+const MAX = Symbol('max');
+const LENGTH = Symbol('length');
+const LENGTH_CALCULATOR = Symbol('lengthCalculator');
+const ALLOW_STALE = Symbol('allowStale');
+const MAX_AGE = Symbol('maxAge');
+const DISPOSE = Symbol('dispose');
+const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
+const LRU_LIST = Symbol('lruList');
+const CACHE = Symbol('cache');
+const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
+
+const naiveLength = () => 1;
+
+// lruList is a yallist where the head is the youngest
+// item, and the tail is the oldest.  the list contains the Hit
+// objects as the entries.
+// Each Hit object has a reference to its Yallist.Node.  This
+// never changes.
+//
+// cache is a Map (or PseudoMap) that matches the keys to
+// the Yallist.Node object.
+class LRUCache {
+  constructor (options) {
+    if (typeof options === 'number')
+      options = { max: options };
+
+    if (!options)
+      options = {};
 
-    if (plugins === null || plugins === undefined) ; else if (typeof plugins === 'object' && plugins !== null) {
-      if ('length' in plugins) {
-        addEach(plugins);
-      } else {
-        addIn(plugins);
-      }
-    } else {
-      throw new Error(
-        'Expected a list or object of plugins, not `' + plugins + '`'
-      )
-    }
+    if (options.max && (typeof options.max !== 'number' || options.max < 0))
+      throw new TypeError('max must be a non-negative number')
+    // Kind of weird to have a default max of Infinity, but oh well.
+    this[MAX] = options.max || Infinity;
 
-    target.settings = Object.assign({}, target.settings, result.settings);
+    const lc = options.length || naiveLength;
+    this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc;
+    this[ALLOW_STALE] = options.stale || false;
+    if (options.maxAge && typeof options.maxAge !== 'number')
+      throw new TypeError('maxAge must be a number')
+    this[MAX_AGE] = options.maxAge || 0;
+    this[DISPOSE] = options.dispose;
+    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
+    this.reset();
   }
 
-  function addEach(result) {
-    var length = result.length;
-    var index = -1;
-    var value;
+  // resize the cache when the max changes.
+  set max (mL) {
+    if (typeof mL !== 'number' || mL < 0)
+      throw new TypeError('max must be a non-negative number')
 
-    while (++index < length) {
-      value = result[index];
+    this[MAX] = mL || Infinity;
+    trim(this);
+  }
+  get max () {
+    return this[MAX]
+  }
 
-      if (value !== null && typeof value === 'object' && 'length' in value) {
-        use.apply(null, value);
-      } else {
-        use(value);
-      }
-    }
+  set allowStale (allowStale) {
+    this[ALLOW_STALE] = !!allowStale;
+  }
+  get allowStale () {
+    return this[ALLOW_STALE]
   }
 
-  function addIn(result) {
-    var key;
+  set maxAge (mA) {
+    if (typeof mA !== 'number')
+      throw new TypeError('maxAge must be a non-negative number')
 
-    for (key in result) {
-      use(key, result[key]);
-    }
+    this[MAX_AGE] = mA;
+    trim(this);
   }
-
-  function use(usable, value) {
-    if (typeof usable === 'string') {
-      addModule(usable, value);
-    } else if (typeof usable === 'function') {
-      addPlugin(usable, value);
-    } else {
-      merge(target, usable, options);
-    }
+  get maxAge () {
+    return this[MAX_AGE]
   }
 
-  function addModule(id, value) {
-    var fp = resolve(id, {cwd: root, prefix: prefix});
-    var result;
-
-    if (fp) {
-      try {
-        result = commonjsRequire(fp);
-      } catch (error) {
-        throw fault_1(
-          'Cannot parse script `%s`\n%s',
-          relative(root, fp),
-          error.stack
-        )
-      }
+  // resize the cache when the lengthCalculator changes.
+  set lengthCalculator (lC) {
+    if (typeof lC !== 'function')
+      lC = naiveLength;
 
-      try {
-        if (typeof result === 'function') {
-          addPlugin(result, value);
-        } else {
-          merge(target, result, Object.assign({}, options, {root: dirname(fp)}));
-        }
-      } catch (_) {
-        throw fault_1(
-          'Error: Expected preset or plugin, not %s, at `%s`',
-          result,
-          relative(root, fp)
-        )
-      }
-    } else {
-      fp = relative(cwd, path$1.resolve(root, id));
-      addPlugin(
-        failingModule(fp, new Error('Could not find module `' + id + '`')),
-        value
-      );
+    if (lC !== this[LENGTH_CALCULATOR]) {
+      this[LENGTH_CALCULATOR] = lC;
+      this[LENGTH] = 0;
+      this[LRU_LIST].forEach(hit => {
+        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
+        this[LENGTH] += hit.length;
+      });
     }
+    trim(this);
   }
+  get lengthCalculator () { return this[LENGTH_CALCULATOR] }
 
-  function addPlugin(result, value) {
-    var entry = find(target.plugins, result);
+  get length () { return this[LENGTH] }
+  get itemCount () { return this[LRU_LIST].length }
 
-    if (entry) {
-      reconfigure(entry, value);
-    } else {
-      target.plugins.push([result, value]);
+  rforEach (fn, thisp) {
+    thisp = thisp || this;
+    for (let walker = this[LRU_LIST].tail; walker !== null;) {
+      const prev = walker.prev;
+      forEachStep(this, fn, walker, thisp);
+      walker = prev;
     }
   }
-}
-
-function reconfigure(entry, value) {
-  if (isPlainObj(entry[1]) && isPlainObj(value)) {
-    value = Object.assign({}, entry[1], value);
-  }
 
-  entry[1] = value;
-}
-
-function find(entries, plugin) {
-  var length = entries.length;
-  var index = -1;
-  var entry;
-
-  while (++index < length) {
-    entry = entries[index];
-
-    if (entry[0] === plugin) {
-      return entry
+  forEach (fn, thisp) {
+    thisp = thisp || this;
+    for (let walker = this[LRU_LIST].head; walker !== null;) {
+      const next = walker.next;
+      forEachStep(this, fn, walker, thisp);
+      walker = next;
     }
   }
-}
 
-function failingModule(id, error) {
-  var cache = failingModule.cache || (failingModule.cache = {});
-  var submodule = own.call(cache, id) ? cache[id] : (cache[id] = fail);
-  return submodule
-  function fail() {
-    throw error
+  keys () {
+    return this[LRU_LIST].toArray().map(k => k.key)
   }
-}
-});
-
-var configure_1 = configure;
-
-function configure(context, settings) {
-  context.configuration = new configuration(settings);
-}
-
-// A simple implementation of make-array
-function makeArray (subject) {
-  return Array.isArray(subject)
-    ? subject
-    : [subject]
-}
-
-const REGEX_TEST_BLANK_LINE = /^\s+$/;
-const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
-const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
-const REGEX_SPLITALL_CRLF = /\r?\n/g;
-// /foo,
-// ./foo,
-// ../foo,
-// .
-// ..
-const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
 
-const SLASH = '/';
-const KEY_IGNORE = typeof Symbol !== 'undefined'
-  ? Symbol.for('node-ignore')
-  /* istanbul ignore next */
-  : 'node-ignore';
+  values () {
+    return this[LRU_LIST].toArray().map(k => k.value)
+  }
 
-const define = (object, key, value) =>
-  Object.defineProperty(object, key, {value});
+  reset () {
+    if (this[DISPOSE] &&
+        this[LRU_LIST] &&
+        this[LRU_LIST].length) {
+      this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value));
+    }
 
-const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    this[CACHE] = new Map(); // hash of items by key
+    this[LRU_LIST] = new Yallist(); // list of items in order of use recency
+    this[LENGTH] = 0; // length of items in the list
+  }
 
-// Sanitize the range of a regular expression
-// The cases are complicated, see test cases for details
-const sanitizeRange = range => range.replace(
-  REGEX_REGEXP_RANGE,
-  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
-    ? match
-    // Invalid range (out of order) which is ok for gitignore rules but
-    //   fatal for JavaScript regular expression, so eliminate it.
-    : ''
-);
+  dump () {
+    return this[LRU_LIST].map(hit =>
+      isStale(this, hit) ? false : {
+        k: hit.key,
+        v: hit.value,
+        e: hit.now + (hit.maxAge || 0)
+      }).toArray().filter(h => h)
+  }
 
-// > If the pattern ends with a slash,
-// > it is removed for the purpose of the following description,
-// > but it would only find a match with a directory.
-// > In other words, foo/ will match a directory foo and paths underneath it,
-// > but will not match a regular file or a symbolic link foo
-// >  (this is consistent with the way how pathspec works in general in Git).
-// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
-// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
-//      you could use option `mark: true` with `glob`
+  dumpLru () {
+    return this[LRU_LIST]
+  }
 
-// '`foo/`' should not continue with the '`..`'
-const REPLACERS = [
+  set (key, value, maxAge) {
+    maxAge = maxAge || this[MAX_AGE];
 
-  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
-  [
-    // (a\ ) -> (a )
-    // (a  ) -> (a)
-    // (a \ ) -> (a  )
-    /\\?\s+$/,
-    match => match.indexOf('\\') === 0
-      ? ' '
-      : ''
-  ],
+    if (maxAge && typeof maxAge !== 'number')
+      throw new TypeError('maxAge must be a number')
 
-  // replace (\ ) with ' '
-  [
-    /\\\s/g,
-    () => ' '
-  ],
+    const now = maxAge ? Date.now() : 0;
+    const len = this[LENGTH_CALCULATOR](value, key);
 
-  // Escape metacharacters
-  // which is written down by users but means special for regular expressions.
+    if (this[CACHE].has(key)) {
+      if (len > this[MAX]) {
+        del(this, this[CACHE].get(key));
+        return false
+      }
 
-  // > There are 12 characters with special meanings:
-  // > - the backslash \,
-  // > - the caret ^,
-  // > - the dollar sign $,
-  // > - the period or dot .,
-  // > - the vertical bar or pipe symbol |,
-  // > - the question mark ?,
-  // > - the asterisk or star *,
-  // > - the plus sign +,
-  // > - the opening parenthesis (,
-  // > - the closing parenthesis ),
-  // > - and the opening square bracket [,
-  // > - the opening curly brace {,
-  // > These special characters are often called "metacharacters".
-  [
-    /[\\^$.|*+(){]/g,
-    match => `\\${match}`
-  ],
+      const node = this[CACHE].get(key);
+      const item = node.value;
 
-  [
-    // > [abc] matches any character inside the brackets
-    // >    (in this case a, b, or c);
-    /\[([^\]/]*)($|\])/g,
-    (match, p1, p2) => p2 === ']'
-      ? `[${sanitizeRange(p1)}]`
-      : `\\${match}`
-  ],
+      // dispose of the old one before overwriting
+      // split out into 2 ifs for better coverage tracking
+      if (this[DISPOSE]) {
+        if (!this[NO_DISPOSE_ON_SET])
+          this[DISPOSE](key, item.value);
+      }
 
-  [
-    // > a question mark (?) matches a single character
-    /(?!\\)\?/g,
-    () => '[^/]'
-  ],
+      item.now = now;
+      item.maxAge = maxAge;
+      item.value = value;
+      this[LENGTH] += len - item.length;
+      item.length = len;
+      this.get(key);
+      trim(this);
+      return true
+    }
 
-  // leading slash
-  [
+    const hit = new Entry(key, value, len, now, maxAge);
 
-    // > A leading slash matches the beginning of the pathname.
-    // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
-    // A leading slash matches the beginning of the pathname
-    /^\//,
-    () => '^'
-  ],
+    // oversized objects fall out of cache automatically.
+    if (hit.length > this[MAX]) {
+      if (this[DISPOSE])
+        this[DISPOSE](key, value);
 
-  // replace special metacharacter slash after the leading slash
-  [
-    /\//g,
-    () => '\\/'
-  ],
+      return false
+    }
 
-  [
-    // > A leading "**" followed by a slash means match in all directories.
-    // > For example, "**/foo" matches file or directory "foo" anywhere,
-    // > the same as pattern "foo".
-    // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
-    // >   under directory "foo".
-    // Notice that the '*'s have been replaced as '\\*'
-    /^\^*\\\*\\\*\\\//,
+    this[LENGTH] += hit.length;
+    this[LRU_LIST].unshift(hit);
+    this[CACHE].set(key, this[LRU_LIST].head);
+    trim(this);
+    return true
+  }
 
-    // '**/foo' <-> 'foo'
-    () => '^(?:.*\\/)?'
-  ],
+  has (key) {
+    if (!this[CACHE].has(key)) return false
+    const hit = this[CACHE].get(key).value;
+    return !isStale(this, hit)
+  }
 
-  // ending
-  [
-    // 'js' will not match 'js.'
-    // 'ab' will not match 'abc'
-    /(?:[^*])$/,
+  get (key) {
+    return get(this, key, true)
+  }
 
-    // WTF!
-    // https://git-scm.com/docs/gitignore
-    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
-    // which re-fixes #24, #38
+  peek (key) {
+    return get(this, key, false)
+  }
 
-    // > If there is a separator at the end of the pattern then the pattern
-    // > will only match directories, otherwise the pattern can match both
-    // > files and directories.
+  pop () {
+    const node = this[LRU_LIST].tail;
+    if (!node)
+      return null
 
-    // 'js*' will not match 'a.js'
-    // 'js/' will not match 'a.js'
-    // 'js' will match 'a.js' and 'a.js/'
-    match => /\/$/.test(match)
-      // foo/ will not match 'foo'
-      ? `${match}$`
-      // foo matches 'foo' and 'foo/'
-      : `${match}(?=$|\\/$)`
-  ],
+    del(this, node);
+    return node.value
+  }
 
-  // starting
-  [
-    // there will be no leading '/'
-    //   (which has been replaced by section "leading slash")
-    // If starts with '**', adding a '^' to the regular expression also works
-    /^(?=[^^])/,
-    function startingReplacer () {
-      // If has a slash `/` at the beginning or middle
-      return !/\/(?!$)/.test(this)
-        // > Prior to 2.22.1
-        // > If the pattern does not contain a slash /,
-        // >   Git treats it as a shell glob pattern
-        // Actually, if there is only a trailing slash,
-        //   git also treats it as a shell glob pattern
+  del (key) {
+    del(this, this[CACHE].get(key));
+  }
 
-        // After 2.22.1 (compatible but clearer)
-        // > If there is a separator at the beginning or middle (or both)
-        // > of the pattern, then the pattern is relative to the directory
-        // > level of the particular .gitignore file itself.
-        // > Otherwise the pattern may also match at any level below
-        // > the .gitignore level.
-        ? '(?:^|\\/)'
+  load (arr) {
+    // reset the cache
+    this.reset();
 
-        // > Otherwise, Git treats the pattern as a shell glob suitable for
-        // >   consumption by fnmatch(3)
-        : '^'
+    const now = Date.now();
+    // A previous serialized cache has the most recent items first
+    for (let l = arr.length - 1; l >= 0; l--) {
+      const hit = arr[l];
+      const expiresAt = hit.e || 0;
+      if (expiresAt === 0)
+        // the item was created without expiration in a non aged cache
+        this.set(hit.k, hit.v);
+      else {
+        const maxAge = expiresAt - now;
+        // dont add already expired items
+        if (maxAge > 0) {
+          this.set(hit.k, hit.v, maxAge);
+        }
+      }
     }
-  ],
-
-  // two globstars
-  [
-    // Use lookahead assertions so that we could match more than one `'/**'`
-    /\\\/\\\*\\\*(?=\\\/|$)/g,
+  }
 
-    // Zero, one or several directories
-    // should not use '*', or it will be replaced by the next replacer
+  prune () {
+    this[CACHE].forEach((value, key) => get(this, key, false));
+  }
+}
 
-    // Check if it is not the last `'/**'`
-    (_, index, str) => index + 6 < str.length
+const get = (self, key, doUse) => {
+  const node = self[CACHE].get(key);
+  if (node) {
+    const hit = node.value;
+    if (isStale(self, hit)) {
+      del(self, node);
+      if (!self[ALLOW_STALE])
+        return undefined
+    } else {
+      if (doUse) {
+        if (self[UPDATE_AGE_ON_GET])
+          node.value.now = Date.now();
+        self[LRU_LIST].unshiftNode(node);
+      }
+    }
+    return hit.value
+  }
+};
 
-      // case: /**/
-      // > A slash followed by two consecutive asterisks then a slash matches
-      // >   zero or more directories.
-      // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
-      // '/**/'
-      ? '(?:\\/[^\\/]+)*'
+const isStale = (self, hit) => {
+  if (!hit || (!hit.maxAge && !self[MAX_AGE]))
+    return false
 
-      // case: /**
-      // > A trailing `"/**"` matches everything inside.
+  const diff = Date.now() - hit.now;
+  return hit.maxAge ? diff > hit.maxAge
+    : self[MAX_AGE] && (diff > self[MAX_AGE])
+};
 
-      // #21: everything inside but it should not include the current folder
-      : '\\/.+'
-  ],
+const trim = self => {
+  if (self[LENGTH] > self[MAX]) {
+    for (let walker = self[LRU_LIST].tail;
+      self[LENGTH] > self[MAX] && walker !== null;) {
+      // We know that we're about to delete this one, and also
+      // what the next least recently used key will be, so just
+      // go ahead and set it now.
+      const prev = walker.prev;
+      del(self, walker);
+      walker = prev;
+    }
+  }
+};
 
-  // intermediate wildcards
-  [
-    // Never replace escaped '*'
-    // ignore rule '\*' will match the path '*'
+const del = (self, node) => {
+  if (node) {
+    const hit = node.value;
+    if (self[DISPOSE])
+      self[DISPOSE](hit.key, hit.value);
 
-    // 'abc.*/' -> go
-    // 'abc.*'  -> skip this rule
-    /(^|[^\\]+)\\\*(?=.+)/g,
+    self[LENGTH] -= hit.length;
+    self[CACHE].delete(hit.key);
+    self[LRU_LIST].removeNode(node);
+  }
+};
 
-    // '*.js' matches '.js'
-    // '*.js' doesn't match 'abc'
-    (_, p1) => `${p1}[^\\/]*`
-  ],
+class Entry {
+  constructor (key, value, length, now, maxAge) {
+    this.key = key;
+    this.value = value;
+    this.length = length;
+    this.now = now;
+    this.maxAge = maxAge || 0;
+  }
+}
 
-  // trailing wildcard
-  [
-    /(\^|\\\/)?\\\*$/,
-    (_, p1) => {
-      const prefix = p1
-        // '\^':
-        // '/*' does not match ''
-        // '/*' does not match everything
+const forEachStep = (self, fn, node, thisp) => {
+  let hit = node.value;
+  if (isStale(self, hit)) {
+    del(self, node);
+    if (!self[ALLOW_STALE])
+      hit = undefined;
+  }
+  if (hit)
+    fn.call(thisp, hit.value, hit.key, self);
+};
 
-        // '\\\/':
-        // 'abc/*' does not match 'abc/'
-        ? `${p1}[^/]+`
+var lruCache = LRUCache;
 
-        // 'a*' matches 'a'
-        // 'a*' matches 'aa'
-        : '[^/]*';
+// hoisted class for cyclic dependency
+class Range$a {
+  constructor (range, options) {
+    options = parseOptions$1(options);
 
-      return `${prefix}(?=$|\\/$)`
+    if (range instanceof Range$a) {
+      if (
+        range.loose === !!options.loose &&
+        range.includePrerelease === !!options.includePrerelease
+      ) {
+        return range
+      } else {
+        return new Range$a(range.raw, options)
+      }
+    }
+
+    if (range instanceof Comparator$2) {
+      // just put it in the set and return
+      this.raw = range.value;
+      this.set = [[range]];
+      this.format();
+      return this
+    }
+
+    this.options = options;
+    this.loose = !!options.loose;
+    this.includePrerelease = !!options.includePrerelease;
+
+    // First, split based on boolean or ||
+    this.raw = range;
+    this.set = range
+      .split(/\s*\|\|\s*/)
+      // map the range to a 2d array of comparators
+      .map(range => this.parseRange(range.trim()))
+      // throw out any comparator lists that are empty
+      // this generally means that it was not a valid range, which is allowed
+      // in loose mode, but will still throw if the WHOLE range is invalid.
+      .filter(c => c.length);
+
+    if (!this.set.length) {
+      throw new TypeError(`Invalid SemVer Range: ${range}`)
+    }
+
+    // if we have any that are not the null set, throw out null sets.
+    if (this.set.length > 1) {
+      // keep the first one, in case they're all null sets
+      const first = this.set[0];
+      this.set = this.set.filter(c => !isNullSet(c[0]));
+      if (this.set.length === 0)
+        this.set = [first];
+      else if (this.set.length > 1) {
+        // if we have any that are *, then the range is just *
+        for (const c of this.set) {
+          if (c.length === 1 && isAny(c[0])) {
+            this.set = [c];
+            break
+          }
+        }
+      }
     }
-  ],
-
-  [
-    // unescape
-    /\\\\\\/g,
-    () => '\\'
-  ]
-];
-
-// A simple cache, because an ignore rule only has only one certain meaning
-const regexCache = Object.create(null);
 
-// @param {pattern}
-const makeRegex = (pattern, negative, ignorecase) => {
-  const r = regexCache[pattern];
-  if (r) {
-    return r
+    this.format();
   }
 
-  // const replacers = negative
-  //   ? NEGATIVE_REPLACERS
-  //   : POSITIVE_REPLACERS
-
-  const source = REPLACERS.reduce(
-    (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
-    pattern
-  );
-
-  return regexCache[pattern] = ignorecase
-    ? new RegExp(source, 'i')
-    : new RegExp(source)
-};
+  format () {
+    this.range = this.set
+      .map((comps) => {
+        return comps.join(' ').trim()
+      })
+      .join('||')
+      .trim();
+    return this.range
+  }
+
+  toString () {
+    return this.range
+  }
+
+  parseRange (range) {
+    range = range.trim();
+
+    // memoize range parsing for performance.
+    // this is a very hot path, and fully deterministic.
+    const memoOpts = Object.keys(this.options).join(',');
+    const memoKey = `parseRange:${memoOpts}:${range}`;
+    const cached = cache$1.get(memoKey);
+    if (cached)
+      return cached
+
+    const loose = this.options.loose;
+    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+    const hr = loose ? re$2[t$1.HYPHENRANGELOOSE] : re$2[t$1.HYPHENRANGE];
+    range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+    debug$d('hyphen replace', range);
+    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+    range = range.replace(re$2[t$1.COMPARATORTRIM], comparatorTrimReplace);
+    debug$d('comparator trim', range, re$2[t$1.COMPARATORTRIM]);
+
+    // `~ 1.2.3` => `~1.2.3`
+    range = range.replace(re$2[t$1.TILDETRIM], tildeTrimReplace);
+
+    // `^ 1.2.3` => `^1.2.3`
+    range = range.replace(re$2[t$1.CARETTRIM], caretTrimReplace);
+
+    // normalize spaces
+    range = range.split(/\s+/).join(' ');
+
+    // At this point, the range is completely trimmed and
+    // ready to be split into comparators.
+
+    const compRe = loose ? re$2[t$1.COMPARATORLOOSE] : re$2[t$1.COMPARATOR];
+    const rangeList = range
+      .split(' ')
+      .map(comp => parseComparator(comp, this.options))
+      .join(' ')
+      .split(/\s+/)
+      // >=0.0.0 is equivalent to *
+      .map(comp => replaceGTE0(comp, this.options))
+      // in loose mode, throw out any that are not valid comparators
+      .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true)
+      .map(comp => new Comparator$2(comp, this.options));
+
+    // if any comparators are the null set, then replace with JUST null set
+    // if more than one comparator, remove any * comparators
+    // also, don't include the same comparator more than once
+    rangeList.length;
+    const rangeMap = new Map();
+    for (const comp of rangeList) {
+      if (isNullSet(comp))
+        return [comp]
+      rangeMap.set(comp.value, comp);
+    }
+    if (rangeMap.size > 1 && rangeMap.has(''))
+      rangeMap.delete('');
+
+    const result = [...rangeMap.values()];
+    cache$1.set(memoKey, result);
+    return result
+  }
 
-const isString = subject => typeof subject === 'string';
+  intersects (range, options) {
+    if (!(range instanceof Range$a)) {
+      throw new TypeError('a Range is required')
+    }
 
-// > A blank line matches no files, so it can serve as a separator for readability.
-const checkPattern = pattern => pattern
-  && isString(pattern)
-  && !REGEX_TEST_BLANK_LINE.test(pattern)
+    return this.set.some((thisComparators) => {
+      return (
+        isSatisfiable(thisComparators, options) &&
+        range.set.some((rangeComparators) => {
+          return (
+            isSatisfiable(rangeComparators, options) &&
+            thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options)
+              })
+            })
+          )
+        })
+      )
+    })
+  }
 
-  // > A line starting with # serves as a comment.
-  && pattern.indexOf('#') !== 0;
+  // if ANY of the sets match ALL of its comparators, then pass
+  test (version) {
+    if (!version) {
+      return false
+    }
 
-const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF);
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer$5(version, this.options);
+      } catch (er) {
+        return false
+      }
+    }
 
-class IgnoreRule {
-  constructor (
-    origin,
-    pattern,
-    negative,
-    regex
-  ) {
-    this.origin = origin;
-    this.pattern = pattern;
-    this.negative = negative;
-    this.regex = regex;
+    for (let i = 0; i < this.set.length; i++) {
+      if (testSet(this.set[i], version, this.options)) {
+        return true
+      }
+    }
+    return false
   }
 }
+var range$1 = Range$a;
 
-const createRule = (pattern, ignorecase) => {
-  const origin = pattern;
-  let negative = false;
+const LRU = lruCache;
+const cache$1 = new LRU({ max: 1000 });
 
-  // > An optional prefix "!" which negates the pattern;
-  if (pattern.indexOf('!') === 0) {
-    negative = true;
-    pattern = pattern.substr(1);
+const parseOptions$1 = parseOptions_1;
+const Comparator$2 = comparator$1;
+const debug$d = debug_1;
+const SemVer$5 = semver$2;
+const {
+  re: re$2,
+  t: t$1,
+  comparatorTrimReplace,
+  tildeTrimReplace,
+  caretTrimReplace
+} = re$6.exports;
+
+const isNullSet = c => c.value === '<0.0.0-0';
+const isAny = c => c.value === '';
+
+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+const isSatisfiable = (comparators, options) => {
+  let result = true;
+  const remainingComparators = comparators.slice();
+  let testComparator = remainingComparators.pop();
+
+  while (result && remainingComparators.length) {
+    result = remainingComparators.every((otherComparator) => {
+      return testComparator.intersects(otherComparator, options)
+    });
+
+    testComparator = remainingComparators.pop();
   }
 
-  pattern = pattern
-  // > Put a backslash ("\") in front of the first "!" for patterns that
-  // >   begin with a literal "!", for example, `"\!important!.txt"`.
-  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
-  // > Put a backslash ("\") in front of the first hash for patterns that
-  // >   begin with a hash.
-  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#');
+  return result
+};
 
-  const regex = makeRegex(pattern, negative, ignorecase);
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+const parseComparator = (comp, options) => {
+  debug$d('comp', comp, options);
+  comp = replaceCarets(comp, options);
+  debug$d('caret', comp);
+  comp = replaceTildes(comp, options);
+  debug$d('tildes', comp);
+  comp = replaceXRanges(comp, options);
+  debug$d('xrange', comp);
+  comp = replaceStars(comp, options);
+  debug$d('stars', comp);
+  return comp
+};
+
+const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+const replaceTildes = (comp, options) =>
+  comp.trim().split(/\s+/).map((comp) => {
+    return replaceTilde(comp, options)
+  }).join(' ');
+
+const replaceTilde = (comp, options) => {
+  const r = options.loose ? re$2[t$1.TILDELOOSE] : re$2[t$1.TILDE];
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug$d('tilde', comp, _, M, m, p, pr);
+    let ret;
 
-  return new IgnoreRule(
-    origin,
-    pattern,
-    negative,
-    regex
-  )
-};
+    if (isX(M)) {
+      ret = '';
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+    } else if (isX(p)) {
+      // ~1.2 == >=1.2.0 <1.3.0-0
+      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+    } else if (pr) {
+      debug$d('replaceTilde pr', pr);
+      ret = `>=${M}.${m}.${p}-${pr
+      } <${M}.${+m + 1}.0-0`;
+    } else {
+      // ~1.2.3 == >=1.2.3 <1.3.0-0
+      ret = `>=${M}.${m}.${p
+      } <${M}.${+m + 1}.0-0`;
+    }
 
-const throwError$1 = (message, Ctor) => {
-  throw new Ctor(message)
+    debug$d('tilde return', ret);
+    return ret
+  })
 };
 
-const checkPath = (path, originalPath, doThrow) => {
-  if (!isString(path)) {
-    return doThrow(
-      `path must be a string, but got \`${originalPath}\``,
-      TypeError
-    )
-  }
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+// ^1.2.3 --> >=1.2.3 <2.0.0-0
+// ^1.2.0 --> >=1.2.0 <2.0.0-0
+const replaceCarets = (comp, options) =>
+  comp.trim().split(/\s+/).map((comp) => {
+    return replaceCaret(comp, options)
+  }).join(' ');
+
+const replaceCaret = (comp, options) => {
+  debug$d('caret', comp, options);
+  const r = options.loose ? re$2[t$1.CARETLOOSE] : re$2[t$1.CARET];
+  const z = options.includePrerelease ? '-0' : '';
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug$d('caret', comp, _, M, m, p, pr);
+    let ret;
 
-  // We don't know if we should ignore '', so throw
-  if (!path) {
-    return doThrow(`path must not be empty`, TypeError)
-  }
+    if (isX(M)) {
+      ret = '';
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+    } else if (isX(p)) {
+      if (M === '0') {
+        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+      } else {
+        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+      }
+    } else if (pr) {
+      debug$d('replaceCaret pr', pr);
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${m}.${+p + 1}-0`;
+        } else {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${+m + 1}.0-0`;
+        }
+      } else {
+        ret = `>=${M}.${m}.${p}-${pr
+        } <${+M + 1}.0.0-0`;
+      }
+    } else {
+      debug$d('no pr');
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${m}.${+p + 1}-0`;
+        } else {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${+m + 1}.0-0`;
+        }
+      } else {
+        ret = `>=${M}.${m}.${p
+        } <${+M + 1}.0.0-0`;
+      }
+    }
 
-  // Check if it is a relative path
-  if (checkPath.isNotRelative(path)) {
-    const r = '`path.relative()`d';
-    return doThrow(
-      `path should be a ${r} string, but got "${originalPath}"`,
-      RangeError
-    )
-  }
+    debug$d('caret return', ret);
+    return ret
+  })
+};
 
-  return true
+const replaceXRanges = (comp, options) => {
+  debug$d('replaceXRanges', comp, options);
+  return comp.split(/\s+/).map((comp) => {
+    return replaceXRange(comp, options)
+  }).join(' ')
 };
 
-const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path);
+const replaceXRange = (comp, options) => {
+  comp = comp.trim();
+  const r = options.loose ? re$2[t$1.XRANGELOOSE] : re$2[t$1.XRANGE];
+  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+    debug$d('xRange', comp, ret, gtlt, M, m, p, pr);
+    const xM = isX(M);
+    const xm = xM || isX(m);
+    const xp = xm || isX(p);
+    const anyX = xp;
 
-checkPath.isNotRelative = isNotRelative;
-checkPath.convert = p => p;
+    if (gtlt === '=' && anyX) {
+      gtlt = '';
+    }
 
-class Ignore {
-  constructor ({
-    ignorecase = true
-  } = {}) {
-    this._rules = [];
-    this._ignorecase = ignorecase;
-    define(this, KEY_IGNORE, true);
-    this._initCache();
-  }
+    // if we're including prereleases in the match, then we need
+    // to fix this to -0, the lowest possible prerelease value
+    pr = options.includePrerelease ? '-0' : '';
 
-  _initCache () {
-    this._ignoreCache = Object.create(null);
-    this._testCache = Object.create(null);
-  }
+    if (xM) {
+      if (gtlt === '>' || gtlt === '<') {
+        // nothing is allowed
+        ret = '<0.0.0-0';
+      } else {
+        // nothing is forbidden
+        ret = '*';
+      }
+    } else if (gtlt && anyX) {
+      // we know patch is an x, because we have any x at all.
+      // replace X with 0
+      if (xm) {
+        m = 0;
+      }
+      p = 0;
+
+      if (gtlt === '>') {
+        // >1 => >=2.0.0
+        // >1.2 => >=1.3.0
+        gtlt = '>=';
+        if (xm) {
+          M = +M + 1;
+          m = 0;
+          p = 0;
+        } else {
+          m = +m + 1;
+          p = 0;
+        }
+      } else if (gtlt === '<=') {
+        // <=0.7.x is actually <0.8.0, since any 0.7.x should
+        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+        gtlt = '<';
+        if (xm) {
+          M = +M + 1;
+        } else {
+          m = +m + 1;
+        }
+      }
 
-  _addPattern (pattern) {
-    // #32
-    if (pattern && pattern[KEY_IGNORE]) {
-      this._rules = this._rules.concat(pattern._rules);
-      this._added = true;
-      return
-    }
+      if (gtlt === '<')
+        pr = '-0';
 
-    if (checkPattern(pattern)) {
-      const rule = createRule(pattern, this._ignorecase);
-      this._added = true;
-      this._rules.push(rule);
+      ret = `${gtlt + M}.${m}.${p}${pr}`;
+    } else if (xm) {
+      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+    } else if (xp) {
+      ret = `>=${M}.${m}.0${pr
+      } <${M}.${+m + 1}.0-0`;
     }
+
+    debug$d('xRange return', ret);
+
+    return ret
+  })
+};
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+const replaceStars = (comp, options) => {
+  debug$d('replaceStars', comp, options);
+  // Looseness is ignored here.  star is always as loose as it gets!
+  return comp.trim().replace(re$2[t$1.STAR], '')
+};
+
+const replaceGTE0 = (comp, options) => {
+  debug$d('replaceGTE0', comp, options);
+  return comp.trim()
+    .replace(re$2[options.includePrerelease ? t$1.GTE0PRE : t$1.GTE0], '')
+};
+
+// This function is passed to string.replace(re[t.HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+const hyphenReplace = incPr => ($0,
+  from, fM, fm, fp, fpr, fb,
+  to, tM, tm, tp, tpr, tb) => {
+  if (isX(fM)) {
+    from = '';
+  } else if (isX(fm)) {
+    from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
+  } else if (isX(fp)) {
+    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
+  } else if (fpr) {
+    from = `>=${from}`;
+  } else {
+    from = `>=${from}${incPr ? '-0' : ''}`;
+  }
+
+  if (isX(tM)) {
+    to = '';
+  } else if (isX(tm)) {
+    to = `<${+tM + 1}.0.0-0`;
+  } else if (isX(tp)) {
+    to = `<${tM}.${+tm + 1}.0-0`;
+  } else if (tpr) {
+    to = `<=${tM}.${tm}.${tp}-${tpr}`;
+  } else if (incPr) {
+    to = `<${tM}.${tm}.${+tp + 1}-0`;
+  } else {
+    to = `<=${to}`;
   }
 
-  // @param {Array<string> | string | Ignore} pattern
-  add (pattern) {
-    this._added = false;
+  return (`${from} ${to}`).trim()
+};
 
-    makeArray(
-      isString(pattern)
-        ? splitPattern(pattern)
-        : pattern
-    ).forEach(this._addPattern, this);
+const testSet = (set, version, options) => {
+  for (let i = 0; i < set.length; i++) {
+    if (!set[i].test(version)) {
+      return false
+    }
+  }
 
-    // Some rules have just added to the ignore,
-    // making the behavior changed.
-    if (this._added) {
-      this._initCache();
+  if (version.prerelease.length && !options.includePrerelease) {
+    // Find the set of versions that are allowed to have prereleases
+    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+    // That should allow `1.2.3-pr.2` to pass.
+    // However, `1.2.4-alpha.notready` should NOT be allowed,
+    // even though it's within the range set by the comparators.
+    for (let i = 0; i < set.length; i++) {
+      debug$d(set[i].semver);
+      if (set[i].semver === Comparator$2.ANY) {
+        continue
+      }
+
+      if (set[i].semver.prerelease.length > 0) {
+        const allowed = set[i].semver;
+        if (allowed.major === version.major &&
+            allowed.minor === version.minor &&
+            allowed.patch === version.patch) {
+          return true
+        }
+      }
     }
 
-    return this
+    // Version has a -pre, but it's not one of the ones we like.
+    return false
   }
 
-  // legacy
-  addPattern (pattern) {
-    return this.add(pattern)
+  return true
+};
+
+const ANY$2 = Symbol('SemVer ANY');
+// hoisted class for cyclic dependency
+class Comparator$1 {
+  static get ANY () {
+    return ANY$2
   }
+  constructor (comp, options) {
+    options = parseOptions(options);
 
-  //          |           ignored : unignored
-  // negative |   0:0   |   0:1   |   1:0   |   1:1
-  // -------- | ------- | ------- | ------- | --------
-  //     0    |  TEST   |  TEST   |  SKIP   |    X
-  //     1    |  TESTIF |  SKIP   |  TEST   |    X
+    if (comp instanceof Comparator$1) {
+      if (comp.loose === !!options.loose) {
+        return comp
+      } else {
+        comp = comp.value;
+      }
+    }
 
-  // - SKIP: always skip
-  // - TEST: always test
-  // - TESTIF: only test if checkUnignored
-  // - X: that never happen
+    debug$c('comparator', comp, options);
+    this.options = options;
+    this.loose = !!options.loose;
+    this.parse(comp);
 
-  // @param {boolean} whether should check if the path is unignored,
-  //   setting `checkUnignored` to `false` could reduce additional
-  //   path matching.
+    if (this.semver === ANY$2) {
+      this.value = '';
+    } else {
+      this.value = this.operator + this.semver.version;
+    }
 
-  // @returns {TestResult} true if a file is ignored
-  _testOne (path, checkUnignored) {
-    let ignored = false;
-    let unignored = false;
+    debug$c('comp', this);
+  }
 
-    this._rules.forEach(rule => {
-      const {negative} = rule;
-      if (
-        unignored === negative && ignored !== unignored
-        || negative && !ignored && !unignored && !checkUnignored
-      ) {
-        return
-      }
+  parse (comp) {
+    const r = this.options.loose ? re$1[t.COMPARATORLOOSE] : re$1[t.COMPARATOR];
+    const m = comp.match(r);
 
-      const matched = rule.regex.test(path);
+    if (!m) {
+      throw new TypeError(`Invalid comparator: ${comp}`)
+    }
 
-      if (matched) {
-        ignored = !negative;
-        unignored = negative;
-      }
-    });
+    this.operator = m[1] !== undefined ? m[1] : '';
+    if (this.operator === '=') {
+      this.operator = '';
+    }
 
-    return {
-      ignored,
-      unignored
+    // if it literally is just '>' or '' then allow anything.
+    if (!m[2]) {
+      this.semver = ANY$2;
+    } else {
+      this.semver = new SemVer$4(m[2], this.options.loose);
     }
   }
 
-  // @returns {TestResult}
-  _test (originalPath, cache, checkUnignored, slices) {
-    const path = originalPath
-      // Supports nullable path
-      && checkPath.convert(originalPath);
-
-    checkPath(path, originalPath, throwError$1);
-
-    return this._t(path, cache, checkUnignored, slices)
+  toString () {
+    return this.value
   }
 
-  _t (path, cache, checkUnignored, slices) {
-    if (path in cache) {
-      return cache[path]
+  test (version) {
+    debug$c('Comparator.test', version, this.options.loose);
+
+    if (this.semver === ANY$2 || version === ANY$2) {
+      return true
     }
 
-    if (!slices) {
-      // path/to/a.js
-      // ['path', 'to', 'a.js']
-      slices = path.split(SLASH);
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer$4(version, this.options);
+      } catch (er) {
+        return false
+      }
     }
 
-    slices.pop();
+    return cmp(version, this.operator, this.semver, this.options)
+  }
 
-    // If the path has no parent directory, just test it
-    if (!slices.length) {
-      return cache[path] = this._testOne(path, checkUnignored)
+  intersects (comp, options) {
+    if (!(comp instanceof Comparator$1)) {
+      throw new TypeError('a Comparator is required')
     }
 
-    const parent = this._t(
-      slices.join(SLASH) + SLASH,
-      cache,
-      checkUnignored,
-      slices
-    );
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false
+      };
+    }
 
-    // If the path contains a parent directory, check the parent first
-    return cache[path] = parent.ignored
-      // > It is not possible to re-include a file if a parent directory of
-      // >   that file is excluded.
-      ? parent
-      : this._testOne(path, checkUnignored)
-  }
+    if (this.operator === '') {
+      if (this.value === '') {
+        return true
+      }
+      return new Range$9(comp.value, options).test(this.value)
+    } else if (comp.operator === '') {
+      if (comp.value === '') {
+        return true
+      }
+      return new Range$9(this.value, options).test(comp.semver)
+    }
+
+    const sameDirectionIncreasing =
+      (this.operator === '>=' || this.operator === '>') &&
+      (comp.operator === '>=' || comp.operator === '>');
+    const sameDirectionDecreasing =
+      (this.operator === '<=' || this.operator === '<') &&
+      (comp.operator === '<=' || comp.operator === '<');
+    const sameSemVer = this.semver.version === comp.semver.version;
+    const differentDirectionsInclusive =
+      (this.operator === '>=' || this.operator === '<=') &&
+      (comp.operator === '>=' || comp.operator === '<=');
+    const oppositeDirectionsLessThan =
+      cmp(this.semver, '<', comp.semver, options) &&
+      (this.operator === '>=' || this.operator === '>') &&
+        (comp.operator === '<=' || comp.operator === '<');
+    const oppositeDirectionsGreaterThan =
+      cmp(this.semver, '>', comp.semver, options) &&
+      (this.operator === '<=' || this.operator === '<') &&
+        (comp.operator === '>=' || comp.operator === '>');
 
-  ignores (path) {
-    return this._test(path, this._ignoreCache, false).ignored
+    return (
+      sameDirectionIncreasing ||
+      sameDirectionDecreasing ||
+      (sameSemVer && differentDirectionsInclusive) ||
+      oppositeDirectionsLessThan ||
+      oppositeDirectionsGreaterThan
+    )
   }
+}
 
-  createFilter () {
-    return path => !this.ignores(path)
-  }
+var comparator$1 = Comparator$1;
 
-  filter (paths) {
-    return makeArray(paths).filter(this.createFilter())
-  }
+const parseOptions = parseOptions_1;
+const {re: re$1, t} = re$6.exports;
+const cmp = cmp_1;
+const debug$c = debug_1;
+const SemVer$4 = semver$2;
+const Range$9 = range$1;
 
-  // @returns {TestResult}
-  test (path) {
-    return this._test(path, this._testCache, true)
+const Range$8 = range$1;
+const satisfies$3 = (version, range, options) => {
+  try {
+    range = new Range$8(range, options);
+  } catch (er) {
+    return false
   }
-}
+  return range.test(version)
+};
+var satisfies_1 = satisfies$3;
 
-const factory = options => new Ignore(options);
+const Range$7 = range$1;
 
-const returnFalse = () => false;
+// Mostly just for testing and legacy API reasons
+const toComparators = (range, options) =>
+  new Range$7(range, options).set
+    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '));
 
-const isPathValid = path =>
-  checkPath(path && checkPath.convert(path), path, returnFalse);
+var toComparators_1 = toComparators;
 
-factory.isPathValid = isPathValid;
+const SemVer$3 = semver$2;
+const Range$6 = range$1;
 
-// Fixes typescript
-factory.default = factory;
+const maxSatisfying = (versions, range, options) => {
+  let max = null;
+  let maxSV = null;
+  let rangeObj = null;
+  try {
+    rangeObj = new Range$6(range, options);
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!max || maxSV.compare(v) === -1) {
+        // compare(max, v, true)
+        max = v;
+        maxSV = new SemVer$3(max, options);
+      }
+    }
+  });
+  return max
+};
+var maxSatisfying_1 = maxSatisfying;
 
-var ignore = factory;
+const SemVer$2 = semver$2;
+const Range$5 = range$1;
+const minSatisfying = (versions, range, options) => {
+  let min = null;
+  let minSV = null;
+  let rangeObj = null;
+  try {
+    rangeObj = new Range$5(range, options);
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!min || minSV.compare(v) === 1) {
+        // compare(min, v, true)
+        min = v;
+        minSV = new SemVer$2(min, options);
+      }
+    }
+  });
+  return min
+};
+var minSatisfying_1 = minSatisfying;
 
-// Windows
-// --------------------------------------------------------------
-/* istanbul ignore if  */
-if (
-  // Detect `process` so that it can run in browsers.
-  typeof process !== 'undefined'
-  && (
-    process.env && process.env.IGNORE_TEST_WIN32
-    || process.platform === 'win32'
-  )
-) {
-  /* eslint no-control-regex: "off" */
-  const makePosix = str => /^\\\\\?\\/.test(str)
-  || /["<>|\u0000-\u001F]+/u.test(str)
-    ? str
-    : str.replace(/\\/g, '/');
+const SemVer$1 = semver$2;
+const Range$4 = range$1;
+const gt$1 = gt_1;
 
-  checkPath.convert = makePosix;
+const minVersion = (range, loose) => {
+  range = new Range$4(range, loose);
 
-  // 'C:\\foo'     <- 'C:\\foo' has been converted to 'C:/'
-  // 'd:\\foo'
-  const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-  checkPath.isNotRelative = path =>
-    REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)
-    || isNotRelative(path);
-}
+  let minver = new SemVer$1('0.0.0');
+  if (range.test(minver)) {
+    return minver
+  }
 
-var ignore$1 = Ignore$1;
+  minver = new SemVer$1('0.0.0-0');
+  if (range.test(minver)) {
+    return minver
+  }
 
-Ignore$1.prototype.check = check;
+  minver = null;
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i];
 
-var sep = path$1.sep;
-var dirname$1 = path$1.dirname;
-var relative$1 = path$1.relative;
-var resolve$2 = path$1.resolve;
+    let setMin = null;
+    comparators.forEach((comparator) => {
+      // Clone to avoid manipulating the comparator's semver object.
+      const compver = new SemVer$1(comparator.semver.version);
+      switch (comparator.operator) {
+        case '>':
+          if (compver.prerelease.length === 0) {
+            compver.patch++;
+          } else {
+            compver.prerelease.push(0);
+          }
+          compver.raw = compver.format();
+          /* fallthrough */
+        case '':
+        case '>=':
+          if (!setMin || gt$1(compver, setMin)) {
+            setMin = compver;
+          }
+          break
+        case '<':
+        case '<=':
+          /* Ignore maximum versions */
+          break
+        /* istanbul ignore next */
+        default:
+          throw new Error(`Unexpected operation: ${comparator.operator}`)
+      }
+    });
+    if (setMin && (!minver || gt$1(minver, setMin)))
+      minver = setMin;
+  }
 
-function Ignore$1(options) {
-  this.cwd = options.cwd;
-  this.ignorePathResolveFrom = options.ignorePathResolveFrom;
+  if (minver && range.test(minver)) {
+    return minver
+  }
 
-  this.findUp = new findUp$1({
-    filePath: options.ignorePath,
-    cwd: options.cwd,
-    detect: options.detectIgnore,
-    names: options.ignoreName ? [options.ignoreName] : [],
-    create: create$1
-  });
-}
+  return null
+};
+var minVersion_1 = minVersion;
 
-function check(filePath, callback) {
-  var self = this;
+const Range$3 = range$1;
+const validRange = (range, options) => {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range$3(range, options).range || '*'
+  } catch (er) {
+    return null
+  }
+};
+var valid = validRange;
+
+const SemVer = semver$2;
+const Comparator = comparator$1;
+const {ANY: ANY$1} = Comparator;
+const Range$2 = range$1;
+const satisfies$2 = satisfies_1;
+const gt = gt_1;
+const lt = lt_1;
+const lte$1 = lte_1;
+const gte$1 = gte_1;
+
+const outside$2 = (version, range, hilo, options) => {
+  version = new SemVer(version, options);
+  range = new Range$2(range, options);
+
+  let gtfn, ltefn, ltfn, comp, ecomp;
+  switch (hilo) {
+    case '>':
+      gtfn = gt;
+      ltefn = lte$1;
+      ltfn = lt;
+      comp = '>';
+      ecomp = '>=';
+      break
+    case '<':
+      gtfn = lt;
+      ltefn = gte$1;
+      ltfn = gt;
+      comp = '<';
+      ecomp = '<=';
+      break
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"')
+  }
 
-  self.findUp.load(filePath, done);
+  // If it satisfies the range it is not outside
+  if (satisfies$2(version, range, options)) {
+    return false
+  }
 
-  function done(error, ignore) {
-    var normal;
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
 
-    if (error) {
-      callback(error);
-    } else if (ignore) {
-      normal = relative$1(
-        resolve$2(
-          self.cwd,
-          self.ignorePathResolveFrom === 'cwd' ? '.' : ignore.filePath
-        ),
-        resolve$2(self.cwd, filePath)
-      );
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i];
 
-      if (
-        normal === '' ||
-        normal === '..' ||
-        normal.charAt(0) === sep ||
-        normal.slice(0, 3) === '..' + sep
-      ) {
-        callback(null, false);
-      } else {
-        callback(null, ignore.ignores(normal));
+    let high = null;
+    let low = null;
+
+    comparators.forEach((comparator) => {
+      if (comparator.semver === ANY$1) {
+        comparator = new Comparator('>=0.0.0');
       }
-    } else {
-      callback(null, false);
+      high = high || comparator;
+      low = low || comparator;
+      if (gtfn(comparator.semver, high.semver, options)) {
+        high = comparator;
+      } else if (ltfn(comparator.semver, low.semver, options)) {
+        low = comparator;
+      }
+    });
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) &&
+        ltefn(version, low.semver)) {
+      return false
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false
     }
   }
-}
+  return true
+};
 
-function create$1(buf, filePath) {
-  var ignore$1 = ignore().add(String(buf));
-  ignore$1.filePath = dirname$1(filePath);
-  return ignore$1
-}
+var outside_1 = outside$2;
+
+// Determine if version is greater than all the versions possible in the range.
+const outside$1 = outside_1;
+const gtr = (version, range, options) => outside$1(version, range, '>', options);
+var gtr_1 = gtr;
+
+const outside = outside_1;
+// Determine if version is less than all the versions possible in the range
+const ltr = (version, range, options) => outside(version, range, '<', options);
+var ltr_1 = ltr;
+
+const Range$1 = range$1;
+const intersects = (r1, r2, options) => {
+  r1 = new Range$1(r1, options);
+  r2 = new Range$1(r2, options);
+  return r1.intersects(r2)
+};
+var intersects_1 = intersects;
+
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies$1 = satisfies_1;
+const compare$2 = compare_1;
+var simplify = (versions, range, options) => {
+  const set = [];
+  let min = null;
+  let prev = null;
+  const v = versions.sort((a, b) => compare$2(a, b, options));
+  for (const version of v) {
+    const included = satisfies$1(version, range, options);
+    if (included) {
+      prev = version;
+      if (!min)
+        min = version;
+    } else {
+      if (prev) {
+        set.push([min, prev]);
+      }
+      prev = null;
+      min = null;
+    }
+  }
+  if (min)
+    set.push([min, null]);
+
+  const ranges = [];
+  for (const [min, max] of set) {
+    if (min === max)
+      ranges.push(min);
+    else if (!max && min === v[0])
+      ranges.push('*');
+    else if (!max)
+      ranges.push(`>=${min}`);
+    else if (min === v[0])
+      ranges.push(`<=${max}`);
+    else
+      ranges.push(`${min} - ${max}`);
+  }
+  const simplified = ranges.join(' || ');
+  const original = typeof range.raw === 'string' ? range.raw : String(range);
+  return simplified.length < original.length ? simplified : range
+};
 
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
+const Range = range$1;
+const { ANY } = comparator$1;
+const satisfies = satisfies_1;
+const compare$1 = compare_1;
+
+// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
+// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...`
 //
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
+// - If c is only the ANY comparator
+//   - If C is only the ANY comparator, return true
+//   - Else return false
+// - Let EQ be the set of = comparators in c
+// - If EQ is more than one, return true (null set)
+// - Let GT be the highest > or >= comparator in c
+// - Let LT be the lowest < or <= comparator in c
+// - If GT and LT, and GT.semver > LT.semver, return true (null set)
+// - If EQ
+//   - If GT, and EQ does not satisfy GT, return true (null set)
+//   - If LT, and EQ does not satisfy LT, return true (null set)
+//   - If EQ satisfies every C, return true
+//   - Else return false
+// - If GT
+//   - If GT.semver is lower than any > or >= comp in C, return false
+//   - If GT is >=, and GT.semver does not satisfy every C, return false
+// - If LT
+//   - If LT.semver is greater than any < or <= comp in C, return false
+//   - If LT is <=, and LT.semver does not satisfy every C, return false
+// - If any C is a = range, and GT or LT are set, return false
+// - Else return true
+
+const subset = (sub, dom, options) => {
+  if (sub === dom)
+    return true
 
+  sub = new Range(sub, options);
+  dom = new Range(dom, options);
+  let sawNonNull = false;
+
+  OUTER: for (const simpleSub of sub.set) {
+    for (const simpleDom of dom.set) {
+      const isSub = simpleSubset(simpleSub, simpleDom, options);
+      sawNonNull = sawNonNull || isSub !== null;
+      if (isSub)
+        continue OUTER
+    }
+    // the null set is a subset of everything, but null simple ranges in
+    // a complex range should be ignored.  so if we saw a non-null range,
+    // then we know this isn't a subset, but if EVERY simple range was null,
+    // then it is a subset.
+    if (sawNonNull)
+      return false
+  }
+  return true
+};
 
-var isWindows = process.platform === 'win32';
+const simpleSubset = (sub, dom, options) => {
+  if (sub === dom)
+    return true
 
+  if (sub.length === 1 && sub[0].semver === ANY)
+    return dom.length === 1 && dom[0].semver === ANY
 
-// JavaScript implementation of realpath, ported from node pre-v6
+  const eqSet = new Set();
+  let gt, lt;
+  for (const c of sub) {
+    if (c.operator === '>' || c.operator === '>=')
+      gt = higherGT(gt, c, options);
+    else if (c.operator === '<' || c.operator === '<=')
+      lt = lowerLT(lt, c, options);
+    else
+      eqSet.add(c.semver);
+  }
 
-var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+  if (eqSet.size > 1)
+    return null
 
-function rethrow() {
-  // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
-  // is fairly slow to generate.
-  var callback;
-  if (DEBUG) {
-    var backtrace = new Error;
-    callback = debugCallback;
-  } else
-    callback = missingCallback;
+  let gtltComp;
+  if (gt && lt) {
+    gtltComp = compare$1(gt.semver, lt.semver, options);
+    if (gtltComp > 0)
+      return null
+    else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<='))
+      return null
+  }
 
-  return callback;
+  // will iterate one or zero times
+  for (const eq of eqSet) {
+    if (gt && !satisfies(eq, String(gt), options))
+      return null
 
-  function debugCallback(err) {
-    if (err) {
-      backtrace.message = err.message;
-      err = backtrace;
-      missingCallback(err);
+    if (lt && !satisfies(eq, String(lt), options))
+      return null
+
+    for (const c of dom) {
+      if (!satisfies(eq, String(c), options))
+        return false
     }
+
+    return true
   }
 
-  function missingCallback(err) {
-    if (err) {
-      if (process.throwDeprecation)
-        throw err;  // Forgot a callback but don't know where? Use NODE_DEBUG=fs
-      else if (!process.noDeprecation) {
-        var msg = 'fs: missing callback ' + (err.stack || err.message);
-        if (process.traceDeprecation)
-          console.trace(msg);
-        else
-          console.error(msg);
-      }
+  let higher, lower;
+  let hasDomLT, hasDomGT;
+  for (const c of dom) {
+    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=';
+    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=';
+    if (gt) {
+      if (c.operator === '>' || c.operator === '>=') {
+        higher = higherGT(gt, c, options);
+        if (higher === c && higher !== gt)
+          return false
+      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options))
+        return false
+    }
+    if (lt) {
+      if (c.operator === '<' || c.operator === '<=') {
+        lower = lowerLT(lt, c, options);
+        if (lower === c && lower !== lt)
+          return false
+      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options))
+        return false
     }
+    if (!c.operator && (lt || gt) && gtltComp !== 0)
+      return false
   }
-}
 
-function maybeCallback(cb) {
-  return typeof cb === 'function' ? cb : rethrow();
-}
+  // if there was a < or >, and nothing in the dom, then must be false
+  // UNLESS it was limited by another range in the other direction.
+  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
+  if (gt && hasDomLT && !lt && gtltComp !== 0)
+    return false
 
-var normalize = path$1.normalize;
+  if (lt && hasDomGT && !gt && gtltComp !== 0)
+    return false
 
-// Regexp that finds the next partion of a (partial) path
-// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
-if (isWindows) {
-  var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
-} else {
-  var nextPartRe = /(.*?)(?:[\/]+|$)/g;
-}
+  return true
+};
 
-// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
-if (isWindows) {
-  var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
-} else {
-  var splitRootRe = /^[\/]*/;
-}
+// >=1.2.3 is lower than >1.2.3
+const higherGT = (a, b, options) => {
+  if (!a)
+    return b
+  const comp = compare$1(a.semver, b.semver, options);
+  return comp > 0 ? a
+    : comp < 0 ? b
+    : b.operator === '>' && a.operator === '>=' ? b
+    : a
+};
+
+// <=1.2.3 is higher than <1.2.3
+const lowerLT = (a, b, options) => {
+  if (!a)
+    return b
+  const comp = compare$1(a.semver, b.semver, options);
+  return comp < 0 ? a
+    : comp > 0 ? b
+    : b.operator === '<' && a.operator === '<=' ? b
+    : a
+};
+
+var subset_1 = subset;
+
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = re$6.exports;
+var semver$1 = {
+  re: internalRe.re,
+  src: internalRe.src,
+  tokens: internalRe.t,
+  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+  SemVer: semver$2,
+  compareIdentifiers: identifiers.compareIdentifiers,
+  rcompareIdentifiers: identifiers.rcompareIdentifiers,
+  parse: parse_1,
+  valid: valid_1,
+  clean: clean_1,
+  inc: inc_1,
+  diff: diff_1,
+  major: major_1,
+  minor: minor_1,
+  patch: patch_1,
+  prerelease: prerelease_1,
+  compare: compare_1,
+  rcompare: rcompare_1,
+  compareLoose: compareLoose_1,
+  compareBuild: compareBuild_1,
+  sort: sort_1,
+  rsort: rsort_1,
+  gt: gt_1,
+  lt: lt_1,
+  eq: eq_1,
+  neq: neq_1,
+  gte: gte_1,
+  lte: lte_1,
+  cmp: cmp_1,
+  coerce: coerce_1,
+  Comparator: comparator$1,
+  Range: range$1,
+  satisfies: satisfies_1,
+  toComparators: toComparators_1,
+  maxSatisfying: maxSatisfying_1,
+  minSatisfying: minSatisfying_1,
+  minVersion: minVersion_1,
+  validRange: valid,
+  outside: outside_1,
+  gtr: gtr_1,
+  ltr: ltr_1,
+  intersects: intersects_1,
+  simplifyRange: simplify,
+  subset: subset_1,
+};
+
+var semver = semver$1;
+
+var builtins = function ({
+  version = process.version,
+  experimental = false
+} = {}) {
+  var coreModules = [
+    'assert',
+    'buffer',
+    'child_process',
+    'cluster',
+    'console',
+    'constants',
+    'crypto',
+    'dgram',
+    'dns',
+    'domain',
+    'events',
+    'fs',
+    'http',
+    'https',
+    'module',
+    'net',
+    'os',
+    'path',
+    'punycode',
+    'querystring',
+    'readline',
+    'repl',
+    'stream',
+    'string_decoder',
+    'sys',
+    'timers',
+    'tls',
+    'tty',
+    'url',
+    'util',
+    'vm',
+    'zlib'
+  ];
 
-var realpathSync = function realpathSync(p, cache) {
-  // make p is absolute
-  p = path$1.resolve(p);
+  if (semver.lt(version, '6.0.0')) coreModules.push('freelist');
+  if (semver.gte(version, '1.0.0')) coreModules.push('v8');
+  if (semver.gte(version, '1.1.0')) coreModules.push('process');
+  if (semver.gte(version, '8.0.0')) coreModules.push('inspector');
+  if (semver.gte(version, '8.1.0')) coreModules.push('async_hooks');
+  if (semver.gte(version, '8.4.0')) coreModules.push('http2');
+  if (semver.gte(version, '8.5.0')) coreModules.push('perf_hooks');
+  if (semver.gte(version, '10.0.0')) coreModules.push('trace_events');
 
-  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
-    return cache[p];
+  if (
+    semver.gte(version, '10.5.0') &&
+    (experimental || semver.gte(version, '12.0.0'))
+  ) {
+    coreModules.push('worker_threads');
   }
+  if (semver.gte(version, '12.16.0') && experimental) {
+    coreModules.push('wasi');
+  }
+  
+  return coreModules
+};
 
-  var original = p,
-      seenLinks = {},
-      knownHard = {};
-
-  // current character position in p
-  var pos;
-  // the partial path so far, including a trailing slash if any
-  var current;
-  // the partial path without a trailing slash (except when pointing at a root)
-  var base;
-  // the partial path scanned in the previous round, with slash
-  var previous;
+// Manually “tree shaken” from:
 
-  start();
+const reader = {read: read$3};
+var packageJsonReader = reader;
 
-  function start() {
-    // Skip over roots
-    var m = splitRootRe.exec(p);
-    pos = m[0].length;
-    current = m[0];
-    base = m[0];
-    previous = '';
+/**
+ * @param {string} jsonPath
+ * @returns {{string: string}}
+ */
+function read$3(jsonPath) {
+  return find$1(path$b.dirname(jsonPath))
+}
 
-    // On windows, check that the root exists. On unix there is no need.
-    if (isWindows && !knownHard[base]) {
-      fs$1.lstatSync(base);
-      knownHard[base] = true;
+/**
+ * @param {string} dir
+ * @returns {{string: string}}
+ */
+function find$1(dir) {
+  try {
+    const string = require$$0$3.readFileSync(
+      path$b.toNamespacedPath(path$b.join(dir, 'package.json')),
+      'utf8'
+    );
+    return {string}
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      const parent = path$b.dirname(dir);
+      if (dir !== parent) return find$1(parent)
+      return {string: undefined}
+      // Throw all other errors.
+      /* c8 ignore next 4 */
     }
+
+    throw error
   }
+}
 
-  // walk down the path, swapping out linked pathparts for their real
-  // values
-  // NB: p.length changes.
-  while (pos < p.length) {
-    // find the next part
-    nextPartRe.lastIndex = pos;
-    var result = nextPartRe.exec(p);
-    previous = current;
-    current += result[0];
-    base = previous + result[1];
-    pos = nextPartRe.lastIndex;
+// Manually “tree shaken” from:
 
-    // continue if not a symlink
-    if (knownHard[base] || (cache && cache[base] === base)) {
-      continue;
-    }
+const isWindows$1 = process.platform === 'win32';
 
-    var resolvedLink;
-    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
-      // some known symbolic link.  no need to stat again.
-      resolvedLink = cache[base];
-    } else {
-      var stat = fs$1.lstatSync(base);
-      if (!stat.isSymbolicLink()) {
-        knownHard[base] = true;
-        if (cache) cache[base] = base;
-        continue;
-      }
+const own$e = {}.hasOwnProperty;
 
-      // read the link if it wasn't read before
-      // dev/ino always return 0 on windows, so skip the check.
-      var linkTarget = null;
-      if (!isWindows) {
-        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
-        if (seenLinks.hasOwnProperty(id)) {
-          linkTarget = seenLinks[id];
-        }
-      }
-      if (linkTarget === null) {
-        fs$1.statSync(base);
-        linkTarget = fs$1.readlinkSync(base);
-      }
-      resolvedLink = path$1.resolve(previous, linkTarget);
-      // track this, if given a cache.
-      if (cache) cache[base] = resolvedLink;
-      if (!isWindows) seenLinks[id] = linkTarget;
-    }
+const codes = {};
 
-    // resolve the link, then start over
-    p = path$1.resolve(resolvedLink, p.slice(pos));
-    start();
-  }
+/**
+ * @typedef {(...args: unknown[]) => string} MessageFunction
+ */
 
-  if (cache) cache[original] = p;
+/** @type {Map<string, MessageFunction|string>} */
+const messages = new Map();
+const nodeInternalPrefix = '__node_internal_';
+/** @type {number} */
+let userStackTraceLimit;
 
-  return p;
-};
+codes.ERR_INVALID_MODULE_SPECIFIER = createError(
+  'ERR_INVALID_MODULE_SPECIFIER',
+  /**
+   * @param {string} request
+   * @param {string} reason
+   * @param {string} [base]
+   */
+  (request, reason, base = undefined) => {
+    return `Invalid module "${request}" ${reason}${
+      base ? ` imported from ${base}` : ''
+    }`
+  },
+  TypeError
+);
 
+codes.ERR_INVALID_PACKAGE_CONFIG = createError(
+  'ERR_INVALID_PACKAGE_CONFIG',
+  /**
+   * @param {string} path
+   * @param {string} [base]
+   * @param {string} [message]
+   */
+  (path, base, message) => {
+    return `Invalid package config ${path}${
+      base ? ` while importing ${base}` : ''
+    }${message ? `. ${message}` : ''}`
+  },
+  Error
+);
 
-var realpath = function realpath(p, cache, cb) {
-  if (typeof cb !== 'function') {
-    cb = maybeCallback(cache);
-    cache = null;
-  }
+codes.ERR_INVALID_PACKAGE_TARGET = createError(
+  'ERR_INVALID_PACKAGE_TARGET',
+  /**
+   * @param {string} pkgPath
+   * @param {string} key
+   * @param {unknown} target
+   * @param {boolean} [isImport=false]
+   * @param {string} [base]
+   */
+  (pkgPath, key, target, isImport = false, base = undefined) => {
+    const relError =
+      typeof target === 'string' &&
+      !isImport &&
+      target.length > 0 &&
+      !target.startsWith('./');
+    if (key === '.') {
+      assert$2(isImport === false);
+      return (
+        `Invalid "exports" main target ${JSON.stringify(target)} defined ` +
+        `in the package config ${pkgPath}package.json${
+          base ? ` imported from ${base}` : ''
+        }${relError ? '; targets must start with "./"' : ''}`
+      )
+    }
 
-  // make p is absolute
-  p = path$1.resolve(p);
+    return `Invalid "${
+      isImport ? 'imports' : 'exports'
+    }" target ${JSON.stringify(
+      target
+    )} defined for '${key}' in the package config ${pkgPath}package.json${
+      base ? ` imported from ${base}` : ''
+    }${relError ? '; targets must start with "./"' : ''}`
+  },
+  Error
+);
 
-  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
-    return process.nextTick(cb.bind(null, null, cache[p]));
-  }
+codes.ERR_MODULE_NOT_FOUND = createError(
+  'ERR_MODULE_NOT_FOUND',
+  /**
+   * @param {string} path
+   * @param {string} base
+   * @param {string} [type]
+   */
+  (path, base, type = 'package') => {
+    return `Cannot find ${type} '${path}' imported from ${base}`
+  },
+  Error
+);
 
-  var original = p,
-      seenLinks = {},
-      knownHard = {};
+codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
+  'ERR_PACKAGE_IMPORT_NOT_DEFINED',
+  /**
+   * @param {string} specifier
+   * @param {string} packagePath
+   * @param {string} base
+   */
+  (specifier, packagePath, base) => {
+    return `Package import specifier "${specifier}" is not defined${
+      packagePath ? ` in package ${packagePath}package.json` : ''
+    } imported from ${base}`
+  },
+  TypeError
+);
 
-  // current character position in p
-  var pos;
-  // the partial path so far, including a trailing slash if any
-  var current;
-  // the partial path without a trailing slash (except when pointing at a root)
-  var base;
-  // the partial path scanned in the previous round, with slash
-  var previous;
+codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
+  'ERR_PACKAGE_PATH_NOT_EXPORTED',
+  /**
+   * @param {string} pkgPath
+   * @param {string} subpath
+   * @param {string} [base]
+   */
+  (pkgPath, subpath, base = undefined) => {
+    if (subpath === '.')
+      return `No "exports" main defined in ${pkgPath}package.json${
+        base ? ` imported from ${base}` : ''
+      }`
+    return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${
+      base ? ` imported from ${base}` : ''
+    }`
+  },
+  Error
+);
 
-  start();
+codes.ERR_UNSUPPORTED_DIR_IMPORT = createError(
+  'ERR_UNSUPPORTED_DIR_IMPORT',
+  "Directory import '%s' is not supported " +
+    'resolving ES modules imported from %s',
+  Error
+);
 
-  function start() {
-    // Skip over roots
-    var m = splitRootRe.exec(p);
-    pos = m[0].length;
-    current = m[0];
-    base = m[0];
-    previous = '';
+codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
+  'ERR_UNKNOWN_FILE_EXTENSION',
+  'Unknown file extension "%s" for %s',
+  TypeError
+);
 
-    // On windows, check that the root exists. On unix there is no need.
-    if (isWindows && !knownHard[base]) {
-      fs$1.lstat(base, function(err) {
-        if (err) return cb(err);
-        knownHard[base] = true;
-        LOOP();
-      });
-    } else {
-      process.nextTick(LOOP);
-    }
-  }
+codes.ERR_INVALID_ARG_VALUE = createError(
+  'ERR_INVALID_ARG_VALUE',
+  /**
+   * @param {string} name
+   * @param {unknown} value
+   * @param {string} [reason='is invalid']
+   */
+  (name, value, reason = 'is invalid') => {
+    let inspected = inspect$1(value);
 
-  // walk down the path, swapping out linked pathparts for their real
-  // values
-  function LOOP() {
-    // stop if scanned past end of path
-    if (pos >= p.length) {
-      if (cache) cache[original] = p;
-      return cb(null, p);
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
     }
 
-    // find the next part
-    nextPartRe.lastIndex = pos;
-    var result = nextPartRe.exec(p);
-    previous = current;
-    current += result[0];
-    base = previous + result[1];
-    pos = nextPartRe.lastIndex;
+    const type = name.includes('.') ? 'property' : 'argument';
 
-    // continue if not a symlink
-    if (knownHard[base] || (cache && cache[base] === base)) {
-      return process.nextTick(LOOP);
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`
+  },
+  TypeError
+  // Note: extra classes have been shaken out.
+  // , RangeError
+);
+
+codes.ERR_UNSUPPORTED_ESM_URL_SCHEME = createError(
+  'ERR_UNSUPPORTED_ESM_URL_SCHEME',
+  /**
+   * @param {URL} url
+   */
+  (url) => {
+    let message =
+      'Only file and data URLs are supported by the default ESM loader';
+
+    if (isWindows$1 && url.protocol.length === 2) {
+      message += '. On Windows, absolute paths must be valid file:// URLs';
     }
 
-    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
-      // known symbolic link.  no need to stat again.
-      return gotResolvedLink(cache[base]);
+    message += `. Received protocol '${url.protocol}'`;
+    return message
+  },
+  Error
+);
+
+/**
+ * Utility function for registering the error codes. Only used here. Exported
+ * *only* to allow for testing.
+ * @param {string} sym
+ * @param {MessageFunction|string} value
+ * @param {ErrorConstructor} def
+ * @returns {new (...args: unknown[]) => Error}
+ */
+function createError(sym, value, def) {
+  // Special case for SystemError that formats the error message differently
+  // The SystemErrors only have SystemError as their base classes.
+  messages.set(sym, value);
+
+  return makeNodeErrorWithCode(def, sym)
+}
+
+/**
+ * @param {ErrorConstructor} Base
+ * @param {string} key
+ * @returns {ErrorConstructor}
+ */
+function makeNodeErrorWithCode(Base, key) {
+  // @ts-expect-error It’s a Node error.
+  return NodeError
+  /**
+   * @param {unknown[]} args
+   */
+  function NodeError(...args) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+    const error = new Base();
+    // Reset the limit and setting the name property.
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+    const message = getMessage(key, args, error);
+    Object.defineProperty(error, 'message', {
+      value: message,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    Object.defineProperty(error, 'toString', {
+      /** @this {Error} */
+      value() {
+        return `${this.name} [${key}]: ${this.message}`
+      },
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    addCodeToName(error, Base.name, key);
+    // @ts-expect-error It’s a Node error.
+    error.code = key;
+    return error
+  }
+}
+
+const addCodeToName = hideStackFrames(
+  /**
+   * @param {Error} error
+   * @param {string} name
+   * @param {string} code
+   * @returns {void}
+   */
+  function (error, name, code) {
+    // Set the stack
+    error = captureLargerStackTrace(error);
+    // Add the error code to the name to include it in the stack trace.
+    error.name = `${name} [${code}]`;
+    // Access the stack to generate the error message including the error code
+    // from the name.
+    error.stack; // eslint-disable-line no-unused-expressions
+    // Reset the name to the actual name.
+    if (name === 'SystemError') {
+      Object.defineProperty(error, 'name', {
+        value: name,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    } else {
+      delete error.name;
     }
+  }
+);
 
-    return fs$1.lstat(base, gotStat);
+/**
+ * @returns {boolean}
+ */
+function isErrorStackTraceLimitWritable() {
+  const desc = Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit');
+  if (desc === undefined) {
+    return Object.isExtensible(Error)
   }
 
-  function gotStat(err, stat) {
-    if (err) return cb(err);
+  return own$e.call(desc, 'writable') ? desc.writable : desc.set !== undefined
+}
 
-    // if not a symlink, skip to the next path part
-    if (!stat.isSymbolicLink()) {
-      knownHard[base] = true;
-      if (cache) cache[base] = base;
-      return process.nextTick(LOOP);
-    }
+/**
+ * This function removes unnecessary frames from Node.js core errors.
+ * @template {(...args: unknown[]) => unknown} T
+ * @type {(fn: T) => T}
+ */
+function hideStackFrames(fn) {
+  // We rename the functions that will be hidden to cut off the stacktrace
+  // at the outermost one
+  const hidden = nodeInternalPrefix + fn.name;
+  Object.defineProperty(fn, 'name', {value: hidden});
+  return fn
+}
 
-    // stat & read the link if not read before
-    // call gotTarget as soon as the link target is known
-    // dev/ino always return 0 on windows, so skip the check.
-    if (!isWindows) {
-      var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
-      if (seenLinks.hasOwnProperty(id)) {
-        return gotTarget(null, seenLinks[id], base);
-      }
+const captureLargerStackTrace = hideStackFrames(
+  /**
+   * @param {Error} error
+   * @returns {Error}
+   */
+  function (error) {
+    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+    if (stackTraceLimitIsWritable) {
+      userStackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
     }
-    fs$1.stat(base, function(err) {
-      if (err) return cb(err);
 
-      fs$1.readlink(base, function(err, target) {
-        if (!isWindows) seenLinks[id] = target;
-        gotTarget(err, target);
-      });
-    });
-  }
+    Error.captureStackTrace(error);
 
-  function gotTarget(err, target, base) {
-    if (err) return cb(err);
+    // Reset the limit
+    if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
 
-    var resolvedLink = path$1.resolve(previous, target);
-    if (cache) cache[base] = resolvedLink;
-    gotResolvedLink(resolvedLink);
+    return error
   }
+);
 
-  function gotResolvedLink(resolvedLink) {
-    // resolve the link, then start over
-    p = path$1.resolve(resolvedLink, p.slice(pos));
-    start();
+/**
+ * @param {string} key
+ * @param {unknown[]} args
+ * @param {Error} self
+ * @returns {string}
+ */
+function getMessage(key, args, self) {
+  const message = messages.get(key);
+
+  if (typeof message === 'function') {
+    assert$2(
+      message.length <= args.length, // Default options do not count.
+      `Code: ${key}; The provided arguments length (${args.length}) does not ` +
+        `match the required ones (${message.length}).`
+    );
+    return Reflect.apply(message, self, args)
   }
-};
 
-var old = {
-	realpathSync: realpathSync,
-	realpath: realpath
-};
+  const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
+  assert$2(
+    expectedLength === args.length,
+    `Code: ${key}; The provided arguments length (${args.length}) does not ` +
+      `match the required ones (${expectedLength}).`
+  );
+  if (args.length === 0) return message
 
-var fs_realpath = realpath$1;
-realpath$1.realpath = realpath$1;
-realpath$1.sync = realpathSync$1;
-realpath$1.realpathSync = realpathSync$1;
-realpath$1.monkeypatch = monkeypatch;
-realpath$1.unmonkeypatch = unmonkeypatch;
+  args.unshift(message);
+  return Reflect.apply(format$2, null, args)
+}
 
+// Manually “tree shaken” from:
 
-var origRealpath = fs$1.realpath;
-var origRealpathSync = fs$1.realpathSync;
+const {ERR_UNKNOWN_FILE_EXTENSION} = codes;
 
-var version = process.version;
-var ok = /^v[0-5]\./.test(version);
+const extensionFormatMap = {
+  __proto__: null,
+  '.cjs': 'commonjs',
+  '.js': 'module',
+  '.mjs': 'module'
+};
 
+/**
+ * @param {string} url
+ * @returns {{format: string|null}}
+ */
+function defaultGetFormat(url) {
+  if (url.startsWith('node:')) {
+    return {format: 'builtin'}
+  }
 
-function newError (er) {
-  return er && er.syscall === 'realpath' && (
-    er.code === 'ELOOP' ||
-    er.code === 'ENOMEM' ||
-    er.code === 'ENAMETOOLONG'
-  )
-}
+  const parsed = new URL$1(url);
 
-function realpath$1 (p, cache, cb) {
-  if (ok) {
-    return origRealpath(p, cache, cb)
+  if (parsed.protocol === 'data:') {
+    const {1: mime} = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
+      parsed.pathname
+    ) || [null, null];
+    const format = mime === 'text/javascript' ? 'module' : null;
+    return {format}
   }
 
-  if (typeof cache === 'function') {
-    cb = cache;
-    cache = null;
-  }
-  origRealpath(p, cache, function (er, result) {
-    if (newError(er)) {
-      old.realpath(p, cache, cb);
+  if (parsed.protocol === 'file:') {
+    const ext = path$b.extname(parsed.pathname);
+    /** @type {string} */
+    let format;
+    if (ext === '.js') {
+      format = getPackageType(parsed.href) === 'module' ? 'module' : 'commonjs';
     } else {
-      cb(er, result);
+      format = extensionFormatMap[ext];
     }
-  });
-}
-
-function realpathSync$1 (p, cache) {
-  if (ok) {
-    return origRealpathSync(p, cache)
-  }
 
-  try {
-    return origRealpathSync(p, cache)
-  } catch (er) {
-    if (newError(er)) {
-      return old.realpathSync(p, cache)
-    } else {
-      throw er
+    if (!format) {
+      throw new ERR_UNKNOWN_FILE_EXTENSION(ext, fileURLToPath(url))
     }
+
+    return {format: format || null}
   }
+
+  return {format: null}
 }
 
-function monkeypatch () {
-  fs$1.realpath = realpath$1;
-  fs$1.realpathSync = realpathSync$1;
+// Manually “tree shaken” from:
+
+const listOfBuiltins = builtins();
+
+const {
+  ERR_INVALID_MODULE_SPECIFIER,
+  ERR_INVALID_PACKAGE_CONFIG,
+  ERR_INVALID_PACKAGE_TARGET,
+  ERR_MODULE_NOT_FOUND,
+  ERR_PACKAGE_IMPORT_NOT_DEFINED,
+  ERR_PACKAGE_PATH_NOT_EXPORTED,
+  ERR_UNSUPPORTED_DIR_IMPORT,
+  ERR_UNSUPPORTED_ESM_URL_SCHEME,
+  ERR_INVALID_ARG_VALUE
+} = codes;
+
+const own$d = {}.hasOwnProperty;
+
+const DEFAULT_CONDITIONS = Object.freeze(['node', 'import']);
+const DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
+
+const invalidSegmentRegEx = /(^|\\|\/)(\.\.?|node_modules)(\\|\/|$)/;
+const patternRegEx = /\*/g;
+const encodedSepRegEx = /%2f|%2c/i;
+/** @type {Set<string>} */
+const emittedPackageWarnings = new Set();
+/** @type {Map<string, PackageConfig>} */
+const packageJsonCache = new Map();
+
+/**
+ * @param {string} match
+ * @param {URL} pjsonUrl
+ * @param {boolean} isExports
+ * @param {URL} base
+ * @returns {void}
+ */
+function emitFolderMapDeprecation(match, pjsonUrl, isExports, base) {
+  const pjsonPath = fileURLToPath(pjsonUrl);
+
+  if (emittedPackageWarnings.has(pjsonPath + '|' + match)) return
+  emittedPackageWarnings.add(pjsonPath + '|' + match);
+  process.emitWarning(
+    `Use of deprecated folder mapping "${match}" in the ${
+      isExports ? '"exports"' : '"imports"'
+    } field module resolution of the package at ${pjsonPath}${
+      base ? ` imported from ${fileURLToPath(base)}` : ''
+    }.\n` +
+      `Update this package.json to use a subpath pattern like "${match}*".`,
+    'DeprecationWarning',
+    'DEP0148'
+  );
 }
 
-function unmonkeypatch () {
-  fs$1.realpath = origRealpath;
-  fs$1.realpathSync = origRealpathSync;
+/**
+ * @param {URL} url
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {unknown} [main]
+ * @returns {void}
+ */
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  const {format} = defaultGetFormat(url.href);
+  if (format !== 'module') return
+  const path = fileURLToPath(url.href);
+  const pkgPath = fileURLToPath(new URL$1('.', packageJsonUrl));
+  const basePath = fileURLToPath(base);
+  if (main)
+    process.emitWarning(
+      `Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, ` +
+        `excluding the full filename and extension to the resolved file at "${path.slice(
+          pkgPath.length
+        )}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is` +
+        'deprecated for ES modules.',
+      'DeprecationWarning',
+      'DEP0151'
+    );
+  else
+    process.emitWarning(
+      `No "main" or "exports" field defined in the package.json for ${pkgPath} resolving the main entry point "${path.slice(
+        pkgPath.length
+      )}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`,
+      'DeprecationWarning',
+      'DEP0151'
+    );
 }
 
-var concatMap = function (xs, fn) {
-    var res = [];
-    for (var i = 0; i < xs.length; i++) {
-        var x = fn(xs[i], i);
-        if (isArray(x)) res.push.apply(res, x);
-        else res.push(x);
+/**
+ * @param {string[]} [conditions]
+ * @returns {Set<string>}
+ */
+function getConditionsSet(conditions) {
+  if (conditions !== undefined && conditions !== DEFAULT_CONDITIONS) {
+    if (!Array.isArray(conditions)) {
+      throw new ERR_INVALID_ARG_VALUE(
+        'conditions',
+        conditions,
+        'expected an array'
+      )
     }
-    return res;
-};
 
-var isArray = Array.isArray || function (xs) {
-    return Object.prototype.toString.call(xs) === '[object Array]';
-};
+    return new Set(conditions)
+  }
 
-var balancedMatch = balanced;
-function balanced(a, b, str) {
-  if (a instanceof RegExp) a = maybeMatch(a, str);
-  if (b instanceof RegExp) b = maybeMatch(b, str);
+  return DEFAULT_CONDITIONS_SET
+}
 
-  var r = range(a, b, str);
+/**
+ * @param {string} path
+ * @returns {Stats}
+ */
+function tryStatSync(path) {
+  // Note: from Node 15 onwards we can use `throwIfNoEntry: false` instead.
+  try {
+    return statSync(path)
+  } catch {
+    return new Stats()
+  }
+}
 
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + a.length, r[1]),
-    post: str.slice(r[1] + b.length)
+/**
+ * @param {string} path
+ * @param {string|URL} specifier Note: `specifier` is actually optional, not base.
+ * @param {URL} [base]
+ * @returns {PackageConfig}
+ */
+function getPackageConfig(path, specifier, base) {
+  const existing = packageJsonCache.get(path);
+  if (existing !== undefined) {
+    return existing
+  }
+
+  const source = packageJsonReader.read(path).string;
+
+  if (source === undefined) {
+    /** @type {PackageConfig} */
+    const packageConfig = {
+      pjsonPath: path,
+      exists: false,
+      main: undefined,
+      name: undefined,
+      type: 'none',
+      exports: undefined,
+      imports: undefined
+    };
+    packageJsonCache.set(path, packageConfig);
+    return packageConfig
+  }
+
+  /** @type {Object.<string, unknown>} */
+  let packageJson;
+  try {
+    packageJson = JSON.parse(source);
+  } catch (error) {
+    throw new ERR_INVALID_PACKAGE_CONFIG(
+      path,
+      (base ? `"${specifier}" from ` : '') + fileURLToPath(base || specifier),
+      error.message
+    )
+  }
+
+  const {exports, imports, main, name, type} = packageJson;
+
+  /** @type {PackageConfig} */
+  const packageConfig = {
+    pjsonPath: path,
+    exists: true,
+    main: typeof main === 'string' ? main : undefined,
+    name: typeof name === 'string' ? name : undefined,
+    type: type === 'module' || type === 'commonjs' ? type : 'none',
+    // @ts-expect-error Assume `Object.<string, unknown>`.
+    exports,
+    // @ts-expect-error Assume `Object.<string, unknown>`.
+    imports: imports && typeof imports === 'object' ? imports : undefined
   };
+  packageJsonCache.set(path, packageConfig);
+  return packageConfig
 }
 
-function maybeMatch(reg, str) {
-  var m = str.match(reg);
-  return m ? m[0] : null;
-}
+/**
+ * @param {URL|string} resolved
+ * @returns {PackageConfig}
+ */
+function getPackageScopeConfig(resolved) {
+  let packageJsonUrl = new URL$1('./package.json', resolved);
 
-balanced.range = range;
-function range(a, b, str) {
-  var begs, beg, left, right, result;
-  var ai = str.indexOf(a);
-  var bi = str.indexOf(b, ai + 1);
-  var i = ai;
+  while (true) {
+    const packageJsonPath = packageJsonUrl.pathname;
 
-  if (ai >= 0 && bi > 0) {
-    begs = [];
-    left = str.length;
+    if (packageJsonPath.endsWith('node_modules/package.json')) break
 
-    while (i >= 0 && !result) {
-      if (i == ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length == 1) {
-        result = [ begs.pop(), bi ];
-      } else {
-        beg = begs.pop();
-        if (beg < left) {
-          left = beg;
-          right = bi;
-        }
+    const packageConfig = getPackageConfig(
+      fileURLToPath(packageJsonUrl),
+      resolved
+    );
+    if (packageConfig.exists) return packageConfig
+
+    const lastPackageJsonUrl = packageJsonUrl;
+    packageJsonUrl = new URL$1('../package.json', packageJsonUrl);
+
+    // Terminates at root where ../package.json equals ../../package.json
+    // (can't just check "/package.json" for Windows support).
+    if (packageJsonUrl.pathname === lastPackageJsonUrl.pathname) break
+  }
+
+  const packageJsonPath = fileURLToPath(packageJsonUrl);
+  /** @type {PackageConfig} */
+  const packageConfig = {
+    pjsonPath: packageJsonPath,
+    exists: false,
+    main: undefined,
+    name: undefined,
+    type: 'none',
+    exports: undefined,
+    imports: undefined
+  };
+  packageJsonCache.set(packageJsonPath, packageConfig);
+  return packageConfig
+}
 
-        bi = str.indexOf(b, i + 1);
-      }
+/**
+ * Legacy CommonJS main resolution:
+ * 1. let M = pkg_url + (json main field)
+ * 2. TRY(M, M.js, M.json, M.node)
+ * 3. TRY(M/index.js, M/index.json, M/index.node)
+ * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
+ * 5. NOT_FOUND
+ *
+ * @param {URL} url
+ * @returns {boolean}
+ */
+function fileExists(url) {
+  return tryStatSync(fileURLToPath(url)).isFile()
+}
 
-      i = ai < bi && ai >= 0 ? ai : bi;
+/**
+ * @param {URL} packageJsonUrl
+ * @param {PackageConfig} packageConfig
+ * @param {URL} base
+ * @returns {URL}
+ */
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+  /** @type {URL} */
+  let guess;
+  if (packageConfig.main !== undefined) {
+    guess = new URL$1(`./${packageConfig.main}`, packageJsonUrl);
+    // Note: fs check redundances will be handled by Descriptor cache here.
+    if (fileExists(guess)) return guess
+
+    const tries = [
+      `./${packageConfig.main}.js`,
+      `./${packageConfig.main}.json`,
+      `./${packageConfig.main}.node`,
+      `./${packageConfig.main}/index.js`,
+      `./${packageConfig.main}/index.json`,
+      `./${packageConfig.main}/index.node`
+    ];
+    let i = -1;
+
+    while (++i < tries.length) {
+      guess = new URL$1(tries[i], packageJsonUrl);
+      if (fileExists(guess)) break
+      guess = undefined;
+    }
+
+    if (guess) {
+      emitLegacyIndexDeprecation(
+        guess,
+        packageJsonUrl,
+        base,
+        packageConfig.main
+      );
+      return guess
     }
+    // Fallthrough.
+  }
 
-    if (begs.length) {
-      result = [ left, right ];
-    }
+  const tries = ['./index.js', './index.json', './index.node'];
+  let i = -1;
+
+  while (++i < tries.length) {
+    guess = new URL$1(tries[i], packageJsonUrl);
+    if (fileExists(guess)) break
+    guess = undefined;
   }
 
-  return result;
+  if (guess) {
+    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+    return guess
+  }
+
+  // Not found.
+  throw new ERR_MODULE_NOT_FOUND(
+    fileURLToPath(new URL$1('.', packageJsonUrl)),
+    fileURLToPath(base)
+  )
 }
 
-var braceExpansion = expandTop;
+/**
+ * @param {URL} resolved
+ * @param {URL} base
+ * @returns {URL}
+ */
+function finalizeResolution(resolved, base) {
+  if (encodedSepRegEx.test(resolved.pathname))
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      resolved.pathname,
+      'must not include encoded "/" or "\\" characters',
+      fileURLToPath(base)
+    )
 
-var escSlash = '\0SLASH'+Math.random()+'\0';
-var escOpen = '\0OPEN'+Math.random()+'\0';
-var escClose = '\0CLOSE'+Math.random()+'\0';
-var escComma = '\0COMMA'+Math.random()+'\0';
-var escPeriod = '\0PERIOD'+Math.random()+'\0';
+  const path = fileURLToPath(resolved);
 
-function numeric(str) {
-  return parseInt(str, 10) == str
-    ? parseInt(str, 10)
-    : str.charCodeAt(0);
+  const stats = tryStatSync(path.endsWith('/') ? path.slice(-1) : path);
+
+  if (stats.isDirectory()) {
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(path, fileURLToPath(base));
+    // @ts-expect-error Add this for `import.meta.resolve`.
+    error.url = String(resolved);
+    throw error
+  }
+
+  if (!stats.isFile()) {
+    throw new ERR_MODULE_NOT_FOUND(
+      path || resolved.pathname,
+      base && fileURLToPath(base),
+      'module'
+    )
+  }
+
+  return resolved
 }
 
-function escapeBraces(str) {
-  return str.split('\\\\').join(escSlash)
-            .split('\\{').join(escOpen)
-            .split('\\}').join(escClose)
-            .split('\\,').join(escComma)
-            .split('\\.').join(escPeriod);
+/**
+ * @param {string} specifier
+ * @param {URL?} packageJsonUrl
+ * @param {URL} base
+ * @returns {never}
+ */
+function throwImportNotDefined(specifier, packageJsonUrl, base) {
+  throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    specifier,
+    packageJsonUrl && fileURLToPath(new URL$1('.', packageJsonUrl)),
+    fileURLToPath(base)
+  )
 }
 
-function unescapeBraces(str) {
-  return str.split(escSlash).join('\\')
-            .split(escOpen).join('{')
-            .split(escClose).join('}')
-            .split(escComma).join(',')
-            .split(escPeriod).join('.');
+/**
+ * @param {string} subpath
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @returns {never}
+ */
+function throwExportsNotFound(subpath, packageJsonUrl, base) {
+  throw new ERR_PACKAGE_PATH_NOT_EXPORTED(
+    fileURLToPath(new URL$1('.', packageJsonUrl)),
+    subpath,
+    base && fileURLToPath(base)
+  )
 }
 
+/**
+ * @param {string} subpath
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} [base]
+ * @returns {never}
+ */
+function throwInvalidSubpath(subpath, packageJsonUrl, internal, base) {
+  const reason = `request is not a valid subpath for the "${
+    internal ? 'imports' : 'exports'
+  }" resolution of ${fileURLToPath(packageJsonUrl)}`;
+
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    subpath,
+    reason,
+    base && fileURLToPath(base)
+  )
+}
 
-// Basically just str.split(","), but handling cases
-// where we have nested braced sections, which should be
-// treated as individual members, like {a,{b,c},d}
-function parseCommaParts(str) {
-  if (!str)
-    return [''];
+/**
+ * @param {string} subpath
+ * @param {unknown} target
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} [base]
+ * @returns {never}
+ */
+function throwInvalidPackageTarget(
+  subpath,
+  target,
+  packageJsonUrl,
+  internal,
+  base
+) {
+  target =
+    typeof target === 'object' && target !== null
+      ? JSON.stringify(target, null, '')
+      : `${target}`;
+
+  throw new ERR_INVALID_PACKAGE_TARGET(
+    fileURLToPath(new URL$1('.', packageJsonUrl)),
+    subpath,
+    target,
+    internal,
+    base && fileURLToPath(base)
+  )
+}
 
-  var parts = [];
-  var m = balancedMatch('{', '}', str);
+/**
+ * @param {string} target
+ * @param {string} subpath
+ * @param {string} match
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {boolean} pattern
+ * @param {boolean} internal
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function resolvePackageTargetString(
+  target,
+  subpath,
+  match,
+  packageJsonUrl,
+  base,
+  pattern,
+  internal,
+  conditions
+) {
+  if (subpath !== '' && !pattern && target[target.length - 1] !== '/')
+    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
 
-  if (!m)
-    return str.split(',');
+  if (!target.startsWith('./')) {
+    if (internal && !target.startsWith('../') && !target.startsWith('/')) {
+      let isURL = false;
 
-  var pre = m.pre;
-  var body = m.body;
-  var post = m.post;
-  var p = pre.split(',');
+      try {
+        new URL$1(target);
+        isURL = true;
+      } catch {}
 
-  p[p.length-1] += '{' + body + '}';
-  var postParts = parseCommaParts(post);
-  if (post.length) {
-    p[p.length-1] += postParts.shift();
-    p.push.apply(p, postParts);
+      if (!isURL) {
+        const exportTarget = pattern
+          ? target.replace(patternRegEx, subpath)
+          : target + subpath;
+
+        return packageResolve(exportTarget, packageJsonUrl, conditions)
+      }
+    }
+
+    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
   }
 
-  parts.push.apply(parts, p);
+  if (invalidSegmentRegEx.test(target.slice(2)))
+    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
 
-  return parts;
-}
+  const resolved = new URL$1(target, packageJsonUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL$1('.', packageJsonUrl).pathname;
 
-function expandTop(str) {
-  if (!str)
-    return [];
+  if (!resolvedPath.startsWith(packagePath))
+    throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
 
-  // I don't know why Bash 4.3 does this, but it does.
-  // Anything starting with {} will have the first two bytes preserved
-  // but *only* at the top level, so {},a}b will not expand to anything,
-  // but a{},b}c will be expanded to [a}c,abc].
-  // One could argue that this is a bug in Bash, but since the goal of
-  // this module is to match Bash's rules, we escape a leading {}
-  if (str.substr(0, 2) === '{}') {
-    str = '\\{\\}' + str.substr(2);
-  }
+  if (subpath === '') return resolved
 
-  return expand(escapeBraces(str), true).map(unescapeBraces);
-}
+  if (invalidSegmentRegEx.test(subpath))
+    throwInvalidSubpath(match + subpath, packageJsonUrl, internal, base);
 
-function embrace(str) {
-  return '{' + str + '}';
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
+  if (pattern) return new URL$1(resolved.href.replace(patternRegEx, subpath))
+  return new URL$1(subpath, resolved)
 }
 
-function lte(i, y) {
-  return i <= y;
-}
-function gte(i, y) {
-  return i >= y;
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isArrayIndex(key) {
+  const keyNumber = Number(key);
+  if (`${keyNumber}` !== key) return false
+  return keyNumber >= 0 && keyNumber < 0xffff_ffff
 }
 
-function expand(str, isTop) {
-  var expansions = [];
+/**
+ * @param {URL} packageJsonUrl
+ * @param {unknown} target
+ * @param {string} subpath
+ * @param {string} packageSubpath
+ * @param {URL} base
+ * @param {boolean} pattern
+ * @param {boolean} internal
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function resolvePackageTarget(
+  packageJsonUrl,
+  target,
+  subpath,
+  packageSubpath,
+  base,
+  pattern,
+  internal,
+  conditions
+) {
+  if (typeof target === 'string') {
+    return resolvePackageTargetString(
+      target,
+      subpath,
+      packageSubpath,
+      packageJsonUrl,
+      base,
+      pattern,
+      internal,
+      conditions
+    )
+  }
 
-  var m = balancedMatch('{', '}', str);
-  if (!m || /\$$/.test(m.pre)) return [str];
+  if (Array.isArray(target)) {
+    /** @type {unknown[]} */
+    const targetList = target;
+    if (targetList.length === 0) return null
 
-  var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-  var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-  var isSequence = isNumericSequence || isAlphaSequence;
-  var isOptions = m.body.indexOf(',') >= 0;
-  if (!isSequence && !isOptions) {
-    // {a},b}
-    if (m.post.match(/,.*\}/)) {
-      str = m.pre + '{' + m.body + escClose + m.post;
-      return expand(str);
+    /** @type {Error} */
+    let lastException;
+    let i = -1;
+
+    while (++i < targetList.length) {
+      const targetItem = targetList[i];
+      /** @type {URL} */
+      let resolved;
+      try {
+        resolved = resolvePackageTarget(
+          packageJsonUrl,
+          targetItem,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          conditions
+        );
+      } catch (error) {
+        lastException = error;
+        if (error.code === 'ERR_INVALID_PACKAGE_TARGET') continue
+        throw error
+      }
+
+      if (resolved === undefined) continue
+
+      if (resolved === null) {
+        lastException = null;
+        continue
+      }
+
+      return resolved
     }
-    return [str];
+
+    if (lastException === undefined || lastException === null) {
+      // @ts-expect-error The diff between `undefined` and `null` seems to be
+      // intentional
+      return lastException
+    }
+
+    throw lastException
   }
 
-  var n;
-  if (isSequence) {
-    n = m.body.split(/\.\./);
-  } else {
-    n = parseCommaParts(m.body);
-    if (n.length === 1) {
-      // x{{a,b}}y ==> x{a}y x{b}y
-      n = expand(n[0], false).map(embrace);
-      if (n.length === 1) {
-        var post = m.post.length
-          ? expand(m.post, false)
-          : [''];
-        return post.map(function(p) {
-          return m.pre + n[0] + p;
-        });
+  if (typeof target === 'object' && target !== null) {
+    const keys = Object.getOwnPropertyNames(target);
+    let i = -1;
+
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (isArrayIndex(key)) {
+        throw new ERR_INVALID_PACKAGE_CONFIG(
+          fileURLToPath(packageJsonUrl),
+          base,
+          '"exports" cannot contain numeric property keys.'
+        )
+      }
+    }
+
+    i = -1;
+
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (key === 'default' || (conditions && conditions.has(key))) {
+        /** @type {unknown} */
+        const conditionalTarget = target[key];
+        const resolved = resolvePackageTarget(
+          packageJsonUrl,
+          conditionalTarget,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          conditions
+        );
+        if (resolved === undefined) continue
+        return resolved
       }
     }
+
+    return undefined
   }
 
-  // at this point, n is the parts, and we know it's not a comma set
-  // with a single entry.
+  if (target === null) {
+    return null
+  }
 
-  // no need to expand pre, since it is guaranteed to be free of brace-sets
-  var pre = m.pre;
-  var post = m.post.length
-    ? expand(m.post, false)
-    : [''];
+  throwInvalidPackageTarget(
+    packageSubpath,
+    target,
+    packageJsonUrl,
+    internal,
+    base
+  );
+}
 
-  var N;
+/**
+ * @param {unknown} exports
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @returns {boolean}
+ */
+function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
+  if (typeof exports === 'string' || Array.isArray(exports)) return true
+  if (typeof exports !== 'object' || exports === null) return false
 
-  if (isSequence) {
-    var x = numeric(n[0]);
-    var y = numeric(n[1]);
-    var width = Math.max(n[0].length, n[1].length);
-    var incr = n.length == 3
-      ? Math.abs(numeric(n[2]))
-      : 1;
-    var test = lte;
-    var reverse = y < x;
-    if (reverse) {
-      incr *= -1;
-      test = gte;
+  const keys = Object.getOwnPropertyNames(exports);
+  let isConditionalSugar = false;
+  let i = 0;
+  let j = -1;
+  while (++j < keys.length) {
+    const key = keys[j];
+    const curIsConditionalSugar = key === '' || key[0] !== '.';
+    if (i++ === 0) {
+      isConditionalSugar = curIsConditionalSugar;
+    } else if (isConditionalSugar !== curIsConditionalSugar) {
+      throw new ERR_INVALID_PACKAGE_CONFIG(
+        fileURLToPath(packageJsonUrl),
+        base,
+        '"exports" cannot contain some keys starting with \'.\' and some not.' +
+          ' The exports object must either be an object of package subpath keys' +
+          ' or an object of main entry condition name keys only.'
+      )
     }
-    var pad = n.some(isPadded);
+  }
 
-    N = [];
+  return isConditionalSugar
+}
 
-    for (var i = x; test(i, y); i += incr) {
-      var c;
-      if (isAlphaSequence) {
-        c = String.fromCharCode(i);
-        if (c === '\\')
-          c = '';
+/**
+ * @param {URL} packageJsonUrl
+ * @param {string} packageSubpath
+ * @param {Object.<string, unknown>} packageConfig
+ * @param {URL} base
+ * @param {Set<string>} conditions
+ * @returns {ResolveObject}
+ */
+function packageExportsResolve(
+  packageJsonUrl,
+  packageSubpath,
+  packageConfig,
+  base,
+  conditions
+) {
+  let exports = packageConfig.exports;
+  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base))
+    exports = {'.': exports};
+
+  if (own$d.call(exports, packageSubpath)) {
+    const target = exports[packageSubpath];
+    const resolved = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      '',
+      packageSubpath,
+      base,
+      false,
+      false,
+      conditions
+    );
+    if (resolved === null || resolved === undefined)
+      throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+    return {resolved, exact: true}
+  }
+
+  let bestMatch = '';
+  const keys = Object.getOwnPropertyNames(exports);
+  let i = -1;
+
+  while (++i < keys.length) {
+    const key = keys[i];
+    if (
+      key[key.length - 1] === '*' &&
+      packageSubpath.startsWith(key.slice(0, -1)) &&
+      packageSubpath.length >= key.length &&
+      key.length > bestMatch.length
+    ) {
+      bestMatch = key;
+    } else if (
+      key[key.length - 1] === '/' &&
+      packageSubpath.startsWith(key) &&
+      key.length > bestMatch.length
+    ) {
+      bestMatch = key;
+    }
+  }
+
+  if (bestMatch) {
+    const target = exports[bestMatch];
+    const pattern = bestMatch[bestMatch.length - 1] === '*';
+    const subpath = packageSubpath.slice(bestMatch.length - (pattern ? 1 : 0));
+    const resolved = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      subpath,
+      bestMatch,
+      base,
+      pattern,
+      false,
+      conditions
+    );
+    if (resolved === null || resolved === undefined)
+      throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+    if (!pattern)
+      emitFolderMapDeprecation(bestMatch, packageJsonUrl, true, base);
+    return {resolved, exact: pattern}
+  }
+
+  throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+}
+
+/**
+ * @param {string} name
+ * @param {URL} base
+ * @param {Set<string>} [conditions]
+ * @returns {ResolveObject}
+ */
+function packageImportsResolve(name, base, conditions) {
+  if (name === '#' || name.startsWith('#/')) {
+    const reason = 'is not a valid internal imports specifier name';
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath(base))
+  }
+
+  /** @type {URL} */
+  let packageJsonUrl;
+
+  const packageConfig = getPackageScopeConfig(base);
+
+  if (packageConfig.exists) {
+    packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
+    const imports = packageConfig.imports;
+    if (imports) {
+      if (own$d.call(imports, name)) {
+        const resolved = resolvePackageTarget(
+          packageJsonUrl,
+          imports[name],
+          '',
+          name,
+          base,
+          false,
+          true,
+          conditions
+        );
+        if (resolved !== null) return {resolved, exact: true}
       } else {
-        c = String(i);
-        if (pad) {
-          var need = width - c.length;
-          if (need > 0) {
-            var z = new Array(need + 1).join('0');
-            if (i < 0)
-              c = '-' + z + c.slice(1);
-            else
-              c = z + c;
+        let bestMatch = '';
+        const keys = Object.getOwnPropertyNames(imports);
+        let i = -1;
+
+        while (++i < keys.length) {
+          const key = keys[i];
+
+          if (
+            key[key.length - 1] === '*' &&
+            name.startsWith(key.slice(0, -1)) &&
+            name.length >= key.length &&
+            key.length > bestMatch.length
+          ) {
+            bestMatch = key;
+          } else if (
+            key[key.length - 1] === '/' &&
+            name.startsWith(key) &&
+            key.length > bestMatch.length
+          ) {
+            bestMatch = key;
+          }
+        }
+
+        if (bestMatch) {
+          const target = imports[bestMatch];
+          const pattern = bestMatch[bestMatch.length - 1] === '*';
+          const subpath = name.slice(bestMatch.length - (pattern ? 1 : 0));
+          const resolved = resolvePackageTarget(
+            packageJsonUrl,
+            target,
+            subpath,
+            bestMatch,
+            base,
+            pattern,
+            true,
+            conditions
+          );
+          if (resolved !== null) {
+            if (!pattern)
+              emitFolderMapDeprecation(bestMatch, packageJsonUrl, false, base);
+            return {resolved, exact: pattern}
           }
         }
       }
-      N.push(c);
     }
-  } else {
-    N = concatMap(n, function(el) { return expand(el, false) });
   }
 
-  for (var j = 0; j < N.length; j++) {
-    for (var k = 0; k < post.length; k++) {
-      var expansion = pre + N[j] + post[k];
-      if (!isTop || isSequence || expansion)
-        expansions.push(expansion);
+  throwImportNotDefined(name, packageJsonUrl, base);
+}
+
+/**
+ * @param {string} url
+ * @returns {PackageType}
+ */
+function getPackageType(url) {
+  const packageConfig = getPackageScopeConfig(url);
+  return packageConfig.type
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ */
+function parsePackageName(specifier, base) {
+  let separatorIndex = specifier.indexOf('/');
+  let validPackageName = true;
+  let isScoped = false;
+  if (specifier[0] === '@') {
+    isScoped = true;
+    if (separatorIndex === -1 || specifier.length === 0) {
+      validPackageName = false;
+    } else {
+      separatorIndex = specifier.indexOf('/', separatorIndex + 1);
     }
   }
 
-  return expansions;
-}
+  const packageName =
+    separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
 
-var minimatch_1 = minimatch;
-minimatch.Minimatch = Minimatch;
+  // Package name cannot have leading . and cannot have percent-encoding or
+  // separators.
+  let i = -1;
+  while (++i < packageName.length) {
+    if (packageName[i] === '%' || packageName[i] === '\\') {
+      validPackageName = false;
+      break
+    }
+  }
 
-var path = { sep: '/' };
-try {
-  path = path$1;
-} catch (er) {}
+  if (!validPackageName) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      specifier,
+      'is not a valid package name',
+      fileURLToPath(base)
+    )
+  }
 
-var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
+  const packageSubpath =
+    '.' + (separatorIndex === -1 ? '' : specifier.slice(separatorIndex));
 
+  return {packageName, packageSubpath, isScoped}
+}
 
-var plTypes = {
-  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
-  '?': { open: '(?:', close: ')?' },
-  '+': { open: '(?:', close: ')+' },
-  '*': { open: '(?:', close: ')*' },
-  '@': { open: '(?:', close: ')' }
-};
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function packageResolve(specifier, base, conditions) {
+  const {packageName, packageSubpath, isScoped} = parsePackageName(
+    specifier,
+    base
+  );
 
-// any single thing other than /
-// don't need to escape / when using new RegExp()
-var qmark = '[^/]';
+  // ResolveSelf
+  const packageConfig = getPackageScopeConfig(base);
 
-// * => any number of characters
-var star = qmark + '*?';
+  // Can’t test.
+  /* c8 ignore next 16 */
+  if (packageConfig.exists) {
+    const packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
+    if (
+      packageConfig.name === packageName &&
+      packageConfig.exports !== undefined &&
+      packageConfig.exports !== null
+    ) {
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      ).resolved
+    }
+  }
 
-// ** when dots are allowed.  Anything goes, except .. and .
-// not (^ or / followed by one or two dots followed by $ or /),
-// followed by anything, any number of times.
-var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?';
+  let packageJsonUrl = new URL$1(
+    './node_modules/' + packageName + '/package.json',
+    base
+  );
+  let packageJsonPath = fileURLToPath(packageJsonUrl);
+  /** @type {string} */
+  let lastPath;
+  do {
+    const stat = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat.isDirectory()) {
+      lastPath = packageJsonPath;
+      packageJsonUrl = new URL$1(
+        (isScoped ? '../../../../node_modules/' : '../../../node_modules/') +
+          packageName +
+          '/package.json',
+        packageJsonUrl
+      );
+      packageJsonPath = fileURLToPath(packageJsonUrl);
+      continue
+    }
 
-// not a ^ or / followed by a dot,
-// followed by anything, any number of times.
-var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';
+    // Package match.
+    const packageConfig = getPackageConfig(packageJsonPath, specifier, base);
+    if (packageConfig.exports !== undefined && packageConfig.exports !== null)
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      ).resolved
+    if (packageSubpath === '.')
+      return legacyMainResolve(packageJsonUrl, packageConfig, base)
+    return new URL$1(packageSubpath, packageJsonUrl)
+    // Cross-platform root check.
+  } while (packageJsonPath.length !== lastPath.length)
 
-// characters that need to be escaped in RegExp.
-var reSpecials = charSet('().*{}+?[]^$\\!');
+  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base))
+}
 
-// "abc" -> { a:true, b:true, c:true }
-function charSet (s) {
-  return s.split('').reduce(function (set, c) {
-    set[c] = true;
-    return set
-  }, {})
+/**
+ * @param {string} specifier
+ * @returns {boolean}
+ */
+function isRelativeSpecifier(specifier) {
+  if (specifier[0] === '.') {
+    if (specifier.length === 1 || specifier[1] === '/') return true
+    if (
+      specifier[1] === '.' &&
+      (specifier.length === 2 || specifier[2] === '/')
+    ) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * @param {string} specifier
+ * @returns {boolean}
+ */
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+  if (specifier === '') return false
+  if (specifier[0] === '/') return true
+  return isRelativeSpecifier(specifier)
+}
+
+/**
+ * The “Resolver Algorithm Specification” as detailed in the Node docs (which is
+ * sync and slightly lower-level than `resolve`).
+ *
+ *
+ *
+ * @param {string} specifier
+ * @param {URL} base
+ * @param {Set<string>} [conditions]
+ * @returns {URL}
+ */
+function moduleResolve(specifier, base, conditions) {
+  // Order swapped from spec for minor perf gain.
+  // Ok since relative URLs cannot parse as URLs.
+  /** @type {URL} */
+  let resolved;
+
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+    resolved = new URL$1(specifier, base);
+  } else if (specifier[0] === '#') {
+({resolved} = packageImportsResolve(specifier, base, conditions));
+  } else {
+    try {
+      resolved = new URL$1(specifier);
+    } catch {
+      resolved = packageResolve(specifier, base, conditions);
+    }
+  }
+
+  return finalizeResolution(resolved, base)
 }
 
-// normalizes slashes.
-var slashSplit = /\/+/;
+/**
+ * @param {string} specifier
+ * @param {{parentURL?: string, conditions?: string[]}} context
+ * @returns {{url: string}}
+ */
+function defaultResolve(specifier, context = {}) {
+  const {parentURL} = context;
+  /** @type {URL} */
+  let parsed;
 
-minimatch.filter = filter;
-function filter (pattern, options) {
-  options = options || {};
-  return function (p, i, list) {
-    return minimatch(p, pattern, options)
-  }
-}
+  try {
+    parsed = new URL$1(specifier);
+    if (parsed.protocol === 'data:') {
+      return {url: specifier}
+    }
+  } catch {}
 
-function ext (a, b) {
-  a = a || {};
-  b = b || {};
-  var t = {};
-  Object.keys(b).forEach(function (k) {
-    t[k] = b[k];
-  });
-  Object.keys(a).forEach(function (k) {
-    t[k] = a[k];
-  });
-  return t
-}
+  if (parsed && parsed.protocol === 'node:') return {url: specifier}
+  if (parsed && parsed.protocol !== 'file:' && parsed.protocol !== 'data:')
+    throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(parsed)
 
-minimatch.defaults = function (def) {
-  if (!def || !Object.keys(def).length) return minimatch
+  if (listOfBuiltins.includes(specifier)) {
+    return {url: 'node:' + specifier}
+  }
 
-  var orig = minimatch;
+  if (parentURL.startsWith('data:')) {
+    // This is gonna blow up, we want the error
+    new URL$1(specifier, parentURL);
+  }
 
-  var m = function minimatch (p, pattern, options) {
-    return orig.minimatch(p, pattern, ext(def, options))
-  };
+  const conditions = getConditionsSet(context.conditions);
+  let url = moduleResolve(specifier, new URL$1(parentURL), conditions);
 
-  m.Minimatch = function Minimatch (pattern, options) {
-    return new orig.Minimatch(pattern, ext(def, options))
-  };
+  const urlPath = fileURLToPath(url);
+  const real = realpathSync$1(urlPath);
+  const old = url;
+  url = pathToFileURL(real + (urlPath.endsWith(path$b.sep) ? '/' : ''));
+  url.search = old.search;
+  url.hash = old.hash;
 
-  return m
-};
+  return {url: `${url}`}
+}
 
-Minimatch.defaults = function (def) {
-  if (!def || !Object.keys(def).length) return Minimatch
-  return minimatch.defaults(def).Minimatch
-};
+/**
+ * Provides a module-relative resolution function scoped to each module,
+ * returning the URL string.
+ * `import.meta.resolve` also accepts a second argument which is the parent
+ * module from which to resolve from.
+ *
+ * This function is asynchronous because the ES module resolver in Node.js is
+ * allowed to be asynchronous.
+ *
+ * @param {string} specifier The module specifier to resolve relative to parent.
+ * @param {string} parent The absolute parent module URL to resolve from.
+ *   You should pass `import.meta.url` or something else
+ * @returns {Promise<string>}
+ */
+async function resolve(specifier, parent) {
+  if (!parent) {
+    throw new Error(
+      'Please pass `parent`: `import-meta-resolve` cannot ponyfill that'
+    )
+  }
 
-function minimatch (p, pattern, options) {
-  if (typeof pattern !== 'string') {
-    throw new TypeError('glob pattern string required')
+  try {
+    return defaultResolve(specifier, {parentURL: parent}).url
+  } catch (error) {
+    return error.code === 'ERR_UNSUPPORTED_DIR_IMPORT'
+      ? error.url
+      : Promise.reject(error)
   }
+}
 
-  if (!options) options = {};
+var libnpmconfig = {};
 
-  // shortcut: comments match nothing.
-  if (!options.nocomment && pattern.charAt(0) === '#') {
-    return false
+class FiggyPudding {
+  constructor (specs, opts, providers) {
+    this.__specs = specs || {};
+    Object.keys(this.__specs).forEach(alias => {
+      if (typeof this.__specs[alias] === 'string') {
+        const key = this.__specs[alias];
+        const realSpec = this.__specs[key];
+        if (realSpec) {
+          const aliasArr = realSpec.aliases || [];
+          aliasArr.push(alias, key);
+          realSpec.aliases = [...(new Set(aliasArr))];
+          this.__specs[alias] = realSpec;
+        } else {
+          throw new Error(`Alias refers to invalid key: ${key} -> ${alias}`)
+        }
+      }
+    });
+    this.__opts = opts || {};
+    this.__providers = reverse((providers).filter(
+      x => x != null && typeof x === 'object'
+    ));
+    this.__isFiggyPudding = true;
   }
+  get (key) {
+    return pudGet(this, key, true)
+  }
+  get [Symbol.toStringTag] () { return 'FiggyPudding' }
+  forEach (fn, thisArg = this) {
+    for (let [key, value] of this.entries()) {
+      fn.call(thisArg, value, key, this);
+    }
+  }
+  toJSON () {
+    const obj = {};
+    this.forEach((val, key) => {
+      obj[key] = val;
+    });
+    return obj
+  }
+  * entries (_matcher) {
+    for (let key of Object.keys(this.__specs)) {
+      yield [key, this.get(key)];
+    }
+    const matcher = _matcher || this.__opts.other;
+    if (matcher) {
+      const seen = new Set();
+      for (let p of this.__providers) {
+        const iter = p.entries ? p.entries(matcher) : entries(p);
+        for (let [key, val] of iter) {
+          if (matcher(key) && !seen.has(key)) {
+            seen.add(key);
+            yield [key, val];
+          }
+        }
+      }
+    }
+  }
+  * [Symbol.iterator] () {
+    for (let [key, value] of this.entries()) {
+      yield [key, value];
+    }
+  }
+  * keys () {
+    for (let [key] of this.entries()) {
+      yield key;
+    }
+  }
+  * values () {
+    for (let [, value] of this.entries()) {
+      yield value;
+    }
+  }
+  concat (...moreConfig) {
+    return new Proxy(new FiggyPudding(
+      this.__specs,
+      this.__opts,
+      reverse(this.__providers).concat(moreConfig)
+    ), proxyHandler)
+  }
+}
+try {
+  const util = require$$0$4;
+  FiggyPudding.prototype[util.inspect.custom] = function (depth, opts) {
+    return (
+      this[Symbol.toStringTag] + ' '
+    ) + util.inspect(this.toJSON(), opts)
+  };
+} catch (e) {}
 
-  // "" only matches ""
-  if (pattern.trim() === '') return p === ''
-
-  return new Minimatch(pattern, options).match(p)
+function BadKeyError (key) {
+  throw Object.assign(new Error(
+    `invalid config key requested: ${key}`
+  ), {code: 'EBADKEY'})
 }
 
-function Minimatch (pattern, options) {
-  if (!(this instanceof Minimatch)) {
-    return new Minimatch(pattern, options)
+function pudGet (pud, key, validate) {
+  let spec = pud.__specs[key];
+  if (validate && !spec && (!pud.__opts.other || !pud.__opts.other(key))) {
+    BadKeyError(key);
+  } else {
+    if (!spec) { spec = {}; }
+    let ret;
+    for (let p of pud.__providers) {
+      ret = tryGet(key, p);
+      if (ret === undefined && spec.aliases && spec.aliases.length) {
+        for (let alias of spec.aliases) {
+          if (alias === key) { continue }
+          ret = tryGet(alias, p);
+          if (ret !== undefined) {
+            break
+          }
+        }
+      }
+      if (ret !== undefined) {
+        break
+      }
+    }
+    if (ret === undefined && spec.default !== undefined) {
+      if (typeof spec.default === 'function') {
+        return spec.default(pud)
+      } else {
+        return spec.default
+      }
+    } else {
+      return ret
+    }
   }
+}
 
-  if (typeof pattern !== 'string') {
-    throw new TypeError('glob pattern string required')
+function tryGet (key, p) {
+  let ret;
+  if (p.__isFiggyPudding) {
+    ret = pudGet(p, key, false);
+  } else if (typeof p.get === 'function') {
+    ret = p.get(key);
+  } else {
+    ret = p[key];
   }
+  return ret
+}
 
-  if (!options) options = {};
-  pattern = pattern.trim();
-
-  // windows support: need to use /, not \
-  if (path.sep !== '/') {
-    pattern = pattern.split(path.sep).join('/');
+const proxyHandler = {
+  has (obj, prop) {
+    return prop in obj.__specs && pudGet(obj, prop, false) !== undefined
+  },
+  ownKeys (obj) {
+    return Object.keys(obj.__specs)
+  },
+  get (obj, prop) {
+    if (
+      typeof prop === 'symbol' ||
+      prop.slice(0, 2) === '__' ||
+      prop in FiggyPudding.prototype
+    ) {
+      return obj[prop]
+    }
+    return obj.get(prop)
+  },
+  set (obj, prop, value) {
+    if (
+      typeof prop === 'symbol' ||
+      prop.slice(0, 2) === '__'
+    ) {
+      obj[prop] = value;
+      return true
+    } else {
+      throw new Error('figgyPudding options cannot be modified. Use .concat() instead.')
+    }
+  },
+  deleteProperty () {
+    throw new Error('figgyPudding options cannot be deleted. Use .concat() and shadow them instead.')
   }
+};
 
-  this.options = options;
-  this.set = [];
-  this.pattern = pattern;
-  this.regexp = null;
-  this.negate = false;
-  this.comment = false;
-  this.empty = false;
+var figgyPudding_1 = figgyPudding$1;
+function figgyPudding$1 (specs, opts) {
+  function factory (...providers) {
+    return new Proxy(new FiggyPudding(
+      specs,
+      opts,
+      providers
+    ), proxyHandler)
+  }
+  return factory
+}
 
-  // make the set of regexps etc.
-  this.make();
+function reverse (arr) {
+  const ret = [];
+  arr.forEach(x => ret.unshift(x));
+  return ret
 }
 
-Minimatch.prototype.debug = function () {};
+function entries (obj) {
+  return Object.keys(obj).map(k => [k, obj[k]])
+}
 
-Minimatch.prototype.make = make;
-function make () {
-  // don't do it more than once.
-  if (this._made) return
+var findUp$1 = {exports: {}};
 
-  var pattern = this.pattern;
-  var options = this.options;
+var locatePath$1 = {exports: {}};
 
-  // empty patterns and comments match nothing.
-  if (!options.nocomment && pattern.charAt(0) === '#') {
-    this.comment = true;
-    return
-  }
-  if (!pattern) {
-    this.empty = true;
-    return
-  }
+var pathExists$1 = {exports: {}};
 
-  // step 1: figure out negation, etc.
-  this.parseNegate();
+const fs$5 = require$$0$3;
 
-  // step 2: expand braces
-  var set = this.globSet = this.braceExpand();
+pathExists$1.exports = fp => new Promise(resolve => {
+	fs$5.access(fp, err => {
+		resolve(!err);
+	});
+});
 
-  if (options.debug) this.debug = console.error;
+pathExists$1.exports.sync = fp => {
+	try {
+		fs$5.accessSync(fp);
+		return true;
+	} catch (err) {
+		return false;
+	}
+};
 
-  this.debug(this.pattern, set);
+var pLimit$2 = {exports: {}};
 
-  // step 3: now we have a set, so turn each one into a series of path-portion
-  // matching patterns.
-  // These will be regexps, except in the case of "**", which is
-  // set to the GLOBSTAR object for globstar behavior,
-  // and will not contain any / characters
-  set = this.globParts = set.map(function (s) {
-    return s.split(slashSplit)
-  });
+var pTry$2 = {exports: {}};
 
-  this.debug(this.pattern, set);
+const pTry$1 = (fn, ...arguments_) => new Promise(resolve => {
+	resolve(fn(...arguments_));
+});
 
-  // glob --> regexps
-  set = set.map(function (s, si, set) {
-    return s.map(this.parse, this)
-  }, this);
+pTry$2.exports = pTry$1;
+// TODO: remove this in the next major version
+pTry$2.exports.default = pTry$1;
 
-  this.debug(this.pattern, set);
+const pTry = pTry$2.exports;
 
-  // filter out everything that didn't compile properly.
-  set = set.filter(function (s) {
-    return s.indexOf(false) === -1
-  });
+const pLimit$1 = concurrency => {
+	if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+		return Promise.reject(new TypeError('Expected `concurrency` to be a number from 1 and up'));
+	}
 
-  this.debug(this.pattern, set);
+	const queue = [];
+	let activeCount = 0;
 
-  this.set = set;
-}
+	const next = () => {
+		activeCount--;
 
-Minimatch.prototype.parseNegate = parseNegate;
-function parseNegate () {
-  var pattern = this.pattern;
-  var negate = false;
-  var options = this.options;
-  var negateOffset = 0;
+		if (queue.length > 0) {
+			queue.shift()();
+		}
+	};
 
-  if (options.nonegate) return
+	const run = (fn, resolve, ...args) => {
+		activeCount++;
 
-  for (var i = 0, l = pattern.length
-    ; i < l && pattern.charAt(i) === '!'
-    ; i++) {
-    negate = !negate;
-    negateOffset++;
-  }
+		const result = pTry(fn, ...args);
 
-  if (negateOffset) this.pattern = pattern.substr(negateOffset);
-  this.negate = negate;
-}
+		resolve(result);
 
-// Brace expansion:
-// a{b,c}d -> abd acd
-// a{b,}c -> abc ac
-// a{0..3}d -> a0d a1d a2d a3d
-// a{b,c{d,e}f}g -> abg acdfg acefg
-// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
-//
-// Invalid sets are not expanded.
-// a{2..}b -> a{2..}b
-// a{b}c -> a{b}c
-minimatch.braceExpand = function (pattern, options) {
-  return braceExpand(pattern, options)
-};
+		result.then(next, next);
+	};
 
-Minimatch.prototype.braceExpand = braceExpand;
+	const enqueue = (fn, resolve, ...args) => {
+		if (activeCount < concurrency) {
+			run(fn, resolve, ...args);
+		} else {
+			queue.push(run.bind(null, fn, resolve, ...args));
+		}
+	};
 
-function braceExpand (pattern, options) {
-  if (!options) {
-    if (this instanceof Minimatch) {
-      options = this.options;
-    } else {
-      options = {};
-    }
-  }
+	const generator = (fn, ...args) => new Promise(resolve => enqueue(fn, resolve, ...args));
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount
+		},
+		pendingCount: {
+			get: () => queue.length
+		},
+		clearQueue: {
+			value: () => {
+				queue.length = 0;
+			}
+		}
+	});
 
-  pattern = typeof pattern === 'undefined'
-    ? this.pattern : pattern;
+	return generator;
+};
 
-  if (typeof pattern === 'undefined') {
-    throw new TypeError('undefined pattern')
-  }
+pLimit$2.exports = pLimit$1;
+pLimit$2.exports.default = pLimit$1;
 
-  if (options.nobrace ||
-    !pattern.match(/\{.*\}/)) {
-    // shortcut. no need to expand.
-    return [pattern]
-  }
+const pLimit = pLimit$2.exports;
 
-  return braceExpansion(pattern)
+class EndError extends Error {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
 }
 
-// parse a component of the expanded set.
-// At this point, no pattern may contain "/" in it
-// so we're going to return a 2d array, where each entry is the full
-// pattern, split on '/', and then turned into a regular expression.
-// A regexp is made at the end which joins each array with an
-// escaped /, and another full one which joins each regexp with |.
-//
-// Following the lead of Bash 4.1, note that "**" only has special meaning
-// when it is the *only* thing in a path portion.  Otherwise, any series
-// of * is equivalent to a single *.  Globstar behavior is enabled by
-// default, and can be disabled by setting options.noglobstar.
-Minimatch.prototype.parse = parse$2;
-var SUBPARSE = {};
-function parse$2 (pattern, isSub) {
-  if (pattern.length > 1024 * 64) {
-    throw new TypeError('pattern is too long')
-  }
-
-  var options = this.options;
+// The input can also be a promise, so we `Promise.resolve()` it
+const testElement = (el, tester) => Promise.resolve(el).then(tester);
 
-  // shortcuts
-  if (!options.noglobstar && pattern === '**') return GLOBSTAR
-  if (pattern === '') return ''
+// The input can also be a promise, so we `Promise.all()` them both
+const finder$1 = el => Promise.all(el).then(val => val[1] === true && Promise.reject(new EndError(val[0])));
 
-  var re = '';
-  var hasMagic = !!options.nocase;
-  var escaping = false;
-  // ? => one single character
-  var patternListStack = [];
-  var negativeLists = [];
-  var stateChar;
-  var inClass = false;
-  var reClassStart = -1;
-  var classStart = -1;
-  // . and .. never match anything that doesn't start with .,
-  // even when options.dot is set.
-  var patternStart = pattern.charAt(0) === '.' ? '' // anything
-  // not (start or / followed by . or .. followed by / or end)
-  : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
-  : '(?!\\.)';
-  var self = this;
+var pLocate$1 = (iterable, tester, opts) => {
+	opts = Object.assign({
+		concurrency: Infinity,
+		preserveOrder: true
+	}, opts);
 
-  function clearStateChar () {
-    if (stateChar) {
-      // we had some state-tracking character
-      // that wasn't consumed by this pass.
-      switch (stateChar) {
-        case '*':
-          re += star;
-          hasMagic = true;
-        break
-        case '?':
-          re += qmark;
-          hasMagic = true;
-        break
-        default:
-          re += '\\' + stateChar;
-        break
-      }
-      self.debug('clearStateChar %j %j', stateChar, re);
-      stateChar = false;
-    }
-  }
+	const limit = pLimit(opts.concurrency);
 
-  for (var i = 0, len = pattern.length, c
-    ; (i < len) && (c = pattern.charAt(i))
-    ; i++) {
-    this.debug('%s\t%s %s %j', pattern, i, re, c);
+	// Start all the promises concurrently with optional limit
+	const items = [...iterable].map(el => [el, limit(testElement, el, tester)]);
 
-    // skip over any that are escaped.
-    if (escaping && reSpecials[c]) {
-      re += '\\' + c;
-      escaping = false;
-      continue
-    }
+	// Check the promises either serially or concurrently
+	const checkLimit = pLimit(opts.preserveOrder ? 1 : Infinity);
 
-    switch (c) {
-      case '/':
-        // completely not allowed, even escaped.
-        // Should already be path-split by now.
-        return false
+	return Promise.all(items.map(el => checkLimit(finder$1, el)))
+		.then(() => {})
+		.catch(err => err instanceof EndError ? err.value : Promise.reject(err));
+};
 
-      case '\\':
-        clearStateChar();
-        escaping = true;
-      continue
+const path$7 = path$b;
+const pathExists = pathExists$1.exports;
+const pLocate = pLocate$1;
 
-      // the various stateChar values
-      // for the "extglob" stuff.
-      case '?':
-      case '*':
-      case '+':
-      case '@':
-      case '!':
-        this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);
+locatePath$1.exports = (iterable, options) => {
+	options = Object.assign({
+		cwd: process.cwd()
+	}, options);
 
-        // all of those are literals inside a class, except that
-        // the glob [!a] means [^a] in regexp
-        if (inClass) {
-          this.debug('  in class');
-          if (c === '!' && i === classStart + 1) c = '^';
-          re += c;
-          continue
-        }
+	return pLocate(iterable, el => pathExists(path$7.resolve(options.cwd, el)), options);
+};
 
-        // if we already have a stateChar, then it means
-        // that there was something like ** or +? in there.
-        // Handle the stateChar, then proceed with this one.
-        self.debug('call clearStateChar %j', stateChar);
-        clearStateChar();
-        stateChar = c;
-        // if extglob is disabled, then +(asdf|foo) isn't a thing.
-        // just clear the statechar *now*, rather than even diving into
-        // the patternList stuff.
-        if (options.noext) clearStateChar();
-      continue
+locatePath$1.exports.sync = (iterable, options) => {
+	options = Object.assign({
+		cwd: process.cwd()
+	}, options);
 
-      case '(':
-        if (inClass) {
-          re += '(';
-          continue
-        }
+	for (const el of iterable) {
+		if (pathExists.sync(path$7.resolve(options.cwd, el))) {
+			return el;
+		}
+	}
+};
 
-        if (!stateChar) {
-          re += '\\(';
-          continue
-        }
+const path$6 = path$b;
+const locatePath = locatePath$1.exports;
 
-        patternListStack.push({
-          type: stateChar,
-          start: i - 1,
-          reStart: re.length,
-          open: plTypes[stateChar].open,
-          close: plTypes[stateChar].close
-        });
-        // negation is (?:(?!js)[^/]*)
-        re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
-        this.debug('plType %j %j', stateChar, re);
-        stateChar = false;
-      continue
+findUp$1.exports = (filename, opts = {}) => {
+	const startDir = path$6.resolve(opts.cwd || '');
+	const {root} = path$6.parse(startDir);
 
-      case ')':
-        if (inClass || !patternListStack.length) {
-          re += '\\)';
-          continue
-        }
+	const filenames = [].concat(filename);
 
-        clearStateChar();
-        hasMagic = true;
-        var pl = patternListStack.pop();
-        // negation is (?:(?!js)[^/]*)
-        // The others are (?:<pattern>)<type>
-        re += pl.close;
-        if (pl.type === '!') {
-          negativeLists.push(pl);
-        }
-        pl.reEnd = re.length;
-      continue
+	return new Promise(resolve => {
+		(function find(dir) {
+			locatePath(filenames, {cwd: dir}).then(file => {
+				if (file) {
+					resolve(path$6.join(dir, file));
+				} else if (dir === root) {
+					resolve(null);
+				} else {
+					find(path$6.dirname(dir));
+				}
+			});
+		})(startDir);
+	});
+};
 
-      case '|':
-        if (inClass || !patternListStack.length || escaping) {
-          re += '\\|';
-          escaping = false;
-          continue
-        }
+findUp$1.exports.sync = (filename, opts = {}) => {
+	let dir = path$6.resolve(opts.cwd || '');
+	const {root} = path$6.parse(dir);
 
-        clearStateChar();
-        re += '|';
-      continue
+	const filenames = [].concat(filename);
 
-      // these are mostly the same in regexp and glob
-      case '[':
-        // swallow any state-tracking char before the [
-        clearStateChar();
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		const file = locatePath.sync(filenames, {cwd: dir});
 
-        if (inClass) {
-          re += '\\' + c;
-          continue
-        }
+		if (file) {
+			return path$6.join(dir, file);
+		}
 
-        inClass = true;
-        classStart = i;
-        reClassStart = re.length;
-        re += c;
-      continue
+		if (dir === root) {
+			return null;
+		}
 
-      case ']':
-        //  a right bracket shall lose its special
-        //  meaning and represent itself in
-        //  a bracket expression if it occurs
-        //  first in the list.  -- POSIX.2 2.8.3.2
-        if (i === classStart + 1 || !inClass) {
-          re += '\\' + c;
-          escaping = false;
-          continue
-        }
+		dir = path$6.dirname(dir);
+	}
+};
 
-        // handle the case where we left a class open.
-        // "[z-a]" is valid, equivalent to "\[z-a\]"
-        if (inClass) {
-          // split where the last [ was, make sure we don't have
-          // an invalid re. if so, re-walk the contents of the
-          // would-be class to re-translate any characters that
-          // were passed through as-is
-          // TODO: It would probably be faster to determine this
-          // without a try/catch and a new RegExp, but it's tricky
-          // to do safely.  For now, this is safe and works.
-          var cs = pattern.substring(classStart + 1, i);
-          try {
-            RegExp('[' + cs + ']');
-          } catch (er) {
-            // not a valid class!
-            var sp = this.parse(cs, SUBPARSE);
-            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
-            hasMagic = hasMagic || sp[1];
-            inClass = false;
-            continue
-          }
-        }
+var ini$1 = {};
 
-        // finish up the class.
-        hasMagic = true;
-        inClass = false;
-        re += c;
-      continue
+ini$1.parse = ini$1.decode = decode;
 
-      default:
-        // swallow any state char that wasn't consumed
-        clearStateChar();
+ini$1.stringify = ini$1.encode = encode$1;
 
-        if (escaping) {
-          // no need
-          escaping = false;
-        } else if (reSpecials[c]
-          && !(c === '^' && inClass)) {
-          re += '\\';
-        }
+ini$1.safe = safe$1;
+ini$1.unsafe = unsafe$1;
 
-        re += c;
+var eol$1 = typeof process !== 'undefined' &&
+  process.platform === 'win32' ? '\r\n' : '\n';
 
-    } // switch
-  } // for
+function encode$1 (obj, opt) {
+  var children = [];
+  var out = '';
 
-  // handle the case where we left a class open.
-  // "[abc" is valid, equivalent to "\[abc"
-  if (inClass) {
-    // split where the last [ was, and escape it
-    // this is a huge pita.  We now have to re-walk
-    // the contents of the would-be class to re-translate
-    // any characters that were passed through as-is
-    cs = pattern.substr(classStart + 1);
-    sp = this.parse(cs, SUBPARSE);
-    re = re.substr(0, reClassStart) + '\\[' + sp[0];
-    hasMagic = hasMagic || sp[1];
+  if (typeof opt === 'string') {
+    opt = {
+      section: opt,
+      whitespace: false,
+    };
+  } else {
+    opt = opt || {};
+    opt.whitespace = opt.whitespace === true;
   }
 
-  // handle the case where we had a +( thing at the *end*
-  // of the pattern.
-  // each pattern list stack adds 3 chars, and we need to go through
-  // and escape any | chars that were passed through as-is for the regexp.
-  // Go through and escape them, taking care not to double-escape any
-  // | chars that were already escaped.
-  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
-    var tail = re.slice(pl.reStart + pl.open.length);
-    this.debug('setting tail', re, pl);
-    // maybe some even number of \, then maybe 1 \, followed by a |
-    tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
-      if (!$2) {
-        // the | isn't already escaped, so escape it.
-        $2 = '\\';
-      }
-
-      // need to escape all those slashes *again*, without escaping the
-      // one that we need for escaping the | character.  As it works out,
-      // escaping an even number of slashes can be done by simply repeating
-      // it exactly after itself.  That's why this trick works.
-      //
-      // I am sorry that you have to see this.
-      return $1 + $1 + $2 + '|'
-    });
+  var separator = opt.whitespace ? ' = ' : '=';
 
-    this.debug('tail=%j\n   %s', tail, tail, pl, re);
-    var t = pl.type === '*' ? star
-      : pl.type === '?' ? qmark
-      : '\\' + pl.type;
+  Object.keys(obj).forEach(function (k, _, __) {
+    var val = obj[k];
+    if (val && Array.isArray(val)) {
+      val.forEach(function (item) {
+        out += safe$1(k + '[]') + separator + safe$1(item) + '\n';
+      });
+    } else if (val && typeof val === 'object')
+      children.push(k);
+    else
+      out += safe$1(k) + separator + safe$1(val) + eol$1;
+  });
 
-    hasMagic = true;
-    re = re.slice(0, pl.reStart) + t + '\\(' + tail;
-  }
+  if (opt.section && out.length)
+    out = '[' + safe$1(opt.section) + ']' + eol$1 + out;
 
-  // handle trailing things that only matter at the very end.
-  clearStateChar();
-  if (escaping) {
-    // trailing \\
-    re += '\\\\';
-  }
+  children.forEach(function (k, _, __) {
+    var nk = dotSplit(k).join('\\.');
+    var section = (opt.section ? opt.section + '.' : '') + nk;
+    var child = encode$1(obj[k], {
+      section: section,
+      whitespace: opt.whitespace,
+    });
+    if (out.length && child.length)
+      out += eol$1;
 
-  // only need to apply the nodot start if the re starts with
-  // something that could conceivably capture a dot
-  var addPatternStart = false;
-  switch (re.charAt(0)) {
-    case '.':
-    case '[':
-    case '(': addPatternStart = true;
-  }
+    out += child;
+  });
 
-  // Hack to work around lack of negative lookbehind in JS
-  // A pattern like: *.!(x).!(y|z) needs to ensure that a name
-  // like 'a.xyz.yz' doesn't match.  So, the first negative
-  // lookahead, has to look ALL the way ahead, to the end of
-  // the pattern.
-  for (var n = negativeLists.length - 1; n > -1; n--) {
-    var nl = negativeLists[n];
+  return out
+}
 
-    var nlBefore = re.slice(0, nl.reStart);
-    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
-    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
-    var nlAfter = re.slice(nl.reEnd);
+function dotSplit (str) {
+  return str.replace(/\1/g, '\u0002LITERAL\\1LITERAL\u0002')
+    .replace(/\\\./g, '\u0001')
+    .split(/\./).map(function (part) {
+      return part.replace(/\1/g, '\\.')
+        .replace(/\2LITERAL\\1LITERAL\2/g, '\u0001')
+    })
+}
 
-    nlLast += nlAfter;
+function decode (str) {
+  var out = {};
+  var p = out;
+  var section = null;
+  //          section     |key      = value
+  var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+  var lines = str.split(/[\r\n]+/g);
 
-    // Handle nested stuff like *(*.js|!(*.json)), where open parens
-    // mean that we should *not* include the ) in the bit that is considered
-    // "after" the negated section.
-    var openParensBefore = nlBefore.split('(').length - 1;
-    var cleanAfter = nlAfter;
-    for (i = 0; i < openParensBefore; i++) {
-      cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
+  lines.forEach(function (line, _, __) {
+    if (!line || line.match(/^\s*[;#]/))
+      return
+    var match = line.match(re);
+    if (!match)
+      return
+    if (match[1] !== undefined) {
+      section = unsafe$1(match[1]);
+      if (section === '__proto__') {
+        // not allowed
+        // keep parsing the section, but don't attach it.
+        p = {};
+        return
+      }
+      p = out[section] = out[section] || {};
+      return
+    }
+    var key = unsafe$1(match[2]);
+    if (key === '__proto__')
+      return
+    var value = match[3] ? unsafe$1(match[4]) : true;
+    switch (value) {
+      case 'true':
+      case 'false':
+      case 'null': value = JSON.parse(value);
     }
-    nlAfter = cleanAfter;
 
-    var dollar = '';
-    if (nlAfter === '' && isSub !== SUBPARSE) {
-      dollar = '$';
+    // Convert keys with '[]' suffix to an array
+    if (key.length > 2 && key.slice(-2) === '[]') {
+      key = key.substring(0, key.length - 2);
+      if (key === '__proto__')
+        return
+      if (!p[key])
+        p[key] = [];
+      else if (!Array.isArray(p[key]))
+        p[key] = [p[key]];
     }
-    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
-    re = newRe;
-  }
 
-  // if the re is not "" at this point, then we need to make sure
-  // it doesn't match against an empty path part.
-  // Otherwise a/* will match a/, which it should not.
-  if (re !== '' && hasMagic) {
-    re = '(?=.)' + re;
-  }
+    // safeguard against resetting a previously defined
+    // array by accidentally forgetting the brackets
+    if (Array.isArray(p[key]))
+      p[key].push(value);
+    else
+      p[key] = value;
+  });
 
-  if (addPatternStart) {
-    re = patternStart + re;
-  }
+  // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
+  // use a filter to return the keys that have to be deleted.
+  Object.keys(out).filter(function (k, _, __) {
+    if (!out[k] ||
+      typeof out[k] !== 'object' ||
+      Array.isArray(out[k]))
+      return false
 
-  // parsing just a piece of a larger pattern.
-  if (isSub === SUBPARSE) {
-    return [re, hasMagic]
-  }
+    // see if the parent section is also an object.
+    // if so, add it to that, and mark this one for deletion
+    var parts = dotSplit(k);
+    var p = out;
+    var l = parts.pop();
+    var nl = l.replace(/\\\./g, '.');
+    parts.forEach(function (part, _, __) {
+      if (part === '__proto__')
+        return
+      if (!p[part] || typeof p[part] !== 'object')
+        p[part] = {};
+      p = p[part];
+    });
+    if (p === out && nl === l)
+      return false
 
-  // skip the regexp for non-magical patterns
-  // unescape anything in it, though, so that it'll be
-  // an exact match against a file etc.
-  if (!hasMagic) {
-    return globUnescape(pattern)
-  }
+    p[nl] = out[k];
+    return true
+  }).forEach(function (del, _, __) {
+    delete out[del];
+  });
 
-  var flags = options.nocase ? 'i' : '';
-  try {
-    var regExp = new RegExp('^' + re + '$', flags);
-  } catch (er) {
-    // If it was an invalid regular expression, then it can't match
-    // anything.  This trick looks for a character after the end of
-    // the string, which is of course impossible, except in multi-line
-    // mode, but it's not a /m regex.
-    return new RegExp('$.')
-  }
+  return out
+}
 
-  regExp._glob = pattern;
-  regExp._src = re;
+function isQuoted (val) {
+  return (val.charAt(0) === '"' && val.slice(-1) === '"') ||
+    (val.charAt(0) === "'" && val.slice(-1) === "'")
+}
 
-  return regExp
+function safe$1 (val) {
+  return (typeof val !== 'string' ||
+    val.match(/[=\r\n]/) ||
+    val.match(/^\[/) ||
+    (val.length > 1 &&
+     isQuoted(val)) ||
+    val !== val.trim())
+    ? JSON.stringify(val)
+    : val.replace(/;/g, '\\;').replace(/#/g, '\\#')
 }
 
-minimatch.makeRe = function (pattern, options) {
-  return new Minimatch(pattern, options || {}).makeRe()
-};
+function unsafe$1 (val, doUnesc) {
+  val = (val || '').trim();
+  if (isQuoted(val)) {
+    // remove the single quotes before calling JSON.parse
+    if (val.charAt(0) === "'")
+      val = val.substr(1, val.length - 2);
 
-Minimatch.prototype.makeRe = makeRe;
-function makeRe () {
-  if (this.regexp || this.regexp === false) return this.regexp
+    try {
+      val = JSON.parse(val);
+    } catch (_) {}
+  } else {
+    // walk the val to find the first not-escaped ; character
+    var esc = false;
+    var unesc = '';
+    for (var i = 0, l = val.length; i < l; i++) {
+      var c = val.charAt(i);
+      if (esc) {
+        if ('\\;#'.indexOf(c) !== -1)
+          unesc += c;
+        else
+          unesc += '\\' + c;
 
-  // at this point, this.set is a 2d array of partial
-  // pattern strings, or "**".
-  //
-  // It's better to use .match().  This function shouldn't
-  // be used, really, but it's pretty convenient sometimes,
-  // when you just want to work with a regex.
-  var set = this.set;
+        esc = false;
+      } else if (';#'.indexOf(c) !== -1)
+        break
+      else if (c === '\\')
+        esc = true;
+      else
+        unesc += c;
+    }
+    if (esc)
+      unesc += '\\';
 
-  if (!set.length) {
-    this.regexp = false;
-    return this.regexp
+    return unesc.trim()
   }
-  var options = this.options;
-
-  var twoStar = options.noglobstar ? star
-    : options.dot ? twoStarDot
-    : twoStarNoDot;
-  var flags = options.nocase ? 'i' : '';
+  return val
+}
 
-  var re = set.map(function (pattern) {
-    return pattern.map(function (p) {
-      return (p === GLOBSTAR) ? twoStar
-      : (typeof p === 'string') ? regExpEscape(p)
-      : p._src
-    }).join('\\\/')
-  }).join('|');
+const fs$4 = require$$0$3;
+const figgyPudding = figgyPudding_1;
+const findUp = findUp$1.exports;
+const ini = ini$1;
+const os = require$$0$2;
+const path$5 = path$b;
 
-  // must match entire pattern
-  // ending in a * or ** will make it less strict.
-  re = '^(?:' + re + ')$';
+const NpmConfig = figgyPudding({}, {
+  // Open up the pudding object.
+  other () { return true }
+});
 
-  // can match anything, as long as it's not this.
-  if (this.negate) re = '^(?!' + re + ').*$';
+const ConfigOpts = figgyPudding({
+  cache: { default: path$5.join(os.homedir(), '.npm') },
+  configNames: { default: ['npmrc', '.npmrc'] },
+  envPrefix: { default: /^npm_config_/i },
+  cwd: { default: () => process.cwd() },
+  globalconfig: {
+    default: () => path$5.join(getGlobalPrefix(), 'etc', 'npmrc')
+  },
+  userconfig: { default: path$5.join(os.homedir(), '.npmrc') }
+});
 
-  try {
-    this.regexp = new RegExp(re, flags);
-  } catch (ex) {
-    this.regexp = false;
+libnpmconfig.read = getNpmConfig;
+function getNpmConfig (_opts, _builtin) {
+  const builtin = ConfigOpts(_builtin);
+  const env = {};
+  for (let key of Object.keys(process.env)) {
+    if (!key.match(builtin.envPrefix)) continue
+    const newKey = key.toLowerCase()
+      .replace(builtin.envPrefix, '')
+      .replace(/(?!^)_/g, '-');
+    env[newKey] = process.env[key];
+  }
+  const cli = NpmConfig(_opts);
+  const userConfPath = (
+    builtin.userconfig ||
+    cli.userconfig ||
+    env.userconfig
+  );
+  const user = userConfPath && maybeReadIni(userConfPath);
+  const globalConfPath = (
+    builtin.globalconfig ||
+    cli.globalconfig ||
+    env.globalconfig
+  );
+  const global = globalConfPath && maybeReadIni(globalConfPath);
+  const projConfPath = findUp.sync(builtin.configNames, { cwd: builtin.cwd });
+  let proj = {};
+  if (projConfPath && projConfPath !== userConfPath) {
+    proj = maybeReadIni(projConfPath);
+  }
+  const newOpts = NpmConfig(builtin, global, user, proj, env, cli);
+  if (newOpts.cache) {
+    return newOpts.concat({
+      cache: path$5.resolve(
+        (
+          (cli.cache || env.cache)
+            ? builtin.cwd
+            : proj.cache
+              ? path$5.dirname(projConfPath)
+              : user.cache
+                ? path$5.dirname(userConfPath)
+                : global.cache
+                  ? path$5.dirname(globalConfPath)
+                  : path$5.dirname(userConfPath)
+        ),
+        newOpts.cache
+      )
+    })
+  } else {
+    return newOpts
   }
-  return this.regexp
 }
 
-minimatch.match = function (list, pattern, options) {
-  options = options || {};
-  var mm = new Minimatch(pattern, options);
-  list = list.filter(function (f) {
-    return mm.match(f)
-  });
-  if (mm.options.nonull && !list.length) {
-    list.push(pattern);
+function maybeReadIni (f) {
+  let txt;
+  try {
+    txt = fs$4.readFileSync(f, 'utf8');
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return ''
+    } else {
+      throw err
+    }
   }
-  return list
-};
-
-Minimatch.prototype.match = match;
-function match (f, partial) {
-  this.debug('match', f, this.pattern);
-  // short-circuit in the case of busted things.
-  // comments, etc.
-  if (this.comment) return false
-  if (this.empty) return f === ''
-
-  if (f === '/' && partial) return true
-
-  var options = this.options;
+  return ini.parse(txt)
+}
 
-  // windows: need to use /, not \
-  if (path.sep !== '/') {
-    f = f.split(path.sep).join('/');
+function getGlobalPrefix () {
+  if (process.env.PREFIX) {
+    return process.env.PREFIX
+  } else if (process.platform === 'win32') {
+    // c:\node\node.exe --> prefix=c:\node\
+    return path$5.dirname(process.execPath)
+  } else {
+    // /usr/local/bin/node --> prefix=/usr/local
+    let pref = path$5.dirname(path$5.dirname(process.execPath));
+    // destdir only is respected on Unix
+    if (process.env.DESTDIR) {
+      pref = path$5.join(process.env.DESTDIR, pref);
+    }
+    return pref
   }
+}
 
-  // treat the test path as a set of pathparts.
-  f = f.split(slashSplit);
-  this.debug(this.pattern, 'split', f);
+/**
+ * @typedef ResolveOptions
+ * @property {string} [prefix]
+ * @property {string|string[]} [cwd]
+ * @property {boolean} [global]
+ */
 
-  // just ONE of the pattern sets in this.set needs to match
-  // in order for it to be valid.  If negating, then just one
-  // match means that we have failed.
-  // Either way, return on the first hit.
+const electron = process.versions.electron !== undefined;
+const windows = process.platform === 'win32';
 
-  var set = this.set;
-  this.debug(this.pattern, 'set', set);
+const argv = process.argv[1] || /* c8 ignore next */ '';
+const nvm = process.env.NVM_BIN;
+const appData = process.env.APPDATA;
 
-  // Find the basename of the path by looking for the last non-empty segment
-  var filename;
-  var i;
-  for (i = f.length - 1; i >= 0; i--) {
-    filename = f[i];
-    if (filename) break
-  }
+/* c8 ignore next */
+const globalsLibrary = windows ? '' : 'lib';
 
-  for (i = 0; i < set.length; i++) {
-    var pattern = set[i];
-    var file = f;
-    if (options.matchBase && pattern.length === 1) {
-      file = [filename];
-    }
-    var hit = this.matchOne(file, pattern, partial);
-    if (hit) {
-      if (options.flipNegate) return true
-      return !this.negate
-    }
-  }
+/** @type {{prefix?: string}} */
+let builtinNpmConfig;
 
-  // didn't get any hits.  this is success if it's a negative
-  // pattern, failure otherwise.
-  if (options.flipNegate) return false
-  return this.negate
+// The prefix config defaults to the location where node is installed.
+// On Windows, this is in a place called `%AppData%`, which we have to
+// pass to `libnpmconfig` explicitly:
+/* c8 ignore next 4 */
+if (windows && appData) {
+  builtinNpmConfig = {prefix: path$b.join(appData, 'npm')};
 }
 
-// set partial to true to test if, for example,
-// "/a/b" matches the start of "/*/b/*/d"
-// Partial means, if you run out of file before you run
-// out of pattern, then that's fine, as long as all
-// the parts match.
-Minimatch.prototype.matchOne = function (file, pattern, partial) {
-  var options = this.options;
-
-  this.debug('matchOne',
-    { 'this': this, file: file, pattern: pattern });
-
-  this.debug('matchOne', file.length, pattern.length);
+/**
+ * Note: `libnpmconfig` uses `figgy-pudding` which is slated for archival.
+ * Either `libnpmconfig` will switch to an alternative or we’ll have to.
+ * @type {string}
+ */
+let npmPrefix = libnpmconfig.read(null, builtinNpmConfig).prefix;
 
-  for (var fi = 0,
-      pi = 0,
-      fl = file.length,
-      pl = pattern.length
-      ; (fi < fl) && (pi < pl)
-      ; fi++, pi++) {
-    this.debug('matchOne loop');
-    var p = pattern[pi];
-    var f = file[fi];
+// If there is no prefix defined, use the defaults
+// See: <https://github.com/eush77/npm-prefix/blob/master/index.js>
+/* c8 ignore next 5 */
+if (!npmPrefix) {
+  npmPrefix = windows
+    ? path$b.dirname(process.execPath)
+    : path$b.resolve(process.execPath, '../..');
+}
 
-    this.debug(pattern, p, f);
+const globalsDefault = electron || argv.indexOf(npmPrefix) === 0;
+let globalDir = path$b.resolve(npmPrefix, globalsLibrary, 'node_modules');
 
-    // should be impossible.
-    // some invalid regexp stuff in the set.
-    if (p === false) return false
+// If we’re in Electron, we’re running in a modified Node that cannot really
+// install global node modules.
+// To find the actual modules, the user has to set `prefix` somewhere in an
+// `.npmrc` (which is picked up by `libnpmconfig`).
+// Most people don’t do that, and some use NVM instead to manage different
+// versions of Node.
+// Luckily NVM leaks some environment variables that we can pick up on to try
+// and detect the actual modules.
+/* c8 ignore next 3 */
+if (electron && nvm && !require$$0$3.existsSync(globalDir)) {
+  globalDir = path$b.resolve(nvm, '..', globalsLibrary, 'node_modules');
+}
 
-    if (p === GLOBSTAR) {
-      this.debug('GLOBSTAR', [pattern, p, f]);
+/**
+ *  Load the plugin found using `resolvePlugin`.
+ *
+ * @param {string} name The name to import.
+ * @param {LoadOptions} [options]
+ * @returns {Promise<unknown>}
+ */
+async function loadPlugin(name, options = {}) {
+  const {key = 'default', ...rest} = options;
+  const fp = await resolvePlugin(name, rest);
+  /** @type {Object.<string, unknown>} */
+  // Bug with coverage on Node@12.
+  /* c8 ignore next 3 */
+  const mod = await import(pathToFileURL(fp).href);
+  return key === false ? mod : mod[key]
+}
 
-      // "**"
-      // a/**/b/**/c would match the following:
-      // a/b/x/y/z/c
-      // a/x/y/z/b/c
-      // a/b/x/b/x/c
-      // a/b/c
-      // To do this, take the rest of the pattern after
-      // the **, and see if it would match the file remainder.
-      // If so, return success.
-      // If not, the ** "swallows" a segment, and try again.
-      // This is recursively awful.
-      //
-      // a/**/b/**/c matching a/b/x/y/z/c
-      // - a matches a
-      // - doublestar
-      //   - matchOne(b/x/y/z/c, b/**/c)
-      //     - b matches b
-      //     - doublestar
-      //       - matchOne(x/y/z/c, c) -> no
-      //       - matchOne(y/z/c, c) -> no
-      //       - matchOne(z/c, c) -> no
-      //       - matchOne(c, c) yes, hit
-      var fr = fi;
-      var pr = pi + 1;
-      if (pr === pl) {
-        this.debug('** at the end');
-        // a ** at the end will just swallow the rest.
-        // We have found a match.
-        // however, it will not swallow /.x, unless
-        // options.dot is set.
-        // . and .. are *never* matched by **, for explosively
-        // exponential reasons.
-        for (; fi < fl; fi++) {
-          if (file[fi] === '.' || file[fi] === '..' ||
-            (!options.dot && file[fi].charAt(0) === '.')) return false
-        }
-        return true
-      }
+/**
+ * Find a plugin.
+ *
+ * See also:
+ * *   https://docs.npmjs.com/files/folders#node-modules
+ * *   https://github.com/sindresorhus/resolve-from
+ *
+ * Uses the standard node module loading strategy to find `$name` in each given
+ * `cwd` (and optionally the global `node_modules` directory).
+ *
+ * If a prefix is given and `$name` is not a path, `$prefix-$name` is also
+ * searched (preferring these over non-prefixed modules).
+ *
+ * @param {string} name
+ * @param {ResolveOptions} [options]
+ * @returns {Promise.<string>}
+ */
+async function resolvePlugin(name, options = {}) {
+  const prefix = options.prefix
+    ? options.prefix +
+      (options.prefix.charAt(options.prefix.length - 1) === '-' ? '' : '-')
+    : undefined;
+  const cwd = options.cwd;
+  const globals =
+    options.global === undefined || options.global === null
+      ? globalsDefault
+      : options.global;
+  const sources = Array.isArray(cwd) ? cwd.concat() : [cwd || process.cwd()];
+  /** @type {string} */
+  let plugin;
+  /** @type {Error} */
+  let lastError;
 
-      // ok, let's see if we can swallow whatever we can.
-      while (fr < fl) {
-        var swallowee = file[fr];
+  // Non-path.
+  if (name.charAt(0) !== '.') {
+    if (globals) {
+      sources.push(globalDir);
+    }
 
-        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
+    let scope = '';
 
-        // XXX remove this slice.  Just pass the start index.
-        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-          this.debug('globstar found match!', fr, fl, swallowee);
-          // found a match.
-          return true
-        } else {
-          // can't swallow "." or ".." ever.
-          // can only swallow ".foo" when explicitly asked.
-          if (swallowee === '.' || swallowee === '..' ||
-            (!options.dot && swallowee.charAt(0) === '.')) {
-            this.debug('dot detected!', file, fr, pattern, pr);
-            break
-          }
+    // Unprefix module.
+    if (prefix) {
+      // Scope?
+      if (name.charAt(0) === '@') {
+        const slash = name.indexOf('/');
 
-          // ** swallows a segment, and continue.
-          this.debug('globstar swallow a segment, and continue');
-          fr++;
+        // Let’s keep the algorithm simple.
+        // No need to care if this is a “valid” scope (I think?).
+        // But we do check for the slash.
+        if (slash !== -1) {
+          scope = name.slice(0, slash + 1);
+          name = name.slice(slash + 1);
         }
       }
 
-      // no match was found.
-      // However, in partial mode, we can't say this is necessarily over.
-      // If there's more *pattern* left, then
-      if (partial) {
-        // ran out of file
-        this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
-        if (fr === fl) return true
+      if (name.slice(0, prefix.length) !== prefix) {
+        plugin = scope + prefix + name;
       }
-      return false
-    }
 
-    // something other than **
-    // non-magic patterns just have to match exactly
-    // patterns with magic have been turned into regexps.
-    var hit;
-    if (typeof p === 'string') {
-      if (options.nocase) {
-        hit = f.toLowerCase() === p.toLowerCase();
-      } else {
-        hit = f === p;
-      }
-      this.debug('string match', p, f, hit);
-    } else {
-      hit = f.match(p);
-      this.debug('pattern match', p, f, hit);
+      name = scope + name;
     }
-
-    if (!hit) return false
   }
 
-  // Note: ending in / means that we'll get a final ""
-  // at the end of the pattern.  This can only match a
-  // corresponding "" at the end of the file.
-  // If the file ends in /, then it can only match a
-  // a pattern that ends in /, unless the pattern just
-  // doesn't have any more for it. But, a/b/ should *not*
-  // match "a/b/*", even though "" matches against the
-  // [^/]*? pattern, except in partial mode, where it might
-  // simply not be reached yet.
-  // However, a/b/ should still satisfy a/*
-
-  // now either we fell off the end of the pattern, or we're done.
-  if (fi === fl && pi === pl) {
-    // ran out of pattern and filename at the same time.
-    // an exact hit!
-    return true
-  } else if (fi === fl) {
-    // ran out of file, but still had pattern left.
-    // this is ok if we're doing the match as part of
-    // a glob fs traversal.
-    return partial
-  } else if (pi === pl) {
-    // ran out of pattern, still have file left.
-    // this is only acceptable if we're on the very last
-    // empty segment of a file with a trailing slash.
-    // a/* should match a/b/
-    var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');
-    return emptyFileEnd
-  }
+  let index = -1;
+  /** @type {string} */
+  let fp;
 
-  // should be unreachable.
-  throw new Error('wtf?')
-};
+  while (++index < sources.length) {
+    fp = plugin && (await attempt(sources[index], plugin));
+    if (fp) return fp
 
-// replace stuff like \* with *
-function globUnescape (s) {
-  return s.replace(/\\(.)/g, '$1')
-}
+    fp = await attempt(sources[index], name);
+    if (fp) return fp
+  }
 
-function regExpEscape (s) {
-  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
-}
+  // There’s always an error.
+  // Bug with coverage on Node@12.
+  /* c8 ignore next 8 */
+  throw lastError
 
-var inherits_browser = createCommonjsModule(function (module) {
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  module.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor;
-      ctor.prototype = Object.create(superCtor.prototype, {
-        constructor: {
-          value: ctor,
-          enumerable: false,
-          writable: true,
-          configurable: true
-        }
-      });
-    }
-  };
-} else {
-  // old school shim for old browsers
-  module.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor;
-      var TempCtor = function () {};
-      TempCtor.prototype = superCtor.prototype;
-      ctor.prototype = new TempCtor();
-      ctor.prototype.constructor = ctor;
+  /**
+   * @param {string} base
+   * @param {string} name
+   * @returns {Promise<string>}
+   */
+  async function attempt(base, name) {
+    try {
+      // `import-meta-resolve` resolves from files, whereas `load-plugin` works
+      // on folders, which is why we add a `/` at the end.
+      return fileURLToPath(
+        await resolve(name, pathToFileURL(base).href + '/')
+      )
+      // Bug with coverage on Node@12.
+      /* c8 ignore next 1 */
+    } catch (error) {
+      lastError = error;
     }
-  };
-}
-});
-
-var inherits = createCommonjsModule(function (module) {
-try {
-  var util = util$2;
-  /* istanbul ignore next */
-  if (typeof util.inherits !== 'function') throw '';
-  module.exports = util.inherits;
-} catch (e) {
-  /* istanbul ignore next */
-  module.exports = inherits_browser;
-}
-});
-
-function posix(path) {
-	return path.charAt(0) === '/';
-}
-
-function win32(path) {
-	// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
-	var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
-	var result = splitDeviceRe.exec(path);
-	var device = result[1] || '';
-	var isUnc = Boolean(device && device.charAt(1) !== ':');
-
-	// UNC paths are always absolute
-	return Boolean(result[2] || isUnc);
+  }
 }
 
-var pathIsAbsolute = process.platform === 'win32' ? win32 : posix;
-var posix_1 = posix;
-var win32_1 = win32;
-pathIsAbsolute.posix = posix_1;
-pathIsAbsolute.win32 = win32_1;
-
-var alphasort_1 = alphasort;
-var alphasorti_1 = alphasorti;
-var setopts_1 = setopts;
-var ownProp_1 = ownProp;
-var makeAbs_1 = makeAbs;
-var finish_1 = finish;
-var mark_1 = mark$1;
-var isIgnored_1 = isIgnored;
-var childrenIgnored_1 = childrenIgnored;
+function isPlainObject$1(value) {
+	if (Object.prototype.toString.call(value) !== '[object Object]') {
+		return false;
+	}
 
-function ownProp (obj, field) {
-  return Object.prototype.hasOwnProperty.call(obj, field)
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype;
 }
 
+var format$1 = {exports: {}};
 
+(function (module) {
+(function() {
 
+  //// Export the API
+  var namespace;
 
-var Minimatch$1 = minimatch_1.Minimatch;
-
-function alphasorti (a, b) {
-  return a.toLowerCase().localeCompare(b.toLowerCase())
-}
-
-function alphasort (a, b) {
-  return a.localeCompare(b)
-}
-
-function setupIgnores (self, options) {
-  self.ignore = options.ignore || [];
+  // CommonJS / Node module
+  {
+    namespace = module.exports = format;
+  }
 
-  if (!Array.isArray(self.ignore))
-    self.ignore = [self.ignore];
+  namespace.format = format;
+  namespace.vsprintf = vsprintf;
 
-  if (self.ignore.length) {
-    self.ignore = self.ignore.map(ignoreMap);
+  if (typeof console !== 'undefined' && typeof console.log === 'function') {
+    namespace.printf = printf;
   }
-}
 
-// ignore patterns are always in dot:true mode.
-function ignoreMap (pattern) {
-  var gmatcher = null;
-  if (pattern.slice(-3) === '/**') {
-    var gpattern = pattern.replace(/(\/\*\*)+$/, '');
-    gmatcher = new Minimatch$1(gpattern, { dot: true });
+  function printf(/* ... */) {
+    console.log(format.apply(null, arguments));
   }
 
-  return {
-    matcher: new Minimatch$1(pattern, { dot: true }),
-    gmatcher: gmatcher
+  function vsprintf(fmt, replacements) {
+    return format.apply(null, [fmt].concat(replacements));
   }
-}
-
-function setopts (self, pattern, options) {
-  if (!options)
-    options = {};
 
-  // base-matching: just use globstar for that.
-  if (options.matchBase && -1 === pattern.indexOf("/")) {
-    if (options.noglobstar) {
-      throw new Error("base matching requires globstar")
+  function format(fmt) {
+    var argIndex = 1 // skip initial format argument
+      , args = [].slice.call(arguments)
+      , i = 0
+      , n = fmt.length
+      , result = ''
+      , c
+      , escaped = false
+      , arg
+      , tmp
+      , leadingZero = false
+      , precision
+      , nextArg = function() { return args[argIndex++]; }
+      , slurpNumber = function() {
+          var digits = '';
+          while (/\d/.test(fmt[i])) {
+            digits += fmt[i++];
+            c = fmt[i];
+          }
+          return digits.length > 0 ? parseInt(digits) : null;
+        }
+      ;
+    for (; i < n; ++i) {
+      c = fmt[i];
+      if (escaped) {
+        escaped = false;
+        if (c == '.') {
+          leadingZero = false;
+          c = fmt[++i];
+        }
+        else if (c == '0' && fmt[i + 1] == '.') {
+          leadingZero = true;
+          i += 2;
+          c = fmt[i];
+        }
+        else {
+          leadingZero = true;
+        }
+        precision = slurpNumber();
+        switch (c) {
+        case 'b': // number in binary
+          result += parseInt(nextArg(), 10).toString(2);
+          break;
+        case 'c': // character
+          arg = nextArg();
+          if (typeof arg === 'string' || arg instanceof String)
+            result += arg;
+          else
+            result += String.fromCharCode(parseInt(arg, 10));
+          break;
+        case 'd': // number in decimal
+          result += parseInt(nextArg(), 10);
+          break;
+        case 'f': // floating point number
+          tmp = String(parseFloat(nextArg()).toFixed(precision || 6));
+          result += leadingZero ? tmp : tmp.replace(/^0/, '');
+          break;
+        case 'j': // JSON
+          result += JSON.stringify(nextArg());
+          break;
+        case 'o': // number in octal
+          result += '0' + parseInt(nextArg(), 10).toString(8);
+          break;
+        case 's': // string
+          result += nextArg();
+          break;
+        case 'x': // lowercase hexadecimal
+          result += '0x' + parseInt(nextArg(), 10).toString(16);
+          break;
+        case 'X': // uppercase hexadecimal
+          result += '0x' + parseInt(nextArg(), 10).toString(16).toUpperCase();
+          break;
+        default:
+          result += c;
+          break;
+        }
+      } else if (c === '%') {
+        escaped = true;
+      } else {
+        result += c;
+      }
     }
-    pattern = "**/" + pattern;
+    return result;
   }
 
-  self.silent = !!options.silent;
-  self.pattern = pattern;
-  self.strict = options.strict !== false;
-  self.realpath = !!options.realpath;
-  self.realpathCache = options.realpathCache || Object.create(null);
-  self.follow = !!options.follow;
-  self.dot = !!options.dot;
-  self.mark = !!options.mark;
-  self.nodir = !!options.nodir;
-  if (self.nodir)
-    self.mark = true;
-  self.sync = !!options.sync;
-  self.nounique = !!options.nounique;
-  self.nonull = !!options.nonull;
-  self.nosort = !!options.nosort;
-  self.nocase = !!options.nocase;
-  self.stat = !!options.stat;
-  self.noprocess = !!options.noprocess;
-  self.absolute = !!options.absolute;
-
-  self.maxLength = options.maxLength || Infinity;
-  self.cache = options.cache || Object.create(null);
-  self.statCache = options.statCache || Object.create(null);
-  self.symlinks = options.symlinks || Object.create(null);
+}());
+}(format$1));
 
-  setupIgnores(self, options);
+var formatter = format$1.exports;
 
-  self.changedCwd = false;
-  var cwd = process.cwd();
-  if (!ownProp(options, "cwd"))
-    self.cwd = cwd;
-  else {
-    self.cwd = path$1.resolve(options.cwd);
-    self.changedCwd = self.cwd !== cwd;
-  }
+// @ts-ignore
 
-  self.root = options.root || path$1.resolve(self.cwd, "/");
-  self.root = path$1.resolve(self.root);
-  if (process.platform === "win32")
-    self.root = self.root.replace(/\\/g, "/");
+var fault = Object.assign(create$1(Error), {
+  eval: create$1(EvalError),
+  range: create$1(RangeError),
+  reference: create$1(ReferenceError),
+  syntax: create$1(SyntaxError),
+  type: create$1(TypeError),
+  uri: create$1(URIError)
+});
 
-  // TODO: is an absolute `cwd` supposed to be resolved against `root`?
-  // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
-  self.cwdAbs = pathIsAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
-  if (process.platform === "win32")
-    self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
-  self.nomount = !!options.nomount;
+/**
+ * Create a new `EConstructor`, with the formatted `format` as a first argument.
+ *
+ * @template {Error} Fault
+ * @template {new (reason: string) => Fault} Class
+ * @param {Class} Constructor
+ */
+function create$1(Constructor) {
+  /** @type {string} */
+  // @ts-ignore
+  FormattedError.displayName = Constructor.displayName || Constructor.name;
 
-  // disable comments and negation in Minimatch.
-  // Note that they are not supported in Glob itself anyway.
-  options.nonegate = true;
-  options.nocomment = true;
+  return FormattedError
 
-  self.minimatch = new Minimatch$1(pattern, options);
-  self.options = self.minimatch.options;
+  /**
+   * @param {string} [format]
+   * @param {...unknown} values
+   * @returns {Fault}
+   */
+  function FormattedError(format, ...values) {
+    /** @type {string} */
+    var reason = format ? formatter(format, ...values) : format;
+    return new Constructor(reason)
+  }
 }
 
-function finish (self) {
-  var nou = self.nounique;
-  var all = nou ? [] : Object.create(null);
+const debug$b = createDebug('unified-engine:find-up');
 
-  for (var i = 0, l = self.matches.length; i < l; i ++) {
-    var matches = self.matches[i];
-    if (!matches || Object.keys(matches).length === 0) {
-      if (self.nonull) {
-        // do like the shell, and spit out the literal glob
-        var literal = self.minimatch.globSet[i];
-        if (nou)
-          all.push(literal);
-        else
-          all[literal] = true;
-      }
-    } else {
-      // had matches
-      var m = Object.keys(matches);
-      if (nou)
-        all.push.apply(all, m);
-      else
-        m.forEach(function (m) {
-          all[m] = true;
-        });
-    }
-  }
+/**
+ * @template Value
+ */
+class FindUp {
+  /**
+   * @callback Create
+   * @param {Buffer} buf
+   * @param {string} filePath
+   * @returns {Promise<Value|undefined>|Value|undefined}
+   */
 
-  if (!nou)
-    all = Object.keys(all);
+  /**
+   * @callback Callback
+   * @param {Error|null} error
+   * @param {Value} [result]
+   * @returns {void}
+   */
+
+  /**
+   * @typedef Options
+   * @property {string} cwd
+   * @property {string|undefined} filePath
+   * @property {boolean|undefined} [detect]
+   * @property {string[]} names
+   * @property {Create} create
+   */
+
+  /**
+   * @param {Options} options
+   */
+  constructor(options) {
+    /** @type {Record<string, Callback[]|undefined|Error|Value>} */
+    this.cache = {};
+    /** @type {string} */
+    this.cwd = options.cwd;
+    /** @type {boolean|undefined} */
+    this.detect = options.detect;
+    /** @type {string[]} */
+    this.names = options.names;
+    /** @type {Create} */
+    this.create = options.create;
+
+    /** @type {string|undefined} */
+    this.givenFilePath = options.filePath
+      ? path$c.resolve(options.cwd, options.filePath)
+      : undefined;
+
+    /* eslint-disable no-unused-expressions */
+    /** @type {Error|Value|Callback[]|undefined} */
+    this.givenFile;
+    /* eslint-enable no-unused-expressions */
+  }
 
-  if (!self.nosort)
-    all = all.sort(self.nocase ? alphasorti : alphasort);
+  /**
+   * @param {string} filePath
+   * @param {Callback} callback
+   */
+  load(filePath, callback) {
+    const self = this;
+    const givenFile = this.givenFile;
+    const {givenFilePath} = this;
+
+    if (givenFilePath) {
+      if (givenFile) {
+        apply(callback, givenFile);
+      } else {
+        const cbs = [callback];
+        this.givenFile = cbs;
+        debug$b('Checking given file `%s`', givenFilePath);
+        fs$a.readFile(givenFilePath, (error, buf) => {
+          if (error) {
+            /** @type {NodeJS.ErrnoException} */
+            const result = fault(
+              'Cannot read given file `%s`\n%s',
+              path$c.relative(this.cwd, givenFilePath),
+              error.stack
+            );
+            result.code = 'ENOENT';
+            result.path = error.path;
+            result.syscall = error.syscall;
+            loaded(result);
+          } else {
+            wrap(this.create, (error, /** @type {Value} */ result) => {
+              if (error) {
+                debug$b(error.message);
+                loaded(
+                  fault(
+                    'Cannot parse given file `%s`\n%s',
+                    path$c.relative(this.cwd, givenFilePath),
+                    error.stack
+                  )
+                );
+              } else {
+                debug$b('Read given file `%s`', givenFilePath);
+                loaded(result);
+              }
+            })(buf, givenFilePath);
+          }
 
-  // at *some* point we statted all of these
-  if (self.mark) {
-    for (var i = 0; i < all.length; i++) {
-      all[i] = self._mark(all[i]);
-    }
-    if (self.nodir) {
-      all = all.filter(function (e) {
-        var notDir = !(/\/$/.test(e));
-        var c = self.cache[e] || self.cache[makeAbs(self, e)];
-        if (notDir && c)
-          notDir = c !== 'DIR' && !Array.isArray(c);
-        return notDir
-      });
+          /** @param {Error|Value} result */
+          function loaded(result) {
+            self.givenFile = result;
+            applyAll(cbs, result);
+          }
+        });
+      }
+
+      return
     }
-  }
 
-  if (self.ignore.length)
-    all = all.filter(function(m) {
-      return !isIgnored(self, m)
-    });
+    if (!this.detect) {
+      return callback(null)
+    }
 
-  self.found = all;
-}
+    filePath = path$c.resolve(this.cwd, filePath);
+    const parent = path$c.dirname(filePath);
 
-function mark$1 (self, p) {
-  var abs = makeAbs(self, p);
-  var c = self.cache[abs];
-  var m = p;
-  if (c) {
-    var isDir = c === 'DIR' || Array.isArray(c);
-    var slash = p.slice(-1) === '/';
+    if (parent in this.cache) {
+      apply(callback, this.cache[parent]);
+    } else {
+      this.cache[parent] = [callback];
+      find(parent);
+    }
 
-    if (isDir && !slash)
-      m += '/';
-    else if (!isDir && slash)
-      m = m.slice(0, -1);
+    /**
+     * @param {string} directory
+     */
+    function find(directory) {
+      let index = -1;
 
-    if (m !== p) {
-      var mabs = makeAbs(self, m);
-      self.statCache[mabs] = self.statCache[abs];
-      self.cache[mabs] = self.cache[abs];
-    }
-  }
+      next();
 
-  return m
-}
+      function next() {
+        // Try to read the next file.
+        // We do not use `readdir` because on huge directories, that could be
+        // *very* slow.
+        if (++index < self.names.length) {
+          fs$a.readFile(path$c.join(directory, self.names[index]), done);
+        } else {
+          const parent = path$c.dirname(directory);
 
-// lotta situps...
-function makeAbs (self, f) {
-  var abs = f;
-  if (f.charAt(0) === '/') {
-    abs = path$1.join(self.root, f);
-  } else if (pathIsAbsolute(f) || f === '') {
-    abs = f;
-  } else if (self.changedCwd) {
-    abs = path$1.resolve(self.cwd, f);
-  } else {
-    abs = path$1.resolve(f);
-  }
+          if (directory === parent) {
+            debug$b('No files found for `%s`', filePath);
+            found(null);
+          } else if (parent in self.cache) {
+            apply(found, self.cache[parent]);
+          } else {
+            self.cache[parent] = [found];
+            find(parent);
+          }
+        }
+      }
 
-  if (process.platform === 'win32')
-    abs = abs.replace(/\\/g, '/');
+      /**
+       * @param {NodeJS.ErrnoException|null} error
+       * @param {Buffer} [buf]
+       * @returns {void}
+       */
+      function done(error, buf) {
+        const fp = path$c.join(directory, self.names[index]);
 
-  return abs
-}
+        if (error) {
+          // Hard to test.
+          /* c8 ignore next 13 */
+          if (error.code === 'ENOENT') {
+            return next()
+          }
 
+          debug$b(error.message);
+          return found(
+            fault(
+              'Cannot read file `%s`\n%s',
+              path$c.relative(self.cwd, fp),
+              error.message
+            )
+          )
+        }
+
+        wrap(self.create, (error, /** @type {Value} */ result) => {
+          if (error) {
+            found(
+              fault(
+                'Cannot parse file `%s`\n%s',
+                path$c.relative(self.cwd, fp),
+                error.message
+              )
+            );
+          } else if (result) {
+            debug$b('Read file `%s`', fp);
+            found(null, result);
+          } else {
+            next();
+          }
+        })(buf, fp);
+      }
 
-// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
-// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
-function isIgnored (self, path) {
-  if (!self.ignore.length)
-    return false
+      /**
+       * @param {Error|null} error
+       * @param {Value} [result]
+       * @returns {void}
+       */
+      function found(error, result) {
+        /** @type {Callback[]} */
+        // @ts-expect-error: always a list if found.
+        const cbs = self.cache[directory];
+        self.cache[directory] = error || result;
+        applyAll(cbs, error || result);
+      }
+    }
 
-  return self.ignore.some(function(item) {
-    return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
-  })
-}
+    /**
+     * @param {Callback[]} cbs
+     * @param {Value|Error|undefined} result
+     */
+    function applyAll(cbs, result) {
+      let index = cbs.length;
 
-function childrenIgnored (self, path) {
-  if (!self.ignore.length)
-    return false
+      while (index--) {
+        apply(cbs[index], result);
+      }
+    }
 
-  return self.ignore.some(function(item) {
-    return !!(item.gmatcher && item.gmatcher.match(path))
-  })
+    /**
+     * @param {Callback} cb
+     * @param {Value|Error|Callback[]|undefined} result
+     */
+    function apply(cb, result) {
+      if (Array.isArray(result)) {
+        result.push(cb);
+      } else if (result instanceof Error) {
+        cb(result);
+      } else {
+        cb(null, result);
+      }
+    }
+  }
 }
 
-var common$2 = {
-	alphasort: alphasort_1,
-	alphasorti: alphasorti_1,
-	setopts: setopts_1,
-	ownProp: ownProp_1,
-	makeAbs: makeAbs_1,
-	finish: finish_1,
-	mark: mark_1,
-	isIgnored: isIgnored_1,
-	childrenIgnored: childrenIgnored_1
-};
+/**
+ * @typedef {import('unified').Plugin<unknown[]>} Plugin
+ * @typedef {import('unified').PluginTuple<unknown[]>} PluginTuple
+ * @typedef {import('unified').PluggableList} PluggableList
+ *
+ * @typedef {Record<string, unknown>} Settings
+ *
+ * @typedef {Record<string, Settings|null|undefined>} PluginIdObject
+ * @typedef {Array<string|[string, ...unknown[]]>} PluginIdList
+ *
+ * @typedef Preset
+ * @property {Settings} [settings]
+ * @property {PluggableList|PluginIdObject|PluginIdList|undefined} [plugins]
+ *
+ * @typedef Config
+ * @property {Settings} [settings]
+ * @property {Array<PluginTuple>} [plugins]
+ *
+ * @callback ConfigTransform
+ * @param {any} config
+ * @param {string} filePath
+ * @returns {Preset}
+ *
+ * @callback Loader
+ * @param {Buffer} buf
+ * @param {string} filePath
+ * @returns {Promise<Preset|undefined>}
+ *
+ * @callback Callback
+ * @param {Error|null} error
+ * @param {Config} [result]
+ * @returns {void}
+ */
 
-var sync$3 = globSync;
-globSync.GlobSync = GlobSync;
-var setopts$1 = common$2.setopts;
-var ownProp$1 = common$2.ownProp;
-var childrenIgnored$1 = common$2.childrenIgnored;
-var isIgnored$1 = common$2.isIgnored;
+const debug$a = createDebug('unified-engine:configuration');
 
-function globSync (pattern, options) {
-  if (typeof options === 'function' || arguments.length === 3)
-    throw new TypeError('callback provided to sync glob\n'+
-                        'See: https://github.com/isaacs/node-glob/issues/167')
+const own$c = {}.hasOwnProperty;
 
-  return new GlobSync(pattern, options).found
-}
+/** @type {Record<string, Loader>} */
+const loaders = {
+  '.json': loadJson,
+  '.cjs': loadScriptOrModule,
+  '.mjs': loadScriptOrModule,
+  '.js': loadScriptOrModule,
+  '.yaml': loadYaml,
+  '.yml': loadYaml
+};
 
-function GlobSync (pattern, options) {
-  if (!pattern)
-    throw new Error('must provide pattern')
+const defaultLoader = loadJson;
 
-  if (typeof options === 'function' || arguments.length === 3)
-    throw new TypeError('callback provided to sync glob\n'+
-                        'See: https://github.com/isaacs/node-glob/issues/167')
+/**
+ * @typedef Options
+ * @property {string} cwd
+ * @property {string} [packageField]
+ * @property {string} [pluginPrefix]
+ * @property {string} [rcName]
+ * @property {string} [rcPath]
+ * @property {boolean} [detectConfig]
+ * @property {ConfigTransform} [configTransform]
+ * @property {Preset} [defaultConfig]
+ * @property {Preset['settings']} [settings]
+ * @property {Preset['plugins']} [plugins]
+ */
 
-  if (!(this instanceof GlobSync))
-    return new GlobSync(pattern, options)
+class Configuration {
+  /**
+   * @param {Options} options
+   */
+  constructor(options) {
+    /** @type {string[]} */
+    const names = [];
+
+    /** @type {string} */
+    this.cwd = options.cwd;
+    /** @type {string|undefined} */
+    this.packageField = options.packageField;
+    /** @type {string|undefined} */
+    this.pluginPrefix = options.pluginPrefix;
+    /** @type {ConfigTransform|undefined} */
+    this.configTransform = options.configTransform;
+    /** @type {Preset|undefined} */
+    this.defaultConfig = options.defaultConfig;
+
+    if (options.rcName) {
+      names.push(
+        options.rcName,
+        options.rcName + '.js',
+        options.rcName + '.yml',
+        options.rcName + '.yaml'
+      );
+      debug$a('Looking for `%s` configuration files', names);
+    }
 
-  setopts$1(this, pattern, options);
+    if (options.packageField) {
+      names.push('package.json');
+      debug$a(
+        'Looking for `%s` fields in `package.json` files',
+        options.packageField
+      );
+    }
 
-  if (this.noprocess)
-    return this
+    /** @type {Preset} */
+    this.given = {settings: options.settings, plugins: options.plugins};
+    this.create = this.create.bind(this);
 
-  var n = this.minimatch.set.length;
-  this.matches = new Array(n);
-  for (var i = 0; i < n; i ++) {
-    this._process(this.minimatch.set[i], i, false);
+    /** @type {FindUp<Config>} */
+    this.findUp = new FindUp({
+      cwd: options.cwd,
+      filePath: options.rcPath,
+      detect: options.detectConfig,
+      names,
+      create: this.create
+    });
   }
-  this._finish();
-}
 
-GlobSync.prototype._finish = function () {
-  assert(this instanceof GlobSync);
-  if (this.realpath) {
-    var self = this;
-    this.matches.forEach(function (matchset, index) {
-      var set = self.matches[index] = Object.create(null);
-      for (var p in matchset) {
-        try {
-          p = self._makeAbs(p);
-          var real = fs_realpath.realpathSync(p, self.realpathCache);
-          set[real] = true;
-        } catch (er) {
-          if (er.syscall === 'stat')
-            set[self._makeAbs(p)] = true;
-          else
-            throw er
+  /**
+   * @param {string} filePath
+   * @param {Callback} callback
+   * @returns {void}
+   */
+  load(filePath, callback) {
+    this.findUp.load(
+      filePath || path$c.resolve(this.cwd, 'stdin.js'),
+      (error, file) => {
+        if (error || file) {
+          return callback(error, file)
         }
+
+        this.create(undefined, undefined).then((result) => {
+          callback(null, result);
+        }, callback);
       }
-    });
+    );
   }
-  common$2.finish(this);
-};
 
+  /**
+   * @param {Buffer|undefined} buf
+   * @param {string|undefined} filePath
+   * @returns {Promise<Config|undefined>}
+   */
+  async create(buf, filePath) {
+    const options = {prefix: this.pluginPrefix, cwd: this.cwd};
+    const result = {settings: {}, plugins: []};
+    const extname = filePath ? path$c.extname(filePath) : undefined;
+    const loader =
+      extname && extname in loaders ? loaders[extname] : defaultLoader;
+    /** @type {Preset|undefined} */
+    let value;
 
-GlobSync.prototype._process = function (pattern, index, inGlobStar) {
-  assert(this instanceof GlobSync);
+    if (filePath && buf) {
+      value = await loader.call(this, buf, filePath);
 
-  // Get the first [n] parts of pattern that are all strings.
-  var n = 0;
-  while (typeof pattern[n] === 'string') {
-    n ++;
-  }
-  // now n is the index of the first one that is *not* a string.
+      if (this.configTransform && value !== undefined) {
+        value = this.configTransform(value, filePath);
+      }
+    }
 
-  // See if there's anything else
-  var prefix;
-  switch (n) {
-    // if not, then this is rather simple
-    case pattern.length:
-      this._processSimple(pattern.join('/'), index);
+    // Exit if we did find a `package.json`, but it does not have configuration.
+    if (
+      filePath &&
+      value === undefined &&
+      path$c.basename(filePath) === 'package.json'
+    ) {
       return
+    }
 
-    case 0:
-      // pattern *starts* with some non-trivial item.
-      // going to readdir(cwd), but not include the prefix in matches.
-      prefix = null;
-      break
-
-    default:
-      // pattern has some string bits in the front.
-      // whatever it starts with, whether that's 'absolute' like /foo/bar,
-      // or 'relative' like '../baz'
-      prefix = pattern.slice(0, n).join('/');
-      break
-  }
+    if (value === undefined) {
+      if (this.defaultConfig) {
+        await merge(
+          result,
+          this.defaultConfig,
+          Object.assign({}, options, {root: this.cwd})
+        );
+      }
+    } else {
+      await merge(
+        result,
+        value,
+        // @ts-expect-error: `value` can only exist if w/ `filePath`.
+        Object.assign({}, options, {root: path$c.dirname(filePath)})
+      );
+    }
 
-  var remain = pattern.slice(n);
+    await merge(
+      result,
+      this.given,
+      Object.assign({}, options, {root: this.cwd})
+    );
 
-  // get the list of entries.
-  var read;
-  if (prefix === null)
-    read = '.';
-  else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
-    if (!prefix || !pathIsAbsolute(prefix))
-      prefix = '/' + prefix;
-    read = prefix;
-  } else
-    read = prefix;
+    // C8 bug on Node@12
+    /* c8 ignore next 2 */
+    return result
+  }
+}
 
-  var abs = this._makeAbs(read);
+/** @type {Loader} */
+async function loadScriptOrModule(_, filePath) {
+  // C8 bug on Node@12
+  /* c8 ignore next 4 */
+  // @ts-expect-error: Assume it matches config.
+  // type-coverage:ignore-next-line
+  return loadFromAbsolutePath(filePath, this.cwd)
+}
 
-  //if ignored, skip processing
-  if (childrenIgnored$1(this, read))
-    return
+/** @type {Loader} */
+async function loadYaml(buf, filePath) {
+  // C8 bug on Node@12
+  /* c8 ignore next 4 */
+  // @ts-expect-error: Assume it matches config.
+  return jsYaml.load(String(buf), {filename: path$c.basename(filePath)})
+}
 
-  var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
-  if (isGlobStar)
-    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
-  else
-    this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
-};
+/** @type {Loader} */
+async function loadJson(buf, filePath) {
+  /** @type {Record<string, unknown>} */
+  const result = parseJson_1(String(buf), filePath);
 
+  // C8 bug on Node@12
+  /* c8 ignore next 8 */
+  // @ts-expect-error: Assume it matches config.
+  return path$c.basename(filePath) === 'package.json'
+    ? // @ts-expect-error: `this` is the configuration context, TS doesn’t like
+      // `this` on callbacks.
+      // type-coverage:ignore-next-line
+      result[this.packageField]
+    : result
+}
 
-GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
-  var entries = this._readdir(abs, inGlobStar);
+/**
+ * @param {Required<Config>} target
+ * @param {Preset} raw
+ * @param {{root: string, prefix: string|undefined}} options
+ * @returns {Promise<Config>}
+ */
+async function merge(target, raw, options) {
+  if (typeof raw === 'object' && raw !== null) {
+    await addPreset(raw);
+  } else {
+    throw new Error('Expected preset, not `' + raw + '`')
+  }
 
-  // if the abs isn't a dir, then nothing can match!
-  if (!entries)
-    return
+  // C8 bug on Node@12
+  /* c8 ignore next 6 */
+  return target
 
-  // It will only match dot entries if it starts with a dot, or if
-  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
-  var pn = remain[0];
-  var negate = !!this.minimatch.negate;
-  var rawGlob = pn._glob;
-  var dotOk = this.dot || rawGlob.charAt(0) === '.';
+  /**
+   * @param {Preset} result
+   */
+  async function addPreset(result) {
+    const plugins = result.plugins;
 
-  var matchedEntries = [];
-  for (var i = 0; i < entries.length; i++) {
-    var e = entries[i];
-    if (e.charAt(0) !== '.' || dotOk) {
-      var m;
-      if (negate && !prefix) {
-        m = !e.match(pn);
-      } else {
-        m = e.match(pn);
-      }
-      if (m)
-        matchedEntries.push(e);
+    if (plugins === null || plugins === undefined) ; else if (typeof plugins === 'object' && plugins !== null) {
+      await (Array.isArray(plugins) ? addEach(plugins) : addIn(plugins));
+    } else {
+      throw new Error(
+        'Expected a list or object of plugins, not `' + plugins + '`'
+      )
     }
+
+    target.settings = Object.assign({}, target.settings, result.settings);
+    // C8 bug on Node@12
+    /* c8 ignore next 6 */
   }
 
-  var len = matchedEntries.length;
-  // If there are no matched entries, then nothing matches.
-  if (len === 0)
-    return
+  /**
+   * @param {PluginIdList|PluggableList} result
+   */
+  async function addEach(result) {
+    let index = -1;
 
-  // if this is the last remaining pattern bit, then no need for
-  // an additional stat *unless* the user has specified mark or
-  // stat explicitly.  We know they exist, since readdir returned
-  // them.
+    while (++index < result.length) {
+      const value = result[index];
 
-  if (remain.length === 1 && !this.mark && !this.stat) {
-    if (!this.matches[index])
-      this.matches[index] = Object.create(null);
+      // Keep order sequential instead of parallel.
+      /* eslint-disable no-await-in-loop */
+      // @ts-expect-error: Spreading is fine.
+      // type-coverage:ignore-next-line
+      await (Array.isArray(value) ? use(...value) : use(value, undefined));
+      /* eslint-enable no-await-in-loop */
+    }
+    // C8 bug on Node@12
+    /* c8 ignore next 6 */
+  }
 
-    for (var i = 0; i < len; i ++) {
-      var e = matchedEntries[i];
-      if (prefix) {
-        if (prefix.slice(-1) !== '/')
-          e = prefix + '/' + e;
-        else
-          e = prefix + e;
-      }
+  /**
+   * @param {PluginIdObject} result
+   */
+  async function addIn(result) {
+    /** @type {string} */
+    let key;
 
-      if (e.charAt(0) === '/' && !this.nomount) {
-        e = path$1.join(this.root, e);
+    for (key in result) {
+      if (own$c.call(result, key)) {
+        // Keep order sequential instead of parallel.
+        // eslint-disable-next-line no-await-in-loop
+        await use(key, result[key]);
       }
-      this._emitMatch(index, e);
     }
-    // This was the last one, and no stats were needed
-    return
+    // C8 bug on Node@12
+    /* c8 ignore next 7 */
   }
 
-  // now test all matched entries as stand-ins for that part
-  // of the pattern.
-  remain.shift();
-  for (var i = 0; i < len; i ++) {
-    var e = matchedEntries[i];
-    var newPattern;
-    if (prefix)
-      newPattern = [prefix, e];
-    else
-      newPattern = [e];
-    this._process(newPattern.concat(remain), index, inGlobStar);
+  /**
+   * @param {string|Plugin|Preset} usable
+   * @param {Settings|null|undefined} value
+   */
+  async function use(usable, value) {
+    if (typeof usable === 'string') {
+      await addModule(usable, value);
+    } else if (typeof usable === 'function') {
+      addPlugin(usable, value);
+    } else {
+      await merge(target, usable, options);
+    }
+    // C8 bug on Node@12
+    /* c8 ignore next 7 */
   }
-};
 
+  /**
+   * @param {string} id
+   * @param {Settings|null|undefined} value
+   */
+  async function addModule(id, value) {
+    /** @type {string} */
+    let fp;
 
-GlobSync.prototype._emitMatch = function (index, e) {
-  if (isIgnored$1(this, e))
-    return
-
-  var abs = this._makeAbs(e);
+    try {
+      fp = await resolvePlugin(id, {
+        cwd: options.root,
+        prefix: options.prefix
+      });
+    } catch (error) {
+      addPlugin(() => {
+        throw fault('Could not find module `%s`\n%s', id, error.stack)
+      }, value);
+      return
+    }
 
-  if (this.mark)
-    e = this._mark(e);
+    const result = await loadFromAbsolutePath(fp, options.root);
 
-  if (this.absolute) {
-    e = abs;
+    try {
+      if (typeof result === 'function') {
+        addPlugin(result, value);
+      } else {
+        await merge(
+          target,
+          result,
+          Object.assign({}, options, {root: path$c.dirname(fp)})
+        );
+      }
+    } catch {
+      throw fault(
+        'Error: Expected preset or plugin, not %s, at `%s`',
+        result,
+        path$c.relative(options.root, fp)
+      )
+    }
+    // C8 bug on Node@12
+    /* c8 ignore next 8 */
   }
 
-  if (this.matches[index][e])
-    return
+  /**
+   * @param {Plugin} plugin
+   * @param {Settings|null|undefined} value
+   * @returns {void}
+   */
+  function addPlugin(plugin, value) {
+    const entry = find(target.plugins, plugin);
 
-  if (this.nodir) {
-    var c = this.cache[abs];
-    if (c === 'DIR' || Array.isArray(c))
-      return
+    if (value === null) {
+      value = undefined;
+    }
+
+    if (entry) {
+      reconfigure(entry, value);
+    } else {
+      target.plugins.push([plugin, value]);
+    }
   }
+}
 
-  this.matches[index][e] = true;
+/**
+ * @param {PluginTuple} entry
+ * @param {Settings|undefined} value
+ * @returns {void}
+ */
+function reconfigure(entry, value) {
+  if (isPlainObject$1(entry[1]) && isPlainObject$1(value)) {
+    value = Object.assign({}, entry[1], value);
+  }
 
-  if (this.stat)
-    this._stat(e);
-};
+  entry[1] = value;
+}
 
+/**
+ * @param {Array<PluginTuple>} entries
+ * @param {Plugin} plugin
+ * @returns {PluginTuple|undefined}
+ */
+function find(entries, plugin) {
+  let index = -1;
 
-GlobSync.prototype._readdirInGlobStar = function (abs) {
-  // follow all symlinked directories forever
-  // just proceed as if this is a non-globstar situation
-  if (this.follow)
-    return this._readdir(abs, false)
+  while (++index < entries.length) {
+    const entry = entries[index];
+    if (entry[0] === plugin) {
+      return entry
+    }
+  }
+}
 
-  var entries;
-  var lstat;
+/**
+ * @param {string} fp
+ * @param {string} base
+ * @returns {Promise<Plugin|Preset>}
+ */
+async function loadFromAbsolutePath(fp, base) {
   try {
-    lstat = fs$1.lstatSync(abs);
-  } catch (er) {
-    if (er.code === 'ENOENT') {
-      // lstat failed, doesn't exist
-      return null
+    /** @type {{default?: unknown}} */
+    const result = await import(pathToFileURL$1(fp).href);
+
+    if (!('default' in result)) {
+      throw new Error(
+        'Expected a plugin or preset exported as the default export'
+      )
     }
+
+    // @ts-expect-error: assume plugin/preset.
+    return result.default
+    // C8 bug on Node@12
+    /* c8 ignore next 4 */
+  } catch (error) {
+    throw fault('Cannot import `%s`\n%s', path$c.relative(base, fp), error.stack)
   }
+}
 
-  var isSym = lstat && lstat.isSymbolicLink();
-  this.symlinks[abs] = isSym;
+/**
+ * @typedef {import('./index.js').Settings} Settings
+ */
 
-  // If it's not a symlink or a dir, then it's definitely a regular file.
-  // don't bother doing a readdir in that case.
-  if (!isSym && lstat && !lstat.isDirectory())
-    this.cache[abs] = 'FILE';
-  else
-    entries = this._readdir(abs, false);
+/**
+ * @param {Context} context
+ * @param {Settings} settings
+ */
+function configure$3(context, settings) {
+  context.configuration = new Configuration(settings);
+}
 
-  return entries
-};
+// A simple implementation of make-array
+function makeArray (subject) {
+  return Array.isArray(subject)
+    ? subject
+    : [subject]
+}
 
-GlobSync.prototype._readdir = function (abs, inGlobStar) {
+const EMPTY = '';
+const SPACE = ' ';
+const ESCAPE = '\\';
+const REGEX_TEST_BLANK_LINE = /^\s+$/;
+const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+const REGEX_SPLITALL_CRLF = /\r?\n/g;
+// /foo,
+// ./foo,
+// ../foo,
+// .
+// ..
+const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
 
-  if (inGlobStar && !ownProp$1(this.symlinks, abs))
-    return this._readdirInGlobStar(abs)
+const SLASH = '/';
+const KEY_IGNORE = typeof Symbol !== 'undefined'
+  ? Symbol.for('node-ignore')
+  /* istanbul ignore next */
+  : 'node-ignore';
 
-  if (ownProp$1(this.cache, abs)) {
-    var c = this.cache[abs];
-    if (!c || c === 'FILE')
-      return null
+const define = (object, key, value) =>
+  Object.defineProperty(object, key, {value});
 
-    if (Array.isArray(c))
-      return c
-  }
+const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
 
-  try {
-    return this._readdirEntries(abs, fs$1.readdirSync(abs))
-  } catch (er) {
-    this._readdirError(abs, er);
-    return null
-  }
+// Sanitize the range of a regular expression
+// The cases are complicated, see test cases for details
+const sanitizeRange = range => range.replace(
+  REGEX_REGEXP_RANGE,
+  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
+    ? match
+    // Invalid range (out of order) which is ok for gitignore rules but
+    //   fatal for JavaScript regular expression, so eliminate it.
+    : EMPTY
+);
+
+// See fixtures #59
+const cleanRangeBackSlash = slashes => {
+  const {length} = slashes;
+  return slashes.slice(0, length - length % 2)
 };
 
-GlobSync.prototype._readdirEntries = function (abs, entries) {
-  // if we haven't asked to stat everything, then just
-  // assume that everything in there exists, so we can avoid
-  // having to stat it a second time.
-  if (!this.mark && !this.stat) {
-    for (var i = 0; i < entries.length; i ++) {
-      var e = entries[i];
-      if (abs === '/')
-        e = abs + e;
-      else
-        e = abs + '/' + e;
-      this.cache[e] = true;
-    }
-  }
+// > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// >  (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+//      you could use option `mark: true` with `glob`
+
+// '`foo/`' should not continue with the '`..`'
+const REPLACERS = [
+
+  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+  [
+    // (a\ ) -> (a )
+    // (a  ) -> (a)
+    // (a \ ) -> (a  )
+    /\\?\s+$/,
+    match => match.indexOf('\\') === 0
+      ? SPACE
+      : EMPTY
+  ],
+
+  // replace (\ ) with ' '
+  [
+    /\\\s/g,
+    () => SPACE
+  ],
+
+  // Escape metacharacters
+  // which is written down by users but means special for regular expressions.
+
+  // > There are 12 characters with special meanings:
+  // > - the backslash \,
+  // > - the caret ^,
+  // > - the dollar sign $,
+  // > - the period or dot .,
+  // > - the vertical bar or pipe symbol |,
+  // > - the question mark ?,
+  // > - the asterisk or star *,
+  // > - the plus sign +,
+  // > - the opening parenthesis (,
+  // > - the closing parenthesis ),
+  // > - and the opening square bracket [,
+  // > - the opening curly brace {,
+  // > These special characters are often called "metacharacters".
+  [
+    /[\\$.|*+(){^]/g,
+    match => `\\${match}`
+  ],
 
-  this.cache[abs] = entries;
+  [
+    // > a question mark (?) matches a single character
+    /(?!\\)\?/g,
+    () => '[^/]'
+  ],
 
-  // mark and cache dir-ness
-  return entries
-};
+  // leading slash
+  [
 
-GlobSync.prototype._readdirError = function (f, er) {
-  // handle errors, and cache the information
-  switch (er.code) {
-    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
-    case 'ENOTDIR': // totally normal. means it *does* exist.
-      var abs = this._makeAbs(f);
-      this.cache[abs] = 'FILE';
-      if (abs === this.cwdAbs) {
-        var error = new Error(er.code + ' invalid cwd ' + this.cwd);
-        error.path = this.cwd;
-        error.code = er.code;
-        throw error
-      }
-      break
+    // > A leading slash matches the beginning of the pathname.
+    // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+    // A leading slash matches the beginning of the pathname
+    /^\//,
+    () => '^'
+  ],
 
-    case 'ENOENT': // not terribly unusual
-    case 'ELOOP':
-    case 'ENAMETOOLONG':
-    case 'UNKNOWN':
-      this.cache[this._makeAbs(f)] = false;
-      break
+  // replace special metacharacter slash after the leading slash
+  [
+    /\//g,
+    () => '\\/'
+  ],
 
-    default: // some unusual error.  Treat as failure.
-      this.cache[this._makeAbs(f)] = false;
-      if (this.strict)
-        throw er
-      if (!this.silent)
-        console.error('glob error', er);
-      break
-  }
-};
+  [
+    // > A leading "**" followed by a slash means match in all directories.
+    // > For example, "**/foo" matches file or directory "foo" anywhere,
+    // > the same as pattern "foo".
+    // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+    // >   under directory "foo".
+    // Notice that the '*'s have been replaced as '\\*'
+    /^\^*\\\*\\\*\\\//,
 
-GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
+    // '**/foo' <-> 'foo'
+    () => '^(?:.*\\/)?'
+  ],
 
-  var entries = this._readdir(abs, inGlobStar);
+  // starting
+  [
+    // there will be no leading '/'
+    //   (which has been replaced by section "leading slash")
+    // If starts with '**', adding a '^' to the regular expression also works
+    /^(?=[^^])/,
+    function startingReplacer () {
+      // If has a slash `/` at the beginning or middle
+      return !/\/(?!$)/.test(this)
+        // > Prior to 2.22.1
+        // > If the pattern does not contain a slash /,
+        // >   Git treats it as a shell glob pattern
+        // Actually, if there is only a trailing slash,
+        //   git also treats it as a shell glob pattern
 
-  // no entries means not a dir, so it can never have matches
-  // foo.txt/** doesn't match foo.txt
-  if (!entries)
-    return
+        // After 2.22.1 (compatible but clearer)
+        // > If there is a separator at the beginning or middle (or both)
+        // > of the pattern, then the pattern is relative to the directory
+        // > level of the particular .gitignore file itself.
+        // > Otherwise the pattern may also match at any level below
+        // > the .gitignore level.
+        ? '(?:^|\\/)'
 
-  // test without the globstar, and with every child both below
-  // and replacing the globstar.
-  var remainWithoutGlobStar = remain.slice(1);
-  var gspref = prefix ? [ prefix ] : [];
-  var noGlobStar = gspref.concat(remainWithoutGlobStar);
+        // > Otherwise, Git treats the pattern as a shell glob suitable for
+        // >   consumption by fnmatch(3)
+        : '^'
+    }
+  ],
 
-  // the noGlobStar pattern exits the inGlobStar state
-  this._process(noGlobStar, index, false);
+  // two globstars
+  [
+    // Use lookahead assertions so that we could match more than one `'/**'`
+    /\\\/\\\*\\\*(?=\\\/|$)/g,
 
-  var len = entries.length;
-  var isSym = this.symlinks[abs];
+    // Zero, one or several directories
+    // should not use '*', or it will be replaced by the next replacer
 
-  // If it's a symlink, and we're in a globstar, then stop
-  if (isSym && inGlobStar)
-    return
+    // Check if it is not the last `'/**'`
+    (_, index, str) => index + 6 < str.length
 
-  for (var i = 0; i < len; i++) {
-    var e = entries[i];
-    if (e.charAt(0) === '.' && !this.dot)
-      continue
+      // case: /**/
+      // > A slash followed by two consecutive asterisks then a slash matches
+      // >   zero or more directories.
+      // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+      // '/**/'
+      ? '(?:\\/[^\\/]+)*'
 
-    // these two cases enter the inGlobStar state
-    var instead = gspref.concat(entries[i], remainWithoutGlobStar);
-    this._process(instead, index, true);
+      // case: /**
+      // > A trailing `"/**"` matches everything inside.
 
-    var below = gspref.concat(entries[i], remain);
-    this._process(below, index, true);
-  }
-};
+      // #21: everything inside but it should not include the current folder
+      : '\\/.+'
+  ],
 
-GlobSync.prototype._processSimple = function (prefix, index) {
-  // XXX review this.  Shouldn't it be doing the mounting etc
-  // before doing stat?  kinda weird?
-  var exists = this._stat(prefix);
+  // intermediate wildcards
+  [
+    // Never replace escaped '*'
+    // ignore rule '\*' will match the path '*'
 
-  if (!this.matches[index])
-    this.matches[index] = Object.create(null);
+    // 'abc.*/' -> go
+    // 'abc.*'  -> skip this rule
+    /(^|[^\\]+)\\\*(?=.+)/g,
 
-  // If it doesn't exist, then just mark the lack of results
-  if (!exists)
-    return
+    // '*.js' matches '.js'
+    // '*.js' doesn't match 'abc'
+    (_, p1) => `${p1}[^\\/]*`
+  ],
 
-  if (prefix && pathIsAbsolute(prefix) && !this.nomount) {
-    var trail = /[\/\\]$/.test(prefix);
-    if (prefix.charAt(0) === '/') {
-      prefix = path$1.join(this.root, prefix);
-    } else {
-      prefix = path$1.resolve(this.root, prefix);
-      if (trail)
-        prefix += '/';
-    }
-  }
+  [
+    // unescape, revert step 3 except for back slash
+    // For example, if a user escape a '\\*',
+    // after step 3, the result will be '\\\\\\*'
+    /\\\\\\(?=[$.|*+(){^])/g,
+    () => ESCAPE
+  ],
 
-  if (process.platform === 'win32')
-    prefix = prefix.replace(/\\/g, '/');
+  [
+    // '\\\\' -> '\\'
+    /\\\\/g,
+    () => ESCAPE
+  ],
 
-  // Mark this as a match
-  this._emitMatch(index, prefix);
-};
+  [
+    // > The range notation, e.g. [a-zA-Z],
+    // > can be used to match one of the characters in a range.
+
+    // `\` is escaped by step 3
+    /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+    (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE
+      // '\\[bar]' -> '\\\\[bar\\]'
+      ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`
+      : close === ']'
+        ? endEscape.length % 2 === 0
+          // A normal case, and it is a range notation
+          // '[bar]'
+          // '[bar\\\\]'
+          ? `[${sanitizeRange(range)}${endEscape}]`
+          // Invalid range notaton
+          // '[bar\\]' -> '[bar\\\\]'
+          : '[]'
+        : '[]'
+  ],
 
-// Returns either 'DIR', 'FILE', or false
-GlobSync.prototype._stat = function (f) {
-  var abs = this._makeAbs(f);
-  var needDir = f.slice(-1) === '/';
+  // ending
+  [
+    // 'js' will not match 'js.'
+    // 'ab' will not match 'abc'
+    /(?:[^*])$/,
 
-  if (f.length > this.maxLength)
-    return false
+    // WTF!
+    // https://git-scm.com/docs/gitignore
+    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+    // which re-fixes #24, #38
 
-  if (!this.stat && ownProp$1(this.cache, abs)) {
-    var c = this.cache[abs];
+    // > If there is a separator at the end of the pattern then the pattern
+    // > will only match directories, otherwise the pattern can match both
+    // > files and directories.
 
-    if (Array.isArray(c))
-      c = 'DIR';
+    // 'js*' will not match 'a.js'
+    // 'js/' will not match 'a.js'
+    // 'js' will match 'a.js' and 'a.js/'
+    match => /\/$/.test(match)
+      // foo/ will not match 'foo'
+      ? `${match}$`
+      // foo matches 'foo' and 'foo/'
+      : `${match}(?=$|\\/$)`
+  ],
 
-    // It exists, but maybe not how we need it
-    if (!needDir || c === 'DIR')
-      return c
+  // trailing wildcard
+  [
+    /(\^|\\\/)?\\\*$/,
+    (_, p1) => {
+      const prefix = p1
+        // '\^':
+        // '/*' does not match EMPTY
+        // '/*' does not match everything
 
-    if (needDir && c === 'FILE')
-      return false
+        // '\\\/':
+        // 'abc/*' does not match 'abc/'
+        ? `${p1}[^/]+`
 
-    // otherwise we have to stat, because maybe c=true
-    // if we know it exists, but not what it is.
-  }
-  var stat = this.statCache[abs];
-  if (!stat) {
-    var lstat;
-    try {
-      lstat = fs$1.lstatSync(abs);
-    } catch (er) {
-      if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
-        this.statCache[abs] = false;
-        return false
-      }
-    }
+        // 'a*' matches 'a'
+        // 'a*' matches 'aa'
+        : '[^/]*';
 
-    if (lstat && lstat.isSymbolicLink()) {
-      try {
-        stat = fs$1.statSync(abs);
-      } catch (er) {
-        stat = lstat;
-      }
-    } else {
-      stat = lstat;
+      return `${prefix}(?=$|\\/$)`
     }
-  }
-
-  this.statCache[abs] = stat;
-
-  var c = true;
-  if (stat)
-    c = stat.isDirectory() ? 'DIR' : 'FILE';
+  ],
+];
 
-  this.cache[abs] = this.cache[abs] || c;
+// A simple cache, because an ignore rule only has only one certain meaning
+const regexCache = Object.create(null);
 
-  if (needDir && c === 'FILE')
-    return false
+// @param {pattern}
+const makeRegex = (pattern, negative, ignorecase) => {
+  const r = regexCache[pattern];
+  if (r) {
+    return r
+  }
 
-  return c
-};
+  // const replacers = negative
+  //   ? NEGATIVE_REPLACERS
+  //   : POSITIVE_REPLACERS
 
-GlobSync.prototype._mark = function (p) {
-  return common$2.mark(this, p)
-};
+  const source = REPLACERS.reduce(
+    (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+    pattern
+  );
 
-GlobSync.prototype._makeAbs = function (f) {
-  return common$2.makeAbs(this, f)
+  return regexCache[pattern] = ignorecase
+    ? new RegExp(source, 'i')
+    : new RegExp(source)
 };
 
-// Returns a wrapper function that returns a wrapped callback
-// The wrapper function should do some stuff, and return a
-// presumably different callback function.
-// This makes sure that own properties are retained, so that
-// decorations and such are not lost along the way.
-var wrappy_1 = wrappy;
-function wrappy (fn, cb) {
-  if (fn && cb) return wrappy(fn)(cb)
+const isString = subject => typeof subject === 'string';
 
-  if (typeof fn !== 'function')
-    throw new TypeError('need wrapper function')
+// > A blank line matches no files, so it can serve as a separator for readability.
+const checkPattern = pattern => pattern
+  && isString(pattern)
+  && !REGEX_TEST_BLANK_LINE.test(pattern)
 
-  Object.keys(fn).forEach(function (k) {
-    wrapper[k] = fn[k];
-  });
+  // > A line starting with # serves as a comment.
+  && pattern.indexOf('#') !== 0;
 
-  return wrapper
+const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF);
 
-  function wrapper() {
-    var args = new Array(arguments.length);
-    for (var i = 0; i < args.length; i++) {
-      args[i] = arguments[i];
-    }
-    var ret = fn.apply(this, args);
-    var cb = args[args.length-1];
-    if (typeof ret === 'function' && ret !== cb) {
-      Object.keys(cb).forEach(function (k) {
-        ret[k] = cb[k];
-      });
-    }
-    return ret
+class IgnoreRule {
+  constructor (
+    origin,
+    pattern,
+    negative,
+    regex
+  ) {
+    this.origin = origin;
+    this.pattern = pattern;
+    this.negative = negative;
+    this.regex = regex;
   }
 }
 
-var once_1 = wrappy_1(once);
-var strict = wrappy_1(onceStrict);
-
-once.proto = once(function () {
-  Object.defineProperty(Function.prototype, 'once', {
-    value: function () {
-      return once(this)
-    },
-    configurable: true
-  });
-
-  Object.defineProperty(Function.prototype, 'onceStrict', {
-    value: function () {
-      return onceStrict(this)
-    },
-    configurable: true
-  });
-});
+const createRule = (pattern, ignorecase) => {
+  const origin = pattern;
+  let negative = false;
 
-function once (fn) {
-  var f = function () {
-    if (f.called) return f.value
-    f.called = true;
-    return f.value = fn.apply(this, arguments)
-  };
-  f.called = false;
-  return f
-}
+  // > An optional prefix "!" which negates the pattern;
+  if (pattern.indexOf('!') === 0) {
+    negative = true;
+    pattern = pattern.substr(1);
+  }
 
-function onceStrict (fn) {
-  var f = function () {
-    if (f.called)
-      throw new Error(f.onceError)
-    f.called = true;
-    return f.value = fn.apply(this, arguments)
-  };
-  var name = fn.name || 'Function wrapped with `once`';
-  f.onceError = name + " shouldn't be called more than once";
-  f.called = false;
-  return f
-}
-once_1.strict = strict;
+  pattern = pattern
+  // > Put a backslash ("\") in front of the first "!" for patterns that
+  // >   begin with a literal "!", for example, `"\!important!.txt"`.
+  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
+  // > Put a backslash ("\") in front of the first hash for patterns that
+  // >   begin with a hash.
+  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#');
 
-var reqs = Object.create(null);
+  const regex = makeRegex(pattern, negative, ignorecase);
 
+  return new IgnoreRule(
+    origin,
+    pattern,
+    negative,
+    regex
+  )
+};
 
-var inflight_1 = wrappy_1(inflight);
+const throwError = (message, Ctor) => {
+  throw new Ctor(message)
+};
 
-function inflight (key, cb) {
-  if (reqs[key]) {
-    reqs[key].push(cb);
-    return null
-  } else {
-    reqs[key] = [cb];
-    return makeres(key)
+const checkPath = (path, originalPath, doThrow) => {
+  if (!isString(path)) {
+    return doThrow(
+      `path must be a string, but got \`${originalPath}\``,
+      TypeError
+    )
   }
-}
 
-function makeres (key) {
-  return once_1(function RES () {
-    var cbs = reqs[key];
-    var len = cbs.length;
-    var args = slice$2(arguments);
+  // We don't know if we should ignore EMPTY, so throw
+  if (!path) {
+    return doThrow(`path must not be empty`, TypeError)
+  }
 
-    // XXX It's somewhat ambiguous whether a new callback added in this
-    // pass should be queued for later execution if something in the
-    // list of callbacks throws, or if it should just be discarded.
-    // However, it's such an edge case that it hardly matters, and either
-    // choice is likely as surprising as the other.
-    // As it happens, we do go ahead and schedule it for later execution.
-    try {
-      for (var i = 0; i < len; i++) {
-        cbs[i].apply(null, args);
-      }
-    } finally {
-      if (cbs.length > len) {
-        // added more in the interim.
-        // de-zalgo, just in case, but don't call again.
-        cbs.splice(0, len);
-        process.nextTick(function () {
-          RES.apply(null, args);
-        });
-      } else {
-        delete reqs[key];
-      }
-    }
-  })
-}
+  // Check if it is a relative path
+  if (checkPath.isNotRelative(path)) {
+    const r = '`path.relative()`d';
+    return doThrow(
+      `path should be a ${r} string, but got "${originalPath}"`,
+      RangeError
+    )
+  }
 
-function slice$2 (args) {
-  var length = args.length;
-  var array = [];
+  return true
+};
 
-  for (var i = 0; i < length; i++) array[i] = args[i];
-  return array
-}
+const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path);
 
-// Approach:
-//
-// 1. Get the minimatch set
-// 2. For each pattern in the set, PROCESS(pattern, false)
-// 3. Store matches per-set, then uniq them
-//
-// PROCESS(pattern, inGlobStar)
-// Get the first [n] items from pattern that are all strings
-// Join these together.  This is PREFIX.
-//   If there is no more remaining, then stat(PREFIX) and
-//   add to matches if it succeeds.  END.
-//
-// If inGlobStar and PREFIX is symlink and points to dir
-//   set ENTRIES = []
-// else readdir(PREFIX) as ENTRIES
-//   If fail, END
-//
-// with ENTRIES
-//   If pattern[n] is GLOBSTAR
-//     // handle the case where the globstar match is empty
-//     // by pruning it out, and testing the resulting pattern
-//     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
-//     // handle other cases.
-//     for ENTRY in ENTRIES (not dotfiles)
-//       // attach globstar + tail onto the entry
-//       // Mark that this entry is a globstar match
-//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
-//
-//   else // not globstar
-//     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
-//       Test ENTRY against pattern[n]
-//       If fails, continue
-//       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
-//
-// Caveat:
-//   Cache all stats and readdirs results to minimize syscall.  Since all
-//   we ever care about is existence and directory-ness, we can just keep
-//   `true` for files, and [children,...] for directories, or `false` for
-//   things that don't exist.
+checkPath.isNotRelative = isNotRelative;
+checkPath.convert = p => p;
 
-var glob_1 = glob;
+class Ignore$1 {
+  constructor ({
+    ignorecase = true
+  } = {}) {
+    this._rules = [];
+    this._ignorecase = ignorecase;
+    define(this, KEY_IGNORE, true);
+    this._initCache();
+  }
 
-var EE = events.EventEmitter;
-var setopts$2 = common$2.setopts;
-var ownProp$2 = common$2.ownProp;
+  _initCache () {
+    this._ignoreCache = Object.create(null);
+    this._testCache = Object.create(null);
+  }
 
+  _addPattern (pattern) {
+    // #32
+    if (pattern && pattern[KEY_IGNORE]) {
+      this._rules = this._rules.concat(pattern._rules);
+      this._added = true;
+      return
+    }
 
-var childrenIgnored$2 = common$2.childrenIgnored;
-var isIgnored$2 = common$2.isIgnored;
+    if (checkPattern(pattern)) {
+      const rule = createRule(pattern, this._ignorecase);
+      this._added = true;
+      this._rules.push(rule);
+    }
+  }
 
+  // @param {Array<string> | string | Ignore} pattern
+  add (pattern) {
+    this._added = false;
 
+    makeArray(
+      isString(pattern)
+        ? splitPattern(pattern)
+        : pattern
+    ).forEach(this._addPattern, this);
 
-function glob (pattern, options, cb) {
-  if (typeof options === 'function') cb = options, options = {};
-  if (!options) options = {};
+    // Some rules have just added to the ignore,
+    // making the behavior changed.
+    if (this._added) {
+      this._initCache();
+    }
 
-  if (options.sync) {
-    if (cb)
-      throw new TypeError('callback provided to sync glob')
-    return sync$3(pattern, options)
+    return this
   }
 
-  return new Glob(pattern, options, cb)
-}
-
-glob.sync = sync$3;
-var GlobSync$1 = glob.GlobSync = sync$3.GlobSync;
+  // legacy
+  addPattern (pattern) {
+    return this.add(pattern)
+  }
 
-// old api surface
-glob.glob = glob;
+  //          |           ignored : unignored
+  // negative |   0:0   |   0:1   |   1:0   |   1:1
+  // -------- | ------- | ------- | ------- | --------
+  //     0    |  TEST   |  TEST   |  SKIP   |    X
+  //     1    |  TESTIF |  SKIP   |  TEST   |    X
 
-function extend$1 (origin, add) {
-  if (add === null || typeof add !== 'object') {
-    return origin
-  }
+  // - SKIP: always skip
+  // - TEST: always test
+  // - TESTIF: only test if checkUnignored
+  // - X: that never happen
 
-  var keys = Object.keys(add);
-  var i = keys.length;
-  while (i--) {
-    origin[keys[i]] = add[keys[i]];
-  }
-  return origin
-}
+  // @param {boolean} whether should check if the path is unignored,
+  //   setting `checkUnignored` to `false` could reduce additional
+  //   path matching.
 
-glob.hasMagic = function (pattern, options_) {
-  var options = extend$1({}, options_);
-  options.noprocess = true;
+  // @returns {TestResult} true if a file is ignored
+  _testOne (path, checkUnignored) {
+    let ignored = false;
+    let unignored = false;
 
-  var g = new Glob(pattern, options);
-  var set = g.minimatch.set;
+    this._rules.forEach(rule => {
+      const {negative} = rule;
+      if (
+        unignored === negative && ignored !== unignored
+        || negative && !ignored && !unignored && !checkUnignored
+      ) {
+        return
+      }
 
-  if (!pattern)
-    return false
+      const matched = rule.regex.test(path);
 
-  if (set.length > 1)
-    return true
+      if (matched) {
+        ignored = !negative;
+        unignored = negative;
+      }
+    });
 
-  for (var j = 0; j < set[0].length; j++) {
-    if (typeof set[0][j] !== 'string')
-      return true
+    return {
+      ignored,
+      unignored
+    }
   }
 
-  return false
-};
+  // @returns {TestResult}
+  _test (originalPath, cache, checkUnignored, slices) {
+    const path = originalPath
+      // Supports nullable path
+      && checkPath.convert(originalPath);
 
-glob.Glob = Glob;
-inherits(Glob, EE);
-function Glob (pattern, options, cb) {
-  if (typeof options === 'function') {
-    cb = options;
-    options = null;
-  }
+    checkPath(path, originalPath, throwError);
 
-  if (options && options.sync) {
-    if (cb)
-      throw new TypeError('callback provided to sync glob')
-    return new GlobSync$1(pattern, options)
+    return this._t(path, cache, checkUnignored, slices)
   }
 
-  if (!(this instanceof Glob))
-    return new Glob(pattern, options, cb)
-
-  setopts$2(this, pattern, options);
-  this._didRealPath = false;
+  _t (path, cache, checkUnignored, slices) {
+    if (path in cache) {
+      return cache[path]
+    }
 
-  // process each pattern in the minimatch set
-  var n = this.minimatch.set.length;
+    if (!slices) {
+      // path/to/a.js
+      // ['path', 'to', 'a.js']
+      slices = path.split(SLASH);
+    }
 
-  // The matches are stored as {<filename>: true,...} so that
-  // duplicates are automagically pruned.
-  // Later, we do an Object.keys() on these.
-  // Keep them as a list so we can fill in when nonull is set.
-  this.matches = new Array(n);
+    slices.pop();
 
-  if (typeof cb === 'function') {
-    cb = once_1(cb);
-    this.on('error', cb);
-    this.on('end', function (matches) {
-      cb(null, matches);
-    });
-  }
+    // If the path has no parent directory, just test it
+    if (!slices.length) {
+      return cache[path] = this._testOne(path, checkUnignored)
+    }
 
-  var self = this;
-  this._processing = 0;
+    const parent = this._t(
+      slices.join(SLASH) + SLASH,
+      cache,
+      checkUnignored,
+      slices
+    );
 
-  this._emitQueue = [];
-  this._processQueue = [];
-  this.paused = false;
+    // If the path contains a parent directory, check the parent first
+    return cache[path] = parent.ignored
+      // > It is not possible to re-include a file if a parent directory of
+      // >   that file is excluded.
+      ? parent
+      : this._testOne(path, checkUnignored)
+  }
 
-  if (this.noprocess)
-    return this
+  ignores (path) {
+    return this._test(path, this._ignoreCache, false).ignored
+  }
 
-  if (n === 0)
-    return done()
+  createFilter () {
+    return path => !this.ignores(path)
+  }
 
-  var sync = true;
-  for (var i = 0; i < n; i ++) {
-    this._process(this.minimatch.set[i], i, false, done);
+  filter (paths) {
+    return makeArray(paths).filter(this.createFilter())
   }
-  sync = false;
 
-  function done () {
-    --self._processing;
-    if (self._processing <= 0) {
-      if (sync) {
-        process.nextTick(function () {
-          self._finish();
-        });
-      } else {
-        self._finish();
-      }
-    }
+  // @returns {TestResult}
+  test (path) {
+    return this._test(path, this._testCache, true)
   }
 }
 
-Glob.prototype._finish = function () {
-  assert(this instanceof Glob);
-  if (this.aborted)
-    return
+const factory$1 = options => new Ignore$1(options);
 
-  if (this.realpath && !this._didRealpath)
-    return this._realpath()
+const returnFalse = () => false;
 
-  common$2.finish(this);
-  this.emit('end', this.found);
-};
+const isPathValid = path =>
+  checkPath(path && checkPath.convert(path), path, returnFalse);
 
-Glob.prototype._realpath = function () {
-  if (this._didRealpath)
-    return
+factory$1.isPathValid = isPathValid;
 
-  this._didRealpath = true;
+// Fixes typescript
+factory$1.default = factory$1;
 
-  var n = this.matches.length;
-  if (n === 0)
-    return this._finish()
+var ignore = factory$1;
 
-  var self = this;
-  for (var i = 0; i < this.matches.length; i++)
-    this._realpathSet(i, next);
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore if  */
+if (
+  // Detect `process` so that it can run in browsers.
+  typeof process !== 'undefined'
+  && (
+    process.env && process.env.IGNORE_TEST_WIN32
+    || process.platform === 'win32'
+  )
+) {
+  /* eslint no-control-regex: "off" */
+  const makePosix = str => /^\\\\\?\\/.test(str)
+  || /["<>|\u0000-\u001F]+/u.test(str)
+    ? str
+    : str.replace(/\\/g, '/');
 
-  function next () {
-    if (--n === 0)
-      self._finish();
-  }
-};
+  checkPath.convert = makePosix;
 
-Glob.prototype._realpathSet = function (index, cb) {
-  var matchset = this.matches[index];
-  if (!matchset)
-    return cb()
+  // 'C:\\foo'     <- 'C:\\foo' has been converted to 'C:/'
+  // 'd:\\foo'
+  const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+  checkPath.isNotRelative = path =>
+    REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)
+    || isNotRelative(path);
+}
 
-  var found = Object.keys(matchset);
-  var self = this;
-  var n = found.length;
+/**
+ * @typedef {import('ignore').Ignore & {filePath: string}} IgnoreConfig
+ *
+ * @typedef {'cwd'|'dir'} ResolveFrom
+ *
+ * @typedef Options
+ * @property {string} cwd
+ * @property {boolean|undefined} detectIgnore
+ * @property {string|undefined} ignoreName
+ * @property {string|undefined} ignorePath
+ * @property {ResolveFrom|undefined} ignorePathResolveFrom
+ *
+ * @callback Callback
+ * @param {Error|null} error
+ * @param {boolean|undefined} [result]
+ */
 
-  if (n === 0)
-    return cb()
+class Ignore {
+  /**
+   * @param {Options} options
+   */
+  constructor(options) {
+    /** @type {string} */
+    this.cwd = options.cwd;
+    /** @type {ResolveFrom|undefined} */
+    this.ignorePathResolveFrom = options.ignorePathResolveFrom;
+
+    /** @type {FindUp<IgnoreConfig>} */
+    this.findUp = new FindUp({
+      cwd: options.cwd,
+      filePath: options.ignorePath,
+      detect: options.detectIgnore,
+      names: options.ignoreName ? [options.ignoreName] : [],
+      create
+    });
+  }
 
-  var set = this.matches[index] = Object.create(null);
-  found.forEach(function (p, i) {
-    // If there's a problem with the stat, then it means that
-    // one or more of the links in the realpath couldn't be
-    // resolved.  just return the abs value in that case.
-    p = self._makeAbs(p);
-    fs_realpath.realpath(p, self.realpathCache, function (er, real) {
-      if (!er)
-        set[real] = true;
-      else if (er.syscall === 'stat')
-        set[p] = true;
-      else
-        self.emit('error', er); // srsly wtf right here
+  /**
+   * @param {string} filePath
+   * @param {Callback} callback
+   */
+  check(filePath, callback) {
+    this.findUp.load(filePath, (error, ignoreSet) => {
+      if (error) {
+        callback(error);
+      } else if (ignoreSet) {
+        const normal = path$c.relative(
+          path$c.resolve(
+            this.cwd,
+            this.ignorePathResolveFrom === 'cwd' ? '.' : ignoreSet.filePath
+          ),
+          path$c.resolve(this.cwd, filePath)
+        );
 
-      if (--n === 0) {
-        self.matches[index] = set;
-        cb();
+        if (
+          normal === '' ||
+          normal === '..' ||
+          normal.charAt(0) === path$c.sep ||
+          normal.slice(0, 3) === '..' + path$c.sep
+        ) {
+          callback(null, false);
+        } else {
+          callback(null, ignoreSet.ignores(normal));
+        }
+      } else {
+        callback(null, false);
       }
     });
-  });
-};
+  }
+}
 
-Glob.prototype._mark = function (p) {
-  return common$2.mark(this, p)
-};
+/**
+ * @param {Buffer} buf
+ * @param {string} filePath
+ * @returns {IgnoreConfig}
+ */
+function create(buf, filePath) {
+  /** @type {IgnoreConfig} */
+  return Object.assign(ignore().add(String(buf)), {
+    filePath: path$c.dirname(filePath)
+  })
+}
 
-Glob.prototype._makeAbs = function (f) {
-  return common$2.makeAbs(this, f)
-};
+var old$1 = {};
 
-Glob.prototype.abort = function () {
-  this.aborted = true;
-  this.emit('abort');
-};
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-Glob.prototype.pause = function () {
-  if (!this.paused) {
-    this.paused = true;
-    this.emit('pause');
-  }
-};
+var pathModule = path$b;
+var isWindows = process.platform === 'win32';
+var fs$3 = require$$0$3;
 
-Glob.prototype.resume = function () {
-  if (this.paused) {
-    this.emit('resume');
-    this.paused = false;
-    if (this._emitQueue.length) {
-      var eq = this._emitQueue.slice(0);
-      this._emitQueue.length = 0;
-      for (var i = 0; i < eq.length; i ++) {
-        var e = eq[i];
-        this._emitMatch(e[0], e[1]);
-      }
+// JavaScript implementation of realpath, ported from node pre-v6
+
+var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+
+function rethrow() {
+  // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
+  // is fairly slow to generate.
+  var callback;
+  if (DEBUG) {
+    var backtrace = new Error;
+    callback = debugCallback;
+  } else
+    callback = missingCallback;
+
+  return callback;
+
+  function debugCallback(err) {
+    if (err) {
+      backtrace.message = err.message;
+      err = backtrace;
+      missingCallback(err);
     }
-    if (this._processQueue.length) {
-      var pq = this._processQueue.slice(0);
-      this._processQueue.length = 0;
-      for (var i = 0; i < pq.length; i ++) {
-        var p = pq[i];
-        this._processing--;
-        this._process(p[0], p[1], p[2], p[3]);
+  }
+
+  function missingCallback(err) {
+    if (err) {
+      if (process.throwDeprecation)
+        throw err;  // Forgot a callback but don't know where? Use NODE_DEBUG=fs
+      else if (!process.noDeprecation) {
+        var msg = 'fs: missing callback ' + (err.stack || err.message);
+        if (process.traceDeprecation)
+          console.trace(msg);
+        else
+          console.error(msg);
       }
     }
   }
-};
+}
 
-Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
-  assert(this instanceof Glob);
-  assert(typeof cb === 'function');
+function maybeCallback(cb) {
+  return typeof cb === 'function' ? cb : rethrow();
+}
 
-  if (this.aborted)
-    return
+pathModule.normalize;
 
-  this._processing++;
-  if (this.paused) {
-    this._processQueue.push([pattern, index, inGlobStar, cb]);
-    return
-  }
+// Regexp that finds the next partion of a (partial) path
+// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
+if (isWindows) {
+  var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+} else {
+  var nextPartRe = /(.*?)(?:[\/]+|$)/g;
+}
 
-  //console.error('PROCESS %d', this._processing, pattern)
+// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
+if (isWindows) {
+  var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+} else {
+  var splitRootRe = /^[\/]*/;
+}
 
-  // Get the first [n] parts of pattern that are all strings.
-  var n = 0;
-  while (typeof pattern[n] === 'string') {
-    n ++;
+old$1.realpathSync = function realpathSync(p, cache) {
+  // make p is absolute
+  p = pathModule.resolve(p);
+
+  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+    return cache[p];
   }
-  // now n is the index of the first one that is *not* a string.
 
-  // see if there's anything else
-  var prefix;
-  switch (n) {
-    // if not, then this is rather simple
-    case pattern.length:
-      this._processSimple(pattern.join('/'), index, cb);
-      return
+  var original = p,
+      seenLinks = {},
+      knownHard = {};
 
-    case 0:
-      // pattern *starts* with some non-trivial item.
-      // going to readdir(cwd), but not include the prefix in matches.
-      prefix = null;
-      break
+  // current character position in p
+  var pos;
+  // the partial path so far, including a trailing slash if any
+  var current;
+  // the partial path without a trailing slash (except when pointing at a root)
+  var base;
+  // the partial path scanned in the previous round, with slash
+  var previous;
 
-    default:
-      // pattern has some string bits in the front.
-      // whatever it starts with, whether that's 'absolute' like /foo/bar,
-      // or 'relative' like '../baz'
-      prefix = pattern.slice(0, n).join('/');
-      break
+  start();
+
+  function start() {
+    // Skip over roots
+    var m = splitRootRe.exec(p);
+    pos = m[0].length;
+    current = m[0];
+    base = m[0];
+    previous = '';
+
+    // On windows, check that the root exists. On unix there is no need.
+    if (isWindows && !knownHard[base]) {
+      fs$3.lstatSync(base);
+      knownHard[base] = true;
+    }
   }
 
-  var remain = pattern.slice(n);
+  // walk down the path, swapping out linked pathparts for their real
+  // values
+  // NB: p.length changes.
+  while (pos < p.length) {
+    // find the next part
+    nextPartRe.lastIndex = pos;
+    var result = nextPartRe.exec(p);
+    previous = current;
+    current += result[0];
+    base = previous + result[1];
+    pos = nextPartRe.lastIndex;
 
-  // get the list of entries.
-  var read;
-  if (prefix === null)
-    read = '.';
-  else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
-    if (!prefix || !pathIsAbsolute(prefix))
-      prefix = '/' + prefix;
-    read = prefix;
-  } else
-    read = prefix;
+    // continue if not a symlink
+    if (knownHard[base] || (cache && cache[base] === base)) {
+      continue;
+    }
 
-  var abs = this._makeAbs(read);
+    var resolvedLink;
+    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+      // some known symbolic link.  no need to stat again.
+      resolvedLink = cache[base];
+    } else {
+      var stat = fs$3.lstatSync(base);
+      if (!stat.isSymbolicLink()) {
+        knownHard[base] = true;
+        if (cache) cache[base] = base;
+        continue;
+      }
+
+      // read the link if it wasn't read before
+      // dev/ino always return 0 on windows, so skip the check.
+      var linkTarget = null;
+      if (!isWindows) {
+        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+        if (seenLinks.hasOwnProperty(id)) {
+          linkTarget = seenLinks[id];
+        }
+      }
+      if (linkTarget === null) {
+        fs$3.statSync(base);
+        linkTarget = fs$3.readlinkSync(base);
+      }
+      resolvedLink = pathModule.resolve(previous, linkTarget);
+      // track this, if given a cache.
+      if (cache) cache[base] = resolvedLink;
+      if (!isWindows) seenLinks[id] = linkTarget;
+    }
 
-  //if ignored, skip _processing
-  if (childrenIgnored$2(this, read))
-    return cb()
+    // resolve the link, then start over
+    p = pathModule.resolve(resolvedLink, p.slice(pos));
+    start();
+  }
 
-  var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
-  if (isGlobStar)
-    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
-  else
-    this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
-};
+  if (cache) cache[original] = p;
 
-Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
-  var self = this;
-  this._readdir(abs, inGlobStar, function (er, entries) {
-    return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
-  });
+  return p;
 };
 
-Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
 
-  // if the abs isn't a dir, then nothing can match!
-  if (!entries)
-    return cb()
+old$1.realpath = function realpath(p, cache, cb) {
+  if (typeof cb !== 'function') {
+    cb = maybeCallback(cache);
+    cache = null;
+  }
 
-  // It will only match dot entries if it starts with a dot, or if
-  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
-  var pn = remain[0];
-  var negate = !!this.minimatch.negate;
-  var rawGlob = pn._glob;
-  var dotOk = this.dot || rawGlob.charAt(0) === '.';
+  // make p is absolute
+  p = pathModule.resolve(p);
 
-  var matchedEntries = [];
-  for (var i = 0; i < entries.length; i++) {
-    var e = entries[i];
-    if (e.charAt(0) !== '.' || dotOk) {
-      var m;
-      if (negate && !prefix) {
-        m = !e.match(pn);
-      } else {
-        m = e.match(pn);
-      }
-      if (m)
-        matchedEntries.push(e);
-    }
+  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+    return process.nextTick(cb.bind(null, null, cache[p]));
   }
 
-  //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
-
-  var len = matchedEntries.length;
-  // If there are no matched entries, then nothing matches.
-  if (len === 0)
-    return cb()
+  var original = p,
+      seenLinks = {},
+      knownHard = {};
 
-  // if this is the last remaining pattern bit, then no need for
-  // an additional stat *unless* the user has specified mark or
-  // stat explicitly.  We know they exist, since readdir returned
-  // them.
+  // current character position in p
+  var pos;
+  // the partial path so far, including a trailing slash if any
+  var current;
+  // the partial path without a trailing slash (except when pointing at a root)
+  var base;
+  // the partial path scanned in the previous round, with slash
+  var previous;
 
-  if (remain.length === 1 && !this.mark && !this.stat) {
-    if (!this.matches[index])
-      this.matches[index] = Object.create(null);
+  start();
 
-    for (var i = 0; i < len; i ++) {
-      var e = matchedEntries[i];
-      if (prefix) {
-        if (prefix !== '/')
-          e = prefix + '/' + e;
-        else
-          e = prefix + e;
-      }
+  function start() {
+    // Skip over roots
+    var m = splitRootRe.exec(p);
+    pos = m[0].length;
+    current = m[0];
+    base = m[0];
+    previous = '';
 
-      if (e.charAt(0) === '/' && !this.nomount) {
-        e = path$1.join(this.root, e);
-      }
-      this._emitMatch(index, e);
+    // On windows, check that the root exists. On unix there is no need.
+    if (isWindows && !knownHard[base]) {
+      fs$3.lstat(base, function(err) {
+        if (err) return cb(err);
+        knownHard[base] = true;
+        LOOP();
+      });
+    } else {
+      process.nextTick(LOOP);
     }
-    // This was the last one, and no stats were needed
-    return cb()
   }
 
-  // now test all matched entries as stand-ins for that part
-  // of the pattern.
-  remain.shift();
-  for (var i = 0; i < len; i ++) {
-    var e = matchedEntries[i];
-    if (prefix) {
-      if (prefix !== '/')
-        e = prefix + '/' + e;
-      else
-        e = prefix + e;
+  // walk down the path, swapping out linked pathparts for their real
+  // values
+  function LOOP() {
+    // stop if scanned past end of path
+    if (pos >= p.length) {
+      if (cache) cache[original] = p;
+      return cb(null, p);
     }
-    this._process([e].concat(remain), index, inGlobStar, cb);
-  }
-  cb();
-};
 
-Glob.prototype._emitMatch = function (index, e) {
-  if (this.aborted)
-    return
+    // find the next part
+    nextPartRe.lastIndex = pos;
+    var result = nextPartRe.exec(p);
+    previous = current;
+    current += result[0];
+    base = previous + result[1];
+    pos = nextPartRe.lastIndex;
 
-  if (isIgnored$2(this, e))
-    return
+    // continue if not a symlink
+    if (knownHard[base] || (cache && cache[base] === base)) {
+      return process.nextTick(LOOP);
+    }
 
-  if (this.paused) {
-    this._emitQueue.push([index, e]);
-    return
-  }
+    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+      // known symbolic link.  no need to stat again.
+      return gotResolvedLink(cache[base]);
+    }
 
-  var abs = pathIsAbsolute(e) ? e : this._makeAbs(e);
+    return fs$3.lstat(base, gotStat);
+  }
 
-  if (this.mark)
-    e = this._mark(e);
+  function gotStat(err, stat) {
+    if (err) return cb(err);
 
-  if (this.absolute)
-    e = abs;
+    // if not a symlink, skip to the next path part
+    if (!stat.isSymbolicLink()) {
+      knownHard[base] = true;
+      if (cache) cache[base] = base;
+      return process.nextTick(LOOP);
+    }
 
-  if (this.matches[index][e])
-    return
+    // stat & read the link if not read before
+    // call gotTarget as soon as the link target is known
+    // dev/ino always return 0 on windows, so skip the check.
+    if (!isWindows) {
+      var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+      if (seenLinks.hasOwnProperty(id)) {
+        return gotTarget(null, seenLinks[id], base);
+      }
+    }
+    fs$3.stat(base, function(err) {
+      if (err) return cb(err);
 
-  if (this.nodir) {
-    var c = this.cache[abs];
-    if (c === 'DIR' || Array.isArray(c))
-      return
+      fs$3.readlink(base, function(err, target) {
+        if (!isWindows) seenLinks[id] = target;
+        gotTarget(err, target);
+      });
+    });
   }
 
-  this.matches[index][e] = true;
+  function gotTarget(err, target, base) {
+    if (err) return cb(err);
 
-  var st = this.statCache[abs];
-  if (st)
-    this.emit('stat', e, st);
+    var resolvedLink = pathModule.resolve(previous, target);
+    if (cache) cache[base] = resolvedLink;
+    gotResolvedLink(resolvedLink);
+  }
 
-  this.emit('match', e);
+  function gotResolvedLink(resolvedLink) {
+    // resolve the link, then start over
+    p = pathModule.resolve(resolvedLink, p.slice(pos));
+    start();
+  }
 };
 
-Glob.prototype._readdirInGlobStar = function (abs, cb) {
-  if (this.aborted)
-    return
+var fs_realpath = realpath;
+realpath.realpath = realpath;
+realpath.sync = realpathSync;
+realpath.realpathSync = realpathSync;
+realpath.monkeypatch = monkeypatch;
+realpath.unmonkeypatch = unmonkeypatch;
 
-  // follow all symlinked directories forever
-  // just proceed as if this is a non-globstar situation
-  if (this.follow)
-    return this._readdir(abs, false, cb)
+var fs$2 = require$$0$3;
+var origRealpath = fs$2.realpath;
+var origRealpathSync = fs$2.realpathSync;
 
-  var lstatkey = 'lstat\0' + abs;
-  var self = this;
-  var lstatcb = inflight_1(lstatkey, lstatcb_);
+var version$2 = process.version;
+var ok$1 = /^v[0-5]\./.test(version$2);
+var old = old$1;
 
-  if (lstatcb)
-    fs$1.lstat(abs, lstatcb);
+function newError (er) {
+  return er && er.syscall === 'realpath' && (
+    er.code === 'ELOOP' ||
+    er.code === 'ENOMEM' ||
+    er.code === 'ENAMETOOLONG'
+  )
+}
 
-  function lstatcb_ (er, lstat) {
-    if (er && er.code === 'ENOENT')
-      return cb()
+function realpath (p, cache, cb) {
+  if (ok$1) {
+    return origRealpath(p, cache, cb)
+  }
 
-    var isSym = lstat && lstat.isSymbolicLink();
-    self.symlinks[abs] = isSym;
+  if (typeof cache === 'function') {
+    cb = cache;
+    cache = null;
+  }
+  origRealpath(p, cache, function (er, result) {
+    if (newError(er)) {
+      old.realpath(p, cache, cb);
+    } else {
+      cb(er, result);
+    }
+  });
+}
 
-    // If it's not a symlink or a dir, then it's definitely a regular file.
-    // don't bother doing a readdir in that case.
-    if (!isSym && lstat && !lstat.isDirectory()) {
-      self.cache[abs] = 'FILE';
-      cb();
-    } else
-      self._readdir(abs, false, cb);
+function realpathSync (p, cache) {
+  if (ok$1) {
+    return origRealpathSync(p, cache)
   }
-};
 
-Glob.prototype._readdir = function (abs, inGlobStar, cb) {
-  if (this.aborted)
-    return
+  try {
+    return origRealpathSync(p, cache)
+  } catch (er) {
+    if (newError(er)) {
+      return old.realpathSync(p, cache)
+    } else {
+      throw er
+    }
+  }
+}
 
-  cb = inflight_1('readdir\0'+abs+'\0'+inGlobStar, cb);
-  if (!cb)
-    return
+function monkeypatch () {
+  fs$2.realpath = realpath;
+  fs$2.realpathSync = realpathSync;
+}
 
-  //console.error('RD %j %j', +inGlobStar, abs)
-  if (inGlobStar && !ownProp$2(this.symlinks, abs))
-    return this._readdirInGlobStar(abs, cb)
+function unmonkeypatch () {
+  fs$2.realpath = origRealpath;
+  fs$2.realpathSync = origRealpathSync;
+}
 
-  if (ownProp$2(this.cache, abs)) {
-    var c = this.cache[abs];
-    if (!c || c === 'FILE')
-      return cb()
+var concatMap$1 = function (xs, fn) {
+    var res = [];
+    for (var i = 0; i < xs.length; i++) {
+        var x = fn(xs[i], i);
+        if (isArray$1(x)) res.push.apply(res, x);
+        else res.push(x);
+    }
+    return res;
+};
 
-    if (Array.isArray(c))
-      return cb(null, c)
-  }
-  fs$1.readdir(abs, readdirCb(this, abs, cb));
+var isArray$1 = Array.isArray || function (xs) {
+    return Object.prototype.toString.call(xs) === '[object Array]';
 };
 
-function readdirCb (self, abs, cb) {
-  return function (er, entries) {
-    if (er)
-      self._readdirError(abs, er, cb);
-    else
-      self._readdirEntries(abs, entries, cb);
-  }
+var balancedMatch = balanced$1;
+function balanced$1(a, b, str) {
+  if (a instanceof RegExp) a = maybeMatch(a, str);
+  if (b instanceof RegExp) b = maybeMatch(b, str);
+
+  var r = range(a, b, str);
+
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + a.length, r[1]),
+    post: str.slice(r[1] + b.length)
+  };
 }
 
-Glob.prototype._readdirEntries = function (abs, entries, cb) {
-  if (this.aborted)
-    return
+function maybeMatch(reg, str) {
+  var m = str.match(reg);
+  return m ? m[0] : null;
+}
 
-  // if we haven't asked to stat everything, then just
-  // assume that everything in there exists, so we can avoid
-  // having to stat it a second time.
-  if (!this.mark && !this.stat) {
-    for (var i = 0; i < entries.length; i ++) {
-      var e = entries[i];
-      if (abs === '/')
-        e = abs + e;
-      else
-        e = abs + '/' + e;
-      this.cache[e] = true;
-    }
-  }
+balanced$1.range = range;
+function range(a, b, str) {
+  var begs, beg, left, right, result;
+  var ai = str.indexOf(a);
+  var bi = str.indexOf(b, ai + 1);
+  var i = ai;
 
-  this.cache[abs] = entries;
-  return cb(null, entries)
-};
+  if (ai >= 0 && bi > 0) {
+    begs = [];
+    left = str.length;
 
-Glob.prototype._readdirError = function (f, er, cb) {
-  if (this.aborted)
-    return
+    while (i >= 0 && !result) {
+      if (i == ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length == 1) {
+        result = [ begs.pop(), bi ];
+      } else {
+        beg = begs.pop();
+        if (beg < left) {
+          left = beg;
+          right = bi;
+        }
 
-  // handle errors, and cache the information
-  switch (er.code) {
-    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
-    case 'ENOTDIR': // totally normal. means it *does* exist.
-      var abs = this._makeAbs(f);
-      this.cache[abs] = 'FILE';
-      if (abs === this.cwdAbs) {
-        var error = new Error(er.code + ' invalid cwd ' + this.cwd);
-        error.path = this.cwd;
-        error.code = er.code;
-        this.emit('error', error);
-        this.abort();
+        bi = str.indexOf(b, i + 1);
       }
-      break
 
-    case 'ENOENT': // not terribly unusual
-    case 'ELOOP':
-    case 'ENAMETOOLONG':
-    case 'UNKNOWN':
-      this.cache[this._makeAbs(f)] = false;
-      break
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
 
-    default: // some unusual error.  Treat as failure.
-      this.cache[this._makeAbs(f)] = false;
-      if (this.strict) {
-        this.emit('error', er);
-        // If the error is handled, then we abort
-        // if not, we threw out of here
-        this.abort();
-      }
-      if (!this.silent)
-        console.error('glob error', er);
-      break
+    if (begs.length) {
+      result = [ left, right ];
+    }
   }
 
-  return cb()
-};
+  return result;
+}
 
-Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
-  var self = this;
-  this._readdir(abs, inGlobStar, function (er, entries) {
-    self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
-  });
-};
+var concatMap = concatMap$1;
+var balanced = balancedMatch;
 
+var braceExpansion = expandTop;
 
-Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
-  //console.error('pgs2', prefix, remain[0], entries)
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
 
-  // no entries means not a dir, so it can never have matches
-  // foo.txt/** doesn't match foo.txt
-  if (!entries)
-    return cb()
+function numeric(str) {
+  return parseInt(str, 10) == str
+    ? parseInt(str, 10)
+    : str.charCodeAt(0);
+}
 
-  // test without the globstar, and with every child both below
-  // and replacing the globstar.
-  var remainWithoutGlobStar = remain.slice(1);
-  var gspref = prefix ? [ prefix ] : [];
-  var noGlobStar = gspref.concat(remainWithoutGlobStar);
+function escapeBraces(str) {
+  return str.split('\\\\').join(escSlash)
+            .split('\\{').join(escOpen)
+            .split('\\}').join(escClose)
+            .split('\\,').join(escComma)
+            .split('\\.').join(escPeriod);
+}
 
-  // the noGlobStar pattern exits the inGlobStar state
-  this._process(noGlobStar, index, false, cb);
+function unescapeBraces(str) {
+  return str.split(escSlash).join('\\')
+            .split(escOpen).join('{')
+            .split(escClose).join('}')
+            .split(escComma).join(',')
+            .split(escPeriod).join('.');
+}
 
-  var isSym = this.symlinks[abs];
-  var len = entries.length;
 
-  // If it's a symlink, and we're in a globstar, then stop
-  if (isSym && inGlobStar)
-    return cb()
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+  if (!str)
+    return [''];
 
-  for (var i = 0; i < len; i++) {
-    var e = entries[i];
-    if (e.charAt(0) === '.' && !this.dot)
-      continue
+  var parts = [];
+  var m = balanced('{', '}', str);
 
-    // these two cases enter the inGlobStar state
-    var instead = gspref.concat(entries[i], remainWithoutGlobStar);
-    this._process(instead, index, true, cb);
+  if (!m)
+    return str.split(',');
 
-    var below = gspref.concat(entries[i], remain);
-    this._process(below, index, true, cb);
+  var pre = m.pre;
+  var body = m.body;
+  var post = m.post;
+  var p = pre.split(',');
+
+  p[p.length-1] += '{' + body + '}';
+  var postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length-1] += postParts.shift();
+    p.push.apply(p, postParts);
   }
 
-  cb();
-};
+  parts.push.apply(parts, p);
 
-Glob.prototype._processSimple = function (prefix, index, cb) {
-  // XXX review this.  Shouldn't it be doing the mounting etc
-  // before doing stat?  kinda weird?
-  var self = this;
-  this._stat(prefix, function (er, exists) {
-    self._processSimple2(prefix, index, er, exists, cb);
-  });
-};
-Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
+  return parts;
+}
 
-  //console.error('ps2', prefix, exists)
+function expandTop(str) {
+  if (!str)
+    return [];
 
-  if (!this.matches[index])
-    this.matches[index] = Object.create(null);
+  // I don't know why Bash 4.3 does this, but it does.
+  // Anything starting with {} will have the first two bytes preserved
+  // but *only* at the top level, so {},a}b will not expand to anything,
+  // but a{},b}c will be expanded to [a}c,abc].
+  // One could argue that this is a bug in Bash, but since the goal of
+  // this module is to match Bash's rules, we escape a leading {}
+  if (str.substr(0, 2) === '{}') {
+    str = '\\{\\}' + str.substr(2);
+  }
 
-  // If it doesn't exist, then just mark the lack of results
-  if (!exists)
-    return cb()
+  return expand$2(escapeBraces(str), true).map(unescapeBraces);
+}
 
-  if (prefix && pathIsAbsolute(prefix) && !this.nomount) {
-    var trail = /[\/\\]$/.test(prefix);
-    if (prefix.charAt(0) === '/') {
-      prefix = path$1.join(this.root, prefix);
-    } else {
-      prefix = path$1.resolve(this.root, prefix);
-      if (trail)
-        prefix += '/';
-    }
-  }
+function embrace(str) {
+  return '{' + str + '}';
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
 
-  if (process.platform === 'win32')
-    prefix = prefix.replace(/\\/g, '/');
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
 
-  // Mark this as a match
-  this._emitMatch(index, prefix);
-  cb();
-};
+function expand$2(str, isTop) {
+  var expansions = [];
 
-// Returns either 'DIR', 'FILE', or false
-Glob.prototype._stat = function (f, cb) {
-  var abs = this._makeAbs(f);
-  var needDir = f.slice(-1) === '/';
+  var m = balanced('{', '}', str);
+  if (!m || /\$$/.test(m.pre)) return [str];
 
-  if (f.length > this.maxLength)
-    return cb()
+  var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+  var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+  var isSequence = isNumericSequence || isAlphaSequence;
+  var isOptions = m.body.indexOf(',') >= 0;
+  if (!isSequence && !isOptions) {
+    // {a},b}
+    if (m.post.match(/,.*\}/)) {
+      str = m.pre + '{' + m.body + escClose + m.post;
+      return expand$2(str);
+    }
+    return [str];
+  }
 
-  if (!this.stat && ownProp$2(this.cache, abs)) {
-    var c = this.cache[abs];
+  var n;
+  if (isSequence) {
+    n = m.body.split(/\.\./);
+  } else {
+    n = parseCommaParts(m.body);
+    if (n.length === 1) {
+      // x{{a,b}}y ==> x{a}y x{b}y
+      n = expand$2(n[0], false).map(embrace);
+      if (n.length === 1) {
+        var post = m.post.length
+          ? expand$2(m.post, false)
+          : [''];
+        return post.map(function(p) {
+          return m.pre + n[0] + p;
+        });
+      }
+    }
+  }
 
-    if (Array.isArray(c))
-      c = 'DIR';
+  // at this point, n is the parts, and we know it's not a comma set
+  // with a single entry.
 
-    // It exists, but maybe not how we need it
-    if (!needDir || c === 'DIR')
-      return cb(null, c)
+  // no need to expand pre, since it is guaranteed to be free of brace-sets
+  var pre = m.pre;
+  var post = m.post.length
+    ? expand$2(m.post, false)
+    : [''];
 
-    if (needDir && c === 'FILE')
-      return cb()
+  var N;
 
-    // otherwise we have to stat, because maybe c=true
-    // if we know it exists, but not what it is.
-  }
-  var stat = this.statCache[abs];
-  if (stat !== undefined) {
-    if (stat === false)
-      return cb(null, stat)
-    else {
-      var type = stat.isDirectory() ? 'DIR' : 'FILE';
-      if (needDir && type === 'FILE')
-        return cb()
-      else
-        return cb(null, type, stat)
+  if (isSequence) {
+    var x = numeric(n[0]);
+    var y = numeric(n[1]);
+    var width = Math.max(n[0].length, n[1].length);
+    var incr = n.length == 3
+      ? Math.abs(numeric(n[2]))
+      : 1;
+    var test = lte;
+    var reverse = y < x;
+    if (reverse) {
+      incr *= -1;
+      test = gte;
     }
-  }
+    var pad = n.some(isPadded);
 
-  var self = this;
-  var statcb = inflight_1('stat\0' + abs, lstatcb_);
-  if (statcb)
-    fs$1.lstat(abs, statcb);
+    N = [];
 
-  function lstatcb_ (er, lstat) {
-    if (lstat && lstat.isSymbolicLink()) {
-      // If it's a symlink, then treat it as the target, unless
-      // the target does not exist, then treat it as a file.
-      return fs$1.stat(abs, function (er, stat) {
-        if (er)
-          self._stat2(f, abs, null, lstat, cb);
-        else
-          self._stat2(f, abs, er, stat, cb);
-      })
-    } else {
-      self._stat2(f, abs, er, lstat, cb);
+    for (var i = x; test(i, y); i += incr) {
+      var c;
+      if (isAlphaSequence) {
+        c = String.fromCharCode(i);
+        if (c === '\\')
+          c = '';
+      } else {
+        c = String(i);
+        if (pad) {
+          var need = width - c.length;
+          if (need > 0) {
+            var z = new Array(need + 1).join('0');
+            if (i < 0)
+              c = '-' + z + c.slice(1);
+            else
+              c = z + c;
+          }
+        }
+      }
+      N.push(c);
     }
+  } else {
+    N = concatMap(n, function(el) { return expand$2(el, false) });
   }
-};
 
-Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
-  if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
-    this.statCache[abs] = false;
-    return cb()
+  for (var j = 0; j < N.length; j++) {
+    for (var k = 0; k < post.length; k++) {
+      var expansion = pre + N[j] + post[k];
+      if (!isTop || isSequence || expansion)
+        expansions.push(expansion);
+    }
   }
 
-  var needDir = f.slice(-1) === '/';
-  this.statCache[abs] = stat;
+  return expansions;
+}
 
-  if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
-    return cb(null, false, stat)
+var minimatch_1 = minimatch$3;
+minimatch$3.Minimatch = Minimatch$1;
 
-  var c = true;
-  if (stat)
-    c = stat.isDirectory() ? 'DIR' : 'FILE';
-  this.cache[abs] = this.cache[abs] || c;
+var path$4 = { sep: '/' };
+try {
+  path$4 = path$b;
+} catch (er) {}
 
-  if (needDir && c === 'FILE')
-    return cb()
+var GLOBSTAR = minimatch$3.GLOBSTAR = Minimatch$1.GLOBSTAR = {};
+var expand$1 = braceExpansion;
 
-  return cb(null, c, stat)
+var plTypes = {
+  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+  '?': { open: '(?:', close: ')?' },
+  '+': { open: '(?:', close: ')+' },
+  '*': { open: '(?:', close: ')*' },
+  '@': { open: '(?:', close: ')' }
 };
 
-/*!
- * Determine if an object is a Buffer
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]';
 
-var isBuffer = function isBuffer (obj) {
-  return obj != null && obj.constructor != null &&
-    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
-};
+// * => any number of characters
+var star = qmark + '*?';
 
-var own = {}.hasOwnProperty;
+// ** when dots are allowed.  Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?';
 
-var unistUtilStringifyPosition = stringify;
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';
 
-function stringify(value) {
-  // Nothing.
-  if (!value || typeof value !== 'object') {
-    return ''
-  }
+// characters that need to be escaped in RegExp.
+var reSpecials = charSet('().*{}+?[]^$\\!');
 
-  // Node.
-  if (own.call(value, 'position') || own.call(value, 'type')) {
-    return position(value.position)
-  }
+// "abc" -> { a:true, b:true, c:true }
+function charSet (s) {
+  return s.split('').reduce(function (set, c) {
+    set[c] = true;
+    return set
+  }, {})
+}
 
-  // Position.
-  if (own.call(value, 'start') || own.call(value, 'end')) {
-    return position(value)
-  }
+// normalizes slashes.
+var slashSplit = /\/+/;
 
-  // Point.
-  if (own.call(value, 'line') || own.call(value, 'column')) {
-    return point(value)
+minimatch$3.filter = filter;
+function filter (pattern, options) {
+  options = options || {};
+  return function (p, i, list) {
+    return minimatch$3(p, pattern, options)
   }
-
-  // ?
-  return ''
 }
 
-function point(point) {
-  if (!point || typeof point !== 'object') {
-    point = {};
-  }
-
-  return index(point.line) + ':' + index(point.column)
+function ext (a, b) {
+  a = a || {};
+  b = b || {};
+  var t = {};
+  Object.keys(b).forEach(function (k) {
+    t[k] = b[k];
+  });
+  Object.keys(a).forEach(function (k) {
+    t[k] = a[k];
+  });
+  return t
 }
 
-function position(pos) {
-  if (!pos || typeof pos !== 'object') {
-    pos = {};
-  }
+minimatch$3.defaults = function (def) {
+  if (!def || !Object.keys(def).length) return minimatch$3
 
-  return point(pos.start) + '-' + point(pos.end)
-}
+  var orig = minimatch$3;
 
-function index(value) {
-  return value && typeof value === 'number' ? value : 1
-}
+  var m = function minimatch (p, pattern, options) {
+    return orig.minimatch(p, pattern, ext(def, options))
+  };
 
-var vfileMessage = VMessage;
+  m.Minimatch = function Minimatch (pattern, options) {
+    return new orig.Minimatch(pattern, ext(def, options))
+  };
 
-// Inherit from `Error#`.
-function VMessagePrototype() {}
-VMessagePrototype.prototype = Error.prototype;
-VMessage.prototype = new VMessagePrototype();
+  return m
+};
 
-// Message properties.
-var proto = VMessage.prototype;
+Minimatch$1.defaults = function (def) {
+  if (!def || !Object.keys(def).length) return Minimatch$1
+  return minimatch$3.defaults(def).Minimatch
+};
 
-proto.file = '';
-proto.name = '';
-proto.reason = '';
-proto.message = '';
-proto.stack = '';
-proto.fatal = null;
-proto.column = null;
-proto.line = null;
+function minimatch$3 (p, pattern, options) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('glob pattern string required')
+  }
 
-// Construct a new VMessage.
-//
-// Note: We cannot invoke `Error` on the created context, as that adds readonly
-// `line` and `column` attributes on Safari 9, thus throwing and failing the
-// data.
-function VMessage(reason, position, origin) {
-  var parts;
-  var range;
-  var location;
+  if (!options) options = {};
 
-  if (typeof position === 'string') {
-    origin = position;
-    position = null;
+  // shortcut: comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    return false
   }
 
-  parts = parseOrigin(origin);
-  range = unistUtilStringifyPosition(position) || '1:1';
+  // "" only matches ""
+  if (pattern.trim() === '') return p === ''
 
-  location = {
-    start: {line: null, column: null},
-    end: {line: null, column: null}
-  };
+  return new Minimatch$1(pattern, options).match(p)
+}
 
-  // Node.
-  if (position && position.position) {
-    position = position.position;
+function Minimatch$1 (pattern, options) {
+  if (!(this instanceof Minimatch$1)) {
+    return new Minimatch$1(pattern, options)
   }
 
-  if (position) {
-    // Position.
-    if (position.start) {
-      location = position;
-      position = position.start;
-    } else {
-      // Point.
-      location.start = position;
-    }
+  if (typeof pattern !== 'string') {
+    throw new TypeError('glob pattern string required')
   }
 
-  if (reason.stack) {
-    this.stack = reason.stack;
-    reason = reason.message;
+  if (!options) options = {};
+  pattern = pattern.trim();
+
+  // windows support: need to use /, not \
+  if (path$4.sep !== '/') {
+    pattern = pattern.split(path$4.sep).join('/');
   }
 
-  this.message = reason;
-  this.name = range;
-  this.reason = reason;
-  this.line = position ? position.line : null;
-  this.column = position ? position.column : null;
-  this.location = location;
-  this.source = parts[0];
-  this.ruleId = parts[1];
-}
+  this.options = options;
+  this.set = [];
+  this.pattern = pattern;
+  this.regexp = null;
+  this.negate = false;
+  this.comment = false;
+  this.empty = false;
 
-function parseOrigin(origin) {
-  var result = [null, null];
-  var index;
+  // make the set of regexps etc.
+  this.make();
+}
 
-  if (typeof origin === 'string') {
-    index = origin.indexOf(':');
+Minimatch$1.prototype.debug = function () {};
 
-    if (index === -1) {
-      result[1] = origin;
-    } else {
-      result[0] = origin.slice(0, index);
-      result[1] = origin.slice(index + 1);
-    }
-  }
+Minimatch$1.prototype.make = make;
+function make () {
+  // don't do it more than once.
+  if (this._made) return
 
-  return result
-}
+  var pattern = this.pattern;
+  var options = this.options;
 
-function replaceExt(npath, ext) {
-  if (typeof npath !== 'string') {
-    return npath;
+  // empty patterns and comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    this.comment = true;
+    return
   }
-
-  if (npath.length === 0) {
-    return npath;
+  if (!pattern) {
+    this.empty = true;
+    return
   }
 
-  var nFileName = path$1.basename(npath, path$1.extname(npath)) + ext;
-  return path$1.join(path$1.dirname(npath), nFileName);
-}
+  // step 1: figure out negation, etc.
+  this.parseNegate();
 
-var replaceExt_1 = replaceExt;
+  // step 2: expand braces
+  var set = this.globSet = this.braceExpand();
 
-var core$1 = VFile;
+  if (options.debug) this.debug = console.error;
 
-var own$1 = {}.hasOwnProperty;
-var proto$1 = VFile.prototype;
+  this.debug(this.pattern, set);
 
-// Order of setting (least specific to most), we need this because otherwise
-// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a
-// stem can be set.
-var order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
+  // step 3: now we have a set, so turn each one into a series of path-portion
+  // matching patterns.
+  // These will be regexps, except in the case of "**", which is
+  // set to the GLOBSTAR object for globstar behavior,
+  // and will not contain any / characters
+  set = this.globParts = set.map(function (s) {
+    return s.split(slashSplit)
+  });
 
-proto$1.toString = toString;
+  this.debug(this.pattern, set);
 
-// Access full path (`~/index.min.js`).
-Object.defineProperty(proto$1, 'path', {get: getPath, set: setPath});
+  // glob --> regexps
+  set = set.map(function (s, si, set) {
+    return s.map(this.parse, this)
+  }, this);
 
-// Access parent path (`~`).
-Object.defineProperty(proto$1, 'dirname', {get: getDirname, set: setDirname});
+  this.debug(this.pattern, set);
 
-// Access basename (`index.min.js`).
-Object.defineProperty(proto$1, 'basename', {get: getBasename, set: setBasename});
+  // filter out everything that didn't compile properly.
+  set = set.filter(function (s) {
+    return s.indexOf(false) === -1
+  });
 
-// Access extname (`.js`).
-Object.defineProperty(proto$1, 'extname', {get: getExtname, set: setExtname});
+  this.debug(this.pattern, set);
 
-// Access stem (`index.min`).
-Object.defineProperty(proto$1, 'stem', {get: getStem, set: setStem});
+  this.set = set;
+}
 
-// Construct a new file.
-function VFile(options) {
-  var prop;
-  var index;
-  var length;
+Minimatch$1.prototype.parseNegate = parseNegate;
+function parseNegate () {
+  var pattern = this.pattern;
+  var negate = false;
+  var options = this.options;
+  var negateOffset = 0;
 
-  if (!options) {
-    options = {};
-  } else if (typeof options === 'string' || isBuffer(options)) {
-    options = {contents: options};
-  } else if ('message' in options && 'messages' in options) {
-    return options
-  }
+  if (options.nonegate) return
 
-  if (!(this instanceof VFile)) {
-    return new VFile(options)
+  for (var i = 0, l = pattern.length
+    ; i < l && pattern.charAt(i) === '!'
+    ; i++) {
+    negate = !negate;
+    negateOffset++;
   }
 
-  this.data = {};
-  this.messages = [];
-  this.history = [];
-  this.cwd = process.cwd();
-
-  // Set path related properties in the correct order.
-  index = -1;
-  length = order.length;
+  if (negateOffset) this.pattern = pattern.substr(negateOffset);
+  this.negate = negate;
+}
 
-  while (++index < length) {
-    prop = order[index];
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+minimatch$3.braceExpand = function (pattern, options) {
+  return braceExpand(pattern, options)
+};
 
-    if (own$1.call(options, prop)) {
-      this[prop] = options[prop];
-    }
-  }
+Minimatch$1.prototype.braceExpand = braceExpand;
 
-  // Set non-path related properties.
-  for (prop in options) {
-    if (order.indexOf(prop) === -1) {
-      this[prop] = options[prop];
+function braceExpand (pattern, options) {
+  if (!options) {
+    if (this instanceof Minimatch$1) {
+      options = this.options;
+    } else {
+      options = {};
     }
   }
-}
-
-function getPath() {
-  return this.history[this.history.length - 1]
-}
 
-function setPath(path) {
-  assertNonEmpty(path, 'path');
+  pattern = typeof pattern === 'undefined'
+    ? this.pattern : pattern;
 
-  if (path !== this.path) {
-    this.history.push(path);
+  if (typeof pattern === 'undefined') {
+    throw new TypeError('undefined pattern')
   }
-}
-
-function getDirname() {
-  return typeof this.path === 'string' ? path$1.dirname(this.path) : undefined
-}
 
-function setDirname(dirname) {
-  assertPath(this.path, 'dirname');
-  this.path = path$1.join(dirname || '', this.basename);
-}
-
-function getBasename() {
-  return typeof this.path === 'string' ? path$1.basename(this.path) : undefined
-}
+  if (options.nobrace ||
+    !pattern.match(/\{.*\}/)) {
+    // shortcut. no need to expand.
+    return [pattern]
+  }
 
-function setBasename(basename) {
-  assertNonEmpty(basename, 'basename');
-  assertPart(basename, 'basename');
-  this.path = path$1.join(this.dirname || '', basename);
+  return expand$1(pattern)
 }
 
-function getExtname() {
-  return typeof this.path === 'string' ? path$1.extname(this.path) : undefined
-}
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion.  Otherwise, any series
+// of * is equivalent to a single *.  Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+Minimatch$1.prototype.parse = parse$3;
+var SUBPARSE = {};
+function parse$3 (pattern, isSub) {
+  if (pattern.length > 1024 * 64) {
+    throw new TypeError('pattern is too long')
+  }
 
-function setExtname(extname) {
-  var ext = extname || '';
+  var options = this.options;
 
-  assertPart(ext, 'extname');
-  assertPath(this.path, 'extname');
+  // shortcuts
+  if (!options.noglobstar && pattern === '**') return GLOBSTAR
+  if (pattern === '') return ''
 
-  if (ext) {
-    if (ext.charAt(0) !== '.') {
-      throw new Error('`extname` must start with `.`')
-    }
+  var re = '';
+  var hasMagic = !!options.nocase;
+  var escaping = false;
+  // ? => one single character
+  var patternListStack = [];
+  var negativeLists = [];
+  var stateChar;
+  var inClass = false;
+  var reClassStart = -1;
+  var classStart = -1;
+  // . and .. never match anything that doesn't start with .,
+  // even when options.dot is set.
+  var patternStart = pattern.charAt(0) === '.' ? '' // anything
+  // not (start or / followed by . or .. followed by / or end)
+  : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+  : '(?!\\.)';
+  var self = this;
 
-    if (ext.indexOf('.', 1) !== -1) {
-      throw new Error('`extname` cannot contain multiple dots')
+  function clearStateChar () {
+    if (stateChar) {
+      // we had some state-tracking character
+      // that wasn't consumed by this pass.
+      switch (stateChar) {
+        case '*':
+          re += star;
+          hasMagic = true;
+        break
+        case '?':
+          re += qmark;
+          hasMagic = true;
+        break
+        default:
+          re += '\\' + stateChar;
+        break
+      }
+      self.debug('clearStateChar %j %j', stateChar, re);
+      stateChar = false;
     }
   }
 
-  this.path = replaceExt_1(this.path, ext);
-}
-
-function getStem() {
-  return typeof this.path === 'string'
-    ? path$1.basename(this.path, this.extname)
-    : undefined
-}
+  for (var i = 0, len = pattern.length, c
+    ; (i < len) && (c = pattern.charAt(i))
+    ; i++) {
+    this.debug('%s\t%s %s %j', pattern, i, re, c);
 
-function setStem(stem) {
-  assertNonEmpty(stem, 'stem');
-  assertPart(stem, 'stem');
-  this.path = path$1.join(this.dirname || '', stem + (this.extname || ''));
-}
+    // skip over any that are escaped.
+    if (escaping && reSpecials[c]) {
+      re += '\\' + c;
+      escaping = false;
+      continue
+    }
 
-// Get the value of the file.
-function toString(encoding) {
-  var value = this.contents || '';
-  return isBuffer(value) ? value.toString(encoding) : String(value)
-}
+    switch (c) {
+      case '/':
+        // completely not allowed, even escaped.
+        // Should already be path-split by now.
+        return false
 
-// Assert that `part` is not a path (i.e., does not contain `path.sep`).
-function assertPart(part, name) {
-  if (part.indexOf(path$1.sep) !== -1) {
-    throw new Error(
-      '`' + name + '` cannot be a path: did not expect `' + path$1.sep + '`'
-    )
-  }
-}
+      case '\\':
+        clearStateChar();
+        escaping = true;
+      continue
 
-// Assert that `part` is not empty.
-function assertNonEmpty(part, name) {
-  if (!part) {
-    throw new Error('`' + name + '` cannot be empty')
-  }
-}
+      // the various stateChar values
+      // for the "extglob" stuff.
+      case '?':
+      case '*':
+      case '+':
+      case '@':
+      case '!':
+        this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);
 
-// Assert `path` exists.
-function assertPath(path, name) {
-  if (!path) {
-    throw new Error('Setting `' + name + '` requires `path` to be set too')
-  }
-}
+        // all of those are literals inside a class, except that
+        // the glob [!a] means [^a] in regexp
+        if (inClass) {
+          this.debug('  in class');
+          if (c === '!' && i === classStart + 1) c = '^';
+          re += c;
+          continue
+        }
 
-var vfile = core$1;
+        // if we already have a stateChar, then it means
+        // that there was something like ** or +? in there.
+        // Handle the stateChar, then proceed with this one.
+        self.debug('call clearStateChar %j', stateChar);
+        clearStateChar();
+        stateChar = c;
+        // if extglob is disabled, then +(asdf|foo) isn't a thing.
+        // just clear the statechar *now*, rather than even diving into
+        // the patternList stuff.
+        if (options.noext) clearStateChar();
+      continue
 
-var proto$2 = core$1.prototype;
+      case '(':
+        if (inClass) {
+          re += '(';
+          continue
+        }
 
-proto$2.message = message;
-proto$2.info = info;
-proto$2.fail = fail;
+        if (!stateChar) {
+          re += '\\(';
+          continue
+        }
 
-// Create a message with `reason` at `position`.
-// When an error is passed in as `reason`, copies the stack.
-function message(reason, position, origin) {
-  var filePath = this.path;
-  var message = new vfileMessage(reason, position, origin);
+        patternListStack.push({
+          type: stateChar,
+          start: i - 1,
+          reStart: re.length,
+          open: plTypes[stateChar].open,
+          close: plTypes[stateChar].close
+        });
+        // negation is (?:(?!js)[^/]*)
+        re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
+        this.debug('plType %j %j', stateChar, re);
+        stateChar = false;
+      continue
 
-  if (filePath) {
-    message.name = filePath + ':' + message.name;
-    message.file = filePath;
-  }
+      case ')':
+        if (inClass || !patternListStack.length) {
+          re += '\\)';
+          continue
+        }
 
-  message.fatal = false;
+        clearStateChar();
+        hasMagic = true;
+        var pl = patternListStack.pop();
+        // negation is (?:(?!js)[^/]*)
+        // The others are (?:<pattern>)<type>
+        re += pl.close;
+        if (pl.type === '!') {
+          negativeLists.push(pl);
+        }
+        pl.reEnd = re.length;
+      continue
 
-  this.messages.push(message);
+      case '|':
+        if (inClass || !patternListStack.length || escaping) {
+          re += '\\|';
+          escaping = false;
+          continue
+        }
 
-  return message
-}
+        clearStateChar();
+        re += '|';
+      continue
 
-// Fail: creates a vmessage, associates it with the file, and throws it.
-function fail() {
-  var message = this.message.apply(this, arguments);
+      // these are mostly the same in regexp and glob
+      case '[':
+        // swallow any state-tracking char before the [
+        clearStateChar();
 
-  message.fatal = true;
+        if (inClass) {
+          re += '\\' + c;
+          continue
+        }
 
-  throw message
-}
+        inClass = true;
+        classStart = i;
+        reClassStart = re.length;
+        re += c;
+      continue
 
-// Info: creates a vmessage, associates it with the file, and marks the fatality
-// as null.
-function info() {
-  var message = this.message.apply(this, arguments);
+      case ']':
+        //  a right bracket shall lose its special
+        //  meaning and represent itself in
+        //  a bracket expression if it occurs
+        //  first in the list.  -- POSIX.2 2.8.3.2
+        if (i === classStart + 1 || !inClass) {
+          re += '\\' + c;
+          escaping = false;
+          continue
+        }
 
-  message.fatal = null;
+        // handle the case where we left a class open.
+        // "[z-a]" is valid, equivalent to "\[z-a\]"
+        if (inClass) {
+          // split where the last [ was, make sure we don't have
+          // an invalid re. if so, re-walk the contents of the
+          // would-be class to re-translate any characters that
+          // were passed through as-is
+          // TODO: It would probably be faster to determine this
+          // without a try/catch and a new RegExp, but it's tricky
+          // to do safely.  For now, this is safe and works.
+          var cs = pattern.substring(classStart + 1, i);
+          try {
+            RegExp('[' + cs + ']');
+          } catch (er) {
+            // not a valid class!
+            var sp = this.parse(cs, SUBPARSE);
+            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
+            hasMagic = hasMagic || sp[1];
+            inClass = false;
+            continue
+          }
+        }
 
-  return message
-}
+        // finish up the class.
+        hasMagic = true;
+        inClass = false;
+        re += c;
+      continue
 
-var core$2 = toVFile;
+      default:
+        // swallow any state char that wasn't consumed
+        clearStateChar();
 
-// Create a virtual file from a description.  If `options` is a string or a
-// buffer, it’s used as the path.  In all other cases, the options are passed
-// through to `vfile()`.
-function toVFile(options) {
-  if (typeof options === 'string' || isBuffer(options)) {
-    options = {path: String(options)};
-  }
+        if (escaping) {
+          // no need
+          escaping = false;
+        } else if (reSpecials[c]
+          && !(c === '^' && inClass)) {
+          re += '\\';
+        }
 
-  return vfile(options)
-}
+        re += c;
 
-var read$2 = readSync;
-var write = writeSync;
+    } // switch
+  } // for
 
-// Create a virtual file and read it in, synchronously.
-function readSync(description, options) {
-  var file = core$2(description);
-  file.contents = fs$1.readFileSync(path$1.resolve(file.cwd, file.path), options);
-  return file
-}
+  // handle the case where we left a class open.
+  // "[abc" is valid, equivalent to "\[abc"
+  if (inClass) {
+    // split where the last [ was, and escape it
+    // this is a huge pita.  We now have to re-walk
+    // the contents of the would-be class to re-translate
+    // any characters that were passed through as-is
+    cs = pattern.substr(classStart + 1);
+    sp = this.parse(cs, SUBPARSE);
+    re = re.substr(0, reClassStart) + '\\[' + sp[0];
+    hasMagic = hasMagic || sp[1];
+  }
 
-// Create a virtual file and write it out, synchronously.
-function writeSync(description, options) {
-  var file = core$2(description);
-  fs$1.writeFileSync(
-    path$1.resolve(file.cwd, file.path),
-    file.contents || '',
-    options
-  );
-  return file
-}
+  // handle the case where we had a +( thing at the *end*
+  // of the pattern.
+  // each pattern list stack adds 3 chars, and we need to go through
+  // and escape any | chars that were passed through as-is for the regexp.
+  // Go through and escape them, taking care not to double-escape any
+  // | chars that were already escaped.
+  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+    var tail = re.slice(pl.reStart + pl.open.length);
+    this.debug('setting tail', re, pl);
+    // maybe some even number of \, then maybe 1 \, followed by a |
+    tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
+      if (!$2) {
+        // the | isn't already escaped, so escape it.
+        $2 = '\\';
+      }
 
-var sync$4 = {
-	read: read$2,
-	write: write
-};
+      // need to escape all those slashes *again*, without escaping the
+      // one that we need for escaping the | character.  As it works out,
+      // escaping an even number of slashes can be done by simply repeating
+      // it exactly after itself.  That's why this trick works.
+      //
+      // I am sorry that you have to see this.
+      return $1 + $1 + $2 + '|'
+    });
 
-var read_1 = read$3;
-var write_1 = write$1;
+    this.debug('tail=%j\n   %s', tail, tail, pl, re);
+    var t = pl.type === '*' ? star
+      : pl.type === '?' ? qmark
+      : '\\' + pl.type;
 
-// Create a virtual file and read it in, asynchronously.
-function read$3(description, options, callback) {
-  var file = core$2(description);
+    hasMagic = true;
+    re = re.slice(0, pl.reStart) + t + '\\(' + tail;
+  }
 
-  if (!callback && typeof options === 'function') {
-    callback = options;
-    options = null;
+  // handle trailing things that only matter at the very end.
+  clearStateChar();
+  if (escaping) {
+    // trailing \\
+    re += '\\\\';
   }
 
-  if (!callback) {
-    return new Promise(executor)
+  // only need to apply the nodot start if the re starts with
+  // something that could conceivably capture a dot
+  var addPatternStart = false;
+  switch (re.charAt(0)) {
+    case '.':
+    case '[':
+    case '(': addPatternStart = true;
   }
 
-  executor(resolve, callback);
+  // Hack to work around lack of negative lookbehind in JS
+  // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+  // like 'a.xyz.yz' doesn't match.  So, the first negative
+  // lookahead, has to look ALL the way ahead, to the end of
+  // the pattern.
+  for (var n = negativeLists.length - 1; n > -1; n--) {
+    var nl = negativeLists[n];
 
-  function resolve(result) {
-    callback(null, result);
-  }
+    var nlBefore = re.slice(0, nl.reStart);
+    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+    var nlAfter = re.slice(nl.reEnd);
 
-  function executor(resolve, reject) {
-    var fp;
+    nlLast += nlAfter;
 
-    try {
-      fp = path$1.resolve(file.cwd, file.path);
-    } catch (error) {
-      return reject(error)
+    // Handle nested stuff like *(*.js|!(*.json)), where open parens
+    // mean that we should *not* include the ) in the bit that is considered
+    // "after" the negated section.
+    var openParensBefore = nlBefore.split('(').length - 1;
+    var cleanAfter = nlAfter;
+    for (i = 0; i < openParensBefore; i++) {
+      cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
     }
+    nlAfter = cleanAfter;
 
-    fs$1.readFile(fp, options, done);
-
-    function done(error, res) {
-      if (error) {
-        reject(error);
-      } else {
-        file.contents = res;
-        resolve(file);
-      }
+    var dollar = '';
+    if (nlAfter === '' && isSub !== SUBPARSE) {
+      dollar = '$';
     }
+    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+    re = newRe;
   }
-}
 
-// Create a virtual file and write it out, asynchronously.
-function write$1(description, options, callback) {
-  var file = core$2(description);
-
-  // Weird, right? Otherwise `fs` doesn’t accept it.
-  if (!callback && typeof options === 'function') {
-    callback = options;
-    options = undefined;
+  // if the re is not "" at this point, then we need to make sure
+  // it doesn't match against an empty path part.
+  // Otherwise a/* will match a/, which it should not.
+  if (re !== '' && hasMagic) {
+    re = '(?=.)' + re;
   }
 
-  if (!callback) {
-    return new Promise(executor)
+  if (addPatternStart) {
+    re = patternStart + re;
   }
 
-  executor(resolve, callback);
-
-  function resolve(result) {
-    callback(null, result);
+  // parsing just a piece of a larger pattern.
+  if (isSub === SUBPARSE) {
+    return [re, hasMagic]
   }
 
-  function executor(resolve, reject) {
-    var fp;
+  // skip the regexp for non-magical patterns
+  // unescape anything in it, though, so that it'll be
+  // an exact match against a file etc.
+  if (!hasMagic) {
+    return globUnescape(pattern)
+  }
 
-    try {
-      fp = path$1.resolve(file.cwd, file.path);
-    } catch (error) {
-      return reject(error)
-    }
+  var flags = options.nocase ? 'i' : '';
+  try {
+    var regExp = new RegExp('^' + re + '$', flags);
+  } catch (er) {
+    // If it was an invalid regular expression, then it can't match
+    // anything.  This trick looks for a character after the end of
+    // the string, which is of course impossible, except in multi-line
+    // mode, but it's not a /m regex.
+    return new RegExp('$.')
+  }
 
-    fs$1.writeFile(fp, file.contents || '', options, done);
+  regExp._glob = pattern;
+  regExp._src = re;
 
-    function done(error) {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(file);
-      }
-    }
-  }
+  return regExp
 }
 
-var async = {
-	read: read_1,
-	write: write_1
+minimatch$3.makeRe = function (pattern, options) {
+  return new Minimatch$1(pattern, options || {}).makeRe()
 };
 
-var fs = core$2;
-
-core$2.read = async.read;
-core$2.readSync = sync$4.read;
-core$2.write = async.write;
-core$2.writeSync = sync$4.write;
-
-var toVfile = fs;
-
-var readdir = fs$1.readdir;
-var stat = fs$1.stat;
-var sep$1 = path$1.sep;
-var join$1 = path$1.join;
-var relative$2 = path$1.relative;
-var resolve$3 = path$1.resolve;
-var basename = path$1.basename;
-var extname = path$1.extname;
-var magic = glob_1.hasMagic;
-
-var finder$1 = find;
-
-// Search `patterns`, a mix of globs, paths, and files.
-function find(input, options, callback) {
-  expand$1(input, options, done);
-
-  function done(error, result) {
-    /* istanbul ignore if - glob errors are unusual.
-     * other errors are on the vfile results. */
-    if (error) {
-      callback(error);
-    } else {
-      callback(null, {oneFileMode: oneFileMode(result), files: result.output});
-    }
-  }
-}
-
-// Expand the given glob patterns, search given and found directories, and map
-// to vfiles.
-function expand$1(input, options, next) {
-  var cwd = options.cwd;
-  var paths = [];
-  var actual = 0;
-  var expected = 0;
-  var failed;
+Minimatch$1.prototype.makeRe = makeRe;
+function makeRe () {
+  if (this.regexp || this.regexp === false) return this.regexp
 
-  input.forEach(each);
+  // at this point, this.set is a 2d array of partial
+  // pattern strings, or "**".
+  //
+  // It's better to use .match().  This function shouldn't
+  // be used, really, but it's pretty convenient sometimes,
+  // when you just want to work with a regex.
+  var set = this.set;
 
-  if (!expected) {
-    search(paths, options, done);
+  if (!set.length) {
+    this.regexp = false;
+    return this.regexp
   }
+  var options = this.options;
 
-  function each(file) {
-    if (typeof file === 'string') {
-      if (magic(file)) {
-        expected++;
-        glob_1(file, {cwd: cwd}, one);
-      } else {
-        // `relative` to make the paths canonical.
-        file = relative$2(cwd, resolve$3(cwd, file)) || '.';
-        paths.push(file);
-      }
-    } else {
-      file.cwd = cwd;
-      file.path = relative$2(cwd, file.path);
-      file.history = [file.path];
-      paths.push(file);
-    }
-  }
+  var twoStar = options.noglobstar ? star
+    : options.dot ? twoStarDot
+    : twoStarNoDot;
+  var flags = options.nocase ? 'i' : '';
 
-  function one(error, files) {
-    /* istanbul ignore if - Glob errors are unusual. */
-    if (failed) {
-      return
-    }
+  var re = set.map(function (pattern) {
+    return pattern.map(function (p) {
+      return (p === GLOBSTAR) ? twoStar
+      : (typeof p === 'string') ? regExpEscape(p)
+      : p._src
+    }).join('\\\/')
+  }).join('|');
 
-    /* istanbul ignore if - Glob errors are unusual. */
-    if (error) {
-      failed = true;
-      done(error);
-    } else {
-      actual++;
-      paths = paths.concat(files);
+  // must match entire pattern
+  // ending in a * or ** will make it less strict.
+  re = '^(?:' + re + ')$';
 
-      if (actual === expected) {
-        search(paths, options, done);
-      }
-    }
-  }
+  // can match anything, as long as it's not this.
+  if (this.negate) re = '^(?!' + re + ').*$';
 
-  function done(error, files) {
-    /* istanbul ignore if - `search` currently does not give errors. */
-    if (error) {
-      next(error);
-    } else {
-      next(null, {input: paths, output: files});
-    }
+  try {
+    this.regexp = new RegExp(re, flags);
+  } catch (ex) {
+    this.regexp = false;
   }
+  return this.regexp
 }
 
-// Search `paths`.
-function search(input, options, next) {
-  var cwd = options.cwd;
-  var silent = options.silentlyIgnore;
-  var nested = options.nested;
-  var extensions = options.extensions;
-  var extraIgnore = ignore().add(options.ignorePatterns);
-  var files = [];
-  var expected = 0;
-  var actual = 0;
-
-  input.forEach(each);
-
-  if (!expected) {
-    next(null, files);
+minimatch$3.match = function (list, pattern, options) {
+  options = options || {};
+  var mm = new Minimatch$1(pattern, options);
+  list = list.filter(function (f) {
+    return mm.match(f)
+  });
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
   }
+  return list
+};
 
-  return each
-
-  function each(file) {
-    var ext = typeof file === 'string' ? extname(file) : file.extname;
-    var part;
-
-    // Normalise globs.
-    if (typeof file === 'string') {
-      file = file.split('/').join(path$1.sep);
-    }
-
-    part = base(file);
-
-    if (nested && (part.charAt(0) === '.' || part === 'node_modules')) {
-      return
-    }
-
-    expected++;
-
-    statAndIgnore(
-      file,
-      Object.assign({}, options, {extraIgnore: extraIgnore}),
-      handle
-    );
-
-    function handle(error, result) {
-      var ignored = result && result.ignored;
-      var dir = result && result.stats && result.stats.isDirectory();
-
-      if (ignored && (nested || silent)) {
-        return one(null, [])
-      }
-
-      if (!ignored && dir) {
-        return readdir(resolve$3(cwd, filePath(file)), directory)
-      }
-
-      if (
-        nested &&
-        !dir &&
-        extensions.length !== 0 &&
-        extensions.indexOf(ext) === -1
-      ) {
-        return one(null, [])
-      }
-
-      file = toVfile(file);
-      file.cwd = cwd;
-
-      if (ignored) {
-        try {
-          file.fail('Cannot process specified file: it’s ignored');
-        } catch (_) {}
-      }
-
-      if (error && error.code === 'ENOENT') {
-        try {
-          file.fail(
-            error.syscall === 'stat' ? 'No such file or directory' : error
-          );
-        } catch (_) {}
-      }
+Minimatch$1.prototype.match = match;
+function match (f, partial) {
+  this.debug('match', f, this.pattern);
+  // short-circuit in the case of busted things.
+  // comments, etc.
+  if (this.comment) return false
+  if (this.empty) return f === ''
 
-      one(null, [file]);
-    }
+  if (f === '/' && partial) return true
 
-    function directory(error, basenames) {
-      var file;
+  var options = this.options;
 
-      /* istanbul ignore if - Should not happen often: the directory is `stat`ed
-       * first, which was ok, but reading it is not. */
-      if (error) {
-        file = toVfile(filePath(file));
-        file.cwd = cwd;
+  // windows: need to use /, not \
+  if (path$4.sep !== '/') {
+    f = f.split(path$4.sep).join('/');
+  }
 
-        try {
-          file.fail('Cannot read directory');
-        } catch (_) {}
+  // treat the test path as a set of pathparts.
+  f = f.split(slashSplit);
+  this.debug(this.pattern, 'split', f);
 
-        one(null, [file]);
-      } else {
-        search(
-          basenames.map(concat),
-          Object.assign({}, options, {nested: true}),
-          one
-        );
-      }
-    }
+  // just ONE of the pattern sets in this.set needs to match
+  // in order for it to be valid.  If negating, then just one
+  // match means that we have failed.
+  // Either way, return on the first hit.
 
-    // Error is never given. Always given `results`.
-    function one(_, results) {
-      /* istanbul ignore else - Always given. */
-      if (results) {
-        files = files.concat(results);
-      }
+  var set = this.set;
+  this.debug(this.pattern, 'set', set);
 
-      actual++;
+  // Find the basename of the path by looking for the last non-empty segment
+  var filename;
+  var i;
+  for (i = f.length - 1; i >= 0; i--) {
+    filename = f[i];
+    if (filename) break
+  }
 
-      if (actual === expected) {
-        next(null, files);
-      }
+  for (i = 0; i < set.length; i++) {
+    var pattern = set[i];
+    var file = f;
+    if (options.matchBase && pattern.length === 1) {
+      file = [filename];
     }
-
-    function concat(value) {
-      return join$1(filePath(file), value)
+    var hit = this.matchOne(file, pattern, partial);
+    if (hit) {
+      if (options.flipNegate) return true
+      return !this.negate
     }
   }
-}
-
-function statAndIgnore(file, options, callback) {
-  var ignore = options.ignore;
-  var extraIgnore = options.extraIgnore;
-  var cwd = options.cwd;
-  var fp = resolve$3(cwd, filePath(file));
-  var normal = relative$2(cwd, fp);
-  var expected = 1;
-  var actual = 0;
-  var stats;
-  var ignored;
-
-  if (!file.contents) {
-    expected++;
-    stat(fp, handleStat);
-  }
-
-  ignore.check(fp, handleIgnore);
 
-  function handleStat(error, value) {
-    stats = value;
-    one(error);
-  }
+  // didn't get any hits.  this is success if it's a negative
+  // pattern, failure otherwise.
+  if (options.flipNegate) return false
+  return this.negate
+}
 
-  function handleIgnore(error, value) {
-    ignored = value;
-    one(error);
-  }
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+Minimatch$1.prototype.matchOne = function (file, pattern, partial) {
+  var options = this.options;
 
-  function one(error) {
-    actual++;
+  this.debug('matchOne',
+    { 'this': this, file: file, pattern: pattern });
 
-    if (error) {
-      callback(error);
-      actual = -1;
-    } else if (actual === expected) {
-      callback(null, {
-        stats: stats,
-        ignored:
-          ignored ||
-          (normal === '' ||
-          normal === '..' ||
-          normal.charAt(0) === sep$1 ||
-          normal.slice(0, 3) === '..' + sep$1
-            ? false
-            : extraIgnore.ignores(normal))
-      });
-    }
-  }
-}
+  this.debug('matchOne', file.length, pattern.length);
 
-function base(file) {
-  return typeof file === 'string' ? basename(file) : file.basename
-}
+  for (var fi = 0,
+      pi = 0,
+      fl = file.length,
+      pl = pattern.length
+      ; (fi < fl) && (pi < pl)
+      ; fi++, pi++) {
+    this.debug('matchOne loop');
+    var p = pattern[pi];
+    var f = file[fi];
 
-function filePath(file) {
-  return typeof file === 'string' ? file : file.path
-}
+    this.debug(pattern, p, f);
 
-function oneFileMode(result) {
-  return (
-    result.output.length === 1 &&
-    result.input.length === 1 &&
-    result.output[0].path === result.input[0]
-  )
-}
+    // should be impossible.
+    // some invalid regexp stuff in the set.
+    if (p === false) return false
 
-var fileSystem_1 = fileSystem;
+    if (p === GLOBSTAR) {
+      this.debug('GLOBSTAR', [pattern, p, f]);
 
-// Find files from the file-system.
-function fileSystem(context, settings, next) {
-  var input = context.files;
+      // "**"
+      // a/**/b/**/c would match the following:
+      // a/b/x/y/z/c
+      // a/x/y/z/b/c
+      // a/b/x/b/x/c
+      // a/b/c
+      // To do this, take the rest of the pattern after
+      // the **, and see if it would match the file remainder.
+      // If so, return success.
+      // If not, the ** "swallows" a segment, and try again.
+      // This is recursively awful.
+      //
+      // a/**/b/**/c matching a/b/x/y/z/c
+      // - a matches a
+      // - doublestar
+      //   - matchOne(b/x/y/z/c, b/**/c)
+      //     - b matches b
+      //     - doublestar
+      //       - matchOne(x/y/z/c, c) -> no
+      //       - matchOne(y/z/c, c) -> no
+      //       - matchOne(z/c, c) -> no
+      //       - matchOne(c, c) yes, hit
+      var fr = fi;
+      var pr = pi + 1;
+      if (pr === pl) {
+        this.debug('** at the end');
+        // a ** at the end will just swallow the rest.
+        // We have found a match.
+        // however, it will not swallow /.x, unless
+        // options.dot is set.
+        // . and .. are *never* matched by **, for explosively
+        // exponential reasons.
+        for (; fi < fl; fi++) {
+          if (file[fi] === '.' || file[fi] === '..' ||
+            (!options.dot && file[fi].charAt(0) === '.')) return false
+        }
+        return true
+      }
 
-  if (input.length === 0) {
-    next();
-  } else {
-    finder$1(
-      input,
-      {
-        cwd: settings.cwd,
-        extensions: settings.extensions,
-        silentlyIgnore: settings.silentlyIgnore,
-        ignorePatterns: settings.ignorePatterns,
-        ignore: new ignore$1({
-          cwd: settings.cwd,
-          detectIgnore: settings.detectIgnore,
-          ignoreName: settings.ignoreName,
-          ignorePath: settings.ignorePath,
-          ignorePathResolveFrom: settings.ignorePathResolveFrom
-        })
-      },
-      onfound
-    );
-  }
+      // ok, let's see if we can swallow whatever we can.
+      while (fr < fl) {
+        var swallowee = file[fr];
 
-  function onfound(error, result) {
-    var output = result.files;
+        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
 
-    // Sort alphabetically.
-    // Everything is unique so we do not care about cases where left and right
-    // are equal.
-    output.sort(sortAlphabetically);
+        // XXX remove this slice.  Just pass the start index.
+        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+          this.debug('globstar found match!', fr, fl, swallowee);
+          // found a match.
+          return true
+        } else {
+          // can't swallow "." or ".." ever.
+          // can only swallow ".foo" when explicitly asked.
+          if (swallowee === '.' || swallowee === '..' ||
+            (!options.dot && swallowee.charAt(0) === '.')) {
+            this.debug('dot detected!', file, fr, pattern, pr);
+            break
+          }
 
-    // Mark as given.
-    // This allows outputting files, which can be pretty dangerous, so it’s
-    // “hidden”.
-    output.forEach(markAsGiven);
+          // ** swallows a segment, and continue.
+          this.debug('globstar swallow a segment, and continue');
+          fr++;
+        }
+      }
 
-    context.files = output;
+      // no match was found.
+      // However, in partial mode, we can't say this is necessarily over.
+      // If there's more *pattern* left, then
+      if (partial) {
+        // ran out of file
+        this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
+        if (fr === fl) return true
+      }
+      return false
+    }
 
-    // If `out` was not set, detect it based on whether one file was given.
-    if (settings.out === null || settings.out === undefined) {
-      settings.out = result.oneFileMode;
+    // something other than **
+    // non-magic patterns just have to match exactly
+    // patterns with magic have been turned into regexps.
+    var hit;
+    if (typeof p === 'string') {
+      if (options.nocase) {
+        hit = f.toLowerCase() === p.toLowerCase();
+      } else {
+        hit = f === p;
+      }
+      this.debug('string match', p, f, hit);
+    } else {
+      hit = f.match(p);
+      this.debug('pattern match', p, f, hit);
     }
 
-    next(error);
+    if (!hit) return false
   }
 
-  function markAsGiven(file) {
-    file.data.unifiedEngineGiven = true;
-  }
+  // Note: ending in / means that we'll get a final ""
+  // at the end of the pattern.  This can only match a
+  // corresponding "" at the end of the file.
+  // If the file ends in /, then it can only match a
+  // a pattern that ends in /, unless the pattern just
+  // doesn't have any more for it. But, a/b/ should *not*
+  // match "a/b/*", even though "" matches against the
+  // [^/]*? pattern, except in partial mode, where it might
+  // simply not be reached yet.
+  // However, a/b/ should still satisfy a/*
 
-  function sortAlphabetically(left, right) {
-    return left.path < right.path ? -1 : 1
+  // now either we fell off the end of the pattern, or we're done.
+  if (fi === fl && pi === pl) {
+    // ran out of pattern and filename at the same time.
+    // an exact hit!
+    return true
+  } else if (fi === fl) {
+    // ran out of file, but still had pattern left.
+    // this is ok if we're doing the match as part of
+    // a glob fs traversal.
+    return partial
+  } else if (pi === pl) {
+    // ran out of pattern, still have file left.
+    // this is only acceptable if we're on the very last
+    // empty segment of a file with a trailing slash.
+    // a/* should match a/b/
+    var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');
+    return emptyFileEnd
   }
-}
-
-var toString$1 = Object.prototype.toString;
 
-var isModern = (
-  typeof Buffer.alloc === 'function' &&
-  typeof Buffer.allocUnsafe === 'function' &&
-  typeof Buffer.from === 'function'
-);
+  // should be unreachable.
+  throw new Error('wtf?')
+};
 
-function isArrayBuffer (input) {
-  return toString$1.call(input).slice(8, -1) === 'ArrayBuffer'
+// replace stuff like \* with *
+function globUnescape (s) {
+  return s.replace(/\\(.)/g, '$1')
 }
 
-function fromArrayBuffer (obj, byteOffset, length) {
-  byteOffset >>>= 0;
-
-  var maxLength = obj.byteLength - byteOffset;
+function regExpEscape (s) {
+  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}
 
-  if (maxLength < 0) {
-    throw new RangeError("'offset' is out of bounds")
-  }
+var inherits$2 = {exports: {}};
 
-  if (length === undefined) {
-    length = maxLength;
-  } else {
-    length >>>= 0;
+var inherits_browser = {exports: {}};
 
-    if (length > maxLength) {
-      throw new RangeError("'length' is out of bounds")
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  inherits_browser.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      });
     }
-  }
-
-  return isModern
-    ? Buffer.from(obj.slice(byteOffset, byteOffset + length))
-    : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)))
+  };
+} else {
+  // old school shim for old browsers
+  inherits_browser.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      var TempCtor = function () {};
+      TempCtor.prototype = superCtor.prototype;
+      ctor.prototype = new TempCtor();
+      ctor.prototype.constructor = ctor;
+    }
+  };
 }
 
-function fromString (string, encoding) {
-  if (typeof encoding !== 'string' || encoding === '') {
-    encoding = 'utf8';
-  }
-
-  if (!Buffer.isEncoding(encoding)) {
-    throw new TypeError('"encoding" must be a valid string encoding')
-  }
-
-  return isModern
-    ? Buffer.from(string, encoding)
-    : new Buffer(string, encoding)
+try {
+  var util$1 = require$$0$4;
+  /* istanbul ignore next */
+  if (typeof util$1.inherits !== 'function') throw '';
+  inherits$2.exports = util$1.inherits;
+} catch (e) {
+  /* istanbul ignore next */
+  inherits$2.exports = inherits_browser.exports;
 }
 
-function bufferFrom (value, encodingOrOffset, length) {
-  if (typeof value === 'number') {
-    throw new TypeError('"value" argument must not be a number')
-  }
+var pathIsAbsolute = {exports: {}};
 
-  if (isArrayBuffer(value)) {
-    return fromArrayBuffer(value, encodingOrOffset, length)
-  }
+function posix(path) {
+	return path.charAt(0) === '/';
+}
 
-  if (typeof value === 'string') {
-    return fromString(value, encodingOrOffset)
-  }
+function win32(path) {
+	// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
+	var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+	var result = splitDeviceRe.exec(path);
+	var device = result[1] || '';
+	var isUnc = Boolean(device && device.charAt(1) !== ':');
 
-  return isModern
-    ? Buffer.from(value)
-    : new Buffer(value)
+	// UNC paths are always absolute
+	return Boolean(result[2] || isUnc);
 }
 
-var bufferFrom_1 = bufferFrom;
+pathIsAbsolute.exports = process.platform === 'win32' ? win32 : posix;
+pathIsAbsolute.exports.posix = posix;
+pathIsAbsolute.exports.win32 = win32;
 
-var typedarray = createCommonjsModule(function (module, exports) {
-var undefined$1 = (void 0); // Paranoia
-
-// Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to
-// create, and consume so much memory, that the browser appears frozen.
-var MAX_ARRAY_LENGTH = 1e5;
+var common$2 = {};
 
-// Approximations of internal ECMAScript conversion functions
-var ECMAScript = (function() {
-  // Stash a copy in case other scripts modify these
-  var opts = Object.prototype.toString,
-      ophop = Object.prototype.hasOwnProperty;
+common$2.alphasort = alphasort;
+common$2.alphasorti = alphasorti;
+common$2.setopts = setopts$2;
+common$2.ownProp = ownProp$2;
+common$2.makeAbs = makeAbs;
+common$2.finish = finish;
+common$2.mark = mark;
+common$2.isIgnored = isIgnored$2;
+common$2.childrenIgnored = childrenIgnored$2;
 
-  return {
-    // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues:
-    Class: function(v) { return opts.call(v).replace(/^\[object *|\]$/g, ''); },
-    HasProperty: function(o, p) { return p in o; },
-    HasOwnProperty: function(o, p) { return ophop.call(o, p); },
-    IsCallable: function(o) { return typeof o === 'function'; },
-    ToInt32: function(v) { return v >> 0; },
-    ToUint32: function(v) { return v >>> 0; }
-  };
-}());
+function ownProp$2 (obj, field) {
+  return Object.prototype.hasOwnProperty.call(obj, field)
+}
 
-// Snapshot intrinsics
-var LN2 = Math.LN2,
-    abs = Math.abs,
-    floor = Math.floor,
-    log = Math.log,
-    min = Math.min,
-    pow = Math.pow,
-    round = Math.round;
+var path$3 = path$b;
+var minimatch$2 = minimatch_1;
+var isAbsolute$2 = pathIsAbsolute.exports;
+var Minimatch = minimatch$2.Minimatch;
 
-// ES5: lock down object properties
-function configureProperties(obj) {
-  if (getOwnPropNames && defineProp) {
-    var props = getOwnPropNames(obj), i;
-    for (i = 0; i < props.length; i += 1) {
-      defineProp(obj, props[i], {
-        value: obj[props[i]],
-        writable: false,
-        enumerable: false,
-        configurable: false
-      });
-    }
-  }
+function alphasorti (a, b) {
+  return a.toLowerCase().localeCompare(b.toLowerCase())
 }
 
-// emulate ES5 getter/setter API using legacy APIs
-// http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx
-// (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but
-// note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless)
-var defineProp;
-if (Object.defineProperty && (function() {
-      try {
-        Object.defineProperty({}, 'x', {});
-        return true;
-      } catch (e) {
-        return false;
-      }
-    })()) {
-  defineProp = Object.defineProperty;
-} else {
-  defineProp = function(o, p, desc) {
-    if (!o === Object(o)) throw new TypeError("Object.defineProperty called on non-object");
-    if (ECMAScript.HasProperty(desc, 'get') && Object.prototype.__defineGetter__) { Object.prototype.__defineGetter__.call(o, p, desc.get); }
-    if (ECMAScript.HasProperty(desc, 'set') && Object.prototype.__defineSetter__) { Object.prototype.__defineSetter__.call(o, p, desc.set); }
-    if (ECMAScript.HasProperty(desc, 'value')) { o[p] = desc.value; }
-    return o;
-  };
+function alphasort (a, b) {
+  return a.localeCompare(b)
 }
 
-var getOwnPropNames = Object.getOwnPropertyNames || function (o) {
-  if (o !== Object(o)) throw new TypeError("Object.getOwnPropertyNames called on non-object");
-  var props = [], p;
-  for (p in o) {
-    if (ECMAScript.HasOwnProperty(o, p)) {
-      props.push(p);
-    }
-  }
-  return props;
-};
+function setupIgnores (self, options) {
+  self.ignore = options.ignore || [];
 
-// ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value)
-// for index in 0 ... obj.length
-function makeArrayAccessors(obj) {
-  if (!defineProp) { return; }
+  if (!Array.isArray(self.ignore))
+    self.ignore = [self.ignore];
 
-  if (obj.length > MAX_ARRAY_LENGTH) throw new RangeError("Array too large for polyfill");
+  if (self.ignore.length) {
+    self.ignore = self.ignore.map(ignoreMap);
+  }
+}
 
-  function makeArrayAccessor(index) {
-    defineProp(obj, index, {
-      'get': function() { return obj._getter(index); },
-      'set': function(v) { obj._setter(index, v); },
-      enumerable: true,
-      configurable: false
-    });
+// ignore patterns are always in dot:true mode.
+function ignoreMap (pattern) {
+  var gmatcher = null;
+  if (pattern.slice(-3) === '/**') {
+    var gpattern = pattern.replace(/(\/\*\*)+$/, '');
+    gmatcher = new Minimatch(gpattern, { dot: true });
   }
 
-  var i;
-  for (i = 0; i < obj.length; i += 1) {
-    makeArrayAccessor(i);
+  return {
+    matcher: new Minimatch(pattern, { dot: true }),
+    gmatcher: gmatcher
   }
 }
 
-// Internal conversion functions:
-//    pack<Type>()   - take a number (interpreted as Type), output a byte array
-//    unpack<Type>() - take a byte array, output a Type-like number
-
-function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; }
-function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; }
-
-function packI8(n) { return [n & 0xff]; }
-function unpackI8(bytes) { return as_signed(bytes[0], 8); }
+function setopts$2 (self, pattern, options) {
+  if (!options)
+    options = {};
 
-function packU8(n) { return [n & 0xff]; }
-function unpackU8(bytes) { return as_unsigned(bytes[0], 8); }
+  // base-matching: just use globstar for that.
+  if (options.matchBase && -1 === pattern.indexOf("/")) {
+    if (options.noglobstar) {
+      throw new Error("base matching requires globstar")
+    }
+    pattern = "**/" + pattern;
+  }
 
-function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; }
+  self.silent = !!options.silent;
+  self.pattern = pattern;
+  self.strict = options.strict !== false;
+  self.realpath = !!options.realpath;
+  self.realpathCache = options.realpathCache || Object.create(null);
+  self.follow = !!options.follow;
+  self.dot = !!options.dot;
+  self.mark = !!options.mark;
+  self.nodir = !!options.nodir;
+  if (self.nodir)
+    self.mark = true;
+  self.sync = !!options.sync;
+  self.nounique = !!options.nounique;
+  self.nonull = !!options.nonull;
+  self.nosort = !!options.nosort;
+  self.nocase = !!options.nocase;
+  self.stat = !!options.stat;
+  self.noprocess = !!options.noprocess;
+  self.absolute = !!options.absolute;
 
-function packI16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
-function unpackI16(bytes) { return as_signed(bytes[0] << 8 | bytes[1], 16); }
+  self.maxLength = options.maxLength || Infinity;
+  self.cache = options.cache || Object.create(null);
+  self.statCache = options.statCache || Object.create(null);
+  self.symlinks = options.symlinks || Object.create(null);
 
-function packU16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
-function unpackU16(bytes) { return as_unsigned(bytes[0] << 8 | bytes[1], 16); }
+  setupIgnores(self, options);
 
-function packI32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
-function unpackI32(bytes) { return as_signed(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
+  self.changedCwd = false;
+  var cwd = process.cwd();
+  if (!ownProp$2(options, "cwd"))
+    self.cwd = cwd;
+  else {
+    self.cwd = path$3.resolve(options.cwd);
+    self.changedCwd = self.cwd !== cwd;
+  }
 
-function packU32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
-function unpackU32(bytes) { return as_unsigned(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
+  self.root = options.root || path$3.resolve(self.cwd, "/");
+  self.root = path$3.resolve(self.root);
+  if (process.platform === "win32")
+    self.root = self.root.replace(/\\/g, "/");
 
-function packIEEE754(v, ebits, fbits) {
+  // TODO: is an absolute `cwd` supposed to be resolved against `root`?
+  // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
+  self.cwdAbs = isAbsolute$2(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+  if (process.platform === "win32")
+    self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
+  self.nomount = !!options.nomount;
 
-  var bias = (1 << (ebits - 1)) - 1,
-      s, e, f, i, bits, str, bytes;
+  // disable comments and negation in Minimatch.
+  // Note that they are not supported in Glob itself anyway.
+  options.nonegate = true;
+  options.nocomment = true;
 
-  function roundToEven(n) {
-    var w = floor(n), f = n - w;
-    if (f < 0.5)
-      return w;
-    if (f > 0.5)
-      return w + 1;
-    return w % 2 ? w + 1 : w;
-  }
+  self.minimatch = new Minimatch(pattern, options);
+  self.options = self.minimatch.options;
+}
 
-  // Compute sign, exponent, fraction
-  if (v !== v) {
-    // NaN
-    // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
-    e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0;
-  } else if (v === Infinity || v === -Infinity) {
-    e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0;
-  } else if (v === 0) {
-    e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0;
-  } else {
-    s = v < 0;
-    v = abs(v);
+function finish (self) {
+  var nou = self.nounique;
+  var all = nou ? [] : Object.create(null);
 
-    if (v >= pow(2, 1 - bias)) {
-      e = min(floor(log(v) / LN2), 1023);
-      f = roundToEven(v / pow(2, e) * pow(2, fbits));
-      if (f / pow(2, fbits) >= 2) {
-        e = e + 1;
-        f = 1;
-      }
-      if (e > bias) {
-        // Overflow
-        e = (1 << ebits) - 1;
-        f = 0;
-      } else {
-        // Normalized
-        e = e + bias;
-        f = f - pow(2, fbits);
+  for (var i = 0, l = self.matches.length; i < l; i ++) {
+    var matches = self.matches[i];
+    if (!matches || Object.keys(matches).length === 0) {
+      if (self.nonull) {
+        // do like the shell, and spit out the literal glob
+        var literal = self.minimatch.globSet[i];
+        if (nou)
+          all.push(literal);
+        else
+          all[literal] = true;
       }
     } else {
-      // Denormalized
-      e = 0;
-      f = roundToEven(v / pow(2, 1 - bias - fbits));
+      // had matches
+      var m = Object.keys(matches);
+      if (nou)
+        all.push.apply(all, m);
+      else
+        m.forEach(function (m) {
+          all[m] = true;
+        });
     }
   }
 
-  // Pack sign, exponent, fraction
-  bits = [];
-  for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); }
-  for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); }
-  bits.push(s ? 1 : 0);
-  bits.reverse();
-  str = bits.join('');
+  if (!nou)
+    all = Object.keys(all);
 
-  // Bits to bytes
-  bytes = [];
-  while (str.length) {
-    bytes.push(parseInt(str.substring(0, 8), 2));
-    str = str.substring(8);
+  if (!self.nosort)
+    all = all.sort(self.nocase ? alphasorti : alphasort);
+
+  // at *some* point we statted all of these
+  if (self.mark) {
+    for (var i = 0; i < all.length; i++) {
+      all[i] = self._mark(all[i]);
+    }
+    if (self.nodir) {
+      all = all.filter(function (e) {
+        var notDir = !(/\/$/.test(e));
+        var c = self.cache[e] || self.cache[makeAbs(self, e)];
+        if (notDir && c)
+          notDir = c !== 'DIR' && !Array.isArray(c);
+        return notDir
+      });
+    }
   }
-  return bytes;
+
+  if (self.ignore.length)
+    all = all.filter(function(m) {
+      return !isIgnored$2(self, m)
+    });
+
+  self.found = all;
 }
 
-function unpackIEEE754(bytes, ebits, fbits) {
+function mark (self, p) {
+  var abs = makeAbs(self, p);
+  var c = self.cache[abs];
+  var m = p;
+  if (c) {
+    var isDir = c === 'DIR' || Array.isArray(c);
+    var slash = p.slice(-1) === '/';
 
-  // Bytes to bits
-  var bits = [], i, j, b, str,
-      bias, s, e, f;
+    if (isDir && !slash)
+      m += '/';
+    else if (!isDir && slash)
+      m = m.slice(0, -1);
 
-  for (i = bytes.length; i; i -= 1) {
-    b = bytes[i - 1];
-    for (j = 8; j; j -= 1) {
-      bits.push(b % 2 ? 1 : 0); b = b >> 1;
+    if (m !== p) {
+      var mabs = makeAbs(self, m);
+      self.statCache[mabs] = self.statCache[abs];
+      self.cache[mabs] = self.cache[abs];
     }
   }
-  bits.reverse();
-  str = bits.join('');
-
-  // Unpack sign, exponent, fraction
-  bias = (1 << (ebits - 1)) - 1;
-  s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
-  e = parseInt(str.substring(1, 1 + ebits), 2);
-  f = parseInt(str.substring(1 + ebits), 2);
 
-  // Produce number
-  if (e === (1 << ebits) - 1) {
-    return f !== 0 ? NaN : s * Infinity;
-  } else if (e > 0) {
-    // Normalized
-    return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
-  } else if (f !== 0) {
-    // Denormalized
-    return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
+  return m
+}
+
+// lotta situps...
+function makeAbs (self, f) {
+  var abs = f;
+  if (f.charAt(0) === '/') {
+    abs = path$3.join(self.root, f);
+  } else if (isAbsolute$2(f) || f === '') {
+    abs = f;
+  } else if (self.changedCwd) {
+    abs = path$3.resolve(self.cwd, f);
   } else {
-    return s < 0 ? -0 : 0;
+    abs = path$3.resolve(f);
   }
+
+  if (process.platform === 'win32')
+    abs = abs.replace(/\\/g, '/');
+
+  return abs
 }
 
-function unpackF64(b) { return unpackIEEE754(b, 11, 52); }
-function packF64(v) { return packIEEE754(v, 11, 52); }
-function unpackF32(b) { return unpackIEEE754(b, 8, 23); }
-function packF32(v) { return packIEEE754(v, 8, 23); }
 
+// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
+// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
+function isIgnored$2 (self, path) {
+  if (!self.ignore.length)
+    return false
 
-//
-// 3 The ArrayBuffer Type
-//
+  return self.ignore.some(function(item) {
+    return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
+  })
+}
 
-(function() {
+function childrenIgnored$2 (self, path) {
+  if (!self.ignore.length)
+    return false
 
-  /** @constructor */
-  var ArrayBuffer = function ArrayBuffer(length) {
-    length = ECMAScript.ToInt32(length);
-    if (length < 0) throw new RangeError('ArrayBuffer size is not a small enough positive integer');
+  return self.ignore.some(function(item) {
+    return !!(item.gmatcher && item.gmatcher.match(path))
+  })
+}
 
-    this.byteLength = length;
-    this._bytes = [];
-    this._bytes.length = length;
+var sync$1 = globSync$1;
+globSync$1.GlobSync = GlobSync$1;
+
+var fs$1 = require$$0$3;
+var rp$1 = fs_realpath;
+var minimatch$1 = minimatch_1;
+var path$2 = path$b;
+var assert$1 = assert$2;
+var isAbsolute$1 = pathIsAbsolute.exports;
+var common$1 = common$2;
+common$1.alphasort;
+common$1.alphasorti;
+var setopts$1 = common$1.setopts;
+var ownProp$1 = common$1.ownProp;
+var childrenIgnored$1 = common$1.childrenIgnored;
+var isIgnored$1 = common$1.isIgnored;
+
+function globSync$1 (pattern, options) {
+  if (typeof options === 'function' || arguments.length === 3)
+    throw new TypeError('callback provided to sync glob\n'+
+                        'See: https://github.com/isaacs/node-glob/issues/167')
 
-    var i;
-    for (i = 0; i < this.byteLength; i += 1) {
-      this._bytes[i] = 0;
-    }
+  return new GlobSync$1(pattern, options).found
+}
 
-    configureProperties(this);
-  };
+function GlobSync$1 (pattern, options) {
+  if (!pattern)
+    throw new Error('must provide pattern')
 
-  exports.ArrayBuffer = exports.ArrayBuffer || ArrayBuffer;
+  if (typeof options === 'function' || arguments.length === 3)
+    throw new TypeError('callback provided to sync glob\n'+
+                        'See: https://github.com/isaacs/node-glob/issues/167')
 
-  //
-  // 4 The ArrayBufferView Type
-  //
+  if (!(this instanceof GlobSync$1))
+    return new GlobSync$1(pattern, options)
 
-  // NOTE: this constructor is not exported
-  /** @constructor */
-  var ArrayBufferView = function ArrayBufferView() {
-    //this.buffer = null;
-    //this.byteOffset = 0;
-    //this.byteLength = 0;
-  };
+  setopts$1(this, pattern, options);
 
-  //
-  // 5 The Typed Array View Types
-  //
+  if (this.noprocess)
+    return this
 
-  function makeConstructor(bytesPerElement, pack, unpack) {
-    // Each TypedArray type requires a distinct constructor instance with
-    // identical logic, which this produces.
+  var n = this.minimatch.set.length;
+  this.matches = new Array(n);
+  for (var i = 0; i < n; i ++) {
+    this._process(this.minimatch.set[i], i, false);
+  }
+  this._finish();
+}
 
-    var ctor;
-    ctor = function(buffer, byteOffset, length) {
-      var array, sequence, i, s;
+GlobSync$1.prototype._finish = function () {
+  assert$1(this instanceof GlobSync$1);
+  if (this.realpath) {
+    var self = this;
+    this.matches.forEach(function (matchset, index) {
+      var set = self.matches[index] = Object.create(null);
+      for (var p in matchset) {
+        try {
+          p = self._makeAbs(p);
+          var real = rp$1.realpathSync(p, self.realpathCache);
+          set[real] = true;
+        } catch (er) {
+          if (er.syscall === 'stat')
+            set[self._makeAbs(p)] = true;
+          else
+            throw er
+        }
+      }
+    });
+  }
+  common$1.finish(this);
+};
 
-      if (!arguments.length || typeof arguments[0] === 'number') {
-        // Constructor(unsigned long length)
-        this.length = ECMAScript.ToInt32(arguments[0]);
-        if (length < 0) throw new RangeError('ArrayBufferView size is not a small enough positive integer');
 
-        this.byteLength = this.length * this.BYTES_PER_ELEMENT;
-        this.buffer = new ArrayBuffer(this.byteLength);
-        this.byteOffset = 0;
-      } else if (typeof arguments[0] === 'object' && arguments[0].constructor === ctor) {
-        // Constructor(TypedArray array)
-        array = arguments[0];
+GlobSync$1.prototype._process = function (pattern, index, inGlobStar) {
+  assert$1(this instanceof GlobSync$1);
 
-        this.length = array.length;
-        this.byteLength = this.length * this.BYTES_PER_ELEMENT;
-        this.buffer = new ArrayBuffer(this.byteLength);
-        this.byteOffset = 0;
+  // Get the first [n] parts of pattern that are all strings.
+  var n = 0;
+  while (typeof pattern[n] === 'string') {
+    n ++;
+  }
+  // now n is the index of the first one that is *not* a string.
 
-        for (i = 0; i < this.length; i += 1) {
-          this._setter(i, array._getter(i));
-        }
-      } else if (typeof arguments[0] === 'object' &&
-                 !(arguments[0] instanceof ArrayBuffer || ECMAScript.Class(arguments[0]) === 'ArrayBuffer')) {
-        // Constructor(sequence<type> array)
-        sequence = arguments[0];
+  // See if there's anything else
+  var prefix;
+  switch (n) {
+    // if not, then this is rather simple
+    case pattern.length:
+      this._processSimple(pattern.join('/'), index);
+      return
 
-        this.length = ECMAScript.ToUint32(sequence.length);
-        this.byteLength = this.length * this.BYTES_PER_ELEMENT;
-        this.buffer = new ArrayBuffer(this.byteLength);
-        this.byteOffset = 0;
+    case 0:
+      // pattern *starts* with some non-trivial item.
+      // going to readdir(cwd), but not include the prefix in matches.
+      prefix = null;
+      break
 
-        for (i = 0; i < this.length; i += 1) {
-          s = sequence[i];
-          this._setter(i, Number(s));
-        }
-      } else if (typeof arguments[0] === 'object' &&
-                 (arguments[0] instanceof ArrayBuffer || ECMAScript.Class(arguments[0]) === 'ArrayBuffer')) {
-        // Constructor(ArrayBuffer buffer,
-        //             optional unsigned long byteOffset, optional unsigned long length)
-        this.buffer = buffer;
+    default:
+      // pattern has some string bits in the front.
+      // whatever it starts with, whether that's 'absolute' like /foo/bar,
+      // or 'relative' like '../baz'
+      prefix = pattern.slice(0, n).join('/');
+      break
+  }
 
-        this.byteOffset = ECMAScript.ToUint32(byteOffset);
-        if (this.byteOffset > this.buffer.byteLength) {
-          throw new RangeError("byteOffset out of range");
-        }
+  var remain = pattern.slice(n);
 
-        if (this.byteOffset % this.BYTES_PER_ELEMENT) {
-          // The given byteOffset must be a multiple of the element
-          // size of the specific type, otherwise an exception is raised.
-          throw new RangeError("ArrayBuffer length minus the byteOffset is not a multiple of the element size.");
-        }
+  // get the list of entries.
+  var read;
+  if (prefix === null)
+    read = '.';
+  else if (isAbsolute$1(prefix) || isAbsolute$1(pattern.join('/'))) {
+    if (!prefix || !isAbsolute$1(prefix))
+      prefix = '/' + prefix;
+    read = prefix;
+  } else
+    read = prefix;
 
-        if (arguments.length < 3) {
-          this.byteLength = this.buffer.byteLength - this.byteOffset;
+  var abs = this._makeAbs(read);
 
-          if (this.byteLength % this.BYTES_PER_ELEMENT) {
-            throw new RangeError("length of buffer minus byteOffset not a multiple of the element size");
-          }
-          this.length = this.byteLength / this.BYTES_PER_ELEMENT;
-        } else {
-          this.length = ECMAScript.ToUint32(length);
-          this.byteLength = this.length * this.BYTES_PER_ELEMENT;
-        }
+  //if ignored, skip processing
+  if (childrenIgnored$1(this, read))
+    return
 
-        if ((this.byteOffset + this.byteLength) > this.buffer.byteLength) {
-          throw new RangeError("byteOffset and length reference an area beyond the end of the buffer");
-        }
-      } else {
-        throw new TypeError("Unexpected argument type(s)");
-      }
+  var isGlobStar = remain[0] === minimatch$1.GLOBSTAR;
+  if (isGlobStar)
+    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
+  else
+    this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
+};
 
-      this.constructor = ctor;
 
-      configureProperties(this);
-      makeArrayAccessors(this);
-    };
+GlobSync$1.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
+  var entries = this._readdir(abs, inGlobStar);
 
-    ctor.prototype = new ArrayBufferView();
-    ctor.prototype.BYTES_PER_ELEMENT = bytesPerElement;
-    ctor.prototype._pack = pack;
-    ctor.prototype._unpack = unpack;
-    ctor.BYTES_PER_ELEMENT = bytesPerElement;
+  // if the abs isn't a dir, then nothing can match!
+  if (!entries)
+    return
 
-    // getter type (unsigned long index);
-    ctor.prototype._getter = function(index) {
-      if (arguments.length < 1) throw new SyntaxError("Not enough arguments");
+  // It will only match dot entries if it starts with a dot, or if
+  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
+  var pn = remain[0];
+  var negate = !!this.minimatch.negate;
+  var rawGlob = pn._glob;
+  var dotOk = this.dot || rawGlob.charAt(0) === '.';
 
-      index = ECMAScript.ToUint32(index);
-      if (index >= this.length) {
-        return undefined$1;
+  var matchedEntries = [];
+  for (var i = 0; i < entries.length; i++) {
+    var e = entries[i];
+    if (e.charAt(0) !== '.' || dotOk) {
+      var m;
+      if (negate && !prefix) {
+        m = !e.match(pn);
+      } else {
+        m = e.match(pn);
       }
+      if (m)
+        matchedEntries.push(e);
+    }
+  }
 
-      var bytes = [], i, o;
-      for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
-           i < this.BYTES_PER_ELEMENT;
-           i += 1, o += 1) {
-        bytes.push(this.buffer._bytes[o]);
-      }
-      return this._unpack(bytes);
-    };
+  var len = matchedEntries.length;
+  // If there are no matched entries, then nothing matches.
+  if (len === 0)
+    return
 
-    // NONSTANDARD: convenience alias for getter: type get(unsigned long index);
-    ctor.prototype.get = ctor.prototype._getter;
+  // if this is the last remaining pattern bit, then no need for
+  // an additional stat *unless* the user has specified mark or
+  // stat explicitly.  We know they exist, since readdir returned
+  // them.
 
-    // setter void (unsigned long index, type value);
-    ctor.prototype._setter = function(index, value) {
-      if (arguments.length < 2) throw new SyntaxError("Not enough arguments");
+  if (remain.length === 1 && !this.mark && !this.stat) {
+    if (!this.matches[index])
+      this.matches[index] = Object.create(null);
 
-      index = ECMAScript.ToUint32(index);
-      if (index >= this.length) {
-        return undefined$1;
+    for (var i = 0; i < len; i ++) {
+      var e = matchedEntries[i];
+      if (prefix) {
+        if (prefix.slice(-1) !== '/')
+          e = prefix + '/' + e;
+        else
+          e = prefix + e;
       }
 
-      var bytes = this._pack(value), i, o;
-      for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
-           i < this.BYTES_PER_ELEMENT;
-           i += 1, o += 1) {
-        this.buffer._bytes[o] = bytes[i];
+      if (e.charAt(0) === '/' && !this.nomount) {
+        e = path$2.join(this.root, e);
       }
-    };
+      this._emitMatch(index, e);
+    }
+    // This was the last one, and no stats were needed
+    return
+  }
 
-    // void set(TypedArray array, optional unsigned long offset);
-    // void set(sequence<type> array, optional unsigned long offset);
-    ctor.prototype.set = function(index, value) {
-      if (arguments.length < 1) throw new SyntaxError("Not enough arguments");
-      var array, sequence, offset, len,
-          i, s, d,
-          byteOffset, byteLength, tmp;
+  // now test all matched entries as stand-ins for that part
+  // of the pattern.
+  remain.shift();
+  for (var i = 0; i < len; i ++) {
+    var e = matchedEntries[i];
+    var newPattern;
+    if (prefix)
+      newPattern = [prefix, e];
+    else
+      newPattern = [e];
+    this._process(newPattern.concat(remain), index, inGlobStar);
+  }
+};
 
-      if (typeof arguments[0] === 'object' && arguments[0].constructor === this.constructor) {
-        // void set(TypedArray array, optional unsigned long offset);
-        array = arguments[0];
-        offset = ECMAScript.ToUint32(arguments[1]);
 
-        if (offset + array.length > this.length) {
-          throw new RangeError("Offset plus length of array is out of range");
-        }
+GlobSync$1.prototype._emitMatch = function (index, e) {
+  if (isIgnored$1(this, e))
+    return
 
-        byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT;
-        byteLength = array.length * this.BYTES_PER_ELEMENT;
+  var abs = this._makeAbs(e);
 
-        if (array.buffer === this.buffer) {
-          tmp = [];
-          for (i = 0, s = array.byteOffset; i < byteLength; i += 1, s += 1) {
-            tmp[i] = array.buffer._bytes[s];
-          }
-          for (i = 0, d = byteOffset; i < byteLength; i += 1, d += 1) {
-            this.buffer._bytes[d] = tmp[i];
-          }
-        } else {
-          for (i = 0, s = array.byteOffset, d = byteOffset;
-               i < byteLength; i += 1, s += 1, d += 1) {
-            this.buffer._bytes[d] = array.buffer._bytes[s];
-          }
-        }
-      } else if (typeof arguments[0] === 'object' && typeof arguments[0].length !== 'undefined') {
-        // void set(sequence<type> array, optional unsigned long offset);
-        sequence = arguments[0];
-        len = ECMAScript.ToUint32(sequence.length);
-        offset = ECMAScript.ToUint32(arguments[1]);
+  if (this.mark)
+    e = this._mark(e);
 
-        if (offset + len > this.length) {
-          throw new RangeError("Offset plus length of array is out of range");
-        }
+  if (this.absolute) {
+    e = abs;
+  }
 
-        for (i = 0; i < len; i += 1) {
-          s = sequence[i];
-          this._setter(offset + i, Number(s));
-        }
-      } else {
-        throw new TypeError("Unexpected argument type(s)");
-      }
-    };
+  if (this.matches[index][e])
+    return
 
-    // TypedArray subarray(long begin, optional long end);
-    ctor.prototype.subarray = function(start, end) {
-      function clamp(v, min, max) { return v < min ? min : v > max ? max : v; }
+  if (this.nodir) {
+    var c = this.cache[abs];
+    if (c === 'DIR' || Array.isArray(c))
+      return
+  }
 
-      start = ECMAScript.ToInt32(start);
-      end = ECMAScript.ToInt32(end);
+  this.matches[index][e] = true;
 
-      if (arguments.length < 1) { start = 0; }
-      if (arguments.length < 2) { end = this.length; }
+  if (this.stat)
+    this._stat(e);
+};
 
-      if (start < 0) { start = this.length + start; }
-      if (end < 0) { end = this.length + end; }
 
-      start = clamp(start, 0, this.length);
-      end = clamp(end, 0, this.length);
+GlobSync$1.prototype._readdirInGlobStar = function (abs) {
+  // follow all symlinked directories forever
+  // just proceed as if this is a non-globstar situation
+  if (this.follow)
+    return this._readdir(abs, false)
 
-      var len = end - start;
-      if (len < 0) {
-        len = 0;
-      }
+  var entries;
+  var lstat;
+  try {
+    lstat = fs$1.lstatSync(abs);
+  } catch (er) {
+    if (er.code === 'ENOENT') {
+      // lstat failed, doesn't exist
+      return null
+    }
+  }
 
-      return new this.constructor(
-        this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len);
-    };
+  var isSym = lstat && lstat.isSymbolicLink();
+  this.symlinks[abs] = isSym;
 
-    return ctor;
-  }
+  // If it's not a symlink or a dir, then it's definitely a regular file.
+  // don't bother doing a readdir in that case.
+  if (!isSym && lstat && !lstat.isDirectory())
+    this.cache[abs] = 'FILE';
+  else
+    entries = this._readdir(abs, false);
 
-  var Int8Array = makeConstructor(1, packI8, unpackI8);
-  var Uint8Array = makeConstructor(1, packU8, unpackU8);
-  var Uint8ClampedArray = makeConstructor(1, packU8Clamped, unpackU8);
-  var Int16Array = makeConstructor(2, packI16, unpackI16);
-  var Uint16Array = makeConstructor(2, packU16, unpackU16);
-  var Int32Array = makeConstructor(4, packI32, unpackI32);
-  var Uint32Array = makeConstructor(4, packU32, unpackU32);
-  var Float32Array = makeConstructor(4, packF32, unpackF32);
-  var Float64Array = makeConstructor(8, packF64, unpackF64);
+  return entries
+};
 
-  exports.Int8Array = exports.Int8Array || Int8Array;
-  exports.Uint8Array = exports.Uint8Array || Uint8Array;
-  exports.Uint8ClampedArray = exports.Uint8ClampedArray || Uint8ClampedArray;
-  exports.Int16Array = exports.Int16Array || Int16Array;
-  exports.Uint16Array = exports.Uint16Array || Uint16Array;
-  exports.Int32Array = exports.Int32Array || Int32Array;
-  exports.Uint32Array = exports.Uint32Array || Uint32Array;
-  exports.Float32Array = exports.Float32Array || Float32Array;
-  exports.Float64Array = exports.Float64Array || Float64Array;
-}());
+GlobSync$1.prototype._readdir = function (abs, inGlobStar) {
 
-//
-// 6 The DataView View Type
-//
+  if (inGlobStar && !ownProp$1(this.symlinks, abs))
+    return this._readdirInGlobStar(abs)
 
-(function() {
-  function r(array, index) {
-    return ECMAScript.IsCallable(array.get) ? array.get(index) : array[index];
+  if (ownProp$1(this.cache, abs)) {
+    var c = this.cache[abs];
+    if (!c || c === 'FILE')
+      return null
+
+    if (Array.isArray(c))
+      return c
   }
 
-  var IS_BIG_ENDIAN = (function() {
-    var u16array = new(exports.Uint16Array)([0x1234]),
-        u8array = new(exports.Uint8Array)(u16array.buffer);
-    return r(u8array, 0) === 0x12;
-  }());
+  try {
+    return this._readdirEntries(abs, fs$1.readdirSync(abs))
+  } catch (er) {
+    this._readdirError(abs, er);
+    return null
+  }
+};
 
-  // Constructor(ArrayBuffer buffer,
-  //             optional unsigned long byteOffset,
-  //             optional unsigned long byteLength)
-  /** @constructor */
-  var DataView = function DataView(buffer, byteOffset, byteLength) {
-    if (arguments.length === 0) {
-      buffer = new exports.ArrayBuffer(0);
-    } else if (!(buffer instanceof exports.ArrayBuffer || ECMAScript.Class(buffer) === 'ArrayBuffer')) {
-      throw new TypeError("TypeError");
+GlobSync$1.prototype._readdirEntries = function (abs, entries) {
+  // if we haven't asked to stat everything, then just
+  // assume that everything in there exists, so we can avoid
+  // having to stat it a second time.
+  if (!this.mark && !this.stat) {
+    for (var i = 0; i < entries.length; i ++) {
+      var e = entries[i];
+      if (abs === '/')
+        e = abs + e;
+      else
+        e = abs + '/' + e;
+      this.cache[e] = true;
     }
+  }
 
-    this.buffer = buffer || new exports.ArrayBuffer(0);
+  this.cache[abs] = entries;
 
-    this.byteOffset = ECMAScript.ToUint32(byteOffset);
-    if (this.byteOffset > this.buffer.byteLength) {
-      throw new RangeError("byteOffset out of range");
-    }
+  // mark and cache dir-ness
+  return entries
+};
 
-    if (arguments.length < 3) {
-      this.byteLength = this.buffer.byteLength - this.byteOffset;
-    } else {
-      this.byteLength = ECMAScript.ToUint32(byteLength);
-    }
+GlobSync$1.prototype._readdirError = function (f, er) {
+  // handle errors, and cache the information
+  switch (er.code) {
+    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
+    case 'ENOTDIR': // totally normal. means it *does* exist.
+      var abs = this._makeAbs(f);
+      this.cache[abs] = 'FILE';
+      if (abs === this.cwdAbs) {
+        var error = new Error(er.code + ' invalid cwd ' + this.cwd);
+        error.path = this.cwd;
+        error.code = er.code;
+        throw error
+      }
+      break
+
+    case 'ENOENT': // not terribly unusual
+    case 'ELOOP':
+    case 'ENAMETOOLONG':
+    case 'UNKNOWN':
+      this.cache[this._makeAbs(f)] = false;
+      break
 
-    if ((this.byteOffset + this.byteLength) > this.buffer.byteLength) {
-      throw new RangeError("byteOffset and length reference an area beyond the end of the buffer");
-    }
+    default: // some unusual error.  Treat as failure.
+      this.cache[this._makeAbs(f)] = false;
+      if (this.strict)
+        throw er
+      if (!this.silent)
+        console.error('glob error', er);
+      break
+  }
+};
 
-    configureProperties(this);
-  };
+GlobSync$1.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
 
-  function makeGetter(arrayType) {
-    return function(byteOffset, littleEndian) {
+  var entries = this._readdir(abs, inGlobStar);
 
-      byteOffset = ECMAScript.ToUint32(byteOffset);
+  // no entries means not a dir, so it can never have matches
+  // foo.txt/** doesn't match foo.txt
+  if (!entries)
+    return
 
-      if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) {
-        throw new RangeError("Array index out of range");
-      }
-      byteOffset += this.byteOffset;
+  // test without the globstar, and with every child both below
+  // and replacing the globstar.
+  var remainWithoutGlobStar = remain.slice(1);
+  var gspref = prefix ? [ prefix ] : [];
+  var noGlobStar = gspref.concat(remainWithoutGlobStar);
 
-      var uint8Array = new exports.Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT),
-          bytes = [], i;
-      for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) {
-        bytes.push(r(uint8Array, i));
-      }
+  // the noGlobStar pattern exits the inGlobStar state
+  this._process(noGlobStar, index, false);
 
-      if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) {
-        bytes.reverse();
-      }
+  var len = entries.length;
+  var isSym = this.symlinks[abs];
 
-      return r(new arrayType(new exports.Uint8Array(bytes).buffer), 0);
-    };
-  }
+  // If it's a symlink, and we're in a globstar, then stop
+  if (isSym && inGlobStar)
+    return
 
-  DataView.prototype.getUint8 = makeGetter(exports.Uint8Array);
-  DataView.prototype.getInt8 = makeGetter(exports.Int8Array);
-  DataView.prototype.getUint16 = makeGetter(exports.Uint16Array);
-  DataView.prototype.getInt16 = makeGetter(exports.Int16Array);
-  DataView.prototype.getUint32 = makeGetter(exports.Uint32Array);
-  DataView.prototype.getInt32 = makeGetter(exports.Int32Array);
-  DataView.prototype.getFloat32 = makeGetter(exports.Float32Array);
-  DataView.prototype.getFloat64 = makeGetter(exports.Float64Array);
+  for (var i = 0; i < len; i++) {
+    var e = entries[i];
+    if (e.charAt(0) === '.' && !this.dot)
+      continue
 
-  function makeSetter(arrayType) {
-    return function(byteOffset, value, littleEndian) {
+    // these two cases enter the inGlobStar state
+    var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+    this._process(instead, index, true);
 
-      byteOffset = ECMAScript.ToUint32(byteOffset);
-      if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) {
-        throw new RangeError("Array index out of range");
-      }
+    var below = gspref.concat(entries[i], remain);
+    this._process(below, index, true);
+  }
+};
 
-      // Get bytes
-      var typeArray = new arrayType([value]),
-          byteArray = new exports.Uint8Array(typeArray.buffer),
-          bytes = [], i, byteView;
+GlobSync$1.prototype._processSimple = function (prefix, index) {
+  // XXX review this.  Shouldn't it be doing the mounting etc
+  // before doing stat?  kinda weird?
+  var exists = this._stat(prefix);
 
-      for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) {
-        bytes.push(r(byteArray, i));
-      }
+  if (!this.matches[index])
+    this.matches[index] = Object.create(null);
 
-      // Flip if necessary
-      if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) {
-        bytes.reverse();
-      }
+  // If it doesn't exist, then just mark the lack of results
+  if (!exists)
+    return
 
-      // Write them
-      byteView = new exports.Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT);
-      byteView.set(bytes);
-    };
+  if (prefix && isAbsolute$1(prefix) && !this.nomount) {
+    var trail = /[\/\\]$/.test(prefix);
+    if (prefix.charAt(0) === '/') {
+      prefix = path$2.join(this.root, prefix);
+    } else {
+      prefix = path$2.resolve(this.root, prefix);
+      if (trail)
+        prefix += '/';
+    }
   }
 
-  DataView.prototype.setUint8 = makeSetter(exports.Uint8Array);
-  DataView.prototype.setInt8 = makeSetter(exports.Int8Array);
-  DataView.prototype.setUint16 = makeSetter(exports.Uint16Array);
-  DataView.prototype.setInt16 = makeSetter(exports.Int16Array);
-  DataView.prototype.setUint32 = makeSetter(exports.Uint32Array);
-  DataView.prototype.setInt32 = makeSetter(exports.Int32Array);
-  DataView.prototype.setFloat32 = makeSetter(exports.Float32Array);
-  DataView.prototype.setFloat64 = makeSetter(exports.Float64Array);
+  if (process.platform === 'win32')
+    prefix = prefix.replace(/\\/g, '/');
 
-  exports.DataView = exports.DataView || DataView;
+  // Mark this as a match
+  this._emitMatch(index, prefix);
+};
 
-}());
-});
-var typedarray_1 = typedarray.ArrayBuffer;
-var typedarray_2 = typedarray.Int8Array;
-var typedarray_3 = typedarray.Uint8Array;
-var typedarray_4 = typedarray.Uint8ClampedArray;
-var typedarray_5 = typedarray.Int16Array;
-var typedarray_6 = typedarray.Uint16Array;
-var typedarray_7 = typedarray.Int32Array;
-var typedarray_8 = typedarray.Uint32Array;
-var typedarray_9 = typedarray.Float32Array;
-var typedarray_10 = typedarray.Float64Array;
-var typedarray_11 = typedarray.DataView;
+// Returns either 'DIR', 'FILE', or false
+GlobSync$1.prototype._stat = function (f) {
+  var abs = this._makeAbs(f);
+  var needDir = f.slice(-1) === '/';
 
-var Writable = stream.Writable;
+  if (f.length > this.maxLength)
+    return false
 
+  if (!this.stat && ownProp$1(this.cache, abs)) {
+    var c = this.cache[abs];
 
+    if (Array.isArray(c))
+      c = 'DIR';
 
-if (typeof Uint8Array === 'undefined') {
-  var U8 = typedarray.Uint8Array;
-} else {
-  var U8 = Uint8Array;
-}
+    // It exists, but maybe not how we need it
+    if (!needDir || c === 'DIR')
+      return c
 
-function ConcatStream(opts, cb) {
-  if (!(this instanceof ConcatStream)) return new ConcatStream(opts, cb)
+    if (needDir && c === 'FILE')
+      return false
 
-  if (typeof opts === 'function') {
-    cb = opts;
-    opts = {};
+    // otherwise we have to stat, because maybe c=true
+    // if we know it exists, but not what it is.
   }
-  if (!opts) opts = {};
-
-  var encoding = opts.encoding;
-  var shouldInferEncoding = false;
+  var stat = this.statCache[abs];
+  if (!stat) {
+    var lstat;
+    try {
+      lstat = fs$1.lstatSync(abs);
+    } catch (er) {
+      if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+        this.statCache[abs] = false;
+        return false
+      }
+    }
 
-  if (!encoding) {
-    shouldInferEncoding = true;
-  } else {
-    encoding =  String(encoding).toLowerCase();
-    if (encoding === 'u8' || encoding === 'uint8') {
-      encoding = 'uint8array';
+    if (lstat && lstat.isSymbolicLink()) {
+      try {
+        stat = fs$1.statSync(abs);
+      } catch (er) {
+        stat = lstat;
+      }
+    } else {
+      stat = lstat;
     }
   }
 
-  Writable.call(this, { objectMode: true });
+  this.statCache[abs] = stat;
 
-  this.encoding = encoding;
-  this.shouldInferEncoding = shouldInferEncoding;
+  var c = true;
+  if (stat)
+    c = stat.isDirectory() ? 'DIR' : 'FILE';
 
-  if (cb) this.on('finish', function () { cb(this.getBody()); });
-  this.body = [];
-}
+  this.cache[abs] = this.cache[abs] || c;
 
-var concatStream = ConcatStream;
-inherits(ConcatStream, Writable);
+  if (needDir && c === 'FILE')
+    return false
 
-ConcatStream.prototype._write = function(chunk, enc, next) {
-  this.body.push(chunk);
-  next();
+  return c
 };
 
-ConcatStream.prototype.inferEncoding = function (buff) {
-  var firstBuffer = buff === undefined ? this.body[0] : buff;
-  if (Buffer.isBuffer(firstBuffer)) return 'buffer'
-  if (typeof Uint8Array !== 'undefined' && firstBuffer instanceof Uint8Array) return 'uint8array'
-  if (Array.isArray(firstBuffer)) return 'array'
-  if (typeof firstBuffer === 'string') return 'string'
-  if (Object.prototype.toString.call(firstBuffer) === "[object Object]") return 'object'
-  return 'buffer'
+GlobSync$1.prototype._mark = function (p) {
+  return common$1.mark(this, p)
 };
 
-ConcatStream.prototype.getBody = function () {
-  if (!this.encoding && this.body.length === 0) return []
-  if (this.shouldInferEncoding) this.encoding = this.inferEncoding();
-  if (this.encoding === 'array') return arrayConcat(this.body)
-  if (this.encoding === 'string') return stringConcat(this.body)
-  if (this.encoding === 'buffer') return bufferConcat(this.body)
-  if (this.encoding === 'uint8array') return u8Concat(this.body)
-  return this.body
+GlobSync$1.prototype._makeAbs = function (f) {
+  return common$1.makeAbs(this, f)
 };
 
-function isArrayish$1 (arr) {
-  return /Array\]$/.test(Object.prototype.toString.call(arr))
-}
-
-function isBufferish (p) {
-  return typeof p === 'string' || isArrayish$1(p) || (p && typeof p.subarray === 'function')
-}
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+var wrappy_1 = wrappy$2;
+function wrappy$2 (fn, cb) {
+  if (fn && cb) return wrappy$2(fn)(cb)
 
-function stringConcat (parts) {
-  var strings = [];
-  for (var i = 0; i < parts.length; i++) {
-    var p = parts[i];
-    if (typeof p === 'string') {
-      strings.push(p);
-    } else if (Buffer.isBuffer(p)) {
-      strings.push(p);
-    } else if (isBufferish(p)) {
-      strings.push(bufferFrom_1(p));
-    } else {
-      strings.push(bufferFrom_1(String(p)));
-    }
-  }
-  if (Buffer.isBuffer(parts[0])) {
-    strings = Buffer.concat(strings);
-    strings = strings.toString('utf8');
-  } else {
-    strings = strings.join('');
-  }
-  return strings
-}
+  if (typeof fn !== 'function')
+    throw new TypeError('need wrapper function')
 
-function bufferConcat (parts) {
-  var bufs = [];
-  for (var i = 0; i < parts.length; i++) {
-    var p = parts[i];
-    if (Buffer.isBuffer(p)) {
-      bufs.push(p);
-    } else if (isBufferish(p)) {
-      bufs.push(bufferFrom_1(p));
-    } else {
-      bufs.push(bufferFrom_1(String(p)));
-    }
-  }
-  return Buffer.concat(bufs)
-}
+  Object.keys(fn).forEach(function (k) {
+    wrapper[k] = fn[k];
+  });
 
-function arrayConcat (parts) {
-  var res = [];
-  for (var i = 0; i < parts.length; i++) {
-    res.push.apply(res, parts[i]);
-  }
-  return res
-}
+  return wrapper
 
-function u8Concat (parts) {
-  var len = 0;
-  for (var i = 0; i < parts.length; i++) {
-    if (typeof parts[i] === 'string') {
-      parts[i] = bufferFrom_1(parts[i]);
+  function wrapper() {
+    var args = new Array(arguments.length);
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
     }
-    len += parts[i].length;
-  }
-  var u8 = new U8(len);
-  for (var i = 0, offset = 0; i < parts.length; i++) {
-    var part = parts[i];
-    for (var j = 0; j < part.length; j++) {
-      u8[offset++] = part[j];
+    var ret = fn.apply(this, args);
+    var cb = args[args.length-1];
+    if (typeof ret === 'function' && ret !== cb) {
+      Object.keys(cb).forEach(function (k) {
+        ret[k] = cb[k];
+      });
     }
+    return ret
   }
-  return u8
 }
 
-var debug$1 = src('unified-engine:file-set-pipeline:stdin');
+var once$3 = {exports: {}};
 
+var wrappy$1 = wrappy_1;
+once$3.exports = wrappy$1(once$2);
+once$3.exports.strict = wrappy$1(onceStrict);
 
+once$2.proto = once$2(function () {
+  Object.defineProperty(Function.prototype, 'once', {
+    value: function () {
+      return once$2(this)
+    },
+    configurable: true
+  });
 
-var stdin_1 = stdin;
+  Object.defineProperty(Function.prototype, 'onceStrict', {
+    value: function () {
+      return onceStrict(this)
+    },
+    configurable: true
+  });
+});
 
-function stdin(context, settings, next) {
-  var streamIn = settings.streamIn;
-  var error;
+function once$2 (fn) {
+  var f = function () {
+    if (f.called) return f.value
+    f.called = true;
+    return f.value = fn.apply(this, arguments)
+  };
+  f.called = false;
+  return f
+}
 
-  if (settings.files && settings.files.length !== 0) {
-    debug$1('Ignoring `streamIn`');
+function onceStrict (fn) {
+  var f = function () {
+    if (f.called)
+      throw new Error(f.onceError)
+    f.called = true;
+    return f.value = fn.apply(this, arguments)
+  };
+  var name = fn.name || 'Function wrapped with `once`';
+  f.onceError = name + " shouldn't be called more than once";
+  f.called = false;
+  return f
+}
 
-    if (settings.filePath) {
-      error = new Error(
-        'Do not pass both `--file-path` and real files.\nDid you mean to pass stdin instead of files?'
-      );
-    }
+var wrappy = wrappy_1;
+var reqs = Object.create(null);
+var once$1 = once$3.exports;
 
-    next(error);
+var inflight_1 = wrappy(inflight$1);
 
-    return
+function inflight$1 (key, cb) {
+  if (reqs[key]) {
+    reqs[key].push(cb);
+    return null
+  } else {
+    reqs[key] = [cb];
+    return makeres(key)
   }
+}
 
-  if (streamIn.isTTY) {
-    debug$1('Cannot read from `tty` stream');
-    next(new Error('No input'));
+function makeres (key) {
+  return once$1(function RES () {
+    var cbs = reqs[key];
+    var len = cbs.length;
+    var args = slice$1(arguments);
 
-    return
-  }
+    // XXX It's somewhat ambiguous whether a new callback added in this
+    // pass should be queued for later execution if something in the
+    // list of callbacks throws, or if it should just be discarded.
+    // However, it's such an edge case that it hardly matters, and either
+    // choice is likely as surprising as the other.
+    // As it happens, we do go ahead and schedule it for later execution.
+    try {
+      for (var i = 0; i < len; i++) {
+        cbs[i].apply(null, args);
+      }
+    } finally {
+      if (cbs.length > len) {
+        // added more in the interim.
+        // de-zalgo, just in case, but don't call again.
+        cbs.splice(0, len);
+        process.nextTick(function () {
+          RES.apply(null, args);
+        });
+      } else {
+        delete reqs[key];
+      }
+    }
+  })
+}
+
+function slice$1 (args) {
+  var length = args.length;
+  var array = [];
+
+  for (var i = 0; i < length; i++) array[i] = args[i];
+  return array
+}
+
+// Approach:
+//
+// 1. Get the minimatch set
+// 2. For each pattern in the set, PROCESS(pattern, false)
+// 3. Store matches per-set, then uniq them
+//
+// PROCESS(pattern, inGlobStar)
+// Get the first [n] items from pattern that are all strings
+// Join these together.  This is PREFIX.
+//   If there is no more remaining, then stat(PREFIX) and
+//   add to matches if it succeeds.  END.
+//
+// If inGlobStar and PREFIX is symlink and points to dir
+//   set ENTRIES = []
+// else readdir(PREFIX) as ENTRIES
+//   If fail, END
+//
+// with ENTRIES
+//   If pattern[n] is GLOBSTAR
+//     // handle the case where the globstar match is empty
+//     // by pruning it out, and testing the resulting pattern
+//     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
+//     // handle other cases.
+//     for ENTRY in ENTRIES (not dotfiles)
+//       // attach globstar + tail onto the entry
+//       // Mark that this entry is a globstar match
+//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
+//
+//   else // not globstar
+//     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
+//       Test ENTRY against pattern[n]
+//       If fails, continue
+//       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
+//
+// Caveat:
+//   Cache all stats and readdirs results to minimize syscall.  Since all
+//   we ever care about is existence and directory-ness, we can just keep
+//   `true` for files, and [children,...] for directories, or `false` for
+//   things that don't exist.
 
-  debug$1('Reading from `streamIn`');
+var glob_1 = glob;
 
-  streamIn.pipe(concatStream({encoding: 'string'}, read));
+var fs = require$$0$3;
+var rp = fs_realpath;
+var minimatch = minimatch_1;
+var inherits$1 = inherits$2.exports;
+var EE = require$$0$5.EventEmitter;
+var path$1 = path$b;
+var assert = assert$2;
+var isAbsolute = pathIsAbsolute.exports;
+var globSync = sync$1;
+var common = common$2;
+common.alphasort;
+common.alphasorti;
+var setopts = common.setopts;
+var ownProp = common.ownProp;
+var inflight = inflight_1;
+var childrenIgnored = common.childrenIgnored;
+var isIgnored = common.isIgnored;
+
+var once = once$3.exports;
 
-  function read(value) {
-    var file = toVfile(settings.filePath || undefined);
+function glob (pattern, options, cb) {
+  if (typeof options === 'function') cb = options, options = {};
+  if (!options) options = {};
 
-    debug$1('Read from `streamIn`');
+  if (options.sync) {
+    if (cb)
+      throw new TypeError('callback provided to sync glob')
+    return globSync(pattern, options)
+  }
 
-    file.cwd = settings.cwd;
-    file.contents = value;
-    file.data.unifiedEngineGiven = true;
-    file.data.unifiedEngineStreamIn = true;
+  return new Glob(pattern, options, cb)
+}
 
-    context.files = [file];
+glob.sync = globSync;
+var GlobSync = glob.GlobSync = globSync.GlobSync;
 
-    // If `out` was not set, set `out`.
-    settings.out =
-      settings.out === null || settings.out === undefined ? true : settings.out;
+// old api surface
+glob.glob = glob;
 
-    next();
+function extend$1 (origin, add) {
+  if (add === null || typeof add !== 'object') {
+    return origin
+  }
+
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
   }
+  return origin
 }
 
-var inherits$1 = util$2.inherits;
+glob.hasMagic = function (pattern, options_) {
+  var options = extend$1({}, options_);
+  options.noprocess = true;
 
+  var g = new Glob(pattern, options);
+  var set = g.minimatch.set;
 
+  if (!pattern)
+    return false
 
-var fileSet = FileSet;
+  if (set.length > 1)
+    return true
 
-// FileSet constructor.
-function FileSet() {
-  var self = this;
+  for (var j = 0; j < set[0].length; j++) {
+    if (typeof set[0][j] !== 'string')
+      return true
+  }
 
-  self.files = [];
-  self.origins = [];
+  return false
+};
 
-  self.expected = 0;
-  self.actual = 0;
+glob.Glob = Glob;
+inherits$1(Glob, EE);
+function Glob (pattern, options, cb) {
+  if (typeof options === 'function') {
+    cb = options;
+    options = null;
+  }
 
-  self.pipeline = trough_1();
-  self.plugins = [];
+  if (options && options.sync) {
+    if (cb)
+      throw new TypeError('callback provided to sync glob')
+    return new GlobSync(pattern, options)
+  }
 
-  events.init.call(self);
+  if (!(this instanceof Glob))
+    return new Glob(pattern, options, cb)
 
-  self.on('one', one.bind(self));
-}
+  setopts(this, pattern, options);
+  this._didRealPath = false;
 
-// Events.
-inherits$1(FileSet, events.EventEmitter);
+  // process each pattern in the minimatch set
+  var n = this.minimatch.set.length;
 
-// Expose methods.
-FileSet.prototype.valueOf = valueOf;
-FileSet.prototype.use = use;
-FileSet.prototype.add = add;
+  // The matches are stored as {<filename>: true,...} so that
+  // duplicates are automagically pruned.
+  // Later, we do an Object.keys() on these.
+  // Keep them as a list so we can fill in when nonull is set.
+  this.matches = new Array(n);
 
-// Create an array representation of `fileSet`.
-function valueOf() {
-  return this.files
-}
+  if (typeof cb === 'function') {
+    cb = once(cb);
+    this.on('error', cb);
+    this.on('end', function (matches) {
+      cb(null, matches);
+    });
+  }
 
-// Attach middleware to the pipeline on `fileSet`.
-function use(plugin) {
   var self = this;
-  var pipeline = self.pipeline;
-  var duplicate = false;
+  this._processing = 0;
 
-  if (plugin && plugin.pluginId) {
-    duplicate = self.plugins.some(matches);
-  }
+  this._emitQueue = [];
+  this._processQueue = [];
+  this.paused = false;
 
-  if (!duplicate && self.plugins.indexOf(plugin) !== -1) {
-    duplicate = true;
-  }
+  if (this.noprocess)
+    return this
 
-  if (!duplicate) {
-    self.plugins.push(plugin);
-    pipeline.use(plugin);
-  }
+  if (n === 0)
+    return done()
 
-  return self
+  var sync = true;
+  for (var i = 0; i < n; i ++) {
+    this._process(this.minimatch.set[i], i, false, done);
+  }
+  sync = false;
 
-  function matches(fn) {
-    return fn.pluginId === plugin.pluginId
+  function done () {
+    --self._processing;
+    if (self._processing <= 0) {
+      if (sync) {
+        process.nextTick(function () {
+          self._finish();
+        });
+      } else {
+        self._finish();
+      }
+    }
   }
 }
 
-// Add a file to be processed.
-// Ignores duplicate files (based on the `filePath` at time of addition).
-// Only runs `file-pipeline` on files which have not `failed` before addition.
-function add(file) {
-  var self = this;
-  var origin;
-
-  if (typeof file === 'string') {
-    file = toVfile(file);
-  }
+Glob.prototype._finish = function () {
+  assert(this instanceof Glob);
+  if (this.aborted)
+    return
 
-  // Prevent files from being added multiple times.
-  origin = file.history[0];
+  if (this.realpath && !this._didRealpath)
+    return this._realpath()
 
-  if (self.origins.indexOf(origin) !== -1) {
-    return self
-  }
+  common.finish(this);
+  this.emit('end', this.found);
+};
 
-  self.origins.push(origin);
+Glob.prototype._realpath = function () {
+  if (this._didRealpath)
+    return
 
-  // Add.
-  self.valueOf().push(file);
-  self.expected++;
+  this._didRealpath = true;
 
-  // Force an asynchronous operation.
-  // This ensures that files which fall through the file pipeline immediately
-  // (such as, when already fatally failed) still queue up correctly.
-  setImmediate(add);
+  var n = this.matches.length;
+  if (n === 0)
+    return this._finish()
 
-  return self
+  var self = this;
+  for (var i = 0; i < this.matches.length; i++)
+    this._realpathSet(i, next);
 
-  function add() {
-    self.emit('add', file);
+  function next () {
+    if (--n === 0)
+      self._finish();
   }
-}
+};
 
-// Utility invoked when a single file has completed it's pipeline, triggering
-// `done` when all files are complete.
-function one() {
-  var self = this;
+Glob.prototype._realpathSet = function (index, cb) {
+  var matchset = this.matches[index];
+  if (!matchset)
+    return cb()
 
-  self.actual++;
+  var found = Object.keys(matchset);
+  var self = this;
+  var n = found.length;
 
-  if (self.actual >= self.expected) {
-    self.emit('done');
-  }
-}
+  if (n === 0)
+    return cb()
 
-var debug$2 = src('unified-engine:file-pipeline:read');
+  var set = this.matches[index] = Object.create(null);
+  found.forEach(function (p, i) {
+    // If there's a problem with the stat, then it means that
+    // one or more of the links in the realpath couldn't be
+    // resolved.  just return the abs value in that case.
+    p = self._makeAbs(p);
+    rp.realpath(p, self.realpathCache, function (er, real) {
+      if (!er)
+        set[real] = true;
+      else if (er.syscall === 'stat')
+        set[p] = true;
+      else
+        self.emit('error', er); // srsly wtf right here
 
+      if (--n === 0) {
+        self.matches[index] = set;
+        cb();
+      }
+    });
+  });
+};
 
-var read_1$1 = read$4;
+Glob.prototype._mark = function (p) {
+  return common.mark(this, p)
+};
 
-var resolve$4 = path$1.resolve;
-var readFile = fs$1.readFile;
+Glob.prototype._makeAbs = function (f) {
+  return common.makeAbs(this, f)
+};
 
-// Fill a file with its contents when not already filled.
-function read$4(context, file, fileSet, next) {
-  var filePath = file.path;
+Glob.prototype.abort = function () {
+  this.aborted = true;
+  this.emit('abort');
+};
 
-  if (file.contents || file.data.unifiedEngineStreamIn) {
-    debug$2('Not reading file `%s` with contents', filePath);
-    next();
-  } else if (vfileStatistics(file).fatal) {
-    debug$2('Not reading failed file `%s`', filePath);
-    next();
-  } else {
-    filePath = resolve$4(context.cwd, filePath);
+Glob.prototype.pause = function () {
+  if (!this.paused) {
+    this.paused = true;
+    this.emit('pause');
+  }
+};
 
-    debug$2('Reading `%s` in `%s`', filePath, 'utf8');
-    readFile(filePath, 'utf8', onread);
+Glob.prototype.resume = function () {
+  if (this.paused) {
+    this.emit('resume');
+    this.paused = false;
+    if (this._emitQueue.length) {
+      var eq = this._emitQueue.slice(0);
+      this._emitQueue.length = 0;
+      for (var i = 0; i < eq.length; i ++) {
+        var e = eq[i];
+        this._emitMatch(e[0], e[1]);
+      }
+    }
+    if (this._processQueue.length) {
+      var pq = this._processQueue.slice(0);
+      this._processQueue.length = 0;
+      for (var i = 0; i < pq.length; i ++) {
+        var p = pq[i];
+        this._processing--;
+        this._process(p[0], p[1], p[2], p[3]);
+      }
+    }
   }
+};
 
-  function onread(error, contents) {
-    debug$2('Read `%s` (error: %s)', filePath, error);
+Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
+  assert(this instanceof Glob);
+  assert(typeof cb === 'function');
 
-    file.contents = contents || '';
+  if (this.aborted)
+    return
 
-    next(error);
+  this._processing++;
+  if (this.paused) {
+    this._processQueue.push([pattern, index, inGlobStar, cb]);
+    return
   }
-}
-
-/**
- * Has own property.
- *
- * @type {Function}
- */
 
-var has = Object.prototype.hasOwnProperty;
+  //console.error('PROCESS %d', this._processing, pattern)
 
-/**
- * To string.
- *
- * @type {Function}
- */
+  // Get the first [n] parts of pattern that are all strings.
+  var n = 0;
+  while (typeof pattern[n] === 'string') {
+    n ++;
+  }
+  // now n is the index of the first one that is *not* a string.
 
-var toString$2 = Object.prototype.toString;
+  // see if there's anything else
+  var prefix;
+  switch (n) {
+    // if not, then this is rather simple
+    case pattern.length:
+      this._processSimple(pattern.join('/'), index, cb);
+      return
 
-/**
- * Test whether a value is "empty".
- *
- * @param {Mixed} val
- * @return {Boolean}
- */
+    case 0:
+      // pattern *starts* with some non-trivial item.
+      // going to readdir(cwd), but not include the prefix in matches.
+      prefix = null;
+      break
 
-function isEmpty(val) {
-  // Null and Undefined...
-  if (val == null) return true
+    default:
+      // pattern has some string bits in the front.
+      // whatever it starts with, whether that's 'absolute' like /foo/bar,
+      // or 'relative' like '../baz'
+      prefix = pattern.slice(0, n).join('/');
+      break
+  }
 
-  // Booleans...
-  if ('boolean' == typeof val) return false
+  var remain = pattern.slice(n);
 
-  // Numbers...
-  if ('number' == typeof val) return val === 0
+  // get the list of entries.
+  var read;
+  if (prefix === null)
+    read = '.';
+  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+    if (!prefix || !isAbsolute(prefix))
+      prefix = '/' + prefix;
+    read = prefix;
+  } else
+    read = prefix;
 
-  // Strings...
-  if ('string' == typeof val) return val.length === 0
+  var abs = this._makeAbs(read);
 
-  // Functions...
-  if ('function' == typeof val) return val.length === 0
+  //if ignored, skip _processing
+  if (childrenIgnored(this, read))
+    return cb()
 
-  // Arrays...
-  if (Array.isArray(val)) return val.length === 0
+  var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+  if (isGlobStar)
+    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
+  else
+    this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
+};
 
-  // Errors...
-  if (val instanceof Error) return val.message === ''
+Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
+  var self = this;
+  this._readdir(abs, inGlobStar, function (er, entries) {
+    return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
+  });
+};
 
-  // Objects...
-  if (val.toString == toString$2) {
-    switch (val.toString()) {
+Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
 
-      // Maps, Sets, Files and Errors...
-      case '[object File]':
-      case '[object Map]':
-      case '[object Set]': {
-        return val.size === 0
-      }
+  // if the abs isn't a dir, then nothing can match!
+  if (!entries)
+    return cb()
 
-      // Plain objects...
-      case '[object Object]': {
-        for (var key in val) {
-          if (has.call(val, key)) return false
-        }
+  // It will only match dot entries if it starts with a dot, or if
+  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
+  var pn = remain[0];
+  var negate = !!this.minimatch.negate;
+  var rawGlob = pn._glob;
+  var dotOk = this.dot || rawGlob.charAt(0) === '.';
 
-        return true
+  var matchedEntries = [];
+  for (var i = 0; i < entries.length; i++) {
+    var e = entries[i];
+    if (e.charAt(0) !== '.' || dotOk) {
+      var m;
+      if (negate && !prefix) {
+        m = !e.match(pn);
+      } else {
+        m = e.match(pn);
       }
+      if (m)
+        matchedEntries.push(e);
     }
   }
 
-  // Anything else...
-  return false
-}
-
-/**
- * Export `isEmpty`.
- *
- * @type {Function}
- */
-
-var lib$3 = isEmpty;
-
-var debug$3 = src('unified-engine:file-pipeline:configure');
+  //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
 
+  var len = matchedEntries.length;
+  // If there are no matched entries, then nothing matches.
+  if (len === 0)
+    return cb()
 
+  // if this is the last remaining pattern bit, then no need for
+  // an additional stat *unless* the user has specified mark or
+  // stat explicitly.  We know they exist, since readdir returned
+  // them.
 
-var configure_1$1 = configure$1;
+  if (remain.length === 1 && !this.mark && !this.stat) {
+    if (!this.matches[index])
+      this.matches[index] = Object.create(null);
 
-// Collect configuration for a file based on the context.
-function configure$1(context, file, fileSet, next) {
-  var config = context.configuration;
-  var processor = context.processor;
+    for (var i = 0; i < len; i ++) {
+      var e = matchedEntries[i];
+      if (prefix) {
+        if (prefix !== '/')
+          e = prefix + '/' + e;
+        else
+          e = prefix + e;
+      }
 
-  if (vfileStatistics(file).fatal) {
-    return next()
+      if (e.charAt(0) === '/' && !this.nomount) {
+        e = path$1.join(this.root, e);
+      }
+      this._emitMatch(index, e);
+    }
+    // This was the last one, and no stats were needed
+    return cb()
   }
 
-  config.load(file.path, handleConfiguration);
-
-  function handleConfiguration(error, configuration) {
-    var plugins;
-    var options;
-    var plugin;
-    var length;
-    var index;
-    var name;
-
-    if (error) {
-      return next(error)
+  // now test all matched entries as stand-ins for that part
+  // of the pattern.
+  remain.shift();
+  for (var i = 0; i < len; i ++) {
+    var e = matchedEntries[i];
+    if (prefix) {
+      if (prefix !== '/')
+        e = prefix + '/' + e;
+      else
+        e = prefix + e;
     }
+    this._process([e].concat(remain), index, inGlobStar, cb);
+  }
+  cb();
+};
 
-    // Store configuration on the context object.
-    debug$3('Using settings `%j`', configuration.settings);
-    processor.data('settings', configuration.settings);
-
-    plugins = configuration.plugins;
-    length = plugins.length;
-    index = -1;
+Glob.prototype._emitMatch = function (index, e) {
+  if (this.aborted)
+    return
 
-    debug$3('Using `%d` plugins', length);
+  if (isIgnored(this, e))
+    return
 
-    while (++index < length) {
-      plugin = plugins[index][0];
-      options = plugins[index][1];
+  if (this.paused) {
+    this._emitQueue.push([index, e]);
+    return
+  }
 
-      if (options === false) {
-        continue
-      }
+  var abs = isAbsolute(e) ? e : this._makeAbs(e);
 
-      // Allow for default arguments in es2020.
-      if (options === null || (typeof options === 'object' && lib$3(options))) {
-        options = undefined;
-      }
+  if (this.mark)
+    e = this._mark(e);
 
-      name = plugin.displayName || plugin.name || 'function';
-      debug$3('Using plugin `%s`, with options `%j`', name, options);
+  if (this.absolute)
+    e = abs;
 
-      try {
-        processor.use(plugin, options, fileSet);
-      } catch (error_) {
-        /* istanbul ignore next - Should not happen anymore! */
-        return next(error_)
-      }
-    }
+  if (this.matches[index][e])
+    return
 
-    next();
+  if (this.nodir) {
+    var c = this.cache[abs];
+    if (c === 'DIR' || Array.isArray(c))
+      return
   }
-}
-
-var debug$4 = src('unified-engine:file-pipeline:parse');
-
 
+  this.matches[index][e] = true;
 
-var parse_1 = parse$3;
+  var st = this.statCache[abs];
+  if (st)
+    this.emit('stat', e, st);
 
-// Fill a file with a tree.
-function parse$3(context, file) {
-  var message;
+  this.emit('match', e);
+};
 
-  if (vfileStatistics(file).fatal) {
+Glob.prototype._readdirInGlobStar = function (abs, cb) {
+  if (this.aborted)
     return
-  }
-
-  if (context.treeIn) {
-    debug$4('Not parsing already parsed document');
 
-    try {
-      context.tree = parseJson$1(file.toString());
-    } catch (error) {
-      message = file.message(
-        new Error('Cannot read file as JSON\n' + error.message)
-      );
-      message.fatal = true;
-    }
+  // follow all symlinked directories forever
+  // just proceed as if this is a non-globstar situation
+  if (this.follow)
+    return this._readdir(abs, false, cb)
 
-    // Add the preferred extension to ensure the file, when serialized, is
-    // correctly recognised.
-    // Only add it if there is a path — not if the file is for example stdin.
-    if (file.path) {
-      file.extname = context.extensions[0];
-    }
+  var lstatkey = 'lstat\0' + abs;
+  var self = this;
+  var lstatcb = inflight(lstatkey, lstatcb_);
 
-    file.contents = '';
+  if (lstatcb)
+    fs.lstat(abs, lstatcb);
 
-    return
-  }
+  function lstatcb_ (er, lstat) {
+    if (er && er.code === 'ENOENT')
+      return cb()
 
-  debug$4('Parsing `%s`', file.path);
+    var isSym = lstat && lstat.isSymbolicLink();
+    self.symlinks[abs] = isSym;
 
-  context.tree = context.processor.parse(file);
+    // If it's not a symlink or a dir, then it's definitely a regular file.
+    // don't bother doing a readdir in that case.
+    if (!isSym && lstat && !lstat.isDirectory()) {
+      self.cache[abs] = 'FILE';
+      cb();
+    } else
+      self._readdir(abs, false, cb);
+  }
+};
 
-  debug$4('Parsed document');
-}
+Glob.prototype._readdir = function (abs, inGlobStar, cb) {
+  if (this.aborted)
+    return
 
-var debug$5 = src('unified-engine:file-pipeline:transform');
+  cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb);
+  if (!cb)
+    return
 
+  //console.error('RD %j %j', +inGlobStar, abs)
+  if (inGlobStar && !ownProp(this.symlinks, abs))
+    return this._readdirInGlobStar(abs, cb)
 
-var transform_1 = transform;
+  if (ownProp(this.cache, abs)) {
+    var c = this.cache[abs];
+    if (!c || c === 'FILE')
+      return cb()
 
-// Transform the tree associated with a file with configured plugins.
-function transform(context, file, fileSet, next) {
-  if (vfileStatistics(file).fatal) {
-    next();
-  } else {
-    debug$5('Transforming document `%s`', file.path);
-    context.processor.run(context.tree, file, onrun);
+    if (Array.isArray(c))
+      return cb(null, c)
   }
+  fs.readdir(abs, readdirCb(this, abs, cb));
+};
 
-  function onrun(error, node) {
-    debug$5('Transformed document (error: %s)', error);
-    context.tree = node;
-    next(error);
+function readdirCb (self, abs, cb) {
+  return function (er, entries) {
+    if (er)
+      self._readdirError(abs, er, cb);
+    else
+      self._readdirEntries(abs, entries, cb);
   }
 }
 
-var debug$6 = src('unified-engine:file-pipeline:queue');
-
-
-var queue_1 = queue;
-
-// Queue all files which came this far.
-// When the last file gets here, run the file-set pipeline and flush the queue.
-function queue(context, file, fileSet, next) {
-  var origin = file.history[0];
-  var map = fileSet.complete;
-  var complete = true;
+Glob.prototype._readdirEntries = function (abs, entries, cb) {
+  if (this.aborted)
+    return
 
-  if (!map) {
-    map = {};
-    fileSet.complete = map;
+  // if we haven't asked to stat everything, then just
+  // assume that everything in there exists, so we can avoid
+  // having to stat it a second time.
+  if (!this.mark && !this.stat) {
+    for (var i = 0; i < entries.length; i ++) {
+      var e = entries[i];
+      if (abs === '/')
+        e = abs + e;
+      else
+        e = abs + '/' + e;
+      this.cache[e] = true;
+    }
   }
 
-  debug$6('Queueing `%s`', origin);
-
-  map[origin] = next;
-
-  fileSet.valueOf().forEach(each);
+  this.cache[abs] = entries;
+  return cb(null, entries)
+};
 
-  if (!complete) {
-    debug$6('Not flushing: some files cannot be flushed');
+Glob.prototype._readdirError = function (f, er, cb) {
+  if (this.aborted)
     return
-  }
-
-  fileSet.complete = {};
 
-  fileSet.pipeline.run(fileSet, done);
-
-  function each(file) {
-    var key = file.history[0];
-
-    if (vfileStatistics(file).fatal) {
-      return
-    }
-
-    if (typeof map[key] === 'function') {
-      debug$6('`%s` can be flushed', key);
-    } else {
-      debug$6('Interupting flush: `%s` is not finished', key);
-      complete = false;
-    }
-  }
+  // handle errors, and cache the information
+  switch (er.code) {
+    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
+    case 'ENOTDIR': // totally normal. means it *does* exist.
+      var abs = this._makeAbs(f);
+      this.cache[abs] = 'FILE';
+      if (abs === this.cwdAbs) {
+        var error = new Error(er.code + ' invalid cwd ' + this.cwd);
+        error.path = this.cwd;
+        error.code = er.code;
+        this.emit('error', error);
+        this.abort();
+      }
+      break
 
-  function done(error) {
-    debug$6('Flushing: all files can be flushed');
+    case 'ENOENT': // not terribly unusual
+    case 'ELOOP':
+    case 'ENAMETOOLONG':
+    case 'UNKNOWN':
+      this.cache[this._makeAbs(f)] = false;
+      break
 
-    // Flush.
-    for (origin in map) {
-      map[origin](error);
-    }
+    default: // some unusual error.  Treat as failure.
+      this.cache[this._makeAbs(f)] = false;
+      if (this.strict) {
+        this.emit('error', er);
+        // If the error is handled, then we abort
+        // if not, we threw out of here
+        this.abort();
+      }
+      if (!this.silent)
+        console.error('glob error', er);
+      break
   }
-}
 
-// Detect color support.
-var color = true;
+  return cb()
+};
 
-try {
-  color = 'inspect' in util$2;
-} catch (_) {
-  /* istanbul ignore next - browser */
-  color = false;
-}
+Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
+  var self = this;
+  this._readdir(abs, inGlobStar, function (er, entries) {
+    self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+  });
+};
 
-var unistUtilInspect = color ? inspect : /* istanbul ignore next */ noColor;
 
-inspect.color = inspect;
-noColor.color = inspect;
-inspect.noColor = noColor;
-noColor.noColor = noColor;
+Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+  //console.error('pgs2', prefix, remain[0], entries)
 
-var dim = ansiColor(2, 22);
-var yellow = ansiColor(33, 39);
-var green = ansiColor(32, 39);
+  // no entries means not a dir, so it can never have matches
+  // foo.txt/** doesn't match foo.txt
+  if (!entries)
+    return cb()
 
-// Define ANSII color removal functionality.
-var colorExpression = new RegExp(
-  '(?:' +
-    '(?:\\u001b\\[)|' +
-    '\\u009b' +
-    ')' +
-    '(?:' +
-    '(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m]' +
-    ')|' +
-    '\\u001b[A-M]',
-  'g'
-);
+  // test without the globstar, and with every child both below
+  // and replacing the globstar.
+  var remainWithoutGlobStar = remain.slice(1);
+  var gspref = prefix ? [ prefix ] : [];
+  var noGlobStar = gspref.concat(remainWithoutGlobStar);
 
-// Standard keys defined by unist: https://github.com/syntax-tree/unist.
-// We don’t ignore `data` though.
-var ignore$2 = ['type', 'value', 'children', 'position'];
+  // the noGlobStar pattern exits the inGlobStar state
+  this._process(noGlobStar, index, false, cb);
 
-// Inspects a node, without using color.
-function noColor(node, pad) {
-  return stripColor(inspect(node, pad))
-}
+  var isSym = this.symlinks[abs];
+  var len = entries.length;
 
-// Inspects a node.
-function inspect(node, pad) {
-  var result;
-  var children;
-  var index;
-  var length;
+  // If it's a symlink, and we're in a globstar, then stop
+  if (isSym && inGlobStar)
+    return cb()
 
-  if (node && Boolean(node.length) && typeof node !== 'string') {
-    length = node.length;
-    index = -1;
-    result = [];
+  for (var i = 0; i < len; i++) {
+    var e = entries[i];
+    if (e.charAt(0) === '.' && !this.dot)
+      continue
 
-    while (++index < length) {
-      result[index] = inspect(node[index]);
-    }
+    // these two cases enter the inGlobStar state
+    var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+    this._process(instead, index, true, cb);
 
-    return result.join('\n')
+    var below = gspref.concat(entries[i], remain);
+    this._process(below, index, true, cb);
   }
 
-  if (!node || !node.type) {
-    return String(node)
-  }
+  cb();
+};
 
-  result = [formatNode(node)];
-  children = node.children;
-  length = children && children.length;
-  index = -1;
+Glob.prototype._processSimple = function (prefix, index, cb) {
+  // XXX review this.  Shouldn't it be doing the mounting etc
+  // before doing stat?  kinda weird?
+  var self = this;
+  this._stat(prefix, function (er, exists) {
+    self._processSimple2(prefix, index, er, exists, cb);
+  });
+};
+Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
 
-  if (!length) {
-    return result[0]
-  }
+  //console.error('ps2', prefix, exists)
 
-  if (!pad || typeof pad === 'number') {
-    pad = '';
-  }
+  if (!this.matches[index])
+    this.matches[index] = Object.create(null);
 
-  while (++index < length) {
-    node = children[index];
+  // If it doesn't exist, then just mark the lack of results
+  if (!exists)
+    return cb()
 
-    if (index === length - 1) {
-      result.push(formatNesting(pad + '└─ ') + inspect(node, pad + '   '));
+  if (prefix && isAbsolute(prefix) && !this.nomount) {
+    var trail = /[\/\\]$/.test(prefix);
+    if (prefix.charAt(0) === '/') {
+      prefix = path$1.join(this.root, prefix);
     } else {
-      result.push(formatNesting(pad + '├─ ') + inspect(node, pad + '│  '));
+      prefix = path$1.resolve(this.root, prefix);
+      if (trail)
+        prefix += '/';
     }
   }
 
-  return result.join('\n')
-}
-
-// Colored nesting formatter.
-function formatNesting(value) {
-  return dim(value)
-}
-
-// Compile a single position.
-function compile(pos) {
-  var values = [];
+  if (process.platform === 'win32')
+    prefix = prefix.replace(/\\/g, '/');
 
-  if (!pos) {
-    return null
-  }
+  // Mark this as a match
+  this._emitMatch(index, prefix);
+  cb();
+};
 
-  values = [[pos.line || 1, pos.column || 1].join(':')];
+// Returns either 'DIR', 'FILE', or false
+Glob.prototype._stat = function (f, cb) {
+  var abs = this._makeAbs(f);
+  var needDir = f.slice(-1) === '/';
 
-  if ('offset' in pos) {
-    values.push(String(pos.offset || 0));
-  }
+  if (f.length > this.maxLength)
+    return cb()
 
-  return values
-}
+  if (!this.stat && ownProp(this.cache, abs)) {
+    var c = this.cache[abs];
 
-// Compile a location.
-function stringify$1(start, end) {
-  var values = [];
-  var positions = [];
-  var offsets = [];
+    if (Array.isArray(c))
+      c = 'DIR';
 
-  add(start);
-  add(end);
+    // It exists, but maybe not how we need it
+    if (!needDir || c === 'DIR')
+      return cb(null, c)
 
-  if (positions.length !== 0) {
-    values.push(positions.join('-'));
-  }
+    if (needDir && c === 'FILE')
+      return cb()
 
-  if (offsets.length !== 0) {
-    values.push(offsets.join('-'));
+    // otherwise we have to stat, because maybe c=true
+    // if we know it exists, but not what it is.
   }
-
-  return values.join(', ')
-
-  // Add a position.
-  function add(position) {
-    var tuple = compile(position);
-
-    if (tuple) {
-      positions.push(tuple[0]);
-
-      if (tuple[1]) {
-        offsets.push(tuple[1]);
-      }
+  var stat = this.statCache[abs];
+  if (stat !== undefined) {
+    if (stat === false)
+      return cb(null, stat)
+    else {
+      var type = stat.isDirectory() ? 'DIR' : 'FILE';
+      if (needDir && type === 'FILE')
+        return cb()
+      else
+        return cb(null, type, stat)
     }
   }
-}
-
-// Colored node formatter.
-function formatNode(node) {
-  var log = node.type;
-  var location = node.position || {};
-  var position = stringify$1(location.start, location.end);
-  var key;
-  var values = [];
-  var value;
-
-  if (node.children) {
-    log += dim('[') + yellow(node.children.length) + dim(']');
-  } else if (typeof node.value === 'string') {
-    log += dim(': ') + green(JSON.stringify(node.value));
-  }
-
-  if (position) {
-    log += ' (' + position + ')';
-  }
 
-  for (key in node) {
-    value = node[key];
+  var self = this;
+  var statcb = inflight('stat\0' + abs, lstatcb_);
+  if (statcb)
+    fs.lstat(abs, statcb);
 
-    if (
-      ignore$2.indexOf(key) !== -1 ||
-      value === null ||
-      value === undefined ||
-      (typeof value === 'object' && lib$3(value))
-    ) {
-      continue
+  function lstatcb_ (er, lstat) {
+    if (lstat && lstat.isSymbolicLink()) {
+      // If it's a symlink, then treat it as the target, unless
+      // the target does not exist, then treat it as a file.
+      return fs.stat(abs, function (er, stat) {
+        if (er)
+          self._stat2(f, abs, null, lstat, cb);
+        else
+          self._stat2(f, abs, er, stat, cb);
+      })
+    } else {
+      self._stat2(f, abs, er, lstat, cb);
     }
-
-    values.push('[' + key + '=' + JSON.stringify(value) + ']');
   }
+};
 
-  if (values.length !== 0) {
-    log += ' ' + values.join('');
+Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
+  if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+    this.statCache[abs] = false;
+    return cb()
   }
 
-  return log
-}
+  var needDir = f.slice(-1) === '/';
+  this.statCache[abs] = stat;
 
-// Remove ANSI colour from `value`.
-function stripColor(value) {
-  return value.replace(colorExpression, '')
-}
+  if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
+    return cb(null, false, stat)
 
-// Factory to wrap values in ANSI colours.
-function ansiColor(open, close) {
-  return color
+  var c = true;
+  if (stat)
+    c = stat.isDirectory() ? 'DIR' : 'FILE';
+  this.cache[abs] = this.cache[abs] || c;
 
-  function color(value) {
-    return '\u001B[' + open + 'm' + value + '\u001B[' + close + 'm'
-  }
-}
+  if (needDir && c === 'FILE')
+    return cb()
 
-var debug$7 = src('unified-engine:file-pipeline:stringify');
+  return cb(null, c, stat)
+};
 
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
 
+var isBuffer = function isBuffer (obj) {
+  return obj != null && obj.constructor != null &&
+    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+};
 
+const proc$1 = process;
 
-var stringify_1 = stringify$2;
+var own$b = {}.hasOwnProperty;
 
-// Stringify a tree.
-function stringify$2(context, file) {
-  var processor = context.processor;
-  var tree = context.tree;
-  var value;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Position} Position
+ * @typedef {import('unist').Point} Point
+ */
 
-  if (vfileStatistics(file).fatal) {
-    debug$7('Not compiling failed document');
-    return
+/**
+ * Stringify one point, a position (start and end points), or a node’s
+ * positional information.
+ *
+ * @param {Node|Position|Point} [value]
+ * @returns {string}
+ */
+function stringifyPosition$1(value) {
+  // Nothing.
+  if (!value || typeof value !== 'object') {
+    return ''
   }
 
-  if (!context.output && !context.out && !context.alwaysStringify) {
-    debug$7('Not compiling document without output settings');
-    return
+  // Node.
+  if (own$b.call(value, 'position') || own$b.call(value, 'type')) {
+    // @ts-ignore looks like a node.
+    return position(value.position)
   }
 
-  debug$7('Compiling `%s`', file.path);
-
-  if (context.inspect) {
-    // Add a `txt` extension if there is a path.
-    if (file.path) {
-      file.extname = '.txt';
-    }
-
-    value = unistUtilInspect[context.color ? 'color' : 'noColor'](tree) + '\n';
-  } else if (context.treeOut) {
-    // Add a `json` extension to ensure the file is correctly seen as JSON.
-    // Only add it if there is a path — not if the file is for example stdin.
-    if (file.path) {
-      file.extname = '.json';
-    }
-
-    // Add the line feed to create a valid UNIX file.
-    value = JSON.stringify(tree, null, 2) + '\n';
-  } else {
-    value = processor.stringify(tree, file);
+  // Position.
+  if (own$b.call(value, 'start') || own$b.call(value, 'end')) {
+    // @ts-ignore looks like a position.
+    return position(value)
   }
 
-  if (value === undefined || value === null) ; else if (typeof value === 'string' || isBuffer(value)) {
-    file.contents = value;
-  } else {
-    file.result = value;
+  // Point.
+  if (own$b.call(value, 'line') || own$b.call(value, 'column')) {
+    // @ts-ignore looks like a point.
+    return point$1(value)
   }
 
-  debug$7('Serialized document');
+  // ?
+  return ''
 }
 
-var debug$8 = src('unified-engine:file-pipeline:copy');
+/**
+ * @param {Point} point
+ * @returns {string}
+ */
+function point$1(point) {
+  return index$1(point && point.line) + ':' + index$1(point && point.column)
+}
 
-var copy_1 = copy;
+/**
+ * @param {Position} pos
+ * @returns {string}
+ */
+function position(pos) {
+  return point$1(pos && pos.start) + '-' + point$1(pos && pos.end)
+}
 
-var stat$1 = fs$1.stat;
-var dirname$2 = path$1.dirname;
-var resolve$5 = path$1.resolve;
-var relative$3 = path$1.relative;
+/**
+ * @param {number} value
+ * @returns {number}
+ */
+function index$1(value) {
+  return value && typeof value === 'number' ? value : 1
+}
 
-// Move a file.
-function copy(context, file, fileSet, next) {
-  var output = context.output;
-  var multi = fileSet.expected > 1;
-  var outpath = output;
-  var currentPath = file.path;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Position} Position
+ * @typedef {import('unist').Point} Point
+ */
 
-  if (typeof outpath !== 'string') {
-    debug$8('Not copying');
-    return next()
-  }
+class VFileMessage extends Error {
+  /**
+   * Constructor of a message for `reason` at `place` from `origin`.
+   * When an error is passed in as `reason`, copies the `stack`.
+   *
+   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
+   * @param {Node|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
+   * @param {string} [origin] Place in code the message originates from (`string`, optional).
+   */
+  constructor(reason, place, origin) {
+    /** @type {[string?, string?]} */
+    var parts = [null, null];
+    /** @type {Position} */
+    var position = {
+      start: {line: null, column: null},
+      end: {line: null, column: null}
+    };
+    /** @type {number} */
+    var index;
 
-  outpath = resolve$5(context.cwd, outpath);
+    super();
 
-  debug$8('Copying `%s`', currentPath);
+    if (typeof place === 'string') {
+      origin = place;
+      place = null;
+    }
 
-  stat$1(outpath, onstatfile);
+    if (typeof origin === 'string') {
+      index = origin.indexOf(':');
 
-  function onstatfile(error, stats) {
-    if (error) {
-      if (
-        error.code !== 'ENOENT' ||
-        output.charAt(output.length - 1) === path$1.sep
-      ) {
-        return next(
-          new Error('Cannot read output directory. Error:\n' + error.message)
-        )
+      if (index === -1) {
+        parts[1] = origin;
+      } else {
+        parts[0] = origin.slice(0, index);
+        parts[1] = origin.slice(index + 1);
       }
-
-      stat$1(dirname$2(outpath), onstatparent);
-    } else {
-      done(stats.isDirectory());
-    }
-  }
-
-  // This is either given an error, or the parent exists which is a directory,
-  // but we should keep the basename of the given file.
-  function onstatparent(error) {
-    if (error) {
-      next(new Error('Cannot read parent directory. Error:\n' + error.message));
-    } else {
-      done(false);
     }
-  }
 
-  function done(directory) {
-    if (!directory && multi) {
-      return next(
-        new Error('Cannot write multiple files to single output: ' + outpath)
-      )
+    if (place) {
+      // Node.
+      if ('type' in place || 'position' in place) {
+        if (place.position) {
+          position = place.position;
+        }
+      }
+      // Position.
+      else if ('start' in place || 'end' in place) {
+        // @ts-ignore Looks like a position.
+        position = place;
+      }
+      // Point.
+      else if ('line' in place || 'column' in place) {
+        // @ts-ignore Looks like a point.
+        position.start = place;
+      }
     }
 
-    file[directory ? 'dirname' : 'path'] = relative$3(file.cwd, outpath);
-
-    debug$8('Copying document from %s to %s', currentPath, file.path);
-
-    next();
-  }
-}
-
-var debug$9 = src('unified-engine:file-pipeline:stdout');
+    // Fields from `Error`
+    this.name = stringifyPosition$1(place) || '1:1';
+    this.message = typeof reason === 'object' ? reason.message : reason;
+    this.stack = typeof reason === 'object' ? reason.stack : '';
 
+    /**
+     * Reason for message.
+     * @type {string}
+     */
+    this.reason = this.message;
+    /**
+     * Starting line of error.
+     * @type {number?}
+     */
+    this.line = position.start.line;
+    /**
+     * Starting column of error.
+     * @type {number?}
+     */
+    this.column = position.start.column;
+    /**
+     * Namespace of warning.
+     * @type {string?}
+     */
+    this.source = parts[0];
+    /**
+     * Category of message.
+     * @type {string?}
+     */
+    this.ruleId = parts[1];
+    /**
+     * Full range information, when available.
+     * Has start and end properties, both set to an object with line and column, set to number?.
+     * @type {Position?}
+     */
+    this.position = position;
 
-var stdout_1 = stdout;
+    // The following fields are “well known”.
+    // Not standard.
+    // Feel free to add other non-standard fields to your messages.
 
-// Write a virtual file to `streamOut`.
-// Ignored when `output` is given, more than one file was processed, or `out`
-// is false.
-function stdout(context, file, fileSet, next) {
-  if (!file.data.unifiedEngineGiven) {
-    debug$9('Ignoring programmatically added file');
-    next();
-  } else if (vfileStatistics(file).fatal || context.output || !context.out) {
-    debug$9('Ignoring writing to `streamOut`');
-    next();
-  } else {
-    debug$9('Writing document to `streamOut`');
-    context.streamOut.write(file.toString(), next);
+    /* eslint-disable no-unused-expressions */
+    /**
+     * You may add a file property with a path of a file (used throughout the VFile ecosystem).
+     * @type {string?}
+     */
+    this.file;
+    /**
+     * If true, marks associated file as no longer processable.
+     * @type {boolean?}
+     */
+    this.fatal;
+    /**
+     * You may add a url property with a link to documentation for the message.
+     * @type {string?}
+     */
+    this.url;
+    /**
+     * You may add a note property with a long form description of the message (supported by vfile-reporter).
+     * @type {string?}
+     */
+    this.note;
+    /* eslint-enable no-unused-expressions */
   }
 }
 
-var debug$a = src('unified-engine:file-pipeline:file-system');
+VFileMessage.prototype.file = '';
+VFileMessage.prototype.name = '';
+VFileMessage.prototype.reason = '';
+VFileMessage.prototype.message = '';
+VFileMessage.prototype.stack = '';
+VFileMessage.prototype.fatal = null;
+VFileMessage.prototype.column = null;
+VFileMessage.prototype.line = null;
+VFileMessage.prototype.source = null;
+VFileMessage.prototype.ruleId = null;
+VFileMessage.prototype.position = null;
 
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Position} Position
+ * @typedef {import('unist').Point} Point
+ *
+ * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'latin1'|'binary'|'hex'} BufferEncoding
+ *   Encodings supported by the buffer class.
+ *   This is a copy of the typing from Node, copied to prevent Node globals from
+ *   being needed.
+ *   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/a2bc1d8/types/node/globals.d.ts#L174>
+ *
+ * @typedef {string|Uint8Array} VFileValue Contents of the file.
+ *   Can either be text, or a Buffer like structure.
+ *   This does not directly use type `Buffer`, because it can also be used in a
+ *   browser context.
+ *   Instead this leverages `Uint8Array` which is the base type for `Buffer`,
+ *   and a native JavaScript construct.
+ *
+ * @typedef {VFileValue|VFileOptions|VFile} VFileCompatible Things that can be
+ *   passed to the constructor.
+ *
+ * @typedef VFileCoreOptions
+ * @property {VFileValue} [value]
+ * @property {string} [cwd]
+ * @property {Array.<string>} [history]
+ * @property {string} [path]
+ * @property {string} [basename]
+ * @property {string} [stem]
+ * @property {string} [extname]
+ * @property {string} [dirname]
+ * @property {Object.<string, unknown>} [data]
+ *
+ * @typedef {{[key: string]: unknown} & VFileCoreOptions} VFileOptions
+ *   Configuration: a bunch of keys that will be shallow copied over to the new
+ *   file.
+ *
+ * @typedef {Object.<string, unknown>} VFileReporterSettings
+ * @typedef {<T = VFileReporterSettings>(files: VFile[], options: T) => string} VFileReporter
+ */
 
-var fileSystem_1$1 = fileSystem$1;
-
-var writeFile = fs$1.writeFile;
-var resolve$6 = path$1.resolve;
+// Order of setting (least specific to most), we need this because otherwise
+// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a
+// stem can be set.
+var order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
 
-// Write a virtual file to the file-system.
-// Ignored when `output` is not given.
-function fileSystem$1(context, file, fileSet, next) {
-  var destinationPath;
+class VFile {
+  /**
+   * Create a new virtual file.
+   *
+   * If `options` is `string` or `Buffer`, treats it as `{value: options}`.
+   * If `options` is a `VFile`, shallow copies its data over to the new file.
+   * All other given fields are set on the newly created `VFile`.
+   *
+   * Path related properties are set in the following order (least specific to
+   * most specific): `history`, `path`, `basename`, `stem`, `extname`,
+   * `dirname`.
+   *
+   * It’s not possible to set either `dirname` or `extname` without setting
+   * either `history`, `path`, `basename`, or `stem` as well.
+   *
+   * @param {VFileCompatible} [value]
+   */
+  constructor(value) {
+    var index = -1;
+    /** @type {VFileOptions} */
+    var options;
+    /** @type {string} */
+    var prop;
 
-  if (!context.output) {
-    debug$a('Ignoring writing to file-system');
-    return next()
-  }
+    if (!value) {
+      options = {};
+    } else if (typeof value === 'string' || isBuffer(value)) {
+      // @ts-ignore Looks like a buffer.
+      options = {value};
+    } else {
+      // @ts-ignore Looks like file or options.
+      options = value;
+    }
 
-  if (!file.data.unifiedEngineGiven) {
-    debug$a('Ignoring programmatically added file');
-    return next()
-  }
+    /**
+     * Place to store custom information.
+     * It’s OK to store custom data directly on the file, moving it to `data`
+     * gives a little more privacy.
+     * @type {Object.<string, unknown>}
+     */
+    this.data = {};
 
-  destinationPath = file.path;
+    /**
+     * List of messages associated with the file.
+     * @type {Array.<VFileMessage>}
+     */
+    this.messages = [];
 
-  if (!destinationPath) {
-    debug$a('Cannot write file without a `destinationPath`');
-    return next(new Error('Cannot write file without an output path'))
-  }
+    /**
+     * List of file paths the file moved between.
+     * @type {Array.<string>}
+     */
+    this.history = [];
 
-  if (vfileStatistics(file).fatal) {
-    debug$a('Cannot write file with a fatal error');
-    return next()
-  }
+    /**
+     * Base of `path`.
+     * Defaults to `process.cwd()` (`/` in browsers).
+     * @type {string}
+     */
+    this.cwd = proc$1.cwd();
 
-  destinationPath = resolve$6(context.cwd, destinationPath);
-  debug$a('Writing document to `%s`', destinationPath);
+    /* eslint-disable no-unused-expressions */
+    /**
+     * Raw value.
+     * @type {VFileValue}
+     */
+    this.value;
 
-  file.stored = true;
+    // The below are non-standard, they are “well-known”.
+    // As in, used in several tools.
 
-  writeFile(destinationPath, file.toString(), next);
-}
+    /**
+     * Whether a file was saved to disk.
+     * This is used by vfile reporters.
+     * @type {boolean}
+     */
+    this.stored;
 
-// This pipeline ensures each of the pipes always runs: even if the read pipe
-// fails, queue and write run.
-var filePipeline = trough_1()
-  .use(chunk(trough_1().use(read_1$1).use(configure_1$1).use(parse_1).use(transform_1)))
-  .use(chunk(trough_1().use(queue_1)))
-  .use(chunk(trough_1().use(stringify_1).use(copy_1).use(stdout_1).use(fileSystem_1$1)));
-
-// Factory to run a pipe.
-// Wraps a pipe to trigger an error on the `file` in `context`, but still call
-// `next`.
-function chunk(pipe) {
-  return run
+    /**
+     * Sometimes files have a non-string representation.
+     * This can be stored in the `result` field.
+     * One example is when turning markdown into React nodes.
+     * This is used by unified to store non-string results.
+     * @type {unknown}
+     */
+    this.result;
+    /* eslint-enable no-unused-expressions */
 
-  // Run the bound bound pipe and handles any errors.
-  function run(context, file, fileSet, next) {
-    pipe.run(context, file, fileSet, one);
+    // Set path related properties in the correct order.
+    while (++index < order.length) {
+      prop = order[index];
 
-    function one(error) {
-      var messages = file.messages;
-      var index;
+      // Note: we specifically use `in` instead of `hasOwnProperty` to accept
+      // `vfile`s too.
+      if (prop in options && options[prop] !== undefined) {
+        this[prop] = prop === 'history' ? options[prop].concat() : options[prop];
+      }
+    }
 
-      if (error) {
-        index = messages.indexOf(error);
+    // Set non-path related properties.
+    for (prop in options) {
+      if (!order.includes(prop)) {
+        this[prop] = options[prop];
+      }
+    }
+  }
 
-        if (index === -1) {
-          error = file.message(error);
-          index = messages.length - 1;
-        }
+  /**
+   * Access full path (`~/index.min.js`).
+   */
+  get path() {
+    return this.history[this.history.length - 1]
+  }
 
-        messages[index].fatal = true;
-      }
+  /**
+   * Set full path (`~/index.min.js`).
+   * Cannot be nullified.
+   */
+  set path(path) {
+    assertNonEmpty(path, 'path');
 
-      next();
+    if (this.path !== path) {
+      this.history.push(path);
     }
   }
-}
 
-var transform_1$1 = transform$1;
+  /**
+   * Access parent path (`~`).
+   */
+  get dirname() {
+    return typeof this.path === 'string' ? path$b.dirname(this.path) : undefined
+  }
 
-// Transform all files.
-function transform$1(context, settings, next) {
-  var fileSet$1 = new fileSet();
+  /**
+   * Set parent path (`~`).
+   * Cannot be set if there's no `path` yet.
+   */
+  set dirname(dirname) {
+    assertPath(this.path, 'dirname');
+    this.path = path$b.join(dirname || '', this.basename);
+  }
 
-  context.fileSet = fileSet$1;
+  /**
+   * Access basename (including extname) (`index.min.js`).
+   */
+  get basename() {
+    return typeof this.path === 'string' ? path$b.basename(this.path) : undefined
+  }
 
-  fileSet$1.on('add', add).on('done', next);
+  /**
+   * Set basename (`index.min.js`).
+   * Cannot contain path separators.
+   * Cannot be nullified either (use `file.path = file.dirname` instead).
+   */
+  set basename(basename) {
+    assertNonEmpty(basename, 'basename');
+    assertPart(basename, 'basename');
+    this.path = path$b.join(this.dirname || '', basename);
+  }
 
-  if (context.files.length === 0) {
-    next();
-  } else {
-    context.files.forEach(fileSet$1.add, fileSet$1);
+  /**
+   * Access extname (including dot) (`.js`).
+   */
+  get extname() {
+    return typeof this.path === 'string' ? path$b.extname(this.path) : undefined
   }
 
-  function add(file) {
-    filePipeline.run(
-      {
-        configuration: context.configuration,
-        processor: settings.processor(),
-        cwd: settings.cwd,
-        extensions: settings.extensions,
-        pluginPrefix: settings.pluginPrefix,
-        treeIn: settings.treeIn,
-        treeOut: settings.treeOut,
-        inspect: settings.inspect,
-        color: settings.color,
-        out: settings.out,
-        output: settings.output,
-        streamOut: settings.streamOut,
-        alwaysStringify: settings.alwaysStringify
-      },
-      file,
-      fileSet$1,
-      done
-    );
+  /**
+   * Set extname (including dot) (`.js`).
+   * Cannot be set if there's no `path` yet and cannot contain path separators.
+   */
+  set extname(extname) {
+    assertPart(extname, 'extname');
+    assertPath(this.path, 'extname');
 
-    function done(error) {
-      /* istanbul ignore next - Does not occur as all failures in `filePipeLine`
-       * are failed on each file.
-       * Still, just to ensure things work in the future, we add an extra
-       * check. */
-      if (error) {
-        error = file.message(error);
-        error.fatal = true;
+    if (extname) {
+      if (extname.charCodeAt(0) !== 46 /* `.` */) {
+        throw new Error('`extname` must start with `.`')
       }
 
-      fileSet$1.emit('one', file);
+      if (extname.includes('.', 1)) {
+        throw new Error('`extname` cannot contain multiple dots')
+      }
     }
-  }
-}
-
-var hasFlag$2 = (flag, argv) => {
-	argv = argv || process.argv;
-	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
-	const pos = argv.indexOf(prefix + flag);
-	const terminatorPos = argv.indexOf('--');
-	return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
-};
 
-const {env: env$2} = process;
+    this.path = path$b.join(this.dirname, this.stem + (extname || ''));
+  }
 
-let forceColor$2;
-if (hasFlag$2('no-color') ||
-	hasFlag$2('no-colors') ||
-	hasFlag$2('color=false') ||
-	hasFlag$2('color=never')) {
-	forceColor$2 = 0;
-} else if (hasFlag$2('color') ||
-	hasFlag$2('colors') ||
-	hasFlag$2('color=true') ||
-	hasFlag$2('color=always')) {
-	forceColor$2 = 1;
-}
-if ('FORCE_COLOR' in env$2) {
-	if (env$2.FORCE_COLOR === true || env$2.FORCE_COLOR === 'true') {
-		forceColor$2 = 1;
-	} else if (env$2.FORCE_COLOR === false || env$2.FORCE_COLOR === 'false') {
-		forceColor$2 = 0;
-	} else {
-		forceColor$2 = env$2.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env$2.FORCE_COLOR, 10), 3);
-	}
-}
+  /**
+   * Access stem (w/o extname) (`index.min`).
+   */
+  get stem() {
+    return typeof this.path === 'string'
+      ? path$b.basename(this.path, this.extname)
+      : undefined
+  }
 
-function translateLevel$2(level) {
-	if (level === 0) {
-		return false;
-	}
+  /**
+   * Set stem (w/o extname) (`index.min`).
+   * Cannot be nullified, and cannot contain path separators.
+   */
+  set stem(stem) {
+    assertNonEmpty(stem, 'stem');
+    assertPart(stem, 'stem');
+    this.path = path$b.join(this.dirname || '', stem + (this.extname || ''));
+  }
 
-	return {
-		level,
-		hasBasic: true,
-		has256: level >= 2,
-		has16m: level >= 3
-	};
-}
+  /**
+   * Serialize the file.
+   *
+   * @param {BufferEncoding} [encoding='utf8'] If `file.value` is a buffer, `encoding` is used to serialize buffers.
+   * @returns {string}
+   */
+  toString(encoding) {
+    // @ts-ignore string’s don’t accept the parameter, but buffers do.
+    return (this.value || '').toString(encoding)
+  }
 
-function supportsColor$2(stream) {
-	if (forceColor$2 === 0) {
-		return 0;
-	}
+  /**
+   * Create a message and associates it w/ the file.
+   *
+   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
+   * @param {Node|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
+   * @param {string} [origin] Place in code the message originates from (`string`, optional).
+   * @returns {VFileMessage}
+   */
+  message(reason, place, origin) {
+    var message = new VFileMessage(reason, place, origin);
 
-	if (hasFlag$2('color=16m') ||
-		hasFlag$2('color=full') ||
-		hasFlag$2('color=truecolor')) {
-		return 3;
-	}
+    if (this.path) {
+      message.name = this.path + ':' + message.name;
+      message.file = this.path;
+    }
 
-	if (hasFlag$2('color=256')) {
-		return 2;
-	}
+    message.fatal = false;
 
-	if (stream && !stream.isTTY && forceColor$2 === undefined) {
-		return 0;
-	}
+    this.messages.push(message);
 
-	const min = forceColor$2 || 0;
+    return message
+  }
 
-	if (env$2.TERM === 'dumb') {
-		return min;
-	}
+  /**
+   * Info: create a message, associate it with the file, and mark the fatality
+   * as `null`.
+   * Calls `message()` internally.
+   *
+   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
+   * @param {Node|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
+   * @param {string} [origin] Place in code the message originates from (`string`, optional).
+   * @returns {VFileMessage}
+   */
+  info(reason, place, origin) {
+    var message = this.message(reason, place, origin);
 
-	if (process.platform === 'win32') {
-		// Node.js 7.5.0 is the first version of Node.js to include a patch to
-		// libuv that enables 256 color output on Windows. Anything earlier and it
-		// won't work. However, here we target Node.js 8 at minimum as it is an LTS
-		// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
-		// release that supports 256 colors. Windows 10 build 14931 is the first release
-		// that supports 16m/TrueColor.
-		const osRelease = os.release().split('.');
-		if (
-			Number(process.versions.node.split('.')[0]) >= 8 &&
-			Number(osRelease[0]) >= 10 &&
-			Number(osRelease[2]) >= 10586
-		) {
-			return Number(osRelease[2]) >= 14931 ? 3 : 2;
-		}
+    message.fatal = null;
 
-		return 1;
-	}
+    return message
+  }
 
-	if ('CI' in env$2) {
-		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env$2) || env$2.CI_NAME === 'codeship') {
-			return 1;
-		}
+  /**
+   * Fail: create a message, associate it with the file, mark the fatality as
+   * `true`.
+   * Note: fatal errors mean a file is no longer processable.
+   * Calls `message()` internally.
+   *
+   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
+   * @param {Node|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
+   * @param {string} [origin] Place in code the message originates from (`string`, optional).
+   * @returns {never}
+   */
+  fail(reason, place, origin) {
+    var message = this.message(reason, place, origin);
 
-		return min;
-	}
+    message.fatal = true;
 
-	if ('TEAMCITY_VERSION' in env$2) {
-		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$2.TEAMCITY_VERSION) ? 1 : 0;
-	}
+    throw message
+  }
+}
 
-	if (env$2.COLORTERM === 'truecolor') {
-		return 3;
-	}
+/**
+ * Assert that `part` is not a path (as in, does not contain `path.sep`).
+ *
+ * @param {string} part
+ * @param {string} name
+ * @returns {void}
+ */
+function assertPart(part, name) {
+  if (part && part.includes(path$b.sep)) {
+    throw new Error(
+      '`' + name + '` cannot be a path: did not expect `' + path$b.sep + '`'
+    )
+  }
+}
 
-	if ('TERM_PROGRAM' in env$2) {
-		const version = parseInt((env$2.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+/**
+ * Assert that `part` is not empty.
+ *
+ * @param {string} part
+ * @param {string} name
+ * @returns {void}
+ */
+function assertNonEmpty(part, name) {
+  if (!part) {
+    throw new Error('`' + name + '` cannot be empty')
+  }
+}
 
-		switch (env$2.TERM_PROGRAM) {
-			case 'iTerm.app':
-				return version >= 3 ? 3 : 2;
-			case 'Apple_Terminal':
-				return 2;
-			// No default
-		}
-	}
+/**
+ * Assert `path` exists.
+ *
+ * @param {string} path
+ * @param {string} name
+ * @returns {void}
+ */
+function assertPath(path, name) {
+  if (!path) {
+    throw new Error('Setting `' + name + '` requires `path` to be set too')
+  }
+}
 
-	if (/-256(color)?$/i.test(env$2.TERM)) {
-		return 2;
-	}
+/**
+ * @typedef {import('vfile').VFileValue} Value
+ * @typedef {import('vfile').VFileOptions} Options
+ * @typedef {import('vfile').BufferEncoding} BufferEncoding
+ *
+ * @typedef {number|string} Mode
+ * @typedef {BufferEncoding|{encoding?: null|BufferEncoding, flag?: string}} ReadOptions
+ * @typedef {BufferEncoding|{encoding?: null|BufferEncoding, mode: Mode?, flag?: string}} WriteOptions
+ *
+ * @typedef {string|Uint8Array} Path Path of the file.
+ * @typedef {Path|URL|Options|VFile} Compatible Things that can be
+ *   passed to the function.
+ */
 
-	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$2.TERM)) {
-		return 1;
-	}
+/**
+ * Create a virtual file from a description.
+ * If `options` is a string or a buffer, it’s used as the path.
+ * If it’s a VFile itself, it’s returned instead.
+ * In all other cases, the options are passed through to `vfile()`.
+ *
+ * @param {Compatible} [options]
+ * @returns {VFile}
+ */
+function toVFile(options) {
+  if (typeof options === 'string' || isBuffer(options)) {
+    options = {path: String(options)};
+  } else if (options instanceof URL$1) {
+    options = {path: fileURLToPath(options)};
+  }
 
-	if ('COLORTERM' in env$2) {
-		return 1;
-	}
+  return looksLikeAVFile$1(options) ? options : new VFile(options)
+}
 
-	return min;
+/**
+ * Create a virtual file and read it in, synchronously.
+ *
+ * @param {Compatible} description
+ * @param {ReadOptions} [options]
+ * @returns {VFile}
+ */
+function readSync(description, options) {
+  var file = toVFile(description);
+  file.value = require$$0$3.readFileSync(path$b.resolve(file.cwd, file.path), options);
+  return file
 }
 
-function getSupportLevel$2(stream) {
-	const level = supportsColor$2(stream);
-	return translateLevel$2(level);
+/**
+ * Create a virtual file and write it in, synchronously.
+ *
+ * @param {Compatible} description
+ * @param {WriteOptions} [options]
+ * @returns {VFile}
+ */
+function writeSync(description, options) {
+  var file = toVFile(description);
+  require$$0$3.writeFileSync(path$b.resolve(file.cwd, file.path), file.value || '', options);
+  return file
 }
 
-var supportsColor_1$2 = {
-	supportsColor: getSupportLevel$2,
-	stdout: getSupportLevel$2(process.stdout),
-	stderr: getSupportLevel$2(process.stderr)
-};
-
-var ansiRegex = ({onlyFirst = false} = {}) => {
-	const pattern = [
-		'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
-		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
-	].join('|');
+const read$2 =
+  /**
+   * @type {{
+   *   (description: Compatible, options: ReadOptions, callback: Callback): void
+   *   (description: Compatible, callback: Callback): void
+   *   (description: Compatible, options?: ReadOptions): Promise<VFile>
+   * }}
+   */
+  (
+    /**
+     * Create a virtual file and read it in, asynchronously.
+     *
+     * @param {Compatible} description
+     * @param {ReadOptions} [options]
+     * @param {Callback} [callback]
+     */
+    function (description, options, callback) {
+      var file = toVFile(description);
 
-	return new RegExp(pattern, onlyFirst ? undefined : 'g');
-};
+      if (!callback && typeof options === 'function') {
+        callback = options;
+        options = null;
+      }
 
-var stripAnsi = string => typeof string === 'string' ? string.replace(ansiRegex(), '') : string;
+      if (!callback) {
+        return new Promise(executor)
+      }
 
-/* eslint-disable yoda */
+      executor(resolve, callback);
 
-const isFullwidthCodePoint = codePoint => {
-	if (Number.isNaN(codePoint)) {
-		return false;
-	}
+      /**
+       * @param {VFile} result
+       */
+      function resolve(result) {
+        callback(null, result);
+      }
 
-	// Code points are derived from:
-	// http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt
-	if (
-		codePoint >= 0x1100 && (
-			codePoint <= 0x115F || // Hangul Jamo
-			codePoint === 0x2329 || // LEFT-POINTING ANGLE BRACKET
-			codePoint === 0x232A || // RIGHT-POINTING ANGLE BRACKET
-			// CJK Radicals Supplement .. Enclosed CJK Letters and Months
-			(0x2E80 <= codePoint && codePoint <= 0x3247 && codePoint !== 0x303F) ||
-			// Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
-			(0x3250 <= codePoint && codePoint <= 0x4DBF) ||
-			// CJK Unified Ideographs .. Yi Radicals
-			(0x4E00 <= codePoint && codePoint <= 0xA4C6) ||
-			// Hangul Jamo Extended-A
-			(0xA960 <= codePoint && codePoint <= 0xA97C) ||
-			// Hangul Syllables
-			(0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
-			// CJK Compatibility Ideographs
-			(0xF900 <= codePoint && codePoint <= 0xFAFF) ||
-			// Vertical Forms
-			(0xFE10 <= codePoint && codePoint <= 0xFE19) ||
-			// CJK Compatibility Forms .. Small Form Variants
-			(0xFE30 <= codePoint && codePoint <= 0xFE6B) ||
-			// Halfwidth and Fullwidth Forms
-			(0xFF01 <= codePoint && codePoint <= 0xFF60) ||
-			(0xFFE0 <= codePoint && codePoint <= 0xFFE6) ||
-			// Kana Supplement
-			(0x1B000 <= codePoint && codePoint <= 0x1B001) ||
-			// Enclosed Ideographic Supplement
-			(0x1F200 <= codePoint && codePoint <= 0x1F251) ||
-			// CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
-			(0x20000 <= codePoint && codePoint <= 0x3FFFD)
-		)
-	) {
-		return true;
-	}
+      /**
+       * @param {(x: VFile) => void} resolve
+       * @param {(x: Error, y?: VFile) => void} reject
+       */
+      function executor(resolve, reject) {
+        /** @type {string} */
+        var fp;
 
-	return false;
-};
+        try {
+          fp = path$b.resolve(file.cwd, file.path);
+        } catch (error) {
+          return reject(error)
+        }
 
-var isFullwidthCodePoint_1 = isFullwidthCodePoint;
-var default_1$2 = isFullwidthCodePoint;
-isFullwidthCodePoint_1.default = default_1$2;
+        require$$0$3.readFile(fp, options, done);
 
-var emojiRegex = function () {
-  // https://mths.be/emoji
-  return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
-};
+        /**
+         * @param {Error} error
+         * @param {Value} result
+         */
+        function done(error, result) {
+          if (error) {
+            reject(error);
+          } else {
+            file.value = result;
+            resolve(file);
+          }
+        }
+      }
+    }
+  );
 
-const stringWidth = string => {
-	string = string.replace(emojiRegex(), '  ');
+const write =
+  /**
+   * @type {{
+   *   (description: Compatible, options: WriteOptions, callback: Callback): void
+   *   (description: Compatible, callback: Callback): void
+   *   (description: Compatible, options?: WriteOptions): Promise<VFile>
+   * }}
+   */
+  (
+    /**
+     * Create a virtual file and write it in, asynchronously.
+     *
+     * @param {Compatible} description
+     * @param {WriteOptions} [options]
+     * @param {Callback} [callback]
+     */
+    function (description, options, callback) {
+      var file = toVFile(description);
 
-	if (typeof string !== 'string' || string.length === 0) {
-		return 0;
-	}
+      // Weird, right? Otherwise `fs` doesn’t accept it.
+      if (!callback && typeof options === 'function') {
+        callback = options;
+        options = undefined;
+      }
 
-	string = stripAnsi(string);
+      if (!callback) {
+        return new Promise(executor)
+      }
 
-	let width = 0;
+      executor(resolve, callback);
 
-	for (let i = 0; i < string.length; i++) {
-		const code = string.codePointAt(i);
+      /**
+       * @param {VFile} result
+       */
+      function resolve(result) {
+        callback(null, result);
+      }
 
-		// Ignore control characters
-		if (code <= 0x1F || (code >= 0x7F && code <= 0x9F)) {
-			continue;
-		}
+      /**
+       * @param {(x: VFile) => void} resolve
+       * @param {(x: Error, y?: VFile) => void} reject
+       */
+      function executor(resolve, reject) {
+        /** @type {string} */
+        var fp;
 
-		// Ignore combining characters
-		if (code >= 0x300 && code <= 0x36F) {
-			continue;
-		}
+        try {
+          fp = path$b.resolve(file.cwd, file.path);
+        } catch (error) {
+          return reject(error)
+        }
 
-		// Surrogates
-		if (code > 0xFFFF) {
-			i++;
-		}
+        require$$0$3.writeFile(fp, file.value || '', options, done);
 
-		width += isFullwidthCodePoint_1(code) ? 2 : 1;
-	}
+        /**
+         * @param {Error} error
+         */
+        function done(error) {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(file);
+          }
+        }
+      }
+    }
+  );
 
-	return width;
-};
+/**
+ * @param {Compatible} value
+ * @returns {value is VFile}
+ */
+function looksLikeAVFile$1(value) {
+  return (
+    value &&
+    typeof value === 'object' &&
+    'message' in value &&
+    'messages' in value
+  )
+}
 
-var stringWidth_1 = stringWidth;
-// TODO: remove this in the next major version
-var default_1$3 = stringWidth;
-stringWidth_1.default = default_1$3;
+toVFile.readSync = readSync;
+toVFile.writeSync = writeSync;
+toVFile.read = read$2;
+toVFile.write = write;
 
-/*!
- * repeat-string <https://github.com/jonschlinkert/repeat-string>
+/**
+ * @typedef {import('fs').Stats} Stats
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('./ignore.js').Ignore} Ignore
+ * @typedef {import('ignore').Ignore} GitIgnore
  *
- * Copyright (c) 2014-2015, Jon Schlinkert.
- * Licensed under the MIT License.
+ * @typedef Options
+ * @property {string} cwd
+ * @property {Array.<string>} extensions
+ * @property {boolean|undefined} silentlyIgnore
+ * @property {Array.<string>} ignorePatterns
+ * @property {Ignore} ignore
+ *
+ * @typedef SearchResults
+ * @property {fs.Stats|undefined} stats
+ * @property {boolean|undefined} ignored
+ *
+ * @typedef Result
+ * @property {Array.<string|VFile>} input
+ * @property {VFile[]} output
+ *
+ * @typedef CleanResult
+ * @property {boolean} oneFileMode
+ * @property {VFile[]} files
+ *
+ * @callback Callback
+ * @param {Error|null} error
+ * @param {CleanResult} [result]
  */
 
 /**
- * Results cache
+ * Search `patterns`, a mix of globs, paths, and files.
+ *
+ * @param {Array.<string|VFile>} input
+ * @param {Options} options
+ * @param {Callback} callback
  */
-
-var res = '';
-var cache;
+function finder(input, options, callback) {
+  expand(input, options, (error, result) => {
+    // Glob errors are unusual.
+    // other errors are on the vfile results.
+    /* c8 ignore next 2 */
+    if (error || !result) {
+      callback(error);
+    } else {
+      callback(null, {oneFileMode: oneFileMode(result), files: result.output});
+    }
+  });
+}
 
 /**
- * Expose `repeat`
+ * Expand the given glob patterns, search given and found directories, and map
+ * to vfiles.
+ *
+ * @param {Array.<string|VFile>} input
+ * @param {Options} options
+ * @param {(error: Error|null, result?: Result) => void} next
  */
+function expand(input, options, next) {
+  /** @type {Array.<string|VFile>} */
+  let paths = [];
+  let actual = 0;
+  let expected = 0;
+  let index = -1;
+  /** @type {boolean|undefined} */
+  let failed;
+
+  while (++index < input.length) {
+    let file = input[index];
+    if (typeof file === 'string') {
+      if (glob_1.hasMagic(file)) {
+        expected++;
+        glob_1(file, {cwd: options.cwd}, (error, files) => {
+          // Glob errors are unusual.
+          /* c8 ignore next 3 */
+          if (failed) {
+            return
+          }
+
+          // Glob errors are unusual.
+          /* c8 ignore next 4 */
+          if (error) {
+            failed = true;
+            done1(error);
+          } else {
+            actual++;
+            paths = paths.concat(files);
+
+            if (actual === expected) {
+              search$1(paths, options, done1);
+            }
+          }
+        });
+      } else {
+        // `relative` to make the paths canonical.
+        file =
+          path$c.relative(options.cwd, path$c.resolve(options.cwd, file)) || '.';
+        paths.push(file);
+      }
+    } else {
+      const fp = file.path ? path$c.relative(options.cwd, file.path) : options.cwd;
+      file.cwd = options.cwd;
+      file.path = fp;
+      file.history = [fp];
+      paths.push(file);
+    }
+  }
+
+  if (!expected) {
+    search$1(paths, options, done1);
+  }
 
-var repeatString = repeat$1;
+  /**
+   * @param {Error|null} error
+   * @param {Array<VFile>} [files]
+   */
+  function done1(error, files) {
+    // `search` currently does not give errors.
+    /* c8 ignore next 2 */
+    if (error || !files) {
+      next(error);
+    } else {
+      next(null, {input: paths, output: files});
+    }
+  }
+}
 
 /**
- * Repeat the given `string` the specified `number`
- * of times.
- *
- * **Example:**
+ * Search `paths`.
  *
- * ```js
- * var repeat = require('repeat-string');
- * repeat('A', 5);
- * //=> AAAAA
- * ```
- *
- * @param {String} `string` The string to repeat
- * @param {Number} `number` The number of times to repeat the string
- * @return {String} Repeated string
- * @api public
+ * @param {Array.<string|VFile>} input
+ * @param {Options & {nested?: boolean}} options
+ * @param {(error: Error|null, files: Array.<VFile>) => void} next
  */
+function search$1(input, options, next) {
+  const extraIgnore = ignore().add(options.ignorePatterns);
+  let expected = 0;
+  let actual = 0;
+  let index = -1;
+  /** @type {Array.<VFile>} */
+  let files = [];
 
-function repeat$1(str, num) {
-  if (typeof str !== 'string') {
-    throw new TypeError('expected a string');
+  while (++index < input.length) {
+    each(input[index]);
   }
 
-  // cover common, quick use cases
-  if (num === 1) return str;
-  if (num === 2) return str + str;
-
-  var max = str.length * num;
-  if (cache !== str || typeof cache === 'undefined') {
-    cache = str;
-    res = '';
-  } else if (res.length >= max) {
-    return res.substr(0, max);
+  if (!expected) {
+    next(null, files);
   }
 
-  while (max > res.length && num > 1) {
-    if (num & 1) {
-      res += str;
+  /**
+   * @param {string|VFile} file
+   */
+  function each(file) {
+    const ext = typeof file === 'string' ? path$c.extname(file) : file.extname;
+
+    // Normalise globs.
+    if (typeof file === 'string') {
+      file = file.split('/').join(path$c.sep);
     }
 
-    num >>= 1;
-    str += str;
-  }
+    const part = base$1(file);
 
-  res += str;
-  res = res.substr(0, max);
-  return res;
+    if (options.nested && (part.charAt(0) === '.' || part === 'node_modules')) {
+      return
+    }
+
+    expected++;
+
+    statAndIgnore(
+      file,
+      Object.assign({}, options, {extraIgnore}),
+      (error, result) => {
+        const ignored = result && result.ignored;
+        const dir = result && result.stats && result.stats.isDirectory();
+
+        if (ignored && (options.nested || options.silentlyIgnore)) {
+          return one(null, [])
+        }
+
+        if (!ignored && dir) {
+          return fs$a.readdir(
+            path$c.resolve(options.cwd, filePath(file)),
+            (error, basenames) => {
+              // Should not happen often: the directory is `stat`ed first, which was ok,
+              // but reading it is not.
+              /* c8 ignore next 9 */
+              if (error) {
+                const otherFile = toVFile(filePath(file));
+                otherFile.cwd = options.cwd;
+
+                try {
+                  otherFile.fail('Cannot read directory');
+                } catch {}
+
+                one(null, [otherFile]);
+              } else {
+                search$1(
+                  basenames.map((name) => path$c.join(filePath(file), name)),
+                  Object.assign({}, options, {nested: true}),
+                  one
+                );
+              }
+            }
+          )
+        }
+
+        if (
+          !dir &&
+          options.nested &&
+          options.extensions.length > 0 &&
+          !options.extensions.includes(ext)
+        ) {
+          return one(null, [])
+        }
+
+        file = toVFile(file);
+        file.cwd = options.cwd;
+
+        if (ignored) {
+          try {
+            file.fail('Cannot process specified file: it’s ignored');
+            // C8 bug on Node@12
+            /* c8 ignore next 1 */
+          } catch {}
+        }
+
+        if (error && error.code === 'ENOENT') {
+          try {
+            file.fail(
+              error.syscall === 'stat' ? 'No such file or directory' : error
+            );
+            // C8 bug on Node@12
+            /* c8 ignore next 1 */
+          } catch {}
+        }
+
+        one(null, [file]);
+      }
+    );
+
+    /**
+     * Error is never given. Always given `results`.
+     *
+     * @param {Error|null} _
+     * @param {Array.<VFile>} results
+     */
+    function one(_, results) {
+      /* istanbul ignore else - Always given. */
+      if (results) {
+        files = files.concat(results);
+      }
+
+      actual++;
+
+      if (actual === expected) {
+        next(null, files);
+      }
+    }
+  }
 }
 
-var vfileSort = sort;
+/**
+ * @param {VFile|string} file
+ * @param {Options & {extraIgnore: GitIgnore}} options
+ * @param {(error: NodeJS.ErrnoException|null, result?: SearchResults) => void} callback
+ */
+function statAndIgnore(file, options, callback) {
+  const fp = path$c.resolve(options.cwd, filePath(file));
+  const normal = path$c.relative(options.cwd, fp);
+  let expected = 1;
+  let actual = 0;
+  /** @type {Stats|undefined} */
+  let stats;
+  /** @type {boolean|undefined} */
+  let ignored;
+
+  if (typeof file === 'string' || !file.value) {
+    expected++;
+    fs$a.stat(fp, (error, value) => {
+      stats = value;
+      onStartOrCheck(error);
+    });
+  }
+
+  options.ignore.check(fp, (error, value) => {
+    ignored = value;
+    onStartOrCheck(error);
+  });
 
-var severities = {
-  true: 2,
-  false: 1,
-  null: 0,
-  undefined: 0
-};
+  /**
+   * @param {Error|null} error
+   */
+  function onStartOrCheck(error) {
+    actual++;
 
-function sort(file) {
-  file.messages.sort(comparator);
-  return file
+    if (error) {
+      callback(error);
+      actual = -1;
+    } else if (actual === expected) {
+      callback(null, {
+        stats,
+        ignored:
+          ignored ||
+          (normal === '' ||
+          normal === '..' ||
+          normal.charAt(0) === path$c.sep ||
+          normal.slice(0, 3) === '..' + path$c.sep
+            ? false
+            : options.extraIgnore.ignores(normal))
+      });
+    }
+  }
 }
 
-function comparator(a, b) {
-  return (
-    check$1(a, b, 'line') ||
-    check$1(a, b, 'column') ||
-    severities[b.fatal] - severities[a.fatal] ||
-    compare(a, b, 'source') ||
-    compare(a, b, 'ruleId') ||
-    compare(a, b, 'reason') ||
-    0
-  )
+/**
+ * @param {string|VFile} file
+ * @returns {string}
+ */
+function base$1(file) {
+  return typeof file === 'string' ? path$c.basename(file) : file.basename
 }
 
-function check$1(a, b, property) {
-  return (a[property] || 0) - (b[property] || 0)
+/**
+ * @param {string|VFile} file
+ * @returns {string}
+ */
+function filePath(file) {
+  return typeof file === 'string' ? file : file.path
 }
 
-function compare(a, b, property) {
-  return (a[property] || '').localeCompare(b[property] || '')
+/**
+ * @param {Result} result
+ * @returns {boolean}
+ */
+function oneFileMode(result) {
+  return (
+    result.output.length === 1 &&
+    result.input.length === 1 &&
+    result.output[0].path === result.input[0]
+  )
 }
 
-var supported = supportsColor_1$2.stderr.hasBasic;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Settings} Settings
+ * @typedef {import('./index.js').Configuration} Configuration
+ */
 
+/**
+ * @param {Context} context
+ * @param {Settings} settings
+ * @param {Callback} next
+ */
+function fileSystem$1(context, settings, next) {
+  if (context.files.length === 0) {
+    next();
+  } else {
+    finder(
+      context.files,
+      {
+        cwd: settings.cwd,
+        extensions: settings.extensions,
+        silentlyIgnore: settings.silentlyIgnore,
+        ignorePatterns: settings.ignorePatterns,
+        ignore: new Ignore({
+          cwd: settings.cwd,
+          detectIgnore: settings.detectIgnore,
+          ignoreName: settings.ignoreName,
+          ignorePath: settings.ignorePath,
+          ignorePathResolveFrom: settings.ignorePathResolveFrom
+        })
+      },
+      (error, result) => {
+        // Glob errors typically don’t occur.
+        /* c8 ignore next 4 */
+        if (!result) {
+          next(error);
+          return
+        }
 
+        const output = result.files;
 
+        // Sort alphabetically.
+        // Everything is unique so we do not care about cases where left and right
+        // are equal.
+        output.sort(sortAlphabetically);
 
+        // Mark as given.
+        // This allows outputting files, which can be pretty dangerous, so it’s
+        // “hidden”.
+        let index = -1;
+        while (++index < output.length) {
+          output[index].data.unifiedEngineGiven = true;
+        }
 
+        context.files = output;
 
-var vfileReporter = reporter;
+        // If `out` was not set, detect it based on whether one file was given.
+        if (settings.out === null || settings.out === undefined) {
+          settings.out = result.oneFileMode;
+        }
 
-// Check which characters should be used.
-var windows$1 = process.platform === 'win32';
-// `log-symbols` without chalk:
-/* istanbul ignore next - Windows. */
-var chars = windows$1 ? {error: '×', warning: '‼'} : {error: '✖', warning: '⚠'};
+        next(error);
+      }
+    );
+  }
 
-// Match trailing white-space.
-var trailing = /\s*$/;
+  /**
+   * @param {VFile} left
+   * @param {VFile} right
+   * @returns {number}
+   */
+  function sortAlphabetically(left, right) {
+    return left.path < right.path ? -1 : 1
+  }
+}
 
-// Default filename.
-var defaultName = '<stdin>';
+/* eslint-disable node/no-deprecated-api */
 
-var noop = {open: '', close: ''};
+var toString$2 = Object.prototype.toString;
 
-var colors = {
-  underline: {open: '\u001B[4m', close: '\u001B[24m'},
-  red: {open: '\u001B[31m', close: '\u001B[39m'},
-  yellow: {open: '\u001B[33m', close: '\u001B[39m'},
-  green: {open: '\u001B[32m', close: '\u001B[39m'}
-};
+var isModern = (
+  typeof Buffer !== 'undefined' &&
+  typeof Buffer.alloc === 'function' &&
+  typeof Buffer.allocUnsafe === 'function' &&
+  typeof Buffer.from === 'function'
+);
 
-var noops = {
-  underline: noop,
-  red: noop,
-  yellow: noop,
-  green: noop
-};
+function isArrayBuffer (input) {
+  return toString$2.call(input).slice(8, -1) === 'ArrayBuffer'
+}
 
-var labels = {
-  true: 'error',
-  false: 'warning',
-  null: 'info',
-  undefined: 'info'
-};
+function fromArrayBuffer (obj, byteOffset, length) {
+  byteOffset >>>= 0;
 
-// Report a file’s messages.
-function reporter(files, options) {
-  var settings = options || {};
-  var one;
+  var maxLength = obj.byteLength - byteOffset;
 
-  if (!files) {
-    return ''
+  if (maxLength < 0) {
+    throw new RangeError("'offset' is out of bounds")
   }
 
-  // Error.
-  if ('name' in files && 'message' in files) {
-    return String(files.stack || files)
-  }
+  if (length === undefined) {
+    length = maxLength;
+  } else {
+    length >>>= 0;
 
-  // One file.
-  if (!('length' in files)) {
-    one = true;
-    files = [files];
+    if (length > maxLength) {
+      throw new RangeError("'length' is out of bounds")
+    }
   }
 
-  return compile$1(parse$4(filter$1(files, settings), settings), one, settings)
+  return isModern
+    ? Buffer.from(obj.slice(byteOffset, byteOffset + length))
+    : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)))
 }
 
-function filter$1(files, options) {
-  var result = [];
-  var length = files.length;
-  var index = -1;
-  var file;
+function fromString (string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8';
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('"encoding" must be a valid string encoding')
+  }
+
+  return isModern
+    ? Buffer.from(string, encoding)
+    : new Buffer(string, encoding)
+}
 
-  if (!options.quiet && !options.silent) {
-    return files.concat()
+function bufferFrom$1 (value, encodingOrOffset, length) {
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number')
   }
 
-  while (++index < length) {
-    file = files[index];
+  if (isArrayBuffer(value)) {
+    return fromArrayBuffer(value, encodingOrOffset, length)
+  }
 
-    if (applicable(file, options).length !== 0) {
-      result.push(file);
-    }
+  if (typeof value === 'string') {
+    return fromString(value, encodingOrOffset)
   }
 
-  return result
+  return isModern
+    ? Buffer.from(value)
+    : new Buffer(value)
 }
 
-function parse$4(files, options) {
-  var length = files.length;
-  var index = -1;
-  var rows = [];
-  var all = [];
-  var locationSize = 0;
-  var labelSize = 0;
-  var reasonSize = 0;
-  var ruleIdSize = 0;
-  var file;
-  var destination;
-  var origin;
-  var messages;
-  var offset;
-  var count;
-  var message;
-  var loc;
-  var reason;
-  var label;
-  var id;
-
-  while (++index < length) {
-    file = files[index];
-    destination = file.path;
-    origin = file.history[0] || destination;
-    messages = vfileSort({messages: applicable(file, options)}).messages;
-
-    if (rows.length !== 0 && rows[rows.length - 1].type !== 'header') {
-      rows.push({type: 'separator'});
-    }
-
-    rows.push({
-      type: 'header',
-      origin: origin,
-      destination: destination,
-      name: origin || options.defaultName || defaultName,
-      stored: Boolean(file.stored),
-      moved: Boolean(file.stored && destination !== origin),
-      stats: vfileStatistics(messages)
-    });
+var bufferFrom_1 = bufferFrom$1;
 
-    offset = -1;
-    count = messages.length;
+var typedarray = {};
 
-    while (++offset < count) {
-      message = messages[offset];
-      id = message.ruleId || '';
-      reason = message.stack || message.message;
-      loc = message.location;
-      loc = unistUtilStringifyPosition(loc.end.line && loc.end.column ? loc : loc.start);
+(function (exports) {
+var undefined$1 = (void 0); // Paranoia
 
-      if (options.verbose && message.note) {
-        reason += '\n' + message.note;
-      }
+// Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to
+// create, and consume so much memory, that the browser appears frozen.
+var MAX_ARRAY_LENGTH = 1e5;
+
+// Approximations of internal ECMAScript conversion functions
+var ECMAScript = (function() {
+  // Stash a copy in case other scripts modify these
+  var opts = Object.prototype.toString,
+      ophop = Object.prototype.hasOwnProperty;
+
+  return {
+    // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues:
+    Class: function(v) { return opts.call(v).replace(/^\[object *|\]$/g, ''); },
+    HasProperty: function(o, p) { return p in o; },
+    HasOwnProperty: function(o, p) { return ophop.call(o, p); },
+    IsCallable: function(o) { return typeof o === 'function'; },
+    ToInt32: function(v) { return v >> 0; },
+    ToUint32: function(v) { return v >>> 0; }
+  };
+}());
 
-      label = labels[message.fatal];
+// Snapshot intrinsics
+var LN2 = Math.LN2,
+    abs = Math.abs,
+    floor = Math.floor,
+    log = Math.log,
+    min = Math.min,
+    pow = Math.pow,
+    round = Math.round;
 
-      rows.push({
-        location: loc,
-        label: label,
-        reason: reason,
-        ruleId: id,
-        source: message.source
+// ES5: lock down object properties
+function configureProperties(obj) {
+  if (getOwnPropNames && defineProp) {
+    var props = getOwnPropNames(obj), i;
+    for (i = 0; i < props.length; i += 1) {
+      defineProp(obj, props[i], {
+        value: obj[props[i]],
+        writable: false,
+        enumerable: false,
+        configurable: false
       });
+    }
+  }
+}
+
+// emulate ES5 getter/setter API using legacy APIs
+// http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx
+// (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but
+// note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless)
+var defineProp;
+if (Object.defineProperty && (function() {
+      try {
+        Object.defineProperty({}, 'x', {});
+        return true;
+      } catch (e) {
+        return false;
+      }
+    })()) {
+  defineProp = Object.defineProperty;
+} else {
+  defineProp = function(o, p, desc) {
+    if (!o === Object(o)) throw new TypeError("Object.defineProperty called on non-object");
+    if (ECMAScript.HasProperty(desc, 'get') && Object.prototype.__defineGetter__) { Object.prototype.__defineGetter__.call(o, p, desc.get); }
+    if (ECMAScript.HasProperty(desc, 'set') && Object.prototype.__defineSetter__) { Object.prototype.__defineSetter__.call(o, p, desc.set); }
+    if (ECMAScript.HasProperty(desc, 'value')) { o[p] = desc.value; }
+    return o;
+  };
+}
 
-      locationSize = Math.max(realLength(loc), locationSize);
-      labelSize = Math.max(realLength(label), labelSize);
-      reasonSize = Math.max(realLength(reason), reasonSize);
-      ruleIdSize = Math.max(realLength(id), ruleIdSize);
+var getOwnPropNames = Object.getOwnPropertyNames || function (o) {
+  if (o !== Object(o)) throw new TypeError("Object.getOwnPropertyNames called on non-object");
+  var props = [], p;
+  for (p in o) {
+    if (ECMAScript.HasOwnProperty(o, p)) {
+      props.push(p);
     }
+  }
+  return props;
+};
+
+// ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value)
+// for index in 0 ... obj.length
+function makeArrayAccessors(obj) {
+  if (!defineProp) { return; }
+
+  if (obj.length > MAX_ARRAY_LENGTH) throw new RangeError("Array too large for polyfill");
 
-    all = all.concat(messages);
+  function makeArrayAccessor(index) {
+    defineProp(obj, index, {
+      'get': function() { return obj._getter(index); },
+      'set': function(v) { obj._setter(index, v); },
+      enumerable: true,
+      configurable: false
+    });
   }
 
-  return {
-    rows: rows,
-    statistics: vfileStatistics(all),
-    location: locationSize,
-    label: labelSize,
-    reason: reasonSize,
-    ruleId: ruleIdSize
+  var i;
+  for (i = 0; i < obj.length; i += 1) {
+    makeArrayAccessor(i);
   }
 }
 
-// eslint-disable-next-line complexity
-function compile$1(map, one, options) {
-  var enabled = options.color;
-  var all = map.statistics;
-  var rows = map.rows;
-  var length = rows.length;
-  var index = -1;
-  var lines = [];
-  var row;
-  var line;
-  var style;
-  var color;
-  var reason;
-  var rest;
-  var position;
+// Internal conversion functions:
+//    pack<Type>()   - take a number (interpreted as Type), output a byte array
+//    unpack<Type>() - take a byte array, output a Type-like number
 
-  if (enabled === null || enabled === undefined) {
-    enabled = supported;
-  }
+function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; }
+function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; }
+
+function packI8(n) { return [n & 0xff]; }
+function unpackI8(bytes) { return as_signed(bytes[0], 8); }
+
+function packU8(n) { return [n & 0xff]; }
+function unpackU8(bytes) { return as_unsigned(bytes[0], 8); }
+
+function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; }
+
+function packI16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
+function unpackI16(bytes) { return as_signed(bytes[0] << 8 | bytes[1], 16); }
+
+function packU16(n) { return [(n >> 8) & 0xff, n & 0xff]; }
+function unpackU16(bytes) { return as_unsigned(bytes[0] << 8 | bytes[1], 16); }
+
+function packI32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
+function unpackI32(bytes) { return as_signed(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
+
+function packU32(n) { return [(n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff]; }
+function unpackU32(bytes) { return as_unsigned(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], 32); }
 
-  style = enabled ? colors : noops;
+function packIEEE754(v, ebits, fbits) {
 
-  while (++index < length) {
-    row = rows[index];
+  var bias = (1 << (ebits - 1)) - 1,
+      s, e, f, i, bits, str, bytes;
 
-    if (row.type === 'separator') {
-      lines.push('');
-    } else if (row.type === 'header') {
-      if (one && !options.defaultName && !row.origin) {
-        line = '';
-      } else {
-        color =
-          style[row.stats.fatal ? 'red' : row.stats.total ? 'yellow' : 'green'];
-        line =
-          style.underline.open +
-          color.open +
-          row.name +
-          color.close +
-          style.underline.close;
-        line += row.moved ? ' > ' + row.destination : '';
-      }
+  function roundToEven(n) {
+    var w = floor(n), f = n - w;
+    if (f < 0.5)
+      return w;
+    if (f > 0.5)
+      return w + 1;
+    return w % 2 ? w + 1 : w;
+  }
 
-      if (!row.stats.total) {
-        line += line ? ': ' : '';
+  // Compute sign, exponent, fraction
+  if (v !== v) {
+    // NaN
+    // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
+    e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0;
+  } else if (v === Infinity || v === -Infinity) {
+    e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0;
+  } else if (v === 0) {
+    e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0;
+  } else {
+    s = v < 0;
+    v = abs(v);
 
-        if (row.stored) {
-          line += style.yellow.open + 'written' + style.yellow.close;
-        } else {
-          line += 'no issues found';
-        }
+    if (v >= pow(2, 1 - bias)) {
+      e = min(floor(log(v) / LN2), 1023);
+      f = roundToEven(v / pow(2, e) * pow(2, fbits));
+      if (f / pow(2, fbits) >= 2) {
+        e = e + 1;
+        f = 1;
       }
-
-      if (line) {
-        lines.push(line);
+      if (e > bias) {
+        // Overflow
+        e = (1 << ebits) - 1;
+        f = 0;
+      } else {
+        // Normalized
+        e = e + bias;
+        f = f - pow(2, fbits);
       }
     } else {
-      color = style[row.label === 'error' ? 'red' : 'yellow'];
-
-      reason = row.reason;
-      rest = '';
-      position = reason.indexOf('\n');
-
-      if (position !== -1) {
-        rest = reason.slice(position);
-        reason = reason.slice(0, position);
-      }
-
-      lines.push(
-        [
-          '',
-          padLeft(row.location, map.location),
-          padRight(color.open + row.label + color.close, map.label),
-          padRight(reason, map.reason),
-          padRight(row.ruleId, map.ruleId),
-          row.source || ''
-        ]
-          .join('  ')
-          .replace(trailing, '') + rest
-      );
+      // Denormalized
+      e = 0;
+      f = roundToEven(v / pow(2, 1 - bias - fbits));
     }
   }
 
-  if (all.fatal || all.warn) {
-    line = [];
+  // Pack sign, exponent, fraction
+  bits = [];
+  for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); }
+  for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); }
+  bits.push(s ? 1 : 0);
+  bits.reverse();
+  str = bits.join('');
 
-    if (all.fatal) {
-      line.push(
-        [
-          style.red.open + chars.error + style.red.close,
-          all.fatal,
-          plural$1(labels.true, all.fatal)
-        ].join(' ')
-      );
-    }
+  // Bits to bytes
+  bytes = [];
+  while (str.length) {
+    bytes.push(parseInt(str.substring(0, 8), 2));
+    str = str.substring(8);
+  }
+  return bytes;
+}
 
-    if (all.warn) {
-      line.push(
-        [
-          style.yellow.open + chars.warning + style.yellow.close,
-          all.warn,
-          plural$1(labels.false, all.warn)
-        ].join(' ')
-      );
-    }
+function unpackIEEE754(bytes, ebits, fbits) {
 
-    line = line.join(', ');
+  // Bytes to bits
+  var bits = [], i, j, b, str,
+      bias, s, e, f;
 
-    if (all.total !== all.fatal && all.total !== all.warn) {
-      line = all.total + ' messages (' + line + ')';
+  for (i = bytes.length; i; i -= 1) {
+    b = bytes[i - 1];
+    for (j = 8; j; j -= 1) {
+      bits.push(b % 2 ? 1 : 0); b = b >> 1;
     }
-
-    lines.push('', line);
   }
+  bits.reverse();
+  str = bits.join('');
 
-  return lines.join('\n')
-}
-
-function applicable(file, options) {
-  var messages = file.messages;
-  var length = messages.length;
-  var index = -1;
-  var result = [];
+  // Unpack sign, exponent, fraction
+  bias = (1 << (ebits - 1)) - 1;
+  s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
+  e = parseInt(str.substring(1, 1 + ebits), 2);
+  f = parseInt(str.substring(1 + ebits), 2);
 
-  if (options.silent) {
-    while (++index < length) {
-      if (messages[index].fatal) {
-        result.push(messages[index]);
-      }
-    }
+  // Produce number
+  if (e === (1 << ebits) - 1) {
+    return f !== 0 ? NaN : s * Infinity;
+  } else if (e > 0) {
+    // Normalized
+    return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
+  } else if (f !== 0) {
+    // Denormalized
+    return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
   } else {
-    result = messages.concat();
+    return s < 0 ? -0 : 0;
   }
-
-  return result
-}
-
-// Get the length of `value`, ignoring ANSI sequences.
-function realLength(value) {
-  var length = value.indexOf('\n');
-  return stringWidth_1(length === -1 ? value : value.slice(0, length))
-}
-
-// Pad `value` on the left.
-function padLeft(value, minimum) {
-  return repeatString(' ', minimum - realLength(value)) + value
-}
-
-// Pad `value` on the right.
-function padRight(value, minimum) {
-  return value + repeatString(' ', minimum - realLength(value))
 }
 
-function plural$1(value, count) {
-  return count === 1 ? value : value + 's'
-}
+function unpackF64(b) { return unpackIEEE754(b, 11, 52); }
+function packF64(v) { return packIEEE754(v, 11, 52); }
+function unpackF32(b) { return unpackIEEE754(b, 8, 23); }
+function packF32(v) { return packIEEE754(v, 8, 23); }
 
-var log_1 = log;
 
-var prefix = 'vfile-reporter';
+//
+// 3 The ArrayBuffer Type
+//
 
-function log(context, settings, next) {
-  var reporter = settings.reporter || vfileReporter;
-  var diagnostics;
+(function() {
 
-  if (typeof reporter === 'string') {
-    try {
-      reporter = loadPlugin_1(reporter, {cwd: settings.cwd, prefix: prefix});
-    } catch (_) {
-      next(new Error('Could not find reporter `' + reporter + '`'));
-      return
-    }
-  }
+  /** @constructor */
+  var ArrayBuffer = function ArrayBuffer(length) {
+    length = ECMAScript.ToInt32(length);
+    if (length < 0) throw new RangeError('ArrayBuffer size is not a small enough positive integer');
 
-  diagnostics = reporter(
-    context.files.filter(given),
-    Object.assign({}, settings.reporterOptions, {
-      quiet: settings.quiet,
-      silent: settings.silent,
-      color: settings.color
-    })
-  );
+    this.byteLength = length;
+    this._bytes = [];
+    this._bytes.length = length;
 
-  if (diagnostics) {
-    if (diagnostics.charAt(diagnostics.length - 1) !== '\n') {
-      diagnostics += '\n';
+    var i;
+    for (i = 0; i < this.byteLength; i += 1) {
+      this._bytes[i] = 0;
     }
 
-    settings.streamError.write(diagnostics, next);
-  } else {
-    next();
-  }
-}
-
-function given(file) {
-  return file.data.unifiedEngineGiven
-}
-
-var fileSetPipeline = trough_1()
-  .use(configure_1)
-  .use(fileSystem_1)
-  .use(stdin_1)
-  .use(transform_1$1)
-  .use(log_1);
+    configureProperties(this);
+  };
 
-var PassThrough = stream.PassThrough;
+  exports.ArrayBuffer = exports.ArrayBuffer || ArrayBuffer;
 
+  //
+  // 4 The ArrayBufferView Type
+  //
 
+  // NOTE: this constructor is not exported
+  /** @constructor */
+  var ArrayBufferView = function ArrayBufferView() {
+    //this.buffer = null;
+    //this.byteOffset = 0;
+    //this.byteLength = 0;
+  };
 
-var lib$4 = run;
+  //
+  // 5 The Typed Array View Types
+  //
 
-// Run the file set pipeline once.
-// `callback` is invoked with a fatal error, or with a status code (`0` on
-// success, `1` on failure).
-function run(options, callback) {
-  var settings = {};
-  var stdin = new PassThrough();
-  var tree;
-  var detectConfig;
-  var hasConfig;
-  var detectIgnore;
-  var hasIgnore;
+  function makeConstructor(bytesPerElement, pack, unpack) {
+    // Each TypedArray type requires a distinct constructor instance with
+    // identical logic, which this produces.
 
-  try {
-    stdin = process.stdin;
-  } catch (_) {
-    // Obscure bug in Node (seen on Windows).
-    // See: <https://github.com/nodejs/node/blob/f856234/lib/internal/process/stdio.js#L82>,
-    // <https://github.com/AtomLinter/linter-markdown/pull/85>.
-  }
+    var ctor;
+    ctor = function(buffer, byteOffset, length) {
+      var array, sequence, i, s;
 
-  if (!callback) {
-    throw new Error('Missing `callback`')
-  }
+      if (!arguments.length || typeof arguments[0] === 'number') {
+        // Constructor(unsigned long length)
+        this.length = ECMAScript.ToInt32(arguments[0]);
+        if (length < 0) throw new RangeError('ArrayBufferView size is not a small enough positive integer');
 
-  if (!options || !options.processor) {
-    return next(new Error('Missing `processor`'))
-  }
+        this.byteLength = this.length * this.BYTES_PER_ELEMENT;
+        this.buffer = new ArrayBuffer(this.byteLength);
+        this.byteOffset = 0;
+      } else if (typeof arguments[0] === 'object' && arguments[0].constructor === ctor) {
+        // Constructor(TypedArray array)
+        array = arguments[0];
 
-  // Processor.
-  settings.processor = options.processor;
+        this.length = array.length;
+        this.byteLength = this.length * this.BYTES_PER_ELEMENT;
+        this.buffer = new ArrayBuffer(this.byteLength);
+        this.byteOffset = 0;
 
-  // Path to run as.
-  settings.cwd = options.cwd || process.cwd();
+        for (i = 0; i < this.length; i += 1) {
+          this._setter(i, array._getter(i));
+        }
+      } else if (typeof arguments[0] === 'object' &&
+                 !(arguments[0] instanceof ArrayBuffer || ECMAScript.Class(arguments[0]) === 'ArrayBuffer')) {
+        // Constructor(sequence<type> array)
+        sequence = arguments[0];
 
-  // Input.
-  settings.files = options.files || [];
-  settings.extensions = (options.extensions || []).map(extension);
+        this.length = ECMAScript.ToUint32(sequence.length);
+        this.byteLength = this.length * this.BYTES_PER_ELEMENT;
+        this.buffer = new ArrayBuffer(this.byteLength);
+        this.byteOffset = 0;
 
-  settings.filePath = options.filePath || null;
-  settings.streamIn = options.streamIn || stdin;
+        for (i = 0; i < this.length; i += 1) {
+          s = sequence[i];
+          this._setter(i, Number(s));
+        }
+      } else if (typeof arguments[0] === 'object' &&
+                 (arguments[0] instanceof ArrayBuffer || ECMAScript.Class(arguments[0]) === 'ArrayBuffer')) {
+        // Constructor(ArrayBuffer buffer,
+        //             optional unsigned long byteOffset, optional unsigned long length)
+        this.buffer = buffer;
 
-  // Output.
-  settings.streamOut = options.streamOut || process.stdout;
-  settings.streamError = options.streamError || process.stderr;
-  settings.alwaysStringify = options.alwaysStringify;
-  settings.output = options.output;
-  settings.out = options.out;
+        this.byteOffset = ECMAScript.ToUint32(byteOffset);
+        if (this.byteOffset > this.buffer.byteLength) {
+          throw new RangeError("byteOffset out of range");
+        }
 
-  // Null overwrites config settings, `undefined` does not.
-  if (settings.output === null || settings.output === undefined) {
-    settings.output = undefined;
-  }
+        if (this.byteOffset % this.BYTES_PER_ELEMENT) {
+          // The given byteOffset must be a multiple of the element
+          // size of the specific type, otherwise an exception is raised.
+          throw new RangeError("ArrayBuffer length minus the byteOffset is not a multiple of the element size.");
+        }
 
-  if (settings.output && settings.out) {
-    return next(new Error('Cannot accept both `output` and `out`'))
-  }
+        if (arguments.length < 3) {
+          this.byteLength = this.buffer.byteLength - this.byteOffset;
 
-  // Process phase management.
-  tree = options.tree || false;
+          if (this.byteLength % this.BYTES_PER_ELEMENT) {
+            throw new RangeError("length of buffer minus byteOffset not a multiple of the element size");
+          }
+          this.length = this.byteLength / this.BYTES_PER_ELEMENT;
+        } else {
+          this.length = ECMAScript.ToUint32(length);
+          this.byteLength = this.length * this.BYTES_PER_ELEMENT;
+        }
 
-  settings.treeIn = options.treeIn;
-  settings.treeOut = options.treeOut;
-  settings.inspect = options.inspect;
+        if ((this.byteOffset + this.byteLength) > this.buffer.byteLength) {
+          throw new RangeError("byteOffset and length reference an area beyond the end of the buffer");
+        }
+      } else {
+        throw new TypeError("Unexpected argument type(s)");
+      }
 
-  if (settings.treeIn === null || settings.treeIn === undefined) {
-    settings.treeIn = tree;
-  }
+      this.constructor = ctor;
 
-  if (settings.treeOut === null || settings.treeOut === undefined) {
-    settings.treeOut = tree;
-  }
+      configureProperties(this);
+      makeArrayAccessors(this);
+    };
 
-  // Configuration.
-  detectConfig = options.detectConfig;
-  hasConfig = Boolean(options.rcName || options.packageField);
+    ctor.prototype = new ArrayBufferView();
+    ctor.prototype.BYTES_PER_ELEMENT = bytesPerElement;
+    ctor.prototype._pack = pack;
+    ctor.prototype._unpack = unpack;
+    ctor.BYTES_PER_ELEMENT = bytesPerElement;
 
-  if (detectConfig && !hasConfig) {
-    return next(
-      new Error('Missing `rcName` or `packageField` with `detectConfig`')
-    )
-  }
+    // getter type (unsigned long index);
+    ctor.prototype._getter = function(index) {
+      if (arguments.length < 1) throw new SyntaxError("Not enough arguments");
 
-  settings.detectConfig =
-    detectConfig === null || detectConfig === undefined
-      ? hasConfig
-      : detectConfig;
-  settings.rcName = options.rcName || null;
-  settings.rcPath = options.rcPath || null;
-  settings.packageField = options.packageField || null;
-  settings.settings = options.settings || {};
-  settings.configTransform = options.configTransform;
-  settings.defaultConfig = options.defaultConfig;
+      index = ECMAScript.ToUint32(index);
+      if (index >= this.length) {
+        return undefined$1;
+      }
 
-  // Ignore.
-  detectIgnore = options.detectIgnore;
-  hasIgnore = Boolean(options.ignoreName);
+      var bytes = [], i, o;
+      for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
+           i < this.BYTES_PER_ELEMENT;
+           i += 1, o += 1) {
+        bytes.push(this.buffer._bytes[o]);
+      }
+      return this._unpack(bytes);
+    };
 
-  settings.detectIgnore =
-    detectIgnore === null || detectIgnore === undefined
-      ? hasIgnore
-      : detectIgnore;
-  settings.ignoreName = options.ignoreName || null;
-  settings.ignorePath = options.ignorePath || null;
-  settings.ignorePathResolveFrom = options.ignorePathResolveFrom || 'dir';
-  settings.ignorePatterns = options.ignorePatterns || [];
-  settings.silentlyIgnore = Boolean(options.silentlyIgnore);
+    // NONSTANDARD: convenience alias for getter: type get(unsigned long index);
+    ctor.prototype.get = ctor.prototype._getter;
 
-  if (detectIgnore && !hasIgnore) {
-    return next(new Error('Missing `ignoreName` with `detectIgnore`'))
-  }
+    // setter void (unsigned long index, type value);
+    ctor.prototype._setter = function(index, value) {
+      if (arguments.length < 2) throw new SyntaxError("Not enough arguments");
 
-  // Plugins.
-  settings.pluginPrefix = options.pluginPrefix || null;
-  settings.plugins = options.plugins || {};
+      index = ECMAScript.ToUint32(index);
+      if (index >= this.length) {
+        return undefined$1;
+      }
 
-  // Reporting.
-  settings.reporter = options.reporter || null;
-  settings.reporterOptions = options.reporterOptions || null;
-  settings.color = options.color || false;
-  settings.silent = options.silent || false;
-  settings.quiet = options.quiet || false;
-  settings.frail = options.frail || false;
+      var bytes = this._pack(value), i, o;
+      for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
+           i < this.BYTES_PER_ELEMENT;
+           i += 1, o += 1) {
+        this.buffer._bytes[o] = bytes[i];
+      }
+    };
 
-  // Process.
-  fileSetPipeline.run({files: options.files || []}, settings, next);
+    // void set(TypedArray array, optional unsigned long offset);
+    // void set(sequence<type> array, optional unsigned long offset);
+    ctor.prototype.set = function(index, value) {
+      if (arguments.length < 1) throw new SyntaxError("Not enough arguments");
+      var array, sequence, offset, len,
+          i, s, d,
+          byteOffset, byteLength, tmp;
 
-  function next(error, context) {
-    var stats = vfileStatistics((context || {}).files);
-    var failed = Boolean(
-      settings.frail ? stats.fatal || stats.warn : stats.fatal
-    );
+      if (typeof arguments[0] === 'object' && arguments[0].constructor === this.constructor) {
+        // void set(TypedArray array, optional unsigned long offset);
+        array = arguments[0];
+        offset = ECMAScript.ToUint32(arguments[1]);
 
-    if (error) {
-      callback(error);
-    } else {
-      callback(null, failed ? 1 : 0, context);
-    }
-  }
-}
+        if (offset + array.length > this.length) {
+          throw new RangeError("Offset plus length of array is out of range");
+        }
 
-function extension(ext) {
-  return ext.charAt(0) === '.' ? ext : '.' + ext
-}
+        byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT;
+        byteLength = array.length * this.BYTES_PER_ELEMENT;
 
-var colorName$1 = {
-	"aliceblue": [240, 248, 255],
-	"antiquewhite": [250, 235, 215],
-	"aqua": [0, 255, 255],
-	"aquamarine": [127, 255, 212],
-	"azure": [240, 255, 255],
-	"beige": [245, 245, 220],
-	"bisque": [255, 228, 196],
-	"black": [0, 0, 0],
-	"blanchedalmond": [255, 235, 205],
-	"blue": [0, 0, 255],
-	"blueviolet": [138, 43, 226],
-	"brown": [165, 42, 42],
-	"burlywood": [222, 184, 135],
-	"cadetblue": [95, 158, 160],
-	"chartreuse": [127, 255, 0],
-	"chocolate": [210, 105, 30],
-	"coral": [255, 127, 80],
-	"cornflowerblue": [100, 149, 237],
-	"cornsilk": [255, 248, 220],
-	"crimson": [220, 20, 60],
-	"cyan": [0, 255, 255],
-	"darkblue": [0, 0, 139],
-	"darkcyan": [0, 139, 139],
-	"darkgoldenrod": [184, 134, 11],
-	"darkgray": [169, 169, 169],
-	"darkgreen": [0, 100, 0],
-	"darkgrey": [169, 169, 169],
-	"darkkhaki": [189, 183, 107],
-	"darkmagenta": [139, 0, 139],
-	"darkolivegreen": [85, 107, 47],
-	"darkorange": [255, 140, 0],
-	"darkorchid": [153, 50, 204],
-	"darkred": [139, 0, 0],
-	"darksalmon": [233, 150, 122],
-	"darkseagreen": [143, 188, 143],
-	"darkslateblue": [72, 61, 139],
-	"darkslategray": [47, 79, 79],
-	"darkslategrey": [47, 79, 79],
-	"darkturquoise": [0, 206, 209],
-	"darkviolet": [148, 0, 211],
-	"deeppink": [255, 20, 147],
-	"deepskyblue": [0, 191, 255],
-	"dimgray": [105, 105, 105],
-	"dimgrey": [105, 105, 105],
-	"dodgerblue": [30, 144, 255],
-	"firebrick": [178, 34, 34],
-	"floralwhite": [255, 250, 240],
-	"forestgreen": [34, 139, 34],
-	"fuchsia": [255, 0, 255],
-	"gainsboro": [220, 220, 220],
-	"ghostwhite": [248, 248, 255],
-	"gold": [255, 215, 0],
-	"goldenrod": [218, 165, 32],
-	"gray": [128, 128, 128],
-	"green": [0, 128, 0],
-	"greenyellow": [173, 255, 47],
-	"grey": [128, 128, 128],
-	"honeydew": [240, 255, 240],
-	"hotpink": [255, 105, 180],
-	"indianred": [205, 92, 92],
-	"indigo": [75, 0, 130],
-	"ivory": [255, 255, 240],
-	"khaki": [240, 230, 140],
-	"lavender": [230, 230, 250],
-	"lavenderblush": [255, 240, 245],
-	"lawngreen": [124, 252, 0],
-	"lemonchiffon": [255, 250, 205],
-	"lightblue": [173, 216, 230],
-	"lightcoral": [240, 128, 128],
-	"lightcyan": [224, 255, 255],
-	"lightgoldenrodyellow": [250, 250, 210],
-	"lightgray": [211, 211, 211],
-	"lightgreen": [144, 238, 144],
-	"lightgrey": [211, 211, 211],
-	"lightpink": [255, 182, 193],
-	"lightsalmon": [255, 160, 122],
-	"lightseagreen": [32, 178, 170],
-	"lightskyblue": [135, 206, 250],
-	"lightslategray": [119, 136, 153],
-	"lightslategrey": [119, 136, 153],
-	"lightsteelblue": [176, 196, 222],
-	"lightyellow": [255, 255, 224],
-	"lime": [0, 255, 0],
-	"limegreen": [50, 205, 50],
-	"linen": [250, 240, 230],
-	"magenta": [255, 0, 255],
-	"maroon": [128, 0, 0],
-	"mediumaquamarine": [102, 205, 170],
-	"mediumblue": [0, 0, 205],
-	"mediumorchid": [186, 85, 211],
-	"mediumpurple": [147, 112, 219],
-	"mediumseagreen": [60, 179, 113],
-	"mediumslateblue": [123, 104, 238],
-	"mediumspringgreen": [0, 250, 154],
-	"mediumturquoise": [72, 209, 204],
-	"mediumvioletred": [199, 21, 133],
-	"midnightblue": [25, 25, 112],
-	"mintcream": [245, 255, 250],
-	"mistyrose": [255, 228, 225],
-	"moccasin": [255, 228, 181],
-	"navajowhite": [255, 222, 173],
-	"navy": [0, 0, 128],
-	"oldlace": [253, 245, 230],
-	"olive": [128, 128, 0],
-	"olivedrab": [107, 142, 35],
-	"orange": [255, 165, 0],
-	"orangered": [255, 69, 0],
-	"orchid": [218, 112, 214],
-	"palegoldenrod": [238, 232, 170],
-	"palegreen": [152, 251, 152],
-	"paleturquoise": [175, 238, 238],
-	"palevioletred": [219, 112, 147],
-	"papayawhip": [255, 239, 213],
-	"peachpuff": [255, 218, 185],
-	"peru": [205, 133, 63],
-	"pink": [255, 192, 203],
-	"plum": [221, 160, 221],
-	"powderblue": [176, 224, 230],
-	"purple": [128, 0, 128],
-	"rebeccapurple": [102, 51, 153],
-	"red": [255, 0, 0],
-	"rosybrown": [188, 143, 143],
-	"royalblue": [65, 105, 225],
-	"saddlebrown": [139, 69, 19],
-	"salmon": [250, 128, 114],
-	"sandybrown": [244, 164, 96],
-	"seagreen": [46, 139, 87],
-	"seashell": [255, 245, 238],
-	"sienna": [160, 82, 45],
-	"silver": [192, 192, 192],
-	"skyblue": [135, 206, 235],
-	"slateblue": [106, 90, 205],
-	"slategray": [112, 128, 144],
-	"slategrey": [112, 128, 144],
-	"snow": [255, 250, 250],
-	"springgreen": [0, 255, 127],
-	"steelblue": [70, 130, 180],
-	"tan": [210, 180, 140],
-	"teal": [0, 128, 128],
-	"thistle": [216, 191, 216],
-	"tomato": [255, 99, 71],
-	"turquoise": [64, 224, 208],
-	"violet": [238, 130, 238],
-	"wheat": [245, 222, 179],
-	"white": [255, 255, 255],
-	"whitesmoke": [245, 245, 245],
-	"yellow": [255, 255, 0],
-	"yellowgreen": [154, 205, 50]
-};
+        if (array.buffer === this.buffer) {
+          tmp = [];
+          for (i = 0, s = array.byteOffset; i < byteLength; i += 1, s += 1) {
+            tmp[i] = array.buffer._bytes[s];
+          }
+          for (i = 0, d = byteOffset; i < byteLength; i += 1, d += 1) {
+            this.buffer._bytes[d] = tmp[i];
+          }
+        } else {
+          for (i = 0, s = array.byteOffset, d = byteOffset;
+               i < byteLength; i += 1, s += 1, d += 1) {
+            this.buffer._bytes[d] = array.buffer._bytes[s];
+          }
+        }
+      } else if (typeof arguments[0] === 'object' && typeof arguments[0].length !== 'undefined') {
+        // void set(sequence<type> array, optional unsigned long offset);
+        sequence = arguments[0];
+        len = ECMAScript.ToUint32(sequence.length);
+        offset = ECMAScript.ToUint32(arguments[1]);
 
-/* MIT license */
-/* eslint-disable no-mixed-operators */
+        if (offset + len > this.length) {
+          throw new RangeError("Offset plus length of array is out of range");
+        }
 
+        for (i = 0; i < len; i += 1) {
+          s = sequence[i];
+          this._setter(offset + i, Number(s));
+        }
+      } else {
+        throw new TypeError("Unexpected argument type(s)");
+      }
+    };
 
-// NOTE: conversions should only return primitive values (i.e. arrays, or
-//       values that give correct `typeof` results).
-//       do not use box values types (i.e. Number(), String(), etc.)
+    // TypedArray subarray(long begin, optional long end);
+    ctor.prototype.subarray = function(start, end) {
+      function clamp(v, min, max) { return v < min ? min : v > max ? max : v; }
 
-const reverseKeywords = {};
-for (const key of Object.keys(colorName$1)) {
-	reverseKeywords[colorName$1[key]] = key;
-}
+      start = ECMAScript.ToInt32(start);
+      end = ECMAScript.ToInt32(end);
 
-const convert$1 = {
-	rgb: {channels: 3, labels: 'rgb'},
-	hsl: {channels: 3, labels: 'hsl'},
-	hsv: {channels: 3, labels: 'hsv'},
-	hwb: {channels: 3, labels: 'hwb'},
-	cmyk: {channels: 4, labels: 'cmyk'},
-	xyz: {channels: 3, labels: 'xyz'},
-	lab: {channels: 3, labels: 'lab'},
-	lch: {channels: 3, labels: 'lch'},
-	hex: {channels: 1, labels: ['hex']},
-	keyword: {channels: 1, labels: ['keyword']},
-	ansi16: {channels: 1, labels: ['ansi16']},
-	ansi256: {channels: 1, labels: ['ansi256']},
-	hcg: {channels: 3, labels: ['h', 'c', 'g']},
-	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
-	gray: {channels: 1, labels: ['gray']}
-};
+      if (arguments.length < 1) { start = 0; }
+      if (arguments.length < 2) { end = this.length; }
 
-var conversions$1 = convert$1;
+      if (start < 0) { start = this.length + start; }
+      if (end < 0) { end = this.length + end; }
 
-// Hide .channels and .labels properties
-for (const model of Object.keys(convert$1)) {
-	if (!('channels' in convert$1[model])) {
-		throw new Error('missing channels property: ' + model);
-	}
+      start = clamp(start, 0, this.length);
+      end = clamp(end, 0, this.length);
 
-	if (!('labels' in convert$1[model])) {
-		throw new Error('missing channel labels property: ' + model);
-	}
+      var len = end - start;
+      if (len < 0) {
+        len = 0;
+      }
 
-	if (convert$1[model].labels.length !== convert$1[model].channels) {
-		throw new Error('channel and label counts mismatch: ' + model);
-	}
+      return new this.constructor(
+        this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len);
+    };
 
-	const {channels, labels} = convert$1[model];
-	delete convert$1[model].channels;
-	delete convert$1[model].labels;
-	Object.defineProperty(convert$1[model], 'channels', {value: channels});
-	Object.defineProperty(convert$1[model], 'labels', {value: labels});
-}
+    return ctor;
+  }
 
-convert$1.rgb.hsl = function (rgb) {
-	const r = rgb[0] / 255;
-	const g = rgb[1] / 255;
-	const b = rgb[2] / 255;
-	const min = Math.min(r, g, b);
-	const max = Math.max(r, g, b);
-	const delta = max - min;
-	let h;
-	let s;
+  var Int8Array = makeConstructor(1, packI8, unpackI8);
+  var Uint8Array = makeConstructor(1, packU8, unpackU8);
+  var Uint8ClampedArray = makeConstructor(1, packU8Clamped, unpackU8);
+  var Int16Array = makeConstructor(2, packI16, unpackI16);
+  var Uint16Array = makeConstructor(2, packU16, unpackU16);
+  var Int32Array = makeConstructor(4, packI32, unpackI32);
+  var Uint32Array = makeConstructor(4, packU32, unpackU32);
+  var Float32Array = makeConstructor(4, packF32, unpackF32);
+  var Float64Array = makeConstructor(8, packF64, unpackF64);
 
-	if (max === min) {
-		h = 0;
-	} else if (r === max) {
-		h = (g - b) / delta;
-	} else if (g === max) {
-		h = 2 + (b - r) / delta;
-	} else if (b === max) {
-		h = 4 + (r - g) / delta;
-	}
+  exports.Int8Array = exports.Int8Array || Int8Array;
+  exports.Uint8Array = exports.Uint8Array || Uint8Array;
+  exports.Uint8ClampedArray = exports.Uint8ClampedArray || Uint8ClampedArray;
+  exports.Int16Array = exports.Int16Array || Int16Array;
+  exports.Uint16Array = exports.Uint16Array || Uint16Array;
+  exports.Int32Array = exports.Int32Array || Int32Array;
+  exports.Uint32Array = exports.Uint32Array || Uint32Array;
+  exports.Float32Array = exports.Float32Array || Float32Array;
+  exports.Float64Array = exports.Float64Array || Float64Array;
+}());
 
-	h = Math.min(h * 60, 360);
+//
+// 6 The DataView View Type
+//
 
-	if (h < 0) {
-		h += 360;
-	}
+(function() {
+  function r(array, index) {
+    return ECMAScript.IsCallable(array.get) ? array.get(index) : array[index];
+  }
 
-	const l = (min + max) / 2;
+  var IS_BIG_ENDIAN = (function() {
+    var u16array = new(exports.Uint16Array)([0x1234]),
+        u8array = new(exports.Uint8Array)(u16array.buffer);
+    return r(u8array, 0) === 0x12;
+  }());
 
-	if (max === min) {
-		s = 0;
-	} else if (l <= 0.5) {
-		s = delta / (max + min);
-	} else {
-		s = delta / (2 - max - min);
-	}
+  // Constructor(ArrayBuffer buffer,
+  //             optional unsigned long byteOffset,
+  //             optional unsigned long byteLength)
+  /** @constructor */
+  var DataView = function DataView(buffer, byteOffset, byteLength) {
+    if (arguments.length === 0) {
+      buffer = new exports.ArrayBuffer(0);
+    } else if (!(buffer instanceof exports.ArrayBuffer || ECMAScript.Class(buffer) === 'ArrayBuffer')) {
+      throw new TypeError("TypeError");
+    }
 
-	return [h, s * 100, l * 100];
-};
+    this.buffer = buffer || new exports.ArrayBuffer(0);
 
-convert$1.rgb.hsv = function (rgb) {
-	let rdif;
-	let gdif;
-	let bdif;
-	let h;
-	let s;
+    this.byteOffset = ECMAScript.ToUint32(byteOffset);
+    if (this.byteOffset > this.buffer.byteLength) {
+      throw new RangeError("byteOffset out of range");
+    }
 
-	const r = rgb[0] / 255;
-	const g = rgb[1] / 255;
-	const b = rgb[2] / 255;
-	const v = Math.max(r, g, b);
-	const diff = v - Math.min(r, g, b);
-	const diffc = function (c) {
-		return (v - c) / 6 / diff + 1 / 2;
-	};
+    if (arguments.length < 3) {
+      this.byteLength = this.buffer.byteLength - this.byteOffset;
+    } else {
+      this.byteLength = ECMAScript.ToUint32(byteLength);
+    }
 
-	if (diff === 0) {
-		h = 0;
-		s = 0;
-	} else {
-		s = diff / v;
-		rdif = diffc(r);
-		gdif = diffc(g);
-		bdif = diffc(b);
+    if ((this.byteOffset + this.byteLength) > this.buffer.byteLength) {
+      throw new RangeError("byteOffset and length reference an area beyond the end of the buffer");
+    }
 
-		if (r === v) {
-			h = bdif - gdif;
-		} else if (g === v) {
-			h = (1 / 3) + rdif - bdif;
-		} else if (b === v) {
-			h = (2 / 3) + gdif - rdif;
-		}
+    configureProperties(this);
+  };
 
-		if (h < 0) {
-			h += 1;
-		} else if (h > 1) {
-			h -= 1;
-		}
-	}
+  function makeGetter(arrayType) {
+    return function(byteOffset, littleEndian) {
 
-	return [
-		h * 360,
-		s * 100,
-		v * 100
-	];
-};
+      byteOffset = ECMAScript.ToUint32(byteOffset);
 
-convert$1.rgb.hwb = function (rgb) {
-	const r = rgb[0];
-	const g = rgb[1];
-	let b = rgb[2];
-	const h = convert$1.rgb.hsl(rgb)[0];
-	const w = 1 / 255 * Math.min(r, Math.min(g, b));
+      if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) {
+        throw new RangeError("Array index out of range");
+      }
+      byteOffset += this.byteOffset;
 
-	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+      var uint8Array = new exports.Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT),
+          bytes = [], i;
+      for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) {
+        bytes.push(r(uint8Array, i));
+      }
 
-	return [h, w * 100, b * 100];
-};
+      if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) {
+        bytes.reverse();
+      }
 
-convert$1.rgb.cmyk = function (rgb) {
-	const r = rgb[0] / 255;
-	const g = rgb[1] / 255;
-	const b = rgb[2] / 255;
+      return r(new arrayType(new exports.Uint8Array(bytes).buffer), 0);
+    };
+  }
 
-	const k = Math.min(1 - r, 1 - g, 1 - b);
-	const c = (1 - r - k) / (1 - k) || 0;
-	const m = (1 - g - k) / (1 - k) || 0;
-	const y = (1 - b - k) / (1 - k) || 0;
+  DataView.prototype.getUint8 = makeGetter(exports.Uint8Array);
+  DataView.prototype.getInt8 = makeGetter(exports.Int8Array);
+  DataView.prototype.getUint16 = makeGetter(exports.Uint16Array);
+  DataView.prototype.getInt16 = makeGetter(exports.Int16Array);
+  DataView.prototype.getUint32 = makeGetter(exports.Uint32Array);
+  DataView.prototype.getInt32 = makeGetter(exports.Int32Array);
+  DataView.prototype.getFloat32 = makeGetter(exports.Float32Array);
+  DataView.prototype.getFloat64 = makeGetter(exports.Float64Array);
 
-	return [c * 100, m * 100, y * 100, k * 100];
-};
+  function makeSetter(arrayType) {
+    return function(byteOffset, value, littleEndian) {
 
-function comparativeDistance(x, y) {
-	/*
-		See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
-	*/
-	return (
-		((x[0] - y[0]) ** 2) +
-		((x[1] - y[1]) ** 2) +
-		((x[2] - y[2]) ** 2)
-	);
+      byteOffset = ECMAScript.ToUint32(byteOffset);
+      if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength) {
+        throw new RangeError("Array index out of range");
+      }
+
+      // Get bytes
+      var typeArray = new arrayType([value]),
+          byteArray = new exports.Uint8Array(typeArray.buffer),
+          bytes = [], i, byteView;
+
+      for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1) {
+        bytes.push(r(byteArray, i));
+      }
+
+      // Flip if necessary
+      if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN)) {
+        bytes.reverse();
+      }
+
+      // Write them
+      byteView = new exports.Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT);
+      byteView.set(bytes);
+    };
+  }
+
+  DataView.prototype.setUint8 = makeSetter(exports.Uint8Array);
+  DataView.prototype.setInt8 = makeSetter(exports.Int8Array);
+  DataView.prototype.setUint16 = makeSetter(exports.Uint16Array);
+  DataView.prototype.setInt16 = makeSetter(exports.Int16Array);
+  DataView.prototype.setUint32 = makeSetter(exports.Uint32Array);
+  DataView.prototype.setInt32 = makeSetter(exports.Int32Array);
+  DataView.prototype.setFloat32 = makeSetter(exports.Float32Array);
+  DataView.prototype.setFloat64 = makeSetter(exports.Float64Array);
+
+  exports.DataView = exports.DataView || DataView;
+
+}());
+}(typedarray));
+
+var Writable = require$$1.Writable;
+var inherits = inherits$2.exports;
+var bufferFrom = bufferFrom_1;
+
+if (typeof Uint8Array === 'undefined') {
+  var U8 = typedarray.Uint8Array;
+} else {
+  var U8 = Uint8Array;
 }
 
-convert$1.rgb.keyword = function (rgb) {
-	const reversed = reverseKeywords[rgb];
-	if (reversed) {
-		return reversed;
-	}
+function ConcatStream(opts, cb) {
+  if (!(this instanceof ConcatStream)) return new ConcatStream(opts, cb)
 
-	let currentClosestDistance = Infinity;
-	let currentClosestKeyword;
+  if (typeof opts === 'function') {
+    cb = opts;
+    opts = {};
+  }
+  if (!opts) opts = {};
 
-	for (const keyword of Object.keys(colorName$1)) {
-		const value = colorName$1[keyword];
+  var encoding = opts.encoding;
+  var shouldInferEncoding = false;
 
-		// Compute comparative distance
-		const distance = comparativeDistance(rgb, value);
+  if (!encoding) {
+    shouldInferEncoding = true;
+  } else {
+    encoding =  String(encoding).toLowerCase();
+    if (encoding === 'u8' || encoding === 'uint8') {
+      encoding = 'uint8array';
+    }
+  }
 
-		// Check if its less, if so set as closest
-		if (distance < currentClosestDistance) {
-			currentClosestDistance = distance;
-			currentClosestKeyword = keyword;
-		}
-	}
+  Writable.call(this, { objectMode: true });
 
-	return currentClosestKeyword;
+  this.encoding = encoding;
+  this.shouldInferEncoding = shouldInferEncoding;
+
+  if (cb) this.on('finish', function () { cb(this.getBody()); });
+  this.body = [];
+}
+
+var concatStream = ConcatStream;
+inherits(ConcatStream, Writable);
+
+ConcatStream.prototype._write = function(chunk, enc, next) {
+  this.body.push(chunk);
+  next();
 };
 
-convert$1.keyword.rgb = function (keyword) {
-	return colorName$1[keyword];
+ConcatStream.prototype.inferEncoding = function (buff) {
+  var firstBuffer = buff === undefined ? this.body[0] : buff;
+  if (Buffer.isBuffer(firstBuffer)) return 'buffer'
+  if (typeof Uint8Array !== 'undefined' && firstBuffer instanceof Uint8Array) return 'uint8array'
+  if (Array.isArray(firstBuffer)) return 'array'
+  if (typeof firstBuffer === 'string') return 'string'
+  if (Object.prototype.toString.call(firstBuffer) === "[object Object]") return 'object'
+  return 'buffer'
 };
 
-convert$1.rgb.xyz = function (rgb) {
-	let r = rgb[0] / 255;
-	let g = rgb[1] / 255;
-	let b = rgb[2] / 255;
+ConcatStream.prototype.getBody = function () {
+  if (!this.encoding && this.body.length === 0) return []
+  if (this.shouldInferEncoding) this.encoding = this.inferEncoding();
+  if (this.encoding === 'array') return arrayConcat(this.body)
+  if (this.encoding === 'string') return stringConcat(this.body)
+  if (this.encoding === 'buffer') return bufferConcat(this.body)
+  if (this.encoding === 'uint8array') return u8Concat(this.body)
+  return this.body
+};
 
-	// Assume sRGB
-	r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
-	g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
-	b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
+function isArrayish (arr) {
+  return /Array\]$/.test(Object.prototype.toString.call(arr))
+}
 
-	const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
-	const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
-	const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+function isBufferish (p) {
+  return typeof p === 'string' || isArrayish(p) || (p && typeof p.subarray === 'function')
+}
 
-	return [x * 100, y * 100, z * 100];
-};
+function stringConcat (parts) {
+  var strings = [];
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i];
+    if (typeof p === 'string') {
+      strings.push(p);
+    } else if (Buffer.isBuffer(p)) {
+      strings.push(p);
+    } else if (isBufferish(p)) {
+      strings.push(bufferFrom(p));
+    } else {
+      strings.push(bufferFrom(String(p)));
+    }
+  }
+  if (Buffer.isBuffer(parts[0])) {
+    strings = Buffer.concat(strings);
+    strings = strings.toString('utf8');
+  } else {
+    strings = strings.join('');
+  }
+  return strings
+}
 
-convert$1.rgb.lab = function (rgb) {
-	const xyz = convert$1.rgb.xyz(rgb);
-	let x = xyz[0];
-	let y = xyz[1];
-	let z = xyz[2];
+function bufferConcat (parts) {
+  var bufs = [];
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i];
+    if (Buffer.isBuffer(p)) {
+      bufs.push(p);
+    } else if (isBufferish(p)) {
+      bufs.push(bufferFrom(p));
+    } else {
+      bufs.push(bufferFrom(String(p)));
+    }
+  }
+  return Buffer.concat(bufs)
+}
 
-	x /= 95.047;
-	y /= 100;
-	z /= 108.883;
+function arrayConcat (parts) {
+  var res = [];
+  for (var i = 0; i < parts.length; i++) {
+    res.push.apply(res, parts[i]);
+  }
+  return res
+}
 
-	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
-	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
-	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+function u8Concat (parts) {
+  var len = 0;
+  for (var i = 0; i < parts.length; i++) {
+    if (typeof parts[i] === 'string') {
+      parts[i] = bufferFrom(parts[i]);
+    }
+    len += parts[i].length;
+  }
+  var u8 = new U8(len);
+  for (var i = 0, offset = 0; i < parts.length; i++) {
+    var part = parts[i];
+    for (var j = 0; j < part.length; j++) {
+      u8[offset++] = part[j];
+    }
+  }
+  return u8
+}
 
-	const l = (116 * y) - 16;
-	const a = 500 * (x - y);
-	const b = 200 * (y - z);
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Settings} Settings
+ */
 
-	return [l, a, b];
-};
+const debug$9 = createDebug('unified-engine:file-set-pipeline:stdin');
 
-convert$1.hsl.rgb = function (hsl) {
-	const h = hsl[0] / 360;
-	const s = hsl[1] / 100;
-	const l = hsl[2] / 100;
-	let t2;
-	let t3;
-	let val;
+/**
+ * @param {Context} context
+ * @param {Settings} settings
+ * @param {Callback} next
+ */
+function stdin(context, settings, next) {
+  if (settings.files && settings.files.length > 0) {
+    debug$9('Ignoring `streamIn`');
 
-	if (s === 0) {
-		val = l * 255;
-		return [val, val, val];
-	}
+    /** @type {Error|undefined} */
+    let error;
 
-	if (l < 0.5) {
-		t2 = l * (1 + s);
-	} else {
-		t2 = l + s - l * s;
-	}
+    if (settings.filePath) {
+      error = new Error(
+        'Do not pass both `--file-path` and real files.\nDid you mean to pass stdin instead of files?'
+      );
+    }
 
-	const t1 = 2 * l - t2;
+    next(error);
 
-	const rgb = [0, 0, 0];
-	for (let i = 0; i < 3; i++) {
-		t3 = h + 1 / 3 * -(i - 1);
-		if (t3 < 0) {
-			t3++;
-		}
+    return
+  }
 
-		if (t3 > 1) {
-			t3--;
-		}
+  // @ts-expect-error: does exist on `stdin`.
+  if (settings.streamIn.isTTY) {
+    debug$9('Cannot read from `tty` stream');
+    next(new Error('No input'));
 
-		if (6 * t3 < 1) {
-			val = t1 + (t2 - t1) * 6 * t3;
-		} else if (2 * t3 < 1) {
-			val = t2;
-		} else if (3 * t3 < 2) {
-			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
-		} else {
-			val = t1;
-		}
+    return
+  }
 
-		rgb[i] = val * 255;
-	}
+  debug$9('Reading from `streamIn`');
 
-	return rgb;
-};
+  settings.streamIn.pipe(
+    concatStream({encoding: 'string'}, (value) => {
+      const file = toVFile(settings.filePath);
 
-convert$1.hsl.hsv = function (hsl) {
-	const h = hsl[0];
-	let s = hsl[1] / 100;
-	let l = hsl[2] / 100;
-	let smin = s;
-	const lmin = Math.max(l, 0.01);
+      debug$9('Read from `streamIn`');
 
-	l *= 2;
-	s *= (l <= 1) ? l : 2 - l;
-	smin *= lmin <= 1 ? lmin : 2 - lmin;
-	const v = (l + s) / 2;
-	const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
+      file.cwd = settings.cwd;
+      file.value = value;
+      file.data.unifiedEngineGiven = true;
+      file.data.unifiedEngineStreamIn = true;
 
-	return [h, sv * 100, v * 100];
-};
+      context.files = [file];
 
-convert$1.hsv.rgb = function (hsv) {
-	const h = hsv[0] / 60;
-	const s = hsv[1] / 100;
-	let v = hsv[2] / 100;
-	const hi = Math.floor(h) % 6;
+      // If `out` was not set, set `out`.
+      settings.out =
+        settings.out === null || settings.out === undefined
+          ? true
+          : settings.out;
 
-	const f = h - Math.floor(h);
-	const p = 255 * v * (1 - s);
-	const q = 255 * v * (1 - (s * f));
-	const t = 255 * v * (1 - (s * (1 - f)));
-	v *= 255;
+      next();
+    })
+  );
+}
 
-	switch (hi) {
-		case 0:
-			return [v, t, p];
-		case 1:
-			return [q, v, p];
-		case 2:
-			return [p, v, t];
-		case 3:
-			return [p, q, v];
-		case 4:
-			return [t, p, v];
-		case 5:
-			return [v, p, q];
-	}
-};
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Pipeline} Pipeline
+ */
 
-convert$1.hsv.hsl = function (hsv) {
-	const h = hsv[0];
-	const s = hsv[1] / 100;
-	const v = hsv[2] / 100;
-	const vmin = Math.max(v, 0.01);
-	let sl;
-	let l;
+class FileSet extends EventEmitter$1 {
+  /**
+   * FileSet constructor.
+   * A FileSet is created to process multiple files through unified processors.
+   * This set, containing all files, is exposed to plugins as an argument to the
+   * attacher.
+   */
+  constructor() {
+    super();
+
+    /** @type {Array.<VFile>} */
+    this.files = [];
+    /** @type {string[]} */
+    this.origins = [];
+    /** @type {Completer[]} */
+    this.plugins = [];
+    /** @type {number} */
+    this.expected = 0;
+    /** @type {number} */
+    this.actual = 0;
+    /** @type {Pipeline} */
+    this.pipeline = trough();
+
+    // Called when a single file has completed it’s pipeline, triggering `done`
+    // when all files are complete.
+    this.on('one', () => {
+      this.actual++;
+
+      if (this.actual >= this.expected) {
+        this.emit('done');
+      }
+    });
+  }
 
-	l = (2 - s) * v;
-	const lmin = (2 - s) * vmin;
-	sl = s * vmin;
-	sl /= (lmin <= 1) ? lmin : 2 - lmin;
-	sl = sl || 0;
-	l /= 2;
+  /**
+   * Access the files in a set.
+   */
+  valueOf() {
+    return this.files
+  }
 
-	return [h, sl * 100, l * 100];
-};
+  /**
+   * Attach middleware to the pipeline on `fileSet`.
+   *
+   * @param {Completer} plugin
+   */
+  use(plugin) {
+    const pipeline = this.pipeline;
+    let duplicate = false;
 
-// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
-convert$1.hwb.rgb = function (hwb) {
-	const h = hwb[0] / 360;
-	let wh = hwb[1] / 100;
-	let bl = hwb[2] / 100;
-	const ratio = wh + bl;
-	let f;
+    if (plugin && plugin.pluginId) {
+      duplicate = this.plugins.some((fn) => fn.pluginId === plugin.pluginId);
+    }
 
-	// Wh + bl cant be > 1
-	if (ratio > 1) {
-		wh /= ratio;
-		bl /= ratio;
-	}
+    if (!duplicate && this.plugins.includes(plugin)) {
+      duplicate = true;
+    }
 
-	const i = Math.floor(6 * h);
-	const v = 1 - bl;
-	f = 6 * h - i;
+    if (!duplicate) {
+      this.plugins.push(plugin);
+      pipeline.use(plugin);
+    }
 
-	if ((i & 0x01) !== 0) {
-		f = 1 - f;
-	}
+    return this
+  }
 
-	const n = wh + f * (v - wh); // Linear interpolation
+  /**
+   * Add a file to be processed.
+   * The given file is processed like other files with a few differences:
+   *
+   * *   Ignored when their file path is already added
+   * *   Never written to the file system or streamOut
+   * *   Not reported for
+   *
+   * @param {string|VFile} file
+   */
+  add(file) {
+    if (typeof file === 'string') {
+      file = toVFile(file);
+    }
 
-	let r;
-	let g;
-	let b;
-	/* eslint-disable max-statements-per-line,no-multi-spaces */
-	switch (i) {
-		default:
-		case 6:
-		case 0: r = v;  g = n;  b = wh; break;
-		case 1: r = n;  g = v;  b = wh; break;
-		case 2: r = wh; g = v;  b = n; break;
-		case 3: r = wh; g = n;  b = v; break;
-		case 4: r = n;  g = wh; b = v; break;
-		case 5: r = v;  g = wh; b = n; break;
-	}
-	/* eslint-enable max-statements-per-line,no-multi-spaces */
+    // Prevent files from being added multiple times.
+    if (this.origins.includes(file.history[0])) {
+      return this
+    }
 
-	return [r * 255, g * 255, b * 255];
-};
+    this.origins.push(file.history[0]);
 
-convert$1.cmyk.rgb = function (cmyk) {
-	const c = cmyk[0] / 100;
-	const m = cmyk[1] / 100;
-	const y = cmyk[2] / 100;
-	const k = cmyk[3] / 100;
+    // Add.
+    this.valueOf().push(file);
+    this.expected++;
 
-	const r = 1 - Math.min(1, c * (1 - k) + k);
-	const g = 1 - Math.min(1, m * (1 - k) + k);
-	const b = 1 - Math.min(1, y * (1 - k) + k);
+    // Force an asynchronous operation.
+    // This ensures that files which fall through the file pipeline immediately
+    // (such as, when already fatally failed) still queue up correctly.
+    setImmediate(() => {
+      this.emit('add', file);
+    });
 
-	return [r * 255, g * 255, b * 255];
-};
+    return this
+  }
+}
 
-convert$1.xyz.rgb = function (xyz) {
-	const x = xyz[0] / 100;
-	const y = xyz[1] / 100;
-	const z = xyz[2] / 100;
-	let r;
-	let g;
-	let b;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
 
-	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
-	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
-	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+const debug$8 = createDebug('unified-engine:file-pipeline:read');
 
-	// Assume sRGB
-	r = r > 0.0031308
-		? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
-		: r * 12.92;
+/**
+ * Fill a file with its value when not already filled.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function read$1(context, file, next) {
+  let filePath = file.path;
 
-	g = g > 0.0031308
-		? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
-		: g * 12.92;
+  if (file.value || file.data.unifiedEngineStreamIn) {
+    debug$8('Not reading file `%s` with `value`', filePath);
+    next();
+  } else if (statistics(file).fatal) {
+    debug$8('Not reading failed file `%s`', filePath);
+    next();
+  } else {
+    filePath = path$c.resolve(context.settings.cwd, filePath);
 
-	b = b > 0.0031308
-		? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
-		: b * 12.92;
+    debug$8('Reading `%s` in `%s`', filePath, 'utf8');
+    fs$a.readFile(filePath, 'utf8', (error, value) => {
+      debug$8('Read `%s` (error: %s)', filePath, error);
 
-	r = Math.min(Math.max(0, r), 1);
-	g = Math.min(Math.max(0, g), 1);
-	b = Math.min(Math.max(0, b), 1);
+      file.value = value || '';
 
-	return [r * 255, g * 255, b * 255];
-};
+      next(error);
+    });
+  }
+}
 
-convert$1.xyz.lab = function (xyz) {
-	let x = xyz[0];
-	let y = xyz[1];
-	let z = xyz[2];
+/**
+ * Has own property.
+ *
+ * @type {Function}
+ */
 
-	x /= 95.047;
-	y /= 100;
-	z /= 108.883;
+var has = Object.prototype.hasOwnProperty;
 
-	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
-	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
-	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+/**
+ * To string.
+ *
+ * @type {Function}
+ */
 
-	const l = (116 * y) - 16;
-	const a = 500 * (x - y);
-	const b = 200 * (y - z);
+var toString$1 = Object.prototype.toString;
 
-	return [l, a, b];
-};
+/**
+ * Test whether a value is "empty".
+ *
+ * @param {Mixed} val
+ * @return {Boolean}
+ */
 
-convert$1.lab.xyz = function (lab) {
-	const l = lab[0];
-	const a = lab[1];
-	const b = lab[2];
-	let x;
-	let y;
-	let z;
+function isEmpty(val) {
+  // Null and Undefined...
+  if (val == null) return true
 
-	y = (l + 16) / 116;
-	x = a / 500 + y;
-	z = y - b / 200;
+  // Booleans...
+  if ('boolean' == typeof val) return false
 
-	const y2 = y ** 3;
-	const x2 = x ** 3;
-	const z2 = z ** 3;
-	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
-	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
-	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+  // Numbers...
+  if ('number' == typeof val) return val === 0
 
-	x *= 95.047;
-	y *= 100;
-	z *= 108.883;
+  // Strings...
+  if ('string' == typeof val) return val.length === 0
 
-	return [x, y, z];
-};
+  // Functions...
+  if ('function' == typeof val) return val.length === 0
 
-convert$1.lab.lch = function (lab) {
-	const l = lab[0];
-	const a = lab[1];
-	const b = lab[2];
-	let h;
+  // Arrays...
+  if (Array.isArray(val)) return val.length === 0
 
-	const hr = Math.atan2(b, a);
-	h = hr * 360 / 2 / Math.PI;
+  // Errors...
+  if (val instanceof Error) return val.message === ''
 
-	if (h < 0) {
-		h += 360;
-	}
+  // Objects...
+  if (val.toString == toString$1) {
+    switch (val.toString()) {
 
-	const c = Math.sqrt(a * a + b * b);
+      // Maps, Sets, Files and Errors...
+      case '[object File]':
+      case '[object Map]':
+      case '[object Set]': {
+        return val.size === 0
+      }
 
-	return [l, c, h];
-};
+      // Plain objects...
+      case '[object Object]': {
+        for (var key in val) {
+          if (has.call(val, key)) return false
+        }
 
-convert$1.lch.lab = function (lch) {
-	const l = lch[0];
-	const c = lch[1];
-	const h = lch[2];
+        return true
+      }
+    }
+  }
 
-	const hr = h / 360 * 2 * Math.PI;
-	const a = c * Math.cos(hr);
-	const b = c * Math.sin(hr);
+  // Anything else...
+  return false
+}
 
-	return [l, a, b];
-};
+/**
+ * Export `isEmpty`.
+ *
+ * @type {Function}
+ */
 
-convert$1.rgb.ansi16 = function (args, saturation = null) {
-	const [r, g, b] = args;
-	let value = saturation === null ? convert$1.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
+var lib$1 = isEmpty;
 
-	value = Math.round(value / 50);
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
 
-	if (value === 0) {
-		return 30;
-	}
+const debug$7 = createDebug('unified-engine:file-pipeline:configure');
 
-	let ansi = 30
-		+ ((Math.round(b / 255) << 2)
-		| (Math.round(g / 255) << 1)
-		| Math.round(r / 255));
+/**
+ * Collect configuration for a file based on the context.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function configure$2(context, file, next) {
+  if (statistics(file).fatal) {
+    return next()
+  }
 
-	if (value === 2) {
-		ansi += 60;
-	}
+  context.configuration.load(file.path, (error, configuration) => {
+    let index = -1;
 
-	return ansi;
-};
+    if (!configuration) {
+      return next(error)
+    }
 
-convert$1.hsv.ansi16 = function (args) {
-	// Optimization here; we already know the value and don't need to get
-	// it converted for us.
-	return convert$1.rgb.ansi16(convert$1.hsv.rgb(args), args[2]);
-};
+    // Could be missing if a `configTransform` returns weird things.
+    /* c8 ignore next 1 */
+    const plugins = configuration.plugins || [];
 
-convert$1.rgb.ansi256 = function (args) {
-	const r = args[0];
-	const g = args[1];
-	const b = args[2];
+    // Store configuration on the context object.
+    debug$7('Using settings `%j`', configuration.settings);
+    context.processor.data('settings', configuration.settings);
 
-	// We use the extended greyscale palette here, with the exception of
-	// black and white. normal palette only has 4 greyscale shades.
-	if (r === g && g === b) {
-		if (r < 8) {
-			return 16;
-		}
+    debug$7('Using `%d` plugins', plugins.length);
 
-		if (r > 248) {
-			return 231;
-		}
+    while (++index < plugins.length) {
+      const plugin = plugins[index][0];
+      let options = plugins[index][1];
 
-		return Math.round(((r - 8) / 247) * 24) + 232;
-	}
+      if (options === false) {
+        continue
+      }
 
-	const ansi = 16
-		+ (36 * Math.round(r / 255 * 5))
-		+ (6 * Math.round(g / 255 * 5))
-		+ Math.round(b / 255 * 5);
+      // Allow for default arguments in es2020.
+      /* c8 ignore next 6 */
+      if (
+        options === null ||
+        (typeof options === 'object' && lib$1(options))
+      ) {
+        options = undefined;
+      }
 
-	return ansi;
-};
+      debug$7(
+        'Using plugin `%s`, with options `%j`',
+        // @ts-expect-error: `displayName` sure can exist on functions.
+        plugin.displayName || plugin.name || 'function',
+        options
+      );
 
-convert$1.ansi16.rgb = function (args) {
-	let color = args % 10;
+      try {
+        context.processor.use(plugin, options, context.fileSet);
+        /* Should not happen anymore! */
+        /* c8 ignore next 3 */
+      } catch (error_) {
+        return next(error_)
+      }
+    }
 
-	// Handle greyscale
-	if (color === 0 || color === 7) {
-		if (args > 50) {
-			color += 3.5;
-		}
+    next();
+  });
+}
 
-		color = color / 10.5 * 255;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('./index.js').Context} Context
+ */
 
-		return [color, color, color];
-	}
+const debug$6 = createDebug('unified-engine:file-pipeline:parse');
 
-	const mult = (~~(args > 50) + 1) * 0.5;
-	const r = ((color & 1) * mult) * 255;
-	const g = (((color >> 1) & 1) * mult) * 255;
-	const b = (((color >> 2) & 1) * mult) * 255;
+/**
+ * Fill a file with a tree.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ */
+function parse$2(context, file) {
+  if (statistics(file).fatal) {
+    return
+  }
 
-	return [r, g, b];
-};
+  if (context.settings.treeIn) {
+    debug$6('Not parsing already parsed document');
 
-convert$1.ansi256.rgb = function (args) {
-	// Handle greyscale
-	if (args >= 232) {
-		const c = (args - 232) * 10 + 8;
-		return [c, c, c];
-	}
+    try {
+      context.tree = parseJson_1(file.toString());
+    } catch (error) {
+      const message = file.message(
+        new Error('Cannot read file as JSON\n' + error.message)
+      );
+      message.fatal = true;
+    }
 
-	args -= 16;
+    // Add the preferred extension to ensure the file, when serialized, is
+    // correctly recognised.
+    // Only add it if there is a path — not if the file is for example stdin.
+    if (file.path) {
+      file.extname = context.settings.extensions[0];
+    }
 
-	let rem;
-	const r = Math.floor(args / 36) / 5 * 255;
-	const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
-	const b = (rem % 6) / 5 * 255;
+    file.value = '';
 
-	return [r, g, b];
-};
+    return
+  }
 
-convert$1.rgb.hex = function (args) {
-	const integer = ((Math.round(args[0]) & 0xFF) << 16)
-		+ ((Math.round(args[1]) & 0xFF) << 8)
-		+ (Math.round(args[2]) & 0xFF);
+  debug$6('Parsing `%s`', file.path);
 
-	const string = integer.toString(16).toUpperCase();
-	return '000000'.substring(string.length) + string;
-};
+  context.tree = context.processor.parse(file);
 
-convert$1.hex.rgb = function (args) {
-	const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
-	if (!match) {
-		return [0, 0, 0];
-	}
+  debug$6('Parsed document');
+}
 
-	let colorString = match[0];
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
 
-	if (match[0].length === 3) {
-		colorString = colorString.split('').map(char => {
-			return char + char;
-		}).join('');
-	}
+const debug$5 = createDebug('unified-engine:file-pipeline:transform');
 
-	const integer = parseInt(colorString, 16);
-	const r = (integer >> 16) & 0xFF;
-	const g = (integer >> 8) & 0xFF;
-	const b = integer & 0xFF;
+/**
+ * Transform the tree associated with a file with configured plugins.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function transform$2(context, file, next) {
+  if (statistics(file).fatal) {
+    next();
+  } else {
+    debug$5('Transforming document `%s`', file.path);
+    // @ts-expect-error: `tree` is defined at this point.
+    context.processor.run(context.tree, file, (error, node) => {
+      debug$5('Transformed document (error: %s)', error);
+      context.tree = node;
+      next(error);
+    });
+  }
+}
 
-	return [r, g, b];
-};
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
 
-convert$1.rgb.hcg = function (rgb) {
-	const r = rgb[0] / 255;
-	const g = rgb[1] / 255;
-	const b = rgb[2] / 255;
-	const max = Math.max(Math.max(r, g), b);
-	const min = Math.min(Math.min(r, g), b);
-	const chroma = (max - min);
-	let grayscale;
-	let hue;
+const debug$4 = createDebug('unified-engine:file-pipeline:queue');
 
-	if (chroma < 1) {
-		grayscale = min / (1 - chroma);
-	} else {
-		grayscale = 0;
-	}
+const own$a = {}.hasOwnProperty;
 
-	if (chroma <= 0) {
-		hue = 0;
-	} else
-	if (max === r) {
-		hue = ((g - b) / chroma) % 6;
-	} else
-	if (max === g) {
-		hue = 2 + (b - r) / chroma;
-	} else {
-		hue = 4 + (r - g) / chroma;
-	}
+/**
+ * Queue all files which came this far.
+ * When the last file gets here, run the file-set pipeline and flush the queue.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function queue(context, file, next) {
+  let origin = file.history[0];
+  // @ts-expect-error: store a completion map on the `fileSet`.
+  let map = context.fileSet.complete;
+  let complete = true;
 
-	hue /= 6;
-	hue %= 1;
+  if (!map) {
+    map = {};
+    // @ts-expect-error: store a completion map on the `fileSet`.
+    context.fileSet.complete = map;
+  }
 
-	return [hue * 360, chroma * 100, grayscale * 100];
-};
+  debug$4('Queueing `%s`', origin);
 
-convert$1.hsl.hcg = function (hsl) {
-	const s = hsl[1] / 100;
-	const l = hsl[2] / 100;
+  map[origin] = next;
 
-	const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
+  const files = context.fileSet.valueOf();
+  let index = -1;
+  while (++index < files.length) {
+    each(files[index]);
+  }
 
-	let f = 0;
-	if (c < 1.0) {
-		f = (l - 0.5 * c) / (1.0 - c);
-	}
+  if (!complete) {
+    debug$4('Not flushing: some files cannot be flushed');
+    return
+  }
 
-	return [hsl[0], c * 100, f * 100];
-};
+  // @ts-expect-error: Reset map.
+  context.fileSet.complete = {};
+  context.fileSet.pipeline.run(context.fileSet, done);
 
-convert$1.hsv.hcg = function (hsv) {
-	const s = hsv[1] / 100;
-	const v = hsv[2] / 100;
+  /**
+   * @param {VFile} file
+   */
+  function each(file) {
+    const key = file.history[0];
 
-	const c = s * v;
-	let f = 0;
+    if (statistics(file).fatal) {
+      return
+    }
 
-	if (c < 1.0) {
-		f = (v - c) / (1 - c);
-	}
+    if (typeof map[key] === 'function') {
+      debug$4('`%s` can be flushed', key);
+    } else {
+      debug$4('Interupting flush: `%s` is not finished', key);
+      complete = false;
+    }
+  }
 
-	return [hsv[0], c * 100, f * 100];
-};
+  /**
+   * @param {Error|Null} error
+   */
+  function done(error) {
+    debug$4('Flushing: all files can be flushed');
 
-convert$1.hcg.rgb = function (hcg) {
-	const h = hcg[0] / 360;
-	const c = hcg[1] / 100;
-	const g = hcg[2] / 100;
+    // Flush.
+    for (origin in map) {
+      if (own$a.call(map, origin)) {
+        map[origin](error);
+      }
+    }
+  }
+}
 
-	if (c === 0.0) {
-		return [g * 255, g * 255, g * 255];
-	}
+var own$9 = {}.hasOwnProperty;
 
-	const pure = [0, 0, 0];
-	const hi = (h % 1) * 6;
-	const v = hi % 1;
-	const w = 1 - v;
-	let mg = 0;
+var bold = ansiColor(1, 22);
+var dim = ansiColor(2, 22);
+var yellow = ansiColor(33, 39);
+var green = ansiColor(32, 39);
 
-	/* eslint-disable max-statements-per-line */
-	switch (Math.floor(hi)) {
-		case 0:
-			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
-		case 1:
-			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
-		case 2:
-			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
-		case 3:
-			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
-		case 4:
-			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
-		default:
-			pure[0] = 1; pure[1] = 0; pure[2] = w;
-	}
-	/* eslint-enable max-statements-per-line */
+// ANSI color regex.
+/* eslint-disable-next-line no-control-regex */
+var colorExpression = /(?:(?:\u001B\[)|\u009B)(?:\d{1,3})?(?:(?:;\d{0,3})*)?[A-M|f-m]|\u001B[A-M]/g;
+
+/**
+ * Inspects a node, without using color.
+ *
+ * @param {unknown} node
+ * @param {InspectOptions} [options]
+ * @returns {string}
+ */
+function inspectNoColor(node, options) {
+  return inspectColor(node, options).replace(colorExpression, '')
+}
+
+/**
+ * Inspects a node, using color.
+ *
+ * @param {unknown} tree
+ * @param {InspectOptions} [options]
+ * @returns {string}
+ */
+function inspectColor(tree, options) {
+  var positions =
+    !options ||
+    options.showPositions === null ||
+    options.showPositions === undefined
+      ? true
+      : options.showPositions;
 
-	mg = (1.0 - c) * g;
+  return inspectValue(tree)
 
-	return [
-		(c * pure[0] + mg) * 255,
-		(c * pure[1] + mg) * 255,
-		(c * pure[2] + mg) * 255
-	];
-};
+  /**
+   * @param {unknown} node
+   * @returns {string}
+   */
+  function inspectValue(node) {
+    if (node && typeof node === 'object' && 'length' in node) {
+      // @ts-ignore looks like a list of nodes.
+      return inspectNodes(node)
+    }
 
-convert$1.hcg.hsv = function (hcg) {
-	const c = hcg[1] / 100;
-	const g = hcg[2] / 100;
+    // @ts-ignore looks like a single node.
+    if (node && node.type) {
+      // @ts-ignore looks like a single node.
+      return inspectTree(node)
+    }
 
-	const v = c + g * (1.0 - c);
-	let f = 0;
+    return inspectNonTree(node)
+  }
 
-	if (v > 0.0) {
-		f = c / v;
-	}
+  /**
+   * @param {unknown} value
+   * @returns {string}
+   */
+  function inspectNonTree(value) {
+    return JSON.stringify(value)
+  }
 
-	return [hcg[0], f * 100, v * 100];
-};
+  /**
+   * @param {Node[]} nodes
+   * @returns {string}
+   */
+  function inspectNodes(nodes) {
+    /** @type {Array.<string>} */
+    var result = [];
+    var index = -1;
 
-convert$1.hcg.hsl = function (hcg) {
-	const c = hcg[1] / 100;
-	const g = hcg[2] / 100;
+    while (++index < nodes.length) {
+      result.push(
+        dim((index < nodes.length - 1 ? '├' : '└') + '─' + index) +
+          ' ' +
+          indent(
+            inspectValue(nodes[index]),
+            (index < nodes.length - 1 ? dim('│') : ' ') + '   ',
+            true
+          )
+      );
+    }
 
-	const l = g * (1.0 - c) + 0.5 * c;
-	let s = 0;
+    return result.join('\n')
+  }
 
-	if (l > 0.0 && l < 0.5) {
-		s = c / (2 * l);
-	} else
-	if (l >= 0.5 && l < 1.0) {
-		s = c / (2 * (1 - l));
-	}
+  /**
+   * @param {Object.<string, unknown>} object
+   * @returns {string}
+   */
+  function inspectFields(object) {
+    /** @type {Array.<string>} */
+    var result = [];
+    /** @type {string} */
+    var key;
+    /** @type {unknown} */
+    var value;
+    /** @type {string} */
+    var formatted;
 
-	return [hcg[0], s * 100, l * 100];
-};
+    for (key in object) {
+      /* c8 ignore next 1 */
+      if (!own$9.call(object, key)) continue
 
-convert$1.hcg.hwb = function (hcg) {
-	const c = hcg[1] / 100;
-	const g = hcg[2] / 100;
-	const v = c + g * (1.0 - c);
-	return [hcg[0], (v - c) * 100, (1 - v) * 100];
-};
+      value = object[key];
 
-convert$1.hwb.hcg = function (hwb) {
-	const w = hwb[1] / 100;
-	const b = hwb[2] / 100;
-	const v = 1 - b;
-	const c = v - w;
-	let g = 0;
+      if (
+        value === undefined ||
+        // Standard keys defined by unist that we format differently.
+        // <https://github.com/syntax-tree/unist>
+        key === 'type' ||
+        key === 'value' ||
+        key === 'children' ||
+        key === 'position' ||
+        // Ignore `name` (from xast) and `tagName` (from `hast`) when string.
+        (typeof value === 'string' && (key === 'name' || key === 'tagName'))
+      ) {
+        continue
+      }
 
-	if (c < 1) {
-		g = (v - c) / (1 - c);
-	}
+      // A single node.
+      if (
+        value &&
+        typeof value === 'object' &&
+        // @ts-ignore looks like a node.
+        value.type &&
+        key !== 'data' &&
+        key !== 'attributes' &&
+        key !== 'properties'
+      ) {
+        // @ts-ignore looks like a node.
+        formatted = inspectTree(value);
+      }
+      // A list of nodes.
+      else if (
+        value &&
+        typeof value === 'object' &&
+        'length' in value &&
+        value[0] &&
+        value[0].type
+      ) {
+        // @ts-ignore looks like a list of nodes.
+        formatted = '\n' + inspectNodes(value);
+      } else {
+        formatted = inspectNonTree(value);
+      }
 
-	return [hwb[0], c * 100, g * 100];
-};
+      result.push(
+        key + dim(':') + (/\s/.test(formatted.charAt(0)) ? '' : ' ') + formatted
+      );
+    }
 
-convert$1.apple.rgb = function (apple) {
-	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
-};
+    return indent(
+      result.join('\n'),
+      // @ts-ignore looks like a parent node.
+      (object.children && object.children.length > 0 ? dim('│') : ' ') + ' '
+    )
+  }
 
-convert$1.rgb.apple = function (rgb) {
-	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
-};
+  /**
+   * @param {Node} node
+   * @returns {string}
+   */
+  function inspectTree(node) {
+    var result = [formatNode(node)];
+    var fields = inspectFields(node);
+    // @ts-ignore looks like a parent.
+    var content = inspectNodes(node.children || []);
+    if (fields) result.push(fields);
+    if (content) result.push(content);
+    return result.join('\n')
+  }
 
-convert$1.gray.rgb = function (args) {
-	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
-};
+  /**
+   * Colored node formatter.
+   *
+   * @param {Node} node
+   * @returns {string}
+   */
+  function formatNode(node) {
+    var result = [bold(node.type)];
+    var kind = node.tagName || node.name;
+    var position = positions ? stringifyPosition(node.position) : '';
 
-convert$1.gray.hsl = function (args) {
-	return [0, 0, args[0]];
-};
+    if (typeof kind === 'string') {
+      result.push('<', kind, '>');
+    }
 
-convert$1.gray.hsv = convert$1.gray.hsl;
+    if (node.children) {
+      // @ts-ignore looks like a parent.
+      result.push(dim('['), yellow(node.children.length), dim(']'));
+    } else if (typeof node.value === 'string') {
+      result.push(' ', green(inspectNonTree(node.value)));
+    }
 
-convert$1.gray.hwb = function (gray) {
-	return [0, 100, gray[0]];
-};
+    if (position) {
+      result.push(' ', dim('('), position, dim(')'));
+    }
 
-convert$1.gray.cmyk = function (gray) {
-	return [0, 0, 0, gray[0]];
-};
+    return result.join('')
+  }
+}
 
-convert$1.gray.lab = function (gray) {
-	return [gray[0], 0, 0];
-};
+/**
+ * @param {string} value
+ * @param {string} indentation
+ * @param {boolean} [ignoreFirst=false]
+ * @returns {string}
+ */
+function indent(value, indentation, ignoreFirst) {
+  var lines = value.split('\n');
+  var index = ignoreFirst ? 0 : -1;
 
-convert$1.gray.hex = function (gray) {
-	const val = Math.round(gray[0] / 100 * 255) & 0xFF;
-	const integer = (val << 16) + (val << 8) + val;
+  if (!value) return value
 
-	const string = integer.toString(16).toUpperCase();
-	return '000000'.substring(string.length) + string;
-};
+  while (++index < lines.length) {
+    lines[index] = indentation + lines[index];
+  }
 
-convert$1.rgb.gray = function (rgb) {
-	const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
-	return [val / 255 * 100];
-};
+  return lines.join('\n')
+}
 
-/*
-	This function routes a model to all other models.
+/**
+ * @param {Position} value
+ * @returns {string}
+ */
+function stringifyPosition(value) {
+  /** @type {Position} */
+  // @ts-ignore
+  var position = value || {};
+  /** @type {Array.<string>} */
+  var result = [];
+  /** @type {Array.<string>} */
+  var positions = [];
+  /** @type {Array.<string>} */
+  var offsets = [];
 
-	all functions that are routed have a property `.conversion` attached
-	to the returned synthetic function. This property is an array
-	of strings, each with the steps in between the 'from' and 'to'
-	color models (inclusive).
+  point(position.start);
+  point(position.end);
 
-	conversions that are not possible simply are not included.
-*/
+  if (positions.length > 0) result.push(positions.join('-'));
+  if (offsets.length > 0) result.push(offsets.join('-'));
 
-function buildGraph$1() {
-	const graph = {};
-	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
-	const models = Object.keys(conversions$1);
+  return result.join(', ')
 
-	for (let len = models.length, i = 0; i < len; i++) {
-		graph[models[i]] = {
-			// http://jsperf.com/1-vs-infinity
-			// micro-opt, but this is simple.
-			distance: -1,
-			parent: null
-		};
-	}
+  /**
+   * @param {Point} value
+   */
+  function point(value) {
+    if (value) {
+      positions.push((value.line || 1) + ':' + (value.column || 1));
 
-	return graph;
+      if ('offset' in value) {
+        offsets.push(String(value.offset || 0));
+      }
+    }
+  }
 }
 
-// https://en.wikipedia.org/wiki/Breadth-first_search
-function deriveBFS$1(fromModel) {
-	const graph = buildGraph$1();
-	const queue = [fromModel]; // Unshift -> queue -> pop
+/**
+ * Factory to wrap values in ANSI colours.
+ *
+ * @param {number} open
+ * @param {number} close
+ * @returns {function(string): string}
+ */
+function ansiColor(open, close) {
+  return color
 
-	graph[fromModel].distance = 0;
+  /**
+   * @param {string} value
+   * @returns {string}
+   */
+  function color(value) {
+    return '\u001B[' + open + 'm' + value + '\u001B[' + close + 'm'
+  }
+}
 
-	while (queue.length) {
-		const current = queue.pop();
-		const adjacents = Object.keys(conversions$1[current]);
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('./index.js').Context} Context
+ */
 
-		for (let len = adjacents.length, i = 0; i < len; i++) {
-			const adjacent = adjacents[i];
-			const node = graph[adjacent];
+const debug$3 = createDebug('unified-engine:file-pipeline:stringify');
 
-			if (node.distance === -1) {
-				node.distance = graph[current].distance + 1;
-				node.parent = current;
-				queue.unshift(adjacent);
-			}
-		}
-	}
+/**
+ * Stringify a tree.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ */
+function stringify$1(context, file) {
+  /** @type {unknown} */
+  let value;
 
-	return graph;
-}
+  if (statistics(file).fatal) {
+    debug$3('Not compiling failed document');
+    return
+  }
 
-function link$1(from, to) {
-	return function (args) {
-		return to(from(args));
-	};
-}
+  if (
+    !context.settings.output &&
+    !context.settings.out &&
+    !context.settings.alwaysStringify
+  ) {
+    debug$3('Not compiling document without output settings');
+    return
+  }
 
-function wrapConversion$1(toModel, graph) {
-	const path = [graph[toModel].parent, toModel];
-	let fn = conversions$1[graph[toModel].parent][toModel];
+  debug$3('Compiling `%s`', file.path);
 
-	let cur = graph[toModel].parent;
-	while (graph[cur].parent) {
-		path.unshift(graph[cur].parent);
-		fn = link$1(conversions$1[graph[cur].parent][cur], fn);
-		cur = graph[cur].parent;
-	}
+  if (context.settings.inspect) {
+    // Add a `txt` extension if there is a path.
+    if (file.path) {
+      file.extname = '.txt';
+    }
 
-	fn.conversion = path;
-	return fn;
+    value =
+      (context.settings.color ? inspectColor : inspectNoColor)(context.tree) +
+      '\n';
+  } else if (context.settings.treeOut) {
+    // Add a `json` extension to ensure the file is correctly seen as JSON.
+    // Only add it if there is a path — not if the file is for example stdin.
+    if (file.path) {
+      file.extname = '.json';
+    }
+
+    // Add the line feed to create a valid UNIX file.
+    value = JSON.stringify(context.tree, null, 2) + '\n';
+  } else {
+    // @ts-expect-error: `tree` is defined if we came this far.
+    value = context.processor.stringify(context.tree, file);
+  }
+
+  if (value === undefined || value === null) ; else if (typeof value === 'string' || isBuffer(value)) {
+    // @ts-expect-error: `isBuffer` checks buffer.
+    file.value = value;
+  } else {
+    file.result = value;
+  }
+
+  debug$3('Serialized document');
 }
 
-var route$1 = function (fromModel) {
-	const graph = deriveBFS$1(fromModel);
-	const conversion = {};
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
 
-	const models = Object.keys(graph);
-	for (let len = models.length, i = 0; i < len; i++) {
-		const toModel = models[i];
-		const node = graph[toModel];
+const debug$2 = createDebug('unified-engine:file-pipeline:copy');
 
-		if (node.parent === null) {
-			// No possible conversion, or this node is the source model.
-			continue;
-		}
+/**
+ * Move a file.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function copy(context, file, next) {
+  const output = context.settings.output;
+  const currentPath = file.path;
 
-		conversion[toModel] = wrapConversion$1(toModel, graph);
-	}
+  if (typeof output !== 'string') {
+    debug$2('Not copying');
+    next();
+    return
+  }
 
-	return conversion;
-};
+  const outpath = path$c.resolve(context.settings.cwd, output);
+
+  debug$2('Copying `%s`', currentPath);
+
+  fs$a.stat(outpath, (error, stats) => {
+    if (error) {
+      if (
+        error.code !== 'ENOENT' ||
+        output.charAt(output.length - 1) === path$c.sep
+      ) {
+        return next(
+          new Error('Cannot read output directory. Error:\n' + error.message)
+        )
+      }
 
-const convert$2 = {};
+      // This is either given an error, or the parent exists which is a directory,
+      // but we should keep the basename of the given file.
+      fs$a.stat(path$c.dirname(outpath), (error) => {
+        if (error) {
+          next(
+            new Error('Cannot read parent directory. Error:\n' + error.message)
+          );
+        } else {
+          done(false);
+        }
+      });
+    } else {
+      done(stats.isDirectory());
+    }
+  });
 
-const models$1 = Object.keys(conversions$1);
+  /**
+   * @param {boolean} directory
+   */
+  function done(directory) {
+    if (!directory && context.fileSet.expected > 1) {
+      return next(
+        new Error('Cannot write multiple files to single output: ' + outpath)
+      )
+    }
 
-function wrapRaw$1(fn) {
-	const wrappedFn = function (...args) {
-		const arg0 = args[0];
-		if (arg0 === undefined || arg0 === null) {
-			return arg0;
-		}
+    file[directory ? 'dirname' : 'path'] = path$c.relative(file.cwd, outpath);
 
-		if (arg0.length > 1) {
-			args = arg0;
-		}
+    debug$2('Copying document from %s to %s', currentPath, file.path);
 
-		return fn(args);
-	};
+    next();
+  }
+}
 
-	// Preserve .conversion property if there is one
-	if ('conversion' in fn) {
-		wrappedFn.conversion = fn.conversion;
-	}
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
 
-	return wrappedFn;
+const debug$1 = createDebug('unified-engine:file-pipeline:stdout');
+
+/**
+ * Write a virtual file to `streamOut`.
+ * Ignored when `output` is given, more than one file was processed, or `out`
+ * is false.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function stdout(context, file, next) {
+  if (!file.data.unifiedEngineGiven) {
+    debug$1('Ignoring programmatically added file');
+    next();
+  } else if (
+    statistics(file).fatal ||
+    context.settings.output ||
+    !context.settings.out
+  ) {
+    debug$1('Ignoring writing to `streamOut`');
+    next();
+  } else {
+    debug$1('Writing document to `streamOut`');
+    context.settings.streamOut.write(file.toString(), next);
+  }
 }
 
-function wrapRounded$1(fn) {
-	const wrappedFn = function (...args) {
-		const arg0 = args[0];
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
 
-		if (arg0 === undefined || arg0 === null) {
-			return arg0;
-		}
+const debug = createDebug('unified-engine:file-pipeline:file-system');
 
-		if (arg0.length > 1) {
-			args = arg0;
-		}
+/**
+ * Write a virtual file to the file-system.
+ * Ignored when `output` is not given.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function fileSystem(context, file, next) {
+  if (!context.settings.output) {
+    debug('Ignoring writing to file-system');
+    return next()
+  }
 
-		const result = fn(args);
+  if (!file.data.unifiedEngineGiven) {
+    debug('Ignoring programmatically added file');
+    return next()
+  }
 
-		// We're assuming the result is an array here.
-		// see notice in conversions.js; don't use box types
-		// in conversion functions.
-		if (typeof result === 'object') {
-			for (let len = result.length, i = 0; i < len; i++) {
-				result[i] = Math.round(result[i]);
-			}
-		}
+  let destinationPath = file.path;
 
-		return result;
-	};
+  if (!destinationPath) {
+    debug('Cannot write file without a `destinationPath`');
+    return next(new Error('Cannot write file without an output path'))
+  }
 
-	// Preserve .conversion property if there is one
-	if ('conversion' in fn) {
-		wrappedFn.conversion = fn.conversion;
-	}
+  if (statistics(file).fatal) {
+    debug('Cannot write file with a fatal error');
+    return next()
+  }
 
-	return wrappedFn;
+  destinationPath = path$c.resolve(context.settings.cwd, destinationPath);
+  debug('Writing document to `%s`', destinationPath);
+
+  file.stored = true;
+  fs$a.writeFile(destinationPath, file.toString(), next);
 }
 
-models$1.forEach(fromModel => {
-	convert$2[fromModel] = {};
+/**
+ * @typedef {import('trough').Pipeline} Pipeline
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unified').Processor} Processor
+ * @typedef {import('../file-set.js').FileSet} FileSet
+ * @typedef {import('../configuration.js').Configuration} Configuration
+ * @typedef {import('../index.js').Settings} Settings
+ */
 
-	Object.defineProperty(convert$2[fromModel], 'channels', {value: conversions$1[fromModel].channels});
-	Object.defineProperty(convert$2[fromModel], 'labels', {value: conversions$1[fromModel].labels});
+// This pipeline ensures each of the pipes always runs: even if the read pipe
+// fails, queue and write run.
+const filePipeline = trough()
+  .use(chunk(trough().use(read$1).use(configure$2).use(parse$2).use(transform$2)))
+  .use(chunk(trough().use(queue)))
+  .use(chunk(trough().use(stringify$1).use(copy).use(stdout).use(fileSystem)));
 
-	const routes = route$1(fromModel);
-	const routeModels = Object.keys(routes);
+/**
+ * Factory to run a pipe.
+ * Wraps a pipe to trigger an error on the `file` in `context`, but still call
+ * `next`.
+ *
+ * @param {Pipeline} pipe
+ */
+function chunk(pipe) {
+  return run
 
-	routeModels.forEach(toModel => {
-		const fn = routes[toModel];
+  /**
+   * Run the bound pipe and handle any errors.
+   *
+   * @param {Context} context
+   * @param {VFile} file
+   * @param {() => void} next
+   */
+  function run(context, file, next) {
+    pipe.run(context, file, (/** @type {VFileMessage|null} */ error) => {
+      const messages = file.messages;
 
-		convert$2[fromModel][toModel] = wrapRounded$1(fn);
-		convert$2[fromModel][toModel].raw = wrapRaw$1(fn);
-	});
-});
+      if (error) {
+        const index = messages.indexOf(error);
 
-var colorConvert$1 = convert$2;
+        if (index === -1) {
+          Object.assign(file.message(error), {fatal: true});
+        } else {
+          messages[index].fatal = true;
+        }
+      }
 
-var ansiStyles$1 = createCommonjsModule(function (module) {
+      next();
+    });
+  }
+}
 
-const wrapAnsi16 = (fn, offset) => (...args) => {
-	const code = fn(...args);
-	return `\u001B[${code + offset}m`;
-};
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Settings} Settings
+ * @typedef {import('./index.js').Configuration} Configuration
+ */
 
-const wrapAnsi256 = (fn, offset) => (...args) => {
-	const code = fn(...args);
-	return `\u001B[${38 + offset};5;${code}m`;
-};
+/**
+ * Transform all files.
+ *
+ * @param {Context} context
+ * @param {Settings} settings
+ * @param {Callback} next
+ */
+function transform$1(context, settings, next) {
+  const fileSet = new FileSet();
 
-const wrapAnsi16m = (fn, offset) => (...args) => {
-	const rgb = fn(...args);
-	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
-};
+  context.fileSet = fileSet;
 
-const ansi2ansi = n => n;
-const rgb2rgb = (r, g, b) => [r, g, b];
+  fileSet.on('add', (/** @type {VFile} */ file) => {
+    filePipeline.run(
+      {
+        configuration: context.configuration,
+        // Needed `any`s
+        // type-coverage:ignore-next-line
+        processor: settings.processor(),
+        fileSet,
+        settings
+      },
+      file,
+      (/** @type {Error|null} */ error) => {
+        // Does not occur as all failures in `filePipeLine` are failed on each
+        // file.
+        // Still, just to ensure things work in the future, we add an extra check.
+        /* c8 ignore next 4 */
+        if (error) {
+          Object.assign(file.message(error), {fatal: true});
+        }
 
-const setLazyProperty = (object, property, get) => {
-	Object.defineProperty(object, property, {
-		get: () => {
-			const value = get();
+        fileSet.emit('one', file);
+      }
+    );
+  });
 
-			Object.defineProperty(object, property, {
-				value,
-				enumerable: true,
-				configurable: true
-			});
+  fileSet.on('done', next);
 
-			return value;
-		},
-		enumerable: true,
-		configurable: true
-	});
-};
+  if (context.files.length === 0) {
+    next();
+  } else {
+    let index = -1;
+    while (++index < context.files.length) {
+      fileSet.add(context.files[index]);
+    }
+  }
+}
 
-/** @type {typeof import('color-convert')} */
-let colorConvert;
-const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
-	if (colorConvert === undefined) {
-		colorConvert = colorConvert$1;
-	}
+function hasFlag(flag, argv = process$1.argv) {
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf('--');
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
 
-	const offset = isBackground ? 10 : 0;
-	const styles = {};
+const {env} = process$1;
 
-	for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
-		const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
-		if (sourceSpace === targetSpace) {
-			styles[name] = wrap(identity, offset);
-		} else if (typeof suite === 'object') {
-			styles[name] = wrap(suite[targetSpace], offset);
+let flagForceColor;
+if (hasFlag('no-color') ||
+	hasFlag('no-colors') ||
+	hasFlag('color=false') ||
+	hasFlag('color=never')) {
+	flagForceColor = 0;
+} else if (hasFlag('color') ||
+	hasFlag('colors') ||
+	hasFlag('color=true') ||
+	hasFlag('color=always')) {
+	flagForceColor = 1;
+}
+
+function envForceColor() {
+	if ('FORCE_COLOR' in env) {
+		if (env.FORCE_COLOR === 'true') {
+			return 1;
 		}
-	}
 
-	return styles;
-};
+		if (env.FORCE_COLOR === 'false') {
+			return 0;
+		}
 
-function assembleStyles() {
-	const codes = new Map();
-	const styles = {
-		modifier: {
-			reset: [0, 0],
-			// 21 isn't widely supported and 22 does the same thing
-			bold: [1, 22],
-			dim: [2, 22],
-			italic: [3, 23],
-			underline: [4, 24],
-			inverse: [7, 27],
-			hidden: [8, 28],
-			strikethrough: [9, 29]
-		},
-		color: {
-			black: [30, 39],
-			red: [31, 39],
-			green: [32, 39],
-			yellow: [33, 39],
-			blue: [34, 39],
-			magenta: [35, 39],
-			cyan: [36, 39],
-			white: [37, 39],
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
 
-			// Bright color
-			blackBright: [90, 39],
-			redBright: [91, 39],
-			greenBright: [92, 39],
-			yellowBright: [93, 39],
-			blueBright: [94, 39],
-			magentaBright: [95, 39],
-			cyanBright: [96, 39],
-			whiteBright: [97, 39]
-		},
-		bgColor: {
-			bgBlack: [40, 49],
-			bgRed: [41, 49],
-			bgGreen: [42, 49],
-			bgYellow: [43, 49],
-			bgBlue: [44, 49],
-			bgMagenta: [45, 49],
-			bgCyan: [46, 49],
-			bgWhite: [47, 49],
+function translateLevel(level) {
+	if (level === 0) {
+		return false;
+	}
+
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
 
-			// Bright color
-			bgBlackBright: [100, 49],
-			bgRedBright: [101, 49],
-			bgGreenBright: [102, 49],
-			bgYellowBright: [103, 49],
-			bgBlueBright: [104, 49],
-			bgMagentaBright: [105, 49],
-			bgCyanBright: [106, 49],
-			bgWhiteBright: [107, 49]
+function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== undefined) {
+		flagForceColor = noFlagForceColor;
+	}
+
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+
+	if (forceColor === 0) {
+		return 0;
+	}
+
+	if (sniffFlags) {
+		if (hasFlag('color=16m') ||
+			hasFlag('color=full') ||
+			hasFlag('color=truecolor')) {
+			return 3;
 		}
-	};
 
-	// Alias bright black as gray (and grey)
-	styles.color.gray = styles.color.blackBright;
-	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
-	styles.color.grey = styles.color.blackBright;
-	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+		if (hasFlag('color=256')) {
+			return 2;
+		}
+	}
 
-	for (const [groupName, group] of Object.entries(styles)) {
-		for (const [styleName, style] of Object.entries(group)) {
-			styles[styleName] = {
-				open: `\u001B[${style[0]}m`,
-				close: `\u001B[${style[1]}m`
-			};
+	if (haveStream && !streamIsTTY && forceColor === undefined) {
+		return 0;
+	}
 
-			group[styleName] = styles[styleName];
+	const min = forceColor || 0;
 
-			codes.set(style[0], style[1]);
+	if (env.TERM === 'dumb') {
+		return min;
+	}
+
+	if (process$1.platform === 'win32') {
+		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+		const osRelease = require$$0$2.release().split('.');
+		if (
+			Number(osRelease[0]) >= 10 &&
+			Number(osRelease[2]) >= 10586
+		) {
+			return Number(osRelease[2]) >= 14931 ? 3 : 2;
 		}
 
-		Object.defineProperty(styles, groupName, {
-			value: group,
-			enumerable: false
-		});
+		return 1;
 	}
 
-	Object.defineProperty(styles, 'codes', {
-		value: codes,
-		enumerable: false
-	});
+	if ('CI' in env) {
+		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+			return 1;
+		}
 
-	styles.color.close = '\u001B[39m';
-	styles.bgColor.close = '\u001B[49m';
+		return min;
+	}
 
-	setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
-	setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
-	setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
-	setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
-	setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
-	setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
+	if ('TEAMCITY_VERSION' in env) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	}
 
-	return styles;
-}
+	if (env.COLORTERM === 'truecolor') {
+		return 3;
+	}
 
-// Make the export immutable
-Object.defineProperty(module, 'exports', {
-	enumerable: true,
-	get: assembleStyles
-});
-});
+	if ('TERM_PROGRAM' in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
 
-const stringReplaceAll = (string, substring, replacer) => {
-	let index = string.indexOf(substring);
-	if (index === -1) {
-		return string;
+		switch (env.TERM_PROGRAM) {
+			case 'iTerm.app':
+				return version >= 3 ? 3 : 2;
+			case 'Apple_Terminal':
+				return 2;
+			// No default
+		}
 	}
 
-	const substringLength = substring.length;
-	let endIndex = 0;
-	let returnValue = '';
-	do {
-		returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
-		endIndex = index + substringLength;
-		index = string.indexOf(substring, endIndex);
-	} while (index !== -1);
+	if (/-256(color)?$/i.test(env.TERM)) {
+		return 2;
+	}
 
-	returnValue += string.substr(endIndex);
-	return returnValue;
-};
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+		return 1;
+	}
 
-const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
-	let endIndex = 0;
-	let returnValue = '';
-	do {
-		const gotCR = string[index - 1] === '\r';
-		returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
-		endIndex = index + 1;
-		index = string.indexOf('\n', endIndex);
-	} while (index !== -1);
+	if ('COLORTERM' in env) {
+		return 1;
+	}
 
-	returnValue += string.substr(endIndex);
-	return returnValue;
-};
+	return min;
+}
 
-var util = {
-	stringReplaceAll,
-	stringEncaseCRLFWithFirstIndex
-};
+function createSupportsColor(stream, options = {}) {
+	const level = _supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	});
 
-const TEMPLATE_REGEX$1 = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
-const STYLE_REGEX$1 = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
-const STRING_REGEX$1 = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
-const ESCAPE_REGEX$1 = /\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.)|([^\\])/gi;
+	return translateLevel(level);
+}
 
-const ESCAPES$1 = new Map([
-	['n', '\n'],
-	['r', '\r'],
-	['t', '\t'],
-	['b', '\b'],
-	['f', '\f'],
-	['v', '\v'],
-	['0', '\0'],
-	['\\', '\\'],
-	['e', '\u001B'],
-	['a', '\u0007']
-]);
+const supportsColor = {
+	stdout: createSupportsColor({isTTY: tty$1.isatty(1)}),
+	stderr: createSupportsColor({isTTY: tty$1.isatty(2)})
+};
 
-function unescape$1(c) {
-	const u = c[0] === 'u';
-	const bracket = c[1] === '{';
+function ansiRegex({onlyFirst = false} = {}) {
+	const pattern = [
+		'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+	].join('|');
 
-	if ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
-		return String.fromCharCode(parseInt(c.slice(1), 16));
-	}
+	return new RegExp(pattern, onlyFirst ? undefined : 'g');
+}
 
-	if (u && bracket) {
-		return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+function stripAnsi(string) {
+	if (typeof string !== 'string') {
+		throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
 	}
 
-	return ESCAPES$1.get(c) || c;
+	return string.replace(ansiRegex(), '');
 }
 
-function parseArguments$1(name, arguments_) {
-	const results = [];
-	const chunks = arguments_.trim().split(/\s*,\s*/g);
-	let matches;
+/* eslint-disable yoda */
 
-	for (const chunk of chunks) {
-		const number = Number(chunk);
-		if (!Number.isNaN(number)) {
-			results.push(number);
-		} else if ((matches = chunk.match(STRING_REGEX$1))) {
-			results.push(matches[2].replace(ESCAPE_REGEX$1, (m, escape, character) => escape ? unescape$1(escape) : character));
-		} else {
-			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
-		}
+function isFullwidthCodePoint(codePoint) {
+	if (!Number.isInteger(codePoint)) {
+		return false;
 	}
 
-	return results;
+	// Code points are derived from:
+	// https://unicode.org/Public/UNIDATA/EastAsianWidth.txt
+	return codePoint >= 0x1100 && (
+		codePoint <= 0x115F || // Hangul Jamo
+		codePoint === 0x2329 || // LEFT-POINTING ANGLE BRACKET
+		codePoint === 0x232A || // RIGHT-POINTING ANGLE BRACKET
+		// CJK Radicals Supplement .. Enclosed CJK Letters and Months
+		(0x2E80 <= codePoint && codePoint <= 0x3247 && codePoint !== 0x303F) ||
+		// Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+		(0x3250 <= codePoint && codePoint <= 0x4DBF) ||
+		// CJK Unified Ideographs .. Yi Radicals
+		(0x4E00 <= codePoint && codePoint <= 0xA4C6) ||
+		// Hangul Jamo Extended-A
+		(0xA960 <= codePoint && codePoint <= 0xA97C) ||
+		// Hangul Syllables
+		(0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
+		// CJK Compatibility Ideographs
+		(0xF900 <= codePoint && codePoint <= 0xFAFF) ||
+		// Vertical Forms
+		(0xFE10 <= codePoint && codePoint <= 0xFE19) ||
+		// CJK Compatibility Forms .. Small Form Variants
+		(0xFE30 <= codePoint && codePoint <= 0xFE6B) ||
+		// Halfwidth and Fullwidth Forms
+		(0xFF01 <= codePoint && codePoint <= 0xFF60) ||
+		(0xFFE0 <= codePoint && codePoint <= 0xFFE6) ||
+		// Kana Supplement
+		(0x1B000 <= codePoint && codePoint <= 0x1B001) ||
+		// Enclosed Ideographic Supplement
+		(0x1F200 <= codePoint && codePoint <= 0x1F251) ||
+		// CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+		(0x20000 <= codePoint && codePoint <= 0x3FFFD)
+	);
 }
 
-function parseStyle$1(style) {
-	STYLE_REGEX$1.lastIndex = 0;
+var emojiRegex = function () {
+  // https://mths.be/emoji
+  return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|(?:\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFC-\uDFFF])|\uD83D\uDC68(?:\uD83C\uDFFB(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|[\u2695\u2696\u2708]\uFE0F|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))?|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])\uFE0F|\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC)?|(?:\uD83D\uDC69(?:\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC69(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83E\uDDD1(?:\u200D(?:\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F\u200D\u26A7|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\uD83C\uDFF4\u200D\u2620|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u2600-\u2604\u260E\u2611\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26B0\u26B1\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0\u26F1\u26F4\u26F7\u26F8\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u3030\u303D\u3297\u3299]|\uD83C[\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])\uFE0F|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDE35\u200D\uD83D\uDCAB|\uD83D\uDE2E\u200D\uD83D\uDCA8|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83E\uDDD1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC69(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83D\uDC08\u200D\u2B1B|\u2764\uFE0F\u200D(?:\uD83D\uDD25|\uD83E\uDE79)|\uD83D\uDC41\uFE0F|\uD83C\uDFF3\uFE0F|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F\u20E3|\u2764\uFE0F|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|\uD83C\uDFF4|(?:[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270C\u270D]|\uD83D[\uDD74\uDD90])(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC08\uDC15\uDC3B\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE2E\uDE35\uDE36\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5]|\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD]|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF]|[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0D\uDD0E\uDD10-\uDD17\uDD1D\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78\uDD7A-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCB\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6]|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26A7\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5-\uDED7\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDD77\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
+};
 
-	const results = [];
-	let matches;
+function stringWidth(string) {
+	if (typeof string !== 'string' || string.length === 0) {
+		return 0;
+	}
 
-	while ((matches = STYLE_REGEX$1.exec(style)) !== null) {
-		const name = matches[1];
+	string = stripAnsi(string);
 
-		if (matches[2]) {
-			const args = parseArguments$1(name, matches[2]);
-			results.push([name].concat(args));
-		} else {
-			results.push([name]);
-		}
+	if (string.length === 0) {
+		return 0;
 	}
 
-	return results;
-}
+	string = string.replace(emojiRegex(), '  ');
 
-function buildStyle$1(chalk, styles) {
-	const enabled = {};
+	let width = 0;
 
-	for (const layer of styles) {
-		for (const style of layer.styles) {
-			enabled[style[0]] = layer.inverse ? null : style.slice(1);
+	for (let index = 0; index < string.length; index++) {
+		const codePoint = string.codePointAt(index);
+
+		// Ignore control characters
+		if (codePoint <= 0x1F || (codePoint >= 0x7F && codePoint <= 0x9F)) {
+			continue;
 		}
-	}
 
-	let current = chalk;
-	for (const [styleName, styles] of Object.entries(enabled)) {
-		if (!Array.isArray(styles)) {
+		// Ignore combining characters
+		if (codePoint >= 0x300 && codePoint <= 0x36F) {
 			continue;
 		}
 
-		if (!(styleName in current)) {
-			throw new Error(`Unknown Chalk style: ${styleName}`);
+		// Surrogates
+		if (codePoint > 0xFFFF) {
+			index++;
 		}
 
-		current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
+		width += isFullwidthCodePoint(codePoint) ? 2 : 1;
 	}
 
-	return current;
+	return width;
 }
 
-var templates$1 = (chalk, temporary) => {
-	const styles = [];
-	const chunks = [];
-	let chunk = [];
+/*!
+ * repeat-string <https://github.com/jonschlinkert/repeat-string>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
 
-	// eslint-disable-next-line max-params
-	temporary.replace(TEMPLATE_REGEX$1, (m, escapeCharacter, inverse, style, close, character) => {
-		if (escapeCharacter) {
-			chunk.push(unescape$1(escapeCharacter));
-		} else if (style) {
-			const string = chunk.join('');
-			chunk = [];
-			chunks.push(styles.length === 0 ? string : buildStyle$1(chalk, styles)(string));
-			styles.push({inverse, styles: parseStyle$1(style)});
-		} else if (close) {
-			if (styles.length === 0) {
-				throw new Error('Found extraneous } in Chalk template literal');
-			}
+/**
+ * Results cache
+ */
 
-			chunks.push(buildStyle$1(chalk, styles)(chunk.join('')));
-			chunk = [];
-			styles.pop();
-		} else {
-			chunk.push(character);
-		}
-	});
+var res = '';
+var cache;
 
-	chunks.push(chunk.join(''));
+/**
+ * Expose `repeat`
+ */
 
-	if (styles.length > 0) {
-		const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
-		throw new Error(errMsg);
-	}
+var repeatString = repeat;
 
-	return chunks.join('');
-};
+/**
+ * Repeat the given `string` the specified `number`
+ * of times.
+ *
+ * **Example:**
+ *
+ * ```js
+ * var repeat = require('repeat-string');
+ * repeat('A', 5);
+ * //=> AAAAA
+ * ```
+ *
+ * @param {String} `string` The string to repeat
+ * @param {Number} `number` The number of times to repeat the string
+ * @return {String} Repeated string
+ * @api public
+ */
 
-const {stdout: stdoutColor, stderr: stderrColor} = supportsColor_1$1;
-const {
-	stringReplaceAll: stringReplaceAll$1,
-	stringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex$1
-} = util;
+function repeat(str, num) {
+  if (typeof str !== 'string') {
+    throw new TypeError('expected a string');
+  }
 
-// `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = [
-	'ansi',
-	'ansi',
-	'ansi256',
-	'ansi16m'
-];
+  // cover common, quick use cases
+  if (num === 1) return str;
+  if (num === 2) return str + str;
 
-const styles = Object.create(null);
+  var max = str.length * num;
+  if (cache !== str || typeof cache === 'undefined') {
+    cache = str;
+    res = '';
+  } else if (res.length >= max) {
+    return res.substr(0, max);
+  }
 
-const applyOptions = (object, options = {}) => {
-	if (options.level > 3 || options.level < 0) {
-		throw new Error('The `level` option should be an integer from 0 to 3');
-	}
+  while (max > res.length && num > 1) {
+    if (num & 1) {
+      res += str;
+    }
 
-	// Detect level if not set manually
-	const colorLevel = stdoutColor ? stdoutColor.level : 0;
-	object.level = options.level === undefined ? colorLevel : options.level;
-};
+    num >>= 1;
+    str += str;
+  }
 
-class ChalkClass {
-	constructor(options) {
-		return chalkFactory(options);
-	}
+  res += str;
+  res = res.substr(0, max);
+  return res;
 }
 
-const chalkFactory = options => {
-	const chalk = {};
-	applyOptions(chalk, options);
-
-	chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
-
-	Object.setPrototypeOf(chalk, Chalk.prototype);
-	Object.setPrototypeOf(chalk.template, chalk);
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ */
 
-	chalk.template.constructor = () => {
-		throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
-	};
+var severities = {true: 2, false: 1, null: 0, undefined: 0};
 
-	chalk.template.Instance = ChalkClass;
+/**
+ * @template {VFile} F
+ * @param {F} file
+ * @returns {F}
+ */
+function sort(file) {
+  file.messages.sort(comparator);
+  return file
+}
 
-	return chalk.template;
-};
+/**
+ * @param {VFileMessage} a
+ * @param {VFileMessage} b
+ * @returns {number}
+ */
+function comparator(a, b) {
+  return (
+    check$1(a, b, 'line') ||
+    check$1(a, b, 'column') ||
+    severities[b.fatal] - severities[a.fatal] ||
+    compare(a, b, 'source') ||
+    compare(a, b, 'ruleId') ||
+    compare(a, b, 'reason') ||
+    0
+  )
+}
 
-function Chalk(options) {
-	return chalkFactory(options);
+/**
+ * @param {VFileMessage} a
+ * @param {VFileMessage} b
+ * @param {string} property
+ * @returns {number}
+ */
+function check$1(a, b, property) {
+  return (a[property] || 0) - (b[property] || 0)
 }
 
-for (const [styleName, style] of Object.entries(ansiStyles$1)) {
-	styles[styleName] = {
-		get() {
-			const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
-			Object.defineProperty(this, styleName, {value: builder});
-			return builder;
-		}
-	};
+/**
+ * @param {VFileMessage} a
+ * @param {VFileMessage} b
+ * @param {string} property
+ * @returns {number}
+ */
+function compare(a, b, property) {
+  return String(a[property] || '').localeCompare(b[property] || '')
 }
 
-styles.visible = {
-	get() {
-		const builder = createBuilder(this, this._styler, true);
-		Object.defineProperty(this, 'visible', {value: builder});
-		return builder;
-	}
-};
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ * @typedef {import('vfile-statistics').Statistics} Statistics
+ *
+ * @typedef Options
+ * @property {boolean} [color]
+ * @property {boolean} [silent=false]
+ * @property {boolean} [quiet=false]
+ * @property {boolean} [verbose=false]
+ * @property {string} [defaultName='<stdin>']
+ *
+ * @typedef _Row
+ * @property {string} place
+ * @property {string} label
+ * @property {string} reason
+ * @property {string} ruleId
+ * @property {string} source
+ *
+ * @typedef _FileRow
+ * @property {'file'} type
+ * @property {VFile} file
+ * @property {Statistics} stats
+ *
+ * @typedef {{[x: string]: number}} _Sizes
+ *
+ * @typedef _Info
+ * @property {Array.<_FileRow|_Row>} rows
+ * @property {Statistics} stats
+ * @property {_Sizes} sizes
+ */
 
-const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
+var own$8 = {}.hasOwnProperty;
 
-for (const model of usedModels) {
-	styles[model] = {
-		get() {
-			const {level} = this;
-			return function (...arguments_) {
-				const styler = createStyler(ansiStyles$1.color[levelMapping[level]][model](...arguments_), ansiStyles$1.color.close, this._styler);
-				return createBuilder(this, styler, this._isEmpty);
-			};
-		}
-	};
-}
+// @ts-ignore Types are incorrect.
+var supported = supportsColor.stderr.hasBasic;
 
-for (const model of usedModels) {
-	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
-	styles[bgModel] = {
-		get() {
-			const {level} = this;
-			return function (...arguments_) {
-				const styler = createStyler(ansiStyles$1.bgColor[levelMapping[level]][model](...arguments_), ansiStyles$1.bgColor.close, this._styler);
-				return createBuilder(this, styler, this._isEmpty);
-			};
-		}
-	};
+// `log-symbols` without chalk, ignored for Windows:
+/* c8 ignore next 4 */
+var chars =
+  process.platform === 'win32'
+    ? {error: '×', warning: '‼'}
+    : {error: '✖', warning: '⚠'};
+
+var labels = {true: 'error', false: 'warning', null: 'info', undefined: 'info'};
+
+/**
+ * Report a file’s messages.
+ *
+ * @param {Error|VFile|Array.<VFile>} [files]
+ * @param {Options} [options]
+ * @returns {string}
+ */
+function reporter$1(files, options = {}) {
+  /** @type {boolean} */
+  var one;
+
+  if (!files) {
+    return ''
+  }
+
+  // Error.
+  if ('name' in files && 'message' in files) {
+    return String(files.stack || files)
+  }
+
+  // One file.
+  if (!Array.isArray(files)) {
+    one = true;
+    files = [files];
+  }
+
+  return format(transform(files, options), one, options)
 }
 
-const proto$3 = Object.defineProperties(() => {}, {
-	...styles,
-	level: {
-		enumerable: true,
-		get() {
-			return this._generator.level;
-		},
-		set(level) {
-			this._generator.level = level;
-		}
-	}
-});
+/**
+ * @param {Array.<VFile>} files
+ * @param {Options} options
+ * @returns {_Info}
+ */
+function transform(files, options) {
+  var index = -1;
+  /** @type {Array.<_FileRow|_Row>} */
+  var rows = [];
+  /** @type {Array.<VFileMessage>} */
+  var all = [];
+  /** @type {number} */
+  var offset;
+  /** @type {_Sizes} */
+  var sizes = {};
+  /** @type {Array.<VFileMessage>} */
+  var messages;
+  /** @type {VFileMessage} */
+  var message;
+  /** @type {_Row} */
+  var row;
+  /** @type {Array.<_Row>} */
+  var messageRows;
+  /** @type {string} */
+  var key;
 
-const createStyler = (open, close, parent) => {
-	let openAll;
-	let closeAll;
-	if (parent === undefined) {
-		openAll = open;
-		closeAll = close;
-	} else {
-		openAll = parent.openAll + open;
-		closeAll = close + parent.closeAll;
-	}
+  while (++index < files.length) {
+    // @ts-ignore it works fine.
+    messages = sort({messages: [...files[index].messages]}).messages;
+    messageRows = [];
+    offset = -1;
 
-	return {
-		open,
-		close,
-		openAll,
-		closeAll,
-		parent
-	};
-};
+    while (++offset < messages.length) {
+      message = messages[offset];
 
-const createBuilder = (self, _styler, _isEmpty) => {
-	const builder = (...arguments_) => {
-		// Single argument is hot path, implicit coercion is faster than anything
-		// eslint-disable-next-line no-implicit-coercion
-		return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
-	};
+      if (!options.silent || message.fatal) {
+        all.push(message);
 
-	// `__proto__` is used because we must return a function, but there is
-	// no way to create a function with a different prototype
-	builder.__proto__ = proto$3; // eslint-disable-line no-proto
+        row = {
+          place: stringifyPosition$1(
+            message.position.end.line && message.position.end.column
+              ? message.position
+              : message.position.start
+          ),
+          label: labels[message.fatal],
+          reason:
+            (message.stack || message.message) +
+            (options.verbose && message.note ? '\n' + message.note : ''),
+          ruleId: message.ruleId || '',
+          source: message.source || ''
+        };
 
-	builder._generator = self;
-	builder._styler = _styler;
-	builder._isEmpty = _isEmpty;
+        for (key in row) {
+          if (own$8.call(row, key)) {
+            sizes[key] = Math.max(size$1(row[key]), sizes[key] || 0);
+          }
+        }
 
-	return builder;
-};
+        messageRows.push(row);
+      }
+    }
 
-const applyStyle = (self, string) => {
-	if (self.level <= 0 || !string) {
-		return self._isEmpty ? '' : string;
-	}
+    if ((!options.quiet && !options.silent) || messageRows.length > 0) {
+      rows.push(
+        {type: 'file', file: files[index], stats: statistics(messages)},
+        ...messageRows
+      );
+    }
+  }
 
-	let styler = self._styler;
+  return {rows, stats: statistics(all), sizes}
+}
 
-	if (styler === undefined) {
-		return string;
-	}
+/**
+ * @param {_Info} map
+ * @param {boolean} one
+ * @param {Options} options
+ */
+function format(map, one, options) {
+  /** @type {boolean} */
+  var enabled =
+    options.color === undefined || options.color === null
+      ? supported
+      : options.color;
+  /** @type {Array.<string>} */
+  var lines = [];
+  var index = -1;
+  /** @type {Statistics} */
+  var stats;
+  /** @type {_FileRow|_Row} */
+  var row;
+  /** @type {string} */
+  var line;
+  /** @type {string} */
+  var reason;
+  /** @type {string} */
+  var rest;
+  /** @type {RegExpMatchArray} */
+  var match;
 
-	const {openAll, closeAll} = styler;
-	if (string.indexOf('\u001B') !== -1) {
-		while (styler !== undefined) {
-			// Replace any instances already present with a re-opening code
-			// otherwise only the part of the string until said closing code
-			// will be colored, and the rest will simply be 'plain'.
-			string = stringReplaceAll$1(string, styler.close, styler.open);
+  while (++index < map.rows.length) {
+    row = map.rows[index];
+
+    if ('type' in row) {
+      stats = row.stats;
+      line = row.file.history[0] || options.defaultName || '<stdin>';
+
+      line =
+        one && !options.defaultName && !row.file.history[0]
+          ? ''
+          : (enabled
+              ? '\u001B[4m' /* Underline. */ +
+                (stats.fatal
+                  ? '\u001B[31m' /* Red. */
+                  : stats.total
+                  ? '\u001B[33m' /* Yellow. */
+                  : '\u001B[32m') /* Green. */ +
+                line +
+                '\u001B[39m\u001B[24m'
+              : line) +
+            (row.file.stored && row.file.path !== row.file.history[0]
+              ? ' > ' + row.file.path
+              : '');
+
+      if (!stats.total) {
+        line =
+          (line ? line + ': ' : '') +
+          (row.file.stored
+            ? enabled
+              ? '\u001B[33mwritten\u001B[39m' /* Yellow. */
+              : 'written'
+            : 'no issues found');
+      }
 
-			styler = styler.parent;
-		}
-	}
+      if (line) {
+        if (index && !('type' in map.rows[index - 1])) {
+          lines.push('');
+        }
 
-	// We can move both next actions out of loop, because remaining actions in loop won't have
-	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
-	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
-	const lfIndex = string.indexOf('\n');
-	if (lfIndex !== -1) {
-		string = stringEncaseCRLFWithFirstIndex$1(string, closeAll, openAll, lfIndex);
-	}
+        lines.push(line);
+      }
+    } else {
+      reason = row.reason;
+      match = /\r?\n|\r/.exec(reason);
 
-	return openAll + string + closeAll;
-};
+      if (match) {
+        rest = reason.slice(match.index);
+        reason = reason.slice(0, match.index);
+      } else {
+        rest = '';
+      }
 
-let template;
-const chalkTag = (chalk, ...strings) => {
-	const [firstString] = strings;
+      lines.push(
+        (
+          '  ' +
+          repeatString(' ', map.sizes.place - size$1(row.place)) +
+          row.place +
+          '  ' +
+          (enabled
+            ? (row.label === 'error'
+                ? '\u001B[31m' /* Red. */
+                : '\u001B[33m') /* Yellow. */ +
+              row.label +
+              '\u001B[39m'
+            : row.label) +
+          repeatString(' ', map.sizes.label - size$1(row.label)) +
+          '  ' +
+          reason +
+          repeatString(' ', map.sizes.reason - size$1(reason)) +
+          '  ' +
+          row.ruleId +
+          repeatString(' ', map.sizes.ruleId - size$1(row.ruleId)) +
+          '  ' +
+          (row.source || '')
+        ).replace(/ +$/, '') + rest
+      );
+    }
+  }
 
-	if (!Array.isArray(firstString)) {
-		// If chalk() was called by itself or with a string,
-		// return the string itself as a string.
-		return strings.join(' ');
-	}
+  stats = map.stats;
 
-	const arguments_ = strings.slice(1);
-	const parts = [firstString.raw[0]];
+  if (stats.fatal || stats.warn) {
+    line = '';
 
-	for (let i = 1; i < firstString.length; i++) {
-		parts.push(
-			String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
-			String(firstString.raw[i])
-		);
-	}
+    if (stats.fatal) {
+      line =
+        (enabled
+          ? '\u001B[31m' /* Red. */ + chars.error + '\u001B[39m'
+          : chars.error) +
+        ' ' +
+        stats.fatal +
+        ' ' +
+        (labels.true + (stats.fatal === 1 ? '' : 's'));
+    }
 
-	if (template === undefined) {
-		template = templates$1;
-	}
+    if (stats.warn) {
+      line =
+        (line ? line + ', ' : '') +
+        (enabled
+          ? '\u001B[33m' /* Yellow. */ + chars.warning + '\u001B[39m'
+          : chars.warning) +
+        ' ' +
+        stats.warn +
+        ' ' +
+        (labels.false + (stats.warn === 1 ? '' : 's'));
+    }
 
-	return template(chalk, parts.join(''));
-};
+    if (stats.total !== stats.fatal && stats.total !== stats.warn) {
+      line = stats.total + ' messages (' + line + ')';
+    }
 
-Object.defineProperties(Chalk.prototype, styles);
+    lines.push('', line);
+  }
 
-const chalk$1 = Chalk(); // eslint-disable-line new-cap
-chalk$1.supportsColor = stdoutColor;
-chalk$1.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
-chalk$1.stderr.supportsColor = stderrColor;
+  return lines.join('\n')
+}
 
-// For TypeScript
-chalk$1.Level = {
-	None: 0,
-	Basic: 1,
-	Ansi256: 2,
-	TrueColor: 3,
-	0: 'None',
-	1: 'Basic',
-	2: 'Ansi256',
-	3: 'TrueColor'
-};
+/**
+ * Get the length of `value`, ignoring ANSI sequences.
+ *
+ * @param {string} value
+ * @returns {number}
+ */
+function size$1(value) {
+  var match = /\r?\n|\r/.exec(value);
+  return stringWidth(match ? value.slice(0, match.index) : value)
+}
 
-var source = chalk$1;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('../index.js').VFileReporter} VFileReporter
+ * @typedef {import('./index.js').Settings} Settings
+ * @typedef {import('./index.js').Configuration} Configuration
+ */
 
-const WIN_SLASH = '\\\\/';
-const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+/**
+ * @typedef Context
+ * @property {Array.<VFile>} files
+ * @property {Configuration} [configuration]
+ */
 
 /**
- * Posix glob regex
+ * @param {Context} context
+ * @param {Settings} settings
  */
+async function log(context, settings) {
+  /** @type {VFileReporter} */
+  let func = reporter$1;
 
-const DOT_LITERAL = '\\.';
-const PLUS_LITERAL = '\\+';
-const QMARK_LITERAL = '\\?';
-const SLASH_LITERAL = '\\/';
-const ONE_CHAR = '(?=.)';
-const QMARK = '[^/]';
-const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
-const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
-const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
-const NO_DOT = `(?!${DOT_LITERAL})`;
-const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
-const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
-const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
-const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
-const STAR = `${QMARK}*?`;
+  if (typeof settings.reporter === 'string') {
+    try {
+      // @ts-expect-error: Assume loaded value is a vfile reporter.
+      func = await loadPlugin(settings.reporter, {
+        cwd: settings.cwd,
+        prefix: 'vfile-reporter'
+      });
+    } catch {
+      throw new Error('Could not find reporter `' + settings.reporter + '`')
+    }
+  } else if (settings.reporter) {
+    func = settings.reporter;
+  }
 
-const POSIX_CHARS = {
-  DOT_LITERAL,
-  PLUS_LITERAL,
-  QMARK_LITERAL,
-  SLASH_LITERAL,
-  ONE_CHAR,
-  QMARK,
-  END_ANCHOR,
-  DOTS_SLASH,
-  NO_DOT,
-  NO_DOTS,
-  NO_DOT_SLASH,
-  NO_DOTS_SLASH,
-  QMARK_NO_DOT,
-  STAR,
-  START_ANCHOR
-};
+  let diagnostics = func(
+    context.files.filter((file) => file.data.unifiedEngineGiven),
+    Object.assign({}, settings.reporterOptions, {
+      quiet: settings.quiet,
+      silent: settings.silent,
+      color: settings.color
+    })
+  );
+
+  if (diagnostics) {
+    if (diagnostics.charAt(diagnostics.length - 1) !== '\n') {
+      diagnostics += '\n';
+    }
+
+    return new Promise((resolve) => {
+      settings.streamError.write(diagnostics, resolve);
+    })
+  }
+}
 
 /**
- * Windows glob regex
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('../configuration.js').Configuration} Configuration
+ * @typedef {import('../index.js').Settings} Settings
  */
 
-const WINDOWS_CHARS = {
-  ...POSIX_CHARS,
+const fileSetPipeline = trough()
+  .use(configure$3)
+  .use(fileSystem$1)
+  .use(stdin)
+  .use(transform$1)
+  .use(log);
 
-  SLASH_LITERAL: `[${WIN_SLASH}]`,
-  QMARK: WIN_NO_SLASH,
-  STAR: `${WIN_NO_SLASH}*?`,
-  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
-  NO_DOT: `(?!${DOT_LITERAL})`,
-  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
-  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
-  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
-};
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('unified').Processor<any, any, any, any>} Processor
+ * @typedef {import('./file-set.js').FileSet} FileSet
+ * @typedef {import('./file-set.js').Completer} Completer
+ * @typedef {import('./ignore.js').ResolveFrom} ResolveFrom
+ * @typedef {import('./configuration.js').ConfigTransform} ConfigTransform
+ * @typedef {import('./configuration.js').Preset} Preset
+ *
+ * @typedef VFileReporterFields
+ * @property {boolean} [color]
+ * @property {boolean} [quiet]
+ * @property {boolean} [silent]
+ *
+ * @typedef {{[key: string]: unknown} & VFileReporterFields} VFileReporterOptions
+ *
+ * @callback VFileReporter
+ * @param {VFile[]} files
+ * @param {VFileReporterOptions} options
+ * @returns {string}
+ *
+ * @typedef Settings
+ * @property {Options['processor']} processor
+ * @property {Exclude<Options['cwd'], undefined>} cwd
+ * @property {Exclude<Options['files'], undefined>} files
+ * @property {Exclude<Options['extensions'], undefined>} extensions
+ * @property {Exclude<Options['streamIn'], undefined>} streamIn
+ * @property {Options['filePath']} filePath
+ * @property {Exclude<Options['streamOut'], undefined>} streamOut
+ * @property {Exclude<Options['streamError'], undefined>} streamError
+ * @property {Options['out']} out
+ * @property {Options['output']} output
+ * @property {Options['alwaysStringify']} alwaysStringify
+ * @property {Options['tree']} tree
+ * @property {Options['treeIn']} treeIn
+ * @property {Options['treeOut']} treeOut
+ * @property {Options['inspect']} inspect
+ * @property {Options['rcName']} rcName
+ * @property {Options['packageField']} packageField
+ * @property {Options['detectConfig']} detectConfig
+ * @property {Options['rcPath']} rcPath
+ * @property {Exclude<Options['settings'], undefined>} settings
+ * @property {Options['ignoreName']} ignoreName
+ * @property {Options['detectIgnore']} detectIgnore
+ * @property {Options['ignorePath']} ignorePath
+ * @property {Options['ignorePathResolveFrom']} ignorePathResolveFrom
+ * @property {Exclude<Options['ignorePatterns'], undefined>} ignorePatterns
+ * @property {Options['silentlyIgnore']} silentlyIgnore
+ * @property {Options['plugins']} plugins
+ * @property {Options['pluginPrefix']} pluginPrefix
+ * @property {Options['configTransform']} configTransform
+ * @property {Options['defaultConfig']} defaultConfig
+ * @property {Options['reporter']} reporter
+ * @property {Options['reporterOptions']} reporterOptions
+ * @property {Options['color']} color
+ * @property {Options['silent']} silent
+ * @property {Options['quiet']} quiet
+ * @property {Options['frail']} frail
+ *
+ * @typedef Options
+ *   Options for unified engine
+ * @property {() => Processor} processor
+ *   Unified processor to transform files
+ * @property {string} [cwd]
+ *   Directory to search files in, load plugins from, and more.
+ *   Defaults to `process.cwd()`.
+ * @property {Array<string|VFile>} [files]
+ *   Paths or globs to files and directories, or virtual files, to process.
+ * @property {string[]} [extensions]
+ *   If `files` matches directories, include `files` with `extensions`
+ * @property {NodeJS.ReadableStream} [streamIn]
+ *   Stream to read from if no files are found or given.
+ *   Defaults to `process.stdin`.
+ * @property {string} [filePath]
+ *   File path to process the given file on `streamIn` as.
+ * @property {NodeJS.WritableStream} [streamOut]
+ *   Stream to write processed files to.
+ *   Defaults to `process.stdout`.
+ * @property {NodeJS.WritableStream} [streamError]
+ *   Stream to write the report (if any) to.
+ *   Defaults to `process.stderr`.
+ * @property {boolean} [out=false]
+ *   Whether to write the processed file to `streamOut`
+ * @property {boolean|string} [output=false]
+ *   Whether to write successfully processed files, and where to.
+ *
+ *   * When `true`, overwrites the given files
+ *   * When `false`, does not write to the file system
+ *   * When pointing to an existing directory, files are written to that
+ *     directory and keep their original basenames
+ *   * When the parent directory of the given path exists and one file is
+ *     processed, the file is written to the given path
+ * @property {boolean} [alwaysStringify=false]
+ *   Whether to always serialize successfully processed files.
+ * @property {boolean} [tree=false]
+ *   Whether to treat both input and output as a syntax tree.
+ * @property {boolean} [treeIn]
+ *   Whether to treat input as a syntax tree.
+ *   Defaults to `options.tree`.
+ * @property {boolean} [treeOut]
+ *   Whether to treat output as a syntax tree.
+ *   Defaults to `options.tree`.
+ * @property {boolean} [inspect=false]
+ *   Whether to output a formatted syntax tree.
+ * @property {string} [rcName]
+ *   Name of configuration files to load.
+ * @property {string} [packageField]
+ *   Property at which configuration can be found in `package.json` files
+ * @property {boolean} [detectConfig]
+ *   Whether to search for configuration files.
+ *   Defaults to `true` if `rcName` or `packageField` are given
+ * @property {string} [rcPath]
+ *   Filepath to a configuration file to load.
+ * @property {Preset['settings']} [settings]
+ *   Configuration for the parser and compiler of the processor.
+ * @property {string} [ignoreName]
+ *   Name of ignore files to load.
+ * @property {boolean} [detectIgnore]
+ *   Whether to search for ignore files.
+ *   Defaults to `true` if `ignoreName` is given.
+ * @property {string} [ignorePath]
+ *   Filepath to an ignore file to load.
+ * @property {ResolveFrom} [ignorePathResolveFrom]
+ *   Resolve patterns in `ignorePath` from the current working
+ *   directory (`'cwd'`) or the ignore file’s directory (`'dir'`, default).
+ * @property {string[]} [ignorePatterns]
+ *   Patterns to ignore in addition to ignore files
+ * @property {boolean} [silentlyIgnore=false]
+ *   Skip given files if they are ignored.
+ * @property {Preset['plugins']} [plugins]
+ *   Plugins to use.
+ * @property {string} [pluginPrefix]
+ *   Prefix to use when searching for plugins
+ * @property {ConfigTransform} [configTransform]
+ *   Transform config files from a different schema.
+ * @property {Preset} [defaultConfig]
+ *   Default configuration to use if no config file is given or found.
+ * @property {VFileReporter|string} [reporter]
+ *   Reporter to use
+ *   Defaults to `vfile-reporter`
+ * @property {VFileReporterOptions} [reporterOptions]
+ *   Config to pass to the used reporter.
+ * @property {VFileReporterOptions['color']} [color=false]
+ *   Whether to report with ANSI color sequences.
+ * @property {VFileReporterOptions['silent']} [silent=false]
+ *   Report only fatal errors
+ * @property {VFileReporterOptions['quiet']} [quiet=false]
+ *   Do not report successful files
+ * @property {boolean} [frail=false]
+ *   Call back with an unsuccessful (`1`) code on warnings as well as errors
+ *
+ * @typedef Context
+ *   Processing context.
+ * @property {VFile[]} [files]
+ *   Processed files.
+ * @property {FileSet} [fileSet]
+ *   Internally used information
+ *
+ * @callback Callback
+ *   Callback called when processing according to options is complete.
+ *   Invoked with either a fatal error if processing went horribly wrong
+ *   (probably due to incorrect configuration), or a status code and the
+ *   processing context.
+ * @param {Error|null} error
+ * @param {0|1} [status]
+ * @param {Context} [context]
+ * @returns {void}
+ */
 
 /**
- * POSIX Bracket Regex
+ * Run the file set pipeline once.
+ * `callback` is called with a fatal error, or with a status code (`0` on
+ * success, `1` on failure).
+ *
+ * @param {Options} options
+ * @param {Callback} callback
  */
+function engine(options, callback) {
+  /** @type {Settings} */
+  const settings = {};
+  /** @type {NodeJS.ReadStream} */
+  // @ts-expect-error: `PassThrough` sure is readable.
+  let stdin = new PassThrough();
 
-const POSIX_REGEX_SOURCE = {
-  alnum: 'a-zA-Z0-9',
-  alpha: 'a-zA-Z',
-  ascii: '\\x00-\\x7F',
-  blank: ' \\t',
-  cntrl: '\\x00-\\x1F\\x7F',
-  digit: '0-9',
-  graph: '\\x21-\\x7E',
-  lower: 'a-z',
-  print: '\\x20-\\x7E ',
-  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
-  space: ' \\t\\r\\n\\v\\f',
-  upper: 'A-Z',
-  word: 'A-Za-z0-9_',
-  xdigit: 'A-Fa-f0-9'
-};
+  try {
+    stdin = process$2.stdin;
+    // Obscure bug in Node (seen on Windows).
+    // See: <https://github.com/nodejs/node/blob/f856234/lib/internal/process/stdio.js#L82>,
+    // <https://github.com/AtomLinter/linter-markdown/pull/85>.
+    /* c8 ignore next 1 */
+  } catch {}
 
-var constants = {
-  MAX_LENGTH: 1024 * 64,
-  POSIX_REGEX_SOURCE,
+  if (!callback) {
+    throw new Error('Missing `callback`')
+  }
 
-  // regular expressions
-  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
-  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
-  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
-  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
-  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
-  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+  // Needed `any`s
+  // type-coverage:ignore-next-line
+  if (!options || !options.processor) {
+    return next(new Error('Missing `processor`'))
+  }
 
-  // Replace globs with equivalent patterns to reduce parsing time.
-  REPLACEMENTS: {
-    '***': '*',
-    '**/**': '**',
-    '**/**/**': '**'
-  },
+  // Processor.
+  // Needed `any`s
+  // type-coverage:ignore-next-line
+  settings.processor = options.processor;
 
-  // Digits
-  CHAR_0: 48, /* 0 */
-  CHAR_9: 57, /* 9 */
+  // Path to run as.
+  settings.cwd = options.cwd || process$2.cwd();
 
-  // Alphabet chars.
-  CHAR_UPPERCASE_A: 65, /* A */
-  CHAR_LOWERCASE_A: 97, /* a */
-  CHAR_UPPERCASE_Z: 90, /* Z */
-  CHAR_LOWERCASE_Z: 122, /* z */
+  // Input.
+  settings.files = options.files || [];
+  settings.extensions = (options.extensions || []).map((ext) =>
+    ext.charAt(0) === '.' ? ext : '.' + ext
+  );
 
-  CHAR_LEFT_PARENTHESES: 40, /* ( */
-  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+  settings.filePath = options.filePath;
+  settings.streamIn = options.streamIn || stdin;
 
-  CHAR_ASTERISK: 42, /* * */
+  // Output.
+  settings.streamOut = options.streamOut || process$2.stdout;
+  settings.streamError = options.streamError || process$2.stderr;
+  settings.alwaysStringify = options.alwaysStringify;
+  settings.output = options.output;
+  settings.out = options.out;
 
-  // Non-alphabetic chars.
-  CHAR_AMPERSAND: 38, /* & */
-  CHAR_AT: 64, /* @ */
-  CHAR_BACKWARD_SLASH: 92, /* \ */
-  CHAR_CARRIAGE_RETURN: 13, /* \r */
-  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
-  CHAR_COLON: 58, /* : */
-  CHAR_COMMA: 44, /* , */
-  CHAR_DOT: 46, /* . */
-  CHAR_DOUBLE_QUOTE: 34, /* " */
-  CHAR_EQUAL: 61, /* = */
-  CHAR_EXCLAMATION_MARK: 33, /* ! */
-  CHAR_FORM_FEED: 12, /* \f */
-  CHAR_FORWARD_SLASH: 47, /* / */
-  CHAR_GRAVE_ACCENT: 96, /* ` */
-  CHAR_HASH: 35, /* # */
-  CHAR_HYPHEN_MINUS: 45, /* - */
-  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
-  CHAR_LEFT_CURLY_BRACE: 123, /* { */
-  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
-  CHAR_LINE_FEED: 10, /* \n */
-  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
-  CHAR_PERCENT: 37, /* % */
-  CHAR_PLUS: 43, /* + */
-  CHAR_QUESTION_MARK: 63, /* ? */
-  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
-  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
-  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
-  CHAR_SEMICOLON: 59, /* ; */
-  CHAR_SINGLE_QUOTE: 39, /* ' */
-  CHAR_SPACE: 32, /*   */
-  CHAR_TAB: 9, /* \t */
-  CHAR_UNDERSCORE: 95, /* _ */
-  CHAR_VERTICAL_LINE: 124, /* | */
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+  // Null overwrites config settings, `undefined` does not.
+  if (settings.output === null || settings.output === undefined) {
+    settings.output = undefined;
+  }
 
-  SEP: path$1.sep,
+  if (settings.output && settings.out) {
+    return next(new Error('Cannot accept both `output` and `out`'))
+  }
 
-  /**
-   * Create EXTGLOB_CHARS
-   */
+  // Process phase management.
+  const tree = options.tree || false;
 
-  extglobChars(chars) {
-    return {
-      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
-      '?': { type: 'qmark', open: '(?:', close: ')?' },
-      '+': { type: 'plus', open: '(?:', close: ')+' },
-      '*': { type: 'star', open: '(?:', close: ')*' },
-      '@': { type: 'at', open: '(?:', close: ')' }
-    };
-  },
+  settings.treeIn = options.treeIn;
+  settings.treeOut = options.treeOut;
+  settings.inspect = options.inspect;
 
-  /**
-   * Create GLOB_CHARS
-   */
+  if (settings.treeIn === null || settings.treeIn === undefined) {
+    settings.treeIn = tree;
+  }
 
-  globChars(win32) {
-    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+  if (settings.treeOut === null || settings.treeOut === undefined) {
+    settings.treeOut = tree;
   }
-};
 
-var utils = createCommonjsModule(function (module, exports) {
+  // Configuration.
+  const detectConfig = options.detectConfig;
+  const hasConfig = Boolean(options.rcName || options.packageField);
 
+  if (detectConfig && !hasConfig) {
+    return next(
+      new Error('Missing `rcName` or `packageField` with `detectConfig`')
+    )
+  }
 
-const win32 = process.platform === 'win32';
-const {
-  REGEX_BACKSLASH,
-  REGEX_REMOVE_BACKSLASH,
-  REGEX_SPECIAL_CHARS,
-  REGEX_SPECIAL_CHARS_GLOBAL
-} = constants;
+  settings.detectConfig =
+    detectConfig === null || detectConfig === undefined
+      ? hasConfig
+      : detectConfig;
+  settings.rcName = options.rcName;
+  settings.rcPath = options.rcPath;
+  settings.packageField = options.packageField;
+  settings.settings = options.settings || {};
+  settings.configTransform = options.configTransform;
+  settings.defaultConfig = options.defaultConfig;
 
-exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
-exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
-exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
-exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
-exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+  // Ignore.
+  const detectIgnore = options.detectIgnore;
+  const hasIgnore = Boolean(options.ignoreName);
 
-exports.removeBackslashes = str => {
-  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
-    return match === '\\' ? '' : match;
-  });
-};
+  settings.detectIgnore =
+    detectIgnore === null || detectIgnore === undefined
+      ? hasIgnore
+      : detectIgnore;
+  settings.ignoreName = options.ignoreName;
+  settings.ignorePath = options.ignorePath;
+  settings.ignorePathResolveFrom = options.ignorePathResolveFrom || 'dir';
+  settings.ignorePatterns = options.ignorePatterns || [];
+  settings.silentlyIgnore = Boolean(options.silentlyIgnore);
 
-exports.supportsLookbehinds = () => {
-  const segs = process.version.slice(1).split('.').map(Number);
-  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
-    return true;
+  if (detectIgnore && !hasIgnore) {
+    return next(new Error('Missing `ignoreName` with `detectIgnore`'))
   }
-  return false;
-};
 
-exports.isWindows = options => {
-  if (options && typeof options.windows === 'boolean') {
-    return options.windows;
-  }
-  return win32 === true || path$1.sep === '\\';
-};
+  // Plugins.
+  settings.pluginPrefix = options.pluginPrefix;
+  settings.plugins = options.plugins || [];
 
-exports.escapeLast = (input, char, lastIdx) => {
-  const idx = input.lastIndexOf(char, lastIdx);
-  if (idx === -1) return input;
-  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
-  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-};
+  // Reporting.
+  settings.reporter = options.reporter;
+  settings.reporterOptions = options.reporterOptions;
+  settings.color = options.color || false;
+  settings.silent = options.silent;
+  settings.quiet = options.quiet;
+  settings.frail = options.frail;
 
-exports.removePrefix = (input, state = {}) => {
-  let output = input;
-  if (output.startsWith('./')) {
-    output = output.slice(2);
-    state.prefix = './';
-  }
-  return output;
-};
+  // Process.
+  fileSetPipeline.run({files: options.files || []}, settings, next);
 
-exports.wrapOutput = (input, state = {}, options = {}) => {
-  const prepend = options.contains ? '' : '^';
-  const append = options.contains ? '' : '$';
+  /**
+   * @param {Error|null} error
+   * @param {Context} [context]
+   */
+  function next(error, context) {
+    const stats = statistics((context || {}).files);
+    const failed = Boolean(
+      settings.frail ? stats.fatal || stats.warn : stats.fatal
+    );
 
-  let output = `${prepend}(?:${input})${append}`;
-  if (state.negated === true) {
-    output = `(?:^(?!${output}).*$)`;
+    if (error) {
+      callback(error);
+    } else {
+      callback(null, failed ? 1 : 0, context);
+    }
   }
-  return output;
+}
+
+var textTable = function (rows_, opts) {
+    if (!opts) opts = {};
+    var hsep = opts.hsep === undefined ? '  ' : opts.hsep;
+    var align = opts.align || [];
+    var stringLength = opts.stringLength
+        || function (s) { return String(s).length; }
+    ;
+    
+    var dotsizes = reduce(rows_, function (acc, row) {
+        forEach(row, function (c, ix) {
+            var n = dotindex(c);
+            if (!acc[ix] || n > acc[ix]) acc[ix] = n;
+        });
+        return acc;
+    }, []);
+    
+    var rows = map$2(rows_, function (row) {
+        return map$2(row, function (c_, ix) {
+            var c = String(c_);
+            if (align[ix] === '.') {
+                var index = dotindex(c);
+                var size = dotsizes[ix] + (/\./.test(c) ? 1 : 2)
+                    - (stringLength(c) - index)
+                ;
+                return c + Array(size).join(' ');
+            }
+            else return c;
+        });
+    });
+    
+    var sizes = reduce(rows, function (acc, row) {
+        forEach(row, function (c, ix) {
+            var n = stringLength(c);
+            if (!acc[ix] || n > acc[ix]) acc[ix] = n;
+        });
+        return acc;
+    }, []);
+    
+    return map$2(rows, function (row) {
+        return map$2(row, function (c, ix) {
+            var n = (sizes[ix] - stringLength(c)) || 0;
+            var s = Array(Math.max(n + 1, 1)).join(' ');
+            if (align[ix] === 'r' || align[ix] === '.') {
+                return s + c;
+            }
+            if (align[ix] === 'c') {
+                return Array(Math.ceil(n / 2 + 1)).join(' ')
+                    + c + Array(Math.floor(n / 2 + 1)).join(' ')
+                ;
+            }
+            
+            return c + s;
+        }).join(hsep).replace(/\s+$/, '');
+    }).join('\n');
 };
-});
-var utils_1 = utils.isObject;
-var utils_2 = utils.hasRegexChars;
-var utils_3 = utils.isRegexChar;
-var utils_4 = utils.escapeRegex;
-var utils_5 = utils.toPosixSlashes;
-var utils_6 = utils.removeBackslashes;
-var utils_7 = utils.supportsLookbehinds;
-var utils_8 = utils.isWindows;
-var utils_9 = utils.escapeLast;
-var utils_10 = utils.removePrefix;
-var utils_11 = utils.wrapOutput;
 
-const {
-  CHAR_ASTERISK: CHAR_ASTERISK$1,             /* * */
-  CHAR_AT,                   /* @ */
-  CHAR_BACKWARD_SLASH,       /* \ */
-  CHAR_COMMA: CHAR_COMMA$1,                /* , */
-  CHAR_DOT,                  /* . */
-  CHAR_EXCLAMATION_MARK,     /* ! */
-  CHAR_FORWARD_SLASH,        /* / */
-  CHAR_LEFT_CURLY_BRACE,     /* { */
-  CHAR_LEFT_PARENTHESES,     /* ( */
-  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1,  /* [ */
-  CHAR_PLUS,                 /* + */
-  CHAR_QUESTION_MARK,        /* ? */
-  CHAR_RIGHT_CURLY_BRACE,    /* } */
-  CHAR_RIGHT_PARENTHESES,    /* ) */
-  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1  /* ] */
-} = constants;
+function dotindex (c) {
+    var m = /\.[^.]*$/.exec(c);
+    return m ? m.index + 1 : c.length;
+}
 
-const isPathSeparator = code => {
-  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-};
+function reduce (xs, f, init) {
+    if (xs.reduce) return xs.reduce(f, init);
+    var i = 0;
+    var acc = arguments.length >= 3 ? init : xs[i++];
+    for (; i < xs.length; i++) {
+        f(acc, xs[i], i);
+    }
+    return acc;
+}
 
-const depth = token => {
-  if (token.isPrefix !== true) {
-    token.depth = token.isGlobstar ? Infinity : 1;
-  }
+function forEach (xs, f) {
+    if (xs.forEach) return xs.forEach(f);
+    for (var i = 0; i < xs.length; i++) {
+        f.call(xs, xs[i], i);
+    }
+}
+
+function map$2 (xs, f) {
+    if (xs.map) return xs.map(f);
+    var res = [];
+    for (var i = 0; i < xs.length; i++) {
+        res.push(f.call(xs, xs[i], i));
+    }
+    return res;
+}
+
+var camelcase$1 = {exports: {}};
+
+const preserveCamelCase = (string, locale) => {
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
+
+	for (let i = 0; i < string.length; i++) {
+		const character = string[i];
+
+		if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+			string = string.slice(0, i) + '-' + string.slice(i);
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			i++;
+		} else if (isLastCharUpper && isLastLastCharUpper && /[\p{Ll}]/u.test(character)) {
+			string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower = character.toLocaleLowerCase(locale) === character && character.toLocaleUpperCase(locale) !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = character.toLocaleUpperCase(locale) === character && character.toLocaleLowerCase(locale) !== character;
+		}
+	}
+
+	return string;
 };
 
-/**
- * Quickly scans a glob pattern and returns an object with a handful of
- * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
- * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).
- *
- * ```js
- * const pm = require('picomatch');
- * console.log(pm.scan('foo/bar/*.js'));
- * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {Object} Returns an object with tokens and regex source string.
- * @api public
- */
+const preserveConsecutiveUppercase = input => {
+	return input.replace(/^[\p{Lu}](?![\p{Lu}])/gu, m1 => m1.toLowerCase());
+};
 
-const scan$1 = (input, options) => {
-  const opts = options || {};
+const postProcess = (input, options) => {
+	return input.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toLocaleUpperCase(options.locale))
+		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toLocaleUpperCase(options.locale));
+};
 
-  const length = input.length - 1;
-  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
-  const slashes = [];
-  const tokens = [];
-  const parts = [];
+const camelCase = (input, options) => {
+	if (!(typeof input === 'string' || Array.isArray(input))) {
+		throw new TypeError('Expected the input to be `string | string[]`');
+	}
 
-  let str = input;
-  let index = -1;
-  let start = 0;
-  let lastIndex = 0;
-  let isBrace = false;
-  let isBracket = false;
-  let isGlob = false;
-  let isExtglob = false;
-  let isGlobstar = false;
-  let braceEscaped = false;
-  let backslashes = false;
-  let negated = false;
-  let finished = false;
-  let braces = 0;
-  let prev;
-  let code;
-  let token = { value: '', depth: 0, isGlob: false };
+	options = {
+		pascalCase: false,
+		preserveConsecutiveUppercase: false,
+		...options
+	};
 
-  const eos = () => index >= length;
-  const peek = () => str.charCodeAt(index + 1);
-  const advance = () => {
-    prev = code;
-    return str.charCodeAt(++index);
-  };
+	if (Array.isArray(input)) {
+		input = input.map(x => x.trim())
+			.filter(x => x.length)
+			.join('-');
+	} else {
+		input = input.trim();
+	}
 
-  while (index < length) {
-    code = advance();
-    let next;
+	if (input.length === 0) {
+		return '';
+	}
 
-    if (code === CHAR_BACKWARD_SLASH) {
-      backslashes = token.backslashes = true;
-      code = advance();
+	if (input.length === 1) {
+		return options.pascalCase ? input.toLocaleUpperCase(options.locale) : input.toLocaleLowerCase(options.locale);
+	}
 
-      if (code === CHAR_LEFT_CURLY_BRACE) {
-        braceEscaped = true;
-      }
-      continue;
-    }
+	const hasUpperCase = input !== input.toLocaleLowerCase(options.locale);
 
-    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
-      braces++;
+	if (hasUpperCase) {
+		input = preserveCamelCase(input, options.locale);
+	}
 
-      while (eos() !== true && (code = advance())) {
-        if (code === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
-          continue;
-        }
+	input = input.replace(/^[_.\- ]+/, '');
 
-        if (code === CHAR_LEFT_CURLY_BRACE) {
-          braces++;
-          continue;
-        }
+	if (options.preserveConsecutiveUppercase) {
+		input = preserveConsecutiveUppercase(input);
+	} else {
+		input = input.toLocaleLowerCase();
+	}
 
-        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
+	if (options.pascalCase) {
+		input = input.charAt(0).toLocaleUpperCase(options.locale) + input.slice(1);
+	}
 
-          if (scanToEnd === true) {
-            continue;
-          }
+	return postProcess(input, options);
+};
 
-          break;
-        }
+camelcase$1.exports = camelCase;
+// TODO: Remove this for the next major release
+camelcase$1.exports.default = camelCase;
 
-        if (braceEscaped !== true && code === CHAR_COMMA$1) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
+var camelcase = camelcase$1.exports;
 
-          if (scanToEnd === true) {
-            continue;
-          }
+var minimist = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {}, unknownFn: null };
 
-          break;
-        }
+    if (typeof opts['unknown'] === 'function') {
+        flags.unknownFn = opts['unknown'];
+    }
 
-        if (code === CHAR_RIGHT_CURLY_BRACE) {
-          braces--;
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+          flags.bools[key] = true;
+      });
+    }
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
 
-          if (braces === 0) {
-            braceEscaped = false;
-            isBrace = token.isBrace = true;
-            finished = true;
-            break;
-          }
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
         }
-      }
+     });
 
-      if (scanToEnd === true) {
-        continue;
-      }
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
 
-      break;
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
     }
 
-    if (code === CHAR_FORWARD_SLASH) {
-      slashes.push(index);
-      tokens.push(token);
-      token = { value: '', depth: 0, isGlob: false };
+    function argDefined(key, arg) {
+        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+            flags.strings[key] || flags.bools[key] || aliases[key];
+    }
 
-      if (finished === true) continue;
-      if (prev === CHAR_DOT && index === (start + 1)) {
-        start += 2;
-        continue;
-      }
+    function setArg (key, val, arg) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false) return;
+        }
 
-      lastIndex = index + 1;
-      continue;
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
     }
 
-    if (opts.noext !== true) {
-      const isExtglobChar = code === CHAR_PLUS
-        || code === CHAR_AT
-        || code === CHAR_ASTERISK$1
-        || code === CHAR_QUESTION_MARK
-        || code === CHAR_EXCLAMATION_MARK;
+    function setKey (obj, keys, value) {
+        var o = obj;
+        for (var i = 0; i < keys.length-1; i++) {
+            var key = keys[i];
+            if (key === '__proto__') return;
+            if (o[key] === undefined) o[key] = {};
+            if (o[key] === Object.prototype || o[key] === Number.prototype
+                || o[key] === String.prototype) o[key] = {};
+            if (o[key] === Array.prototype) o[key] = [];
+            o = o[key];
+        }
 
-      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
-        isGlob = token.isGlob = true;
-        isExtglob = token.isExtglob = true;
-        finished = true;
+        var key = keys[keys.length - 1];
+        if (key === '__proto__') return;
+        if (o === Object.prototype || o === Number.prototype
+            || o === String.prototype) o = {};
+        if (o === Array.prototype) o = [];
+        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+            o[key] = value;
+        }
+        else if (Array.isArray(o[key])) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [ o[key], value ];
+        }
+    }
+    
+    function aliasIsBoolean(key) {
+      return aliases[key].some(function (x) {
+          return flags.bools[x];
+      });
+    }
 
-        if (scanToEnd === true) {
-          while (eos() !== true && (code = advance())) {
-            if (code === CHAR_BACKWARD_SLASH) {
-              backslashes = token.backslashes = true;
-              code = advance();
-              continue;
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            var key = m[1];
+            var value = m[2];
+            if (flags.bools[key]) {
+                value = value !== 'false';
             }
-
-            if (code === CHAR_RIGHT_PARENTHESES) {
-              isGlob = token.isGlob = true;
-              finished = true;
-              break;
+            setArg(key, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && !flags.allBools
+            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true', arg);
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split('=')[1], arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i+1], arg);
+                    i++;
+                }
+                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true', arg);
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(
+                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+                );
+            }
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
             }
-          }
-          continue;
         }
-        break;
-      }
     }
-
-    if (code === CHAR_ASTERISK$1) {
-      if (prev === CHAR_ASTERISK$1) isGlobstar = token.isGlobstar = true;
-      isGlob = token.isGlob = true;
-      finished = true;
-
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function(key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function(key) {
+            argv._.push(key);
+        });
     }
 
-    if (code === CHAR_QUESTION_MARK) {
-      isGlob = token.isGlob = true;
-      finished = true;
+    return argv;
+};
 
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
 
-    if (code === CHAR_LEFT_SQUARE_BRACKET$1) {
-      while (eos() !== true && (next = advance())) {
-        if (next === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
-          continue;
-        }
+    var key = keys[keys.length - 1];
+    return key in o;
+}
 
-        if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
-          isBracket = token.isBracket = true;
-          isGlob = token.isGlob = true;
-          finished = true;
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
 
-          if (scanToEnd === true) {
-            continue;
-          }
-          break;
-        }
-      }
-    }
+// This is a generated file. Do not edit.
+var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
+var ID_Start = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/;
+var ID_Continue = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/;
 
-    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
-      negated = token.negated = true;
-      start++;
-      continue;
-    }
+var unicode = {
+	Space_Separator: Space_Separator,
+	ID_Start: ID_Start,
+	ID_Continue: ID_Continue
+};
 
-    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-      isGlob = token.isGlob = true;
+var util = {
+    isSpaceSeparator (c) {
+        return typeof c === 'string' && unicode.Space_Separator.test(c)
+    },
 
-      if (scanToEnd === true) {
-        while (eos() !== true && (code = advance())) {
-          if (code === CHAR_LEFT_PARENTHESES) {
-            backslashes = token.backslashes = true;
-            code = advance();
-            continue;
-          }
+    isIdStartChar (c) {
+        return typeof c === 'string' && (
+            (c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z') ||
+        (c === '$') || (c === '_') ||
+        unicode.ID_Start.test(c)
+        )
+    },
 
-          if (code === CHAR_RIGHT_PARENTHESES) {
-            finished = true;
-            break;
-          }
-        }
-        continue;
-      }
-      break;
-    }
+    isIdContinueChar (c) {
+        return typeof c === 'string' && (
+            (c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z') ||
+        (c >= '0' && c <= '9') ||
+        (c === '$') || (c === '_') ||
+        (c === '\u200C') || (c === '\u200D') ||
+        unicode.ID_Continue.test(c)
+        )
+    },
 
-    if (isGlob === true) {
-      finished = true;
+    isDigit (c) {
+        return typeof c === 'string' && /[0-9]/.test(c)
+    },
 
-      if (scanToEnd === true) {
-        continue;
-      }
+    isHexDigit (c) {
+        return typeof c === 'string' && /[0-9A-Fa-f]/.test(c)
+    },
+};
 
-      break;
-    }
-  }
+let source;
+let parseState;
+let stack;
+let pos;
+let line;
+let column;
+let token;
+let key;
+let root$1;
 
-  if (opts.noext === true) {
-    isExtglob = false;
-    isGlob = false;
-  }
+var parse$1 = function parse (text, reviver) {
+    source = String(text);
+    parseState = 'start';
+    stack = [];
+    pos = 0;
+    line = 1;
+    column = 0;
+    token = undefined;
+    key = undefined;
+    root$1 = undefined;
 
-  let base = str;
-  let prefix = '';
-  let glob = '';
+    do {
+        token = lex();
 
-  if (start > 0) {
-    prefix = str.slice(0, start);
-    str = str.slice(start);
-    lastIndex -= start;
-  }
+        // This code is unreachable.
+        // if (!parseStates[parseState]) {
+        //     throw invalidParseState()
+        // }
 
-  if (base && isGlob === true && lastIndex > 0) {
-    base = str.slice(0, lastIndex);
-    glob = str.slice(lastIndex);
-  } else if (isGlob === true) {
-    base = '';
-    glob = str;
-  } else {
-    base = str;
-  }
+        parseStates[parseState]();
+    } while (token.type !== 'eof')
 
-  if (base && base !== '' && base !== '/' && base !== str) {
-    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
-      base = base.slice(0, -1);
+    if (typeof reviver === 'function') {
+        return internalize({'': root$1}, '', reviver)
     }
-  }
 
-  if (opts.unescape === true) {
-    if (glob) glob = utils.removeBackslashes(glob);
+    return root$1
+};
 
-    if (base && backslashes === true) {
-      base = utils.removeBackslashes(base);
+function internalize (holder, name, reviver) {
+    const value = holder[name];
+    if (value != null && typeof value === 'object') {
+        for (const key in value) {
+            const replacement = internalize(value, key, reviver);
+            if (replacement === undefined) {
+                delete value[key];
+            } else {
+                value[key] = replacement;
+            }
+        }
     }
-  }
 
-  const state = {
-    prefix,
-    input,
-    start,
-    base,
-    glob,
-    isBrace,
-    isBracket,
-    isGlob,
-    isExtglob,
-    isGlobstar,
-    negated
-  };
+    return reviver.call(holder, name, value)
+}
 
-  if (opts.tokens === true) {
-    state.maxDepth = 0;
-    if (!isPathSeparator(code)) {
-      tokens.push(token);
-    }
-    state.tokens = tokens;
-  }
+let lexState;
+let buffer;
+let doubleQuote;
+let sign;
+let c;
 
-  if (opts.parts === true || opts.tokens === true) {
-    let prevIndex;
+function lex () {
+    lexState = 'default';
+    buffer = '';
+    doubleQuote = false;
+    sign = 1;
 
-    for (let idx = 0; idx < slashes.length; idx++) {
-      const n = prevIndex ? prevIndex + 1 : start;
-      const i = slashes[idx];
-      const value = input.slice(n, i);
-      if (opts.tokens) {
-        if (idx === 0 && start !== 0) {
-          tokens[idx].isPrefix = true;
-          tokens[idx].value = prefix;
-        } else {
-          tokens[idx].value = value;
-        }
-        depth(tokens[idx]);
-        state.maxDepth += tokens[idx].depth;
-      }
-      if (idx !== 0 || value !== '') {
-        parts.push(value);
-      }
-      prevIndex = i;
-    }
+    for (;;) {
+        c = peek();
 
-    if (prevIndex && prevIndex + 1 < input.length) {
-      const value = input.slice(prevIndex + 1);
-      parts.push(value);
+        // This code is unreachable.
+        // if (!lexStates[lexState]) {
+        //     throw invalidLexState(lexState)
+        // }
 
-      if (opts.tokens) {
-        tokens[tokens.length - 1].value = value;
-        depth(tokens[tokens.length - 1]);
-        state.maxDepth += tokens[tokens.length - 1].depth;
-      }
+        const token = lexStates[lexState]();
+        if (token) {
+            return token
+        }
     }
+}
 
-    state.slashes = slashes;
-    state.parts = parts;
-  }
-
-  return state;
-};
+function peek () {
+    if (source[pos]) {
+        return String.fromCodePoint(source.codePointAt(pos))
+    }
+}
 
-var scan_1 = scan$1;
+function read () {
+    const c = peek();
 
-/**
- * Constants
- */
+    if (c === '\n') {
+        line++;
+        column = 0;
+    } else if (c) {
+        column += c.length;
+    } else {
+        column++;
+    }
 
-const {
-  MAX_LENGTH,
-  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
-  REGEX_NON_SPECIAL_CHARS,
-  REGEX_SPECIAL_CHARS_BACKREF,
-  REPLACEMENTS
-} = constants;
+    if (c) {
+        pos += c.length;
+    }
 
-/**
- * Helpers
- */
+    return c
+}
 
-const expandRange = (args, options) => {
-  if (typeof options.expandRange === 'function') {
-    return options.expandRange(...args, options);
-  }
+const lexStates = {
+    default () {
+        switch (c) {
+        case '\t':
+        case '\v':
+        case '\f':
+        case ' ':
+        case '\u00A0':
+        case '\uFEFF':
+        case '\n':
+        case '\r':
+        case '\u2028':
+        case '\u2029':
+            read();
+            return
 
-  args.sort();
-  const value = `[${args.join('-')}]`;
+        case '/':
+            read();
+            lexState = 'comment';
+            return
 
-  try {
-    /* eslint-disable-next-line no-new */
-    new RegExp(value);
-  } catch (ex) {
-    return args.map(v => utils.escapeRegex(v)).join('..');
-  }
+        case undefined:
+            read();
+            return newToken('eof')
+        }
 
-  return value;
-};
+        if (util.isSpaceSeparator(c)) {
+            read();
+            return
+        }
 
-/**
- * Create the message for a syntax error
- */
+        // This code is unreachable.
+        // if (!lexStates[parseState]) {
+        //     throw invalidLexState(parseState)
+        // }
 
-const syntaxError = (type, char) => {
-  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-};
+        return lexStates[parseState]()
+    },
 
-/**
- * Parse the given input string.
- * @param {String} input
- * @param {Object} options
- * @return {Object}
- */
+    comment () {
+        switch (c) {
+        case '*':
+            read();
+            lexState = 'multiLineComment';
+            return
 
-const parse$5 = (input, options) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected a string');
-  }
+        case '/':
+            read();
+            lexState = 'singleLineComment';
+            return
+        }
 
-  input = REPLACEMENTS[input] || input;
+        throw invalidChar(read())
+    },
 
-  const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    multiLineComment () {
+        switch (c) {
+        case '*':
+            read();
+            lexState = 'multiLineCommentAsterisk';
+            return
 
-  let len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-  }
+        case undefined:
+            throw invalidChar(read())
+        }
 
-  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
-  const tokens = [bos];
+        read();
+    },
 
-  const capture = opts.capture ? '' : '?:';
-  const win32 = utils.isWindows(options);
+    multiLineCommentAsterisk () {
+        switch (c) {
+        case '*':
+            read();
+            return
 
-  // create constants based on platform, for windows or posix
-  const PLATFORM_CHARS = constants.globChars(win32);
-  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+        case '/':
+            read();
+            lexState = 'default';
+            return
 
-  const {
-    DOT_LITERAL,
-    PLUS_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOT_SLASH,
-    NO_DOTS_SLASH,
-    QMARK,
-    QMARK_NO_DOT,
-    STAR,
-    START_ANCHOR
-  } = PLATFORM_CHARS;
+        case undefined:
+            throw invalidChar(read())
+        }
 
-  const globstar = (opts) => {
-    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-  };
+        read();
+        lexState = 'multiLineComment';
+    },
 
-  const nodot = opts.dot ? '' : NO_DOT;
-  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
-  let star = opts.bash === true ? globstar(opts) : STAR;
+    singleLineComment () {
+        switch (c) {
+        case '\n':
+        case '\r':
+        case '\u2028':
+        case '\u2029':
+            read();
+            lexState = 'default';
+            return
 
-  if (opts.capture) {
-    star = `(${star})`;
-  }
+        case undefined:
+            read();
+            return newToken('eof')
+        }
 
-  // minimatch options support
-  if (typeof opts.noext === 'boolean') {
-    opts.noextglob = opts.noext;
-  }
+        read();
+    },
 
-  const state = {
-    input,
-    index: -1,
-    start: 0,
-    dot: opts.dot === true,
-    consumed: '',
-    output: '',
-    prefix: '',
-    backtrack: false,
-    negated: false,
-    brackets: 0,
-    braces: 0,
-    parens: 0,
-    quotes: 0,
-    globstar: false,
-    tokens
-  };
+    value () {
+        switch (c) {
+        case '{':
+        case '[':
+            return newToken('punctuator', read())
 
-  input = utils.removePrefix(input, state);
-  len = input.length;
+        case 'n':
+            read();
+            literal('ull');
+            return newToken('null', null)
 
-  const extglobs = [];
-  const braces = [];
-  const stack = [];
-  let prev = bos;
-  let value;
+        case 't':
+            read();
+            literal('rue');
+            return newToken('boolean', true)
 
-  /**
-   * Tokenizing helpers
-   */
+        case 'f':
+            read();
+            literal('alse');
+            return newToken('boolean', false)
 
-  const eos = () => state.index === len - 1;
-  const peek = state.peek = (n = 1) => input[state.index + n];
-  const advance = state.advance = () => input[++state.index];
-  const remaining = () => input.slice(state.index + 1);
-  const consume = (value = '', num = 0) => {
-    state.consumed += value;
-    state.index += num;
-  };
-  const append = token => {
-    state.output += token.output != null ? token.output : token.value;
-    consume(token.value);
-  };
+        case '-':
+        case '+':
+            if (read() === '-') {
+                sign = -1;
+            }
 
-  const negate = () => {
-    let count = 1;
+            lexState = 'sign';
+            return
 
-    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
-      advance();
-      state.start++;
-      count++;
-    }
+        case '.':
+            buffer = read();
+            lexState = 'decimalPointLeading';
+            return
 
-    if (count % 2 === 0) {
-      return false;
-    }
+        case '0':
+            buffer = read();
+            lexState = 'zero';
+            return
 
-    state.negated = true;
-    state.start++;
-    return true;
-  };
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            buffer = read();
+            lexState = 'decimalInteger';
+            return
 
-  const increment = type => {
-    state[type]++;
-    stack.push(type);
-  };
+        case 'I':
+            read();
+            literal('nfinity');
+            return newToken('numeric', Infinity)
 
-  const decrement = type => {
-    state[type]--;
-    stack.pop();
-  };
+        case 'N':
+            read();
+            literal('aN');
+            return newToken('numeric', NaN)
 
-  /**
-   * Push tokens onto the tokens array. This helper speeds up
-   * tokenizing by 1) helping us avoid backtracking as much as possible,
-   * and 2) helping us avoid creating extra tokens when consecutive
-   * characters are plain text. This improves performance and simplifies
-   * lookbehinds.
-   */
+        case '"':
+        case "'":
+            doubleQuote = (read() === '"');
+            buffer = '';
+            lexState = 'string';
+            return
+        }
 
-  const push = tok => {
-    if (prev.type === 'globstar') {
-      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
-      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+        throw invalidChar(read())
+    },
 
-      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
-        state.output = state.output.slice(0, -prev.output.length);
-        prev.type = 'star';
-        prev.value = '*';
-        prev.output = star;
-        state.output += prev.output;
-      }
-    }
+    identifierNameStartEscape () {
+        if (c !== 'u') {
+            throw invalidChar(read())
+        }
 
-    if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
-      extglobs[extglobs.length - 1].inner += tok.value;
-    }
+        read();
+        const u = unicodeEscape();
+        switch (u) {
+        case '$':
+        case '_':
+            break
 
-    if (tok.value || tok.output) append(tok);
-    if (prev && prev.type === 'text' && tok.type === 'text') {
-      prev.value += tok.value;
-      prev.output = (prev.output || '') + tok.value;
-      return;
-    }
+        default:
+            if (!util.isIdStartChar(u)) {
+                throw invalidIdentifier()
+            }
 
-    tok.prev = prev;
-    tokens.push(tok);
-    prev = tok;
-  };
+            break
+        }
 
-  const extglobOpen = (type, value) => {
-    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+        buffer += u;
+        lexState = 'identifierName';
+    },
 
-    token.prev = prev;
-    token.parens = state.parens;
-    token.output = state.output;
-    const output = (opts.capture ? '(' : '') + token.open;
+    identifierName () {
+        switch (c) {
+        case '$':
+        case '_':
+        case '\u200C':
+        case '\u200D':
+            buffer += read();
+            return
 
-    increment('parens');
-    push({ type, value, output: state.output ? '' : ONE_CHAR });
-    push({ type: 'paren', extglob: true, value: advance(), output });
-    extglobs.push(token);
-  };
+        case '\\':
+            read();
+            lexState = 'identifierNameEscape';
+            return
+        }
 
-  const extglobClose = token => {
-    let output = token.close + (opts.capture ? ')' : '');
+        if (util.isIdContinueChar(c)) {
+            buffer += read();
+            return
+        }
 
-    if (token.type === 'negate') {
-      let extglobStar = star;
+        return newToken('identifier', buffer)
+    },
 
-      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
-        extglobStar = globstar(opts);
-      }
+    identifierNameEscape () {
+        if (c !== 'u') {
+            throw invalidChar(read())
+        }
 
-      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
-        output = token.close = `)$))${extglobStar}`;
-      }
+        read();
+        const u = unicodeEscape();
+        switch (u) {
+        case '$':
+        case '_':
+        case '\u200C':
+        case '\u200D':
+            break
 
-      if (token.prev.type === 'bos' && eos()) {
-        state.negatedExtglob = true;
-      }
-    }
+        default:
+            if (!util.isIdContinueChar(u)) {
+                throw invalidIdentifier()
+            }
 
-    push({ type: 'paren', extglob: true, value, output });
-    decrement('parens');
-  };
+            break
+        }
 
-  /**
-   * Fast paths
-   */
+        buffer += u;
+        lexState = 'identifierName';
+    },
 
-  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-    let backslashes = false;
+    sign () {
+        switch (c) {
+        case '.':
+            buffer = read();
+            lexState = 'decimalPointLeading';
+            return
 
-    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
-      if (first === '\\') {
-        backslashes = true;
-        return m;
-      }
+        case '0':
+            buffer = read();
+            lexState = 'zero';
+            return
 
-      if (first === '?') {
-        if (esc) {
-          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
-        }
-        if (index === 0) {
-          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
-        }
-        return QMARK.repeat(chars.length);
-      }
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            buffer = read();
+            lexState = 'decimalInteger';
+            return
 
-      if (first === '.') {
-        return DOT_LITERAL.repeat(chars.length);
-      }
+        case 'I':
+            read();
+            literal('nfinity');
+            return newToken('numeric', sign * Infinity)
 
-      if (first === '*') {
-        if (esc) {
-          return esc + first + (rest ? star : '');
+        case 'N':
+            read();
+            literal('aN');
+            return newToken('numeric', NaN)
         }
-        return star;
-      }
-      return esc ? m : `\\${m}`;
-    });
-
-    if (backslashes === true) {
-      if (opts.unescape === true) {
-        output = output.replace(/\\/g, '');
-      } else {
-        output = output.replace(/\\+/g, m => {
-          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
-        });
-      }
-    }
 
-    if (output === input && opts.contains === true) {
-      state.output = input;
-      return state;
-    }
+        throw invalidChar(read())
+    },
 
-    state.output = utils.wrapOutput(output, state, options);
-    return state;
-  }
+    zero () {
+        switch (c) {
+        case '.':
+            buffer += read();
+            lexState = 'decimalPoint';
+            return
 
-  /**
-   * Tokenize input until we reach end-of-string
-   */
+        case 'e':
+        case 'E':
+            buffer += read();
+            lexState = 'decimalExponent';
+            return
 
-  while (!eos()) {
-    value = advance();
+        case 'x':
+        case 'X':
+            buffer += read();
+            lexState = 'hexadecimal';
+            return
+        }
 
-    if (value === '\u0000') {
-      continue;
-    }
+        return newToken('numeric', sign * 0)
+    },
 
-    /**
-     * Escaped characters
-     */
+    decimalInteger () {
+        switch (c) {
+        case '.':
+            buffer += read();
+            lexState = 'decimalPoint';
+            return
 
-    if (value === '\\') {
-      const next = peek();
+        case 'e':
+        case 'E':
+            buffer += read();
+            lexState = 'decimalExponent';
+            return
+        }
 
-      if (next === '/' && opts.bash !== true) {
-        continue;
-      }
+        if (util.isDigit(c)) {
+            buffer += read();
+            return
+        }
 
-      if (next === '.' || next === ';') {
-        continue;
-      }
+        return newToken('numeric', sign * Number(buffer))
+    },
 
-      if (!next) {
-        value += '\\';
-        push({ type: 'text', value });
-        continue;
-      }
+    decimalPointLeading () {
+        if (util.isDigit(c)) {
+            buffer += read();
+            lexState = 'decimalFraction';
+            return
+        }
 
-      // collapse slashes to reduce potential for exploits
-      const match = /^\\+/.exec(remaining());
-      let slashes = 0;
+        throw invalidChar(read())
+    },
 
-      if (match && match[0].length > 2) {
-        slashes = match[0].length;
-        state.index += slashes;
-        if (slashes % 2 !== 0) {
-          value += '\\';
+    decimalPoint () {
+        switch (c) {
+        case 'e':
+        case 'E':
+            buffer += read();
+            lexState = 'decimalExponent';
+            return
         }
-      }
 
-      if (opts.unescape === true) {
-        value = advance() || '';
-      } else {
-        value += advance() || '';
-      }
+        if (util.isDigit(c)) {
+            buffer += read();
+            lexState = 'decimalFraction';
+            return
+        }
 
-      if (state.brackets === 0) {
-        push({ type: 'text', value });
-        continue;
-      }
-    }
+        return newToken('numeric', sign * Number(buffer))
+    },
 
-    /**
-     * If we're inside a regex character class, continue
-     * until we reach the closing bracket.
-     */
+    decimalFraction () {
+        switch (c) {
+        case 'e':
+        case 'E':
+            buffer += read();
+            lexState = 'decimalExponent';
+            return
+        }
 
-    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
-      if (opts.posix !== false && value === ':') {
-        const inner = prev.value.slice(1);
-        if (inner.includes('[')) {
-          prev.posix = true;
+        if (util.isDigit(c)) {
+            buffer += read();
+            return
+        }
 
-          if (inner.includes(':')) {
-            const idx = prev.value.lastIndexOf('[');
-            const pre = prev.value.slice(0, idx);
-            const rest = prev.value.slice(idx + 2);
-            const posix = POSIX_REGEX_SOURCE$1[rest];
-            if (posix) {
-              prev.value = pre + posix;
-              state.backtrack = true;
-              advance();
+        return newToken('numeric', sign * Number(buffer))
+    },
 
-              if (!bos.output && tokens.indexOf(prev) === 1) {
-                bos.output = ONE_CHAR;
-              }
-              continue;
-            }
-          }
+    decimalExponent () {
+        switch (c) {
+        case '+':
+        case '-':
+            buffer += read();
+            lexState = 'decimalExponentSign';
+            return
         }
-      }
-
-      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
-        value = `\\${value}`;
-      }
 
-      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
-        value = `\\${value}`;
-      }
+        if (util.isDigit(c)) {
+            buffer += read();
+            lexState = 'decimalExponentInteger';
+            return
+        }
 
-      if (opts.posix === true && value === '!' && prev.value === '[') {
-        value = '^';
-      }
+        throw invalidChar(read())
+    },
 
-      prev.value += value;
-      append({ value });
-      continue;
-    }
+    decimalExponentSign () {
+        if (util.isDigit(c)) {
+            buffer += read();
+            lexState = 'decimalExponentInteger';
+            return
+        }
 
-    /**
-     * If we're inside a quoted string, continue
-     * until we reach the closing double quote.
-     */
+        throw invalidChar(read())
+    },
 
-    if (state.quotes === 1 && value !== '"') {
-      value = utils.escapeRegex(value);
-      prev.value += value;
-      append({ value });
-      continue;
-    }
+    decimalExponentInteger () {
+        if (util.isDigit(c)) {
+            buffer += read();
+            return
+        }
 
-    /**
-     * Double quotes
-     */
+        return newToken('numeric', sign * Number(buffer))
+    },
 
-    if (value === '"') {
-      state.quotes = state.quotes === 1 ? 0 : 1;
-      if (opts.keepQuotes === true) {
-        push({ type: 'text', value });
-      }
-      continue;
-    }
+    hexadecimal () {
+        if (util.isHexDigit(c)) {
+            buffer += read();
+            lexState = 'hexadecimalInteger';
+            return
+        }
 
-    /**
-     * Parentheses
-     */
+        throw invalidChar(read())
+    },
 
-    if (value === '(') {
-      increment('parens');
-      push({ type: 'paren', value });
-      continue;
-    }
+    hexadecimalInteger () {
+        if (util.isHexDigit(c)) {
+            buffer += read();
+            return
+        }
 
-    if (value === ')') {
-      if (state.parens === 0 && opts.strictBrackets === true) {
-        throw new SyntaxError(syntaxError('opening', '('));
-      }
+        return newToken('numeric', sign * Number(buffer))
+    },
 
-      const extglob = extglobs[extglobs.length - 1];
-      if (extglob && state.parens === extglob.parens + 1) {
-        extglobClose(extglobs.pop());
-        continue;
-      }
+    string () {
+        switch (c) {
+        case '\\':
+            read();
+            buffer += escape();
+            return
 
-      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
-      decrement('parens');
-      continue;
-    }
+        case '"':
+            if (doubleQuote) {
+                read();
+                return newToken('string', buffer)
+            }
 
-    /**
-     * Square brackets
-     */
+            buffer += read();
+            return
 
-    if (value === '[') {
-      if (opts.nobracket === true || !remaining().includes(']')) {
-        if (opts.nobracket !== true && opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError('closing', ']'));
-        }
+        case "'":
+            if (!doubleQuote) {
+                read();
+                return newToken('string', buffer)
+            }
 
-        value = `\\${value}`;
-      } else {
-        increment('brackets');
-      }
+            buffer += read();
+            return
 
-      push({ type: 'bracket', value });
-      continue;
-    }
+        case '\n':
+        case '\r':
+            throw invalidChar(read())
 
-    if (value === ']') {
-      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
-        push({ type: 'text', value, output: `\\${value}` });
-        continue;
-      }
+        case '\u2028':
+        case '\u2029':
+            separatorChar(c);
+            break
 
-      if (state.brackets === 0) {
-        if (opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError('opening', '['));
+        case undefined:
+            throw invalidChar(read())
         }
 
-        push({ type: 'text', value, output: `\\${value}` });
-        continue;
-      }
-
-      decrement('brackets');
+        buffer += read();
+    },
 
-      const prevValue = prev.value.slice(1);
-      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
-        value = `/${value}`;
-      }
+    start () {
+        switch (c) {
+        case '{':
+        case '[':
+            return newToken('punctuator', read())
 
-      prev.value += value;
-      append({ value });
+        // This code is unreachable since the default lexState handles eof.
+        // case undefined:
+        //     return newToken('eof')
+        }
 
-      // when literal brackets are explicitly disabled
-      // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
-        continue;
-      }
+        lexState = 'value';
+    },
 
-      const escaped = utils.escapeRegex(prev.value);
-      state.output = state.output.slice(0, -prev.value.length);
+    beforePropertyName () {
+        switch (c) {
+        case '$':
+        case '_':
+            buffer = read();
+            lexState = 'identifierName';
+            return
 
-      // when literal brackets are explicitly enabled
-      // assume we should escape the brackets to match literal characters
-      if (opts.literalBrackets === true) {
-        state.output += escaped;
-        prev.value = escaped;
-        continue;
-      }
+        case '\\':
+            read();
+            lexState = 'identifierNameStartEscape';
+            return
 
-      // when the user specifies nothing, try to match both
-      prev.value = `(${capture}${escaped}|${prev.value})`;
-      state.output += prev.value;
-      continue;
-    }
+        case '}':
+            return newToken('punctuator', read())
 
-    /**
-     * Braces
-     */
+        case '"':
+        case "'":
+            doubleQuote = (read() === '"');
+            lexState = 'string';
+            return
+        }
 
-    if (value === '{' && opts.nobrace !== true) {
-      increment('braces');
+        if (util.isIdStartChar(c)) {
+            buffer += read();
+            lexState = 'identifierName';
+            return
+        }
 
-      const open = {
-        type: 'brace',
-        value,
-        output: '(',
-        outputIndex: state.output.length,
-        tokensIndex: state.tokens.length
-      };
+        throw invalidChar(read())
+    },
 
-      braces.push(open);
-      push(open);
-      continue;
-    }
+    afterPropertyName () {
+        if (c === ':') {
+            return newToken('punctuator', read())
+        }
 
-    if (value === '}') {
-      const brace = braces[braces.length - 1];
+        throw invalidChar(read())
+    },
 
-      if (opts.nobrace === true || !brace) {
-        push({ type: 'text', value, output: value });
-        continue;
-      }
+    beforePropertyValue () {
+        lexState = 'value';
+    },
 
-      let output = ')';
+    afterPropertyValue () {
+        switch (c) {
+        case ',':
+        case '}':
+            return newToken('punctuator', read())
+        }
 
-      if (brace.dots === true) {
-        const arr = tokens.slice();
-        const range = [];
+        throw invalidChar(read())
+    },
 
-        for (let i = arr.length - 1; i >= 0; i--) {
-          tokens.pop();
-          if (arr[i].type === 'brace') {
-            break;
-          }
-          if (arr[i].type !== 'dots') {
-            range.unshift(arr[i].value);
-          }
+    beforeArrayValue () {
+        if (c === ']') {
+            return newToken('punctuator', read())
         }
 
-        output = expandRange(range, opts);
-        state.backtrack = true;
-      }
+        lexState = 'value';
+    },
 
-      if (brace.comma !== true && brace.dots !== true) {
-        const out = state.output.slice(0, brace.outputIndex);
-        const toks = state.tokens.slice(brace.tokensIndex);
-        brace.value = brace.output = '\\{';
-        value = output = '\\}';
-        state.output = out;
-        for (const t of toks) {
-          state.output += (t.output || t.value);
+    afterArrayValue () {
+        switch (c) {
+        case ',':
+        case ']':
+            return newToken('punctuator', read())
         }
-      }
 
-      push({ type: 'brace', value, output });
-      decrement('braces');
-      braces.pop();
-      continue;
-    }
+        throw invalidChar(read())
+    },
 
-    /**
-     * Pipes
-     */
+    end () {
+        // This code is unreachable since it's handled by the default lexState.
+        // if (c === undefined) {
+        //     read()
+        //     return newToken('eof')
+        // }
 
-    if (value === '|') {
-      if (extglobs.length > 0) {
-        extglobs[extglobs.length - 1].conditions++;
-      }
-      push({ type: 'text', value });
-      continue;
-    }
+        throw invalidChar(read())
+    },
+};
 
-    /**
-     * Commas
-     */
+function newToken (type, value) {
+    return {
+        type,
+        value,
+        line,
+        column,
+    }
+}
 
-    if (value === ',') {
-      let output = value;
+function literal (s) {
+    for (const c of s) {
+        const p = peek();
 
-      const brace = braces[braces.length - 1];
-      if (brace && stack[stack.length - 1] === 'braces') {
-        brace.comma = true;
-        output = '|';
-      }
+        if (p !== c) {
+            throw invalidChar(read())
+        }
 
-      push({ type: 'comma', value, output });
-      continue;
+        read();
     }
+}
 
-    /**
-     * Slashes
-     */
+function escape () {
+    const c = peek();
+    switch (c) {
+    case 'b':
+        read();
+        return '\b'
 
-    if (value === '/') {
-      // if the beginning of the glob is "./", advance the start
-      // to the current index, and don't add the "./" characters
-      // to the state. This greatly simplifies lookbehinds when
-      // checking for BOS characters like "!" and "." (not "./")
-      if (prev.type === 'dot' && state.index === state.start + 1) {
-        state.start = state.index + 1;
-        state.consumed = '';
-        state.output = '';
-        tokens.pop();
-        prev = bos; // reset "prev" to the first token
-        continue;
-      }
+    case 'f':
+        read();
+        return '\f'
 
-      push({ type: 'slash', value, output: SLASH_LITERAL });
-      continue;
-    }
+    case 'n':
+        read();
+        return '\n'
 
-    /**
-     * Dots
-     */
+    case 'r':
+        read();
+        return '\r'
 
-    if (value === '.') {
-      if (state.braces > 0 && prev.type === 'dot') {
-        if (prev.value === '.') prev.output = DOT_LITERAL;
-        const brace = braces[braces.length - 1];
-        prev.type = 'dots';
-        prev.output += value;
-        prev.value += value;
-        brace.dots = true;
-        continue;
-      }
+    case 't':
+        read();
+        return '\t'
 
-      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
-        push({ type: 'text', value, output: DOT_LITERAL });
-        continue;
-      }
+    case 'v':
+        read();
+        return '\v'
+
+    case '0':
+        read();
+        if (util.isDigit(peek())) {
+            throw invalidChar(read())
+        }
 
-      push({ type: 'dot', value, output: DOT_LITERAL });
-      continue;
-    }
+        return '\0'
 
-    /**
-     * Question marks
-     */
+    case 'x':
+        read();
+        return hexEscape()
 
-    if (value === '?') {
-      const isGroup = prev && prev.value === '(';
-      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        extglobOpen('qmark', value);
-        continue;
-      }
+    case 'u':
+        read();
+        return unicodeEscape()
 
-      if (prev && prev.type === 'paren') {
-        const next = peek();
-        let output = value;
+    case '\n':
+    case '\u2028':
+    case '\u2029':
+        read();
+        return ''
 
-        if (next === '<' && !utils.supportsLookbehinds()) {
-          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+    case '\r':
+        read();
+        if (peek() === '\n') {
+            read();
         }
 
-        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
-          output = `\\${value}`;
-        }
+        return ''
 
-        push({ type: 'text', value, output });
-        continue;
-      }
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+        throw invalidChar(read())
 
-      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
-        push({ type: 'qmark', value, output: QMARK_NO_DOT });
-        continue;
-      }
+    case undefined:
+        throw invalidChar(read())
+    }
 
-      push({ type: 'qmark', value, output: QMARK });
-      continue;
+    return read()
+}
+
+function hexEscape () {
+    let buffer = '';
+    let c = peek();
+
+    if (!util.isHexDigit(c)) {
+        throw invalidChar(read())
     }
 
-    /**
-     * Exclamation
-     */
+    buffer += read();
 
-    if (value === '!') {
-      if (opts.noextglob !== true && peek() === '(') {
-        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
-          extglobOpen('negate', value);
-          continue;
+    c = peek();
+    if (!util.isHexDigit(c)) {
+        throw invalidChar(read())
+    }
+
+    buffer += read();
+
+    return String.fromCodePoint(parseInt(buffer, 16))
+}
+
+function unicodeEscape () {
+    let buffer = '';
+    let count = 4;
+
+    while (count-- > 0) {
+        const c = peek();
+        if (!util.isHexDigit(c)) {
+            throw invalidChar(read())
         }
-      }
 
-      if (opts.nonegate !== true && state.index === 0) {
-        negate();
-        continue;
-      }
+        buffer += read();
     }
 
-    /**
-     * Plus
-     */
+    return String.fromCodePoint(parseInt(buffer, 16))
+}
 
-    if (value === '+') {
-      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        extglobOpen('plus', value);
-        continue;
-      }
+const parseStates = {
+    start () {
+        if (token.type === 'eof') {
+            throw invalidEOF()
+        }
 
-      if ((prev && prev.value === '(') || opts.regex === false) {
-        push({ type: 'plus', value, output: PLUS_LITERAL });
-        continue;
-      }
+        push$1();
+    },
 
-      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
-        push({ type: 'plus', value });
-        continue;
-      }
+    beforePropertyName () {
+        switch (token.type) {
+        case 'identifier':
+        case 'string':
+            key = token.value;
+            parseState = 'afterPropertyName';
+            return
 
-      push({ type: 'plus', value: PLUS_LITERAL });
-      continue;
-    }
+        case 'punctuator':
+            // This code is unreachable since it's handled by the lexState.
+            // if (token.value !== '}') {
+            //     throw invalidToken()
+            // }
 
-    /**
-     * Plain text
-     */
+            pop();
+            return
 
-    if (value === '@') {
-      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        push({ type: 'at', extglob: true, value, output: '' });
-        continue;
-      }
+        case 'eof':
+            throw invalidEOF()
+        }
 
-      push({ type: 'text', value });
-      continue;
-    }
+        // This code is unreachable since it's handled by the lexState.
+        // throw invalidToken()
+    },
 
-    /**
-     * Plain text
-     */
+    afterPropertyName () {
+        // This code is unreachable since it's handled by the lexState.
+        // if (token.type !== 'punctuator' || token.value !== ':') {
+        //     throw invalidToken()
+        // }
 
-    if (value !== '*') {
-      if (value === '$' || value === '^') {
-        value = `\\${value}`;
-      }
+        if (token.type === 'eof') {
+            throw invalidEOF()
+        }
 
-      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
-      if (match) {
-        value += match[0];
-        state.index += match[0].length;
-      }
+        parseState = 'beforePropertyValue';
+    },
 
-      push({ type: 'text', value });
-      continue;
-    }
+    beforePropertyValue () {
+        if (token.type === 'eof') {
+            throw invalidEOF()
+        }
 
-    /**
-     * Stars
-     */
+        push$1();
+    },
 
-    if (prev && (prev.type === 'globstar' || prev.star === true)) {
-      prev.type = 'star';
-      prev.star = true;
-      prev.value += value;
-      prev.output = star;
-      state.backtrack = true;
-      state.globstar = true;
-      consume(value);
-      continue;
-    }
+    beforeArrayValue () {
+        if (token.type === 'eof') {
+            throw invalidEOF()
+        }
 
-    let rest = remaining();
-    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
-      extglobOpen('star', value);
-      continue;
-    }
+        if (token.type === 'punctuator' && token.value === ']') {
+            pop();
+            return
+        }
 
-    if (prev.type === 'star') {
-      if (opts.noglobstar === true) {
-        consume(value);
-        continue;
-      }
+        push$1();
+    },
 
-      const prior = prev.prev;
-      const before = prior.prev;
-      const isStart = prior.type === 'slash' || prior.type === 'bos';
-      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+    afterPropertyValue () {
+        // This code is unreachable since it's handled by the lexState.
+        // if (token.type !== 'punctuator') {
+        //     throw invalidToken()
+        // }
 
-      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
-        push({ type: 'star', value, output: '' });
-        continue;
-      }
+        if (token.type === 'eof') {
+            throw invalidEOF()
+        }
 
-      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
-      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
-      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
-        push({ type: 'star', value, output: '' });
-        continue;
-      }
+        switch (token.value) {
+        case ',':
+            parseState = 'beforePropertyName';
+            return
 
-      // strip consecutive `/**/`
-      while (rest.slice(0, 3) === '/**') {
-        const after = input[state.index + 4];
-        if (after && after !== '/') {
-          break;
+        case '}':
+            pop();
         }
-        rest = rest.slice(3);
-        consume('/**', 3);
-      }
 
-      if (prior.type === 'bos' && eos()) {
-        prev.type = 'globstar';
-        prev.value += value;
-        prev.output = globstar(opts);
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value);
-        continue;
-      }
+        // This code is unreachable since it's handled by the lexState.
+        // throw invalidToken()
+    },
 
-      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
+    afterArrayValue () {
+        // This code is unreachable since it's handled by the lexState.
+        // if (token.type !== 'punctuator') {
+        //     throw invalidToken()
+        // }
 
-        prev.type = 'globstar';
-        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
-        prev.value += value;
-        state.globstar = true;
-        state.output += prior.output + prev.output;
-        consume(value);
-        continue;
-      }
+        if (token.type === 'eof') {
+            throw invalidEOF()
+        }
 
-      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
-        const end = rest[1] !== void 0 ? '|$' : '';
+        switch (token.value) {
+        case ',':
+            parseState = 'beforeArrayValue';
+            return
 
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
+        case ']':
+            pop();
+        }
 
-        prev.type = 'globstar';
-        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
-        prev.value += value;
+        // This code is unreachable since it's handled by the lexState.
+        // throw invalidToken()
+    },
 
-        state.output += prior.output + prev.output;
-        state.globstar = true;
+    end () {
+        // This code is unreachable since it's handled by the lexState.
+        // if (token.type !== 'eof') {
+        //     throw invalidToken()
+        // }
+    },
+};
 
-        consume(value + advance());
+function push$1 () {
+    let value;
 
-        push({ type: 'slash', value: '/', output: '' });
-        continue;
-      }
+    switch (token.type) {
+    case 'punctuator':
+        switch (token.value) {
+        case '{':
+            value = {};
+            break
 
-      if (prior.type === 'bos' && rest[0] === '/') {
-        prev.type = 'globstar';
-        prev.value += value;
-        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value + advance());
-        push({ type: 'slash', value: '/', output: '' });
-        continue;
-      }
+        case '[':
+            value = [];
+            break
+        }
 
-      // remove single star from output
-      state.output = state.output.slice(0, -prev.output.length);
+        break
 
-      // reset previous token to globstar
-      prev.type = 'globstar';
-      prev.output = globstar(opts);
-      prev.value += value;
+    case 'null':
+    case 'boolean':
+    case 'numeric':
+    case 'string':
+        value = token.value;
+        break
 
-      // reset output with globstar
-      state.output += prev.output;
-      state.globstar = true;
-      consume(value);
-      continue;
+    // This code is unreachable.
+    // default:
+    //     throw invalidToken()
     }
 
-    const token = { type: 'star', value, output: star };
-
-    if (opts.bash === true) {
-      token.output = '.*?';
-      if (prev.type === 'bos' || prev.type === 'slash') {
-        token.output = nodot + token.output;
-      }
-      push(token);
-      continue;
+    if (root$1 === undefined) {
+        root$1 = value;
+    } else {
+        const parent = stack[stack.length - 1];
+        if (Array.isArray(parent)) {
+            parent.push(value);
+        } else {
+            parent[key] = value;
+        }
     }
 
-    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
-      token.output = value;
-      push(token);
-      continue;
+    if (value !== null && typeof value === 'object') {
+        stack.push(value);
+
+        if (Array.isArray(value)) {
+            parseState = 'beforeArrayValue';
+        } else {
+            parseState = 'beforePropertyName';
+        }
+    } else {
+        const current = stack[stack.length - 1];
+        if (current == null) {
+            parseState = 'end';
+        } else if (Array.isArray(current)) {
+            parseState = 'afterArrayValue';
+        } else {
+            parseState = 'afterPropertyValue';
+        }
     }
+}
 
-    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
-      if (prev.type === 'dot') {
-        state.output += NO_DOT_SLASH;
-        prev.output += NO_DOT_SLASH;
+function pop () {
+    stack.pop();
 
-      } else if (opts.dot === true) {
-        state.output += NO_DOTS_SLASH;
-        prev.output += NO_DOTS_SLASH;
+    const current = stack[stack.length - 1];
+    if (current == null) {
+        parseState = 'end';
+    } else if (Array.isArray(current)) {
+        parseState = 'afterArrayValue';
+    } else {
+        parseState = 'afterPropertyValue';
+    }
+}
 
-      } else {
-        state.output += nodot;
-        prev.output += nodot;
-      }
+// This code is unreachable.
+// function invalidParseState () {
+//     return new Error(`JSON5: invalid parse state '${parseState}'`)
+// }
 
-      if (peek() !== '*') {
-        state.output += ONE_CHAR;
-        prev.output += ONE_CHAR;
-      }
+// This code is unreachable.
+// function invalidLexState (state) {
+//     return new Error(`JSON5: invalid lex state '${state}'`)
+// }
+
+function invalidChar (c) {
+    if (c === undefined) {
+        return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
     }
 
-    push(token);
-  }
+    return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
+}
 
-  while (state.brackets > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils.escapeLast(state.output, '[');
-    decrement('brackets');
-  }
+function invalidEOF () {
+    return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+}
 
-  while (state.parens > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
-    state.output = utils.escapeLast(state.output, '(');
-    decrement('parens');
-  }
+// This code is unreachable.
+// function invalidToken () {
+//     if (token.type === 'eof') {
+//         return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+//     }
 
-  while (state.braces > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
-    state.output = utils.escapeLast(state.output, '{');
-    decrement('braces');
-  }
+//     const c = String.fromCodePoint(token.value.codePointAt(0))
+//     return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
+// }
 
-  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
-    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
-  }
+function invalidIdentifier () {
+    column -= 5;
+    return syntaxError(`JSON5: invalid identifier character at ${line}:${column}`)
+}
 
-  // rebuild the output if we had to backtrack at any point
-  if (state.backtrack === true) {
-    state.output = '';
+function separatorChar (c) {
+    console.warn(`JSON5: '${formatChar(c)}' in strings is not valid ECMAScript; consider escaping`);
+}
 
-    for (const token of state.tokens) {
-      state.output += token.output != null ? token.output : token.value;
+function formatChar (c) {
+    const replacements = {
+        "'": "\\'",
+        '"': '\\"',
+        '\\': '\\\\',
+        '\b': '\\b',
+        '\f': '\\f',
+        '\n': '\\n',
+        '\r': '\\r',
+        '\t': '\\t',
+        '\v': '\\v',
+        '\0': '\\0',
+        '\u2028': '\\u2028',
+        '\u2029': '\\u2029',
+    };
 
-      if (token.suffix) {
-        state.output += token.suffix;
-      }
+    if (replacements[c]) {
+        return replacements[c]
     }
-  }
 
-  return state;
-};
+    if (c < ' ') {
+        const hexString = c.charCodeAt(0).toString(16);
+        return '\\x' + ('00' + hexString).substring(hexString.length)
+    }
 
-/**
- * Fast paths for creating regular expressions for common glob patterns.
- * This can significantly speed up processing and has very little downside
- * impact when none of the fast paths match.
- */
+    return c
+}
 
-parse$5.fastpaths = (input, options) => {
-  const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-  const len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-  }
+function syntaxError (message) {
+    const err = new SyntaxError(message);
+    err.lineNumber = line;
+    err.columnNumber = column;
+    return err
+}
+
+var stringify = function stringify (value, replacer, space) {
+    const stack = [];
+    let indent = '';
+    let propertyList;
+    let replacerFunc;
+    let gap = '';
+    let quote;
+
+    if (
+        replacer != null &&
+        typeof replacer === 'object' &&
+        !Array.isArray(replacer)
+    ) {
+        space = replacer.space;
+        quote = replacer.quote;
+        replacer = replacer.replacer;
+    }
 
-  input = REPLACEMENTS[input] || input;
-  const win32 = utils.isWindows(options);
+    if (typeof replacer === 'function') {
+        replacerFunc = replacer;
+    } else if (Array.isArray(replacer)) {
+        propertyList = [];
+        for (const v of replacer) {
+            let item;
 
-  // create constants based on platform, for windows or posix
-  const {
-    DOT_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOTS,
-    NO_DOTS_SLASH,
-    STAR,
-    START_ANCHOR
-  } = constants.globChars(win32);
+            if (typeof v === 'string') {
+                item = v;
+            } else if (
+                typeof v === 'number' ||
+                v instanceof String ||
+                v instanceof Number
+            ) {
+                item = String(v);
+            }
 
-  const nodot = opts.dot ? NO_DOTS : NO_DOT;
-  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
-  const capture = opts.capture ? '' : '?:';
-  const state = { negated: false, prefix: '' };
-  let star = opts.bash === true ? '.*?' : STAR;
+            if (item !== undefined && propertyList.indexOf(item) < 0) {
+                propertyList.push(item);
+            }
+        }
+    }
 
-  if (opts.capture) {
-    star = `(${star})`;
-  }
+    if (space instanceof Number) {
+        space = Number(space);
+    } else if (space instanceof String) {
+        space = String(space);
+    }
 
-  const globstar = (opts) => {
-    if (opts.noglobstar === true) return star;
-    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-  };
+    if (typeof space === 'number') {
+        if (space > 0) {
+            space = Math.min(10, Math.floor(space));
+            gap = '          '.substr(0, space);
+        }
+    } else if (typeof space === 'string') {
+        gap = space.substr(0, 10);
+    }
 
-  const create = str => {
-    switch (str) {
-      case '*':
-        return `${nodot}${ONE_CHAR}${star}`;
+    return serializeProperty('', {'': value})
 
-      case '.*':
-        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+    function serializeProperty (key, holder) {
+        let value = holder[key];
+        if (value != null) {
+            if (typeof value.toJSON5 === 'function') {
+                value = value.toJSON5(key);
+            } else if (typeof value.toJSON === 'function') {
+                value = value.toJSON(key);
+            }
+        }
 
-      case '*.*':
-        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+        if (replacerFunc) {
+            value = replacerFunc.call(holder, key, value);
+        }
 
-      case '*/*':
-        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+        if (value instanceof Number) {
+            value = Number(value);
+        } else if (value instanceof String) {
+            value = String(value);
+        } else if (value instanceof Boolean) {
+            value = value.valueOf();
+        }
 
-      case '**':
-        return nodot + globstar(opts);
+        switch (value) {
+        case null: return 'null'
+        case true: return 'true'
+        case false: return 'false'
+        }
 
-      case '**/*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+        if (typeof value === 'string') {
+            return quoteString(value)
+        }
 
-      case '**/*.*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+        if (typeof value === 'number') {
+            return String(value)
+        }
 
-      case '**/.*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+        if (typeof value === 'object') {
+            return Array.isArray(value) ? serializeArray(value) : serializeObject(value)
+        }
 
-      default: {
-        const match = /^(.*?)\.(\w+)$/.exec(str);
-        if (!match) return;
+        return undefined
+    }
 
-        const source = create(match[1]);
-        if (!source) return;
+    function quoteString (value) {
+        const quotes = {
+            "'": 0.1,
+            '"': 0.2,
+        };
 
-        return source + DOT_LITERAL + match[2];
-      }
-    }
-  };
+        const replacements = {
+            "'": "\\'",
+            '"': '\\"',
+            '\\': '\\\\',
+            '\b': '\\b',
+            '\f': '\\f',
+            '\n': '\\n',
+            '\r': '\\r',
+            '\t': '\\t',
+            '\v': '\\v',
+            '\0': '\\0',
+            '\u2028': '\\u2028',
+            '\u2029': '\\u2029',
+        };
 
-  const output = utils.removePrefix(input, state);
-  let source = create(output);
+        let product = '';
 
-  if (source && opts.strictSlashes !== true) {
-    source += `${SLASH_LITERAL}?`;
-  }
+        for (let i = 0; i < value.length; i++) {
+            const c = value[i];
+            switch (c) {
+            case "'":
+            case '"':
+                quotes[c]++;
+                product += c;
+                continue
 
-  return source;
-};
+            case '\0':
+                if (util.isDigit(value[i + 1])) {
+                    product += '\\x00';
+                    continue
+                }
+            }
 
-var parse_1$1 = parse$5;
+            if (replacements[c]) {
+                product += replacements[c];
+                continue
+            }
 
-const isObject$1 = val => val && typeof val === 'object' && !Array.isArray(val);
+            if (c < ' ') {
+                let hexString = c.charCodeAt(0).toString(16);
+                product += '\\x' + ('00' + hexString).substring(hexString.length);
+                continue
+            }
 
-/**
- * Creates a matcher function from one or more glob patterns. The
- * returned function takes a string to match as its first argument,
- * and returns true if the string is a match. The returned matcher
- * function also takes a boolean as the second argument that, when true,
- * returns an object with additional information.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch(glob[, options]);
- *
- * const isMatch = picomatch('*.!(*a)');
- * console.log(isMatch('a.a')); //=> false
- * console.log(isMatch('a.b')); //=> true
- * ```
- * @name picomatch
- * @param {String|Array} `globs` One or more glob patterns.
- * @param {Object=} `options`
- * @return {Function=} Returns a matcher function.
- * @api public
- */
+            product += c;
+        }
 
-const picomatch = (glob, options, returnState = false) => {
-  if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch(input, options, returnState));
-    const arrayMatcher = str => {
-      for (const isMatch of fns) {
-        const state = isMatch(str);
-        if (state) return state;
-      }
-      return false;
-    };
-    return arrayMatcher;
-  }
+        const quoteChar = quote || Object.keys(quotes).reduce((a, b) => (quotes[a] < quotes[b]) ? a : b);
 
-  const isState = isObject$1(glob) && glob.tokens && glob.input;
+        product = product.replace(new RegExp(quoteChar, 'g'), replacements[quoteChar]);
 
-  if (glob === '' || (typeof glob !== 'string' && !isState)) {
-    throw new TypeError('Expected pattern to be a non-empty string');
-  }
+        return quoteChar + product + quoteChar
+    }
 
-  const opts = options || {};
-  const posix = utils.isWindows(options);
-  const regex = isState
-    ? picomatch.compileRe(glob, options)
-    : picomatch.makeRe(glob, options, false, true);
+    function serializeObject (value) {
+        if (stack.indexOf(value) >= 0) {
+            throw TypeError('Converting circular structure to JSON5')
+        }
 
-  const state = regex.state;
-  delete regex.state;
+        stack.push(value);
 
-  let isIgnored = () => false;
-  if (opts.ignore) {
-    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
-  }
+        let stepback = indent;
+        indent = indent + gap;
 
-  const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
-    const result = { glob, state, regex, posix, input, output, match, isMatch };
+        let keys = propertyList || Object.keys(value);
+        let partial = [];
+        for (const key of keys) {
+            const propertyString = serializeProperty(key, value);
+            if (propertyString !== undefined) {
+                let member = serializeKey(key) + ':';
+                if (gap !== '') {
+                    member += ' ';
+                }
+                member += propertyString;
+                partial.push(member);
+            }
+        }
 
-    if (typeof opts.onResult === 'function') {
-      opts.onResult(result);
-    }
+        let final;
+        if (partial.length === 0) {
+            final = '{}';
+        } else {
+            let properties;
+            if (gap === '') {
+                properties = partial.join(',');
+                final = '{' + properties + '}';
+            } else {
+                let separator = ',\n' + indent;
+                properties = partial.join(separator);
+                final = '{\n' + indent + properties + ',\n' + stepback + '}';
+            }
+        }
 
-    if (isMatch === false) {
-      result.isMatch = false;
-      return returnObject ? result : false;
+        stack.pop();
+        indent = stepback;
+        return final
     }
 
-    if (isIgnored(input)) {
-      if (typeof opts.onIgnore === 'function') {
-        opts.onIgnore(result);
-      }
-      result.isMatch = false;
-      return returnObject ? result : false;
-    }
+    function serializeKey (key) {
+        if (key.length === 0) {
+            return quoteString(key)
+        }
 
-    if (typeof opts.onMatch === 'function') {
-      opts.onMatch(result);
-    }
-    return returnObject ? result : true;
-  };
+        const firstChar = String.fromCodePoint(key.codePointAt(0));
+        if (!util.isIdStartChar(firstChar)) {
+            return quoteString(key)
+        }
 
-  if (returnState) {
-    matcher.state = state;
-  }
+        for (let i = firstChar.length; i < key.length; i++) {
+            if (!util.isIdContinueChar(String.fromCodePoint(key.codePointAt(i)))) {
+                return quoteString(key)
+            }
+        }
 
-  return matcher;
-};
+        return key
+    }
 
-/**
- * Test `input` with the given `regex`. This is used by the main
- * `picomatch()` function to test the input string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.test(input, regex[, options]);
- *
- * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
- * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp} `regex`
- * @return {Object} Returns an object with matching info.
- * @api public
- */
+    function serializeArray (value) {
+        if (stack.indexOf(value) >= 0) {
+            throw TypeError('Converting circular structure to JSON5')
+        }
 
-picomatch.test = (input, regex, options, { glob, posix } = {}) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected input to be a string');
-  }
+        stack.push(value);
 
-  if (input === '') {
-    return { isMatch: false, output: '' };
-  }
+        let stepback = indent;
+        indent = indent + gap;
 
-  const opts = options || {};
-  const format = opts.format || (posix ? utils.toPosixSlashes : null);
-  let match = input === glob;
-  let output = (match && format) ? format(input) : input;
+        let partial = [];
+        for (let i = 0; i < value.length; i++) {
+            const propertyString = serializeProperty(String(i), value);
+            partial.push((propertyString !== undefined) ? propertyString : 'null');
+        }
 
-  if (match === false) {
-    output = format ? format(input) : input;
-    match = output === glob;
-  }
+        let final;
+        if (partial.length === 0) {
+            final = '[]';
+        } else {
+            if (gap === '') {
+                let properties = partial.join(',');
+                final = '[' + properties + ']';
+            } else {
+                let separator = ',\n' + indent;
+                let properties = partial.join(separator);
+                final = '[\n' + indent + properties + ',\n' + stepback + ']';
+            }
+        }
 
-  if (match === false || opts.capture === true) {
-    if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch.matchBase(input, regex, options, posix);
-    } else {
-      match = regex.exec(output);
+        stack.pop();
+        indent = stepback;
+        return final
     }
-  }
+};
 
-  return { isMatch: Boolean(match), match, output };
+const JSON5 = {
+    parse: parse$1,
+    stringify,
 };
 
+var lib = JSON5;
+
 /**
- * Match the basename of a filepath.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.matchBase(input, glob[, options]);
- * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
- * @return {Boolean}
- * @api public
+ * @typedef Option
+ * @property {'boolean'|'string'} [type='string']
+ * @property {string} long
+ * @property {string} description
+ * @property {string} [value]
+ * @property {string} [short]
+ * @property {boolean|string} [default='']
+ * @property {boolean} [truelike=false]
  */
 
-picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-  return regex.test(path$1.basename(input));
-};
+/** @type {Option[]} */
+const schema = [
+  {
+    long: 'help',
+    description: 'output usage information',
+    short: 'h',
+    type: 'boolean',
+    default: false
+  },
+  {
+    long: 'version',
+    description: 'output version number',
+    short: 'v',
+    type: 'boolean',
+    default: false
+  },
+  {
+    long: 'output',
+    description: 'specify output location',
+    short: 'o',
+    value: '[path]'
+  },
+  {
+    long: 'rc-path',
+    description: 'specify configuration file',
+    short: 'r',
+    type: 'string',
+    value: '<path>'
+  },
+  {
+    long: 'ignore-path',
+    description: 'specify ignore file',
+    short: 'i',
+    type: 'string',
+    value: '<path>'
+  },
+  {
+    long: 'setting',
+    description: 'specify settings',
+    short: 's',
+    type: 'string',
+    value: '<settings>'
+  },
+  {
+    long: 'ext',
+    description: 'specify extensions',
+    short: 'e',
+    type: 'string',
+    value: '<extensions>'
+  },
+  {
+    long: 'use',
+    description: 'use plugins',
+    short: 'u',
+    type: 'string',
+    value: '<plugins>'
+  },
+  {
+    long: 'watch',
+    description: 'watch for changes and reprocess',
+    short: 'w',
+    type: 'boolean',
+    default: false
+  },
+  {
+    long: 'quiet',
+    description: 'output only warnings and errors',
+    short: 'q',
+    type: 'boolean',
+    default: false
+  },
+  {
+    long: 'silent',
+    description: 'output only errors',
+    short: 'S',
+    type: 'boolean',
+    default: false
+  },
+  {
+    long: 'frail',
+    description: 'exit with 1 on warnings',
+    short: 'f',
+    type: 'boolean',
+    default: false
+  },
+  {
+    long: 'tree',
+    description: 'specify input and output as syntax tree',
+    short: 't',
+    type: 'boolean',
+    default: false
+  },
+  {
+    long: 'report',
+    description: 'specify reporter',
+    type: 'string',
+    value: '<reporter>'
+  },
+  {
+    long: 'file-path',
+    description: 'specify path to process as',
+    type: 'string',
+    value: '<path>'
+  },
+  {
+    long: 'ignore-path-resolve-from',
+    description: 'resolve patterns in `ignore-path` from its directory or cwd',
+    type: 'string',
+    value: 'dir|cwd',
+    default: 'dir'
+  },
+  {
+    long: 'ignore-pattern',
+    description: 'specify ignore patterns',
+    type: 'string',
+    value: '<globs>'
+  },
+  {
+    long: 'silently-ignore',
+    description: 'do not fail when given ignored files',
+    type: 'boolean'
+  },
+  {
+    long: 'tree-in',
+    description: 'specify input as syntax tree',
+    type: 'boolean'
+  },
+  {
+    long: 'tree-out',
+    description: 'output syntax tree',
+    type: 'boolean'
+  },
+  {
+    long: 'inspect',
+    description: 'output formatted syntax tree',
+    type: 'boolean'
+  },
+  {
+    long: 'stdout',
+    description: 'specify writing to stdout',
+    type: 'boolean',
+    truelike: true
+  },
+  {
+    long: 'color',
+    description: 'specify color in report',
+    type: 'boolean',
+    default: true
+  },
+  {
+    long: 'config',
+    description: 'search for configuration files',
+    type: 'boolean',
+    default: true
+  },
+  {
+    long: 'ignore',
+    description: 'search for ignore files',
+    type: 'boolean',
+    default: true
+  }
+];
 
 /**
- * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ * @typedef {import('unified-engine').Options} EngineOptions
+ * @typedef {import('./schema.js').Option} Option
  *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.isMatch(string, patterns[, options]);
+ * @typedef {Required<
+ *   Pick<
+ *     EngineOptions,
+ *     | 'extensions'
+ *     | 'ignoreName'
+ *     | 'packageField'
+ *     | 'pluginPrefix'
+ *     | 'processor'
+ *     | 'rcName'
+ *   >
+ * >} RequiredEngineOptions
  *
- * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
- * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
- * ```
- * @param {String|Array} str The string to test.
- * @param {String|Array} patterns One or more glob patterns to use for matching.
- * @param {Object} [options] See available [options](#options).
- * @return {Boolean} Returns true if any patterns match `str`
- * @api public
- */
-
-picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
-
-/**
- * Parse a glob pattern to create the source string for a regular
- * expression.
+ * @typedef ArgsOptionsFields
+ * @property {string} name
+ *   Name of executable
+ * @property {string} description
+ *   Description of executable
+ * @property {string} version
+ *   Version (semver) of executable
  *
- * ```js
- * const picomatch = require('picomatch');
- * const result = picomatch.parse(pattern[, options]);
- * ```
- * @param {String} `pattern`
- * @param {Object} `options`
- * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
- * @api public
+ * @typedef {RequiredEngineOptions & Pick<EngineOptions, 'cwd'> & ArgsOptionsFields} Options
  */
 
-picomatch.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
-  return parse_1$1(pattern, { ...options, fastpaths: false });
-};
+const own$7 = {}.hasOwnProperty;
 
 /**
- * Scan a glob pattern to separate the pattern into segments.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.scan(input[, options]);
- *
- * const result = picomatch.scan('!./foo/*.js');
- * console.log(result);
- * { prefix: '!./',
- *   input: '!./foo/*.js',
- *   start: 3,
- *   base: 'foo',
- *   glob: '*.js',
- *   isBrace: false,
- *   isBracket: false,
- *   isGlob: true,
- *   isExtglob: false,
- *   isGlobstar: false,
- *   negated: true }
- * ```
- * @param {String} `input` Glob pattern to scan.
- * @param {Object} `options`
- * @return {Object} Returns an object with
- * @api public
+ * Schema for `minimist`.
  */
+const minischema = {
+  unknown: handleUnknownArgument,
+  /** @type {Record<string, string|boolean|null>} */
+  default: {},
+  /** @type {Record<string, string>} */
+  alias: {},
+  /** @type {string[]} */
+  string: [],
+  /** @type {string[]} */
+  boolean: []
+};
 
-picomatch.scan = (input, options) => scan_1(input, options);
+let index = -1;
+while (++index < schema.length) {
+  addEach(schema[index]);
+}
 
 /**
- * Create a regular expression from a parsed glob pattern.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const state = picomatch.parse('*.js');
- * // picomatch.compileRe(state[, options]);
+ * Parse CLI options.
  *
- * console.log(picomatch.compileRe(state));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `state` The object returned from the `.parse` method.
- * @param {Object} `options`
- * @return {RegExp} Returns a regex created from the given pattern.
- * @api public
+ * @param {string[]} flags
+ * @param {Options} configuration
  */
+function options(flags, configuration) {
+  const extension = configuration.extensions[0];
+  const name = configuration.name;
+  const config = toCamelCase(minimist(flags, minischema));
+  let index = -1;
 
-picomatch.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
-  if (returnOutput === true) {
-    return parsed.output;
-  }
-
-  const opts = options || {};
-  const prepend = opts.contains ? '' : '^';
-  const append = opts.contains ? '' : '$';
-
-  let source = `${prepend}(?:${parsed.output})${append}`;
-  if (parsed && parsed.negated === true) {
-    source = `^(?!${source}).*$`;
-  }
-
-  const regex = picomatch.toRegex(source, options);
-  if (returnState === true) {
-    regex.state = parsed;
+  while (++index < schema.length) {
+    const option = schema[index];
+    if (option.type === 'string' && config[option.long] === '') {
+      throw fault('Missing value:%s', inspect(option).join(' '))
+    }
   }
 
-  return regex;
-};
+  const ext = commaSeparated(/** @type {string} */ (config.ext));
+  const report = reporter(/** @type {string} */ (config.report));
+  const help = [
+    inspectAll(schema),
+    '',
+    'Examples:',
+    '',
+    '  # Process `input.' + extension + '`',
+    '  $ ' + name + ' input.' + extension + ' -o output.' + extension,
+    '',
+    '  # Pipe',
+    '  $ ' + name + ' < input.' + extension + ' > output.' + extension,
+    '',
+    '  # Rewrite all applicable files',
+    '  $ ' + name + ' . -o'
+  ].join('\n');
 
-picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {
-  if (!input || typeof input !== 'string') {
-    throw new TypeError('Expected a non-empty string');
+  return {
+    helpMessage: help,
+    cwd: configuration.cwd,
+    processor: configuration.processor,
+    help: config.help,
+    version: config.version,
+    files: config._,
+    filePath: config.filePath,
+    watch: config.watch,
+    extensions: ext.length === 0 ? configuration.extensions : ext,
+    output: config.output,
+    out: config.stdout,
+    tree: config.tree,
+    treeIn: config.treeIn,
+    treeOut: config.treeOut,
+    inspect: config.inspect,
+    rcName: configuration.rcName,
+    packageField: configuration.packageField,
+    rcPath: config.rcPath,
+    detectConfig: config.config,
+    settings: /** @type {Record<string, unknown>} */ (
+      settings(/** @type {string} */ (config.setting))
+    ),
+    ignoreName: configuration.ignoreName,
+    ignorePath: config.ignorePath,
+    ignorePathResolveFrom: config.ignorePathResolveFrom,
+    ignorePatterns: commaSeparated(
+      /** @type {string} */ (config.ignorePattern)
+    ),
+    silentlyIgnore: config.silentlyIgnore,
+    detectIgnore: config.ignore,
+    pluginPrefix: configuration.pluginPrefix,
+    plugins: plugins$2(/** @type {string} */ (config.use)),
+    reporter: report[0],
+    reporterOptions: report[1],
+    color: config.color,
+    silent: config.silent,
+    quiet: config.quiet,
+    frail: config.frail
   }
+}
 
-  const opts = options || {};
-  let parsed = { negated: false, fastpaths: true };
-  let prefix = '';
-  let output;
+/**
+ * @param {Option} option
+ */
+function addEach(option) {
+  const value = option.default;
 
-  if (input.startsWith('./')) {
-    input = input.slice(2);
-    prefix = parsed.prefix = './';
-  }
+  minischema.default[option.long] = value === undefined ? null : value;
 
-  if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    output = parse_1$1.fastpaths(input, options);
+  if (option.type && option.type in minischema) {
+    minischema[option.type].push(option.long);
   }
 
-  if (output === undefined) {
-    parsed = parse_1$1(input, options);
-    parsed.prefix = prefix + (parsed.prefix || '');
-  } else {
-    parsed.output = output;
+  if (option.short) {
+    minischema.alias[option.short] = option.long;
   }
-
-  return picomatch.compileRe(parsed, options, returnOutput, returnState);
-};
+}
 
 /**
- * Create a regular expression from the given regex source string.
+ * Parse `extensions`.
  *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.toRegex(source[, options]);
+ * @param {string[]|string|null|undefined} value
+ * @returns {string[]}
+ */
+function commaSeparated(value) {
+  return flatten(normalize(value).map((d) => splitList(d)))
+}
+
+/**
+ * Parse `plugins`.
  *
- * const { output } = picomatch.parse('*.js');
- * console.log(picomatch.toRegex(output));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `source` Regular expression source string.
- * @param {Object} `options`
- * @return {RegExp}
- * @api public
+ * @param {string[]|string|null|undefined} value
+ * @returns {Record<string, Record<string, unknown>|undefined>}
  */
+function plugins$2(value) {
+  const normalized = normalize(value).map((d) => splitOptions(d));
+  let index = -1;
+  /** @type {Record<string, Record<string, unknown>|undefined>} */
+  const result = {};
 
-picomatch.toRegex = (source, options) => {
-  try {
-    const opts = options || {};
-    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
-  } catch (err) {
-    if (options && options.debug === true) throw err;
-    return /$^/;
+  while (++index < normalized.length) {
+    const value = normalized[index];
+    result[value[0]] = value[1] ? parseConfig(value[1], {}) : undefined;
   }
-};
+
+  return result
+}
 
 /**
- * Picomatch constants.
- * @return {Object}
+ * Parse `reporter`: only one is accepted.
+ *
+ * @param {string[]|string|null|undefined} value
+ * @returns {[string|undefined, Record<string, unknown>|undefined]}
  */
+function reporter(value) {
+  const all = normalize(value)
+    .map((d) => splitOptions(d))
+    .map(
+      /**
+       * @returns {[string, Record<string, unknown>|undefined]}
+       */
+      (value) => [value[0], value[1] ? parseConfig(value[1], {}) : undefined]
+    );
 
-picomatch.constants = constants;
+  return all[all.length - 1] || []
+}
 
 /**
- * Expose "picomatch"
+ * Parse `settings`.
+ *
+ * @param {string[]|string|null|undefined} value
+ * @returns {Record<string, unknown>}
  */
+function settings(value) {
+  const normalized = normalize(value);
+  let index = -1;
+  /** @type {Record<string, unknown>} */
+  const cache = {};
 
-var picomatch_1 = picomatch;
-
-var picomatch$1 = picomatch_1;
-
-const { Readable } = stream;
-
-const { promisify } = util$2;
-
+  while (++index < normalized.length) {
+    parseConfig(normalized[index], cache);
+  }
 
-const readdir$1 = promisify(fs$1.readdir);
-const stat$2 = promisify(fs$1.stat);
-const lstat = promisify(fs$1.lstat);
-const realpath$2 = promisify(fs$1.realpath);
+  return cache
+}
 
 /**
- * @typedef {Object} EntryInfo
- * @property {String} path
- * @property {String} fullPath
- * @property {fs.Stats=} stats
- * @property {fs.Dirent=} dirent
- * @property {String} basename
+ * Parse configuration.
+ *
+ * @param {string} value
+ * @param {Record<string, unknown>} cache
+ * @returns {Record<string, unknown>}
  */
+function parseConfig(value, cache) {
+  /** @type {Record<string, unknown>} */
+  let flags;
+  /** @type {string} */
+  let flag;
 
-const BANG = '!';
-const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP']);
-const FILE_TYPE = 'files';
-const DIR_TYPE = 'directories';
-const FILE_DIR_TYPE = 'files_directories';
-const EVERYTHING_TYPE = 'all';
-const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
-
-const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);
-
-const normalizeFilter = filter => {
-  if (filter === undefined) return;
-  if (typeof filter === 'function') return filter;
+  try {
+    flags = toCamelCase(parseJSON(value));
+  } catch (error) {
+    throw fault(
+      'Cannot parse `%s` as JSON: %s',
+      value,
+      // Fix position
+      error.message.replace(/at(?= position)/, 'around')
+    )
+  }
 
-  if (typeof filter === 'string') {
-    const glob = picomatch$1(filter.trim());
-    return entry => glob(entry.basename);
+  for (flag in flags) {
+    if (own$7.call(flags, flag)) {
+      cache[flag] = flags[flag];
+    }
   }
 
-  if (Array.isArray(filter)) {
-    const positive = [];
-    const negative = [];
-    for (const item of filter) {
-      const trimmed = item.trim();
-      if (trimmed.charAt(0) === BANG) {
-        negative.push(picomatch$1(trimmed.slice(1)));
-      } else {
-        positive.push(picomatch$1(trimmed));
-      }
+  return cache
+}
+
+/**
+ * Handle an unknown flag.
+ *
+ * @param {string} flag
+ * @returns {boolean}
+ */
+function handleUnknownArgument(flag) {
+  // Not a glob.
+  if (flag.charAt(0) === '-') {
+    // Long options, always unknown.
+    if (flag.charAt(1) === '-') {
+      throw fault(
+        'Unknown option `%s`, expected:\n%s',
+        flag,
+        inspectAll(schema)
+      )
     }
 
-    if (negative.length > 0) {
-      if (positive.length > 0) {
-        return entry =>
-          positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
+    // Short options, can be grouped.
+    const found = flag.slice(1).split('');
+    const known = schema.filter((d) => d.short);
+    const knownKeys = new Set(known.map((d) => d.short));
+    let index = -1;
+
+    while (++index < found.length) {
+      const key = found[index];
+      if (!knownKeys.has(key)) {
+        throw fault(
+          'Unknown short option `-%s`, expected:\n%s',
+          key,
+          inspectAll(known)
+        )
       }
-      return entry => !negative.some(f => f(entry.basename));
     }
-    return entry => positive.some(f => f(entry.basename));
   }
-};
 
-class ReaddirpStream extends Readable {
-  static get defaultOptions() {
-    return {
-      root: '.',
-      /* eslint-disable no-unused-vars */
-      fileFilter: (path) => true,
-      directoryFilter: (path) => true,
-      /* eslint-enable no-unused-vars */
-      type: FILE_TYPE,
-      lstat: false,
-      depth: 2147483648,
-      alwaysStat: false
-    };
-  }
+  return true
+}
 
-  constructor(options = {}) {
-    super({
-      objectMode: true,
-      autoDestroy: true,
-      highWaterMark: options.highWaterMark || 4096
-    });
-    const opts = { ...ReaddirpStream.defaultOptions, ...options };
-    const { root, type } = opts;
+/**
+ * Inspect all `options`.
+ *
+ * @param {Option[]} options
+ * @returns {string}
+ */
+function inspectAll(options) {
+  return textTable(options.map((d) => inspect(d)))
+}
 
-    this._fileFilter = normalizeFilter(opts.fileFilter);
-    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+/**
+ * Inspect one `option`.
+ *
+ * @param {Option} option
+ * @returns {string[]}
+ */
+function inspect(option) {
+  let description = option.description;
+  let long = option.long;
 
-    const statMethod = opts.lstat ? lstat : stat$2;
-    // Use bigint stats if it's windows and stat() supports options (node 10+).
-    if (process.platform === 'win32' && stat$2.length === 3) {
-      this._stat = path => statMethod(path, { bigint: true });
-    } else {
-      this._stat = statMethod;
-    }
+  if (option.default === true || option.truelike) {
+    description += ' (on by default)';
+    long = '[no-]' + long;
+  }
 
-    this._maxDepth = opts.depth;
-    this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
-    this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
-    this._wantsEverything = type === EVERYTHING_TYPE;
-    this._root = path$1.resolve(root);
-    this._isDirent = ('Dirent' in fs$1) && !opts.alwaysStat;
-    this._statsProp = this._isDirent ? 'dirent' : 'stats';
-    this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+  return [
+    '',
+    option.short ? '-' + option.short : '',
+    '--' + long + (option.value ? ' ' + option.value : ''),
+    description
+  ]
+}
 
-    // Launch stream with one parent, the root dir.
-    this.parents = [this._exploreDir(root, 1)];
-    this.reading = false;
-    this.parent = undefined;
+/**
+ * Normalize `value`.
+ *
+ * @param {string[]|string|null|undefined} value
+ * @returns {string[]}
+ */
+function normalize(value) {
+  if (!value) {
+    return []
   }
 
-  async _read(batch) {
-    if (this.reading) return;
-    this.reading = true;
-
-    try {
-      while (!this.destroyed && batch > 0) {
-        const { path, depth, files = [] } = this.parent || {};
+  if (typeof value === 'string') {
+    return [value]
+  }
 
-        if (files.length > 0) {
-          const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
-          for (const entry of await Promise.all(slice)) {
-            if (this.destroyed) return;
+  return flatten(value.map((d) => normalize(d)))
+}
 
-            const entryType = await this._getEntryType(entry);
-            if (entryType === 'directory' && this._directoryFilter(entry)) {
-              if (depth <= this._maxDepth) {
-                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
-              }
+/**
+ * Flatten `values`.
+ *
+ * @param {string|string[]|string[][]} values
+ * @returns {string[]}
+ */
+function flatten(values) {
+  // @ts-expect-error: TS is wrong.
+  return values.flat()
+}
 
-              if (this._wantsDir) {
-                this.push(entry);
-                batch--;
-              }
-            } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
-              if (this._wantsFile) {
-                this.push(entry);
-                batch--;
-              }
-            }
-          }
-        } else {
-          const parent = this.parents.pop();
-          if (!parent) {
-            this.push(null);
-            break;
-          }
-          this.parent = await parent;
-          if (this.destroyed) return;
-        }
-      }
-    } catch (error) {
-      this.destroy(error);
-    } finally {
-      this.reading = false;
-    }
-  }
+/**
+ * @param {string} value
+ * @returns {string[]}
+ */
+function splitOptions(value) {
+  return value.split('=')
+}
 
-  async _exploreDir(path, depth) {
-    let files;
-    try {
-      files = await readdir$1(path, this._rdOptions);
-    } catch (error) {
-      this._onError(error);
-    }
-    return {files, depth, path};
-  }
+/**
+ * @param {string} value
+ * @returns {string[]}
+ */
+function splitList(value) {
+  return value.split(',')
+}
 
-  async _formatEntry(dirent, path) {
-    let entry;
-    try {
-      const basename = this._isDirent ? dirent.name : dirent;
-      const fullPath = path$1.resolve(path$1.join(path, basename));
-      entry = {path: path$1.relative(this._root, fullPath), fullPath, basename};
-      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-    } catch (err) {
-      this._onError(err);
-    }
-    return entry;
-  }
+/**
+ * Transform the keys on an object to camel-case, recursivly.
+ *
+ * @param {Record<string, unknown>} object
+ * @returns {Record<string, unknown>}
+ */
+function toCamelCase(object) {
+  /** @type {Record<string, unknown>} */
+  const result = {};
+  /** @type {string} */
+  let key;
 
-  _onError(err) {
-    if (isNormalFlowError(err) && !this.destroyed) {
-      this.emit('warn', err);
-    } else {
-      this.destroy(err);
-    }
-  }
+  for (key in object) {
+    if (own$7.call(object, key)) {
+      let value = object[key];
 
-  async _getEntryType(entry) {
-    // entry may be undefined, because a warning or an error were emitted
-    // and the statsProp is undefined
-    const stats = entry && entry[this._statsProp];
-    if (!stats) {
-      return;
-    }
-    if (stats.isFile()) {
-      return 'file';
-    }
-    if (stats.isDirectory()) {
-      return 'directory';
-    }
-    if (stats && stats.isSymbolicLink()) {
-      try {
-        const entryRealPath = await realpath$2(entry.fullPath);
-        const entryRealPathStats = await lstat(entryRealPath);
-        if (entryRealPathStats.isFile()) {
-          return 'file';
-        }
-        if (entryRealPathStats.isDirectory()) {
-          return 'directory';
-        }
-      } catch (error) {
-        this._onError(error);
+      if (value && typeof value === 'object' && !Array.isArray(value)) {
+        // @ts-expect-error: looks like an object.
+        value = toCamelCase(value);
       }
+
+      result[camelcase(key)] = value;
     }
   }
 
-  _includeAsFile(entry) {
-    const stats = entry && entry[this._statsProp];
-
-    return stats && this._wantsEverything && !stats.isDirectory();
-  }
+  return result
 }
 
 /**
- * @typedef {Object} ReaddirpArguments
- * @property {Function=} fileFilter
- * @property {Function=} directoryFilter
- * @property {String=} type
- * @property {Number=} depth
- * @property {String=} root
- * @property {Boolean=} lstat
- * @property {Boolean=} bigint
+ * Parse a (lazy?) JSON config.
+ *
+ * @param {string} value
+ * @returns {Record<string, unknown>}
  */
+function parseJSON(value) {
+  return lib.parse('{' + value + '}')
+}
 
 /**
- * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
- * @param {String} root Root directory
- * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
+ * @typedef {import('unified-engine').Options} EngineOptions
+ * @typedef {import('unified-engine').Context} EngineContext
+ * @typedef {import('unified-engine').Callback} EngineCallback
+ * @typedef {import('./options.js').Options} Options
  */
-const readdirp = (root, options = {}) => {
-  let type = options.entryType || options.type;
-  if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
-  if (type) options.type = type;
-  if (!root) {
-    throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
-  } else if (typeof root !== 'string') {
-    throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
-  } else if (type && !ALL_TYPES.includes(type)) {
-    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
-  }
 
-  options.root = root;
-  return new ReaddirpStream(options);
-};
+// Fake TTY stream.
+const ttyStream = Object.assign(new stream.Readable(), {isTTY: true});
 
-const readdirpPromise = (root, options = {}) => {
-  return new Promise((resolve, reject) => {
-    const files = [];
-    readdirp(root, options)
-      .on('data', entry => files.push(entry))
-      .on('end', () => resolve(files))
-      .on('error', error => reject(error));
-  });
-};
+// Exit, lazily, with the correct exit status code.
+let exitStatus = 0;
 
-readdirp.promise = readdirpPromise;
-readdirp.ReaddirpStream = ReaddirpStream;
-readdirp.default = readdirp;
+process$2.on('exit', onexit);
 
-var readdirp_1 = readdirp;
+// Handle uncaught errors, such as from unexpected async behaviour.
+process$2.on('uncaughtException', fail);
 
-/*!
- * normalize-path <https://github.com/jonschlinkert/normalize-path>
+/**
+ * Start the CLI.
  *
- * Copyright (c) 2014-2018, Jon Schlinkert.
- * Released under the MIT License.
+ * @param {Options} cliConfig
  */
+function args(cliConfig) {
+  /** @type {EngineOptions & {help: boolean, helpMessage: string, watch: boolean, version: boolean}} */
+  let config;
+  /** @type {chokidar.FSWatcher|undefined} */
+  let watcher;
+  /** @type {boolean|string|undefined} */
+  let output;
 
-var normalizePath = function(path, stripTrailing) {
-  if (typeof path !== 'string') {
-    throw new TypeError('expected path to be a string');
+  try {
+    // @ts-expect-error: Close enough.
+    config = options(process$2.argv.slice(2), cliConfig);
+  } catch (error) {
+    return fail(error, true)
   }
 
-  if (path === '\\' || path === '/') return '/';
-
-  var len = path.length;
-  if (len <= 1) return path;
+  if (config.help) {
+    process$2.stdout.write(
+      [
+        'Usage: ' + cliConfig.name + ' [options] [path | glob ...]',
+        '',
+        '  ' + cliConfig.description,
+        '',
+        'Options:',
+        '',
+        config.helpMessage,
+        ''
+      ].join('\n'),
+      noop$1
+    );
 
-  // ensure that win32 namespaces has two leading slashes, so that the path is
-  // handled properly by the win32 version of path.parse() after being normalized
-  // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
-  var prefix = '';
-  if (len > 4 && path[3] === '\\') {
-    var ch = path[2];
-    if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
-      path = path.slice(2);
-      prefix = '//';
-    }
+    return
   }
 
-  var segs = path.split(/[/\\]+/);
-  if (stripTrailing !== false && segs[segs.length - 1] === '') {
-    segs.pop();
-  }
-  return prefix + segs.join('/');
-};
+  if (config.version) {
+    process$2.stdout.write(cliConfig.version + '\n', noop$1);
 
-var anymatch_1 = createCommonjsModule(function (module, exports) {
+    return
+  }
 
-Object.defineProperty(exports, "__esModule", { value: true });
+  // Modify `config` for watching.
+  if (config.watch) {
+    output = config.output;
 
+    // Do not read from stdin(4).
+    config.streamIn = ttyStream;
 
+    // Do not write to stdout(4).
+    config.out = false;
 
+    process$2.stderr.write(
+      source$1.bold('Watching...') + ' (press CTRL+C to exit)\n',
+      noop$1
+    );
 
-/**
- * @typedef {(testString: string) => boolean} AnymatchFn
- * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
- * @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
- */
-const BANG = '!';
-const DEFAULT_OPTIONS = {returnIndex: false};
-const arrify = (item) => Array.isArray(item) ? item : [item];
+    // Prevent infinite loop if set to regeneration.
+    if (output === true) {
+      config.output = false;
 
-/**
- * @param {AnymatchPattern} matcher
- * @param {object} options
- * @returns {AnymatchFn}
- */
-const createPattern = (matcher, options) => {
-  if (typeof matcher === 'function') {
-    return matcher;
-  }
-  if (typeof matcher === 'string') {
-    const glob = picomatch$1(matcher, options);
-    return (string) => matcher === string || glob(string);
-  }
-  if (matcher instanceof RegExp) {
-    return (string) => matcher.test(string);
+      process$2.stderr.write(
+        source$1.yellow('Note') + ': Ignoring `--output` until exit.\n',
+        noop$1
+      );
+    }
   }
-  return (string) => false;
-};
 
-/**
- * @param {Array<Function>} patterns
- * @param {Array<Function>} negPatterns
- * @param {String|Array} args
- * @param {Boolean} returnIndex
- * @returns {boolean|number}
- */
-const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
-  const isList = Array.isArray(args);
-  const _path = isList ? args[0] : args;
-  if (!isList && typeof _path !== 'string') {
-    throw new TypeError('anymatch: second argument must be a string: got ' +
-      Object.prototype.toString.call(_path))
-  }
-  const path = normalizePath(_path);
+  // Initial run.
+  engine(config, done);
 
-  for (let index = 0; index < negPatterns.length; index++) {
-    const nglob = negPatterns[index];
-    if (nglob(path)) {
-      return returnIndex ? -1 : false;
-    }
-  }
+  /**
+   * Handle complete run.
+   *
+   * @type {EngineCallback}
+   */
+  function done(error, code, context) {
+    if (error) {
+      clean();
+      fail(error);
+    } else {
+      exitStatus = code || 0;
 
-  const applied = isList && [path].concat(args.slice(1));
-  for (let index = 0; index < patterns.length; index++) {
-    const pattern = patterns[index];
-    if (isList ? pattern(...applied) : pattern(path)) {
-      return returnIndex ? index : true;
+      if (config.watch && !watcher && context) {
+        subscribe(context);
+      }
     }
   }
 
-  return returnIndex ? -1 : false;
-};
-
-/**
- * @param {AnymatchMatcher} matchers
- * @param {Array|string} testString
- * @param {object} options
- * @returns {boolean|number|Function}
- */
-const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
-  if (matchers == null) {
-    throw new TypeError('anymatch: specify first argument');
+  // Clean the watcher.
+  function clean() {
+    if (watcher) {
+      watcher.close();
+      watcher = undefined;
+    }
   }
-  const opts = typeof options === 'boolean' ? {returnIndex: options} : options;
-  const returnIndex = opts.returnIndex || false;
 
-  // Early cache for matchers.
-  const mtchers = arrify(matchers);
-  const negatedGlobs = mtchers
-    .filter(item => typeof item === 'string' && item.charAt(0) === BANG)
-    .map(item => item.slice(1))
-    .map(item => picomatch$1(item, opts));
-  const patterns = mtchers.map(matcher => createPattern(matcher, opts));
+  /**
+   * Subscribe a chokidar watcher to all processed files.
+   *
+   * @param {EngineContext} context
+   */
+  function subscribe(context) {
+    watcher = chokidar
+      // @ts-expect-error: `fileSet` is available.
+      .watch(context.fileSet.origins, {cwd: config.cwd, ignoreInitial: true})
+      .on('error', done)
+      .on('change', (filePath) => {
+        config.files = [filePath];
+        engine(config, done);
+      });
 
-  if (testString == null) {
-    return (testString, ri = false) => {
-      const returnIndex = typeof ri === 'boolean' ? ri : false;
-      return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
-    }
-  }
+    process$2.on('SIGINT', onsigint);
 
-  return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
-};
+    /**
+     * Handle a SIGINT.
+     */
+    function onsigint() {
+      // Hide the `^C` in terminal.
+      process$2.stderr.write('\n', noop$1);
 
-anymatch.default = anymatch;
-module.exports = anymatch;
-});
+      clean();
 
-unwrapExports(anymatch_1);
+      // Do another process if `output` specified regeneration.
+      if (output === true) {
+        config.output = output;
+        config.watch = false;
+        engine(config, done);
+      }
+    }
+  }
+}
 
-/*!
- * is-extglob <https://github.com/jonschlinkert/is-extglob>
+/**
+ * Print an error, optionally with stack.
  *
- * Copyright (c) 2014-2016, Jon Schlinkert.
- * Licensed under the MIT License.
+ * @param {Error} error
+ * @param {boolean} [pretty=false]
  */
+function fail(error, pretty) {
+  // Old versions of Node
+  /* c8 ignore next 1 */
+  const message = String((pretty ? error : error.stack) || error);
 
-var isExtglob = function isExtglob(str) {
-  if (typeof str !== 'string' || str === '') {
-    return false;
-  }
+  exitStatus = 1;
 
-  var match;
-  while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
-    if (match[2]) return true;
-    str = str.slice(match.index + match[0].length);
-  }
+  process$2.stderr.write(message.trim() + '\n', noop$1);
+}
 
-  return false;
-};
+function onexit() {
+  /* eslint-disable unicorn/no-process-exit */
+  process$2.exit(exitStatus);
+  /* eslint-enable unicorn/no-process-exit */
+}
 
-/*!
- * is-glob <https://github.com/jonschlinkert/is-glob>
- *
- * Copyright (c) 2014-2017, Jon Schlinkert.
- * Released under the MIT License.
- */
+function noop$1() {}
 
+var require$$0 = [
+	"md",
+	"markdown",
+	"mdown",
+	"mkdn",
+	"mkd",
+	"mdwn",
+	"mkdown",
+	"ron"
+];
 
-var chars$1 = { '{': '}', '(': ')', '[': ']'};
-var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
-var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
+var markdownExtensions = require$$0;
 
-var isGlob = function isGlob(str, options) {
-  if (typeof str !== 'string' || str === '') {
-    return false;
+/**
+ * Throw a given error.
+ *
+ * @param {Error | null | undefined} [error]
+ */
+function bail(error) {
+  if (error) {
+    throw error
   }
+}
 
-  if (isExtglob(str)) {
-    return true;
-  }
+var hasOwn = Object.prototype.hasOwnProperty;
+var toStr = Object.prototype.toString;
+var defineProperty = Object.defineProperty;
+var gOPD = Object.getOwnPropertyDescriptor;
 
-  var regex = strictRegex;
-  var match;
+var isArray = function isArray(arr) {
+	if (typeof Array.isArray === 'function') {
+		return Array.isArray(arr);
+	}
 
-  // optionally relax regex
-  if (options && options.strict === false) {
-    regex = relaxedRegex;
-  }
+	return toStr.call(arr) === '[object Array]';
+};
 
-  while ((match = regex.exec(str))) {
-    if (match[2]) return true;
-    var idx = match.index + match[0].length;
+var isPlainObject = function isPlainObject(obj) {
+	if (!obj || toStr.call(obj) !== '[object Object]') {
+		return false;
+	}
 
-    // if an open bracket/brace/paren is escaped,
-    // set the index to the next closing character
-    var open = match[1];
-    var close = open ? chars$1[open] : null;
-    if (open && close) {
-      var n = str.indexOf(close, idx);
-      if (n !== -1) {
-        idx = n + 1;
-      }
-    }
+	var hasOwnConstructor = hasOwn.call(obj, 'constructor');
+	var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
+	// Not own constructor property must be Object
+	if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+		return false;
+	}
 
-    str = str.slice(idx);
-  }
-  return false;
+	// Own properties are enumerated firstly, so to speed up,
+	// if last one is own, then all properties are own.
+	var key;
+	for (key in obj) { /**/ }
+
+	return typeof key === 'undefined' || hasOwn.call(obj, key);
 };
 
-var pathPosixDirname = path$1.posix.dirname;
-var isWin32 = os.platform() === 'win32';
+// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
+var setProperty = function setProperty(target, options) {
+	if (defineProperty && options.name === '__proto__') {
+		defineProperty(target, options.name, {
+			enumerable: true,
+			configurable: true,
+			value: options.newValue,
+			writable: true
+		});
+	} else {
+		target[options.name] = options.newValue;
+	}
+};
 
-var slash = '/';
-var backslash = /\\/g;
-var enclosure = /[\{\[].*[\/]*.*[\}\]]$/;
-var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
-var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+// Return undefined instead of __proto__ if '__proto__' is not an own property
+var getProperty = function getProperty(obj, name) {
+	if (name === '__proto__') {
+		if (!hasOwn.call(obj, name)) {
+			return void 0;
+		} else if (gOPD) {
+			// In early versions of node, obj['__proto__'] is buggy when obj has
+			// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
+			return gOPD(obj, name).value;
+		}
+	}
 
-/**
- * @param {string} str
- * @param {Object} opts
- * @param {boolean} [opts.flipBackslashes=true]
- */
-var globParent = function globParent(str, opts) {
-  var options = Object.assign({ flipBackslashes: true }, opts);
+	return obj[name];
+};
 
-  // flip windows path separators
-  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
-    str = str.replace(backslash, slash);
-  }
+var extend = function extend() {
+	var options, name, src, copy, copyIsArray, clone;
+	var target = arguments[0];
+	var i = 1;
+	var length = arguments.length;
+	var deep = false;
 
-  // special case for strings ending in enclosure containing path separator
-  if (enclosure.test(str)) {
-    str += slash;
-  }
+	// Handle a deep copy situation
+	if (typeof target === 'boolean') {
+		deep = target;
+		target = arguments[1] || {};
+		// skip the boolean and the target
+		i = 2;
+	}
+	if (target == null || (typeof target !== 'object' && typeof target !== 'function')) {
+		target = {};
+	}
 
-  // preserves full path in case of trailing path separator
-  str += 'a';
+	for (; i < length; ++i) {
+		options = arguments[i];
+		// Only deal with non-null/undefined values
+		if (options != null) {
+			// Extend the base object
+			for (name in options) {
+				src = getProperty(target, name);
+				copy = getProperty(options, name);
 
-  // remove path parts that are globby
-  do {
-    str = pathPosixDirname(str);
-  } while (isGlob(str) || globby.test(str));
+				// Prevent never-ending loop
+				if (target !== copy) {
+					// Recurse if we're merging plain objects or arrays
+					if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
+						if (copyIsArray) {
+							copyIsArray = false;
+							clone = src && isArray(src) ? src : [];
+						} else {
+							clone = src && isPlainObject(src) ? src : {};
+						}
 
-  // remove escape chars and return result
-  return str.replace(escaped, '$1');
-};
+						// Never move original objects, clone them
+						setProperty(target, { name: name, newValue: extend(deep, clone, copy) });
 
-var utils$1 = createCommonjsModule(function (module, exports) {
+					// Don't bring in undefined values
+					} else if (typeof copy !== 'undefined') {
+						setProperty(target, { name: name, newValue: copy });
+					}
+				}
+			}
+		}
+	}
 
-exports.isInteger = num => {
-  if (typeof num === 'number') {
-    return Number.isInteger(num);
-  }
-  if (typeof num === 'string' && num.trim() !== '') {
-    return Number.isInteger(Number(num));
-  }
-  return false;
+	// Return the modified object
+	return target;
 };
 
 /**
- * Find a node of the given type
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFileCompatible} VFileCompatible
+ * @typedef {import('vfile').VFileValue} VFileValue
+ * @typedef {import('..').Processor} Processor
+ * @typedef {import('..').Plugin} Plugin
+ * @typedef {import('..').Preset} Preset
+ * @typedef {import('..').Pluggable} Pluggable
+ * @typedef {import('..').PluggableList} PluggableList
+ * @typedef {import('..').Transformer} Transformer
+ * @typedef {import('..').Parser} Parser
+ * @typedef {import('..').Compiler} Compiler
+ * @typedef {import('..').RunCallback} RunCallback
+ * @typedef {import('..').ProcessCallback} ProcessCallback
+ *
+ * @typedef Context
+ * @property {Node} tree
+ * @property {VFile} file
  */
 
-exports.find = (node, type) => node.nodes.find(node => node.type === type);
+// Expose a frozen processor.
+const unified = base().freeze();
+
+const own$6 = {}.hasOwnProperty;
 
+// Function to create the first processor.
 /**
- * Find a node of the given type
+ * @returns {Processor}
  */
+function base() {
+  const transformers = trough();
+  /** @type {Processor['attachers']} */
+  const attachers = [];
+  /** @type {Record<string, unknown>} */
+  let namespace = {};
+  /** @type {boolean|undefined} */
+  let frozen;
+  let freezeIndex = -1;
 
-exports.exceedsLimit = (min, max, step = 1, limit) => {
-  if (limit === false) return false;
-  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
-  return ((Number(max) - Number(min)) / Number(step)) >= limit;
-};
+  // Data management.
+  // @ts-expect-error: overloads are handled.
+  processor.data = data;
+  processor.Parser = undefined;
+  processor.Compiler = undefined;
 
-/**
- * Escape the given node with '\\' before node.value
- */
+  // Lock.
+  processor.freeze = freeze;
 
-exports.escapeNode = (block, n = 0, type) => {
-  let node = block.nodes[n];
-  if (!node) return;
+  // Plugins.
+  processor.attachers = attachers;
+  // @ts-expect-error: overloads are handled.
+  processor.use = use;
 
-  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
-    if (node.escaped !== true) {
-      node.value = '\\' + node.value;
-      node.escaped = true;
+  // API.
+  processor.parse = parse;
+  processor.stringify = stringify;
+  // @ts-expect-error: overloads are handled.
+  processor.run = run;
+  processor.runSync = runSync;
+  // @ts-expect-error: overloads are handled.
+  processor.process = process;
+  processor.processSync = processSync;
+
+  // Expose.
+  return processor
+
+  // Create a new processor based on the processor in the current scope.
+  /** @type {Processor} */
+  function processor() {
+    const destination = base();
+    let index = -1;
+
+    while (++index < attachers.length) {
+      destination.use(...attachers[index]);
     }
-  }
-};
 
-/**
- * Returns true if the given brace node should be enclosed in literal braces
- */
+    destination.data(extend(true, {}, namespace));
 
-exports.encloseBrace = node => {
-  if (node.type !== 'brace') return false;
-  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
-    node.invalid = true;
-    return true;
+    return destination
   }
-  return false;
-};
 
-/**
- * Returns true if a brace node is invalid.
- */
+  /**
+   * @param {string|Record<string, unknown>} [key]
+   * @param {unknown} [value]
+   * @returns {unknown}
+   */
+  function data(key, value) {
+    if (typeof key === 'string') {
+      // Set `key`.
+      if (arguments.length === 2) {
+        assertUnfrozen('data', frozen);
+        namespace[key] = value;
+        return processor
+      }
 
-exports.isInvalidBrace = block => {
-  if (block.type !== 'brace') return false;
-  if (block.invalid === true || block.dollar) return true;
-  if ((block.commas >> 0 + block.ranges >> 0) === 0) {
-    block.invalid = true;
-    return true;
-  }
-  if (block.open !== true || block.close !== true) {
-    block.invalid = true;
-    return true;
-  }
-  return false;
-};
+      // Get `key`.
+      return (own$6.call(namespace, key) && namespace[key]) || null
+    }
 
-/**
- * Returns true if a node is an open or close node
- */
+    // Set space.
+    if (key) {
+      assertUnfrozen('data', frozen);
+      namespace = key;
+      return processor
+    }
 
-exports.isOpenOrClose = node => {
-  if (node.type === 'open' || node.type === 'close') {
-    return true;
+    // Get space.
+    return namespace
   }
-  return node.open === true || node.close === true;
-};
 
-/**
- * Reduce an array of text nodes.
- */
+  /** @type {Processor['freeze']} */
+  function freeze() {
+    if (frozen) {
+      return processor
+    }
 
-exports.reduce = nodes => nodes.reduce((acc, node) => {
-  if (node.type === 'text') acc.push(node.value);
-  if (node.type === 'range') node.type = 'text';
-  return acc;
-}, []);
+    while (++freezeIndex < attachers.length) {
+      const [attacher, ...options] = attachers[freezeIndex];
 
-/**
- * Flatten an array
- */
+      if (options[0] === false) {
+        continue
+      }
 
-exports.flatten = (...args) => {
-  const result = [];
-  const flat = arr => {
-    for (let i = 0; i < arr.length; i++) {
-      let ele = arr[i];
-      Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
-    }
-    return result;
-  };
-  flat(args);
-  return result;
-};
-});
-var utils_1$1 = utils$1.isInteger;
-var utils_2$1 = utils$1.find;
-var utils_3$1 = utils$1.exceedsLimit;
-var utils_4$1 = utils$1.escapeNode;
-var utils_5$1 = utils$1.encloseBrace;
-var utils_6$1 = utils$1.isInvalidBrace;
-var utils_7$1 = utils$1.isOpenOrClose;
-var utils_8$1 = utils$1.reduce;
-var utils_9$1 = utils$1.flatten;
-
-var stringify$3 = (ast, options = {}) => {
-  let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils$1.isInvalidBrace(parent);
-    let invalidNode = node.invalid === true && options.escapeInvalid === true;
-    let output = '';
+      if (options[0] === true) {
+        options[1] = undefined;
+      }
 
-    if (node.value) {
-      if ((invalidBlock || invalidNode) && utils$1.isOpenOrClose(node)) {
-        return '\\' + node.value;
+      /** @type {Transformer|void} */
+      const transformer = attacher.call(processor, ...options);
+
+      if (typeof transformer === 'function') {
+        transformers.use(transformer);
       }
-      return node.value;
     }
 
-    if (node.value) {
-      return node.value;
-    }
+    frozen = true;
+    freezeIndex = Number.POSITIVE_INFINITY;
 
-    if (node.nodes) {
-      for (let child of node.nodes) {
-        output += stringify(child);
+    return processor
+  }
+
+  /**
+   * @param {Pluggable|null|undefined} [value]
+   * @param {...unknown} options
+   * @returns {Processor}
+   */
+  function use(value, ...options) {
+    /** @type {Record<string, unknown>|undefined} */
+    let settings;
+
+    assertUnfrozen('use', frozen);
+
+    if (value === null || value === undefined) ; else if (typeof value === 'function') {
+      addPlugin(value, ...options);
+    } else if (typeof value === 'object') {
+      if (Array.isArray(value)) {
+        addList(value);
+      } else {
+        addPreset(value);
       }
+    } else {
+      throw new TypeError('Expected usable value, not `' + value + '`')
     }
-    return output;
-  };
 
-  return stringify(ast);
-};
+    if (settings) {
+      namespace.settings = Object.assign(namespace.settings || {}, settings);
+    }
 
-/*!
- * is-number <https://github.com/jonschlinkert/is-number>
- *
- * Copyright (c) 2014-present, Jon Schlinkert.
- * Released under the MIT License.
- */
+    return processor
 
-var isNumber = function(num) {
-  if (typeof num === 'number') {
-    return num - num === 0;
-  }
-  if (typeof num === 'string' && num.trim() !== '') {
-    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
-  }
-  return false;
-};
+    /**
+     * @param {import('..').Pluggable<unknown[]>} value
+     * @returns {void}
+     */
+    function add(value) {
+      if (typeof value === 'function') {
+        addPlugin(value);
+      } else if (typeof value === 'object') {
+        if (Array.isArray(value)) {
+          const [plugin, ...options] = value;
+          addPlugin(plugin, ...options);
+        } else {
+          addPreset(value);
+        }
+      } else {
+        throw new TypeError('Expected usable value, not `' + value + '`')
+      }
+    }
 
-const toRegexRange = (min, max, options) => {
-  if (isNumber(min) === false) {
-    throw new TypeError('toRegexRange: expected the first argument to be a number');
-  }
+    /**
+     * @param {Preset} result
+     * @returns {void}
+     */
+    function addPreset(result) {
+      addList(result.plugins);
 
-  if (max === void 0 || min === max) {
-    return String(min);
-  }
+      if (result.settings) {
+        settings = Object.assign(settings || {}, result.settings);
+      }
+    }
 
-  if (isNumber(max) === false) {
-    throw new TypeError('toRegexRange: expected the second argument to be a number.');
-  }
+    /**
+     * @param {PluggableList|null|undefined} [plugins]
+     * @returns {void}
+     */
+    function addList(plugins) {
+      let index = -1;
 
-  let opts = { relaxZeros: true, ...options };
-  if (typeof opts.strictZeros === 'boolean') {
-    opts.relaxZeros = opts.strictZeros === false;
-  }
+      if (plugins === null || plugins === undefined) ; else if (Array.isArray(plugins)) {
+        while (++index < plugins.length) {
+          const thing = plugins[index];
+          add(thing);
+        }
+      } else {
+        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')
+      }
+    }
 
-  let relax = String(opts.relaxZeros);
-  let shorthand = String(opts.shorthand);
-  let capture = String(opts.capture);
-  let wrap = String(opts.wrap);
-  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+    /**
+     * @param {Plugin} plugin
+     * @param {...unknown} [value]
+     * @returns {void}
+     */
+    function addPlugin(plugin, value) {
+      let index = -1;
+      /** @type {Processor['attachers'][number]|undefined} */
+      let entry;
 
-  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
-    return toRegexRange.cache[cacheKey].result;
-  }
+      while (++index < attachers.length) {
+        if (attachers[index][0] === plugin) {
+          entry = attachers[index];
+          break
+        }
+      }
 
-  let a = Math.min(min, max);
-  let b = Math.max(min, max);
+      if (entry) {
+        if (isPlainObject$1(entry[1]) && isPlainObject$1(value)) {
+          value = extend(true, entry[1], value);
+        }
 
-  if (Math.abs(a - b) === 1) {
-    let result = min + '|' + max;
-    if (opts.capture) {
-      return `(${result})`;
-    }
-    if (opts.wrap === false) {
-      return result;
+        entry[1] = value;
+      } else {
+        // @ts-expect-error: fine.
+        attachers.push([...arguments]);
+      }
     }
-    return `(?:${result})`;
   }
 
-  let isPadded = hasPadding(min) || hasPadding(max);
-  let state = { min, max, a, b };
-  let positives = [];
-  let negatives = [];
+  /** @type {Processor['parse']} */
+  function parse(doc) {
+    processor.freeze();
+    const file = vfile(doc);
+    const Parser = processor.Parser;
+    assertParser('parse', Parser);
 
-  if (isPadded) {
-    state.isPadded = isPadded;
-    state.maxLen = String(state.max).length;
-  }
+    if (newable(Parser, 'parse')) {
+      // @ts-expect-error: `newable` checks this.
+      return new Parser(String(file), file).parse()
+    }
 
-  if (a < 0) {
-    let newMin = b < 0 ? Math.abs(b) : 1;
-    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
-    a = state.a = 0;
+    // @ts-expect-error: `newable` checks this.
+    return Parser(String(file), file) // eslint-disable-line new-cap
   }
 
-  if (b >= 0) {
-    positives = splitToPatterns(a, b, state, opts);
-  }
+  /** @type {Processor['stringify']} */
+  function stringify(node, doc) {
+    processor.freeze();
+    const file = vfile(doc);
+    const Compiler = processor.Compiler;
+    assertCompiler('stringify', Compiler);
+    assertNode(node);
 
-  state.negatives = negatives;
-  state.positives = positives;
-  state.result = collatePatterns(negatives, positives);
+    if (newable(Compiler, 'compile')) {
+      // @ts-expect-error: `newable` checks this.
+      return new Compiler(node, file).compile()
+    }
 
-  if (opts.capture === true) {
-    state.result = `(${state.result})`;
-  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
-    state.result = `(?:${state.result})`;
+    // @ts-expect-error: `newable` checks this.
+    return Compiler(node, file) // eslint-disable-line new-cap
   }
 
-  toRegexRange.cache[cacheKey] = state;
-  return state.result;
-};
+  /**
+   * @param {Node} node
+   * @param {VFileCompatible|RunCallback} [doc]
+   * @param {RunCallback} [callback]
+   * @returns {Promise<Node>|void}
+   */
+  function run(node, doc, callback) {
+    assertNode(node);
+    processor.freeze();
 
-function collatePatterns(neg, pos, options) {
-  let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
-  let onlyPositive = filterPatterns(pos, neg, '', false) || [];
-  let intersected = filterPatterns(neg, pos, '-?', true) || [];
-  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
-  return subpatterns.join('|');
-}
+    if (!callback && typeof doc === 'function') {
+      callback = doc;
+      doc = undefined;
+    }
 
-function splitToRanges(min, max) {
-  let nines = 1;
-  let zeros = 1;
+    if (!callback) {
+      return new Promise(executor)
+    }
 
-  let stop = countNines(min, nines);
-  let stops = new Set([max]);
+    executor(null, callback);
 
-  while (min <= stop && stop <= max) {
-    stops.add(stop);
-    nines += 1;
-    stop = countNines(min, nines);
+    /**
+     * @param {null|((node: Node) => void)} resolve
+     * @param {(error: Error) => void} reject
+     * @returns {void}
+     */
+    function executor(resolve, reject) {
+      // @ts-expect-error: `doc` can’t be a callback anymore, we checked.
+      transformers.run(node, vfile(doc), done);
+
+      /**
+       * @param {Error|null} error
+       * @param {Node} tree
+       * @param {VFile} file
+       * @returns {void}
+       */
+      function done(error, tree, file) {
+        tree = tree || node;
+        if (error) {
+          reject(error);
+        } else if (resolve) {
+          resolve(tree);
+        } else {
+          // @ts-expect-error: `callback` is defined if `resolve` is not.
+          callback(null, tree, file);
+        }
+      }
+    }
   }
 
-  stop = countZeros(max + 1, zeros) - 1;
+  /** @type {Processor['runSync']} */
+  function runSync(node, file) {
+    /** @type {Node|undefined} */
+    let result;
+    /** @type {boolean|undefined} */
+    let complete;
 
-  while (min < stop && stop <= max) {
-    stops.add(stop);
-    zeros += 1;
-    stop = countZeros(max + 1, zeros) - 1;
-  }
+    processor.run(node, file, done);
 
-  stops = [...stops];
-  stops.sort(compare$1);
-  return stops;
-}
+    assertDone('runSync', 'run', complete);
 
-/**
- * Convert a range to a regex pattern
- * @param {Number} `start`
- * @param {Number} `stop`
- * @return {String}
- */
+    // @ts-expect-error: we either bailed on an error or have a tree.
+    return result
 
-function rangeToPattern(start, stop, options) {
-  if (start === stop) {
-    return { pattern: start, count: [], digits: 0 };
+    /**
+     * @param {Error|null} [error]
+     * @param {Node} [tree]
+     * @returns {void}
+     */
+    function done(error, tree) {
+      bail(error);
+      result = tree;
+      complete = true;
+    }
   }
 
-  let zipped = zip(start, stop);
-  let digits = zipped.length;
-  let pattern = '';
-  let count = 0;
+  /**
+   * @param {VFileCompatible} doc
+   * @param {ProcessCallback} [callback]
+   * @returns {Promise<VFile>|undefined}
+   */
+  function process(doc, callback) {
+    processor.freeze();
+    assertParser('process', processor.Parser);
+    assertCompiler('process', processor.Compiler);
 
-  for (let i = 0; i < digits; i++) {
-    let [startDigit, stopDigit] = zipped[i];
+    if (!callback) {
+      return new Promise(executor)
+    }
 
-    if (startDigit === stopDigit) {
-      pattern += startDigit;
+    executor(null, callback);
 
-    } else if (startDigit !== '0' || stopDigit !== '9') {
-      pattern += toCharacterClass(startDigit, stopDigit);
+    /**
+     * @param {null|((file: VFile) => void)} resolve
+     * @param {(error?: Error|null|undefined) => void} reject
+     * @returns {void}
+     */
+    function executor(resolve, reject) {
+      const file = vfile(doc);
 
-    } else {
-      count++;
+      processor.run(processor.parse(file), file, (error, tree, file) => {
+        if (error || !tree || !file) {
+          done(error);
+        } else {
+          /** @type {unknown} */
+          const result = processor.stringify(tree, file);
+
+          if (result === undefined || result === null) ; else if (looksLikeAVFileValue(result)) {
+            file.value = result;
+          } else {
+            file.result = result;
+          }
+
+          done(error, file);
+        }
+      });
+
+      /**
+       * @param {Error|null|undefined} [error]
+       * @param {VFile|undefined} [file]
+       * @returns {void}
+       */
+      function done(error, file) {
+        if (error || !file) {
+          reject(error);
+        } else if (resolve) {
+          resolve(file);
+        } else {
+          // @ts-expect-error: `callback` is defined if `resolve` is not.
+          callback(null, file);
+        }
+      }
     }
   }
 
-  if (count) {
-    pattern += options.shorthand === true ? '\\d' : '[0-9]';
-  }
+  /** @type {Processor['processSync']} */
+  function processSync(doc) {
+    /** @type {boolean|undefined} */
+    let complete;
 
-  return { pattern, count: [count], digits };
-}
+    processor.freeze();
+    assertParser('processSync', processor.Parser);
+    assertCompiler('processSync', processor.Compiler);
 
-function splitToPatterns(min, max, tok, options) {
-  let ranges = splitToRanges(min, max);
-  let tokens = [];
-  let start = min;
-  let prev;
+    const file = vfile(doc);
 
-  for (let i = 0; i < ranges.length; i++) {
-    let max = ranges[i];
-    let obj = rangeToPattern(String(start), String(max), options);
-    let zeros = '';
+    processor.process(file, done);
 
-    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
-      if (prev.count.length > 1) {
-        prev.count.pop();
-      }
+    assertDone('processSync', 'process', complete);
 
-      prev.count.push(obj.count[0]);
-      prev.string = prev.pattern + toQuantifier(prev.count);
-      start = max + 1;
-      continue;
-    }
+    return file
 
-    if (tok.isPadded) {
-      zeros = padZeros(max, tok, options);
+    /**
+     * @param {Error|null|undefined} [error]
+     * @returns {void}
+     */
+    function done(error) {
+      complete = true;
+      bail(error);
     }
-
-    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
-    tokens.push(obj);
-    start = max + 1;
-    prev = obj;
   }
-
-  return tokens;
 }
 
-function filterPatterns(arr, comparison, prefix, intersection, options) {
-  let result = [];
+/**
+ * Check if `value` is a constructor.
+ *
+ * @param {unknown} value
+ * @param {string} name
+ * @returns {boolean}
+ */
+function newable(value, name) {
+  return (
+    typeof value === 'function' &&
+    // Prototypes do exist.
+    // type-coverage:ignore-next-line
+    value.prototype &&
+    // A function with keys in its prototype is probably a constructor.
+    // Classes’ prototype methods are not enumerable, so we check if some value
+    // exists in the prototype.
+    // type-coverage:ignore-next-line
+    (keys(value.prototype) || name in value.prototype)
+  )
+}
 
-  for (let ele of arr) {
-    let { string } = ele;
+/**
+ * Check if `value` is an object with keys.
+ *
+ * @param {Record<string, unknown>} value
+ * @returns {boolean}
+ */
+function keys(value) {
+  /** @type {string} */
+  let key;
 
-    // only push if _both_ are negative...
-    if (!intersection && !contains(comparison, 'string', string)) {
-      result.push(prefix + string);
+  for (key in value) {
+    if (own$6.call(value, key)) {
+      return true
     }
+  }
 
-    // or _both_ are positive
-    if (intersection && contains(comparison, 'string', string)) {
-      result.push(prefix + string);
-    }
+  return false
+}
+
+/**
+ * Assert a parser is available.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {asserts value is Parser}
+ */
+function assertParser(name, value) {
+  if (typeof value !== 'function') {
+    throw new TypeError('Cannot `' + name + '` without `Parser`')
   }
-  return result;
 }
 
 /**
- * Zip strings
+ * Assert a compiler is available.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {asserts value is Compiler}
  */
+function assertCompiler(name, value) {
+  if (typeof value !== 'function') {
+    throw new TypeError('Cannot `' + name + '` without `Compiler`')
+  }
+}
 
-function zip(a, b) {
-  let arr = [];
-  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
-  return arr;
+/**
+ * Assert the processor is not frozen.
+ *
+ * @param {string} name
+ * @param {unknown} frozen
+ * @returns {asserts frozen is false}
+ */
+function assertUnfrozen(name, frozen) {
+  if (frozen) {
+    throw new Error(
+      'Cannot call `' +
+        name +
+        '` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'
+    )
+  }
 }
 
-function compare$1(a, b) {
-  return a > b ? 1 : b > a ? -1 : 0;
+/**
+ * Assert `node` is a unist node.
+ *
+ * @param {unknown} node
+ * @returns {asserts node is Node}
+ */
+function assertNode(node) {
+  // `isPlainObj` unfortunately uses `any` instead of `unknown`.
+  // type-coverage:ignore-next-line
+  if (!isPlainObject$1(node) || typeof node.type !== 'string') {
+    throw new TypeError('Expected node, got `' + node + '`')
+    // Fine.
+  }
 }
 
-function contains(arr, key, val) {
-  return arr.some(ele => ele[key] === val);
+/**
+ * Assert that `complete` is `true`.
+ *
+ * @param {string} name
+ * @param {string} asyncName
+ * @param {unknown} complete
+ * @returns {asserts complete is true}
+ */
+function assertDone(name, asyncName, complete) {
+  if (!complete) {
+    throw new Error(
+      '`' + name + '` finished async. Use `' + asyncName + '` instead'
+    )
+  }
 }
 
-function countNines(min, len) {
-  return Number(String(min).slice(0, -len) + '9'.repeat(len));
+/**
+ * @param {VFileCompatible} [value]
+ * @returns {VFile}
+ */
+function vfile(value) {
+  return looksLikeAVFile(value) ? value : new VFile(value)
 }
 
-function countZeros(integer, zeros) {
-  return integer - (integer % Math.pow(10, zeros));
+/**
+ * @param {VFileCompatible} [value]
+ * @returns {value is VFile}
+ */
+function looksLikeAVFile(value) {
+  return Boolean(
+    value &&
+      typeof value === 'object' &&
+      'message' in value &&
+      'messages' in value
+  )
 }
 
-function toQuantifier(digits) {
-  let [start = 0, stop = ''] = digits;
-  if (stop || start > 1) {
-    return `{${start + (stop ? ',' + stop : '')}}`;
-  }
-  return '';
+/**
+ * @param {unknown} [value]
+ * @returns {value is VFileValue}
+ */
+function looksLikeAVFileValue(value) {
+  return typeof value === 'string' || isBuffer(value)
 }
 
-function toCharacterClass(a, b, options) {
-  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+/**
+ * @typedef Options
+ * @property {boolean} [includeImageAlt=true]
+ */
+
+/**
+ * Get the text content of a node.
+ * Prefer the node’s plain-text fields, otherwise serialize its children,
+ * and if the given value is an array, serialize the nodes in it.
+ *
+ * @param {unknown} node
+ * @param {Options} [options]
+ * @returns {string}
+ */
+function toString(node, options) {
+  var {includeImageAlt = true} = options || {};
+  return one(node, includeImageAlt)
 }
 
-function hasPadding(str) {
-  return /^-?(0+)\d/.test(str);
+/**
+ * @param {unknown} node
+ * @param {boolean} includeImageAlt
+ * @returns {string}
+ */
+function one(node, includeImageAlt) {
+  return (
+    (node &&
+      typeof node === 'object' &&
+      // @ts-ignore looks like a literal.
+      (node.value ||
+        // @ts-ignore looks like an image.
+        (includeImageAlt ? node.alt : '') ||
+        // @ts-ignore looks like a parent.
+        ('children' in node && all(node.children, includeImageAlt)) ||
+        (Array.isArray(node) && all(node, includeImageAlt)))) ||
+    ''
+  )
 }
 
-function padZeros(value, tok, options) {
-  if (!tok.isPadded) {
-    return value;
+/**
+ * @param {Array.<unknown>} values
+ * @param {boolean} includeImageAlt
+ * @returns {string}
+ */
+function all(values, includeImageAlt) {
+  /** @type {Array.<string>} */
+  var result = [];
+  var index = -1;
+
+  while (++index < values.length) {
+    result[index] = one(values[index], includeImageAlt);
   }
 
-  let diff = Math.abs(tok.maxLen - String(value).length);
-  let relax = options.relaxZeros !== false;
+  return result.join('')
+}
 
-  switch (diff) {
-    case 0:
-      return '';
-    case 1:
-      return relax ? '0?' : '0';
-    case 2:
-      return relax ? '0{0,2}' : '00';
-    default: {
-      return relax ? `0{0,${diff}}` : `0{${diff}}`;
+/**
+ * Like `Array#splice`, but smarter for giant arrays.
+ *
+ * `Array#splice` takes all items to be inserted as individual argument which
+ * causes a stack overflow in V8 when trying to insert 100k items for instance.
+ *
+ * Otherwise, this does not return the removed items, and takes `items` as an
+ * array instead of rest parameters.
+ *
+ * @template {unknown} T
+ * @param {T[]} list
+ * @param {number} start
+ * @param {number} remove
+ * @param {T[]} items
+ * @returns {void}
+ */
+function splice(list, start, remove, items) {
+  const end = list.length;
+  let chunkStart = 0;
+  /** @type {unknown[]} */
+
+  let parameters; // Make start between zero and `end` (included).
+
+  if (start < 0) {
+    start = -start > end ? 0 : end + start;
+  } else {
+    start = start > end ? end : start;
+  }
+
+  remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.
+
+  if (items.length < 10000) {
+    parameters = Array.from(items);
+    parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.
+    ;[].splice.apply(list, parameters);
+  } else {
+    // Delete `remove` items starting from `start`
+    if (remove) [].splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.
+
+    while (chunkStart < items.length) {
+      parameters = items.slice(chunkStart, chunkStart + 10000);
+      parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.
+      ;[].splice.apply(list, parameters);
+      chunkStart += 10000;
+      start += 10000;
     }
   }
 }
-
 /**
- * Cache
+ * Append `items` (an array) at the end of `list` (another array).
+ * When `list` was empty, returns `items` instead.
+ *
+ * This prevents a potentially expensive operation when `list` is empty,
+ * and adds items in batches to prevent V8 from hanging.
+ *
+ * @template {unknown} T
+ * @param {T[]} list
+ * @param {T[]} items
+ * @returns {T[]}
  */
 
-toRegexRange.cache = {};
-toRegexRange.clearCache = () => (toRegexRange.cache = {});
+function push(list, items) {
+  if (list.length > 0) {
+    splice(list, list.length, 0, items);
+    return list
+  }
+
+  return items
+}
 
 /**
- * Expose `toRegexRange`
+ * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
  */
 
-var toRegexRange_1 = toRegexRange;
+const hasOwnProperty = {}.hasOwnProperty;
 
-const isObject$2 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+/**
+ * Combine several syntax extensions into one.
+ *
+ * @param {Extension[]} extensions List of syntax extensions.
+ * @returns {NormalizedExtension} A single combined extension.
+ */
+function combineExtensions(extensions) {
+  /** @type {NormalizedExtension} */
+  const all = {};
+  let index = -1;
 
-const transform$2 = toNumber => {
-  return value => toNumber === true ? Number(value) : String(value);
-};
+  while (++index < extensions.length) {
+    syntaxExtension(all, extensions[index]);
+  }
 
-const isValidValue = value => {
-  return typeof value === 'number' || (typeof value === 'string' && value !== '');
-};
+  return all
+}
 
-const isNumber$1 = num => Number.isInteger(+num);
+/**
+ * Merge `extension` into `all`.
+ *
+ * @param {NormalizedExtension} all Extension to merge into.
+ * @param {Extension} extension Extension to merge.
+ * @returns {void}
+ */
+function syntaxExtension(all, extension) {
+  /** @type {string} */
+  let hook;
+
+  for (hook in extension) {
+    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;
+    const left = maybe || (all[hook] = {});
+    const right = extension[hook];
+    /** @type {string} */
+    let code;
+
+    for (code in right) {
+      if (!hasOwnProperty.call(left, code)) left[code] = [];
+      const value = right[code];
+      constructs(
+        // @ts-expect-error Looks like a list.
+        left[code],
+        Array.isArray(value) ? value : value ? [value] : []
+      );
+    }
+  }
+}
 
-const zeros = input => {
-  let value = `${input}`;
+/**
+ * Merge `list` into `existing` (both lists of constructs).
+ * Mutates `existing`.
+ *
+ * @param {unknown[]} existing
+ * @param {unknown[]} list
+ * @returns {void}
+ */
+function constructs(existing, list) {
   let index = -1;
-  if (value[0] === '-') value = value.slice(1);
-  if (value === '0') return false;
-  while (value[++index] === '0');
-  return index > 0;
-};
+  /** @type {unknown[]} */
+  const before = [];
 
-const stringify$4 = (start, end, options) => {
-  if (typeof start === 'string' || typeof end === 'string') {
-    return true;
+  while (++index < list.length) {
+(list[index].add === 'after' ? existing : before).push(list[index]);
   }
-  return options.stringify === true;
-};
 
-const pad = (input, maxLength, toNumber) => {
-  if (maxLength > 0) {
-    let dash = input[0] === '-' ? '-' : '';
-    if (dash) input = input.slice(1);
-    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
-  }
-  if (toNumber === false) {
-    return String(input);
-  }
-  return input;
-};
+  splice(existing, 0, 0, before);
+}
 
-const toMaxLen = (input, maxLength) => {
-  let negative = input[0] === '-' ? '-' : '';
-  if (negative) {
-    input = input.slice(1);
-    maxLength--;
+/**
+ * Combine several HTML extensions into one.
+ *
+ * @param {HtmlExtension[]} htmlExtensions List of HTML extensions.
+ * @returns {HtmlExtension} A single combined extension.
+ */
+function combineHtmlExtensions(htmlExtensions) {
+  /** @type {HtmlExtension} */
+  const handlers = {};
+  let index = -1;
+
+  while (++index < htmlExtensions.length) {
+    htmlExtension(handlers, htmlExtensions[index]);
   }
-  while (input.length < maxLength) input = '0' + input;
-  return negative ? ('-' + input) : input;
-};
 
-const toSequence = (parts, options) => {
-  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return handlers
+}
 
-  let prefix = options.capture ? '' : '?:';
-  let positives = '';
-  let negatives = '';
-  let result;
+/**
+ * Merge `extension` into `all`.
+ *
+ * @param {HtmlExtension} all Extension to merge into.
+ * @param {HtmlExtension} extension Extension to merge.
+ * @returns {void}
+ */
+function htmlExtension(all, extension) {
+  /** @type {string} */
+  let hook;
 
-  if (parts.positives.length) {
-    positives = parts.positives.join('|');
-  }
+  for (hook in extension) {
+    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;
+    const left = maybe || (all[hook] = {});
+    const right = extension[hook];
+    /** @type {string} */
+    let type;
 
-  if (parts.negatives.length) {
-    negatives = `-(${prefix}${parts.negatives.join('|')})`;
+    if (right) {
+      for (type in right) {
+        left[type] = right[type];
+      }
+    }
   }
+}
 
-  if (positives && negatives) {
-    result = `${positives}|${negatives}`;
-  } else {
-    result = positives || negatives;
-  }
+// This module is generated by `script/`.
+//
+// CommonMark handles attention (emphasis, strong) markers based on what comes
+// before or after them.
+// One such difference is if those characters are Unicode punctuation.
+// This script is generated from the Unicode data.
+const unicodePunctuationRegex =
+  /[!-/:-@[-`{-~\u00A1\u00A7\u00AB\u00B6\u00B7\u00BB\u00BF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/;
 
-  if (options.wrap) {
-    return `(${prefix}${result})`;
-  }
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+/**
+ * Check whether the character code represents an ASCII alpha (`a` through `z`,
+ * case insensitive).
+ *
+ * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
+ *
+ * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
+ * to U+005A (`Z`).
+ *
+ * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
+ * to U+007A (`z`).
+ */
 
-  return result;
-};
+const asciiAlpha = regexCheck(/[A-Za-z]/);
+/**
+ * Check whether the character code represents an ASCII digit (`0` through `9`).
+ *
+ * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
+ * U+0039 (`9`).
+ */
 
-const toRange = (a, b, isNumbers, options) => {
-  if (isNumbers) {
-    return toRegexRange_1(a, b, { wrap: false, ...options });
-  }
+const asciiDigit = regexCheck(/\d/);
+/**
+ * Check whether the character code represents an ASCII hex digit (`a` through
+ * `f`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
+ * digit, or an ASCII lower hex digit.
+ *
+ * An **ASCII upper hex digit** is a character in the inclusive range U+0041
+ * (`A`) to U+0046 (`F`).
+ *
+ * An **ASCII lower hex digit** is a character in the inclusive range U+0061
+ * (`a`) to U+0066 (`f`).
+ */
 
-  let start = String.fromCharCode(a);
-  if (a === b) return start;
+const asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
+/**
+ * Check whether the character code represents an ASCII alphanumeric (`a`
+ * through `z`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
+ * (see `asciiAlpha`).
+ */
 
-  let stop = String.fromCharCode(b);
-  return `[${start}-${stop}]`;
-};
+const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
+/**
+ * Check whether the character code represents ASCII punctuation.
+ *
+ * An **ASCII punctuation** is a character in the inclusive ranges U+0021
+ * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
+ * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
+ * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
+ */
 
-const toRegex = (start, end, options) => {
-  if (Array.isArray(start)) {
-    let wrap = options.wrap === true;
-    let prefix = options.capture ? '' : '?:';
-    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
-  }
-  return toRegexRange_1(start, end, options);
-};
+const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
+/**
+ * Check whether the character code represents an ASCII atext.
+ *
+ * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
+ * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
+ * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
+ * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
+ * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
+ * (`{`) to U+007E TILDE (`~`).
+ *
+ * See:
+ * **\[RFC5322]**:
+ * [Internet Message Format](https://tools.ietf.org/html/rfc5322).
+ * P. Resnick.
+ * IETF.
+ */
 
-const rangeError = (...args) => {
-  return new RangeError('Invalid range arguments: ' + util$2.inspect(...args));
-};
+const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
+/**
+ * Check whether a character code is an ASCII control character.
+ *
+ * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+ * to U+001F (US), or U+007F (DEL).
+ *
+ * @param {Code} code
+ * @returns {code is number}
+ */
 
-const invalidRange = (start, end, options) => {
-  if (options.strictRanges === true) throw rangeError([start, end]);
-  return [];
-};
+function asciiControl(code) {
+  return (
+    // Special whitespace codes (which have negative values), C0 and Control
+    // character DEL
+    code !== null && (code < 32 || code === 127)
+  )
+}
+/**
+ * Check whether a character code is a markdown line ending (see
+ * `markdownLineEnding`) or markdown space (see `markdownSpace`).
+ *
+ * @param {Code} code
+ * @returns {code is number}
+ */
 
-const invalidStep = (step, options) => {
-  if (options.strictRanges === true) {
-    throw new TypeError(`Expected step "${step}" to be a number`);
-  }
-  return [];
-};
+function markdownLineEndingOrSpace(code) {
+  return code !== null && (code < 0 || code === 32)
+}
+/**
+ * Check whether a character code is a markdown line ending.
+ *
+ * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+ * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+ *
+ * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+ * RETURN (CR) are replaced by these virtual characters depending on whether
+ * they occurred together.
+ *
+ * @param {Code} code
+ * @returns {code is number}
+ */
 
-const fillNumbers = (start, end, step = 1, options = {}) => {
-  let a = Number(start);
-  let b = Number(end);
+function markdownLineEnding(code) {
+  return code !== null && code < -2
+}
+/**
+ * Check whether a character code is a markdown space.
+ *
+ * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+ * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+ *
+ * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+ * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+ * SPACE (VS) characters, depending on the column at which the tab occurred.
+ *
+ * @param {Code} code
+ * @returns {code is number}
+ */
 
-  if (!Number.isInteger(a) || !Number.isInteger(b)) {
-    if (options.strictRanges === true) throw rangeError([start, end]);
-    return [];
-  }
+function markdownSpace(code) {
+  return code === -2 || code === -1 || code === 32
+}
+/**
+ * Check whether the character code represents Unicode whitespace.
+ *
+ * Note that this does handle micromark specific markdown whitespace characters.
+ * See `markdownLineEndingOrSpace` to check that.
+ *
+ * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+ * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+ * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ */
 
-  // fix negative zero
-  if (a === 0) a = 0;
-  if (b === 0) b = 0;
+const unicodeWhitespace = regexCheck(/\s/);
+/**
+ * Check whether the character code represents Unicode punctuation.
+ *
+ * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+ * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+ * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+ * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+ * punctuation (see `asciiPunctuation`).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ */
+// Size note: removing ASCII from the regex and using `asciiPunctuation` here
+// In fact adds to the bundle size.
 
-  let descending = a > b;
-  let startString = String(start);
-  let endString = String(end);
-  let stepString = String(step);
-  step = Math.max(Math.abs(step), 1);
+const unicodePunctuation = regexCheck(unicodePunctuationRegex);
+/**
+ * Create a code check from a regex.
+ *
+ * @param {RegExp} regex
+ * @returns {(code: Code) => code is number}
+ */
 
-  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
-  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
-  let toNumber = padded === false && stringify$4(start, end, options) === false;
-  let format = options.transform || transform$2(toNumber);
+function regexCheck(regex) {
+  return check
+  /**
+   * Check whether a code matches the bound regex.
+   *
+   * @param {Code} code Character code
+   * @returns {code is number} Whether the character code matches the bound regex
+   */
 
-  if (options.toRegex && step === 1) {
-    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+  function check(code) {
+    return code !== null && regex.test(String.fromCharCode(code))
   }
+}
 
-  let parts = { negatives: [], positives: [] };
-  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
-  let range = [];
-  let index = 0;
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ */
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {string} type
+ * @param {number} [max=Infinity]
+ * @returns {State}
+ */
 
-  while (descending ? a >= b : a <= b) {
-    if (options.toRegex === true && step > 1) {
-      push(a);
-    } else {
-      range.push(pad(format(a, index), maxLen, toNumber));
+function factorySpace(effects, ok, type, max) {
+  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+  let size = 0;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    if (markdownSpace(code)) {
+      effects.enter(type);
+      return prefix(code)
     }
-    a = descending ? a - step : a + step;
-    index++;
-  }
 
-  if (options.toRegex === true) {
-    return step > 1
-      ? toSequence(parts, options)
-      : toRegex(range, null, { wrap: false, ...options });
+    return ok(code)
   }
+  /** @type {State} */
 
-  return range;
-};
+  function prefix(code) {
+    if (markdownSpace(code) && size++ < limit) {
+      effects.consume(code);
+      return prefix
+    }
 
-const fillLetters = (start, end, step = 1, options = {}) => {
-  if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {
-    return invalidRange(start, end, options);
+    effects.exit(type);
+    return ok(code)
   }
+}
 
+/**
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').Initializer} Initializer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
 
-  let format = options.transform || (val => String.fromCharCode(val));
-  let a = `${start}`.charCodeAt(0);
-  let b = `${end}`.charCodeAt(0);
+/** @type {InitialConstruct} */
+const content$1 = {
+  tokenize: initializeContent
+};
+/** @type {Initializer} */
 
-  let descending = a > b;
-  let min = Math.min(a, b);
-  let max = Math.max(a, b);
+function initializeContent(effects) {
+  const contentStart = effects.attempt(
+    this.parser.constructs.contentInitial,
+    afterContentStartConstruct,
+    paragraphInitial
+  );
+  /** @type {Token} */
 
-  if (options.toRegex && step === 1) {
-    return toRange(min, max, false, options);
-  }
+  let previous;
+  return contentStart
+  /** @type {State} */
 
-  let range = [];
-  let index = 0;
+  function afterContentStartConstruct(code) {
+    if (code === null) {
+      effects.consume(code);
+      return
+    }
 
-  while (descending ? a >= b : a <= b) {
-    range.push(format(a, index));
-    a = descending ? a - step : a + step;
-    index++;
+    effects.enter('lineEnding');
+    effects.consume(code);
+    effects.exit('lineEnding');
+    return factorySpace(effects, contentStart, 'linePrefix')
   }
+  /** @type {State} */
 
-  if (options.toRegex === true) {
-    return toRegex(range, null, { wrap: false, options });
+  function paragraphInitial(code) {
+    effects.enter('paragraph');
+    return lineStart(code)
   }
+  /** @type {State} */
 
-  return range;
-};
-
-const fill = (start, end, step, options = {}) => {
-  if (end == null && isValidValue(start)) {
-    return [start];
-  }
+  function lineStart(code) {
+    const token = effects.enter('chunkText', {
+      contentType: 'text',
+      previous
+    });
 
-  if (!isValidValue(start) || !isValidValue(end)) {
-    return invalidRange(start, end, options);
-  }
+    if (previous) {
+      previous.next = token;
+    }
 
-  if (typeof step === 'function') {
-    return fill(start, end, 1, { transform: step });
+    previous = token;
+    return data(code)
   }
+  /** @type {State} */
 
-  if (isObject$2(step)) {
-    return fill(start, end, 0, step);
-  }
+  function data(code) {
+    if (code === null) {
+      effects.exit('chunkText');
+      effects.exit('paragraph');
+      effects.consume(code);
+      return
+    }
 
-  let opts = { ...options };
-  if (opts.capture === true) opts.wrap = true;
-  step = step || opts.step || 1;
+    if (markdownLineEnding(code)) {
+      effects.consume(code);
+      effects.exit('chunkText');
+      return lineStart
+    } // Data.
 
-  if (!isNumber$1(step)) {
-    if (step != null && !isObject$2(step)) return invalidStep(step, opts);
-    return fill(start, end, 1, step);
+    effects.consume(code);
+    return data
   }
+}
 
-  if (isNumber$1(start) && isNumber$1(end)) {
-    return fillNumbers(start, end, step, opts);
-  }
+/**
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').Initializer} Initializer
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Point} Point
+ */
+/** @type {InitialConstruct} */
 
-  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+const document$2 = {
+  tokenize: initializeDocument
 };
+/** @type {Construct} */
 
-var fillRange = fill;
+const containerConstruct = {
+  tokenize: tokenizeContainer
+};
+/** @type {Initializer} */
 
-const compile$2 = (ast, options = {}) => {
-  let walk = (node, parent = {}) => {
-    let invalidBlock = utils$1.isInvalidBrace(parent);
-    let invalidNode = node.invalid === true && options.escapeInvalid === true;
-    let invalid = invalidBlock === true || invalidNode === true;
-    let prefix = options.escapeInvalid === true ? '\\' : '';
-    let output = '';
+function initializeDocument(effects) {
+  const self = this;
+  /** @type {StackItem[]} */
 
-    if (node.isOpen === true) {
-      return prefix + node.value;
-    }
-    if (node.isClose === true) {
-      return prefix + node.value;
+  const stack = [];
+  let continued = 0;
+  /** @type {TokenizeContext|undefined} */
+
+  let childFlow;
+  /** @type {Token|undefined} */
+
+  let childToken;
+  /** @type {number} */
+
+  let lineStartOffset;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    // First we iterate through the open blocks, starting with the root
+    // document, and descending through last children down to the last open
+    // block.
+    // Each block imposes a condition that the line must satisfy if the block is
+    // to remain open.
+    // For example, a block quote requires a `>` character.
+    // A paragraph requires a non-blank line.
+    // In this phase we may match all or just some of the open blocks.
+    // But we cannot close unmatched blocks yet, because we may have a lazy
+    // continuation line.
+    if (continued < stack.length) {
+      const item = stack[continued];
+      self.containerState = item[1];
+      return effects.attempt(
+        item[0].continuation,
+        documentContinue,
+        checkNewContainers
+      )(code)
+    } // Done.
+
+    return checkNewContainers(code)
+  }
+  /** @type {State} */
+
+  function documentContinue(code) {
+    if (self.containerState._closeFlow) closeFlow();
+    continued++;
+    return start(code)
+  }
+  /** @type {State} */
+
+  function checkNewContainers(code) {
+    // Next, after consuming the continuation markers for existing blocks, we
+    // look for new block starts (e.g. `>` for a block quote).
+    // If we encounter a new block start, we close any blocks unmatched in
+    // step 1 before creating the new block as a child of the last matched
+    // block.
+    if (continued === stack.length) {
+      // No need to `check` whether there’s a container, of `exitContainers`
+      // would be moot.
+      // We can instead immediately `attempt` to parse one.
+      if (!childFlow) {
+        return documentContinued(code)
+      } // If we have concrete content, such as block HTML or fenced code,
+      // we can’t have containers “pierce” into them, so we can immediately
+      // start.
+
+      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
+        return flowStart(code)
+      } // If we do have flow, it could still be a blank line,
+      // but we’d be interrupting it w/ a new container if there’s a current
+      // construct.
+
+      self.interrupt = Boolean(childFlow.currentConstruct);
+    } // Check if there is a new container.
+
+    self.containerState = {};
+    return effects.check(
+      containerConstruct,
+      thereIsANewContainer,
+      thereIsNoNewContainer
+    )(code)
+  }
+  /** @type {State} */
+
+  function thereIsANewContainer(code) {
+    if (childFlow) closeFlow();
+    exitContainers(continued);
+    return documentContinued(code)
+  }
+  /** @type {State} */
+
+  function thereIsNoNewContainer(code) {
+    self.parser.lazy[self.now().line] = continued !== stack.length;
+    lineStartOffset = self.now().offset;
+    return flowStart(code)
+  }
+  /** @type {State} */
+
+  function documentContinued(code) {
+    // Try new containers.
+    self.containerState = {};
+    return effects.attempt(
+      containerConstruct,
+      containerContinue,
+      flowStart
+    )(code)
+  }
+  /** @type {State} */
+
+  function containerContinue(code) {
+    continued++;
+    stack.push([self.currentConstruct, self.containerState]); // Try another.
+
+    return documentContinued(code)
+  }
+  /** @type {State} */
+
+  function flowStart(code) {
+    if (code === null) {
+      if (childFlow) closeFlow();
+      exitContainers(0);
+      effects.consume(code);
+      return
     }
 
-    if (node.type === 'open') {
-      return invalid ? (prefix + node.value) : '(';
-    }
+    childFlow = childFlow || self.parser.flow(self.now());
+    effects.enter('chunkFlow', {
+      contentType: 'flow',
+      previous: childToken,
+      _tokenizer: childFlow
+    });
+    return flowContinue(code)
+  }
+  /** @type {State} */
 
-    if (node.type === 'close') {
-      return invalid ? (prefix + node.value) : ')';
+  function flowContinue(code) {
+    if (code === null) {
+      writeToChild(effects.exit('chunkFlow'), true);
+      exitContainers(0);
+      effects.consume(code);
+      return
     }
 
-    if (node.type === 'comma') {
-      return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
-    }
+    if (markdownLineEnding(code)) {
+      effects.consume(code);
+      writeToChild(effects.exit('chunkFlow')); // Get ready for the next line.
 
-    if (node.value) {
-      return node.value;
+      continued = 0;
+      self.interrupt = undefined;
+      return start
     }
 
-    if (node.nodes && node.ranges > 0) {
-      let args = utils$1.reduce(node.nodes);
-      let range = fillRange(...args, { ...options, wrap: false, toRegex: true });
+    effects.consume(code);
+    return flowContinue
+  }
+  /**
+   * @param {Token} token
+   * @param {boolean} [eof]
+   * @returns {void}
+   */
 
-      if (range.length !== 0) {
-        return args.length > 1 && range.length > 1 ? `(${range})` : range;
-      }
-    }
+  function writeToChild(token, eof) {
+    const stream = self.sliceStream(token);
+    if (eof) stream.push(null);
+    token.previous = childToken;
+    if (childToken) childToken.next = token;
+    childToken = token;
+    childFlow.defineSkip(token.start);
+    childFlow.write(stream); // Alright, so we just added a lazy line:
+    //
+    // ```markdown
+    // > a
+    // b.
+    //
+    // Or:
+    //
+    // > ~~~c
+    // d
+    //
+    // Or:
+    //
+    // > | e |
+    // f
+    // ```
+    //
+    // The construct in the second example (fenced code) does not accept lazy
+    // lines, so it marked itself as done at the end of its first line, and
+    // then the content construct parses `d`.
+    // Most constructs in markdown match on the first line: if the first line
+    // forms a construct, a non-lazy line can’t “unmake” it.
+    //
+    // The construct in the third example is potentially a GFM table, and
+    // those are *weird*.
+    // It *could* be a table, from the first line, if the following line
+    // matches a condition.
+    // In this case, that second line is lazy, which “unmakes” the first line
+    // and turns the whole into one content block.
+    //
+    // We’ve now parsed the non-lazy and the lazy line, and can figure out
+    // whether the lazy line started a new flow block.
+    // If it did, we exit the current containers between the two flow blocks.
 
-    if (node.nodes) {
-      for (let child of node.nodes) {
-        output += walk(child, node);
-      }
-    }
-    return output;
-  };
+    if (self.parser.lazy[token.start.line]) {
+      let index = childFlow.events.length;
 
-  return walk(ast);
-};
+      while (index--) {
+        if (
+          // The token starts before the line ending…
+          childFlow.events[index][1].start.offset < lineStartOffset &&
+          (!childFlow.events[index][1].end || // …or ends after it.
+            childFlow.events[index][1].end.offset > lineStartOffset)
+        ) {
+          // Exit: there’s still something open, which means it’s a lazy line
+          // part of something.
+          return
+        }
+      }
 
-var compile_1 = compile$2;
+      const indexBeforeExits = self.events.length;
+      let indexBeforeFlow = indexBeforeExits;
+      /** @type {boolean|undefined} */
 
-const append = (queue = '', stash = '', enclose = false) => {
-  let result = [];
+      let seen;
+      /** @type {Point|undefined} */
 
-  queue = [].concat(queue);
-  stash = [].concat(stash);
+      let point; // Find the previous chunk (the one before the lazy line).
 
-  if (!stash.length) return queue;
-  if (!queue.length) {
-    return enclose ? utils$1.flatten(stash).map(ele => `{${ele}}`) : stash;
-  }
+      while (indexBeforeFlow--) {
+        if (
+          self.events[indexBeforeFlow][0] === 'exit' &&
+          self.events[indexBeforeFlow][1].type === 'chunkFlow'
+        ) {
+          if (seen) {
+            point = self.events[indexBeforeFlow][1].end;
+            break
+          }
 
-  for (let item of queue) {
-    if (Array.isArray(item)) {
-      for (let value of item) {
-        result.push(append(value, stash, enclose));
-      }
-    } else {
-      for (let ele of stash) {
-        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
-        result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
+          seen = true;
+        }
       }
-    }
-  }
-  return utils$1.flatten(result);
-};
 
-const expand$2 = (ast, options = {}) => {
-  let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
+      exitContainers(continued); // Fix positions.
 
-  let walk = (node, parent = {}) => {
-    node.queue = [];
+      index = indexBeforeExits;
 
-    let p = parent;
-    let q = parent.queue;
+      while (index < self.events.length) {
+        self.events[index][1].end = Object.assign({}, point);
+        index++;
+      } // Inject the exits earlier (they’re still also at the end).
 
-    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
-      p = p.parent;
-      q = p.queue;
-    }
+      splice(
+        self.events,
+        indexBeforeFlow + 1,
+        0,
+        self.events.slice(indexBeforeExits)
+      ); // Discard the duplicate exits.
 
-    if (node.invalid || node.dollar) {
-      q.push(append(q.pop(), stringify$3(node, options)));
-      return;
+      self.events.length = index;
     }
+  }
+  /**
+   * @param {number} size
+   * @returns {void}
+   */
 
-    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
-      q.push(append(q.pop(), ['{}']));
-      return;
-    }
+  function exitContainers(size) {
+    let index = stack.length; // Exit open containers.
 
-    if (node.nodes && node.ranges > 0) {
-      let args = utils$1.reduce(node.nodes);
+    while (index-- > size) {
+      const entry = stack[index];
+      self.containerState = entry[1];
+      entry[0].exit.call(self, effects);
+    }
 
-      if (utils$1.exceedsLimit(...args, options.step, rangeLimit)) {
-        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
-      }
+    stack.length = size;
+  }
 
-      let range = fillRange(...args, options);
-      if (range.length === 0) {
-        range = stringify$3(node, options);
-      }
+  function closeFlow() {
+    childFlow.write([null]);
+    childToken = undefined;
+    childFlow = undefined;
+    self.containerState._closeFlow = undefined;
+  }
+}
+/** @type {Tokenizer} */
 
-      q.push(append(q.pop(), range));
-      node.nodes = [];
-      return;
-    }
+function tokenizeContainer(effects, ok, nok) {
+  return factorySpace(
+    effects,
+    effects.attempt(this.parser.constructs.document, ok, nok),
+    'linePrefix',
+    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4
+  )
+}
 
-    let enclose = utils$1.encloseBrace(node);
-    let queue = node.queue;
-    let block = node;
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ */
 
-    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
-      block = block.parent;
-      queue = block.queue;
-    }
+/**
+ * Classify whether a character code represents whitespace, punctuation, or
+ * something else.
+ *
+ * Used for attention (emphasis, strong), whose sequences can open or close
+ * based on the class of surrounding characters.
+ *
+ * Note that eof (`null`) is seen as whitespace.
+ *
+ * @param {Code} code
+ * @returns {number|undefined}
+ */
+function classifyCharacter(code) {
+  if (
+    code === null ||
+    markdownLineEndingOrSpace(code) ||
+    unicodeWhitespace(code)
+  ) {
+    return 1
+  }
 
-    for (let i = 0; i < node.nodes.length; i++) {
-      let child = node.nodes[i];
+  if (unicodePunctuation(code)) {
+    return 2
+  }
+}
 
-      if (child.type === 'comma' && node.type === 'brace') {
-        if (i === 1) queue.push('');
-        queue.push('');
-        continue;
-      }
+/**
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ */
 
-      if (child.type === 'close') {
-        q.push(append(q.pop(), queue, enclose));
-        continue;
-      }
+/**
+ * Call all `resolveAll`s.
+ *
+ * @param {{resolveAll?: Resolver}[]} constructs
+ * @param {Event[]} events
+ * @param {TokenizeContext} context
+ * @returns {Event[]}
+ */
+function resolveAll(constructs, events, context) {
+  /** @type {Resolver[]} */
+  const called = [];
+  let index = -1;
 
-      if (child.value && child.type !== 'open') {
-        queue.push(append(queue.pop(), child.value));
-        continue;
-      }
+  while (++index < constructs.length) {
+    const resolve = constructs[index].resolveAll;
 
-      if (child.nodes) {
-        walk(child, node);
-      }
+    if (resolve && !called.includes(resolve)) {
+      events = resolve(events, context);
+      called.push(resolve);
     }
+  }
 
-    return queue;
-  };
+  return events
+}
+
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').Point} Point
+ */
 
-  return utils$1.flatten(walk(ast));
+/** @type {Construct} */
+const attention = {
+  name: 'attention',
+  tokenize: tokenizeAttention,
+  resolveAll: resolveAllAttention
 };
+/**
+ * Take all events and resolve attention to emphasis or strong.
+ *
+ * @type {Resolver}
+ */
 
-var expand_1 = expand$2;
+function resolveAllAttention(events, context) {
+  let index = -1;
+  /** @type {number} */
 
-var constants$1 = {
-  MAX_LENGTH: 1024 * 64,
+  let open;
+  /** @type {Token} */
 
-  // Digits
-  CHAR_0: '0', /* 0 */
-  CHAR_9: '9', /* 9 */
+  let group;
+  /** @type {Token} */
 
-  // Alphabet chars.
-  CHAR_UPPERCASE_A: 'A', /* A */
-  CHAR_LOWERCASE_A: 'a', /* a */
-  CHAR_UPPERCASE_Z: 'Z', /* Z */
-  CHAR_LOWERCASE_Z: 'z', /* z */
+  let text;
+  /** @type {Token} */
 
-  CHAR_LEFT_PARENTHESES: '(', /* ( */
-  CHAR_RIGHT_PARENTHESES: ')', /* ) */
+  let openingSequence;
+  /** @type {Token} */
 
-  CHAR_ASTERISK: '*', /* * */
+  let closingSequence;
+  /** @type {number} */
 
-  // Non-alphabetic chars.
-  CHAR_AMPERSAND: '&', /* & */
-  CHAR_AT: '@', /* @ */
-  CHAR_BACKSLASH: '\\', /* \ */
-  CHAR_BACKTICK: '`', /* ` */
-  CHAR_CARRIAGE_RETURN: '\r', /* \r */
-  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
-  CHAR_COLON: ':', /* : */
-  CHAR_COMMA: ',', /* , */
-  CHAR_DOLLAR: '$', /* . */
-  CHAR_DOT: '.', /* . */
-  CHAR_DOUBLE_QUOTE: '"', /* " */
-  CHAR_EQUAL: '=', /* = */
-  CHAR_EXCLAMATION_MARK: '!', /* ! */
-  CHAR_FORM_FEED: '\f', /* \f */
-  CHAR_FORWARD_SLASH: '/', /* / */
-  CHAR_HASH: '#', /* # */
-  CHAR_HYPHEN_MINUS: '-', /* - */
-  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
-  CHAR_LEFT_CURLY_BRACE: '{', /* { */
-  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
-  CHAR_LINE_FEED: '\n', /* \n */
-  CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
-  CHAR_PERCENT: '%', /* % */
-  CHAR_PLUS: '+', /* + */
-  CHAR_QUESTION_MARK: '?', /* ? */
-  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
-  CHAR_RIGHT_CURLY_BRACE: '}', /* } */
-  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
-  CHAR_SEMICOLON: ';', /* ; */
-  CHAR_SINGLE_QUOTE: '\'', /* ' */
-  CHAR_SPACE: ' ', /*   */
-  CHAR_TAB: '\t', /* \t */
-  CHAR_UNDERSCORE: '_', /* _ */
-  CHAR_VERTICAL_LINE: '|', /* | */
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
-};
+  let use;
+  /** @type {Event[]} */
 
-/**
- * Constants
- */
+  let nextEvents;
+  /** @type {number} */
 
-const {
-  MAX_LENGTH: MAX_LENGTH$1,
-  CHAR_BACKSLASH, /* \ */
-  CHAR_BACKTICK, /* ` */
-  CHAR_COMMA: CHAR_COMMA$2, /* , */
-  CHAR_DOT: CHAR_DOT$1, /* . */
-  CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */
-  CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */
-  CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */
-  CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */
-  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$2, /* [ */
-  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$2, /* ] */
-  CHAR_DOUBLE_QUOTE: CHAR_DOUBLE_QUOTE$1, /* " */
-  CHAR_SINGLE_QUOTE: CHAR_SINGLE_QUOTE$1, /* ' */
-  CHAR_NO_BREAK_SPACE,
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE
-} = constants$1;
+  let offset; // Walk through all events.
+  //
+  // Note: performance of this is fine on an mb of normal markdown, but it’s
+  // a bottleneck for malicious stuff.
 
-/**
- * parse
- */
+  while (++index < events.length) {
+    // Find a token that can close.
+    if (
+      events[index][0] === 'enter' &&
+      events[index][1].type === 'attentionSequence' &&
+      events[index][1]._close
+    ) {
+      open = index; // Now walk back to find an opener.
 
-const parse$6 = (input, options = {}) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected a string');
-  }
+      while (open--) {
+        // Find a token that can open the closer.
+        if (
+          events[open][0] === 'exit' &&
+          events[open][1].type === 'attentionSequence' &&
+          events[open][1]._open && // If the markers are the same:
+          context.sliceSerialize(events[open][1]).charCodeAt(0) ===
+            context.sliceSerialize(events[index][1]).charCodeAt(0)
+        ) {
+          // If the opening can close or the closing can open,
+          // and the close size *is not* a multiple of three,
+          // but the sum of the opening and closing size *is* multiple of three,
+          // then don’t match.
+          if (
+            (events[open][1]._close || events[index][1]._open) &&
+            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&
+            !(
+              (events[open][1].end.offset -
+                events[open][1].start.offset +
+                events[index][1].end.offset -
+                events[index][1].start.offset) %
+              3
+            )
+          ) {
+            continue
+          } // Number of markers to use from the sequence.
+
+          use =
+            events[open][1].end.offset - events[open][1].start.offset > 1 &&
+            events[index][1].end.offset - events[index][1].start.offset > 1
+              ? 2
+              : 1;
+          const start = Object.assign({}, events[open][1].end);
+          const end = Object.assign({}, events[index][1].start);
+          movePoint(start, -use);
+          movePoint(end, use);
+          openingSequence = {
+            type: use > 1 ? 'strongSequence' : 'emphasisSequence',
+            start,
+            end: Object.assign({}, events[open][1].end)
+          };
+          closingSequence = {
+            type: use > 1 ? 'strongSequence' : 'emphasisSequence',
+            start: Object.assign({}, events[index][1].start),
+            end
+          };
+          text = {
+            type: use > 1 ? 'strongText' : 'emphasisText',
+            start: Object.assign({}, events[open][1].end),
+            end: Object.assign({}, events[index][1].start)
+          };
+          group = {
+            type: use > 1 ? 'strong' : 'emphasis',
+            start: Object.assign({}, openingSequence.start),
+            end: Object.assign({}, closingSequence.end)
+          };
+          events[open][1].end = Object.assign({}, openingSequence.start);
+          events[index][1].start = Object.assign({}, closingSequence.end);
+          nextEvents = []; // If there are more markers in the opening, add them before.
+
+          if (events[open][1].end.offset - events[open][1].start.offset) {
+            nextEvents = push(nextEvents, [
+              ['enter', events[open][1], context],
+              ['exit', events[open][1], context]
+            ]);
+          } // Opening.
+
+          nextEvents = push(nextEvents, [
+            ['enter', group, context],
+            ['enter', openingSequence, context],
+            ['exit', openingSequence, context],
+            ['enter', text, context]
+          ]); // Between.
+
+          nextEvents = push(
+            nextEvents,
+            resolveAll(
+              context.parser.constructs.insideSpan.null,
+              events.slice(open + 1, index),
+              context
+            )
+          ); // Closing.
+
+          nextEvents = push(nextEvents, [
+            ['exit', text, context],
+            ['enter', closingSequence, context],
+            ['exit', closingSequence, context],
+            ['exit', group, context]
+          ]); // If there are more markers in the closing, add them after.
+
+          if (events[index][1].end.offset - events[index][1].start.offset) {
+            offset = 2;
+            nextEvents = push(nextEvents, [
+              ['enter', events[index][1], context],
+              ['exit', events[index][1], context]
+            ]);
+          } else {
+            offset = 0;
+          }
 
-  let opts = options || {};
-  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
-  if (input.length > max) {
-    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+          splice(events, open - 1, index - open + 3, nextEvents);
+          index = open + nextEvents.length - offset - 2;
+          break
+        }
+      }
+    }
+  } // Remove remaining sequences.
+
+  index = -1;
+
+  while (++index < events.length) {
+    if (events[index][1].type === 'attentionSequence') {
+      events[index][1].type = 'data';
+    }
   }
 
-  let ast = { type: 'root', input, nodes: [] };
-  let stack = [ast];
-  let block = ast;
-  let prev = ast;
-  let brackets = 0;
-  let length = input.length;
-  let index = 0;
-  let depth = 0;
-  let value;
+  return events
+}
+/** @type {Tokenizer} */
 
-  /**
-   * Helpers
-   */
+function tokenizeAttention(effects, ok) {
+  const before = classifyCharacter(this.previous);
+  /** @type {NonNullable<Code>} */
 
-  const advance = () => input[index++];
-  const push = node => {
-    if (node.type === 'text' && prev.type === 'dot') {
-      prev.type = 'text';
-    }
+  let marker;
+  return start
+  /** @type {State} */
 
-    if (prev && prev.type === 'text' && node.type === 'text') {
-      prev.value += node.value;
-      return;
+  function start(code) {
+    effects.enter('attentionSequence');
+    marker = code;
+    return sequence(code)
+  }
+  /** @type {State} */
+
+  function sequence(code) {
+    if (code === marker) {
+      effects.consume(code);
+      return sequence
     }
 
-    block.nodes.push(node);
-    node.parent = block;
-    node.prev = prev;
-    prev = node;
-    return node;
-  };
+    const token = effects.exit('attentionSequence');
+    const after = classifyCharacter(code);
+    const open = !after || (after === 2 && before);
+    const close = !before || (before === 2 && after);
+    token._open = Boolean(marker === 42 ? open : open && (before || !close));
+    token._close = Boolean(marker === 42 ? close : close && (after || !open));
+    return ok(code)
+  }
+}
+/**
+ * Move a point a bit.
+ *
+ * Note: `move` only works inside lines! It’s not possible to move past other
+ * chunks (replacement characters, tabs, or line endings).
+ *
+ * @param {Point} point
+ * @param {number} offset
+ * @returns {void}
+ */
 
-  push({ type: 'bos' });
+function movePoint(point, offset) {
+  point.column += offset;
+  point.offset += offset;
+  point._bufferIndex += offset;
+}
 
-  while (index < length) {
-    block = stack[stack.length - 1];
-    value = advance();
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
 
-    /**
-     * Invalid chars
-     */
+/** @type {Construct} */
+const autolink = {
+  name: 'autolink',
+  tokenize: tokenizeAutolink
+};
+/** @type {Tokenizer} */
 
-    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
-      continue;
-    }
+function tokenizeAutolink(effects, ok, nok) {
+  let size = 1;
+  return start
+  /** @type {State} */
 
-    /**
-     * Escaped chars
-     */
+  function start(code) {
+    effects.enter('autolink');
+    effects.enter('autolinkMarker');
+    effects.consume(code);
+    effects.exit('autolinkMarker');
+    effects.enter('autolinkProtocol');
+    return open
+  }
+  /** @type {State} */
 
-    if (value === CHAR_BACKSLASH) {
-      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
-      continue;
+  function open(code) {
+    if (asciiAlpha(code)) {
+      effects.consume(code);
+      return schemeOrEmailAtext
     }
 
-    /**
-     * Right square bracket (literal): ']'
-     */
+    return asciiAtext(code) ? emailAtext(code) : nok(code)
+  }
+  /** @type {State} */
 
-    if (value === CHAR_RIGHT_SQUARE_BRACKET$2) {
-      push({ type: 'text', value: '\\' + value });
-      continue;
-    }
+  function schemeOrEmailAtext(code) {
+    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)
+      ? schemeInsideOrEmailAtext(code)
+      : emailAtext(code)
+  }
+  /** @type {State} */
 
-    /**
-     * Left square bracket: '['
-     */
+  function schemeInsideOrEmailAtext(code) {
+    if (code === 58) {
+      effects.consume(code);
+      return urlInside
+    }
 
-    if (value === CHAR_LEFT_SQUARE_BRACKET$2) {
-      brackets++;
-      let next;
+    if (
+      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&
+      size++ < 32
+    ) {
+      effects.consume(code);
+      return schemeInsideOrEmailAtext
+    }
 
-      while (index < length && (next = advance())) {
-        value += next;
+    return emailAtext(code)
+  }
+  /** @type {State} */
 
-        if (next === CHAR_LEFT_SQUARE_BRACKET$2) {
-          brackets++;
-          continue;
-        }
+  function urlInside(code) {
+    if (code === 62) {
+      effects.exit('autolinkProtocol');
+      return end(code)
+    }
 
-        if (next === CHAR_BACKSLASH) {
-          value += advance();
-          continue;
-        }
+    if (code === null || code === 32 || code === 60 || asciiControl(code)) {
+      return nok(code)
+    }
 
-        if (next === CHAR_RIGHT_SQUARE_BRACKET$2) {
-          brackets--;
+    effects.consume(code);
+    return urlInside
+  }
+  /** @type {State} */
 
-          if (brackets === 0) {
-            break;
-          }
-        }
-      }
+  function emailAtext(code) {
+    if (code === 64) {
+      effects.consume(code);
+      size = 0;
+      return emailAtSignOrDot
+    }
 
-      push({ type: 'text', value });
-      continue;
+    if (asciiAtext(code)) {
+      effects.consume(code);
+      return emailAtext
     }
 
-    /**
-     * Parentheses
-     */
+    return nok(code)
+  }
+  /** @type {State} */
 
-    if (value === CHAR_LEFT_PARENTHESES$1) {
-      block = push({ type: 'paren', nodes: [] });
-      stack.push(block);
-      push({ type: 'text', value });
-      continue;
-    }
+  function emailAtSignOrDot(code) {
+    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)
+  }
+  /** @type {State} */
 
-    if (value === CHAR_RIGHT_PARENTHESES$1) {
-      if (block.type !== 'paren') {
-        push({ type: 'text', value });
-        continue;
-      }
-      block = stack.pop();
-      push({ type: 'text', value });
-      block = stack[stack.length - 1];
-      continue;
+  function emailLabel(code) {
+    if (code === 46) {
+      effects.consume(code);
+      size = 0;
+      return emailAtSignOrDot
     }
 
-    /**
-     * Quotes: '|"|`
-     */
-
-    if (value === CHAR_DOUBLE_QUOTE$1 || value === CHAR_SINGLE_QUOTE$1 || value === CHAR_BACKTICK) {
-      let open = value;
-      let next;
+    if (code === 62) {
+      // Exit, then change the type.
+      effects.exit('autolinkProtocol').type = 'autolinkEmail';
+      return end(code)
+    }
 
-      if (options.keepQuotes !== true) {
-        value = '';
-      }
+    return emailValue(code)
+  }
+  /** @type {State} */
 
-      while (index < length && (next = advance())) {
-        if (next === CHAR_BACKSLASH) {
-          value += next + advance();
-          continue;
-        }
+  function emailValue(code) {
+    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {
+      effects.consume(code);
+      return code === 45 ? emailValue : emailLabel
+    }
 
-        if (next === open) {
-          if (options.keepQuotes === true) value += next;
-          break;
-        }
+    return nok(code)
+  }
+  /** @type {State} */
 
-        value += next;
-      }
+  function end(code) {
+    effects.enter('autolinkMarker');
+    effects.consume(code);
+    effects.exit('autolinkMarker');
+    effects.exit('autolink');
+    return ok
+  }
+}
 
-      push({ type: 'text', value });
-      continue;
-    }
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
 
-    /**
-     * Left curly brace: '{'
-     */
+/** @type {Construct} */
+const blankLine = {
+  tokenize: tokenizeBlankLine,
+  partial: true
+};
+/** @type {Tokenizer} */
 
-    if (value === CHAR_LEFT_CURLY_BRACE$1) {
-      depth++;
+function tokenizeBlankLine(effects, ok, nok) {
+  return factorySpace(effects, afterWhitespace, 'linePrefix')
+  /** @type {State} */
 
-      let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
-      let brace = {
-        type: 'brace',
-        open: true,
-        close: false,
-        dollar,
-        depth,
-        commas: 0,
-        ranges: 0,
-        nodes: []
-      };
+  function afterWhitespace(code) {
+    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)
+  }
+}
 
-      block = push(brace);
-      stack.push(block);
-      push({ type: 'open', value });
-      continue;
-    }
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Exiter} Exiter
+ * @typedef {import('micromark-util-types').State} State
+ */
 
-    /**
-     * Right curly brace: '}'
-     */
+/** @type {Construct} */
+const blockQuote = {
+  name: 'blockQuote',
+  tokenize: tokenizeBlockQuoteStart,
+  continuation: {
+    tokenize: tokenizeBlockQuoteContinuation
+  },
+  exit: exit$1
+};
+/** @type {Tokenizer} */
 
-    if (value === CHAR_RIGHT_CURLY_BRACE$1) {
-      if (block.type !== 'brace') {
-        push({ type: 'text', value });
-        continue;
+function tokenizeBlockQuoteStart(effects, ok, nok) {
+  const self = this;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    if (code === 62) {
+      const state = self.containerState;
+
+      if (!state.open) {
+        effects.enter('blockQuote', {
+          _container: true
+        });
+        state.open = true;
       }
 
-      let type = 'close';
-      block = stack.pop();
-      block.close = true;
+      effects.enter('blockQuotePrefix');
+      effects.enter('blockQuoteMarker');
+      effects.consume(code);
+      effects.exit('blockQuoteMarker');
+      return after
+    }
 
-      push({ type, value });
-      depth--;
+    return nok(code)
+  }
+  /** @type {State} */
 
-      block = stack[stack.length - 1];
-      continue;
+  function after(code) {
+    if (markdownSpace(code)) {
+      effects.enter('blockQuotePrefixWhitespace');
+      effects.consume(code);
+      effects.exit('blockQuotePrefixWhitespace');
+      effects.exit('blockQuotePrefix');
+      return ok
     }
 
-    /**
-     * Comma: ','
-     */
+    effects.exit('blockQuotePrefix');
+    return ok(code)
+  }
+}
+/** @type {Tokenizer} */
 
-    if (value === CHAR_COMMA$2 && depth > 0) {
-      if (block.ranges > 0) {
-        block.ranges = 0;
-        let open = block.nodes.shift();
-        block.nodes = [open, { type: 'text', value: stringify$3(block) }];
-      }
+function tokenizeBlockQuoteContinuation(effects, ok, nok) {
+  return factorySpace(
+    effects,
+    effects.attempt(blockQuote, ok, nok),
+    'linePrefix',
+    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4
+  )
+}
+/** @type {Exiter} */
 
-      push({ type: 'comma', value });
-      block.commas++;
-      continue;
-    }
+function exit$1(effects) {
+  effects.exit('blockQuote');
+}
 
-    /**
-     * Dot: '.'
-     */
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
 
-    if (value === CHAR_DOT$1 && depth > 0 && block.commas === 0) {
-      let siblings = block.nodes;
+/** @type {Construct} */
+const characterEscape$1 = {
+  name: 'characterEscape',
+  tokenize: tokenizeCharacterEscape
+};
+/** @type {Tokenizer} */
+
+function tokenizeCharacterEscape(effects, ok, nok) {
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('characterEscape');
+    effects.enter('escapeMarker');
+    effects.consume(code);
+    effects.exit('escapeMarker');
+    return open
+  }
+  /** @type {State} */
+
+  function open(code) {
+    if (asciiPunctuation(code)) {
+      effects.enter('characterEscapeValue');
+      effects.consume(code);
+      effects.exit('characterEscapeValue');
+      effects.exit('characterEscape');
+      return ok
+    }
+
+    return nok(code)
+  }
+}
+
+var characterEntities = {
+  AEli: 'Æ',
+  AElig: 'Æ',
+  AM: '&',
+  AMP: '&',
+  Aacut: 'Á',
+  Aacute: 'Á',
+  Abreve: 'Ă',
+  Acir: 'Â',
+  Acirc: 'Â',
+  Acy: 'А',
+  Afr: '𝔄',
+  Agrav: 'À',
+  Agrave: 'À',
+  Alpha: 'Α',
+  Amacr: 'Ā',
+  And: '⩓',
+  Aogon: 'Ą',
+  Aopf: '𝔸',
+  ApplyFunction: '⁡',
+  Arin: 'Å',
+  Aring: 'Å',
+  Ascr: '𝒜',
+  Assign: '≔',
+  Atild: 'Ã',
+  Atilde: 'Ã',
+  Aum: 'Ä',
+  Auml: 'Ä',
+  Backslash: '∖',
+  Barv: '⫧',
+  Barwed: '⌆',
+  Bcy: 'Б',
+  Because: '∵',
+  Bernoullis: 'ℬ',
+  Beta: 'Β',
+  Bfr: '𝔅',
+  Bopf: '𝔹',
+  Breve: '˘',
+  Bscr: 'ℬ',
+  Bumpeq: '≎',
+  CHcy: 'Ч',
+  COP: '©',
+  COPY: '©',
+  Cacute: 'Ć',
+  Cap: '⋒',
+  CapitalDifferentialD: 'ⅅ',
+  Cayleys: 'ℭ',
+  Ccaron: 'Č',
+  Ccedi: 'Ç',
+  Ccedil: 'Ç',
+  Ccirc: 'Ĉ',
+  Cconint: '∰',
+  Cdot: 'Ċ',
+  Cedilla: '¸',
+  CenterDot: '·',
+  Cfr: 'ℭ',
+  Chi: 'Χ',
+  CircleDot: '⊙',
+  CircleMinus: '⊖',
+  CirclePlus: '⊕',
+  CircleTimes: '⊗',
+  ClockwiseContourIntegral: '∲',
+  CloseCurlyDoubleQuote: '”',
+  CloseCurlyQuote: '’',
+  Colon: '∷',
+  Colone: '⩴',
+  Congruent: '≡',
+  Conint: '∯',
+  ContourIntegral: '∮',
+  Copf: 'ℂ',
+  Coproduct: '∐',
+  CounterClockwiseContourIntegral: '∳',
+  Cross: '⨯',
+  Cscr: '𝒞',
+  Cup: '⋓',
+  CupCap: '≍',
+  DD: 'ⅅ',
+  DDotrahd: '⤑',
+  DJcy: 'Ђ',
+  DScy: 'Ѕ',
+  DZcy: 'Џ',
+  Dagger: '‡',
+  Darr: '↡',
+  Dashv: '⫤',
+  Dcaron: 'Ď',
+  Dcy: 'Д',
+  Del: '∇',
+  Delta: 'Δ',
+  Dfr: '𝔇',
+  DiacriticalAcute: '´',
+  DiacriticalDot: '˙',
+  DiacriticalDoubleAcute: '˝',
+  DiacriticalGrave: '`',
+  DiacriticalTilde: '˜',
+  Diamond: '⋄',
+  DifferentialD: 'ⅆ',
+  Dopf: '𝔻',
+  Dot: '¨',
+  DotDot: '⃜',
+  DotEqual: '≐',
+  DoubleContourIntegral: '∯',
+  DoubleDot: '¨',
+  DoubleDownArrow: '⇓',
+  DoubleLeftArrow: '⇐',
+  DoubleLeftRightArrow: '⇔',
+  DoubleLeftTee: '⫤',
+  DoubleLongLeftArrow: '⟸',
+  DoubleLongLeftRightArrow: '⟺',
+  DoubleLongRightArrow: '⟹',
+  DoubleRightArrow: '⇒',
+  DoubleRightTee: '⊨',
+  DoubleUpArrow: '⇑',
+  DoubleUpDownArrow: '⇕',
+  DoubleVerticalBar: '∥',
+  DownArrow: '↓',
+  DownArrowBar: '⤓',
+  DownArrowUpArrow: '⇵',
+  DownBreve: '̑',
+  DownLeftRightVector: '⥐',
+  DownLeftTeeVector: '⥞',
+  DownLeftVector: '↽',
+  DownLeftVectorBar: '⥖',
+  DownRightTeeVector: '⥟',
+  DownRightVector: '⇁',
+  DownRightVectorBar: '⥗',
+  DownTee: '⊤',
+  DownTeeArrow: '↧',
+  Downarrow: '⇓',
+  Dscr: '𝒟',
+  Dstrok: 'Đ',
+  ENG: 'Ŋ',
+  ET: 'Ð',
+  ETH: 'Ð',
+  Eacut: 'É',
+  Eacute: 'É',
+  Ecaron: 'Ě',
+  Ecir: 'Ê',
+  Ecirc: 'Ê',
+  Ecy: 'Э',
+  Edot: 'Ė',
+  Efr: '𝔈',
+  Egrav: 'È',
+  Egrave: 'È',
+  Element: '∈',
+  Emacr: 'Ē',
+  EmptySmallSquare: '◻',
+  EmptyVerySmallSquare: '▫',
+  Eogon: 'Ę',
+  Eopf: '𝔼',
+  Epsilon: 'Ε',
+  Equal: '⩵',
+  EqualTilde: '≂',
+  Equilibrium: '⇌',
+  Escr: 'ℰ',
+  Esim: '⩳',
+  Eta: 'Η',
+  Eum: 'Ë',
+  Euml: 'Ë',
+  Exists: '∃',
+  ExponentialE: 'ⅇ',
+  Fcy: 'Ф',
+  Ffr: '𝔉',
+  FilledSmallSquare: '◼',
+  FilledVerySmallSquare: '▪',
+  Fopf: '𝔽',
+  ForAll: '∀',
+  Fouriertrf: 'ℱ',
+  Fscr: 'ℱ',
+  GJcy: 'Ѓ',
+  G: '>',
+  GT: '>',
+  Gamma: 'Γ',
+  Gammad: 'Ϝ',
+  Gbreve: 'Ğ',
+  Gcedil: 'Ģ',
+  Gcirc: 'Ĝ',
+  Gcy: 'Г',
+  Gdot: 'Ġ',
+  Gfr: '𝔊',
+  Gg: '⋙',
+  Gopf: '𝔾',
+  GreaterEqual: '≥',
+  GreaterEqualLess: '⋛',
+  GreaterFullEqual: '≧',
+  GreaterGreater: '⪢',
+  GreaterLess: '≷',
+  GreaterSlantEqual: '⩾',
+  GreaterTilde: '≳',
+  Gscr: '𝒢',
+  Gt: '≫',
+  HARDcy: 'Ъ',
+  Hacek: 'ˇ',
+  Hat: '^',
+  Hcirc: 'Ĥ',
+  Hfr: 'ℌ',
+  HilbertSpace: 'ℋ',
+  Hopf: 'ℍ',
+  HorizontalLine: '─',
+  Hscr: 'ℋ',
+  Hstrok: 'Ħ',
+  HumpDownHump: '≎',
+  HumpEqual: '≏',
+  IEcy: 'Е',
+  IJlig: 'IJ',
+  IOcy: 'Ё',
+  Iacut: 'Í',
+  Iacute: 'Í',
+  Icir: 'Î',
+  Icirc: 'Î',
+  Icy: 'И',
+  Idot: 'İ',
+  Ifr: 'ℑ',
+  Igrav: 'Ì',
+  Igrave: 'Ì',
+  Im: 'ℑ',
+  Imacr: 'Ī',
+  ImaginaryI: 'ⅈ',
+  Implies: '⇒',
+  Int: '∬',
+  Integral: '∫',
+  Intersection: '⋂',
+  InvisibleComma: '⁣',
+  InvisibleTimes: '⁢',
+  Iogon: 'Į',
+  Iopf: '𝕀',
+  Iota: 'Ι',
+  Iscr: 'ℐ',
+  Itilde: 'Ĩ',
+  Iukcy: 'І',
+  Ium: 'Ï',
+  Iuml: 'Ï',
+  Jcirc: 'Ĵ',
+  Jcy: 'Й',
+  Jfr: '𝔍',
+  Jopf: '𝕁',
+  Jscr: '𝒥',
+  Jsercy: 'Ј',
+  Jukcy: 'Є',
+  KHcy: 'Х',
+  KJcy: 'Ќ',
+  Kappa: 'Κ',
+  Kcedil: 'Ķ',
+  Kcy: 'К',
+  Kfr: '𝔎',
+  Kopf: '𝕂',
+  Kscr: '𝒦',
+  LJcy: 'Љ',
+  L: '<',
+  LT: '<',
+  Lacute: 'Ĺ',
+  Lambda: 'Λ',
+  Lang: '⟪',
+  Laplacetrf: 'ℒ',
+  Larr: '↞',
+  Lcaron: 'Ľ',
+  Lcedil: 'Ļ',
+  Lcy: 'Л',
+  LeftAngleBracket: '⟨',
+  LeftArrow: '←',
+  LeftArrowBar: '⇤',
+  LeftArrowRightArrow: '⇆',
+  LeftCeiling: '⌈',
+  LeftDoubleBracket: '⟦',
+  LeftDownTeeVector: '⥡',
+  LeftDownVector: '⇃',
+  LeftDownVectorBar: '⥙',
+  LeftFloor: '⌊',
+  LeftRightArrow: '↔',
+  LeftRightVector: '⥎',
+  LeftTee: '⊣',
+  LeftTeeArrow: '↤',
+  LeftTeeVector: '⥚',
+  LeftTriangle: '⊲',
+  LeftTriangleBar: '⧏',
+  LeftTriangleEqual: '⊴',
+  LeftUpDownVector: '⥑',
+  LeftUpTeeVector: '⥠',
+  LeftUpVector: '↿',
+  LeftUpVectorBar: '⥘',
+  LeftVector: '↼',
+  LeftVectorBar: '⥒',
+  Leftarrow: '⇐',
+  Leftrightarrow: '⇔',
+  LessEqualGreater: '⋚',
+  LessFullEqual: '≦',
+  LessGreater: '≶',
+  LessLess: '⪡',
+  LessSlantEqual: '⩽',
+  LessTilde: '≲',
+  Lfr: '𝔏',
+  Ll: '⋘',
+  Lleftarrow: '⇚',
+  Lmidot: 'Ŀ',
+  LongLeftArrow: '⟵',
+  LongLeftRightArrow: '⟷',
+  LongRightArrow: '⟶',
+  Longleftarrow: '⟸',
+  Longleftrightarrow: '⟺',
+  Longrightarrow: '⟹',
+  Lopf: '𝕃',
+  LowerLeftArrow: '↙',
+  LowerRightArrow: '↘',
+  Lscr: 'ℒ',
+  Lsh: '↰',
+  Lstrok: 'Ł',
+  Lt: '≪',
+  Map: '⤅',
+  Mcy: 'М',
+  MediumSpace: ' ',
+  Mellintrf: 'ℳ',
+  Mfr: '𝔐',
+  MinusPlus: '∓',
+  Mopf: '𝕄',
+  Mscr: 'ℳ',
+  Mu: 'Μ',
+  NJcy: 'Њ',
+  Nacute: 'Ń',
+  Ncaron: 'Ň',
+  Ncedil: 'Ņ',
+  Ncy: 'Н',
+  NegativeMediumSpace: '​',
+  NegativeThickSpace: '​',
+  NegativeThinSpace: '​',
+  NegativeVeryThinSpace: '​',
+  NestedGreaterGreater: '≫',
+  NestedLessLess: '≪',
+  NewLine: '\n',
+  Nfr: '𝔑',
+  NoBreak: '⁠',
+  NonBreakingSpace: ' ',
+  Nopf: 'ℕ',
+  Not: '⫬',
+  NotCongruent: '≢',
+  NotCupCap: '≭',
+  NotDoubleVerticalBar: '∦',
+  NotElement: '∉',
+  NotEqual: '≠',
+  NotEqualTilde: '≂̸',
+  NotExists: '∄',
+  NotGreater: '≯',
+  NotGreaterEqual: '≱',
+  NotGreaterFullEqual: '≧̸',
+  NotGreaterGreater: '≫̸',
+  NotGreaterLess: '≹',
+  NotGreaterSlantEqual: '⩾̸',
+  NotGreaterTilde: '≵',
+  NotHumpDownHump: '≎̸',
+  NotHumpEqual: '≏̸',
+  NotLeftTriangle: '⋪',
+  NotLeftTriangleBar: '⧏̸',
+  NotLeftTriangleEqual: '⋬',
+  NotLess: '≮',
+  NotLessEqual: '≰',
+  NotLessGreater: '≸',
+  NotLessLess: '≪̸',
+  NotLessSlantEqual: '⩽̸',
+  NotLessTilde: '≴',
+  NotNestedGreaterGreater: '⪢̸',
+  NotNestedLessLess: '⪡̸',
+  NotPrecedes: '⊀',
+  NotPrecedesEqual: '⪯̸',
+  NotPrecedesSlantEqual: '⋠',
+  NotReverseElement: '∌',
+  NotRightTriangle: '⋫',
+  NotRightTriangleBar: '⧐̸',
+  NotRightTriangleEqual: '⋭',
+  NotSquareSubset: '⊏̸',
+  NotSquareSubsetEqual: '⋢',
+  NotSquareSuperset: '⊐̸',
+  NotSquareSupersetEqual: '⋣',
+  NotSubset: '⊂⃒',
+  NotSubsetEqual: '⊈',
+  NotSucceeds: '⊁',
+  NotSucceedsEqual: '⪰̸',
+  NotSucceedsSlantEqual: '⋡',
+  NotSucceedsTilde: '≿̸',
+  NotSuperset: '⊃⃒',
+  NotSupersetEqual: '⊉',
+  NotTilde: '≁',
+  NotTildeEqual: '≄',
+  NotTildeFullEqual: '≇',
+  NotTildeTilde: '≉',
+  NotVerticalBar: '∤',
+  Nscr: '𝒩',
+  Ntild: 'Ñ',
+  Ntilde: 'Ñ',
+  Nu: 'Ν',
+  OElig: 'Œ',
+  Oacut: 'Ó',
+  Oacute: 'Ó',
+  Ocir: 'Ô',
+  Ocirc: 'Ô',
+  Ocy: 'О',
+  Odblac: 'Ő',
+  Ofr: '𝔒',
+  Ograv: 'Ò',
+  Ograve: 'Ò',
+  Omacr: 'Ō',
+  Omega: 'Ω',
+  Omicron: 'Ο',
+  Oopf: '𝕆',
+  OpenCurlyDoubleQuote: '“',
+  OpenCurlyQuote: '‘',
+  Or: '⩔',
+  Oscr: '𝒪',
+  Oslas: 'Ø',
+  Oslash: 'Ø',
+  Otild: 'Õ',
+  Otilde: 'Õ',
+  Otimes: '⨷',
+  Oum: 'Ö',
+  Ouml: 'Ö',
+  OverBar: '‾',
+  OverBrace: '⏞',
+  OverBracket: '⎴',
+  OverParenthesis: '⏜',
+  PartialD: '∂',
+  Pcy: 'П',
+  Pfr: '𝔓',
+  Phi: 'Φ',
+  Pi: 'Π',
+  PlusMinus: '±',
+  Poincareplane: 'ℌ',
+  Popf: 'ℙ',
+  Pr: '⪻',
+  Precedes: '≺',
+  PrecedesEqual: '⪯',
+  PrecedesSlantEqual: '≼',
+  PrecedesTilde: '≾',
+  Prime: '″',
+  Product: '∏',
+  Proportion: '∷',
+  Proportional: '∝',
+  Pscr: '𝒫',
+  Psi: 'Ψ',
+  QUO: '"',
+  QUOT: '"',
+  Qfr: '𝔔',
+  Qopf: 'ℚ',
+  Qscr: '𝒬',
+  RBarr: '⤐',
+  RE: '®',
+  REG: '®',
+  Racute: 'Ŕ',
+  Rang: '⟫',
+  Rarr: '↠',
+  Rarrtl: '⤖',
+  Rcaron: 'Ř',
+  Rcedil: 'Ŗ',
+  Rcy: 'Р',
+  Re: 'ℜ',
+  ReverseElement: '∋',
+  ReverseEquilibrium: '⇋',
+  ReverseUpEquilibrium: '⥯',
+  Rfr: 'ℜ',
+  Rho: 'Ρ',
+  RightAngleBracket: '⟩',
+  RightArrow: '→',
+  RightArrowBar: '⇥',
+  RightArrowLeftArrow: '⇄',
+  RightCeiling: '⌉',
+  RightDoubleBracket: '⟧',
+  RightDownTeeVector: '⥝',
+  RightDownVector: '⇂',
+  RightDownVectorBar: '⥕',
+  RightFloor: '⌋',
+  RightTee: '⊢',
+  RightTeeArrow: '↦',
+  RightTeeVector: '⥛',
+  RightTriangle: '⊳',
+  RightTriangleBar: '⧐',
+  RightTriangleEqual: '⊵',
+  RightUpDownVector: '⥏',
+  RightUpTeeVector: '⥜',
+  RightUpVector: '↾',
+  RightUpVectorBar: '⥔',
+  RightVector: '⇀',
+  RightVectorBar: '⥓',
+  Rightarrow: '⇒',
+  Ropf: 'ℝ',
+  RoundImplies: '⥰',
+  Rrightarrow: '⇛',
+  Rscr: 'ℛ',
+  Rsh: '↱',
+  RuleDelayed: '⧴',
+  SHCHcy: 'Щ',
+  SHcy: 'Ш',
+  SOFTcy: 'Ь',
+  Sacute: 'Ś',
+  Sc: '⪼',
+  Scaron: 'Š',
+  Scedil: 'Ş',
+  Scirc: 'Ŝ',
+  Scy: 'С',
+  Sfr: '𝔖',
+  ShortDownArrow: '↓',
+  ShortLeftArrow: '←',
+  ShortRightArrow: '→',
+  ShortUpArrow: '↑',
+  Sigma: 'Σ',
+  SmallCircle: '∘',
+  Sopf: '𝕊',
+  Sqrt: '√',
+  Square: '□',
+  SquareIntersection: '⊓',
+  SquareSubset: '⊏',
+  SquareSubsetEqual: '⊑',
+  SquareSuperset: '⊐',
+  SquareSupersetEqual: '⊒',
+  SquareUnion: '⊔',
+  Sscr: '𝒮',
+  Star: '⋆',
+  Sub: '⋐',
+  Subset: '⋐',
+  SubsetEqual: '⊆',
+  Succeeds: '≻',
+  SucceedsEqual: '⪰',
+  SucceedsSlantEqual: '≽',
+  SucceedsTilde: '≿',
+  SuchThat: '∋',
+  Sum: '∑',
+  Sup: '⋑',
+  Superset: '⊃',
+  SupersetEqual: '⊇',
+  Supset: '⋑',
+  THOR: 'Þ',
+  THORN: 'Þ',
+  TRADE: '™',
+  TSHcy: 'Ћ',
+  TScy: 'Ц',
+  Tab: '\t',
+  Tau: 'Τ',
+  Tcaron: 'Ť',
+  Tcedil: 'Ţ',
+  Tcy: 'Т',
+  Tfr: '𝔗',
+  Therefore: '∴',
+  Theta: 'Θ',
+  ThickSpace: '  ',
+  ThinSpace: ' ',
+  Tilde: '∼',
+  TildeEqual: '≃',
+  TildeFullEqual: '≅',
+  TildeTilde: '≈',
+  Topf: '𝕋',
+  TripleDot: '⃛',
+  Tscr: '𝒯',
+  Tstrok: 'Ŧ',
+  Uacut: 'Ú',
+  Uacute: 'Ú',
+  Uarr: '↟',
+  Uarrocir: '⥉',
+  Ubrcy: 'Ў',
+  Ubreve: 'Ŭ',
+  Ucir: 'Û',
+  Ucirc: 'Û',
+  Ucy: 'У',
+  Udblac: 'Ű',
+  Ufr: '𝔘',
+  Ugrav: 'Ù',
+  Ugrave: 'Ù',
+  Umacr: 'Ū',
+  UnderBar: '_',
+  UnderBrace: '⏟',
+  UnderBracket: '⎵',
+  UnderParenthesis: '⏝',
+  Union: '⋃',
+  UnionPlus: '⊎',
+  Uogon: 'Ų',
+  Uopf: '𝕌',
+  UpArrow: '↑',
+  UpArrowBar: '⤒',
+  UpArrowDownArrow: '⇅',
+  UpDownArrow: '↕',
+  UpEquilibrium: '⥮',
+  UpTee: '⊥',
+  UpTeeArrow: '↥',
+  Uparrow: '⇑',
+  Updownarrow: '⇕',
+  UpperLeftArrow: '↖',
+  UpperRightArrow: '↗',
+  Upsi: 'ϒ',
+  Upsilon: 'Υ',
+  Uring: 'Ů',
+  Uscr: '𝒰',
+  Utilde: 'Ũ',
+  Uum: 'Ü',
+  Uuml: 'Ü',
+  VDash: '⊫',
+  Vbar: '⫫',
+  Vcy: 'В',
+  Vdash: '⊩',
+  Vdashl: '⫦',
+  Vee: '⋁',
+  Verbar: '‖',
+  Vert: '‖',
+  VerticalBar: '∣',
+  VerticalLine: '|',
+  VerticalSeparator: '❘',
+  VerticalTilde: '≀',
+  VeryThinSpace: ' ',
+  Vfr: '𝔙',
+  Vopf: '𝕍',
+  Vscr: '𝒱',
+  Vvdash: '⊪',
+  Wcirc: 'Ŵ',
+  Wedge: '⋀',
+  Wfr: '𝔚',
+  Wopf: '𝕎',
+  Wscr: '𝒲',
+  Xfr: '𝔛',
+  Xi: 'Ξ',
+  Xopf: '𝕏',
+  Xscr: '𝒳',
+  YAcy: 'Я',
+  YIcy: 'Ї',
+  YUcy: 'Ю',
+  Yacut: 'Ý',
+  Yacute: 'Ý',
+  Ycirc: 'Ŷ',
+  Ycy: 'Ы',
+  Yfr: '𝔜',
+  Yopf: '𝕐',
+  Yscr: '𝒴',
+  Yuml: 'Ÿ',
+  ZHcy: 'Ж',
+  Zacute: 'Ź',
+  Zcaron: 'Ž',
+  Zcy: 'З',
+  Zdot: 'Ż',
+  ZeroWidthSpace: '​',
+  Zeta: 'Ζ',
+  Zfr: 'ℨ',
+  Zopf: 'ℤ',
+  Zscr: '𝒵',
+  aacut: 'á',
+  aacute: 'á',
+  abreve: 'ă',
+  ac: '∾',
+  acE: '∾̳',
+  acd: '∿',
+  acir: 'â',
+  acirc: 'â',
+  acut: '´',
+  acute: '´',
+  acy: 'а',
+  aeli: 'æ',
+  aelig: 'æ',
+  af: '⁡',
+  afr: '𝔞',
+  agrav: 'à',
+  agrave: 'à',
+  alefsym: 'ℵ',
+  aleph: 'ℵ',
+  alpha: 'α',
+  amacr: 'ā',
+  amalg: '⨿',
+  am: '&',
+  amp: '&',
+  and: '∧',
+  andand: '⩕',
+  andd: '⩜',
+  andslope: '⩘',
+  andv: '⩚',
+  ang: '∠',
+  ange: '⦤',
+  angle: '∠',
+  angmsd: '∡',
+  angmsdaa: '⦨',
+  angmsdab: '⦩',
+  angmsdac: '⦪',
+  angmsdad: '⦫',
+  angmsdae: '⦬',
+  angmsdaf: '⦭',
+  angmsdag: '⦮',
+  angmsdah: '⦯',
+  angrt: '∟',
+  angrtvb: '⊾',
+  angrtvbd: '⦝',
+  angsph: '∢',
+  angst: 'Å',
+  angzarr: '⍼',
+  aogon: 'ą',
+  aopf: '𝕒',
+  ap: '≈',
+  apE: '⩰',
+  apacir: '⩯',
+  ape: '≊',
+  apid: '≋',
+  apos: "'",
+  approx: '≈',
+  approxeq: '≊',
+  arin: 'å',
+  aring: 'å',
+  ascr: '𝒶',
+  ast: '*',
+  asymp: '≈',
+  asympeq: '≍',
+  atild: 'ã',
+  atilde: 'ã',
+  aum: 'ä',
+  auml: 'ä',
+  awconint: '∳',
+  awint: '⨑',
+  bNot: '⫭',
+  backcong: '≌',
+  backepsilon: '϶',
+  backprime: '‵',
+  backsim: '∽',
+  backsimeq: '⋍',
+  barvee: '⊽',
+  barwed: '⌅',
+  barwedge: '⌅',
+  bbrk: '⎵',
+  bbrktbrk: '⎶',
+  bcong: '≌',
+  bcy: 'б',
+  bdquo: '„',
+  becaus: '∵',
+  because: '∵',
+  bemptyv: '⦰',
+  bepsi: '϶',
+  bernou: 'ℬ',
+  beta: 'β',
+  beth: 'ℶ',
+  between: '≬',
+  bfr: '𝔟',
+  bigcap: '⋂',
+  bigcirc: '◯',
+  bigcup: '⋃',
+  bigodot: '⨀',
+  bigoplus: '⨁',
+  bigotimes: '⨂',
+  bigsqcup: '⨆',
+  bigstar: '★',
+  bigtriangledown: '▽',
+  bigtriangleup: '△',
+  biguplus: '⨄',
+  bigvee: '⋁',
+  bigwedge: '⋀',
+  bkarow: '⤍',
+  blacklozenge: '⧫',
+  blacksquare: '▪',
+  blacktriangle: '▴',
+  blacktriangledown: '▾',
+  blacktriangleleft: '◂',
+  blacktriangleright: '▸',
+  blank: '␣',
+  blk12: '▒',
+  blk14: '░',
+  blk34: '▓',
+  block: '█',
+  bne: '=⃥',
+  bnequiv: '≡⃥',
+  bnot: '⌐',
+  bopf: '𝕓',
+  bot: '⊥',
+  bottom: '⊥',
+  bowtie: '⋈',
+  boxDL: '╗',
+  boxDR: '╔',
+  boxDl: '╖',
+  boxDr: '╓',
+  boxH: '═',
+  boxHD: '╦',
+  boxHU: '╩',
+  boxHd: '╤',
+  boxHu: '╧',
+  boxUL: '╝',
+  boxUR: '╚',
+  boxUl: '╜',
+  boxUr: '╙',
+  boxV: '║',
+  boxVH: '╬',
+  boxVL: '╣',
+  boxVR: '╠',
+  boxVh: '╫',
+  boxVl: '╢',
+  boxVr: '╟',
+  boxbox: '⧉',
+  boxdL: '╕',
+  boxdR: '╒',
+  boxdl: '┐',
+  boxdr: '┌',
+  boxh: '─',
+  boxhD: '╥',
+  boxhU: '╨',
+  boxhd: '┬',
+  boxhu: '┴',
+  boxminus: '⊟',
+  boxplus: '⊞',
+  boxtimes: '⊠',
+  boxuL: '╛',
+  boxuR: '╘',
+  boxul: '┘',
+  boxur: '└',
+  boxv: '│',
+  boxvH: '╪',
+  boxvL: '╡',
+  boxvR: '╞',
+  boxvh: '┼',
+  boxvl: '┤',
+  boxvr: '├',
+  bprime: '‵',
+  breve: '˘',
+  brvba: '¦',
+  brvbar: '¦',
+  bscr: '𝒷',
+  bsemi: '⁏',
+  bsim: '∽',
+  bsime: '⋍',
+  bsol: '\\',
+  bsolb: '⧅',
+  bsolhsub: '⟈',
+  bull: '•',
+  bullet: '•',
+  bump: '≎',
+  bumpE: '⪮',
+  bumpe: '≏',
+  bumpeq: '≏',
+  cacute: 'ć',
+  cap: '∩',
+  capand: '⩄',
+  capbrcup: '⩉',
+  capcap: '⩋',
+  capcup: '⩇',
+  capdot: '⩀',
+  caps: '∩︀',
+  caret: '⁁',
+  caron: 'ˇ',
+  ccaps: '⩍',
+  ccaron: 'č',
+  ccedi: 'ç',
+  ccedil: 'ç',
+  ccirc: 'ĉ',
+  ccups: '⩌',
+  ccupssm: '⩐',
+  cdot: 'ċ',
+  cedi: '¸',
+  cedil: '¸',
+  cemptyv: '⦲',
+  cen: '¢',
+  cent: '¢',
+  centerdot: '·',
+  cfr: '𝔠',
+  chcy: 'ч',
+  check: '✓',
+  checkmark: '✓',
+  chi: 'χ',
+  cir: '○',
+  cirE: '⧃',
+  circ: 'ˆ',
+  circeq: '≗',
+  circlearrowleft: '↺',
+  circlearrowright: '↻',
+  circledR: '®',
+  circledS: 'Ⓢ',
+  circledast: '⊛',
+  circledcirc: '⊚',
+  circleddash: '⊝',
+  cire: '≗',
+  cirfnint: '⨐',
+  cirmid: '⫯',
+  cirscir: '⧂',
+  clubs: '♣',
+  clubsuit: '♣',
+  colon: ':',
+  colone: '≔',
+  coloneq: '≔',
+  comma: ',',
+  commat: '@',
+  comp: '∁',
+  compfn: '∘',
+  complement: '∁',
+  complexes: 'ℂ',
+  cong: '≅',
+  congdot: '⩭',
+  conint: '∮',
+  copf: '𝕔',
+  coprod: '∐',
+  cop: '©',
+  copy: '©',
+  copysr: '℗',
+  crarr: '↵',
+  cross: '✗',
+  cscr: '𝒸',
+  csub: '⫏',
+  csube: '⫑',
+  csup: '⫐',
+  csupe: '⫒',
+  ctdot: '⋯',
+  cudarrl: '⤸',
+  cudarrr: '⤵',
+  cuepr: '⋞',
+  cuesc: '⋟',
+  cularr: '↶',
+  cularrp: '⤽',
+  cup: '∪',
+  cupbrcap: '⩈',
+  cupcap: '⩆',
+  cupcup: '⩊',
+  cupdot: '⊍',
+  cupor: '⩅',
+  cups: '∪︀',
+  curarr: '↷',
+  curarrm: '⤼',
+  curlyeqprec: '⋞',
+  curlyeqsucc: '⋟',
+  curlyvee: '⋎',
+  curlywedge: '⋏',
+  curre: '¤',
+  curren: '¤',
+  curvearrowleft: '↶',
+  curvearrowright: '↷',
+  cuvee: '⋎',
+  cuwed: '⋏',
+  cwconint: '∲',
+  cwint: '∱',
+  cylcty: '⌭',
+  dArr: '⇓',
+  dHar: '⥥',
+  dagger: '†',
+  daleth: 'ℸ',
+  darr: '↓',
+  dash: '‐',
+  dashv: '⊣',
+  dbkarow: '⤏',
+  dblac: '˝',
+  dcaron: 'ď',
+  dcy: 'д',
+  dd: 'ⅆ',
+  ddagger: '‡',
+  ddarr: '⇊',
+  ddotseq: '⩷',
+  de: '°',
+  deg: '°',
+  delta: 'δ',
+  demptyv: '⦱',
+  dfisht: '⥿',
+  dfr: '𝔡',
+  dharl: '⇃',
+  dharr: '⇂',
+  diam: '⋄',
+  diamond: '⋄',
+  diamondsuit: '♦',
+  diams: '♦',
+  die: '¨',
+  digamma: 'ϝ',
+  disin: '⋲',
+  div: '÷',
+  divid: '÷',
+  divide: '÷',
+  divideontimes: '⋇',
+  divonx: '⋇',
+  djcy: 'ђ',
+  dlcorn: '⌞',
+  dlcrop: '⌍',
+  dollar: '$',
+  dopf: '𝕕',
+  dot: '˙',
+  doteq: '≐',
+  doteqdot: '≑',
+  dotminus: '∸',
+  dotplus: '∔',
+  dotsquare: '⊡',
+  doublebarwedge: '⌆',
+  downarrow: '↓',
+  downdownarrows: '⇊',
+  downharpoonleft: '⇃',
+  downharpoonright: '⇂',
+  drbkarow: '⤐',
+  drcorn: '⌟',
+  drcrop: '⌌',
+  dscr: '𝒹',
+  dscy: 'ѕ',
+  dsol: '⧶',
+  dstrok: 'đ',
+  dtdot: '⋱',
+  dtri: '▿',
+  dtrif: '▾',
+  duarr: '⇵',
+  duhar: '⥯',
+  dwangle: '⦦',
+  dzcy: 'џ',
+  dzigrarr: '⟿',
+  eDDot: '⩷',
+  eDot: '≑',
+  eacut: 'é',
+  eacute: 'é',
+  easter: '⩮',
+  ecaron: 'ě',
+  ecir: 'ê',
+  ecirc: 'ê',
+  ecolon: '≕',
+  ecy: 'э',
+  edot: 'ė',
+  ee: 'ⅇ',
+  efDot: '≒',
+  efr: '𝔢',
+  eg: '⪚',
+  egrav: 'è',
+  egrave: 'è',
+  egs: '⪖',
+  egsdot: '⪘',
+  el: '⪙',
+  elinters: '⏧',
+  ell: 'ℓ',
+  els: '⪕',
+  elsdot: '⪗',
+  emacr: 'ē',
+  empty: '∅',
+  emptyset: '∅',
+  emptyv: '∅',
+  emsp13: ' ',
+  emsp14: ' ',
+  emsp: ' ',
+  eng: 'ŋ',
+  ensp: ' ',
+  eogon: 'ę',
+  eopf: '𝕖',
+  epar: '⋕',
+  eparsl: '⧣',
+  eplus: '⩱',
+  epsi: 'ε',
+  epsilon: 'ε',
+  epsiv: 'ϵ',
+  eqcirc: '≖',
+  eqcolon: '≕',
+  eqsim: '≂',
+  eqslantgtr: '⪖',
+  eqslantless: '⪕',
+  equals: '=',
+  equest: '≟',
+  equiv: '≡',
+  equivDD: '⩸',
+  eqvparsl: '⧥',
+  erDot: '≓',
+  erarr: '⥱',
+  escr: 'ℯ',
+  esdot: '≐',
+  esim: '≂',
+  eta: 'η',
+  et: 'ð',
+  eth: 'ð',
+  eum: 'ë',
+  euml: 'ë',
+  euro: '€',
+  excl: '!',
+  exist: '∃',
+  expectation: 'ℰ',
+  exponentiale: 'ⅇ',
+  fallingdotseq: '≒',
+  fcy: 'ф',
+  female: '♀',
+  ffilig: 'ffi',
+  fflig: 'ff',
+  ffllig: 'ffl',
+  ffr: '𝔣',
+  filig: 'fi',
+  fjlig: 'fj',
+  flat: '♭',
+  fllig: 'fl',
+  fltns: '▱',
+  fnof: 'ƒ',
+  fopf: '𝕗',
+  forall: '∀',
+  fork: '⋔',
+  forkv: '⫙',
+  fpartint: '⨍',
+  frac1: '¼',
+  frac12: '½',
+  frac13: '⅓',
+  frac14: '¼',
+  frac15: '⅕',
+  frac16: '⅙',
+  frac18: '⅛',
+  frac23: '⅔',
+  frac25: '⅖',
+  frac3: '¾',
+  frac34: '¾',
+  frac35: '⅗',
+  frac38: '⅜',
+  frac45: '⅘',
+  frac56: '⅚',
+  frac58: '⅝',
+  frac78: '⅞',
+  frasl: '⁄',
+  frown: '⌢',
+  fscr: '𝒻',
+  gE: '≧',
+  gEl: '⪌',
+  gacute: 'ǵ',
+  gamma: 'γ',
+  gammad: 'ϝ',
+  gap: '⪆',
+  gbreve: 'ğ',
+  gcirc: 'ĝ',
+  gcy: 'г',
+  gdot: 'ġ',
+  ge: '≥',
+  gel: '⋛',
+  geq: '≥',
+  geqq: '≧',
+  geqslant: '⩾',
+  ges: '⩾',
+  gescc: '⪩',
+  gesdot: '⪀',
+  gesdoto: '⪂',
+  gesdotol: '⪄',
+  gesl: '⋛︀',
+  gesles: '⪔',
+  gfr: '𝔤',
+  gg: '≫',
+  ggg: '⋙',
+  gimel: 'ℷ',
+  gjcy: 'ѓ',
+  gl: '≷',
+  glE: '⪒',
+  gla: '⪥',
+  glj: '⪤',
+  gnE: '≩',
+  gnap: '⪊',
+  gnapprox: '⪊',
+  gne: '⪈',
+  gneq: '⪈',
+  gneqq: '≩',
+  gnsim: '⋧',
+  gopf: '𝕘',
+  grave: '`',
+  gscr: 'ℊ',
+  gsim: '≳',
+  gsime: '⪎',
+  gsiml: '⪐',
+  g: '>',
+  gt: '>',
+  gtcc: '⪧',
+  gtcir: '⩺',
+  gtdot: '⋗',
+  gtlPar: '⦕',
+  gtquest: '⩼',
+  gtrapprox: '⪆',
+  gtrarr: '⥸',
+  gtrdot: '⋗',
+  gtreqless: '⋛',
+  gtreqqless: '⪌',
+  gtrless: '≷',
+  gtrsim: '≳',
+  gvertneqq: '≩︀',
+  gvnE: '≩︀',
+  hArr: '⇔',
+  hairsp: ' ',
+  half: '½',
+  hamilt: 'ℋ',
+  hardcy: 'ъ',
+  harr: '↔',
+  harrcir: '⥈',
+  harrw: '↭',
+  hbar: 'ℏ',
+  hcirc: 'ĥ',
+  hearts: '♥',
+  heartsuit: '♥',
+  hellip: '…',
+  hercon: '⊹',
+  hfr: '𝔥',
+  hksearow: '⤥',
+  hkswarow: '⤦',
+  hoarr: '⇿',
+  homtht: '∻',
+  hookleftarrow: '↩',
+  hookrightarrow: '↪',
+  hopf: '𝕙',
+  horbar: '―',
+  hscr: '𝒽',
+  hslash: 'ℏ',
+  hstrok: 'ħ',
+  hybull: '⁃',
+  hyphen: '‐',
+  iacut: 'í',
+  iacute: 'í',
+  ic: '⁣',
+  icir: 'î',
+  icirc: 'î',
+  icy: 'и',
+  iecy: 'е',
+  iexc: '¡',
+  iexcl: '¡',
+  iff: '⇔',
+  ifr: '𝔦',
+  igrav: 'ì',
+  igrave: 'ì',
+  ii: 'ⅈ',
+  iiiint: '⨌',
+  iiint: '∭',
+  iinfin: '⧜',
+  iiota: '℩',
+  ijlig: 'ij',
+  imacr: 'ī',
+  image: 'ℑ',
+  imagline: 'ℐ',
+  imagpart: 'ℑ',
+  imath: 'ı',
+  imof: '⊷',
+  imped: 'Ƶ',
+  in: '∈',
+  incare: '℅',
+  infin: '∞',
+  infintie: '⧝',
+  inodot: 'ı',
+  int: '∫',
+  intcal: '⊺',
+  integers: 'ℤ',
+  intercal: '⊺',
+  intlarhk: '⨗',
+  intprod: '⨼',
+  iocy: 'ё',
+  iogon: 'į',
+  iopf: '𝕚',
+  iota: 'ι',
+  iprod: '⨼',
+  iques: '¿',
+  iquest: '¿',
+  iscr: '𝒾',
+  isin: '∈',
+  isinE: '⋹',
+  isindot: '⋵',
+  isins: '⋴',
+  isinsv: '⋳',
+  isinv: '∈',
+  it: '⁢',
+  itilde: 'ĩ',
+  iukcy: 'і',
+  ium: 'ï',
+  iuml: 'ï',
+  jcirc: 'ĵ',
+  jcy: 'й',
+  jfr: '𝔧',
+  jmath: 'ȷ',
+  jopf: '𝕛',
+  jscr: '𝒿',
+  jsercy: 'ј',
+  jukcy: 'є',
+  kappa: 'κ',
+  kappav: 'ϰ',
+  kcedil: 'ķ',
+  kcy: 'к',
+  kfr: '𝔨',
+  kgreen: 'ĸ',
+  khcy: 'х',
+  kjcy: 'ќ',
+  kopf: '𝕜',
+  kscr: '𝓀',
+  lAarr: '⇚',
+  lArr: '⇐',
+  lAtail: '⤛',
+  lBarr: '⤎',
+  lE: '≦',
+  lEg: '⪋',
+  lHar: '⥢',
+  lacute: 'ĺ',
+  laemptyv: '⦴',
+  lagran: 'ℒ',
+  lambda: 'λ',
+  lang: '⟨',
+  langd: '⦑',
+  langle: '⟨',
+  lap: '⪅',
+  laqu: '«',
+  laquo: '«',
+  larr: '←',
+  larrb: '⇤',
+  larrbfs: '⤟',
+  larrfs: '⤝',
+  larrhk: '↩',
+  larrlp: '↫',
+  larrpl: '⤹',
+  larrsim: '⥳',
+  larrtl: '↢',
+  lat: '⪫',
+  latail: '⤙',
+  late: '⪭',
+  lates: '⪭︀',
+  lbarr: '⤌',
+  lbbrk: '❲',
+  lbrace: '{',
+  lbrack: '[',
+  lbrke: '⦋',
+  lbrksld: '⦏',
+  lbrkslu: '⦍',
+  lcaron: 'ľ',
+  lcedil: 'ļ',
+  lceil: '⌈',
+  lcub: '{',
+  lcy: 'л',
+  ldca: '⤶',
+  ldquo: '“',
+  ldquor: '„',
+  ldrdhar: '⥧',
+  ldrushar: '⥋',
+  ldsh: '↲',
+  le: '≤',
+  leftarrow: '←',
+  leftarrowtail: '↢',
+  leftharpoondown: '↽',
+  leftharpoonup: '↼',
+  leftleftarrows: '⇇',
+  leftrightarrow: '↔',
+  leftrightarrows: '⇆',
+  leftrightharpoons: '⇋',
+  leftrightsquigarrow: '↭',
+  leftthreetimes: '⋋',
+  leg: '⋚',
+  leq: '≤',
+  leqq: '≦',
+  leqslant: '⩽',
+  les: '⩽',
+  lescc: '⪨',
+  lesdot: '⩿',
+  lesdoto: '⪁',
+  lesdotor: '⪃',
+  lesg: '⋚︀',
+  lesges: '⪓',
+  lessapprox: '⪅',
+  lessdot: '⋖',
+  lesseqgtr: '⋚',
+  lesseqqgtr: '⪋',
+  lessgtr: '≶',
+  lesssim: '≲',
+  lfisht: '⥼',
+  lfloor: '⌊',
+  lfr: '𝔩',
+  lg: '≶',
+  lgE: '⪑',
+  lhard: '↽',
+  lharu: '↼',
+  lharul: '⥪',
+  lhblk: '▄',
+  ljcy: 'љ',
+  ll: '≪',
+  llarr: '⇇',
+  llcorner: '⌞',
+  llhard: '⥫',
+  lltri: '◺',
+  lmidot: 'ŀ',
+  lmoust: '⎰',
+  lmoustache: '⎰',
+  lnE: '≨',
+  lnap: '⪉',
+  lnapprox: '⪉',
+  lne: '⪇',
+  lneq: '⪇',
+  lneqq: '≨',
+  lnsim: '⋦',
+  loang: '⟬',
+  loarr: '⇽',
+  lobrk: '⟦',
+  longleftarrow: '⟵',
+  longleftrightarrow: '⟷',
+  longmapsto: '⟼',
+  longrightarrow: '⟶',
+  looparrowleft: '↫',
+  looparrowright: '↬',
+  lopar: '⦅',
+  lopf: '𝕝',
+  loplus: '⨭',
+  lotimes: '⨴',
+  lowast: '∗',
+  lowbar: '_',
+  loz: '◊',
+  lozenge: '◊',
+  lozf: '⧫',
+  lpar: '(',
+  lparlt: '⦓',
+  lrarr: '⇆',
+  lrcorner: '⌟',
+  lrhar: '⇋',
+  lrhard: '⥭',
+  lrm: '‎',
+  lrtri: '⊿',
+  lsaquo: '‹',
+  lscr: '𝓁',
+  lsh: '↰',
+  lsim: '≲',
+  lsime: '⪍',
+  lsimg: '⪏',
+  lsqb: '[',
+  lsquo: '‘',
+  lsquor: '‚',
+  lstrok: 'ł',
+  l: '<',
+  lt: '<',
+  ltcc: '⪦',
+  ltcir: '⩹',
+  ltdot: '⋖',
+  lthree: '⋋',
+  ltimes: '⋉',
+  ltlarr: '⥶',
+  ltquest: '⩻',
+  ltrPar: '⦖',
+  ltri: '◃',
+  ltrie: '⊴',
+  ltrif: '◂',
+  lurdshar: '⥊',
+  luruhar: '⥦',
+  lvertneqq: '≨︀',
+  lvnE: '≨︀',
+  mDDot: '∺',
+  mac: '¯',
+  macr: '¯',
+  male: '♂',
+  malt: '✠',
+  maltese: '✠',
+  map: '↦',
+  mapsto: '↦',
+  mapstodown: '↧',
+  mapstoleft: '↤',
+  mapstoup: '↥',
+  marker: '▮',
+  mcomma: '⨩',
+  mcy: 'м',
+  mdash: '—',
+  measuredangle: '∡',
+  mfr: '𝔪',
+  mho: '℧',
+  micr: 'µ',
+  micro: 'µ',
+  mid: '∣',
+  midast: '*',
+  midcir: '⫰',
+  middo: '·',
+  middot: '·',
+  minus: '−',
+  minusb: '⊟',
+  minusd: '∸',
+  minusdu: '⨪',
+  mlcp: '⫛',
+  mldr: '…',
+  mnplus: '∓',
+  models: '⊧',
+  mopf: '𝕞',
+  mp: '∓',
+  mscr: '𝓂',
+  mstpos: '∾',
+  mu: 'μ',
+  multimap: '⊸',
+  mumap: '⊸',
+  nGg: '⋙̸',
+  nGt: '≫⃒',
+  nGtv: '≫̸',
+  nLeftarrow: '⇍',
+  nLeftrightarrow: '⇎',
+  nLl: '⋘̸',
+  nLt: '≪⃒',
+  nLtv: '≪̸',
+  nRightarrow: '⇏',
+  nVDash: '⊯',
+  nVdash: '⊮',
+  nabla: '∇',
+  nacute: 'ń',
+  nang: '∠⃒',
+  nap: '≉',
+  napE: '⩰̸',
+  napid: '≋̸',
+  napos: 'ʼn',
+  napprox: '≉',
+  natur: '♮',
+  natural: '♮',
+  naturals: 'ℕ',
+  nbs: ' ',
+  nbsp: ' ',
+  nbump: '≎̸',
+  nbumpe: '≏̸',
+  ncap: '⩃',
+  ncaron: 'ň',
+  ncedil: 'ņ',
+  ncong: '≇',
+  ncongdot: '⩭̸',
+  ncup: '⩂',
+  ncy: 'н',
+  ndash: '–',
+  ne: '≠',
+  neArr: '⇗',
+  nearhk: '⤤',
+  nearr: '↗',
+  nearrow: '↗',
+  nedot: '≐̸',
+  nequiv: '≢',
+  nesear: '⤨',
+  nesim: '≂̸',
+  nexist: '∄',
+  nexists: '∄',
+  nfr: '𝔫',
+  ngE: '≧̸',
+  nge: '≱',
+  ngeq: '≱',
+  ngeqq: '≧̸',
+  ngeqslant: '⩾̸',
+  nges: '⩾̸',
+  ngsim: '≵',
+  ngt: '≯',
+  ngtr: '≯',
+  nhArr: '⇎',
+  nharr: '↮',
+  nhpar: '⫲',
+  ni: '∋',
+  nis: '⋼',
+  nisd: '⋺',
+  niv: '∋',
+  njcy: 'њ',
+  nlArr: '⇍',
+  nlE: '≦̸',
+  nlarr: '↚',
+  nldr: '‥',
+  nle: '≰',
+  nleftarrow: '↚',
+  nleftrightarrow: '↮',
+  nleq: '≰',
+  nleqq: '≦̸',
+  nleqslant: '⩽̸',
+  nles: '⩽̸',
+  nless: '≮',
+  nlsim: '≴',
+  nlt: '≮',
+  nltri: '⋪',
+  nltrie: '⋬',
+  nmid: '∤',
+  nopf: '𝕟',
+  no: '¬',
+  not: '¬',
+  notin: '∉',
+  notinE: '⋹̸',
+  notindot: '⋵̸',
+  notinva: '∉',
+  notinvb: '⋷',
+  notinvc: '⋶',
+  notni: '∌',
+  notniva: '∌',
+  notnivb: '⋾',
+  notnivc: '⋽',
+  npar: '∦',
+  nparallel: '∦',
+  nparsl: '⫽⃥',
+  npart: '∂̸',
+  npolint: '⨔',
+  npr: '⊀',
+  nprcue: '⋠',
+  npre: '⪯̸',
+  nprec: '⊀',
+  npreceq: '⪯̸',
+  nrArr: '⇏',
+  nrarr: '↛',
+  nrarrc: '⤳̸',
+  nrarrw: '↝̸',
+  nrightarrow: '↛',
+  nrtri: '⋫',
+  nrtrie: '⋭',
+  nsc: '⊁',
+  nsccue: '⋡',
+  nsce: '⪰̸',
+  nscr: '𝓃',
+  nshortmid: '∤',
+  nshortparallel: '∦',
+  nsim: '≁',
+  nsime: '≄',
+  nsimeq: '≄',
+  nsmid: '∤',
+  nspar: '∦',
+  nsqsube: '⋢',
+  nsqsupe: '⋣',
+  nsub: '⊄',
+  nsubE: '⫅̸',
+  nsube: '⊈',
+  nsubset: '⊂⃒',
+  nsubseteq: '⊈',
+  nsubseteqq: '⫅̸',
+  nsucc: '⊁',
+  nsucceq: '⪰̸',
+  nsup: '⊅',
+  nsupE: '⫆̸',
+  nsupe: '⊉',
+  nsupset: '⊃⃒',
+  nsupseteq: '⊉',
+  nsupseteqq: '⫆̸',
+  ntgl: '≹',
+  ntild: 'ñ',
+  ntilde: 'ñ',
+  ntlg: '≸',
+  ntriangleleft: '⋪',
+  ntrianglelefteq: '⋬',
+  ntriangleright: '⋫',
+  ntrianglerighteq: '⋭',
+  nu: 'ν',
+  num: '#',
+  numero: '№',
+  numsp: ' ',
+  nvDash: '⊭',
+  nvHarr: '⤄',
+  nvap: '≍⃒',
+  nvdash: '⊬',
+  nvge: '≥⃒',
+  nvgt: '>⃒',
+  nvinfin: '⧞',
+  nvlArr: '⤂',
+  nvle: '≤⃒',
+  nvlt: '<⃒',
+  nvltrie: '⊴⃒',
+  nvrArr: '⤃',
+  nvrtrie: '⊵⃒',
+  nvsim: '∼⃒',
+  nwArr: '⇖',
+  nwarhk: '⤣',
+  nwarr: '↖',
+  nwarrow: '↖',
+  nwnear: '⤧',
+  oS: 'Ⓢ',
+  oacut: 'ó',
+  oacute: 'ó',
+  oast: '⊛',
+  ocir: 'ô',
+  ocirc: 'ô',
+  ocy: 'о',
+  odash: '⊝',
+  odblac: 'ő',
+  odiv: '⨸',
+  odot: '⊙',
+  odsold: '⦼',
+  oelig: 'œ',
+  ofcir: '⦿',
+  ofr: '𝔬',
+  ogon: '˛',
+  ograv: 'ò',
+  ograve: 'ò',
+  ogt: '⧁',
+  ohbar: '⦵',
+  ohm: 'Ω',
+  oint: '∮',
+  olarr: '↺',
+  olcir: '⦾',
+  olcross: '⦻',
+  oline: '‾',
+  olt: '⧀',
+  omacr: 'ō',
+  omega: 'ω',
+  omicron: 'ο',
+  omid: '⦶',
+  ominus: '⊖',
+  oopf: '𝕠',
+  opar: '⦷',
+  operp: '⦹',
+  oplus: '⊕',
+  or: '∨',
+  orarr: '↻',
+  ord: 'º',
+  order: 'ℴ',
+  orderof: 'ℴ',
+  ordf: 'ª',
+  ordm: 'º',
+  origof: '⊶',
+  oror: '⩖',
+  orslope: '⩗',
+  orv: '⩛',
+  oscr: 'ℴ',
+  oslas: 'ø',
+  oslash: 'ø',
+  osol: '⊘',
+  otild: 'õ',
+  otilde: 'õ',
+  otimes: '⊗',
+  otimesas: '⨶',
+  oum: 'ö',
+  ouml: 'ö',
+  ovbar: '⌽',
+  par: '¶',
+  para: '¶',
+  parallel: '∥',
+  parsim: '⫳',
+  parsl: '⫽',
+  part: '∂',
+  pcy: 'п',
+  percnt: '%',
+  period: '.',
+  permil: '‰',
+  perp: '⊥',
+  pertenk: '‱',
+  pfr: '𝔭',
+  phi: 'φ',
+  phiv: 'ϕ',
+  phmmat: 'ℳ',
+  phone: '☎',
+  pi: 'π',
+  pitchfork: '⋔',
+  piv: 'ϖ',
+  planck: 'ℏ',
+  planckh: 'ℎ',
+  plankv: 'ℏ',
+  plus: '+',
+  plusacir: '⨣',
+  plusb: '⊞',
+  pluscir: '⨢',
+  plusdo: '∔',
+  plusdu: '⨥',
+  pluse: '⩲',
+  plusm: '±',
+  plusmn: '±',
+  plussim: '⨦',
+  plustwo: '⨧',
+  pm: '±',
+  pointint: '⨕',
+  popf: '𝕡',
+  poun: '£',
+  pound: '£',
+  pr: '≺',
+  prE: '⪳',
+  prap: '⪷',
+  prcue: '≼',
+  pre: '⪯',
+  prec: '≺',
+  precapprox: '⪷',
+  preccurlyeq: '≼',
+  preceq: '⪯',
+  precnapprox: '⪹',
+  precneqq: '⪵',
+  precnsim: '⋨',
+  precsim: '≾',
+  prime: '′',
+  primes: 'ℙ',
+  prnE: '⪵',
+  prnap: '⪹',
+  prnsim: '⋨',
+  prod: '∏',
+  profalar: '⌮',
+  profline: '⌒',
+  profsurf: '⌓',
+  prop: '∝',
+  propto: '∝',
+  prsim: '≾',
+  prurel: '⊰',
+  pscr: '𝓅',
+  psi: 'ψ',
+  puncsp: ' ',
+  qfr: '𝔮',
+  qint: '⨌',
+  qopf: '𝕢',
+  qprime: '⁗',
+  qscr: '𝓆',
+  quaternions: 'ℍ',
+  quatint: '⨖',
+  quest: '?',
+  questeq: '≟',
+  quo: '"',
+  quot: '"',
+  rAarr: '⇛',
+  rArr: '⇒',
+  rAtail: '⤜',
+  rBarr: '⤏',
+  rHar: '⥤',
+  race: '∽̱',
+  racute: 'ŕ',
+  radic: '√',
+  raemptyv: '⦳',
+  rang: '⟩',
+  rangd: '⦒',
+  range: '⦥',
+  rangle: '⟩',
+  raqu: '»',
+  raquo: '»',
+  rarr: '→',
+  rarrap: '⥵',
+  rarrb: '⇥',
+  rarrbfs: '⤠',
+  rarrc: '⤳',
+  rarrfs: '⤞',
+  rarrhk: '↪',
+  rarrlp: '↬',
+  rarrpl: '⥅',
+  rarrsim: '⥴',
+  rarrtl: '↣',
+  rarrw: '↝',
+  ratail: '⤚',
+  ratio: '∶',
+  rationals: 'ℚ',
+  rbarr: '⤍',
+  rbbrk: '❳',
+  rbrace: '}',
+  rbrack: ']',
+  rbrke: '⦌',
+  rbrksld: '⦎',
+  rbrkslu: '⦐',
+  rcaron: 'ř',
+  rcedil: 'ŗ',
+  rceil: '⌉',
+  rcub: '}',
+  rcy: 'р',
+  rdca: '⤷',
+  rdldhar: '⥩',
+  rdquo: '”',
+  rdquor: '”',
+  rdsh: '↳',
+  real: 'ℜ',
+  realine: 'ℛ',
+  realpart: 'ℜ',
+  reals: 'ℝ',
+  rect: '▭',
+  re: '®',
+  reg: '®',
+  rfisht: '⥽',
+  rfloor: '⌋',
+  rfr: '𝔯',
+  rhard: '⇁',
+  rharu: '⇀',
+  rharul: '⥬',
+  rho: 'ρ',
+  rhov: 'ϱ',
+  rightarrow: '→',
+  rightarrowtail: '↣',
+  rightharpoondown: '⇁',
+  rightharpoonup: '⇀',
+  rightleftarrows: '⇄',
+  rightleftharpoons: '⇌',
+  rightrightarrows: '⇉',
+  rightsquigarrow: '↝',
+  rightthreetimes: '⋌',
+  ring: '˚',
+  risingdotseq: '≓',
+  rlarr: '⇄',
+  rlhar: '⇌',
+  rlm: '‏',
+  rmoust: '⎱',
+  rmoustache: '⎱',
+  rnmid: '⫮',
+  roang: '⟭',
+  roarr: '⇾',
+  robrk: '⟧',
+  ropar: '⦆',
+  ropf: '𝕣',
+  roplus: '⨮',
+  rotimes: '⨵',
+  rpar: ')',
+  rpargt: '⦔',
+  rppolint: '⨒',
+  rrarr: '⇉',
+  rsaquo: '›',
+  rscr: '𝓇',
+  rsh: '↱',
+  rsqb: ']',
+  rsquo: '’',
+  rsquor: '’',
+  rthree: '⋌',
+  rtimes: '⋊',
+  rtri: '▹',
+  rtrie: '⊵',
+  rtrif: '▸',
+  rtriltri: '⧎',
+  ruluhar: '⥨',
+  rx: '℞',
+  sacute: 'ś',
+  sbquo: '‚',
+  sc: '≻',
+  scE: '⪴',
+  scap: '⪸',
+  scaron: 'š',
+  sccue: '≽',
+  sce: '⪰',
+  scedil: 'ş',
+  scirc: 'ŝ',
+  scnE: '⪶',
+  scnap: '⪺',
+  scnsim: '⋩',
+  scpolint: '⨓',
+  scsim: '≿',
+  scy: 'с',
+  sdot: '⋅',
+  sdotb: '⊡',
+  sdote: '⩦',
+  seArr: '⇘',
+  searhk: '⤥',
+  searr: '↘',
+  searrow: '↘',
+  sec: '§',
+  sect: '§',
+  semi: ';',
+  seswar: '⤩',
+  setminus: '∖',
+  setmn: '∖',
+  sext: '✶',
+  sfr: '𝔰',
+  sfrown: '⌢',
+  sharp: '♯',
+  shchcy: 'щ',
+  shcy: 'ш',
+  shortmid: '∣',
+  shortparallel: '∥',
+  sh: '­',
+  shy: '­',
+  sigma: 'σ',
+  sigmaf: 'ς',
+  sigmav: 'ς',
+  sim: '∼',
+  simdot: '⩪',
+  sime: '≃',
+  simeq: '≃',
+  simg: '⪞',
+  simgE: '⪠',
+  siml: '⪝',
+  simlE: '⪟',
+  simne: '≆',
+  simplus: '⨤',
+  simrarr: '⥲',
+  slarr: '←',
+  smallsetminus: '∖',
+  smashp: '⨳',
+  smeparsl: '⧤',
+  smid: '∣',
+  smile: '⌣',
+  smt: '⪪',
+  smte: '⪬',
+  smtes: '⪬︀',
+  softcy: 'ь',
+  sol: '/',
+  solb: '⧄',
+  solbar: '⌿',
+  sopf: '𝕤',
+  spades: '♠',
+  spadesuit: '♠',
+  spar: '∥',
+  sqcap: '⊓',
+  sqcaps: '⊓︀',
+  sqcup: '⊔',
+  sqcups: '⊔︀',
+  sqsub: '⊏',
+  sqsube: '⊑',
+  sqsubset: '⊏',
+  sqsubseteq: '⊑',
+  sqsup: '⊐',
+  sqsupe: '⊒',
+  sqsupset: '⊐',
+  sqsupseteq: '⊒',
+  squ: '□',
+  square: '□',
+  squarf: '▪',
+  squf: '▪',
+  srarr: '→',
+  sscr: '𝓈',
+  ssetmn: '∖',
+  ssmile: '⌣',
+  sstarf: '⋆',
+  star: '☆',
+  starf: '★',
+  straightepsilon: 'ϵ',
+  straightphi: 'ϕ',
+  strns: '¯',
+  sub: '⊂',
+  subE: '⫅',
+  subdot: '⪽',
+  sube: '⊆',
+  subedot: '⫃',
+  submult: '⫁',
+  subnE: '⫋',
+  subne: '⊊',
+  subplus: '⪿',
+  subrarr: '⥹',
+  subset: '⊂',
+  subseteq: '⊆',
+  subseteqq: '⫅',
+  subsetneq: '⊊',
+  subsetneqq: '⫋',
+  subsim: '⫇',
+  subsub: '⫕',
+  subsup: '⫓',
+  succ: '≻',
+  succapprox: '⪸',
+  succcurlyeq: '≽',
+  succeq: '⪰',
+  succnapprox: '⪺',
+  succneqq: '⪶',
+  succnsim: '⋩',
+  succsim: '≿',
+  sum: '∑',
+  sung: '♪',
+  sup: '⊃',
+  sup1: '¹',
+  sup2: '²',
+  sup3: '³',
+  supE: '⫆',
+  supdot: '⪾',
+  supdsub: '⫘',
+  supe: '⊇',
+  supedot: '⫄',
+  suphsol: '⟉',
+  suphsub: '⫗',
+  suplarr: '⥻',
+  supmult: '⫂',
+  supnE: '⫌',
+  supne: '⊋',
+  supplus: '⫀',
+  supset: '⊃',
+  supseteq: '⊇',
+  supseteqq: '⫆',
+  supsetneq: '⊋',
+  supsetneqq: '⫌',
+  supsim: '⫈',
+  supsub: '⫔',
+  supsup: '⫖',
+  swArr: '⇙',
+  swarhk: '⤦',
+  swarr: '↙',
+  swarrow: '↙',
+  swnwar: '⤪',
+  szli: 'ß',
+  szlig: 'ß',
+  target: '⌖',
+  tau: 'τ',
+  tbrk: '⎴',
+  tcaron: 'ť',
+  tcedil: 'ţ',
+  tcy: 'т',
+  tdot: '⃛',
+  telrec: '⌕',
+  tfr: '𝔱',
+  there4: '∴',
+  therefore: '∴',
+  theta: 'θ',
+  thetasym: 'ϑ',
+  thetav: 'ϑ',
+  thickapprox: '≈',
+  thicksim: '∼',
+  thinsp: ' ',
+  thkap: '≈',
+  thksim: '∼',
+  thor: 'þ',
+  thorn: 'þ',
+  tilde: '˜',
+  time: '×',
+  times: '×',
+  timesb: '⊠',
+  timesbar: '⨱',
+  timesd: '⨰',
+  tint: '∭',
+  toea: '⤨',
+  top: '⊤',
+  topbot: '⌶',
+  topcir: '⫱',
+  topf: '𝕥',
+  topfork: '⫚',
+  tosa: '⤩',
+  tprime: '‴',
+  trade: '™',
+  triangle: '▵',
+  triangledown: '▿',
+  triangleleft: '◃',
+  trianglelefteq: '⊴',
+  triangleq: '≜',
+  triangleright: '▹',
+  trianglerighteq: '⊵',
+  tridot: '◬',
+  trie: '≜',
+  triminus: '⨺',
+  triplus: '⨹',
+  trisb: '⧍',
+  tritime: '⨻',
+  trpezium: '⏢',
+  tscr: '𝓉',
+  tscy: 'ц',
+  tshcy: 'ћ',
+  tstrok: 'ŧ',
+  twixt: '≬',
+  twoheadleftarrow: '↞',
+  twoheadrightarrow: '↠',
+  uArr: '⇑',
+  uHar: '⥣',
+  uacut: 'ú',
+  uacute: 'ú',
+  uarr: '↑',
+  ubrcy: 'ў',
+  ubreve: 'ŭ',
+  ucir: 'û',
+  ucirc: 'û',
+  ucy: 'у',
+  udarr: '⇅',
+  udblac: 'ű',
+  udhar: '⥮',
+  ufisht: '⥾',
+  ufr: '𝔲',
+  ugrav: 'ù',
+  ugrave: 'ù',
+  uharl: '↿',
+  uharr: '↾',
+  uhblk: '▀',
+  ulcorn: '⌜',
+  ulcorner: '⌜',
+  ulcrop: '⌏',
+  ultri: '◸',
+  umacr: 'ū',
+  um: '¨',
+  uml: '¨',
+  uogon: 'ų',
+  uopf: '𝕦',
+  uparrow: '↑',
+  updownarrow: '↕',
+  upharpoonleft: '↿',
+  upharpoonright: '↾',
+  uplus: '⊎',
+  upsi: 'υ',
+  upsih: 'ϒ',
+  upsilon: 'υ',
+  upuparrows: '⇈',
+  urcorn: '⌝',
+  urcorner: '⌝',
+  urcrop: '⌎',
+  uring: 'ů',
+  urtri: '◹',
+  uscr: '𝓊',
+  utdot: '⋰',
+  utilde: 'ũ',
+  utri: '▵',
+  utrif: '▴',
+  uuarr: '⇈',
+  uum: 'ü',
+  uuml: 'ü',
+  uwangle: '⦧',
+  vArr: '⇕',
+  vBar: '⫨',
+  vBarv: '⫩',
+  vDash: '⊨',
+  vangrt: '⦜',
+  varepsilon: 'ϵ',
+  varkappa: 'ϰ',
+  varnothing: '∅',
+  varphi: 'ϕ',
+  varpi: 'ϖ',
+  varpropto: '∝',
+  varr: '↕',
+  varrho: 'ϱ',
+  varsigma: 'ς',
+  varsubsetneq: '⊊︀',
+  varsubsetneqq: '⫋︀',
+  varsupsetneq: '⊋︀',
+  varsupsetneqq: '⫌︀',
+  vartheta: 'ϑ',
+  vartriangleleft: '⊲',
+  vartriangleright: '⊳',
+  vcy: 'в',
+  vdash: '⊢',
+  vee: '∨',
+  veebar: '⊻',
+  veeeq: '≚',
+  vellip: '⋮',
+  verbar: '|',
+  vert: '|',
+  vfr: '𝔳',
+  vltri: '⊲',
+  vnsub: '⊂⃒',
+  vnsup: '⊃⃒',
+  vopf: '𝕧',
+  vprop: '∝',
+  vrtri: '⊳',
+  vscr: '𝓋',
+  vsubnE: '⫋︀',
+  vsubne: '⊊︀',
+  vsupnE: '⫌︀',
+  vsupne: '⊋︀',
+  vzigzag: '⦚',
+  wcirc: 'ŵ',
+  wedbar: '⩟',
+  wedge: '∧',
+  wedgeq: '≙',
+  weierp: '℘',
+  wfr: '𝔴',
+  wopf: '𝕨',
+  wp: '℘',
+  wr: '≀',
+  wreath: '≀',
+  wscr: '𝓌',
+  xcap: '⋂',
+  xcirc: '◯',
+  xcup: '⋃',
+  xdtri: '▽',
+  xfr: '𝔵',
+  xhArr: '⟺',
+  xharr: '⟷',
+  xi: 'ξ',
+  xlArr: '⟸',
+  xlarr: '⟵',
+  xmap: '⟼',
+  xnis: '⋻',
+  xodot: '⨀',
+  xopf: '𝕩',
+  xoplus: '⨁',
+  xotime: '⨂',
+  xrArr: '⟹',
+  xrarr: '⟶',
+  xscr: '𝓍',
+  xsqcup: '⨆',
+  xuplus: '⨄',
+  xutri: '△',
+  xvee: '⋁',
+  xwedge: '⋀',
+  yacut: 'ý',
+  yacute: 'ý',
+  yacy: 'я',
+  ycirc: 'ŷ',
+  ycy: 'ы',
+  ye: '¥',
+  yen: '¥',
+  yfr: '𝔶',
+  yicy: 'ї',
+  yopf: '𝕪',
+  yscr: '𝓎',
+  yucy: 'ю',
+  yum: 'ÿ',
+  yuml: 'ÿ',
+  zacute: 'ź',
+  zcaron: 'ž',
+  zcy: 'з',
+  zdot: 'ż',
+  zeetrf: 'ℨ',
+  zeta: 'ζ',
+  zfr: '𝔷',
+  zhcy: 'ж',
+  zigrarr: '⇝',
+  zopf: '𝕫',
+  zscr: '𝓏',
+  zwj: '‍',
+  zwnj: '‌'
+};
 
-      if (depth === 0 || siblings.length === 0) {
-        push({ type: 'text', value });
-        continue;
-      }
+var own$5 = {}.hasOwnProperty;
 
-      if (prev.type === 'dot') {
-        block.range = [];
-        prev.value += value;
-        prev.type = 'range';
+/**
+ * @param {string} characters
+ * @returns {string|false}
+ */
+function decodeEntity(characters) {
+  return own$5.call(characterEntities, characters)
+    ? characterEntities[characters]
+    : false
+}
 
-        if (block.nodes.length !== 3 && block.nodes.length !== 5) {
-          block.invalid = true;
-          block.ranges = 0;
-          prev.type = 'text';
-          continue;
-        }
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
 
-        block.ranges++;
-        block.args = [];
-        continue;
-      }
+/** @type {Construct} */
+const characterReference$1 = {
+  name: 'characterReference',
+  tokenize: tokenizeCharacterReference
+};
+/** @type {Tokenizer} */
 
-      if (prev.type === 'range') {
-        siblings.pop();
+function tokenizeCharacterReference(effects, ok, nok) {
+  const self = this;
+  let size = 0;
+  /** @type {number} */
 
-        let before = siblings[siblings.length - 1];
-        before.value += prev.value + value;
-        prev = before;
-        block.ranges--;
-        continue;
-      }
+  let max;
+  /** @type {(code: Code) => code is number} */
 
-      push({ type: 'dot', value });
-      continue;
+  let test;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('characterReference');
+    effects.enter('characterReferenceMarker');
+    effects.consume(code);
+    effects.exit('characterReferenceMarker');
+    return open
+  }
+  /** @type {State} */
+
+  function open(code) {
+    if (code === 35) {
+      effects.enter('characterReferenceMarkerNumeric');
+      effects.consume(code);
+      effects.exit('characterReferenceMarkerNumeric');
+      return numeric
     }
 
-    /**
-     * Text
-     */
+    effects.enter('characterReferenceValue');
+    max = 31;
+    test = asciiAlphanumeric;
+    return value(code)
+  }
+  /** @type {State} */
 
-    push({ type: 'text', value });
+  function numeric(code) {
+    if (code === 88 || code === 120) {
+      effects.enter('characterReferenceMarkerHexadecimal');
+      effects.consume(code);
+      effects.exit('characterReferenceMarkerHexadecimal');
+      effects.enter('characterReferenceValue');
+      max = 6;
+      test = asciiHexDigit;
+      return value
+    }
+
+    effects.enter('characterReferenceValue');
+    max = 7;
+    test = asciiDigit;
+    return value(code)
   }
+  /** @type {State} */
 
-  // Mark imbalanced braces and brackets as invalid
-  do {
-    block = stack.pop();
+  function value(code) {
+    /** @type {Token} */
+    let token;
 
-    if (block.type !== 'root') {
-      block.nodes.forEach(node => {
-        if (!node.nodes) {
-          if (node.type === 'open') node.isOpen = true;
-          if (node.type === 'close') node.isClose = true;
-          if (!node.nodes) node.type = 'text';
-          node.invalid = true;
-        }
-      });
+    if (code === 59 && size) {
+      token = effects.exit('characterReferenceValue');
 
-      // get the location of the block on parent.nodes (block's siblings)
-      let parent = stack[stack.length - 1];
-      let index = parent.nodes.indexOf(block);
-      // replace the (invalid) block with it's nodes
-      parent.nodes.splice(index, 1, ...block.nodes);
+      if (
+        test === asciiAlphanumeric &&
+        !decodeEntity(self.sliceSerialize(token))
+      ) {
+        return nok(code)
+      }
+
+      effects.enter('characterReferenceMarker');
+      effects.consume(code);
+      effects.exit('characterReferenceMarker');
+      effects.exit('characterReference');
+      return ok
     }
-  } while (stack.length > 0);
 
-  push({ type: 'eos' });
-  return ast;
-};
+    if (test(code) && size++ < max) {
+      effects.consume(code);
+      return value
+    }
 
-var parse_1$2 = parse$6;
+    return nok(code)
+  }
+}
 
 /**
- * Expand the given pattern or create a regex-compatible string.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
- * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {String}
- * @api public
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
  */
 
-const braces = (input, options = {}) => {
-  let output = [];
+/** @type {Construct} */
+const codeFenced = {
+  name: 'codeFenced',
+  tokenize: tokenizeCodeFenced,
+  concrete: true
+};
+/** @type {Tokenizer} */
 
-  if (Array.isArray(input)) {
-    for (let pattern of input) {
-      let result = braces.create(pattern, options);
-      if (Array.isArray(result)) {
-        output.push(...result);
-      } else {
-        output.push(result);
-      }
-    }
-  } else {
-    output = [].concat(braces.create(input, options));
-  }
+function tokenizeCodeFenced(effects, ok, nok) {
+  const self = this;
+  /** @type {Construct} */
 
-  if (options && options.expand === true && options.nodupes === true) {
-    output = [...new Set(output)];
+  const closingFenceConstruct = {
+    tokenize: tokenizeClosingFence,
+    partial: true
+  };
+  /** @type {Construct} */
+
+  const nonLazyLine = {
+    tokenize: tokenizeNonLazyLine,
+    partial: true
+  };
+  const tail = this.events[this.events.length - 1];
+  const initialPrefix =
+    tail && tail[1].type === 'linePrefix'
+      ? tail[2].sliceSerialize(tail[1], true).length
+      : 0;
+  let sizeOpen = 0;
+  /** @type {NonNullable<Code>} */
+
+  let marker;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('codeFenced');
+    effects.enter('codeFencedFence');
+    effects.enter('codeFencedFenceSequence');
+    marker = code;
+    return sequenceOpen(code)
   }
-  return output;
-};
+  /** @type {State} */
 
-/**
- * Parse the given `str` with the given `options`.
- *
- * ```js
- * // braces.parse(pattern, [, options]);
- * const ast = braces.parse('a/{b,c}/d');
- * console.log(ast);
- * ```
- * @param {String} pattern Brace pattern to parse
- * @param {Object} options
- * @return {Object} Returns an AST
- * @api public
- */
+  function sequenceOpen(code) {
+    if (code === marker) {
+      effects.consume(code);
+      sizeOpen++;
+      return sequenceOpen
+    }
 
-braces.parse = (input, options = {}) => parse_1$2(input, options);
+    effects.exit('codeFencedFenceSequence');
+    return sizeOpen < 3
+      ? nok(code)
+      : factorySpace(effects, infoOpen, 'whitespace')(code)
+  }
+  /** @type {State} */
 
-/**
- * Creates a braces string from an AST, or an AST node.
- *
- * ```js
- * const braces = require('braces');
- * let ast = braces.parse('foo/{a,b}/bar');
- * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
- * ```
- * @param {String} `input` Brace pattern or AST.
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
+  function infoOpen(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return openAfter(code)
+    }
 
-braces.stringify = (input, options = {}) => {
-  if (typeof input === 'string') {
-    return stringify$3(braces.parse(input, options), options);
+    effects.enter('codeFencedFenceInfo');
+    effects.enter('chunkString', {
+      contentType: 'string'
+    });
+    return info(code)
   }
-  return stringify$3(input, options);
-};
+  /** @type {State} */
 
-/**
- * Compiles a brace pattern into a regex-compatible, optimized string.
- * This method is called by the main [braces](#braces) function by default.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.compile('a/{b,c}/d'));
- * //=> ['a/(b|c)/d']
- * ```
- * @param {String} `input` Brace pattern or AST.
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
+  function info(code) {
+    if (code === null || markdownLineEndingOrSpace(code)) {
+      effects.exit('chunkString');
+      effects.exit('codeFencedFenceInfo');
+      return factorySpace(effects, infoAfter, 'whitespace')(code)
+    }
 
-braces.compile = (input, options = {}) => {
-  if (typeof input === 'string') {
-    input = braces.parse(input, options);
+    if (code === 96 && code === marker) return nok(code)
+    effects.consume(code);
+    return info
   }
-  return compile_1(input, options);
-};
+  /** @type {State} */
 
-/**
- * Expands a brace pattern into an array. This method is called by the
- * main [braces](#braces) function when `options.expand` is true. Before
- * using this method it's recommended that you read the [performance notes](#performance))
- * and advantages of using [.compile](#compile) instead.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.expand('a/{b,c}/d'));
- * //=> ['a/b/d', 'a/c/d'];
- * ```
- * @param {String} `pattern` Brace pattern
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
+  function infoAfter(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return openAfter(code)
+    }
 
-braces.expand = (input, options = {}) => {
-  if (typeof input === 'string') {
-    input = braces.parse(input, options);
+    effects.enter('codeFencedFenceMeta');
+    effects.enter('chunkString', {
+      contentType: 'string'
+    });
+    return meta(code)
   }
+  /** @type {State} */
 
-  let result = expand_1(input, options);
+  function meta(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit('chunkString');
+      effects.exit('codeFencedFenceMeta');
+      return openAfter(code)
+    }
 
-  // filter out empty strings if specified
-  if (options.noempty === true) {
-    result = result.filter(Boolean);
+    if (code === 96 && code === marker) return nok(code)
+    effects.consume(code);
+    return meta
   }
+  /** @type {State} */
 
-  // filter out duplicates if specified
-  if (options.nodupes === true) {
-    result = [...new Set(result)];
+  function openAfter(code) {
+    effects.exit('codeFencedFence');
+    return self.interrupt ? ok(code) : contentStart(code)
   }
+  /** @type {State} */
 
-  return result;
-};
+  function contentStart(code) {
+    if (code === null) {
+      return after(code)
+    }
 
-/**
- * Processes a brace pattern and returns either an expanded array
- * (if `options.expand` is true), a highly optimized regex-compatible string.
- * This method is called by the main [braces](#braces) function.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
- * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
- * ```
- * @param {String} `pattern` Brace pattern
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
+    if (markdownLineEnding(code)) {
+      return effects.attempt(
+        nonLazyLine,
+        effects.attempt(
+          closingFenceConstruct,
+          after,
+          initialPrefix
+            ? factorySpace(
+                effects,
+                contentStart,
+                'linePrefix',
+                initialPrefix + 1
+              )
+            : contentStart
+        ),
+        after
+      )(code)
+    }
 
-braces.create = (input, options = {}) => {
-  if (input === '' || input.length < 3) {
-    return [input];
+    effects.enter('codeFlowValue');
+    return contentContinue(code)
   }
+  /** @type {State} */
 
- return options.expand !== true
-    ? braces.compile(input, options)
-    : braces.expand(input, options);
-};
+  function contentContinue(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit('codeFlowValue');
+      return contentStart(code)
+    }
 
-/**
- * Expose "braces"
- */
+    effects.consume(code);
+    return contentContinue
+  }
+  /** @type {State} */
+
+  function after(code) {
+    effects.exit('codeFenced');
+    return ok(code)
+  }
+  /** @type {Tokenizer} */
 
-var braces_1 = braces;
+  function tokenizeNonLazyLine(effects, ok, nok) {
+    const self = this;
+    return start
+    /** @type {State} */
 
-var binaryExtensions = [
-	"3dm",
-	"3ds",
-	"3g2",
-	"3gp",
-	"7z",
-	"a",
-	"aac",
-	"adp",
-	"ai",
-	"aif",
-	"aiff",
-	"alz",
-	"ape",
-	"apk",
-	"ar",
-	"arj",
-	"asf",
-	"au",
-	"avi",
-	"bak",
-	"baml",
-	"bh",
-	"bin",
-	"bk",
-	"bmp",
-	"btif",
-	"bz2",
-	"bzip2",
-	"cab",
-	"caf",
-	"cgm",
-	"class",
-	"cmx",
-	"cpio",
-	"cr2",
-	"cur",
-	"dat",
-	"dcm",
-	"deb",
-	"dex",
-	"djvu",
-	"dll",
-	"dmg",
-	"dng",
-	"doc",
-	"docm",
-	"docx",
-	"dot",
-	"dotm",
-	"dra",
-	"DS_Store",
-	"dsk",
-	"dts",
-	"dtshd",
-	"dvb",
-	"dwg",
-	"dxf",
-	"ecelp4800",
-	"ecelp7470",
-	"ecelp9600",
-	"egg",
-	"eol",
-	"eot",
-	"epub",
-	"exe",
-	"f4v",
-	"fbs",
-	"fh",
-	"fla",
-	"flac",
-	"fli",
-	"flv",
-	"fpx",
-	"fst",
-	"fvt",
-	"g3",
-	"gh",
-	"gif",
-	"graffle",
-	"gz",
-	"gzip",
-	"h261",
-	"h263",
-	"h264",
-	"icns",
-	"ico",
-	"ief",
-	"img",
-	"ipa",
-	"iso",
-	"jar",
-	"jpeg",
-	"jpg",
-	"jpgv",
-	"jpm",
-	"jxr",
-	"key",
-	"ktx",
-	"lha",
-	"lib",
-	"lvp",
-	"lz",
-	"lzh",
-	"lzma",
-	"lzo",
-	"m3u",
-	"m4a",
-	"m4v",
-	"mar",
-	"mdi",
-	"mht",
-	"mid",
-	"midi",
-	"mj2",
-	"mka",
-	"mkv",
-	"mmr",
-	"mng",
-	"mobi",
-	"mov",
-	"movie",
-	"mp3",
-	"mp4",
-	"mp4a",
-	"mpeg",
-	"mpg",
-	"mpga",
-	"mxu",
-	"nef",
-	"npx",
-	"numbers",
-	"nupkg",
-	"o",
-	"oga",
-	"ogg",
-	"ogv",
-	"otf",
-	"pages",
-	"pbm",
-	"pcx",
-	"pdb",
-	"pdf",
-	"pea",
-	"pgm",
-	"pic",
-	"png",
-	"pnm",
-	"pot",
-	"potm",
-	"potx",
-	"ppa",
-	"ppam",
-	"ppm",
-	"pps",
-	"ppsm",
-	"ppsx",
-	"ppt",
-	"pptm",
-	"pptx",
-	"psd",
-	"pya",
-	"pyc",
-	"pyo",
-	"pyv",
-	"qt",
-	"rar",
-	"ras",
-	"raw",
-	"resources",
-	"rgb",
-	"rip",
-	"rlc",
-	"rmf",
-	"rmvb",
-	"rtf",
-	"rz",
-	"s3m",
-	"s7z",
-	"scpt",
-	"sgi",
-	"shar",
-	"sil",
-	"sketch",
-	"slk",
-	"smv",
-	"snk",
-	"so",
-	"stl",
-	"suo",
-	"sub",
-	"swf",
-	"tar",
-	"tbz",
-	"tbz2",
-	"tga",
-	"tgz",
-	"thmx",
-	"tif",
-	"tiff",
-	"tlz",
-	"ttc",
-	"ttf",
-	"txz",
-	"udf",
-	"uvh",
-	"uvi",
-	"uvm",
-	"uvp",
-	"uvs",
-	"uvu",
-	"viv",
-	"vob",
-	"war",
-	"wav",
-	"wax",
-	"wbmp",
-	"wdp",
-	"weba",
-	"webm",
-	"webp",
-	"whl",
-	"wim",
-	"wm",
-	"wma",
-	"wmv",
-	"wmx",
-	"woff",
-	"woff2",
-	"wrm",
-	"wvx",
-	"xbm",
-	"xif",
-	"xla",
-	"xlam",
-	"xls",
-	"xlsb",
-	"xlsm",
-	"xlsx",
-	"xlt",
-	"xltm",
-	"xltx",
-	"xm",
-	"xmind",
-	"xpi",
-	"xpm",
-	"xwd",
-	"xz",
-	"z",
-	"zip",
-	"zipx"
-];
+    function start(code) {
+      effects.enter('lineEnding');
+      effects.consume(code);
+      effects.exit('lineEnding');
+      return lineStart
+    }
+    /** @type {State} */
+
+    function lineStart(code) {
+      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
+    }
+  }
+  /** @type {Tokenizer} */
 
-var binaryExtensions$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': binaryExtensions
-});
+  function tokenizeClosingFence(effects, ok, nok) {
+    let size = 0;
+    return factorySpace(
+      effects,
+      closingSequenceStart,
+      'linePrefix',
+      this.parser.constructs.disable.null.includes('codeIndented')
+        ? undefined
+        : 4
+    )
+    /** @type {State} */
 
-var require$$0$1 = getCjsExportFromNamespace(binaryExtensions$1);
+    function closingSequenceStart(code) {
+      effects.enter('codeFencedFence');
+      effects.enter('codeFencedFenceSequence');
+      return closingSequence(code)
+    }
+    /** @type {State} */
 
-var binaryExtensions$2 = require$$0$1;
+    function closingSequence(code) {
+      if (code === marker) {
+        effects.consume(code);
+        size++;
+        return closingSequence
+      }
 
-const extensions = new Set(binaryExtensions$2);
+      if (size < sizeOpen) return nok(code)
+      effects.exit('codeFencedFenceSequence');
+      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)
+    }
+    /** @type {State} */
 
-var isBinaryPath = filePath => extensions.has(path$1.extname(filePath).slice(1).toLowerCase());
+    function closingSequenceEnd(code) {
+      if (code === null || markdownLineEnding(code)) {
+        effects.exit('codeFencedFence');
+        return ok(code)
+      }
 
-var constants$2 = createCommonjsModule(function (module, exports) {
+      return nok(code)
+    }
+  }
+}
 
-const {sep} = path$1;
-const {platform} = process;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
 
-exports.EV_ALL = 'all';
-exports.EV_READY = 'ready';
-exports.EV_ADD = 'add';
-exports.EV_CHANGE = 'change';
-exports.EV_ADD_DIR = 'addDir';
-exports.EV_UNLINK = 'unlink';
-exports.EV_UNLINK_DIR = 'unlinkDir';
-exports.EV_RAW = 'raw';
-exports.EV_ERROR = 'error';
+/** @type {Construct} */
+const codeIndented = {
+  name: 'codeIndented',
+  tokenize: tokenizeCodeIndented
+};
+/** @type {Construct} */
 
-exports.STR_DATA = 'data';
-exports.STR_END = 'end';
-exports.STR_CLOSE = 'close';
+const indentedContent = {
+  tokenize: tokenizeIndentedContent,
+  partial: true
+};
+/** @type {Tokenizer} */
 
-exports.FSEVENT_CREATED = 'created';
-exports.FSEVENT_MODIFIED = 'modified';
-exports.FSEVENT_DELETED = 'deleted';
-exports.FSEVENT_MOVED = 'moved';
-exports.FSEVENT_CLONED = 'cloned';
-exports.FSEVENT_UNKNOWN = 'unknown';
-exports.FSEVENT_TYPE_FILE = 'file';
-exports.FSEVENT_TYPE_DIRECTORY = 'directory';
-exports.FSEVENT_TYPE_SYMLINK = 'symlink';
+function tokenizeCodeIndented(effects, ok, nok) {
+  const self = this;
+  return start
+  /** @type {State} */
 
-exports.KEY_LISTENERS = 'listeners';
-exports.KEY_ERR = 'errHandlers';
-exports.KEY_RAW = 'rawEmitters';
-exports.HANDLER_KEYS = [exports.KEY_LISTENERS, exports.KEY_ERR, exports.KEY_RAW];
+  function start(code) {
+    effects.enter('codeIndented');
+    return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code)
+  }
+  /** @type {State} */
 
-exports.DOT_SLASH = `.${sep}`;
+  function afterStartPrefix(code) {
+    const tail = self.events[self.events.length - 1];
+    return tail &&
+      tail[1].type === 'linePrefix' &&
+      tail[2].sliceSerialize(tail[1], true).length >= 4
+      ? afterPrefix(code)
+      : nok(code)
+  }
+  /** @type {State} */
 
-exports.BACK_SLASH_RE = /\\/g;
-exports.DOUBLE_SLASH_RE = /\/\//;
-exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
-exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
-exports.REPLACER_RE = /^\.[/\\]/;
+  function afterPrefix(code) {
+    if (code === null) {
+      return after(code)
+    }
 
-exports.SLASH = '/';
-exports.BRACE_START = '{';
-exports.BANG = '!';
-exports.ONE_DOT = '.';
-exports.TWO_DOTS = '..';
-exports.STAR = '*';
-exports.GLOBSTAR = '**';
-exports.ROOT_GLOBSTAR = '/**/*';
-exports.SLASH_GLOBSTAR = '/**';
-exports.DIR_SUFFIX = 'Dir';
-exports.ANYMATCH_OPTS = {dot: true};
-exports.STRING_TYPE = 'string';
-exports.FUNCTION_TYPE = 'function';
-exports.EMPTY_STR = '';
-exports.EMPTY_FN = () => {};
-exports.IDENTITY_FN = val => val;
+    if (markdownLineEnding(code)) {
+      return effects.attempt(indentedContent, afterPrefix, after)(code)
+    }
 
-exports.isWindows = platform === 'win32';
-exports.isMacos = platform === 'darwin';
-});
-var constants_1 = constants$2.EV_ALL;
-var constants_2 = constants$2.EV_READY;
-var constants_3 = constants$2.EV_ADD;
-var constants_4 = constants$2.EV_CHANGE;
-var constants_5 = constants$2.EV_ADD_DIR;
-var constants_6 = constants$2.EV_UNLINK;
-var constants_7 = constants$2.EV_UNLINK_DIR;
-var constants_8 = constants$2.EV_RAW;
-var constants_9 = constants$2.EV_ERROR;
-var constants_10 = constants$2.STR_DATA;
-var constants_11 = constants$2.STR_END;
-var constants_12 = constants$2.STR_CLOSE;
-var constants_13 = constants$2.FSEVENT_CREATED;
-var constants_14 = constants$2.FSEVENT_MODIFIED;
-var constants_15 = constants$2.FSEVENT_DELETED;
-var constants_16 = constants$2.FSEVENT_MOVED;
-var constants_17 = constants$2.FSEVENT_CLONED;
-var constants_18 = constants$2.FSEVENT_UNKNOWN;
-var constants_19 = constants$2.FSEVENT_TYPE_FILE;
-var constants_20 = constants$2.FSEVENT_TYPE_DIRECTORY;
-var constants_21 = constants$2.FSEVENT_TYPE_SYMLINK;
-var constants_22 = constants$2.KEY_LISTENERS;
-var constants_23 = constants$2.KEY_ERR;
-var constants_24 = constants$2.KEY_RAW;
-var constants_25 = constants$2.HANDLER_KEYS;
-var constants_26 = constants$2.DOT_SLASH;
-var constants_27 = constants$2.BACK_SLASH_RE;
-var constants_28 = constants$2.DOUBLE_SLASH_RE;
-var constants_29 = constants$2.SLASH_OR_BACK_SLASH_RE;
-var constants_30 = constants$2.DOT_RE;
-var constants_31 = constants$2.REPLACER_RE;
-var constants_32 = constants$2.SLASH;
-var constants_33 = constants$2.BRACE_START;
-var constants_34 = constants$2.BANG;
-var constants_35 = constants$2.ONE_DOT;
-var constants_36 = constants$2.TWO_DOTS;
-var constants_37 = constants$2.STAR;
-var constants_38 = constants$2.GLOBSTAR;
-var constants_39 = constants$2.ROOT_GLOBSTAR;
-var constants_40 = constants$2.SLASH_GLOBSTAR;
-var constants_41 = constants$2.DIR_SUFFIX;
-var constants_42 = constants$2.ANYMATCH_OPTS;
-var constants_43 = constants$2.STRING_TYPE;
-var constants_44 = constants$2.FUNCTION_TYPE;
-var constants_45 = constants$2.EMPTY_STR;
-var constants_46 = constants$2.EMPTY_FN;
-var constants_47 = constants$2.IDENTITY_FN;
-var constants_48 = constants$2.isWindows;
-var constants_49 = constants$2.isMacos;
-
-const { promisify: promisify$1 } = util$2;
+    effects.enter('codeFlowValue');
+    return content(code)
+  }
+  /** @type {State} */
 
-const {
-  isWindows: isWindows$1,
-  EMPTY_FN,
-  EMPTY_STR,
-  KEY_LISTENERS,
-  KEY_ERR,
-  KEY_RAW,
-  HANDLER_KEYS,
-  EV_CHANGE,
-  EV_ADD,
-  EV_ADD_DIR,
-  EV_ERROR,
-  STR_DATA,
-  STR_END,
-  BRACE_START,
-  STAR: STAR$1
-} = constants$2;
+  function content(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit('codeFlowValue');
+      return afterPrefix(code)
+    }
 
-const THROTTLE_MODE_WATCH = 'watch';
+    effects.consume(code);
+    return content
+  }
+  /** @type {State} */
 
-const open = promisify$1(fs$1.open);
-const stat$3 = promisify$1(fs$1.stat);
-const lstat$1 = promisify$1(fs$1.lstat);
-const close = promisify$1(fs$1.close);
-const fsrealpath = promisify$1(fs$1.realpath);
+  function after(code) {
+    effects.exit('codeIndented');
+    return ok(code)
+  }
+}
+/** @type {Tokenizer} */
 
-const statMethods = { lstat: lstat$1, stat: stat$3 };
+function tokenizeIndentedContent(effects, ok, nok) {
+  const self = this;
+  return start
+  /** @type {State} */
 
-// TODO: emit errors properly. Example: EMFILE on Macos.
-const foreach = (val, fn) => {
-  if (val instanceof Set) {
-    val.forEach(fn);
-  } else {
-    fn(val);
+  function start(code) {
+    // If this is a lazy line, it can’t be code.
+    if (self.parser.lazy[self.now().line]) {
+      return nok(code)
+    }
+
+    if (markdownLineEnding(code)) {
+      effects.enter('lineEnding');
+      effects.consume(code);
+      effects.exit('lineEnding');
+      return start
+    }
+
+    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)
   }
-};
+  /** @type {State} */
 
-const addAndConvert = (main, prop, item) => {
-  let container = main[prop];
-  if (!(container instanceof Set)) {
-    main[prop] = container = new Set([container]);
+  function afterPrefix(code) {
+    const tail = self.events[self.events.length - 1];
+    return tail &&
+      tail[1].type === 'linePrefix' &&
+      tail[2].sliceSerialize(tail[1], true).length >= 4
+      ? ok(code)
+      : markdownLineEnding(code)
+      ? start(code)
+      : nok(code)
   }
-  container.add(item);
+}
+
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Previous} Previous
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/** @type {Construct} */
+const codeText = {
+  name: 'codeText',
+  tokenize: tokenizeCodeText,
+  resolve: resolveCodeText,
+  previous: previous$1
 };
+/** @type {Resolver} */
 
-const clearItem = cont => key => {
-  const set = cont[key];
-  if (set instanceof Set) {
-    set.clear();
-  } else {
-    delete cont[key];
+function resolveCodeText(events) {
+  let tailExitIndex = events.length - 4;
+  let headEnterIndex = 3;
+  /** @type {number} */
+
+  let index;
+  /** @type {number|undefined} */
+
+  let enter; // If we start and end with an EOL or a space.
+
+  if (
+    (events[headEnterIndex][1].type === 'lineEnding' ||
+      events[headEnterIndex][1].type === 'space') &&
+    (events[tailExitIndex][1].type === 'lineEnding' ||
+      events[tailExitIndex][1].type === 'space')
+  ) {
+    index = headEnterIndex; // And we have data.
+
+    while (++index < tailExitIndex) {
+      if (events[index][1].type === 'codeTextData') {
+        // Then we have padding.
+        events[headEnterIndex][1].type = 'codeTextPadding';
+        events[tailExitIndex][1].type = 'codeTextPadding';
+        headEnterIndex += 2;
+        tailExitIndex -= 2;
+        break
+      }
+    }
+  } // Merge adjacent spaces and data.
+
+  index = headEnterIndex - 1;
+  tailExitIndex++;
+
+  while (++index <= tailExitIndex) {
+    if (enter === undefined) {
+      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {
+        enter = index;
+      }
+    } else if (
+      index === tailExitIndex ||
+      events[index][1].type === 'lineEnding'
+    ) {
+      events[enter][1].type = 'codeTextData';
+
+      if (index !== enter + 2) {
+        events[enter][1].end = events[index - 1][1].end;
+        events.splice(enter + 2, index - enter - 2);
+        tailExitIndex -= index - enter - 2;
+        index = enter + 2;
+      }
+
+      enter = undefined;
+    }
   }
-};
 
-const delFromSet = (main, prop, item) => {
-  const container = main[prop];
-  if (container instanceof Set) {
-    container.delete(item);
-  } else if (container === item) {
-    delete main[prop];
+  return events
+}
+/** @type {Previous} */
+
+function previous$1(code) {
+  // If there is a previous code, there will always be a tail.
+  return (
+    code !== 96 ||
+    this.events[this.events.length - 1][1].type === 'characterEscape'
+  )
+}
+/** @type {Tokenizer} */
+
+function tokenizeCodeText(effects, ok, nok) {
+  let sizeOpen = 0;
+  /** @type {number} */
+
+  let size;
+  /** @type {Token} */
+
+  let token;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('codeText');
+    effects.enter('codeTextSequence');
+    return openingSequence(code)
   }
-};
+  /** @type {State} */
 
-const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+  function openingSequence(code) {
+    if (code === 96) {
+      effects.consume(code);
+      sizeOpen++;
+      return openingSequence
+    }
+
+    effects.exit('codeTextSequence');
+    return gap(code)
+  }
+  /** @type {State} */
+
+  function gap(code) {
+    // EOF.
+    if (code === null) {
+      return nok(code)
+    } // Closing fence?
+    // Could also be data.
+
+    if (code === 96) {
+      token = effects.enter('codeTextSequence');
+      size = 0;
+      return closingSequence(code)
+    } // Tabs don’t work, and virtual spaces don’t make sense.
+
+    if (code === 32) {
+      effects.enter('space');
+      effects.consume(code);
+      effects.exit('space');
+      return gap
+    }
+
+    if (markdownLineEnding(code)) {
+      effects.enter('lineEnding');
+      effects.consume(code);
+      effects.exit('lineEnding');
+      return gap
+    } // Data.
+
+    effects.enter('codeTextData');
+    return data(code)
+  } // In code.
+
+  /** @type {State} */
+
+  function data(code) {
+    if (
+      code === null ||
+      code === 32 ||
+      code === 96 ||
+      markdownLineEnding(code)
+    ) {
+      effects.exit('codeTextData');
+      return gap(code)
+    }
+
+    effects.consume(code);
+    return data
+  } // Closing fence.
+
+  /** @type {State} */
+
+  function closingSequence(code) {
+    // More.
+    if (code === 96) {
+      effects.consume(code);
+      size++;
+      return closingSequence
+    } // Done!
+
+    if (size === sizeOpen) {
+      effects.exit('codeTextSequence');
+      effects.exit('codeText');
+      return ok(code)
+    } // More or less accents: mark as data.
+
+    token.type = 'codeTextData';
+    return data(code)
+  }
+}
 
 /**
- * @typedef {String} Path
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Chunk} Chunk
+ * @typedef {import('micromark-util-types').Event} Event
  */
 
-// fs_watch helpers
+/**
+ * Tokenize subcontent.
+ *
+ * @param {Event[]} events
+ * @returns {boolean}
+ */
+function subtokenize(events) {
+  /** @type {Record<string, number>} */
+  const jumps = {};
+  let index = -1;
+  /** @type {Event} */
 
-// object to hold per-process fs_watch instances
-// (may be shared across chokidar FSWatcher instances)
+  let event;
+  /** @type {number|undefined} */
+
+  let lineIndex;
+  /** @type {number} */
+
+  let otherIndex;
+  /** @type {Event} */
+
+  let otherEvent;
+  /** @type {Event[]} */
+
+  let parameters;
+  /** @type {Event[]} */
+
+  let subevents;
+  /** @type {boolean|undefined} */
+
+  let more;
+
+  while (++index < events.length) {
+    while (index in jumps) {
+      index = jumps[index];
+    }
+
+    event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text
+    // is in the first content of a list item.
 
+    if (
+      index &&
+      event[1].type === 'chunkFlow' &&
+      events[index - 1][1].type === 'listItemPrefix'
+    ) {
+      subevents = event[1]._tokenizer.events;
+      otherIndex = 0;
+
+      if (
+        otherIndex < subevents.length &&
+        subevents[otherIndex][1].type === 'lineEndingBlank'
+      ) {
+        otherIndex += 2;
+      }
+
+      if (
+        otherIndex < subevents.length &&
+        subevents[otherIndex][1].type === 'content'
+      ) {
+        while (++otherIndex < subevents.length) {
+          if (subevents[otherIndex][1].type === 'content') {
+            break
+          }
+
+          if (subevents[otherIndex][1].type === 'chunkText') {
+            subevents[otherIndex][1]._isInFirstContentOfListItem = true;
+            otherIndex++;
+          }
+        }
+      }
+    } // Enter.
+
+    if (event[0] === 'enter') {
+      if (event[1].contentType) {
+        Object.assign(jumps, subcontent(events, index));
+        index = jumps[index];
+        more = true;
+      }
+    } // Exit.
+    else if (event[1]._container) {
+      otherIndex = index;
+      lineIndex = undefined;
+
+      while (otherIndex--) {
+        otherEvent = events[otherIndex];
+
+        if (
+          otherEvent[1].type === 'lineEnding' ||
+          otherEvent[1].type === 'lineEndingBlank'
+        ) {
+          if (otherEvent[0] === 'enter') {
+            if (lineIndex) {
+              events[lineIndex][1].type = 'lineEndingBlank';
+            }
+
+            otherEvent[1].type = 'lineEnding';
+            lineIndex = otherIndex;
+          }
+        } else {
+          break
+        }
+      }
+
+      if (lineIndex) {
+        // Fix position.
+        event[1].end = Object.assign({}, events[lineIndex][1].start); // Switch container exit w/ line endings.
+
+        parameters = events.slice(lineIndex, index);
+        parameters.unshift(event);
+        splice(events, lineIndex, index - lineIndex + 1, parameters);
+      }
+    }
+  }
+
+  return !more
+}
 /**
- * @typedef {Object} FsWatchContainer
- * @property {Set} listeners
- * @property {Set} errHandlers
- * @property {Set} rawEmitters
- * @property {fs.FSWatcher=} watcher
- * @property {Boolean=} watcherUnusable
+ * Tokenize embedded tokens.
+ *
+ * @param {Event[]} events
+ * @param {number} eventIndex
+ * @returns {Record<string, number>}
+ */
+
+function subcontent(events, eventIndex) {
+  const token = events[eventIndex][1];
+  const context = events[eventIndex][2];
+  let startPosition = eventIndex - 1;
+  /** @type {number[]} */
+
+  const startPositions = [];
+  const tokenizer =
+    token._tokenizer || context.parser[token.contentType](token.start);
+  const childEvents = tokenizer.events;
+  /** @type {[number, number][]} */
+
+  const jumps = [];
+  /** @type {Record<string, number>} */
+
+  const gaps = {};
+  /** @type {Chunk[]} */
+
+  let stream;
+  /** @type {Token|undefined} */
+
+  let previous;
+  let index = -1;
+  /** @type {Token|undefined} */
+
+  let current = token;
+  let adjust = 0;
+  let start = 0;
+  const breaks = [start]; // Loop forward through the linked tokens to pass them in order to the
+  // subtokenizer.
+
+  while (current) {
+    // Find the position of the event for this token.
+    while (events[++startPosition][1] !== current) {
+      // Empty.
+    }
+
+    startPositions.push(startPosition);
+
+    if (!current._tokenizer) {
+      stream = context.sliceStream(current);
+
+      if (!current.next) {
+        stream.push(null);
+      }
+
+      if (previous) {
+        tokenizer.defineSkip(current.start);
+      }
+
+      if (current._isInFirstContentOfListItem) {
+        tokenizer._gfmTasklistFirstContentOfListItem = true;
+      }
+
+      tokenizer.write(stream);
+
+      if (current._isInFirstContentOfListItem) {
+        tokenizer._gfmTasklistFirstContentOfListItem = undefined;
+      }
+    } // Unravel the next token.
+
+    previous = current;
+    current = current.next;
+  } // Now, loop back through all events (and linked tokens), to figure out which
+  // parts belong where.
+
+  current = token;
+
+  while (++index < childEvents.length) {
+    if (
+      // Find a void token that includes a break.
+      childEvents[index][0] === 'exit' &&
+      childEvents[index - 1][0] === 'enter' &&
+      childEvents[index][1].type === childEvents[index - 1][1].type &&
+      childEvents[index][1].start.line !== childEvents[index][1].end.line
+    ) {
+      start = index + 1;
+      breaks.push(start); // Help GC.
+
+      current._tokenizer = undefined;
+      current.previous = undefined;
+      current = current.next;
+    }
+  } // Help GC.
+
+  tokenizer.events = []; // If there’s one more token (which is the cases for lines that end in an
+  // EOF), that’s perfect: the last point we found starts it.
+  // If there isn’t then make sure any remaining content is added to it.
+
+  if (current) {
+    // Help GC.
+    current._tokenizer = undefined;
+    current.previous = undefined;
+  } else {
+    breaks.pop();
+  } // Now splice the events from the subtokenizer into the current events,
+  // moving back to front so that splice indices aren’t affected.
+
+  index = breaks.length;
+
+  while (index--) {
+    const slice = childEvents.slice(breaks[index], breaks[index + 1]);
+    const start = startPositions.pop();
+    jumps.unshift([start, start + slice.length - 1]);
+    splice(events, start, 2, slice);
+  }
+
+  index = -1;
+
+  while (++index < jumps.length) {
+    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];
+    adjust += jumps[index][1] - jumps[index][0] - 1;
+  }
+
+  return gaps
+}
+
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
  */
 
 /**
- * @type {Map<String,FsWatchContainer>}
+ * No name because it must not be turned off.
+ * @type {Construct}
  */
-const FsWatchInstances = new Map();
+const content = {
+  tokenize: tokenizeContent,
+  resolve: resolveContent
+};
+/** @type {Construct} */
 
+const continuationConstruct = {
+  tokenize: tokenizeContinuation,
+  partial: true
+};
 /**
- * Instantiates the fs_watch interface
- * @param {String} path to be watched
- * @param {Object} options to be passed to fs_watch
- * @param {Function} listener main event handler
- * @param {Function} errHandler emits info about errors
- * @param {Function} emitRaw emits raw event data
- * @returns {fs.FSWatcher} new fsevents instance
+ * Content is transparent: it’s parsed right now. That way, definitions are also
+ * parsed right now: before text in paragraphs (specifically, media) are parsed.
+ *
+ * @type {Resolver}
  */
-function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
-  const handleEvent = (rawEvent, evPath) => {
-    listener(path);
-    emitRaw(rawEvent, evPath, {watchedPath: path});
 
-    // emit based on events occurring for files from a directory's watcher in
-    // case the file's watcher misses it (and rely on throttling to de-dupe)
-    if (evPath && path !== evPath) {
-      fsWatchBroadcast(
-        path$1.resolve(path, evPath), KEY_LISTENERS, path$1.join(path, evPath)
-      );
+function resolveContent(events) {
+  subtokenize(events);
+  return events
+}
+/** @type {Tokenizer} */
+
+function tokenizeContent(effects, ok) {
+  /** @type {Token} */
+  let previous;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('content');
+    previous = effects.enter('chunkContent', {
+      contentType: 'content'
+    });
+    return data(code)
+  }
+  /** @type {State} */
+
+  function data(code) {
+    if (code === null) {
+      return contentEnd(code)
     }
-  };
-  try {
-    return fs$1.watch(path, options, handleEvent);
-  } catch (error) {
-    errHandler(error);
+
+    if (markdownLineEnding(code)) {
+      return effects.check(
+        continuationConstruct,
+        contentContinue,
+        contentEnd
+      )(code)
+    } // Data.
+
+    effects.consume(code);
+    return data
+  }
+  /** @type {State} */
+
+  function contentEnd(code) {
+    effects.exit('chunkContent');
+    effects.exit('content');
+    return ok(code)
+  }
+  /** @type {State} */
+
+  function contentContinue(code) {
+    effects.consume(code);
+    effects.exit('chunkContent');
+    previous.next = effects.enter('chunkContent', {
+      contentType: 'content',
+      previous
+    });
+    previous = previous.next;
+    return data
+  }
+}
+/** @type {Tokenizer} */
+
+function tokenizeContinuation(effects, ok, nok) {
+  const self = this;
+  return startLookahead
+  /** @type {State} */
+
+  function startLookahead(code) {
+    effects.exit('chunkContent');
+    effects.enter('lineEnding');
+    effects.consume(code);
+    effects.exit('lineEnding');
+    return factorySpace(effects, prefixed, 'linePrefix')
+  }
+  /** @type {State} */
+
+  function prefixed(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return nok(code)
+    }
+
+    const tail = self.events[self.events.length - 1];
+
+    if (
+      !self.parser.constructs.disable.null.includes('codeIndented') &&
+      tail &&
+      tail[1].type === 'linePrefix' &&
+      tail[2].sliceSerialize(tail[1], true).length >= 4
+    ) {
+      return ok(code)
+    }
+
+    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)
   }
 }
 
 /**
- * Helper for passing fs_watch event data to a collection of listeners
- * @param {Path} fullPath absolute path bound to fs_watch instance
- * @param {String} type listener type
- * @param {*=} val1 arguments to be passed to listeners
- * @param {*=} val2
- * @param {*=} val3
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
  */
-const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
-  const cont = FsWatchInstances.get(fullPath);
-  if (!cont) return;
-  foreach(cont[type], (listener) => {
-    listener(val1, val2, val3);
-  });
-};
 
 /**
- * Instantiates the fs_watch interface or binds listeners
- * to an existing one covering the same file system entry
- * @param {String} path
- * @param {String} fullPath absolute path
- * @param {Object} options to be passed to fs_watch
- * @param {Object} handlers container for event listener functions
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {string} type
+ * @param {string} literalType
+ * @param {string} literalMarkerType
+ * @param {string} rawType
+ * @param {string} stringType
+ * @param {number} [max=Infinity]
+ * @returns {State}
  */
-const setFsWatchListener = (path, fullPath, options, handlers) => {
-  const {listener, errHandler, rawEmitter} = handlers;
-  let cont = FsWatchInstances.get(fullPath);
+// eslint-disable-next-line max-params
+function factoryDestination(
+  effects,
+  ok,
+  nok,
+  type,
+  literalType,
+  literalMarkerType,
+  rawType,
+  stringType,
+  max
+) {
+  const limit = max || Number.POSITIVE_INFINITY;
+  let balance = 0;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    if (code === 60) {
+      effects.enter(type);
+      effects.enter(literalType);
+      effects.enter(literalMarkerType);
+      effects.consume(code);
+      effects.exit(literalMarkerType);
+      return destinationEnclosedBefore
+    }
+
+    if (code === null || code === 41 || asciiControl(code)) {
+      return nok(code)
+    }
+
+    effects.enter(type);
+    effects.enter(rawType);
+    effects.enter(stringType);
+    effects.enter('chunkString', {
+      contentType: 'string'
+    });
+    return destinationRaw(code)
+  }
+  /** @type {State} */
 
-  /** @type {fs.FSWatcher=} */
-  let watcher;
-  if (!options.persistent) {
-    watcher = createFsWatchInstance(
-      path, options, listener, errHandler, rawEmitter
-    );
-    return watcher.close.bind(watcher);
+  function destinationEnclosedBefore(code) {
+    if (code === 62) {
+      effects.enter(literalMarkerType);
+      effects.consume(code);
+      effects.exit(literalMarkerType);
+      effects.exit(literalType);
+      effects.exit(type);
+      return ok
+    }
+
+    effects.enter(stringType);
+    effects.enter('chunkString', {
+      contentType: 'string'
+    });
+    return destinationEnclosed(code)
   }
-  if (cont) {
-    addAndConvert(cont, KEY_LISTENERS, listener);
-    addAndConvert(cont, KEY_ERR, errHandler);
-    addAndConvert(cont, KEY_RAW, rawEmitter);
-  } else {
-    watcher = createFsWatchInstance(
-      path,
-      options,
-      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
-      errHandler, // no need to use broadcast here
-      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
-    );
-    if (!watcher) return;
-    watcher.on(EV_ERROR, async (error) => {
-      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
-      cont.watcherUnusable = true; // documented since Node 10.4.1
-      // Workaround for https://github.com/joyent/node/issues/4337
-      if (isWindows$1 && error.code === 'EPERM') {
-        try {
-          const fd = await open(path, 'r');
-          await close(fd);
-          broadcastErr(error);
-        } catch (err) {}
-      } else {
-        broadcastErr(error);
+  /** @type {State} */
+
+  function destinationEnclosed(code) {
+    if (code === 62) {
+      effects.exit('chunkString');
+      effects.exit(stringType);
+      return destinationEnclosedBefore(code)
+    }
+
+    if (code === null || code === 60 || markdownLineEnding(code)) {
+      return nok(code)
+    }
+
+    effects.consume(code);
+    return code === 92 ? destinationEnclosedEscape : destinationEnclosed
+  }
+  /** @type {State} */
+
+  function destinationEnclosedEscape(code) {
+    if (code === 60 || code === 62 || code === 92) {
+      effects.consume(code);
+      return destinationEnclosed
+    }
+
+    return destinationEnclosed(code)
+  }
+  /** @type {State} */
+
+  function destinationRaw(code) {
+    if (code === 40) {
+      if (++balance > limit) return nok(code)
+      effects.consume(code);
+      return destinationRaw
+    }
+
+    if (code === 41) {
+      if (!balance--) {
+        effects.exit('chunkString');
+        effects.exit(stringType);
+        effects.exit(rawType);
+        effects.exit(type);
+        return ok(code)
       }
+
+      effects.consume(code);
+      return destinationRaw
+    }
+
+    if (code === null || markdownLineEndingOrSpace(code)) {
+      if (balance) return nok(code)
+      effects.exit('chunkString');
+      effects.exit(stringType);
+      effects.exit(rawType);
+      effects.exit(type);
+      return ok(code)
+    }
+
+    if (asciiControl(code)) return nok(code)
+    effects.consume(code);
+    return code === 92 ? destinationRawEscape : destinationRaw
+  }
+  /** @type {State} */
+
+  function destinationRawEscape(code) {
+    if (code === 40 || code === 41 || code === 92) {
+      effects.consume(code);
+      return destinationRaw
+    }
+
+    return destinationRaw(code)
+  }
+}
+
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/**
+ * @this {TokenizeContext}
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {string} type
+ * @param {string} markerType
+ * @param {string} stringType
+ * @returns {State}
+ */
+// eslint-disable-next-line max-params
+function factoryLabel(effects, ok, nok, type, markerType, stringType) {
+  const self = this;
+  let size = 0;
+  /** @type {boolean} */
+
+  let data;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter(type);
+    effects.enter(markerType);
+    effects.consume(code);
+    effects.exit(markerType);
+    effects.enter(stringType);
+    return atBreak
+  }
+  /** @type {State} */
+
+  function atBreak(code) {
+    if (
+      code === null ||
+      code === 91 ||
+      (code === 93 && !data) ||
+      /* Hidden footnotes hook */
+
+      /* c8 ignore next 3 */
+      (code === 94 &&
+        !size &&
+        '_hiddenFootnoteSupport' in self.parser.constructs) ||
+      size > 999
+    ) {
+      return nok(code)
+    }
+
+    if (code === 93) {
+      effects.exit(stringType);
+      effects.enter(markerType);
+      effects.consume(code);
+      effects.exit(markerType);
+      effects.exit(type);
+      return ok
+    }
+
+    if (markdownLineEnding(code)) {
+      effects.enter('lineEnding');
+      effects.consume(code);
+      effects.exit('lineEnding');
+      return atBreak
+    }
+
+    effects.enter('chunkString', {
+      contentType: 'string'
     });
-    cont = {
-      listeners: listener,
-      errHandlers: errHandler,
-      rawEmitters: rawEmitter,
-      watcher
-    };
-    FsWatchInstances.set(fullPath, cont);
+    return label(code)
   }
-  // const index = cont.listeners.indexOf(listener);
+  /** @type {State} */
 
-  // removes this instance's listeners and closes the underlying fs_watch
-  // instance if there are no more listeners left
-  return () => {
-    delFromSet(cont, KEY_LISTENERS, listener);
-    delFromSet(cont, KEY_ERR, errHandler);
-    delFromSet(cont, KEY_RAW, rawEmitter);
-    if (isEmptySet(cont.listeners)) {
-      // Check to protect against issue gh-730.
-      // if (cont.watcherUnusable) {
-      cont.watcher.close();
-      // }
-      FsWatchInstances.delete(fullPath);
-      HANDLER_KEYS.forEach(clearItem(cont));
-      cont.watcher = undefined;
-      Object.freeze(cont);
+  function label(code) {
+    if (
+      code === null ||
+      code === 91 ||
+      code === 93 ||
+      markdownLineEnding(code) ||
+      size++ > 999
+    ) {
+      effects.exit('chunkString');
+      return atBreak(code)
     }
-  };
-};
 
-// fs_watchFile helpers
+    effects.consume(code);
+    data = data || !markdownSpace(code);
+    return code === 92 ? labelEscape : label
+  }
+  /** @type {State} */
 
-// object to hold per-process fs_watchFile instances
-// (may be shared across chokidar FSWatcher instances)
-const FsWatchFileInstances = new Map();
+  function labelEscape(code) {
+    if (code === 91 || code === 92 || code === 93) {
+      effects.consume(code);
+      size++;
+      return label
+    }
+
+    return label(code)
+  }
+}
 
 /**
- * Instantiates the fs_watchFile interface or binds listeners
- * to an existing one covering the same file system entry
- * @param {String} path to be watched
- * @param {String} fullPath absolute path
- * @param {Object} options options to be passed to fs_watchFile
- * @param {Object} handlers container for event listener functions
- * @returns {Function} closer
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
  */
-const setFsWatchFileListener = (path, fullPath, options, handlers) => {
-  const {listener, rawEmitter} = handlers;
-  let cont = FsWatchFileInstances.get(fullPath);
 
-  /* eslint-disable no-unused-vars, prefer-destructuring */
-  let listeners = new Set();
-  let rawEmitters = new Set();
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {string} type
+ * @param {string} markerType
+ * @param {string} stringType
+ * @returns {State}
+ */
+// eslint-disable-next-line max-params
+function factoryTitle(effects, ok, nok, type, markerType, stringType) {
+  /** @type {NonNullable<Code>} */
+  let marker;
+  return start
+  /** @type {State} */
 
-  const copts = cont && cont.options;
-  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    // "Upgrade" the watcher to persistence or a quicker interval.
-    // This creates some unlikely edge case issues if the user mixes
-    // settings in a very weird way, but solving for those cases
-    // doesn't seem worthwhile for the added complexity.
-    listeners = cont.listeners;
-    rawEmitters = cont.rawEmitters;
-    fs$1.unwatchFile(fullPath);
-    cont = undefined;
+  function start(code) {
+    effects.enter(type);
+    effects.enter(markerType);
+    effects.consume(code);
+    effects.exit(markerType);
+    marker = code === 40 ? 41 : code;
+    return atFirstTitleBreak
   }
+  /** @type {State} */
 
-  /* eslint-enable no-unused-vars, prefer-destructuring */
+  function atFirstTitleBreak(code) {
+    if (code === marker) {
+      effects.enter(markerType);
+      effects.consume(code);
+      effects.exit(markerType);
+      effects.exit(type);
+      return ok
+    }
 
-  if (cont) {
-    addAndConvert(cont, KEY_LISTENERS, listener);
-    addAndConvert(cont, KEY_RAW, rawEmitter);
-  } else {
-    // TODO
-    // listeners.add(listener);
-    // rawEmitters.add(rawEmitter);
-    cont = {
-      listeners: listener,
-      rawEmitters: rawEmitter,
-      options,
-      watcher: fs$1.watchFile(fullPath, options, (curr, prev) => {
-        foreach(cont.rawEmitters, (rawEmitter) => {
-          rawEmitter(EV_CHANGE, fullPath, {curr, prev});
-        });
-        const currmtime = curr.mtimeMs;
-        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener) => listener(path, curr));
-        }
-      })
-    };
-    FsWatchFileInstances.set(fullPath, cont);
+    effects.enter(stringType);
+    return atTitleBreak(code)
+  }
+  /** @type {State} */
+
+  function atTitleBreak(code) {
+    if (code === marker) {
+      effects.exit(stringType);
+      return atFirstTitleBreak(marker)
+    }
+
+    if (code === null) {
+      return nok(code)
+    } // Note: blank lines can’t exist in content.
+
+    if (markdownLineEnding(code)) {
+      effects.enter('lineEnding');
+      effects.consume(code);
+      effects.exit('lineEnding');
+      return factorySpace(effects, atTitleBreak, 'linePrefix')
+    }
+
+    effects.enter('chunkString', {
+      contentType: 'string'
+    });
+    return title(code)
+  }
+  /** @type {State} */
+
+  function title(code) {
+    if (code === marker || code === null || markdownLineEnding(code)) {
+      effects.exit('chunkString');
+      return atTitleBreak(code)
+    }
+
+    effects.consume(code);
+    return code === 92 ? titleEscape : title
   }
-  // const index = cont.listeners.indexOf(listener);
+  /** @type {State} */
 
-  // Removes this instance's listeners and closes the underlying fs_watchFile
-  // instance if there are no more listeners left.
-  return () => {
-    delFromSet(cont, KEY_LISTENERS, listener);
-    delFromSet(cont, KEY_RAW, rawEmitter);
-    if (isEmptySet(cont.listeners)) {
-      FsWatchFileInstances.delete(fullPath);
-      fs$1.unwatchFile(fullPath);
-      cont.options = cont.watcher = undefined;
-      Object.freeze(cont);
+  function titleEscape(code) {
+    if (code === marker || code === 92) {
+      effects.consume(code);
+      return title
     }
-  };
-};
+
+    return title(code)
+  }
+}
 
 /**
- * @mixin
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
  */
-class NodeFsHandler {
 
 /**
- * @param {import("../index").FSWatcher} fsW
+ * @param {Effects} effects
+ * @param {State} ok
  */
-constructor(fsW) {
-  this.fsw = fsW;
-  this._boundHandleError = (error) => fsW._handleError(error);
+function factoryWhitespace(effects, ok) {
+  /** @type {boolean} */
+  let seen;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    if (markdownLineEnding(code)) {
+      effects.enter('lineEnding');
+      effects.consume(code);
+      effects.exit('lineEnding');
+      seen = true;
+      return start
+    }
+
+    if (markdownSpace(code)) {
+      return factorySpace(
+        effects,
+        start,
+        seen ? 'linePrefix' : 'lineSuffix'
+      )(code)
+    }
+
+    return ok(code)
+  }
 }
 
 /**
- * Watch file for changes with fs_watchFile or fs_watch.
- * @param {String} path to file or dir
- * @param {Function} listener on fs change
- * @returns {Function} closer for the watcher instance
+ * Normalize an identifier (such as used in definitions).
+ *
+ * @param {string} value
+ * @returns {string}
  */
-_watchWithNodeFs(path, listener) {
-  const opts = this.fsw.options;
-  const directory = path$1.dirname(path);
-  const basename = path$1.basename(path);
-  const parent = this.fsw._getWatchedDir(directory);
-  parent.add(basename);
-  const absolutePath = path$1.resolve(path);
-  const options = {persistent: opts.persistent};
-  if (!listener) listener = EMPTY_FN;
-
-  let closer;
-  if (opts.usePolling) {
-    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
-      opts.binaryInterval : opts.interval;
-    closer = setFsWatchFileListener(path, absolutePath, options, {
-      listener,
-      rawEmitter: this.fsw._emitRaw
-    });
-  } else {
-    closer = setFsWatchListener(path, absolutePath, options, {
-      listener,
-      errHandler: this._boundHandleError,
-      rawEmitter: this.fsw._emitRaw
-    });
-  }
-  return closer;
+function normalizeIdentifier(value) {
+  return (
+    value // Collapse Markdown whitespace.
+      .replace(/[\t\n\r ]+/g, ' ') // Trim.
+      .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase
+      // counterpart is uppercased will result in a different uppercase
+      // character.
+      // Hence, to get that form, we perform both lower- and uppercase.
+      // Upper case makes sure keys will not interact with default prototypal
+      // methods: no method is uppercase.
+      .toLowerCase()
+      .toUpperCase()
+  )
 }
 
 /**
- * Watch a file and emit add event if warranted.
- * @param {Path} file Path
- * @param {fs.Stats} stats result of fs_stat
- * @param {Boolean} initialAdd was the file added at watch instantiation?
- * @returns {Function} closer for the watcher instance
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
  */
-_handleFile(file, stats, initialAdd) {
-  if (this.fsw.closed) {
-    return;
+
+/** @type {Construct} */
+const definition$1 = {
+  name: 'definition',
+  tokenize: tokenizeDefinition
+};
+/** @type {Construct} */
+
+const titleConstruct = {
+  tokenize: tokenizeTitle,
+  partial: true
+};
+/** @type {Tokenizer} */
+
+function tokenizeDefinition(effects, ok, nok) {
+  const self = this;
+  /** @type {string} */
+
+  let identifier;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('definition');
+    return factoryLabel.call(
+      self,
+      effects,
+      labelAfter,
+      nok,
+      'definitionLabel',
+      'definitionLabelMarker',
+      'definitionLabelString'
+    )(code)
   }
-  const dirname = path$1.dirname(file);
-  const basename = path$1.basename(file);
-  const parent = this.fsw._getWatchedDir(dirname);
-  // stats is always present
-  let prevStats = stats;
+  /** @type {State} */
 
-  // if the file is already being watched, do nothing
-  if (parent.has(basename)) return;
+  function labelAfter(code) {
+    identifier = normalizeIdentifier(
+      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
+    );
 
-  // kick off the watcher
-  const closer = this._watchWithNodeFs(file, async (path, newStats) => {
-    if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
-    if (!newStats || newStats.mtimeMs === 0) {
-      try {
-        const newStats = await stat$3(file);
-        if (this.fsw.closed) return;
-        // Check that change event was not fired because of changed only accessTime.
-        const at = newStats.atimeMs;
-        const mt = newStats.mtimeMs;
-        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-          this.fsw._emit(EV_CHANGE, file, newStats);
-        }
-        prevStats = newStats;
-      } catch (error) {
-        // Fix issues where mtime is null but file is still present
-        this.fsw._remove(dirname, basename);
-      }
-    // add is about to be emitted if file not already tracked in parent
-    } else if (parent.has(basename)) {
-      // Check that change event was not fired because of changed only accessTime.
-      const at = newStats.atimeMs;
-      const mt = newStats.mtimeMs;
-      if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-        this.fsw._emit(EV_CHANGE, file, newStats);
+    if (code === 58) {
+      effects.enter('definitionMarker');
+      effects.consume(code);
+      effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.
+
+      return factoryWhitespace(
+        effects,
+        factoryDestination(
+          effects,
+          effects.attempt(
+            titleConstruct,
+            factorySpace(effects, after, 'whitespace'),
+            factorySpace(effects, after, 'whitespace')
+          ),
+          nok,
+          'definitionDestination',
+          'definitionDestinationLiteral',
+          'definitionDestinationLiteralMarker',
+          'definitionDestinationRaw',
+          'definitionDestinationString'
+        )
+      )
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function after(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit('definition');
+
+      if (!self.parser.defined.includes(identifier)) {
+        self.parser.defined.push(identifier);
       }
-      prevStats = newStats;
+
+      return ok(code)
     }
-  });
 
-  // emit an add event if we're supposed to
-  if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
-    if (!this.fsw._throttle(EV_ADD, file, 0)) return;
-    this.fsw._emit(EV_ADD, file, stats);
+    return nok(code)
   }
+}
+/** @type {Tokenizer} */
 
-  return closer;
+function tokenizeTitle(effects, ok, nok) {
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    return markdownLineEndingOrSpace(code)
+      ? factoryWhitespace(effects, before)(code)
+      : nok(code)
+  }
+  /** @type {State} */
+
+  function before(code) {
+    if (code === 34 || code === 39 || code === 40) {
+      return factoryTitle(
+        effects,
+        factorySpace(effects, after, 'whitespace'),
+        nok,
+        'definitionTitle',
+        'definitionTitleMarker',
+        'definitionTitleString'
+      )(code)
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function after(code) {
+    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)
+  }
 }
 
 /**
- * Handle symlinks encountered while reading a dir.
- * @param {Object} entry returned by readdirp
- * @param {String} directory path of dir being read
- * @param {String} path of this item
- * @param {String} item basename of this item
- * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
  */
-async _handleSymlink(entry, directory, path, item) {
-  if (this.fsw.closed) {
-    return;
+
+/** @type {Construct} */
+const hardBreakEscape = {
+  name: 'hardBreakEscape',
+  tokenize: tokenizeHardBreakEscape
+};
+/** @type {Tokenizer} */
+
+function tokenizeHardBreakEscape(effects, ok, nok) {
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('hardBreakEscape');
+    effects.enter('escapeMarker');
+    effects.consume(code);
+    return open
   }
-  const full = entry.fullPath;
-  const dir = this.fsw._getWatchedDir(directory);
+  /** @type {State} */
 
-  if (!this.fsw.options.followSymlinks) {
-    // watch symlink directly (don't follow) and detect changes
-    this.fsw._incrReadyCount();
-    const linkPath = await fsrealpath(path);
-    if (this.fsw.closed) return;
-    if (dir.has(item)) {
-      if (this.fsw._symlinkPaths.get(full) !== linkPath) {
-        this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV_CHANGE, path, entry.stats);
-      }
-    } else {
-      dir.add(item);
-      this.fsw._symlinkPaths.set(full, linkPath);
-      this.fsw._emit(EV_ADD, path, entry.stats);
+  function open(code) {
+    if (markdownLineEnding(code)) {
+      effects.exit('escapeMarker');
+      effects.exit('hardBreakEscape');
+      return ok(code)
     }
-    this.fsw._emitReady();
-    return true;
+
+    return nok(code)
   }
+}
 
-  // don't follow the same symlink more than once
-  if (this.fsw._symlinkPaths.has(full)) {
-    return true;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/** @type {Construct} */
+const headingAtx = {
+  name: 'headingAtx',
+  tokenize: tokenizeHeadingAtx,
+  resolve: resolveHeadingAtx
+};
+/** @type {Resolver} */
+
+function resolveHeadingAtx(events, context) {
+  let contentEnd = events.length - 2;
+  let contentStart = 3;
+  /** @type {Token} */
+
+  let content;
+  /** @type {Token} */
+
+  let text; // Prefix whitespace, part of the opening.
+
+  if (events[contentStart][1].type === 'whitespace') {
+    contentStart += 2;
+  } // Suffix whitespace, part of the closing.
+
+  if (
+    contentEnd - 2 > contentStart &&
+    events[contentEnd][1].type === 'whitespace'
+  ) {
+    contentEnd -= 2;
   }
 
-  this.fsw._symlinkPaths.set(full, true);
+  if (
+    events[contentEnd][1].type === 'atxHeadingSequence' &&
+    (contentStart === contentEnd - 1 ||
+      (contentEnd - 4 > contentStart &&
+        events[contentEnd - 2][1].type === 'whitespace'))
+  ) {
+    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
+  }
+
+  if (contentEnd > contentStart) {
+    content = {
+      type: 'atxHeadingText',
+      start: events[contentStart][1].start,
+      end: events[contentEnd][1].end
+    };
+    text = {
+      type: 'chunkText',
+      start: events[contentStart][1].start,
+      end: events[contentEnd][1].end,
+      // @ts-expect-error Constants are fine to assign.
+      contentType: 'text'
+    };
+    splice(events, contentStart, contentEnd - contentStart + 1, [
+      ['enter', content, context],
+      ['enter', text, context],
+      ['exit', text, context],
+      ['exit', content, context]
+    ]);
+  }
+
+  return events
 }
+/** @type {Tokenizer} */
 
-_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-  // Normalize the directory name on Windows
-  directory = path$1.join(directory, EMPTY_STR);
+function tokenizeHeadingAtx(effects, ok, nok) {
+  const self = this;
+  let size = 0;
+  return start
+  /** @type {State} */
 
-  if (!wh.hasGlob) {
-    throttler = this.fsw._throttle('readdir', directory, 1000);
-    if (!throttler) return;
+  function start(code) {
+    effects.enter('atxHeading');
+    effects.enter('atxHeadingSequence');
+    return fenceOpenInside(code)
   }
+  /** @type {State} */
 
-  const previous = this.fsw._getWatchedDir(wh.path);
-  const current = new Set();
-
-  let stream = this.fsw._readdirp(directory, {
-    fileFilter: entry => wh.filterPath(entry),
-    directoryFilter: entry => wh.filterDir(entry),
-    depth: 0
-  }).on(STR_DATA, async (entry) => {
-    if (this.fsw.closed) {
-      stream = undefined;
-      return;
+  function fenceOpenInside(code) {
+    if (code === 35 && size++ < 6) {
+      effects.consume(code);
+      return fenceOpenInside
     }
-    const item = entry.path;
-    let path = path$1.join(directory, item);
-    current.add(item);
 
-    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
-      return;
+    if (code === null || markdownLineEndingOrSpace(code)) {
+      effects.exit('atxHeadingSequence');
+      return self.interrupt ? ok(code) : headingBreak(code)
     }
 
-    if (this.fsw.closed) {
-      stream = undefined;
-      return;
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function headingBreak(code) {
+    if (code === 35) {
+      effects.enter('atxHeadingSequence');
+      return sequence(code)
     }
-    // Files that present in current directory snapshot
-    // but absent in previous are added to watch list and
-    // emit `add` event.
-    if (item === target || !target && !previous.has(item)) {
-      this.fsw._incrReadyCount();
 
-      // ensure relativeness of path is preserved in case of watcher reuse
-      path = path$1.join(dir, path$1.relative(dir, path));
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit('atxHeading');
+      return ok(code)
+    }
 
-      this._addToNodeFs(path, initialAdd, wh, depth + 1);
+    if (markdownSpace(code)) {
+      return factorySpace(effects, headingBreak, 'whitespace')(code)
     }
-  }).on(EV_ERROR, this._boundHandleError);
 
-  return new Promise(resolve =>
-    stream.once(STR_END, () => {
-      if (this.fsw.closed) {
-        stream = undefined;
-        return;
-      }
-      const wasThrottled = throttler ? throttler.clear() : false;
+    effects.enter('atxHeadingText');
+    return data(code)
+  }
+  /** @type {State} */
 
-      resolve();
+  function sequence(code) {
+    if (code === 35) {
+      effects.consume(code);
+      return sequence
+    }
 
-      // Files that absent in current directory snapshot
-      // but present in previous emit `remove` event
-      // and are removed from @watched[directory].
-      previous.getChildren().filter((item) => {
-        return item !== directory &&
-          !current.has(item) &&
-          // in case of intersecting globs;
-          // a path may have been filtered out of this readdir, but
-          // shouldn't be removed because it matches a different glob
-          (!wh.hasGlob || wh.filterPath({
-            fullPath: path$1.resolve(directory, item)
-          }));
-      }).forEach((item) => {
-        this.fsw._remove(directory, item);
-      });
+    effects.exit('atxHeadingSequence');
+    return headingBreak(code)
+  }
+  /** @type {State} */
 
-      stream = undefined;
+  function data(code) {
+    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {
+      effects.exit('atxHeadingText');
+      return headingBreak(code)
+    }
 
-      // one more time for any missed in case changes came in extremely quickly
-      if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
-    })
-  );
+    effects.consume(code);
+    return data
+  }
 }
 
 /**
- * Read directory to add / remove files from `@watched` list and re-read it on change.
- * @param {String} dir fs path
- * @param {fs.Stats} stats
- * @param {Boolean} initialAdd
- * @param {Number} depth relative to user-supplied path
- * @param {String} target child path targeted for watch
- * @param {Object} wh Common watch helpers for this path
- * @param {String} realpath
- * @returns {Promise<Function>} closer for the watcher instance.
+ * List of lowercase HTML tag names which when parsing HTML (flow), result
+ * in more relaxed rules (condition 6): because they are known blocks, the
+ * HTML-like syntax doesn’t have to be strictly parsed.
+ * For tag names not in this list, a more strict algorithm (condition 7) is used
+ * to detect whether the HTML-like syntax is seen as HTML (flow) or not.
+ *
+ * This is copied from:
+ * <https://spec.commonmark.org/0.29/#html-blocks>.
  */
-async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-  const parentDir = this.fsw._getWatchedDir(path$1.dirname(dir));
-  const tracked = parentDir.has(path$1.basename(dir));
-  if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
-    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
-  }
+const htmlBlockNames = [
+  'address',
+  'article',
+  'aside',
+  'base',
+  'basefont',
+  'blockquote',
+  'body',
+  'caption',
+  'center',
+  'col',
+  'colgroup',
+  'dd',
+  'details',
+  'dialog',
+  'dir',
+  'div',
+  'dl',
+  'dt',
+  'fieldset',
+  'figcaption',
+  'figure',
+  'footer',
+  'form',
+  'frame',
+  'frameset',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'head',
+  'header',
+  'hr',
+  'html',
+  'iframe',
+  'legend',
+  'li',
+  'link',
+  'main',
+  'menu',
+  'menuitem',
+  'nav',
+  'noframes',
+  'ol',
+  'optgroup',
+  'option',
+  'p',
+  'param',
+  'section',
+  'source',
+  'summary',
+  'table',
+  'tbody',
+  'td',
+  'tfoot',
+  'th',
+  'thead',
+  'title',
+  'tr',
+  'track',
+  'ul'
+];
 
-  // ensure dir is tracked (harmless if redundant)
-  parentDir.add(path$1.basename(dir));
-  this.fsw._getWatchedDir(dir);
-  let throttler;
-  let closer;
+/**
+ * List of lowercase HTML tag names which when parsing HTML (flow), result in
+ * HTML that can include lines w/o exiting, until a closing tag also in this
+ * list is found (condition 1).
+ *
+ * This module is copied from:
+ * <https://spec.commonmark.org/0.29/#html-blocks>.
+ *
+ * Note that `textarea` is not available in `CommonMark@0.29` but has been
+ * merged to the primary branch and is slated to be released in the next release
+ * of CommonMark.
+ */
+const htmlRawNames = ['pre', 'script', 'style', 'textarea'];
 
-  const oDepth = this.fsw.options.depth;
-  if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
-    if (!target) {
-      await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
-      if (this.fsw.closed) return;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+/** @type {Construct} */
+
+const htmlFlow = {
+  name: 'htmlFlow',
+  tokenize: tokenizeHtmlFlow,
+  resolveTo: resolveToHtmlFlow,
+  concrete: true
+};
+/** @type {Construct} */
+
+const nextBlankConstruct = {
+  tokenize: tokenizeNextBlank,
+  partial: true
+};
+/** @type {Resolver} */
+
+function resolveToHtmlFlow(events) {
+  let index = events.length;
+
+  while (index--) {
+    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {
+      break
     }
+  }
 
-    closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
-      // if current directory is removed, do nothing
-      if (stats && stats.mtimeMs === 0) return;
+  if (index > 1 && events[index - 2][1].type === 'linePrefix') {
+    // Add the prefix start to the HTML token.
+    events[index][1].start = events[index - 2][1].start; // Add the prefix start to the HTML line token.
 
-      this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
-    });
+    events[index + 1][1].start = events[index - 2][1].start; // Remove the line prefix.
+
+    events.splice(index - 2, 2);
   }
-  return closer;
+
+  return events
 }
+/** @type {Tokenizer} */
 
-/**
- * Handle added file, directory, or glob pattern.
- * Delegates call to _handleFile / _handleDir after checks.
- * @param {String} path to file or ir
- * @param {Boolean} initialAdd was the file added at watch instantiation?
- * @param {Object} priorWh depth relative to user-supplied path
- * @param {Number} depth Child path actually targeted for watch
- * @param {String=} target Child path actually targeted for watch
- * @returns {Promise}
- */
-async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
-  const ready = this.fsw._emitReady;
-  if (this.fsw._isIgnored(path) || this.fsw.closed) {
-    ready();
-    return false;
+function tokenizeHtmlFlow(effects, ok, nok) {
+  const self = this;
+  /** @type {number} */
+
+  let kind;
+  /** @type {boolean} */
+
+  let startTag;
+  /** @type {string} */
+
+  let buffer;
+  /** @type {number} */
+
+  let index;
+  /** @type {Code} */
+
+  let marker;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('htmlFlow');
+    effects.enter('htmlFlowData');
+    effects.consume(code);
+    return open
   }
+  /** @type {State} */
 
-  const wh = this.fsw._getWatchHelpers(path, depth);
-  if (!wh.hasGlob && priorWh) {
-    wh.hasGlob = priorWh.hasGlob;
-    wh.globFilter = priorWh.globFilter;
-    wh.filterPath = entry => priorWh.filterPath(entry);
-    wh.filterDir = entry => priorWh.filterDir(entry);
+  function open(code) {
+    if (code === 33) {
+      effects.consume(code);
+      return declarationStart
+    }
+
+    if (code === 47) {
+      effects.consume(code);
+      return tagCloseStart
+    }
+
+    if (code === 63) {
+      effects.consume(code);
+      kind = 3; // While we’re in an instruction instead of a declaration, we’re on a `?`
+      // right now, so we do need to search for `>`, similar to declarations.
+
+      return self.interrupt ? ok : continuationDeclarationInside
+    }
+
+    if (asciiAlpha(code)) {
+      effects.consume(code);
+      buffer = String.fromCharCode(code);
+      startTag = true;
+      return tagName
+    }
+
+    return nok(code)
   }
+  /** @type {State} */
 
-  // evaluate what is at the path we're being asked to watch
-  try {
-    const stats = await statMethods[wh.statMethod](wh.watchPath);
-    if (this.fsw.closed) return;
-    if (this.fsw._isIgnored(wh.watchPath, stats)) {
-      ready();
-      return false;
+  function declarationStart(code) {
+    if (code === 45) {
+      effects.consume(code);
+      kind = 2;
+      return commentOpenInside
     }
 
-    const follow = this.fsw.options.followSymlinks && !path.includes(STAR$1) && !path.includes(BRACE_START);
-    let closer;
-    if (stats.isDirectory()) {
-      const targetPath = follow ? await fsrealpath(path) : path;
-      if (this.fsw.closed) return;
-      closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
-      if (this.fsw.closed) return;
-      // preserve this symlink's target path
-      if (path !== targetPath && targetPath !== undefined) {
-        this.fsw._symlinkPaths.set(targetPath, true);
+    if (code === 91) {
+      effects.consume(code);
+      kind = 5;
+      buffer = 'CDATA[';
+      index = 0;
+      return cdataOpenInside
+    }
+
+    if (asciiAlpha(code)) {
+      effects.consume(code);
+      kind = 4;
+      return self.interrupt ? ok : continuationDeclarationInside
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function commentOpenInside(code) {
+    if (code === 45) {
+      effects.consume(code);
+      return self.interrupt ? ok : continuationDeclarationInside
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function cdataOpenInside(code) {
+    if (code === buffer.charCodeAt(index++)) {
+      effects.consume(code);
+      return index === buffer.length
+        ? self.interrupt
+          ? ok
+          : continuation
+        : cdataOpenInside
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function tagCloseStart(code) {
+    if (asciiAlpha(code)) {
+      effects.consume(code);
+      buffer = String.fromCharCode(code);
+      return tagName
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function tagName(code) {
+    if (
+      code === null ||
+      code === 47 ||
+      code === 62 ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      if (
+        code !== 47 &&
+        startTag &&
+        htmlRawNames.includes(buffer.toLowerCase())
+      ) {
+        kind = 1;
+        return self.interrupt ? ok(code) : continuation(code)
       }
-    } else if (stats.isSymbolicLink()) {
-      const targetPath = follow ? await fsrealpath(path) : path;
-      if (this.fsw.closed) return;
-      const parent = path$1.dirname(wh.watchPath);
-      this.fsw._getWatchedDir(parent).add(wh.watchPath);
-      this.fsw._emit(EV_ADD, wh.watchPath, stats);
-      closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
-      if (this.fsw.closed) return;
 
-      // preserve this symlink's target path
-      if (targetPath !== undefined) {
-        this.fsw._symlinkPaths.set(path$1.resolve(path), targetPath);
+      if (htmlBlockNames.includes(buffer.toLowerCase())) {
+        kind = 6;
+
+        if (code === 47) {
+          effects.consume(code);
+          return basicSelfClosing
+        }
+
+        return self.interrupt ? ok(code) : continuation(code)
       }
-    } else {
-      closer = this._handleFile(wh.watchPath, stats, initialAdd);
+
+      kind = 7; // Do not support complete HTML when interrupting
+
+      return self.interrupt && !self.parser.lazy[self.now().line]
+        ? nok(code)
+        : startTag
+        ? completeAttributeNameBefore(code)
+        : completeClosingTagAfter(code)
     }
-    ready();
 
-    this.fsw._addPathCloser(path, closer);
-    return false;
+    if (code === 45 || asciiAlphanumeric(code)) {
+      effects.consume(code);
+      buffer += String.fromCharCode(code);
+      return tagName
+    }
 
-  } catch (error) {
-    if (this.fsw._handleError(error)) {
-      ready();
-      return path;
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function basicSelfClosing(code) {
+    if (code === 62) {
+      effects.consume(code);
+      return self.interrupt ? ok : continuation
     }
+
+    return nok(code)
   }
-}
+  /** @type {State} */
 
-}
+  function completeClosingTagAfter(code) {
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return completeClosingTagAfter
+    }
 
-var nodefsHandler = NodeFsHandler;
+    return completeEnd(code)
+  }
+  /** @type {State} */
 
-const { promisify: promisify$2 } = util$2;
+  function completeAttributeNameBefore(code) {
+    if (code === 47) {
+      effects.consume(code);
+      return completeEnd
+    }
 
-let fsevents;
-try {
-  fsevents = undefined;
-} catch (error) {
-  if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
-}
+    if (code === 58 || code === 95 || asciiAlpha(code)) {
+      effects.consume(code);
+      return completeAttributeName
+    }
 
-if (fsevents) {
-  // TODO: real check
-  const mtch = process.version.match(/v(\d+)\.(\d+)/);
-  if (mtch && mtch[1] && mtch[2]) {
-    const maj = Number.parseInt(mtch[1], 10);
-    const min = Number.parseInt(mtch[2], 10);
-    if (maj === 8 && min < 16) {
-      fsevents = undefined;
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return completeAttributeNameBefore
     }
+
+    return completeEnd(code)
   }
-}
+  /** @type {State} */
 
-const {
-  EV_ADD: EV_ADD$1,
-  EV_CHANGE: EV_CHANGE$1,
-  EV_ADD_DIR: EV_ADD_DIR$1,
-  EV_UNLINK,
-  EV_ERROR: EV_ERROR$1,
-  STR_DATA: STR_DATA$1,
-  STR_END: STR_END$1,
-  FSEVENT_CREATED,
-  FSEVENT_MODIFIED,
-  FSEVENT_DELETED,
-  FSEVENT_MOVED,
-  // FSEVENT_CLONED,
-  FSEVENT_UNKNOWN,
-  FSEVENT_TYPE_FILE,
-  FSEVENT_TYPE_DIRECTORY,
-  FSEVENT_TYPE_SYMLINK,
+  function completeAttributeName(code) {
+    if (
+      code === 45 ||
+      code === 46 ||
+      code === 58 ||
+      code === 95 ||
+      asciiAlphanumeric(code)
+    ) {
+      effects.consume(code);
+      return completeAttributeName
+    }
 
-  ROOT_GLOBSTAR,
-  DIR_SUFFIX,
-  DOT_SLASH,
-  FUNCTION_TYPE,
-  EMPTY_FN: EMPTY_FN$1,
-  IDENTITY_FN
-} = constants$2;
+    return completeAttributeNameAfter(code)
+  }
+  /** @type {State} */
 
-const Depth = (value) => isNaN(value) ? {} : {depth: value};
+  function completeAttributeNameAfter(code) {
+    if (code === 61) {
+      effects.consume(code);
+      return completeAttributeValueBefore
+    }
+
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return completeAttributeNameAfter
+    }
 
-const stat$4 = promisify$2(fs$1.stat);
-const lstat$2 = promisify$2(fs$1.lstat);
-const realpath$3 = promisify$2(fs$1.realpath);
+    return completeAttributeNameBefore(code)
+  }
+  /** @type {State} */
 
-const statMethods$1 = { stat: stat$4, lstat: lstat$2 };
+  function completeAttributeValueBefore(code) {
+    if (
+      code === null ||
+      code === 60 ||
+      code === 61 ||
+      code === 62 ||
+      code === 96
+    ) {
+      return nok(code)
+    }
 
-/**
- * @typedef {String} Path
- */
+    if (code === 34 || code === 39) {
+      effects.consume(code);
+      marker = code;
+      return completeAttributeValueQuoted
+    }
 
-/**
- * @typedef {Object} FsEventsWatchContainer
- * @property {Set<Function>} listeners
- * @property {Function} rawEmitter
- * @property {{stop: Function}} watcher
- */
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return completeAttributeValueBefore
+    }
 
-// fsevents instance helper functions
-/**
- * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
- * @type {Map<Path,FsEventsWatchContainer>}
- */
-const FSEventsWatchers = new Map();
+    marker = null;
+    return completeAttributeValueUnquoted(code)
+  }
+  /** @type {State} */
 
-// Threshold of duplicate path prefixes at which to start
-// consolidating going forward
-const consolidateThreshhold = 10;
+  function completeAttributeValueQuoted(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return nok(code)
+    }
 
-const wrongEventFlags = new Set([
-  69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
-]);
+    if (code === marker) {
+      effects.consume(code);
+      return completeAttributeValueQuotedAfter
+    }
 
-/**
- * Instantiates the fsevents interface
- * @param {Path} path path to be watched
- * @param {Function} callback called when fsevents is bound and ready
- * @returns {{stop: Function}} new fsevents instance
- */
-const createFSEventsInstance = (path, callback) => {
-  const stop = fsevents.watch(path, callback);
-  return {stop};
-};
+    effects.consume(code);
+    return completeAttributeValueQuoted
+  }
+  /** @type {State} */
 
-/**
- * Instantiates the fsevents interface or binds listeners to an existing one covering
- * the same file tree.
- * @param {Path} path           - to be watched
- * @param {Path} realPath       - real path for symlinks
- * @param {Function} listener   - called when fsevents emits events
- * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
- * @returns {Function} closer
- */
-function setFSEventsListener(path, realPath, listener, rawEmitter, fsw) {
-  let watchPath = path$1.extname(path) ? path$1.dirname(path) : path;
-  const parentPath = path$1.dirname(watchPath);
-  let cont = FSEventsWatchers.get(watchPath);
+  function completeAttributeValueUnquoted(code) {
+    if (
+      code === null ||
+      code === 34 ||
+      code === 39 ||
+      code === 60 ||
+      code === 61 ||
+      code === 62 ||
+      code === 96 ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      return completeAttributeNameAfter(code)
+    }
 
-  // If we've accumulated a substantial number of paths that
-  // could have been consolidated by watching one directory
-  // above the current one, create a watcher on the parent
-  // path instead, so that we do consolidate going forward.
-  if (couldConsolidate(parentPath)) {
-    watchPath = parentPath;
+    effects.consume(code);
+    return completeAttributeValueUnquoted
   }
+  /** @type {State} */
 
-  const resolvedPath = path$1.resolve(path);
-  const hasSymlink = resolvedPath !== realPath;
+  function completeAttributeValueQuotedAfter(code) {
+    if (code === 47 || code === 62 || markdownSpace(code)) {
+      return completeAttributeNameBefore(code)
+    }
 
-  const filteredListener = (fullPath, flags, info) => {
-    if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
-    if (
-      fullPath === resolvedPath ||
-      !fullPath.indexOf(resolvedPath + path$1.sep)
-    ) listener(fullPath, flags, info);
-  };
+    return nok(code)
+  }
+  /** @type {State} */
 
-  // check if there is already a watcher on a parent path
-  // modifies `watchPath` to the parent path when it finds a match
-  let watchedParent = false;
-  for (const watchedPath of FSEventsWatchers.keys()) {
-    if (realPath.indexOf(path$1.resolve(watchedPath) + path$1.sep) === 0) {
-      watchPath = watchedPath;
-      cont = FSEventsWatchers.get(watchPath);
-      watchedParent = true;
-      break;
+  function completeEnd(code) {
+    if (code === 62) {
+      effects.consume(code);
+      return completeAfter
     }
+
+    return nok(code)
   }
+  /** @type {State} */
 
-  if (cont || watchedParent) {
-    cont.listeners.add(filteredListener);
-  } else {
-    cont = {
-      listeners: new Set([filteredListener]),
-      rawEmitter,
-      watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
-        if (fsw.closed) return;
-        const info = fsevents.getInfo(fullPath, flags);
-        cont.listeners.forEach(list => {
-          list(fullPath, flags, info);
-        });
+  function completeAfter(code) {
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return completeAfter
+    }
 
-        cont.rawEmitter(info.event, fullPath, info);
-      })
-    };
-    FSEventsWatchers.set(watchPath, cont);
+    return code === null || markdownLineEnding(code)
+      ? continuation(code)
+      : nok(code)
   }
+  /** @type {State} */
 
-  // removes this instance's listeners and closes the underlying fsevents
-  // instance if there are no more listeners left
-  return () => {
-    const lst = cont.listeners;
+  function continuation(code) {
+    if (code === 45 && kind === 2) {
+      effects.consume(code);
+      return continuationCommentInside
+    }
 
-    lst.delete(filteredListener);
-    if (!lst.size) {
-      FSEventsWatchers.delete(watchPath);
-      if (cont.watcher) return cont.watcher.stop().then(() => {
-        cont.rawEmitter = cont.watcher = undefined;
-        Object.freeze(cont);
-      });
+    if (code === 60 && kind === 1) {
+      effects.consume(code);
+      return continuationRawTagOpen
     }
-  };
-}
 
-// Decide whether or not we should start a new higher-level
-// parent watcher
-const couldConsolidate = (path) => {
-  let count = 0;
-  for (const watchPath of FSEventsWatchers.keys()) {
-    if (watchPath.indexOf(path) === 0) {
-      count++;
-      if (count >= consolidateThreshhold) {
-        return true;
-      }
+    if (code === 62 && kind === 4) {
+      effects.consume(code);
+      return continuationClose
     }
-  }
 
-  return false;
-};
+    if (code === 63 && kind === 3) {
+      effects.consume(code);
+      return continuationDeclarationInside
+    }
 
-// returns boolean indicating whether fsevents can be used
-const canUse = () => fsevents && FSEventsWatchers.size < 128;
+    if (code === 93 && kind === 5) {
+      effects.consume(code);
+      return continuationCharacterDataInside
+    }
 
-// determines subdirectory traversal levels from root to path
-const calcDepth = (path, root) => {
-  let i = 0;
-  while (!path.indexOf(root) && (path = path$1.dirname(path)) !== root) i++;
-  return i;
-};
+    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {
+      return effects.check(
+        nextBlankConstruct,
+        continuationClose,
+        continuationAtLineEnding
+      )(code)
+    }
 
-// returns boolean indicating whether the fsevents' event info has the same type
-// as the one returned by fs.stat
-const sameTypes = (info, stats) => (
-  info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
-  info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
-  info.type === FSEVENT_TYPE_FILE && stats.isFile()
-);
+    if (code === null || markdownLineEnding(code)) {
+      return continuationAtLineEnding(code)
+    }
 
-/**
- * @mixin
- */
-class FsEventsHandler {
+    effects.consume(code);
+    return continuation
+  }
+  /** @type {State} */
 
-/**
- * @param {import('../index').FSWatcher} fsw
- */
-constructor(fsw) {
-  this.fsw = fsw;
-}
-checkIgnored(path, stats) {
-  const ipaths = this.fsw._ignoredPaths;
-  if (this.fsw._isIgnored(path, stats)) {
-    ipaths.add(path);
-    if (stats && stats.isDirectory()) {
-      ipaths.add(path + ROOT_GLOBSTAR);
+  function continuationAtLineEnding(code) {
+    effects.exit('htmlFlowData');
+    return htmlContinueStart(code)
+  }
+  /** @type {State} */
+
+  function htmlContinueStart(code) {
+    if (code === null) {
+      return done(code)
     }
-    return true;
+
+    if (markdownLineEnding(code)) {
+      return effects.attempt(
+        {
+          tokenize: htmlLineEnd,
+          partial: true
+        },
+        htmlContinueStart,
+        done
+      )(code)
+    }
+
+    effects.enter('htmlFlowData');
+    return continuation(code)
   }
+  /** @type {Tokenizer} */
 
-  ipaths.delete(path);
-  ipaths.delete(path + ROOT_GLOBSTAR);
-}
+  function htmlLineEnd(effects, ok, nok) {
+    return start
+    /** @type {State} */
 
-addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
-  const event = watchedDir.has(item) ? EV_CHANGE$1 : EV_ADD$1;
-  this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
-}
+    function start(code) {
+      effects.enter('lineEnding');
+      effects.consume(code);
+      effects.exit('lineEnding');
+      return lineStart
+    }
+    /** @type {State} */
 
-async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
-  try {
-    const stats = await stat$4(path);
-    if (this.fsw.closed) return;
-    if (this.fsw.closed) return;
-    if (sameTypes(info, stats)) {
-      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
-    } else {
-      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    function lineStart(code) {
+      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
     }
-  } catch (error) {
-    if (error.code === 'EACCES') {
-      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
-    } else {
-      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+  }
+  /** @type {State} */
+
+  function continuationCommentInside(code) {
+    if (code === 45) {
+      effects.consume(code);
+      return continuationDeclarationInside
     }
+
+    return continuation(code)
   }
-}
+  /** @type {State} */
 
-handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
-  if (this.fsw.closed || this.checkIgnored(path)) return;
+  function continuationRawTagOpen(code) {
+    if (code === 47) {
+      effects.consume(code);
+      buffer = '';
+      return continuationRawEndTag
+    }
 
-  if (event === EV_UNLINK) {
-    const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
-    // suppress unlink events on never before seen files
-    if (isDirectory || watchedDir.has(item)) {
-      this.fsw._remove(parent, item, isDirectory);
+    return continuation(code)
+  }
+  /** @type {State} */
+
+  function continuationRawEndTag(code) {
+    if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {
+      effects.consume(code);
+      return continuationClose
     }
-  } else {
-    if (event === EV_ADD$1) {
-      // track new directories
-      if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);
 
-      if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
-        // push symlinks back to the top of the stack to get handled
-        const curDepth = opts.depth === undefined ?
-          undefined : calcDepth(fullPath, realPath) + 1;
-        return this._addToFsEvents(path, false, true, curDepth);
-      }
+    if (asciiAlpha(code) && buffer.length < 8) {
+      effects.consume(code);
+      buffer += String.fromCharCode(code);
+      return continuationRawEndTag
+    }
 
-      // track new paths
-      // (other than symlinks being followed, which will be tracked soon)
-      this.fsw._getWatchedDir(parent).add(item);
+    return continuation(code)
+  }
+  /** @type {State} */
+
+  function continuationCharacterDataInside(code) {
+    if (code === 93) {
+      effects.consume(code);
+      return continuationDeclarationInside
     }
-    /**
-     * @type {'add'|'addDir'|'unlink'|'unlinkDir'}
-     */
-    const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
-    this.fsw._emit(eventName, path);
-    if (eventName === EV_ADD_DIR$1) this._addToFsEvents(path, false, true);
+
+    return continuation(code)
   }
-}
+  /** @type {State} */
 
-/**
- * Handle symlinks encountered during directory scan
- * @param {String} watchPath  - file/dir path to be watched with fsevents
- * @param {String} realPath   - real path (in case of symlinks)
- * @param {Function} transform  - path transformer
- * @param {Function} globFilter - path filter in case a glob pattern was provided
- * @returns {Function} closer for the watcher instance
-*/
-_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
-  if (this.fsw.closed) return;
-  if (this.fsw._isIgnored(watchPath)) return;
-  const opts = this.fsw.options;
-  const watchCallback = async (fullPath, flags, info) => {
-    if (this.fsw.closed) return;
-    if (
-      opts.depth !== undefined &&
-      calcDepth(fullPath, realPath) > opts.depth
-    ) return;
-    const path = transform(path$1.join(
-      watchPath, path$1.relative(watchPath, fullPath)
-    ));
-    if (globFilter && !globFilter(path)) return;
-    // ensure directories are tracked
-    const parent = path$1.dirname(path);
-    const item = path$1.basename(path);
-    const watchedDir = this.fsw._getWatchedDir(
-      info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
-    );
+  function continuationDeclarationInside(code) {
+    if (code === 62) {
+      effects.consume(code);
+      return continuationClose
+    }
 
-    // correct for wrong events emitted
-    if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
-      if (typeof opts.ignored === FUNCTION_TYPE) {
-        let stats;
-        try {
-          stats = await stat$4(path);
-        } catch (error) {}
-        if (this.fsw.closed) return;
-        if (this.checkIgnored(path, stats)) return;
-        if (sameTypes(info, stats)) {
-          this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
-        } else {
-          this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
-        }
-      } else {
-        this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
-      }
-    } else {
-      switch (info.event) {
-      case FSEVENT_CREATED:
-      case FSEVENT_MODIFIED:
-        return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
-      case FSEVENT_DELETED:
-      case FSEVENT_MOVED:
-        return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
-      }
+    return continuation(code)
+  }
+  /** @type {State} */
+
+  function continuationClose(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit('htmlFlowData');
+      return done(code)
     }
-  };
 
-  const closer = setFSEventsListener(
-    watchPath,
-    realPath,
-    watchCallback,
-    this.fsw._emitRaw,
-    this.fsw
-  );
+    effects.consume(code);
+    return continuationClose
+  }
+  /** @type {State} */
 
-  this.fsw._emitReady();
-  return closer;
+  function done(code) {
+    effects.exit('htmlFlow');
+    return ok(code)
+  }
+}
+/** @type {Tokenizer} */
+
+function tokenizeNextBlank(effects, ok, nok) {
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.exit('htmlFlowData');
+    effects.enter('lineEndingBlank');
+    effects.consume(code);
+    effects.exit('lineEndingBlank');
+    return effects.attempt(blankLine, ok, nok)
+  }
 }
 
 /**
- * Handle symlinks encountered during directory scan
- * @param {String} linkPath path to symlink
- * @param {String} fullPath absolute path to the symlink
- * @param {Function} transform pre-existing path transformer
- * @param {Number} curDepth level of subdirectories traversed to where symlink is
- * @returns {Promise<void>}
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
  */
-async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
-  // don't follow the same symlink more than once
-  if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;
 
-  this.fsw._symlinkPaths.set(fullPath, true);
-  this.fsw._incrReadyCount();
+/** @type {Construct} */
+const htmlText = {
+  name: 'htmlText',
+  tokenize: tokenizeHtmlText
+};
+/** @type {Tokenizer} */
 
-  try {
-    const linkTarget = await realpath$3(linkPath);
-    if (this.fsw.closed) return;
-    if (this.fsw._isIgnored(linkTarget)) {
-      return this.fsw._emitReady();
+function tokenizeHtmlText(effects, ok, nok) {
+  const self = this;
+  /** @type {NonNullable<Code>|undefined} */
+
+  let marker;
+  /** @type {string} */
+
+  let buffer;
+  /** @type {number} */
+
+  let index;
+  /** @type {State} */
+
+  let returnState;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('htmlText');
+    effects.enter('htmlTextData');
+    effects.consume(code);
+    return open
+  }
+  /** @type {State} */
+
+  function open(code) {
+    if (code === 33) {
+      effects.consume(code);
+      return declarationOpen
     }
 
-    this.fsw._incrReadyCount();
+    if (code === 47) {
+      effects.consume(code);
+      return tagCloseStart
+    }
 
-    // add the linkTarget for watching with a wrapper for transform
-    // that causes emitted paths to incorporate the link's path
-    this._addToFsEvents(linkTarget || linkPath, (path) => {
-      let aliasedPath = linkPath;
-      if (linkTarget && linkTarget !== DOT_SLASH) {
-        aliasedPath = path.replace(linkTarget, linkPath);
-      } else if (path !== DOT_SLASH) {
-        aliasedPath = path$1.join(linkPath, path);
-      }
-      return transform(aliasedPath);
-    }, false, curDepth);
-  } catch(error) {
-    if (this.fsw._handleError(error)) {
-      return this.fsw._emitReady();
+    if (code === 63) {
+      effects.consume(code);
+      return instruction
     }
+
+    if (asciiAlpha(code)) {
+      effects.consume(code);
+      return tagOpen
+    }
+
+    return nok(code)
   }
-}
+  /** @type {State} */
 
-/**
- *
- * @param {Path} newPath
- * @param {fs.Stats} stats
- */
-emitAdd(newPath, stats, processPath, opts, forceAdd) {
-  const pp = processPath(newPath);
-  const isDir = stats.isDirectory();
-  const dirObj = this.fsw._getWatchedDir(path$1.dirname(pp));
-  const base = path$1.basename(pp);
+  function declarationOpen(code) {
+    if (code === 45) {
+      effects.consume(code);
+      return commentOpen
+    }
 
-  // ensure empty dirs get tracked
-  if (isDir) this.fsw._getWatchedDir(pp);
-  if (dirObj.has(base)) return;
-  dirObj.add(base);
+    if (code === 91) {
+      effects.consume(code);
+      buffer = 'CDATA[';
+      index = 0;
+      return cdataOpen
+    }
 
-  if (!opts.ignoreInitial || forceAdd === true) {
-    this.fsw._emit(isDir ? EV_ADD_DIR$1 : EV_ADD$1, pp, stats);
+    if (asciiAlpha(code)) {
+      effects.consume(code);
+      return declaration
+    }
+
+    return nok(code)
   }
-}
+  /** @type {State} */
 
-initWatch(realPath, path, wh, processPath) {
-  if (this.fsw.closed) return;
-  const closer = this._watchWithFsEvents(
-    wh.watchPath,
-    path$1.resolve(realPath || wh.watchPath),
-    processPath,
-    wh.globFilter
-  );
-  this.fsw._addPathCloser(path, closer);
-}
+  function commentOpen(code) {
+    if (code === 45) {
+      effects.consume(code);
+      return commentStart
+    }
 
-/**
- * Handle added path with fsevents
- * @param {String} path file/dir path or glob pattern
- * @param {Function|Boolean=} transform converts working path to what the user expects
- * @param {Boolean=} forceAdd ensure add is emitted
- * @param {Number=} priorDepth Level of subdirectories already traversed.
- * @returns {Promise<void>}
- */
-async _addToFsEvents(path, transform, forceAdd, priorDepth) {
-  if (this.fsw.closed) {
-    return;
+    return nok(code)
   }
-  const opts = this.fsw.options;
-  const processPath = typeof transform === FUNCTION_TYPE ? transform : IDENTITY_FN;
+  /** @type {State} */
 
-  const wh = this.fsw._getWatchHelpers(path);
+  function commentStart(code) {
+    if (code === null || code === 62) {
+      return nok(code)
+    }
 
-  // evaluate what is at the path we're being asked to watch
-  try {
-    const stats = await statMethods$1[wh.statMethod](wh.watchPath);
-    if (this.fsw.closed) return;
-    if (this.fsw._isIgnored(wh.watchPath, stats)) {
-      throw null;
+    if (code === 45) {
+      effects.consume(code);
+      return commentStartDash
     }
-    if (stats.isDirectory()) {
-      // emit addDir unless this is a glob parent
-      if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
 
-      // don't recurse further if it would exceed depth setting
-      if (priorDepth && priorDepth > opts.depth) return;
+    return comment(code)
+  }
+  /** @type {State} */
 
-      // scan the contents of the dir
-      this.fsw._readdirp(wh.watchPath, {
-        fileFilter: entry => wh.filterPath(entry),
-        directoryFilter: entry => wh.filterDir(entry),
-        ...Depth(opts.depth - (priorDepth || 0))
-      }).on(STR_DATA$1, (entry) => {
-        // need to check filterPath on dirs b/c filterDir is less restrictive
-        if (this.fsw.closed) {
-          return;
-        }
-        if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
+  function commentStartDash(code) {
+    if (code === null || code === 62) {
+      return nok(code)
+    }
 
-        const joinedPath = path$1.join(wh.watchPath, entry.path);
-        const {fullPath} = entry;
+    return comment(code)
+  }
+  /** @type {State} */
 
-        if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
-          // preserve the current depth here since it can't be derived from
-          // real paths past the symlink
-          const curDepth = opts.depth === undefined ?
-            undefined : calcDepth(joinedPath, path$1.resolve(wh.watchPath)) + 1;
+  function comment(code) {
+    if (code === null) {
+      return nok(code)
+    }
 
-          this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
-        } else {
-          this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
-        }
-      }).on(EV_ERROR$1, EMPTY_FN$1).on(STR_END$1, () => {
-        this.fsw._emitReady();
-      });
-    } else {
-      this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
-      this.fsw._emitReady();
+    if (code === 45) {
+      effects.consume(code);
+      return commentClose
     }
-  } catch (error) {
-    if (!error || this.fsw._handleError(error)) {
-      // TODO: Strange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
-      this.fsw._emitReady();
-      this.fsw._emitReady();
+
+    if (markdownLineEnding(code)) {
+      returnState = comment;
+      return atLineEnding(code)
     }
+
+    effects.consume(code);
+    return comment
   }
+  /** @type {State} */
 
-  if (opts.persistent && forceAdd !== true) {
-    if (typeof transform === FUNCTION_TYPE) {
-      // realpath has already been resolved
-      this.initWatch(undefined, path, wh, processPath);
-    } else {
-      let realPath;
-      try {
-        realPath = await realpath$3(wh.watchPath);
-      } catch (e) {}
-      this.initWatch(realPath, path, wh, processPath);
+  function commentClose(code) {
+    if (code === 45) {
+      effects.consume(code);
+      return end
     }
+
+    return comment(code)
   }
-}
+  /** @type {State} */
 
-}
+  function cdataOpen(code) {
+    if (code === buffer.charCodeAt(index++)) {
+      effects.consume(code);
+      return index === buffer.length ? cdata : cdataOpen
+    }
 
-var fseventsHandler = FsEventsHandler;
-var canUse_1 = canUse;
-fseventsHandler.canUse = canUse_1;
+    return nok(code)
+  }
+  /** @type {State} */
 
-const { EventEmitter } = events;
+  function cdata(code) {
+    if (code === null) {
+      return nok(code)
+    }
 
+    if (code === 93) {
+      effects.consume(code);
+      return cdataClose
+    }
 
-const { promisify: promisify$3 } = util$2;
+    if (markdownLineEnding(code)) {
+      returnState = cdata;
+      return atLineEnding(code)
+    }
 
-const anymatch = anymatch_1.default;
+    effects.consume(code);
+    return cdata
+  }
+  /** @type {State} */
 
+  function cdataClose(code) {
+    if (code === 93) {
+      effects.consume(code);
+      return cdataEnd
+    }
 
+    return cdata(code)
+  }
+  /** @type {State} */
 
+  function cdataEnd(code) {
+    if (code === 62) {
+      return end(code)
+    }
 
+    if (code === 93) {
+      effects.consume(code);
+      return cdataEnd
+    }
 
+    return cdata(code)
+  }
+  /** @type {State} */
 
+  function declaration(code) {
+    if (code === null || code === 62) {
+      return end(code)
+    }
 
-const {
-  EV_ALL,
-  EV_READY,
-  EV_ADD: EV_ADD$2,
-  EV_CHANGE: EV_CHANGE$2,
-  EV_UNLINK: EV_UNLINK$1,
-  EV_ADD_DIR: EV_ADD_DIR$2,
-  EV_UNLINK_DIR,
-  EV_RAW,
-  EV_ERROR: EV_ERROR$2,
+    if (markdownLineEnding(code)) {
+      returnState = declaration;
+      return atLineEnding(code)
+    }
 
-  STR_CLOSE,
-  STR_END: STR_END$2,
+    effects.consume(code);
+    return declaration
+  }
+  /** @type {State} */
 
-  BACK_SLASH_RE,
-  DOUBLE_SLASH_RE,
-  SLASH_OR_BACK_SLASH_RE,
-  DOT_RE,
-  REPLACER_RE,
+  function instruction(code) {
+    if (code === null) {
+      return nok(code)
+    }
 
-  SLASH: SLASH$1,
-  BRACE_START: BRACE_START$1,
-  BANG: BANG$1,
-  ONE_DOT,
-  TWO_DOTS,
-  GLOBSTAR: GLOBSTAR$1,
-  SLASH_GLOBSTAR,
-  ANYMATCH_OPTS,
-  STRING_TYPE,
-  FUNCTION_TYPE: FUNCTION_TYPE$1,
-  EMPTY_STR: EMPTY_STR$1,
-  EMPTY_FN: EMPTY_FN$2,
+    if (code === 63) {
+      effects.consume(code);
+      return instructionClose
+    }
 
-  isWindows: isWindows$2,
-  isMacos
-} = constants$2;
+    if (markdownLineEnding(code)) {
+      returnState = instruction;
+      return atLineEnding(code)
+    }
 
-const stat$5 = promisify$3(fs$1.stat);
-const readdir$2 = promisify$3(fs$1.readdir);
+    effects.consume(code);
+    return instruction
+  }
+  /** @type {State} */
 
-/**
- * @typedef {String} Path
- * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
- * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
- */
+  function instructionClose(code) {
+    return code === 62 ? end(code) : instruction(code)
+  }
+  /** @type {State} */
 
-/**
- *
- * @typedef {Object} WatchHelpers
- * @property {Boolean} followSymlinks
- * @property {'stat'|'lstat'} statMethod
- * @property {Path} path
- * @property {Path} watchPath
- * @property {Function} entryPath
- * @property {Boolean} hasGlob
- * @property {Object} globFilter
- * @property {Function} filterPath
- * @property {Function} filterDir
- */
+  function tagCloseStart(code) {
+    if (asciiAlpha(code)) {
+      effects.consume(code);
+      return tagClose
+    }
 
-const arrify = (value = []) => Array.isArray(value) ? value : [value];
-const flatten = (list, result = []) => {
-  list.forEach(item => {
-    if (Array.isArray(item)) {
-      flatten(item, result);
-    } else {
-      result.push(item);
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function tagClose(code) {
+    if (code === 45 || asciiAlphanumeric(code)) {
+      effects.consume(code);
+      return tagClose
     }
-  });
-  return result;
-};
 
-const unifyPaths = (paths_) => {
-  /**
-   * @type {Array<String>}
-   */
-  const paths = flatten(arrify(paths_));
-  if (!paths.every(p => typeof p === STRING_TYPE)) {
-    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+    return tagCloseBetween(code)
   }
-  return paths.map(normalizePathToUnix);
-};
+  /** @type {State} */
 
-const toUnix = (string) => {
-  let str = string.replace(BACK_SLASH_RE, SLASH$1);
-  while (str.match(DOUBLE_SLASH_RE)) {
-    str = str.replace(DOUBLE_SLASH_RE, SLASH$1);
+  function tagCloseBetween(code) {
+    if (markdownLineEnding(code)) {
+      returnState = tagCloseBetween;
+      return atLineEnding(code)
+    }
+
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return tagCloseBetween
+    }
+
+    return end(code)
   }
-  return str;
-};
+  /** @type {State} */
+
+  function tagOpen(code) {
+    if (code === 45 || asciiAlphanumeric(code)) {
+      effects.consume(code);
+      return tagOpen
+    }
+
+    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
+      return tagOpenBetween(code)
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function tagOpenBetween(code) {
+    if (code === 47) {
+      effects.consume(code);
+      return end
+    }
 
-// Our version of upath.normalize
-// TODO: this is not equal to path-normalize module - investigate why
-const normalizePathToUnix = (path) => toUnix(path$1.normalize(toUnix(path)));
+    if (code === 58 || code === 95 || asciiAlpha(code)) {
+      effects.consume(code);
+      return tagOpenAttributeName
+    }
 
-const normalizeIgnored = (cwd = EMPTY_STR$1) => (path) => {
-  if (typeof path !== STRING_TYPE) return path;
-  return normalizePathToUnix(path$1.isAbsolute(path) ? path : path$1.join(cwd, path));
-};
+    if (markdownLineEnding(code)) {
+      returnState = tagOpenBetween;
+      return atLineEnding(code)
+    }
 
-const getAbsolutePath = (path, cwd) => {
-  if (path$1.isAbsolute(path)) {
-    return path;
-  }
-  if (path.startsWith(BANG$1)) {
-    return BANG$1 + path$1.join(cwd, path.slice(1));
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return tagOpenBetween
+    }
+
+    return end(code)
   }
-  return path$1.join(cwd, path);
-};
+  /** @type {State} */
 
-const undef = (opts, key) => opts[key] === undefined;
+  function tagOpenAttributeName(code) {
+    if (
+      code === 45 ||
+      code === 46 ||
+      code === 58 ||
+      code === 95 ||
+      asciiAlphanumeric(code)
+    ) {
+      effects.consume(code);
+      return tagOpenAttributeName
+    }
 
-/**
- * Directory entry.
- * @property {Path} path
- * @property {Set<Path>} items
- */
-class DirEntry {
-  /**
-   * @param {Path} dir
-   * @param {Function} removeWatcher
-   */
-  constructor(dir, removeWatcher) {
-    this.path = dir;
-    this._removeWatcher = removeWatcher;
-    /** @type {Set<Path>} */
-    this.items = new Set();
+    return tagOpenAttributeNameAfter(code)
   }
+  /** @type {State} */
 
-  add(item) {
-    const {items} = this;
-    if (!items) return;
-    if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
-  }
+  function tagOpenAttributeNameAfter(code) {
+    if (code === 61) {
+      effects.consume(code);
+      return tagOpenAttributeValueBefore
+    }
 
-  async remove(item) {
-    const {items} = this;
-    if (!items) return;
-    items.delete(item);
-    if (items.size > 0) return;
+    if (markdownLineEnding(code)) {
+      returnState = tagOpenAttributeNameAfter;
+      return atLineEnding(code)
+    }
 
-    const dir = this.path;
-    try {
-      await readdir$2(dir);
-    } catch (err) {
-      if (this._removeWatcher) {
-        this._removeWatcher(path$1.dirname(dir), path$1.basename(dir));
-      }
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return tagOpenAttributeNameAfter
     }
-  }
 
-  has(item) {
-    const {items} = this;
-    if (!items) return;
-    return items.has(item);
+    return tagOpenBetween(code)
   }
+  /** @type {State} */
 
-  /**
-   * @returns {Array<String>}
-   */
-  getChildren() {
-    const {items} = this;
-    if (!items) return;
-    return [...items.values()];
-  }
+  function tagOpenAttributeValueBefore(code) {
+    if (
+      code === null ||
+      code === 60 ||
+      code === 61 ||
+      code === 62 ||
+      code === 96
+    ) {
+      return nok(code)
+    }
 
-  dispose() {
-    this.items.clear();
-    delete this.path;
-    delete this._removeWatcher;
-    delete this.items;
-    Object.freeze(this);
-  }
-}
+    if (code === 34 || code === 39) {
+      effects.consume(code);
+      marker = code;
+      return tagOpenAttributeValueQuoted
+    }
 
-const STAT_METHOD_F = 'stat';
-const STAT_METHOD_L = 'lstat';
-class WatchHelper {
-  constructor(path, watchPath, follow, fsw) {
-    this.fsw = fsw;
-    this.path = path = path.replace(REPLACER_RE, EMPTY_STR$1);
-    this.watchPath = watchPath;
-    this.fullWatchPath = path$1.resolve(watchPath);
-    this.hasGlob = watchPath !== path;
-    /** @type {object|boolean} */
-    if (path === EMPTY_STR$1) this.hasGlob = false;
-    this.globSymlink = this.hasGlob && follow ? undefined : false;
-    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
-    this.dirParts = this.getDirParts(path);
-    this.dirParts.forEach((parts) => {
-      if (parts.length > 1) parts.pop();
-    });
-    this.followSymlinks = follow;
-    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+    if (markdownLineEnding(code)) {
+      returnState = tagOpenAttributeValueBefore;
+      return atLineEnding(code)
+    }
+
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return tagOpenAttributeValueBefore
+    }
+
+    effects.consume(code);
+    marker = undefined;
+    return tagOpenAttributeValueUnquoted
   }
+  /** @type {State} */
 
-  checkGlobSymlink(entry) {
-    // only need to resolve once
-    // first entry should always have entry.parentDir === EMPTY_STR
-    if (this.globSymlink === undefined) {
-      this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
-        false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
+  function tagOpenAttributeValueQuoted(code) {
+    if (code === marker) {
+      effects.consume(code);
+      return tagOpenAttributeValueQuotedAfter
     }
 
-    if (this.globSymlink) {
-      return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
+    if (code === null) {
+      return nok(code)
     }
 
-    return entry.fullPath;
+    if (markdownLineEnding(code)) {
+      returnState = tagOpenAttributeValueQuoted;
+      return atLineEnding(code)
+    }
+
+    effects.consume(code);
+    return tagOpenAttributeValueQuoted
   }
+  /** @type {State} */
 
-  entryPath(entry) {
-    return path$1.join(this.watchPath,
-      path$1.relative(this.watchPath, this.checkGlobSymlink(entry))
-    );
+  function tagOpenAttributeValueQuotedAfter(code) {
+    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {
+      return tagOpenBetween(code)
+    }
+
+    return nok(code)
   }
+  /** @type {State} */
 
-  filterPath(entry) {
-    const {stats} = entry;
-    if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
-    const resolvedPath = this.entryPath(entry);
-    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE$1 ?
-      this.globFilter(resolvedPath) : true;
-    return matchesGlob &&
-      this.fsw._isntIgnored(resolvedPath, stats) &&
-      this.fsw._hasReadPermissions(stats);
+  function tagOpenAttributeValueUnquoted(code) {
+    if (
+      code === null ||
+      code === 34 ||
+      code === 39 ||
+      code === 60 ||
+      code === 61 ||
+      code === 96
+    ) {
+      return nok(code)
+    }
+
+    if (code === 62 || markdownLineEndingOrSpace(code)) {
+      return tagOpenBetween(code)
+    }
+
+    effects.consume(code);
+    return tagOpenAttributeValueUnquoted
+  } // We can’t have blank lines in content, so no need to worry about empty
+  // tokens.
+
+  /** @type {State} */
+
+  function atLineEnding(code) {
+    effects.exit('htmlTextData');
+    effects.enter('lineEnding');
+    effects.consume(code);
+    effects.exit('lineEnding');
+    return factorySpace(
+      effects,
+      afterPrefix,
+      'linePrefix',
+      self.parser.constructs.disable.null.includes('codeIndented')
+        ? undefined
+        : 4
+    )
   }
+  /** @type {State} */
 
-  getDirParts(path) {
-    if (!this.hasGlob) return [];
-    const parts = [];
-    const expandedPath = path.includes(BRACE_START$1) ? braces_1.expand(path) : [path];
-    expandedPath.forEach((path) => {
-      parts.push(path$1.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
-    });
-    return parts;
+  function afterPrefix(code) {
+    effects.enter('htmlTextData');
+    return returnState(code)
   }
+  /** @type {State} */
 
-  filterDir(entry) {
-    if (this.hasGlob) {
-      const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
-      let globstar = false;
-      this.unmatchedGlob = !this.dirParts.some((parts) => {
-        return parts.every((part, i) => {
-          if (part === GLOBSTAR$1) globstar = true;
-          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
-        });
-      });
+  function end(code) {
+    if (code === 62) {
+      effects.consume(code);
+      effects.exit('htmlTextData');
+      effects.exit('htmlText');
+      return ok
     }
-    return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+
+    return nok(code)
   }
 }
 
 /**
- * Watches files & directories for changes. Emitted events:
- * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
- *
- *     new FSWatcher()
- *       .add(directories)
- *       .on('add', path => log('File', path, 'was added'))
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
  */
-class FSWatcher extends EventEmitter {
-// Not indenting methods for history sake; for now.
-constructor(_opts) {
-  super();
 
-  const opts = {};
-  if (_opts) Object.assign(opts, _opts); // for frozen objects
+/** @type {Construct} */
+const labelEnd = {
+  name: 'labelEnd',
+  tokenize: tokenizeLabelEnd,
+  resolveTo: resolveToLabelEnd,
+  resolveAll: resolveAllLabelEnd
+};
+/** @type {Construct} */
 
-  /** @type {Map<String, DirEntry>} */
-  this._watched = new Map();
-  /** @type {Map<String, Array>} */
-  this._closers = new Map();
-  /** @type {Set<String>} */
-  this._ignoredPaths = new Set();
+const resourceConstruct = {
+  tokenize: tokenizeResource
+};
+/** @type {Construct} */
 
-  /** @type {Map<ThrottleType, Map>} */
-  this._throttled = new Map();
+const fullReferenceConstruct = {
+  tokenize: tokenizeFullReference
+};
+/** @type {Construct} */
 
-  /** @type {Map<Path, String|Boolean>} */
-  this._symlinkPaths = new Map();
+const collapsedReferenceConstruct = {
+  tokenize: tokenizeCollapsedReference
+};
+/** @type {Resolver} */
 
-  this._streams = new Set();
-  this.closed = false;
+function resolveAllLabelEnd(events) {
+  let index = -1;
+  /** @type {Token} */
 
-  // Set up default options.
-  if (undef(opts, 'persistent')) opts.persistent = true;
-  if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
-  if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
-  if (undef(opts, 'interval')) opts.interval = 100;
-  if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
-  if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
-  opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
+  let token;
 
-  // Enable fsevents on OS X when polling isn't explicitly enabled.
-  if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
+  while (++index < events.length) {
+    token = events[index][1];
 
-  // If we can't use fsevents, ensure the options reflect it's disabled.
-  const canUseFsEvents = fseventsHandler.canUse();
-  if (!canUseFsEvents) opts.useFsEvents = false;
+    if (
+      token.type === 'labelImage' ||
+      token.type === 'labelLink' ||
+      token.type === 'labelEnd'
+    ) {
+      // Remove the marker.
+      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);
+      token.type = 'data';
+      index++;
+    }
+  }
 
-  // Use polling on Mac if not using fsevents.
-  // Other platforms use non-polling fs_watch.
-  if (undef(opts, 'usePolling') && !opts.useFsEvents) {
-    opts.usePolling = isMacos;
+  return events
+}
+/** @type {Resolver} */
+
+function resolveToLabelEnd(events, context) {
+  let index = events.length;
+  let offset = 0;
+  /** @type {Token} */
+
+  let token;
+  /** @type {number|undefined} */
+
+  let open;
+  /** @type {number|undefined} */
+
+  let close;
+  /** @type {Event[]} */
+
+  let media; // Find an opening.
+
+  while (index--) {
+    token = events[index][1];
+
+    if (open) {
+      // If we see another link, or inactive link label, we’ve been here before.
+      if (
+        token.type === 'link' ||
+        (token.type === 'labelLink' && token._inactive)
+      ) {
+        break
+      } // Mark other link openings as inactive, as we can’t have links in
+      // links.
+
+      if (events[index][0] === 'enter' && token.type === 'labelLink') {
+        token._inactive = true;
+      }
+    } else if (close) {
+      if (
+        events[index][0] === 'enter' &&
+        (token.type === 'labelImage' || token.type === 'labelLink') &&
+        !token._balanced
+      ) {
+        open = index;
+
+        if (token.type !== 'labelLink') {
+          offset = 2;
+          break
+        }
+      }
+    } else if (token.type === 'labelEnd') {
+      close = index;
+    }
   }
 
-  // Global override (useful for end-developers that need to force polling for all
-  // instances of chokidar, regardless of usage/dependency depth)
-  const envPoll = process.env.CHOKIDAR_USEPOLLING;
-  if (envPoll !== undefined) {
-    const envLower = envPoll.toLowerCase();
+  const group = {
+    type: events[open][1].type === 'labelLink' ? 'link' : 'image',
+    start: Object.assign({}, events[open][1].start),
+    end: Object.assign({}, events[events.length - 1][1].end)
+  };
+  const label = {
+    type: 'label',
+    start: Object.assign({}, events[open][1].start),
+    end: Object.assign({}, events[close][1].end)
+  };
+  const text = {
+    type: 'labelText',
+    start: Object.assign({}, events[open + offset + 2][1].end),
+    end: Object.assign({}, events[close - 2][1].start)
+  };
+  media = [
+    ['enter', group, context],
+    ['enter', label, context]
+  ]; // Opening marker.
 
-    if (envLower === 'false' || envLower === '0') {
-      opts.usePolling = false;
-    } else if (envLower === 'true' || envLower === '1') {
-      opts.usePolling = true;
-    } else {
-      opts.usePolling = !!envLower;
+  media = push(media, events.slice(open + 1, open + offset + 3)); // Text open.
+
+  media = push(media, [['enter', text, context]]); // Between.
+
+  media = push(
+    media,
+    resolveAll(
+      context.parser.constructs.insideSpan.null,
+      events.slice(open + offset + 4, close - 3),
+      context
+    )
+  ); // Text close, marker close, label close.
+
+  media = push(media, [
+    ['exit', text, context],
+    events[close - 2],
+    events[close - 1],
+    ['exit', label, context]
+  ]); // Reference, resource, or so.
+
+  media = push(media, events.slice(close + 1)); // Media close.
+
+  media = push(media, [['exit', group, context]]);
+  splice(events, open, events.length, media);
+  return events
+}
+/** @type {Tokenizer} */
+
+function tokenizeLabelEnd(effects, ok, nok) {
+  const self = this;
+  let index = self.events.length;
+  /** @type {Token} */
+
+  let labelStart;
+  /** @type {boolean} */
+
+  let defined; // Find an opening.
+
+  while (index--) {
+    if (
+      (self.events[index][1].type === 'labelImage' ||
+        self.events[index][1].type === 'labelLink') &&
+      !self.events[index][1]._balanced
+    ) {
+      labelStart = self.events[index][1];
+      break
     }
   }
-  const envInterval = process.env.CHOKIDAR_INTERVAL;
-  if (envInterval) {
-    opts.interval = Number.parseInt(envInterval, 10);
+
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    if (!labelStart) {
+      return nok(code)
+    } // It’s a balanced bracket, but contains a link.
+
+    if (labelStart._inactive) return balanced(code)
+    defined = self.parser.defined.includes(
+      normalizeIdentifier(
+        self.sliceSerialize({
+          start: labelStart.end,
+          end: self.now()
+        })
+      )
+    );
+    effects.enter('labelEnd');
+    effects.enter('labelMarker');
+    effects.consume(code);
+    effects.exit('labelMarker');
+    effects.exit('labelEnd');
+    return afterLabelEnd
   }
+  /** @type {State} */
 
-  // Editor atomic write normalization enabled by default with fs.watch
-  if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
-  if (opts.atomic) this._pendingUnlinks = new Map();
+  function afterLabelEnd(code) {
+    // Resource: `[asd](fgh)`.
+    if (code === 40) {
+      return effects.attempt(
+        resourceConstruct,
+        ok,
+        defined ? ok : balanced
+      )(code)
+    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?
+
+    if (code === 91) {
+      return effects.attempt(
+        fullReferenceConstruct,
+        ok,
+        defined
+          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)
+          : balanced
+      )(code)
+    } // Shortcut reference: `[asd]`?
+
+    return defined ? ok(code) : balanced(code)
+  }
+  /** @type {State} */
+
+  function balanced(code) {
+    labelStart._balanced = true;
+    return nok(code)
+  }
+}
+/** @type {Tokenizer} */
+
+function tokenizeResource(effects, ok, nok) {
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('resource');
+    effects.enter('resourceMarker');
+    effects.consume(code);
+    effects.exit('resourceMarker');
+    return factoryWhitespace(effects, open)
+  }
+  /** @type {State} */
+
+  function open(code) {
+    if (code === 41) {
+      return end(code)
+    }
+
+    return factoryDestination(
+      effects,
+      destinationAfter,
+      nok,
+      'resourceDestination',
+      'resourceDestinationLiteral',
+      'resourceDestinationLiteralMarker',
+      'resourceDestinationRaw',
+      'resourceDestinationString',
+      3
+    )(code)
+  }
+  /** @type {State} */
+
+  function destinationAfter(code) {
+    return markdownLineEndingOrSpace(code)
+      ? factoryWhitespace(effects, between)(code)
+      : end(code)
+  }
+  /** @type {State} */
+
+  function between(code) {
+    if (code === 34 || code === 39 || code === 40) {
+      return factoryTitle(
+        effects,
+        factoryWhitespace(effects, end),
+        nok,
+        'resourceTitle',
+        'resourceTitleMarker',
+        'resourceTitleString'
+      )(code)
+    }
+
+    return end(code)
+  }
+  /** @type {State} */
+
+  function end(code) {
+    if (code === 41) {
+      effects.enter('resourceMarker');
+      effects.consume(code);
+      effects.exit('resourceMarker');
+      effects.exit('resource');
+      return ok
+    }
+
+    return nok(code)
+  }
+}
+/** @type {Tokenizer} */
+
+function tokenizeFullReference(effects, ok, nok) {
+  const self = this;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    return factoryLabel.call(
+      self,
+      effects,
+      afterLabel,
+      nok,
+      'reference',
+      'referenceMarker',
+      'referenceString'
+    )(code)
+  }
+  /** @type {State} */
 
-  if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;
+  function afterLabel(code) {
+    return self.parser.defined.includes(
+      normalizeIdentifier(
+        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
+      )
+    )
+      ? ok(code)
+      : nok(code)
+  }
+}
+/** @type {Tokenizer} */
 
-  if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
-  if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
-  const awf = opts.awaitWriteFinish;
-  if (awf) {
-    if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
-    if (!awf.pollInterval) awf.pollInterval = 100;
-    this._pendingWrites = new Map();
+function tokenizeCollapsedReference(effects, ok, nok) {
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('reference');
+    effects.enter('referenceMarker');
+    effects.consume(code);
+    effects.exit('referenceMarker');
+    return open
   }
-  if (opts.ignored) opts.ignored = arrify(opts.ignored);
+  /** @type {State} */
 
-  let readyCalls = 0;
-  this._emitReady = () => {
-    readyCalls++;
-    if (readyCalls >= this._readyCount) {
-      this._emitReady = EMPTY_FN$2;
-      this._readyEmitted = true;
-      // use process.nextTick to allow time for listener to be bound
-      process.nextTick(() => this.emit(EV_READY));
+  function open(code) {
+    if (code === 93) {
+      effects.enter('referenceMarker');
+      effects.consume(code);
+      effects.exit('referenceMarker');
+      effects.exit('reference');
+      return ok
     }
-  };
-  this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
-  this._readyEmitted = false;
-  this.options = opts;
 
-  // Initialize with proper watcher.
-  if (opts.useFsEvents) {
-    this._fsEventsHandler = new fseventsHandler(this);
-  } else {
-    this._nodeFsHandler = new nodefsHandler(this);
+    return nok(code)
   }
-
-  // You’re frozen when your heart’s not open.
-  Object.freeze(opts);
 }
 
-// Public methods
-
 /**
- * Adds paths to be watched on an existing FSWatcher instance
- * @param {Path|Array<Path>} paths_
- * @param {String=} _origAdd private; for handling non-existent paths to be watched
- * @param {Boolean=} _internal private; indicates a non-user add
- * @returns {FSWatcher} for chaining
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
  */
-add(paths_, _origAdd, _internal) {
-  const {cwd, disableGlobbing} = this.options;
-  this.closed = false;
-  let paths = unifyPaths(paths_);
-  if (cwd) {
-    paths = paths.map((path) => {
-      const absPath = getAbsolutePath(path, cwd);
+/** @type {Construct} */
 
-      // Check `path` instead of `absPath` because the cwd portion can't be a glob
-      if (disableGlobbing || !isGlob(path)) {
-        return absPath;
-      }
-      return normalizePath(absPath);
-    });
+const labelStartImage = {
+  name: 'labelStartImage',
+  tokenize: tokenizeLabelStartImage,
+  resolveAll: labelEnd.resolveAll
+};
+/** @type {Tokenizer} */
+
+function tokenizeLabelStartImage(effects, ok, nok) {
+  const self = this;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('labelImage');
+    effects.enter('labelImageMarker');
+    effects.consume(code);
+    effects.exit('labelImageMarker');
+    return open
   }
+  /** @type {State} */
 
-  // set aside negated glob strings
-  paths = paths.filter((path) => {
-    if (path.startsWith(BANG$1)) {
-      this._ignoredPaths.add(path.slice(1));
-      return false;
+  function open(code) {
+    if (code === 91) {
+      effects.enter('labelMarker');
+      effects.consume(code);
+      effects.exit('labelMarker');
+      effects.exit('labelImage');
+      return after
     }
 
-    // if a path is being added that was previously ignored, stop ignoring it
-    this._ignoredPaths.delete(path);
-    this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
-
-    // reset the cached userIgnored anymatch fn
-    // to make ignoredPaths changes effective
-    this._userIgnored = undefined;
+    return nok(code)
+  }
+  /** @type {State} */
 
-    return true;
-  });
+  function after(code) {
+    /* Hidden footnotes hook */
 
-  if (this.options.useFsEvents && this._fsEventsHandler) {
-    if (!this._readyCount) this._readyCount = paths.length;
-    if (this.options.persistent) this._readyCount *= 2;
-    paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
-  } else {
-    if (!this._readyCount) this._readyCount = 0;
-    this._readyCount += paths.length;
-    Promise.all(
-      paths.map(async path => {
-        const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
-        if (res) this._emitReady();
-        return res;
-      })
-    ).then(results => {
-      if (this.closed) return;
-      results.filter(item => item).forEach(item => {
-        this.add(path$1.dirname(item), path$1.basename(_origAdd || item));
-      });
-    });
+    /* c8 ignore next 3 */
+    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs
+      ? nok(code)
+      : ok(code)
   }
-
-  return this;
 }
 
 /**
- * Close watchers or start ignoring events from specified paths.
- * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
- * @returns {FSWatcher} for chaining
-*/
-unwatch(paths_) {
-  if (this.closed) return this;
-  const paths = unifyPaths(paths_);
-  const {cwd} = this.options;
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
+/** @type {Construct} */
 
-  paths.forEach((path) => {
-    // convert to absolute path unless relative path already matches
-    if (!path$1.isAbsolute(path) && !this._closers.has(path)) {
-      if (cwd) path = path$1.join(cwd, path);
-      path = path$1.resolve(path);
-    }
+const labelStartLink = {
+  name: 'labelStartLink',
+  tokenize: tokenizeLabelStartLink,
+  resolveAll: labelEnd.resolveAll
+};
+/** @type {Tokenizer} */
 
-    this._closePath(path);
+function tokenizeLabelStartLink(effects, ok, nok) {
+  const self = this;
+  return start
+  /** @type {State} */
 
-    this._ignoredPaths.add(path);
-    if (this._watched.has(path)) {
-      this._ignoredPaths.add(path + SLASH_GLOBSTAR);
-    }
+  function start(code) {
+    effects.enter('labelLink');
+    effects.enter('labelMarker');
+    effects.consume(code);
+    effects.exit('labelMarker');
+    effects.exit('labelLink');
+    return after
+  }
+  /** @type {State} */
 
-    // reset the cached userIgnored anymatch fn
-    // to make ignoredPaths changes effective
-    this._userIgnored = undefined;
-  });
+  function after(code) {
+    /* Hidden footnotes hook. */
 
-  return this;
+    /* c8 ignore next 3 */
+    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs
+      ? nok(code)
+      : ok(code)
+  }
 }
 
 /**
- * Close watchers and remove all listeners from watched paths.
- * @returns {Promise<void>}.
-*/
-close() {
-  if (this.closed) return this._closePromise;
-  this.closed = true;
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
 
-  // Memory management.
-  this.removeAllListeners();
-  const closers = [];
-  this._closers.forEach(closerList => closerList.forEach(closer => {
-    const promise = closer();
-    if (promise instanceof Promise) closers.push(promise);
-  }));
-  this._streams.forEach(stream => stream.destroy());
-  this._userIgnored = undefined;
-  this._readyCount = 0;
-  this._readyEmitted = false;
-  this._watched.forEach(dirent => dirent.dispose());
-  ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
-    this[`_${key}`].clear();
-  });
+/** @type {Construct} */
+const lineEnding = {
+  name: 'lineEnding',
+  tokenize: tokenizeLineEnding
+};
+/** @type {Tokenizer} */
 
-  this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
-  return this._closePromise;
+function tokenizeLineEnding(effects, ok) {
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('lineEnding');
+    effects.consume(code);
+    effects.exit('lineEnding');
+    return factorySpace(effects, ok, 'linePrefix')
+  }
 }
 
 /**
- * Expose list of watched paths
- * @returns {Object} for chaining
-*/
-getWatched() {
-  const watchList = {};
-  this._watched.forEach((entry, dir) => {
-    const key = this.options.cwd ? path$1.relative(this.options.cwd, dir) : dir;
-    watchList[key || ONE_DOT] = entry.getChildren().sort();
-  });
-  return watchList;
-}
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
 
-emitWithAll(event, args) {
-  this.emit(...args);
-  if (event !== EV_ERROR$2) this.emit(EV_ALL, ...args);
+/** @type {Construct} */
+const thematicBreak$1 = {
+  name: 'thematicBreak',
+  tokenize: tokenizeThematicBreak
+};
+/** @type {Tokenizer} */
+
+function tokenizeThematicBreak(effects, ok, nok) {
+  let size = 0;
+  /** @type {NonNullable<Code>} */
+
+  let marker;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    effects.enter('thematicBreak');
+    marker = code;
+    return atBreak(code)
+  }
+  /** @type {State} */
+
+  function atBreak(code) {
+    if (code === marker) {
+      effects.enter('thematicBreakSequence');
+      return sequence(code)
+    }
+
+    if (markdownSpace(code)) {
+      return factorySpace(effects, atBreak, 'whitespace')(code)
+    }
+
+    if (size < 3 || (code !== null && !markdownLineEnding(code))) {
+      return nok(code)
+    }
+
+    effects.exit('thematicBreak');
+    return ok(code)
+  }
+  /** @type {State} */
+
+  function sequence(code) {
+    if (code === marker) {
+      effects.consume(code);
+      size++;
+      return sequence
+    }
+
+    effects.exit('thematicBreakSequence');
+    return atBreak(code)
+  }
 }
 
-// Common helpers
-// --------------
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Exiter} Exiter
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+/** @type {Construct} */
+
+const list$1 = {
+  name: 'list',
+  tokenize: tokenizeListStart,
+  continuation: {
+    tokenize: tokenizeListContinuation
+  },
+  exit: tokenizeListEnd
+};
+/** @type {Construct} */
+
+const listItemPrefixWhitespaceConstruct = {
+  tokenize: tokenizeListItemPrefixWhitespace,
+  partial: true
+};
+/** @type {Construct} */
 
+const indentConstruct = {
+  tokenize: tokenizeIndent,
+  partial: true
+};
 /**
- * Normalize and emit events.
- * Calling _emit DOES NOT MEAN emit() would be called!
- * @param {EventName} event Type of event
- * @param {Path} path File or directory path
- * @param {*=} val1 arguments to be passed with event
- * @param {*=} val2
- * @param {*=} val3
- * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+ * @type {Tokenizer}
+ * @this {TokenizeContextWithState}
  */
-async _emit(event, path, val1, val2, val3) {
-  if (this.closed) return;
 
-  const opts = this.options;
-  if (isWindows$2) path = path$1.normalize(path);
-  if (opts.cwd) path = path$1.relative(opts.cwd, path);
-  /** @type Array<any> */
-  const args = [event, path];
-  if (val3 !== undefined) args.push(val1, val2, val3);
-  else if (val2 !== undefined) args.push(val1, val2);
-  else if (val1 !== undefined) args.push(val1);
+function tokenizeListStart(effects, ok, nok) {
+  const self = this;
+  const tail = self.events[self.events.length - 1];
+  let initialSize =
+    tail && tail[1].type === 'linePrefix'
+      ? tail[2].sliceSerialize(tail[1], true).length
+      : 0;
+  let size = 0;
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    const kind =
+      self.containerState.type ||
+      (code === 42 || code === 43 || code === 45
+        ? 'listUnordered'
+        : 'listOrdered');
 
-  const awf = opts.awaitWriteFinish;
-  let pw;
-  if (awf && (pw = this._pendingWrites.get(path))) {
-    pw.lastChange = new Date();
-    return this;
+    if (
+      kind === 'listUnordered'
+        ? !self.containerState.marker || code === self.containerState.marker
+        : asciiDigit(code)
+    ) {
+      if (!self.containerState.type) {
+        self.containerState.type = kind;
+        effects.enter(kind, {
+          _container: true
+        });
+      }
+
+      if (kind === 'listUnordered') {
+        effects.enter('listItemPrefix');
+        return code === 42 || code === 45
+          ? effects.check(thematicBreak$1, nok, atMarker)(code)
+          : atMarker(code)
+      }
+
+      if (!self.interrupt || code === 49) {
+        effects.enter('listItemPrefix');
+        effects.enter('listItemValue');
+        return inside(code)
+      }
+    }
+
+    return nok(code)
   }
+  /** @type {State} */
 
-  if (opts.atomic) {
-    if (event === EV_UNLINK$1) {
-      this._pendingUnlinks.set(path, args);
-      setTimeout(() => {
-        this._pendingUnlinks.forEach((entry, path) => {
-          this.emit(...entry);
-          this.emit(EV_ALL, ...entry);
-          this._pendingUnlinks.delete(path);
-        });
-      }, typeof opts.atomic === 'number' ? opts.atomic : 100);
-      return this;
+  function inside(code) {
+    if (asciiDigit(code) && ++size < 10) {
+      effects.consume(code);
+      return inside
     }
-    if (event === EV_ADD$2 && this._pendingUnlinks.has(path)) {
-      event = args[0] = EV_CHANGE$2;
-      this._pendingUnlinks.delete(path);
+
+    if (
+      (!self.interrupt || size < 2) &&
+      (self.containerState.marker
+        ? code === self.containerState.marker
+        : code === 41 || code === 46)
+    ) {
+      effects.exit('listItemValue');
+      return atMarker(code)
     }
+
+    return nok(code)
+  }
+  /**
+   * @type {State}
+   **/
+
+  function atMarker(code) {
+    effects.enter('listItemMarker');
+    effects.consume(code);
+    effects.exit('listItemMarker');
+    self.containerState.marker = self.containerState.marker || code;
+    return effects.check(
+      blankLine, // Can’t be empty when interrupting.
+      self.interrupt ? nok : onBlank,
+      effects.attempt(
+        listItemPrefixWhitespaceConstruct,
+        endOfPrefix,
+        otherPrefix
+      )
+    )
   }
+  /** @type {State} */
 
-  if (awf && (event === EV_ADD$2 || event === EV_CHANGE$2) && this._readyEmitted) {
-    const awfEmit = (err, stats) => {
-      if (err) {
-        event = args[0] = EV_ERROR$2;
-        args[1] = err;
-        this.emitWithAll(event, args);
-      } else if (stats) {
-        // if stats doesn't exist the file must have been deleted
-        if (args.length > 2) {
-          args[2] = stats;
-        } else {
-          args.push(stats);
-        }
-        this.emitWithAll(event, args);
-      }
-    };
+  function onBlank(code) {
+    self.containerState.initialBlankLine = true;
+    initialSize++;
+    return endOfPrefix(code)
+  }
+  /** @type {State} */
 
-    this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
-    return this;
+  function otherPrefix(code) {
+    if (markdownSpace(code)) {
+      effects.enter('listItemPrefixWhitespace');
+      effects.consume(code);
+      effects.exit('listItemPrefixWhitespace');
+      return endOfPrefix
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function endOfPrefix(code) {
+    self.containerState.size =
+      initialSize +
+      self.sliceSerialize(effects.exit('listItemPrefix'), true).length;
+    return ok(code)
   }
+}
+/**
+ * @type {Tokenizer}
+ * @this {TokenizeContextWithState}
+ */
+
+function tokenizeListContinuation(effects, ok, nok) {
+  const self = this;
+  self.containerState._closeFlow = undefined;
+  return effects.check(blankLine, onBlank, notBlank)
+  /** @type {State} */
 
-  if (event === EV_CHANGE$2) {
-    const isThrottled = !this._throttle(EV_CHANGE$2, path, 50);
-    if (isThrottled) return this;
+  function onBlank(code) {
+    self.containerState.furtherBlankLines =
+      self.containerState.furtherBlankLines ||
+      self.containerState.initialBlankLine; // We have a blank line.
+    // Still, try to consume at most the items size.
+
+    return factorySpace(
+      effects,
+      ok,
+      'listItemIndent',
+      self.containerState.size + 1
+    )(code)
   }
+  /** @type {State} */
 
-  if (opts.alwaysStat && val1 === undefined &&
-    (event === EV_ADD$2 || event === EV_ADD_DIR$2 || event === EV_CHANGE$2)
-  ) {
-    const fullPath = opts.cwd ? path$1.join(opts.cwd, path) : path;
-    let stats;
-    try {
-      stats = await stat$5(fullPath);
-    } catch (err) {}
-    // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
-    if (!stats || this.closed) return;
-    args.push(stats);
+  function notBlank(code) {
+    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {
+      self.containerState.furtherBlankLines = undefined;
+      self.containerState.initialBlankLine = undefined;
+      return notInCurrentItem(code)
+    }
+
+    self.containerState.furtherBlankLines = undefined;
+    self.containerState.initialBlankLine = undefined;
+    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)
   }
-  this.emitWithAll(event, args);
+  /** @type {State} */
 
-  return this;
-}
+  function notInCurrentItem(code) {
+    // While we do continue, we signal that the flow should be closed.
+    self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting.
 
-/**
- * Common handler for errors
- * @param {Error} error
- * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
- */
-_handleError(error) {
-  const code = error && error.code;
-  if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
-    (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
-  ) {
-    this.emit(EV_ERROR$2, error);
+    self.interrupt = undefined;
+    return factorySpace(
+      effects,
+      effects.attempt(list$1, ok, nok),
+      'linePrefix',
+      self.parser.constructs.disable.null.includes('codeIndented')
+        ? undefined
+        : 4
+    )(code)
   }
-  return error || this.closed;
 }
-
 /**
- * Helper utility for throttling
- * @param {ThrottleType} actionType type being throttled
- * @param {Path} path being acted upon
- * @param {Number} timeout duration of time to suppress duplicate actions
- * @returns {Object|false} tracking object or false if action should be suppressed
+ * @type {Tokenizer}
+ * @this {TokenizeContextWithState}
  */
-_throttle(actionType, path, timeout) {
-  if (!this._throttled.has(actionType)) {
-    this._throttled.set(actionType, new Map());
-  }
 
-  /** @type {Map<Path, Object>} */
-  const action = this._throttled.get(actionType);
-  /** @type {Object} */
-  const actionPath = action.get(path);
+function tokenizeIndent(effects, ok, nok) {
+  const self = this;
+  return factorySpace(
+    effects,
+    afterPrefix,
+    'listItemIndent',
+    self.containerState.size + 1
+  )
+  /** @type {State} */
 
-  if (actionPath) {
-    actionPath.count++;
-    return false;
+  function afterPrefix(code) {
+    const tail = self.events[self.events.length - 1];
+    return tail &&
+      tail[1].type === 'listItemIndent' &&
+      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size
+      ? ok(code)
+      : nok(code)
   }
+}
+/**
+ * @type {Exiter}
+ * @this {TokenizeContextWithState}
+ */
 
-  let timeoutObject;
-  const clear = () => {
-    const item = action.get(path);
-    const count = item ? item.count : 0;
-    action.delete(path);
-    clearTimeout(timeoutObject);
-    if (item) clearTimeout(item.timeoutObject);
-    return count;
-  };
-  timeoutObject = setTimeout(clear, timeout);
-  const thr = {timeoutObject, clear, count: 0};
-  action.set(path, thr);
-  return thr;
+function tokenizeListEnd(effects) {
+  effects.exit(this.containerState.type);
 }
+/**
+ * @type {Tokenizer}
+ * @this {TokenizeContextWithState}
+ */
 
-_incrReadyCount() {
-  return this._readyCount++;
+function tokenizeListItemPrefixWhitespace(effects, ok, nok) {
+  const self = this;
+  return factorySpace(
+    effects,
+    afterPrefix,
+    'listItemPrefixWhitespace',
+    self.parser.constructs.disable.null.includes('codeIndented')
+      ? undefined
+      : 4 + 1
+  )
+  /** @type {State} */
+
+  function afterPrefix(code) {
+    const tail = self.events[self.events.length - 1];
+    return !markdownSpace(code) &&
+      tail &&
+      tail[1].type === 'listItemPrefixWhitespace'
+      ? ok(code)
+      : nok(code)
+  }
 }
 
 /**
- * Awaits write operation to finish.
- * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
- * @param {Path} path being acted upon
- * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
- * @param {EventName} event
- * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
  */
-_awaitWriteFinish(path, threshold, event, awfEmit) {
-  let timeoutHandler;
 
-  let fullPath = path;
-  if (this.options.cwd && !path$1.isAbsolute(path)) {
-    fullPath = path$1.join(this.options.cwd, path);
-  }
+/** @type {Construct} */
+const setextUnderline = {
+  name: 'setextUnderline',
+  tokenize: tokenizeSetextUnderline,
+  resolveTo: resolveToSetextUnderline
+};
+/** @type {Resolver} */
 
-  const now = new Date();
+function resolveToSetextUnderline(events, context) {
+  let index = events.length;
+  /** @type {number|undefined} */
 
-  const awaitWriteFinish = (prevStat) => {
-    fs$1.stat(fullPath, (err, curStat) => {
-      if (err || !this._pendingWrites.has(path)) {
-        if (err && err.code !== 'ENOENT') awfEmit(err);
-        return;
-      }
+  let content;
+  /** @type {number|undefined} */
 
-      const now = Number(new Date());
+  let text;
+  /** @type {number|undefined} */
 
-      if (prevStat && curStat.size !== prevStat.size) {
-        this._pendingWrites.get(path).lastChange = now;
+  let definition; // Find the opening of the content.
+  // It’ll always exist: we don’t tokenize if it isn’t there.
+
+  while (index--) {
+    if (events[index][0] === 'enter') {
+      if (events[index][1].type === 'content') {
+        content = index;
+        break
       }
-      const pw = this._pendingWrites.get(path);
-      const df = now - pw.lastChange;
 
-      if (df >= threshold) {
-        this._pendingWrites.delete(path);
-        awfEmit(undefined, curStat);
-      } else {
-        timeoutHandler = setTimeout(
-          awaitWriteFinish,
-          this.options.awaitWriteFinish.pollInterval,
-          curStat
-        );
+      if (events[index][1].type === 'paragraph') {
+        text = index;
+      }
+    } // Exit
+    else {
+      if (events[index][1].type === 'content') {
+        // Remove the content end (if needed we’ll add it later)
+        events.splice(index, 1);
       }
-    });
-  };
 
-  if (!this._pendingWrites.has(path)) {
-    this._pendingWrites.set(path, {
-      lastChange: now,
-      cancelWait: () => {
-        this._pendingWrites.delete(path);
-        clearTimeout(timeoutHandler);
-        return event;
+      if (!definition && events[index][1].type === 'definition') {
+        definition = index;
       }
-    });
-    timeoutHandler = setTimeout(
-      awaitWriteFinish,
-      this.options.awaitWriteFinish.pollInterval
-    );
+    }
   }
+
+  const heading = {
+    type: 'setextHeading',
+    start: Object.assign({}, events[text][1].start),
+    end: Object.assign({}, events[events.length - 1][1].end)
+  }; // Change the paragraph to setext heading text.
+
+  events[text][1].type = 'setextHeadingText'; // If we have definitions in the content, we’ll keep on having content,
+  // but we need move it.
+
+  if (definition) {
+    events.splice(text, 0, ['enter', heading, context]);
+    events.splice(definition + 1, 0, ['exit', events[content][1], context]);
+    events[content][1].end = Object.assign({}, events[definition][1].end);
+  } else {
+    events[content][1] = heading;
+  } // Add the heading exit at the end.
+
+  events.push(['exit', heading, context]);
+  return events
 }
+/** @type {Tokenizer} */
 
-_getGlobIgnored() {
-  return [...this._ignoredPaths.values()];
+function tokenizeSetextUnderline(effects, ok, nok) {
+  const self = this;
+  let index = self.events.length;
+  /** @type {NonNullable<Code>} */
+
+  let marker;
+  /** @type {boolean} */
+
+  let paragraph; // Find an opening.
+
+  while (index--) {
+    // Skip enter/exit of line ending, line prefix, and content.
+    // We can now either have a definition or a paragraph.
+    if (
+      self.events[index][1].type !== 'lineEnding' &&
+      self.events[index][1].type !== 'linePrefix' &&
+      self.events[index][1].type !== 'content'
+    ) {
+      paragraph = self.events[index][1].type === 'paragraph';
+      break
+    }
+  }
+
+  return start
+  /** @type {State} */
+
+  function start(code) {
+    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {
+      effects.enter('setextHeadingLine');
+      effects.enter('setextHeadingLineSequence');
+      marker = code;
+      return closingSequence(code)
+    }
+
+    return nok(code)
+  }
+  /** @type {State} */
+
+  function closingSequence(code) {
+    if (code === marker) {
+      effects.consume(code);
+      return closingSequence
+    }
+
+    effects.exit('setextHeadingLineSequence');
+    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)
+  }
+  /** @type {State} */
+
+  function closingSequenceEnd(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit('setextHeadingLine');
+      return ok(code)
+    }
+
+    return nok(code)
+  }
 }
 
 /**
- * Determines whether user has asked to ignore this path.
- * @param {Path} path filepath or dir
- * @param {fs.Stats=} stats result of fs.stat
- * @returns {Boolean}
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').Initializer} Initializer
+ * @typedef {import('micromark-util-types').State} State
  */
-_isIgnored(path, stats) {
-  if (this.options.atomic && DOT_RE.test(path)) return true;
-  if (!this._userIgnored) {
-    const {cwd} = this.options;
-    const ign = this.options.ignored;
 
-    const ignored = ign && ign.map(normalizeIgnored(cwd));
-    const paths = arrify(ignored)
-      .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
-      .map((path) => path + SLASH_GLOBSTAR);
-    const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
-    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
+/** @type {InitialConstruct} */
+const flow$1 = {
+  tokenize: initializeFlow
+};
+/** @type {Initializer} */
+
+function initializeFlow(effects) {
+  const self = this;
+  const initial = effects.attempt(
+    // Try to parse a blank line.
+    blankLine,
+    atBlankEnding, // Try to parse initial flow (essentially, only code).
+    effects.attempt(
+      this.parser.constructs.flowInitial,
+      afterConstruct,
+      factorySpace(
+        effects,
+        effects.attempt(
+          this.parser.constructs.flow,
+          afterConstruct,
+          effects.attempt(content, afterConstruct)
+        ),
+        'linePrefix'
+      )
+    )
+  );
+  return initial
+  /** @type {State} */
+
+  function atBlankEnding(code) {
+    if (code === null) {
+      effects.consume(code);
+      return
+    }
+
+    effects.enter('lineEndingBlank');
+    effects.consume(code);
+    effects.exit('lineEndingBlank');
+    self.currentConstruct = undefined;
+    return initial
   }
+  /** @type {State} */
 
-  return this._userIgnored([path, stats]);
-}
+  function afterConstruct(code) {
+    if (code === null) {
+      effects.consume(code);
+      return
+    }
 
-_isntIgnored(path, stat) {
-  return !this._isIgnored(path, stat);
+    effects.enter('lineEnding');
+    effects.consume(code);
+    effects.exit('lineEnding');
+    self.currentConstruct = undefined;
+    return initial
+  }
 }
 
 /**
- * Provides a set of common helpers and properties relating to symlink and glob handling.
- * @param {Path} path file, directory, or glob pattern being watched
- * @param {Number=} depth at any depth > 0, this isn't a glob
- * @returns {WatchHelper} object containing helpers for this path
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Initializer} Initializer
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+const resolver = {
+  resolveAll: createResolver()
+};
+const string$1 = initializeFactory('string');
+const text$3 = initializeFactory('text');
+/**
+ * @param {'string'|'text'} field
+ * @returns {InitialConstruct}
  */
-_getWatchHelpers(path, depth) {
-  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
-  const follow = this.options.followSymlinks;
 
-  return new WatchHelper(path, watchPath, follow, this);
-}
+function initializeFactory(field) {
+  return {
+    tokenize: initializeText,
+    resolveAll: createResolver(
+      field === 'text' ? resolveAllLineSuffixes : undefined
+    )
+  }
+  /** @type {Initializer} */
 
-// Directory helpers
-// -----------------
+  function initializeText(effects) {
+    const self = this;
+    const constructs = this.parser.constructs[field];
+    const text = effects.attempt(constructs, start, notText);
+    return start
+    /** @type {State} */
+
+    function start(code) {
+      return atBreak(code) ? text(code) : notText(code)
+    }
+    /** @type {State} */
+
+    function notText(code) {
+      if (code === null) {
+        effects.consume(code);
+        return
+      }
+
+      effects.enter('data');
+      effects.consume(code);
+      return data
+    }
+    /** @type {State} */
+
+    function data(code) {
+      if (atBreak(code)) {
+        effects.exit('data');
+        return text(code)
+      } // Data.
+
+      effects.consume(code);
+      return data
+    }
+    /**
+     * @param {Code} code
+     * @returns {boolean}
+     */
+
+    function atBreak(code) {
+      if (code === null) {
+        return true
+      }
+
+      const list = constructs[code];
+      let index = -1;
+
+      if (list) {
+        while (++index < list.length) {
+          const item = list[index];
+
+          if (!item.previous || item.previous.call(self, self.previous)) {
+            return true
+          }
+        }
+      }
 
+      return false
+    }
+  }
+}
 /**
- * Provides directory tracking objects
- * @param {String} directory path of the directory
- * @returns {DirEntry} the directory's tracking object
+ * @param {Resolver} [extraResolver]
+ * @returns {Resolver}
  */
-_getWatchedDir(directory) {
-  if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
-  const dir = path$1.resolve(directory);
-  if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
-  return this._watched.get(dir);
-}
 
-// File helpers
-// ------------
+function createResolver(extraResolver) {
+  return resolveAllText
+  /** @type {Resolver} */
 
-/**
- * Check for read permissions.
- * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
- * @param {fs.Stats} stats - object, result of fs_stat
- * @returns {Boolean} indicates whether the file can be read
-*/
-_hasReadPermissions(stats) {
-  if (this.options.ignorePermissionErrors) return true;
+  function resolveAllText(events, context) {
+    let index = -1;
+    /** @type {number|undefined} */
 
-  // stats.mode may be bigint
-  const md = stats && Number.parseInt(stats.mode, 10);
-  const st = md & 0o777;
-  const it = Number.parseInt(st.toString(8)[0], 10);
-  return Boolean(4 & it);
-}
+    let enter; // A rather boring computation (to merge adjacent `data` events) which
+    // improves mm performance by 29%.
 
-/**
- * Handles emitting unlink events for
- * files and directories, and via recursion, for
- * files and directories within directories that are unlinked
- * @param {String} directory within which the following item is located
- * @param {String} item      base path of item/directory
- * @returns {void}
-*/
-_remove(directory, item, isDirectory) {
-  // if what is being deleted is a directory, get that directory's paths
-  // for recursive deleting and cleaning of watched object
-  // if it is not a directory, nestedDirectoryChildren will be empty array
-  const path = path$1.join(directory, item);
-  const fullPath = path$1.resolve(path);
-  isDirectory = isDirectory != null
-    ? isDirectory
-    : this._watched.has(path) || this._watched.has(fullPath);
+    while (++index <= events.length) {
+      if (enter === undefined) {
+        if (events[index] && events[index][1].type === 'data') {
+          enter = index;
+          index++;
+        }
+      } else if (!events[index] || events[index][1].type !== 'data') {
+        // Don’t do anything if there is one data token.
+        if (index !== enter + 2) {
+          events[enter][1].end = events[index - 1][1].end;
+          events.splice(enter + 2, index - enter - 2);
+          index = enter + 2;
+        }
 
-  // prevent duplicate handling in case of arriving here nearly simultaneously
-  // via multiple paths (such as _handleFile and _handleDir)
-  if (!this._throttle('remove', path, 100)) return;
+        enter = undefined;
+      }
+    }
 
-  // if the only watched file is removed, watch for its return
-  if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
-    this.add(directory, item, true);
+    return extraResolver ? extraResolver(events, context) : events
   }
+}
+/**
+ * A rather ugly set of instructions which again looks at chunks in the input
+ * stream.
+ * The reason to do this here is that it is *much* faster to parse in reverse.
+ * And that we can’t hook into `null` to split the line suffix before an EOF.
+ * To do: figure out if we can make this into a clean utility, or even in core.
+ * As it will be useful for GFMs literal autolink extension (and maybe even
+ * tables?)
+ *
+ * @type {Resolver}
+ */
 
-  // This will create a new entry in the watched object in either case
-  // so we got to do the directory check beforehand
-  const wp = this._getWatchedDir(path);
-  const nestedDirectoryChildren = wp.getChildren();
+function resolveAllLineSuffixes(events, context) {
+  let eventIndex = -1;
 
-  // Recursively remove children directories / files.
-  nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
+  while (++eventIndex <= events.length) {
+    if (
+      (eventIndex === events.length ||
+        events[eventIndex][1].type === 'lineEnding') &&
+      events[eventIndex - 1][1].type === 'data'
+    ) {
+      const data = events[eventIndex - 1][1];
+      const chunks = context.sliceStream(data);
+      let index = chunks.length;
+      let bufferIndex = -1;
+      let size = 0;
+      /** @type {boolean|undefined} */
 
-  // Check if item was on the watched list and remove it
-  const parent = this._getWatchedDir(directory);
-  const wasTracked = parent.has(item);
-  parent.remove(item);
+      let tabs;
 
-  // If we wait for this file to be fully written, cancel the wait.
-  let relPath = path;
-  if (this.options.cwd) relPath = path$1.relative(this.options.cwd, path);
-  if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
-    const event = this._pendingWrites.get(relPath).cancelWait();
-    if (event === EV_ADD$2) return;
-  }
+      while (index--) {
+        const chunk = chunks[index];
 
-  // The Entry will either be a directory that just got removed
-  // or a bogus entry to a file, in either case we have to remove it
-  this._watched.delete(path);
-  this._watched.delete(fullPath);
-  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK$1;
-  if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+        if (typeof chunk === 'string') {
+          bufferIndex = chunk.length;
 
-  // Avoid conflicts if we later create another file with the same name
-  if (!this.options.useFsEvents) {
-    this._closePath(path);
+          while (chunk.charCodeAt(bufferIndex - 1) === 32) {
+            size++;
+            bufferIndex--;
+          }
+
+          if (bufferIndex) break
+          bufferIndex = -1;
+        } // Number
+        else if (chunk === -2) {
+          tabs = true;
+          size++;
+        } else if (chunk === -1) ; else {
+          // Replacement character, exit.
+          index++;
+          break
+        }
+      }
+
+      if (size) {
+        const token = {
+          type:
+            eventIndex === events.length || tabs || size < 2
+              ? 'lineSuffix'
+              : 'hardBreakTrailing',
+          start: {
+            line: data.end.line,
+            column: data.end.column - size,
+            offset: data.end.offset - size,
+            _index: data.start._index + index,
+            _bufferIndex: index
+              ? bufferIndex
+              : data.start._bufferIndex + bufferIndex
+          },
+          end: Object.assign({}, data.end)
+        };
+        data.end = Object.assign({}, token.start);
+
+        if (data.start.offset === data.end.offset) {
+          Object.assign(data, token);
+        } else {
+          events.splice(
+            eventIndex,
+            0,
+            ['enter', token, context],
+            ['exit', token, context]
+          );
+          eventIndex += 2;
+        }
+      }
+
+      eventIndex++;
+    }
   }
+
+  return events
 }
 
 /**
- *
- * @param {Path} path
+ * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').Chunk} Chunk
+ * @typedef {import('micromark-util-types').Point} Point
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').ParseContext} ParseContext
  */
-_closePath(path) {
-  const closers = this._closers.get(path);
-  if (!closers) return;
-  closers.forEach(closer => closer());
-  this._closers.delete(path);
-  const dir = path$1.dirname(path);
-  this._getWatchedDir(dir).remove(path$1.basename(path));
-}
 
 /**
+ * Create a tokenizer.
+ * Tokenizers deal with one type of data (e.g., containers, flow, text).
+ * The parser is the object dealing with it all.
+ * `initialize` works like other constructs, except that only its `tokenize`
+ * function is used, in which case it doesn’t receive an `ok` or `nok`.
+ * `from` can be given to set the point before the first character, although
+ * when further lines are indented, they must be set with `defineSkip`.
  *
- * @param {Path} path
- * @param {Function} closer
+ * @param {ParseContext} parser
+ * @param {InitialConstruct} initialize
+ * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]
+ * @returns {TokenizeContext}
  */
-_addPathCloser(path, closer) {
-  if (!closer) return;
-  let list = this._closers.get(path);
-  if (!list) {
-    list = [];
-    this._closers.set(path, list);
+function createTokenizer(parser, initialize, from) {
+  /** @type {Point} */
+  let point = Object.assign(
+    from
+      ? Object.assign({}, from)
+      : {
+          line: 1,
+          column: 1,
+          offset: 0
+        },
+    {
+      _index: 0,
+      _bufferIndex: -1
+    }
+  );
+  /** @type {Record<string, number>} */
+
+  const columnStart = {};
+  /** @type {Construct[]} */
+
+  const resolveAllConstructs = [];
+  /** @type {Chunk[]} */
+
+  let chunks = [];
+  /** @type {Token[]} */
+
+  let stack = [];
+  /**
+   * Tools used for tokenizing.
+   *
+   * @type {Effects}
+   */
+
+  const effects = {
+    consume,
+    enter,
+    exit,
+    attempt: constructFactory(onsuccessfulconstruct),
+    check: constructFactory(onsuccessfulcheck),
+    interrupt: constructFactory(onsuccessfulcheck, {
+      interrupt: true
+    })
+  };
+  /**
+   * State and tools for resolving and serializing.
+   *
+   * @type {TokenizeContext}
+   */
+
+  const context = {
+    previous: null,
+    code: null,
+    containerState: {},
+    events: [],
+    parser,
+    sliceStream,
+    sliceSerialize,
+    now,
+    defineSkip,
+    write
+  };
+  /**
+   * The state function.
+   *
+   * @type {State|void}
+   */
+
+  let state = initialize.tokenize.call(context, effects);
+
+  if (initialize.resolveAll) {
+    resolveAllConstructs.push(initialize);
   }
-  list.push(closer);
-}
 
-_readdirp(root, opts) {
-  if (this.closed) return;
-  const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
-  let stream = readdirp_1(root, options);
-  this._streams.add(stream);
-  stream.once(STR_CLOSE, () => {
-    stream = undefined;
-  });
-  stream.once(STR_END$2, () => {
-    if (stream) {
-      this._streams.delete(stream);
-      stream = undefined;
+  return context
+  /** @type {TokenizeContext['write']} */
+
+  function write(slice) {
+    chunks = push(chunks, slice);
+    main(); // Exit if we’re not done, resolve might change stuff.
+
+    if (chunks[chunks.length - 1] !== null) {
+      return []
     }
-  });
-  return stream;
-}
 
-}
+    addResult(initialize, 0); // Otherwise, resolve, and exit.
 
-// Export FSWatcher class
-var FSWatcher_1 = FSWatcher;
+    context.events = resolveAll(resolveAllConstructs, context.events, context);
+    return context.events
+  } //
+  // Tools.
+  //
 
-/**
- * Instantiates watcher with paths to be tracked.
- * @param {String|Array<String>} paths file/directory paths and/or globs
- * @param {Object=} options chokidar opts
- * @returns an instance of FSWatcher for chaining.
- */
-const watch = (paths, options) => {
-  const watcher = new FSWatcher(options);
-  watcher.add(paths);
-  return watcher;
-};
+  /** @type {TokenizeContext['sliceSerialize']} */
 
-var watch_1 = watch;
+  function sliceSerialize(token, expandTabs) {
+    return serializeChunks(sliceStream(token), expandTabs)
+  }
+  /** @type {TokenizeContext['sliceStream']} */
 
-var chokidar = {
-	FSWatcher: FSWatcher_1,
-	watch: watch_1
-};
+  function sliceStream(token) {
+    return sliceChunks(chunks, token)
+  }
+  /** @type {TokenizeContext['now']} */
 
-var textTable = function (rows_, opts) {
-    if (!opts) opts = {};
-    var hsep = opts.hsep === undefined ? '  ' : opts.hsep;
-    var align = opts.align || [];
-    var stringLength = opts.stringLength
-        || function (s) { return String(s).length; }
-    ;
-    
-    var dotsizes = reduce(rows_, function (acc, row) {
-        forEach(row, function (c, ix) {
-            var n = dotindex(c);
-            if (!acc[ix] || n > acc[ix]) acc[ix] = n;
-        });
-        return acc;
-    }, []);
-    
-    var rows = map$1(rows_, function (row) {
-        return map$1(row, function (c_, ix) {
-            var c = String(c_);
-            if (align[ix] === '.') {
-                var index = dotindex(c);
-                var size = dotsizes[ix] + (/\./.test(c) ? 1 : 2)
-                    - (stringLength(c) - index)
-                ;
-                return c + Array(size).join(' ');
-            }
-            else return c;
-        });
-    });
-    
-    var sizes = reduce(rows, function (acc, row) {
-        forEach(row, function (c, ix) {
-            var n = stringLength(c);
-            if (!acc[ix] || n > acc[ix]) acc[ix] = n;
-        });
-        return acc;
-    }, []);
-    
-    return map$1(rows, function (row) {
-        return map$1(row, function (c, ix) {
-            var n = (sizes[ix] - stringLength(c)) || 0;
-            var s = Array(Math.max(n + 1, 1)).join(' ');
-            if (align[ix] === 'r' || align[ix] === '.') {
-                return s + c;
-            }
-            if (align[ix] === 'c') {
-                return Array(Math.ceil(n / 2 + 1)).join(' ')
-                    + c + Array(Math.floor(n / 2 + 1)).join(' ')
-                ;
-            }
-            
-            return c + s;
-        }).join(hsep).replace(/\s+$/, '');
-    }).join('\n');
-};
+  function now() {
+    return Object.assign({}, point)
+  }
+  /** @type {TokenizeContext['defineSkip']} */
+
+  function defineSkip(value) {
+    columnStart[value.line] = value.column;
+    accountForPotentialSkip();
+  } //
+  // State management.
+  //
+
+  /**
+   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by
+   * `consume`).
+   * Here is where we walk through the chunks, which either include strings of
+   * several characters, or numerical character codes.
+   * The reason to do this in a loop instead of a call is so the stack can
+   * drain.
+   *
+   * @returns {void}
+   */
+
+  function main() {
+    /** @type {number} */
+    let chunkIndex;
+
+    while (point._index < chunks.length) {
+      const chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.
+
+      if (typeof chunk === 'string') {
+        chunkIndex = point._index;
+
+        if (point._bufferIndex < 0) {
+          point._bufferIndex = 0;
+        }
+
+        while (
+          point._index === chunkIndex &&
+          point._bufferIndex < chunk.length
+        ) {
+          go(chunk.charCodeAt(point._bufferIndex));
+        }
+      } else {
+        go(chunk);
+      }
+    }
+  }
+  /**
+   * Deal with one code.
+   *
+   * @param {Code} code
+   * @returns {void}
+   */
+
+  function go(code) {
+    state = state(code);
+  }
+  /** @type {Effects['consume']} */
+
+  function consume(code) {
+    if (markdownLineEnding(code)) {
+      point.line++;
+      point.column = 1;
+      point.offset += code === -3 ? 2 : 1;
+      accountForPotentialSkip();
+    } else if (code !== -1) {
+      point.column++;
+      point.offset++;
+    } // Not in a string chunk.
+
+    if (point._bufferIndex < 0) {
+      point._index++;
+    } else {
+      point._bufferIndex++; // At end of string chunk.
+      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference
+      // strings.
+
+      if (point._bufferIndex === chunks[point._index].length) {
+        point._bufferIndex = -1;
+        point._index++;
+      }
+    } // Expose the previous character.
+
+    context.previous = code; // Mark as consumed.
+  }
+  /** @type {Effects['enter']} */
+
+  function enter(type, fields) {
+    /** @type {Token} */
+    // @ts-expect-error Patch instead of assign required fields to help GC.
+    const token = fields || {};
+    token.type = type;
+    token.start = now();
+    context.events.push(['enter', token, context]);
+    stack.push(token);
+    return token
+  }
+  /** @type {Effects['exit']} */
+
+  function exit(type) {
+    const token = stack.pop();
+    token.end = now();
+    context.events.push(['exit', token, context]);
+    return token
+  }
+  /**
+   * Use results.
+   *
+   * @type {ReturnHandle}
+   */
+
+  function onsuccessfulconstruct(construct, info) {
+    addResult(construct, info.from);
+  }
+  /**
+   * Discard results.
+   *
+   * @type {ReturnHandle}
+   */
+
+  function onsuccessfulcheck(_, info) {
+    info.restore();
+  }
+  /**
+   * Factory to attempt/check/interrupt.
+   *
+   * @param {ReturnHandle} onreturn
+   * @param {Record<string, unknown>} [fields]
+   */
+
+  function constructFactory(onreturn, fields) {
+    return hook
+    /**
+     * Handle either an object mapping codes to constructs, a list of
+     * constructs, or a single construct.
+     *
+     * @param {Construct|Construct[]|ConstructRecord} constructs
+     * @param {State} returnState
+     * @param {State} [bogusState]
+     * @returns {State}
+     */
+
+    function hook(constructs, returnState, bogusState) {
+      /** @type {Construct[]} */
+      let listOfConstructs;
+      /** @type {number} */
+
+      let constructIndex;
+      /** @type {Construct} */
+
+      let currentConstruct;
+      /** @type {Info} */
+
+      let info;
+      return Array.isArray(constructs)
+        ? /* c8 ignore next 1 */
+          handleListOfConstructs(constructs)
+        : 'tokenize' in constructs // @ts-expect-error Looks like a construct.
+        ? handleListOfConstructs([constructs])
+        : handleMapOfConstructs(constructs)
+      /**
+       * Handle a list of construct.
+       *
+       * @param {ConstructRecord} map
+       * @returns {State}
+       */
+
+      function handleMapOfConstructs(map) {
+        return start
+        /** @type {State} */
+
+        function start(code) {
+          const def = code !== null && map[code];
+          const all = code !== null && map.null;
+          const list = [
+            // To do: add more extension tests.
+
+            /* c8 ignore next 2 */
+            ...(Array.isArray(def) ? def : def ? [def] : []),
+            ...(Array.isArray(all) ? all : all ? [all] : [])
+          ];
+          return handleListOfConstructs(list)(code)
+        }
+      }
+      /**
+       * Handle a list of construct.
+       *
+       * @param {Construct[]} list
+       * @returns {State}
+       */
+
+      function handleListOfConstructs(list) {
+        listOfConstructs = list;
+        constructIndex = 0;
+
+        if (list.length === 0) {
+          return bogusState
+        }
+
+        return handleConstruct(list[constructIndex])
+      }
+      /**
+       * Handle a single construct.
+       *
+       * @param {Construct} construct
+       * @returns {State}
+       */
+
+      function handleConstruct(construct) {
+        return start
+        /** @type {State} */
+
+        function start(code) {
+          // To do: not needed to store if there is no bogus state, probably?
+          // Currently doesn’t work because `inspect` in document does a check
+          // w/o a bogus, which doesn’t make sense. But it does seem to help perf
+          // by not storing.
+          info = store();
+          currentConstruct = construct;
+
+          if (!construct.partial) {
+            context.currentConstruct = construct;
+          }
+
+          if (
+            construct.name &&
+            context.parser.constructs.disable.null.includes(construct.name)
+          ) {
+            return nok()
+          }
+
+          return construct.tokenize.call(
+            // If we do have fields, create an object w/ `context` as its
+            // prototype.
+            // This allows a “live binding”, which is needed for `interrupt`.
+            fields ? Object.assign(Object.create(context), fields) : context,
+            effects,
+            ok,
+            nok
+          )(code)
+        }
+      }
+      /** @type {State} */
+
+      function ok(code) {
+        onreturn(currentConstruct, info);
+        return returnState
+      }
+      /** @type {State} */
+
+      function nok(code) {
+        info.restore();
+
+        if (++constructIndex < listOfConstructs.length) {
+          return handleConstruct(listOfConstructs[constructIndex])
+        }
+
+        return bogusState
+      }
+    }
+  }
+  /**
+   * @param {Construct} construct
+   * @param {number} from
+   * @returns {void}
+   */
+
+  function addResult(construct, from) {
+    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
+      resolveAllConstructs.push(construct);
+    }
 
-function dotindex (c) {
-    var m = /\.[^.]*$/.exec(c);
-    return m ? m.index + 1 : c.length;
-}
+    if (construct.resolve) {
+      splice(
+        context.events,
+        from,
+        context.events.length - from,
+        construct.resolve(context.events.slice(from), context)
+      );
+    }
 
-function reduce (xs, f, init) {
-    if (xs.reduce) return xs.reduce(f, init);
-    var i = 0;
-    var acc = arguments.length >= 3 ? init : xs[i++];
-    for (; i < xs.length; i++) {
-        f(acc, xs[i], i);
+    if (construct.resolveTo) {
+      context.events = construct.resolveTo(context.events, context);
     }
-    return acc;
-}
+  }
+  /**
+   * Store state.
+   *
+   * @returns {Info}
+   */
 
-function forEach (xs, f) {
-    if (xs.forEach) return xs.forEach(f);
-    for (var i = 0; i < xs.length; i++) {
-        f.call(xs, xs[i], i);
+  function store() {
+    const startPoint = now();
+    const startPrevious = context.previous;
+    const startCurrentConstruct = context.currentConstruct;
+    const startEventsIndex = context.events.length;
+    const startStack = Array.from(stack);
+    return {
+      restore,
+      from: startEventsIndex
+    }
+    /**
+     * Restore state.
+     *
+     * @returns {void}
+     */
+
+    function restore() {
+      point = startPoint;
+      context.previous = startPrevious;
+      context.currentConstruct = startCurrentConstruct;
+      context.events.length = startEventsIndex;
+      stack = startStack;
+      accountForPotentialSkip();
+    }
+  }
+  /**
+   * Move the current point a bit forward in the line when it’s on a column
+   * skip.
+   *
+   * @returns {void}
+   */
+
+  function accountForPotentialSkip() {
+    if (point.line in columnStart && point.column < 2) {
+      point.column = columnStart[point.line];
+      point.offset += columnStart[point.line] - 1;
     }
+  }
 }
+/**
+ * Get the chunks from a slice of chunks in the range of a token.
+ *
+ * @param {Chunk[]} chunks
+ * @param {Pick<Token, 'start'|'end'>} token
+ * @returns {Chunk[]}
+ */
 
-function map$1 (xs, f) {
-    if (xs.map) return xs.map(f);
-    var res = [];
-    for (var i = 0; i < xs.length; i++) {
-        res.push(f.call(xs, xs[i], i));
+function sliceChunks(chunks, token) {
+  const startIndex = token.start._index;
+  const startBufferIndex = token.start._bufferIndex;
+  const endIndex = token.end._index;
+  const endBufferIndex = token.end._bufferIndex;
+  /** @type {Chunk[]} */
+
+  let view;
+
+  if (startIndex === endIndex) {
+    // @ts-expect-error `_bufferIndex` is used on string chunks.
+    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
+  } else {
+    view = chunks.slice(startIndex, endIndex);
+
+    if (startBufferIndex > -1) {
+      // @ts-expect-error `_bufferIndex` is used on string chunks.
+      view[0] = view[0].slice(startBufferIndex);
     }
-    return res;
+
+    if (endBufferIndex > 0) {
+      // @ts-expect-error `_bufferIndex` is used on string chunks.
+      view.push(chunks[endIndex].slice(0, endBufferIndex));
+    }
+  }
+
+  return view
 }
+/**
+ * Get the string value of a slice of chunks.
+ *
+ * @param {Chunk[]} chunks
+ * @param {boolean} [expandTabs=false]
+ * @returns {string}
+ */
 
-const preserveCamelCase = string => {
-	let isLastCharLower = false;
-	let isLastCharUpper = false;
-	let isLastLastCharUpper = false;
+function serializeChunks(chunks, expandTabs) {
+  let index = -1;
+  /** @type {string[]} */
 
-	for (let i = 0; i < string.length; i++) {
-		const character = string[i];
+  const result = [];
+  /** @type {boolean|undefined} */
 
-		if (isLastCharLower && /[a-zA-Z]/.test(character) && character.toUpperCase() === character) {
-			string = string.slice(0, i) + '-' + string.slice(i);
-			isLastCharLower = false;
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper = true;
-			i++;
-		} else if (isLastCharUpper && isLastLastCharUpper && /[a-zA-Z]/.test(character) && character.toLowerCase() === character) {
-			string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper = false;
-			isLastCharLower = true;
-		} else {
-			isLastCharLower = character.toLowerCase() === character && character.toUpperCase() !== character;
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper = character.toUpperCase() === character && character.toLowerCase() !== character;
-		}
-	}
+  let atTab;
 
-	return string;
-};
+  while (++index < chunks.length) {
+    const chunk = chunks[index];
+    /** @type {string} */
 
-const camelCase = (input, options) => {
-	if (!(typeof input === 'string' || Array.isArray(input))) {
-		throw new TypeError('Expected the input to be `string | string[]`');
-	}
+    let value;
 
-	options = Object.assign({
-		pascalCase: false
-	}, options);
+    if (typeof chunk === 'string') {
+      value = chunk;
+    } else
+      switch (chunk) {
+        case -5: {
+          value = '\r';
+          break
+        }
 
-	const postProcess = x => options.pascalCase ? x.charAt(0).toUpperCase() + x.slice(1) : x;
+        case -4: {
+          value = '\n';
+          break
+        }
 
-	if (Array.isArray(input)) {
-		input = input.map(x => x.trim())
-			.filter(x => x.length)
-			.join('-');
-	} else {
-		input = input.trim();
-	}
+        case -3: {
+          value = '\r' + '\n';
+          break
+        }
 
-	if (input.length === 0) {
-		return '';
-	}
+        case -2: {
+          value = expandTabs ? ' ' : '\t';
+          break
+        }
 
-	if (input.length === 1) {
-		return options.pascalCase ? input.toUpperCase() : input.toLowerCase();
-	}
+        case -1: {
+          if (!expandTabs && atTab) continue
+          value = ' ';
+          break
+        }
 
-	const hasUpperCase = input !== input.toLowerCase();
+        default: {
+          // Currently only replacement character.
+          value = String.fromCharCode(chunk);
+        }
+      }
 
-	if (hasUpperCase) {
-		input = preserveCamelCase(input);
-	}
+    atTab = chunk === -2;
+    result.push(value);
+  }
 
-	input = input
-		.replace(/^[_.\- ]+/, '')
-		.toLowerCase()
-		.replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase())
-		.replace(/\d+(\w|$)/g, m => m.toUpperCase());
+  return result.join('')
+}
 
-	return postProcess(input);
-};
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ */
+/** @type {Extension['document']} */
+
+const document$1 = {
+  [42]: list$1,
+  [43]: list$1,
+  [45]: list$1,
+  [48]: list$1,
+  [49]: list$1,
+  [50]: list$1,
+  [51]: list$1,
+  [52]: list$1,
+  [53]: list$1,
+  [54]: list$1,
+  [55]: list$1,
+  [56]: list$1,
+  [57]: list$1,
+  [62]: blockQuote
+};
+/** @type {Extension['contentInitial']} */
+
+const contentInitial = {
+  [91]: definition$1
+};
+/** @type {Extension['flowInitial']} */
+
+const flowInitial = {
+  [-2]: codeIndented,
+  [-1]: codeIndented,
+  [32]: codeIndented
+};
+/** @type {Extension['flow']} */
+
+const flow = {
+  [35]: headingAtx,
+  [42]: thematicBreak$1,
+  [45]: [setextUnderline, thematicBreak$1],
+  [60]: htmlFlow,
+  [61]: setextUnderline,
+  [95]: thematicBreak$1,
+  [96]: codeFenced,
+  [126]: codeFenced
+};
+/** @type {Extension['string']} */
+
+const string = {
+  [38]: characterReference$1,
+  [92]: characterEscape$1
+};
+/** @type {Extension['text']} */
+
+const text$2 = {
+  [-5]: lineEnding,
+  [-4]: lineEnding,
+  [-3]: lineEnding,
+  [33]: labelStartImage,
+  [38]: characterReference$1,
+  [42]: attention,
+  [60]: [autolink, htmlText],
+  [91]: labelStartLink,
+  [92]: [hardBreakEscape, characterEscape$1],
+  [93]: labelEnd,
+  [95]: attention,
+  [96]: codeText
+};
+/** @type {Extension['insideSpan']} */
+
+const insideSpan = {
+  null: [attention, resolver]
+};
+/** @type {Extension['disable']} */
+
+const disable = {
+  null: []
+};
+
+var defaultConstructs = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	document: document$1,
+	contentInitial: contentInitial,
+	flowInitial: flowInitial,
+	flow: flow,
+	string: string,
+	text: text$2,
+	insideSpan: insideSpan,
+	disable: disable
+});
 
-var camelcase = camelCase;
-// TODO: Remove this for the next major release
-var default_1$4 = camelCase;
-camelcase.default = default_1$4;
+/**
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension
+ * @typedef {import('micromark-util-types').ParseOptions} ParseOptions
+ * @typedef {import('micromark-util-types').ParseContext} ParseContext
+ * @typedef {import('micromark-util-types').Create} Create
+ */
+/**
+ * @param {ParseOptions} [options]
+ * @returns {ParseContext}
+ */
 
-var minimist = function (args, opts) {
-    if (!opts) opts = {};
+function parse(options = {}) {
+  /** @type {FullNormalizedExtension} */
+  // @ts-expect-error `defaultConstructs` is full, so the result will be too.
+  const constructs = combineExtensions(
+    // @ts-expect-error Same as above.
+    [defaultConstructs].concat(options.extensions || [])
+  );
+  /** @type {ParseContext} */
+
+  const parser = {
+    defined: [],
+    lazy: {},
+    constructs,
+    content: create(content$1),
+    document: create(document$2),
+    flow: create(flow$1),
+    string: create(string$1),
+    text: create(text$3)
+  };
+  return parser
+  /**
+   * @param {InitialConstruct} initial
+   */
 
-    var flags = { bools : {}, strings : {}, unknownFn: null };
+  function create(initial) {
+    return creator
+    /** @type {Create} */
 
-    if (typeof opts['unknown'] === 'function') {
-        flags.unknownFn = opts['unknown'];
+    function creator(from) {
+      return createTokenizer(parser, initial, from)
     }
+  }
+}
 
-    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
-      flags.allBools = true;
-    } else {
-      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
-          flags.bools[key] = true;
-      });
-    }
+/**
+ * @typedef {import('micromark-util-types').Encoding} Encoding
+ * @typedef {import('micromark-util-types').Value} Value
+ * @typedef {import('micromark-util-types').Chunk} Chunk
+ * @typedef {import('micromark-util-types').Code} Code
+ */
 
-    var aliases = {};
-    Object.keys(opts.alias || {}).forEach(function (key) {
-        aliases[key] = [].concat(opts.alias[key]);
-        aliases[key].forEach(function (x) {
-            aliases[x] = [key].concat(aliases[key].filter(function (y) {
-                return x !== y;
-            }));
-        });
-    });
+/**
+ * @callback Preprocessor
+ * @param {Value} value
+ * @param {Encoding} [encoding]
+ * @param {boolean} [end=false]
+ * @returns {Chunk[]}
+ */
+const search = /[\0\t\n\r]/g;
+/**
+ * @returns {Preprocessor}
+ */
 
-    [].concat(opts.string).filter(Boolean).forEach(function (key) {
-        flags.strings[key] = true;
-        if (aliases[key]) {
-            flags.strings[aliases[key]] = true;
-        }
-     });
+function preprocess() {
+  let column = 1;
+  let buffer = '';
+  /** @type {boolean|undefined} */
 
-    var defaults = opts['default'] || {};
+  let start = true;
+  /** @type {boolean|undefined} */
 
-    var argv = { _ : [] };
-    Object.keys(flags.bools).forEach(function (key) {
-        setArg(key, defaults[key] === undefined ? false : defaults[key]);
-    });
+  let atCarriageReturn;
+  return preprocessor
+  /** @type {Preprocessor} */
 
-    var notFlags = [];
+  function preprocessor(value, encoding, end) {
+    /** @type {Chunk[]} */
+    const chunks = [];
+    /** @type {RegExpMatchArray|null} */
 
-    if (args.indexOf('--') !== -1) {
-        notFlags = args.slice(args.indexOf('--')+1);
-        args = args.slice(0, args.indexOf('--'));
-    }
+    let match;
+    /** @type {number} */
 
-    function argDefined(key, arg) {
-        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
-            flags.strings[key] || flags.bools[key] || aliases[key];
-    }
+    let next;
+    /** @type {number} */
 
-    function setArg (key, val, arg) {
-        if (arg && flags.unknownFn && !argDefined(key, arg)) {
-            if (flags.unknownFn(arg) === false) return;
-        }
+    let startPosition;
+    /** @type {number} */
 
-        var value = !flags.strings[key] && isNumber$2(val)
-            ? Number(val) : val
-        ;
-        setKey(argv, key.split('.'), value);
+    let endPosition;
+    /** @type {Code} */
 
-        (aliases[key] || []).forEach(function (x) {
-            setKey(argv, x.split('.'), value);
-        });
+    let code; // @ts-expect-error `Buffer` does allow an encoding.
+
+    value = buffer + value.toString(encoding);
+    startPosition = 0;
+    buffer = '';
+
+    if (start) {
+      if (value.charCodeAt(0) === 65279) {
+        startPosition++;
+      }
+
+      start = undefined;
     }
 
-    function setKey (obj, keys, value) {
-        var o = obj;
-        for (var i = 0; i < keys.length-1; i++) {
-            var key = keys[i];
-            if (key === '__proto__') return;
-            if (o[key] === undefined) o[key] = {};
-            if (o[key] === Object.prototype || o[key] === Number.prototype
-                || o[key] === String.prototype) o[key] = {};
-            if (o[key] === Array.prototype) o[key] = [];
-            o = o[key];
-        }
+    while (startPosition < value.length) {
+      search.lastIndex = startPosition;
+      match = search.exec(value);
+      endPosition =
+        match && match.index !== undefined ? match.index : value.length;
+      code = value.charCodeAt(endPosition);
 
-        var key = keys[keys.length - 1];
-        if (key === '__proto__') return;
-        if (o === Object.prototype || o === Number.prototype
-            || o === String.prototype) o = {};
-        if (o === Array.prototype) o = [];
-        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
-            o[key] = value;
+      if (!match) {
+        buffer = value.slice(startPosition);
+        break
+      }
+
+      if (code === 10 && startPosition === endPosition && atCarriageReturn) {
+        chunks.push(-3);
+        atCarriageReturn = undefined;
+      } else {
+        if (atCarriageReturn) {
+          chunks.push(-5);
+          atCarriageReturn = undefined;
         }
-        else if (Array.isArray(o[key])) {
-            o[key].push(value);
+
+        if (startPosition < endPosition) {
+          chunks.push(value.slice(startPosition, endPosition));
+          column += endPosition - startPosition;
         }
-        else {
-            o[key] = [ o[key], value ];
+
+        switch (code) {
+          case 0: {
+            chunks.push(65533);
+            column++;
+            break
+          }
+
+          case 9: {
+            next = Math.ceil(column / 4) * 4;
+            chunks.push(-2);
+
+            while (column++ < next) chunks.push(-1);
+
+            break
+          }
+
+          case 10: {
+            chunks.push(-4);
+            column = 1;
+            break
+          }
+
+          default: {
+            atCarriageReturn = true;
+            column = 1;
+          }
         }
+      }
+
+      startPosition = endPosition + 1;
     }
 
-    function aliasIsBoolean(key) {
-      return aliases[key].some(function (x) {
-          return flags.bools[x];
-      });
+    if (end) {
+      if (atCarriageReturn) chunks.push(-5);
+      if (buffer) chunks.push(buffer);
+      chunks.push(null);
     }
 
-    for (var i = 0; i < args.length; i++) {
-        var arg = args[i];
+    return chunks
+  }
+}
 
-        if (/^--.+=/.test(arg)) {
-            // Using [\s\S] instead of . because js doesn't support the
-            // 'dotall' regex modifier. See:
-            // http://stackoverflow.com/a/1068308/13216
-            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
-            var key = m[1];
-            var value = m[2];
-            if (flags.bools[key]) {
-                value = value !== 'false';
-            }
-            setArg(key, value, arg);
-        }
-        else if (/^--no-.+/.test(arg)) {
-            var key = arg.match(/^--no-(.+)/)[1];
-            setArg(key, false, arg);
-        }
-        else if (/^--.+/.test(arg)) {
-            var key = arg.match(/^--(.+)/)[1];
-            var next = args[i + 1];
-            if (next !== undefined && !/^-/.test(next)
-            && !flags.bools[key]
-            && !flags.allBools
-            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
-                setArg(key, next, arg);
-                i++;
-            }
-            else if (/^(true|false)$/.test(next)) {
-                setArg(key, next === 'true', arg);
-                i++;
-            }
-            else {
-                setArg(key, flags.strings[key] ? '' : true, arg);
-            }
-        }
-        else if (/^-[^-]+/.test(arg)) {
-            var letters = arg.slice(1,-1).split('');
+/**
+ * @typedef {import('micromark-util-types').Event} Event
+ */
+/**
+ * @param {Event[]} events
+ * @returns {Event[]}
+ */
 
-            var broken = false;
-            for (var j = 0; j < letters.length; j++) {
-                var next = arg.slice(j+2);
+function postprocess(events) {
+  while (!subtokenize(events)) {
+    // Empty
+  }
 
-                if (next === '-') {
-                    setArg(letters[j], next, arg);
-                    continue;
-                }
+  return events
+}
 
-                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
-                    setArg(letters[j], next.split('=')[1], arg);
-                    broken = true;
-                    break;
-                }
+/**
+ * Turn the number (in string form as either hexa- or plain decimal) coming from
+ * a numeric character reference into a character.
+ *
+ * @param {string} value
+ *   Value to decode.
+ * @param {number} base
+ *   Numeric base.
+ * @returns {string}
+ */
+function decodeNumericCharacterReference(value, base) {
+  const code = Number.parseInt(value, base);
 
-                if (/[A-Za-z]/.test(letters[j])
-                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
-                    setArg(letters[j], next, arg);
-                    broken = true;
-                    break;
-                }
+  if (
+    // C0 except for HT, LF, FF, CR, space
+    code < 9 ||
+    code === 11 ||
+    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.
+    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.
+    (code > 55295 && code < 57344) || // Noncharacters.
+    (code > 64975 && code < 65008) ||
+    (code & 65535) === 65535 ||
+    (code & 65535) === 65534 || // Out of range
+    code > 1114111
+  ) {
+    return '\uFFFD'
+  }
 
-                if (letters[j+1] && letters[j+1].match(/\W/)) {
-                    setArg(letters[j], arg.slice(j+2), arg);
-                    broken = true;
-                    break;
-                }
-                else {
-                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
-                }
-            }
+  return String.fromCharCode(code)
+}
 
-            var key = arg.slice(-1)[0];
-            if (!broken && key !== '-') {
-                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
-                && !flags.bools[key]
-                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
-                    setArg(key, args[i+1], arg);
-                    i++;
-                }
-                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
-                    setArg(key, args[i+1] === 'true', arg);
-                    i++;
-                }
-                else {
-                    setArg(key, flags.strings[key] ? '' : true, arg);
-                }
-            }
+/**
+ * @typedef {import('micromark-util-types').Encoding} Encoding
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').ParseOptions} ParseOptions
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Value} Value
+ * @typedef {Root|Root['children'][number]} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist').Point} Point
+ * @typedef {import('mdast').Break} Break
+ * @typedef {import('mdast').Blockquote} Blockquote
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('mdast').Definition} Definition
+ * @typedef {import('mdast').Emphasis} Emphasis
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('mdast').HTML} HTML
+ * @typedef {import('mdast').Image} Image
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('mdast').List} List
+ * @typedef {import('mdast').ListItem} ListItem
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast').Strong} Strong
+ * @typedef {import('mdast').Text} Text
+ * @typedef {import('mdast').ThematicBreak} ThematicBreak
+ */
+const own$4 = {}.hasOwnProperty;
+/**
+ * @param value Markdown to parse (`string` or `Buffer`).
+ * @param [encoding] Character encoding to understand `value` as when it’s a `Buffer` (`string`, default: `'utf8'`).
+ * @param [options] Configuration
+ */
+
+const fromMarkdown =
+  /**
+   * @type {(
+   *   ((value: Value, encoding: Encoding, options?: Options) => Root) &
+   *   ((value: Value, options?: Options) => Root)
+   * )}
+   */
+
+  /**
+   * @param {Value} value
+   * @param {Encoding} [encoding]
+   * @param {Options} [options]
+   * @returns {Root}
+   */
+  function (value, encoding, options) {
+    if (typeof encoding !== 'string') {
+      options = encoding;
+      encoding = undefined;
+    }
+
+    return compiler(options)(
+      postprocess(
+        parse(options).document().write(preprocess()(value, encoding, true))
+      )
+    )
+  };
+/**
+ * Note this compiler only understand complete buffering, not streaming.
+ *
+ * @param {Options} [options]
+ */
+
+function compiler(options = {}) {
+  /** @type {NormalizedExtension} */
+  // @ts-expect-error: our base has all required fields, so the result will too.
+  const config = configure$1(
+    {
+      transforms: [],
+      canContainEols: [
+        'emphasis',
+        'fragment',
+        'heading',
+        'paragraph',
+        'strong'
+      ],
+      enter: {
+        autolink: opener(link),
+        autolinkProtocol: onenterdata,
+        autolinkEmail: onenterdata,
+        atxHeading: opener(heading),
+        blockQuote: opener(blockQuote),
+        characterEscape: onenterdata,
+        characterReference: onenterdata,
+        codeFenced: opener(codeFlow),
+        codeFencedFenceInfo: buffer,
+        codeFencedFenceMeta: buffer,
+        codeIndented: opener(codeFlow, buffer),
+        codeText: opener(codeText, buffer),
+        codeTextData: onenterdata,
+        data: onenterdata,
+        codeFlowValue: onenterdata,
+        definition: opener(definition),
+        definitionDestinationString: buffer,
+        definitionLabelString: buffer,
+        definitionTitleString: buffer,
+        emphasis: opener(emphasis),
+        hardBreakEscape: opener(hardBreak),
+        hardBreakTrailing: opener(hardBreak),
+        htmlFlow: opener(html, buffer),
+        htmlFlowData: onenterdata,
+        htmlText: opener(html, buffer),
+        htmlTextData: onenterdata,
+        image: opener(image),
+        label: buffer,
+        link: opener(link),
+        listItem: opener(listItem),
+        listItemValue: onenterlistitemvalue,
+        listOrdered: opener(list, onenterlistordered),
+        listUnordered: opener(list),
+        paragraph: opener(paragraph),
+        reference: onenterreference,
+        referenceString: buffer,
+        resourceDestinationString: buffer,
+        resourceTitleString: buffer,
+        setextHeading: opener(heading),
+        strong: opener(strong),
+        thematicBreak: opener(thematicBreak)
+      },
+      exit: {
+        atxHeading: closer(),
+        atxHeadingSequence: onexitatxheadingsequence,
+        autolink: closer(),
+        autolinkEmail: onexitautolinkemail,
+        autolinkProtocol: onexitautolinkprotocol,
+        blockQuote: closer(),
+        characterEscapeValue: onexitdata,
+        characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,
+        characterReferenceMarkerNumeric: onexitcharacterreferencemarker,
+        characterReferenceValue: onexitcharacterreferencevalue,
+        codeFenced: closer(onexitcodefenced),
+        codeFencedFence: onexitcodefencedfence,
+        codeFencedFenceInfo: onexitcodefencedfenceinfo,
+        codeFencedFenceMeta: onexitcodefencedfencemeta,
+        codeFlowValue: onexitdata,
+        codeIndented: closer(onexitcodeindented),
+        codeText: closer(onexitcodetext),
+        codeTextData: onexitdata,
+        data: onexitdata,
+        definition: closer(),
+        definitionDestinationString: onexitdefinitiondestinationstring,
+        definitionLabelString: onexitdefinitionlabelstring,
+        definitionTitleString: onexitdefinitiontitlestring,
+        emphasis: closer(),
+        hardBreakEscape: closer(onexithardbreak),
+        hardBreakTrailing: closer(onexithardbreak),
+        htmlFlow: closer(onexithtmlflow),
+        htmlFlowData: onexitdata,
+        htmlText: closer(onexithtmltext),
+        htmlTextData: onexitdata,
+        image: closer(onexitimage),
+        label: onexitlabel,
+        labelText: onexitlabeltext,
+        lineEnding: onexitlineending,
+        link: closer(onexitlink),
+        listItem: closer(),
+        listOrdered: closer(),
+        listUnordered: closer(),
+        paragraph: closer(),
+        referenceString: onexitreferencestring,
+        resourceDestinationString: onexitresourcedestinationstring,
+        resourceTitleString: onexitresourcetitlestring,
+        resource: onexitresource,
+        setextHeading: closer(onexitsetextheading),
+        setextHeadingLineSequence: onexitsetextheadinglinesequence,
+        setextHeadingText: onexitsetextheadingtext,
+        strong: closer(),
+        thematicBreak: closer()
+      }
+    },
+    options.mdastExtensions || []
+  );
+  /** @type {CompileData} */
+
+  const data = {};
+  return compile
+  /**
+   * @param {Array.<Event>} events
+   * @returns {Root}
+   */
+
+  function compile(events) {
+    /** @type {Root} */
+    let tree = {
+      type: 'root',
+      children: []
+    };
+    /** @type {CompileContext['stack']} */
+
+    const stack = [tree];
+    /** @type {CompileContext['tokenStack']} */
+
+    const tokenStack = [];
+    /** @type {Array.<number>} */
+
+    const listStack = [];
+    /** @type {Omit<CompileContext, 'sliceSerialize'>} */
+
+    const context = {
+      stack,
+      tokenStack,
+      config,
+      enter,
+      exit,
+      buffer,
+      resume,
+      setData,
+      getData
+    };
+    let index = -1;
+
+    while (++index < events.length) {
+      // We preprocess lists to add `listItem` tokens, and to infer whether
+      // items the list itself are spread out.
+      if (
+        events[index][1].type === 'listOrdered' ||
+        events[index][1].type === 'listUnordered'
+      ) {
+        if (events[index][0] === 'enter') {
+          listStack.push(index);
+        } else {
+          const tail = listStack.pop();
+          index = prepareList(events, tail, index);
         }
-        else {
-            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-                argv._.push(
-                    flags.strings['_'] || !isNumber$2(arg) ? arg : Number(arg)
-                );
+      }
+    }
+
+    index = -1;
+
+    while (++index < events.length) {
+      const handler = config[events[index][0]];
+
+      if (own$4.call(handler, events[index][1].type)) {
+        handler[events[index][1].type].call(
+          Object.assign(
+            {
+              sliceSerialize: events[index][2].sliceSerialize
+            },
+            context
+          ),
+          events[index][1]
+        );
+      }
+    }
+
+    if (tokenStack.length > 0) {
+      throw new Error(
+        'Cannot close document, a token (`' +
+          tokenStack[tokenStack.length - 1].type +
+          '`, ' +
+          stringifyPosition$1({
+            start: tokenStack[tokenStack.length - 1].start,
+            end: tokenStack[tokenStack.length - 1].end
+          }) +
+          ') is still open'
+      )
+    } // Figure out `root` position.
+
+    tree.position = {
+      start: point(
+        events.length > 0
+          ? events[0][1].start
+          : {
+              line: 1,
+              column: 1,
+              offset: 0
             }
-            if (opts.stopEarly) {
-                argv._.push.apply(argv._, args.slice(i + 1));
-                break;
+      ),
+      end: point(
+        events.length > 0
+          ? events[events.length - 2][1].end
+          : {
+              line: 1,
+              column: 1,
+              offset: 0
             }
-        }
+      )
+    };
+    index = -1;
+
+    while (++index < config.transforms.length) {
+      tree = config.transforms[index](tree) || tree;
     }
 
-    Object.keys(defaults).forEach(function (key) {
-        if (!hasKey(argv, key.split('.'))) {
-            setKey(argv, key.split('.'), defaults[key]);
+    return tree
+  }
+  /**
+   * @param {Array.<Event>} events
+   * @param {number} start
+   * @param {number} length
+   * @returns {number}
+   */
 
-            (aliases[key] || []).forEach(function (x) {
-                setKey(argv, x.split('.'), defaults[key]);
-            });
+  function prepareList(events, start, length) {
+    let index = start - 1;
+    let containerBalance = -1;
+    let listSpread = false;
+    /** @type {Token|undefined} */
+
+    let listItem;
+    /** @type {number|undefined} */
+
+    let lineIndex;
+    /** @type {number|undefined} */
+
+    let firstBlankLineIndex;
+    /** @type {boolean|undefined} */
+
+    let atMarker;
+
+    while (++index <= length) {
+      const event = events[index];
+
+      if (
+        event[1].type === 'listUnordered' ||
+        event[1].type === 'listOrdered' ||
+        event[1].type === 'blockQuote'
+      ) {
+        if (event[0] === 'enter') {
+          containerBalance++;
+        } else {
+          containerBalance--;
+        }
+
+        atMarker = undefined;
+      } else if (event[1].type === 'lineEndingBlank') {
+        if (event[0] === 'enter') {
+          if (
+            listItem &&
+            !atMarker &&
+            !containerBalance &&
+            !firstBlankLineIndex
+          ) {
+            firstBlankLineIndex = index;
+          }
+
+          atMarker = undefined;
         }
-    });
+      } else if (
+        event[1].type === 'linePrefix' ||
+        event[1].type === 'listItemValue' ||
+        event[1].type === 'listItemMarker' ||
+        event[1].type === 'listItemPrefix' ||
+        event[1].type === 'listItemPrefixWhitespace'
+      ) ; else {
+        atMarker = undefined;
+      }
 
-    if (opts['--']) {
-        argv['--'] = new Array();
-        notFlags.forEach(function(key) {
-            argv['--'].push(key);
-        });
-    }
-    else {
-        notFlags.forEach(function(key) {
-            argv._.push(key);
-        });
-    }
+      if (
+        (!containerBalance &&
+          event[0] === 'enter' &&
+          event[1].type === 'listItemPrefix') ||
+        (containerBalance === -1 &&
+          event[0] === 'exit' &&
+          (event[1].type === 'listUnordered' ||
+            event[1].type === 'listOrdered'))
+      ) {
+        if (listItem) {
+          let tailIndex = index;
+          lineIndex = undefined;
 
-    return argv;
-};
+          while (tailIndex--) {
+            const tailEvent = events[tailIndex];
 
-function hasKey (obj, keys) {
-    var o = obj;
-    keys.slice(0,-1).forEach(function (key) {
-        o = (o[key] || {});
-    });
+            if (
+              tailEvent[1].type === 'lineEnding' ||
+              tailEvent[1].type === 'lineEndingBlank'
+            ) {
+              if (tailEvent[0] === 'exit') continue
 
-    var key = keys[keys.length - 1];
-    return key in o;
-}
+              if (lineIndex) {
+                events[lineIndex][1].type = 'lineEndingBlank';
+                listSpread = true;
+              }
 
-function isNumber$2 (x) {
-    if (typeof x === 'number') return true;
-    if (/^0x[0-9a-f]+$/i.test(x)) return true;
-    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
-}
+              tailEvent[1].type = 'lineEnding';
+              lineIndex = tailIndex;
+            } else if (
+              tailEvent[1].type === 'linePrefix' ||
+              tailEvent[1].type === 'blockQuotePrefix' ||
+              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||
+              tailEvent[1].type === 'blockQuoteMarker' ||
+              tailEvent[1].type === 'listItemIndent'
+            ) ; else {
+              break
+            }
+          }
 
-// This is a generated file. Do not edit.
-var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
-var ID_Start = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/;
-var ID_Continue = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/;
+          if (
+            firstBlankLineIndex &&
+            (!lineIndex || firstBlankLineIndex < lineIndex)
+          ) {
+            // @ts-expect-error Patched.
+            listItem._spread = true;
+          } // Fix position.
+
+          listItem.end = Object.assign(
+            {},
+            lineIndex ? events[lineIndex][1].start : event[1].end
+          );
+          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);
+          index++;
+          length++;
+        } // Create a new list item.
+
+        if (event[1].type === 'listItemPrefix') {
+          listItem = {
+            type: 'listItem',
+            // @ts-expect-error Patched
+            _spread: false,
+            start: Object.assign({}, event[1].start)
+          }; // @ts-expect-error: `listItem` is most definitely defined, TS...
+
+          events.splice(index, 0, ['enter', listItem, event[2]]);
+          index++;
+          length++;
+          firstBlankLineIndex = undefined;
+          atMarker = true;
+        }
+      }
+    } // @ts-expect-error Patched.
 
-var unicode = {
-	Space_Separator: Space_Separator,
-	ID_Start: ID_Start,
-	ID_Continue: ID_Continue
-};
+    events[start][1]._spread = listSpread;
+    return length
+  }
+  /**
+   * @type {CompileContext['setData']}
+   * @param [value]
+   */
 
-var util$1 = {
-    isSpaceSeparator (c) {
-        return typeof c === 'string' && unicode.Space_Separator.test(c)
-    },
+  function setData(key, value) {
+    data[key] = value;
+  }
+  /**
+   * @type {CompileContext['getData']}
+   * @template {string} K
+   * @param {K} key
+   * @returns {CompileData[K]}
+   */
 
-    isIdStartChar (c) {
-        return typeof c === 'string' && (
-            (c >= 'a' && c <= 'z') ||
-        (c >= 'A' && c <= 'Z') ||
-        (c === '$') || (c === '_') ||
-        unicode.ID_Start.test(c)
-        )
-    },
+  function getData(key) {
+    return data[key]
+  }
+  /**
+   * @param {Point} d
+   * @returns {Point}
+   */
 
-    isIdContinueChar (c) {
-        return typeof c === 'string' && (
-            (c >= 'a' && c <= 'z') ||
-        (c >= 'A' && c <= 'Z') ||
-        (c >= '0' && c <= '9') ||
-        (c === '$') || (c === '_') ||
-        (c === '\u200C') || (c === '\u200D') ||
-        unicode.ID_Continue.test(c)
-        )
-    },
+  function point(d) {
+    return {
+      line: d.line,
+      column: d.column,
+      offset: d.offset
+    }
+  }
+  /**
+   * @param {(token: Token) => Node} create
+   * @param {Handle} [and]
+   * @returns {Handle}
+   */
+
+  function opener(create, and) {
+    return open
+    /**
+     * @this {CompileContext}
+     * @param {Token} token
+     * @returns {void}
+     */
+
+    function open(token) {
+      enter.call(this, create(token), token);
+      if (and) and.call(this, token);
+    }
+  }
+  /** @type {CompileContext['buffer']} */
+
+  function buffer() {
+    // @ts-expect-error: Custom node type to collect text.
+    this.stack.push({
+      type: 'fragment',
+      children: []
+    });
+  }
+  /**
+   * @type {CompileContext['enter']}
+   * @template {Node} N
+   * @this {CompileContext}
+   * @param {N} node
+   * @param {Token} token
+   * @returns {N}
+   */
+
+  function enter(node, token) {
+    /** @type {Parent} */
+    // @ts-expect-error: Assume parent.
+    const parent = this.stack[this.stack.length - 1];
+    parent.children.push(node);
+    this.stack.push(node);
+    this.tokenStack.push(token); // @ts-expect-error: `end` will be patched later.
 
-    isDigit (c) {
-        return typeof c === 'string' && /[0-9]/.test(c)
-    },
+    node.position = {
+      start: point(token.start)
+    };
+    return node
+  }
+  /**
+   * @param {Handle} [and]
+   * @returns {Handle}
+   */
 
-    isHexDigit (c) {
-        return typeof c === 'string' && /[0-9A-Fa-f]/.test(c)
-    },
-};
+  function closer(and) {
+    return close
+    /**
+     * @this {CompileContext}
+     * @param {Token} token
+     * @returns {void}
+     */
 
-let source$1;
-let parseState;
-let stack;
-let pos;
-let line;
-let column;
-let token;
-let key;
-let root;
+    function close(token) {
+      if (and) and.call(this, token);
+      exit.call(this, token);
+    }
+  }
+  /** @type {CompileContext['exit']} */
 
-var parse$7 = function parse (text, reviver) {
-    source$1 = String(text);
-    parseState = 'start';
-    stack = [];
-    pos = 0;
-    line = 1;
-    column = 0;
-    token = undefined;
-    key = undefined;
-    root = undefined;
+  function exit(token) {
+    const node = this.stack.pop();
+    const open = this.tokenStack.pop();
 
-    do {
-        token = lex();
+    if (!open) {
+      throw new Error(
+        'Cannot close `' +
+          token.type +
+          '` (' +
+          stringifyPosition$1({
+            start: token.start,
+            end: token.end
+          }) +
+          '): it’s not open'
+      )
+    } else if (open.type !== token.type) {
+      throw new Error(
+        'Cannot close `' +
+          token.type +
+          '` (' +
+          stringifyPosition$1({
+            start: token.start,
+            end: token.end
+          }) +
+          '): a different token (`' +
+          open.type +
+          '`, ' +
+          stringifyPosition$1({
+            start: open.start,
+            end: open.end
+          }) +
+          ') is open'
+      )
+    }
 
-        // This code is unreachable.
-        // if (!parseStates[parseState]) {
-        //     throw invalidParseState()
-        // }
+    node.position.end = point(token.end);
+    return node
+  }
+  /**
+   * @this {CompileContext}
+   * @returns {string}
+   */
 
-        parseStates[parseState]();
-    } while (token.type !== 'eof')
+  function resume() {
+    return toString(this.stack.pop())
+  } //
+  // Handlers.
+  //
 
-    if (typeof reviver === 'function') {
-        return internalize({'': root}, '', reviver)
-    }
+  /** @type {Handle} */
 
-    return root
-};
+  function onenterlistordered() {
+    setData('expectingFirstListItemValue', true);
+  }
+  /** @type {Handle} */
 
-function internalize (holder, name, reviver) {
-    const value = holder[name];
-    if (value != null && typeof value === 'object') {
-        for (const key in value) {
-            const replacement = internalize(value, key, reviver);
-            if (replacement === undefined) {
-                delete value[key];
-            } else {
-                value[key] = replacement;
-            }
-        }
+  function onenterlistitemvalue(token) {
+    if (getData('expectingFirstListItemValue')) {
+      this.stack[this.stack.length - 2].start = Number.parseInt(
+        this.sliceSerialize(token),
+        10
+      );
+      setData('expectingFirstListItemValue');
     }
+  }
+  /** @type {Handle} */
 
-    return reviver.call(holder, name, value)
-}
+  function onexitcodefencedfenceinfo() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].lang = data;
+  }
+  /** @type {Handle} */
 
-let lexState;
-let buffer;
-let doubleQuote;
-let sign;
-let c;
+  function onexitcodefencedfencemeta() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].meta = data;
+  }
+  /** @type {Handle} */
 
-function lex () {
-    lexState = 'default';
-    buffer = '';
-    doubleQuote = false;
-    sign = 1;
+  function onexitcodefencedfence() {
+    // Exit if this is the closing fence.
+    if (getData('flowCodeInside')) return
+    this.buffer();
+    setData('flowCodeInside', true);
+  }
+  /** @type {Handle} */
 
-    for (;;) {
-        c = peek();
+  function onexitcodefenced() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].value = data.replace(
+      /^(\r?\n|\r)|(\r?\n|\r)$/g,
+      ''
+    );
+    setData('flowCodeInside');
+  }
+  /** @type {Handle} */
 
-        // This code is unreachable.
-        // if (!lexStates[lexState]) {
-        //     throw invalidLexState(lexState)
-        // }
+  function onexitcodeindented() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].value = data.replace(/(\r?\n|\r)$/g, '');
+  }
+  /** @type {Handle} */
 
-        const token = lexStates[lexState]();
-        if (token) {
-            return token
-        }
-    }
-}
+  function onexitdefinitionlabelstring(token) {
+    // Discard label, use the source content instead.
+    const label = this.resume();
+    this.stack[this.stack.length - 1].label = label;
+    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(
+      this.sliceSerialize(token)
+    ).toLowerCase();
+  }
+  /** @type {Handle} */
 
-function peek () {
-    if (source$1[pos]) {
-        return String.fromCodePoint(source$1.codePointAt(pos))
-    }
-}
+  function onexitdefinitiontitlestring() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].title = data;
+  }
+  /** @type {Handle} */
 
-function read$5 () {
-    const c = peek();
+  function onexitdefinitiondestinationstring() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].url = data;
+  }
+  /** @type {Handle} */
 
-    if (c === '\n') {
-        line++;
-        column = 0;
-    } else if (c) {
-        column += c.length;
-    } else {
-        column++;
+  function onexitatxheadingsequence(token) {
+    if (!this.stack[this.stack.length - 1].depth) {
+      this.stack[this.stack.length - 1].depth =
+        this.sliceSerialize(token).length;
     }
+  }
+  /** @type {Handle} */
 
-    if (c) {
-        pos += c.length;
-    }
+  function onexitsetextheadingtext() {
+    setData('setextHeadingSlurpLineEnding', true);
+  }
+  /** @type {Handle} */
 
-    return c
-}
+  function onexitsetextheadinglinesequence(token) {
+    this.stack[this.stack.length - 1].depth =
+      this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;
+  }
+  /** @type {Handle} */
 
-const lexStates = {
-    default () {
-        switch (c) {
-        case '\t':
-        case '\v':
-        case '\f':
-        case ' ':
-        case '\u00A0':
-        case '\uFEFF':
-        case '\n':
-        case '\r':
-        case '\u2028':
-        case '\u2029':
-            read$5();
-            return
+  function onexitsetextheading() {
+    setData('setextHeadingSlurpLineEnding');
+  }
+  /** @type {Handle} */
 
-        case '/':
-            read$5();
-            lexState = 'comment';
-            return
+  function onenterdata(token) {
+    /** @type {Parent} */
+    // @ts-expect-error: assume parent.
+    const parent = this.stack[this.stack.length - 1];
+    /** @type {Node} */
+    // @ts-expect-error: assume child.
 
-        case undefined:
-            read$5();
-            return newToken('eof')
-        }
+    let tail = parent.children[parent.children.length - 1];
 
-        if (util$1.isSpaceSeparator(c)) {
-            read$5();
-            return
-        }
+    if (!tail || tail.type !== 'text') {
+      // Add a new text node.
+      tail = text(); // @ts-expect-error: we’ll add `end` later.
 
-        // This code is unreachable.
-        // if (!lexStates[parseState]) {
-        //     throw invalidLexState(parseState)
-        // }
+      tail.position = {
+        start: point(token.start)
+      };
+      parent.children.push(tail);
+    }
 
-        return lexStates[parseState]()
-    },
+    this.stack.push(tail);
+  }
+  /** @type {Handle} */
 
-    comment () {
-        switch (c) {
-        case '*':
-            read$5();
-            lexState = 'multiLineComment';
-            return
+  function onexitdata(token) {
+    const tail = this.stack.pop();
+    tail.value += this.sliceSerialize(token);
+    tail.position.end = point(token.end);
+  }
+  /** @type {Handle} */
 
-        case '/':
-            read$5();
-            lexState = 'singleLineComment';
-            return
-        }
+  function onexitlineending(token) {
+    /** @type {Parent} */
+    // @ts-expect-error: supposed to be a parent.
+    const context = this.stack[this.stack.length - 1];
 
-        throw invalidChar(read$5())
-    },
+    // If we’re at a hard break, include the line ending in there.
+    if (getData('atHardBreak')) {
+      const tail = context.children[context.children.length - 1];
+      tail.position.end = point(token.end);
+      setData('atHardBreak');
+      return
+    }
 
-    multiLineComment () {
-        switch (c) {
-        case '*':
-            read$5();
-            lexState = 'multiLineCommentAsterisk';
-            return
+    if (
+      !getData('setextHeadingSlurpLineEnding') &&
+      config.canContainEols.includes(context.type)
+    ) {
+      onenterdata.call(this, token);
+      onexitdata.call(this, token);
+    }
+  }
+  /** @type {Handle} */
 
-        case undefined:
-            throw invalidChar(read$5())
-        }
+  function onexithardbreak() {
+    setData('atHardBreak', true);
+  }
+  /** @type {Handle} */
 
-        read$5();
-    },
+  function onexithtmlflow() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].value = data;
+  }
+  /** @type {Handle} */
 
-    multiLineCommentAsterisk () {
-        switch (c) {
-        case '*':
-            read$5();
-            return
+  function onexithtmltext() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].value = data;
+  }
+  /** @type {Handle} */
 
-        case '/':
-            read$5();
-            lexState = 'default';
-            return
+  function onexitcodetext() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].value = data;
+  }
+  /** @type {Handle} */
 
-        case undefined:
-            throw invalidChar(read$5())
-        }
+  function onexitlink() {
+    const context = this.stack[this.stack.length - 1]; // To do: clean.
 
-        read$5();
-        lexState = 'multiLineComment';
-    },
+    if (getData('inReference')) {
+      context.type += 'Reference';
+      context.referenceType = getData('referenceType') || 'shortcut';
+      delete context.url;
+      delete context.title;
+    } else {
+      delete context.identifier;
+      delete context.label;
+      delete context.referenceType;
+    }
 
-    singleLineComment () {
-        switch (c) {
-        case '\n':
-        case '\r':
-        case '\u2028':
-        case '\u2029':
-            read$5();
-            lexState = 'default';
-            return
+    setData('referenceType');
+  }
+  /** @type {Handle} */
 
-        case undefined:
-            read$5();
-            return newToken('eof')
-        }
+  function onexitimage() {
+    const context = this.stack[this.stack.length - 1]; // To do: clean.
 
-        read$5();
-    },
+    if (getData('inReference')) {
+      context.type += 'Reference';
+      context.referenceType = getData('referenceType') || 'shortcut';
+      delete context.url;
+      delete context.title;
+    } else {
+      delete context.identifier;
+      delete context.label;
+      delete context.referenceType;
+    }
 
-    value () {
-        switch (c) {
-        case '{':
-        case '[':
-            return newToken('punctuator', read$5())
+    setData('referenceType');
+  }
+  /** @type {Handle} */
 
-        case 'n':
-            read$5();
-            literal('ull');
-            return newToken('null', null)
+  function onexitlabeltext(token) {
+    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(
+      this.sliceSerialize(token)
+    ).toLowerCase();
+  }
+  /** @type {Handle} */
 
-        case 't':
-            read$5();
-            literal('rue');
-            return newToken('boolean', true)
+  function onexitlabel() {
+    const fragment = this.stack[this.stack.length - 1];
+    const value = this.resume();
+    this.stack[this.stack.length - 1].label = value; // Assume a reference.
 
-        case 'f':
-            read$5();
-            literal('alse');
-            return newToken('boolean', false)
+    setData('inReference', true);
 
-        case '-':
-        case '+':
-            if (read$5() === '-') {
-                sign = -1;
-            }
+    if (this.stack[this.stack.length - 1].type === 'link') {
+      this.stack[this.stack.length - 1].children = fragment.children;
+    } else {
+      this.stack[this.stack.length - 1].alt = value;
+    }
+  }
+  /** @type {Handle} */
 
-            lexState = 'sign';
-            return
+  function onexitresourcedestinationstring() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].url = data;
+  }
+  /** @type {Handle} */
 
-        case '.':
-            buffer = read$5();
-            lexState = 'decimalPointLeading';
-            return
+  function onexitresourcetitlestring() {
+    const data = this.resume();
+    this.stack[this.stack.length - 1].title = data;
+  }
+  /** @type {Handle} */
 
-        case '0':
-            buffer = read$5();
-            lexState = 'zero';
-            return
+  function onexitresource() {
+    setData('inReference');
+  }
+  /** @type {Handle} */
 
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9':
-            buffer = read$5();
-            lexState = 'decimalInteger';
-            return
+  function onenterreference() {
+    setData('referenceType', 'collapsed');
+  }
+  /** @type {Handle} */
 
-        case 'I':
-            read$5();
-            literal('nfinity');
-            return newToken('numeric', Infinity)
+  function onexitreferencestring(token) {
+    const label = this.resume();
+    this.stack[this.stack.length - 1].label = label;
+    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(
+      this.sliceSerialize(token)
+    ).toLowerCase();
+    setData('referenceType', 'full');
+  }
+  /** @type {Handle} */
 
-        case 'N':
-            read$5();
-            literal('aN');
-            return newToken('numeric', NaN)
+  function onexitcharacterreferencemarker(token) {
+    setData('characterReferenceType', token.type);
+  }
+  /** @type {Handle} */
 
-        case '"':
-        case "'":
-            doubleQuote = (read$5() === '"');
-            buffer = '';
-            lexState = 'string';
-            return
-        }
+  function onexitcharacterreferencevalue(token) {
+    const data = this.sliceSerialize(token);
+    const type = getData('characterReferenceType');
+    /** @type {string} */
 
-        throw invalidChar(read$5())
-    },
+    let value;
 
-    identifierNameStartEscape () {
-        if (c !== 'u') {
-            throw invalidChar(read$5())
-        }
+    if (type) {
+      value = decodeNumericCharacterReference(
+        data,
+        type === 'characterReferenceMarkerNumeric' ? 10 : 16
+      );
+      setData('characterReferenceType');
+    } else {
+      // @ts-expect-error `decodeEntity` can return false for invalid named
+      // character references, but everything we’ve tokenized is valid.
+      value = decodeEntity(data);
+    }
 
-        read$5();
-        const u = unicodeEscape();
-        switch (u) {
-        case '$':
-        case '_':
-            break
+    const tail = this.stack.pop();
+    tail.value += value;
+    tail.position.end = point(token.end);
+  }
+  /** @type {Handle} */
 
-        default:
-            if (!util$1.isIdStartChar(u)) {
-                throw invalidIdentifier()
-            }
+  function onexitautolinkprotocol(token) {
+    onexitdata.call(this, token);
+    this.stack[this.stack.length - 1].url = this.sliceSerialize(token);
+  }
+  /** @type {Handle} */
 
-            break
-        }
+  function onexitautolinkemail(token) {
+    onexitdata.call(this, token);
+    this.stack[this.stack.length - 1].url =
+      'mailto:' + this.sliceSerialize(token);
+  } //
+  // Creaters.
+  //
 
-        buffer += u;
-        lexState = 'identifierName';
-    },
+  /** @returns {Blockquote} */
 
-    identifierName () {
-        switch (c) {
-        case '$':
-        case '_':
-        case '\u200C':
-        case '\u200D':
-            buffer += read$5();
-            return
+  function blockQuote() {
+    return {
+      type: 'blockquote',
+      children: []
+    }
+  }
+  /** @returns {Code} */
 
-        case '\\':
-            read$5();
-            lexState = 'identifierNameEscape';
-            return
-        }
+  function codeFlow() {
+    // @ts-expect-error: we’ve always used `null`.
+    return {
+      type: 'code',
+      lang: null,
+      meta: null,
+      value: ''
+    }
+  }
+  /** @returns {InlineCode} */
 
-        if (util$1.isIdContinueChar(c)) {
-            buffer += read$5();
-            return
-        }
+  function codeText() {
+    return {
+      type: 'inlineCode',
+      value: ''
+    }
+  }
+  /** @returns {Definition} */
 
-        return newToken('identifier', buffer)
-    },
+  function definition() {
+    return {
+      type: 'definition',
+      identifier: '',
+      // @ts-expect-error: we’ve always used `null`.
+      label: null,
+      // @ts-expect-error: we’ve always used `null`.
+      title: null,
+      url: ''
+    }
+  }
+  /** @returns {Emphasis} */
 
-    identifierNameEscape () {
-        if (c !== 'u') {
-            throw invalidChar(read$5())
-        }
+  function emphasis() {
+    return {
+      type: 'emphasis',
+      children: []
+    }
+  }
+  /** @returns {Heading} */
 
-        read$5();
-        const u = unicodeEscape();
-        switch (u) {
-        case '$':
-        case '_':
-        case '\u200C':
-        case '\u200D':
-            break
+  function heading() {
+    // @ts-expect-error `depth` will be set later.
+    return {
+      type: 'heading',
+      depth: undefined,
+      children: []
+    }
+  }
+  /** @returns {Break} */
 
-        default:
-            if (!util$1.isIdContinueChar(u)) {
-                throw invalidIdentifier()
-            }
+  function hardBreak() {
+    return {
+      type: 'break'
+    }
+  }
+  /** @returns {HTML} */
 
-            break
-        }
+  function html() {
+    return {
+      type: 'html',
+      value: ''
+    }
+  }
+  /** @returns {Image} */
 
-        buffer += u;
-        lexState = 'identifierName';
-    },
+  function image() {
+    // @ts-expect-error: we’ve always used `null`.
+    return {
+      type: 'image',
+      title: null,
+      url: '',
+      alt: null
+    }
+  }
+  /** @returns {Link} */
 
-    sign () {
-        switch (c) {
-        case '.':
-            buffer = read$5();
-            lexState = 'decimalPointLeading';
-            return
+  function link() {
+    // @ts-expect-error: we’ve always used `null`.
+    return {
+      type: 'link',
+      title: null,
+      url: '',
+      children: []
+    }
+  }
+  /**
+   * @param {Token} token
+   * @returns {List}
+   */
 
-        case '0':
-            buffer = read$5();
-            lexState = 'zero';
-            return
+  function list(token) {
+    return {
+      type: 'list',
+      ordered: token.type === 'listOrdered',
+      // @ts-expect-error: we’ve always used `null`.
+      start: null,
+      // @ts-expect-error Patched.
+      spread: token._spread,
+      children: []
+    }
+  }
+  /**
+   * @param {Token} token
+   * @returns {ListItem}
+   */
 
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9':
-            buffer = read$5();
-            lexState = 'decimalInteger';
-            return
+  function listItem(token) {
+    return {
+      type: 'listItem',
+      // @ts-expect-error Patched.
+      spread: token._spread,
+      // @ts-expect-error: we’ve always used `null`.
+      checked: null,
+      children: []
+    }
+  }
+  /** @returns {Paragraph} */
 
-        case 'I':
-            read$5();
-            literal('nfinity');
-            return newToken('numeric', sign * Infinity)
+  function paragraph() {
+    return {
+      type: 'paragraph',
+      children: []
+    }
+  }
+  /** @returns {Strong} */
 
-        case 'N':
-            read$5();
-            literal('aN');
-            return newToken('numeric', NaN)
-        }
+  function strong() {
+    return {
+      type: 'strong',
+      children: []
+    }
+  }
+  /** @returns {Text} */
 
-        throw invalidChar(read$5())
-    },
+  function text() {
+    return {
+      type: 'text',
+      value: ''
+    }
+  }
+  /** @returns {ThematicBreak} */
 
-    zero () {
-        switch (c) {
-        case '.':
-            buffer += read$5();
-            lexState = 'decimalPoint';
-            return
+  function thematicBreak() {
+    return {
+      type: 'thematicBreak'
+    }
+  }
+}
+/**
+ * @param {Extension} combined
+ * @param {Array.<Extension|Array.<Extension>>} extensions
+ * @returns {Extension}
+ */
 
-        case 'e':
-        case 'E':
-            buffer += read$5();
-            lexState = 'decimalExponent';
-            return
+function configure$1(combined, extensions) {
+  let index = -1;
 
-        case 'x':
-        case 'X':
-            buffer += read$5();
-            lexState = 'hexadecimal';
-            return
-        }
+  while (++index < extensions.length) {
+    const value = extensions[index];
 
-        return newToken('numeric', sign * 0)
-    },
+    if (Array.isArray(value)) {
+      configure$1(combined, value);
+    } else {
+      extension(combined, value);
+    }
+  }
 
-    decimalInteger () {
-        switch (c) {
-        case '.':
-            buffer += read$5();
-            lexState = 'decimalPoint';
-            return
+  return combined
+}
+/**
+ * @param {Extension} combined
+ * @param {Extension} extension
+ * @returns {void}
+ */
 
-        case 'e':
-        case 'E':
-            buffer += read$5();
-            lexState = 'decimalExponent';
-            return
-        }
+function extension(combined, extension) {
+  /** @type {string} */
+  let key;
 
-        if (util$1.isDigit(c)) {
-            buffer += read$5();
-            return
-        }
+  for (key in extension) {
+    if (own$4.call(extension, key)) {
+      const list = key === 'canContainEols' || key === 'transforms';
+      const maybe = own$4.call(combined, key) ? combined[key] : undefined;
+      /* c8 ignore next */
 
-        return newToken('numeric', sign * Number(buffer))
-    },
+      const left = maybe || (combined[key] = list ? [] : {});
+      const right = extension[key];
 
-    decimalPointLeading () {
-        if (util$1.isDigit(c)) {
-            buffer += read$5();
-            lexState = 'decimalFraction';
-            return
+      if (right) {
+        if (list) {
+          // @ts-expect-error: `left` is an array.
+          combined[key] = [...left, ...right];
+        } else {
+          Object.assign(left, right);
         }
+      }
+    }
+  }
+}
 
-        throw invalidChar(read$5())
-    },
-
-    decimalPoint () {
-        switch (c) {
-        case 'e':
-        case 'E':
-            buffer += read$5();
-            lexState = 'decimalExponent';
-            return
-        }
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast-util-from-markdown').Options} Options
+ */
 
-        if (util$1.isDigit(c)) {
-            buffer += read$5();
-            lexState = 'decimalFraction';
-            return
-        }
+/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */
+function remarkParse(options) {
+  /** @type {import('unified').ParserFunction<Root>} */
+  const parser = (doc) => {
+    // Assume options.
+    const settings = /** @type {Options} */ (this.data('settings'));
+
+    return fromMarkdown(
+      doc,
+      Object.assign({}, settings, options, {
+        // Note: these options are not in the readme.
+        // The goal is for them to be set by plugins on `data` instead of being
+        // passed by users.
+        extensions: this.data('micromarkExtensions') || [],
+        mdastExtensions: this.data('fromMarkdownExtensions') || []
+      })
+    )
+  };
 
-        return newToken('numeric', sign * Number(buffer))
-    },
+  Object.assign(this, {Parser: parser});
+}
 
-    decimalFraction () {
-        switch (c) {
-        case 'e':
-        case 'E':
-            buffer += read$5();
-            lexState = 'decimalExponent';
-            return
-        }
+var own$3 = {}.hasOwnProperty;
 
-        if (util$1.isDigit(c)) {
-            buffer += read$5();
-            return
-        }
+/**
+ * @callback Handler
+ * @param {...unknown} value
+ * @return {unknown}
+ *
+ * @typedef {Record<string, Handler>} Handlers
+ *
+ * @typedef {Object} Options
+ * @property {Handler} [unknown]
+ * @property {Handler} [invalid]
+ * @property {Handlers} [handlers]
+ */
 
-        return newToken('numeric', sign * Number(buffer))
-    },
+/**
+ * Handle values based on a property.
+ *
+ * @param {string} key
+ * @param {Options} [options]
+ */
+function zwitch(key, options) {
+  var settings = options || {};
 
-    decimalExponent () {
-        switch (c) {
-        case '+':
-        case '-':
-            buffer += read$5();
-            lexState = 'decimalExponentSign';
-            return
-        }
+  /**
+   * Handle one value.
+   * Based on the bound `key`, a respective handler will be called.
+   * If `value` is not an object, or doesn’t have a `key` property, the special
+   * “invalid” handler will be called.
+   * If `value` has an unknown `key`, the special “unknown” handler will be
+   * called.
+   *
+   * All arguments, and the context object, are passed through to the handler,
+   * and it’s result is returned.
+   *
+   * @param {...unknown} [value]
+   * @this {unknown}
+   * @returns {unknown}
+   * @property {Handler} invalid
+   * @property {Handler} unknown
+   * @property {Handlers} handlers
+   */
+  function one(value) {
+    var fn = one.invalid;
+    var handlers = one.handlers;
 
-        if (util$1.isDigit(c)) {
-            buffer += read$5();
-            lexState = 'decimalExponentInteger';
-            return
-        }
+    if (value && own$3.call(value, key)) {
+      fn = own$3.call(handlers, value[key]) ? handlers[value[key]] : one.unknown;
+    }
 
-        throw invalidChar(read$5())
-    },
+    if (fn) {
+      return fn.apply(this, arguments)
+    }
+  }
 
-    decimalExponentSign () {
-        if (util$1.isDigit(c)) {
-            buffer += read$5();
-            lexState = 'decimalExponentInteger';
-            return
-        }
+  one.handlers = settings.handlers || {};
+  one.invalid = settings.invalid;
+  one.unknown = settings.unknown;
 
-        throw invalidChar(read$5())
-    },
+  return one
+}
 
-    decimalExponentInteger () {
-        if (util$1.isDigit(c)) {
-            buffer += read$5();
-            return
-        }
+/**
+ * @typedef {import('./types.js').Options} Options
+ * @typedef {import('./types.js').Context} Context
+ */
 
-        return newToken('numeric', sign * Number(buffer))
-    },
+/**
+ * @param {Context} base
+ * @param {Options} extension
+ * @returns {Context}
+ */
+function configure(base, extension) {
+  let index = -1;
+  /** @type {string} */
+  let key;
 
-    hexadecimal () {
-        if (util$1.isHexDigit(c)) {
-            buffer += read$5();
-            lexState = 'hexadecimalInteger';
-            return
-        }
+  // First do subextensions.
+  if (extension.extensions) {
+    while (++index < extension.extensions.length) {
+      configure(base, extension.extensions[index]);
+    }
+  }
 
-        throw invalidChar(read$5())
-    },
+  for (key in extension) {
+    if (key === 'extensions') ; else if (key === 'unsafe' || key === 'join') {
+      /* c8 ignore next 2 */
+      // @ts-expect-error: hush.
+      base[key] = [...(base[key] || []), ...(extension[key] || [])];
+    } else if (key === 'handlers') {
+      base[key] = Object.assign(base[key], extension[key] || {});
+    } else {
+      // @ts-expect-error: hush.
+      base.options[key] = extension[key];
+    }
+  }
 
-    hexadecimalInteger () {
-        if (util$1.isHexDigit(c)) {
-            buffer += read$5();
-            return
-        }
+  return base
+}
 
-        return newToken('numeric', sign * Number(buffer))
-    },
+/**
+ * @typedef {import('../types.js').Node} Node
+ * @typedef {import('../types.js').Parent} Parent
+ * @typedef {import('../types.js').Join} Join
+ * @typedef {import('../types.js').Context} Context
+ */
 
-    string () {
-        switch (c) {
-        case '\\':
-            read$5();
-            buffer += escape();
-            return
+/**
+ * @param {Parent} parent
+ * @param {Context} context
+ * @returns {string}
+ */
+function containerFlow(parent, context) {
+  const children = parent.children || [];
+  /** @type {Array.<string>} */
+  const results = [];
+  let index = -1;
 
-        case '"':
-            if (doubleQuote) {
-                read$5();
-                return newToken('string', buffer)
-            }
+  while (++index < children.length) {
+    const child = children[index];
 
-            buffer += read$5();
-            return
+    results.push(
+      context.handle(child, parent, context, {before: '\n', after: '\n'})
+    );
 
-        case "'":
-            if (!doubleQuote) {
-                read$5();
-                return newToken('string', buffer)
-            }
+    if (index < children.length - 1) {
+      results.push(between(child, children[index + 1]));
+    }
+  }
 
-            buffer += read$5();
-            return
+  return results.join('')
 
-        case '\n':
-        case '\r':
-            throw invalidChar(read$5())
+  /**
+   * @param {Node} left
+   * @param {Node} right
+   * @returns {string}
+   */
+  function between(left, right) {
+    let index = context.join.length;
+    /** @type {ReturnType<Join>} */
+    let result;
 
-        case '\u2028':
-        case '\u2029':
-            separatorChar(c);
-            break
+    while (index--) {
+      result = context.join[index](left, right, parent, context);
 
-        case undefined:
-            throw invalidChar(read$5())
-        }
+      if (result === true || result === 1) {
+        break
+      }
 
-        buffer += read$5();
-    },
+      if (typeof result === 'number') {
+        return '\n'.repeat(1 + result)
+      }
 
-    start () {
-        switch (c) {
-        case '{':
-        case '[':
-            return newToken('punctuator', read$5())
+      if (result === false) {
+        return '\n\n<!---->\n\n'
+      }
+    }
 
-        // This code is unreachable since the default lexState handles eof.
-        // case undefined:
-        //     return newToken('eof')
-        }
+    return '\n\n'
+  }
+}
 
-        lexState = 'value';
-    },
+/**
+ * @callback Map
+ * @param {string} value
+ * @param {number} line
+ * @param {boolean} blank
+ * @returns {string}
+ */
 
-    beforePropertyName () {
-        switch (c) {
-        case '$':
-        case '_':
-            buffer = read$5();
-            lexState = 'identifierName';
-            return
+const eol = /\r?\n|\r/g;
 
-        case '\\':
-            read$5();
-            lexState = 'identifierNameStartEscape';
-            return
+/**
+ * @param {string} value
+ * @param {Map} map
+ * @returns {string}
+ */
+function indentLines(value, map) {
+  /** @type {Array.<string>} */
+  const result = [];
+  let start = 0;
+  let line = 0;
+  /** @type {RegExpExecArray|null} */
+  let match;
+
+  while ((match = eol.exec(value))) {
+    one(value.slice(start, match.index));
+    result.push(match[0]);
+    start = match.index + match[0].length;
+    line++;
+  }
 
-        case '}':
-            return newToken('punctuator', read$5())
+  one(value.slice(start));
 
-        case '"':
-        case "'":
-            doubleQuote = (read$5() === '"');
-            lexState = 'string';
-            return
-        }
+  return result.join('')
 
-        if (util$1.isIdStartChar(c)) {
-            buffer += read$5();
-            lexState = 'identifierName';
-            return
-        }
+  /**
+   * @param {string} value
+   */
+  function one(value) {
+    result.push(map(value, line, !value));
+  }
+}
 
-        throw invalidChar(read$5())
-    },
+/**
+ * @typedef {import('mdast').Blockquote} Blockquote
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../util/indent-lines.js').Map} Map
+ */
 
-    afterPropertyName () {
-        if (c === ':') {
-            return newToken('punctuator', read$5())
-        }
+/**
+ * @type {Handle}
+ * @param {Blockquote} node
+ */
+function blockquote(node, _, context) {
+  const exit = context.enter('blockquote');
+  const value = indentLines(containerFlow(node, context), map$1);
+  exit();
+  return value
+}
 
-        throw invalidChar(read$5())
-    },
+/** @type {Map} */
+function map$1(line, _, blank) {
+  return '>' + (blank ? '' : ' ') + line
+}
 
-    beforePropertyValue () {
-        lexState = 'value';
-    },
+/**
+ * @typedef {import('../types.js').Unsafe} Unsafe
+ */
 
-    afterPropertyValue () {
-        switch (c) {
-        case ',':
-        case '}':
-            return newToken('punctuator', read$5())
-        }
+/**
+ * @param {Array.<string>} stack
+ * @param {Unsafe} pattern
+ * @returns {boolean}
+ */
+function patternInScope(stack, pattern) {
+  return (
+    listInScope(stack, pattern.inConstruct, true) &&
+    !listInScope(stack, pattern.notInConstruct, false)
+  )
+}
 
-        throw invalidChar(read$5())
-    },
+/**
+ * @param {Array.<string>} stack
+ * @param {Unsafe['inConstruct']} list
+ * @param {boolean} none
+ * @returns {boolean}
+ */
+function listInScope(stack, list, none) {
+  if (!list) {
+    return none
+  }
 
-    beforeArrayValue () {
-        if (c === ']') {
-            return newToken('punctuator', read$5())
-        }
+  if (typeof list === 'string') {
+    list = [list];
+  }
 
-        lexState = 'value';
-    },
+  let index = -1;
 
-    afterArrayValue () {
-        switch (c) {
-        case ',':
-        case ']':
-            return newToken('punctuator', read$5())
-        }
+  while (++index < list.length) {
+    if (stack.includes(list[index])) {
+      return true
+    }
+  }
 
-        throw invalidChar(read$5())
-    },
+  return false
+}
 
-    end () {
-        // This code is unreachable since it's handled by the default lexState.
-        // if (c === undefined) {
-        //     read()
-        //     return newToken('eof')
-        // }
+/**
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('mdast').Break} Break
+ */
 
-        throw invalidChar(read$5())
-    },
-};
+/**
+ * @type {Handle}
+ * @param {Break} _
+ */
+function hardBreak(_, _1, context, safe) {
+  let index = -1;
 
-function newToken (type, value) {
-    return {
-        type,
-        value,
-        line,
-        column,
+  while (++index < context.unsafe.length) {
+    // If we can’t put eols in this construct (setext headings, tables), use a
+    // space instead.
+    if (
+      context.unsafe[index].character === '\n' &&
+      patternInScope(context.stack, context.unsafe[index])
+    ) {
+      return /[ \t]/.test(safe.before) ? '' : ' '
     }
+  }
+
+  return '\\\n'
 }
 
-function literal (s) {
-    for (const c of s) {
-        const p = peek();
+/**
+ * Get the count of the longest repeating streak of `character` in `value`.
+ *
+ * @param {string} value Content.
+ * @param {string} character Single character to look for
+ * @returns {number} Count of most frequent adjacent `character`s in `value`
+ */
+function longestStreak(value, character) {
+  var source = String(value);
+  var index = source.indexOf(character);
+  var expected = index;
+  var count = 0;
+  var max = 0;
 
-        if (p !== c) {
-            throw invalidChar(read$5())
-        }
+  if (typeof character !== 'string' || character.length !== 1) {
+    throw new Error('Expected character')
+  }
 
-        read$5();
+  while (index !== -1) {
+    if (index === expected) {
+      if (++count > max) {
+        max = count;
+      }
+    } else {
+      count = 1;
     }
-}
 
-function escape () {
-    const c = peek();
-    switch (c) {
-    case 'b':
-        read$5();
-        return '\b'
+    expected = index + 1;
+    index = source.indexOf(character, expected);
+  }
 
-    case 'f':
-        read$5();
-        return '\f'
+  return max
+}
 
-    case 'n':
-        read$5();
-        return '\n'
+/**
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('../types.js').Context} Context
+ */
 
-    case 'r':
-        read$5();
-        return '\r'
+/**
+ * @param {Code} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function formatCodeAsIndented(node, context) {
+  return Boolean(
+    !context.options.fences &&
+      node.value &&
+      // If there’s no info…
+      !node.lang &&
+      // And there’s a non-whitespace character…
+      /[^ \r\n]/.test(node.value) &&
+      // And the value doesn’t start or end in a blank…
+      !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node.value)
+  )
+}
 
-    case 't':
-        read$5();
-        return '\t'
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
 
-    case 'v':
-        read$5();
-        return '\v'
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['fence'], undefined>}
+ */
+function checkFence(context) {
+  const marker = context.options.fence || '`';
 
-    case '0':
-        read$5();
-        if (util$1.isDigit(peek())) {
-            throw invalidChar(read$5())
-        }
+  if (marker !== '`' && marker !== '~') {
+    throw new Error(
+      'Cannot serialize code with `' +
+        marker +
+        '` for `options.fence`, expected `` ` `` or `~`'
+    )
+  }
 
-        return '\0'
+  return marker
+}
 
-    case 'x':
-        read$5();
-        return hexEscape()
+/**
+ * @typedef {import('../types.js').Unsafe} Unsafe
+ */
 
-    case 'u':
-        read$5();
-        return unicodeEscape()
+/**
+ * @param {Unsafe} pattern
+ * @returns {RegExp}
+ */
+function patternCompile(pattern) {
+  if (!pattern._compiled) {
+    const before =
+      (pattern.atBreak ? '[\\r\\n][\\t ]*' : '') +
+      (pattern.before ? '(?:' + pattern.before + ')' : '');
+
+    pattern._compiled = new RegExp(
+      (before ? '(' + before + ')' : '') +
+        (/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? '\\' : '') +
+        pattern.character +
+        (pattern.after ? '(?:' + pattern.after + ')' : ''),
+      'g'
+    );
+  }
 
-    case '\n':
-    case '\u2028':
-    case '\u2029':
-        read$5();
-        return ''
+  return pattern._compiled
+}
 
-    case '\r':
-        read$5();
-        if (peek() === '\n') {
-            read$5();
-        }
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').SafeOptions} SafeOptions
+ */
 
-        return ''
+/**
+ * @param {Context} context
+ * @param {string|null|undefined} input
+ * @param {SafeOptions & {encode?: Array.<string>}} config
+ * @returns {string}
+ */
+function safe(context, input, config) {
+  const value = (config.before || '') + (input || '') + (config.after || '');
+  /** @type {Array.<number>} */
+  const positions = [];
+  /** @type {Array.<string>} */
+  const result = [];
+  /** @type {Record<number, {before: boolean, after: boolean}>} */
+  const infos = {};
+  let index = -1;
 
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-        throw invalidChar(read$5())
+  while (++index < context.unsafe.length) {
+    const pattern = context.unsafe[index];
 
-    case undefined:
-        throw invalidChar(read$5())
+    if (!patternInScope(context.stack, pattern)) {
+      continue
     }
 
-    return read$5()
-}
+    const expression = patternCompile(pattern);
+    /** @type {RegExpExecArray|null} */
+    let match;
 
-function hexEscape () {
-    let buffer = '';
-    let c = peek();
+    while ((match = expression.exec(value))) {
+      const before = 'before' in pattern || Boolean(pattern.atBreak);
+      const after = 'after' in pattern;
+      const position = match.index + (before ? match[1].length : 0);
 
-    if (!util$1.isHexDigit(c)) {
-        throw invalidChar(read$5())
+      if (positions.includes(position)) {
+        if (infos[position].before && !before) {
+          infos[position].before = false;
+        }
+
+        if (infos[position].after && !after) {
+          infos[position].after = false;
+        }
+      } else {
+        positions.push(position);
+        infos[position] = {before, after};
+      }
     }
+  }
 
-    buffer += read$5();
+  positions.sort(numerical);
 
-    c = peek();
-    if (!util$1.isHexDigit(c)) {
-        throw invalidChar(read$5())
-    }
+  let start = config.before ? config.before.length : 0;
+  const end = value.length - (config.after ? config.after.length : 0);
+  index = -1;
 
-    buffer += read$5();
+  while (++index < positions.length) {
+    const position = positions[index];
 
-    return String.fromCodePoint(parseInt(buffer, 16))
-}
+    // Character before or after matched:
+    if (position < start || position >= end) {
+      continue
+    }
 
-function unicodeEscape () {
-    let buffer = '';
-    let count = 4;
+    // If this character is supposed to be escaped because it has a condition on
+    // the next character, and the next character is definitly being escaped,
+    // then skip this escape.
+    if (
+      position + 1 < end &&
+      positions[index + 1] === position + 1 &&
+      infos[position].after &&
+      !infos[position + 1].before &&
+      !infos[position + 1].after
+    ) {
+      continue
+    }
 
-    while (count-- > 0) {
-        const c = peek();
-        if (!util$1.isHexDigit(c)) {
-            throw invalidChar(read$5())
-        }
+    if (start !== position) {
+      // If we have to use a character reference, an ampersand would be more
+      // correct, but as backslashes only care about punctuation, either will
+      // do the trick
+      result.push(escapeBackslashes(value.slice(start, position), '\\'));
+    }
 
-        buffer += read$5();
+    start = position;
+
+    if (
+      /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&
+      (!config.encode || !config.encode.includes(value.charAt(position)))
+    ) {
+      // Character escape.
+      result.push('\\');
+    } else {
+      // Character reference.
+      result.push(
+        '&#x' + value.charCodeAt(position).toString(16).toUpperCase() + ';'
+      );
+      start++;
     }
+  }
 
-    return String.fromCodePoint(parseInt(buffer, 16))
+  result.push(escapeBackslashes(value.slice(start, end), config.after));
+
+  return result.join('')
 }
 
-const parseStates = {
-    start () {
-        if (token.type === 'eof') {
-            throw invalidEOF()
-        }
+/**
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function numerical(a, b) {
+  return a - b
+}
 
-        push();
-    },
+/**
+ * @param {string} value
+ * @param {string} after
+ * @returns {string}
+ */
+function escapeBackslashes(value, after) {
+  const expression = /\\(?=[!-/:-@[-`{-~])/g;
+  /** @type {Array.<number>} */
+  const positions = [];
+  /** @type {Array.<string>} */
+  const results = [];
+  const whole = value + after;
+  let index = -1;
+  let start = 0;
+  /** @type {RegExpExecArray|null} */
+  let match;
 
-    beforePropertyName () {
-        switch (token.type) {
-        case 'identifier':
-        case 'string':
-            key = token.value;
-            parseState = 'afterPropertyName';
-            return
+  while ((match = expression.exec(whole))) {
+    positions.push(match.index);
+  }
 
-        case 'punctuator':
-            // This code is unreachable since it's handled by the lexState.
-            // if (token.value !== '}') {
-            //     throw invalidToken()
-            // }
+  while (++index < positions.length) {
+    if (start !== positions[index]) {
+      results.push(value.slice(start, positions[index]));
+    }
 
-            pop();
-            return
+    results.push('\\');
+    start = positions[index];
+  }
 
-        case 'eof':
-            throw invalidEOF()
-        }
+  results.push(value.slice(start));
 
-        // This code is unreachable since it's handled by the lexState.
-        // throw invalidToken()
-    },
+  return results.join('')
+}
 
-    afterPropertyName () {
-        // This code is unreachable since it's handled by the lexState.
-        // if (token.type !== 'punctuator' || token.value !== ':') {
-        //     throw invalidToken()
-        // }
+/**
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../types.js').Exit} Exit
+ * @typedef {import('../util/indent-lines.js').Map} Map
+ */
 
-        if (token.type === 'eof') {
-            throw invalidEOF()
-        }
+/**
+ * @type {Handle}
+ * @param {Code} node
+ */
+function code$1(node, _, context) {
+  const marker = checkFence(context);
+  const raw = node.value || '';
+  const suffix = marker === '`' ? 'GraveAccent' : 'Tilde';
+  /** @type {string} */
+  let value;
+  /** @type {Exit} */
+  let exit;
 
-        parseState = 'beforePropertyValue';
-    },
+  if (formatCodeAsIndented(node, context)) {
+    exit = context.enter('codeIndented');
+    value = indentLines(raw, map);
+  } else {
+    const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
+    /** @type {Exit} */
+    let subexit;
+    exit = context.enter('codeFenced');
+    value = sequence;
+
+    if (node.lang) {
+      subexit = context.enter('codeFencedLang' + suffix);
+      value += safe(context, node.lang, {
+        before: '`',
+        after: ' ',
+        encode: ['`']
+      });
+      subexit();
+    }
 
-    beforePropertyValue () {
-        if (token.type === 'eof') {
-            throw invalidEOF()
-        }
+    if (node.lang && node.meta) {
+      subexit = context.enter('codeFencedMeta' + suffix);
+      value +=
+        ' ' +
+        safe(context, node.meta, {
+          before: ' ',
+          after: '\n',
+          encode: ['`']
+        });
+      subexit();
+    }
 
-        push();
-    },
+    value += '\n';
 
-    beforeArrayValue () {
-        if (token.type === 'eof') {
-            throw invalidEOF()
-        }
+    if (raw) {
+      value += raw + '\n';
+    }
 
-        if (token.type === 'punctuator' && token.value === ']') {
-            pop();
-            return
-        }
+    value += sequence;
+  }
 
-        push();
-    },
+  exit();
+  return value
+}
 
-    afterPropertyValue () {
-        // This code is unreachable since it's handled by the lexState.
-        // if (token.type !== 'punctuator') {
-        //     throw invalidToken()
-        // }
+/** @type {Map} */
+function map(line, _, blank) {
+  return (blank ? '' : '    ') + line
+}
 
-        if (token.type === 'eof') {
-            throw invalidEOF()
-        }
+/**
+ * @typedef {import('mdast').Association} Association
+ */
 
-        switch (token.value) {
-        case ',':
-            parseState = 'beforePropertyName';
-            return
+const characterEscape = /\\([!-/:-@[-`{-~])/g;
+const characterReference = /&(#(\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
 
-        case '}':
-            pop();
-        }
+/**
+ * The `label` of an association is the string value: character escapes and
+ * references work, and casing is intact.
+ * The `identifier` is used to match one association to another: controversially,
+ * character escapes and references don’t work in this matching: `&copy;` does
+ * not match `©`, and `\+` does not match `+`.
+ * But casing is ignored (and whitespace) is trimmed and collapsed: ` A\nb`
+ * matches `a b`.
+ * So, we do prefer the label when figuring out how we’re going to serialize:
+ * it has whitespace, casing, and we can ignore most useless character escapes
+ * and all character references.
+ *
+ * @param {Association} node
+ * @returns {string}
+ */
+function association(node) {
+  if (node.label || !node.identifier) {
+    return node.label || ''
+  }
 
-        // This code is unreachable since it's handled by the lexState.
-        // throw invalidToken()
-    },
+  return node.identifier
+    .replace(characterEscape, '$1')
+    .replace(characterReference, decodeIfPossible)
+}
 
-    afterArrayValue () {
-        // This code is unreachable since it's handled by the lexState.
-        // if (token.type !== 'punctuator') {
-        //     throw invalidToken()
-        // }
+/**
+ * @param {string} $0
+ * @param {string} $1
+ * @returns {string}
+ */
+function decodeIfPossible($0, $1) {
+  return decodeEntity($1) || $0
+}
 
-        if (token.type === 'eof') {
-            throw invalidEOF()
-        }
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
 
-        switch (token.value) {
-        case ',':
-            parseState = 'beforeArrayValue';
-            return
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['quote'], undefined>}
+ */
+function checkQuote(context) {
+  const marker = context.options.quote || '"';
 
-        case ']':
-            pop();
-        }
+  if (marker !== '"' && marker !== "'") {
+    throw new Error(
+      'Cannot serialize title with `' +
+        marker +
+        '` for `options.quote`, expected `"`, or `\'`'
+    )
+  }
 
-        // This code is unreachable since it's handled by the lexState.
-        // throw invalidToken()
-    },
+  return marker
+}
 
-    end () {
-        // This code is unreachable since it's handled by the lexState.
-        // if (token.type !== 'eof') {
-        //     throw invalidToken()
-        // }
-    },
-};
+/**
+ * @typedef {import('mdast').Definition} Definition
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-function push () {
-    let value;
+/**
+ * @type {Handle}
+ * @param {Definition} node
+ */
+function definition(node, _, context) {
+  const marker = checkQuote(context);
+  const suffix = marker === '"' ? 'Quote' : 'Apostrophe';
+  const exit = context.enter('definition');
+  let subexit = context.enter('label');
+  let value =
+    '[' + safe(context, association(node), {before: '[', after: ']'}) + ']: ';
 
-    switch (token.type) {
-    case 'punctuator':
-        switch (token.value) {
-        case '{':
-            value = {};
-            break
+  subexit();
 
-        case '[':
-            value = [];
-            break
-        }
+  if (
+    // If there’s no url, or…
+    !node.url ||
+    // If there’s whitespace, enclosed is prettier.
+    /[ \t\r\n]/.test(node.url)
+  ) {
+    subexit = context.enter('destinationLiteral');
+    value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>';
+  } else {
+    // No whitespace, raw is prettier.
+    subexit = context.enter('destinationRaw');
+    value += safe(context, node.url, {before: ' ', after: ' '});
+  }
 
-        break
+  subexit();
 
-    case 'null':
-    case 'boolean':
-    case 'numeric':
-    case 'string':
-        value = token.value;
-        break
+  if (node.title) {
+    subexit = context.enter('title' + suffix);
+    value +=
+      ' ' +
+      marker +
+      safe(context, node.title, {before: marker, after: marker}) +
+      marker;
+    subexit();
+  }
 
-    // This code is unreachable.
-    // default:
-    //     throw invalidToken()
-    }
+  exit();
 
-    if (root === undefined) {
-        root = value;
-    } else {
-        const parent = stack[stack.length - 1];
-        if (Array.isArray(parent)) {
-            parent.push(value);
-        } else {
-            parent[key] = value;
-        }
-    }
+  return value
+}
 
-    if (value !== null && typeof value === 'object') {
-        stack.push(value);
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
+
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['emphasis'], undefined>}
+ */
+function checkEmphasis(context) {
+  const marker = context.options.emphasis || '*';
+
+  if (marker !== '*' && marker !== '_') {
+    throw new Error(
+      'Cannot serialize emphasis with `' +
+        marker +
+        '` for `options.emphasis`, expected `*`, or `_`'
+    )
+  }
 
-        if (Array.isArray(value)) {
-            parseState = 'beforeArrayValue';
-        } else {
-            parseState = 'beforePropertyName';
-        }
-    } else {
-        const current = stack[stack.length - 1];
-        if (current == null) {
-            parseState = 'end';
-        } else if (Array.isArray(current)) {
-            parseState = 'afterArrayValue';
-        } else {
-            parseState = 'afterPropertyValue';
-        }
-    }
+  return marker
 }
 
-function pop () {
-    stack.pop();
+/**
+ * @typedef {import('../types.js').Node} Node
+ * @typedef {import('../types.js').Parent} Parent
+ * @typedef {import('../types.js').SafeOptions} SafeOptions
+ * @typedef {import('../types.js').Context} Context
+ */
 
-    const current = stack[stack.length - 1];
-    if (current == null) {
-        parseState = 'end';
-    } else if (Array.isArray(current)) {
-        parseState = 'afterArrayValue';
+/**
+ * @param {Parent} parent
+ * @param {Context} context
+ * @param {SafeOptions} safeOptions
+ * @returns {string}
+ */
+function containerPhrasing(parent, context, safeOptions) {
+  const children = parent.children || [];
+  /** @type {Array.<string>} */
+  const results = [];
+  let index = -1;
+  let before = safeOptions.before;
+
+  while (++index < children.length) {
+    const child = children[index];
+    /** @type {string} */
+    let after;
+
+    if (index + 1 < children.length) {
+      // @ts-expect-error: hush, it’s actually a `zwitch`.
+      let handle = context.handle.handlers[children[index + 1].type];
+      if (handle && handle.peek) handle = handle.peek;
+      after = handle
+        ? handle(children[index + 1], parent, context, {
+            before: '',
+            after: ''
+          }).charAt(0)
+        : '';
     } else {
-        parseState = 'afterPropertyValue';
+      after = safeOptions.after;
     }
-}
 
-// This code is unreachable.
-// function invalidParseState () {
-//     return new Error(`JSON5: invalid parse state '${parseState}'`)
-// }
+    // In some cases, html (text) can be found in phrasing right after an eol.
+    // When we’d serialize that, in most cases that would be seen as html
+    // (flow).
+    // As we can’t escape or so to prevent it from happening, we take a somewhat
+    // reasonable approach: replace that eol with a space.
+    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>
+    if (
+      results.length > 0 &&
+      (before === '\r' || before === '\n') &&
+      child.type === 'html'
+    ) {
+      results[results.length - 1] = results[results.length - 1].replace(
+        /(\r?\n|\r)$/,
+        ' '
+      );
+      before = ' ';
+    }
 
-// This code is unreachable.
-// function invalidLexState (state) {
-//     return new Error(`JSON5: invalid lex state '${state}'`)
-// }
+    results.push(context.handle(child, parent, context, {before, after}));
 
-function invalidChar (c) {
-    if (c === undefined) {
-        return syntaxError$1(`JSON5: invalid end of input at ${line}:${column}`)
-    }
+    before = results[results.length - 1].slice(-1);
+  }
 
-    return syntaxError$1(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
+  return results.join('')
 }
 
-function invalidEOF () {
-    return syntaxError$1(`JSON5: invalid end of input at ${line}:${column}`)
-}
+/**
+ * @typedef {import('mdast').Emphasis} Emphasis
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-// This code is unreachable.
-// function invalidToken () {
-//     if (token.type === 'eof') {
-//         return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
-//     }
+emphasis.peek = emphasisPeek;
 
-//     const c = String.fromCodePoint(token.value.codePointAt(0))
-//     return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
-// }
+// To do: there are cases where emphasis cannot “form” depending on the
+// previous or next character of sequences.
+// There’s no way around that though, except for injecting zero-width stuff.
+// Do we need to safeguard against that?
+/**
+ * @type {Handle}
+ * @param {Emphasis} node
+ */
+function emphasis(node, _, context) {
+  const marker = checkEmphasis(context);
+  const exit = context.enter('emphasis');
+  const value = containerPhrasing(node, context, {
+    before: marker,
+    after: marker
+  });
+  exit();
+  return marker + value + marker
+}
 
-function invalidIdentifier () {
-    column -= 5;
-    return syntaxError$1(`JSON5: invalid identifier character at ${line}:${column}`)
+/**
+ * @type {Handle}
+ * @param {Emphasis} _
+ */
+function emphasisPeek(_, _1, context) {
+  return context.options.emphasis || '*'
 }
 
-function separatorChar (c) {
-    console.warn(`JSON5: '${formatChar(c)}' in strings is not valid ECMAScript; consider escaping`);
+/**
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('../types.js').Context} Context
+ */
+
+/**
+ * @param {Heading} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function formatHeadingAsSetext(node, context) {
+  return Boolean(
+    context.options.setext && (!node.depth || node.depth < 3) && toString(node)
+  )
 }
 
-function formatChar (c) {
-    const replacements = {
-        "'": "\\'",
-        '"': '\\"',
-        '\\': '\\\\',
-        '\b': '\\b',
-        '\f': '\\f',
-        '\n': '\\n',
-        '\r': '\\r',
-        '\t': '\\t',
-        '\v': '\\v',
-        '\0': '\\0',
-        '\u2028': '\\u2028',
-        '\u2029': '\\u2029',
-    };
+/**
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../types.js').Exit} Exit
+ */
 
-    if (replacements[c]) {
-        return replacements[c]
-    }
+/**
+ * @type {Handle}
+ * @param {Heading} node
+ */
+function heading(node, _, context) {
+  const rank = Math.max(Math.min(6, node.depth || 1), 1);
+  /** @type {Exit} */
+  let exit;
+  /** @type {Exit} */
+  let subexit;
+  /** @type {string} */
+  let value;
 
-    if (c < ' ') {
-        const hexString = c.charCodeAt(0).toString(16);
-        return '\\x' + ('00' + hexString).substring(hexString.length)
-    }
+  if (formatHeadingAsSetext(node, context)) {
+    exit = context.enter('headingSetext');
+    subexit = context.enter('phrasing');
+    value = containerPhrasing(node, context, {before: '\n', after: '\n'});
+    subexit();
+    exit();
 
-    return c
-}
+    return (
+      value +
+      '\n' +
+      (rank === 1 ? '=' : '-').repeat(
+        // The whole size…
+        value.length -
+          // Minus the position of the character after the last EOL (or
+          // 0 if there is none)…
+          (Math.max(value.lastIndexOf('\r'), value.lastIndexOf('\n')) + 1)
+      )
+    )
+  }
 
-function syntaxError$1 (message) {
-    const err = new SyntaxError(message);
-    err.lineNumber = line;
-    err.columnNumber = column;
-    return err
-}
+  const sequence = '#'.repeat(rank);
+  exit = context.enter('headingAtx');
+  subexit = context.enter('phrasing');
+  value = containerPhrasing(node, context, {before: '# ', after: '\n'});
+  value = value ? sequence + ' ' + value : sequence;
+  if (context.options.closeAtx) {
+    value += ' ' + sequence;
+  }
 
-var stringify$5 = function stringify (value, replacer, space) {
-    const stack = [];
-    let indent = '';
-    let propertyList;
-    let replacerFunc;
-    let gap = '';
-    let quote;
+  subexit();
+  exit();
 
-    if (
-        replacer != null &&
-        typeof replacer === 'object' &&
-        !Array.isArray(replacer)
-    ) {
-        space = replacer.space;
-        quote = replacer.quote;
-        replacer = replacer.replacer;
-    }
+  return value
+}
 
-    if (typeof replacer === 'function') {
-        replacerFunc = replacer;
-    } else if (Array.isArray(replacer)) {
-        propertyList = [];
-        for (const v of replacer) {
-            let item;
+/**
+ * @typedef {import('mdast').HTML} HTML
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-            if (typeof v === 'string') {
-                item = v;
-            } else if (
-                typeof v === 'number' ||
-                v instanceof String ||
-                v instanceof Number
-            ) {
-                item = String(v);
-            }
+html.peek = htmlPeek;
 
-            if (item !== undefined && propertyList.indexOf(item) < 0) {
-                propertyList.push(item);
-            }
-        }
-    }
+/**
+ * @type {Handle}
+ * @param {HTML} node
+ */
+function html(node) {
+  return node.value || ''
+}
 
-    if (space instanceof Number) {
-        space = Number(space);
-    } else if (space instanceof String) {
-        space = String(space);
-    }
+/**
+ * @type {Handle}
+ */
+function htmlPeek() {
+  return '<'
+}
 
-    if (typeof space === 'number') {
-        if (space > 0) {
-            space = Math.min(10, Math.floor(space));
-            gap = '          '.substr(0, space);
-        }
-    } else if (typeof space === 'string') {
-        gap = space.substr(0, 10);
-    }
+/**
+ * @typedef {import('mdast').Image} Image
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-    return serializeProperty('', {'': value})
+image.peek = imagePeek;
 
-    function serializeProperty (key, holder) {
-        let value = holder[key];
-        if (value != null) {
-            if (typeof value.toJSON5 === 'function') {
-                value = value.toJSON5(key);
-            } else if (typeof value.toJSON === 'function') {
-                value = value.toJSON(key);
-            }
-        }
+/**
+ * @type {Handle}
+ * @param {Image} node
+ */
+function image(node, _, context) {
+  const quote = checkQuote(context);
+  const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
+  const exit = context.enter('image');
+  let subexit = context.enter('label');
+  let value = '![' + safe(context, node.alt, {before: '[', after: ']'}) + '](';
 
-        if (replacerFunc) {
-            value = replacerFunc.call(holder, key, value);
-        }
+  subexit();
 
-        if (value instanceof Number) {
-            value = Number(value);
-        } else if (value instanceof String) {
-            value = String(value);
-        } else if (value instanceof Boolean) {
-            value = value.valueOf();
-        }
+  if (
+    // If there’s no url but there is a title…
+    (!node.url && node.title) ||
+    // Or if there’s markdown whitespace or an eol, enclose.
+    /[ \t\r\n]/.test(node.url)
+  ) {
+    subexit = context.enter('destinationLiteral');
+    value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>';
+  } else {
+    // No whitespace, raw is prettier.
+    subexit = context.enter('destinationRaw');
+    value += safe(context, node.url, {
+      before: '(',
+      after: node.title ? ' ' : ')'
+    });
+  }
 
-        switch (value) {
-        case null: return 'null'
-        case true: return 'true'
-        case false: return 'false'
-        }
+  subexit();
 
-        if (typeof value === 'string') {
-            return quoteString(value)
-        }
+  if (node.title) {
+    subexit = context.enter('title' + suffix);
+    value +=
+      ' ' +
+      quote +
+      safe(context, node.title, {before: quote, after: quote}) +
+      quote;
+    subexit();
+  }
 
-        if (typeof value === 'number') {
-            return String(value)
-        }
+  value += ')';
+  exit();
 
-        if (typeof value === 'object') {
-            return Array.isArray(value) ? serializeArray(value) : serializeObject(value)
-        }
+  return value
+}
 
-        return undefined
-    }
+/**
+ * @type {Handle}
+ */
+function imagePeek() {
+  return '!'
+}
 
-    function quoteString (value) {
-        const quotes = {
-            "'": 0.1,
-            '"': 0.2,
-        };
+/**
+ * @typedef {import('mdast').ImageReference} ImageReference
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-        const replacements = {
-            "'": "\\'",
-            '"': '\\"',
-            '\\': '\\\\',
-            '\b': '\\b',
-            '\f': '\\f',
-            '\n': '\\n',
-            '\r': '\\r',
-            '\t': '\\t',
-            '\v': '\\v',
-            '\0': '\\0',
-            '\u2028': '\\u2028',
-            '\u2029': '\\u2029',
-        };
+imageReference.peek = imageReferencePeek;
 
-        let product = '';
+/**
+ * @type {Handle}
+ * @param {ImageReference} node
+ */
+function imageReference(node, _, context) {
+  const type = node.referenceType;
+  const exit = context.enter('imageReference');
+  let subexit = context.enter('label');
+  const alt = safe(context, node.alt, {before: '[', after: ']'});
+  let value = '![' + alt + ']';
+
+  subexit();
+  // Hide the fact that we’re in phrasing, because escapes don’t work.
+  const stack = context.stack;
+  context.stack = [];
+  subexit = context.enter('reference');
+  const reference = safe(context, association(node), {before: '[', after: ']'});
+  subexit();
+  context.stack = stack;
+  exit();
 
-        for (let i = 0; i < value.length; i++) {
-            const c = value[i];
-            switch (c) {
-            case "'":
-            case '"':
-                quotes[c]++;
-                product += c;
-                continue
+  if (type === 'full' || !alt || alt !== reference) {
+    value += '[' + reference + ']';
+  } else if (type !== 'shortcut') {
+    value += '[]';
+  }
 
-            case '\0':
-                if (util$1.isDigit(value[i + 1])) {
-                    product += '\\x00';
-                    continue
-                }
-            }
+  return value
+}
 
-            if (replacements[c]) {
-                product += replacements[c];
-                continue
-            }
+/**
+ * @type {Handle}
+ */
+function imageReferencePeek() {
+  return '!'
+}
 
-            if (c < ' ') {
-                let hexString = c.charCodeAt(0).toString(16);
-                product += '\\x' + ('00' + hexString).substring(hexString.length);
-                continue
-            }
+/**
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-            product += c;
-        }
+inlineCode.peek = inlineCodePeek;
 
-        const quoteChar = quote || Object.keys(quotes).reduce((a, b) => (quotes[a] < quotes[b]) ? a : b);
+/**
+ * @type {Handle}
+ * @param {InlineCode} node
+ */
+function inlineCode(node, _, context) {
+  let value = node.value || '';
+  let sequence = '`';
+  let index = -1;
 
-        product = product.replace(new RegExp(quoteChar, 'g'), replacements[quoteChar]);
+  // If there is a single grave accent on its own in the code, use a fence of
+  // two.
+  // If there are two in a row, use one.
+  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {
+    sequence += '`';
+  }
 
-        return quoteChar + product + quoteChar
+  // If this is not just spaces or eols (tabs don’t count), and either the
+  // first or last character are a space, eol, or tick, then pad with spaces.
+  if (
+    /[^ \r\n]/.test(value) &&
+    ((/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value)) || /^`|`$/.test(value))
+  ) {
+    value = ' ' + value + ' ';
+  }
+
+  // We have a potential problem: certain characters after eols could result in
+  // blocks being seen.
+  // For example, if someone injected the string `'\n# b'`, then that would
+  // result in an ATX heading.
+  // We can’t escape characters in `inlineCode`, but because eols are
+  // transformed to spaces when going from markdown to HTML anyway, we can swap
+  // them out.
+  while (++index < context.unsafe.length) {
+    const pattern = context.unsafe[index];
+    const expression = patternCompile(pattern);
+    /** @type {RegExpExecArray|null} */
+    let match;
+
+    // Only look for `atBreak`s.
+    // Btw: note that `atBreak` patterns will always start the regex at LF or
+    // CR.
+    if (!pattern.atBreak) continue
+
+    while ((match = expression.exec(value))) {
+      let position = match.index;
+
+      // Support CRLF (patterns only look for one of the characters).
+      if (
+        value.charCodeAt(position) === 10 /* `\n` */ &&
+        value.charCodeAt(position - 1) === 13 /* `\r` */
+      ) {
+        position--;
+      }
+
+      value = value.slice(0, position) + ' ' + value.slice(match.index + 1);
     }
+  }
 
-    function serializeObject (value) {
-        if (stack.indexOf(value) >= 0) {
-            throw TypeError('Converting circular structure to JSON5')
-        }
+  return sequence + value + sequence
+}
 
-        stack.push(value);
+/**
+ * @type {Handle}
+ */
+function inlineCodePeek() {
+  return '`'
+}
 
-        let stepback = indent;
-        indent = indent + gap;
+/**
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('../types.js').Context} Context
+ */
 
-        let keys = propertyList || Object.keys(value);
-        let partial = [];
-        for (const key of keys) {
-            const propertyString = serializeProperty(key, value);
-            if (propertyString !== undefined) {
-                let member = serializeKey(key) + ':';
-                if (gap !== '') {
-                    member += ' ';
-                }
-                member += propertyString;
-                partial.push(member);
-            }
-        }
+/**
+ * @param {Link} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function formatLinkAsAutolink(node, context) {
+  const raw = toString(node);
+
+  return Boolean(
+    !context.options.resourceLink &&
+      // If there’s a url…
+      node.url &&
+      // And there’s a no title…
+      !node.title &&
+      // And the content of `node` is a single text node…
+      node.children &&
+      node.children.length === 1 &&
+      node.children[0].type === 'text' &&
+      // And if the url is the same as the content…
+      (raw === node.url || 'mailto:' + raw === node.url) &&
+      // And that starts w/ a protocol…
+      /^[a-z][a-z+.-]+:/i.test(node.url) &&
+      // And that doesn’t contain ASCII control codes (character escapes and
+      // references don’t work) or angle brackets…
+      !/[\0- <>\u007F]/.test(node.url)
+  )
+}
 
-        let final;
-        if (partial.length === 0) {
-            final = '{}';
-        } else {
-            let properties;
-            if (gap === '') {
-                properties = partial.join(',');
-                final = '{' + properties + '}';
-            } else {
-                let separator = ',\n' + indent;
-                properties = partial.join(separator);
-                final = '{\n' + indent + properties + ',\n' + stepback + '}';
-            }
-        }
+/**
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../types.js').Exit} Exit
+ */
 
-        stack.pop();
-        indent = stepback;
-        return final
-    }
+link.peek = linkPeek;
 
-    function serializeKey (key) {
-        if (key.length === 0) {
-            return quoteString(key)
-        }
+/**
+ * @type {Handle}
+ * @param {Link} node
+ */
+function link(node, _, context) {
+  const quote = checkQuote(context);
+  const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
+  /** @type {Exit} */
+  let exit;
+  /** @type {Exit} */
+  let subexit;
+  /** @type {string} */
+  let value;
 
-        const firstChar = String.fromCodePoint(key.codePointAt(0));
-        if (!util$1.isIdStartChar(firstChar)) {
-            return quoteString(key)
-        }
+  if (formatLinkAsAutolink(node, context)) {
+    // Hide the fact that we’re in phrasing, because escapes don’t work.
+    const stack = context.stack;
+    context.stack = [];
+    exit = context.enter('autolink');
+    value =
+      '<' + containerPhrasing(node, context, {before: '<', after: '>'}) + '>';
+    exit();
+    context.stack = stack;
+    return value
+  }
 
-        for (let i = firstChar.length; i < key.length; i++) {
-            if (!util$1.isIdContinueChar(String.fromCodePoint(key.codePointAt(i)))) {
-                return quoteString(key)
-            }
-        }
+  exit = context.enter('link');
+  subexit = context.enter('label');
+  value =
+    '[' + containerPhrasing(node, context, {before: '[', after: ']'}) + '](';
+  subexit();
 
-        return key
-    }
+  if (
+    // If there’s no url but there is a title…
+    (!node.url && node.title) ||
+    // Or if there’s markdown whitespace or an eol, enclose.
+    /[ \t\r\n]/.test(node.url)
+  ) {
+    subexit = context.enter('destinationLiteral');
+    value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>';
+  } else {
+    // No whitespace, raw is prettier.
+    subexit = context.enter('destinationRaw');
+    value += safe(context, node.url, {
+      before: '(',
+      after: node.title ? ' ' : ')'
+    });
+  }
 
-    function serializeArray (value) {
-        if (stack.indexOf(value) >= 0) {
-            throw TypeError('Converting circular structure to JSON5')
-        }
+  subexit();
 
-        stack.push(value);
+  if (node.title) {
+    subexit = context.enter('title' + suffix);
+    value +=
+      ' ' +
+      quote +
+      safe(context, node.title, {before: quote, after: quote}) +
+      quote;
+    subexit();
+  }
 
-        let stepback = indent;
-        indent = indent + gap;
+  value += ')';
 
-        let partial = [];
-        for (let i = 0; i < value.length; i++) {
-            const propertyString = serializeProperty(String(i), value);
-            partial.push((propertyString !== undefined) ? propertyString : 'null');
-        }
+  exit();
+  return value
+}
 
-        let final;
-        if (partial.length === 0) {
-            final = '[]';
-        } else {
-            if (gap === '') {
-                let properties = partial.join(',');
-                final = '[' + properties + ']';
-            } else {
-                let separator = ',\n' + indent;
-                let properties = partial.join(separator);
-                final = '[\n' + indent + properties + ',\n' + stepback + ']';
-            }
-        }
+/**
+ * @type {Handle}
+ * @param {Link} node
+ */
+function linkPeek(node, _, context) {
+  return formatLinkAsAutolink(node, context) ? '<' : '['
+}
 
-        stack.pop();
-        indent = stepback;
-        return final
-    }
-};
+/**
+ * @typedef {import('mdast').LinkReference} LinkReference
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-const JSON5 = {
-    parse: parse$7,
-    stringify: stringify$5,
-};
+linkReference.peek = linkReferencePeek;
 
-var lib$5 = JSON5;
+/**
+ * @type {Handle}
+ * @param {LinkReference} node
+ */
+function linkReference(node, _, context) {
+  const type = node.referenceType;
+  const exit = context.enter('linkReference');
+  let subexit = context.enter('label');
+  const text = containerPhrasing(node, context, {before: '[', after: ']'});
+  let value = '[' + text + ']';
+
+  subexit();
+  // Hide the fact that we’re in phrasing, because escapes don’t work.
+  const stack = context.stack;
+  context.stack = [];
+  subexit = context.enter('reference');
+  const reference = safe(context, association(node), {before: '[', after: ']'});
+  subexit();
+  context.stack = stack;
+  exit();
 
-var dist$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': lib$5
-});
+  if (type === 'full' || !text || text !== reference) {
+    value += '[' + reference + ']';
+  } else if (type !== 'shortcut') {
+    value += '[]';
+  }
 
-var schema$1 = [
-	{
-		long: "help",
-		description: "output usage information",
-		short: "h",
-		type: "boolean",
-		"default": false
-	},
-	{
-		long: "version",
-		description: "output version number",
-		short: "v",
-		type: "boolean",
-		"default": false
-	},
-	{
-		long: "output",
-		description: "specify output location",
-		short: "o",
-		value: "[path]"
-	},
-	{
-		long: "rc-path",
-		description: "specify configuration file",
-		short: "r",
-		type: "string",
-		value: "<path>"
-	},
-	{
-		long: "ignore-path",
-		description: "specify ignore file",
-		short: "i",
-		type: "string",
-		value: "<path>"
-	},
-	{
-		long: "setting",
-		description: "specify settings",
-		short: "s",
-		type: "string",
-		value: "<settings>"
-	},
-	{
-		long: "ext",
-		description: "specify extensions",
-		short: "e",
-		type: "string",
-		value: "<extensions>"
-	},
-	{
-		long: "use",
-		description: "use plugins",
-		short: "u",
-		type: "string",
-		value: "<plugins>"
-	},
-	{
-		long: "watch",
-		description: "watch for changes and reprocess",
-		short: "w",
-		type: "boolean",
-		"default": false
-	},
-	{
-		long: "quiet",
-		description: "output only warnings and errors",
-		short: "q",
-		type: "boolean",
-		"default": false
-	},
-	{
-		long: "silent",
-		description: "output only errors",
-		short: "S",
-		type: "boolean",
-		"default": false
-	},
-	{
-		long: "frail",
-		description: "exit with 1 on warnings",
-		short: "f",
-		type: "boolean",
-		"default": false
-	},
-	{
-		long: "tree",
-		description: "specify input and output as syntax tree",
-		short: "t",
-		type: "boolean",
-		"default": false
-	},
-	{
-		long: "report",
-		description: "specify reporter",
-		type: "string",
-		value: "<reporter>"
-	},
-	{
-		long: "file-path",
-		description: "specify path to process as",
-		type: "string",
-		value: "<path>"
-	},
-	{
-		long: "ignore-path-resolve-from",
-		description: "resolve patterns in `ignore-path` from its directory or cwd",
-		type: "string",
-		value: "dir|cwd",
-		"default": "dir"
-	},
-	{
-		long: "ignore-pattern",
-		description: "specify ignore patterns",
-		type: "string",
-		value: "<globs>"
-	},
-	{
-		long: "tree-in",
-		description: "specify input as syntax tree",
-		type: "boolean"
-	},
-	{
-		long: "tree-out",
-		description: "output syntax tree",
-		type: "boolean"
-	},
-	{
-		long: "inspect",
-		description: "output formatted syntax tree",
-		type: "boolean"
-	},
-	{
-		long: "stdout",
-		description: "specify writing to stdout",
-		type: "boolean",
-		truelike: true
-	},
-	{
-		long: "color",
-		description: "specify color in report",
-		type: "boolean",
-		"default": true
-	},
-	{
-		long: "config",
-		description: "search for configuration files",
-		type: "boolean",
-		"default": true
-	},
-	{
-		long: "ignore",
-		description: "search for ignore files",
-		type: "boolean",
-		"default": true
-	}
-];
+  return value
+}
 
-var schema$2 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': schema$1
-});
+/**
+ * @type {Handle}
+ */
+function linkReferencePeek() {
+  return '['
+}
 
-var json5 = getCjsExportFromNamespace(dist$1);
+/**
+ * @typedef {import('mdast').List} List
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-var schema$3 = getCjsExportFromNamespace(schema$2);
+/**
+ * @type {Handle}
+ * @param {List} node
+ */
+function list(node, _, context) {
+  const exit = context.enter('list');
+  const value = containerFlow(node, context);
+  exit();
+  return value
+}
 
-var options_1 = options;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
 
-// Schema for `minimist`.
-var minischema = {
-  unknown: handleUnknownArgument,
-  default: {},
-  alias: {},
-  string: [],
-  boolean: []
-};
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['bullet'], undefined>}
+ */
+function checkBullet(context) {
+  const marker = context.options.bullet || '*';
 
-schema$3.forEach(addEach);
+  if (marker !== '*' && marker !== '+' && marker !== '-') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        marker +
+        '` for `options.bullet`, expected `*`, `+`, or `-`'
+    )
+  }
 
-// Parse CLI options.
-function options(flags, configuration) {
-  var extension = configuration.extensions[0];
-  var name = configuration.name;
-  var config = toCamelCase(minimist(flags, minischema));
-  var help;
-  var ext;
-  var report;
-
-  schema$3.forEach(function (option) {
-    if (option.type === 'string' && config[option.long] === '') {
-      throw fault_1('Missing value:%s', inspect$1(option).join(' '))
-    }
-  });
+  return marker
+}
 
-  ext = commaSeparated(config.ext);
-  report = reporter$1(config.report);
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
 
-  help = [
-    inspectAll(schema$3),
-    '',
-    'Examples:',
-    '',
-    '  # Process `input.' + extension + '`',
-    '  $ ' + name + ' input.' + extension + ' -o output.' + extension,
-    '',
-    '  # Pipe',
-    '  $ ' + name + ' < input.' + extension + ' > output.' + extension,
-    '',
-    '  # Rewrite all applicable files',
-    '  $ ' + name + ' . -o'
-  ].join('\n');
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['listItemIndent'], undefined>}
+ */
+function checkListItemIndent(context) {
+  const style = context.options.listItemIndent || 'tab';
 
-  return {
-    helpMessage: help,
-    // “hidden” feature, makes testing easier.
-    cwd: configuration.cwd,
-    processor: configuration.processor,
-    help: config.help,
-    version: config.version,
-    files: config._,
-    filePath: config.filePath,
-    watch: config.watch,
-    extensions: ext.length === 0 ? configuration.extensions : ext,
-    output: config.output,
-    out: config.stdout,
-    tree: config.tree,
-    treeIn: config.treeIn,
-    treeOut: config.treeOut,
-    inspect: config.inspect,
-    rcName: configuration.rcName,
-    packageField: configuration.packageField,
-    rcPath: config.rcPath,
-    detectConfig: config.config,
-    settings: settings(config.setting),
-    ignoreName: configuration.ignoreName,
-    ignorePath: config.ignorePath,
-    ignorePathResolveFrom: config.ignorePathResolveFrom,
-    ignorePatterns: commaSeparated(config.ignorePattern),
-    detectIgnore: config.ignore,
-    pluginPrefix: configuration.pluginPrefix,
-    plugins: plugins(config.use),
-    reporter: report[0],
-    reporterOptions: report[1],
-    color: config.color,
-    silent: config.silent,
-    quiet: config.quiet,
-    frail: config.frail
+  // To do: remove in a major.
+  // @ts-expect-error: deprecated.
+  if (style === 1 || style === '1') {
+    return 'one'
+  }
+
+  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        style +
+        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'
+    )
   }
+
+  return style
 }
 
-function addEach(option) {
-  var value = option.default;
+/**
+ * @typedef {import('mdast').ListItem} ListItem
+ * @typedef {import('mdast').List} List
+ * @typedef {import('../util/indent-lines.js').Map} Map
+ * @typedef {import('../types.js').Options} Options
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-  minischema.default[option.long] = value === undefined ? null : value;
+/**
+ * @type {Handle}
+ * @param {ListItem} node
+ */
+function listItem(node, parent, context) {
+  const listItemIndent = checkListItemIndent(context);
+  /** @type {string} */
+  let bullet = checkBullet(context);
 
-  if (option.type in minischema) {
-    minischema[option.type].push(option.long);
+  if (parent && parent.type === 'list' && parent.ordered) {
+    bullet =
+      (typeof parent.start === 'number' && parent.start > -1
+        ? parent.start
+        : 1) +
+      (context.options.incrementListMarker === false
+        ? 0
+        : parent.children.indexOf(node)) +
+      '.';
   }
 
-  if (option.short) {
-    minischema.alias[option.short] = option.long;
+  let size = bullet.length + 1;
+
+  if (
+    listItemIndent === 'tab' ||
+    (listItemIndent === 'mixed' &&
+      ((parent && 'spread' in parent && parent.spread) || node.spread))
+  ) {
+    size = Math.ceil(size / 4) * 4;
   }
-}
 
-// Parse `extensions`.
-function commaSeparated(value) {
-  return flatten$1(normalize$1(value).map(splitList))
-}
+  const exit = context.enter('listItem');
+  const value = indentLines(containerFlow(node, context), map);
+  exit();
 
-// Parse `plugins`.
-function plugins(value) {
-  var result = {};
+  return value
 
-  normalize$1(value)
-    .map(splitOptions)
-    .forEach(function (value) {
-      result[value[0]] = value[1] ? parseConfig(value[1], {}) : null;
-    });
+  /** @type {Map} */
+  function map(line, index, blank) {
+    if (index) {
+      return (blank ? '' : ' '.repeat(size)) + line
+    }
 
-  return result
+    return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line
+  }
 }
 
-// Parse `reporter`: only one is accepted.
-function reporter$1(value) {
-  var all = normalize$1(value)
-    .map(splitOptions)
-    .map(function (value) {
-      return [value[0], value[1] ? parseConfig(value[1], {}) : null]
-    });
+/**
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-  return all[all.length - 1] || []
+/**
+ * @type {Handle}
+ * @param {Paragraph} node
+ */
+function paragraph(node, _, context) {
+  const exit = context.enter('paragraph');
+  const subexit = context.enter('phrasing');
+  const value = containerPhrasing(node, context, {before: '\n', after: '\n'});
+  subexit();
+  exit();
+  return value
 }
 
-// Parse `settings`.
-function settings(value) {
-  var cache = {};
-
-  normalize$1(value).forEach(function (value) {
-    parseConfig(value, cache);
-  });
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-  return cache
+/**
+ * @type {Handle}
+ * @param {Root} node
+ */
+function root(node, _, context) {
+  return containerFlow(node, context)
 }
 
-// Parse configuration.
-function parseConfig(flags, cache) {
-  var flag;
-  var message;
-
-  try {
-    flags = toCamelCase(parseJSON(flags));
-  } catch (error) {
-    // Fix position
-    message = error.message.replace(/at(?= position)/, 'around');
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
 
-    throw fault_1('Cannot parse `%s` as JSON: %s', flags, message)
-  }
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['strong'], undefined>}
+ */
+function checkStrong(context) {
+  const marker = context.options.strong || '*';
 
-  for (flag in flags) {
-    cache[flag] = flags[flag];
+  if (marker !== '*' && marker !== '_') {
+    throw new Error(
+      'Cannot serialize strong with `' +
+        marker +
+        '` for `options.strong`, expected `*`, or `_`'
+    )
   }
 
-  return cache
+  return marker
 }
 
-// Handle an unknown flag.
-function handleUnknownArgument(flag) {
-  // Glob.
-  if (flag.charAt(0) !== '-') {
-    return
-  }
-
-  // Long options, always unknown.
-  if (flag.charAt(1) === '-') {
-    throw fault_1('Unknown option `%s`, expected:\n%s', flag, inspectAll(schema$3))
-  }
-
-  // Short options, can be grouped.
-  flag.slice(1).split('').forEach(each);
+/**
+ * @typedef {import('mdast').Strong} Strong
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-  function each(key) {
-    var length = schema$3.length;
-    var index = -1;
-    var option;
+strong.peek = strongPeek;
 
-    while (++index < length) {
-      option = schema$3[index];
+// To do: there are cases where emphasis cannot “form” depending on the
+// previous or next character of sequences.
+// There’s no way around that though, except for injecting zero-width stuff.
+// Do we need to safeguard against that?
+/**
+ * @type {Handle}
+ * @param {Strong} node
+ */
+function strong(node, _, context) {
+  const marker = checkStrong(context);
+  const exit = context.enter('strong');
+  const value = containerPhrasing(node, context, {
+    before: marker,
+    after: marker
+  });
+  exit();
+  return marker + marker + value + marker + marker
+}
 
-      if (option.short === key) {
-        return
-      }
-    }
+/**
+ * @type {Handle}
+ * @param {Strong} _
+ */
+function strongPeek(_, _1, context) {
+  return context.options.strong || '*'
+}
 
-    throw fault_1(
-      'Unknown short option `-%s`, expected:\n%s',
-      key,
-      inspectAll(schema$3.filter(short))
-    )
-  }
+/**
+ * @typedef {import('mdast').Text} Text
+ * @typedef {import('../types.js').Handle} Handle
+ */
 
-  function short(option) {
-    return option.short
-  }
+/**
+ * @type {Handle}
+ * @param {Text} node
+ */
+function text$1(node, _, context, safeOptions) {
+  return safe(context, node.value, safeOptions)
 }
 
-// Inspect all `options`.
-function inspectAll(options) {
-  return textTable(options.map(inspect$1))
-}
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
 
-// Inspect one `option`.
-function inspect$1(option) {
-  var description = option.description;
-  var long = option.long;
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['ruleRepetition'], undefined>}
+ */
+function checkRuleRepetition(context) {
+  const repetition = context.options.ruleRepetition || 3;
 
-  if (option.default === true || option.truelike) {
-    description += ' (on by default)';
-    long = '[no-]' + long;
+  if (repetition < 3) {
+    throw new Error(
+      'Cannot serialize rules with repetition `' +
+        repetition +
+        '` for `options.ruleRepetition`, expected `3` or more'
+    )
   }
 
-  return [
-    '',
-    option.short ? '-' + option.short : '',
-    '--' + long + (option.value ? ' ' + option.value : ''),
-    description
-  ]
+  return repetition
 }
 
-// Normalize `value`.
-function normalize$1(value) {
-  if (!value) {
-    return []
-  }
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
 
-  if (typeof value === 'string') {
-    return [value]
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['rule'], undefined>}
+ */
+function checkRule(context) {
+  const marker = context.options.rule || '*';
+
+  if (marker !== '*' && marker !== '-' && marker !== '_') {
+    throw new Error(
+      'Cannot serialize rules with `' +
+        marker +
+        '` for `options.rule`, expected `*`, `-`, or `_`'
+    )
   }
 
-  return flatten$1(value.map(normalize$1))
+  return marker
 }
 
-// Flatten `values`.
-function flatten$1(values) {
-  return [].concat.apply([], values)
-}
+/**
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('mdast').ThematicBreak} ThematicBreak
+ */
 
-function splitOptions(value) {
-  return value.split('=')
-}
+/**
+ * @type {Handle}
+ * @param {ThematicBreak} _
+ */
+function thematicBreak(_, _1, context) {
+  const value = (
+    checkRule(context) + (context.options.ruleSpaces ? ' ' : '')
+  ).repeat(checkRuleRepetition(context));
+
+  return context.options.ruleSpaces ? value.slice(0, -1) : value
+}
+
+const handle = {
+  blockquote,
+  break: hardBreak,
+  code: code$1,
+  definition,
+  emphasis,
+  hardBreak,
+  heading,
+  html,
+  image,
+  imageReference,
+  inlineCode,
+  link,
+  linkReference,
+  list,
+  listItem,
+  paragraph,
+  root,
+  strong,
+  text: text$1,
+  thematicBreak
+};
 
-function splitList(value) {
-  return value.split(',')
-}
+/**
+ * @typedef {import('./types.js').Join} Join
+ */
 
-// Transform the keys on an object to camel-case, recursivly.
-function toCamelCase(object) {
-  var result = {};
-  var value;
-  var key;
+/** @type {Array.<Join>} */
+const join = [joinDefaults];
 
-  for (key in object) {
-    value = object[key];
+/** @type {Join} */
+function joinDefaults(left, right, parent, context) {
+  if (
+    // Two lists with the same marker.
+    (right.type === 'list' &&
+      right.type === left.type &&
+      Boolean(left.ordered) === Boolean(right.ordered)) ||
+    // Indented code after list or another indented code.
+    (right.type === 'code' &&
+      formatCodeAsIndented(right, context) &&
+      (left.type === 'list' ||
+        (left.type === right.type && formatCodeAsIndented(left, context))))
+  ) {
+    return false
+  }
 
-    if (value && typeof value === 'object' && !('length' in value)) {
-      value = toCamelCase(value);
+  // Join children of a list or an item.
+  // In which case, `parent` has a `spread` field.
+  if ('spread' in parent && typeof parent.spread === 'boolean') {
+    if (
+      left.type === 'paragraph' &&
+      // Two paragraphs.
+      (left.type === right.type ||
+        right.type === 'definition' ||
+        // Paragraph followed by a setext heading.
+        (right.type === 'heading' && formatHeadingAsSetext(right, context)))
+    ) {
+      return
     }
 
-    result[camelcase(key)] = value;
+    return parent.spread ? 1 : 0
   }
-
-  return result
 }
 
-// Parse a (lazy?) JSON config.
-function parseJSON(value) {
-  return json5.parse('{' + value + '}')
-}
+/**
+ * @typedef {import('./types.js').Unsafe} Unsafe
+ */
 
-var lib$6 = start;
+/** @type {Array.<Unsafe>} */
+const unsafe = [
+  {
+    character: '\t',
+    inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde']
+  },
+  {
+    character: '\r',
+    inConstruct: [
+      'codeFencedLangGraveAccent',
+      'codeFencedLangTilde',
+      'codeFencedMetaGraveAccent',
+      'codeFencedMetaTilde',
+      'destinationLiteral',
+      'headingAtx'
+    ]
+  },
+  {
+    character: '\n',
+    inConstruct: [
+      'codeFencedLangGraveAccent',
+      'codeFencedLangTilde',
+      'codeFencedMetaGraveAccent',
+      'codeFencedMetaTilde',
+      'destinationLiteral',
+      'headingAtx'
+    ]
+  },
+  {
+    character: ' ',
+    inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde']
+  },
+  // An exclamation mark can start an image, if it is followed by a link or
+  // a link reference.
+  {character: '!', after: '\\[', inConstruct: 'phrasing'},
+  // A quote can break out of a title.
+  {character: '"', inConstruct: 'titleQuote'},
+  // A number sign could start an ATX heading if it starts a line.
+  {atBreak: true, character: '#'},
+  {character: '#', inConstruct: 'headingAtx', after: '(?:[\r\n]|$)'},
+  // Dollar sign and percentage are not used in markdown.
+  // An ampersand could start a character reference.
+  {character: '&', after: '[#A-Za-z]', inConstruct: 'phrasing'},
+  // An apostrophe can break out of a title.
+  {character: "'", inConstruct: 'titleApostrophe'},
+  // A left paren could break out of a destination raw.
+  {character: '(', inConstruct: 'destinationRaw'},
+  {before: '\\]', character: '(', inConstruct: 'phrasing'},
+  // A right paren could start a list item or break out of a destination
+  // raw.
+  {atBreak: true, before: '\\d+', character: ')'},
+  {character: ')', inConstruct: 'destinationRaw'},
+  // An asterisk can start thematic breaks, list items, emphasis, strong.
+  {atBreak: true, character: '*'},
+  {character: '*', inConstruct: 'phrasing'},
+  // A plus sign could start a list item.
+  {atBreak: true, character: '+'},
+  // A dash can start thematic breaks, list items, and setext heading
+  // underlines.
+  {atBreak: true, character: '-'},
+  // A dot could start a list item.
+  {atBreak: true, before: '\\d+', character: '.', after: '(?:[ \t\r\n]|$)'},
+  // Slash, colon, and semicolon are not used in markdown for constructs.
+  // A less than can start html (flow or text) or an autolink.
+  // HTML could start with an exclamation mark (declaration, cdata, comment),
+  // slash (closing tag), question mark (instruction), or a letter (tag).
+  // An autolink also starts with a letter.
+  // Finally, it could break out of a destination literal.
+  {atBreak: true, character: '<', after: '[!/?A-Za-z]'},
+  {character: '<', after: '[!/?A-Za-z]', inConstruct: 'phrasing'},
+  {character: '<', inConstruct: 'destinationLiteral'},
+  // An equals to can start setext heading underlines.
+  {atBreak: true, character: '='},
+  // A greater than can start block quotes and it can break out of a
+  // destination literal.
+  {atBreak: true, character: '>'},
+  {character: '>', inConstruct: 'destinationLiteral'},
+  // Question mark and at sign are not used in markdown for constructs.
+  // A left bracket can start definitions, references, labels,
+  {atBreak: true, character: '['},
+  {character: '[', inConstruct: ['phrasing', 'label', 'reference']},
+  // A backslash can start an escape (when followed by punctuation) or a
+  // hard break (when followed by an eol).
+  // Note: typical escapes are handled in `safe`!
+  {character: '\\', after: '[\\r\\n]', inConstruct: 'phrasing'},
+  // A right bracket can exit labels.
+  {
+    character: ']',
+    inConstruct: ['label', 'reference']
+  },
+  // Caret is not used in markdown for constructs.
+  // An underscore can start emphasis, strong, or a thematic break.
+  {atBreak: true, character: '_'},
+  {before: '[^A-Za-z]', character: '_', inConstruct: 'phrasing'},
+  {character: '_', after: '[^A-Za-z]', inConstruct: 'phrasing'},
+  // A grave accent can start code (fenced or text), or it can break out of
+  // a grave accent code fence.
+  {atBreak: true, character: '`'},
+  {
+    character: '`',
+    inConstruct: [
+      'codeFencedLangGraveAccent',
+      'codeFencedMetaGraveAccent',
+      'phrasing'
+    ]
+  },
+  // Left brace, vertical bar, right brace are not used in markdown for
+  // constructs.
+  // A tilde can start code (fenced).
+  {atBreak: true, character: '~'}
+];
 
-var noop$1 = Function.prototype;
+/**
+ * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').Options} Options
+ * @typedef {import('./types.js').Context} Context
+ * @typedef {import('./types.js').Handle} Handle
+ * @typedef {import('./types.js').Join} Join
+ * @typedef {import('./types.js').Unsafe} Unsafe
+ */
 
-// Fake TTY stream.
-var ttyStream = new stream.Readable();
-ttyStream.isTTY = true;
+/**
+ * @param {Node} tree
+ * @param {Options} [options]
+ * @returns {string}
+ */
+function toMarkdown(tree, options = {}) {
+  /** @type {Context} */
+  // @ts-expect-error: we’ll add `handle` later.
+  const context = {
+    enter,
+    stack: [],
+    unsafe: [],
+    join: [],
+    handlers: {},
+    options: {}
+  };
 
-// Exit, lazily, with the correct exit status code.
-var exitStatus = 0;
+  configure(context, {unsafe, join, handlers: handle});
+  configure(context, options);
 
-process.on('exit', onexit);
+  if (context.options.tightDefinitions) {
+    configure(context, {join: [joinDefinition]});
+  }
 
-// Handle uncaught errors, such as from unexpected async behaviour.
-process.on('uncaughtException', fail$1);
+  /** @type {Handle} */
+  context.handle = zwitch('type', {
+    invalid,
+    // @ts-expect-error: hush.
+    unknown,
+    // @ts-expect-error: hush.
+    handlers: context.handlers
+  });
 
-// Start the CLI.
-function start(cliConfig) {
-  var config;
-  var output;
-  var watcher;
+  let result = context.handle(tree, null, context, {before: '\n', after: '\n'});
 
-  try {
-    config = options_1(process.argv.slice(2), cliConfig);
-  } catch (error) {
-    return fail$1(error, true)
+  if (
+    result &&
+    result.charCodeAt(result.length - 1) !== 10 &&
+    result.charCodeAt(result.length - 1) !== 13
+  ) {
+    result += '\n';
   }
 
-  if (config.help) {
-    process.stdout.write(
-      [
-        'Usage: ' + cliConfig.name + ' [options] [path | glob ...]',
-        '',
-        '  ' + cliConfig.description,
-        '',
-        'Options:',
-        '',
-        config.helpMessage,
-        ''
-      ].join('\n'),
-      noop$1
-    );
+  return result
 
-    return
+  /** @type {Context['enter']} */
+  function enter(name) {
+    context.stack.push(name);
+    return exit
+
+    function exit() {
+      context.stack.pop();
+    }
   }
+}
 
-  if (config.version) {
-    process.stdout.write(cliConfig.version + '\n', noop$1);
+/**
+ * @type {Handle}
+ * @param {unknown} value
+ */
+function invalid(value) {
+  throw new Error('Cannot handle value `' + value + '`, expected node')
+}
 
-    return
+/**
+ * @type {Handle}
+ * @param {Node} node
+ */
+function unknown(node) {
+  throw new Error('Cannot handle unknown node `' + node.type + '`')
+}
+
+/** @type {Join} */
+function joinDefinition(left, right) {
+  // No blank line between adjacent definitions.
+  if (left.type === 'definition' && left.type === right.type) {
+    return 0
   }
+}
 
-  // Modify `config` for watching.
-  if (config.watch) {
-    output = config.output;
+/**
+ * @typedef {import('mdast').Root|import('mdast').Content} Node
+ * @typedef {import('mdast-util-to-markdown').Options} Options
+ */
 
-    // Do not read from stdin(4).
-    config.streamIn = ttyStream;
+/** @type {import('unified').Plugin<[Options]|void[], Node, string>} */
+function remarkStringify(options) {
+  /** @type {import('unified').CompilerFunction<Node, string>} */
+  const compiler = (tree) => {
+    // Assume options.
+    const settings = /** @type {Options} */ (this.data('settings'));
+
+    return toMarkdown(
+      tree,
+      Object.assign({}, settings, options, {
+        // Note: this option is not in the readme.
+        // The goal is for it to be set by plugins on `data` instead of being
+        // passed by users.
+        extensions: this.data('toMarkdownExtensions') || []
+      })
+    )
+  };
 
-    // Do not write to stdout(4).
-    config.out = false;
+  Object.assign(this, {Compiler: compiler});
+}
 
-    process.stderr.write(
-      source.bold('Watching...') + ' (press CTRL+C to exit)\n',
-      noop$1
-    );
+const remark = unified().use(remarkParse).use(remarkStringify).freeze();
 
-    // Prevent infinite loop if set to regeneration.
-    if (output === true) {
-      config.output = false;
+const name$1 = "remark";
+const version$1 = "14.0.1";
+const description$1 = "Markdown processor powered by plugins part of the unified collective";
+const license = "MIT";
+const keywords = [
+	"unified",
+	"remark",
+	"markdown",
+	"mdast",
+	"abstract",
+	"syntax",
+	"tree",
+	"ast",
+	"parse",
+	"stringify",
+	"serialize",
+	"compile",
+	"process"
+];
+const homepage = "https://remark.js.org";
+const repository = "https://github.com/remarkjs/remark/tree/main/packages/remark";
+const bugs = "https://github.com/remarkjs/remark/issues";
+const funding = {
+	type: "opencollective",
+	url: "https://opencollective.com/unified"
+};
+const author = "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)";
+const contributors = [
+	"Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+];
+const sideEffects = false;
+const type = "module";
+const main$1 = "index.js";
+const types = "index.d.ts";
+const files = [
+	"index.d.ts",
+	"index.js"
+];
+const dependencies$1 = {
+	"@types/mdast": "^3.0.0",
+	"remark-parse": "^10.0.0",
+	"remark-stringify": "^10.0.0",
+	unified: "^10.0.0"
+};
+const scripts$1 = {
+	test: "node --conditions development test.js",
+	build: "rimraf \"*.d.ts\" && tsc && type-coverage"
+};
+const xo = false;
+const typeCoverage = {
+	atLeast: 100,
+	detail: true,
+	strict: true,
+	ignoreCatch: true
+};
+var proc = {
+	name: name$1,
+	version: version$1,
+	description: description$1,
+	license: license,
+	keywords: keywords,
+	homepage: homepage,
+	repository: repository,
+	bugs: bugs,
+	funding: funding,
+	author: author,
+	contributors: contributors,
+	sideEffects: sideEffects,
+	type: type,
+	main: main$1,
+	types: types,
+	files: files,
+	dependencies: dependencies$1,
+	scripts: scripts$1,
+	xo: xo,
+	typeCoverage: typeCoverage
+};
 
-      process.stderr.write(
-        source.yellow('Note') + ': Ignoring `--output` until exit.\n',
-        noop$1
-      );
-    }
+const name = "node-lint-md-cli-rollup";
+const description = "remark packaged for Node.js Markdown linting";
+const version = "2.0.2";
+const devDependencies = {
+	"@rollup/plugin-commonjs": "^20.0.0",
+	"@rollup/plugin-json": "^4.1.0",
+	"@rollup/plugin-node-resolve": "^13.0.4",
+	rollup: "^2.52.7",
+	shx: "^0.3.3"
+};
+const dependencies = {
+	"markdown-extensions": "^1.1.1",
+	remark: "^14.0.0",
+	"remark-gfm": "^2.0.0",
+	"remark-preset-lint-node": "^3.0.0",
+	"unified-args": "^9.0.0"
+};
+const main = "dist/index.js";
+const scripts = {
+	build: "npx rollup -c",
+	"build-node": "npm run build && npx shx cp dist/index.mjs ../lint-md.mjs"
+};
+var cli = {
+	name: name,
+	description: description,
+	version: version,
+	devDependencies: devDependencies,
+	dependencies: dependencies,
+	main: main,
+	scripts: scripts
+};
+
+/**
+ * @typedef {import('unist').Point} Point
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {Pick<Point, 'line'|'column'>} PositionalPoint
+ * @typedef {Required<Point>} FullPoint
+ * @typedef {NonNullable<Point['offset']>} Offset
+ */
+
+/**
+ * Get transform functions for the given `document`.
+ *
+ * @param {string|Uint8Array|VFile} file
+ */
+function location(file) {
+  var value = String(file);
+  /** @type {Array.<number>} */
+  var indices = [];
+  var search = /\r?\n|\r/g;
+
+  while (search.test(value)) {
+    indices.push(search.lastIndex);
   }
 
-  // Initial run.
-  lib$4(config, done);
+  indices.push(value.length + 1);
 
-  // Handle complete run.
-  function done(err, code, context) {
-    if (err) {
-      clean();
-      fail$1(err);
-    } else {
-      exitStatus = code;
+  return {toPoint, toOffset}
 
-      if (config.watch && !watcher) {
-        subscribe(context);
+  /**
+   * Get the line and column-based `point` for `offset` in the bound indices.
+   * Returns a point with `undefined` values when given invalid or out of bounds
+   * input.
+   *
+   * @param {Offset} offset
+   * @returns {FullPoint}
+   */
+  function toPoint(offset) {
+    var index = -1;
+
+    if (offset > -1 && offset < indices[indices.length - 1]) {
+      while (++index < indices.length) {
+        if (indices[index] > offset) {
+          return {
+            line: index + 1,
+            column: offset - (indices[index - 1] || 0) + 1,
+            offset
+          }
+        }
       }
     }
-  }
 
-  // Clean the watcher.
-  function clean() {
-    if (watcher) {
-      watcher.close();
-      watcher = null;
-    }
+    return {line: undefined, column: undefined, offset: undefined}
   }
 
-  // Subscribe a chokidar watcher to all processed files.
-  function subscribe(context) {
-    watcher = chokidar
-      .watch(context.fileSet.origins, {cwd: config.cwd, ignoreInitial: true})
-      .on('error', done)
-      .on('change', onchange);
+  /**
+   * Get the `offset` for a line and column-based `point` in the bound indices.
+   * Returns `-1` when given invalid or out of bounds input.
+   *
+   * @param {PositionalPoint} point
+   * @returns {Offset}
+   */
+  function toOffset(point) {
+    var line = point && point.line;
+    var column = point && point.column;
+    /** @type {number} */
+    var offset;
 
-    process.on('SIGINT', onsigint);
+    if (
+      typeof line === 'number' &&
+      typeof column === 'number' &&
+      !Number.isNaN(line) &&
+      !Number.isNaN(column) &&
+      line - 1 in indices
+    ) {
+      offset = (indices[line - 2] || 0) + column - 1 || 0;
+    }
 
-    function onchange(filePath) {
-      config.files = [filePath];
+    return offset > -1 && offset < indices[indices.length - 1] ? offset : -1
+  }
+}
 
-      lib$4(config, done);
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ *
+ * @typedef {string} Type
+ * @typedef {Object<string, unknown>} Props
+ *
+ * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test
+ */
 
-    function onsigint() {
-      // Hide the `^C` in terminal.
-      process.stderr.write('\n', noop$1);
+const convert =
+  /**
+   * @type {(
+   *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
+   *   ((test?: Test) => AssertAnything)
+   * )}
+   */
+  (
+    /**
+     * Generate an assertion from a check.
+     * @param {Test} [test]
+     * When nullish, checks if `node` is a `Node`.
+     * When `string`, works like passing `function (node) {return node.type === test}`.
+     * When `function` checks if function passed the node is true.
+     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+     * When `array`, checks any one of the subtests pass.
+     * @returns {AssertAnything}
+     */
+    function (test) {
+      if (test === undefined || test === null) {
+        return ok
+      }
 
-      clean();
+      if (typeof test === 'string') {
+        return typeFactory(test)
+      }
 
-      // Do another process if `output` specified regeneration.
-      if (output === true) {
-        config.output = output;
-        config.watch = false;
-        lib$4(config, done);
+      if (typeof test === 'object') {
+        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)
       }
-    }
-  }
-}
 
-// Print an error, optionally with stack.
-function fail$1(err, pretty) {
-  var message =
-    (pretty ? String(err).trim() : err.stack) ||
-    /* istanbul ignore next - Old versions of Node */ err;
+      if (typeof test === 'function') {
+        return castFactory(test)
+      }
 
-  exitStatus = 1;
+      throw new Error('Expected function, string, or object as test')
+    }
+  );
+/**
+ * @param {Array.<Type|Props|TestFunctionAnything>} tests
+ * @returns {AssertAnything}
+ */
+function anyFactory(tests) {
+  /** @type {Array.<AssertAnything>} */
+  const checks = [];
+  let index = -1;
 
-  process.stderr.write(message.trim() + '\n', noop$1);
-}
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index]);
+  }
 
-function onexit() {
-  /* eslint-disable unicorn/no-process-exit */
-  process.exit(exitStatus);
-  /* eslint-enable unicorn/no-process-exit */
-}
+  return castFactory(any)
 
-var unifiedArgs = lib$6;
+  /**
+   * @this {unknown}
+   * @param {unknown[]} parameters
+   * @returns {boolean}
+   */
+  function any(...parameters) {
+    let index = -1;
 
-var markdownExtensions = [
-	"md",
-	"markdown",
-	"mdown",
-	"mkdn",
-	"mkd",
-	"mdwn",
-	"mkdown",
-	"ron"
-];
+    while (++index < checks.length) {
+      if (checks[index].call(this, ...parameters)) return true
+    }
 
-var markdownExtensions$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': markdownExtensions
-});
+    return false
+  }
+}
 
-var require$$0$2 = getCjsExportFromNamespace(markdownExtensions$1);
+/**
+ * Utility to assert each property in `test` is represented in `node`, and each
+ * values are strictly equal.
+ *
+ * @param {Props} check
+ * @returns {AssertAnything}
+ */
+function propsFactory(check) {
+  return castFactory(all)
 
-var markdownExtensions$2 = require$$0$2;
+  /**
+   * @param {Node} node
+   * @returns {boolean}
+   */
+  function all(node) {
+    /** @type {string} */
+    let key;
 
-var bail_1 = bail;
+    for (key in check) {
+      // @ts-expect-error: hush, it sure works as an index.
+      if (node[key] !== check[key]) return false
+    }
 
-function bail(err) {
-  if (err) {
-    throw err
+    return true
   }
 }
 
-var hasOwn = Object.prototype.hasOwnProperty;
-var toStr = Object.prototype.toString;
-var defineProperty = Object.defineProperty;
-var gOPD = Object.getOwnPropertyDescriptor;
+/**
+ * Utility to convert a string into a function which checks a given node’s type
+ * for said string.
+ *
+ * @param {Type} check
+ * @returns {AssertAnything}
+ */
+function typeFactory(check) {
+  return castFactory(type)
 
-var isArray$1 = function isArray(arr) {
-	if (typeof Array.isArray === 'function') {
-		return Array.isArray(arr);
-	}
+  /**
+   * @param {Node} node
+   */
+  function type(node) {
+    return node && node.type === check
+  }
+}
 
-	return toStr.call(arr) === '[object Array]';
-};
+/**
+ * Utility to convert a string into a function which checks a given node’s type
+ * for said string.
+ * @param {TestFunctionAnything} check
+ * @returns {AssertAnything}
+ */
+function castFactory(check) {
+  return assertion
 
-var isPlainObject = function isPlainObject(obj) {
-	if (!obj || toStr.call(obj) !== '[object Object]') {
-		return false;
-	}
+  /**
+   * @this {unknown}
+   * @param {Array.<unknown>} parameters
+   * @returns {boolean}
+   */
+  function assertion(...parameters) {
+    // @ts-expect-error: spreading is fine.
+    return Boolean(check.call(this, ...parameters))
+  }
+}
 
-	var hasOwnConstructor = hasOwn.call(obj, 'constructor');
-	var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
-	// Not own constructor property must be Object
-	if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
-		return false;
-	}
+// Utility to return true.
+function ok() {
+  return true
+}
 
-	// Own properties are enumerated firstly, so to speed up,
-	// if last one is own, then all properties are own.
-	var key;
-	for (key in obj) { /**/ }
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+function color$2(d) {
+  return '\u001B[33m' + d + '\u001B[39m'
+}
 
-	return typeof key === 'undefined' || hasOwn.call(obj, key);
-};
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist-util-is').Test} Test
+ */
 
-// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
-var setProperty = function setProperty(target, options) {
-	if (defineProperty && options.name === '__proto__') {
-		defineProperty(target, options.name, {
-			enumerable: true,
-			configurable: true,
-			value: options.newValue,
-			writable: true
-		});
-	} else {
-		target[options.name] = options.newValue;
-	}
-};
+/**
+ * Continue traversing as normal
+ */
+const CONTINUE$2 = true;
+/**
+ * Do not traverse this node’s children
+ */
+const SKIP$2 = 'skip';
+/**
+ * Stop traversing immediately
+ */
+const EXIT$2 = false;
 
-// Return undefined instead of __proto__ if '__proto__' is not an own property
-var getProperty = function getProperty(obj, name) {
-	if (name === '__proto__') {
-		if (!hasOwn.call(obj, name)) {
-			return void 0;
-		} else if (gOPD) {
-			// In early versions of node, obj['__proto__'] is buggy when obj has
-			// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
-			return gOPD(obj, name).value;
-		}
-	}
+const visitParents$2 =
+  /**
+   * @type {(
+   *   (<T extends Node>(tree: Node, test: T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>>, visitor: Visitor<T>, reverse?: boolean) => void) &
+   *   ((tree: Node, test: Test, visitor: Visitor<Node>, reverse?: boolean) => void) &
+   *   ((tree: Node, visitor: Visitor<Node>, reverse?: boolean) => void)
+   * )}
+   */
+  (
+    /**
+     * Visit children of tree which pass a test
+     *
+     * @param {Node} tree Abstract syntax tree to walk
+     * @param {Test} test test Test node
+     * @param {Visitor<Node>} visitor Function to run for each node
+     * @param {boolean} [reverse] Fisit the tree in reverse, defaults to false
+     */
+    function (tree, test, visitor, reverse) {
+      if (typeof test === 'function' && typeof visitor !== 'function') {
+        reverse = visitor;
+        // @ts-ignore no visitor given, so `visitor` is test.
+        visitor = test;
+        test = null;
+      }
+
+      var is = convert(test);
+      var step = reverse ? -1 : 1;
+
+      factory(tree, null, [])();
+
+      /**
+       * @param {Node} node
+       * @param {number?} index
+       * @param {Array.<Parent>} parents
+       */
+      function factory(node, index, parents) {
+        /** @type {Object.<string, unknown>} */
+        var value = typeof node === 'object' && node !== null ? node : {};
+        /** @type {string} */
+        var name;
+
+        if (typeof value.type === 'string') {
+          name =
+            typeof value.tagName === 'string'
+              ? value.tagName
+              : typeof value.name === 'string'
+              ? value.name
+              : undefined;
+
+          Object.defineProperty(visit, 'name', {
+            value:
+              'node (' +
+              color$2(value.type + (name ? '<' + name + '>' : '')) +
+              ')'
+          });
+        }
 
-	return obj[name];
-};
+        return visit
 
-var extend$2 = function extend() {
-	var options, name, src, copy, copyIsArray, clone;
-	var target = arguments[0];
-	var i = 1;
-	var length = arguments.length;
-	var deep = false;
+        function visit() {
+          /** @type {ActionTuple} */
+          var result = [];
+          /** @type {ActionTuple} */
+          var subresult;
+          /** @type {number} */
+          var offset;
+          /** @type {Array.<Parent>} */
+          var grandparents;
 
-	// Handle a deep copy situation
-	if (typeof target === 'boolean') {
-		deep = target;
-		target = arguments[1] || {};
-		// skip the boolean and the target
-		i = 2;
-	}
-	if (target == null || (typeof target !== 'object' && typeof target !== 'function')) {
-		target = {};
-	}
+          if (!test || is(node, index, parents[parents.length - 1] || null)) {
+            result = toResult$2(visitor(node, parents));
 
-	for (; i < length; ++i) {
-		options = arguments[i];
-		// Only deal with non-null/undefined values
-		if (options != null) {
-			// Extend the base object
-			for (name in options) {
-				src = getProperty(target, name);
-				copy = getProperty(options, name);
+            if (result[0] === EXIT$2) {
+              return result
+            }
+          }
 
-				// Prevent never-ending loop
-				if (target !== copy) {
-					// Recurse if we're merging plain objects or arrays
-					if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray$1(copy)))) {
-						if (copyIsArray) {
-							copyIsArray = false;
-							clone = src && isArray$1(src) ? src : [];
-						} else {
-							clone = src && isPlainObject(src) ? src : {};
-						}
+          if (node.children && result[0] !== SKIP$2) {
+            // @ts-ignore looks like a parent.
+            offset = (reverse ? node.children.length : -1) + step;
+            // @ts-ignore looks like a parent.
+            grandparents = parents.concat(node);
 
-						// Never move original objects, clone them
-						setProperty(target, { name: name, newValue: extend(deep, clone, copy) });
+            // @ts-ignore looks like a parent.
+            while (offset > -1 && offset < node.children.length) {
+              subresult = factory(node.children[offset], offset, grandparents)();
 
-					// Don't bring in undefined values
-					} else if (typeof copy !== 'undefined') {
-						setProperty(target, { name: name, newValue: copy });
-					}
-				}
-			}
-		}
-	}
+              if (subresult[0] === EXIT$2) {
+                return subresult
+              }
 
-	// Return the modified object
-	return target;
-};
+              offset =
+                typeof subresult[1] === 'number' ? subresult[1] : offset + step;
+            }
+          }
 
-// Expose a frozen processor.
-var unified_1 = unified().freeze();
+          return result
+        }
+      }
+    }
+  );
 
-var slice$3 = [].slice;
-var own$2 = {}.hasOwnProperty;
+/**
+ * @param {VisitorResult} value
+ * @returns {ActionTuple}
+ */
+function toResult$2(value) {
+  if (Array.isArray(value)) {
+    return value
+  }
 
-// Process pipeline.
-var pipeline = trough_1()
-  .use(pipelineParse)
-  .use(pipelineRun)
-  .use(pipelineStringify);
+  if (typeof value === 'number') {
+    return [CONTINUE$2, value]
+  }
 
-function pipelineParse(p, ctx) {
-  ctx.tree = p.parse(ctx.file);
+  return [value]
 }
 
-function pipelineRun(p, ctx, next) {
-  p.run(ctx.tree, ctx.file, done);
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist-util-is').Test} Test
+ * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
+ */
 
-  function done(err, tree, file) {
-    if (err) {
-      next(err);
-    } else {
-      ctx.tree = tree;
-      ctx.file = file;
-      next();
+const visit$1 =
+  /**
+   * @type {(
+   *   (<T extends Node>(tree: Node, test: T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>>, visitor: Visitor<T>, reverse?: boolean) => void) &
+   *   ((tree: Node, test: Test, visitor: Visitor<Node>, reverse?: boolean) => void) &
+   *   ((tree: Node, visitor: Visitor<Node>, reverse?: boolean) => void)
+   * )}
+   */
+  (
+    /**
+     * Visit children of tree which pass a test
+     *
+     * @param {Node} tree Abstract syntax tree to walk
+     * @param {Test} test test Test node
+     * @param {Visitor<Node>} visitor Function to run for each node
+     * @param {boolean} [reverse] Fisit the tree in reverse, defaults to false
+     */
+    function (tree, test, visitor, reverse) {
+      if (typeof test === 'function' && typeof visitor !== 'function') {
+        reverse = visitor;
+        visitor = test;
+        test = null;
+      }
+
+      visitParents$2(tree, test, overload, reverse);
+
+      /**
+       * @param {Node} node
+       * @param {Array.<Parent>} parents
+       */
+      function overload(node, parents) {
+        var parent = parents[parents.length - 1];
+        return visitor(
+          node,
+          parent ? parent.children.indexOf(node) : null,
+          parent
+        )
+      }
     }
-  }
-}
-
-function pipelineStringify(p, ctx) {
-  var result = p.stringify(ctx.tree, ctx.file);
-  var file = ctx.file;
-
-  if (result === undefined || result === null) ; else if (typeof result === 'string' || isBuffer(result)) {
-    file.contents = result;
-  } else {
-    file.result = result;
-  }
-}
+  );
 
-// Function to create the first processor.
-function unified() {
-  var attachers = [];
-  var transformers = trough_1();
-  var namespace = {};
-  var frozen = false;
-  var freezeIndex = -1;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist').Point} Point
+ * @typedef {import('unist-util-is').Test} Test
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ *
+ * @typedef {OptionsWithoutReset|OptionsWithReset} Options
+ * @typedef {OptionsBaseFields & OptionsWithoutResetFields} OptionsWithoutReset
+ * @typedef {OptionsBaseFields & OptionsWithResetFields} OptionsWithReset
+ *
+ * @typedef OptionsWithoutResetFields
+ * @property {false} [reset]
+ *   Whether to treat all messages as turned off initially.
+ * @property {string[]} [disable]
+ *   List of `ruleId`s to turn off.
+ *
+ * @typedef OptionsWithResetFields
+ * @property {true} reset
+ *   Whether to treat all messages as turned off initially.
+ * @property {string[]} [enable]
+ *   List of `ruleId`s to initially turn on.
+ *
+ * @typedef OptionsBaseFields
+ * @property {string} name
+ *   Name of markers that can control the message sources.
+ *
+ *   For example, `{name: 'alpha'}` controls `alpha` markers:
+ *
+ *   ```html
+ *   <!--alpha ignore-->
+ *   ```
+ * @property {MarkerParser} marker
+ *   Parse a possible marker to a comment marker object (Marker).
+ *   If the marker isn't a marker, should return `null`.
+ * @property {Test} [test]
+ *   Test for possible markers
+ * @property {string[]} [known]
+ *   List of allowed `ruleId`s. When given a warning is shown
+ *   when someone tries to control an unknown rule.
+ *
+ *   For example, `{name: 'alpha', known: ['bravo']}` results in a warning if
+ *   `charlie` is configured:
+ *
+ *   ```html
+ *   <!--alpha ignore charlie-->
+ *   ```
+ * @property {string|string[]} [source]
+ *   Sources that can be controlled with `name` markers.
+ *   Defaults to `name`.
+ *
+ * @callback MarkerParser
+ *   Parse a possible comment marker node to a Marker.
+ * @param {Node} node
+ *   Node to parse
+ *
+ * @typedef Marker
+ *   A comment marker.
+ * @property {string} name
+ *   Name of marker.
+ * @property {string} attributes
+ *   Value after name.
+ * @property {Record<string, string|number|boolean>} parameters
+ *   Parsed attributes.
+ * @property {Node} node
+ *   Reference to given node.
+ *
+ * @typedef Mark
+ * @property {Point|undefined} point
+ * @property {boolean} state
+ */
 
-  // Data management.
-  processor.data = data;
+const own$2 = {}.hasOwnProperty;
 
-  // Lock.
-  processor.freeze = freeze;
+/**
+ * @type {import('unified').Plugin<[Options]>}
+ * @returns {(tree: Node, file: VFile) => void}
+ */
+function messageControl(options) {
+  if (!options || typeof options !== 'object' || !options.name) {
+    throw new Error(
+      'Expected `name` in `options`, got `' + (options || {}).name + '`'
+    )
+  }
 
-  // Plugins.
-  processor.attachers = attachers;
-  processor.use = use;
+  if (!options.marker) {
+    throw new Error(
+      'Expected `marker` in `options`, got `' + options.marker + '`'
+    )
+  }
 
-  // API.
-  processor.parse = parse;
-  processor.stringify = stringify;
-  processor.run = run;
-  processor.runSync = runSync;
-  processor.process = process;
-  processor.processSync = processSync;
+  const enable = 'enable' in options && options.enable ? options.enable : [];
+  const disable = 'disable' in options && options.disable ? options.disable : [];
+  let reset = options.reset;
+  const sources =
+    typeof options.source === 'string'
+      ? [options.source]
+      : options.source || [options.name];
 
-  // Expose.
-  return processor
+  return transformer
 
-  // Create a new processor based on the processor in the current scope.
-  function processor() {
-    var destination = unified();
-    var length = attachers.length;
-    var index = -1;
+  /**
+   * @param {Node} tree
+   * @param {VFile} file
+   */
+  function transformer(tree, file) {
+    const toOffset = location(file).toOffset;
+    const initial = !reset;
+    const gaps = detectGaps(tree, file);
+    /** @type {Record<string, Mark[]>} */
+    const scope = {};
+    /** @type {Mark[]} */
+    const globals = [];
 
-    while (++index < length) {
-      destination.use.apply(null, attachers[index]);
-    }
+    visit$1(tree, options.test, visitor);
 
-    destination.data(extend$2(true, {}, namespace));
+    file.messages = file.messages.filter((m) => filter(m));
 
-    return destination
-  }
+    /**
+     * @param {Node} node
+     * @param {number|null} position
+     * @param {Parent|null} parent
+     */
+    function visitor(node, position, parent) {
+      /** @type {Marker|null} */
+      const mark = options.marker(node);
 
-  // Freeze: used to signal a processor that has finished configuration.
-  //
-  // For example, take unified itself: it’s frozen.
-  // Plugins should not be added to it.
-  // Rather, it should be extended, by invoking it, before modifying it.
-  //
-  // In essence, always invoke this when exporting a processor.
-  function freeze() {
-    var values;
-    var plugin;
-    var options;
-    var transformer;
+      if (!mark || mark.name !== options.name) {
+        return
+      }
 
-    if (frozen) {
-      return processor
-    }
+      const ruleIds = mark.attributes.split(/\s/g);
+      const point = mark.node.position && mark.node.position.start;
+      const next =
+        (parent && position !== null && parent.children[position + 1]) ||
+        undefined;
+      const tail = (next && next.position && next.position.end) || undefined;
+      let index = -1;
 
-    while (++freezeIndex < attachers.length) {
-      values = attachers[freezeIndex];
-      plugin = values[0];
-      options = values[1];
-      transformer = null;
+      /** @type {string} */
+      // @ts-expect-error: we’ll check for unknown values next.
+      const verb = ruleIds.shift();
 
-      if (options === false) {
-        continue
+      if (verb !== 'enable' && verb !== 'disable' && verb !== 'ignore') {
+        file.fail(
+          'Unknown keyword `' +
+            verb +
+            '`: expected ' +
+            "`'enable'`, `'disable'`, or `'ignore'`",
+          mark.node
+        );
       }
 
-      if (options === true) {
-        values[1] = undefined;
-      }
+      // Apply to all rules.
+      if (ruleIds.length > 0) {
+        while (++index < ruleIds.length) {
+          const ruleId = ruleIds[index];
 
-      transformer = plugin.apply(processor, values.slice(1));
+          if (isKnown(ruleId, verb, mark.node)) {
+            toggle(point, verb === 'enable', ruleId);
 
-      if (typeof transformer === 'function') {
-        transformers.use(transformer);
+            if (verb === 'ignore') {
+              toggle(tail, true, ruleId);
+            }
+          }
+        }
+      } else if (verb === 'ignore') {
+        toggle(point, false);
+        toggle(tail, true);
+      } else {
+        toggle(point, verb === 'enable');
+        reset = verb !== 'enable';
       }
     }
 
-    frozen = true;
-    freezeIndex = Infinity;
-
-    return processor
-  }
-
-  // Data management.
-  // Getter / setter for processor-specific informtion.
-  function data(key, value) {
-    if (typeof key === 'string') {
-      // Set `key`.
-      if (arguments.length === 2) {
-        assertUnfrozen('data', frozen);
+    /**
+     * @param {VFileMessage} message
+     * @returns {boolean}
+     */
+    function filter(message) {
+      let gapIndex = gaps.length;
 
-        namespace[key] = value;
+      // Keep messages from a different source.
+      if (!message.source || !sources.includes(message.source)) {
+        return true
+      }
 
-        return processor
+      // We only ignore messages if they‘re disabled, *not* when they’re not in
+      // the document.
+      if (!message.line) {
+        message.line = 1;
       }
 
-      // Get `key`.
-      return (own$2.call(namespace, key) && namespace[key]) || null
-    }
+      if (!message.column) {
+        message.column = 1;
+      }
 
-    // Set space.
-    if (key) {
-      assertUnfrozen('data', frozen);
-      namespace = key;
-      return processor
-    }
+      // Check whether the warning is inside a gap.
+      // @ts-expect-error: we just normalized `null` to `number`s.
+      const offset = toOffset(message);
 
-    // Get space.
-    return namespace
-  }
+      while (gapIndex--) {
+        if (gaps[gapIndex][0] <= offset && gaps[gapIndex][1] > offset) {
+          return false
+        }
+      }
 
-  // Plugin management.
-  //
-  // Pass it:
-  // *   an attacher and options,
-  // *   a preset,
-  // *   a list of presets, attachers, and arguments (list of attachers and
-  //     options).
-  function use(value) {
-    var settings;
+      // Check whether allowed by specific and global states.
+      return (
+        (!message.ruleId ||
+          check(message, scope[message.ruleId], message.ruleId)) &&
+        check(message, globals)
+      )
+    }
 
-    assertUnfrozen('use', frozen);
+    /**
+     * Helper to check (and possibly warn) if a `ruleId` is unknown.
+     *
+     * @param {string} ruleId
+     * @param {string} verb
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    function isKnown(ruleId, verb, node) {
+      const result = options.known ? options.known.includes(ruleId) : true;
 
-    if (value === null || value === undefined) ; else if (typeof value === 'function') {
-      addPlugin.apply(null, arguments);
-    } else if (typeof value === 'object') {
-      if ('length' in value) {
-        addList(value);
-      } else {
-        addPreset(value);
+      if (!result) {
+        file.message(
+          'Unknown rule: cannot ' + verb + " `'" + ruleId + "'`",
+          node
+        );
       }
-    } else {
-      throw new Error('Expected usable value, not `' + value + '`')
-    }
 
-    if (settings) {
-      namespace.settings = extend$2(namespace.settings || {}, settings);
+      return result
     }
 
-    return processor
+    /**
+     * Get the latest state of a rule.
+     * When without `ruleId`, gets global state.
+     *
+     * @param {string|undefined} ruleId
+     * @returns {boolean}
+     */
+    function getState(ruleId) {
+      const ranges = ruleId ? scope[ruleId] : globals;
 
-    function addPreset(result) {
-      addList(result.plugins);
+      if (ranges && ranges.length > 0) {
+        return ranges[ranges.length - 1].state
+      }
 
-      if (result.settings) {
-        settings = extend$2(settings || {}, result.settings);
+      if (!ruleId) {
+        return !reset
       }
+
+      return reset ? enable.includes(ruleId) : !disable.includes(ruleId)
     }
 
-    function add(value) {
-      if (typeof value === 'function') {
-        addPlugin(value);
-      } else if (typeof value === 'object') {
-        if ('length' in value) {
-          addPlugin.apply(null, value);
-        } else {
-          addPreset(value);
-        }
-      } else {
-        throw new Error('Expected usable value, not `' + value + '`')
+    /**
+     * Handle a rule.
+     *
+     * @param {Point|undefined} point
+     * @param {boolean} state
+     * @param {string|undefined} [ruleId]
+     * @returns {void}
+     */
+    function toggle(point, state, ruleId) {
+      let markers = ruleId ? scope[ruleId] : globals;
+
+      if (!markers) {
+        markers = [];
+        scope[String(ruleId)] = markers;
       }
-    }
 
-    function addList(plugins) {
-      var length;
-      var index;
+      const previousState = getState(ruleId);
 
-      if (plugins === null || plugins === undefined) ; else if (typeof plugins === 'object' && 'length' in plugins) {
-        length = plugins.length;
-        index = -1;
+      if (state !== previousState) {
+        markers.push({state, point});
+      }
 
-        while (++index < length) {
-          add(plugins[index]);
+      // Toggle all known rules.
+      if (!ruleId) {
+        for (ruleId in scope) {
+          if (own$2.call(scope, ruleId)) {
+            toggle(point, state, ruleId);
+          }
         }
-      } else {
-        throw new Error('Expected a list of plugins, not `' + plugins + '`')
       }
     }
 
-    function addPlugin(plugin, value) {
-      var entry = find(plugin);
-
-      if (entry) {
-        if (isPlainObj(entry[1]) && isPlainObj(value)) {
-          value = extend$2(entry[1], value);
+    /**
+     * Check all `ranges` for `message`.
+     *
+     * @param {VFileMessage} message
+     * @param {Mark[]|undefined} ranges
+     * @param {string|undefined} [ruleId]
+     * @returns {boolean}
+     */
+    function check(message, ranges, ruleId) {
+      if (ranges && ranges.length > 0) {
+        // Check the state at the message’s position.
+        let index = ranges.length;
+
+        while (index--) {
+          const range = ranges[index];
+
+          if (
+            message.line &&
+            message.column &&
+            range.point &&
+            range.point.line &&
+            range.point.column &&
+            (range.point.line < message.line ||
+              (range.point.line === message.line &&
+                range.point.column <= message.column))
+          ) {
+            return range.state === true
+          }
         }
+      }
 
-        entry[1] = value;
-      } else {
-        attachers.push(slice$3.call(arguments));
+      // The first marker ocurred after the first message, so we check the
+      // initial state.
+      if (!ruleId) {
+        return Boolean(initial || reset)
       }
+
+      return reset ? enable.includes(ruleId) : !disable.includes(ruleId)
     }
   }
+}
 
-  function find(plugin) {
-    var length = attachers.length;
-    var index = -1;
-    var entry;
+/**
+ * Detect gaps in `tree`.
+ *
+ * @param {Node} tree
+ * @param {VFile} file
+ */
+function detectGaps(tree, file) {
+  /** @type {Node[]} */
+  // @ts-expect-error: fine.
+  const children = tree.children || [];
+  const lastNode = children[children.length - 1];
+  /** @type {[number, number][]} */
+  const gaps = [];
+  let offset = 0;
+  /** @type {boolean|undefined} */
+  let gap;
 
-    while (++index < length) {
-      entry = attachers[index];
+  // Find all gaps.
+  visit$1(tree, one);
 
-      if (entry[0] === plugin) {
-        return entry
-      }
-    }
+  // Get the end of the document.
+  // This detects if the last node was the last node.
+  // If not, there’s an extra gap between the last node and the end of the
+  // document.
+  if (
+    lastNode &&
+    lastNode.position &&
+    lastNode.position.end &&
+    offset === lastNode.position.end.offset &&
+    file.toString().slice(offset).trim() !== ''
+  ) {
+    update();
+
+    update(
+      tree &&
+        tree.position &&
+        tree.position.end &&
+        tree.position.end.offset &&
+        tree.position.end.offset - 1
+    );
   }
 
-  // Parse a file (in string or vfile representation) into a unist node using
-  // the `Parser` on the processor.
-  function parse(doc) {
-    var file = vfile(doc);
-    var Parser;
+  return gaps
 
-    freeze();
-    Parser = processor.Parser;
-    assertParser('parse', Parser);
+  /**
+   * @param {Node} node
+   */
+  function one(node) {
+    update(node.position && node.position.start && node.position.start.offset);
 
-    if (newable(Parser, 'parse')) {
-      return new Parser(String(file), file).parse()
+    if (!('children' in node)) {
+      update(node.position && node.position.end && node.position.end.offset);
     }
-
-    return Parser(String(file), file) // eslint-disable-line new-cap
   }
 
-  // Run transforms on a unist node representation of a file (in string or
-  // vfile representation), async.
-  function run(node, file, cb) {
-    assertNode(node);
-    freeze();
+  /**
+   * Detect a new position.
+   *
+   * @param {number|undefined} [latest]
+   * @returns {void}
+   */
+  function update(latest) {
+    if (latest === null || latest === undefined) {
+      gap = true;
+    } else if (offset < latest) {
+      if (gap) {
+        gaps.push([offset, latest]);
+        gap = undefined;
+      }
 
-    if (!cb && typeof file === 'function') {
-      cb = file;
-      file = null;
+      offset = latest;
     }
+  }
+}
 
-    if (!cb) {
-      return new Promise(executor)
-    }
+/**
+ * @typedef {string|number|boolean} MarkerParameterValue
+ * @typedef {Object.<string, MarkerParameterValue>} MarkerParameters
+ *
+ * @typedef HtmlNode
+ * @property {'html'} type
+ * @property {string} value
+ *
+ * @typedef CommentNode
+ * @property {'comment'} type
+ * @property {string} value
+ *
+ * @typedef Marker
+ * @property {string} name
+ * @property {string} attributes
+ * @property {MarkerParameters|null} parameters
+ * @property {HtmlNode|CommentNode} node
+ */
 
-    executor(null, cb);
+var commentExpression = /\s*([a-zA-Z\d-]+)(\s+([\s\S]*))?\s*/;
 
-    function executor(resolve, reject) {
-      transformers.run(node, vfile(file), done);
+var markerExpression = new RegExp(
+  '(\\s*<!--' + commentExpression.source + '-->\\s*)'
+);
 
-      function done(err, tree, file) {
-        tree = tree || node;
-        if (err) {
-          reject(err);
-        } else if (resolve) {
-          resolve(tree);
-        } else {
-          cb(null, tree, file);
+/**
+ * Parse a comment marker.
+ * @param {unknown} node
+ * @returns {Marker|null}
+ */
+function commentMarker(node) {
+  /** @type {RegExpMatchArray} */
+  var match;
+  /** @type {number} */
+  var offset;
+  /** @type {MarkerParameters} */
+  var parameters;
+
+  if (
+    node &&
+    typeof node === 'object' &&
+    // @ts-ignore hush
+    (node.type === 'html' || node.type === 'comment')
+  ) {
+    // @ts-ignore hush
+    match = node.value.match(
+      // @ts-ignore hush
+      node.type === 'comment' ? commentExpression : markerExpression
+    );
+
+    // @ts-ignore hush
+    if (match && match[0].length === node.value.length) {
+      // @ts-ignore hush
+      offset = node.type === 'comment' ? 1 : 2;
+      parameters = parseParameters(match[offset + 1] || '');
+
+      if (parameters) {
+        return {
+          name: match[offset],
+          attributes: match[offset + 2] || '',
+          parameters,
+          // @ts-ignore hush
+          node
         }
       }
     }
   }
 
-  // Run transforms on a unist node representation of a file (in string or
-  // vfile representation), sync.
-  function runSync(node, file) {
-    var complete = false;
-    var result;
+  return null
+}
 
-    run(node, file, done);
+/**
+ * Parse `value` into an object.
+ *
+ * @param {string} value
+ * @returns {MarkerParameters|null}
+ */
+function parseParameters(value) {
+  /** @type {MarkerParameters} */
+  var parameters = {};
 
-    assertDone('runSync', 'run', complete);
+  return value
+    .replace(
+      /\s+([-\w]+)(?:=(?:"((?:\\[\s\S]|[^"])+)"|'((?:\\[\s\S]|[^'])+)'|((?:\\[\s\S]|[^"'\s])+)))?/gi,
+      replacer
+    )
+    .replace(/\s+/g, '')
+    ? null
+    : parameters
 
-    return result
+  /**
+   * @param {string} _
+   * @param {string} $1
+   * @param {string} $2
+   * @param {string} $3
+   * @param {string} $4
+   */
+  // eslint-disable-next-line max-params
+  function replacer(_, $1, $2, $3, $4) {
+    /** @type {MarkerParameterValue} */
+    var value = $2 || $3 || $4 || '';
 
-    function done(err, tree) {
-      complete = true;
-      bail_1(err);
-      result = tree;
+    if (value === 'true' || value === '') {
+      value = true;
+    } else if (value === 'false') {
+      value = false;
+    } else if (!Number.isNaN(Number(value))) {
+      value = Number(value);
     }
+
+    parameters[$1] = value;
+
+    return ''
   }
+}
 
-  // Stringify a unist node representation of a file (in string or vfile
-  // representation) into a string using the `Compiler` on the processor.
-  function stringify(node, doc) {
-    var file = vfile(doc);
-    var Compiler;
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('unified-message-control')} MessageControl
+ * @typedef {Omit<import('unified-message-control').OptionsWithoutReset, 'marker'>|Omit<import('unified-message-control').OptionsWithReset, 'marker'>} Options
+ */
 
-    freeze();
-    Compiler = processor.Compiler;
-    assertCompiler('stringify', Compiler);
-    assertNode(node);
+const test = [
+  'html', // Comments are `html` nodes in mdast.
+  'comment' // In MDX, comments have their own node.
+];
 
-    if (newable(Compiler, 'compile')) {
-      return new Compiler(node, file).compile()
-    }
+/**
+ * Plugin to enable, disable, and ignore messages.
+ *
+ * @type {import('unified').Plugin<[Options], Root>}
+ * @returns {(node: Root, file: VFile) => void}
+ */
+function remarkMessageControl(options) {
+  return messageControl(
+    Object.assign({marker: commentMarker, test}, options)
+  )
+}
 
-    return Compiler(node, file) // eslint-disable-line new-cap
-  }
+/**
+ * @typedef {import('mdast').Root} Root
+ */
 
-  // Parse a file (in string or vfile representation) into a unist node using
-  // the `Parser` on the processor, then run transforms on that node, and
-  // compile the resulting node using the `Compiler` on the processor, and
-  // store that result on the vfile.
-  function process(doc, cb) {
-    freeze();
-    assertParser('process', processor.Parser);
-    assertCompiler('process', processor.Compiler);
+/**
+ * The core plugin for `remark-lint`.
+ * This adds support for ignoring stuff from messages (`<!--lint ignore-->`).
+ * All rules are in their own packages and presets.
+ *
+ * @type {import('unified').Plugin<void[], Root>}
+ */
+function remarkLint() {
+  this.use(lintMessageControl);
+}
 
-    if (!cb) {
-      return new Promise(executor)
-    }
+/** @type {import('unified').Plugin<void[], Root>} */
+function lintMessageControl() {
+  return remarkMessageControl({name: 'lint', source: 'remark-lint'})
+}
 
-    executor(null, cb);
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    function executor(resolve, reject) {
-      var file = vfile(doc);
+const primitives$G = new Set(['string', 'number', 'boolean']);
 
-      pipeline.run(processor, {file: file}, done);
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$G(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-      function done(err) {
-        if (err) {
-          reject(err);
-        } else if (resolve) {
-          resolve(file);
-        } else {
-          cb(null, file);
-        }
-      }
-    }
-  }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  // Process the given document (in string or vfile representation), sync.
-  function processSync(doc) {
-    var complete = false;
-    var file;
+  return plugin
 
-    freeze();
-    assertParser('processSync', processor.Parser);
-    assertCompiler('processSync', processor.Compiler);
-    file = vfile(doc);
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$H(ruleId, raw);
 
-    process(file, done);
+    if (!severity) return
 
-    assertDone('processSync', 'process', complete);
+    const fatal = severity === 2;
 
-    return file
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-    function done(err) {
-      complete = true;
-      bail_1(err);
+      wrap(rule, (error) => {
+        const messages = file.messages;
+
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
+
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
+
+        next();
+      })(tree, file, options);
     }
   }
 }
 
-// Check if `value` is a constructor.
-function newable(value, name) {
-  return (
-    typeof value === 'function' &&
-    value.prototype &&
-    // A function with keys in its prototype is probably a constructor.
-    // Classes’ prototype methods are not enumerable, so we check if some value
-    // exists in the prototype.
-    (keys(value.prototype) || name in value.prototype)
-  )
-}
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$H(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-// Check if `value` is an object with keys.
-function keys(value) {
-  var key;
-  for (key in value) {
-    return true
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$G.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  return false
-}
-
-// Assert a parser is available.
-function assertParser(name, Parser) {
-  if (typeof Parser !== 'function') {
-    throw new Error('Cannot `' + name + '` without `Parser`')
-  }
-}
+  let level = result[0];
 
-// Assert a compiler is available.
-function assertCompiler(name, Compiler) {
-  if (typeof Compiler !== 'function') {
-    throw new Error('Cannot `' + name + '` without `Compiler`')
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
-}
 
-// Assert the processor is not frozen.
-function assertUnfrozen(name, frozen) {
-  if (frozen) {
+  if (typeof level !== 'number' || level < 0 || level > 2) {
     throw new Error(
-      'Cannot invoke `' +
+      'Incorrect severity `' +
+        level +
+        '` for `' +
         name +
-        '` on a frozen processor.\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.'
+        '`, ' +
+        'expected 0, 1, or 2'
     )
   }
+
+  result[0] = level;
+
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-// Assert `node` is a unist node.
-function assertNode(node) {
-  if (!node || typeof node.type !== 'string') {
-    throw new Error('Expected node, got `' + node + '`')
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module final-newline
+ * @fileoverview
+ *   Warn when a line feed at the end of a file is missing.
+ *   Empty files are allowed.
+ *
+ *   See [StackExchange](https://unix.stackexchange.com/questions/18743) for why.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   always adds a final line feed to files.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ *   ## Example
+ *
+ *   ##### `ok.md`
+ *
+ *   ###### In
+ *
+ *   Note: `␊` represents LF.
+ *
+ *   ```markdown
+ *   Alpha␊
+ *   ```
+ *
+ *   ###### Out
+ *
+ *   No messages.
+ *
+ *   ##### `not-ok.md`
+ *
+ *   ###### In
+ *
+ *   Note: The below file does not have a final newline.
+ *
+ *   ```markdown
+ *   Bravo
+ *   ```
+ *
+ *   ###### Out
+ *
+ *   ```text
+ *   1:1: Missing newline character at end of file
+ *   ```
+ */
+
+const remarkLintFinalNewline = lintRule$G(
+  'remark-lint:final-newline',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (_, file) => {
+    const value = String(file);
+    const last = value.length - 1;
+
+    if (last > -1 && value.charAt(last) !== '\n') {
+      file.message('Missing newline character at end of file');
+    }
+  }
+);
+
+var remarkLintFinalNewline$1 = remarkLintFinalNewline;
+
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$F = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$F(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
+
+  Object.defineProperty(plugin, 'name', {value: id});
+
+  return plugin
+
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$G(ruleId, raw);
+
+    if (!severity) return
+
+    const fatal = severity === 2;
+
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
+
+      wrap(rule, (error) => {
+        const messages = file.messages;
+
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
+
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
+
+        next();
+      })(tree, file, options);
+    }
   }
 }
 
-// Assert that `complete` is `true`.
-function assertDone(name, asyncName, complete) {
-  if (!complete) {
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$G(name, value) {
+  /** @type {unknown[]} */
+  let result;
+
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$F.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
+
+  let level = result[0];
+
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
+  }
+
+  if (typeof level !== 'number' || level < 0 || level > 2) {
     throw new Error(
-      '`' + name + '` finished async. Use `' + asyncName + '` instead'
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
     )
   }
-}
-
-var immutable = extend$3;
-
-var hasOwnProperty = Object.prototype.hasOwnProperty;
 
-function extend$3() {
-    var target = {};
-
-    for (var i = 0; i < arguments.length; i++) {
-        var source = arguments[i];
-
-        for (var key in source) {
-            if (hasOwnProperty.call(source, key)) {
-                target[key] = source[key];
-            }
-        }
-    }
+  result[0] = level;
 
-    return target
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var unherit_1 = unherit;
-
-// Create a custom constructor which can be modified without affecting the
-// original class.
-function unherit(Super) {
-  var result;
-  var key;
-  var value;
-
-  inherits(Of, Super);
-  inherits(From, Of);
-
-  // Clone values.
-  result = Of.prototype;
+var pluralize = {exports: {}};
 
-  for (key in result) {
-    value = result[key];
-
-    if (value && typeof value === 'object') {
-      result[key] = 'concat' in value ? value.concat() : immutable(value);
-    }
-  }
-
-  return Of
+/* global define */
 
-  // Constructor accepting a single argument, which itself is an `arguments`
-  // object.
-  function From(parameters) {
-    return Super.apply(this, parameters)
+(function (module, exports) {
+(function (root, pluralize) {
+  /* istanbul ignore else */
+  if (typeof commonjsRequire === 'function' && 'object' === 'object' && 'object' === 'object') {
+    // Node.
+    module.exports = pluralize();
+  } else {
+    // Browser global.
+    root.pluralize = pluralize();
   }
+})(commonjsGlobal, function () {
+  // Rule storage - pluralize and singularize need to be run sequentially,
+  // while other rules can be optimized using an object for instant lookups.
+  var pluralRules = [];
+  var singularRules = [];
+  var uncountables = {};
+  var irregularPlurals = {};
+  var irregularSingles = {};
 
-  // Constructor accepting variadic arguments.
-  function Of() {
-    if (!(this instanceof Of)) {
-      return new From(arguments)
+  /**
+   * Sanitize a pluralization rule to a usable regular expression.
+   *
+   * @param  {(RegExp|string)} rule
+   * @return {RegExp}
+   */
+  function sanitizeRule (rule) {
+    if (typeof rule === 'string') {
+      return new RegExp('^' + rule + '$', 'i');
     }
 
-    return Super.apply(this, arguments)
+    return rule;
   }
-}
 
-var stateToggle = factory$1;
-
-// Construct a state `toggler`: a function which inverses `property` in context
-// based on its current value.
-// The by `toggler` returned function restores that value.
-function factory$1(key, state, ctx) {
-  return enter
-
-  function enter() {
-    var context = ctx || this;
-    var current = context[key];
+  /**
+   * Pass in a word token to produce a function that can replicate the case on
+   * another word.
+   *
+   * @param  {string}   word
+   * @param  {string}   token
+   * @return {Function}
+   */
+  function restoreCase (word, token) {
+    // Tokens are an exact match.
+    if (word === token) return token;
 
-    context[key] = !state;
+    // Lower cased words. E.g. "hello".
+    if (word === word.toLowerCase()) return token.toLowerCase();
 
-    return exit
+    // Upper cased words. E.g. "WHISKY".
+    if (word === word.toUpperCase()) return token.toUpperCase();
 
-    function exit() {
-      context[key] = current;
+    // Title cased words. E.g. "Title".
+    if (word[0] === word[0].toUpperCase()) {
+      return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
     }
-  }
-}
 
-var vfileLocation = factory$2;
-
-function factory$2(file) {
-  var contents = indices(String(file));
-
-  return {
-    toPosition: offsetToPositionFactory(contents),
-    toOffset: positionToOffsetFactory(contents)
+    // Lower cased words. E.g. "test".
+    return token.toLowerCase();
   }
-}
 
-// Factory to get the line and column-based `position` for `offset` in the bound
-// indices.
-function offsetToPositionFactory(indices) {
-  return offsetToPosition
-
-  // Get the line and column-based `position` for `offset` in the bound indices.
-  function offsetToPosition(offset) {
-    var index = -1;
-    var length = indices.length;
+  /**
+   * Interpolate a regexp string.
+   *
+   * @param  {string} str
+   * @param  {Array}  args
+   * @return {string}
+   */
+  function interpolate (str, args) {
+    return str.replace(/\$(\d{1,2})/g, function (match, index) {
+      return args[index] || '';
+    });
+  }
 
-    if (offset < 0) {
-      return {}
-    }
+  /**
+   * Replace a word using a rule.
+   *
+   * @param  {string} word
+   * @param  {Array}  rule
+   * @return {string}
+   */
+  function replace (word, rule) {
+    return word.replace(rule[0], function (match, index) {
+      var result = interpolate(rule[1], arguments);
 
-    while (++index < length) {
-      if (indices[index] > offset) {
-        return {
-          line: index + 1,
-          column: offset - (indices[index - 1] || 0) + 1,
-          offset: offset
-        }
+      if (match === '') {
+        return restoreCase(word[index - 1], result);
       }
-    }
 
-    return {}
+      return restoreCase(match, result);
+    });
   }
-}
 
-// Factory to get the `offset` for a line and column-based `position` in the
-// bound indices.
-function positionToOffsetFactory(indices) {
-  return positionToOffset
-
-  // Get the `offset` for a line and column-based `position` in the bound
-  // indices.
-  function positionToOffset(position) {
-    var line = position && position.line;
-    var column = position && position.column;
-
-    if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {
-      return (indices[line - 2] || 0) + column - 1 || 0
+  /**
+   * Sanitize a word by passing in the word and sanitization rules.
+   *
+   * @param  {string}   token
+   * @param  {string}   word
+   * @param  {Array}    rules
+   * @return {string}
+   */
+  function sanitizeWord (token, word, rules) {
+    // Empty string or doesn't need fixing.
+    if (!token.length || uncountables.hasOwnProperty(token)) {
+      return word;
     }
 
-    return -1
-  }
-}
+    var len = rules.length;
 
-// Get indices of line-breaks in `value`.
-function indices(value) {
-  var result = [];
-  var index = value.indexOf('\n');
+    // Iterate over the sanitization rules and use the first one to match.
+    while (len--) {
+      var rule = rules[len];
 
-  while (index !== -1) {
-    result.push(index + 1);
-    index = value.indexOf('\n', index + 1);
-  }
+      if (rule[0].test(word)) return replace(word, rule);
+    }
 
-  result.push(value.length + 1);
+    return word;
+  }
 
-  return result
-}
+  /**
+   * Replace a word with the updated word.
+   *
+   * @param  {Object}   replaceMap
+   * @param  {Object}   keepMap
+   * @param  {Array}    rules
+   * @return {Function}
+   */
+  function replaceWord (replaceMap, keepMap, rules) {
+    return function (word) {
+      // Get the correct token and case restoration functions.
+      var token = word.toLowerCase();
 
-var _unescape = factory$3;
+      // Check against the keep object map.
+      if (keepMap.hasOwnProperty(token)) {
+        return restoreCase(word, token);
+      }
 
-var backslash$1 = '\\';
+      // Check against the replacement map for a direct word replacement.
+      if (replaceMap.hasOwnProperty(token)) {
+        return restoreCase(word, replaceMap[token]);
+      }
 
-// Factory to de-escape a value, based on a list at `key` in `ctx`.
-function factory$3(ctx, key) {
-  return unescape
+      // Run all the rules against the word.
+      return sanitizeWord(token, word, rules);
+    };
+  }
 
-  // De-escape a string using the expression at `key` in `ctx`.
-  function unescape(value) {
-    var previous = 0;
-    var index = value.indexOf(backslash$1);
-    var escape = ctx[key];
-    var queue = [];
-    var character;
+  /**
+   * Check if a word is part of the map.
+   */
+  function checkWord (replaceMap, keepMap, rules, bool) {
+    return function (word) {
+      var token = word.toLowerCase();
 
-    while (index !== -1) {
-      queue.push(value.slice(previous, index));
-      previous = index + 1;
-      character = value.charAt(previous);
-
-      // If the following character is not a valid escape, add the slash.
-      if (!character || escape.indexOf(character) === -1) {
-        queue.push(backslash$1);
-      }
-
-      index = value.indexOf(backslash$1, previous + 1);
-    }
-
-    queue.push(value.slice(previous));
-
-    return queue.join('')
-  }
-}
-
-const AElig = "Æ";
-const AMP = "&";
-const Aacute = "Á";
-const Acirc = "Â";
-const Agrave = "À";
-const Aring = "Å";
-const Atilde = "Ã";
-const Auml = "Ä";
-const COPY = "©";
-const Ccedil = "Ç";
-const ETH = "Ð";
-const Eacute = "É";
-const Ecirc = "Ê";
-const Egrave = "È";
-const Euml = "Ë";
-const GT = ">";
-const Iacute = "Í";
-const Icirc = "Î";
-const Igrave = "Ì";
-const Iuml = "Ï";
-const LT = "<";
-const Ntilde = "Ñ";
-const Oacute = "Ó";
-const Ocirc = "Ô";
-const Ograve = "Ò";
-const Oslash = "Ø";
-const Otilde = "Õ";
-const Ouml = "Ö";
-const QUOT = "\"";
-const REG = "®";
-const THORN = "Þ";
-const Uacute = "Ú";
-const Ucirc = "Û";
-const Ugrave = "Ù";
-const Uuml = "Ü";
-const Yacute = "Ý";
-const aacute = "á";
-const acirc = "â";
-const acute = "´";
-const aelig = "æ";
-const agrave = "à";
-const amp = "&";
-const aring = "å";
-const atilde = "ã";
-const auml = "ä";
-const brvbar = "¦";
-const ccedil = "ç";
-const cedil = "¸";
-const cent = "¢";
-const copy$1 = "©";
-const curren = "¤";
-const deg = "°";
-const divide = "÷";
-const eacute = "é";
-const ecirc = "ê";
-const egrave = "è";
-const eth = "ð";
-const euml = "ë";
-const frac12 = "½";
-const frac14 = "¼";
-const frac34 = "¾";
-const gt = ">";
-const iacute = "í";
-const icirc = "î";
-const iexcl = "¡";
-const igrave = "ì";
-const iquest = "¿";
-const iuml = "ï";
-const laquo = "«";
-const lt = "<";
-const macr = "¯";
-const micro = "µ";
-const middot = "·";
-const nbsp = " ";
-const not = "¬";
-const ntilde = "ñ";
-const oacute = "ó";
-const ocirc = "ô";
-const ograve = "ò";
-const ordf = "ª";
-const ordm = "º";
-const oslash = "ø";
-const otilde = "õ";
-const ouml = "ö";
-const para = "¶";
-const plusmn = "±";
-const pound = "£";
-const quot = "\"";
-const raquo = "»";
-const reg = "®";
-const sect = "§";
-const shy = "­";
-const sup1 = "¹";
-const sup2 = "²";
-const sup3 = "³";
-const szlig = "ß";
-const thorn = "þ";
-const times = "×";
-const uacute = "ú";
-const ucirc = "û";
-const ugrave = "ù";
-const uml = "¨";
-const uuml = "ü";
-const yacute = "ý";
-const yen = "¥";
-const yuml = "ÿ";
-var index$1 = {
-	AElig: AElig,
-	AMP: AMP,
-	Aacute: Aacute,
-	Acirc: Acirc,
-	Agrave: Agrave,
-	Aring: Aring,
-	Atilde: Atilde,
-	Auml: Auml,
-	COPY: COPY,
-	Ccedil: Ccedil,
-	ETH: ETH,
-	Eacute: Eacute,
-	Ecirc: Ecirc,
-	Egrave: Egrave,
-	Euml: Euml,
-	GT: GT,
-	Iacute: Iacute,
-	Icirc: Icirc,
-	Igrave: Igrave,
-	Iuml: Iuml,
-	LT: LT,
-	Ntilde: Ntilde,
-	Oacute: Oacute,
-	Ocirc: Ocirc,
-	Ograve: Ograve,
-	Oslash: Oslash,
-	Otilde: Otilde,
-	Ouml: Ouml,
-	QUOT: QUOT,
-	REG: REG,
-	THORN: THORN,
-	Uacute: Uacute,
-	Ucirc: Ucirc,
-	Ugrave: Ugrave,
-	Uuml: Uuml,
-	Yacute: Yacute,
-	aacute: aacute,
-	acirc: acirc,
-	acute: acute,
-	aelig: aelig,
-	agrave: agrave,
-	amp: amp,
-	aring: aring,
-	atilde: atilde,
-	auml: auml,
-	brvbar: brvbar,
-	ccedil: ccedil,
-	cedil: cedil,
-	cent: cent,
-	copy: copy$1,
-	curren: curren,
-	deg: deg,
-	divide: divide,
-	eacute: eacute,
-	ecirc: ecirc,
-	egrave: egrave,
-	eth: eth,
-	euml: euml,
-	frac12: frac12,
-	frac14: frac14,
-	frac34: frac34,
-	gt: gt,
-	iacute: iacute,
-	icirc: icirc,
-	iexcl: iexcl,
-	igrave: igrave,
-	iquest: iquest,
-	iuml: iuml,
-	laquo: laquo,
-	lt: lt,
-	macr: macr,
-	micro: micro,
-	middot: middot,
-	nbsp: nbsp,
-	not: not,
-	ntilde: ntilde,
-	oacute: oacute,
-	ocirc: ocirc,
-	ograve: ograve,
-	ordf: ordf,
-	ordm: ordm,
-	oslash: oslash,
-	otilde: otilde,
-	ouml: ouml,
-	para: para,
-	plusmn: plusmn,
-	pound: pound,
-	quot: quot,
-	raquo: raquo,
-	reg: reg,
-	sect: sect,
-	shy: shy,
-	sup1: sup1,
-	sup2: sup2,
-	sup3: sup3,
-	szlig: szlig,
-	thorn: thorn,
-	times: times,
-	uacute: uacute,
-	ucirc: ucirc,
-	ugrave: ugrave,
-	uml: uml,
-	uuml: uuml,
-	yacute: yacute,
-	yen: yen,
-	yuml: yuml
-};
-
-var characterEntitiesLegacy = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AElig: AElig,
-  AMP: AMP,
-  Aacute: Aacute,
-  Acirc: Acirc,
-  Agrave: Agrave,
-  Aring: Aring,
-  Atilde: Atilde,
-  Auml: Auml,
-  COPY: COPY,
-  Ccedil: Ccedil,
-  ETH: ETH,
-  Eacute: Eacute,
-  Ecirc: Ecirc,
-  Egrave: Egrave,
-  Euml: Euml,
-  GT: GT,
-  Iacute: Iacute,
-  Icirc: Icirc,
-  Igrave: Igrave,
-  Iuml: Iuml,
-  LT: LT,
-  Ntilde: Ntilde,
-  Oacute: Oacute,
-  Ocirc: Ocirc,
-  Ograve: Ograve,
-  Oslash: Oslash,
-  Otilde: Otilde,
-  Ouml: Ouml,
-  QUOT: QUOT,
-  REG: REG,
-  THORN: THORN,
-  Uacute: Uacute,
-  Ucirc: Ucirc,
-  Ugrave: Ugrave,
-  Uuml: Uuml,
-  Yacute: Yacute,
-  aacute: aacute,
-  acirc: acirc,
-  acute: acute,
-  aelig: aelig,
-  agrave: agrave,
-  amp: amp,
-  aring: aring,
-  atilde: atilde,
-  auml: auml,
-  brvbar: brvbar,
-  ccedil: ccedil,
-  cedil: cedil,
-  cent: cent,
-  copy: copy$1,
-  curren: curren,
-  deg: deg,
-  divide: divide,
-  eacute: eacute,
-  ecirc: ecirc,
-  egrave: egrave,
-  eth: eth,
-  euml: euml,
-  frac12: frac12,
-  frac14: frac14,
-  frac34: frac34,
-  gt: gt,
-  iacute: iacute,
-  icirc: icirc,
-  iexcl: iexcl,
-  igrave: igrave,
-  iquest: iquest,
-  iuml: iuml,
-  laquo: laquo,
-  lt: lt,
-  macr: macr,
-  micro: micro,
-  middot: middot,
-  nbsp: nbsp,
-  not: not,
-  ntilde: ntilde,
-  oacute: oacute,
-  ocirc: ocirc,
-  ograve: ograve,
-  ordf: ordf,
-  ordm: ordm,
-  oslash: oslash,
-  otilde: otilde,
-  ouml: ouml,
-  para: para,
-  plusmn: plusmn,
-  pound: pound,
-  quot: quot,
-  raquo: raquo,
-  reg: reg,
-  sect: sect,
-  shy: shy,
-  sup1: sup1,
-  sup2: sup2,
-  sup3: sup3,
-  szlig: szlig,
-  thorn: thorn,
-  times: times,
-  uacute: uacute,
-  ucirc: ucirc,
-  ugrave: ugrave,
-  uml: uml,
-  uuml: uuml,
-  yacute: yacute,
-  yen: yen,
-  yuml: yuml,
-  'default': index$1
-});
+      if (keepMap.hasOwnProperty(token)) return true;
+      if (replaceMap.hasOwnProperty(token)) return false;
 
-var index$2 = {
-	"0": "�",
-	"128": "€",
-	"130": "‚",
-	"131": "ƒ",
-	"132": "„",
-	"133": "…",
-	"134": "†",
-	"135": "‡",
-	"136": "ˆ",
-	"137": "‰",
-	"138": "Š",
-	"139": "‹",
-	"140": "Œ",
-	"142": "Ž",
-	"145": "‘",
-	"146": "’",
-	"147": "“",
-	"148": "”",
-	"149": "•",
-	"150": "–",
-	"151": "—",
-	"152": "˜",
-	"153": "™",
-	"154": "š",
-	"155": "›",
-	"156": "œ",
-	"158": "ž",
-	"159": "Ÿ"
-};
-
-var characterReferenceInvalid = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': index$2
-});
+      return sanitizeWord(token, token, rules) === token;
+    };
+  }
 
-var isDecimal = decimal;
+  /**
+   * Pluralize or singularize a word based on the passed in count.
+   *
+   * @param  {string}  word      The word to pluralize
+   * @param  {number}  count     How many of the word exist
+   * @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
+   * @return {string}
+   */
+  function pluralize (word, count, inclusive) {
+    var pluralized = count === 1
+      ? pluralize.singular(word) : pluralize.plural(word);
 
-// Check if the given character code, or the character code at the first
-// character, is decimal.
-function decimal(character) {
-  var code = typeof character === 'string' ? character.charCodeAt(0) : character;
+    return (inclusive ? count + ' ' : '') + pluralized;
+  }
 
-  return code >= 48 && code <= 57 /* 0-9 */
-}
+  /**
+   * Pluralize a word.
+   *
+   * @type {Function}
+   */
+  pluralize.plural = replaceWord(
+    irregularSingles, irregularPlurals, pluralRules
+  );
 
-var isHexadecimal = hexadecimal;
+  /**
+   * Check if a word is plural.
+   *
+   * @type {Function}
+   */
+  pluralize.isPlural = checkWord(
+    irregularSingles, irregularPlurals, pluralRules
+  );
 
-// Check if the given character code, or the character code at the first
-// character, is hexadecimal.
-function hexadecimal(character) {
-  var code = typeof character === 'string' ? character.charCodeAt(0) : character;
+  /**
+   * Singularize a word.
+   *
+   * @type {Function}
+   */
+  pluralize.singular = replaceWord(
+    irregularPlurals, irregularSingles, singularRules
+  );
 
-  return (
-    (code >= 97 /* a */ && code <= 102) /* z */ ||
-    (code >= 65 /* A */ && code <= 70) /* Z */ ||
-    (code >= 48 /* A */ && code <= 57) /* Z */
-  )
-}
+  /**
+   * Check if a word is singular.
+   *
+   * @type {Function}
+   */
+  pluralize.isSingular = checkWord(
+    irregularPlurals, irregularSingles, singularRules
+  );
 
-var isAlphabetical = alphabetical;
+  /**
+   * Add a pluralization rule to the collection.
+   *
+   * @param {(string|RegExp)} rule
+   * @param {string}          replacement
+   */
+  pluralize.addPluralRule = function (rule, replacement) {
+    pluralRules.push([sanitizeRule(rule), replacement]);
+  };
 
-// Check if the given character code, or the character code at the first
-// character, is alphabetical.
-function alphabetical(character) {
-  var code = typeof character === 'string' ? character.charCodeAt(0) : character;
+  /**
+   * Add a singularization rule to the collection.
+   *
+   * @param {(string|RegExp)} rule
+   * @param {string}          replacement
+   */
+  pluralize.addSingularRule = function (rule, replacement) {
+    singularRules.push([sanitizeRule(rule), replacement]);
+  };
 
-  return (
-    (code >= 97 && code <= 122) /* a-z */ ||
-    (code >= 65 && code <= 90) /* A-Z */
-  )
-}
+  /**
+   * Add an uncountable word rule.
+   *
+   * @param {(string|RegExp)} word
+   */
+  pluralize.addUncountableRule = function (word) {
+    if (typeof word === 'string') {
+      uncountables[word.toLowerCase()] = true;
+      return;
+    }
 
-var isAlphanumerical = alphanumerical;
-
-// Check if the given character code, or the character code at the first
-// character, is alphanumerical.
-function alphanumerical(character) {
-  return isAlphabetical(character) || isDecimal(character)
-}
-
-const AEli = "Æ";
-const AElig$1 = "Æ";
-const AM = "&";
-const AMP$1 = "&";
-const Aacut = "Á";
-const Aacute$1 = "Á";
-const Abreve = "Ă";
-const Acir = "Â";
-const Acirc$1 = "Â";
-const Acy = "А";
-const Afr = "𝔄";
-const Agrav = "À";
-const Agrave$1 = "À";
-const Alpha = "Α";
-const Amacr = "Ā";
-const And = "⩓";
-const Aogon = "Ą";
-const Aopf = "𝔸";
-const ApplyFunction = "⁡";
-const Arin = "Å";
-const Aring$1 = "Å";
-const Ascr = "𝒜";
-const Assign = "≔";
-const Atild = "Ã";
-const Atilde$1 = "Ã";
-const Aum = "Ä";
-const Auml$1 = "Ä";
-const Backslash = "∖";
-const Barv = "⫧";
-const Barwed = "⌆";
-const Bcy = "Б";
-const Because = "∵";
-const Bernoullis = "ℬ";
-const Beta = "Β";
-const Bfr = "𝔅";
-const Bopf = "𝔹";
-const Breve = "˘";
-const Bscr = "ℬ";
-const Bumpeq = "≎";
-const CHcy = "Ч";
-const COP = "©";
-const COPY$1 = "©";
-const Cacute = "Ć";
-const Cap = "⋒";
-const CapitalDifferentialD = "ⅅ";
-const Cayleys = "ℭ";
-const Ccaron = "Č";
-const Ccedi = "Ç";
-const Ccedil$1 = "Ç";
-const Ccirc = "Ĉ";
-const Cconint = "∰";
-const Cdot = "Ċ";
-const Cedilla = "¸";
-const CenterDot = "·";
-const Cfr = "ℭ";
-const Chi = "Χ";
-const CircleDot = "⊙";
-const CircleMinus = "⊖";
-const CirclePlus = "⊕";
-const CircleTimes = "⊗";
-const ClockwiseContourIntegral = "∲";
-const CloseCurlyDoubleQuote = "”";
-const CloseCurlyQuote = "’";
-const Colon = "∷";
-const Colone = "⩴";
-const Congruent = "≡";
-const Conint = "∯";
-const ContourIntegral = "∮";
-const Copf = "ℂ";
-const Coproduct = "∐";
-const CounterClockwiseContourIntegral = "∳";
-const Cross = "⨯";
-const Cscr = "𝒞";
-const Cup = "⋓";
-const CupCap = "≍";
-const DD = "ⅅ";
-const DDotrahd = "⤑";
-const DJcy = "Ђ";
-const DScy = "Ѕ";
-const DZcy = "Џ";
-const Dagger = "‡";
-const Darr = "↡";
-const Dashv = "⫤";
-const Dcaron = "Ď";
-const Dcy = "Д";
-const Del = "∇";
-const Delta = "Δ";
-const Dfr = "𝔇";
-const DiacriticalAcute = "´";
-const DiacriticalDot = "˙";
-const DiacriticalDoubleAcute = "˝";
-const DiacriticalGrave = "`";
-const DiacriticalTilde = "˜";
-const Diamond = "⋄";
-const DifferentialD = "ⅆ";
-const Dopf = "𝔻";
-const Dot = "¨";
-const DotDot = "⃜";
-const DotEqual = "≐";
-const DoubleContourIntegral = "∯";
-const DoubleDot = "¨";
-const DoubleDownArrow = "⇓";
-const DoubleLeftArrow = "⇐";
-const DoubleLeftRightArrow = "⇔";
-const DoubleLeftTee = "⫤";
-const DoubleLongLeftArrow = "⟸";
-const DoubleLongLeftRightArrow = "⟺";
-const DoubleLongRightArrow = "⟹";
-const DoubleRightArrow = "⇒";
-const DoubleRightTee = "⊨";
-const DoubleUpArrow = "⇑";
-const DoubleUpDownArrow = "⇕";
-const DoubleVerticalBar = "∥";
-const DownArrow = "↓";
-const DownArrowBar = "⤓";
-const DownArrowUpArrow = "⇵";
-const DownBreve = "̑";
-const DownLeftRightVector = "⥐";
-const DownLeftTeeVector = "⥞";
-const DownLeftVector = "↽";
-const DownLeftVectorBar = "⥖";
-const DownRightTeeVector = "⥟";
-const DownRightVector = "⇁";
-const DownRightVectorBar = "⥗";
-const DownTee = "⊤";
-const DownTeeArrow = "↧";
-const Downarrow = "⇓";
-const Dscr = "𝒟";
-const Dstrok = "Đ";
-const ENG = "Ŋ";
-const ET = "Ð";
-const ETH$1 = "Ð";
-const Eacut = "É";
-const Eacute$1 = "É";
-const Ecaron = "Ě";
-const Ecir = "Ê";
-const Ecirc$1 = "Ê";
-const Ecy = "Э";
-const Edot = "Ė";
-const Efr = "𝔈";
-const Egrav = "È";
-const Egrave$1 = "È";
-const Element = "∈";
-const Emacr = "Ē";
-const EmptySmallSquare = "◻";
-const EmptyVerySmallSquare = "▫";
-const Eogon = "Ę";
-const Eopf = "𝔼";
-const Epsilon = "Ε";
-const Equal = "⩵";
-const EqualTilde = "≂";
-const Equilibrium = "⇌";
-const Escr = "ℰ";
-const Esim = "⩳";
-const Eta = "Η";
-const Eum = "Ë";
-const Euml$1 = "Ë";
-const Exists = "∃";
-const ExponentialE = "ⅇ";
-const Fcy = "Ф";
-const Ffr = "𝔉";
-const FilledSmallSquare = "◼";
-const FilledVerySmallSquare = "▪";
-const Fopf = "𝔽";
-const ForAll = "∀";
-const Fouriertrf = "ℱ";
-const Fscr = "ℱ";
-const GJcy = "Ѓ";
-const G = ">";
-const GT$1 = ">";
-const Gamma = "Γ";
-const Gammad = "Ϝ";
-const Gbreve = "Ğ";
-const Gcedil = "Ģ";
-const Gcirc = "Ĝ";
-const Gcy = "Г";
-const Gdot = "Ġ";
-const Gfr = "𝔊";
-const Gg = "⋙";
-const Gopf = "𝔾";
-const GreaterEqual = "≥";
-const GreaterEqualLess = "⋛";
-const GreaterFullEqual = "≧";
-const GreaterGreater = "⪢";
-const GreaterLess = "≷";
-const GreaterSlantEqual = "⩾";
-const GreaterTilde = "≳";
-const Gscr = "𝒢";
-const Gt = "≫";
-const HARDcy = "Ъ";
-const Hacek = "ˇ";
-const Hat = "^";
-const Hcirc = "Ĥ";
-const Hfr = "ℌ";
-const HilbertSpace = "ℋ";
-const Hopf = "ℍ";
-const HorizontalLine = "─";
-const Hscr = "ℋ";
-const Hstrok = "Ħ";
-const HumpDownHump = "≎";
-const HumpEqual = "≏";
-const IEcy = "Е";
-const IJlig = "IJ";
-const IOcy = "Ё";
-const Iacut = "Í";
-const Iacute$1 = "Í";
-const Icir = "Î";
-const Icirc$1 = "Î";
-const Icy = "И";
-const Idot = "İ";
-const Ifr = "ℑ";
-const Igrav = "Ì";
-const Igrave$1 = "Ì";
-const Im = "ℑ";
-const Imacr = "Ī";
-const ImaginaryI = "ⅈ";
-const Implies = "⇒";
-const Int = "∬";
-const Integral = "∫";
-const Intersection = "⋂";
-const InvisibleComma = "⁣";
-const InvisibleTimes = "⁢";
-const Iogon = "Į";
-const Iopf = "𝕀";
-const Iota = "Ι";
-const Iscr = "ℐ";
-const Itilde = "Ĩ";
-const Iukcy = "І";
-const Ium = "Ï";
-const Iuml$1 = "Ï";
-const Jcirc = "Ĵ";
-const Jcy = "Й";
-const Jfr = "𝔍";
-const Jopf = "𝕁";
-const Jscr = "𝒥";
-const Jsercy = "Ј";
-const Jukcy = "Є";
-const KHcy = "Х";
-const KJcy = "Ќ";
-const Kappa = "Κ";
-const Kcedil = "Ķ";
-const Kcy = "К";
-const Kfr = "𝔎";
-const Kopf = "𝕂";
-const Kscr = "𝒦";
-const LJcy = "Љ";
-const L = "<";
-const LT$1 = "<";
-const Lacute = "Ĺ";
-const Lambda = "Λ";
-const Lang = "⟪";
-const Laplacetrf = "ℒ";
-const Larr = "↞";
-const Lcaron = "Ľ";
-const Lcedil = "Ļ";
-const Lcy = "Л";
-const LeftAngleBracket = "⟨";
-const LeftArrow = "←";
-const LeftArrowBar = "⇤";
-const LeftArrowRightArrow = "⇆";
-const LeftCeiling = "⌈";
-const LeftDoubleBracket = "⟦";
-const LeftDownTeeVector = "⥡";
-const LeftDownVector = "⇃";
-const LeftDownVectorBar = "⥙";
-const LeftFloor = "⌊";
-const LeftRightArrow = "↔";
-const LeftRightVector = "⥎";
-const LeftTee = "⊣";
-const LeftTeeArrow = "↤";
-const LeftTeeVector = "⥚";
-const LeftTriangle = "⊲";
-const LeftTriangleBar = "⧏";
-const LeftTriangleEqual = "⊴";
-const LeftUpDownVector = "⥑";
-const LeftUpTeeVector = "⥠";
-const LeftUpVector = "↿";
-const LeftUpVectorBar = "⥘";
-const LeftVector = "↼";
-const LeftVectorBar = "⥒";
-const Leftarrow = "⇐";
-const Leftrightarrow = "⇔";
-const LessEqualGreater = "⋚";
-const LessFullEqual = "≦";
-const LessGreater = "≶";
-const LessLess = "⪡";
-const LessSlantEqual = "⩽";
-const LessTilde = "≲";
-const Lfr = "𝔏";
-const Ll = "⋘";
-const Lleftarrow = "⇚";
-const Lmidot = "Ŀ";
-const LongLeftArrow = "⟵";
-const LongLeftRightArrow = "⟷";
-const LongRightArrow = "⟶";
-const Longleftarrow = "⟸";
-const Longleftrightarrow = "⟺";
-const Longrightarrow = "⟹";
-const Lopf = "𝕃";
-const LowerLeftArrow = "↙";
-const LowerRightArrow = "↘";
-const Lscr = "ℒ";
-const Lsh = "↰";
-const Lstrok = "Ł";
-const Lt = "≪";
-const Mcy = "М";
-const MediumSpace = " ";
-const Mellintrf = "ℳ";
-const Mfr = "𝔐";
-const MinusPlus = "∓";
-const Mopf = "𝕄";
-const Mscr = "ℳ";
-const Mu = "Μ";
-const NJcy = "Њ";
-const Nacute = "Ń";
-const Ncaron = "Ň";
-const Ncedil = "Ņ";
-const Ncy = "Н";
-const NegativeMediumSpace = "​";
-const NegativeThickSpace = "​";
-const NegativeThinSpace = "​";
-const NegativeVeryThinSpace = "​";
-const NestedGreaterGreater = "≫";
-const NestedLessLess = "≪";
-const NewLine = "\n";
-const Nfr = "𝔑";
-const NoBreak = "⁠";
-const NonBreakingSpace = " ";
-const Nopf = "ℕ";
-const Not = "⫬";
-const NotCongruent = "≢";
-const NotCupCap = "≭";
-const NotDoubleVerticalBar = "∦";
-const NotElement = "∉";
-const NotEqual = "≠";
-const NotEqualTilde = "≂̸";
-const NotExists = "∄";
-const NotGreater = "≯";
-const NotGreaterEqual = "≱";
-const NotGreaterFullEqual = "≧̸";
-const NotGreaterGreater = "≫̸";
-const NotGreaterLess = "≹";
-const NotGreaterSlantEqual = "⩾̸";
-const NotGreaterTilde = "≵";
-const NotHumpDownHump = "≎̸";
-const NotHumpEqual = "≏̸";
-const NotLeftTriangle = "⋪";
-const NotLeftTriangleBar = "⧏̸";
-const NotLeftTriangleEqual = "⋬";
-const NotLess = "≮";
-const NotLessEqual = "≰";
-const NotLessGreater = "≸";
-const NotLessLess = "≪̸";
-const NotLessSlantEqual = "⩽̸";
-const NotLessTilde = "≴";
-const NotNestedGreaterGreater = "⪢̸";
-const NotNestedLessLess = "⪡̸";
-const NotPrecedes = "⊀";
-const NotPrecedesEqual = "⪯̸";
-const NotPrecedesSlantEqual = "⋠";
-const NotReverseElement = "∌";
-const NotRightTriangle = "⋫";
-const NotRightTriangleBar = "⧐̸";
-const NotRightTriangleEqual = "⋭";
-const NotSquareSubset = "⊏̸";
-const NotSquareSubsetEqual = "⋢";
-const NotSquareSuperset = "⊐̸";
-const NotSquareSupersetEqual = "⋣";
-const NotSubset = "⊂⃒";
-const NotSubsetEqual = "⊈";
-const NotSucceeds = "⊁";
-const NotSucceedsEqual = "⪰̸";
-const NotSucceedsSlantEqual = "⋡";
-const NotSucceedsTilde = "≿̸";
-const NotSuperset = "⊃⃒";
-const NotSupersetEqual = "⊉";
-const NotTilde = "≁";
-const NotTildeEqual = "≄";
-const NotTildeFullEqual = "≇";
-const NotTildeTilde = "≉";
-const NotVerticalBar = "∤";
-const Nscr = "𝒩";
-const Ntild = "Ñ";
-const Ntilde$1 = "Ñ";
-const Nu = "Ν";
-const OElig = "Œ";
-const Oacut = "Ó";
-const Oacute$1 = "Ó";
-const Ocir = "Ô";
-const Ocirc$1 = "Ô";
-const Ocy = "О";
-const Odblac = "Ő";
-const Ofr = "𝔒";
-const Ograv = "Ò";
-const Ograve$1 = "Ò";
-const Omacr = "Ō";
-const Omega = "Ω";
-const Omicron = "Ο";
-const Oopf = "𝕆";
-const OpenCurlyDoubleQuote = "“";
-const OpenCurlyQuote = "‘";
-const Or = "⩔";
-const Oscr = "𝒪";
-const Oslas = "Ø";
-const Oslash$1 = "Ø";
-const Otild = "Õ";
-const Otilde$1 = "Õ";
-const Otimes = "⨷";
-const Oum = "Ö";
-const Ouml$1 = "Ö";
-const OverBar = "‾";
-const OverBrace = "⏞";
-const OverBracket = "⎴";
-const OverParenthesis = "⏜";
-const PartialD = "∂";
-const Pcy = "П";
-const Pfr = "𝔓";
-const Phi = "Φ";
-const Pi = "Π";
-const PlusMinus = "±";
-const Poincareplane = "ℌ";
-const Popf = "ℙ";
-const Pr = "⪻";
-const Precedes = "≺";
-const PrecedesEqual = "⪯";
-const PrecedesSlantEqual = "≼";
-const PrecedesTilde = "≾";
-const Prime = "″";
-const Product = "∏";
-const Proportion = "∷";
-const Proportional = "∝";
-const Pscr = "𝒫";
-const Psi = "Ψ";
-const QUO = "\"";
-const QUOT$1 = "\"";
-const Qfr = "𝔔";
-const Qopf = "ℚ";
-const Qscr = "𝒬";
-const RBarr = "⤐";
-const RE = "®";
-const REG$1 = "®";
-const Racute = "Ŕ";
-const Rang = "⟫";
-const Rarr = "↠";
-const Rarrtl = "⤖";
-const Rcaron = "Ř";
-const Rcedil = "Ŗ";
-const Rcy = "Р";
-const Re = "ℜ";
-const ReverseElement = "∋";
-const ReverseEquilibrium = "⇋";
-const ReverseUpEquilibrium = "⥯";
-const Rfr = "ℜ";
-const Rho = "Ρ";
-const RightAngleBracket = "⟩";
-const RightArrow = "→";
-const RightArrowBar = "⇥";
-const RightArrowLeftArrow = "⇄";
-const RightCeiling = "⌉";
-const RightDoubleBracket = "⟧";
-const RightDownTeeVector = "⥝";
-const RightDownVector = "⇂";
-const RightDownVectorBar = "⥕";
-const RightFloor = "⌋";
-const RightTee = "⊢";
-const RightTeeArrow = "↦";
-const RightTeeVector = "⥛";
-const RightTriangle = "⊳";
-const RightTriangleBar = "⧐";
-const RightTriangleEqual = "⊵";
-const RightUpDownVector = "⥏";
-const RightUpTeeVector = "⥜";
-const RightUpVector = "↾";
-const RightUpVectorBar = "⥔";
-const RightVector = "⇀";
-const RightVectorBar = "⥓";
-const Rightarrow = "⇒";
-const Ropf = "ℝ";
-const RoundImplies = "⥰";
-const Rrightarrow = "⇛";
-const Rscr = "ℛ";
-const Rsh = "↱";
-const RuleDelayed = "⧴";
-const SHCHcy = "Щ";
-const SHcy = "Ш";
-const SOFTcy = "Ь";
-const Sacute = "Ś";
-const Sc = "⪼";
-const Scaron = "Š";
-const Scedil = "Ş";
-const Scirc = "Ŝ";
-const Scy = "С";
-const Sfr = "𝔖";
-const ShortDownArrow = "↓";
-const ShortLeftArrow = "←";
-const ShortRightArrow = "→";
-const ShortUpArrow = "↑";
-const Sigma = "Σ";
-const SmallCircle = "∘";
-const Sopf = "𝕊";
-const Sqrt = "√";
-const Square = "□";
-const SquareIntersection = "⊓";
-const SquareSubset = "⊏";
-const SquareSubsetEqual = "⊑";
-const SquareSuperset = "⊐";
-const SquareSupersetEqual = "⊒";
-const SquareUnion = "⊔";
-const Sscr = "𝒮";
-const Star = "⋆";
-const Sub = "⋐";
-const Subset = "⋐";
-const SubsetEqual = "⊆";
-const Succeeds = "≻";
-const SucceedsEqual = "⪰";
-const SucceedsSlantEqual = "≽";
-const SucceedsTilde = "≿";
-const SuchThat = "∋";
-const Sum = "∑";
-const Sup = "⋑";
-const Superset = "⊃";
-const SupersetEqual = "⊇";
-const Supset = "⋑";
-const THOR = "Þ";
-const THORN$1 = "Þ";
-const TRADE = "™";
-const TSHcy = "Ћ";
-const TScy = "Ц";
-const Tab = "\t";
-const Tau = "Τ";
-const Tcaron = "Ť";
-const Tcedil = "Ţ";
-const Tcy = "Т";
-const Tfr = "𝔗";
-const Therefore = "∴";
-const Theta = "Θ";
-const ThickSpace = "  ";
-const ThinSpace = " ";
-const Tilde = "∼";
-const TildeEqual = "≃";
-const TildeFullEqual = "≅";
-const TildeTilde = "≈";
-const Topf = "𝕋";
-const TripleDot = "⃛";
-const Tscr = "𝒯";
-const Tstrok = "Ŧ";
-const Uacut = "Ú";
-const Uacute$1 = "Ú";
-const Uarr = "↟";
-const Uarrocir = "⥉";
-const Ubrcy = "Ў";
-const Ubreve = "Ŭ";
-const Ucir = "Û";
-const Ucirc$1 = "Û";
-const Ucy = "У";
-const Udblac = "Ű";
-const Ufr = "𝔘";
-const Ugrav = "Ù";
-const Ugrave$1 = "Ù";
-const Umacr = "Ū";
-const UnderBar = "_";
-const UnderBrace = "⏟";
-const UnderBracket = "⎵";
-const UnderParenthesis = "⏝";
-const Union = "⋃";
-const UnionPlus = "⊎";
-const Uogon = "Ų";
-const Uopf = "𝕌";
-const UpArrow = "↑";
-const UpArrowBar = "⤒";
-const UpArrowDownArrow = "⇅";
-const UpDownArrow = "↕";
-const UpEquilibrium = "⥮";
-const UpTee = "⊥";
-const UpTeeArrow = "↥";
-const Uparrow = "⇑";
-const Updownarrow = "⇕";
-const UpperLeftArrow = "↖";
-const UpperRightArrow = "↗";
-const Upsi = "ϒ";
-const Upsilon = "Υ";
-const Uring = "Ů";
-const Uscr = "𝒰";
-const Utilde = "Ũ";
-const Uum = "Ü";
-const Uuml$1 = "Ü";
-const VDash = "⊫";
-const Vbar = "⫫";
-const Vcy = "В";
-const Vdash = "⊩";
-const Vdashl = "⫦";
-const Vee = "⋁";
-const Verbar = "‖";
-const Vert = "‖";
-const VerticalBar = "∣";
-const VerticalLine = "|";
-const VerticalSeparator = "❘";
-const VerticalTilde = "≀";
-const VeryThinSpace = " ";
-const Vfr = "𝔙";
-const Vopf = "𝕍";
-const Vscr = "𝒱";
-const Vvdash = "⊪";
-const Wcirc = "Ŵ";
-const Wedge = "⋀";
-const Wfr = "𝔚";
-const Wopf = "𝕎";
-const Wscr = "𝒲";
-const Xfr = "𝔛";
-const Xi = "Ξ";
-const Xopf = "𝕏";
-const Xscr = "𝒳";
-const YAcy = "Я";
-const YIcy = "Ї";
-const YUcy = "Ю";
-const Yacut = "Ý";
-const Yacute$1 = "Ý";
-const Ycirc = "Ŷ";
-const Ycy = "Ы";
-const Yfr = "𝔜";
-const Yopf = "𝕐";
-const Yscr = "𝒴";
-const Yuml = "Ÿ";
-const ZHcy = "Ж";
-const Zacute = "Ź";
-const Zcaron = "Ž";
-const Zcy = "З";
-const Zdot = "Ż";
-const ZeroWidthSpace = "​";
-const Zeta = "Ζ";
-const Zfr = "ℨ";
-const Zopf = "ℤ";
-const Zscr = "𝒵";
-const aacut = "á";
-const aacute$1 = "á";
-const abreve = "ă";
-const ac = "∾";
-const acE = "∾̳";
-const acd = "∿";
-const acir = "â";
-const acirc$1 = "â";
-const acut = "´";
-const acute$1 = "´";
-const acy = "а";
-const aeli = "æ";
-const aelig$1 = "æ";
-const af = "⁡";
-const afr = "𝔞";
-const agrav = "à";
-const agrave$1 = "à";
-const alefsym = "ℵ";
-const aleph = "ℵ";
-const alpha = "α";
-const amacr = "ā";
-const amalg = "⨿";
-const am = "&";
-const amp$1 = "&";
-const and = "∧";
-const andand = "⩕";
-const andd = "⩜";
-const andslope = "⩘";
-const andv = "⩚";
-const ang = "∠";
-const ange = "⦤";
-const angle = "∠";
-const angmsd = "∡";
-const angmsdaa = "⦨";
-const angmsdab = "⦩";
-const angmsdac = "⦪";
-const angmsdad = "⦫";
-const angmsdae = "⦬";
-const angmsdaf = "⦭";
-const angmsdag = "⦮";
-const angmsdah = "⦯";
-const angrt = "∟";
-const angrtvb = "⊾";
-const angrtvbd = "⦝";
-const angsph = "∢";
-const angst = "Å";
-const angzarr = "⍼";
-const aogon = "ą";
-const aopf = "𝕒";
-const ap = "≈";
-const apE = "⩰";
-const apacir = "⩯";
-const ape = "≊";
-const apid = "≋";
-const apos = "'";
-const approx = "≈";
-const approxeq = "≊";
-const arin = "å";
-const aring$1 = "å";
-const ascr = "𝒶";
-const ast = "*";
-const asymp = "≈";
-const asympeq = "≍";
-const atild = "ã";
-const atilde$1 = "ã";
-const aum = "ä";
-const auml$1 = "ä";
-const awconint = "∳";
-const awint = "⨑";
-const bNot = "⫭";
-const backcong = "≌";
-const backepsilon = "϶";
-const backprime = "‵";
-const backsim = "∽";
-const backsimeq = "⋍";
-const barvee = "⊽";
-const barwed = "⌅";
-const barwedge = "⌅";
-const bbrk = "⎵";
-const bbrktbrk = "⎶";
-const bcong = "≌";
-const bcy = "б";
-const bdquo = "„";
-const becaus = "∵";
-const because = "∵";
-const bemptyv = "⦰";
-const bepsi = "϶";
-const bernou = "ℬ";
-const beta = "β";
-const beth = "ℶ";
-const between = "≬";
-const bfr = "𝔟";
-const bigcap = "⋂";
-const bigcirc = "◯";
-const bigcup = "⋃";
-const bigodot = "⨀";
-const bigoplus = "⨁";
-const bigotimes = "⨂";
-const bigsqcup = "⨆";
-const bigstar = "★";
-const bigtriangledown = "▽";
-const bigtriangleup = "△";
-const biguplus = "⨄";
-const bigvee = "⋁";
-const bigwedge = "⋀";
-const bkarow = "⤍";
-const blacklozenge = "⧫";
-const blacksquare = "▪";
-const blacktriangle = "▴";
-const blacktriangledown = "▾";
-const blacktriangleleft = "◂";
-const blacktriangleright = "▸";
-const blank = "␣";
-const blk12 = "▒";
-const blk14 = "░";
-const blk34 = "▓";
-const block = "█";
-const bne = "=⃥";
-const bnequiv = "≡⃥";
-const bnot = "⌐";
-const bopf = "𝕓";
-const bot = "⊥";
-const bottom = "⊥";
-const bowtie = "⋈";
-const boxDL = "╗";
-const boxDR = "╔";
-const boxDl = "╖";
-const boxDr = "╓";
-const boxH = "═";
-const boxHD = "╦";
-const boxHU = "╩";
-const boxHd = "╤";
-const boxHu = "╧";
-const boxUL = "╝";
-const boxUR = "╚";
-const boxUl = "╜";
-const boxUr = "╙";
-const boxV = "║";
-const boxVH = "╬";
-const boxVL = "╣";
-const boxVR = "╠";
-const boxVh = "╫";
-const boxVl = "╢";
-const boxVr = "╟";
-const boxbox = "⧉";
-const boxdL = "╕";
-const boxdR = "╒";
-const boxdl = "┐";
-const boxdr = "┌";
-const boxh = "─";
-const boxhD = "╥";
-const boxhU = "╨";
-const boxhd = "┬";
-const boxhu = "┴";
-const boxminus = "⊟";
-const boxplus = "⊞";
-const boxtimes = "⊠";
-const boxuL = "╛";
-const boxuR = "╘";
-const boxul = "┘";
-const boxur = "└";
-const boxv = "│";
-const boxvH = "╪";
-const boxvL = "╡";
-const boxvR = "╞";
-const boxvh = "┼";
-const boxvl = "┤";
-const boxvr = "├";
-const bprime = "‵";
-const breve = "˘";
-const brvba = "¦";
-const brvbar$1 = "¦";
-const bscr = "𝒷";
-const bsemi = "⁏";
-const bsim = "∽";
-const bsime = "⋍";
-const bsol = "\\";
-const bsolb = "⧅";
-const bsolhsub = "⟈";
-const bull = "•";
-const bullet = "•";
-const bump = "≎";
-const bumpE = "⪮";
-const bumpe = "≏";
-const bumpeq = "≏";
-const cacute = "ć";
-const cap = "∩";
-const capand = "⩄";
-const capbrcup = "⩉";
-const capcap = "⩋";
-const capcup = "⩇";
-const capdot = "⩀";
-const caps = "∩︀";
-const caret = "⁁";
-const caron = "ˇ";
-const ccaps = "⩍";
-const ccaron = "č";
-const ccedi = "ç";
-const ccedil$1 = "ç";
-const ccirc = "ĉ";
-const ccups = "⩌";
-const ccupssm = "⩐";
-const cdot = "ċ";
-const cedi = "¸";
-const cedil$1 = "¸";
-const cemptyv = "⦲";
-const cen = "¢";
-const cent$1 = "¢";
-const centerdot = "·";
-const cfr = "𝔠";
-const chcy = "ч";
-const check$2 = "✓";
-const checkmark = "✓";
-const chi = "χ";
-const cir = "○";
-const cirE = "⧃";
-const circ = "ˆ";
-const circeq = "≗";
-const circlearrowleft = "↺";
-const circlearrowright = "↻";
-const circledR = "®";
-const circledS = "Ⓢ";
-const circledast = "⊛";
-const circledcirc = "⊚";
-const circleddash = "⊝";
-const cire = "≗";
-const cirfnint = "⨐";
-const cirmid = "⫯";
-const cirscir = "⧂";
-const clubs = "♣";
-const clubsuit = "♣";
-const colon = ":";
-const colone = "≔";
-const coloneq = "≔";
-const comma = ",";
-const commat = "@";
-const comp = "∁";
-const compfn = "∘";
-const complement = "∁";
-const complexes = "ℂ";
-const cong = "≅";
-const congdot = "⩭";
-const conint = "∮";
-const copf = "𝕔";
-const coprod = "∐";
-const cop = "©";
-const copy$2 = "©";
-const copysr = "℗";
-const crarr = "↵";
-const cross = "✗";
-const cscr = "𝒸";
-const csub = "⫏";
-const csube = "⫑";
-const csup = "⫐";
-const csupe = "⫒";
-const ctdot = "⋯";
-const cudarrl = "⤸";
-const cudarrr = "⤵";
-const cuepr = "⋞";
-const cuesc = "⋟";
-const cularr = "↶";
-const cularrp = "⤽";
-const cup = "∪";
-const cupbrcap = "⩈";
-const cupcap = "⩆";
-const cupcup = "⩊";
-const cupdot = "⊍";
-const cupor = "⩅";
-const cups = "∪︀";
-const curarr = "↷";
-const curarrm = "⤼";
-const curlyeqprec = "⋞";
-const curlyeqsucc = "⋟";
-const curlyvee = "⋎";
-const curlywedge = "⋏";
-const curre = "¤";
-const curren$1 = "¤";
-const curvearrowleft = "↶";
-const curvearrowright = "↷";
-const cuvee = "⋎";
-const cuwed = "⋏";
-const cwconint = "∲";
-const cwint = "∱";
-const cylcty = "⌭";
-const dArr = "⇓";
-const dHar = "⥥";
-const dagger = "†";
-const daleth = "ℸ";
-const darr = "↓";
-const dash = "‐";
-const dashv = "⊣";
-const dbkarow = "⤏";
-const dblac = "˝";
-const dcaron = "ď";
-const dcy = "д";
-const dd = "ⅆ";
-const ddagger = "‡";
-const ddarr = "⇊";
-const ddotseq = "⩷";
-const de = "°";
-const deg$1 = "°";
-const delta = "δ";
-const demptyv = "⦱";
-const dfisht = "⥿";
-const dfr = "𝔡";
-const dharl = "⇃";
-const dharr = "⇂";
-const diam = "⋄";
-const diamond = "⋄";
-const diamondsuit = "♦";
-const diams = "♦";
-const die = "¨";
-const digamma = "ϝ";
-const disin = "⋲";
-const div = "÷";
-const divid = "÷";
-const divide$1 = "÷";
-const divideontimes = "⋇";
-const divonx = "⋇";
-const djcy = "ђ";
-const dlcorn = "⌞";
-const dlcrop = "⌍";
-const dollar = "$";
-const dopf = "𝕕";
-const dot = "˙";
-const doteq = "≐";
-const doteqdot = "≑";
-const dotminus = "∸";
-const dotplus = "∔";
-const dotsquare = "⊡";
-const doublebarwedge = "⌆";
-const downarrow = "↓";
-const downdownarrows = "⇊";
-const downharpoonleft = "⇃";
-const downharpoonright = "⇂";
-const drbkarow = "⤐";
-const drcorn = "⌟";
-const drcrop = "⌌";
-const dscr = "𝒹";
-const dscy = "ѕ";
-const dsol = "⧶";
-const dstrok = "đ";
-const dtdot = "⋱";
-const dtri = "▿";
-const dtrif = "▾";
-const duarr = "⇵";
-const duhar = "⥯";
-const dwangle = "⦦";
-const dzcy = "џ";
-const dzigrarr = "⟿";
-const eDDot = "⩷";
-const eDot = "≑";
-const eacut = "é";
-const eacute$1 = "é";
-const easter = "⩮";
-const ecaron = "ě";
-const ecir = "ê";
-const ecirc$1 = "ê";
-const ecolon = "≕";
-const ecy = "э";
-const edot = "ė";
-const ee = "ⅇ";
-const efDot = "≒";
-const efr = "𝔢";
-const eg = "⪚";
-const egrav = "è";
-const egrave$1 = "è";
-const egs = "⪖";
-const egsdot = "⪘";
-const el = "⪙";
-const elinters = "⏧";
-const ell = "ℓ";
-const els = "⪕";
-const elsdot = "⪗";
-const emacr = "ē";
-const empty = "∅";
-const emptyset = "∅";
-const emptyv = "∅";
-const emsp13 = " ";
-const emsp14 = " ";
-const emsp = " ";
-const eng = "ŋ";
-const ensp = " ";
-const eogon = "ę";
-const eopf = "𝕖";
-const epar = "⋕";
-const eparsl = "⧣";
-const eplus = "⩱";
-const epsi = "ε";
-const epsilon = "ε";
-const epsiv = "ϵ";
-const eqcirc = "≖";
-const eqcolon = "≕";
-const eqsim = "≂";
-const eqslantgtr = "⪖";
-const eqslantless = "⪕";
-const equals = "=";
-const equest = "≟";
-const equiv = "≡";
-const equivDD = "⩸";
-const eqvparsl = "⧥";
-const erDot = "≓";
-const erarr = "⥱";
-const escr = "ℯ";
-const esdot = "≐";
-const esim = "≂";
-const eta = "η";
-const et = "ð";
-const eth$1 = "ð";
-const eum = "ë";
-const euml$1 = "ë";
-const euro = "€";
-const excl = "!";
-const exist = "∃";
-const expectation = "ℰ";
-const exponentiale = "ⅇ";
-const fallingdotseq = "≒";
-const fcy = "ф";
-const female = "♀";
-const ffilig = "ffi";
-const fflig = "ff";
-const ffllig = "ffl";
-const ffr = "𝔣";
-const filig = "fi";
-const fjlig = "fj";
-const flat = "♭";
-const fllig = "fl";
-const fltns = "▱";
-const fnof = "ƒ";
-const fopf = "𝕗";
-const forall = "∀";
-const fork = "⋔";
-const forkv = "⫙";
-const fpartint = "⨍";
-const frac1 = "¼";
-const frac12$1 = "½";
-const frac13 = "⅓";
-const frac14$1 = "¼";
-const frac15 = "⅕";
-const frac16 = "⅙";
-const frac18 = "⅛";
-const frac23 = "⅔";
-const frac25 = "⅖";
-const frac3 = "¾";
-const frac34$1 = "¾";
-const frac35 = "⅗";
-const frac38 = "⅜";
-const frac45 = "⅘";
-const frac56 = "⅚";
-const frac58 = "⅝";
-const frac78 = "⅞";
-const frasl = "⁄";
-const frown = "⌢";
-const fscr = "𝒻";
-const gE = "≧";
-const gEl = "⪌";
-const gacute = "ǵ";
-const gamma = "γ";
-const gammad = "ϝ";
-const gap = "⪆";
-const gbreve = "ğ";
-const gcirc = "ĝ";
-const gcy = "г";
-const gdot = "ġ";
-const ge = "≥";
-const gel = "⋛";
-const geq = "≥";
-const geqq = "≧";
-const geqslant = "⩾";
-const ges = "⩾";
-const gescc = "⪩";
-const gesdot = "⪀";
-const gesdoto = "⪂";
-const gesdotol = "⪄";
-const gesl = "⋛︀";
-const gesles = "⪔";
-const gfr = "𝔤";
-const gg = "≫";
-const ggg = "⋙";
-const gimel = "ℷ";
-const gjcy = "ѓ";
-const gl = "≷";
-const glE = "⪒";
-const gla = "⪥";
-const glj = "⪤";
-const gnE = "≩";
-const gnap = "⪊";
-const gnapprox = "⪊";
-const gne = "⪈";
-const gneq = "⪈";
-const gneqq = "≩";
-const gnsim = "⋧";
-const gopf = "𝕘";
-const grave = "`";
-const gscr = "ℊ";
-const gsim = "≳";
-const gsime = "⪎";
-const gsiml = "⪐";
-const g = ">";
-const gt$1 = ">";
-const gtcc = "⪧";
-const gtcir = "⩺";
-const gtdot = "⋗";
-const gtlPar = "⦕";
-const gtquest = "⩼";
-const gtrapprox = "⪆";
-const gtrarr = "⥸";
-const gtrdot = "⋗";
-const gtreqless = "⋛";
-const gtreqqless = "⪌";
-const gtrless = "≷";
-const gtrsim = "≳";
-const gvertneqq = "≩︀";
-const gvnE = "≩︀";
-const hArr = "⇔";
-const hairsp = " ";
-const half = "½";
-const hamilt = "ℋ";
-const hardcy = "ъ";
-const harr = "↔";
-const harrcir = "⥈";
-const harrw = "↭";
-const hbar = "ℏ";
-const hcirc = "ĥ";
-const hearts = "♥";
-const heartsuit = "♥";
-const hellip = "…";
-const hercon = "⊹";
-const hfr = "𝔥";
-const hksearow = "⤥";
-const hkswarow = "⤦";
-const hoarr = "⇿";
-const homtht = "∻";
-const hookleftarrow = "↩";
-const hookrightarrow = "↪";
-const hopf = "𝕙";
-const horbar = "―";
-const hscr = "𝒽";
-const hslash = "ℏ";
-const hstrok = "ħ";
-const hybull = "⁃";
-const hyphen = "‐";
-const iacut = "í";
-const iacute$1 = "í";
-const ic = "⁣";
-const icir = "î";
-const icirc$1 = "î";
-const icy = "и";
-const iecy = "е";
-const iexc = "¡";
-const iexcl$1 = "¡";
-const iff = "⇔";
-const ifr = "𝔦";
-const igrav = "ì";
-const igrave$1 = "ì";
-const ii = "ⅈ";
-const iiiint = "⨌";
-const iiint = "∭";
-const iinfin = "⧜";
-const iiota = "℩";
-const ijlig = "ij";
-const imacr = "ī";
-const image = "ℑ";
-const imagline = "ℐ";
-const imagpart = "ℑ";
-const imath = "ı";
-const imof = "⊷";
-const imped = "Ƶ";
-const incare = "℅";
-const infin = "∞";
-const infintie = "⧝";
-const inodot = "ı";
-const int = "∫";
-const intcal = "⊺";
-const integers = "ℤ";
-const intercal = "⊺";
-const intlarhk = "⨗";
-const intprod = "⨼";
-const iocy = "ё";
-const iogon = "į";
-const iopf = "𝕚";
-const iota = "ι";
-const iprod = "⨼";
-const iques = "¿";
-const iquest$1 = "¿";
-const iscr = "𝒾";
-const isin = "∈";
-const isinE = "⋹";
-const isindot = "⋵";
-const isins = "⋴";
-const isinsv = "⋳";
-const isinv = "∈";
-const it = "⁢";
-const itilde = "ĩ";
-const iukcy = "і";
-const ium = "ï";
-const iuml$1 = "ï";
-const jcirc = "ĵ";
-const jcy = "й";
-const jfr = "𝔧";
-const jmath = "ȷ";
-const jopf = "𝕛";
-const jscr = "𝒿";
-const jsercy = "ј";
-const jukcy = "є";
-const kappa = "κ";
-const kappav = "ϰ";
-const kcedil = "ķ";
-const kcy = "к";
-const kfr = "𝔨";
-const kgreen = "ĸ";
-const khcy = "х";
-const kjcy = "ќ";
-const kopf = "𝕜";
-const kscr = "𝓀";
-const lAarr = "⇚";
-const lArr = "⇐";
-const lAtail = "⤛";
-const lBarr = "⤎";
-const lE = "≦";
-const lEg = "⪋";
-const lHar = "⥢";
-const lacute = "ĺ";
-const laemptyv = "⦴";
-const lagran = "ℒ";
-const lambda = "λ";
-const lang = "⟨";
-const langd = "⦑";
-const langle = "⟨";
-const lap = "⪅";
-const laqu = "«";
-const laquo$1 = "«";
-const larr = "←";
-const larrb = "⇤";
-const larrbfs = "⤟";
-const larrfs = "⤝";
-const larrhk = "↩";
-const larrlp = "↫";
-const larrpl = "⤹";
-const larrsim = "⥳";
-const larrtl = "↢";
-const lat = "⪫";
-const latail = "⤙";
-const late = "⪭";
-const lates = "⪭︀";
-const lbarr = "⤌";
-const lbbrk = "❲";
-const lbrace = "{";
-const lbrack = "[";
-const lbrke = "⦋";
-const lbrksld = "⦏";
-const lbrkslu = "⦍";
-const lcaron = "ľ";
-const lcedil = "ļ";
-const lceil = "⌈";
-const lcub = "{";
-const lcy = "л";
-const ldca = "⤶";
-const ldquo = "“";
-const ldquor = "„";
-const ldrdhar = "⥧";
-const ldrushar = "⥋";
-const ldsh = "↲";
-const le = "≤";
-const leftarrow = "←";
-const leftarrowtail = "↢";
-const leftharpoondown = "↽";
-const leftharpoonup = "↼";
-const leftleftarrows = "⇇";
-const leftrightarrow = "↔";
-const leftrightarrows = "⇆";
-const leftrightharpoons = "⇋";
-const leftrightsquigarrow = "↭";
-const leftthreetimes = "⋋";
-const leg = "⋚";
-const leq = "≤";
-const leqq = "≦";
-const leqslant = "⩽";
-const les = "⩽";
-const lescc = "⪨";
-const lesdot = "⩿";
-const lesdoto = "⪁";
-const lesdotor = "⪃";
-const lesg = "⋚︀";
-const lesges = "⪓";
-const lessapprox = "⪅";
-const lessdot = "⋖";
-const lesseqgtr = "⋚";
-const lesseqqgtr = "⪋";
-const lessgtr = "≶";
-const lesssim = "≲";
-const lfisht = "⥼";
-const lfloor = "⌊";
-const lfr = "𝔩";
-const lg = "≶";
-const lgE = "⪑";
-const lhard = "↽";
-const lharu = "↼";
-const lharul = "⥪";
-const lhblk = "▄";
-const ljcy = "љ";
-const ll = "≪";
-const llarr = "⇇";
-const llcorner = "⌞";
-const llhard = "⥫";
-const lltri = "◺";
-const lmidot = "ŀ";
-const lmoust = "⎰";
-const lmoustache = "⎰";
-const lnE = "≨";
-const lnap = "⪉";
-const lnapprox = "⪉";
-const lne = "⪇";
-const lneq = "⪇";
-const lneqq = "≨";
-const lnsim = "⋦";
-const loang = "⟬";
-const loarr = "⇽";
-const lobrk = "⟦";
-const longleftarrow = "⟵";
-const longleftrightarrow = "⟷";
-const longmapsto = "⟼";
-const longrightarrow = "⟶";
-const looparrowleft = "↫";
-const looparrowright = "↬";
-const lopar = "⦅";
-const lopf = "𝕝";
-const loplus = "⨭";
-const lotimes = "⨴";
-const lowast = "∗";
-const lowbar = "_";
-const loz = "◊";
-const lozenge = "◊";
-const lozf = "⧫";
-const lpar = "(";
-const lparlt = "⦓";
-const lrarr = "⇆";
-const lrcorner = "⌟";
-const lrhar = "⇋";
-const lrhard = "⥭";
-const lrm = "‎";
-const lrtri = "⊿";
-const lsaquo = "‹";
-const lscr = "𝓁";
-const lsh = "↰";
-const lsim = "≲";
-const lsime = "⪍";
-const lsimg = "⪏";
-const lsqb = "[";
-const lsquo = "‘";
-const lsquor = "‚";
-const lstrok = "ł";
-const l = "<";
-const lt$1 = "<";
-const ltcc = "⪦";
-const ltcir = "⩹";
-const ltdot = "⋖";
-const lthree = "⋋";
-const ltimes = "⋉";
-const ltlarr = "⥶";
-const ltquest = "⩻";
-const ltrPar = "⦖";
-const ltri = "◃";
-const ltrie = "⊴";
-const ltrif = "◂";
-const lurdshar = "⥊";
-const luruhar = "⥦";
-const lvertneqq = "≨︀";
-const lvnE = "≨︀";
-const mDDot = "∺";
-const mac = "¯";
-const macr$1 = "¯";
-const male = "♂";
-const malt = "✠";
-const maltese = "✠";
-const map$2 = "↦";
-const mapsto = "↦";
-const mapstodown = "↧";
-const mapstoleft = "↤";
-const mapstoup = "↥";
-const marker = "▮";
-const mcomma = "⨩";
-const mcy = "м";
-const mdash = "—";
-const measuredangle = "∡";
-const mfr = "𝔪";
-const mho = "℧";
-const micr = "µ";
-const micro$1 = "µ";
-const mid = "∣";
-const midast = "*";
-const midcir = "⫰";
-const middo = "·";
-const middot$1 = "·";
-const minus = "−";
-const minusb = "⊟";
-const minusd = "∸";
-const minusdu = "⨪";
-const mlcp = "⫛";
-const mldr = "…";
-const mnplus = "∓";
-const models$2 = "⊧";
-const mopf = "𝕞";
-const mp = "∓";
-const mscr = "𝓂";
-const mstpos = "∾";
-const mu = "μ";
-const multimap = "⊸";
-const mumap = "⊸";
-const nGg = "⋙̸";
-const nGt = "≫⃒";
-const nGtv = "≫̸";
-const nLeftarrow = "⇍";
-const nLeftrightarrow = "⇎";
-const nLl = "⋘̸";
-const nLt = "≪⃒";
-const nLtv = "≪̸";
-const nRightarrow = "⇏";
-const nVDash = "⊯";
-const nVdash = "⊮";
-const nabla = "∇";
-const nacute = "ń";
-const nang = "∠⃒";
-const nap = "≉";
-const napE = "⩰̸";
-const napid = "≋̸";
-const napos = "ʼn";
-const napprox = "≉";
-const natur = "♮";
-const natural = "♮";
-const naturals = "ℕ";
-const nbs = " ";
-const nbsp$1 = " ";
-const nbump = "≎̸";
-const nbumpe = "≏̸";
-const ncap = "⩃";
-const ncaron = "ň";
-const ncedil = "ņ";
-const ncong = "≇";
-const ncongdot = "⩭̸";
-const ncup = "⩂";
-const ncy = "н";
-const ndash = "–";
-const ne = "≠";
-const neArr = "⇗";
-const nearhk = "⤤";
-const nearr = "↗";
-const nearrow = "↗";
-const nedot = "≐̸";
-const nequiv = "≢";
-const nesear = "⤨";
-const nesim = "≂̸";
-const nexist = "∄";
-const nexists = "∄";
-const nfr = "𝔫";
-const ngE = "≧̸";
-const nge = "≱";
-const ngeq = "≱";
-const ngeqq = "≧̸";
-const ngeqslant = "⩾̸";
-const nges = "⩾̸";
-const ngsim = "≵";
-const ngt = "≯";
-const ngtr = "≯";
-const nhArr = "⇎";
-const nharr = "↮";
-const nhpar = "⫲";
-const ni = "∋";
-const nis = "⋼";
-const nisd = "⋺";
-const niv = "∋";
-const njcy = "њ";
-const nlArr = "⇍";
-const nlE = "≦̸";
-const nlarr = "↚";
-const nldr = "‥";
-const nle = "≰";
-const nleftarrow = "↚";
-const nleftrightarrow = "↮";
-const nleq = "≰";
-const nleqq = "≦̸";
-const nleqslant = "⩽̸";
-const nles = "⩽̸";
-const nless = "≮";
-const nlsim = "≴";
-const nlt = "≮";
-const nltri = "⋪";
-const nltrie = "⋬";
-const nmid = "∤";
-const nopf = "𝕟";
-const no = "¬";
-const not$1 = "¬";
-const notin = "∉";
-const notinE = "⋹̸";
-const notindot = "⋵̸";
-const notinva = "∉";
-const notinvb = "⋷";
-const notinvc = "⋶";
-const notni = "∌";
-const notniva = "∌";
-const notnivb = "⋾";
-const notnivc = "⋽";
-const npar = "∦";
-const nparallel = "∦";
-const nparsl = "⫽⃥";
-const npart = "∂̸";
-const npolint = "⨔";
-const npr = "⊀";
-const nprcue = "⋠";
-const npre = "⪯̸";
-const nprec = "⊀";
-const npreceq = "⪯̸";
-const nrArr = "⇏";
-const nrarr = "↛";
-const nrarrc = "⤳̸";
-const nrarrw = "↝̸";
-const nrightarrow = "↛";
-const nrtri = "⋫";
-const nrtrie = "⋭";
-const nsc = "⊁";
-const nsccue = "⋡";
-const nsce = "⪰̸";
-const nscr = "𝓃";
-const nshortmid = "∤";
-const nshortparallel = "∦";
-const nsim = "≁";
-const nsime = "≄";
-const nsimeq = "≄";
-const nsmid = "∤";
-const nspar = "∦";
-const nsqsube = "⋢";
-const nsqsupe = "⋣";
-const nsub = "⊄";
-const nsubE = "⫅̸";
-const nsube = "⊈";
-const nsubset = "⊂⃒";
-const nsubseteq = "⊈";
-const nsubseteqq = "⫅̸";
-const nsucc = "⊁";
-const nsucceq = "⪰̸";
-const nsup = "⊅";
-const nsupE = "⫆̸";
-const nsupe = "⊉";
-const nsupset = "⊃⃒";
-const nsupseteq = "⊉";
-const nsupseteqq = "⫆̸";
-const ntgl = "≹";
-const ntild = "ñ";
-const ntilde$1 = "ñ";
-const ntlg = "≸";
-const ntriangleleft = "⋪";
-const ntrianglelefteq = "⋬";
-const ntriangleright = "⋫";
-const ntrianglerighteq = "⋭";
-const nu = "ν";
-const num = "#";
-const numero = "№";
-const numsp = " ";
-const nvDash = "⊭";
-const nvHarr = "⤄";
-const nvap = "≍⃒";
-const nvdash = "⊬";
-const nvge = "≥⃒";
-const nvgt = ">⃒";
-const nvinfin = "⧞";
-const nvlArr = "⤂";
-const nvle = "≤⃒";
-const nvlt = "<⃒";
-const nvltrie = "⊴⃒";
-const nvrArr = "⤃";
-const nvrtrie = "⊵⃒";
-const nvsim = "∼⃒";
-const nwArr = "⇖";
-const nwarhk = "⤣";
-const nwarr = "↖";
-const nwarrow = "↖";
-const nwnear = "⤧";
-const oS = "Ⓢ";
-const oacut = "ó";
-const oacute$1 = "ó";
-const oast = "⊛";
-const ocir = "ô";
-const ocirc$1 = "ô";
-const ocy = "о";
-const odash = "⊝";
-const odblac = "ő";
-const odiv = "⨸";
-const odot = "⊙";
-const odsold = "⦼";
-const oelig = "œ";
-const ofcir = "⦿";
-const ofr = "𝔬";
-const ogon = "˛";
-const ograv = "ò";
-const ograve$1 = "ò";
-const ogt = "⧁";
-const ohbar = "⦵";
-const ohm = "Ω";
-const oint = "∮";
-const olarr = "↺";
-const olcir = "⦾";
-const olcross = "⦻";
-const oline = "‾";
-const olt = "⧀";
-const omacr = "ō";
-const omega = "ω";
-const omicron = "ο";
-const omid = "⦶";
-const ominus = "⊖";
-const oopf = "𝕠";
-const opar = "⦷";
-const operp = "⦹";
-const oplus = "⊕";
-const or = "∨";
-const orarr = "↻";
-const ord = "º";
-const order$1 = "ℴ";
-const orderof = "ℴ";
-const ordf$1 = "ª";
-const ordm$1 = "º";
-const origof = "⊶";
-const oror = "⩖";
-const orslope = "⩗";
-const orv = "⩛";
-const oscr = "ℴ";
-const oslas = "ø";
-const oslash$1 = "ø";
-const osol = "⊘";
-const otild = "õ";
-const otilde$1 = "õ";
-const otimes = "⊗";
-const otimesas = "⨶";
-const oum = "ö";
-const ouml$1 = "ö";
-const ovbar = "⌽";
-const par = "¶";
-const para$1 = "¶";
-const parallel = "∥";
-const parsim = "⫳";
-const parsl = "⫽";
-const part = "∂";
-const pcy = "п";
-const percnt = "%";
-const period = ".";
-const permil = "‰";
-const perp = "⊥";
-const pertenk = "‱";
-const pfr = "𝔭";
-const phi = "φ";
-const phiv = "ϕ";
-const phmmat = "ℳ";
-const phone = "☎";
-const pi = "π";
-const pitchfork = "⋔";
-const piv = "ϖ";
-const planck = "ℏ";
-const planckh = "ℎ";
-const plankv = "ℏ";
-const plus = "+";
-const plusacir = "⨣";
-const plusb = "⊞";
-const pluscir = "⨢";
-const plusdo = "∔";
-const plusdu = "⨥";
-const pluse = "⩲";
-const plusm = "±";
-const plusmn$1 = "±";
-const plussim = "⨦";
-const plustwo = "⨧";
-const pm = "±";
-const pointint = "⨕";
-const popf = "𝕡";
-const poun = "£";
-const pound$1 = "£";
-const pr = "≺";
-const prE = "⪳";
-const prap = "⪷";
-const prcue = "≼";
-const pre = "⪯";
-const prec = "≺";
-const precapprox = "⪷";
-const preccurlyeq = "≼";
-const preceq = "⪯";
-const precnapprox = "⪹";
-const precneqq = "⪵";
-const precnsim = "⋨";
-const precsim = "≾";
-const prime = "′";
-const primes = "ℙ";
-const prnE = "⪵";
-const prnap = "⪹";
-const prnsim = "⋨";
-const prod = "∏";
-const profalar = "⌮";
-const profline = "⌒";
-const profsurf = "⌓";
-const prop = "∝";
-const propto = "∝";
-const prsim = "≾";
-const prurel = "⊰";
-const pscr = "𝓅";
-const psi = "ψ";
-const puncsp = " ";
-const qfr = "𝔮";
-const qint = "⨌";
-const qopf = "𝕢";
-const qprime = "⁗";
-const qscr = "𝓆";
-const quaternions = "ℍ";
-const quatint = "⨖";
-const quest = "?";
-const questeq = "≟";
-const quo = "\"";
-const quot$1 = "\"";
-const rAarr = "⇛";
-const rArr = "⇒";
-const rAtail = "⤜";
-const rBarr = "⤏";
-const rHar = "⥤";
-const race = "∽̱";
-const racute = "ŕ";
-const radic = "√";
-const raemptyv = "⦳";
-const rang = "⟩";
-const rangd = "⦒";
-const range$1 = "⦥";
-const rangle = "⟩";
-const raqu = "»";
-const raquo$1 = "»";
-const rarr = "→";
-const rarrap = "⥵";
-const rarrb = "⇥";
-const rarrbfs = "⤠";
-const rarrc = "⤳";
-const rarrfs = "⤞";
-const rarrhk = "↪";
-const rarrlp = "↬";
-const rarrpl = "⥅";
-const rarrsim = "⥴";
-const rarrtl = "↣";
-const rarrw = "↝";
-const ratail = "⤚";
-const ratio = "∶";
-const rationals = "ℚ";
-const rbarr = "⤍";
-const rbbrk = "❳";
-const rbrace = "}";
-const rbrack = "]";
-const rbrke = "⦌";
-const rbrksld = "⦎";
-const rbrkslu = "⦐";
-const rcaron = "ř";
-const rcedil = "ŗ";
-const rceil = "⌉";
-const rcub = "}";
-const rcy = "р";
-const rdca = "⤷";
-const rdldhar = "⥩";
-const rdquo = "”";
-const rdquor = "”";
-const rdsh = "↳";
-const real = "ℜ";
-const realine = "ℛ";
-const realpart = "ℜ";
-const reals = "ℝ";
-const rect = "▭";
-const re = "®";
-const reg$1 = "®";
-const rfisht = "⥽";
-const rfloor = "⌋";
-const rfr = "𝔯";
-const rhard = "⇁";
-const rharu = "⇀";
-const rharul = "⥬";
-const rho = "ρ";
-const rhov = "ϱ";
-const rightarrow = "→";
-const rightarrowtail = "↣";
-const rightharpoondown = "⇁";
-const rightharpoonup = "⇀";
-const rightleftarrows = "⇄";
-const rightleftharpoons = "⇌";
-const rightrightarrows = "⇉";
-const rightsquigarrow = "↝";
-const rightthreetimes = "⋌";
-const ring = "˚";
-const risingdotseq = "≓";
-const rlarr = "⇄";
-const rlhar = "⇌";
-const rlm = "‏";
-const rmoust = "⎱";
-const rmoustache = "⎱";
-const rnmid = "⫮";
-const roang = "⟭";
-const roarr = "⇾";
-const robrk = "⟧";
-const ropar = "⦆";
-const ropf = "𝕣";
-const roplus = "⨮";
-const rotimes = "⨵";
-const rpar = ")";
-const rpargt = "⦔";
-const rppolint = "⨒";
-const rrarr = "⇉";
-const rsaquo = "›";
-const rscr = "𝓇";
-const rsh = "↱";
-const rsqb = "]";
-const rsquo = "’";
-const rsquor = "’";
-const rthree = "⋌";
-const rtimes = "⋊";
-const rtri = "▹";
-const rtrie = "⊵";
-const rtrif = "▸";
-const rtriltri = "⧎";
-const ruluhar = "⥨";
-const rx = "℞";
-const sacute = "ś";
-const sbquo = "‚";
-const sc = "≻";
-const scE = "⪴";
-const scap = "⪸";
-const scaron = "š";
-const sccue = "≽";
-const sce = "⪰";
-const scedil = "ş";
-const scirc = "ŝ";
-const scnE = "⪶";
-const scnap = "⪺";
-const scnsim = "⋩";
-const scpolint = "⨓";
-const scsim = "≿";
-const scy = "с";
-const sdot = "⋅";
-const sdotb = "⊡";
-const sdote = "⩦";
-const seArr = "⇘";
-const searhk = "⤥";
-const searr = "↘";
-const searrow = "↘";
-const sec = "§";
-const sect$1 = "§";
-const semi = ";";
-const seswar = "⤩";
-const setminus = "∖";
-const setmn = "∖";
-const sext = "✶";
-const sfr = "𝔰";
-const sfrown = "⌢";
-const sharp = "♯";
-const shchcy = "щ";
-const shcy = "ш";
-const shortmid = "∣";
-const shortparallel = "∥";
-const sh = "­";
-const shy$1 = "­";
-const sigma = "σ";
-const sigmaf = "ς";
-const sigmav = "ς";
-const sim = "∼";
-const simdot = "⩪";
-const sime = "≃";
-const simeq = "≃";
-const simg = "⪞";
-const simgE = "⪠";
-const siml = "⪝";
-const simlE = "⪟";
-const simne = "≆";
-const simplus = "⨤";
-const simrarr = "⥲";
-const slarr = "←";
-const smallsetminus = "∖";
-const smashp = "⨳";
-const smeparsl = "⧤";
-const smid = "∣";
-const smile = "⌣";
-const smt = "⪪";
-const smte = "⪬";
-const smtes = "⪬︀";
-const softcy = "ь";
-const sol = "/";
-const solb = "⧄";
-const solbar = "⌿";
-const sopf = "𝕤";
-const spades = "♠";
-const spadesuit = "♠";
-const spar = "∥";
-const sqcap = "⊓";
-const sqcaps = "⊓︀";
-const sqcup = "⊔";
-const sqcups = "⊔︀";
-const sqsub = "⊏";
-const sqsube = "⊑";
-const sqsubset = "⊏";
-const sqsubseteq = "⊑";
-const sqsup = "⊐";
-const sqsupe = "⊒";
-const sqsupset = "⊐";
-const sqsupseteq = "⊒";
-const squ = "□";
-const square = "□";
-const squarf = "▪";
-const squf = "▪";
-const srarr = "→";
-const sscr = "𝓈";
-const ssetmn = "∖";
-const ssmile = "⌣";
-const sstarf = "⋆";
-const star$1 = "☆";
-const starf = "★";
-const straightepsilon = "ϵ";
-const straightphi = "ϕ";
-const strns = "¯";
-const sub = "⊂";
-const subE = "⫅";
-const subdot = "⪽";
-const sube = "⊆";
-const subedot = "⫃";
-const submult = "⫁";
-const subnE = "⫋";
-const subne = "⊊";
-const subplus = "⪿";
-const subrarr = "⥹";
-const subset = "⊂";
-const subseteq = "⊆";
-const subseteqq = "⫅";
-const subsetneq = "⊊";
-const subsetneqq = "⫋";
-const subsim = "⫇";
-const subsub = "⫕";
-const subsup = "⫓";
-const succ = "≻";
-const succapprox = "⪸";
-const succcurlyeq = "≽";
-const succeq = "⪰";
-const succnapprox = "⪺";
-const succneqq = "⪶";
-const succnsim = "⋩";
-const succsim = "≿";
-const sum = "∑";
-const sung = "♪";
-const sup = "⊃";
-const sup1$1 = "¹";
-const sup2$1 = "²";
-const sup3$1 = "³";
-const supE = "⫆";
-const supdot = "⪾";
-const supdsub = "⫘";
-const supe = "⊇";
-const supedot = "⫄";
-const suphsol = "⟉";
-const suphsub = "⫗";
-const suplarr = "⥻";
-const supmult = "⫂";
-const supnE = "⫌";
-const supne = "⊋";
-const supplus = "⫀";
-const supset = "⊃";
-const supseteq = "⊇";
-const supseteqq = "⫆";
-const supsetneq = "⊋";
-const supsetneqq = "⫌";
-const supsim = "⫈";
-const supsub = "⫔";
-const supsup = "⫖";
-const swArr = "⇙";
-const swarhk = "⤦";
-const swarr = "↙";
-const swarrow = "↙";
-const swnwar = "⤪";
-const szli = "ß";
-const szlig$1 = "ß";
-const target = "⌖";
-const tau = "τ";
-const tbrk = "⎴";
-const tcaron = "ť";
-const tcedil = "ţ";
-const tcy = "т";
-const tdot = "⃛";
-const telrec = "⌕";
-const tfr = "𝔱";
-const there4 = "∴";
-const therefore = "∴";
-const theta = "θ";
-const thetasym = "ϑ";
-const thetav = "ϑ";
-const thickapprox = "≈";
-const thicksim = "∼";
-const thinsp = " ";
-const thkap = "≈";
-const thksim = "∼";
-const thor = "þ";
-const thorn$1 = "þ";
-const tilde = "˜";
-const time = "×";
-const times$1 = "×";
-const timesb = "⊠";
-const timesbar = "⨱";
-const timesd = "⨰";
-const tint = "∭";
-const toea = "⤨";
-const top = "⊤";
-const topbot = "⌶";
-const topcir = "⫱";
-const topf = "𝕥";
-const topfork = "⫚";
-const tosa = "⤩";
-const tprime = "‴";
-const trade = "™";
-const triangle = "▵";
-const triangledown = "▿";
-const triangleleft = "◃";
-const trianglelefteq = "⊴";
-const triangleq = "≜";
-const triangleright = "▹";
-const trianglerighteq = "⊵";
-const tridot = "◬";
-const trie = "≜";
-const triminus = "⨺";
-const triplus = "⨹";
-const trisb = "⧍";
-const tritime = "⨻";
-const trpezium = "⏢";
-const tscr = "𝓉";
-const tscy = "ц";
-const tshcy = "ћ";
-const tstrok = "ŧ";
-const twixt = "≬";
-const twoheadleftarrow = "↞";
-const twoheadrightarrow = "↠";
-const uArr = "⇑";
-const uHar = "⥣";
-const uacut = "ú";
-const uacute$1 = "ú";
-const uarr = "↑";
-const ubrcy = "ў";
-const ubreve = "ŭ";
-const ucir = "û";
-const ucirc$1 = "û";
-const ucy = "у";
-const udarr = "⇅";
-const udblac = "ű";
-const udhar = "⥮";
-const ufisht = "⥾";
-const ufr = "𝔲";
-const ugrav = "ù";
-const ugrave$1 = "ù";
-const uharl = "↿";
-const uharr = "↾";
-const uhblk = "▀";
-const ulcorn = "⌜";
-const ulcorner = "⌜";
-const ulcrop = "⌏";
-const ultri = "◸";
-const umacr = "ū";
-const um = "¨";
-const uml$1 = "¨";
-const uogon = "ų";
-const uopf = "𝕦";
-const uparrow = "↑";
-const updownarrow = "↕";
-const upharpoonleft = "↿";
-const upharpoonright = "↾";
-const uplus = "⊎";
-const upsi = "υ";
-const upsih = "ϒ";
-const upsilon = "υ";
-const upuparrows = "⇈";
-const urcorn = "⌝";
-const urcorner = "⌝";
-const urcrop = "⌎";
-const uring = "ů";
-const urtri = "◹";
-const uscr = "𝓊";
-const utdot = "⋰";
-const utilde = "ũ";
-const utri = "▵";
-const utrif = "▴";
-const uuarr = "⇈";
-const uum = "ü";
-const uuml$1 = "ü";
-const uwangle = "⦧";
-const vArr = "⇕";
-const vBar = "⫨";
-const vBarv = "⫩";
-const vDash = "⊨";
-const vangrt = "⦜";
-const varepsilon = "ϵ";
-const varkappa = "ϰ";
-const varnothing = "∅";
-const varphi = "ϕ";
-const varpi = "ϖ";
-const varpropto = "∝";
-const varr = "↕";
-const varrho = "ϱ";
-const varsigma = "ς";
-const varsubsetneq = "⊊︀";
-const varsubsetneqq = "⫋︀";
-const varsupsetneq = "⊋︀";
-const varsupsetneqq = "⫌︀";
-const vartheta = "ϑ";
-const vartriangleleft = "⊲";
-const vartriangleright = "⊳";
-const vcy = "в";
-const vdash = "⊢";
-const vee = "∨";
-const veebar = "⊻";
-const veeeq = "≚";
-const vellip = "⋮";
-const verbar = "|";
-const vert = "|";
-const vfr = "𝔳";
-const vltri = "⊲";
-const vnsub = "⊂⃒";
-const vnsup = "⊃⃒";
-const vopf = "𝕧";
-const vprop = "∝";
-const vrtri = "⊳";
-const vscr = "𝓋";
-const vsubnE = "⫋︀";
-const vsubne = "⊊︀";
-const vsupnE = "⫌︀";
-const vsupne = "⊋︀";
-const vzigzag = "⦚";
-const wcirc = "ŵ";
-const wedbar = "⩟";
-const wedge = "∧";
-const wedgeq = "≙";
-const weierp = "℘";
-const wfr = "𝔴";
-const wopf = "𝕨";
-const wp = "℘";
-const wr = "≀";
-const wreath = "≀";
-const wscr = "𝓌";
-const xcap = "⋂";
-const xcirc = "◯";
-const xcup = "⋃";
-const xdtri = "▽";
-const xfr = "𝔵";
-const xhArr = "⟺";
-const xharr = "⟷";
-const xi = "ξ";
-const xlArr = "⟸";
-const xlarr = "⟵";
-const xmap = "⟼";
-const xnis = "⋻";
-const xodot = "⨀";
-const xopf = "𝕩";
-const xoplus = "⨁";
-const xotime = "⨂";
-const xrArr = "⟹";
-const xrarr = "⟶";
-const xscr = "𝓍";
-const xsqcup = "⨆";
-const xuplus = "⨄";
-const xutri = "△";
-const xvee = "⋁";
-const xwedge = "⋀";
-const yacut = "ý";
-const yacute$1 = "ý";
-const yacy = "я";
-const ycirc = "ŷ";
-const ycy = "ы";
-const ye = "¥";
-const yen$1 = "¥";
-const yfr = "𝔶";
-const yicy = "ї";
-const yopf = "𝕪";
-const yscr = "𝓎";
-const yucy = "ю";
-const yum = "ÿ";
-const yuml$1 = "ÿ";
-const zacute = "ź";
-const zcaron = "ž";
-const zcy = "з";
-const zdot = "ż";
-const zeetrf = "ℨ";
-const zeta = "ζ";
-const zfr = "𝔷";
-const zhcy = "ж";
-const zigrarr = "⇝";
-const zopf = "𝕫";
-const zscr = "𝓏";
-const zwj = "‍";
-const zwnj = "‌";
-var index$3 = {
-	AEli: AEli,
-	AElig: AElig$1,
-	AM: AM,
-	AMP: AMP$1,
-	Aacut: Aacut,
-	Aacute: Aacute$1,
-	Abreve: Abreve,
-	Acir: Acir,
-	Acirc: Acirc$1,
-	Acy: Acy,
-	Afr: Afr,
-	Agrav: Agrav,
-	Agrave: Agrave$1,
-	Alpha: Alpha,
-	Amacr: Amacr,
-	And: And,
-	Aogon: Aogon,
-	Aopf: Aopf,
-	ApplyFunction: ApplyFunction,
-	Arin: Arin,
-	Aring: Aring$1,
-	Ascr: Ascr,
-	Assign: Assign,
-	Atild: Atild,
-	Atilde: Atilde$1,
-	Aum: Aum,
-	Auml: Auml$1,
-	Backslash: Backslash,
-	Barv: Barv,
-	Barwed: Barwed,
-	Bcy: Bcy,
-	Because: Because,
-	Bernoullis: Bernoullis,
-	Beta: Beta,
-	Bfr: Bfr,
-	Bopf: Bopf,
-	Breve: Breve,
-	Bscr: Bscr,
-	Bumpeq: Bumpeq,
-	CHcy: CHcy,
-	COP: COP,
-	COPY: COPY$1,
-	Cacute: Cacute,
-	Cap: Cap,
-	CapitalDifferentialD: CapitalDifferentialD,
-	Cayleys: Cayleys,
-	Ccaron: Ccaron,
-	Ccedi: Ccedi,
-	Ccedil: Ccedil$1,
-	Ccirc: Ccirc,
-	Cconint: Cconint,
-	Cdot: Cdot,
-	Cedilla: Cedilla,
-	CenterDot: CenterDot,
-	Cfr: Cfr,
-	Chi: Chi,
-	CircleDot: CircleDot,
-	CircleMinus: CircleMinus,
-	CirclePlus: CirclePlus,
-	CircleTimes: CircleTimes,
-	ClockwiseContourIntegral: ClockwiseContourIntegral,
-	CloseCurlyDoubleQuote: CloseCurlyDoubleQuote,
-	CloseCurlyQuote: CloseCurlyQuote,
-	Colon: Colon,
-	Colone: Colone,
-	Congruent: Congruent,
-	Conint: Conint,
-	ContourIntegral: ContourIntegral,
-	Copf: Copf,
-	Coproduct: Coproduct,
-	CounterClockwiseContourIntegral: CounterClockwiseContourIntegral,
-	Cross: Cross,
-	Cscr: Cscr,
-	Cup: Cup,
-	CupCap: CupCap,
-	DD: DD,
-	DDotrahd: DDotrahd,
-	DJcy: DJcy,
-	DScy: DScy,
-	DZcy: DZcy,
-	Dagger: Dagger,
-	Darr: Darr,
-	Dashv: Dashv,
-	Dcaron: Dcaron,
-	Dcy: Dcy,
-	Del: Del,
-	Delta: Delta,
-	Dfr: Dfr,
-	DiacriticalAcute: DiacriticalAcute,
-	DiacriticalDot: DiacriticalDot,
-	DiacriticalDoubleAcute: DiacriticalDoubleAcute,
-	DiacriticalGrave: DiacriticalGrave,
-	DiacriticalTilde: DiacriticalTilde,
-	Diamond: Diamond,
-	DifferentialD: DifferentialD,
-	Dopf: Dopf,
-	Dot: Dot,
-	DotDot: DotDot,
-	DotEqual: DotEqual,
-	DoubleContourIntegral: DoubleContourIntegral,
-	DoubleDot: DoubleDot,
-	DoubleDownArrow: DoubleDownArrow,
-	DoubleLeftArrow: DoubleLeftArrow,
-	DoubleLeftRightArrow: DoubleLeftRightArrow,
-	DoubleLeftTee: DoubleLeftTee,
-	DoubleLongLeftArrow: DoubleLongLeftArrow,
-	DoubleLongLeftRightArrow: DoubleLongLeftRightArrow,
-	DoubleLongRightArrow: DoubleLongRightArrow,
-	DoubleRightArrow: DoubleRightArrow,
-	DoubleRightTee: DoubleRightTee,
-	DoubleUpArrow: DoubleUpArrow,
-	DoubleUpDownArrow: DoubleUpDownArrow,
-	DoubleVerticalBar: DoubleVerticalBar,
-	DownArrow: DownArrow,
-	DownArrowBar: DownArrowBar,
-	DownArrowUpArrow: DownArrowUpArrow,
-	DownBreve: DownBreve,
-	DownLeftRightVector: DownLeftRightVector,
-	DownLeftTeeVector: DownLeftTeeVector,
-	DownLeftVector: DownLeftVector,
-	DownLeftVectorBar: DownLeftVectorBar,
-	DownRightTeeVector: DownRightTeeVector,
-	DownRightVector: DownRightVector,
-	DownRightVectorBar: DownRightVectorBar,
-	DownTee: DownTee,
-	DownTeeArrow: DownTeeArrow,
-	Downarrow: Downarrow,
-	Dscr: Dscr,
-	Dstrok: Dstrok,
-	ENG: ENG,
-	ET: ET,
-	ETH: ETH$1,
-	Eacut: Eacut,
-	Eacute: Eacute$1,
-	Ecaron: Ecaron,
-	Ecir: Ecir,
-	Ecirc: Ecirc$1,
-	Ecy: Ecy,
-	Edot: Edot,
-	Efr: Efr,
-	Egrav: Egrav,
-	Egrave: Egrave$1,
-	Element: Element,
-	Emacr: Emacr,
-	EmptySmallSquare: EmptySmallSquare,
-	EmptyVerySmallSquare: EmptyVerySmallSquare,
-	Eogon: Eogon,
-	Eopf: Eopf,
-	Epsilon: Epsilon,
-	Equal: Equal,
-	EqualTilde: EqualTilde,
-	Equilibrium: Equilibrium,
-	Escr: Escr,
-	Esim: Esim,
-	Eta: Eta,
-	Eum: Eum,
-	Euml: Euml$1,
-	Exists: Exists,
-	ExponentialE: ExponentialE,
-	Fcy: Fcy,
-	Ffr: Ffr,
-	FilledSmallSquare: FilledSmallSquare,
-	FilledVerySmallSquare: FilledVerySmallSquare,
-	Fopf: Fopf,
-	ForAll: ForAll,
-	Fouriertrf: Fouriertrf,
-	Fscr: Fscr,
-	GJcy: GJcy,
-	G: G,
-	GT: GT$1,
-	Gamma: Gamma,
-	Gammad: Gammad,
-	Gbreve: Gbreve,
-	Gcedil: Gcedil,
-	Gcirc: Gcirc,
-	Gcy: Gcy,
-	Gdot: Gdot,
-	Gfr: Gfr,
-	Gg: Gg,
-	Gopf: Gopf,
-	GreaterEqual: GreaterEqual,
-	GreaterEqualLess: GreaterEqualLess,
-	GreaterFullEqual: GreaterFullEqual,
-	GreaterGreater: GreaterGreater,
-	GreaterLess: GreaterLess,
-	GreaterSlantEqual: GreaterSlantEqual,
-	GreaterTilde: GreaterTilde,
-	Gscr: Gscr,
-	Gt: Gt,
-	HARDcy: HARDcy,
-	Hacek: Hacek,
-	Hat: Hat,
-	Hcirc: Hcirc,
-	Hfr: Hfr,
-	HilbertSpace: HilbertSpace,
-	Hopf: Hopf,
-	HorizontalLine: HorizontalLine,
-	Hscr: Hscr,
-	Hstrok: Hstrok,
-	HumpDownHump: HumpDownHump,
-	HumpEqual: HumpEqual,
-	IEcy: IEcy,
-	IJlig: IJlig,
-	IOcy: IOcy,
-	Iacut: Iacut,
-	Iacute: Iacute$1,
-	Icir: Icir,
-	Icirc: Icirc$1,
-	Icy: Icy,
-	Idot: Idot,
-	Ifr: Ifr,
-	Igrav: Igrav,
-	Igrave: Igrave$1,
-	Im: Im,
-	Imacr: Imacr,
-	ImaginaryI: ImaginaryI,
-	Implies: Implies,
-	Int: Int,
-	Integral: Integral,
-	Intersection: Intersection,
-	InvisibleComma: InvisibleComma,
-	InvisibleTimes: InvisibleTimes,
-	Iogon: Iogon,
-	Iopf: Iopf,
-	Iota: Iota,
-	Iscr: Iscr,
-	Itilde: Itilde,
-	Iukcy: Iukcy,
-	Ium: Ium,
-	Iuml: Iuml$1,
-	Jcirc: Jcirc,
-	Jcy: Jcy,
-	Jfr: Jfr,
-	Jopf: Jopf,
-	Jscr: Jscr,
-	Jsercy: Jsercy,
-	Jukcy: Jukcy,
-	KHcy: KHcy,
-	KJcy: KJcy,
-	Kappa: Kappa,
-	Kcedil: Kcedil,
-	Kcy: Kcy,
-	Kfr: Kfr,
-	Kopf: Kopf,
-	Kscr: Kscr,
-	LJcy: LJcy,
-	L: L,
-	LT: LT$1,
-	Lacute: Lacute,
-	Lambda: Lambda,
-	Lang: Lang,
-	Laplacetrf: Laplacetrf,
-	Larr: Larr,
-	Lcaron: Lcaron,
-	Lcedil: Lcedil,
-	Lcy: Lcy,
-	LeftAngleBracket: LeftAngleBracket,
-	LeftArrow: LeftArrow,
-	LeftArrowBar: LeftArrowBar,
-	LeftArrowRightArrow: LeftArrowRightArrow,
-	LeftCeiling: LeftCeiling,
-	LeftDoubleBracket: LeftDoubleBracket,
-	LeftDownTeeVector: LeftDownTeeVector,
-	LeftDownVector: LeftDownVector,
-	LeftDownVectorBar: LeftDownVectorBar,
-	LeftFloor: LeftFloor,
-	LeftRightArrow: LeftRightArrow,
-	LeftRightVector: LeftRightVector,
-	LeftTee: LeftTee,
-	LeftTeeArrow: LeftTeeArrow,
-	LeftTeeVector: LeftTeeVector,
-	LeftTriangle: LeftTriangle,
-	LeftTriangleBar: LeftTriangleBar,
-	LeftTriangleEqual: LeftTriangleEqual,
-	LeftUpDownVector: LeftUpDownVector,
-	LeftUpTeeVector: LeftUpTeeVector,
-	LeftUpVector: LeftUpVector,
-	LeftUpVectorBar: LeftUpVectorBar,
-	LeftVector: LeftVector,
-	LeftVectorBar: LeftVectorBar,
-	Leftarrow: Leftarrow,
-	Leftrightarrow: Leftrightarrow,
-	LessEqualGreater: LessEqualGreater,
-	LessFullEqual: LessFullEqual,
-	LessGreater: LessGreater,
-	LessLess: LessLess,
-	LessSlantEqual: LessSlantEqual,
-	LessTilde: LessTilde,
-	Lfr: Lfr,
-	Ll: Ll,
-	Lleftarrow: Lleftarrow,
-	Lmidot: Lmidot,
-	LongLeftArrow: LongLeftArrow,
-	LongLeftRightArrow: LongLeftRightArrow,
-	LongRightArrow: LongRightArrow,
-	Longleftarrow: Longleftarrow,
-	Longleftrightarrow: Longleftrightarrow,
-	Longrightarrow: Longrightarrow,
-	Lopf: Lopf,
-	LowerLeftArrow: LowerLeftArrow,
-	LowerRightArrow: LowerRightArrow,
-	Lscr: Lscr,
-	Lsh: Lsh,
-	Lstrok: Lstrok,
-	Lt: Lt,
-	"Map": "⤅",
-	Mcy: Mcy,
-	MediumSpace: MediumSpace,
-	Mellintrf: Mellintrf,
-	Mfr: Mfr,
-	MinusPlus: MinusPlus,
-	Mopf: Mopf,
-	Mscr: Mscr,
-	Mu: Mu,
-	NJcy: NJcy,
-	Nacute: Nacute,
-	Ncaron: Ncaron,
-	Ncedil: Ncedil,
-	Ncy: Ncy,
-	NegativeMediumSpace: NegativeMediumSpace,
-	NegativeThickSpace: NegativeThickSpace,
-	NegativeThinSpace: NegativeThinSpace,
-	NegativeVeryThinSpace: NegativeVeryThinSpace,
-	NestedGreaterGreater: NestedGreaterGreater,
-	NestedLessLess: NestedLessLess,
-	NewLine: NewLine,
-	Nfr: Nfr,
-	NoBreak: NoBreak,
-	NonBreakingSpace: NonBreakingSpace,
-	Nopf: Nopf,
-	Not: Not,
-	NotCongruent: NotCongruent,
-	NotCupCap: NotCupCap,
-	NotDoubleVerticalBar: NotDoubleVerticalBar,
-	NotElement: NotElement,
-	NotEqual: NotEqual,
-	NotEqualTilde: NotEqualTilde,
-	NotExists: NotExists,
-	NotGreater: NotGreater,
-	NotGreaterEqual: NotGreaterEqual,
-	NotGreaterFullEqual: NotGreaterFullEqual,
-	NotGreaterGreater: NotGreaterGreater,
-	NotGreaterLess: NotGreaterLess,
-	NotGreaterSlantEqual: NotGreaterSlantEqual,
-	NotGreaterTilde: NotGreaterTilde,
-	NotHumpDownHump: NotHumpDownHump,
-	NotHumpEqual: NotHumpEqual,
-	NotLeftTriangle: NotLeftTriangle,
-	NotLeftTriangleBar: NotLeftTriangleBar,
-	NotLeftTriangleEqual: NotLeftTriangleEqual,
-	NotLess: NotLess,
-	NotLessEqual: NotLessEqual,
-	NotLessGreater: NotLessGreater,
-	NotLessLess: NotLessLess,
-	NotLessSlantEqual: NotLessSlantEqual,
-	NotLessTilde: NotLessTilde,
-	NotNestedGreaterGreater: NotNestedGreaterGreater,
-	NotNestedLessLess: NotNestedLessLess,
-	NotPrecedes: NotPrecedes,
-	NotPrecedesEqual: NotPrecedesEqual,
-	NotPrecedesSlantEqual: NotPrecedesSlantEqual,
-	NotReverseElement: NotReverseElement,
-	NotRightTriangle: NotRightTriangle,
-	NotRightTriangleBar: NotRightTriangleBar,
-	NotRightTriangleEqual: NotRightTriangleEqual,
-	NotSquareSubset: NotSquareSubset,
-	NotSquareSubsetEqual: NotSquareSubsetEqual,
-	NotSquareSuperset: NotSquareSuperset,
-	NotSquareSupersetEqual: NotSquareSupersetEqual,
-	NotSubset: NotSubset,
-	NotSubsetEqual: NotSubsetEqual,
-	NotSucceeds: NotSucceeds,
-	NotSucceedsEqual: NotSucceedsEqual,
-	NotSucceedsSlantEqual: NotSucceedsSlantEqual,
-	NotSucceedsTilde: NotSucceedsTilde,
-	NotSuperset: NotSuperset,
-	NotSupersetEqual: NotSupersetEqual,
-	NotTilde: NotTilde,
-	NotTildeEqual: NotTildeEqual,
-	NotTildeFullEqual: NotTildeFullEqual,
-	NotTildeTilde: NotTildeTilde,
-	NotVerticalBar: NotVerticalBar,
-	Nscr: Nscr,
-	Ntild: Ntild,
-	Ntilde: Ntilde$1,
-	Nu: Nu,
-	OElig: OElig,
-	Oacut: Oacut,
-	Oacute: Oacute$1,
-	Ocir: Ocir,
-	Ocirc: Ocirc$1,
-	Ocy: Ocy,
-	Odblac: Odblac,
-	Ofr: Ofr,
-	Ograv: Ograv,
-	Ograve: Ograve$1,
-	Omacr: Omacr,
-	Omega: Omega,
-	Omicron: Omicron,
-	Oopf: Oopf,
-	OpenCurlyDoubleQuote: OpenCurlyDoubleQuote,
-	OpenCurlyQuote: OpenCurlyQuote,
-	Or: Or,
-	Oscr: Oscr,
-	Oslas: Oslas,
-	Oslash: Oslash$1,
-	Otild: Otild,
-	Otilde: Otilde$1,
-	Otimes: Otimes,
-	Oum: Oum,
-	Ouml: Ouml$1,
-	OverBar: OverBar,
-	OverBrace: OverBrace,
-	OverBracket: OverBracket,
-	OverParenthesis: OverParenthesis,
-	PartialD: PartialD,
-	Pcy: Pcy,
-	Pfr: Pfr,
-	Phi: Phi,
-	Pi: Pi,
-	PlusMinus: PlusMinus,
-	Poincareplane: Poincareplane,
-	Popf: Popf,
-	Pr: Pr,
-	Precedes: Precedes,
-	PrecedesEqual: PrecedesEqual,
-	PrecedesSlantEqual: PrecedesSlantEqual,
-	PrecedesTilde: PrecedesTilde,
-	Prime: Prime,
-	Product: Product,
-	Proportion: Proportion,
-	Proportional: Proportional,
-	Pscr: Pscr,
-	Psi: Psi,
-	QUO: QUO,
-	QUOT: QUOT$1,
-	Qfr: Qfr,
-	Qopf: Qopf,
-	Qscr: Qscr,
-	RBarr: RBarr,
-	RE: RE,
-	REG: REG$1,
-	Racute: Racute,
-	Rang: Rang,
-	Rarr: Rarr,
-	Rarrtl: Rarrtl,
-	Rcaron: Rcaron,
-	Rcedil: Rcedil,
-	Rcy: Rcy,
-	Re: Re,
-	ReverseElement: ReverseElement,
-	ReverseEquilibrium: ReverseEquilibrium,
-	ReverseUpEquilibrium: ReverseUpEquilibrium,
-	Rfr: Rfr,
-	Rho: Rho,
-	RightAngleBracket: RightAngleBracket,
-	RightArrow: RightArrow,
-	RightArrowBar: RightArrowBar,
-	RightArrowLeftArrow: RightArrowLeftArrow,
-	RightCeiling: RightCeiling,
-	RightDoubleBracket: RightDoubleBracket,
-	RightDownTeeVector: RightDownTeeVector,
-	RightDownVector: RightDownVector,
-	RightDownVectorBar: RightDownVectorBar,
-	RightFloor: RightFloor,
-	RightTee: RightTee,
-	RightTeeArrow: RightTeeArrow,
-	RightTeeVector: RightTeeVector,
-	RightTriangle: RightTriangle,
-	RightTriangleBar: RightTriangleBar,
-	RightTriangleEqual: RightTriangleEqual,
-	RightUpDownVector: RightUpDownVector,
-	RightUpTeeVector: RightUpTeeVector,
-	RightUpVector: RightUpVector,
-	RightUpVectorBar: RightUpVectorBar,
-	RightVector: RightVector,
-	RightVectorBar: RightVectorBar,
-	Rightarrow: Rightarrow,
-	Ropf: Ropf,
-	RoundImplies: RoundImplies,
-	Rrightarrow: Rrightarrow,
-	Rscr: Rscr,
-	Rsh: Rsh,
-	RuleDelayed: RuleDelayed,
-	SHCHcy: SHCHcy,
-	SHcy: SHcy,
-	SOFTcy: SOFTcy,
-	Sacute: Sacute,
-	Sc: Sc,
-	Scaron: Scaron,
-	Scedil: Scedil,
-	Scirc: Scirc,
-	Scy: Scy,
-	Sfr: Sfr,
-	ShortDownArrow: ShortDownArrow,
-	ShortLeftArrow: ShortLeftArrow,
-	ShortRightArrow: ShortRightArrow,
-	ShortUpArrow: ShortUpArrow,
-	Sigma: Sigma,
-	SmallCircle: SmallCircle,
-	Sopf: Sopf,
-	Sqrt: Sqrt,
-	Square: Square,
-	SquareIntersection: SquareIntersection,
-	SquareSubset: SquareSubset,
-	SquareSubsetEqual: SquareSubsetEqual,
-	SquareSuperset: SquareSuperset,
-	SquareSupersetEqual: SquareSupersetEqual,
-	SquareUnion: SquareUnion,
-	Sscr: Sscr,
-	Star: Star,
-	Sub: Sub,
-	Subset: Subset,
-	SubsetEqual: SubsetEqual,
-	Succeeds: Succeeds,
-	SucceedsEqual: SucceedsEqual,
-	SucceedsSlantEqual: SucceedsSlantEqual,
-	SucceedsTilde: SucceedsTilde,
-	SuchThat: SuchThat,
-	Sum: Sum,
-	Sup: Sup,
-	Superset: Superset,
-	SupersetEqual: SupersetEqual,
-	Supset: Supset,
-	THOR: THOR,
-	THORN: THORN$1,
-	TRADE: TRADE,
-	TSHcy: TSHcy,
-	TScy: TScy,
-	Tab: Tab,
-	Tau: Tau,
-	Tcaron: Tcaron,
-	Tcedil: Tcedil,
-	Tcy: Tcy,
-	Tfr: Tfr,
-	Therefore: Therefore,
-	Theta: Theta,
-	ThickSpace: ThickSpace,
-	ThinSpace: ThinSpace,
-	Tilde: Tilde,
-	TildeEqual: TildeEqual,
-	TildeFullEqual: TildeFullEqual,
-	TildeTilde: TildeTilde,
-	Topf: Topf,
-	TripleDot: TripleDot,
-	Tscr: Tscr,
-	Tstrok: Tstrok,
-	Uacut: Uacut,
-	Uacute: Uacute$1,
-	Uarr: Uarr,
-	Uarrocir: Uarrocir,
-	Ubrcy: Ubrcy,
-	Ubreve: Ubreve,
-	Ucir: Ucir,
-	Ucirc: Ucirc$1,
-	Ucy: Ucy,
-	Udblac: Udblac,
-	Ufr: Ufr,
-	Ugrav: Ugrav,
-	Ugrave: Ugrave$1,
-	Umacr: Umacr,
-	UnderBar: UnderBar,
-	UnderBrace: UnderBrace,
-	UnderBracket: UnderBracket,
-	UnderParenthesis: UnderParenthesis,
-	Union: Union,
-	UnionPlus: UnionPlus,
-	Uogon: Uogon,
-	Uopf: Uopf,
-	UpArrow: UpArrow,
-	UpArrowBar: UpArrowBar,
-	UpArrowDownArrow: UpArrowDownArrow,
-	UpDownArrow: UpDownArrow,
-	UpEquilibrium: UpEquilibrium,
-	UpTee: UpTee,
-	UpTeeArrow: UpTeeArrow,
-	Uparrow: Uparrow,
-	Updownarrow: Updownarrow,
-	UpperLeftArrow: UpperLeftArrow,
-	UpperRightArrow: UpperRightArrow,
-	Upsi: Upsi,
-	Upsilon: Upsilon,
-	Uring: Uring,
-	Uscr: Uscr,
-	Utilde: Utilde,
-	Uum: Uum,
-	Uuml: Uuml$1,
-	VDash: VDash,
-	Vbar: Vbar,
-	Vcy: Vcy,
-	Vdash: Vdash,
-	Vdashl: Vdashl,
-	Vee: Vee,
-	Verbar: Verbar,
-	Vert: Vert,
-	VerticalBar: VerticalBar,
-	VerticalLine: VerticalLine,
-	VerticalSeparator: VerticalSeparator,
-	VerticalTilde: VerticalTilde,
-	VeryThinSpace: VeryThinSpace,
-	Vfr: Vfr,
-	Vopf: Vopf,
-	Vscr: Vscr,
-	Vvdash: Vvdash,
-	Wcirc: Wcirc,
-	Wedge: Wedge,
-	Wfr: Wfr,
-	Wopf: Wopf,
-	Wscr: Wscr,
-	Xfr: Xfr,
-	Xi: Xi,
-	Xopf: Xopf,
-	Xscr: Xscr,
-	YAcy: YAcy,
-	YIcy: YIcy,
-	YUcy: YUcy,
-	Yacut: Yacut,
-	Yacute: Yacute$1,
-	Ycirc: Ycirc,
-	Ycy: Ycy,
-	Yfr: Yfr,
-	Yopf: Yopf,
-	Yscr: Yscr,
-	Yuml: Yuml,
-	ZHcy: ZHcy,
-	Zacute: Zacute,
-	Zcaron: Zcaron,
-	Zcy: Zcy,
-	Zdot: Zdot,
-	ZeroWidthSpace: ZeroWidthSpace,
-	Zeta: Zeta,
-	Zfr: Zfr,
-	Zopf: Zopf,
-	Zscr: Zscr,
-	aacut: aacut,
-	aacute: aacute$1,
-	abreve: abreve,
-	ac: ac,
-	acE: acE,
-	acd: acd,
-	acir: acir,
-	acirc: acirc$1,
-	acut: acut,
-	acute: acute$1,
-	acy: acy,
-	aeli: aeli,
-	aelig: aelig$1,
-	af: af,
-	afr: afr,
-	agrav: agrav,
-	agrave: agrave$1,
-	alefsym: alefsym,
-	aleph: aleph,
-	alpha: alpha,
-	amacr: amacr,
-	amalg: amalg,
-	am: am,
-	amp: amp$1,
-	and: and,
-	andand: andand,
-	andd: andd,
-	andslope: andslope,
-	andv: andv,
-	ang: ang,
-	ange: ange,
-	angle: angle,
-	angmsd: angmsd,
-	angmsdaa: angmsdaa,
-	angmsdab: angmsdab,
-	angmsdac: angmsdac,
-	angmsdad: angmsdad,
-	angmsdae: angmsdae,
-	angmsdaf: angmsdaf,
-	angmsdag: angmsdag,
-	angmsdah: angmsdah,
-	angrt: angrt,
-	angrtvb: angrtvb,
-	angrtvbd: angrtvbd,
-	angsph: angsph,
-	angst: angst,
-	angzarr: angzarr,
-	aogon: aogon,
-	aopf: aopf,
-	ap: ap,
-	apE: apE,
-	apacir: apacir,
-	ape: ape,
-	apid: apid,
-	apos: apos,
-	approx: approx,
-	approxeq: approxeq,
-	arin: arin,
-	aring: aring$1,
-	ascr: ascr,
-	ast: ast,
-	asymp: asymp,
-	asympeq: asympeq,
-	atild: atild,
-	atilde: atilde$1,
-	aum: aum,
-	auml: auml$1,
-	awconint: awconint,
-	awint: awint,
-	bNot: bNot,
-	backcong: backcong,
-	backepsilon: backepsilon,
-	backprime: backprime,
-	backsim: backsim,
-	backsimeq: backsimeq,
-	barvee: barvee,
-	barwed: barwed,
-	barwedge: barwedge,
-	bbrk: bbrk,
-	bbrktbrk: bbrktbrk,
-	bcong: bcong,
-	bcy: bcy,
-	bdquo: bdquo,
-	becaus: becaus,
-	because: because,
-	bemptyv: bemptyv,
-	bepsi: bepsi,
-	bernou: bernou,
-	beta: beta,
-	beth: beth,
-	between: between,
-	bfr: bfr,
-	bigcap: bigcap,
-	bigcirc: bigcirc,
-	bigcup: bigcup,
-	bigodot: bigodot,
-	bigoplus: bigoplus,
-	bigotimes: bigotimes,
-	bigsqcup: bigsqcup,
-	bigstar: bigstar,
-	bigtriangledown: bigtriangledown,
-	bigtriangleup: bigtriangleup,
-	biguplus: biguplus,
-	bigvee: bigvee,
-	bigwedge: bigwedge,
-	bkarow: bkarow,
-	blacklozenge: blacklozenge,
-	blacksquare: blacksquare,
-	blacktriangle: blacktriangle,
-	blacktriangledown: blacktriangledown,
-	blacktriangleleft: blacktriangleleft,
-	blacktriangleright: blacktriangleright,
-	blank: blank,
-	blk12: blk12,
-	blk14: blk14,
-	blk34: blk34,
-	block: block,
-	bne: bne,
-	bnequiv: bnequiv,
-	bnot: bnot,
-	bopf: bopf,
-	bot: bot,
-	bottom: bottom,
-	bowtie: bowtie,
-	boxDL: boxDL,
-	boxDR: boxDR,
-	boxDl: boxDl,
-	boxDr: boxDr,
-	boxH: boxH,
-	boxHD: boxHD,
-	boxHU: boxHU,
-	boxHd: boxHd,
-	boxHu: boxHu,
-	boxUL: boxUL,
-	boxUR: boxUR,
-	boxUl: boxUl,
-	boxUr: boxUr,
-	boxV: boxV,
-	boxVH: boxVH,
-	boxVL: boxVL,
-	boxVR: boxVR,
-	boxVh: boxVh,
-	boxVl: boxVl,
-	boxVr: boxVr,
-	boxbox: boxbox,
-	boxdL: boxdL,
-	boxdR: boxdR,
-	boxdl: boxdl,
-	boxdr: boxdr,
-	boxh: boxh,
-	boxhD: boxhD,
-	boxhU: boxhU,
-	boxhd: boxhd,
-	boxhu: boxhu,
-	boxminus: boxminus,
-	boxplus: boxplus,
-	boxtimes: boxtimes,
-	boxuL: boxuL,
-	boxuR: boxuR,
-	boxul: boxul,
-	boxur: boxur,
-	boxv: boxv,
-	boxvH: boxvH,
-	boxvL: boxvL,
-	boxvR: boxvR,
-	boxvh: boxvh,
-	boxvl: boxvl,
-	boxvr: boxvr,
-	bprime: bprime,
-	breve: breve,
-	brvba: brvba,
-	brvbar: brvbar$1,
-	bscr: bscr,
-	bsemi: bsemi,
-	bsim: bsim,
-	bsime: bsime,
-	bsol: bsol,
-	bsolb: bsolb,
-	bsolhsub: bsolhsub,
-	bull: bull,
-	bullet: bullet,
-	bump: bump,
-	bumpE: bumpE,
-	bumpe: bumpe,
-	bumpeq: bumpeq,
-	cacute: cacute,
-	cap: cap,
-	capand: capand,
-	capbrcup: capbrcup,
-	capcap: capcap,
-	capcup: capcup,
-	capdot: capdot,
-	caps: caps,
-	caret: caret,
-	caron: caron,
-	ccaps: ccaps,
-	ccaron: ccaron,
-	ccedi: ccedi,
-	ccedil: ccedil$1,
-	ccirc: ccirc,
-	ccups: ccups,
-	ccupssm: ccupssm,
-	cdot: cdot,
-	cedi: cedi,
-	cedil: cedil$1,
-	cemptyv: cemptyv,
-	cen: cen,
-	cent: cent$1,
-	centerdot: centerdot,
-	cfr: cfr,
-	chcy: chcy,
-	check: check$2,
-	checkmark: checkmark,
-	chi: chi,
-	cir: cir,
-	cirE: cirE,
-	circ: circ,
-	circeq: circeq,
-	circlearrowleft: circlearrowleft,
-	circlearrowright: circlearrowright,
-	circledR: circledR,
-	circledS: circledS,
-	circledast: circledast,
-	circledcirc: circledcirc,
-	circleddash: circleddash,
-	cire: cire,
-	cirfnint: cirfnint,
-	cirmid: cirmid,
-	cirscir: cirscir,
-	clubs: clubs,
-	clubsuit: clubsuit,
-	colon: colon,
-	colone: colone,
-	coloneq: coloneq,
-	comma: comma,
-	commat: commat,
-	comp: comp,
-	compfn: compfn,
-	complement: complement,
-	complexes: complexes,
-	cong: cong,
-	congdot: congdot,
-	conint: conint,
-	copf: copf,
-	coprod: coprod,
-	cop: cop,
-	copy: copy$2,
-	copysr: copysr,
-	crarr: crarr,
-	cross: cross,
-	cscr: cscr,
-	csub: csub,
-	csube: csube,
-	csup: csup,
-	csupe: csupe,
-	ctdot: ctdot,
-	cudarrl: cudarrl,
-	cudarrr: cudarrr,
-	cuepr: cuepr,
-	cuesc: cuesc,
-	cularr: cularr,
-	cularrp: cularrp,
-	cup: cup,
-	cupbrcap: cupbrcap,
-	cupcap: cupcap,
-	cupcup: cupcup,
-	cupdot: cupdot,
-	cupor: cupor,
-	cups: cups,
-	curarr: curarr,
-	curarrm: curarrm,
-	curlyeqprec: curlyeqprec,
-	curlyeqsucc: curlyeqsucc,
-	curlyvee: curlyvee,
-	curlywedge: curlywedge,
-	curre: curre,
-	curren: curren$1,
-	curvearrowleft: curvearrowleft,
-	curvearrowright: curvearrowright,
-	cuvee: cuvee,
-	cuwed: cuwed,
-	cwconint: cwconint,
-	cwint: cwint,
-	cylcty: cylcty,
-	dArr: dArr,
-	dHar: dHar,
-	dagger: dagger,
-	daleth: daleth,
-	darr: darr,
-	dash: dash,
-	dashv: dashv,
-	dbkarow: dbkarow,
-	dblac: dblac,
-	dcaron: dcaron,
-	dcy: dcy,
-	dd: dd,
-	ddagger: ddagger,
-	ddarr: ddarr,
-	ddotseq: ddotseq,
-	de: de,
-	deg: deg$1,
-	delta: delta,
-	demptyv: demptyv,
-	dfisht: dfisht,
-	dfr: dfr,
-	dharl: dharl,
-	dharr: dharr,
-	diam: diam,
-	diamond: diamond,
-	diamondsuit: diamondsuit,
-	diams: diams,
-	die: die,
-	digamma: digamma,
-	disin: disin,
-	div: div,
-	divid: divid,
-	divide: divide$1,
-	divideontimes: divideontimes,
-	divonx: divonx,
-	djcy: djcy,
-	dlcorn: dlcorn,
-	dlcrop: dlcrop,
-	dollar: dollar,
-	dopf: dopf,
-	dot: dot,
-	doteq: doteq,
-	doteqdot: doteqdot,
-	dotminus: dotminus,
-	dotplus: dotplus,
-	dotsquare: dotsquare,
-	doublebarwedge: doublebarwedge,
-	downarrow: downarrow,
-	downdownarrows: downdownarrows,
-	downharpoonleft: downharpoonleft,
-	downharpoonright: downharpoonright,
-	drbkarow: drbkarow,
-	drcorn: drcorn,
-	drcrop: drcrop,
-	dscr: dscr,
-	dscy: dscy,
-	dsol: dsol,
-	dstrok: dstrok,
-	dtdot: dtdot,
-	dtri: dtri,
-	dtrif: dtrif,
-	duarr: duarr,
-	duhar: duhar,
-	dwangle: dwangle,
-	dzcy: dzcy,
-	dzigrarr: dzigrarr,
-	eDDot: eDDot,
-	eDot: eDot,
-	eacut: eacut,
-	eacute: eacute$1,
-	easter: easter,
-	ecaron: ecaron,
-	ecir: ecir,
-	ecirc: ecirc$1,
-	ecolon: ecolon,
-	ecy: ecy,
-	edot: edot,
-	ee: ee,
-	efDot: efDot,
-	efr: efr,
-	eg: eg,
-	egrav: egrav,
-	egrave: egrave$1,
-	egs: egs,
-	egsdot: egsdot,
-	el: el,
-	elinters: elinters,
-	ell: ell,
-	els: els,
-	elsdot: elsdot,
-	emacr: emacr,
-	empty: empty,
-	emptyset: emptyset,
-	emptyv: emptyv,
-	emsp13: emsp13,
-	emsp14: emsp14,
-	emsp: emsp,
-	eng: eng,
-	ensp: ensp,
-	eogon: eogon,
-	eopf: eopf,
-	epar: epar,
-	eparsl: eparsl,
-	eplus: eplus,
-	epsi: epsi,
-	epsilon: epsilon,
-	epsiv: epsiv,
-	eqcirc: eqcirc,
-	eqcolon: eqcolon,
-	eqsim: eqsim,
-	eqslantgtr: eqslantgtr,
-	eqslantless: eqslantless,
-	equals: equals,
-	equest: equest,
-	equiv: equiv,
-	equivDD: equivDD,
-	eqvparsl: eqvparsl,
-	erDot: erDot,
-	erarr: erarr,
-	escr: escr,
-	esdot: esdot,
-	esim: esim,
-	eta: eta,
-	et: et,
-	eth: eth$1,
-	eum: eum,
-	euml: euml$1,
-	euro: euro,
-	excl: excl,
-	exist: exist,
-	expectation: expectation,
-	exponentiale: exponentiale,
-	fallingdotseq: fallingdotseq,
-	fcy: fcy,
-	female: female,
-	ffilig: ffilig,
-	fflig: fflig,
-	ffllig: ffllig,
-	ffr: ffr,
-	filig: filig,
-	fjlig: fjlig,
-	flat: flat,
-	fllig: fllig,
-	fltns: fltns,
-	fnof: fnof,
-	fopf: fopf,
-	forall: forall,
-	fork: fork,
-	forkv: forkv,
-	fpartint: fpartint,
-	frac1: frac1,
-	frac12: frac12$1,
-	frac13: frac13,
-	frac14: frac14$1,
-	frac15: frac15,
-	frac16: frac16,
-	frac18: frac18,
-	frac23: frac23,
-	frac25: frac25,
-	frac3: frac3,
-	frac34: frac34$1,
-	frac35: frac35,
-	frac38: frac38,
-	frac45: frac45,
-	frac56: frac56,
-	frac58: frac58,
-	frac78: frac78,
-	frasl: frasl,
-	frown: frown,
-	fscr: fscr,
-	gE: gE,
-	gEl: gEl,
-	gacute: gacute,
-	gamma: gamma,
-	gammad: gammad,
-	gap: gap,
-	gbreve: gbreve,
-	gcirc: gcirc,
-	gcy: gcy,
-	gdot: gdot,
-	ge: ge,
-	gel: gel,
-	geq: geq,
-	geqq: geqq,
-	geqslant: geqslant,
-	ges: ges,
-	gescc: gescc,
-	gesdot: gesdot,
-	gesdoto: gesdoto,
-	gesdotol: gesdotol,
-	gesl: gesl,
-	gesles: gesles,
-	gfr: gfr,
-	gg: gg,
-	ggg: ggg,
-	gimel: gimel,
-	gjcy: gjcy,
-	gl: gl,
-	glE: glE,
-	gla: gla,
-	glj: glj,
-	gnE: gnE,
-	gnap: gnap,
-	gnapprox: gnapprox,
-	gne: gne,
-	gneq: gneq,
-	gneqq: gneqq,
-	gnsim: gnsim,
-	gopf: gopf,
-	grave: grave,
-	gscr: gscr,
-	gsim: gsim,
-	gsime: gsime,
-	gsiml: gsiml,
-	g: g,
-	gt: gt$1,
-	gtcc: gtcc,
-	gtcir: gtcir,
-	gtdot: gtdot,
-	gtlPar: gtlPar,
-	gtquest: gtquest,
-	gtrapprox: gtrapprox,
-	gtrarr: gtrarr,
-	gtrdot: gtrdot,
-	gtreqless: gtreqless,
-	gtreqqless: gtreqqless,
-	gtrless: gtrless,
-	gtrsim: gtrsim,
-	gvertneqq: gvertneqq,
-	gvnE: gvnE,
-	hArr: hArr,
-	hairsp: hairsp,
-	half: half,
-	hamilt: hamilt,
-	hardcy: hardcy,
-	harr: harr,
-	harrcir: harrcir,
-	harrw: harrw,
-	hbar: hbar,
-	hcirc: hcirc,
-	hearts: hearts,
-	heartsuit: heartsuit,
-	hellip: hellip,
-	hercon: hercon,
-	hfr: hfr,
-	hksearow: hksearow,
-	hkswarow: hkswarow,
-	hoarr: hoarr,
-	homtht: homtht,
-	hookleftarrow: hookleftarrow,
-	hookrightarrow: hookrightarrow,
-	hopf: hopf,
-	horbar: horbar,
-	hscr: hscr,
-	hslash: hslash,
-	hstrok: hstrok,
-	hybull: hybull,
-	hyphen: hyphen,
-	iacut: iacut,
-	iacute: iacute$1,
-	ic: ic,
-	icir: icir,
-	icirc: icirc$1,
-	icy: icy,
-	iecy: iecy,
-	iexc: iexc,
-	iexcl: iexcl$1,
-	iff: iff,
-	ifr: ifr,
-	igrav: igrav,
-	igrave: igrave$1,
-	ii: ii,
-	iiiint: iiiint,
-	iiint: iiint,
-	iinfin: iinfin,
-	iiota: iiota,
-	ijlig: ijlig,
-	imacr: imacr,
-	image: image,
-	imagline: imagline,
-	imagpart: imagpart,
-	imath: imath,
-	imof: imof,
-	imped: imped,
-	"in": "∈",
-	incare: incare,
-	infin: infin,
-	infintie: infintie,
-	inodot: inodot,
-	int: int,
-	intcal: intcal,
-	integers: integers,
-	intercal: intercal,
-	intlarhk: intlarhk,
-	intprod: intprod,
-	iocy: iocy,
-	iogon: iogon,
-	iopf: iopf,
-	iota: iota,
-	iprod: iprod,
-	iques: iques,
-	iquest: iquest$1,
-	iscr: iscr,
-	isin: isin,
-	isinE: isinE,
-	isindot: isindot,
-	isins: isins,
-	isinsv: isinsv,
-	isinv: isinv,
-	it: it,
-	itilde: itilde,
-	iukcy: iukcy,
-	ium: ium,
-	iuml: iuml$1,
-	jcirc: jcirc,
-	jcy: jcy,
-	jfr: jfr,
-	jmath: jmath,
-	jopf: jopf,
-	jscr: jscr,
-	jsercy: jsercy,
-	jukcy: jukcy,
-	kappa: kappa,
-	kappav: kappav,
-	kcedil: kcedil,
-	kcy: kcy,
-	kfr: kfr,
-	kgreen: kgreen,
-	khcy: khcy,
-	kjcy: kjcy,
-	kopf: kopf,
-	kscr: kscr,
-	lAarr: lAarr,
-	lArr: lArr,
-	lAtail: lAtail,
-	lBarr: lBarr,
-	lE: lE,
-	lEg: lEg,
-	lHar: lHar,
-	lacute: lacute,
-	laemptyv: laemptyv,
-	lagran: lagran,
-	lambda: lambda,
-	lang: lang,
-	langd: langd,
-	langle: langle,
-	lap: lap,
-	laqu: laqu,
-	laquo: laquo$1,
-	larr: larr,
-	larrb: larrb,
-	larrbfs: larrbfs,
-	larrfs: larrfs,
-	larrhk: larrhk,
-	larrlp: larrlp,
-	larrpl: larrpl,
-	larrsim: larrsim,
-	larrtl: larrtl,
-	lat: lat,
-	latail: latail,
-	late: late,
-	lates: lates,
-	lbarr: lbarr,
-	lbbrk: lbbrk,
-	lbrace: lbrace,
-	lbrack: lbrack,
-	lbrke: lbrke,
-	lbrksld: lbrksld,
-	lbrkslu: lbrkslu,
-	lcaron: lcaron,
-	lcedil: lcedil,
-	lceil: lceil,
-	lcub: lcub,
-	lcy: lcy,
-	ldca: ldca,
-	ldquo: ldquo,
-	ldquor: ldquor,
-	ldrdhar: ldrdhar,
-	ldrushar: ldrushar,
-	ldsh: ldsh,
-	le: le,
-	leftarrow: leftarrow,
-	leftarrowtail: leftarrowtail,
-	leftharpoondown: leftharpoondown,
-	leftharpoonup: leftharpoonup,
-	leftleftarrows: leftleftarrows,
-	leftrightarrow: leftrightarrow,
-	leftrightarrows: leftrightarrows,
-	leftrightharpoons: leftrightharpoons,
-	leftrightsquigarrow: leftrightsquigarrow,
-	leftthreetimes: leftthreetimes,
-	leg: leg,
-	leq: leq,
-	leqq: leqq,
-	leqslant: leqslant,
-	les: les,
-	lescc: lescc,
-	lesdot: lesdot,
-	lesdoto: lesdoto,
-	lesdotor: lesdotor,
-	lesg: lesg,
-	lesges: lesges,
-	lessapprox: lessapprox,
-	lessdot: lessdot,
-	lesseqgtr: lesseqgtr,
-	lesseqqgtr: lesseqqgtr,
-	lessgtr: lessgtr,
-	lesssim: lesssim,
-	lfisht: lfisht,
-	lfloor: lfloor,
-	lfr: lfr,
-	lg: lg,
-	lgE: lgE,
-	lhard: lhard,
-	lharu: lharu,
-	lharul: lharul,
-	lhblk: lhblk,
-	ljcy: ljcy,
-	ll: ll,
-	llarr: llarr,
-	llcorner: llcorner,
-	llhard: llhard,
-	lltri: lltri,
-	lmidot: lmidot,
-	lmoust: lmoust,
-	lmoustache: lmoustache,
-	lnE: lnE,
-	lnap: lnap,
-	lnapprox: lnapprox,
-	lne: lne,
-	lneq: lneq,
-	lneqq: lneqq,
-	lnsim: lnsim,
-	loang: loang,
-	loarr: loarr,
-	lobrk: lobrk,
-	longleftarrow: longleftarrow,
-	longleftrightarrow: longleftrightarrow,
-	longmapsto: longmapsto,
-	longrightarrow: longrightarrow,
-	looparrowleft: looparrowleft,
-	looparrowright: looparrowright,
-	lopar: lopar,
-	lopf: lopf,
-	loplus: loplus,
-	lotimes: lotimes,
-	lowast: lowast,
-	lowbar: lowbar,
-	loz: loz,
-	lozenge: lozenge,
-	lozf: lozf,
-	lpar: lpar,
-	lparlt: lparlt,
-	lrarr: lrarr,
-	lrcorner: lrcorner,
-	lrhar: lrhar,
-	lrhard: lrhard,
-	lrm: lrm,
-	lrtri: lrtri,
-	lsaquo: lsaquo,
-	lscr: lscr,
-	lsh: lsh,
-	lsim: lsim,
-	lsime: lsime,
-	lsimg: lsimg,
-	lsqb: lsqb,
-	lsquo: lsquo,
-	lsquor: lsquor,
-	lstrok: lstrok,
-	l: l,
-	lt: lt$1,
-	ltcc: ltcc,
-	ltcir: ltcir,
-	ltdot: ltdot,
-	lthree: lthree,
-	ltimes: ltimes,
-	ltlarr: ltlarr,
-	ltquest: ltquest,
-	ltrPar: ltrPar,
-	ltri: ltri,
-	ltrie: ltrie,
-	ltrif: ltrif,
-	lurdshar: lurdshar,
-	luruhar: luruhar,
-	lvertneqq: lvertneqq,
-	lvnE: lvnE,
-	mDDot: mDDot,
-	mac: mac,
-	macr: macr$1,
-	male: male,
-	malt: malt,
-	maltese: maltese,
-	map: map$2,
-	mapsto: mapsto,
-	mapstodown: mapstodown,
-	mapstoleft: mapstoleft,
-	mapstoup: mapstoup,
-	marker: marker,
-	mcomma: mcomma,
-	mcy: mcy,
-	mdash: mdash,
-	measuredangle: measuredangle,
-	mfr: mfr,
-	mho: mho,
-	micr: micr,
-	micro: micro$1,
-	mid: mid,
-	midast: midast,
-	midcir: midcir,
-	middo: middo,
-	middot: middot$1,
-	minus: minus,
-	minusb: minusb,
-	minusd: minusd,
-	minusdu: minusdu,
-	mlcp: mlcp,
-	mldr: mldr,
-	mnplus: mnplus,
-	models: models$2,
-	mopf: mopf,
-	mp: mp,
-	mscr: mscr,
-	mstpos: mstpos,
-	mu: mu,
-	multimap: multimap,
-	mumap: mumap,
-	nGg: nGg,
-	nGt: nGt,
-	nGtv: nGtv,
-	nLeftarrow: nLeftarrow,
-	nLeftrightarrow: nLeftrightarrow,
-	nLl: nLl,
-	nLt: nLt,
-	nLtv: nLtv,
-	nRightarrow: nRightarrow,
-	nVDash: nVDash,
-	nVdash: nVdash,
-	nabla: nabla,
-	nacute: nacute,
-	nang: nang,
-	nap: nap,
-	napE: napE,
-	napid: napid,
-	napos: napos,
-	napprox: napprox,
-	natur: natur,
-	natural: natural,
-	naturals: naturals,
-	nbs: nbs,
-	nbsp: nbsp$1,
-	nbump: nbump,
-	nbumpe: nbumpe,
-	ncap: ncap,
-	ncaron: ncaron,
-	ncedil: ncedil,
-	ncong: ncong,
-	ncongdot: ncongdot,
-	ncup: ncup,
-	ncy: ncy,
-	ndash: ndash,
-	ne: ne,
-	neArr: neArr,
-	nearhk: nearhk,
-	nearr: nearr,
-	nearrow: nearrow,
-	nedot: nedot,
-	nequiv: nequiv,
-	nesear: nesear,
-	nesim: nesim,
-	nexist: nexist,
-	nexists: nexists,
-	nfr: nfr,
-	ngE: ngE,
-	nge: nge,
-	ngeq: ngeq,
-	ngeqq: ngeqq,
-	ngeqslant: ngeqslant,
-	nges: nges,
-	ngsim: ngsim,
-	ngt: ngt,
-	ngtr: ngtr,
-	nhArr: nhArr,
-	nharr: nharr,
-	nhpar: nhpar,
-	ni: ni,
-	nis: nis,
-	nisd: nisd,
-	niv: niv,
-	njcy: njcy,
-	nlArr: nlArr,
-	nlE: nlE,
-	nlarr: nlarr,
-	nldr: nldr,
-	nle: nle,
-	nleftarrow: nleftarrow,
-	nleftrightarrow: nleftrightarrow,
-	nleq: nleq,
-	nleqq: nleqq,
-	nleqslant: nleqslant,
-	nles: nles,
-	nless: nless,
-	nlsim: nlsim,
-	nlt: nlt,
-	nltri: nltri,
-	nltrie: nltrie,
-	nmid: nmid,
-	nopf: nopf,
-	no: no,
-	not: not$1,
-	notin: notin,
-	notinE: notinE,
-	notindot: notindot,
-	notinva: notinva,
-	notinvb: notinvb,
-	notinvc: notinvc,
-	notni: notni,
-	notniva: notniva,
-	notnivb: notnivb,
-	notnivc: notnivc,
-	npar: npar,
-	nparallel: nparallel,
-	nparsl: nparsl,
-	npart: npart,
-	npolint: npolint,
-	npr: npr,
-	nprcue: nprcue,
-	npre: npre,
-	nprec: nprec,
-	npreceq: npreceq,
-	nrArr: nrArr,
-	nrarr: nrarr,
-	nrarrc: nrarrc,
-	nrarrw: nrarrw,
-	nrightarrow: nrightarrow,
-	nrtri: nrtri,
-	nrtrie: nrtrie,
-	nsc: nsc,
-	nsccue: nsccue,
-	nsce: nsce,
-	nscr: nscr,
-	nshortmid: nshortmid,
-	nshortparallel: nshortparallel,
-	nsim: nsim,
-	nsime: nsime,
-	nsimeq: nsimeq,
-	nsmid: nsmid,
-	nspar: nspar,
-	nsqsube: nsqsube,
-	nsqsupe: nsqsupe,
-	nsub: nsub,
-	nsubE: nsubE,
-	nsube: nsube,
-	nsubset: nsubset,
-	nsubseteq: nsubseteq,
-	nsubseteqq: nsubseteqq,
-	nsucc: nsucc,
-	nsucceq: nsucceq,
-	nsup: nsup,
-	nsupE: nsupE,
-	nsupe: nsupe,
-	nsupset: nsupset,
-	nsupseteq: nsupseteq,
-	nsupseteqq: nsupseteqq,
-	ntgl: ntgl,
-	ntild: ntild,
-	ntilde: ntilde$1,
-	ntlg: ntlg,
-	ntriangleleft: ntriangleleft,
-	ntrianglelefteq: ntrianglelefteq,
-	ntriangleright: ntriangleright,
-	ntrianglerighteq: ntrianglerighteq,
-	nu: nu,
-	num: num,
-	numero: numero,
-	numsp: numsp,
-	nvDash: nvDash,
-	nvHarr: nvHarr,
-	nvap: nvap,
-	nvdash: nvdash,
-	nvge: nvge,
-	nvgt: nvgt,
-	nvinfin: nvinfin,
-	nvlArr: nvlArr,
-	nvle: nvle,
-	nvlt: nvlt,
-	nvltrie: nvltrie,
-	nvrArr: nvrArr,
-	nvrtrie: nvrtrie,
-	nvsim: nvsim,
-	nwArr: nwArr,
-	nwarhk: nwarhk,
-	nwarr: nwarr,
-	nwarrow: nwarrow,
-	nwnear: nwnear,
-	oS: oS,
-	oacut: oacut,
-	oacute: oacute$1,
-	oast: oast,
-	ocir: ocir,
-	ocirc: ocirc$1,
-	ocy: ocy,
-	odash: odash,
-	odblac: odblac,
-	odiv: odiv,
-	odot: odot,
-	odsold: odsold,
-	oelig: oelig,
-	ofcir: ofcir,
-	ofr: ofr,
-	ogon: ogon,
-	ograv: ograv,
-	ograve: ograve$1,
-	ogt: ogt,
-	ohbar: ohbar,
-	ohm: ohm,
-	oint: oint,
-	olarr: olarr,
-	olcir: olcir,
-	olcross: olcross,
-	oline: oline,
-	olt: olt,
-	omacr: omacr,
-	omega: omega,
-	omicron: omicron,
-	omid: omid,
-	ominus: ominus,
-	oopf: oopf,
-	opar: opar,
-	operp: operp,
-	oplus: oplus,
-	or: or,
-	orarr: orarr,
-	ord: ord,
-	order: order$1,
-	orderof: orderof,
-	ordf: ordf$1,
-	ordm: ordm$1,
-	origof: origof,
-	oror: oror,
-	orslope: orslope,
-	orv: orv,
-	oscr: oscr,
-	oslas: oslas,
-	oslash: oslash$1,
-	osol: osol,
-	otild: otild,
-	otilde: otilde$1,
-	otimes: otimes,
-	otimesas: otimesas,
-	oum: oum,
-	ouml: ouml$1,
-	ovbar: ovbar,
-	par: par,
-	para: para$1,
-	parallel: parallel,
-	parsim: parsim,
-	parsl: parsl,
-	part: part,
-	pcy: pcy,
-	percnt: percnt,
-	period: period,
-	permil: permil,
-	perp: perp,
-	pertenk: pertenk,
-	pfr: pfr,
-	phi: phi,
-	phiv: phiv,
-	phmmat: phmmat,
-	phone: phone,
-	pi: pi,
-	pitchfork: pitchfork,
-	piv: piv,
-	planck: planck,
-	planckh: planckh,
-	plankv: plankv,
-	plus: plus,
-	plusacir: plusacir,
-	plusb: plusb,
-	pluscir: pluscir,
-	plusdo: plusdo,
-	plusdu: plusdu,
-	pluse: pluse,
-	plusm: plusm,
-	plusmn: plusmn$1,
-	plussim: plussim,
-	plustwo: plustwo,
-	pm: pm,
-	pointint: pointint,
-	popf: popf,
-	poun: poun,
-	pound: pound$1,
-	pr: pr,
-	prE: prE,
-	prap: prap,
-	prcue: prcue,
-	pre: pre,
-	prec: prec,
-	precapprox: precapprox,
-	preccurlyeq: preccurlyeq,
-	preceq: preceq,
-	precnapprox: precnapprox,
-	precneqq: precneqq,
-	precnsim: precnsim,
-	precsim: precsim,
-	prime: prime,
-	primes: primes,
-	prnE: prnE,
-	prnap: prnap,
-	prnsim: prnsim,
-	prod: prod,
-	profalar: profalar,
-	profline: profline,
-	profsurf: profsurf,
-	prop: prop,
-	propto: propto,
-	prsim: prsim,
-	prurel: prurel,
-	pscr: pscr,
-	psi: psi,
-	puncsp: puncsp,
-	qfr: qfr,
-	qint: qint,
-	qopf: qopf,
-	qprime: qprime,
-	qscr: qscr,
-	quaternions: quaternions,
-	quatint: quatint,
-	quest: quest,
-	questeq: questeq,
-	quo: quo,
-	quot: quot$1,
-	rAarr: rAarr,
-	rArr: rArr,
-	rAtail: rAtail,
-	rBarr: rBarr,
-	rHar: rHar,
-	race: race,
-	racute: racute,
-	radic: radic,
-	raemptyv: raemptyv,
-	rang: rang,
-	rangd: rangd,
-	range: range$1,
-	rangle: rangle,
-	raqu: raqu,
-	raquo: raquo$1,
-	rarr: rarr,
-	rarrap: rarrap,
-	rarrb: rarrb,
-	rarrbfs: rarrbfs,
-	rarrc: rarrc,
-	rarrfs: rarrfs,
-	rarrhk: rarrhk,
-	rarrlp: rarrlp,
-	rarrpl: rarrpl,
-	rarrsim: rarrsim,
-	rarrtl: rarrtl,
-	rarrw: rarrw,
-	ratail: ratail,
-	ratio: ratio,
-	rationals: rationals,
-	rbarr: rbarr,
-	rbbrk: rbbrk,
-	rbrace: rbrace,
-	rbrack: rbrack,
-	rbrke: rbrke,
-	rbrksld: rbrksld,
-	rbrkslu: rbrkslu,
-	rcaron: rcaron,
-	rcedil: rcedil,
-	rceil: rceil,
-	rcub: rcub,
-	rcy: rcy,
-	rdca: rdca,
-	rdldhar: rdldhar,
-	rdquo: rdquo,
-	rdquor: rdquor,
-	rdsh: rdsh,
-	real: real,
-	realine: realine,
-	realpart: realpart,
-	reals: reals,
-	rect: rect,
-	re: re,
-	reg: reg$1,
-	rfisht: rfisht,
-	rfloor: rfloor,
-	rfr: rfr,
-	rhard: rhard,
-	rharu: rharu,
-	rharul: rharul,
-	rho: rho,
-	rhov: rhov,
-	rightarrow: rightarrow,
-	rightarrowtail: rightarrowtail,
-	rightharpoondown: rightharpoondown,
-	rightharpoonup: rightharpoonup,
-	rightleftarrows: rightleftarrows,
-	rightleftharpoons: rightleftharpoons,
-	rightrightarrows: rightrightarrows,
-	rightsquigarrow: rightsquigarrow,
-	rightthreetimes: rightthreetimes,
-	ring: ring,
-	risingdotseq: risingdotseq,
-	rlarr: rlarr,
-	rlhar: rlhar,
-	rlm: rlm,
-	rmoust: rmoust,
-	rmoustache: rmoustache,
-	rnmid: rnmid,
-	roang: roang,
-	roarr: roarr,
-	robrk: robrk,
-	ropar: ropar,
-	ropf: ropf,
-	roplus: roplus,
-	rotimes: rotimes,
-	rpar: rpar,
-	rpargt: rpargt,
-	rppolint: rppolint,
-	rrarr: rrarr,
-	rsaquo: rsaquo,
-	rscr: rscr,
-	rsh: rsh,
-	rsqb: rsqb,
-	rsquo: rsquo,
-	rsquor: rsquor,
-	rthree: rthree,
-	rtimes: rtimes,
-	rtri: rtri,
-	rtrie: rtrie,
-	rtrif: rtrif,
-	rtriltri: rtriltri,
-	ruluhar: ruluhar,
-	rx: rx,
-	sacute: sacute,
-	sbquo: sbquo,
-	sc: sc,
-	scE: scE,
-	scap: scap,
-	scaron: scaron,
-	sccue: sccue,
-	sce: sce,
-	scedil: scedil,
-	scirc: scirc,
-	scnE: scnE,
-	scnap: scnap,
-	scnsim: scnsim,
-	scpolint: scpolint,
-	scsim: scsim,
-	scy: scy,
-	sdot: sdot,
-	sdotb: sdotb,
-	sdote: sdote,
-	seArr: seArr,
-	searhk: searhk,
-	searr: searr,
-	searrow: searrow,
-	sec: sec,
-	sect: sect$1,
-	semi: semi,
-	seswar: seswar,
-	setminus: setminus,
-	setmn: setmn,
-	sext: sext,
-	sfr: sfr,
-	sfrown: sfrown,
-	sharp: sharp,
-	shchcy: shchcy,
-	shcy: shcy,
-	shortmid: shortmid,
-	shortparallel: shortparallel,
-	sh: sh,
-	shy: shy$1,
-	sigma: sigma,
-	sigmaf: sigmaf,
-	sigmav: sigmav,
-	sim: sim,
-	simdot: simdot,
-	sime: sime,
-	simeq: simeq,
-	simg: simg,
-	simgE: simgE,
-	siml: siml,
-	simlE: simlE,
-	simne: simne,
-	simplus: simplus,
-	simrarr: simrarr,
-	slarr: slarr,
-	smallsetminus: smallsetminus,
-	smashp: smashp,
-	smeparsl: smeparsl,
-	smid: smid,
-	smile: smile,
-	smt: smt,
-	smte: smte,
-	smtes: smtes,
-	softcy: softcy,
-	sol: sol,
-	solb: solb,
-	solbar: solbar,
-	sopf: sopf,
-	spades: spades,
-	spadesuit: spadesuit,
-	spar: spar,
-	sqcap: sqcap,
-	sqcaps: sqcaps,
-	sqcup: sqcup,
-	sqcups: sqcups,
-	sqsub: sqsub,
-	sqsube: sqsube,
-	sqsubset: sqsubset,
-	sqsubseteq: sqsubseteq,
-	sqsup: sqsup,
-	sqsupe: sqsupe,
-	sqsupset: sqsupset,
-	sqsupseteq: sqsupseteq,
-	squ: squ,
-	square: square,
-	squarf: squarf,
-	squf: squf,
-	srarr: srarr,
-	sscr: sscr,
-	ssetmn: ssetmn,
-	ssmile: ssmile,
-	sstarf: sstarf,
-	star: star$1,
-	starf: starf,
-	straightepsilon: straightepsilon,
-	straightphi: straightphi,
-	strns: strns,
-	sub: sub,
-	subE: subE,
-	subdot: subdot,
-	sube: sube,
-	subedot: subedot,
-	submult: submult,
-	subnE: subnE,
-	subne: subne,
-	subplus: subplus,
-	subrarr: subrarr,
-	subset: subset,
-	subseteq: subseteq,
-	subseteqq: subseteqq,
-	subsetneq: subsetneq,
-	subsetneqq: subsetneqq,
-	subsim: subsim,
-	subsub: subsub,
-	subsup: subsup,
-	succ: succ,
-	succapprox: succapprox,
-	succcurlyeq: succcurlyeq,
-	succeq: succeq,
-	succnapprox: succnapprox,
-	succneqq: succneqq,
-	succnsim: succnsim,
-	succsim: succsim,
-	sum: sum,
-	sung: sung,
-	sup: sup,
-	sup1: sup1$1,
-	sup2: sup2$1,
-	sup3: sup3$1,
-	supE: supE,
-	supdot: supdot,
-	supdsub: supdsub,
-	supe: supe,
-	supedot: supedot,
-	suphsol: suphsol,
-	suphsub: suphsub,
-	suplarr: suplarr,
-	supmult: supmult,
-	supnE: supnE,
-	supne: supne,
-	supplus: supplus,
-	supset: supset,
-	supseteq: supseteq,
-	supseteqq: supseteqq,
-	supsetneq: supsetneq,
-	supsetneqq: supsetneqq,
-	supsim: supsim,
-	supsub: supsub,
-	supsup: supsup,
-	swArr: swArr,
-	swarhk: swarhk,
-	swarr: swarr,
-	swarrow: swarrow,
-	swnwar: swnwar,
-	szli: szli,
-	szlig: szlig$1,
-	target: target,
-	tau: tau,
-	tbrk: tbrk,
-	tcaron: tcaron,
-	tcedil: tcedil,
-	tcy: tcy,
-	tdot: tdot,
-	telrec: telrec,
-	tfr: tfr,
-	there4: there4,
-	therefore: therefore,
-	theta: theta,
-	thetasym: thetasym,
-	thetav: thetav,
-	thickapprox: thickapprox,
-	thicksim: thicksim,
-	thinsp: thinsp,
-	thkap: thkap,
-	thksim: thksim,
-	thor: thor,
-	thorn: thorn$1,
-	tilde: tilde,
-	time: time,
-	times: times$1,
-	timesb: timesb,
-	timesbar: timesbar,
-	timesd: timesd,
-	tint: tint,
-	toea: toea,
-	top: top,
-	topbot: topbot,
-	topcir: topcir,
-	topf: topf,
-	topfork: topfork,
-	tosa: tosa,
-	tprime: tprime,
-	trade: trade,
-	triangle: triangle,
-	triangledown: triangledown,
-	triangleleft: triangleleft,
-	trianglelefteq: trianglelefteq,
-	triangleq: triangleq,
-	triangleright: triangleright,
-	trianglerighteq: trianglerighteq,
-	tridot: tridot,
-	trie: trie,
-	triminus: triminus,
-	triplus: triplus,
-	trisb: trisb,
-	tritime: tritime,
-	trpezium: trpezium,
-	tscr: tscr,
-	tscy: tscy,
-	tshcy: tshcy,
-	tstrok: tstrok,
-	twixt: twixt,
-	twoheadleftarrow: twoheadleftarrow,
-	twoheadrightarrow: twoheadrightarrow,
-	uArr: uArr,
-	uHar: uHar,
-	uacut: uacut,
-	uacute: uacute$1,
-	uarr: uarr,
-	ubrcy: ubrcy,
-	ubreve: ubreve,
-	ucir: ucir,
-	ucirc: ucirc$1,
-	ucy: ucy,
-	udarr: udarr,
-	udblac: udblac,
-	udhar: udhar,
-	ufisht: ufisht,
-	ufr: ufr,
-	ugrav: ugrav,
-	ugrave: ugrave$1,
-	uharl: uharl,
-	uharr: uharr,
-	uhblk: uhblk,
-	ulcorn: ulcorn,
-	ulcorner: ulcorner,
-	ulcrop: ulcrop,
-	ultri: ultri,
-	umacr: umacr,
-	um: um,
-	uml: uml$1,
-	uogon: uogon,
-	uopf: uopf,
-	uparrow: uparrow,
-	updownarrow: updownarrow,
-	upharpoonleft: upharpoonleft,
-	upharpoonright: upharpoonright,
-	uplus: uplus,
-	upsi: upsi,
-	upsih: upsih,
-	upsilon: upsilon,
-	upuparrows: upuparrows,
-	urcorn: urcorn,
-	urcorner: urcorner,
-	urcrop: urcrop,
-	uring: uring,
-	urtri: urtri,
-	uscr: uscr,
-	utdot: utdot,
-	utilde: utilde,
-	utri: utri,
-	utrif: utrif,
-	uuarr: uuarr,
-	uum: uum,
-	uuml: uuml$1,
-	uwangle: uwangle,
-	vArr: vArr,
-	vBar: vBar,
-	vBarv: vBarv,
-	vDash: vDash,
-	vangrt: vangrt,
-	varepsilon: varepsilon,
-	varkappa: varkappa,
-	varnothing: varnothing,
-	varphi: varphi,
-	varpi: varpi,
-	varpropto: varpropto,
-	varr: varr,
-	varrho: varrho,
-	varsigma: varsigma,
-	varsubsetneq: varsubsetneq,
-	varsubsetneqq: varsubsetneqq,
-	varsupsetneq: varsupsetneq,
-	varsupsetneqq: varsupsetneqq,
-	vartheta: vartheta,
-	vartriangleleft: vartriangleleft,
-	vartriangleright: vartriangleright,
-	vcy: vcy,
-	vdash: vdash,
-	vee: vee,
-	veebar: veebar,
-	veeeq: veeeq,
-	vellip: vellip,
-	verbar: verbar,
-	vert: vert,
-	vfr: vfr,
-	vltri: vltri,
-	vnsub: vnsub,
-	vnsup: vnsup,
-	vopf: vopf,
-	vprop: vprop,
-	vrtri: vrtri,
-	vscr: vscr,
-	vsubnE: vsubnE,
-	vsubne: vsubne,
-	vsupnE: vsupnE,
-	vsupne: vsupne,
-	vzigzag: vzigzag,
-	wcirc: wcirc,
-	wedbar: wedbar,
-	wedge: wedge,
-	wedgeq: wedgeq,
-	weierp: weierp,
-	wfr: wfr,
-	wopf: wopf,
-	wp: wp,
-	wr: wr,
-	wreath: wreath,
-	wscr: wscr,
-	xcap: xcap,
-	xcirc: xcirc,
-	xcup: xcup,
-	xdtri: xdtri,
-	xfr: xfr,
-	xhArr: xhArr,
-	xharr: xharr,
-	xi: xi,
-	xlArr: xlArr,
-	xlarr: xlarr,
-	xmap: xmap,
-	xnis: xnis,
-	xodot: xodot,
-	xopf: xopf,
-	xoplus: xoplus,
-	xotime: xotime,
-	xrArr: xrArr,
-	xrarr: xrarr,
-	xscr: xscr,
-	xsqcup: xsqcup,
-	xuplus: xuplus,
-	xutri: xutri,
-	xvee: xvee,
-	xwedge: xwedge,
-	yacut: yacut,
-	yacute: yacute$1,
-	yacy: yacy,
-	ycirc: ycirc,
-	ycy: ycy,
-	ye: ye,
-	yen: yen$1,
-	yfr: yfr,
-	yicy: yicy,
-	yopf: yopf,
-	yscr: yscr,
-	yucy: yucy,
-	yum: yum,
-	yuml: yuml$1,
-	zacute: zacute,
-	zcaron: zcaron,
-	zcy: zcy,
-	zdot: zdot,
-	zeetrf: zeetrf,
-	zeta: zeta,
-	zfr: zfr,
-	zhcy: zhcy,
-	zigrarr: zigrarr,
-	zopf: zopf,
-	zscr: zscr,
-	zwj: zwj,
-	zwnj: zwnj
-};
-
-var characterEntities = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  AEli: AEli,
-  AElig: AElig$1,
-  AM: AM,
-  AMP: AMP$1,
-  Aacut: Aacut,
-  Aacute: Aacute$1,
-  Abreve: Abreve,
-  Acir: Acir,
-  Acirc: Acirc$1,
-  Acy: Acy,
-  Afr: Afr,
-  Agrav: Agrav,
-  Agrave: Agrave$1,
-  Alpha: Alpha,
-  Amacr: Amacr,
-  And: And,
-  Aogon: Aogon,
-  Aopf: Aopf,
-  ApplyFunction: ApplyFunction,
-  Arin: Arin,
-  Aring: Aring$1,
-  Ascr: Ascr,
-  Assign: Assign,
-  Atild: Atild,
-  Atilde: Atilde$1,
-  Aum: Aum,
-  Auml: Auml$1,
-  Backslash: Backslash,
-  Barv: Barv,
-  Barwed: Barwed,
-  Bcy: Bcy,
-  Because: Because,
-  Bernoullis: Bernoullis,
-  Beta: Beta,
-  Bfr: Bfr,
-  Bopf: Bopf,
-  Breve: Breve,
-  Bscr: Bscr,
-  Bumpeq: Bumpeq,
-  CHcy: CHcy,
-  COP: COP,
-  COPY: COPY$1,
-  Cacute: Cacute,
-  Cap: Cap,
-  CapitalDifferentialD: CapitalDifferentialD,
-  Cayleys: Cayleys,
-  Ccaron: Ccaron,
-  Ccedi: Ccedi,
-  Ccedil: Ccedil$1,
-  Ccirc: Ccirc,
-  Cconint: Cconint,
-  Cdot: Cdot,
-  Cedilla: Cedilla,
-  CenterDot: CenterDot,
-  Cfr: Cfr,
-  Chi: Chi,
-  CircleDot: CircleDot,
-  CircleMinus: CircleMinus,
-  CirclePlus: CirclePlus,
-  CircleTimes: CircleTimes,
-  ClockwiseContourIntegral: ClockwiseContourIntegral,
-  CloseCurlyDoubleQuote: CloseCurlyDoubleQuote,
-  CloseCurlyQuote: CloseCurlyQuote,
-  Colon: Colon,
-  Colone: Colone,
-  Congruent: Congruent,
-  Conint: Conint,
-  ContourIntegral: ContourIntegral,
-  Copf: Copf,
-  Coproduct: Coproduct,
-  CounterClockwiseContourIntegral: CounterClockwiseContourIntegral,
-  Cross: Cross,
-  Cscr: Cscr,
-  Cup: Cup,
-  CupCap: CupCap,
-  DD: DD,
-  DDotrahd: DDotrahd,
-  DJcy: DJcy,
-  DScy: DScy,
-  DZcy: DZcy,
-  Dagger: Dagger,
-  Darr: Darr,
-  Dashv: Dashv,
-  Dcaron: Dcaron,
-  Dcy: Dcy,
-  Del: Del,
-  Delta: Delta,
-  Dfr: Dfr,
-  DiacriticalAcute: DiacriticalAcute,
-  DiacriticalDot: DiacriticalDot,
-  DiacriticalDoubleAcute: DiacriticalDoubleAcute,
-  DiacriticalGrave: DiacriticalGrave,
-  DiacriticalTilde: DiacriticalTilde,
-  Diamond: Diamond,
-  DifferentialD: DifferentialD,
-  Dopf: Dopf,
-  Dot: Dot,
-  DotDot: DotDot,
-  DotEqual: DotEqual,
-  DoubleContourIntegral: DoubleContourIntegral,
-  DoubleDot: DoubleDot,
-  DoubleDownArrow: DoubleDownArrow,
-  DoubleLeftArrow: DoubleLeftArrow,
-  DoubleLeftRightArrow: DoubleLeftRightArrow,
-  DoubleLeftTee: DoubleLeftTee,
-  DoubleLongLeftArrow: DoubleLongLeftArrow,
-  DoubleLongLeftRightArrow: DoubleLongLeftRightArrow,
-  DoubleLongRightArrow: DoubleLongRightArrow,
-  DoubleRightArrow: DoubleRightArrow,
-  DoubleRightTee: DoubleRightTee,
-  DoubleUpArrow: DoubleUpArrow,
-  DoubleUpDownArrow: DoubleUpDownArrow,
-  DoubleVerticalBar: DoubleVerticalBar,
-  DownArrow: DownArrow,
-  DownArrowBar: DownArrowBar,
-  DownArrowUpArrow: DownArrowUpArrow,
-  DownBreve: DownBreve,
-  DownLeftRightVector: DownLeftRightVector,
-  DownLeftTeeVector: DownLeftTeeVector,
-  DownLeftVector: DownLeftVector,
-  DownLeftVectorBar: DownLeftVectorBar,
-  DownRightTeeVector: DownRightTeeVector,
-  DownRightVector: DownRightVector,
-  DownRightVectorBar: DownRightVectorBar,
-  DownTee: DownTee,
-  DownTeeArrow: DownTeeArrow,
-  Downarrow: Downarrow,
-  Dscr: Dscr,
-  Dstrok: Dstrok,
-  ENG: ENG,
-  ET: ET,
-  ETH: ETH$1,
-  Eacut: Eacut,
-  Eacute: Eacute$1,
-  Ecaron: Ecaron,
-  Ecir: Ecir,
-  Ecirc: Ecirc$1,
-  Ecy: Ecy,
-  Edot: Edot,
-  Efr: Efr,
-  Egrav: Egrav,
-  Egrave: Egrave$1,
-  Element: Element,
-  Emacr: Emacr,
-  EmptySmallSquare: EmptySmallSquare,
-  EmptyVerySmallSquare: EmptyVerySmallSquare,
-  Eogon: Eogon,
-  Eopf: Eopf,
-  Epsilon: Epsilon,
-  Equal: Equal,
-  EqualTilde: EqualTilde,
-  Equilibrium: Equilibrium,
-  Escr: Escr,
-  Esim: Esim,
-  Eta: Eta,
-  Eum: Eum,
-  Euml: Euml$1,
-  Exists: Exists,
-  ExponentialE: ExponentialE,
-  Fcy: Fcy,
-  Ffr: Ffr,
-  FilledSmallSquare: FilledSmallSquare,
-  FilledVerySmallSquare: FilledVerySmallSquare,
-  Fopf: Fopf,
-  ForAll: ForAll,
-  Fouriertrf: Fouriertrf,
-  Fscr: Fscr,
-  GJcy: GJcy,
-  G: G,
-  GT: GT$1,
-  Gamma: Gamma,
-  Gammad: Gammad,
-  Gbreve: Gbreve,
-  Gcedil: Gcedil,
-  Gcirc: Gcirc,
-  Gcy: Gcy,
-  Gdot: Gdot,
-  Gfr: Gfr,
-  Gg: Gg,
-  Gopf: Gopf,
-  GreaterEqual: GreaterEqual,
-  GreaterEqualLess: GreaterEqualLess,
-  GreaterFullEqual: GreaterFullEqual,
-  GreaterGreater: GreaterGreater,
-  GreaterLess: GreaterLess,
-  GreaterSlantEqual: GreaterSlantEqual,
-  GreaterTilde: GreaterTilde,
-  Gscr: Gscr,
-  Gt: Gt,
-  HARDcy: HARDcy,
-  Hacek: Hacek,
-  Hat: Hat,
-  Hcirc: Hcirc,
-  Hfr: Hfr,
-  HilbertSpace: HilbertSpace,
-  Hopf: Hopf,
-  HorizontalLine: HorizontalLine,
-  Hscr: Hscr,
-  Hstrok: Hstrok,
-  HumpDownHump: HumpDownHump,
-  HumpEqual: HumpEqual,
-  IEcy: IEcy,
-  IJlig: IJlig,
-  IOcy: IOcy,
-  Iacut: Iacut,
-  Iacute: Iacute$1,
-  Icir: Icir,
-  Icirc: Icirc$1,
-  Icy: Icy,
-  Idot: Idot,
-  Ifr: Ifr,
-  Igrav: Igrav,
-  Igrave: Igrave$1,
-  Im: Im,
-  Imacr: Imacr,
-  ImaginaryI: ImaginaryI,
-  Implies: Implies,
-  Int: Int,
-  Integral: Integral,
-  Intersection: Intersection,
-  InvisibleComma: InvisibleComma,
-  InvisibleTimes: InvisibleTimes,
-  Iogon: Iogon,
-  Iopf: Iopf,
-  Iota: Iota,
-  Iscr: Iscr,
-  Itilde: Itilde,
-  Iukcy: Iukcy,
-  Ium: Ium,
-  Iuml: Iuml$1,
-  Jcirc: Jcirc,
-  Jcy: Jcy,
-  Jfr: Jfr,
-  Jopf: Jopf,
-  Jscr: Jscr,
-  Jsercy: Jsercy,
-  Jukcy: Jukcy,
-  KHcy: KHcy,
-  KJcy: KJcy,
-  Kappa: Kappa,
-  Kcedil: Kcedil,
-  Kcy: Kcy,
-  Kfr: Kfr,
-  Kopf: Kopf,
-  Kscr: Kscr,
-  LJcy: LJcy,
-  L: L,
-  LT: LT$1,
-  Lacute: Lacute,
-  Lambda: Lambda,
-  Lang: Lang,
-  Laplacetrf: Laplacetrf,
-  Larr: Larr,
-  Lcaron: Lcaron,
-  Lcedil: Lcedil,
-  Lcy: Lcy,
-  LeftAngleBracket: LeftAngleBracket,
-  LeftArrow: LeftArrow,
-  LeftArrowBar: LeftArrowBar,
-  LeftArrowRightArrow: LeftArrowRightArrow,
-  LeftCeiling: LeftCeiling,
-  LeftDoubleBracket: LeftDoubleBracket,
-  LeftDownTeeVector: LeftDownTeeVector,
-  LeftDownVector: LeftDownVector,
-  LeftDownVectorBar: LeftDownVectorBar,
-  LeftFloor: LeftFloor,
-  LeftRightArrow: LeftRightArrow,
-  LeftRightVector: LeftRightVector,
-  LeftTee: LeftTee,
-  LeftTeeArrow: LeftTeeArrow,
-  LeftTeeVector: LeftTeeVector,
-  LeftTriangle: LeftTriangle,
-  LeftTriangleBar: LeftTriangleBar,
-  LeftTriangleEqual: LeftTriangleEqual,
-  LeftUpDownVector: LeftUpDownVector,
-  LeftUpTeeVector: LeftUpTeeVector,
-  LeftUpVector: LeftUpVector,
-  LeftUpVectorBar: LeftUpVectorBar,
-  LeftVector: LeftVector,
-  LeftVectorBar: LeftVectorBar,
-  Leftarrow: Leftarrow,
-  Leftrightarrow: Leftrightarrow,
-  LessEqualGreater: LessEqualGreater,
-  LessFullEqual: LessFullEqual,
-  LessGreater: LessGreater,
-  LessLess: LessLess,
-  LessSlantEqual: LessSlantEqual,
-  LessTilde: LessTilde,
-  Lfr: Lfr,
-  Ll: Ll,
-  Lleftarrow: Lleftarrow,
-  Lmidot: Lmidot,
-  LongLeftArrow: LongLeftArrow,
-  LongLeftRightArrow: LongLeftRightArrow,
-  LongRightArrow: LongRightArrow,
-  Longleftarrow: Longleftarrow,
-  Longleftrightarrow: Longleftrightarrow,
-  Longrightarrow: Longrightarrow,
-  Lopf: Lopf,
-  LowerLeftArrow: LowerLeftArrow,
-  LowerRightArrow: LowerRightArrow,
-  Lscr: Lscr,
-  Lsh: Lsh,
-  Lstrok: Lstrok,
-  Lt: Lt,
-  Mcy: Mcy,
-  MediumSpace: MediumSpace,
-  Mellintrf: Mellintrf,
-  Mfr: Mfr,
-  MinusPlus: MinusPlus,
-  Mopf: Mopf,
-  Mscr: Mscr,
-  Mu: Mu,
-  NJcy: NJcy,
-  Nacute: Nacute,
-  Ncaron: Ncaron,
-  Ncedil: Ncedil,
-  Ncy: Ncy,
-  NegativeMediumSpace: NegativeMediumSpace,
-  NegativeThickSpace: NegativeThickSpace,
-  NegativeThinSpace: NegativeThinSpace,
-  NegativeVeryThinSpace: NegativeVeryThinSpace,
-  NestedGreaterGreater: NestedGreaterGreater,
-  NestedLessLess: NestedLessLess,
-  NewLine: NewLine,
-  Nfr: Nfr,
-  NoBreak: NoBreak,
-  NonBreakingSpace: NonBreakingSpace,
-  Nopf: Nopf,
-  Not: Not,
-  NotCongruent: NotCongruent,
-  NotCupCap: NotCupCap,
-  NotDoubleVerticalBar: NotDoubleVerticalBar,
-  NotElement: NotElement,
-  NotEqual: NotEqual,
-  NotEqualTilde: NotEqualTilde,
-  NotExists: NotExists,
-  NotGreater: NotGreater,
-  NotGreaterEqual: NotGreaterEqual,
-  NotGreaterFullEqual: NotGreaterFullEqual,
-  NotGreaterGreater: NotGreaterGreater,
-  NotGreaterLess: NotGreaterLess,
-  NotGreaterSlantEqual: NotGreaterSlantEqual,
-  NotGreaterTilde: NotGreaterTilde,
-  NotHumpDownHump: NotHumpDownHump,
-  NotHumpEqual: NotHumpEqual,
-  NotLeftTriangle: NotLeftTriangle,
-  NotLeftTriangleBar: NotLeftTriangleBar,
-  NotLeftTriangleEqual: NotLeftTriangleEqual,
-  NotLess: NotLess,
-  NotLessEqual: NotLessEqual,
-  NotLessGreater: NotLessGreater,
-  NotLessLess: NotLessLess,
-  NotLessSlantEqual: NotLessSlantEqual,
-  NotLessTilde: NotLessTilde,
-  NotNestedGreaterGreater: NotNestedGreaterGreater,
-  NotNestedLessLess: NotNestedLessLess,
-  NotPrecedes: NotPrecedes,
-  NotPrecedesEqual: NotPrecedesEqual,
-  NotPrecedesSlantEqual: NotPrecedesSlantEqual,
-  NotReverseElement: NotReverseElement,
-  NotRightTriangle: NotRightTriangle,
-  NotRightTriangleBar: NotRightTriangleBar,
-  NotRightTriangleEqual: NotRightTriangleEqual,
-  NotSquareSubset: NotSquareSubset,
-  NotSquareSubsetEqual: NotSquareSubsetEqual,
-  NotSquareSuperset: NotSquareSuperset,
-  NotSquareSupersetEqual: NotSquareSupersetEqual,
-  NotSubset: NotSubset,
-  NotSubsetEqual: NotSubsetEqual,
-  NotSucceeds: NotSucceeds,
-  NotSucceedsEqual: NotSucceedsEqual,
-  NotSucceedsSlantEqual: NotSucceedsSlantEqual,
-  NotSucceedsTilde: NotSucceedsTilde,
-  NotSuperset: NotSuperset,
-  NotSupersetEqual: NotSupersetEqual,
-  NotTilde: NotTilde,
-  NotTildeEqual: NotTildeEqual,
-  NotTildeFullEqual: NotTildeFullEqual,
-  NotTildeTilde: NotTildeTilde,
-  NotVerticalBar: NotVerticalBar,
-  Nscr: Nscr,
-  Ntild: Ntild,
-  Ntilde: Ntilde$1,
-  Nu: Nu,
-  OElig: OElig,
-  Oacut: Oacut,
-  Oacute: Oacute$1,
-  Ocir: Ocir,
-  Ocirc: Ocirc$1,
-  Ocy: Ocy,
-  Odblac: Odblac,
-  Ofr: Ofr,
-  Ograv: Ograv,
-  Ograve: Ograve$1,
-  Omacr: Omacr,
-  Omega: Omega,
-  Omicron: Omicron,
-  Oopf: Oopf,
-  OpenCurlyDoubleQuote: OpenCurlyDoubleQuote,
-  OpenCurlyQuote: OpenCurlyQuote,
-  Or: Or,
-  Oscr: Oscr,
-  Oslas: Oslas,
-  Oslash: Oslash$1,
-  Otild: Otild,
-  Otilde: Otilde$1,
-  Otimes: Otimes,
-  Oum: Oum,
-  Ouml: Ouml$1,
-  OverBar: OverBar,
-  OverBrace: OverBrace,
-  OverBracket: OverBracket,
-  OverParenthesis: OverParenthesis,
-  PartialD: PartialD,
-  Pcy: Pcy,
-  Pfr: Pfr,
-  Phi: Phi,
-  Pi: Pi,
-  PlusMinus: PlusMinus,
-  Poincareplane: Poincareplane,
-  Popf: Popf,
-  Pr: Pr,
-  Precedes: Precedes,
-  PrecedesEqual: PrecedesEqual,
-  PrecedesSlantEqual: PrecedesSlantEqual,
-  PrecedesTilde: PrecedesTilde,
-  Prime: Prime,
-  Product: Product,
-  Proportion: Proportion,
-  Proportional: Proportional,
-  Pscr: Pscr,
-  Psi: Psi,
-  QUO: QUO,
-  QUOT: QUOT$1,
-  Qfr: Qfr,
-  Qopf: Qopf,
-  Qscr: Qscr,
-  RBarr: RBarr,
-  RE: RE,
-  REG: REG$1,
-  Racute: Racute,
-  Rang: Rang,
-  Rarr: Rarr,
-  Rarrtl: Rarrtl,
-  Rcaron: Rcaron,
-  Rcedil: Rcedil,
-  Rcy: Rcy,
-  Re: Re,
-  ReverseElement: ReverseElement,
-  ReverseEquilibrium: ReverseEquilibrium,
-  ReverseUpEquilibrium: ReverseUpEquilibrium,
-  Rfr: Rfr,
-  Rho: Rho,
-  RightAngleBracket: RightAngleBracket,
-  RightArrow: RightArrow,
-  RightArrowBar: RightArrowBar,
-  RightArrowLeftArrow: RightArrowLeftArrow,
-  RightCeiling: RightCeiling,
-  RightDoubleBracket: RightDoubleBracket,
-  RightDownTeeVector: RightDownTeeVector,
-  RightDownVector: RightDownVector,
-  RightDownVectorBar: RightDownVectorBar,
-  RightFloor: RightFloor,
-  RightTee: RightTee,
-  RightTeeArrow: RightTeeArrow,
-  RightTeeVector: RightTeeVector,
-  RightTriangle: RightTriangle,
-  RightTriangleBar: RightTriangleBar,
-  RightTriangleEqual: RightTriangleEqual,
-  RightUpDownVector: RightUpDownVector,
-  RightUpTeeVector: RightUpTeeVector,
-  RightUpVector: RightUpVector,
-  RightUpVectorBar: RightUpVectorBar,
-  RightVector: RightVector,
-  RightVectorBar: RightVectorBar,
-  Rightarrow: Rightarrow,
-  Ropf: Ropf,
-  RoundImplies: RoundImplies,
-  Rrightarrow: Rrightarrow,
-  Rscr: Rscr,
-  Rsh: Rsh,
-  RuleDelayed: RuleDelayed,
-  SHCHcy: SHCHcy,
-  SHcy: SHcy,
-  SOFTcy: SOFTcy,
-  Sacute: Sacute,
-  Sc: Sc,
-  Scaron: Scaron,
-  Scedil: Scedil,
-  Scirc: Scirc,
-  Scy: Scy,
-  Sfr: Sfr,
-  ShortDownArrow: ShortDownArrow,
-  ShortLeftArrow: ShortLeftArrow,
-  ShortRightArrow: ShortRightArrow,
-  ShortUpArrow: ShortUpArrow,
-  Sigma: Sigma,
-  SmallCircle: SmallCircle,
-  Sopf: Sopf,
-  Sqrt: Sqrt,
-  Square: Square,
-  SquareIntersection: SquareIntersection,
-  SquareSubset: SquareSubset,
-  SquareSubsetEqual: SquareSubsetEqual,
-  SquareSuperset: SquareSuperset,
-  SquareSupersetEqual: SquareSupersetEqual,
-  SquareUnion: SquareUnion,
-  Sscr: Sscr,
-  Star: Star,
-  Sub: Sub,
-  Subset: Subset,
-  SubsetEqual: SubsetEqual,
-  Succeeds: Succeeds,
-  SucceedsEqual: SucceedsEqual,
-  SucceedsSlantEqual: SucceedsSlantEqual,
-  SucceedsTilde: SucceedsTilde,
-  SuchThat: SuchThat,
-  Sum: Sum,
-  Sup: Sup,
-  Superset: Superset,
-  SupersetEqual: SupersetEqual,
-  Supset: Supset,
-  THOR: THOR,
-  THORN: THORN$1,
-  TRADE: TRADE,
-  TSHcy: TSHcy,
-  TScy: TScy,
-  Tab: Tab,
-  Tau: Tau,
-  Tcaron: Tcaron,
-  Tcedil: Tcedil,
-  Tcy: Tcy,
-  Tfr: Tfr,
-  Therefore: Therefore,
-  Theta: Theta,
-  ThickSpace: ThickSpace,
-  ThinSpace: ThinSpace,
-  Tilde: Tilde,
-  TildeEqual: TildeEqual,
-  TildeFullEqual: TildeFullEqual,
-  TildeTilde: TildeTilde,
-  Topf: Topf,
-  TripleDot: TripleDot,
-  Tscr: Tscr,
-  Tstrok: Tstrok,
-  Uacut: Uacut,
-  Uacute: Uacute$1,
-  Uarr: Uarr,
-  Uarrocir: Uarrocir,
-  Ubrcy: Ubrcy,
-  Ubreve: Ubreve,
-  Ucir: Ucir,
-  Ucirc: Ucirc$1,
-  Ucy: Ucy,
-  Udblac: Udblac,
-  Ufr: Ufr,
-  Ugrav: Ugrav,
-  Ugrave: Ugrave$1,
-  Umacr: Umacr,
-  UnderBar: UnderBar,
-  UnderBrace: UnderBrace,
-  UnderBracket: UnderBracket,
-  UnderParenthesis: UnderParenthesis,
-  Union: Union,
-  UnionPlus: UnionPlus,
-  Uogon: Uogon,
-  Uopf: Uopf,
-  UpArrow: UpArrow,
-  UpArrowBar: UpArrowBar,
-  UpArrowDownArrow: UpArrowDownArrow,
-  UpDownArrow: UpDownArrow,
-  UpEquilibrium: UpEquilibrium,
-  UpTee: UpTee,
-  UpTeeArrow: UpTeeArrow,
-  Uparrow: Uparrow,
-  Updownarrow: Updownarrow,
-  UpperLeftArrow: UpperLeftArrow,
-  UpperRightArrow: UpperRightArrow,
-  Upsi: Upsi,
-  Upsilon: Upsilon,
-  Uring: Uring,
-  Uscr: Uscr,
-  Utilde: Utilde,
-  Uum: Uum,
-  Uuml: Uuml$1,
-  VDash: VDash,
-  Vbar: Vbar,
-  Vcy: Vcy,
-  Vdash: Vdash,
-  Vdashl: Vdashl,
-  Vee: Vee,
-  Verbar: Verbar,
-  Vert: Vert,
-  VerticalBar: VerticalBar,
-  VerticalLine: VerticalLine,
-  VerticalSeparator: VerticalSeparator,
-  VerticalTilde: VerticalTilde,
-  VeryThinSpace: VeryThinSpace,
-  Vfr: Vfr,
-  Vopf: Vopf,
-  Vscr: Vscr,
-  Vvdash: Vvdash,
-  Wcirc: Wcirc,
-  Wedge: Wedge,
-  Wfr: Wfr,
-  Wopf: Wopf,
-  Wscr: Wscr,
-  Xfr: Xfr,
-  Xi: Xi,
-  Xopf: Xopf,
-  Xscr: Xscr,
-  YAcy: YAcy,
-  YIcy: YIcy,
-  YUcy: YUcy,
-  Yacut: Yacut,
-  Yacute: Yacute$1,
-  Ycirc: Ycirc,
-  Ycy: Ycy,
-  Yfr: Yfr,
-  Yopf: Yopf,
-  Yscr: Yscr,
-  Yuml: Yuml,
-  ZHcy: ZHcy,
-  Zacute: Zacute,
-  Zcaron: Zcaron,
-  Zcy: Zcy,
-  Zdot: Zdot,
-  ZeroWidthSpace: ZeroWidthSpace,
-  Zeta: Zeta,
-  Zfr: Zfr,
-  Zopf: Zopf,
-  Zscr: Zscr,
-  aacut: aacut,
-  aacute: aacute$1,
-  abreve: abreve,
-  ac: ac,
-  acE: acE,
-  acd: acd,
-  acir: acir,
-  acirc: acirc$1,
-  acut: acut,
-  acute: acute$1,
-  acy: acy,
-  aeli: aeli,
-  aelig: aelig$1,
-  af: af,
-  afr: afr,
-  agrav: agrav,
-  agrave: agrave$1,
-  alefsym: alefsym,
-  aleph: aleph,
-  alpha: alpha,
-  amacr: amacr,
-  amalg: amalg,
-  am: am,
-  amp: amp$1,
-  and: and,
-  andand: andand,
-  andd: andd,
-  andslope: andslope,
-  andv: andv,
-  ang: ang,
-  ange: ange,
-  angle: angle,
-  angmsd: angmsd,
-  angmsdaa: angmsdaa,
-  angmsdab: angmsdab,
-  angmsdac: angmsdac,
-  angmsdad: angmsdad,
-  angmsdae: angmsdae,
-  angmsdaf: angmsdaf,
-  angmsdag: angmsdag,
-  angmsdah: angmsdah,
-  angrt: angrt,
-  angrtvb: angrtvb,
-  angrtvbd: angrtvbd,
-  angsph: angsph,
-  angst: angst,
-  angzarr: angzarr,
-  aogon: aogon,
-  aopf: aopf,
-  ap: ap,
-  apE: apE,
-  apacir: apacir,
-  ape: ape,
-  apid: apid,
-  apos: apos,
-  approx: approx,
-  approxeq: approxeq,
-  arin: arin,
-  aring: aring$1,
-  ascr: ascr,
-  ast: ast,
-  asymp: asymp,
-  asympeq: asympeq,
-  atild: atild,
-  atilde: atilde$1,
-  aum: aum,
-  auml: auml$1,
-  awconint: awconint,
-  awint: awint,
-  bNot: bNot,
-  backcong: backcong,
-  backepsilon: backepsilon,
-  backprime: backprime,
-  backsim: backsim,
-  backsimeq: backsimeq,
-  barvee: barvee,
-  barwed: barwed,
-  barwedge: barwedge,
-  bbrk: bbrk,
-  bbrktbrk: bbrktbrk,
-  bcong: bcong,
-  bcy: bcy,
-  bdquo: bdquo,
-  becaus: becaus,
-  because: because,
-  bemptyv: bemptyv,
-  bepsi: bepsi,
-  bernou: bernou,
-  beta: beta,
-  beth: beth,
-  between: between,
-  bfr: bfr,
-  bigcap: bigcap,
-  bigcirc: bigcirc,
-  bigcup: bigcup,
-  bigodot: bigodot,
-  bigoplus: bigoplus,
-  bigotimes: bigotimes,
-  bigsqcup: bigsqcup,
-  bigstar: bigstar,
-  bigtriangledown: bigtriangledown,
-  bigtriangleup: bigtriangleup,
-  biguplus: biguplus,
-  bigvee: bigvee,
-  bigwedge: bigwedge,
-  bkarow: bkarow,
-  blacklozenge: blacklozenge,
-  blacksquare: blacksquare,
-  blacktriangle: blacktriangle,
-  blacktriangledown: blacktriangledown,
-  blacktriangleleft: blacktriangleleft,
-  blacktriangleright: blacktriangleright,
-  blank: blank,
-  blk12: blk12,
-  blk14: blk14,
-  blk34: blk34,
-  block: block,
-  bne: bne,
-  bnequiv: bnequiv,
-  bnot: bnot,
-  bopf: bopf,
-  bot: bot,
-  bottom: bottom,
-  bowtie: bowtie,
-  boxDL: boxDL,
-  boxDR: boxDR,
-  boxDl: boxDl,
-  boxDr: boxDr,
-  boxH: boxH,
-  boxHD: boxHD,
-  boxHU: boxHU,
-  boxHd: boxHd,
-  boxHu: boxHu,
-  boxUL: boxUL,
-  boxUR: boxUR,
-  boxUl: boxUl,
-  boxUr: boxUr,
-  boxV: boxV,
-  boxVH: boxVH,
-  boxVL: boxVL,
-  boxVR: boxVR,
-  boxVh: boxVh,
-  boxVl: boxVl,
-  boxVr: boxVr,
-  boxbox: boxbox,
-  boxdL: boxdL,
-  boxdR: boxdR,
-  boxdl: boxdl,
-  boxdr: boxdr,
-  boxh: boxh,
-  boxhD: boxhD,
-  boxhU: boxhU,
-  boxhd: boxhd,
-  boxhu: boxhu,
-  boxminus: boxminus,
-  boxplus: boxplus,
-  boxtimes: boxtimes,
-  boxuL: boxuL,
-  boxuR: boxuR,
-  boxul: boxul,
-  boxur: boxur,
-  boxv: boxv,
-  boxvH: boxvH,
-  boxvL: boxvL,
-  boxvR: boxvR,
-  boxvh: boxvh,
-  boxvl: boxvl,
-  boxvr: boxvr,
-  bprime: bprime,
-  breve: breve,
-  brvba: brvba,
-  brvbar: brvbar$1,
-  bscr: bscr,
-  bsemi: bsemi,
-  bsim: bsim,
-  bsime: bsime,
-  bsol: bsol,
-  bsolb: bsolb,
-  bsolhsub: bsolhsub,
-  bull: bull,
-  bullet: bullet,
-  bump: bump,
-  bumpE: bumpE,
-  bumpe: bumpe,
-  bumpeq: bumpeq,
-  cacute: cacute,
-  cap: cap,
-  capand: capand,
-  capbrcup: capbrcup,
-  capcap: capcap,
-  capcup: capcup,
-  capdot: capdot,
-  caps: caps,
-  caret: caret,
-  caron: caron,
-  ccaps: ccaps,
-  ccaron: ccaron,
-  ccedi: ccedi,
-  ccedil: ccedil$1,
-  ccirc: ccirc,
-  ccups: ccups,
-  ccupssm: ccupssm,
-  cdot: cdot,
-  cedi: cedi,
-  cedil: cedil$1,
-  cemptyv: cemptyv,
-  cen: cen,
-  cent: cent$1,
-  centerdot: centerdot,
-  cfr: cfr,
-  chcy: chcy,
-  check: check$2,
-  checkmark: checkmark,
-  chi: chi,
-  cir: cir,
-  cirE: cirE,
-  circ: circ,
-  circeq: circeq,
-  circlearrowleft: circlearrowleft,
-  circlearrowright: circlearrowright,
-  circledR: circledR,
-  circledS: circledS,
-  circledast: circledast,
-  circledcirc: circledcirc,
-  circleddash: circleddash,
-  cire: cire,
-  cirfnint: cirfnint,
-  cirmid: cirmid,
-  cirscir: cirscir,
-  clubs: clubs,
-  clubsuit: clubsuit,
-  colon: colon,
-  colone: colone,
-  coloneq: coloneq,
-  comma: comma,
-  commat: commat,
-  comp: comp,
-  compfn: compfn,
-  complement: complement,
-  complexes: complexes,
-  cong: cong,
-  congdot: congdot,
-  conint: conint,
-  copf: copf,
-  coprod: coprod,
-  cop: cop,
-  copy: copy$2,
-  copysr: copysr,
-  crarr: crarr,
-  cross: cross,
-  cscr: cscr,
-  csub: csub,
-  csube: csube,
-  csup: csup,
-  csupe: csupe,
-  ctdot: ctdot,
-  cudarrl: cudarrl,
-  cudarrr: cudarrr,
-  cuepr: cuepr,
-  cuesc: cuesc,
-  cularr: cularr,
-  cularrp: cularrp,
-  cup: cup,
-  cupbrcap: cupbrcap,
-  cupcap: cupcap,
-  cupcup: cupcup,
-  cupdot: cupdot,
-  cupor: cupor,
-  cups: cups,
-  curarr: curarr,
-  curarrm: curarrm,
-  curlyeqprec: curlyeqprec,
-  curlyeqsucc: curlyeqsucc,
-  curlyvee: curlyvee,
-  curlywedge: curlywedge,
-  curre: curre,
-  curren: curren$1,
-  curvearrowleft: curvearrowleft,
-  curvearrowright: curvearrowright,
-  cuvee: cuvee,
-  cuwed: cuwed,
-  cwconint: cwconint,
-  cwint: cwint,
-  cylcty: cylcty,
-  dArr: dArr,
-  dHar: dHar,
-  dagger: dagger,
-  daleth: daleth,
-  darr: darr,
-  dash: dash,
-  dashv: dashv,
-  dbkarow: dbkarow,
-  dblac: dblac,
-  dcaron: dcaron,
-  dcy: dcy,
-  dd: dd,
-  ddagger: ddagger,
-  ddarr: ddarr,
-  ddotseq: ddotseq,
-  de: de,
-  deg: deg$1,
-  delta: delta,
-  demptyv: demptyv,
-  dfisht: dfisht,
-  dfr: dfr,
-  dharl: dharl,
-  dharr: dharr,
-  diam: diam,
-  diamond: diamond,
-  diamondsuit: diamondsuit,
-  diams: diams,
-  die: die,
-  digamma: digamma,
-  disin: disin,
-  div: div,
-  divid: divid,
-  divide: divide$1,
-  divideontimes: divideontimes,
-  divonx: divonx,
-  djcy: djcy,
-  dlcorn: dlcorn,
-  dlcrop: dlcrop,
-  dollar: dollar,
-  dopf: dopf,
-  dot: dot,
-  doteq: doteq,
-  doteqdot: doteqdot,
-  dotminus: dotminus,
-  dotplus: dotplus,
-  dotsquare: dotsquare,
-  doublebarwedge: doublebarwedge,
-  downarrow: downarrow,
-  downdownarrows: downdownarrows,
-  downharpoonleft: downharpoonleft,
-  downharpoonright: downharpoonright,
-  drbkarow: drbkarow,
-  drcorn: drcorn,
-  drcrop: drcrop,
-  dscr: dscr,
-  dscy: dscy,
-  dsol: dsol,
-  dstrok: dstrok,
-  dtdot: dtdot,
-  dtri: dtri,
-  dtrif: dtrif,
-  duarr: duarr,
-  duhar: duhar,
-  dwangle: dwangle,
-  dzcy: dzcy,
-  dzigrarr: dzigrarr,
-  eDDot: eDDot,
-  eDot: eDot,
-  eacut: eacut,
-  eacute: eacute$1,
-  easter: easter,
-  ecaron: ecaron,
-  ecir: ecir,
-  ecirc: ecirc$1,
-  ecolon: ecolon,
-  ecy: ecy,
-  edot: edot,
-  ee: ee,
-  efDot: efDot,
-  efr: efr,
-  eg: eg,
-  egrav: egrav,
-  egrave: egrave$1,
-  egs: egs,
-  egsdot: egsdot,
-  el: el,
-  elinters: elinters,
-  ell: ell,
-  els: els,
-  elsdot: elsdot,
-  emacr: emacr,
-  empty: empty,
-  emptyset: emptyset,
-  emptyv: emptyv,
-  emsp13: emsp13,
-  emsp14: emsp14,
-  emsp: emsp,
-  eng: eng,
-  ensp: ensp,
-  eogon: eogon,
-  eopf: eopf,
-  epar: epar,
-  eparsl: eparsl,
-  eplus: eplus,
-  epsi: epsi,
-  epsilon: epsilon,
-  epsiv: epsiv,
-  eqcirc: eqcirc,
-  eqcolon: eqcolon,
-  eqsim: eqsim,
-  eqslantgtr: eqslantgtr,
-  eqslantless: eqslantless,
-  equals: equals,
-  equest: equest,
-  equiv: equiv,
-  equivDD: equivDD,
-  eqvparsl: eqvparsl,
-  erDot: erDot,
-  erarr: erarr,
-  escr: escr,
-  esdot: esdot,
-  esim: esim,
-  eta: eta,
-  et: et,
-  eth: eth$1,
-  eum: eum,
-  euml: euml$1,
-  euro: euro,
-  excl: excl,
-  exist: exist,
-  expectation: expectation,
-  exponentiale: exponentiale,
-  fallingdotseq: fallingdotseq,
-  fcy: fcy,
-  female: female,
-  ffilig: ffilig,
-  fflig: fflig,
-  ffllig: ffllig,
-  ffr: ffr,
-  filig: filig,
-  fjlig: fjlig,
-  flat: flat,
-  fllig: fllig,
-  fltns: fltns,
-  fnof: fnof,
-  fopf: fopf,
-  forall: forall,
-  fork: fork,
-  forkv: forkv,
-  fpartint: fpartint,
-  frac1: frac1,
-  frac12: frac12$1,
-  frac13: frac13,
-  frac14: frac14$1,
-  frac15: frac15,
-  frac16: frac16,
-  frac18: frac18,
-  frac23: frac23,
-  frac25: frac25,
-  frac3: frac3,
-  frac34: frac34$1,
-  frac35: frac35,
-  frac38: frac38,
-  frac45: frac45,
-  frac56: frac56,
-  frac58: frac58,
-  frac78: frac78,
-  frasl: frasl,
-  frown: frown,
-  fscr: fscr,
-  gE: gE,
-  gEl: gEl,
-  gacute: gacute,
-  gamma: gamma,
-  gammad: gammad,
-  gap: gap,
-  gbreve: gbreve,
-  gcirc: gcirc,
-  gcy: gcy,
-  gdot: gdot,
-  ge: ge,
-  gel: gel,
-  geq: geq,
-  geqq: geqq,
-  geqslant: geqslant,
-  ges: ges,
-  gescc: gescc,
-  gesdot: gesdot,
-  gesdoto: gesdoto,
-  gesdotol: gesdotol,
-  gesl: gesl,
-  gesles: gesles,
-  gfr: gfr,
-  gg: gg,
-  ggg: ggg,
-  gimel: gimel,
-  gjcy: gjcy,
-  gl: gl,
-  glE: glE,
-  gla: gla,
-  glj: glj,
-  gnE: gnE,
-  gnap: gnap,
-  gnapprox: gnapprox,
-  gne: gne,
-  gneq: gneq,
-  gneqq: gneqq,
-  gnsim: gnsim,
-  gopf: gopf,
-  grave: grave,
-  gscr: gscr,
-  gsim: gsim,
-  gsime: gsime,
-  gsiml: gsiml,
-  g: g,
-  gt: gt$1,
-  gtcc: gtcc,
-  gtcir: gtcir,
-  gtdot: gtdot,
-  gtlPar: gtlPar,
-  gtquest: gtquest,
-  gtrapprox: gtrapprox,
-  gtrarr: gtrarr,
-  gtrdot: gtrdot,
-  gtreqless: gtreqless,
-  gtreqqless: gtreqqless,
-  gtrless: gtrless,
-  gtrsim: gtrsim,
-  gvertneqq: gvertneqq,
-  gvnE: gvnE,
-  hArr: hArr,
-  hairsp: hairsp,
-  half: half,
-  hamilt: hamilt,
-  hardcy: hardcy,
-  harr: harr,
-  harrcir: harrcir,
-  harrw: harrw,
-  hbar: hbar,
-  hcirc: hcirc,
-  hearts: hearts,
-  heartsuit: heartsuit,
-  hellip: hellip,
-  hercon: hercon,
-  hfr: hfr,
-  hksearow: hksearow,
-  hkswarow: hkswarow,
-  hoarr: hoarr,
-  homtht: homtht,
-  hookleftarrow: hookleftarrow,
-  hookrightarrow: hookrightarrow,
-  hopf: hopf,
-  horbar: horbar,
-  hscr: hscr,
-  hslash: hslash,
-  hstrok: hstrok,
-  hybull: hybull,
-  hyphen: hyphen,
-  iacut: iacut,
-  iacute: iacute$1,
-  ic: ic,
-  icir: icir,
-  icirc: icirc$1,
-  icy: icy,
-  iecy: iecy,
-  iexc: iexc,
-  iexcl: iexcl$1,
-  iff: iff,
-  ifr: ifr,
-  igrav: igrav,
-  igrave: igrave$1,
-  ii: ii,
-  iiiint: iiiint,
-  iiint: iiint,
-  iinfin: iinfin,
-  iiota: iiota,
-  ijlig: ijlig,
-  imacr: imacr,
-  image: image,
-  imagline: imagline,
-  imagpart: imagpart,
-  imath: imath,
-  imof: imof,
-  imped: imped,
-  incare: incare,
-  infin: infin,
-  infintie: infintie,
-  inodot: inodot,
-  int: int,
-  intcal: intcal,
-  integers: integers,
-  intercal: intercal,
-  intlarhk: intlarhk,
-  intprod: intprod,
-  iocy: iocy,
-  iogon: iogon,
-  iopf: iopf,
-  iota: iota,
-  iprod: iprod,
-  iques: iques,
-  iquest: iquest$1,
-  iscr: iscr,
-  isin: isin,
-  isinE: isinE,
-  isindot: isindot,
-  isins: isins,
-  isinsv: isinsv,
-  isinv: isinv,
-  it: it,
-  itilde: itilde,
-  iukcy: iukcy,
-  ium: ium,
-  iuml: iuml$1,
-  jcirc: jcirc,
-  jcy: jcy,
-  jfr: jfr,
-  jmath: jmath,
-  jopf: jopf,
-  jscr: jscr,
-  jsercy: jsercy,
-  jukcy: jukcy,
-  kappa: kappa,
-  kappav: kappav,
-  kcedil: kcedil,
-  kcy: kcy,
-  kfr: kfr,
-  kgreen: kgreen,
-  khcy: khcy,
-  kjcy: kjcy,
-  kopf: kopf,
-  kscr: kscr,
-  lAarr: lAarr,
-  lArr: lArr,
-  lAtail: lAtail,
-  lBarr: lBarr,
-  lE: lE,
-  lEg: lEg,
-  lHar: lHar,
-  lacute: lacute,
-  laemptyv: laemptyv,
-  lagran: lagran,
-  lambda: lambda,
-  lang: lang,
-  langd: langd,
-  langle: langle,
-  lap: lap,
-  laqu: laqu,
-  laquo: laquo$1,
-  larr: larr,
-  larrb: larrb,
-  larrbfs: larrbfs,
-  larrfs: larrfs,
-  larrhk: larrhk,
-  larrlp: larrlp,
-  larrpl: larrpl,
-  larrsim: larrsim,
-  larrtl: larrtl,
-  lat: lat,
-  latail: latail,
-  late: late,
-  lates: lates,
-  lbarr: lbarr,
-  lbbrk: lbbrk,
-  lbrace: lbrace,
-  lbrack: lbrack,
-  lbrke: lbrke,
-  lbrksld: lbrksld,
-  lbrkslu: lbrkslu,
-  lcaron: lcaron,
-  lcedil: lcedil,
-  lceil: lceil,
-  lcub: lcub,
-  lcy: lcy,
-  ldca: ldca,
-  ldquo: ldquo,
-  ldquor: ldquor,
-  ldrdhar: ldrdhar,
-  ldrushar: ldrushar,
-  ldsh: ldsh,
-  le: le,
-  leftarrow: leftarrow,
-  leftarrowtail: leftarrowtail,
-  leftharpoondown: leftharpoondown,
-  leftharpoonup: leftharpoonup,
-  leftleftarrows: leftleftarrows,
-  leftrightarrow: leftrightarrow,
-  leftrightarrows: leftrightarrows,
-  leftrightharpoons: leftrightharpoons,
-  leftrightsquigarrow: leftrightsquigarrow,
-  leftthreetimes: leftthreetimes,
-  leg: leg,
-  leq: leq,
-  leqq: leqq,
-  leqslant: leqslant,
-  les: les,
-  lescc: lescc,
-  lesdot: lesdot,
-  lesdoto: lesdoto,
-  lesdotor: lesdotor,
-  lesg: lesg,
-  lesges: lesges,
-  lessapprox: lessapprox,
-  lessdot: lessdot,
-  lesseqgtr: lesseqgtr,
-  lesseqqgtr: lesseqqgtr,
-  lessgtr: lessgtr,
-  lesssim: lesssim,
-  lfisht: lfisht,
-  lfloor: lfloor,
-  lfr: lfr,
-  lg: lg,
-  lgE: lgE,
-  lhard: lhard,
-  lharu: lharu,
-  lharul: lharul,
-  lhblk: lhblk,
-  ljcy: ljcy,
-  ll: ll,
-  llarr: llarr,
-  llcorner: llcorner,
-  llhard: llhard,
-  lltri: lltri,
-  lmidot: lmidot,
-  lmoust: lmoust,
-  lmoustache: lmoustache,
-  lnE: lnE,
-  lnap: lnap,
-  lnapprox: lnapprox,
-  lne: lne,
-  lneq: lneq,
-  lneqq: lneqq,
-  lnsim: lnsim,
-  loang: loang,
-  loarr: loarr,
-  lobrk: lobrk,
-  longleftarrow: longleftarrow,
-  longleftrightarrow: longleftrightarrow,
-  longmapsto: longmapsto,
-  longrightarrow: longrightarrow,
-  looparrowleft: looparrowleft,
-  looparrowright: looparrowright,
-  lopar: lopar,
-  lopf: lopf,
-  loplus: loplus,
-  lotimes: lotimes,
-  lowast: lowast,
-  lowbar: lowbar,
-  loz: loz,
-  lozenge: lozenge,
-  lozf: lozf,
-  lpar: lpar,
-  lparlt: lparlt,
-  lrarr: lrarr,
-  lrcorner: lrcorner,
-  lrhar: lrhar,
-  lrhard: lrhard,
-  lrm: lrm,
-  lrtri: lrtri,
-  lsaquo: lsaquo,
-  lscr: lscr,
-  lsh: lsh,
-  lsim: lsim,
-  lsime: lsime,
-  lsimg: lsimg,
-  lsqb: lsqb,
-  lsquo: lsquo,
-  lsquor: lsquor,
-  lstrok: lstrok,
-  l: l,
-  lt: lt$1,
-  ltcc: ltcc,
-  ltcir: ltcir,
-  ltdot: ltdot,
-  lthree: lthree,
-  ltimes: ltimes,
-  ltlarr: ltlarr,
-  ltquest: ltquest,
-  ltrPar: ltrPar,
-  ltri: ltri,
-  ltrie: ltrie,
-  ltrif: ltrif,
-  lurdshar: lurdshar,
-  luruhar: luruhar,
-  lvertneqq: lvertneqq,
-  lvnE: lvnE,
-  mDDot: mDDot,
-  mac: mac,
-  macr: macr$1,
-  male: male,
-  malt: malt,
-  maltese: maltese,
-  map: map$2,
-  mapsto: mapsto,
-  mapstodown: mapstodown,
-  mapstoleft: mapstoleft,
-  mapstoup: mapstoup,
-  marker: marker,
-  mcomma: mcomma,
-  mcy: mcy,
-  mdash: mdash,
-  measuredangle: measuredangle,
-  mfr: mfr,
-  mho: mho,
-  micr: micr,
-  micro: micro$1,
-  mid: mid,
-  midast: midast,
-  midcir: midcir,
-  middo: middo,
-  middot: middot$1,
-  minus: minus,
-  minusb: minusb,
-  minusd: minusd,
-  minusdu: minusdu,
-  mlcp: mlcp,
-  mldr: mldr,
-  mnplus: mnplus,
-  models: models$2,
-  mopf: mopf,
-  mp: mp,
-  mscr: mscr,
-  mstpos: mstpos,
-  mu: mu,
-  multimap: multimap,
-  mumap: mumap,
-  nGg: nGg,
-  nGt: nGt,
-  nGtv: nGtv,
-  nLeftarrow: nLeftarrow,
-  nLeftrightarrow: nLeftrightarrow,
-  nLl: nLl,
-  nLt: nLt,
-  nLtv: nLtv,
-  nRightarrow: nRightarrow,
-  nVDash: nVDash,
-  nVdash: nVdash,
-  nabla: nabla,
-  nacute: nacute,
-  nang: nang,
-  nap: nap,
-  napE: napE,
-  napid: napid,
-  napos: napos,
-  napprox: napprox,
-  natur: natur,
-  natural: natural,
-  naturals: naturals,
-  nbs: nbs,
-  nbsp: nbsp$1,
-  nbump: nbump,
-  nbumpe: nbumpe,
-  ncap: ncap,
-  ncaron: ncaron,
-  ncedil: ncedil,
-  ncong: ncong,
-  ncongdot: ncongdot,
-  ncup: ncup,
-  ncy: ncy,
-  ndash: ndash,
-  ne: ne,
-  neArr: neArr,
-  nearhk: nearhk,
-  nearr: nearr,
-  nearrow: nearrow,
-  nedot: nedot,
-  nequiv: nequiv,
-  nesear: nesear,
-  nesim: nesim,
-  nexist: nexist,
-  nexists: nexists,
-  nfr: nfr,
-  ngE: ngE,
-  nge: nge,
-  ngeq: ngeq,
-  ngeqq: ngeqq,
-  ngeqslant: ngeqslant,
-  nges: nges,
-  ngsim: ngsim,
-  ngt: ngt,
-  ngtr: ngtr,
-  nhArr: nhArr,
-  nharr: nharr,
-  nhpar: nhpar,
-  ni: ni,
-  nis: nis,
-  nisd: nisd,
-  niv: niv,
-  njcy: njcy,
-  nlArr: nlArr,
-  nlE: nlE,
-  nlarr: nlarr,
-  nldr: nldr,
-  nle: nle,
-  nleftarrow: nleftarrow,
-  nleftrightarrow: nleftrightarrow,
-  nleq: nleq,
-  nleqq: nleqq,
-  nleqslant: nleqslant,
-  nles: nles,
-  nless: nless,
-  nlsim: nlsim,
-  nlt: nlt,
-  nltri: nltri,
-  nltrie: nltrie,
-  nmid: nmid,
-  nopf: nopf,
-  no: no,
-  not: not$1,
-  notin: notin,
-  notinE: notinE,
-  notindot: notindot,
-  notinva: notinva,
-  notinvb: notinvb,
-  notinvc: notinvc,
-  notni: notni,
-  notniva: notniva,
-  notnivb: notnivb,
-  notnivc: notnivc,
-  npar: npar,
-  nparallel: nparallel,
-  nparsl: nparsl,
-  npart: npart,
-  npolint: npolint,
-  npr: npr,
-  nprcue: nprcue,
-  npre: npre,
-  nprec: nprec,
-  npreceq: npreceq,
-  nrArr: nrArr,
-  nrarr: nrarr,
-  nrarrc: nrarrc,
-  nrarrw: nrarrw,
-  nrightarrow: nrightarrow,
-  nrtri: nrtri,
-  nrtrie: nrtrie,
-  nsc: nsc,
-  nsccue: nsccue,
-  nsce: nsce,
-  nscr: nscr,
-  nshortmid: nshortmid,
-  nshortparallel: nshortparallel,
-  nsim: nsim,
-  nsime: nsime,
-  nsimeq: nsimeq,
-  nsmid: nsmid,
-  nspar: nspar,
-  nsqsube: nsqsube,
-  nsqsupe: nsqsupe,
-  nsub: nsub,
-  nsubE: nsubE,
-  nsube: nsube,
-  nsubset: nsubset,
-  nsubseteq: nsubseteq,
-  nsubseteqq: nsubseteqq,
-  nsucc: nsucc,
-  nsucceq: nsucceq,
-  nsup: nsup,
-  nsupE: nsupE,
-  nsupe: nsupe,
-  nsupset: nsupset,
-  nsupseteq: nsupseteq,
-  nsupseteqq: nsupseteqq,
-  ntgl: ntgl,
-  ntild: ntild,
-  ntilde: ntilde$1,
-  ntlg: ntlg,
-  ntriangleleft: ntriangleleft,
-  ntrianglelefteq: ntrianglelefteq,
-  ntriangleright: ntriangleright,
-  ntrianglerighteq: ntrianglerighteq,
-  nu: nu,
-  num: num,
-  numero: numero,
-  numsp: numsp,
-  nvDash: nvDash,
-  nvHarr: nvHarr,
-  nvap: nvap,
-  nvdash: nvdash,
-  nvge: nvge,
-  nvgt: nvgt,
-  nvinfin: nvinfin,
-  nvlArr: nvlArr,
-  nvle: nvle,
-  nvlt: nvlt,
-  nvltrie: nvltrie,
-  nvrArr: nvrArr,
-  nvrtrie: nvrtrie,
-  nvsim: nvsim,
-  nwArr: nwArr,
-  nwarhk: nwarhk,
-  nwarr: nwarr,
-  nwarrow: nwarrow,
-  nwnear: nwnear,
-  oS: oS,
-  oacut: oacut,
-  oacute: oacute$1,
-  oast: oast,
-  ocir: ocir,
-  ocirc: ocirc$1,
-  ocy: ocy,
-  odash: odash,
-  odblac: odblac,
-  odiv: odiv,
-  odot: odot,
-  odsold: odsold,
-  oelig: oelig,
-  ofcir: ofcir,
-  ofr: ofr,
-  ogon: ogon,
-  ograv: ograv,
-  ograve: ograve$1,
-  ogt: ogt,
-  ohbar: ohbar,
-  ohm: ohm,
-  oint: oint,
-  olarr: olarr,
-  olcir: olcir,
-  olcross: olcross,
-  oline: oline,
-  olt: olt,
-  omacr: omacr,
-  omega: omega,
-  omicron: omicron,
-  omid: omid,
-  ominus: ominus,
-  oopf: oopf,
-  opar: opar,
-  operp: operp,
-  oplus: oplus,
-  or: or,
-  orarr: orarr,
-  ord: ord,
-  order: order$1,
-  orderof: orderof,
-  ordf: ordf$1,
-  ordm: ordm$1,
-  origof: origof,
-  oror: oror,
-  orslope: orslope,
-  orv: orv,
-  oscr: oscr,
-  oslas: oslas,
-  oslash: oslash$1,
-  osol: osol,
-  otild: otild,
-  otilde: otilde$1,
-  otimes: otimes,
-  otimesas: otimesas,
-  oum: oum,
-  ouml: ouml$1,
-  ovbar: ovbar,
-  par: par,
-  para: para$1,
-  parallel: parallel,
-  parsim: parsim,
-  parsl: parsl,
-  part: part,
-  pcy: pcy,
-  percnt: percnt,
-  period: period,
-  permil: permil,
-  perp: perp,
-  pertenk: pertenk,
-  pfr: pfr,
-  phi: phi,
-  phiv: phiv,
-  phmmat: phmmat,
-  phone: phone,
-  pi: pi,
-  pitchfork: pitchfork,
-  piv: piv,
-  planck: planck,
-  planckh: planckh,
-  plankv: plankv,
-  plus: plus,
-  plusacir: plusacir,
-  plusb: plusb,
-  pluscir: pluscir,
-  plusdo: plusdo,
-  plusdu: plusdu,
-  pluse: pluse,
-  plusm: plusm,
-  plusmn: plusmn$1,
-  plussim: plussim,
-  plustwo: plustwo,
-  pm: pm,
-  pointint: pointint,
-  popf: popf,
-  poun: poun,
-  pound: pound$1,
-  pr: pr,
-  prE: prE,
-  prap: prap,
-  prcue: prcue,
-  pre: pre,
-  prec: prec,
-  precapprox: precapprox,
-  preccurlyeq: preccurlyeq,
-  preceq: preceq,
-  precnapprox: precnapprox,
-  precneqq: precneqq,
-  precnsim: precnsim,
-  precsim: precsim,
-  prime: prime,
-  primes: primes,
-  prnE: prnE,
-  prnap: prnap,
-  prnsim: prnsim,
-  prod: prod,
-  profalar: profalar,
-  profline: profline,
-  profsurf: profsurf,
-  prop: prop,
-  propto: propto,
-  prsim: prsim,
-  prurel: prurel,
-  pscr: pscr,
-  psi: psi,
-  puncsp: puncsp,
-  qfr: qfr,
-  qint: qint,
-  qopf: qopf,
-  qprime: qprime,
-  qscr: qscr,
-  quaternions: quaternions,
-  quatint: quatint,
-  quest: quest,
-  questeq: questeq,
-  quo: quo,
-  quot: quot$1,
-  rAarr: rAarr,
-  rArr: rArr,
-  rAtail: rAtail,
-  rBarr: rBarr,
-  rHar: rHar,
-  race: race,
-  racute: racute,
-  radic: radic,
-  raemptyv: raemptyv,
-  rang: rang,
-  rangd: rangd,
-  range: range$1,
-  rangle: rangle,
-  raqu: raqu,
-  raquo: raquo$1,
-  rarr: rarr,
-  rarrap: rarrap,
-  rarrb: rarrb,
-  rarrbfs: rarrbfs,
-  rarrc: rarrc,
-  rarrfs: rarrfs,
-  rarrhk: rarrhk,
-  rarrlp: rarrlp,
-  rarrpl: rarrpl,
-  rarrsim: rarrsim,
-  rarrtl: rarrtl,
-  rarrw: rarrw,
-  ratail: ratail,
-  ratio: ratio,
-  rationals: rationals,
-  rbarr: rbarr,
-  rbbrk: rbbrk,
-  rbrace: rbrace,
-  rbrack: rbrack,
-  rbrke: rbrke,
-  rbrksld: rbrksld,
-  rbrkslu: rbrkslu,
-  rcaron: rcaron,
-  rcedil: rcedil,
-  rceil: rceil,
-  rcub: rcub,
-  rcy: rcy,
-  rdca: rdca,
-  rdldhar: rdldhar,
-  rdquo: rdquo,
-  rdquor: rdquor,
-  rdsh: rdsh,
-  real: real,
-  realine: realine,
-  realpart: realpart,
-  reals: reals,
-  rect: rect,
-  re: re,
-  reg: reg$1,
-  rfisht: rfisht,
-  rfloor: rfloor,
-  rfr: rfr,
-  rhard: rhard,
-  rharu: rharu,
-  rharul: rharul,
-  rho: rho,
-  rhov: rhov,
-  rightarrow: rightarrow,
-  rightarrowtail: rightarrowtail,
-  rightharpoondown: rightharpoondown,
-  rightharpoonup: rightharpoonup,
-  rightleftarrows: rightleftarrows,
-  rightleftharpoons: rightleftharpoons,
-  rightrightarrows: rightrightarrows,
-  rightsquigarrow: rightsquigarrow,
-  rightthreetimes: rightthreetimes,
-  ring: ring,
-  risingdotseq: risingdotseq,
-  rlarr: rlarr,
-  rlhar: rlhar,
-  rlm: rlm,
-  rmoust: rmoust,
-  rmoustache: rmoustache,
-  rnmid: rnmid,
-  roang: roang,
-  roarr: roarr,
-  robrk: robrk,
-  ropar: ropar,
-  ropf: ropf,
-  roplus: roplus,
-  rotimes: rotimes,
-  rpar: rpar,
-  rpargt: rpargt,
-  rppolint: rppolint,
-  rrarr: rrarr,
-  rsaquo: rsaquo,
-  rscr: rscr,
-  rsh: rsh,
-  rsqb: rsqb,
-  rsquo: rsquo,
-  rsquor: rsquor,
-  rthree: rthree,
-  rtimes: rtimes,
-  rtri: rtri,
-  rtrie: rtrie,
-  rtrif: rtrif,
-  rtriltri: rtriltri,
-  ruluhar: ruluhar,
-  rx: rx,
-  sacute: sacute,
-  sbquo: sbquo,
-  sc: sc,
-  scE: scE,
-  scap: scap,
-  scaron: scaron,
-  sccue: sccue,
-  sce: sce,
-  scedil: scedil,
-  scirc: scirc,
-  scnE: scnE,
-  scnap: scnap,
-  scnsim: scnsim,
-  scpolint: scpolint,
-  scsim: scsim,
-  scy: scy,
-  sdot: sdot,
-  sdotb: sdotb,
-  sdote: sdote,
-  seArr: seArr,
-  searhk: searhk,
-  searr: searr,
-  searrow: searrow,
-  sec: sec,
-  sect: sect$1,
-  semi: semi,
-  seswar: seswar,
-  setminus: setminus,
-  setmn: setmn,
-  sext: sext,
-  sfr: sfr,
-  sfrown: sfrown,
-  sharp: sharp,
-  shchcy: shchcy,
-  shcy: shcy,
-  shortmid: shortmid,
-  shortparallel: shortparallel,
-  sh: sh,
-  shy: shy$1,
-  sigma: sigma,
-  sigmaf: sigmaf,
-  sigmav: sigmav,
-  sim: sim,
-  simdot: simdot,
-  sime: sime,
-  simeq: simeq,
-  simg: simg,
-  simgE: simgE,
-  siml: siml,
-  simlE: simlE,
-  simne: simne,
-  simplus: simplus,
-  simrarr: simrarr,
-  slarr: slarr,
-  smallsetminus: smallsetminus,
-  smashp: smashp,
-  smeparsl: smeparsl,
-  smid: smid,
-  smile: smile,
-  smt: smt,
-  smte: smte,
-  smtes: smtes,
-  softcy: softcy,
-  sol: sol,
-  solb: solb,
-  solbar: solbar,
-  sopf: sopf,
-  spades: spades,
-  spadesuit: spadesuit,
-  spar: spar,
-  sqcap: sqcap,
-  sqcaps: sqcaps,
-  sqcup: sqcup,
-  sqcups: sqcups,
-  sqsub: sqsub,
-  sqsube: sqsube,
-  sqsubset: sqsubset,
-  sqsubseteq: sqsubseteq,
-  sqsup: sqsup,
-  sqsupe: sqsupe,
-  sqsupset: sqsupset,
-  sqsupseteq: sqsupseteq,
-  squ: squ,
-  square: square,
-  squarf: squarf,
-  squf: squf,
-  srarr: srarr,
-  sscr: sscr,
-  ssetmn: ssetmn,
-  ssmile: ssmile,
-  sstarf: sstarf,
-  star: star$1,
-  starf: starf,
-  straightepsilon: straightepsilon,
-  straightphi: straightphi,
-  strns: strns,
-  sub: sub,
-  subE: subE,
-  subdot: subdot,
-  sube: sube,
-  subedot: subedot,
-  submult: submult,
-  subnE: subnE,
-  subne: subne,
-  subplus: subplus,
-  subrarr: subrarr,
-  subset: subset,
-  subseteq: subseteq,
-  subseteqq: subseteqq,
-  subsetneq: subsetneq,
-  subsetneqq: subsetneqq,
-  subsim: subsim,
-  subsub: subsub,
-  subsup: subsup,
-  succ: succ,
-  succapprox: succapprox,
-  succcurlyeq: succcurlyeq,
-  succeq: succeq,
-  succnapprox: succnapprox,
-  succneqq: succneqq,
-  succnsim: succnsim,
-  succsim: succsim,
-  sum: sum,
-  sung: sung,
-  sup: sup,
-  sup1: sup1$1,
-  sup2: sup2$1,
-  sup3: sup3$1,
-  supE: supE,
-  supdot: supdot,
-  supdsub: supdsub,
-  supe: supe,
-  supedot: supedot,
-  suphsol: suphsol,
-  suphsub: suphsub,
-  suplarr: suplarr,
-  supmult: supmult,
-  supnE: supnE,
-  supne: supne,
-  supplus: supplus,
-  supset: supset,
-  supseteq: supseteq,
-  supseteqq: supseteqq,
-  supsetneq: supsetneq,
-  supsetneqq: supsetneqq,
-  supsim: supsim,
-  supsub: supsub,
-  supsup: supsup,
-  swArr: swArr,
-  swarhk: swarhk,
-  swarr: swarr,
-  swarrow: swarrow,
-  swnwar: swnwar,
-  szli: szli,
-  szlig: szlig$1,
-  target: target,
-  tau: tau,
-  tbrk: tbrk,
-  tcaron: tcaron,
-  tcedil: tcedil,
-  tcy: tcy,
-  tdot: tdot,
-  telrec: telrec,
-  tfr: tfr,
-  there4: there4,
-  therefore: therefore,
-  theta: theta,
-  thetasym: thetasym,
-  thetav: thetav,
-  thickapprox: thickapprox,
-  thicksim: thicksim,
-  thinsp: thinsp,
-  thkap: thkap,
-  thksim: thksim,
-  thor: thor,
-  thorn: thorn$1,
-  tilde: tilde,
-  time: time,
-  times: times$1,
-  timesb: timesb,
-  timesbar: timesbar,
-  timesd: timesd,
-  tint: tint,
-  toea: toea,
-  top: top,
-  topbot: topbot,
-  topcir: topcir,
-  topf: topf,
-  topfork: topfork,
-  tosa: tosa,
-  tprime: tprime,
-  trade: trade,
-  triangle: triangle,
-  triangledown: triangledown,
-  triangleleft: triangleleft,
-  trianglelefteq: trianglelefteq,
-  triangleq: triangleq,
-  triangleright: triangleright,
-  trianglerighteq: trianglerighteq,
-  tridot: tridot,
-  trie: trie,
-  triminus: triminus,
-  triplus: triplus,
-  trisb: trisb,
-  tritime: tritime,
-  trpezium: trpezium,
-  tscr: tscr,
-  tscy: tscy,
-  tshcy: tshcy,
-  tstrok: tstrok,
-  twixt: twixt,
-  twoheadleftarrow: twoheadleftarrow,
-  twoheadrightarrow: twoheadrightarrow,
-  uArr: uArr,
-  uHar: uHar,
-  uacut: uacut,
-  uacute: uacute$1,
-  uarr: uarr,
-  ubrcy: ubrcy,
-  ubreve: ubreve,
-  ucir: ucir,
-  ucirc: ucirc$1,
-  ucy: ucy,
-  udarr: udarr,
-  udblac: udblac,
-  udhar: udhar,
-  ufisht: ufisht,
-  ufr: ufr,
-  ugrav: ugrav,
-  ugrave: ugrave$1,
-  uharl: uharl,
-  uharr: uharr,
-  uhblk: uhblk,
-  ulcorn: ulcorn,
-  ulcorner: ulcorner,
-  ulcrop: ulcrop,
-  ultri: ultri,
-  umacr: umacr,
-  um: um,
-  uml: uml$1,
-  uogon: uogon,
-  uopf: uopf,
-  uparrow: uparrow,
-  updownarrow: updownarrow,
-  upharpoonleft: upharpoonleft,
-  upharpoonright: upharpoonright,
-  uplus: uplus,
-  upsi: upsi,
-  upsih: upsih,
-  upsilon: upsilon,
-  upuparrows: upuparrows,
-  urcorn: urcorn,
-  urcorner: urcorner,
-  urcrop: urcrop,
-  uring: uring,
-  urtri: urtri,
-  uscr: uscr,
-  utdot: utdot,
-  utilde: utilde,
-  utri: utri,
-  utrif: utrif,
-  uuarr: uuarr,
-  uum: uum,
-  uuml: uuml$1,
-  uwangle: uwangle,
-  vArr: vArr,
-  vBar: vBar,
-  vBarv: vBarv,
-  vDash: vDash,
-  vangrt: vangrt,
-  varepsilon: varepsilon,
-  varkappa: varkappa,
-  varnothing: varnothing,
-  varphi: varphi,
-  varpi: varpi,
-  varpropto: varpropto,
-  varr: varr,
-  varrho: varrho,
-  varsigma: varsigma,
-  varsubsetneq: varsubsetneq,
-  varsubsetneqq: varsubsetneqq,
-  varsupsetneq: varsupsetneq,
-  varsupsetneqq: varsupsetneqq,
-  vartheta: vartheta,
-  vartriangleleft: vartriangleleft,
-  vartriangleright: vartriangleright,
-  vcy: vcy,
-  vdash: vdash,
-  vee: vee,
-  veebar: veebar,
-  veeeq: veeeq,
-  vellip: vellip,
-  verbar: verbar,
-  vert: vert,
-  vfr: vfr,
-  vltri: vltri,
-  vnsub: vnsub,
-  vnsup: vnsup,
-  vopf: vopf,
-  vprop: vprop,
-  vrtri: vrtri,
-  vscr: vscr,
-  vsubnE: vsubnE,
-  vsubne: vsubne,
-  vsupnE: vsupnE,
-  vsupne: vsupne,
-  vzigzag: vzigzag,
-  wcirc: wcirc,
-  wedbar: wedbar,
-  wedge: wedge,
-  wedgeq: wedgeq,
-  weierp: weierp,
-  wfr: wfr,
-  wopf: wopf,
-  wp: wp,
-  wr: wr,
-  wreath: wreath,
-  wscr: wscr,
-  xcap: xcap,
-  xcirc: xcirc,
-  xcup: xcup,
-  xdtri: xdtri,
-  xfr: xfr,
-  xhArr: xhArr,
-  xharr: xharr,
-  xi: xi,
-  xlArr: xlArr,
-  xlarr: xlarr,
-  xmap: xmap,
-  xnis: xnis,
-  xodot: xodot,
-  xopf: xopf,
-  xoplus: xoplus,
-  xotime: xotime,
-  xrArr: xrArr,
-  xrarr: xrarr,
-  xscr: xscr,
-  xsqcup: xsqcup,
-  xuplus: xuplus,
-  xutri: xutri,
-  xvee: xvee,
-  xwedge: xwedge,
-  yacut: yacut,
-  yacute: yacute$1,
-  yacy: yacy,
-  ycirc: ycirc,
-  ycy: ycy,
-  ye: ye,
-  yen: yen$1,
-  yfr: yfr,
-  yicy: yicy,
-  yopf: yopf,
-  yscr: yscr,
-  yucy: yucy,
-  yum: yum,
-  yuml: yuml$1,
-  zacute: zacute,
-  zcaron: zcaron,
-  zcy: zcy,
-  zdot: zdot,
-  zeetrf: zeetrf,
-  zeta: zeta,
-  zfr: zfr,
-  zhcy: zhcy,
-  zigrarr: zigrarr,
-  zopf: zopf,
-  zscr: zscr,
-  zwj: zwj,
-  zwnj: zwnj,
-  'default': index$3
-});
+    // Set singular and plural references for the word.
+    pluralize.addPluralRule(word, '$0');
+    pluralize.addSingularRule(word, '$0');
+  };
 
-var characterEntities$1 = getCjsExportFromNamespace(characterEntities);
+  /**
+   * Add an irregular word definition.
+   *
+   * @param {string} single
+   * @param {string} plural
+   */
+  pluralize.addIrregularRule = function (single, plural) {
+    plural = plural.toLowerCase();
+    single = single.toLowerCase();
 
-var decodeEntity_1 = decodeEntity;
+    irregularSingles[single] = plural;
+    irregularPlurals[plural] = single;
+  };
 
-var own$3 = {}.hasOwnProperty;
+  /**
+   * Irregular rules.
+   */
+  [
+    // Pronouns.
+    ['I', 'we'],
+    ['me', 'us'],
+    ['he', 'they'],
+    ['she', 'they'],
+    ['them', 'them'],
+    ['myself', 'ourselves'],
+    ['yourself', 'yourselves'],
+    ['itself', 'themselves'],
+    ['herself', 'themselves'],
+    ['himself', 'themselves'],
+    ['themself', 'themselves'],
+    ['is', 'are'],
+    ['was', 'were'],
+    ['has', 'have'],
+    ['this', 'these'],
+    ['that', 'those'],
+    // Words ending in with a consonant and `o`.
+    ['echo', 'echoes'],
+    ['dingo', 'dingoes'],
+    ['volcano', 'volcanoes'],
+    ['tornado', 'tornadoes'],
+    ['torpedo', 'torpedoes'],
+    // Ends with `us`.
+    ['genus', 'genera'],
+    ['viscus', 'viscera'],
+    // Ends with `ma`.
+    ['stigma', 'stigmata'],
+    ['stoma', 'stomata'],
+    ['dogma', 'dogmata'],
+    ['lemma', 'lemmata'],
+    ['schema', 'schemata'],
+    ['anathema', 'anathemata'],
+    // Other irregular rules.
+    ['ox', 'oxen'],
+    ['axe', 'axes'],
+    ['die', 'dice'],
+    ['yes', 'yeses'],
+    ['foot', 'feet'],
+    ['eave', 'eaves'],
+    ['goose', 'geese'],
+    ['tooth', 'teeth'],
+    ['quiz', 'quizzes'],
+    ['human', 'humans'],
+    ['proof', 'proofs'],
+    ['carve', 'carves'],
+    ['valve', 'valves'],
+    ['looey', 'looies'],
+    ['thief', 'thieves'],
+    ['groove', 'grooves'],
+    ['pickaxe', 'pickaxes'],
+    ['passerby', 'passersby']
+  ].forEach(function (rule) {
+    return pluralize.addIrregularRule(rule[0], rule[1]);
+  });
 
-function decodeEntity(characters) {
-  return own$3.call(characterEntities$1, characters)
-    ? characterEntities$1[characters]
-    : false
-}
+  /**
+   * Pluralization rules.
+   */
+  [
+    [/s?$/i, 's'],
+    [/[^\u0000-\u007F]$/i, '$0'],
+    [/([^aeiou]ese)$/i, '$1'],
+    [/(ax|test)is$/i, '$1es'],
+    [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, '$1es'],
+    [/(e[mn]u)s?$/i, '$1s'],
+    [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, '$1'],
+    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1i'],
+    [/(alumn|alg|vertebr)(?:a|ae)$/i, '$1ae'],
+    [/(seraph|cherub)(?:im)?$/i, '$1im'],
+    [/(her|at|gr)o$/i, '$1oes'],
+    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, '$1a'],
+    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, '$1a'],
+    [/sis$/i, 'ses'],
+    [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, '$1$2ves'],
+    [/([^aeiouy]|qu)y$/i, '$1ies'],
+    [/([^ch][ieo][ln])ey$/i, '$1ies'],
+    [/(x|ch|ss|sh|zz)$/i, '$1es'],
+    [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, '$1ices'],
+    [/\b((?:tit)?m|l)(?:ice|ouse)$/i, '$1ice'],
+    [/(pe)(?:rson|ople)$/i, '$1ople'],
+    [/(child)(?:ren)?$/i, '$1ren'],
+    [/eaux$/i, '$0'],
+    [/m[ae]n$/i, 'men'],
+    ['thou', 'you']
+  ].forEach(function (rule) {
+    return pluralize.addPluralRule(rule[0], rule[1]);
+  });
 
-var legacy = getCjsExportFromNamespace(characterEntitiesLegacy);
-
-var invalid = getCjsExportFromNamespace(characterReferenceInvalid);
-
-var parseEntities_1 = parseEntities;
-
-var own$4 = {}.hasOwnProperty;
-var fromCharCode = String.fromCharCode;
-var noop$2 = Function.prototype;
-
-// Default settings.
-var defaults = {
-  warning: null,
-  reference: null,
-  text: null,
-  warningContext: null,
-  referenceContext: null,
-  textContext: null,
-  position: {},
-  additional: null,
-  attribute: false,
-  nonTerminated: true
-};
-
-// Characters.
-var tab = 9; // '\t'
-var lineFeed = 10; // '\n'
-var formFeed = 12; // '\f'
-var space = 32; // ' '
-var ampersand = 38; // '&'
-var semicolon = 59; // ';'
-var lessThan = 60; // '<'
-var equalsTo = 61; // '='
-var numberSign = 35; // '#'
-var uppercaseX = 88; // 'X'
-var lowercaseX = 120; // 'x'
-var replacementCharacter = 65533; // '�'
-
-// Reference types.
-var name = 'named';
-var hexa = 'hexadecimal';
-var deci = 'decimal';
-
-// Map of bases.
-var bases = {};
-
-bases[hexa] = 16;
-bases[deci] = 10;
-
-// Map of types to tests.
-// Each type of character reference accepts different characters.
-// This test is used to detect whether a reference has ended (as the semicolon
-// is not strictly needed).
-var tests = {};
-
-tests[name] = isAlphanumerical;
-tests[deci] = isDecimal;
-tests[hexa] = isHexadecimal;
-
-// Warning types.
-var namedNotTerminated = 1;
-var numericNotTerminated = 2;
-var namedEmpty = 3;
-var numericEmpty = 4;
-var namedUnknown = 5;
-var numericDisallowed = 6;
-var numericProhibited = 7;
-
-// Warning messages.
-var messages = {};
-
-messages[namedNotTerminated] =
-  'Named character references must be terminated by a semicolon';
-messages[numericNotTerminated] =
-  'Numeric character references must be terminated by a semicolon';
-messages[namedEmpty] = 'Named character references cannot be empty';
-messages[numericEmpty] = 'Numeric character references cannot be empty';
-messages[namedUnknown] = 'Named character references must be known';
-messages[numericDisallowed] =
-  'Numeric character references cannot be disallowed';
-messages[numericProhibited] =
-  'Numeric character references cannot be outside the permissible Unicode range';
-
-// Wrap to ensure clean parameters are given to `parse`.
-function parseEntities(value, options) {
-  var settings = {};
-  var option;
-  var key;
+  /**
+   * Singularization rules.
+   */
+  [
+    [/s$/i, ''],
+    [/(ss)$/i, '$1'],
+    [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, '$1fe'],
+    [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, '$1f'],
+    [/ies$/i, 'y'],
+    [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, '$1ie'],
+    [/\b(mon|smil)ies$/i, '$1ey'],
+    [/\b((?:tit)?m|l)ice$/i, '$1ouse'],
+    [/(seraph|cherub)im$/i, '$1'],
+    [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, '$1'],
+    [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, '$1sis'],
+    [/(movie|twelve|abuse|e[mn]u)s$/i, '$1'],
+    [/(test)(?:is|es)$/i, '$1is'],
+    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1us'],
+    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, '$1um'],
+    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, '$1on'],
+    [/(alumn|alg|vertebr)ae$/i, '$1a'],
+    [/(cod|mur|sil|vert|ind)ices$/i, '$1ex'],
+    [/(matr|append)ices$/i, '$1ix'],
+    [/(pe)(rson|ople)$/i, '$1rson'],
+    [/(child)ren$/i, '$1'],
+    [/(eau)x?$/i, '$1'],
+    [/men$/i, 'man']
+  ].forEach(function (rule) {
+    return pluralize.addSingularRule(rule[0], rule[1]);
+  });
 
-  if (!options) {
-    options = {};
-  }
+  /**
+   * Uncountable rules.
+   */
+  [
+    // Singular words with no plurals.
+    'adulthood',
+    'advice',
+    'agenda',
+    'aid',
+    'aircraft',
+    'alcohol',
+    'ammo',
+    'analytics',
+    'anime',
+    'athletics',
+    'audio',
+    'bison',
+    'blood',
+    'bream',
+    'buffalo',
+    'butter',
+    'carp',
+    'cash',
+    'chassis',
+    'chess',
+    'clothing',
+    'cod',
+    'commerce',
+    'cooperation',
+    'corps',
+    'debris',
+    'diabetes',
+    'digestion',
+    'elk',
+    'energy',
+    'equipment',
+    'excretion',
+    'expertise',
+    'firmware',
+    'flounder',
+    'fun',
+    'gallows',
+    'garbage',
+    'graffiti',
+    'hardware',
+    'headquarters',
+    'health',
+    'herpes',
+    'highjinks',
+    'homework',
+    'housework',
+    'information',
+    'jeans',
+    'justice',
+    'kudos',
+    'labour',
+    'literature',
+    'machinery',
+    'mackerel',
+    'mail',
+    'media',
+    'mews',
+    'moose',
+    'music',
+    'mud',
+    'manga',
+    'news',
+    'only',
+    'personnel',
+    'pike',
+    'plankton',
+    'pliers',
+    'police',
+    'pollution',
+    'premises',
+    'rain',
+    'research',
+    'rice',
+    'salmon',
+    'scissors',
+    'series',
+    'sewage',
+    'shambles',
+    'shrimp',
+    'software',
+    'species',
+    'staff',
+    'swine',
+    'tennis',
+    'traffic',
+    'transportation',
+    'trout',
+    'tuna',
+    'wealth',
+    'welfare',
+    'whiting',
+    'wildebeest',
+    'wildlife',
+    'you',
+    /pok[eé]mon$/i,
+    // Regexes.
+    /[^aeiou]ese$/i, // "chinese", "japanese"
+    /deer$/i, // "deer", "reindeer"
+    /fish$/i, // "fish", "blowfish", "angelfish"
+    /measles$/i,
+    /o[iu]s$/i, // "carnivorous"
+    /pox$/i, // "chickpox", "smallpox"
+    /sheep$/i
+  ].forEach(pluralize.addUncountableRule);
 
-  for (key in defaults) {
-    option = options[key];
-    settings[key] =
-      option === null || option === undefined ? defaults[key] : option;
-  }
+  return pluralize;
+});
+}(pluralize));
 
-  if (settings.position.indent || settings.position.start) {
-    settings.indent = settings.position.indent || [];
-    settings.position = settings.position.start;
-  }
+var plural = pluralize.exports;
 
-  return parse$8(value, settings)
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+function color$1(d) {
+  return '\u001B[33m' + d + '\u001B[39m'
 }
 
-// Parse entities.
-// eslint-disable-next-line complexity
-function parse$8(value, settings) {
-  var additional = settings.additional;
-  var nonTerminated = settings.nonTerminated;
-  var handleText = settings.text;
-  var handleReference = settings.reference;
-  var handleWarning = settings.warning;
-  var textContext = settings.textContext;
-  var referenceContext = settings.referenceContext;
-  var warningContext = settings.warningContext;
-  var pos = settings.position;
-  var indent = settings.indent || [];
-  var length = value.length;
-  var index = 0;
-  var lines = -1;
-  var column = pos.column || 1;
-  var line = pos.line || 1;
-  var queue = '';
-  var result = [];
-  var entityCharacters;
-  var namedEntity;
-  var terminated;
-  var characters;
-  var character;
-  var reference;
-  var following;
-  var warning;
-  var reason;
-  var output;
-  var entity;
-  var begin;
-  var start;
-  var type;
-  var test;
-  var prev;
-  var next;
-  var diff;
-  var end;
-
-  if (typeof additional === 'string') {
-    additional = additional.charCodeAt(0);
-  }
-
-  // Cache the current point.
-  prev = now();
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist-util-is').Test} Test
+ */
 
-  // Wrap `handleWarning`.
-  warning = handleWarning ? parseError : noop$2;
+/**
+ * Continue traversing as normal
+ */
+const CONTINUE$1 = true;
+/**
+ * Do not traverse this node’s children
+ */
+const SKIP$1 = 'skip';
+/**
+ * Stop traversing immediately
+ */
+const EXIT$1 = false;
 
-  // Ensure the algorithm walks over the first character and the end
-  // (inclusive).
-  index--;
-  length++;
+/**
+ * Visit children of tree which pass a test
+ *
+ * @param tree Abstract syntax tree to walk
+ * @param test Test node, optional
+ * @param visitor Function to run for each node
+ * @param reverse Visit the tree in reverse order, defaults to false
+ */
+const visitParents$1 =
+  /**
+   * @type {(
+   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: Visitor<import('./complex-types').Matches<import('./complex-types').InclusiveDescendant<Tree>, Check>>, reverse?: boolean) => void) &
+   *   (<Tree extends Node>(tree: Tree, visitor: Visitor<import('./complex-types').InclusiveDescendant<Tree>>, reverse?: boolean) => void)
+   * )}
+   */
+  (
+    /**
+     * @param {Node} tree
+     * @param {Test} test
+     * @param {Visitor<Node>} visitor
+     * @param {boolean} [reverse]
+     */
+    function (tree, test, visitor, reverse) {
+      if (typeof test === 'function' && typeof visitor !== 'function') {
+        reverse = visitor;
+        // @ts-expect-error no visitor given, so `visitor` is test.
+        visitor = test;
+        test = null;
+      }
+
+      const is = convert(test);
+      const step = reverse ? -1 : 1;
+
+      factory(tree, null, [])();
+
+      /**
+       * @param {Node} node
+       * @param {number?} index
+       * @param {Array.<Parent>} parents
+       */
+      function factory(node, index, parents) {
+        /** @type {Object.<string, unknown>} */
+        // @ts-expect-error: hush
+        const value = typeof node === 'object' && node !== null ? node : {};
+        /** @type {string|undefined} */
+        let name;
+
+        if (typeof value.type === 'string') {
+          name =
+            typeof value.tagName === 'string'
+              ? value.tagName
+              : typeof value.name === 'string'
+              ? value.name
+              : undefined;
+
+          Object.defineProperty(visit, 'name', {
+            value:
+              'node (' +
+              color$1(value.type + (name ? '<' + name + '>' : '')) +
+              ')'
+          });
+        }
 
-  while (++index < length) {
-    // If the previous character was a newline.
-    if (character === lineFeed) {
-      column = indent[lines] || 1;
-    }
+        return visit
 
-    character = value.charCodeAt(index);
+        function visit() {
+          /** @type {ActionTuple} */
+          let result = [];
+          /** @type {ActionTuple} */
+          let subresult;
+          /** @type {number} */
+          let offset;
+          /** @type {Array.<Parent>} */
+          let grandparents;
 
-    if (character === ampersand) {
-      following = value.charCodeAt(index + 1);
+          if (!test || is(node, index, parents[parents.length - 1] || null)) {
+            result = toResult$1(visitor(node, parents));
 
-      // The behaviour depends on the identity of the next character.
-      if (
-        following === tab ||
-        following === lineFeed ||
-        following === formFeed ||
-        following === space ||
-        following === ampersand ||
-        following === lessThan ||
-        following !== following ||
-        (additional && following === additional)
-      ) {
-        // Not a character reference.
-        // No characters are consumed, and nothing is returned.
-        // This is not an error, either.
-        queue += fromCharCode(character);
-        column++;
+            if (result[0] === EXIT$1) {
+              return result
+            }
+          }
 
-        continue
-      }
+          // @ts-expect-error looks like a parent.
+          if (node.children && result[0] !== SKIP$1) {
+            // @ts-expect-error looks like a parent.
+            offset = (reverse ? node.children.length : -1) + step;
+            // @ts-expect-error looks like a parent.
+            grandparents = parents.concat(node);
 
-      start = index + 1;
-      begin = start;
-      end = start;
+            // @ts-expect-error looks like a parent.
+            while (offset > -1 && offset < node.children.length) {
+              // @ts-expect-error looks like a parent.
+              subresult = factory(node.children[offset], offset, grandparents)();
 
-      if (following === numberSign) {
-        // Numerical entity.
-        end = ++begin;
+              if (subresult[0] === EXIT$1) {
+                return subresult
+              }
 
-        // The behaviour further depends on the next character.
-        following = value.charCodeAt(end);
+              offset =
+                typeof subresult[1] === 'number' ? subresult[1] : offset + step;
+            }
+          }
 
-        if (following === uppercaseX || following === lowercaseX) {
-          // ASCII hex digits.
-          type = hexa;
-          end = ++begin;
-        } else {
-          // ASCII digits.
-          type = deci;
+          return result
         }
-      } else {
-        // Named entity.
-        type = name;
       }
+    }
+  );
 
-      entityCharacters = '';
-      entity = '';
-      characters = '';
-      test = tests[type];
-      end--;
+/**
+ * @param {VisitorResult} value
+ * @returns {ActionTuple}
+ */
+function toResult$1(value) {
+  if (Array.isArray(value)) {
+    return value
+  }
 
-      while (++end < length) {
-        following = value.charCodeAt(end);
+  if (typeof value === 'number') {
+    return [CONTINUE$1, value]
+  }
 
-        if (!test(following)) {
-          break
-        }
+  return [value]
+}
 
-        characters += fromCharCode(following);
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist-util-is').Test} Test
+ * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
+ */
 
-        // Check if we can match a legacy named reference.
-        // If so, we cache that as the last viable named reference.
-        // This ensures we do not need to walk backwards later.
-        if (type === name && own$4.call(legacy, characters)) {
-          entityCharacters = characters;
-          entity = legacy[characters];
-        }
+/**
+ * Visit children of tree which pass a test
+ *
+ * @param tree Abstract syntax tree to walk
+ * @param test Test, optional
+ * @param visitor Function to run for each node
+ * @param reverse Fisit the tree in reverse, defaults to false
+ */
+const visit =
+  /**
+   * @type {(
+   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: Visitor<import('unist-util-visit-parents/complex-types').Matches<import('unist-util-visit-parents/complex-types').InclusiveDescendant<Tree>, Check>>, reverse?: boolean) => void) &
+   *   (<Tree extends Node>(tree: Tree, visitor: Visitor<import('unist-util-visit-parents/complex-types').InclusiveDescendant<Tree>>, reverse?: boolean) => void)
+   * )}
+   */
+  (
+    /**
+     * @param {Node} tree
+     * @param {Test} test
+     * @param {Visitor<Node>} visitor
+     * @param {boolean} [reverse]
+     */
+    function (tree, test, visitor, reverse) {
+      if (typeof test === 'function' && typeof visitor !== 'function') {
+        reverse = visitor;
+        visitor = test;
+        test = null;
+      }
+
+      visitParents$1(tree, test, overload, reverse);
+
+      /**
+       * @param {Node} node
+       * @param {Array.<Parent>} parents
+       */
+      function overload(node, parents) {
+        const parent = parents[parents.length - 1];
+        return visitor(
+          node,
+          parent ? parent.children.indexOf(node) : null,
+          parent
+        )
       }
+    }
+  );
+
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module list-item-bullet-indent
+ * @fileoverview
+ *   Warn when list item bullets are indented.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   removes all indentation before bullets.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   Paragraph.
+ *
+ *   * List item
+ *   * List item
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   Paragraph.
+ *
+ *   ·* List item
+ *   ·* List item
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   3:2: Incorrect indentation before bullet: remove 1 space
+ *   4:2: Incorrect indentation before bullet: remove 1 space
+ */
 
-      terminated = value.charCodeAt(end) === semicolon;
+const remarkLintListItemBulletIndent = lintRule$F(
+  'remark-lint:list-item-bullet-indent',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, 'list', (list, _, grandparent) => {
+      let index = -1;
 
-      if (terminated) {
-        end++;
+      while (++index < list.children.length) {
+        const item = list.children[index];
 
-        namedEntity = type === name ? decodeEntity_1(characters) : false;
+        if (
+          grandparent &&
+          grandparent.type === 'root' &&
+          grandparent.position &&
+          typeof grandparent.position.start.column === 'number' &&
+          item.position &&
+          typeof item.position.start.column === 'number'
+        ) {
+          const indent =
+            item.position.start.column - grandparent.position.start.column;
 
-        if (namedEntity) {
-          entityCharacters = characters;
-          entity = namedEntity;
+          if (indent) {
+            file.message(
+              'Incorrect indentation before bullet: remove ' +
+                indent +
+                ' ' +
+                plural('space', indent),
+              item.position.start
+            );
+          }
         }
       }
+    });
+  }
+);
 
-      diff = 1 + end - start;
+var remarkLintListItemBulletIndent$1 = remarkLintListItemBulletIndent;
 
-      if (!terminated && !nonTerminated) ; else if (!characters) {
-        // An empty (possible) entity is valid, unless it’s numeric (thus an
-        // ampersand followed by an octothorp).
-        if (type !== name) {
-          warning(numericEmpty, diff);
-        }
-      } else if (type === name) {
-        // An ampersand followed by anything unknown, and not terminated, is
-        // invalid.
-        if (terminated && !entity) {
-          warning(namedUnknown, 1);
-        } else {
-          // If theres something after an entity name which is not known, cap
-          // the reference.
-          if (entityCharacters !== characters) {
-            end = begin + entityCharacters.length;
-            diff = 1 + end - begin;
-            terminated = false;
-          }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-          // If the reference is not terminated, warn.
-          if (!terminated) {
-            reason = entityCharacters ? namedNotTerminated : namedEmpty;
+const primitives$E = new Set(['string', 'number', 'boolean']);
 
-            if (settings.attribute) {
-              following = value.charCodeAt(end);
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$E(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-              if (following === equalsTo) {
-                warning(reason, diff);
-                entity = null;
-              } else if (isAlphanumerical(following)) {
-                entity = null;
-              } else {
-                warning(reason, diff);
-              }
-            } else {
-              warning(reason, diff);
-            }
-          }
-        }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-        reference = entity;
-      } else {
-        if (!terminated) {
-          // All non-terminated numeric entities are not rendered, and trigger a
-          // warning.
-          warning(numericNotTerminated, diff);
-        }
-
-        // When terminated and number, parse as either hexadecimal or decimal.
-        reference = parseInt(characters, bases[type]);
-
-        // Trigger a warning when the parsed number is prohibited, and replace
-        // with replacement character.
-        if (prohibited(reference)) {
-          warning(numericProhibited, diff);
-          reference = fromCharCode(replacementCharacter);
-        } else if (reference in invalid) {
-          // Trigger a warning when the parsed number is disallowed, and replace
-          // by an alternative.
-          warning(numericDisallowed, diff);
-          reference = invalid[reference];
-        } else {
-          // Parse the number.
-          output = '';
+  return plugin
 
-          // Trigger a warning when the parsed number should not be used.
-          if (disallowed(reference)) {
-            warning(numericDisallowed, diff);
-          }
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$F(ruleId, raw);
 
-          // Stringify the number.
-          if (reference > 0xffff) {
-            reference -= 0x10000;
-            output += fromCharCode((reference >>> (10 & 0x3ff)) | 0xd800);
-            reference = 0xdc00 | (reference & 0x3ff);
-          }
+    if (!severity) return
 
-          reference = output + fromCharCode(reference);
-        }
-      }
+    const fatal = severity === 2;
 
-      // Found it!
-      // First eat the queued characters as normal text, then eat an entity.
-      if (reference) {
-        flush();
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-        prev = now();
-        index = end - 1;
-        column += end - start + 1;
-        result.push(reference);
-        next = now();
-        next.offset++;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-        if (handleReference) {
-          handleReference.call(
-            referenceContext,
-            reference,
-            {start: prev, end: next},
-            value.slice(start - 1, end)
-          );
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
 
-        prev = next;
-      } else {
-        // If we could not find a reference, queue the checked characters (as
-        // normal characters), and move the pointer to their end.
-        // This is possible because we can be certain neither newlines nor
-        // ampersands are included.
-        characters = value.slice(start - 1, end);
-        queue += characters;
-        column += characters.length;
-        index = end - 1;
-      }
-    } else {
-      // Handle anything other than an ampersand, including newlines and EOF.
-      if (
-        character === 10 // Line feed
-      ) {
-        line++;
-        lines++;
-        column = 0;
-      }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-      if (character === character) {
-        queue += fromCharCode(character);
-        column++;
-      } else {
-        flush();
-      }
+        next();
+      })(tree, file, options);
     }
   }
+}
 
-  // Return the reduced nodes.
-  return result.join('')
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$F(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  // Get current position.
-  function now() {
-    return {
-      line: line,
-      column: column,
-      offset: index + (pos.offset || 0)
-    }
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$E.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  // “Throw” a parse-error: a warning.
-  function parseError(code, offset) {
-    var position = now();
+  let level = result[0];
 
-    position.column += offset;
-    position.offset += offset;
-
-    handleWarning.call(warningContext, messages[code], position, code);
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  // Flush `queue` (normal text).
-  // Macro invoked before each entity and at the end of `value`.
-  // Does nothing when `queue` is empty.
-  function flush() {
-    if (queue) {
-      result.push(queue);
-
-      if (handleText) {
-        handleText.call(textContext, queue, {start: prev, end: now()});
-      }
-
-      queue = '';
-    }
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
-}
 
-// Check if `character` is outside the permissible unicode range.
-function prohibited(code) {
-  return (code >= 0xd800 && code <= 0xdfff) || code > 0x10ffff
-}
+  result[0] = level;
 
-// Check if `character` is disallowed.
-function disallowed(code) {
-  return (
-    (code >= 0x0001 && code <= 0x0008) ||
-    code === 0x000b ||
-    (code >= 0x000d && code <= 0x001f) ||
-    (code >= 0x007f && code <= 0x009f) ||
-    (code >= 0xfdd0 && code <= 0xfdef) ||
-    (code & 0xffff) === 0xffff ||
-    (code & 0xffff) === 0xfffe
-  )
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var decode = factory$4;
-
-// Factory to create an entity decoder.
-function factory$4(ctx) {
-  decoder.raw = decodeRaw;
-
-  return decoder
-
-  // Normalize `position` to add an `indent`.
-  function normalize(position) {
-    var offsets = ctx.offset;
-    var line = position.line;
-    var result = [];
-
-    while (++line) {
-      if (!(line in offsets)) {
-        break
-      }
-
-      result.push((offsets[line] || 0) + 1);
-    }
+/**
+ * @typedef {import('unist').Position} Position
+ * @typedef {import('unist').Point} Point
+ *
+ * @typedef {Partial<Point>} PointLike
+ *
+ * @typedef {Object} PositionLike
+ * @property {PointLike} [start]
+ * @property {PointLike} [end]
+ *
+ * @typedef {Object} NodeLike
+ * @property {PositionLike} [position]
+ */
 
-    return {start: position, indent: result}
-  }
+var pointStart = point('start');
+var pointEnd = point('end');
 
-  // Decode `value` (at `position`) into text-nodes.
-  function decoder(value, position, handler) {
-    parseEntities_1(value, {
-      position: normalize(position),
-      warning: handleWarning,
-      text: handler,
-      reference: handler,
-      textContext: ctx,
-      referenceContext: ctx
-    });
-  }
+/**
+ * Get the positional info of `node`.
+ *
+ * @param {'start'|'end'} type
+ */
+function point(type) {
+  return point
 
-  // Decode `value` (at `position`) into a string.
-  function decodeRaw(value, position, options) {
-    return parseEntities_1(
-      value,
-      immutable(options, {position: normalize(position), warning: handleWarning})
-    )
-  }
+  /**
+   * Get the positional info of `node`.
+   *
+   * @param {NodeLike} [node]
+   * @returns {Point}
+   */
+  function point(node) {
+    /** @type {Point} */
+    // @ts-ignore looks like a point
+    var point = (node && node.position && node.position[type]) || {};
 
-  // Handle a warning.
-  // See <https://github.com/wooorm/parse-entities> for the warnings.
-  function handleWarning(reason, position, code) {
-    if (code !== 3) {
-      ctx.file.message(reason, position);
+    return {
+      line: point.line || null,
+      column: point.column || null,
+      offset: point.offset > -1 ? point.offset : null
     }
   }
 }
 
-var tokenizer = factory$5;
-
-// Construct a tokenizer.  This creates both `tokenizeInline` and `tokenizeBlock`.
-function factory$5(type) {
-  return tokenize
-
-  // Tokenizer for a bound `type`.
-  function tokenize(value, location) {
-    var self = this;
-    var offset = self.offset;
-    var tokens = [];
-    var methods = self[type + 'Methods'];
-    var tokenizers = self[type + 'Tokenizers'];
-    var line = location.line;
-    var column = location.column;
-    var index;
-    var length;
-    var method;
-    var name;
-    var matched;
-    var valueLength;
-
-    // Trim white space only lines.
-    if (!value) {
-      return tokens
-    }
-
-    // Expose on `eat`.
-    eat.now = now;
-    eat.file = self.file;
-
-    // Sync initial offset.
-    updatePosition('');
-
-    // Iterate over `value`, and iterate over all tokenizers.  When one eats
-    // something, re-iterate with the remaining value.  If no tokenizer eats,
-    // something failed (should not happen) and an exception is thrown.
-    while (value) {
-      index = -1;
-      length = methods.length;
-      matched = false;
-
-      while (++index < length) {
-        name = methods[index];
-        method = tokenizers[name];
-
-        // Previously, we had constructs such as footnotes and YAML that used
-        // these properties.
-        // Those are now external (plus there are userland extensions), that may
-        // still use them.
-        if (
-          method &&
-          /* istanbul ignore next */ (!method.onlyAtStart || self.atStart) &&
-          /* istanbul ignore next */ (!method.notInList || !self.inList) &&
-          /* istanbul ignore next */ (!method.notInBlock || !self.inBlock) &&
-          (!method.notInLink || !self.inLink)
-        ) {
-          valueLength = value.length;
-
-          method.apply(self, [eat, value]);
+/**
+ * @typedef {Object} PointLike
+ * @property {number} [line]
+ * @property {number} [column]
+ * @property {number} [offset]
+ *
+ * @typedef {Object} PositionLike
+ * @property {PointLike} [start]
+ * @property {PointLike} [end]
+ *
+ * @typedef {Object} NodeLike
+ * @property {PositionLike} [position]
+ */
 
-          matched = valueLength !== value.length;
+/**
+ * Check if `node` is *generated*.
+ *
+ * @param {NodeLike} [node]
+ * @returns {boolean}
+ */
+function generated(node) {
+  return (
+    !node ||
+    !node.position ||
+    !node.position.start ||
+    !node.position.start.line ||
+    !node.position.start.column ||
+    !node.position.end ||
+    !node.position.end.line ||
+    !node.position.end.column
+  )
+}
 
-          if (matched) {
-            break
-          }
-        }
-      }
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module list-item-indent
+ * @fileoverview
+ *   Warn when the spacing between a list item’s bullet and its content violates
+ *   a given style.
+ *
+ *   Options: `'tab-size'`, `'mixed'`, or `'space'`, default: `'tab-size'`.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   uses `'tab-size'` (named `'tab'` there) by default to ensure Markdown is
+ *   seen the same way across vendors.
+ *   This can be configured with the
+ *   [`listItemIndent`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionslistitemindent)
+ *   option.
+ *   This rule’s `'space'` option is named `'1'` there.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   *···List
+ *   ····item.
+ *
+ *   Paragraph.
+ *
+ *   11.·List
+ *   ····item.
+ *
+ *   Paragraph.
+ *
+ *   *···List
+ *   ····item.
+ *
+ *   *···List
+ *   ····item.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "mixed"}
+ *
+ *   *·List item.
+ *
+ *   Paragraph.
+ *
+ *   11.·List item
+ *
+ *   Paragraph.
+ *
+ *   *···List
+ *   ····item.
+ *
+ *   *···List
+ *   ····item.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "space"}
+ *
+ *   *·List item.
+ *
+ *   Paragraph.
+ *
+ *   11.·List item
+ *
+ *   Paragraph.
+ *
+ *   *·List
+ *   ··item.
+ *
+ *   *·List
+ *   ··item.
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": "space", "label": "input"}
+ *
+ *   *···List
+ *   ····item.
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": "space", "label": "output"}
+ *
+ *    1:5: Incorrect list-item indent: remove 2 spaces
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": "tab-size", "label": "input"}
+ *
+ *   *·List
+ *   ··item.
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": "tab-size", "label": "output"}
+ *
+ *    1:3: Incorrect list-item indent: add 2 spaces
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": "mixed", "label": "input"}
+ *
+ *   *···List item.
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": "mixed", "label": "output"}
+ *
+ *    1:5: Incorrect list-item indent: remove 2 spaces
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": "💩", "label": "output", "positionless": true}
+ *
+ *    1:1: Incorrect list-item indent style `💩`: use either `'tab-size'`, `'space'`, or `'mixed'`
+ */
 
-      /* istanbul ignore if */
-      if (!matched) {
-        self.file.fail(new Error('Infinite loop'), eat.now());
-      }
+const remarkLintListItemIndent = lintRule$E(
+  'remark-lint:list-item-indent',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'tab-size') => {
+    const value = String(file);
+
+    if (option !== 'tab-size' && option !== 'space' && option !== 'mixed') {
+      file.fail(
+        'Incorrect list-item indent style `' +
+          option +
+          "`: use either `'tab-size'`, `'space'`, or `'mixed'`"
+      );
     }
 
-    self.eof = now();
+    visit(tree, 'list', (node) => {
+      if (generated(node)) return
 
-    return tokens
+      const spread = node.spread;
+      let index = -1;
 
-    // Update line, column, and offset based on `value`.
-    function updatePosition(subvalue) {
-      var lastIndex = -1;
-      var index = subvalue.indexOf('\n');
+      while (++index < node.children.length) {
+        const item = node.children[index];
+        const head = item.children[0];
+        const final = pointStart(head);
 
-      while (index !== -1) {
-        line++;
-        lastIndex = index;
-        index = subvalue.indexOf('\n', index + 1);
-      }
-
-      if (lastIndex === -1) {
-        column += subvalue.length;
-      } else {
-        column = subvalue.length - lastIndex;
-      }
-
-      if (line in offset) {
-        if (lastIndex !== -1) {
-          column += offset[line];
-        } else if (column <= offset[line]) {
-          column = offset[line] + 1;
-        }
-      }
-    }
+        const marker = value
+          .slice(pointStart(item).offset, final.offset)
+          .replace(/\[[x ]?]\s*$/i, '');
 
-    // Get offset.  Called before the first character is eaten to retrieve the
-    // range’s offsets.
-    function getOffset() {
-      var indentation = [];
-      var pos = line + 1;
+        const bulletSize = marker.replace(/\s+$/, '').length;
 
-      // Done.  Called when the last character is eaten to retrieve the range’s
-      // offsets.
-      return function () {
-        var last = line + 1;
+        const style =
+          option === 'tab-size' || (option === 'mixed' && spread)
+            ? Math.ceil(bulletSize / 4) * 4
+            : bulletSize + 1;
 
-        while (pos < last) {
-          indentation.push((offset[pos] || 0) + 1);
+        if (marker.length !== style) {
+          const diff = style - marker.length;
+          const abs = Math.abs(diff);
 
-          pos++;
+          file.message(
+            'Incorrect list-item indent: ' +
+              (diff > 0 ? 'add' : 'remove') +
+              ' ' +
+              abs +
+              ' ' +
+              plural('space', abs),
+            final
+          );
         }
-
-        return indentation
       }
-    }
-
-    // Get the current position.
-    function now() {
-      var pos = {line: line, column: column};
+    });
+  }
+);
 
-      pos.offset = self.toOffset(pos);
+var remarkLintListItemIndent$1 = remarkLintListItemIndent;
 
-      return pos
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    // Store position information for a node.
-    function Position(start) {
-      this.start = start;
-      this.end = now();
-    }
+const primitives$D = new Set(['string', 'number', 'boolean']);
 
-    // Throw when a value is incorrectly eaten.  This shouldn’t happen but will
-    // throw on new, incorrect rules.
-    function validateEat(subvalue) {
-      /* istanbul ignore if */
-      if (value.slice(0, subvalue.length) !== subvalue) {
-        // Capture stack-trace.
-        self.file.fail(
-          new Error(
-            'Incorrectly eaten value: please report this warning on https://git.io/vg5Ft'
-          ),
-          now()
-        );
-      }
-    }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$D(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-    // Mark position and patch `node.position`.
-    function position() {
-      var before = now();
+  Object.defineProperty(plugin, 'name', {value: id});
 
-      return update
+  return plugin
 
-      // Add the position to a node.
-      function update(node, indent) {
-        var previous = node.position;
-        var start = previous ? previous.start : before;
-        var combined = [];
-        var n = previous && previous.end.line;
-        var l = before.line;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$E(ruleId, raw);
 
-        node.position = new Position(start);
+    if (!severity) return
 
-        // If there was already a `position`, this node was merged.  Fixing
-        // `start` wasn’t hard, but the indent is different.  Especially
-        // because some information, the indent between `n` and `l` wasn’t
-        // tracked.  Luckily, that space is (should be?) empty, so we can
-        // safely check for it now.
-        if (previous && indent && previous.indent) {
-          combined = previous.indent;
+    const fatal = severity === 2;
 
-          if (n < l) {
-            while (++n < l) {
-              combined.push((offset[n] || 0) + 1);
-            }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-            combined.push(before.column);
-          }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-          indent = combined.concat(indent);
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
 
-        node.position.indent = indent || [];
-
-        return node
-      }
-    }
-
-    // Add `node` to `parent`s children or to `tokens`.  Performs merges where
-    // possible.
-    function add(node, parent) {
-      var children = parent ? parent.children : tokens;
-      var previous = children[children.length - 1];
-      var fn;
-
-      if (
-        previous &&
-        node.type === previous.type &&
-        (node.type === 'text' || node.type === 'blockquote') &&
-        mergeable(previous) &&
-        mergeable(node)
-      ) {
-        fn = node.type === 'text' ? mergeText : mergeBlockquote;
-        node = fn.call(self, previous, node);
-      }
-
-      if (node !== previous) {
-        children.push(node);
-      }
-
-      if (self.atStart && tokens.length !== 0) {
-        self.exitStart();
-      }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-      return node
+        next();
+      })(tree, file, options);
     }
+  }
+}
 
-    // Remove `subvalue` from `value`.  `subvalue` must be at the start of
-    // `value`.
-    function eat(subvalue) {
-      var indent = getOffset();
-      var pos = position();
-      var current = now();
-
-      validateEat(subvalue);
-
-      apply.reset = reset;
-      reset.test = test;
-      apply.test = test;
-
-      value = value.slice(subvalue.length);
-
-      updatePosition(subvalue);
-
-      indent = indent();
-
-      return apply
-
-      // Add the given arguments, add `position` to the returned node, and
-      // return the node.
-      function apply(node, parent) {
-        return pos(add(pos(node), parent), indent)
-      }
-
-      // Functions just like apply, but resets the content: the line and
-      // column are reversed, and the eaten value is re-added.   This is
-      // useful for nodes with a single type of content, such as lists and
-      // tables.  See `apply` above for what parameters are expected.
-      function reset() {
-        var node = apply.apply(null, arguments);
-
-        line = current.line;
-        column = current.column;
-        value = subvalue + value;
-
-        return node
-      }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$E(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-      // Test the position, after eating, and reverse to a not-eaten state.
-      function test() {
-        var result = pos({});
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$D.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-        line = current.line;
-        column = current.column;
-        value = subvalue + value;
+  let level = result[0];
 
-        return result.position
-      }
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
   }
-}
 
-// Check whether a node is mergeable with adjacent nodes.
-function mergeable(node) {
-  var start;
-  var end;
-
-  if (node.type !== 'text' || !node.position) {
-    return true
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  start = node.position.start;
-  end = node.position.end;
+  result[0] = level;
 
-  // Only merge nodes which occupy the same size as their `value`.
-  return (
-    start.line !== end.line || end.column - start.column === node.value.length
-  )
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-// Merge two text nodes: `node` into `prev`.
-function mergeText(previous, node) {
-  previous.value += node.value;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-auto-link-without-protocol
+ * @fileoverview
+ *   Warn for autolinks without protocol.
+ *   Autolinks are URLs enclosed in `<` (less than) and `>` (greater than)
+ *   characters.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   adds a protocol where needed.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   <http://www.example.com>
+ *   <mailto:foo@bar.com>
+ *
+ *   Most Markdown vendors don’t recognize the following as a link:
+ *   <www.example.com>
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   <foo@bar.com>
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-1:14: All automatic links must start with a protocol
+ */
 
-  return previous
-}
+// Protocol expression.
+// See: <https://en.wikipedia.org/wiki/URI_scheme#Generic_syntax>.
+const protocol = /^[a-z][a-z+.-]+:\/?/i;
 
-// Merge two blockquotes: `node` into `prev`, unless in CommonMark or gfm modes.
-function mergeBlockquote(previous, node) {
-  if (this.options.commonmark || this.options.gfm) {
-    return node
+const remarkLintNoAutoLinkWithoutProtocol = lintRule$D(
+  'remark-lint:no-auto-link-without-protocol',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, 'link', (node) => {
+      if (
+        !generated(node) &&
+        pointStart(node).column === pointStart(node.children[0]).column - 1 &&
+        pointEnd(node).column ===
+          pointEnd(node.children[node.children.length - 1]).column + 1 &&
+        !protocol.test(toString(node))
+      ) {
+        file.message('All automatic links must start with a protocol', node);
+      }
+    });
   }
+);
 
-  previous.children = previous.children.concat(node.children);
-
-  return previous
-}
-
-var markdownEscapes = escapes;
-
-var defaults$1 = [
-  '\\',
-  '`',
-  '*',
-  '{',
-  '}',
-  '[',
-  ']',
-  '(',
-  ')',
-  '#',
-  '+',
-  '-',
-  '.',
-  '!',
-  '_',
-  '>'
-];
+var remarkLintNoAutoLinkWithoutProtocol$1 = remarkLintNoAutoLinkWithoutProtocol;
 
-var gfm = defaults$1.concat(['~', '|']);
-
-var commonmark = gfm.concat([
-  '\n',
-  '"',
-  '$',
-  '%',
-  '&',
-  "'",
-  ',',
-  '/',
-  ':',
-  ';',
-  '<',
-  '=',
-  '?',
-  '@',
-  '^'
-]);
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-escapes.default = defaults$1;
-escapes.gfm = gfm;
-escapes.commonmark = commonmark;
+const primitives$C = new Set(['string', 'number', 'boolean']);
 
-// Get markdown escapes.
-function escapes(options) {
-  var settings = options || {};
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$C(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  if (settings.commonmark) {
-    return commonmark
-  }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  return settings.gfm ? gfm : defaults$1
-}
+  return plugin
 
-var blockElements = [
-  'address',
-  'article',
-  'aside',
-  'base',
-  'basefont',
-  'blockquote',
-  'body',
-  'caption',
-  'center',
-  'col',
-  'colgroup',
-  'dd',
-  'details',
-  'dialog',
-  'dir',
-  'div',
-  'dl',
-  'dt',
-  'fieldset',
-  'figcaption',
-  'figure',
-  'footer',
-  'form',
-  'frame',
-  'frameset',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'head',
-  'header',
-  'hgroup',
-  'hr',
-  'html',
-  'iframe',
-  'legend',
-  'li',
-  'link',
-  'main',
-  'menu',
-  'menuitem',
-  'meta',
-  'nav',
-  'noframes',
-  'ol',
-  'optgroup',
-  'option',
-  'p',
-  'param',
-  'pre',
-  'section',
-  'source',
-  'title',
-  'summary',
-  'table',
-  'tbody',
-  'td',
-  'tfoot',
-  'th',
-  'thead',
-  'title',
-  'tr',
-  'track',
-  'ul'
-];
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$D(ruleId, raw);
 
-var defaults$2 = {
-  position: true,
-  gfm: true,
-  commonmark: false,
-  pedantic: false,
-  blocks: blockElements
-};
+    if (!severity) return
 
-var setOptions_1 = setOptions;
+    const fatal = severity === 2;
 
-function setOptions(options) {
-  var self = this;
-  var current = self.options;
-  var key;
-  var value;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  if (options == null) {
-    options = {};
-  } else if (typeof options === 'object') {
-    options = immutable(options);
-  } else {
-    throw new Error('Invalid value `' + options + '` for setting `options`')
-  }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  for (key in defaults$2) {
-    value = options[key];
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-    if (value == null) {
-      value = current[key];
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (
-      (key !== 'blocks' && typeof value !== 'boolean') ||
-      (key === 'blocks' && typeof value !== 'object')
-    ) {
-      throw new Error(
-        'Invalid value `' + value + '` for setting `options.' + key + '`'
-      )
+        next();
+      })(tree, file, options);
     }
-
-    options[key] = value;
   }
-
-  self.options = options;
-  self.escape = markdownEscapes(options);
-
-  return self
 }
 
-var convert_1 = convert$3;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$D(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-function convert$3(test) {
-  if (typeof test === 'string') {
-    return typeFactory(test)
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$C.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  if (test === null || test === undefined) {
-    return ok$1
-  }
+  let level = result[0];
 
-  if (typeof test === 'object') {
-    return ('length' in test ? anyFactory : matchesFactory)(test)
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  if (typeof test === 'function') {
-    return test
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  throw new Error('Expected function, string, or object as test')
-}
-
-function convertAll(tests) {
-  var results = [];
-  var length = tests.length;
-  var index = -1;
-
-  while (++index < length) {
-    results[index] = convert$3(tests[index]);
-  }
+  result[0] = level;
 
-  return results
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-// Utility assert each property in `test` is represented in `node`, and each
-// values are strictly equal.
-function matchesFactory(test) {
-  return matches
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-blockquote-without-marker
+ * @fileoverview
+ *   Warn when blank lines without `>` (greater than) markers are found in a
+ *   block quote.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   adds markers to every line in a block quote.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   > Foo…
+ *   > …bar…
+ *   > …baz.
+ *
+ * @example
+ *   {"name": "ok-tabs.md"}
+ *
+ *   >»Foo…
+ *   >»…bar…
+ *   >»…baz.
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   > Foo…
+ *   …bar…
+ *   > …baz.
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   2:1: Missing marker in block quote
+ *
+ * @example
+ *   {"name": "not-ok-tabs.md", "label": "input"}
+ *
+ *   >»Foo…
+ *   »…bar…
+ *   …baz.
+ *
+ * @example
+ *   {"name": "not-ok-tabs.md", "label": "output"}
+ *
+ *   2:1: Missing marker in block quote
+ *   3:1: Missing marker in block quote
+ */
 
-  function matches(node) {
-    var key;
+const remarkLintNoBlockquoteWithoutMarker = lintRule$C(
+  'remark-lint:no-blockquote-without-marker',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    const value = String(file);
+    const loc = location(file);
 
-    for (key in test) {
-      if (node[key] !== test[key]) {
-        return false
-      }
-    }
+    visit(tree, 'blockquote', (node) => {
+      let index = -1;
 
-    return true
-  }
-}
+      while (++index < node.children.length) {
+        const child = node.children[index];
 
-function anyFactory(tests) {
-  var checks = convertAll(tests);
-  var length = checks.length;
+        if (child.type === 'paragraph' && !generated(child)) {
+          const end = pointEnd(child).line;
+          const column = pointStart(child).column;
+          let line = pointStart(child).line;
 
-  return matches
+          // Skip past the first line.
+          while (++line <= end) {
+            const offset = loc.toOffset({line, column});
 
-  function matches() {
-    var index = -1;
+            if (/>[\t ]+$/.test(value.slice(offset - 5, offset))) {
+              continue
+            }
 
-    while (++index < length) {
-      if (checks[index].apply(this, arguments)) {
-        return true
+            // Roughly here.
+            file.message('Missing marker in block quote', {
+              line,
+              column: column - 2
+            });
+          }
+        }
       }
-    }
-
-    return false
-  }
-}
-
-// Utility to convert a string into a function which checks a given node’s type
-// for said string.
-function typeFactory(test) {
-  return type
-
-  function type(node) {
-    return Boolean(node && node.type === test)
+    });
   }
-}
+);
 
-// Utility to return true.
-function ok$1() {
-  return true
-}
+var remarkLintNoBlockquoteWithoutMarker$1 = remarkLintNoBlockquoteWithoutMarker;
 
-var unistUtilVisitParents = visitParents;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
+const primitives$B = new Set(['string', 'number', 'boolean']);
 
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$B(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-var CONTINUE = true;
-var SKIP = 'skip';
-var EXIT = false;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-visitParents.CONTINUE = CONTINUE;
-visitParents.SKIP = SKIP;
-visitParents.EXIT = EXIT;
+  return plugin
 
-function visitParents(tree, test, visitor, reverse) {
-  var is;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$C(ruleId, raw);
 
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor;
-    visitor = test;
-    test = null;
-  }
+    if (!severity) return
 
-  is = convert_1(test);
+    const fatal = severity === 2;
 
-  one(tree, null, []);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  // Visit a single node.
-  function one(node, index, parents) {
-    var result = [];
-    var subresult;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-    if (!test || is(node, index, parents[parents.length - 1] || null)) {
-      result = toResult(visitor(node, parents));
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-      if (result[0] === EXIT) {
-        return result
-      }
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (node.children && result[0] !== SKIP) {
-      subresult = toResult(all(node.children, parents.concat(node)));
-      return subresult[0] === EXIT ? subresult : result
+        next();
+      })(tree, file, options);
     }
-
-    return result
   }
+}
 
-  // Visit children in `parent`.
-  function all(children, parents) {
-    var min = -1;
-    var step = reverse ? -1 : 1;
-    var index = (reverse ? children.length : min) + step;
-    var result;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$C(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-    while (index > min && index < children.length) {
-      result = one(children[index], index, parents);
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$B.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-      if (result[0] === EXIT) {
-        return result
-      }
+  let level = result[0];
 
-      index = typeof result[1] === 'number' ? result[1] : index + step;
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
   }
-}
 
-function toResult(value) {
-  if (value !== null && typeof value === 'object' && 'length' in value) {
-    return value
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  if (typeof value === 'number') {
-    return [CONTINUE, value]
-  }
+  result[0] = level;
 
-  return [value]
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var unistUtilVisit = visit;
-
-
-
-var CONTINUE$1 = unistUtilVisitParents.CONTINUE;
-var SKIP$1 = unistUtilVisitParents.SKIP;
-var EXIT$1 = unistUtilVisitParents.EXIT;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-literal-urls
+ * @fileoverview
+ *   Warn for literal URLs in text.
+ *   URLs are treated as links in some Markdown vendors, but not in others.
+ *   To make sure they are always linked, wrap them in `<` (less than) and `>`
+ *   (greater than).
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   never creates literal URLs and always uses `<` (less than) and `>`
+ *   (greater than).
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   <http://foo.bar/baz>
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input", "gfm": true}
+ *
+ *   http://foo.bar/baz
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "gfm": true}
+ *
+ *   1:1-1:19: Don’t use literal URLs without angle brackets
+ */
 
-visit.CONTINUE = CONTINUE$1;
-visit.SKIP = SKIP$1;
-visit.EXIT = EXIT$1;
+const remarkLintNoLiteralUrls = lintRule$B(
+  'remark-lint:no-literal-urls',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, 'link', (node) => {
+      const value = toString(node);
 
-function visit(tree, test, visitor, reverse) {
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor;
-    visitor = test;
-    test = null;
+      if (
+        !generated(node) &&
+        pointStart(node).column === pointStart(node.children[0]).column &&
+        pointEnd(node).column ===
+          pointEnd(node.children[node.children.length - 1]).column &&
+        (node.url === 'mailto:' + value || node.url === value)
+      ) {
+        file.message('Don’t use literal URLs without angle brackets', node);
+      }
+    });
   }
+);
 
-  unistUtilVisitParents(tree, test, overload, reverse);
+var remarkLintNoLiteralUrls$1 = remarkLintNoLiteralUrls;
 
-  function overload(node, parents) {
-    var parent = parents[parents.length - 1];
-    var index = parent ? parent.children.indexOf(node) : null;
-    return visitor(node, index, parent)
-  }
-}
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-var unistUtilRemovePosition = removePosition;
+const primitives$A = new Set(['string', 'number', 'boolean']);
 
-function removePosition(node, force) {
-  unistUtilVisit(node, force ? hard : soft);
-  return node
-}
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$A(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-function hard(node) {
-  delete node.position;
-}
+  Object.defineProperty(plugin, 'name', {value: id});
 
-function soft(node) {
-  node.position = undefined;
-}
+  return plugin
 
-var parse_1$3 = parse$9;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$B(ruleId, raw);
 
-var lineFeed$1 = '\n';
-var lineBreaksExpression = /\r\n|\r/g;
+    if (!severity) return
 
-// Parse the bound file.
-function parse$9() {
-  var self = this;
-  var value = String(self.file);
-  var start = {line: 1, column: 1, offset: 0};
-  var content = immutable(start);
-  var node;
+    const fatal = severity === 2;
 
-  // Clean non-unix newlines: `\r\n` and `\r` are all changed to `\n`.
-  // This should not affect positional information.
-  value = value.replace(lineBreaksExpression, lineFeed$1);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  // BOM.
-  if (value.charCodeAt(0) === 0xfeff) {
-    value = value.slice(1);
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-    content.column++;
-    content.offset++;
-  }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  node = {
-    type: 'root',
-    children: self.tokenizeBlock(value, content),
-    position: {start: start, end: self.eof || immutable(start)}
-  };
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-  if (!self.options.position) {
-    unistUtilRemovePosition(node, true);
+        next();
+      })(tree, file, options);
+    }
   }
-
-  return node
 }
 
-// A line containing no characters, or a line containing only spaces (U+0020) or
-// tabs (U+0009), is called a blank line.
-// See <https://spec.commonmark.org/0.29/#blank-line>.
-var reBlankLine = /^[ \t]*(\n|$)/;
-
-// Note that though blank lines play a special role in lists to determine
-// whether the list is tight or loose
-// (<https://spec.commonmark.org/0.29/#blank-lines>), it’s done by the list
-// tokenizer and this blank line tokenizer does not have to be responsible for
-// that.
-// Therefore, configs such as `blankLine.notInList` do not have to be set here.
-var blankLine_1 = blankLine;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$B(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-function blankLine(eat, value, silent) {
-  var match;
-  var subvalue = '';
-  var index = 0;
-  var length = value.length;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$A.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-  while (index < length) {
-    match = reBlankLine.exec(value.slice(index));
+  let level = result[0];
 
-    if (match == null) {
-      break
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
-
-    index += match[0].length;
-    subvalue += match[0];
   }
 
-  if (subvalue === '') {
-    return
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
-  }
+  result[0] = level;
 
-  eat(subvalue);
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var trimTrailingLines_1 = trimTrailingLines;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module ordered-list-marker-style
+ * @fileoverview
+ *   Warn when the list item marker style of ordered lists violate a given style.
+ *
+ *   Options: `'consistent'`, `'.'`, or `')'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used list style and warns when subsequent
+ *   lists use different styles.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   1.  Foo
+ *
+ *
+ *   1.  Bar
+ *
+ *   Unordered lists are not affected by this rule.
+ *
+ *   * Foo
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "."}
+ *
+ *   1.  Foo
+ *
+ *   2.  Bar
+ *
+ * @example
+ *   {"name": "ok.md", "setting": ")"}
+ *
+ *   1)  Foo
+ *
+ *   2)  Bar
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   1.  Foo
+ *
+ *   2)  Bar
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   3:1-3:8: Marker style should be `.`
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "setting": "💩", "positionless": true}
+ *
+ *   1:1: Incorrect ordered list item marker style `💩`: use either `'.'` or `')'`
+ */
 
-var line$1 = '\n';
+const remarkLintOrderedListMarkerStyle = lintRule$A(
+  'remark-lint:ordered-list-marker-style',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    const value = String(file);
+
+    if (option !== 'consistent' && option !== '.' && option !== ')') {
+      file.fail(
+        'Incorrect ordered list item marker style `' +
+          option +
+          "`: use either `'.'` or `')'`"
+      );
+    }
 
-// Remove final newline characters from `value`.
-function trimTrailingLines(value) {
-  var val = String(value);
-  var index = val.length;
+    visit(tree, 'list', (node) => {
+      let index = -1;
 
-  while (val.charAt(--index) === line$1) {
-    // Empty
-  }
+      if (!node.ordered) return
 
-  return val.slice(0, index + 1)
-}
+      while (++index < node.children.length) {
+        const child = node.children[index];
 
-var codeIndented = indentedCode;
+        if (!generated(child)) {
+          const marker = /** @type {Marker} */ (
+            value
+              .slice(
+                pointStart(child).offset,
+                pointStart(child.children[0]).offset
+              )
+              .replace(/\s|\d/g, '')
+              .replace(/\[[x ]?]\s*$/i, '')
+          );
 
-var lineFeed$2 = '\n';
-var tab$1 = '\t';
-var space$1 = ' ';
+          if (option === 'consistent') {
+            option = marker;
+          } else if (marker !== option) {
+            file.message('Marker style should be `' + option + '`', child);
+          }
+        }
+      }
+    });
+  }
+);
 
-var tabSize = 4;
-var codeIndent = repeatString(space$1, tabSize);
+var remarkLintOrderedListMarkerStyle$1 = remarkLintOrderedListMarkerStyle;
 
-function indentedCode(eat, value, silent) {
-  var index = -1;
-  var length = value.length;
-  var subvalue = '';
-  var content = '';
-  var subvalueQueue = '';
-  var contentQueue = '';
-  var character;
-  var blankQueue;
-  var indent;
-
-  while (++index < length) {
-    character = value.charAt(index);
-
-    if (indent) {
-      indent = false;
-
-      subvalue += subvalueQueue;
-      content += contentQueue;
-      subvalueQueue = '';
-      contentQueue = '';
-
-      if (character === lineFeed$2) {
-        subvalueQueue = character;
-        contentQueue = character;
-      } else {
-        subvalue += character;
-        content += character;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-        while (++index < length) {
-          character = value.charAt(index);
+const primitives$z = new Set(['string', 'number', 'boolean']);
 
-          if (!character || character === lineFeed$2) {
-            contentQueue = character;
-            subvalueQueue = character;
-            break
-          }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$z(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-          subvalue += character;
-          content += character;
-        }
-      }
-    } else if (
-      character === space$1 &&
-      value.charAt(index + 1) === character &&
-      value.charAt(index + 2) === character &&
-      value.charAt(index + 3) === character
-    ) {
-      subvalueQueue += codeIndent;
-      index += 3;
-      indent = true;
-    } else if (character === tab$1) {
-      subvalueQueue += character;
-      indent = true;
-    } else {
-      blankQueue = '';
+  Object.defineProperty(plugin, 'name', {value: id});
 
-      while (character === tab$1 || character === space$1) {
-        blankQueue += character;
-        character = value.charAt(++index);
-      }
+  return plugin
 
-      if (character !== lineFeed$2) {
-        break
-      }
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$A(ruleId, raw);
 
-      subvalueQueue += blankQueue + character;
-      contentQueue += character;
-    }
-  }
+    if (!severity) return
 
-  if (content) {
-    if (silent) {
-      return true
-    }
+    const fatal = severity === 2;
 
-    return eat(subvalue)({
-      type: 'code',
-      lang: null,
-      meta: null,
-      value: trimTrailingLines_1(content)
-    })
-  }
-}
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-var codeFenced = fencedCode;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-var lineFeed$3 = '\n';
-var tab$2 = '\t';
-var space$2 = ' ';
-var tilde$1 = '~';
-var graveAccent = '`';
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-var minFenceCount = 3;
-var tabSize$1 = 4;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-function fencedCode(eat, value, silent) {
-  var self = this;
-  var gfm = self.options.gfm;
-  var length = value.length + 1;
-  var index = 0;
-  var subvalue = '';
-  var fenceCount;
-  var marker;
-  var character;
-  var flag;
-  var lang;
-  var meta;
-  var queue;
-  var content;
-  var exdentedContent;
-  var closing;
-  var exdentedClosing;
-  var indent;
-  var now;
-
-  if (!gfm) {
-    return
+        next();
+      })(tree, file, options);
+    }
   }
+}
 
-  // Eat initial spacing.
-  while (index < length) {
-    character = value.charAt(index);
-
-    if (character !== space$2 && character !== tab$2) {
-      break
-    }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$A(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-    subvalue += character;
-    index++;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$z.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  indent = index;
+  let level = result[0];
 
-  // Eat the fence.
-  character = value.charAt(index);
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
+  }
 
-  if (character !== tilde$1 && character !== graveAccent) {
-    return
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  index++;
-  marker = character;
-  fenceCount = 1;
-  subvalue += character;
+  result[0] = level;
 
-  while (index < length) {
-    character = value.charAt(index);
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    if (character !== marker) {
-      break
-    }
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module hard-break-spaces
+ * @fileoverview
+ *   Warn when too many spaces are used to create a hard break.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   Lorem ipsum··
+ *   dolor sit amet
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   Lorem ipsum···
+ *   dolor sit amet.
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:12-2:1: Use two spaces for hard line breaks
+ */
 
-    subvalue += character;
-    fenceCount++;
-    index++;
-  }
+const remarkLintHardBreakSpaces = lintRule$z(
+  'remark-lint:hard-break-spaces',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    const value = String(file);
 
-  if (fenceCount < minFenceCount) {
-    return
+    visit(tree, 'break', (node) => {
+      if (!generated(node)) {
+        const slice = value
+          .slice(pointStart(node).offset, pointEnd(node).offset)
+          .split('\n', 1)[0]
+          .replace(/\r$/, '');
+
+        if (slice.length > 2) {
+          file.message('Use two spaces for hard line breaks', node);
+        }
+      }
+    });
   }
+);
 
-  // Eat spacing before flag.
-  while (index < length) {
-    character = value.charAt(index);
+var remarkLintHardBreakSpaces$1 = remarkLintHardBreakSpaces;
 
-    if (character !== space$2 && character !== tab$2) {
-      break
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    subvalue += character;
-    index++;
-  }
+const primitives$y = new Set(['string', 'number', 'boolean']);
 
-  // Eat flag.
-  flag = '';
-  queue = '';
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$y(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  while (index < length) {
-    character = value.charAt(index);
+  Object.defineProperty(plugin, 'name', {value: id});
 
-    if (
-      character === lineFeed$3 ||
-      (marker === graveAccent && character === marker)
-    ) {
-      break
-    }
+  return plugin
 
-    if (character === space$2 || character === tab$2) {
-      queue += character;
-    } else {
-      flag += queue + character;
-      queue = '';
-    }
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$z(ruleId, raw);
 
-    index++;
-  }
+    if (!severity) return
 
-  character = value.charAt(index);
+    const fatal = severity === 2;
 
-  if (character && character !== lineFeed$3) {
-    return
-  }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  if (silent) {
-    return true
-  }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  now = eat.now();
-  now.column += subvalue.length;
-  now.offset += subvalue.length;
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  subvalue += flag;
-  flag = self.decode.raw(self.unescape(flag), now);
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-  if (queue) {
-    subvalue += queue;
+        next();
+      })(tree, file, options);
+    }
   }
+}
 
-  queue = '';
-  closing = '';
-  exdentedClosing = '';
-  content = '';
-  exdentedContent = '';
-  var skip = true;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$z(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  // Eat content.
-  while (index < length) {
-    character = value.charAt(index);
-    content += closing;
-    exdentedContent += exdentedClosing;
-    closing = '';
-    exdentedClosing = '';
-
-    if (character !== lineFeed$3) {
-      content += character;
-      exdentedClosing += character;
-      index++;
-      continue
-    }
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$y.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-    // The first line feed is ignored. Others aren’t.
-    if (skip) {
-      subvalue += character;
-      skip = false;
+  let level = result[0];
+
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
     } else {
-      closing += character;
-      exdentedClosing += character;
+      level = 1;
+      result = [level, result];
     }
+  }
 
-    queue = '';
-    index++;
-
-    while (index < length) {
-      character = value.charAt(index);
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-      if (character !== space$2) {
-        break
-      }
+  result[0] = level;
 
-      queue += character;
-      index++;
-    }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    closing += queue;
-    exdentedClosing += queue.slice(indent);
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-duplicate-definitions
+ * @fileoverview
+ *   Warn when duplicate definitions are found.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   [foo]: bar
+ *   [baz]: qux
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   [foo]: bar
+ *   [foo]: qux
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   2:1-2:11: Do not use definitions with the same identifier (1:1)
+ */
 
-    if (queue.length >= tabSize$1) {
-      continue
-    }
+const remarkLintNoDuplicateDefinitions = lintRule$y(
+  'remark-lint:no-duplicate-definitions',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    /** @type {Record<string, string>} */
+    const map = Object.create(null);
 
-    queue = '';
+    visit(tree, (node) => {
+      if (
+        (node.type === 'definition' || node.type === 'footnoteDefinition') &&
+        !generated(node)
+      ) {
+        const identifier = node.identifier;
+        const duplicate = map[identifier];
 
-    while (index < length) {
-      character = value.charAt(index);
+        if (duplicate) {
+          file.message(
+            'Do not use definitions with the same identifier (' +
+              duplicate +
+              ')',
+            node
+          );
+        }
 
-      if (character !== marker) {
-        break
+        map[identifier] = stringifyPosition$1(pointStart(node));
       }
+    });
+  }
+);
 
-      queue += character;
-      index++;
-    }
-
-    closing += queue;
-    exdentedClosing += queue;
+var remarkLintNoDuplicateDefinitions$1 = remarkLintNoDuplicateDefinitions;
 
-    if (queue.length < fenceCount) {
-      continue
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    queue = '';
+const primitives$x = new Set(['string', 'number', 'boolean']);
 
-    while (index < length) {
-      character = value.charAt(index);
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$x(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-      if (character !== space$2 && character !== tab$2) {
-        break
-      }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-      closing += character;
-      exdentedClosing += character;
-      index++;
-    }
+  return plugin
 
-    if (!character || character === lineFeed$3) {
-      break
-    }
-  }
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$y(ruleId, raw);
 
-  subvalue += content + closing;
+    if (!severity) return
 
-  // Get lang and meta from the flag.
-  index = -1;
-  length = flag.length;
+    const fatal = severity === 2;
 
-  while (++index < length) {
-    character = flag.charAt(index);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-    if (character === space$2 || character === tab$2) {
-      if (!lang) {
-        lang = flag.slice(0, index);
-      }
-    } else if (lang) {
-      meta = flag.slice(index);
-      break
-    }
-  }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  return eat(subvalue)({
-    type: 'code',
-    lang: lang || flag || null,
-    meta: meta || null,
-    value: exdentedContent
-  })
-}
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-var trim_1 = createCommonjsModule(function (module, exports) {
-exports = module.exports = trim;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-function trim(str){
-  return str.replace(/^\s*|\s*$/g, '');
+        next();
+      })(tree, file, options);
+    }
+  }
 }
 
-exports.left = function(str){
-  return str.replace(/^\s*/, '');
-};
-
-exports.right = function(str){
-  return str.replace(/\s*$/, '');
-};
-});
-var trim_2 = trim_1.left;
-var trim_3 = trim_1.right;
-
-var interrupt_1 = interrupt;
-
-function interrupt(interruptors, tokenizers, ctx, parameters) {
-  var length = interruptors.length;
-  var index = -1;
-  var interruptor;
-  var config;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$y(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  while (++index < length) {
-    interruptor = interruptors[index];
-    config = interruptor[1] || {};
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$x.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-    if (
-      config.pedantic !== undefined &&
-      config.pedantic !== ctx.options.pedantic
-    ) {
-      continue
-    }
+  let level = result[0];
 
-    if (
-      config.commonmark !== undefined &&
-      config.commonmark !== ctx.options.commonmark
-    ) {
-      continue
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
+  }
 
-    if (tokenizers[interruptor[0]].apply(ctx, parameters)) {
-      return true
-    }
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  return false
-}
+  result[0] = level;
 
-var blockquote_1 = blockquote;
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-var lineFeed$4 = '\n';
-var tab$3 = '\t';
-var space$3 = ' ';
-var greaterThan = '>';
+/**
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {'atx'|'atx-closed'|'setext'} Style
+ */
 
-function blockquote(eat, value, silent) {
-  var self = this;
-  var offsets = self.offset;
-  var tokenizers = self.blockTokenizers;
-  var interruptors = self.interruptBlockquote;
-  var now = eat.now();
-  var currentLine = now.line;
-  var length = value.length;
-  var values = [];
-  var contents = [];
-  var indents = [];
-  var add;
-  var index = 0;
-  var character;
-  var rest;
-  var nextIndex;
-  var content;
-  var line;
-  var startIndex;
-  var prefixed;
-  var exit;
+/**
+ * @param {Heading} node
+ * @param {Style} [relative]
+ * @returns {Style|null}
+ */
+function headingStyle(node, relative) {
+  var last = node.children[node.children.length - 1];
+  var depth = node.depth;
+  var pos = node && node.position && node.position.end;
+  var final = last && last.position && last.position.end;
 
-  while (index < length) {
-    character = value.charAt(index);
+  if (!pos) {
+    return null
+  }
 
-    if (character !== space$3 && character !== tab$3) {
-      break
+  // This can only occur for `'atx'` and `'atx-closed'` headings.
+  // This might incorrectly match `'atx'` headings with lots of trailing white
+  // space as an `'atx-closed'` heading.
+  if (!last) {
+    if (pos.column - 1 <= depth * 2) {
+      return consolidate(depth, relative)
     }
 
-    index++;
+    return 'atx-closed'
   }
 
-  if (value.charAt(index) !== greaterThan) {
-    return
+  if (final.line + 1 === pos.line) {
+    return 'setext'
   }
 
-  if (silent) {
-    return true
+  if (final.column + depth < pos.column) {
+    return 'atx-closed'
   }
 
-  index = 0;
-
-  while (index < length) {
-    nextIndex = value.indexOf(lineFeed$4, index);
-    startIndex = index;
-    prefixed = false;
+  return consolidate(depth, relative)
+}
 
-    if (nextIndex === -1) {
-      nextIndex = length;
-    }
+/**
+ * Get the probable style of an atx-heading, depending on preferred style.
+ *
+ * @param {number} depth
+ * @param {Style} relative
+ * @returns {Style|null}
+ */
+function consolidate(depth, relative) {
+  return depth < 3
+    ? 'atx'
+    : relative === 'atx' || relative === 'setext'
+    ? relative
+    : null
+}
 
-    while (index < length) {
-      character = value.charAt(index);
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-heading-content-indent
+ * @fileoverview
+ *   Warn when content of headings is indented.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   removes all unneeded padding around content in headings.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   #·Foo
+ *
+ *   ## Bar·##
+ *
+ *     ##·Baz
+ *
+ *   Setext headings are not affected.
+ *
+ *   Baz
+ *   ===
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   #··Foo
+ *
+ *   ## Bar··##
+ *
+ *     ##··Baz
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:4: Remove 1 space before this heading’s content
+ *   3:7: Remove 1 space after this heading’s content
+ *   5:7: Remove 1 space before this heading’s content
+ *
+ * @example
+ *   {"name": "empty-heading.md"}
+ *
+ *   #··
+ */
 
-      if (character !== space$3 && character !== tab$3) {
-        break
+const remarkLintNoHeadingContentIndent = lintRule$x(
+  'remark-lint:no-heading-content-indent',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, 'heading', (node) => {
+      if (generated(node)) {
+        return
       }
 
-      index++;
-    }
+      const type = headingStyle(node, 'atx');
 
-    if (value.charAt(index) === greaterThan) {
-      index++;
-      prefixed = true;
+      if (type === 'atx' || type === 'atx-closed') {
+        const head = pointStart(node.children[0]).column;
 
-      if (value.charAt(index) === space$3) {
-        index++;
-      }
-    } else {
-      index = startIndex;
-    }
+        // Ignore empty headings.
+        if (!head) {
+          return
+        }
 
-    content = value.slice(index, nextIndex);
+        const diff = head - pointStart(node).column - 1 - node.depth;
 
-    if (!prefixed && !trim_1(content)) {
-      index = startIndex;
-      break
-    }
+        if (diff) {
+          file.message(
+            'Remove ' +
+              Math.abs(diff) +
+              ' ' +
+              plural('space', Math.abs(diff)) +
+              ' before this heading’s content',
+            pointStart(node.children[0])
+          );
+        }
+      }
 
-    if (!prefixed) {
-      rest = value.slice(index);
+      // Closed ATX headings always must have a space between their content and
+      // the final hashes, thus, there is no `add x spaces`.
+      if (type === 'atx-closed') {
+        const final = pointEnd(node.children[node.children.length - 1]);
+        const diff = pointEnd(node).column - final.column - 1 - node.depth;
 
-      // Check if the following code contains a possible block.
-      if (interrupt_1(interruptors, tokenizers, self, [eat, rest, true])) {
-        break
+        if (diff) {
+          file.message(
+            'Remove ' +
+              diff +
+              ' ' +
+              plural('space', diff) +
+              ' after this heading’s content',
+            final
+          );
+        }
       }
-    }
-
-    line = startIndex === index ? content : value.slice(startIndex, nextIndex);
+    });
+  }
+);
 
-    indents.push(index - startIndex);
-    values.push(line);
-    contents.push(content);
+var remarkLintNoHeadingContentIndent$1 = remarkLintNoHeadingContentIndent;
 
-    index = nextIndex + 1;
-  }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  index = -1;
-  length = indents.length;
-  add = eat(values.join(lineFeed$4));
+const primitives$w = new Set(['string', 'number', 'boolean']);
 
-  while (++index < length) {
-    offsets[currentLine] = (offsets[currentLine] || 0) + indents[index];
-    currentLine++;
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$w(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  exit = self.enterBlock();
-  contents = self.tokenizeBlock(contents.join(lineFeed$4), now);
-  exit();
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  return add({type: 'blockquote', children: contents})
-}
+  return plugin
 
-var headingAtx = atxHeading;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$x(ruleId, raw);
 
-var lineFeed$5 = '\n';
-var tab$4 = '\t';
-var space$4 = ' ';
-var numberSign$1 = '#';
+    if (!severity) return
 
-var maxFenceCount = 6;
+    const fatal = severity === 2;
 
-function atxHeading(eat, value, silent) {
-  var self = this;
-  var pedantic = self.options.pedantic;
-  var length = value.length + 1;
-  var index = -1;
-  var now = eat.now();
-  var subvalue = '';
-  var content = '';
-  var character;
-  var queue;
-  var depth;
-
-  // Eat initial spacing.
-  while (++index < length) {
-    character = value.charAt(index);
-
-    if (character !== space$4 && character !== tab$4) {
-      index--;
-      break
-    }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-    subvalue += character;
-  }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  // Eat hashes.
-  depth = 0;
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  while (++index <= length) {
-    character = value.charAt(index);
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (character !== numberSign$1) {
-      index--;
-      break
+        next();
+      })(tree, file, options);
     }
-
-    subvalue += character;
-    depth++;
   }
+}
 
-  if (depth > maxFenceCount) {
-    return
-  }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$x(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if (!depth || (!pedantic && value.charAt(index + 1) === numberSign$1)) {
-    return
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$w.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  length = value.length + 1;
-
-  // Eat intermediate white-space.
-  queue = '';
+  let level = result[0];
 
-  while (++index < length) {
-    character = value.charAt(index);
-
-    if (character !== space$4 && character !== tab$4) {
-      index--;
-      break
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
-
-    queue += character;
   }
 
-  // Exit when not in pedantic mode without spacing.
-  if (!pedantic && queue.length === 0 && character && character !== lineFeed$5) {
-    return
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  if (silent) {
-    return true
-  }
+  result[0] = level;
 
-  // Eat content.
-  subvalue += queue;
-  queue = '';
-  content = '';
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-  while (++index < length) {
-    character = value.charAt(index);
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-inline-padding
+ * @fileoverview
+ *   Warn when phrasing content is padded with spaces between their markers and
+ *   content.
+ *
+ *   Warns for emphasis, strong, delete, image, and link.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   Alpha [bravo](http://echo.fox/trot)
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   Alpha [ bravo ](http://echo.fox/trot)
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:7-1:38: Don’t pad `link` with inner spaces
+ */
 
-    if (!character || character === lineFeed$5) {
-      break
-    }
+const remarkLintNoInlinePadding = lintRule$w(
+  'remark-lint:no-inline-padding',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    // Note: `emphasis`, `strong`, `delete` (GFM) can’t have padding anymore
+    // since CM.
+    visit(tree, (node) => {
+      if (
+        (node.type === 'link' || node.type === 'linkReference') &&
+        !generated(node)
+      ) {
+        const value = toString(node);
 
-    if (character !== space$4 && character !== tab$4 && character !== numberSign$1) {
-      content += queue + character;
-      queue = '';
-      continue
-    }
+        if (value.charAt(0) === ' ' || value.charAt(value.length - 1) === ' ') {
+          file.message('Don’t pad `' + node.type + '` with inner spaces', node);
+        }
+      }
+    });
+  }
+);
 
-    while (character === space$4 || character === tab$4) {
-      queue += character;
-      character = value.charAt(++index);
-    }
+var remarkLintNoInlinePadding$1 = remarkLintNoInlinePadding;
 
-    // `#` without a queue is part of the content.
-    if (!pedantic && content && !queue && character === numberSign$1) {
-      content += character;
-      continue
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    while (character === numberSign$1) {
-      queue += character;
-      character = value.charAt(++index);
-    }
+const primitives$v = new Set(['string', 'number', 'boolean']);
 
-    while (character === space$4 || character === tab$4) {
-      queue += character;
-      character = value.charAt(++index);
-    }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$v(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-    index--;
-  }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  now.column += subvalue.length;
-  now.offset += subvalue.length;
-  subvalue += content + queue;
+  return plugin
 
-  return eat(subvalue)({
-    type: 'heading',
-    depth: depth,
-    children: self.tokenizeInline(content, now)
-  })
-}
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$w(ruleId, raw);
 
-var thematicBreak_1 = thematicBreak;
+    if (!severity) return
 
-var tab$5 = '\t';
-var lineFeed$6 = '\n';
-var space$5 = ' ';
-var asterisk = '*';
-var dash$1 = '-';
-var underscore = '_';
+    const fatal = severity === 2;
 
-var maxCount = 3;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-function thematicBreak(eat, value, silent) {
-  var index = -1;
-  var length = value.length + 1;
-  var subvalue = '';
-  var character;
-  var marker;
-  var markerCount;
-  var queue;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  while (++index < length) {
-    character = value.charAt(index);
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-    if (character !== tab$5 && character !== space$5) {
-      break
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    subvalue += character;
+        next();
+      })(tree, file, options);
+    }
   }
+}
 
-  if (
-    character !== asterisk &&
-    character !== dash$1 &&
-    character !== underscore
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$w(name, value) {
+  /** @type {unknown[]} */
+  let result;
+
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$v.has(typeof value[0])
   ) {
-    return
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  marker = character;
-  subvalue += character;
-  markerCount = 1;
-  queue = '';
-
-  while (++index < length) {
-    character = value.charAt(index);
-
-    if (character === marker) {
-      markerCount++;
-      subvalue += queue + marker;
-      queue = '';
-    } else if (character === space$5) {
-      queue += character;
-    } else if (
-      markerCount >= maxCount &&
-      (!character || character === lineFeed$6)
-    ) {
-      subvalue += queue;
-
-      if (silent) {
-        return true
-      }
+  let level = result[0];
 
-      return eat(subvalue)({type: 'thematicBreak'})
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
     } else {
-      return
+      level = 1;
+      result = [level, result];
     }
   }
-}
-
-var getIndentation = indentation;
-
-var tab$6 = '\t';
-var space$6 = ' ';
 
-var spaceSize = 1;
-var tabSize$2 = 4;
-
-// Gets indentation information for a line.
-function indentation(value) {
-  var index = 0;
-  var indent = 0;
-  var character = value.charAt(index);
-  var stops = {};
-  var size;
-  var lastIndent = 0;
-
-  while (character === tab$6 || character === space$6) {
-    size = character === tab$6 ? tabSize$2 : spaceSize;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-    indent += size;
+  result[0] = level;
 
-    if (size > 1) {
-      indent = Math.floor(indent / size) * size;
-    }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    while (lastIndent < indent) {
-      stops[++lastIndent] = index;
-    }
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-shortcut-reference-image
+ * @fileoverview
+ *   Warn when shortcut reference images are used.
+ *
+ *   Shortcut references render as images when a definition is found, and as
+ *   plain text without definition.
+ *   Sometimes, you don’t intend to create an image from the reference, but this
+ *   rule still warns anyway.
+ *   In that case, you can escape the reference like so: `!\[foo]`.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   ![foo][]
+ *
+ *   [foo]: http://foo.bar/baz.png
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   ![foo]
+ *
+ *   [foo]: http://foo.bar/baz.png
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-1:7: Use the trailing [] on reference images
+ */
 
-    character = value.charAt(++index);
+const remarkLintNoShortcutReferenceImage = lintRule$v(
+  'remark-lint:no-shortcut-reference-image',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, 'imageReference', (node) => {
+      if (!generated(node) && node.referenceType === 'shortcut') {
+        file.message('Use the trailing [] on reference images', node);
+      }
+    });
   }
+);
 
-  return {indent: indent, stops: stops}
-}
+var remarkLintNoShortcutReferenceImage$1 = remarkLintNoShortcutReferenceImage;
 
-var removeIndentation = indentation$1;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-var lineFeed$7 = '\n';
-var space$7 = ' ';
-var exclamationMark = '!';
+const primitives$u = new Set(['string', 'number', 'boolean']);
 
-// Remove the minimum indent from every line in `value`.  Supports both tab,
-// spaced, and mixed indentation (as well as possible).
-function indentation$1(value, maximum) {
-  var values = value.split(lineFeed$7);
-  var position = values.length + 1;
-  var minIndent = Infinity;
-  var matrix = [];
-  var index;
-  var indentation;
-  var stops;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$u(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  values.unshift(repeatString(space$7, maximum) + exclamationMark);
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  while (position--) {
-    indentation = getIndentation(values[position]);
+  return plugin
 
-    matrix[position] = indentation.stops;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$v(ruleId, raw);
 
-    if (trim_1(values[position]).length === 0) {
-      continue
-    }
+    if (!severity) return
 
-    if (indentation.indent) {
-      if (indentation.indent > 0 && indentation.indent < minIndent) {
-        minIndent = indentation.indent;
-      }
-    } else {
-      minIndent = Infinity;
+    const fatal = severity === 2;
 
-      break
-    }
-  }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  if (minIndent !== Infinity) {
-    position = values.length;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-    while (position--) {
-      stops = matrix[position];
-      index = minIndent;
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-      while (index && !(index in stops)) {
-        index--;
-      }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-      values[position] = values[position].slice(stops[index] + 1);
+        next();
+      })(tree, file, options);
     }
   }
-
-  values.shift();
-
-  return values.join(lineFeed$7)
 }
 
-var list_1 = list;
-
-var asterisk$1 = '*';
-var underscore$1 = '_';
-var plusSign = '+';
-var dash$2 = '-';
-var dot$1 = '.';
-var space$8 = ' ';
-var lineFeed$8 = '\n';
-var tab$7 = '\t';
-var rightParenthesis = ')';
-var lowercaseX$1 = 'x';
-
-var tabSize$3 = 4;
-var looseListItemExpression = /\n\n(?!\s*$)/;
-var taskItemExpression = /^\[([ X\tx])][ \t]/;
-var bulletExpression = /^([ \t]*)([*+-]|\d+[.)])( {1,4}(?! )| |\t|$|(?=\n))([^\n]*)/;
-var pedanticBulletExpression = /^([ \t]*)([*+-]|\d+[.)])([ \t]+)/;
-var initialIndentExpression = /^( {1,4}|\t)?/gm;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$v(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-function list(eat, value, silent) {
-  var self = this;
-  var commonmark = self.options.commonmark;
-  var pedantic = self.options.pedantic;
-  var tokenizers = self.blockTokenizers;
-  var interuptors = self.interruptList;
-  var index = 0;
-  var length = value.length;
-  var start = null;
-  var size;
-  var queue;
-  var ordered;
-  var character;
-  var marker;
-  var nextIndex;
-  var startIndex;
-  var prefixed;
-  var currentMarker;
-  var content;
-  var line;
-  var previousEmpty;
-  var empty;
-  var items;
-  var allLines;
-  var emptyLines;
-  var item;
-  var enterTop;
-  var exitBlockquote;
-  var spread = false;
-  var node;
-  var now;
-  var end;
-  var indented;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$u.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-  while (index < length) {
-    character = value.charAt(index);
+  let level = result[0];
 
-    if (character !== tab$7 && character !== space$8) {
-      break
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
+  }
 
-    index++;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  character = value.charAt(index);
+  result[0] = level;
 
-  if (character === asterisk$1 || character === plusSign || character === dash$2) {
-    marker = character;
-    ordered = false;
-  } else {
-    ordered = true;
-    queue = '';
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    while (index < length) {
-      character = value.charAt(index);
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-shortcut-reference-link
+ * @fileoverview
+ *   Warn when shortcut reference links are used.
+ *
+ *   Shortcut references render as links when a definition is found, and as
+ *   plain text without definition.
+ *   Sometimes, you don’t intend to create a link from the reference, but this
+ *   rule still warns anyway.
+ *   In that case, you can escape the reference like so: `\[foo]`.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   [foo][]
+ *
+ *   [foo]: http://foo.bar/baz
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   [foo]
+ *
+ *   [foo]: http://foo.bar/baz
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-1:6: Use the trailing `[]` on reference links
+ */
 
-      if (!isDecimal(character)) {
-        break
+const remarkLintNoShortcutReferenceLink = lintRule$u(
+  'remark-lint:no-shortcut-reference-link',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, 'linkReference', (node) => {
+      if (!generated(node) && node.referenceType === 'shortcut') {
+        file.message('Use the trailing `[]` on reference links', node);
       }
+    });
+  }
+);
 
-      queue += character;
-      index++;
-    }
-
-    character = value.charAt(index);
-
-    if (
-      !queue ||
-      !(character === dot$1 || (commonmark && character === rightParenthesis))
-    ) {
-      return
-    }
+var remarkLintNoShortcutReferenceLink$1 = remarkLintNoShortcutReferenceLink;
 
-    /* Slightly abusing `silent` mode, whose goal is to make interrupting
-     * paragraphs work.
-     * Well, that’s exactly what we want to do here: don’t interrupt:
-     * 2. here, because the “list” doesn’t start with `1`. */
-    if (silent && queue !== '1') {
-      return
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    start = parseInt(queue, 10);
-    marker = character;
-  }
+const primitives$t = new Set(['string', 'number', 'boolean']);
 
-  character = value.charAt(++index);
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$t(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  if (
-    character !== space$8 &&
-    character !== tab$7 &&
-    (pedantic || (character !== lineFeed$8 && character !== ''))
-  ) {
-    return
-  }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  if (silent) {
-    return true
-  }
+  return plugin
 
-  index = 0;
-  items = [];
-  allLines = [];
-  emptyLines = [];
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$u(ruleId, raw);
 
-  while (index < length) {
-    nextIndex = value.indexOf(lineFeed$8, index);
-    startIndex = index;
-    prefixed = false;
-    indented = false;
+    if (!severity) return
 
-    if (nextIndex === -1) {
-      nextIndex = length;
-    }
+    const fatal = severity === 2;
 
-    size = 0;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-    while (index < length) {
-      character = value.charAt(index);
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-      if (character === tab$7) {
-        size += tabSize$3 - (size % tabSize$3);
-      } else if (character === space$8) {
-        size++;
-      } else {
-        break
-      }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-      index++;
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (item && size >= item.indent) {
-      indented = true;
+        next();
+      })(tree, file, options);
     }
+  }
+}
 
-    character = value.charAt(index);
-    currentMarker = null;
-
-    if (!indented) {
-      if (
-        character === asterisk$1 ||
-        character === plusSign ||
-        character === dash$2
-      ) {
-        currentMarker = character;
-        index++;
-        size++;
-      } else {
-        queue = '';
-
-        while (index < length) {
-          character = value.charAt(index);
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$u(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-          if (!isDecimal(character)) {
-            break
-          }
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$t.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-          queue += character;
-          index++;
-        }
+  let level = result[0];
 
-        character = value.charAt(index);
-        index++;
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
+  }
 
-        if (
-          queue &&
-          (character === dot$1 || (commonmark && character === rightParenthesis))
-        ) {
-          currentMarker = character;
-          size += queue.length + 1;
-        }
-      }
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-      if (currentMarker) {
-        character = value.charAt(index);
+  result[0] = level;
 
-        if (character === tab$7) {
-          size += tabSize$3 - (size % tabSize$3);
-          index++;
-        } else if (character === space$8) {
-          end = index + tabSize$3;
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-          while (index < end) {
-            if (value.charAt(index) !== space$8) {
-              break
-            }
+/**
+ * @author Titus Wormer
+ * @copyright 2016 Titus Wormer
+ * @license MIT
+ * @module no-undefined-references
+ * @fileoverview
+ *   Warn when references to undefined definitions are found.
+ *
+ *   Options: `Object`, optional.
+ *
+ *   The object can have an `allow` field, set to an array of strings that may
+ *   appear between `[` and `]`, but that should not be treated as link
+ *   identifiers.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   [foo][]
+ *
+ *   Just a [ bracket.
+ *
+ *   Typically, you’d want to use escapes (with a backslash: \\) to escape what
+ *   could turn into a \[reference otherwise].
+ *
+ *   Just two braces can’t link: [].
+ *
+ *   [foo]: https://example.com
+ *
+ * @example
+ *   {"name": "ok-allow.md", "setting": {"allow": ["...", "…"]}}
+ *
+ *   > Eliding a portion of a quoted passage […] is acceptable.
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   [bar]
+ *
+ *   [baz][]
+ *
+ *   [text][qux]
+ *
+ *   Spread [over
+ *   lines][]
+ *
+ *   > in [a
+ *   > block quote][]
+ *
+ *   [asd][a
+ *
+ *   Can include [*emphasis*].
+ *
+ *   Multiple pairs: [a][b][c].
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-1:6: Found reference to undefined definition
+ *   3:1-3:8: Found reference to undefined definition
+ *   5:1-5:12: Found reference to undefined definition
+ *   7:8-8:9: Found reference to undefined definition
+ *   10:6-11:17: Found reference to undefined definition
+ *   13:1-13:6: Found reference to undefined definition
+ *   15:13-15:25: Found reference to undefined definition
+ *   17:17-17:23: Found reference to undefined definition
+ *   17:23-17:26: Found reference to undefined definition
+ */
 
-            index++;
-            size++;
-          }
+const remarkLintNoUndefinedReferences = lintRule$t(
+  'remark-lint:no-undefined-references',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = {}) => {
+    const contents = String(file);
+    const loc = location(file);
+    const lineEnding = /(\r?\n|\r)[\t ]*(>[\t ]*)*/g;
+    const allow = new Set(
+      (option.allow || []).map((d) => normalizeIdentifier(d))
+    );
+    /** @type {Record<string, boolean>} */
+    const map = Object.create(null);
 
-          if (index === end && value.charAt(index) === space$8) {
-            index -= tabSize$3 - 1;
-            size -= tabSize$3 - 1;
-          }
-        } else if (character !== lineFeed$8 && character !== '') {
-          currentMarker = null;
-        }
+    visit(tree, (node) => {
+      if (
+        (node.type === 'definition' || node.type === 'footnoteDefinition') &&
+        !generated(node)
+      ) {
+        map[normalizeIdentifier(node.identifier)] = true;
       }
-    }
+    });
 
-    if (currentMarker) {
-      if (!pedantic && marker !== currentMarker) {
-        break
+    visit(tree, (node) => {
+      // CM specifiers that references only form when defined.
+      // Still, they could be added by plugins, so let’s keep it.
+      /* c8 ignore next 10 */
+      if (
+        (node.type === 'imageReference' ||
+          node.type === 'linkReference' ||
+          node.type === 'footnoteReference') &&
+        !generated(node) &&
+        !(normalizeIdentifier(node.identifier) in map) &&
+        !allow.has(normalizeIdentifier(node.identifier))
+      ) {
+        file.message('Found reference to undefined definition', node);
       }
 
-      prefixed = true;
-    } else {
-      if (!commonmark && !indented && value.charAt(startIndex) === space$8) {
-        indented = true;
-      } else if (commonmark && item) {
-        indented = size >= item.indent || size > tabSize$3;
+      if (node.type === 'paragraph' || node.type === 'heading') {
+        findInPhrasing(node);
       }
+    });
 
-      prefixed = false;
-      index = startIndex;
-    }
-
-    line = value.slice(startIndex, nextIndex);
-    content = startIndex === index ? line : value.slice(index, nextIndex);
+    /**
+     * @param {Heading|Paragraph} node
+     */
+    function findInPhrasing(node) {
+      /** @type {Range[]} */
+      let ranges = [];
 
-    if (
-      currentMarker === asterisk$1 ||
-      currentMarker === underscore$1 ||
-      currentMarker === dash$2
-    ) {
-      if (tokenizers.thematicBreak.call(self, eat, line, true)) {
-        break
-      }
-    }
+      visit(node, (child) => {
+        // Ignore the node itself.
+        if (child === node) return
 
-    previousEmpty = empty;
-    empty = !prefixed && !trim_1(content).length;
+        // Can’t have links in links, so reset ranges.
+        if (child.type === 'link' || child.type === 'linkReference') {
+          ranges = [];
+          return SKIP$1
+        }
 
-    if (indented && item) {
-      item.value = item.value.concat(emptyLines, line);
-      allLines = allLines.concat(emptyLines, line);
-      emptyLines = [];
-    } else if (prefixed) {
-      if (emptyLines.length !== 0) {
-        spread = true;
-        item.value.push('');
-        item.trail = emptyLines.concat();
-      }
+        // Enter non-text.
+        if (child.type !== 'text') return
 
-      item = {
-        value: [line],
-        indent: size,
-        trail: []
-      };
+        const start = pointStart(child).offset;
+        const end = pointEnd(child).offset;
 
-      items.push(item);
-      allLines = allLines.concat(emptyLines, line);
-      emptyLines = [];
-    } else if (empty) {
-      if (previousEmpty && !commonmark) {
-        break
-      }
+        // Bail if there’s no positional info.
+        if (typeof start !== 'number' || typeof end !== 'number') {
+          return EXIT$1
+        }
 
-      emptyLines.push(line);
-    } else {
-      if (previousEmpty) {
-        break
-      }
+        const source = contents.slice(start, end);
+        /** @type {Array.<[number, string]>} */
+        const lines = [[start, '']];
+        let last = 0;
 
-      if (interrupt_1(interuptors, tokenizers, self, [eat, line, true])) {
-        break
-      }
+        lineEnding.lastIndex = 0;
+        let match = lineEnding.exec(source);
 
-      item.value = item.value.concat(emptyLines, line);
-      allLines = allLines.concat(emptyLines, line);
-      emptyLines = [];
-    }
+        while (match) {
+          const index = match.index;
+          lines[lines.length - 1][1] = source.slice(last, index);
+          last = index + match[0].length;
+          lines.push([start + last, '']);
+          match = lineEnding.exec(source);
+        }
 
-    index = nextIndex + 1;
-  }
+        lines[lines.length - 1][1] = source.slice(last);
+        let lineIndex = -1;
 
-  node = eat(allLines.join(lineFeed$8)).reset({
-    type: 'list',
-    ordered: ordered,
-    start: start,
-    spread: spread,
-    children: []
-  });
+        while (++lineIndex < lines.length) {
+          const line = lines[lineIndex][1];
+          let index = 0;
 
-  enterTop = self.enterList();
-  exitBlockquote = self.enterBlock();
-  index = -1;
-  length = items.length;
+          while (index < line.length) {
+            const code = line.charCodeAt(index);
 
-  while (++index < length) {
-    item = items[index].value.join(lineFeed$8);
-    now = eat.now();
+            // Skip past escaped brackets.
+            if (code === 92) {
+              const next = line.charCodeAt(index + 1);
+              index++;
 
-    eat(item)(listItem(self, item, now), node);
+              if (next === 91 || next === 93) {
+                index++;
+              }
+            }
+            // Opening bracket.
+            else if (code === 91) {
+              ranges.push([lines[lineIndex][0] + index]);
+              index++;
+            }
+            // Close bracket.
+            else if (code === 93) {
+              // No opening.
+              if (ranges.length === 0) {
+                index++;
+              } else if (line.charCodeAt(index + 1) === 91) {
+                index++;
+
+                // Collapsed or full.
+                let range = ranges.pop();
+
+                // Range should always exist.
+                // eslint-disable-next-line max-depth
+                if (range) {
+                  range.push(lines[lineIndex][0] + index);
+
+                  // This is the end of a reference already.
+                  // eslint-disable-next-line max-depth
+                  if (range.length === 4) {
+                    handleRange(range);
+                    range = [];
+                  }
+
+                  range.push(lines[lineIndex][0] + index);
+                  ranges.push(range);
+                  index++;
+                }
+              } else {
+                index++;
 
-    item = items[index].trail.join(lineFeed$8);
+                // Shortcut or typical end of a reference.
+                const range = ranges.pop();
 
-    if (index !== length - 1) {
-      item += lineFeed$8;
-    }
+                // Range should always exist.
+                // eslint-disable-next-line max-depth
+                if (range) {
+                  range.push(lines[lineIndex][0] + index);
+                  handleRange(range);
+                }
+              }
+            }
+            // Anything else.
+            else {
+              index++;
+            }
+          }
+        }
+      });
 
-    eat(item);
-  }
+      let index = -1;
 
-  enterTop();
-  exitBlockquote();
+      while (++index < ranges.length) {
+        handleRange(ranges[index]);
+      }
 
-  return node
-}
+      return SKIP$1
 
-function listItem(ctx, value, position) {
-  var offsets = ctx.offset;
-  var fn = ctx.options.pedantic ? pedanticListItem : normalListItem;
-  var checked = null;
-  var task;
-  var indent;
+      /**
+       * @param {Range} range
+       */
+      function handleRange(range) {
+        if (range.length === 1) return
+        if (range.length === 3) range.length = 2;
 
-  value = fn.apply(null, arguments);
+        // No need to warn for just `[]`.
+        if (range.length === 2 && range[0] + 2 === range[1]) return
 
-  if (ctx.options.gfm) {
-    task = value.match(taskItemExpression);
+        const offset = range.length === 4 && range[2] + 2 !== range[3] ? 2 : 0;
+        const id = contents
+          .slice(range[0 + offset] + 1, range[1 + offset] - 1)
+          .replace(lineEnding, ' ');
+        const pos = {
+          start: loc.toPoint(range[0]),
+          end: loc.toPoint(range[range.length - 1])
+        };
 
-    if (task) {
-      indent = task[0].length;
-      checked = task[1].toLowerCase() === lowercaseX$1;
-      offsets[position.line] += indent;
-      value = value.slice(indent);
+        if (
+          !generated({position: pos}) &&
+          !(normalizeIdentifier(id) in map) &&
+          !allow.has(normalizeIdentifier(id))
+        ) {
+          file.message('Found reference to undefined definition', pos);
+        }
+      }
     }
   }
+);
 
-  return {
-    type: 'listItem',
-    spread: looseListItemExpression.test(value),
-    checked: checked,
-    children: ctx.tokenizeBlock(value, position)
-  }
-}
-
-// Create a list-item using overly simple mechanics.
-function pedanticListItem(ctx, value, position) {
-  var offsets = ctx.offset;
-  var line = position.line;
-
-  // Remove the list-item’s bullet.
-  value = value.replace(pedanticBulletExpression, replacer);
-
-  // The initial line was also matched by the below, so we reset the `line`.
-  line = position.line;
-
-  return value.replace(initialIndentExpression, replacer)
+var remarkLintNoUndefinedReferences$1 = remarkLintNoUndefinedReferences;
 
-  // A simple replacer which removed all matches, and adds their length to
-  // `offset`.
-  function replacer($0) {
-    offsets[line] = (offsets[line] || 0) + $0.length;
-    line++;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    return ''
-  }
-}
+const primitives$s = new Set(['string', 'number', 'boolean']);
 
-// Create a list-item using sane mechanics.
-function normalListItem(ctx, value, position) {
-  var offsets = ctx.offset;
-  var line = position.line;
-  var max;
-  var bullet;
-  var rest;
-  var lines;
-  var trimmedLines;
-  var index;
-  var length;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$s(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  // Remove the list-item’s bullet.
-  value = value.replace(bulletExpression, replacer);
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  lines = value.split(lineFeed$8);
+  return plugin
 
-  trimmedLines = removeIndentation(value, getIndentation(max).indent).split(lineFeed$8);
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$t(ruleId, raw);
 
-  // We replaced the initial bullet with something else above, which was used
-  // to trick `removeIndentation` into removing some more characters when
-  // possible.  However, that could result in the initial line to be stripped
-  // more than it should be.
-  trimmedLines[0] = rest;
+    if (!severity) return
 
-  offsets[line] = (offsets[line] || 0) + bullet.length;
-  line++;
+    const fatal = severity === 2;
 
-  index = 0;
-  length = lines.length;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  while (++index < length) {
-    offsets[line] =
-      (offsets[line] || 0) + lines[index].length - trimmedLines[index].length;
-    line++;
-  }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  return trimmedLines.join(lineFeed$8)
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  /* eslint-disable-next-line max-params */
-  function replacer($0, $1, $2, $3, $4) {
-    bullet = $1 + $2 + $3;
-    rest = $4;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    // Make sure that the first nine numbered list items can indent with an
-    // extra space.  That is, when the bullet did not receive an extra final
-    // space.
-    if (Number($2) < 10 && bullet.length % 2 === 1) {
-      $2 = space$8 + $2;
+        next();
+      })(tree, file, options);
     }
-
-    max = $1 + repeatString(space$8, $2.length) + $3;
-
-    return max + rest
   }
 }
 
-var headingSetext = setextHeading;
-
-var lineFeed$9 = '\n';
-var tab$8 = '\t';
-var space$9 = ' ';
-var equalsTo$1 = '=';
-var dash$3 = '-';
-
-var maxIndent = 3;
-
-var equalsToDepth = 1;
-var dashDepth = 2;
-
-function setextHeading(eat, value, silent) {
-  var self = this;
-  var now = eat.now();
-  var length = value.length;
-  var index = -1;
-  var subvalue = '';
-  var content;
-  var queue;
-  var character;
-  var marker;
-  var depth;
-
-  // Eat initial indentation.
-  while (++index < length) {
-    character = value.charAt(index);
-
-    if (character !== space$9 || index >= maxIndent) {
-      index--;
-      break
-    }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$t(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-    subvalue += character;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$s.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  // Eat content.
-  content = '';
-  queue = '';
-
-  while (++index < length) {
-    character = value.charAt(index);
-
-    if (character === lineFeed$9) {
-      index--;
-      break
-    }
+  let level = result[0];
 
-    if (character === space$9 || character === tab$8) {
-      queue += character;
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
     } else {
-      content += queue + character;
-      queue = '';
+      level = 1;
+      result = [level, result];
     }
   }
 
-  now.column += subvalue.length;
-  now.offset += subvalue.length;
-  subvalue += content + queue;
-
-  // Ensure the content is followed by a newline and a valid marker.
-  character = value.charAt(++index);
-  marker = value.charAt(++index);
-
-  if (character !== lineFeed$9 || (marker !== equalsTo$1 && marker !== dash$3)) {
-    return
-  }
-
-  subvalue += character;
-
-  // Eat Setext-line.
-  queue = marker;
-  depth = marker === equalsTo$1 ? equalsToDepth : dashDepth;
-
-  while (++index < length) {
-    character = value.charAt(index);
-
-    if (character !== marker) {
-      if (character !== lineFeed$9) {
-        return
-      }
-
-      index--;
-      break
-    }
-
-    queue += character;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  if (silent) {
-    return true
-  }
+  result[0] = level;
 
-  return eat(subvalue + queue)({
-    type: 'heading',
-    depth: depth,
-    children: self.tokenizeInline(content, now)
-  })
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var attributeName = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
-var unquoted = '[^"\'=<>`\\u0000-\\u0020]+';
-var singleQuoted = "'[^']*'";
-var doubleQuoted = '"[^"]*"';
-var attributeValue =
-  '(?:' + unquoted + '|' + singleQuoted + '|' + doubleQuoted + ')';
-var attribute =
-  '(?:\\s+' + attributeName + '(?:\\s*=\\s*' + attributeValue + ')?)';
-var openTag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
-var closeTag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
-var comment = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';
-var processing = '<[?].*?[?]>';
-var declaration = '<![A-Za-z]+\\s+[^>]*>';
-var cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
-
-var openCloseTag = new RegExp('^(?:' + openTag + '|' + closeTag + ')');
-
-var tag = new RegExp(
-  '^(?:' +
-    openTag +
-    '|' +
-    closeTag +
-    '|' +
-    comment +
-    '|' +
-    processing +
-    '|' +
-    declaration +
-    '|' +
-    cdata +
-    ')'
-);
-
-var html = {
-	openCloseTag: openCloseTag,
-	tag: tag
-};
-
-var openCloseTag$1 = html.openCloseTag;
-
-var htmlBlock = blockHtml;
-
-var tab$9 = '\t';
-var space$a = ' ';
-var lineFeed$a = '\n';
-var lessThan$1 = '<';
-
-var rawOpenExpression = /^<(script|pre|style)(?=(\s|>|$))/i;
-var rawCloseExpression = /<\/(script|pre|style)>/i;
-var commentOpenExpression = /^<!--/;
-var commentCloseExpression = /-->/;
-var instructionOpenExpression = /^<\?/;
-var instructionCloseExpression = /\?>/;
-var directiveOpenExpression = /^<![A-Za-z]/;
-var directiveCloseExpression = />/;
-var cdataOpenExpression = /^<!\[CDATA\[/;
-var cdataCloseExpression = /]]>/;
-var elementCloseExpression = /^$/;
-var otherElementOpenExpression = new RegExp(openCloseTag$1.source + '\\s*$');
-
-function blockHtml(eat, value, silent) {
-  var self = this;
-  var blocks = self.options.blocks.join('|');
-  var elementOpenExpression = new RegExp(
-    '^</?(' + blocks + ')(?=(\\s|/?>|$))',
-    'i'
-  );
-  var length = value.length;
-  var index = 0;
-  var next;
-  var line;
-  var offset;
-  var character;
-  var count;
-  var sequence;
-  var subvalue;
-
-  var sequences = [
-    [rawOpenExpression, rawCloseExpression, true],
-    [commentOpenExpression, commentCloseExpression, true],
-    [instructionOpenExpression, instructionCloseExpression, true],
-    [directiveOpenExpression, directiveCloseExpression, true],
-    [cdataOpenExpression, cdataCloseExpression, true],
-    [elementOpenExpression, elementCloseExpression, true],
-    [otherElementOpenExpression, elementCloseExpression, false]
-  ];
-
-  // Eat initial spacing.
-  while (index < length) {
-    character = value.charAt(index);
-
-    if (character !== tab$9 && character !== space$a) {
-      break
-    }
-
-    index++;
-  }
+/**
+ * @author Titus Wormer
+ * @copyright 2016 Titus Wormer
+ * @license MIT
+ * @module no-unused-definitions
+ * @fileoverview
+ *   Warn when unused definitions are found.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   [foo][]
+ *
+ *   [foo]: https://example.com
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   [bar]: https://example.com
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-1:27: Found unused definition
+ */
 
-  if (value.charAt(index) !== lessThan$1) {
-    return
-  }
+const own$1 = {}.hasOwnProperty;
 
-  next = value.indexOf(lineFeed$a, index + 1);
-  next = next === -1 ? length : next;
-  line = value.slice(index, next);
-  offset = -1;
-  count = sequences.length;
+const remarkLintNoUnusedDefinitions = lintRule$s(
+  'remark-lint:no-unused-definitions',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    /** @type {Record<string, {node: DefinitionContent, used: boolean}>} */
+    const map = Object.create(null);
 
-  while (++offset < count) {
-    if (sequences[offset][0].test(line)) {
-      sequence = sequences[offset];
-      break
-    }
-  }
+    visit(tree, (node) => {
+      if (
+        (node.type === 'definition' || node.type === 'footnoteDefinition') &&
+        !generated(node)
+      ) {
+        map[node.identifier.toUpperCase()] = {node, used: false};
+      }
+    });
 
-  if (!sequence) {
-    return
-  }
+    visit(tree, (node) => {
+      if (
+        node.type === 'imageReference' ||
+        node.type === 'linkReference' ||
+        node.type === 'footnoteReference'
+      ) {
+        const info = map[node.identifier.toUpperCase()];
 
-  if (silent) {
-    return sequence[2]
-  }
+        if (!generated(node) && info) {
+          info.used = true;
+        }
+      }
+    });
 
-  index = next;
+    /** @type {string} */
+    let identifier;
 
-  if (!sequence[1].test(line)) {
-    while (index < length) {
-      next = value.indexOf(lineFeed$a, index + 1);
-      next = next === -1 ? length : next;
-      line = value.slice(index + 1, next);
+    for (identifier in map) {
+      if (own$1.call(map, identifier)) {
+        const entry = map[identifier];
 
-      if (sequence[1].test(line)) {
-        if (line) {
-          index = next;
+        if (!entry.used) {
+          file.message('Found unused definition', entry.node);
         }
-
-        break
       }
-
-      index = next;
     }
   }
+);
 
-  subvalue = value.slice(0, index);
-
-  return eat(subvalue)({type: 'html', value: subvalue})
-}
-
-var isWhitespaceCharacter = whitespace;
+var remarkLintNoUnusedDefinitions$1 = remarkLintNoUnusedDefinitions;
 
-var fromCode = String.fromCharCode;
-var re$1 = /\s/;
+/**
+ * @fileoverview
+ *   remark preset to configure `remark-lint` with settings that prevent
+ *   mistakes or stuff that fails across vendors.
+ */
 
-// Check if the given character code, or the character code at the first
-// character, is a whitespace character.
-function whitespace(character) {
-  return re$1.test(
-    typeof character === 'number' ? fromCode(character) : character.charAt(0)
-  )
-}
+const plugins$1 = [
+  remarkLint,
+  // Unix compatibility.
+  remarkLintFinalNewline$1,
+  // Rendering across vendors differs greatly if using other styles.
+  remarkLintListItemBulletIndent$1,
+  [remarkLintListItemIndent$1, 'tab-size'],
+  // Differs or unsupported across vendors.
+  remarkLintNoAutoLinkWithoutProtocol$1,
+  remarkLintNoBlockquoteWithoutMarker$1,
+  remarkLintNoLiteralUrls$1,
+  [remarkLintOrderedListMarkerStyle$1, '.'],
+  // Mistakes.
+  remarkLintHardBreakSpaces$1,
+  remarkLintNoDuplicateDefinitions$1,
+  remarkLintNoHeadingContentIndent$1,
+  remarkLintNoInlinePadding$1,
+  remarkLintNoShortcutReferenceImage$1,
+  remarkLintNoShortcutReferenceLink$1,
+  remarkLintNoUndefinedReferences$1,
+  remarkLintNoUnusedDefinitions$1
+];
 
-var collapseWhiteSpace = collapse;
+const remarkPresetLintRecommended = {plugins: plugins$1};
 
-// `collapse(' \t\nbar \nbaz\t') // ' bar baz '`
-function collapse(value) {
-  return String(value).replace(/\s+/g, ' ')
-}
+var remarkPresetLintRecommended$1 = remarkPresetLintRecommended;
 
-var normalize_1 = normalize$2;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-// Normalize an identifier.  Collapses multiple white space characters into a
-// single space, and removes casing.
-function normalize$2(value) {
-  return collapseWhiteSpace(value).toLowerCase()
-}
+const primitives$r = new Set(['string', 'number', 'boolean']);
 
-var definition_1 = definition;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$r(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-var quotationMark = '"';
-var apostrophe = "'";
-var backslash$2 = '\\';
-var lineFeed$b = '\n';
-var tab$a = '\t';
-var space$b = ' ';
-var leftSquareBracket = '[';
-var rightSquareBracket = ']';
-var leftParenthesis = '(';
-var rightParenthesis$1 = ')';
-var colon$1 = ':';
-var lessThan$2 = '<';
-var greaterThan$1 = '>';
+  Object.defineProperty(plugin, 'name', {value: id});
 
-function definition(eat, value, silent) {
-  var self = this;
-  var commonmark = self.options.commonmark;
-  var index = 0;
-  var length = value.length;
-  var subvalue = '';
-  var beforeURL;
-  var beforeTitle;
-  var queue;
-  var character;
-  var test;
-  var identifier;
-  var url;
-  var title;
+  return plugin
 
-  while (index < length) {
-    character = value.charAt(index);
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$s(ruleId, raw);
 
-    if (character !== space$b && character !== tab$a) {
-      break
-    }
+    if (!severity) return
 
-    subvalue += character;
-    index++;
-  }
+    const fatal = severity === 2;
 
-  character = value.charAt(index);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  if (character !== leftSquareBracket) {
-    return
-  }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  index++;
-  subvalue += character;
-  queue = '';
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  while (index < length) {
-    character = value.charAt(index);
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (character === rightSquareBracket) {
-      break
-    } else if (character === backslash$2) {
-      queue += character;
-      index++;
-      character = value.charAt(index);
+        next();
+      })(tree, file, options);
     }
-
-    queue += character;
-    index++;
   }
+}
 
-  if (
-    !queue ||
-    value.charAt(index) !== rightSquareBracket ||
-    value.charAt(index + 1) !== colon$1
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$s(name, value) {
+  /** @type {unknown[]} */
+  let result;
+
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$r.has(typeof value[0])
   ) {
-    return
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  identifier = queue;
-  subvalue += queue + rightSquareBracket + colon$1;
-  index = subvalue.length;
-  queue = '';
+  let level = result[0];
 
-  while (index < length) {
-    character = value.charAt(index);
-
-    if (character !== tab$a && character !== space$b && character !== lineFeed$b) {
-      break
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
-
-    subvalue += character;
-    index++;
   }
 
-  character = value.charAt(index);
-  queue = '';
-  beforeURL = subvalue;
-
-  if (character === lessThan$2) {
-    index++;
-
-    while (index < length) {
-      character = value.charAt(index);
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-      if (!isEnclosedURLCharacter(character)) {
-        break
-      }
+  result[0] = level;
 
-      queue += character;
-      index++;
-    }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    character = value.charAt(index);
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module blockquote-indentation
+ * @fileoverview
+ *   Warn when block quotes are indented too much or too little.
+ *
+ *   Options: `number` or `'consistent'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used indentation and will warn when
+ *   other block quotes use a different indentation.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": 4}
+ *
+ *   >   Hello
+ *
+ *   Paragraph.
+ *
+ *   >   World
+ * @example
+ *   {"name": "ok.md", "setting": 2}
+ *
+ *   > Hello
+ *
+ *   Paragraph.
+ *
+ *   > World
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   >  Hello
+ *
+ *   Paragraph.
+ *
+ *   >   World
+ *
+ *   Paragraph.
+ *
+ *   > World
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   5:5: Remove 1 space between block quote and content
+ *   9:3: Add 1 space between block quote and content
+ */
 
-    if (character === isEnclosedURLCharacter.delimiter) {
-      subvalue += lessThan$2 + queue + character;
-      index++;
-    } else {
-      if (commonmark) {
+const remarkLintBlockquoteIndentation = lintRule$r(
+  'remark-lint:blockquote-indentation',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    visit(tree, 'blockquote', (node) => {
+      if (generated(node) || node.children.length === 0) {
         return
       }
 
-      index -= queue.length + 1;
-      queue = '';
-    }
-  }
+      if (option === 'consistent') {
+        option = check(node);
+      } else {
+        const diff = option - check(node);
 
-  if (!queue) {
-    while (index < length) {
-      character = value.charAt(index);
+        if (diff !== 0) {
+          const abs = Math.abs(diff);
 
-      if (!isUnclosedURLCharacter(character)) {
-        break
+          file.message(
+            (diff > 0 ? 'Add' : 'Remove') +
+              ' ' +
+              abs +
+              ' ' +
+              plural('space', abs) +
+              ' between block quote and content',
+            pointStart(node.children[0])
+          );
+        }
       }
-
-      queue += character;
-      index++;
-    }
-
-    subvalue += queue;
+    });
   }
+);
 
-  if (!queue) {
-    return
-  }
+var remarkLintBlockquoteIndentation$1 = remarkLintBlockquoteIndentation;
 
-  url = queue;
-  queue = '';
+/**
+ * @param {Blockquote} node
+ * @returns {number}
+ */
+function check(node) {
+  return pointStart(node.children[0]).column - pointStart(node).column
+}
 
-  while (index < length) {
-    character = value.charAt(index);
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    if (character !== tab$a && character !== space$b && character !== lineFeed$b) {
-      break
-    }
+const primitives$q = new Set(['string', 'number', 'boolean']);
 
-    queue += character;
-    index++;
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$q(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  character = value.charAt(index);
-  test = null;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  if (character === quotationMark) {
-    test = quotationMark;
-  } else if (character === apostrophe) {
-    test = apostrophe;
-  } else if (character === leftParenthesis) {
-    test = rightParenthesis$1;
-  }
+  return plugin
 
-  if (!test) {
-    queue = '';
-    index = subvalue.length;
-  } else if (queue) {
-    subvalue += queue + character;
-    index = subvalue.length;
-    queue = '';
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$r(ruleId, raw);
 
-    while (index < length) {
-      character = value.charAt(index);
+    if (!severity) return
 
-      if (character === test) {
-        break
-      }
+    const fatal = severity === 2;
 
-      if (character === lineFeed$b) {
-        index++;
-        character = value.charAt(index);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-        if (character === lineFeed$b || character === test) {
-          return
+      wrap(rule, (error) => {
+        const messages = file.messages;
+
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
 
-        queue += lineFeed$b;
-      }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-      queue += character;
-      index++;
+        next();
+      })(tree, file, options);
     }
+  }
+}
 
-    character = value.charAt(index);
-
-    if (character !== test) {
-      return
-    }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$r(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-    beforeTitle = subvalue;
-    subvalue += queue + character;
-    index++;
-    title = queue;
-    queue = '';
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$q.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
   } else {
-    return
+    result = [1, value];
   }
 
-  while (index < length) {
-    character = value.charAt(index);
+  let level = result[0];
 
-    if (character !== tab$a && character !== space$b) {
-      break
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
+  }
 
-    subvalue += character;
-    index++;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  character = value.charAt(index);
+  result[0] = level;
 
-  if (!character || character === lineFeed$b) {
-    if (silent) {
-      return true
-    }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    beforeURL = eat(beforeURL).test().end;
-    url = self.decode.raw(self.unescape(url), beforeURL, {nonTerminated: false});
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module checkbox-character-style
+ * @fileoverview
+ *   Warn when list item checkboxes violate a given style.
+ *
+ *   Options: `Object` or `'consistent'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used checked and unchecked checkbox
+ *   styles and warns when subsequent checkboxes use different styles.
+ *
+ *   Styles can also be passed in like so:
+ *
+ *   ```js
+ *   {checked: 'x', unchecked: ' '}
+ *   ```
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   formats checked checkboxes using `x` (lowercase X) and unchecked checkboxes
+ *   as `·` (a single space).
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": {"checked": "x"}, "gfm": true}
+ *
+ *   - [x] List item
+ *   - [x] List item
+ *
+ * @example
+ *   {"name": "ok.md", "setting": {"checked": "X"}, "gfm": true}
+ *
+ *   - [X] List item
+ *   - [X] List item
+ *
+ * @example
+ *   {"name": "ok.md", "setting": {"unchecked": " "}, "gfm": true}
+ *
+ *   - [ ] List item
+ *   - [ ] List item
+ *   - [ ]··
+ *   - [ ]
+ *
+ * @example
+ *   {"name": "ok.md", "setting": {"unchecked": "\t"}, "gfm": true}
+ *
+ *   - [»] List item
+ *   - [»] List item
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input", "gfm": true}
+ *
+ *   - [x] List item
+ *   - [X] List item
+ *   - [ ] List item
+ *   - [»] List item
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "gfm": true}
+ *
+ *   2:5: Checked checkboxes should use `x` as a marker
+ *   4:5: Unchecked checkboxes should use ` ` as a marker
+ *
+ * @example
+ *   {"setting": {"unchecked": "💩"}, "name": "not-ok.md", "label": "output", "positionless": true, "gfm": true}
+ *
+ *   1:1: Incorrect unchecked checkbox marker `💩`: use either `'\t'`, or `' '`
+ *
+ * @example
+ *   {"setting": {"checked": "💩"}, "name": "not-ok.md", "label": "output", "positionless": true, "gfm": true}
+ *
+ *   1:1: Incorrect checked checkbox marker `💩`: use either `'x'`, or `'X'`
+ */
 
-    if (title) {
-      beforeTitle = eat(beforeTitle).test().end;
-      title = self.decode.raw(self.unescape(title), beforeTitle);
+const remarkLintCheckboxCharacterStyle = lintRule$q(
+  'remark-lint:checkbox-character-style',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    const value = String(file);
+    /** @type {'x'|'X'|'consistent'} */
+    let checked = 'consistent';
+    /** @type {' '|'\x09'|'consistent'} */
+    let unchecked = 'consistent';
+
+    if (typeof option === 'object') {
+      checked = option.checked || 'consistent';
+      unchecked = option.unchecked || 'consistent';
+    }
+
+    if (unchecked !== 'consistent' && unchecked !== ' ' && unchecked !== '\t') {
+      file.fail(
+        'Incorrect unchecked checkbox marker `' +
+          unchecked +
+          "`: use either `'\\t'`, or `' '`"
+      );
     }
 
-    return eat(subvalue)({
-      type: 'definition',
-      identifier: normalize_1(identifier),
-      label: identifier,
-      title: title || null,
-      url: url
-    })
-  }
-}
-
-// Check if `character` can be inside an enclosed URI.
-function isEnclosedURLCharacter(character) {
-  return (
-    character !== greaterThan$1 &&
-    character !== leftSquareBracket &&
-    character !== rightSquareBracket
-  )
-}
+    if (checked !== 'consistent' && checked !== 'x' && checked !== 'X') {
+      file.fail(
+        'Incorrect checked checkbox marker `' +
+          checked +
+          "`: use either `'x'`, or `'X'`"
+      );
+    }
 
-isEnclosedURLCharacter.delimiter = greaterThan$1;
+    visit(tree, 'listItem', (node) => {
+      const head = node.children[0];
+      const point = pointStart(head);
 
-// Check if `character` can be inside an unclosed URI.
-function isUnclosedURLCharacter(character) {
-  return (
-    character !== leftSquareBracket &&
-    character !== rightSquareBracket &&
-    !isWhitespaceCharacter(character)
-  )
-}
+      // Exit early for items without checkbox.
+      // A list item cannot be checked and empty, according to GFM.
+      if (
+        typeof node.checked !== 'boolean' ||
+        !head ||
+        typeof point.offset !== 'number'
+      ) {
+        return
+      }
 
-var table_1 = table;
+      // Move back to before `] `.
+      point.offset -= 2;
+      point.column -= 2;
 
-var tab$b = '\t';
-var lineFeed$c = '\n';
-var space$c = ' ';
-var dash$4 = '-';
-var colon$2 = ':';
-var backslash$3 = '\\';
-var verticalBar = '|';
+      // Assume we start with a checkbox, because well, `checked` is set.
+      const match = /\[([\t Xx])]/.exec(
+        value.slice(point.offset - 2, point.offset + 1)
+      );
 
-var minColumns = 1;
-var minRows = 2;
+      // Failsafe to make sure we don‘t crash if there actually isn’t a checkbox.
+      /* c8 ignore next */
+      if (!match) return
 
-var left = 'left';
-var center = 'center';
-var right = 'right';
+      const style = node.checked ? checked : unchecked;
 
-function table(eat, value, silent) {
-  var self = this;
-  var index;
-  var alignments;
-  var alignment;
-  var subvalue;
-  var row;
-  var length;
-  var lines;
-  var queue;
-  var character;
-  var hasDash;
-  var align;
-  var cell;
-  var preamble;
-  var now;
-  var position;
-  var lineCount;
-  var line;
-  var rows;
-  var table;
-  var lineIndex;
-  var pipeIndex;
-  var first;
-
-  // Exit when not in gfm-mode.
-  if (!self.options.gfm) {
-    return
+      if (style === 'consistent') {
+        if (node.checked) {
+          // @ts-expect-error: valid marker.
+          checked = match[1];
+        } else {
+          // @ts-expect-error: valid marker.
+          unchecked = match[1];
+        }
+      } else if (match[1] !== style) {
+        file.message(
+          (node.checked ? 'Checked' : 'Unchecked') +
+            ' checkboxes should use `' +
+            style +
+            '` as a marker',
+          point
+        );
+      }
+    });
   }
+);
 
-  // Get the rows.
-  // Detecting tables soon is hard, so there are some checks for performance
-  // here, such as the minimum number of rows, and allowed characters in the
-  // alignment row.
-  index = 0;
-  lineCount = 0;
-  length = value.length + 1;
-  lines = [];
+var remarkLintCheckboxCharacterStyle$1 = remarkLintCheckboxCharacterStyle;
 
-  while (index < length) {
-    lineIndex = value.indexOf(lineFeed$c, index);
-    pipeIndex = value.indexOf(verticalBar, index + 1);
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    if (lineIndex === -1) {
-      lineIndex = value.length;
-    }
+const primitives$p = new Set(['string', 'number', 'boolean']);
 
-    if (pipeIndex === -1 || pipeIndex > lineIndex) {
-      if (lineCount < minRows) {
-        return
-      }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$p(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-      break
-    }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-    lines.push(value.slice(index, lineIndex));
-    lineCount++;
-    index = lineIndex + 1;
-  }
+  return plugin
 
-  // Parse the alignment row.
-  subvalue = lines.join(lineFeed$c);
-  alignments = lines.splice(1, 1)[0] || [];
-  index = 0;
-  length = alignments.length;
-  lineCount--;
-  alignment = false;
-  align = [];
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$q(ruleId, raw);
 
-  while (index < length) {
-    character = alignments.charAt(index);
+    if (!severity) return
 
-    if (character === verticalBar) {
-      hasDash = null;
+    const fatal = severity === 2;
 
-      if (alignment === false) {
-        if (first === false) {
-          return
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
+
+      wrap(rule, (error) => {
+        const messages = file.messages;
+
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
-      } else {
-        align.push(alignment);
-        alignment = false;
-      }
 
-      first = false;
-    } else if (character === dash$4) {
-      hasDash = true;
-      alignment = alignment || null;
-    } else if (character === colon$2) {
-      if (alignment === left) {
-        alignment = center;
-      } else if (hasDash && alignment === null) {
-        alignment = right;
-      } else {
-        alignment = left;
-      }
-    } else if (!isWhitespaceCharacter(character)) {
-      return
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    index++;
+        next();
+      })(tree, file, options);
+    }
   }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$q(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if (alignment !== false) {
-    align.push(alignment);
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$p.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  // Exit when without enough columns.
-  if (align.length < minColumns) {
-    return
+  let level = result[0];
+
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  // Parse the rows.
-  position = -1;
-  rows = [];
-
-  table = eat(subvalue).reset({type: 'table', align: align, children: rows});
-
-  while (++position < lineCount) {
-    line = lines[position];
-    row = {type: 'tableRow', children: []};
-
-    // Eat a newline character when this is not the first row.
-    if (position) {
-      eat(lineFeed$c);
-    }
+  result[0] = level;
 
-    // Eat the row.
-    eat(line).reset(row, table);
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    length = line.length + 1;
-    index = 0;
-    queue = '';
-    cell = '';
-    preamble = true;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module checkbox-content-indent
+ * @fileoverview
+ *   Warn when list item checkboxes are followed by too much whitespace.
+ *
+ * @example
+ *   {"name": "ok.md", "gfm": true}
+ *
+ *   - [ ] List item
+ *   +  [x] List Item
+ *   *   [X] List item
+ *   -    [ ] List item
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input", "gfm": true}
+ *
+ *   - [ ] List item
+ *   + [x]  List item
+ *   * [X]   List item
+ *   - [ ]    List item
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "gfm": true}
+ *
+ *   2:7-2:8: Checkboxes should be followed by a single character
+ *   3:7-3:9: Checkboxes should be followed by a single character
+ *   4:7-4:10: Checkboxes should be followed by a single character
+ */
 
-    while (index < length) {
-      character = line.charAt(index);
+const remarkLintCheckboxContentIndent = lintRule$p(
+  'remark-lint:checkbox-content-indent',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    const value = String(file);
+    const loc = location(file);
 
-      if (character === tab$b || character === space$c) {
-        if (cell) {
-          queue += character;
-        } else {
-          eat(character);
-        }
+    visit(tree, 'listItem', (node) => {
+      const head = node.children[0];
+      const point = pointStart(head);
 
-        index++;
-        continue
+      // Exit early for items without checkbox.
+      // A list item cannot be checked and empty, according to GFM.
+      if (
+        typeof node.checked !== 'boolean' ||
+        !head ||
+        typeof point.offset !== 'number'
+      ) {
+        return
       }
 
-      if (character === '' || character === verticalBar) {
-        if (preamble) {
-          eat(character);
-        } else {
-          if ((cell || character) && !preamble) {
-            subvalue = cell;
-
-            if (queue.length > 1) {
-              if (character) {
-                subvalue += queue.slice(0, -1);
-                queue = queue.charAt(queue.length - 1);
-              } else {
-                subvalue += queue;
-                queue = '';
-              }
-            }
-
-            now = eat.now();
-
-            eat(subvalue)(
-              {type: 'tableCell', children: self.tokenizeInline(cell, now)},
-              row
-            );
-          }
+      // Assume we start with a checkbox, because well, `checked` is set.
+      const match = /\[([\t xX])]/.exec(
+        value.slice(point.offset - 4, point.offset + 1)
+      );
 
-          eat(queue + character);
+      // Failsafe to make sure we don‘t crash if there actually isn’t a checkbox.
+      /* c8 ignore next */
+      if (!match) return
 
-          queue = '';
-          cell = '';
-        }
-      } else {
-        if (queue) {
-          cell += queue;
-          queue = '';
-        }
+      // Move past checkbox.
+      const initial = point.offset;
+      let final = initial;
 
-        cell += character;
+      while (/[\t ]/.test(value.charAt(final))) final++;
 
-        if (character === backslash$3 && index !== length - 2) {
-          cell += line.charAt(index + 1);
-          index++;
-        }
+      if (final - initial > 0) {
+        file.message('Checkboxes should be followed by a single character', {
+          start: loc.toPoint(initial),
+          end: loc.toPoint(final)
+        });
       }
+    });
+  }
+);
 
-      preamble = false;
-      index++;
-    }
+var remarkLintCheckboxContentIndent$1 = remarkLintCheckboxContentIndent;
 
-    // Eat the alignment row.
-    if (!position) {
-      eat(lineFeed$c + alignments);
-    }
-  }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  return table
-}
+const primitives$o = new Set(['string', 'number', 'boolean']);
 
-var paragraph_1 = paragraph;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$o(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-var tab$c = '\t';
-var lineFeed$d = '\n';
-var space$d = ' ';
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var tabSize$4 = 4;
+  return plugin
 
-// Tokenise paragraph.
-function paragraph(eat, value, silent) {
-  var self = this;
-  var settings = self.options;
-  var commonmark = settings.commonmark;
-  var tokenizers = self.blockTokenizers;
-  var interruptors = self.interruptParagraph;
-  var index = value.indexOf(lineFeed$d);
-  var length = value.length;
-  var position;
-  var subvalue;
-  var character;
-  var size;
-  var now;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$p(ruleId, raw);
 
-  while (index < length) {
-    // Eat everything if there’s no following newline.
-    if (index === -1) {
-      index = length;
-      break
-    }
+    if (!severity) return
 
-    // Stop if the next character is NEWLINE.
-    if (value.charAt(index + 1) === lineFeed$d) {
-      break
-    }
+    const fatal = severity === 2;
 
-    // In commonmark-mode, following indented lines are part of the paragraph.
-    if (commonmark) {
-      size = 0;
-      position = index + 1;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      while (position < length) {
-        character = value.charAt(position);
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-        if (character === tab$c) {
-          size = tabSize$4;
-          break
-        } else if (character === space$d) {
-          size++;
-        } else {
-          break
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
 
-        position++;
-      }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-      if (size >= tabSize$4 && character !== lineFeed$d) {
-        index = value.indexOf(lineFeed$d, index + 1);
-        continue
-      }
+        next();
+      })(tree, file, options);
     }
+  }
+}
 
-    subvalue = value.slice(index + 1);
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$p(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-    // Check if the following code contains a possible block.
-    if (interrupt_1(interruptors, tokenizers, self, [eat, subvalue, true])) {
-      break
-    }
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$o.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-    position = index;
-    index = value.indexOf(lineFeed$d, index + 1);
+  let level = result[0];
 
-    if (index !== -1 && trim_1(value.slice(position, index)) === '') {
-      index = position;
-      break
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
   }
 
-  subvalue = value.slice(0, index);
-
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  now = eat.now();
-  subvalue = trimTrailingLines_1(subvalue);
+  result[0] = level;
 
-  return eat(subvalue)({
-    type: 'paragraph',
-    children: self.tokenizeInline(subvalue, now)
-  })
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var _escape = locate;
-
-function locate(value, fromIndex) {
-  return value.indexOf('\\', fromIndex)
-}
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module code-block-style
+ * @fileoverview
+ *   Warn when code blocks do not adhere to a given style.
+ *
+ *   Options: `'consistent'`, `'fenced'`, or `'indented'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used code block style and warns when
+ *   subsequent code blocks uses different styles.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   formats code blocks using a fence if they have a language flag and
+ *   indentation if not.
+ *   Pass
+ *   [`fences: true`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionsfences)
+ *   to always use fences for code blocks.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"setting": "indented", "name": "ok.md"}
+ *
+ *       alpha()
+ *
+ *   Paragraph.
+ *
+ *       bravo()
+ *
+ * @example
+ *   {"setting": "indented", "name": "not-ok.md", "label": "input"}
+ *
+ *   ```
+ *   alpha()
+ *   ```
+ *
+ *   Paragraph.
+ *
+ *   ```
+ *   bravo()
+ *   ```
+ *
+ * @example
+ *   {"setting": "indented", "name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-3:4: Code blocks should be indented
+ *   7:1-9:4: Code blocks should be indented
+ *
+ * @example
+ *   {"setting": "fenced", "name": "ok.md"}
+ *
+ *   ```
+ *   alpha()
+ *   ```
+ *
+ *   Paragraph.
+ *
+ *   ```
+ *   bravo()
+ *   ```
+ *
+ * @example
+ *   {"setting": "fenced", "name": "not-ok-fenced.md", "label": "input"}
+ *
+ *       alpha()
+ *
+ *   Paragraph.
+ *
+ *       bravo()
+ *
+ * @example
+ *   {"setting": "fenced", "name": "not-ok-fenced.md", "label": "output"}
+ *
+ *   1:1-1:12: Code blocks should be fenced
+ *   5:1-5:12: Code blocks should be fenced
+ *
+ * @example
+ *   {"name": "not-ok-consistent.md", "label": "input"}
+ *
+ *       alpha()
+ *
+ *   Paragraph.
+ *
+ *   ```
+ *   bravo()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok-consistent.md", "label": "output"}
+ *
+ *   5:1-7:4: Code blocks should be indented
+ *
+ * @example
+ *   {"setting": "💩", "name": "not-ok-incorrect.md", "label": "output", "positionless": true}
+ *
+ *   1:1: Incorrect code block style `💩`: use either `'consistent'`, `'fenced'`, or `'indented'`
+ */
 
-var _escape$1 = escape$1;
-escape$1.locator = _escape;
+const remarkLintCodeBlockStyle = lintRule$o(
+  'remark-lint:code-block-style',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    const value = String(file);
 
-var lineFeed$e = '\n';
-var backslash$4 = '\\';
+    if (
+      option !== 'consistent' &&
+      option !== 'fenced' &&
+      option !== 'indented'
+    ) {
+      file.fail(
+        'Incorrect code block style `' +
+          option +
+          "`: use either `'consistent'`, `'fenced'`, or `'indented'`"
+      );
+    }
 
-function escape$1(eat, value, silent) {
-  var self = this;
-  var character;
-  var node;
+    visit(tree, 'code', (node) => {
+      if (generated(node)) {
+        return
+      }
 
-  if (value.charAt(0) === backslash$4) {
-    character = value.charAt(1);
+      const initial = pointStart(node).offset;
+      const final = pointEnd(node).offset;
 
-    if (self.escape.indexOf(character) !== -1) {
-      /* istanbul ignore if - never used (yet) */
-      if (silent) {
-        return true
-      }
+      const current =
+        node.lang || /^\s*([~`])\1{2,}/.test(value.slice(initial, final))
+          ? 'fenced'
+          : 'indented';
 
-      if (character === lineFeed$e) {
-        node = {type: 'break'};
-      } else {
-        node = {type: 'text', value: character};
+      if (option === 'consistent') {
+        option = current;
+      } else if (option !== current) {
+        file.message('Code blocks should be ' + option, node);
       }
-
-      return eat(backslash$4 + character)(node)
-    }
+    });
   }
-}
-
-var tag$1 = locate$1;
-
-function locate$1(value, fromIndex) {
-  return value.indexOf('<', fromIndex)
-}
+);
 
-var autoLink_1 = autoLink;
-autoLink.locator = tag$1;
-autoLink.notInLink = true;
+var remarkLintCodeBlockStyle$1 = remarkLintCodeBlockStyle;
 
-var lessThan$3 = '<';
-var greaterThan$2 = '>';
-var atSign = '@';
-var slash$1 = '/';
-var mailto = 'mailto:';
-var mailtoLength = mailto.length;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-function autoLink(eat, value, silent) {
-  var self = this;
-  var subvalue = '';
-  var length = value.length;
-  var index = 0;
-  var queue = '';
-  var hasAtCharacter = false;
-  var link = '';
-  var character;
-  var now;
-  var content;
-  var tokenizers;
-  var exit;
-
-  if (value.charAt(0) !== lessThan$3) {
-    return
-  }
+const primitives$n = new Set(['string', 'number', 'boolean']);
 
-  index++;
-  subvalue = lessThan$3;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$n(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  while (index < length) {
-    character = value.charAt(index);
+  Object.defineProperty(plugin, 'name', {value: id});
 
-    if (
-      isWhitespaceCharacter(character) ||
-      character === greaterThan$2 ||
-      character === atSign ||
-      (character === ':' && value.charAt(index + 1) === slash$1)
-    ) {
-      break
-    }
+  return plugin
 
-    queue += character;
-    index++;
-  }
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$o(ruleId, raw);
 
-  if (!queue) {
-    return
-  }
+    if (!severity) return
 
-  link += queue;
-  queue = '';
+    const fatal = severity === 2;
 
-  character = value.charAt(index);
-  link += character;
-  index++;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  if (character === atSign) {
-    hasAtCharacter = true;
-  } else {
-    if (character !== ':' || value.charAt(index + 1) !== slash$1) {
-      return
-    }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-    link += slash$1;
-    index++;
-  }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  while (index < length) {
-    character = value.charAt(index);
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (isWhitespaceCharacter(character) || character === greaterThan$2) {
-      break
+        next();
+      })(tree, file, options);
     }
-
-    queue += character;
-    index++;
   }
+}
 
-  character = value.charAt(index);
-
-  if (!queue || character !== greaterThan$2) {
-    return
-  }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$o(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$n.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  link += queue;
-  content = link;
-  subvalue += link + character;
-  now = eat.now();
-  now.column++;
-  now.offset++;
+  let level = result[0];
 
-  if (hasAtCharacter) {
-    if (link.slice(0, mailtoLength).toLowerCase() === mailto) {
-      content = content.slice(mailtoLength);
-      now.column += mailtoLength;
-      now.offset += mailtoLength;
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
     } else {
-      link = mailto + link;
+      level = 1;
+      result = [level, result];
     }
   }
 
-  // Temporarily remove all tokenizers except text in autolinks.
-  tokenizers = self.inlineTokenizers;
-  self.inlineTokenizers = {text: tokenizers.text};
-
-  exit = self.enterLink();
-
-  content = self.tokenizeInline(content, now);
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-  self.inlineTokenizers = tokenizers;
-  exit();
+  result[0] = level;
 
-  return eat(subvalue)({
-    type: 'link',
-    title: null,
-    url: parseEntities_1(link, {nonTerminated: false}),
-    children: content
-  })
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var ccount_1 = ccount;
-
-function ccount(value, character) {
-  var val = String(value);
-  var count = 0;
-  var index;
-
-  if (typeof character !== 'string' || character.length !== 1) {
-    throw new Error('Expected character')
-  }
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module definition-spacing
+ * @fileoverview
+ *   Warn when consecutive whitespace is used in a definition.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   [example domain]: http://example.com "Example Domain"
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   [example····domain]: http://example.com "Example Domain"
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-1:57: Do not use consecutive whitespace in definition labels
+ */
 
-  index = val.indexOf(character);
+const label = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/;
 
-  while (index !== -1) {
-    count++;
-    index = val.indexOf(character, index + 1);
-  }
+const remarkLintDefinitionSpacing = lintRule$n(
+  'remark-lint:definition-spacing',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    const value = String(file);
 
-  return count
-}
+    visit(tree, (node) => {
+      if (node.type === 'definition' || node.type === 'footnoteDefinition') {
+        const start = pointStart(node).offset;
+        const end = pointEnd(node).offset;
 
-var url = locate$2;
+        if (typeof start === 'number' && typeof end === 'number') {
+          const match = value.slice(start, end).match(label);
 
-var values = ['www.', 'http://', 'https://'];
+          if (match && /[ \t\n]{2,}/.test(match[1])) {
+            file.message(
+              'Do not use consecutive whitespace in definition labels',
+              node
+            );
+          }
+        }
+      }
+    });
+  }
+);
 
-function locate$2(value, fromIndex) {
-  var min = -1;
-  var index;
-  var length;
-  var position;
+var remarkLintDefinitionSpacing$1 = remarkLintDefinitionSpacing;
 
-  if (!this.options.gfm) {
-    return min
-  }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  length = values.length;
-  index = -1;
+const primitives$m = new Set(['string', 'number', 'boolean']);
 
-  while (++index < length) {
-    position = value.indexOf(values[index], fromIndex);
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$m(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-    if (position !== -1 && (min === -1 || position < min)) {
-      min = position;
-    }
-  }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  return min
-}
+  return plugin
 
-var url_1 = url$1;
-url$1.locator = url;
-url$1.notInLink = true;
-
-var exclamationMark$1 = 33; // '!'
-var ampersand$1 = 38; // '&'
-var rightParenthesis$2 = 41; // ')'
-var asterisk$2 = 42; // '*'
-var comma$1 = 44; // ','
-var dash$5 = 45; // '-'
-var dot$2 = 46; // '.'
-var colon$3 = 58; // ':'
-var semicolon$1 = 59; // ';'
-var questionMark = 63; // '?'
-var lessThan$4 = 60; // '<'
-var underscore$2 = 95; // '_'
-var tilde$2 = 126; // '~'
-
-var leftParenthesisCharacter = '(';
-var rightParenthesisCharacter = ')';
-
-function url$1(eat, value, silent) {
-  var self = this;
-  var gfm = self.options.gfm;
-  var tokenizers = self.inlineTokenizers;
-  var length = value.length;
-  var previousDot = -1;
-  var protocolless = false;
-  var dots;
-  var lastTwoPartsStart;
-  var start;
-  var index;
-  var pathStart;
-  var path;
-  var code;
-  var end;
-  var leftCount;
-  var rightCount;
-  var content;
-  var children;
-  var url;
-  var exit;
-
-  if (!gfm) {
-    return
-  }
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$n(ruleId, raw);
 
-  // `WWW.` doesn’t work.
-  if (value.slice(0, 4) === 'www.') {
-    protocolless = true;
-    index = 4;
-  } else if (value.slice(0, 7).toLowerCase() === 'http://') {
-    index = 7;
-  } else if (value.slice(0, 8).toLowerCase() === 'https://') {
-    index = 8;
-  } else {
-    return
-  }
+    if (!severity) return
 
-  // Act as if the starting boundary is a dot.
-  previousDot = index - 1;
+    const fatal = severity === 2;
 
-  // Parse a valid domain.
-  start = index;
-  dots = [];
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  while (index < length) {
-    code = value.charCodeAt(index);
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-    if (code === dot$2) {
-      // Dots may not appear after each other.
-      if (previousDot === index - 1) {
-        break
-      }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-      dots.push(index);
-      previousDot = index;
-      index++;
-      continue
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (
-      isDecimal(code) ||
-      isAlphabetical(code) ||
-      code === dash$5 ||
-      code === underscore$2
-    ) {
-      index++;
-      continue
+        next();
+      })(tree, file, options);
     }
-
-    break
   }
+}
 
-  // Ignore a final dot:
-  if (code === dot$2) {
-    dots.pop();
-    index--;
-  }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$n(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  // If there are not dots, exit.
-  if (dots[0] === undefined) {
-    return
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$m.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  // If there is an underscore in the last two domain parts, exit:
-  // `www.example.c_m` and `www.ex_ample.com` are not OK, but
-  // `www.sub_domain.example.com` is.
-  lastTwoPartsStart = dots.length < 2 ? start : dots[dots.length - 2] + 1;
+  let level = result[0];
 
-  if (value.slice(lastTwoPartsStart, index).indexOf('_') !== -1) {
-    return
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  end = index;
-  pathStart = index;
-
-  // Parse a path.
-  while (index < length) {
-    code = value.charCodeAt(index);
+  result[0] = level;
 
-    if (isWhitespaceCharacter(code) || code === lessThan$4) {
-      break
-    }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    index++;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module fenced-code-flag
+ * @fileoverview
+ *   Check fenced code block flags.
+ *
+ *   Options: `Array.<string>` or `Object`, optional.
+ *
+ *   Providing an array is as passing `{flags: Array}`.
+ *
+ *   The object can have an array of `'flags'` which are allowed: other flags
+ *   will not be allowed.
+ *   An `allowEmpty` field (`boolean`, default: `false`) can be set to allow
+ *   code blocks without language flags.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   ```alpha
+ *   bravo()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   ```
+ *   alpha()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-3:4: Missing code language flag
+ *
+ * @example
+ *   {"name": "ok.md", "setting": {"allowEmpty": true}}
+ *
+ *   ```
+ *   alpha()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": {"allowEmpty": false}, "label": "input"}
+ *
+ *   ```
+ *   alpha()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": {"allowEmpty": false}, "label": "output"}
+ *
+ *   1:1-3:4: Missing code language flag
+ *
+ * @example
+ *   {"name": "ok.md", "setting": ["alpha"]}
+ *
+ *   ```alpha
+ *   bravo()
+ *   ```
+ *
+ * @example
+ *   {"name": "ok.md", "setting": {"flags":["alpha"]}}
+ *
+ *   ```alpha
+ *   bravo()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": ["charlie"], "label": "input"}
+ *
+ *   ```alpha
+ *   bravo()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": ["charlie"], "label": "output"}
+ *
+ *   1:1-3:4: Incorrect code language flag
+ */
 
-    if (
-      code === exclamationMark$1 ||
-      code === asterisk$2 ||
-      code === comma$1 ||
-      code === dot$2 ||
-      code === colon$3 ||
-      code === questionMark ||
-      code === underscore$2 ||
-      code === tilde$2
-    ) ; else {
-      end = index;
-    }
-  }
+const fence = /^ {0,3}([~`])\1{2,}/;
 
-  index = end;
+const remarkLintFencedCodeFlag = lintRule$m(
+  'remark-lint:fenced-code-flag',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option) => {
+    const value = String(file);
+    let allowEmpty = false;
+    /** @type {string[]} */
+    let allowed = [];
 
-  // If the path ends in a closing paren, and the count of closing parens is
-  // higher than the opening count, then remove the supefluous closing parens.
-  if (value.charCodeAt(index - 1) === rightParenthesis$2) {
-    path = value.slice(pathStart, index);
-    leftCount = ccount_1(path, leftParenthesisCharacter);
-    rightCount = ccount_1(path, rightParenthesisCharacter);
+    if (typeof option === 'object') {
+      if (Array.isArray(option)) {
+        allowed = option;
+      } else {
+        allowEmpty = Boolean(option.allowEmpty);
 
-    while (rightCount > leftCount) {
-      index = pathStart + path.lastIndexOf(rightParenthesisCharacter);
-      path = value.slice(pathStart, index);
-      rightCount--;
+        if (option.flags) {
+          allowed = option.flags;
+        }
+      }
     }
-  }
-
-  if (value.charCodeAt(index - 1) === semicolon$1) {
-    // GitHub doesn’t document this, but final semicolons aren’t paret of the
-    // URL either.
-    index--;
 
-    // // If the path ends in what looks like an entity, it’s not part of the path.
-    if (isAlphabetical(value.charCodeAt(index - 1))) {
-      end = index - 2;
-
-      while (isAlphabetical(value.charCodeAt(end))) {
-        end--;
-      }
+    visit(tree, 'code', (node) => {
+      if (!generated(node)) {
+        if (node.lang) {
+          if (allowed.length > 0 && !allowed.includes(node.lang)) {
+            file.message('Incorrect code language flag', node);
+          }
+        } else {
+          const slice = value.slice(
+            pointStart(node).offset,
+            pointEnd(node).offset
+          );
 
-      if (value.charCodeAt(end) === ampersand$1) {
-        index = end;
+          if (!allowEmpty && fence.test(slice)) {
+            file.message('Missing code language flag', node);
+          }
+        }
       }
-    }
+    });
   }
+);
 
-  content = value.slice(0, index);
-  url = parseEntities_1(content, {nonTerminated: false});
-
-  if (protocolless) {
-    url = 'http://' + url;
-  }
+var remarkLintFencedCodeFlag$1 = remarkLintFencedCodeFlag;
 
-  exit = self.enterLink();
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  // Temporarily remove all tokenizers except text in url.
-  self.inlineTokenizers = {text: tokenizers.text};
-  children = self.tokenizeInline(content, eat.now());
-  self.inlineTokenizers = tokenizers;
+const primitives$l = new Set(['string', 'number', 'boolean']);
 
-  exit();
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$l(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  return eat(content)({type: 'link', title: null, url: url, children: children})
-}
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var plusSign$1 = 43; // '+'
-var dash$6 = 45; // '-'
-var dot$3 = 46; // '.'
-var underscore$3 = 95; // '_'
+  return plugin
 
-var email = locate$3;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$m(ruleId, raw);
 
-// See: <https://github.github.com/gfm/#extended-email-autolink>
-function locate$3(value, fromIndex) {
-  var self = this;
-  var at;
-  var position;
+    if (!severity) return
 
-  if (!this.options.gfm) {
-    return -1
-  }
+    const fatal = severity === 2;
 
-  at = value.indexOf('@', fromIndex);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  if (at === -1) {
-    return -1
-  }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  position = at;
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  if (position === fromIndex || !isGfmAtext(value.charCodeAt(position - 1))) {
-    return locate$3.call(self, value, at + 1)
-  }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-  while (position > fromIndex && isGfmAtext(value.charCodeAt(position - 1))) {
-    position--;
+        next();
+      })(tree, file, options);
+    }
   }
-
-  return position
-}
-
-function isGfmAtext(code) {
-  return (
-    isDecimal(code) ||
-    isAlphabetical(code) ||
-    code === plusSign$1 ||
-    code === dash$6 ||
-    code === dot$3 ||
-    code === underscore$3
-  )
 }
 
-var email_1 = email$1;
-email$1.locator = email;
-email$1.notInLink = true;
-
-var plusSign$2 = 43; // '+'
-var dash$7 = 45; // '-'
-var dot$4 = 46; // '.'
-var atSign$1 = 64; // '@'
-var underscore$4 = 95; // '_'
-
-function email$1(eat, value, silent) {
-  var self = this;
-  var gfm = self.options.gfm;
-  var tokenizers = self.inlineTokenizers;
-  var index = 0;
-  var length = value.length;
-  var firstDot = -1;
-  var code;
-  var content;
-  var children;
-  var exit;
-
-  if (!gfm) {
-    return
-  }
-
-  code = value.charCodeAt(index);
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$m(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  while (
-    isDecimal(code) ||
-    isAlphabetical(code) ||
-    code === plusSign$2 ||
-    code === dash$7 ||
-    code === dot$4 ||
-    code === underscore$4
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$l.has(typeof value[0])
   ) {
-    code = value.charCodeAt(++index);
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  if (index === 0) {
-    return
-  }
+  let level = result[0];
 
-  if (code !== atSign$1) {
-    return
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  index++;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-  while (index < length) {
-    code = value.charCodeAt(index);
+  result[0] = level;
 
-    if (
-      isDecimal(code) ||
-      isAlphabetical(code) ||
-      code === dash$7 ||
-      code === dot$4 ||
-      code === underscore$4
-    ) {
-      index++;
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-      if (firstDot === -1 && code === dot$4) {
-        firstDot = index;
-      }
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module fenced-code-marker
+ * @fileoverview
+ *   Warn for violating fenced code markers.
+ *
+ *   Options: `` '`' ``, `'~'`, or `'consistent'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used fenced code marker style and warns
+ *   when subsequent fenced code blocks use different styles.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   formats fences using ``'`'`` (grave accent) by default.
+ *   Pass
+ *   [`fence: '~'`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionsfence)
+ *   to use `~` (tilde) instead.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   Indented code blocks are not affected by this rule:
+ *
+ *       bravo()
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "`"}
+ *
+ *   ```alpha
+ *   bravo()
+ *   ```
+ *
+ *   ```
+ *   charlie()
+ *   ```
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "~"}
+ *
+ *   ~~~alpha
+ *   bravo()
+ *   ~~~
+ *
+ *   ~~~
+ *   charlie()
+ *   ~~~
+ *
+ * @example
+ *   {"name": "not-ok-consistent-tick.md", "label": "input"}
+ *
+ *   ```alpha
+ *   bravo()
+ *   ```
+ *
+ *   ~~~
+ *   charlie()
+ *   ~~~
+ *
+ * @example
+ *   {"name": "not-ok-consistent-tick.md", "label": "output"}
+ *
+ *   5:1-7:4: Fenced code should use `` ` `` as a marker
+ *
+ * @example
+ *   {"name": "not-ok-consistent-tilde.md", "label": "input"}
+ *
+ *   ~~~alpha
+ *   bravo()
+ *   ~~~
+ *
+ *   ```
+ *   charlie()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok-consistent-tilde.md", "label": "output"}
+ *
+ *   5:1-7:4: Fenced code should use `~` as a marker
+ *
+ * @example
+ *   {"name": "not-ok-incorrect.md", "setting": "💩", "label": "output", "positionless": true}
+ *
+ *   1:1: Incorrect fenced code marker `💩`: use either `'consistent'`, `` '`' ``, or `'~'`
+ */
 
-      continue
+const remarkLintFencedCodeMarker = lintRule$l(
+  'remark-lint:fenced-code-marker',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    const contents = String(file);
+
+    if (option !== 'consistent' && option !== '~' && option !== '`') {
+      file.fail(
+        'Incorrect fenced code marker `' +
+          option +
+          "`: use either `'consistent'`, `` '`' ``, or `'~'`"
+      );
     }
 
-    break
-  }
+    visit(tree, 'code', (node) => {
+      const start = pointStart(node).offset;
 
-  if (
-    firstDot === -1 ||
-    firstDot === index ||
-    code === dash$7 ||
-    code === underscore$4
-  ) {
-    return
-  }
+      if (typeof start === 'number') {
+        const marker = contents
+          .slice(start, start + 4)
+          .replace(/^\s+/, '')
+          .charAt(0);
 
-  if (code === dot$4) {
-    index--;
+        // Ignore unfenced code blocks.
+        if (marker === '~' || marker === '`') {
+          if (option === 'consistent') {
+            option = marker;
+          } else if (marker !== option) {
+            file.message(
+              'Fenced code should use `' +
+                (option === '~' ? option : '` ` `') +
+                '` as a marker',
+              node
+            );
+          }
+        }
+      }
+    });
   }
+);
 
-  content = value.slice(0, index);
+var remarkLintFencedCodeMarker$1 = remarkLintFencedCodeMarker;
 
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
-  }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  exit = self.enterLink();
+const primitives$k = new Set(['string', 'number', 'boolean']);
 
-  // Temporarily remove all tokenizers except text in url.
-  self.inlineTokenizers = {text: tokenizers.text};
-  children = self.tokenizeInline(content, eat.now());
-  self.inlineTokenizers = tokenizers;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$k(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  exit();
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  return eat(content)({
-    type: 'link',
-    title: null,
-    url: 'mailto:' + parseEntities_1(content, {nonTerminated: false}),
-    children: children
-  })
-}
+  return plugin
 
-var tag$2 = html.tag;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$l(ruleId, raw);
 
-var htmlInline = inlineHTML;
-inlineHTML.locator = tag$1;
+    if (!severity) return
 
-var lessThan$5 = '<';
-var questionMark$1 = '?';
-var exclamationMark$2 = '!';
-var slash$2 = '/';
+    const fatal = severity === 2;
 
-var htmlLinkOpenExpression = /^<a /i;
-var htmlLinkCloseExpression = /^<\/a>/i;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-function inlineHTML(eat, value, silent) {
-  var self = this;
-  var length = value.length;
-  var character;
-  var subvalue;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  if (value.charAt(0) !== lessThan$5 || length < 3) {
-    return
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
+
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
+
+        next();
+      })(tree, file, options);
+    }
   }
+}
 
-  character = value.charAt(1);
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$l(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if (
-    !isAlphabetical(character) &&
-    character !== questionMark$1 &&
-    character !== exclamationMark$2 &&
-    character !== slash$2
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$k.has(typeof value[0])
   ) {
-    return
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  subvalue = value.match(tag$2);
+  let level = result[0];
 
-  if (!subvalue) {
-    return
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  /* istanbul ignore if - not used yet. */
-  if (silent) {
-    return true
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  subvalue = subvalue[0];
-
-  if (!self.inLink && htmlLinkOpenExpression.test(subvalue)) {
-    self.inLink = true;
-  } else if (self.inLink && htmlLinkCloseExpression.test(subvalue)) {
-    self.inLink = false;
-  }
+  result[0] = level;
 
-  return eat(subvalue)({type: 'html', value: subvalue})
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var link$2 = locate$4;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module file-extension
+ * @fileoverview
+ *   Warn when the file extension differ from the preferred extension.
+ *
+ *   Does not warn when given documents have no file extensions (such as
+ *   `AUTHORS` or `LICENSE`).
+ *
+ *   Options: `string`, default: `'md'` — Expected file extension.
+ *
+ * @example
+ *   {"name": "readme.md"}
+ *
+ * @example
+ *   {"name": "readme"}
+ *
+ * @example
+ *   {"name": "readme.mkd", "label": "output", "positionless": true}
+ *
+ *   1:1: Incorrect extension: use `md`
+ *
+ * @example
+ *   {"name": "readme.mkd", "setting": "mkd"}
+ */
 
-function locate$4(value, fromIndex) {
-  var link = value.indexOf('[', fromIndex);
-  var image = value.indexOf('![', fromIndex);
+const remarkLintFileExtension = lintRule$k(
+  'remark-lint:file-extension',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (_, file, option = 'md') => {
+    const ext = file.extname;
 
-  if (image === -1) {
-    return link
+    if (ext && ext.slice(1) !== option) {
+      file.message('Incorrect extension: use `' + option + '`');
+    }
   }
+);
 
-  // Link can never be `-1` if an image is found, so we don’t need to check
-  // for that :)
-  return link < image ? link : image
-}
+var remarkLintFileExtension$1 = remarkLintFileExtension;
 
-var link_1 = link$3;
-link$3.locator = link$2;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-var lineFeed$f = '\n';
-var exclamationMark$3 = '!';
-var quotationMark$1 = '"';
-var apostrophe$1 = "'";
-var leftParenthesis$1 = '(';
-var rightParenthesis$3 = ')';
-var lessThan$6 = '<';
-var greaterThan$3 = '>';
-var leftSquareBracket$1 = '[';
-var backslash$5 = '\\';
-var rightSquareBracket$1 = ']';
-var graveAccent$1 = '`';
+const primitives$j = new Set(['string', 'number', 'boolean']);
 
-function link$3(eat, value, silent) {
-  var self = this;
-  var subvalue = '';
-  var index = 0;
-  var character = value.charAt(0);
-  var pedantic = self.options.pedantic;
-  var commonmark = self.options.commonmark;
-  var gfm = self.options.gfm;
-  var closed;
-  var count;
-  var opening;
-  var beforeURL;
-  var beforeTitle;
-  var subqueue;
-  var hasMarker;
-  var isImage;
-  var content;
-  var marker;
-  var length;
-  var title;
-  var depth;
-  var queue;
-  var url;
-  var now;
-  var exit;
-  var node;
-
-  // Detect whether this is an image.
-  if (character === exclamationMark$3) {
-    isImage = true;
-    subvalue = character;
-    character = value.charAt(++index);
-  }
-
-  // Eat the opening.
-  if (character !== leftSquareBracket$1) {
-    return
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$j(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  // Exit when this is a link and we’re already inside a link.
-  if (!isImage && self.inLink) {
-    return
-  }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  subvalue += character;
-  queue = '';
-  index++;
+  return plugin
 
-  // Eat the content.
-  length = value.length;
-  now = eat.now();
-  depth = 0;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$k(ruleId, raw);
 
-  now.column += index;
-  now.offset += index;
+    if (!severity) return
 
-  while (index < length) {
-    character = value.charAt(index);
-    subqueue = character;
+    const fatal = severity === 2;
 
-    if (character === graveAccent$1) {
-      // Inline-code in link content.
-      count = 1;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      while (value.charAt(index + 1) === graveAccent$1) {
-        subqueue += character;
-        index++;
-        count++;
-      }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-      if (!opening) {
-        opening = count;
-      } else if (count >= opening) {
-        opening = 0;
-      }
-    } else if (character === backslash$5) {
-      // Allow brackets to be escaped.
-      index++;
-      subqueue += value.charAt(index);
-    } else if ((!opening || gfm) && character === leftSquareBracket$1) {
-      // In GFM mode, brackets in code still count.  In all other modes,
-      // they don’t.
-      depth++;
-    } else if ((!opening || gfm) && character === rightSquareBracket$1) {
-      if (depth) {
-        depth--;
-      } else {
-        if (value.charAt(index + 1) !== leftParenthesis$1) {
-          return
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
 
-        subqueue += leftParenthesis$1;
-        closed = true;
-        index++;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-        break
-      }
+        next();
+      })(tree, file, options);
     }
-
-    queue += subqueue;
-    subqueue = '';
-    index++;
-  }
-
-  // Eat the content closing.
-  if (!closed) {
-    return
   }
+}
 
-  content = queue;
-  subvalue += queue + subqueue;
-  index++;
-
-  // Eat white-space.
-  while (index < length) {
-    character = value.charAt(index);
-
-    if (!isWhitespaceCharacter(character)) {
-      break
-    }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$k(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-    subvalue += character;
-    index++;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$j.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  // Eat the URL.
-  character = value.charAt(index);
-  queue = '';
-  beforeURL = subvalue;
-
-  if (character === lessThan$6) {
-    index++;
-    beforeURL += lessThan$6;
-
-    while (index < length) {
-      character = value.charAt(index);
-
-      if (character === greaterThan$3) {
-        break
-      }
-
-      if (commonmark && character === lineFeed$f) {
-        return
-      }
-
-      queue += character;
-      index++;
-    }
+  let level = result[0];
 
-    if (value.charAt(index) !== greaterThan$3) {
-      return
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
+  }
 
-    subvalue += lessThan$6 + queue + greaterThan$3;
-    url = queue;
-    index++;
-  } else {
-    character = null;
-    subqueue = '';
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-    while (index < length) {
-      character = value.charAt(index);
+  result[0] = level;
 
-      if (
-        subqueue &&
-        (character === quotationMark$1 ||
-          character === apostrophe$1 ||
-          (commonmark && character === leftParenthesis$1))
-      ) {
-        break
-      }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-      if (isWhitespaceCharacter(character)) {
-        if (!pedantic) {
-          break
-        }
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module final-definition
+ * @fileoverview
+ *   Warn when definitions are placed somewhere other than at the end of
+ *   the file.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   Paragraph.
+ *
+ *   [example]: http://example.com "Example Domain"
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   Paragraph.
+ *
+ *   [example]: http://example.com "Example Domain"
+ *
+ *   Another paragraph.
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   3:1-3:47: Move definitions to the end of the file (after the node at line `5`)
+ *
+ * @example
+ *   {"name": "ok-comments.md"}
+ *
+ *   Paragraph.
+ *
+ *   [example-1]: http://example.com/one/
+ *
+ *   <!-- Comments are fine between and after definitions -->
+ *
+ *   [example-2]: http://example.com/two/
+ */
 
-        subqueue += character;
-      } else {
-        if (character === leftParenthesis$1) {
-          depth++;
-        } else if (character === rightParenthesis$3) {
-          if (depth === 0) {
-            break
-          }
+const remarkLintFinalDefinition = lintRule$j(
+  'remark-lint:final-definition',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    let last = 0;
 
-          depth--;
+    visit(
+      tree,
+      (node) => {
+        // Ignore generated and HTML comment nodes.
+        if (
+          node.type === 'root' ||
+          generated(node) ||
+          (node.type === 'html' && /^\s*<!--/.test(node.value))
+        ) {
+          return
         }
 
-        queue += subqueue;
-        subqueue = '';
+        const line = pointStart(node).line;
 
-        if (character === backslash$5) {
-          queue += backslash$5;
-          character = value.charAt(++index);
+        if (node.type === 'definition') {
+          if (last && last > line) {
+            file.message(
+              'Move definitions to the end of the file (after the node at line `' +
+                last +
+                '`)',
+              node
+            );
+          }
+        } else if (last === 0) {
+          last = line;
         }
-
-        queue += character;
-      }
-
-      index++;
-    }
-
-    subvalue += queue;
-    url = queue;
-    index = subvalue.length;
+      },
+      true
+    );
   }
+);
 
-  // Eat white-space.
-  queue = '';
-
-  while (index < length) {
-    character = value.charAt(index);
+var remarkLintFinalDefinition$1 = remarkLintFinalDefinition;
 
-    if (!isWhitespaceCharacter(character)) {
-      break
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    queue += character;
-    index++;
-  }
+const primitives$i = new Set(['string', 'number', 'boolean']);
 
-  character = value.charAt(index);
-  subvalue += queue;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$i(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  // Eat the title.
-  if (
-    queue &&
-    (character === quotationMark$1 ||
-      character === apostrophe$1 ||
-      (commonmark && character === leftParenthesis$1))
-  ) {
-    index++;
-    subvalue += character;
-    queue = '';
-    marker = character === leftParenthesis$1 ? rightParenthesis$3 : character;
-    beforeTitle = subvalue;
-
-    // In commonmark-mode, things are pretty easy: the marker cannot occur
-    // inside the title.  Non-commonmark does, however, support nested
-    // delimiters.
-    if (commonmark) {
-      while (index < length) {
-        character = value.charAt(index);
-
-        if (character === marker) {
-          break
-        }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-        if (character === backslash$5) {
-          queue += backslash$5;
-          character = value.charAt(++index);
-        }
+  return plugin
 
-        index++;
-        queue += character;
-      }
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$j(ruleId, raw);
 
-      character = value.charAt(index);
+    if (!severity) return
 
-      if (character !== marker) {
-        return
-      }
+    const fatal = severity === 2;
 
-      title = queue;
-      subvalue += queue + character;
-      index++;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      while (index < length) {
-        character = value.charAt(index);
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-        if (!isWhitespaceCharacter(character)) {
-          break
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
 
-        subvalue += character;
-        index++;
-      }
-    } else {
-      subqueue = '';
-
-      while (index < length) {
-        character = value.charAt(index);
-
-        if (character === marker) {
-          if (hasMarker) {
-            queue += marker + subqueue;
-            subqueue = '';
-          }
-
-          hasMarker = true;
-        } else if (!hasMarker) {
-          queue += character;
-        } else if (character === rightParenthesis$3) {
-          subvalue += queue + marker + subqueue;
-          title = queue;
-          break
-        } else if (isWhitespaceCharacter(character)) {
-          subqueue += character;
-        } else {
-          queue += marker + subqueue + character;
-          subqueue = '';
-          hasMarker = false;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
         }
 
-        index++;
-      }
+        next();
+      })(tree, file, options);
     }
   }
+}
 
-  if (value.charAt(index) !== rightParenthesis$3) {
-    return
-  }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$j(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$i.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  subvalue += rightParenthesis$3;
+  let level = result[0];
 
-  url = self.decode.raw(self.unescape(url), eat(beforeURL).test().end, {
-    nonTerminated: false
-  });
-
-  if (title) {
-    beforeTitle = eat(beforeTitle).test().end;
-    title = self.decode.raw(self.unescape(title), beforeTitle);
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  node = {
-    type: isImage ? 'image' : 'link',
-    title: title || null,
-    url: url
-  };
-
-  if (isImage) {
-    node.alt = self.decode.raw(self.unescape(content), now) || null;
-  } else {
-    exit = self.enterLink();
-    node.children = self.tokenizeInline(content, now);
-    exit();
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  return eat(subvalue)(node)
-}
+  result[0] = level;
 
-var reference_1 = reference;
-reference.locator = link$2;
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-var link$4 = 'link';
-var image$1 = 'image';
-var shortcut = 'shortcut';
-var collapsed = 'collapsed';
-var full = 'full';
-var exclamationMark$4 = '!';
-var leftSquareBracket$2 = '[';
-var backslash$6 = '\\';
-var rightSquareBracket$2 = ']';
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module first-heading-level
+ * @fileoverview
+ *   Warn when the first heading has a level other than a specified value.
+ *
+ *   Options: `number`, default: `1`.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   # The default is to expect a level one heading
+ *
+ * @example
+ *   {"name": "ok-html.md"}
+ *
+ *   <h1>An HTML heading is also seen by this rule.</h1>
+ *
+ * @example
+ *   {"name": "ok-delayed.md"}
+ *
+ *   You can use markdown content before the heading.
+ *
+ *   <div>Or non-heading HTML</div>
+ *
+ *   <h1>So the first heading, be it HTML or markdown, is checked</h1>
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   ## Bravo
+ *
+ *   Paragraph.
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-1:9: First heading level should be `1`
+ *
+ * @example
+ *   {"name": "not-ok-html.md", "label": "input"}
+ *
+ *   <h2>Charlie</h2>
+ *
+ *   Paragraph.
+ *
+ * @example
+ *   {"name": "not-ok-html.md", "label": "output"}
+ *
+ *   1:1-1:17: First heading level should be `1`
+ *
+ * @example
+ *   {"name": "ok.md", "setting": 2}
+ *
+ *   ## Delta
+ *
+ *   Paragraph.
+ *
+ * @example
+ *   {"name": "ok-html.md", "setting": 2}
+ *
+ *   <h2>Echo</h2>
+ *
+ *   Paragraph.
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": 2, "label": "input"}
+ *
+ *   # Foxtrot
+ *
+ *   Paragraph.
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": 2, "label": "output"}
+ *
+ *   1:1-1:10: First heading level should be `2`
+ *
+ * @example
+ *   {"name": "not-ok-html.md", "setting": 2, "label": "input"}
+ *
+ *   <h1>Golf</h1>
+ *
+ *   Paragraph.
+ *
+ * @example
+ *   {"name": "not-ok-html.md", "setting": 2, "label": "output"}
+ *
+ *   1:1-1:14: First heading level should be `2`
+ */
 
-function reference(eat, value, silent) {
-  var self = this;
-  var commonmark = self.options.commonmark;
-  var character = value.charAt(0);
-  var index = 0;
-  var length = value.length;
-  var subvalue = '';
-  var intro = '';
-  var type = link$4;
-  var referenceType = shortcut;
-  var content;
-  var identifier;
-  var now;
-  var node;
-  var exit;
-  var queue;
-  var bracketed;
-  var depth;
-
-  // Check whether we’re eating an image.
-  if (character === exclamationMark$4) {
-    type = image$1;
-    intro = character;
-    character = value.charAt(++index);
-  }
-
-  if (character !== leftSquareBracket$2) {
-    return
-  }
+const re = /<h([1-6])/;
 
-  index++;
-  intro += character;
-  queue = '';
+const remarkLintFirstHeadingLevel = lintRule$i(
+  'remark-lint:first-heading-level',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 1) => {
+    visit(tree, (node) => {
+      if (!generated(node)) {
+        /** @type {Depth|undefined} */
+        let rank;
 
-  // Eat the text.
-  depth = 0;
+        if (node.type === 'heading') {
+          rank = node.depth;
+        } else if (node.type === 'html') {
+          rank = infer(node);
+        }
 
-  while (index < length) {
-    character = value.charAt(index);
+        if (rank !== undefined) {
+          if (rank !== option) {
+            file.message('First heading level should be `' + option + '`', node);
+          }
 
-    if (character === leftSquareBracket$2) {
-      bracketed = true;
-      depth++;
-    } else if (character === rightSquareBracket$2) {
-      if (!depth) {
-        break
+          return EXIT$1
+        }
       }
-
-      depth--;
-    }
-
-    if (character === backslash$6) {
-      queue += backslash$6;
-      character = value.charAt(++index);
-    }
-
-    queue += character;
-    index++;
+    });
   }
+);
 
-  subvalue = queue;
-  content = queue;
-  character = value.charAt(index);
+var remarkLintFirstHeadingLevel$1 = remarkLintFirstHeadingLevel;
 
-  if (character !== rightSquareBracket$2) {
-    return
-  }
+/**
+ * @param {HTML} node
+ * @returns {Depth|undefined}
+ */
+function infer(node) {
+  const results = node.value.match(re);
+  // @ts-expect-error: can be castes fine.
+  return results ? Number(results[1]) : undefined
+}
 
-  index++;
-  subvalue += character;
-  queue = '';
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  if (!commonmark) {
-    // The original markdown syntax definition explicitly allows for whitespace
-    // between the link text and link label; commonmark departs from this, in
-    // part to improve support for shortcut reference links
-    while (index < length) {
-      character = value.charAt(index);
+const primitives$h = new Set(['string', 'number', 'boolean']);
 
-      if (!isWhitespaceCharacter(character)) {
-        break
-      }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$h(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-      queue += character;
-      index++;
-    }
-  }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  character = value.charAt(index);
+  return plugin
 
-  if (character === leftSquareBracket$2) {
-    identifier = '';
-    queue += character;
-    index++;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$i(ruleId, raw);
 
-    while (index < length) {
-      character = value.charAt(index);
+    if (!severity) return
 
-      if (character === leftSquareBracket$2 || character === rightSquareBracket$2) {
-        break
-      }
+    const fatal = severity === 2;
 
-      if (character === backslash$6) {
-        identifier += backslash$6;
-        character = value.charAt(++index);
-      }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      identifier += character;
-      index++;
-    }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-    character = value.charAt(index);
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-    if (character === rightSquareBracket$2) {
-      referenceType = identifier ? full : collapsed;
-      queue += identifier + character;
-      index++;
-    } else {
-      identifier = '';
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    subvalue += queue;
-    queue = '';
-  } else {
-    if (!content) {
-      return
+        next();
+      })(tree, file, options);
     }
-
-    identifier = content;
-  }
-
-  // Brackets cannot be inside the identifier.
-  if (referenceType !== full && bracketed) {
-    return
-  }
-
-  subvalue = intro + subvalue;
-
-  if (type === link$4 && self.inLink) {
-    return null
-  }
-
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
   }
+}
 
-  now = eat.now();
-  now.column += intro.length;
-  now.offset += intro.length;
-  identifier = referenceType === full ? identifier : content;
-
-  node = {
-    type: type + 'Reference',
-    identifier: normalize_1(identifier),
-    label: identifier,
-    referenceType: referenceType
-  };
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$i(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if (type === link$4) {
-    exit = self.enterLink();
-    node.children = self.tokenizeInline(content, now);
-    exit();
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$h.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
   } else {
-    node.alt = self.decode.raw(self.unescape(content), now) || null;
+    result = [1, value];
   }
 
-  return eat(subvalue)(node)
-}
-
-var strong = locate$5;
-
-function locate$5(value, fromIndex) {
-  var asterisk = value.indexOf('**', fromIndex);
-  var underscore = value.indexOf('__', fromIndex);
+  let level = result[0];
 
-  if (underscore === -1) {
-    return asterisk
-  }
-
-  if (asterisk === -1) {
-    return underscore
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  return underscore < asterisk ? underscore : asterisk
-}
-
-var strong_1 = strong$1;
-strong$1.locator = strong;
-
-var backslash$7 = '\\';
-var asterisk$3 = '*';
-var underscore$5 = '_';
-
-function strong$1(eat, value, silent) {
-  var self = this;
-  var index = 0;
-  var character = value.charAt(index);
-  var now;
-  var pedantic;
-  var marker;
-  var queue;
-  var subvalue;
-  var length;
-  var previous;
-
-  if (
-    (character !== asterisk$3 && character !== underscore$5) ||
-    value.charAt(++index) !== character
-  ) {
-    return
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  pedantic = self.options.pedantic;
-  marker = character;
-  subvalue = marker + marker;
-  length = value.length;
-  index++;
-  queue = '';
-  character = '';
+  result[0] = level;
 
-  if (pedantic && isWhitespaceCharacter(value.charAt(index))) {
-    return
-  }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-  while (index < length) {
-    previous = character;
-    character = value.charAt(index);
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module heading-style
+ * @fileoverview
+ *   Warn when a heading does not conform to a given style.
+ *
+ *   Options: `'consistent'`, `'atx'`, `'atx-closed'`, or `'setext'`,
+ *   default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used heading style and warns when
+ *   subsequent headings use different styles.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   formats headings as ATX by default.
+ *   This can be configured with the
+ *   [`setext`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionssetext)
+ *   and
+ *   [`closeAtx`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionscloseatx)
+ *   options.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "atx"}
+ *
+ *   # Alpha
+ *
+ *   ## Bravo
+ *
+ *   ### Charlie
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "atx-closed"}
+ *
+ *   # Delta ##
+ *
+ *   ## Echo ##
+ *
+ *   ### Foxtrot ###
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "setext"}
+ *
+ *   Golf
+ *   ====
+ *
+ *   Hotel
+ *   -----
+ *
+ *   ### India
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   Juliett
+ *   =======
+ *
+ *   ## Kilo
+ *
+ *   ### Lima ###
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   4:1-4:8: Headings should use setext
+ *   6:1-6:13: Headings should use setext
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": "💩", "label": "output", "positionless": true}
+ *
+ *   1:1: Incorrect heading style type `💩`: use either `'consistent'`, `'atx'`, `'atx-closed'`, or `'setext'`
+ */
 
+const remarkLintHeadingStyle = lintRule$h(
+  'remark-lint:heading-style',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
     if (
-      character === marker &&
-      value.charAt(index + 1) === marker &&
-      (!pedantic || !isWhitespaceCharacter(previous))
+      option !== 'consistent' &&
+      option !== 'atx' &&
+      option !== 'atx-closed' &&
+      option !== 'setext'
     ) {
-      character = value.charAt(index + 2);
-
-      if (character !== marker) {
-        if (!trim_1(queue)) {
-          return
-        }
+      file.fail(
+        'Incorrect heading style type `' +
+          option +
+          "`: use either `'consistent'`, `'atx'`, `'atx-closed'`, or `'setext'`"
+      );
+    }
 
-        /* istanbul ignore if - never used (yet) */
-        if (silent) {
-          return true
+    visit(tree, 'heading', (node) => {
+      if (!generated(node)) {
+        if (option === 'consistent') {
+          // Funky nodes perhaps cannot be detected.
+          /* c8 ignore next */
+          option = headingStyle(node) || 'consistent';
+        } else if (headingStyle(node, option) !== option) {
+          file.message('Headings should use ' + option, node);
         }
-
-        now = eat.now();
-        now.column += 2;
-        now.offset += 2;
-
-        return eat(subvalue + queue + subvalue)({
-          type: 'strong',
-          children: self.tokenizeInline(queue, now)
-        })
       }
-    }
-
-    if (!pedantic && character === backslash$7) {
-      queue += character;
-      character = value.charAt(++index);
-    }
-
-    queue += character;
-    index++;
-  }
-}
-
-var isWordCharacter = wordCharacter;
-
-var fromCode$1 = String.fromCharCode;
-var re$2 = /\w/;
-
-// Check if the given character code, or the character code at the first
-// character, is a word character.
-function wordCharacter(character) {
-  return re$2.test(
-    typeof character === 'number' ? fromCode$1(character) : character.charAt(0)
-  )
-}
-
-var emphasis = locate$6;
-
-function locate$6(value, fromIndex) {
-  var asterisk = value.indexOf('*', fromIndex);
-  var underscore = value.indexOf('_', fromIndex);
-
-  if (underscore === -1) {
-    return asterisk
+    });
   }
+);
 
-  if (asterisk === -1) {
-    return underscore
-  }
+var remarkLintHeadingStyle$1 = remarkLintHeadingStyle;
 
-  return underscore < asterisk ? underscore : asterisk
-}
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-var emphasis_1 = emphasis$1;
-emphasis$1.locator = emphasis;
+const primitives$g = new Set(['string', 'number', 'boolean']);
 
-var asterisk$4 = '*';
-var underscore$6 = '_';
-var backslash$8 = '\\';
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$g(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-function emphasis$1(eat, value, silent) {
-  var self = this;
-  var index = 0;
-  var character = value.charAt(index);
-  var now;
-  var pedantic;
-  var marker;
-  var queue;
-  var subvalue;
-  var length;
-  var previous;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  if (character !== asterisk$4 && character !== underscore$6) {
-    return
-  }
+  return plugin
 
-  pedantic = self.options.pedantic;
-  subvalue = character;
-  marker = character;
-  length = value.length;
-  index++;
-  queue = '';
-  character = '';
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$h(ruleId, raw);
 
-  if (pedantic && isWhitespaceCharacter(value.charAt(index))) {
-    return
-  }
+    if (!severity) return
 
-  while (index < length) {
-    previous = character;
-    character = value.charAt(index);
+    const fatal = severity === 2;
 
-    if (character === marker && (!pedantic || !isWhitespaceCharacter(previous))) {
-      character = value.charAt(++index);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      if (character !== marker) {
-        if (!trim_1(queue) || previous === marker) {
-          return
-        }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-        if (!pedantic && marker === underscore$6 && isWordCharacter(character)) {
-          queue += marker;
-          continue
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
 
-        /* istanbul ignore if - never used (yet) */
-        if (silent) {
-          return true
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
         }
 
-        now = eat.now();
-        now.column++;
-        now.offset++;
-
-        return eat(subvalue + queue + marker)({
-          type: 'emphasis',
-          children: self.tokenizeInline(queue, now)
-        })
-      }
-
-      queue += marker;
-    }
-
-    if (!pedantic && character === backslash$8) {
-      queue += character;
-      character = value.charAt(++index);
+        next();
+      })(tree, file, options);
     }
-
-    queue += character;
-    index++;
   }
 }
 
-var _delete = locate$7;
-
-function locate$7(value, fromIndex) {
-  return value.indexOf('~~', fromIndex)
-}
-
-var _delete$1 = strikethrough;
-strikethrough.locator = _delete;
-
-var tilde$3 = '~';
-var fence = '~~';
-
-function strikethrough(eat, value, silent) {
-  var self = this;
-  var character = '';
-  var previous = '';
-  var preceding = '';
-  var subvalue = '';
-  var index;
-  var length;
-  var now;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$h(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if (
-    !self.options.gfm ||
-    value.charAt(0) !== tilde$3 ||
-    value.charAt(1) !== tilde$3 ||
-    isWhitespaceCharacter(value.charAt(2))
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$g.has(typeof value[0])
   ) {
-    return
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  index = 1;
-  length = value.length;
-  now = eat.now();
-  now.column += 2;
-  now.offset += 2;
-
-  while (++index < length) {
-    character = value.charAt(index);
-
-    if (
-      character === tilde$3 &&
-      previous === tilde$3 &&
-      (!preceding || !isWhitespaceCharacter(preceding))
-    ) {
-      /* istanbul ignore if - never used (yet) */
-      if (silent) {
-        return true
-      }
+  let level = result[0];
 
-      return eat(fence + subvalue + fence)({
-        type: 'delete',
-        children: self.tokenizeInline(subvalue, now)
-      })
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
+  }
 
-    subvalue += previous;
-    preceding = previous;
-    previous = character;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
-}
 
-var codeInline = locate$8;
+  result[0] = level;
 
-function locate$8(value, fromIndex) {
-  return value.indexOf('`', fromIndex)
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var codeInline$1 = inlineCode;
-inlineCode.locator = codeInline;
-
-var lineFeed$g = 10; //  '\n'
-var space$e = 32; // ' '
-var graveAccent$2 = 96; //  '`'
-
-function inlineCode(eat, value, silent) {
-  var length = value.length;
-  var index = 0;
-  var openingFenceEnd;
-  var closingFenceStart;
-  var closingFenceEnd;
-  var code;
-  var next;
-  var found;
-
-  while (index < length) {
-    if (value.charCodeAt(index) !== graveAccent$2) {
-      break
-    }
-
-    index++;
-  }
-
-  if (index === 0 || index === length) {
-    return
-  }
-
-  openingFenceEnd = index;
-  next = value.charCodeAt(index);
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module maximum-line-length
+ * @fileoverview
+ *   Warn when lines are too long.
+ *
+ *   Options: `number`, default: `80`.
+ *
+ *   Ignores nodes that cannot be wrapped, such as headings, tables, code,
+ *   definitions, HTML, and JSX.
+ *
+ *   Ignores images, links, and inline code if they start before the wrap, end
+ *   after the wrap, and there’s no whitespace after them.
+ *
+ * @example
+ *   {"name": "ok.md", "positionless": true, "gfm": true}
+ *
+ *   This line is simply not toooooooooooooooooooooooooooooooooooooooooooo
+ *   long.
+ *
+ *   This is also fine: <http://this-long-url-with-a-long-domain.co.uk/a-long-path?query=variables>
+ *
+ *   <http://this-link-is-fine.com>
+ *
+ *   `alphaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJuliettKiloLimaMikeNovemberOscarPapaQuebec.romeo()`
+ *
+ *   [foo](http://this-long-url-with-a-long-domain-is-ok.co.uk/a-long-path?query=variables)
+ *
+ *   <http://this-long-url-with-a-long-domain-is-ok.co.uk/a-long-path?query=variables>
+ *
+ *   ![foo](http://this-long-url-with-a-long-domain-is-ok.co.uk/a-long-path?query=variables)
+ *
+ *   | An | exception | is | line | length | in | long | tables | because | those | can’t | just |
+ *   | -- | --------- | -- | ---- | ------ | -- | ---- | ------ | ------- | ----- | ----- | ---- |
+ *   | be | helped    |    |      |        |    |      |        |         |       |       | .    |
+ *
+ *   <a><b><i><p><q><s><u>alpha bravo charlie delta echo foxtrot golf</u></s></q></p></i></b></a>
+ *
+ *   The following is also fine, because there is no whitespace.
+ *
+ *   <http://this-long-url-with-a-long-domain-is-ok.co.uk/a-long-path?query=variables>.
+ *
+ *   In addition, definitions are also fine:
+ *
+ *   [foo]: <http://this-long-url-with-a-long-domain-is-ok.co.uk/a-long-path?query=variables>
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": 80, "label": "input", "positionless": true}
+ *
+ *   This line is simply not tooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+ *   long.
+ *
+ *   Just like thiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiis one.
+ *
+ *   And this one is also very wrong: because the link starts aaaaaaafter the column: <http://line.com>
+ *
+ *   <http://this-long-url-with-a-long-domain-is-not-ok.co.uk/a-long-path?query=variables> and such.
+ *
+ *   And this one is also very wrong: because the code starts aaaaaaafter the column: `alpha.bravo()`
+ *
+ *   `alphaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJuliettKiloLimaMikeNovemberOscar.papa()` and such.
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": 80, "label": "output", "positionless": true}
+ *
+ *   4:86: Line must be at most 80 characters
+ *   6:99: Line must be at most 80 characters
+ *   8:96: Line must be at most 80 characters
+ *   10:97: Line must be at most 80 characters
+ *   12:99: Line must be at most 80 characters
+ *
+ * @example
+ *   {"name": "ok-mixed-line-endings.md", "setting": 10, "positionless": true}
+ *
+ *   0123456789␍␊
+ *   0123456789␊
+ *   01234␍␊
+ *   01234␊
+ *
+ * @example
+ *   {"name": "not-ok-mixed-line-endings.md", "setting": 10, "label": "input", "positionless": true}
+ *
+ *   012345678901␍␊
+ *   012345678901␊
+ *   01234567890␍␊
+ *   01234567890␊
+ *
+ * @example
+ *   {"name": "not-ok-mixed-line-endings.md", "setting": 10, "label": "output", "positionless": true}
+ *
+ *   1:13: Line must be at most 10 characters
+ *   2:13: Line must be at most 10 characters
+ *   3:12: Line must be at most 10 characters
+ *   4:12: Line must be at most 10 characters
+ */
 
-  while (index < length) {
-    code = next;
-    next = value.charCodeAt(index + 1);
+const remarkLintMaximumLineLength = lintRule$g(
+  'remark-lint:maximum-line-length',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 80) => {
+    const value = String(file);
+    const lines = value.split(/\r?\n/);
 
-    if (code === graveAccent$2) {
-      if (closingFenceStart === undefined) {
-        closingFenceStart = index;
+    visit(tree, (node) => {
+      if (
+        (node.type === 'heading' ||
+          node.type === 'table' ||
+          node.type === 'code' ||
+          node.type === 'definition' ||
+          node.type === 'html' ||
+          // @ts-expect-error: JSX is from MDX: <https://github.com/mdx-js/specification>.
+          node.type === 'jsx' ||
+          node.type === 'yaml' ||
+          // @ts-expect-error: TOML is from frontmatter.
+          node.type === 'toml') &&
+        !generated(node)
+      ) {
+        allowList(pointStart(node).line - 1, pointEnd(node).line);
       }
+    });
 
-      closingFenceEnd = index + 1;
+    // Finally, allow some inline spans, but only if they occur at or after
+    // the wrap.
+    // However, when they do, and there’s whitespace after it, they are not
+    // allowed.
+    visit(tree, (node, pos, parent_) => {
+      const parent = /** @type {Parent} */ (parent_);
 
       if (
-        next !== graveAccent$2 &&
-        closingFenceEnd - closingFenceStart === openingFenceEnd
+        (node.type === 'link' ||
+          node.type === 'image' ||
+          node.type === 'inlineCode') &&
+        !generated(node) &&
+        parent &&
+        typeof pos === 'number'
       ) {
-        found = true;
-        break
-      }
-    } else if (closingFenceStart !== undefined) {
-      closingFenceStart = undefined;
-      closingFenceEnd = undefined;
-    }
+        const initial = pointStart(node);
+        const final = pointEnd(node);
 
-    index++;
-  }
+        // Not allowing when starting after the border, or ending before it.
+        if (initial.column > option || final.column < option) {
+          return
+        }
 
-  if (!found) {
-    return
-  }
+        const next = parent.children[pos + 1];
 
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
-  }
+        // Not allowing when there’s whitespace after the link.
+        if (
+          next &&
+          pointStart(next).line === initial.line &&
+          (!('value' in next) || /^(.+?[ \t].+?)/.test(next.value))
+        ) {
+          return
+        }
 
-  // Remove the initial and final space (or line feed), iff they exist and there
-  // are non-space characters in the content.
-  index = openingFenceEnd;
-  length = closingFenceStart;
-  code = value.charCodeAt(index);
-  next = value.charCodeAt(length - 1);
-  found = false;
+        allowList(initial.line - 1, final.line);
+      }
+    });
 
-  if (
-    length - index > 2 &&
-    (code === space$e || code === lineFeed$g) &&
-    (next === space$e || next === lineFeed$g)
-  ) {
-    index++;
-    length--;
+    // Iterate over every line, and warn for violating lines.
+    let index = -1;
 
-    while (index < length) {
-      code = value.charCodeAt(index);
+    while (++index < lines.length) {
+      const lineLength = lines[index].length;
 
-      if (code !== space$e && code !== lineFeed$g) {
-        found = true;
-        break
+      if (lineLength > option) {
+        file.message('Line must be at most ' + option + ' characters', {
+          line: index + 1,
+          column: lineLength + 1
+        });
       }
-
-      index++;
     }
 
-    if (found === true) {
-      openingFenceEnd++;
-      closingFenceStart--;
+    /**
+     * Allowlist from `initial` to `final`, zero-based.
+     *
+     * @param {number} initial
+     * @param {number} final
+     */
+    function allowList(initial, final) {
+      while (initial < final) {
+        lines[initial++] = '';
+      }
     }
   }
+);
 
-  return eat(value.slice(0, closingFenceEnd))({
-    type: 'inlineCode',
-    value: value.slice(openingFenceEnd, closingFenceStart)
-  })
-}
-
-var _break = locate$9;
+var remarkLintMaximumLineLength$1 = remarkLintMaximumLineLength;
 
-function locate$9(value, fromIndex) {
-  var index = value.indexOf('\n', fromIndex);
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  while (index > fromIndex) {
-    if (value.charAt(index - 1) !== ' ') {
-      break
-    }
+const primitives$f = new Set(['string', 'number', 'boolean']);
 
-    index--;
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$f(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  return index
-}
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var _break$1 = hardBreak;
-hardBreak.locator = _break;
+  return plugin
 
-var space$f = ' ';
-var lineFeed$h = '\n';
-var minBreakLength = 2;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$g(ruleId, raw);
 
-function hardBreak(eat, value, silent) {
-  var length = value.length;
-  var index = -1;
-  var queue = '';
-  var character;
+    if (!severity) return
 
-  while (++index < length) {
-    character = value.charAt(index);
+    const fatal = severity === 2;
 
-    if (character === lineFeed$h) {
-      if (index < minBreakLength) {
-        return
-      }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      /* istanbul ignore if - never used (yet) */
-      if (silent) {
-        return true
-      }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-      queue += character;
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-      return eat(queue)({type: 'break'})
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (character !== space$f) {
-      return
+        next();
+      })(tree, file, options);
     }
-
-    queue += character;
   }
 }
 
-var text_1 = text;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$g(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-function text(eat, value, silent) {
-  var self = this;
-  var methods;
-  var tokenizers;
-  var index;
-  var length;
-  var subvalue;
-  var position;
-  var tokenizer;
-  var name;
-  var min;
-  var now;
-
-  /* istanbul ignore if - never used (yet) */
-  if (silent) {
-    return true
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$f.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  methods = self.inlineMethods;
-  length = methods.length;
-  tokenizers = self.inlineTokenizers;
-  index = -1;
-  min = value.length;
-
-  while (++index < length) {
-    name = methods[index];
-
-    if (name === 'text' || !tokenizers[name]) {
-      continue
-    }
-
-    tokenizer = tokenizers[name].locator;
-
-    if (!tokenizer) {
-      eat.file.fail('Missing locator: `' + name + '`');
-    }
-
-    position = tokenizer.call(self, value, 1);
+  let level = result[0];
 
-    if (position !== -1 && position < min) {
-      min = position;
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
   }
 
-  subvalue = value.slice(0, min);
-  now = eat.now();
-
-  self.decode(subvalue, now, handler);
-
-  function handler(content, position, source) {
-    eat(source || content)({type: 'text', value: content});
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
-}
-
-var parser = Parser;
-
-function Parser(doc, file) {
-  this.file = file;
-  this.offset = {};
-  this.options = immutable(this.options);
-  this.setOptions({});
-
-  this.inList = false;
-  this.inBlock = false;
-  this.inLink = false;
-  this.atStart = true;
-
-  this.toOffset = vfileLocation(file).toOffset;
-  this.unescape = _unescape(this, 'escape');
-  this.decode = decode(this);
-}
-
-var proto$4 = Parser.prototype;
-
-// Expose core.
-proto$4.setOptions = setOptions_1;
-proto$4.parse = parse_1$3;
-
-// Expose `defaults`.
-proto$4.options = defaults$2;
-
-// Enter and exit helpers.
-proto$4.exitStart = stateToggle('atStart', true);
-proto$4.enterList = stateToggle('inList', false);
-proto$4.enterLink = stateToggle('inLink', false);
-proto$4.enterBlock = stateToggle('inBlock', false);
-
-// Nodes that can interupt a paragraph:
-//
-// ```markdown
-// A paragraph, followed by a thematic break.
-// ___
-// ```
-//
-// In the above example, the thematic break “interupts” the paragraph.
-proto$4.interruptParagraph = [
-  ['thematicBreak'],
-  ['list'],
-  ['atxHeading'],
-  ['fencedCode'],
-  ['blockquote'],
-  ['html'],
-  ['setextHeading', {commonmark: false}],
-  ['definition', {commonmark: false}]
-];
-
-// Nodes that can interupt a list:
-//
-// ```markdown
-// - One
-// ___
-// ```
-//
-// In the above example, the thematic break “interupts” the list.
-proto$4.interruptList = [
-  ['atxHeading', {pedantic: false}],
-  ['fencedCode', {pedantic: false}],
-  ['thematicBreak', {pedantic: false}],
-  ['definition', {commonmark: false}]
-];
-
-// Nodes that can interupt a blockquote:
-//
-// ```markdown
-// > A paragraph.
-// ___
-// ```
-//
-// In the above example, the thematic break “interupts” the blockquote.
-proto$4.interruptBlockquote = [
-  ['indentedCode', {commonmark: true}],
-  ['fencedCode', {commonmark: true}],
-  ['atxHeading', {commonmark: true}],
-  ['setextHeading', {commonmark: true}],
-  ['thematicBreak', {commonmark: true}],
-  ['html', {commonmark: true}],
-  ['list', {commonmark: true}],
-  ['definition', {commonmark: false}]
-];
-
-// Handlers.
-proto$4.blockTokenizers = {
-  blankLine: blankLine_1,
-  indentedCode: codeIndented,
-  fencedCode: codeFenced,
-  blockquote: blockquote_1,
-  atxHeading: headingAtx,
-  thematicBreak: thematicBreak_1,
-  list: list_1,
-  setextHeading: headingSetext,
-  html: htmlBlock,
-  definition: definition_1,
-  table: table_1,
-  paragraph: paragraph_1
-};
-
-proto$4.inlineTokenizers = {
-  escape: _escape$1,
-  autoLink: autoLink_1,
-  url: url_1,
-  email: email_1,
-  html: htmlInline,
-  link: link_1,
-  reference: reference_1,
-  strong: strong_1,
-  emphasis: emphasis_1,
-  deletion: _delete$1,
-  code: codeInline$1,
-  break: _break$1,
-  text: text_1
-};
-
-// Expose precedence.
-proto$4.blockMethods = keys$1(proto$4.blockTokenizers);
-proto$4.inlineMethods = keys$1(proto$4.inlineTokenizers);
-
-// Tokenizers.
-proto$4.tokenizeBlock = tokenizer('block');
-proto$4.tokenizeInline = tokenizer('inline');
-proto$4.tokenizeFactory = tokenizer;
-
-// Get all keys in `value`.
-function keys$1(value) {
-  var result = [];
-  var key;
 
-  for (key in value) {
-    result.push(key);
-  }
+  result[0] = level;
 
+  // @ts-expect-error: it’s now a valid tuple.
   return result
 }
 
-var remarkParse = parse$a;
-parse$a.Parser = parser;
-
-function parse$a(options) {
-  var settings = this.data('settings');
-  var Local = unherit_1(parser);
-
-  Local.prototype.options = immutable(Local.prototype.options, settings, options);
-
-  this.Parser = Local;
-}
-
-var identity_1 = identity;
-
-function identity(value) {
-  return value
-}
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-consecutive-blank-lines
+ * @fileoverview
+ *   Warn for too many consecutive blank lines.
+ *   Knows about the extra line needed between a list and indented code, and two
+ *   lists.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   always uses one blank line between blocks if possible, or two lines when
+ *   needed.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   Foo…
+ *   ␊
+ *   …Bar.
+ *
+ * @example
+ *   {"name": "empty-document.md"}
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   Foo…
+ *   ␊
+ *   ␊
+ *   …Bar
+ *   ␊
+ *   ␊
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   4:1: Remove 1 line before node
+ *   4:5: Remove 2 lines after node
+ */
 
-var enterLinkReference = enter;
+const remarkLintNoConsecutiveBlankLines = lintRule$f(
+  'remark-lint:no-consecutive-blank-lines',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, (node) => {
+      if (!generated(node) && 'children' in node) {
+        const head = node.children[0];
 
-// Shortcut and collapsed link references need no escaping and encoding during
-// the processing of child nodes (it must be implied from identifier).
-//
-// This toggler turns encoding and escaping off for shortcut and collapsed
-// references.
-//
-// Implies `enterLink`.
-function enter(compiler, node) {
-  var encode = compiler.encode;
-  var escape = compiler.escape;
-  var exitLink = compiler.enterLink();
-
-  if (node.referenceType !== 'shortcut' && node.referenceType !== 'collapsed') {
-    return exitLink
-  }
-
-  compiler.escape = identity_1;
-  compiler.encode = identity_1;
-
-  return exit
-
-  function exit() {
-    compiler.encode = encode;
-    compiler.escape = escape;
-    exitLink();
-  }
-}
-
-var defaults$3 = {
-  gfm: true,
-  commonmark: false,
-  pedantic: false,
-  entities: 'false',
-  setext: false,
-  closeAtx: false,
-  tableCellPadding: true,
-  tablePipeAlign: true,
-  stringLength: stringLength,
-  incrementListMarker: true,
-  fences: false,
-  fence: '`',
-  bullet: '-',
-  listItemIndent: 'tab',
-  rule: '*',
-  ruleSpaces: true,
-  ruleRepetition: 3,
-  strong: '*',
-  emphasis: '_'
-};
-
-function stringLength(value) {
-  return value.length
-}
+        if (head && !generated(head)) {
+          // Compare parent and first child.
+          compare(pointStart(node), pointStart(head), 0);
 
-const nbsp$2 = " ";
-const iexcl$2 = "¡";
-const cent$2 = "¢";
-const pound$2 = "£";
-const curren$2 = "¤";
-const yen$2 = "¥";
-const brvbar$2 = "¦";
-const sect$2 = "§";
-const uml$2 = "¨";
-const copy$3 = "©";
-const ordf$2 = "ª";
-const laquo$2 = "«";
-const not$2 = "¬";
-const shy$2 = "­";
-const reg$2 = "®";
-const macr$2 = "¯";
-const deg$2 = "°";
-const plusmn$2 = "±";
-const sup2$2 = "²";
-const sup3$2 = "³";
-const acute$2 = "´";
-const micro$2 = "µ";
-const para$2 = "¶";
-const middot$2 = "·";
-const cedil$2 = "¸";
-const sup1$2 = "¹";
-const ordm$2 = "º";
-const raquo$2 = "»";
-const frac14$2 = "¼";
-const frac12$2 = "½";
-const frac34$2 = "¾";
-const iquest$2 = "¿";
-const Agrave$2 = "À";
-const Aacute$2 = "Á";
-const Acirc$2 = "Â";
-const Atilde$2 = "Ã";
-const Auml$2 = "Ä";
-const Aring$2 = "Å";
-const AElig$2 = "Æ";
-const Ccedil$2 = "Ç";
-const Egrave$2 = "È";
-const Eacute$2 = "É";
-const Ecirc$2 = "Ê";
-const Euml$2 = "Ë";
-const Igrave$2 = "Ì";
-const Iacute$2 = "Í";
-const Icirc$2 = "Î";
-const Iuml$2 = "Ï";
-const ETH$2 = "Ð";
-const Ntilde$2 = "Ñ";
-const Ograve$2 = "Ò";
-const Oacute$2 = "Ó";
-const Ocirc$2 = "Ô";
-const Otilde$2 = "Õ";
-const Ouml$2 = "Ö";
-const times$2 = "×";
-const Oslash$2 = "Ø";
-const Ugrave$2 = "Ù";
-const Uacute$2 = "Ú";
-const Ucirc$2 = "Û";
-const Uuml$2 = "Ü";
-const Yacute$2 = "Ý";
-const THORN$2 = "Þ";
-const szlig$2 = "ß";
-const agrave$2 = "à";
-const aacute$2 = "á";
-const acirc$2 = "â";
-const atilde$2 = "ã";
-const auml$2 = "ä";
-const aring$2 = "å";
-const aelig$2 = "æ";
-const ccedil$2 = "ç";
-const egrave$2 = "è";
-const eacute$2 = "é";
-const ecirc$2 = "ê";
-const euml$2 = "ë";
-const igrave$2 = "ì";
-const iacute$2 = "í";
-const icirc$2 = "î";
-const iuml$2 = "ï";
-const eth$2 = "ð";
-const ntilde$2 = "ñ";
-const ograve$2 = "ò";
-const oacute$2 = "ó";
-const ocirc$2 = "ô";
-const otilde$2 = "õ";
-const ouml$2 = "ö";
-const divide$2 = "÷";
-const oslash$2 = "ø";
-const ugrave$2 = "ù";
-const uacute$2 = "ú";
-const ucirc$2 = "û";
-const uuml$2 = "ü";
-const yacute$2 = "ý";
-const thorn$2 = "þ";
-const yuml$2 = "ÿ";
-const fnof$1 = "ƒ";
-const Alpha$1 = "Α";
-const Beta$1 = "Β";
-const Gamma$1 = "Γ";
-const Delta$1 = "Δ";
-const Epsilon$1 = "Ε";
-const Zeta$1 = "Ζ";
-const Eta$1 = "Η";
-const Theta$1 = "Θ";
-const Iota$1 = "Ι";
-const Kappa$1 = "Κ";
-const Lambda$1 = "Λ";
-const Mu$1 = "Μ";
-const Nu$1 = "Ν";
-const Xi$1 = "Ξ";
-const Omicron$1 = "Ο";
-const Pi$1 = "Π";
-const Rho$1 = "Ρ";
-const Sigma$1 = "Σ";
-const Tau$1 = "Τ";
-const Upsilon$1 = "Υ";
-const Phi$1 = "Φ";
-const Chi$1 = "Χ";
-const Psi$1 = "Ψ";
-const Omega$1 = "Ω";
-const alpha$1 = "α";
-const beta$1 = "β";
-const gamma$1 = "γ";
-const delta$1 = "δ";
-const epsilon$1 = "ε";
-const zeta$1 = "ζ";
-const eta$1 = "η";
-const theta$1 = "θ";
-const iota$1 = "ι";
-const kappa$1 = "κ";
-const lambda$1 = "λ";
-const mu$1 = "μ";
-const nu$1 = "ν";
-const xi$1 = "ξ";
-const omicron$1 = "ο";
-const pi$1 = "π";
-const rho$1 = "ρ";
-const sigmaf$1 = "ς";
-const sigma$1 = "σ";
-const tau$1 = "τ";
-const upsilon$1 = "υ";
-const phi$1 = "φ";
-const chi$1 = "χ";
-const psi$1 = "ψ";
-const omega$1 = "ω";
-const thetasym$1 = "ϑ";
-const upsih$1 = "ϒ";
-const piv$1 = "ϖ";
-const bull$1 = "•";
-const hellip$1 = "…";
-const prime$1 = "′";
-const Prime$1 = "″";
-const oline$1 = "‾";
-const frasl$1 = "⁄";
-const weierp$1 = "℘";
-const image$2 = "ℑ";
-const real$1 = "ℜ";
-const trade$1 = "™";
-const alefsym$1 = "ℵ";
-const larr$1 = "←";
-const uarr$1 = "↑";
-const rarr$1 = "→";
-const darr$1 = "↓";
-const harr$1 = "↔";
-const crarr$1 = "↵";
-const lArr$1 = "⇐";
-const uArr$1 = "⇑";
-const rArr$1 = "⇒";
-const dArr$1 = "⇓";
-const hArr$1 = "⇔";
-const forall$1 = "∀";
-const part$1 = "∂";
-const exist$1 = "∃";
-const empty$1 = "∅";
-const nabla$1 = "∇";
-const isin$1 = "∈";
-const notin$1 = "∉";
-const ni$1 = "∋";
-const prod$1 = "∏";
-const sum$1 = "∑";
-const minus$1 = "−";
-const lowast$1 = "∗";
-const radic$1 = "√";
-const prop$1 = "∝";
-const infin$1 = "∞";
-const ang$1 = "∠";
-const and$1 = "∧";
-const or$1 = "∨";
-const cap$1 = "∩";
-const cup$1 = "∪";
-const int$1 = "∫";
-const there4$1 = "∴";
-const sim$1 = "∼";
-const cong$1 = "≅";
-const asymp$1 = "≈";
-const ne$1 = "≠";
-const equiv$1 = "≡";
-const le$1 = "≤";
-const ge$1 = "≥";
-const sub$1 = "⊂";
-const sup$1 = "⊃";
-const nsub$1 = "⊄";
-const sube$1 = "⊆";
-const supe$1 = "⊇";
-const oplus$1 = "⊕";
-const otimes$1 = "⊗";
-const perp$1 = "⊥";
-const sdot$1 = "⋅";
-const lceil$1 = "⌈";
-const rceil$1 = "⌉";
-const lfloor$1 = "⌊";
-const rfloor$1 = "⌋";
-const lang$1 = "〈";
-const rang$1 = "〉";
-const loz$1 = "◊";
-const spades$1 = "♠";
-const clubs$1 = "♣";
-const hearts$1 = "♥";
-const diams$1 = "♦";
-const quot$2 = "\"";
-const amp$2 = "&";
-const lt$2 = "<";
-const gt$2 = ">";
-const OElig$1 = "Œ";
-const oelig$1 = "œ";
-const Scaron$1 = "Š";
-const scaron$1 = "š";
-const Yuml$1 = "Ÿ";
-const circ$1 = "ˆ";
-const tilde$4 = "˜";
-const ensp$1 = " ";
-const emsp$1 = " ";
-const thinsp$1 = " ";
-const zwnj$1 = "‌";
-const zwj$1 = "‍";
-const lrm$1 = "‎";
-const rlm$1 = "‏";
-const ndash$1 = "–";
-const mdash$1 = "—";
-const lsquo$1 = "‘";
-const rsquo$1 = "’";
-const sbquo$1 = "‚";
-const ldquo$1 = "“";
-const rdquo$1 = "”";
-const bdquo$1 = "„";
-const dagger$1 = "†";
-const Dagger$1 = "‡";
-const permil$1 = "‰";
-const lsaquo$1 = "‹";
-const rsaquo$1 = "›";
-const euro$1 = "€";
-var index$4 = {
-	nbsp: nbsp$2,
-	iexcl: iexcl$2,
-	cent: cent$2,
-	pound: pound$2,
-	curren: curren$2,
-	yen: yen$2,
-	brvbar: brvbar$2,
-	sect: sect$2,
-	uml: uml$2,
-	copy: copy$3,
-	ordf: ordf$2,
-	laquo: laquo$2,
-	not: not$2,
-	shy: shy$2,
-	reg: reg$2,
-	macr: macr$2,
-	deg: deg$2,
-	plusmn: plusmn$2,
-	sup2: sup2$2,
-	sup3: sup3$2,
-	acute: acute$2,
-	micro: micro$2,
-	para: para$2,
-	middot: middot$2,
-	cedil: cedil$2,
-	sup1: sup1$2,
-	ordm: ordm$2,
-	raquo: raquo$2,
-	frac14: frac14$2,
-	frac12: frac12$2,
-	frac34: frac34$2,
-	iquest: iquest$2,
-	Agrave: Agrave$2,
-	Aacute: Aacute$2,
-	Acirc: Acirc$2,
-	Atilde: Atilde$2,
-	Auml: Auml$2,
-	Aring: Aring$2,
-	AElig: AElig$2,
-	Ccedil: Ccedil$2,
-	Egrave: Egrave$2,
-	Eacute: Eacute$2,
-	Ecirc: Ecirc$2,
-	Euml: Euml$2,
-	Igrave: Igrave$2,
-	Iacute: Iacute$2,
-	Icirc: Icirc$2,
-	Iuml: Iuml$2,
-	ETH: ETH$2,
-	Ntilde: Ntilde$2,
-	Ograve: Ograve$2,
-	Oacute: Oacute$2,
-	Ocirc: Ocirc$2,
-	Otilde: Otilde$2,
-	Ouml: Ouml$2,
-	times: times$2,
-	Oslash: Oslash$2,
-	Ugrave: Ugrave$2,
-	Uacute: Uacute$2,
-	Ucirc: Ucirc$2,
-	Uuml: Uuml$2,
-	Yacute: Yacute$2,
-	THORN: THORN$2,
-	szlig: szlig$2,
-	agrave: agrave$2,
-	aacute: aacute$2,
-	acirc: acirc$2,
-	atilde: atilde$2,
-	auml: auml$2,
-	aring: aring$2,
-	aelig: aelig$2,
-	ccedil: ccedil$2,
-	egrave: egrave$2,
-	eacute: eacute$2,
-	ecirc: ecirc$2,
-	euml: euml$2,
-	igrave: igrave$2,
-	iacute: iacute$2,
-	icirc: icirc$2,
-	iuml: iuml$2,
-	eth: eth$2,
-	ntilde: ntilde$2,
-	ograve: ograve$2,
-	oacute: oacute$2,
-	ocirc: ocirc$2,
-	otilde: otilde$2,
-	ouml: ouml$2,
-	divide: divide$2,
-	oslash: oslash$2,
-	ugrave: ugrave$2,
-	uacute: uacute$2,
-	ucirc: ucirc$2,
-	uuml: uuml$2,
-	yacute: yacute$2,
-	thorn: thorn$2,
-	yuml: yuml$2,
-	fnof: fnof$1,
-	Alpha: Alpha$1,
-	Beta: Beta$1,
-	Gamma: Gamma$1,
-	Delta: Delta$1,
-	Epsilon: Epsilon$1,
-	Zeta: Zeta$1,
-	Eta: Eta$1,
-	Theta: Theta$1,
-	Iota: Iota$1,
-	Kappa: Kappa$1,
-	Lambda: Lambda$1,
-	Mu: Mu$1,
-	Nu: Nu$1,
-	Xi: Xi$1,
-	Omicron: Omicron$1,
-	Pi: Pi$1,
-	Rho: Rho$1,
-	Sigma: Sigma$1,
-	Tau: Tau$1,
-	Upsilon: Upsilon$1,
-	Phi: Phi$1,
-	Chi: Chi$1,
-	Psi: Psi$1,
-	Omega: Omega$1,
-	alpha: alpha$1,
-	beta: beta$1,
-	gamma: gamma$1,
-	delta: delta$1,
-	epsilon: epsilon$1,
-	zeta: zeta$1,
-	eta: eta$1,
-	theta: theta$1,
-	iota: iota$1,
-	kappa: kappa$1,
-	lambda: lambda$1,
-	mu: mu$1,
-	nu: nu$1,
-	xi: xi$1,
-	omicron: omicron$1,
-	pi: pi$1,
-	rho: rho$1,
-	sigmaf: sigmaf$1,
-	sigma: sigma$1,
-	tau: tau$1,
-	upsilon: upsilon$1,
-	phi: phi$1,
-	chi: chi$1,
-	psi: psi$1,
-	omega: omega$1,
-	thetasym: thetasym$1,
-	upsih: upsih$1,
-	piv: piv$1,
-	bull: bull$1,
-	hellip: hellip$1,
-	prime: prime$1,
-	Prime: Prime$1,
-	oline: oline$1,
-	frasl: frasl$1,
-	weierp: weierp$1,
-	image: image$2,
-	real: real$1,
-	trade: trade$1,
-	alefsym: alefsym$1,
-	larr: larr$1,
-	uarr: uarr$1,
-	rarr: rarr$1,
-	darr: darr$1,
-	harr: harr$1,
-	crarr: crarr$1,
-	lArr: lArr$1,
-	uArr: uArr$1,
-	rArr: rArr$1,
-	dArr: dArr$1,
-	hArr: hArr$1,
-	forall: forall$1,
-	part: part$1,
-	exist: exist$1,
-	empty: empty$1,
-	nabla: nabla$1,
-	isin: isin$1,
-	notin: notin$1,
-	ni: ni$1,
-	prod: prod$1,
-	sum: sum$1,
-	minus: minus$1,
-	lowast: lowast$1,
-	radic: radic$1,
-	prop: prop$1,
-	infin: infin$1,
-	ang: ang$1,
-	and: and$1,
-	or: or$1,
-	cap: cap$1,
-	cup: cup$1,
-	int: int$1,
-	there4: there4$1,
-	sim: sim$1,
-	cong: cong$1,
-	asymp: asymp$1,
-	ne: ne$1,
-	equiv: equiv$1,
-	le: le$1,
-	ge: ge$1,
-	sub: sub$1,
-	sup: sup$1,
-	nsub: nsub$1,
-	sube: sube$1,
-	supe: supe$1,
-	oplus: oplus$1,
-	otimes: otimes$1,
-	perp: perp$1,
-	sdot: sdot$1,
-	lceil: lceil$1,
-	rceil: rceil$1,
-	lfloor: lfloor$1,
-	rfloor: rfloor$1,
-	lang: lang$1,
-	rang: rang$1,
-	loz: loz$1,
-	spades: spades$1,
-	clubs: clubs$1,
-	hearts: hearts$1,
-	diams: diams$1,
-	quot: quot$2,
-	amp: amp$2,
-	lt: lt$2,
-	gt: gt$2,
-	OElig: OElig$1,
-	oelig: oelig$1,
-	Scaron: Scaron$1,
-	scaron: scaron$1,
-	Yuml: Yuml$1,
-	circ: circ$1,
-	tilde: tilde$4,
-	ensp: ensp$1,
-	emsp: emsp$1,
-	thinsp: thinsp$1,
-	zwnj: zwnj$1,
-	zwj: zwj$1,
-	lrm: lrm$1,
-	rlm: rlm$1,
-	ndash: ndash$1,
-	mdash: mdash$1,
-	lsquo: lsquo$1,
-	rsquo: rsquo$1,
-	sbquo: sbquo$1,
-	ldquo: ldquo$1,
-	rdquo: rdquo$1,
-	bdquo: bdquo$1,
-	dagger: dagger$1,
-	Dagger: Dagger$1,
-	permil: permil$1,
-	lsaquo: lsaquo$1,
-	rsaquo: rsaquo$1,
-	euro: euro$1
-};
-
-var characterEntitiesHtml4 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  nbsp: nbsp$2,
-  iexcl: iexcl$2,
-  cent: cent$2,
-  pound: pound$2,
-  curren: curren$2,
-  yen: yen$2,
-  brvbar: brvbar$2,
-  sect: sect$2,
-  uml: uml$2,
-  copy: copy$3,
-  ordf: ordf$2,
-  laquo: laquo$2,
-  not: not$2,
-  shy: shy$2,
-  reg: reg$2,
-  macr: macr$2,
-  deg: deg$2,
-  plusmn: plusmn$2,
-  sup2: sup2$2,
-  sup3: sup3$2,
-  acute: acute$2,
-  micro: micro$2,
-  para: para$2,
-  middot: middot$2,
-  cedil: cedil$2,
-  sup1: sup1$2,
-  ordm: ordm$2,
-  raquo: raquo$2,
-  frac14: frac14$2,
-  frac12: frac12$2,
-  frac34: frac34$2,
-  iquest: iquest$2,
-  Agrave: Agrave$2,
-  Aacute: Aacute$2,
-  Acirc: Acirc$2,
-  Atilde: Atilde$2,
-  Auml: Auml$2,
-  Aring: Aring$2,
-  AElig: AElig$2,
-  Ccedil: Ccedil$2,
-  Egrave: Egrave$2,
-  Eacute: Eacute$2,
-  Ecirc: Ecirc$2,
-  Euml: Euml$2,
-  Igrave: Igrave$2,
-  Iacute: Iacute$2,
-  Icirc: Icirc$2,
-  Iuml: Iuml$2,
-  ETH: ETH$2,
-  Ntilde: Ntilde$2,
-  Ograve: Ograve$2,
-  Oacute: Oacute$2,
-  Ocirc: Ocirc$2,
-  Otilde: Otilde$2,
-  Ouml: Ouml$2,
-  times: times$2,
-  Oslash: Oslash$2,
-  Ugrave: Ugrave$2,
-  Uacute: Uacute$2,
-  Ucirc: Ucirc$2,
-  Uuml: Uuml$2,
-  Yacute: Yacute$2,
-  THORN: THORN$2,
-  szlig: szlig$2,
-  agrave: agrave$2,
-  aacute: aacute$2,
-  acirc: acirc$2,
-  atilde: atilde$2,
-  auml: auml$2,
-  aring: aring$2,
-  aelig: aelig$2,
-  ccedil: ccedil$2,
-  egrave: egrave$2,
-  eacute: eacute$2,
-  ecirc: ecirc$2,
-  euml: euml$2,
-  igrave: igrave$2,
-  iacute: iacute$2,
-  icirc: icirc$2,
-  iuml: iuml$2,
-  eth: eth$2,
-  ntilde: ntilde$2,
-  ograve: ograve$2,
-  oacute: oacute$2,
-  ocirc: ocirc$2,
-  otilde: otilde$2,
-  ouml: ouml$2,
-  divide: divide$2,
-  oslash: oslash$2,
-  ugrave: ugrave$2,
-  uacute: uacute$2,
-  ucirc: ucirc$2,
-  uuml: uuml$2,
-  yacute: yacute$2,
-  thorn: thorn$2,
-  yuml: yuml$2,
-  fnof: fnof$1,
-  Alpha: Alpha$1,
-  Beta: Beta$1,
-  Gamma: Gamma$1,
-  Delta: Delta$1,
-  Epsilon: Epsilon$1,
-  Zeta: Zeta$1,
-  Eta: Eta$1,
-  Theta: Theta$1,
-  Iota: Iota$1,
-  Kappa: Kappa$1,
-  Lambda: Lambda$1,
-  Mu: Mu$1,
-  Nu: Nu$1,
-  Xi: Xi$1,
-  Omicron: Omicron$1,
-  Pi: Pi$1,
-  Rho: Rho$1,
-  Sigma: Sigma$1,
-  Tau: Tau$1,
-  Upsilon: Upsilon$1,
-  Phi: Phi$1,
-  Chi: Chi$1,
-  Psi: Psi$1,
-  Omega: Omega$1,
-  alpha: alpha$1,
-  beta: beta$1,
-  gamma: gamma$1,
-  delta: delta$1,
-  epsilon: epsilon$1,
-  zeta: zeta$1,
-  eta: eta$1,
-  theta: theta$1,
-  iota: iota$1,
-  kappa: kappa$1,
-  lambda: lambda$1,
-  mu: mu$1,
-  nu: nu$1,
-  xi: xi$1,
-  omicron: omicron$1,
-  pi: pi$1,
-  rho: rho$1,
-  sigmaf: sigmaf$1,
-  sigma: sigma$1,
-  tau: tau$1,
-  upsilon: upsilon$1,
-  phi: phi$1,
-  chi: chi$1,
-  psi: psi$1,
-  omega: omega$1,
-  thetasym: thetasym$1,
-  upsih: upsih$1,
-  piv: piv$1,
-  bull: bull$1,
-  hellip: hellip$1,
-  prime: prime$1,
-  Prime: Prime$1,
-  oline: oline$1,
-  frasl: frasl$1,
-  weierp: weierp$1,
-  image: image$2,
-  real: real$1,
-  trade: trade$1,
-  alefsym: alefsym$1,
-  larr: larr$1,
-  uarr: uarr$1,
-  rarr: rarr$1,
-  darr: darr$1,
-  harr: harr$1,
-  crarr: crarr$1,
-  lArr: lArr$1,
-  uArr: uArr$1,
-  rArr: rArr$1,
-  dArr: dArr$1,
-  hArr: hArr$1,
-  forall: forall$1,
-  part: part$1,
-  exist: exist$1,
-  empty: empty$1,
-  nabla: nabla$1,
-  isin: isin$1,
-  notin: notin$1,
-  ni: ni$1,
-  prod: prod$1,
-  sum: sum$1,
-  minus: minus$1,
-  lowast: lowast$1,
-  radic: radic$1,
-  prop: prop$1,
-  infin: infin$1,
-  ang: ang$1,
-  and: and$1,
-  or: or$1,
-  cap: cap$1,
-  cup: cup$1,
-  int: int$1,
-  there4: there4$1,
-  sim: sim$1,
-  cong: cong$1,
-  asymp: asymp$1,
-  ne: ne$1,
-  equiv: equiv$1,
-  le: le$1,
-  ge: ge$1,
-  sub: sub$1,
-  sup: sup$1,
-  nsub: nsub$1,
-  sube: sube$1,
-  supe: supe$1,
-  oplus: oplus$1,
-  otimes: otimes$1,
-  perp: perp$1,
-  sdot: sdot$1,
-  lceil: lceil$1,
-  rceil: rceil$1,
-  lfloor: lfloor$1,
-  rfloor: rfloor$1,
-  lang: lang$1,
-  rang: rang$1,
-  loz: loz$1,
-  spades: spades$1,
-  clubs: clubs$1,
-  hearts: hearts$1,
-  diams: diams$1,
-  quot: quot$2,
-  amp: amp$2,
-  lt: lt$2,
-  gt: gt$2,
-  OElig: OElig$1,
-  oelig: oelig$1,
-  Scaron: Scaron$1,
-  scaron: scaron$1,
-  Yuml: Yuml$1,
-  circ: circ$1,
-  tilde: tilde$4,
-  ensp: ensp$1,
-  emsp: emsp$1,
-  thinsp: thinsp$1,
-  zwnj: zwnj$1,
-  zwj: zwj$1,
-  lrm: lrm$1,
-  rlm: rlm$1,
-  ndash: ndash$1,
-  mdash: mdash$1,
-  lsquo: lsquo$1,
-  rsquo: rsquo$1,
-  sbquo: sbquo$1,
-  ldquo: ldquo$1,
-  rdquo: rdquo$1,
-  bdquo: bdquo$1,
-  dagger: dagger$1,
-  Dagger: Dagger$1,
-  permil: permil$1,
-  lsaquo: lsaquo$1,
-  rsaquo: rsaquo$1,
-  euro: euro$1,
-  'default': index$4
-});
+          // Compare between each child.
+          let index = -1;
 
-var dangerous = [
-	"cent",
-	"copy",
-	"divide",
-	"gt",
-	"lt",
-	"not",
-	"para",
-	"times"
-];
+          while (++index < node.children.length) {
+            const previous = node.children[index - 1];
+            const child = node.children[index];
 
-var dangerous$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': dangerous
-});
+            if (previous && !generated(previous) && !generated(child)) {
+              compare(pointEnd(previous), pointStart(child), 2);
+            }
+          }
 
-var entities = getCjsExportFromNamespace(characterEntitiesHtml4);
+          const tail = node.children[node.children.length - 1];
 
-var dangerous$2 = getCjsExportFromNamespace(dangerous$1);
+          // Compare parent and last child.
+          if (tail !== head && !generated(tail)) {
+            compare(pointEnd(node), pointEnd(tail), 1);
+          }
+        }
+      }
+    });
 
-var decimal$1 = isDecimal;
+    /**
+     * Compare the difference between `start` and `end`, and warn when that
+     * difference exceeds `max`.
+     *
+     * @param {Point} start
+     * @param {Point} end
+     * @param {0|1|2} max
+     */
+    function compare(start, end, max) {
+      const diff = end.line - start.line;
+      const lines = Math.abs(diff) - max;
 
+      if (lines > 0) {
+        file.message(
+          'Remove ' +
+            lines +
+            ' ' +
+            plural('line', Math.abs(lines)) +
+            ' ' +
+            (diff > 0 ? 'before' : 'after') +
+            ' node',
+          end
+        );
+      }
+    }
+  }
+);
 
+var remarkLintNoConsecutiveBlankLines$1 = remarkLintNoConsecutiveBlankLines;
 
-var stringifyEntities = encode;
-encode.escape = escape$2;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-var own$5 = {}.hasOwnProperty;
+const primitives$e = new Set(['string', 'number', 'boolean']);
 
-// Characters
-var equalsTo$2 = 61;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$e(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-// List of enforced escapes.
-var escapes$1 = ['"', "'", '<', '>', '&', '`'];
+  Object.defineProperty(plugin, 'name', {value: id});
 
-// Map of characters to names.
-var characters = construct();
+  return plugin
 
-// Default escapes.
-var defaultEscapes = toExpression(escapes$1);
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$f(ruleId, raw);
 
-// Surrogate pairs.
-var surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+    if (!severity) return
 
-// Non-ASCII characters.
-// eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
-var bmp = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+    const fatal = severity === 2;
 
-// Encode special characters in `value`.
-function encode(value, options) {
-  var settings = options || {};
-  var subset = settings.subset;
-  var set = subset ? toExpression(subset) : defaultEscapes;
-  var escapeOnly = settings.escapeOnly;
-  var omit = settings.omitOptionalSemicolons;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  value = value.replace(set, replace);
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  if (subset || escapeOnly) {
-    return value
-  }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  return value
-    .replace(surrogatePair, replaceSurrogatePair)
-    .replace(bmp, replace)
-
-  function replaceSurrogatePair(pair, pos, slice) {
-    return toHexReference(
-      (pair.charCodeAt(0) - 0xd800) * 0x400 +
-        pair.charCodeAt(1) -
-        0xdc00 +
-        0x10000,
-      slice.charCodeAt(pos + 2),
-      omit
-    )
-  }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-  function replace(char, pos, slice) {
-    return one$1(char, slice.charCodeAt(pos + 1), settings)
+        next();
+      })(tree, file, options);
+    }
   }
 }
 
-// Shortcut to escape special characters in HTML.
-function escape$2(value) {
-  return encode(value, {escapeOnly: true, useNamedReferences: true})
-}
-
-// Encode `char` according to `options`.
-function one$1(char, next, options) {
-  var shortest = options.useShortestReferences;
-  var omit = options.omitOptionalSemicolons;
-  var named;
-  var code;
-  var numeric;
-  var decimal;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$f(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if ((shortest || options.useNamedReferences) && own$5.call(characters, char)) {
-    named = toNamed(characters[char], next, omit, options.attribute);
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$e.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  if (shortest || !named) {
-    code = char.charCodeAt(0);
-    numeric = toHexReference(code, next, omit);
+  let level = result[0];
 
-    // Use the shortest numeric reference when requested.
-    // A simple algorithm would use decimal for all code points under 100, as
-    // those are shorter than hexadecimal:
-    //
-    // * `&#99;` vs `&#x63;` (decimal shorter)
-    // * `&#100;` vs `&#x64;` (equal)
-    //
-    // However, because we take `next` into consideration when `omit` is used,
-    // And it would be possible that decimals are shorter on bigger values as
-    // well if `next` is hexadecimal but not decimal, we instead compare both.
-    if (shortest) {
-      decimal = toDecimalReference(code, next, omit);
-
-      if (decimal.length < numeric.length) {
-        numeric = decimal;
-      }
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
   }
 
-  if (named && (!shortest || named.length < numeric.length)) {
-    return named
-  }
-
-  return numeric
-}
-
-// Transform `code` into an entity.
-function toNamed(name, next, omit, attribute) {
-  var value = '&' + name;
-
-  if (
-    omit &&
-    own$5.call(legacy, name) &&
-    dangerous$2.indexOf(name) === -1 &&
-    (!attribute || (next && next !== equalsTo$2 && !isAlphanumerical(next)))
-  ) {
-    return value
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  return value + ';'
-}
-
-// Transform `code` into a hexadecimal character reference.
-function toHexReference(code, next, omit) {
-  var value = '&#x' + code.toString(16).toUpperCase();
-  return omit && next && !isHexadecimal(next) ? value : value + ';'
-}
+  result[0] = level;
 
-// Transform `code` into a decimal character reference.
-function toDecimalReference(code, next, omit) {
-  var value = '&#' + String(code);
-  return omit && next && !decimal$1(next) ? value : value + ';'
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-// Create an expression for `characters`.
-function toExpression(characters) {
-  return new RegExp('[' + characters.join('') + ']', 'g')
-}
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-file-name-articles
+ * @fileoverview
+ *   Warn when file names start with an article.
+ *
+ * @example
+ *   {"name": "title.md"}
+ *
+ * @example
+ *   {"name": "a-title.md", "label": "output", "positionless": true}
+ *
+ *   1:1: Do not start file names with `a`
+ *
+ * @example
+ *   {"name": "the-title.md", "label": "output", "positionless": true}
+ *
+ *   1:1: Do not start file names with `the`
+ *
+ * @example
+ *   {"name": "teh-title.md", "label": "output", "positionless": true}
+ *
+ *   1:1: Do not start file names with `teh`
+ *
+ * @example
+ *   {"name": "an-article.md", "label": "output", "positionless": true}
+ *
+ *   1:1: Do not start file names with `an`
+ */
 
-// Construct the map.
-function construct() {
-  var chars = {};
-  var name;
+const remarkLintNoFileNameArticles = lintRule$e(
+  'remark-lint:no-file-name-articles',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (_, file) => {
+    const match = file.stem && file.stem.match(/^(the|teh|an?)\b/i);
 
-  for (name in entities) {
-    chars[entities[name]] = name;
+    if (match) {
+      file.message('Do not start file names with `' + match[0] + '`');
+    }
   }
+);
 
-  return chars
-}
-
-var isAlphanumeric = function (str) {
-	if (typeof str !== 'string') {
-		throw new TypeError('Expected a string');
-	}
-
-	return !/[^0-9a-z\xDF-\xFF]/.test(str.toLowerCase());
-};
-
-var entityPrefixLength = length;
+var remarkLintNoFileNameArticles$1 = remarkLintNoFileNameArticles;
 
-var ampersand$2 = '&';
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-// Returns the length of HTML entity that is a prefix of the given string
-// (excluding the ampersand), 0 if it does not start with an entity.
-function length(value) {
-  var prefix;
+const primitives$d = new Set(['string', 'number', 'boolean']);
 
-  /* istanbul ignore if - Currently also tested for at implemention, but we
-   * keep it here because that’s proper. */
-  if (value.charAt(0) !== ampersand$2) {
-    return 0
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$d(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  prefix = value.split(ampersand$2, 2).join(ampersand$2);
-
-  return prefix.length - parseEntities_1(prefix).length
-}
-
-var _escape$2 = factory$6;
-
-var tab$d = '\t';
-var lineFeed$i = '\n';
-var space$g = ' ';
-var numberSign$2 = '#';
-var ampersand$3 = '&';
-var leftParenthesis$2 = '(';
-var rightParenthesis$4 = ')';
-var asterisk$5 = '*';
-var plusSign$3 = '+';
-var dash$8 = '-';
-var dot$5 = '.';
-var colon$4 = ':';
-var lessThan$7 = '<';
-var greaterThan$4 = '>';
-var leftSquareBracket$3 = '[';
-var backslash$9 = '\\';
-var rightSquareBracket$3 = ']';
-var underscore$7 = '_';
-var graveAccent$3 = '`';
-var verticalBar$1 = '|';
-var tilde$5 = '~';
-var exclamationMark$5 = '!';
-
-var entities$1 = {
-  '<': '&lt;',
-  ':': '&#x3A;',
-  '&': '&amp;',
-  '|': '&#x7C;',
-  '~': '&#x7E;'
-};
-
-var shortcut$1 = 'shortcut';
-var mailto$1 = 'mailto';
-var https = 'https';
-var http = 'http';
-
-var blankExpression = /\n\s*$/;
-
-// Factory to escape characters.
-function factory$6(options) {
-  return escape
-
-  // Escape punctuation characters in a node’s value.
-  function escape(value, node, parent) {
-    var self = this;
-    var gfm = options.gfm;
-    var commonmark = options.commonmark;
-    var pedantic = options.pedantic;
-    var markers = commonmark ? [dot$5, rightParenthesis$4] : [dot$5];
-    var siblings = parent && parent.children;
-    var index = siblings && siblings.indexOf(node);
-    var previous = siblings && siblings[index - 1];
-    var next = siblings && siblings[index + 1];
-    var length = value.length;
-    var escapable = markdownEscapes(options);
-    var position = -1;
-    var queue = [];
-    var escaped = queue;
-    var afterNewLine;
-    var character;
-    var wordCharBefore;
-    var wordCharAfter;
-    var offset;
-    var replace;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-    if (previous) {
-      afterNewLine = text$1(previous) && blankExpression.test(previous.value);
-    } else {
-      afterNewLine =
-        !parent || parent.type === 'root' || parent.type === 'paragraph';
-    }
+  return plugin
 
-    while (++position < length) {
-      character = value.charAt(position);
-      replace = false;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$e(ruleId, raw);
 
-      if (character === '\n') {
-        afterNewLine = true;
-      } else if (
-        character === backslash$9 ||
-        character === graveAccent$3 ||
-        character === asterisk$5 ||
-        character === leftSquareBracket$3 ||
-        character === lessThan$7 ||
-        (character === ampersand$3 && entityPrefixLength(value.slice(position)) > 0) ||
-        (character === rightSquareBracket$3 && self.inLink) ||
-        (gfm && character === tilde$5 && value.charAt(position + 1) === tilde$5) ||
-        (gfm &&
-          character === verticalBar$1 &&
-          (self.inTable || alignment(value, position))) ||
-        (character === underscore$7 &&
-          // Delegate leading/trailing underscores to the multinode version below.
-          position > 0 &&
-          position < length - 1 &&
-          (pedantic ||
-            !isAlphanumeric(value.charAt(position - 1)) ||
-            !isAlphanumeric(value.charAt(position + 1)))) ||
-        (gfm && !self.inLink && character === colon$4 && protocol(queue.join('')))
-      ) {
-        replace = true;
-      } else if (afterNewLine) {
-        if (
-          character === greaterThan$4 ||
-          character === numberSign$2 ||
-          character === asterisk$5 ||
-          character === dash$8 ||
-          character === plusSign$3
-        ) {
-          replace = true;
-        } else if (isDecimal(character)) {
-          offset = position + 1;
+    if (!severity) return
 
-          while (offset < length) {
-            if (!isDecimal(value.charAt(offset))) {
-              break
-            }
+    const fatal = severity === 2;
 
-            offset++;
-          }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-          if (markers.indexOf(value.charAt(offset)) !== -1) {
-            next = value.charAt(offset + 1);
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-            if (!next || next === space$g || next === tab$d || next === lineFeed$i) {
-              queue.push(value.slice(position, offset));
-              position = offset;
-              character = value.charAt(position);
-              replace = true;
-            }
-          }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
-      }
 
-      if (afterNewLine && !isWhitespaceCharacter(character)) {
-        afterNewLine = false;
-      }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-      queue.push(replace ? one(character) : character);
+        next();
+      })(tree, file, options);
     }
+  }
+}
 
-    // Multi-node versions.
-    if (siblings && text$1(node)) {
-      // Check for an opening parentheses after a link-reference (which can be
-      // joined by white-space).
-      if (previous && previous.referenceType === shortcut$1) {
-        position = -1;
-        length = escaped.length;
-
-        while (++position < length) {
-          character = escaped[position];
-
-          if (character === space$g || character === tab$d) {
-            continue
-          }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$e(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-          if (character === leftParenthesis$2 || character === colon$4) {
-            escaped[position] = one(character);
-          }
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$d.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-          break
-        }
+  let level = result[0];
 
-        // If the current node is all spaces / tabs, preceded by a shortcut,
-        // and followed by a text starting with `(`, escape it.
-        if (
-          text$1(next) &&
-          position === length &&
-          next.value.charAt(0) === leftParenthesis$2
-        ) {
-          escaped.push(backslash$9);
-        }
-      }
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
+  }
 
-      // Ensure non-auto-links are not seen as links.  This pattern needs to
-      // check the preceding nodes too.
-      if (
-        gfm &&
-        !self.inLink &&
-        text$1(previous) &&
-        value.charAt(0) === colon$4 &&
-        protocol(previous.value.slice(-6))
-      ) {
-        escaped[0] = one(colon$4);
-      }
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-      // Escape ampersand if it would otherwise start an entity.
-      if (
-        text$1(next) &&
-        value.charAt(length - 1) === ampersand$3 &&
-        entityPrefixLength(ampersand$3 + next.value) !== 0
-      ) {
-        escaped[escaped.length - 1] = one(ampersand$3);
-      }
+  result[0] = level;
 
-      // Escape exclamation marks immediately followed by links.
-      if (
-        next &&
-        next.type === 'link' &&
-        value.charAt(length - 1) === exclamationMark$5
-      ) {
-        escaped[escaped.length - 1] = one(exclamationMark$5);
-      }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-      // Escape double tildes in GFM.
-      if (
-        gfm &&
-        text$1(next) &&
-        value.charAt(length - 1) === tilde$5 &&
-        next.value.charAt(0) === tilde$5
-      ) {
-        escaped.splice(-1, 0, backslash$9);
-      }
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-file-name-consecutive-dashes
+ * @fileoverview
+ *   Warn when file names contain consecutive dashes.
+ *
+ * @example
+ *   {"name": "plug-ins.md"}
+ *
+ * @example
+ *   {"name": "plug--ins.md", "label": "output", "positionless": true}
+ *
+ *   1:1: Do not use consecutive dashes in a file name
+ */
 
-      // Escape underscores, but not mid-word (unless in pedantic mode).
-      wordCharBefore = text$1(previous) && isAlphanumeric(previous.value.slice(-1));
-      wordCharAfter = text$1(next) && isAlphanumeric(next.value.charAt(0));
+const remarkLintNoFileNameConsecutiveDashes = lintRule$d(
+  'remark-lint:no-file-name-consecutive-dashes',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (_, file) => {
+    if (file.stem && /-{2,}/.test(file.stem)) {
+      file.message('Do not use consecutive dashes in a file name');
+    }
+  }
+);
 
-      if (length === 1) {
-        if (
-          value === underscore$7 &&
-          (pedantic || !wordCharBefore || !wordCharAfter)
-        ) {
-          escaped.unshift(backslash$9);
-        }
-      } else {
-        if (
-          value.charAt(0) === underscore$7 &&
-          (pedantic || !wordCharBefore || !isAlphanumeric(value.charAt(1)))
-        ) {
-          escaped.unshift(backslash$9);
-        }
+var remarkLintNoFileNameConsecutiveDashes$1 = remarkLintNoFileNameConsecutiveDashes;
 
-        if (
-          value.charAt(length - 1) === underscore$7 &&
-          (pedantic ||
-            !wordCharAfter ||
-            !isAlphanumeric(value.charAt(length - 2)))
-        ) {
-          escaped.splice(-1, 0, backslash$9);
-        }
-      }
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    return escaped.join('')
+const primitives$c = new Set(['string', 'number', 'boolean']);
 
-    function one(character) {
-      return escapable.indexOf(character) === -1
-        ? entities$1[character]
-        : backslash$9 + character
-    }
-  }
-}
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$c(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-// Check if `index` in `value` is inside an alignment row.
-function alignment(value, index) {
-  var start = value.lastIndexOf(lineFeed$i, index);
-  var end = value.indexOf(lineFeed$i, index);
-  var char;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  end = end === -1 ? value.length : end;
+  return plugin
 
-  while (++start < end) {
-    char = value.charAt(start);
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$d(ruleId, raw);
 
-    if (
-      char !== colon$4 &&
-      char !== dash$8 &&
-      char !== space$g &&
-      char !== verticalBar$1
-    ) {
-      return false
-    }
-  }
+    if (!severity) return
 
-  return true
-}
+    const fatal = severity === 2;
 
-// Check if `node` is a text node.
-function text$1(node) {
-  return node && node.type === 'text'
-}
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-// Check if `value` ends in a protocol.
-function protocol(value) {
-  var tail = value.slice(-6).toLowerCase();
-  return tail === mailto$1 || tail.slice(-5) === https || tail.slice(-4) === http
-}
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-var setOptions_1$1 = setOptions$1;
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-// Map of applicable enums.
-var maps = {
-  entities: {true: true, false: true, numbers: true, escape: true},
-  bullet: {'*': true, '-': true, '+': true},
-  rule: {'-': true, _: true, '*': true},
-  listItemIndent: {tab: true, mixed: true, 1: true},
-  emphasis: {_: true, '*': true},
-  strong: {_: true, '*': true},
-  fence: {'`': true, '~': true}
-};
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-// Expose `validate`.
-var validate = {
-  boolean: validateBoolean,
-  string: validateString,
-  number: validateNumber,
-  function: validateFunction
-};
+        next();
+      })(tree, file, options);
+    }
+  }
+}
 
-// Set options.  Does not overwrite previously set options.
-function setOptions$1(options) {
-  var self = this;
-  var current = self.options;
-  var ruleRepetition;
-  var key;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$d(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if (options == null) {
-    options = {};
-  } else if (typeof options === 'object') {
-    options = immutable(options);
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$c.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
   } else {
-    throw new Error('Invalid value `' + options + '` for setting `options`')
-  }
-
-  for (key in defaults$3) {
-    validate[typeof defaults$3[key]](options, key, current[key], maps[key]);
+    result = [1, value];
   }
 
-  ruleRepetition = options.ruleRepetition;
+  let level = result[0];
 
-  if (ruleRepetition && ruleRepetition < 3) {
-    raise(ruleRepetition, 'options.ruleRepetition');
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  self.encode = encodeFactory(String(options.entities));
-  self.escape = _escape$2(options);
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-  self.options = options;
+  result[0] = level;
 
-  return self
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-// Validate a value to be boolean. Defaults to `def`.  Raises an exception with
-// `context[name]` when not a boolean.
-function validateBoolean(context, name, def) {
-  var value = context[name];
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-file-name-outer-dashes
+ * @fileoverview
+ *   Warn when file names contain initial or final dashes (hyphen-minus, `-`).
+ *
+ * @example
+ *   {"name": "readme.md"}
+ *
+ * @example
+ *   {"name": "-readme.md", "label": "output", "positionless": true}
+ *
+ *   1:1: Do not use initial or final dashes in a file name
+ *
+ * @example
+ *   {"name": "readme-.md", "label": "output", "positionless": true}
+ *
+ *   1:1: Do not use initial or final dashes in a file name
+ */
 
-  if (value == null) {
-    value = def;
+const remarkLintNofileNameOuterDashes = lintRule$c(
+  'remark-lint:no-file-name-outer-dashes',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (_, file) => {
+    if (file.stem && /^-|-$/.test(file.stem)) {
+      file.message('Do not use initial or final dashes in a file name');
+    }
   }
+);
 
-  if (typeof value !== 'boolean') {
-    raise(value, 'options.' + name);
-  }
+var remarkLintNofileNameOuterDashes$1 = remarkLintNofileNameOuterDashes;
 
-  context[name] = value;
-}
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-// Validate a value to be boolean. Defaults to `def`.  Raises an exception with
-// `context[name]` when not a boolean.
-function validateNumber(context, name, def) {
-  var value = context[name];
+const primitives$b = new Set(['string', 'number', 'boolean']);
 
-  if (value == null) {
-    value = def;
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$b(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  if (isNaN(value)) {
-    raise(value, 'options.' + name);
-  }
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  context[name] = value;
-}
+  return plugin
 
-// Validate a value to be in `map`. Defaults to `def`.  Raises an exception
-// with `context[name]` when not in `map`.
-function validateString(context, name, def, map) {
-  var value = context[name];
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$c(ruleId, raw);
 
-  if (value == null) {
-    value = def;
-  }
+    if (!severity) return
 
-  value = String(value);
+    const fatal = severity === 2;
 
-  if (!(value in map)) {
-    raise(value, 'options.' + name);
-  }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  context[name] = value;
-}
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-// Validate a value to be function. Defaults to `def`.  Raises an exception
-// with `context[name]` when not a function.
-function validateFunction(context, name, def) {
-  var value = context[name];
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  if (value == null) {
-    value = def;
-  }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-  if (typeof value !== 'function') {
-    raise(value, 'options.' + name);
+        next();
+      })(tree, file, options);
+    }
   }
-
-  context[name] = value;
 }
 
-// Factory to encode HTML entities.  Creates a no-operation function when
-// `type` is `'false'`, a function which encodes using named references when
-// `type` is `'true'`, and a function which encodes using numbered references
-// when `type` is `'numbers'`.
-function encodeFactory(type) {
-  var options = {};
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$c(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if (type === 'false') {
-    return identity_1
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$b.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  if (type === 'true') {
-    options.useNamedReferences = true;
-  }
+  let level = result[0];
 
-  if (type === 'escape') {
-    options.escapeOnly = true;
-    options.useNamedReferences = true;
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  return wrapped
-
-  // Encode HTML entities using the bound options.
-  function wrapped(value) {
-    return stringifyEntities(value, options)
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
-}
-
-// Throw an exception with in its `message` `value` and `name`.
-function raise(value, name) {
-  throw new Error('Invalid value `' + value + '` for setting `' + name + '`')
-}
 
-var mdastUtilCompact = compact;
-
-// Make an mdast tree compact by merging adjacent text nodes.
-function compact(tree, commonmark) {
-  unistUtilVisit(tree, visitor);
-
-  return tree
+  result[0] = level;
 
-  function visitor(child, index, parent) {
-    var siblings = parent ? parent.children : [];
-    var prev = index && siblings[index - 1];
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-    if (
-      prev &&
-      child.type === prev.type &&
-      mergeable$1(prev, commonmark) &&
-      mergeable$1(child, commonmark)
-    ) {
-      if (child.value) {
-        prev.value += child.value;
-      }
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-heading-indent
+ * @fileoverview
+ *   Warn when a heading is indented.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   removes all unneeded indentation before headings.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   #·Hello world
+ *
+ *   Foo
+ *   -----
+ *
+ *   #·Hello world·#
+ *
+ *   Bar
+ *   =====
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   ···# Hello world
+ *
+ *   ·Foo
+ *   -----
+ *
+ *   ·# Hello world #
+ *
+ *   ···Bar
+ *   =====
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:4: Remove 3 spaces before this heading
+ *   3:2: Remove 1 space before this heading
+ *   6:2: Remove 1 space before this heading
+ *   8:4: Remove 3 spaces before this heading
+ */
 
-      if (child.children) {
-        prev.children = prev.children.concat(child.children);
+const remarkLintNoHeadingIndent = lintRule$b(
+  'remark-lint:no-heading-indent',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, 'heading', (node, _, parent) => {
+      // Note: it’s rather complex to detect what the expected indent is in block
+      // quotes and lists, so let’s only do directly in root for now.
+      if (generated(node) || (parent && parent.type !== 'root')) {
+        return
       }
 
-      siblings.splice(index, 1);
+      const diff = pointStart(node).column - 1;
 
-      if (prev.position && child.position) {
-        prev.position.end = child.position.end;
+      if (diff) {
+        file.message(
+          'Remove ' +
+            diff +
+            ' ' +
+            plural('space', diff) +
+            ' before this heading',
+          pointStart(node)
+        );
       }
-
-      return index
-    }
+    });
   }
-}
+);
 
-function mergeable$1(node, commonmark) {
-  var start;
-  var end;
+var remarkLintNoHeadingIndent$1 = remarkLintNoHeadingIndent;
 
-  if (node.type === 'text') {
-    if (!node.position) {
-      return true
-    }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-    start = node.position.start;
-    end = node.position.end;
+const primitives$a = new Set(['string', 'number', 'boolean']);
 
-    // Only merge nodes which occupy the same size as their `value`.
-    return (
-      start.line !== end.line || end.column - start.column === node.value.length
-    )
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$a(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  return commonmark && node.type === 'blockquote'
-}
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var compile_1$1 = compile$3;
+  return plugin
 
-// Stringify the given tree.
-function compile$3() {
-  return this.visit(mdastUtilCompact(this.tree, this.options.commonmark))
-}
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$b(ruleId, raw);
 
-var one_1 = one$2;
+    if (!severity) return
 
-function one$2(node, parent) {
-  var self = this;
-  var visitors = self.visitors;
+    const fatal = severity === 2;
 
-  // Fail on unknown nodes.
-  if (typeof visitors[node.type] !== 'function') {
-    self.file.fail(
-      new Error(
-        'Missing compiler for node of type `' + node.type + '`: `' + node + '`'
-      ),
-      node
-    );
-  }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  return visitors[node.type].call(self, node, parent)
-}
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-var all_1 = all;
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-// Visit all children of `parent`.
-function all(parent) {
-  var self = this;
-  var children = parent.children;
-  var length = children.length;
-  var results = [];
-  var index = -1;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-  while (++index < length) {
-    results[index] = self.visit(children[index], parent);
+        next();
+      })(tree, file, options);
+    }
   }
-
-  return results
 }
 
-var block_1 = block$1;
-
-var lineFeed$j = '\n';
-
-var blank$1 = lineFeed$j + lineFeed$j;
-var triple = blank$1 + lineFeed$j;
-var comment$1 = blank$1 + '<!---->' + blank$1;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$b(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-// Stringify a block node with block children (e.g., `root` or `blockquote`).
-// Knows about code following a list, or adjacent lists with similar bullets,
-// and places an extra line feed between them.
-function block$1(node) {
-  var self = this;
-  var options = self.options;
-  var fences = options.fences;
-  var gap = options.commonmark ? comment$1 : triple;
-  var values = [];
-  var children = node.children;
-  var length = children.length;
-  var index = -1;
-  var previous;
-  var child;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$a.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-  while (++index < length) {
-    previous = child;
-    child = children[index];
+  let level = result[0];
 
-    if (previous) {
-      // A list preceding another list that are equally ordered, or a
-      // list preceding an indented code block, need a gap between them,
-      // so as not to see them as one list, or content of the list,
-      // respectively.
-      //
-      // In commonmark, only something that breaks both up can do that,
-      // so we opt for an empty, invisible comment.  In other flavours,
-      // two blank lines are fine.
-      if (
-        previous.type === 'list' &&
-        ((child.type === 'list' && previous.ordered === child.ordered) ||
-          (child.type === 'code' && !child.lang && !fences))
-      ) {
-        values.push(gap);
-      } else {
-        values.push(blank$1);
-      }
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
+  }
 
-    values.push(self.visit(child, node));
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  return values.join('')
+  result[0] = level;
+
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var orderedItems_1 = orderedItems;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-multiple-toplevel-headings
+ * @fileoverview
+ *   Warn when multiple top level headings are used.
+ *
+ *   Options: `number`, default: `1`.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": 1}
+ *
+ *   # Foo
+ *
+ *   ## Bar
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": 1, "label": "input"}
+ *
+ *   # Foo
+ *
+ *   # Bar
+ *
+ * @example
+ *   {"name": "not-ok.md", "setting": 1, "label": "output"}
+ *
+ *   3:1-3:6: Don’t use multiple top level headings (1:1)
+ */
 
-var lineFeed$k = '\n';
-var dot$6 = '.';
+const remarkLintNoMultipleToplevelHeadings = lintRule$a(
+  'remark-lint:no-multiple-toplevel-headings',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 1) => {
+    /** @type {string|undefined} */
+    let duplicate;
 
-var blank$2 = lineFeed$k + lineFeed$k;
+    visit(tree, 'heading', (node) => {
+      if (!generated(node) && node.depth === option) {
+        if (duplicate) {
+          file.message(
+            'Don’t use multiple top level headings (' + duplicate + ')',
+            node
+          );
+        } else {
+          duplicate = stringifyPosition$1(pointStart(node));
+        }
+      }
+    });
+  }
+);
 
-// Visit ordered list items.
-//
-// Starts the list with
-// `node.start` and increments each following list item
-// bullet by one:
-//
-//     2. foo
-//     3. bar
-//
-// In `incrementListMarker: false` mode, does not increment
-// each marker and stays on `node.start`:
-//
-//     1. foo
-//     1. bar
-function orderedItems(node) {
-  var self = this;
-  var fn = self.visitors.listItem;
-  var increment = self.options.incrementListMarker;
-  var values = [];
-  var start = node.start;
-  var children = node.children;
-  var length = children.length;
-  var index = -1;
-  var bullet;
+var remarkLintNoMultipleToplevelHeadings$1 = remarkLintNoMultipleToplevelHeadings;
 
-  start = start == null ? 1 : start;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  while (++index < length) {
-    bullet = (increment ? start + index : start) + dot$6;
-    values[index] = fn.call(self, children[index], node, index, bullet);
-  }
+const primitives$9 = new Set(['string', 'number', 'boolean']);
 
-  return values.join(node.spread ? blank$2 : lineFeed$k)
-}
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$9(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-var unorderedItems_1 = unorderedItems;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var lineFeed$l = '\n';
+  return plugin
 
-var blank$3 = lineFeed$l + lineFeed$l;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$a(ruleId, raw);
 
-// Visit unordered list items.  Uses `options.bullet` as each item’s bullet.
-function unorderedItems(node) {
-  var self = this;
-  var bullet = self.options.bullet;
-  var fn = self.visitors.listItem;
-  var children = node.children;
-  var length = children.length;
-  var index = -1;
-  var values = [];
+    if (!severity) return
 
-  while (++index < length) {
-    values[index] = fn.call(self, children[index], node, index, bullet);
-  }
+    const fatal = severity === 2;
 
-  return values.join(node.spread ? blank$3 : lineFeed$l)
-}
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-var root_1 = root$1;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-var lineFeed$m = '\n';
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-// Stringify a root.
-// Adds a final newline to ensure valid POSIX files. */
-function root$1(node) {
-  var doc = this.block(node);
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-  if (doc.charAt(doc.length - 1) !== lineFeed$m) {
-    doc += lineFeed$m;
+        next();
+      })(tree, file, options);
+    }
   }
-
-  return doc
 }
 
-var text_1$1 = text$2;
-
-// Stringify text.
-// Supports named entities in `settings.encode: true` mode:
-//
-// ```markdown
-// AT&amp;T
-// ```
-//
-// Supports numbered entities in `settings.encode: numbers` mode:
-//
-// ```markdown
-// AT&#x26;T
-// ```
-function text$2(node, parent) {
-  return this.encode(this.escape(node.value, node, parent), node)
-}
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$a(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-var heading_1 = heading;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$9.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-var lineFeed$n = '\n';
-var space$h = ' ';
-var numberSign$3 = '#';
-var dash$9 = '-';
-var equalsTo$3 = '=';
+  let level = result[0];
 
-// Stringify a heading.
-//
-// In `setext: true` mode and when `depth` is smaller than three, creates a
-// setext header:
-//
-// ```markdown
-// Foo
-// ===
-// ```
-//
-// Otherwise, an ATX header is generated:
-//
-// ```markdown
-// ### Foo
-// ```
-//
-// In `closeAtx: true` mode, the header is closed with hashes:
-//
-// ```markdown
-// ### Foo ###
-// ```
-function heading(node) {
-  var self = this;
-  var depth = node.depth;
-  var setext = self.options.setext;
-  var closeAtx = self.options.closeAtx;
-  var content = self.all(node).join('');
-  var prefix;
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
+  }
 
-  if (setext && depth < 3) {
-    return (
-      content + lineFeed$n + repeatString(depth === 1 ? equalsTo$3 : dash$9, content.length)
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
     )
   }
 
-  prefix = repeatString(numberSign$3, node.depth);
+  result[0] = level;
 
-  return prefix + space$h + content + (closeAtx ? space$h + prefix : '')
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var paragraph_1$1 = paragraph$1;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-shell-dollars
+ * @fileoverview
+ *   Warn when shell code is prefixed by `$` (dollar sign) characters.
+ *
+ *   Ignores indented code blocks and fenced code blocks without language flag.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   ```bash
+ *   echo a
+ *   ```
+ *
+ *   ```sh
+ *   echo a
+ *   echo a > file
+ *   ```
+ *
+ *   ```zsh
+ *   $ echo a
+ *   a
+ *   $ echo a > file
+ *   ```
+ *
+ *   Some empty code:
+ *
+ *   ```command
+ *   ```
+ *
+ *   It’s fine to use dollars in non-shell code.
+ *
+ *   ```js
+ *   $('div').remove()
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   ```sh
+ *   $ echo a
+ *   ```
+ *
+ *   ```bash
+ *   $ echo a
+ *   $ echo a > file
+ *   ```
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1-3:4: Do not use dollar signs before shell commands
+ *   5:1-8:4: Do not use dollar signs before shell commands
+ */
 
-function paragraph$1(node) {
-  return this.all(node).join('')
-}
+// List of shell script file extensions (also used as code flags for syntax
+// highlighting on GitHub):
+// See: <https://github.com/github/linguist/blob/40992ba/lib/linguist/languages.yml#L4984>
+const flags = new Set([
+  'sh',
+  'bash',
+  'bats',
+  'cgi',
+  'command',
+  'fcgi',
+  'ksh',
+  'tmux',
+  'tool',
+  'zsh'
+]);
 
-var blockquote_1$1 = blockquote$1;
+const remarkLintNoShellDollars = lintRule$9(
+  'remark-lint:no-shell-dollars',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    visit(tree, 'code', (node) => {
+      // Check both known shell code and unknown code.
+      if (!generated(node) && node.lang && flags.has(node.lang)) {
+        const lines = node.value
+          .split('\n')
+          .filter((line) => line.trim().length > 0);
+        let index = -1;
+
+        if (lines.length === 0) {
+          return
+        }
 
-var lineFeed$o = '\n';
-var space$i = ' ';
-var greaterThan$5 = '>';
+        while (++index < lines.length) {
+          const line = lines[index];
 
-function blockquote$1(node) {
-  var values = this.block(node).split(lineFeed$o);
-  var result = [];
-  var length = values.length;
-  var index = -1;
-  var value;
+          if (line.trim() && !/^\s*\$\s*/.test(line)) {
+            return
+          }
+        }
 
-  while (++index < length) {
-    value = values[index];
-    result[index] = (value ? space$i : '') + value;
+        file.message('Do not use dollar signs before shell commands', node);
+      }
+    });
   }
+);
 
-  return greaterThan$5 + result.join(lineFeed$o + greaterThan$5)
-}
+var remarkLintNoShellDollars$1 = remarkLintNoShellDollars;
 
-var list_1$1 = list$1;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-function list$1(node) {
-  var fn = node.ordered ? this.visitOrderedItems : this.visitUnorderedItems;
-  return fn.call(this, node)
-}
+const primitives$8 = new Set(['string', 'number', 'boolean']);
 
-var pad_1 = pad$1;
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$8(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-var lineFeed$p = '\n';
-var space$j = ' ';
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var tabSize$5 = 4;
+  return plugin
 
-// Pad `value` with `level * tabSize` spaces.  Respects lines.  Ignores empty
-// lines.
-function pad$1(value, level) {
-  var values = value.split(lineFeed$p);
-  var index = values.length;
-  var padding = repeatString(space$j, level * tabSize$5);
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$9(ruleId, raw);
 
-  while (index--) {
-    if (values[index].length !== 0) {
-      values[index] = padding + values[index];
-    }
-  }
+    if (!severity) return
 
-  return values.join(lineFeed$p)
-}
+    const fatal = severity === 2;
 
-var listItem_1 = listItem$1;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-var lineFeed$q = '\n';
-var space$k = ' ';
-var leftSquareBracket$4 = '[';
-var rightSquareBracket$4 = ']';
-var lowercaseX$2 = 'x';
+      wrap(rule, (error) => {
+        const messages = file.messages;
+
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-var ceil = Math.ceil;
-var blank$4 = lineFeed$q + lineFeed$q;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-var tabSize$6 = 4;
+        next();
+      })(tree, file, options);
+    }
+  }
+}
 
-// Stringify a list item.
-//
-// Prefixes the content with a checked checkbox when `checked: true`:
-//
-// ```markdown
-// [x] foo
-// ```
-//
-// Prefixes the content with an unchecked checkbox when `checked: false`:
-//
-// ```markdown
-// [ ] foo
-// ```
-function listItem$1(node, parent, position, bullet) {
-  var self = this;
-  var style = self.options.listItemIndent;
-  var marker = bullet || self.options.bullet;
-  var spread = node.spread == null ? true : node.spread;
-  var checked = node.checked;
-  var children = node.children;
-  var length = children.length;
-  var values = [];
-  var index = -1;
-  var value;
-  var indent;
-  var spacing;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$9(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  while (++index < length) {
-    values[index] = self.visit(children[index], node);
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$8.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  value = values.join(spread ? blank$4 : lineFeed$q);
+  let level = result[0];
 
-  if (typeof checked === 'boolean') {
-    // Note: I’d like to be able to only add the space between the check and
-    // the value, but unfortunately github does not support empty list-items
-    // with a checkbox :(
-    value =
-      leftSquareBracket$4 +
-      (checked ? lowercaseX$2 : space$k) +
-      rightSquareBracket$4 +
-      space$k +
-      value;
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  if (style === '1' || (style === 'mixed' && value.indexOf(lineFeed$q) === -1)) {
-    indent = marker.length + 1;
-    spacing = space$k;
-  } else {
-    indent = ceil((marker.length + 1) / tabSize$6) * tabSize$6;
-    spacing = repeatString(space$k, indent - marker.length);
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  return value
-    ? marker + spacing + pad_1(value, indent / tabSize$6).slice(indent)
-    : marker
+  result[0] = level;
+
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var longestStreak_1 = longestStreak;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-table-indentation
+ * @fileoverview
+ *   Warn when tables are indented.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   removes all unneeded indentation before tables.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md", "gfm": true}
+ *
+ *   Paragraph.
+ *
+ *   | A     | B     |
+ *   | ----- | ----- |
+ *   | Alpha | Bravo |
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input", "gfm": true}
+ *
+ *   Paragraph.
+ *
+ *   ···| A     | B     |
+ *   ···| ----- | ----- |
+ *   ···| Alpha | Bravo |
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "gfm": true}
+ *
+ *   3:4: Do not indent table rows
+ *   4:4: Do not indent table rows
+ *   5:4: Do not indent table rows
+ *
+ * @example
+ *   {"name": "not-ok-blockquote.md", "label": "input", "gfm": true}
+ *
+ *   >··| A |
+ *   >·| - |
+ *
+ * @example
+ *   {"name": "not-ok-blockquote.md", "label": "output", "gfm": true}
+ *
+ *   1:4: Do not indent table rows
+ *
+ * @example
+ *   {"name": "not-ok-list.md", "label": "input", "gfm": true}
+ *
+ *   -···paragraph
+ *
+ *   ·····| A |
+ *   ····| - |
+ *
+ * @example
+ *   {"name": "not-ok-list.md", "label": "output", "gfm": true}
+ *
+ *   3:6: Do not indent table rows
+ */
 
-// Get the count of the longest repeating streak of `character` in `value`.
-function longestStreak(value, character) {
-  var count = 0;
-  var maximum = 0;
-  var expected;
-  var index;
+const remarkLintNoTableIndentation = lintRule$8(
+  'remark-lint:no-table-indentation',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    const value = String(file);
+    const loc = location(value);
 
-  if (typeof character !== 'string' || character.length !== 1) {
-    throw new Error('Expected character')
-  }
+    visit(tree, 'table', (node, _, parent) => {
+      const end = pointEnd(node).line;
+      let line = pointStart(node).line;
+      let column = 0;
 
-  value = String(value);
-  index = value.indexOf(character);
-  expected = index;
+      if (parent && parent.type === 'root') {
+        column = 1;
+      } else if (parent && parent.type === 'blockquote') {
+        column = pointStart(parent).column + 2;
+      } else if (parent && parent.type === 'listItem') {
+        column = pointStart(parent.children[0]).column;
 
-  while (index !== -1) {
-    count++;
+        // Skip past the first line if we’re the first child of a list item.
+        /* c8 ignore next 3 */
+        if (parent.children[0] === node) {
+          line++;
+        }
+      }
 
-    if (index === expected) {
-      if (count > maximum) {
-        maximum = count;
+      // In a parent we don’t know, exit.
+      if (!column || !line) {
+        return
       }
-    } else {
-      count = 1;
-    }
 
-    expected = index + 1;
-    index = value.indexOf(character, expected);
-  }
+      while (line <= end) {
+        let offset = loc.toOffset({line, column});
+        const lineColumn = offset;
+
+        while (/[ \t]/.test(value.charAt(offset - 1))) {
+          offset--;
+        }
+
+        if (!offset || /[\r\n>]/.test(value.charAt(offset - 1))) {
+          offset = lineColumn;
+
+          while (/[ \t]/.test(value.charAt(offset))) {
+            offset++;
+          }
+
+          if (lineColumn !== offset) {
+            file.message('Do not indent table rows', loc.toPoint(offset));
+          }
+        }
+
+        line++;
+      }
+
+      return SKIP$1
+    });
+  }
+);
+
+var remarkLintNoTableIndentation$1 = remarkLintNoTableIndentation;
+
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$7 = new Set(['string', 'number', 'boolean']);
 
-  return maximum
-}
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$7(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-var inlineCode_1 = inlineCode$1;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var graveAccentChar = '`';
-var lineFeed$r = 10; //  '\n'
-var space$l = 32; // ' '
-var graveAccent$4 = 96; //  '`'
+  return plugin
 
-// Stringify inline code.
-//
-// Knows about internal ticks (`\``), and ensures one more tick is used to
-// enclose the inline code:
-//
-// ````markdown
-// ```foo ``bar`` baz```
-// ````
-//
-// Even knows about inital and final ticks:
-//
-// ``markdown
-// `` `foo ``
-// `` foo` ``
-// ```
-function inlineCode$1(node) {
-  var value = node.value;
-  var ticks = repeatString(graveAccentChar, longestStreak_1(value, graveAccentChar) + 1);
-  var start = ticks;
-  var end = ticks;
-  var head = value.charCodeAt(0);
-  var tail = value.charCodeAt(value.length - 1);
-  var wrap = false;
-  var index;
-  var length;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$8(ruleId, raw);
 
-  if (head === graveAccent$4 || tail === graveAccent$4) {
-    wrap = true;
-  } else if (value.length > 2 && ws(head) && ws(tail)) {
-    index = 1;
-    length = value.length - 1;
+    if (!severity) return
 
-    while (++index < length) {
-      if (!ws(value.charCodeAt(index))) {
-        wrap = true;
-        break
-      }
-    }
-  }
+    const fatal = severity === 2;
 
-  if (wrap) {
-    start += ' ';
-    end = ' ' + end;
-  }
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  return start + value + end
-}
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-function ws(code) {
-  return code === lineFeed$r || code === space$l
-}
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-var code_1 = code;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-var lineFeed$s = '\n';
-var space$m = ' ';
-var tilde$6 = '~';
-var graveAccent$5 = '`';
+        next();
+      })(tree, file, options);
+    }
+  }
+}
 
-// Stringify code.
-// Creates indented code when:
-//
-// - No language tag exists
-// - Not in `fences: true` mode
-// - A non-empty value exists
-//
-// Otherwise, GFM fenced code is created:
-//
-// ````markdown
-// ```js
-// foo();
-// ```
-// ````
-//
-// When in ``fence: `~` `` mode, uses tildes as fences:
-//
-// ```markdown
-// ~~~js
-// foo();
-// ~~~
-// ```
-//
-// Knows about internal fences:
-//
-// `````markdown
-// ````markdown
-// ```javascript
-// foo();
-// ```
-// ````
-// `````
-function code(node, parent) {
-  var self = this;
-  var value = node.value;
-  var options = self.options;
-  var marker = options.fence;
-  var info = node.lang || '';
-  var fence;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$8(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  if (info && node.meta) {
-    info += space$m + node.meta;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$7.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  info = self.encode(self.escape(info, node));
+  let level = result[0];
 
-  // Without (needed) fences.
-  if (
-    !info &&
-    !options.fences &&
-    value &&
-    value.charAt(0) !== lineFeed$s &&
-    value.charAt(value.length - 1) !== lineFeed$s
-  ) {
-    // Throw when pedantic, in a list item which isn’t compiled using a tab.
-    if (
-      parent &&
-      parent.type === 'listItem' &&
-      options.listItemIndent !== 'tab' &&
-      options.pedantic
-    ) {
-      self.file.fail(
-        'Cannot indent code properly. See https://git.io/fxKR8',
-        node.position
-      );
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
-
-    return pad_1(value, 1)
   }
 
-  // Backticks in the info string don’t work with backtick fenced code.
-  // Backticks (and tildes) are fine in tilde fenced code.
-  if (marker === graveAccent$5 && info.indexOf(graveAccent$5) !== -1) {
-    marker = tilde$6;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  fence = repeatString(marker, Math.max(longestStreak_1(value, marker) + 1, 3));
+  result[0] = level;
 
-  return fence + info + lineFeed$s + value + lineFeed$s + fence
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-var html_1 = html$1;
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module no-tabs
+ * @fileoverview
+ *   Warn when hard tabs (`\t`) are used instead of spaces.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   uses spaces where tabs are used for indentation, but retains tabs used in
+ *   content.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   Foo Bar
+ *
+ *   ····Foo
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input", "positionless": true}
+ *
+ *   »Here's one before a code block.
+ *
+ *   Here's a tab:», and here is another:».
+ *
+ *   And this is in `inline»code`.
+ *
+ *   >»This is in a block quote.
+ *
+ *   *»And…
+ *
+ *   »1.»in a list.
+ *
+ *   And this is a tab as the last character.»
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:1: Use spaces instead of tabs
+ *   3:14: Use spaces instead of tabs
+ *   3:37: Use spaces instead of tabs
+ *   5:23: Use spaces instead of tabs
+ *   7:2: Use spaces instead of tabs
+ *   9:2: Use spaces instead of tabs
+ *   11:1: Use spaces instead of tabs
+ *   11:4: Use spaces instead of tabs
+ *   13:41: Use spaces instead of tabs
+ */
 
-function html$1(node) {
-  return node.value
-}
+const remarkLintNoTabs = lintRule$7(
+  'remark-lint:no-tabs',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (_, file) => {
+    const value = String(file);
+    const toPoint = location(file).toPoint;
+    let index = value.indexOf('\t');
 
-var thematicBreak$1 = thematic;
+    while (index !== -1) {
+      file.message('Use spaces instead of tabs', toPoint(index));
+      index = value.indexOf('\t', index + 1);
+    }
+  }
+);
 
-var space$n = ' ';
+var remarkLintNoTabs$1 = remarkLintNoTabs;
 
-// Stringify a `thematic-break`.
-// The character used is configurable through `rule`: (`'_'`):
-//
-// ```markdown
-// ___
-// ```
-//
-// The number of repititions is defined through `ruleRepetition` (`6`):
-//
-// ```markdown
-// ******
-// ```
-//
-// Whether spaces delimit each character, is configured through `ruleSpaces`
-// (`true`):
-// ```markdown
-// * * *
-// ```
-function thematic() {
-  var options = this.options;
-  var rule = repeatString(options.rule, options.ruleRepetition);
-  return options.ruleSpaces ? rule.split('').join(space$n) : rule
-}
+/**
+ * An Array.prototype.slice.call(arguments) alternative
+ *
+ * @param {Object} args something with a length
+ * @param {Number} slice
+ * @param {Number} sliceEnd
+ * @api public
+ */
 
-var strong_1$1 = strong$2;
+var sliced$1 = function (args, slice, sliceEnd) {
+  var ret = [];
+  var len = args.length;
 
-// Stringify a `strong`.
-//
-// The marker used is configurable by `strong`, which defaults to an asterisk
-// (`'*'`) but also accepts an underscore (`'_'`):
-//
-// ```markdown
-// __foo__
-// ```
-function strong$2(node) {
-  var marker = repeatString(this.options.strong, 2);
-  return marker + this.all(node).join('') + marker
-}
+  if (0 === len) return ret;
 
-var emphasis_1$1 = emphasis$2;
+  var start = slice < 0
+    ? Math.max(0, slice + len)
+    : slice || 0;
 
-var underscore$8 = '_';
-var asterisk$6 = '*';
+  if (sliceEnd !== undefined) {
+    len = sliceEnd < 0
+      ? sliceEnd + len
+      : sliceEnd;
+  }
 
-// Stringify an `emphasis`.
-//
-// The marker used is configurable through `emphasis`, which defaults to an
-// underscore (`'_'`) but also accepts an asterisk (`'*'`):
-//
-// ```markdown
-// *foo*
-// ```
-//
-// In `pedantic` mode, text which itself contains an underscore will cause the
-// marker to default to an asterisk instead:
-//
-// ```markdown
-// *foo_bar*
-// ```
-function emphasis$2(node) {
-  var marker = this.options.emphasis;
-  var content = this.all(node).join('');
-
-  // When in pedantic mode, prevent using underscore as the marker when there
-  // are underscores in the content.
-  if (
-    this.options.pedantic &&
-    marker === underscore$8 &&
-    content.indexOf(marker) !== -1
-  ) {
-    marker = asterisk$6;
+  while (len-- > start) {
+    ret[len - start] = args[len];
   }
 
-  return marker + content + marker
-}
+  return ret;
+};
 
-var _break$2 = lineBreak;
+/**
+ * slice() reference.
+ */
 
-var backslash$a = '\\';
-var lineFeed$t = '\n';
-var space$o = ' ';
+var slice = Array.prototype.slice;
 
-var commonmark$1 = backslash$a + lineFeed$t;
-var normal = space$o + space$o + lineFeed$t;
+/**
+ * Expose `co`.
+ */
 
-function lineBreak() {
-  return this.options.commonmark ? commonmark$1 : normal
-}
+var co_1 = co$1;
 
-var _delete$2 = strikethrough$1;
+/**
+ * Wrap the given generator `fn` and
+ * return a thunk.
+ *
+ * @param {Function} fn
+ * @return {Function}
+ * @api public
+ */
 
-var tilde$7 = '~';
+function co$1(fn) {
+  var isGenFun = isGeneratorFunction(fn);
 
-var fence$1 = tilde$7 + tilde$7;
+  return function (done) {
+    var ctx = this;
 
-function strikethrough$1(node) {
-  return fence$1 + this.all(node).join('') + fence$1
-}
+    // in toThunk() below we invoke co()
+    // with a generator, so optimize for
+    // this case
+    var gen = fn;
 
-var encloseUri = enclose;
+    // we only need to parse the arguments
+    // if gen is a generator function.
+    if (isGenFun) {
+      var args = slice.call(arguments), len = args.length;
+      var hasCallback = len && 'function' == typeof args[len - 1];
+      done = hasCallback ? args.pop() : error;
+      gen = fn.apply(this, args);
+    } else {
+      done = done || error;
+    }
 
-var leftParenthesis$3 = '(';
-var rightParenthesis$5 = ')';
-var lessThan$8 = '<';
-var greaterThan$6 = '>';
+    next();
 
-var expression = /\s/;
+    // #92
+    // wrap the callback in a setImmediate
+    // so that any of its errors aren't caught by `co`
+    function exit(err, res) {
+      setImmediate(function(){
+        done.call(ctx, err, res);
+      });
+    }
 
-// Wrap `url` in angle brackets when needed, or when
-// forced.
-// In links, images, and definitions, the URL part needs
-// to be enclosed when it:
-//
-// - has a length of `0`
-// - contains white-space
-// - has more or less opening than closing parentheses
-function enclose(uri, always) {
-  if (
-    always ||
-    uri.length === 0 ||
-    expression.test(uri) ||
-    ccount_1(uri, leftParenthesis$3) !== ccount_1(uri, rightParenthesis$5)
-  ) {
-    return lessThan$8 + uri + greaterThan$6
-  }
+    function next(err, res) {
+      var ret;
 
-  return uri
-}
+      // multiple args
+      if (arguments.length > 2) res = slice.call(arguments, 1);
 
-var encloseTitle = enclose$1;
+      // error
+      if (err) {
+        try {
+          ret = gen.throw(err);
+        } catch (e) {
+          return exit(e);
+        }
+      }
 
-var quotationMark$2 = '"';
-var apostrophe$2 = "'";
+      // ok
+      if (!err) {
+        try {
+          ret = gen.next(res);
+        } catch (e) {
+          return exit(e);
+        }
+      }
 
-// There is currently no way to support nested delimiters across Markdown.pl,
-// CommonMark, and GitHub (RedCarpet).  The following code supports Markdown.pl
-// and GitHub.
-// CommonMark is not supported when mixing double- and single quotes inside a
-// title.
-function enclose$1(title) {
-  var delimiter =
-    title.indexOf(quotationMark$2) === -1 ? quotationMark$2 : apostrophe$2;
-  return delimiter + title + delimiter
-}
+      // done
+      if (ret.done) return exit(null, ret.value);
 
-var link_1$1 = link$5;
+      // normalize
+      ret.value = toThunk(ret.value, ctx);
 
-var space$p = ' ';
-var leftSquareBracket$5 = '[';
-var rightSquareBracket$5 = ']';
-var leftParenthesis$4 = '(';
-var rightParenthesis$6 = ')';
+      // run
+      if ('function' == typeof ret.value) {
+        var called = false;
+        try {
+          ret.value.call(ctx, function(){
+            if (called) return;
+            called = true;
+            next.apply(ctx, arguments);
+          });
+        } catch (e) {
+          setImmediate(function(){
+            if (called) return;
+            called = true;
+            next(e);
+          });
+        }
+        return;
+      }
 
-// Expression for a protocol:
-// See <https://en.wikipedia.org/wiki/Uniform_Resource_Identifier#Generic_syntax>.
-var protocol$1 = /^[a-z][a-z+.-]+:\/?/i;
+      // invalid
+      next(new TypeError('You may only yield a function, promise, generator, array, or object, '
+        + 'but the following was passed: "' + String(ret.value) + '"'));
+    }
+  }
+}
 
-// Stringify a link.
-//
-// When no title exists, the compiled `children` equal `url`, and `url` starts
-// with a protocol, an auto link is created:
-//
-// ```markdown
-// <http://example.com>
-// ```
-//
-// Otherwise, is smart about enclosing `url` (see `encloseURI()`) and `title`
-// (see `encloseTitle()`).
-// ```
-//
-// ```markdown
-// [foo](<foo at bar dot com> 'An "example" e-mail')
-// ```
-//
-// Supports named entities in the `url` and `title` when in `settings.encode`
-// mode.
-function link$5(node) {
-  var self = this;
-  var content = self.encode(node.url || '', node);
-  var exit = self.enterLink();
-  var escaped = self.encode(self.escape(node.url || '', node));
-  var value = self.all(node).join('');
+/**
+ * Convert `obj` into a normalized thunk.
+ *
+ * @param {Mixed} obj
+ * @param {Mixed} ctx
+ * @return {Function}
+ * @api private
+ */
 
-  exit();
+function toThunk(obj, ctx) {
 
-  if (node.title == null && protocol$1.test(content) && escaped === value) {
-    // Backslash escapes do not work in autolinks, so we do not escape.
-    return encloseUri(self.encode(node.url), true)
+  if (isGeneratorFunction(obj)) {
+    return co$1(obj.call(ctx));
   }
 
-  content = encloseUri(content);
-
-  if (node.title) {
-    content += space$p + encloseTitle(self.encode(self.escape(node.title, node), node));
+  if (isGenerator(obj)) {
+    return co$1(obj);
   }
 
-  return (
-    leftSquareBracket$5 +
-    value +
-    rightSquareBracket$5 +
-    leftParenthesis$4 +
-    content +
-    rightParenthesis$6
-  )
-}
-
-var copyIdentifierEncoding = copy$4;
+  if (isPromise(obj)) {
+    return promiseToThunk(obj);
+  }
 
-var ampersand$4 = '&';
+  if ('function' == typeof obj) {
+    return obj;
+  }
 
-var punctuationExppresion = /[-!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~_]/;
+  if (isObject(obj) || Array.isArray(obj)) {
+    return objectToThunk.call(ctx, obj);
+  }
 
-// For shortcut and collapsed reference links, the contents is also an
-// identifier, so we need to restore the original encoding and escaping
-// that were present in the source string.
-//
-// This function takes the unescaped & unencoded value from shortcut’s
-// child nodes and the identifier and encodes the former according to
-// the latter.
-function copy$4(value, identifier) {
-  var length = value.length;
-  var count = identifier.length;
-  var result = [];
-  var position = 0;
-  var index = 0;
-  var start;
+  return obj;
+}
 
-  while (index < length) {
-    // Take next non-punctuation characters from `value`.
-    start = index;
+/**
+ * Convert an object of yieldables to a thunk.
+ *
+ * @param {Object} obj
+ * @return {Function}
+ * @api private
+ */
 
-    while (index < length && !punctuationExppresion.test(value.charAt(index))) {
-      index += 1;
-    }
+function objectToThunk(obj){
+  var ctx = this;
+  var isArray = Array.isArray(obj);
 
-    result.push(value.slice(start, index));
+  return function(done){
+    var keys = Object.keys(obj);
+    var pending = keys.length;
+    var results = isArray
+      ? new Array(pending) // predefine the array length
+      : new obj.constructor();
+    var finished;
 
-    // Advance `position` to the next punctuation character.
-    while (
-      position < count &&
-      !punctuationExppresion.test(identifier.charAt(position))
-    ) {
-      position += 1;
+    if (!pending) {
+      setImmediate(function(){
+        done(null, results);
+      });
+      return;
     }
 
-    // Take next punctuation characters from `identifier`.
-    start = position;
-
-    while (
-      position < count &&
-      punctuationExppresion.test(identifier.charAt(position))
-    ) {
-      if (identifier.charAt(position) === ampersand$4) {
-        position += entityPrefixLength(identifier.slice(position));
+    // prepopulate object keys to preserve key ordering
+    if (!isArray) {
+      for (var i = 0; i < pending; i++) {
+        results[keys[i]] = undefined;
       }
-
-      position += 1;
     }
 
-    result.push(identifier.slice(start, position));
-
-    // Advance `index` to the next non-punctuation character.
-    while (index < length && punctuationExppresion.test(value.charAt(index))) {
-      index += 1;
+    for (var i = 0; i < keys.length; i++) {
+      run(obj[keys[i]], keys[i]);
     }
-  }
-
-  return result.join('')
-}
 
-var label_1 = label;
+    function run(fn, key) {
+      if (finished) return;
+      try {
+        fn = toThunk(fn, ctx);
 
-var leftSquareBracket$6 = '[';
-var rightSquareBracket$6 = ']';
+        if ('function' != typeof fn) {
+          results[key] = fn;
+          return --pending || done(null, results);
+        }
 
-var shortcut$2 = 'shortcut';
-var collapsed$1 = 'collapsed';
+        fn.call(ctx, function(err, res){
+          if (finished) return;
 
-// Stringify a reference label.
-// Because link references are easily, mistakingly, created (for example,
-// `[foo]`), reference nodes have an extra property depicting how it looked in
-// the original document, so stringification can cause minimal changes.
-function label(node) {
-  var type = node.referenceType;
+          if (err) {
+            finished = true;
+            return done(err);
+          }
 
-  if (type === shortcut$2) {
-    return ''
+          results[key] = res;
+          --pending || done(null, results);
+        });
+      } catch (err) {
+        finished = true;
+        done(err);
+      }
+    }
   }
-
-  return (
-    leftSquareBracket$6 +
-    (type === collapsed$1 ? '' : node.label || node.identifier) +
-    rightSquareBracket$6
-  )
 }
 
-var linkReference_1 = linkReference;
-
-var leftSquareBracket$7 = '[';
-var rightSquareBracket$7 = ']';
-
-var shortcut$3 = 'shortcut';
-var collapsed$2 = 'collapsed';
-
-function linkReference(node) {
-  var self = this;
-  var type = node.referenceType;
-  var exit = self.enterLinkReference(self, node);
-  var value = self.all(node).join('');
-
-  exit();
+/**
+ * Convert `promise` to a thunk.
+ *
+ * @param {Object} promise
+ * @return {Function}
+ * @api private
+ */
 
-  if (type === shortcut$3 || type === collapsed$2) {
-    value = copyIdentifierEncoding(value, node.label || node.identifier);
+function promiseToThunk(promise) {
+  return function(fn){
+    promise.then(function(res) {
+      fn(null, res);
+    }, fn);
   }
-
-  return leftSquareBracket$7 + value + rightSquareBracket$7 + label_1(node)
 }
 
-var imageReference_1 = imageReference;
-
-var leftSquareBracket$8 = '[';
-var rightSquareBracket$8 = ']';
-var exclamationMark$6 = '!';
+/**
+ * Check if `obj` is a promise.
+ *
+ * @param {Object} obj
+ * @return {Boolean}
+ * @api private
+ */
 
-function imageReference(node) {
-  return (
-    exclamationMark$6 +
-    leftSquareBracket$8 +
-    (this.encode(node.alt, node) || '') +
-    rightSquareBracket$8 +
-    label_1(node)
-  )
+function isPromise(obj) {
+  return obj && 'function' == typeof obj.then;
 }
 
-var definition_1$1 = definition$1;
-
-var space$q = ' ';
-var colon$5 = ':';
-var leftSquareBracket$9 = '[';
-var rightSquareBracket$9 = ']';
-
-// Stringify an URL definition.
-//
-// Is smart about enclosing `url` (see `encloseURI()`) and `title` (see
-// `encloseTitle()`).
-//
-// ```markdown
-// [foo]: <foo at bar dot com> 'An "example" e-mail'
-// ```
-function definition$1(node) {
-  var content = encloseUri(node.url);
-
-  if (node.title) {
-    content += space$q + encloseTitle(node.title);
-  }
+/**
+ * Check if `obj` is a generator.
+ *
+ * @param {Mixed} obj
+ * @return {Boolean}
+ * @api private
+ */
 
-  return (
-    leftSquareBracket$9 +
-    (node.label || node.identifier) +
-    rightSquareBracket$9 +
-    colon$5 +
-    space$q +
-    content
-  )
+function isGenerator(obj) {
+  return obj && 'function' == typeof obj.next && 'function' == typeof obj.throw;
 }
 
-var image_1 = image$3;
+/**
+ * Check if `obj` is a generator function.
+ *
+ * @param {Mixed} obj
+ * @return {Boolean}
+ * @api private
+ */
 
-var space$r = ' ';
-var leftParenthesis$5 = '(';
-var rightParenthesis$7 = ')';
-var leftSquareBracket$a = '[';
-var rightSquareBracket$a = ']';
-var exclamationMark$7 = '!';
+function isGeneratorFunction(obj) {
+  return obj && obj.constructor && 'GeneratorFunction' == obj.constructor.name;
+}
 
-// Stringify an image.
-//
-// Is smart about enclosing `url` (see `encloseURI()`) and `title` (see
-// `encloseTitle()`).
-//
-// ```markdown
-// ![foo](</fav icon.png> 'My "favourite" icon')
-// ```
-//
-// Supports named entities in `url`, `alt`, and `title` when in
-// `settings.encode` mode.
-function image$3(node) {
-  var self = this;
-  var content = encloseUri(self.encode(node.url || '', node));
-  var exit = self.enterLink();
-  var alt = self.encode(self.escape(node.alt || '', node));
+/**
+ * Check for plain object.
+ *
+ * @param {Mixed} val
+ * @return {Boolean}
+ * @api private
+ */
 
-  exit();
+function isObject(val) {
+  return val && Object == val.constructor;
+}
 
-  if (node.title) {
-    content += space$r + encloseTitle(self.encode(node.title, node));
-  }
+/**
+ * Throw `err` in a new stack.
+ *
+ * This is used when co() is invoked
+ * without supplying a callback, which
+ * should only be for demonstrational
+ * purposes.
+ *
+ * @param {Error} err
+ * @api private
+ */
 
-  return (
-    exclamationMark$7 +
-    leftSquareBracket$a +
-    alt +
-    rightSquareBracket$a +
-    leftParenthesis$5 +
-    content +
-    rightParenthesis$7
-  )
+function error(err) {
+  if (!err) return;
+  setImmediate(function(){
+    throw err;
+  });
 }
 
-var markdownTable_1 = markdownTable;
-
-var trailingWhitespace = / +$/;
+/**
+ * Module Dependencies
+ */
 
-// Characters.
-var space$s = ' ';
-var lineFeed$u = '\n';
-var dash$a = '-';
-var colon$6 = ':';
-var verticalBar$2 = '|';
+var sliced = sliced$1;
+var noop = function(){};
+var co = co_1;
 
-var x = 0;
-var C = 67;
-var L$1 = 76;
-var R = 82;
-var c$1 = 99;
-var l$1 = 108;
-var r = 114;
+/**
+ * Export `wrapped`
+ */
 
-// Create a table from a matrix of strings.
-function markdownTable(table, options) {
-  var settings = options || {};
-  var padding = settings.padding !== false;
-  var start = settings.delimiterStart !== false;
-  var end = settings.delimiterEnd !== false;
-  var align = (settings.align || []).concat();
-  var alignDelimiters = settings.alignDelimiters !== false;
-  var alignments = [];
-  var stringLength = settings.stringLength || defaultStringLength;
-  var rowIndex = -1;
-  var rowLength = table.length;
-  var cellMatrix = [];
-  var sizeMatrix = [];
-  var row = [];
-  var sizes = [];
-  var longestCellByColumn = [];
-  var mostCellsPerRow = 0;
-  var cells;
-  var columnIndex;
-  var columnLength;
-  var largest;
-  var size;
-  var cell;
-  var lines;
-  var line;
-  var before;
-  var after;
-  var code;
+var wrapped_1 = wrapped$1;
 
-  // This is a superfluous loop if we don’t align delimiters, but otherwise we’d
-  // do superfluous work when aligning, so optimize for aligning.
-  while (++rowIndex < rowLength) {
-    cells = table[rowIndex];
-    columnIndex = -1;
-    columnLength = cells.length;
-    row = [];
-    sizes = [];
+/**
+ * Wrap a function to support
+ * sync, async, and gen functions.
+ *
+ * @param {Function} fn
+ * @return {Function}
+ * @api public
+ */
 
-    if (columnLength > mostCellsPerRow) {
-      mostCellsPerRow = columnLength;
-    }
+function wrapped$1(fn) {
+  function wrap() {
+    var args = sliced(arguments);
+    var last = args[args.length - 1];
+    var ctx = this;
 
-    while (++columnIndex < columnLength) {
-      cell = serialize(cells[columnIndex]);
+    // done
+    var done = typeof last == 'function' ? args.pop() : noop;
 
-      if (alignDelimiters === true) {
-        size = stringLength(cell);
-        sizes[columnIndex] = size;
+    // nothing
+    if (!fn) {
+      return done.apply(ctx, [null].concat(args));
+    }
 
-        largest = longestCellByColumn[columnIndex];
+    // generator
+    if (generator(fn)) {
+      return co(fn).apply(ctx, args.concat(done));
+    }
 
-        if (largest === undefined || size > largest) {
-          longestCellByColumn[columnIndex] = size;
-        }
+    // async
+    if (fn.length > args.length) {
+      // NOTE: this only handles uncaught synchronous errors
+      try {
+        return fn.apply(ctx, args.concat(done));
+      } catch (e) {
+        return done(e);
       }
-
-      row.push(cell);
     }
 
-    cellMatrix[rowIndex] = row;
-    sizeMatrix[rowIndex] = sizes;
+    // sync
+    return sync(fn, done).apply(ctx, args);
   }
 
-  // Figure out which alignments to use.
-  columnIndex = -1;
-  columnLength = mostCellsPerRow;
+  return wrap;
+}
 
-  if (typeof align === 'object' && 'length' in align) {
-    while (++columnIndex < columnLength) {
-      alignments[columnIndex] = toAlignment(align[columnIndex]);
+/**
+ * Wrap a synchronous function execution.
+ *
+ * @param {Function} fn
+ * @param {Function} done
+ * @return {Function}
+ * @api private
+ */
+
+function sync(fn, done) {
+  return function () {
+    var ret;
+
+    try {
+      ret = fn.apply(this, arguments);
+    } catch (err) {
+      return done(err);
     }
-  } else {
-    code = toAlignment(align);
 
-    while (++columnIndex < columnLength) {
-      alignments[columnIndex] = code;
+    if (promise(ret)) {
+      ret.then(function (value) { done(null, value); }, done);
+    } else {
+      ret instanceof Error ? done(ret) : done(null, ret);
     }
   }
+}
 
-  // Inject the alignment row.
-  columnIndex = -1;
-  columnLength = mostCellsPerRow;
-  row = [];
-  sizes = [];
+/**
+ * Is `value` a generator?
+ *
+ * @param {Mixed} value
+ * @return {Boolean}
+ * @api private
+ */
 
-  while (++columnIndex < columnLength) {
-    code = alignments[columnIndex];
-    before = '';
-    after = '';
+function generator(value) {
+  return value
+    && value.constructor
+    && 'GeneratorFunction' == value.constructor.name;
+}
 
-    if (code === l$1) {
-      before = colon$6;
-    } else if (code === r) {
-      after = colon$6;
-    } else if (code === c$1) {
-      before = colon$6;
-      after = colon$6;
-    }
 
-    // There *must* be at least one hyphen-minus in each alignment cell.
-    size = alignDelimiters
-      ? Math.max(
-          1,
-          longestCellByColumn[columnIndex] - before.length - after.length
-        )
-      : 1;
+/**
+ * Is `value` a promise?
+ *
+ * @param {Mixed} value
+ * @return {Boolean}
+ * @api private
+ */
 
-    cell = before + repeatString(dash$a, size) + after;
+function promise(value) {
+  return value && 'function' == typeof value.then;
+}
 
-    if (alignDelimiters === true) {
-      size = before.length + size + after.length;
+var wrapped = wrapped_1;
 
-      if (size > longestCellByColumn[columnIndex]) {
-        longestCellByColumn[columnIndex] = size;
-      }
+var unifiedLintRule = factory;
 
-      sizes[columnIndex] = size;
-    }
+function factory(id, rule) {
+  var parts = id.split(':');
+  var source = parts[0];
+  var ruleId = parts[1];
+  var fn = wrapped(rule);
 
-    row[columnIndex] = cell;
+  /* istanbul ignore if - possibly useful if externalised later. */
+  if (!ruleId) {
+    ruleId = source;
+    source = null;
   }
 
-  // Inject the alignment row.
-  cellMatrix.splice(1, 0, row);
-  sizeMatrix.splice(1, 0, sizes);
+  attacher.displayName = id;
 
-  rowIndex = -1;
-  rowLength = cellMatrix.length;
-  lines = [];
+  return attacher
 
-  while (++rowIndex < rowLength) {
-    row = cellMatrix[rowIndex];
-    sizes = sizeMatrix[rowIndex];
-    columnIndex = -1;
-    columnLength = mostCellsPerRow;
-    line = [];
+  function attacher(raw) {
+    var config = coerce$7(ruleId, raw);
+    var severity = config[0];
+    var options = config[1];
+    var fatal = severity === 2;
 
-    while (++columnIndex < columnLength) {
-      cell = row[columnIndex] || '';
-      before = '';
-      after = '';
+    return severity ? transformer : undefined
 
-      if (alignDelimiters === true) {
-        size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0);
-        code = alignments[columnIndex];
+    function transformer(tree, file, next) {
+      var index = file.messages.length;
 
-        if (code === r) {
-          before = repeatString(space$s, size);
-        } else if (code === c$1) {
-          if (size % 2 === 0) {
-            before = repeatString(space$s, size / 2);
-            after = before;
-          } else {
-            before = repeatString(space$s, size / 2 + 0.5);
-            after = repeatString(space$s, size / 2 - 0.5);
-          }
-        } else {
-          after = repeatString(space$s, size);
-        }
-      }
+      fn(tree, file, options, done);
 
-      if (start === true && columnIndex === 0) {
-        line.push(verticalBar$2);
-      }
+      function done(err) {
+        var messages = file.messages;
+        var message;
 
-      if (
-        padding === true &&
-        // Don’t add the opening space if we’re not aligning and the cell is
-        // empty: there will be a closing space.
-        !(alignDelimiters === false && cell === '') &&
-        (start === true || columnIndex !== 0)
-      ) {
-        line.push(space$s);
-      }
+        // Add the error, if not already properly added.
+        /* istanbul ignore if - only happens for incorrect plugins */
+        if (err && messages.indexOf(err) === -1) {
+          try {
+            file.fail(err);
+          } catch (_) {}
+        }
 
-      if (alignDelimiters === true) {
-        line.push(before);
-      }
+        while (index < messages.length) {
+          message = messages[index];
+          message.ruleId = ruleId;
+          message.source = source;
+          message.fatal = fatal;
 
-      line.push(cell);
+          index++;
+        }
 
-      if (alignDelimiters === true) {
-        line.push(after);
+        next();
       }
+    }
+  }
+}
 
-      if (padding === true) {
-        line.push(space$s);
-      }
+// Coerce a value to a severity--options tuple.
+function coerce$7(name, value) {
+  var def = 1;
+  var result;
+  var level;
 
-      if (end === true || columnIndex !== columnLength - 1) {
-        line.push(verticalBar$2);
-      }
-    }
+  /* istanbul ignore if - Handled by unified in v6.0.0 */
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value == null) {
+    result = [def];
+  } else if (
+    typeof value === 'object' &&
+    (typeof value[0] === 'number' ||
+      typeof value[0] === 'boolean' ||
+      typeof value[0] === 'string')
+  ) {
+    result = value.concat();
+  } else {
+    result = [1, value];
+  }
 
-    line = line.join('');
+  level = result[0];
 
-    if (end === false) {
-      line = line.replace(trailingWhitespace, '');
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
-
-    lines.push(line);
   }
 
-  return lines.join(lineFeed$u)
-}
+  if (level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-function serialize(value) {
-  return value === null || value === undefined ? '' : String(value)
-}
+  result[0] = level;
 
-function defaultStringLength(value) {
-  return value.length
+  return result
 }
 
-function toAlignment(value) {
-  var code = typeof value === 'string' ? value.charCodeAt(0) : x;
-
-  return code === L$1 || code === l$1
-    ? l$1
-    : code === R || code === r
-    ? r
-    : code === C || code === c$1
-    ? c$1
-    : x
-}
+var rule = unifiedLintRule;
 
-var table_1$1 = table$1;
+var remarkLintNoTrailingSpaces = rule('remark-lint:no-trailing-spaces', noTrailingSpaces);
 
-// Stringify table.
-//
-// Creates a fenced table.
-// The table has aligned delimiters by default, but not in
-// `tablePipeAlign: false`:
-//
-// ```markdown
-// | Header 1 | Header 2 |
-// | :-: | - |
-// | Alpha | Bravo |
-// ```
-//
-// The table is spaced by default, but not in `tableCellPadding: false`:
-//
-// ```markdown
-// |Foo|Bar|
-// |:-:|---|
-// |Baz|Qux|
-// ```
-function table$1(node) {
-  var self = this;
-  var options = self.options;
-  var padding = options.tableCellPadding;
-  var alignDelimiters = options.tablePipeAlign;
-  var stringLength = options.stringLength;
-  var rows = node.children;
-  var index = rows.length;
-  var exit = self.enterTable();
-  var result = [];
+/**
+ * Lines that are just space characters are not present in
+ * the AST, which is why we loop through lines manually.
+ */
 
-  while (index--) {
-    result[index] = self.all(rows[index]);
+function noTrailingSpaces(ast, file) {
+  var lines = file.toString().split(/\r?\n/);
+  for (var i = 0; i < lines.length; i++) {
+    var currentLine = lines[i];
+    var lineIndex = i + 1;
+    if (/\s$/.test(currentLine)) {
+      file.message('Remove trailing whitespace', {
+        position: {
+          start: { line: lineIndex, column: currentLine.length + 1 },
+          end: { line: lineIndex }
+        }
+      });
+    }
   }
-
-  exit();
-
-  return markdownTable_1(result, {
-    align: node.align,
-    alignDelimiters: alignDelimiters,
-    padding: padding,
-    stringLength: stringLength
-  })
-}
-
-var tableCell_1 = tableCell;
-
-var lineFeed$v = /\r?\n/g;
-
-function tableCell(node) {
-  return this.all(node).join('').replace(lineFeed$v, ' ')
-}
-
-var compiler = Compiler;
-
-// Construct a new compiler.
-function Compiler(tree, file) {
-  this.inLink = false;
-  this.inTable = false;
-  this.tree = tree;
-  this.file = file;
-  this.options = immutable(this.options);
-  this.setOptions({});
-}
-
-var proto$5 = Compiler.prototype;
-
-// Enter and exit helpers. */
-proto$5.enterLink = stateToggle('inLink', false);
-proto$5.enterTable = stateToggle('inTable', false);
-proto$5.enterLinkReference = enterLinkReference;
-
-// Configuration.
-proto$5.options = defaults$3;
-proto$5.setOptions = setOptions_1$1;
-
-proto$5.compile = compile_1$1;
-proto$5.visit = one_1;
-proto$5.all = all_1;
-proto$5.block = block_1;
-proto$5.visitOrderedItems = orderedItems_1;
-proto$5.visitUnorderedItems = unorderedItems_1;
-
-// Expose visitors.
-proto$5.visitors = {
-  root: root_1,
-  text: text_1$1,
-  heading: heading_1,
-  paragraph: paragraph_1$1,
-  blockquote: blockquote_1$1,
-  list: list_1$1,
-  listItem: listItem_1,
-  inlineCode: inlineCode_1,
-  code: code_1,
-  html: html_1,
-  thematicBreak: thematicBreak$1,
-  strong: strong_1$1,
-  emphasis: emphasis_1$1,
-  break: _break$2,
-  delete: _delete$2,
-  link: link_1$1,
-  linkReference: linkReference_1,
-  imageReference: imageReference_1,
-  definition: definition_1$1,
-  image: image_1,
-  table: table_1$1,
-  tableCell: tableCell_1
-};
-
-var remarkStringify = stringify$6;
-stringify$6.Compiler = compiler;
-
-function stringify$6(options) {
-  var Local = unherit_1(compiler);
-  Local.prototype.options = immutable(
-    Local.prototype.options,
-    this.data('settings'),
-    options
-  );
-  this.Compiler = Local;
 }
 
-var remark = unified_1().use(remarkParse).use(remarkStringify).freeze();
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-const _args = [
-	[
-		"remark@12.0.0",
-		"/Users/bytedance/Documents/code/github/node/tools/node-lint-md-cli-rollup"
-	]
-];
-const _from = "remark@12.0.0";
-const _id = "remark@12.0.0";
-const _inBundle = false;
-const _integrity = "sha512-oX4lMIS0csgk8AEbzY0h2jdR0ngiCHOpwwpxjmRa5TqAkeknY+tkhjRJGZqnCmvyuWh55/0SW5WY3R3nn3PH9A==";
-const _location = "/remark";
-const _phantomChildren = {
-};
-const _requested = {
-	type: "version",
-	registry: true,
-	raw: "remark@12.0.0",
-	name: "remark",
-	escapedName: "remark",
-	rawSpec: "12.0.0",
-	saveSpec: null,
-	fetchSpec: "12.0.0"
-};
-const _requiredBy = [
-	"/"
-];
-const _resolved = "https://registry.npmjs.org/remark/-/remark-12.0.0.tgz";
-const _spec = "12.0.0";
-const _where = "/Users/bytedance/Documents/code/github/node/tools/node-lint-md-cli-rollup";
-const author = {
-	name: "Titus Wormer",
-	email: "tituswormer@gmail.com",
-	url: "https://wooorm.com"
-};
-const bugs = {
-	url: "https://github.com/remarkjs/remark/issues"
-};
-const contributors = [
-	{
-		name: "Titus Wormer",
-		email: "tituswormer@gmail.com",
-		url: "https://wooorm.com"
-	}
-];
-const dependencies = {
-	"remark-parse": "^8.0.0",
-	"remark-stringify": "^8.0.0",
-	unified: "^9.0.0"
-};
-const description = "Markdown processor powered by plugins part of the unified collective";
-const files = [
-	"index.js",
-	"types/index.d.ts"
-];
-const funding = {
-	type: "opencollective",
-	url: "https://opencollective.com/unified"
-};
-const homepage = "https://remark.js.org";
-const keywords = [
-	"unified",
-	"remark",
-	"markdown",
-	"mdast",
-	"abstract",
-	"syntax",
-	"tree",
-	"ast",
-	"parse",
-	"stringify",
-	"serialize",
-	"compile",
-	"process"
-];
-const license = "MIT";
-const name$1 = "remark";
-const repository = {
-	type: "git",
-	url: "https://github.com/remarkjs/remark/tree/master/packages/remark"
-};
-const scripts = {
-	test: "tape test.js"
-};
-const types = "types/index.d.ts";
-const version$1 = "12.0.0";
-const xo = false;
-var _package = {
-	_args: _args,
-	_from: _from,
-	_id: _id,
-	_inBundle: _inBundle,
-	_integrity: _integrity,
-	_location: _location,
-	_phantomChildren: _phantomChildren,
-	_requested: _requested,
-	_requiredBy: _requiredBy,
-	_resolved: _resolved,
-	_spec: _spec,
-	_where: _where,
-	author: author,
-	bugs: bugs,
-	contributors: contributors,
-	dependencies: dependencies,
-	description: description,
-	files: files,
-	funding: funding,
-	homepage: homepage,
-	keywords: keywords,
-	license: license,
-	name: name$1,
-	repository: repository,
-	scripts: scripts,
-	types: types,
-	version: version$1,
-	xo: xo
-};
+const primitives$6 = new Set(['string', 'number', 'boolean']);
 
-var _package$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  _args: _args,
-  _from: _from,
-  _id: _id,
-  _inBundle: _inBundle,
-  _integrity: _integrity,
-  _location: _location,
-  _phantomChildren: _phantomChildren,
-  _requested: _requested,
-  _requiredBy: _requiredBy,
-  _resolved: _resolved,
-  _spec: _spec,
-  _where: _where,
-  author: author,
-  bugs: bugs,
-  contributors: contributors,
-  dependencies: dependencies,
-  description: description,
-  files: files,
-  funding: funding,
-  homepage: homepage,
-  keywords: keywords,
-  license: license,
-  name: name$1,
-  repository: repository,
-  scripts: scripts,
-  types: types,
-  version: version$1,
-  xo: xo,
-  'default': _package
-});
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$6(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-const name$2 = "node-lint-md-cli-rollup";
-const description$1 = "remark packaged for Node.js Markdown linting";
-const version$2 = "2.0.2";
-const devDependencies = {
-	"@rollup/plugin-commonjs": "^11.0.1",
-	"@rollup/plugin-json": "^4.0.1",
-	"@rollup/plugin-node-resolve": "^7.0.0",
-	rollup: "^1.30.1",
-	shx: "^0.3.2"
-};
-const dependencies$1 = {
-	"markdown-extensions": "^1.1.1",
-	remark: "^12.0.0",
-	"remark-lint": "^7.0.0",
-	"remark-preset-lint-node": "^1.16.0",
-	"unified-args": "^8.0.0"
-};
-const main = "dist/index.js";
-const scripts$1 = {
-	build: "npx rollup -c",
-	"build-node": "npm run build && npx shx cp dist/index.js ../lint-md.js"
-};
-var _package$2 = {
-	name: name$2,
-	description: description$1,
-	version: version$2,
-	devDependencies: devDependencies,
-	dependencies: dependencies$1,
-	main: main,
-	scripts: scripts$1
-};
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var _package$3 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  name: name$2,
-  description: description$1,
-  version: version$2,
-  devDependencies: devDependencies,
-  dependencies: dependencies$1,
-  main: main,
-  scripts: scripts$1,
-  'default': _package$2
-});
+  return plugin
 
-var vfileLocation$1 = factory$7;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$6(ruleId, raw);
 
-function factory$7(file) {
-  var contents = indices$1(String(file));
+    if (!severity) return
 
-  return {
-    toPosition: offsetToPositionFactory$1(contents),
-    toOffset: positionToOffsetFactory$1(contents)
-  }
-}
+    const fatal = severity === 2;
 
-// Factory to get the line and column-based `position` for `offset` in the bound
-// indices.
-function offsetToPositionFactory$1(indices) {
-  return offsetToPosition
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-  // Get the line and column-based `position` for `offset` in the bound indices.
-  function offsetToPosition(offset) {
-    var index = -1;
-    var length = indices.length;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-    if (offset < 0) {
-      return {}
-    }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-    while (++index < length) {
-      if (indices[index] > offset) {
-        return {
-          line: index + 1,
-          column: offset - (indices[index - 1] || 0) + 1,
-          offset: offset
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
         }
-      }
-    }
 
-    return {}
+        next();
+      })(tree, file, options);
+    }
   }
 }
 
-// Factory to get the `offset` for a line and column-based `position` in the
-// bound indices.
-function positionToOffsetFactory$1(indices) {
-  return positionToOffset
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$6(name, value) {
+  /** @type {unknown[]} */
+  let result;
+
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$6.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-  // Get the `offset` for a line and column-based `position` in the bound
-  // indices.
-  function positionToOffset(position) {
-    var line = position && position.line;
-    var column = position && position.column;
+  let level = result[0];
 
-    if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {
-      return (indices[line - 2] || 0) + column - 1 || 0
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
-
-    return -1
   }
-}
-
-// Get indices of line-breaks in `value`.
-function indices$1(value) {
-  var result = [];
-  var index = value.indexOf('\n');
 
-  while (index !== -1) {
-    result.push(index + 1);
-    index = value.indexOf('\n', index + 1);
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  result.push(value.length + 1);
+  result[0] = level;
 
+  // @ts-expect-error: it’s now a valid tuple.
   return result
 }
 
-var convert_1$1 = convert$4;
-
-function convert$4(test) {
-  if (typeof test === 'string') {
-    return typeFactory$1(test)
-  }
-
-  if (test === null || test === undefined) {
-    return ok$2
-  }
-
-  if (typeof test === 'object') {
-    return ('length' in test ? anyFactory$1 : matchesFactory$1)(test)
+function* getLinksRecursively(node) {
+  if (node.url) {
+    yield node;
   }
-
-  if (typeof test === 'function') {
-    return test
+  for (const child of node.children || []) {
+    yield* getLinksRecursively(child);
   }
-
-  throw new Error('Expected function, string, or object as test')
 }
 
-function convertAll$1(tests) {
-  var results = [];
-  var length = tests.length;
-  var index = -1;
-
-  while (++index < length) {
-    results[index] = convert$4(tests[index]);
+function validateLinks(tree, vfile) {
+  const currentFileURL = pathToFileURL(path$b.join(vfile.cwd, vfile.path));
+  let previousDefinitionLabel;
+  for (const node of getLinksRecursively(tree)) {
+    if (node.url[0] !== "#") {
+      const targetURL = new URL(node.url, currentFileURL);
+      if (targetURL.protocol === "file:" && !require$$0$3.existsSync(targetURL)) {
+        vfile.message("Broken link", node);
+      } else if (targetURL.pathname === currentFileURL.pathname) {
+        const expected = node.url.includes("#")
+          ? node.url.slice(node.url.indexOf("#"))
+          : "#";
+        vfile.message(
+          `Self-reference must start with hash (expected "${expected}", got "${node.url}")`,
+          node
+        );
+      }
+    }
+    if (node.type === "definition") {
+      if (previousDefinitionLabel && previousDefinitionLabel > node.label) {
+        vfile.message(
+          `Unordered reference ("${node.label}" should be before "${previousDefinitionLabel}")`,
+          node
+        );
+      }
+      previousDefinitionLabel = node.label;
+    }
   }
-
-  return results
 }
 
-// Utility assert each property in `test` is represented in `node`, and each
-// values are strictly equal.
-function matchesFactory$1(test) {
-  return matches
+const remarkLintNodejsLinks = lintRule$6(
+  "remark-lint:nodejs-links",
+  validateLinks
+);
 
-  function matches(node) {
-    var key;
+const allowedKeys = [
+  "added",
+  "napiVersion",
+  "deprecated",
+  "removed",
+  "changes",
+];
+const changesExpectedKeys = ["version", "pr-url", "description"];
+const VERSION_PLACEHOLDER = "REPLACEME";
+const MAX_SAFE_SEMVER_VERSION = parse_1(
+  Array.from({ length: 3 }, () => Number.MAX_SAFE_INTEGER).join(".")
+);
+const validVersionNumberRegex = /^v\d+\.\d+\.\d+$/;
+const prUrlRegex = new RegExp("^https://github.com/nodejs/node/pull/\\d+$");
+const privatePRUrl = "https://github.com/nodejs-private/node-private/pull/";
+
+let releasedVersions;
+let invalidVersionMessage = "version(s) must respect the pattern `vx.x.x` or";
+if (process.env.NODE_RELEASED_VERSIONS) {
+  console.log("Using release list from env...");
+  releasedVersions = process.env.NODE_RELEASED_VERSIONS.split(",").map(
+    (v) => `v${v}`
+  );
+  invalidVersionMessage = `version not listed in the changelogs, `;
+}
+invalidVersionMessage += `use the placeholder \`${VERSION_PLACEHOLDER}\``;
 
-    for (key in test) {
-      if (node[key] !== test[key]) {
-        return false
-      }
+const kContainsIllegalKey = Symbol("illegal key");
+const kWrongKeyOrder = Symbol("Wrong key order");
+function unorderedKeys(meta) {
+  const keys = Object.keys(meta);
+  let previousKeyIndex = -1;
+  for (const key of keys) {
+    const keyIndex = allowedKeys.indexOf(key);
+    if (keyIndex <= previousKeyIndex) {
+      return keyIndex === -1 ? kContainsIllegalKey : kWrongKeyOrder;
     }
-
-    return true
+    previousKeyIndex = keyIndex;
   }
 }
 
-function anyFactory$1(tests) {
-  var checks = convertAll$1(tests);
-  var length = checks.length;
+function containsInvalidVersionNumber(version) {
+  if (Array.isArray(version)) {
+    return version.some(containsInvalidVersionNumber);
+  }
 
-  return matches
+  if (version === undefined || version === VERSION_PLACEHOLDER) return false;
 
-  function matches() {
-    var index = -1;
+  if (
+    releasedVersions &&
+    // Always ignore 0.0.x and 0.1.x release numbers:
+    (version[1] !== "0" || (version[3] !== "0" && version[3] !== "1"))
+  )
+    return !releasedVersions.includes(version);
 
-    while (++index < length) {
-      if (checks[index].apply(this, arguments)) {
-        return true
-      }
-    }
+  return !validVersionNumberRegex.test(version);
+}
+const getValidSemver = (version) =>
+  version === VERSION_PLACEHOLDER ? MAX_SAFE_SEMVER_VERSION : version;
+function areVersionsUnordered(versions) {
+  if (!Array.isArray(versions)) return false;
 
-    return false
+  for (let index = 1; index < versions.length; index++) {
+    if (
+      lt_1(
+        getValidSemver(versions[index - 1]),
+        getValidSemver(versions[index])
+      )
+    ) {
+      return true;
+    }
   }
 }
 
-// Utility to convert a string into a function which checks a given node’s type
-// for said string.
-function typeFactory$1(test) {
-  return type
-
-  function type(node) {
-    return Boolean(node && node.type === test)
+function invalidChangesKeys(change) {
+  const keys = Object.keys(change);
+  const { length } = keys;
+  if (length !== changesExpectedKeys.length) return true;
+  for (let index = 0; index < length; index++) {
+    if (keys[index] !== changesExpectedKeys[index]) return true;
   }
 }
+function validateSecurityChange(file, node, change, index) {
+  if ("commit" in change) {
+    if (typeof change.commit !== "string" || isNaN(`0x${change.commit}`)) {
+      file.message(
+        `changes[${index}]: Ill-formed security change commit ID`,
+        node
+      );
+    }
 
-// Utility to return true.
-function ok$2() {
-  return true
+    if (Object.keys(change)[1] === "commit") {
+      change = { ...change };
+      delete change.commit;
+    }
+  }
+  if (invalidChangesKeys(change)) {
+    const securityChangeExpectedKeys = [...changesExpectedKeys];
+    securityChangeExpectedKeys[0] += "[, commit]";
+    file.message(
+      `changes[${index}]: Invalid keys. Expected keys are: ` +
+        securityChangeExpectedKeys.join(", "),
+      node
+    );
+  }
 }
+function validateChanges(file, node, changes) {
+  if (!Array.isArray(changes))
+    return file.message("`changes` must be a YAML list", node);
 
-var unistUtilVisitParents$1 = visitParents$1;
+  const changesVersions = [];
+  for (let index = 0; index < changes.length; index++) {
+    const change = changes[index];
 
+    const isAncient =
+      typeof change.version === "string" && change.version.startsWith("v0.");
+    const isSecurityChange =
+      !isAncient &&
+      typeof change["pr-url"] === "string" &&
+      change["pr-url"].startsWith(privatePRUrl);
 
+    if (isSecurityChange) {
+      validateSecurityChange(file, node, change, index);
+    } else if (!isAncient && invalidChangesKeys(change)) {
+      file.message(
+        `changes[${index}]: Invalid keys. Expected keys are: ` +
+          changesExpectedKeys.join(", "),
+        node
+      );
+    }
 
-var CONTINUE$2 = true;
-var SKIP$2 = 'skip';
-var EXIT$2 = false;
+    if (containsInvalidVersionNumber(change.version)) {
+      file.message(`changes[${index}]: ${invalidVersionMessage}`, node);
+    } else if (areVersionsUnordered(change.version)) {
+      file.message(`changes[${index}]: list of versions is not in order`, node);
+    }
 
-visitParents$1.CONTINUE = CONTINUE$2;
-visitParents$1.SKIP = SKIP$2;
-visitParents$1.EXIT = EXIT$2;
+    if (!isAncient && !isSecurityChange && !prUrlRegex.test(change["pr-url"])) {
+      file.message(
+        `changes[${index}]: PR-URL does not match the expected pattern`,
+        node
+      );
+    }
 
-function visitParents$1(tree, test, visitor, reverse) {
-  var is;
+    if (typeof change.description !== "string" || !change.description.length) {
+      file.message(
+        `changes[${index}]: must contain a non-empty description`,
+        node
+      );
+    } else if (!change.description.endsWith(".")) {
+      file.message(
+        `changes[${index}]: description must end with a period`,
+        node
+      );
+    }
 
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor;
-    visitor = test;
-    test = null;
+    changesVersions.push(
+      Array.isArray(change.version) ? change.version[0] : change.version
+    );
   }
 
-  is = convert_1$1(test);
-
-  one(tree, null, []);
-
-  // Visit a single node.
-  function one(node, index, parents) {
-    var result = [];
-    var subresult;
+  if (areVersionsUnordered(changesVersions)) {
+    file.message("Items in `changes` list are not in order", node);
+  }
+}
 
-    if (!test || is(node, index, parents[parents.length - 1] || null)) {
-      result = toResult$1(visitor(node, parents));
+function validateMeta(node, file, meta) {
+  switch (unorderedKeys(meta)) {
+    case kContainsIllegalKey:
+      file.message(
+        "YAML dictionary contains illegal keys. Accepted values are: " +
+          allowedKeys.join(", "),
+        node
+      );
+      break;
 
-      if (result[0] === EXIT$2) {
-        return result
-      }
-    }
+    case kWrongKeyOrder:
+      file.message(
+        "YAML dictionary keys should be in this order: " +
+          allowedKeys.join(", "),
+        node
+      );
+      break;
+  }
 
-    if (node.children && result[0] !== SKIP$2) {
-      subresult = toResult$1(all(node.children, parents.concat(node)));
-      return subresult[0] === EXIT$2 ? subresult : result
-    }
+  if (containsInvalidVersionNumber(meta.added)) {
+    file.message(`Invalid \`added\` value: ${invalidVersionMessage}`, node);
+  } else if (areVersionsUnordered(meta.added)) {
+    file.message("Versions in `added` list are not in order", node);
+  }
 
-    return result
+  if (containsInvalidVersionNumber(meta.deprecated)) {
+    file.message(
+      `Invalid \`deprecated\` value: ${invalidVersionMessage}`,
+      node
+    );
+  } else if (areVersionsUnordered(meta.deprecated)) {
+    file.message("Versions in `deprecated` list are not in order", node);
   }
 
-  // Visit children in `parent`.
-  function all(children, parents) {
-    var min = -1;
-    var step = reverse ? -1 : 1;
-    var index = (reverse ? children.length : min) + step;
-    var result;
+  if (containsInvalidVersionNumber(meta.removed)) {
+    file.message(`Invalid \`removed\` value: ${invalidVersionMessage}`, node);
+  } else if (areVersionsUnordered(meta.removed)) {
+    file.message("Versions in `removed` list are not in order", node);
+  }
 
-    while (index > min && index < children.length) {
-      result = one(children[index], index, parents);
+  if ("changes" in meta) {
+    validateChanges(file, node, meta.changes);
+  }
+}
 
-      if (result[0] === EXIT$2) {
-        return result
-      }
+function validateYAMLComments(tree, file) {
+  visit(tree, "html", function visitor(node) {
+    if (node.value.startsWith("<!--YAML\n"))
+      file.message(
+        "Expected `<!-- YAML`, found `<!--YAML`. Please add a space",
+        node
+      );
+    if (!node.value.startsWith("<!-- YAML\n")) return;
+    try {
+      const meta = jsYaml.load("#" + node.value.slice(0, -"-->".length));
 
-      index = typeof result[1] === 'number' ? result[1] : index + step;
+      validateMeta(node, file, meta);
+    } catch (e) {
+      file.message(e, node);
     }
-  }
+  });
 }
 
-function toResult$1(value) {
-  if (value !== null && typeof value === 'object' && 'length' in value) {
-    return value
-  }
+const remarkLintNodejsYamlComments = lintRule$6(
+  "remark-lint:nodejs-yaml-comments",
+  validateYAMLComments
+);
 
-  if (typeof value === 'number') {
-    return [CONTINUE$2, value]
-  }
+function escapeStringRegexp(string) {
+	if (typeof string !== 'string') {
+		throw new TypeError('Expected a string');
+	}
 
-  return [value]
+	// Escape characters with special meaning either inside or outside character sets.
+	// Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+	return string
+		.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
+		.replace(/-/g, '\\x2d');
 }
 
-var unistUtilVisit$1 = visit$1;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
+const primitives$5 = new Set(['string', 'number', 'boolean']);
 
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$5(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-var CONTINUE$3 = unistUtilVisitParents$1.CONTINUE;
-var SKIP$3 = unistUtilVisitParents$1.SKIP;
-var EXIT$3 = unistUtilVisitParents$1.EXIT;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-visit$1.CONTINUE = CONTINUE$3;
-visit$1.SKIP = SKIP$3;
-visit$1.EXIT = EXIT$3;
+  return plugin
 
-function visit$1(tree, test, visitor, reverse) {
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor;
-    visitor = test;
-    test = null;
-  }
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$5(ruleId, raw);
 
-  unistUtilVisitParents$1(tree, test, overload, reverse);
+    if (!severity) return
 
-  function overload(node, parents) {
-    var parent = parents[parents.length - 1];
-    var index = parent ? parent.children.indexOf(node) : null;
-    return visitor(node, index, parent)
-  }
-}
+    const fatal = severity === 2;
 
-var unifiedMessageControl = messageControl;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-function messageControl(options) {
-  var settings = options || {};
-  var name = settings.name;
-  var marker = settings.marker;
-  var test = settings.test;
-  var sources = settings.source;
-  var known = settings.known;
-  var reset = settings.reset;
-  var enable = settings.enable || [];
-  var disable = settings.disable || [];
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  if (!name) {
-    throw new Error('Expected `name` in `options`, got `' + name + '`')
-  }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  if (!marker) {
-    throw new Error('Expected `marker` in `options`, got `' + marker + '`')
-  }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-  if (!sources) {
-    sources = [name];
-  } else if (typeof sources === 'string') {
-    sources = [sources];
+        next();
+      })(tree, file, options);
+    }
   }
+}
 
-  return transformer
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$5(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  function transformer(tree, file) {
-    var toOffset = vfileLocation$1(file).toOffset;
-    var initial = !reset;
-    var gaps = detectGaps(tree, file);
-    var scope = {};
-    var globals = [];
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$5.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-    unistUtilVisit$1(tree, test, visitor);
+  let level = result[0];
 
-    file.messages = file.messages.filter(filter);
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
+  }
 
-    function visitor(node, position, parent) {
-      var mark = marker(node);
-      var ruleIds;
-      var ruleId;
-      var verb;
-      var index;
-      var length;
-      var next;
-      var pos;
-      var tail;
-
-      if (!mark || mark.name !== name) {
-        return
-      }
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-      ruleIds = mark.attributes.split(/\s/g);
-      verb = ruleIds.shift();
-      next = parent.children[position + 1];
-      pos = mark.node.position && mark.node.position.start;
-      tail = next && next.position && next.position.end;
+  result[0] = level;
 
-      if (verb !== 'enable' && verb !== 'disable' && verb !== 'ignore') {
-        file.fail(
-          'Unknown keyword `' +
-            verb +
-            '`: expected ' +
-            "`'enable'`, `'disable'`, or `'ignore'`",
-          mark.node
-        );
-      }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
 
-      length = ruleIds.length;
-      index = -1;
+const remarkLintProhibitedStrings = lintRule$5('remark-lint:prohibited-strings', prohibitedStrings);
 
-      // Apply to all rules.
-      if (length === 0) {
-        if (verb === 'ignore') {
-          toggle(pos, false);
-          toggle(tail, true);
-        } else {
-          toggle(pos, verb === 'enable');
-          reset = verb !== 'enable';
-        }
-      } else {
-        while (++index < length) {
-          ruleId = ruleIds[index];
+function testProhibited (val, content) {
+  let regexpFlags = 'g';
+  let no = val.no;
 
-          if (isKnown(ruleId, verb, mark.node)) {
-            toggle(pos, verb === 'enable', ruleId);
+  if (!no) {
+    no = escapeStringRegexp(val.yes);
+    regexpFlags += 'i';
+  }
 
-            if (verb === 'ignore') {
-              toggle(tail, true, ruleId);
-            }
-          }
-        }
-      }
-    }
+  let regexpString = '(?<!\\.|@[a-zA-Z0-9/-]*)';
 
-    function filter(message) {
-      var gapIndex = gaps.length;
-      var ruleId = message.ruleId;
-      var ranges = scope[ruleId];
-      var pos;
+  const ignoreNextTo = val.ignoreNextTo ? escapeStringRegexp(val.ignoreNextTo) : '';
+  const replaceCaptureGroups = !!val.replaceCaptureGroups;
 
-      // Keep messages from a different source.
-      if (!message.source || sources.indexOf(message.source) === -1) {
-        return true
-      }
+  // If it starts with a letter, make sure it is a word break.
+  if (/^\b/.test(no)) {
+    regexpString += '\\b';
+  }
+  if (ignoreNextTo) {
+    regexpString += `(?<!${ignoreNextTo})`;
+  }
 
-      // We only ignore messages if they‘re disabled, *not* when they’re not in
-      // the document.
-      if (!message.line) {
-        message.line = 1;
-      }
+  regexpString += `(${no})`;
 
-      if (!message.column) {
-        message.column = 1;
-      }
+  if (ignoreNextTo) {
+    regexpString += `(?!${ignoreNextTo})`;
+  }
 
-      // Check whether the warning is inside a gap.
-      pos = toOffset(message);
+  // If it ends with a letter, make sure it is a word break.
+  if (/\b$/.test(no)) {
+    regexpString += '\\b';
+  }
+  regexpString += '(?!\\.\\w)';
+  const re = new RegExp(regexpString, regexpFlags);
 
-      while (gapIndex--) {
-        if (gaps[gapIndex].start <= pos && gaps[gapIndex].end > pos) {
-          return false
-        }
+  const results = [];
+  let result = re.exec(content);
+  while (result) {
+    if (result[1] !== val.yes) {
+      let yes = val.yes;
+      if (replaceCaptureGroups) {
+        yes = result[1].replace(new RegExp(no), yes);
       }
-
-      // Check whether allowed by specific and global states.
-      return check(message, ranges, ruleId) && check(message, globals)
+      results.push({ result: result[1], index: result.index, yes: yes });
     }
+    result = re.exec(content);
+  }
 
-    // Helper to check (and possibly warn) if a `ruleId` is unknown.
-    function isKnown(ruleId, verb, pos) {
-      var result = known ? known.indexOf(ruleId) !== -1 : true;
+  return results
+}
 
-      if (!result) {
-        file.message(
-          'Unknown rule: cannot ' + verb + " `'" + ruleId + "'`",
-          pos
-        );
-      }
+function prohibitedStrings (ast, file, strings) {
+  const myLocation = location(file);
 
-      return result
-    }
+  visit(ast, 'text', checkText);
 
-    // Get the latest state of a rule.
-    // When without `ruleId`, gets global state.
-    function getState(ruleId) {
-      var ranges = ruleId ? scope[ruleId] : globals;
+  function checkText (node) {
+    const content = node.value;
+    const initial = pointStart(node).offset;
 
-      if (ranges && ranges.length !== 0) {
-        return ranges[ranges.length - 1].state
+    strings.forEach((val) => {
+      const results = testProhibited(val, content);
+      if (results.length) {
+        results.forEach(({ result, index, yes }) => {
+          const message = val.yes ? `Use "${yes}" instead of "${result}"` : `Do not use "${result}"`;
+          file.message(message, {
+            start: myLocation.toPoint(initial + index),
+            end: myLocation.toPoint(initial + index + [...result].length)
+          });
+        });
       }
+    });
+  }
+}
 
-      if (!ruleId) {
-        return !reset
-      }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-      if (reset) {
-        return enable.indexOf(ruleId) !== -1
-      }
+const primitives$4 = new Set(['string', 'number', 'boolean']);
 
-      return disable.indexOf(ruleId) === -1
-    }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$4(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-    // Handle a rule.
-    function toggle(pos, state, ruleId) {
-      var markers = ruleId ? scope[ruleId] : globals;
-      var previousState;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-      if (!markers) {
-        markers = [];
-        scope[ruleId] = markers;
-      }
+  return plugin
 
-      previousState = getState(ruleId);
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$4(ruleId, raw);
 
-      if (state !== previousState) {
-        markers.push({state: state, position: pos});
-      }
+    if (!severity) return
 
-      // Toggle all known rules.
-      if (!ruleId) {
-        for (ruleId in scope) {
-          toggle(pos, state, ruleId);
-        }
-      }
-    }
+    const fatal = severity === 2;
 
-    // Check all `ranges` for `message`.
-    function check(message, ranges, id) {
-      // Check the state at the message’s position.
-      var index = ranges && ranges.length;
-      var length = -1;
-      var range;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      while (--index > length) {
-        range = ranges[index];
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-        /* istanbul ignore if - Generated marker. */
-        if (!range.position || !range.position.line || !range.position.column) {
-          continue
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
 
-        if (
-          range.position.line < message.line ||
-          (range.position.line === message.line &&
-            range.position.column <= message.column)
-        ) {
-          return range.state === true
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
         }
-      }
-
-      // The first marker ocurred after the first message, so we check the
-      // initial state.
-      if (!id) {
-        return initial || reset
-      }
 
-      return reset ? enable.indexOf(id) !== -1 : disable.indexOf(id) === -1
+        next();
+      })(tree, file, options);
     }
   }
 }
 
-// Detect gaps in `tree`.
-function detectGaps(tree, file) {
-  var lastNode = tree.children[tree.children.length - 1];
-  var offset = 0;
-  var isGap = false;
-  var gaps = [];
-
-  // Find all gaps.
-  unistUtilVisit$1(tree, one);
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$4(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-  // Get the end of the document.
-  // This detects if the last node was the last node.
-  // If not, there’s an extra gap between the last node and the end of the
-  // document.
-  if (
-    lastNode &&
-    lastNode.position &&
-    lastNode.position.end &&
-    offset === lastNode.position.end.offset &&
-    trim(file.toString().slice(offset)) !== ''
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$4.has(typeof value[0])
   ) {
-    update();
-
-    update(
-      tree && tree.position && tree.position.end && tree.position.end.offset - 1
-    );
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  return gaps
-
-  function one(node) {
-    var pos = node.position;
-
-    update(pos && pos.start && pos.start.offset);
+  let level = result[0];
 
-    if (!node.children) {
-      update(pos && pos.end && pos.end.offset);
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
     }
   }
 
-  // Detect a new position.
-  function update(latest) {
-    if (latest === null || latest === undefined) {
-      isGap = true;
-      return
-    }
-
-    if (offset >= latest) {
-      return
-    }
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-    if (isGap) {
-      gaps.push({start: offset, end: latest});
-      isGap = false;
-    }
+  result[0] = level;
 
-    offset = latest;
-  }
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
-function trim(value) {
-  return value.replace(/^\s*|\s*$/g, '')
-}
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module rule-style
+ * @fileoverview
+ *   Warn when the thematic breaks (horizontal rules) violate a given or
+ *   detected style.
+ *
+ *   Options: `string`, either a corect thematic breaks such as `***`, or
+ *   `'consistent'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used thematic break style and warns when
+ *   subsequent rules use different styles.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   has three settings that define how rules are created:
+ *
+ *   *   [`rule`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionsrule)
+ *       (default: `*`) — Marker to use
+ *   *   [`ruleRepetition`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionsrulerepetition)
+ *       (default: `3`) — Number of markers to use
+ *   *   [`ruleSpaces`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionsrulespaces)
+ *       (default: `true`) — Whether to pad markers with spaces
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "* * *"}
+ *
+ *   * * *
+ *
+ *   * * *
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "_______"}
+ *
+ *   _______
+ *
+ *   _______
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   ***
+ *
+ *   * * *
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   3:1-3:6: Rules should use `***`
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "setting": "💩", "positionless": true}
+ *
+ *   1:1: Incorrect preferred rule style: provide a correct markdown rule or `'consistent'`
+ */
 
-var mdastCommentMarker = marker$1;
+const remarkLintRuleStyle = lintRule$4(
+  'remark-lint:rule-style',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    const value = String(file);
 
-var whiteSpaceExpression = /\s+/g;
+    if (option !== 'consistent' && /[^-_* ]/.test(option)) {
+      file.fail(
+        "Incorrect preferred rule style: provide a correct markdown rule or `'consistent'`"
+      );
+    }
 
-var parametersExpression = /\s+([-a-z0-9_]+)(?:=(?:"((?:\\[\s\S]|[^"])+)"|'((?:\\[\s\S]|[^'])+)'|((?:\\[\s\S]|[^"'\s])+)))?/gi;
+    visit(tree, 'thematicBreak', (node) => {
+      const initial = pointStart(node).offset;
+      const final = pointEnd(node).offset;
 
-var commentExpression = /\s*([a-zA-Z0-9-]+)(\s+([\s\S]*))?\s*/;
+      if (typeof initial === 'number' && typeof final === 'number') {
+        const rule = value.slice(initial, final);
 
-var markerExpression = new RegExp(
-  '(\\s*<!--' + commentExpression.source + '-->\\s*)'
+        if (option === 'consistent') {
+          option = rule;
+        } else if (rule !== option) {
+          file.message('Rules should use `' + option + '`', node);
+        }
+      }
+    });
+  }
 );
 
-// Parse a comment marker.
-function marker$1(node) {
-  var type;
-  var value;
-  var match;
-  var params;
+var remarkLintRuleStyle$1 = remarkLintRuleStyle;
 
-  if (!node) {
-    return null
-  }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
 
-  type = node.type;
+const primitives$3 = new Set(['string', 'number', 'boolean']);
 
-  if (type !== 'html' && type !== 'comment') {
-    return null
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$3(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  value = node.value;
-  match = value.match(type === 'comment' ? commentExpression : markerExpression);
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  if (!match || match[0].length !== value.length) {
-    return null
-  }
+  return plugin
 
-  match = match.slice(node.type === 'comment' ? 1 : 2);
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$3(ruleId, raw);
 
-  params = parameters(match[1] || '');
+    if (!severity) return
 
-  if (!params) {
-    return null
-  }
+    const fatal = severity === 2;
 
-  return {
-    name: match[0],
-    attributes: match[2] || '',
-    parameters: params,
-    node: node
-  }
-}
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-// Parse `value` into an object.
-function parameters(value) {
-  var attributes = {};
-  var rest = value.replace(parametersExpression, replacer);
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-  return rest.replace(whiteSpaceExpression, '') ? null : attributes
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-  /* eslint-disable max-params */
-  function replacer($0, $1, $2, $3, $4) {
-    var result = $2 || $3 || $4 || '';
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    if (result === 'true' || result === '') {
-      result = true;
-    } else if (result === 'false') {
-      result = false;
-    } else if (!isNaN(result)) {
-      result = Number(result);
+        next();
+      })(tree, file, options);
     }
-
-    attributes[$1] = result;
-
-    return ''
   }
 }
 
-var remarkMessageControl = messageControl$1;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$3(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-var test = [
-  'html', // Comments are `html` nodes in mdast.
-  'comment' // In MDX, comments have their own node.
-];
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$3.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-function messageControl$1(options) {
-  return unifiedMessageControl(Object.assign({marker: mdastCommentMarker, test: test}, options))
-}
+  let level = result[0];
+
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
+  }
 
-var remarkLint = lint;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
 
-// `remark-lint`.
-// This adds support for ignoring stuff from messages (`<!--lint ignore-->`).
-// All rules are in their own packages and presets.
-function lint() {
-  this.use(lintMessageControl);
-}
+  result[0] = level;
 
-function lintMessageControl() {
-  return remarkMessageControl({name: 'lint', source: 'remark-lint'})
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
 /**
- * An Array.prototype.slice.call(arguments) alternative
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module strong-marker
+ * @fileoverview
+ *   Warn for violating importance (strong) markers.
  *
- * @param {Object} args something with a length
- * @param {Number} slice
- * @param {Number} sliceEnd
- * @api public
+ *   Options: `'consistent'`, `'*'`, or `'_'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used importance style and warns when
+ *   subsequent importance sequences use different styles.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   formats importance using an `*` (asterisk) by default.
+ *   Pass
+ *   [`strong: '_'`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionsstrong)
+ *   to use `_` (underscore) instead.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   **foo** and **bar**.
+ *
+ * @example
+ *   {"name": "also-ok.md"}
+ *
+ *   __foo__ and __bar__.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "*"}
+ *
+ *   **foo**.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "_"}
+ *
+ *   __foo__.
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   **foo** and __bar__.
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   1:13-1:20: Strong should use `*` as a marker
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "setting": "💩", "positionless": true}
+ *
+ *   1:1: Incorrect strong marker `💩`: use either `'consistent'`, `'*'`, or `'_'`
  */
 
-var sliced = function (args, slice, sliceEnd) {
-  var ret = [];
-  var len = args.length;
-
-  if (0 === len) return ret;
+const remarkLintStrongMarker = lintRule$3(
+  'remark-lint:strong-marker',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    const value = String(file);
+
+    if (option !== '*' && option !== '_' && option !== 'consistent') {
+      file.fail(
+        'Incorrect strong marker `' +
+          option +
+          "`: use either `'consistent'`, `'*'`, or `'_'`"
+      );
+    }
 
-  var start = slice < 0
-    ? Math.max(0, slice + len)
-    : slice || 0;
+    visit(tree, 'strong', (node) => {
+      const start = pointStart(node).offset;
 
-  if (sliceEnd !== undefined) {
-    len = sliceEnd < 0
-      ? sliceEnd + len
-      : sliceEnd;
-  }
+      if (typeof start === 'number') {
+        const marker = /** @type {Marker} */ (value.charAt(start));
 
-  while (len-- > start) {
-    ret[len - start] = args[len];
+        if (option === 'consistent') {
+          option = marker;
+        } else if (marker !== option) {
+          file.message('Strong should use `' + option + '` as a marker', node);
+        }
+      }
+    });
   }
+);
 
-  return ret;
-};
-
-/**
- * slice() reference.
- */
-
-var slice$4 = Array.prototype.slice;
+var remarkLintStrongMarker$1 = remarkLintStrongMarker;
 
 /**
- * Expose `co`.
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
  */
 
-var co_1 = co;
+const primitives$2 = new Set(['string', 'number', 'boolean']);
 
 /**
- * Wrap the given generator `fn` and
- * return a thunk.
- *
- * @param {Function} fn
- * @return {Function}
- * @api public
+ * @param {string} id
+ * @param {Rule} rule
  */
+function lintRule$2(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-function co(fn) {
-  var isGenFun = isGeneratorFunction(fn);
-
-  return function (done) {
-    var ctx = this;
-
-    // in toThunk() below we invoke co()
-    // with a generator, so optimize for
-    // this case
-    var gen = fn;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-    // we only need to parse the arguments
-    // if gen is a generator function.
-    if (isGenFun) {
-      var args = slice$4.call(arguments), len = args.length;
-      var hasCallback = len && 'function' == typeof args[len - 1];
-      done = hasCallback ? args.pop() : error;
-      gen = fn.apply(this, args);
-    } else {
-      done = done || error;
-    }
+  return plugin
 
-    next();
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$2(ruleId, raw);
 
-    // #92
-    // wrap the callback in a setImmediate
-    // so that any of its errors aren't caught by `co`
-    function exit(err, res) {
-      setImmediate(function(){
-        done.call(ctx, err, res);
-      });
-    }
+    if (!severity) return
 
-    function next(err, res) {
-      var ret;
+    const fatal = severity === 2;
 
-      // multiple args
-      if (arguments.length > 2) res = slice$4.call(arguments, 1);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      // error
-      if (err) {
-        try {
-          ret = gen.throw(err);
-        } catch (e) {
-          return exit(e);
-        }
-      }
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-      // ok
-      if (!err) {
-        try {
-          ret = gen.next(res);
-        } catch (e) {
-          return exit(e);
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
         }
-      }
-
-      // done
-      if (ret.done) return exit(null, ret.value);
-
-      // normalize
-      ret.value = toThunk(ret.value, ctx);
 
-      // run
-      if ('function' == typeof ret.value) {
-        var called = false;
-        try {
-          ret.value.call(ctx, function(){
-            if (called) return;
-            called = true;
-            next.apply(ctx, arguments);
-          });
-        } catch (e) {
-          setImmediate(function(){
-            if (called) return;
-            called = true;
-            next(e);
-          });
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
         }
-        return;
-      }
 
-      // invalid
-      next(new TypeError('You may only yield a function, promise, generator, array, or object, '
-        + 'but the following was passed: "' + String(ret.value) + '"'));
+        next();
+      })(tree, file, options);
     }
   }
 }
 
 /**
- * Convert `obj` into a normalized thunk.
+ * Coerce a value to a severity--options tuple.
  *
- * @param {Mixed} obj
- * @param {Mixed} ctx
- * @return {Function}
- * @api private
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
  */
+function coerce$2(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-function toThunk(obj, ctx) {
-
-  if (isGeneratorFunction(obj)) {
-    return co(obj.call(ctx));
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$2.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
   }
 
-  if (isGenerator(obj)) {
-    return co(obj);
-  }
+  let level = result[0];
 
-  if (isPromise(obj)) {
-    return promiseToThunk(obj);
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
+    } else {
+      level = 1;
+      result = [level, result];
+    }
   }
 
-  if ('function' == typeof obj) {
-    return obj;
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
   }
 
-  if (isObject$3(obj) || Array.isArray(obj)) {
-    return objectToThunk.call(ctx, obj);
-  }
+  result[0] = level;
+
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
+}
+
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module table-cell-padding
+ * @fileoverview
+ *   Warn when table cells are incorrectly padded.
+ *
+ *   Options: `'consistent'`, `'padded'`, or `'compact'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used cell padding style and warns when
+ *   subsequent cells use different styles.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   formats tables with padding by default.
+ *   Pass
+ *   [`spacedTable: false`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionsspacedtable)
+ *   to not use padding.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "padded", "gfm": true}
+ *
+ *   | A     | B     |
+ *   | ----- | ----- |
+ *   | Alpha | Bravo |
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input", "setting": "padded", "gfm": true}
+ *
+ *   | A    |    B |
+ *   | :----|----: |
+ *   | Alpha|Bravo |
+ *
+ *   | C      |    D |
+ *   | :----- | ---: |
+ *   |Charlie | Delta|
+ *
+ *   Too much padding isn’t good either:
+ *
+ *   | E     | F        |   G    |      H |
+ *   | :---- | -------- | :----: | -----: |
+ *   | Echo  | Foxtrot  |  Golf  |  Hotel |
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "setting": "padded", "gfm": true}
+ *
+ *   3:8: Cell should be padded
+ *   3:9: Cell should be padded
+ *   7:2: Cell should be padded
+ *   7:17: Cell should be padded
+ *   13:9: Cell should be padded with 1 space, not 2
+ *   13:20: Cell should be padded with 1 space, not 2
+ *   13:21: Cell should be padded with 1 space, not 2
+ *   13:29: Cell should be padded with 1 space, not 2
+ *   13:30: Cell should be padded with 1 space, not 2
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "compact", "gfm": true}
+ *
+ *   |A    |B    |
+ *   |-----|-----|
+ *   |Alpha|Bravo|
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input", "setting": "compact", "gfm": true}
+ *
+ *   |   A    | B    |
+ *   |   -----| -----|
+ *   |   Alpha| Bravo|
+ *
+ *   |C      |     D|
+ *   |:------|-----:|
+ *   |Charlie|Delta |
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "setting": "compact", "gfm": true}
+ *
+ *   3:2: Cell should be compact
+ *   3:11: Cell should be compact
+ *   7:16: Cell should be compact
+ *
+ * @example
+ *   {"name": "ok-padded.md", "setting": "consistent", "gfm": true}
+ *
+ *   | A     | B     |
+ *   | ----- | ----- |
+ *   | Alpha | Bravo |
+ *
+ *   | C       | D     |
+ *   | ------- | ----- |
+ *   | Charlie | Delta |
+ *
+ * @example
+ *   {"name": "not-ok-padded.md", "label": "input", "setting": "consistent", "gfm": true}
+ *
+ *   | A     | B     |
+ *   | ----- | ----- |
+ *   | Alpha | Bravo |
+ *
+ *   | C      |     D |
+ *   | :----- | ----: |
+ *   |Charlie | Delta |
+ *
+ * @example
+ *   {"name": "not-ok-padded.md", "label": "output", "setting": "consistent", "gfm": true}
+ *
+ *   7:2: Cell should be padded
+ *
+ * @example
+ *   {"name": "ok-compact.md", "setting": "consistent", "gfm": true}
+ *
+ *   |A    |B    |
+ *   |-----|-----|
+ *   |Alpha|Bravo|
+ *
+ *   |C      |D    |
+ *   |-------|-----|
+ *   |Charlie|Delta|
+ *
+ * @example
+ *   {"name": "not-ok-compact.md", "label": "input", "setting": "consistent", "gfm": true}
+ *
+ *   |A    |B    |
+ *   |-----|-----|
+ *   |Alpha|Bravo|
+ *
+ *   |C      |     D|
+ *   |:------|-----:|
+ *   |Charlie|Delta |
+ *
+ * @example
+ *   {"name": "not-ok-compact.md", "label": "output", "setting": "consistent", "gfm": true}
+ *
+ *   7:16: Cell should be compact
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "setting": "💩", "positionless": true, "gfm": true}
+ *
+ *   1:1: Incorrect table cell padding style `💩`, expected `'padded'`, `'compact'`, or `'consistent'`
+ *
+ * @example
+ *   {"name": "empty.md", "label": "input", "setting": "padded", "gfm": true}
+ *
+ *   <!-- Empty cells are OK, but those surrounding them may not be. -->
+ *
+ *   |        | Alpha | Bravo|
+ *   | ------ | ----- | ---: |
+ *   | Charlie|       |  Echo|
+ *
+ * @example
+ *   {"name": "empty.md", "label": "output", "setting": "padded", "gfm": true}
+ *
+ *   3:25: Cell should be padded
+ *   5:10: Cell should be padded
+ *   5:25: Cell should be padded
+ *
+ * @example
+ *   {"name": "missing-body.md", "setting": "padded", "gfm": true}
+ *
+ *   <!-- Missing cells are fine as well. -->
+ *
+ *   | Alpha | Bravo   | Charlie |
+ *   | ----- | ------- | ------- |
+ *   | Delta |
+ *   | Echo  | Foxtrot |
+ */
+
+const remarkLintTableCellPadding = lintRule$2(
+  'remark-lint:table-cell-padding',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    if (
+      option !== 'padded' &&
+      option !== 'compact' &&
+      option !== 'consistent'
+    ) {
+      file.fail(
+        'Incorrect table cell padding style `' +
+          option +
+          "`, expected `'padded'`, `'compact'`, or `'consistent'`"
+      );
+    }
+
+    visit(tree, 'table', (node) => {
+      const rows = node.children;
+      // To do: fix types to always have `align` defined.
+      /* c8 ignore next */
+      const align = node.align || [];
+      /** @type {number[]} */
+      const sizes = Array.from({length: align.length});
+      /** @type {Entry[]} */
+      const entries = [];
+      let index = -1;
+
+      // Check rows.
+      while (++index < rows.length) {
+        const row = rows[index];
+        let column = -1;
+
+        // Check fences (before, between, and after cells).
+        while (++column < row.children.length) {
+          const cell = row.children[column];
+
+          if (cell.children.length > 0) {
+            const cellStart = pointStart(cell).offset;
+            const cellEnd = pointEnd(cell).offset;
+            const contentStart = pointStart(cell.children[0]).offset;
+            const contentEnd = pointEnd(
+              cell.children[cell.children.length - 1]
+            ).offset;
+
+            if (
+              typeof cellStart !== 'number' ||
+              typeof cellEnd !== 'number' ||
+              typeof contentStart !== 'number' ||
+              typeof contentEnd !== 'number'
+            ) {
+              continue
+            }
+
+            entries.push({
+              node: cell,
+              start: contentStart - cellStart - (column ? 0 : 1),
+              end: cellEnd - contentEnd - 1,
+              column
+            });
+
+            // Detect max space per column.
+            sizes[column] = Math.max(
+              sizes[column] || 0,
+              contentEnd - contentStart
+            );
+          }
+        }
+      }
 
-  return obj;
-}
+      const style =
+        option === 'consistent'
+          ? entries[0] && (!entries[0].start || !entries[0].end)
+            ? 0
+            : 1
+          : option === 'padded'
+          ? 1
+          : 0;
 
-/**
- * Convert an object of yieldables to a thunk.
- *
- * @param {Object} obj
- * @return {Function}
- * @api private
- */
+      index = -1;
 
-function objectToThunk(obj){
-  var ctx = this;
-  var isArray = Array.isArray(obj);
+      while (++index < entries.length) {
+        checkSide('start', entries[index], style, sizes);
+        checkSide('end', entries[index], style, sizes);
+      }
 
-  return function(done){
-    var keys = Object.keys(obj);
-    var pending = keys.length;
-    var results = isArray
-      ? new Array(pending) // predefine the array length
-      : new obj.constructor();
-    var finished;
+      return SKIP$1
+    });
 
-    if (!pending) {
-      setImmediate(function(){
-        done(null, results);
-      });
-      return;
-    }
+    /**
+     * @param {'start'|'end'} side
+     * @param {Entry} entry
+     * @param {0|1} style
+     * @param {number[]} sizes
+     */
+    function checkSide(side, entry, style, sizes) {
+      const cell = entry.node;
+      const column = entry.column;
+      const spacing = entry[side];
 
-    // prepopulate object keys to preserve key ordering
-    if (!isArray) {
-      for (var i = 0; i < pending; i++) {
-        results[keys[i]] = undefined;
+      if (spacing === undefined || spacing === style) {
+        return
       }
-    }
-
-    for (var i = 0; i < keys.length; i++) {
-      run(obj[keys[i]], keys[i]);
-    }
 
-    function run(fn, key) {
-      if (finished) return;
-      try {
-        fn = toThunk(fn, ctx);
+      let reason = 'Cell should be ';
 
-        if ('function' != typeof fn) {
-          results[key] = fn;
-          return --pending || done(null, results);
+      if (style === 0) {
+        // Ignore every cell except the biggest in the column.
+        if (size(cell) < sizes[column]) {
+          return
         }
 
-        fn.call(ctx, function(err, res){
-          if (finished) return;
+        reason += 'compact';
+      } else {
+        reason += 'padded';
 
-          if (err) {
-            finished = true;
-            return done(err);
+        if (spacing > style) {
+          // May be right or center aligned.
+          if (size(cell) < sizes[column]) {
+            return
           }
 
-          results[key] = res;
-          --pending || done(null, results);
-        });
-      } catch (err) {
-        finished = true;
-        done(err);
+          reason += ' with 1 space, not ' + spacing;
+        }
       }
-    }
-  }
-}
-
-/**
- * Convert `promise` to a thunk.
- *
- * @param {Object} promise
- * @return {Function}
- * @api private
- */
 
-function promiseToThunk(promise) {
-  return function(fn){
-    promise.then(function(res) {
-      fn(null, res);
-    }, fn);
-  }
-}
-
-/**
- * Check if `obj` is a promise.
- *
- * @param {Object} obj
- * @return {Boolean}
- * @api private
- */
+      /** @type {Point} */
+      let point;
 
-function isPromise(obj) {
-  return obj && 'function' == typeof obj.then;
-}
+      if (side === 'start') {
+        point = pointStart(cell);
+        if (!column) {
+          point.column++;
 
-/**
- * Check if `obj` is a generator.
- *
- * @param {Mixed} obj
- * @return {Boolean}
- * @api private
- */
+          if (typeof point.offset === 'number') {
+            point.offset++;
+          }
+        }
+      } else {
+        point = pointEnd(cell);
+        point.column--;
 
-function isGenerator(obj) {
-  return obj && 'function' == typeof obj.next && 'function' == typeof obj.throw;
-}
+        if (typeof point.offset === 'number') {
+          point.offset--;
+        }
+      }
 
-/**
- * Check if `obj` is a generator function.
- *
- * @param {Mixed} obj
- * @return {Boolean}
- * @api private
- */
+      file.message(reason, point);
+    }
+  }
+);
 
-function isGeneratorFunction(obj) {
-  return obj && obj.constructor && 'GeneratorFunction' == obj.constructor.name;
-}
+var remarkLintTableCellPadding$1 = remarkLintTableCellPadding;
 
 /**
- * Check for plain object.
- *
- * @param {Mixed} val
- * @return {Boolean}
- * @api private
+ * @param {TableCell} node
+ * @returns {number}
  */
-
-function isObject$3(val) {
-  return val && Object == val.constructor;
+function size(node) {
+  const head = pointStart(node.children[0]).offset;
+  const tail = pointEnd(node.children[node.children.length - 1]).offset;
+  // Only called when we’re sure offsets exist.
+  /* c8 ignore next */
+  return typeof head === 'number' && typeof tail === 'number' ? tail - head : 0
 }
 
 /**
- * Throw `err` in a new stack.
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
  *
- * This is used when co() is invoked
- * without supplying a callback, which
- * should only be for demonstrational
- * purposes.
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
  *
- * @param {Error} err
- * @api private
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
  */
 
-function error(err) {
-  if (!err) return;
-  setImmediate(function(){
-    throw err;
-  });
-}
+const primitives$1 = new Set(['string', 'number', 'boolean']);
 
 /**
- * Module Dependencies
+ * @param {string} id
+ * @param {Rule} rule
  */
+function lintRule$1(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
+  Object.defineProperty(plugin, 'name', {value: id});
 
-var noop$3 = function(){};
-
+  return plugin
 
-/**
- * Export `wrapped`
- */
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce$1(ruleId, raw);
 
-var wrapped_1 = wrapped;
+    if (!severity) return
 
-/**
- * Wrap a function to support
- * sync, async, and gen functions.
- *
- * @param {Function} fn
- * @return {Function}
- * @api public
- */
+    const fatal = severity === 2;
 
-function wrapped(fn) {
-  function wrap() {
-    var args = sliced(arguments);
-    var last = args[args.length - 1];
-    var ctx = this;
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-    // done
-    var done = typeof last == 'function' ? args.pop() : noop$3;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
-    // nothing
-    if (!fn) {
-      return done.apply(ctx, [null].concat(args));
-    }
+        // Add the error, if not already properly added.
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
+          try {
+            file.fail(error);
+          } catch {}
+        }
 
-    // generator
-    if (generator(fn)) {
-      return co_1(fn).apply(ctx, args.concat(done));
-    }
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
+        }
 
-    // async
-    if (fn.length > args.length) {
-      // NOTE: this only handles uncaught synchronous errors
-      try {
-        return fn.apply(ctx, args.concat(done));
-      } catch (e) {
-        return done(e);
-      }
+        next();
+      })(tree, file, options);
     }
-
-    // sync
-    return sync$5(fn, done).apply(ctx, args);
   }
-
-  return wrap;
 }
 
 /**
- * Wrap a synchronous function execution.
+ * Coerce a value to a severity--options tuple.
  *
- * @param {Function} fn
- * @param {Function} done
- * @return {Function}
- * @api private
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
  */
+function coerce$1(name, value) {
+  /** @type {unknown[]} */
+  let result;
 
-function sync$5(fn, done) {
-  return function () {
-    var ret;
+  if (typeof value === 'boolean') {
+    result = [value];
+  } else if (value === null || value === undefined) {
+    result = [1];
+  } else if (
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives$1.has(typeof value[0])
+  ) {
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
+  } else {
+    result = [1, value];
+  }
 
-    try {
-      ret = fn.apply(this, arguments);
-    } catch (err) {
-      return done(err);
-    }
+  let level = result[0];
 
-    if (promise(ret)) {
-      ret.then(function (value) { done(null, value); }, done);
+  if (typeof level === 'boolean') {
+    level = level ? 1 : 0;
+  } else if (typeof level === 'string') {
+    if (level === 'off') {
+      level = 0;
+    } else if (level === 'on' || level === 'warn') {
+      level = 1;
+    } else if (level === 'error') {
+      level = 2;
     } else {
-      ret instanceof Error ? done(ret) : done(null, ret);
+      level = 1;
+      result = [level, result];
     }
   }
+
+  if (typeof level !== 'number' || level < 0 || level > 2) {
+    throw new Error(
+      'Incorrect severity `' +
+        level +
+        '` for `' +
+        name +
+        '`, ' +
+        'expected 0, 1, or 2'
+    )
+  }
+
+  result[0] = level;
+
+  // @ts-expect-error: it’s now a valid tuple.
+  return result
 }
 
 /**
- * Is `value` a generator?
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module table-pipes
+ * @fileoverview
+ *   Warn when table rows are not fenced with pipes.
  *
- * @param {Mixed} value
- * @return {Boolean}
- * @api private
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   creates fenced rows with initial and final pipes by default.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md", "gfm": true}
+ *
+ *   | A     | B     |
+ *   | ----- | ----- |
+ *   | Alpha | Bravo |
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input", "gfm": true}
+ *
+ *   A     | B
+ *   ----- | -----
+ *   Alpha | Bravo
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "gfm": true}
+ *
+ *   1:1: Missing initial pipe in table fence
+ *   1:10: Missing final pipe in table fence
+ *   3:1: Missing initial pipe in table fence
+ *   3:14: Missing final pipe in table fence
  */
 
-function generator(value) {
-  return value
-    && value.constructor
-    && 'GeneratorFunction' == value.constructor.name;
-}
+const reasonStart = 'Missing initial pipe in table fence';
+const reasonEnd = 'Missing final pipe in table fence';
+
+const remarkLintTablePipes = lintRule$1(
+  'remark-lint:table-pipes',
+  /** @type {import('unified-lint-rule').Rule<Root, void>} */
+  (tree, file) => {
+    const value = String(file);
 
+    visit(tree, 'table', (node) => {
+      let index = -1;
+
+      while (++index < node.children.length) {
+        const row = node.children[index];
+        const start = pointStart(row);
+        const end = pointEnd(row);
+
+        if (
+          typeof start.offset === 'number' &&
+          value.charCodeAt(start.offset) !== 124
+        ) {
+          file.message(reasonStart, start);
+        }
+
+        if (
+          typeof end.offset === 'number' &&
+          value.charCodeAt(end.offset - 1) !== 124
+        ) {
+          file.message(reasonEnd, end);
+        }
+      }
+    });
+  }
+);
+
+var remarkLintTablePipes$1 = remarkLintTablePipes;
 
 /**
- * Is `value` a promise?
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
  *
- * @param {Mixed} value
- * @return {Boolean}
- * @api private
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
  */
 
-function promise(value) {
-  return value && 'function' == typeof value.then;
-}
-
-var unifiedLintRule = factory$8;
+const primitives = new Set(['string', 'number', 'boolean']);
 
-function factory$8(id, rule) {
-  var parts = id.split(':');
-  var source = parts[0];
-  var ruleId = parts[1];
-  var fn = wrapped_1(rule);
-
-  /* istanbul ignore if - possibly useful if externalised later. */
-  if (!ruleId) {
-    ruleId = source;
-    source = null;
-  }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule(id, rule) {
+  const parts = id.split(':');
+  // Possibly useful if externalised later.
+  /* c8 ignore next */
+  const source = parts[1] ? parts[0] : undefined;
+  const ruleId = parts[1];
 
-  attacher.displayName = id;
+  Object.defineProperty(plugin, 'name', {value: id});
 
-  return attacher
+  return plugin
 
-  function attacher(raw) {
-    var config = coerce(ruleId, raw);
-    var severity = config[0];
-    var options = config[1];
-    var fatal = severity === 2;
+  /** @type {import('unified').Plugin<[unknown]|void[]>} */
+  function plugin(raw) {
+    const [severity, options] = coerce(ruleId, raw);
 
-    return severity ? transformer : undefined
+    if (!severity) return
 
-    function transformer(tree, file, next) {
-      var index = file.messages.length;
+    const fatal = severity === 2;
 
-      fn(tree, file, options, done);
+    return (tree, file, next) => {
+      let index = file.messages.length - 1;
 
-      function done(err) {
-        var messages = file.messages;
-        var message;
+      wrap(rule, (error) => {
+        const messages = file.messages;
 
         // Add the error, if not already properly added.
-        /* istanbul ignore if - only happens for incorrect plugins */
-        if (err && messages.indexOf(err) === -1) {
+        // Only happens for incorrect plugins.
+        /* c8 ignore next 6 */
+        // @ts-expect-error: errors could be `messages`.
+        if (error && !messages.includes(error)) {
           try {
-            file.fail(err);
-          } catch (_) {}
+            file.fail(error);
+          } catch {}
         }
 
-        while (index < messages.length) {
-          message = messages[index];
-          message.ruleId = ruleId;
-          message.source = source;
-          message.fatal = fatal;
-
-          index++;
+        while (++index < messages.length) {
+          Object.assign(messages[index], {ruleId, source, fatal});
         }
 
         next();
-      }
+      })(tree, file, options);
     }
   }
 }
 
-// Coerce a value to a severity--options tuple.
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
 function coerce(name, value) {
-  var def = 1;
-  var result;
-  var level;
+  /** @type {unknown[]} */
+  let result;
 
-  /* istanbul ignore if - Handled by unified in v6.0.0 */
   if (typeof value === 'boolean') {
     result = [value];
-  } else if (value == null) {
-    result = [def];
+  } else if (value === null || value === undefined) {
+    result = [1];
   } else if (
-    typeof value === 'object' &&
-    (typeof value[0] === 'number' ||
-      typeof value[0] === 'boolean' ||
-      typeof value[0] === 'string')
+    Array.isArray(value) &&
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    primitives.has(typeof value[0])
   ) {
-    result = value.concat();
+    // `isArray(unknown)` is turned into `any[]`:
+    // type-coverage:ignore-next-line
+    result = [...value];
   } else {
     result = [1, value];
   }
 
-  level = result[0];
+  let level = result[0];
 
   if (typeof level === 'boolean') {
     level = level ? 1 : 0;
@@ -44709,7 +57695,7 @@ function coerce(name, value) {
     }
   }
 
-  if (level < 0 || level > 2) {
+  if (typeof level !== 'number' || level < 0 || level > 2) {
     throw new Error(
       'Incorrect severity `' +
         level +
@@ -44722,2558 +57708,3541 @@ function coerce(name, value) {
 
   result[0] = level;
 
+  // @ts-expect-error: it’s now a valid tuple.
   return result
 }
 
-var remarkLintFinalNewline = unifiedLintRule('remark-lint:final-newline', finalNewline);
-
-function finalNewline(tree, file) {
-  var contents = String(file);
-  var last = contents.length - 1;
-
-  if (last > -1 && contents.charAt(last) !== '\n') {
-    file.message('Missing newline character at end of file');
-  }
-}
-
-var pluralize = createCommonjsModule(function (module, exports) {
-/* global define */
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module unordered-list-marker-style
+ * @fileoverview
+ *   Warn when the list item marker style of unordered lists violate a given
+ *   style.
+ *
+ *   Options: `'consistent'`, `'-'`, `'*'`, or `'+'`, default: `'consistent'`.
+ *
+ *   `'consistent'` detects the first used list style and warns when subsequent
+ *   lists use different styles.
+ *
+ *   ## Fix
+ *
+ *   [`remark-stringify`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify)
+ *   formats unordered lists using `-` (hyphen-minus) by default.
+ *   Pass
+ *   [`bullet: '*'` or `bullet: '+'`](https://github.com/remarkjs/remark/tree/HEAD/packages/remark-stringify#optionsbullet)
+ *   to use `*` (asterisk) or `+` (plus sign) instead.
+ *
+ *   See [Using remark to fix your Markdown](https://github.com/remarkjs/remark-lint#using-remark-to-fix-your-markdown)
+ *   on how to automatically fix warnings for this rule.
+ *
+ * @example
+ *   {"name": "ok.md"}
+ *
+ *   By default (`'consistent'`), if the file uses only one marker,
+ *   that’s OK.
+ *
+ *   * Foo
+ *   * Bar
+ *   * Baz
+ *
+ *   Ordered lists are not affected.
+ *
+ *   1. Foo
+ *   2. Bar
+ *   3. Baz
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "*"}
+ *
+ *   * Foo
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "-"}
+ *
+ *   - Foo
+ *
+ * @example
+ *   {"name": "ok.md", "setting": "+"}
+ *
+ *   + Foo
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "input"}
+ *
+ *   * Foo
+ *   - Bar
+ *   + Baz
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output"}
+ *
+ *   2:1-2:6: Marker style should be `*`
+ *   3:1-3:6: Marker style should be `*`
+ *
+ * @example
+ *   {"name": "not-ok.md", "label": "output", "setting": "💩", "positionless": true}
+ *
+ *   1:1: Incorrect unordered list item marker style `💩`: use either `'-'`, `'*'`, or `'+'`
+ */
 
-(function (root, pluralize) {
-  /* istanbul ignore else */
-  if (typeof commonjsRequire === 'function' && 'object' === 'object' && 'object' === 'object') {
-    // Node.
-    module.exports = pluralize();
-  } else {
-    // Browser global.
-    root.pluralize = pluralize();
-  }
-})(commonjsGlobal, function () {
-  // Rule storage - pluralize and singularize need to be run sequentially,
-  // while other rules can be optimized using an object for instant lookups.
-  var pluralRules = [];
-  var singularRules = [];
-  var uncountables = {};
-  var irregularPlurals = {};
-  var irregularSingles = {};
+const markers = new Set(['-', '*', '+']);
 
-  /**
-   * Sanitize a pluralization rule to a usable regular expression.
-   *
-   * @param  {(RegExp|string)} rule
-   * @return {RegExp}
-   */
-  function sanitizeRule (rule) {
-    if (typeof rule === 'string') {
-      return new RegExp('^' + rule + '$', 'i');
+const remarkLintUnorderedListMarkerStyle = lintRule(
+  'remark-lint:unordered-list-marker-style',
+  /** @type {import('unified-lint-rule').Rule<Root, Options>} */
+  (tree, file, option = 'consistent') => {
+    const value = String(file);
+
+    if (option !== 'consistent' && !markers.has(option)) {
+      file.fail(
+        'Incorrect unordered list item marker style `' +
+          option +
+          "`: use either `'-'`, `'*'`, or `'+'`"
+      );
     }
 
-    return rule;
-  }
-
-  /**
-   * Pass in a word token to produce a function that can replicate the case on
-   * another word.
-   *
-   * @param  {string}   word
-   * @param  {string}   token
-   * @return {Function}
-   */
-  function restoreCase (word, token) {
-    // Tokens are an exact match.
-    if (word === token) return token;
-
-    // Lower cased words. E.g. "hello".
-    if (word === word.toLowerCase()) return token.toLowerCase();
+    visit(tree, 'list', (node) => {
+      if (node.ordered) return
 
-    // Upper cased words. E.g. "WHISKY".
-    if (word === word.toUpperCase()) return token.toUpperCase();
+      let index = -1;
 
-    // Title cased words. E.g. "Title".
-    if (word[0] === word[0].toUpperCase()) {
-      return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
-    }
+      while (++index < node.children.length) {
+        const child = node.children[index];
 
-    // Lower cased words. E.g. "test".
-    return token.toLowerCase();
-  }
+        if (!generated(child)) {
+          const marker = /** @type {Marker} */ (
+            value
+              .slice(
+                pointStart(child).offset,
+                pointStart(child.children[0]).offset
+              )
+              .replace(/\[[x ]?]\s*$/i, '')
+              .replace(/\s/g, '')
+          );
 
-  /**
-   * Interpolate a regexp string.
-   *
-   * @param  {string} str
-   * @param  {Array}  args
-   * @return {string}
-   */
-  function interpolate (str, args) {
-    return str.replace(/\$(\d{1,2})/g, function (match, index) {
-      return args[index] || '';
+          if (option === 'consistent') {
+            option = marker;
+          } else if (marker !== option) {
+            file.message('Marker style should be `' + option + '`', child);
+          }
+        }
+      }
     });
   }
+);
 
-  /**
-   * Replace a word using a rule.
-   *
-   * @param  {string} word
-   * @param  {Array}  rule
-   * @return {string}
-   */
-  function replace (word, rule) {
-    return word.replace(rule[0], function (match, index) {
-      var result = interpolate(rule[1], arguments);
+var remarkLintUnorderedListMarkerStyle$1 = remarkLintUnorderedListMarkerStyle;
 
-      if (match === '') {
-        return restoreCase(word[index - 1], result);
-      }
+// @see https://github.com/nodejs/node/blob/HEAD/doc/guides/doc-style-guide.md
 
-      return restoreCase(match, result);
-    });
-  }
+// Add in rules alphabetically
+const plugins = [
+  // Leave preset at the top so it can be overridden
+  remarkPresetLintRecommended$1,
+  [remarkLintBlockquoteIndentation$1, 2],
+  [remarkLintCheckboxCharacterStyle$1, { checked: "x", unchecked: " " }],
+  remarkLintCheckboxContentIndent$1,
+  [remarkLintCodeBlockStyle$1, "fenced"],
+  remarkLintDefinitionSpacing$1,
+  [
+    remarkLintFencedCodeFlag$1,
+    {
+      flags: [
+        "bash",
+        "c",
+        "cjs",
+        "coffee",
+        "console",
+        "cpp",
+        "diff",
+        "http",
+        "js",
+        "json",
+        "markdown",
+        "mjs",
+        "powershell",
+        "r",
+        "text",
+      ],
+    },
+  ],
+  [remarkLintFencedCodeMarker$1, "`"],
+  [remarkLintFileExtension$1, "md"],
+  remarkLintFinalDefinition$1,
+  [remarkLintFirstHeadingLevel$1, 1],
+  [remarkLintHeadingStyle$1, "atx"],
+  [remarkLintListItemIndent$1, "space"],
+  remarkLintMaximumLineLength$1,
+  remarkLintNoConsecutiveBlankLines$1,
+  remarkLintNoFileNameArticles$1,
+  remarkLintNoFileNameConsecutiveDashes$1,
+  remarkLintNofileNameOuterDashes$1,
+  remarkLintNoHeadingIndent$1,
+  remarkLintNoMultipleToplevelHeadings$1,
+  remarkLintNoShellDollars$1,
+  remarkLintNoTableIndentation$1,
+  remarkLintNoTabs$1,
+  remarkLintNoTrailingSpaces,
+  remarkLintNodejsLinks,
+  remarkLintNodejsYamlComments,
+  [
+    remarkLintProhibitedStrings,
+    [
+      { yes: "End-of-Life" },
+      { yes: "GitHub" },
+      { no: "hostname", yes: "host name" },
+      { yes: "JavaScript" },
+      { no: "[Ll]ong[ -][Tt]erm [Ss]upport", yes: "Long Term Support" },
+      { no: "Node", yes: "Node.js", ignoreNextTo: "-API" },
+      { yes: "Node.js" },
+      { no: "Node[Jj][Ss]", yes: "Node.js" },
+      { no: "Node\\.js's?", yes: "the Node.js" },
+      { no: "[Nn]ote that", yes: "<nothing>" },
+      { yes: "RFC" },
+      { no: "[Rr][Ff][Cc]\\d+", yes: "RFC <number>" },
+      { yes: "Unix" },
+      { yes: "V8" },
+    ],
+  ],
+  remarkLintRuleStyle$1,
+  [remarkLintStrongMarker$1, "*"],
+  [remarkLintTableCellPadding$1, "padded"],
+  remarkLintTablePipes$1,
+  [remarkLintUnorderedListMarkerStyle$1, "*"],
+];
 
-  /**
-   * Sanitize a word by passing in the word and sanitization rules.
-   *
-   * @param  {string}   token
-   * @param  {string}   word
-   * @param  {Array}    rules
-   * @return {string}
-   */
-  function sanitizeWord (token, word, rules) {
-    // Empty string or doesn't need fixing.
-    if (!token.length || uncountables.hasOwnProperty(token)) {
-      return word;
-    }
+const remarkPresetLintNode = { plugins };
+
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Previous} Previous
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+const www = {
+  tokenize: tokenizeWww,
+  partial: true
+};
+const domain = {
+  tokenize: tokenizeDomain,
+  partial: true
+};
+const path = {
+  tokenize: tokenizePath,
+  partial: true
+};
+const punctuation = {
+  tokenize: tokenizePunctuation,
+  partial: true
+};
+const namedCharacterReference = {
+  tokenize: tokenizeNamedCharacterReference,
+  partial: true
+};
+const wwwAutolink = {
+  tokenize: tokenizeWwwAutolink,
+  previous: previousWww
+};
+const httpAutolink = {
+  tokenize: tokenizeHttpAutolink,
+  previous: previousHttp
+};
+const emailAutolink = {
+  tokenize: tokenizeEmailAutolink,
+  previous: previousEmail
+};
+/** @type {ConstructRecord} */
 
-    var len = rules.length;
+const text = {};
+/** @type {Extension} */
 
-    // Iterate over the sanitization rules and use the first one to match.
-    while (len--) {
-      var rule = rules[len];
+const gfmAutolinkLiteral = {
+  text
+};
+let code = 48; // Add alphanumerics.
 
-      if (rule[0].test(word)) return replace(word, rule);
-    }
+while (code < 123) {
+  text[code] = emailAutolink;
+  code++;
+  if (code === 58) code = 65;
+  else if (code === 91) code = 97;
+}
 
-    return word;
-  }
+text[43] = emailAutolink;
+text[45] = emailAutolink;
+text[46] = emailAutolink;
+text[95] = emailAutolink;
+text[72] = [emailAutolink, httpAutolink];
+text[104] = [emailAutolink, httpAutolink];
+text[87] = [emailAutolink, wwwAutolink];
+text[119] = [emailAutolink, wwwAutolink];
+/** @type {Tokenizer} */
 
-  /**
-   * Replace a word with the updated word.
-   *
-   * @param  {Object}   replaceMap
-   * @param  {Object}   keepMap
-   * @param  {Array}    rules
-   * @return {Function}
-   */
-  function replaceWord (replaceMap, keepMap, rules) {
-    return function (word) {
-      // Get the correct token and case restoration functions.
-      var token = word.toLowerCase();
+function tokenizeEmailAutolink(effects, ok, nok) {
+  const self = this;
+  /** @type {boolean} */
 
-      // Check against the keep object map.
-      if (keepMap.hasOwnProperty(token)) {
-        return restoreCase(word, token);
-      }
+  let hasDot;
+  /** @type {boolean|undefined} */
 
-      // Check against the replacement map for a direct word replacement.
-      if (replaceMap.hasOwnProperty(token)) {
-        return restoreCase(word, replaceMap[token]);
-      }
+  let hasDigitInLastSegment;
+  return start
+  /** @type {State} */
 
-      // Run all the rules against the word.
-      return sanitizeWord(token, word, rules);
-    };
+  function start(code) {
+    if (
+      !gfmAtext(code) ||
+      !previousEmail(self.previous) ||
+      previousUnbalanced(self.events)
+    ) {
+      return nok(code)
+    }
+
+    effects.enter('literalAutolink');
+    effects.enter('literalAutolinkEmail');
+    return atext(code)
   }
+  /** @type {State} */
 
-  /**
-   * Check if a word is part of the map.
-   */
-  function checkWord (replaceMap, keepMap, rules, bool) {
-    return function (word) {
-      var token = word.toLowerCase();
+  function atext(code) {
+    if (gfmAtext(code)) {
+      effects.consume(code);
+      return atext
+    }
 
-      if (keepMap.hasOwnProperty(token)) return true;
-      if (replaceMap.hasOwnProperty(token)) return false;
+    if (code === 64) {
+      effects.consume(code);
+      return label
+    }
 
-      return sanitizeWord(token, token, rules) === token;
-    };
+    return nok(code)
   }
+  /** @type {State} */
 
-  /**
-   * Pluralize or singularize a word based on the passed in count.
-   *
-   * @param  {string}  word      The word to pluralize
-   * @param  {number}  count     How many of the word exist
-   * @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
-   * @return {string}
-   */
-  function pluralize (word, count, inclusive) {
-    var pluralized = count === 1
-      ? pluralize.singular(word) : pluralize.plural(word);
-
-    return (inclusive ? count + ' ' : '') + pluralized;
-  }
+  function label(code) {
+    if (code === 46) {
+      return effects.check(punctuation, done, dotContinuation)(code)
+    }
 
-  /**
-   * Pluralize a word.
-   *
-   * @type {Function}
-   */
-  pluralize.plural = replaceWord(
-    irregularSingles, irregularPlurals, pluralRules
-  );
+    if (code === 45 || code === 95) {
+      return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code)
+    }
 
-  /**
-   * Check if a word is plural.
-   *
-   * @type {Function}
-   */
-  pluralize.isPlural = checkWord(
-    irregularSingles, irregularPlurals, pluralRules
-  );
+    if (asciiAlphanumeric(code)) {
+      if (!hasDigitInLastSegment && asciiDigit(code)) {
+        hasDigitInLastSegment = true;
+      }
 
-  /**
-   * Singularize a word.
-   *
-   * @type {Function}
-   */
-  pluralize.singular = replaceWord(
-    irregularPlurals, irregularSingles, singularRules
-  );
+      effects.consume(code);
+      return label
+    }
 
-  /**
-   * Check if a word is singular.
-   *
-   * @type {Function}
-   */
-  pluralize.isSingular = checkWord(
-    irregularPlurals, irregularSingles, singularRules
-  );
+    return done(code)
+  }
+  /** @type {State} */
 
-  /**
-   * Add a pluralization rule to the collection.
-   *
-   * @param {(string|RegExp)} rule
-   * @param {string}          replacement
-   */
-  pluralize.addPluralRule = function (rule, replacement) {
-    pluralRules.push([sanitizeRule(rule), replacement]);
-  };
+  function dotContinuation(code) {
+    effects.consume(code);
+    hasDot = true;
+    hasDigitInLastSegment = undefined;
+    return label
+  }
+  /** @type {State} */
 
-  /**
-   * Add a singularization rule to the collection.
-   *
-   * @param {(string|RegExp)} rule
-   * @param {string}          replacement
-   */
-  pluralize.addSingularRule = function (rule, replacement) {
-    singularRules.push([sanitizeRule(rule), replacement]);
-  };
+  function dashOrUnderscoreContinuation(code) {
+    effects.consume(code);
+    return afterDashOrUnderscore
+  }
+  /** @type {State} */
 
-  /**
-   * Add an uncountable word rule.
-   *
-   * @param {(string|RegExp)} word
-   */
-  pluralize.addUncountableRule = function (word) {
-    if (typeof word === 'string') {
-      uncountables[word.toLowerCase()] = true;
-      return;
+  function afterDashOrUnderscore(code) {
+    if (code === 46) {
+      return effects.check(punctuation, nok, dotContinuation)(code)
     }
 
-    // Set singular and plural references for the word.
-    pluralize.addPluralRule(word, '$0');
-    pluralize.addSingularRule(word, '$0');
-  };
+    return label(code)
+  }
+  /** @type {State} */
 
-  /**
-   * Add an irregular word definition.
-   *
-   * @param {string} single
-   * @param {string} plural
-   */
-  pluralize.addIrregularRule = function (single, plural) {
-    plural = plural.toLowerCase();
-    single = single.toLowerCase();
+  function done(code) {
+    if (hasDot && !hasDigitInLastSegment) {
+      effects.exit('literalAutolinkEmail');
+      effects.exit('literalAutolink');
+      return ok(code)
+    }
 
-    irregularSingles[single] = plural;
-    irregularPlurals[plural] = single;
-  };
+    return nok(code)
+  }
+}
+/** @type {Tokenizer} */
 
-  /**
-   * Irregular rules.
-   */
-  [
-    // Pronouns.
-    ['I', 'we'],
-    ['me', 'us'],
-    ['he', 'they'],
-    ['she', 'they'],
-    ['them', 'them'],
-    ['myself', 'ourselves'],
-    ['yourself', 'yourselves'],
-    ['itself', 'themselves'],
-    ['herself', 'themselves'],
-    ['himself', 'themselves'],
-    ['themself', 'themselves'],
-    ['is', 'are'],
-    ['was', 'were'],
-    ['has', 'have'],
-    ['this', 'these'],
-    ['that', 'those'],
-    // Words ending in with a consonant and `o`.
-    ['echo', 'echoes'],
-    ['dingo', 'dingoes'],
-    ['volcano', 'volcanoes'],
-    ['tornado', 'tornadoes'],
-    ['torpedo', 'torpedoes'],
-    // Ends with `us`.
-    ['genus', 'genera'],
-    ['viscus', 'viscera'],
-    // Ends with `ma`.
-    ['stigma', 'stigmata'],
-    ['stoma', 'stomata'],
-    ['dogma', 'dogmata'],
-    ['lemma', 'lemmata'],
-    ['schema', 'schemata'],
-    ['anathema', 'anathemata'],
-    // Other irregular rules.
-    ['ox', 'oxen'],
-    ['axe', 'axes'],
-    ['die', 'dice'],
-    ['yes', 'yeses'],
-    ['foot', 'feet'],
-    ['eave', 'eaves'],
-    ['goose', 'geese'],
-    ['tooth', 'teeth'],
-    ['quiz', 'quizzes'],
-    ['human', 'humans'],
-    ['proof', 'proofs'],
-    ['carve', 'carves'],
-    ['valve', 'valves'],
-    ['looey', 'looies'],
-    ['thief', 'thieves'],
-    ['groove', 'grooves'],
-    ['pickaxe', 'pickaxes'],
-    ['passerby', 'passersby']
-  ].forEach(function (rule) {
-    return pluralize.addIrregularRule(rule[0], rule[1]);
-  });
+function tokenizeWwwAutolink(effects, ok, nok) {
+  const self = this;
+  return start
+  /** @type {State} */
 
-  /**
-   * Pluralization rules.
-   */
-  [
-    [/s?$/i, 's'],
-    [/[^\u0000-\u007F]$/i, '$0'],
-    [/([^aeiou]ese)$/i, '$1'],
-    [/(ax|test)is$/i, '$1es'],
-    [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, '$1es'],
-    [/(e[mn]u)s?$/i, '$1s'],
-    [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, '$1'],
-    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1i'],
-    [/(alumn|alg|vertebr)(?:a|ae)$/i, '$1ae'],
-    [/(seraph|cherub)(?:im)?$/i, '$1im'],
-    [/(her|at|gr)o$/i, '$1oes'],
-    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, '$1a'],
-    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, '$1a'],
-    [/sis$/i, 'ses'],
-    [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, '$1$2ves'],
-    [/([^aeiouy]|qu)y$/i, '$1ies'],
-    [/([^ch][ieo][ln])ey$/i, '$1ies'],
-    [/(x|ch|ss|sh|zz)$/i, '$1es'],
-    [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, '$1ices'],
-    [/\b((?:tit)?m|l)(?:ice|ouse)$/i, '$1ice'],
-    [/(pe)(?:rson|ople)$/i, '$1ople'],
-    [/(child)(?:ren)?$/i, '$1ren'],
-    [/eaux$/i, '$0'],
-    [/m[ae]n$/i, 'men'],
-    ['thou', 'you']
-  ].forEach(function (rule) {
-    return pluralize.addPluralRule(rule[0], rule[1]);
-  });
+  function start(code) {
+    if (
+      (code !== 87 && code !== 119) ||
+      !previousWww(self.previous) ||
+      previousUnbalanced(self.events)
+    ) {
+      return nok(code)
+    }
 
-  /**
-   * Singularization rules.
-   */
-  [
-    [/s$/i, ''],
-    [/(ss)$/i, '$1'],
-    [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, '$1fe'],
-    [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, '$1f'],
-    [/ies$/i, 'y'],
-    [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, '$1ie'],
-    [/\b(mon|smil)ies$/i, '$1ey'],
-    [/\b((?:tit)?m|l)ice$/i, '$1ouse'],
-    [/(seraph|cherub)im$/i, '$1'],
-    [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, '$1'],
-    [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, '$1sis'],
-    [/(movie|twelve|abuse|e[mn]u)s$/i, '$1'],
-    [/(test)(?:is|es)$/i, '$1is'],
-    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1us'],
-    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, '$1um'],
-    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, '$1on'],
-    [/(alumn|alg|vertebr)ae$/i, '$1a'],
-    [/(cod|mur|sil|vert|ind)ices$/i, '$1ex'],
-    [/(matr|append)ices$/i, '$1ix'],
-    [/(pe)(rson|ople)$/i, '$1rson'],
-    [/(child)ren$/i, '$1'],
-    [/(eau)x?$/i, '$1'],
-    [/men$/i, 'man']
-  ].forEach(function (rule) {
-    return pluralize.addSingularRule(rule[0], rule[1]);
-  });
+    effects.enter('literalAutolink');
+    effects.enter('literalAutolinkWww'); // For `www.` we check instead of attempt, because when it matches, GH
+    // treats it as part of a domain (yes, it says a valid domain must come
+    // after `www.`, but that’s not how it’s implemented by them).
 
-  /**
-   * Uncountable rules.
-   */
-  [
-    // Singular words with no plurals.
-    'adulthood',
-    'advice',
-    'agenda',
-    'aid',
-    'aircraft',
-    'alcohol',
-    'ammo',
-    'analytics',
-    'anime',
-    'athletics',
-    'audio',
-    'bison',
-    'blood',
-    'bream',
-    'buffalo',
-    'butter',
-    'carp',
-    'cash',
-    'chassis',
-    'chess',
-    'clothing',
-    'cod',
-    'commerce',
-    'cooperation',
-    'corps',
-    'debris',
-    'diabetes',
-    'digestion',
-    'elk',
-    'energy',
-    'equipment',
-    'excretion',
-    'expertise',
-    'firmware',
-    'flounder',
-    'fun',
-    'gallows',
-    'garbage',
-    'graffiti',
-    'hardware',
-    'headquarters',
-    'health',
-    'herpes',
-    'highjinks',
-    'homework',
-    'housework',
-    'information',
-    'jeans',
-    'justice',
-    'kudos',
-    'labour',
-    'literature',
-    'machinery',
-    'mackerel',
-    'mail',
-    'media',
-    'mews',
-    'moose',
-    'music',
-    'mud',
-    'manga',
-    'news',
-    'only',
-    'personnel',
-    'pike',
-    'plankton',
-    'pliers',
-    'police',
-    'pollution',
-    'premises',
-    'rain',
-    'research',
-    'rice',
-    'salmon',
-    'scissors',
-    'series',
-    'sewage',
-    'shambles',
-    'shrimp',
-    'software',
-    'species',
-    'staff',
-    'swine',
-    'tennis',
-    'traffic',
-    'transportation',
-    'trout',
-    'tuna',
-    'wealth',
-    'welfare',
-    'whiting',
-    'wildebeest',
-    'wildlife',
-    'you',
-    /pok[eé]mon$/i,
-    // Regexes.
-    /[^aeiou]ese$/i, // "chinese", "japanese"
-    /deer$/i, // "deer", "reindeer"
-    /fish$/i, // "fish", "blowfish", "angelfish"
-    /measles$/i,
-    /o[iu]s$/i, // "carnivorous"
-    /pox$/i, // "chickpox", "smallpox"
-    /sheep$/i
-  ].forEach(pluralize.addUncountableRule);
+    return effects.check(
+      www,
+      effects.attempt(domain, effects.attempt(path, done), nok),
+      nok
+    )(code)
+  }
+  /** @type {State} */
 
-  return pluralize;
-});
-});
+  function done(code) {
+    effects.exit('literalAutolinkWww');
+    effects.exit('literalAutolink');
+    return ok(code)
+  }
+}
+/** @type {Tokenizer} */
 
-var start$1 = factory$9('start');
-var end = factory$9('end');
+function tokenizeHttpAutolink(effects, ok, nok) {
+  const self = this;
+  return start
+  /** @type {State} */
 
-var unistUtilPosition = position$1;
+  function start(code) {
+    if (
+      (code !== 72 && code !== 104) ||
+      !previousHttp(self.previous) ||
+      previousUnbalanced(self.events)
+    ) {
+      return nok(code)
+    }
 
-position$1.start = start$1;
-position$1.end = end;
+    effects.enter('literalAutolink');
+    effects.enter('literalAutolinkHttp');
+    effects.consume(code);
+    return t1
+  }
+  /** @type {State} */
 
-function position$1(node) {
-  return {start: start$1(node), end: end(node)}
-}
+  function t1(code) {
+    if (code === 84 || code === 116) {
+      effects.consume(code);
+      return t2
+    }
 
-function factory$9(type) {
-  point.displayName = type;
+    return nok(code)
+  }
+  /** @type {State} */
 
-  return point
+  function t2(code) {
+    if (code === 84 || code === 116) {
+      effects.consume(code);
+      return p
+    }
 
-  function point(node) {
-    var point = (node && node.position && node.position[type]) || {};
+    return nok(code)
+  }
+  /** @type {State} */
 
-    return {
-      line: point.line || null,
-      column: point.column || null,
-      offset: isNaN(point.offset) ? null : point.offset
+  function p(code) {
+    if (code === 80 || code === 112) {
+      effects.consume(code);
+      return s
     }
+
+    return nok(code)
   }
-}
+  /** @type {State} */
 
-var unistUtilGenerated = generated;
+  function s(code) {
+    if (code === 83 || code === 115) {
+      effects.consume(code);
+      return colon
+    }
 
-function generated(node) {
-  var position = optional(optional(node).position);
-  var start = optional(position.start);
-  var end = optional(position.end);
+    return colon(code)
+  }
+  /** @type {State} */
 
-  return !start.line || !start.column || !end.line || !end.column
-}
+  function colon(code) {
+    if (code === 58) {
+      effects.consume(code);
+      return slash1
+    }
 
-function optional(value) {
-  return value && typeof value === 'object' ? value : {}
-}
+    return nok(code)
+  }
+  /** @type {State} */
 
-var remarkLintListItemBulletIndent = unifiedLintRule(
-  'remark-lint:list-item-bullet-indent',
-  listItemBulletIndent
-);
+  function slash1(code) {
+    if (code === 47) {
+      effects.consume(code);
+      return slash2
+    }
 
-var start$2 = unistUtilPosition.start;
+    return nok(code)
+  }
+  /** @type {State} */
 
-function listItemBulletIndent(tree, file) {
-  var contents = String(file);
+  function slash2(code) {
+    if (code === 47) {
+      effects.consume(code);
+      return after
+    }
 
-  unistUtilVisit(tree, 'list', visitor);
+    return nok(code)
+  }
+  /** @type {State} */
 
-  function visitor(node) {
-    node.children.forEach(visitItems);
+  function after(code) {
+    return code === null ||
+      asciiControl(code) ||
+      unicodeWhitespace(code) ||
+      unicodePunctuation(code)
+      ? nok(code)
+      : effects.attempt(domain, effects.attempt(path, done), nok)(code)
   }
+  /** @type {State} */
 
-  function visitItems(item) {
-    var final;
-    var indent;
-    var reason;
+  function done(code) {
+    effects.exit('literalAutolinkHttp');
+    effects.exit('literalAutolink');
+    return ok(code)
+  }
+}
+/** @type {Tokenizer} */
 
-    if (!unistUtilGenerated(item)) {
-      final = start$2(item.children[0]);
-      indent = contents.slice(start$2(item).offset, final.offset).match(/^\s*/)[0]
-        .length;
+function tokenizeWww(effects, ok, nok) {
+  return start
+  /** @type {State} */
 
-      if (indent !== 0) {
-        reason =
-          'Incorrect indentation before bullet: remove ' +
-          indent +
-          ' ' +
-          pluralize('space', indent);
+  function start(code) {
+    effects.consume(code);
+    return w2
+  }
+  /** @type {State} */
 
-        file.message(reason, {
-          line: final.line,
-          column: final.column - indent
-        });
-      }
+  function w2(code) {
+    if (code === 87 || code === 119) {
+      effects.consume(code);
+      return w3
     }
+
+    return nok(code)
   }
-}
+  /** @type {State} */
 
-var remarkLintListItemIndent = unifiedLintRule('remark-lint:list-item-indent', listItemIndent);
+  function w3(code) {
+    if (code === 87 || code === 119) {
+      effects.consume(code);
+      return dot
+    }
 
-var start$3 = unistUtilPosition.start;
+    return nok(code)
+  }
+  /** @type {State} */
 
-var styles$1 = {'tab-size': true, mixed: true, space: true};
+  function dot(code) {
+    if (code === 46) {
+      effects.consume(code);
+      return after
+    }
 
-function listItemIndent(tree, file, option) {
-  var contents = String(file);
-  var preferred = typeof option === 'string' ? option : 'tab-size';
+    return nok(code)
+  }
+  /** @type {State} */
 
-  if (styles$1[preferred] !== true) {
-    file.fail(
-      'Incorrect list-item indent style `' +
-        preferred +
-        "`: use either `'tab-size'`, `'space'`, or `'mixed'`"
-    );
+  function after(code) {
+    return code === null || markdownLineEnding(code) ? nok(code) : ok(code)
   }
+}
+/** @type {Tokenizer} */
 
-  unistUtilVisit(tree, 'list', visitor);
+function tokenizeDomain(effects, ok, nok) {
+  /** @type {boolean|undefined} */
+  let hasUnderscoreInLastSegment;
+  /** @type {boolean|undefined} */
 
-  function visitor(node) {
-    var spread = node.spread || node.loose;
+  let hasUnderscoreInLastLastSegment;
+  return domain
+  /** @type {State} */
 
-    if (!unistUtilGenerated(node)) {
-      node.children.forEach(visitItem);
+  function domain(code) {
+    if (code === 38) {
+      return effects.check(
+        namedCharacterReference,
+        done,
+        punctuationContinuation
+      )(code)
     }
 
-    function visitItem(item) {
-      var head = item.children[0];
-      var final = start$3(head);
-      var marker;
-      var bulletSize;
-      var style;
-      var diff;
-      var reason;
-      var abs;
-
-      marker = contents
-        .slice(start$3(item).offset, final.offset)
-        .replace(/\[[x ]?]\s*$/i, '');
+    if (code === 46 || code === 95) {
+      return effects.check(punctuation, done, punctuationContinuation)(code)
+    } // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can
+    // occur, which sounds like ASCII only, but they also support `www.點看.com`,
+    // so that’s Unicode.
+    // Instead of some new production for Unicode alphanumerics, markdown
+    // already has that for Unicode punctuation and whitespace, so use those.
 
-      bulletSize = marker.replace(/\s+$/, '').length;
+    if (
+      code === null ||
+      asciiControl(code) ||
+      unicodeWhitespace(code) ||
+      (code !== 45 && unicodePunctuation(code))
+    ) {
+      return done(code)
+    }
 
-      style =
-        preferred === 'tab-size' || (preferred === 'mixed' && spread)
-          ? Math.ceil(bulletSize / 4) * 4
-          : bulletSize + 1;
+    effects.consume(code);
+    return domain
+  }
+  /** @type {State} */
 
-      if (marker.length !== style) {
-        diff = style - marker.length;
-        abs = Math.abs(diff);
+  function punctuationContinuation(code) {
+    if (code === 46) {
+      hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment;
+      hasUnderscoreInLastSegment = undefined;
+      effects.consume(code);
+      return domain
+    }
 
-        reason =
-          'Incorrect list-item indent: ' +
-          (diff > 0 ? 'add' : 'remove') +
-          ' ' +
-          abs +
-          ' ' +
-          pluralize('space', abs);
+    if (code === 95) hasUnderscoreInLastSegment = true;
+    effects.consume(code);
+    return domain
+  }
+  /** @type {State} */
 
-        file.message(reason, final);
-      }
+  function done(code) {
+    if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {
+      return ok(code)
     }
+
+    return nok(code)
   }
 }
+/** @type {Tokenizer} */
 
-var mdastUtilToString = toString$3;
-
-// Get the text content of a node.
-// Prefer the node’s plain-text fields, otherwise serialize its children,
-// and if the given value is an array, serialize the nodes in it.
-function toString$3(node) {
-  return (
-    (node &&
-      (node.value ||
-        node.alt ||
-        node.title ||
-        ('children' in node && all$1(node.children)) ||
-        ('length' in node && all$1(node)))) ||
-    ''
-  )
-}
+function tokenizePath(effects, ok) {
+  let balance = 0;
+  return inPath
+  /** @type {State} */
 
-function all$1(values) {
-  var result = [];
-  var length = values.length;
-  var index = -1;
+  function inPath(code) {
+    if (code === 38) {
+      return effects.check(
+        namedCharacterReference,
+        ok,
+        continuedPunctuation
+      )(code)
+    }
 
-  while (++index < length) {
-    result[index] = toString$3(values[index]);
-  }
+    if (code === 40) {
+      balance++;
+    }
 
-  return result.join('')
-}
+    if (code === 41) {
+      return effects.check(
+        punctuation,
+        parenAtPathEnd,
+        continuedPunctuation
+      )(code)
+    }
 
-var remarkLintNoAutoLinkWithoutProtocol = unifiedLintRule(
-  'remark-lint:no-auto-link-without-protocol',
-  noAutoLinkWithoutProtocol
-);
+    if (pathEnd(code)) {
+      return ok(code)
+    }
 
-var start$4 = unistUtilPosition.start;
-var end$1 = unistUtilPosition.end;
+    if (trailingPunctuation(code)) {
+      return effects.check(punctuation, ok, continuedPunctuation)(code)
+    }
 
-// Protocol expression.
-// See: <https://en.wikipedia.org/wiki/URI_scheme#Generic_syntax>.
-var protocol$2 = /^[a-z][a-z+.-]+:\/?/i;
+    effects.consume(code);
+    return inPath
+  }
+  /** @type {State} */
 
-var reason = 'All automatic links must start with a protocol';
+  function continuedPunctuation(code) {
+    effects.consume(code);
+    return inPath
+  }
+  /** @type {State} */
 
-function noAutoLinkWithoutProtocol(tree, file) {
-  unistUtilVisit(tree, 'link', visitor);
+  function parenAtPathEnd(code) {
+    balance--;
+    return balance < 0 ? ok(code) : continuedPunctuation(code)
+  }
+}
+/** @type {Tokenizer} */
 
-  function visitor(node) {
-    var children;
+function tokenizeNamedCharacterReference(effects, ok, nok) {
+  return start
+  /** @type {State} */
 
-    if (!unistUtilGenerated(node)) {
-      children = node.children;
+  function start(code) {
+    effects.consume(code);
+    return inside
+  }
+  /** @type {State} */
 
-      if (
-        start$4(node).column === start$4(children[0]).column - 1 &&
-        end$1(node).column === end$1(children[children.length - 1]).column + 1 &&
-        !protocol$2.test(mdastUtilToString(node))
-      ) {
-        file.message(reason, node);
-      }
+  function inside(code) {
+    if (asciiAlpha(code)) {
+      effects.consume(code);
+      return inside
     }
-  }
-}
 
-var remarkLintNoBlockquoteWithoutMarker = unifiedLintRule(
-  'remark-lint:no-blockquote-without-marker',
-  noBlockquoteWithoutMarker
-);
+    if (code === 59) {
+      effects.consume(code);
+      return after
+    }
 
-var reason$1 = 'Missing marker in block quote';
+    return nok(code)
+  }
+  /** @type {State} */
 
-function noBlockquoteWithoutMarker(tree, file) {
-  var contents = String(file);
-  var location = vfileLocation(file);
-  var last = contents.length;
+  function after(code) {
+    // If the named character reference is followed by the end of the path, it’s
+    // not continued punctuation.
+    return pathEnd(code) ? ok(code) : nok(code)
+  }
+}
+/** @type {Tokenizer} */
 
-  unistUtilVisit(tree, 'blockquote', visitor);
+function tokenizePunctuation(effects, ok, nok) {
+  return start
+  /** @type {State} */
 
-  function visitor(node) {
-    var indent = node.position && node.position.indent;
-    var start;
-    var length;
-    var index;
-    var line;
-    var offset;
-    var character;
-    var pos;
+  function start(code) {
+    effects.consume(code);
+    return after
+  }
+  /** @type {State} */
 
-    if (unistUtilGenerated(node) || !indent || indent.length === 0) {
-      return
-    }
+  function after(code) {
+    // Check the next.
+    if (trailingPunctuation(code)) {
+      effects.consume(code);
+      return after
+    } // If the punctuation marker is followed by the end of the path, it’s not
+    // continued punctuation.
 
-    start = unistUtilPosition.start(node).line;
-    length = indent.length;
-    index = -1;
+    return pathEnd(code) ? ok(code) : nok(code)
+  }
+}
+/**
+ * @param {Code} code
+ * @returns {boolean}
+ */
 
-    while (++index < length) {
-      line = start + index + 1;
-      pos = {line: line, column: indent[index]};
-      offset = location.toOffset(pos) - 1;
+function trailingPunctuation(code) {
+  return (
+    code === 33 ||
+    code === 34 ||
+    code === 39 ||
+    code === 41 ||
+    code === 42 ||
+    code === 44 ||
+    code === 46 ||
+    code === 58 ||
+    code === 59 ||
+    code === 60 ||
+    code === 63 ||
+    code === 95 ||
+    code === 126
+  )
+}
+/**
+ * @param {Code} code
+ * @returns {boolean}
+ */
 
-      while (++offset < last) {
-        character = contents.charAt(offset);
+function pathEnd(code) {
+  return code === null || code === 60 || markdownLineEndingOrSpace(code)
+}
+/**
+ * @param {Code} code
+ * @returns {boolean}
+ */
 
-        if (character === '>') {
-          break
-        }
+function gfmAtext(code) {
+  return (
+    code === 43 ||
+    code === 45 ||
+    code === 46 ||
+    code === 95 ||
+    asciiAlphanumeric(code)
+  )
+}
+/** @type {Previous} */
 
-        /* istanbul ignore else - just for safety */
-        if (character !== ' ' && character !== '\t') {
-          file.message(reason$1, pos);
-          break
-        }
-      }
-    }
-  }
+function previousWww(code) {
+  return (
+    code === null ||
+    code === 40 ||
+    code === 42 ||
+    code === 95 ||
+    code === 126 ||
+    markdownLineEndingOrSpace(code)
+  )
 }
+/** @type {Previous} */
 
-var remarkLintNoLiteralUrls = unifiedLintRule('remark-lint:no-literal-urls', noLiteralURLs);
+function previousHttp(code) {
+  return code === null || !asciiAlpha(code)
+}
+/** @type {Previous} */
 
-var start$5 = unistUtilPosition.start;
-var end$2 = unistUtilPosition.end;
-var mailto$2 = 'mailto:';
-var reason$2 = 'Don’t use literal URLs without angle brackets';
+function previousEmail(code) {
+  return code !== 47 && previousHttp(code)
+}
+/**
+ * @param {Event[]} events
+ * @returns {boolean}
+ */
 
-function noLiteralURLs(tree, file) {
-  unistUtilVisit(tree, 'link', visitor);
+function previousUnbalanced(events) {
+  let index = events.length;
+  let result = false;
 
-  function visitor(node) {
-    var children = node.children;
-    var value = mdastUtilToString(node);
+  while (index--) {
+    const token = events[index][1];
 
     if (
-      !unistUtilGenerated(node) &&
-      start$5(node).column === start$5(children[0]).column &&
-      end$2(node).column === end$2(children[children.length - 1]).column &&
-      (node.url === mailto$2 + value || node.url === value)
+      (token.type === 'labelLink' || token.type === 'labelImage') &&
+      !token._balanced
     ) {
-      file.message(reason$2, node);
+      result = true;
+      break
+    } // @ts-expect-error If we’ve seen this token, and it was marked as not
+    // having any unbalanced bracket before it, we can exit.
+
+    if (token._gfmAutolinkLiteralWalkedInto) {
+      result = false;
+      break
     }
   }
-}
 
-var remarkLintOrderedListMarkerStyle = unifiedLintRule(
-  'remark-lint:ordered-list-marker-style',
-  orderedListMarkerStyle
-);
+  if (events.length > 0 && !result) {
+    // @ts-expect-error Mark the last token as “walked into” w/o finding
+    // anything.
+    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;
+  }
 
-var start$6 = unistUtilPosition.start;
+  return result
+}
 
-var styles$2 = {
-  ')': true,
-  '.': true,
-  null: true
-};
+const characterReferences = {'"': 'quot', '&': 'amp', '<': 'lt', '>': 'gt'};
 
-function orderedListMarkerStyle(tree, file, option) {
-  var contents = String(file);
-  var preferred =
-    typeof option !== 'string' || option === 'consistent' ? null : option;
+/**
+ * Encode only the dangerous HTML characters.
+ *
+ * This ensures that certain characters which have special meaning in HTML are
+ * dealt with.
+ * Technically, we can skip `>` and `"` in many cases, but CM includes them.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function encode(value) {
+  return value.replace(/["&<>]/g, replace)
 
-  if (styles$2[preferred] !== true) {
-    file.fail(
-      'Incorrect ordered list item marker style `' +
-        preferred +
-        "`: use either `'.'` or `')'`"
-    );
+  /**
+   * @param {string} value
+   * @returns {string}
+   */
+  function replace(value) {
+    // @ts-expect-error Hush, it’s fine.
+    return '&' + characterReferences[value] + ';'
   }
+}
 
-  unistUtilVisit(tree, 'list', visitor);
-
-  function visitor(node) {
-    var children = node.children;
-    var length = node.ordered ? children.length : 0;
-    var index = -1;
-    var marker;
-    var child;
+/**
+ * Make a value safe for injection as a URL.
+ *
+ * This encodes unsafe characters with percent-encoding and skips already
+ * encoded sequences (see `normalizeUri` below).
+ * Further unsafe characters are encoded as character references (see
+ * `micromark-util-encode`).
+ *
+ * Then, a regex of allowed protocols can be given, in which case the URL is
+ * sanitized.
+ * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`,
+ * or `/^https?$/i` for `img[src]`.
+ * If the URL includes an unknown protocol (one not matched by `protocol`, such
+ * as a dangerous example, `javascript:`), the value is ignored.
+ *
+ * @param {string|undefined} url
+ * @param {RegExp} [protocol]
+ * @returns {string}
+ */
+function sanitizeUri(url, protocol) {
+  const value = encode(normalizeUri(url || ''));
 
-    while (++index < length) {
-      child = children[index];
+  if (!protocol) {
+    return value
+  }
 
-      if (!unistUtilGenerated(child)) {
-        marker = contents
-          .slice(start$6(child).offset, start$6(child.children[0]).offset)
-          .replace(/\s|\d/g, '')
-          .replace(/\[[x ]?]\s*$/i, '');
+  const colon = value.indexOf(':');
+  const questionMark = value.indexOf('?');
+  const numberSign = value.indexOf('#');
+  const slash = value.indexOf('/');
 
-        if (preferred) {
-          if (marker !== preferred) {
-            file.message('Marker style should be `' + preferred + '`', child);
-          }
-        } else {
-          preferred = marker;
-        }
-      }
-    }
+  if (
+    // If there is no protocol, it’s relative.
+    colon < 0 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.
+    (slash > -1 && colon > slash) ||
+    (questionMark > -1 && colon > questionMark) ||
+    (numberSign > -1 && colon > numberSign) || // It is a protocol, it should be allowed.
+    protocol.test(value.slice(0, colon))
+  ) {
+    return value
   }
-}
 
-var remarkLintHardBreakSpaces = unifiedLintRule('remark-lint:hard-break-spaces', hardBreakSpaces);
+  return ''
+}
+/**
+ * Normalize a URL (such as used in definitions).
+ *
+ * Encode unsafe characters with percent-encoding, skipping already encoded
+ * sequences.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
 
-var reason$3 = 'Use two spaces for hard line breaks';
+function normalizeUri(value) {
+  /** @type {string[]} */
+  const result = [];
+  let index = -1;
+  let start = 0;
+  let skip = 0;
 
-function hardBreakSpaces(tree, file) {
-  var contents = String(file);
+  while (++index < value.length) {
+    const code = value.charCodeAt(index);
+    /** @type {string} */
 
-  unistUtilVisit(tree, 'break', visitor);
+    let replace = ''; // A correct percent encoded value.
 
-  function visitor(node) {
-    var value;
+    if (
+      code === 37 &&
+      asciiAlphanumeric(value.charCodeAt(index + 1)) &&
+      asciiAlphanumeric(value.charCodeAt(index + 2))
+    ) {
+      skip = 2;
+    } // ASCII.
+    else if (code < 128) {
+      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {
+        replace = String.fromCharCode(code);
+      }
+    } // Astral.
+    else if (code > 55295 && code < 57344) {
+      const next = value.charCodeAt(index + 1); // A correct surrogate pair.
+
+      if (code < 56320 && next > 56319 && next < 57344) {
+        replace = String.fromCharCode(code, next);
+        skip = 1;
+      } // Lone surrogate.
+      else {
+        replace = '\uFFFD';
+      }
+    } // Unicode.
+    else {
+      replace = String.fromCharCode(code);
+    }
 
-    if (!unistUtilGenerated(node)) {
-      value = contents
-        .slice(unistUtilPosition.start(node).offset, unistUtilPosition.end(node).offset)
-        .split('\n', 1)[0]
-        .replace(/\r$/, '');
+    if (replace) {
+      result.push(value.slice(start, index), encodeURIComponent(replace));
+      start = index + skip + 1;
+      replace = '';
+    }
 
-      if (value.length > 2) {
-        file.message(reason$3, node);
-      }
+    if (skip) {
+      index += skip;
+      skip = 0;
     }
   }
+
+  return result.join('') + value.slice(start)
 }
 
-var remarkLintNoDuplicateDefinitions = unifiedLintRule(
-  'remark-lint:no-duplicate-definitions',
-  noDuplicateDefinitions
-);
+/**
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ * @typedef {import('micromark-util-types').Handle} Handle
+ * @typedef {import('micromark-util-types').CompileContext} CompileContext
+ * @typedef {import('micromark-util-types').Token} Token
+ */
+/** @type {HtmlExtension} */
 
-var reason$4 = 'Do not use definitions with the same identifier';
+const gfmAutolinkLiteralHtml = {
+  exit: {
+    literalAutolinkEmail,
+    literalAutolinkHttp,
+    literalAutolinkWww
+  }
+};
+/** @type {Handle} */
 
-function noDuplicateDefinitions(tree, file) {
-  var map = {};
+function literalAutolinkWww(token) {
+  anchorFromToken.call(this, token, 'http://');
+}
+/** @type {Handle} */
 
-  unistUtilVisit(tree, ['definition', 'footnoteDefinition'], check);
+function literalAutolinkEmail(token) {
+  anchorFromToken.call(this, token, 'mailto:');
+}
+/** @type {Handle} */
 
-  function check(node) {
-    var identifier;
-    var duplicate;
+function literalAutolinkHttp(token) {
+  anchorFromToken.call(this, token);
+}
+/**
+ * @this CompileContext
+ * @param {Token} token
+ * @param {string} [protocol]
+ * @returns {void}
+ */
 
-    if (!unistUtilGenerated(node)) {
-      identifier = node.identifier;
-      duplicate = map[identifier];
+function anchorFromToken(token, protocol) {
+  const url = this.sliceSerialize(token);
+  this.tag('<a href="' + sanitizeUri((protocol || '') + url) + '">');
+  this.raw(this.encode(url));
+  this.tag('</a>');
+}
 
-      if (duplicate && duplicate.type) {
-        file.message(
-          reason$4 + ' (' + unistUtilStringifyPosition(unistUtilPosition.start(duplicate)) + ')',
-          node
-        );
-      }
+/**
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ */
 
-      map[identifier] = node;
+/** @type {HtmlExtension} */
+const gfmStrikethroughHtml = {
+  enter: {
+    strikethrough() {
+      this.tag('<del>');
+    }
+  },
+  exit: {
+    strikethrough() {
+      this.tag('</del>');
     }
   }
-}
+};
 
-var mdastUtilHeadingStyle = style;
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Event} Event
+ */
 
-function style(node, relative) {
-  var last = node.children[node.children.length - 1];
-  var depth = node.depth;
-  var pos = node && node.position && node.position.end;
-  var final = last && last.position && last.position.end;
+/**
+ * @param {Options} [options]
+ * @returns {Extension}
+ */
+function gfmStrikethrough(options = {}) {
+  let single = options.singleTilde;
+  const tokenizer = {
+    tokenize: tokenizeStrikethrough,
+    resolveAll: resolveAllStrikethrough
+  };
 
-  if (!pos) {
-    return null
+  if (single === null || single === undefined) {
+    single = true;
   }
 
-  // This can only occur for `'atx'` and `'atx-closed'` headings.
-  // This might incorrectly match `'atx'` headings with lots of trailing white
-  // space as an `'atx-closed'` heading.
-  if (!last) {
-    if (pos.column - 1 <= depth * 2) {
-      return consolidate(depth, relative)
+  return {
+    text: {
+      [126]: tokenizer
+    },
+    insideSpan: {
+      null: [tokenizer]
     }
-
-    return 'atx-closed'
-  }
-
-  if (final.line + 1 === pos.line) {
-    return 'setext'
-  }
-
-  if (final.column + depth < pos.column) {
-    return 'atx-closed'
   }
+  /**
+   * Take events and resolve strikethrough.
+   *
+   * @type {Resolver}
+   */
 
-  return consolidate(depth, relative)
-}
+  function resolveAllStrikethrough(events, context) {
+    let index = -1;
+    /** @type {Token} */
 
-// Get the probable style of an atx-heading, depending on preferred style.
-function consolidate(depth, relative) {
-  return depth < 3
-    ? 'atx'
-    : relative === 'atx' || relative === 'setext'
-    ? relative
-    : null
-}
+    let strikethrough;
+    /** @type {Token} */
 
-var remarkLintNoHeadingContentIndent = unifiedLintRule(
-  'remark-lint:no-heading-content-indent',
-  noHeadingContentIndent
-);
+    let text;
+    /** @type {number} */
 
-var start$7 = unistUtilPosition.start;
-var end$3 = unistUtilPosition.end;
+    let open;
+    /** @type {Event[]} */
 
-function noHeadingContentIndent(tree, file) {
-  var contents = String(file);
+    let nextEvents; // Walk through all events.
 
-  unistUtilVisit(tree, 'heading', visitor);
+    while (++index < events.length) {
+      // Find a token that can close.
+      if (
+        events[index][0] === 'enter' &&
+        events[index][1].type === 'strikethroughSequenceTemporary' &&
+        events[index][1]._close
+      ) {
+        open = index; // Now walk back to find an opener.
+
+        while (open--) {
+          // Find a token that can open the closer.
+          if (
+            events[open][0] === 'exit' &&
+            events[open][1].type === 'strikethroughSequenceTemporary' &&
+            events[open][1]._open && // If the sizes are the same:
+            events[index][1].end.offset - events[index][1].start.offset ===
+              events[open][1].end.offset - events[open][1].start.offset
+          ) {
+            events[index][1].type = 'strikethroughSequence';
+            events[open][1].type = 'strikethroughSequence';
+            strikethrough = {
+              type: 'strikethrough',
+              start: Object.assign({}, events[open][1].start),
+              end: Object.assign({}, events[index][1].end)
+            };
+            text = {
+              type: 'strikethroughText',
+              start: Object.assign({}, events[open][1].end),
+              end: Object.assign({}, events[index][1].start)
+            }; // Opening.
+
+            nextEvents = [
+              ['enter', strikethrough, context],
+              ['enter', events[open][1], context],
+              ['exit', events[open][1], context],
+              ['enter', text, context]
+            ]; // Between.
+
+            splice(
+              nextEvents,
+              nextEvents.length,
+              0,
+              resolveAll(
+                context.parser.constructs.insideSpan.null,
+                events.slice(open + 1, index),
+                context
+              )
+            ); // Closing.
+
+            splice(nextEvents, nextEvents.length, 0, [
+              ['exit', text, context],
+              ['enter', events[index][1], context],
+              ['exit', events[index][1], context],
+              ['exit', strikethrough, context]
+            ]);
+            splice(events, open - 1, index - open + 3, nextEvents);
+            index = open + nextEvents.length - 2;
+            break
+          }
+        }
+      }
+    }
 
-  function visitor(node) {
-    var depth;
-    var children;
-    var type;
-    var head;
-    var initial;
-    var final;
-    var diff;
-    var index;
-    var char;
-    var reason;
-    var abs;
+    index = -1;
 
-    if (unistUtilGenerated(node)) {
-      return
+    while (++index < events.length) {
+      if (events[index][1].type === 'strikethroughSequenceTemporary') {
+        events[index][1].type = 'data';
+      }
     }
 
-    depth = node.depth;
-    children = node.children;
-    type = mdastUtilHeadingStyle(node, 'atx');
+    return events
+  }
+  /** @type {Tokenizer} */
 
-    if (type === 'atx' || type === 'atx-closed') {
-      initial = start$7(node);
-      index = initial.offset;
-      char = contents.charAt(index);
+  function tokenizeStrikethrough(effects, ok, nok) {
+    const previous = this.previous;
+    const events = this.events;
+    let size = 0;
+    return start
+    /** @type {State} */
 
-      while (char && char !== '#') {
-        char = contents.charAt(++index);
+    function start(code) {
+      if (
+        code !== 126 ||
+        (previous === 126 &&
+          events[events.length - 1][1].type !== 'characterEscape')
+      ) {
+        return nok(code)
       }
 
-      /* istanbul ignore if - CR/LF bug: remarkjs/remark#195. */
-      if (!char) {
-        return
-      }
+      effects.enter('strikethroughSequenceTemporary');
+      return more(code)
+    }
+    /** @type {State} */
 
-      index = depth + (index - initial.offset);
-      head = start$7(children[0]).column;
+    function more(code) {
+      const before = classifyCharacter(previous);
 
-      // Ignore empty headings.
-      if (!head) {
-        return
+      if (code === 126) {
+        // If this is the third marker, exit.
+        if (size > 1) return nok(code)
+        effects.consume(code);
+        size++;
+        return more
       }
 
-      diff = head - initial.column - 1 - index;
+      if (size < 2 && !single) return nok(code)
+      const token = effects.exit('strikethroughSequenceTemporary');
+      const after = classifyCharacter(code);
+      token._open = !after || (after === 2 && Boolean(before));
+      token._close = !before || (before === 2 && Boolean(after));
+      return ok(code)
+    }
+  }
+}
 
-      if (diff) {
-        abs = Math.abs(diff);
+/**
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ */
 
-        reason =
-          (diff > 0 ? 'Remove' : 'Add') +
-          ' ' +
-          abs +
-          ' ' +
-          pluralize('space', abs) +
-          ' before this heading’s content';
+/**
+ * @typedef {import('./syntax.js').Align} Align
+ */
+const alignment = {
+  null: '',
+  left: ' align="left"',
+  right: ' align="right"',
+  center: ' align="center"'
+};
+/** @type {HtmlExtension} */
 
-        file.message(reason, start$7(children[0]));
-      }
-    }
+const gfmTableHtml = {
+  enter: {
+    table(token) {
+      this.lineEndingIfNeeded();
+      this.tag('<table>'); // @ts-expect-error Custom.
+
+      this.setData('tableAlign', token._align);
+    },
 
-    // Closed ATX headings always must have a space between their content and
-    // the final hashes, thus, there is no `add x spaces`.
-    if (type === 'atx-closed') {
-      final = end$3(children[children.length - 1]);
-      diff = end$3(node).column - final.column - 1 - depth;
+    tableBody() {
+      // Clear slurping line ending from the delimiter row.
+      this.setData('slurpOneLineEnding');
+      this.tag('<tbody>');
+    },
 
-      if (diff) {
-        reason =
-          'Remove ' +
-          diff +
-          ' ' +
-          pluralize('space', diff) +
-          ' after this heading’s content';
+    tableData() {
+      /** @type {string|undefined} */
+      const align = // @ts-expect-error Custom.
+        alignment[this.getData('tableAlign')[this.getData('tableColumn')]];
 
-        file.message(reason, final);
+      if (align === undefined) {
+        // Capture results to ignore them.
+        this.buffer();
+      } else {
+        this.lineEndingIfNeeded();
+        this.tag('<td' + align + '>');
       }
-    }
-  }
-}
-
-var remarkLintNoInlinePadding = unifiedLintRule('remark-lint:no-inline-padding', noInlinePadding);
+    },
 
-function noInlinePadding(tree, file) {
-  unistUtilVisit(tree, ['emphasis', 'strong', 'delete', 'image', 'link'], visitor);
+    tableHead() {
+      this.lineEndingIfNeeded();
+      this.tag('<thead>');
+    },
 
-  function visitor(node) {
-    var contents;
+    tableHeader() {
+      this.lineEndingIfNeeded();
+      this.tag(
+        '<th' + // @ts-expect-error Custom.
+          alignment[this.getData('tableAlign')[this.getData('tableColumn')]] +
+          '>'
+      );
+    },
 
-    if (!unistUtilGenerated(node)) {
-      contents = mdastUtilToString(node);
+    tableRow() {
+      this.setData('tableColumn', 0);
+      this.lineEndingIfNeeded();
+      this.tag('<tr>');
+    }
+  },
+  exit: {
+    // Overwrite the default code text data handler to unescape escaped pipes when
+    // they are in tables.
+    codeTextData(token) {
+      let value = this.sliceSerialize(token);
 
-      if (
-        contents.charAt(0) === ' ' ||
-        contents.charAt(contents.length - 1) === ' '
-      ) {
-        file.message('Don’t pad `' + node.type + '` with inner spaces', node);
+      if (this.getData('tableAlign')) {
+        value = value.replace(/\\([\\|])/g, replace$1);
       }
-    }
-  }
-}
 
-var remarkLintNoShortcutReferenceImage = unifiedLintRule(
-  'remark-lint:no-shortcut-reference-image',
-  noShortcutReferenceImage
-);
+      this.raw(this.encode(value));
+    },
 
-var reason$5 = 'Use the trailing [] on reference images';
+    table() {
+      this.setData('tableAlign'); // If there was no table body, make sure the slurping from the delimiter row
+      // is cleared.
 
-function noShortcutReferenceImage(tree, file) {
-  unistUtilVisit(tree, 'imageReference', visitor);
+      this.setData('slurpAllLineEndings');
+      this.lineEndingIfNeeded();
+      this.tag('</table>');
+    },
 
-  function visitor(node) {
-    if (!unistUtilGenerated(node) && node.referenceType === 'shortcut') {
-      file.message(reason$5, node);
-    }
-  }
-}
+    tableBody() {
+      this.lineEndingIfNeeded();
+      this.tag('</tbody>');
+    },
 
-var remarkLintNoShortcutReferenceLink = unifiedLintRule(
-  'remark-lint:no-shortcut-reference-link',
-  noShortcutReferenceLink
-);
+    tableData() {
+      /** @type {number} */
+      // @ts-expect-error Custom.
+      const column = this.getData('tableColumn'); // @ts-expect-error Custom.
 
-var reason$6 = 'Use the trailing `[]` on reference links';
+      if (column in this.getData('tableAlign')) {
+        this.tag('</td>');
+        this.setData('tableColumn', column + 1);
+      } else {
+        // Stop capturing.
+        this.resume();
+      }
+    },
 
-function noShortcutReferenceLink(tree, file) {
-  unistUtilVisit(tree, 'linkReference', visitor);
+    tableHead() {
+      this.lineEndingIfNeeded();
+      this.tag('</thead>');
+      this.setData('slurpOneLineEnding', true); // Slurp the line ending from the delimiter row.
+    },
 
-  function visitor(node) {
-    if (!unistUtilGenerated(node) && node.referenceType === 'shortcut') {
-      file.message(reason$6, node);
-    }
-  }
-}
+    tableHeader() {
+      this.tag('</th>'); // @ts-expect-error Custom.
 
-var remarkLintNoUndefinedReferences = unifiedLintRule(
-  'remark-lint:no-undefined-references',
-  noUndefinedReferences
-);
+      this.setData('tableColumn', this.getData('tableColumn') + 1);
+    },
 
-var reason$7 = 'Found reference to undefined definition';
+    tableRow() {
+      /** @type {Align[]} */
+      // @ts-expect-error Custom.
+      const align = this.getData('tableAlign');
+      /** @type {number} */
+      // @ts-expect-error Custom.
 
-// The identifier is upcased to avoid naming collisions with fields inherited
-// from `Object.prototype`.
-// If `Object.create(null)` was used in place of `{}`, downcasing would work
-// equally well.
-function normalize$3(s) {
-  return collapseWhiteSpace(s.toUpperCase())
-}
+      let column = this.getData('tableColumn');
 
-function noUndefinedReferences(tree, file, option) {
-  var allow = ((option || {}).allow || []).map(normalize$3);
-  var map = {};
+      while (column < align.length) {
+        this.lineEndingIfNeeded(); // @ts-expect-error `null` is fine as an index.
 
-  unistUtilVisit(tree, ['definition', 'footnoteDefinition'], mark);
-  unistUtilVisit(tree, ['imageReference', 'linkReference', 'footnoteReference'], find);
+        this.tag('<td' + alignment[align[column]] + '></td>');
+        column++;
+      }
 
-  function mark(node) {
-    if (!unistUtilGenerated(node)) {
-      map[normalize$3(node.identifier)] = true;
+      this.setData('tableColumn', column);
+      this.lineEndingIfNeeded();
+      this.tag('</tr>');
     }
   }
+};
+/**
+ * @param {string} $0
+ * @param {string} $1
+ * @returns {string}
+ */
 
-  function find(node) {
-    if (
-      !unistUtilGenerated(node) &&
-      !(normalize$3(node.identifier) in map) &&
-      allow.indexOf(normalize$3(node.identifier)) === -1
-    ) {
-      file.message(reason$7, node);
+function replace$1($0, $1) {
+  // Pipes work, backslashes don’t (but can’t escape pipes).
+  return $1 === '|' ? $1 : $0
+}
+
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ */
+
+/** @type {Extension} */
+const gfmTable = {
+  flow: {
+    null: {
+      tokenize: tokenizeTable,
+      resolve: resolveTable
     }
   }
-}
+};
+const setextUnderlineMini = {
+  tokenize: tokenizeSetextUnderlineMini,
+  partial: true
+};
+const nextPrefixedOrBlank = {
+  tokenize: tokenizeNextPrefixedOrBlank,
+  partial: true
+};
+/** @type {Resolver} */
 
-var remarkLintNoUnusedDefinitions = unifiedLintRule('remark-lint:no-unused-definitions', noUnusedDefinitions);
+function resolveTable(events, context) {
+  let index = -1;
+  /** @type {Token} */
 
-var reason$8 = 'Found unused definition';
+  let token;
+  /** @type {boolean|undefined} */
 
-function noUnusedDefinitions(tree, file) {
-  var map = {};
-  var identifier;
-  var entry;
+  let inHead;
+  /** @type {boolean|undefined} */
 
-  unistUtilVisit(tree, ['definition', 'footnoteDefinition'], find);
-  unistUtilVisit(tree, ['imageReference', 'linkReference', 'footnoteReference'], mark);
+  let inDelimiterRow;
+  /** @type {boolean|undefined} */
 
-  for (identifier in map) {
-    entry = map[identifier];
+  let inRow;
+  /** @type {Token} */
 
-    if (!entry.used) {
-      file.message(reason$8, entry.node);
-    }
-  }
+  let cell;
+  /** @type {Token} */
 
-  function find(node) {
-    if (!unistUtilGenerated(node)) {
-      map[node.identifier.toUpperCase()] = {node: node, used: false};
-    }
-  }
+  let content;
+  /** @type {Token} */
 
-  function mark(node) {
-    var info = map[node.identifier.toUpperCase()];
+  let text;
+  /** @type {number|undefined} */
 
-    if (!unistUtilGenerated(node) && info) {
-      info.used = true;
-    }
-  }
-}
+  let contentStart;
+  /** @type {number|undefined} */
 
-var plugins$1 = [
-  remarkLint,
-  // Unix compatibility.
-  remarkLintFinalNewline,
-  // Rendering across vendors differs greatly if using other styles.
-  remarkLintListItemBulletIndent,
-  [remarkLintListItemIndent, 'tab-size'],
-  // Differs or unsupported across vendors.
-  remarkLintNoAutoLinkWithoutProtocol,
-  remarkLintNoBlockquoteWithoutMarker,
-  remarkLintNoLiteralUrls,
-  [remarkLintOrderedListMarkerStyle, '.'],
-  // Mistakes.
-  remarkLintHardBreakSpaces,
-  remarkLintNoDuplicateDefinitions,
-  remarkLintNoHeadingContentIndent,
-  remarkLintNoInlinePadding,
-  remarkLintNoShortcutReferenceImage,
-  remarkLintNoShortcutReferenceLink,
-  remarkLintNoUndefinedReferences,
-  remarkLintNoUnusedDefinitions
-];
+  let contentEnd;
+  /** @type {number|undefined} */
 
-var remarkPresetLintRecommended = {
-	plugins: plugins$1
-};
+  let cellStart;
 
-var remarkLintBlockquoteIndentation = unifiedLintRule(
-  'remark-lint:blockquote-indentation',
-  blockquoteIndentation
-);
+  while (++index < events.length) {
+    token = events[index][1];
 
-function blockquoteIndentation(tree, file, option) {
-  var preferred = typeof option === 'number' && !isNaN(option) ? option : null;
+    if (inRow) {
+      if (token.type === 'temporaryTableCellContent') {
+        contentStart = contentStart || index;
+        contentEnd = index;
+      }
 
-  unistUtilVisit(tree, 'blockquote', visitor);
+      if (
+        // Combine separate content parts into one.
+        (token.type === 'tableCellDivider' || token.type === 'tableRow') &&
+        contentEnd
+      ) {
+        content = {
+          type: 'tableContent',
+          // @ts-expect-error `contentStart` is defined if `contentEnd` is too.
+          start: events[contentStart][1].start,
+          end: events[contentEnd][1].end
+        };
+        text = {
+          type: 'chunkText',
+          start: content.start,
+          end: content.end,
+          // @ts-expect-error It’s fine.
+          contentType: 'text'
+        };
+        events.splice(
+          // @ts-expect-error `contentStart` is defined if `contentEnd` is too.
+          contentStart, // @ts-expect-error `contentStart` is defined if `contentEnd` is too.
+          contentEnd - contentStart + 1,
+          ['enter', content, context],
+          ['enter', text, context],
+          ['exit', text, context],
+          ['exit', content, context]
+        ); // @ts-expect-error `contentStart` is defined if `contentEnd` is too.
 
-  function visitor(node) {
-    var abs;
-    var diff;
-    var reason;
+        index -= contentEnd - contentStart - 3;
+        contentStart = undefined;
+        contentEnd = undefined;
+      }
+    }
 
-    if (unistUtilGenerated(node) || node.children.length === 0) {
-      return
+    if (
+      events[index][0] === 'exit' &&
+      cellStart &&
+      cellStart + 1 < index &&
+      (token.type === 'tableCellDivider' ||
+        (token.type === 'tableRow' &&
+          (cellStart + 3 < index ||
+            events[cellStart][1].type !== 'whitespace')))
+    ) {
+      cell = {
+        type: inDelimiterRow
+          ? 'tableDelimiter'
+          : inHead
+          ? 'tableHeader'
+          : 'tableData',
+        start: events[cellStart][1].start,
+        end: events[index][1].end
+      };
+      events.splice(index + (token.type === 'tableCellDivider' ? 1 : 0), 0, [
+        'exit',
+        cell,
+        context
+      ]);
+      events.splice(cellStart, 0, ['enter', cell, context]);
+      index += 2;
+      cellStart = index + 1;
     }
 
-    if (preferred) {
-      diff = preferred - check$3(node);
+    if (token.type === 'tableRow') {
+      inRow = events[index][0] === 'enter';
 
-      if (diff !== 0) {
-        abs = Math.abs(diff);
-        reason =
-          (diff > 0 ? 'Add' : 'Remove') +
-          ' ' +
-          abs +
-          ' ' +
-          pluralize('space', abs) +
-          ' between block quote and content';
+      if (inRow) {
+        cellStart = index + 1;
+      }
+    }
 
-        file.message(reason, unistUtilPosition.start(node.children[0]));
+    if (token.type === 'tableDelimiterRow') {
+      inDelimiterRow = events[index][0] === 'enter';
+
+      if (inDelimiterRow) {
+        cellStart = index + 1;
       }
-    } else {
-      preferred = check$3(node);
+    }
+
+    if (token.type === 'tableHead') {
+      inHead = events[index][0] === 'enter';
     }
   }
+
+  return events
 }
+/** @type {Tokenizer} */
 
-function check$3(node) {
-  var head = node.children[0];
-  var indentation = unistUtilPosition.start(head).column - unistUtilPosition.start(node).column;
-  var padding = mdastUtilToString(head).match(/^ +/);
+function tokenizeTable(effects, ok, nok) {
+  const self = this;
+  /** @type {Align[]} */
 
-  if (padding) {
-    indentation += padding[0].length;
-  }
+  const align = [];
+  let tableHeaderCount = 0;
+  /** @type {boolean|undefined} */
 
-  return indentation
-}
+  let seenDelimiter;
+  /** @type {boolean|undefined} */
 
-var remarkLintCheckboxCharacterStyle = unifiedLintRule(
-  'remark-lint:checkbox-character-style',
-  checkboxCharacterStyle
-);
+  let hasDash;
+  return start
+  /** @type {State} */
 
-var start$8 = unistUtilPosition.start;
-var end$4 = unistUtilPosition.end;
+  function start(code) {
+    // @ts-expect-error Custom.
+    effects.enter('table')._align = align;
+    effects.enter('tableHead');
+    effects.enter('tableRow'); // If we start with a pipe, we open a cell marker.
 
-var checked = {x: true, X: true};
-var unchecked = {' ': true, '\t': true};
-var types$1 = {true: 'checked', false: 'unchecked'};
+    if (code === 124) {
+      return cellDividerHead(code)
+    }
 
-function checkboxCharacterStyle(tree, file, option) {
-  var contents = String(file);
-  var location = vfileLocation(file);
-  var preferred = typeof option === 'object' ? option : {};
+    tableHeaderCount++;
+    effects.enter('temporaryTableCellContent'); // Can’t be space or eols at the start of a construct, so we’re in a cell.
 
-  if (preferred.unchecked && unchecked[preferred.unchecked] !== true) {
-    file.fail(
-      'Incorrect unchecked checkbox marker `' +
-        preferred.unchecked +
-        "`: use either `'\\t'`, or `' '`"
-    );
+    return inCellContentHead(code)
   }
+  /** @type {State} */
 
-  if (preferred.checked && checked[preferred.checked] !== true) {
-    file.fail(
-      'Incorrect checked checkbox marker `' +
-        preferred.checked +
-        "`: use either `'x'`, or `'X'`"
-    );
+  function cellDividerHead(code) {
+    effects.enter('tableCellDivider');
+    effects.consume(code);
+    effects.exit('tableCellDivider');
+    seenDelimiter = true;
+    return cellBreakHead
   }
+  /** @type {State} */
 
-  unistUtilVisit(tree, 'listItem', visitor);
+  function cellBreakHead(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return atRowEndHead(code)
+    }
 
-  function visitor(node) {
-    var type;
-    var initial;
-    var final;
-    var value;
-    var style;
-    var character;
-    var reason;
+    if (markdownSpace(code)) {
+      effects.enter('whitespace');
+      effects.consume(code);
+      return inWhitespaceHead
+    }
 
-    // Exit early for items without checkbox.
-    if (typeof node.checked !== 'boolean' || unistUtilGenerated(node)) {
-      return
+    if (seenDelimiter) {
+      seenDelimiter = undefined;
+      tableHeaderCount++;
     }
 
-    type = types$1[node.checked];
-    initial = start$8(node).offset;
-    final = (node.children.length === 0 ? end$4(node) : start$8(node.children[0]))
-      .offset;
+    if (code === 124) {
+      return cellDividerHead(code)
+    } // Anything else is cell content.
 
-    // For a checkbox to be parsed, it must be followed by a whitespace.
-    value = contents.slice(initial, final).replace(/\s+$/, '').slice(0, -1);
+    effects.enter('temporaryTableCellContent');
+    return inCellContentHead(code)
+  }
+  /** @type {State} */
 
-    // The checkbox character is behind a square bracket.
-    character = value.charAt(value.length - 1);
-    style = preferred[type];
+  function inWhitespaceHead(code) {
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return inWhitespaceHead
+    }
 
-    if (style) {
-      if (character !== style) {
-        reason =
-          type.charAt(0).toUpperCase() +
-          type.slice(1) +
-          ' checkboxes should use `' +
-          style +
-          '` as a marker';
+    effects.exit('whitespace');
+    return cellBreakHead(code)
+  }
+  /** @type {State} */
 
-        file.message(reason, {
-          start: location.toPosition(initial + value.length - 1),
-          end: location.toPosition(initial + value.length)
-        });
-      }
-    } else {
-      preferred[type] = character;
+  function inCellContentHead(code) {
+    // EOF, whitespace, pipe
+    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {
+      effects.exit('temporaryTableCellContent');
+      return cellBreakHead(code)
     }
-  }
-}
 
-var remarkLintCheckboxContentIndent = unifiedLintRule(
-  'remark-lint:checkbox-content-indent',
-  checkboxContentIndent
-);
+    effects.consume(code);
+    return code === 92 ? inCellContentEscapeHead : inCellContentHead
+  }
+  /** @type {State} */
 
-var start$9 = unistUtilPosition.start;
-var end$5 = unistUtilPosition.end;
+  function inCellContentEscapeHead(code) {
+    if (code === 92 || code === 124) {
+      effects.consume(code);
+      return inCellContentHead
+    } // Anything else.
 
-var reason$9 = 'Checkboxes should be followed by a single character';
+    return inCellContentHead(code)
+  }
+  /** @type {State} */
 
-function checkboxContentIndent(tree, file) {
-  var contents = String(file);
-  var location = vfileLocation(file);
+  function atRowEndHead(code) {
+    if (code === null) {
+      return nok(code)
+    }
 
-  unistUtilVisit(tree, 'listItem', visitor);
+    effects.exit('tableRow');
+    effects.exit('tableHead');
+    return effects.attempt(
+      {
+        tokenize: tokenizeRowEnd,
+        partial: true
+      },
+      atDelimiterLineStart,
+      nok
+    )(code)
+  }
+  /** @type {State} */
 
-  function visitor(node) {
-    var initial;
-    var final;
-    var value;
+  function atDelimiterLineStart(code) {
+    // To do: is the lazy setext thing still needed?
+    return effects.check(
+      setextUnderlineMini,
+      nok, // Support an indent before the delimiter row.
+      factorySpace(effects, rowStartDelimiter, 'linePrefix', 4)
+    )(code)
+  }
+  /** @type {State} */
 
-    // Exit early for items without checkbox.
-    if (typeof node.checked !== 'boolean' || unistUtilGenerated(node)) {
-      return
+  function rowStartDelimiter(code) {
+    // If there’s another space, or we’re at the EOL/EOF, exit.
+    if (code === null || markdownLineEndingOrSpace(code)) {
+      return nok(code)
     }
 
-    initial = start$9(node).offset;
-    /* istanbul ignore next - hard to test, couldn’t find a case. */
-    final = (node.children.length === 0 ? end$5(node) : start$9(node.children[0]))
-      .offset;
+    effects.enter('tableDelimiterRow');
+    return atDelimiterRowBreak(code)
+  }
+  /** @type {State} */
 
-    while (/[^\S\n]/.test(contents.charAt(final))) {
-      final++;
+  function atDelimiterRowBreak(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return rowEndDelimiter(code)
     }
 
-    // For a checkbox to be parsed, it must be followed by a whitespace.
-    value = contents.slice(initial, final);
-    value = value.slice(value.indexOf(']') + 1);
-
-    if (value.length !== 1) {
-      file.message(reason$9, {
-        start: location.toPosition(final - value.length + 1),
-        end: location.toPosition(final)
-      });
+    if (markdownSpace(code)) {
+      effects.enter('whitespace');
+      effects.consume(code);
+      return inWhitespaceDelimiter
     }
-  }
-}
 
-var remarkLintCodeBlockStyle = unifiedLintRule('remark-lint:code-block-style', codeBlockStyle);
-
-var start$a = unistUtilPosition.start;
-var end$6 = unistUtilPosition.end;
+    if (code === 45) {
+      effects.enter('tableDelimiterFiller');
+      effects.consume(code);
+      hasDash = true;
+      align.push(null);
+      return inFillerDelimiter
+    }
 
-var styles$3 = {null: true, fenced: true, indented: true};
+    if (code === 58) {
+      effects.enter('tableDelimiterAlignment');
+      effects.consume(code);
+      effects.exit('tableDelimiterAlignment');
+      align.push('left');
+      return afterLeftAlignment
+    } // If we start with a pipe, we open a cell marker.
 
-function codeBlockStyle(tree, file, option) {
-  var contents = String(file);
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null;
+    if (code === 124) {
+      effects.enter('tableCellDivider');
+      effects.consume(code);
+      effects.exit('tableCellDivider');
+      return atDelimiterRowBreak
+    }
 
-  if (styles$3[preferred] !== true) {
-    file.fail(
-      'Incorrect code block style `' +
-        preferred +
-        "`: use either `'consistent'`, `'fenced'`, or `'indented'`"
-    );
+    return nok(code)
   }
+  /** @type {State} */
 
-  unistUtilVisit(tree, 'code', visitor);
+  function inWhitespaceDelimiter(code) {
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return inWhitespaceDelimiter
+    }
 
-  function visitor(node) {
-    var initial;
-    var final;
-    var current;
+    effects.exit('whitespace');
+    return atDelimiterRowBreak(code)
+  }
+  /** @type {State} */
 
-    if (unistUtilGenerated(node)) {
-      return null
+  function inFillerDelimiter(code) {
+    if (code === 45) {
+      effects.consume(code);
+      return inFillerDelimiter
     }
 
-    initial = start$a(node).offset;
-    final = end$6(node).offset;
+    effects.exit('tableDelimiterFiller');
 
-    current =
-      node.lang || /^\s*([~`])\1{2,}/.test(contents.slice(initial, final))
-        ? 'fenced'
-        : 'indented';
-
-    if (preferred) {
-      if (preferred !== current) {
-        file.message('Code blocks should be ' + preferred, node);
-      }
-    } else {
-      preferred = current;
+    if (code === 58) {
+      effects.enter('tableDelimiterAlignment');
+      effects.consume(code);
+      effects.exit('tableDelimiterAlignment');
+      align[align.length - 1] =
+        align[align.length - 1] === 'left' ? 'center' : 'right';
+      return afterRightAlignment
     }
-  }
-}
 
-var remarkLintDefinitionSpacing = unifiedLintRule('remark-lint:definition-spacing', definitionSpacing);
+    return atDelimiterRowBreak(code)
+  }
+  /** @type {State} */
 
-var label$1 = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/;
-var reason$a = 'Do not use consecutive whitespace in definition labels';
+  function afterLeftAlignment(code) {
+    if (code === 45) {
+      effects.enter('tableDelimiterFiller');
+      effects.consume(code);
+      hasDash = true;
+      return inFillerDelimiter
+    } // Anything else is not ok.
 
-function definitionSpacing(tree, file) {
-  var contents = String(file);
+    return nok(code)
+  }
+  /** @type {State} */
 
-  unistUtilVisit(tree, ['definition', 'footnoteDefinition'], check);
+  function afterRightAlignment(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return rowEndDelimiter(code)
+    }
 
-  function check(node) {
-    var start = unistUtilPosition.start(node).offset;
-    var end = unistUtilPosition.end(node).offset;
+    if (markdownSpace(code)) {
+      effects.enter('whitespace');
+      effects.consume(code);
+      return inWhitespaceDelimiter
+    } // `|`
 
-    if (
-      !unistUtilGenerated(node) &&
-      /[ \t\n]{2,}/.test(contents.slice(start, end).match(label$1)[1])
-    ) {
-      file.message(reason$a, node);
+    if (code === 124) {
+      effects.enter('tableCellDivider');
+      effects.consume(code);
+      effects.exit('tableCellDivider');
+      return atDelimiterRowBreak
     }
+
+    return nok(code)
   }
-}
+  /** @type {State} */
 
-var remarkLintFencedCodeFlag = unifiedLintRule('remark-lint:fenced-code-flag', fencedCodeFlag);
+  function rowEndDelimiter(code) {
+    effects.exit('tableDelimiterRow'); // Exit if there was no dash at all, or if the header cell count is not the
+    // delimiter cell count.
 
-var start$b = unistUtilPosition.start;
-var end$7 = unistUtilPosition.end;
+    if (!hasDash || tableHeaderCount !== align.length) {
+      return nok(code)
+    }
 
-var fence$2 = /^ {0,3}([~`])\1{2,}/;
-var reasonIncorrect = 'Incorrect code language flag';
-var reasonMissing = 'Missing code language flag';
+    if (code === null) {
+      return tableClose(code)
+    }
 
-function fencedCodeFlag(tree, file, option) {
-  var contents = String(file);
-  var allowEmpty = false;
-  var allowed = [];
-  var flags = option;
+    return effects.check(
+      nextPrefixedOrBlank,
+      tableClose,
+      effects.attempt(
+        {
+          tokenize: tokenizeRowEnd,
+          partial: true
+        },
+        factorySpace(effects, bodyStart, 'linePrefix', 4),
+        tableClose
+      )
+    )(code)
+  }
+  /** @type {State} */
 
-  if (typeof flags === 'object' && !('length' in flags)) {
-    allowEmpty = Boolean(flags.allowEmpty);
-    flags = flags.flags;
+  function tableClose(code) {
+    effects.exit('table');
+    return ok(code)
   }
+  /** @type {State} */
 
-  if (typeof flags === 'object' && 'length' in flags) {
-    allowed = String(flags).split(',');
+  function bodyStart(code) {
+    effects.enter('tableBody');
+    return rowStartBody(code)
   }
+  /** @type {State} */
 
-  unistUtilVisit(tree, 'code', visitor);
+  function rowStartBody(code) {
+    effects.enter('tableRow'); // If we start with a pipe, we open a cell marker.
 
-  function visitor(node) {
-    var value;
+    if (code === 124) {
+      return cellDividerBody(code)
+    }
 
-    if (!unistUtilGenerated(node)) {
-      if (node.lang) {
-        if (allowed.length !== 0 && allowed.indexOf(node.lang) === -1) {
-          file.message(reasonIncorrect, node);
-        }
-      } else {
-        value = contents.slice(start$b(node).offset, end$7(node).offset);
+    effects.enter('temporaryTableCellContent'); // Can’t be space or eols at the start of a construct, so we’re in a cell.
 
-        if (!allowEmpty && fence$2.test(value)) {
-          file.message(reasonMissing, node);
-        }
-      }
-    }
+    return inCellContentBody(code)
   }
-}
+  /** @type {State} */
 
-var remarkLintFencedCodeMarker = unifiedLintRule('remark-lint:fenced-code-marker', fencedCodeMarker);
+  function cellDividerBody(code) {
+    effects.enter('tableCellDivider');
+    effects.consume(code);
+    effects.exit('tableCellDivider');
+    return cellBreakBody
+  }
+  /** @type {State} */
 
-var markers = {
-  '`': true,
-  '~': true,
-  null: true
-};
+  function cellBreakBody(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return atRowEndBody(code)
+    }
 
-function fencedCodeMarker(tree, file, option) {
-  var contents = String(file);
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null;
+    if (markdownSpace(code)) {
+      effects.enter('whitespace');
+      effects.consume(code);
+      return inWhitespaceBody
+    } // `|`
 
-  if (markers[preferred] !== true) {
-    file.fail(
-      'Incorrect fenced code marker `' +
-        preferred +
-        "`: use either `'consistent'`, `` '`' ``, or `'~'`"
-    );
-  }
+    if (code === 124) {
+      return cellDividerBody(code)
+    } // Anything else is cell content.
 
-  unistUtilVisit(tree, 'code', visitor);
+    effects.enter('temporaryTableCellContent');
+    return inCellContentBody(code)
+  }
+  /** @type {State} */
 
-  function visitor(node) {
-    var start;
-    var marker;
-    var label;
+  function inWhitespaceBody(code) {
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return inWhitespaceBody
+    }
 
-    if (!unistUtilGenerated(node)) {
-      start = unistUtilPosition.start(node).offset;
-      marker = contents
-        .slice(start, start + 4)
-        .replace(/^\s+/, '')
-        .charAt(0);
+    effects.exit('whitespace');
+    return cellBreakBody(code)
+  }
+  /** @type {State} */
 
-      // Ignore unfenced code blocks.
-      if (markers[marker] === true) {
-        if (preferred) {
-          if (marker !== preferred) {
-            label = preferred === '~' ? preferred : '` ` `';
-            file.message(
-              'Fenced code should use `' + label + '` as a marker',
-              node
-            );
-          }
-        } else {
-          preferred = marker;
-        }
-      }
+  function inCellContentBody(code) {
+    // EOF, whitespace, pipe
+    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {
+      effects.exit('temporaryTableCellContent');
+      return cellBreakBody(code)
     }
-  }
-}
 
-var remarkLintFileExtension = unifiedLintRule('remark-lint:file-extension', fileExtension);
+    effects.consume(code);
+    return code === 92 ? inCellContentEscapeBody : inCellContentBody
+  }
+  /** @type {State} */
 
-function fileExtension(tree, file, option) {
-  var ext = file.extname;
-  var preferred = typeof option === 'string' ? option : 'md';
+  function inCellContentEscapeBody(code) {
+    if (code === 92 || code === 124) {
+      effects.consume(code);
+      return inCellContentBody
+    } // Anything else.
 
-  if (ext && ext.slice(1) !== preferred) {
-    file.message('Incorrect extension: use `' + preferred + '`');
+    return inCellContentBody(code)
   }
-}
+  /** @type {State} */
 
-var remarkLintFinalDefinition = unifiedLintRule('remark-lint:final-definition', finalDefinition);
+  function atRowEndBody(code) {
+    effects.exit('tableRow');
 
-var start$c = unistUtilPosition.start;
+    if (code === null) {
+      return tableBodyClose(code)
+    }
 
-function finalDefinition(tree, file) {
-  var last = null;
+    return effects.check(
+      nextPrefixedOrBlank,
+      tableBodyClose,
+      effects.attempt(
+        {
+          tokenize: tokenizeRowEnd,
+          partial: true
+        },
+        factorySpace(effects, rowStartBody, 'linePrefix', 4),
+        tableBodyClose
+      )
+    )(code)
+  }
+  /** @type {State} */
 
-  unistUtilVisit(tree, visitor, true);
+  function tableBodyClose(code) {
+    effects.exit('tableBody');
+    return tableClose(code)
+  }
+  /** @type {Tokenizer} */
 
-  function visitor(node) {
-    var line = start$c(node).line;
+  function tokenizeRowEnd(effects, ok, nok) {
+    return start
+    /** @type {State} */
 
-    // Ignore generated nodes.
-    if (node.type === 'root' || unistUtilGenerated(node)) {
-      return
+    function start(code) {
+      effects.enter('lineEnding');
+      effects.consume(code);
+      effects.exit('lineEnding');
+      return lineStart
     }
+    /** @type {State} */
 
-    if (node.type === 'definition') {
-      if (last !== null && last > line) {
-        file.message(
-          'Move definitions to the end of the file (after the node at line `' +
-            last +
-            '`)',
-          node
-        );
-      }
-    } else if (last === null) {
-      last = line;
+    function lineStart(code) {
+      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
     }
   }
-}
+} // Based on micromark, but that won’t work as we’re in a table, and that expects
+// content.
+// <https://github.com/micromark/micromark/blob/main/lib/tokenize/setext-underline.js>
 
-var remarkLintFirstHeadingLevel = unifiedLintRule('remark-lint:first-heading-level', firstHeadingLevel);
+/** @type {Tokenizer} */
 
-var re$3 = /<h([1-6])/;
+function tokenizeSetextUnderlineMini(effects, ok, nok) {
+  return start
+  /** @type {State} */
 
-function firstHeadingLevel(tree, file, option) {
-  var preferred = option && option !== true ? option : 1;
+  function start(code) {
+    if (code !== 45) {
+      return nok(code)
+    }
 
-  unistUtilVisit(tree, visitor);
+    effects.enter('setextUnderline');
+    return sequence(code)
+  }
+  /** @type {State} */
 
-  function visitor(node) {
-    var rank;
+  function sequence(code) {
+    if (code === 45) {
+      effects.consume(code);
+      return sequence
+    }
 
-    if (!unistUtilGenerated(node)) {
-      if (node.type === 'heading') {
-        rank = node.depth;
-      } else if (node.type === 'html') {
-        rank = infer(node);
-      }
+    return whitespace(code)
+  }
+  /** @type {State} */
 
-      if (rank !== undefined) {
-        if (rank !== preferred) {
-          file.message(
-            'First heading level should be `' + preferred + '`',
-            node
-          );
-        }
+  function whitespace(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return ok(code)
+    }
 
-        return unistUtilVisit.EXIT
-      }
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return whitespace
     }
+
+    return nok(code)
   }
 }
+/** @type {Tokenizer} */
 
-function infer(node) {
-  var results = node.value.match(re$3);
-  return results ? Number(results[1]) : undefined
-}
+function tokenizeNextPrefixedOrBlank(effects, ok, nok) {
+  let size = 0;
+  return start
+  /** @type {State} */
 
-var remarkLintHeadingStyle = unifiedLintRule('remark-lint:heading-style', headingStyle);
+  function start(code) {
+    // This is a check, so we don’t care about tokens, but we open a bogus one
+    // so we’re valid.
+    effects.enter('check'); // EOL.
 
-var types$2 = ['atx', 'atx-closed', 'setext'];
+    effects.consume(code);
+    return whitespace
+  }
+  /** @type {State} */
 
-function headingStyle(tree, file, option) {
-  var preferred = types$2.indexOf(option) === -1 ? null : option;
+  function whitespace(code) {
+    if (code === -1 || code === 32) {
+      effects.consume(code);
+      size++;
+      return size === 4 ? ok : whitespace
+    } // EOF or whitespace
 
-  unistUtilVisit(tree, 'heading', visitor);
+    if (code === null || markdownLineEndingOrSpace(code)) {
+      return ok(code)
+    } // Anything else.
 
-  function visitor(node) {
-    if (!unistUtilGenerated(node)) {
-      if (preferred) {
-        if (mdastUtilHeadingStyle(node, preferred) !== preferred) {
-          file.message('Headings should use ' + preferred, node);
-        }
-      } else {
-        preferred = mdastUtilHeadingStyle(node, preferred);
-      }
-    }
+    return nok(code)
   }
 }
 
-var remarkLintMaximumLineLength = unifiedLintRule('remark-lint:maximum-line-length', maximumLineLength);
+/**
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').CompileContext} CompileContext
+ */
 
-var start$d = unistUtilPosition.start;
-var end$8 = unistUtilPosition.end;
+/**
+ * An opening or closing tag, followed by a case-insensitive specific tag name,
+ * followed by HTML whitespace, a greater than, or a slash.
+ */
+const reFlow =
+  /<(\/?)(iframe|noembed|noframes|plaintext|script|style|title|textarea|xmp)(?=[\t\n\f\r />])/gi;
 
-function maximumLineLength(tree, file, option) {
-  var preferred = typeof option === 'number' && !isNaN(option) ? option : 80;
-  var content = String(file);
-  var lines = content.split(/\r?\n/);
-  var length = lines.length;
-  var index = -1;
-  var lineLength;
+/**
+ * As HTML (text) parses tags separately (and v. strictly), we don’t need to be
+ * global.
+ */
+const reText = new RegExp('^' + reFlow.source, 'i');
 
-  // Note: JSX is from MDX: <https://github.com/mdx-js/specification>.
-  unistUtilVisit(tree, ['heading', 'table', 'code', 'definition', 'html', 'jsx'], ignore);
-  unistUtilVisit(tree, ['link', 'image', 'inlineCode'], inline);
+/** @type {HtmlExtension} */
+const gfmTagfilterHtml = {
+  exit: {
+    htmlFlowData(token) {
+      exitHtmlData.call(this, token, reFlow);
+    },
+    htmlTextData(token) {
+      exitHtmlData.call(this, token, reText);
+    }
+  }
+};
 
-  // Iterate over every line, and warn for violating lines.
-  while (++index < length) {
-    lineLength = lines[index].length;
+/**
+ * @this {CompileContext}
+ * @param {Token} token
+ * @param {RegExp} filter
+ */
+function exitHtmlData(token, filter) {
+  let value = this.sliceSerialize(token);
 
-    if (lineLength > preferred) {
-      file.message('Line must be at most ' + preferred + ' characters', {
-        line: index + 1,
-        column: lineLength + 1
-      });
-    }
+  if (this.options.allowDangerousHtml) {
+    value = value.replace(filter, '&lt;$1$2');
   }
 
-  // Finally, whitelist some inline spans, but only if they occur at or after
-  // the wrap.
-  // However, when they do, and there’s whitespace after it, they are not
-  // whitelisted.
-  function inline(node, pos, parent) {
-    var next = parent.children[pos + 1];
-    var initial;
-    var final;
+  this.raw(this.encode(value));
+}
 
-    /* istanbul ignore if - Nothing to whitelist when generated. */
-    if (unistUtilGenerated(node)) {
-      return
-    }
+/**
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ */
 
-    initial = start$d(node);
-    final = end$8(node);
+/** @type {HtmlExtension} */
+const gfmTaskListItemHtml = {
+  enter: {
+    taskListCheck() {
+      this.tag('<input ');
+    }
+  },
+  exit: {
+    taskListCheck() {
+      this.tag('disabled="" type="checkbox">');
+    },
 
-    // No whitelisting when starting after the border, or ending before it.
-    if (initial.column > preferred || final.column < preferred) {
-      return
+    taskListCheckValueChecked() {
+      this.tag('checked="" ');
     }
+  }
+};
 
-    // No whitelisting when there’s whitespace after the link.
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Previous} Previous
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+const tasklistCheck = {
+  tokenize: tokenizeTasklistCheck
+};
+const gfmTaskListItem = {
+  text: {
+    [91]: tasklistCheck
+  }
+};
+/** @type {Tokenizer} */
+
+function tokenizeTasklistCheck(effects, ok, nok) {
+  const self = this;
+  return open
+  /** @type {State} */
+
+  function open(code) {
     if (
-      next &&
-      start$d(next).line === initial.line &&
-      (!next.value || /^(.+?[ \t].+?)/.test(next.value))
+      // Exit if there’s stuff before.
+      self.previous !== null || // Exit if not in the first content that is the first child of a list
+      // item.
+      !self._gfmTasklistFirstContentOfListItem
     ) {
-      return
+      return nok(code)
     }
 
-    whitelist(initial.line - 1, final.line);
+    effects.enter('taskListCheck');
+    effects.enter('taskListCheckMarker');
+    effects.consume(code);
+    effects.exit('taskListCheckMarker');
+    return inside
   }
+  /** @type {State} */
 
-  function ignore(node) {
-    /* istanbul ignore else - Hard to test, as we only run this case on `position: true` */
-    if (!unistUtilGenerated(node)) {
-      whitelist(start$d(node).line - 1, end$8(node).line);
+  function inside(code) {
+    if (markdownSpace(code)) {
+      effects.enter('taskListCheckValueUnchecked');
+      effects.consume(code);
+      effects.exit('taskListCheckValueUnchecked');
+      return close
     }
+
+    if (code === 88 || code === 120) {
+      effects.enter('taskListCheckValueChecked');
+      effects.consume(code);
+      effects.exit('taskListCheckValueChecked');
+      return close
+    }
+
+    return nok(code)
   }
+  /** @type {State} */
 
-  // Whitelist from `initial` to `final`, zero-based.
-  function whitelist(initial, final) {
-    while (initial < final) {
-      lines[initial++] = '';
+  function close(code) {
+    if (code === 93) {
+      effects.enter('taskListCheckMarker');
+      effects.consume(code);
+      effects.exit('taskListCheckMarker');
+      effects.exit('taskListCheck');
+      return effects.check(
+        {
+          tokenize: spaceThenNonSpace
+        },
+        ok,
+        nok
+      )
     }
+
+    return nok(code)
   }
 }
+/** @type {Tokenizer} */
 
-var remarkLintNoConsecutiveBlankLines = unifiedLintRule(
-  'remark-lint:no-consecutive-blank-lines',
-  noConsecutiveBlankLines
-);
+function spaceThenNonSpace(effects, ok, nok) {
+  const self = this;
+  return factorySpace(effects, after, 'whitespace')
+  /** @type {State} */
 
-function noConsecutiveBlankLines(tree, file) {
-  unistUtilVisit(tree, visitor);
+  function after(code) {
+    const tail = self.events[self.events.length - 1];
+    return tail &&
+      tail[1].type === 'whitespace' &&
+      code !== null &&
+      !markdownLineEndingOrSpace(code)
+      ? ok(code)
+      : nok(code)
+  }
+}
 
-  function visitor(node) {
-    var children = node.children;
-    var head;
-    var tail;
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options
+ */
 
-    if (!unistUtilGenerated(node) && children) {
-      head = children[0];
+/**
+ * Support GFM or markdown on github.com.
+ *
+ * @param {Options} [options]
+ * @returns {Extension}
+ */
+function gfm(options) {
+  return combineExtensions([
+    gfmAutolinkLiteral,
+    gfmStrikethrough(options),
+    gfmTable,
+    gfmTaskListItem
+  ])
+}
+
+/** @type {HtmlExtension} */
+combineHtmlExtensions([
+  gfmAutolinkLiteralHtml,
+  gfmStrikethroughHtml,
+  gfmTableHtml,
+  gfmTagfilterHtml,
+  gfmTaskListItemHtml
+]);
 
-      if (head && !unistUtilGenerated(head)) {
-        // Compare parent and first child.
-        compare(unistUtilPosition.start(node), unistUtilPosition.start(head), 0);
+/**
+ * Get the total count of `character` in `value`.
+ *
+ * @param {any} value Content, coerced to string
+ * @param {string} character Single character to look for
+ * @return {number} Number of times `character` occurred in `value`.
+ */
+function ccount(value, character) {
+  var source = String(value);
+  var count = 0;
+  var index;
 
-        // Compare between each child.
-        children.forEach(visitChild);
+  if (typeof character !== 'string') {
+    throw new Error('Expected character')
+  }
 
-        tail = children[children.length - 1];
+  index = source.indexOf(character);
 
-        // Compare parent and last child.
-        if (tail !== head && !unistUtilGenerated(tail)) {
-          compare(unistUtilPosition.end(node), unistUtilPosition.end(tail), 1);
-        }
-      }
-    }
+  while (index !== -1) {
+    count++;
+    index = source.indexOf(character, index + character.length);
   }
 
-  // Compare the difference between `start` and `end`, and warn when that
-  // difference exceeds `max`.
-  function compare(start, end, max) {
-    var diff = end.line - start.line;
-    var lines = Math.abs(diff) - max;
-    var reason;
+  return count
+}
 
-    if (lines > 0) {
-      reason =
-        'Remove ' +
-        lines +
-        ' ' +
-        pluralize('line', Math.abs(lines)) +
-        ' ' +
-        (diff > 0 ? 'before' : 'after') +
-        ' node';
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+function color(d) {
+  return '\u001B[33m' + d + '\u001B[39m'
+}
 
-      file.message(reason, end);
-    }
-  }
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist-util-is').Test} Test
+ */
 
-  function visitChild(child, index, all) {
-    var previous = all[index - 1];
-    var max = 2;
+/**
+ * Continue traversing as normal
+ */
+const CONTINUE = true;
+/**
+ * Do not traverse this node’s children
+ */
+const SKIP = 'skip';
+/**
+ * Stop traversing immediately
+ */
+const EXIT = false;
 
-    if (previous && !unistUtilGenerated(previous) && !unistUtilGenerated(child)) {
-      if (
-        (previous.type === 'list' && child.type === 'list') ||
-        (child.type === 'code' && previous.type === 'list' && !child.lang)
-      ) {
-        max++;
-      }
+const visitParents =
+  /**
+   * @type {(
+   *   (<T extends Node>(tree: Node, test: T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>>, visitor: Visitor<T>, reverse?: boolean) => void) &
+   *   ((tree: Node, test: Test, visitor: Visitor<Node>, reverse?: boolean) => void) &
+   *   ((tree: Node, visitor: Visitor<Node>, reverse?: boolean) => void)
+   * )}
+   */
+  (
+    /**
+     * Visit children of tree which pass a test
+     *
+     * @param {Node} tree Abstract syntax tree to walk
+     * @param {Test} test test Test node
+     * @param {Visitor<Node>} visitor Function to run for each node
+     * @param {boolean} [reverse] Fisit the tree in reverse, defaults to false
+     */
+    function (tree, test, visitor, reverse) {
+      if (typeof test === 'function' && typeof visitor !== 'function') {
+        reverse = visitor;
+        // @ts-ignore no visitor given, so `visitor` is test.
+        visitor = test;
+        test = null;
+      }
+
+      var is = convert(test);
+      var step = reverse ? -1 : 1;
+
+      factory(tree, null, [])();
+
+      /**
+       * @param {Node} node
+       * @param {number?} index
+       * @param {Array.<Parent>} parents
+       */
+      function factory(node, index, parents) {
+        /** @type {Object.<string, unknown>} */
+        var value = typeof node === 'object' && node !== null ? node : {};
+        /** @type {string} */
+        var name;
+
+        if (typeof value.type === 'string') {
+          name =
+            typeof value.tagName === 'string'
+              ? value.tagName
+              : typeof value.name === 'string'
+              ? value.name
+              : undefined;
+
+          Object.defineProperty(visit, 'name', {
+            value:
+              'node (' +
+              color(value.type + (name ? '<' + name + '>' : '')) +
+              ')'
+          });
+        }
 
-      compare(unistUtilPosition.end(previous), unistUtilPosition.start(child), max);
-    }
-  }
-}
+        return visit
 
-var remarkLintNoFileNameArticles = unifiedLintRule('remark-lint:no-file-name-articles', noFileNameArticles);
+        function visit() {
+          /** @type {ActionTuple} */
+          var result = [];
+          /** @type {ActionTuple} */
+          var subresult;
+          /** @type {number} */
+          var offset;
+          /** @type {Array.<Parent>} */
+          var grandparents;
 
-function noFileNameArticles(tree, file) {
-  var match = file.stem && file.stem.match(/^(the|teh|an?)\b/i);
+          if (!test || is(node, index, parents[parents.length - 1] || null)) {
+            result = toResult(visitor(node, parents));
 
-  if (match) {
-    file.message('Do not start file names with `' + match[0] + '`');
-  }
-}
+            if (result[0] === EXIT) {
+              return result
+            }
+          }
 
-var remarkLintNoFileNameConsecutiveDashes = unifiedLintRule(
-  'remark-lint:no-file-name-consecutive-dashes',
-  noFileNameConsecutiveDashes
-);
+          if (node.children && result[0] !== SKIP) {
+            // @ts-ignore looks like a parent.
+            offset = (reverse ? node.children.length : -1) + step;
+            // @ts-ignore looks like a parent.
+            grandparents = parents.concat(node);
 
-var reason$b = 'Do not use consecutive dashes in a file name';
+            // @ts-ignore looks like a parent.
+            while (offset > -1 && offset < node.children.length) {
+              subresult = factory(node.children[offset], offset, grandparents)();
 
-function noFileNameConsecutiveDashes(tree, file) {
-  if (file.stem && /-{2,}/.test(file.stem)) {
-    file.message(reason$b);
-  }
-}
+              if (subresult[0] === EXIT) {
+                return subresult
+              }
 
-var remarkLintNoFileNameOuterDashes = unifiedLintRule(
-  'remark-lint:no-file-name-outer-dashes',
-  noFileNameOuterDashes
-);
+              offset =
+                typeof subresult[1] === 'number' ? subresult[1] : offset + step;
+            }
+          }
+
+          return result
+        }
+      }
+    }
+  );
 
-var reason$c = 'Do not use initial or final dashes in a file name';
+/**
+ * @param {VisitorResult} value
+ * @returns {ActionTuple}
+ */
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value
+  }
 
-function noFileNameOuterDashes(tree, file) {
-  if (file.stem && /^-|-$/.test(file.stem)) {
-    file.message(reason$c);
+  if (typeof value === 'number') {
+    return [CONTINUE, value]
   }
+
+  return [value]
 }
 
-var remarkLintNoHeadingIndent = unifiedLintRule('remark-lint:no-heading-indent', noHeadingIndent);
+/**
+ * @typedef Options Configuration.
+ * @property {Test} [ignore] `unist-util-is` test used to assert parents
+ *
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast').Content} Content
+ * @typedef {import('mdast').PhrasingContent} PhrasingContent
+ * @typedef {import('mdast').Text} Text
+ * @typedef {Content|Root} Node
+ * @typedef {Extract<Node, import('mdast').Parent>} Parent
+ *
+ * @typedef {import('unist-util-visit-parents').Test} Test
+ * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
+ *
+ * @typedef RegExpMatchObject
+ * @property {number} index
+ * @property {string} input
+ *
+ * @typedef {string|RegExp} Find
+ * @typedef {string|ReplaceFunction} Replace
+ *
+ * @typedef {[Find, Replace]} FindAndReplaceTuple
+ * @typedef {Object.<string, Replace>} FindAndReplaceSchema
+ * @typedef {Array.<FindAndReplaceTuple>} FindAndReplaceList
+ *
+ * @typedef {[RegExp, ReplaceFunction]} Pair
+ * @typedef {Array.<Pair>} Pairs
+ */
 
-var start$e = unistUtilPosition.start;
+const own = {}.hasOwnProperty;
 
-function noHeadingIndent(tree, file) {
-  var contents = String(file);
-  var length = contents.length;
+/**
+ * @param tree mdast tree
+ * @param find Value to find and remove. When `string`, escaped and made into a global `RegExp`
+ * @param [replace] Value to insert.
+ *   * When `string`, turned into a Text node.
+ *   * When `Function`, called with the results of calling `RegExp.exec` as
+ *     arguments, in which case it can return a single or a list of `Node`,
+ *     a `string` (which is wrapped in a `Text` node), or `false` to not replace
+ * @param [options] Configuration.
+ */
+const findAndReplace =
+  /**
+   * @type {(
+   *   ((tree: Node, find: Find, replace?: Replace, options?: Options) => Node) &
+   *   ((tree: Node, schema: FindAndReplaceSchema|FindAndReplaceList, options?: Options) => Node)
+   * )}
+   **/
+  (
+    /**
+     * @param {Node} tree
+     * @param {Find|FindAndReplaceSchema|FindAndReplaceList} find
+     * @param {Replace|Options} [replace]
+     * @param {Options} [options]
+     */
+    function (tree, find, replace, options) {
+      /** @type {Options|undefined} */
+      let settings;
+      /** @type {FindAndReplaceSchema|FindAndReplaceList} */
+      let schema;
+
+      if (typeof find === 'string' || find instanceof RegExp) {
+        // @ts-expect-error don’t expect options twice.
+        schema = [[find, replace]];
+        settings = options;
+      } else {
+        schema = find;
+        // @ts-expect-error don’t expect replace twice.
+        settings = replace;
+      }
 
-  unistUtilVisit(tree, 'heading', visitor);
+      if (!settings) {
+        settings = {};
+      }
 
-  function visitor(node) {
-    var initial;
-    var begin;
-    var index;
-    var character;
-    var diff;
+      const ignored = convert(settings.ignore || []);
+      const pairs = toPairs(schema);
+      let pairIndex = -1;
 
-    if (unistUtilGenerated(node)) {
-      return
-    }
+      while (++pairIndex < pairs.length) {
+        visitParents(tree, 'text', visitor);
+      }
 
-    initial = start$e(node);
-    begin = initial.offset;
-    index = begin - 1;
+      return tree
 
-    while (++index < length) {
-      character = contents.charAt(index);
+      /** @type {import('unist-util-visit-parents').Visitor<Text>} */
+      function visitor(node, parents) {
+        let index = -1;
+        /** @type {Parent|undefined} */
+        let grandparent;
 
-      if (character !== ' ' && character !== '\t') {
-        break
-      }
-    }
+        while (++index < parents.length) {
+          const parent = /** @type {Parent} */ (parents[index]);
 
-    diff = index - begin;
+          if (
+            ignored(
+              parent,
+              // @ts-expect-error mdast vs. unist parent.
+              grandparent ? grandparent.children.indexOf(parent) : undefined,
+              grandparent
+            )
+          ) {
+            return
+          }
 
-    if (diff) {
-      file.message(
-        'Remove ' + diff + ' ' + pluralize('space', diff) + ' before this heading',
-        {
-          line: initial.line,
-          column: initial.column + diff
+          grandparent = parent;
         }
-      );
-    }
-  }
-}
 
-var start$f = unistUtilPosition.start;
+        if (grandparent) {
+          return handler(node, grandparent)
+        }
+      }
 
+      /**
+       * @param {Text} node
+       * @param {Parent} parent
+       * @returns {VisitorResult}
+       */
+      function handler(node, parent) {
+        const find = pairs[pairIndex][0];
+        const replace = pairs[pairIndex][1];
+        let start = 0;
+        // @ts-expect-error: TS is wrong, some of these children can be text.
+        let index = parent.children.indexOf(node);
+        /** @type {Array.<PhrasingContent>} */
+        let nodes = [];
+        /** @type {number|undefined} */
+        let position;
 
+        find.lastIndex = 0;
 
-var remarkLintNoMultipleToplevelHeadings = unifiedLintRule(
-  'remark-lint:no-multiple-toplevel-headings',
-  noMultipleToplevelHeadings
-);
+        let match = find.exec(node.value);
 
-function noMultipleToplevelHeadings(tree, file, option) {
-  var preferred = option || 1;
-  var duplicate;
+        while (match) {
+          position = match.index;
+          // @ts-expect-error this is perfectly fine, typescript.
+          let value = replace(...match, {
+            index: match.index,
+            input: match.input
+          });
 
-  unistUtilVisit(tree, 'heading', visitor);
+          if (typeof value === 'string') {
+            value = value.length > 0 ? {type: 'text', value} : undefined;
+          }
 
-  function visitor(node) {
-    if (!unistUtilGenerated(node) && node.depth === preferred) {
-      if (duplicate) {
-        file.message(
-          'Don’t use multiple top level headings (' + duplicate + ')',
-          node
-        );
-      } else {
-        duplicate = unistUtilStringifyPosition(start$f(node));
-      }
-    }
-  }
-}
+          if (value !== false) {
+            if (start !== position) {
+              nodes.push({
+                type: 'text',
+                value: node.value.slice(start, position)
+              });
+            }
 
-var remarkLintNoShellDollars = unifiedLintRule('remark-lint:no-shell-dollars', noShellDollars);
+            if (Array.isArray(value)) {
+              nodes.push(...value);
+            } else if (value) {
+              nodes.push(value);
+            }
 
-var reason$d = 'Do not use dollar signs before shell commands';
+            start = position + match[0].length;
+          }
 
-// List of shell script file extensions (also used as code flags for syntax
-// highlighting on GitHub):
-// See: <https://github.com/github/linguist/blob/40992ba/lib/linguist/languages.yml#L4984>
-var flags = [
-  'sh',
-  'bash',
-  'bats',
-  'cgi',
-  'command',
-  'fcgi',
-  'ksh',
-  'tmux',
-  'tool',
-  'zsh'
-];
+          if (!find.global) {
+            break
+          }
 
-function noShellDollars(tree, file) {
-  unistUtilVisit(tree, 'code', visitor);
+          match = find.exec(node.value);
+        }
 
-  function visitor(node) {
-    var lines;
-    var line;
-    var length;
-    var index;
+        if (position === undefined) {
+          nodes = [node];
+          index--;
+        } else {
+          if (start < node.value.length) {
+            nodes.push({type: 'text', value: node.value.slice(start)});
+          }
 
-    // Check both known shell code and unknown code.
-    if (!unistUtilGenerated(node) && node.lang && flags.indexOf(node.lang) !== -1) {
-      lines = node.value.split('\n').filter(notEmpty);
-      length = lines.length;
-      index = -1;
+          parent.children.splice(index, 1, ...nodes);
+        }
 
-      if (length === 0) {
-        return
+        return index + nodes.length + 1
       }
+    }
+  );
+
+/**
+ * @param {FindAndReplaceSchema|FindAndReplaceList} schema
+ * @returns {Pairs}
+ */
+function toPairs(schema) {
+  /** @type {Pairs} */
+  const result = [];
 
-      while (++index < length) {
-        line = lines[index];
+  if (typeof schema !== 'object') {
+    throw new TypeError('Expected array or object as schema')
+  }
 
-        if (line.trim() && !line.match(/^\s*\$\s*/)) {
-          return
-        }
-      }
+  if (Array.isArray(schema)) {
+    let index = -1;
 
-      file.message(reason$d, node);
+    while (++index < schema.length) {
+      result.push([
+        toExpression(schema[index][0]),
+        toFunction(schema[index][1])
+      ]);
     }
-  }
+  } else {
+    /** @type {string} */
+    let key;
 
-  function notEmpty(line) {
-    return line.trim().length !== 0
+    for (key in schema) {
+      if (own.call(schema, key)) {
+        result.push([toExpression(key), toFunction(schema[key])]);
+      }
+    }
   }
-}
-
-var remarkLintNoTableIndentation = unifiedLintRule('remark-lint:no-table-indentation', noTableIndentation);
 
-var reason$e = 'Do not indent table rows';
+  return result
+}
 
-function noTableIndentation(tree, file) {
-  var contents = String(file);
+/**
+ * @param {Find} find
+ * @returns {RegExp}
+ */
+function toExpression(find) {
+  return typeof find === 'string' ? new RegExp(escapeStringRegexp(find), 'g') : find
+}
 
-  unistUtilVisit(tree, 'table', visitor);
+/**
+ * @param {Replace} replace
+ * @returns {ReplaceFunction}
+ */
+function toFunction(replace) {
+  return typeof replace === 'function' ? replace : () => replace
+}
 
-  function visitor(node) {
-    if (!unistUtilGenerated(node)) {
-      node.children.forEach(each);
-    }
+/**
+ * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+ * @typedef {import('mdast-util-from-markdown').Transform} FromMarkdownTransform
+ * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+ * @typedef {import('mdast-util-to-markdown/lib/types.js').Options} ToMarkdownExtension
+ * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction
+ * @typedef {import('mdast-util-find-and-replace').RegExpMatchObject} RegExpMatchObject
+ * @typedef {import('mdast-util-find-and-replace').PhrasingContent} PhrasingContent
+ */
 
-    return unistUtilVisit.SKIP
+const inConstruct = 'phrasing';
+const notInConstruct = ['autolink', 'link', 'image', 'label'];
+
+/** @type {FromMarkdownExtension} */
+const gfmAutolinkLiteralFromMarkdown = {
+  transforms: [transformGfmAutolinkLiterals],
+  enter: {
+    literalAutolink: enterLiteralAutolink,
+    literalAutolinkEmail: enterLiteralAutolinkValue,
+    literalAutolinkHttp: enterLiteralAutolinkValue,
+    literalAutolinkWww: enterLiteralAutolinkValue
+  },
+  exit: {
+    literalAutolink: exitLiteralAutolink,
+    literalAutolinkEmail: exitLiteralAutolinkEmail,
+    literalAutolinkHttp: exitLiteralAutolinkHttp,
+    literalAutolinkWww: exitLiteralAutolinkWww
   }
+};
 
-  function each(row) {
-    var fence = contents.slice(
-      unistUtilPosition.start(row).offset,
-      unistUtilPosition.start(row.children[0]).offset
-    );
+/** @type {ToMarkdownExtension} */
+const gfmAutolinkLiteralToMarkdown = {
+  unsafe: [
+    {
+      character: '@',
+      before: '[+\\-.\\w]',
+      after: '[\\-.\\w]',
+      inConstruct,
+      notInConstruct
+    },
+    {
+      character: '.',
+      before: '[Ww]',
+      after: '[\\-.\\w]',
+      inConstruct,
+      notInConstruct
+    },
+    {character: ':', before: '[ps]', after: '\\/', inConstruct, notInConstruct}
+  ]
+};
 
-    if (fence.indexOf('|') > 1) {
-      file.message(reason$e, row);
-    }
-  }
+/** @type {FromMarkdownHandle} */
+function enterLiteralAutolink(token) {
+  // @ts-expect-error: `null` is fine.
+  this.enter({type: 'link', title: null, url: '', children: []}, token);
 }
 
-var remarkLintNoTabs = unifiedLintRule('remark-lint:no-tabs', noTabs);
+/** @type {FromMarkdownHandle} */
+function enterLiteralAutolinkValue(token) {
+  this.config.enter.autolinkProtocol.call(this, token);
+}
 
-var reason$f = 'Use spaces instead of tabs';
+/** @type {FromMarkdownHandle} */
+function exitLiteralAutolinkHttp(token) {
+  this.config.exit.autolinkProtocol.call(this, token);
+}
 
-function noTabs(tree, file) {
-  var content = String(file);
-  var position = vfileLocation(file).toPosition;
-  var index = content.indexOf('\t');
+/** @type {FromMarkdownHandle} */
+function exitLiteralAutolinkWww(token) {
+  this.config.exit.data.call(this, token);
+  this.stack[this.stack.length - 1].url = 'http://' + this.sliceSerialize(token);
+}
 
-  while (index !== -1) {
-    file.message(reason$f, position(index));
-    index = content.indexOf('\t', index + 1);
-  }
+/** @type {FromMarkdownHandle} */
+function exitLiteralAutolinkEmail(token) {
+  this.config.exit.autolinkEmail.call(this, token);
+}
+
+/** @type {FromMarkdownHandle} */
+function exitLiteralAutolink(token) {
+  this.exit(token);
 }
 
-var remarkLintNoTrailingSpaces = unifiedLintRule('remark-lint:no-trailing-spaces', noTrailingSpaces);
+/** @type {FromMarkdownTransform} */
+function transformGfmAutolinkLiterals(tree) {
+  findAndReplace(
+    tree,
+    [
+      [/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/i, findUrl],
+      [/([-.\w+]+)@([-\w]+(?:\.[-\w]+)+)/, findEmail]
+    ],
+    {ignore: ['link', 'linkReference']}
+  );
+}
 
 /**
- * Lines that are just space characters are not present in
- * the AST, which is why we loop through lines manually.
+ * @type {ReplaceFunction}
+ * @param {string} _
+ * @param {string} protocol
+ * @param {string} domain
+ * @param {string} path
+ * @param {RegExpMatchObject} match
  */
+// eslint-disable-next-line max-params
+function findUrl(_, protocol, domain, path, match) {
+  let prefix = '';
 
-function noTrailingSpaces(ast, file) {
-  var lines = file.toString().split(/\r?\n/);
-  for (var i = 0; i < lines.length; i++) {
-    var currentLine = lines[i];
-    var lineIndex = i + 1;
-    if (/\s$/.test(currentLine)) {
-      file.message('Remove trailing whitespace', {
-        position: {
-          start: { line: lineIndex, column: currentLine.length + 1 },
-          end: { line: lineIndex }
-        }
-      });
-    }
+  // Not an expected previous character.
+  if (!previous(match)) {
+    return false
   }
-}
 
-var escapeStringRegexp$1 = string => {
-	if (typeof string !== 'string') {
-		throw new TypeError('Expected a string');
-	}
+  // Treat `www` as part of the domain.
+  if (/^w/i.test(protocol)) {
+    domain = protocol + domain;
+    protocol = '';
+    prefix = 'http://';
+  }
 
-	// Escape characters with special meaning either inside or outside character sets.
-	// Use a simple backslash escape when it’s always valid, and a \unnnn escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
-	return string
-		.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
-		.replace(/-/g, '\\x2d');
-};
+  if (!isCorrectDomain(domain)) {
+    return false
+  }
 
-const start$g = unistUtilPosition.start;
+  const parts = splitUrl(domain + path);
 
-var remarkLintProhibitedStrings = unifiedLintRule('remark-lint:prohibited-strings', prohibitedStrings);
+  if (!parts[0]) return false
 
-function testProhibited (val, content) {
-  let regexpFlags = 'g';
-  let no = val.no;
+  /** @type {PhrasingContent} */
+  // @ts-expect-error: `null` is fine.
+  const result = {
+    type: 'link',
+    title: null,
+    url: prefix + protocol + parts[0],
+    children: [{type: 'text', value: protocol + parts[0]}]
+  };
 
-  if (!no) {
-    no = escapeStringRegexp$1(val.yes);
-    regexpFlags += 'i';
+  if (parts[1]) {
+    return [result, {type: 'text', value: parts[1]}]
   }
 
-  let regexpString = '(?<!\\.|@[a-zA-Z0-9/-]*)';
-
-  const ignoreNextTo = val.ignoreNextTo ? escapeStringRegexp$1(val.ignoreNextTo) : '';
+  return result
+}
 
-  // If it starts with a letter, make sure it is a word break.
-  if (/^\b/.test(no)) {
-    regexpString += '\\b';
+/**
+ * @type {ReplaceFunction}
+ * @param {string} _
+ * @param {string} atext
+ * @param {string} label
+ * @param {RegExpMatchObject} match
+ */
+function findEmail(_, atext, label, match) {
+  // Not an expected previous character.
+  if (!previous(match, true) || /[_-]$/.test(label)) {
+    return false
   }
-  if (ignoreNextTo) {
-    regexpString += `(?<!${ignoreNextTo})`;
+
+  return {
+    type: 'link',
+    // @ts-expect-error: `null` is fine.
+    title: null,
+    url: 'mailto:' + atext + '@' + label,
+    children: [{type: 'text', value: atext + '@' + label}]
   }
+}
 
-  regexpString += `(${no})`;
+/**
+ * @param {string} domain
+ * @returns {boolean}
+ */
+function isCorrectDomain(domain) {
+  const parts = domain.split('.');
 
-  if (ignoreNextTo) {
-    regexpString += `(?!${ignoreNextTo})`;
+  if (
+    parts.length < 2 ||
+    (parts[parts.length - 1] &&
+      (/_/.test(parts[parts.length - 1]) ||
+        !/[a-zA-Z\d]/.test(parts[parts.length - 1]))) ||
+    (parts[parts.length - 2] &&
+      (/_/.test(parts[parts.length - 2]) ||
+        !/[a-zA-Z\d]/.test(parts[parts.length - 2])))
+  ) {
+    return false
   }
 
-  // If it ends with a letter, make sure it is a word break.
-  if (/\b$/.test(no)) {
-    regexpString += '\\b';
-  }
-  regexpString += '(?!\\.\\w)';
-  const re = new RegExp(regexpString, regexpFlags);
+  return true
+}
 
-  const results = [];
-  let result = re.exec(content);
-  while (result) {
-    if (result[1] !== val.yes) {
-      results.push({ result: result[1], index: result.index });
+/**
+ * @param {string} url
+ * @returns {[string, string|undefined]}
+ */
+function splitUrl(url) {
+  const trailExec = /[!"&'),.:;<>?\]}]+$/.exec(url);
+  /** @type {number} */
+  let closingParenIndex;
+  /** @type {number} */
+  let openingParens;
+  /** @type {number} */
+  let closingParens;
+  /** @type {string|undefined} */
+  let trail;
+
+  if (trailExec) {
+    url = url.slice(0, trailExec.index);
+    trail = trailExec[0];
+    closingParenIndex = trail.indexOf(')');
+    openingParens = ccount(url, '(');
+    closingParens = ccount(url, ')');
+
+    while (closingParenIndex !== -1 && openingParens > closingParens) {
+      url += trail.slice(0, closingParenIndex + 1);
+      trail = trail.slice(closingParenIndex + 1);
+      closingParenIndex = trail.indexOf(')');
+      closingParens++;
     }
-    result = re.exec(content);
   }
 
-  return results
+  return [url, trail]
 }
 
-function prohibitedStrings (ast, file, strings) {
-  const location = vfileLocation(file);
+/**
+ * @param {RegExpMatchObject} match
+ * @param {boolean} [email=false]
+ * @returns {boolean}
+ */
+function previous(match, email) {
+  const code = match.input.charCodeAt(match.index - 1);
 
-  unistUtilVisit(ast, 'text', checkText);
+  return (
+    (match.index === 0 ||
+      unicodeWhitespace(code) ||
+      unicodePunctuation(code)) &&
+    (!email || code !== 47)
+  )
+}
 
-  function checkText (node) {
-    const content = node.value;
-    const initial = start$g(node).offset;
+/**
+ * @typedef {import('mdast').Delete} Delete
+ * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+ * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+ * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+ * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+ */
 
-    strings.forEach((val) => {
-      const results = testProhibited(val, content);
-      if (results.length) {
-        results.forEach(({ result, index }) => {
-          const message = val.yes ? `Use "${val.yes}" instead of "${result}"` : `Do not use "${result}"`;
-          file.message(message, {
-            start: location.toPosition(initial + index),
-            end: location.toPosition(initial + index + [...result].length)
-          });
-        });
-      }
-    });
-  }
-}
+/** @type {FromMarkdownExtension} */
+const gfmStrikethroughFromMarkdown = {
+  canContainEols: ['delete'],
+  enter: {strikethrough: enterStrikethrough},
+  exit: {strikethrough: exitStrikethrough}
+};
 
-var rule = unifiedLintRule;
+/** @type {ToMarkdownExtension} */
+const gfmStrikethroughToMarkdown = {
+  unsafe: [{character: '~', inConstruct: 'phrasing'}],
+  handlers: {delete: handleDelete}
+};
 
+handleDelete.peek = peekDelete;
 
+/** @type {FromMarkdownHandle} */
+function enterStrikethrough(token) {
+  this.enter({type: 'delete', children: []}, token);
+}
+
+/** @type {FromMarkdownHandle} */
+function exitStrikethrough(token) {
+  this.exit(token);
+}
 
+/**
+ * @type {ToMarkdownHandle}
+ * @param {Delete} node
+ */
+function handleDelete(node, _, context) {
+  const exit = context.enter('emphasis');
+  const value = containerPhrasing(node, context, {before: '~', after: '~'});
+  exit();
+  return '~~' + value + '~~'
+}
 
-var remarkLintRuleStyle = rule('remark-lint:rule-style', ruleStyle);
+/** @type {ToMarkdownHandle} */
+function peekDelete() {
+  return '~'
+}
 
-var start$h = unistUtilPosition.start;
-var end$9 = unistUtilPosition.end;
+/**
+ * @typedef MarkdownTableOptions
+ * @property {string|null|Array.<string|null|undefined>} [align]
+ * @property {boolean} [padding=true]
+ * @property {boolean} [delimiterStart=true]
+ * @property {boolean} [delimiterStart=true]
+ * @property {boolean} [delimiterEnd=true]
+ * @property {boolean} [alignDelimiters=true]
+ * @property {(value: string) => number} [stringLength]
+ */
 
-function ruleStyle(tree, file, option) {
-  var contents = String(file);
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null;
+/**
+ * Create a table from a matrix of strings.
+ *
+ * @param {Array.<Array.<string|null|undefined>>} table
+ * @param {MarkdownTableOptions} [options]
+ * @returns {string}
+ */
+function markdownTable(table, options) {
+  const settings = options || {};
+  const align = (settings.align || []).concat();
+  const stringLength = settings.stringLength || defaultStringLength;
+  /** @type {number[]} Character codes as symbols for alignment per column. */
+  const alignments = [];
+  let rowIndex = -1;
+  /** @type {string[][]} Cells per row. */
+  const cellMatrix = [];
+  /** @type {number[][]} Sizes of each cell per row. */
+  const sizeMatrix = [];
+  /** @type {number[]} */
+  const longestCellByColumn = [];
+  let mostCellsPerRow = 0;
+  /** @type {number} */
+  let columnIndex;
+  /** @type {string[]} Cells of current row */
+  let row;
+  /** @type {number[]} Sizes of current row */
+  let sizes;
+  /** @type {number} Sizes of current cell */
+  let size;
+  /** @type {string} Current cell */
+  let cell;
+  /** @type {string[]} Chunks of current line. */
+  let line;
+  /** @type {string} */
+  let before;
+  /** @type {string} */
+  let after;
+  /** @type {number} */
+  let code;
 
-  if (preferred !== null && /[^-_* ]/.test(preferred)) {
-    file.fail(
-      "Incorrect preferred rule style: provide a correct markdown rule or `'consistent'`"
-    );
-  }
+  // This is a superfluous loop if we don’t align delimiters, but otherwise we’d
+  // do superfluous work when aligning, so optimize for aligning.
+  while (++rowIndex < table.length) {
+    columnIndex = -1;
+    row = [];
+    sizes = [];
 
-  unistUtilVisit(tree, 'thematicBreak', visitor);
+    if (table[rowIndex].length > mostCellsPerRow) {
+      mostCellsPerRow = table[rowIndex].length;
+    }
 
-  function visitor(node) {
-    var initial = start$h(node).offset;
-    var final = end$9(node).offset;
-    var rule;
+    while (++columnIndex < table[rowIndex].length) {
+      cell = serialize(table[rowIndex][columnIndex]);
 
-    if (!unistUtilGenerated(node)) {
-      rule = contents.slice(initial, final);
+      if (settings.alignDelimiters !== false) {
+        size = stringLength(cell);
+        sizes[columnIndex] = size;
 
-      if (preferred) {
-        if (rule !== preferred) {
-          file.message('Rules should use `' + preferred + '`', node);
+        if (
+          longestCellByColumn[columnIndex] === undefined ||
+          size > longestCellByColumn[columnIndex]
+        ) {
+          longestCellByColumn[columnIndex] = size;
         }
-      } else {
-        preferred = rule;
       }
+
+      row.push(cell);
     }
-  }
-}
 
-var remarkLintStrongMarker = unifiedLintRule('remark-lint:strong-marker', strongMarker);
+    cellMatrix[rowIndex] = row;
+    sizeMatrix[rowIndex] = sizes;
+  }
 
-var markers$1 = {'*': true, _: true, null: true};
+  // Figure out which alignments to use.
+  columnIndex = -1;
 
-function strongMarker(tree, file, option) {
-  var contents = String(file);
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null;
+  if (typeof align === 'object' && 'length' in align) {
+    while (++columnIndex < mostCellsPerRow) {
+      alignments[columnIndex] = toAlignment(align[columnIndex]);
+    }
+  } else {
+    code = toAlignment(align);
 
-  if (markers$1[preferred] !== true) {
-    file.fail(
-      'Incorrect strong marker `' +
-        preferred +
-        "`: use either `'consistent'`, `'*'`, or `'_'`"
-    );
+    while (++columnIndex < mostCellsPerRow) {
+      alignments[columnIndex] = code;
+    }
   }
 
-  unistUtilVisit(tree, 'strong', visitor);
+  // Inject the alignment row.
+  columnIndex = -1;
+  row = [];
+  sizes = [];
+
+  while (++columnIndex < mostCellsPerRow) {
+    code = alignments[columnIndex];
+    before = '';
+    after = '';
 
-  function visitor(node) {
-    var marker = contents.charAt(unistUtilPosition.start(node).offset);
+    if (code === 99 /* `c` */) {
+      before = ':';
+      after = ':';
+    } else if (code === 108 /* `l` */) {
+      before = ':';
+    } else if (code === 114 /* `r` */) {
+      after = ':';
+    }
 
-    if (!unistUtilGenerated(node)) {
-      if (preferred) {
-        if (marker !== preferred) {
-          file.message(
-            'Strong should use `' + preferred + '` as a marker',
-            node
+    // There *must* be at least one hyphen-minus in each alignment cell.
+    size =
+      settings.alignDelimiters === false
+        ? 1
+        : Math.max(
+            1,
+            longestCellByColumn[columnIndex] - before.length - after.length
           );
-        }
-      } else {
-        preferred = marker;
-      }
-    }
-  }
-}
 
-var remarkLintTableCellPadding = unifiedLintRule('remark-lint:table-cell-padding', tableCellPadding);
+    cell = before + '-'.repeat(size) + after;
 
-var start$i = unistUtilPosition.start;
-var end$a = unistUtilPosition.end;
+    if (settings.alignDelimiters !== false) {
+      size = before.length + size + after.length;
 
-var styles$4 = {null: true, padded: true, compact: true};
+      if (size > longestCellByColumn[columnIndex]) {
+        longestCellByColumn[columnIndex] = size;
+      }
 
-function tableCellPadding(tree, file, option) {
-  var contents = String(file);
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null;
+      sizes[columnIndex] = size;
+    }
 
-  if (styles$4[preferred] !== true) {
-    file.fail(
-      'Incorrect table cell padding style `' +
-        preferred +
-        "`, expected `'padded'`, `'compact'`, or `'consistent'`"
-    );
+    row[columnIndex] = cell;
   }
 
-  unistUtilVisit(tree, 'table', visitor);
+  // Inject the alignment row.
+  cellMatrix.splice(1, 0, row);
+  sizeMatrix.splice(1, 0, sizes);
 
-  function visitor(node) {
-    var rows = node.children;
-    var sizes = new Array(node.align.length);
-    var length = unistUtilGenerated(node) ? -1 : rows.length;
-    var index = -1;
-    var entries = [];
-    var style;
-    var row;
-    var cells;
-    var column;
-    var cellCount;
-    var cell;
-    var next;
-    var fence;
-    var pos;
-    var entry;
-    var final;
-
-    // Check rows.
-    while (++index < length) {
-      row = rows[index];
-      cells = row.children;
-      cellCount = cells.length;
-      column = -2; // Start without a first cell.
-      next = null;
-      final = undefined;
-
-      // Check fences (before, between, and after cells).
-      while (++column < cellCount) {
-        cell = next;
-        next = cells[column + 1];
-
-        fence = contents.slice(
-          cell ? end$a(cell).offset : start$i(row).offset,
-          next ? start$i(next).offset : end$a(row).offset
-        );
+  rowIndex = -1;
+  /** @type {string[]} */
+  const lines = [];
+
+  while (++rowIndex < cellMatrix.length) {
+    row = cellMatrix[rowIndex];
+    sizes = sizeMatrix[rowIndex];
+    columnIndex = -1;
+    line = [];
 
-        pos = fence.indexOf('|');
+    while (++columnIndex < mostCellsPerRow) {
+      cell = row[columnIndex] || '';
+      before = '';
+      after = '';
 
-        if (cell && cell.children.length !== 0 && final !== undefined) {
-          entries.push({node: cell, start: final, end: pos, index: column});
+      if (settings.alignDelimiters !== false) {
+        size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0);
+        code = alignments[columnIndex];
 
-          // Detect max space per column.
-          sizes[column] = Math.max(sizes[column] || 0, size(cell));
+        if (code === 114 /* `r` */) {
+          before = ' '.repeat(size);
+        } else if (code === 99 /* `c` */) {
+          if (size % 2) {
+            before = ' '.repeat(size / 2 + 0.5);
+            after = ' '.repeat(size / 2 - 0.5);
+          } else {
+            before = ' '.repeat(size / 2);
+            after = before;
+          }
         } else {
-          final = undefined;
+          after = ' '.repeat(size);
         }
+      }
 
-        if (next && next.children.length !== 0) {
-          final = fence.length - pos - 1;
-        } else {
-          final = undefined;
-        }
+      if (settings.delimiterStart !== false && !columnIndex) {
+        line.push('|');
       }
-    }
 
-    if (preferred) {
-      style = preferred === 'padded' ? 1 : 0;
-    } else {
-      style = entries[0] && (!entries[0].start || !entries[0].end) ? 0 : 1;
-    }
+      if (
+        settings.padding !== false &&
+        // Don’t add the opening space if we’re not aligning and the cell is
+        // empty: there will be a closing space.
+        !(settings.alignDelimiters === false && cell === '') &&
+        (settings.delimiterStart !== false || columnIndex)
+      ) {
+        line.push(' ');
+      }
 
-    index = -1;
-    length = entries.length;
+      if (settings.alignDelimiters !== false) {
+        line.push(before);
+      }
+
+      line.push(cell);
+
+      if (settings.alignDelimiters !== false) {
+        line.push(after);
+      }
+
+      if (settings.padding !== false) {
+        line.push(' ');
+      }
 
-    while (++index < length) {
-      entry = entries[index];
-      checkSide('start', entry, style, sizes);
-      checkSide('end', entry, style, sizes);
+      if (
+        settings.delimiterEnd !== false ||
+        columnIndex !== mostCellsPerRow - 1
+      ) {
+        line.push('|');
+      }
     }
 
-    return unistUtilVisit.SKIP
+    lines.push(
+      settings.delimiterEnd === false
+        ? line.join('').replace(/ +$/, '')
+        : line.join('')
+    );
   }
 
-  function checkSide(side, entry, style, sizes) {
-    var cell = entry.node;
-    var spacing = entry[side];
-    var index = entry.index;
-    var reason;
+  return lines.join('\n')
+}
 
-    if (spacing === undefined || spacing === style) {
-      return
-    }
+/**
+ * @param {string|null|undefined} [value]
+ * @returns {string}
+ */
+function serialize(value) {
+  return value === null || value === undefined ? '' : String(value)
+}
+
+/**
+ * @param {string} value
+ * @returns {number}
+ */
+function defaultStringLength(value) {
+  return value.length
+}
 
-    reason = 'Cell should be ';
+/**
+ * @param {string|null|undefined} value
+ * @returns {number}
+ */
+function toAlignment(value) {
+  const code = typeof value === 'string' ? value.charCodeAt(0) : 0;
 
-    if (style === 0) {
-      reason += 'compact';
+  return code === 67 /* `C` */ || code === 99 /* `c` */
+    ? 99 /* `c` */
+    : code === 76 /* `L` */ || code === 108 /* `l` */
+    ? 108 /* `l` */
+    : code === 82 /* `R` */ || code === 114 /* `r` */
+    ? 114 /* `r` */
+    : 0
+}
 
-      // Ignore every cell except the biggest in the column.
-      if (size(cell) < sizes[index]) {
-        return
-      }
-    } else {
-      reason += 'padded';
+/**
+ * @typedef {import('mdast').AlignType} AlignType
+ * @typedef {import('mdast').Table} Table
+ * @typedef {import('mdast').TableRow} TableRow
+ * @typedef {import('mdast').TableCell} TableCell
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('markdown-table').MarkdownTableOptions} MarkdownTableOptions
+ * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+ * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+ * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+ * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+ * @typedef {import('mdast-util-to-markdown').Context} ToMarkdownContext
+ *
+ * @typedef Options
+ * @property {boolean} [tableCellPadding=true]
+ * @property {boolean} [tablePipeAlign=true]
+ * @property {MarkdownTableOptions['stringLength']} [stringLength]
+ */
 
-      if (spacing > style) {
-        reason += ' with 1 space, not ' + spacing;
+/** @type {FromMarkdownExtension} */
+const gfmTableFromMarkdown = {
+  enter: {
+    table: enterTable,
+    tableData: enterCell,
+    tableHeader: enterCell,
+    tableRow: enterRow
+  },
+  exit: {
+    codeText: exitCodeText,
+    table: exitTable,
+    tableData: exit,
+    tableHeader: exit,
+    tableRow: exit
+  }
+};
 
-        // May be right or center aligned.
-        if (size(cell) < sizes[index]) {
-          return
-        }
-      }
-    }
+/** @type {FromMarkdownHandle} */
+function enterTable(token) {
+  /** @type {AlignType[]} */
+  // @ts-expect-error: `align` is custom.
+  const align = token._align;
+  this.enter({type: 'table', align, children: []}, token);
+  this.setData('inTable', true);
+}
+
+/** @type {FromMarkdownHandle} */
+function exitTable(token) {
+  this.exit(token);
+  this.setData('inTable');
+}
+
+/** @type {FromMarkdownHandle} */
+function enterRow(token) {
+  this.enter({type: 'tableRow', children: []}, token);
+}
+
+/** @type {FromMarkdownHandle} */
+function exit(token) {
+  this.exit(token);
+}
+
+/** @type {FromMarkdownHandle} */
+function enterCell(token) {
+  this.enter({type: 'tableCell', children: []}, token);
+}
+
+// Overwrite the default code text data handler to unescape escaped pipes when
+// they are in tables.
+/** @type {FromMarkdownHandle} */
+function exitCodeText(token) {
+  let value = this.resume();
 
-    file.message(reason, cell.position[side]);
+  if (this.getData('inTable')) {
+    value = value.replace(/\\([\\|])/g, replace);
   }
+
+  const node = /** @type {InlineCode} */ (this.stack[this.stack.length - 1]);
+  node.value = value;
+  this.exit(token);
 }
 
-function size(node) {
-  return end$a(node).offset - start$i(node).offset
+/**
+ * @param {string} $0
+ * @param {string} $1
+ * @returns {string}
+ */
+function replace($0, $1) {
+  // Pipes work, backslashes don’t (but can’t escape pipes).
+  return $1 === '|' ? $1 : $0
 }
 
-var remarkLintTablePipes = unifiedLintRule('remark-lint:table-pipes', tablePipes);
+/**
+ * @param {Options} [options]
+ * @returns {ToMarkdownExtension}
+ */
+function gfmTableToMarkdown(options) {
+  const settings = options || {};
+  const padding = settings.tableCellPadding;
+  const alignDelimiters = settings.tablePipeAlign;
+  const stringLength = settings.stringLength;
+  const around = padding ? ' ' : '|';
+
+  return {
+    unsafe: [
+      {character: '\r', inConstruct: 'tableCell'},
+      {character: '\n', inConstruct: 'tableCell'},
+      // A pipe, when followed by a tab or space (padding), or a dash or colon
+      // (unpadded delimiter row), could result in a table.
+      {atBreak: true, character: '|', after: '[\t :-]'},
+      // A pipe in a cell must be encoded.
+      {character: '|', inConstruct: 'tableCell'},
+      // A colon must be followed by a dash, in which case it could start a
+      // delimiter row.
+      {atBreak: true, character: ':', after: '-'},
+      // A delimiter row can also start with a dash, when followed by more
+      // dashes, a colon, or a pipe.
+      // This is a stricter version than the built in check for lists, thematic
+      // breaks, and setex heading underlines though:
+      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>
+      {atBreak: true, character: '-', after: '[:|-]'}
+    ],
+    handlers: {
+      table: handleTable,
+      tableRow: handleTableRow,
+      tableCell: handleTableCell,
+      inlineCode: inlineCodeWithTable
+    }
+  }
+
+  /**
+   * @type {ToMarkdownHandle}
+   * @param {Table} node
+   */
+  function handleTable(node, _, context) {
+    // @ts-expect-error: fixed in `markdown-table@3.0.1`.
+    return serializeData(handleTableAsData(node, context), node.align)
+  }
 
-var start$j = unistUtilPosition.start;
-var end$b = unistUtilPosition.end;
+  /**
+   * This function isn’t really used normally, because we handle rows at the
+   * table level.
+   * But, if someone passes in a table row, this ensures we make somewhat sense.
+   *
+   * @type {ToMarkdownHandle}
+   * @param {TableRow} node
+   */
+  function handleTableRow(node, _, context) {
+    const row = handleTableRowAsData(node, context);
+    // `markdown-table` will always add an align row
+    const value = serializeData([row]);
+    return value.slice(0, value.indexOf('\n'))
+  }
 
-var reasonStart = 'Missing initial pipe in table fence';
-var reasonEnd = 'Missing final pipe in table fence';
+  /**
+   * @type {ToMarkdownHandle}
+   * @param {TableCell} node
+   */
+  function handleTableCell(node, _, context) {
+    const exit = context.enter('tableCell');
+    const subexit = context.enter('phrasing');
+    const value = containerPhrasing(node, context, {
+      before: around,
+      after: around
+    });
+    subexit();
+    exit();
+    return value
+  }
 
-function tablePipes(tree, file) {
-  var contents = String(file);
+  /**
+   * @param {Array.<Array.<string>>} matrix
+   * @param {Array.<string>} [align]
+   */
+  function serializeData(matrix, align) {
+    return markdownTable(matrix, {
+      align,
+      alignDelimiters,
+      padding,
+      stringLength
+    })
+  }
 
-  unistUtilVisit(tree, 'table', visitor);
+  /**
+   * @param {Table} node
+   * @param {ToMarkdownContext} context
+   */
+  function handleTableAsData(node, context) {
+    const children = node.children;
+    let index = -1;
+    /** @type {Array.<Array.<string>>} */
+    const result = [];
+    const subexit = context.enter('table');
 
-  function visitor(node) {
-    var rows = node.children;
-    var length = rows.length;
-    var index = -1;
-    var row;
-    var cells;
-    var head;
-    var tail;
-    var initial;
-    var final;
+    while (++index < children.length) {
+      result[index] = handleTableRowAsData(children[index], context);
+    }
 
-    while (++index < length) {
-      row = rows[index];
+    subexit();
 
-      if (!unistUtilGenerated(row)) {
-        cells = row.children;
-        head = cells[0];
-        tail = cells[cells.length - 1];
-        initial = contents.slice(start$j(row).offset, start$j(head).offset);
-        final = contents.slice(end$b(tail).offset, end$b(row).offset);
+    return result
+  }
 
-        if (initial.indexOf('|') === -1) {
-          file.message(reasonStart, start$j(row));
-        }
+  /**
+   * @param {TableRow} node
+   * @param {ToMarkdownContext} context
+   */
+  function handleTableRowAsData(node, context) {
+    const children = node.children;
+    let index = -1;
+    /** @type {Array.<string>} */
+    const result = [];
+    const subexit = context.enter('tableRow');
 
-        if (final.indexOf('|') === -1) {
-          file.message(reasonEnd, end$b(row));
-        }
-      }
+    while (++index < children.length) {
+      result[index] = handleTableCell(children[index], node, context);
     }
+
+    subexit();
+
+    return result
   }
-}
 
-var remarkLintUnorderedListMarkerStyle = unifiedLintRule(
-  'remark-lint:unordered-list-marker-style',
-  unorderedListMarkerStyle
-);
+  /**
+   * @type {ToMarkdownHandle}
+   * @param {InlineCode} node
+   */
+  function inlineCodeWithTable(node, parent, context) {
+    let value = inlineCode(node, parent, context);
 
-var start$k = unistUtilPosition.start;
+    if (context.stack.includes('tableCell')) {
+      value = value.replace(/\|/g, '\\$&');
+    }
 
-var styles$5 = {
-  '-': true,
-  '*': true,
-  '+': true,
-  null: true
-};
+    return value
+  }
+}
 
-function unorderedListMarkerStyle(tree, file, option) {
-  var contents = String(file);
-  var preferred =
-    typeof option === 'string' && option !== 'consistent' ? option : null;
+/**
+ * @typedef {import('mdast').ListItem} ListItem
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('mdast').BlockContent} BlockContent
+ * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+ * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+ * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+ * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+ */
 
-  if (styles$5[preferred] !== true) {
-    file.fail(
-      'Incorrect unordered list item marker style `' +
-        preferred +
-        "`: use either `'-'`, `'*'`, or `'+'`"
-    );
+/** @type {FromMarkdownExtension} */
+const gfmTaskListItemFromMarkdown = {
+  exit: {
+    taskListCheckValueChecked: exitCheck,
+    taskListCheckValueUnchecked: exitCheck,
+    paragraph: exitParagraphWithTaskListItem
   }
+};
+
+/** @type {ToMarkdownExtension} */
+const gfmTaskListItemToMarkdown = {
+  unsafe: [{atBreak: true, character: '-', after: '[:|-]'}],
+  handlers: {listItem: listItemWithTaskListItem}
+};
 
-  unistUtilVisit(tree, 'list', visitor);
+/** @type {FromMarkdownHandle} */
+function exitCheck(token) {
+  // We’re always in a paragraph, in a list item.
+  this.stack[this.stack.length - 2].checked =
+    token.type === 'taskListCheckValueChecked';
+}
 
-  function visitor(node) {
-    var children = node.children;
-    var length = node.ordered ? 0 : children.length;
-    var index = -1;
-    var child;
-    var marker;
+/** @type {FromMarkdownHandle} */
+function exitParagraphWithTaskListItem(token) {
+  const parent = this.stack[this.stack.length - 2];
+  /** @type {Paragraph} */
+  // @ts-expect-error: must be true.
+  const node = this.stack[this.stack.length - 1];
+  /** @type {BlockContent[]} */
+  // @ts-expect-error: check whether `parent` is a `listItem` later.
+  const siblings = parent.children;
+  const head = node.children[0];
+  let index = -1;
+  /** @type {Paragraph|undefined} */
+  let firstParaghraph;
 
-    while (++index < length) {
-      child = children[index];
+  if (
+    parent &&
+    parent.type === 'listItem' &&
+    typeof parent.checked === 'boolean' &&
+    head &&
+    head.type === 'text'
+  ) {
+    while (++index < siblings.length) {
+      const sibling = siblings[index];
+      if (sibling.type === 'paragraph') {
+        firstParaghraph = sibling;
+        break
+      }
+    }
 
-      if (!unistUtilGenerated(child)) {
-        marker = contents
-          .slice(start$k(child).offset, start$k(child.children[0]).offset)
-          .replace(/\[[x ]?]\s*$/i, '')
-          .replace(/\s/g, '');
+    if (firstParaghraph === node) {
+      // Must start with a space or a tab.
+      head.value = head.value.slice(1);
 
-        if (preferred) {
-          if (marker !== preferred) {
-            file.message('Marker style should be `' + preferred + '`', child);
-          }
-        } else {
-          preferred = marker;
-        }
+      if (head.value.length === 0) {
+        node.children.shift();
+      } else {
+        // @ts-expect-error: must be true.
+        head.position.start.column++;
+        // @ts-expect-error: must be true.
+        head.position.start.offset++;
+        // @ts-expect-error: must be true.
+        node.position.start = Object.assign({}, head.position.start);
       }
     }
   }
+
+  this.exit(token);
 }
 
-// Add in rules alphabetically
-var plugins$2 = [
-  remarkLint,
-  // Leave preset at the top so it can be overridden
-  remarkPresetLintRecommended,
-  [remarkLintBlockquoteIndentation, 2],
-  [
-    remarkLintCheckboxCharacterStyle,
-    {
-      checked: "x",
-      unchecked: " ",
-    },
-  ],
-  remarkLintCheckboxContentIndent,
-  [remarkLintCodeBlockStyle, "fenced"],
-  remarkLintDefinitionSpacing,
-  [
-    remarkLintFencedCodeFlag,
-    {
-      flags: [
-        "bash",
-        "c",
-        "coffee",
-        "console",
-        "cpp",
-        "diff",
-        "http",
-        "js",
-        "json",
-        "markdown",
-        "powershell",
-        "r",
-        "text",
-      ],
-    },
-  ],
-  [remarkLintFencedCodeMarker, "`"],
-  [remarkLintFileExtension, "md"],
-  remarkLintFinalDefinition,
-  [remarkLintFirstHeadingLevel, 1],
-  [remarkLintHeadingStyle, "atx"],
-  [remarkLintListItemIndent, "space"],
-  remarkLintMaximumLineLength,
-  remarkLintNoConsecutiveBlankLines,
-  remarkLintNoFileNameArticles,
-  remarkLintNoFileNameConsecutiveDashes,
-  remarkLintNoFileNameOuterDashes,
-  remarkLintNoHeadingIndent,
-  remarkLintNoMultipleToplevelHeadings,
-  remarkLintNoShellDollars,
-  remarkLintNoTableIndentation,
-  remarkLintNoTabs,
-  remarkLintNoTrailingSpaces,
-  [
-    remarkLintProhibitedStrings,
-    [
-      { yes: "End-of-Life" },
-      { yes: "GitHub" },
-      { no: "hostname", yes: "host name" },
-      { yes: "JavaScript" },
-      { no: "Node", yes: "Node.js" },
-      { yes: "Node.js" },
-      { no: "Node[Jj][Ss]", yes: "Node.js" },
-      { no: "Node\\.js's?", yes: "the Node.js" },
-      { no: "[Nn]ote that", yes: "<nothing>" },
-      { yes: "RFC" },
-      { no: "[Rr][Ff][Cc]\\d+", yes: "RFC <number>" },
-      { yes: "Unix" },
-      { yes: "V8" },
-    ],
-  ],
-  remarkLintRuleStyle,
-  [remarkLintStrongMarker, "*"],
-  [remarkLintTableCellPadding, "padded"],
-  remarkLintTablePipes,
-  [remarkLintUnorderedListMarkerStyle, "*"],
-];
+/**
+ * @type {ToMarkdownHandle}
+ * @param {ListItem} node
+ */
+function listItemWithTaskListItem(node, parent, context) {
+  const head = node.children[0];
+  let value = listItem(node, parent, context);
 
-var remarkPresetLintNode = {
-	plugins: plugins$2
-};
+  if (typeof node.checked === 'boolean' && head && head.type === 'paragraph') {
+    value = value.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, check);
+  }
+
+  return value
 
-var proc = getCjsExportFromNamespace(_package$1);
+  /**
+   * @param {string} $0
+   * @returns {string}
+   */
+  function check($0) {
+    return $0 + '[' + (node.checked ? 'x' : ' ') + '] '
+  }
+}
 
-var cli = getCjsExportFromNamespace(_package$3);
+/**
+ * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+ * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+ *
+ * @typedef {import('mdast-util-gfm-table').Options} Options
+ */
 
-// To aid in future maintenance, this layout closely matches remark-cli/cli.js.
-// https://github.com/remarkjs/remark/blob/master/packages/remark-cli/cli.js
+/**
+ * @type {Array.<FromMarkdownExtension>}
+ */
+const gfmFromMarkdown = [
+  gfmAutolinkLiteralFromMarkdown,
+  gfmStrikethroughFromMarkdown,
+  gfmTableFromMarkdown,
+  gfmTaskListItemFromMarkdown
+];
 
+/**
+ * @param {Options} [options]
+ * @returns {ToMarkdownExtension}
+ */
+function gfmToMarkdown(options) {
+  return {
+    extensions: [
+      gfmAutolinkLiteralToMarkdown,
+      gfmStrikethroughToMarkdown,
+      gfmTableToMarkdown(options),
+      gfmTaskListItemToMarkdown
+    ]
+  }
+}
 
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('micromark-extension-gfm').Options & import('mdast-util-gfm').Options} Options
+ */
 
+/**
+ * Plugin to support GitHub Flavored Markdown (GFM).
+ *
+ * @type {import('unified').Plugin<[Options?]|void[], Root>}
+ */
+function remarkGfm(options = {}) {
+  const data = this.data();
 
+  add('micromarkExtensions', gfm(options));
+  add('fromMarkdownExtensions', gfmFromMarkdown);
+  add('toMarkdownExtensions', gfmToMarkdown(options));
 
+  /**
+   * @param {string} field
+   * @param {unknown} value
+   */
+  function add(field, value) {
+    const list = /** @type {unknown[]} */ (
+      // Other extensions
+      /* c8 ignore next 2 */
+      data[field] ? data[field] : (data[field] = [])
+    );
 
+    list.push(value);
+  }
+}
 
+// To aid in future maintenance, this layout closely matches remark-cli/cli.js.
 
-unifiedArgs({
-  processor: remark().use(remarkPresetLintNode),
+args({
+  processor: remark().use(remarkGfm).use(remarkPresetLintNode),
   name: proc.name,
   description: cli.description,
   version: [
@@ -47285,6 +61254,6 @@ unifiedArgs({
   packageField: proc.name + 'Config',
   rcName: '.' + proc.name + 'rc',
   ignoreName: '.' + proc.name + 'ignore',
-  extensions: markdownExtensions$2,
+  extensions: markdownExtensions,
   detectConfig: false,
 });
diff --git a/tools/lint-pr-commit-message.sh b/tools/lint-pr-commit-message.sh
deleted file mode 100644
index 01afd9bab567c8bfcd82dbcd23ecdb3379a059e6..0000000000000000000000000000000000000000
--- a/tools/lint-pr-commit-message.sh
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-
-# Shell script to lint the message of the first commit in a pull request.
-#
-# Depends on curl, git, node, npm and npx being in $PATH.
-#
-# The pull request is either:
-# 1) supplied as an argument to this shell script
-# 2) derived from the HEAD commit via the GitHub API
-
-GH_API_URL="https://api.github.com"
-PR_ID=$1;
-if [ -z "${PR_ID}" ]; then
-  # Attempt to work out the PR number based on current HEAD
-  if HEAD_COMMIT="$( git rev-parse HEAD )"; then
-    if SEARCH_RESULTS="$( curl -s ${GH_API_URL}/search/issues?q=sha:${HEAD_COMMIT}+type:pr+repo:nodejs/node )"; then
-      if FOUND_PR="$( node -p 'JSON.parse(process.argv[1]).items[0].number' "${SEARCH_RESULTS}" 2> /dev/null )"; then
-        PR_ID=${FOUND_PR}
-      fi
-    fi
-  fi
-fi
-if [ -z "${PR_ID}" ]; then
-  echo "Unable to determine the pull request number to check. Please specify, "
-  echo " e.g. $0 <PR_NUMBER>"
-  exit 1
-fi
-
-PATCH=$( curl -sL https://github.com/nodejs/node/pull/${PR_ID}.patch | grep '^From ' )
-if FIRST_COMMIT="$( echo "$PATCH" | awk '/^From [0-9a-f]{40} / { if (count++ == 0) print $2 }' )"; then
-  MESSAGE=$( git show --quiet --format='format:%B' $FIRST_COMMIT )
-  echo "
-*** Linting the first commit message for pull request ${PR_ID}
-*** according to the guidelines at https://goo.gl/p2fr5Q.
-*** Commit message for $(echo $FIRST_COMMIT | cut -c 1-10) is:
-${MESSAGE}
-"
-  npx -q core-validate-commit --no-validate-metadata "${FIRST_COMMIT}"
-fi
diff --git a/tools/lint-pr-url.mjs b/tools/lint-pr-url.mjs
new file mode 100755
index 0000000000000000000000000000000000000000..0ebbfdd079671d95bef03cc9a571d77c5bf05b4a
--- /dev/null
+++ b/tools/lint-pr-url.mjs
@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+// Usage:
+// git diff upstream/master...HEAD -G"pr-url:" -- "*.md" | \
+// ./tools/lint-pr-url.mjs <expected-pr-url>
+
+import process from 'node:process';
+import readline from 'node:readline';
+
+const [, , expectedPrUrl] = process.argv;
+
+const fileDelimiter = /^\+\+\+ b\/(.+\.md)$/;
+const changeDelimiter = /^@@ -\d+,\d+ \+(\d+),\d+ @@/;
+const prUrlDefinition = /^\+\s+pr-url: (.+)$/;
+
+const validatePrUrl = (url) => url == null || url === expectedPrUrl;
+
+let currentFile;
+let currentLine;
+
+const diff = readline.createInterface({ input: process.stdin });
+for await (const line of diff) {
+  if (fileDelimiter.test(line)) {
+    currentFile = line.match(fileDelimiter)[1];
+    console.log(`Parsing changes in ${currentFile}.`);
+  } else if (changeDelimiter.test(line)) {
+    currentLine = Number(line.match(changeDelimiter)[1]);
+  } else if (!validatePrUrl(line.match(prUrlDefinition)?.[1])) {
+    console.warn(
+      `::warning file=${currentFile},line=${currentLine++},col=${line.length}` +
+      '::pr-url doesn\'t match the URL of the current PR.'
+    );
+  } else if (line[0] !== '-') {
+    // Increment line counter if line is not being deleted.
+    currentLine++;
+  }
+}
diff --git a/tools/lint-sh.js b/tools/lint-sh.js
new file mode 100755
index 0000000000000000000000000000000000000000..42889c16b6af0e76b901f14ea47b1f3e882b5772
--- /dev/null
+++ b/tools/lint-sh.js
@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+'use strict';
+
+const { execSync, spawn } = require('child_process');
+const { promises: fs, readdirSync, statSync } = require('fs');
+const { extname, join, relative, resolve } = require('path');
+
+const FIX_MODE_ENABLED = process.argv.includes('--fix');
+const USE_NPX = process.argv.includes('--from-npx');
+
+const SHELLCHECK_EXE_NAME = 'shellcheck';
+const SHELLCHECK_OPTIONS = ['--shell=sh', '--severity=info', '--enable=all'];
+if (FIX_MODE_ENABLED) SHELLCHECK_OPTIONS.push('--format=diff');
+else if (process.env.GITHUB_ACTIONS) SHELLCHECK_OPTIONS.push('--format=json');
+
+const SPAWN_OPTIONS = {
+  cwd: null,
+  shell: false,
+  stdio: ['pipe', 'pipe', 'inherit'],
+};
+
+function* findScriptFilesRecursively(dirPath) {
+  const entries = readdirSync(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const path = join(dirPath, entry.name);
+
+    if (
+      entry.isDirectory() &&
+      entry.name !== 'build' &&
+      entry.name !== 'changelogs' &&
+      entry.name !== 'deps' &&
+      entry.name !== 'fixtures' &&
+      entry.name !== 'gyp' &&
+      entry.name !== 'inspector_protocol' &&
+      entry.name !== 'node_modules' &&
+      entry.name !== 'out' &&
+      entry.name !== 'tmp'
+    ) {
+      yield* findScriptFilesRecursively(path);
+    } else if (entry.isFile() && extname(entry.name) === '.sh') {
+      yield path;
+    }
+  }
+}
+
+const expectedHashBang = Buffer.from('#!/bin/sh\n');
+async function hasInvalidHashBang(fd) {
+  const { length } = expectedHashBang;
+
+  const actual = Buffer.allocUnsafe(length);
+  await fd.read(actual, 0, length, 0);
+
+  return Buffer.compare(actual, expectedHashBang);
+}
+
+async function checkFiles(...files) {
+  const flags = FIX_MODE_ENABLED ? 'r+' : 'r';
+  await Promise.all(
+    files.map(async (file) => {
+      const fd = await fs.open(file, flags);
+      if (await hasInvalidHashBang(fd)) {
+        if (FIX_MODE_ENABLED) {
+          const file = await fd.readFile();
+
+          const fileContent =
+            file[0] === '#'.charCodeAt() ?
+              file.subarray(file.indexOf('\n') + 1) :
+              file;
+
+          const toWrite = Buffer.concat([expectedHashBang, fileContent]);
+          await fd.truncate(toWrite.length);
+          await fd.write(toWrite, 0, toWrite.length, 0);
+        } else {
+          if (!process.exitCode) process.exitCode = 1;
+          console.error(
+            (process.env.GITHUB_ACTIONS ?
+              `::error file=${file},line=1,col=1::` :
+              'Fixable with --fix: ') +
+              `Invalid hashbang for ${file} (expected /bin/sh).`
+          );
+        }
+      }
+      await fd.close();
+    })
+  );
+
+  const stdout = await new Promise((resolve, reject) => {
+    const SHELLCHECK_EXE =
+      process.env.SHELLCHECK ||
+      execSync('command -v ' + (USE_NPX ? 'npx' : SHELLCHECK_EXE_NAME))
+        .toString()
+        .trim();
+    const NPX_OPTIONS = USE_NPX ? [SHELLCHECK_EXE_NAME] : [];
+
+    const shellcheck = spawn(
+      SHELLCHECK_EXE,
+      [
+        ...NPX_OPTIONS,
+        ...SHELLCHECK_OPTIONS,
+        ...(FIX_MODE_ENABLED ?
+          files.map((filePath) => relative(SPAWN_OPTIONS.cwd, filePath)) :
+          files),
+      ],
+      SPAWN_OPTIONS
+    );
+    shellcheck.once('error', reject);
+
+    let json = '';
+    let childProcess = shellcheck;
+    if (FIX_MODE_ENABLED) {
+      const GIT_EXE =
+        process.env.GIT || execSync('command -v git').toString().trim();
+
+      const gitApply = spawn(GIT_EXE, ['apply'], SPAWN_OPTIONS);
+      shellcheck.stdout.pipe(gitApply.stdin);
+      shellcheck.once('exit', (code) => {
+        if (!process.exitCode && code) process.exitCode = code;
+      });
+      gitApply.stdout.pipe(process.stdout);
+
+      gitApply.once('error', reject);
+      childProcess = gitApply;
+    } else if (process.env.GITHUB_ACTIONS) {
+      shellcheck.stdout.on('data', (chunk) => {
+        json += chunk;
+      });
+    } else {
+      shellcheck.stdout.pipe(process.stdout);
+    }
+    childProcess.once('exit', (code) => {
+      if (!process.exitCode && code) process.exitCode = code;
+      resolve(json);
+    });
+  });
+
+  if (!FIX_MODE_ENABLED && process.env.GITHUB_ACTIONS) {
+    const data = JSON.parse(stdout);
+    for (const { file, line, column, message } of data) {
+      console.error(
+        `::error file=${file},line=${line},col=${column}::${file}:${line}:${column}: ${message}`
+      );
+    }
+  }
+}
+
+const USAGE_STR =
+  `Usage: ${process.argv[1]} <path> [--fix] [--from-npx]\n` +
+  '\n' +
+  'Environment variables:\n' +
+  ' - SHELLCHECK: absolute path to `shellcheck`. If not provided, the\n' +
+  '   script will use the result of `command -v shellcheck`, or\n' +
+  '   `$(command -v npx) shellcheck` if the flag `--from-npx` is provided\n' +
+  '   (may require an internet connection).\n' +
+  ' - GIT: absolute path to `git`. If not provided, the \n' +
+  '   script will use the result of `command -v git`.\n';
+
+if (
+  process.argv.length < 3 ||
+  process.argv.includes('-h') ||
+  process.argv.includes('--help')
+) {
+  console.log(USAGE_STR);
+} else {
+  console.log('Running Shell scripts checker...');
+  const entryPoint = resolve(process.argv[2]);
+  const stats = statSync(entryPoint, { throwIfNoEntry: false });
+
+  function onError(e) {
+    console.log(USAGE_STR);
+    console.error(e);
+    process.exitCode = 1;
+  }
+  if (stats?.isDirectory()) {
+    SPAWN_OPTIONS.cwd = entryPoint;
+    checkFiles(...findScriptFilesRecursively(entryPoint)).catch(onError);
+  } else if (stats?.isFile()) {
+    SPAWN_OPTIONS.cwd = process.cwd();
+    checkFiles(entryPoint).catch(onError);
+  } else {
+    onError(new Error('You must provide a valid directory or file path. ' +
+                      `Received '${process.argv[2]}'.`));
+  }
+}
diff --git a/tools/macos-firewall.sh b/tools/macos-firewall.sh
index 4079dc4d790f5adf5230c32eb79ea626a231d3ca..b6050aaf3450bd34b72cf96a9498674bcc82230b 100755
--- a/tools/macos-firewall.sh
+++ b/tools/macos-firewall.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 # Script that adds rules to Mac OS X Socket Firewall to avoid
 # popups asking to accept incoming network connections when
 # running tests.
@@ -21,36 +21,25 @@ CCTEST_DEBUG="$OUTDIR/Debug/cctest"
 OPENSSL_CLI_RELEASE="$OUTDIR/Release/openssl-cli"
 OPENSSL_CLI_DEBUG="$OUTDIR/Debug/openssl-cli"
 
+add_and_unblock () {
+  if [ -e "$1" ]
+  then
+    echo Processing "$1"
+    $SFW --remove "$1" >/dev/null
+    $SFW --add "$1"
+    $SFW --unblock "$1"
+  fi
+}
+
 if [ -f $SFW ];
 then
-  # Duplicating these commands on purpose as the symbolic link node might be
-  # linked to either out/Debug/node or out/Release/node depending on the
-  # BUILDTYPE.
-  $SFW --remove "$NODE_DEBUG"
-  $SFW --remove "$NODE_DEBUG"
-  $SFW --remove "$NODE_RELEASE"
-  $SFW --remove "$NODE_RELEASE"
-  $SFW --remove "$NODE_LINK"
-  $SFW --remove "$CCTEST_DEBUG"
-  $SFW --remove "$CCTEST_RELEASE"
-  $SFW --remove "$OPENSSL_CLI_DEBUG"
-  $SFW --remove "$OPENSSL_CLI_RELEASE"
-
-  $SFW --add "$NODE_DEBUG"
-  $SFW --add "$NODE_RELEASE"
-  $SFW --add "$NODE_LINK"
-  $SFW --add "$CCTEST_DEBUG"
-  $SFW --add "$CCTEST_RELEASE"
-  $SFW --add "$OPENSSL_CLI_DEBUG"
-  $SFW --add "$OPENSSL_CLI_RELEASE"
-
-  $SFW --unblock "$NODE_DEBUG"
-  $SFW --unblock "$NODE_RELEASE"
-  $SFW --unblock "$NODE_LINK"
-  $SFW --unblock "$CCTEST_DEBUG"
-  $SFW --unblock "$CCTEST_RELEASE"
-  $SFW --unblock "$OPENSSL_CLI_DEBUG"
-  $SFW --unblock "$OPENSSL_CLI_RELEASE"
+  add_and_unblock "$NODE_DEBUG"
+  add_and_unblock "$NODE_RELEASE"
+  add_and_unblock "$NODE_LINK"
+  add_and_unblock "$CCTEST_DEBUG"
+  add_and_unblock "$CCTEST_RELEASE"
+  add_and_unblock "$OPENSSL_CLI_DEBUG"
+  add_and_unblock "$OPENSSL_CLI_RELEASE"
 else
   echo "SocketFirewall not found in location: $SFW"
 fi
diff --git a/tools/make-v8.sh b/tools/make-v8.sh
index 68222c1cd8ba9fd0231c7ac8f58b114542b9394c..79ab02af275aa9b8ba5b03824ca9d0bf65fbe2a6 100755
--- a/tools/make-v8.sh
+++ b/tools/make-v8.sh
@@ -1,16 +1,18 @@
-#!/bin/bash -xe
+#!/bin/sh
+
+set -xe
 
 BUILD_ARCH_TYPE=$1
 V8_BUILD_OPTIONS=$2
 
-cd deps/v8
-find . -type d -name .git | xargs rm -rf
+cd deps/v8 || exit
+find . -type d -name .git -print0 | xargs -0 rm -rf
 tools/node/fetch_deps.py .
 
 ARCH="`arch`"
-if [[ "$ARCH" == "s390x" ]] || [[ "$ARCH" == "ppc64le" ]]; then
+if [ "$ARCH" = "s390x" ] || [ "$ARCH" = "ppc64le" ]; then
   TARGET_ARCH=$ARCH
-  if [[ "$ARCH" == "ppc64le" ]]; then
+  if [ "$ARCH" = "ppc64le" ]; then
     TARGET_ARCH="ppc64"
   fi
   # set paths manually for now to use locally installed gn
@@ -18,20 +20,24 @@ if [[ "$ARCH" == "s390x" ]] || [[ "$ARCH" == "ppc64le" ]]; then
   export LD_LIBRARY_PATH=$BUILD_TOOLS:$LD_LIBRARY_PATH
   # Avoid linking to ccache symbolic links as ccache decides which
   # binary to run based on the name of the link (we always name them gcc/g++).
-  CC_PATH=`which -a $CC gcc | grep -v ccache | head -n 1`
-  CXX_PATH=`which -a $CXX g++ | grep -v ccache | head -n 1`
+  # shellcheck disable=SC2154
+  CC_PATH=`command -v "$CC" gcc | grep -v ccache | head -n 1`
+  # shellcheck disable=SC2154
+  CXX_PATH=`command -v "$CXX" g++ | grep -v ccache | head -n 1`
   rm -f "$BUILD_TOOLS/g++"
   rm -f "$BUILD_TOOLS/gcc"
-  ln -s $CXX_PATH "$BUILD_TOOLS/g++"
-  ln -s $CC_PATH "$BUILD_TOOLS/gcc"
+  ln -s "$CXX_PATH" "$BUILD_TOOLS/g++"
+  ln -s "$CC_PATH" "$BUILD_TOOLS/gcc"
   export PATH=$BUILD_TOOLS:$PATH
 
   g++ --version
   gcc --version
   export PKG_CONFIG_PATH=$BUILD_TOOLS/pkg-config
-  gn gen -v out.gn/$BUILD_ARCH_TYPE --args="is_component_build=false is_debug=false use_goma=false goma_dir=\"None\" use_custom_libcxx=false v8_target_cpu=\"$TARGET_ARCH\" target_cpu=\"$TARGET_ARCH\" v8_enable_backtrace=true"
-  ninja -v -C out.gn/$BUILD_ARCH_TYPE d8 cctest inspector-test
+  gn gen -v "out.gn/$BUILD_ARCH_TYPE" --args="is_component_build=false is_debug=false use_goma=false goma_dir=\"None\" use_custom_libcxx=false v8_target_cpu=\"$TARGET_ARCH\" target_cpu=\"$TARGET_ARCH\" v8_enable_backtrace=true"
+  ninja -v -C "out.gn/$BUILD_ARCH_TYPE" d8 cctest inspector-test
 else
-  PATH=~/_depot_tools:$PATH tools/dev/v8gen.py $BUILD_ARCH_TYPE --no-goma $V8_BUILD_OPTIONS
-  PATH=~/_depot_tools:$PATH ninja -C out.gn/$BUILD_ARCH_TYPE/ d8 cctest inspector-test
+  DEPOT_TOOLS_DIR="$(cd _depot_tools && pwd)"
+  # shellcheck disable=SC2086
+  PATH="$DEPOT_TOOLS_DIR":$PATH tools/dev/v8gen.py "$BUILD_ARCH_TYPE" --no-goma $V8_BUILD_OPTIONS
+  PATH="$DEPOT_TOOLS_DIR":$PATH ninja -C "out.gn/$BUILD_ARCH_TYPE/" d8 cctest inspector-test
 fi
diff --git a/tools/msvs/find_nasm.cmd b/tools/msvs/find_nasm.cmd
index d30d2131166caa46e68b4ebc51aaa710752c156a..09e7c7554a87869144090425b3a466e3ed19dc04 100644
--- a/tools/msvs/find_nasm.cmd
+++ b/tools/msvs/find_nasm.cmd
@@ -16,4 +16,9 @@ IF EXIST "%ProgramFiles(x86)%\NASM\nasm.exe" (
   EXIT /B 0
 )
 
+if EXIST "%LOCALAPPDATA%\bin\NASM\nasm.exe" (
+  SET "Path=%Path%;%LOCALAPPDATA%\bin\NASM"
+  EXIT /B 0
+)
+
 EXIT /B 1
diff --git a/tools/msvs/find_python.cmd b/tools/msvs/find_python.cmd
index 728eeb405b8171380832fe37a7de5a8bc7234925..671fcbd7e58c03a9ebdcf8558ce3f2f3720a0c06 100644
--- a/tools/msvs/find_python.cmd
+++ b/tools/msvs/find_python.cmd
@@ -3,27 +3,6 @@
 echo Looking for Python
 setlocal enabledelayedexpansion
 
-:: To remove the preference for Python 2, but still support it, just remove
-:: the 5 blocks marked with "Python 2:" and the support warnings
-
-:: Python 2: If python.exe is in %Path%, use if it's Python 2
-FOR /F "delims=" %%a IN ('where python.exe 2^> NUL') DO (
-  SET need_path=0
-  SET p=%%~dpa
-  CALL :validate-v2
-  IF NOT ERRORLEVEL 1 GOTO :found-python2
-  GOTO :done-path-v2
-)
-:done-path-v2
-
-:: Python 2: Query the 3 locations mentioned in PEP 514 for a python2 InstallPath
-FOR %%K IN ( "HKCU\Software", "HKLM\SOFTWARE", "HKLM\Software\Wow6432Node") DO (
-  SET need_path=1
-  CALL :find-versions-v2 %%K
-  IF NOT ERRORLEVEL 1 CALL :validate-v2
-  IF NOT ERRORLEVEL 1 GOTO :found-python2
-)
-
 :: Use python.exe if in %PATH%
 set need_path=0
 for /f "delims=" %%a in ('where python.exe 2^> nul') do (
@@ -41,14 +20,6 @@ for %%k in ( "HKCU\Software", "HKLM\SOFTWARE", "HKLM\Software\Wow6432Node") do (
 goto :no-python
 
 
-:: Python 2: Find Python 2 installations in a registry location
-:find-versions-v2
-for /f "delims=" %%a in ('reg query "%~1\Python\PythonCore" /f * /k 2^> nul ^| findstr /r ^^HK ^| findstr "\\2\."') do (
-  call :read-installpath %%a
-  if not errorlevel 1 exit /b 0
-)
-exit /b 1
-
 :: Find Python installations in a registry location
 :find-versions
 for /f "delims=" %%a in ('reg query "%~1\Python\PythonCore" /f * /k 2^> nul ^| findstr /r ^^HK') do (
@@ -73,32 +44,11 @@ for /f "skip=2 tokens=1* delims=)" %%a in ('reg query "%1\InstallPath" /ve /t RE
 )
 exit /b 1
 
-
-:: Python 2: Check if %p% holds a path to a real python2 executable
-:validate-v2
-IF NOT EXIST "%p%\python.exe" EXIT /B 1
-:: Check if %p% is python2
-"%p%\python.exe" -V 2>&1 | findstr /R "^Python.2.*" > NUL
-EXIT /B %ERRORLEVEL%
-
-
-:: Python 2:
-:found-python2
-echo Python 2 found in %p%\python.exe
-set pyver=2
-goto :done
-
 :found-python
 echo Python found in %p%\python.exe
-echo WARNING: Python 3 is not yet fully supported, to avoid issues Python 2 should be installed.
-set pyver=3
-goto :done
-
-:done
 endlocal ^
   & set "pt=%p%" ^
-  & set "need_path_ext=%need_path%" ^
-  & set "VCBUILD_PYTHON_VERSION=%pyver%"
+  & set "need_path_ext=%need_path%"
 set "VCBUILD_PYTHON_LOCATION=%pt%\python.exe"
 if %need_path_ext%==1 set "PATH=%pt%;%PATH%"
 set "pt="
diff --git a/tools/msvs/msi/custom_actions.vcxproj b/tools/msvs/msi/custom_actions.vcxproj
index f984ccd7ad9985a420baa98627d92e9acd73f015..2fed47b6e4a781f8694dcb67ffd7410534057937 100644
--- a/tools/msvs/msi/custom_actions.vcxproj
+++ b/tools/msvs/msi/custom_actions.vcxproj
@@ -112,7 +112,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(WIX)sdk\VS$(GypMsvsVersion)\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(WixSdkDir)\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
@@ -122,7 +122,7 @@
     </ClCompile>
     <Link>
       <AdditionalDependencies>msi.lib;dutil.lib;wcautil.lib;version.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>$(WIX)sdk\VS$(GypMsvsVersion)\lib\x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(WixSdkDir)\lib\x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <ModuleDefinitionFile>custom_actions.def</ModuleDefinitionFile>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
@@ -150,7 +150,7 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(WIX)sdk\VS$(GypMsvsVersion)\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(WixSdkDir)\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
@@ -160,7 +160,7 @@
     </ClCompile>
     <Link>
       <AdditionalDependencies>msi.lib;dutil.lib;wcautil.lib;version.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>$(WIX)sdk\VS$(GypMsvsVersion)\lib\x64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(WixSdkDir)\lib\x64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <ModuleDefinitionFile>custom_actions.def</ModuleDefinitionFile>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
@@ -170,7 +170,7 @@
     <ClCompile>
       <Optimization>MaxSpeed</Optimization>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(WIX)sdk\VS$(GypMsvsVersion)\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(WixSdkDir)\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
@@ -184,7 +184,7 @@
     </ClCompile>
     <Link>
       <AdditionalDependencies>msi.lib;dutil.lib;wcautil.lib;version.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>$(WIX)sdk\VS$(GypMsvsVersion)\lib\x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(WixSdkDir)\lib\x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <ModuleDefinitionFile>custom_actions.def</ModuleDefinitionFile>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
@@ -222,7 +222,7 @@
     <ClCompile>
       <Optimization>MaxSpeed</Optimization>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(WIX)sdk\VS$(GypMsvsVersion)\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(WixSdkDir)\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
@@ -236,7 +236,7 @@
     </ClCompile>
     <Link>
       <AdditionalDependencies>msi.lib;dutil.lib;wcautil.lib;version.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>$(WIX)sdk\VS$(GypMsvsVersion)\lib\x64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(WixSdkDir)\lib\x64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <ModuleDefinitionFile>custom_actions.def</ModuleDefinitionFile>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
diff --git a/tools/msvs/msi/product.wxs b/tools/msvs/msi/product.wxs
index 61909bbeb61c9f122699ffb5d9249de193341029..ed062c3d74729b0f1997f46aaa4fce9a16fda888 100755
--- a/tools/msvs/msi/product.wxs
+++ b/tools/msvs/msi/product.wxs
@@ -23,8 +23,8 @@
              Compressed="yes"
              InstallScope="perMachine"/>
 
-    <Condition Message="This application is only supported on Windows 7, Windows Server 2008 R2, or higher.">
-      <![CDATA[Installed OR (VersionNT >= 601)]]>
+    <Condition Message="This application is only supported on Windows 8.1, Windows Server 2012 R2, or higher.">
+      <![CDATA[Installed OR (VersionNT >= 603) OR (VersionNT >= 602 AND MsiNTProductType <> 1)]]>
     </Condition>
 
     <Media Id="1" Cabinet="media1.cab" EmbedCab="yes"/>
diff --git a/tools/msvs/vswhere_usability_wrapper.cmd b/tools/msvs/vswhere_usability_wrapper.cmd
index 0c7cac1e4c4aa2e8ed11c319e079b803aea85c37..45ca5b2164a3b3ce210ddf7210044eb2fc372e93 100644
--- a/tools/msvs/vswhere_usability_wrapper.cmd
+++ b/tools/msvs/vswhere_usability_wrapper.cmd
@@ -5,7 +5,7 @@
 
 @if not defined DEBUG_HELPER @ECHO OFF
 setlocal
-if "%~1"=="prerelease" set VSWHERE_WITH_PRERELEASE=1
+if "%~2"=="prerelease" set VSWHERE_WITH_PRERELEASE=1
 set "InstallerPath=%ProgramFiles(x86)%\Microsoft Visual Studio\Installer"
 if not exist "%InstallerPath%" set "InstallerPath=%ProgramFiles%\Microsoft Visual Studio\Installer"
 if not exist "%InstallerPath%" goto :no-vswhere
diff --git a/tools/node-lint-md-cli-rollup/package-lock.json b/tools/node-lint-md-cli-rollup/package-lock.json
index 9392260f13f4bb771dade857f54652d436404160..3cfe12696fad45d88ac1bbb469ad56e4d0c9976e 100644
--- a/tools/node-lint-md-cli-rollup/package-lock.json
+++ b/tools/node-lint-md-cli-rollup/package-lock.json
@@ -1,28 +1,4156 @@
 {
   "name": "node-lint-md-cli-rollup",
   "version": "2.0.2",
-  "lockfileVersion": 1,
+  "lockfileVersion": 2,
   "requires": true,
+  "packages": {
+    "": {
+      "version": "2.0.2",
+      "dependencies": {
+        "markdown-extensions": "^1.1.1",
+        "remark": "^14.0.0",
+        "remark-gfm": "^2.0.0",
+        "remark-preset-lint-node": "^3.0.0",
+        "unified-args": "^9.0.0"
+      },
+      "devDependencies": {
+        "@rollup/plugin-commonjs": "^20.0.0",
+        "@rollup/plugin-json": "^4.1.0",
+        "@rollup/plugin-node-resolve": "^13.0.4",
+        "rollup": "^2.52.7",
+        "shx": "^0.3.3"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.14.5.tgz",
+      "integrity": "sha512-9pzDqyc6OLDaqe+zbACgFkb6fKMNG6CObKpnYXChRsvYGyEdc7CA2BaqeOM+vOtCS5ndmJicPJhKAwYRI6UfFw==",
+      "dependencies": {
+        "@babel/highlight": "^7.14.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.14.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.9.tgz",
+      "integrity": "sha512-pQYxPY0UP6IHISRitNe8bsijHex4TWZXi2HwKVsjPiltzlhse2znVcm9Ace510VT1kxIHjGJCZZQBX2gJDbo0g==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/highlight": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.14.5.tgz",
+      "integrity": "sha512-qf9u2WFWVV0MppaL877j2dBtQIDgmidgjGk5VIMw3OadXvYaXn66U1BFlH2t4+t3i+8PhedppRv+i40ABzd+gg==",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.14.5",
+        "chalk": "^2.0.0",
+        "js-tokens": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/highlight/node_modules/ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dependencies": {
+        "color-convert": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/@babel/highlight/node_modules/chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dependencies": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/@babel/highlight/node_modules/color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dependencies": {
+        "color-name": "1.1.3"
+      }
+    },
+    "node_modules/@babel/highlight/node_modules/color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU="
+    },
+    "node_modules/@babel/highlight/node_modules/escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/@babel/highlight/node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/@babel/highlight/node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/@rollup/plugin-commonjs": {
+      "version": "20.0.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-20.0.0.tgz",
+      "integrity": "sha512-5K0g5W2Ol8hAcTHqcTBHiA7M58tfmYi1o9KxeJuuRNpGaTa5iLjcyemBitCBcKXaHamOBBEH2dGom6v6Unmqjg==",
+      "dev": true,
+      "dependencies": {
+        "@rollup/pluginutils": "^3.1.0",
+        "commondir": "^1.0.1",
+        "estree-walker": "^2.0.1",
+        "glob": "^7.1.6",
+        "is-reference": "^1.2.1",
+        "magic-string": "^0.25.7",
+        "resolve": "^1.17.0"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.38.3"
+      }
+    },
+    "node_modules/@rollup/plugin-json": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-json/-/plugin-json-4.1.0.tgz",
+      "integrity": "sha512-yfLbTdNS6amI/2OpmbiBoW12vngr5NW2jCJVZSBEz+H5KfUJZ2M7sDjk0U6GOOdCWFVScShte29o9NezJ53TPw==",
+      "dev": true,
+      "dependencies": {
+        "@rollup/pluginutils": "^3.0.8"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0 || ^2.0.0"
+      }
+    },
+    "node_modules/@rollup/plugin-node-resolve": {
+      "version": "13.0.4",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-13.0.4.tgz",
+      "integrity": "sha512-eYq4TFy40O8hjeDs+sIxEH/jc9lyuI2k9DM557WN6rO5OpnC2qXMBNj4IKH1oHrnAazL49C5p0tgP0/VpqJ+/w==",
+      "dev": true,
+      "dependencies": {
+        "@rollup/pluginutils": "^3.1.0",
+        "@types/resolve": "1.17.1",
+        "builtin-modules": "^3.1.0",
+        "deepmerge": "^4.2.2",
+        "is-module": "^1.0.0",
+        "resolve": "^1.19.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.42.0"
+      }
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz",
+      "integrity": "sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==",
+      "dev": true,
+      "dependencies": {
+        "@types/estree": "0.0.39",
+        "estree-walker": "^1.0.1",
+        "picomatch": "^2.2.2"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0"
+      }
+    },
+    "node_modules/@rollup/pluginutils/node_modules/estree-walker": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz",
+      "integrity": "sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==",
+      "dev": true
+    },
+    "node_modules/@types/concat-stream": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@types/concat-stream/-/concat-stream-1.6.1.tgz",
+      "integrity": "sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/debug": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.7.tgz",
+      "integrity": "sha512-9AonUzyTjXXhEOa0DnqpzZi6VHlqKMswga9EXjpXnnqxwLtdvPPtlO8evrI5D9S6asFRCQ6v+wpiUKbw+vKqyg==",
+      "dependencies": {
+        "@types/ms": "*"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "0.0.39",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz",
+      "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==",
+      "dev": true
+    },
+    "node_modules/@types/hast": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.2.tgz",
+      "integrity": "sha512-Op5W7jYgZI7AWKY5wQ0/QNMzQM7dGQPyW1rXKNiymVCy5iTfdPuGu4HhYNOM2sIv8gUfIuIdcYlXmAepwaowow==",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/is-empty": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@types/is-empty/-/is-empty-1.2.0.tgz",
+      "integrity": "sha512-brJKf2boFhUxTDxlpI7cstwiUtA2ovm38UzFTi9aZI6//ARncaV+Q5ALjCaJqXaMtdZk/oPTJnSutugsZR6h8A=="
+    },
+    "node_modules/@types/js-yaml": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/js-yaml/-/js-yaml-4.0.2.tgz",
+      "integrity": "sha512-KbeHS/Y4R+k+5sWXEYzAZKuB1yQlZtEghuhRxrVRLaqhtoG5+26JwQsa4HyS3AWX8v1Uwukma5HheduUDskasA=="
+    },
+    "node_modules/@types/mdast": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.3.tgz",
+      "integrity": "sha512-SXPBMnFVQg1s00dlMCc/jCdvPqdE4mXaMMCeRlxLDmTAEoegHT53xKtkDnzDTOcmMHUfcjyf36/YYZ6SxRdnsw==",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "0.7.31",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.31.tgz",
+      "integrity": "sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA=="
+    },
+    "node_modules/@types/node": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.6.1.tgz",
+      "integrity": "sha512-Sr7BhXEAer9xyGuCN3Ek9eg9xPviCF2gfu9kTfuU2HkTVAMYSDeX40fvpmo72n5nansg3nsBjuQBrsS28r+NUw=="
+    },
+    "node_modules/@types/parse5": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/@types/parse5/-/parse5-6.0.1.tgz",
+      "integrity": "sha512-ARATsLdrGPUnaBvxLhUlnltcMgn7pQG312S8ccdYlnyijabrX9RN/KN/iGj9Am96CoW8e/K9628BA7Bv4XHdrA=="
+    },
+    "node_modules/@types/repeat-string": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@types/repeat-string/-/repeat-string-1.6.1.tgz",
+      "integrity": "sha512-vdna8kjLGljgtPnYN6MBD2UwX62QE0EFLj9QlLXvg6dEu66NksXB900BNguBCMZZY2D9SSqncUskM23vT3uvWQ=="
+    },
+    "node_modules/@types/resolve": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.17.1.tgz",
+      "integrity": "sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==",
+      "dev": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/@types/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-dPWnWsf+kzIG140B8z2w3fr5D03TLWbOAFQl45xUpI3vcizeXriNR5VYkWZ+WTMsUHqZ9Xlt3hrxGNANFyNQfw=="
+    },
+    "node_modules/@types/text-table": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/@types/text-table/-/text-table-0.2.2.tgz",
+      "integrity": "sha512-dGoI5Af7To0R2XE8wJuc6vwlavWARsCh3UKJPjWs1YEqGUqfgBI/j/4GX0yf19/DsDPPf0YAXWAp8psNeIehLg=="
+    },
+    "node_modules/@types/unist": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.3.tgz",
+      "integrity": "sha512-FvUupuM3rlRsRtCN+fDudtmytGO6iHJuuRKS1Ss0pG5z8oX0diNEw94UEL7hgDbpN94rgaK5R7sWm6RrSkZuAQ=="
+    },
+    "node_modules/ansi-regex": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.0.tgz",
+      "integrity": "sha512-tAaOSrWCHF+1Ear1Z4wnJCXA9GGox4K6Ic85a5qalES2aeEwQGr7UC93mwef49536PkCYjzkp0zIxfFvexJ6zQ==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz",
+      "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
+    },
+    "node_modules/bail": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.1.tgz",
+      "integrity": "sha512-d5FoTAr2S5DSUPKl85WNm2yUwsINN8eidIdIwsOge2t33DaOfOdSmmsI11jMN3GmALCXaw+Y6HMVHDzePshFAA==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c="
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dependencies": {
+        "fill-range": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
+    },
+    "node_modules/builtin-modules": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.2.0.tgz",
+      "integrity": "sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/builtins": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/builtins/-/builtins-4.0.0.tgz",
+      "integrity": "sha512-qC0E2Dxgou1IHhvJSLwGDSTvokbRovU5zZFuDY6oY8Y2lF3nGt5Ad8YZK7GMtqzY84Wu7pXTPeHQeHcXSXsRhw==",
+      "dependencies": {
+        "semver": "^7.0.0"
+      }
+    },
+    "node_modules/camelcase": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz",
+      "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ccount": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.0.tgz",
+      "integrity": "sha512-VOR0NWFYX65n9gELQdcpqsie5L5ihBXuZGAgaPEp/U7IOSjnPMEH6geE+2f6lcekaNEfWzAHS45mPvSo5bqsUA==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/character-entities": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.0.tgz",
+      "integrity": "sha512-oHqMj3eAuJ77/P5PaIRcqk+C3hdfNwyCD2DAUcD5gyXkegAuF2USC40CEqPscDk4I8FRGMTojGJQkXDsN5QlJA==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-html4": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.0.0.tgz",
+      "integrity": "sha512-dwT2xh5ZhUAjyP96k57ilMKoTQyASaw9IAMR9U5c1lCu2RUni6O6jxfpUEdO2RcPT6TJFvr8pqsbami4Jk+2oA==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-2.0.0.tgz",
+      "integrity": "sha512-YwaEtEvWLpFa6Wh3uVLrvirA/ahr9fki/NUd/Bd4OR6EdJ8D22hovYQEOUCBfQfcqnC4IAMGMsHXY1eXgL4ZZA==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-reference-invalid": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.0.tgz",
+      "integrity": "sha512-pE3Z15lLRxDzWJy7bBHBopRwfI20sbrMVLQTC7xsPglCHf4Wv1e167OgYAFP78co2XlhojDyAqA+IAJse27//g==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.2.tgz",
+      "integrity": "sha512-ekGhOnNVPgT77r4K/U3GDhu+FQ2S8TnK/s2KbIGXi0SZWuwkZ2QNyfWdZW+TVfn84DpEP7rLeCt2UI6bJ8GwbQ==",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/co": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/co/-/co-3.1.0.tgz",
+      "integrity": "sha1-TqVOpaCJOBUxheFSEMaNkJK8G3g="
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
+    },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-G5yTt3KQN4Yn7Yk4ed73hlZ1evrFKXeUW3086p3PRFNp7m2vIjI6Pg+Kgb+oyzhd9F2qdcoj67+y3SdxL5XWsg==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/commondir": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
+      "integrity": "sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=",
+      "dev": true
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
+    },
+    "node_modules/concat-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-2.0.0.tgz",
+      "integrity": "sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==",
+      "engines": [
+        "node >= 6.0"
+      ],
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^3.0.2",
+        "typedarray": "^0.0.6"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
+      "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deepmerge": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz",
+      "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="
+    },
+    "node_modules/error-ex": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
+      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+      "dependencies": {
+        "is-arrayish": "^0.2.1"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true
+    },
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="
+    },
+    "node_modules/fault": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fault/-/fault-2.0.0.tgz",
+      "integrity": "sha512-JsDj9LFcoC+4ChII1QpXPA7YIaY8zmqPYw7h9j5n7St7a0BBKfNnwEBAUQRBx70o2q4rs+BeSNHk8Exm6xE7fQ==",
+      "dependencies": {
+        "format": "^0.2.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/figgy-pudding": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/figgy-pudding/-/figgy-pudding-3.5.2.tgz",
+      "integrity": "sha512-0btnI/H8f2pavGMN8w40mlSKOfTK2SVJmBfBeVIj3kNw0swwgzyRq0d5TJVOwodFmtvpPeWPN/MCcfuWF0Ezbw=="
+    },
+    "node_modules/fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
+      "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
+      "dependencies": {
+        "locate-path": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/format": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz",
+      "integrity": "sha1-1hcBB+nv3E7TDJ3DkBbflCtctYs=",
+      "engines": {
+        "node": ">=0.4.x"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
+      "dev": true
+    },
+    "node_modules/glob": {
+      "version": "7.1.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+      "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dev": true,
+      "dependencies": {
+        "function-bind": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/hast-util-from-parse5": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-7.1.0.tgz",
+      "integrity": "sha512-m8yhANIAccpU4K6+121KpPP55sSl9/samzQSQGpb0mTExcNh2WlvjtMwSWFhg6uqD4Rr6Nfa8N6TMypQM51rzQ==",
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "@types/parse5": "^6.0.0",
+        "@types/unist": "^2.0.0",
+        "hastscript": "^7.0.0",
+        "property-information": "^6.0.0",
+        "vfile": "^5.0.0",
+        "vfile-location": "^4.0.0",
+        "web-namespaces": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-is-element": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-2.1.1.tgz",
+      "integrity": "sha512-ag0fiZfRWsPiR1udvnSbaazJLGv8qd8E+/e3rW8rUZhbKG4HNJmFL4QkEceN+22BgE+uozXY30z/s+2dL6Z++g==",
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "@types/unist": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-parse-selector": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-3.1.0.tgz",
+      "integrity": "sha512-AyjlI2pTAZEOeu7GeBPZhROx0RHBnydkQIXlhnFzDi0qfXTmGUWoCYZtomHbrdrheV4VFUlPcfJ6LMF5T6sQzg==",
+      "dependencies": {
+        "@types/hast": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-to-html": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-8.0.1.tgz",
+      "integrity": "sha512-S1mTqXvWVGIxrWw0xOHHvmevwCBFTRGNvXWsjE32IyEAlMhbMkK+ZuP6CAqkQ6Vb7swrehaHpfXHEI6voGDh0w==",
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "ccount": "^2.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-is-element": "^2.0.0",
+        "hast-util-whitespace": "^2.0.0",
+        "html-void-elements": "^2.0.0",
+        "property-information": "^6.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-is": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-2.0.0.tgz",
+      "integrity": "sha512-Pkw+xBHuV6xFeJprJe2BBEoDV+AvQySaz3pPDRUs5PNZEMQjpXJJueqrpcHIXxnWTcAGi/UOCgVShlkY6kLoqg==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hastscript": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-7.0.2.tgz",
+      "integrity": "sha512-uA8ooUY4ipaBvKcMuPehTAB/YfFLSSzCwFSwT6ltJbocFUKH/GDHLN+tflq7lSRf9H86uOuxOFkh1KgIy3Gg2g==",
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-parse-selector": "^3.0.0",
+        "property-information": "^6.0.0",
+        "space-separated-tokens": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/html-void-elements": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-2.0.0.tgz",
+      "integrity": "sha512-4OYzQQsBt0G9bJ/nM9/DDsjm4+fVdzAaPJJcWk5QwA3GIAPxQEeOR0rsI8HbDHQz5Gta8pVvGnnTNSbZVEVvkQ==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/ignore": {
+      "version": "5.1.8",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.8.tgz",
+      "integrity": "sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-meta-resolve": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-1.1.1.tgz",
+      "integrity": "sha512-JiTuIvVyPaUg11eTrNDx5bgQ/yMKMZffc7YSjvQeSMXy58DO2SQ8BtAf3xteZvmzvjYh14wnqNjL8XVeDy2o9A==",
+      "dependencies": {
+        "builtins": "^4.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "node_modules/ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="
+    },
+    "node_modules/interpret": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz",
+      "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-alphabetical": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.0.tgz",
+      "integrity": "sha512-5OV8Toyq3oh4eq6sbWTYzlGdnMT/DPI5I0zxUBxjiigQsZycpkKF3kskkao3JyYGuYDHvhgJF+DrjMQp9SX86w==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-alphanumerical": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.0.tgz",
+      "integrity": "sha512-t+2GlJ+hO9yagJ+jU3+HSh80VKvz/3cG2cxbGGm4S0hjKuhWQXgPVUVOZz3tqZzMjhmphZ+1TIJTlRZRoe6GCQ==",
+      "dependencies": {
+        "is-alphabetical": "^2.0.0",
+        "is-decimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0="
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-buffer": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz",
+      "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz",
+      "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==",
+      "dev": true,
+      "dependencies": {
+        "has": "^1.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-decimal": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.0.tgz",
+      "integrity": "sha512-QfrfjQV0LjoWQ1K1XSoEZkTAzSa14RKVMa5zg3SdAfzEmQzRM4+tbSFWb78creCeA9rNBzaZal92opi1TwPWZw==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-empty": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/is-empty/-/is-empty-1.2.0.tgz",
+      "integrity": "sha1-3pu1snhzigWgsJpX4ftNSjQan2s="
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz",
+      "integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
+      "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-hexadecimal": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.0.tgz",
+      "integrity": "sha512-vGOtYkiaxwIiR0+Ng/zNId+ZZehGfINwTzdrDqc6iubbnQWhnPuYymOzOKUDqa2cSl59yHnEh2h6MvRLQsyNug==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-module": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
+      "integrity": "sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=",
+      "dev": true
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/is-plain-obj": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.0.0.tgz",
+      "integrity": "sha512-NXRbBtUdBioI73y/HmOhogw/U5msYPC9DAtGkJXeFcFWSFZw0mCUsPxk/snTuJHzNKA8kLBK4rH97RMB1BfCXw==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-reference": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz",
+      "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/estree": "*"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
+    },
+    "node_modules/json5": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz",
+      "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==",
+      "dependencies": {
+        "minimist": "^1.2.5"
+      },
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/libnpmconfig": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/libnpmconfig/-/libnpmconfig-1.2.1.tgz",
+      "integrity": "sha512-9esX8rTQAHqarx6qeZqmGQKBNZR5OIbl/Ayr0qQDy3oXja2iFVQQI81R6GZ2a02bSNZ9p3YOGX1O6HHCb1X7kA==",
+      "dependencies": {
+        "figgy-pudding": "^3.5.1",
+        "find-up": "^3.0.0",
+        "ini": "^1.3.5"
+      }
+    },
+    "node_modules/lines-and-columns": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.1.6.tgz",
+      "integrity": "sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA="
+    },
+    "node_modules/load-plugin": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/load-plugin/-/load-plugin-4.0.1.tgz",
+      "integrity": "sha512-4kMi+mOSn/TR51pDo4tgxROHfBHXsrcyEYSGHcJ1o6TtRaP2PsRM5EwmYbj1uiLDvbfA/ohwuSWZJzqGiai8Dw==",
+      "dependencies": {
+        "import-meta-resolve": "^1.0.0",
+        "libnpmconfig": "^1.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
+      "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
+      "dependencies": {
+        "p-locate": "^3.0.0",
+        "path-exists": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/longest-streak": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.0.0.tgz",
+      "integrity": "sha512-XhUjWR5CFaQ03JOP+iSDS9koy8T5jfoImCZ4XprElw3BXsSk4MpVYOLw/6LTDKZhO13PlAXnB5gS4MHQTpkSOw==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.25.7",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.25.7.tgz",
+      "integrity": "sha512-4CrMT5DOHTDk4HYDlzmwu4FVCcIYI8gauveasrdCu2IKIFOJ3f0v/8MDGJCDL9oD2ppz/Av1b0Nj345H9M+XIA==",
+      "dev": true,
+      "dependencies": {
+        "sourcemap-codec": "^1.4.4"
+      }
+    },
+    "node_modules/markdown-extensions": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-1.1.1.tgz",
+      "integrity": "sha512-WWC0ZuMzCyDHYCasEGs4IPvLyTGftYwh6wIEOULOF0HXcqZlhwRzrK0w2VUlxWA98xnvb/jszw4ZSkJ6ADpM6Q==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/markdown-table": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.1.tgz",
+      "integrity": "sha512-CBbaYXKSGnE1uLRpKA1SWgIRb2PQrpkllNWpZtZe6VojOJ4ysqiq7/2glYcmKsOYN09QgH/HEBX5hIshAeiK6A==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/mdast-util-find-and-replace": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-2.1.0.tgz",
+      "integrity": "sha512-1w1jbqAd13oU78QPBf5223+xB+37ecNtQ1JElq2feWols5oEYAl+SgNDnOZipe7NfLemoEt362yUS15/wip4mw==",
+      "dependencies": {
+        "escape-string-regexp": "^5.0.0",
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-find-and-replace/node_modules/unist-util-visit-parents": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz",
+      "integrity": "sha512-1xAFJXAKpnnJl8G7K5KgU7FY55y3GcLIXqkzUj5QF/QVP7biUm0K0O2oqVkYsdjzJKifYeWn9+o6piAK2hGSHw==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-from-markdown": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-1.0.0.tgz",
+      "integrity": "sha512-uj2G60sb7z1PNOeElFwCC9b/Se/lFXuLhVKFOAY2EHz/VvgbupTQRNXPoZl7rGpXYL6BNZgcgaybrlSWbo7n/g==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "micromark": "^3.0.0",
+        "micromark-util-decode-numeric-character-reference": "^1.0.0",
+        "micromark-util-normalize-identifier": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0",
+        "parse-entities": "^3.0.0",
+        "unist-util-stringify-position": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-1.0.0.tgz",
+      "integrity": "sha512-JY4qImsTqivQ0Gl3qvdaizCpomFaNrHnjEhNjNNKeNEA5jZHAJDYu1+yO4V9jn4/ti8GrKdAScaT4F71knoxsA==",
+      "dependencies": {
+        "mdast-util-gfm-autolink-literal": "^1.0.0",
+        "mdast-util-gfm-strikethrough": "^1.0.0",
+        "mdast-util-gfm-table": "^1.0.0",
+        "mdast-util-gfm-task-list-item": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-autolink-literal": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-1.0.0.tgz",
+      "integrity": "sha512-NaGypnNJop+hybP/PLnMVV5aN14VFda31DU+j8qsQdPR8m8AENuCX959hXaCiwVeUem33O6zY+JTt0sH1Kj7ng==",
+      "dependencies": {
+        "ccount": "^2.0.0",
+        "mdast-util-find-and-replace": "^2.0.0",
+        "micromark-util-character": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-strikethrough": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-1.0.0.tgz",
+      "integrity": "sha512-gM9ipBUdRxYa6Yq1Hd8Otg6jEn/dRxFZ1F9ZX4QHosHOexLGqNZO2dh0A+YFbUEd10RcKjnjb4jOfJJzoXXUew==",
+      "dependencies": {
+        "@types/mdast": "^3.0.3",
+        "mdast-util-to-markdown": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-table": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-1.0.1.tgz",
+      "integrity": "sha512-NByKuaSg5+M6r9DZBPXFUmhMHGFf9u+WE76EeStN01ghi8hpnydiWBXr+qj0XCRWI7SAMNtEjGvip6zci9axQA==",
+      "dependencies": {
+        "markdown-table": "^3.0.0",
+        "mdast-util-to-markdown": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-task-list-item": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-1.0.0.tgz",
+      "integrity": "sha512-dwkzOTjQe8JCCHVE3Cb0pLHTYLudf7t9WCAnb20jI8/dW+VHjgWhjtIUVA3oigNkssgjEwX+i+3XesUdCnXGyA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.3",
+        "mdast-util-to-markdown": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-heading-style": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-heading-style/-/mdast-util-heading-style-2.0.0.tgz",
+      "integrity": "sha512-q9+WW2hJduW51LgV2r/fcU5wIt2GLFf0yYHxyi0f2aaxnC63ErBSOAJlhP6nbQ6yeG5rTCozbwOi4QNDPKV0zw==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-markdown": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-1.1.1.tgz",
+      "integrity": "sha512-4puev/CxuxVdlsx5lVmuzgdqfjkkJJLS1Zm/MnejQ8I7BLeeBlbkwp6WOGJypEcN8g56LbVbhNmn84MvvcAvSQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "parse-entities": "^3.0.0",
+        "zwitch": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-string": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-3.1.0.tgz",
+      "integrity": "sha512-n4Vypz/DZgwo0iMHLQL49dJzlp7YtAJP+N07MZHpjPf/5XJuHUWstviF4Mn2jEiR/GNmtnRRqnwsXExk3igfFA==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-3.0.3.tgz",
+      "integrity": "sha512-fWuHx+JKV4zA8WfCFor2DWP9XmsZkIiyWRGofr7P7IGfpRIlb7/C5wwusGsNyr1D8HI5arghZDG1Ikc0FBwS5Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "micromark-core-commonmark": "^1.0.0",
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-combine-extensions": "^1.0.0",
+        "micromark-util-decode-numeric-character-reference": "^1.0.0",
+        "micromark-util-encode": "^1.0.0",
+        "micromark-util-normalize-identifier": "^1.0.0",
+        "micromark-util-resolve-all": "^1.0.0",
+        "micromark-util-sanitize-uri": "^1.0.0",
+        "micromark-util-subtokenize": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0",
+        "parse-entities": "^3.0.0"
+      }
+    },
+    "node_modules/micromark-core-commonmark": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-1.0.0.tgz",
+      "integrity": "sha512-y9g7zymcKRBHM/aNBekstvs/Grpf+y4OEBULUTYvGZcusnp+JeOxmilJY4GMpo2/xY7iHQL9fjz5pD9pSAud9A==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-factory-destination": "^1.0.0",
+        "micromark-factory-label": "^1.0.0",
+        "micromark-factory-space": "^1.0.0",
+        "micromark-factory-title": "^1.0.0",
+        "micromark-factory-whitespace": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-classify-character": "^1.0.0",
+        "micromark-util-html-tag-name": "^1.0.0",
+        "micromark-util-normalize-identifier": "^1.0.0",
+        "micromark-util-resolve-all": "^1.0.0",
+        "micromark-util-subtokenize": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0",
+        "parse-entities": "^3.0.0"
+      }
+    },
+    "node_modules/micromark-extension-gfm": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-1.0.0.tgz",
+      "integrity": "sha512-OjqbQPL1Vec/4l5hnC8WnMNmWwgrT9JvzR2udqIGrGKecZsdwY9GAWZ5482CuD12SXuHNj8aS8epni6ip0Pwog==",
+      "dependencies": {
+        "micromark-extension-gfm-autolink-literal": "^1.0.0",
+        "micromark-extension-gfm-strikethrough": "^1.0.0",
+        "micromark-extension-gfm-table": "^1.0.0",
+        "micromark-extension-gfm-tagfilter": "^1.0.0",
+        "micromark-extension-gfm-task-list-item": "^1.0.0",
+        "micromark-util-combine-extensions": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-autolink-literal": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-1.0.0.tgz",
+      "integrity": "sha512-t+K0aPK32mXypVTEKV+WRfoT/Rb7MERDgHZVRr56NXpyQQhgMk72QnK4NljYUlrgbuesH+MxiPQwThzqRDIwvA==",
+      "dependencies": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-sanitize-uri": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-strikethrough": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-1.0.0.tgz",
+      "integrity": "sha512-5PhVJVK8zRsrc+A715NBPMY5iOQwtkMfL/8XURAPeU5fPC0S5dm4qjpoA6fGy4B9MHm+6WNs3xZDxF1ZGTtGDw==",
+      "dependencies": {
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-classify-character": "^1.0.0",
+        "micromark-util-resolve-all": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-table": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-1.0.0.tgz",
+      "integrity": "sha512-OATRuHDgEAT/aaJJRSdU12V+s01kNSnJ0jumdfLq5mPy0F5DkR3zbTSFLH4tjVYM0/kEG6umxIhHY62mFe4z5Q==",
+      "dependencies": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-tagfilter": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-1.0.0.tgz",
+      "integrity": "sha512-GGUZhzQrOdHR8RHU2ru6K+4LMlj+pBdNuXRtw5prOflDOk2hHqDB0xEgej1AHJ2VETeycX7tzQh2EmaTUOmSKg==",
+      "dependencies": {
+        "micromark-util-types": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-task-list-item": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-1.0.0.tgz",
+      "integrity": "sha512-3tkHCq1NNwijtwpjYba9+rl1yvQ4xYg8iQpUAfTJRyq8MtIEsBUF/vW6B9Gh8Qwy1hE2FmpyHhP4jnFAt61zLg==",
+      "dependencies": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-factory-destination": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-1.0.0.tgz",
+      "integrity": "sha512-eUBA7Rs1/xtTVun9TmV3gjfPz2wEwgK5R5xcbIM5ZYAtvGF6JkyaDsj0agx8urXnO31tEO6Ug83iVH3tdedLnw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-factory-label": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-1.0.0.tgz",
+      "integrity": "sha512-XWEucVZb+qBCe2jmlOnWr6sWSY6NHx+wtpgYFsm4G+dufOf6tTQRRo0bdO7XSlGPu5fyjpJenth6Ksnc5Mwfww==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-factory-space": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-1.0.0.tgz",
+      "integrity": "sha512-qUmqs4kj9a5yBnk3JMLyjtWYN6Mzfcx8uJfi5XAveBniDevmZasdGBba5b4QsvRcAkmvGo5ACmSUmyGiKTLZew==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-factory-title": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-1.0.0.tgz",
+      "integrity": "sha512-flvC7Gx0dWVWorXuBl09Cr3wB5FTuYec8pMGVySIp2ZlqTcIjN/lFohZcP0EG//krTptm34kozHk7aK/CleCfA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-factory-whitespace": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-1.0.0.tgz",
+      "integrity": "sha512-Qx7uEyahU1lt1RnsECBiuEbfr9INjQTGa6Err+gF3g0Tx4YEviPbqqGKNv/NrBaE7dVHdn1bVZKM/n5I/Bak7A==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-character": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-1.1.0.tgz",
+      "integrity": "sha512-agJ5B3unGNJ9rJvADMJ5ZiYjBRyDpzKAOk01Kpi1TKhlT1APx3XZk6eN7RtSz1erbWHC2L8T3xLZ81wdtGRZzg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-chunked": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-1.0.0.tgz",
+      "integrity": "sha512-5e8xTis5tEZKgesfbQMKRCyzvffRRUX+lK/y+DvsMFdabAicPkkZV6gO+FEWi9RfuKKoxxPwNL+dFF0SMImc1g==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-symbol": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-classify-character": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-1.0.0.tgz",
+      "integrity": "sha512-F8oW2KKrQRb3vS5ud5HIqBVkCqQi224Nm55o5wYLzY/9PwHGXC01tr3d7+TqHHz6zrKQ72Okwtvm/xQm6OVNZA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-combine-extensions": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-1.0.0.tgz",
+      "integrity": "sha512-J8H058vFBdo/6+AsjHp2NF7AJ02SZtWaVUjsayNFeAiydTxUwViQPxN0Hf8dp4FmCQi0UUFovFsEyRSUmFH3MA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-numeric-character-reference": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-1.0.0.tgz",
+      "integrity": "sha512-OzO9AI5VUtrTD7KSdagf4MWgHMtET17Ua1fIpXTpuhclCqD8egFWo85GxSGvxgkGS74bEahvtM0WP0HjvV0e4w==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-symbol": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-1.0.0.tgz",
+      "integrity": "sha512-cJpFVM768h6zkd8qJ1LNRrITfY4gwFt+tziPcIf71Ui8yFzY9wG3snZQqiWVq93PG4Sw6YOtcNiKJfVIs9qfGg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ]
+    },
+    "node_modules/micromark-util-html-tag-name": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-1.0.0.tgz",
+      "integrity": "sha512-NenEKIshW2ZI/ERv9HtFNsrn3llSPZtY337LID/24WeLqMzeZhBEE6BQ0vS2ZBjshm5n40chKtJ3qjAbVV8S0g==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ]
+    },
+    "node_modules/micromark-util-normalize-identifier": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-1.0.0.tgz",
+      "integrity": "sha512-yg+zrL14bBTFrQ7n35CmByWUTFsgst5JhA4gJYoty4Dqzj4Z4Fr/DHekSS5aLfH9bdlfnSvKAWsAgJhIbogyBg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-symbol": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-resolve-all": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-1.0.0.tgz",
+      "integrity": "sha512-CB/AGk98u50k42kvgaMM94wzBqozSzDDaonKU7P7jwQIuH2RU0TeBqGYJz2WY1UdihhjweivStrJ2JdkdEmcfw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-1.0.0.tgz",
+      "integrity": "sha512-cCxvBKlmac4rxCGx6ejlIviRaMKZc0fWm5HdCHEeDWRSkn44l6NdYVRyU+0nT1XC72EQJMZV8IPHF+jTr56lAg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-encode": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-subtokenize": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-1.0.0.tgz",
+      "integrity": "sha512-EsnG2qscmcN5XhkqQBZni/4oQbLFjz9yk3ZM/P8a3YUjwV6+6On2wehr1ALx0MxK3+XXXLTzuBKHDFeDFYRdgQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "dependencies": {
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-1.0.0.tgz",
+      "integrity": "sha512-NZA01jHRNCt4KlOROn8/bGi6vvpEmlXld7EHcRH+aYWUfL3Wc8JLUNNlqUMKa0hhz6GrpUWsHtzPmKof57v0gQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ]
+    },
+    "node_modules/micromark-util-types": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-1.0.0.tgz",
+      "integrity": "sha512-psf1WAaP1B77WpW4mBGDkTr+3RsPuDAgsvlP47GJzbH1jmjH8xjOx7Z6kp84L8oqHmy5pYO3Ev46odosZV+3AA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ]
+    },
+    "node_modules/minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
+      "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
+    },
+    "node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+      "dependencies": {
+        "p-try": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
+      "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
+      "dependencies": {
+        "p-limit": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/p-try": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/parse-entities": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-3.0.0.tgz",
+      "integrity": "sha512-AJlcIFDNPEP33KyJLguv0xJc83BNvjxwpuUIcetyXUsLpVXAUCePJ5kIoYtEN2R1ac0cYaRu/vk9dVFkewHQhQ==",
+      "dependencies": {
+        "character-entities": "^2.0.0",
+        "character-entities-legacy": "^2.0.0",
+        "character-reference-invalid": "^2.0.0",
+        "is-alphanumerical": "^2.0.0",
+        "is-decimal": "^2.0.0",
+        "is-hexadecimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/parse-json": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+      "dependencies": {
+        "@babel/code-frame": "^7.0.0",
+        "error-ex": "^1.3.1",
+        "json-parse-even-better-errors": "^2.3.0",
+        "lines-and-columns": "^1.1.6"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parse5": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz",
+      "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw=="
+    },
+    "node_modules/path-exists": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
+      "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true
+    },
+    "node_modules/picomatch": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz",
+      "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pluralize": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz",
+      "integrity": "sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/property-information": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-6.0.1.tgz",
+      "integrity": "sha512-F4WUUAF7fMeF4/JUFHNBWDaKDXi2jbvqBW/y6o5wsf3j19wTZ7S60TmtB5HoBhtgw7NKQRMWuz5vk2PR0CygUg==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
+      "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/rechoir": {
+      "version": "0.6.2",
+      "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz",
+      "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=",
+      "dev": true,
+      "dependencies": {
+        "resolve": "^1.1.6"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/rehype": {
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/rehype/-/rehype-12.0.0.tgz",
+      "integrity": "sha512-gZcttmf9R5IYHb8AlI1rlmWqXS1yX0rSB/S5ZGJs8atfYZy2DobvH3Ic/gSzB+HL/+oOHPtBguw1TprfhxXBgQ==",
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "rehype-parse": "^8.0.0",
+        "rehype-stringify": "^9.0.0",
+        "unified": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/rehype-parse": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/rehype-parse/-/rehype-parse-8.0.2.tgz",
+      "integrity": "sha512-Y5AvUbTareuAcCQITTbC9SGagm1IvOOSfG5CTTaOUW0pEeoNHkOq4YmMaEywUmSwwOgel3gOF3O7Mwl1acoBzg==",
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "hast-util-from-parse5": "^7.0.0",
+        "parse5": "^6.0.0",
+        "unified": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/rehype-stringify": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-9.0.1.tgz",
+      "integrity": "sha512-xfhm8Erp7yL+RRgYmtZMJUqu6OSguwOQMfR2LkqT1dgNDQheClFMaDPVERy4/su7o0eHo0PKFGn4L68kOjVdRQ==",
+      "dependencies": {
+        "@types/hast": "^2.0.0",
+        "hast-util-to-html": "^8.0.0",
+        "unified": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark": {
+      "version": "14.0.1",
+      "resolved": "https://registry.npmjs.org/remark/-/remark-14.0.1.tgz",
+      "integrity": "sha512-7zLG3u8EUjOGuaAS9gUNJPD2j+SqDqAFHv2g6WMpE5CU9rZ6e3IKDM12KHZ3x+YNje+NMAuN55yx8S5msGSx7Q==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "remark-parse": "^10.0.0",
+        "remark-stringify": "^10.0.0",
+        "unified": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-gfm": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-2.0.0.tgz",
+      "integrity": "sha512-waIv4Tjcd2CTUDxKRYzuPyIHw1FoX4H2GjXAzXV9PxQWb+dU4fJivd/FZ+nxyzPARrqTjMIkwIwPoWNbpBhjcQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-gfm": "^1.0.0",
+        "micromark-extension-gfm": "^1.0.0",
+        "unified": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-blockquote-indentation": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-blockquote-indentation/-/remark-lint-blockquote-indentation-3.0.0.tgz",
+      "integrity": "sha512-qWWyAJWHwnVFsfKEyl51os1rr4ex9KX398g8326esJ2/RFsCYJbJaXmVk/S+uf7B7HfOWFuJo+tu/7jlZZ54+Q==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "pluralize": "^8.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-blockquote-indentation/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-checkbox-character-style": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-checkbox-character-style/-/remark-lint-checkbox-character-style-4.0.0.tgz",
+      "integrity": "sha512-NHpVZOcTJeLOI1gGOvVDz8i3sXVY3s9K+OADupEA89Syfs4YAbnrij8OMJ6ozbHTn4av/HyVfsF4IK8X2pBUeQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-checkbox-character-style/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-checkbox-content-indent": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-checkbox-content-indent/-/remark-lint-checkbox-content-indent-4.0.0.tgz",
+      "integrity": "sha512-WeB8aSC1oesu0t/wcqNEbn3bg0kRw+NK7Y5xrhQsREw6NcH1TnvjH95PvizFT5LxXAGhz4AtCFz0B28YugSznQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-checkbox-content-indent/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-code-block-style": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-code-block-style/-/remark-lint-code-block-style-3.0.0.tgz",
+      "integrity": "sha512-xZMfFeaMOb5OIM4SrNz3QTRV3u5g3/+e6Oq40A3Apwd+a9Kx49lZbGxl8vfqaczP89PTNanm2e4OqqRsCen4Mg==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-code-block-style/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-definition-spacing": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-definition-spacing/-/remark-lint-definition-spacing-3.0.0.tgz",
+      "integrity": "sha512-3LxU7lwCpfPstldcGly2ULb8knH4IOqZHoABT2KyKFw3rRFUCAEUBSl0k5eetnXXNc/X4NlHmnyjIyzhyl4PhA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-definition-spacing/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-fenced-code-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-fenced-code-flag/-/remark-lint-fenced-code-flag-3.0.0.tgz",
+      "integrity": "sha512-wvyaTvQ5F78yuw4BDQsneTCvkxHGAjq0OuDQU4pawAZMYO3qFJlau7qoLppgquY1D+jBakejMT/yKnoQgRf1dQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-fenced-code-flag/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-fenced-code-marker": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-fenced-code-marker/-/remark-lint-fenced-code-marker-3.0.0.tgz",
+      "integrity": "sha512-x3wr1+22Atr72Z7+dUS8cqwuz8m8d4UgCAfBTNO+E6pRLVeCnVMvEtuJbDI5UqBlqvkLGlNofV4lJZQvrZUxqQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-fenced-code-marker/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-file-extension": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-file-extension/-/remark-lint-file-extension-2.0.0.tgz",
+      "integrity": "sha512-fZ0nDGyuZSgkrakLKl+cjqXwOT7iAz0wfSbrkCabYW3DdN6X1QYeSlMtHPizGXuri+AZhVkrUnujSn+9P4hJ2w==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-file-extension/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-final-definition": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-final-definition/-/remark-lint-final-definition-3.0.0.tgz",
+      "integrity": "sha512-RHR8aku0jCH4AoHVepw9b0tCmiBevMtLPG1l5FKhbkLtBWk9GRRryuD3GExxsInEUN2P/a6FhvcBBtRSJbIfIA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-final-definition/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-final-newline": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-final-newline/-/remark-lint-final-newline-2.0.0.tgz",
+      "integrity": "sha512-3u1IbgVfUN5Qgid8iqc1qlZhzscs4YPu8mwyahvLWVKMkBtoRWjDIVL6+CXcPPoUB2k3p+zuZ5oaE4yfO5Pb4w==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-final-newline/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-first-heading-level": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-first-heading-level/-/remark-lint-first-heading-level-3.0.0.tgz",
+      "integrity": "sha512-SMvBHO4HJd1ZkFDfx7OikJAoq5FQe+nFPm3n4DeAKIgM1FywaC7tD7ShwTRUL2DJMzdPjlta7UQRtTryAQGj+w==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-first-heading-level/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-hard-break-spaces": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-hard-break-spaces/-/remark-lint-hard-break-spaces-3.0.0.tgz",
+      "integrity": "sha512-TNTI32Va6hE33pTYC6iqn4NvyZHqCULsOKKLnAzBocFFFIYuaNUdfKyVc9wknAAutbQLqApr8tgs1mLHtHm9Fw==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-hard-break-spaces/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-heading-style": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-heading-style/-/remark-lint-heading-style-3.0.0.tgz",
+      "integrity": "sha512-pPiXG24yXER7xXZr+J11iuMd1DXa71m6Cx7jqUO5z1Ptc7WkolcW6lNRFG76BCOJp8Jp6vH5eNITuQxYa0AnJw==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-heading-style": "^2.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-heading-style/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-list-item-bullet-indent": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-list-item-bullet-indent/-/remark-lint-list-item-bullet-indent-4.0.0.tgz",
+      "integrity": "sha512-b/U3wAJPE00xGQGYBvjPPsdXsBPJxUvITYgAZee7aA2sGEiflMGmg90anS2sJZEAoD4XtNzp96bPaY6QLN89dQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "pluralize": "^8.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-list-item-bullet-indent/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-list-item-indent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-list-item-indent/-/remark-lint-list-item-indent-3.0.0.tgz",
+      "integrity": "sha512-z7doG/aJCy8ivmfbE/cSm9HOpIeUaV5zZHMqSsZ6XZ+wXIj4wtMFVhI7fsAVs5pAB1gzSvZQuwJOfSs2//Fw2g==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "pluralize": "^8.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-list-item-indent/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-maximum-line-length": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-maximum-line-length/-/remark-lint-maximum-line-length-3.0.0.tgz",
+      "integrity": "sha512-0x5TsUDlc4IDPUObNjVtcQxzI1JokUwbVpr22akWypnZaX9QMIL+Cp1OXrKRknZVU3rIndt4QCNnjMEYKezn1g==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-maximum-line-length/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-auto-link-without-protocol": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-auto-link-without-protocol/-/remark-lint-no-auto-link-without-protocol-3.0.0.tgz",
+      "integrity": "sha512-qeJhWZcO0wnavTdpLU6M1q5RBfo4nZnYmzASoSCmIj/ZxIinluXLmLcMHC2Ol46egWdvwDNpr3V0dJP79fiJMQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-auto-link-without-protocol/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-blockquote-without-marker": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-blockquote-without-marker/-/remark-lint-no-blockquote-without-marker-5.0.0.tgz",
+      "integrity": "sha512-6m1KZE8X2OhNV9wpEPVUfFxdzgVD523unRkstlRedKC3ONLlqP/CIliAOITRmIGuUxXVjyD7mDC892bFJnJTfw==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-blockquote-without-marker/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-consecutive-blank-lines": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-consecutive-blank-lines/-/remark-lint-no-consecutive-blank-lines-4.0.0.tgz",
+      "integrity": "sha512-gP1b3lM+oemvA0WOC5HbvkjESG2BiZHL8ZDSX+wbg/2+7zu14rOmAAMiUOlk/CxbusttwJxsz8a/Wn1dEK/jPg==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "pluralize": "^8.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-consecutive-blank-lines/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-duplicate-definitions": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-duplicate-definitions/-/remark-lint-no-duplicate-definitions-3.0.0.tgz",
+      "integrity": "sha512-6VOGPegh2ZQ0d9yronmhNXhg2wLYA5litT7bC1ljg2LQwMTIjYOgJbJsQJSKWD+FiHuqVhdWvXHzyTbFCch8Aw==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-stringify-position": "^3.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-duplicate-definitions/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-file-name-articles": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-articles/-/remark-lint-no-file-name-articles-2.0.0.tgz",
+      "integrity": "sha512-PgyJXEsZDT2r1bvtwaChwTjYKPxo47/OxpJmiozwLcnPsBNbsDtrH+W5gIjNkvkENNcIQD48WZ9jIwyJiskBng==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-file-name-articles/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-file-name-consecutive-dashes": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-consecutive-dashes/-/remark-lint-no-file-name-consecutive-dashes-2.0.0.tgz",
+      "integrity": "sha512-o7yz//+vel7IFDoZ/M0BmOS4sVE3sTAFOkeYlH44meGbNnEudr+TKKa0lwopMqZHKhXgUPSayCq+D5dgRO6JLA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-file-name-consecutive-dashes/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-file-name-outer-dashes": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-outer-dashes/-/remark-lint-no-file-name-outer-dashes-2.0.0.tgz",
+      "integrity": "sha512-SZS9FeGLty0wOBLTKyboDUZpjIKMihH88ZvgdqCUgIiDlZ9/72JKtZv43UuMnMVRgKJWQCRyZtT3nSNw3HwM+g==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-file-name-outer-dashes/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-heading-content-indent": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-heading-content-indent/-/remark-lint-no-heading-content-indent-4.0.0.tgz",
+      "integrity": "sha512-2SljHUYTN83EN5DEZrl7WH4ibmUxai6gONhZaQrQOJyGUO2ReZj5Zdn4xi79NHpORSzCzjn2tSXPB6yL3AhJag==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-heading-style": "^2.0.0",
+        "pluralize": "^8.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-heading-content-indent/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-heading-indent": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-heading-indent/-/remark-lint-no-heading-indent-4.0.0.tgz",
+      "integrity": "sha512-t4MWiMjPH6TOdM8d5i5Eik6NVrOokoYy6z0GnuI7PNrmNmVVIV9CVBJU94aSXZ7friKx5ucvUEw6NhXIRcNtOw==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "pluralize": "^8.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-heading-indent/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-inline-padding": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-inline-padding/-/remark-lint-no-inline-padding-4.0.0.tgz",
+      "integrity": "sha512-dugEtHudM/UVQYzTbQoWy4aeG9Micd9g6O/uzN59sIMM8Xb+Srbv/p5/2JNtJWej9PmzINldE0AHjpuB8NiNLA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-inline-padding/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-literal-urls": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-literal-urls/-/remark-lint-no-literal-urls-3.0.0.tgz",
+      "integrity": "sha512-P+9VxemAeSGWGMmFGKcQMIsPgVDaoXnQLl0Bx/TuBms0Favb7XI3ecii/HjjDeks3zlrxlVhzvEkHBk1uH1tdA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-literal-urls/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-multiple-toplevel-headings": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-multiple-toplevel-headings/-/remark-lint-no-multiple-toplevel-headings-3.0.0.tgz",
+      "integrity": "sha512-HzPTSy9nu9RHSIUfZCbxEa7KP4CoKNbfI4SW8txh7KnYwr6vC6QgqXPF77z1sIpiSgD9X2z0LwMk0DBk1v3bmA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-stringify-position": "^3.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-multiple-toplevel-headings/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-shell-dollars": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-shell-dollars/-/remark-lint-no-shell-dollars-3.0.0.tgz",
+      "integrity": "sha512-jygHSWi+w7C/VT6+oKIMHhrnMlURWF+ohjdtkxDc/C/7FXWyHg1nJR2t+c+j5Dmirz3oSfInSGw/jUfYP048GQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-shell-dollars/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-shortcut-reference-image": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-image/-/remark-lint-no-shortcut-reference-image-3.0.0.tgz",
+      "integrity": "sha512-PyB5xkCd8moJf1MrmIXlBTSXZ8pkjXtdrmHzYba7La8S/6TKN2+LFrfN9daLG9pVsD0DSBAlvbajM/MBFh2DfQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-shortcut-reference-image/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-shortcut-reference-link": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-link/-/remark-lint-no-shortcut-reference-link-3.0.0.tgz",
+      "integrity": "sha512-SbPrP6ZfRA2IJ++L7xAivXl7PJdOMzBUlhVwlt5PsWJKWHX07TIB02GGAiMnSOLN0FnUCvgF2c5we6eU1K3plA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-shortcut-reference-link/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-table-indentation": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-table-indentation/-/remark-lint-no-table-indentation-4.0.0.tgz",
+      "integrity": "sha512-S1u4DHBS75xAcM/u1zsYize/0uB2u+xAoHbstN3JmFWsTRj5LUSppwkSrWsPk/3y9/jHJAQ4XSihwH7C95EObQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-table-indentation/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-tabs": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-tabs/-/remark-lint-no-tabs-3.0.0.tgz",
+      "integrity": "sha512-iK5gXQLoBchviHRNNDIWKQsMAbsLIZzK2ZKo0ywzNBHBckd8fy+wIP6RUosb6p/RBHtq1JG1lUC5ADg1PSj0tQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-tabs/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-trailing-spaces": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-trailing-spaces/-/remark-lint-no-trailing-spaces-2.0.1.tgz",
+      "integrity": "sha512-cj8t+nvtO6eAY2lJC7o5du8VeOCK13XiDUHL4U6k5aw6ZLr3EYWbQ/rNc6cr60eHkh5Ldm09KiZjV3CWpxqJ0g==",
+      "dependencies": {
+        "unified-lint-rule": "^1.0.2"
+      }
+    },
+    "node_modules/remark-lint-no-undefined-references": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-undefined-references/-/remark-lint-no-undefined-references-4.0.0.tgz",
+      "integrity": "sha512-HI68vLoTTCXDADAp8LQ6RqCuf9QHX7bSaaqKI1V82EyvizxgnFtvN46XIi1uiDTN+Jv/KzAAGaFrofV8OJknBA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "micromark-util-normalize-identifier": "^1.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-undefined-references/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-unused-definitions": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-unused-definitions/-/remark-lint-no-unused-definitions-3.0.0.tgz",
+      "integrity": "sha512-1LqEZx0IJx59ezXA9e0qq6h5W3n9I6oiBm3Kl+HvmXTFl1OME6f8SVFwtDbt9EaGmf+3NL+T24cWIhZWjmZ0bA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-no-unused-definitions/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-ordered-list-marker-style": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-ordered-list-marker-style/-/remark-lint-ordered-list-marker-style-3.0.0.tgz",
+      "integrity": "sha512-HDg5Fyg3tENtmI5SpEL34TvEjIiVX4GhuOjU8aOGF7T4SMG69kLyx+IWMKhg39pBw+3h4lG6FDC8IfqYXONNLg==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-ordered-list-marker-style/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-prohibited-strings": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-3.0.0.tgz",
+      "integrity": "sha512-Aw21KVeoOiDte6dNfeTfTgjKV19yWXpPjLxfJ3ShC22/r97gkGdOo4dnuwyEEAfKhr3uimtSf3rRQyGSudY5tQ==",
+      "dependencies": {
+        "escape-string-regexp": "^5.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.1",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.1"
+      }
+    },
+    "node_modules/remark-lint-prohibited-strings/node_modules/unified-lint-rule": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.1.tgz",
+      "integrity": "sha512-2RzZuuuWW+ifftM0zd/ZEng0Hb5lah+Zi+ZL/ybj8BrLO/TH2aQAMYvG+iC95aCg2FkWu/pcvVvHqsh2UMmzPg==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-rule-style": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-rule-style/-/remark-lint-rule-style-3.0.0.tgz",
+      "integrity": "sha512-KHSPHW/7YCl9gHFsqqWOqIkJYmPuxTu/5G3Ks3lG8seBDf1bg+lPPUg5TigsKa/E7juVgfTR7AhK6P+lYAp4EA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-rule-style/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-strong-marker": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-strong-marker/-/remark-lint-strong-marker-3.0.0.tgz",
+      "integrity": "sha512-nNyW3tKl0rEf2j784HzVWChAomCxzld+v2A5R5r5Zw5VogUNikZA7ZRwy51HsmhqiTWHArVGeyuvCPrpkTDZ0A==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-strong-marker/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-table-cell-padding": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-table-cell-padding/-/remark-lint-table-cell-padding-4.0.0.tgz",
+      "integrity": "sha512-jYBhfu/x0bEXt+wilHnm76q6wHnPVW2v2EuTdvAsxqkVtlvWSl9BbO4bb/L7jKqwlfiTK8E/luHKZuPiNWlucw==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-table-cell-padding/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-table-pipes": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-table-pipes/-/remark-lint-table-pipes-4.0.0.tgz",
+      "integrity": "sha512-wOIAwkPAEDArKYMEpDylycGOCCt9hUxfgirgYCaHujCvyg484GWO+n+Moabgd19O9ZjuYr2P7akuOocsTh2z3g==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-table-pipes/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-unordered-list-marker-style": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-unordered-list-marker-style/-/remark-lint-unordered-list-marker-style-3.0.0.tgz",
+      "integrity": "sha512-iwliMh7GzTdFAWKnVSabpdfcI6qoDE5PPX8hacDIZNbTe4xuUVFbopGCzsTlLiFQkTn6m3ePwOQn+lIbFofKDQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-lint-unordered-list-marker-style/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-parse": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-10.0.0.tgz",
+      "integrity": "sha512-07ei47p2Xl7Bqbn9H2VYQYirnAFJPwdMuypdozWsSbnmrkgA2e2sZLZdnDNrrsxR4onmIzH/J6KXqKxCuqHtPQ==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-from-markdown": "^1.0.0",
+        "unified": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-preset-lint-node": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-3.0.1.tgz",
+      "integrity": "sha512-L7yhho9q9vmpsfMHO2gRKFNj36106iFM4KpodE+3k3rGg5dcmhV+zcsftNh5NGzbKKKYsGQj9C5XxCR/0NwKDg==",
+      "dependencies": {
+        "js-yaml": "^4.0.0",
+        "remark-lint-blockquote-indentation": "^3.0.0",
+        "remark-lint-checkbox-character-style": "^4.0.0",
+        "remark-lint-checkbox-content-indent": "^4.0.0",
+        "remark-lint-code-block-style": "^3.0.0",
+        "remark-lint-definition-spacing": "^3.0.0",
+        "remark-lint-fenced-code-flag": "^3.0.0",
+        "remark-lint-fenced-code-marker": "^3.0.0",
+        "remark-lint-file-extension": "^2.0.0",
+        "remark-lint-final-definition": "^3.0.0",
+        "remark-lint-first-heading-level": "^3.0.0",
+        "remark-lint-heading-style": "^3.0.0",
+        "remark-lint-list-item-indent": "^3.0.0",
+        "remark-lint-maximum-line-length": "^3.0.0",
+        "remark-lint-no-consecutive-blank-lines": "^4.0.0",
+        "remark-lint-no-file-name-articles": "^2.0.0",
+        "remark-lint-no-file-name-consecutive-dashes": "^2.0.0",
+        "remark-lint-no-file-name-outer-dashes": "^2.0.0",
+        "remark-lint-no-heading-indent": "^4.0.0",
+        "remark-lint-no-multiple-toplevel-headings": "^3.0.0",
+        "remark-lint-no-shell-dollars": "^3.0.0",
+        "remark-lint-no-table-indentation": "^4.0.0",
+        "remark-lint-no-tabs": "^3.0.0",
+        "remark-lint-no-trailing-spaces": "^2.0.1",
+        "remark-lint-prohibited-strings": "^3.0.0",
+        "remark-lint-rule-style": "^3.0.0",
+        "remark-lint-strong-marker": "^3.0.0",
+        "remark-lint-table-cell-padding": "^4.0.0",
+        "remark-lint-table-pipes": "^4.0.0",
+        "remark-lint-unordered-list-marker-style": "^3.0.0",
+        "remark-preset-lint-recommended": "^6.0.0",
+        "semver": "^7.3.2",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/remark-preset-lint-node/node_modules/unified-lint-rule": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+      "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "trough": "^2.0.0",
+        "unified": "^10.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-preset-lint-recommended": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/remark-preset-lint-recommended/-/remark-preset-lint-recommended-6.0.0.tgz",
+      "integrity": "sha512-ZVugDvBLFQ2JZ/tRIb0q/Oo4Qwp8s8AD8M/8GU7VgQYQ39GDVzo8lUTg2ugWy3YuBCX7wmnP0UDOSwIJt7vn0A==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "remark-lint": "^9.0.0",
+        "remark-lint-final-newline": "^2.0.0",
+        "remark-lint-hard-break-spaces": "^3.0.0",
+        "remark-lint-list-item-bullet-indent": "^4.0.0",
+        "remark-lint-list-item-indent": "^3.0.0",
+        "remark-lint-no-auto-link-without-protocol": "^3.0.0",
+        "remark-lint-no-blockquote-without-marker": "^5.0.0",
+        "remark-lint-no-duplicate-definitions": "^3.0.0",
+        "remark-lint-no-heading-content-indent": "^4.0.0",
+        "remark-lint-no-inline-padding": "^4.0.0",
+        "remark-lint-no-literal-urls": "^3.0.0",
+        "remark-lint-no-shortcut-reference-image": "^3.0.0",
+        "remark-lint-no-shortcut-reference-link": "^3.0.0",
+        "remark-lint-no-undefined-references": "^4.0.0",
+        "remark-lint-no-unused-definitions": "^3.0.0",
+        "remark-lint-ordered-list-marker-style": "^3.0.0",
+        "unified": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-preset-lint-recommended/node_modules/mdast-comment-marker": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-comment-marker/-/mdast-comment-marker-2.0.0.tgz",
+      "integrity": "sha512-LQ4sf7vUzxz4mQQlzzBDgjaCJO5A0lkIAT9TyeNMfqaP31ooP1Qw9hprf7/V3NCo5FA1nvo5gbnfLVRY79QlDQ==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-preset-lint-recommended/node_modules/remark-lint": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint/-/remark-lint-9.0.0.tgz",
+      "integrity": "sha512-ETO4zI48PR1Nz42YiyaYBzyhOiEfppXLnck7HW2pjKqxd36SIyQgM6sxD4ToMQI9KuCgy8mLAl/iVJoDLKxVjw==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "remark-message-control": "^7.0.0",
+        "unified": "^10.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-preset-lint-recommended/node_modules/remark-message-control": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/remark-message-control/-/remark-message-control-7.0.0.tgz",
+      "integrity": "sha512-KZySoC97TrMPYfIZ9vJ7wxvQwniy68K6WCY3vmSedDN5YuGfdVOpMj6sjaZQcqbWZV9n7BhrT70E3xaUTtk4hA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-comment-marker": "^2.0.0",
+        "rehype": "^12.0.0",
+        "unified": "^10.0.0",
+        "unified-message-control": "^4.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-preset-lint-recommended/node_modules/unified-message-control": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unified-message-control/-/unified-message-control-4.0.0.tgz",
+      "integrity": "sha512-1b92N+VkPHftOsvXNOtkJm4wHlr+UDmTBF2dUzepn40oy9NxanJ9xS1RwUBTjXJwqr2K0kMbEyv1Krdsho7+Iw==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit": "^3.0.0",
+        "vfile": "^5.0.0",
+        "vfile-location": "^4.0.0",
+        "vfile-message": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-preset-lint-recommended/node_modules/unist-util-visit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-3.1.0.tgz",
+      "integrity": "sha512-Szoh+R/Ll68QWAyQyZZpQzZQm2UPbxibDvaY8Xc9SUtYgPsDzx5AWSk++UUt2hJuow8mvwR+rG+LQLw+KsuAKA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-preset-lint-recommended/node_modules/unist-util-visit-parents": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz",
+      "integrity": "sha512-1xAFJXAKpnnJl8G7K5KgU7FY55y3GcLIXqkzUj5QF/QVP7biUm0K0O2oqVkYsdjzJKifYeWn9+o6piAK2hGSHw==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-stringify": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-10.0.0.tgz",
+      "integrity": "sha512-3LAQqJ/qiUxkWc7fUcVuB7RtIT38rvmxfmJG8z1TiE/D8zi3JGQ2tTcTJu9Tptdpb7gFwU0whRi5q1FbFOb9yA==",
+      "dependencies": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-markdown": "^1.0.0",
+        "unified": "^10.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/repeat-string": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
+      "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.19.0",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.19.0.tgz",
+      "integrity": "sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==",
+      "dev": true,
+      "dependencies": {
+        "is-core-module": "^2.1.0",
+        "path-parse": "^1.0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "2.56.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.56.2.tgz",
+      "integrity": "sha512-s8H00ZsRi29M2/lGdm1u8DJpJ9ML8SUOpVVBd33XNeEeL3NVaTiUcSBHzBdF3eAyR0l7VSpsuoVUGrRHq7aPwQ==",
+      "dev": true,
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
+    "node_modules/semver": {
+      "version": "7.3.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.4.tgz",
+      "integrity": "sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==",
+      "dependencies": {
+        "lru-cache": "^6.0.0"
+      },
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/shelljs": {
+      "version": "0.8.4",
+      "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.4.tgz",
+      "integrity": "sha512-7gk3UZ9kOfPLIAbslLzyWeGiEqx9e3rxwZM0KE6EL8GlGwjym9Mrlx5/p33bWTu9YG6vcS4MBxYZDHYr5lr8BQ==",
+      "dev": true,
+      "dependencies": {
+        "glob": "^7.0.0",
+        "interpret": "^1.0.0",
+        "rechoir": "^0.6.2"
+      },
+      "bin": {
+        "shjs": "bin/shjs"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/shx": {
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/shx/-/shx-0.3.3.tgz",
+      "integrity": "sha512-nZJ3HFWVoTSyyB+evEKjJ1STiixGztlqwKLTUNV5KqMWtGey9fTd4KU1gdZ1X9BV6215pswQ/Jew9NsuS/fNDA==",
+      "dev": true,
+      "dependencies": {
+        "minimist": "^1.2.3",
+        "shelljs": "^0.8.4"
+      },
+      "bin": {
+        "shx": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/sliced": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/sliced/-/sliced-1.0.1.tgz",
+      "integrity": "sha1-CzpmK10Ewxd7GSa+qCsD+Dei70E="
+    },
+    "node_modules/sourcemap-codec": {
+      "version": "1.4.8",
+      "resolved": "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz",
+      "integrity": "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==",
+      "dev": true
+    },
+    "node_modules/space-separated-tokens": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.1.tgz",
+      "integrity": "sha512-ekwEbFp5aqSPKaqeY1PGrlGQxPNaq+Cnx4+bE2D8sciBQrHpbwoBbawqTN2+6jPs9IdWxxiUcN0K2pkczD3zmw==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.0.0.tgz",
+      "integrity": "sha512-zwXcRmLUdiWhMPrHz6EXITuyTgcEnUqDzspTkCLhQovxywWz6NP9VHgqfVg20V/1mUg0B95AKbXxNT+ALRmqCw==",
+      "dependencies": {
+        "emoji-regex": "^9.2.2",
+        "is-fullwidth-code-point": "^4.0.0",
+        "strip-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/stringify-entities": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.1.tgz",
+      "integrity": "sha512-gmMQxKXPWIO3NXNSPyWNhlYcBNGpPA/487D+9dLPnU4xBnIrnHdr8cv5rGJOS/1BRxEXRb7uKwg7BA36IWV7xg==",
+      "dependencies": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.0.0.tgz",
+      "integrity": "sha512-UhDTSnGF1dc0DRbUqr1aXwNoY3RgVkSWG8BrpnuFIxhP57IqbS7IRta2Gfiavds4yCxc5+fEAVVOgBZWnYkvzg==",
+      "dependencies": {
+        "ansi-regex": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/text-table": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ="
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/to-vfile": {
+      "version": "7.2.1",
+      "resolved": "https://registry.npmjs.org/to-vfile/-/to-vfile-7.2.1.tgz",
+      "integrity": "sha512-biljADNq2n+AZn/zX+/87zStnIqctKr/q5OaOD8+qSKINokUGPbWBShvxa1iLUgHz6dGGjVnQPNoFRtVBzMkVg==",
+      "dependencies": {
+        "is-buffer": "^2.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/trough": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-2.0.2.tgz",
+      "integrity": "sha512-FnHq5sTMxC0sk957wHDzRnemFnNBvt/gSY99HzK8F7UP5WAbvP70yX5bd7CjEQkN+TjdxwI7g7lJ6podqrG2/w==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c="
+    },
+    "node_modules/unified": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-10.1.0.tgz",
+      "integrity": "sha512-4U3ru/BRXYYhKbwXV6lU6bufLikoAavTwev89H5UxY8enDFaAT2VXmIXYNm6hb5oHPng/EXr77PVyDFcptbk5g==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "bail": "^2.0.0",
+        "extend": "^3.0.0",
+        "is-buffer": "^2.0.0",
+        "is-plain-obj": "^4.0.0",
+        "trough": "^2.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unified-args": {
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/unified-args/-/unified-args-9.0.2.tgz",
+      "integrity": "sha512-qSqryjoqfJSII4E4Z2Jx7MhXX2MuUIn6DsrlmL8UnWFdGtrWvEtvm7Rx5fKT5TPUz7q/Fb4oxwIHLCttvAuRLQ==",
+      "dependencies": {
+        "@types/text-table": "^0.2.0",
+        "camelcase": "^6.0.0",
+        "chalk": "^4.0.0",
+        "chokidar": "^3.0.0",
+        "fault": "^2.0.0",
+        "json5": "^2.0.0",
+        "minimist": "^1.0.0",
+        "text-table": "^0.2.0",
+        "unified-engine": "^9.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unified-engine": {
+      "version": "9.0.3",
+      "resolved": "https://registry.npmjs.org/unified-engine/-/unified-engine-9.0.3.tgz",
+      "integrity": "sha512-SgzREcCM2IpUy3JMFUcPRZQ2Py6IwvJ2KIrg2AiI7LnGge6E6OPFWpcabHrEXG0IvO2OI3afiD9DOcQvvZfXDQ==",
+      "dependencies": {
+        "@types/concat-stream": "^1.0.0",
+        "@types/debug": "^4.0.0",
+        "@types/is-empty": "^1.0.0",
+        "@types/js-yaml": "^4.0.0",
+        "@types/node": "^16.0.0",
+        "@types/unist": "^2.0.0",
+        "concat-stream": "^2.0.0",
+        "debug": "^4.0.0",
+        "fault": "^2.0.0",
+        "glob": "^7.0.0",
+        "ignore": "^5.0.0",
+        "is-buffer": "^2.0.0",
+        "is-empty": "^1.0.0",
+        "is-plain-obj": "^4.0.0",
+        "js-yaml": "^4.0.0",
+        "load-plugin": "^4.0.0",
+        "parse-json": "^5.0.0",
+        "to-vfile": "^7.0.0",
+        "trough": "^2.0.0",
+        "unist-util-inspect": "^7.0.0",
+        "vfile-message": "^3.0.0",
+        "vfile-reporter": "^7.0.0",
+        "vfile-statistics": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unified-lint-rule": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-1.0.6.tgz",
+      "integrity": "sha512-YPK15YBFwnsVorDFG/u0cVVQN5G2a3V8zv5/N6KN3TCG+ajKtaALcy7u14DCSrJI+gZeyYquFL9cioJXOGXSvg==",
+      "dependencies": {
+        "wrapped": "^1.0.1"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-generated": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-2.0.0.tgz",
+      "integrity": "sha512-TiWE6DVtVe7Ye2QxOVW9kqybs6cZexNwTwSMVgkfjEReqy/xwGpAXb99OxktoWwmL+Z+Epb0Dn8/GNDYP1wnUw==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-inspect": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-inspect/-/unist-util-inspect-7.0.0.tgz",
+      "integrity": "sha512-2Utgv78I7PUu461Y9cdo+IUiiKSKpDV5CE/XD6vTj849a3xlpDAScvSJ6cQmtFBGgAmCn2wR7jLuXhpg1XLlJw==",
+      "dependencies": {
+        "@types/unist": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
+      "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
+      "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.0.tgz",
+      "integrity": "sha512-SdfAl8fsDclywZpfMDTVDxA2V7LjtRDTOFd44wUJamgl6OlVngsqWjxvermMYf60elWHbxhuRCZml7AnuXCaSA==",
+      "dependencies": {
+        "@types/unist": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
+      "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
+      "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
+    },
+    "node_modules/vfile": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.0.2.tgz",
+      "integrity": "sha512-5cV+K7tX83MT3bievROc+7AvHv0GXDB0zqbrTjbOe+HRbkzvY4EP+wS3IR77kUBCoWFMdG9py18t0sesPtQ1Rw==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "is-buffer": "^2.0.0",
+        "unist-util-stringify-position": "^3.0.0",
+        "vfile-message": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-location": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
+      "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "vfile": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.0.2.tgz",
+      "integrity": "sha512-UUjZYIOg9lDRwwiBAuezLIsu9KlXntdxwG+nXnjuQAHvBpcX3x0eN8h+I7TkY5nkCXj+cWVp4ZqebtGBvok8ww==",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-stringify-position": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-reporter": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/vfile-reporter/-/vfile-reporter-7.0.1.tgz",
+      "integrity": "sha512-pof+cQSJCUNmHG6zoBOJfErb6syIWHWM14CwKjsugCixxl4CZdrgzgxwLBW8lIB6czkzX0Agnnhj33YpKyLvmA==",
+      "dependencies": {
+        "@types/repeat-string": "^1.0.0",
+        "@types/supports-color": "^8.0.0",
+        "repeat-string": "^1.0.0",
+        "string-width": "^5.0.0",
+        "supports-color": "^9.0.0",
+        "unist-util-stringify-position": "^3.0.0",
+        "vfile-sort": "^3.0.0",
+        "vfile-statistics": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-reporter/node_modules/has-flag": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-5.0.1.tgz",
+      "integrity": "sha512-CsNUt5x9LUdx6hnk/E2SZLsDyvfqANZSUq4+D3D8RzDJ2M+HDTIkF60ibS1vHaK55vzgiZw1bEPFG9yH7l33wA==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/vfile-reporter/node_modules/supports-color": {
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-9.0.2.tgz",
+      "integrity": "sha512-ii6tc8ImGFrgMPYq7RVAMKkhPo9vk8uA+D3oKbJq/3Pk2YSMv1+9dUAesa9UxMbxBTvxwKTQffBahNVNxEvM8Q==",
+      "dependencies": {
+        "has-flag": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/vfile-sort": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/vfile-sort/-/vfile-sort-3.0.0.tgz",
+      "integrity": "sha512-fJNctnuMi3l4ikTVcKpxTbzHeCgvDhnI44amA3NVDvA6rTC6oKCFpCVyT5n2fFMr3ebfr+WVQZedOCd73rzSxg==",
+      "dependencies": {
+        "vfile-message": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-statistics": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/vfile-statistics/-/vfile-statistics-2.0.0.tgz",
+      "integrity": "sha512-foOWtcnJhKN9M2+20AOTlWi2dxNfAoeNIoxD5GXcO182UJyId4QrXa41fWrgcfV3FWTjdEDy3I4cpLVcQscIMA==",
+      "dependencies": {
+        "vfile-message": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/web-namespaces": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.0.tgz",
+      "integrity": "sha512-dE7ELZRVWh0ceQsRgkjLgsAvwTuv3kcjSY/hLjqL0llleUlQBDjE9JkB9FCBY5F2mnFEwiyJoowl8+NVGHe8dw==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/wrapped": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/wrapped/-/wrapped-1.0.1.tgz",
+      "integrity": "sha1-x4PZ2Aeyc+mwHoUWgKk4yHyQckI=",
+      "dependencies": {
+        "co": "3.1.0",
+        "sliced": "^1.0.1"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
+    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.2.tgz",
+      "integrity": "sha512-JZxotl7SxAJH0j7dN4pxsTV6ZLXoLdGME+PsjkL/DaBrVryK9kTGq06GfKrwcSOqypP+fdXGoCHE36b99fWVoA==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    }
+  },
   "dependencies": {
     "@babel/code-frame": {
-      "version": "7.8.3",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.8.3.tgz",
-      "integrity": "sha512-a9gxpmdXtZEInkCSHUJDLHZVBgb1QS0jhss4cPP93EW7s+uC5bikET2twEF3KV+7rDblJcmNvTR7VJejqd2C2g==",
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.14.5.tgz",
+      "integrity": "sha512-9pzDqyc6OLDaqe+zbACgFkb6fKMNG6CObKpnYXChRsvYGyEdc7CA2BaqeOM+vOtCS5ndmJicPJhKAwYRI6UfFw==",
       "requires": {
-        "@babel/highlight": "^7.8.3"
+        "@babel/highlight": "^7.14.5"
       }
     },
     "@babel/helper-validator-identifier": {
-      "version": "7.9.5",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.9.5.tgz",
-      "integrity": "sha512-/8arLKUFq882w4tWGj9JYzRpAlZgiWUJ+dtteNTDqrRBz9Iguck9Rn3ykuBDoUwh2TO4tSAJlrxDUOXWklJe4g=="
+      "version": "7.14.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.9.tgz",
+      "integrity": "sha512-pQYxPY0UP6IHISRitNe8bsijHex4TWZXi2HwKVsjPiltzlhse2znVcm9Ace510VT1kxIHjGJCZZQBX2gJDbo0g=="
     },
     "@babel/highlight": {
-      "version": "7.9.0",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.9.0.tgz",
-      "integrity": "sha512-lJZPilxX7Op3Nv/2cvFdnlepPXDxi29wxteT57Q965oc5R9v86ztx0jfxVrTcBk8C2kcPkkDa2Z4T3ZsPPVWsQ==",
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.14.5.tgz",
+      "integrity": "sha512-qf9u2WFWVV0MppaL877j2dBtQIDgmidgjGk5VIMw3OadXvYaXn66U1BFlH2t4+t3i+8PhedppRv+i40ABzd+gg==",
       "requires": {
-        "@babel/helper-validator-identifier": "^7.9.0",
+        "@babel/helper-validator-identifier": "^7.14.5",
         "chalk": "^2.0.0",
         "js-tokens": "^4.0.0"
       },
@@ -58,6 +4186,11 @@
           "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
           "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU="
         },
+        "escape-string-regexp": {
+          "version": "1.0.5",
+          "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+          "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ="
+        },
         "has-flag": {
           "version": "3.0.0",
           "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
@@ -74,53 +4207,77 @@
       }
     },
     "@rollup/plugin-commonjs": {
-      "version": "11.0.1",
-      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-11.0.1.tgz",
-      "integrity": "sha512-SaVUoaLDg3KnIXC5IBNIspr1APTYDzk05VaYcI6qz+0XX3ZlSCwAkfAhNSOxfd5GAdcm/63Noi4TowOY9MpcDg==",
+      "version": "20.0.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-20.0.0.tgz",
+      "integrity": "sha512-5K0g5W2Ol8hAcTHqcTBHiA7M58tfmYi1o9KxeJuuRNpGaTa5iLjcyemBitCBcKXaHamOBBEH2dGom6v6Unmqjg==",
       "dev": true,
       "requires": {
-        "@rollup/pluginutils": "^3.0.0",
-        "estree-walker": "^0.6.1",
-        "is-reference": "^1.1.2",
-        "magic-string": "^0.25.2",
-        "resolve": "^1.11.0"
+        "@rollup/pluginutils": "^3.1.0",
+        "commondir": "^1.0.1",
+        "estree-walker": "^2.0.1",
+        "glob": "^7.1.6",
+        "is-reference": "^1.2.1",
+        "magic-string": "^0.25.7",
+        "resolve": "^1.17.0"
       }
     },
     "@rollup/plugin-json": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@rollup/plugin-json/-/plugin-json-4.0.1.tgz",
-      "integrity": "sha512-soxllkhOGgchswBAAaTe7X9G80U2tjjHvXv0sBrriLJcC/89PkP59iTrKPOfbz3SjX088mKDmMhAscuyLz8ZSg==",
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-json/-/plugin-json-4.1.0.tgz",
+      "integrity": "sha512-yfLbTdNS6amI/2OpmbiBoW12vngr5NW2jCJVZSBEz+H5KfUJZ2M7sDjk0U6GOOdCWFVScShte29o9NezJ53TPw==",
       "dev": true,
       "requires": {
-        "rollup-pluginutils": "^2.5.0"
+        "@rollup/pluginutils": "^3.0.8"
       }
     },
     "@rollup/plugin-node-resolve": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-7.0.0.tgz",
-      "integrity": "sha512-+vOx2+WMBMFotYKM3yYeDGZxIvcQ7yO4g+SuKDFsjKaq8Lw3EPgfB6qNlp8Z/3ceDCEhHvC9/b+PgBGwDQGbzQ==",
+      "version": "13.0.4",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-13.0.4.tgz",
+      "integrity": "sha512-eYq4TFy40O8hjeDs+sIxEH/jc9lyuI2k9DM557WN6rO5OpnC2qXMBNj4IKH1oHrnAazL49C5p0tgP0/VpqJ+/w==",
       "dev": true,
       "requires": {
-        "@rollup/pluginutils": "^3.0.0",
-        "@types/resolve": "0.0.8",
+        "@rollup/pluginutils": "^3.1.0",
+        "@types/resolve": "1.17.1",
         "builtin-modules": "^3.1.0",
+        "deepmerge": "^4.2.2",
         "is-module": "^1.0.0",
-        "resolve": "^1.11.1"
+        "resolve": "^1.19.0"
       }
     },
     "@rollup/pluginutils": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.0.4.tgz",
-      "integrity": "sha512-buc0oeq2zqQu2mpMyvZgAaQvitikYjT/4JYhA4EXwxX8/g0ZGHoGiX+0AwmfhrNqH4oJv67gn80sTZFQ/jL1bw==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz",
+      "integrity": "sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==",
       "dev": true,
       "requires": {
-        "estree-walker": "^0.6.1"
+        "@types/estree": "0.0.39",
+        "estree-walker": "^1.0.1",
+        "picomatch": "^2.2.2"
+      },
+      "dependencies": {
+        "estree-walker": {
+          "version": "1.0.1",
+          "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz",
+          "integrity": "sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==",
+          "dev": true
+        }
+      }
+    },
+    "@types/concat-stream": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@types/concat-stream/-/concat-stream-1.6.1.tgz",
+      "integrity": "sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==",
+      "requires": {
+        "@types/node": "*"
       }
     },
-    "@types/color-name": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@types/color-name/-/color-name-1.1.1.tgz",
-      "integrity": "sha512-rr+OQyAjxze7GgWrSaJwydHStIhHq2lvY3BOC2Mj7KnzI7XK0Uw1TOOdI9lDoajEbSWLiYgoo4f1R51erQfhPQ=="
+    "@types/debug": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.7.tgz",
+      "integrity": "sha512-9AonUzyTjXXhEOa0DnqpzZi6VHlqKMswga9EXjpXnnqxwLtdvPPtlO8evrI5D9S6asFRCQ6v+wpiUKbw+vKqyg==",
+      "requires": {
+        "@types/ms": "*"
+      }
     },
     "@types/estree": {
       "version": "0.0.39",
@@ -128,67 +4285,107 @@
       "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==",
       "dev": true
     },
+    "@types/hast": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.2.tgz",
+      "integrity": "sha512-Op5W7jYgZI7AWKY5wQ0/QNMzQM7dGQPyW1rXKNiymVCy5iTfdPuGu4HhYNOM2sIv8gUfIuIdcYlXmAepwaowow==",
+      "requires": {
+        "@types/unist": "*"
+      }
+    },
+    "@types/is-empty": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@types/is-empty/-/is-empty-1.2.0.tgz",
+      "integrity": "sha512-brJKf2boFhUxTDxlpI7cstwiUtA2ovm38UzFTi9aZI6//ARncaV+Q5ALjCaJqXaMtdZk/oPTJnSutugsZR6h8A=="
+    },
+    "@types/js-yaml": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/js-yaml/-/js-yaml-4.0.2.tgz",
+      "integrity": "sha512-KbeHS/Y4R+k+5sWXEYzAZKuB1yQlZtEghuhRxrVRLaqhtoG5+26JwQsa4HyS3AWX8v1Uwukma5HheduUDskasA=="
+    },
+    "@types/mdast": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.3.tgz",
+      "integrity": "sha512-SXPBMnFVQg1s00dlMCc/jCdvPqdE4mXaMMCeRlxLDmTAEoegHT53xKtkDnzDTOcmMHUfcjyf36/YYZ6SxRdnsw==",
+      "requires": {
+        "@types/unist": "*"
+      }
+    },
+    "@types/ms": {
+      "version": "0.7.31",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.31.tgz",
+      "integrity": "sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA=="
+    },
     "@types/node": {
-      "version": "13.1.8",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-13.1.8.tgz",
-      "integrity": "sha512-6XzyyNM9EKQW4HKuzbo/CkOIjn/evtCmsU+MUM1xDfJ+3/rNjBttM1NgN7AOQvN6tP1Sl1D1PIKMreTArnxM9A==",
-      "dev": true
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.6.1.tgz",
+      "integrity": "sha512-Sr7BhXEAer9xyGuCN3Ek9eg9xPviCF2gfu9kTfuU2HkTVAMYSDeX40fvpmo72n5nansg3nsBjuQBrsS28r+NUw=="
+    },
+    "@types/parse5": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/@types/parse5/-/parse5-6.0.1.tgz",
+      "integrity": "sha512-ARATsLdrGPUnaBvxLhUlnltcMgn7pQG312S8ccdYlnyijabrX9RN/KN/iGj9Am96CoW8e/K9628BA7Bv4XHdrA=="
+    },
+    "@types/repeat-string": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@types/repeat-string/-/repeat-string-1.6.1.tgz",
+      "integrity": "sha512-vdna8kjLGljgtPnYN6MBD2UwX62QE0EFLj9QlLXvg6dEu66NksXB900BNguBCMZZY2D9SSqncUskM23vT3uvWQ=="
     },
     "@types/resolve": {
-      "version": "0.0.8",
-      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-0.0.8.tgz",
-      "integrity": "sha512-auApPaJf3NPfe18hSoJkp8EbZzer2ISk7o8mCC3M9he/a04+gbMF97NkpD2S8riMGvm4BMRI59/SZQSaLTKpsQ==",
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.17.1.tgz",
+      "integrity": "sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==",
       "dev": true,
       "requires": {
         "@types/node": "*"
       }
     },
+    "@types/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/@types/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-dPWnWsf+kzIG140B8z2w3fr5D03TLWbOAFQl45xUpI3vcizeXriNR5VYkWZ+WTMsUHqZ9Xlt3hrxGNANFyNQfw=="
+    },
+    "@types/text-table": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/@types/text-table/-/text-table-0.2.2.tgz",
+      "integrity": "sha512-dGoI5Af7To0R2XE8wJuc6vwlavWARsCh3UKJPjWs1YEqGUqfgBI/j/4GX0yf19/DsDPPf0YAXWAp8psNeIehLg=="
+    },
     "@types/unist": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.3.tgz",
       "integrity": "sha512-FvUupuM3rlRsRtCN+fDudtmytGO6iHJuuRKS1Ss0pG5z8oX0diNEw94UEL7hgDbpN94rgaK5R7sWm6RrSkZuAQ=="
     },
-    "acorn": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.1.1.tgz",
-      "integrity": "sha512-add7dgA5ppRPxCFJoAGfMDi7PIBXq1RtGo7BhbLaxwrXPOmw8gq48Y9ozT01hUKy9byMjlR20EJhu5zlkErEkg==",
-      "dev": true
-    },
     "ansi-regex": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz",
-      "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg=="
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.0.tgz",
+      "integrity": "sha512-tAaOSrWCHF+1Ear1Z4wnJCXA9GGox4K6Ic85a5qalES2aeEwQGr7UC93mwef49536PkCYjzkp0zIxfFvexJ6zQ=="
     },
     "ansi-styles": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.2.1.tgz",
-      "integrity": "sha512-9VGjrMsG1vePxcSweQsN20KY/c4zN0h9fLjqAbwbPfahM3t+NL+M9HC8xeXG2I8pX5NoamTGNuomEUFI7fcUjA==",
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
       "requires": {
-        "@types/color-name": "^1.1.1",
         "color-convert": "^2.0.1"
       }
     },
     "anymatch": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz",
-      "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz",
+      "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==",
       "requires": {
         "normalize-path": "^3.0.0",
         "picomatch": "^2.0.4"
       }
     },
     "argparse": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
-      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
-      "requires": {
-        "sprintf-js": "~1.0.2"
-      }
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
     },
     "bail": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/bail/-/bail-1.0.5.tgz",
-      "integrity": "sha512-xFbRxM1tahm08yHBP16MMjVUAvDaBMD38zsM9EMAUN61omwLmKlOpB/Zku5QkjZ8TZ4vn53pj+t518cH0S03RQ=="
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.1.tgz",
+      "integrity": "sha512-d5FoTAr2S5DSUPKl85WNm2yUwsINN8eidIdIwsOge2t33DaOfOdSmmsI11jMN3GmALCXaw+Y6HMVHDzePshFAA=="
     },
     "balanced-match": {
       "version": "1.0.0",
@@ -196,9 +4393,9 @@
       "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c="
     },
     "binary-extensions": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.0.0.tgz",
-      "integrity": "sha512-Phlt0plgpIIBOGTT/ehfFnbNlfsDEiqmzE2KRXoX1bLIlir4X/MR+zSyBEkL05ffWgnRSf/DXv+WrUAVr93/ow=="
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA=="
     },
     "brace-expansion": {
       "version": "1.1.11",
@@ -218,68 +4415,76 @@
       }
     },
     "buffer-from": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
-      "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A=="
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
     },
     "builtin-modules": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.1.0.tgz",
-      "integrity": "sha512-k0KL0aWZuBt2lrxrcASWDfwOLMnodeQjodT/1SxEQAXsHANgo6ZC/VEaSEHCXt7aSTZ4/4H5LKa+tBXmW7Vtvw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.2.0.tgz",
+      "integrity": "sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==",
       "dev": true
     },
+    "builtins": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/builtins/-/builtins-4.0.0.tgz",
+      "integrity": "sha512-qC0E2Dxgou1IHhvJSLwGDSTvokbRovU5zZFuDY6oY8Y2lF3nGt5Ad8YZK7GMtqzY84Wu7pXTPeHQeHcXSXsRhw==",
+      "requires": {
+        "semver": "^7.0.0"
+      }
+    },
     "camelcase": {
-      "version": "5.3.1",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
-      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg=="
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz",
+      "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg=="
     },
     "ccount": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/ccount/-/ccount-1.0.5.tgz",
-      "integrity": "sha512-MOli1W+nfbPLlKEhInaxhRdp7KVLFxLN5ykwzHgLsLI3H3gs5jjFAK4Eoj3OzzcxCtumDaI8onoVDeQyWaNTkw=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.0.tgz",
+      "integrity": "sha512-VOR0NWFYX65n9gELQdcpqsie5L5ihBXuZGAgaPEp/U7IOSjnPMEH6geE+2f6lcekaNEfWzAHS45mPvSo5bqsUA=="
     },
     "chalk": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz",
-      "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
       "requires": {
         "ansi-styles": "^4.1.0",
         "supports-color": "^7.1.0"
       }
     },
     "character-entities": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-1.2.4.tgz",
-      "integrity": "sha512-iBMyeEHxfVnIakwOuDXpVkc54HijNgCyQB2w0VfGQThle6NXn50zU6V/u+LDhxHcDUPojn6Kpga3PTAD8W1bQw=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.0.tgz",
+      "integrity": "sha512-oHqMj3eAuJ77/P5PaIRcqk+C3hdfNwyCD2DAUcD5gyXkegAuF2USC40CEqPscDk4I8FRGMTojGJQkXDsN5QlJA=="
     },
     "character-entities-html4": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-1.1.4.tgz",
-      "integrity": "sha512-HRcDxZuZqMx3/a+qrzxdBKBPUpxWEq9xw2OPZ3a/174ihfrQKVsFhqtthBInFy1zZ9GgZyFXOatNujm8M+El3g=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.0.0.tgz",
+      "integrity": "sha512-dwT2xh5ZhUAjyP96k57ilMKoTQyASaw9IAMR9U5c1lCu2RUni6O6jxfpUEdO2RcPT6TJFvr8pqsbami4Jk+2oA=="
     },
     "character-entities-legacy": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-1.1.4.tgz",
-      "integrity": "sha512-3Xnr+7ZFS1uxeiUDvV02wQ+QDbc55o97tIV5zHScSPJpcLm/r0DFPcoY3tYRp+VZukxuMeKgXYmsXQHO05zQeA=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-2.0.0.tgz",
+      "integrity": "sha512-YwaEtEvWLpFa6Wh3uVLrvirA/ahr9fki/NUd/Bd4OR6EdJ8D22hovYQEOUCBfQfcqnC4IAMGMsHXY1eXgL4ZZA=="
     },
     "character-reference-invalid": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-1.1.4.tgz",
-      "integrity": "sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.0.tgz",
+      "integrity": "sha512-pE3Z15lLRxDzWJy7bBHBopRwfI20sbrMVLQTC7xsPglCHf4Wv1e167OgYAFP78co2XlhojDyAqA+IAJse27//g=="
     },
     "chokidar": {
-      "version": "3.4.0",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.4.0.tgz",
-      "integrity": "sha512-aXAaho2VJtisB/1fg1+3nlLJqGOuewTzQpd/Tz0yTg2R0e4IGtshYvtjowyEumcBv2z+y4+kc75Mz7j5xJskcQ==",
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.2.tgz",
+      "integrity": "sha512-ekGhOnNVPgT77r4K/U3GDhu+FQ2S8TnK/s2KbIGXi0SZWuwkZ2QNyfWdZW+TVfn84DpEP7rLeCt2UI6bJ8GwbQ==",
       "requires": {
-        "anymatch": "~3.1.1",
+        "anymatch": "~3.1.2",
         "braces": "~3.0.2",
-        "fsevents": "~2.1.2",
-        "glob-parent": "~5.1.0",
+        "fsevents": "~2.3.2",
+        "glob-parent": "~5.1.2",
         "is-binary-path": "~2.1.0",
         "is-glob": "~4.0.1",
         "normalize-path": "~3.0.0",
-        "readdirp": "~3.4.0"
+        "readdirp": "~3.6.0"
       }
     },
     "co": {
@@ -287,11 +4492,6 @@
       "resolved": "https://registry.npmjs.org/co/-/co-3.1.0.tgz",
       "integrity": "sha1-TqVOpaCJOBUxheFSEMaNkJK8G3g="
     },
-    "collapse-white-space": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-1.0.5.tgz",
-      "integrity": "sha512-703bOOmytCYAX9cXYqoikYIx6twmFCXsnzRQheBcTG3nzKYBR4P/+wkYeH+Mvj7qUz8zZDtdyzbxfnEi/kYzRQ=="
-    },
     "color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -305,6 +4505,17 @@
       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
     },
+    "comma-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-G5yTt3KQN4Yn7Yk4ed73hlZ1evrFKXeUW3086p3PRFNp7m2vIjI6Pg+Kgb+oyzhd9F2qdcoj67+y3SdxL5XWsg=="
+    },
+    "commondir": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
+      "integrity": "sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=",
+      "dev": true
+    },
     "concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -322,17 +4533,23 @@
       }
     },
     "debug": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz",
-      "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
+      "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
       "requires": {
-        "ms": "^2.1.1"
+        "ms": "2.1.2"
       }
     },
+    "deepmerge": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz",
+      "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==",
+      "dev": true
+    },
     "emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="
     },
     "error-ex": {
       "version": "1.3.2",
@@ -342,26 +4559,15 @@
         "is-arrayish": "^0.2.1"
       }
     },
-    "es6-object-assign": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/es6-object-assign/-/es6-object-assign-1.1.0.tgz",
-      "integrity": "sha1-wsNYJlYkfDnqEHyx5mUrb58kUjw=",
-      "dev": true
-    },
     "escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ="
-    },
-    "esprima": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
-      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A=="
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="
     },
     "estree-walker": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-0.6.1.tgz",
-      "integrity": "sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
       "dev": true
     },
     "extend": {
@@ -370,9 +4576,9 @@
       "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="
     },
     "fault": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/fault/-/fault-1.0.4.tgz",
-      "integrity": "sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fault/-/fault-2.0.0.tgz",
+      "integrity": "sha512-JsDj9LFcoC+4ChII1QpXPA7YIaY8zmqPYw7h9j5n7St7a0BBKfNnwEBAUQRBx70o2q4rs+BeSNHk8Exm6xE7fQ==",
       "requires": {
         "format": "^0.2.0"
       }
@@ -382,14 +4588,6 @@
       "resolved": "https://registry.npmjs.org/figgy-pudding/-/figgy-pudding-3.5.2.tgz",
       "integrity": "sha512-0btnI/H8f2pavGMN8w40mlSKOfTK2SVJmBfBeVIj3kNw0swwgzyRq0d5TJVOwodFmtvpPeWPN/MCcfuWF0Ezbw=="
     },
-    "figures": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz",
-      "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==",
-      "requires": {
-        "escape-string-regexp": "^1.0.5"
-      }
-    },
     "fill-range": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
@@ -417,11 +4615,17 @@
       "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
     },
     "fsevents": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.3.tgz",
-      "integrity": "sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
       "optional": true
     },
+    "function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
+      "dev": true
+    },
     "glob": {
       "version": "7.1.6",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
@@ -436,22 +4640,110 @@
       }
     },
     "glob-parent": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
-      "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
       "requires": {
         "is-glob": "^4.0.1"
       }
     },
+    "has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dev": true,
+      "requires": {
+        "function-bind": "^1.1.1"
+      }
+    },
     "has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
       "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="
     },
+    "hast-util-from-parse5": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-7.1.0.tgz",
+      "integrity": "sha512-m8yhANIAccpU4K6+121KpPP55sSl9/samzQSQGpb0mTExcNh2WlvjtMwSWFhg6uqD4Rr6Nfa8N6TMypQM51rzQ==",
+      "requires": {
+        "@types/hast": "^2.0.0",
+        "@types/parse5": "^6.0.0",
+        "@types/unist": "^2.0.0",
+        "hastscript": "^7.0.0",
+        "property-information": "^6.0.0",
+        "vfile": "^5.0.0",
+        "vfile-location": "^4.0.0",
+        "web-namespaces": "^2.0.0"
+      }
+    },
+    "hast-util-is-element": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-2.1.1.tgz",
+      "integrity": "sha512-ag0fiZfRWsPiR1udvnSbaazJLGv8qd8E+/e3rW8rUZhbKG4HNJmFL4QkEceN+22BgE+uozXY30z/s+2dL6Z++g==",
+      "requires": {
+        "@types/hast": "^2.0.0",
+        "@types/unist": "^2.0.0"
+      }
+    },
+    "hast-util-parse-selector": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-3.1.0.tgz",
+      "integrity": "sha512-AyjlI2pTAZEOeu7GeBPZhROx0RHBnydkQIXlhnFzDi0qfXTmGUWoCYZtomHbrdrheV4VFUlPcfJ6LMF5T6sQzg==",
+      "requires": {
+        "@types/hast": "^2.0.0"
+      }
+    },
+    "hast-util-to-html": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-8.0.1.tgz",
+      "integrity": "sha512-S1mTqXvWVGIxrWw0xOHHvmevwCBFTRGNvXWsjE32IyEAlMhbMkK+ZuP6CAqkQ6Vb7swrehaHpfXHEI6voGDh0w==",
+      "requires": {
+        "@types/hast": "^2.0.0",
+        "ccount": "^2.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-is-element": "^2.0.0",
+        "hast-util-whitespace": "^2.0.0",
+        "html-void-elements": "^2.0.0",
+        "property-information": "^6.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-is": "^5.0.0"
+      }
+    },
+    "hast-util-whitespace": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-2.0.0.tgz",
+      "integrity": "sha512-Pkw+xBHuV6xFeJprJe2BBEoDV+AvQySaz3pPDRUs5PNZEMQjpXJJueqrpcHIXxnWTcAGi/UOCgVShlkY6kLoqg=="
+    },
+    "hastscript": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-7.0.2.tgz",
+      "integrity": "sha512-uA8ooUY4ipaBvKcMuPehTAB/YfFLSSzCwFSwT6ltJbocFUKH/GDHLN+tflq7lSRf9H86uOuxOFkh1KgIy3Gg2g==",
+      "requires": {
+        "@types/hast": "^2.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-parse-selector": "^3.0.0",
+        "property-information": "^6.0.0",
+        "space-separated-tokens": "^2.0.0"
+      }
+    },
+    "html-void-elements": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-2.0.0.tgz",
+      "integrity": "sha512-4OYzQQsBt0G9bJ/nM9/DDsjm4+fVdzAaPJJcWk5QwA3GIAPxQEeOR0rsI8HbDHQz5Gta8pVvGnnTNSbZVEVvkQ=="
+    },
     "ignore": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.4.tgz",
-      "integrity": "sha512-MzbUSahkTW1u7JpKKjY7LCARd1fU5W2rLdxlM4kdkayuCwZImjkpluF9CM1aLewYJguPDqewLam18Y6AU69A8A=="
+      "version": "5.1.8",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.8.tgz",
+      "integrity": "sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw=="
+    },
+    "import-meta-resolve": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-1.1.1.tgz",
+      "integrity": "sha512-JiTuIvVyPaUg11eTrNDx5bgQ/yMKMZffc7YSjvQeSMXy58DO2SQ8BtAf3xteZvmzvjYh14wnqNjL8XVeDy2o9A==",
+      "requires": {
+        "builtins": "^4.0.0"
+      }
     },
     "inflight": {
       "version": "1.0.6",
@@ -468,33 +4760,28 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
     "ini": {
-      "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz",
-      "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw=="
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="
     },
     "interpret": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.2.0.tgz",
-      "integrity": "sha512-mT34yGKMNceBQUoVn7iCDKDntA7SC6gycMAWzGx1z/CMCTV7b2AAtXlo3nRyHZ1FelRkQbQjprHSYGwzLtkVbw==",
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz",
+      "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==",
       "dev": true
     },
     "is-alphabetical": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-1.0.4.tgz",
-      "integrity": "sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg=="
-    },
-    "is-alphanumeric": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-alphanumeric/-/is-alphanumeric-1.0.0.tgz",
-      "integrity": "sha1-Spzvcdr0wAHB2B1j0UDPU/1oifQ="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.0.tgz",
+      "integrity": "sha512-5OV8Toyq3oh4eq6sbWTYzlGdnMT/DPI5I0zxUBxjiigQsZycpkKF3kskkao3JyYGuYDHvhgJF+DrjMQp9SX86w=="
     },
     "is-alphanumerical": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz",
-      "integrity": "sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.0.tgz",
+      "integrity": "sha512-t+2GlJ+hO9yagJ+jU3+HSh80VKvz/3cG2cxbGGm4S0hjKuhWQXgPVUVOZz3tqZzMjhmphZ+1TIJTlRZRoe6GCQ==",
       "requires": {
-        "is-alphabetical": "^1.0.0",
-        "is-decimal": "^1.0.0"
+        "is-alphabetical": "^2.0.0",
+        "is-decimal": "^2.0.0"
       }
     },
     "is-arrayish": {
@@ -511,14 +4798,23 @@
       }
     },
     "is-buffer": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.4.tgz",
-      "integrity": "sha512-Kq1rokWXOPXWuaMAqZiJW4XxsmD9zGx9q4aePabbn3qCRGedtH7Cm+zV8WETitMfu1wdh+Rvd6w5egwSngUX2A=="
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz",
+      "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ=="
+    },
+    "is-core-module": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz",
+      "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==",
+      "dev": true,
+      "requires": {
+        "has": "^1.0.3"
+      }
     },
     "is-decimal": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.4.tgz",
-      "integrity": "sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.0.tgz",
+      "integrity": "sha512-QfrfjQV0LjoWQ1K1XSoEZkTAzSa14RKVMa5zg3SdAfzEmQzRM4+tbSFWb78creCeA9rNBzaZal92opi1TwPWZw=="
     },
     "is-empty": {
       "version": "1.2.0",
@@ -531,9 +4827,9 @@
       "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI="
     },
     "is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz",
+      "integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ=="
     },
     "is-glob": {
       "version": "4.0.1",
@@ -544,9 +4840,9 @@
       }
     },
     "is-hexadecimal": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz",
-      "integrity": "sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.0.tgz",
+      "integrity": "sha512-vGOtYkiaxwIiR0+Ng/zNId+ZZehGfINwTzdrDqc6iubbnQWhnPuYymOzOKUDqa2cSl59yHnEh2h6MvRLQsyNug=="
     },
     "is-module": {
       "version": "1.0.0",
@@ -560,52 +4856,41 @@
       "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="
     },
     "is-plain-obj": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
-      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA=="
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.0.0.tgz",
+      "integrity": "sha512-NXRbBtUdBioI73y/HmOhogw/U5msYPC9DAtGkJXeFcFWSFZw0mCUsPxk/snTuJHzNKA8kLBK4rH97RMB1BfCXw=="
     },
     "is-reference": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.1.4.tgz",
-      "integrity": "sha512-uJA/CDPO3Tao3GTrxYn6AwkM4nUPJiGGYu5+cB8qbC7WGFlrKZbiRo7SFKxUAEpFUfiHofWCXBUNhvYJMh+6zw==",
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz",
+      "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==",
       "dev": true,
       "requires": {
-        "@types/estree": "0.0.39"
+        "@types/estree": "*"
       }
     },
-    "is-whitespace-character": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-whitespace-character/-/is-whitespace-character-1.0.4.tgz",
-      "integrity": "sha512-SDweEzfIZM0SJV0EUga669UTKlmL0Pq8Lno0QDQsPnvECB3IM2aP0gdx5TrU0A01MAPfViaZiI2V1QMZLaKK5w=="
-    },
-    "is-word-character": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-word-character/-/is-word-character-1.0.4.tgz",
-      "integrity": "sha512-5SMO8RVennx3nZrqtKwCGyyetPE9VDba5ugvKLaD4KopPG5kR4mQ7tNt/r7feL5yt5h3lpuBbIUmCOG2eSzXHA=="
-    },
     "js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
       "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
     },
     "js-yaml": {
-      "version": "3.13.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz",
-      "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==",
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
       "requires": {
-        "argparse": "^1.0.7",
-        "esprima": "^4.0.0"
+        "argparse": "^2.0.1"
       }
     },
-    "json-parse-better-errors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
-      "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw=="
+    "json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
     },
     "json5": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.3.tgz",
-      "integrity": "sha512-KXPvOm8K9IJKFM0bmdn8QXh7udDh1g/giieX0NLCaMnb4hEiVFqnop2ImTXCc5e0/oHz3LTqmHGtExn5hfMkOA==",
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz",
+      "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==",
       "requires": {
         "minimist": "^1.2.5"
       }
@@ -626,12 +4911,12 @@
       "integrity": "sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA="
     },
     "load-plugin": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/load-plugin/-/load-plugin-3.0.0.tgz",
-      "integrity": "sha512-od7eKCCZ62ITvFf8nHHrIiYmgOHb4xVNDRDqxBWSaao5FZyyZVX8OmRCbwjDGPrSrgIulwPNyBsWCGnhiDC0oQ==",
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/load-plugin/-/load-plugin-4.0.1.tgz",
+      "integrity": "sha512-4kMi+mOSn/TR51pDo4tgxROHfBHXsrcyEYSGHcJ1o6TtRaP2PsRM5EwmYbj1uiLDvbfA/ohwuSWZJzqGiai8Dw==",
       "requires": {
-        "libnpmconfig": "^1.0.0",
-        "resolve-from": "^5.0.0"
+        "import-meta-resolve": "^1.0.0",
+        "libnpmconfig": "^1.0.0"
       }
     },
     "locate-path": {
@@ -644,59 +4929,411 @@
       }
     },
     "longest-streak": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-2.0.4.tgz",
-      "integrity": "sha512-vM6rUVCVUJJt33bnmHiZEvr7wPT78ztX7rojL+LW51bHtLh6HTjx84LA5W4+oa6aKEJA7jJu5LR6vQRBpA5DVg=="
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.0.0.tgz",
+      "integrity": "sha512-XhUjWR5CFaQ03JOP+iSDS9koy8T5jfoImCZ4XprElw3BXsSk4MpVYOLw/6LTDKZhO13PlAXnB5gS4MHQTpkSOw=="
+    },
+    "lru-cache": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+      "requires": {
+        "yallist": "^4.0.0"
+      }
     },
     "magic-string": {
-      "version": "0.25.6",
-      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.25.6.tgz",
-      "integrity": "sha512-3a5LOMSGoCTH5rbqobC2HuDNRtE2glHZ8J7pK+QZYppyWA36yuNpsX994rIY2nCuyP7CZYy7lQq/X2jygiZ89g==",
+      "version": "0.25.7",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.25.7.tgz",
+      "integrity": "sha512-4CrMT5DOHTDk4HYDlzmwu4FVCcIYI8gauveasrdCu2IKIFOJ3f0v/8MDGJCDL9oD2ppz/Av1b0Nj345H9M+XIA==",
       "dev": true,
       "requires": {
         "sourcemap-codec": "^1.4.4"
       }
     },
-    "markdown-escapes": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/markdown-escapes/-/markdown-escapes-1.0.4.tgz",
-      "integrity": "sha512-8z4efJYk43E0upd0NbVXwgSTQs6cT3T06etieCMEg7dRbzCbxUCK/GHlX8mhHRDcp+OLlHkPKsvqQTCvsRl2cg=="
-    },
     "markdown-extensions": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-1.1.1.tgz",
       "integrity": "sha512-WWC0ZuMzCyDHYCasEGs4IPvLyTGftYwh6wIEOULOF0HXcqZlhwRzrK0w2VUlxWA98xnvb/jszw4ZSkJ6ADpM6Q=="
     },
     "markdown-table": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.1.tgz",
+      "integrity": "sha512-CBbaYXKSGnE1uLRpKA1SWgIRb2PQrpkllNWpZtZe6VojOJ4ysqiq7/2glYcmKsOYN09QgH/HEBX5hIshAeiK6A=="
+    },
+    "mdast-util-find-and-replace": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-2.1.0.tgz",
+      "integrity": "sha512-1w1jbqAd13oU78QPBf5223+xB+37ecNtQ1JElq2feWols5oEYAl+SgNDnOZipe7NfLemoEt362yUS15/wip4mw==",
+      "requires": {
+        "escape-string-regexp": "^5.0.0",
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^4.0.0"
+      },
+      "dependencies": {
+        "unist-util-visit-parents": {
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz",
+          "integrity": "sha512-1xAFJXAKpnnJl8G7K5KgU7FY55y3GcLIXqkzUj5QF/QVP7biUm0K0O2oqVkYsdjzJKifYeWn9+o6piAK2hGSHw==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-is": "^5.0.0"
+          }
+        }
+      }
+    },
+    "mdast-util-from-markdown": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-1.0.0.tgz",
+      "integrity": "sha512-uj2G60sb7z1PNOeElFwCC9b/Se/lFXuLhVKFOAY2EHz/VvgbupTQRNXPoZl7rGpXYL6BNZgcgaybrlSWbo7n/g==",
+      "requires": {
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "micromark": "^3.0.0",
+        "micromark-util-decode-numeric-character-reference": "^1.0.0",
+        "micromark-util-normalize-identifier": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0",
+        "parse-entities": "^3.0.0",
+        "unist-util-stringify-position": "^3.0.0"
+      }
+    },
+    "mdast-util-gfm": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-1.0.0.tgz",
+      "integrity": "sha512-JY4qImsTqivQ0Gl3qvdaizCpomFaNrHnjEhNjNNKeNEA5jZHAJDYu1+yO4V9jn4/ti8GrKdAScaT4F71knoxsA==",
+      "requires": {
+        "mdast-util-gfm-autolink-literal": "^1.0.0",
+        "mdast-util-gfm-strikethrough": "^1.0.0",
+        "mdast-util-gfm-table": "^1.0.0",
+        "mdast-util-gfm-task-list-item": "^1.0.0"
+      }
+    },
+    "mdast-util-gfm-autolink-literal": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-1.0.0.tgz",
+      "integrity": "sha512-NaGypnNJop+hybP/PLnMVV5aN14VFda31DU+j8qsQdPR8m8AENuCX959hXaCiwVeUem33O6zY+JTt0sH1Kj7ng==",
+      "requires": {
+        "ccount": "^2.0.0",
+        "mdast-util-find-and-replace": "^2.0.0",
+        "micromark-util-character": "^1.0.0"
+      }
+    },
+    "mdast-util-gfm-strikethrough": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-1.0.0.tgz",
+      "integrity": "sha512-gM9ipBUdRxYa6Yq1Hd8Otg6jEn/dRxFZ1F9ZX4QHosHOexLGqNZO2dh0A+YFbUEd10RcKjnjb4jOfJJzoXXUew==",
+      "requires": {
+        "@types/mdast": "^3.0.3",
+        "mdast-util-to-markdown": "^1.0.0"
+      }
+    },
+    "mdast-util-gfm-table": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-1.0.1.tgz",
+      "integrity": "sha512-NByKuaSg5+M6r9DZBPXFUmhMHGFf9u+WE76EeStN01ghi8hpnydiWBXr+qj0XCRWI7SAMNtEjGvip6zci9axQA==",
+      "requires": {
+        "markdown-table": "^3.0.0",
+        "mdast-util-to-markdown": "^1.0.0"
+      }
+    },
+    "mdast-util-gfm-task-list-item": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-1.0.0.tgz",
+      "integrity": "sha512-dwkzOTjQe8JCCHVE3Cb0pLHTYLudf7t9WCAnb20jI8/dW+VHjgWhjtIUVA3oigNkssgjEwX+i+3XesUdCnXGyA==",
+      "requires": {
+        "@types/mdast": "^3.0.3",
+        "mdast-util-to-markdown": "^1.0.0"
+      }
+    },
+    "mdast-util-heading-style": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz",
-      "integrity": "sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==",
+      "resolved": "https://registry.npmjs.org/mdast-util-heading-style/-/mdast-util-heading-style-2.0.0.tgz",
+      "integrity": "sha512-q9+WW2hJduW51LgV2r/fcU5wIt2GLFf0yYHxyi0f2aaxnC63ErBSOAJlhP6nbQ6yeG5rTCozbwOi4QNDPKV0zw==",
       "requires": {
-        "repeat-string": "^1.0.0"
+        "@types/mdast": "^3.0.0"
       }
     },
-    "mdast-comment-marker": {
+    "mdast-util-to-markdown": {
       "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/mdast-comment-marker/-/mdast-comment-marker-1.1.1.tgz",
-      "integrity": "sha512-TWZDaUtPLwKX1pzDIY48MkSUQRDwX/HqbTB4m3iYdL/zosi/Z6Xqfdv0C0hNVKvzrPjZENrpWDt4p4odeVO0Iw=="
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-1.1.1.tgz",
+      "integrity": "sha512-4puev/CxuxVdlsx5lVmuzgdqfjkkJJLS1Zm/MnejQ8I7BLeeBlbkwp6WOGJypEcN8g56LbVbhNmn84MvvcAvSQ==",
+      "requires": {
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "parse-entities": "^3.0.0",
+        "zwitch": "^2.0.0"
+      }
     },
-    "mdast-util-compact": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-compact/-/mdast-util-compact-2.0.1.tgz",
-      "integrity": "sha512-7GlnT24gEwDrdAwEHrU4Vv5lLWrEer4KOkAiKT9nYstsTad7Oc1TwqT2zIMKRdZF7cTuaf+GA1E4Kv7jJh8mPA==",
+    "mdast-util-to-string": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-3.1.0.tgz",
+      "integrity": "sha512-n4Vypz/DZgwo0iMHLQL49dJzlp7YtAJP+N07MZHpjPf/5XJuHUWstviF4Mn2jEiR/GNmtnRRqnwsXExk3igfFA=="
+    },
+    "micromark": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-3.0.3.tgz",
+      "integrity": "sha512-fWuHx+JKV4zA8WfCFor2DWP9XmsZkIiyWRGofr7P7IGfpRIlb7/C5wwusGsNyr1D8HI5arghZDG1Ikc0FBwS5Q==",
       "requires": {
-        "unist-util-visit": "^2.0.0"
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "micromark-core-commonmark": "^1.0.0",
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-combine-extensions": "^1.0.0",
+        "micromark-util-decode-numeric-character-reference": "^1.0.0",
+        "micromark-util-encode": "^1.0.0",
+        "micromark-util-normalize-identifier": "^1.0.0",
+        "micromark-util-resolve-all": "^1.0.0",
+        "micromark-util-sanitize-uri": "^1.0.0",
+        "micromark-util-subtokenize": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0",
+        "parse-entities": "^3.0.0"
       }
     },
-    "mdast-util-heading-style": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/mdast-util-heading-style/-/mdast-util-heading-style-1.0.6.tgz",
-      "integrity": "sha512-8ZuuegRqS0KESgjAGW8zTx4tJ3VNIiIaGFNEzFpRSAQBavVc7AvOo9I4g3crcZBfYisHs4seYh0rAVimO6HyOw=="
+    "micromark-core-commonmark": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-1.0.0.tgz",
+      "integrity": "sha512-y9g7zymcKRBHM/aNBekstvs/Grpf+y4OEBULUTYvGZcusnp+JeOxmilJY4GMpo2/xY7iHQL9fjz5pD9pSAud9A==",
+      "requires": {
+        "micromark-factory-destination": "^1.0.0",
+        "micromark-factory-label": "^1.0.0",
+        "micromark-factory-space": "^1.0.0",
+        "micromark-factory-title": "^1.0.0",
+        "micromark-factory-whitespace": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-classify-character": "^1.0.0",
+        "micromark-util-html-tag-name": "^1.0.0",
+        "micromark-util-normalize-identifier": "^1.0.0",
+        "micromark-util-resolve-all": "^1.0.0",
+        "micromark-util-subtokenize": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0",
+        "parse-entities": "^3.0.0"
+      }
+    },
+    "micromark-extension-gfm": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-1.0.0.tgz",
+      "integrity": "sha512-OjqbQPL1Vec/4l5hnC8WnMNmWwgrT9JvzR2udqIGrGKecZsdwY9GAWZ5482CuD12SXuHNj8aS8epni6ip0Pwog==",
+      "requires": {
+        "micromark-extension-gfm-autolink-literal": "^1.0.0",
+        "micromark-extension-gfm-strikethrough": "^1.0.0",
+        "micromark-extension-gfm-table": "^1.0.0",
+        "micromark-extension-gfm-tagfilter": "^1.0.0",
+        "micromark-extension-gfm-task-list-item": "^1.0.0",
+        "micromark-util-combine-extensions": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-extension-gfm-autolink-literal": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-1.0.0.tgz",
+      "integrity": "sha512-t+K0aPK32mXypVTEKV+WRfoT/Rb7MERDgHZVRr56NXpyQQhgMk72QnK4NljYUlrgbuesH+MxiPQwThzqRDIwvA==",
+      "requires": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-sanitize-uri": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-extension-gfm-strikethrough": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-1.0.0.tgz",
+      "integrity": "sha512-5PhVJVK8zRsrc+A715NBPMY5iOQwtkMfL/8XURAPeU5fPC0S5dm4qjpoA6fGy4B9MHm+6WNs3xZDxF1ZGTtGDw==",
+      "requires": {
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-classify-character": "^1.0.0",
+        "micromark-util-resolve-all": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-extension-gfm-table": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-1.0.0.tgz",
+      "integrity": "sha512-OATRuHDgEAT/aaJJRSdU12V+s01kNSnJ0jumdfLq5mPy0F5DkR3zbTSFLH4tjVYM0/kEG6umxIhHY62mFe4z5Q==",
+      "requires": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-extension-gfm-tagfilter": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-1.0.0.tgz",
+      "integrity": "sha512-GGUZhzQrOdHR8RHU2ru6K+4LMlj+pBdNuXRtw5prOflDOk2hHqDB0xEgej1AHJ2VETeycX7tzQh2EmaTUOmSKg==",
+      "requires": {
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-extension-gfm-task-list-item": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-1.0.0.tgz",
+      "integrity": "sha512-3tkHCq1NNwijtwpjYba9+rl1yvQ4xYg8iQpUAfTJRyq8MtIEsBUF/vW6B9Gh8Qwy1hE2FmpyHhP4jnFAt61zLg==",
+      "requires": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-factory-destination": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-1.0.0.tgz",
+      "integrity": "sha512-eUBA7Rs1/xtTVun9TmV3gjfPz2wEwgK5R5xcbIM5ZYAtvGF6JkyaDsj0agx8urXnO31tEO6Ug83iVH3tdedLnw==",
+      "requires": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-factory-label": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-1.0.0.tgz",
+      "integrity": "sha512-XWEucVZb+qBCe2jmlOnWr6sWSY6NHx+wtpgYFsm4G+dufOf6tTQRRo0bdO7XSlGPu5fyjpJenth6Ksnc5Mwfww==",
+      "requires": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-factory-space": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-1.0.0.tgz",
+      "integrity": "sha512-qUmqs4kj9a5yBnk3JMLyjtWYN6Mzfcx8uJfi5XAveBniDevmZasdGBba5b4QsvRcAkmvGo5ACmSUmyGiKTLZew==",
+      "requires": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-factory-title": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-1.0.0.tgz",
+      "integrity": "sha512-flvC7Gx0dWVWorXuBl09Cr3wB5FTuYec8pMGVySIp2ZlqTcIjN/lFohZcP0EG//krTptm34kozHk7aK/CleCfA==",
+      "requires": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-factory-whitespace": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-1.0.0.tgz",
+      "integrity": "sha512-Qx7uEyahU1lt1RnsECBiuEbfr9INjQTGa6Err+gF3g0Tx4YEviPbqqGKNv/NrBaE7dVHdn1bVZKM/n5I/Bak7A==",
+      "requires": {
+        "micromark-factory-space": "^1.0.0",
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-util-character": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-1.1.0.tgz",
+      "integrity": "sha512-agJ5B3unGNJ9rJvADMJ5ZiYjBRyDpzKAOk01Kpi1TKhlT1APx3XZk6eN7RtSz1erbWHC2L8T3xLZ81wdtGRZzg==",
+      "requires": {
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-util-chunked": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-1.0.0.tgz",
+      "integrity": "sha512-5e8xTis5tEZKgesfbQMKRCyzvffRRUX+lK/y+DvsMFdabAicPkkZV6gO+FEWi9RfuKKoxxPwNL+dFF0SMImc1g==",
+      "requires": {
+        "micromark-util-symbol": "^1.0.0"
+      }
+    },
+    "micromark-util-classify-character": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-1.0.0.tgz",
+      "integrity": "sha512-F8oW2KKrQRb3vS5ud5HIqBVkCqQi224Nm55o5wYLzY/9PwHGXC01tr3d7+TqHHz6zrKQ72Okwtvm/xQm6OVNZA==",
+      "requires": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-util-combine-extensions": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-1.0.0.tgz",
+      "integrity": "sha512-J8H058vFBdo/6+AsjHp2NF7AJ02SZtWaVUjsayNFeAiydTxUwViQPxN0Hf8dp4FmCQi0UUFovFsEyRSUmFH3MA==",
+      "requires": {
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-util-decode-numeric-character-reference": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-1.0.0.tgz",
+      "integrity": "sha512-OzO9AI5VUtrTD7KSdagf4MWgHMtET17Ua1fIpXTpuhclCqD8egFWo85GxSGvxgkGS74bEahvtM0WP0HjvV0e4w==",
+      "requires": {
+        "micromark-util-symbol": "^1.0.0"
+      }
+    },
+    "micromark-util-encode": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-1.0.0.tgz",
+      "integrity": "sha512-cJpFVM768h6zkd8qJ1LNRrITfY4gwFt+tziPcIf71Ui8yFzY9wG3snZQqiWVq93PG4Sw6YOtcNiKJfVIs9qfGg=="
+    },
+    "micromark-util-html-tag-name": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-1.0.0.tgz",
+      "integrity": "sha512-NenEKIshW2ZI/ERv9HtFNsrn3llSPZtY337LID/24WeLqMzeZhBEE6BQ0vS2ZBjshm5n40chKtJ3qjAbVV8S0g=="
+    },
+    "micromark-util-normalize-identifier": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-1.0.0.tgz",
+      "integrity": "sha512-yg+zrL14bBTFrQ7n35CmByWUTFsgst5JhA4gJYoty4Dqzj4Z4Fr/DHekSS5aLfH9bdlfnSvKAWsAgJhIbogyBg==",
+      "requires": {
+        "micromark-util-symbol": "^1.0.0"
+      }
+    },
+    "micromark-util-resolve-all": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-1.0.0.tgz",
+      "integrity": "sha512-CB/AGk98u50k42kvgaMM94wzBqozSzDDaonKU7P7jwQIuH2RU0TeBqGYJz2WY1UdihhjweivStrJ2JdkdEmcfw==",
+      "requires": {
+        "micromark-util-types": "^1.0.0"
+      }
+    },
+    "micromark-util-sanitize-uri": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-1.0.0.tgz",
+      "integrity": "sha512-cCxvBKlmac4rxCGx6ejlIviRaMKZc0fWm5HdCHEeDWRSkn44l6NdYVRyU+0nT1XC72EQJMZV8IPHF+jTr56lAg==",
+      "requires": {
+        "micromark-util-character": "^1.0.0",
+        "micromark-util-encode": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0"
+      }
+    },
+    "micromark-util-subtokenize": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-1.0.0.tgz",
+      "integrity": "sha512-EsnG2qscmcN5XhkqQBZni/4oQbLFjz9yk3ZM/P8a3YUjwV6+6On2wehr1ALx0MxK3+XXXLTzuBKHDFeDFYRdgQ==",
+      "requires": {
+        "micromark-util-chunked": "^1.0.0",
+        "micromark-util-symbol": "^1.0.0",
+        "micromark-util-types": "^1.0.0"
+      }
     },
-    "mdast-util-to-string": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-1.1.0.tgz",
-      "integrity": "sha512-jVU0Nr2B9X3MU4tSK7JP1CMkSvOj7X5l/GboG1tKRw52lLF1x2Ju92Ms9tNetCcbfX3hzlM73zYo2NKkWSfF/A=="
+    "micromark-util-symbol": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-1.0.0.tgz",
+      "integrity": "sha512-NZA01jHRNCt4KlOROn8/bGi6vvpEmlXld7EHcRH+aYWUfL3Wc8JLUNNlqUMKa0hhz6GrpUWsHtzPmKof57v0gQ=="
+    },
+    "micromark-util-types": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-1.0.0.tgz",
+      "integrity": "sha512-psf1WAaP1B77WpW4mBGDkTr+3RsPuDAgsvlP47GJzbH1jmjH8xjOx7Z6kp84L8oqHmy5pYO3Ev46odosZV+3AA=="
     },
     "minimatch": {
       "version": "3.0.4",
@@ -751,29 +5388,34 @@
       "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ=="
     },
     "parse-entities": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-2.0.0.tgz",
-      "integrity": "sha512-kkywGpCcRYhqQIchaWqZ875wzpS/bMKhz5HnN3p7wveJTkTtyAB/AlnS0f8DFSqYW1T82t6yEAkEcB+A1I3MbQ==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-3.0.0.tgz",
+      "integrity": "sha512-AJlcIFDNPEP33KyJLguv0xJc83BNvjxwpuUIcetyXUsLpVXAUCePJ5kIoYtEN2R1ac0cYaRu/vk9dVFkewHQhQ==",
       "requires": {
-        "character-entities": "^1.0.0",
-        "character-entities-legacy": "^1.0.0",
-        "character-reference-invalid": "^1.0.0",
-        "is-alphanumerical": "^1.0.0",
-        "is-decimal": "^1.0.0",
-        "is-hexadecimal": "^1.0.0"
+        "character-entities": "^2.0.0",
+        "character-entities-legacy": "^2.0.0",
+        "character-reference-invalid": "^2.0.0",
+        "is-alphanumerical": "^2.0.0",
+        "is-decimal": "^2.0.0",
+        "is-hexadecimal": "^2.0.0"
       }
     },
     "parse-json": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.0.0.tgz",
-      "integrity": "sha512-OOY5b7PAEFV0E2Fir1KOkxchnZNCdowAJgQ5NuxjpBKTRP3pQhwkrkxqQjeoKJ+fO7bCpmIZaogI4eZGDMEGOw==",
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
       "requires": {
         "@babel/code-frame": "^7.0.0",
         "error-ex": "^1.3.1",
-        "json-parse-better-errors": "^1.0.1",
+        "json-parse-even-better-errors": "^2.3.0",
         "lines-and-columns": "^1.1.6"
       }
     },
+    "parse5": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz",
+      "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw=="
+    },
     "path-exists": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
@@ -785,9 +5427,9 @@
       "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
     },
     "path-parse": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
-      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
       "dev": true
     },
     "picomatch": {
@@ -800,6 +5442,11 @@
       "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz",
       "integrity": "sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA=="
     },
+    "property-information": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-6.0.1.tgz",
+      "integrity": "sha512-F4WUUAF7fMeF4/JUFHNBWDaKDXi2jbvqBW/y6o5wsf3j19wTZ7S60TmtB5HoBhtgw7NKQRMWuz5vk2PR0CygUg=="
+    },
     "readable-stream": {
       "version": "3.6.0",
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
@@ -811,9 +5458,9 @@
       }
     },
     "readdirp": {
-      "version": "3.4.0",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.4.0.tgz",
-      "integrity": "sha512-0xe001vZBnJEK+uKcj8qOhyAKPzIT+gStxWr3LCB0DwcXR5NZJ3IaC+yGnHCYzB/S7ov3m3EEbZI2zeNvX+hGQ==",
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
       "requires": {
         "picomatch": "^2.2.1"
       }
@@ -827,379 +5474,903 @@
         "resolve": "^1.1.6"
       }
     },
-    "remark": {
+    "rehype": {
       "version": "12.0.0",
-      "resolved": "https://registry.npmjs.org/remark/-/remark-12.0.0.tgz",
-      "integrity": "sha512-oX4lMIS0csgk8AEbzY0h2jdR0ngiCHOpwwpxjmRa5TqAkeknY+tkhjRJGZqnCmvyuWh55/0SW5WY3R3nn3PH9A==",
+      "resolved": "https://registry.npmjs.org/rehype/-/rehype-12.0.0.tgz",
+      "integrity": "sha512-gZcttmf9R5IYHb8AlI1rlmWqXS1yX0rSB/S5ZGJs8atfYZy2DobvH3Ic/gSzB+HL/+oOHPtBguw1TprfhxXBgQ==",
       "requires": {
-        "remark-parse": "^8.0.0",
-        "remark-stringify": "^8.0.0",
-        "unified": "^9.0.0"
+        "@types/hast": "^2.0.0",
+        "rehype-parse": "^8.0.0",
+        "rehype-stringify": "^9.0.0",
+        "unified": "^10.0.0"
       }
     },
-    "remark-lint": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint/-/remark-lint-7.0.0.tgz",
-      "integrity": "sha512-OLrWPYy0MUcGLa/2rjuy1kQILTRRK+JiRtyUzqe4XRoHboGuvFDcy/W2e7sq5hu/0xmD+Eh7cEa1Coiqp7LeaA==",
+    "rehype-parse": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/rehype-parse/-/rehype-parse-8.0.2.tgz",
+      "integrity": "sha512-Y5AvUbTareuAcCQITTbC9SGagm1IvOOSfG5CTTaOUW0pEeoNHkOq4YmMaEywUmSwwOgel3gOF3O7Mwl1acoBzg==",
       "requires": {
-        "remark-message-control": "^6.0.0"
+        "@types/hast": "^2.0.0",
+        "hast-util-from-parse5": "^7.0.0",
+        "parse5": "^6.0.0",
+        "unified": "^10.0.0"
       }
     },
-    "remark-lint-blockquote-indentation": {
+    "rehype-stringify": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-9.0.1.tgz",
+      "integrity": "sha512-xfhm8Erp7yL+RRgYmtZMJUqu6OSguwOQMfR2LkqT1dgNDQheClFMaDPVERy4/su7o0eHo0PKFGn4L68kOjVdRQ==",
+      "requires": {
+        "@types/hast": "^2.0.0",
+        "hast-util-to-html": "^8.0.0",
+        "unified": "^10.0.0"
+      }
+    },
+    "remark": {
+      "version": "14.0.1",
+      "resolved": "https://registry.npmjs.org/remark/-/remark-14.0.1.tgz",
+      "integrity": "sha512-7zLG3u8EUjOGuaAS9gUNJPD2j+SqDqAFHv2g6WMpE5CU9rZ6e3IKDM12KHZ3x+YNje+NMAuN55yx8S5msGSx7Q==",
+      "requires": {
+        "@types/mdast": "^3.0.0",
+        "remark-parse": "^10.0.0",
+        "remark-stringify": "^10.0.0",
+        "unified": "^10.0.0"
+      }
+    },
+    "remark-gfm": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-blockquote-indentation/-/remark-lint-blockquote-indentation-2.0.0.tgz",
-      "integrity": "sha512-Ma/lk+egYzvzV9+RLxR7iaNcFqwsF02guxY2nFF7gaVFXWDhbRy+hbiRZiTQe3y8AK+smc2yE79I+JRUVL15LQ==",
+      "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-2.0.0.tgz",
+      "integrity": "sha512-waIv4Tjcd2CTUDxKRYzuPyIHw1FoX4H2GjXAzXV9PxQWb+dU4fJivd/FZ+nxyzPARrqTjMIkwIwPoWNbpBhjcQ==",
+      "requires": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-gfm": "^1.0.0",
+        "micromark-extension-gfm": "^1.0.0",
+        "unified": "^10.0.0"
+      }
+    },
+    "remark-lint-blockquote-indentation": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-blockquote-indentation/-/remark-lint-blockquote-indentation-3.0.0.tgz",
+      "integrity": "sha512-qWWyAJWHwnVFsfKEyl51os1rr4ex9KX398g8326esJ2/RFsCYJbJaXmVk/S+uf7B7HfOWFuJo+tu/7jlZZ54+Q==",
       "requires": {
-        "mdast-util-to-string": "^1.0.2",
+        "@types/mdast": "^3.0.0",
         "pluralize": "^8.0.0",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-checkbox-character-style": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-checkbox-character-style/-/remark-lint-checkbox-character-style-2.0.0.tgz",
-      "integrity": "sha512-V+eTXFHrHCpFFG2RWaQM6lSetLLvpYC8WEZ9dMYSAUbeS/h0PhA7cB7j5kGH86RUwGCihawfzNAKbRmgGxL+DQ==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-checkbox-character-style/-/remark-lint-checkbox-character-style-4.0.0.tgz",
+      "integrity": "sha512-NHpVZOcTJeLOI1gGOvVDz8i3sXVY3s9K+OADupEA89Syfs4YAbnrij8OMJ6ozbHTn4av/HyVfsF4IK8X2pBUeQ==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0",
-        "vfile-location": "^3.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-checkbox-content-indent": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-checkbox-content-indent/-/remark-lint-checkbox-content-indent-2.0.0.tgz",
-      "integrity": "sha512-02Xytexe8nso1ofPC6wN3FE48302nmteSIwydeIDFhJq7mG14SxF4xgay+Kjbhs/O5NoRIF2ju9qcPNJ5gFsXA==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-checkbox-content-indent/-/remark-lint-checkbox-content-indent-4.0.0.tgz",
+      "integrity": "sha512-WeB8aSC1oesu0t/wcqNEbn3bg0kRw+NK7Y5xrhQsREw6NcH1TnvjH95PvizFT5LxXAGhz4AtCFz0B28YugSznQ==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0",
-        "vfile-location": "^3.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-code-block-style": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-code-block-style/-/remark-lint-code-block-style-2.0.0.tgz",
-      "integrity": "sha512-bXT1b9MvYDxKdLfzWTW3eSXWy7v57LXtU5ySLzlD1g3DWoSA6rSWjJT5l/2mA+iOuswg18ssY3SSjwExmTyWUA==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-code-block-style/-/remark-lint-code-block-style-3.0.0.tgz",
+      "integrity": "sha512-xZMfFeaMOb5OIM4SrNz3QTRV3u5g3/+e6Oq40A3Apwd+a9Kx49lZbGxl8vfqaczP89PTNanm2e4OqqRsCen4Mg==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-definition-spacing": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-definition-spacing/-/remark-lint-definition-spacing-2.0.0.tgz",
-      "integrity": "sha512-kE+ffEGsyxgUDlcKSVrnhqyHjQfH0RtUVN/OdA/iSzKfTy/Yc9VMMaNu6xT14xhwjTnSVPrd38rUOnDt1LZhAw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-definition-spacing/-/remark-lint-definition-spacing-3.0.0.tgz",
+      "integrity": "sha512-3LxU7lwCpfPstldcGly2ULb8knH4IOqZHoABT2KyKFw3rRFUCAEUBSl0k5eetnXXNc/X4NlHmnyjIyzhyl4PhA==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-fenced-code-flag": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-fenced-code-flag/-/remark-lint-fenced-code-flag-2.0.0.tgz",
-      "integrity": "sha512-SyQ31cdQlbsS+eBw2DUxkuzNwGIGlWnnCLyHLz3D1nxtZBVUaUOnIAturSA3PsguIrnxH4qD2JYCTp5aPbZhzQ==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-fenced-code-flag/-/remark-lint-fenced-code-flag-3.0.0.tgz",
+      "integrity": "sha512-wvyaTvQ5F78yuw4BDQsneTCvkxHGAjq0OuDQU4pawAZMYO3qFJlau7qoLppgquY1D+jBakejMT/yKnoQgRf1dQ==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-fenced-code-marker": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-fenced-code-marker/-/remark-lint-fenced-code-marker-2.0.0.tgz",
-      "integrity": "sha512-ZkJ4/o0A34nQefhsu6AU2cftQjCwzXClbZ5TrwgtkQQHG9BSu9/vo3PSLxGGw7XBX63oKcrx5HWGrWXaeLTN2g==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-fenced-code-marker/-/remark-lint-fenced-code-marker-3.0.0.tgz",
+      "integrity": "sha512-x3wr1+22Atr72Z7+dUS8cqwuz8m8d4UgCAfBTNO+E6pRLVeCnVMvEtuJbDI5UqBlqvkLGlNofV4lJZQvrZUxqQ==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-file-extension": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/remark-lint-file-extension/-/remark-lint-file-extension-1.0.4.tgz",
-      "integrity": "sha512-Zfp1mXNwpg7STjTWynZjL+/JtvIOCrmOAZzL3uK+tYpT0ZDPdQ1EQEl5D92+Eiu5OcYlenzG42jiLcyJjv+Q2g==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-file-extension/-/remark-lint-file-extension-2.0.0.tgz",
+      "integrity": "sha512-fZ0nDGyuZSgkrakLKl+cjqXwOT7iAz0wfSbrkCabYW3DdN6X1QYeSlMtHPizGXuri+AZhVkrUnujSn+9P4hJ2w==",
       "requires": {
-        "unified-lint-rule": "^1.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-final-definition": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-final-definition/-/remark-lint-final-definition-2.0.0.tgz",
-      "integrity": "sha512-oGObGXt/CdQfvnoQHWrFPtpTQK7oHiw5kBGzG5GbPSj3rrv30ohD5K+11ljEle9e3wO048EiWDROO5eKzIeeGw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-final-definition/-/remark-lint-final-definition-3.0.0.tgz",
+      "integrity": "sha512-RHR8aku0jCH4AoHVepw9b0tCmiBevMtLPG1l5FKhbkLtBWk9GRRryuD3GExxsInEUN2P/a6FhvcBBtRSJbIfIA==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-final-newline": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/remark-lint-final-newline/-/remark-lint-final-newline-1.0.4.tgz",
-      "integrity": "sha512-pUwqX8TVTTfqX5arMnu9Dr2ufg6wZ6Pk1VeqlnWfK92PBXLG8Zc3yrLpYXOJy1fHdWpqUECRRowG0H/OkZIEbw==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-final-newline/-/remark-lint-final-newline-2.0.0.tgz",
+      "integrity": "sha512-3u1IbgVfUN5Qgid8iqc1qlZhzscs4YPu8mwyahvLWVKMkBtoRWjDIVL6+CXcPPoUB2k3p+zuZ5oaE4yfO5Pb4w==",
       "requires": {
-        "unified-lint-rule": "^1.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-first-heading-level": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-first-heading-level/-/remark-lint-first-heading-level-2.0.0.tgz",
-      "integrity": "sha512-LFjKO6nQAPo0oarhLZqHaGUqCpLvjeVuJTr58yo3jpC4v0Gmb1iG8X53hrLtxPz+MP4J5WVz/83eAXCH+Vh3vA==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-first-heading-level/-/remark-lint-first-heading-level-3.0.0.tgz",
+      "integrity": "sha512-SMvBHO4HJd1ZkFDfx7OikJAoq5FQe+nFPm3n4DeAKIgM1FywaC7tD7ShwTRUL2DJMzdPjlta7UQRtTryAQGj+w==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-hard-break-spaces": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-hard-break-spaces/-/remark-lint-hard-break-spaces-2.0.0.tgz",
-      "integrity": "sha512-dmB8GucOSDtEctwa+Y8JlSAWF4q8HcquvLr+OpFOSE1QCrpFoZdb2mcSY+rZuTtfeg4S60orhhzArd2aiHvUPQ==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-hard-break-spaces/-/remark-lint-hard-break-spaces-3.0.0.tgz",
+      "integrity": "sha512-TNTI32Va6hE33pTYC6iqn4NvyZHqCULsOKKLnAzBocFFFIYuaNUdfKyVc9wknAAutbQLqApr8tgs1mLHtHm9Fw==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-heading-style": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-heading-style/-/remark-lint-heading-style-2.0.0.tgz",
-      "integrity": "sha512-LZvnAq5zWh9i/oRAEocth8yajEEH4kRgCrL4dE547Nkv6zaR2SKcym+uXMZ+GF6WEWcjXMiwSxIL7MHaT6XexA==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-heading-style/-/remark-lint-heading-style-3.0.0.tgz",
+      "integrity": "sha512-pPiXG24yXER7xXZr+J11iuMd1DXa71m6Cx7jqUO5z1Ptc7WkolcW6lNRFG76BCOJp8Jp6vH5eNITuQxYa0AnJw==",
       "requires": {
-        "mdast-util-heading-style": "^1.0.2",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "mdast-util-heading-style": "^2.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-list-item-bullet-indent": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-list-item-bullet-indent/-/remark-lint-list-item-bullet-indent-2.0.0.tgz",
-      "integrity": "sha512-8iK+ht771UBf/Iuj4YBgdLnFFOyEgfXY62jBoywtMuiOLVWXDfPe+jUY7pCrnFjsnxXGEnMaxHJqENgrHd0J/w==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-list-item-bullet-indent/-/remark-lint-list-item-bullet-indent-4.0.0.tgz",
+      "integrity": "sha512-b/U3wAJPE00xGQGYBvjPPsdXsBPJxUvITYgAZee7aA2sGEiflMGmg90anS2sJZEAoD4XtNzp96bPaY6QLN89dQ==",
       "requires": {
+        "@types/mdast": "^3.0.0",
         "pluralize": "^8.0.0",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-list-item-indent": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-list-item-indent/-/remark-lint-list-item-indent-2.0.0.tgz",
-      "integrity": "sha512-qnKsq2UQpCC8gnI1O23dgoKsd+5RAJrAJuvHXrlkRgzsab7BOMluptxRlyLVXn0P71l4Wo/bfo84Ual7qpOyWw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-list-item-indent/-/remark-lint-list-item-indent-3.0.0.tgz",
+      "integrity": "sha512-z7doG/aJCy8ivmfbE/cSm9HOpIeUaV5zZHMqSsZ6XZ+wXIj4wtMFVhI7fsAVs5pAB1gzSvZQuwJOfSs2//Fw2g==",
       "requires": {
+        "@types/mdast": "^3.0.0",
         "pluralize": "^8.0.0",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-maximum-line-length": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-maximum-line-length/-/remark-lint-maximum-line-length-2.0.0.tgz",
-      "integrity": "sha512-Qhe1QwDGisMP/UraUexWIPNBXJO8VQ7LIelz4NdftBQl/FxDVoXn3477Fm+8bGtcTXkMPF+QfllE4L1U7kJQgQ==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-maximum-line-length/-/remark-lint-maximum-line-length-3.0.0.tgz",
+      "integrity": "sha512-0x5TsUDlc4IDPUObNjVtcQxzI1JokUwbVpr22akWypnZaX9QMIL+Cp1OXrKRknZVU3rIndt4QCNnjMEYKezn1g==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-auto-link-without-protocol": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-auto-link-without-protocol/-/remark-lint-no-auto-link-without-protocol-2.0.0.tgz",
-      "integrity": "sha512-pIntUa+zNiyRxIt2Wvp1soktDbVnk1SEiJXsjcLYYn9GapgXqOQG5ZfFwR6zxTkGV5mZKo9927EvHQkvIV6cLQ==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-auto-link-without-protocol/-/remark-lint-no-auto-link-without-protocol-3.0.0.tgz",
+      "integrity": "sha512-qeJhWZcO0wnavTdpLU6M1q5RBfo4nZnYmzASoSCmIj/ZxIinluXLmLcMHC2Ol46egWdvwDNpr3V0dJP79fiJMQ==",
       "requires": {
-        "mdast-util-to-string": "^1.0.2",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-blockquote-without-marker": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-blockquote-without-marker/-/remark-lint-no-blockquote-without-marker-3.0.0.tgz",
-      "integrity": "sha512-auyAxMVDuhvGw29VilqUfUIUnBT7qmByG/kBPqV/GwM1a5rn4fIUJ7p9Je9BlWMRCBMTNQUMsm3ce0dawouVew==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-blockquote-without-marker/-/remark-lint-no-blockquote-without-marker-5.0.0.tgz",
+      "integrity": "sha512-6m1KZE8X2OhNV9wpEPVUfFxdzgVD523unRkstlRedKC3ONLlqP/CIliAOITRmIGuUxXVjyD7mDC892bFJnJTfw==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0",
-        "vfile-location": "^3.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-consecutive-blank-lines": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-consecutive-blank-lines/-/remark-lint-no-consecutive-blank-lines-2.0.0.tgz",
-      "integrity": "sha512-qIXHW0atHaOmHlu7V+4Krs5IAdIZhcXoeRdOMgqkGNW8CtfL12pP8KnzigAB9D5/X/qxPxZ95Js/KaESFS+3hA==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-consecutive-blank-lines/-/remark-lint-no-consecutive-blank-lines-4.0.0.tgz",
+      "integrity": "sha512-gP1b3lM+oemvA0WOC5HbvkjESG2BiZHL8ZDSX+wbg/2+7zu14rOmAAMiUOlk/CxbusttwJxsz8a/Wn1dEK/jPg==",
       "requires": {
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
         "pluralize": "^8.0.0",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-duplicate-definitions": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-duplicate-definitions/-/remark-lint-no-duplicate-definitions-2.0.0.tgz",
-      "integrity": "sha512-Z5DkYKbmS+r4D0ZhaXgK6L72EWzhiklpXNF/TS+KCsffAFgfy5aJfSA3A8GpVNj1wYMP35STXBGBCLW5TckvGw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-duplicate-definitions/-/remark-lint-no-duplicate-definitions-3.0.0.tgz",
+      "integrity": "sha512-6VOGPegh2ZQ0d9yronmhNXhg2wLYA5litT7bC1ljg2LQwMTIjYOgJbJsQJSKWD+FiHuqVhdWvXHzyTbFCch8Aw==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-stringify-position": "^2.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-stringify-position": "^3.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-file-name-articles": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-articles/-/remark-lint-no-file-name-articles-1.0.4.tgz",
-      "integrity": "sha512-Ieqg/2WjYs5M+IoZsFrQUG0niN8zRC6IAYWOVaHi3UK/1P0IdmXKZE6pCFSJrhletawAaPw9Xtl42/45tcccCA==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-articles/-/remark-lint-no-file-name-articles-2.0.0.tgz",
+      "integrity": "sha512-PgyJXEsZDT2r1bvtwaChwTjYKPxo47/OxpJmiozwLcnPsBNbsDtrH+W5gIjNkvkENNcIQD48WZ9jIwyJiskBng==",
       "requires": {
-        "unified-lint-rule": "^1.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-file-name-consecutive-dashes": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-consecutive-dashes/-/remark-lint-no-file-name-consecutive-dashes-1.0.4.tgz",
-      "integrity": "sha512-Fyc8mL+Fyt2b/BVkCc2Y+GjJ4SwafDKQEUaizeuZQDBTiqRK3S4L9YpvLHTAPgTNntZkXLUsHzFDlGyKzW2gBQ==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-consecutive-dashes/-/remark-lint-no-file-name-consecutive-dashes-2.0.0.tgz",
+      "integrity": "sha512-o7yz//+vel7IFDoZ/M0BmOS4sVE3sTAFOkeYlH44meGbNnEudr+TKKa0lwopMqZHKhXgUPSayCq+D5dgRO6JLA==",
       "requires": {
-        "unified-lint-rule": "^1.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-file-name-outer-dashes": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-outer-dashes/-/remark-lint-no-file-name-outer-dashes-1.0.5.tgz",
-      "integrity": "sha512-5CMrCqyJj4ydM2QMhMAc60o08fJDxBgmO62r+RqVs+aIdIK6TtsF+T8oX+aTEtc3y/euKJ681tqEsSeJZh/h0A==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-file-name-outer-dashes/-/remark-lint-no-file-name-outer-dashes-2.0.0.tgz",
+      "integrity": "sha512-SZS9FeGLty0wOBLTKyboDUZpjIKMihH88ZvgdqCUgIiDlZ9/72JKtZv43UuMnMVRgKJWQCRyZtT3nSNw3HwM+g==",
       "requires": {
-        "unified-lint-rule": "^1.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-heading-content-indent": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-heading-content-indent/-/remark-lint-no-heading-content-indent-2.0.0.tgz",
-      "integrity": "sha512-Zqg0WXG60Nan8j7HZtnBXidMxXhlhc7Q5JrB54I3n7H3vSPCyaqhZJ2/obYVLalEVGND8NOJGvfA1rtchaZyYg==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-heading-content-indent/-/remark-lint-no-heading-content-indent-4.0.0.tgz",
+      "integrity": "sha512-2SljHUYTN83EN5DEZrl7WH4ibmUxai6gONhZaQrQOJyGUO2ReZj5Zdn4xi79NHpORSzCzjn2tSXPB6yL3AhJag==",
       "requires": {
-        "mdast-util-heading-style": "^1.0.2",
+        "@types/mdast": "^3.0.0",
+        "mdast-util-heading-style": "^2.0.0",
         "pluralize": "^8.0.0",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-heading-indent": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-heading-indent/-/remark-lint-no-heading-indent-2.0.0.tgz",
-      "integrity": "sha512-dBjSP2QdQVypFpwQdjZ6h/VsyY3CBY+IXY2edSWiITOofZrt7knmwrLFUoxPtvc9k4PIBA7XXpiwPPYBQzuLFg==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-heading-indent/-/remark-lint-no-heading-indent-4.0.0.tgz",
+      "integrity": "sha512-t4MWiMjPH6TOdM8d5i5Eik6NVrOokoYy6z0GnuI7PNrmNmVVIV9CVBJU94aSXZ7friKx5ucvUEw6NhXIRcNtOw==",
       "requires": {
+        "@types/mdast": "^3.0.0",
         "pluralize": "^8.0.0",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-inline-padding": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-inline-padding/-/remark-lint-no-inline-padding-2.0.0.tgz",
-      "integrity": "sha512-0YueQ3SBA8zFQYCN0/afRc6ZuSbM4Azx4sPVeVpAfMT0MrYgmi6msswyhUDXaeN2RwVO6bx/ZW6di8dVqRr7UA==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-inline-padding/-/remark-lint-no-inline-padding-4.0.0.tgz",
+      "integrity": "sha512-dugEtHudM/UVQYzTbQoWy4aeG9Micd9g6O/uzN59sIMM8Xb+Srbv/p5/2JNtJWej9PmzINldE0AHjpuB8NiNLA==",
       "requires": {
-        "mdast-util-to-string": "^1.0.2",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-literal-urls": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-literal-urls/-/remark-lint-no-literal-urls-2.0.0.tgz",
-      "integrity": "sha512-bZAxr65ftz9joszDkSs2LBeJB2cRE8GydUtxYdA1WRHYmVW1AfM5ilcqLnWhiOmu+XMPH7J0eRvUzbtvu+xerw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-literal-urls/-/remark-lint-no-literal-urls-3.0.0.tgz",
+      "integrity": "sha512-P+9VxemAeSGWGMmFGKcQMIsPgVDaoXnQLl0Bx/TuBms0Favb7XI3ecii/HjjDeks3zlrxlVhzvEkHBk1uH1tdA==",
       "requires": {
-        "mdast-util-to-string": "^1.0.2",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-string": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-multiple-toplevel-headings": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-multiple-toplevel-headings/-/remark-lint-no-multiple-toplevel-headings-2.0.0.tgz",
-      "integrity": "sha512-vpbdnrqUykyqpjaREg4W07J3gHgR0eTapDkz9RjVwyGNmBry7xUnyvaiPavAKqsA+qO/nnpIH8Qyw/2u5hDsJQ==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-multiple-toplevel-headings/-/remark-lint-no-multiple-toplevel-headings-3.0.0.tgz",
+      "integrity": "sha512-HzPTSy9nu9RHSIUfZCbxEa7KP4CoKNbfI4SW8txh7KnYwr6vC6QgqXPF77z1sIpiSgD9X2z0LwMk0DBk1v3bmA==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-stringify-position": "^2.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-stringify-position": "^3.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-shell-dollars": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-shell-dollars/-/remark-lint-no-shell-dollars-2.0.1.tgz",
-      "integrity": "sha512-N+wOq3nmZ8WnCreWhi/rfIKQJPAz+pcbErQATcnQzH0znzldXlX8Ovlm54yDx/A+TmGMex/epkCwuiewIj9m4g==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-shell-dollars/-/remark-lint-no-shell-dollars-3.0.0.tgz",
+      "integrity": "sha512-jygHSWi+w7C/VT6+oKIMHhrnMlURWF+ohjdtkxDc/C/7FXWyHg1nJR2t+c+j5Dmirz3oSfInSGw/jUfYP048GQ==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-shortcut-reference-image": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-image/-/remark-lint-no-shortcut-reference-image-2.0.0.tgz",
-      "integrity": "sha512-kgGCQBHibJ0IFVhWjnfjbqkKC0VeL5+cvyjjwfMJlgZrHEXNOYb2FJE2nvF/l6PSXQ17goRZpznTBfP4mQieUA==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-image/-/remark-lint-no-shortcut-reference-image-3.0.0.tgz",
+      "integrity": "sha512-PyB5xkCd8moJf1MrmIXlBTSXZ8pkjXtdrmHzYba7La8S/6TKN2+LFrfN9daLG9pVsD0DSBAlvbajM/MBFh2DfQ==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-shortcut-reference-link": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-link/-/remark-lint-no-shortcut-reference-link-2.0.0.tgz",
-      "integrity": "sha512-rSdGLWpEsHa4b2doUch+B7QtUHH9XuC8Hndb4rAYf8U0d48KfGAIoiicxUho8qZJ4VA3RIaDo4kA/iQ15Al+Vg==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-link/-/remark-lint-no-shortcut-reference-link-3.0.0.tgz",
+      "integrity": "sha512-SbPrP6ZfRA2IJ++L7xAivXl7PJdOMzBUlhVwlt5PsWJKWHX07TIB02GGAiMnSOLN0FnUCvgF2c5we6eU1K3plA==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-table-indentation": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-table-indentation/-/remark-lint-no-table-indentation-2.0.0.tgz",
-      "integrity": "sha512-5akpqHl+5r3Xe2WFiZB1I9eAwn6zTYqXNd0CVsiTF3DJo0KyvvgyrFRV1sCf/l/kzyNaFvpWpFDTMoWc8EI0RQ==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-table-indentation/-/remark-lint-no-table-indentation-4.0.0.tgz",
+      "integrity": "sha512-S1u4DHBS75xAcM/u1zsYize/0uB2u+xAoHbstN3JmFWsTRj5LUSppwkSrWsPk/3y9/jHJAQ4XSihwH7C95EObQ==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-tabs": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-tabs/-/remark-lint-no-tabs-2.0.0.tgz",
-      "integrity": "sha512-aXbqkgjI0611IN651eXK8NxLQLEjReviU6AjtluMVnvGx1B8Y8mEn5pxznrorXaAjOP4mvX0JYeu8kdhcAaHsw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-tabs/-/remark-lint-no-tabs-3.0.0.tgz",
+      "integrity": "sha512-iK5gXQLoBchviHRNNDIWKQsMAbsLIZzK2ZKo0ywzNBHBckd8fy+wIP6RUosb6p/RBHtq1JG1lUC5ADg1PSj0tQ==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "vfile-location": "^3.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-trailing-spaces": {
@@ -1211,223 +6382,395 @@
       }
     },
     "remark-lint-no-undefined-references": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-undefined-references/-/remark-lint-no-undefined-references-2.0.0.tgz",
-      "integrity": "sha512-K4k05pmlMRqEMUDYewitRUx8zM+ntJWbG61dILmL7to7uy0JoSbzuDtz1cxC+kKBKzkulPnyE3WOgRZG8RX2Jg==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-undefined-references/-/remark-lint-no-undefined-references-4.0.0.tgz",
+      "integrity": "sha512-HI68vLoTTCXDADAp8LQ6RqCuf9QHX7bSaaqKI1V82EyvizxgnFtvN46XIi1uiDTN+Jv/KzAAGaFrofV8OJknBA==",
       "requires": {
-        "collapse-white-space": "^1.0.4",
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "micromark-util-normalize-identifier": "^1.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-no-unused-definitions": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-no-unused-definitions/-/remark-lint-no-unused-definitions-2.0.0.tgz",
-      "integrity": "sha512-Y8zrulwaf7z6WR1ICfEGjW92iq2SPEN7Zhrs0nloNITHOg22tIPf28TurUz9HSQ3sEd52d9bZCfW9RkdfMq1xw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-no-unused-definitions/-/remark-lint-no-unused-definitions-3.0.0.tgz",
+      "integrity": "sha512-1LqEZx0IJx59ezXA9e0qq6h5W3n9I6oiBm3Kl+HvmXTFl1OME6f8SVFwtDbt9EaGmf+3NL+T24cWIhZWjmZ0bA==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-ordered-list-marker-style": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-ordered-list-marker-style/-/remark-lint-ordered-list-marker-style-2.0.0.tgz",
-      "integrity": "sha512-zYMZA8tQD/slJYKqsstZv0/Q34Hkdlf4DjC8SOr92PSA60R/xr7JdVd/AHHisbMsFvdnHZrxaB8oIOtbAUJCSw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-ordered-list-marker-style/-/remark-lint-ordered-list-marker-style-3.0.0.tgz",
+      "integrity": "sha512-HDg5Fyg3tENtmI5SpEL34TvEjIiVX4GhuOjU8aOGF7T4SMG69kLyx+IWMKhg39pBw+3h4lG6FDC8IfqYXONNLg==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-prohibited-strings": {
-      "version": "1.5.2",
-      "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-1.5.2.tgz",
-      "integrity": "sha512-1+WIHboeLxmAnlxTFW6XNfvxvhnC2WRxn0rGgcNp/M7CrANHhnadY2/YeXFLF9oY22SAylrxiPG9eAuUmJuW6w==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-3.0.0.tgz",
+      "integrity": "sha512-Aw21KVeoOiDte6dNfeTfTgjKV19yWXpPjLxfJ3ShC22/r97gkGdOo4dnuwyEEAfKhr3uimtSf3rRQyGSudY5tQ==",
       "requires": {
-        "escape-string-regexp": "^4.0.0",
-        "unified-lint-rule": "^1.0.2",
-        "unist-util-position": "^3.1.0",
-        "unist-util-visit": "^2.0.0",
-        "vfile-location": "^3.0.1"
+        "escape-string-regexp": "^5.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.1",
+        "unist-util-visit": "^4.0.0",
+        "vfile-location": "^4.0.1"
       },
       "dependencies": {
-        "escape-string-regexp": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-          "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="
+        "unified-lint-rule": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.1.tgz",
+          "integrity": "sha512-2RzZuuuWW+ifftM0zd/ZEng0Hb5lah+Zi+ZL/ybj8BrLO/TH2aQAMYvG+iC95aCg2FkWu/pcvVvHqsh2UMmzPg==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
         }
       }
     },
     "remark-lint-rule-style": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-rule-style/-/remark-lint-rule-style-2.0.0.tgz",
-      "integrity": "sha512-fdRfLUE5AJiFEn9rWTQrHwOUG3UcYtIxbWnR7YFvuPlFmzcMRwRHP5ZOcrj4KIpwCdVtlPI3h08m0kfO7a1KlQ==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-rule-style/-/remark-lint-rule-style-3.0.0.tgz",
+      "integrity": "sha512-KHSPHW/7YCl9gHFsqqWOqIkJYmPuxTu/5G3Ks3lG8seBDf1bg+lPPUg5TigsKa/E7juVgfTR7AhK6P+lYAp4EA==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-strong-marker": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-strong-marker/-/remark-lint-strong-marker-2.0.0.tgz",
-      "integrity": "sha512-1gl6vZF5BvV4kvS4xxhl8cw90La5Cio9ZFDQuspZMRA2KjzpwoU5RlTUbeHv8OqlKJJ2p7s0MDs8bLZNTzzjHA==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-strong-marker/-/remark-lint-strong-marker-3.0.0.tgz",
+      "integrity": "sha512-nNyW3tKl0rEf2j784HzVWChAomCxzld+v2A5R5r5Zw5VogUNikZA7ZRwy51HsmhqiTWHArVGeyuvCPrpkTDZ0A==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-table-cell-padding": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-table-cell-padding/-/remark-lint-table-cell-padding-2.0.0.tgz",
-      "integrity": "sha512-UstIXIaRVRJPKZPv1AXX/p3qCt//RYNsRHIq8KvL5YQPKaKWRkj2cNermCgm0XoUXy0EmRPNiBtUcuAQaP+jXg==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-table-cell-padding/-/remark-lint-table-cell-padding-4.0.0.tgz",
+      "integrity": "sha512-jYBhfu/x0bEXt+wilHnm76q6wHnPVW2v2EuTdvAsxqkVtlvWSl9BbO4bb/L7jKqwlfiTK8E/luHKZuPiNWlucw==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "@types/unist": "^2.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-table-pipes": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-table-pipes/-/remark-lint-table-pipes-2.0.0.tgz",
-      "integrity": "sha512-qGIttPFNT+19BEDz2JJWQtJIClFNIpg+XVw6ruX9LSR7xdo5QG9uARG4XS2EGUQQ7fiLIxQYb8g2dHwuXGbfmA==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-table-pipes/-/remark-lint-table-pipes-4.0.0.tgz",
+      "integrity": "sha512-wOIAwkPAEDArKYMEpDylycGOCCt9hUxfgirgYCaHujCvyg484GWO+n+Moabgd19O9ZjuYr2P7akuOocsTh2z3g==",
       "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-lint-unordered-list-marker-style": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/remark-lint-unordered-list-marker-style/-/remark-lint-unordered-list-marker-style-2.0.0.tgz",
-      "integrity": "sha512-s+ZiBgBDbIiScPPxWG/r2E/4YY+xP6EFLsLXPV/uPx7JqegIP/4+MAPi7Nz2zLmnQ2eekssZrEXma3uDb/dE1Q==",
-      "requires": {
-        "unified-lint-rule": "^1.0.0",
-        "unist-util-generated": "^1.1.0",
-        "unist-util-position": "^3.0.0",
-        "unist-util-visit": "^2.0.0"
-      }
-    },
-    "remark-message-control": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/remark-message-control/-/remark-message-control-6.0.0.tgz",
-      "integrity": "sha512-k9bt7BYc3G7YBdmeAhvd3VavrPa/XlKWR3CyHjr4sLO9xJyly8WHHT3Sp+8HPR8lEUv+/sZaffL7IjMLV0f6BA==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/remark-lint-unordered-list-marker-style/-/remark-lint-unordered-list-marker-style-3.0.0.tgz",
+      "integrity": "sha512-iwliMh7GzTdFAWKnVSabpdfcI6qoDE5PPX8hacDIZNbTe4xuUVFbopGCzsTlLiFQkTn6m3ePwOQn+lIbFofKDQ==",
       "requires": {
-        "mdast-comment-marker": "^1.0.0",
-        "unified-message-control": "^3.0.0"
+        "@types/mdast": "^3.0.0",
+        "unified": "^10.0.0",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-generated": "^2.0.0",
+        "unist-util-position": "^4.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-parse": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-8.0.2.tgz",
-      "integrity": "sha512-eMI6kMRjsAGpMXXBAywJwiwAse+KNpmt+BK55Oofy4KvBZEqUDj6mWbGLJZrujoPIPPxDXzn3T9baRlpsm2jnQ==",
-      "requires": {
-        "ccount": "^1.0.0",
-        "collapse-white-space": "^1.0.2",
-        "is-alphabetical": "^1.0.0",
-        "is-decimal": "^1.0.0",
-        "is-whitespace-character": "^1.0.0",
-        "is-word-character": "^1.0.0",
-        "markdown-escapes": "^1.0.0",
-        "parse-entities": "^2.0.0",
-        "repeat-string": "^1.5.4",
-        "state-toggle": "^1.0.0",
-        "trim": "0.0.1",
-        "trim-trailing-lines": "^1.0.0",
-        "unherit": "^1.0.4",
-        "unist-util-remove-position": "^2.0.0",
-        "vfile-location": "^3.0.0",
-        "xtend": "^4.0.1"
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-10.0.0.tgz",
+      "integrity": "sha512-07ei47p2Xl7Bqbn9H2VYQYirnAFJPwdMuypdozWsSbnmrkgA2e2sZLZdnDNrrsxR4onmIzH/J6KXqKxCuqHtPQ==",
+      "requires": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-from-markdown": "^1.0.0",
+        "unified": "^10.0.0"
       }
     },
     "remark-preset-lint-node": {
-      "version": "1.16.0",
-      "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-1.16.0.tgz",
-      "integrity": "sha512-/SeIfHFDZkpi29quPG6Bt9FAao0oic3fTkvGFy1Xzu27qtuZba0h3wHIkNRRPZ281PRdT6LB6MfsigBr2A5eMw==",
-      "requires": {
-        "remark-lint": "^7.0.0",
-        "remark-lint-blockquote-indentation": "^2.0.0",
-        "remark-lint-checkbox-character-style": "^2.0.0",
-        "remark-lint-checkbox-content-indent": "^2.0.0",
-        "remark-lint-code-block-style": "^2.0.0",
-        "remark-lint-definition-spacing": "^2.0.0",
-        "remark-lint-fenced-code-flag": "^2.0.0",
-        "remark-lint-fenced-code-marker": "^2.0.0",
-        "remark-lint-file-extension": "^1.0.3",
-        "remark-lint-final-definition": "^2.0.0",
-        "remark-lint-first-heading-level": "^2.0.0",
-        "remark-lint-heading-style": "^2.0.0",
-        "remark-lint-list-item-indent": "^2.0.0",
-        "remark-lint-maximum-line-length": "^2.0.0",
-        "remark-lint-no-consecutive-blank-lines": "^2.0.0",
-        "remark-lint-no-file-name-articles": "^1.0.4",
-        "remark-lint-no-file-name-consecutive-dashes": "^1.0.4",
-        "remark-lint-no-file-name-outer-dashes": "^1.0.5",
-        "remark-lint-no-heading-indent": "^2.0.0",
-        "remark-lint-no-multiple-toplevel-headings": "^2.0.0",
-        "remark-lint-no-shell-dollars": "^2.0.0",
-        "remark-lint-no-table-indentation": "^2.0.0",
-        "remark-lint-no-tabs": "^2.0.0",
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-3.0.1.tgz",
+      "integrity": "sha512-L7yhho9q9vmpsfMHO2gRKFNj36106iFM4KpodE+3k3rGg5dcmhV+zcsftNh5NGzbKKKYsGQj9C5XxCR/0NwKDg==",
+      "requires": {
+        "js-yaml": "^4.0.0",
+        "remark-lint-blockquote-indentation": "^3.0.0",
+        "remark-lint-checkbox-character-style": "^4.0.0",
+        "remark-lint-checkbox-content-indent": "^4.0.0",
+        "remark-lint-code-block-style": "^3.0.0",
+        "remark-lint-definition-spacing": "^3.0.0",
+        "remark-lint-fenced-code-flag": "^3.0.0",
+        "remark-lint-fenced-code-marker": "^3.0.0",
+        "remark-lint-file-extension": "^2.0.0",
+        "remark-lint-final-definition": "^3.0.0",
+        "remark-lint-first-heading-level": "^3.0.0",
+        "remark-lint-heading-style": "^3.0.0",
+        "remark-lint-list-item-indent": "^3.0.0",
+        "remark-lint-maximum-line-length": "^3.0.0",
+        "remark-lint-no-consecutive-blank-lines": "^4.0.0",
+        "remark-lint-no-file-name-articles": "^2.0.0",
+        "remark-lint-no-file-name-consecutive-dashes": "^2.0.0",
+        "remark-lint-no-file-name-outer-dashes": "^2.0.0",
+        "remark-lint-no-heading-indent": "^4.0.0",
+        "remark-lint-no-multiple-toplevel-headings": "^3.0.0",
+        "remark-lint-no-shell-dollars": "^3.0.0",
+        "remark-lint-no-table-indentation": "^4.0.0",
+        "remark-lint-no-tabs": "^3.0.0",
         "remark-lint-no-trailing-spaces": "^2.0.1",
-        "remark-lint-prohibited-strings": "^1.5.2",
-        "remark-lint-rule-style": "^2.0.0",
-        "remark-lint-strong-marker": "^2.0.0",
-        "remark-lint-table-cell-padding": "^2.0.0",
-        "remark-lint-table-pipes": "^2.0.0",
-        "remark-lint-unordered-list-marker-style": "^2.0.0",
-        "remark-preset-lint-recommended": "^4.0.0"
+        "remark-lint-prohibited-strings": "^3.0.0",
+        "remark-lint-rule-style": "^3.0.0",
+        "remark-lint-strong-marker": "^3.0.0",
+        "remark-lint-table-cell-padding": "^4.0.0",
+        "remark-lint-table-pipes": "^4.0.0",
+        "remark-lint-unordered-list-marker-style": "^3.0.0",
+        "remark-preset-lint-recommended": "^6.0.0",
+        "semver": "^7.3.2",
+        "unified-lint-rule": "^2.0.0",
+        "unist-util-visit": "^4.0.0"
+      },
+      "dependencies": {
+        "unified-lint-rule": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.0.tgz",
+          "integrity": "sha512-3V+eyHZR+PAeKavQrrvSacXq83C3TGVDZJpTZ8+MTlHZmS4arL1ul5U4WRymok0zobAsMiri42bJj0rCHIlIjA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "trough": "^2.0.0",
+            "unified": "^10.0.0",
+            "vfile": "^5.0.0"
+          }
+        }
       }
     },
     "remark-preset-lint-recommended": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/remark-preset-lint-recommended/-/remark-preset-lint-recommended-4.0.0.tgz",
-      "integrity": "sha512-Nroe+4Itvk+AHxkMCMu6iRUptE/5pXWgLoEOGdVO/2JIiMk/+15HEogMZ05vMhPct9+Wp4uVt2zqfuvzNzdcww==",
-      "requires": {
-        "remark-lint": "^7.0.0",
-        "remark-lint-final-newline": "^1.0.0",
-        "remark-lint-hard-break-spaces": "^2.0.0",
-        "remark-lint-list-item-bullet-indent": "^2.0.0",
-        "remark-lint-list-item-indent": "^2.0.0",
-        "remark-lint-no-auto-link-without-protocol": "^2.0.0",
-        "remark-lint-no-blockquote-without-marker": "^3.0.0",
-        "remark-lint-no-duplicate-definitions": "^2.0.0",
-        "remark-lint-no-heading-content-indent": "^2.0.0",
-        "remark-lint-no-inline-padding": "^2.0.0",
-        "remark-lint-no-literal-urls": "^2.0.0",
-        "remark-lint-no-shortcut-reference-image": "^2.0.0",
-        "remark-lint-no-shortcut-reference-link": "^2.0.0",
-        "remark-lint-no-undefined-references": "^2.0.0",
-        "remark-lint-no-unused-definitions": "^2.0.0",
-        "remark-lint-ordered-list-marker-style": "^2.0.0"
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/remark-preset-lint-recommended/-/remark-preset-lint-recommended-6.0.0.tgz",
+      "integrity": "sha512-ZVugDvBLFQ2JZ/tRIb0q/Oo4Qwp8s8AD8M/8GU7VgQYQ39GDVzo8lUTg2ugWy3YuBCX7wmnP0UDOSwIJt7vn0A==",
+      "requires": {
+        "@types/mdast": "^3.0.0",
+        "remark-lint": "^9.0.0",
+        "remark-lint-final-newline": "^2.0.0",
+        "remark-lint-hard-break-spaces": "^3.0.0",
+        "remark-lint-list-item-bullet-indent": "^4.0.0",
+        "remark-lint-list-item-indent": "^3.0.0",
+        "remark-lint-no-auto-link-without-protocol": "^3.0.0",
+        "remark-lint-no-blockquote-without-marker": "^5.0.0",
+        "remark-lint-no-duplicate-definitions": "^3.0.0",
+        "remark-lint-no-heading-content-indent": "^4.0.0",
+        "remark-lint-no-inline-padding": "^4.0.0",
+        "remark-lint-no-literal-urls": "^3.0.0",
+        "remark-lint-no-shortcut-reference-image": "^3.0.0",
+        "remark-lint-no-shortcut-reference-link": "^3.0.0",
+        "remark-lint-no-undefined-references": "^4.0.0",
+        "remark-lint-no-unused-definitions": "^3.0.0",
+        "remark-lint-ordered-list-marker-style": "^3.0.0",
+        "unified": "^10.0.0"
+      },
+      "dependencies": {
+        "mdast-comment-marker": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/mdast-comment-marker/-/mdast-comment-marker-2.0.0.tgz",
+          "integrity": "sha512-LQ4sf7vUzxz4mQQlzzBDgjaCJO5A0lkIAT9TyeNMfqaP31ooP1Qw9hprf7/V3NCo5FA1nvo5gbnfLVRY79QlDQ=="
+        },
+        "remark-lint": {
+          "version": "9.0.0",
+          "resolved": "https://registry.npmjs.org/remark-lint/-/remark-lint-9.0.0.tgz",
+          "integrity": "sha512-ETO4zI48PR1Nz42YiyaYBzyhOiEfppXLnck7HW2pjKqxd36SIyQgM6sxD4ToMQI9KuCgy8mLAl/iVJoDLKxVjw==",
+          "requires": {
+            "@types/mdast": "^3.0.0",
+            "remark-message-control": "^7.0.0",
+            "unified": "^10.1.0"
+          }
+        },
+        "remark-message-control": {
+          "version": "7.0.0",
+          "resolved": "https://registry.npmjs.org/remark-message-control/-/remark-message-control-7.0.0.tgz",
+          "integrity": "sha512-KZySoC97TrMPYfIZ9vJ7wxvQwniy68K6WCY3vmSedDN5YuGfdVOpMj6sjaZQcqbWZV9n7BhrT70E3xaUTtk4hA==",
+          "requires": {
+            "@types/mdast": "^3.0.0",
+            "mdast-comment-marker": "^2.0.0",
+            "rehype": "^12.0.0",
+            "unified": "^10.0.0",
+            "unified-message-control": "^4.0.0",
+            "vfile": "^5.0.0"
+          }
+        },
+        "unified-message-control": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/unified-message-control/-/unified-message-control-4.0.0.tgz",
+          "integrity": "sha512-1b92N+VkPHftOsvXNOtkJm4wHlr+UDmTBF2dUzepn40oy9NxanJ9xS1RwUBTjXJwqr2K0kMbEyv1Krdsho7+Iw==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-is": "^5.0.0",
+            "unist-util-visit": "^3.0.0",
+            "vfile": "^5.0.0",
+            "vfile-location": "^4.0.0",
+            "vfile-message": "^3.0.0"
+          }
+        },
+        "unist-util-visit": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-3.1.0.tgz",
+          "integrity": "sha512-Szoh+R/Ll68QWAyQyZZpQzZQm2UPbxibDvaY8Xc9SUtYgPsDzx5AWSk++UUt2hJuow8mvwR+rG+LQLw+KsuAKA==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-is": "^5.0.0",
+            "unist-util-visit-parents": "^4.0.0"
+          }
+        },
+        "unist-util-visit-parents": {
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz",
+          "integrity": "sha512-1xAFJXAKpnnJl8G7K5KgU7FY55y3GcLIXqkzUj5QF/QVP7biUm0K0O2oqVkYsdjzJKifYeWn9+o6piAK2hGSHw==",
+          "requires": {
+            "@types/unist": "^2.0.0",
+            "unist-util-is": "^5.0.0"
+          }
+        }
       }
     },
     "remark-stringify": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-8.0.0.tgz",
-      "integrity": "sha512-cABVYVloFH+2ZI5bdqzoOmemcz/ZuhQSH6W6ZNYnLojAUUn3xtX7u+6BpnYp35qHoGr2NFBsERV14t4vCIeW8w==",
-      "requires": {
-        "ccount": "^1.0.0",
-        "is-alphanumeric": "^1.0.0",
-        "is-decimal": "^1.0.0",
-        "is-whitespace-character": "^1.0.0",
-        "longest-streak": "^2.0.1",
-        "markdown-escapes": "^1.0.0",
-        "markdown-table": "^2.0.0",
-        "mdast-util-compact": "^2.0.0",
-        "parse-entities": "^2.0.0",
-        "repeat-string": "^1.5.4",
-        "state-toggle": "^1.0.0",
-        "stringify-entities": "^3.0.0",
-        "unherit": "^1.0.4",
-        "xtend": "^4.0.1"
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-10.0.0.tgz",
+      "integrity": "sha512-3LAQqJ/qiUxkWc7fUcVuB7RtIT38rvmxfmJG8z1TiE/D8zi3JGQ2tTcTJu9Tptdpb7gFwU0whRi5q1FbFOb9yA==",
+      "requires": {
+        "@types/mdast": "^3.0.0",
+        "mdast-util-to-markdown": "^1.0.0",
+        "unified": "^10.0.0"
       }
     },
     "repeat-string": {
@@ -1435,43 +6778,23 @@
       "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
       "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc="
     },
-    "replace-ext": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.0.tgz",
-      "integrity": "sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs="
-    },
     "resolve": {
-      "version": "1.14.2",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.14.2.tgz",
-      "integrity": "sha512-EjlOBLBO1kxsUxsKjLt7TAECyKW6fOh1VRkykQkKGzcBbjjPIxBqGh0jf7GJ3k/f5mxMqW3htMD3WdTUVtW8HQ==",
+      "version": "1.19.0",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.19.0.tgz",
+      "integrity": "sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==",
       "dev": true,
       "requires": {
+        "is-core-module": "^2.1.0",
         "path-parse": "^1.0.6"
       }
     },
-    "resolve-from": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
-      "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw=="
-    },
     "rollup": {
-      "version": "1.30.1",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-1.30.1.tgz",
-      "integrity": "sha512-Uus8mwQXwaO+ZVoNwBcXKhT0AvycFCBW/W8VZtkpVGsotRllWk9oldfCjqWmTnFRI0y7x6BnEqSqc65N+/YdBw==",
-      "dev": true,
-      "requires": {
-        "@types/estree": "*",
-        "@types/node": "*",
-        "acorn": "^7.1.0"
-      }
-    },
-    "rollup-pluginutils": {
-      "version": "2.8.2",
-      "resolved": "https://registry.npmjs.org/rollup-pluginutils/-/rollup-pluginutils-2.8.2.tgz",
-      "integrity": "sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ==",
+      "version": "2.56.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.56.2.tgz",
+      "integrity": "sha512-s8H00ZsRi29M2/lGdm1u8DJpJ9ML8SUOpVVBd33XNeEeL3NVaTiUcSBHzBdF3eAyR0l7VSpsuoVUGrRHq7aPwQ==",
       "dev": true,
       "requires": {
-        "estree-walker": "^0.6.1"
+        "fsevents": "~2.3.2"
       }
     },
     "safe-buffer": {
@@ -1479,10 +6802,18 @@
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
       "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
     },
+    "semver": {
+      "version": "7.3.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.4.tgz",
+      "integrity": "sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==",
+      "requires": {
+        "lru-cache": "^6.0.0"
+      }
+    },
     "shelljs": {
-      "version": "0.8.3",
-      "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.3.tgz",
-      "integrity": "sha512-fc0BKlAWiLpwZljmOvAOTE/gXawtCoNrP5oaY7KIaQbbyHeQVg01pSEuEGvGh3HEdBU4baCD7wQBwADmM/7f7A==",
+      "version": "0.8.4",
+      "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.4.tgz",
+      "integrity": "sha512-7gk3UZ9kOfPLIAbslLzyWeGiEqx9e3rxwZM0KE6EL8GlGwjym9Mrlx5/p33bWTu9YG6vcS4MBxYZDHYr5lr8BQ==",
       "dev": true,
       "requires": {
         "glob": "^7.0.0",
@@ -1491,14 +6822,13 @@
       }
     },
     "shx": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/shx/-/shx-0.3.2.tgz",
-      "integrity": "sha512-aS0mWtW3T2sHAenrSrip2XGv39O9dXIFUqxAEWHEOS1ePtGIBavdPJY1kE2IHl14V/4iCbUiNDPGdyYTtmhSoA==",
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/shx/-/shx-0.3.3.tgz",
+      "integrity": "sha512-nZJ3HFWVoTSyyB+evEKjJ1STiixGztlqwKLTUNV5KqMWtGey9fTd4KU1gdZ1X9BV6215pswQ/Jew9NsuS/fNDA==",
       "dev": true,
       "requires": {
-        "es6-object-assign": "^1.0.3",
-        "minimist": "^1.2.0",
-        "shelljs": "^0.8.1"
+        "minimist": "^1.2.3",
+        "shelljs": "^0.8.4"
       }
     },
     "sliced": {
@@ -1512,25 +6842,10 @@
       "integrity": "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==",
       "dev": true
     },
-    "sprintf-js": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
-      "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw="
-    },
-    "state-toggle": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/state-toggle/-/state-toggle-1.0.3.tgz",
-      "integrity": "sha512-d/5Z4/2iiCnHw6Xzghyhb+GcmF89bxwgXG60wjIiZaxnymbyOmI8Hk4VqHXiVVp6u2ysaskFfXg3ekCj4WNftQ=="
-    },
-    "string-width": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
-      "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
-      "requires": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.0"
-      }
+    "space-separated-tokens": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.1.tgz",
+      "integrity": "sha512-ekwEbFp5aqSPKaqeY1PGrlGQxPNaq+Cnx4+bE2D8sciBQrHpbwoBbawqTN2+6jPs9IdWxxiUcN0K2pkczD3zmw=="
     },
     "string_decoder": {
       "version": "1.3.0",
@@ -1540,30 +6855,37 @@
         "safe-buffer": "~5.2.0"
       }
     },
+    "string-width": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.0.0.tgz",
+      "integrity": "sha512-zwXcRmLUdiWhMPrHz6EXITuyTgcEnUqDzspTkCLhQovxywWz6NP9VHgqfVg20V/1mUg0B95AKbXxNT+ALRmqCw==",
+      "requires": {
+        "emoji-regex": "^9.2.2",
+        "is-fullwidth-code-point": "^4.0.0",
+        "strip-ansi": "^7.0.0"
+      }
+    },
     "stringify-entities": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-3.0.1.tgz",
-      "integrity": "sha512-Lsk3ISA2++eJYqBMPKcr/8eby1I6L0gP0NlxF8Zja6c05yr/yCYyb2c9PwXjd08Ib3If1vn1rbs1H5ZtVuOfvQ==",
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.1.tgz",
+      "integrity": "sha512-gmMQxKXPWIO3NXNSPyWNhlYcBNGpPA/487D+9dLPnU4xBnIrnHdr8cv5rGJOS/1BRxEXRb7uKwg7BA36IWV7xg==",
       "requires": {
-        "character-entities-html4": "^1.0.0",
-        "character-entities-legacy": "^1.0.0",
-        "is-alphanumerical": "^1.0.0",
-        "is-decimal": "^1.0.2",
-        "is-hexadecimal": "^1.0.0"
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^2.0.0"
       }
     },
     "strip-ansi": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz",
-      "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.0.0.tgz",
+      "integrity": "sha512-UhDTSnGF1dc0DRbUqr1aXwNoY3RgVkSWG8BrpnuFIxhP57IqbS7IRta2Gfiavds4yCxc5+fEAVVOgBZWnYkvzg==",
       "requires": {
-        "ansi-regex": "^5.0.0"
+        "ansi-regex": "^6.0.0"
       }
     },
     "supports-color": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.1.0.tgz",
-      "integrity": "sha512-oRSIpR8pxT1Wr2FquTNnGet79b3BWljqOuoW/h4oBhxJ/HUbX5nX6JSruTkvXDCFMwDPvsaTTbvMLKZWSy0R5g==",
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
       "requires": {
         "has-flag": "^4.0.0"
       }
@@ -1582,199 +6904,140 @@
       }
     },
     "to-vfile": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/to-vfile/-/to-vfile-6.1.0.tgz",
-      "integrity": "sha512-BxX8EkCxOAZe+D/ToHdDsJcVI4HqQfmw0tCkp31zf3dNP/XWIAjU4CmeuSwsSoOzOTqHPOL0KUzyZqJplkD0Qw==",
+      "version": "7.2.1",
+      "resolved": "https://registry.npmjs.org/to-vfile/-/to-vfile-7.2.1.tgz",
+      "integrity": "sha512-biljADNq2n+AZn/zX+/87zStnIqctKr/q5OaOD8+qSKINokUGPbWBShvxa1iLUgHz6dGGjVnQPNoFRtVBzMkVg==",
       "requires": {
         "is-buffer": "^2.0.0",
-        "vfile": "^4.0.0"
+        "vfile": "^5.0.0"
       }
     },
-    "trim": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/trim/-/trim-0.0.1.tgz",
-      "integrity": "sha1-WFhUf2spB1fulczMZm+1AITEYN0="
-    },
-    "trim-trailing-lines": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/trim-trailing-lines/-/trim-trailing-lines-1.1.3.tgz",
-      "integrity": "sha512-4ku0mmjXifQcTVfYDfR5lpgV7zVqPg6zV9rdZmwOPqq0+Zq19xDqEgagqVbc4pOOShbncuAOIs59R3+3gcF3ZA=="
-    },
     "trough": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/trough/-/trough-1.0.4.tgz",
-      "integrity": "sha512-tdzBRDGWcI1OpPVmChbdSKhvSVurznZ8X36AYURAcl+0o2ldlCY2XPzyXNNxwJwwyIU+rIglTCG4kxtNKBQH7Q=="
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-2.0.2.tgz",
+      "integrity": "sha512-FnHq5sTMxC0sk957wHDzRnemFnNBvt/gSY99HzK8F7UP5WAbvP70yX5bd7CjEQkN+TjdxwI7g7lJ6podqrG2/w=="
     },
     "typedarray": {
       "version": "0.0.6",
       "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
       "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c="
     },
-    "unherit": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/unherit/-/unherit-1.1.3.tgz",
-      "integrity": "sha512-Ft16BJcnapDKp0+J/rqFC3Rrk6Y/Ng4nzsC028k2jdDII/rdZ7Wd3pPT/6+vIIxRagwRc9K0IUX0Ra4fKvw+WQ==",
-      "requires": {
-        "inherits": "^2.0.0",
-        "xtend": "^4.0.0"
-      }
-    },
     "unified": {
-      "version": "9.0.0",
-      "resolved": "https://registry.npmjs.org/unified/-/unified-9.0.0.tgz",
-      "integrity": "sha512-ssFo33gljU3PdlWLjNp15Inqb77d6JnJSfyplGJPT/a+fNRNyCBeveBAYJdO5khKdF6WVHa/yYCC7Xl6BDwZUQ==",
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-10.1.0.tgz",
+      "integrity": "sha512-4U3ru/BRXYYhKbwXV6lU6bufLikoAavTwev89H5UxY8enDFaAT2VXmIXYNm6hb5oHPng/EXr77PVyDFcptbk5g==",
       "requires": {
-        "bail": "^1.0.0",
+        "@types/unist": "^2.0.0",
+        "bail": "^2.0.0",
         "extend": "^3.0.0",
         "is-buffer": "^2.0.0",
-        "is-plain-obj": "^2.0.0",
-        "trough": "^1.0.0",
-        "vfile": "^4.0.0"
+        "is-plain-obj": "^4.0.0",
+        "trough": "^2.0.0",
+        "vfile": "^5.0.0"
       }
     },
     "unified-args": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/unified-args/-/unified-args-8.0.0.tgz",
-      "integrity": "sha512-224jfXOL0Xu0e52fJTfxmAaNTuW1zopPmnXh/5GDAxx4Z6NbcZpjgQPBmo1xoLAhGih0rWVG2+a2kodzrEHfHw==",
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/unified-args/-/unified-args-9.0.2.tgz",
+      "integrity": "sha512-qSqryjoqfJSII4E4Z2Jx7MhXX2MuUIn6DsrlmL8UnWFdGtrWvEtvm7Rx5fKT5TPUz7q/Fb4oxwIHLCttvAuRLQ==",
       "requires": {
-        "camelcase": "^5.0.0",
-        "chalk": "^3.0.0",
+        "@types/text-table": "^0.2.0",
+        "camelcase": "^6.0.0",
+        "chalk": "^4.0.0",
         "chokidar": "^3.0.0",
-        "fault": "^1.0.2",
+        "fault": "^2.0.0",
         "json5": "^2.0.0",
-        "minimist": "^1.2.0",
+        "minimist": "^1.0.0",
         "text-table": "^0.2.0",
-        "unified-engine": "^8.0.0"
+        "unified-engine": "^9.0.0"
       }
     },
     "unified-engine": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/unified-engine/-/unified-engine-8.0.0.tgz",
-      "integrity": "sha512-vLUezxCnjzz+ya4pYouRQVMT8k82Rk4fIj406UidRnSFJdGXFaQyQklAnalsQHJrLqAlaYPkXPUa1upfVSHGCA==",
+      "version": "9.0.3",
+      "resolved": "https://registry.npmjs.org/unified-engine/-/unified-engine-9.0.3.tgz",
+      "integrity": "sha512-SgzREcCM2IpUy3JMFUcPRZQ2Py6IwvJ2KIrg2AiI7LnGge6E6OPFWpcabHrEXG0IvO2OI3afiD9DOcQvvZfXDQ==",
       "requires": {
+        "@types/concat-stream": "^1.0.0",
+        "@types/debug": "^4.0.0",
+        "@types/is-empty": "^1.0.0",
+        "@types/js-yaml": "^4.0.0",
+        "@types/node": "^16.0.0",
+        "@types/unist": "^2.0.0",
         "concat-stream": "^2.0.0",
         "debug": "^4.0.0",
-        "fault": "^1.0.0",
-        "figures": "^3.0.0",
-        "glob": "^7.0.3",
+        "fault": "^2.0.0",
+        "glob": "^7.0.0",
         "ignore": "^5.0.0",
         "is-buffer": "^2.0.0",
         "is-empty": "^1.0.0",
-        "is-plain-obj": "^2.0.0",
-        "js-yaml": "^3.6.1",
-        "load-plugin": "^3.0.0",
+        "is-plain-obj": "^4.0.0",
+        "js-yaml": "^4.0.0",
+        "load-plugin": "^4.0.0",
         "parse-json": "^5.0.0",
-        "to-vfile": "^6.0.0",
-        "trough": "^1.0.0",
-        "unist-util-inspect": "^5.0.0",
-        "vfile-reporter": "^6.0.0",
-        "vfile-statistics": "^1.1.0"
+        "to-vfile": "^7.0.0",
+        "trough": "^2.0.0",
+        "unist-util-inspect": "^7.0.0",
+        "vfile-message": "^3.0.0",
+        "vfile-reporter": "^7.0.0",
+        "vfile-statistics": "^2.0.0"
       }
     },
     "unified-lint-rule": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-1.0.5.tgz",
-      "integrity": "sha512-jOPr/fx8lTzqszEfh46p99jUMqgPlIZ8rNKllEepumISvgfj9lUq1c7BSpVihr0L1df3lkjVHAThRPS7dIyjYg==",
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-1.0.6.tgz",
+      "integrity": "sha512-YPK15YBFwnsVorDFG/u0cVVQN5G2a3V8zv5/N6KN3TCG+ajKtaALcy7u14DCSrJI+gZeyYquFL9cioJXOGXSvg==",
       "requires": {
         "wrapped": "^1.0.1"
       }
     },
-    "unified-message-control": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/unified-message-control/-/unified-message-control-3.0.1.tgz",
-      "integrity": "sha512-K2Kvvp1DBzeuxYLLsumZh/gDWUTl4e2z/P3VReFirC78cfHKtQifbhnfRrSBtKtd1Uc6cvYTW0/SZIUaMAEcTg==",
-      "requires": {
-        "unist-util-visit": "^2.0.0",
-        "vfile-location": "^3.0.0"
-      },
-      "dependencies": {
-        "unist-util-is": {
-          "version": "4.0.2",
-          "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.0.2.tgz",
-          "integrity": "sha512-Ofx8uf6haexJwI1gxWMGg6I/dLnF2yE+KibhD3/diOqY2TinLcqHXCV6OI5gFVn3xQqDH+u0M625pfKwIwgBKQ=="
-        },
-        "unist-util-visit": {
-          "version": "2.0.2",
-          "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.2.tgz",
-          "integrity": "sha512-HoHNhGnKj6y+Sq+7ASo2zpVdfdRifhTgX2KTU3B/sO/TTlZchp7E3S4vjRzDJ7L60KmrCPsQkVK3lEF3cz36XQ==",
-          "requires": {
-            "@types/unist": "^2.0.0",
-            "unist-util-is": "^4.0.0",
-            "unist-util-visit-parents": "^3.0.0"
-          }
-        },
-        "unist-util-visit-parents": {
-          "version": "3.0.2",
-          "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.0.2.tgz",
-          "integrity": "sha512-yJEfuZtzFpQmg1OSCyS9M5NJRrln/9FbYosH3iW0MG402QbdbaB8ZESwUv9RO6nRfLAKvWcMxCwdLWOov36x/g==",
-          "requires": {
-            "@types/unist": "^2.0.0",
-            "unist-util-is": "^4.0.0"
-          }
-        },
-        "vfile-location": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.0.1.tgz",
-          "integrity": "sha512-yYBO06eeN/Ki6Kh1QAkgzYpWT1d3Qln+ZCtSbJqFExPl1S3y2qqotJQXoh6qEvl/jDlgpUJolBn3PItVnnZRqQ=="
-        }
-      }
-    },
     "unist-util-generated": {
-      "version": "1.1.5",
-      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-1.1.5.tgz",
-      "integrity": "sha512-1TC+NxQa4N9pNdayCYA1EGUOCAO0Le3fVp7Jzns6lnua/mYgwHo0tz5WUAfrdpNch1RZLHc61VZ1SDgrtNXLSw=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-2.0.0.tgz",
+      "integrity": "sha512-TiWE6DVtVe7Ye2QxOVW9kqybs6cZexNwTwSMVgkfjEReqy/xwGpAXb99OxktoWwmL+Z+Epb0Dn8/GNDYP1wnUw=="
     },
     "unist-util-inspect": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/unist-util-inspect/-/unist-util-inspect-5.0.1.tgz",
-      "integrity": "sha512-fPNWewS593JSmg49HbnE86BJKuBi1/nMWhDSccBvbARfxezEuJV85EaARR9/VplveiwCoLm2kWq+DhP8TBaDpw==",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-inspect/-/unist-util-inspect-7.0.0.tgz",
+      "integrity": "sha512-2Utgv78I7PUu461Y9cdo+IUiiKSKpDV5CE/XD6vTj849a3xlpDAScvSJ6cQmtFBGgAmCn2wR7jLuXhpg1XLlJw==",
       "requires": {
-        "is-empty": "^1.0.0"
+        "@types/unist": "^2.0.0"
       }
     },
     "unist-util-is": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.0.2.tgz",
-      "integrity": "sha512-Ofx8uf6haexJwI1gxWMGg6I/dLnF2yE+KibhD3/diOqY2TinLcqHXCV6OI5gFVn3xQqDH+u0M625pfKwIwgBKQ=="
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
+      "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
     },
     "unist-util-position": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-3.1.0.tgz",
-      "integrity": "sha512-w+PkwCbYSFw8vpgWD0v7zRCl1FpY3fjDSQ3/N/wNd9Ffa4gPi8+4keqt99N3XW6F99t/mUzp2xAhNmfKWp95QA=="
-    },
-    "unist-util-remove-position": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-2.0.1.tgz",
-      "integrity": "sha512-fDZsLYIe2uT+oGFnuZmy73K6ZxOPG/Qcm+w7jbEjaFcJgbQ6cqjs/eSPzXhsmGpAsWPkqZM9pYjww5QTn3LHMA==",
-      "requires": {
-        "unist-util-visit": "^2.0.0"
-      }
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
+      "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
     },
     "unist-util-stringify-position": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.2.tgz",
-      "integrity": "sha512-nK5n8OGhZ7ZgUwoUbL8uiVRwAbZyzBsB/Ddrlbu6jwwubFza4oe15KlyEaLNMXQW1svOQq4xesUeqA85YrIUQA==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.0.tgz",
+      "integrity": "sha512-SdfAl8fsDclywZpfMDTVDxA2V7LjtRDTOFd44wUJamgl6OlVngsqWjxvermMYf60elWHbxhuRCZml7AnuXCaSA==",
       "requires": {
-        "@types/unist": "^2.0.2"
+        "@types/unist": "^2.0.0"
       }
     },
     "unist-util-visit": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.2.tgz",
-      "integrity": "sha512-HoHNhGnKj6y+Sq+7ASo2zpVdfdRifhTgX2KTU3B/sO/TTlZchp7E3S4vjRzDJ7L60KmrCPsQkVK3lEF3cz36XQ==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
+      "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
       "requires": {
         "@types/unist": "^2.0.0",
-        "unist-util-is": "^4.0.0",
-        "unist-util-visit-parents": "^3.0.0"
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^5.0.0"
       }
     },
     "unist-util-visit-parents": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.0.2.tgz",
-      "integrity": "sha512-yJEfuZtzFpQmg1OSCyS9M5NJRrln/9FbYosH3iW0MG402QbdbaB8ZESwUv9RO6nRfLAKvWcMxCwdLWOov36x/g==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
+      "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
       "requires": {
         "@types/unist": "^2.0.0",
-        "unist-util-is": "^4.0.0"
+        "unist-util-is": "^5.0.0"
       }
     },
     "util-deprecate": {
@@ -1783,68 +7046,84 @@
       "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
     },
     "vfile": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/vfile/-/vfile-4.0.2.tgz",
-      "integrity": "sha512-yhoTU5cDMSsaeaMfJ5g0bUKYkYmZhAh9fn9TZicxqn+Cw4Z439il2v3oT9S0yjlpqlI74aFOQCt3nOV+pxzlkw==",
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.0.2.tgz",
+      "integrity": "sha512-5cV+K7tX83MT3bievROc+7AvHv0GXDB0zqbrTjbOe+HRbkzvY4EP+wS3IR77kUBCoWFMdG9py18t0sesPtQ1Rw==",
       "requires": {
         "@types/unist": "^2.0.0",
         "is-buffer": "^2.0.0",
-        "replace-ext": "1.0.0",
-        "unist-util-stringify-position": "^2.0.0",
-        "vfile-message": "^2.0.0"
+        "unist-util-stringify-position": "^3.0.0",
+        "vfile-message": "^3.0.0"
       }
     },
     "vfile-location": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.0.1.tgz",
-      "integrity": "sha512-yYBO06eeN/Ki6Kh1QAkgzYpWT1d3Qln+ZCtSbJqFExPl1S3y2qqotJQXoh6qEvl/jDlgpUJolBn3PItVnnZRqQ=="
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
+      "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
+      "requires": {
+        "@types/unist": "^2.0.0",
+        "vfile": "^5.0.0"
+      }
     },
     "vfile-message": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-2.0.2.tgz",
-      "integrity": "sha512-gNV2Y2fDvDOOqq8bEe7cF3DXU6QgV4uA9zMR2P8tix11l1r7zju3zry3wZ8sx+BEfuO6WQ7z2QzfWTvqHQiwsA==",
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.0.2.tgz",
+      "integrity": "sha512-UUjZYIOg9lDRwwiBAuezLIsu9KlXntdxwG+nXnjuQAHvBpcX3x0eN8h+I7TkY5nkCXj+cWVp4ZqebtGBvok8ww==",
       "requires": {
         "@types/unist": "^2.0.0",
-        "unist-util-stringify-position": "^2.0.0"
+        "unist-util-stringify-position": "^3.0.0"
       }
     },
     "vfile-reporter": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/vfile-reporter/-/vfile-reporter-6.0.1.tgz",
-      "integrity": "sha512-0OppK9mo8G2XUpv+hIKLVSDsoxJrXnOy73+vIm0jQUOUFYRduqpFHX+QqAQfvRHyX9B0UFiRuNJnBOjQCIsw1g==",
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/vfile-reporter/-/vfile-reporter-7.0.1.tgz",
+      "integrity": "sha512-pof+cQSJCUNmHG6zoBOJfErb6syIWHWM14CwKjsugCixxl4CZdrgzgxwLBW8lIB6czkzX0Agnnhj33YpKyLvmA==",
       "requires": {
-        "repeat-string": "^1.5.0",
-        "string-width": "^4.0.0",
-        "supports-color": "^6.0.0",
-        "unist-util-stringify-position": "^2.0.0",
-        "vfile-sort": "^2.1.2",
-        "vfile-statistics": "^1.1.0"
+        "@types/repeat-string": "^1.0.0",
+        "@types/supports-color": "^8.0.0",
+        "repeat-string": "^1.0.0",
+        "string-width": "^5.0.0",
+        "supports-color": "^9.0.0",
+        "unist-util-stringify-position": "^3.0.0",
+        "vfile-sort": "^3.0.0",
+        "vfile-statistics": "^2.0.0"
       },
       "dependencies": {
         "has-flag": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-          "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0="
+          "version": "5.0.1",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-5.0.1.tgz",
+          "integrity": "sha512-CsNUt5x9LUdx6hnk/E2SZLsDyvfqANZSUq4+D3D8RzDJ2M+HDTIkF60ibS1vHaK55vzgiZw1bEPFG9yH7l33wA=="
         },
         "supports-color": {
-          "version": "6.1.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz",
-          "integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==",
+          "version": "9.0.2",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-9.0.2.tgz",
+          "integrity": "sha512-ii6tc8ImGFrgMPYq7RVAMKkhPo9vk8uA+D3oKbJq/3Pk2YSMv1+9dUAesa9UxMbxBTvxwKTQffBahNVNxEvM8Q==",
           "requires": {
-            "has-flag": "^3.0.0"
+            "has-flag": "^5.0.0"
           }
         }
       }
     },
     "vfile-sort": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/vfile-sort/-/vfile-sort-2.2.2.tgz",
-      "integrity": "sha512-tAyUqD2R1l/7Rn7ixdGkhXLD3zsg+XLAeUDUhXearjfIcpL1Hcsj5hHpCoy/gvfK/Ws61+e972fm0F7up7hfYA=="
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/vfile-sort/-/vfile-sort-3.0.0.tgz",
+      "integrity": "sha512-fJNctnuMi3l4ikTVcKpxTbzHeCgvDhnI44amA3NVDvA6rTC6oKCFpCVyT5n2fFMr3ebfr+WVQZedOCd73rzSxg==",
+      "requires": {
+        "vfile-message": "^3.0.0"
+      }
     },
     "vfile-statistics": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/vfile-statistics/-/vfile-statistics-1.1.4.tgz",
-      "integrity": "sha512-lXhElVO0Rq3frgPvFBwahmed3X03vjPF8OcjKMy8+F1xU/3Q3QU3tKEDp743SFtb74PdF0UWpxPvtOP0GCLheA=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/vfile-statistics/-/vfile-statistics-2.0.0.tgz",
+      "integrity": "sha512-foOWtcnJhKN9M2+20AOTlWi2dxNfAoeNIoxD5GXcO182UJyId4QrXa41fWrgcfV3FWTjdEDy3I4cpLVcQscIMA==",
+      "requires": {
+        "vfile-message": "^3.0.0"
+      }
+    },
+    "web-namespaces": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.0.tgz",
+      "integrity": "sha512-dE7ELZRVWh0ceQsRgkjLgsAvwTuv3kcjSY/hLjqL0llleUlQBDjE9JkB9FCBY5F2mnFEwiyJoowl8+NVGHe8dw=="
     },
     "wrapped": {
       "version": "1.0.1",
@@ -1860,10 +7139,15 @@
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
       "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
     },
-    "xtend": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
-      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="
+    "yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+    },
+    "zwitch": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.2.tgz",
+      "integrity": "sha512-JZxotl7SxAJH0j7dN4pxsTV6ZLXoLdGME+PsjkL/DaBrVryK9kTGq06GfKrwcSOqypP+fdXGoCHE36b99fWVoA=="
     }
   }
 }
diff --git a/tools/node-lint-md-cli-rollup/package.json b/tools/node-lint-md-cli-rollup/package.json
index 069a93e801da4145fc82e3afd56c088b31b0ba3b..56ad44b391eee2b520c4c11b506f3092cd564f4a 100644
--- a/tools/node-lint-md-cli-rollup/package.json
+++ b/tools/node-lint-md-cli-rollup/package.json
@@ -3,22 +3,22 @@
   "description": "remark packaged for Node.js Markdown linting",
   "version": "2.0.2",
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^11.0.1",
-    "@rollup/plugin-json": "^4.0.1",
-    "@rollup/plugin-node-resolve": "^7.0.0",
-    "rollup": "^1.30.1",
-    "shx": "^0.3.2"
+    "@rollup/plugin-commonjs": "^20.0.0",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.4",
+    "rollup": "^2.52.7",
+    "shx": "^0.3.3"
   },
   "dependencies": {
     "markdown-extensions": "^1.1.1",
-    "remark": "^12.0.0",
-    "remark-lint": "^7.0.0",
-    "remark-preset-lint-node": "^1.16.0",
-    "unified-args": "^8.0.0"
+    "remark": "^14.0.0",
+    "remark-gfm": "^2.0.0",
+    "remark-preset-lint-node": "^3.0.0",
+    "unified-args": "^9.0.0"
   },
   "main": "dist/index.js",
   "scripts": {
     "build": "npx rollup -c",
-    "build-node": "npm run build && npx shx cp dist/index.js ../lint-md.js"
+    "build-node": "npm run build && npx shx cp dist/index.mjs ../lint-md.mjs"
   }
 }
diff --git a/tools/node-lint-md-cli-rollup/rollup.config.js b/tools/node-lint-md-cli-rollup/rollup.config.js
index 967f81865c6d3a051f790dafa92876d2d07ae9b5..0a2b2098e69dd6ab4504d6c4c0a1e7e310b75ae9 100644
--- a/tools/node-lint-md-cli-rollup/rollup.config.js
+++ b/tools/node-lint-md-cli-rollup/rollup.config.js
@@ -1,27 +1,24 @@
 'use strict';
 
-const resolve = require('@rollup/plugin-node-resolve');
+const { nodeResolve } = require('@rollup/plugin-node-resolve');
 const commonjs = require('@rollup/plugin-commonjs');
 const json = require('@rollup/plugin-json');
 
 module.exports = {
-  input: 'src/cli-entry.js',
+  input: 'src/cli-entry.mjs',
   output: {
-    file: 'dist/index.js',
-    format: 'cjs',
+    file: 'dist/index.mjs',
+    format: 'es',
     sourcemap: false,
+    exports: 'none',
   },
   external: [
-    'stream',
-    'path',
-    'module',
-    'util',
-    'tty',
-    'os',
-    'fs',
-    'fsevents',
-    'events',
-    'assert',
+    'node:events',
+    'node:fs',
+    'node:path',
+    'node:process',
+    'node:stream',
+    'node:url',
   ],
   plugins: [
     {
@@ -39,13 +36,15 @@ module.exports = {
             'fsevents = require(\'fsevents\');', 'fsevents = undefined;'
           );
         }
+        // Remove circular dependency in glob that messes up rollup
+        return code.replace("var Glob = require('./glob.js').Glob", '');
       }
     },
     json({
       preferConst: true
     }),
-    resolve(), // tells Rollup how to find date-fns in node_modules
-    commonjs(), // Converts date-fns to ES modules
+    nodeResolve({ exportConditions: ['node'] }),
+    commonjs(),
     {
       name: 'banner',
       renderChunk(code) {
diff --git a/tools/node-lint-md-cli-rollup/src/cli-entry.js b/tools/node-lint-md-cli-rollup/src/cli-entry.mjs
similarity index 53%
rename from tools/node-lint-md-cli-rollup/src/cli-entry.js
rename to tools/node-lint-md-cli-rollup/src/cli-entry.mjs
index a66c4a6894aef65f87a3236d5aca229dc705e431..71e2563926b26cba3a2082382d435230875ed40c 100644
--- a/tools/node-lint-md-cli-rollup/src/cli-entry.js
+++ b/tools/node-lint-md-cli-rollup/src/cli-entry.mjs
@@ -1,17 +1,16 @@
-'use strict';
-
 // To aid in future maintenance, this layout closely matches remark-cli/cli.js.
-// https://github.com/remarkjs/remark/blob/master/packages/remark-cli/cli.js
+// https://github.com/remarkjs/remark/blob/HEAD/packages/remark-cli/cli.js
 
-const start = require('unified-args');
-const extensions = require('markdown-extensions');
-const processor = require('remark');
-const proc = require('remark/package.json');
-const cli = require('../package.json');
-const lintNode = require('remark-preset-lint-node');
+import { args } from 'unified-args';
+import extensions from 'markdown-extensions';
+import { remark } from 'remark';
+import proc from 'remark/package.json';
+import cli from '../package.json';
+import lintNode from 'remark-preset-lint-node';
+import gfm from 'remark-gfm';
 
-start({
-  processor: processor().use(lintNode),
+args({
+  processor: remark().use(gfm).use(lintNode),
   name: proc.name,
   description: cli.description,
   version: [
diff --git a/tools/release.sh b/tools/release.sh
index 3c2cc1ea0736e7518135fe0b3f746ddbf3f4f25f..bf70eadfbcada06ae5472b9ec4b91db92e663555 100755
--- a/tools/release.sh
+++ b/tools/release.sh
@@ -1,6 +1,6 @@
-#!/usr/bin/env bash
+#!/bin/sh
 
-# To promote and sign a release that has been prepared by the build slaves, use:
+# To promote and sign a release that has been prepared by the build jobs, use:
 #  release.sh
 
 # To _only_ sign an existing release, use:
@@ -28,7 +28,7 @@ while getopts ":i:s:" option; do
             echo "Invalid option -$OPTARG."
             exit 1
             ;;
-        :)
+        *)
             echo "Option -$OPTARG takes a parameter."
             exit 1
             ;;
@@ -42,50 +42,45 @@ shift $((OPTIND-1))
 echo "# Selecting GPG key ..."
 
 gpgkey=$(gpg --list-secret-keys --keyid-format SHORT | awk -F'( +|/)' '/^(sec|ssb)/{print $3}')
-keycount=$(echo $gpgkey | wc -w)
+keycount=$(echo "$gpgkey" | wc -w)
 
-if [ $keycount -eq 0 ]; then
+if [ "$keycount" -eq 0 ]; then
+  # shellcheck disable=SC2016
   echo 'Need at least one GPG key, please make one with `gpg --gen-key`'
   echo 'You will also need to submit your key to a public keyserver, e.g.'
   echo '  https://sks-keyservers.net/i/#submit'
   exit 1
-elif [ $keycount -ne 1 ]; then
-  echo -e 'You have multiple GPG keys:\n'
+elif [ "$keycount" -ne 1 ]; then
+  printf "You have multiple GPG keys:\n\n"
 
   gpg --list-secret-keys
 
-  while true; do
-    echo $gpgkey | awk '{ for(i = 1; i <= NF; i++) { print i ") " $i; } }'
-    echo -n 'Select a key: '
-    read keynum
-
-    if $(test "$keynum" -eq "$keynum" > /dev/null 2>&1); then
-      _gpgkey=$(echo $gpgkey | awk '{ print $'${keynum}'}')
-      keycount=$(echo $_gpgkey | wc -w)
-      if [ $keycount -eq 1 ]; then
-        echo ""
-        gpgkey=$_gpgkey
-        break
-      fi
-    fi
+  keynum=
+  while [ -z "${keynum##*[!0-9]*}" ] || [ "$keynum" -le 0 ] || [ "$keynum" -gt "$keycount" ]; do
+    echo "$gpgkey" | awk '{ print NR ") " $0; }'
+    printf 'Select a key: '
+    read -r keynum
   done
+  echo ""
+  gpgkey=$(echo "$gpgkey" | sed -n "${keynum}p")
 fi
 
-gpgfing=$(gpg --keyid-format 0xLONG --fingerprint $gpgkey | grep 'Key fingerprint =' | awk -F' = ' '{print $2}' | tr -d ' ')
+gpgfing=$(gpg --keyid-format 0xLONG --fingerprint "$gpgkey" | grep 'Key fingerprint =' | awk -F' = ' '{print $2}' | tr -d ' ')
+
+grep -q "$gpgfing" README.md || (\
+  echo 'Error: this GPG key fingerprint is not listed in ./README.md' && \
+  exit 1 \
+)
 
-if ! test "$(grep $gpgfing README.md)"; then
-  echo 'Error: this GPG key fingerprint is not listed in ./README.md'
-  exit 1
-fi
 
 echo "Using GPG key: $gpgkey"
 echo "  Fingerprint: $gpgfing"
 
-function checktag {
-  local version=$1
+checktag() {
+  # local version=$1
 
-  if ! git tag -v $version 2>&1 | grep "${gpgkey}" | grep key > /dev/null; then
-    echo "Could not find signed tag for \"${version}\" or GPG key is not yours"
+  if ! git tag -v "$1" 2>&1 | grep "${gpgkey}" | grep key > /dev/null; then
+    echo "Could not find signed tag for \"$1\" or GPG key is not yours"
     exit 1
   fi
 }
@@ -93,58 +88,63 @@ function checktag {
 ################################################################################
 ## Create and sign checksums file for a given version
 
-function sign {
-  echo -e "\n# Creating SHASUMS256.txt ..."
+sign() {
+  printf "\n# Creating SHASUMS256.txt ...\n"
 
-  local version=$1
+  # local version=$1
 
-  ghtaggedversion=$(curl -sL https://raw.githubusercontent.com/nodejs/node/${version}/src/node_version.h \
+  ghtaggedversion=$(curl -sL "https://raw.githubusercontent.com/nodejs/node/$1/src/node_version.h" \
       | awk '/define NODE_(MAJOR|MINOR|PATCH)_VERSION/{ v = v "." $3 } END{ v = "v" substr(v, 2); print v }')
-  if [ "${version}" != "${ghtaggedversion}" ]; then
+  if [ "$1" != "${ghtaggedversion}" ]; then
     echo "Could not find tagged version on github.com/nodejs/node, did you push your tag?"
     exit 1
   fi
 
-  shapath=$(ssh ${customsshkey} ${webuser}@${webhost} $signcmd nodejs $version)
+  # shellcheck disable=SC2086,SC2029
+  shapath=$(ssh ${customsshkey} "${webuser}@${webhost}" $signcmd nodejs $1)
 
-  if ! [[ ${shapath} =~ ^/.+/SHASUMS256.txt$ ]]; then
-    echo 'Error: No SHASUMS file returned by sign!'
-    exit 1
-  fi
+  echo "${shapath}" | grep -q '^/.*/SHASUMS256.txt$' || (\
+    echo 'Error: No SHASUMS file returned by sign!' &&\
+    exit 1)
 
-  echo -e "\n# Signing SHASUMS for ${version}..."
+  echo ""
+  echo "# Signing SHASUMS for $1..."
 
-  shafile=$(basename $shapath)
-  shadir=$(dirname $shapath)
+  shafile=$(basename "$shapath")
+  shadir=$(dirname "$shapath")
   tmpdir="/tmp/_node_release.$$"
 
   mkdir -p $tmpdir
 
-  scp ${customsshkey} ${webuser}@${webhost}:${shapath} ${tmpdir}/${shafile}
+  # shellcheck disable=SC2086
+  scp ${customsshkey} "${webuser}@${webhost}:${shapath}" "${tmpdir}/${shafile}"
 
-  gpg --default-key $gpgkey --clearsign --digest-algo SHA256 ${tmpdir}/${shafile}
-  gpg --default-key $gpgkey --detach-sign --digest-algo SHA256 ${tmpdir}/${shafile}
+  gpg --default-key "$gpgkey" --clearsign --digest-algo SHA256 "${tmpdir}/${shafile}"
+  gpg --default-key "$gpgkey" --detach-sign --digest-algo SHA256 "${tmpdir}/${shafile}"
 
   echo "Wrote to ${tmpdir}/"
 
-  echo -e "Your signed ${shafile}.asc:\n"
+  echo "Your signed ${shafile}.asc:"
+  echo ""
 
-  cat ${tmpdir}/${shafile}.asc
+  cat "${tmpdir}/${shafile}.asc"
 
   echo ""
 
   while true; do
-    echo -n "Upload files? [y/n] "
+    printf "Upload files? [y/n] "
     yorn=""
-    read yorn
+    read -r yorn
 
-    if [ "X${yorn}" == "Xn" ]; then
+    if [ "X${yorn}" = "Xn" ]; then
       break
     fi
 
-    if [ "X${yorn}" == "Xy" ]; then
-      scp ${customsshkey} ${tmpdir}/${shafile} ${tmpdir}/${shafile}.asc ${tmpdir}/${shafile}.sig ${webuser}@${webhost}:${shadir}/
-      ssh ${customsshkey} ${webuser}@${webhost} chmod 644 ${shadir}/${shafile}.asc ${shadir}/${shafile}.sig
+    if [ "X${yorn}" = "Xy" ]; then
+      # shellcheck disable=SC2086
+      scp ${customsshkey} "${tmpdir}/${shafile}" "${tmpdir}/${shafile}.asc" "${tmpdir}/${shafile}.sig" "${webuser}@${webhost}:${shadir}/"
+      # shellcheck disable=SC2086,SC2029
+      ssh ${customsshkey} "${webuser}@${webhost}" chmod 644 "${shadir}/${shafile}.asc" "${shadir}/${shafile}.sig"
       break
     fi
   done
@@ -154,8 +154,8 @@ function sign {
 
 
 if [ -n "${signversion}" ]; then
-		checktag $signversion
-    sign $signversion
+		checktag "$signversion"
+    sign "$signversion"
     exit 0
 fi
 
@@ -164,16 +164,18 @@ fi
 ################################################################################
 ## Look for releases to promote
 
-echo -e "\n# Checking for releases ..."
+printf "\n# Checking for releases ...\n"
 
-promotable=$(ssh ${customsshkey} ${webuser}@${webhost} $promotablecmd nodejs)
+# shellcheck disable=SC2086,SC2029
+promotable=$(ssh ${customsshkey} "$webuser@$webhost" $promotablecmd nodejs)
 
-if [ "X${promotable}" == "X" ]; then
+if [ "X${promotable}" = "X" ]; then
   echo "No releases to promote!"
   exit 0
 fi
 
-echo -e "Found the following releases / builds ready to promote:\n"
+echo "Found the following releases / builds ready to promote:"
+echo ""
 echo "$promotable" | sed 's/^/ * /'
 echo ""
 
@@ -184,12 +186,12 @@ versions=$(echo "$promotable" | cut -d: -f1)
 
 for version in $versions; do
   while true; do
-    files=$(echo "$promotable" | grep "^${version}" | sed 's/^'${version}': //')
-    echo -n "Promote ${version} files (${files})? [y/n] "
+    files=$(echo "$promotable" | grep "^${version}" | sed 's/^'"${version}"': //')
+    printf "Promote %s files (%s)? [y/n] " "${version}" "${files}"
     yorn=""
-    read yorn
+    read -r yorn
 
-    if [ "X${yorn}" == "Xn" ]; then
+    if [ "X${yorn}" = "Xn" ]; then
       break
     fi
 
@@ -197,15 +199,14 @@ for version in $versions; do
       continue
     fi
 
-		checktag $version
-
-    echo -e "\n# Promoting ${version}..."
+		checktag "$version"
 
-    ssh ${customsshkey} ${webuser}@${webhost} $promotecmd nodejs $version
+    echo ""
+    echo "# Promoting ${version}..."
 
-    if [ $? -eq 0 ];then
-      sign $version
-    fi
+    # shellcheck disable=SC2086,SC2029
+    ssh ${customsshkey} "$webuser@$webhost" $promotecmd nodejs $version && \
+      sign "$version"
 
     break
   done
diff --git a/tools/rpm/rpmbuild.sh b/tools/rpm/rpmbuild.sh
index 6f2d0d123be2b2c51df9b6c911ccfa8a9ba2c7aa..6c990c8e94b997d4942bd3a9a3e851d5e0a44305 100755
--- a/tools/rpm/rpmbuild.sh
+++ b/tools/rpm/rpmbuild.sh
@@ -16,7 +16,7 @@
 
 set -e
 
-TOOLSDIR=`dirname $0`
+TOOLSDIR=`dirname "$0"`
 TOPLEVELDIR="$TOOLSDIR/../.."
 
 RPMBUILD_PATH="${RPMBUILD_PATH:-$HOME/rpmbuild}"
@@ -38,7 +38,7 @@ fi
 set -x
 
 sed -re "s/%define _version .+/%define _version ${VERSION}/" \
-    "$TOOLSDIR/node.spec" > $RPMBUILD_PATH/SPECS/node.spec
+    "$TOOLSDIR/node.spec" > "$RPMBUILD_PATH/SPECS/node.spec"
 tar --exclude-vcs --transform="s|^|node-${VERSION}/|" \
-    -czf $RPMBUILD_PATH/SOURCES/node-v${VERSION}.tar.gz .
-rpmbuild $* -ba $RPMBUILD_PATH/SPECS/node.spec
+    -czf "$RPMBUILD_PATH/SOURCES/node-v${VERSION}.tar.gz" .
+rpmbuild "$*" -ba "$RPMBUILD_PATH/SPECS/node.spec"
diff --git a/tools/snapshot/node_mksnapshot.cc b/tools/snapshot/node_mksnapshot.cc
index edf5cb72a80b84d7e59959606233b021971ddbb3..29f9e1cbcbb09608edd379e28f459bca8d62b46a 100644
--- a/tools/snapshot/node_mksnapshot.cc
+++ b/tools/snapshot/node_mksnapshot.cc
@@ -17,7 +17,6 @@
 int wmain(int argc, wchar_t* argv[]) {
 #else   // UNIX
 int main(int argc, char* argv[]) {
-  argv = uv_setup_args(argc, argv);
 #endif  // _WIN32
 
   v8::V8::SetFlagsFromString("--random_seed=42");
diff --git a/tools/test.py b/tools/test.py
index 532b855479b7bbff069900a862abc5e33c68e1fb..d2c09169a46a413275e4f7c050d4248a0966bede 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -98,6 +98,7 @@ class ProgressIndicator(object):
 
   def __init__(self, cases, flaky_tests_mode):
     self.cases = cases
+    self.serial_id = 0
     self.flaky_tests_mode = flaky_tests_mode
     self.parallel_queue = Queue(len(cases))
     self.sequential_queue = Queue(len(cases))
@@ -115,6 +116,25 @@ class ProgressIndicator(object):
     self.lock = threading.Lock()
     self.shutdown_event = threading.Event()
 
+  def GetFailureOutput(self, failure):
+    output = []
+    if failure.output.stderr:
+      output += ["--- stderr ---" ]
+      output += [failure.output.stderr.strip()]
+    if failure.output.stdout:
+      output += ["--- stdout ---"]
+      output += [failure.output.stdout.strip()]
+    output += ["Command: %s" % EscapeCommand(failure.command)]
+    if failure.HasCrashed():
+      output += ["--- %s ---" % PrintCrashed(failure.output.exit_code)]
+    if failure.HasTimedOut():
+      output += ["--- TIMEOUT ---"]
+    output = "\n".join(output)
+    return output
+
+  def PrintFailureOutput(self, failure):
+    print(self.GetFailureOutput(failure))
+
   def PrintFailureHeader(self, test):
     if test.IsNegative():
       negative_marker = '[negative] '
@@ -167,6 +187,8 @@ class ProgressIndicator(object):
       case = test
       case.thread_id = thread_id
       self.lock.acquire()
+      case.serial_id = self.serial_id
+      self.serial_id += 1
       self.AboutToRun(case)
       self.lock.release()
       try:
@@ -221,17 +243,7 @@ class SimpleProgressIndicator(ProgressIndicator):
     print()
     for failed in self.failed:
       self.PrintFailureHeader(failed.test)
-      if failed.output.stderr:
-        print("--- stderr ---")
-        print(failed.output.stderr.strip())
-      if failed.output.stdout:
-        print("--- stdout ---")
-        print(failed.output.stdout.strip())
-      print("Command: %s" % EscapeCommand(failed.command))
-      if failed.HasCrashed():
-        print("--- %s ---" % PrintCrashed(failed.output.exit_code))
-      if failed.HasTimedOut():
-        print("--- TIMEOUT ---")
+      self.PrintFailureOutput(failed)
     if len(self.failed) == 0:
       print("===")
       print("=== All tests succeeded")
@@ -285,6 +297,21 @@ class DotsProgressIndicator(SimpleProgressIndicator):
       sys.stdout.write('.')
       sys.stdout.flush()
 
+class ActionsAnnotationProgressIndicator(DotsProgressIndicator):
+  def GetAnnotationInfo(self, test, output):
+    traceback = output.stdout + output.stderr
+    find_full_path = re.search(r' +at .*\(.*%s:([0-9]+):([0-9]+)' % test.file, traceback)
+    col = line = 0
+    if find_full_path:
+        line, col = map(int, find_full_path.groups())
+    root_path = abspath(join(dirname(__file__), '../')) + os.sep
+    filename = test.file.replace(root_path, "")
+    return filename, line, col
+
+  def PrintFailureOutput(self, failure):
+    output = self.GetFailureOutput(failure)
+    filename, line, column = self.GetAnnotationInfo(failure.test, failure.output)
+    print("::error file=%s,line=%d,col=%d::%s" % (filename, line, column, output.replace('\n', '%0A')))
 
 class TapProgressIndicator(SimpleProgressIndicator):
 
@@ -348,7 +375,10 @@ class TapProgressIndicator(SimpleProgressIndicator):
 
       if output.diagnostic:
         self.severity = 'ok'
-        self.traceback = output.diagnostic
+        if isinstance(output.diagnostic, list):
+          self.traceback = '\n'.join(output.diagnostic)
+        else:
+          self.traceback = output.diagnostic
 
 
     duration = output.test.duration
@@ -493,6 +523,7 @@ class MonochromeProgressIndicator(CompactProgressIndicator):
 PROGRESS_INDICATORS = {
   'verbose': VerboseProgressIndicator,
   'dots': DotsProgressIndicator,
+  'actions': ActionsAnnotationProgressIndicator,
   'color': ColorProgressIndicator,
   'tap': TapProgressIndicator,
   'mono': MonochromeProgressIndicator,
@@ -525,6 +556,7 @@ class TestCase(object):
     self.mode = mode
     self.parallel = False
     self.disable_core_files = False
+    self.serial_id = 0
     self.thread_id = 0
 
   def IsNegative(self):
@@ -556,6 +588,7 @@ class TestCase(object):
   def Run(self):
     try:
       result = self.RunCommand(self.GetCommand(), {
+        "TEST_SERIAL_ID": "%d" % self.serial_id,
         "TEST_THREAD_ID": "%d" % self.thread_id,
         "TEST_PARALLEL" : "%d" % self.parallel
       })
@@ -1294,7 +1327,7 @@ def BuildOptions():
   result.add_option('--logfile', dest='logfile',
       help='write test output to file. NOTE: this only applies the tap progress indicator')
   result.add_option("-p", "--progress",
-      help="The style of progress indicator (verbose, dots, color, mono, tap)",
+      help="The style of progress indicator (%s)" % ", ".join(PROGRESS_INDICATORS.keys()),
       choices=list(PROGRESS_INDICATORS.keys()), default="mono")
   result.add_option("--report", help="Print a summary of the tests to be run",
       default=False, action="store_true")
diff --git a/tools/update-authors.js b/tools/update-authors.js
index 312f253c4854e588f8e54467beeec803feb823a0..f9797b1998c3d934e02e590feef2af1bd4131653 100755
--- a/tools/update-authors.js
+++ b/tools/update-authors.js
@@ -41,19 +41,21 @@ const mailmap = new CaseIndifferentMap();
     let match;
     // Replaced Name <original@example.com>
     if (match = line.match(/^([^<]+)\s+(<[^>]+>)$/)) {
-      mailmap.set(match[2], { author: match[1] });
+      mailmap.set(match[2].toLowerCase(), {
+        author: match[1], email: match[2]
+      });
     // <replaced@example.com> <original@example.com>
     } else if (match = line.match(/^<([^>]+)>\s+(<[^>]+>)$/)) {
-      mailmap.set(match[2], { email: match[1] });
+      mailmap.set(match[2].toLowerCase(), { email: match[1] });
     // Replaced Name <replaced@example.com> <original@example.com>
     } else if (match = line.match(/^([^<]+)\s+(<[^>]+>)\s+(<[^>]+>)$/)) {
-      mailmap.set(match[3], {
+      mailmap.set(match[3].toLowerCase(), {
         author: match[1], email: match[2]
       });
     // Replaced Name <replaced@example.com> Original Name <original@example.com>
     } else if (match =
         line.match(/^([^<]+)\s+(<[^>]+>)\s+([^<]+)\s+(<[^>]+>)$/)) {
-      mailmap.set(match[3] + '\0' + match[4], {
+      mailmap.set(match[3] + '\0' + match[4].toLowerCase(), {
         author: match[1], email: match[2]
       });
     } else {
@@ -75,8 +77,10 @@ rl.on('line', (line) => {
   if (!match) return;
 
   let { author, email } = match.groups;
+  const emailLower = email.toLowerCase();
 
-  const replacement = mailmap.get(author + '\0' + email) || mailmap.get(email);
+  const replacement =
+    mailmap.get(author + '\0' + emailLower) || mailmap.get(emailLower);
   if (replacement) {
     ({ author, email } = { author, email, ...replacement });
   }
diff --git a/tools/update-babel-eslint.sh b/tools/update-babel-eslint.sh
index 700194da937dcbd7f34cf41e3def9b7be5d44c5b..b64b8f25d32f7c442ce6f620485a8a97238f4355 100755
--- a/tools/update-babel-eslint.sh
+++ b/tools/update-babel-eslint.sh
@@ -1,19 +1,19 @@
-#!/usr/bin/env bash
+#!/bin/sh
 
 # Shell script to update babel-eslint in the source tree to the latest release.
 
 # Depends on npm, npx, and node being in $PATH.
 
 # This script must be be in the tools directory when it runs because it uses
-# $BASH_SOURCE[0] to determine directories to work in.
+# $0 to determine directories to work in.
 
-cd "$( dirname "${BASH_SOURCE[0]}" )"
-rm -rf node_modules/babel-eslint
+cd "$( dirname "${0}" )" || exit
+rm -rf node_modules/@babel
 mkdir babel-eslint-tmp
-cd babel-eslint-tmp
+cd babel-eslint-tmp || exit
 npm init --yes
 
-npm install --global-style --no-bin-links --production --no-package-lock babel-eslint@latest
+npm install --global-style --no-bin-links --production --no-package-lock @babel/core @babel/eslint-parser@latest @babel/plugin-syntax-class-properties@latest @babel/plugin-syntax-top-level-await@latest
 
 # Use dmn to remove some unneeded files.
 npx dmn@2.2.2 -f clean
@@ -22,5 +22,5 @@ npx dmn@2.2.2 -f clean
 npx removeNPMAbsolutePaths@1.0.4 .
 
 cd ..
-mv babel-eslint-tmp/node_modules/babel-eslint node_modules/babel-eslint
+mv babel-eslint-tmp/node_modules/@babel node_modules/@babel
 rm -rf babel-eslint-tmp/
diff --git a/tools/update-cares.sh b/tools/update-cares.sh
new file mode 100755
index 0000000000000000000000000000000000000000..d92fc6ed2e7362fb9e3d19d90beb7014dc51d5ba
--- /dev/null
+++ b/tools/update-cares.sh
@@ -0,0 +1,56 @@
+#!/bin/sh
+set -e
+# Shell script to update c-ares in the source tree to a specific version
+
+BASE_DIR="$( pwd )"/
+DEPS_DIR="$BASE_DIR"deps/
+ARES_VERSION=$1
+
+if [ "$#" -le 0 ]; then
+  echo "Error: please provide an c-ares version to update to"
+  echo "	e.g. $0 1.18.1"
+  exit 1
+fi
+
+echo "Making temporary workspace"
+
+WORKSPACE=$(mktemp -d 2> /dev/null || mktemp -d -t 'tmp')
+
+cleanup () {
+  EXIT_CODE=$?
+  [ -d "$WORKSPACE" ] && rm -rf "$WORKSPACE"
+  exit $EXIT_CODE
+}
+
+trap cleanup INT TERM EXIT
+
+ARES_REF="cares-$(echo "$ARES_VERSION" | tr . _)"
+ARES_TARBALL="c-ares-$ARES_VERSION.tar.gz"
+
+cd "$WORKSPACE"
+
+echo "Fetching c-ares source archive"
+curl -sL -o "$ARES_TARBALL" "https://github.com/c-ares/c-ares/releases/download/$ARES_REF/$ARES_TARBALL"
+gzip -dc "$ARES_TARBALL" | tar xf -
+rm "$ARES_TARBALL"
+mv "c-ares-$ARES_VERSION" cares
+
+echo "Removing tests"
+rm -rf "$WORKSPACE/cares/test"
+
+echo "Copying existing .gitignore, config and gyp files"
+cp -R "$DEPS_DIR/cares/config" "$WORKSPACE/cares"
+cp "$DEPS_DIR/cares/.gitignore" "$WORKSPACE/cares"
+cp "$DEPS_DIR/cares/cares.gyp" "$WORKSPACE/cares"
+
+echo "Replacing existing c-ares"
+rm -rf "$DEPS_DIR/cares"
+mv "$WORKSPACE/cares" "$DEPS_DIR/"
+
+echo "All done!"
+echo ""
+echo "Please git add c-ares, commit the new version:"
+echo ""
+echo "$ git add -A deps/cares"
+echo "$ git commit -m \"deps: update c-ares to $ARES_VERSION\""
+echo ""
diff --git a/tools/update-eslint.sh b/tools/update-eslint.sh
index f877c0a9e48259d24ee66484c39f6bf485dc725f..109390d2b27baf0be905c595d84c8805c3727883 100755
--- a/tools/update-eslint.sh
+++ b/tools/update-eslint.sh
@@ -1,30 +1,29 @@
-#!/usr/bin/env bash
+#!/bin/sh
 
 # Shell script to update ESLint in the source tree to the latest release.
 
 # Depends on npm, npx, and node being in $PATH.
 
-# This script must be be in the tools directory when it runs because it uses
-# $BASH_SOURCE[0] to determine directories to work in.
+# This script must be in the tools directory when it runs because it uses the
+# script source file path to determine directories to work in.
 
-cd "$( dirname "${BASH_SOURCE[0]}" )"
-rm -rf node_modules/eslint
-mkdir eslint-tmp
-cd eslint-tmp
-npm init --yes
+cd "$( dirname "$0" )" || exit
+rm -rf node_modules/eslint node_modules/eslint-plugin-markdown
+(
+    mkdir eslint-tmp
+    cd eslint-tmp || exit
+    npm init --yes
 
-npm install --global-style --no-bin-links --production --no-package-lock eslint@latest
-cd node_modules/eslint
+    npm install --global-style --no-bin-links --production --no-package-lock eslint@latest
+    npm install --global-style --no-bin-links --production --no-package-lock eslint-plugin-markdown@latest
 
-npm install --no-bin-links --production --no-package-lock eslint-plugin-markdown@latest
-cd ../..
+    # Use dmn to remove some unneeded files.
+    npx dmn@2.2.2 -f clean
+    # Use removeNPMAbsolutePaths to remove unused data in package.json.
+    # This avoids churn as absolute paths can change from one dev to another.
+    npx removeNPMAbsolutePaths@1.0.4 .
+)
 
-# Use dmn to remove some unneeded files.
-npx dmn@2.2.2 -f clean
-# Use removeNPMAbsolutePaths to remove unused data in package.json.
-# This avoids churn as absolute paths can change from one dev to another.
-npx removeNPMAbsolutePaths@1.0.4 .
-
-cd ..
 mv eslint-tmp/node_modules/eslint node_modules/eslint
+mv eslint-tmp/node_modules/eslint-plugin-markdown node_modules/eslint-plugin-markdown
 rm -rf eslint-tmp/
diff --git a/tools/update-npm.sh b/tools/update-npm.sh
new file mode 100755
index 0000000000000000000000000000000000000000..d58b325b77f713711a450d8e4f2fa639aaac3e62
--- /dev/null
+++ b/tools/update-npm.sh
@@ -0,0 +1,53 @@
+#!/bin/sh
+set -e
+# Shell script to update npm in the source tree to a specific version
+
+BASE_DIR="$( pwd )"/
+DEPS_DIR="$BASE_DIR"deps/
+NPM_VERSION=$1
+
+if [ "$#" -le 0 ]; then
+  echo "Error: please provide an npm version to update to"
+  exit 1
+fi
+
+echo "Making temporary workspace"
+
+WORKSPACE=$(mktemp -d 2> /dev/null || mktemp -d -t 'tmp')
+
+cleanup () {
+  EXIT_CODE=$?
+  [ -d "$WORKSPACE" ] && rm -rf "$WORKSPACE"
+  exit $EXIT_CODE
+}
+
+trap cleanup INT TERM EXIT
+
+cd "$WORKSPACE"
+
+git clone --depth=1 --branch="v$NPM_VERSION" git@github.com:npm/cli.git
+cd cli
+
+echo "Preparing npm release"
+
+make
+make release
+
+echo "Removing old npm"
+
+cd "$DEPS_DIR"
+rm -rf npm/
+
+echo "Copying new npm"
+
+tar zxf "$WORKSPACE"/cli/release/npm-"$NPM_VERSION".tgz
+
+echo ""
+echo "All done!"
+echo ""
+echo "Please git add npm, commit the new version, and whitespace-fix:"
+echo ""
+echo "$ git add -A deps/npm"
+echo "$ git commit -m \"deps: upgrade npm to $NPM_VERSION\""
+echo "$ git rebase --whitespace=fix master"
+echo ""
diff --git a/tools/utils.py b/tools/utils.py
index 9734836db7f06e5ba7e11f1293e4f74d5f50a7d8..b8963e0b5240b996b9c689aede696a62d975de30 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -26,8 +26,10 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
+import os
 import platform
 import re
+import sys
 
 
 # Reads a .list file into an array of strings
@@ -106,3 +108,14 @@ def GuessArchitecture():
 
 def IsWindows():
   return GuessOS() == 'win32'
+
+
+def SearchFiles(dir, ext):
+  matching_files = []
+  for path, dirs, files in os.walk(dir):
+    for file in files:
+      if file.endswith('.' + ext):
+        matching_files.append(path + '/' + file)
+  if sys.platform == 'win32':
+    matching_files = [x.replace('\\', '/') for x in matching_files]
+  return matching_files
diff --git a/tools/v8_gypfiles/features.gypi b/tools/v8_gypfiles/features.gypi
index 602d6063f361738439681b86377f2866d3633dad..b24e0b332b3c1d2e9b017391867a420cde886703 100644
--- a/tools/v8_gypfiles/features.gypi
+++ b/tools/v8_gypfiles/features.gypi
@@ -109,9 +109,6 @@
     # Enable fast mksnapshot runs.
     'v8_enable_fast_mksnapshot%': 0,
 
-    # Enable embedded builtins.
-    'v8_enable_embedded_builtins%': 1,
-
     # Enable the registration of unwinding info for Windows/x64 and ARM64.
     'v8_win64_unwinding_info%': 1,
 
@@ -149,6 +146,9 @@
     # Sets -dV8_CONCURRENT_MARKING
     'v8_enable_concurrent_marking%': 1,
 
+    # Sets -dV8_ARRAY_BUFFER_EXTENSION
+    'v8_enable_array_buffer_extension%': 1,
+
     # Enables various testing features.
     'v8_enable_test_features%': 0,
 
@@ -184,6 +184,15 @@
     # Enable lazy source positions by default.
     'v8_enable_lazy_source_positions%': 1,
 
+    # Enable third party HEAP library
+    'v8_enable_third_party_heap%': 0,
+
+    # Libaries used by third party heap
+    'v8_third_party_heap_libs%': [],
+
+    # Source code used by third party heap
+    'v8_third_party_heap_files%': [],
+
     # Disable write barriers when GCs are non-incremental and
     # heap has single generation.
     'v8_disable_write_barriers%': 0,
@@ -196,11 +205,18 @@
     # Use switch-based dispatch if this is false.
     'v8_enable_regexp_interpreter_threaded_dispatch%': 1,
 
-    # Variables from v8.gni
+    # Disable all snapshot compression.
+    'v8_enable_snapshot_compression%': 1,
+
+    # Enable control-flow integrity features, such as pointer authentication
+    # for ARM64.
+    'v8_control_flow_integrity%': 0,
 
-    # Enable the snapshot feature, for fast context creation.
-    # http://v8project.blogspot.com/2015/09/custom-startup-snapshots.html
-    'v8_use_snapshot%': 1,
+    # Experimental support for native context independent code.
+    # https://crbug.com/v8/8888
+    'v8_enable_nci_code%': 0,
+
+    # Variables from v8.gni
 
     # Enable ECMAScript Internationalization API. Enabling this feature will
     # add a dependency on the ICU library.
@@ -225,10 +241,7 @@
         'defines': ['V8_ENABLE_FUTURE',],
       }],
       ['v8_enable_lite_mode==1', {
-        'defines': [
-          'V8_LITE_MODE',
-          'V8_JITLESS_MODE',
-        ],
+        'defines': ['V8_LITE_MODE',],
       }],
       ['v8_enable_gdbjit==1', {
         'defines': ['ENABLE_GDB_JIT_INTERFACE',],
@@ -287,13 +300,8 @@
       # ['v8_enable_handle_zapping==1', {
       #  'defines': ['ENABLE_HANDLE_ZAPPING',],
       # }],
-      ['v8_use_snapshot==1', {
-        'defines': ['V8_USE_SNAPSHOT',],
-        'conditions': [
-          ['v8_enable_snapshot_native_code_counters==1', {
-            'defines': ['V8_SNAPSHOT_NATIVE_CODE_COUNTERS',],
-          }],
-        ],
+      ['v8_enable_snapshot_native_code_counters==1', {
+        'defines': ['V8_SNAPSHOT_NATIVE_CODE_COUNTERS',],
       }],
       ['v8_enable_single_generation==1', {
         'defines': ['V8_ENABLE_SINGLE_GENERATION',],
@@ -301,18 +309,21 @@
       ['v8_disable_write_barriers==1', {
         'defines': ['V8_DISABLE_WRITE_BARRIERS',],
       }],
+      ['v8_enable_third_party_heap==1', {
+        'defines': ['V8_ENABLE_THIRD_PARTY_HEAP',],
+      }],
       ['v8_enable_concurrent_marking==1', {
         'defines': ['V8_CONCURRENT_MARKING',],
       }],
+      ['v8_enable_array_buffer_extension==1', {
+        'defines': ['V8_ARRAY_BUFFER_EXTENSION',],
+      }],
       ['v8_enable_lazy_source_positions==1', {
         'defines': ['V8_ENABLE_LAZY_SOURCE_POSITIONS',],
       }],
       ['v8_check_microtasks_scopes_consistency==1', {
         'defines': ['V8_CHECK_MICROTASKS_SCOPES_CONSISTENCY',],
       }],
-      ['v8_enable_embedded_builtins==1', {
-        'defines': ['V8_EMBEDDED_BUILTINS',],
-      }],
       ['v8_use_siphash==1', {
         'defines': ['V8_USE_SIPHASH',],
       }],
@@ -334,6 +345,15 @@
       ['v8_enable_regexp_interpreter_threaded_dispatch==1', {
         'defines': ['V8_ENABLE_REGEXP_INTERPRETER_THREADED_DISPATCH',],
       }],
+      ['v8_enable_snapshot_compression==1', {
+        'defines': ['V8_SNAPSHOT_COMPRESSION',],
+      }],
+      ['v8_control_flow_integrity==1', {
+        'defines': ['V8_ENABLE_CONTROL_FLOW_INTEGRITY',],
+      }],
+      ['v8_enable_nci_code==1', {
+        'defines': ['V8_ENABLE_NCI_CODE',],
+      }],
     ],  # conditions
     'defines': [
       'V8_GYP_BUILD',
diff --git a/tools/v8_gypfiles/inspector.gypi b/tools/v8_gypfiles/inspector.gypi
index 562583126d3f7fa74d89f5c0ef7e7d726bc4b075..27e2014132a671494c5d8f86ec1bac14d8f724a9 100644
--- a/tools/v8_gypfiles/inspector.gypi
+++ b/tools/v8_gypfiles/inspector.gypi
@@ -8,16 +8,9 @@
     'inspector_protocol_files': [
       '<(inspector_protocol_path)/lib/base_string_adapter_cc.template',
       '<(inspector_protocol_path)/lib/base_string_adapter_h.template',
-      '<(inspector_protocol_path)/lib/DispatcherBase_cpp.template',
-      '<(inspector_protocol_path)/lib/DispatcherBase_h.template',
-      '<(inspector_protocol_path)/lib/ErrorSupport_cpp.template',
-      '<(inspector_protocol_path)/lib/ErrorSupport_h.template',
       '<(inspector_protocol_path)/lib/Forward_h.template',
-      '<(inspector_protocol_path)/lib/FrontendChannel_h.template',
       '<(inspector_protocol_path)/lib/Object_cpp.template',
       '<(inspector_protocol_path)/lib/Object_h.template',
-      '<(inspector_protocol_path)/lib/Parser_cpp.template',
-      '<(inspector_protocol_path)/lib/Parser_h.template',
       '<(inspector_protocol_path)/lib/Protocol_cpp.template',
       '<(inspector_protocol_path)/lib/ValueConversions_h.template',
       '<(inspector_protocol_path)/lib/Values_cpp.template',
@@ -86,8 +79,6 @@
       '<(V8_ROOT)/src/inspector/v8-heap-profiler-agent-impl.h',
       '<(V8_ROOT)/src/inspector/v8-inspector-impl.cc',
       '<(V8_ROOT)/src/inspector/v8-inspector-impl.h',
-      '<(V8_ROOT)/src/inspector/v8-inspector-protocol-encoding.cc',
-      '<(V8_ROOT)/src/inspector/v8-inspector-protocol-encoding.h',
       '<(V8_ROOT)/src/inspector/v8-inspector-session-impl.cc',
       '<(V8_ROOT)/src/inspector/v8-inspector-session-impl.h',
       '<(V8_ROOT)/src/inspector/v8-profiler-agent-impl.cc',
@@ -104,18 +95,32 @@
       '<(V8_ROOT)/src/inspector/v8-value-utils.h',
       '<(V8_ROOT)/src/inspector/value-mirror.cc',
       '<(V8_ROOT)/src/inspector/value-mirror.h',
-      '<(V8_ROOT)/src/inspector/wasm-translation.cc',
-      '<(V8_ROOT)/src/inspector/wasm-translation.h',
       # Flat merge `third_party/inspector_protocol:inspector_string_conversions`
       '<(inspector_path)/v8-string-conversions.cc',
       '<(inspector_path)/v8-string-conversions.h',
-      # Flat merge `third_party/inspector_protocol:encoding`
-      '<(inspector_protocol_path)/encoding/encoding.cc',
-      '<(inspector_protocol_path)/encoding/encoding.h',
-      # Flat merge `third_party/inspector_protocol:bindings`
-      '<(inspector_protocol_path)/bindings/bindings.cc',
-      '<(inspector_protocol_path)/bindings/bindings.h',
-
+      # Flat merge `third_party/inspector_protocal:crdtp_platform`
+      '<(inspector_protocol_path)/crdtp/json_platform.h',
+      '<(inspector_protocol_path)/crdtp/json_platform_v8.cc',
+      # Flat merge `third_party/inspector_protocol:crdtp`
+      '<(inspector_protocol_path)/crdtp/cbor.cc',
+      '<(inspector_protocol_path)/crdtp/cbor.h',
+      '<(inspector_protocol_path)/crdtp/dispatch.cc',
+      '<(inspector_protocol_path)/crdtp/dispatch.h',
+      '<(inspector_protocol_path)/crdtp/error_support.cc',
+      '<(inspector_protocol_path)/crdtp/error_support.h',
+      '<(inspector_protocol_path)/crdtp/export.h',
+      '<(inspector_protocol_path)/crdtp/find_by_first.h',
+      '<(inspector_protocol_path)/crdtp/glue.h',
+      '<(inspector_protocol_path)/crdtp/json.cc',
+      '<(inspector_protocol_path)/crdtp/json.h',
+      '<(inspector_protocol_path)/crdtp/parser_handler.h',
+      '<(inspector_protocol_path)/crdtp/serializable.cc',
+      '<(inspector_protocol_path)/crdtp/serializable.h',
+      '<(inspector_protocol_path)/crdtp/serializer_traits.h',
+      '<(inspector_protocol_path)/crdtp/span.cc',
+      '<(inspector_protocol_path)/crdtp/span.h',
+      '<(inspector_protocol_path)/crdtp/status.cc',
+      '<(inspector_protocol_path)/crdtp/status.h',
     ],
     'v8_inspector_js_protocol': '<(V8_ROOT)/include/js_protocol.pdl',
   },
diff --git a/tools/v8_gypfiles/toolchain.gypi b/tools/v8_gypfiles/toolchain.gypi
index 0876b16b46a1f5f8469209c6da2bc81471ccc5de..d4bad70d45025ee3816ecdc0e94268529a02fd54 100644
--- a/tools/v8_gypfiles/toolchain.gypi
+++ b/tools/v8_gypfiles/toolchain.gypi
@@ -270,11 +270,17 @@
         'defines': [
           'V8_TARGET_ARCH_ARM64',
         ],
+        'conditions': [
+          ['v8_control_flow_integrity==1', {
+            'cflags': [ '-mbranch-protection=standard' ],
+          }],
+        ],
       }],
       ['v8_target_arch=="s390x"', {
         'defines': [
           'V8_TARGET_ARCH_S390',
         ],
+        'cflags': [ '-ffp-contract=off' ],
         'conditions': [
           ['v8_target_arch=="s390x"', {
             'defines': [
@@ -291,10 +297,12 @@
           ],
       }],  # s390x
       ['v8_target_arch=="ppc" or v8_target_arch=="ppc64"', {
-        'defines': [
-          'V8_TARGET_ARCH_PPC',
-        ],
         'conditions': [
+          ['v8_target_arch=="ppc"', {
+            'defines': [
+              'V8_TARGET_ARCH_PPC',
+            ],
+          }],
           ['v8_target_arch=="ppc64"', {
             'defines': [
               'V8_TARGET_ARCH_PPC64',
diff --git a/tools/v8_gypfiles/v8.gyp b/tools/v8_gypfiles/v8.gyp
index 26b8e56e834a05c3efc10d6b0b664c6a0613c513..48ec392b6f85ed8fc2f6c30dd7d01f33dbca36af 100644
--- a/tools/v8_gypfiles/v8.gyp
+++ b/tools/v8_gypfiles/v8.gyp
@@ -13,13 +13,14 @@
     'generate_bytecode_output_root': '<(SHARED_INTERMEDIATE_DIR)/generate-bytecode-output-root',
     'generate_bytecode_builtins_list_output': '<(generate_bytecode_output_root)/builtins-generated/bytecodes-builtins-list.h',
     'torque_files': [
-      "<(V8_ROOT)/src/builtins/arguments.tq",
       "<(V8_ROOT)/src/builtins/array-copywithin.tq",
       "<(V8_ROOT)/src/builtins/array-every.tq",
       "<(V8_ROOT)/src/builtins/array-filter.tq",
       "<(V8_ROOT)/src/builtins/array-find.tq",
       "<(V8_ROOT)/src/builtins/array-findindex.tq",
       "<(V8_ROOT)/src/builtins/array-foreach.tq",
+      "<(V8_ROOT)/src/builtins/array-from.tq",
+      "<(V8_ROOT)/src/builtins/array-isarray.tq",
       "<(V8_ROOT)/src/builtins/array-join.tq",
       "<(V8_ROOT)/src/builtins/array-lastindexof.tq",
       "<(V8_ROOT)/src/builtins/array-map.tq",
@@ -36,16 +37,36 @@
       "<(V8_ROOT)/src/builtins/base.tq",
       "<(V8_ROOT)/src/builtins/bigint.tq",
       "<(V8_ROOT)/src/builtins/boolean.tq",
+      "<(V8_ROOT)/src/builtins/builtins-string.tq",
       "<(V8_ROOT)/src/builtins/collections.tq",
+      "<(V8_ROOT)/src/builtins/cast.tq",
+      "<(V8_ROOT)/src/builtins/convert.tq",
+      "<(V8_ROOT)/src/builtins/console.tq",
       "<(V8_ROOT)/src/builtins/data-view.tq",
-      "<(V8_ROOT)/src/builtins/extras-utils.tq",
+      "<(V8_ROOT)/src/builtins/finalization-registry.tq",
       "<(V8_ROOT)/src/builtins/frames.tq",
+      "<(V8_ROOT)/src/builtins/frame-arguments.tq",
       "<(V8_ROOT)/src/builtins/growable-fixed-array.tq",
+      "<(V8_ROOT)/src/builtins/ic-callable.tq",
+      "<(V8_ROOT)/src/builtins/ic.tq",
       "<(V8_ROOT)/src/builtins/internal-coverage.tq",
       "<(V8_ROOT)/src/builtins/iterator.tq",
       "<(V8_ROOT)/src/builtins/math.tq",
+      "<(V8_ROOT)/src/builtins/number.tq",
       "<(V8_ROOT)/src/builtins/object-fromentries.tq",
       "<(V8_ROOT)/src/builtins/object.tq",
+      "<(V8_ROOT)/src/builtins/promise-abstract-operations.tq",
+      "<(V8_ROOT)/src/builtins/promise-all.tq",
+      "<(V8_ROOT)/src/builtins/promise-all-element-closure.tq",
+      "<(V8_ROOT)/src/builtins/promise-any.tq",
+      "<(V8_ROOT)/src/builtins/promise-constructor.tq",
+      "<(V8_ROOT)/src/builtins/promise-finally.tq",
+      "<(V8_ROOT)/src/builtins/promise-misc.tq",
+      "<(V8_ROOT)/src/builtins/promise-race.tq",
+      "<(V8_ROOT)/src/builtins/promise-reaction-job.tq",
+      "<(V8_ROOT)/src/builtins/promise-resolve.tq",
+      "<(V8_ROOT)/src/builtins/promise-then.tq",
+      "<(V8_ROOT)/src/builtins/promise-jobs.tq",
       "<(V8_ROOT)/src/builtins/proxy-constructor.tq",
       "<(V8_ROOT)/src/builtins/proxy-delete-property.tq",
       "<(V8_ROOT)/src/builtins/proxy-get-property.tq",
@@ -59,20 +80,26 @@
       "<(V8_ROOT)/src/builtins/proxy-set-prototype-of.tq",
       "<(V8_ROOT)/src/builtins/proxy.tq",
       "<(V8_ROOT)/src/builtins/reflect.tq",
+      "<(V8_ROOT)/src/builtins/regexp-exec.tq",
+      "<(V8_ROOT)/src/builtins/regexp-match-all.tq",
       "<(V8_ROOT)/src/builtins/regexp-match.tq",
       "<(V8_ROOT)/src/builtins/regexp-replace.tq",
+      "<(V8_ROOT)/src/builtins/regexp-search.tq",
       "<(V8_ROOT)/src/builtins/regexp-source.tq",
+      "<(V8_ROOT)/src/builtins/regexp-split.tq",
       "<(V8_ROOT)/src/builtins/regexp-test.tq",
       "<(V8_ROOT)/src/builtins/regexp.tq",
-      "<(V8_ROOT)/src/builtins/string.tq",
       "<(V8_ROOT)/src/builtins/string-endswith.tq",
       "<(V8_ROOT)/src/builtins/string-html.tq",
       "<(V8_ROOT)/src/builtins/string-iterator.tq",
       "<(V8_ROOT)/src/builtins/string-pad.tq",
       "<(V8_ROOT)/src/builtins/string-repeat.tq",
+      "<(V8_ROOT)/src/builtins/string-replaceall.tq",
       "<(V8_ROOT)/src/builtins/string-slice.tq",
       "<(V8_ROOT)/src/builtins/string-startswith.tq",
       "<(V8_ROOT)/src/builtins/string-substring.tq",
+      "<(V8_ROOT)/src/builtins/string-substr.tq",
+      "<(V8_ROOT)/src/builtins/symbol.tq",
       "<(V8_ROOT)/src/builtins/torque-internal.tq",
       "<(V8_ROOT)/src/builtins/typed-array-createtypedarray.tq",
       "<(V8_ROOT)/src/builtins/typed-array-every.tq",
@@ -80,14 +107,74 @@
       "<(V8_ROOT)/src/builtins/typed-array-find.tq",
       "<(V8_ROOT)/src/builtins/typed-array-findindex.tq",
       "<(V8_ROOT)/src/builtins/typed-array-foreach.tq",
+      "<(V8_ROOT)/src/builtins/typed-array-from.tq",
+      "<(V8_ROOT)/src/builtins/typed-array-of.tq",
       "<(V8_ROOT)/src/builtins/typed-array-reduce.tq",
       "<(V8_ROOT)/src/builtins/typed-array-reduceright.tq",
+      "<(V8_ROOT)/src/builtins/typed-array-set.tq",
       "<(V8_ROOT)/src/builtins/typed-array-slice.tq",
       "<(V8_ROOT)/src/builtins/typed-array-some.tq",
+      "<(V8_ROOT)/src/builtins/typed-array-sort.tq",
       "<(V8_ROOT)/src/builtins/typed-array-subarray.tq",
       "<(V8_ROOT)/src/builtins/typed-array.tq",
-      "<(V8_ROOT)/third_party/v8/builtins/array-sort.tq",
+      "<(V8_ROOT)/src/builtins/wasm.tq",
+      "<(V8_ROOT)/src/ic/handler-configuration.tq",
+      "<(V8_ROOT)/src/objects/allocation-site.tq",
+      "<(V8_ROOT)/src/objects/api-callbacks.tq",
+      "<(V8_ROOT)/src/objects/arguments.tq",
+      "<(V8_ROOT)/src/objects/cell.tq",
+      "<(V8_ROOT)/src/objects/code.tq",
+      "<(V8_ROOT)/src/objects/contexts.tq",
+      "<(V8_ROOT)/src/objects/data-handler.tq",
+      "<(V8_ROOT)/src/objects/debug-objects.tq",
+      "<(V8_ROOT)/src/objects/descriptor-array.tq",
+      "<(V8_ROOT)/src/objects/embedder-data-array.tq",
+      "<(V8_ROOT)/src/objects/feedback-cell.tq",
+      "<(V8_ROOT)/src/objects/feedback-vector.tq",
+      "<(V8_ROOT)/src/objects/fixed-array.tq",
+      "<(V8_ROOT)/src/objects/foreign.tq",
+      "<(V8_ROOT)/src/objects/free-space.tq",
+      "<(V8_ROOT)/src/objects/heap-number.tq",
+      "<(V8_ROOT)/src/objects/heap-object.tq",
+      "<(V8_ROOT)/src/objects/js-aggregate-error.tq",
+      "<(V8_ROOT)/src/objects/js-array-buffer.tq",
+      "<(V8_ROOT)/src/objects/js-array.tq",
+      "<(V8_ROOT)/src/objects/js-collection-iterator.tq",
+      "<(V8_ROOT)/src/objects/js-collection.tq",
+      "<(V8_ROOT)/src/objects/js-generator.tq",
+      "<(V8_ROOT)/src/objects/js-objects.tq",
+      "<(V8_ROOT)/src/objects/js-promise.tq",
+      "<(V8_ROOT)/src/objects/js-proxy.tq",
+      "<(V8_ROOT)/src/objects/js-regexp-string-iterator.tq",
+      "<(V8_ROOT)/src/objects/js-regexp.tq",
+      "<(V8_ROOT)/src/objects/js-weak-refs.tq",
+      "<(V8_ROOT)/src/objects/literal-objects.tq",
+      "<(V8_ROOT)/src/objects/map.tq",
+      "<(V8_ROOT)/src/objects/microtask.tq",
+      "<(V8_ROOT)/src/objects/module.tq",
+      "<(V8_ROOT)/src/objects/name.tq",
+      "<(V8_ROOT)/src/objects/oddball.tq",
+      "<(V8_ROOT)/src/objects/ordered-hash-table.tq",
+      "<(V8_ROOT)/src/objects/primitive-heap-object.tq",
+      "<(V8_ROOT)/src/objects/promise.tq",
+      "<(V8_ROOT)/src/objects/property-array.tq",
+      "<(V8_ROOT)/src/objects/property-cell.tq",
+      "<(V8_ROOT)/src/objects/property-descriptor-object.tq",
+      "<(V8_ROOT)/src/objects/prototype-info.tq",
+      "<(V8_ROOT)/src/objects/regexp-match-info.tq",
+      "<(V8_ROOT)/src/objects/scope-info.tq",
+      "<(V8_ROOT)/src/objects/script.tq",
+      "<(V8_ROOT)/src/objects/shared-function-info.tq",
+      "<(V8_ROOT)/src/objects/source-text-module.tq",
+      "<(V8_ROOT)/src/objects/stack-frame-info.tq",
+      "<(V8_ROOT)/src/objects/string.tq",
+      "<(V8_ROOT)/src/objects/struct.tq",
+      "<(V8_ROOT)/src/objects/synthetic-module.tq",
+      "<(V8_ROOT)/src/objects/template-objects.tq",
+      "<(V8_ROOT)/src/objects/template.tq",
+      "<(V8_ROOT)/src/wasm/wasm-objects.tq",
       "<(V8_ROOT)/test/torque/test-torque.tq",
+      "<(V8_ROOT)/third_party/v8/builtins/array-sort.tq",
     ],
     'torque_output_root': '<(SHARED_INTERMEDIATE_DIR)/torque-output-root',
     'torque_files_replaced': ['<!@pymod_do_main(ForEachReplace ".tq" "-tq-csa" <@(torque_files))'],
@@ -137,11 +224,17 @@
             '<@(torque_files)',
           ],
           'outputs': [
+            '<(torque_output_root)/torque-generated/bit-fields-tq.h',
             '<(torque_output_root)/torque-generated/builtin-definitions-tq.h',
+            '<(torque_output_root)/torque-generated/interface-descriptors-tq.inc',
+            '<(torque_output_root)/torque-generated/factory-tq.cc',
+            '<(torque_output_root)/torque-generated/factory-tq.inc',
             '<(torque_output_root)/torque-generated/field-offsets-tq.h',
             '<(torque_output_root)/torque-generated/class-verifiers-tq.cc',
             '<(torque_output_root)/torque-generated/class-verifiers-tq.h',
+            '<(torque_output_root)/torque-generated/enum-verifiers-tq.cc',
             '<(torque_output_root)/torque-generated/objects-printer-tq.cc',
+            '<(torque_output_root)/torque-generated/objects-body-descriptors-tq-inl.inc',
             '<(torque_output_root)/torque-generated/class-definitions-tq.cc',
             '<(torque_output_root)/torque-generated/class-definitions-tq-inl.h',
             '<(torque_output_root)/torque-generated/class-definitions-tq.h',
@@ -197,9 +290,11 @@
       ],
       'direct_dependent_settings': {
         'sources': [
+          '<(torque_output_root)/torque-generated/csa-types-tq.h',
+          '<(torque_output_root)/torque-generated/enum-verifiers-tq.cc',
           '<(torque_output_root)/torque-generated/exported-macros-assembler-tq.cc',
           '<(torque_output_root)/torque-generated/exported-macros-assembler-tq.h',
-          '<(torque_output_root)/torque-generated/csa-types-tq.h',
+          '<(V8_ROOT)/src/torque/runtime-support.h',
           '<@(torque_outputs)',
         ],
       }
@@ -223,6 +318,7 @@
           '<(torque_output_root)/torque-generated/class-definitions-tq.cc',
           '<(torque_output_root)/torque-generated/class-verifiers-tq.cc',
           '<(torque_output_root)/torque-generated/class-verifiers-tq.h',
+          '<(torque_output_root)/torque-generated/factory-tq.cc',
           '<(torque_output_root)/torque-generated/objects-printer-tq.cc',
         ],
         'include_dirs': [
@@ -269,26 +365,6 @@
         },
       ],
     },  # generate_bytecode_builtins_list
-
-    {
-      # This rule delegates to either v8_snapshot or v8_nosnapshot depending on
-      # the current variables.
-      # The intention is to make the 'calling' rules a bit simpler.
-      'target_name': 'v8_maybe_snapshot',
-      'type': 'none',
-      'toolsets': ['target'],
-      'hard_dependency': 1,
-      'conditions': [
-        # The dependency on v8_base should come from a transitive
-        # dependency however the Android toolchain requires libv8_base.a
-        # to appear before libv8_snapshot.a so it's listed explicitly.
-        ['v8_use_snapshot==1', {
-          'dependencies': ['v8_base', 'v8_snapshot'],
-        }, {
-          'dependencies': ['v8_base', 'v8_init', 'v8_nosnapshot'],
-        }],
-      ]
-    },  # v8_maybe_snapshot
     {
       'target_name': 'v8_init',
       'type': 'static_library',
@@ -359,7 +435,12 @@
             '<(V8_ROOT)/src/builtins/mips64/builtins-mips64.cc',
           ],
         }],
-        ['v8_target_arch=="ppc" or v8_target_arch=="ppc64"', {
+        ['v8_target_arch=="ppc"', {
+          'sources': [
+            '<(V8_ROOT)/src/builtins/ppc/builtins-ppc.cc',
+          ],
+        }],
+        ['v8_target_arch=="ppc64"', {
           'sources': [
             '<(V8_ROOT)/src/builtins/ppc/builtins-ppc.cc',
           ],
@@ -395,6 +476,11 @@
       'toolsets': ['target'],
       'conditions': [
         ['want_separate_host_toolset', {
+          'conditions': [
+            ['v8_target_arch=="arm64"', {
+              'msvs_enable_marmasm': 1,
+            }]
+          ],
           'dependencies': [
             'generate_bytecode_builtins_list',
             'run_torque',
@@ -422,7 +508,6 @@
       ],
       'sources': [
         '<(V8_ROOT)/src/init/setup-isolate-deserialize.cc',
-        './extras-libraries.cc',
       ],
       'xcode_settings': {
         # V8 7.4 over macOS10.11 compatibility
@@ -443,27 +528,19 @@
               '--target_os=<(OS)',
               '--target_arch=<(v8_target_arch)',
               '--startup_src', '<(INTERMEDIATE_DIR)/snapshot.cc',
+              '--embedded_variant', 'Default',
+              '--embedded_src', '<(INTERMEDIATE_DIR)/embedded.S',
             ],
           },
           'inputs': [
             '<(mksnapshot_exec)',
           ],
-          'outputs': ["<(INTERMEDIATE_DIR)/snapshot.cc"],
+          'outputs': [
+            '<(INTERMEDIATE_DIR)/snapshot.cc',
+            '<(INTERMEDIATE_DIR)/embedded.S',
+          ],
           'process_outputs_as_sources': 1,
           'conditions': [
-            ['v8_enable_embedded_builtins', {
-              # In this case we use `embedded_variant "Default"`
-              # and `suffix = ''` for the template `embedded${suffix}.S`.
-              'outputs': ['<(INTERMEDIATE_DIR)/embedded.S'],
-              'variables': {
-                'mksnapshot_flags': [
-                  '--embedded_variant', 'Default',
-                  '--embedded_src', '<(INTERMEDIATE_DIR)/embedded.S',
-                ],
-              },
-            }, {
-               'outputs': ['<(V8_ROOT)/src/snapshot/embedded/embedded-empty.cc']
-             }],
             ['v8_random_seed', {
               'variables': {
                 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'],
@@ -504,31 +581,6 @@
         },
       ],
     },  # v8_snapshot
-    {
-      'target_name': 'v8_nosnapshot',
-      'type': 'static_library',
-      'dependencies': [
-        # 'js2c_extras',  # Disabled for Node.js
-        'generate_bytecode_builtins_list',
-        'run_torque',
-        'v8_maybe_icu',
-      ],
-      'sources': [
-        './extras-libraries.cc',
-        '<(V8_ROOT)/src/snapshot/embedded/embedded-empty.cc',
-        '<(V8_ROOT)/src/snapshot/snapshot-empty.cc',
-      ],
-      'conditions': [
-        ['want_separate_host_toolset', {
-          'toolsets': ['host', 'target'],
-        }],
-        ['component=="shared_library"', {
-          'defines': [
-            'BUILDING_V8_SHARED',
-          ],
-        }],
-      ]
-    },  # v8_nosnapshot
     {
       'target_name': 'v8_version',
       'type': 'none',
@@ -558,6 +610,7 @@
       ],
       'direct_dependent_settings': {
         'sources': [
+          '<(V8_ROOT)/include/v8-fast-api-calls.h',
           '<(V8_ROOT)/include/v8-internal.h',
           '<(V8_ROOT)/include/v8.h',
           '<(V8_ROOT)/include/v8config.h',
@@ -678,6 +731,7 @@
         'generate_bytecode_builtins_list',
         'run_torque',
         'v8_maybe_icu',
+        'v8_zlib',
       ],
       'includes': ['inspector.gypi'],
       'direct_dependent_settings': {
@@ -697,9 +751,25 @@
         '<@(inspector_all_sources)',
       ],
       'conditions': [
+        ['v8_enable_third_party_heap==1', {
+          # TODO(targos): add values from v8_third_party_heap_files to sources
+        }, {
+          'sources': [
+            '<(V8_ROOT)/src/heap/third-party/heap-api-stub.cc',
+          ],
+        }],
         ['want_separate_host_toolset', {
           'toolsets': ['host', 'target'],
         }],
+        ['v8_control_flow_integrity==1', {
+          'sources': [
+            '<(V8_ROOT)/src/execution/arm64/pointer-authentication-arm64.h',
+          ],
+        }, {
+          'sources': [
+            '<(V8_ROOT)/src/execution/pointer-authentication-dummy.h',
+          ],
+        }],
         ['v8_target_arch=="ia32"', {
           'sources': [  ### gcmole(arch:ia32) ###
             '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"x86.*?sources \+= ")',
@@ -712,7 +782,7 @@
           'conditions': [
             # iOS Xcode simulator builds run on an x64 target. iOS and macOS are both
             # based on Darwin and thus POSIX-compliant to a similar degree.
-            ['OS=="linux" or OS=="mac" or OS=="ios"', {
+            ['OS=="linux" or OS=="mac" or OS=="ios" or OS=="freebsd"', {
               'sources': [
                 '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?is_linux.*?sources \+= ")',
               ],
@@ -726,32 +796,53 @@
         }],
         ['v8_target_arch=="arm"', {
           'sources': [  ### gcmole(arch:arm) ###
-            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"arm.*?sources \+= ")',
+            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"arm\\".*?sources \+= ")',
           ],
         }],
         ['v8_target_arch=="arm64"', {
           'sources': [  ### gcmole(arch:arm64) ###
-            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"arm64.*?sources \+= ")',
+            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"arm64\\".*?sources \+= ")',
+          ],
+          'conditions': [
+            ['OS=="win"', {
+              'sources': [
+                "<(V8_ROOT)/src/diagnostics/unwinding-info-win64.cc",
+                "<(V8_ROOT)/src/diagnostics/unwinding-info-win64.h"
+              ],
+            }],
+          ],
+          'conditions': [
+            ['OS=="win"', {
+              'sources': [
+                "<(V8_ROOT)/src/diagnostics/unwinding-info-win64.cc",
+                "<(V8_ROOT)/src/diagnostics/unwinding-info-win64.h"
+              ],
+            }],
           ],
         }],
         ['v8_target_arch=="mips" or v8_target_arch=="mipsel"', {
           'sources': [  ### gcmole(arch:mipsel) ###
-            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"mips.*?sources \+= ")',
+            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"mips\\".*?sources \+= ")',
           ],
         }],
         ['v8_target_arch=="mips64" or v8_target_arch=="mips64el"', {
           'sources': [  ### gcmole(arch:mips64el) ###
-            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"mips64.*?sources \+= ")',
+            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"mips64\\".*?sources \+= ")',
           ],
         }],
-        ['v8_target_arch=="ppc" or v8_target_arch=="ppc64"', {
+        ['v8_target_arch=="ppc"', {
           'sources': [  ### gcmole(arch:ppc) ###
-            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"ppc.*?sources \+= ")',
+            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"ppc\\".*?sources \+= ")',
+          ],
+        }],
+        ['v8_target_arch=="ppc64"', {
+          'sources': [  ### gcmole(arch:ppc64) ###
+            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"ppc64\\".*?sources \+= ")',
           ],
         }],
         ['v8_target_arch=="s390x"', {
           'sources': [  ### gcmole(arch:s390) ###
-            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"s390.*?sources \+= ")',
+            '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"v8_base_without_compiler.*?v8_current_cpu == \\"s390\\".*?sources \+= ")',
           ],
         }],
         ['OS=="win"', {
@@ -807,6 +898,9 @@
         ['v8_postmortem_support', {
           'dependencies': ['postmortem-metadata#target'],
         }],
+        ['v8_enable_third_party_heap', {
+          # TODO(targos): add values from v8_third_party_heap_libs to link_settings.libraries
+        }],
         # Platforms that don't have Compare-And-Swap (CAS) support need to link atomic library
         # to implement atomic memory access
         ['v8_current_cpu in ["mips", "mipsel", "mips64", "mips64el", "ppc", "arm"]', {
@@ -1003,8 +1097,10 @@
             '<(V8_ROOT)/src/base/platform/platform-win32.cc',
             '<(V8_ROOT)/src/base/win32-headers.h',
           ],
-
-          'defines': ['_CRT_RAND_S'],  # for rand_s()
+          'conditions': [['target_arch == "arm64"', {
+            'defines': ['_WIN32_WINNT=0x0602'], # For GetCurrentThreadStackLimits on Windows on Arm
+          }]],
+          'defines': ['_CRT_RAND_S'], # for rand_s()
           'direct_dependent_settings': {
             'msvs_settings': {
               'VCLinkerTool': {
@@ -1146,6 +1242,8 @@
         '<(V8_ROOT)/include/libplatform/v8-tracing.h',
         '<(V8_ROOT)/src/libplatform/default-foreground-task-runner.cc',
         '<(V8_ROOT)/src/libplatform/default-foreground-task-runner.h',
+        '<(V8_ROOT)/src/libplatform/default-job.cc',
+        '<(V8_ROOT)/src/libplatform/default-job.h',
         '<(V8_ROOT)/src/libplatform/default-platform.cc',
         '<(V8_ROOT)/src/libplatform/default-platform.h',
         '<(V8_ROOT)/src/libplatform/default-worker-threads-task-runner.cc',
@@ -1209,49 +1307,6 @@
         '<(V8_ROOT)/src/libsampler/sampler.h'
       ],
     },  # v8_libsampler
-
-    # {
-    #   'target_name': 'fuzzer_support',
-    #   'type': 'static_library',
-    #   'conditions': [
-    #     ['want_separate_host_toolset', {
-    #       'toolsets': ['host', 'target'],
-    #     }],
-    #   ],
-    #   'dependencies': [
-    #     'v8',
-    #     'v8_libbase',
-    #     'v8_libplatform',
-    #     'v8_maybe_icu',
-    #   ],
-    #   'sources': [
-    #     "<(V8_ROOT)/test/fuzzer/fuzzer-support.cc",
-    #     "<(V8_ROOT)/test/fuzzer/fuzzer-support.h",
-    #   ],
-    # },  # fuzzer_support
-
-    # {
-    #   'target_name': 'wee8',
-    #   'type': 'static_library',
-    #   'dependencies': [
-    #     'v8_base',
-    #     'v8_libbase',
-    #     'v8_libplatform',
-    #     'v8_libsampler',
-    #     'v8_maybe_snapshot',
-    #     # 'build/win:default_exe_manifest',
-    #   ],
-    #   'sources': [
-    #     "<(V8_ROOT)/src/wasm/c-api.cc",
-    #     "<(V8_ROOT)/third_party/wasm-api/wasm.h",
-    #     "<(V8_ROOT)/third_party/wasm-api/wasm.hh",
-    #   ],
-    # }, # wee8
-
-    # ###############################################################################
-    # # Executablesicu_path
-    # #
-
     {
       'target_name': 'bytecode_builtins_list_generator',
       'type': 'executable',
@@ -1284,9 +1339,8 @@
         'v8_init',
         'v8_libbase',
         'v8_libplatform',
-        'v8_nosnapshot',
-        # "build/win:default_exe_manifest",
         'v8_maybe_icu',
+        # "build/win:default_exe_manifest",
       ],
       'sources': [
         '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"mksnapshot.*?sources = ")',
@@ -1418,7 +1472,7 @@
       'hard_dependency': 1,
       'toolsets': ['target'],
       'dependencies': [
-        'v8_maybe_snapshot'
+        'v8_snapshot',
       ],
       'conditions': [
         ['component=="shared_library"', {
@@ -1485,9 +1539,7 @@
               'v8_enable_i18n_support=<(v8_enable_i18n_support)',
               'v8_enable_verify_predictable=<(v8_enable_verify_predictable)',
               'v8_target_cpu=<(v8_target_arch)',
-              'v8_use_snapshot=<(v8_use_snapshot)',
               'v8_use_siphash=<(v8_use_siphash)',
-              'v8_enable_embedded_builtins=<(v8_enable_embedded_builtins)',
               'v8_enable_verify_csa=<(v8_enable_verify_csa)',
               'v8_enable_lite_mode=<(v8_enable_lite_mode)',
               'v8_enable_pointer_compression=<(v8_enable_pointer_compression)',
@@ -1523,9 +1575,68 @@
           'toolsets': ['host', 'target'],
         }],
       ],
+      'dependencies': ['run_torque'],
       'variables': {
         'heapobject_files': [
-          '<!@pymod_do_main(GN-scraper "<(V8_ROOT)/BUILD.gn"  "\\"postmortem-metadata.*?sources = ")',
+          '<(V8_ROOT)/src/objects/objects.h',
+          '<(V8_ROOT)/src/objects/objects-inl.h',
+          '<(V8_ROOT)/src/objects/allocation-site-inl.h',
+          '<(V8_ROOT)/src/objects/allocation-site.h',
+          '<(V8_ROOT)/src/objects/cell-inl.h',
+          '<(V8_ROOT)/src/objects/cell.h',
+          '<(V8_ROOT)/src/objects/code-inl.h',
+          '<(V8_ROOT)/src/objects/code.h',
+          '<(V8_ROOT)/src/objects/data-handler.h',
+          '<(V8_ROOT)/src/objects/data-handler-inl.h',
+          '<(V8_ROOT)/src/objects/descriptor-array.h',
+          '<(V8_ROOT)/src/objects/descriptor-array-inl.h',
+          '<(V8_ROOT)/src/objects/feedback-cell.h',
+          '<(V8_ROOT)/src/objects/feedback-cell-inl.h',
+          '<(V8_ROOT)/src/objects/fixed-array-inl.h',
+          '<(V8_ROOT)/src/objects/fixed-array.h',
+          '<(V8_ROOT)/src/objects/heap-number-inl.h',
+          '<(V8_ROOT)/src/objects/heap-number.h',
+          '<(V8_ROOT)/src/objects/heap-object-inl.h',
+          '<(V8_ROOT)/src/objects/heap-object.h',
+          '<(V8_ROOT)/src/objects/instance-type.h',
+          '<(V8_ROOT)/src/objects/js-array-inl.h',
+          '<(V8_ROOT)/src/objects/js-array.h',
+          '<(V8_ROOT)/src/objects/js-aggregate-error-inl.h',
+          '<(V8_ROOT)/src/objects/js-aggregate-error.h',
+          '<(V8_ROOT)/src/objects/js-array-buffer-inl.h',
+          '<(V8_ROOT)/src/objects/js-array-buffer.h',
+          '<(V8_ROOT)/src/objects/js-objects-inl.h',
+          '<(V8_ROOT)/src/objects/js-objects.h',
+          '<(V8_ROOT)/src/objects/js-promise-inl.h',
+          '<(V8_ROOT)/src/objects/js-promise.h',
+          '<(V8_ROOT)/src/objects/js-regexp-inl.h',
+          '<(V8_ROOT)/src/objects/js-regexp.cc',
+          '<(V8_ROOT)/src/objects/js-regexp.h',
+          '<(V8_ROOT)/src/objects/js-regexp-string-iterator-inl.h',
+          '<(V8_ROOT)/src/objects/js-regexp-string-iterator.h',
+          '<(V8_ROOT)/src/objects/map.h',
+          '<(V8_ROOT)/src/objects/map.cc',
+          '<(V8_ROOT)/src/objects/map-inl.h',
+          '<(V8_ROOT)/src/objects/js-objects.cc',
+          '<(V8_ROOT)/src/objects/name.h',
+          '<(V8_ROOT)/src/objects/name-inl.h',
+          '<(V8_ROOT)/src/objects/oddball-inl.h',
+          '<(V8_ROOT)/src/objects/oddball.h',
+          '<(V8_ROOT)/src/objects/primitive-heap-object.h',
+          '<(V8_ROOT)/src/objects/primitive-heap-object-inl.h',
+          '<(V8_ROOT)/src/objects/scope-info.h',
+          '<(V8_ROOT)/src/objects/script.h',
+          '<(V8_ROOT)/src/objects/script-inl.h',
+          '<(V8_ROOT)/src/objects/shared-function-info.h',
+          '<(V8_ROOT)/src/objects/shared-function-info-inl.h',
+          '<(V8_ROOT)/src/objects/string.cc',
+          '<(V8_ROOT)/src/objects/string.h',
+          '<(V8_ROOT)/src/objects/string-comparator.cc',
+          '<(V8_ROOT)/src/objects/string-comparator.h',
+          '<(V8_ROOT)/src/objects/string-inl.h',
+          '<(V8_ROOT)/src/objects/struct.h',
+          '<(V8_ROOT)/src/objects/struct-inl.h',
+          '<(torque_output_root)/torque-generated/instance-types-tq.h',
         ],
       },
       'actions': [
@@ -1550,5 +1661,70 @@
         'sources': ['<(SHARED_INTERMEDIATE_DIR)/debug-support.cc', ],
       },
     },  # postmortem-metadata
+
+    {
+      'target_name': 'v8_zlib',
+      'type': 'static_library',
+      'conditions': [
+        ['want_separate_host_toolset', {
+          'toolsets': ['host', 'target'],
+        }],
+        ['OS=="win"', {
+          'conditions': [
+            ['"<(target_arch)"=="arm64" and _toolset=="target"', {
+              'defines': ['CPU_NO_SIMD']
+            }, {
+              'defines': ['X86_WINDOWS']
+            }]
+          ]
+        }],
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [
+          '<(V8_ROOT)/third_party/zlib',
+          '<(V8_ROOT)/third_party/zlib/google',
+        ],
+      },
+      'defines': [ 'ZLIB_IMPLEMENTATION' ],
+      'include_dirs': [
+        '<(V8_ROOT)/third_party/zlib',
+        '<(V8_ROOT)/third_party/zlib/google',
+      ],
+      'sources': [
+        '<(V8_ROOT)/third_party/zlib/adler32.c',
+        '<(V8_ROOT)/third_party/zlib/chromeconf.h',
+        '<(V8_ROOT)/third_party/zlib/compress.c',
+        '<(V8_ROOT)/third_party/zlib/contrib/optimizations/insert_string.h',
+        '<(V8_ROOT)/third_party/zlib/contrib/optimizations/insert_string.h',
+        '<(V8_ROOT)/third_party/zlib/cpu_features.c',
+        '<(V8_ROOT)/third_party/zlib/cpu_features.h',
+        '<(V8_ROOT)/third_party/zlib/crc32.c',
+        '<(V8_ROOT)/third_party/zlib/crc32.h',
+        '<(V8_ROOT)/third_party/zlib/deflate.c',
+        '<(V8_ROOT)/third_party/zlib/deflate.h',
+        '<(V8_ROOT)/third_party/zlib/gzclose.c',
+        '<(V8_ROOT)/third_party/zlib/gzguts.h',
+        '<(V8_ROOT)/third_party/zlib/gzlib.c',
+        '<(V8_ROOT)/third_party/zlib/gzread.c',
+        '<(V8_ROOT)/third_party/zlib/gzwrite.c',
+        '<(V8_ROOT)/third_party/zlib/infback.c',
+        '<(V8_ROOT)/third_party/zlib/inffast.c',
+        '<(V8_ROOT)/third_party/zlib/inffast.h',
+        '<(V8_ROOT)/third_party/zlib/inffixed.h',
+        '<(V8_ROOT)/third_party/zlib/inflate.c',
+        '<(V8_ROOT)/third_party/zlib/inflate.h',
+        '<(V8_ROOT)/third_party/zlib/inftrees.c',
+        '<(V8_ROOT)/third_party/zlib/inftrees.h',
+        '<(V8_ROOT)/third_party/zlib/trees.c',
+        '<(V8_ROOT)/third_party/zlib/trees.h',
+        '<(V8_ROOT)/third_party/zlib/uncompr.c',
+        '<(V8_ROOT)/third_party/zlib/zconf.h',
+        '<(V8_ROOT)/third_party/zlib/zlib.h',
+        '<(V8_ROOT)/third_party/zlib/zutil.c',
+        '<(V8_ROOT)/third_party/zlib/zutil.h',
+        '<(V8_ROOT)/third_party/zlib/google/compression_utils_portable.cc',
+        '<(V8_ROOT)/third_party/zlib/google/compression_utils_portable.h',
+      ],
+    },  # v8_zlib
   ],
 }
diff --git a/vcbuild.bat b/vcbuild.bat
index 86788bd8608ae50bfc70861d857ff1d60f730a03..b5c5a53dd7298d531060a02627a03453d27fb0dc 100644
--- a/vcbuild.bat
+++ b/vcbuild.bat
@@ -99,6 +99,7 @@ if /i "%1"=="build-addons"   set build_addons=1&goto arg-ok
 if /i "%1"=="build-js-native-api-tests"   set build_js_native_api_tests=1&goto arg-ok
 if /i "%1"=="build-node-api-tests"   set build_node_api_tests=1&goto arg-ok
 if /i "%1"=="test-addons"   set test_args=%test_args% addons&set build_addons=1&goto arg-ok
+if /i "%1"=="test-doc"      set test_args=%test_args% %CI_DOC%&set doc=1&&set lint_js=1&set lint_md=1&goto arg-ok
 if /i "%1"=="test-js-native-api"   set test_args=%test_args% js-native-api&set build_js_native_api_tests=1&goto arg-ok
 if /i "%1"=="test-node-api"   set test_args=%test_args% node-api&set build_node_api_tests=1&goto arg-ok
 if /i "%1"=="test-benchmark" set test_args=%test_args% benchmark&goto arg-ok
@@ -125,7 +126,7 @@ if /i "%1"=="lint-md-build" set lint_md_build=1&goto arg-ok
 if /i "%1"=="lint"          set lint_cpp=1&set lint_js=1&set lint_md=1&goto arg-ok
 if /i "%1"=="lint-ci"       set lint_cpp=1&set lint_js_ci=1&goto arg-ok
 if /i "%1"=="package"       set package=1&goto arg-ok
-if /i "%1"=="msi"           set msi=1&set licensertf=1&set download_arg="--download=all"&set i18n_arg=small-icu&goto arg-ok
+if /i "%1"=="msi"           set msi=1&set licensertf=1&set download_arg="--download=all"&set i18n_arg=full-icu&goto arg-ok
 if /i "%1"=="build-release" set build_release=1&set sign=1&goto arg-ok
 if /i "%1"=="upload"        set upload=1&goto arg-ok
 if /i "%1"=="small-icu"     set i18n_arg=%1&goto arg-ok
@@ -162,7 +163,7 @@ if defined build_release (
   set msi=1
   set licensertf=1
   set download_arg="--download=all"
-  set i18n_arg=small-icu
+  set i18n_arg=full-icu
   set projgen=1
   set cctest=1
   set ltcg=1
@@ -197,6 +198,7 @@ if defined target_arch      set configure_flags=%configure_flags% --dest-cpu=%ta
 if defined openssl_no_asm   set configure_flags=%configure_flags% --openssl-no-asm
 if defined DEBUG_HELPER     set configure_flags=%configure_flags% --verbose
 if "%target_arch%"=="x86" if "%PROCESSOR_ARCHITECTURE%"=="AMD64" set configure_flags=%configure_flags% --no-cross-compiling
+if "%target_arch%"=="arm64" set configure_flags=%configure_flags% --cross-compiling
 
 if not exist "%~dp0deps\icu" goto no-depsicu
 if "%target%"=="Clean" echo deleting %~dp0deps\icu
@@ -239,26 +241,31 @@ if %target_arch%==x64 if %msvs_host_arch%==amd64 set vcvarsall_arg=amd64
 @rem also if both are x86
 if %target_arch%==x86 if %msvs_host_arch%==x86 set vcvarsall_arg=x86
 
-@rem Look for Visual Studio 2017
-:vs-set-2017
-if defined target_env if "%target_env%" NEQ "vs2017" goto vs-set-2019
-echo Looking for Visual Studio 2017
-call tools\msvs\vswhere_usability_wrapper.cmd "[15.0,16.0)"
-if "_%VCINSTALLDIR%_" == "__" goto msbuild-not-found
+@rem Look for Visual Studio 2019
+:vs-set-2019
+if defined target_env if "%target_env%" NEQ "vs2019" goto vs-set-2017
+echo Looking for Visual Studio 2019
+@rem VCINSTALLDIR may be set if run from a VS Command Prompt and needs to be
+@rem cleared first as vswhere_usability_wrapper.cmd doesn't when it fails to
+@rem detect the version searched for
+if not defined target_env set "VCINSTALLDIR="
+call tools\msvs\vswhere_usability_wrapper.cmd "[16.0,17.0)" "prerelease"
+if "_%VCINSTALLDIR%_" == "__" goto vs-set-2017
+set "WIXSDKDIR=%WIX%\SDK\VS2017"
 if defined msi (
-  echo Looking for WiX installation for Visual Studio 2017...
-  if not exist "%WIX%\SDK\VS2017" (
-    echo Failed to find WiX install for Visual Studio 2017
-    echo VS2017 support for WiX is only present starting at version 3.11
-    goto msbuild-not-found
+  echo Looking for WiX installation for Visual Studio 2019...
+  if not exist "%WIXSDKDIR%" (
+    echo Failed to find WiX install for Visual Studio 2019
+    echo VS2019 support for WiX is only present starting at version 3.11
+    goto vs-set-2017
   )
   if not exist "%VCINSTALLDIR%\..\MSBuild\Microsoft\WiX" (
-    echo Failed to find the WiX Toolset Visual Studio 2017 Extension
-    goto msbuild-not-found
+    echo Failed to find the WiX Toolset Visual Studio 2019 Extension
+    goto vs-set-2017
   )
 )
-@rem check if VS2017 is already setup, and for the requested arch
-if "_%VisualStudioVersion%_" == "_15.0_" if "_%VSCMD_ARG_TGT_ARCH%_"=="_%target_arch%_" goto found_vs2017
+@rem check if VS2019 is already setup, and for the requested arch
+if "_%VisualStudioVersion%_" == "_16.0_" if "_%VSCMD_ARG_TGT_ARCH%_"=="_%target_arch%_" goto found_vs2019
 @rem need to clear VSINSTALLDIR for vcvarsall to work as expected
 set "VSINSTALLDIR="
 @rem prevent VsDevCmd.bat from changing the current working directory
@@ -266,34 +273,35 @@ set "VSCMD_START_DIR=%CD%"
 set vcvars_call="%VCINSTALLDIR%\Auxiliary\Build\vcvarsall.bat" %vcvarsall_arg%
 echo calling: %vcvars_call%
 call %vcvars_call%
-if errorlevel 1 goto msbuild-not-found
+if errorlevel 1 goto vs-set-2017
 if defined DEBUG_HELPER @ECHO ON
-:found_vs2017
+:found_vs2019
 echo Found MSVS version %VisualStudioVersion%
-set GYP_MSVS_VERSION=2017
-set PLATFORM_TOOLSET=v141
+set GYP_MSVS_VERSION=2019
+set PLATFORM_TOOLSET=v142
 goto msbuild-found
 
-@rem Look for Visual Studio 2019
-:vs-set-2019
-if defined target_env if "%target_env%" NEQ "vs2019" goto msbuild-not-found
-echo Looking for Visual Studio 2019
-call tools\msvs\vswhere_usability_wrapper.cmd "[16.0,17.0)"
+@rem Look for Visual Studio 2017
+:vs-set-2017
+if defined target_env if "%target_env%" NEQ "vs2017" goto msbuild-not-found
+echo Looking for Visual Studio 2017
+call tools\msvs\vswhere_usability_wrapper.cmd "[15.0,16.0)"
 if "_%VCINSTALLDIR%_" == "__" goto msbuild-not-found
+set "WIXSDKDIR=%WIX%\SDK\VS2017"
 if defined msi (
-  echo Looking for WiX installation for Visual Studio 2019...
-  if not exist "%WIX%\SDK\VS2017" (
-    echo Failed to find WiX install for Visual Studio 2019
-    echo VS2019 support for WiX is only present starting at version 3.11
+  echo Looking for WiX installation for Visual Studio 2017...
+  if not exist "%WIXSDKDIR%" (
+    echo Failed to find WiX install for Visual Studio 2017
+    echo VS2017 support for WiX is only present starting at version 3.11
     goto msbuild-not-found
   )
   if not exist "%VCINSTALLDIR%\..\MSBuild\Microsoft\WiX" (
-    echo Failed to find the WiX Toolset Visual Studio 2019 Extension
+    echo Failed to find the WiX Toolset Visual Studio 2017 Extension
     goto msbuild-not-found
   )
 )
-@rem check if VS2019 is already setup, and for the requested arch
-if "_%VisualStudioVersion%_" == "_16.0_" if "_%VSCMD_ARG_TGT_ARCH%_"=="_%target_arch%_" goto found_vs2019
+@rem check if VS2017 is already setup, and for the requested arch
+if "_%VisualStudioVersion%_" == "_15.0_" if "_%VSCMD_ARG_TGT_ARCH%_"=="_%target_arch%_" goto found_vs2017
 @rem need to clear VSINSTALLDIR for vcvarsall to work as expected
 set "VSINSTALLDIR="
 @rem prevent VsDevCmd.bat from changing the current working directory
@@ -303,16 +311,16 @@ echo calling: %vcvars_call%
 call %vcvars_call%
 if errorlevel 1 goto msbuild-not-found
 if defined DEBUG_HELPER @ECHO ON
-:found_vs2019
+:found_vs2017
 echo Found MSVS version %VisualStudioVersion%
-set GYP_MSVS_VERSION=2019
-set PLATFORM_TOOLSET=v142
+set GYP_MSVS_VERSION=2017
+set PLATFORM_TOOLSET=v141
 goto msbuild-found
 
 :msbuild-not-found
 echo Failed to find a suitable Visual Studio installation.
 echo Try to run in a "Developer Command Prompt" or consult
-echo https://github.com/nodejs/node/blob/master/BUILDING.md#windows
+echo https://github.com/nodejs/node/blob/HEAD/BUILDING.md#windows
 goto exit
 
 :msbuild-found
@@ -325,7 +333,7 @@ if defined projgen goto run-configure
 if not exist node.sln goto run-configure
 if not exist .gyp_configure_stamp goto run-configure
 echo %configure_flags% > .tmp_gyp_configure_stamp
-where /R . /T *.gyp? >> .tmp_gyp_configure_stamp
+where /R . /T *.gyp* >> .tmp_gyp_configure_stamp
 fc .gyp_configure_stamp .tmp_gyp_configure_stamp >NUL 2>&1
 if errorlevel 1 goto run-configure
 
@@ -346,7 +354,7 @@ if not exist node.sln goto create-msvs-files-failed
 set project_generated=1
 echo Project files generated.
 echo %configure_flags% > .gyp_configure_stamp
-where /R . /T *.gyp? >> .gyp_configure_stamp
+where /R . /T *.gyp* >> .gyp_configure_stamp
 
 :msbuild
 @rem Skip build if requested.
@@ -365,6 +373,10 @@ if "%target%"=="Build" (
 )
 if "%target%"=="node" if exist "%config%\cctest.exe" del "%config%\cctest.exe"
 if defined msbuild_args set "extra_msbuild_args=%extra_msbuild_args% %msbuild_args%"
+@rem Setup env variables to use multiprocessor build
+set UseMultiToolTask=True
+set EnforceProcessCountAcrossBuilds=True
+set MultiProcMaxCount=%NUMBER_OF_PROCESSORS%
 msbuild node.sln %msbcpu% /t:%target% /p:Configuration=%config% /p:Platform=%msbplatform% /clp:NoItemAndPropertyList;Verbosity=minimal /nologo %extra_msbuild_args%
 if errorlevel 1 (
   if not defined project_generated echo Building Node with reused solution failed. To regenerate project files use "vcbuild projgen"
@@ -390,7 +402,26 @@ if errorlevel 1 echo Failed to sign exe&goto exit
 @rem Skip license.rtf generation if not requested.
 if not defined licensertf goto stage_package
 
-%node_exe% tools\license2rtf.js < LICENSE > %config%\license.rtf
+set "use_x64_node_exe=false"
+if "%target_arch%"=="arm64" if "%PROCESSOR_ARCHITECTURE%"=="AMD64" set "use_x64_node_exe=true"
+if "%use_x64_node_exe%"=="true" (
+  echo Cross-compilation to ARM64 detected. We'll use the x64 Node executable for license2rtf.
+  if not defined "%x64_node_exe%" set "x64_node_exe=temp-vcbuild\node-x64-cross-compiling.exe"
+  if not exist "%x64_node_exe%" (
+    echo Downloading x64 node.exe...
+    if not exist "temp-vcbuild" mkdir temp-vcbuild
+    powershell -c "Invoke-WebRequest -Uri 'https://nodejs.org/dist/latest/win-x64/node.exe' -OutFile 'temp-vcbuild\node-x64-cross-compiling.exe'"
+  )
+  if not exist "%x64_node_exe%" (
+    echo Could not find the Node executable at the given x64_node_exe path. Aborting.
+    set exit_code=1
+    goto exit
+  )
+  %x64_node_exe% tools\license2rtf.js < LICENSE > %config%\license.rtf
+) else (
+  %node_exe% tools\license2rtf.js < LICENSE > %config%\license.rtf
+)
+
 if errorlevel 1 echo Failed to generate license.rtf&goto exit
 
 :stage_package
@@ -467,7 +498,7 @@ if not defined msi goto install-doctools
 echo Building node-v%FULLVERSION%-%target_arch%.msi
 set "msbsdk="
 if defined WindowsSDKVersion set "msbsdk=/p:WindowsTargetPlatformVersion=%WindowsSDKVersion:~0,-1%"
-msbuild "%~dp0tools\msvs\msi\nodemsi.sln" /m /t:Clean,Build %msbsdk% /p:PlatformToolset=%PLATFORM_TOOLSET% /p:GypMsvsVersion=%GYP_MSVS_VERSION% /p:Configuration=%config% /p:Platform=%target_arch% /p:NodeVersion=%NODE_VERSION% /p:FullVersion=%FULLVERSION% /p:DistTypeDir=%DISTTYPEDIR% %noetw_msi_arg% /clp:NoSummary;NoItemAndPropertyList;Verbosity=minimal /nologo
+msbuild "%~dp0tools\msvs\msi\nodemsi.sln" /m /t:Clean,Build %msbsdk% /p:PlatformToolset=%PLATFORM_TOOLSET% /p:WixSdkDir="%WIXSDKDIR%" /p:Configuration=%config% /p:Platform=%target_arch% /p:NodeVersion=%NODE_VERSION% /p:FullVersion=%FULLVERSION% /p:DistTypeDir=%DISTTYPEDIR% %noetw_msi_arg% /clp:NoSummary;NoItemAndPropertyList;Verbosity=minimal /nologo
 if errorlevel 1 goto exit
 
 if not defined sign goto upload
@@ -533,7 +564,7 @@ robocopy /e doc\api %config%\doc\api
 robocopy /e doc\api_assets %config%\doc\api\assets
 
 for %%F in (%config%\doc\api\*.md) do (
-  %node_exe% tools\doc\generate.js --node-version=v%FULLVERSION% %%F --output-directory=%%~dF%%~pF
+  %node_exe% tools\doc\generate.mjs --node-version=v%FULLVERSION% %%F --output-directory=%%~dF%%~pF
 )
 
 :run
@@ -550,7 +581,7 @@ for /d %%F in (test\addons\??_*) do (
   rd /s /q %%F
 )
 :: generate
-"%node_exe%" tools\doc\addon-verify.js
+"%node_exe%" tools\doc\addon-verify.mjs
 if %errorlevel% neq 0 exit /b %errorlevel%
 :: building addons
 setlocal
@@ -658,7 +689,7 @@ goto lint-js
 if not defined lint_js goto lint-md-build
 if not exist tools\node_modules\eslint goto no-lint
 echo running lint-js
-%node_exe% tools\node_modules\eslint\bin\eslint.js --cache --report-unused-disable-directives --rule "linebreak-style: 0" --ext=.js,.mjs,.md .eslintrc.js benchmark doc lib test tools
+%node_exe% tools\node_modules\eslint\bin\eslint.js --cache --report-unused-disable-directives --rule "linebreak-style: 0" .eslintrc.js benchmark doc lib test tools
 goto lint-md-build
 
 :no-lint
@@ -681,21 +712,18 @@ for /D %%D IN (doc\*) do (
     set "lint_md_files="%%F" !lint_md_files!"
   )
 )
-%node_exe% tools\lint-md.js -q -f %lint_md_files%
+%node_exe% tools\lint-md.mjs -q -f %lint_md_files%
 ENDLOCAL
 goto exit
 
 :create-msvs-files-failed
 echo Failed to create vc project files.
-if %VCBUILD_PYTHON_VERSION%==3 (
-  echo Python 3 is not yet fully supported, to avoid issues Python 2 should be installed.
-)
 del .used_configure_flags
 set exit_code=1
 goto exit
 
 :help
-echo vcbuild.bat [debug/release] [msi] [doc] [test/test-all/test-addons/test-js-native-api/test-node-api/test-benchmark/test-internet/test-pummel/test-simple/test-message/test-tick-processor/test-known-issues/test-node-inspect/test-check-deopts/test-npm/test-async-hooks/test-v8/test-v8-intl/test-v8-benchmarks/test-v8-all] [ignore-flaky] [static/dll] [noprojgen] [projgen] [small-icu/full-icu/without-intl] [nobuild] [nosnapshot] [noetw] [ltcg] [licensetf] [sign] [ia32/x86/x64/arm64] [vs2017/vs2019] [download-all] [lint/lint-ci/lint-js/lint-md] [lint-md-build] [package] [build-release] [upload] [no-NODE-OPTIONS] [link-module path-to-module] [debug-http2] [debug-nghttp2] [clean] [cctest] [no-cctest] [openssl-no-asm]
+echo vcbuild.bat [debug/release] [msi] [doc] [test/test-all/test-addons/test-doc/test-js-native-api/test-node-api/test-benchmark/test-internet/test-pummel/test-simple/test-message/test-tick-processor/test-known-issues/test-node-inspect/test-check-deopts/test-npm/test-async-hooks/test-v8/test-v8-intl/test-v8-benchmarks/test-v8-all] [ignore-flaky] [static/dll] [noprojgen] [projgen] [small-icu/full-icu/without-intl] [nobuild] [nosnapshot] [noetw] [ltcg] [licensetf] [sign] [ia32/x86/x64/arm64] [vs2017/vs2019] [download-all] [lint/lint-ci/lint-js/lint-md] [lint-md-build] [package] [build-release] [upload] [no-NODE-OPTIONS] [link-module path-to-module] [debug-http2] [debug-nghttp2] [clean] [cctest] [no-cctest] [openssl-no-asm]
 echo Examples:
 echo   vcbuild.bat                          : builds release build
 echo   vcbuild.bat debug                    : builds debug build